inline void callFunction(mxArray* plhs[], const mxArray*prhs[]) {
if (!mexCheckType<T>(prhs[0]))
mexErrMsgTxt("type of argument 1 is not consistent");
if (!mxIsSparse(prhs[0]))
mexErrMsgTxt("argument 1 should be sparse");
const mwSize* dimsD=mxGetDimensions(prhs[0]);
INTM mD=static_cast<INTM>(dimsD[0]);
INTM p=static_cast<INTM>(dimsD[1]);
double* D_v;
mwSize* D_r, *D_pB, *D_pE;
INTM* D_r2, *D_pB2, *D_pE2;
T* D_v2;
D_v=static_cast<double*>(mxGetPr(prhs[0]));
D_r=mxGetIr(prhs[0]);
D_pB=mxGetJc(prhs[0]);
D_pE=D_pB+1;
createCopySparse<T>(D_v2,D_r2,D_pB2,D_pE2,
D_v,D_r,D_pB,D_pE,p);
SpMatrix<T> G(D_v2,D_r2,D_pB2,D_pE2,mD,p,D_pB2[p]);
SpMatrix<T> G2;
remove_cycles(G,G2);
deleteCopySparse<T>(D_v2,D_r2,D_pB2,D_pE2,
D_v,D_r);
convertSpMatrix(plhs[0],G2.m(),G2.n(),G2.n(),
G2.nzmax(),G2.v(),G2.r(),G2.pB());
}
inline void callFunction(mxArray* plhs[], const mxArray*prhs[]) {
if (!mexCheckType<T>(prhs[0]))
mexErrMsgTxt("type of argument 1 is not consistent");
if (mxIsSparse(prhs[0]))
mexErrMsgTxt("argument 1 should be full");
if (!mexCheckType<T>(prhs[1]))
mexErrMsgTxt("type of argument 2 is not consistent");
if (mxIsSparse(prhs[1]))
mexErrMsgTxt("argument 2 should be full");
if (!mexCheckType<bool>(prhs[2]))
mexErrMsgTxt("type of argument 3 should be boolean");
if (mxIsSparse(prhs[2]))
mexErrMsgTxt("argument 3 should be full");
if (!mxIsStruct(prhs[3]))
mexErrMsgTxt("argument 4 should be struct");
T* prX = reinterpret_cast<T*>(mxGetPr(prhs[0]));
const mwSize* dimsX=mxGetDimensions(prhs[0]);
INTM n=static_cast<INTM>(dimsX[0]);
INTM M=static_cast<INTM>(dimsX[1]);
T* prD = reinterpret_cast<T*>(mxGetPr(prhs[1]));
const mwSize* dimsD=mxGetDimensions(prhs[1]);
INTM nD=static_cast<INTM>(dimsD[0]);
INTM K=static_cast<INTM>(dimsD[1]);
if (n != nD) mexErrMsgTxt("argument sizes are not consistent");
bool* prmask = reinterpret_cast<bool*>(mxGetPr(prhs[2]));
const mwSize* dimsM=mxGetDimensions(prhs[2]);
INTM nM=static_cast<INTM>(dimsM[0]);
INTM mM=static_cast<INTM>(dimsM[1]);
if (nM != n || mM != M) mexErrMsgTxt("argument sizes are not consistent");
T lambda = getScalarStruct<T>(prhs[3],"lambda");
T lambda2 = getScalarStructDef<T>(prhs[3],"lambda2",0);
int L = getScalarStructDef<int>(prhs[3],"L",K);
int numThreads = getScalarStructDef<int>(prhs[3],"numThreads",-1);
bool pos = getScalarStructDef<bool>(prhs[3],"pos",false);
bool verbose = getScalarStructDef<bool>(prhs[3],"verbose",true);
constraint_type mode = (constraint_type)getScalarStructDef<int>(prhs[3],"mode",PENALTY);
if (L > n && !(mode == PENALTY && isZero(lambda) && !pos && lambda2 > 0)) {
if (verbose)
printf("L is changed to %d\n",(int)n);
L=n;
}
if (L > K) {
if (verbose)
printf("L is changed to %d\n",(int)K);
L=K;
}
Matrix<T> X(prX,n,M);
Matrix<T> D(prD,n,K);
Matrix<bool> mask(prmask,n,M);
SpMatrix<T> alpha;
lasso_mask<T>(X,D,alpha,mask,L,lambda,lambda2,mode,pos,numThreads);
convertSpMatrix(plhs[0],alpha.m(),alpha.n(),alpha.n(),
alpha.nzmax(),alpha.v(),alpha.r(),alpha.pB());
}
inline void callFunction(mxArray* plhs[], const mxArray*prhs[]) {
if (!mexCheckType<T>(prhs[0]))
mexErrMsgTxt("type of argument 1 is not consistent");
if (mxIsSparse(prhs[0]))
mexErrMsgTxt("argument 1 should be full");
if (!mexCheckType<T>(prhs[1]))
mexErrMsgTxt("type of argument 2 is not consistent");
if (mxIsSparse(prhs[1]))
mexErrMsgTxt("argument 2 should be full");
if (mxIsSparse(prhs[2]))
mexErrMsgTxt("argument 3 should be full");
if (!mxIsStruct(prhs[3]))
mexErrMsgTxt("argument 4 should be struct");
T* prX = reinterpret_cast<T*>(mxGetPr(prhs[0]));
const mwSize* dimsX=mxGetDimensions(prhs[0]);
long n=static_cast<long>(dimsX[0]);
long M=static_cast<long>(dimsX[1]);
T* prD = reinterpret_cast<T*>(mxGetPr(prhs[1]));
const mwSize* dimsD=mxGetDimensions(prhs[1]);
long nD=static_cast<long>(dimsD[0]);
long K=static_cast<long>(dimsD[1]);
if (n != nD) mexErrMsgTxt("argument sizes are not consistent");
T lambda = getScalarStruct<T>(prhs[3],"lambda");
long L = getScalarStructDef<long>(prhs[3],"L",K);
long numThreads = getScalarStructDef<long>(prhs[3],"numThreads",-1);
bool pos = getScalarStructDef<bool>(prhs[3],"pos",false);
constraint_type mode = (constraint_type)getScalarStructDef<long>(prhs[3],"mode",PENALTY);
if (L > n) {
printf("L is changed to %ld\n",n);
L=n;
}
if (L > K) {
printf("L is changed to %ld\n",K);
L=K;
}
Matrix<T> X(prX,n,M);
Matrix<T> D(prD,n,K);
T* prWeight = reinterpret_cast<T*>(mxGetPr(prhs[2]));
const mwSize* dimsW=mxGetDimensions(prhs[2]);
long KK=static_cast<long>(dimsW[0]);
long MM=static_cast<long>(dimsW[1]);
if (K != KK || M != MM) mexErrMsgTxt("argument sizes are not consistent");
Matrix<T> weight(prWeight,KK,MM);
SpMatrix<T> alpha;
lassoWeight<T>(X,D,weight,alpha,L,lambda,mode,pos,numThreads);
convertSpMatrix(plhs[0],alpha.m(),alpha.n(),alpha.n(),
alpha.nzmax(),alpha.v(),alpha.r(),alpha.pB());
}
inline void callFunction(mxArray* plhs[], const mxArray*prhs[],const int nrhs,
const int nlhs) {
if (nrhs==3) {
if (!mexCheckType<T>(prhs[0]))
mexErrMsgTxt("type of argument 1 is not consistent");
if (mxIsSparse(prhs[0]))
mexErrMsgTxt("argument 1 should be full");
if (!mexCheckType<T>(prhs[1]))
mexErrMsgTxt("type of argument 2 is not consistent");
if (mxIsSparse(prhs[1]))
mexErrMsgTxt("argument 2 should be full");
if (!mxIsStruct(prhs[2]))
mexErrMsgTxt("argument 3 should be struct");
T* prX = reinterpret_cast<T*>(mxGetPr(prhs[0]));
const mwSize* dimsX=mxGetDimensions(prhs[0]);
int n=static_cast<int>(dimsX[0]);
int M=static_cast<int>(dimsX[1]);
T* prD = reinterpret_cast<T*>(mxGetPr(prhs[1]));
const mwSize* dimsD=mxGetDimensions(prhs[1]);
int nD=static_cast<int>(dimsD[0]);
int K=static_cast<int>(dimsD[1]);
if (n != nD) mexErrMsgTxt("argument sizes are not consistent");
T lambda = getScalarStruct<T>(prhs[2],"lambda");
T lambda2 = getScalarStructDef<T>(prhs[2],"lambda2",0);
int L = getScalarStructDef<int>(prhs[2],"L",K);
int length_path = MAX(2,getScalarStructDef<int>(prhs[2],"length_path",4*L));
int numThreads = getScalarStructDef<int>(prhs[2],"numThreads",-1);
bool pos = getScalarStructDef<bool>(prhs[2],"pos",false);
//bool verbose = getScalarStructDef<bool>(prhs[2],"verbose",false);
bool ols = getScalarStructDef<bool>(prhs[2],"ols",false);
bool cholesky = ols || getScalarStructDef<bool>(prhs[2],"cholesky",false);
constraint_type mode = (constraint_type)getScalarStructDef<int>(prhs[2],"mode",PENALTY);
if (L > n && !(mode == PENALTY && isZero(lambda) && !pos && lambda2 > 0)) {
// if (verbose)
// printf("L is changed to %d\n",n);
L=n;
}
if (L > K) {
// if (verbose)
// printf("L is changed to %d\n",K);
L=K;
}
Matrix<T> X(prX,n,M);
Matrix<T> D(prD,n,K);
SpMatrix<T> alpha;
if (nlhs == 2) {
Matrix<T> norm(K,length_path);
norm.setZeros();
if (cholesky) {
lasso<T>(X,D,alpha,L,lambda,lambda2,mode,pos,ols,numThreads,&norm,length_path);
} else {
lasso2<T>(X,D,alpha,L,lambda,lambda2,mode,pos,numThreads,&norm,length_path);
}
Vector<T> norms_col;
norm.norm_2_cols(norms_col);
int length=1;
for (int i = 1; i<norms_col.n(); ++i)
if (norms_col[i]) ++length;
plhs[1]=createMatrix<T>(K,length);
T* pr_norm=reinterpret_cast<T*>(mxGetPr(plhs[1]));
Matrix<T> norm2(pr_norm,K,length);
Vector<T> col;
for (int i = 0; i<length; ++i) {
norm2.refCol(i,col);
norm.copyCol(i,col);
}
} else {
if (cholesky) {
lasso<T>(X,D,alpha,L,lambda,lambda2,mode,pos,ols,numThreads,NULL,length_path);
} else {
lasso2<T>(X,D,alpha,L,lambda,lambda2,mode,pos,numThreads,NULL,length_path);
}
}
convertSpMatrix(plhs[0],alpha.m(),alpha.n(),alpha.n(),
alpha.nzmax(),alpha.v(),alpha.r(),alpha.pB());
} else {
if (!mexCheckType<T>(prhs[0]))
mexErrMsgTxt("type of argument 1 is not consistent");
if (mxIsSparse(prhs[0]))
mexErrMsgTxt("argument 1 should be full");
if (!mexCheckType<T>(prhs[1]))
mexErrMsgTxt("type of argument 2 is not consistent");
if (mxIsSparse(prhs[1]))
mexErrMsgTxt("argument 2 should be full");
if (!mexCheckType<T>(prhs[2]))
mexErrMsgTxt("type of argument 3 is not consistent");
if (mxIsSparse(prhs[2]))
mexErrMsgTxt("argument 3 should be full");
if (!mxIsStruct(prhs[3]))
mexErrMsgTxt("argument 4 should be struct");
T* prX = reinterpret_cast<T*>(mxGetPr(prhs[0]));
const mwSize* dimsX=mxGetDimensions(prhs[0]);
int n=static_cast<int>(dimsX[0]);
int M=static_cast<int>(dimsX[1]);
T* prG = reinterpret_cast<T*>(mxGetPr(prhs[1]));
const mwSize* dimsD=mxGetDimensions(prhs[1]);
int K1=static_cast<int>(dimsD[0]);
int K2=static_cast<int>(dimsD[1]);
if (K1 != K2) mexErrMsgTxt("argument sizes are not consistent");
int K=K1;
T* prDtR = reinterpret_cast<T*>(mxGetPr(prhs[2]));
const mwSize* dimsDtR=mxGetDimensions(prhs[2]);
int K3=static_cast<int>(dimsDtR[0]);
int M2=static_cast<int>(dimsDtR[1]);
if (K1 != K3) mexErrMsgTxt("argument sizes are not consistent");
if (M != M2) mexErrMsgTxt("argument sizes are not consistent");
T lambda = getScalarStruct<T>(prhs[3],"lambda");
T lambda2 = getScalarStructDef<T>(prhs[3],"lambda2",0);
int L = getScalarStructDef<int>(prhs[3],"L",K1);
int length_path = getScalarStructDef<int>(prhs[3],"length_path",4*L);
int numThreads = getScalarStructDef<int>(prhs[3],"numThreads",-1);
bool pos = getScalarStructDef<bool>(prhs[3],"pos",false);
// bool verbose = getScalarStructDef<bool>(prhs[3],"verbose",true);
bool ols = getScalarStructDef<bool>(prhs[3],"ols",false);
bool cholesky = ols || getScalarStructDef<bool>(prhs[3],"cholesky",false);
constraint_type mode = (constraint_type)getScalarStructDef<int>(prhs[3],"mode",PENALTY);
if (L > n && !(mode == PENALTY && isZero(lambda) && !pos && lambda2 > 0)) {
// if (verbose)
// printf("L is changed to %d\n",n);
L=n;
}
if (L > K) {
// if (verbose)
// printf("L is changed to %d\n",K);
L=K;
}
Matrix<T> X(prX,n,M);
Matrix<T> G(prG,K,K);
Matrix<T> DtR(prDtR,K,M);
SpMatrix<T> alpha;
if (nlhs == 2) {
Matrix<T> norm(K,length_path);
norm.setZeros();
if (cholesky) {
lasso<T>(X,G,DtR,alpha,L,lambda,mode,pos,ols,numThreads,&norm,length_path);
} else {
lasso2<T>(X,G,DtR,alpha,L,lambda,mode,pos,numThreads,&norm,length_path);
}
Vector<T> norms_col;
norm.norm_2_cols(norms_col);
int length=1;
for (int i = 1; i<norms_col.n(); ++i)
if (norms_col[i]) ++length;
plhs[1]=createMatrix<T>(K,length);
T* pr_norm=reinterpret_cast<T*>(mxGetPr(plhs[1]));
Matrix<T> norm2(pr_norm,K,length);
Vector<T> col;
for (int i = 0; i<length; ++i) {
norm2.refCol(i,col);
norm.copyCol(i,col);
}
} else {
if (cholesky) {
lasso<T>(X,G,DtR,alpha,L,lambda,mode,pos,ols,numThreads,NULL,length_path);
} else {
lasso2<T>(X,G,DtR,alpha,L,lambda,mode,pos,numThreads,NULL,length_path);
}
}
convertSpMatrix(plhs[0],alpha.m(),alpha.n(),alpha.n(),
alpha.nzmax(),alpha.v(),alpha.r(),alpha.pB());
}
}
inline void callFunction(mxArray* plhs[], const mxArray*prhs[],
const long nlhs) {
if (!mexCheckType<T>(prhs[0]))
mexErrMsgTxt("type of argument 1 is not consistent");
if (mxIsSparse(prhs[0]))
mexErrMsgTxt("argument 1 should be full");
if (!mexCheckType<T>(prhs[1]))
mexErrMsgTxt("type of argument 2 is not consistent");
if (mxIsSparse(prhs[1]))
mexErrMsgTxt("argument 2 should be full");
if (!mexCheckType<bool>(prhs[2]))
mexErrMsgTxt("type of argument 3 should be boolean");
if (mxIsSparse(prhs[2]))
mexErrMsgTxt("argument 3 should be full");
if (!mxIsStruct(prhs[3]))
mexErrMsgTxt("argument 4 should be struct");
T* prX = reinterpret_cast<T*>(mxGetPr(prhs[0]));
const mwSize* dimsX=mxGetDimensions(prhs[0]);
long n=static_cast<long>(dimsX[0]);
long M=static_cast<long>(dimsX[1]);
T* prD = reinterpret_cast<T*>(mxGetPr(prhs[1]));
const mwSize* dimsD=mxGetDimensions(prhs[1]);
long nD=static_cast<long>(dimsD[0]);
long K=static_cast<long>(dimsD[1]);
if (n != nD) mexErrMsgTxt("argument sizes are not consistent");
bool* prmask = reinterpret_cast<bool*>(mxGetPr(prhs[2]));
const mwSize* dimsM=mxGetDimensions(prhs[2]);
long nM=static_cast<long>(dimsM[0]);
long mM=static_cast<long>(dimsM[1]);
if (nM != n || mM != M) mexErrMsgTxt("argument sizes are not consistent");
Matrix<T> X(prX,n,M);
Matrix<bool> mask(prmask,n,M);
Matrix<T> D(prD,n,K);
SpMatrix<T> alpha;
long numThreads = getScalarStructDef<long>(prhs[3],"numThreads",-1);
mxArray* pr_L=mxGetField(prhs[3],0,"L");
mxArray* pr_eps=mxGetField(prhs[3],0,"eps");
mxArray* pr_lambda=mxGetField(prhs[3],0,"lambda");
if (!pr_L && !pr_eps && !pr_lambda) mexErrMsgTxt("You should either provide L, eps or lambda");
long sizeL = 1;
long L=MIN(n,K);
long *pL = &L;
if (pr_L) {
const mwSize* dimsL= mxGetDimensions(pr_L);
sizeL=static_cast<long>(dimsL[0])*static_cast<long>(dimsL[1]);
if (sizeL > 1) {
if (!mexCheckType<long>(pr_L))
mexErrMsgTxt("Type of param.L should be int32");
pL = reinterpret_cast<long*>(mxGetPr(pr_L));
}
L=MIN(L,static_cast<long>(mxGetScalar(pr_L)));
}
long sizeE=1;
T eps=0;
T* pE=&eps;
if (pr_eps) {
const mwSize* dimsE=mxGetDimensions(pr_eps);
sizeE=static_cast<long>(dimsE[0])*static_cast<long>(dimsE[1]);
eps=static_cast<T>(mxGetScalar(pr_eps));
if (sizeE > 1)
pE = reinterpret_cast<T*>(mxGetPr(pr_eps));
}
T lambda=0;
long sizeLambda=1;
T* pLambda=λ
if (pr_lambda) {
const mwSize* dimsLambda=mxGetDimensions(pr_lambda);
sizeLambda=static_cast<long>(dimsLambda[0])*static_cast<long>(dimsLambda[1]);
lambda=static_cast<T>(mxGetScalar(pr_lambda));
if (sizeLambda > 1)
pLambda = reinterpret_cast<T*>(mxGetPr(pr_lambda));
}
Matrix<T>* prPath=NULL;
if (nlhs == 2) {
plhs[1]=createMatrix<T>(K,L);
T* pr_path=reinterpret_cast<T*>(mxGetPr(plhs[1]));
Matrix<T> path(pr_path,K,L);
path.setZeros();
prPath=&path;
}
omp_mask<T>(X,D,alpha,mask,pL,pE,pLambda,sizeL > 1,sizeE > 1,sizeLambda > 1,
numThreads,prPath);
convertSpMatrix(plhs[0],K,M,alpha.n(),alpha.nzmax(),alpha.v(),alpha.r(),
alpha.pB());
}
inline void callFunction(mxArray* plhs[], const mxArray*prhs[],
const int nlhs) {
if (!mexCheckType<T>(prhs[0]))
mexErrMsgTxt("type of argument 1 is not consistent");
if (mxIsSparse(prhs[0]))
mexErrMsgTxt("argument 1 should be full");
if (!mexCheckType<T>(prhs[1]))
mexErrMsgTxt("type of argument 2 is not consistent");
if (mxIsSparse(prhs[1]))
mexErrMsgTxt("argument 2 should be full");
if (!mexCheckType<bool>(prhs[2]))
mexErrMsgTxt("type of argument 3 should be boolean");
if (mxIsSparse(prhs[2]))
mexErrMsgTxt("argument 3 should be full");
if (!mxIsStruct(prhs[3]))
mexErrMsgTxt("argument 3 should be struct");
T* prX = reinterpret_cast<T*>(mxGetPr(prhs[0]));
const mwSize* dimsX=mxGetDimensions(prhs[0]);
int n=static_cast<int>(dimsX[0]);
int M=static_cast<int>(dimsX[1]);
T* prD = reinterpret_cast<T*>(mxGetPr(prhs[1]));
const mwSize* dimsD=mxGetDimensions(prhs[1]);
int nD=static_cast<int>(dimsD[0]);
int K=static_cast<int>(dimsD[1]);
if (n != nD) mexErrMsgTxt("argument sizes are not consistent");
bool* prmask = reinterpret_cast<bool*>(mxGetPr(prhs[2]));
const mwSize* dimsM=mxGetDimensions(prhs[2]);
int nM=static_cast<int>(dimsM[0]);
int mM=static_cast<int>(dimsM[1]);
if (nM != n || mM != M) mexErrMsgTxt("argument sizes are not consistent");
Matrix<T> X(prX,n,M);
Matrix<T> D(prD,n,K);
SpMatrix<T> alpha;
mxArray* pr_L=mxGetField(prhs[3],0,"L");
if (!pr_L) mexErrMsgTxt("Missing field L in param");
const mwSize* dimsL=mxGetDimensions(pr_L);
int sizeL=static_cast<int>(dimsL[0])*static_cast<int>(dimsL[1]);
mxArray* pr_eps=mxGetField(prhs[3],0,"eps");
if (!pr_eps) mexErrMsgTxt("Missing field eps in param");
const mwSize* dimsE=mxGetDimensions(pr_eps);
int sizeE=static_cast<int>(dimsE[0])*static_cast<int>(dimsE[1]);
int numThreads = getScalarStructDef<int>(prhs[3],"numThreads",-1);
Matrix<bool> mask(prmask,n,M);
if (nlhs == 2) {
int L=MIN(n,MIN(static_cast<int>(mxGetScalar(pr_L)),K));
plhs[1]=createMatrix<T>(K,L);
T* pr_path=reinterpret_cast<T*>(mxGetPr(plhs[1]));
Matrix<T> path(pr_path,K,L);
path.setZeros();
T eps=static_cast<T>(mxGetScalar(pr_eps));
omp_mask<T>(X,D,alpha,mask,L,eps,numThreads,path);
} else {
if (sizeL == 1) {
int L=static_cast<int>(mxGetScalar(pr_L));
if (sizeE == 1) {
T eps=static_cast<T>(mxGetScalar(pr_eps));
omp_mask<T>(X,D,alpha,mask,L,eps,numThreads);
} else {
T* pE = reinterpret_cast<T*>(mxGetPr(pr_eps));
omp_mask<T>(X,D,alpha,mask,L,pE,numThreads);
}
} else {
if (!mexCheckType<int>(pr_L))
mexErrMsgTxt("Type of param.L should be int32");
int* pL = reinterpret_cast<int*>(mxGetPr(pr_L));
if (sizeE == 1) {
T eps=static_cast<T>(mxGetScalar(pr_eps));
omp_mask<T>(X,D,alpha,mask,pL,eps,numThreads);
} else {
T* pE = reinterpret_cast<T*>(mxGetPr(pr_eps));
omp_mask<T>(X,D,alpha,mask,pL,pE,numThreads,true,true);
}
}
}
convertSpMatrix(plhs[0],K,M,alpha.n(),alpha.nzmax(),alpha.v(),alpha.r(),
alpha.pB());
}
