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;
 
 
Implementations of generic capabilities like sum of elements and dot products
 
 public abstract class AbstractVector implements VectorLengthCachingVector {
 
   private int size;
   protected double lengthSquared = -1.0;
 
   protected AbstractVector(int size) {
     this. = size;
   }
 
   @Override
   public Iterable<Elementall() {
     return new Iterable<Element>() {
       @Override
       public Iterator<Elementiterator() {
         return AbstractVector.this.iterator();
       }
     };
   }
 
   @Override
   public Iterable<ElementnonZeroes() {
     return new Iterable<Element>() {
       @Override
       public Iterator<Elementiterator() {
         return iterateNonZero();
       }
     };
   }

  
Iterates over all elements

* NOTE: Implementations may choose to reuse the Element returned for performance reasons, so if you need a copy of it, you should call getElement(int) for the given index

Returns:
An java.util.Iterator over all elements
 
   protected abstract Iterator<Elementiterator();

  
Iterates over all non-zero elements.

NOTE: Implementations may choose to reuse the Element returned for performance reasons, so if you need a copy of it, you should call getElement(int) for the given index

Returns:
An java.util.Iterator over all non-zero elements
 
   protected abstract Iterator<ElementiterateNonZero();
  
Aggregates a vector by applying a mapping function fm(x) to every component and aggregating the results with an aggregating function fa(x, y).

Parameters:
aggregator used to combine the current value of the aggregation with the result of map.apply(nextValue)
map a function to apply to each element of the vector in turn before passing to the aggregator
Returns:
the result of the aggregation
 
   @Override
   public double aggregate(DoubleDoubleFunction aggregatorDoubleFunction map) {
     if ( == 0) {
       return 0;
     }
 
     // If the aggregator is associative and commutative and it's likeLeftMult (fa(0, y) = 0), and there is
     // at least one zero in the vector (size > getNumNondefaultElements) and applying fm(0) = 0, the result
     // gets cascaded through the aggregation and the final result will be 0.
     if (aggregator.isAssociativeAndCommutative() && aggregator.isLikeLeftMult()
         &&  > getNumNondefaultElements() && !map.isDensifying()) {
       return 0;
     }
 
     double result;
     if (isSequentialAccess() || aggregator.isAssociativeAndCommutative()) {
       Iterator<Elementiterator;
       // If fm(0) = 0 and fa(x, 0) = x, we can skip all zero values.
       if (!map.isDensifying() && aggregator.isLikeRightPlus()) {
        iterator = iterateNonZero();
        if (!iterator.hasNext()) {
          return 0;
        }
      } else {
        iterator = iterator();
      }
      Element element = iterator.next();
      result = map.apply(element.get());
      while (iterator.hasNext()) {
        element = iterator.next();
        result = aggregator.apply(resultmap.apply(element.get()));
      }
    } else {
      result = map.apply(getQuick(0));
      for (int i = 1; i < i++) {
        result = aggregator.apply(resultmap.apply(getQuick(i)));
      }
    }
    return result;
  }
  public double aggregate(Vector otherDoubleDoubleFunction aggregatorDoubleDoubleFunction combiner) {
    Preconditions.checkArgument( == other.size(), "Vector sizes differ");
    if ( == 0) {
      return 0;
    }
    return VectorBinaryAggregate.aggregateBest(thisotheraggregatorcombiner);
  }

  
Subclasses must override to return an appropriately sparse or dense result

Parameters:
rows the row cardinality
columns the column cardinality
Returns:
a Matrix
  protected abstract Matrix matrixLike(int rowsint columns);
  public Vector viewPart(int offsetint length) {
    if (offset < 0) {
      throw new IndexException(offset);
    }
    if (offset + length > ) {
      throw new IndexException(offset + length);
    }
    return new VectorView(thisoffsetlength);
  }
  @SuppressWarnings("CloneDoesntDeclareCloneNotSupportedException")
  public Vector clone() {
    try {
      AbstractVector r = (AbstractVectorsuper.clone();
      r.size = ;
      r.lengthSquared = ;
      return r;
    } catch (CloneNotSupportedException e) {
      throw new IllegalStateException("Can't happen");
    }
  }
  public Vector divide(double x) {
    if (x == 1.0) {
      return clone();
    }
    Vector result = createOptimizedCopy();
    for (Element element : result.nonZeroes()) {
      element.set(element.get() / x);
    }
    return result;
  }
  public double dot(Vector x) {
    if ( != x.size()) {
      throw new CardinalityException(x.size());
    }
    if (this == x) {
      return getLengthSquared();
    }
    return aggregate(x..);
  }
  protected double dotSelf() {
    return aggregate(., Functions.pow(2));
  }
  public double get(int index) {
    if (index < 0 || index >= ) {
      throw new IndexException(index);
    }
    return getQuick(index);
  }
  public Element getElement(int index) {
    return new LocalElement(index);
  }
  public Vector normalize() {
    return divide(Math.sqrt(getLengthSquared()));
  }
  public Vector normalize(double power) {
    return divide(norm(power));
  }
  public Vector logNormalize() {
    return logNormalize(2.0, Math.sqrt(getLengthSquared()));
  }
  public Vector logNormalize(double power) {
    return logNormalize(powernorm(power));
  }
  public Vector logNormalize(double powerdouble normLength) {
    // we can special case certain powers
    if (Double.isInfinite(power) || power <= 1.0) {
      throw new IllegalArgumentException("Power must be > 1 and < infinity");
    } else {
      double denominator = normLength * Math.log(power);
      Vector result = createOptimizedCopy();
      for (Element element : result.nonZeroes()) {
        element.set(Math.log1p(element.get()) / denominator);
      }
      return result;
    }
  }
  public double norm(double power) {
    if (power < 0.0) {
      throw new IllegalArgumentException("Power must be >= 0");
    }
    // We can special case certain powers.
    if (Double.isInfinite(power)) {
      return aggregate(..);
    } else if (power == 2.0) {
      return Math.sqrt(getLengthSquared());
    } else if (power == 1.0) {
      double result = 0.0;
      Iterator<Elementiterator = this.iterateNonZero();
      while (iterator.hasNext()) {
        result += Math.abs(iterator.next().get());
      }
      return result;
      // TODO: this should ideally be used, but it's slower.
      // return aggregate(Functions.PLUS, Functions.ABS);
    } else if (power == 0.0) {
      return getNumNonZeroElements();
    } else {
      return Math.pow(aggregate(., Functions.pow(power)), 1.0 / power);
    }
  }
  public double getLengthSquared() {
    if ( >= 0.0) {
      return ;
    }
    return  = dotSelf();
  }
  public void invalidateCachedLength() {
     = -1;
  }
  public double getDistanceSquared(Vector that) {
    if ( != that.size()) {
      throw new CardinalityException(that.size());
    }
    double thisLength = getLengthSquared();
    double thatLength = that.getLengthSquared();
    double dot = dot(that);
    double distanceEstimate = thisLength + thatLength - 2 * dot;
    if (distanceEstimate > 1.0e-3 * (thisLength + thatLength)) {
      // The vectors are far enough from each other that the formula is accurate.
      return Math.max(distanceEstimate, 0);
    } else {
      return aggregate(that..);
    }
  }
  public double maxValue() {
    if ( == 0) {
      return .;
    }
  }
  public int maxValueIndex() {
    int result = -1;
    double max = .;
    int nonZeroElements = 0;
    Iterator<Elementiter = this.iterateNonZero();
    while (iter.hasNext()) {
      nonZeroElements++;
      Element element = iter.next();
      double tmp = element.get();
      if (tmp > max) {
        max = tmp;
        result = element.index();
      }
    }
    // if the maxElement is negative and the vector is sparse then any
    // unfilled element(0.0) could be the maxValue hence we need to
    // find one of those elements
    if (nonZeroElements <  && max < 0.0) {
      for (Element element : all()) {
        if (element.get() == 0.0) {
          return element.index();
        }
      }
    }
    return result;
  }
  public double minValue() {
    if ( == 0) {
      return .;
    }
  }
  public int minValueIndex() {
    int result = -1;
    double min = .;
    int nonZeroElements = 0;
    Iterator<Elementiter = this.iterateNonZero();
    while (iter.hasNext()) {
      nonZeroElements++;
      Element element = iter.next();
      double tmp = element.get();
      if (tmp < min) {
        min = tmp;
        result = element.index();
      }
    }
    // if the maxElement is positive and the vector is sparse then any
    // unfilled element(0.0) could be the maxValue hence we need to
    // find one of those elements
    if (nonZeroElements <  && min > 0.0) {
      for (Element element : all()) {
        if (element.get() == 0.0) {
          return element.index();
        }
      }
    }
    return result;
  }
  public Vector plus(double x) {
    Vector result = createOptimizedCopy();
    if (x == 0.0) {
      return result;
    }
    return result.assign(Functions.plus(x));
  }
  public Vector plus(Vector that) {
    if ( != that.size()) {
      throw new CardinalityException(that.size());
    }
    return createOptimizedCopy().assign(that.);
  }
  public Vector minus(Vector that) {
    if ( != that.size()) {
      throw new CardinalityException(that.size());
    }
    return createOptimizedCopy().assign(that.);
  }
  public void set(int indexdouble value) {
    if (index < 0 || index >= ) {
      throw new IndexException(index);
    }
    setQuick(indexvalue);
  }
  public void incrementQuick(int indexdouble increment) {
    setQuick(indexgetQuick(index) + increment);
  }
  public Vector times(double x) {
    if (x == 0.0) {
      return like();
    }
    return createOptimizedCopy().assign(Functions.mult(x));
  }

  
Copy the current vector in the most optimum fashion. Used by immutable methods like plus(), minus(). Use this instead of vector.like().assign(vector). Sub-class can choose to override this method.

Returns:
a copy of the current vector.
  protected Vector createOptimizedCopy() {
    return createOptimizedCopy(this);
  }
  private static Vector createOptimizedCopy(Vector vector) {
    Vector result;
    if (vector.isDense()) {
      result = vector.like().assign(vector.);
    } else {
      result = vector.clone();
    }
    return result;
  }
  public Vector times(Vector that) {
    if ( != that.size()) {
      throw new CardinalityException(that.size());
    }
    if (this.getNumNondefaultElements() <= that.getNumNondefaultElements()) {
      return createOptimizedCopy(this).assign(that.);
    } else {
      return createOptimizedCopy(that).assign(this.);
    }
  }
  public double zSum() {
  }
  public int getNumNonZeroElements() {
    int count = 0;
    Iterator<Elementit = iterateNonZero();
    while (it.hasNext()) {
      if (it.next().get() != 0.0) {
        count++;
      }
    }
    return count;
  }
  public Vector assign(double value) {
    Iterator<Elementit;
    if (value == 0.0) {
      // Make all the non-zero values 0.
      it = iterateNonZero();
      while (it.hasNext()) {
        it.next().set(value);
      }
    } else {
      if (isSequentialAccess() && !isAddConstantTime()) {
        // Update all the non-zero values and queue the updates for the zero vaues.
        // The vector will become dense.
        it = iterator();
        OrderedIntDoubleMapping updates = new OrderedIntDoubleMapping();
        while (it.hasNext()) {
          Element element = it.next();
          if (element.get() == 0.0) {
            updates.set(element.index(), value);
          } else {
            element.set(value);
          }
        }
        mergeUpdates(updates);
      } else {
        for (int i = 0; i < ; ++i) {
          setQuick(ivalue);
        }
      }
    }
    return this;
  }
  public Vector assign(double[] values) {
    if ( != values.length) {
      throw new CardinalityException(values.length);
    }
    if (isSequentialAccess() && !isAddConstantTime()) {
      OrderedIntDoubleMapping updates = new OrderedIntDoubleMapping();
      Iterator<Elementit = iterator();
      while (it.hasNext()) {
        Element element = it.next();
        int index = element.index();
        if (element.get() == 0.0) {
          updates.set(indexvalues[index]);
        } else {
          element.set(values[index]);
        }
      }
      mergeUpdates(updates);
    } else {
      for (int i = 0; i < ; ++i) {
        setQuick(ivalues[i]);
      }
    }
    return this;
  }
  public Vector assign(Vector other) {
    return assign(other.);
  }
  public Vector assign(DoubleDoubleFunction fdouble y) {
    Iterator<Elementiterator = f.apply(0, y) == 0 ? iterateNonZero() : iterator();
    while (iterator.hasNext()) {
      Element element = iterator.next();
      element.set(f.apply(element.get(), y));
    }
    return this;
  }
  public Vector assign(DoubleFunction f) {
    Iterator<Elementiterator = !f.isDensifying() ? iterateNonZero() : iterator();
    while (iterator.hasNext()) {
      Element element = iterator.next();
      element.set(f.apply(element.get()));
    }
    return this;
  }
  public Vector assign(Vector otherDoubleDoubleFunction function) {
    if ( != other.size()) {
      throw new CardinalityException(other.size());
    }
    VectorBinaryAssign.assignBest(thisotherfunction);
    return this;
  }
  public Matrix cross(Vector other) {
    Matrix result = matrixLike(other.size());
    while (it.hasNext()) {
      Vector.Element e = it.next();
      int row = e.index();
      result.assignRow(rowother.times(getQuick(row)));
    }
    return result;
  }
  public final int size() {
    return ;
  }
  public String asFormatString() {
    return toString();
  }
  public int hashCode() {
    int result = ;
    Iterator<Elementiter = iterateNonZero();
    while (iter.hasNext()) {
      Element ele = iter.next();
      result += ele.index() * RandomUtils.hashDouble(ele.get());
    }
    return result;
  }

  
Determines whether this Vector represents the same logical vector as another object. Two Vectors are equal (regardless of implementation) if the value at each index is the same, and the cardinalities are the same.
  public boolean equals(Object o) {
    if (this == o) {
      return true;
    }
    if (!(o instanceof Vector)) {
      return false;
    }
    Vector that = (Vectoro;
    return  == that.size() && aggregate(that..) == 0.0;
  }
  public String toString() {
    return toString(null);
  }
  public String toString(String[] dictionary) {
    StringBuilder result = new StringBuilder();
    result.append('{');
    for (int index = 0; index < index++) {
      double value = getQuick(index);
      if (value != 0.0) {
        result.append(dictionary != null && dictionary.length > index ? dictionary[index] : index);
        result.append(':');
        result.append(value);
        result.append(',');
      }
    }
    if (result.length() > 1) {
      result.setCharAt(result.length() - 1, '}');
    } else {
      result.append('}');
    }
    return result.toString();
  }
  protected final class LocalElement implements Element {
    int index;
    LocalElement(int index) {
      this. = index;
    }
    @Override
    public double get() {
      return getQuick();
    }
    @Override
    public int index() {
      return ;
    }
    @Override
    public void set(double value) {
      setQuick(value);
    }
  }
New to GrepCode? Check out our FAQ X