// OPT: don't create a new FacetComplex, use a non modifying alg on the old one
bool FacetComplex::AreConnected_new(const facet& g1,const facet& g2)const
{
if (g1.IamEmpty() || g2.IamEmpty()) return false;
if (g1==g2 || AreDirectlyConnected(g1,g2)) return true;
if (this->mySize()==2) return false;// they are 2, they are not directly connected, they are not connected
unsigned int g1_index=myGetIndex(g1);
unsigned int g2_index=myGetIndex(g2);
vector<unsigned int> P,P1;
for (unsigned int i=0;i!=mySize();++i)
P.push_back(i);
list<unsigned int> xj;
vector<unsigned int> g;
for (unsigned int j=0;j!=myNumIndets();++j)
{
myMakeXj(xj,j);
if (xj.size()>1)
{
myMakeG(g,P,xj);
P1.clear();
for (vector<unsigned int>::const_iterator it1=P.begin();it1!=P.end();++it1)
P1.push_back(g[P[*it1]]);
P1.swap(P);
}//if
}//for
return (P[g1_index]==P[g2_index]);
}// AreConnected_new
// For use in re_connected_new
void FacetComplex::myMakeG(vector<unsigned int>& theL,
const vector<unsigned int>& P,
const list<unsigned>& xj)const
{
theL.clear();
bool found_x=false;
if (xj.empty())
{
for (unsigned int i=0;i!=mySize();++i)
theL.push_back(i);
return;
}//if
unsigned int x=xj.front();
for (vector<unsigned int>::const_iterator it=P.begin();it!=P.end();++it)
{
found_x=false;
for (list<unsigned int>::const_iterator it1=xj.begin();it1!=xj.end();++it1)
{
if (P[*it1]==*it)
{found_x=true;break;}
}//for
if (found_x) theL.push_back(x); else theL.push_back(*it);
}// for
return;
}//FacetComplex::MakeG
void mexFunction( int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]){ ALLOCATES();
CreateTicTacToc( CallMatlab );
CreateTicTacToc( callSort );
int I, J, K, ii, jj, kk;
int IJ, IJK, IJK_1;
int DI, DJ, DK, DIJK, DIJK_1;
int CDI, CDJ, CDK;
int result, fevals = 0;
int NVOLS, NVOLS_1, n, s, s_start, s_end, v_init;
real *volumes, *V, x, y, *DIST, *order, last_distance;
int *VV=NULL, nV, v, vv;
char skip;
triplet *TS=NULL, *DTS=NULL, T;
mxArray *INPUT[2]={NULL,NULL}, *OUTPUT[3]={NULL,NULL,NULL};
double *MAXs, LAST_MAX;
double thisMINx, thisMINy;
double *idxs;
double *vols;
double *ijk;
char callSort;
mwSize toVec[2]={1,1};
char VERBOSE = 0;
char STR[1024];
if( nlhs > 1 ){
mxErrMsgTxt("too much outputs");
}
if( mxIsChar( prhs[nrhs-1] ) ){
mxGetString( prhs[nrhs-1], STR, 100 );
if( ! myStrcmpi(STR,"verbose") ){
VERBOSE = 1;
} else {
mxErrMsgTxt("only 'verbose' option allowed.");
}
nrhs = nrhs-1;
}
if( nrhs != 3 ){
mxErrMsgTxt("sintax error. max_min_multiples_erodes( V , F , volumes )");
}
if( mxGetClassID( prhs[1] ) != mxFUNCTION_CLASS ){
mxErrMsgTxt("F have to be a function_handle.");
}
if( myNDims( prhs[0] ) > 3 ){
mxErrMsgTxt("bigger than 3d arrays is not allowed.");
}
NVOLS = myNumel( prhs[2] );
NVOLS_1 = NVOLS - 1;
volumes = myGetPr( prhs[2] );
I = mySize( prhs[0] , 0 );
J = mySize( prhs[0] , 1 );
K = mySize( prhs[0] , 2 );
IJ = I*J;
IJK = IJ*K;
VV = (int *) mxMalloc( IJK*sizeof( int ) );
TS = (triplet *) mxMalloc( IJK*sizeof( triplet ) );
V = myGetPr( prhs[0] );
v = 0;
nV = 0;
for( kk = 0 ; kk < K ; kk++ ){ for( jj = 0 ; jj < J ; jj++ ){ for( ii = 0 ; ii < I ; ii++ ){
x = V[ v ];
if( x == x ){
VV[ nV ] = v;
TS[ v ].isnan = 0;
TS[ v ].i = ii;
TS[ v ].j = jj;
TS[ v ].k = kk;
nV++;
} else {
TS[ v ].isnan = 1;
}
v++;
}}}
INPUT[0] = prhs[1];
INPUT[1] = mxCreateNumericMatrix( 1 , 3 , mxDOUBLE_CLASS , mxREAL );
ijk = (double *) mxGetData( INPUT[1] );
ijk[0] = TS[ VV[ nV/2] ].i + 1;
ijk[1] = TS[ VV[ nV/2] ].j + 1;
ijk[2] = TS[ VV[ nV/2] ].k + 1;
OUTPUT[2] = mexCallMATLABWithTrap( 2 , OUTPUT , 2 , INPUT , "feval" );
if( OUTPUT[2] == NULL ){
callSort = 0;
if( mxGetClassID( OUTPUT[0] ) != mxDOUBLE_CLASS ){
if( INPUT[1] != NULL ){ mxDestroyArray( INPUT[1] ); INPUT[1]=NULL; }
if( OUTPUT[0] != NULL ){ mxDestroyArray( OUTPUT[0] ); OUTPUT[0]=NULL; }
if( OUTPUT[1] != NULL ){ mxDestroyArray( OUTPUT[1] ); OUTPUT[1]=NULL; }
if( OUTPUT[2] != NULL ){ mxDestroyArray( OUTPUT[2] ); OUTPUT[2]=NULL; }
mxErrMsgTxt("F debe retornar un double en el primer output.");
}
if( mxGetClassID( OUTPUT[1] ) != mxDOUBLE_CLASS ){
if( INPUT[1] != NULL ){ mxDestroyArray( INPUT[1] ); INPUT[1]=NULL; }
if( OUTPUT[0] != NULL ){ mxDestroyArray( OUTPUT[0] ); OUTPUT[0]=NULL; }
if( OUTPUT[1] != NULL ){ mxDestroyArray( OUTPUT[1] ); OUTPUT[1]=NULL; }
if( OUTPUT[2] != NULL ){ mxDestroyArray( OUTPUT[2] ); OUTPUT[2]=NULL; }
mxErrMsgTxt("F debe retornar un double en el segundo output.");
}
} else {
callSort = 1;
if( VERBOSE ){
mexPrintf("sort has to be called\n");
}
mxDestroyArray( OUTPUT[2] ); OUTPUT[2] = NULL;
result = mexCallMATLAB( 1 , OUTPUT , 2 , INPUT , "feval" );
if( result ){ mxErrMsgTxt("error computing la funcion."); }
if( mxGetClassID( OUTPUT[0] ) != mxDOUBLE_CLASS ){
if( INPUT[1] != NULL ){ mxDestroyArray( INPUT[1] ); INPUT[1]=NULL; }
if( OUTPUT[0] != NULL ){ mxDestroyArray( OUTPUT[0] ); OUTPUT[0]=NULL; }
if( OUTPUT[1] != NULL ){ mxDestroyArray( OUTPUT[1] ); OUTPUT[1]=NULL; }
if( OUTPUT[2] != NULL ){ mxDestroyArray( OUTPUT[2] ); OUTPUT[2]=NULL; }
mxErrMsgTxt("F debe retornar un double en el primer output.");
}
}
DI = mySize( OUTPUT[0] , 0 );
DJ = mySize( OUTPUT[0] , 1 );
DK = mySize( OUTPUT[0] , 2 );
DTS = (triplet *) mxMalloc( 2*DI*DJ*DK*sizeof( triplet ) );
plhs[0] = mxCreateNumericMatrix( NVOLS , 1 , mxREAL_CLASS , mxREAL );
MAXs = (real *) mxGetData( plhs[0] );
for( n = 0 ; n < NVOLS ; n++ ){
MAXs[n] = -10000;
}
LAST_MAX = MAXs[ NVOLS_1 ];
for( v_init = 0 ; v_init < EVERY ; v_init++ ){
if( utIsInterruptPending() ){
if( INPUT[1] != NULL ){ mxDestroyArray( INPUT[1] ); INPUT[1]=NULL; }
if( OUTPUT[0] != NULL ){ mxDestroyArray( OUTPUT[0] ); OUTPUT[0]=NULL; }
if( OUTPUT[1] != NULL ){ mxDestroyArray( OUTPUT[1] ); OUTPUT[1]=NULL; }
if( OUTPUT[2] != NULL ){ mxDestroyArray( OUTPUT[2] ); OUTPUT[2]=NULL; }
mexPrintf("USER INTERRUP!!!\n");
mxErrMsgTxt("USER INTERRUP!!!");
}
if( VERBOSE ){
mexPrintf("v_init: %d (%g) of %d\n", v_init , LAST_MAX , EVERY );
}
for( v = v_init ; v < nV ; v += EVERY ){
vv = VV[ v ];
thisMINx = V[ vv ];
thisMINy = -thisMINx;
if( ( thisMINx < LAST_MAX ) && ( thisMINy < LAST_MAX ) ){
continue;
}
T = TS[ vv ];
ijk[0] = T.i + 1;
ijk[1] = T.j + 1;
ijk[2] = T.k + 1;
if( OUTPUT[0] != NULL ){ mxDestroyArray( OUTPUT[0] ); OUTPUT[0]=NULL; }
if( OUTPUT[1] != NULL ){ mxDestroyArray( OUTPUT[1] ); OUTPUT[1]=NULL; }
if( OUTPUT[2] != NULL ){ mxDestroyArray( OUTPUT[2] ); OUTPUT[2]=NULL; }
if( !callSort ){
tic( CallMatlab );
result = mexCallMATLAB( 2 , OUTPUT , 2 , INPUT , "feval" ); fevals++;
tac( CallMatlab );
} else {
tic( CallMatlab );
result = mexCallMATLAB( 1 , OUTPUT , 2 , INPUT , "feval" ); fevals++;
tac( CallMatlab );
}
DI = mySize( OUTPUT[0] , 0 );
DJ = mySize( OUTPUT[0] , 1 );
DK = mySize( OUTPUT[0] , 2 );
DIJK = DI*DJ*DK;
if( volumes[ NVOLS_1 ] > DIJK ){
if( INPUT[1] != NULL ){ mxDestroyArray( INPUT[1] ); INPUT[1]=NULL; }
if( OUTPUT[0] != NULL ){ mxDestroyArray( OUTPUT[0] ); OUTPUT[0]=NULL; }
if( OUTPUT[1] != NULL ){ mxDestroyArray( OUTPUT[1] ); OUTPUT[1]=NULL; }
if( OUTPUT[2] != NULL ){ mxDestroyArray( OUTPUT[2] ); OUTPUT[2]=NULL; }
mxErrMsgTxt("el maximo volumen debe ser menor que numel(DIST)");
}
DIJK_1 = DIJK - 1;
DIST = (double *) mxGetData( OUTPUT[0] );
DTS = (triplet *) mxRealloc( DTS , DIJK*sizeof( triplet ) );
s = 0;
for( kk = 0 ; kk < DK ; kk++ ){ for( jj = 0 ; jj < DJ ; jj++ ){ for( ii = 0 ; ii < DI ; ii++ ){
DTS[ s ].i = ii;
DTS[ s ].j = jj;
DTS[ s ].k = kk;
s++;
}}}
if( !callSort ){
order = (double *) mxGetData( OUTPUT[1] );
} else {
toVec[0] = mxGetNumberOfElements( OUTPUT[0] );
mxSetDimensions( OUTPUT[0] , toVec , 2 );
tic( callSort );
result = mexCallMATLAB( 2 , OUTPUT+1 , 1 , OUTPUT , "sort" );
tac( callSort );
order = (double *) mxGetData( OUTPUT[2] );
}
CDI = DTS[ (int) ( order[0] - 1 ) ].i;
CDJ = DTS[ (int) ( order[0] - 1 ) ].j;
CDK = DTS[ (int) ( order[0] - 1 ) ].k;
skip = 0;
s = 0;
for( n = 0 ; n < NVOLS ; n++ ){
s_end = (int) ( volumes[n] - 1 );
last_distance = DIST[ (int) order[ s_end ] - 1 ];
while( s_end < DIJK_1 && DIST[ (int) ( order[ s_end + 1 ] - 1 ) ] == last_distance ){
s_end++;
}
s_end++;
for( ; s < s_end ; s++ ){
vv = (int) ( order[ s ] - 1 );
ii = T.i + DTS[ vv ].i - CDI; if( ii < 0 || ii > I ){ skip = 1; break; }
jj = T.j + DTS[ vv ].j - CDJ; if( jj < 0 || jj > J ){ skip = 1; break; }
kk = T.k + DTS[ vv ].k - CDK; if( kk < 0 || kk > K ){ skip = 1; break; }
vv = ii + jj*I + kk*IJ;
if( TS[ vv ].isnan ){ skip = 1; break; }
x = V[ vv ]; if( x < thisMINx ){ thisMINx = x; }
y = -x; if( y < thisMINy ){ thisMINy = y; }
if( ( thisMINx < LAST_MAX ) && ( thisMINy < LAST_MAX ) ){
skip = 1; break;
}
}
if( skip ){ break; }
if( thisMINx > MAXs[n] ){ MAXs[n] = thisMINx; }
if( thisMINy > MAXs[n] ){ MAXs[n] = thisMINy; }
}
LAST_MAX = MAXs[ NVOLS_1 ];
}
}
if( INPUT[1] != NULL ){ mxDestroyArray( INPUT[1] ); INPUT[1] =NULL; }
if( OUTPUT[0] != NULL ){ mxDestroyArray( OUTPUT[0] ); OUTPUT[0]=NULL; }
if( OUTPUT[1] != NULL ){ mxDestroyArray( OUTPUT[1] ); OUTPUT[1]=NULL; }
if( OUTPUT[2] != NULL ){ mxDestroyArray( OUTPUT[2] ); OUTPUT[2]=NULL; }
if( VERBOSE ){
mexPrintf( "\nfevals: %d en tiempo: CallMatlab: %20.30g sorting: %20.30g\n" , fevals , toc( CallMatlab ) , toc( callSort ) );
}
if( VV != NULL ){ mxFree( VV ); }
if( TS != NULL ){ mxFree( TS ); }
if( DTS != NULL ){ mxFree( DTS ); }
myFreeALLOCATES();
}
void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]) { ALLOCATES();
int nX, nN;
int nsd, c, n, x;
double *X, *N, *O, *D, *P;
double minO, minD, dist, xx;
double maximalDIST;
P = NULL;
nsd = mySize( prhs[0] , 1 );
if( mySize( prhs[1] , 1 ) != nsd ){ myErrMsgTxt("number of spatial coordinates (number of column) have to be the same."); }
nX = mySize( prhs[0] , 0 );
X = myGetPr( prhs[0] );
nN = mySize( prhs[1] , 0 );
N = myGetPr( prhs[1] );
if( nrhs > 2 ){
maximalDIST = *( myGetPr( prhs[2] ) );
maximalDIST = maximalDIST*maximalDIST;
// mexPrintf("minimal %g\n\n",maximalDIST);
} else {
maximalDIST = INF;
}
plhs[0] = mxCreateDoubleMatrix(0,0,mxREAL);
mxSetM( plhs[0] , nN ); mxSetN( plhs[0] , 1 ); mxSetData( plhs[0] , mxMalloc( nN << 3 ) );
O = mxGetPr( plhs[0] );
if( nlhs > 1 ){
plhs[1] = mxCreateDoubleMatrix(0,0,mxREAL);
mxSetM( plhs[1] , nN ); mxSetN( plhs[1] , 1 ); mxSetData( plhs[1] , mxMalloc( nN << 3 ) );
D = mxGetPr( plhs[1] );
}
P = mxMalloc( nsd << 3 );
for( n = 0 ; n < nN ; n++ ){
for( c = 0 ; c < nsd ; c++ ){ P[c] = N[ c*nN + n ]; }
dist = 0;
for( c = 0 ; ( c < nsd ) && ( dist < maximalDIST ); c++ ){
xx = X[ c*nX + 0 ] - P[c];
xx = xx*xx;
dist += xx;
}
minO = 0;
minD = dist;
// for( x = 1 ; x < nX && ( minD > maximalDIST ); x++ ){
for( x = 1 ; x < nX ; x++ ){
dist = 0;
for( c = 0 ; c < nsd && ( dist < minD ) && ( dist < maximalDIST ); c++ ){
xx = X[ c*nX + x ] - P[c];
// if( fabs(xx) > minD ){ dist = minD + 1e10; break; }
xx = xx*xx;
dist += xx;
}
if( dist < minD ){
minD = dist;
minO = x;
}
}
O[n] = minO + 1;
if( nlhs > 1 ){
D[n] = sqrt( minD );
}
}
EXIT:
if( P != NULL ){ mxFree(P); }
myFreeALLOCATES();
}
void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]) { ALLOCATES();
real *X, XX[NN], Xk[NN], XXr[NN], D[N], DS[N], fD[N], V[NN], VS[NN], *O, Ok[NN];
long k1, K1, k2, K2, k3, K3, ii, jj;
int ORDER[N];
char STR[100];
enum symmetrize_ { NONE , X_Xt , Xt_X , PLUS };
enum symmetrize_ symmetrize;
enum outs_types { ID , INVERSE , EIGVALS , EIGVECS , EIGVALSDIAG , MAXDIFF , SQRT , LOG , EXP , evalFUN , DET , TRACE };
enum outs_types outs[50];
int ndims, Odims[50];
real det;
int oid;
int D_computed, V_computed, D_sorted, V_sorted, ORDER_computed;
int dim1 , dim2;
mxArray *mxX;
if( nlhs == 0 ){ nlhs = 1; }
if( nlhs > nrhs-2 ){
myErrMsgTxt("There are no enough inputs.\n");
}
if( mxIsCell( prhs[0] ) ){
mxX = mxGetCell( prhs[0] , 0 );
dim1 = myGetValue( mxGetCell( prhs[0] , 1 ) );
dim2 = myGetValue( mxGetCell( prhs[0] , 2 ) );
} else {
mxX = prhs[0];
dim1 = 1;
dim2 = 2;
}
if( ( mySize( mxX , dim1-1 ) != N ) || ( mySize( mxX , dim1-1 ) != N ) ){
myErrMsgTxt("size( X , %d ) and size( X , %d ) have to be equal to three.\n",dim1,dim2);
}
if( myIsEmpty( prhs[1] ) ){
symmetrize = NONE;
} else if( mxIsChar(prhs[1]) ){
mxGetString( prhs[1], STR, 100 );
if( !myStrcmpi(STR,"+") ) {
symmetrize = PLUS;
} else if( !myStrcmpi(STR,"xt*x") || !myStrcmpi(STR,"xtx") ) {
symmetrize = Xt_X;
} else if( !myStrcmpi(STR,"x*xt") || !myStrcmpi(STR,"xxt") ) {
symmetrize = X_Xt;
} else {
myErrMsgTxt("Second argument expected: 'xt*x' , 'x*xt' , '+' , or [].\n");
}
} else {
myErrMsgTxt("Second argument expected: 'xt*x' , 'x*xt' , '+' , or [].\n");
}
for( oid = 0 ; oid < nlhs ; oid++ ){
if( ! mxIsChar(prhs[oid+2]) ){
myErrMsgTxt("Valids arguments are: 'id' 'eigval' 'eigvec' 'log' 'sqrt' 'exp' 'error'.\n");
}
mxGetString( prhs[oid+2], STR, 100 );
if( !myStrcmpi(STR,"id") ) {
outs[oid] = ID;
} else if( !myStrcmpi(STR,"inv") || !myStrcmpi(STR,"inverse") ) {
outs[oid] = INVERSE;
} else if( !myStrcmpi(STR,"det") ) {
outs[oid] = DET;
} else if( !myStrcmpi(STR,"trace") ) {
outs[oid] = TRACE;
} else if( !myStrcmpi(STR,"evec") || !myStrcmpi(STR,"v") || !myStrcmpi(STR,"eigenvec") || !myStrcmpi(STR,"eigvec") || !myStrcmpi(STR,"eigenvectors") ) {
outs[oid] = EIGVECS;
} else if( !myStrcmpi(STR,"eval") || !myStrcmpi(STR,"d") || !myStrcmpi(STR,"eigenval") || !myStrcmpi(STR,"eigval") || !myStrcmpi(STR,"eigenvalues") ) {
outs[oid] = EIGVALS;
} else if( !myStrcmpi(STR,"diag") || !myStrcmpi(STR,"dd") ) {
outs[oid] = EIGVALSDIAG;
} else if( !myStrcmpi(STR,"error") ) {
outs[oid] = MAXDIFF;
} else if( !myStrcmpi(STR,"sqrt") || !myStrcmpi(STR,"sqrtm") ) {
outs[oid] = SQRT;
} else if( !myStrcmpi(STR,"log") || !myStrcmpi(STR,"logm") ) {
outs[oid] = LOG;
} else if( !myStrcmpi(STR,"exp") || !myStrcmpi(STR,"expm") ) {
outs[oid] = EXP;
} else {
myErrMsgTxt("Valids arguments are: 'id' 'inv' 'det' 'trace' 'eigval' 'eigvec' 'log' 'sqrt' 'exp' 'error'.\n");
}
}
X = mxGetPr( mxX );
ndims = myGetSizes( mxX , Odims );
for( oid = 0 ; oid < nlhs ; oid++ ){
switch( outs[oid] ){
case ID:
plhs[oid] = mxCreateNumericArray( ndims , Odims , mxREAL_CLASS , mxREAL );
break;
case INVERSE:
plhs[oid] = mxCreateNumericArray( ndims , Odims , mxREAL_CLASS , mxREAL );
break;
case DET:
Odims[dim1-1] = 1;
Odims[dim2-1] = 1;
plhs[oid] = mxCreateNumericArray( ndims , Odims , mxREAL_CLASS , mxREAL );
Odims[dim1-1] = N;
Odims[dim2-1] = N;
break;
case TRACE:
Odims[dim1-1] = 1;
Odims[dim2-1] = 1;
plhs[oid] = mxCreateNumericArray( ndims , Odims , mxREAL_CLASS , mxREAL );
Odims[dim1-1] = N;
Odims[dim2-1] = N;
break;
case EIGVALS:
Odims[dim2-1] = 1;
plhs[oid] = mxCreateNumericArray( ndims , Odims , mxREAL_CLASS , mxREAL );
Odims[dim2-1] = N;
break;
case EIGVECS:
plhs[oid] = mxCreateNumericArray( ndims , Odims , mxREAL_CLASS , mxREAL );
break;
case EIGVALSDIAG:
plhs[oid] = mxCreateNumericArray( ndims , Odims , mxREAL_CLASS , mxREAL );
break;
case MAXDIFF:
Odims[dim1-1] = 1;
Odims[dim2-1] = 1;
plhs[oid] = mxCreateNumericArray( ndims , Odims , mxREAL_CLASS , mxREAL );
Odims[dim1-1] = N;
Odims[dim2-1] = N;
break;
case EXP:
plhs[oid] = mxCreateNumericArray( ndims , Odims , mxREAL_CLASS , mxREAL );
break;
case LOG:
plhs[oid] = mxCreateNumericArray( ndims , Odims , mxREAL_CLASS , mxREAL );
break;
case SQRT:
plhs[oid] = mxCreateNumericArray( ndims , Odims , mxREAL_CLASS , mxREAL );
break;
case evalFUN:
plhs[oid] = mxCreateNumericArray( ndims , Odims , mxREAL_CLASS , mxREAL );
break;
}
}
K1 = 1;
for( k1 = 0 ; k1 < dim1-1 ; k1++ ){ K1 *= Odims[k1]; }
K2 = 1;
for( k2 = dim1 ; k2 < dim2-1 ; k2++ ){ K2 *= Odims[k2]; }
K3 = 1;
for( k3 = dim2 ; k3 < ndims ; k3++ ){ K3 *= Odims[k3]; }
for( k3 = 0 ; k3 < K3 ; k3++ ){
for( k2 = 0 ; k2 < K2 ; k2++ ){
for( k1 = 0 ; k1 < K1 ; k1++ ){
if( K1 == 1 && K2 == 1 ){
memcpy( Xk , X + k3*NN , NN*sizeof( real ) );
} else {
for( jj = 0 ; jj < N ; jj++ ){ for( ii = 0 ; ii < N ; ii++ ){
Xk[ ii + N*jj ] = X[ k1 + K1*( ii + N*( k2 + K2*( jj + N*k3 ))) ];
} }
}
switch( symmetrize ){
case NONE:
memcpy( XX , Xk , NN*sizeof( real ) );
break;
case X_Xt:
XX[0] = Xk[0]*Xk[0] + Xk[2]*Xk[2];
XX[1] = Xk[1]*Xk[0] + Xk[3]*Xk[2];
XX[2] = Xk[0]*Xk[1] + Xk[2]*Xk[3];
XX[3] = Xk[1]*Xk[1] + Xk[3]*Xk[3];
break;
case Xt_X:
XX[0] = Xk[0]*Xk[0] + Xk[1]*Xk[1];
XX[1] = Xk[2]*Xk[0] + Xk[3]*Xk[1];
XX[2] = Xk[0]*Xk[2] + Xk[1]*Xk[3];
XX[3] = Xk[2]*Xk[2] + Xk[3]*Xk[3];
break;
case PLUS:
XX[0] = Xk[0];
XX[1] = XX[2] = ( Xk[1] + Xk[2] )/2.0;
XX[3] = Xk[3];
break;
}
D_computed = 0;
V_computed = 0;
ORDER_computed = 0;
D_sorted = 0;
V_sorted = 0;
for( oid = 0 ; oid < nlhs ; oid++ ){
switch( outs[oid] ){
case ID:
memcpy( Ok , XX , NN*sizeof( real ) );
O = mxGetPr( plhs[oid] );
ToOutput2x2;
break;
case INVERSE:
det = XX[0]*XX[3] - XX[1]*XX[2];
det = 1.0/det;
Ok[0] = XX[3] *det;
Ok[1] = -XX[1] *det;
Ok[2] = -XX[2] *det;
Ok[3] = XX[0] *det;
O = mxGetPr( plhs[oid] );
ToOutput2x2;
break;
case DET:
Ok[0] = XX[0]*XX[3] - XX[1]*XX[2];
O = mxGetPr( plhs[oid] );
ToOutput1x1;
break;
case TRACE:
Ok[0] = XX[0] + XX[3];
O = mxGetPr( plhs[oid] );
ToOutput1x1;
break;
case EIGVALS:
if( !D_computed ){ EigenValues2x2( XX , D ); D_computed = 1; }
if( !ORDER_computed ){ GetOrder( D, ORDER ); ORDER_computed = 1; }
if( !D_sorted ){ SortEigenValues( D, ORDER , DS ); D_sorted = 1; }
memcpy( Ok , DS , N*sizeof( real ) );
O = mxGetPr( plhs[oid] );
ToOutput2x1;
break;
case EIGVALSDIAG:
if( !D_computed ){ EigenValues2x2( XX , D ); D_computed = 1; }
if( !ORDER_computed ){ GetOrder( D, ORDER ); ORDER_computed = 1; }
if( !D_sorted ){ SortEigenValues( D, ORDER , DS ); D_sorted = 1; }
Ok[0] = DS[0];
Ok[3] = DS[1];
Ok[1] = Ok[2] = 0;
O = mxGetPr( plhs[oid] );
ToOutput2x2;
break;
case EIGVECS:
if( !D_computed ){ EigenValues2x2( XX , D ); D_computed = 1; }
if( !V_computed ){ EigenVectors2x2( XX , D , V); V_computed = 1; }
if( !ORDER_computed ){ GetOrder( D, ORDER ); ORDER_computed = 1; }
if( !V_sorted ){ SortEigenVectors( V, ORDER , VS); V_sorted = 1; }
memcpy( Ok , VS , NN*sizeof( real ) );
O = mxGetPr( plhs[oid] );
ToOutput2x2;
break;
// case MAXDIFF:
// if( !D_computed ){ EigenValuesSym3x3( XX , D ); D_computed = 1; }
// if( !V_computed ){ EigenVectorsSym3x3( XX , D , V); V_computed = 1; }
//
// Ok[0] = V[0]*V[0]*D[0] + V[3]*V[3]*D[1] + V[6]*V[6]*D[2];
// Ok[1] = V[1]*V[0]*D[0] + V[4]*V[3]*D[1] + V[7]*V[6]*D[2];
// Ok[2] = V[2]*V[0]*D[0] + V[5]*V[3]*D[1] + V[8]*V[6]*D[2];
//
// Ok[3] = V[0]*V[1]*D[0] + V[3]*V[4]*D[1] + V[6]*V[7]*D[2];
// Ok[4] = V[1]*V[1]*D[0] + V[4]*V[4]*D[1] + V[7]*V[7]*D[2];
// Ok[5] = V[2]*V[1]*D[0] + V[5]*V[4]*D[1] + V[8]*V[7]*D[2];
//
// Ok[6] = V[0]*V[2]*D[0] + V[3]*V[5]*D[1] + V[6]*V[8]*D[2];
// Ok[7] = V[1]*V[2]*D[0] + V[4]*V[5]*D[1] + V[7]*V[8]*D[2];
// Ok[8] = V[2]*V[2]*D[0] + V[5]*V[5]*D[1] + V[8]*V[8]*D[2];
//
// Ok[0] = MAX9( fabs( Ok[0] - XX[0] ) ,
// fabs( Ok[1] - XX[1] ) ,
// fabs( Ok[2] - XX[2] ) ,
// fabs( Ok[3] - XX[3] ) ,
// fabs( Ok[4] - XX[4] ) ,
// fabs( Ok[5] - XX[5] ) ,
// fabs( Ok[6] - XX[6] ) ,
// fabs( Ok[7] - XX[7] ) ,
// fabs( Ok[8] - XX[8] ) );
//
// O = mxGetPr( plhs[oid] );
// ToOutput1x1;
// break;
//
//
// case SQRT:
// if( !D_computed ){ EigenValuesSym3x3( XX , D ); D_computed = 1; }
// if( !V_computed ){ EigenVectorsSym3x3( XX , D , V); V_computed = 1; }
//
// fD[0] = sqrt( D[0] );
// fD[1] = sqrt( D[1] );
// fD[2] = sqrt( D[2] );
//
// FillOk;
// O = mxGetPr( plhs[oid] );
// ToOutput3x3;
// break;
//
//
// case LOG:
// if( !D_computed ){ EigenValuesSym3x3( XX , D ); D_computed = 1; }
// if( !V_computed ){ EigenVectorsSym3x3( XX , D , V); V_computed = 1; }
//
// fD[0] = log( D[0] );
// fD[1] = log( D[1] );
// fD[2] = log( D[2] );
//
// FillOk;
// O = mxGetPr( plhs[oid] );
// ToOutput3x3;
// break;
#define r eval[0]
#define e eval[1]
#define er eval[2]
case EXP:
r = XX[0] - XX[3];
r = 4*XX[1]*XX[2] + r*r;
if( r >= 0 ){
r = sqrt(r);
e = exp( ( XX[0] + XX[3] - r )/2 )/r/2.0;
er = exp(r);
Ok[0] = e * ( XX[3] - XX[0] + r + er*(XX[0]-XX[3]+r) );
Ok[1] = e * XX[1] * ( er - 1 ) * 2;
Ok[2] = e * XX[2] * ( er - 1 ) * 2;
Ok[3] = e * ( XX[0] - XX[3] + r + er*(XX[3]-XX[0]+r) );
} else {
r = sqrt( -r );
e = exp( ( XX[0] + XX[3] )/2 )/r;
er = sin(r/2);
Ok[0] = e * ( r*cos(r/2) + ( XX[0]-XX[3] )*er );
Ok[1] = 2 * XX[1] * e * er;
Ok[2] = 2 * XX[2] * e * er;
Ok[3] = e * ( r*cos(r/2) + ( XX[3]-XX[0] )*er );
}
O = mxGetPr( plhs[oid] );
ToOutput2x2;
break;
// case evalFUN:
// O = mxGetPr( plhs[oid] ) + k*NN;
// if( !D_computed ){ EigenValuesSym3x3( XX , D ); D_computed = 1; }
// if( !V_computed ){ EigenVectorsSym3x3( XX , D , V); V_computed = 1; }
//
// fD[0] = exp( D[0] );
// fD[1] = exp( D[1] );
// fD[2] = exp( D[2] );
//
// mexCallMATLAB(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[], const char *name)
//
// FillO
// break;
}
}
}}}
EXIT: myFreeALLOCATES();
}
void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])
{
ALLOCATES();
real *M, *O;
int NX, NY;
int Odims[2];
if(nrhs < 1)
mexErrMsgTxt("no input matrix!!.");
if(nrhs > 1)
mexPrintf("only first argument wil be inverted!!.");
if(mxIsComplex(prhs[0]))
mexErrMsgTxt("input matrix is a complex data!!.");
if(mxIsEmpty(prhs[0]))
mexErrMsgTxt("input matrix is empty!!.");
if(!mxIsNumeric(prhs[0]))
mexErrMsgTxt("input matrix is not numeric!!.");
NX = mySize( prhs[0] , 0 );
NY = mySize( prhs[0] , 1 );
if( NX != NY ){ myErrMsgTxt("no square matrix!!."); }
M = (real*)myGetPr( prhs[0] );
/*Creating output*/
Odims[0] = NX;
Odims[1] = NY;
plhs[0] = mxCreateNumericArray( 2 , Odims , mxDOUBLE_CLASS , mxREAL );
O = (real*)myGetPr( plhs[0] );
/*END Creating output*/
switch (NX)
{
case 1:
O[0] = 1/M[0];
break;
case 2:
invt2x2m(O, M);
break;
case 3:
invt3x3m(O, M);
break;
case 4:
if( (M[3] == 0) && (M[7] == 0) && (M[11] == 0) && (M[15] == 1) )
{
invt4x4mh(O, M);
}
else
{
invt4x4m(O, M);
//myErrMsgTxt("inverting matrix 4 x 4 not homogeneous is not implemented yet.");
}
break;
default:
myErrMsgTxt("max size matrix for inverting: 4 x 4.");
break;
}
EXIT: myFreeALLOCATES();
}
void mexFunction( int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]){
int n, i, j ,k, I, J, K, IJ, I1, J1, K1;
int i0,i1,j0,j1,k0,k1,slice;
mwSize sizes[3];
mxLogical *V, *O;
int connect;
if( nrhs < 1 ){
mxErrMsgTxt("sintax error\n");
}
if( !mxIsLogical( prhs[0] ) ){
mxErrMsgTxt("array have to be logical.\n");
}
if( myNDims( prhs[0] ) > 3 ){
mxErrMsgTxt("bigger than 3d arrays is not allowed.\n");
}
if( nrhs > 1 ){
connect = myGetValue( prhs[1] );
if( connect != 26 && connect != 18 && connect != 6 ){
mxErrMsgTxt("valid connects are 6, 18, 26.\n");
}
} else {
connect = 26;
}
I = mySize( prhs[0] , 0 );
J = mySize( prhs[0] , 1 );
K = mySize( prhs[0] , 2 );
IJ = I*J;
I1 = I-1;
J1 = J-1;
K1 = K-1;
sizes[0] = I;
sizes[1] = J;
sizes[2] = K;
V = (mxLogical *) mxGetData( prhs[0] );
plhs[0] = mxCreateLogicalArray( 3 , sizes );
O = (mxLogical *) mxGetData( plhs[0] );
if( connect == 26 ){
n = 0;
for( k = 0 ; k < K ; k++ ){
k0 = k > 0 ? k - 1 : k;
k1 = k < K1 ? k + 1 : k;
for( j = 0 ; j < J ; j++ ){
j0 = j > 0 ? j - 1 : j;
j1 = j < J1 ? j + 1 : j;
for( i = 0 ; i < I ; i++ ){
if( V[n] ){
i0 = i > 0 ? i - 1 : i;
i1 = i < I1 ? i + 1 : i;
O( i0 , j0 , k0 ) = 1;
O( i , j0 , k0 ) = 1;
O( i1 , j0 , k0 ) = 1;
O( i0 , j , k0 ) = 1;
O( i , j , k0 ) = 1;
O( i1 , j , k0 ) = 1;
O( i0 , j1 , k0 ) = 1;
O( i , j1 , k0 ) = 1;
O( i1 , j1 , k0 ) = 1;
O( i0 , j0 , k ) = 1;
O( i , j0 , k ) = 1;
O( i1 , j0 , k ) = 1;
O( i0 , j , k ) = 1;
O[ n ] = 1;
O( i1 , j , k ) = 1;
O( i0 , j1 , k ) = 1;
O( i , j1 , k ) = 1;
O( i1 , j1 , k ) = 1;
O( i0 , j0 , k1 ) = 1;
O( i , j0 , k1 ) = 1;
O( i1 , j0 , k1 ) = 1;
O( i0 , j , k1 ) = 1;
O( i , j , k1 ) = 1;
O( i1 , j , k1 ) = 1;
O( i0 , j1 , k1 ) = 1;
O( i , j1 , k1 ) = 1;
O( i1 , j1 , k1 ) = 1;
}
n++;
}
}
}
} else if( connect == 18 ){
n = 0;
for( k = 0 ; k < K ; k++ ){
k0 = k > 0 ? k - 1 : k;
k1 = k < K1 ? k + 1 : k;
for( j = 0 ; j < J ; j++ ){
j0 = j > 0 ? j - 1 : j;
j1 = j < J1 ? j + 1 : j;
for( i = 0 ; i < I ; i++ ){
if( V[n] ){
i0 = i > 0 ? i - 1 : i;
i1 = i < I1 ? i + 1 : i;
O( i , j0 , k0 ) = 1;
O( i0 , j , k0 ) = 1;
O( i , j , k0 ) = 1;
O( i1 , j , k0 ) = 1;
O( i , j1 , k0 ) = 1;
O( i0 , j0 , k ) = 1;
O( i , j0 , k ) = 1;
O( i1 , j0 , k ) = 1;
O( i0 , j , k ) = 1;
O[ n ] = 1;
O( i1 , j , k ) = 1;
O( i0 , j1 , k ) = 1;
O( i , j1 , k ) = 1;
O( i1 , j1 , k ) = 1;
O( i , j0 , k1 ) = 1;
O( i0 , j , k1 ) = 1;
O( i , j , k1 ) = 1;
O( i1 , j , k1 ) = 1;
O( i , j1 , k1 ) = 1;
}
n++;
}
}
}
} else if( connect == 6 ){
n = 0;
for( k = 0 ; k < K ; k++ ){
k0 = k > 0 ? k - 1 : k;
k1 = k < K-1 ? k + 1 : k;
for( j = 0 ; j < J ; j++ ){
j0 = j > 0 ? j - 1 : j;
j1 = j < J-1 ? j + 1 : j;
for( i = 0 ; i < I ; i++ ){
if( V[n] ){
i0 = i > 0 ? i - 1 : i;
i1 = i < I-1 ? i + 1 : i;
O( i0 , j , k ) = 1;
O( i , j , k ) = 1;
O( i1 , j , k ) = 1;
O( i , j0 , k ) = 1;
O[ n ] = 1;
O( i , j1 , k ) = 1;
O( i , j , k0 ) = 1;
O( i , j , k ) = 1;
O( i , j , k1 ) = 1;
}
n++;
}
}
}
}
}
