Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Licensed to the Apache Software Foundation (ASF) under one or more
   * contributor license agreements.  See the NOTICE file distributed with
   * this work for additional information regarding copyright ownership.
   * The ASF licenses this file to You under the Apache License, Version 2.0
   * (the "License"); you may not use this file except in compliance with
   * the License.  You may obtain a copy of the License at
   *
   *     http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 
 package org.apache.mahout.math;
 
A delegating vector provides an easy way to decorate vectors with weights or id's and such while keeping all of the Vector functionality. This vector implements LengthCachingVector because almost all delegates cache the length and the cost of false positives is very low.
 
 public class DelegatingVector implements VectorLengthCachingVector {
   protected Vector delegate;
 
   public DelegatingVector(Vector v) {
      = v;
   }
 
   protected DelegatingVector() {
   }
 
   public Vector getVector() {
     return ;
   }
 
   @Override
   public double aggregate(DoubleDoubleFunction aggregatorDoubleFunction map) {
     return .aggregate(aggregatormap);
   }
 
   @Override
   public double aggregate(Vector otherDoubleDoubleFunction aggregatorDoubleDoubleFunction combiner) {
     return .aggregate(otheraggregatorcombiner);
   }
 
   @Override
   public Vector viewPart(int offsetint length) {
     return .viewPart(offsetlength);
   }
 
   @SuppressWarnings("CloneDoesntDeclareCloneNotSupportedException")
   @Override
   public Vector clone() {
     DelegatingVector r;
     try {
       r = (DelegatingVectorsuper.clone();
     } catch (CloneNotSupportedException e) {
       throw new RuntimeException("Clone not supported for DelegatingVector, shouldn't be possible");
     }
     // delegate points to original without this
     r.delegate = .clone();
     return r;
   }
 
   @Override
   public Iterable<Elementall() {
     return .all();
   }
 
   @Override
   public Iterable<ElementnonZeroes() {
     return .nonZeroes();
   }
 
   @Override
   public Vector divide(double x) {
     return .divide(x);
   }
 
   @Override
   public double dot(Vector x) {
     return .dot(x);
   }
 
   @Override
   public double get(int index) {
     return .get(index);
   }
 
   @Override
   public Element getElement(int index) {
    return .getElement(index);
  }

  
Merge a set of (index, value) pairs into the vector.

Parameters:
updates an ordered mapping of indices to values to be merged in.
  public void mergeUpdates(OrderedIntDoubleMapping updates) {
    .mergeUpdates(updates);
  }
  public Vector minus(Vector that) {
    return .minus(that);
  }
  public Vector normalize() {
    return .normalize();
  }
  public Vector normalize(double power) {
    return .normalize(power);
  }
  public Vector logNormalize() {
    return .logNormalize();
  }
  public Vector logNormalize(double power) {
    return .logNormalize(power);
  }
  public double norm(double power) {
    return .norm(power);
  }
  public double getLengthSquared() {
    return .getLengthSquared();
  }
  public void invalidateCachedLength() {
    if ( instanceof LengthCachingVector) {
    }
  }
  public double getDistanceSquared(Vector v) {
    return .getDistanceSquared(v);
  }
  public double getLookupCost() {
    return .getLookupCost();
  }
  public double getIteratorAdvanceCost() {
  }
  public boolean isAddConstantTime() {
    return .isAddConstantTime();
  }
  public double maxValue() {
    return .maxValue();
  }
  public int maxValueIndex() {
    return .maxValueIndex();
  }
  public double minValue() {
    return .minValue();
  }
  public int minValueIndex() {
    return .minValueIndex();
  }
  public Vector plus(double x) {
    return .plus(x);
  }
  public Vector plus(Vector x) {
    return .plus(x);
  }
  public void set(int indexdouble value) {
    .set(indexvalue);
  }
  public Vector times(double x) {
    return .times(x);
  }
  public Vector times(Vector x) {
    return .times(x);
  }
  public double zSum() {
    return .zSum();
  }
  public Vector assign(double value) {
    .assign(value);
    return this;
  }
  public Vector assign(double[] values) {
    .assign(values);
    return this;
  }
  public Vector assign(Vector other) {
    .assign(other);
    return this;
  }
  public Vector assign(DoubleDoubleFunction fdouble y) {
    .assign(fy);
    return this;
  }
  public Vector assign(DoubleFunction function) {
    .assign(function);
    return this;
  }
  public Vector assign(Vector otherDoubleDoubleFunction function) {
    .assign(otherfunction);
    return this;
  }
  public Matrix cross(Vector other) {
    return .cross(other);
  }
  public int size() {
    return .size();
  }
  public String asFormatString() {
    return .asFormatString();
  }
  public int hashCode() {
    return .hashCode();
  }
  @SuppressWarnings("EqualsWhichDoesntCheckParameterClass")
  public boolean equals(Object o) {
    return .equals(o);
  }
  public String toString() {
    return .toString();
  }
  public boolean isDense() {
    return .isDense();
  }
  public boolean isSequentialAccess() {
    return .isSequentialAccess();
  }
  public double getQuick(int index) {
    return .getQuick(index);
  }
  public Vector like() {
    return new DelegatingVector(.like());
  }
  public void setQuick(int indexdouble value) {
    .setQuick(indexvalue);
  }
  public void incrementQuick(int indexdouble increment) {
    .incrementQuick(indexincrement);
  }
  public int getNumNondefaultElements() {
  }
  public int getNumNonZeroElements() {
  }
New to GrepCode? Check out our FAQ X