@datagrok/eda 1.0.3

package/wasm/PCA/PCA.cpp

@@ -0,0 +1,151 @@
+// PCA.cpp
+// Principal Component Analysis using the lib Eigen: implementations of functions
+
+#include "../../../../../Eigen/Eigen/Dense"
+using namespace Eigen;
+
+#include "PCA.h"
+using pca::Float;
+using pca::Integer;
+using pca::Double;
+
+/* Principal Component Analysis of the data: using correlation matrix.
+     data - input matrix;
+     height, width - sizes of the input;
+     numOfPrincipalComponents - number of principal components to be computed;
+     principalComponents - the principal components computed;
+	 approxData - approximation of the input data using principal components obtained.  */
+int pca::pcaUsingCorrelationMatrix(Float * data,
+	const int height,
+	const int width,
+	const int numOfPrincipalComponents,
+	const int centerNum,
+	const int scaleNum,
+	Float * principalComponents,
+	Float * approxData) noexcept
+{
+	/* Here, we use a MODIFICATION of the algorithm given in 
+	   Charu C. Aggarwal. Data Mining: The Textbook. Springer, 2015,
+	   (see page 42). */
+
+	// check number of principal components
+	if (height < numOfPrincipalComponents || numOfPrincipalComponents < 1)
+		return UNCORRECT_ARGUMENTS_ERROR;
+
+	// assign data and Eigen matrix
+	Map< Matrix<Float, Dynamic, Dynamic, RowMajor> > dataMatrix(data, height, width);
+
+	Vector<Float, Dynamic> means = dataMatrix.rowwise().mean();		
+
+	if (centerNum != 0)		
+		dataMatrix = dataMatrix.colwise() - means;
+
+	if (scaleNum != 0)
+	    dataMatrix = dataMatrix.rowwise().normalized() * sqrt(height);
+	
+	Matrix<Float, Dynamic, Dynamic>	corMatrix = dataMatrix * dataMatrix.transpose();	
+
+	// The following solver computes eigen vals & vectors: the order of eigen vals is increasing.
+	SelfAdjointEigenSolver<Matrix<Float, Dynamic, Dynamic>> eigensolver(corMatrix);
+
+	// Check result of eigen values & vectors computation.
+	if (eigensolver.info() != Success)
+		return COMPUTATION_ERROR;
+
+	// Check order of computed eigen values: increasing order is expected
+	Vector<Float, Dynamic> eigenVals = eigensolver.eigenvalues();
+	for(int i = 1; i < eigenVals.size(); i++)
+	    if(eigenVals(i - 1) > eigenVals(i))
+		    return METHOD_ERROR;
+	
+	// get feature vectors, taking into account increasing order of computed eigen values
+	Matrix<Float, Dynamic, Dynamic, ColMajor> featureVectors
+		= (eigensolver.eigenvectors().rowwise().reverse())(all, seq(0, numOfPrincipalComponents - 1));
+
+	// assign principal components and Eigen matrix
+	Map< Matrix<Float, Dynamic, Dynamic, RowMajor> > 
+	     princCompMatrix(principalComponents, numOfPrincipalComponents, width);
+
+	princCompMatrix = featureVectors.transpose() * dataMatrix; 
+
+	// computation of approximation
+	if (approxData != NULL)
+	{
+		// assign data and Eigen matrix
+		Map< Matrix<Float, Dynamic, Dynamic, RowMajor> > approxMatrix(approxData, height, width);
+
+		approxMatrix = (featureVectors * princCompMatrix).colwise() + means;
+	}	
+
+	return NO_ERROR;
+} // pcaUsingCorrelationMatrix
+
+/*{
+	// Here, we use a MODIFICATION of the algorithm given in 
+	// Charu C. Aggarwal. Data Mining: The Textbook. Springer, 2015,
+	// (see page 42). 
+
+	// check number of principal components
+	if (height < numOfPrincipalComponents || numOfPrincipalComponents < 1)
+		return UNCORRECT_ARGUMENTS_ERROR;
+
+	// assign data and Eigen matrix
+	Map< Matrix<Float, Dynamic, Dynamic, RowMajor> > dataMatrix(data, height, width);
+	
+	Vector<Float, Dynamic> means = dataMatrix.rowwise().mean();
+
+	Matrix<Float, Dynamic, Dynamic> corMatrix 
+		= dataMatrix * dataMatrix.transpose() / width - means * means.transpose();
+
+	// The following solver computes eigen vals & vectors: the order of eigen vals is increasing.
+	SelfAdjointEigenSolver<Matrix<Float, Dynamic, Dynamic>> eigensolver(corMatrix);
+
+	// Check result of eigen values & vectors computation.
+	if (eigensolver.info() != Success)
+		return COMPUTATION_ERROR;
+
+	// Check order of computed eigen values: increasing order is expected
+	Vector<Float, Dynamic> eigenVals = eigensolver.eigenvalues();
+	for(int i = 1; i < eigenVals.size(); i++)
+	    if(eigenVals(i - 1) > eigenVals(i))
+		    return METHOD_ERROR;
+	
+	// get feature vectors, taking into account increasing order of computed eigen values
+	Matrix<Float, Dynamic, Dynamic, ColMajor> featureVectors
+		= (eigensolver.eigenvectors().rowwise().reverse())(all, seq(0, numOfPrincipalComponents - 1));
+
+	// assign principal components and Eigen matrix
+	Map< Matrix<Float, Dynamic, Dynamic, RowMajor> > 
+	     princCompMatrix(principalComponents, numOfPrincipalComponents, width);
+
+	// compute principal componets
+	princCompMatrix = featureVectors.transpose() * (dataMatrix.colwise() - means);
+
+	// computation of approximation
+	if (approxData != NULL)
+	{
+		// assign data and Eigen matrix
+		Map< Matrix<Float, Dynamic, Dynamic, RowMajor> > approxMatrix(approxData, height, width);
+
+		approxMatrix = (featureVectors * princCompMatrix).colwise() + means;
+	}	
+
+	return NO_ERROR;
+} */
+
+// Maximum absolute deviation between arrays
+Float pca::mad(Float * arr1, Float * arr2, const int length) noexcept
+{
+	// Solution using Eigen: nice, but additional structures are created! 
+	/*Map<Vector<Float, Dynamic>> vec1(arr1, length);
+	Map<Vector<Float, Dynamic>> vec2(arr2, length);
+	return ((vec1 - vec2).cwiseAbs()).maxCoeff();*/
+
+	// Naive solution
+	Float result = fabs(arr1[0] - arr2[0]);
+
+	for (int i = 1; i < length; i++)
+		result = fmax(result, fabs(arr1[i] - arr2[i]));
+
+	return result;
+}

