Example usage for org.apache.commons.math3.linear RealMatrix setRow

List of usage examples for org.apache.commons.math3.linear RealMatrix setRow

Introduction

In this page you can find the example usage for org.apache.commons.math3.linear RealMatrix setRow.

Prototype

void setRow(int row, double[] array) throws OutOfRangeException, MatrixDimensionMismatchException;

Source Link

Document

Sets the specified row of this matrix to the entries of the specified array .

Usage

From source file:com.github.thorbenlindhauer.test.util.LinearAlgebraUtil.java

public static RealMatrix asRowMatrix(double... values) {
    RealMatrix matrix = new Array2DRowRealMatrix(1, values.length);
    matrix.setRow(0, values);
    return matrix;
}

From source file:com.github.thorbenlindhauer.test.util.LinearAlgebraUtil.java

public static RealMatrix asSingleRowMatrix(double value, int repetitions) {
    double[] values = new double[repetitions];
    for (int i = 0; i < repetitions; i++) {
        values[i] = value;/*from w ww  .ja v a 2  s  .  c  o m*/
    }

    RealMatrix matrix = new Array2DRowRealMatrix(1, repetitions);
    matrix.setRow(0, values);
    return matrix;
}

From source file:iDynoOptimizer.MOEAFramework26.src.org.moeaframework.core.operator.real.AdaptiveMetropolis.java

@Override
public Solution[] evolve(Solution[] parents) {
    int k = parents.length;
    int n = parents[0].getNumberOfVariables();
    RealMatrix x = new Array2DRowRealMatrix(k, n);

    for (int i = 0; i < k; i++) {
        x.setRow(i, EncodingUtils.getReal(parents[i]));
    }/* w  w  w  .  j  a  v  a  2 s.  c om*/

    try {
        //perform Cholesky factorization and get the upper triangular matrix
        double jumpRate = Math.pow(jumpRateCoefficient / Math.sqrt(n), 2.0);

        RealMatrix chol = new CholeskyDecomposition(
                new Covariance(x.scalarMultiply(jumpRate)).getCovarianceMatrix()).getLT();

        //produce the offspring
        Solution[] offspring = new Solution[numberOfOffspring];

        for (int i = 0; i < numberOfOffspring; i++) {
            Solution child = parents[PRNG.nextInt(parents.length)].copy();

            //apply adaptive metropolis step to solution
            RealVector muC = new ArrayRealVector(EncodingUtils.getReal(child));
            RealVector ru = new ArrayRealVector(n);

            for (int j = 0; j < n; j++) {
                ru.setEntry(j, PRNG.nextGaussian());
            }

            double[] variables = muC.add(chol.preMultiply(ru)).toArray();

            //assign variables back to solution
            for (int j = 0; j < n; j++) {
                RealVariable variable = (RealVariable) child.getVariable(j);
                double value = variables[j];

                if (value < variable.getLowerBound()) {
                    value = variable.getLowerBound();
                } else if (value > variable.getUpperBound()) {
                    value = variable.getUpperBound();
                }

                variable.setValue(value);
            }

            offspring[i] = child;
        }

        return offspring;
    } catch (Exception e) {
        return new Solution[0];
    }
}

From source file:mase.app.allocation.AllocationProblem.java

private DescriptiveStatistics pairDistances(RealMatrix distMatrix) {
    DescriptiveStatistics ds = new DescriptiveStatistics();
    distMatrix = distMatrix.copy();/*  w w  w . ja v a  2s .c  om*/

    for (int k = 0; k < numAgents; k++) {
        // find closest pair
        double min = Double.POSITIVE_INFINITY;
        int minI = -1, minJ = -1;
        for (int i = 0; i < numAgents; i++) {
            for (int j = 0; j < numAgents; j++) {
                double d = distMatrix.getEntry(i, j);
                if (!Double.isNaN(d) && d < min) {
                    min = d;
                    minI = i;
                    minJ = j;
                }
            }
        }
        ds.addValue(min);
        distMatrix.setRow(minI, nulify);
        distMatrix.setColumn(minJ, nulify);
    }
    return ds;
}

