Java Lambda类代码示例

import edu.jhu.prim.util.Lambda; //导入依赖的package包/类
/** Updates this vector to be the entrywise sum of this vector with the other. */
public void add(LongDoubleVector other) {
    if (other instanceof LongDoubleUnsortedVector) {
        LongDoubleUnsortedVector vec = (LongDoubleUnsortedVector) other;
        for (int i=0; i<vec.top; i++) {
            this.add(vec.idx[i], vec.vals[i]);
        }
    } else {
        //  TODO: Add special case for LongDoubleDenseVector.
        other.iterate(new SparseBinaryOpApplier(this, new Lambda.DoubleAdd()));
    }
}
 

import edu.jhu.prim.util.Lambda; //导入依赖的package包/类
/** Updates this vector to be the entrywise difference of this vector with the other. */
public void subtract(LongDoubleVector other) {
    if (other instanceof LongDoubleUnsortedVector) {
        LongDoubleUnsortedVector vec = (LongDoubleUnsortedVector) other;
        for (int i=0; i<vec.top; i++) {
            this.add(vec.idx[i], -vec.vals[i]);
        }
    } else {
        // TODO: Add special case for LongDoubleDenseVector.
        other.iterate(new SparseBinaryOpApplier(this, new Lambda.DoubleSubtract()));
    }
}
 

import edu.jhu.prim.util.Lambda; //导入依赖的package包/类
/** Updates this vector to be the entrywise product (i.e. Hadamard product) of this vector with the other. */
public void product(LongDoubleVector other) { 
    // TODO: This is correct, but will create lots of zero entries and not remove any.
    // Also this will be very slow if other is a LongDoubleSortedVector since it will have to
    // call get() each time.
    this.apply(new SparseBinaryOpApplier2(this, other, new Lambda.DoubleProd()));
}
 

import edu.jhu.prim.util.Lambda; //导入依赖的package包/类
/** Updates this vector to be the entrywise product (i.e. Hadamard product) of this vector with the other. */
public void product(IntLongVector other) { 
    // TODO: This is correct, but will create lots of zero entries and not remove any.
    // Also this will be very slow if other is a IntLongSortedVector since it will have to
    // call get() each time.
    this.apply(new SparseBinaryOpApplier2(this, other, new Lambda.LongProd()));
}
 

import edu.jhu.prim.util.Lambda; //导入依赖的package包/类
/** Updates this vector to be the entrywise sum of this vector with the other. */
public void add(IntDoubleVector other) {
    if (other instanceof IntDoubleUnsortedVector) {
        IntDoubleUnsortedVector vec = (IntDoubleUnsortedVector) other;
        for (int i=0; i<vec.top; i++) {
            this.add(vec.idx[i], vec.vals[i]);
        }
    } else {
        //  TODO: Add special case for IntDoubleDenseVector.
        other.iterate(new SparseBinaryOpApplier(this, new Lambda.DoubleAdd()));
    }
}
 

import edu.jhu.prim.util.Lambda; //导入依赖的package包/类
/** Updates this vector to be the entrywise difference of this vector with the other. */
public void subtract(IntDoubleVector other) {
    if (other instanceof IntDoubleUnsortedVector) {
        IntDoubleUnsortedVector vec = (IntDoubleUnsortedVector) other;
        for (int i=0; i<vec.top; i++) {
            this.add(vec.idx[i], -vec.vals[i]);
        }
    } else {
        // TODO: Add special case for IntDoubleDenseVector.
        other.iterate(new SparseBinaryOpApplier(this, new Lambda.DoubleSubtract()));
    }
}
 

import edu.jhu.prim.util.Lambda; //导入依赖的package包/类
/** Updates this vector to be the entrywise sum of this vector with the other. */
public void add(IntIntVector other) {
    if (other instanceof IntIntUnsortedVector) {
        IntIntUnsortedVector vec = (IntIntUnsortedVector) other;
        for (int i=0; i<vec.top; i++) {
            this.add(vec.idx[i], vec.vals[i]);
        }
    } else {
        //  TODO: Add special case for IntIntDenseVector.
        other.iterate(new SparseBinaryOpApplier(this, new Lambda.IntAdd()));
    }
}
 

