protected Vector4 GetReverseVector(HorizontalVector vector)
{
switch (vector)
{
case HorizontalVector.Left:
return(Vector4.Right);
case HorizontalVector.Right:
default:
return(Vector4.Left);
}
}
public int GetColumnNumber(Point3d point)
{
if (point.IsEqualTo(_insertPoint, Tolerance.Global))
{
return(0);
}
Vector3d vector = point - _insertPoint;
double xval = HorizontalVector.GetCos2d(vector) * vector.Length;
return((int)(xval / _horizontalStep));
}
/// <summary>
/// Calculates eigenvectors (loads) and the corresponding eigenvalues (scores)
/// by means of the NIPALS algorithm
/// </summary>
/// <param name="X">The matrix to which the decomposition is applied to. A row of the matrix is one spectrum (or a single measurement giving multiple resulting values). The different rows of the matrix represent
/// measurements under different conditions.</param>
/// <param name="numFactors">The number of factors to be calculated. If 0 is provided, factors are calculated until the provided accuracy is reached. </param>
/// <param name="accuracy">The relative residual variance that should be reached.</param>
/// <param name="factors">Resulting matrix of factors. You have to provide a extensible matrix of dimension(0,0) as the vertical score vectors are appended to the matrix.</param>
/// <param name="loads">Resulting matrix consiting of horizontal load vectors (eigenspectra). You have to provide a extensible matrix of dimension(0,0) here.</param>
/// <param name="residualVarianceVector">Residual variance. Element[0] is the original variance, element[1] the residual variance after the first factor subtracted and so on. You can provide null if you don't need this result.</param>
public static void NIPALS_HO(
IMatrix X,
int numFactors,
double accuracy,
IRightExtensibleMatrix factors,
IBottomExtensibleMatrix loads,
IBottomExtensibleMatrix residualVarianceVector)
{
// first center the matrix
//MatrixMath.ColumnsToZeroMean(X, null);
double originalVariance = Math.Sqrt(MatrixMath.SumOfSquares(X));
if(null!=residualVarianceVector)
residualVarianceVector.AppendBottom(new MatrixMath.Scalar(originalVariance));
IMatrix l = new HorizontalVector(X.Columns);
IMatrix t_prev = null;
IMatrix t = new VerticalVector(X.Rows);
int maxFactors = numFactors<=0 ? X.Columns : Math.Min(numFactors,X.Columns);
for(int nFactor=0; nFactor<maxFactors; nFactor++)
{
//l has to be a horizontal vector
// 1. Guess the transposed Vector l_transp, use first row of X matrix if it is not empty, otherwise the first non-empty row
int rowoffset=0;
do
{
Submatrix(X,l,rowoffset,0); // l is now a horizontal vector
rowoffset++;
} while(IsZeroMatrix(l) && rowoffset<X.Rows);
for(int iter=0;iter<500;iter++)
{
// 2. Calculate the new vector t for the factor values
MultiplySecondTransposed(X,l,t); // t = X*l_t (t is a vertical vector)
// Compare this with the previous one
if(t_prev!=null && IsEqual(t_prev,t,1E-9))
break;
// 3. Calculate the new loads
MultiplyFirstTransposed(t,X,l); // l = t_tr*X (gives a horizontal vector of load (= eigenvalue spectrum)
// normalize the (one) row
NormalizeRows(l); // normalize the eigenvector spectrum
// 4. Goto step 2 or break after a number of iterations
if(t_prev==null)
t_prev = new VerticalVector(X.Rows);
Copy(t,t_prev); // stores the content of t in t_prev
}
// Store factor and loads
factors.AppendRight(t);
loads.AppendBottom(l);
// 5. Calculate the residual matrix X = X - t*l
SubtractProductFromSelf(t,l,X); // X is now the residual matrix
// if the number of factors to calculate is not provided,
// calculate the norm of the residual matrix and compare with the original
// one
if(numFactors<=0 || null!=residualVarianceVector)
{
double residualVariance = Math.Sqrt(MatrixMath.SumOfSquares(X));
residualVarianceVector.AppendBottom(new MatrixMath.Scalar(residualVariance));
if(residualVariance<=accuracy*originalVariance)
{
break;
}
}
} // for all factors
} // end NIPALS
