Java Vector.assertDimensionalityEquals方法代码示例

import gov.sandia.cognition.math.matrix.Vector; //导入方法依赖的package包/类
@Override
final public void convertFromVector(
    final Vector v)
{
    v.assertDimensionalityEquals(this.getNumRows() * this.getNumColumns());

    final int numRows = this.getNumRows();
    final int numColumns = this.getNumColumns();
    for (int i = 0; i < numRows; ++i)
    {
        for (int j = 0; j < numColumns; ++j)
        {
            this.rows[i].values[j] = v.get(i + j
                * getNumRows());
        }
    }
}
 

import gov.sandia.cognition.math.matrix.Vector; //导入方法依赖的package包/类
/**
 * Creates a new instance of ContinuousDensityHiddenMarkovModel
 * @param initialProbability
 * Initial probability Vector over the states.  Each entry must be
 * nonnegative and the Vector must sum to 1.
 * @param transitionProbability
 * Transition probability matrix.  The entry (i,j) is the probability
 * of transition from state "j" to state "i".  As a corollary, all
 * entries in the Matrix must be nonnegative and the
 * columns of the Matrix must sum to 1.
 */
public MarkovChain(
    Vector initialProbability,
    Matrix transitionProbability )
{

    if( !transitionProbability.isSquare() )
    {
        throw new IllegalArgumentException(
            "transitionProbability must be square!" );
    }

    final int k = transitionProbability.getNumRows();
    initialProbability.assertDimensionalityEquals( k );

    this.setTransitionProbability(transitionProbability);
    this.setInitialProbability(initialProbability);

}
 

import gov.sandia.cognition.math.matrix.Vector; //导入方法依赖的package包/类
@Override
public void convertFromVector(
    final Vector parameters)
{
    parameters.assertDimensionalityEquals(2);
    final int a = (int) parameters.getElement(0);
    final int b = (int) parameters.getElement(1);

    this.setMinSupport(Math.min(a, b));
    this.setMaxSupport(Math.max(a, b));
}
 

import gov.sandia.cognition.math.matrix.Vector; //导入方法依赖的package包/类
@Override
public void convertFromVector(
    Vector parameters)
{
    final int num =
        this.getInputDimensionality() * this.getOutputDimensionality();
    parameters.assertDimensionalityEquals(num + this.getOutputDimensionality());
    Vector mp = parameters.subVector(0,num-1);
    Vector bp = parameters.subVector(num, num+this.getOutputDimensionality()-1);
    super.convertFromVector( mp );
    this.bias.convertFromVector(bp);
}
 

import gov.sandia.cognition.math.matrix.Vector; //导入方法依赖的package包/类
/**
 * {@inheritDoc}
 *
 * NOTE: Upon ocmpletion this is in the compressed Yale format.
 *
 * @param parameters {@inheritDoc}
 * @throws IllegalArgumentException if parameters does not have the same
 * number of elements as this's full size (including all of the zero
 * values).
 */
@Override
final public void convertFromVector(
    final Vector parameters)
{
    parameters.assertDimensionalityEquals(numRows * numCols);

    // Count how many non-zero elements there will be at the end
    int nnz = 0;
    final int d = parameters.getDimensionality();
    for (int i = 0; i < d; ++i)
    {
        if (parameters.get(i) != 0)
        {
            ++nnz;
        }
    }
    // Initialize the compressed Yale format
    firstIndicesForRows = new int[numRows + 1];
    columnIndices = new int[nnz];
    values = new double[nnz];
    int idx = 0;
    // Fill the data in
    for (int i = 0; i < numRows; ++i)
    {
        rows[i].clear();
        firstIndicesForRows[i] = idx;
        for (int j = 0; j < numCols; ++j)
        {
            double val = parameters.get(i + j * numRows);
            if (val != 0)
            {
                columnIndices[idx] = j;
                values[idx] = val;
                ++idx;
            }
        }
    }
    firstIndicesForRows[numRows] = idx;
}
 

import gov.sandia.cognition.math.matrix.Vector; //导入方法依赖的package包/类
/**
 * Helper method that handles all vector-on-the-right multiplies because we
 * depend on the vector dotProduct optimization here.
 *
 * @param vector The vector to multiply
 * @return The vector resulting from multiplying this * vector
 */
private Vector timesInternal(
    final Vector vector)
{
    vector.assertDimensionalityEquals(this.getNumColumns());
    
    final int numRows = this.getNumRows();
    DenseVector result = new DenseVector(numRows);
    for (int i = 0; i < numRows; ++i)
    {
        result.setElement(i, vector.dotProduct(rows[i]));
    }

    return result;
}
 

