//---------------------------------------------------------
DMat& chol(DMat& A, bool in_place)
//---------------------------------------------------------
{
// Given symmetric positive-definite matrix A,
// return its Cholesky-factorization for use
// later in solving (multiple) linear systems.
int M=A.num_rows(), LDA=A.num_rows(), info=0;
char uplo = 'U';
if (in_place)
{
// factorize arg
POTRF (uplo, M, A.data(), LDA, info);
if (info) { umERROR("chol(A)", "dpotrf reports: info = %d", info); }
A.zero_below_diag();
A.set_factmode(FACT_CHOL); // indicate factored state
return A;
}
else
{
// factorize copy of arg
DMat* tmp = new DMat(A, OBJ_temp, "chol(A)");
POTRF (uplo, M, tmp->data(), LDA, info);
if (info) { umERROR("chol(A)", "dpotrf reports: info = %d", info); }
tmp->zero_below_diag();
tmp->set_factmode(FACT_CHOL); // indicate factored state
#if (0)
// compare with Matlab
tmp->print(g_MSGFile, "chol", "lf", 4, 8);
#endif
return (*tmp);
}
}
//=============================================================================
int Epetra_SerialSpdDenseSolver::Factor(void) {
if (Factored()) return(0); // Already factored
if (Inverted()) EPETRA_CHK_ERR(-100); // Cannot factor inverted matrix
int ierr = 0;
ANORM_ = SymMatrix_->OneNorm();
// If we want to refine the solution, then the factor must
// be stored separatedly from the original matrix
if (A_ == AF_)
if (RefineSolution_ ) {
SymFactor_ = new Epetra_SerialSymDenseMatrix(*SymMatrix_);
Factor_ = SymFactor_;
AF_ = SymFactor_->A();
LDAF_ = SymFactor_->LDA();
}
if (Equilibrate_) ierr = EquilibrateMatrix();
if (ierr!=0) EPETRA_CHK_ERR(ierr-2);
POTRF (SymMatrix_->UPLO(), N_, AF_, LDAF_, &INFO_);
Factored_ = true;
double DN = N_;
UpdateFlops((DN*DN*DN)/3.0);
EPETRA_CHK_ERR(INFO_);
return(0);
}
int CHOL(MATRIX_T A)
{
/* computes the Cholesky factorization of A */
int info;
int N = (int)A.nrows;
char uplo = 'L';
POTRF(&uplo,&N,A.m,&N,&info);
// fill the upper triangular
for(int i=0;i<N;i++){
for(int j=i+1;j<N;j++){
A.m[i+j*N] = 0.0;
}}
return info;
}
int main(int argc, char *argv[]){
#ifndef COMPLEX
char *trans[] = {"T", "N"};
#else
char *trans[] = {"C", "N"};
#endif
char *uplo[] = {"U", "L"};
FLOAT alpha[] = {1.0, 0.0};
FLOAT beta [] = {0.0, 0.0};
FLOAT *a, *b;
blasint m, i, j, info, uplos;
int from = 1;
int to = 200;
int step = 1;
FLOAT maxerr;
struct timeval start, stop;
double time1;
argc--;argv++;
if (argc > 0) { from = atol(*argv); argc--; argv++;}
if (argc > 0) { to = MAX(atol(*argv), from); argc--; argv++;}
if (argc > 0) { step = atol(*argv); argc--; argv++;}
fprintf(stderr, "From : %3d To : %3d Step = %3d\n", from, to, step);
if (( a = (FLOAT *)malloc(sizeof(FLOAT) * to * to * COMPSIZE)) == NULL){
fprintf(stderr,"Out of Memory!!\n");exit(1);
}
if (( b = (FLOAT *)malloc(sizeof(FLOAT) * to * to * COMPSIZE)) == NULL){
fprintf(stderr,"Out of Memory!!\n");exit(1);
}
for(m = from; m <= to; m += step){
fprintf(stderr, "M = %6d : ", (int)m);
for (uplos = 0; uplos < 2; uplos ++) {
#ifndef COMPLEX
if (uplos & 1) {
for (j = 0; j < m; j++) {
for(i = 0; i < j; i++) a[i + j * m] = 0.;
a[j + j * m] = ((double) rand() / (double) RAND_MAX) + 8.;
for(i = j + 1; i < m; i++) a[i + j * m] = ((double) rand() / (double) RAND_MAX) - 0.5;
}
} else {
for (j = 0; j < m; j++) {
for(i = 0; i < j; i++) a[i + j * m] = ((double) rand() / (double) RAND_MAX) - 0.5;
a[j + j * m] = ((double) rand() / (double) RAND_MAX) + 8.;
for(i = j + 1; i < m; i++) a[i + j * m] = 0.;
}
}
#else
if (uplos & 1) {
for (j = 0; j < m; j++) {
for(i = 0; i < j; i++) {
a[(i + j * m) * 2 + 0] = 0.;
a[(i + j * m) * 2 + 1] = 0.;
}
a[(j + j * m) * 2 + 0] = ((double) rand() / (double) RAND_MAX) + 8.;
a[(j + j * m) * 2 + 1] = 0.;
for(i = j + 1; i < m; i++) {
a[(i + j * m) * 2 + 0] = ((double) rand() / (double) RAND_MAX) - 0.5;
a[(i + j * m) * 2 + 1] = ((double) rand() / (double) RAND_MAX) - 0.5;
}
}
} else {
for (j = 0; j < m; j++) {
for(i = 0; i < j; i++) {
a[(i + j * m) * 2 + 0] = ((double) rand() / (double) RAND_MAX) - 0.5;
a[(i + j * m) * 2 + 1] = ((double) rand() / (double) RAND_MAX) - 0.5;
}
a[(j + j * m) * 2 + 0] = ((double) rand() / (double) RAND_MAX) + 8.;
a[(j + j * m) * 2 + 1] = 0.;
for(i = j + 1; i < m; i++) {
a[(i + j * m) * 2 + 0] = 0.;
a[(i + j * m) * 2 + 1] = 0.;
}
}
}
#endif
SYRK(uplo[uplos], trans[uplos], &m, &m, alpha, a, &m, beta, b, &m);
gettimeofday( &start, (struct timezone *)0);
POTRF(uplo[uplos], &m, b, &m, &info);
gettimeofday( &stop, (struct timezone *)0);
if (info != 0) {
fprintf(stderr, "Info = %d\n", info);
exit(1);
}
time1 = (double)(stop.tv_sec - start.tv_sec) + (double)((stop.tv_usec - start.tv_usec)) * 1.e-6;
maxerr = 0.;
if (!(uplos & 1)) {
for (j = 0; j < m; j++) {
for(i = 0; i <= j; i++) {
#ifndef COMPLEX
if (maxerr < fabs(a[i + j * m] - b[i + j * m])) maxerr = fabs(a[i + j * m] - b[i + j * m]);
#else
if (maxerr < fabs(a[(i + j * m) * 2 + 0] - b[(i + j * m) * 2 + 0])) maxerr = fabs(a[(i + j * m) * 2 + 0] - b[(i + j * m) * 2 + 0]);
if (maxerr < fabs(a[(i + j * m) * 2 + 1] - b[(i + j * m) * 2 + 1])) maxerr = fabs(a[(i + j * m) * 2 + 1] - b[(i + j * m) * 2 + 1]);
#endif
}
}
} else {
for (j = 0; j < m; j++) {
for(i = j; i < m; i++) {
#ifndef COMPLEX
if (maxerr < fabs(a[i + j * m] - b[i + j * m])) maxerr = fabs(a[i + j * m] - b[i + j * m]);
#else
if (maxerr < fabs(a[(i + j * m) * 2 + 0] - b[(i + j * m) * 2 + 0])) maxerr = fabs(a[(i + j * m) * 2 + 0] - b[(i + j * m) * 2 + 0]);
if (maxerr < fabs(a[(i + j * m) * 2 + 1] - b[(i + j * m) * 2 + 1])) maxerr = fabs(a[(i + j * m) * 2 + 1] - b[(i + j * m) * 2 + 1]);
#endif
}
}
}
fprintf(stderr,
#ifdef XDOUBLE
" %Le %10.3f MFlops", maxerr,
#else
" %e %10.3f MFlops", maxerr,
#endif
getmflops(COMPSIZE * COMPSIZE, m, time1));
if (maxerr > 1.e-3) {
fprintf(stderr, "Hmm, probably it has bug.\n");
exit(1);
}
}
fprintf(stderr, "\n");
}
return 0;
}
int main(int argc, char *argv[]){
#ifndef COMPLEX
char *trans[] = {"T", "N"};
#else
char *trans[] = {"C", "N"};
#endif
char *uplo[] = {"U", "L"};
FLOAT alpha[] = {1.0, 0.0};
FLOAT beta [] = {0.0, 0.0};
FLOAT *a, *b;
char *p;
char btest = 'F';
blasint m, i, j, info, uplos=0;
double flops;
int from = 1;
int to = 200;
int step = 1;
struct timeval start, stop;
double time1;
argc--;argv++;
if (argc > 0) { from = atol(*argv); argc--; argv++;}
if (argc > 0) { to = MAX(atol(*argv), from); argc--; argv++;}
if (argc > 0) { step = atol(*argv); argc--; argv++;}
if ((p = getenv("OPENBLAS_UPLO")))
if (*p == 'L') uplos=1;
if ((p = getenv("OPENBLAS_TEST"))) btest=*p;
fprintf(stderr, "From : %3d To : %3d Step = %3d Uplo = %c\n", from, to, step,*uplo[uplos]);
if (( a = (FLOAT *)malloc(sizeof(FLOAT) * to * to * COMPSIZE)) == NULL){
fprintf(stderr,"Out of Memory!!\n");exit(1);
}
if (( b = (FLOAT *)malloc(sizeof(FLOAT) * to * to * COMPSIZE)) == NULL){
fprintf(stderr,"Out of Memory!!\n");exit(1);
}
for(m = from; m <= to; m += step){
#ifndef COMPLEX
if (uplos & 1) {
for (j = 0; j < m; j++) {
for(i = 0; i < j; i++) a[i + j * m] = 0.;
a[j + j * m] = ((double) rand() / (double) RAND_MAX) + 8.;
for(i = j + 1; i < m; i++) a[i + j * m] = ((double) rand() / (double) RAND_MAX) - 0.5;
}
} else {
for (j = 0; j < m; j++) {
for(i = 0; i < j; i++) a[i + j * m] = ((double) rand() / (double) RAND_MAX) - 0.5;
a[j + j * m] = ((double) rand() / (double) RAND_MAX) + 8.;
for(i = j + 1; i < m; i++) a[i + j * m] = 0.;
}
}
#else
if (uplos & 1) {
for (j = 0; j < m; j++) {
for(i = 0; i < j; i++) {
a[(i + j * m) * 2 + 0] = 0.;
a[(i + j * m) * 2 + 1] = 0.;
}
a[(j + j * m) * 2 + 0] = ((double) rand() / (double) RAND_MAX) + 8.;
a[(j + j * m) * 2 + 1] = 0.;
for(i = j + 1; i < m; i++) {
a[(i + j * m) * 2 + 0] = ((double) rand() / (double) RAND_MAX) - 0.5;
a[(i + j * m) * 2 + 1] = ((double) rand() / (double) RAND_MAX) - 0.5;
}
}
} else {
for (j = 0; j < m; j++) {
for(i = 0; i < j; i++) {
a[(i + j * m) * 2 + 0] = ((double) rand() / (double) RAND_MAX) - 0.5;
a[(i + j * m) * 2 + 1] = ((double) rand() / (double) RAND_MAX) - 0.5;
}
a[(j + j * m) * 2 + 0] = ((double) rand() / (double) RAND_MAX) + 8.;
a[(j + j * m) * 2 + 1] = 0.;
for(i = j + 1; i < m; i++) {
a[(i + j * m) * 2 + 0] = 0.;
a[(i + j * m) * 2 + 1] = 0.;
}
}
}
#endif
SYRK(uplo[uplos], trans[uplos], &m, &m, alpha, a, &m, beta, b, &m);
gettimeofday( &start, (struct timezone *)0);
POTRF(uplo[uplos], &m, b, &m, &info);
gettimeofday( &stop, (struct timezone *)0);
if (info != 0) {
fprintf(stderr, "Potrf info = %d\n", info);
exit(1);
}
time1 = (double)(stop.tv_sec - start.tv_sec) + (double)((stop.tv_usec - start.tv_usec)) * 1.e-6;
flops = COMPSIZE * COMPSIZE * (1.0/3.0 * (double)m * (double)m *(double)m +1.0/2.0* (double)m *(double)m + 1.0/6.0* (double)m) / time1 * 1.e-6;
if ( btest == 'S' )
{
for(j = 0; j < to; j++){
for(i = 0; i < to * COMPSIZE; i++){
a[i + j * to * COMPSIZE] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
}
}
gettimeofday( &start, (struct timezone *)0);
POTRS(uplo[uplos], &m, &m, b, &m, a, &m, &info);
gettimeofday( &stop, (struct timezone *)0);
if (info != 0) {
fprintf(stderr, "Potrs info = %d\n", info);
exit(1);
}
time1 = (double)(stop.tv_sec - start.tv_sec) + (double)((stop.tv_usec - start.tv_usec)) * 1.e-6;
flops = COMPSIZE * COMPSIZE * (2.0 * (double)m * (double)m *(double)m ) / time1 * 1.e-6;
}
if ( btest == 'I' )
{
gettimeofday( &start, (struct timezone *)0);
POTRI(uplo[uplos], &m, b, &m, &info);
gettimeofday( &stop, (struct timezone *)0);
if (info != 0) {
fprintf(stderr, "Potri info = %d\n", info);
exit(1);
}
time1 = (double)(stop.tv_sec - start.tv_sec) + (double)((stop.tv_usec - start.tv_usec)) * 1.e-6;
flops = COMPSIZE * COMPSIZE * (2.0/3.0 * (double)m * (double)m *(double)m +1.0/2.0* (double)m *(double)m + 5.0/6.0* (double)m) / time1 * 1.e-6;
}
fprintf(stderr, "%8d : %10.2f MFlops : %10.3f Sec : Test=%c\n",m,flops ,time1,btest);
}
return 0;
}
/*
* This function returns the solution of Ax=b
*
* The function assumes that A is symmetric & postive definite and employs
* the Cholesky decomposition:
* If A=L L^T with L lower triangular, the system to be solved becomes
* (L L^T) x = b
* This amounts to solving L y = b for y and then L^T x = y for x
*
* A is mxm, b is mx1
*
* The function returns 0 in case of error, 1 if successful
*
* This function is often called repetitively to solve problems of identical
* dimensions. To avoid repetitive malloc's and free's, allocated memory is
* retained between calls and free'd-malloc'ed when not of the appropriate size.
* A call with NULL as the first argument forces this memory to be released.
*/
int AX_EQ_B_CHOL(LM_REAL *A, LM_REAL *B, LM_REAL *x, int m)
{
__STATIC__ LM_REAL *buf=NULL;
__STATIC__ int buf_sz=0;
LM_REAL *a;
int a_sz, tot_sz;
int info, nrhs=1;
if(!A)
#ifdef LINSOLVERS_RETAIN_MEMORY
{
if(buf) free(buf);
buf=NULL;
buf_sz=0;
return 1;
}
#else
return 1; /* NOP */
#endif /* LINSOLVERS_RETAIN_MEMORY */
/* calculate required memory size */
a_sz=m*m;
tot_sz=a_sz;
#ifdef LINSOLVERS_RETAIN_MEMORY
if(tot_sz>buf_sz){ /* insufficient memory, allocate a "big" memory chunk at once */
if(buf) free(buf); /* free previously allocated memory */
buf_sz=tot_sz;
buf=(LM_REAL *)malloc(buf_sz*sizeof(LM_REAL));
if(!buf){
fprintf(stderr, RCAT("memory allocation in ", AX_EQ_B_CHOL) "() failed!\n");
exit(1);
}
}
#else
buf_sz=tot_sz;
buf=(LM_REAL *)malloc(buf_sz*sizeof(LM_REAL));
if(!buf){
fprintf(stderr, RCAT("memory allocation in ", AX_EQ_B_CHOL) "() failed!\n");
exit(1);
}
#endif /* LINSOLVERS_RETAIN_MEMORY */
a=buf;
/* store A into a and B into x. A is assumed symmetric,
* hence no transposition is needed
*/
memcpy(a, A, a_sz*sizeof(LM_REAL));
memcpy(x, B, m*sizeof(LM_REAL));
/* Cholesky decomposition of A */
//POTF2("L", (int *)&m, a, (int *)&m, (int *)&info);
POTRF("L", (int *)&m, a, (int *)&m, (int *)&info);
/* error treatment */
if(info!=0){
if(info<0){
fprintf(stderr, RCAT(RCAT(RCAT("LAPACK error: illegal value for argument %d of ", POTF2) "/", POTRF) " in ",
AX_EQ_B_CHOL) "()\n", -info);
exit(1);
}
else{
fprintf(stderr, RCAT(RCAT(RCAT("LAPACK error: the leading minor of order %d is not positive definite,\nthe factorization could not be completed for ", POTF2) "/", POTRF) " in ", AX_EQ_B_CHOL) "()\n", info);
#ifndef LINSOLVERS_RETAIN_MEMORY
free(buf);
#endif
return 0;
}
}
/* solve using the computed Cholesky in one lapack call */
POTRS("L", (int *)&m, (int *)&nrhs, a, (int *)&m, x, (int *)&m, &info);
if(info<0){
fprintf(stderr, RCAT(RCAT("LAPACK error: illegal value for argument %d of ", POTRS) " in ", AX_EQ_B_CHOL) "()\n", -info);
exit(1);
}
#if 0
/* alternative: solve the linear system L y = b ... */
TRTRS("L", "N", "N", (int *)&m, (int *)&nrhs, a, (int *)&m, x, (int *)&m, &info);
/* error treatment */
if(info!=0){
if(info<0){
fprintf(stderr, RCAT(RCAT("LAPACK error: illegal value for argument %d of ", TRTRS) " in ", AX_EQ_B_CHOL) "()\n", -info);
exit(1);
}
else{
fprintf(stderr, RCAT("LAPACK error: the %d-th diagonal element of A is zero (singular matrix) in ", AX_EQ_B_CHOL) "()\n", info);
#ifndef LINSOLVERS_RETAIN_MEMORY
free(buf);
#endif
return 0;
}
}
/* ... solve the linear system L^T x = y */
TRTRS("L", "T", "N", (int *)&m, (int *)&nrhs, a, (int *)&m, x, (int *)&m, &info);
/* error treatment */
if(info!=0){
if(info<0){
fprintf(stderr, RCAT(RCAT("LAPACK error: illegal value for argument %d of ", TRTRS) "in ", AX_EQ_B_CHOL) "()\n", -info);
exit(1);
}
else{
fprintf(stderr, RCAT("LAPACK error: the %d-th diagonal element of A is zero (singular matrix) in ", AX_EQ_B_CHOL) "()\n", info);
#ifndef LINSOLVERS_RETAIN_MEMORY
free(buf);
#endif
return 0;
}
}
#endif /* 0 */
#ifndef LINSOLVERS_RETAIN_MEMORY
free(buf);
#endif
return 1;
}
void l2ls_learn_basis_dual(DOUBLE *Dopt, DOUBLE *Dorig, DOUBLE *X, DOUBLE *S, DOUBLE l2norm, INT length, INT N, INT K, INT numSamples) {
DOUBLE *SSt = (DOUBLE *) MALLOC(K * K * sizeof(DOUBLE));
CHAR uplo = 'U';
CHAR trans = 'N';
INT SYRKN = K;
INT SYRKK = numSamples;
DOUBLE alpha = 1;
INT SYRKLDA = K;
DOUBLE beta = 0;
INT SYRKLDC = K;
SYRK(&uplo, &trans, &SYRKN, &SYRKK, &alpha, S, &SYRKLDA, &beta, SSt, &SYRKLDC);
DOUBLE *XSt = (DOUBLE *) MALLOC(N * K * sizeof(DOUBLE));
CHAR transa = 'N';
CHAR transb = 'T';
INT GEMMM = N;
INT GEMMN = K;
INT GEMMK = numSamples;
alpha = 1;
INT GEMMLDA = N;
INT GEMMLDB = K;
beta = 0;
INT GEMMLDC = N;
GEMM(&transa, &transb, &GEMMM, &GEMMN, &GEMMK, &alpha, X, &GEMMLDA, S, &GEMMLDB, &beta, XSt, &GEMMLDC);
DOUBLE *SXt = (DOUBLE *) MALLOC(N * K * sizeof(DOUBLE));
transpose(XSt, SXt, N, K);
INT iterK;
DOUBLE *dualLambdaOrig = (DOUBLE *) MALLOC(K * sizeof(DOUBLE));
if (Dorig == NULL) {
srand(time(NULL));
for (iterK = 0; iterK < K; ++iterK) {
dualLambdaOrig[iterK] = 10 * (DOUBLE) rand() / (DOUBLE) RAND_MAX;
}
} else {
INT maxNK = IMAX(N, K);
DOUBLE *B = (DOUBLE *) MALLOC(maxNK * maxNK * sizeof(DOUBLE));
for (iterK = 0; iterK < K; ++iterK) {
datacpy(&B[iterK * maxNK], &XSt[iterK * N], K);
}
INT GELSYM = N;
INT GELSYN = K;
INT GELSYNRHS = K;
INT GELSYLDA = N;
INT GELSYLDB = maxNK;
INT *jpvt = (INT *) MALLOC(K * sizeof(INT));
DOUBLE rcond;
INT rank;
INT lwork = -1;
DOUBLE work_temp;
DOUBLE *work;
INT INFO;
GELSY(&GELSYM, &GELSYN, &GELSYNRHS, Dorig, &GELSYLDA, B, &GELSYLDB, jpvt, &rcond, &rank, &work_temp, &lwork, &INFO);
lwork = (INT) work_temp;
work = (DOUBLE*) MALLOC(lwork * sizeof(DOUBLE));
GELSY(&GELSYM, &GELSYN, &GELSYNRHS, Dorig, &GELSYLDA, XSt, &GELSYLDB, jpvt, &rcond, &rank, work, &lwork, &INFO);
for (iterK = 0; iterK < K; ++iterK) {
dualLambdaOrig[K] = B[iterK * K + iterK] - SSt[iterK * K + iterK];
}
FREE(work);
FREE(B);
FREE(jpvt);
}
DOUBLE *SXtXSt = (DOUBLE *) MALLOC(K * K * sizeof(DOUBLE));
uplo = 'U';
trans = 'N';
SYRKN = K;
SYRKK = N;
alpha = 1;
SYRKLDA = K;
beta = 0;
SYRKLDC = K;
SYRK(&uplo, &trans, &SYRKN, &SYRKK, &alpha, SXt, &SYRKLDA, &beta, SXtXSt, &SYRKLDC);
DOUBLE c = SQR(l2norm);
CHAR norm = 'F';
INT LANGEM = N;
INT LANGEN = numSamples;
INT LANGELDA = N;
DOUBLE trXXt = LANGE(&norm, &LANGEM, &LANGEN, X, &LANGELDA, NULL);
trXXt = SQR(trXXt);
/*
DOUBLE *dualLambdaOpt = (DOUBLE *) MALLOC(K * sizeof(DOUBLE));
*/
DOUBLE *dualLambdaOpt = XSt;
minimize_dual(dualLambdaOpt, dualLambdaOrig, length, SSt, SXt, SXtXSt, trXXt, c, N, K);
for (iterK = 0; iterK < K; ++iterK) {
SSt[iterK * K + iterK] += dualLambdaOpt[iterK];
}
uplo = 'U';
INT POTRSN = K;
INT POTRSLDA = K;
INT INFO;
POTRF(&uplo, &POTRSN, SSt, &POTRSLDA, &INFO);
INT POTRSNRHS = N;
INT POTRSLDB = K;
POTRS(&uplo, &POTRSN, &POTRSNRHS, SSt, &POTRSLDA, SXt, &POTRSLDB, &INFO);
transpose(SXt, Dopt, K, N);
FREE(SSt);
FREE(XSt);
FREE(SXt);
FREE(dualLambdaOrig);
FREE(SXtXSt);
}
void dual_obj_grad(DOUBLE *obj, DOUBLE *deriv, DOUBLE *dualLambda, DOUBLE *SSt, DOUBLE *SXt, DOUBLE *SXtXSt, DOUBLE trXXt, \
DOUBLE c, INT N, INT K, INT derivFlag, DOUBLE *SStLambda, DOUBLE *tempMatrix) {
INT maxNK = IMAX(N, K);
INT SStLambdaFlag = 0;
if (SStLambda == NULL) {
SStLambda = (DOUBLE *) MALLOC(maxNK * K * sizeof(DOUBLE));
SStLambdaFlag = 1;
}
INT tempMatrixFlag = 0;
if (tempMatrix == NULL) {
tempMatrix = (DOUBLE *) MALLOC(maxNK * K * sizeof(DOUBLE));
tempMatrixFlag = 1;
}
datacpy(SStLambda, SSt, K * K);
INT iterK;
/*
#pragma omp parallel for private(iterK) shared(SStLambda, dualLambda, K)
*/
for (iterK = 0; iterK < K; ++iterK) {
SStLambda[iterK * K + iterK] += dualLambda[iterK];
}
CHAR uplo = 'U';
INT POTRSN = K;
INT POTRSLDA = K;
INT INFO;
POTRF(&uplo, &POTRSN, SStLambda, &POTRSLDA, &INFO);
datacpy(tempMatrix, SXtXSt, K * K);
INT POTRSNRHS = K;
INT POTRSLDB = K;
POTRS(&uplo, &POTRSN, &POTRSNRHS, SStLambda, &POTRSLDA, tempMatrix, &POTRSLDB, &INFO);
DOUBLE objTemp = 0;
/*
#pragma omp parallel for private(iterK) shared(tempMatrix, K) reduction(-: objTemp)
*/
for (iterK = 0; iterK < K; ++iterK) {
objTemp = objTemp - tempMatrix[iterK * K + iterK];
}
INT ASUMN = K;
INT incx = 1;
DOUBLE sumDualLambda = ASUM(&ASUMN, dualLambda, &incx);
objTemp += trXXt - c * sumDualLambda;
*obj = - objTemp;
if (derivFlag == 1) {
datacpy(tempMatrix, SXt, K * N);
POTRSNRHS = N;
POTRSLDB = K;
POTRS(&uplo, &POTRSN, &POTRSNRHS, SStLambda, &POTRSLDA, tempMatrix, &POTRSLDB, &INFO);
transpose(tempMatrix, SStLambda, K, N);
INT NRM2N = N;
DOUBLE tempNorm;
#pragma omp parallel for private(iterK, tempNorm) shared(SStLambda, deriv, K, c)
for (iterK = 0; iterK < K; ++iterK) {
tempNorm = NRM2(&NRM2N, &SStLambda[iterK * N], &incx);
deriv[iterK] = - SQR(tempNorm) + c;
}
}
if (SStLambdaFlag == 1) {
FREE(SStLambda);
}
if (tempMatrixFlag == 1) {
FREE(tempMatrix);
}
}