From source file:lirmm.inria.fr.math.BigSparseRealMatrixTest.java

@Test
public void testSetRow() {
    RealMatrix m = new BigSparseRealMatrix(subTestData);
    Assert.assertTrue(subRow3[0][0] != m.getRow(0)[0]);
    m.setRow(0, subRow3[0]);
    checkArrays(subRow3[0], m.getRow(0));
    try {//from w  w  w .ja  va2s . c  om
        m.setRow(-1, subRow3[0]);
        Assert.fail("Expecting OutOfRangeException");
    } catch (OutOfRangeException ex) {
        // expected
    }
    try {
        m.setRow(0, new double[5]);
        Assert.fail("Expecting MatrixDimensionMismatchException");
    } catch (MatrixDimensionMismatchException ex) {
        // expected
    }
}

From source file:com.github.tteofili.looseen.yay.SGM.java

/**
 * perform weights learning from the training examples using (configurable) mini batch gradient descent algorithm
 *
 * @param samples the training examples/*  w ww .j av  a 2  s. c  o  m*/
 * @return the final cost with the updated weights
 * @throws Exception if BGD fails to converge or any numerical error happens
 */
private double learnWeights(Sample... samples) throws Exception {

    int iterations = 0;

    double cost = Double.MAX_VALUE;

    int j = 0;

    // momentum
    RealMatrix vb = MatrixUtils.createRealMatrix(biases[0].getRowDimension(), biases[0].getColumnDimension());
    RealMatrix vb2 = MatrixUtils.createRealMatrix(biases[1].getRowDimension(), biases[1].getColumnDimension());
    RealMatrix vw = MatrixUtils.createRealMatrix(weights[0].getRowDimension(), weights[0].getColumnDimension());
    RealMatrix vw2 = MatrixUtils.createRealMatrix(weights[1].getRowDimension(),
            weights[1].getColumnDimension());

    long start = System.currentTimeMillis();
    int c = 1;
    RealMatrix x = MatrixUtils.createRealMatrix(configuration.batchSize, samples[0].getInputs().length);
    RealMatrix y = MatrixUtils.createRealMatrix(configuration.batchSize, samples[0].getOutputs().length);
    while (true) {

        int i = 0;
        for (int k = j * configuration.batchSize; k < j * configuration.batchSize
                + configuration.batchSize; k++) {
            Sample sample = samples[k % samples.length];
            x.setRow(i, sample.getInputs());
            y.setRow(i, sample.getOutputs());
            i++;
        }
        j++;

        long time = (System.currentTimeMillis() - start) / 1000;
        if (iterations % (1 + (configuration.maxIterations / 100)) == 0 && time > 60 * c) {
            c += 1;
            //                System.out.println("cost: " + cost + ", accuracy: " + evaluate(this) + " after " + iterations + " iterations in " + (time / 60) + " minutes (" + ((double) iterations / time) + " ips)");
        }

        RealMatrix w0t = weights[0].transpose();
        RealMatrix w1t = weights[1].transpose();

        RealMatrix hidden = rectifierFunction.applyMatrix(x.multiply(w0t));
        hidden.walkInOptimizedOrder(new RealMatrixChangingVisitor() {
            @Override
            public void start(int rows, int columns, int startRow, int endRow, int startColumn, int endColumn) {

            }

            @Override
            public double visit(int row, int column, double value) {
                return value + biases[0].getEntry(0, column);
            }

            @Override
            public double end() {
                return 0;
            }
        });
        RealMatrix scores = hidden.multiply(w1t);
        scores.walkInOptimizedOrder(new RealMatrixChangingVisitor() {
            @Override
            public void start(int rows, int columns, int startRow, int endRow, int startColumn, int endColumn) {

            }

            @Override
            public double visit(int row, int column, double value) {
                return value + biases[1].getEntry(0, column);
            }

            @Override
            public double end() {
                return 0;
            }
        });

        RealMatrix probs = scores.copy();
        int len = scores.getColumnDimension() - 1;
        for (int d = 0; d < configuration.window - 1; d++) {
            int startColumn = d * len / (configuration.window - 1);
            RealMatrix subMatrix = scores.getSubMatrix(0, scores.getRowDimension() - 1, startColumn,
                    startColumn + x.getColumnDimension());
            for (int sm = 0; sm < subMatrix.getRowDimension(); sm++) {
                probs.setSubMatrix(softmaxActivationFunction.applyMatrix(subMatrix.getRowMatrix(sm)).getData(),
                        sm, startColumn);
            }
        }

        RealMatrix correctLogProbs = MatrixUtils.createRealMatrix(x.getRowDimension(), 1);
        correctLogProbs.walkInOptimizedOrder(new RealMatrixChangingVisitor() {
            @Override
            public void start(int rows, int columns, int startRow, int endRow, int startColumn, int endColumn) {

            }

            @Override
            public double visit(int row, int column, double value) {
                return -Math.log(probs.getEntry(row, getMaxIndex(y.getRow(row))));
            }

            @Override
            public double end() {
                return 0;
            }
        });
        double dataLoss = correctLogProbs.walkInOptimizedOrder(new RealMatrixPreservingVisitor() {
            private double d = 0;

            @Override
            public void start(int rows, int columns, int startRow, int endRow, int startColumn, int endColumn) {

            }

            @Override
            public void visit(int row, int column, double value) {
                d += value;
            }

            @Override
            public double end() {
                return d;
            }
        }) / samples.length;

        double reg = 0d;
        reg += weights[0].walkInOptimizedOrder(new RealMatrixPreservingVisitor() {
            private double d = 0d;

            @Override
            public void start(int rows, int columns, int startRow, int endRow, int startColumn, int endColumn) {

            }

            @Override
            public void visit(int row, int column, double value) {
                d += Math.pow(value, 2);
            }

            @Override
            public double end() {
                return d;
            }
        });
        reg += weights[1].walkInOptimizedOrder(new RealMatrixPreservingVisitor() {
            private double d = 0d;

            @Override
            public void start(int rows, int columns, int startRow, int endRow, int startColumn, int endColumn) {

            }

            @Override
            public void visit(int row, int column, double value) {
                d += Math.pow(value, 2);
            }

            @Override
            public double end() {
                return d;
            }
        });

        double regLoss = 0.5 * configuration.regularizationLambda * reg;
        double newCost = dataLoss + regLoss;
        if (iterations == 0) {
            //                System.out.println("started with cost = " + dataLoss + " + " + regLoss + " = " + newCost);
        }

        if (Double.POSITIVE_INFINITY == newCost) {
            throw new Exception("failed to converge at iteration " + iterations + " with alpha "
                    + configuration.alpha + " : cost going from " + cost + " to " + newCost);
        } else if (iterations > 1
                && (newCost < configuration.threshold || iterations > configuration.maxIterations)) {
            cost = newCost;
            //                System.out.println("successfully converged after " + (iterations - 1) + " iterations (alpha:" + configuration.alpha + ",threshold:" + configuration.threshold + ") with cost " + newCost);
            break;
        } else if (Double.isNaN(newCost)) {
            throw new Exception("failed to converge at iteration " + iterations + " with alpha "
                    + configuration.alpha + " : cost calculation underflow");
        }

        // update registered cost
        cost = newCost;

        // calculate the derivatives to update the parameters

        RealMatrix dscores = probs.copy();
        dscores.walkInOptimizedOrder(new RealMatrixChangingVisitor() {
            @Override
            public void start(int rows, int columns, int startRow, int endRow, int startColumn, int endColumn) {

            }

            @Override
            public double visit(int row, int column, double value) {
                return (y.getEntry(row, column) == 1 ? (value - 1) : value) / samples.length;
            }

            @Override
            public double end() {
                return 0;
            }
        });

        // get derivative on second layer
        RealMatrix dW2 = hidden.transpose().multiply(dscores);

        // regularize dw2
        dW2.walkInOptimizedOrder(new RealMatrixChangingVisitor() {
            @Override
            public void start(int rows, int columns, int startRow, int endRow, int startColumn, int endColumn) {

            }

            @Override
            public double visit(int row, int column, double value) {
                return value + configuration.regularizationLambda * w1t.getEntry(row, column);
            }

            @Override
            public double end() {
                return 0;
            }
        });

        RealMatrix db2 = MatrixUtils.createRealMatrix(biases[1].getRowDimension(),
                biases[1].getColumnDimension());
        dscores.walkInOptimizedOrder(new RealMatrixPreservingVisitor() {
            @Override
            public void start(int rows, int columns, int startRow, int endRow, int startColumn, int endColumn) {

            }

            @Override
            public void visit(int row, int column, double value) {
                db2.setEntry(0, column, db2.getEntry(0, column) + value);
            }

            @Override
            public double end() {
                return 0;
            }
        });

        RealMatrix dhidden = dscores.multiply(weights[1]);
        dhidden.walkInOptimizedOrder(new RealMatrixChangingVisitor() {
            @Override
            public void start(int rows, int columns, int startRow, int endRow, int startColumn, int endColumn) {

            }

            @Override
            public double visit(int row, int column, double value) {
                return value < 0 ? 0 : value;
            }

            @Override
            public double end() {
                return 0;
            }
        });

        RealMatrix db = MatrixUtils.createRealMatrix(biases[0].getRowDimension(),
                biases[0].getColumnDimension());
        dhidden.walkInOptimizedOrder(new RealMatrixPreservingVisitor() {
            @Override
            public void start(int rows, int columns, int startRow, int endRow, int startColumn, int endColumn) {

            }

            @Override
            public void visit(int row, int column, double value) {
                db.setEntry(0, column, db.getEntry(0, column) + value);
            }

            @Override
            public double end() {
                return 0;
            }
        });

        // get derivative on first layer
        RealMatrix dW = x.transpose().multiply(dhidden);

        // regularize
        dW.walkInOptimizedOrder(new RealMatrixChangingVisitor() {
            @Override
            public void start(int rows, int columns, int startRow, int endRow, int startColumn, int endColumn) {

            }

            @Override
            public double visit(int row, int column, double value) {
                return value + configuration.regularizationLambda * w0t.getEntry(row, column);
            }

            @Override
            public double end() {
                return 0;
            }
        });

        RealMatrix dWt = dW.transpose();
        RealMatrix dWt2 = dW2.transpose();

        if (configuration.useNesterovMomentum) {

            // update nesterov momentum
            final RealMatrix vbPrev = vb.copy();
            final RealMatrix vb2Prev = vb2.copy();
            final RealMatrix vwPrev = vw.copy();
            final RealMatrix vw2Prev = vw2.copy();

            vb.walkInOptimizedOrder(new RealMatrixChangingVisitor() {
                @Override
                public void start(int rows, int columns, int startRow, int endRow, int startColumn,
                        int endColumn) {

                }

                @Override
                public double visit(int row, int column, double value) {
                    return configuration.mu * value - configuration.alpha * db.getEntry(row, column);
                }

                @Override
                public double end() {
                    return 0;
                }
            });

            vb2.walkInOptimizedOrder(new RealMatrixChangingVisitor() {
                @Override
                public void start(int rows, int columns, int startRow, int endRow, int startColumn,
                        int endColumn) {

                }

                @Override
                public double visit(int row, int column, double value) {
                    return configuration.mu * value - configuration.alpha * db2.getEntry(row, column);
                }

                @Override
                public double end() {
                    return 0;
                }
            });

            vw.walkInOptimizedOrder(new RealMatrixChangingVisitor() {
                @Override
                public void start(int rows, int columns, int startRow, int endRow, int startColumn,
                        int endColumn) {

                }

                @Override
                public double visit(int row, int column, double value) {
                    return configuration.mu * value - configuration.alpha * dWt.getEntry(row, column);
                }

                @Override
                public double end() {
                    return 0;
                }
            });

            vw2.walkInOptimizedOrder(new RealMatrixChangingVisitor() {
                @Override
                public void start(int rows, int columns, int startRow, int endRow, int startColumn,
                        int endColumn) {

                }

                @Override
                public double visit(int row, int column, double value) {
                    return configuration.mu * value - configuration.alpha * dWt2.getEntry(row, column);
                }

                @Override
                public double end() {
                    return 0;
                }
            });

            // update bias
            biases[0].walkInOptimizedOrder(new RealMatrixChangingVisitor() {
                @Override
                public void start(int rows, int columns, int startRow, int endRow, int startColumn,
                        int endColumn) {

                }

                @Override
                public double visit(int row, int column, double value) {
                    return value - configuration.mu * vbPrev.getEntry(row, column)
                            + (1 + configuration.mu) * vb.getEntry(row, column);
                }

                @Override
                public double end() {
                    return 0;
                }
            });

            biases[1].walkInOptimizedOrder(new RealMatrixChangingVisitor() {
                @Override
                public void start(int rows, int columns, int startRow, int endRow, int startColumn,
                        int endColumn) {

                }

                @Override
                public double visit(int row, int column, double value) {
                    return value - configuration.mu * vb2Prev.getEntry(row, column)
                            + (1 + configuration.mu) * vb2.getEntry(row, column);
                }

                @Override
                public double end() {
                    return 0;
                }
            });

            // update the weights
            weights[0].walkInOptimizedOrder(new RealMatrixChangingVisitor() {

                @Override
                public void start(int rows, int columns, int startRow, int endRow, int startColumn,
                        int endColumn) {

                }

                @Override
                public double visit(int row, int column, double value) {
                    return value - configuration.mu * vwPrev.getEntry(row, column)
                            + (1 + configuration.mu) * vw.getEntry(row, column);
                }

                @Override
                public double end() {
                    return 0;
                }
            });

            weights[1].walkInOptimizedOrder(new RealMatrixChangingVisitor() {

                @Override
                public void start(int rows, int columns, int startRow, int endRow, int startColumn,
                        int endColumn) {

                }

                @Override
                public double visit(int row, int column, double value) {
                    return value - configuration.mu * vw2Prev.getEntry(row, column)
                            + (1 + configuration.mu) * vw2.getEntry(row, column);
                }

                @Override
                public double end() {
                    return 0;
                }
            });
        } else if (configuration.useMomentum) {
            // update momentum
            vb.walkInOptimizedOrder(new RealMatrixChangingVisitor() {
                @Override
                public void start(int rows, int columns, int startRow, int endRow, int startColumn,
                        int endColumn) {

                }

                @Override
                public double visit(int row, int column, double value) {
                    return configuration.mu * value - configuration.alpha * db.getEntry(row, column);
                }

                @Override
                public double end() {
                    return 0;
                }
            });

            vb2.walkInOptimizedOrder(new RealMatrixChangingVisitor() {
                @Override
                public void start(int rows, int columns, int startRow, int endRow, int startColumn,
                        int endColumn) {

                }

                @Override
                public double visit(int row, int column, double value) {
                    return configuration.mu * value - configuration.alpha * db2.getEntry(row, column);
                }

                @Override
                public double end() {
                    return 0;
                }
            });

            vw.walkInOptimizedOrder(new RealMatrixChangingVisitor() {
                @Override
                public void start(int rows, int columns, int startRow, int endRow, int startColumn,
                        int endColumn) {

                }

                @Override
                public double visit(int row, int column, double value) {
                    return configuration.mu * value - configuration.alpha * dWt.getEntry(row, column);
                }

                @Override
                public double end() {
                    return 0;
                }
            });

            vw2.walkInOptimizedOrder(new RealMatrixChangingVisitor() {
                @Override
                public void start(int rows, int columns, int startRow, int endRow, int startColumn,
                        int endColumn) {

                }

                @Override
                public double visit(int row, int column, double value) {
                    return configuration.mu * value - configuration.alpha * dWt2.getEntry(row, column);
                }

                @Override
                public double end() {
                    return 0;
                }
            });

            // update bias
            biases[0].walkInOptimizedOrder(new RealMatrixChangingVisitor() {
                @Override
                public void start(int rows, int columns, int startRow, int endRow, int startColumn,
                        int endColumn) {

                }

                @Override
                public double visit(int row, int column, double value) {
                    return value + vb.getEntry(row, column);
                }

                @Override
                public double end() {
                    return 0;
                }
            });

            biases[1].walkInOptimizedOrder(new RealMatrixChangingVisitor() {
                @Override
                public void start(int rows, int columns, int startRow, int endRow, int startColumn,
                        int endColumn) {

                }

                @Override
                public double visit(int row, int column, double value) {
                    return value + vb2.getEntry(row, column);
                }

                @Override
                public double end() {
                    return 0;
                }
            });

            // update the weights
            weights[0].walkInOptimizedOrder(new RealMatrixChangingVisitor() {

                @Override
                public void start(int rows, int columns, int startRow, int endRow, int startColumn,
                        int endColumn) {

                }

                @Override
                public double visit(int row, int column, double value) {
                    return value + vw.getEntry(row, column);
                }

                @Override
                public double end() {
                    return 0;
                }
            });

            weights[1].walkInOptimizedOrder(new RealMatrixChangingVisitor() {

                @Override
                public void start(int rows, int columns, int startRow, int endRow, int startColumn,
                        int endColumn) {

                }

                @Override
                public double visit(int row, int column, double value) {
                    return value + vw2.getEntry(row, column);
                }

                @Override
                public double end() {
                    return 0;
                }
            });
        } else {
            // standard parameter update

            // update bias
            biases[0].walkInOptimizedOrder(new RealMatrixChangingVisitor() {
                @Override
                public void start(int rows, int columns, int startRow, int endRow, int startColumn,
                        int endColumn) {

                }

                @Override
                public double visit(int row, int column, double value) {
                    return value - configuration.alpha * db.getEntry(row, column);
                }

                @Override
                public double end() {
                    return 0;
                }
            });

            biases[1].walkInOptimizedOrder(new RealMatrixChangingVisitor() {
                @Override
                public void start(int rows, int columns, int startRow, int endRow, int startColumn,
                        int endColumn) {

                }

                @Override
                public double visit(int row, int column, double value) {
                    return value - configuration.alpha * db2.getEntry(row, column);
                }

                @Override
                public double end() {
                    return 0;
                }
            });

            // update the weights
            weights[0].walkInOptimizedOrder(new RealMatrixChangingVisitor() {

                @Override
                public void start(int rows, int columns, int startRow, int endRow, int startColumn,
                        int endColumn) {

                }

                @Override
                public double visit(int row, int column, double value) {
                    return value - configuration.alpha * dWt.getEntry(row, column);
                }

                @Override
                public double end() {
                    return 0;
                }
            });

            weights[1].walkInOptimizedOrder(new RealMatrixChangingVisitor() {

                @Override
                public void start(int rows, int columns, int startRow, int endRow, int startColumn,
                        int endColumn) {

                }

                @Override
                public double visit(int row, int column, double value) {
                    return value - configuration.alpha * dWt2.getEntry(row, column);
                }

                @Override
                public double end() {
                    return 0;
                }
            });
        }

        iterations++;
    }

    return cost;
}