import gov.sandia.cognition.math.matrix.Vector; //导入方法依赖的package包/类
@Override
public void convertFromVector(
    final Vector parameters)
{
    parameters.assertDimensionalityEquals(2);
    this.setR( parameters.getElement(0) );
    this.setP( parameters.getElement(1) );
}
 

import gov.sandia.cognition.math.matrix.Vector; //导入方法依赖的package包/类
/**
 * Converts a vector into the index to select from the vector.
 *
 * @param   parameters
 *      The parameter vector. Must be of dimensionality one.
 */
@Override
public void convertFromVector(
    final Vector parameters)
{
    // The parameters must be of dimensionality 1.
    parameters.assertDimensionalityEquals(1);

    // Set the index.
    this.setIndex((int) parameters.getElement(0));
}
 

import gov.sandia.cognition.math.matrix.Vector; //导入方法依赖的package包/类
@Override
public void convertFromVector(
    final Vector parameters)
{
    parameters.assertDimensionalityEquals(1);
    this.setRate( parameters.getElement(0) );
}
 

import gov.sandia.cognition.math.matrix.Vector; //导入方法依赖的package包/类
@Override
public void convertFromVector(
    final Vector parameters)
{
    parameters.assertDimensionalityEquals(this.getParameterCount());
    final int d = this.getInputDimensionality();
    
    // Get the bias.
    this.setBias(parameters.getElement(0));
    
    int offset = 1;
    if (this.hasWeights())
    {
        // Set the weights.
        this.setWeights(parameters.subVector(offset, offset + d - 1));
        offset += d;
    }
    
    if (this.hasFactors())
    {
        final int factorCount = this.getFactorCount();
        
        // Extract the factors for each row.
        for (int k = 0; k < factorCount; k++)
        {
            this.factors.setRow(k, 
                parameters.subVector(offset, offset + d - 1));
            offset += d;
        }
    }
}
 

import gov.sandia.cognition.math.matrix.Vector; //导入方法依赖的package包/类
public void setValue(
    Vector value)
{
    value.assertDimensionalityEquals(2);
    double mean = value.getElement(0);
    double variance = value.getElement(1);
    this.conditionalDistribution.setMean(mean);
    this.conditionalDistribution.setVariance(variance);
}
 

import gov.sandia.cognition.math.matrix.Vector; //导入方法依赖的package包/类
@Override
public void convertFromVector(
    final Vector parameters)
{
    int p = this.getInputDimensionality();
    parameters.assertDimensionalityEquals( 1 + p*p );
    int dof = (int) Math.round(parameters.getElement(0));
    Vector matrix =
        parameters.subVector(1, parameters.getDimensionality()-1 );

    this.setDegreesOfFreedom(dof);
    this.getInverseScale().convertFromVector( matrix );
}
 

import gov.sandia.cognition.math.matrix.Vector; //导入方法依赖的package包/类
@Override
public void convertFromVector(
    Vector parameters)
{
    parameters.assertDimensionalityEquals(2);
    this.setShape( parameters.getElement(0) );
    this.setScale( parameters.getElement(1) );
}
 

import gov.sandia.cognition.math.matrix.Vector; //导入方法依赖的package包/类
@Override
public void convertFromVector(
    final Vector parameters)
{
    parameters.assertDimensionalityEquals(2);
    this.setAlpha( parameters.getElement(0) );
    this.setNumCustomers( (int) Math.round( parameters.getElement(1) ) );
}
 

import gov.sandia.cognition.math.matrix.Vector; //导入方法依赖的package包/类
@Override
public double logEvaluate(
    final Vector input)
{
    final int dim = this.getInputDimensionality();
    input.assertDimensionalityEquals(dim);
    final int ni = (int) Math.round( input.norm1() );
    final int N = this.getNumTrials();
    final double A = this.parameters.norm1();
    if( ni != N )
    {
        return Math.log(0.0);
    }

    double logSum = 0.0;
    logSum += Math.log(ni);
    logSum += MathUtil.logBetaFunction(A, ni);
    for( int i = 0; i < dim; i++ )
    {
        double pi = this.parameters.getElement(i);
        double xi = input.getElement(i);
        if( (pi > 0.0) && (xi > 0.0) )
        {
            logSum -= Math.log(xi);
            logSum -= MathUtil.logBetaFunction( pi, xi );
        }
    }
    return logSum;
}