Example usage for org.apache.commons.math3.linear RealVector subtract

List of usage examples for org.apache.commons.math3.linear RealVector subtract

Introduction

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

Prototype

public RealVector subtract(RealVector v) throws DimensionMismatchException 

Source Link

Document

Subtract v from this vector.

Usage

From source file:edu.oregonstate.eecs.mcplan.ml.ConstrainedKMeans.java

/**
 * @param args/*  w  ww .j a  v a  2  s . c om*/
 */
public static void main(final String[] args) {
    final RandomGenerator rng = new MersenneTwister(42);
    final int K = 2;
    final int d = 2;
    final ArrayList<RealVector> X = new ArrayList<RealVector>();
    final double u = 2.0;
    final double ell = 8.0;
    final double gamma = 10.0;

    for (final int s : new int[] { 0, 5, 10 }) {
        for (int x = -1; x <= 1; ++x) {
            for (int y = -1; y <= 1; ++y) {
                X.add(new ArrayRealVector(new double[] { x + s, y }));
            }
        }
    }

    final TIntObjectMap<Pair<int[], double[]>> M = new TIntObjectHashMap<Pair<int[], double[]>>();
    M.put(16, Pair.makePair(new int[] { 20 }, new double[] { 1.0 }));
    M.put(0, Pair.makePair(new int[] { 8 }, new double[] { 1.0 }));

    final TIntObjectMap<Pair<int[], double[]>> C = new TIntObjectHashMap<Pair<int[], double[]>>();
    C.put(13, Pair.makePair(new int[] { 20 }, new double[] { 1.0 }));
    C.put(10, Pair.makePair(new int[] { 16 }, new double[] { 1.0 }));

    final ArrayList<double[]> S = new ArrayList<double[]>();
    M.forEachKey(new TIntProcedure() {
        @Override
        public boolean execute(final int i) {
            final Pair<int[], double[]> p = M.get(i);
            if (p != null) {
                for (final int j : p.first) {
                    S.add(new double[] { i, j });
                }
            }
            return true;
        }
    });

    final ArrayList<double[]> D = new ArrayList<double[]>();
    C.forEachKey(new TIntProcedure() {
        @Override
        public boolean execute(final int i) {
            final Pair<int[], double[]> p = C.get(i);
            if (p != null) {
                for (final int j : p.first) {
                    D.add(new double[] { i, j });
                }
            }
            return true;
        }
    });

    final ConstrainedKMeans kmeans = new ConstrainedKMeans(K, d, X, M, C, rng) {
        RealMatrix A_ = MatrixUtils.createRealIdentityMatrix(d);
        double Dmax_ = 1.0;

        @Override
        public double distance(final RealVector x1, final RealVector x2) {
            final RealVector diff = x1.subtract(x2);
            return Math.sqrt(HilbertSpace.inner_prod(diff, A_, diff));
        }

        @Override
        public double distanceMax() {
            return Dmax_;
        }

        @Override
        protected void initializeDistanceFunction() {
            double max_distance = 0.0;
            for (int i = 0; i < X.size(); ++i) {
                for (int j = i + 1; j < X.size(); ++j) {
                    final double d = distance(X.get(i), X.get(j));
                    if (d > max_distance) {
                        max_distance = d;
                    }
                }
            }
            Dmax_ = max_distance;
        }

        @Override
        protected boolean updateDistanceFunction() {
            final InformationTheoreticMetricLearner itml = new InformationTheoreticMetricLearner(S, D, u, ell,
                    A_, gamma, rng_);
            itml.run();
            final double delta = A_.subtract(itml.A()).getFrobeniusNorm();
            A_ = itml.A();
            initializeDistanceFunction();
            return delta > convergence_tolerance_;
        }
    };

    kmeans.run();
    for (int i = 0; i < kmeans.mu().length; ++i) {
        System.out.println("Mu " + i + ": " + kmeans.mu()[i]);
        for (int j = 0; j < kmeans.assignments().length; ++j) {
            if (kmeans.assignments()[j] == i) {
                System.out.println("\tPoint " + X.get(j));
            }
        }
    }

}

