/** * @return a new vector with dimension num and a default value of 1. */ public static DenseDoubleVector ones(int num) { return new DenseDoubleVector(num, 1.0d); }
/** * @return a new vector with dimension num and a default value of 0. */ public static DenseDoubleVector zeros(int num) { return new DenseDoubleVector(num); }
@Override public DoubleVector apply(DoubleVectorFunction func) { DenseDoubleVector newV = new DenseDoubleVector(this.vector); for (int i = 0; i < vector.length; i++) { newV.vector[i] = func.calculate(i, vector[i]); } return newV; }
@Override public final DoubleVector subtractFrom(double v) { DenseDoubleVector newv = new DenseDoubleVector(vector.length); for (int i = 0; i < vector.length; i++) { newv.set(i, v - vector[i]); } return newv; }
@Override public final DoubleVector subtract(double v) { DenseDoubleVector newv = new DenseDoubleVector(vector.length); for (int i = 0; i < vector.length; i++) { newv.set(i, vector[i] - v); } return newv; }
@Override public DoubleVector getRowVector(int row) { return new DenseDoubleVector(getRow(row)); }
@Override public DoubleVector sliceByLength(int start, int length) { DoubleVector nv = new DenseDoubleVector(length); int index = start; for (int i = 0; i < length; i++) { nv.set(i, vector[index++]); } return nv; }
public static HyperRectangle infiniteHyperRectangle(int dimension) { DoubleVector min = new DenseDoubleVector(dimension); DoubleVector max = new DenseDoubleVector(dimension); for (int i = 0; i < dimension; ++i) { min.set(i, Double.NEGATIVE_INFINITY); max.set(i, Double.POSITIVE_INFINITY); } return new HyperRectangle(min, max); }
HMM(int numVisibleStates, int numHiddenStates, long seed) { this.seed = seed; this.numVisibleStates = numVisibleStates; this.numHiddenStates = numHiddenStates; this.transitionProbabilityMatrix = new DenseDoubleMatrix(numHiddenStates, numHiddenStates); this.emissionProbabilityMatrix = new DenseDoubleMatrix(numHiddenStates, numVisibleStates); this.hiddenPriorProbability = new DenseDoubleVector(numHiddenStates); }
/** * @return a new vector filled from index, to index, with a given stepsize. */ public static DenseDoubleVector fromUpTo(double from, double to, double stepsize) { DenseDoubleVector v = new DenseDoubleVector( (int) (FastMath.round(((to - from) / stepsize) + 0.5))); for (int i = 0; i < v.getLength(); i++) { v.set(i, from + i * stepsize); } return v; }
@Override public DoubleVector divide(double scalar) { if (scalar == 0d) { throw new java.lang.ArithmeticException("/ by zero"); } DenseDoubleVector v = new DenseDoubleVector(this.getLength()); for (int i = 0; i < v.getLength(); i++) { v.set(i, this.get(i) / scalar); } return v; }
/** * @return the transition probabilities for the states. */ public DoubleVector getTransitionProbabilities(int[] stateSequence) { DenseDoubleVector distribution = new DenseDoubleVector( stateSequence.length - 1); for (int i = 0; i < distribution.getDimension(); i++) { distribution.set(i, transitionProbabilities.get(stateSequence[i], stateSequence[i + 1])); } return distribution; }
private DoubleVector computeHiddenActivations(DoubleVector input, DoubleMatrix theta) { // add the bias to the input DoubleVector biased = new DenseDoubleVector(1d, input.toArray()); return activationFunction.apply(theta.multiplyVectorRow(biased)); }
@Override public DoubleVector sqrt() { DoubleVector v = new DenseDoubleVector(this.getLength()); for (int i = 0; i < v.getLength(); i++) { v.set(i, FastMath.sqrt(vector[i])); } return v; }
@Override public DoubleVector log() { DoubleVector v = new DenseDoubleVector(getLength()); for (int i = 0; i < v.getLength(); i++) { v.set(i, FastMath.log(vector[i])); } return v; }
@Override public DoubleVector abs() { DoubleVector v = new DenseDoubleVector(getLength()); for (int i = 0; i < v.getLength(); i++) { v.set(i, FastMath.abs(vector[i])); } return v; }
@Override public DoubleVector exp() { DoubleVector v = new DenseDoubleVector(getLength()); for (int i = 0; i < v.getLength(); i++) { v.set(i, FastMath.exp(vector[i])); } return v; }
@Override public DoubleVector multiplyVectorColumn(DoubleVector v) { DoubleVector vector = new DenseDoubleVector(this.getColumnCount()); for (int col = 0; col < numColumns; col++) { double sum = 0.0d; for (int row = 0; row < numRows; row++) { sum += (matrix[translate(row, col, numRows)] * v.get(row)); } vector.set(col, sum); } return vector; }
@Override public DoubleVector divide(DoubleVector vector) { DoubleVector v = new DenseDoubleVector(this.getLength()); for (int i = 0; i < v.getLength(); i++) { if (vector.get(i) != 0.0d) { double result = this.get(i) / vector.get(i); v.set(i, result); } else { throw new java.lang.ArithmeticException("/ by zero"); } } return v; }
/** * @return a log'd matrix that was guarded against edge cases of the * logarithm. */ public static DoubleVector logVector(DoubleVector input) { DenseDoubleVector log = new DenseDoubleVector(input.getDimension()); for (int col = 0; col < log.getDimension(); col++) { log.set(col, guardedLogarithm(input.get(col))); } return log; }