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;
 
 
 public class NamedVector implements Vector {
 
   private Vector delegate;
   private String name;
 
   public NamedVector() {
   }
 
   public NamedVector(NamedVector other) {
     this. = other.getDelegate();
     this. = other.getName();
   }
 
   public NamedVector(Vector delegateString name) {
     if (delegate == null || name == null) {
       throw new IllegalArgumentException();
     }
     this. = delegate;
     this. = name;
   }
 
   public String getName() {
     return ;
   }
 
   public Vector getDelegate() {
     return ;
   }
 
   @Override
   public int hashCode() {
     return .hashCode();
   }

  
To not break transitivity with other Vectors, this does not compare name.
 
   @SuppressWarnings("EqualsWhichDoesntCheckParameterClass")
   @Override
   public boolean equals(Object other) {
     return .equals(other);
   }
 
   @SuppressWarnings("CloneDoesntCallSuperClone")
   @Override
   public NamedVector clone() {
     return new NamedVector(.clone(), );
   }
 
   @Override
   public Iterable<Elementall() {
     return .all();
   }
 
   @Override
   public Iterable<ElementnonZeroes() {
     return .nonZeroes();
   }
 
   @Override
   public String asFormatString() {
     return toString();
   }
 
   @Override
   public String toString() {
     StringBuilder bldr = new StringBuilder();
     bldr.append().append(':').append(.toString());
     return bldr.toString();
   }
 
   @Override
   public Vector assign(double value) {
     return .assign(value);
   }
 
   @Override
  public Vector assign(double[] values) {
    return .assign(values);
  }
  public Vector assign(Vector other) {
    return .assign(other);
  }
  public Vector assign(DoubleFunction function) {
    return .assign(function);
  }
  public Vector assign(Vector otherDoubleDoubleFunction function) {
    return .assign(otherfunction);
  }
  public Vector assign(DoubleDoubleFunction fdouble y) {
    return .assign(fy);
  }
  public int size() {
    return .size();
  }
  public boolean isDense() {
    return .isDense();
  }
  public boolean isSequentialAccess() {
    return .isSequentialAccess();
  }
  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 divide(double x) {
    return .divide(x);
  }
  public double dot(Vector x) {
    return .dot(x);
  }
  public double get(int index) {
    return .get(index);
  }
  public double getQuick(int index) {
    return .getQuick(index);
  }
  public NamedVector like() {
    return new NamedVector(.like(), );
  }
  public Vector minus(Vector x) {
    return .minus(x);
  }
  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 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 void setQuick(int indexdouble value) {
    .setQuick(indexvalue);
  }
  public void incrementQuick(int indexdouble increment) {
    .incrementQuick(indexincrement);
  }
  public int getNumNonZeroElements() {
  }
  public int getNumNondefaultElements() {
  }
  public Vector times(double x) {
    return .times(x);
  }
  public Vector times(Vector x) {
    return .times(x);
  }
  public Vector viewPart(int offsetint length) {
    return .viewPart(offsetlength);
  }
  public double zSum() {
    return .zSum();
  }
  public Matrix cross(Vector other) {
    return .cross(other);
  }
  public double aggregate(DoubleDoubleFunction aggregatorDoubleFunction map) {
    return .aggregate(aggregatormap);
  }
  public double aggregate(Vector otherDoubleDoubleFunction aggregatorDoubleDoubleFunction combiner) {
    return .aggregate(otheraggregatorcombiner);
  }
  public double getLengthSquared() {
    return .getLengthSquared();
  }
  public double getDistanceSquared(Vector v) {
    return .getDistanceSquared(v);
  }
  public double getLookupCost() {
    return .getLookupCost();
  }
  public double getIteratorAdvanceCost() {
  }
  public boolean isAddConstantTime() {
    return .isAddConstantTime();
  }
New to GrepCode? Check out our FAQ X