From source file:hivemall.utils.math.StatsUtils.java

/**
 * @param mu1 mean vector of the first normal distribution
 * @param sigma1 covariance matrix of the first normal distribution
 * @param mu2 mean vector of the second normal distribution
 * @param sigma2 covariance matrix of the second normal distribution
 * @return the Hellinger distance between two multivariate normal distributions
 * @link https://en.wikipedia.org/wiki/Hellinger_distance#Examples
 *//*from  ww w .  j  av  a  2 s. c om*/
public static double hellingerDistance(@Nonnull final RealVector mu1, @Nonnull final RealMatrix sigma1,
        @Nonnull final RealVector mu2, @Nonnull final RealMatrix sigma2) {
    RealVector muSub = mu1.subtract(mu2);
    RealMatrix sigmaMean = sigma1.add(sigma2).scalarMultiply(0.5d);
    LUDecomposition LUsigmaMean = new LUDecomposition(sigmaMean);
    double denominator = Math.sqrt(LUsigmaMean.getDeterminant());
    if (denominator == 0.d) {
        return 1.d; // avoid divide by zero
    }
    RealMatrix sigmaMeanInv = LUsigmaMean.getSolver().getInverse(); // has inverse iff det != 0
    double sigma1Det = MatrixUtils.det(sigma1);
    double sigma2Det = MatrixUtils.det(sigma2);

    double numerator = Math.pow(sigma1Det, 0.25d) * Math.pow(sigma2Det, 0.25d)
            * Math.exp(-0.125d * sigmaMeanInv.preMultiply(muSub).dotProduct(muSub));
    return 1.d - numerator / denominator;
}

From source file:de.terministic.serein.core.genome.translators.LinearTranslator.java

public LinearTranslator(RealVector pointMin, RealVector pointMax) {
    origin = pointMin;
    distance = pointMax.subtract(pointMin);
}

From source file:com.cloudera.oryx.kmeans.computation.covariance.DistanceData.java

public double mahalanobisDistance(RealVector v) {
    RealVector d = v.subtract(means);
    return d.dotProduct(covInv.operate(d));
}

From source file:edu.oregonstate.eecs.mcplan.ml.RadialBasisFunctionKernel.java

@Override
public double apply(final RealVector x, final RealVector y) {
    final RealVector diff = x.subtract(y);
    final double sq_norm2 = diff.dotProduct(diff);
    return Math.exp(gamma_ * sq_norm2);
}

From source file:edu.oregonstate.eecs.mcplan.ml.MetricConstrainedKMeans.java

@Override
public double distance(final RealVector x1, final RealVector x2) {
    final RealVector diff = x1.subtract(x2);
    return Math.sqrt(HilbertSpace.inner_prod(diff, metric, diff));
}

From source file:edu.oregonstate.eecs.mcplan.ml.SequentialProjectionHashLearner.java

@Override
public long hash(final RealVector x) {
    assert (K <= 64);
    long h = 0L;//from   w  w  w.  j  ava 2  s .c o  m
    long shift = 1;
    final RealVector centered = x.subtract(b);
    for (int k = 0; k < K; ++k) {
        final double hk = Math.signum(W.get(k).dotProduct(centered));
        if (hk > 0) {
            h |= shift;
        }
        shift <<= 1;
    }
    return h;
}

From source file:com.analog.lyric.dimple.solvers.sumproduct.customFactors.CustomComplexGaussianPolynomial.java

private Object[] calculateWeightedSums(Complex[] in) {

    double[] means = new double[] { 0, 0 };

    for (int i = 0; i < in.length; i++) {
        means[0] += in[i].getReal();/*from  w ww  .j  a v  a2 s .c  o m*/
        means[1] += in[i].getImaginary();
    }
    means[0] /= in.length;
    means[1] /= in.length;

    RealMatrix cm = createRealMatrix(2, 2);
    RealVector mm = wrapRealVector(means);

    for (int i = 0; i < in.length; i++) {
        RealVector m = createRealVector(new double[] { in[i].getReal(), in[i].getImaginary() });
        RealVector m2 = m.subtract(mm);
        cm = cm.add(m2.outerProduct(m2));
    }

    cm = cm.scalarMultiply(1.0 / in.length);

    return new Object[] { new Complex(means[0], means[1]), matrixGetDataRef(cm) };

}

