void ThreadProc( PBYTE *pMem )
{
int i;
InterlockedIncrement( (PLONG)&nThreads );
Sleep(500); // wait for more threads to start up too..
// initial state - have to do an allocate....
// Release( Allocate( 1 ) );
// DebugDumpMem();
for( i = 0; i < 10; i++ )
{
T1 (A1(pMem));
// Sleep(0);
T2 (A1(pMem));
// Sleep(0);
T3 (A1(pMem));
// Sleep(0);
T3i (A1(pMem));
// Sleep(0);
T3is(A1(pMem));
// Sleep(0);
T4 (A1(pMem));
// Sleep(0);
T5 (A1(pMem));
// Sleep(0);
T1 (A2(pMem));
// Sleep(0);
T2 (A2(pMem));
// Sleep(0);
T3 (A2(pMem));
// Sleep(0);
T3i (A2(pMem));
// Sleep(0);
T3is(A2(pMem));
// Sleep(0);
T4 (A2(pMem));
// Sleep(0);
T5 (A1(pMem));
// Sleep(0);
T1 (A2i(pMem));
// Sleep(0);
T2 (A2i(pMem));
// Sleep(0);
T3 (A2i(pMem));
// Sleep(0);
T3i (A2i(pMem));
// Sleep(0);
T3is(A2i(pMem));
// Sleep(0);
T4 (A2i(pMem));
// Sleep(0);
T5 (A1(pMem));
// Sleep(0);
}
InterlockedDecrement( (PLONG)&nThreads );
ExitThread(0);
}
sequence(
const T1& t1 = T1(),
const T2& t2 = T2(),
const T3& t3 = T3(),
const T4& t4 = T4(),
const T5& t5 = T5(),
const T6& t6 = T6(),
const T7& t7 = T7(),
const T8& t8 = T8(),
const T9& t9 = T9(),
const T10& t10 = T10(),
const T11& t11 = T11(),
const T12& t12 = T12(),
const T13& t13 = T13(),
const T14& t14 = T14(),
const T15& t15 = T15(),
const T16& t16 = T16(),
const T17& t17 = T17() ) :
p1(t1),
p2(t2),
p3(t3),
p4(t4),
p5(t5),
p6(t6),
p7(t7),
p8(t8),
p9(t9),
p10(t10),
p11(t11),
p12(t12),
p13(t13),
p14(t14),
p15(t15),
p16(t16),
p17(t17) {}
double getAveragePtr(T4 *array,int n){
T4 sum = T4(); //sum = 0
for(int i=0;i<n;i++)
sum += *(array+i);
return double(sum)/n;
}
int main()
{
T1();
T2();
T3();
T4();
return 0;
}
int main(void)
{
T1();
T2();
T3();
T4();
T5();
T6();
return 0;
}
int main(void)
{
T1();
T2();
T3();
T4();
T5();
T6();
T7();
T8();
T9();
T10();
T11();
return 0;
}
XC::BJtensor XC::DPPotentialSurface::d2Qods2(const XC::EPState *EPS) const {
BJtensor d2Qods2(4, def_dim_4, 0.0);
BJtensor KroneckerI("I", 2, def_dim_2);
BJtensor T1 = KroneckerI("ij")*KroneckerI("mn");
T1.null_indices();
BJtensor T2 = (T1.transpose0110()+T1.transpose0111())*0.5;
BJtensor T3 = T2 - T1*(1.0/3.0);
//double temp1 = EPS->getScalarVar(1);
//double temp1 = getalfa2();
BJtensor T4;
XC::stresstensor alpha;
XC::stresstensor s_bar;
BJtensor temp9(4, def_dim_4, 0.0);
XC::stresstensor sigma = EPS->getStress();
double p = sigma.p_hydrostatic();
XC::stresstensor sdev = sigma.deviator();
double halfRt2 = 0.5 * sqrt(2.0);
int nod = EPS->getNTensorVar();
if ( nod >=1 ) { //May not have kinematic hardening
alpha = EPS->getTensorVar(1);
temp9 = KroneckerI("ij") * alpha("mn");
temp9.null_indices();
T4 = T2 + temp9*(1.0/3.0);
s_bar = sdev - (alpha*p);
}
else {
s_bar = sdev;
T4 = T2;
}
T4 = T2 - temp9;
BJtensor temp3 = s_bar("ij") * s_bar("ij");
temp3.null_indices();
double temp4 = temp3.trace();
temp4 = sqrt(temp4);
BJtensor temp5 = s_bar("ij")*s_bar("mn");
double eps = pow( d_macheps(), 0.5 );
if ( fabs(temp4) > eps ) {
d2Qods2 = T3 * (halfRt2/temp4) - temp5*(halfRt2/(temp4*temp4*temp4));
d2Qods2 = T4("ijkl") * d2Qods2("klmn");
d2Qods2.null_indices();
}
return d2Qods2;
}
rgpprob1::rgpprob1() : rgp_base(NUM_VARS)
{
// Objective function: h^-1 w^-1 d^-1 (inverse of volume)
{ monomial<aaf> obj(NUM_VARS);
obj._a[h] = aaf(-1.0); obj._a[w] = aaf(-1.0); obj._a[d] = aaf(-1.0);
obj.set_coeff(aaf(1.0));
rgp_base::_M.push_back( posynomial<aaf>(obj) ); }
// (2/Awall)hw + (2/Awall)hd <= 1
{ monomial<aaf> T11(NUM_VARS);
T11._a[h] = aaf(1.0); T11._a[w] = aaf(1.0);
T11.set_coeff(2./Awall);
monomial<aaf> T12(NUM_VARS);
T12._a[h] = aaf(1.0); T12._a[d] = aaf(1.0);
T12.set_coeff(2./Awall);
posynomial<aaf> P1(T11);
P1 += T12;
rgp_base::_M.push_back(P1); }
{ monomial<aaf> T2(NUM_VARS);
T2._a[w] = aaf(1.0); T2._a[d] = aaf(1.0);
T2.set_coeff(1./Aflr);
rgp_base::_M.push_back( posynomial<aaf>(T2) ); }
{ monomial<aaf> T3(NUM_VARS);
T3._a[h] = aaf(-1.0); T3._a[w] = aaf(1.0);
T3.set_coeff(alpha);
rgp_base::_M.push_back( posynomial<aaf>(T3) ); }
{ monomial<aaf> T4(NUM_VARS);
T4._a[h] = aaf(1.0); T4._a[w] = aaf(-1.0);
T4.set_coeff(1./beta);
rgp_base::_M.push_back( posynomial<aaf>(T4) ); }
{ monomial<aaf> T5(NUM_VARS);
T5._a[w] = aaf(1.0); T5._a[d] = aaf(-1.0);
T5.set_coeff(gamma2);
rgp_base::_M.push_back( posynomial<aaf>(T5) ); }
{ monomial<aaf> T6(NUM_VARS);
T6._a[w] = aaf(-1.0); T6._a[d] = aaf(1.0);
T6.set_coeff(1./delta);
rgp_base::_M.push_back( posynomial<aaf>(T6) ); }
}
sixtuple(const T1& a = T1(), const T2& b = T2(), const T3& c = T3(),
const T4& d = T4(), const T5& e = T5(), const T6& f = T6()) :
first(a), second(b), third(c), forth(d), fifth(e), sixth(f) {
}
//----------- Begin of function LinAlg::quadratic_prog ------//
//! Interior Point Quadratic Programming
//! c, Q, A, b, xNames (no global or member variable access)
//!
//! try, by BM:
//! c = { 0,0 }
//! Q = { {2,0}, {0,5} }
//! A = { {5,6} }
//! b = { 10 }
//! xNames={x1,x2}
//!
bool LinearAlgebra::quadratic_prog(const Vector &v_c, const Matrix &m_Q, const Matrix &m_A, const Vector &v_b, Vector &v_xNames, int loopCountMultiplier) {
// init local variables
int maxIteration = 20;
const REAL SIGMA = 1/15.0; // 1/10.0;
const REAL R = 9.0/10;
int iter = 0;
int n = v_c.Storage();
int m = v_b.Storage();
maxIteration *= loopCountMultiplier;
#ifdef DEBUG_VC
DEBUG_LOG("----------- quadratic_prog begin -----------");
// print_input(c,Q,A,b,xNames)
if ( n==10 && m==12 ) {
char s[500];
DEBUG_LOG("c = ");
sprintf(s, "{ %.3f, %.3f, %.3f, %.3f, %.3f, %.3f, %.3f, %.3f, %.3f, %.3f };",
v_c(1),v_c(2),v_c(3),
v_c(4),v_c(5),v_c(6),
v_c(7),v_c(8),v_c(9), v_c(10));
DEBUG_LOG(s);
DEBUG_LOG("Q = ");
for (int i=1; i<=n; i++) {
sprintf(s, "{%f, %f, %f, %f, %f, %f, %f, %f, %f, %f},",
m_Q(i,1),m_Q(i,2),m_Q(i,3),m_Q(i,4),m_Q(i,5),m_Q(i,6),m_Q(i,7),m_Q(i,8),m_Q(i,9),m_Q(i,10)
);
DEBUG_LOG(s);
}
DEBUG_LOG("A = ");
for (i=1; i<=m; i++) {
sprintf(s, "{%f, %f, %f, %f, %f, %f, %f, %f, %f, %f},",
m_A(i,1),m_A(i,2),m_A(i,3),m_A(i,4),m_A(i,5),m_A(i,6),m_A(i,7),m_A(i,8),m_A(i,9),m_A(i,10)
);
DEBUG_LOG(s);
}
DEBUG_LOG("b = ");
sprintf(s, "{%.3f, %.3f, %.3f, %.3f, %.3f, %.3f, %.3f, %.3f, %.3f, %.3f, %.3f, %.3f,",
v_b(1),v_b(2),v_b(3),
v_b(4),v_b(5),v_b(6),
v_b(7),v_b(8),v_b(9), v_b(10), v_b(11), v_b(12)
);
DEBUG_LOG(s);
/*sprintf(s, "%f, %f, %f, %f, %f, %f, %f, %f, %f,",
v_b(10),v_b(11),v_b(12),
v_b(13),v_b(14),v_b(15),
v_b(16),v_b(17),v_b(18)
);
DEBUG_LOG(s);
sprintf(s, "%f, %f};",
v_b(19),v_b(20));
DEBUG_LOG(s);*/
}
else if ( n==9 && m==20 ) { // stage 1
char s[500];
DEBUG_LOG("c = ");
sprintf(s, "{ %.3f, %.3f, %.3f, %.3f, %.3f, %.3f, %.3f, %.3f, %.3f };",
v_c(1),v_c(2),v_c(3),
v_c(4),v_c(5),v_c(6),
v_c(7),v_c(8),v_c(9));
DEBUG_LOG(s);
DEBUG_LOG("Q = ");
for (int i=1; i<=n; i++) {
sprintf(s, "{%f, %f, %f, %f, %f, %f, %f, %f, %f, },",
m_Q(i,1),m_Q(i,2),m_Q(i,3),m_Q(i,4),m_Q(i,5),m_Q(i,6),m_Q(i,7),m_Q(i,8),m_Q(i,9)
);
DEBUG_LOG(s);
}
DEBUG_LOG("A = ");
for (i=1; i<=m; i++) {
sprintf(s, "{%f, %f, %f, %f, %f, %f, %f, %f, %f },",
m_A(i,1),m_A(i,2),m_A(i,3),m_A(i,4),m_A(i,5),m_A(i,6),m_A(i,7),m_A(i,8),m_A(i,9)
);
DEBUG_LOG(s);
}
DEBUG_LOG("b = ");
sprintf(s, "{%f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, }, ",
v_b(1),v_b(2),v_b(3),
v_b(4),v_b(5),v_b(6),
v_b(7),v_b(8),v_b(9), v_b(10), v_b(11), v_b(12),
v_b(13),v_b(14),v_b(15), v_b(16), v_b(17), v_b(18), v_b(19), v_b(20)
);
DEBUG_LOG(s);
}
else if ( n==10 && m==22 ) { // stage 2
char s[500];
DEBUG_LOG("c = ");
sprintf(s, "{ %.3f, %.3f, %.3f, %.3f, %.3f, %.3f, %.3f, %.3f, %.3f, %.3f };",
v_c(1),v_c(2),v_c(3),
v_c(4),v_c(5),v_c(6),
v_c(7),v_c(8),v_c(9),v_c(10));
DEBUG_LOG(s);
DEBUG_LOG("Q = ");
for (int i=1; i<=n; i++) {
sprintf(s, "{%.3f, %.3f, %.3f, %.3f, %.3f, %.3f, %.3f, %.3f, %.3f, %.3f, },",
m_Q(i,1),m_Q(i,2),m_Q(i,3),m_Q(i,4),m_Q(i,5),m_Q(i,6),m_Q(i,7),m_Q(i,8),m_Q(i,9),m_Q(i,10)
);
DEBUG_LOG(s);
}
DEBUG_LOG("A = ");
for (i=1; i<=m; i++) {
sprintf(s, "{%.3f, %.3f, %.3f, %.3f, %.3f, %.3f, %.3f, %.3f, %.3f, %.3f },",
m_A(i,1),m_A(i,2),m_A(i,3),m_A(i,4),m_A(i,5),m_A(i,6),m_A(i,7),m_A(i,8),m_A(i,9),m_A(i,10)
);
DEBUG_LOG(s);
}
DEBUG_LOG("b = ");
sprintf(s, "{%.3f, %.3f, %.3f, %.3f, %.3f, %.3f, %.3f, %.3f, %.3f, %.3f, %.3f, %.3f, %.3f, %.3f, %.3f, %.3f, %.3f, %.3f, %.3f, %.3f, %.3f, %.3f, }, ",
v_b(1),v_b(2),v_b(3),
v_b(4),v_b(5),v_b(6),
v_b(7),v_b(8),v_b(9), v_b(10), v_b(11), v_b(12),
v_b(13),v_b(14),v_b(15), v_b(16), v_b(17), v_b(18), v_b(19), v_b(20), v_b(21), v_b(22)
);
DEBUG_LOG(s);
}
#endif
Vector v_eN(n); v_eN = 1;
Vector v_eM(m); v_eM = 1;
Vector v_x(n); v_x = 1;
Vector v_z(n); v_z = 1;
Vector v_y(m); v_y = 1;
Vector v_w(m); v_w = 1;
// check m_A is nxm, m_Q is nxn
err_when(m_A.Nrows() != m || m_A.Ncols() != n );
err_when(m_Q.Nrows() != n || m_Q.Ncols() != n );
// init for while loop not_converged() checking
//
Vector v_Road = v_b - m_A*(v_x) + v_w;
Vector v_Sigma = v_c - m_A.t() * v_y - v_z + m_Q*v_x;
REAL gamma = (v_z.t()*v_x + v_y.t()*v_w).AsScalar();
REAL mute = SIGMA*gamma / (n+m);
DiagonalMatrix X(n), Xinv(n);
DiagonalMatrix Y(m), Yinv(m);
DiagonalMatrix Z(n);
DiagonalMatrix W(m);
Matrix T1(n,n), T2(n,m), T3(m,n), T4(m,m);
Vector KKFvec(n+m); //, v_tmp1(n), v_tmp2(m);
Vector m_temp(m+n);
Vector v_dx(n), v_dy(m), v_dz(n), v_dw(m);
REAL theeta;
X=0; Xinv=0; Z=0;
Y=0; Yinv=0; W=0; {
// Matrix _t1(n,n), _t2(n,n); _t1=1; _t2=2;
// _t1 = SP(_t1,_t2);
}
Matrix KKFmat(m+n,m+n);
Matrix KKFmatInverse(m+n,m+n);
REAL min=1;
while ( quadratic_prog_not_converged(v_x,v_y,v_Road,v_Sigma,gamma) && iter <= maxIteration && min > 0.0000000001 ) {
iter++;
v_Road = v_b - m_A*v_x + v_w;
v_Sigma = v_c - m_A.t()*v_y - v_z + m_Q*v_x;
gamma = (v_z.t()*v_x + v_y.t()*v_w).AsScalar();
mute = SIGMA*gamma / (n+m);
X.set_diagonal(v_x);
Y.set_diagonal(v_y);
Z.set_diagonal(v_z);
W.set_diagonal(v_w);
Xinv.set_diagonal(ElmDivide(v_eN, v_x));
Yinv.set_diagonal(ElmDivide(v_eM, v_y));
T1 = -(Xinv * Z + m_Q);
T2 = m_A.t();
T3 = m_A;
T4 = Yinv*W;
//PRT_MAT << "T1: " << T1 << endl;
KKFmat = (T1|T2) & (T3|T4);
KKFvec = (v_c - T2*v_y - mute*Xinv*v_eN + m_Q*v_x)
& (v_b - m_A*v_x + mute*Yinv*v_eM);
Try {
/*{
bool _f;
DiagonalMatrix _dmat(n+m); _dmat=1;
Matrix _inv(n+m,n+m);
SVD(KKFmat, _dmat, _inv);
_dmat=1;
if ( KKFmat*_inv == _dmat )
_f = true;
else
_f = false;
}*/
min = fabs(KKFmat(1,1));
for (int i=2; i<=m+n; i++) {
if ( min > fabs(KKFmat(i,i)) ) // check diagonal element
min = fabs(KKFmat(i,i));
}
KKFmatInverse = KKFmat.i();
/*
if ( KKFmat.LogDeterminant().Value() )
KKFmatInverse = KKFmat.i();
else
break;
*/
m_temp = KKFmatInverse * KKFvec;
v_dx = m_temp.Rows(1,n);
v_dy = m_temp.Rows(n+1,n+m);
v_dz = Xinv*(mute*v_eN - X*Z*v_eN - Z*v_dx);
v_dw = Yinv*(mute*v_eM - Y*W*v_eM - W*v_dy);
//PRT_MAT << "v_dx,z,y,w: " << (v_dx|v_dz) <<", "<< (v_dy|v_dw) <<endl;
//PRT_MAT << "v_x: " << v_x << endl;
//PRT_MAT << "ElmDivide(v_x,v_dx): " << ElmDivide(v_x,v_dx) << endl;
theeta =
(R/((
ElmDivide(-v_dx,v_x)
& ElmDivide(-v_dw,v_w)
& ElmDivide(-v_dy,v_y)
& ElmDivide(-v_dz,v_z)
)).MaximumValue()
);
if(theeta>1) // theeta = min(theeta,1)
theeta = 1;
v_x += theeta * v_dx;
v_y += theeta * v_dy;
v_w += theeta * v_dw;
v_z += theeta * v_dz;
#ifdef DEBUG_CONSOLE
cout << "#iter "<< iter << ": " << v_Road.Sum() << ", " << v_Sigma.Sum() << ", " << gamma << endl;
cout << "Ro:" << v_Road << endl;
PRT_MAT15 << "v_x:" << v_x << endl;
PRT_MAT15 << "v_y:" << v_y << endl;
PRT_MAT15 << "v_w:" << v_w << endl;
PRT_MAT15 << "v_z:" << v_z << endl;
#elif defined(DEBUG_VC)
char s[200];
sprintf(s, "#iter %d: %f, %f, %f",
iter, v_Road.Sum(), v_Sigma.Sum(), gamma);
DEBUG_LOG(s);
if ( n == 9 && false ) {
DEBUG_LOG("x = ");
sprintf(s, " %f, %f, %f, %f, %f, %f, %f, %f, %f",
v_x(1),v_x(2),v_x(3),
v_x(4),v_x(5),v_x(6),
v_x(7),v_x(8),v_x(9));
DEBUG_LOG(s);
}
#endif
}
CatchAll {
#ifdef DEBUG_CONSOLE
cout << Exception::what();
#endif
#ifdef DEBUG_VC
DEBUG_LOG("olinalg: failure in quad_prog");
DEBUG_LOG((char *)Exception::what());
#endif
return false;
}
} // while
v_xNames = v_x;
if ( min < 0.00001 ) { // 1214 || KKFmat.LogDeterminant().Value() == 0 )
//char s[200];
//sprintf(s, "#iter %d: %f, %f, %f",
// iter, v_Road.Sum(), v_Sigma.Sum(), gamma);
//DEBUG_LOG(s);
DEBUG_LOG("--- quad_prog early exit for min < 0.00001 ---");
}
else
DEBUG_LOG("----------- quad_prog normal exit -----------");
#ifdef DEBUG_CONSOLE
cout << "#iter: " << iter;
#endif
return true;
}
void operator () (const S4 <T1> &x) { T4 (*x, u[v++]); }
void TestMatrix(ostream& os)
{
// display a headline
os << "Matrix test\r\n===========\r\n";
Matrix<int> A(3,3), B(3,3), C(3,3), D(3,3);
A(0,0) = 1;
A(0,1) = 3;
A(0,2) = -4;
A(1,0) = 1;
A(1,1) = 1;
A(1,2) = -2;
A(2,0) = -1;
A(2,1) = -2;
A(2,2) = 5;
B(0,0) = 8;
B(0,1) = 3;
B(0,2) = 0;
B(1,0) = 3;
B(1,1) = 10;
B(1,2) = 2;
B(2,0) = 0;
B(2,1) = 2;
B(2,2) = 6;
D(0,0) = 1;
D(0,1) = 2;
D(0,2) = -1;
D(1,0) = 2;
D(1,1) = -1;
D(1,2) = -3;
D(2,0) = 0;
D(2,1) = -2;
D(2,2) = 4;
os << "\r\nMatrix A = \r\n";
ShowMatrix(os,A);
os << "\r\nMatrix B = \r\n";
ShowMatrix(os,B);
C = A % B;
os << "\r\nMatrix C (A % B) = \r\n";
ShowMatrix(os,C);
C = A + B;
os << "\r\nMatrix C (A + B) = \r\n";
ShowMatrix(os,C);
C = A;
C += B;
os << "\r\nMatrix C (= A, += B) =\r\n";
ShowMatrix(os,C);
C = A + 1;
os << "\r\nMatrix C (= A + 1) =\r\n";
ShowMatrix(os,C);
C += 1;
os << "\r\nMatrix C (+= 1) =\r\n";
ShowMatrix(os,C);
C = A - B;
os << "\r\nMatrix C (A - B) = \r\n";
ShowMatrix(os,C);
C = A;
C -= B;
os << "\r\nMatrix C (= A, -= B) =\r\n";
ShowMatrix(os,C);
C = A - 1;
os << "\r\nMatrix C (= A - 1) =\r\n";
ShowMatrix(os,C);
C -= 1;
os << "\r\nMatrix C (-= 1) =\r\n";
ShowMatrix(os,C);
C = A * B;
os << "\r\nMatrix C (A * B) = \r\n";
ShowMatrix(os,C);
C = A;
C *= B;
os << "\r\nMatrix C (= A, *= B) =\r\n";
ShowMatrix(os,C);
C = A * 2;
os << "\r\nMatrix C (= A * 2) =\r\n";
ShowMatrix(os,C);
C *= 2;
os << "\r\nMatrix C (*= 2) =\r\n";
ShowMatrix(os,C);
C = B / A;
os << "\r\nMatrix C (B / A) = \r\n";
ShowMatrix(os,C);
C = B;
C /= A;
os << "\r\nMatrix C (= B, /= A) =\r\n";
ShowMatrix(os,C);
C = A / 2;
os << "\r\nMatrix C (= A / 2) =\r\n";
ShowMatrix(os,C);
C /= 2;
os << "\r\nMatrix C (/= 2) =\r\n";
ShowMatrix(os,C);
C = -A;
os << "\r\nMatrix C (-A) = \r\n";
ShowMatrix(os,C);
// test comparisons
os << "\r\nMatrix A = \r\n";
ShowMatrix(os,A);
os << "\r\nMatrix D = \r\n";
ShowMatrix(os,D);
if (A.Equals(D))
os << "\r\nERROR: A should not equal D";
else
os << "\r\nOKAY: A not equal D";
C = A;
if (A.Equals(C))
os << "\r\nOKAY: A equals C\r\n";
else
os << "\r\nERROR: A should equal C\r\n";
Matrix<bool> I(3,3);
I = (A == D);
os << "\r\nMatrix I = (A == D)\r\n";
ShowMatrix(os,I);
I = (A != D);
os << "\r\nMatrix I = (A != D)\r\n";
ShowMatrix(os,I);
I = (A < D);
os << "\r\nMatrix I = (A < D)\r\n";
ShowMatrix(os,I);
I = (A <= D);
os << "\r\nMatrix I = (A <= D)\r\n";
ShowMatrix(os,I);
I = (A > D);
os << "\r\nMatrix I = (A > D)\r\n";
ShowMatrix(os,I);
I = (A >= D);
os << "\r\nMatrix I = (A >= D)\r\n";
ShowMatrix(os,I);
// check fill function
C.Fill(9);
os << "\r\nC filled with 9 =\r\n";
ShowMatrix(os,C);
// check Apply functions
C = Apply(A, Times2);
os << "\r\nC = A.Apply(Times2)\r\n";
ShowMatrix(os,C);
C.Apply(Times2);
os << "\r\nApply(C,Times2)\r\n";
ShowMatrix(os,C);
// check row and column vector functions
Matrix<int> S(1,1);
Matrix<int> r1A(3,1);
Matrix<int> c0B(1,3);
r1A = A.VectorRow(1);
c0B = B.VectorCol(0);
os << "\r\nMatrix S = \r\n";
ShowMatrix(os,S);
os << "\r\nMatrix R1A = \r\n";
ShowMatrix(os,r1A);
os << "\r\nMatrix C0B = \r\n";
ShowMatrix(os,c0B);
if (r1A.IsRowVector())
os << "\r\nOKAY: R1A is row vector";
else
os << "\r\nERROR: R1A should be a row vector";
if (!r1A.IsColVector())
os << "\r\nOKAY: R1A is not a column vector";
else
os << "\r\nERROR: R1A should not be a column vector";
if (!c0B.IsRowVector())
os << "\r\nOKAY: C0B is not a row vector";
else
os << "\r\nERROR: C0B should not be a row vector";
if (c0B.IsColVector())
os << "\r\nOKAY: C0B is column vector";
else
os << "\r\nERROR: C0B should be a column vector";
if (c0B.IsVector())
os << "\r\nOKAY: C0B is a vector";
else
os << "\r\nERROR: C0B should be a vector";
if (!A.IsVector())
os << "\r\nOKAY: A is not a vector";
else
os << "\r\nERROR: A should not be a vector";
if (!c0B.IsSquare())
os << "\r\nOKAY: C0B is not square";
else
os << "\r\nERROR: C0B should not be square";
if (A.IsSquare())
os << "\r\nOKAY: A is square";
else
os << "\r\nERROR: A should be square";
B.Fill(0);
if (B.IsZero())
os << "\r\nOKAY: B is zero";
else
os << "\r\nERROR: B should be zero";
if (!A.IsZero())
os << "\r\nOKAY: A is not zero";
else
os << "\r\nERROR: A should not be zero";
// test inner product
int ip = r1A.InnerProduct(c0B);
os << "\r\n\r\ninner product of R1A and C0B = " << ip << "\r\n";
// make some bigger matrices
Matrix<int> M1(5,5), M2(5,5,3), M3(5,5), M4(5,5);
const int junk[] = { 1, 5, 3, 0, 1,
0, 2, 0, 4, 5,
1, 0, 0, 2, 3,
7, 1, 3, 0, 0,
2, 1, 0, 4, 6 };
const int ident[] = { 1, 0, 0, 0, 0,
0, 1, 0, 0, 0,
0, 0, 1, 0, 0,
0, 0, 0, 1, 0,
0, 0, 0, 0, 1 };
const int tridi[] = { 1, 1, 0, 0, 0,
1, 1, 1, 0, 0,
0, 1, 1, 1, 0,
0, 0, 1, 1, 1,
0, 0, 0, 1, 1 };
const int utri[] = { 1, 1, 1, 1, 1,
0, 1, 1, 1, 1,
0, 0, 1, 1, 1,
0, 0, 0, 1, 1,
0, 0, 0, 0, 1 };
const int ltri[] = { 1, 0, 0, 0, 0,
1, 1, 0, 0, 0,
1, 1, 1, 0, 0,
1, 1, 1, 1, 0,
1, 1, 1, 1, 1 };
const int perm[] = { 0, 1, 0, 0, 0,
1, 0, 0, 0, 0,
0, 0, 0, 1, 0,
0, 0, 0, 0, 1,
0, 0, 1, 0, 0 };
const int det[] = { 3, 5, 3, 8, 1,
2, 6, 3, 4, 5,
1, 4, 5, 2, 3,
7, 1, 3, 6, 8,
2, 4, 1, 4, 9 };
M1 = ident;
M3 = M1 * 2;
M4 = junk;
os << "\r\nmatrix M1 = \r\n";
ShowMatrix(os,M1);
os << "\r\nmatrix M2 = \r\n";
ShowMatrix(os,M2);
os << "\r\nmatrix M3 = \r\n";
ShowMatrix(os,M3);
os << "\r\nmatrix M4 = \r\n";
ShowMatrix(os,M4);
if (M1.IsDiagonal())
os << "\r\nOKAY: M1 is diagonal";
else
os << "\r\nERROR: M1 should be diagonal";
if (M1.IsIdentity())
os << "\r\nOKAY: M1 is an identity matrix";
else
os << "\r\nERROR: M1 should be an identity matrix";
if (!M2.IsDiagonal())
os << "\r\nOKAY: M2 is not diagonal";
else
os << "\r\nERROR: M2 should not be diagonal";
if (!M2.IsIdentity())
os << "\r\nOKAY: M2 is not an identity matrix";
else
os << "\r\nERROR: M2 should not be an identity matrix";
if (M3.IsDiagonal())
os << "\r\nOKAY: M3 is diagonal";
else
os << "\r\nERROR: M3 should be diagonal";
if (!M3.IsIdentity())
os << "\r\nOKAY: M3 is not an identity matrix";
else
os << "\r\nERROR: M3 should not be an identity matrix";
if (!M4.IsDiagonal())
os << "\r\nOKAY: M4 is not diagonal";
else
os << "\r\nERROR: M4 should not be diagonal";
if (!M4.IsIdentity())
os << "\r\nOKAY: M4 is not an identity matrix";
else
os << "\r\nERROR: M4 should not be an identity matrix";
// tridiagonal tests
M1 = tridi;
os << "\r\n\r\nmatrix M1 = \r\n";
ShowMatrix(os,M1);
if (M1.IsTridiagonal())
os << "\r\nOKAY: M1 is tridiagonal";
else
os << "\r\nERROR: M1 should be tridiagonal";
if (!M4.IsTridiagonal())
os << "\r\nOKAY: M4 is not tridiagonal";
else
os << "\r\nERROR: M1 should not be tridiagonal";
// upper triangular tests
M1 = utri;
os << "\r\n\r\nmatrix M1 = \r\n";
ShowMatrix(os,M1);
if (M1.IsUpperTriangular())
os << "\r\nOKAY: M1 is upper-triangular";
else
os << "\r\nERROR: M1 should be upper-triangular";
if (!M4.IsUpperTriangular())
os << "\r\nOKAY: M4 is not upper-triangular";
else
os << "\r\nERROR: M4 should not be upper-triangular";
// lower triangular tests
M1 = ltri;
os << "\r\n\r\nmatrix M1 = \r\n";
ShowMatrix(os,M1);
if (M1.IsLowerTriangular())
os << "\r\nOKAY: M1 is lower-triangular";
else
os << "\r\nERROR: M1 should be lower-triangular";
if (!M4.IsLowerTriangular())
os << "\r\nOKAY: M4 is not lower-triangular";
else
os << "\r\nERROR: M4 should not be lower-triangular";
// permutation tests
M1 = perm;
os << "\r\n\r\nmatrix M1 = \r\n";
ShowMatrix(os,M1);
M2 = ident;
os << "\r\n\r\nmatrix M2 = \r\n";
ShowMatrix(os,M2);
if (M1.IsPermutation())
os << "\r\nOKAY: M1 is permutation matrix";
else
os << "\r\nERROR: M1 should be permutation";
if (M2.IsPermutation())
os << "\r\nOKAY: M2 is permutation matrix";
else
os << "\r\nERROR: M2 should be permutation";
if (!M4.IsPermutation())
os << "\r\nOKAY: M4 is not permutation";
else
os << "\r\nERROR: M4 should not be permutation";
// check singularity function
M1(0,1) = 0;
os << "\r\n\r\nmatrix M1 = \r\n";
ShowMatrix(os,M1);
if (M1.IsSingular())
os << "\r\nOKAY: M1 is singular";
else
os << "\r\nERROR: M1 should be singular";
if (!M2.IsSingular())
os << "\r\nOKAY: M2 is not singular";
else
os << "\r\nERROR: M2 should not be singular";
if (!M4.IsSingular())
os << "\r\nOKAY: M4 is not singular";
else
os << "\r\nERROR: M4 should not be singular";
// change main window heading
os <<endl
<<"Matrix Tests (manipulations)" <<endl
<<"============================" <<endl;
// test minors and determinants
os << "\r\n\r\nmatrix M4 = \r\n";
ShowMatrix(os,M4);
os << "\r\nminor M4(1,1) = \r\n";
ShowMatrix(os,M4.Minor(1,1));
os << "\r\nminor M4(0,4) = \r\n";
ShowMatrix(os,M4.Minor(0,4));
Matrix<int> M5(2,2), M6(3,3);
M5(0,0) = 1;
M5(0,1) = 2;
M5(1,0) = 3;
M5(1,1) = 4;
M6(0,0) = 1;
M6(0,1) = 3;
M6(0,2) = 2;
M6(1,0) = 5;
M6(1,1) = 4;
M6(1,2) = 7;
M6(2,0) = 6;
M6(2,1) = 9;
M6(2,2) = 8;
M4 = det;
Matrix<int> T4(5,5), T5(2,2), T6(3,3);
T4 = M4.Transpose();
T5 = M5.Transpose();
T6 = M6.Transpose();
os << "\r\nmatrix M5 = \r\n";
ShowMatrix(os,M5);
os << "\r\ndeterminant of M5 = "
<< M5.Determinant() << "\r\n";
os << "\r\nmatrix T5 = \r\n";
ShowMatrix(os,T5);
os << "\r\ndeterminant of T5 = "
<< T5.Determinant() << "\r\n";
os << "\r\nmatrix M6 = \r\n";
ShowMatrix(os,M6);
os << "\r\ndeterminant of M6 = "
<< M6.Determinant() << "\r\n";
os << "\r\nmatrix T6 = \r\n";
ShowMatrix(os,T6);
os << "\r\ndeterminant of T6 = "
<< T6.Determinant() << "\r\n";
os << "\r\nmatrix M4 = \r\n";
ShowMatrix(os,M4);
os << "\r\ndeterminant of M4 = "
<< M4.Determinant() << "\r\n";
os << "\r\nmatrix T4 = \r\n";
ShowMatrix(os,T4);
os << "\r\ndeterminant of T4 = "
<< T4.Determinant() << "\r\n";
Matrix<int> R;
os << "\r\nMatrix R (def. constr.) = \r\n";
ShowMatrix(os,R);
R.Resize(10,10);
os << "\r\nMatrix R (now 10x10) = \r\n";
ShowMatrix(os,R);
// change main window heading
os <<endl
<<"Matrix Tests (double)" <<endl
<<"=====================" <<endl;
// check <double> Matrix
os << "\r\nFLOATING POINT!";
Matrix<double> X(3,4), Y(4,3), Z(3,3);
X(0,0) = 1.0; X(1,0) = 5.0; X(2,0) = 2.0;
X(0,1) = 2.0; X(1,1) = 2.0; X(2,1) = 4.0;
X(0,2) = 0.0; X(1,2) = 3.0; X(2,2) = 3.0;
X(0,3) = 1.0; X(1,3) = 2.0; X(2,3) = 1.0;
Y(0,0) = 0.0; Y(2,0) = 1.0;
Y(0,1) = 1.0; Y(2,1) = 0.0;
Y(0,2) = 2.0; Y(2,2) = 5.0;
Y(1,0) = 1.0; Y(3,0) = 3.0;
Y(1,1) = 3.0; Y(3,1) = 1.0;
Y(1,2) = 2.0; Y(3,2) = 2.0;
os << "\r\nMatrix X = \r\n";
ShowMatrix(os,X);
os << "\r\nMatrix Y = \r\n";
ShowMatrix(os,Y);
Z = X % Y;
os << "\r\nMatrix Z (X % Y) = \r\n";
ShowMatrix(os,Z);
// check transposition
Matrix<double> tX;
tX = X.Transpose();
os << "\r\nOriginal X =\r\n";
ShowMatrix(os,X);
os << "\r\nTranspose X =\r\n";
ShowMatrix(os,tX);
X(0,0) = 1; X(0,1) = 3; X(0,2) = -4; X(0,3) = 8;
X(1,0) = 1; X(1,1) = 1; X(1,2) = -2; X(1,3) = 2;
X(2,0) = -1; X(2,1) = -2; X(2,2) = 5; X(2,3) = -1;
os << "\r\nOriginal X =\r\n";
ShowMatrix(os,X);
Matrix<double> lX(X.LinSolve());
os << "\r\nX after elimination =\r\n";
ShowMatrix(os,X);
os << "\r\nlinear equation solution =\r\n";
ShowMatrix(os,lX);
X(0,0) = 1.0; X(1,0) = 3.0; X(2,0) = 5.0;
X(0,1) = 2.0; X(1,1) = 5.0; X(2,1) = 6.0;
X(0,2) = 0.0; X(1,2) = 4.0; X(2,2) = 3.0;
X(0,3) = 0.1; X(1,3) = 12.5; X(2,3) = 10.3;
os << "\r\nOriginal X =\r\n";
ShowMatrix(os,X);
lX = X.LinSolve();
os << "\r\nX after elimination =\r\n";
ShowMatrix(os,X);
os << "\r\nlinear equation solution =\r\n";
ShowMatrix(os,lX);
Matrix<double> Adbl(3,3), Bdbl(3,1);
Adbl(0,0) = 1.0; Adbl(0,1) = 2.0; Adbl(0,2) = 0.0;
Adbl(1,0) = 3.0; Adbl(1,1) = 5.0; Adbl(1,2) = 4.0;
Adbl(2,0) = 5.0; Adbl(2,1) = 6.0; Adbl(2,2) = 3.0;
Bdbl(0,0) = 0.1;
Bdbl(1,0) = 12.5;
Bdbl(2,0) = 10.3;
os << "\r\n\r\nmatrix Adbl = \r\n";
ShowMatrix(os,Adbl);
os << "\r\nmatrix Bdbl = \r\n";
ShowMatrix(os,Bdbl);
Matrix<double> alup(Adbl); // copy Adbl before LUP decomp
os << "\r\nLU decomp of Adbl (before) = \r\n";
ShowMatrix(os,alup);
Matrix<size_t> aperm = alup.LUPDecompose();
os << "\r\nLU decomp of Adbl (after) = \r\n";
ShowMatrix(os,alup);
os << "\r\nPermutation of Adbl = \r\n";
ShowMatrix(os,aperm);
Matrix<double> asol = alup.LUPSolve(aperm,Bdbl);
os << "\r\nlinear solution of Adbl and Bdbl = \r\n";
ShowMatrix(os,asol);
Matrix<double> ainv = alup.LUPInvert(aperm);
os << "\r\ninverse of Adbl and Bdbl = \r\n";
ShowMatrix(os,ainv);
Matrix<double> aid = Adbl % ainv;
os << "\r\ninverse dot Adbl = \r\n";
ShowMatrix(os,aid);
Grid<size_t> iperm = ainv.LUPDecompose();
Matrix<double> invinv = ainv.LUPInvert(iperm);
os << "\r\ninverse of inverse =\r\n";
ShowMatrix(os,invinv);
}
// calculate gfield close to the nth caustic ring flow
// two cases: within the caustic, all four roots are real, so we use T1 for d4 and T2,3,4 for d3
// outside the caustic there should be two real roots and two complex roots
// the vector intlimits hold the limits of integration; for the first case, intlimits is of length four; second, length two
void gfield_close(double rho, double z, int n, double *rfield, double *zfield) {
z = (double complex)(z / p_n[n]);
double complex x = (double complex)(( rho - a_n[n] ) / p_n[n]);
double im[4] = {cabs(cimag(T1(x,z))), cabs(cimag(T2(x,z))), cabs(cimag(T3(x,z))), cabs(cimag(T4(x,z)))};
double re[4] = {creal(T1(x,z)) , creal(T2(x,z)) , creal(T3(x,z)) , creal(T4(x,z))};
int count = 0;
int i, j;
double temp;
// get only the roots we want
for (i = 0; i < 4; ++i) {
if (im[i] < TOLERANCE) {
re[count] = re[i];
++count; // count the roots - there should be 2 or 4
}
}
// sort all 2 or 4 roots in ascending order
for (i = 0; i < count - 1; ++i) {
for (j = i + 1; j < count; ++j)
if (re[i] > re[j]) {
temp = re[i];
re[i] = re[j];
re[j] = temp;
}
}
// roots stored in re[]
double factor = -8.0 * M_PI * G * rate_n[n] * 4498.6589 / (rho * V_n[n] * 1.0226831);
*rfield += factor * ( creal(f5(x,z,re[1])) - creal(f5(x,z,re[0])) - 0.5 ); // it seems that the answer is just off by 0.5, so we subtract it by hand
*zfield += factor * ( cimag(f5(x,z,re[1])) - cimag(f5(x,z,re[0])) );
if (count == 4){
*rfield += factor * ( creal(f5(x,z,re[3])) - creal(f5(x,z,re[2])) );
*zfield += factor * ( cimag(f5(x,z,re[3])) - cimag(f5(x,z,re[2])) );
}
}
quadruple() : first(T1()), second(T2()), third(T3()), fourth(T4()) {}