1 // c3.i -Swig interface
2 
3 %module c3
4 
5 %{
6     #define SWIG_FILE_WITH_INIT
7 
8     #include <Python.h>
9     #include "approximate.h"
10     #include "array.h"
11     #include "stringmanip.h"
12     #include "regress.h"
13     #include "learning_options.h"
14     #include "objective_functions.h"
15     #include "parameterization.h"
16     #include "superlearn.h"
17     #include "regress.h"
18     #include "c3_interface.h"
19     #include "diffusion.h"
20     #include "dmrg.h"
21     #include "dmrgprod.h"
22     #include "ft.h"
23     #include "indmanage.h"
24     #include "lib_clinalg.h"
25     #include "qmarray.h"
26     #include "quasimatrix.h"
27     /* #include "fft.h" */
28     #include "fapprox.h"
29     #include "functions.h"
30     #include "fwrap.h"
31     #include "hpoly.h"
32     #include "legtens.h"
33     #include "lib_funcs.h"
34     #include "linelm.h"
35     #include "kernels.h"
36     #include "monitoring.h"
37     #include "piecewisepoly.h"
38     #include "pivoting.h"
39     #include "polynomials.h"
40     #include "space.h"
41     #include "lib_linalg.h"
42     #include "linalg.h"
43     #include "matrix_util.h"
44     #include "lib_optimization.h"
45     #include "probability.h"
46     #include "lib_probability.h"
47     #include "optimization.h"
48     #include "quadrature.h"
49 
50     int c3py_wrapped_eval(size_t N, const double * x, double * out, void * args);
51     void fwrap_set_pyfunc(struct Fwrap *, PyObject *);
52 
53     typedef long unsigned int size_t;
54 %}
55 
56 
57 typedef long unsigned int size_t;
58 int c3py_wrapped_eval(size_t N, const double * x, double * out, void * args);
59 void fwrap_set_pyfunc(struct Fwrap *, PyObject *);
60 
61 
62 %include "numpy.i"
63 
64 %init %{
65     import_array();
66 %}
67 
68 %apply (int DIM1, double* IN_ARRAY1) {
69     (size_t len2, const double * ydata)
70 };
71 
72 %apply (int DIM1, double* IN_ARRAY1) {
73     (size_t len1, const double * xdata)
74 };
75 
76 %apply (int DIM1, double* IN_ARRAY1) {
77     (size_t len1, const double * evalnd_pt)
78 };
79 
80 %apply (int DIM1, double* INPLACE_ARRAY1) {
81     (size_t len2, double * evalnd_out)
82 };
83 
84 %apply (int DIM1, size_t* IN_ARRAY1) {
85     (size_t leni, const size_t * xi)
86 };
87 
88 
89 // Python Memory Management
90 %newobject function_train_alloc;
91 struct FunctionTrain * function_train_alloc(size_t);
92 %delobject function_train_free;
93 void function_train_free(struct FunctionTrain *);
94 
95 
96 // Modified Python Interface
97 %rename (ft_regress_run) my_ft_regress_run;
98 %exception my_ft_regress_run{
99     $action
100     if (PyErr_Occurred()) SWIG_fail;
101 }
102 %inline %{
my_ft_regress_run(struct FTRegress * ftr,struct c3Opt * opt,size_t len1,const double * xdata,size_t len2,const double * ydata)103     struct FunctionTrain * my_ft_regress_run(struct FTRegress * ftr ,struct c3Opt * opt ,size_t len1, const double* xdata, size_t len2, const double * ydata){
104         if (len1 != len2*ft_regress_get_dim(ftr)){
105             PyErr_Format(PyExc_ValueError,
106                          "Arrays of lengths (%zu,%zu) given",
107                          len1, len2);
108             return NULL;
109         }
110         return ft_regress_run(ftr,opt,len2,xdata,ydata);
111     }
112 %}
113 %ignore ft_regress_run;
114 
115 
116 %rename (cross_validate_init) my_cross_validate_init;
117 %exception my_cross_validate_init{
118     $action
119     if (PyErr_Occurred()) SWIG_fail;
120 }
121 %inline %{
my_cross_validate_init(size_t dim,size_t len1,const double * xdata,size_t len2,const double * ydata,size_t kfold,int verbose)122     struct CrossValidate * my_cross_validate_init(size_t dim, size_t len1, const double* xdata, size_t len2, const double * ydata,size_t kfold, int verbose){
123         if (len1 != len2*dim){
124             PyErr_Format(PyExc_ValueError,
125                          "Arrays of lengths (%zu,%zu) given",
126                          len1, len2);
127             return NULL;
128         }
129         return cross_validate_init(len2,dim,xdata,ydata,kfold,verbose);
130     }
131 %}
132 %ignore cross_validate_init;
133 
134 %rename (lin_elem_exp_aopts_alloc) my_lin_elem_exp_aopts_alloc;
135 %exception my_lin_elem_exp_aopts_alloc{
136     $action
137     if (PyErr_Occurred()) SWIG_fail;
138 }
139 %inline %{
my_lin_elem_exp_aopts_alloc(size_t len1,const double * evalnd_pt)140     struct LinElemExpAopts * my_lin_elem_exp_aopts_alloc(size_t len1, const double* evalnd_pt){
141 
142       struct LinElemExpAopts * lexp = lin_elem_exp_aopts_alloc(len1,(double*)evalnd_pt);
143       lin_elem_exp_aopts_set_nodes_copy(lexp,len1,evalnd_pt);
144       return lexp;
145     }
146 %}
147 %ignore lin_elem_exp_aopts_alloc;
148 
149 %rename (function_train_eval) my_function_train_eval;
150 %exception my_function_train_eval{
151     $action
152     if (PyErr_Occurred()) SWIG_fail;
153 }
154 %inline %{
my_function_train_eval(struct FunctionTrain * ft,size_t len1,const double * evalnd_pt)155     double my_function_train_eval(struct FunctionTrain * ft ,size_t len1, const double* evalnd_pt){
156         if (len1 != function_train_get_dim(ft)){
157             PyErr_Format(PyExc_ValueError,
158                          "Evaluation point has incorrect dimensions (%zu) instead of %zu",
159                          len1,function_train_get_dim(ft));
160             return 0.0;
161         }
162         return function_train_eval(ft,evalnd_pt);
163     }
164 %}
165 %ignore function_train_eval;
166 
167 %rename (function_train_gradient_eval) my_function_train_gradient_eval;
168 %exception my_function_train_gradient_eval{
169     $action
170     if (PyErr_Occurred()) SWIG_fail;
171 }
172 %inline %{
my_function_train_gradient_eval(struct FunctionTrain * ft,size_t len1,const double * evalnd_pt,size_t len2,double * evalnd_out)173     void my_function_train_gradient_eval(struct FunctionTrain * ft ,size_t len1, const double* evalnd_pt,
174                                          size_t len2, double * evalnd_out){
175         if (len1 != function_train_get_dim(ft)){
176             PyErr_Format(PyExc_ValueError,
177                          "Evaluation point has incorrect dimensions (%zu) instead of %zu",
178                          len1,function_train_get_dim(ft));
179         }
180         if (len1 != len2){
181             PyErr_Format(PyExc_ValueError,
182                          "Input and outputs must be the same size: currently they are (%zu,%zu)",
183                          len1,len2);
184         }
185 
186         function_train_gradient_eval(ft,evalnd_pt,evalnd_out);
187 
188     }
189 %}
190 %ignore function_train_gradient_eval;
191 
192 
193 %typemap(in) size_t * ranks {
194     if (!PyList_Check($input)) {
195         PyErr_SetString(PyExc_ValueError,"Expecting a list");
196         return NULL;
197     }
198     int size = PyList_Size($input);
199     $1 = (size_t *) malloc(size * sizeof(size_t));
200     for (int i = 0; i < size; i++){
201         PyObject *s = PyList_GetItem($input,i);
202         if (!PyInt_Check(s)) {
203             free($1);
204             PyErr_SetString(PyExc_ValueError, "List items must be integers");
205             return NULL;
206         }
207         $1[i] = PyInt_AsLong(s);
208     }
209  }
210 
211 %typemap(freearg) (size_t * ranks){
212     if ($1) free($1);
213 }
214 
215 %typemap(in) void * paramlist {
216     if (!PyList_Check($input)) {
217         PyErr_SetString(PyExc_ValueError,"Expecting a list");
218         return NULL;
219     }
220     int size = PyList_Size($input);
221 
222     PyObject *s = PyList_GetItem($input,0);
223     int is_size_t = 0;
224     if (PyInt_Check(s)){
225         is_size_t = 1;
226     }
227     else{
228         if (!PyFloat_Check(s)){
229             PyErr_SetString(PyExc_ValueError, "List items must be integers or floats");
230             return NULL;
231         }
232     }
233 
234     if (is_size_t == 1){
235         $1 = malloc(size * sizeof(size_t));
236     }
237     else{
238         $1 = malloc(size * sizeof(double));
239     }
240     for (int i = 0; i < size; i++){
241         PyObject *s = PyList_GetItem($input,i);
242         if (is_size_t == 1){
243             if (!PyInt_Check(s)) {
244                 free($1);
245                 PyErr_SetString(PyExc_ValueError, "List items must the same type");
246                 return NULL;
247             }
248             ((size_t *)$1)[i] = PyInt_AsLong(s);
249         }
250         else{
251             if (!PyFloat_Check(s)) {
252                 free($1);
253                 PyErr_SetString(PyExc_ValueError, "List items must be the same type");
254                 return NULL;
255             }
256             ((double *)$1)[i] = PyFloat_AsDouble(s);
257         }
258 
259     }
260  }
261 
262 %typemap(freearg) (void * paramlist){
263     if ($1) free($1);
264 }
265 
266 %typemap(in) double * onedx {
267     if (!PyList_Check($input)) {
268         PyErr_SetString(PyExc_ValueError,"Expecting a list");
269         return NULL;
270     }
271     int size = PyList_Size($input);
272     $1 = (double *) malloc(size * sizeof(double));
273     for (int i = 0; i < size; i++){
274         PyObject *s = PyList_GetItem($input,i);
275         if (!PyFloat_Check(s)) {
276             free($1);
277             PyErr_SetString(PyExc_ValueError, "List items must be floating point values");
278             return NULL;
279         }
280         $1[i] = PyFloat_AsDouble(s);
281     }
282 
283     /* printf("size = %d\n",size); */
284     /* printf("list_elem = "); */
285     /* for (int ii = 0; ii < size; ii++){ */
286     /*   printf("$1[%d] = %G\n",ii,$1[ii]); */
287     /* } */
288  }
289 
290 %typemap(freearg) (double * onedx){
291     if ($1) free($1);
292 }
293 
294 
295 /* %include "../../include/c3.h" */
296 
297 %include "../../src/lib_interface/approximate.h"
298 
299 %include "../../src/lib_array/array.h"
300 
301 %include "../../src/lib_stringmanip/stringmanip.h"
302 %include "../../src/lib_superlearn/regress.h"
303 %include "../../src/lib_superlearn/learning_options.h"
304 %include "../../src/lib_superlearn/objective_functions.h"
305 %include "../../src/lib_superlearn/parameterization.h"
306 %include "../../src/lib_superlearn/superlearn.h"
307 %include "../../src/lib_interface/c3_interface.h"
308 %include "../../src/lib_clinalg/diffusion.h"
309 %include "../../src/lib_clinalg/dmrg.h"
310 %include "../../src/lib_clinalg/dmrgprod.h"
311 %include "../../src/lib_clinalg/ft.h"
312 %include "../../src/lib_clinalg/indmanage.h"
313 %include "../../src/lib_clinalg/lib_clinalg.h"
314 %include "../../src/lib_clinalg/qmarray.h"
315 %include "../../src/lib_clinalg/quasimatrix.h"
316 /* %include "../../src/lib_fft/fft.h" */
317 %include "../../src/lib_funcs/fapprox.h"
318 %include "../../src/lib_funcs/functions.h"
319 %include "../../src/lib_funcs/fwrap.h"
320 %include "../../src/lib_funcs/hpoly.h"
321 %include "../../src/lib_funcs/legtens.h"
322 %include "../../src/lib_funcs/lib_funcs.h"
323 %include "../../src/lib_funcs/linelm.h"
324 %include "../../src/lib_funcs/kernels.h"
325 %include "../../src/lib_funcs/monitoring.h"
326 %include "../../src/lib_funcs/piecewisepoly.h"
327 %include "../../src/lib_funcs/pivoting.h"
328 %include "../../src/lib_funcs/polynomials.h"
329 %include "../../src/lib_funcs/space.h"
330 %include "../../src/lib_linalg/lib_linalg.h"
331 %include "../../src/lib_linalg/linalg.h"
332 %include "../../src/lib_linalg/matrix_util.h"
333 %include "../../src/lib_optimization/lib_optimization.h"
334 %include "../../src/lib_optimization/optimization.h"
335 %include "../../src/lib_probability/lib_probability.h"
336 %include "../../src/lib_probability/probability.h"
337 %include "../../src/lib_quadrature/quadrature.h"
338 
339 
340 
341