void QRZT(const Matrix& X, Matrix& Y, Matrix& M)
{
REPORT
Tracer et("QRZT(2)");
int n = X.Ncols(); int s = X.Nrows(); int t = Y.Nrows();
if (Y.Ncols() != n)
{ Throw(ProgramException("Unequal row lengths",X,Y)); }
M.ReSize(t,s);
Real* xi = X.Store(); int k;
for (int i=0; i<s; i++)
{
Real* xj0 = Y.Store(); Real* xi0 = xi;
for (int j=0; j<t; j++)
{
Real sum=0.0;
xi=xi0; Real* xj=xj0; k=n; while(k--) { sum += *xi++ * *xj++; }
xi=xi0; k=n; while(k--) { *xj0++ -= sum * *xi++; }
M.element(j,i) = sum;
}
}
}
void SpinAdapted::Wavefunction::FlattenInto (Matrix& C)
{
int flatIndex = 0;
for (int lQ = 0; lQ < nrows (); ++lQ)
for (int rQ = 0; rQ < ncols (); ++rQ)
if (allowed(lQ, rQ))
flatIndex += operator_element(lQ,rQ).Nrows()*operator_element(lQ,rQ).Ncols();
C.ReSize(flatIndex,1);
flatIndex = 0;
for (int lQ = 0; lQ < nrows (); ++lQ)
for (int rQ = 0; rQ < ncols (); ++rQ)
if (allowed(lQ, rQ))
for (int lQState = 0; lQState < operator_element(lQ, rQ).Nrows (); ++lQState)
for (int rQState = 0; rQState < operator_element(lQ, rQ).Ncols (); ++rQState)
{
C.element (flatIndex,0) = operator_element(lQ, rQ).element (lQState, rQState);
++flatIndex;
}
}
bool q_rigidaffine_compute_rigidmatrix_3D(const vector<Point3D64f> &vec_A,const vector<Point3D64f> &vec_B,Matrix &x4x4_rigidmatrix)
{
if(vec_A.size()<4 || vec_A.size()!=vec_B.size())
{
fprintf(stderr,"ERROR: Invalid input parameters! \n");
return false;
}
if(x4x4_rigidmatrix.nrows()!=4 || x4x4_rigidmatrix.ncols()!=4)
{
x4x4_rigidmatrix.ReSize(4,4);
}
int n_point=vec_A.size();
vector<Point3D64f> vec_A_norm,vec_B_norm;
Matrix x4x4_normalize_A(4,4),x4x4_normalize_B(4,4);
vec_A_norm=vec_A; vec_B_norm=vec_B;
q_normalize_points_3D(vec_A,vec_A_norm,x4x4_normalize_A);
q_normalize_points_3D(vec_B,vec_B_norm,x4x4_normalize_B);
Matrix x3xn_A(3,n_point),x3xn_B(3,n_point);
for(long i=0;i<n_point;i++)
{
x3xn_A(1,i+1)=vec_A_norm[i].x; x3xn_A(2,i+1)=vec_A_norm[i].y; x3xn_A(3,i+1)=vec_A_norm[i].z;
x3xn_B(1,i+1)=vec_B_norm[i].x; x3xn_B(2,i+1)=vec_B_norm[i].y; x3xn_B(3,i+1)=vec_B_norm[i].z;
}
DiagonalMatrix D;
Matrix U,V;
SVD(x3xn_A*x3xn_B.t(),D,U,V);
Matrix R=V*U.t();
x4x4_rigidmatrix(1,1)=R(1,1); x4x4_rigidmatrix(1,2)=R(1,2); x4x4_rigidmatrix(1,3)=R(1,3); x4x4_rigidmatrix(1,4)=0.0;
x4x4_rigidmatrix(2,1)=R(2,1); x4x4_rigidmatrix(2,2)=R(2,2); x4x4_rigidmatrix(2,3)=R(2,3); x4x4_rigidmatrix(2,4)=0.0;
x4x4_rigidmatrix(3,1)=R(3,1); x4x4_rigidmatrix(3,2)=R(3,2); x4x4_rigidmatrix(3,3)=R(3,3); x4x4_rigidmatrix(3,4)=0.0;
x4x4_rigidmatrix(4,1)=0.0; x4x4_rigidmatrix(4,2)=0.0; x4x4_rigidmatrix(4,3)=0.0; x4x4_rigidmatrix(4,4)=1.0;
x4x4_rigidmatrix=x4x4_normalize_B.i()*x4x4_rigidmatrix*x4x4_normalize_A;
return true;
}
bool SpectClust::findNLargestEvals(const Matrix &M, int numLamda, std::vector<Numeric> &eVals, Matrix &EVec, int maxIterations) {
bool converged = true;
EVec.ReSize(M.Ncols(), numLamda);
eVals.clear();
eVals.reserve(numLamda);
Matrix W = M;
for(int i = 1; i <= numLamda; i++) {
ColumnVector maxVec;
double maxVal;
/* Get the maximum eigen vector. */
converged = MaxEigen(W, maxVal, maxVec, maxIterations) && converged;
EVec.Column(i) << maxVec;
eVals.push_back(maxVal);
/* Now subtract of the largest eigen value to get the next
largest in next iteration. */
Matrix ToSub = maxVal * (maxVec * maxVec.t());
W = W - ToSub;
}
return converged;
}
bool SpectClust::findNLargestSymEvals(const SymmetricMatrix &W, int numLamda, std::vector<Numeric> &eVals, Matrix &EVec) {
bool converged = false;
eVals.clear();
eVals.reserve(numLamda);
DiagonalMatrix D(W.Ncols());
Matrix E;
try {
EigenValues(W, D, E);
converged = true;
EVec.ReSize(W.Ncols(), numLamda);
int count = 0;
for(int i = W.Ncols(); i > W.Ncols() - numLamda; i--) {
eVals.push_back(D(i));
EVec.Column(++count) << E.Column(i);
}
}
catch(const Exception &e) {
Err::errAbort("Exception: " + ToStr(e.what()));
}
catch(...) {
Err::errAbort("Yikes couldn't calculate eigen vectors.");
}
return converged;
}
void SpinAdapted::MatrixTensorProduct (const Matrix& a_ref, char conjA, Real scaleA, const Matrix& b_ref, char conjB, Real scaleB, Matrix& c, int rowstride, int colstride, bool allocate)
{
#ifndef BLAS
Matrix A;
Matrix B;
#endif
Matrix& a = const_cast<Matrix&>(a_ref); // for BLAS calls
Matrix& b = const_cast<Matrix&>(b_ref);
int arows = a.Nrows();
int acols = a.Ncols();
// some specialisations
#ifdef FAST_MTP
// if ((brows == 1) && (bcols == 1))
{
double b00 = *b.Store();
if (conjA == 'n')
{
double* cptr = c.Store()+ rowstride*c.Ncols() + colstride;
for (int i=0; i< a.Nrows();i++)
DAXPY(a.Ncols(), scaleA * scaleB * b00, a.Store()+i*a.Ncols(), 1, cptr + i*c.Ncols(), 1);
return;
}
else
{
double* aptr = a.Store();
double* cptr = c.Store() + rowstride*c.Ncols() + colstride;
for (int col = 0; col < acols; ++col)
{
DAXPY(arows, scaleA * scaleB * b00, aptr, acols, cptr, 1);
++aptr;
cptr += c.Ncols();//arows;
}
return;
}
}
// else
// abort();
#else
try
{
if (conjA == 'n' && conjB == 'n')
{
if (allocate)
{
c.ReSize (a.Nrows () * b.Nrows (), a.Ncols () * b.Ncols ());
Clear (c);
}
//assert ((c.Nrows () == (a.Nrows () * b.Nrows ())) && (c.Ncols () == (a.Ncols () * b.Ncols ())));
#ifdef BLAS
int aRows = a.Nrows ();
int aCols = a.Ncols ();
int bRows = b.Nrows ();
int bCols = b.Ncols ();
for (int i = 0; i < aRows; ++i)
for (int j = 0; j < aCols; ++j)
{
Real scale = scaleA * scaleB * a (i+1,j+1);
for (int k = 0; k < bRows; ++k)
GAXPY (bCols, scale, &b (k+1,1), 1, &c (i * bRows + k+1 +rowstride,j * bCols+1+colstride), 1);
}
return;
#else
A = a;
B = b;
#endif
}
else if (conjA == 't' && conjB == 'n')
{
if (allocate)
{
c.ReSize (a.Ncols () * b.Nrows (), a.Nrows () * b.Ncols ());
Clear (c);
}
//assert ((c.Nrows () == (a.Ncols () * b.Nrows ())) && (c.Ncols () == (a.Nrows () * b.Ncols ())));
#ifdef BLAS
int aRows = a.Ncols ();
int aCols = a.Nrows ();
int bRows = b.Nrows ();
int bCols = b.Ncols ();
for (int i = 0; i < aRows; ++i)
for (int j = 0; j < aCols; ++j)
{
Real scale = scaleA * scaleB * a (j+1,i+1);
for (int k = 0; k < bRows; ++k)
GAXPY (bCols, scale, &b (k+1,1), 1, &c (i * bRows + k+1+rowstride,j * bCols+1+colstride), 1);
}
return;
#else
A = a.t ();
B = b;
#endif
}
else if (conjA == 'n' && conjB == 't')
{
if (allocate)
{
c.ReSize (a.Nrows () * b.Ncols (), a.Ncols () * b.Nrows ());
Clear (c);
}
//assert ((c.Nrows () == (a.Nrows () * b.Ncols ())) && (c.Ncols () == (a.Ncols () * b.Nrows ())));
#ifdef BLAS
int aRows = a.Nrows ();
int aCols = a.Ncols ();
int bRows = b.Ncols ();
int bCols = b.Nrows ();
for (int i = 0; i < aRows; ++i)
for (int j = 0; j < aCols; ++j)
{
Real scale = scaleA * scaleB * a (i+1,j+1);
for (int k = 0; k < bRows; ++k)
GAXPY (bCols, scale, &b (1,k+1), bRows, &c (i * bRows + k+1+rowstride,j * bCols+1+colstride), 1);
}
return;
#else
A = a;
B = b.t ();
#endif
}
else if (conjA == 't' && conjB == 't')
{
if (allocate)
{
c.ReSize (a.Ncols () * b.Ncols (), a.Nrows () * b.Nrows ());
Clear (c);
}
//assert ((c.Nrows () == (a.Ncols () * b.Ncols ())) && (c.Ncols () == (a.Nrows () * b.Nrows ())));
#ifdef BLAS
int aRows = a.Ncols ();
int aCols = a.Nrows ();
int bRows = b.Ncols ();
int bCols = b.Nrows ();
for (int i = 0; i < aRows; ++i)
for (int j = 0; j < aCols; ++j)
{
Real scale = scaleA * scaleB * a (j+1,i+1);
for (int k = 0; k < bRows; ++k)
GAXPY (bCols, scaleA * scaleB * a (j+1,i+1), &b (1,k+1), bRows, &c (i * bRows + k+1+rowstride,j * bCols+1+colstride), 1);
}
return;
#else
A = a.t ();
B = b.t ();
#endif
}
else
abort ();
#ifndef BLAS
for (int i = 1; i <= A.Nrows (); ++i)
for (int j = 1; j <= A.Ncols (); ++j)
c.SubMatrix ((i - 1) * B.Nrows () + 1, i * B.Nrows (), (j - 1) * B.Ncols () + 1, j * B.Ncols ()) += (scaleA * scaleB) * A (i,j) * B;
#endif
}
catch (Exception)
{
pout << Exception::what () << endl;
abort ();
}
#endif
}
void trymat2()
{
// cout << "\nSecond test of Matrix package\n\n";
Tracer et("Second test of Matrix package");
Tracer::PrintTrace();
int i,j;
Matrix M(3,5);
for (i=1; i<=3; i++) for (j=1; j<=5; j++) M(i,j) = 100*i + j;
Matrix X(8,10);
for (i=1; i<=8; i++) for (j=1; j<=10; j++) X(i,j) = 1000*i + 10*j;
Matrix Y = X; Matrix Z = X;
{ X.SubMatrix(2,4,3,7) << M; }
for (i=1; i<=3; i++) for (j=1; j<=5; j++) Y(i+1,j+2) = 100*i + j;
Print(Matrix(X-Y));
Real a[15]; Real* r = a;
for (i=1; i<=3; i++) for (j=1; j<=5; j++) *r++ = 100*i + j;
{ Z.SubMatrix(2,4,3,7) << a; }
Print(Matrix(Z-Y));
{ M=33; X.SubMatrix(2,4,3,7) << M; }
{ Z.SubMatrix(2,4,3,7) = 33; }
Print(Matrix(Z-X));
for (i=1; i<=8; i++) for (j=1; j<=10; j++) X(i,j) = 1000*i + 10*j;
Y = X;
UpperTriangularMatrix U(5);
for (i=1; i<=5; i++) for (j=i; j<=5; j++) U(i,j) = 100*i + j;
{ X.SubMatrix(3,7,5,9) << U; }
for (i=1; i<=5; i++) for (j=i; j<=5; j++) Y(i+2,j+4) = 100*i + j;
for (i=1; i<=5; i++) for (j=1; j<i; j++) Y(i+2,j+4) = 0.0;
Print(Matrix(X-Y));
for (i=1; i<=8; i++) for (j=1; j<=10; j++) X(i,j) = 1000*i + 10*j;
Y = X;
for (i=1; i<=5; i++) for (j=i; j<=5; j++) U(i,j) = 100*i + j;
{ X.SubMatrix(3,7,5,9).Inject(U); }
for (i=1; i<=5; i++) for (j=i; j<=5; j++) Y(i+2,j+4) = 100*i + j;
Print(Matrix(X-Y));
// test growing and shrinking a vector
{
ColumnVector V(100);
for (i=1;i<=100;i++) V(i) = i*i+i;
V = V.Rows(1,50); // to get first 50 vlaues.
{
V.Release(); ColumnVector VX=V;
V.ReSize(100); V = 0.0; V.Rows(1,50)=VX;
} // V now length 100
M=V; M=100; // to make sure V will hold its values
for (i=1;i<=50;i++) V(i) -= i*i+i;
Print(V);
// test redimensioning vectors with two dimensions given
ColumnVector CV1(10); CV1 = 10;
ColumnVector CV2(5); CV2.ReSize(10,1); CV2 = 10;
V = CV1-CV2; Print(V);
RowVector RV1(20); RV1 = 100;
RowVector RV2; RV2.ReSize(1,20); RV2 = 100;
V = (RV1-RV2).t(); Print(V);
X.ReSize(4,7);
for (i=1; i<=4; i++) for (j=1; j<=7; j++) X(i,j) = 1000*i + 10*j;
Y = 10.5 * X;
Z = 7.25 - Y;
M = Z + X * 10.5 - 7.25;
Print(M);
Y = 2.5 * X;
Z = 9.25 + Y;
M = Z - X * 2.5 - 9.25;
Print(M);
U.ReSize(8);
for (i=1; i<=8; i++) for (j=i; j<=8; j++) U(i,j) = 100*i + j;
Y = 100 - U;
M = Y + U - 100;
Print(M);
}
{
SymmetricMatrix S,T;
S << (U + U.t());
T = 100 - S; M = T + S - 100; Print(M);
T = 100 - 2 * S; M = T + S * 2 - 100; Print(M);
X = 100 - 2 * S; M = X + S * 2 - 100; Print(M);
T = S; T = 100 - T; M = T + S - 100; Print(M);
}
// test new
{
ColumnVector CV1; RowVector RV1;
Matrix* MX; MX = new Matrix; if (!MX) Throw(Bad_alloc("New fails "));
MX->ReSize(10,20);
for (i = 1; i <= 10; i++) for (j = 1; j <= 20; j++)
(*MX)(i,j) = 100 * i + j;
ColumnVector* CV = new ColumnVector(10);
if (!CV) Throw(Bad_alloc("New fails "));
*CV << 1 << 2 << 3 << 4 << 5 << 6 << 7 << 8 << 9 << 10;
RowVector* RV = new RowVector(CV->t() | (*CV + 10).t());
if (!RV) Throw(Bad_alloc("New fails "));
CV1 = ColumnVector(10); CV1 = 1; RV1 = RowVector(20); RV1 = 1;
*MX -= 100 * *CV * RV1 + CV1 * *RV;
Print(*MX);
delete MX; delete CV; delete RV;
}
// test copying of vectors and matrices with no elements
{
ColumnVector dims(16);
Matrix M1; Matrix M2 = M1; Print(M2);
dims(1) = M2.Nrows(); dims(2) = M2.Ncols();
dims(3) = (Real)(unsigned long)M2.Store(); dims(4) = M2.Storage();
M2 = M1;
dims(5) = M2.Nrows(); dims(6) = M2.Ncols();
dims(7) = (Real)(unsigned long)M2.Store(); dims(8) = M2.Storage();
M2.ReSize(10,20); M2.CleanUp();
dims(9) = M2.Nrows(); dims(10) = M2.Ncols();
dims(11) = (Real)(unsigned long)M2.Store(); dims(12) = M2.Storage();
M2.ReSize(20,10); M2.ReSize(0,0);
dims(13) = M2.Nrows(); dims(14) = M2.Ncols();
dims(15) = (Real)(unsigned long)M2.Store(); dims(16) = M2.Storage();
Print(dims);
}
{
ColumnVector dims(16);
ColumnVector M1; ColumnVector M2 = M1; Print(M2);
dims(1) = M2.Nrows(); dims(2) = M2.Ncols()-1;
dims(3) = (Real)(unsigned long)M2.Store(); dims(4) = M2.Storage();
M2 = M1;
dims(5) = M2.Nrows(); dims(6) = M2.Ncols()-1;
dims(7) = (Real)(unsigned long)M2.Store(); dims(8) = M2.Storage();
M2.ReSize(10); M2.CleanUp();
dims(9) = M2.Nrows(); dims(10) = M2.Ncols()-1;
dims(11) = (Real)(unsigned long)M2.Store(); dims(12) = M2.Storage();
M2.ReSize(10); M2.ReSize(0);
dims(13) = M2.Nrows(); dims(14) = M2.Ncols()-1;
dims(15) = (Real)(unsigned long)M2.Store(); dims(16) = M2.Storage();
Print(dims);
}
{
ColumnVector dims(16);
RowVector M1; RowVector M2 = M1; Print(M2);
dims(1) = M2.Nrows()-1; dims(2) = M2.Ncols();
dims(3) = (Real)(unsigned long)M2.Store(); dims(4) = M2.Storage();
M2 = M1;
dims(5) = M2.Nrows()-1; dims(6) = M2.Ncols();
dims(7) = (Real)(unsigned long)M2.Store(); dims(8) = M2.Storage();
M2.ReSize(10); M2.CleanUp();
dims(9) = M2.Nrows()-1; dims(10) = M2.Ncols();
dims(11) = (Real)(unsigned long)M2.Store(); dims(12) = M2.Storage();
M2.ReSize(10); M2.ReSize(0);
dims(13) = M2.Nrows()-1; dims(14) = M2.Ncols();
dims(15) = (Real)(unsigned long)M2.Store(); dims(16) = M2.Storage();
Print(dims);
}
// test identity matrix
{
Matrix M;
IdentityMatrix I(10); DiagonalMatrix D(10); D = 1;
M = I; M -= D; Print(M);
D -= I; Print(D);
ColumnVector X(8);
D = 1;
X(1) = Sum(D) - Sum(I);
X(2) = SumAbsoluteValue(D) - SumAbsoluteValue(I);
X(3) = SumSquare(D) - SumSquare(I);
X(4) = Trace(D) - Trace(I);
X(5) = Maximum(D) - Maximum(I);
X(6) = Minimum(D) - Minimum(I);
X(7) = LogDeterminant(D).LogValue() - LogDeterminant(I).LogValue();
X(8) = LogDeterminant(D).Sign() - LogDeterminant(I).Sign();
Clean(X,0.00000001); Print(X);
for (i = 1; i <= 10; i++) for (j = 1; j <= 10; j++)
M(i,j) = 100 * i + j;
Matrix N;
N = M * I - M; Print(N);
N = I * M - M; Print(N);
N = M * I.i() - M; Print(N);
N = I.i() * M - M; Print(N);
N = I.i(); N -= I; Print(N);
N = I.t(); N -= I; Print(N);
N = I.t(); N += (-I); Print(N); // <----------------
D = I; N = D; D = 1; N -= D; Print(N);
N = I; D = 1; N -= D; Print(N);
N = M + 2 * IdentityMatrix(10); N -= (M + 2 * D); Print(N);
I *= 4;
D = 4;
X.ReSize(14);
X(1) = Sum(D) - Sum(I);
X(2) = SumAbsoluteValue(D) - SumAbsoluteValue(I);
X(3) = SumSquare(D) - SumSquare(I);
X(4) = Trace(D) - Trace(I);
X(5) = Maximum(D) - Maximum(I);
X(6) = Minimum(D) - Minimum(I);
X(7) = LogDeterminant(D).LogValue() - LogDeterminant(I).LogValue(); // <--
X(8) = LogDeterminant(D).Sign() - LogDeterminant(I).Sign();
int i,j;
X(9) = I.Maximum1(i) - 4; X(10) = i-1;
X(11) = I.Maximum2(i,j) - 4; X(12) = i-10; X(13) = j-10;
X(14) = I.Nrows() - 10;
Clean(X,0.00000001); Print(X);
N = D.i();
N += I / (-16);
Print(N);
N = M * I - 4 * M; Print(N);
N = I * M - 4 * M; Print(N);
N = M * I.i() - 0.25 * M; Print(N);
N = I.i() * M - 0.25 * M; Print(N);
N = I.i(); N -= I * 0.0625; Print(N);
N = I.i(); N = N - 0.0625 * I; Print(N);
N = I.t(); N -= I; Print(N);
D = I * 2; N = D; D = 1; N -= 8 * D; Print(N);
N = I * 2; N -= 8 * D; Print(N);
N = 0.5 * I + M; N -= M; N -= 2.0 * D; Print(N);
IdentityMatrix J(10); J = 8;
D = 4;
DiagonalMatrix E(10); E = 8;
N = (I + J) - (D + E); Print(N);
N = (5*I + 3*J) - (5*D + 3*E); Print(N);
N = (-I + J) - (-D + E); Print(N);
N = (I - J) - (D - E); Print(N);
N = (I | J) - (D | E); Print(N);
N = (I & J) - (D & E); Print(N);
N = SP(I,J) - SP(D,E); Print(N);
N = D.SubMatrix(2,5,3,8) - I.SubMatrix(2,5,3,8); Print(N);
N = M; N.Inject(I); D << M; N -= (M + I); N += D; Print(N);
D = 4;
IdentityMatrix K = I.i()*7 - J.t()/4;
N = D.i() * 7 - E / 4 - K; Print(N);
K = I * J; N = K - D * E; Print(N);
N = I * J; N -= D * E; Print(N);
K = 5*I - 3*J;
N = K - (5*D - 3*E); Print(N);
K = I.i(); N = K - 0.0625 * I; Print(N);
K = I.t(); N = K - I; Print(N);
K.ReSize(20); D.ReSize(20); D = 1;
D -= K; Print(D);
I.ReSize(3); J.ReSize(3); K = I * J; N = K - I; Print(N);
K << D; N = K - D; Print(N);
}
// test add integer
{
Matrix X(2,3);
X << 5.25 << 7.75 << 1.25
<< 9.00 << 1.00 << 2.50;
Matrix Y = X;
X = 10 + X;
X += (-10);
X -= Y;
Print(X);
// also test f suffix
X << 5.25f << 7.75f << 1.25f
<< 9.00f << 1.00f << 2.50f;
X -= Y; Print(X);
}
// cout << "\nEnd of second test\n";
}
//==========================================================================
void make_implicit_svd(vector<vector<double> >& mat,
vector<double>& b, double& sigma_min)
//==========================================================================
{
int rows = (int)mat.size();
int cols = (int)mat[0].size();
// cout << "Rows = " << rows << endl
// << "Cols = " << cols << endl;
Matrix nmat;
nmat.ReSize(rows, cols);
for (int i = 0; i < rows; ++i) {
for (int j = 0; j < cols; ++j) {
nmat.element(i, j) = mat[i][j];
}
}
// Check if mat has enough rows. If not fill out with zeros.
if (rows < cols) {
RowVector zero(cols);
zero = 0.0; // Initializes zero to a null-vector.
for (int i = rows; i < cols; ++i) {
nmat &= zero; // & means horizontal concatenation in newmat
}
}
// Perform SVD.
// cout << "Running SVD..." << endl;
static DiagonalMatrix diag;
static Matrix V;
Try {
SVD(nmat, diag, nmat, V);
} CatchAll {
cout << Exception::what() << endl;
b = vector<double>(cols, 0.0);
sigma_min = -1.0;
return;
}
// // Write out singular values.
// cout << "Singular values:" << endl;
// for (int ik = 0; ik < cols; ik++)
// cout << ik << "\t" << diag.element(ik, ik) << endl;
// // Write out info about singular values
// double s_min = diag.element(cols-1, cols-1);
// double s_max = diag.element(0, 0);
// cout << "Implicitization:" << endl
// << "s_min = " << s_min << endl
// << "s_max = " << s_max << endl
// << "Ratio of s_min/s_max = " << s_min/s_max << endl;
// // Find square sum of singular values
// double sum = 0.0;
// for (int i = 0; i < cols; i++)
// sum += diag.element(i, i) * diag.element(i, i);
// sum = sqrt(sum);
// cout << "Square sum = " << sum << endl;
// Get the appropriate null-vector and corresponding singular value
const double eps = 1.0e-15;
double tol = cols * fabs(diag.element(0, 0)) * eps;
int nullvec = 0;
for (int i = 0; i < cols-1; ++i) {
if (fabs(diag.element(i, i)) > tol) {
++nullvec;
}
}
sigma_min = diag.element(nullvec, nullvec);
// cout << "Null-vector: " << nullvec << endl
// << "sigma_min = " << sigma_min << endl;
// Set the coefficients
b.resize(cols);
for (int jk = 0; jk < cols; ++jk)
b[jk] = V.element(jk, nullvec);
return;
}
void trymat7()
{
// cout << "\nSeventh test of Matrix package\n";
Tracer et("Seventh test of Matrix package");
Tracer::PrintTrace();
int i,j;
DiagonalMatrix D(6);
UpperTriangularMatrix U(6);
for (i=1; i<=6; i++) {
for (j=i; j<=6; j++) U(i,j)=i*i*j-50;
D(i,i)=i*i+i-10;
}
LowerTriangularMatrix L=(U*3.0).t();
SymmetricMatrix S(6);
for (i=1; i<=6; i++) for (j=i; j<=6; j++) S(i,j)=i*i+2.0+j;
Matrix MD=D;
Matrix ML=L;
Matrix MU=U;
Matrix MS=S;
Matrix M(6,6);
for (i=1; i<=6; i++) for (j=1; j<=6; j++) M(i,j)=i*j+i*i-10.0;
{
Tracer et1("Stage 1");
Print(Matrix((S-M)-(MS-M)));
Print(Matrix((-M-S)+(MS+M)));
Print(Matrix((U-M)-(MU-M)));
}
{
Tracer et1("Stage 2");
Print(Matrix((L-M)+(M-ML)));
Print(Matrix((D-M)+(M-MD)));
Print(Matrix((D-S)+(MS-MD)));
Print(Matrix((D-L)+(ML-MD)));
}
{
M=MU.t();
}
LowerTriangularMatrix LY=D.i()*U.t();
{
Tracer et1("Stage 3");
MS=D*LY-M;
Clean(MS,0.00000001);
Print(MS);
L=U.t();
LY=D.i()*L;
MS=D*LY-M;
Clean(MS,0.00000001);
Print(MS);
}
{
Tracer et1("Stage 4");
UpperTriangularMatrix UT(11);
int i, j;
for (i=1; i<=11; i++) for (j=i; j<=11; j++) UT(i,j)=i*i+j*3;
GenericMatrix GM;
Matrix X;
UpperBandMatrix UB(11,3);
UB.Inject(UT);
UT = UB;
UpperBandMatrix UB2 = UB / 8;
GM = UB2-UT/8;
X = GM;
Print(X);
SymmetricBandMatrix SB(11,4);
SB << (UB + UB.t());
X = SB - UT - UT.t();
Print(X);
BandMatrix B = UB + UB.t()*2;
DiagonalMatrix D;
D << B;
X.ReSize(1,1);
X(1,1) = Trace(B)-Sum(D);
Print(X);
X = SB + 5;
Matrix X1=X;
X = SP(UB,X);
Matrix X2 =UB;
X1 = (X1.AsDiagonal() * X2.AsDiagonal()).AsRow()-X.AsColumn().t();
Print(X1);
X1=SB.t();
X2 = B.t();
X = SB.i() * B - X1.i() * X2.t();
Clean(X,0.00000001);
Print(X);
X = SB.i();
X = X * B - X1.i() * X2.t();
Clean(X,0.00000001);
Print(X);
D = 1;
X = SB.i() * SB - D;
Clean(X,0.00000001);
Print(X);
ColumnVector CV(11);
CV << 2 << 6 <<3 << 8 << -4 << 17.5 << 2 << 1 << -2 << 5 << 3.75;
D << 2 << 6 <<3 << 8 << -4 << 17.5 << 2 << 1 << -2 << 5 << 3.75;
X = CV.AsDiagonal();
X = X-D;
Print(X);
SymmetricBandMatrix SB1(11,7);
SB1 = 5;
SymmetricBandMatrix SB2 = SB1 + D;
X.ReSize(11,11);
X=0;
for (i=1; i<=11; i++) for (j=1; j<=11; j++)
{
if (abs(i-j)<=7) X(i,j)=5;
if (i==j) X(i,j)+=CV(i);
}
SymmetricMatrix SM;
SM.ReSize(11);
SM=SB;
SB = SB+SB2;
X1 = SM+X-SB;
Print(X1);
SB2=0;
X2=SB2;
X1=SB;
Print(X2);
for (i=1; i<=11; i++) SB2.Column(i)<<SB.Column(i);
X1=X1-SB2;
Print(X1);
X = SB;
SB2.ReSize(11,4);
SB2 = SB*5;
SB2 = SB + SB2;
X1 = X*6 - SB2;
Print(X1);
X1 = SP(SB,SB2/3);
X1=X1-SP(X,X*2);
Print(X1);
X1 = SP(SB2/6,X*2);
X1=X1-SP(X*2,X);
Print(X1);
}
{
// test the simple integer array class
Tracer et("Stage 5");
ColumnVector Test(10);
Test = 0.0;
int i;
SimpleIntArray A(100);
for (i = 0; i < 100; i++) A[i] = i*i+1;
SimpleIntArray B(100), C(50), D;
B = A;
A.ReSize(50, true);
C = A;
A.ReSize(150, true);
D = A;
for (i = 0; i < 100; i++) if (B[i] != i*i+1) Test(1)=1;
for (i = 0; i < 50; i++) if (C[i] != i*i+1) Test(2)=1;
for (i = 0; i < 50; i++) if (D[i] != i*i+1) Test(3)=1;
for (i = 50; i < 150; i++) if (D[i] != 0) Test(3)=1;
A.resize(75);
A = A.size();
for (i = 0; i < 75; i++) if (A[i] != 75) Test(4)=1;
A.resize(25);
A = A.size();
for (i = 0; i < 25; i++) if (A[i] != 25) Test(5)=1;
A.ReSize(25);
A = 23;
for (i = 0; i < 25; i++) if (A[i] != 23) Test(6)=1;
A.ReSize(0);
A.ReSize(15);
A = A.Size();
for (i = 0; i < 15; i++) if (A[i] != 15) Test(7)=1;
const SimpleIntArray E = B;
for (i = 0; i < 100; i++) if (E[i] != i*i+1) Test(8)=1;
SimpleIntArray F;
F.resize_keep(5);
for (i = 0; i < 5; i++) if (F[i] != 0) Test(9)=1;
Print(Test);
}
{
// testing RealStarStar
Tracer et("Stage 6");
MultWithCarry MWC;
Matrix A(10, 12), B(12, 15), C(10, 15);
FillWithValues(MWC, A);
FillWithValues(MWC, B);
ConstRealStarStar a(A);
ConstRealStarStar b(B);
RealStarStar c(C);
c_matrix_multiply(10,12,15,a,b,c);
Matrix X = C - A * B;
Clean(X,0.00000001);
Print(X);
A.ReSize(11, 10);
B.ReSize(10,8);
C.ReSize(11,8);
FillWithValues(MWC, A);
FillWithValues(MWC, B);
C = -1;
c_matrix_multiply(11,10,8,
ConstRealStarStar(A),ConstRealStarStar(B),RealStarStar(C));
X = C - A * B;
Clean(X,0.00000001);
Print(X);
}
{
// testing resize_keep
Tracer et("Stage 7");
Matrix X, Y;
MultWithCarry MWC;
X.resize(20,35);
FillWithValues(MWC, X);
Matrix M(20,35);
M = X;
X = M.submatrix(1,15,1,25);
M.resize_keep(15,25);
Y = X - M;
Print(Y);
M.resize_keep(15,25);
Y = X - M;
Print(Y);
Y.resize(29,27);
Y = 0;
Y.submatrix(1,15,1,25) = X;
M.resize_keep(29,27);
Y -= M;
Print(Y);
M.resize_keep(0,5);
M.resize_keep(10,10);
Print(M);
M.resize_keep(15,0);
M.resize_keep(10,10);
Print(M);
X.resize(20,35);
FillWithValues(MWC, X);
M = X;
M.resize_keep(38,17);
Y.resize(38,17);
Y = 0;
Y.submatrix(1,20,1,17) = X.submatrix(1,20,1,17);
Y -= M;
Print(Y);
X.resize(40,12);
FillWithValues(MWC, X);
M = X;
M.resize_keep(38,17);
Y.resize(38,17);
Y = 0;
Y.submatrix(1,38,1,12) = X.submatrix(1,38,1,12);
Y -= M;
Print(Y);
#ifndef DONT_DO_NRIC
X.resize(20,35);
FillWithValues(MWC, X);
nricMatrix nM(20,35);
nM = X;
X = nM.submatrix(1,15,1,25);
nM.resize_keep(15,25);
Y = X - nM;
Print(Y);
nM.resize_keep(15,25);
Y = X - nM;
Print(Y);
Y.resize(29,27);
Y = 0;
Y.submatrix(1,15,1,25) = X;
nM.resize_keep(29,27);
Y -= nM;
Print(Y);
nM.resize_keep(0,5);
nM.resize_keep(10,10);
Print(nM);
nM.resize_keep(15,0);
nM.resize_keep(10,10);
Print(nM);
X.resize(20,35);
FillWithValues(MWC, X);
nM = X;
nM.resize_keep(38,17);
Y.resize(38,17);
Y = 0;
Y.submatrix(1,20,1,17) = X.submatrix(1,20,1,17);
Y -= nM;
Print(Y);
X.resize(40,12);
FillWithValues(MWC, X);
nM = X;
nM.resize_keep(38,17);
Y.resize(38,17);
Y = 0;
Y.submatrix(1,38,1,12) = X.submatrix(1,38,1,12);
Y -= nM;
Print(Y);
#endif
X.resize(20,20);
FillWithValues(MWC, X);
SquareMatrix SQM(20);
SQM << X;
X = SQM.sym_submatrix(1,13);
SQM.resize_keep(13);
Y = X - SQM;
Print(Y);
SQM.resize_keep(13);
Y = X - SQM;
Print(Y);
Y.resize(23,23);
Y = 0;
Y.sym_submatrix(1,13) = X;
SQM.resize_keep(23,23);
Y -= SQM;
Print(Y);
SQM.resize_keep(0);
SQM.resize_keep(50);
Print(SQM);
X.resize(20,20);
FillWithValues(MWC, X);
SymmetricMatrix SM(20);
SM << X;
X = SM.sym_submatrix(1,13);
SM.resize_keep(13);
Y = X - SM;
Print(Y);
SM.resize_keep(13);
Y = X - SM;
Print(Y);
Y.resize(23,23);
Y = 0;
Y.sym_submatrix(1,13) = X;
SM.resize_keep(23);
Y -= SM;
Print(Y);
SM.resize_keep(0);
SM.resize_keep(50);
Print(SM);
X.resize(20,20);
FillWithValues(MWC, X);
LowerTriangularMatrix LT(20);
LT << X;
X = LT.sym_submatrix(1,13);
LT.resize_keep(13);
Y = X - LT;
Print(Y);
LT.resize_keep(13);
Y = X - LT;
Print(Y);
Y.resize(23,23);
Y = 0;
Y.sym_submatrix(1,13) = X;
LT.resize_keep(23);
Y -= LT;
Print(Y);
LT.resize_keep(0);
LT.resize_keep(50);
Print(LT);
X.resize(20,20);
FillWithValues(MWC, X);
UpperTriangularMatrix UT(20);
UT << X;
X = UT.sym_submatrix(1,13);
UT.resize_keep(13);
Y = X - UT;
Print(Y);
UT.resize_keep(13);
Y = X - UT;
Print(Y);
Y.resize(23,23);
Y = 0;
Y.sym_submatrix(1,13) = X;
UT.resize_keep(23);
Y -= UT;
Print(Y);
UT.resize_keep(0);
UT.resize_keep(50);
Print(UT);
X.resize(20,20);
FillWithValues(MWC, X);
DiagonalMatrix DM(20);
DM << X;
X = DM.sym_submatrix(1,13);
DM.resize_keep(13);
Y = X - DM;
Print(Y);
DM.resize_keep(13);
Y = X - DM;
Print(Y);
Y.resize(23,23);
Y = 0;
Y.sym_submatrix(1,13) = X;
DM.resize_keep(23);
Y -= DM;
Print(Y);
DM.resize_keep(0);
DM.resize_keep(50);
Print(DM);
X.resize(1,20);
FillWithValues(MWC, X);
RowVector RV(20);
RV << X;
X = RV.columns(1,13);
RV.resize_keep(13);
Y = X - RV;
Print(Y);
RV.resize_keep(13);
Y = X - RV;
Print(Y);
Y.resize(1,23);
Y = 0;
Y.columns(1,13) = X;
RV.resize_keep(1,23);
Y -= RV;
Print(Y);
RV.resize_keep(0);
RV.resize_keep(50);
Print(RV);
X.resize(20,1);
FillWithValues(MWC, X);
ColumnVector CV(20);
CV << X;
X = CV.rows(1,13);
CV.resize_keep(13);
Y = X - CV;
Print(Y);
CV.resize_keep(13);
Y = X - CV;
Print(Y);
Y.resize(23,1);
Y = 0;
Y.rows(1,13) = X;
CV.resize_keep(23,1);
Y -= CV;
Print(Y);
CV.resize_keep(0);
CV.resize_keep(50);
Print(CV);
}
// cout << "\nEnd of seventh test\n";
}
void trymatc()
{
// cout << "\nTwelfth test of Matrix package\n";
Tracer et("Twelfth test of Matrix package");
Tracer::PrintTrace();
DiagonalMatrix D(15); D=1.5;
Matrix A(15,15);
int i,j;
for (i=1;i<=15;i++) for (j=1;j<=15;j++) A(i,j)=i*i+j-150;
{ A = A + D; }
ColumnVector B(15);
for (i=1;i<=15;i++) B(i)=i+i*i-150.0;
{
Tracer et1("Stage 1");
ColumnVector B1=B;
B=(A*2.0).i() * B1;
Matrix X = A*B-B1/2.0;
Clean(X, 0.000000001); Print(X);
A.ReSize(3,5);
for (i=1; i<=3; i++) for (j=1; j<=5; j++) A(i,j) = i+100*j;
B = A.AsColumn()+10000;
RowVector R = (A+10000).AsColumn().t();
Print( RowVector(R-B.t()) );
}
{
Tracer et1("Stage 2");
B = A.AsColumn()+10000;
Matrix XR = (A+10000).AsMatrix(15,1).t();
Print( RowVector(XR-B.t()) );
}
{
Tracer et1("Stage 3");
B = (A.AsMatrix(15,1)+A.AsColumn())/2.0+10000;
Matrix MR = (A+10000).AsColumn().t();
Print( RowVector(MR-B.t()) );
B = (A.AsMatrix(15,1)+A.AsColumn())/2.0;
MR = A.AsColumn().t();
Print( RowVector(MR-B.t()) );
}
{
Tracer et1("Stage 4");
B = (A.AsMatrix(15,1)+A.AsColumn())/2.0;
RowVector R = A.AsColumn().t();
Print( RowVector(R-B.t()) );
}
{
Tracer et1("Stage 5");
RowVector R = (A.AsColumn()-5000).t();
B = ((R.t()+10000) - A.AsColumn())-5000;
Print( RowVector(B.t()) );
}
{
Tracer et1("Stage 6");
B = A.AsColumn(); ColumnVector B1 = (A+10000).AsColumn() - 10000;
Print(ColumnVector(B1-B));
}
{
Tracer et1("Stage 7");
Matrix X = B.AsMatrix(3,5); Print(Matrix(X-A));
for (i=1; i<=3; i++) for (j=1; j<=5; j++) B(5*(i-1)+j) -= i+100*j;
Print(B);
}
{
Tracer et1("Stage 8");
A.ReSize(7,7); D.ReSize(7);
for (i=1; i<=7; i++) for (j=1; j<=7; j++) A(i,j) = i*j*j;
for (i=1; i<=7; i++) D(i,i) = i;
UpperTriangularMatrix U; U << A;
Matrix X = A; for (i=1; i<=7; i++) X(i,i) = i;
A.Inject(D); Print(Matrix(X-A));
X = U; U.Inject(D); A = U; for (i=1; i<=7; i++) X(i,i) = i;
Print(Matrix(X-A));
}
{
Tracer et1("Stage 9");
A.ReSize(7,5);
for (i=1; i<=7; i++) for (j=1; j<=5; j++) A(i,j) = i+100*j;
Matrix Y = A; Y = Y - ((const Matrix&)A); Print(Y);
Matrix X = A;
Y = A; Y = ((const Matrix&)X) - A; Print(Y); Y = 0.0;
Y = ((const Matrix&)X) - ((const Matrix&)A); Print(Y);
}
{
Tracer et1("Stage 10");
// some tests on submatrices
UpperTriangularMatrix U(20);
for (i=1; i<=20; i++) for (j=i; j<=20; j++) U(i,j)=100 * i + j;
UpperTriangularMatrix V = U.SymSubMatrix(1,5);
UpperTriangularMatrix U1 = U;
U1.SubMatrix(4,8,5,9) /= 2;
U1.SubMatrix(4,8,5,9) += 388 * V;
U1.SubMatrix(4,8,5,9) *= 2;
U1.SubMatrix(4,8,5,9) += V;
U1 -= U; UpperTriangularMatrix U2 = U1;
U1 << U1.SubMatrix(4,8,5,9);
U2.SubMatrix(4,8,5,9) -= U1; Print(U2);
U1 -= (777*V); Print(U1);
U1 = U; U1.SubMatrix(4,8,5,9) -= U.SymSubMatrix(1,5);
U1 -= U; U2 = U1; U1 << U1.SubMatrix(4,8,5,9);
U2.SubMatrix(4,8,5,9) -= U1; Print(U2);
U1 += V; Print(U1);
U1 = U;
U1.SubMatrix(3,10,15,19) += 29;
U1 -= U;
Matrix X = U1.SubMatrix(3,10,15,19); X -= 29; Print(X);
U1.SubMatrix(3,10,15,19) *= 0; Print(U1);
LowerTriangularMatrix L = U.t();
LowerTriangularMatrix M = L.SymSubMatrix(1,5);
LowerTriangularMatrix L1 = L;
L1.SubMatrix(5,9,4,8) /= 2;
L1.SubMatrix(5,9,4,8) += 388 * M;
L1.SubMatrix(5,9,4,8) *= 2;
L1.SubMatrix(5,9,4,8) += M;
L1 -= L; LowerTriangularMatrix L2 = L1;
L1 << L1.SubMatrix(5,9,4,8);
L2.SubMatrix(5,9,4,8) -= L1; Print(L2);
L1 -= (777*M); Print(L1);
L1 = L; L1.SubMatrix(5,9,4,8) -= L.SymSubMatrix(1,5);
L1 -= L; L2 =L1; L1 << L1.SubMatrix(5,9,4,8);
L2.SubMatrix(5,9,4,8) -= L1; Print(L2);
L1 += M; Print(L1);
L1 = L;
L1.SubMatrix(15,19,3,10) -= 29;
L1 -= L;
X = L1.SubMatrix(15,19,3,10); X += 29; Print(X);
L1.SubMatrix(15,19,3,10) *= 0; Print(L1);
}
{
Tracer et1("Stage 11");
// more tests on submatrices
Matrix M(20,30);
for (i=1; i<=20; i++) for (j=1; j<=30; j++) M(i,j)=100 * i + j;
Matrix M1 = M;
for (j=1; j<=30; j++)
{ ColumnVector CV = 3 * M1.Column(j); M.Column(j) += CV; }
for (i=1; i<=20; i++)
{ RowVector RV = 5 * M1.Row(i); M.Row(i) -= RV; }
M += M1; Print(M);
}
{
Tracer et1("Stage 12");
// more tests on Release
Matrix M(20,30);
for (i=1; i<=20; i++) for (j=1; j<=30; j++) M(i,j)=100 * i + j;
Matrix M1 = M;
M.Release();
Matrix M2 = M;
Matrix X = M; Print(X);
X = M1 - M2; Print(X);
#ifndef DONT_DO_NRIC
nricMatrix N = M1;
nricMatrix N1 = N;
N.Release();
nricMatrix N2 = N;
nricMatrix Y = N; Print(Y);
Y = N1 - N2; Print(Y);
N = M1 / 2; N1 = N * 2; N.Release(); N2 = N * 2; Y = N; Print(N);
Y = (N1 - M1) | (N2 - M1); Print(Y);
#endif
}
{
Tracer et("Stage 13");
// test sum of squares of rows or columns
MultWithCarry mwc;
DiagonalMatrix DM; Matrix X;
// rectangular matrix
Matrix A(20, 15);
FillWithValues(mwc, A);
// sum of squares of rows
DM << A * A.t();
ColumnVector CV = A.sum_square_rows();
X = CV - DM.AsColumn(); Clean(X, 0.000000001); Print(X);
DM << A.t() * A;
RowVector RV = A.sum_square_columns();
X = RV - DM.AsRow(); Clean(X, 0.000000001); Print(X);
X = RV - A.t().sum_square_rows().t(); Clean(X, 0.000000001); Print(X);
X = CV - A.t().sum_square_columns().t(); Clean(X, 0.000000001); Print(X);
// UpperTriangularMatrix
A.ReSize(17,17); FillWithValues(mwc, A);
UpperTriangularMatrix UT; UT << A;
Matrix A1 = UT;
X = UT.sum_square_rows() - A1.sum_square_rows(); Print(X);
X = UT.sum_square_columns() - A1.sum_square_columns(); Print(X);
// LowerTriangularMatrix
LowerTriangularMatrix LT; LT << A;
A1 = LT;
X = LT.sum_square_rows() - A1.sum_square_rows(); Print(X);
X = LT.sum_square_columns() - A1.sum_square_columns(); Print(X);
// SymmetricMatrix
SymmetricMatrix SM; SM << A;
A1 = SM;
X = SM.sum_square_rows() - A1.sum_square_rows(); Print(X);
X = SM.sum_square_columns() - A1.sum_square_columns(); Print(X);
// DiagonalMatrix
DM << A;
A1 = DM;
X = DM.sum_square_rows() - A1.sum_square_rows(); Print(X);
X = DM.sum_square_columns() - A1.sum_square_columns(); Print(X);
// BandMatrix
BandMatrix BM(17, 3, 5); BM.Inject(A);
A1 = BM;
X = BM.sum_square_rows() - A1.sum_square_rows(); Print(X);
X = BM.sum_square_columns() - A1.sum_square_columns(); Print(X);
// SymmetricBandMatrix
SymmetricBandMatrix SBM(17, 4); SBM.Inject(A);
A1 = SBM;
X = SBM.sum_square_rows() - A1.sum_square_rows(); Print(X);
X = SBM.sum_square_columns() - A1.sum_square_columns(); Print(X);
// IdentityMatrix
IdentityMatrix IM(29);
X = IM.sum_square_rows() - 1; Print(X);
X = IM.sum_square_columns() - 1; Print(X);
// Matrix with zero rows
A1.ReSize(0,10);
X.ReSize(1,10); X = 0; X -= A1.sum_square_columns(); Print(X);
X.ReSize(0,1); X -= A1.sum_square_rows(); Print(X);
// Matrix with zero columns
A1.ReSize(10,0);
X.ReSize(10,1); X = 0; X -= A1.sum_square_rows(); Print(X);
X.ReSize(1,0); X -= A1.sum_square_columns(); Print(X);
}
{
Tracer et("Stage 14");
// test extend orthonormal
MultWithCarry mwc;
Matrix A(20,5); FillWithValues(mwc, A);
// Orthonormalise
UpperTriangularMatrix R;
Matrix A_old = A;
QRZ(A,R);
// Check decomposition
Matrix X = A * R - A_old; Clean(X, 0.000000001); Print(X);
// Check orthogonality
X = A.t() * A - IdentityMatrix(5);
Clean(X, 0.000000001); Print(X);
// Try orthonality extend
SquareMatrix A1(20);
A1.Columns(1,5) = A;
extend_orthonormal(A1,5);
// check columns unchanged
X = A - A1.Columns(1,5); Print(X);
// Check orthogonality
X = A1.t() * A1 - IdentityMatrix(20);
Clean(X, 0.000000001); Print(X);
X = A1 * A1.t() - IdentityMatrix(20);
Clean(X, 0.000000001); Print(X);
// Test with smaller number of columns
Matrix A2(20,15);
A2.Columns(1,5) = A;
extend_orthonormal(A2,5);
// check columns unchanged
X = A - A2.Columns(1,5); Print(X);
// Check orthogonality
X = A2.t() * A2 - IdentityMatrix(15);
Clean(X, 0.000000001); Print(X);
// check it works with no columns to start with
A2.ReSize(100,100);
extend_orthonormal(A2,0);
// Check orthogonality
X = A2.t() * A2 - IdentityMatrix(100);
Clean(X, 0.000000001); Print(X);
X = A2 * A2.t() - IdentityMatrix(100);
Clean(X, 0.000000001); Print(X);
}
// cout << "\nEnd of twelfth test\n";
}
static void tred2(const SymmetricMatrix& A, DiagonalMatrix& D,
DiagonalMatrix& E, Matrix& Z)
{
Tracer et("Evalue(tred2)");
Real tol =
FloatingPointPrecision::Minimum()/FloatingPointPrecision::Epsilon();
int n = A.Nrows(); Z.ReSize(n,n); Z.Inject(A);
D.ReSize(n); E.ReSize(n);
Real* z = Z.Store(); int i;
for (i=n-1; i > 0; i--) // i=0 is excluded
{
Real f = Z.element(i,i-1); Real g = 0.0;
int k = i-1; Real* zik = z + i*n;
while (k--) g += square(*zik++);
Real h = g + square(f);
if (g <= tol) { E.element(i) = f; h = 0.0; }
else
{
g = sign(-sqrt(h), f); E.element(i) = g; h -= f*g;
Z.element(i,i-1) = f-g; f = 0.0;
Real* zji = z + i; Real* zij = z + i*n; Real* ej = E.Store();
int j;
for (j=0; j<i; j++)
{
*zji = (*zij++)/h; g = 0.0;
Real* zjk = z + j*n; zik = z + i*n;
k = j; while (k--) g += *zjk++ * (*zik++);
k = i-j; while (k--) { g += *zjk * (*zik++); zjk += n; }
*ej++ = g/h; f += g * (*zji); zji += n;
}
Real hh = f / (h + h); zij = z + i*n; ej = E.Store();
for (j=0; j<i; j++)
{
f = *zij++; g = *ej - hh * f; *ej++ = g;
Real* zjk = z + j*n; Real* zik = z + i*n;
Real* ek = E.Store(); k = j+1;
while (k--) *zjk++ -= ( f*(*ek++) + g*(*zik++) );
}
}
D.element(i) = h;
}
D.element(0) = 0.0; E.element(0) = 0.0;
for (i=0; i<n; i++)
{
if (D.element(i) != 0.0)
{
for (int j=0; j<i; j++)
{
Real g = 0.0;
Real* zik = z + i*n; Real* zkj = z + j;
int k = i; while (k--) { g += *zik++ * (*zkj); zkj += n; }
Real* zki = z + i; zkj = z + j;
k = i; while (k--) { *zkj -= g * (*zki); zkj += n; zki += n; }
}
}
Real* zij = z + i*n; Real* zji = z + i;
int j = i; while (j--) { *zij++ = 0.0; *zji = 0.0; zji += n; }
D.element(i) = *zij; *zij = 1.0;
}
}
double SweepOnepdm::do_one(SweepParams &sweepParams, const bool &warmUp, const bool &forward, const bool &restart, const int &restartSize, int state)
{
Timer sweeptimer;
int integralIndex = 0;
SpinBlock system;
const int nroots = dmrginp.nroots();
std::vector<double> finalEnergy(nroots,0.);
std::vector<double> finalEnergy_spins(nroots,0.);
double finalError = 0.;
int pdmsize = dmrginp.spinAdapted() ? 2*dmrginp.last_site() : dmrginp.last_site();
Matrix onepdm(pdmsize, pdmsize);onepdm=0.0;
Matrix pairmat;
if (dmrginp.hamiltonian() == BCS) {
pairmat.ReSize(pdmsize, pdmsize);
pairmat = 0.0;
save_pairmat_binary(pairmat, state, state);
}
save_onepdm_binary(onepdm, state ,state);
sweepParams.set_sweep_parameters();
// a new renormalisation sweep routine
pout << ((forward) ? "\t\t\t Starting renormalisation sweep in forwards direction" : "\t\t\t Starting renormalisation sweep in backwards direction") << endl;
pout << "\t\t\t ============================================================================ " << endl;
InitBlocks::InitStartingBlock (system,forward, sweepParams.current_root(), sweepParams.current_root(), sweepParams.get_forward_starting_size(), sweepParams.get_backward_starting_size(), restartSize, restart, warmUp, integralIndex);
sweepParams.set_block_iter() = 0;
pout << "\t\t\t Starting block is :: " << endl << system << endl;
SpinBlock::store (forward, system.get_sites(), system, sweepParams.current_root(), sweepParams.current_root()); // if restart, just restoring an existing block --
sweepParams.savestate(forward, system.get_sites().size());
bool dot_with_sys = true;
sweepParams.set_guesstype() = TRANSPOSE;
for (; sweepParams.get_block_iter() < sweepParams.get_n_iters(); )
{
pout << "\n\t\t\t Block Iteration :: " << sweepParams.get_block_iter() << endl;
pout << "\t\t\t ----------------------------" << endl;
if (forward)
p1out << "\t\t\t Current direction is :: Forwards " << endl;
else
p1out << "\t\t\t Current direction is :: Backwards " << endl;
if (sweepParams.get_block_iter() == 0)
sweepParams.set_guesstype() = TRANSPOSE;
else
sweepParams.set_guesstype() = TRANSFORM;
p1out << "\t\t\t Blocking and Decimating " << endl;
SpinBlock newSystem;
BlockAndDecimate (sweepParams, system, newSystem, warmUp, dot_with_sys, state);
pout.precision(12);
system = newSystem;
pout << system<<endl;
SpinBlock::store (forward, system.get_sites(), system, sweepParams.current_root(), sweepParams.current_root());
p1out << "\t\t\t saving state " << system.get_sites().size() << endl;
++sweepParams.set_block_iter();
//sweepParams.savestate(forward, system.get_sites().size());
}
pout << "\t\t\t The lowest sweep energy : "<< sweepParams.get_lowest_energy()[0] << endl;
pout << "\t\t\t ============================================================================ " << endl;
load_onepdm_binary(onepdm, state ,state);
accumulate_onepdm(onepdm);
save_onepdm_spatial_text(onepdm, state, state);
save_onepdm_text(onepdm, state, state);
save_onepdm_spatial_binary(onepdm, state, state);
if (dmrginp.hamiltonian() == BCS) {
load_pairmat_binary(pairmat, state, state);
accumulate_onepdm(pairmat);
// FIXME write out text version
// only <D{ia}D{jb}> is in the matrix
save_pairmat_text(pairmat , state, state);
}
ecpu = sweeptimer.elapsedcputime(); ewall = sweeptimer.elapsedwalltime();
pout << "\t\t\t Elapsed Sweep CPU Time (seconds): " << setprecision(3) << ecpu << endl;
pout << "\t\t\t Elapsed Sweep Wall Time (seconds): " << setprecision(3) << ewall << endl;
return sweepParams.get_lowest_energy()[0];
}
void ReSizeMatrix(Matrix& A)
// for seeing if we can redimension a vector as a matrix
{ A.ReSize(4,5); }
inline void resize(Matrix& m, size_t row, size_t col)
{
m.ReSize(row, col);
}
//centrilize and scale the point set
// xn = T*x;
// x: every column represent a point [3*N]
bool q_normalize_points(const vector<Coord3D_PCM> vec_input,vector<Coord3D_PCM> &vec_output,Matrix &x4x4_normalize)
{
//check parameters
if(vec_input.size()<=0)
{
fprintf(stderr,"ERROR: Input array is null! \n");
return false;
}
if(!vec_output.empty())
vec_output.clear();
vec_output=vec_input;
if(x4x4_normalize.nrows()!=4 || x4x4_normalize.ncols()!=4)
{
x4x4_normalize.ReSize(4,4);
}
//compute the centriod of input point set
Coord3D_PCM cord_centroid;
int n_point=vec_input.size();
for(int i=0;i<n_point;i++)
{
cord_centroid.x+=vec_input[i].x;
cord_centroid.y+=vec_input[i].y;
cord_centroid.z+=vec_input[i].z;
}
cord_centroid.x/=n_point;
cord_centroid.y/=n_point;
cord_centroid.z/=n_point;
//center the point set
for(int i=0;i<n_point;i++)
{
vec_output[i].x-=cord_centroid.x;
vec_output[i].y-=cord_centroid.y;
vec_output[i].z-=cord_centroid.z;
}
//compute the average distance of every point to the origin
double d_point2o=0,d_point2o_avg=0;
for(int i=0;i<n_point;i++)
{
d_point2o=sqrt(vec_output[i].x*vec_output[i].x+vec_output[i].y*vec_output[i].y+vec_output[i].z*vec_output[i].z);
d_point2o_avg+=d_point2o;
}
d_point2o_avg/=n_point;
//compute the scale factor
double d_scale_factor=1.0/d_point2o_avg;
//scale the point set
for(int i=0;i<n_point;i++)
{
vec_output[i].x*=d_scale_factor;
vec_output[i].y*=d_scale_factor;
vec_output[i].z*=d_scale_factor;
}
//compute the transformation matrix
// 1 row
x4x4_normalize(1,1)=d_scale_factor;
x4x4_normalize(1,2)=0;
x4x4_normalize(1,3)=0;
x4x4_normalize(1,4)=-d_scale_factor*cord_centroid.x;
// 2 row
x4x4_normalize(2,1)=0;
x4x4_normalize(2,2)=d_scale_factor;
x4x4_normalize(2,3)=0;
x4x4_normalize(2,4)=-d_scale_factor*cord_centroid.y;
// 3 row
x4x4_normalize(3,1)=0;
x4x4_normalize(3,2)=0;
x4x4_normalize(3,3)=d_scale_factor;
x4x4_normalize(3,4)=-d_scale_factor*cord_centroid.z;
// 4 row
x4x4_normalize(4,1)=0;
x4x4_normalize(4,2)=0;
x4x4_normalize(4,3)=0;
x4x4_normalize(4,4)=1;
return true;
}
void IsolatedWordRecogDialog::recognize(MotionClip* pmc, int nStartFn, int nEndFn)
{
MotionEditor editor;
MotionClip* pmctmp = editor.CreateSubMotion(pmc, nStartFn, nEndFn);
if (pmctmp)
{
// The first layer
RuleNode* prn = SwiftModel::instance().m_prm->findCandidateNode(pmctmp, SwiftModel::instance().m_prm->m_pRootRuleNode);
if (prn)
{
std::map<std::string, FStrongClassifier*>::iterator itfsc;
std::vector<std::string> vFResult;
// The second layer
int result=0;
for (int i=0; i<prn->m_vSigns.size(); i++)
{
itfsc = SwiftModel::instance().m_mFStrongClassifier.find(prn->m_vSigns.at(i));
result = itfsc->second->recognize(pmctmp);
if (result == 1)
{
vFResult.push_back(itfsc->first);
}
}
// The third layer
MotionJoint *pmjlw, *pmjle, *pmjrw, *pmjre, *pmjlw1, *pmjle1, *pmjrw1, *pmjre1;
pmjlw = pmctmp->findJoint("l_wrist");
pmjle = pmctmp->findJoint("l_elbow");
pmjrw = pmctmp->findJoint("r_wrist");
pmjre = pmctmp->findJoint("r_elbow");
Matrix test;
long nSamples = pmctmp->getFrameCount();
int nDimention = 20;
test.ReSize(nDimention,nSamples);
std::vector<double> vFlex;
std::vector<double> vDist;
std::vector<double> vOriX, vOriY, vOriZ;
MotionJoint *pmj0, *pmj1, *pmj2, *pmj3, *pmj4;
InfoCalcualtor calculator;
// Right thumb finger
pmj0 = pmctmp->findJoint("r_thumb0");
pmj1 = pmctmp->findJoint("r_thumb1");
pmj2 = pmctmp->findJoint("r_thumb2");
pmj3 = pmctmp->findJoint("r_thumb3");
pmj4 = pmctmp->getChild(pmj3, 0);
calculator.calFingerFlex(pmj0, pmj1, pmj2, pmj3, pmj4, 0, nSamples-1, vFlex, 190);
int k=0;
for (int j=0; j<nSamples; j++)
{
test.element(k,j)=vFlex.at(j);
}
vFlex.clear();
// Right index finger
pmj0 = pmctmp->findJoint("r_index0");
pmj1 = pmctmp->findJoint("r_index1");
pmj2 = pmctmp->findJoint("r_index2");
pmj3 = pmctmp->findJoint("r_index3");
pmj4 = pmctmp->getChild(pmj3, 0);
calculator.calFingerFlex(pmj0, pmj1, pmj2, pmj3, pmj4, 0, nSamples-1, vFlex, 250);
k++;
for (int j=0; j<nSamples; j++)
{
test.element(k,j)=vFlex.at(j);
}
vFlex.clear();
// Right middle finger
pmj0 = pmctmp->findJoint("r_middle0");
pmj1 = pmctmp->findJoint("r_middle1");
pmj2 = pmctmp->findJoint("r_middle2");
pmj3 = pmctmp->findJoint("r_middle3");
pmj4 = pmctmp->getChild(pmj3, 0);
calculator.calFingerFlex(pmj0, pmj1, pmj2, pmj3, pmj4, 0, nSamples-1, vFlex, 250);
k++;
for (int j=0; j<nSamples; j++)
{
test.element(k,j)=vFlex.at(j);
}
vFlex.clear();
// Right ring finger
pmj0 = pmctmp->findJoint("r_ring0");
pmj1 = pmctmp->findJoint("r_ring1");
pmj2 = pmctmp->findJoint("r_ring2");
pmj3 = pmctmp->findJoint("r_ring3");
pmj4 = pmctmp->getChild(pmj3, 0);
calculator.calFingerFlex(pmj0, pmj1, pmj2, pmj3, pmj4, 0, nSamples-1, vFlex, 250);
k++;
for (int j=0; j<nSamples; j++)
{
test.element(k,j)=vFlex.at(j);
}
vFlex.clear();
// Right little finger
pmj0 = pmctmp->findJoint("r_pinky0");
pmj1 = pmctmp->findJoint("r_pinky1");
pmj2 = pmctmp->findJoint("r_pinky2");
pmj3 = pmctmp->findJoint("r_pinky3");
pmj4 = pmctmp->getChild(pmj3, 0);
calculator.calFingerFlex(pmj0, pmj1, pmj2, pmj3, pmj4, 0, nSamples-1, vFlex, 250);
k++;
for (int j=0; j<nSamples; j++)
{
test.element(k,j)=vFlex.at(j);
}
vFlex.clear();
// Left thumb finger
pmj0 = pmctmp->findJoint("l_thumb0");
pmj1 = pmctmp->findJoint("l_thumb1");
pmj2 = pmctmp->findJoint("l_thumb2");
pmj3 = pmctmp->findJoint("l_thumb3");
pmj4 = pmctmp->getChild(pmj3, 0);
calculator.calFingerFlex(pmj0, pmj1, pmj2, pmj3, pmj4, 0, nSamples-1, vFlex, 190);
k++;
for (int j=0; j<nSamples; j++)
{
test.element(k,j)=vFlex.at(j);
}
vFlex.clear();
// Left index finger
pmj0 = pmctmp->findJoint("l_index0");
pmj1 = pmctmp->findJoint("l_index1");
pmj2 = pmctmp->findJoint("l_index2");
pmj3 = pmctmp->findJoint("l_index3");
pmj4 = pmctmp->getChild(pmj3, 0);
calculator.calFingerFlex(pmj0, pmj1, pmj2, pmj3, pmj4, 0, nSamples-1, vFlex, 250);
k++;
for (int j=0; j<nSamples; j++)
{
test.element(k,j)=vFlex.at(j);
}
vFlex.clear();
// Left middle finger
pmj0 = pmctmp->findJoint("l_middle0");
pmj1 = pmctmp->findJoint("l_middle1");
pmj2 = pmctmp->findJoint("l_middle2");
pmj3 = pmctmp->findJoint("l_middle3");
pmj4 = pmctmp->getChild(pmj3, 0);
calculator.calFingerFlex(pmj0, pmj1, pmj2, pmj3, pmj4, 0, nSamples-1, vFlex, 250);
k++;
for (int j=0; j<nSamples; j++)
{
test.element(k,j)=vFlex.at(j);
}
vFlex.clear();
// Left ring finger
pmj0 = pmctmp->findJoint("l_ring0");
pmj1 = pmctmp->findJoint("l_ring1");
pmj2 = pmctmp->findJoint("l_ring2");
pmj3 = pmctmp->findJoint("l_ring3");
pmj4 = pmctmp->getChild(pmj3, 0);
calculator.calFingerFlex(pmj0, pmj1, pmj2, pmj3, pmj4, 0, nSamples-1, vFlex, 250);
k++;
for (int j=0; j<nSamples; j++)
{
test.element(k,j)=vFlex.at(j);
}
vFlex.clear();
// Left little finger
pmj0 = pmctmp->findJoint("l_pinky0");
pmj1 = pmctmp->findJoint("l_pinky1");
pmj2 = pmctmp->findJoint("l_pinky2");
pmj3 = pmctmp->findJoint("l_pinky3");
pmj4 = pmctmp->getChild(pmj3, 0);
calculator.calFingerFlex(pmj0, pmj1, pmj2, pmj3, pmj4, 0, nSamples-1, vFlex, 250);
k++;
for (int j=0; j<nSamples; j++)
{
test.element(k,j)=vFlex.at(j);
}
vFlex.clear();
pmj1 = pmctmp->findJoint("r_wrist");
pmj2 = pmctmp->findJoint("root");
calculator.calDist(pmj1, pmj2, 0, nSamples-1, vDist);
k++;
for (int j=0; j<nSamples; j++)
{
test.element(k,j)=vDist.at(j);
}
vDist.clear();
pmj2 = pmctmp->findJoint("skullbase");
calculator.calDist(pmj1, pmj2, 0, nSamples-1, vDist);
k++;
for (int j=0; j<nSamples; j++)
{
test.element(k,j)=vDist.at(j);
}
vDist.clear();
pmj1 = pmctmp->findJoint("l_wrist");
pmj2 = pmctmp->findJoint("root");
calculator.calDist(pmj1, pmj2, 0, nSamples-1, vDist);
k++;
for (int j=0; j<nSamples; j++)
{
test.element(k,j)=vDist.at(j);
}
vDist.clear();
pmj2 = pmctmp->findJoint("skullbase");
calculator.calDist(pmj1, pmj2, 0, nSamples-1, vDist);
k++;
for (int j=0; j<nSamples; j++)
{
test.element(k,j)=vDist.at(j);
}
vDist.clear();
pmj1 = pmctmp->findJoint("r_wrist");
pmj2 = pmctmp->findJoint("r_index1");
pmj3 = pmctmp->findJoint("r_ring1");
calculator.calPalmOri(pmctmp, pmj1, pmj2, pmj3, 0, nSamples-1, vOriX, vOriY, vOriZ);
for (int j=0; j<nSamples; j++)
{
test.element(k+1,j)=vOriX.at(j);
test.element(k+2,j)=vOriY.at(j);
test.element(k+3,j)=vOriZ.at(j);
}
k+=3;
vOriX.clear();
vOriY.clear();
vOriZ.clear();
pmj1 = pmctmp->findJoint("l_wrist");
pmj2 = pmctmp->findJoint("l_index1");
pmj3 = pmctmp->findJoint("l_ring1");
calculator.calPalmOri(pmc, pmj1, pmj2, pmj3, 0, nSamples-1, vOriX, vOriY, vOriZ);
for (int j=0; j<nSamples; j++)
{
test.element(k+1,j)=vOriX.at(j);
test.element(k+2,j)=vOriY.at(j);
test.element(k+3,j)=vOriZ.at(j);
}
k+=3;
vOriX.clear();
vOriY.clear();
vOriZ.clear();
double dmax = -1.0e100, d;
std::string str;
RecogResult rr;
std::vector<RecogResult> vResult;
QString strBestN = ui.lineEdit_BestN->text();
int nBestN = strBestN.toInt();
std::map<std::string, HMM*>::iterator it;
for (int i=0; i<vFResult.size(); i++)
{
it = HMMModel::instance().m_mHMM.find(vFResult.at(i));
if (it != HMMModel::instance().m_mHMM.end())
{
d = it->second->viterbi_p(test);
//if (d > dmax)
//{
// dmax = d;
// str = it->first;
//}
rr.strSign = it->first;
rr.dScore = d;
if(vResult.size() == nBestN)
{
HMMModel::instance().sortResut(vResult);
if (vResult.back().dScore < d)
{
vResult.erase(vResult.end()-1);
vResult.push_back(rr);
}
}
else
{
vResult.push_back(rr);
}
}
}
HMMModel::instance().sortResut(vResult);
ui.textBrowser_Result->setText("The best "+QString::number(vResult.size())+" candidates and their scores:");
for (int i=0; i<vResult.size(); i++)
{
ui.textBrowser_Result->append(QString::fromStdString(vResult.at(i).strSign)+": "+QString::number(vResult.at(i).dScore));
}
ui.textBrowser_Result->append("");
}
}
}
void SpinAdapted::OneElectronArray::ReadFromDumpFile(ifstream& dumpFile, int norbs) {
pout << "OneElectronArray::ReadFromDumpFile is deprecated" << endl;
if (bin) {
dumpFile.seekg (0, ios::end);
//int size = dumpFile.tellg();
double size = dumpFile.tellg();
dumpFile.seekg (0, ios::beg);
FORTINT nmo = rhf ? static_cast<int>(2*sqrt(size / (sizeof(double)))) : static_cast<int>(sqrt(size / (sizeof(double))));
ReSize(nmo);
if (rhf) nmo /= 2;
char buffer[nmo*nmo*sizeof(double)] ;
dumpFile.read(buffer, nmo*nmo*sizeof(double));
Matrix Aoints, Moints;
Aoints.ReSize(nmo,nmo);
Moints.ReSize(nmo, nmo);
Aoints = 0;
for(int i=0;i<nmo;++i)
for(int j=0; j<nmo; ++j)
{
int a=i,b=j;
Aoints(a+1,b+1) = ((double*)(&buffer[(i*nmo +j)*sizeof(double)]))[0];
}
//the above are the ao integrals...need mo integrals
//first read the mo coefficients
ifstream moCoeff;
moCoeff.open("42.0", ios::binary);
if (rhf) {
Matrix CoeffMatrix;
CoeffMatrix.ReSize(nmo, nmo);
char coeffchars[nmo*nmo*sizeof(double)];
moCoeff.read(coeffchars, nmo*nmo*sizeof(double));
double* coeffs = ((double*)(coeffchars));
for (int i=0; i<nmo; i++)
for (int j=0; j<nmo; j++) {
CoeffMatrix(i+1,j+1) = coeffs[i*nmo+j];
}
moCoeff.read(coeffchars, nmo*sizeof(double));
double* occnums = ((double*)(coeffchars));
Occnum.resize(2*nmo);
for (int i=0; i<nmo; i++) {
Occnum.at(2*i) = occnums[i];
Occnum.at(2*i+1) = occnums[i];
}
double scale=1.0, cfactor=0.0;
double* inter = new double[nmo*nmo];
char n='n', t='t';
dgemm_ (&n, &n, &nmo, &nmo, &nmo, &scale, Aoints.Store(), &nmo, CoeffMatrix.Store (), &nmo, &cfactor, inter, &nmo);
dgemm_ (&t, &n, &nmo, &nmo, &nmo, &scale, CoeffMatrix.Store (), &nmo, inter, &nmo, &cfactor, Moints.Store (), &nmo);
delete [] inter;
for(int i=0;i<nmo;++i)
for(int j=0; j<nmo; ++j)
{
int a=i,b=j;
if (rhf)
{
a*=2;
b*=2;
}
(*this)(a,b) = Moints(a/2+1, b/2+1);
}
}
}
else {
int n = 0;
string msg; int msgsize = 5000;
Input::ReadMeaningfulLine(dumpFile, msg, msgsize);
vector<string> tok;
boost::split(tok, msg, is_any_of(" \t"), token_compress_on);
if (tok.size() != 1) {
perr << "The first line of one electron integral file should be number of orbitals"<<endl;
perr << "Error at line :"<<msg<<endl;
abort();
}
if (atoi(tok[0].c_str()) != norbs) {
perr << "Number of orbitals in one electron integral file should be equal to one given in input file"<<endl;
perr << "# orbs in input file : "<<norbs<<endl;
perr << "# orbs in one electron integral file : "<<atoi(tok[0].c_str())/2<<endl;
abort();
}
n = norbs;
if (rhf)
{
n=2*n;
}
ReSize(n);
int i, j;
Input::ReadMeaningfulLine(dumpFile, msg, msgsize);
while (msg.size() != 0)
{
boost::split(tok, msg, is_any_of(" \t"), token_compress_on);
if (tok.size() != 3) {
perr<< "The format of one electron integral file incorrect"<<endl;
perr <<"error at this line: "<<msg<<endl;
abort();
}
i = atoi(tok[0].c_str());
j = atoi(tok[1].c_str());
if (i >= n || j >= n) {
perr << "index of orbitals in one electron integral file cannot be bigger than "<<n<<endl;
perr<< "error at this line: "<<msg<<endl;
abort();
}
if (rhf)
{
i=2*i;
j=2*j;
}
(*this)(i, j) = atof(tok[2].c_str());
msg.resize(0);
Input::ReadMeaningfulLine(dumpFile, msg, msgsize);
}
}
}
