1 // Copyright (C) 2012 Massachusetts Institute of Technology, Lincoln Laboratory
2 // License: Boost Software License See LICENSE.txt for the full license.
3 // Authors: Davis E. King (davis@dlib.net)
4 #ifndef MIT_LL_CALL_MATLAB_H__
5 #define MIT_LL_CALL_MATLAB_H__
6
7 #include <string>
8 #include <sstream>
9 #include <dlib/error.h>
10 #include <dlib/assert.h>
11
12 namespace dlib
13 {
14
15 // ----------------------------------------------------------------------------------------
16
17 struct invalid_args_exception : error
18 {
19 /*!
20 WHAT THIS OBJECT REPRESENTS
21 This is the exception thrown when the mex wrapper tries to convert a matlab
22 object into a C++ object but for whatever reason can't (usually because the
23 types don't match).
24 !*/
invalid_args_exceptioninvalid_args_exception25 invalid_args_exception(const std::string& msg_): error(msg_) {}
invalid_args_exceptioninvalid_args_exception26 invalid_args_exception(const std::ostringstream& msg_): error(msg_.str()) {}
27 };
28
29 // ----------------------------------------------------------------------------------------
30
31 void check_for_matlab_ctrl_c();
32 /*!
33 ensures
34 - If the user of MATLAB has pressed ctrl+c then this function will throw an
35 exception.
36 !*/
37
38 // ----------------------------------------------------------------------------------------
39
40 class matlab_object
41 {
42 /*!
43 WHAT THIS OBJECT REPRESENTS
44 This object is a simple wrapper around matlab's generic mxArray, which is the
45 thing that is matlab's "anything object". So a matlab_object can be used as an
46 argument to a mex_function() that can bind to any matlab object at all. It can
47 also bind to "nothing" and so is inherently also an optional argument when
48 present in a mex_funciton().
49 !*/
50 public:
matlab_object()51 matlab_object() : handle(0),should_free(false),arg_idx(0) {}
52 matlab_object(const matlab_object&) = delete;
53
54 ~matlab_object();
55
56
57 // Check if a matlab object is bound to this object.
is_empty()58 bool is_empty() const { return handle==0; }
59 operator bool() const { return handle!=0; }
60
61 // Convert from MATLAB to C++, throw invalid_args_exception if not possible.
62 template <typename T> operator T() const;
63 template <typename T> void get(T& item) const;
64
65 // Convert from a C++ object to MATLAB
66 template <typename T> matlab_object& operator= (const T& new_val);
67
68
try_get(T & item)69 template <typename T> bool try_get(T& item) const
70 {
71 try { get(item); return true; }
72 catch(invalid_args_exception&) { return false; }
73 }
74
get_handle()75 const void* get_handle() const { return handle; }
76 /*!
77 ensures
78 - returns a pointer to the mxArray object. Might be NULL.
79 !*/
80
81
82 matlab_object& operator=(const matlab_object&) = delete;
83
84 // Users shouldn't call these functions
release_object_to_matlab()85 const void* release_object_to_matlab() { const void* temp=handle; handle = 0; return temp; }
set_object_handle(int arg_idx_,const void * sh)86 void set_object_handle(int arg_idx_, const void* sh) { DLIB_CASSERT(!handle); handle = sh; arg_idx=arg_idx_; }
87 private:
88
89 const void* handle;
90 bool should_free;
91 int arg_idx;
92 };
93
94 // ----------------------------------------------------------------------------------------
95
96 class matlab_struct
97 {
98 /*!
99 WHAT THIS OBJECT REPRESENTS
100 This object lets you interface with MATLAB structs from C++. For example,
101 given a MATLAB struct named mystruct, you could access it's fields like this:
102 MATLAB way: mystruct.field
103 C++ way: mystruct["field"]
104 MATLAB way: mystruct.field.subfield
105 C++ way: mystruct["field"]["subfield"]
106
107 To get the values as C++ types you do something like this:
108 int val = mystruct["field"];
109 or
110 int val;
111 mystruct["field"].get(val);
112
113 See also example_mex_struct.cpp for an example that uses this part of the API.
114 !*/
115
116 class sub;
117 public:
matlab_struct()118 matlab_struct() : struct_handle(0),should_free(false),arg_idx(0) {}
119 matlab_struct(const matlab_struct&) = delete;
120 ~matlab_struct();
121
122 const sub operator[] (const std::string& name) const;
123 sub operator[] (const std::string& name);
124 bool has_field(const std::string& name) const;
125
release_struct_to_matlab()126 const void* release_struct_to_matlab() { const void* temp=struct_handle; struct_handle = 0; return temp; }
set_struct_handle(int arg_idx_,const void * sh)127 void set_struct_handle(int arg_idx_, const void* sh) { DLIB_CASSERT(!struct_handle); struct_handle = sh; arg_idx=arg_idx_; }
128 private:
129
130 class sub
131 {
132 public:
sub()133 sub() : struct_handle(0), field_idx(-1) {}
134
135 template <typename T> operator T() const;
136 template <typename T> void get(T& item) const;
137 template <typename T> sub& operator= (const T& new_val);
138 const sub operator[] (const std::string& name) const;
139 sub operator[] (const std::string& name);
140 bool has_field(const std::string& name) const;
141 private:
142 friend class matlab_struct;
143 const void* struct_handle;
144 int field_idx;
145 sub& operator=(const sub&);
146 };
147 const void* struct_handle;
148 bool should_free;
149 int arg_idx;
150 matlab_struct& operator=(const matlab_struct&);
151 };
152
153 // ----------------------------------------------------------------------------------------
154 // ----------------------------------------------------------------------------------------
155
156 template <typename T>
157 struct output_decorator
158 {
output_decoratoroutput_decorator159 output_decorator(T& item_):item(item_){}
160 T& item;
161 };
162
163 template <typename T>
returns(T & item)164 output_decorator<T> returns(T& item) { return output_decorator<T>(item); }
165 /*!
166 ensures
167 - decorates item as an output type. This stuff is used by the call_matlab()
168 functions to tell if an argument is an input to the function or is supposed
169 to be bound to one of the return arguments.
170 !*/
171
172 // ----------------------------------------------------------------------------------------
173 // ----------------------------------------------------------------------------------------
174
175 struct function_handle
176 {
177 /*!
178 WHAT THIS OBJECT REPRESENTS
179 This type is used to represent function handles passed from MATLAB into a
180 mex function. You can call the function referenced by the handle by
181 saying:
182 call_matlab(my_handle);
183 !*/
184
185 // These two lines are just implementation details, ignore them.
function_handlefunction_handle186 function_handle():h(0){}
187 void* const h;
188 };
189
190 // ----------------------------------------------------------------------------------------
191 // ----------------------------------------------------------------------------------------
192
193 void call_matlab (
194 const std::string& function_name
195 );
196 /*!
197 ensures
198 - Calls MATLAB's function of the given name
199 !*/
200
201 // ----------------------------------------------------------------------------------------
202
203 void call_matlab (
204 const function_handle& funct
205 );
206 /*!
207 ensures
208 - Calls MATLAB's function represented by the handle funct
209 !*/
210
211 // ----------------------------------------------------------------------------------------
212
213 template <
214 typename T1
215 >
216 void call_matlab (
217 const std::string& function_name,
218 const T1& A1
219 );
220 /*!
221 ensures
222 - calls MATLAB's function of the given name.
223 - if (A1 is not decorated as an output by returns()) then
224 - A1 is passed as an argument into the MATLAB function
225 - else
226 - A1 is treated as the first return value from the MATLAB function.
227 !*/
228
229 template <
230 typename T1
231 >
call_matlab(const function_handle & funct,const T1 & A1)232 void call_matlab (
233 const function_handle& funct,
234 const T1& A1
235 ) { call_matlab("feval", funct, A1); }
236 /*!
237 ensures
238 - Calls MATLAB's function represented by the handle funct
239 - if (A1 is not decorated as an output by returns()) then
240 - A1 is passed as an argument into the MATLAB function
241 - else
242 - A1 is treated as the first return value from the MATLAB function.
243 !*/
244
245 // ----------------------------------------------------------------------------------------
246 // ----------------------------------------------------------------------------------------
247 /*
248 The rest of this file is just overloads of call_matlab() for up to 10 arguments (or
249 just 9 arguments if function_handle is used). They all do the same thing as the above
250 version of call_matlab(). Generally, any argument not decorated by returns() is an
251 input to the MATLAB function. On the other hand, all arguments decorated by returns()
252 are treated as outputs.
253 */
254 // ----------------------------------------------------------------------------------------
255
256 template <
257 typename T1,
258 typename T2
259 >
260 void call_matlab (
261 const std::string& function_name,
262 const T1& A1,
263 const T2& A2
264 );
265
266 // ----------------------------------------------------------------------------------------
267
268 template <
269 typename T1,
270 typename T2,
271 typename T3
272 >
273 void call_matlab (
274 const std::string& function_name,
275 const T1& A1,
276 const T2& A2,
277 const T3& A3
278 );
279
280 // ----------------------------------------------------------------------------------------
281
282 template <
283 typename T1,
284 typename T2,
285 typename T3,
286 typename T4
287 >
288 void call_matlab (
289 const std::string& function_name,
290 const T1& A1,
291 const T2& A2,
292 const T3& A3,
293 const T4& A4
294 );
295
296 // ----------------------------------------------------------------------------------------
297
298 template <
299 typename T1,
300 typename T2,
301 typename T3,
302 typename T4,
303 typename T5
304 >
305 void call_matlab (
306 const std::string& function_name,
307 const T1& A1,
308 const T2& A2,
309 const T3& A3,
310 const T4& A4,
311 const T5& A5
312 );
313
314 // ----------------------------------------------------------------------------------------
315
316 template <
317 typename T1,
318 typename T2,
319 typename T3,
320 typename T4,
321 typename T5,
322 typename T6
323 >
324 void call_matlab (
325 const std::string& function_name,
326 const T1& A1,
327 const T2& A2,
328 const T3& A3,
329 const T4& A4,
330 const T5& A5,
331 const T6& A6
332 );
333
334 // ----------------------------------------------------------------------------------------
335
336 template <
337 typename T1,
338 typename T2,
339 typename T3,
340 typename T4,
341 typename T5,
342 typename T6,
343 typename T7
344 >
345 void call_matlab (
346 const std::string& function_name,
347 const T1& A1,
348 const T2& A2,
349 const T3& A3,
350 const T4& A4,
351 const T5& A5,
352 const T6& A6,
353 const T7& A7
354 );
355
356 // ----------------------------------------------------------------------------------------
357
358 template <
359 typename T1,
360 typename T2,
361 typename T3,
362 typename T4,
363 typename T5,
364 typename T6,
365 typename T7,
366 typename T8
367 >
368 void call_matlab (
369 const std::string& function_name,
370 const T1& A1,
371 const T2& A2,
372 const T3& A3,
373 const T4& A4,
374 const T5& A5,
375 const T6& A6,
376 const T7& A7,
377 const T8& A8
378 );
379
380 // ----------------------------------------------------------------------------------------
381
382 template <
383 typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename
384 T7, typename T8, typename T9
385 >
386 void call_matlab (
387 const std::string& function_name,
388 const T1& A1, const T2& A2, const T3& A3, const T4& A4, const T5& A5, const T6& A6,
389 const T7& A7, const T8& A8, const T9& A9
390 );
391
392 // ----------------------------------------------------------------------------------------
393
394 template <
395 typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename
396 T7, typename T8, typename T9, typename T10
397 >
398 void call_matlab (
399 const std::string& function_name,
400 const T1& A1, const T2& A2, const T3& A3, const T4& A4, const T5& A5, const T6& A6,
401 const T7& A7, const T8& A8, const T9& A9, const T10& A10
402 );
403
404 // ----------------------------------------------------------------------------------------
405
406 template <
407 typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename
408 T7, typename T8, typename T9, typename T10, typename T11
409 >
410 void call_matlab (
411 const std::string& function_name,
412 const T1& A1, const T2& A2, const T3& A3, const T4& A4, const T5& A5, const T6& A6,
413 const T7& A7, const T8& A8, const T9& A9, const T10& A10, const T11& A11
414 );
415
416 // ----------------------------------------------------------------------------------------
417
418 template <
419 typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename
420 T7, typename T8, typename T9, typename T10, typename T11, typename T12
421 >
422 void call_matlab (
423 const std::string& function_name,
424 const T1& A1, const T2& A2, const T3& A3, const T4& A4, const T5& A5, const T6& A6,
425 const T7& A7, const T8& A8, const T9& A9, const T10& A10, const T11& A11, const T12& A12
426 );
427
428 // ----------------------------------------------------------------------------------------
429
430 template <
431 typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename
432 T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13
433 >
434 void call_matlab (
435 const std::string& function_name,
436 const T1& A1, const T2& A2, const T3& A3, const T4& A4, const T5& A5, const T6& A6,
437 const T7& A7, const T8& A8, const T9& A9, const T10& A10, const T11& A11, const T12&
438 A12, const T13& A13
439 );
440
441 // ----------------------------------------------------------------------------------------
442
443 template <
444 typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename
445 T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13,
446 typename T14
447 >
448 void call_matlab (
449 const std::string& function_name,
450 const T1& A1, const T2& A2, const T3& A3, const T4& A4, const T5& A5, const T6& A6,
451 const T7& A7, const T8& A8, const T9& A9, const T10& A10, const T11& A11, const T12&
452 A12, const T13& A13, const T14& A14
453 );
454
455 // ----------------------------------------------------------------------------------------
456
457 template <
458 typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename
459 T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13,
460 typename T14, typename T15
461 >
462 void call_matlab (
463 const std::string& function_name,
464 const T1& A1, const T2& A2, const T3& A3, const T4& A4, const T5& A5, const T6& A6,
465 const T7& A7, const T8& A8, const T9& A9, const T10& A10, const T11& A11, const T12&
466 A12, const T13& A13, const T14& A14, const T15& A15
467 );
468
469 // ----------------------------------------------------------------------------------------
470
471 template <
472 typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename
473 T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13,
474 typename T14, typename T15, typename T16
475 >
476 void call_matlab (
477 const std::string& function_name,
478 const T1& A1, const T2& A2, const T3& A3, const T4& A4, const T5& A5, const T6& A6,
479 const T7& A7, const T8& A8, const T9& A9, const T10& A10, const T11& A11, const T12&
480 A12, const T13& A13, const T14& A14, const T15& A15, const T16& A16
481 );
482
483 // ----------------------------------------------------------------------------------------
484
485 template <
486 typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename
487 T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13,
488 typename T14, typename T15, typename T16, typename T17
489 >
490 void call_matlab (
491 const std::string& function_name,
492 const T1& A1, const T2& A2, const T3& A3, const T4& A4, const T5& A5, const T6& A6,
493 const T7& A7, const T8& A8, const T9& A9, const T10& A10, const T11& A11, const T12&
494 A12, const T13& A13, const T14& A14, const T15& A15, const T16& A16, const T17& A17
495 );
496
497 // ----------------------------------------------------------------------------------------
498
499 template <
500 typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename
501 T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13,
502 typename T14, typename T15, typename T16, typename T17, typename T18
503 >
504 void call_matlab (
505 const std::string& function_name,
506 const T1& A1, const T2& A2, const T3& A3, const T4& A4, const T5& A5, const T6& A6,
507 const T7& A7, const T8& A8, const T9& A9, const T10& A10, const T11& A11, const T12&
508 A12, const T13& A13, const T14& A14, const T15& A15, const T16& A16, const T17& A17,
509 const T18& A18
510 );
511
512 // ----------------------------------------------------------------------------------------
513
514 template <
515 typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename
516 T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13,
517 typename T14, typename T15, typename T16, typename T17, typename T18, typename T19
518 >
519 void call_matlab (
520 const std::string& function_name,
521 const T1& A1, const T2& A2, const T3& A3, const T4& A4, const T5& A5, const T6& A6,
522 const T7& A7, const T8& A8, const T9& A9, const T10& A10, const T11& A11, const T12&
523 A12, const T13& A13, const T14& A14, const T15& A15, const T16& A16, const T17& A17,
524 const T18& A18, const T19& A19
525 );
526
527 // ----------------------------------------------------------------------------------------
528
529 template <
530 typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename
531 T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13,
532 typename T14, typename T15, typename T16, typename T17, typename T18, typename T19,
533 typename T20
534 >
535 void call_matlab (
536 const std::string& function_name,
537 const T1& A1, const T2& A2, const T3& A3, const T4& A4, const T5& A5, const T6& A6,
538 const T7& A7, const T8& A8, const T9& A9, const T10& A10, const T11& A11, const T12&
539 A12, const T13& A13, const T14& A14, const T15& A15, const T16& A16, const T17& A17,
540 const T18& A18, const T19& A19, const T20& A20
541 );
542
543 // ----------------------------------------------------------------------------------------
544 // ----------------------------------------------------------------------------------------
545 // ----------------------------------------------------------------------------------------
546 // ----------------------------------------------------------------------------------------
547
548 template <
549 typename T1,
550 typename T2
551 >
call_matlab(const function_handle & funct,const T1 & A1,const T2 & A2)552 void call_matlab (
553 const function_handle& funct,
554 const T1& A1,
555 const T2& A2
556 )
557 {
558 call_matlab("feval", funct, A1, A2);
559 }
560
561 template <
562 typename T1,
563 typename T2,
564 typename T3
565 >
call_matlab(const function_handle & funct,const T1 & A1,const T2 & A2,const T3 & A3)566 void call_matlab (
567 const function_handle& funct,
568 const T1& A1,
569 const T2& A2,
570 const T3& A3
571 )
572 {
573 call_matlab("feval", funct, A1, A2, A3);
574 }
575
576 template <
577 typename T1,
578 typename T2,
579 typename T3,
580 typename T4
581 >
call_matlab(const function_handle & funct,const T1 & A1,const T2 & A2,const T3 & A3,const T4 & A4)582 void call_matlab (
583 const function_handle& funct,
584 const T1& A1,
585 const T2& A2,
586 const T3& A3,
587 const T4& A4
588 )
589 {
590 call_matlab("feval", funct, A1, A2, A3, A4);
591 }
592
593 template <
594 typename T1,
595 typename T2,
596 typename T3,
597 typename T4,
598 typename T5
599 >
call_matlab(const function_handle & funct,const T1 & A1,const T2 & A2,const T3 & A3,const T4 & A4,const T5 & A5)600 void call_matlab (
601 const function_handle& funct,
602 const T1& A1,
603 const T2& A2,
604 const T3& A3,
605 const T4& A4,
606 const T5& A5
607 )
608 {
609 call_matlab("feval", funct, A1, A2, A3, A4, A5);
610 }
611
612 template <
613 typename T1,
614 typename T2,
615 typename T3,
616 typename T4,
617 typename T5,
618 typename T6
619 >
call_matlab(const function_handle & funct,const T1 & A1,const T2 & A2,const T3 & A3,const T4 & A4,const T5 & A5,const T6 & A6)620 void call_matlab (
621 const function_handle& funct,
622 const T1& A1,
623 const T2& A2,
624 const T3& A3,
625 const T4& A4,
626 const T5& A5,
627 const T6& A6
628 )
629 {
630 call_matlab("feval", funct, A1, A2, A3, A4, A5, A6);
631 }
632
633 template <
634 typename T1,
635 typename T2,
636 typename T3,
637 typename T4,
638 typename T5,
639 typename T6,
640 typename T7
641 >
call_matlab(const function_handle & funct,const T1 & A1,const T2 & A2,const T3 & A3,const T4 & A4,const T5 & A5,const T6 & A6,const T7 & A7)642 void call_matlab (
643 const function_handle& funct,
644 const T1& A1,
645 const T2& A2,
646 const T3& A3,
647 const T4& A4,
648 const T5& A5,
649 const T6& A6,
650 const T7& A7
651 )
652 {
653 call_matlab("feval", funct, A1, A2, A3, A4, A5, A6, A7);
654 }
655
656 template <
657 typename T1,
658 typename T2,
659 typename T3,
660 typename T4,
661 typename T5,
662 typename T6,
663 typename T7,
664 typename T8
665 >
call_matlab(const function_handle & funct,const T1 & A1,const T2 & A2,const T3 & A3,const T4 & A4,const T5 & A5,const T6 & A6,const T7 & A7,const T8 & A8)666 void call_matlab (
667 const function_handle& funct,
668 const T1& A1,
669 const T2& A2,
670 const T3& A3,
671 const T4& A4,
672 const T5& A5,
673 const T6& A6,
674 const T7& A7,
675 const T8& A8
676 )
677 {
678 call_matlab("feval", funct, A1, A2, A3, A4, A5, A6, A7, A8);
679 }
680
681 template <
682 typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename
683 T7, typename T8, typename T9
684 >
call_matlab(const function_handle & funct,const T1 & A1,const T2 & A2,const T3 & A3,const T4 & A4,const T5 & A5,const T6 & A6,const T7 & A7,const T8 & A8,const T9 & A9)685 void call_matlab (
686 const function_handle& funct,
687 const T1& A1, const T2& A2, const T3& A3, const T4& A4, const T5& A5, const T6& A6,
688 const T7& A7, const T8& A8, const T9& A9
689 )
690 {
691 call_matlab("feval", funct, A1, A2, A3, A4, A5, A6, A7, A8, A9);
692 }
693
694 template <
695 typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename
696 T7, typename T8, typename T9, typename T10
697 >
call_matlab(const function_handle & funct,const T1 & A1,const T2 & A2,const T3 & A3,const T4 & A4,const T5 & A5,const T6 & A6,const T7 & A7,const T8 & A8,const T9 & A9,const T10 & A10)698 void call_matlab (
699 const function_handle& funct,
700 const T1& A1, const T2& A2, const T3& A3, const T4& A4, const T5& A5, const T6& A6,
701 const T7& A7, const T8& A8, const T9& A9, const T10& A10
702 )
703 {
704 call_matlab("feval", funct, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10);
705 }
706
707 template <
708 typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename
709 T7, typename T8, typename T9, typename T10, typename T11
710 >
call_matlab(const function_handle & funct,const T1 & A1,const T2 & A2,const T3 & A3,const T4 & A4,const T5 & A5,const T6 & A6,const T7 & A7,const T8 & A8,const T9 & A9,const T10 & A10,const T11 & A11)711 void call_matlab (
712 const function_handle& funct,
713 const T1& A1, const T2& A2, const T3& A3, const T4& A4, const T5& A5, const T6& A6,
714 const T7& A7, const T8& A8, const T9& A9, const T10& A10, const T11& A11
715 )
716 {
717 call_matlab("feval", funct, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11);
718 }
719
720 template <
721 typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename
722 T7, typename T8, typename T9, typename T10, typename T11, typename T12
723 >
call_matlab(const function_handle & funct,const T1 & A1,const T2 & A2,const T3 & A3,const T4 & A4,const T5 & A5,const T6 & A6,const T7 & A7,const T8 & A8,const T9 & A9,const T10 & A10,const T11 & A11,const T12 & A12)724 void call_matlab (
725 const function_handle& funct,
726 const T1& A1, const T2& A2, const T3& A3, const T4& A4, const T5& A5, const T6& A6,
727 const T7& A7, const T8& A8, const T9& A9, const T10& A10, const T11& A11, const T12&
728 A12
729 )
730 {
731 call_matlab("feval", funct, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12);
732 }
733
734 template <
735 typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename
736 T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13
737 >
call_matlab(const function_handle & funct,const T1 & A1,const T2 & A2,const T3 & A3,const T4 & A4,const T5 & A5,const T6 & A6,const T7 & A7,const T8 & A8,const T9 & A9,const T10 & A10,const T11 & A11,const T12 & A12,const T13 & A13)738 void call_matlab (
739 const function_handle& funct,
740 const T1& A1, const T2& A2, const T3& A3, const T4& A4, const T5& A5, const T6& A6,
741 const T7& A7, const T8& A8, const T9& A9, const T10& A10, const T11& A11, const T12&
742 A12, const T13& A13
743 )
744 {
745 call_matlab("feval", funct, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13);
746 }
747
748 template <
749 typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename
750 T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13,
751 typename T14
752 >
call_matlab(const function_handle & funct,const T1 & A1,const T2 & A2,const T3 & A3,const T4 & A4,const T5 & A5,const T6 & A6,const T7 & A7,const T8 & A8,const T9 & A9,const T10 & A10,const T11 & A11,const T12 & A12,const T13 & A13,const T14 & A14)753 void call_matlab (
754 const function_handle& funct,
755 const T1& A1, const T2& A2, const T3& A3, const T4& A4, const T5& A5, const T6& A6,
756 const T7& A7, const T8& A8, const T9& A9, const T10& A10, const T11& A11, const T12&
757 A12, const T13& A13, const T14& A14
758 )
759 {
760 call_matlab("feval", funct, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14);
761 }
762
763 template <
764 typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename
765 T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13,
766 typename T14, typename T15
767 >
call_matlab(const function_handle & funct,const T1 & A1,const T2 & A2,const T3 & A3,const T4 & A4,const T5 & A5,const T6 & A6,const T7 & A7,const T8 & A8,const T9 & A9,const T10 & A10,const T11 & A11,const T12 & A12,const T13 & A13,const T14 & A14,const T15 & A15)768 void call_matlab (
769 const function_handle& funct,
770 const T1& A1, const T2& A2, const T3& A3, const T4& A4, const T5& A5, const T6& A6,
771 const T7& A7, const T8& A8, const T9& A9, const T10& A10, const T11& A11, const T12&
772 A12, const T13& A13, const T14& A14, const T15& A15
773 )
774 {
775 call_matlab("feval", funct, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15);
776 }
777
778 template <
779 typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename
780 T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13,
781 typename T14, typename T15, typename T16
782 >
call_matlab(const function_handle & funct,const T1 & A1,const T2 & A2,const T3 & A3,const T4 & A4,const T5 & A5,const T6 & A6,const T7 & A7,const T8 & A8,const T9 & A9,const T10 & A10,const T11 & A11,const T12 & A12,const T13 & A13,const T14 & A14,const T15 & A15,const T16 & A16)783 void call_matlab (
784 const function_handle& funct,
785 const T1& A1, const T2& A2, const T3& A3, const T4& A4, const T5& A5, const T6& A6,
786 const T7& A7, const T8& A8, const T9& A9, const T10& A10, const T11& A11, const T12&
787 A12, const T13& A13, const T14& A14, const T15& A15, const T16& A16
788 )
789 {
790 call_matlab("feval", funct, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16);
791 }
792
793 template <
794 typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename
795 T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13,
796 typename T14, typename T15, typename T16, typename T17
797 >
call_matlab(const function_handle & funct,const T1 & A1,const T2 & A2,const T3 & A3,const T4 & A4,const T5 & A5,const T6 & A6,const T7 & A7,const T8 & A8,const T9 & A9,const T10 & A10,const T11 & A11,const T12 & A12,const T13 & A13,const T14 & A14,const T15 & A15,const T16 & A16,const T17 & A17)798 void call_matlab (
799 const function_handle& funct,
800 const T1& A1, const T2& A2, const T3& A3, const T4& A4, const T5& A5, const T6& A6,
801 const T7& A7, const T8& A8, const T9& A9, const T10& A10, const T11& A11, const T12&
802 A12, const T13& A13, const T14& A14, const T15& A15, const T16& A16, const T17& A17
803 )
804 {
805 call_matlab("feval", funct, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17);
806 }
807
808 template <
809 typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename
810 T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13,
811 typename T14, typename T15, typename T16, typename T17, typename T18
812 >
call_matlab(const function_handle & funct,const T1 & A1,const T2 & A2,const T3 & A3,const T4 & A4,const T5 & A5,const T6 & A6,const T7 & A7,const T8 & A8,const T9 & A9,const T10 & A10,const T11 & A11,const T12 & A12,const T13 & A13,const T14 & A14,const T15 & A15,const T16 & A16,const T17 & A17,const T18 & A18)813 void call_matlab (
814 const function_handle& funct,
815 const T1& A1, const T2& A2, const T3& A3, const T4& A4, const T5& A5, const T6& A6,
816 const T7& A7, const T8& A8, const T9& A9, const T10& A10, const T11& A11, const T12&
817 A12, const T13& A13, const T14& A14, const T15& A15, const T16& A16, const T17& A17,
818 const T18& A18
819 )
820 {
821 call_matlab("feval", funct, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18);
822 }
823
824 template <
825 typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename
826 T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13,
827 typename T14, typename T15, typename T16, typename T17, typename T18, typename T19
828 >
call_matlab(const function_handle & funct,const T1 & A1,const T2 & A2,const T3 & A3,const T4 & A4,const T5 & A5,const T6 & A6,const T7 & A7,const T8 & A8,const T9 & A9,const T10 & A10,const T11 & A11,const T12 & A12,const T13 & A13,const T14 & A14,const T15 & A15,const T16 & A16,const T17 & A17,const T18 & A18,const T19 & A19)829 void call_matlab (
830 const function_handle& funct,
831 const T1& A1, const T2& A2, const T3& A3, const T4& A4, const T5& A5, const T6& A6,
832 const T7& A7, const T8& A8, const T9& A9, const T10& A10, const T11& A11, const T12&
833 A12, const T13& A13, const T14& A14, const T15& A15, const T16& A16, const T17& A17,
834 const T18& A18, const T19& A19
835 )
836 {
837 call_matlab("feval", funct, A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19);
838 }
839
840 // ----------------------------------------------------------------------------------------
841
842 // We define this function here so that, if you write some code that has check_for_matlab_ctrl_c()
843 // sprinkled throughout it you can still compile that code outside the mex wrapper
844 // environment and these calls will simply be no-ops.
845 #ifndef MATLAB_MEX_FILE
check_for_matlab_ctrl_c()846 inline void check_for_matlab_ctrl_c() {}
847 #endif
848
849 }
850
851 #endif // MIT_LL_CALL_MATLAB_H__
852
853