From source file:org.lenskit.mf.BiasedMFItemScorerTest.java

@Before
public void createModel() {
    baseline = PrecomputedItemScorer.newBuilder().addScore(1, 42, 3.0).addScore(1, 39, 2.5).addScore(1, 25, 4.2)
            .addScore(5, 42, 3.7).addScore(5, 39, 2.8).addScore(3, 42, 2.2).addScore(3, 39, 3.2)
            .addScore(17, 42, 2.5).build();

    RealMatrix umat = MatrixUtils.createRealMatrix(3, 2);
    umat.setRow(0, new double[] { 0.1, 0.3 });
    umat.setRow(1, new double[] { -0.2, 0.2 });
    umat.setRow(2, new double[] { 0.0, 0.15 });
    HashKeyIndex uidx = new HashKeyIndex();
    uidx.internId(1);/*from  ww w  . ja va 2 s  .c  o m*/
    uidx.internId(5);
    uidx.internId(3);

    RealMatrix imat = MatrixUtils.createRealMatrix(2, 2);
    imat.setRow(0, new double[] { 0.52, 0.29 });
    imat.setRow(1, new double[] { 0.3, -1.2 });
    HashKeyIndex iidx = new HashKeyIndex();
    iidx.internId(42);
    iidx.internId(39);

    model = new MFModel(umat, imat, uidx, iidx);

    // scorer = new BiasedMFItemScorer(model, baseline);
}

