Enable R_NO_REMAP for a cleaner namespace
[openmx:openmx.git] / src / csolnpImportFrontend.cpp
1 /*
2  *  Copyright 2007-2012 The OpenMx Project
3  *
4  *  Licensed under the Apache License, Version 2.0 (the "License");
5  *  you may not use this file except in compliance with the License.
6  *  You may obtain a copy of the License at
7  *
8  *       http://www.apache.org/licenses/LICENSE-2.0
9  *
10  *   Unless required by applicable law or agreed to in writing, software
11  *   distributed under the License is distributed on an "AS IS" BASIS,
12  *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  *  See the License for the specific language governing permissions and
14  *  limitations under the License.
15  */
16
17 #define R_NO_REMAP
18 #include <R.h>
19 #include <Rinternals.h>
20
21 #include <sys/stat.h>
22 #include <errno.h>
23
24 #include "omxDefines.h"
25 #include "omxState.h"
26 #include "omxNPSOLSpecific.h"
27 #include "omxImportFrontendState.h"
28 #include "matrix.h"
29
30 Matrix result_csolnpEqBStartFun;
31 Matrix result_csolnpEqB;
32 Matrix result_ineqLB;
33 Matrix result_ineqUB;
34 Matrix result_ineqVal;
35 //double EMPTY = -999999.0;
36
37 void setupIneqLess(struct Matrix *bl_ineqless, struct Matrix *bu_ineqless, int size)
38     {
39         int index = 0;
40         for(int offset = 0; offset < size; offset++) {
41             bl_ineqless->t[index] = NEG_INF;
42             bu_ineqless->t[index] = -0.0;
43             index++;
44         }
45     }
46
47 void setupIneqGreater(struct Matrix *lb, struct Matrix *ub, int size)
48 {
49         int index = 0;
50         for(int offset = 0; offset < size; offset++) {
51             lb->t[index] = 0.0;
52             ub->t[index] = INF;
53             printf("%2f", lb->t[index]); putchar('\n');
54             printf("%2f", ub->t[index]); putchar('\n');
55             index++;
56         }
57 }
58     
59 void setupEqB(struct Matrix *eqPointer, int size)
60     {
61         int index = 0;
62         for(int offset = 0; offset < size; offset++) {
63             eqPointer->t[index] = 0.0;
64             index++;
65         }
66     }
67     
68     
69 void omxProcessConstraintsCsolnp(struct Matrix *lb_ineq, struct Matrix *ub_ineq, struct Matrix *eqb)  {
70     if (globalState->numConstraints == 0){
71         return;
72     }
73     
74     int i;
75     int size;
76         double EMPTY = -999999.0;
77     Matrix lb_ineqless = fill(1, 1, EMPTY);
78     Matrix ub_ineqless = fill(1, 1, EMPTY);
79     Matrix lb_ineqmore = fill(1, 1, EMPTY);
80     Matrix ub_ineqmore = fill(1, 1, EMPTY);
81     Matrix eqbound = fill(1, 1, EMPTY);
82     Matrix ineq_lb = fill(1, 1, EMPTY);
83     Matrix ineq_ub = fill(1, 1, EMPTY);
84     Matrix myeqb = fill(1, 1, EMPTY);
85     
86         for(int constraintIndex = 0; constraintIndex < globalState->numConstraints; constraintIndex++) {
87
88                 size = globalState->conList[constraintIndex].size;
89         
90             if (globalState->conList[constraintIndex].opCode == 0)
91             {
92                 Matrix lb_ineqless = fill(size, 1, EMPTY);
93                 Matrix ub_ineqless = fill(size, 1, EMPTY);
94                 setupIneqLess(&lb_ineqless, &ub_ineqless, size);
95             }
96             
97             if (globalState->conList[constraintIndex].opCode == 1)
98             {
99                 eqbound = fill(size, 1, EMPTY);
100                 setupEqB(&eqbound, size);
101             }
102             
103             if (globalState->conList[constraintIndex].opCode == 2)
104             {
105                 lb_ineqmore = fill(size, 1, EMPTY);
106                 ub_ineqmore = fill(size, 1, EMPTY);
107                 setupIneqGreater(&lb_ineqmore, &ub_ineqmore, size);
108             }
109             
110         printf("lb_ineqmore is: \n");
111         print(lb_ineqmore); putchar('\n');
112         printf("ub_ineqmore is: \n");
113         print(ub_ineqmore); putchar('\n');
114         
115         if (M(lb_ineqless, 0, 0) != EMPTY)
116         {
117             printf("inside lb_ineqless \n");
118             ineq_lb = copy(ineq_lb, lb_ineqless);
119             ineq_ub = copy(ineq_ub, ub_ineqless);
120         }
121         else if (M(lb_ineqmore, 0, 0) != EMPTY)
122         {
123             printf("inside lb_ineqmore \n");
124             ineq_lb = copy(ineq_lb, lb_ineqmore);
125             ineq_ub = copy(ineq_ub, ub_ineqmore);
126         }
127         else if (M(eqbound, 0, 0) != EMPTY)
128         {
129             printf("inside lb_eqb \n");
130             myeqb = copy(myeqb, eqbound);
131         }
132     }
133
134     if (ineq_lb.cols > 1)
135     {
136         ineq_lb = subset(ineq_lb, 0, 1, ineq_lb.cols - 1);
137         ineq_ub = subset(ineq_ub, 0, 1, ineq_ub.cols - 1);
138     }
139     
140     if (myeqb.cols > 1)
141     {
142         myeqb = subset(myeqb, 0, 1, myeqb.cols - 1);
143     }
144     
145     for (i = 0; i < ineq_lb.cols; i++)
146     {
147         lb_ineq->t[i] = M(ineq_lb, i, 0);
148         ub_ineq->t[i] = M(ineq_ub, i, 0);
149         printf("pointer check \n");
150         printf("%2f", lb_ineq->t[i]); putchar('\n');
151         printf("%2f", ub_ineq->t[i]); putchar('\n');
152     }
153     printf("%d", myeqb.cols); putchar('\n');
154     
155     for (i = 0; i < myeqb.cols; i++)
156     {
157         eqb->t[i] = M(myeqb, i, 0);
158         printf("%2f", eqb->t[i]); putchar('\n');
159     }
160     
161     lb_ineq->cols = ineq_lb.cols;
162     ub_ineq->cols = ineq_ub.cols;
163     eqb->cols = myeqb.cols;
164     //printf("eqb is: \n");
165     //print(eqb); putchar('\n');
166
167 }