Index: commons/src/main/java/org/apache/hama/commons/math/NamedDoubleVector.java =================================================================== --- commons/src/main/java/org/apache/hama/commons/math/NamedDoubleVector.java (리비전 0) +++ commons/src/main/java/org/apache/hama/commons/math/NamedDoubleVector.java (작업 사본) @@ -0,0 +1,241 @@ +/** + * 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.hama.commons.math; + +import java.util.Iterator; + +public class NamedDoubleVector implements DoubleVector { + + private String name; + private DoubleVector vector; + + public NamedDoubleVector(String name, DoubleVector deepCopy) { + super(); + this.name = name; + this.vector = deepCopy; + } + + @Override + public double get(int index) { + return vector.get(index); + } + + @Override + public int getLength() { + return vector.getLength(); + } + + @Override + public int getDimension() { + return vector.getDimension(); + } + + @Override + public void set(int index, double value) { + vector.set(index, value); + } + + @SuppressWarnings("deprecation") + @Override + public DoubleVector apply(DoubleVectorFunction func) { + return vector.apply(func); + } + + @SuppressWarnings("deprecation") + @Override + public DoubleVector apply(DoubleVector other, DoubleDoubleVectorFunction func) { + return vector.apply(other, func); + } + + @Override + public DoubleVector applyToElements(DoubleFunction func) { + return vector.applyToElements(func); + } + + @Override + public DoubleVector applyToElements(DoubleVector other, + DoubleDoubleFunction func) { + return vector.applyToElements(other, func); + } + + @Override + public DoubleVector addUnsafe(DoubleVector vector) { + return vector.addUnsafe(vector); + } + + @Override + public DoubleVector add(DoubleVector vector) { + return vector.add(vector); + } + + @Override + public DoubleVector add(double scalar) { + return vector.add(scalar); + } + + @Override + public DoubleVector subtractUnsafe(DoubleVector vector) { + return vector.subtractUnsafe(vector); + } + + @Override + public DoubleVector subtract(DoubleVector vector) { + return vector.subtract(vector); + } + + @Override + public DoubleVector subtract(double scalar) { + return vector.subtract(scalar); + } + + @Override + public DoubleVector subtractFrom(double scalar) { + return vector.subtractFrom(scalar); + } + + @Override + public DoubleVector multiply(double scalar) { + return vector.multiply(scalar); + } + + @Override + public DoubleVector multiplyUnsafe(DoubleVector vector) { + return vector.multiplyUnsafe(vector); + } + + @Override + public DoubleVector multiply(DoubleVector vector) { + return vector.multiply(vector); + } + + @Override + public DoubleVector multiply(DoubleMatrix matrix) { + return vector.multiply(matrix); + } + + @Override + public DoubleVector multiplyUnsafe(DoubleMatrix matrix) { + return vector.multiplyUnsafe(matrix); + } + + @Override + public DoubleVector divide(double scalar) { + return vector.divide(scalar); + } + + @Override + public DoubleVector divideFrom(double scalar) { + return vector.divideFrom(scalar); + } + + @Override + public DoubleVector pow(int x) { + return vector.pow(x); + } + + @Override + public DoubleVector abs() { + return vector.abs(); + } + + @Override + public DoubleVector sqrt() { + return vector.sqrt(); + } + + @Override + public double sum() { + return vector.sum(); + } + + @Override + public double dotUnsafe(DoubleVector vector) { + return vector.dotUnsafe(vector); + } + + @Override + public double dot(DoubleVector vector) { + return vector.dot(vector); + } + + @Override + public DoubleVector slice(int length) { + return vector.slice(length); + } + + @Override + public DoubleVector sliceUnsafe(int length) { + return vector.sliceUnsafe(length); + } + + @Override + public DoubleVector slice(int start, int end) { + return vector.slice(start, end); + } + + @Override + public DoubleVector sliceUnsafe(int start, int end) { + return vector.sliceUnsafe(start, end); + } + + @Override + public double max() { + return vector.max(); + } + + @Override + public double min() { + return vector.min(); + } + + @Override + public double[] toArray() { + return vector.toArray(); + } + + @Override + public DoubleVector deepCopy() { + return new NamedDoubleVector(name, vector.deepCopy()); + } + + @Override + public Iterator iterateNonZero() { + return vector.iterateNonZero(); + } + + @Override + public Iterator iterate() { + return vector.iterate(); + } + + @Override + public boolean isSparse() { + return vector.isSparse(); + } + + @Override + public boolean isNamed() { + return true; + } + + @Override + public String getName() { + return name; + } + +}