From source file:org.lenskit.mf.svd.BiasedMFItemScorerTest.java

@Before
public void createModel() {
    baseline = PrecomputedItemScorer.newBuilder().addScore(1, 42, 3.0).addScore(1, 39, 2.5).addScore(1, 25, 4.2)
            .addScore(5, 42, 3.7).addScore(5, 39, 2.8).addScore(3, 42, 2.2).addScore(3, 39, 3.2)
            .addScore(17, 42, 2.5).build();

    RealMatrix umat = MatrixUtils.createRealMatrix(3, 2);
    umat.setRow(0, new double[] { 0.1, 0.3 });
    umat.setRow(1, new double[] { -0.2, 0.2 });
    umat.setRow(2, new double[] { 0.0, 0.15 });
    HashKeyIndex uidx = new HashKeyIndex();
    uidx.internId(1);//from   ww w . java 2  s .co m
    uidx.internId(5);
    uidx.internId(3);

    RealMatrix imat = MatrixUtils.createRealMatrix(2, 2);
    imat.setRow(0, new double[] { 0.52, 0.29 });
    imat.setRow(1, new double[] { 0.3, -1.2 });
    HashKeyIndex iidx = new HashKeyIndex();
    iidx.internId(42);
    iidx.internId(39);

    model = new MFModel(umat, imat, uidx, iidx);

    scorer = new BiasedMFItemScorer(model, new DotProductKernel(), baseline);
}