package/wasm/PCA/PCA.h

@@ -0,0 +1,48 @@
+// PCA.h
+// Principal Component Analysis (PCA) using the lib Eigen: headers of functions
+
+// REMARK 1. Each row of the input data contains Datagrok column. 
+//           For this reason, the following convention is used:
+//             -  height is a number of Datagrok columns to be processed,
+//             -  width is a number of each Datagrok column.
+
+// REMARK 2. Here, we operate matrices that have float rows and integer rows, 
+//           each row contains values of the same type.
+//           Each matrix consists of two blocks: float rows and integer rows.
+//           In this case, an input is void **.
+
+// RMEARK 3. Also, the same methods are implemented for the case when data is
+//           given by float *.
+
+#ifndef PCA_H
+#define PCA_H
+
+namespace pca {
+
+	typedef float Float;
+	typedef int Integer;
+	typedef double Double;
+
+	enum ResultCode {NO_ERROR = 0, UNCORRECT_ARGUMENTS_ERROR, COMPUTATION_ERROR, METHOD_ERROR};
+
+	/* Principal Component Analysis of the data: using correlation matrix.
+	     data - input matrix;
+	     height, width - sizes of the input;
+	     numOfPrincipalComponents - number of principal components to be computed;
+	     principalComponents - the principal components computed;
+		 approxData - approximation of the input data using principal components obtained.  */
+	int pcaUsingCorrelationMatrix(Float * data,
+		const int height,
+		const int width,
+		const int numOfPrincipalComponents,
+		const int centerNum,
+		const int scaleNum,
+		Float * principalComponents,
+		Float * approxData = 0) noexcept;	
+
+	// Maximum absolute deviation between arrays
+	Float mad(Float * arr1, Float * arr2, const int length) noexcept;
+};
+
+#endif // PCA_H
+

package/wasm/PLS/PLS.h