import edu.jhu.prim.util.Lambda; //导入依赖的package包/类
/** Updates this vector to be the entrywise difference of this vector with the other. */
public void subtract(IntIntVector other) {
    if (other instanceof IntIntUnsortedVector) {
        IntIntUnsortedVector vec = (IntIntUnsortedVector) other;
        for (int i=0; i<vec.top; i++) {
            this.add(vec.idx[i], -vec.vals[i]);
        }
    } else {
        // TODO: Add special case for IntIntDenseVector.
        other.iterate(new SparseBinaryOpApplier(this, new Lambda.IntSubtract()));
    }
}
 

import edu.jhu.prim.util.Lambda; //导入依赖的package包/类
/** Updates this vector to be the entrywise product (i.e. Hadamard product) of this vector with the other. */
public void product(LongIntVector other) { 
    // TODO: This is correct, but will create lots of zero entries and not remove any.
    // Also this will be very slow if other is a LongIntSortedVector since it will have to
    // call get() each time.
    this.apply(new SparseBinaryOpApplier2(this, other, new Lambda.IntProd()));
}
 

import edu.jhu.prim.util.Lambda; //导入依赖的package包/类
/** Updates this vector to be the entrywise product (i.e. Hadamard product) of this vector with the other. */
public void product(IntFloatVector other) { 
    // TODO: This is correct, but will create lots of zero entries and not remove any.
    // Also this will be very slow if other is a IntFloatSortedVector since it will have to
    // call get() each time.
    this.apply(new SparseBinaryOpApplier2(this, other, new Lambda.FloatProd()));
}
 

import edu.jhu.prim.util.Lambda; //导入依赖的package包/类
/** Updates this vector to be the entrywise sum of this vector with the other. */
public void add(IntLongVector other) {
    if (other instanceof IntLongUnsortedVector) {
        IntLongUnsortedVector vec = (IntLongUnsortedVector) other;
        for (int i=0; i<vec.top; i++) {
            this.add(vec.idx[i], vec.vals[i]);
        }
    } else {
        //  TODO: Add special case for IntLongDenseVector.
        other.iterate(new SparseBinaryOpApplier(this, new Lambda.LongAdd()));
    }
}
 

import edu.jhu.prim.util.Lambda; //导入依赖的package包/类
/** Updates this vector to be the entrywise difference of this vector with the other. */
public void subtract(IntLongVector other) {
    if (other instanceof IntLongUnsortedVector) {
        IntLongUnsortedVector vec = (IntLongUnsortedVector) other;
        for (int i=0; i<vec.top; i++) {
            this.add(vec.idx[i], -vec.vals[i]);
        }
    } else {
        // TODO: Add special case for IntLongDenseVector.
        other.iterate(new SparseBinaryOpApplier(this, new Lambda.LongSubtract()));
    }
}
 

import edu.jhu.prim.util.Lambda; //导入依赖的package包/类
/** Updates this vector to be the entrywise sum of this vector with the other. */
public void add(LongIntVector other) {
    if (other instanceof LongIntUnsortedVector) {
        LongIntUnsortedVector vec = (LongIntUnsortedVector) other;
        for (int i=0; i<vec.top; i++) {
            this.add(vec.idx[i], vec.vals[i]);
        }
    } else {
        //  TODO: Add special case for LongIntDenseVector.
        other.iterate(new SparseBinaryOpApplier(this, new Lambda.IntAdd()));
    }
}
 

import edu.jhu.prim.util.Lambda; //导入依赖的package包/类
/** Updates this vector to be the entrywise difference of this vector with the other. */
public void subtract(LongIntVector other) {
    if (other instanceof LongIntUnsortedVector) {
        LongIntUnsortedVector vec = (LongIntUnsortedVector) other;
        for (int i=0; i<vec.top; i++) {
            this.add(vec.idx[i], -vec.vals[i]);
        }
    } else {
        // TODO: Add special case for LongIntDenseVector.
        other.iterate(new SparseBinaryOpApplier(this, new Lambda.IntSubtract()));
    }
}
 

import edu.jhu.prim.util.Lambda; //导入依赖的package包/类
/** Updates this vector to be the entrywise product (i.e. Hadamard product) of this vector with the other. */
public void product(IntIntVector other) { 
    // TODO: This is correct, but will create lots of zero entries and not remove any.
    // Also this will be very slow if other is a IntIntSortedVector since it will have to
    // call get() each time.
    this.apply(new SparseBinaryOpApplier2(this, other, new Lambda.IntProd()));
}