From source file:org.moeaframework.core.operator.real.AdaptiveMetropolisTest.java

/**
 * Returns the covariance matrix for the specified cluster.
 * /*  w  w w .  j  a  v a  2  s .com*/
 * @param cluster the cluster
 * @return the covariance matrix for the specified cluster
 */
private RealMatrix getCovariance(Cluster<ClusterablePoint> cluster) {
    List<ClusterablePoint> points = cluster.getPoints();
    RealMatrix rm = MatrixUtils.createRealMatrix(points.size(), 2);

    for (int i = 0; i < points.size(); i++) {
        rm.setRow(i, points.get(i).getPoint());
    }

    return new Covariance(rm).getCovarianceMatrix();
}

From source file:org.moeaframework.core.operator.real.AdaptiveMetropolisTest.java

/**
 * Returns the covariance matrix for the specified solutions.
 * /*from  ww  w .j a v a  2 s  .  c om*/
 * @param cluster the cluster
 * @param jumpRateCoefficient the jump rate coefficient
 * @return the covariance matrix for the specified solutions
 */
private RealMatrix getCovariance(Solution[] parents, double jumpRateCoefficient) {
    RealMatrix rm = MatrixUtils.createRealMatrix(parents.length, 2);

    for (int i = 0; i < parents.length; i++) {
        rm.setRow(i, EncodingUtils.getReal(parents[i]));
    }

    rm = rm.scalarMultiply(Math.pow(jumpRateCoefficient / Math.sqrt(2), 2.0));

    return new Covariance(rm).getCovarianceMatrix();
}