From source file:com.joptimizer.algebra.CholeskySparseFactorizationTest.java

/**
 * Tests vector and matrix solve method.
 *//*from  w w  w.j a v a 2 s . co  m*/
public void testFromFile3() throws Exception {
    log.debug("testFromFile3");
    String matrixId = "3";
    double[][] G = Utils
            .loadDoubleMatrixFromFile("factorization" + File.separator + "matrix" + matrixId + ".csv");
    RealMatrix Q = MatrixUtils.createRealMatrix(G);
    int dim = Q.getRowDimension();

    CholeskySparseFactorization myc = new CholeskySparseFactorization(new SparseDoubleMatrix2D(G));
    myc.factorize();

    //solve for a vector
    RealVector b = new ArrayRealVector(Utils.randomValuesVector(dim, -0.5, 0.5, new Long(dim)).toArray());
    RealVector x = new ArrayRealVector(myc.solve(F1.make(b.toArray())).toArray());

    //b - Q.x
    double n1 = b.subtract(Q.operate(x)).getNorm();
    double sr1 = Utils.calculateScaledResidual(G, x.toArray(), b.toArray());
    log.debug("||b - Q.x||: " + n1);
    log.debug("scaled res : " + sr1);
    assertTrue(n1 < 1.E-8);
    assertTrue(sr1 < Utils.getDoubleMachineEpsilon());

    //solve for a matrix
    RealMatrix B = new Array2DRowRealMatrix(
            Utils.randomValuesMatrix(dim, 10, -0.5, 0.5, new Long(dim)).toArray());
    RealMatrix X = new Array2DRowRealMatrix(myc.solve(F2.make(B.getData())).toArray());

    //B - Q.X
    double n2 = B.subtract(Q.multiply(X)).getNorm();
    double sr2 = Utils.calculateScaledResidual(G, X.getData(), B.getData());
    log.debug("||B - Q.X||: " + n2);
    log.debug("scaled res : " + sr2);
    assertTrue(n2 < 1.E-8);
    assertTrue(sr2 < Utils.getDoubleMachineEpsilon());
}

From source file:com.github.thorbenlindhauer.factor.CanonicalGaussianFactor.java

@Override
public GaussianFactor observation(Scope observationScope, double[] values) {
    if (observationScope.getVariables().size() != values.length) {
        throw new ModelStructureException("Observed variables and values do not match");
    }/*from www  . j av a 2 s  . c  o m*/

    if (scope.intersect(observationScope).isEmpty()) {
        return this;
    }

    RealVector observationVector = new ArrayRealVector(values);

    Scope newScope = scope.reduceBy(observationScope);

    // reduce K matrix to values that are in the scope to keep
    int[] scopeMapping = newScope.createContinuousVariableMapping(this.scope);
    RealMatrix scopeValuesMatrix = precisionMatrix.getSubMatrix(scopeMapping, scopeMapping);

    int[] observationScopeMapping = observationScope.createContinuousVariableMapping(this.scope);
    // xyMatrix
    RealMatrix scopeObservationMatrix = precisionMatrix.getSubMatrix(scopeMapping, observationScopeMapping);

    // h_x
    RealVector scopeMeanVector = getSubVector(scaledMeanVector, scopeMapping);
    RealVector newMeanVector = scopeMeanVector.subtract(scopeObservationMatrix.operate(observationVector));

    // g
    RealVector observationMeanVector = getSubVector(scaledMeanVector, observationScopeMapping);
    RealMatrix observationMatrix = precisionMatrix.getSubMatrix(observationScopeMapping,
            observationScopeMapping);
    double newNormalizationConstant = normalizationConstant
            + observationMeanVector.dotProduct(observationVector)
            - 0.5d * (observationVector.dotProduct(observationMatrix.operate(observationVector)));

    return new CanonicalGaussianFactor(newScope, scopeValuesMatrix, newMeanVector, newNormalizationConstant);
}