44 static int CreateSpRowMatWdata(
int,
int,
const double[],
const int[],
const int[],smatx **);
45 static int SpRowMatMult(smatx*,
const double[],
int ,
double[],
int);
46 static int SpRowMatMultTrans(smatx *,
const double[],
int,
double[],
int);
47 static int SpRowMatGetRowVector(smatx*,
int,
double*,
int);
48 static int SpRowMatGetScaledRowVector(smatx*,
int,
const double[],
double*,
int);
49 static int SpRowMatDestroy(smatx*);
50 static int SpRowMatView(smatx*);
56 static int SpRowIMultAdd(smatx*,
int*,
int,
int *,
int);
57 static int SpRowMatRowNnz(smatx*,
int,
int*,
int);
58 static int SpRowMatNorm2(smatx*,
int,
double*);
62 #define __FUNCT__ "LPConeSetUp" 63 static int LPConeSetup(
void *dcone,
DSDPVec y){
67 if (lpcone->n<1)
return 0;
69 info=DSDPVecCreateSeq(m+2,&lpcone->WY);DSDPCHKERR(info);
70 info=DSDPVecDuplicate(lpcone->WY,&lpcone->WY2);DSDPCHKERR(info);
71 info=DSDPVecDuplicate(lpcone->WY,&lpcone->Y);DSDPCHKERR(info);
72 info=DSDPVecDuplicate(lpcone->C,&lpcone->WX);DSDPCHKERR(info);
73 info=DSDPVecDuplicate(lpcone->C,&lpcone->WX2);DSDPCHKERR(info);
74 info=DSDPVecDuplicate(lpcone->C,&lpcone->PS);DSDPCHKERR(info);
75 info=DSDPVecDuplicate(lpcone->C,&lpcone->DS);DSDPCHKERR(info);
76 info=DSDPVecDuplicate(lpcone->C,&lpcone->X);DSDPCHKERR(info);
77 DSDPFunctionReturn(0);
81 #define __FUNCT__ "LPConeSetUp2" 85 DSDPLogInfo(0,19,
"Setup LP Cone of dimension: %d\n",lpcone->n);
86 DSDPFunctionReturn(0);
91 #define __FUNCT__ "LPConeDestroy" 92 static int LPConeDestroy(
void *dcone){
96 if (lpcone->n<1)
return 0;
97 info=DSDPVecDestroy(&lpcone->DS);DSDPCHKERR(info);
98 info=DSDPVecDestroy(&lpcone->PS);DSDPCHKERR(info);
99 info=DSDPVecDestroy(&lpcone->C);DSDPCHKERR(info);
100 info=DSDPVecDestroy(&lpcone->X);DSDPCHKERR(info);
101 info=SpRowMatDestroy(lpcone->A);DSDPCHKERR(info);
102 info=DSDPVecDestroy(&lpcone->WX2);DSDPCHKERR(info);
103 info=DSDPVecDestroy(&lpcone->WY2);DSDPCHKERR(info);
104 info=DSDPVecDestroy(&lpcone->WY);DSDPCHKERR(info);
105 info=DSDPVecDestroy(&lpcone->Y);DSDPCHKERR(info);
106 info=DSDPVecDestroy(&lpcone->WX);DSDPCHKERR(info);
107 DSDPFREE(&lpcone,&info);DSDPCHKERR(info);
108 DSDPFunctionReturn(0);
112 #define __FUNCT__ "LPConeSize" 113 static int LPConeSize(
void *dcone,
double *n){
116 *n=lpcone->muscale*lpcone->n;
117 DSDPFunctionReturn(0);
123 #define __FUNCT__ "LPComputeAX" 125 int info,m=lpcone->m,n=lpcone->n;
129 if (lpcone->n<1)
return 0;
130 info=DSDPVecGetSize(X,&n);DSDPCHKERR(info);
131 info=DSDPVecDot(lpcone->C,X,&ppobj);DSDPCHKERR(info);
132 info=DSDPVecSetC(Y,ppobj);
133 info=DSDPVecSum(X,&ppobj);DSDPCHKERR(info);
134 info=DSDPVecSetR(Y,ppobj*lpcone->r);DSDPCHKERR(info);
135 info=DSDPVecGetArray(Y,&y);DSDPCHKERR(info);
136 info=DSDPVecGetArray(X,&x);DSDPCHKERR(info);
137 info=SpRowMatMult(A,x,n,y+1,m);
138 info=DSDPVecRestoreArray(X,&x);DSDPCHKERR(info);
139 info=DSDPVecRestoreArray(Y,&y);DSDPCHKERR(info);
140 DSDPFunctionReturn(0);
144 #define __FUNCT__ "LPComputeATY" 146 int info,m=lpcone->m,n=lpcone->n;
151 if (lpcone->n<1)
return 0;
152 info=DSDPVecGetC(Y,&cc);DSDPCHKERR(info);
153 info=DSDPVecGetR(Y,&r);DSDPCHKERR(info);
154 info=DSDPVecGetSize(S,&n);DSDPCHKERR(info);
155 info=DSDPVecGetArray(S,&s);DSDPCHKERR(info);
156 info=DSDPVecGetArray(Y,&y);DSDPCHKERR(info);
157 info=SpRowMatMultTrans(A,y+1,m,s,n); DSDPCHKERR(info);
158 info=DSDPVecRestoreArray(S,&s);DSDPCHKERR(info);
159 info=DSDPVecRestoreArray(Y,&y);DSDPCHKERR(info);
160 info=DSDPVecAXPY(cc,C,S);DSDPCHKERR(info);
161 info=DSDPVecShift(r*lpcone->r,S);DSDPCHKERR(info);
162 info=DSDPVecScale(-1.0,S);DSDPCHKERR(info);
163 DSDPFunctionReturn(0);
166 #define __FUNCT__ "LPConeHessian" 167 static int LPConeHessian(
void* dcone,
double mu,
DSDPSchurMat M,
169 int info,i,m,n,ncols;
170 double r=1.0,*wx,*wx2;
172 DSDPVec WX=lpcone->WX,WX2=lpcone->WX2,WY=lpcone->WY,WY2=lpcone->WY2,S=lpcone->DS;
176 if (lpcone->n<1)
return 0;
178 info=DSDPVecGetSize(vrhs1,&m);DSDPCHKERR(info);
179 info=DSDPVecGetSize(WX,&n);DSDPCHKERR(info);
180 info=DSDPVecSet(mu,WX2);DSDPCHKERR(info);
181 info=DSDPVecPointwiseDivide(WX2,S,WX2);DSDPCHKERR(info);
182 info=DSDPVecPointwiseDivide(WX2,S,WX2);DSDPCHKERR(info);
186 if (ncols==0)
continue;
189 info=DSDPVecPointwiseMult(lpcone->C,WX2,WX); DSDPCHKERR(info);
191 info=DSDPVecScaleCopy(WX2,r,WX); DSDPCHKERR(info);
193 info=DSDPVecGetArray(WX,&wx);
194 info=DSDPVecGetArray(WX2,&wx2);DSDPCHKERR(info);
195 info=SpRowMatGetScaledRowVector(A,i-1,wx2,wx,n);
196 info=DSDPVecRestoreArray(WX,&wx);
197 info=DSDPVecRestoreArray(WX2,&wx2);
200 info=LPComputeAX(lpcone,WX,WY);DSDPCHKERR(info);
202 info=DSDPVecPointwiseMult(WY2,WY,WY);DSDPCHKERR(info);
208 info=DSDPVecSet(mu,WX);DSDPCHKERR(info);
209 info=DSDPVecPointwiseDivide(WX,S,WX);DSDPCHKERR(info);
210 info=LPComputeAX(lpcone,WX,WY);DSDPCHKERR(info);
213 info=DSDPVecPointwiseMult(WY2,WY,WY);DSDPCHKERR(info);
214 info=DSDPVecAXPY(1.0,WY,vrhs2);DSDPCHKERR(info);
216 DSDPFunctionReturn(0);
220 #define __FUNCT__ "LPConeHessian" 221 static int LPConeRHS(
void* dcone,
double mu,
DSDPVec vrow,
225 DSDPVec WX=lpcone->WX,WY=lpcone->WY,S=lpcone->DS;
228 if (lpcone->n<1)
return 0;
232 info=DSDPVecSet(mu,WX);DSDPCHKERR(info);
233 info=DSDPVecPointwiseDivide(WX,S,WX);DSDPCHKERR(info);
234 info=LPComputeAX(lpcone,WX,WY);DSDPCHKERR(info);
236 info=DSDPVecPointwiseMult(vrow,WY,WY);DSDPCHKERR(info);
237 info=DSDPVecAXPY(1.0,WY,vrhs2);DSDPCHKERR(info);
239 DSDPFunctionReturn(0);
243 #define __FUNCT__ "LPConeMultiply" 247 DSDPVec WX=lpcone->WX,S=lpcone->DS,WY=lpcone->WY;
249 if (lpcone->n<1)
return 0;
251 info=LPComputeATY(lpcone,vin,WX);DSDPCHKERR(info);
252 info=DSDPVecPointwiseDivide(WX,S,WX);DSDPCHKERR(info);
253 info=DSDPVecScale(mu,WX);DSDPCHKERR(info);
254 info=DSDPVecPointwiseDivide(WX,S,WX);DSDPCHKERR(info);
255 info=LPComputeAX(lpcone,WX,WY);DSDPCHKERR(info);
256 info=DSDPVecPointwiseMult(WY,vrow,WY);DSDPCHKERR(info);
257 info=DSDPVecAXPY(1.0,WY,vout);DSDPCHKERR(info);
258 DSDPFunctionReturn(0);
262 #define __FUNCT__ "LPConeSetX" 263 static int LPConeSetX(
void* dcone,
double mu,
DSDPVec Y,
DSDPVec DY){
265 DSDPFunctionReturn(0);
269 #define __FUNCT__ "LPConeX" 275 DSDPVec S=lpcone->PS,WX=lpcone->WX,X=lpcone->X,DS=lpcone->DS,WY=lpcone->WY;
276 double *xx,*xout=lpcone->xout;
279 if (lpcone->n<1)
return 0;
281 info=LPComputeATY(lpcone,Y,S);DSDPCHKERR(info);
283 info=DSDPVecSet(1.0,WX);
284 info=DSDPVecPointwiseDivide(WX,S,WX);DSDPCHKERR(info);
286 info=LPComputeATY(lpcone,DY,DS);DSDPCHKERR(info);
287 info=DSDPVecPointwiseMult(WX,DS,X);DSDPCHKERR(info);
289 info=DSDPVecScale(-mu,WX);DSDPCHKERR(info);
290 info=DSDPVecPointwiseMult(WX,X,X);DSDPCHKERR(info);
291 info=DSDPVecAXPY(-1.0,WX,X);DSDPCHKERR(info);
292 info=DSDPVecGetArray(X,&xx);DSDPCHKERR(info);
293 for (info=0;info<lpcone->n;info++){
294 if (xx[info]<0) xx[info]=0;
296 info=DSDPVecRestoreArray(X,&xx);DSDPCHKERR(info);
297 info=LPComputeAX(lpcone,X,WY);DSDPCHKERR(info);
298 info=DSDPVecAXPY(1.0,WY,AX);DSDPCHKERR(info);
299 info=DSDPVecDot(S,X,&dtracexs);DSDPCHKERR(info);
301 info=DSDPVecGetArray(X,&xx);DSDPCHKERR(info);
303 for (info=0;info<lpcone->n;info++){
304 if (xout){ xout[info]=xx[info]; }
307 info=DSDPVecRestoreArray(X,&xx);DSDPCHKERR(info);
308 DSDPFunctionReturn(0);
313 #define __FUNCT__ "LPConeS" 323 if (lpcone->n<1)
return 0;
330 info=DSDPVecCopy(Y,lpcone->Y);DSDPCHKERR(info);
331 info=LPComputeATY(lpcone,Y,S);DSDPCHKERR(info);
332 info=DSDPVecGetC(Y,&lpcone->sscale);
333 info=DSDPVecGetSize(S,&n);DSDPCHKERR(info);
334 info=DSDPVecGetArray(S,&s);DSDPCHKERR(info);
336 for (i=0;i<n;i++){
if (s[i]<=0) *psdefinite=
DSDP_FALSE;}
337 info=DSDPVecRestoreArray(S,&s);DSDPCHKERR(info);
339 DSDPFunctionReturn(0);
342 #define __FUNCT__ "LPConeInvertS" 343 static int LPConeInvertS(
void* dcone){
345 DSDPFunctionReturn(0);
349 #define __FUNCT__ "LPConeComputeMaxStepLength" 352 double *s,*ds,mstep=1.0e200;
356 if (lpcone->n<1)
return 0;
363 info=LPComputeATY(lpcone,DY,DS);DSDPCHKERR(info);
365 info=DSDPVecGetSize(DS,&n);DSDPCHKERR(info);
366 info=DSDPVecGetArray(S,&s);DSDPCHKERR(info);
367 info=DSDPVecGetArray(DS,&ds);DSDPCHKERR(info);
368 for (i=0;i<n;i++)
if (ds[i]<0){mstep=DSDPMin(mstep,-s[i]/ds[i]);}
369 info=DSDPVecRestoreArray(S,&s);DSDPCHKERR(info);
370 info=DSDPVecRestoreArray(DS,&ds);DSDPCHKERR(info);
372 *maxsteplength=mstep;
374 DSDPFunctionReturn(0);
379 #define __FUNCT__ "LPConePotential" 380 static int LPConePotential(
void* dcone,
double *logobj,
double *logdet){
382 double *s,mu,sumlog=0;
385 if (lpcone->n<1)
return 0;
387 info=DSDPVecGetArray(lpcone->DS,&s);DSDPCHKERR(info);
388 info=DSDPVecGetSize(lpcone->DS,&n);DSDPCHKERR(info);
390 sumlog+= mu*log(s[i]);
392 info=DSDPVecRestoreArray(lpcone->DS,&s);DSDPCHKERR(info);
395 DSDPFunctionReturn(0);
399 #define __FUNCT__ "LPConeSparsity" 400 static int LPConeSparsity(
void *dcone,
int row,
int *tnnz,
int rnnz[],
int m){
406 if (lpcone->n<1)
return 0;
407 if (row==0)
return 0;
411 info=DSDPVecGetSize(W,&n);DSDPCHKERR(info);
412 info=DSDPVecGetArray(W,&wd);DSDPCHKERR(info);
414 info=SpRowMatRowNnz(lpcone->A,row-1,wi,n);DSDPCHKERR(info);
415 info=SpRowIMultAdd(lpcone->A,wi,n,rnnz+1,m-2);DSDPCHKERR(info);
416 info=DSDPVecRestoreArray(W,&wd);DSDPCHKERR(info);
417 DSDPFunctionReturn(0);
422 #define __FUNCT__ "LPConeMonitor" 423 static int LPConeMonitor(
void *dcone,
int tag){
425 DSDPFunctionReturn(0);
429 #define __FUNCT__ "LPANorm2" 430 static int LPANorm2(
void *dcone,
DSDPVec ANorm){
435 if (lpcone->n<1)
return 0;
436 info=DSDPVecNorm22(lpcone->C,&dd);DSDPCHKERR(info);
437 info=DSDPVecAddC(ANorm,dd);DSDPCHKERR(info);
438 for (i=0;i<lpcone->m;i++){
439 info=SpRowMatNorm2(lpcone->A,i,&dd);DSDPCHKERR(info);
440 info=DSDPVecAddElement(ANorm,i+1,dd);DSDPCHKERR(info);
442 info=DSDPVecAddR(ANorm,1.0);DSDPCHKERR(info);
443 DSDPFunctionReturn(0);
447 static struct DSDPCone_Ops kops;
448 static const char *lpconename=
"LP Cone";
451 #define __FUNCT__ "LPConeOperationsInitialize" 452 static int LPConeOperationsInitialize(
struct DSDPCone_Ops* coneops){
454 if (coneops==NULL)
return 0;
456 coneops->conehessian=LPConeHessian;
457 coneops->conerhs=LPConeRHS;
458 coneops->conesetup=LPConeSetup;
459 coneops->conesetup2=LPConeSetup2;
460 coneops->conedestroy=LPConeDestroy;
461 coneops->conecomputes=LPConeS;
462 coneops->coneinverts=LPConeInvertS;
463 coneops->conesetxmaker=LPConeSetX;
464 coneops->conecomputex=LPConeX;
465 coneops->conemaxsteplength=LPConeComputeMaxStepLength;
466 coneops->conelogpotential=LPConePotential;
467 coneops->conesize=LPConeSize;
468 coneops->conesparsity=LPConeSparsity;
469 coneops->conehmultiplyadd=LPConeMultiply;
470 coneops->conemonitor=LPConeMonitor;
471 coneops->coneanorm2=LPANorm2;
473 coneops->name=lpconename;
478 #define __FUNCT__ "DSDPAddLP" 482 info=LPConeOperationsInitialize(&kops); DSDPCHKERR(info);
483 info=
DSDPAddCone(dsdp,&kops,(
void*)lpcone); DSDPCHKERR(info);
484 DSDPFunctionReturn(0);
488 #define __FUNCT__ "DSDPCreateLPCone" 511 struct LPCone_C *lpcone;
513 DSDPCALLOC1(&lpcone,
struct LPCone_C,&info);DSDPCHKERR(info);
518 info=LPConeOperationsInitialize(&kops); DSDPCHKERR(info);
519 info=
DSDPAddCone(dsdp,&kops,(
void*)lpcone); DSDPCHKERR(info);
526 info=DSDPVecCreateSeq(0,&lpcone->C);DSDPCHKERR(info);
527 info=DSDPVecCreateSeq(0,&lpcone->WY);DSDPCHKERR(info);
528 info=DSDPVecDuplicate(lpcone->C,&lpcone->WX);DSDPCHKERR(info);
529 info=DSDPVecDuplicate(lpcone->C,&lpcone->WX2);DSDPCHKERR(info);
530 info=DSDPVecDuplicate(lpcone->C,&lpcone->PS);DSDPCHKERR(info);
531 info=DSDPVecDuplicate(lpcone->C,&lpcone->DS);DSDPCHKERR(info);
532 info=DSDPVecDuplicate(lpcone->C,&lpcone->X);DSDPCHKERR(info);
533 DSDPFunctionReturn(0);
538 #define __FUNCT__ "LPConeGetXArray" 559 info=DSDPVecGetArray(lpcone->X,x);DSDPCHKERR(info);
560 info=DSDPVecGetSize(lpcone->X,n);DSDPCHKERR(info);
561 DSDPFunctionReturn(0);
565 #define __FUNCT__ "LPConeGetSArray" 575 int LPConeGetSArray(
LPCone lpcone,
double *s[],
int *n){
578 info=DSDPVecGetArray(lpcone->DS,s);DSDPCHKERR(info);
579 info=DSDPVecGetSize(lpcone->DS,n);DSDPCHKERR(info);
580 DSDPFunctionReturn(0);
584 #define __FUNCT__ "LPConeCopyS" 597 double *ss,sscale=lpcone->sscale;
600 info=LPConeS((
void*)lpcone,lpcone->Y,
DUAL_FACTOR ,&psdefinite);DSDPCHKERR(info);
601 info=DSDPVecGetArray(lpcone->DS,&ss);DSDPCHKERR(info);
602 for (i=0;i<n;i++) s[i]=ss[i]/fabs(sscale);
603 DSDPFunctionReturn(0);
607 #define __FUNCT__ "LPConeGetDimension" 618 *n=(int)(lpcone->n*lpcone->muscale);
619 DSDPFunctionReturn(0);
624 #define __FUNCT__ "LPConeScaleBarrier" 625 int LPConeScaleBarrier(
LPCone lpcone,
double muscale){
628 lpcone->muscale=muscale;
630 DSDPFunctionReturn(0);
634 #define __FUNCT__ "LPConeSetData" 667 int info,i,spot,m=lpcone->m;
671 info=DSDPVecCreateSeq(n,&C);DSDPCHKERR(info);
673 info=DSDPVecZero(C);DSDPCHKERR(info);
675 if (n<100) lpcone->muscale=1.0;
676 if (n<10) lpcone->muscale=1.0;
677 for (i=ik[0];i<ik[1];i++){
678 info=DSDPVecSetElement(C,cols[i],vals[i]);
681 info=CreateSpRowMatWdata(m,n,vals+spot,cols+spot,ik+1,&lpcone->A);DSDPCHKERR(info);
682 DSDPFunctionReturn(0);
686 #define __FUNCT__ "LPConeSetData2" 718 int info,i,spot,m=lpcone->m;
722 info=DSDPVecCreateSeq(n,&C);DSDPCHKERR(info);
724 info=DSDPVecZero(C);DSDPCHKERR(info);
726 if (n<100) lpcone->muscale=1.0;
727 if (n<10) lpcone->muscale=1.0;
728 for (i=ik[m];i<ik[m+1];i++){
729 info=DSDPVecSetElement(C,cols[i],vals[i]);
732 info=CreateSpRowMatWdata(m,n,vals+spot,cols+spot,ik,&lpcone->A);DSDPCHKERR(info);
733 DSDPFunctionReturn(0);
737 #define __FUNCT__ "LPConeView2" 747 printf(
"LPCone Constraint Matrix\n");
748 info=SpRowMatView(lpcone->A);DSDPCHKERR(info);
749 printf(
"LPCone Objective C vector\n");
750 info=DSDPVecView(lpcone->C);DSDPCHKERR(info);
751 DSDPFunctionReturn(0);
757 #define __FUNCT__ "LPConeGetConstraint" 763 info=DSDPVecCopy(lpcone->C,W);DSDPCHKERR(info);
765 info=DSDPVecGetSize(W,&n);DSDPCHKERR(info);
766 info=DSDPVecGetArray(W,&w);DSDPCHKERR(info);
767 info=SpRowMatGetRowVector(lpcone->A,column-1,w,n);info=0;DSDPCHKERR(info);
768 info=DSDPVecRestoreArray(W,&w);DSDPCHKERR(info);
770 DSDPFunctionReturn(0);
774 #define __FUNCT__ "LPConeGetData" 787 info=DSDPVecCreateWArray(&W,vv,n);DSDPCHKERR(info);
788 info=LPConeGetConstraint(lpcone,vari,W);DSDPCHKERR(info);
789 DSDPFunctionReturn(0);
793 #define __FUNCT__ "LPConeSetXVec" 794 int LPConeSetXVec(
LPCone lpcone,
double *xout,
int n){
796 if (n==lpcone->n) lpcone->xout=xout;
797 DSDPFunctionReturn(0);
801 static int vsdot(
const int*,
const double *,
int,
const double *,
int,
double *);
802 static int checkvsparse(smatx *);
805 static int CreateSpRowMatWdata(
int m,
int n,
const double vals[],
const int cols[],
const int ik[],
810 V=(smatx*) malloc(1*
sizeof(smatx));
811 if (V==NULL)
return 1;
815 V->an=vals; V->col=cols; V->nnz=ik;
822 static int vsdot(
const int ja[],
const double an[],
int nn0,
const double vv[],
int n,
double *vdot){
827 for (i=0; i<nn0; i++){
829 tmp += an[i] * vv[ja[i]];
835 static int checkvsparse(smatx *A){
836 int i,k=0,m=A->nrow,tnnz=0;
837 const int *nnz=A->nnz;
840 if (nnz[i+1]-nnz[i]>0){
845 A->nzrows =(
int*)malloc((tnnz)*
sizeof(int));
848 if (nnz[i+1]-nnz[i]>0){
861 #define __FUNCT__ "SpRowMatMult" 862 static int SpRowMatMult(smatx* A,
const double x[],
int n,
double y[],
int m){
864 int i,k1,k2,nrow=A->nrow;
865 const int *nnz=A->nnz,*col=A->col;
866 const double *an=A->an;
868 if (A->ncol != n)
return 1;
869 if (A->nrow != m)
return 2;
870 if (x==0 && n>0)
return 3;
871 if (y==0 && m>0)
return 3;
874 memset((
void*)y,0,m*
sizeof(
double));
875 for (i=0; i<nrow; i++){
876 k1=*(nnz+i); k2=*(nnz+i+1);
877 vsdot(col+k1,an+k1,k2-k1,x,n,y+i);
884 #define __FUNCT__ "SpRowMatMultTrans" 885 static int SpRowMatMultTrans(smatx * A,
const double x[],
int m,
double y[],
int n){
887 int i,j,k1,k2,nrow=A->nrow;
888 const int *col=A->col,*nnz=A->nnz;
889 const double *an=A->an;
890 if (A->ncol != n)
return 1;
891 if (A->nrow != m)
return 2;
892 if (x==0 && m>0)
return 3;
893 if (y==0 && n>0)
return 3;
895 memset((
void*)y,0,n*
sizeof(
double));
896 for (i=0; i<nrow; i++){
897 k1=nnz[i]; k2=nnz[i+1];
898 for (j=k1; j<k2; j++){
899 y[col[j]] += an[j]*x[i];
907 static int SpRowMatRowNnz(smatx *A,
int row,
int* wi,
int n){
909 const int *col=A->col;
911 memset((
void*)wi,0,n*
sizeof(
double));
914 for (i=k1; i<k2; i++){
917 DSDPFunctionReturn(0);
920 static int SpRowIMultAdd(smatx *A,
int *wi,
int n,
int *rnnz,
int m){
922 int i,j,k1,k2,nrow=A->nrow;
923 const int *nnz=A->nnz,*col=A->col;
925 for (i=0; i<nrow; i++){
928 for (j=k1; j<k2; j++){
934 DSDPFunctionReturn(0);
949 static int SpRowMatNorm2(smatx* A,
int nrow,
double *norm22){
951 const int *nnz=A->nnz;
953 const double *an=A->an;
955 for (k=nnz[nrow]; k<nnz[nrow+1]; k++){
964 #define __FUNCT__ "SpRowMatGetRowVector" 965 static int SpRowMatGetRowVector(smatx* M,
int row,
double r[],
int m){
968 const int *col=M->col;
969 const double *an=M->an;
975 memset((
void*)r,0,m*
sizeof(
double));
979 for (i=k1; i<k2; i++){
986 #define __FUNCT__ "SpRowMatGetScaledRowVector" 987 static int SpRowMatGetScaledRowVector(smatx* M,
int row,
const double ss[],
double r[],
int m){
990 const int *col=M->col;
991 const double *an=M->an;
997 memset((
void*)r,0,m*
sizeof(
double));
1001 for (i=k1; i<k2; i++){
1002 r[col[i]]=ss[col[i]]*an[i];
1032 #define __FUNCT__ "SpRowMatDestroy" 1033 static int SpRowMatDestroy(smatx* A){
1036 printf(
"Can't free array");
1044 if (A->nzrows) free(A->nzrows);
1051 #define __FUNCT__ "SpRowMatView" 1052 static int SpRowMatView(smatx* M){
1056 for (i=0; i<M->nrow; i++){
1057 k1=M->nnz[i]; k2=M->nnz[i+1];
1060 printf(
"Row %d, (Variable y%d) : ",i,i+1);
1061 for (j=k1; j<k2; j++)
1062 printf(
" %4.2e x%d + ",M->an[j],M->col[j]);
1063 printf(
"= dobj%d \n",i+1);
1071 #define __FUNCT__ "LPConeView" 1082 const int *row=A->col,*nnz=A->nnz;
1083 int n=A->ncol,m=A->nrow;
1084 const double *an=A->an;
1088 printf(
"LPCone Constraint Matrix\n");
1089 printf(
"Number y variables 1 through %d\n",m);
1090 for (i=0; i<n; i++){
1091 printf(
"Inequality %d: ",i);
1093 for (jj=nnz[j];jj<nnz[j+1];jj++){
1095 printf(
"%4.2e y%d + ",an[jj],j+1);
1099 info=DSDPVecGetElement(C,i,&cc);DSDPCHKERR(info);
1100 printf(
" <= %4.2e\n",cc);
1102 DSDPFunctionReturn(0);
int LPConeGetDimension(LPCone lpcone, int *n)
Get the dimension is the number of variables x, which equals the number of slack variables s...
DSDPTruth
Boolean variables.
int LPConeView2(LPCone lpcone)
Print the data in the LP cone to the screen.
struct DSDPVec_C DSDPVec
This object hold m+2 variables: a scaling of C, the y variables, and r.
Schur complement matrix whose solution is the Newton direction.
Error handling, printing, and profiling.
Internal structures for the DSDP solver.
int DSDPCreateLPCone(DSDP dsdp, LPCone *dspcone)
Create a new object for linear programs and scalar inequalities.
int DSDPSchurMatRowColumnScaling(DSDPSchurMat, int, DSDPVec, int *)
Get the scaling and nonzero pattern of each column in this row of the matrix.
int LPConeCopyS(LPCone lpcone, double s[], int n)
Copy the variables s into the spedified array.
int LPConeGetXArray(LPCone lpcone, double *x[], int *n)
Get the array used to store the x variables.
The API to DSDP for those applications using DSDP as a subroutine library.
int LPConeSetData(LPCone lpcone, int n, const int ik[], const int cols[], const double vals[])
Set data into the LP cone.
int LPConeGetData(LPCone lpcone, int vari, double vv[], int n)
Get one column (or row) of the LP data.
int DSDPSchurMatDiagonalScaling(DSDPSchurMat, DSDPVec)
Get the scaling and nonzero pattern of each diagonal element of the matrix.
int LPConeView(LPCone lpcone)
Print the data in the LP cone to the screen.
int DSDPSchurMatAddRow(DSDPSchurMat, int, double, DSDPVec)
Add elements to a row of the Schur matrix.
Implementations of a cone (SDP,LP,...) must provide a structure of function pointers.
DSDPDualFactorMatrix
DSDP requires two instances of the data structures S.
int DSDPGetNumberOfVariables(DSDP dsdp, int *m)
Copy the number of variables y.
int DSDPAddCone(DSDP, struct DSDPCone_Ops *, void *)
Apply DSDP to a conic structure.
int LPConeSetData2(LPCone lpcone, int n, const int ik[], const int cols[], const double vals[])
Set data A and into the LP cone.
int DSDPConeOpsInitialize(struct DSDPCone_Ops *dops)
Initialize the function pointers to 0.
struct LPCone_C * LPCone
The LPCone object points to blocks of data that specify linear scalar inequality constraints.