How to use

setRowVector

method

in

de.jungblut.math.DoubleMatrix

@Override
public DoubleMatrix apply(DoubleMatrix matrix) {
  DoubleMatrix dm = newInstance(matrix);
  for (int row = 0; row < matrix.getRowCount(); row++) {
    DoubleVector apply = apply(matrix.getRowVector(row));
    if (apply.getLength() != 0) {
      dm.setRowVector(row, apply);
    }
  }
  return dm;
}

@Override
public DoubleMatrix subtract(DoubleVector vec) {
 DoubleMatrix result = new SparseDoubleRowMatrix(this.getRowCount(),
   this.getColumnCount());
 for (int row : this.matrix.keys()) {
  SparseDoubleVector rowVec = matrix.get(row);
  result.setRowVector(row, rowVec.subtract(vec.get(row)));
 }
 return result;
}

final int numHiddenStates = beta.getColumnCount();
beta.setRowVector(features.length - 1,
    DenseDoubleVector.ones(numHiddenStates));

transitionProbabilityMatrix.setRowVector(rowIndex,
    DenseDoubleVector.ones(numHiddenStates));
emissionProbabilityMatrix.setRowVector(rowIndex,
    DenseDoubleVector.ones(numVisibleStates));

private static void normalize(DoubleVector hiddenPriorProbability,
               DoubleMatrix transitionProbabilityMatrix,
               DoubleMatrix emissionProbabilitiyMatrix, boolean log) {
  double sum = hiddenPriorProbability.sum();
  if (sum != 0d) {
    for (int i = 0; i < hiddenPriorProbability.getDimension(); i++) {
      hiddenPriorProbability.set(i, hiddenPriorProbability.get(i) / sum);
    }
  }
  for (int row = 0; row < transitionProbabilityMatrix.getRowCount(); row++) {
    // note that we are using row vectors here, because dense matrices give us
    // the underlying array wrapped by the vector object so we can directly
    // mutate the values beneath
    DoubleVector rowVector = transitionProbabilityMatrix.getRowVector(row);
    rowVector = rowVector.divide(rowVector.sum());
    if (log) {
      rowVector = rowVector.log();
    }
    transitionProbabilityMatrix.setRowVector(row, rowVector);
    rowVector = emissionProbabilitiyMatrix.getRowVector(row);
    rowVector = rowVector.divide(rowVector.sum());
    if (log) {
      rowVector = rowVector.log();
    }
    emissionProbabilitiyMatrix.setRowVector(row, rowVector);
  }
}

@Override
public DoubleMatrix apply(DoubleMatrix matrix) {
  DoubleMatrix newInstance = newInstance(matrix);
  if (matrix.isSparse()) {
    // if we have a sparse matrix, it is more efficient to loop over the
    // sparse row vectors
    int[] rows = matrix.rowIndices();
    for (int row : rows) {
      DoubleVector rowVector = matrix.getRowVector(row);
      if (rowVector.getLength() > 0) {
        DoubleVector apply = apply(rowVector);
        newInstance.setRowVector(row, apply);
      }
    }
  } else {
    // on dense matrices we can be faster by directly looping over the items
    for (int i = 0; i < matrix.getRowCount(); i++) {
      for (int j = 0; j < matrix.getColumnCount(); j++) {
        newInstance.set(i, j, apply(matrix.get(i, j)));
      }
    }
  }
  return newInstance;
}

  vec.set(0, bestLabel);
outcome.setRowVector(position, vec);
bestLabel = backpointers[position][bestLabel];