Java RealVector类代码示例

import org.apache.commons.math.linear.RealVector; //导入依赖的package包/类
public double[] createAvgProductVector(List<Long> recentitemInteractions,Map<Long,float[]> productFeatures)
  {
  	int numLatentFactors = productFeatures.values().iterator().next().length;
  	double[] userFeatures = new double[numLatentFactors];
  	for (Long item : recentitemInteractions) 
{
  		float[] productFactors = productFeatures.get(item);
  		if (productFactors != null)
  		{
  			for (int feature = 0; feature < numLatentFactors; feature++) 
  			{
  				userFeatures[feature] += productFactors[feature];
  			}
  		}
}
  	RealVector  userFeaturesAsVector = new ArrayRealVector(userFeatures);
  	RealVector normalised =  userFeaturesAsVector.mapDivide(userFeaturesAsVector.getL1Norm());

  	return normalised.getData();
  }
 

import org.apache.commons.math.linear.RealVector; //导入依赖的package包/类
/**
 * Verifies that setting X, Y and covariance separately has the same effect as newSample(X,Y,cov).
 */
@Test
public void testNewSample2() throws Exception {
    double[] y = new double[] {1, 2, 3, 4}; 
    double[][] x = new double[][] {
      {19, 22, 33},
      {20, 30, 40},
      {25, 35, 45},
      {27, 37, 47}   
    };
    double[][] covariance = MatrixUtils.createRealIdentityMatrix(4).scalarMultiply(2).getData();
    GLSMultipleLinearRegression regression = new GLSMultipleLinearRegression();
    regression.newSampleData(y, x, covariance);
    RealMatrix combinedX = regression.X.copy();
    RealVector combinedY = regression.Y.copy();
    RealMatrix combinedCovInv = regression.getOmegaInverse();
    regression.newXSampleData(x);
    regression.newYSampleData(y);
    assertEquals(combinedX, regression.X);
    assertEquals(combinedY, regression.Y);
    assertEquals(combinedCovInv, regression.getOmegaInverse());
}
 

import org.apache.commons.math.linear.RealVector; //导入依赖的package包/类
/**
 * Converts a test string to a {@link LinearConstraint}.
 * Ex: x0 + x1 + x2 + x3 - x12 = 0
 */
private LinearConstraint equationFromString(int numCoefficients, String s) {
    Relationship relationship;
    if (s.contains(">=")) {
        relationship = Relationship.GEQ;
    } else if (s.contains("<=")) {
        relationship = Relationship.LEQ;
    } else if (s.contains("=")) {
        relationship = Relationship.EQ;
    } else {
        throw new IllegalArgumentException();
    }

    String[] equationParts = s.split("[>|<]?=");
    double rhs = Double.parseDouble(equationParts[1].trim());

    RealVector lhs = new ArrayRealVector(numCoefficients);
    String left = equationParts[0].replaceAll(" ?x", "");
    String[] coefficients = left.split(" ");
    for (String coefficient : coefficients) {
        double value = coefficient.charAt(0) == '-' ? -1 : 1;
        int index = Integer.parseInt(coefficient.replaceFirst("[+|-]", "").trim());
        lhs.setEntry(index, value);
    }
    return new LinearConstraint(lhs, relationship, rhs);
}
 

import org.apache.commons.math.linear.RealVector; //导入依赖的package包/类
public static double cosine(RealVector vec1, RealVector vec2) throws Exception
{
    final double norm1 = vec1.getNorm();
    final double norm2 = vec2.getNorm();

    if (norm1 == 0 || norm2 == 0) 
        throw new Exception("Division by zero");
    return vec1.dotProduct(vec2) / (norm1 * norm2);
}
 

import org.apache.commons.math.linear.RealVector; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
@Override
public double getInnerProduct(final Matrix<?> m1, final Matrix<?> m2) {
  Validate.notNull(m1, "m1");
  Validate.notNull(m2, "m2");
  if (m1 instanceof DoubleMatrix1D && m2 instanceof DoubleMatrix1D) {
    final RealVector t1 = CommonsMathWrapper.wrap((DoubleMatrix1D) m1);
    final RealVector t2 = CommonsMathWrapper.wrap((DoubleMatrix1D) m2);
    return t1.dotProduct(t2);
  }
  throw new IllegalArgumentException("Can only find inner product of DoubleMatrix1D; have " + m1.getClass() + " and " + m2.getClass());
}
 

import org.apache.commons.math.linear.RealVector; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
@Override
public DoubleMatrix2D getOuterProduct(final Matrix<?> m1, final Matrix<?> m2) {
  Validate.notNull(m1, "m1");
  Validate.notNull(m2, "m2");
  if (m1 instanceof DoubleMatrix1D && m2 instanceof DoubleMatrix1D) {
    final RealVector t1 = CommonsMathWrapper.wrap((DoubleMatrix1D) m1);
    final RealVector t2 = CommonsMathWrapper.wrap((DoubleMatrix1D) m2);
    return CommonsMathWrapper.unwrap(t1.outerProduct(t2));
  }
  throw new IllegalArgumentException("Can only find outer product of DoubleMatrix1D; have " + m1.getClass() + " and " + m2.getClass());
}
 

import org.apache.commons.math.linear.RealVector; //导入依赖的package包/类
private void assertRealVectorEquals(final RealVector v1, final DoubleMatrix1D v2) {
  final int n = v1.getDimension();
  assertEquals(n, v2.getNumberOfElements());
  for (int i = 0; i < n; i++) {
    assertEquals(v1.getEntry(i), v2.getEntry(i), EPS);
  }
}
 

