List of usage examples for org.apache.commons.math3.linear RealMatrix getRowVector
RealVector getRowVector(int row) throws OutOfRangeException;
From source file:com.cloudera.oryx.kmeans.common.ClusterValidityStatistics.java
/** * Calculates the normalized van Dongen criterion for the contingency contingencyMatrix. * * @return the normalized van Dongen criterion for the contingency contingencyMatrix *///from www .j av a 2 s. co m private static double normVanDongen(RealMatrix contingencyMatrix, double[] rowSums, double[] colSums, double n) { double rs = 0.0; double cs = 0.0; double rmax = 0.0; double cmax = 0.0; for (int i = 0; i < rowSums.length; i++) { rs += contingencyMatrix.getRowVector(i).getLInfNorm(); cs += contingencyMatrix.getColumnVector(i).getLInfNorm(); rmax = Math.max(rmax, rowSums[i]); cmax = Math.max(cmax, colSums[i]); } double den = 2 * n - rmax - cmax; if (den == 0.0) { return Double.NaN; } return (2 * n - rs - cs) / den; }
From source file:edu.byu.nlp.stats.DirichletDistribution.java
/** Returns an array of logs of samples from the specified Dirichlet distributions. * Similar to calling:/*from w ww . j a v a2s. c o m*/ * <pre> * double[][] thetas = sample(alpha, rnd); * for (int k = 0; k < thetas.length; k++) { * DoubleArrays.logToSelf(thetas[k]); * } * </pre> * EXCEPT that precision is better preserved. **/ public static double[][] logSample(RealMatrix alphas, RandomGenerator rnd) { double[][] thetas = new double[alphas.getRowDimension()][]; for (int i = 0; i < thetas.length; i++) { thetas[i] = logSample(alphas.getRowVector(i), rnd); } return thetas; }
From source file:com.vsthost.rnd.commons.math.ext.linear.EMatrixUtils.java
/** * Multiplies the matrix' rows using the vector element-by-element. * * @param matrix The input matrix.// www . j a v a 2 s . c o m * @param vector The vector which will be used to multiply rows of the matrix element-by-element. * @return The new matrix of which rows are multiplied with the vector element-by-element. */ public static RealMatrix rbrMultiply(RealMatrix matrix, RealVector vector) { // Define the return value: RealMatrix retval = MatrixUtils.createRealMatrix(matrix.getRowDimension(), matrix.getColumnDimension()); // Iterate over rows: for (int i = 0; i < retval.getRowDimension(); i++) { retval.setRowVector(i, matrix.getRowVector(i).ebeMultiply(vector)); } // Done, return: return retval; }
From source file:com.github.thorbenlindhauer.factor.CanonicalGaussianFactor.java
/** * Transforms a conditional linear gaussian (i.e. a Gaussian of the form N(x; a + B^T * Y, C) into canonical form. * * @param meanVector a/*from w w w.j a v a 2 s . co m*/ * @param weightMatrix B * @param covarianceMatrix C */ public static CanonicalGaussianFactor fromConditionalForm(Scope scope, Scope conditioningScope, RealVector meanVector, RealMatrix covarianceMatrix, RealMatrix weightMatrix) { // TODO: perform cardinality checks etc. // the following assumes that the resulting precision matrix (and mean vector) can be restructured as follows: // ( SUBMATRIX_XX SUBMATRIX_XY ) // ( SUBMATRIX_YX SUBMATRIX_YY ) // where X indicates variables that are part of the prediction scope and Y are variables being part of the conditioning scope // assuming // meanVector: a; |x| vector // covarianceMatrix: C; |x| cross |x| matrix // weightMatrix: B; |x| cross |y| matrix // XX = C^-1 // XY = -C^-1 * B // YX = -B^T * C^-1 // YY = B^T * C^-1 * B^T MathUtil mathUtil = new MathUtil(covarianceMatrix); // C^(-1) RealMatrix xxMatrix = null; xxMatrix = mathUtil.invert(); // if (!mathUtil.isZeroMatrix()) { // xxMatrix = mathUtil.invert(); // } else { // // // this is a special case for convolution in which the "summing" variable has no variance itself // // although a 0 variance is not valid in general // xxMatrix = covarianceMatrix; // } // B^T * C^(-1) RealMatrix weightedXXMatrix = weightMatrix.transpose().multiply(xxMatrix); // -B^T * C^(-1) RealMatrix yxMatrix = weightedXXMatrix.scalarMultiply(-1.0d); // -C^(-1)^T * B RealMatrix xyMatrix = xxMatrix.transpose().multiply(weightMatrix).scalarMultiply(-1.0d); // B^T * C^(-1) * B RealMatrix yyMatrix = weightedXXMatrix.multiply(weightMatrix); // K RealMatrix conditionedPrecisionMatrix = new Array2DRowRealMatrix(scope.size(), scope.size()); // Matrix to generate h RealMatrix conditionedMeanTransformationMatrix = new Array2DRowRealMatrix(scope.size(), scope.size()); Scope predictionScope = scope.reduceBy(conditioningScope); int[] predictionMapping = scope.createContinuousVariableMapping(predictionScope); int[] conditioningMapping = scope.createContinuousVariableMapping(conditioningScope); for (int i = 0; i < scope.size(); i++) { RealVector precisionColumn = conditionedPrecisionMatrix.getColumnVector(i); if (predictionMapping[i] >= 0) { precisionColumn = precisionColumn.add( padVector(xxMatrix.getColumnVector(predictionMapping[i]), scope.size(), predictionMapping)); conditionedMeanTransformationMatrix.setColumnVector(i, precisionColumn); precisionColumn = precisionColumn.add(padVector(yxMatrix.getColumnVector(predictionMapping[i]), scope.size(), conditioningMapping)); conditionedPrecisionMatrix.setColumnVector(i, precisionColumn); } if (conditioningMapping[i] >= 0) { precisionColumn = precisionColumn.add(padVector(xyMatrix.getColumnVector(conditioningMapping[i]), scope.size(), predictionMapping)); conditionedMeanTransformationMatrix.setColumnVector(i, precisionColumn); precisionColumn = precisionColumn.add(padVector(yyMatrix.getColumnVector(conditioningMapping[i]), scope.size(), conditioningMapping)); conditionedPrecisionMatrix.setColumnVector(i, precisionColumn); } } // h = (a, 0)^T * (XX, XY; 0, 0) RealMatrix scaledMeanMatrix = new Array2DRowRealMatrix(1, scope.size()); scaledMeanMatrix.setRowVector(0, padVector(meanVector, scope.size(), predictionMapping)); scaledMeanMatrix = scaledMeanMatrix.multiply(conditionedMeanTransformationMatrix); RealVector scaledMeanVector = scaledMeanMatrix.getRowVector(0); // g = a^T * C^-1 * a - log((2 * PI) ^ m/2 * det(C)^0.5) where m is the size of the prediction scope RealMatrix meanMatrix = new Array2DRowRealMatrix(predictionScope.size(), 1); meanMatrix.setColumnVector(0, meanVector); double normalizationConstant = -0.5d * meanVector.dotProduct(xxMatrix.operate(meanVector)) - Math.log( Math.pow(2 * Math.PI, (double) predictionScope.size() / 2.0d) * Math.sqrt(mathUtil.determinant())); return new CanonicalGaussianFactor(scope, conditionedPrecisionMatrix, scaledMeanVector, normalizationConstant); }
From source file:com.vsthost.rnd.commons.math.ext.linear.EMatrixUtils.java
/** * Shuffles rows of a matrix using the provided random number generator. * * @param matrix The matrix of which the rows will be shuffled. * @param randomGenerator The random number generator to be used. * @return The new shuffled matrix./*ww w . java2s .com*/ */ public static RealMatrix shuffleRows(RealMatrix matrix, RandomGenerator randomGenerator) { // Create an index vector to be shuffled: int[] index = MathArrays.sequence(matrix.getRowDimension(), 0, 1); MathArrays.shuffle(index, randomGenerator); // Create a new matrix: RealMatrix retval = MatrixUtils.createRealMatrix(matrix.getRowDimension(), matrix.getColumnDimension()); // Populate: for (int row = 0; row < index.length; row++) { retval.setRowVector(row, matrix.getRowVector(index[row])); } // Done, return: return retval; }
From source file:gamlss.utilities.WLSMultipleLinearRegression.java
/** * /* w w w . ja v a 2 s .co m*/ * @param y * @param x * @param w */ private void newSampleDataNoCopy(ArrayRealVector y, RealMatrix x, ArrayRealVector w) { for (int row = 0; row < x.getRowDimension(); row++) { x.setRowVector(row, x.getRowVector(row).mapMultiplyToSelf(w.getEntry(row))); } //double[][] xw=x.getData(); //double[] yw= y.ebeMultiply(w).getDataRef(); //validateSampleData(xw, yw); //we have already checked this in the gamlss algorithm. newYSampleData(y.ebeMultiply(w)); newXSampleData(x.getData(), w); }
From source file:eagle.security.userprofile.impl.UserProfileAnomalyEigenEvaluator.java
@Override public List<MLCallbackResult> detect(final String user, final String algorithm, UserActivityAggModel userActivity, UserProfileEigenModel aModel) { RealMatrix inputData = userActivity.matrix(); LOG.warn("EigenBasedAnomalyDetection predictAnomaly called with dimension: " + inputData.getRowDimension() + "x" + inputData.getColumnDimension()); if (aModel == null) { LOG.warn(/*from w ww.ja v a 2 s. com*/ "nothing to do as the input model does not have required values, returning from evaluating this algorithm.."); return null; } List<MLCallbackResult> mlCallbackResults = new ArrayList<MLCallbackResult>(); RealMatrix normalizedMat = normalizeData(inputData, aModel); UserCommandStatistics[] listStats = aModel.statistics(); int colWithHighVariant = 0; for (int j = 0; j < normalizedMat.getColumnDimension(); j++) { if (listStats[j].isLowVariant() == false) { colWithHighVariant++; } } final Map<String, String> context = new HashMap<String, String>() { { put(UserProfileConstants.USER_TAG, user); put(UserProfileConstants.ALGORITHM_TAG, algorithm); } }; Map<Integer, String> lineNoWithVariantBasedAnomalyDetection = new HashMap<Integer, String>(); for (int i = 0; i < normalizedMat.getRowDimension(); i++) { MLCallbackResult aResult = new MLCallbackResult(); aResult.setAnomaly(false); aResult.setContext(context); for (int j = 0; j < normalizedMat.getColumnDimension(); j++) { //LOG.info("mean for j=" + j + " is:" + listStats[j].getMean()); //LOG.info("stddev for j=" + j + " is:" + listStats[j].getStddev()); if (listStats[j].isLowVariant() == true) { //LOG.info(listOfCmds[j] + " is low variant"); if (normalizedMat.getEntry(i, j) > listStats[j].getMean()) { lineNoWithVariantBasedAnomalyDetection.put(i, "lowVariantAnomaly"); aResult.setAnomaly(true); aResult.setTimestamp(userActivity.timestamp()); aResult.setFeature(listStats[j].getCommandName()); aResult.setAlgorithm(UserProfileConstants.EIGEN_DECOMPOSITION_ALGORITHM); List<String> datapoints = new ArrayList<String>(); double[] rowVals = inputData.getRow(i); for (double rowVal : rowVals) datapoints.add(rowVal + ""); aResult.setDatapoints(datapoints); aResult.setId(user); //mlCallbackResults.add(aResult); } /*else { aResult.setAnomaly(false); aResult.setTimestamp(userActivity.timestamp()); mlCallbackResults.add(aResult); }*/ } } mlCallbackResults.add(i, aResult); //return results; } //LOG.info("results size here: " + results.length); //LOG.info("col with high variant: " + colWithHighVariant); RealMatrix finalMatWithoutLowVariantFeatures = new Array2DRowRealMatrix(normalizedMat.getRowDimension(), colWithHighVariant); //LOG.info("size of final test data: " + finalMatWithoutLowVariantFeatures.getRowDimension() +"x"+ finalMatWithoutLowVariantFeatures.getColumnDimension()); int finalMatrixRow = 0; int finalMatrixCol = 0; for (int i = 0; i < normalizedMat.getRowDimension(); i++) { for (int j = 0; j < normalizedMat.getColumnDimension(); j++) { if (listStats[j].isLowVariant() == false) { finalMatWithoutLowVariantFeatures.setEntry(finalMatrixRow, finalMatrixCol, normalizedMat.getEntry(i, j)); finalMatrixCol++; } } finalMatrixCol = 0; finalMatrixRow++; } RealVector[] pcs = aModel.principalComponents(); //LOG.info("pc size: " + pcs.getRowDimension() +"x" + pcs.getColumnDimension()); RealMatrix finalInputMatTranspose = finalMatWithoutLowVariantFeatures.transpose(); for (int i = 0; i < finalMatWithoutLowVariantFeatures.getRowDimension(); i++) { if (lineNoWithVariantBasedAnomalyDetection.get(i) == null) { //MLCallbackResult result = new MLCallbackResult(); MLCallbackResult result = mlCallbackResults.get(i); //result.setContext(context); for (int sz = 0; sz < pcs.length; sz++) { double[] pc1 = pcs[sz].toArray(); RealMatrix pc1Mat = new Array2DRowRealMatrix(pc1); RealMatrix transposePC1Mat = pc1Mat.transpose(); RealMatrix testData = pc1Mat.multiply(transposePC1Mat) .multiply(finalInputMatTranspose.getColumnMatrix(i)); //LOG.info("testData size: " + testData.getRowDimension() + "x" + testData.getColumnDimension()); RealMatrix testDataTranspose = testData.transpose(); //LOG.info("testData transpose size: " + testDataTranspose.getRowDimension() + "x" + testDataTranspose.getColumnDimension()); RealVector iRowVector = testDataTranspose.getRowVector(0); //RealVector pc1Vector = transposePC1Mat.getRowVector(sz); RealVector pc1Vector = transposePC1Mat.getRowVector(0); double distanceiRowAndPC1 = iRowVector.getDistance(pc1Vector); //LOG.info("distance from pc sz: " + sz + " " + distanceiRowAndPC1 + " " + model.getMaxL2Norm().getEntry(sz)); //LOG.info("model.getMaxL2Norm().getEntry(sz):" + model.getMaxL2Norm().getEntry(sz)); if (distanceiRowAndPC1 > aModel.maximumL2Norm().getEntry(sz)) { //LOG.info("distance from pc sz: " + sz + " " + distanceiRowAndPC1 + " " + model.getMaxL2Norm().getEntry(sz)); result.setAnomaly(true); result.setFeature(aModel.statistics()[sz].getCommandName()); result.setTimestamp(System.currentTimeMillis()); result.setAlgorithm(UserProfileConstants.EIGEN_DECOMPOSITION_ALGORITHM); List<String> datapoints = new ArrayList<String>(); double[] rowVals = inputData.getRow(i); for (double rowVal : rowVals) datapoints.add(rowVal + ""); result.setDatapoints(datapoints); result.setId(user); } } mlCallbackResults.set(i, result); } } return mlCallbackResults; }
From source file:edu.stanford.cfuller.imageanalysistools.fitting.DifferentialEvolutionMinimizer.java
/** * Updates the function values for each parameter set in the population only if that parameter set has changed. * @param f The function being minimized * @param population The current population of parameters, one parameter set per row. * @param values The vector of the last computed values for each entry in the population; entries that have changed will be overwritten. * @param valuesChanged An array indicating whether each entry in the population has changed and requires computation of the value. *///from w w w .j a v a2 s.c om private void computeValues(ObjectiveFunction f, RealMatrix population, RealVector values, boolean[] valuesChanged) { for (int i = 0; i < population.getRowDimension(); i++) { if (valuesChanged[i]) { values.setEntry(i, f.evaluate(population.getRowVector(i))); } } }
From source file:ellipsoidFit.FitPoints.java
/** * Find the center of the ellipsoid.//from w ww . j av a 2 s .c o m * * @param a * the algebraic from of the polynomial. * @return a vector containing the center of the ellipsoid. */ private RealVector findCenter(RealMatrix a) { RealMatrix subA = a.getSubMatrix(0, 2, 0, 2); for (int q = 0; q < subA.getRowDimension(); q++) { for (int s = 0; s < subA.getColumnDimension(); s++) { subA.multiplyEntry(q, s, -1.0); } } RealVector subV = a.getRowVector(3).getSubVector(0, 3); // inv (dtd) DecompositionSolver solver = new SingularValueDecomposition(subA).getSolver(); RealMatrix subAi = solver.getInverse(); return subAi.operate(subV); }
From source file:com.github.thorbenlindhauer.factor.GaussianFactorTest.java
@Test public void testFactorMarginalCase2() { Scope variables = newScope(new ContinuousVariable("A")); GaussianFactor aMarginal = abcFactor.marginal(variables); // then/*w w w .ja va2s . c om*/ Collection<Variable> newVariables = aMarginal.getVariables().getVariables(); assertThat(newVariables).hasSize(1); assertThat(newVariables).contains(new ContinuousVariable("A")); // precision matrix: K_xx - K_xy * K_yy^(-1) * K_yx RealMatrix precisionMatrix = aMarginal.getPrecisionMatrix(); assertThat(precisionMatrix.isSquare()).isTrue(); assertThat(precisionMatrix.getColumnDimension()).isEqualTo(1); double precision = precisionMatrix.getRowVector(0).toArray()[0]; assertThat(precision).isEqualTo(-(14.0d / 3.0d), TestConstants.DOUBLE_VALUE_TOLERANCE); // scaled mean vector: h_x - K_xy * K_yy^(-1) * h_y RealVector scaledMeanVector = aMarginal.getScaledMeanVector(); assertThat(scaledMeanVector.getDimension()).isEqualTo(1); double meanValue = scaledMeanVector.toArray()[0]; assertThat(meanValue).isEqualTo(4.0d / 3.0d, TestConstants.DOUBLE_VALUE_TOLERANCE); // normalization constant: g + 0.5 * (log( det( 2 * PI * K_yy^(-1))) + h_y * K_yy^(-1) * h_y) assertThat(aMarginal.getNormalizationConstant()).isEqualTo(9.324590408d, TestConstants.DOUBLE_VALUE_TOLERANCE); }