DSDP
dsdpschurmatadd.c
Go to the documentation of this file.
1#include "dsdpschurmat_impl.h"
2#include "dsdpschurmat.h"
3#include "dsdpbasictypes.h"
4#include "dsdpsys.h"
5
11#define DSDPNoOperationError(a); { DSDPSETERR1(10,"Schur matrix type: %s, Operation not defined\n",(a).dsdpops->matname); }
12#define DSDPChkMatError(a,b); { if (b){ DSDPSETERR1(b,"Schur matrix type: %s,\n",(a).dsdpops->matname);} }
13
14
15#undef __FUNCT__
16#define __FUNCT__ "DSDPSchurMatRowColumnScaling"
33int DSDPSchurMatRowColumnScaling(DSDPSchurMat M,int row, DSDPVec V, int *nzcols){
34 int info,m;
35 double *cols,r=M.schur->r;
36 DSDPTruth flag;
37 DSDPFunctionBegin;
38 info=DSDPVecSet(0.0,V);DSDPCHKERR(info);
39 info=DSDPVecGetSize(V,&m);DSDPCHKERR(info);
40 if (row==0){info=DSDPVecZero(V);DSDPCHKERR(info);*nzcols=0;}
41 else if (row==m-1){
42 info=DSDPVecZero(V);DSDPCHKERR(info);*nzcols=0;
43 if (r){info=DSDPVecSetR(V,1.0);DSDPCHKERR(info);*nzcols=1;}
44 } else if (M.dsdpops->matrownonzeros){
45 info=DSDPVecGetSize(V,&m);DSDPCHKERR(info);
46 info=DSDPVecGetArray(V,&cols);DSDPCHKERR(info);
47 info=(M.dsdpops->matrownonzeros)(M.data,row-1,cols+1,nzcols,m-2); DSDPChkMatError(M,info);
48 info=DSDPVecRestoreArray(V,&cols);DSDPCHKERR(info);
49 info=DSDPZeroFixedVariables(M,V);DSDPCHKERR(info);
50 info=DSDPVecSetC(V,0.0);DSDPCHKERR(info);
51 if (r){info=DSDPVecSetR(V,1.0);DSDPCHKERR(info);}
52 info=DSDPIsFixed(M,row,&flag);DSDPCHKERR(info);
53 if (flag==DSDP_TRUE&&*nzcols>0){info=DSDPVecZero(V);*nzcols=0;DSDPFunctionReturn(0);}
54 } else {
55 DSDPNoOperationError(M);
56 }
57
58 DSDPFunctionReturn(0);
59}
60
61#undef __FUNCT__
62#define __FUNCT__ "DSDPSchurMatAddRow"
76int DSDPSchurMatAddRow(DSDPSchurMat M, int row, double alpha, DSDPVec R){
77 int info,j,m;
78 double *v,rr,dd=1e-1*M.schur->dd;
79 DSDPVec rhs3=M.schur->rhs3;
80 DSDPTruth flag;
81 DSDPFunctionBegin;
82 info=DSDPVecGetSize(R,&m); DSDPCHKERR(info);
83 if (row==0){
84 } else if (row==m-1){
85 info=DSDPVecGetR(R,&rr);DSDPCHKERR(info);
86 info=DSDPVecAddR(rhs3,alpha*rr);DSDPCHKERR(info);
87 } else if (M.dsdpops->mataddrow){
88 info=DSDPVecGetArray(R,&v); DSDPCHKERR(info);
89 /* v[row]=DSDPMax(0,v[row]); v[row]+=1.0e-15; */
90 for (j=0;j<m;j++){ if (fabs(v[j]) < 1e-25 && row!=j){ v[j]=0.0;} }
91 v[row]*=(1.0+dd);
92 info=DSDPZeroFixedVariables(M,R);DSDPCHKERR(info);
93 info=DSDPIsFixed(M,row,&flag);DSDPCHKERR(info);
94 if (flag==DSDP_TRUE){info=DSDPVecSetBasis(R,row);DSDPCHKERR(info);}
95 info=(M.dsdpops->mataddrow)(M.data,row-1,alpha,v+1,m-2); DSDPChkMatError(M,info);
96 info=DSDPVecRestoreArray(R,&v); DSDPCHKERR(info);
97 info=DSDPVecGetR(R,&rr); DSDPCHKERR(info);
98 info=DSDPVecAddElement(rhs3,row,alpha*rr); DSDPCHKERR(info);
99 } else {
100 DSDPNoOperationError(M);
101 }
102 DSDPFunctionReturn(0);
103}
104
105#undef __FUNCT__
106#define __FUNCT__ "DSDPSchurMatVariableCompute"
120int DSDPSchurMatVariableCompute(DSDPSchurMat M, int row, double *rcv){
121 int info,m,dd=1;
122 double r=M.schur->r;
123 DSDPTruth flag;
124 DSDPFunctionBegin;
125 info=DSDPVecGetSize(M.schur->rhs3,&m);
126 if (row==0){ *rcv=0.0;
127 } else if (row==m-1){
128 if (r){*rcv=1.0;}
129 else {*rcv=0.0;}
130 } else if (M.dsdpops->pmatonprocessor){
131 info=(M.dsdpops->pmatonprocessor)(M.data,row-1,&dd); DSDPChkMatError(M,info);
132 if (dd){*rcv=1.0;} else {*rcv=0;}
133 } else {
134 info=DSDPSchurMatInParallel(M,&flag);DSDPChkMatError(M,info);
135 if (flag==DSDP_FALSE){ *rcv=1.0;
136 } else {
137 DSDPNoOperationError(M);
138 }
139 }
140 DSDPFunctionReturn(0);
141}
142
143#undef __FUNCT__
144#define __FUNCT__ "DSDPSchurMatAddDiagonalElement"
158 int info,m;
159 DSDPVec rhs3=M.schur->rhs3;
160 DSDPFunctionBegin;
161 info=DSDPVecGetSize(rhs3,&m);DSDPCHKERR(info);
162 if (dd==0){
163 } else if (row==0){
164 } else if (row==m-1){info=DSDPVecAddR(rhs3,dd);
165 } else if (M.dsdpops->mataddelement){
166 info=(M.dsdpops->mataddelement)(M.data,row-1,dd); DSDPChkMatError(M,info);
167 } else {
168 DSDPNoOperationError(M);
169 }
170 DSDPFunctionReturn(0);
171}
172
173#undef __FUNCT__
174#define __FUNCT__ "DSDPSchurMatVariableComputeR"
182 DSDPFunctionBegin;
183 *rcv=0.0;
184 if (M.schur->r) *rcv=1.0;
185 DSDPFunctionReturn(0);
186}
187
188
189#undef __FUNCT__
190#define __FUNCT__ "DSDPSchurMatAddR"
198int DSDPSchurMatAddR(DSDPSchurMat M, int row, double dd){
199 int info;
200 DSDPFunctionBegin;
201 if (dd==0){DSDPFunctionReturn(0);}
202 info=DSDPVecAddElement(M.schur->rhs3,row,dd);DSDPCHKERR(info);
203 DSDPFunctionReturn(0);
204}
205
206#undef __FUNCT__
207#define __FUNCT__ "DSDPSchurMatVariableComputeC"
208int DSDPSchurMatVariableComputeC(DSDPSchurMat M, double *rcv){
209 DSDPFunctionBegin;
210 *rcv=0.0;
211 DSDPFunctionReturn(0);
212}
213
214#undef __FUNCT__
215#define __FUNCT__ "DSDPSchurMatAddC"
216int DSDPSchurMatAddC(DSDPSchurMat M, int row, double dd){
217 DSDPFunctionBegin;
218 DSDPFunctionReturn(0);
219}
220
221#undef __FUNCT__
222#define __FUNCT__ "DSDPSchurMatDiagonalScaling"
236 int m,info;
237 double *vars;
238 DSDPTruth flag;
239 DSDPFunctionBegin;
240 info=DSDPVecSet(1.0,D);DSDPCHKERR(info);
241 info=DSDPVecGetSize(D,&m);DSDPCHKERR(info);
242 if (M.dsdpops->pmatlocalvariables){
243 info=DSDPVecGetArray(D,&vars);DSDPCHKERR(info);
244 info=(M.dsdpops->pmatlocalvariables)(M.data,vars+1,m-2); DSDPChkMatError(M,info);
245 info=DSDPVecRestoreArray(D,&vars);DSDPCHKERR(info);
246 } else {
247 info=DSDPSchurMatInParallel(M,&flag);DSDPChkMatError(M,info);
248 if (flag==DSDP_TRUE){
249 DSDPNoOperationError(M);
250 }
251 }
252 info=DSDPVecSetC(D,0.0);DSDPCHKERR(info);
253 if (M.schur->r==0){info=DSDPVecSetR(D,0.0);DSDPCHKERR(info);}
254 info=DSDPZeroFixedVariables(M,D);DSDPCHKERR(info);
255 DSDPFunctionReturn(0);
256}
257
258#undef __FUNCT__
259#define __FUNCT__ "DSDPSchurMatAddDiagonal"
273 int m,info;
274 double *dd;
275 DSDPFunctionBegin;
276 if (M.dsdpops->matadddiagonal){
277 info=DSDPZeroFixedVariables(M,D);DSDPCHKERR(info);
278 info=DSDPVecGetSize(D,&m); DSDPCHKERR(info);
279 info=DSDPVecGetArray(D,&dd); DSDPCHKERR(info);
280 info=(M.dsdpops->matadddiagonal)(M.data,dd+1,m-2); DSDPChkMatError(M,info);
281 info=DSDPVecAddR(M.schur->rhs3,dd[m-1]);DSDPCHKERR(info);
282 info=DSDPVecRestoreArray(D,&dd); DSDPCHKERR(info);
283 } else {
284 DSDPNoOperationError(M);
285 }
286 DSDPFunctionReturn(0);
287}
288
289
Solver, solution types, termination codes,.
DSDPTruth
Boolean variables.
@ DSDP_FALSE
@ DSDP_TRUE
int DSDPSchurMatInParallel(DSDPSchurMat M, DSDPTruth *flag)
Determine whether M is computed in parallel.
Methods of a Schur Matrix.
Function pointers that a Schur complement matrix (dense, sparse, parallel dense) must provide.
int DSDPSchurMatVariableCompute(DSDPSchurMat M, int row, double *rcv)
Determine with the cone should compute this diagonal element of M and RHS.
int DSDPSchurMatVariableComputeR(DSDPSchurMat M, double *rcv)
Add an element to the Schur matrix correponding the variable r.
int DSDPSchurMatDiagonalScaling(DSDPSchurMat M, DSDPVec D)
Get the scaling and nonzero pattern of each diagonal element of the matrix.
int DSDPSchurMatAddDiagonalElement(DSDPSchurMat M, int row, double dd)
Determine with the cone should compute this diagonal element of M and RHS.
int DSDPSchurMatRowColumnScaling(DSDPSchurMat M, int row, DSDPVec V, int *nzcols)
Get the scaling and nonzero pattern of each column in this row of the matrix.
int DSDPSchurMatAddRow(DSDPSchurMat M, int row, double alpha, DSDPVec R)
Add elements to a row of the Schur matrix.
int DSDPSchurMatAddDiagonal(DSDPSchurMat M, DSDPVec D)
Add elements to a row of the Schur matrix.
int DSDPSchurMatAddR(DSDPSchurMat M, int row, double dd)
Add an element to the Schur matrix correponding the variable r.
Error handling, printing, and profiling.
struct DSDPVec_C DSDPVec
This object hold m+2 variables: a scaling of C, the y variables, and r.
Definition dsdpvec.h:25
Schur complement matrix whose solution is the Newton direction.