import org.apache.commons.math.linear.RealVector; //导入依赖的package包/类
/**
 * 
 * Computes useful statistics for the vector on the non-zero elements only.
 * These include the average, the absolute value average, positive values only average, 
 * negative values only average, max positive value, max negative value, num of positive values,
 * num of negative values, sparsity, L1-norm, count
 * @return 
 */
@Override
public double[] vecStatsNonZeros()
{
    double sumNonZero = 0;
    double positiveSum = 0, negativeSum = 0, minNegative = 0, maxPositive = 0;
    int counter = 0, positiveCounter = 0, negativeCounter = 0;
    double l1Norm = 0;
    for(Iterator<RealVector.Entry> it = counts.sparseIterator(); it.hasNext();)
    {
        double value = it.next().getValue();
        sumNonZero += value;
        l1Norm += Math.abs(value);
        if(value > 0)
        {
            positiveSum += value;
            positiveCounter++;
            if(value > maxPositive)
                maxPositive = value;
        }
        else
        {
            negativeSum += value;
            negativeCounter++;
            if(value < minNegative)
                minNegative = value;
        }
        counter++;
    }
    return new double[] {sumNonZero / (double) counter, l1Norm / (double) counter, 
        positiveSum / (double) positiveCounter, negativeSum / (double) negativeCounter,
        maxPositive, minNegative, 
        (double) counter / (double) size(), l1Norm, positiveCounter, negativeCounter, counter};
}
 

import org.apache.commons.math.linear.RealVector; //导入依赖的package包/类
/**
 * Get the -1 times the sum of all coefficients in the given array.
 * @param coefficients coefficients to sum
 * @return the -1 times the sum of all coefficients in the given array.
 */
protected static double getInvertedCoeffiecientSum(final RealVector coefficients) {
    double sum = 0;
    for (double coefficient : coefficients.getData()) {
        sum -= coefficient;
    }
    return sum;
}
 

import org.apache.commons.math.linear.RealVector; //导入依赖的package包/类
/** test eigenvectors */
public void testEigenvectors() {
    EigenDecomposition ed = new EigenDecompositionImpl(matrix, MathUtils.SAFE_MIN);
    for (int i = 0; i < matrix.getRowDimension(); ++i) {
        double lambda = ed.getRealEigenvalue(i);
        RealVector v  = ed.getEigenvector(i);
        RealVector mV = matrix.operate(v);
        assertEquals(0, mV.subtract(v.mapMultiplyToSelf(lambda)).getNorm(), 1.0e-13);
    }
}
 

import org.apache.commons.math.linear.RealVector; //导入依赖的package包/类
/**
 * Calculates beta by GLS.
 * <pre>
 *  b=(X' Omega^-1 X)^-1X'Omega^-1 y
 * </pre>
 * @return beta
 */
@Override
protected RealVector calculateBeta() {
    RealMatrix OI = getOmegaInverse();
    RealMatrix XT = X.transpose();
    RealMatrix XTOIX = XT.multiply(OI).multiply(X);
    RealMatrix inverse = new LUDecompositionImpl(XTOIX).getSolver().getInverse();
    return inverse.multiply(XT).multiply(OI).operate(Y);
}
 

import org.apache.commons.math.linear.RealVector; //导入依赖的package包/类
public RealVector getObsPoint() {
if (hemisphere) {
    return new ArrayRealVector(new double[] { 0, 0, 1 });
} else {
    return new ArrayRealVector(new double[] { 0, 0, -1 });
}
   }
 

import org.apache.commons.math.linear.RealVector; //导入依赖的package包/类
/**
 * Store the illumination and index of the brightest sample.
 * @param illuminationFromSample illumination received from sample
 * @param sample current sample illuminating the element
 */
void store(final double illuminationFromSample,
           final Map.Entry<RealVector, Double> sample) {
    if (illuminationFromSample > this.brightestIllumination) {
        this.brightestIllumination = illuminationFromSample;
        this.brightestSample = sample;
    }
}
 

import org.apache.commons.math.linear.RealVector; //导入依赖的package包/类
/**
 * Compute the LSH for a given vector.
 */
public long apply(RealVector vector)
{
  /*
   * The hash is just floor(<v, a>/w)
   */
   double ret = b;
  
   for(int i = 0;i < dim;++i)
   {
      ret += vector.getEntry(i)*a[i];
   }
   return (long)Math.floor(ret/w);
}
 

import org.apache.commons.math.linear.RealVector; //导入依赖的package包/类
/**
 * Verifies that setting X and Y separately has the same effect as newSample(X,Y).
 */
@Test
public void testNewSample2() throws Exception {
    double[] y = new double[] {1, 2, 3, 4}; 
    double[][] x = new double[][] {
      {19, 22, 33},
      {20, 30, 40},
      {25, 35, 45},
      {27, 37, 47}   
    };
    OLSMultipleLinearRegression regression = new OLSMultipleLinearRegression();
    regression.newSampleData(y, x);
    RealMatrix combinedX = regression.X.copy();
    RealVector combinedY = regression.Y.copy();
    regression.newXSampleData(x);
    regression.newYSampleData(y);
    assertEquals(combinedX, regression.X);
    assertEquals(combinedY, regression.Y);
    
    // No intercept
    regression.setNoIntercept(true);
    regression.newSampleData(y, x);
    combinedX = regression.X.copy();
    combinedY = regression.Y.copy();
    regression.newXSampleData(x);
    regression.newYSampleData(y);
    assertEquals(combinedX, regression.X);
    assertEquals(combinedY, regression.Y);
}