//Степень
NQInt NQInt::pow(NQInt A)
{// возведение в степень
A.deleteNullsItems();
if (!THIS.Compare(NQInt(0)) && !A.Compare(NQInt(0))) throw NQIntException(NQIntNullInNull);
if (!THIS.Compare(NQInt(0)))
{
NQInt Result = 1;
Result.errSize = errSize;
return Result;
}
if (!A.Compare(NQInt(0)))
{
NQInt Result = 1;
Result.errSize = errSize;
return Result;
}
if (A.underValueLeng) throw NQIntException(NQIntDecimalPow);
NQInt DSum(1);
NQInt Result = THIS;
Result.errSize = errSize;
for (NQInt Temp(1); (Temp.Compare(A)); Temp = Temp + DSum)
{//последовательное умножение
Result = Result * THIS;
}
return Result;
}
/***=======================================================================***/
void QuatAlign(double* frameI, double* frameII, int num_atoms, double* mass,
int m, dmat *U)
{
int i, itr, maxeigloc;
double maxeig, a, x, y, z, totmass, tmass;
double aa, ab, ac, ba, bb, bc, ca, cb, cc, i1, i2, i3, g1, g2, g3;
double diag[4], sdiag[4];
dmat R;
/*** Compute the quaternion matrix ***/
R = CreateDmat(4, 4);
totmass = (m == 1) ? 1.0/DSum(mass, num_atoms) : 1.0/num_atoms;
for (i = 0; i < num_atoms; i++) {
itr = 3*i;
i1 = frameII[itr];
i2 = frameII[itr+1];
i3 = frameII[itr+2];
g1 = frameI[itr];
g2 = frameI[itr+1];
g3 = frameI[itr+2];
aa = i1*g1;
ab = i1*g2;
ac = i1*g3;
ba = i2*g1;
bb = i2*g2;
bc = i2*g3;
ca = i3*g1;
cb = i3*g2;
cc = i3*g3;
if (m == 1) {
tmass = mass[i];
R.data[0] += tmass*(aa+bb+cc);
R.data[1] += tmass*(cb-bc);
R.data[2] += tmass*(ac-ca);
R.data[3] += tmass*(ba-ab);
R.data[5] += tmass*(aa-bb-cc);
R.data[6] += tmass*(ab+ba);
R.data[7] += tmass*(ca+ac);
R.data[10] += tmass*(bb-cc-aa);
R.data[11] += tmass*(bc+cb);
R.data[15] += tmass*(cc-aa-bb);
}
else {
R.data[0] += aa+bb+cc;
R.data[1] += cb-bc;
R.data[2] += ac-ca;
R.data[3] += ba-ab;
R.data[5] += aa-bb-cc;
R.data[6] += ab+ba;
R.data[7] += ca+ac;
R.data[10] += bb-cc-aa;
R.data[11] += bc+cb;
R.data[15] += cc-aa-bb;
}
}
R.data[4] = R.data[1];
R.data[8] = R.data[2];
R.data[12] = R.data[3];
R.data[9] = R.data[6];
R.data[13] = R.data[7];
R.data[14] = R.data[11];
for (i = 0; i < 16; i++) {
R.data[i] *= totmass;
}
TRED2(R.map, 4, diag, sdiag);
TQLI(diag, sdiag, 4, R.map);
maxeig = diag[0];
maxeigloc = 0;
for (i = 1; i < 4; i++) {
if (diag[i] > maxeig) {
maxeig = diag[i];
maxeigloc = i;
}
}
a = R.data[maxeigloc];
x = R.data[maxeigloc+4];
y = R.data[maxeigloc+8];
z = R.data[maxeigloc+12];
/*** Construct the rotation matrix ***/
U->data[0] = a*a + x*x -y*y - z*z;
U->data[1] = 2.0*(x*y + a*z);
U->data[2] = 2.0*(z*x - a*y);
U->data[3] = 2.0*(x*y - a*z);
U->data[4] = a*a - x*x + y*y - z*z;
U->data[5] = 2.0*(y*z + a*x);
U->data[6] = 2.0*(z*x + a*y);
U->data[7] = 2.0*(y*z - a*x);
U->data[8] = a*a - x*x - y*y + z*z;
DestroyDmat(&R);
}
/***=======================================================================***/
double DAverage(double* V, int n)
{
return DSum(V, n)/n;
}
