Java Vector.unitVector方法代码示例

import gov.sandia.cognition.math.matrix.Vector; //导入方法依赖的package包/类
/**
 * Finds the eigenvalue associated with the given Matrix and eigenvector.
 * This is found by noting that the definition of an eigensystem is:
 * lamba*v=A*v.  Therefore, the absolute value of the eigenvalue will be 
 * norm2(A*v), but determining the sign of the eigenvalue takes some minor
 * computation (which we do, so this method works with negative
 * eigenvalues).
 *
 * @param A 
 * Matrix to estimate the eigenvalue of.  May have negative, repeated, 
 * positive, or zero eigenvalues
 * @param v 
 * Eigenvector associated with the unknown eigenvalue
 * @return 
 * Eigenvalue associated with the eigenvector and Matrix
 */
public static double estimateEigenvalue(
    final Matrix A,
    final Vector v )
{
    // Definition of eigenvalue/eigenvector: lamba*ei = A*ei
    Vector vunit = v.unitVector();
    Vector vlambda = A.times( vunit );
    double lambda = vlambda.norm2();

    if (lambda != 0.0)
    {
        Vector vunithat = vlambda.scale( 1.0 / lambda );
        double dp = vunithat.minus( vunit ).norm2();
        double dn = vunithat.plus( vunit ).norm2();
        if (dn < dp)
        {
            lambda *= -1.0;
        }
    }
    return lambda;
}
 

import gov.sandia.cognition.math.matrix.Vector; //导入方法依赖的package包/类
/**
 * Test of normalizeWeights method, of class UnitTermWeightNormalizer.
 */
@Test
public void testNormalizeWeights()
{
    Random random = new Random();
    UnitTermWeightNormalizer instance =
        new UnitTermWeightNormalizer();
    
    int dimensionality = 10;
    Vector weights = VectorFactory.getDefault().createUniformRandom(
        dimensionality, 0.0, 1.0, random);
    Vector expected = weights.unitVector();
    instance.normalizeWeights(weights, null, null);
    assertEquals(expected, weights);

    weights.zero();
    expected = weights.clone();
    instance.normalizeWeights(weights, null, null);
    assertEquals(expected, weights);

    weights.setElement(0, 1.0);
    expected = weights.clone();
    instance.normalizeWeights(weights, null, null);
    assertEquals(expected, weights);
}
 

import gov.sandia.cognition.math.matrix.Vector; //导入方法依赖的package包/类
/**
     * Estimates the eigenvector corresponding to the largest magnitude 
     * eigenvalue.  The eigenvector will be of unit length, unless the
     * input Matrix is all zeros, in which case the method will return
     * an all-zero Vector.  Please note that all eigenvectors are unique to
     * a direction.  That is, sometimes eigenvectors may be a scale factor 
     * of -1.0 to eigenvectors found by other approaches or initial conditions.
     * <BR><BR>
     * This method is appropriate for sparse matrix problems.
     * 
     * 
     * @return Eigenvector corresponding to the largest magnitude eigenvalue.
     * @param initial 
     * Initial estimate of the eigenvector. This is generally a uniform 
     * (constant nonzero) Vector.
     * @param A The matrix to estimate the eigenvectors for. It must be symmetric.
     *      It will be modified by the algorithm.
     * @param stoppingThreshold The stopping threshold for the power iteration algorithm. The 
     *      algorithm will stop its computation of an eigenvector when the
     * @param maxIterations The maximum number of iterations for the power iteration algorithm.
     */
// TODO: Implement the AnytimeAlgorithm interface here.  --krdixon, 2009-07-02
    public static Vector estimateEigenvector(
        final Vector initial,
        final Matrix A,
        final double stoppingThreshold,
        final int maxIterations )
    {
        // This is the brain-dead algorithm called "Power Iteration"
        Vector v = initial.unitVector();

        double normChange;
        int iteration = 0;
        boolean keepGoing = true;
        while (keepGoing)
        {
            final Vector vPrevious = v;
            v = A.times( v );
            v.unitVectorEquals();
            normChange = v.minus( vPrevious ).norm2();
            iteration++;

            if ((normChange <= stoppingThreshold) || (iteration >= maxIterations))
            {
                keepGoing = false;
            }
        }

        return v;
    }