44static int CreateSpRowMatWdata(
int,
int,
const double[],
const int[],
const int[],smatx **);
45static int SpRowMatMult(smatx*,
const double[],
int ,
double[],
int);
46static int SpRowMatMultTrans(smatx *,
const double[],
int,
double[],
int);
47static int SpRowMatGetRowVector(smatx*,
int,
double*,
int);
48static int SpRowMatGetScaledRowVector(smatx*,
int,
const double[],
double*,
int);
49static int SpRowMatDestroy(smatx*);
50static int SpRowMatView(smatx*);
56static int SpRowIMultAdd(smatx*,
int*,
int,
int *,
int);
57static int SpRowMatRowNnz(smatx*,
int,
int*,
int);
58static int SpRowMatNorm2(smatx*,
int,
double*);
62#define __FUNCT__ "LPConeSetUp"
63static 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"
92static 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"
113static 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"
167static 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"
221static 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"
263static 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"
343static 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"
380static 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"
400static 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"
423static int LPConeMonitor(
void *dcone,
int tag){
425 DSDPFunctionReturn(0);
429#define __FUNCT__ "LPANorm2"
430static 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);
447static struct DSDPCone_Ops kops;
448static const char *lpconename=
"LP Cone";
451#define __FUNCT__ "LPConeOperationsInitialize"
452static 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"
509int DSDPCreateLPCone(
DSDP dsdp,
LPCone *dspcone){
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);
520 info=DSDPGetNumberOfVariables(dsdp,&m);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"
556int LPConeGetXArray(
LPCone lpcone,
double *x[],
int *n){
559 info=DSDPVecGetArray(lpcone->X,x);DSDPCHKERR(info);
560 info=DSDPVecGetSize(lpcone->X,n);DSDPCHKERR(info);
561 DSDPFunctionReturn(0);
565#define __FUNCT__ "LPConeGetSArray"
575int 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"
595int LPConeCopyS(
LPCone lpcone,
double s[],
int n){
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"
616int LPConeGetDimension(
LPCone lpcone,
int *n){
618 *n=(int)(lpcone->n*lpcone->muscale);
619 DSDPFunctionReturn(0);
624#define __FUNCT__ "LPConeScaleBarrier"
625int LPConeScaleBarrier(
LPCone lpcone,
double muscale){
628 lpcone->muscale=muscale;
630 DSDPFunctionReturn(0);
634#define __FUNCT__ "LPConeSetData"
666int LPConeSetData(
LPCone lpcone,
int n,
const int ik[],
const int cols[],
const double vals[]){
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"
717int LPConeSetData2(
LPCone lpcone,
int n,
const int ik[],
const int cols[],
const double vals[]){
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"
744int LPConeView2(
LPCone lpcone){
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"
794int LPConeSetXVec(
LPCone lpcone,
double *xout,
int n){
796 if (n==lpcone->n) lpcone->xout=xout;
797 DSDPFunctionReturn(0);
801static int vsdot(
const int*,
const double *,
int,
const double *,
int,
double *);
802static int checkvsparse(smatx *);
805static 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;
822static 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]];
835static 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"
862static 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"
885static 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];
907static 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);
920static 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);
949static 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"
965static 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"
987static 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"
1033static int SpRowMatDestroy(smatx* A){
1036 printf(
"Can't free array");
1044 if (A->nzrows) free(A->nzrows);
1051#define __FUNCT__ "SpRowMatView"
1052static 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"
1078int LPConeView(
LPCone lpcone){
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);
The API to DSDP for those applications using DSDP as a subroutine library.
struct LPCone_C * LPCone
The LPCone object points to blocks of data that specify linear scalar inequality constraints.
DSDPDualFactorMatrix
DSDP requires two instances of the data structures S.
DSDPTruth
Boolean variables.
int DSDPConeOpsInitialize(struct DSDPCone_Ops *dops)
Initialize the function pointers to 0.
Implementations of a cone (SDP,LP,...) must provide a structure of function pointers.
int DSDPAddCone(DSDP, struct DSDPCone_Ops *, void *)
Apply DSDP to a conic structure.
int LPConeGetData(LPCone lpcone, int vari, double vv[], int n)
Get one column (or row) of the LP data.
int DSDPSchurMatRowColumnScaling(DSDPSchurMat, int, DSDPVec, int *)
Get the scaling and nonzero pattern of each column in this row of the matrix.
int DSDPSchurMatAddRow(DSDPSchurMat, int, double, DSDPVec)
Add elements to a row of the Schur matrix.
int DSDPSchurMatDiagonalScaling(DSDPSchurMat, DSDPVec)
Get the scaling and nonzero pattern of each diagonal element of the matrix.
Error handling, printing, and profiling.
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.
Internal structures for the DSDP solver.