YAP 7.1.0
matlab.c
1/*************************************************************************
2* *
3* YAP Prolog *
4* *
5* Yap Prolog was developed at NCCUP - Universidade do Porto *
6* *
7* Copyright L.Damas, V.S.Costa and Universidade do Porto 1985-1997 *
8* *
9**************************************************************************
10* *
11* File: random.c *
12* Last rev: *
13* mods: *
14* comments: regular expression interpreter *
15* *
16*************************************************************************/
17
18#include "config.h"
19#include "YapInterface.h"
20#include <math.h>
21#include <string.h>
22#if defined(__MINGW32__) || _MSC_VER
23#include <windows.h>
24#endif
25
26#include <mex.h>
27#include <engine.h>
28#include <matrix.h>
29
30#define MAT_ACCESS(I,J,ROWS,COLS) ((I)+((J)*(ROWS)))
31
32#define BUFSIZE 512
33#define OBUFSIZE 2048
34
35void init_matlab(void);
36
37static YAP_Functor MatlabAddress;
38static Engine *Meng = NULL;
39
40static mxArray *
41matlab_getvar(YAP_Term t)
42{
43 return engGetVariable(Meng, YAP_AtomName(YAP_AtomOfTerm(t)));
44}
45
46static YAP_Term
47address2term(mxArray *mat)
48{
49 YAP_Term t[1];
50
51 t[0] = YAP_MkIntTerm((YAP_Int)mat);
52 return YAP_MkApplTerm(MatlabAddress,1,t);
53}
54
55static int
56cp_back(YAP_Term vart, mxArray *mat)
57{
58 if (!YAP_IsAtomTerm(vart)) {
59 return TRUE;
60 }
61 /* save back to matlab */
62 return !engPutVariable(Meng, YAP_AtomName(YAP_AtomOfTerm(vart)), mat);
63}
64
65static int
66p_startmatlab(void)
67{
68 char opts[BUFSIZE];
69 const char *ptr;
70 YAP_Term topts = YAP_ARG1;
71
72 if (Meng)
73 return TRUE;
74 if (YAP_IsAtomTerm(topts))
75 ptr = YAP_AtomName(YAP_AtomOfTerm(topts));
76 else
77 {
78 if (!YAP_StringToBuffer(topts,opts, BUFSIZE))
79 return YAP_Unify(YAP_ARG2, YAP_MkIntTerm(-1));
80 ptr = opts;
81 }
82 if (!strlen(ptr)) {
83 if (!(Meng = engOpen("\0"))) {
84 return YAP_Unify(YAP_ARG2, YAP_MkIntTerm(-2));
85 }
86 } else {
87 if (!(Meng = engOpen(ptr))) {
88 return YAP_Unify(YAP_ARG2, YAP_MkIntTerm(-2));
89 }
90 }
91 engOutputBuffer(Meng, NULL, 0);
92 return TRUE;
93}
94
95static int
96p_matlabon(void)
97{
98 return Meng != NULL;
99}
100
101static int
102p_closematlab(void)
103{
104 Engine *eng = Meng;
105
106 Meng = NULL;
107 if (Meng)
108 return engClose(eng);
109 else
110 return FALSE;
111}
112
113static int
114p_evalstring2(void)
115{
116 char com[BUFSIZE];
117 YAP_Term tcom = YAP_ARG1;
118 const char *comd;
119
120 if (YAP_IsAtomTerm(tcom))
121 comd = YAP_AtomName(YAP_AtomOfTerm(tcom));
122 else {
123 if (!YAP_StringToBuffer(tcom, com, BUFSIZE))
124 return YAP_Unify(YAP_ARG2, YAP_MkIntTerm(-1));
125 comd = com;
126 }
127 return !engEvalString(Meng, comd);
128}
129
130static int
131p_evalstring3(void)
132{
133 int out;
134 YAP_Term tcom = YAP_ARG1;
135 const char *comd;
136 char com[BUFSIZE];
137 char buf[OBUFSIZE];
138
139 buf[0] = '\0';
140 if (YAP_IsAtomTerm(tcom))
141 comd = YAP_AtomName(YAP_AtomOfTerm(tcom));
142 else {
143 if (!YAP_StringToBuffer(tcom, com, BUFSIZE))
144 return YAP_Unify(YAP_ARG2, YAP_MkIntTerm(-1));
145 comd = com;
146 }
147 engOutputBuffer(Meng, buf, OBUFSIZE);
148 out = !engEvalString(Meng, comd);
149 engOutputBuffer(Meng, NULL, 0);
150 return YAP_Unify(YAP_ARG2, YAP_BufferToString(buf));
151}
152
153static int
154p_create_cell_vector(void)
155{
156 mwSize dims[1];
157 mxArray *mat;
158
159 dims[0] = YAP_IntOfTerm(YAP_ARG1);
160 if (!(mat = mxCreateCellArray(1, dims)))
161 return FALSE;
162 if (YAP_IsAtomTerm(YAP_ARG2)) {
163 return !engPutVariable(Meng, YAP_AtomName(YAP_AtomOfTerm(YAP_ARG2)), mat);
164 }
165 return YAP_Unify(YAP_ARG2,address2term(mat));
166}
167
168static int
169p_create_cell_array(void)
170{
171 int rows, cols;
172 mxArray *mat;
173
174 rows = YAP_IntOfTerm(YAP_ARG1);
175 cols = YAP_IntOfTerm(YAP_ARG2);
176 if (!(mat = mxCreateCellMatrix(rows, cols)))
177 return FALSE;
178 if (YAP_IsAtomTerm(YAP_ARG3)) {
179 return !engPutVariable(Meng, YAP_AtomName(YAP_AtomOfTerm(YAP_ARG3)), mat);
180 }
181 return YAP_Unify(YAP_ARG3,address2term(mat));
182}
183
184static int
185p_create_double_vector(void)
186{
187 mwSize dims[1];
188 mxArray *mat;
189
190 dims[0] = YAP_IntOfTerm(YAP_ARG1);
191 if (!(mat = mxCreateNumericArray(1, dims, mxDOUBLE_CLASS, mxREAL)))
192 return FALSE;
193 if (YAP_IsAtomTerm(YAP_ARG2)) {
194 return !engPutVariable(Meng, YAP_AtomName(YAP_AtomOfTerm(YAP_ARG2)), mat);
195 }
196 return YAP_Unify(YAP_ARG2,address2term(mat));
197}
198
199static int
200p_create_double_array(void)
201{
202 int rows, cols;
203 mxArray *mat;
204
205 rows = YAP_IntOfTerm(YAP_ARG1);
206 cols = YAP_IntOfTerm(YAP_ARG2);
207 if (!(mat = mxCreateDoubleMatrix(rows, cols, mxREAL)))
208 return FALSE;
209 if (YAP_IsAtomTerm(YAP_ARG3)) {
210 return !engPutVariable(Meng, YAP_AtomName(YAP_AtomOfTerm(YAP_ARG3)), mat);
211 }
212 return YAP_Unify(YAP_ARG3,address2term(mat));
213}
214
215static int
216p_create_double_array3(void)
217{
218 mwSize dims[3];
219 mxArray *mat;
220
221 dims[0] = YAP_IntOfTerm(YAP_ARG1);
222 dims[1] = YAP_IntOfTerm(YAP_ARG2);
223 dims[2] = YAP_IntOfTerm(YAP_ARG3);
224 if (!(mat = mxCreateNumericArray(3, dims, mxDOUBLE_CLASS, mxREAL)))
225 return FALSE;
226 if (YAP_IsAtomTerm(YAP_ARG3)) {
227 return !engPutVariable(Meng, YAP_AtomName(YAP_AtomOfTerm(YAP_ARG4)), mat);
228 }
229 return YAP_Unify(YAP_ARG3,address2term(mat));
230}
231
232static int
233p_set_int_array(void)
234{
235 int rows, cols, i = 0, j = 0;
236 YAP_Int *input;
237 mxArray *mat;
238 YAP_Term tl = YAP_ARG4;
239
240 mat = matlab_getvar(YAP_ARG1);
241 rows = YAP_IntOfTerm(YAP_ARG2);
242 cols = YAP_IntOfTerm(YAP_ARG3);
243 input = (YAP_Int *)mxGetPr(mat);
244 /* copy ints to matrix. */
245 for (i = 0; i < rows*cols; i++) {
246 YAP_Term th;
247
248 if (!YAP_IsPairTerm(tl)) {
249 return FALSE;
250 }
251 th = YAP_HeadOfTerm(tl);
252 if (!YAP_IsIntTerm(th)) {
253 /* ERROR */
254 return FALSE;
255 }
256 input[MAT_ACCESS(i++,j,rows,cols)] = YAP_IntOfTerm(th);
257 if (i == rows) {
258 i = 0;
259 j++;
260 }
261 tl = YAP_TailOfTerm(tl);
262 }
263 if (YAP_IsAtomTerm(YAP_ARG4)) {
264 return !engPutVariable(Meng, YAP_AtomName(YAP_AtomOfTerm(YAP_ARG4)), mat);
265 }
266 return YAP_Unify(YAP_ARG4,address2term(mat));
267}
268
269static int
270p_set_float_array(void)
271{
272 int rows, cols, i = 0, j = 0;
273 double *input;
274 mxArray *mat;
275 YAP_Term tl = YAP_ARG3;
276
277 rows = YAP_IntOfTerm(YAP_ARG1);
278 cols = YAP_IntOfTerm(YAP_ARG2);
279 if (!(mat = mxCreateDoubleMatrix(rows, cols, mxREAL)))
280 return FALSE;
281 input = mxGetPr(mat);
282 /* copy ints to matrix. */
283 for (i = 0; i < rows; i++) {
284 for (j = 0; j < cols; j++) {
285 YAP_Term th;
286
287 if (!YAP_IsPairTerm(tl)) {
288 return FALSE;
289 }
290 th = YAP_HeadOfTerm(tl);
291 if (YAP_IsIntTerm(th)) {
292 input[MAT_ACCESS(i,j,rows,cols)] = YAP_IntOfTerm(th);
293 } else if (YAP_IsFloatTerm(th)) {
294 input[MAT_ACCESS(i,j,rows,cols)] = YAP_FloatOfTerm(th);
295 } else {
296 /* ERROR */
297 return FALSE;
298 }
299 tl = YAP_TailOfTerm(tl);
300 }
301 }
302 if (YAP_IsAtomTerm(YAP_ARG4)) {
303 return !engPutVariable(Meng, YAP_AtomName(YAP_AtomOfTerm(YAP_ARG4)), mat);
304 }
305 return YAP_Unify(YAP_ARG4,address2term(mat));
306}
307
308static int
309p_set_float_vector(void)
310{
311 mwSize len[1];
312 int i = 0;
313 double *input;
314 mxArray *mat;
315 YAP_Term tl = YAP_ARG2;
316
317 len[0] = YAP_IntOfTerm(YAP_ARG1);
318 if (!(mat = mxCreateNumericArray(1,len, mxDOUBLE_CLASS, mxREAL)))
319 return FALSE;
320 input = mxGetPr(mat);
321 /* copy ints to matrix. */
322 for (i = 0; i < len[0]; i++) {
323 YAP_Term th;
324
325 if (!YAP_IsPairTerm(tl)) {
326 return FALSE;
327 }
328 th = YAP_HeadOfTerm(tl);
329 if (YAP_IsIntTerm(th)) {
330 input[i] = YAP_IntOfTerm(th);
331 } else if (YAP_IsFloatTerm(th)) {
332 input[i] = YAP_FloatOfTerm(th);
333 } else {
334 /* ERROR */
335 return FALSE;
336 }
337 tl = YAP_TailOfTerm(tl);
338 }
339 if (YAP_IsAtomTerm(YAP_ARG3)) {
340 return !engPutVariable(Meng, YAP_AtomName(YAP_AtomOfTerm(YAP_ARG3)), mat);
341 }
342 return YAP_Unify(YAP_ARG3,address2term(mat));
343}
344
345static int
346p_set_int(void)
347{
348 int rows, cols, i, j;
349 YAP_Int *input;
350 mxArray *mat;
351
352 mat = matlab_getvar(YAP_ARG1);
353 i = YAP_IntOfTerm(YAP_ARG2);
354 j = YAP_IntOfTerm(YAP_ARG3);
355 input = (YAP_Int *)mxGetPr(mat);
356 rows = mxGetM(mat);
357 cols = mxGetN(mat);
358 input[MAT_ACCESS(i-1,j-1,rows,cols)] = YAP_IntOfTerm(YAP_ARG4);
359 return TRUE;
360}
361
362static int
363p_set_float(void)
364{
365 int rows, cols, i, j;
366 double *input;
367 mxArray *mat;
368 YAP_Term t = YAP_ARG4;
369
370 mat = matlab_getvar(YAP_ARG1);
371 i = YAP_IntOfTerm(YAP_ARG2);
372 j = YAP_IntOfTerm(YAP_ARG3);
373 input = mxGetPr(mat);
374 rows = mxGetM(mat);
375 cols = mxGetN(mat);
376 if (YAP_IsIntTerm(t))
377 input[MAT_ACCESS(i-1,j-1,rows,cols)] = YAP_IntOfTerm(t);
378 else
379 input[MAT_ACCESS(i-1,j-1,rows,cols)] = YAP_FloatOfTerm(t);
380 return TRUE;
381}
382
383/* this has to be done carefully because we all need to transpose the matrix */
384static YAP_Term
385cp_ints32(int ndims, int *dims, INT32_T *input, int factor, int base, YAP_Term t)
386{
387 int i;
388
389 if (ndims == 1)
390 for (i=dims[0]; i>0; i--) {
391 t = YAP_MkPairTerm(YAP_MkIntTerm(input[base+factor*(i-1)]),t);
392 }
393 else
394 for (i=dims[0]; i>0; i--) {
395 t = cp_ints32(ndims-1, dims+1, input, factor*dims[0], base+factor*(i-1),t);
396 }
397 return t;
398}
399
400static YAP_Term
401cp_ints64(int ndims, int *dims, INT64_T *input, int factor, int base, YAP_Term t)
402{
403 int i;
404
405 if (ndims == 1)
406 for (i=dims[0]; i>0; i--) {
407 t = YAP_MkPairTerm(YAP_MkIntTerm(input[base+factor*(i-1)]),t);
408 }
409 else
410 for (i=dims[0]; i>0; i--) {
411 t = cp_ints64(ndims-1, dims+1, input, factor*dims[0], base+factor*(i-1),t);
412 }
413 return t;
414}
415
416static YAP_Term
417cp_cells(int ndims, int *dims, mxArray *mat, int factor, int base, YAP_Term t)
418{
419 int i;
420
421 if (ndims == 1)
422 for (i=dims[0]; i>0; i--) {
423 t = YAP_MkPairTerm(YAP_MkIntTerm((YAP_Int)mxGetCell(mat,base+factor*(i-1))),t);
424 }
425 else
426 for (i=dims[0]; i>0; i--) {
427 t = cp_cells(ndims-1, dims+1, mat, factor*dims[0], base+factor*(i-1),t);
428 }
429 return t;
430}
431
432/* this has to be done carefully because we all need to transpose the matrix */
433static YAP_Term
434cp_floats(int ndims, int *dims, double *input, int factor, int base, YAP_Term t)
435{
436 int i;
437
438 if (ndims == 1)
439 for (i=dims[0]; i>0; i--) {
440 t = YAP_MkPairTerm(YAP_MkFloatTerm(input[base+factor*(i-1)]),t);
441 }
442 else
443 for (i=dims[0]; i>0; i--) {
444 t = cp_floats(ndims-1, dims+1, input, factor*dims[0], base+factor*(i-1),t);
445 }
446 return t;
447}
448
449
450static mxArray*
451get_array(YAP_Term ti)
452{
453 if (YAP_IsIntTerm(ti)) {
454 return mxCreateDoubleScalar(YAP_IntOfTerm(ti));
455 } else if (YAP_IsFloatTerm(ti)) {
456 return mxCreateDoubleScalar(YAP_FloatOfTerm(ti));
457 } else if (YAP_IsAtomTerm(ti)) {
458 return matlab_getvar(ti);
459 } else if (YAP_IsPairTerm(ti)) {
460 YAP_Term tv = YAP_HeadOfTerm(ti);
461 YAP_Term tf = YAP_TailOfTerm(ti);
462 const mxArray *mout;
463
464 if (!YAP_IsAtomTerm(tv)) {
465 char s[BUFSIZE];
466 if (!YAP_StringToBuffer(ti, s, BUFSIZE))
467 return FALSE;
468 return mxCreateString(s);
469 }
470 mout = matlab_getvar(tv);
471 if (!mout)
472 return FALSE;
473 if (YAP_IsIntTerm(tf)) {
474 return mxGetFieldByNumber(mout, 0, YAP_IntOfTerm(tf));
475 } else if (YAP_IsAtomTerm(tf)) {
476 const char *s=YAP_AtomName(YAP_AtomOfTerm(tf));
477 return mxGetField(mout, 0, s);
478 } else {
479 return NULL;
480 }
481 } else {
482 return (mxArray *)YAP_IntOfTerm(YAP_ArgOfTerm(1,ti));
483 }
484}
485
486static int
487p_get_variable(void)
488{
489 YAP_Term t;
490 mxArray *mat;
491 const mwSize *dims;
492 int ndims;
493
494 mat = get_array(YAP_ARG1);
495 if (!mat)
496 return FALSE;
497 dims = mxGetDimensions(mat);
498 ndims = mxGetNumberOfDimensions(mat);
499 if (mxIsInt32(mat)) {
500 INT32_T *input = (INT32_T *)mxGetPr(mat);
501 t = cp_ints32(ndims, (int *)dims, input, 1, 0, YAP_TermNil());
502 } else if (mxIsInt64(mat)) {
503 INT64_T *input = (INT64_T *)mxGetPr(mat);
504 t = cp_ints64(ndims, (int *)dims, input, 1, 0, YAP_TermNil());
505 } else if (mxIsInt32(mat) || mxIsInt64(mat) || mxIsCell(mat)) {
506 t = cp_cells(ndims, (int *)dims, mat, 1, 0, YAP_TermNil());
507 } else if (mxIsDouble(mat)) {
508 double *input = mxGetPr(mat);
509 t = cp_floats(ndims, (int *)dims, input, 1, 0, YAP_TermNil());
510 } else {
511 return FALSE;
512 }
513 return YAP_Unify(YAP_ARG2, t);
514}
515
516
517static int
518item1(YAP_Term tvar, YAP_Term titem, int off)
519{
520 mxArray *mat;
521 mat = get_array(tvar);
522 if (!mat)
523 return FALSE;
524 if (mxIsInt32(mat)) {
525 INT32_T *input = (INT32_T *)mxGetPr(mat);
526 if (YAP_IsIntTerm(titem)) {
527 input[off] = YAP_IntOfTerm(titem);
528 } else if (YAP_IsFloatTerm(titem)) {
529 input[off] = YAP_FloatOfTerm(titem);
530 } else if (YAP_IsVarTerm(titem)) {
531 return YAP_Unify(titem, YAP_MkIntTerm(input[off]));
532 } else
533 return FALSE;
534 } else if (mxIsInt64(mat)) {
535 INT64_T *input = (INT64_T *)mxGetPr(mat);
536 if (YAP_IsIntTerm(titem)) {
537 input[off] = YAP_IntOfTerm(titem);
538 } else if (YAP_IsFloatTerm(titem)) {
539 input[off] = YAP_FloatOfTerm(titem);
540 } else if (YAP_IsVarTerm(titem)) {
541 return YAP_Unify(titem, YAP_MkIntTerm(input[off]));
542 } else
543 return FALSE;
544 } else if (mxIsCell(mat)) {
545 if (YAP_IsVarTerm(titem)) {
546 return YAP_Unify(titem, YAP_MkIntTerm((YAP_Int)mxGetCell(mat,off)));
547 } else {
548 mxArray *mat2 = get_array(titem);
549 mxSetCell(mat,off, mat2);
550 }
551 } else if (mxIsDouble(mat)) {
552 double *input = mxGetPr(mat);
553 if (YAP_IsFloatTerm(titem)) {
554 input[off] = YAP_FloatOfTerm(titem);
555 } else if (YAP_IsIntTerm(titem)) {
556 input[off] = YAP_IntOfTerm(titem);
557 } else {
558 return YAP_Unify(titem, YAP_MkFloatTerm(input[off]));
559 }
560 } else
561 return FALSE;
562 return cp_back(tvar, mat);
563}
564
565static int
566p_item(void)
567{
568 YAP_Term titem;
569 int off = YAP_IntOfTerm(YAP_ARG2);
570
571 titem = YAP_ARG3;
572 return item1(YAP_ARG1,titem,off);
573}
574
575static int
576p_item_1(void)
577{
578 YAP_Term titem;
579 int off = YAP_IntOfTerm(YAP_ARG2)-1;
580
581 titem = YAP_ARG3;
582 return item1(YAP_ARG1,titem,off);
583}
584
585
586static int
587item2(YAP_Term tvar, YAP_Term titem, int offx, int offy)
588{
589 mxArray *mat;
590 int rows;
591 int cols;
592 int off;
593
594 mat = get_array(tvar);
595 rows = mxGetM(mat);
596 cols = mxGetN(mat);
597 off = MAT_ACCESS(offx,offy,rows,cols);
598 if (!mat)
599 return FALSE;
600 if (mxIsInt32(mat)) {
601 INT32_T *input = (INT32_T *)mxGetPr(mat);
602 if (YAP_IsIntTerm(titem)) {
603 input[off] = YAP_IntOfTerm(titem);
604 } else if (YAP_IsFloatTerm(titem)) {
605 input[off] = YAP_FloatOfTerm(titem);
606 } else if (YAP_IsVarTerm(titem)) {
607 return YAP_Unify(titem, YAP_MkIntTerm(input[off]));
608 } else
609 return FALSE;
610 } else if (mxIsInt64(mat)) {
611 INT64_T *input = (INT64_T *)mxGetPr(mat);
612 if (YAP_IsIntTerm(titem)) {
613 input[off] = YAP_IntOfTerm(titem);
614 } else if (YAP_IsFloatTerm(titem)) {
615 input[off] = YAP_FloatOfTerm(titem);
616 } else if (YAP_IsVarTerm(titem)) {
617 return YAP_Unify(titem, YAP_MkIntTerm(input[off]));
618 } else
619 return FALSE;
620 } else if (mxIsCell(mat)) {
621 if (YAP_IsVarTerm(titem)) {
622 return YAP_Unify(titem, YAP_MkIntTerm((YAP_Int)mxGetCell(mat,off)));
623 } else {
624 mxArray *mat2 = get_array(titem);
625 mxSetCell(mat,off, mat2);
626 }
627 } else if (mxIsDouble(mat)) {
628 double *input = mxGetPr(mat);
629 if (YAP_IsFloatTerm(titem)) {
630 input[off] = YAP_FloatOfTerm(titem);
631 } else if (YAP_IsIntTerm(titem)) {
632 input[off] = YAP_IntOfTerm(titem);
633 } else {
634 return YAP_Unify(titem, YAP_MkFloatTerm(input[off]));
635 }
636 } else
637 return FALSE;
638 return cp_back(tvar, mat);
639}
640
641static int
642p_item2(void)
643{
644 YAP_Term titem;
645 int x = YAP_IntOfTerm(YAP_ARG2);
646 int y = YAP_IntOfTerm(YAP_ARG3);
647
648 titem = YAP_ARG4;
649 return item2(YAP_ARG1,titem,x,y);
650}
651
652static int
653p_item2_1(void)
654{
655 YAP_Term titem;
656 int offx = YAP_IntOfTerm(YAP_ARG2)-1;
657 int offy = YAP_IntOfTerm(YAP_ARG3)-1;
658
659 titem = YAP_ARG4;
660 return item2(YAP_ARG1,titem,offx,offy);
661}
662
663static int
664p_call_matlab(void)
665{
666 YAP_Term tlength = YAP_ARG2,
667 tl = YAP_ARG3,
668 tname = YAP_ARG1,
669 tolength = YAP_ARG4,
670 tout = YAP_ARG5;
671 int i = 0;
672 mxArray *inps[50], *outs[50];
673 const char *name;
674 int olength = YAP_IntOfTerm(tolength);
675
676 if (!YAP_IsAtomTerm(tname))
677 return FALSE;
678 name = YAP_AtomName(YAP_AtomOfTerm(tname));
679 if (!YAP_IsIntTerm(tlength))
680 return FALSE;
681 while (YAP_IsPairTerm(tl)) {
682 inps[i] = get_array(YAP_HeadOfTerm(tl));
683 i++;
684 tl = YAP_TailOfTerm(tl);
685 }
686 if (mexCallMATLAB(olength, outs, i, inps, name))
687 return FALSE;
688 /* output arguments */
689 if (YAP_IsPairTerm(tout)) {
690 for (i=0; i<olength; i++) {
691 YAP_Term ti = YAP_HeadOfTerm(tout);
692 if (YAP_IsAtomTerm(ti)) {
693 return !engPutVariable(Meng, YAP_AtomName(YAP_AtomOfTerm(ti)), outs[i]);
694 } else {
695 return YAP_Unify(ti,address2term(outs[i]));
696 }
697 }
698 } else {
699 YAP_Term to = YAP_MkAtomTerm(YAP_LookupAtom("[]"));
700 for (i=olength; i>0; i--) {
701 to = YAP_MkPairTerm(address2term(outs[i-1]),to);
702 }
703 }
704 return TRUE;
705}
706
707static int
708p_create_cell_matrix_and_copy1(void)
709{
710 int rows, cols;
711 mxArray *mat;
712 YAP_Term tl = YAP_ARG3;
713
714 rows = YAP_IntOfTerm(YAP_ARG1);
715 cols = YAP_IntOfTerm(YAP_ARG2);
716 if (!(mat = mxCreateCellMatrix(rows, cols)))
717 return FALSE;
718 while (YAP_IsPairTerm(tl)) {
719 YAP_Term th = YAP_HeadOfTerm(tl);
720 int off = MAT_ACCESS(YAP_IntOfTerm(YAP_ArgOfTerm(1,th))-1,
721 YAP_IntOfTerm(YAP_ArgOfTerm(2,th))-1,
722 rows,cols);
723 mxArray *mat2 = get_array(YAP_ArgOfTerm(3,th));
724 mxSetCell(mat,off, mat2);
725 tl = YAP_TailOfTerm(tl);
726 }
727 if (YAP_IsAtomTerm(YAP_ARG4)) {
728 return !engPutVariable(Meng, YAP_AtomName(YAP_AtomOfTerm(YAP_ARG4)), mat);
729 }
730 return YAP_Unify(YAP_ARG4,address2term(mat));
731}
732
733void
734init_matlab(void)
735{
736 MatlabAddress = YAP_MkFunctor(YAP_LookupAtom("MATLAB"),1);
737 YAP_UserCPredicate("start_matlab", p_startmatlab, 1);
738 YAP_UserCPredicate("close_matlab", p_closematlab, 0);
739 YAP_UserCPredicate("matlab_on", p_matlabon, 0);
740 YAP_UserCPredicate("matlab_eval_string", p_evalstring2, 1);
741 YAP_UserCPredicate("matlab_eval_string", p_evalstring3, 2);
742 YAP_UserCPredicate("matlab_cells", p_create_cell_vector, 2);
743 YAP_UserCPredicate("matlab_cells", p_create_cell_array, 3);
744 YAP_UserCPredicate("matlab_initialized_cells", p_create_cell_matrix_and_copy1, 4);
745 YAP_UserCPredicate("matlab_zeros", p_create_double_vector, 2);
746 YAP_UserCPredicate("matlab_zeros", p_create_double_array, 3);
747 YAP_UserCPredicate("matlab_zeros", p_create_double_array3, 4);
748 YAP_UserCPredicate("matlab_int_array", p_set_int_array, 4);
749 YAP_UserCPredicate("matlab_vector", p_set_float_vector, 3);
750 YAP_UserCPredicate("matlab_matrix", p_set_float_array, 4);
751 YAP_UserCPredicate("matlab_set_int", p_set_int, 4);
752 YAP_UserCPredicate("matlab_set", p_set_float, 4);
753 YAP_UserCPredicate("matlab_get_variable", p_get_variable, 2);
754 YAP_UserCPredicate("matlab_item", p_item, 3);
755 YAP_UserCPredicate("matlab_item", p_item2, 4);
756 YAP_UserCPredicate("matlab_item1", p_item_1, 3);
757 YAP_UserCPredicate("matlab_item1", p_item2_1, 4);
758 YAP_UserCPredicate("matlab_call_matlab", p_call_matlab, 5);
759}
760
761#ifdef _WIN32
762
763int WINAPI win_matlab(HANDLE, DWORD, LPVOID);
764
765int WINAPI win_matlab(HANDLE hinst, DWORD reason, LPVOID reserved)
766{
767 switch (reason)
768 {
769 case DLL_PROCESS_ATTACH:
770 break;
771 case DLL_PROCESS_DETACH:
772 break;
773 case DLL_THREAD_ATTACH:
774 break;
775 case DLL_THREAD_DETACH:
776 break;
777 }
778 return 1;
779}
780#endif
781
YAP_StringToBuffer
X_API char * YAP_StringToBuffer(Term t, char *buf, unsigned int bufsize)
copy a string to a buffer, the buffer must have been malloced
Definition: c_interface.c:1362