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"
17 
33 int 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"
63 
76 int 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"
107 
120 int 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"
145 
157 int DSDPSchurMatAddDiagonalElement(DSDPSchurMat M, int row, double dd){
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"
175 
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"
191 
198 int 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"
208 int DSDPSchurMatVariableComputeC(DSDPSchurMat M, double *rcv){
209  DSDPFunctionBegin;
210  *rcv=0.0;
211  DSDPFunctionReturn(0);
212 }
213 
214 #undef __FUNCT__
215 #define __FUNCT__ "DSDPSchurMatAddC"
216 int DSDPSchurMatAddC(DSDPSchurMat M, int row, double dd){
217  DSDPFunctionBegin;
218  DSDPFunctionReturn(0);
219 }
220 
221 #undef __FUNCT__
222 #define __FUNCT__ "DSDPSchurMatDiagonalScaling"
223 
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"
260 
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 
DSDPTruth
Boolean variables.
int DSDPSchurMatAddRow(DSDPSchurMat M, int row, double alpha, DSDPVec R)
Add elements to a row of the Schur matrix.
struct DSDPVec_C DSDPVec
This object hold m+2 variables: a scaling of C, the y variables, and r.
Definition: dsdpvec.h:25
int DSDPSchurMatAddR(DSDPSchurMat M, int row, double dd)
Add an element to the Schur matrix correponding the variable r.
Schur complement matrix whose solution is the Newton direction.
Definition: dsdpschurmat.h:35
Error handling, printing, and profiling.
int DSDPSchurMatAddDiagonalElement(DSDPSchurMat M, int row, double dd)
Determine with the cone should compute this diagonal element of M and RHS.
Function pointers that a Schur complement matrix (dense, sparse, parallel dense) must provide.
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.
Solver, solution types, termination codes,.
Methods of a Schur Matrix.
int DSDPSchurMatVariableCompute(DSDPSchurMat M, int row, double *rcv)
Determine with the cone should compute this diagonal element of M and RHS.
int DSDPSchurMatAddDiagonal(DSDPSchurMat M, DSDPVec D)
Add elements to a row of the Schur matrix.
int DSDPSchurMatInParallel(DSDPSchurMat M, DSDPTruth *flag)
Determine whether M is computed in parallel.
Definition: dsdpschurmat.c:149
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.