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);