@@ -0,0 +1,64 @@
+// PLS.h
+// Declarations of functions that provides Partial Least Square (PLS) Regression.
+
+// An implementation of the algorithm PLS1 without X-deflation is used.
+// Source paper: Ulf G. Indahl, The geometry of PLS1 explained properly: 
+//               10 key notes on mathematical properties of and some alternative 
+//               algorithmic approaches to PLS1 modelling, DOI: https://doi.org/10.1002/cem.2589
+// Also, the following aricle is used: https://doi.org/10.1016/S0169-7439(01)00155-1
+
+#ifndef PLS_H
+#define PLS_H
+
+namespace pls {
+
+	typedef float Float;	
+	typedef double Double;
+
+	enum ResultCode { NO_ERROR = 0, UNCORRECT_ARGUMENTS_ERROR, COMPUTATION_ERROR, METHOD_ERROR };
+
+	/* Partial Least Square (PLS1).
+	      predictorColumnsDataPtr - data from columns that are used for prediction
+		  rowCount - number of rows
+		  columnCount - number of columns
+		  responseColumnDataPtr - data from column that is predicted, i.e. responce
+		  componentsCount - number of components that extracted in PLS
+		  predictionDataPtr - prediction obtained using PLS (its size is equal to the size of responce)
+		  regressionCoefficients - coeffcient of linear regression that are computed (their size is eqaul to the number of columns)
+	*/
+	int partialLeastSquare(Float * predictorColumnsDataPtr,
+		const int rowCount,
+		const int columnCount,
+		Float * responseColumnDataPtr,
+		const int componentsCount,
+		Float * predictionDataPtr,
+		Float * regressionCoefficients) noexcept;	
+
+
+	/* Partial Least Square (PLS1) - extended version: scores data is provided.
+	      predictorColumnsDataPtr - data from columns that are used for prediction (X)
+	      rowCount - number of rows
+	      columnCount - number of columns
+	      responseColumnDataPtr - data from column that is predicted, i.e. responce (Y)
+	      componentsCount - number of components that extracted in PLS (A)
+	      predictionDataPtr - prediction obtained using PLS (its size is equal to the size of responce)
+	      regressionCoefficientsPtr - coeffcient of linear regression that are computed (their size is eqaul to the number of columns) (b)
+		  predictorScoresPtr - scores of predectors (T)
+		  responceScoresPtr - scores of response (U)
+		  predictorLoadingsPtr - loadings of predictors (P)
+	*/
+	int partialLeastSquareExtended(Float * predictorColumnsDataPtr,
+		const int rowCount,
+		const int columnCount,
+		Float * responseColumnDataPtr,
+		const int componentsCount,
+		Float * predictionDataPtr,
+		Float * regressionCoefficientsPtr,
+		Float * predictorScoresPtr,
+		Float * responceScoresPtr,
+	    Float * predictorLoadingsPtr) noexcept;	
+};
+
+#endif
+
+

package/wasm/PLS/pls.cpp

