int cranck(double *const Up1, double const*const U, sConst *const psc,pfLinearOp pfTimeStep, pfBC pfBoundary)
{
if (strcmp(discret,"real")==0)
{
psc->eDir =_X;
pfTimeStep(psc->pUrhs,U,psc);
addfields(psc->pUk1,U,psc->pUrhs,0.5*psc->dDt,psc->sSize);
invMat(psc->pUk1,psc->pUk2,psc->sSize,psc->sInvY);
pfBoundary(psc->pUk2,psc->sSize);
psc->eDir =_Y;
pfTimeStep(psc->pUrhs,psc->pUk2,psc);
addfields(psc->pUk1,psc->pUk2,psc->pUrhs,0.5*psc->dDt,psc->sSize);
invMat(psc->pUk1,Up1,psc->sSize,psc->sInvX);
pfBoundary(Up1,psc->sSize);
}
else if (strcmp(discret,"fourier")==0)
{
psc->eDir =_XF;
pfTimeStep(psc->pUrhs,U,psc);
addfields(psc->pUk1,U,psc->pUrhs,0.5*psc->dDt,psc->sSize);
addfields(psc->pUk1,U,psc->pdSource,0.5*psc->dDt,psc->sSize);
invMat(psc->pUk1,Up1,psc->sSize,psc->sInvX);
pfBoundary(Up1,psc->sSize);
}
return 0;
}
Vec3 Transform::transformNormal(const Vec3& normal) {
Vec3 result;
result.x = invMat(0, 0)*normal.x + invMat(1, 0)*normal.y + invMat(2, 0)*normal.z;
result.y = invMat(0, 1)*normal.x + invMat(1, 1)*normal.y + invMat(2, 1)*normal.z;
result.z = invMat(0, 2)*normal.x + invMat(1, 2)*normal.y + invMat(2, 2)*normal.z;
return result;
}
int draw(Scene& myScene)
{
unsigned char* img;
img = (unsigned char*)tga_create(myScene.width, myScene.height, TGA_TRUECOLOR_24);
int img_index = 0;
for(int m = 0; m<myScene.height*myScene.width*3; m++)
img[m]=0;
for(int y = 0; y < myScene.height; y++)
for(int x = 0; x < myScene.width; x++)
{ Ray viewRay;
viewRay.o.x = x;
viewRay.o.y = y;
viewRay.o.z = -1000.0;
viewRay.d.x = 0.0;
viewRay.d.y = 0.0;
viewRay.d.z = 1.0;
viewRay.reflected = 0;
float red = 0, green = 0, blue = 0;
float coef = 1.0;
int level = 0;
int repeatFlag = 0;
int lastfrontSphere = -1;
int frontSphere = -1;
int lastfrontTriangle = -1;
int frontTriangle = -1;
do{
Point inter;
Point frontInter;
float t_inter;
Matrix iMat;
Ray newviewRay;
int triangleisFront, sphereisFront;
int flag;
if(repeatFlag==0)
{
int ret_val_trngl = 0;
flag = 1;
float t = 2000.0;
frontSphere = -1;
frontTriangle = -1;
sphereisFront = 0;
triangleisFront = 0;
for(int i = 0; i<myScene.spheres.size(); i++)
{ if(myScene.spheres[i].transformed==0)
{ if(raySphere(viewRay, myScene.spheres[i], t))
{ frontSphere = i;
t_inter = t;
}
}
else if(myScene.spheres[i].transformed==1)
{ if(lastfrontSphere!=i)
{ if(viewRay.reflected == 0)
{ Matrix temp_iMat = invMat(myScene.spheres[i].mat);
Ray temp_newviewRay;
temp_newviewRay.o = transformPoint(temp_iMat, viewRay.o);
temp_newviewRay.o = subPoint(temp_newviewRay.o, myScene.spheres[i].tlate);// we have to sub since it is a inverse transform
temp_newviewRay.d = transformPoint(temp_iMat, viewRay.d); ///////////////*doubt*why???////
if(raySphere(temp_newviewRay, myScene.spheres[i], t))
{ frontSphere = i;
iMat = temp_iMat;
t_inter = t;
newviewRay = temp_newviewRay;
newviewRay.reflected = 0;
}
}
else
{ Matrix temp_iMat = invMat(myScene.spheres[i].mat);
if(raySphere(viewRay, myScene.spheres[i], t))
{ frontSphere = i;
iMat = temp_iMat;
t_inter = t;
newviewRay = viewRay;
newviewRay.reflected = 0;
}
}
}
}
}
viewRay.reflected = 0;
for(int i = 0; i<myScene.triangles.size(); i++)
{ ret_val_trngl = rayTriangle(viewRay, myScene.triangles[i], inter);
if((ret_val_trngl==1)&&(lastfrontTriangle!=i))
{ frontTriangle = i;
frontInter = inter;
}
}
if(frontSphere==-1)
if(frontTriangle==-1)
{ flag = 0;
triangleisFront = 0;
sphereisFront = 0;
break;
}
else
{ triangleisFront = 1;
sphereisFront = 0;
}
if(frontSphere!=-1)
if(frontTriangle==-1)
{ triangleisFront = 0;
sphereisFront = 1;
}
else
{ triangleisFront = 1;
sphereisFront = 1;
}
}
repeatFlag = 0;
if((sphereisFront==1)&&(triangleisFront==0))
{
if(myScene.spheres[frontSphere].transformed==0)
{ Point tempo = multPoint(t_inter, viewRay.d);
Point newStart = addPoint(viewRay.o, tempo);
Point n = subPoint(newStart, myScene.spheres[frontSphere].c);
float temp = multPoint(n, n);
if (temp == 0.0f)
break;
temp = 1.0f / sqrtf(temp);
n = multPoint(temp, n); //normal
Material currentMat = myScene.materials[myScene.spheres[frontSphere].materialId];
for (int j = 0; j < myScene.lights.size(); j++)
{
Light light = myScene.lights[j];
Point dist = subPoint(light.pos, newStart);
if (multPoint(n, dist) <= 0.0f)
continue;
float t = sqrtf(multPoint(dist, dist));
if ( t <= 0.0f )
continue;
Ray lightRay;
lightRay.o = newStart;
lightRay.d = multPoint((1/t), dist);
bool inShadow = false;
for (int k = 0; k < myScene.spheres.size(); k++)
{
if (raySphere(lightRay, myScene.spheres[k], t))
{ inShadow = true;
break;
}
}
if (!inShadow)
{ // lambert
float lambert = multPoint(n, lightRay.d) * coef;
red += lambert * light.col.r * currentMat.r;
green += lambert * light.col.g * currentMat.g;
blue += lambert * light.col.b * currentMat.b;
}
}
coef *= currentMat.reflection;
float reflet = 2.0f * multPoint(viewRay.d, n);
viewRay.o = newStart;
Point temp_2 = multPoint(reflet, n);
viewRay.d = subPoint(viewRay.d, temp_2);
viewRay.reflected = 0;
level++;
}
else if (myScene.spheres[frontSphere].transformed==1)
{
Point tempo = multPoint(t_inter, newviewRay.d);
Point newStart = addPoint(newviewRay.o, tempo); //intersection point in sphere space
Point newStart_2 = transformPoint(myScene.spheres[frontSphere].mat, newStart);//intersection point in ellipsoid space
newStart_2 = addPoint(newStart_2, myScene.spheres[frontSphere].tlate);
Point n = subPoint(newStart, myScene.spheres[frontSphere].c);
float temp = multPoint(n, n);
if (temp == 0.0f)
break;
temp = 1.0f / sqrtf(temp);
n = multPoint(temp, n);
//convert normal to new worldspace
Matrix iMat_2 = transMat(iMat);
Point n_orig = n;
n = transformPoint(iMat_2, n);
Material currentMat = myScene.materials[myScene.spheres[frontSphere].materialId];
for (int j = 0; j < myScene.lights.size(); j++)
{
Light light = myScene.lights[j];
Point dist = subPoint(light.pos, newStart_2);
if (multPoint(n, dist) <= 0.0f)
continue;
float t2 = sqrtf(multPoint(dist, dist));
if ( t2 <= 0.0f )
continue;
Ray lightRay;
lightRay.o = newStart_2;
lightRay.d = multPoint((1/t2), dist);
lightRay.reflected = 0;
Point dist_temp = subPoint(light.pos, newStart);
float t_temp = sqrtf(multPoint(dist_temp, dist_temp));
bool inShadow = false;
Ray newlightRay;
for (int k = 0; k < myScene.spheres.size(); k++)
{
newlightRay.o = newStart;
newlightRay.d = transformPoint(iMat, lightRay.d);
newlightRay.reflected = 0;
if((k!=frontSphere) && (k!=lastfrontSphere))
if (raySphere(newlightRay, myScene.spheres[k], t_temp))
{ inShadow = true;
break;
}
}
if (!inShadow)
{ // lambert
float lambert = multPoint(n, lightRay.d) * coef;
red += lambert * light.col.r * currentMat.r;
green += lambert * light.col.g * currentMat.g;
blue += lambert * light.col.b * currentMat.b;
}
}
lastfrontSphere = frontSphere;
coef *= currentMat.reflection;
float reflet = 2.0f * multPoint(newviewRay.d, n_orig);
viewRay.o = newStart_2;
Point temp_2 = multPoint(reflet, n_orig);
viewRay.d = subPoint(newviewRay.d, temp_2);
viewRay.reflected = 1;
level++;
}
}
else if((sphereisFront==0)&&(triangleisFront==1))
{
Point u_n = subPoint(myScene.triangles[frontTriangle].v1, frontInter);
Point v_n = subPoint(myScene.triangles[frontTriangle].v2, frontInter);
Point n = crossProduct(v_n, u_n); //pay attention here
float temp = multPoint(n, n);
if (temp == 0.0f)
flag = 0;
temp = 1.0f / sqrtf(temp);
n = multPoint(temp, n); //normal
Material currentMat = myScene.materials[myScene.triangles[frontTriangle].materialId];
for (int j = 0; j < myScene.lights.size(); j++)
{
Light light = myScene.lights[j];
Point dist = subPoint(light.pos, frontInter);
if (multPoint(n, dist) <= 0.0f)
continue;
float t = sqrtf(multPoint(dist, dist));
if ( t <= 0.0f )
continue;
Ray lightRay;
lightRay.o = frontInter;
lightRay.d = multPoint((1/t), dist);
Point temp_inter;
for (int k = 0; k < myScene.triangles.size(); k++)
{
if((k!=frontTriangle) && (k!=lastfrontTriangle))
if ((rayTriangle(lightRay, myScene.triangles[k], temp_inter)==1))
{ flag = 0;
break;
}
}
if(flag == 1)
{ float lambert = multPoint(n, lightRay.d) * coef;
red += lambert * light.col.r * currentMat.r;
green += lambert * light.col.g * currentMat.g;
blue += lambert * light.col.b * currentMat.b;
}
lastfrontTriangle = frontTriangle; //important
}
coef *= currentMat.reflection;
float reflet = 2.0f * multPoint(viewRay.d, n);
viewRay.o = frontInter;
Point temp_2 = multPoint(reflet, n);
viewRay.d = subPoint(viewRay.d, temp_2);
viewRay.reflected = 1;
level++;
}
else if((sphereisFront==1)&&(triangleisFront==1))
{
Point tempo = multPoint(t_inter, viewRay.d);
Point newStart = addPoint(viewRay.o, tempo);
if(newStart.z <= frontInter.z)
triangleisFront=0;
else
sphereisFront = 0;
repeatFlag = 1;
}
}while((coef>0.0f)&&(level<10));
img[img_index] = (unsigned char)(min(red*255.0f, 255.0f));
img[img_index+1] = (unsigned char)(min(green*255.0f, 255.0f));
img[img_index+2] = (unsigned char)(min(blue*255.0f, 255.0f));
img_index = img_index+3;
}
int ret_value = tga_write_rle( "output3.tga", myScene.width, myScene.height, img, TGA_TRUECOLOR_24);
return 1;
}
static PyObject *UtilsC_expectation_H(PyObject *self, PyObject *args){
PyObject *XGamma,*Y,*y_tilde,*m_A,*m_H,*X,*R,*Gamma,*Sigma_A,*sigma_epsilone,*Sigma_H,*QQ_barnCond;
PyArrayObject *XGammaarray,*QQ_barnCondarray,*Yarray,*y_tildearray,*Rarray,*m_Aarray,*m_Harray,*sigma_epsilonearray,*Sigma_Harray,*Xarray,*Gammaarray,*Sigma_Aarray;
int j,J,m,m2,d,D,nCond,Nrep,nr;
npy_float64 scale,sigmaH;
PyArg_ParseTuple(args, "OOOOOOOOOOOOiiiidd",&XGamma,&QQ_barnCond,&sigma_epsilone,&Gamma,&R,&Sigma_H,&Y,&y_tilde,&m_A,&m_H,&Sigma_A,&X,&J,&D,&nCond,&Nrep,&scale,&sigmaH);
Xarray = (PyArrayObject *) PyArray_ContiguousFromObject(X,PyArray_INT,3,3);
m_Aarray = (PyArrayObject *) PyArray_ContiguousFromObject(m_A,PyArray_FLOAT64,2,2);
Rarray = (PyArrayObject *) PyArray_ContiguousFromObject(R,PyArray_FLOAT64,2,2);
m_Harray = (PyArrayObject *) PyArray_ContiguousFromObject(m_H,PyArray_FLOAT64,1,1);
y_tildearray = (PyArrayObject *) PyArray_ContiguousFromObject(y_tilde,PyArray_FLOAT64,2,2);
sigma_epsilonearray = (PyArrayObject *) PyArray_ContiguousFromObject(sigma_epsilone,PyArray_FLOAT64,1,1);
Yarray = (PyArrayObject *) PyArray_ContiguousFromObject(Y,PyArray_FLOAT64,2,2);
Sigma_Harray = (PyArrayObject *) PyArray_ContiguousFromObject(Sigma_H,PyArray_FLOAT64,2,2);
Gammaarray = (PyArrayObject *) PyArray_ContiguousFromObject(Gamma,PyArray_FLOAT64,2,2);
Sigma_Aarray = (PyArrayObject *) PyArray_ContiguousFromObject(Sigma_A,PyArray_FLOAT64,3,3);
QQ_barnCondarray = (PyArrayObject *) PyArray_ContiguousFromObject(QQ_barnCond,PyArray_FLOAT64,4,4);
XGammaarray = (PyArrayObject *) PyArray_ContiguousFromObject(XGamma,PyArray_FLOAT64,3,3);
npy_float64 *S,*H,*tmp,*tmpT,*GGamma,*tmp2;
npy_float64 *yy_tilde,*Y_bar_tilde,*Q_bar,*Q_barnCond;
struct timeval tstart, tend;
S = malloc(sizeof(npy_float64)*Nrep);
H = malloc(sizeof(npy_float64)*D);
tmp = malloc(sizeof(npy_float64)*Nrep*D);
tmpT = malloc(sizeof(npy_float64)*Nrep*D);
GGamma = malloc(sizeof(npy_float64)*Nrep*Nrep);
tmp2 = malloc(sizeof(npy_float64)*Nrep*D);
yy_tilde = malloc(sizeof(npy_float64)*Nrep);
Y_bar_tilde = malloc(sizeof(npy_float64)*D);
Q_bar = malloc(sizeof(npy_float64)*D*D);
Q_barnCond = malloc(sizeof(npy_float64)*nCond*nCond*D*D);
for (d=0;d<Nrep;d++){
for (nr=0;nr<Nrep;nr++){
GGamma[d*Nrep + nr] = GetValue(Gammaarray,nr,d);
}
}
for (d=0;d<D;d++){
for (nr=0;nr<D;nr++){
Q_bar[d*D+nr] = GetValue(Rarray,d,nr) * scale/sigmaH;
}
Y_bar_tilde[d] = 0;
}
gettimeofday(&tstart, NULL);
for (j=0;j<J;j++){
if (GetValue1D(sigma_epsilonearray,j) < eps) GetValue1D(sigma_epsilonearray,j) = eps;
for (nr=0;nr<Nrep;nr++){
yy_tilde[nr] = GetValue(y_tildearray,nr,j);
for (d=0;d<D;d++){
tmp[nr*D + d] = 0;
tmp2[nr*D + d] = 0;
tmpT[nr*D + d] = 0;
}
}
for (m=0;m<nCond;m++){
for (nr=0;nr<Nrep;nr++){
for (d=0;d<D;d++){
tmp2[d*Nrep + nr] += GetValue3D(XGammaarray,m,d,nr) * GetValue(m_Aarray,j,m) / GetValue1D(sigma_epsilonearray,j);
tmpT[d*Nrep+nr] += GetValue(m_Aarray,j,m) * GetValue3DInt(Xarray,m,nr,d);
}
}
}
prodaddMat(tmp2,yy_tilde,Y_bar_tilde,D,1,Nrep);
for (m=0;m<nCond;m++){
for (m2=0;m2<nCond;m2++){
for (d=0;d<D;d++){
for (nr=0;nr<D;nr++){
Q_bar[d*D+nr] += GetValue4D(QQ_barnCondarray,m,m2,d,nr) * ( GetValue3D(Sigma_Aarray,m,m2,j) + GetValue(m_Aarray,j,m2) * GetValue(m_Aarray,j,m)) / GetValue1D(sigma_epsilonearray,j) ;
}
}
}
}
}
gettimeofday(&tend, NULL);
if (profiling)
printf ("Ytilde and Q_bar step took %ld msec\n", difftimeval(&tend,&tstart));
gettimeofday(&tstart, NULL);
invMat(Q_bar,D);
gettimeofday(&tend, NULL);
if (profiling)
printf ("Inv Q_bar step took %ld msec\n", difftimeval(&tend,&tstart));
gettimeofday(&tstart, NULL);
prodMat2(Q_bar,Y_bar_tilde,H,D,1,D);
gettimeofday(&tend, NULL);
if (profiling)
printf ("Prod Q_bar Y_bar step took %ld msec\n", difftimeval(&tend,&tstart));
for (d=0;d<D;d++){
GetValue1D(m_Harray,d) = H[d];
for (m=0;m<D;m++){
GetValue(Sigma_Harray,d,m) = Q_bar[d*D+m];
}
}
free(S);
free(H);
free(tmp);
free(tmpT);
free(GGamma);
free(tmp2);
free(yy_tilde);
free(Y_bar_tilde);
free(Q_bar);
free(Q_barnCond);
Py_DECREF(QQ_barnCondarray);
Py_DECREF(XGammaarray);
Py_DECREF(Sigma_Harray);
Py_DECREF(Sigma_Aarray);
Py_DECREF(m_Aarray);
Py_DECREF(m_Harray);
Py_DECREF(Xarray);
Py_DECREF(Yarray);
Py_DECREF(Rarray);
Py_DECREF(y_tildearray);
Py_DECREF(Gammaarray);
Py_DECREF(sigma_epsilonearray);
Py_INCREF(Py_None);
return Py_None;
}
static PyObject *UtilsC_expectation_A(PyObject *self, PyObject *args){
PyObject *Y,*y_tilde,*m_A,*m_H,*X,*Gamma,*Sigma_A,*sigma_epsilone,*Sigma_H,*PL,*mu_MK,*sigma_MK,*q_Z;
PyArrayObject *q_Zarray,*mu_MKarray,*sigma_MKarray,*PLarray,*Yarray,*y_tildearray,*m_Aarray,*m_Harray,*sigma_epsilonearray,*Sigma_Harray,*Xarray,*Gammaarray,*Sigma_Aarray;
int j,J,m,m2,d,D,nCond,Nrep,nr,K,k;
PyArg_ParseTuple(args, "OOOOOOOOOOOOOiiiii",&q_Z,&mu_MK,&sigma_MK,&PL,&sigma_epsilone,&Gamma,&Sigma_H,&Y,&y_tilde,&m_A,&m_H,&Sigma_A,&X,&J,&D,&nCond,&Nrep,&K);
Xarray = (PyArrayObject *) PyArray_ContiguousFromObject(X,PyArray_INT,3,3);
Sigma_Harray = (PyArrayObject *) PyArray_ContiguousFromObject(Sigma_H,PyArray_FLOAT64,2,2);
m_Aarray = (PyArrayObject *) PyArray_ContiguousFromObject(m_A,PyArray_FLOAT64,2,2);
mu_MKarray = (PyArrayObject *) PyArray_ContiguousFromObject(mu_MK,PyArray_FLOAT64,2,2);
sigma_MKarray = (PyArrayObject *) PyArray_ContiguousFromObject(sigma_MK,PyArray_FLOAT64,2,2);
PLarray = (PyArrayObject *) PyArray_ContiguousFromObject(PL,PyArray_FLOAT64,2,2);
m_Harray = (PyArrayObject *) PyArray_ContiguousFromObject(m_H,PyArray_FLOAT64,1,1);
y_tildearray = (PyArrayObject *) PyArray_ContiguousFromObject(y_tilde,PyArray_FLOAT64,2,2);
sigma_epsilonearray = (PyArrayObject *) PyArray_ContiguousFromObject(sigma_epsilone,PyArray_FLOAT64,1,1);
Yarray = (PyArrayObject *) PyArray_ContiguousFromObject(Y,PyArray_FLOAT64,2,2);
Gammaarray = (PyArrayObject *) PyArray_ContiguousFromObject(Gamma,PyArray_FLOAT64,2,2);
Sigma_Aarray = (PyArrayObject *) PyArray_ContiguousFromObject(Sigma_A,PyArray_FLOAT64,3,3);
q_Zarray = (PyArrayObject *) PyArray_ContiguousFromObject(q_Z,PyArray_FLOAT64,3,3);
npy_float64 *H,*tmp,*tmpT,*GGamma,*tmp2,*X_tilde,*Sigma_Aj,*Delta,*tmpDD,*tmpD,*tmpNrep,*tmpNrep2,*tmpnCond,*tmpnCond2;
npy_float64 *yy_tilde,*SSigma_H,*Sigma_A0;
int *XX,*XXT;
tmpnCond = malloc(sizeof(npy_float64)*nCond);
tmpnCond2 = malloc(sizeof(npy_float64)*nCond);
SSigma_H = malloc(sizeof(npy_float64)*D*D);
Delta = malloc(sizeof(npy_float64)*nCond*nCond);
Sigma_A0 = malloc(sizeof(npy_float64)*nCond*nCond);
Sigma_Aj = malloc(sizeof(npy_float64)*nCond*nCond);
X_tilde = malloc(sizeof(npy_float64)*nCond*D);
H = malloc(sizeof(npy_float64)*D);
tmp = malloc(sizeof(npy_float64)*Nrep*D);
tmpD = malloc(sizeof(npy_float64)*D);
tmpDD = malloc(sizeof(npy_float64)*D*D);
tmpNrep = malloc(sizeof(npy_float64)*Nrep);
tmpNrep2 = malloc(sizeof(npy_float64)*Nrep);
tmpT = malloc(sizeof(npy_float64)*Nrep*D);
GGamma = malloc(sizeof(npy_float64)*Nrep*Nrep);
tmp2 = malloc(sizeof(npy_float64)*Nrep*D);
yy_tilde = malloc(sizeof(npy_float64)*Nrep);
XX = malloc(sizeof(int)*D*Nrep);
XXT = malloc(sizeof(int)*D*Nrep);
for (d=0;d<Nrep;d++){
for (nr=0;nr<Nrep;nr++){
GGamma[d*Nrep + nr] = GetValue(Gammaarray,nr,d);
}
}
for (d=0;d<D;d++){
H[d] = GetValue1D(m_Harray,d);
for (nr=0;nr<D;nr++){
SSigma_H[d*D+nr] = GetValue(Sigma_Harray,d,nr);
}
}
for (m=0;m<nCond;m++){
for (m2=0;m2<nCond;m2++){
for (d=0;d<D;d++){
for (nr=0;nr<Nrep;nr++){
XX[nr*D + d] = GetValue3DInt(Xarray,m2,nr,d);
XXT[d*Nrep + nr] = GetValue3DInt(Xarray,m,nr,d);
}
}
prodMat4(H,XXT,tmpNrep,1,Nrep,D);
prodMat2(tmpNrep,GGamma,tmpNrep2,1,Nrep,Nrep);
prodMat4(tmpNrep2,XX,tmpD,1, D, Nrep);
Sigma_A0[m*nCond + m2] = prodMatScal(tmpD,H,D);
prodMat4(SSigma_H,XXT,tmp,D,Nrep,D);
prodMat2(tmp,GGamma,tmpT,D,Nrep,Nrep);
prodMat4(tmpT,XX,tmpDD,D, D, Nrep);
Sigma_A0[m*nCond + m2] += traceMat(tmpDD,D);
Delta[m*nCond+m2] = 0;
}
}
for (j=0;j<J;j++){
if (GetValue1D(sigma_epsilonearray,j) < eps) GetValue1D(sigma_epsilonearray,j) = eps;
for (nr=0;nr<Nrep;nr++){
yy_tilde[nr] = GetValue(y_tildearray,nr,j);
}
for (m=0;m<nCond;m++){
for (d=0;d<D;d++){
for (nr=0;nr<Nrep;nr++){
XX[nr*D + d] = GetValue3DInt(Xarray,m,nr,d);
}
}
prodMat2(GGamma,yy_tilde,tmpNrep,Nrep,1,Nrep);
prodMat4(tmpNrep,XX,tmpD,1,D,Nrep);
for (d=0;d<D;d++){
X_tilde[m*D+d] = tmpD[d] / GetValue1D(sigma_epsilonearray,j);
}
for (m2=0;m2<nCond;m2++){
Sigma_Aj[m*nCond + m2] = Sigma_A0[m*nCond + m2] / GetValue1D(sigma_epsilonearray,j);
}
}
prodMat2(X_tilde,H,tmpnCond,nCond,1,D);
for (k=0;k<K;k++){
for (m=0;m<nCond;m++){
// Delta[m*nCond+m] = GetValue3D(q_Zarray,m,k,j) / (GetValue(sigma_MKarray,m,k) + eps);
Delta[m*nCond+m] = GetValue3D(q_Zarray,m,k,j) / GetValue(sigma_MKarray,m,k);
tmpnCond2[m] = GetValue(mu_MKarray,m,k);
}
prodaddMat(Delta,tmpnCond2,tmpnCond,nCond,1,nCond);
addMatfast(Delta,Sigma_Aj,nCond,nCond);
}
invMat(Sigma_Aj,nCond);
for (m=0;m<nCond;m++){
for (m2=0;m2<nCond;m2++){
GetValue3D(Sigma_Aarray,m,m2,j) = Sigma_Aj[m*nCond + m2];
}
}
prodMat2(Sigma_Aj,tmpnCond,tmpnCond2,nCond,1,nCond);
for (m=0;m<nCond;m++){
GetValue(m_Aarray,j,m) = tmpnCond2[m];
}
}
free(X_tilde);
free(Sigma_Aj);
free(Sigma_A0);
free(Delta);
free(tmpDD);
free(tmpD);
free(tmpNrep);
free(tmpNrep2);
free(tmpnCond);
free(tmpnCond2);
free(H);
free(tmp);
free(tmpT);
free(GGamma);
free(tmp2);
free(yy_tilde);
free(XX);
free(XXT);
Py_DECREF(q_Zarray);
Py_DECREF(Sigma_Harray);
Py_DECREF(Sigma_Aarray);
Py_DECREF(m_Aarray);
Py_DECREF(m_Harray);
Py_DECREF(Xarray);
Py_DECREF(Yarray);
Py_DECREF(sigma_MKarray);
Py_DECREF(mu_MKarray);
Py_DECREF(PLarray);
Py_DECREF(y_tildearray);
Py_DECREF(Gammaarray);
Py_DECREF(sigma_epsilonearray);
Py_INCREF(Py_None);
return Py_None;
}