@@ -0,0 +1,393 @@
+// pls.cpp
+// Principal Component Analysis (PCA) using the lib Eigen: implementation of functions
+
+// The following STL lib is used for printing results and their verifying
+//#include<iostream>
+//using namespace std;
+
+#include "../../../../../Eigen/Eigen/Dense"
+using namespace Eigen;
+
+#include "PLS.h"
+using pls::Float;
+using pls::Double;
+
+  /* Partial Least Square (PLS1).
+  predictorColumnsDataPtr - data from columns that are used for prediction
+  rowCount - number of rows
+  columnCount - number of columns
+  responseColumnDataPtr - data from column that is predicted, i.e. responce
+  componentsCount - number of components that extracted in PLS
+  predictionDataPtr - prediction obtained using PLS (its size is equal to the size of responce)
+  regressionCoefficients - coeffcient of linear regression that are computed (their size is eqaul to the number of columns)
+  */
+int pls::partialLeastSquare(Float * predictorColumnsDataPtr,
+	const int rowCount,
+	const int columnCount,
+	Float * responseColumnDataPtr,
+	const int componentsCount,
+	Float * predictionDataPtr,
+	Float * regressionCoefficients) noexcept
+{
+	// check correctness of arguments
+	if (componentsCount <= 0 || componentsCount > columnCount)
+		return UNCORRECT_ARGUMENTS_ERROR;
+
+	// Further, notation from the paper https://doi.org/10.1002/cem.2589 is used (see Algorithm 2).
+
+	// create matrix, which is associated with predictor data
+	Map < Matrix<Float, Dynamic, Dynamic, ColMajor>> D(predictorColumnsDataPtr, rowCount, columnCount);
+
+	// compute mean value of each column of D
+	Vector<Float, Dynamic> mu = D.colwise().mean();
+
+	// mean-centered version of D
+	Matrix<Float, Dynamic, Dynamic, ColMajor> X = D.rowwise() - mu.transpose();
+
+    // vector for standard deviations of X
+	Vector<Float, Dynamic> stdDevX(columnCount);
+	
+	Float rowCountSqrt = sqrt(static_cast<Float>(rowCount));
+
+    // normilizing X-columns
+	for (int i = 0; i < columnCount; i++)
+	{
+		stdDevX(i) = X.col(i).norm() / rowCountSqrt;
+		X.col(i) = X.col(i) / stdDevX(i);		
+	}	
+
+	// create a vector, which is associated with responce or predicted data 
+	Map<Vector<Float, Dynamic>> ySource(responseColumnDataPtr, rowCount);		
+
+    // mean value of the responce
+	Vector<Float, 1> meanY;
+	meanY(0) = ySource.mean();		
+
+    // mean-centered version of the responce
+	Vector<Float, Dynamic> y = ySource.rowwise() - meanY;
+
+    // standard deviation
+	Float stdDevY = sqrt(y.squaredNorm() / rowCount);
+
+    // normalizing
+	y /= stdDevY;	
+
+	// create a vector, which is associtated with regression coefficients
+	Map<Vector<Float, Dynamic>> b(regressionCoefficients, columnCount);
+
+	// create a vector, which is associated with prediction data 
+	Map<Vector<Float, Dynamic>> prediction(predictionDataPtr, rowCount);
+
+	// PLS1 algorithm routine
+
+	Matrix<Float, Dynamic, Dynamic, ColMajor> W(columnCount, componentsCount);
+
+	Matrix<Float, Dynamic, Dynamic, ColMajor> P(columnCount, componentsCount);
+
+	Matrix<Float, Dynamic, Dynamic, ColMajor> T(rowCount, componentsCount);
+
+	Vector<Float, Dynamic> normTau(componentsCount);
+
+	Vector<Float, Dynamic> q(componentsCount);
+
+	Vector<Float, Dynamic> normV(componentsCount);
+
+	// PLS1 algorithm: see Algorithm 2 in https://doi.org/10.1002/cem.2589
+
+	Vector<Float, Dynamic> w = (X.transpose() * y);
+
+	normV(0) = w.norm();
+
+	// prevent division by zero
+	if (normV(0) == static_cast<Float>(0))
+		return METHOD_ERROR;
+
+	w = w / normV(0);
+
+	W.col(0) = w;
+
+	Vector<Float, Dynamic> t = X * w;
+
+	normTau(0) = t.norm();
+
+	// prevent division by zero
+	if (normTau(0) == static_cast<Float>(0))
+		return METHOD_ERROR;
+
+	t = t / normTau(0);
+
+	T.col(0) = t;
+
+	Vector<Float, Dynamic> p = X.transpose() * t;
+
+	P.col(0) = p;
+
+	q(0) = t.transpose() * y;
+
+	for (int a = 1; a < componentsCount; a++)
+	{
+		w = normV(a - 1) * (w - p / normTau(a - 1));
+
+		normV(a) = w.norm();
+
+		// prevent division by zero
+		if (normV(a) == static_cast<Float>(0))
+			return METHOD_ERROR;
+
+		w = w / normV(a);
+
+		W.col(a) = w;
+
+		t = X * w;
+
+		t = t - T.leftCols(a) * (T.leftCols(a).transpose() * t);
+
+		normTau(a) = t.norm();
+
+		// prevent division by zero
+		if (normTau(a) == static_cast<Float>(0))
+			return METHOD_ERROR;
+
+		t = t / normTau(a);
+
+		T.col(a) = t;
+
+		p = X.transpose() * t;
+
+		P.col(a) = p;
+
+		q(a) = t.transpose() * y;
+	} // for a	
+
+	  // compute coefficients of regression
+	Matrix<Float, Dynamic, Dynamic> H = P.transpose() * W;
+
+	// chech existence of inverse matrix
+	if (H.determinant() == static_cast<Float>(0))
+		return METHOD_ERROR;
+
+	b = W * H.inverse() * q;
+
+	for (int i = 0; i < columnCount; i++)
+		b(i) *= stdDevY / stdDevX(i);   
+	
+	// TODO: to discuss a constant term of the regression
+	// a constant term
+	//Vector<Float, 1> shift;
+	//shift(0) = ySource(0) - D.row(0) * b;
+	//q(0) - P.col(0).transpose().dot(b);	
+	//prediction = (D * b).rowwise() + shift;
+
+	prediction = D * b;	
+
+	return NO_ERROR;
+} // partialLeastSquare
+
+/* Partial Least Square (PLS1) - extended version: scores data is provided.
+      predictorColumnsDataPtr - data from columns that are used for prediction (X)
+      rowCount - number of rows
+	  columnCount - number of columns
+	  responseColumnDataPtr - data from column that is predicted, i.e. responce (Y)
+	  componentsCount - number of components that extracted in PLS (A)
+	  predictionDataPtr - prediction obtained using PLS (its size is equal to the size of responce)
+	  regressionCoefficientsPtr - coeffcient of linear regression that are computed (their size is eqaul to the number of columns) (b)
+	  predictorScoresPtr - scores of predectors (T)
+	  responceScoresPtr - scores of response (U)
+	  predictorLoadingsPtr - loadings of predictors (P)
+*/
+int pls::partialLeastSquareExtended(Float * predictorColumnsDataPtr,
+	const int rowCount,
+	const int columnCount,
+	Float * responseColumnDataPtr,
+	const int componentsCount,
+	Float * predictionDataPtr,
+	Float * regressionCoefficientsPtr,
+	Float * predictorScoresPtr,
+	Float * responceScoresPtr,
+	Float * predictorLoadingsPtr) noexcept
+{
+	// check correctness of arguments
+	if (componentsCount <= 0 || componentsCount > columnCount)
+		return UNCORRECT_ARGUMENTS_ERROR;
+
+	// Further, notation from the paper https://doi.org/10.1002/cem.2589 is used (see Algorithm 2).
+
+	// create matrix, which is associated with predictor data
+	Map < Matrix<Float, Dynamic, Dynamic, ColMajor>> D(predictorColumnsDataPtr, rowCount, columnCount);
+
+	// compute mean value of each column of D
+	Vector<Float, Dynamic> mu = D.colwise().mean();
+	
+	// mean-centered version of D
+	Matrix<Float, Dynamic, Dynamic, ColMajor> X = D.rowwise() - mu.transpose();
+	
+	// standard deviations of X
+	Vector<Float, Dynamic> stdDevX(columnCount);
+		
+	Float rowCountSqrt = sqrt(static_cast<Float>(rowCount));
+
+	// normalizing X
+	for (int i = 0; i < columnCount; i++)
+	{
+		stdDevX(i) = X.col(i).norm() / rowCountSqrt;
+
+        // check deviation
+		if(stdDevX(i) == static_cast<Float>(0))
+		    return UNCORRECT_ARGUMENTS_ERROR;
+
+		X.col(i) = X.col(i) / stdDevX(i);
+	}	
+
+	// create a vector, which is associated with responce or predicted data 
+	Map<Vector<Float, Dynamic>> ySource(responseColumnDataPtr, rowCount);
+
+	// mean value of Y: Eigen vector is used in order to provide broadcasting
+	Vector<Float, 1> meanY;
+	meanY(0) = ySource.mean();
+
+	// centering Y
+	Vector<Float, Dynamic> y = ySource.rowwise() - meanY;
+
+	// standard deviation of Y normalizing Y
+	Float stdDevY = sqrt(y.squaredNorm() / rowCount);
+
+	// check deviation
+	if(stdDevY == static_cast<Float>(0))
+	    return UNCORRECT_ARGUMENTS_ERROR;
+
+	// normalizing Y
+	y /= stdDevY;
+	
+	// create a vector, which is associtated with regression coefficients
+	Map<Vector<Float, Dynamic>> b(regressionCoefficientsPtr, columnCount);
+
+	// create a vector, which is associated with prediction data 
+	Map<Vector<Float, Dynamic>> prediction(predictionDataPtr, rowCount);
+
+	// weights matrix, W
+	Matrix<Float, Dynamic, Dynamic, ColMajor> W(columnCount, componentsCount);
+
+	// X-loadings matrix, P
+	Map<Matrix<Float, Dynamic, Dynamic, ColMajor>> P(predictorLoadingsPtr, columnCount, componentsCount);
+
+	//Matrix<Float, Dynamic, Dynamic, ColMajor> P(columnCount, componentsCount);
+
+	// X-scores, T
+	Map<Matrix<Float, Dynamic, Dynamic, ColMajor>> T(predictorScoresPtr, rowCount, componentsCount);
+
+	// Y-scores, U
+	Map<Matrix<Float, Dynamic, Dynamic, ColMajor>> U(responceScoresPtr, rowCount, componentsCount);
+
+	// Y-loadings, q
+	Vector<Float, Dynamic> q(componentsCount);
+
+	// PLS1 routine auxiliry vectors
+	Vector<Float, Dynamic> normTau(componentsCount);
+	Vector<Float, Dynamic> normV(componentsCount);
+
+	// PLS1 algorithm: see Algorithm 2 in https://doi.org/10.1002/cem.2589
+		
+	Vector<Float, Dynamic> w = (X.transpose() * y);
+
+	normV(0) = w.norm();
+
+	// prevent division by zero
+	if (normV(0) == static_cast<Float>(0))
+		return METHOD_ERROR;
+
+	w = w / normV(0);
+
+	W.col(0) = w;
+
+	Vector<Float, Dynamic> t = X * w;
+
+	normTau(0) = t.norm();
+
+	// prevent division by zero
+	if (normTau(0) == static_cast<Float>(0))
+		return METHOD_ERROR;
+
+	t = t / normTau(0);
+
+	T.col(0) = t;
+
+	Vector<Float, Dynamic> p = X.transpose() * t;
+
+	P.col(0) = p;
+
+	q(0) = t.transpose() * y;
+
+	for (int a = 1; a < componentsCount; a++)
+	{
+		w = normV(a - 1) * (w - p / normTau(a - 1));
+
+		normV(a) = w.norm();
+
+		// prevent division by zero
+		if (normV(a) == static_cast<Float>(0))
+			return METHOD_ERROR;
+
+		w = w / normV(a);
+
+		W.col(a) = w;
+
+		t = X * w;
+
+		t = t - T.leftCols(a) * (T.leftCols(a).transpose() * t);
+
+		normTau(a) = t.norm();
+
+		// prevent division by zero
+		if (normTau(a) == static_cast<Float>(0))
+			return METHOD_ERROR;
+
+		t = t / normTau(a);
+
+		T.col(a) = t;
+
+		p = X.transpose() * t;
+
+		P.col(a) = p;
+
+		q(a) = t.transpose() * y;
+	} // for a	
+
+	// compute Y-scores
+	U = y * q.transpose() / q.squaredNorm();
+
+	// compute coefficients of regression
+	Matrix<Float, Dynamic, Dynamic> H = P.transpose() * W;
+
+	// chech existence of inverse matrix
+	if (H.determinant() == static_cast<Float>(0))
+		return METHOD_ERROR;
+
+	// compute regression coefficients
+	b = W * H.inverse() * q;
+
+	// ... also, we take into account a normalizing
+	for (int i = 0; i < columnCount; i++)
+		b(i) *= stdDevY / stdDevX(i);
+
+	// compute predictions
+	prediction = D * b;	
+
+	// Remove the following comments in order to print and verify results
+	//cout << "\nW_star:\n" << Wstar << endl;	
+	//cout << "\nU:\n" << U << endl;
+	//cout << "\nU.tr * U:\n" << U.transpose() * U << endl; // this must be identity matrix	
+	//cout << "\nb:\n" << b << endl;
+	//cout << "\nq:\n" << q << endl;
+	//cout << "\nD:\n" << D << endl;	
+	//cout << "\nP:\n" << P << endl;
+	//cout << "\nT:\n" << T << endl;
+	//cout << "\nT.tr * T:\n" << T.transpose() * T << endl; // this must be identity matrix
+	//cout << "\nW:\n" << W << endl;
+	//cout << "\nW.tr * W:\n" << W.transpose() * W << endl; // this must be identity matrix
+	//cout << "\nprediction\n" << prediction << endl;
+
+	return NO_ERROR;
+} // partialLeastSquareExtended
+
+
+