1 
2 // File: index.xml
3 
4 // File: classcasadi_1_1Assertion.xml
5 
6 
7 // File: classcasadi_1_1BackwardDiff.xml
8 %feature("docstring")
9 casadi::FunctionInternal::instruction_constant(casadi_int k) const  "
10 
11 [INTERNAL]  Get the floating point output argument of an atomic operation.
12 
13 ";
14 
15 %feature("docstring")  casadi::FunctionInternal::index_out(const std::string
16 &name) const  "
17 
18 [INTERNAL]  Get output scheme index by name.
19 
20 ";
21 
22 %feature("docstring")  casadi::ProtoFunction::clear_mem() "
23 
24 [INTERNAL]  Clear all memory (called from destructor)
25 
26 ";
27 
28 %feature("docstring")  casadi::FunctionInternal::call_forward(const
29 std::vector< MX > &arg, const std::vector< MX > &res, const std::vector<
30 std::vector< MX > > &fseed, std::vector< std::vector< MX > > &fsens, bool
31 always_inline, bool never_inline) const  "
32 
33 [INTERNAL]  Forward mode AD, virtual functions overloaded in derived
34 classes.
35 
36 ";
37 
38 %feature("docstring")  casadi::FunctionInternal::call_forward(const
39 std::vector< SX > &arg, const std::vector< SX > &res, const std::vector<
40 std::vector< SX > > &fseed, std::vector< std::vector< SX > > &fsens, bool
41 always_inline, bool never_inline) const  "
42 
43 [INTERNAL]  Forward mode AD, virtual functions overloaded in derived
44 classes.
45 
46 ";
47 
48 %feature("docstring")  casadi::FunctionInternal::replace_res(const
49 std::vector< M > &res, casadi_int npar) const  "
50 
51 [INTERNAL]  Replace 0-by-0 outputs.
52 
53 ";
54 
55 %feature("docstring")  casadi::FunctionInternal::alloc(const Function &f,
56 bool persistent=false) "
57 
58 [INTERNAL]  Ensure work vectors long enough to evaluate function.
59 
60 ";
61 
62 %feature("docstring")  casadi::ProtoFunction::checkout() const  "
63 
64 [INTERNAL]  Checkout a memory object.
65 
66 ";
67 
68 %feature("docstring")  casadi::FunctionInternal::nz_out(const std::vector<
69 DM > &res) const  "
70 
71 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
72 
73 ";
74 
75 %feature("docstring")  casadi::FunctionInternal::nz_out(const std::vector<
76 double > &res) const  "
77 
78 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
79 
80 ";
81 
82 %feature("docstring")  casadi::FunctionInternal::matching_res(const
83 std::vector< M > &arg, casadi_int &npar) const  "
84 
85 [INTERNAL]  Check if output arguments that needs to be replaced.
86 
87 Raises errors
88 
89 Parameters:
90 -----------
91 
92 npar[in]:  normal usage: 1, disallow pararallel calls: -1
93 
94 npar:  max number of horizontal repetitions across all arguments (or -1)
95 
96 ";
97 
98 %feature("docstring")  casadi::FunctionInternal::slice(const std::string
99 &name, const std::vector< casadi_int > &order_in, const std::vector<
100 casadi_int > &order_out, const Dict &opts) const  "
101 
102 [INTERNAL]  returns a new function with a selection of inputs/outputs of the
103 original
104 
105 ";
106 
107 %feature("docstring")  casadi::ProtoFunction::format_time(char *buffer,
108 double time) const  "
109 
110 [INTERNAL]  Format time in a fixed width 8 format.
111 
112 ";
113 
114 %feature("docstring")  casadi::FunctionInternal::alloc_res(size_t sz_res,
115 bool persistent=false) "
116 
117 [INTERNAL]  Ensure required length of res field.
118 
119 ";
120 
121 %feature("docstring")  casadi::FunctionInternal::size1_out(casadi_int ind)
122 const  "
123 
124 [INTERNAL]  Input/output dimensions.
125 
126 ";
127 
128 %feature("docstring")  casadi::FunctionInternal::wrap() const  "
129 
130 [INTERNAL]  Wrap in an Function instance consisting of only one MX call.
131 
132 ";
133 
134 %feature("docstring")
135 casadi::FunctionInternal::codegen_incref(CodeGenerator &g) const  "
136 
137 [INTERNAL]  Codegen incref for dependencies.
138 
139 ";
140 
141 %feature("docstring")  casadi::FunctionInternal::getJacSparsity(casadi_int
142 iind, casadi_int oind, bool symmetric) const  "
143 
144 [INTERNAL]  Generate the sparsity of a Jacobian block.
145 
146 ";
147 
148 %feature("docstring")  casadi::FunctionInternal::alloc_w(size_t sz_w, bool
149 persistent=false) "
150 
151 [INTERNAL]  Ensure required length of w field.
152 
153 ";
154 
155 %feature("docstring")  casadi::FunctionInternal::eval_dm(const std::vector<
156 DM > &arg) const  "
157 
158 [INTERNAL]  Evaluate with DM matrices.
159 
160 ";
161 
162 %feature("docstring")  casadi::FiniteDiff::get_sparsity_out(casadi_int i)  "
163 
164 [INTERNAL]  Sparsities of function inputs and outputs.
165 
166 ";
167 
168 %feature("docstring")  casadi::FunctionInternal::get_reverse(casadi_int
169 nadj, const std::string &name, const std::vector< std::string > &inames,
170 const std::vector< std::string > &onames, const Dict &opts) const  "
171 
172 [INTERNAL]  Return function that calculates adjoint derivatives
173 reverse(nadj) returns a cached instance if available, and calls  Function
174 get_reverse(casadi_int nadj) if no cached version is available.
175 
176 ";
177 
178 %feature("docstring")  casadi::FiniteDiff::uses_output() const  "
179 
180 [INTERNAL]  Is the scheme using the (nondifferentiated) output?
181 
182 ";
183 
184 %feature("docstring")  casadi::FunctionInternal::info() const  "
185 
186 [INTERNAL]  Obtain information about function
187 
188 ";
189 
190 %feature("docstring")  casadi::FunctionInternal::has_sprev() const  "
191 
192 [INTERNAL]  Is the class able to propagate seeds through the algorithm?
193 
194 ";
195 
196 %feature("docstring")  casadi::BackwardDiff::class_name() const  "
197 
198 [INTERNAL]  Get type name.
199 
200 ";
201 
202 %feature("docstring")  casadi::FunctionInternal::all_scalar() const  "
203 
204 [INTERNAL]  Are all inputs and outputs scalar.
205 
206 ";
207 
208 %feature("docstring")  casadi::FunctionInternal::eval_sx(const SXElem **arg,
209 SXElem **res, casadi_int *iw, SXElem *w, void *mem) const  "
210 
211 [INTERNAL]  Evaluate with symbolic scalars.
212 
213 ";
214 
215 %feature("docstring")  casadi::ProtoFunction::alloc_mem() const  "
216 
217 [INTERNAL]  Create memory block.
218 
219 ";
220 
221 %feature("docstring")  casadi::FunctionInternal::has_jacobian() const  "
222 
223 [INTERNAL]  Return Jacobian of all input elements with respect to all output
224 elements.
225 
226 ";
227 
228 %feature("docstring")  casadi::FunctionInternal::symbolic_output(const
229 std::vector< MX > &arg) const  "
230 
231 [INTERNAL]  Get a vector of symbolic variables corresponding to the outputs.
232 
233 ";
234 
235 %feature("docstring")  casadi::FunctionInternal::jac() const  "
236 
237 [INTERNAL]  Return Jacobian of all input elements with respect to all output
238 elements.
239 
240 ";
241 
242 %feature("docstring")  casadi::FunctionInternal::dm_in(casadi_int ind) const
243 "
244 
245 [INTERNAL]  Get function input(s) and output(s)
246 
247 ";
248 
249 %feature("docstring")  casadi::FunctionInternal::dm_in() const  "
250 
251 [INTERNAL]  Get function input(s) and output(s)
252 
253 ";
254 
255 %feature("docstring")  casadi::FunctionInternal::disp(std::ostream &stream,
256 bool more) const  "
257 
258 [INTERNAL]  Display object.
259 
260 ";
261 
262 %feature("docstring")  casadi::FunctionInternal::is_diff_in(casadi_int i) "
263 
264 [INTERNAL] ";
265 
266 %feature("docstring")  casadi::FunctionInternal::jacobian_sparsity() const
267 "
268 
269 [INTERNAL]  Get Jacobian sparsity.
270 
271 ";
272 
273 %feature("docstring")  casadi::FunctionInternal::generate_options(bool
274 is_temp=false) const  "
275 
276 [INTERNAL]  Reconstruct options dict.
277 
278 ";
279 
280 %feature("docstring")  casadi::FunctionInternal::sparsity_out(casadi_int
281 ind) const  "
282 
283 [INTERNAL]  Input/output sparsity.
284 
285 ";
286 
287 %feature("docstring")  casadi::FunctionInternal::convert_arg(const
288 std::vector< M > &arg) const  "
289 
290 [INTERNAL]  Convert from/to input/output lists/map.
291 
292 ";
293 
294 %feature("docstring")  casadi::FunctionInternal::convert_arg(const std::map<
295 std::string, M > &arg) const  "
296 
297 [INTERNAL]  Convert from/to input/output lists/map.
298 
299 ";
300 
301 %feature("docstring")  casadi::FunctionInternal::jit_dependencies(const
302 std::string &fname) "
303 
304 [INTERNAL]  Jit dependencies.
305 
306 ";
307 
308 %feature("docstring")  casadi::FunctionInternal::mapsum_mx(const
309 std::vector< MX > &arg, const std::string &parallelization) "
310 
311 [INTERNAL]  Parallel evaluation.
312 
313 ";
314 
315 %feature("docstring")  casadi::ProtoFunction::init_mem(void *mem) const  "
316 
317 [INTERNAL]  Initalize memory block.
318 
319 ";
320 
321 %feature("docstring")  casadi::FunctionInternal::sz_arg() const  "
322 
323 [INTERNAL]  Get required length of arg field.
324 
325 ";
326 
327 %feature("docstring")  casadi::FunctionInternal::get_jacobian(const
328 std::string &name, const std::vector< std::string > &inames, const
329 std::vector< std::string > &onames, const Dict &opts) const  "
330 
331 [INTERNAL]  Return Jacobian of all input elements with respect to all output
332 elements.
333 
334 ";
335 
336 %feature("docstring")  casadi::ProtoFunction::release(int mem) const  "
337 
338 [INTERNAL]  Release a memory object.
339 
340 ";
341 
342 %feature("docstring")
343 casadi::FunctionInternal::jacobian_sparsity_filter(const Sparsity &sp) const
344 "
345 
346 [INTERNAL]  Filter out nonzeros in the full sparsity jacobian according to
347 is_diff_in/out.
348 
349 ";
350 
351 %feature("docstring")  casadi::FiniteDiff::get_name_out(casadi_int i)  "
352 
353 [INTERNAL]  Names of function input and outputs.
354 
355 ";
356 
357 %feature("docstring")
358 casadi::FunctionInternal::codegen_free_mem(CodeGenerator &g) const  "
359 
360 [INTERNAL]  Codegen for free_mem.
361 
362 ";
363 
364 %feature("docstring")  casadi::FunctionInternal::nz_in(const std::vector< DM
365 > &arg) const  "
366 
367 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
368 
369 ";
370 
371 %feature("docstring")  casadi::FunctionInternal::nz_in(const std::vector<
372 double > &arg) const  "
373 
374 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
375 
376 ";
377 
378 %feature("docstring")  casadi::FunctionInternal::check_mat(const Sparsity
379 &arg, const Sparsity &inp, casadi_int &npar) "
380 
381 [INTERNAL]  Helper function
382 
383 Parameters:
384 -----------
385 
386 npar[in]:  normal usage: 1, disallow pararallel calls: -1
387 
388 npar[out]:  required number of parallel calls (or -1)
389 
390 ";
391 
392 %feature("docstring")  casadi::FunctionInternal::check_res(const
393 std::vector< M > &res, casadi_int &npar) const  "
394 
395 [INTERNAL]  Check if output arguments have correct length and dimensions.
396 
397 Raises errors.
398 
399 Parameters:
400 -----------
401 
402 npar[in]:  normal usage: 1, disallow pararallel calls: -1
403 
404 npar:  max number of horizontal repetitions across all arguments (or -1)
405 
406 ";
407 
408 %feature("docstring")  casadi::FunctionInternal::is_diff_out(casadi_int i) "
409 
410 [INTERNAL] ";
411 
412 %feature("docstring")  casadi::FunctionInternal::free_sx() const  "
413 
414 [INTERNAL]  Get free variables (SX)
415 
416 ";
417 
418 %feature("docstring")  casadi::FiniteDiff::has_codegen() const  "
419 
420 [INTERNAL]  Is codegen supported?
421 
422 ";
423 
424 %feature("docstring")
425 casadi::FunctionInternal::instruction_output(casadi_int k) const  "
426 
427 [INTERNAL]  Get the (integer) output argument of an atomic operation.
428 
429 ";
430 
431 %feature("docstring")  casadi::FunctionInternal::size_out(casadi_int ind)
432 const  "
433 
434 [INTERNAL]  Input/output dimensions.
435 
436 ";
437 
438 %feature("docstring")  casadi::FunctionInternal::has_jacobian_sparsity()
439 const  "
440 
441 [INTERNAL]  Get Jacobian sparsity.
442 
443 ";
444 
445 %feature("docstring")  casadi::FunctionInternal::wrap_as_needed(const Dict
446 &opts) const  "
447 
448 [INTERNAL]  Wrap in an Function instance consisting of only one MX call.
449 
450 ";
451 
452 %feature("docstring")  casadi::FiniteDiff::get_sparsity_in(casadi_int i)  "
453 
454 [INTERNAL]  Sparsities of function inputs and outputs.
455 
456 ";
457 
458 %feature("docstring")
459 casadi::FunctionInternal::getJacSparsityHierarchicalSymm(casadi_int iind,
460 casadi_int oind) const  "
461 
462 [INTERNAL]  A flavor of getJacSparsity that does hierarchical block
463 structure recognition for symmetric Jacobians
464 
465 ";
466 
467 %feature("docstring")  casadi::FunctionInternal::has_function(const
468 std::string &fname) const  "
469 
470 [INTERNAL] ";
471 
472 %feature("docstring")  casadi::FunctionInternal::sz_iw() const  "
473 
474 [INTERNAL]  Get required length of iw field.
475 
476 ";
477 
478 %feature("docstring")  casadi::FunctionInternal::replace_arg(const
479 std::vector< M > &arg, casadi_int npar) const  "
480 
481 [INTERNAL]  Replace 0-by-0 inputs.
482 
483 ";
484 
485 %feature("docstring")
486 casadi::FunctionInternal::getJacSparsityHierarchical(casadi_int iind,
487 casadi_int oind) const  "
488 
489 [INTERNAL]  A flavor of getJacSparsity that does hierarchical block
490 structure recognition.
491 
492 ";
493 
494 %feature("docstring")
495 casadi::FunctionInternal::serialize_body(SerializingStream &s) const  "
496 
497 [INTERNAL]  Serialize an object without type information.
498 
499 ";
500 
501 %feature("docstring")  casadi::FunctionInternal::codegen(CodeGenerator &g,
502 const std::string &fname) const  "
503 
504 [INTERNAL]  Generate code the function.
505 
506 ";
507 
508 %feature("docstring")  casadi::FunctionInternal::size2_out(casadi_int ind)
509 const  "
510 
511 [INTERNAL]  Input/output dimensions.
512 
513 ";
514 
515 %feature("docstring")
516 casadi::FunctionInternal::getJacSparsityGen(casadi_int iind, casadi_int
517 oind, bool symmetric, casadi_int gr_i=1, casadi_int gr_o=1) const  "
518 
519 [INTERNAL]  Get the sparsity pattern, forward mode.
520 
521 ";
522 
523 %feature("docstring")  casadi::FiniteDiff::get_name_in(casadi_int i)  "
524 
525 [INTERNAL]  Names of function input and outputs.
526 
527 ";
528 
529 %feature("docstring")  casadi::FunctionInternal::replace_fseed(const
530 std::vector< std::vector< M >> &fseed, casadi_int npar) const  "
531 
532 [INTERNAL]  Replace 0-by-0 forward seeds.
533 
534 ";
535 
536 %feature("docstring")  casadi::FunctionInternal::replace_fseed(const
537 std::vector< std::vector< M > > &fseed, casadi_int npar) const  "
538 
539 [INTERNAL] ";
540 
541 %feature("docstring")  casadi::FunctionInternal::tocache(const Function &f,
542 const std::string &suffix="") const  "
543 
544 [INTERNAL]  Save function to cache.
545 
546 ";
547 
548 %feature("docstring")  casadi::FunctionInternal::factory(const std::string
549 &name, const std::vector< std::string > &s_in, const std::vector<
550 std::string > &s_out, const Function::AuxOut &aux, const Dict &opts) const
551 "
552 
553 [INTERNAL] ";
554 
555 %feature("docstring")  casadi::ProtoFunction::serialize(SerializingStream
556 &s) const  "
557 
558 [INTERNAL]  Serialize an object.
559 
560 ";
561 
562 %feature("docstring")  casadi::FunctionInternal::map(casadi_int n, const
563 std::string &parallelization) const  "
564 
565 [INTERNAL]  Generate/retrieve cached serial map.
566 
567 ";
568 
569 %feature("docstring")  casadi::FunctionInternal::set_work(void *mem, const
570 double **&arg, double **&res, casadi_int *&iw, double *&w) const  "
571 
572 [INTERNAL]  Set the (persistent) work vectors.
573 
574 ";
575 
576 %feature("docstring")  casadi::FunctionInternal::has_derivative() const  "
577 
578 [INTERNAL]  Can derivatives be calculated in any way?
579 
580 ";
581 
582 %feature("docstring")  casadi::FunctionInternal::eval_gen(const double
583 **arg, double **res, casadi_int *iw, double *w, void *mem) const  "
584 
585 [INTERNAL]  Evaluate numerically.
586 
587 ";
588 
589 %feature("docstring")  casadi::FunctionInternal::eval_gen(const SXElem
590 **arg, SXElem **res, casadi_int *iw, SXElem *w, void *mem) const  "
591 
592 [INTERNAL]  Evaluate a function, overloaded.
593 
594 ";
595 
596 %feature("docstring")  casadi::FunctionInternal::eval_gen(const bvec_t
597 **arg, bvec_t **res, casadi_int *iw, bvec_t *w, void *mem) const  "
598 
599 [INTERNAL]  Evaluate a function, overloaded.
600 
601 ";
602 
603 %feature("docstring")  casadi::FunctionInternal::n_instructions() const  "
604 
605 [INTERNAL]  Get the number of atomic operations.
606 
607 ";
608 
609 %feature("docstring")  casadi::FunctionInternal::jacobian() const  "
610 
611 [INTERNAL]  Return Jacobian of all input elements with respect to all output
612 elements.
613 
614 ";
615 
616 %feature("docstring")  casadi::FiniteDiff::codegen_body(CodeGenerator &g)
617 const  "
618 
619 [INTERNAL]  Generate code for the body of the C function.
620 
621 ";
622 
623 %feature("docstring")  casadi::FunctionInternal::sz_work(size_t &sz_arg,
624 size_t &sz_res, size_t &sz_iw, size_t &sz_w) const  "
625 
626 [INTERNAL]  Get number of temporary variables needed.
627 
628 ";
629 
630 %feature("docstring") casadi::BackwardDiff::BackwardDiff(const std::string
631 &name, casadi_int n) "
632 
633 [INTERNAL] ";
634 
635 %feature("docstring")  casadi::ForwardDiff::has_err() const  "
636 
637 [INTERNAL] ";
638 
639 %feature("docstring")  casadi::FunctionInternal::project_res(const
640 std::vector< M > &arg, casadi_int npar) const  "
641 
642 [INTERNAL]   Project sparsities.
643 
644 ";
645 
646 %feature("docstring")  casadi::FunctionInternal::oracle() const  "
647 
648 [INTERNAL]  Get oracle.
649 
650 ";
651 
652 %feature("docstring")  casadi::ProtoFunction::print(const char *fmt,...)
653 const  "
654 
655 [INTERNAL]  C-style formatted printing during evaluation.
656 
657 ";
658 
659 %feature("docstring")  casadi::FunctionInternal::sparsity_jac(casadi_int
660 iind, casadi_int oind, bool compact, bool symmetric) const  "
661 
662 [INTERNAL]  Get, if necessary generate, the sparsity of a Jacobian block.
663 
664 ";
665 
666 %feature("docstring")  casadi::FunctionInternal::sparsity_in(casadi_int ind)
667 const  "
668 
669 [INTERNAL]  Input/output sparsity.
670 
671 ";
672 
673 %feature("docstring")  casadi::FunctionInternal::has_reverse(casadi_int
674 nadj) const  "
675 
676 [INTERNAL]  Return function that calculates adjoint derivatives
677 reverse(nadj) returns a cached instance if available, and calls  Function
678 get_reverse(casadi_int nadj) if no cached version is available.
679 
680 ";
681 
682 %feature("docstring")  casadi::FunctionInternal::n_nodes() const  "
683 
684 [INTERNAL]  Number of nodes in the algorithm.
685 
686 ";
687 
688 %feature("docstring")  casadi::FunctionInternal::eval_mx(const MXVector
689 &arg, MXVector &res, bool always_inline, bool never_inline) const  "
690 
691 [INTERNAL]  Evaluate with symbolic matrices.
692 
693 ";
694 
695 %feature("docstring")  casadi::FunctionInternal::check_arg(const
696 std::vector< M > &arg, casadi_int &npar) const  "
697 
698 [INTERNAL]  Check if input arguments have correct length and dimensions.
699 
700 Raises errors.
701 
702 Parameters:
703 -----------
704 
705 npar[in]:  normal usage: 1, disallow pararallel calls: -1
706 
707 npar:  max number of horizontal repetitions across all arguments (or -1)
708 
709 ";
710 
711 %feature("docstring")  casadi::FunctionInternal::symbolicAdjSeed(casadi_int
712 nadj, const std::vector< MatType > &v) const  "
713 
714 [INTERNAL]  Symbolic expressions for the adjoint seeds.
715 
716 ";
717 
718 %feature("docstring")  casadi::FunctionInternal::matching_arg(const
719 std::vector< M > &arg, casadi_int &npar) const  "
720 
721 [INTERNAL]  Check if input arguments that needs to be replaced.
722 
723 Raises errors
724 
725 Parameters:
726 -----------
727 
728 npar[in]:  normal usage: 1, disallow pararallel calls: -1
729 
730 npar:  max number of horizontal repetitions across all arguments (or -1)
731 
732 ";
733 
734 %feature("docstring")  casadi::SharedObjectInternal::getCount() const  "
735 
736 [INTERNAL]  Get the reference count.
737 
738 ";
739 
740 %feature("docstring")  casadi::ForwardDiff::get_abstol() const  "
741 
742 [INTERNAL]  Get absolute tolerance.
743 
744 ";
745 
746 %feature("docstring")  casadi::FunctionInternal::fwd_seed(casadi_int nfwd)
747 const  "
748 
749 [INTERNAL]  Symbolic expressions for the forward seeds.
750 
751 ";
752 
753 %feature("docstring")  casadi::FunctionInternal::nnz_out() const  "
754 
755 [INTERNAL]  Number of input/output nonzeros.
756 
757 ";
758 
759 %feature("docstring")  casadi::FunctionInternal::nnz_out(casadi_int ind)
760 const  "
761 
762 [INTERNAL]  Number of input/output nonzeros.
763 
764 ";
765 
766 %feature("docstring")  casadi::ForwardDiff::calc_fd(double **yk, double *y0,
767 double *J, double h) const  "
768 
769 [INTERNAL] ";
770 
771 %feature("docstring")  casadi::ForwardDiff::calc_fd() const  "
772 
773 [INTERNAL] ";
774 
775 %feature("docstring")  casadi::FunctionInternal::dm_out(casadi_int ind)
776 const  "
777 
778 [INTERNAL]  Get function input(s) and output(s)
779 
780 ";
781 
782 %feature("docstring")  casadi::FunctionInternal::dm_out() const  "
783 
784 [INTERNAL]  Get function input(s) and output(s)
785 
786 ";
787 
788 %feature("docstring")  casadi::FunctionInternal::free_mx() const  "
789 
790 [INTERNAL]  Get free variables ( MX)
791 
792 ";
793 
794 %feature("docstring")  casadi::FunctionInternal::get_function() const  "
795 
796 [INTERNAL] ";
797 
798 %feature("docstring")  casadi::FunctionInternal::get_function(const
799 std::string &name) const  "
800 
801 [INTERNAL] ";
802 
803 %feature("docstring")  casadi::FunctionInternal::size1_in(casadi_int ind)
804 const  "
805 
806 [INTERNAL]  Input/output dimensions.
807 
808 ";
809 
810 %feature("docstring")  casadi::FunctionInternal::has_jac() const  "
811 
812 [INTERNAL]  Return Jacobian of all input elements with respect to all output
813 elements.
814 
815 ";
816 
817 %feature("docstring")  casadi::FunctionInternal::definition() const  "
818 
819 [INTERNAL]  Get function signature: name:(inputs)->(outputs)
820 
821 ";
822 
823 %feature("docstring")  casadi::FunctionInternal::adjViaJac(casadi_int nadj)
824 const  "
825 
826 [INTERNAL]  Calculate derivatives by multiplying the full Jacobian and
827 multiplying.
828 
829 ";
830 
831 %feature("docstring")  casadi::FunctionInternal::get_jacobian_sparsity()
832 const  "
833 
834 [INTERNAL]  Get Jacobian sparsity.
835 
836 ";
837 
838 %feature("docstring")  casadi::FunctionInternal::sp_reverse(bvec_t **arg,
839 bvec_t **res, casadi_int *iw, bvec_t *w, void *mem) const  "
840 
841 [INTERNAL]  Propagate sparsity backwards.
842 
843 ";
844 
845 %feature("docstring")  casadi::FunctionInternal::get_jac(const std::string
846 &name, const std::vector< std::string > &inames, const std::vector<
847 std::string > &onames, const Dict &opts) const  "
848 
849 [INTERNAL]  Return Jacobian of all input elements with respect to all output
850 elements.
851 
852 ";
853 
854 %feature("docstring")  casadi::FunctionInternal::instruction_id(casadi_int
855 k) const  "
856 
857 [INTERNAL]  Get an atomic operation operator index.
858 
859 ";
860 
861 %feature("docstring")  casadi::FunctionInternal::alloc_arg(size_t sz_arg,
862 bool persistent=false) "
863 
864 [INTERNAL]  Ensure required length of arg field.
865 
866 ";
867 
868 %feature("docstring")  casadi::ProtoFunction::print_time(const std::map<
869 std::string, FStats > &fstats) const  "
870 
871 [INTERNAL]  Print timing statistics.
872 
873 ";
874 
875 %feature("docstring")  casadi::FunctionInternal::get_reltol() const  "
876 
877 [INTERNAL]  Get relative tolerance.
878 
879 ";
880 
881 %feature("docstring")  casadi::FiniteDiff::get_default_in(casadi_int ind)
882 const  "
883 
884 [INTERNAL]  Get default input value.
885 
886 ";
887 
888 %feature("docstring")  casadi::FunctionInternal::numel_in() const  "
889 
890 [INTERNAL]  Number of input/output elements.
891 
892 ";
893 
894 %feature("docstring")  casadi::FunctionInternal::numel_in(casadi_int ind)
895 const  "
896 
897 [INTERNAL]  Number of input/output elements.
898 
899 ";
900 
901 %feature("docstring") casadi::BackwardDiff "
902 
903 [INTERNAL]  Calculate derivative using backward differences Joel Andersson
904 
905 >List of available options
906 
907 +------------------+-----------------+------------------+------------------+
908 |        Id        |      Type       |   Description    |     Used in      |
909 +==================+=================+==================+==================+
910 | abstol           | OT_DOUBLE       | Accuracy of      | casadi::Backward |
911 |                  |                 | function outputs | Diff             |
912 |                  |                 | [default: query  |                  |
913 |                  |                 | object]          |                  |
914 +------------------+-----------------+------------------+------------------+
915 | ad_weight        | OT_DOUBLE       | Weighting factor | casadi::Function |
916 |                  |                 | for derivative   | Internal         |
917 |                  |                 | calculation.When |                  |
918 |                  |                 | there is an      |                  |
919 |                  |                 | option of either |                  |
920 |                  |                 | using forward or |                  |
921 |                  |                 | reverse mode     |                  |
922 |                  |                 | directional      |                  |
923 |                  |                 | derivatives, the |                  |
924 |                  |                 | condition ad_wei |                  |
925 |                  |                 | ght*nf<=(1-ad_we |                  |
926 |                  |                 | ight)*na is used |                  |
927 |                  |                 | where nf and na  |                  |
928 |                  |                 | are estimates of |                  |
929 |                  |                 | the number of    |                  |
930 |                  |                 | forward/reverse  |                  |
931 |                  |                 | mode directional |                  |
932 |                  |                 | derivatives      |                  |
933 |                  |                 | needed. By       |                  |
934 |                  |                 | default,         |                  |
935 |                  |                 | ad_weight is     |                  |
936 |                  |                 | calculated       |                  |
937 |                  |                 | automatically,   |                  |
938 |                  |                 | but this can be  |                  |
939 |                  |                 | overridden by    |                  |
940 |                  |                 | setting this     |                  |
941 |                  |                 | option. In       |                  |
942 |                  |                 | particular, 0    |                  |
943 |                  |                 | means forcing    |                  |
944 |                  |                 | forward mode and |                  |
945 |                  |                 | 1 forcing        |                  |
946 |                  |                 | reverse mode.    |                  |
947 |                  |                 | Leave unset for  |                  |
948 |                  |                 | (class specific) |                  |
949 |                  |                 | heuristics.      |                  |
950 +------------------+-----------------+------------------+------------------+
951 | ad_weight_sp     | OT_DOUBLE       | Weighting factor | casadi::Function |
952 |                  |                 | for sparsity     | Internal         |
953 |                  |                 | pattern          |                  |
954 |                  |                 | calculation calc |                  |
955 |                  |                 | ulation.Override |                  |
956 |                  |                 | s default        |                  |
957 |                  |                 | behavior. Set to |                  |
958 |                  |                 | 0 and 1 to force |                  |
959 |                  |                 | forward and      |                  |
960 |                  |                 | reverse mode     |                  |
961 |                  |                 | respectively.    |                  |
962 |                  |                 | Cf. option       |                  |
963 |                  |                 | \"ad_weight\".     |                  |
964 |                  |                 | When set to -1,  |                  |
965 |                  |                 | sparsity is      |                  |
966 |                  |                 | completely       |                  |
967 |                  |                 | ignored and      |                  |
968 |                  |                 | dense matrices   |                  |
969 |                  |                 | are used.        |                  |
970 +------------------+-----------------+------------------+------------------+
971 | always_inline    | OT_BOOL         | Force inlining.  | casadi::Function |
972 |                  |                 |                  | Internal         |
973 +------------------+-----------------+------------------+------------------+
974 | compiler         | OT_STRING       | Just-in-time     | casadi::Function |
975 |                  |                 | compiler plugin  | Internal         |
976 |                  |                 | to be used.      |                  |
977 +------------------+-----------------+------------------+------------------+
978 | custom_jacobian  | OT_FUNCTION     | Override         | casadi::Function |
979 |                  |                 | CasADi's AD. Use | Internal         |
980 |                  |                 | together with    |                  |
981 |                  |                 | 'jac_penalty':   |                  |
982 |                  |                 | 0. Note: Highly  |                  |
983 |                  |                 | experimental.    |                  |
984 |                  |                 | Syntax may break |                  |
985 |                  |                 | often.           |                  |
986 +------------------+-----------------+------------------+------------------+
987 | derivative_of    | OT_FUNCTION     | The function is  | casadi::Function |
988 |                  |                 | a derivative of  | Internal         |
989 |                  |                 | another          |                  |
990 |                  |                 | function. The    |                  |
991 |                  |                 | type of          |                  |
992 |                  |                 | derivative       |                  |
993 |                  |                 | (directional     |                  |
994 |                  |                 | derivative,      |                  |
995 |                  |                 | Jacobian) is     |                  |
996 |                  |                 | inferred from    |                  |
997 |                  |                 | the function     |                  |
998 |                  |                 | name.            |                  |
999 +------------------+-----------------+------------------+------------------+
1000 | dump             | OT_BOOL         | Dump function to | casadi::Function |
1001 |                  |                 | file upon first  | Internal         |
1002 |                  |                 | evaluation.      |                  |
1003 |                  |                 | [false]          |                  |
1004 +------------------+-----------------+------------------+------------------+
1005 | dump_dir         | OT_STRING       | Directory to     | casadi::Function |
1006 |                  |                 | dump             | Internal         |
1007 |                  |                 | inputs/outputs   |                  |
1008 |                  |                 | to. Make sure    |                  |
1009 |                  |                 | the directory    |                  |
1010 |                  |                 | exists [.]       |                  |
1011 +------------------+-----------------+------------------+------------------+
1012 | dump_format      | OT_STRING       | Choose file      | casadi::Function |
1013 |                  |                 | format to dump   | Internal         |
1014 |                  |                 | matrices. See    |                  |
1015 |                  |                 | DM.from_file     |                  |
1016 |                  |                 | [mtx]            |                  |
1017 +------------------+-----------------+------------------+------------------+
1018 | dump_in          | OT_BOOL         | Dump numerical   | casadi::Function |
1019 |                  |                 | values of inputs | Internal         |
1020 |                  |                 | to file          |                  |
1021 |                  |                 | (readable with   |                  |
1022 |                  |                 | DM.from_file )   |                  |
1023 |                  |                 | [default: false] |                  |
1024 +------------------+-----------------+------------------+------------------+
1025 | dump_out         | OT_BOOL         | Dump numerical   | casadi::Function |
1026 |                  |                 | values of        | Internal         |
1027 |                  |                 | outputs to file  |                  |
1028 |                  |                 | (readable with   |                  |
1029 |                  |                 | DM.from_file )   |                  |
1030 |                  |                 | [default: false] |                  |
1031 +------------------+-----------------+------------------+------------------+
1032 | enable_fd        | OT_BOOL         | Enable           | casadi::Function |
1033 |                  |                 | derivative       | Internal         |
1034 |                  |                 | calculation by   |                  |
1035 |                  |                 | finite           |                  |
1036 |                  |                 | differencing.    |                  |
1037 |                  |                 | [default:        |                  |
1038 |                  |                 | false]]          |                  |
1039 +------------------+-----------------+------------------+------------------+
1040 | enable_forward   | OT_BOOL         | Enable           | casadi::Function |
1041 |                  |                 | derivative       | Internal         |
1042 |                  |                 | calculation      |                  |
1043 |                  |                 | using generated  |                  |
1044 |                  |                 | functions for    |                  |
1045 |                  |                 | Jacobian-times-  |                  |
1046 |                  |                 | vector products  |                  |
1047 |                  |                 | - typically      |                  |
1048 |                  |                 | using forward    |                  |
1049 |                  |                 | mode AD - if     |                  |
1050 |                  |                 | available.       |                  |
1051 |                  |                 | [default: true]  |                  |
1052 +------------------+-----------------+------------------+------------------+
1053 | enable_jacobian  | OT_BOOL         | Enable           | casadi::Function |
1054 |                  |                 | derivative       | Internal         |
1055 |                  |                 | calculation      |                  |
1056 |                  |                 | using generated  |                  |
1057 |                  |                 | functions for    |                  |
1058 |                  |                 | Jacobians of all |                  |
1059 |                  |                 | differentiable   |                  |
1060 |                  |                 | outputs with     |                  |
1061 |                  |                 | respect to all   |                  |
1062 |                  |                 | differentiable   |                  |
1063 |                  |                 | inputs - if      |                  |
1064 |                  |                 | available.       |                  |
1065 |                  |                 | [default: true]  |                  |
1066 +------------------+-----------------+------------------+------------------+
1067 | enable_reverse   | OT_BOOL         | Enable           | casadi::Function |
1068 |                  |                 | derivative       | Internal         |
1069 |                  |                 | calculation      |                  |
1070 |                  |                 | using generated  |                  |
1071 |                  |                 | functions for    |                  |
1072 |                  |                 | transposed       |                  |
1073 |                  |                 | Jacobian-times-  |                  |
1074 |                  |                 | vector products  |                  |
1075 |                  |                 | - typically      |                  |
1076 |                  |                 | using reverse    |                  |
1077 |                  |                 | mode AD - if     |                  |
1078 |                  |                 | available.       |                  |
1079 |                  |                 | [default: true]  |                  |
1080 +------------------+-----------------+------------------+------------------+
1081 | fd_method        | OT_STRING       | Method for       | casadi::Function |
1082 |                  |                 | finite           | Internal         |
1083 |                  |                 | differencing     |                  |
1084 |                  |                 | [default         |                  |
1085 |                  |                 | 'central']       |                  |
1086 +------------------+-----------------+------------------+------------------+
1087 | fd_options       | OT_DICT         | Options to be    | casadi::Function |
1088 |                  |                 | passed to the    | Internal         |
1089 |                  |                 | finite           |                  |
1090 |                  |                 | difference       |                  |
1091 |                  |                 | instance         |                  |
1092 +------------------+-----------------+------------------+------------------+
1093 | forward_options  | OT_DICT         | Options to be    | casadi::Function |
1094 |                  |                 | passed to a      | Internal         |
1095 |                  |                 | forward mode     |                  |
1096 |                  |                 | constructor      |                  |
1097 +------------------+-----------------+------------------+------------------+
1098 | gather_stats     | OT_BOOL         | Deprecated       | casadi::Function |
1099 |                  |                 | option           | Internal         |
1100 |                  |                 | (ignored):       |                  |
1101 |                  |                 | Statistics are   |                  |
1102 |                  |                 | now always       |                  |
1103 |                  |                 | collected.       |                  |
1104 +------------------+-----------------+------------------+------------------+
1105 | h                | OT_DOUBLE       | Step size        | casadi::Backward |
1106 |                  |                 | [default:        | Diff             |
1107 |                  |                 | computed from    |                  |
1108 |                  |                 | abstol]          |                  |
1109 +------------------+-----------------+------------------+------------------+
1110 | h_iter           | OT_INT          | Number of        | casadi::Backward |
1111 |                  |                 | iterations to    | Diff             |
1112 |                  |                 | improve on the   |                  |
1113 |                  |                 | step-size        |                  |
1114 |                  |                 | [default: 1 if   |                  |
1115 |                  |                 | error estimate   |                  |
1116 |                  |                 | available,       |                  |
1117 |                  |                 | otherwise 0]     |                  |
1118 +------------------+-----------------+------------------+------------------+
1119 | h_max            | OT_DOUBLE       | Maximum step     | casadi::Backward |
1120 |                  |                 | size [default 0] | Diff             |
1121 +------------------+-----------------+------------------+------------------+
1122 | h_min            | OT_DOUBLE       | Minimum step     | casadi::Backward |
1123 |                  |                 | size [default    | Diff             |
1124 |                  |                 | inf]             |                  |
1125 +------------------+-----------------+------------------+------------------+
1126 | input_scheme     | OT_STRINGVECTOR | Deprecated       | casadi::Function |
1127 |                  |                 | option (ignored) | Internal         |
1128 +------------------+-----------------+------------------+------------------+
1129 | inputs_check     | OT_BOOL         | Throw exceptions | casadi::Function |
1130 |                  |                 | when the         | Internal         |
1131 |                  |                 | numerical values |                  |
1132 |                  |                 | of the inputs    |                  |
1133 |                  |                 | don't make sense |                  |
1134 +------------------+-----------------+------------------+------------------+
1135 | is_diff_in       | OT_BOOLVECTOR   | Indicate for     | casadi::Function |
1136 |                  |                 | each input if it | Internal         |
1137 |                  |                 | should be        |                  |
1138 |                  |                 | differentiable.  |                  |
1139 +------------------+-----------------+------------------+------------------+
1140 | is_diff_out      | OT_BOOLVECTOR   | Indicate for     | casadi::Function |
1141 |                  |                 | each output if   | Internal         |
1142 |                  |                 | it should be     |                  |
1143 |                  |                 | differentiable.  |                  |
1144 +------------------+-----------------+------------------+------------------+
1145 | jac_penalty      | OT_DOUBLE       | When requested   | casadi::Function |
1146 |                  |                 | for a number of  | Internal         |
1147 |                  |                 | forward/reverse  |                  |
1148 |                  |                 | directions, it   |                  |
1149 |                  |                 | may be cheaper   |                  |
1150 |                  |                 | to compute first |                  |
1151 |                  |                 | the full         |                  |
1152 |                  |                 | jacobian and     |                  |
1153 |                  |                 | then multiply    |                  |
1154 |                  |                 | with seeds,      |                  |
1155 |                  |                 | rather than      |                  |
1156 |                  |                 | obtain the       |                  |
1157 |                  |                 | requested        |                  |
1158 |                  |                 | directions in a  |                  |
1159 |                  |                 | straightforward  |                  |
1160 |                  |                 | manner. Casadi   |                  |
1161 |                  |                 | uses a heuristic |                  |
1162 |                  |                 | to decide which  |                  |
1163 |                  |                 | is cheaper. A    |                  |
1164 |                  |                 | high value of    |                  |
1165 |                  |                 | 'jac_penalty'    |                  |
1166 |                  |                 | makes it less    |                  |
1167 |                  |                 | likely for the   |                  |
1168 |                  |                 | heurstic to      |                  |
1169 |                  |                 | chose the full   |                  |
1170 |                  |                 | Jacobian         |                  |
1171 |                  |                 | strategy. The    |                  |
1172 |                  |                 | special value -1 |                  |
1173 |                  |                 | indicates never  |                  |
1174 |                  |                 | to use the full  |                  |
1175 |                  |                 | Jacobian         |                  |
1176 |                  |                 | strategy         |                  |
1177 +------------------+-----------------+------------------+------------------+
1178 | jit              | OT_BOOL         | Use just-in-time | casadi::Function |
1179 |                  |                 | compiler to      | Internal         |
1180 |                  |                 | speed up the     |                  |
1181 |                  |                 | evaluation       |                  |
1182 +------------------+-----------------+------------------+------------------+
1183 | jit_cleanup      | OT_BOOL         | Cleanup up the   | casadi::Function |
1184 |                  |                 | temporary source | Internal         |
1185 |                  |                 | file that jit    |                  |
1186 |                  |                 | creates.         |                  |
1187 |                  |                 | Default: true    |                  |
1188 +------------------+-----------------+------------------+------------------+
1189 | jit_name         | OT_STRING       | The file name    | casadi::Function |
1190 |                  |                 | used to write    | Internal         |
1191 |                  |                 | out code. The    |                  |
1192 |                  |                 | actual file      |                  |
1193 |                  |                 | names used       |                  |
1194 |                  |                 | depend on 'jit_t |                  |
1195 |                  |                 | emp_suffix' and  |                  |
1196 |                  |                 | include          |                  |
1197 |                  |                 | extensions.      |                  |
1198 |                  |                 | Default:         |                  |
1199 |                  |                 | 'jit_tmp'        |                  |
1200 +------------------+-----------------+------------------+------------------+
1201 | jit_options      | OT_DICT         | Options to be    | casadi::Function |
1202 |                  |                 | passed to the    | Internal         |
1203 |                  |                 | jit compiler.    |                  |
1204 +------------------+-----------------+------------------+------------------+
1205 | jit_serialize    | OT_STRING       | Specify          | casadi::Function |
1206 |                  |                 | behaviour when   | Internal         |
1207 |                  |                 | serializing a    |                  |
1208 |                  |                 | jitted function: |                  |
1209 |                  |                 | SOURCE|link|embe |                  |
1210 |                  |                 | d.               |                  |
1211 +------------------+-----------------+------------------+------------------+
1212 | jit_temp_suffix  | OT_BOOL         | Use a temporary  | casadi::Function |
1213 |                  |                 | (seemingly       | Internal         |
1214 |                  |                 | random) filename |                  |
1215 |                  |                 | suffix for       |                  |
1216 |                  |                 | generated code   |                  |
1217 |                  |                 | and libraries.   |                  |
1218 |                  |                 | This is desired  |                  |
1219 |                  |                 | for thread-      |                  |
1220 |                  |                 | safety. This     |                  |
1221 |                  |                 | behaviour may    |                  |
1222 |                  |                 | defeat caching   |                  |
1223 |                  |                 | compiler         |                  |
1224 |                  |                 | wrappers.        |                  |
1225 |                  |                 | Default: true    |                  |
1226 +------------------+-----------------+------------------+------------------+
1227 | max_num_dir      | OT_INT          | Specify the      | casadi::Function |
1228 |                  |                 | maximum number   | Internal         |
1229 |                  |                 | of directions    |                  |
1230 |                  |                 | for derivative   |                  |
1231 |                  |                 | functions.       |                  |
1232 |                  |                 | Overrules the    |                  |
1233 |                  |                 | builtin optimize |                  |
1234 |                  |                 | d_num_dir.       |                  |
1235 +------------------+-----------------+------------------+------------------+
1236 | never_inline     | OT_BOOL         | Forbid inlining. | casadi::Function |
1237 |                  |                 |                  | Internal         |
1238 +------------------+-----------------+------------------+------------------+
1239 | output_scheme    | OT_STRINGVECTOR | Deprecated       | casadi::Function |
1240 |                  |                 | option (ignored) | Internal         |
1241 +------------------+-----------------+------------------+------------------+
1242 | print_in         | OT_BOOL         | Print numerical  | casadi::Function |
1243 |                  |                 | values of inputs | Internal         |
1244 |                  |                 | [default: false] |                  |
1245 +------------------+-----------------+------------------+------------------+
1246 | print_out        | OT_BOOL         | Print numerical  | casadi::Function |
1247 |                  |                 | values of        | Internal         |
1248 |                  |                 | outputs          |                  |
1249 |                  |                 | [default: false] |                  |
1250 +------------------+-----------------+------------------+------------------+
1251 | print_time       | OT_BOOL         | print            | casadi::Function |
1252 |                  |                 | information      | Internal         |
1253 |                  |                 | about execution  |                  |
1254 |                  |                 | time. Implies    |                  |
1255 |                  |                 | record_time.     |                  |
1256 +------------------+-----------------+------------------+------------------+
1257 | record_time      | OT_BOOL         | record           | casadi::Function |
1258 |                  |                 | information      | Internal         |
1259 |                  |                 | about execution  |                  |
1260 |                  |                 | time, for        |                  |
1261 |                  |                 | retrieval with   |                  |
1262 |                  |                 | stats().         |                  |
1263 +------------------+-----------------+------------------+------------------+
1264 | regularity_check | OT_BOOL         | Throw exceptions | casadi::Function |
1265 |                  |                 | when NaN or Inf  | Internal         |
1266 |                  |                 | appears during   |                  |
1267 |                  |                 | evaluation       |                  |
1268 +------------------+-----------------+------------------+------------------+
1269 | reltol           | OT_DOUBLE       | Accuracy of      | casadi::Backward |
1270 |                  |                 | function inputs  | Diff             |
1271 |                  |                 | [default: query  |                  |
1272 |                  |                 | object]          |                  |
1273 +------------------+-----------------+------------------+------------------+
1274 | reverse_options  | OT_DICT         | Options to be    | casadi::Function |
1275 |                  |                 | passed to a      | Internal         |
1276 |                  |                 | reverse mode     |                  |
1277 |                  |                 | constructor      |                  |
1278 +------------------+-----------------+------------------+------------------+
1279 | second_order_ste | OT_DOUBLE       | Second order     | casadi::Backward |
1280 | psize            |                 | perturbation     | Diff             |
1281 |                  |                 | size [default:   |                  |
1282 |                  |                 | 1e-3]            |                  |
1283 +------------------+-----------------+------------------+------------------+
1284 | smoothing        | OT_DOUBLE       | Smoothing        | casadi::Backward |
1285 |                  |                 | regularization   | Diff             |
1286 |                  |                 | [default:        |                  |
1287 |                  |                 | machine          |                  |
1288 |                  |                 | precision]       |                  |
1289 +------------------+-----------------+------------------+------------------+
1290 | u_aim            | OT_DOUBLE       | Target ratio of  | casadi::Backward |
1291 |                  |                 | roundoff error   | Diff             |
1292 |                  |                 | to truncation    |                  |
1293 |                  |                 | error [default:  |                  |
1294 |                  |                 | 100.]            |                  |
1295 +------------------+-----------------+------------------+------------------+
1296 | user_data        | OT_VOIDPTR      | A user-defined   | casadi::Function |
1297 |                  |                 | field that can   | Internal         |
1298 |                  |                 | be used to       |                  |
1299 |                  |                 | identify the     |                  |
1300 |                  |                 | function or pass |                  |
1301 |                  |                 | additional       |                  |
1302 |                  |                 | information      |                  |
1303 +------------------+-----------------+------------------+------------------+
1304 | verbose          | OT_BOOL         | Verbose          | casadi::Function |
1305 |                  |                 | evaluation  for  | Internal         |
1306 |                  |                 | debugging        |                  |
1307 +------------------+-----------------+------------------+------------------+
1308 
1309 Diagrams
1310 --------
1311 
1312 
1313 
1314 C++ includes: finite_differences.hpp ";
1315 
1316 %feature("docstring")  casadi::FunctionInternal::call_reverse(const
1317 std::vector< MX > &arg, const std::vector< MX > &res, const std::vector<
1318 std::vector< MX > > &aseed, std::vector< std::vector< MX > > &asens, bool
1319 always_inline, bool never_inline) const  "
1320 
1321 [INTERNAL]  Reverse mode, virtual functions overloaded in derived classes.
1322 
1323 ";
1324 
1325 %feature("docstring")  casadi::FunctionInternal::call_reverse(const
1326 std::vector< SX > &arg, const std::vector< SX > &res, const std::vector<
1327 std::vector< SX > > &aseed, std::vector< std::vector< SX > > &asens, bool
1328 always_inline, bool never_inline) const  "
1329 
1330 [INTERNAL]  Reverse mode, virtual functions overloaded in derived classes.
1331 
1332 ";
1333 
1334 %feature("docstring")  casadi::FunctionInternal::call(const std::vector< M >
1335 &arg, std::vector< M > &res, bool always_inline, bool never_inline) const  "
1336 
1337 [INTERNAL]   Call a function, templated.
1338 
1339 ";
1340 
1341 %feature("docstring")  casadi::FunctionInternal::call_gen(const MXVector
1342 &arg, MXVector &res, casadi_int npar, bool always_inline, bool never_inline)
1343 const  "
1344 
1345 [INTERNAL]   Call a function, overloaded.
1346 
1347 ";
1348 
1349 %feature("docstring")  casadi::FunctionInternal::call_gen(const std::vector<
1350 MatrixCommon > &arg, std::vector< MatrixCommon > &res, casadi_int npar, bool
1351 always_inline, bool never_inline) const  "
1352 
1353 [INTERNAL]   Call a function, overloaded.
1354 
1355 ";
1356 
1357 %feature("docstring")  casadi::FunctionInternal::project_arg(const
1358 std::vector< M > &arg, casadi_int npar) const  "
1359 
1360 [INTERNAL]   Project sparsities.
1361 
1362 ";
1363 
1364 %feature("docstring")  casadi::FiniteDiff::init(const Dict &opts)  "
1365 
1366 [INTERNAL]  Initialize.
1367 
1368 ";
1369 
1370 %feature("docstring")  casadi::FunctionInternal::which_depends(const
1371 std::string &s_in, const std::vector< std::string > &s_out, casadi_int
1372 order, bool tr=false) const  "
1373 
1374 [INTERNAL]  Which variables enter with some order.
1375 
1376 Parameters:
1377 -----------
1378 
1379 s_in:   Input name
1380 
1381 s_out:   Output name(s)
1382 
1383 order:  Only 1 (linear) and 2 (nonlinear) allowed
1384 
1385 tr:  Flip the relationship. Return which expressions contain the variables
1386 
1387 ";
1388 
1389 %feature("docstring")  casadi::FunctionInternal::size2_in(casadi_int ind)
1390 const  "
1391 
1392 [INTERNAL]  Input/output dimensions.
1393 
1394 ";
1395 
1396 %feature("docstring")  casadi::ProtoFunction::construct(const Dict &opts) "
1397 
1398 [INTERNAL]  Construct Prepares the function for evaluation.
1399 
1400 ";
1401 
1402 %feature("docstring")
1403 casadi::FiniteDiff::codegen_declarations(CodeGenerator &g) const  "
1404 
1405 [INTERNAL]  Generate code for the declarations of the C function.
1406 
1407 ";
1408 
1409 %feature("docstring")  casadi::FiniteDiff::eval(const double **arg, double
1410 **res, casadi_int *iw, double *w, void *mem) const  "
1411 
1412 [INTERNAL]  Evaluate numerically.
1413 
1414 ";
1415 
1416 %feature("docstring")  casadi::FunctionInternal::has_free() const  "
1417 
1418 [INTERNAL]  Does the function have free variables.
1419 
1420 ";
1421 
1422 %feature("docstring")  casadi::FunctionInternal::export_code(const
1423 std::string &lang, std::ostream &stream, const Dict &options) const  "
1424 
1425 [INTERNAL]  Export function in a specific language.
1426 
1427 ";
1428 
1429 %feature("docstring")  casadi::FunctionInternal::instruction_MX(casadi_int
1430 k) const  "
1431 
1432 [INTERNAL]  get MX expression associated with instruction
1433 
1434 ";
1435 
1436 %feature("docstring")  casadi::FunctionInternal::set_temp(void *mem, const
1437 double **arg, double **res, casadi_int *iw, double *w) const  "
1438 
1439 [INTERNAL]  Set the (temporary) work vectors.
1440 
1441 ";
1442 
1443 %feature("docstring")  casadi::ForwardDiff::has_forward(casadi_int nfwd)
1444 const  "
1445 
1446 [INTERNAL]  Second order derivatives.
1447 
1448 ";
1449 
1450 %feature("docstring")  casadi::FunctionInternal::incache(const std::string
1451 &fname, Function &f, const std::string &suffix="") const  "
1452 
1453 [INTERNAL]  Get function in cache.
1454 
1455 ";
1456 
1457 %feature("docstring")  casadi::FunctionInternal::print_options(std::ostream
1458 &stream) const  "
1459 
1460 [INTERNAL]  Print list of options.
1461 
1462 ";
1463 
1464 %feature("docstring")  casadi::FunctionInternal::codegen_mem(CodeGenerator
1465 &g, const std::string &index="mem") const  "
1466 
1467 [INTERNAL]  Get thread-local memory object.
1468 
1469 ";
1470 
1471 %feature("docstring")  casadi::FiniteDiff::get_n_in()  "
1472 
1473 [INTERNAL]  Number of function inputs and outputs.
1474 
1475 ";
1476 
1477 %feature("docstring")  casadi::FunctionInternal::generate_dependencies(const
1478 std::string &fname, const Dict &opts) const  "
1479 
1480 [INTERNAL]  Export / Generate C code for the dependency function.
1481 
1482 ";
1483 
1484 %feature("docstring")  casadi::FunctionInternal::get_free() const  "
1485 
1486 [INTERNAL]  Print free variables.
1487 
1488 ";
1489 
1490 %feature("docstring")  casadi::FunctionInternal::generate_out(const
1491 std::string &fname, double **res) const  "
1492 
1493 [INTERNAL] ";
1494 
1495 %feature("docstring")  casadi::ProtoFunction::free_mem(void *mem) const  "
1496 
1497 [INTERNAL]  Free memory block.
1498 
1499 ";
1500 
1501 %feature("docstring")
1502 casadi::FunctionInternal::print_dimensions(std::ostream &stream) const  "
1503 
1504 [INTERNAL]  Print dimensions of inputs and outputs.
1505 
1506 ";
1507 
1508 %feature("docstring")  casadi::ForwardDiff::n_pert() const  "
1509 
1510 [INTERNAL] ";
1511 
1512 %feature("docstring")  casadi::FunctionInternal::disp_more(std::ostream
1513 &stream) const  "
1514 
1515 [INTERNAL]  Print more.
1516 
1517 ";
1518 
1519 %feature("docstring")  casadi::FunctionInternal::finalize()  "
1520 
1521 [INTERNAL]  Finalize the object creation.
1522 
1523 ";
1524 
1525 %feature("docstring")  casadi::SharedObjectInternal::weak() "
1526 
1527 [INTERNAL]  Get a weak reference to the object.
1528 
1529 ";
1530 
1531 %feature("docstring")  casadi::FiniteDiff::get_options() const  "
1532 
1533 [INTERNAL]  Options.
1534 
1535 ";
1536 
1537 %feature("docstring")
1538 casadi::FunctionInternal::codegen_alloc_mem(CodeGenerator &g) const  "
1539 
1540 [INTERNAL]  Codegen decref for alloc_mem.
1541 
1542 ";
1543 
1544 %feature("docstring")  casadi::FunctionInternal::get_max_in(casadi_int ind)
1545 const  "
1546 
1547 [INTERNAL]  Get largest input value.
1548 
1549 ";
1550 
1551 %feature("docstring")  casadi::FunctionInternal::print_option(const
1552 std::string &name, std::ostream &stream) const  "
1553 
1554 [INTERNAL]  Print all information there is to know about a certain option.
1555 
1556 ";
1557 
1558 %feature("docstring")  casadi::FunctionInternal::instructions_sx() const  "
1559 
1560 [INTERNAL]  get SX expression associated with instructions
1561 
1562 ";
1563 
1564 %feature("docstring")
1565 casadi::FunctionInternal::codegen_init_mem(CodeGenerator &g) const  "
1566 
1567 [INTERNAL]  Codegen decref for init_mem.
1568 
1569 ";
1570 
1571 %feature("docstring")  casadi::FunctionInternal::reverse(casadi_int nadj)
1572 const  "
1573 
1574 [INTERNAL]  Return function that calculates adjoint derivatives
1575 reverse(nadj) returns a cached instance if available, and calls  Function
1576 get_reverse(casadi_int nadj) if no cached version is available.
1577 
1578 ";
1579 
1580 %feature("docstring")  casadi::FunctionInternal::is_a(const std::string
1581 &type, bool recursive) const  "
1582 
1583 [INTERNAL]  Check if the function is of a particular type.
1584 
1585 ";
1586 
1587 %feature("docstring")  casadi::ProtoFunction::memory(int ind) const  "
1588 
1589 [INTERNAL]  Memory objects.
1590 
1591 ";
1592 
1593 %feature("docstring")  casadi::FunctionInternal::mx_out(casadi_int ind)
1594 const  "
1595 
1596 [INTERNAL]  Get function input(s) and output(s)
1597 
1598 ";
1599 
1600 %feature("docstring")  casadi::FunctionInternal::mx_out() const  "
1601 
1602 [INTERNAL]  Get function input(s) and output(s)
1603 
1604 ";
1605 
1606 %feature("docstring")
1607 casadi::FunctionInternal::serialize_type(SerializingStream &s) const  "
1608 
1609 [INTERNAL]  Serialize type information.
1610 
1611 ";
1612 
1613 %feature("docstring")  casadi::ForwardDiff::pert(const std::string &k) const
1614 "
1615 
1616 [INTERNAL] ";
1617 
1618 %feature("docstring")  casadi::ForwardDiff::pert(casadi_int k, double h)
1619 const  "
1620 
1621 [INTERNAL] ";
1622 
1623 %feature("docstring")  casadi::FunctionInternal::size_in(casadi_int ind)
1624 const  "
1625 
1626 [INTERNAL]  Input/output dimensions.
1627 
1628 ";
1629 
1630 %feature("docstring")  casadi::FunctionInternal::nnz_in() const  "
1631 
1632 [INTERNAL]  Number of input/output nonzeros.
1633 
1634 ";
1635 
1636 %feature("docstring")  casadi::FunctionInternal::nnz_in(casadi_int ind)
1637 const  "
1638 
1639 [INTERNAL]  Number of input/output nonzeros.
1640 
1641 ";
1642 
1643 %feature("docstring")  casadi::FunctionInternal::forward(casadi_int nfwd)
1644 const  "
1645 
1646 [INTERNAL]  Return function that calculates forward derivatives
1647 forward(nfwd) returns a cached instance if available, and calls  Function
1648 get_forward(casadi_int nfwd) if no cached version is available.
1649 
1650 ";
1651 
1652 %feature("docstring")  casadi::FunctionInternal::setup(void *mem, const
1653 double **arg, double **res, casadi_int *iw, double *w) const  "
1654 
1655 [INTERNAL]  Set the (persistent and temporary) work vectors.
1656 
1657 ";
1658 
1659 %feature("docstring")  casadi::FunctionInternal::numel_out(casadi_int ind)
1660 const  "
1661 
1662 [INTERNAL]  Number of input/output elements.
1663 
1664 ";
1665 
1666 %feature("docstring")  casadi::FunctionInternal::numel_out() const  "
1667 
1668 [INTERNAL]  Number of input/output elements.
1669 
1670 ";
1671 
1672 %feature("docstring")  casadi::FunctionInternal::getAdaptorSolverName()
1673 const  "
1674 
1675 [INTERNAL]  Obtain solver name from Adaptor.
1676 
1677 ";
1678 
1679 %feature("docstring")  casadi::ProtoFunction::serialize_base_function()
1680 const  "
1681 
1682 [INTERNAL]  String used to identify the immediate FunctionInternal subclass.
1683 
1684 ";
1685 
1686 %feature("docstring")  casadi::BackwardDiff::calc_stepsize(double abstol)
1687 const  "
1688 
1689 [INTERNAL] ";
1690 
1691 %feature("docstring")  casadi::ForwardDiff::get_forward(casadi_int nfwd,
1692 const std::string &name, const std::vector< std::string > &inames, const
1693 std::vector< std::string > &onames, const Dict &opts) const  "
1694 
1695 [INTERNAL]  Second order derivatives.
1696 
1697 ";
1698 
1699 %feature("docstring")  casadi::FunctionInternal::alloc_iw(size_t sz_iw, bool
1700 persistent=false) "
1701 
1702 [INTERNAL]  Ensure required length of iw field.
1703 
1704 ";
1705 
1706 %feature("docstring")  casadi::FunctionInternal::sx_out(casadi_int ind)
1707 const  "
1708 
1709 [INTERNAL]  Get function input(s) and output(s)
1710 
1711 ";
1712 
1713 %feature("docstring")  casadi::FunctionInternal::sx_out() const  "
1714 
1715 [INTERNAL]  Get function input(s) and output(s)
1716 
1717 ";
1718 
1719 %feature("docstring")  casadi::FunctionInternal::sp_forward(const bvec_t
1720 **arg, bvec_t **res, casadi_int *iw, bvec_t *w, void *mem) const  "
1721 
1722 [INTERNAL]  Propagate sparsity forward.
1723 
1724 ";
1725 
1726 %feature("docstring")  casadi::FunctionInternal::sz_w() const  "
1727 
1728 [INTERNAL]  Get required length of w field.
1729 
1730 ";
1731 
1732 %feature("docstring")  casadi::FunctionInternal::sp_weight() const  "
1733 
1734 [INTERNAL]  Weighting factor for chosing forward/reverse mode, sparsity
1735 propagation.
1736 
1737 ";
1738 
1739 %feature("docstring")  casadi::FunctionInternal::sx_in(casadi_int ind) const
1740 "
1741 
1742 [INTERNAL]  Get function input(s) and output(s)
1743 
1744 ";
1745 
1746 %feature("docstring")  casadi::FunctionInternal::sx_in() const  "
1747 
1748 [INTERNAL]  Get function input(s) and output(s)
1749 
1750 ";
1751 
1752 %feature("docstring")  casadi::ProtoFunction::get_stats(void *mem) const  "
1753 
1754 [INTERNAL]  Get all statistics.
1755 
1756 ";
1757 
1758 %feature("docstring")
1759 casadi::FunctionInternal::instruction_input(casadi_int k) const  "
1760 
1761 [INTERNAL]  Get the (integer) input arguments of an atomic operation.
1762 
1763 ";
1764 
1765 %feature("docstring")  casadi::FunctionInternal::index_in(const std::string
1766 &name) const  "
1767 
1768 [INTERNAL]  Get input scheme index by name.
1769 
1770 ";
1771 
1772 %feature("docstring")  casadi::FunctionInternal::has_spfwd() const  "
1773 
1774 [INTERNAL]  Is the class able to propagate seeds through the algorithm?
1775 
1776 ";
1777 
1778 %feature("docstring")  casadi::FunctionInternal::fwdViaJac(casadi_int nfwd)
1779 const  "
1780 
1781 [INTERNAL]  Calculate derivatives by multiplying the full Jacobian and
1782 multiplying.
1783 
1784 ";
1785 
1786 %feature("docstring")
1787 casadi::FunctionInternal::codegen_sparsities(CodeGenerator &g) const  "
1788 
1789 [INTERNAL]  Codegen sparsities.
1790 
1791 ";
1792 
1793 %feature("docstring")  casadi::FunctionInternal::codegen_name(const
1794 CodeGenerator &g, bool ns=true) const  "
1795 
1796 [INTERNAL]  Get name in codegen.
1797 
1798 ";
1799 
1800 %feature("docstring")  casadi::FunctionInternal::generate_lifted(Function
1801 &vdef_fcn, Function &vinit_fcn) const  "
1802 
1803 [INTERNAL]  Extract the functions needed for the Lifted Newton method.
1804 
1805 ";
1806 
1807 %feature("docstring")  casadi::FunctionInternal::sz_res() const  "
1808 
1809 [INTERNAL]  Get required length of res field.
1810 
1811 ";
1812 
1813 %feature("docstring")  casadi::FunctionInternal::signature(const std::string
1814 &fname) const  "
1815 
1816 [INTERNAL]  Code generate the function.
1817 
1818 ";
1819 
1820 %feature("docstring")  casadi::FunctionInternal::ad_weight() const  "
1821 
1822 [INTERNAL]  Weighting factor for chosing forward/reverse mode.
1823 
1824 ";
1825 
1826 %feature("docstring")  casadi::FunctionInternal::codegen_mem_type() const  "
1827 
1828 [INTERNAL]  Thread-local memory object type.
1829 
1830 ";
1831 
1832 %feature("docstring")  casadi::ProtoFunction::sprint(char *buf, size_t
1833 buf_sz, const char *fmt,...) const  "
1834 
1835 [INTERNAL]  C-style formatted printing to string.
1836 
1837 ";
1838 
1839 %feature("docstring")  casadi::FunctionInternal::replace_aseed(const
1840 std::vector< std::vector< M >> &aseed, casadi_int npar) const  "
1841 
1842 [INTERNAL]  Replace 0-by-0 reverse seeds.
1843 
1844 ";
1845 
1846 %feature("docstring")  casadi::FunctionInternal::replace_aseed(const
1847 std::vector< std::vector< M > > &aseed, casadi_int npar) const  "
1848 
1849 [INTERNAL] ";
1850 
1851 %feature("docstring") casadi::BackwardDiff::~BackwardDiff "
1852 
1853 [INTERNAL]  Destructor.
1854 
1855 ";
1856 
1857 %feature("docstring")
1858 casadi::FunctionInternal::codegen_decref(CodeGenerator &g) const  "
1859 
1860 [INTERNAL]  Codegen decref for dependencies.
1861 
1862 ";
1863 
1864 %feature("docstring")  casadi::FunctionInternal::convert_res(const
1865 std::vector< M > &res) const  "
1866 
1867 [INTERNAL]  Convert from/to input/output lists/map.
1868 
1869 ";
1870 
1871 %feature("docstring")  casadi::FunctionInternal::convert_res(const std::map<
1872 std::string, M > &res) const  "
1873 
1874 [INTERNAL]  Convert from/to input/output lists/map.
1875 
1876 ";
1877 
1878 %feature("docstring")  casadi::FunctionInternal::get_partition(casadi_int
1879 iind, casadi_int oind, Sparsity &D1, Sparsity &D2, bool compact, bool
1880 symmetric, bool allow_forward, bool allow_reverse) const  "
1881 
1882 [INTERNAL]  Get the unidirectional or bidirectional partition.
1883 
1884 ";
1885 
1886 %feature("docstring")  casadi::FiniteDiff::get_n_out()  "
1887 
1888 [INTERNAL]  Number of function inputs and outputs.
1889 
1890 ";
1891 
1892 %feature("docstring")  casadi::FunctionInternal::has_eval_dm() const  "
1893 
1894 [INTERNAL]  Evaluate with DM matrices.
1895 
1896 ";
1897 
1898 %feature("docstring")  casadi::FunctionInternal::get_min_in(casadi_int ind)
1899 const  "
1900 
1901 [INTERNAL]  Get smallest input value.
1902 
1903 ";
1904 
1905 %feature("docstring")  casadi::FunctionInternal::codegen_meta(CodeGenerator
1906 &g) const  "
1907 
1908 [INTERNAL]  Generate meta-information allowing a user to evaluate a
1909 generated function.
1910 
1911 ";
1912 
1913 %feature("docstring")  casadi::FunctionInternal::generate_in(const
1914 std::string &fname, const double **arg) const  "
1915 
1916 [INTERNAL]  Export an input file that can be passed to generate C code with
1917 a main.
1918 
1919 ";
1920 
1921 %feature("docstring")  casadi::FunctionInternal::self() const  "
1922 
1923 [INTERNAL]  Get a public class instance.
1924 
1925 ";
1926 
1927 %feature("docstring")  casadi::FunctionInternal::mx_in(casadi_int ind) const
1928 "
1929 
1930 [INTERNAL]  Get function input(s) and output(s)
1931 
1932 ";
1933 
1934 %feature("docstring")  casadi::FunctionInternal::mx_in() const  "
1935 
1936 [INTERNAL]  Get function input(s) and output(s)
1937 
1938 ";
1939 
1940 
1941 // File: classcasadi_1_1Bilin.xml
1942 
1943 
1944 // File: classcasadi_1_1BinaryMX.xml
1945 
1946 
1947 // File: classcasadi_1_1BinarySX.xml
1948 
1949 
1950 // File: classcasadi_1_1Blocksqp.xml
1951 %feature("docstring")  casadi::FunctionInternal::sz_work(size_t &sz_arg,
1952 size_t &sz_res, size_t &sz_iw, size_t &sz_w) const  "
1953 
1954 [INTERNAL]  Get number of temporary variables needed.
1955 
1956 ";
1957 
1958 %feature("docstring")  casadi::Blocksqp::get_options() const  "
1959 
1960 [INTERNAL]  Options.
1961 
1962 ";
1963 
1964 %feature("docstring")  casadi::ProtoFunction::memory(int ind) const  "
1965 
1966 [INTERNAL]  Memory objects.
1967 
1968 ";
1969 
1970 %feature("docstring")  casadi::FunctionInternal::matching_res(const
1971 std::vector< M > &arg, casadi_int &npar) const  "
1972 
1973 [INTERNAL]  Check if output arguments that needs to be replaced.
1974 
1975 Raises errors
1976 
1977 Parameters:
1978 -----------
1979 
1980 npar[in]:  normal usage: 1, disallow pararallel calls: -1
1981 
1982 npar:  max number of horizontal repetitions across all arguments (or -1)
1983 
1984 ";
1985 
1986 %feature("docstring")  casadi::Nlpsol::get_name_out(casadi_int i)  "
1987 
1988 [INTERNAL]  Names of function input and outputs.
1989 
1990 ";
1991 
1992 %feature("docstring")  casadi::Nlpsol::get_forward(casadi_int nfwd, const
1993 std::string &name, const std::vector< std::string > &inames, const
1994 std::vector< std::string > &onames, const Dict &opts) const  "
1995 
1996 [INTERNAL]  Generate a function that calculates forward mode derivatives.
1997 
1998 ";
1999 
2000 %feature("docstring")
2001 casadi::FunctionInternal::getJacSparsityHierarchical(casadi_int iind,
2002 casadi_int oind) const  "
2003 
2004 [INTERNAL]  A flavor of getJacSparsity that does hierarchical block
2005 structure recognition.
2006 
2007 ";
2008 
2009 %feature("docstring")
2010 casadi::FunctionInternal::instruction_constant(casadi_int k) const  "
2011 
2012 [INTERNAL]  Get the floating point output argument of an atomic operation.
2013 
2014 ";
2015 
2016 %feature("docstring")  casadi::Blocksqp::alloc_mem() const  "
2017 
2018 [INTERNAL]  Create memory block.
2019 
2020 ";
2021 
2022 %feature("docstring")  casadi::OracleFunction::finalize()  "
2023 
2024 [INTERNAL]  Finalize initialization.
2025 
2026 ";
2027 
2028 %feature("docstring")  casadi::FunctionInternal::adjViaJac(casadi_int nadj)
2029 const  "
2030 
2031 [INTERNAL]  Calculate derivatives by multiplying the full Jacobian and
2032 multiplying.
2033 
2034 ";
2035 
2036 %feature("docstring")  casadi::Blocksqp::plugin_name() const  "
2037 
2038 [INTERNAL] ";
2039 
2040 %feature("docstring")  casadi::FunctionInternal::mx_out(casadi_int ind)
2041 const  "
2042 
2043 [INTERNAL]  Get function input(s) and output(s)
2044 
2045 ";
2046 
2047 %feature("docstring")  casadi::FunctionInternal::mx_out() const  "
2048 
2049 [INTERNAL]  Get function input(s) and output(s)
2050 
2051 ";
2052 
2053 %feature("docstring")  casadi::ProtoFunction::clear_mem() "
2054 
2055 [INTERNAL]  Clear all memory (called from destructor)
2056 
2057 ";
2058 
2059 %feature("docstring")  casadi::OracleFunction::set_function(const Function
2060 &fcn, const std::string &fname, bool jit=false) "
2061 
2062 [INTERNAL]  Register the function for evaluation and statistics gathering
2063 
2064 ";
2065 
2066 %feature("docstring")  casadi::OracleFunction::set_function(const Function
2067 &fcn) "
2068 
2069 [INTERNAL]  Register the function for evaluation and statistics gathering
2070 
2071 ";
2072 
2073 %feature("docstring")  casadi::Blocksqp::printProgress(BlocksqpMemory *m)
2074 const  "
2075 
2076 [INTERNAL]  Print one line of output to stdout about the current iteration.
2077 
2078 ";
2079 
2080 %feature("docstring")  casadi::FunctionInternal::wrap() const  "
2081 
2082 [INTERNAL]  Wrap in an Function instance consisting of only one MX call.
2083 
2084 ";
2085 
2086 %feature("docstring")  casadi::FunctionInternal::codegen(CodeGenerator &g,
2087 const std::string &fname) const  "
2088 
2089 [INTERNAL]  Generate code the function.
2090 
2091 ";
2092 
2093 %feature("docstring")  casadi::Nlpsol::disp_more(std::ostream &stream) const
2094 "
2095 
2096 [INTERNAL]  Print description.
2097 
2098 ";
2099 
2100 %feature("docstring")  casadi::FunctionInternal::alloc_w(size_t sz_w, bool
2101 persistent=false) "
2102 
2103 [INTERNAL]  Ensure required length of w field.
2104 
2105 ";
2106 
2107 %feature("docstring")  casadi::FunctionInternal::replace_res(const
2108 std::vector< M > &res, casadi_int npar) const  "
2109 
2110 [INTERNAL]  Replace 0-by-0 outputs.
2111 
2112 ";
2113 
2114 %feature("docstring")  casadi::Nlpsol::callback(NlpsolMemory *m) const  "
2115 
2116 [INTERNAL] ";
2117 
2118 %feature("docstring")  casadi::FunctionInternal::project_res(const
2119 std::vector< M > &arg, casadi_int npar) const  "
2120 
2121 [INTERNAL]   Project sparsities.
2122 
2123 ";
2124 
2125 %feature("docstring")  casadi::Nlpsol::kkt() const  "
2126 
2127 [INTERNAL] ";
2128 
2129 %feature("docstring")  casadi::FunctionInternal::check_res(const
2130 std::vector< M > &res, casadi_int &npar) const  "
2131 
2132 [INTERNAL]  Check if output arguments have correct length and dimensions.
2133 
2134 Raises errors.
2135 
2136 Parameters:
2137 -----------
2138 
2139 npar[in]:  normal usage: 1, disallow pararallel calls: -1
2140 
2141 npar:  max number of horizontal repetitions across all arguments (or -1)
2142 
2143 ";
2144 
2145 %feature("docstring")  casadi::FunctionInternal::has_spfwd() const  "
2146 
2147 [INTERNAL]  Is the class able to propagate seeds through the algorithm?
2148 
2149 ";
2150 
2151 %feature("docstring")  casadi::ProtoFunction::construct(const Dict &opts) "
2152 
2153 [INTERNAL]  Construct Prepares the function for evaluation.
2154 
2155 ";
2156 
2157 %feature("docstring")  casadi::FunctionInternal::size_in(casadi_int ind)
2158 const  "
2159 
2160 [INTERNAL]  Input/output dimensions.
2161 
2162 ";
2163 
2164 %feature("docstring")
2165 casadi::FunctionInternal::codegen_sparsities(CodeGenerator &g) const  "
2166 
2167 [INTERNAL]  Codegen sparsities.
2168 
2169 ";
2170 
2171 %feature("docstring")  casadi::Nlpsol::nlpsol_codegen_body(CodeGenerator &g)
2172 const  "
2173 
2174 [INTERNAL]  Generate code for the function body.
2175 
2176 ";
2177 
2178 %feature("docstring")  casadi::FunctionInternal::disp(std::ostream &stream,
2179 bool more) const  "
2180 
2181 [INTERNAL]  Display object.
2182 
2183 ";
2184 
2185 %feature("docstring")  casadi::ProtoFunction::sprint(char *buf, size_t
2186 buf_sz, const char *fmt,...) const  "
2187 
2188 [INTERNAL]  C-style formatted printing to string.
2189 
2190 ";
2191 
2192 %feature("docstring")  casadi::FunctionInternal::codegen_mem(CodeGenerator
2193 &g, const std::string &index="mem") const  "
2194 
2195 [INTERNAL]  Get thread-local memory object.
2196 
2197 ";
2198 
2199 %feature("docstring")  casadi::FunctionInternal::wrap_as_needed(const Dict
2200 &opts) const  "
2201 
2202 [INTERNAL]  Wrap in an Function instance consisting of only one MX call.
2203 
2204 ";
2205 
2206 %feature("docstring")  casadi::Blocksqp::sizeHessianCOL(BlocksqpMemory *m,
2207 const double *gamma, const double *delta, casadi_int b) const  "
2208 
2209 [INTERNAL] ";
2210 
2211 %feature("docstring")  casadi::FunctionInternal::has_codegen() const  "
2212 
2213 [INTERNAL]  Is codegen supported?
2214 
2215 ";
2216 
2217 %feature("docstring")  casadi::FunctionInternal::n_instructions() const  "
2218 
2219 [INTERNAL]  Get the number of atomic operations.
2220 
2221 ";
2222 
2223 %feature("docstring")  casadi::Blocksqp::calcBFGS(BlocksqpMemory *m, const
2224 double *gamma, const double *delta, casadi_int b) const  "
2225 
2226 [INTERNAL] ";
2227 
2228 %feature("docstring")  casadi::FunctionInternal::n_nodes() const  "
2229 
2230 [INTERNAL]  Number of nodes in the algorithm.
2231 
2232 ";
2233 
2234 %feature("docstring")  casadi::FunctionInternal::is_diff_in(casadi_int i) "
2235 
2236 [INTERNAL] ";
2237 
2238 %feature("docstring")  casadi::Blocksqp::pairInFilter(BlocksqpMemory *m,
2239 double cNorm, double obj) const  "
2240 
2241 [INTERNAL] ";
2242 
2243 %feature("docstring")  casadi::Blocksqp::reset_sqp(BlocksqpMemory *m) const
2244 "
2245 
2246 [INTERNAL]  Reset variables that any SQP code needs.
2247 
2248 ";
2249 
2250 %feature("docstring")  casadi::Blocksqp::resetHessian(BlocksqpMemory *m)
2251 const  "
2252 
2253 [INTERNAL] ";
2254 
2255 %feature("docstring")  casadi::Blocksqp::resetHessian(BlocksqpMemory *m,
2256 casadi_int b) const  "
2257 
2258 [INTERNAL] ";
2259 
2260 %feature("docstring")  casadi::OracleFunction::has_function(const
2261 std::string &fname) const  "
2262 
2263 [INTERNAL] ";
2264 
2265 %feature("docstring")  casadi::FunctionInternal::dm_in(casadi_int ind) const
2266 "
2267 
2268 [INTERNAL]  Get function input(s) and output(s)
2269 
2270 ";
2271 
2272 %feature("docstring")  casadi::FunctionInternal::dm_in() const  "
2273 
2274 [INTERNAL]  Get function input(s) and output(s)
2275 
2276 ";
2277 
2278 %feature("docstring")  casadi::Blocksqp::fullstep(BlocksqpMemory *m) const
2279 "
2280 
2281 [INTERNAL]  No globalization strategy.
2282 
2283 ";
2284 
2285 %feature("docstring")  casadi::Nlpsol::has_reverse(casadi_int nadj) const  "
2286 
2287 [INTERNAL]  Generate a function that calculates reverse mode derivatives.
2288 
2289 ";
2290 
2291 %feature("docstring")  casadi::FunctionInternal::eval_mx(const MXVector
2292 &arg, MXVector &res, bool always_inline, bool never_inline) const  "
2293 
2294 [INTERNAL]  Evaluate with symbolic matrices.
2295 
2296 ";
2297 
2298 %feature("docstring")  casadi::FunctionInternal::jacobian() const  "
2299 
2300 [INTERNAL]  Return Jacobian of all input elements with respect to all output
2301 elements.
2302 
2303 ";
2304 
2305 %feature("docstring")  casadi::FunctionInternal::call_forward(const
2306 std::vector< MX > &arg, const std::vector< MX > &res, const std::vector<
2307 std::vector< MX > > &fseed, std::vector< std::vector< MX > > &fsens, bool
2308 always_inline, bool never_inline) const  "
2309 
2310 [INTERNAL]  Forward mode AD, virtual functions overloaded in derived
2311 classes.
2312 
2313 ";
2314 
2315 %feature("docstring")  casadi::FunctionInternal::call_forward(const
2316 std::vector< SX > &arg, const std::vector< SX > &res, const std::vector<
2317 std::vector< SX > > &fseed, std::vector< std::vector< SX > > &fsens, bool
2318 always_inline, bool never_inline) const  "
2319 
2320 [INTERNAL]  Forward mode AD, virtual functions overloaded in derived
2321 classes.
2322 
2323 ";
2324 
2325 %feature("docstring")  casadi::FunctionInternal::fwd_seed(casadi_int nfwd)
2326 const  "
2327 
2328 [INTERNAL]  Symbolic expressions for the forward seeds.
2329 
2330 ";
2331 
2332 %feature("docstring")  casadi::FunctionInternal::nz_in(const std::vector< DM
2333 > &arg) const  "
2334 
2335 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
2336 
2337 ";
2338 
2339 %feature("docstring")  casadi::FunctionInternal::nz_in(const std::vector<
2340 double > &arg) const  "
2341 
2342 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
2343 
2344 ";
2345 
2346 %feature("docstring")  casadi::FunctionInternal::call_gen(const MXVector
2347 &arg, MXVector &res, casadi_int npar, bool always_inline, bool never_inline)
2348 const  "
2349 
2350 [INTERNAL]   Call a function, overloaded.
2351 
2352 ";
2353 
2354 %feature("docstring")  casadi::FunctionInternal::call_gen(const std::vector<
2355 MatrixCommon > &arg, std::vector< MatrixCommon > &res, casadi_int npar, bool
2356 always_inline, bool never_inline) const  "
2357 
2358 [INTERNAL]   Call a function, overloaded.
2359 
2360 ";
2361 
2362 %feature("docstring")  casadi::Nlpsol::get_n_in()  "
2363 
2364 [INTERNAL]  Number of function inputs and outputs.
2365 
2366 ";
2367 
2368 %feature("docstring")  casadi::FunctionInternal::alloc_res(size_t sz_res,
2369 bool persistent=false) "
2370 
2371 [INTERNAL]  Ensure required length of res field.
2372 
2373 ";
2374 
2375 %feature("docstring")  casadi::FunctionInternal::all_scalar() const  "
2376 
2377 [INTERNAL]  Are all inputs and outputs scalar.
2378 
2379 ";
2380 
2381 %feature("docstring")  casadi::FunctionInternal::setup(void *mem, const
2382 double **arg, double **res, casadi_int *iw, double *w) const  "
2383 
2384 [INTERNAL]  Set the (persistent and temporary) work vectors.
2385 
2386 ";
2387 
2388 %feature("docstring")  casadi::Nlpsol::get_sparsity_in(casadi_int i)  "
2389 
2390 [INTERNAL]  Sparsities of function inputs and outputs.
2391 
2392 ";
2393 
2394 %feature("docstring")  casadi::FunctionInternal::sp_reverse(bvec_t **arg,
2395 bvec_t **res, casadi_int *iw, bvec_t *w, void *mem) const  "
2396 
2397 [INTERNAL]  Propagate sparsity backwards.
2398 
2399 ";
2400 
2401 %feature("docstring") casadi::Blocksqp::~Blocksqp "
2402 
2403 [INTERNAL] ";
2404 
2405 %feature("docstring")
2406 casadi::FunctionInternal::codegen_decref(CodeGenerator &g) const  "
2407 
2408 [INTERNAL]  Codegen decref for dependencies.
2409 
2410 ";
2411 
2412 %feature("docstring")  casadi::FunctionInternal::has_sprev() const  "
2413 
2414 [INTERNAL]  Is the class able to propagate seeds through the algorithm?
2415 
2416 ";
2417 
2418 %feature("docstring")  casadi::FunctionInternal::get_free() const  "
2419 
2420 [INTERNAL]  Print free variables.
2421 
2422 ";
2423 
2424 %feature("docstring")  casadi::FunctionInternal::sz_w() const  "
2425 
2426 [INTERNAL]  Get required length of w field.
2427 
2428 ";
2429 
2430 %feature("docstring")  casadi::Blocksqp::calcHessianUpdate(BlocksqpMemory
2431 *m, casadi_int updateType, casadi_int hessScaling) const  "
2432 
2433 [INTERNAL] ";
2434 
2435 %feature("docstring")  casadi::ProtoFunction::checkout() const  "
2436 
2437 [INTERNAL]  Checkout a memory object.
2438 
2439 ";
2440 
2441 %feature("docstring")  casadi::Blocksqp::evaluate(BlocksqpMemory *m, double
2442 *f, double *g, double *grad_f, double *jac_g) const  "
2443 
2444 [INTERNAL]  Evaluate objective and constraints, including derivatives.
2445 
2446 ";
2447 
2448 %feature("docstring")  casadi::Blocksqp::evaluate(BlocksqpMemory *m, const
2449 double *xk, double *f, double *g) const  "
2450 
2451 [INTERNAL]  Evaluate objective and constraints, no derivatives.
2452 
2453 ";
2454 
2455 %feature("docstring")  casadi::Blocksqp::evaluate(BlocksqpMemory *m, double
2456 *exact_hess_lag) const  "
2457 
2458 [INTERNAL]  Evaluate exact hessian of Lagrangian.
2459 
2460 ";
2461 
2462 %feature("docstring")  casadi::Nlpsol::check_inputs(void *mem) const  "
2463 
2464 [INTERNAL]  Check if the inputs correspond to a well-posed problem.
2465 
2466 ";
2467 
2468 %feature("docstring")  casadi::Blocksqp::initializeFilter(BlocksqpMemory *m)
2469 const  "
2470 
2471 [INTERNAL] ";
2472 
2473 %feature("docstring")  casadi::Nlpsol::getReducedHessian() "
2474 
2475 [INTERNAL] ";
2476 
2477 %feature("docstring")  casadi::OracleFunction::get_function() const  "
2478 
2479 [INTERNAL]  Get list of dependency functions -1 Indicates irregularity.
2480 
2481 ";
2482 
2483 %feature("docstring")  casadi::OracleFunction::get_function(const
2484 std::string &name) const  "
2485 
2486 [INTERNAL] ";
2487 
2488 %feature("docstring")  casadi::FunctionInternal::sparsity_jac(casadi_int
2489 iind, casadi_int oind, bool compact, bool symmetric) const  "
2490 
2491 [INTERNAL]  Get, if necessary generate, the sparsity of a Jacobian block.
2492 
2493 ";
2494 
2495 %feature("docstring") casadi::Blocksqp::Blocksqp(const std::string &name,
2496 const Function &nlp) "
2497 
2498 [INTERNAL] ";
2499 
2500 %feature("docstring")  casadi::FunctionInternal::generate_options(bool
2501 is_temp=false) const  "
2502 
2503 [INTERNAL]  Reconstruct options dict.
2504 
2505 ";
2506 
2507 %feature("docstring")  casadi::Blocksqp::computeNextHessian(BlocksqpMemory
2508 *m, casadi_int idx, casadi_int maxQP) const  "
2509 
2510 [INTERNAL] ";
2511 
2512 %feature("docstring")  casadi::FunctionInternal::sz_res() const  "
2513 
2514 [INTERNAL]  Get required length of res field.
2515 
2516 ";
2517 
2518 %feature("docstring")  casadi::FunctionInternal::is_diff_out(casadi_int i) "
2519 
2520 [INTERNAL] ";
2521 
2522 %feature("docstring")  casadi::FunctionInternal::sp_forward(const bvec_t
2523 **arg, bvec_t **res, casadi_int *iw, bvec_t *w, void *mem) const  "
2524 
2525 [INTERNAL]  Propagate sparsity forward.
2526 
2527 ";
2528 
2529 %feature("docstring")  casadi::OracleFunction::expand() "
2530 
2531 [INTERNAL] ";
2532 
2533 %feature("docstring")  casadi::FunctionInternal::generate_out(const
2534 std::string &fname, double **res) const  "
2535 
2536 [INTERNAL] ";
2537 
2538 %feature("docstring")  casadi::FunctionInternal::get_jac(const std::string
2539 &name, const std::vector< std::string > &inames, const std::vector<
2540 std::string > &onames, const Dict &opts) const  "
2541 
2542 [INTERNAL]  Return Jacobian of all input elements with respect to all output
2543 elements.
2544 
2545 ";
2546 
2547 %feature("docstring")  casadi::Nlpsol::has_forward(casadi_int nfwd) const  "
2548 
2549 [INTERNAL]  Generate a function that calculates forward mode derivatives.
2550 
2551 ";
2552 
2553 %feature("docstring") casadi::Blocksqp "
2554 
2555 'blocksqp' plugin for Nlpsol
2556 
2557 This is a modified version of blockSQP by Janka et al.
2558 
2559 Dennis Janka, Joel Andersson
2560 
2561 >List of available options
2562 
2563 +----------------------------+-----------+---------------------------------+
2564 |             Id             |   Type    |           Description           |
2565 +============================+===========+=================================+
2566 | block_hess                 | OT_INT    | Blockwise Hessian               |
2567 |                            |           | approximation?                  |
2568 +----------------------------+-----------+---------------------------------+
2569 | col_eps                    | OT_DOUBLE | Epsilon for COL scaling         |
2570 |                            |           | strategy                        |
2571 +----------------------------+-----------+---------------------------------+
2572 | col_tau1                   | OT_DOUBLE | tau1 for COL scaling strategy   |
2573 +----------------------------+-----------+---------------------------------+
2574 | col_tau2                   | OT_DOUBLE | tau2 for COL scaling strategy   |
2575 +----------------------------+-----------+---------------------------------+
2576 | conv_strategy              | OT_INT    | Convexification strategy        |
2577 +----------------------------+-----------+---------------------------------+
2578 | delta                      | OT_DOUBLE | Filter line search parameter,   |
2579 |                            |           | cf. IPOPT paper                 |
2580 +----------------------------+-----------+---------------------------------+
2581 | delta_h0                   | OT_DOUBLE | Filter line search parameter,   |
2582 |                            |           | cf. IPOPT paper                 |
2583 +----------------------------+-----------+---------------------------------+
2584 | eps                        | OT_DOUBLE | Values smaller than this are    |
2585 |                            |           | regarded as numerically zero    |
2586 +----------------------------+-----------+---------------------------------+
2587 | eta                        | OT_DOUBLE | Filter line search parameter,   |
2588 |                            |           | cf. IPOPT paper                 |
2589 +----------------------------+-----------+---------------------------------+
2590 | fallback_scaling           | OT_INT    | If indefinite update is used,   |
2591 |                            |           | the type of fallback strategy   |
2592 +----------------------------+-----------+---------------------------------+
2593 | fallback_update            | OT_INT    | If indefinite update is used,   |
2594 |                            |           | the type of fallback strategy   |
2595 +----------------------------+-----------+---------------------------------+
2596 | gamma_f                    | OT_DOUBLE | Filter line search parameter,   |
2597 |                            |           | cf. IPOPT paper                 |
2598 +----------------------------+-----------+---------------------------------+
2599 | gamma_theta                | OT_DOUBLE | Filter line search parameter,   |
2600 |                            |           | cf. IPOPT paper                 |
2601 +----------------------------+-----------+---------------------------------+
2602 | globalization              | OT_BOOL   | Enable globalization            |
2603 +----------------------------+-----------+---------------------------------+
2604 | hess_damp                  | OT_INT    | Activate Powell damping for     |
2605 |                            |           | BFGS                            |
2606 +----------------------------+-----------+---------------------------------+
2607 | hess_damp_fac              | OT_DOUBLE | Damping factor for BFGS Powell  |
2608 |                            |           | modification                    |
2609 +----------------------------+-----------+---------------------------------+
2610 | hess_lim_mem               | OT_INT    | Full or limited memory          |
2611 +----------------------------+-----------+---------------------------------+
2612 | hess_memsize               | OT_INT    | Memory size for L-BFGS updates  |
2613 +----------------------------+-----------+---------------------------------+
2614 | hess_scaling               | OT_INT    | Scaling strategy for Hessian    |
2615 |                            |           | approximation                   |
2616 +----------------------------+-----------+---------------------------------+
2617 | hess_update                | OT_INT    | Type of Hessian approximation   |
2618 +----------------------------+-----------+---------------------------------+
2619 | ini_hess_diag              | OT_DOUBLE | Initial Hessian guess: diagonal |
2620 |                            |           | matrix diag(iniHessDiag)        |
2621 +----------------------------+-----------+---------------------------------+
2622 | kappa_f                    | OT_DOUBLE | Filter line search parameter,   |
2623 |                            |           | cf. IPOPT paper                 |
2624 +----------------------------+-----------+---------------------------------+
2625 | kappa_minus                | OT_DOUBLE | Filter line search parameter,   |
2626 |                            |           | cf. IPOPT paper                 |
2627 +----------------------------+-----------+---------------------------------+
2628 | kappa_plus                 | OT_DOUBLE | Filter line search parameter,   |
2629 |                            |           | cf. IPOPT paper                 |
2630 +----------------------------+-----------+---------------------------------+
2631 | kappa_plus_max             | OT_DOUBLE | Filter line search parameter,   |
2632 |                            |           | cf. IPOPT paper                 |
2633 +----------------------------+-----------+---------------------------------+
2634 | kappa_soc                  | OT_DOUBLE | Filter line search parameter,   |
2635 |                            |           | cf. IPOPT paper                 |
2636 +----------------------------+-----------+---------------------------------+
2637 | linsol                     | OT_STRING | The linear solver to be used by |
2638 |                            |           | the QP method                   |
2639 +----------------------------+-----------+---------------------------------+
2640 | max_consec_reduced_steps   | OT_INT    | Maximum number of consecutive   |
2641 |                            |           | reduced steps                   |
2642 +----------------------------+-----------+---------------------------------+
2643 | max_consec_skipped_updates | OT_INT    | Maximum number of consecutive   |
2644 |                            |           | skipped updates                 |
2645 +----------------------------+-----------+---------------------------------+
2646 | max_conv_qp                | OT_INT    | How many additional QPs may be  |
2647 |                            |           | solved for convexification per  |
2648 |                            |           | iteration?                      |
2649 +----------------------------+-----------+---------------------------------+
2650 | max_it_qp                  | OT_INT    | Maximum number of QP iterations |
2651 |                            |           | per SQP iteration               |
2652 +----------------------------+-----------+---------------------------------+
2653 | max_iter                   | OT_INT    | Maximum number of SQP           |
2654 |                            |           | iterations                      |
2655 +----------------------------+-----------+---------------------------------+
2656 | max_line_search            | OT_INT    | Maximum number of steps in line |
2657 |                            |           | search                          |
2658 +----------------------------+-----------+---------------------------------+
2659 | max_soc_iter               | OT_INT    | Maximum number of SOC line      |
2660 |                            |           | search iterations               |
2661 +----------------------------+-----------+---------------------------------+
2662 | max_time_qp                | OT_DOUBLE | Maximum number of time in       |
2663 |                            |           | seconds per QP solve per SQP    |
2664 |                            |           | iteration                       |
2665 +----------------------------+-----------+---------------------------------+
2666 | nlinfeastol                | OT_DOUBLE | Nonlinear feasibility tolerance |
2667 +----------------------------+-----------+---------------------------------+
2668 | obj_lo                     | OT_DOUBLE | Lower bound on objective        |
2669 |                            |           | function [-inf]                 |
2670 +----------------------------+-----------+---------------------------------+
2671 | obj_up                     | OT_DOUBLE | Upper bound on objective        |
2672 |                            |           | function [inf]                  |
2673 +----------------------------+-----------+---------------------------------+
2674 | opttol                     | OT_DOUBLE | Optimality tolerance            |
2675 +----------------------------+-----------+---------------------------------+
2676 | print_header               | OT_BOOL   | Print solver header at startup  |
2677 +----------------------------+-----------+---------------------------------+
2678 | print_iteration            | OT_BOOL   | Print SQP iterations            |
2679 +----------------------------+-----------+---------------------------------+
2680 | print_maxit_reached        | OT_BOOL   | Print error when maximum number |
2681 |                            |           | of SQP iterations reached       |
2682 +----------------------------+-----------+---------------------------------+
2683 | qp_init                    | OT_BOOL   | Use warmstarting                |
2684 +----------------------------+-----------+---------------------------------+
2685 | qpsol                      | OT_STRING | The QP solver to be used by the |
2686 |                            |           | SQP method                      |
2687 +----------------------------+-----------+---------------------------------+
2688 | qpsol_options              | OT_DICT   | Options to be passed to the QP  |
2689 |                            |           | solver                          |
2690 +----------------------------+-----------+---------------------------------+
2691 | restore_feas               | OT_BOOL   | Use feasibility restoration     |
2692 |                            |           | phase                           |
2693 +----------------------------+-----------+---------------------------------+
2694 | rho                        | OT_DOUBLE | Feasibility restoration phase   |
2695 |                            |           | parameter                       |
2696 +----------------------------+-----------+---------------------------------+
2697 | s_f                        | OT_DOUBLE | Filter line search parameter,   |
2698 |                            |           | cf. IPOPT paper                 |
2699 +----------------------------+-----------+---------------------------------+
2700 | s_theta                    | OT_DOUBLE | Filter line search parameter,   |
2701 |                            |           | cf. IPOPT paper                 |
2702 +----------------------------+-----------+---------------------------------+
2703 | schur                      | OT_BOOL   | Use qpOASES Schur compliment    |
2704 |                            |           | approach                        |
2705 +----------------------------+-----------+---------------------------------+
2706 | skip_first_globalization   | OT_BOOL   | No globalization strategy in    |
2707 |                            |           | first iteration                 |
2708 +----------------------------+-----------+---------------------------------+
2709 | theta_max                  | OT_DOUBLE | Filter line search parameter,   |
2710 |                            |           | cf. IPOPT paper                 |
2711 +----------------------------+-----------+---------------------------------+
2712 | theta_min                  | OT_DOUBLE | Filter line search parameter,   |
2713 |                            |           | cf. IPOPT paper                 |
2714 +----------------------------+-----------+---------------------------------+
2715 | warmstart                  | OT_BOOL   | Use warmstarting                |
2716 +----------------------------+-----------+---------------------------------+
2717 | which_second_derv          | OT_INT    | For which block should second   |
2718 |                            |           | derivatives be provided by the  |
2719 |                            |           | user                            |
2720 +----------------------------+-----------+---------------------------------+
2721 | zeta                       | OT_DOUBLE | Feasibility restoration phase   |
2722 |                            |           | parameter                       |
2723 +----------------------------+-----------+---------------------------------+
2724 
2725 >List of available options
2726 
2727 +-------------------+---------------+-------------------+------------------+
2728 |        Id         |     Type      |    Description    |     Used in      |
2729 +===================+===============+===================+==================+
2730 | block_hess        | OT_INT        | Blockwise Hessian | casadi::Blocksqp |
2731 |                   |               | approximation?    |                  |
2732 +-------------------+---------------+-------------------+------------------+
2733 | bound_consistency | OT_BOOL       | Ensure that       | casadi::Nlpsol   |
2734 |                   |               | primal-dual       |                  |
2735 |                   |               | solution is       |                  |
2736 |                   |               | consistent with   |                  |
2737 |                   |               | the bounds        |                  |
2738 +-------------------+---------------+-------------------+------------------+
2739 | calc_f            | OT_BOOL       | Calculate 'f' in  | casadi::Nlpsol   |
2740 |                   |               | the Nlpsol base   |                  |
2741 |                   |               | class             |                  |
2742 +-------------------+---------------+-------------------+------------------+
2743 | calc_g            | OT_BOOL       | Calculate 'g' in  | casadi::Nlpsol   |
2744 |                   |               | the Nlpsol base   |                  |
2745 |                   |               | class             |                  |
2746 +-------------------+---------------+-------------------+------------------+
2747 | calc_lam_p        | OT_BOOL       | Calculate 'lam_p' | casadi::Nlpsol   |
2748 |                   |               | in the Nlpsol     |                  |
2749 |                   |               | base class        |                  |
2750 +-------------------+---------------+-------------------+------------------+
2751 | calc_lam_x        | OT_BOOL       | Calculate 'lam_x' | casadi::Nlpsol   |
2752 |                   |               | in the Nlpsol     |                  |
2753 |                   |               | base class        |                  |
2754 +-------------------+---------------+-------------------+------------------+
2755 | calc_multipliers  | OT_BOOL       | Calculate         | casadi::Nlpsol   |
2756 |                   |               | Lagrange          |                  |
2757 |                   |               | multipliers in    |                  |
2758 |                   |               | the Nlpsol base   |                  |
2759 |                   |               | class             |                  |
2760 +-------------------+---------------+-------------------+------------------+
2761 | col_eps           | OT_DOUBLE     | Epsilon for COL   | casadi::Blocksqp |
2762 |                   |               | scaling strategy  |                  |
2763 +-------------------+---------------+-------------------+------------------+
2764 | col_tau1          | OT_DOUBLE     | tau1 for COL      | casadi::Blocksqp |
2765 |                   |               | scaling strategy  |                  |
2766 +-------------------+---------------+-------------------+------------------+
2767 | col_tau2          | OT_DOUBLE     | tau2 for COL      | casadi::Blocksqp |
2768 |                   |               | scaling strategy  |                  |
2769 +-------------------+---------------+-------------------+------------------+
2770 | conv_strategy     | OT_INT        | Convexification   | casadi::Blocksqp |
2771 |                   |               | strategy          |                  |
2772 +-------------------+---------------+-------------------+------------------+
2773 | delta             | OT_DOUBLE     | Filter line       | casadi::Blocksqp |
2774 |                   |               | search parameter, |                  |
2775 |                   |               | cf. IPOPT paper   |                  |
2776 +-------------------+---------------+-------------------+------------------+
2777 | delta_h0          | OT_DOUBLE     | Filter line       | casadi::Blocksqp |
2778 |                   |               | search parameter, |                  |
2779 |                   |               | cf. IPOPT paper   |                  |
2780 +-------------------+---------------+-------------------+------------------+
2781 | discrete          | OT_BOOLVECTOR | Indicates which   | casadi::Nlpsol   |
2782 |                   |               | of the variables  |                  |
2783 |                   |               | are discrete,     |                  |
2784 |                   |               | i.e. integer-     |                  |
2785 |                   |               | valued            |                  |
2786 +-------------------+---------------+-------------------+------------------+
2787 | eps               | OT_DOUBLE     | Values smaller    | casadi::Blocksqp |
2788 |                   |               | than this are     |                  |
2789 |                   |               | regarded as       |                  |
2790 |                   |               | numerically zero  |                  |
2791 +-------------------+---------------+-------------------+------------------+
2792 | error_on_fail     | OT_BOOL       | When the          | casadi::Nlpsol   |
2793 |                   |               | numerical process |                  |
2794 |                   |               | returns           |                  |
2795 |                   |               | unsuccessfully,   |                  |
2796 |                   |               | raise an error    |                  |
2797 |                   |               | (default false).  |                  |
2798 +-------------------+---------------+-------------------+------------------+
2799 | eta               | OT_DOUBLE     | Filter line       | casadi::Blocksqp |
2800 |                   |               | search parameter, |                  |
2801 |                   |               | cf. IPOPT paper   |                  |
2802 +-------------------+---------------+-------------------+------------------+
2803 | eval_errors_fatal | OT_BOOL       | When errors occur | casadi::Nlpsol   |
2804 |                   |               | during evaluation |                  |
2805 |                   |               | of f,g,...,stop   |                  |
2806 |                   |               | the iterations    |                  |
2807 +-------------------+---------------+-------------------+------------------+
2808 | fallback_scaling  | OT_INT        | If indefinite     | casadi::Blocksqp |
2809 |                   |               | update is used,   |                  |
2810 |                   |               | the type of       |                  |
2811 |                   |               | fallback strategy |                  |
2812 +-------------------+---------------+-------------------+------------------+
2813 | fallback_update   | OT_INT        | If indefinite     | casadi::Blocksqp |
2814 |                   |               | update is used,   |                  |
2815 |                   |               | the type of       |                  |
2816 |                   |               | fallback strategy |                  |
2817 +-------------------+---------------+-------------------+------------------+
2818 | gamma_f           | OT_DOUBLE     | Filter line       | casadi::Blocksqp |
2819 |                   |               | search parameter, |                  |
2820 |                   |               | cf. IPOPT paper   |                  |
2821 +-------------------+---------------+-------------------+------------------+
2822 | gamma_theta       | OT_DOUBLE     | Filter line       | casadi::Blocksqp |
2823 |                   |               | search parameter, |                  |
2824 |                   |               | cf. IPOPT paper   |                  |
2825 +-------------------+---------------+-------------------+------------------+
2826 | globalization     | OT_BOOL       | Enable            | casadi::Blocksqp |
2827 |                   |               | globalization     |                  |
2828 +-------------------+---------------+-------------------+------------------+
2829 | hess_damp         | OT_INT        | Activate Powell   | casadi::Blocksqp |
2830 |                   |               | damping for BFGS  |                  |
2831 +-------------------+---------------+-------------------+------------------+
2832 | hess_damp_fac     | OT_DOUBLE     | Damping factor    | casadi::Blocksqp |
2833 |                   |               | for BFGS Powell   |                  |
2834 |                   |               | modification      |                  |
2835 +-------------------+---------------+-------------------+------------------+
2836 | hess_lim_mem      | OT_INT        | Full or limited   | casadi::Blocksqp |
2837 |                   |               | memory            |                  |
2838 +-------------------+---------------+-------------------+------------------+
2839 | hess_memsize      | OT_INT        | Memory size for   | casadi::Blocksqp |
2840 |                   |               | L-BFGS updates    |                  |
2841 +-------------------+---------------+-------------------+------------------+
2842 | hess_scaling      | OT_INT        | Scaling strategy  | casadi::Blocksqp |
2843 |                   |               | for Hessian       |                  |
2844 |                   |               | approximation     |                  |
2845 +-------------------+---------------+-------------------+------------------+
2846 | hess_update       | OT_INT        | Type of Hessian   | casadi::Blocksqp |
2847 |                   |               | approximation     |                  |
2848 +-------------------+---------------+-------------------+------------------+
2849 | ignore_check_vec  | OT_BOOL       | If set to true,   | casadi::Nlpsol   |
2850 |                   |               | the input shape   |                  |
2851 |                   |               | of F will not be  |                  |
2852 |                   |               | checked.          |                  |
2853 +-------------------+---------------+-------------------+------------------+
2854 | ini_hess_diag     | OT_DOUBLE     | Initial Hessian   | casadi::Blocksqp |
2855 |                   |               | guess: diagonal   |                  |
2856 |                   |               | matrix            |                  |
2857 |                   |               | diag(iniHessDiag) |                  |
2858 +-------------------+---------------+-------------------+------------------+
2859 | iteration_callbac | OT_FUNCTION   | A function that   | casadi::Nlpsol   |
2860 | k                 |               | will be called at |                  |
2861 |                   |               | each iteration    |                  |
2862 |                   |               | with the solver   |                  |
2863 |                   |               | as input. Check   |                  |
2864 |                   |               | documentation of  |                  |
2865 |                   |               | Callback .        |                  |
2866 +-------------------+---------------+-------------------+------------------+
2867 | iteration_callbac | OT_BOOL       | If set to true,   | casadi::Nlpsol   |
2868 | k_ignore_errors   |               | errors thrown by  |                  |
2869 |                   |               | iteration_callbac |                  |
2870 |                   |               | k will be         |                  |
2871 |                   |               | ignored.          |                  |
2872 +-------------------+---------------+-------------------+------------------+
2873 | iteration_callbac | OT_INT        | Only call the     | casadi::Nlpsol   |
2874 | k_step            |               | callback function |                  |
2875 |                   |               | every few         |                  |
2876 |                   |               | iterations.       |                  |
2877 +-------------------+---------------+-------------------+------------------+
2878 | kappa_f           | OT_DOUBLE     | Filter line       | casadi::Blocksqp |
2879 |                   |               | search parameter, |                  |
2880 |                   |               | cf. IPOPT paper   |                  |
2881 +-------------------+---------------+-------------------+------------------+
2882 | kappa_minus       | OT_DOUBLE     | Filter line       | casadi::Blocksqp |
2883 |                   |               | search parameter, |                  |
2884 |                   |               | cf. IPOPT paper   |                  |
2885 +-------------------+---------------+-------------------+------------------+
2886 | kappa_plus        | OT_DOUBLE     | Filter line       | casadi::Blocksqp |
2887 |                   |               | search parameter, |                  |
2888 |                   |               | cf. IPOPT paper   |                  |
2889 +-------------------+---------------+-------------------+------------------+
2890 | kappa_plus_max    | OT_DOUBLE     | Filter line       | casadi::Blocksqp |
2891 |                   |               | search parameter, |                  |
2892 |                   |               | cf. IPOPT paper   |                  |
2893 +-------------------+---------------+-------------------+------------------+
2894 | kappa_soc         | OT_DOUBLE     | Filter line       | casadi::Blocksqp |
2895 |                   |               | search parameter, |                  |
2896 |                   |               | cf. IPOPT paper   |                  |
2897 +-------------------+---------------+-------------------+------------------+
2898 | linsol            | OT_STRING     | The linear solver | casadi::Blocksqp |
2899 |                   |               | to be used by the |                  |
2900 |                   |               | QP method         |                  |
2901 +-------------------+---------------+-------------------+------------------+
2902 | max_consec_reduce | OT_INT        | Maximum number of | casadi::Blocksqp |
2903 | d_steps           |               | consecutive       |                  |
2904 |                   |               | reduced steps     |                  |
2905 +-------------------+---------------+-------------------+------------------+
2906 | max_consec_skippe | OT_INT        | Maximum number of | casadi::Blocksqp |
2907 | d_updates         |               | consecutive       |                  |
2908 |                   |               | skipped updates   |                  |
2909 +-------------------+---------------+-------------------+------------------+
2910 | max_conv_qp       | OT_INT        | How many          | casadi::Blocksqp |
2911 |                   |               | additional QPs    |                  |
2912 |                   |               | may be solved for |                  |
2913 |                   |               | convexification   |                  |
2914 |                   |               | per iteration?    |                  |
2915 +-------------------+---------------+-------------------+------------------+
2916 | max_it_qp         | OT_INT        | Maximum number of | casadi::Blocksqp |
2917 |                   |               | QP iterations per |                  |
2918 |                   |               | SQP iteration     |                  |
2919 +-------------------+---------------+-------------------+------------------+
2920 | max_iter          | OT_INT        | Maximum number of | casadi::Blocksqp |
2921 |                   |               | SQP iterations    |                  |
2922 +-------------------+---------------+-------------------+------------------+
2923 | max_line_search   | OT_INT        | Maximum number of | casadi::Blocksqp |
2924 |                   |               | steps in line     |                  |
2925 |                   |               | search            |                  |
2926 +-------------------+---------------+-------------------+------------------+
2927 | max_soc_iter      | OT_INT        | Maximum number of | casadi::Blocksqp |
2928 |                   |               | SOC line search   |                  |
2929 |                   |               | iterations        |                  |
2930 +-------------------+---------------+-------------------+------------------+
2931 | max_time_qp       | OT_DOUBLE     | Maximum number of | casadi::Blocksqp |
2932 |                   |               | time in seconds   |                  |
2933 |                   |               | per QP solve per  |                  |
2934 |                   |               | SQP iteration     |                  |
2935 +-------------------+---------------+-------------------+------------------+
2936 | min_lam           | OT_DOUBLE     | Minimum allowed   | casadi::Nlpsol   |
2937 |                   |               | multiplier value  |                  |
2938 +-------------------+---------------+-------------------+------------------+
2939 | nlinfeastol       | OT_DOUBLE     | Nonlinear         | casadi::Blocksqp |
2940 |                   |               | feasibility       |                  |
2941 |                   |               | tolerance         |                  |
2942 +-------------------+---------------+-------------------+------------------+
2943 | no_nlp_grad       | OT_BOOL       | Prevent the       | casadi::Nlpsol   |
2944 |                   |               | creation of the   |                  |
2945 |                   |               | 'nlp_grad'        |                  |
2946 |                   |               | function          |                  |
2947 +-------------------+---------------+-------------------+------------------+
2948 | obj_lo            | OT_DOUBLE     | Lower bound on    | casadi::Blocksqp |
2949 |                   |               | objective         |                  |
2950 |                   |               | function [-inf]   |                  |
2951 +-------------------+---------------+-------------------+------------------+
2952 | obj_up            | OT_DOUBLE     | Upper bound on    | casadi::Blocksqp |
2953 |                   |               | objective         |                  |
2954 |                   |               | function [inf]    |                  |
2955 +-------------------+---------------+-------------------+------------------+
2956 | opttol            | OT_DOUBLE     | Optimality        | casadi::Blocksqp |
2957 |                   |               | tolerance         |                  |
2958 +-------------------+---------------+-------------------+------------------+
2959 | oracle_options    | OT_DICT       | Options to be     | casadi::Nlpsol   |
2960 |                   |               | passed to the     |                  |
2961 |                   |               | oracle function   |                  |
2962 +-------------------+---------------+-------------------+------------------+
2963 | print_header      | OT_BOOL       | Print solver      | casadi::Blocksqp |
2964 |                   |               | header at startup |                  |
2965 +-------------------+---------------+-------------------+------------------+
2966 | print_iteration   | OT_BOOL       | Print SQP         | casadi::Blocksqp |
2967 |                   |               | iterations        |                  |
2968 +-------------------+---------------+-------------------+------------------+
2969 | print_maxit_reach | OT_BOOL       | Print error when  | casadi::Blocksqp |
2970 | ed                |               | maximum number of |                  |
2971 |                   |               | SQP iterations    |                  |
2972 |                   |               | reached           |                  |
2973 +-------------------+---------------+-------------------+------------------+
2974 | qp_init           | OT_BOOL       | Use warmstarting  | casadi::Blocksqp |
2975 +-------------------+---------------+-------------------+------------------+
2976 | qpsol             | OT_STRING     | The QP solver to  | casadi::Blocksqp |
2977 |                   |               | be used by the    |                  |
2978 |                   |               | SQP method        |                  |
2979 +-------------------+---------------+-------------------+------------------+
2980 | qpsol_options     | OT_DICT       | Options to be     | casadi::Blocksqp |
2981 |                   |               | passed to the QP  |                  |
2982 |                   |               | solver            |                  |
2983 +-------------------+---------------+-------------------+------------------+
2984 | restore_feas      | OT_BOOL       | Use feasibility   | casadi::Blocksqp |
2985 |                   |               | restoration phase |                  |
2986 +-------------------+---------------+-------------------+------------------+
2987 | rho               | OT_DOUBLE     | Feasibility       | casadi::Blocksqp |
2988 |                   |               | restoration phase |                  |
2989 |                   |               | parameter         |                  |
2990 +-------------------+---------------+-------------------+------------------+
2991 | s_f               | OT_DOUBLE     | Filter line       | casadi::Blocksqp |
2992 |                   |               | search parameter, |                  |
2993 |                   |               | cf. IPOPT paper   |                  |
2994 +-------------------+---------------+-------------------+------------------+
2995 | s_theta           | OT_DOUBLE     | Filter line       | casadi::Blocksqp |
2996 |                   |               | search parameter, |                  |
2997 |                   |               | cf. IPOPT paper   |                  |
2998 +-------------------+---------------+-------------------+------------------+
2999 | schur             | OT_BOOL       | Use qpOASES Schur | casadi::Blocksqp |
3000 |                   |               | compliment        |                  |
3001 |                   |               | approach          |                  |
3002 +-------------------+---------------+-------------------+------------------+
3003 | sens_linsol       | OT_STRING     | Linear solver     | casadi::Nlpsol   |
3004 |                   |               | used for          |                  |
3005 |                   |               | parametric        |                  |
3006 |                   |               | sensitivities     |                  |
3007 |                   |               | (default 'qr').   |                  |
3008 +-------------------+---------------+-------------------+------------------+
3009 | sens_linsol_optio | OT_DICT       | Linear solver     | casadi::Nlpsol   |
3010 | ns                |               | options used for  |                  |
3011 |                   |               | parametric        |                  |
3012 |                   |               | sensitivities.    |                  |
3013 +-------------------+---------------+-------------------+------------------+
3014 | skip_first_global | OT_BOOL       | No globalization  | casadi::Blocksqp |
3015 | ization           |               | strategy in first |                  |
3016 |                   |               | iteration         |                  |
3017 +-------------------+---------------+-------------------+------------------+
3018 | theta_max         | OT_DOUBLE     | Filter line       | casadi::Blocksqp |
3019 |                   |               | search parameter, |                  |
3020 |                   |               | cf. IPOPT paper   |                  |
3021 +-------------------+---------------+-------------------+------------------+
3022 | theta_min         | OT_DOUBLE     | Filter line       | casadi::Blocksqp |
3023 |                   |               | search parameter, |                  |
3024 |                   |               | cf. IPOPT paper   |                  |
3025 +-------------------+---------------+-------------------+------------------+
3026 | verbose_init      | OT_BOOL       | Print out timing  | casadi::Nlpsol   |
3027 |                   |               | information about |                  |
3028 |                   |               | the different     |                  |
3029 |                   |               | stages of         |                  |
3030 |                   |               | initialization    |                  |
3031 +-------------------+---------------+-------------------+------------------+
3032 | warmstart         | OT_BOOL       | Use warmstarting  | casadi::Blocksqp |
3033 +-------------------+---------------+-------------------+------------------+
3034 | warn_initial_boun | OT_BOOL       | Warn if the       | casadi::Nlpsol   |
3035 | ds                |               | initial guess     |                  |
3036 |                   |               | does not satisfy  |                  |
3037 |                   |               | LBX and UBX       |                  |
3038 +-------------------+---------------+-------------------+------------------+
3039 | which_second_derv | OT_INT        | For which block   | casadi::Blocksqp |
3040 |                   |               | should second     |                  |
3041 |                   |               | derivatives be    |                  |
3042 |                   |               | provided by the   |                  |
3043 |                   |               | user              |                  |
3044 +-------------------+---------------+-------------------+------------------+
3045 | zeta              | OT_DOUBLE     | Feasibility       | casadi::Blocksqp |
3046 |                   |               | restoration phase |                  |
3047 |                   |               | parameter         |                  |
3048 +-------------------+---------------+-------------------+------------------+
3049 
3050 Diagrams
3051 --------
3052 
3053 
3054 
3055 C++ includes: blocksqp.hpp ";
3056 
3057 %feature("docstring")  casadi::FunctionInternal::codegen_name(const
3058 CodeGenerator &g, bool ns=true) const  "
3059 
3060 [INTERNAL]  Get name in codegen.
3061 
3062 ";
3063 
3064 %feature("docstring")  casadi::ProtoFunction::format_time(char *buffer,
3065 double time) const  "
3066 
3067 [INTERNAL]  Format time in a fixed width 8 format.
3068 
3069 ";
3070 
3071 %feature("docstring")  casadi::FunctionInternal::alloc_arg(size_t sz_arg,
3072 bool persistent=false) "
3073 
3074 [INTERNAL]  Ensure required length of arg field.
3075 
3076 ";
3077 
3078 %feature("docstring")
3079 casadi::Blocksqp::secondOrderCorrection(BlocksqpMemory *m, double cNorm,
3080 double cNormTrial, double dfTdeltaXi, bool swCond, casadi_int it) const  "
3081 
3082 [INTERNAL] ";
3083 
3084 %feature("docstring")  casadi::Blocksqp::solve(void *mem) const  "
3085 
3086 [INTERNAL] ";
3087 
3088 %feature("docstring")  casadi::Blocksqp::kktErrorReduction(BlocksqpMemory
3089 *m) const  "
3090 
3091 [INTERNAL] ";
3092 
3093 %feature("docstring")  casadi::FunctionInternal::codegen_body(CodeGenerator
3094 &g) const  "
3095 
3096 [INTERNAL]  Generate code for the function body.
3097 
3098 ";
3099 
3100 %feature("docstring")  casadi::FunctionInternal::check_arg(const
3101 std::vector< M > &arg, casadi_int &npar) const  "
3102 
3103 [INTERNAL]  Check if input arguments have correct length and dimensions.
3104 
3105 Raises errors.
3106 
3107 Parameters:
3108 -----------
3109 
3110 npar[in]:  normal usage: 1, disallow pararallel calls: -1
3111 
3112 npar:  max number of horizontal repetitions across all arguments (or -1)
3113 
3114 ";
3115 
3116 %feature("docstring")  casadi::FunctionInternal::incache(const std::string
3117 &fname, Function &f, const std::string &suffix="") const  "
3118 
3119 [INTERNAL]  Get function in cache.
3120 
3121 ";
3122 
3123 %feature("docstring")  casadi::Nlpsol::setOptionsFromFile(const std::string
3124 &file) "
3125 
3126 [INTERNAL]  Read options from parameter xml.
3127 
3128 ";
3129 
3130 %feature("docstring")
3131 casadi::FunctionInternal::instruction_input(casadi_int k) const  "
3132 
3133 [INTERNAL]  Get the (integer) input arguments of an atomic operation.
3134 
3135 ";
3136 
3137 %feature("docstring")  casadi::Blocksqp::class_name() const  "
3138 
3139 [INTERNAL]  Get type name.
3140 
3141 ";
3142 
3143 %feature("docstring")
3144 casadi::Blocksqp::feasibilityRestorationPhase(BlocksqpMemory *m) const  "
3145 
3146 [INTERNAL] ";
3147 
3148 %feature("docstring")  casadi::Blocksqp::updateStepBounds(BlocksqpMemory *m,
3149 bool soc) const  "
3150 
3151 [INTERNAL] ";
3152 
3153 %feature("docstring")  casadi::FunctionInternal::getAdaptorSolverName()
3154 const  "
3155 
3156 [INTERNAL]  Obtain solver name from Adaptor.
3157 
3158 ";
3159 
3160 %feature("docstring")  casadi::FunctionInternal::ad_weight() const  "
3161 
3162 [INTERNAL]  Weighting factor for chosing forward/reverse mode.
3163 
3164 ";
3165 
3166 %feature("docstring")  casadi::FunctionInternal::index_in(const std::string
3167 &name) const  "
3168 
3169 [INTERNAL]  Get input scheme index by name.
3170 
3171 ";
3172 
3173 %feature("docstring")  casadi::Blocksqp::filterLineSearch(BlocksqpMemory *m)
3174 const  "
3175 
3176 [INTERNAL] ";
3177 
3178 %feature("docstring")  casadi::FunctionInternal::instruction_MX(casadi_int
3179 k) const  "
3180 
3181 [INTERNAL]  get MX expression associated with instruction
3182 
3183 ";
3184 
3185 %feature("docstring")  casadi::FunctionInternal::size2_out(casadi_int ind)
3186 const  "
3187 
3188 [INTERNAL]  Input/output dimensions.
3189 
3190 ";
3191 
3192 %feature("docstring")  casadi::FunctionInternal::mx_in(casadi_int ind) const
3193 "
3194 
3195 [INTERNAL]  Get function input(s) and output(s)
3196 
3197 ";
3198 
3199 %feature("docstring")  casadi::FunctionInternal::mx_in() const  "
3200 
3201 [INTERNAL]  Get function input(s) and output(s)
3202 
3203 ";
3204 
3205 %feature("docstring")  casadi::FunctionInternal::get_partition(casadi_int
3206 iind, casadi_int oind, Sparsity &D1, Sparsity &D2, bool compact, bool
3207 symmetric, bool allow_forward, bool allow_reverse) const  "
3208 
3209 [INTERNAL]  Get the unidirectional or bidirectional partition.
3210 
3211 ";
3212 
3213 %feature("docstring")  casadi::Blocksqp::calcOptTol(BlocksqpMemory *m) const
3214 "
3215 
3216 [INTERNAL]  Update optimization tolerance (similar to SNOPT) in current
3217 iterate.
3218 
3219 ";
3220 
3221 %feature("docstring")  casadi::FunctionInternal::mapsum_mx(const
3222 std::vector< MX > &arg, const std::string &parallelization) "
3223 
3224 [INTERNAL]  Parallel evaluation.
3225 
3226 ";
3227 
3228 %feature("docstring")  casadi::Blocksqp::calcInitialHessian(BlocksqpMemory
3229 *m) const  "
3230 
3231 [INTERNAL] ";
3232 
3233 %feature("docstring")  casadi::Blocksqp::calcInitialHessian(BlocksqpMemory
3234 *m, casadi_int b) const  "
3235 
3236 [INTERNAL] ";
3237 
3238 %feature("docstring")  casadi::FunctionInternal::replace_aseed(const
3239 std::vector< std::vector< M >> &aseed, casadi_int npar) const  "
3240 
3241 [INTERNAL]  Replace 0-by-0 reverse seeds.
3242 
3243 ";
3244 
3245 %feature("docstring")  casadi::FunctionInternal::replace_aseed(const
3246 std::vector< std::vector< M > > &aseed, casadi_int npar) const  "
3247 
3248 [INTERNAL] ";
3249 
3250 %feature("docstring")  casadi::FunctionInternal::get_reltol() const  "
3251 
3252 [INTERNAL]  Get relative tolerance.
3253 
3254 ";
3255 
3256 %feature("docstring")  casadi::FunctionInternal::check_mat(const Sparsity
3257 &arg, const Sparsity &inp, casadi_int &npar) "
3258 
3259 [INTERNAL]  Helper function
3260 
3261 Parameters:
3262 -----------
3263 
3264 npar[in]:  normal usage: 1, disallow pararallel calls: -1
3265 
3266 npar[out]:  required number of parallel calls (or -1)
3267 
3268 ";
3269 
3270 %feature("docstring")  casadi::FunctionInternal::call(const std::vector< M >
3271 &arg, std::vector< M > &res, bool always_inline, bool never_inline) const  "
3272 
3273 [INTERNAL]   Call a function, templated.
3274 
3275 ";
3276 
3277 %feature("docstring")  casadi::Blocksqp::augmentFilter(BlocksqpMemory *m,
3278 double cNorm, double obj) const  "
3279 
3280 [INTERNAL] ";
3281 
3282 %feature("docstring")  casadi::Blocksqp::serialize_body(SerializingStream
3283 &s) const  "
3284 
3285 [INTERNAL]  Serialize an object without type information.
3286 
3287 ";
3288 
3289 %feature("docstring")  casadi::FunctionInternal::numel_out(casadi_int ind)
3290 const  "
3291 
3292 [INTERNAL]  Number of input/output elements.
3293 
3294 ";
3295 
3296 %feature("docstring")  casadi::FunctionInternal::numel_out() const  "
3297 
3298 [INTERNAL]  Number of input/output elements.
3299 
3300 ";
3301 
3302 %feature("docstring")  casadi::FunctionInternal::size2_in(casadi_int ind)
3303 const  "
3304 
3305 [INTERNAL]  Input/output dimensions.
3306 
3307 ";
3308 
3309 %feature("docstring")  casadi::Nlpsol::integer_support() const  "
3310 
3311 [INTERNAL]  Can discrete variables be treated.
3312 
3313 ";
3314 
3315 %feature("docstring")  casadi::Nlpsol::get_name_in(casadi_int i)  "
3316 
3317 [INTERNAL]  Names of function input and outputs.
3318 
3319 ";
3320 
3321 %feature("docstring")
3322 casadi::Blocksqp::calcHessianUpdateLimitedMemory(BlocksqpMemory *m,
3323 casadi_int updateType, casadi_int hessScaling) const  "
3324 
3325 [INTERNAL] ";
3326 
3327 %feature("docstring")  casadi::Nlpsol::uses_output() const  "
3328 
3329 [INTERNAL]  Do the derivative functions need nondifferentiated outputs?
3330 
3331 ";
3332 
3333 %feature("docstring")  casadi::FunctionInternal::has_eval_dm() const  "
3334 
3335 [INTERNAL]  Evaluate with DM matrices.
3336 
3337 ";
3338 
3339 %feature("docstring")  casadi::Nlpsol::eval(const double **arg, double
3340 **res, casadi_int *iw, double *w, void *mem) const final "
3341 
3342 [INTERNAL]  Evaluate numerically.
3343 
3344 ";
3345 
3346 %feature("docstring")  casadi::FunctionInternal::sp_weight() const  "
3347 
3348 [INTERNAL]  Weighting factor for chosing forward/reverse mode, sparsity
3349 propagation.
3350 
3351 ";
3352 
3353 %feature("docstring")  casadi::FunctionInternal::instruction_id(casadi_int
3354 k) const  "
3355 
3356 [INTERNAL]  Get an atomic operation operator index.
3357 
3358 ";
3359 
3360 %feature("docstring")  casadi::FunctionInternal::symbolicAdjSeed(casadi_int
3361 nadj, const std::vector< MatType > &v) const  "
3362 
3363 [INTERNAL]  Symbolic expressions for the adjoint seeds.
3364 
3365 ";
3366 
3367 %feature("docstring")  casadi::FunctionInternal::alloc_iw(size_t sz_iw, bool
3368 persistent=false) "
3369 
3370 [INTERNAL]  Ensure required length of iw field.
3371 
3372 ";
3373 
3374 %feature("docstring")  casadi::FunctionInternal::map(casadi_int n, const
3375 std::string &parallelization) const  "
3376 
3377 [INTERNAL]  Generate/retrieve cached serial map.
3378 
3379 ";
3380 
3381 %feature("docstring")  casadi::FunctionInternal::sz_iw() const  "
3382 
3383 [INTERNAL]  Get required length of iw field.
3384 
3385 ";
3386 
3387 %feature("docstring")  casadi::FunctionInternal::reverse(casadi_int nadj)
3388 const  "
3389 
3390 [INTERNAL]  Return function that calculates adjoint derivatives
3391 reverse(nadj) returns a cached instance if available, and calls  Function
3392 get_reverse(casadi_int nadj) if no cached version is available.
3393 
3394 ";
3395 
3396 %feature("docstring")  casadi::SharedObjectInternal::getCount() const  "
3397 
3398 [INTERNAL]  Get the reference count.
3399 
3400 ";
3401 
3402 %feature("docstring")  casadi::FunctionInternal::alloc(const Function &f,
3403 bool persistent=false) "
3404 
3405 [INTERNAL]  Ensure work vectors long enough to evaluate function.
3406 
3407 ";
3408 
3409 %feature("docstring")  casadi::Blocksqp::initIterate(BlocksqpMemory *m)
3410 const  "
3411 
3412 [INTERNAL]  Set initial filter, objective function, tolerances etc.
3413 
3414 ";
3415 
3416 %feature("docstring")  casadi::FunctionInternal::jac() const  "
3417 
3418 [INTERNAL]  Return Jacobian of all input elements with respect to all output
3419 elements.
3420 
3421 ";
3422 
3423 %feature("docstring")  casadi::FunctionInternal::has_jacobian_sparsity()
3424 const  "
3425 
3426 [INTERNAL]  Get Jacobian sparsity.
3427 
3428 ";
3429 
3430 %feature("docstring")  casadi::FunctionInternal::call_reverse(const
3431 std::vector< MX > &arg, const std::vector< MX > &res, const std::vector<
3432 std::vector< MX > > &aseed, std::vector< std::vector< MX > > &asens, bool
3433 always_inline, bool never_inline) const  "
3434 
3435 [INTERNAL]  Reverse mode, virtual functions overloaded in derived classes.
3436 
3437 ";
3438 
3439 %feature("docstring")  casadi::FunctionInternal::call_reverse(const
3440 std::vector< SX > &arg, const std::vector< SX > &res, const std::vector<
3441 std::vector< SX > > &aseed, std::vector< std::vector< SX > > &asens, bool
3442 always_inline, bool never_inline) const  "
3443 
3444 [INTERNAL]  Reverse mode, virtual functions overloaded in derived classes.
3445 
3446 ";
3447 
3448 %feature("docstring")
3449 casadi::FunctionInternal::codegen_init_mem(CodeGenerator &g) const  "
3450 
3451 [INTERNAL]  Codegen decref for init_mem.
3452 
3453 ";
3454 
3455 %feature("docstring")  casadi::ProtoFunction::print_time(const std::map<
3456 std::string, FStats > &fstats) const  "
3457 
3458 [INTERNAL]  Print timing statistics.
3459 
3460 ";
3461 
3462 %feature("docstring")  casadi::Nlpsol::serialize_base_function() const  "
3463 
3464 [INTERNAL]  String used to identify the immediate FunctionInternal subclass.
3465 
3466 ";
3467 
3468 %feature("docstring")  casadi::FunctionInternal::nz_out(const std::vector<
3469 DM > &res) const  "
3470 
3471 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
3472 
3473 ";
3474 
3475 %feature("docstring")  casadi::FunctionInternal::nz_out(const std::vector<
3476 double > &res) const  "
3477 
3478 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
3479 
3480 ";
3481 
3482 %feature("docstring")  casadi::FunctionInternal::get_jacobian(const
3483 std::string &name, const std::vector< std::string > &inames, const
3484 std::vector< std::string > &onames, const Dict &opts) const  "
3485 
3486 [INTERNAL]  Return Jacobian of all input elements with respect to all output
3487 elements.
3488 
3489 ";
3490 
3491 %feature("docstring")  casadi::FunctionInternal::eval_gen(const double
3492 **arg, double **res, casadi_int *iw, double *w, void *mem) const  "
3493 
3494 [INTERNAL]  Evaluate numerically.
3495 
3496 ";
3497 
3498 %feature("docstring")  casadi::FunctionInternal::eval_gen(const SXElem
3499 **arg, SXElem **res, casadi_int *iw, SXElem *w, void *mem) const  "
3500 
3501 [INTERNAL]  Evaluate a function, overloaded.
3502 
3503 ";
3504 
3505 %feature("docstring")  casadi::FunctionInternal::eval_gen(const bvec_t
3506 **arg, bvec_t **res, casadi_int *iw, bvec_t *w, void *mem) const  "
3507 
3508 [INTERNAL]  Evaluate a function, overloaded.
3509 
3510 ";
3511 
3512 %feature("docstring")  casadi::FunctionInternal::dm_out(casadi_int ind)
3513 const  "
3514 
3515 [INTERNAL]  Get function input(s) and output(s)
3516 
3517 ";
3518 
3519 %feature("docstring")  casadi::FunctionInternal::dm_out() const  "
3520 
3521 [INTERNAL]  Get function input(s) and output(s)
3522 
3523 ";
3524 
3525 %feature("docstring")  casadi::Blocksqp::sizeInitialHessian(BlocksqpMemory
3526 *m, const double *gamma, const double *delta, casadi_int b, casadi_int
3527 option) const  "
3528 
3529 [INTERNAL] ";
3530 
3531 %feature("docstring")  casadi::FunctionInternal::codegen_mem_type() const  "
3532 
3533 [INTERNAL]  Thread-local memory object type.
3534 
3535 ";
3536 
3537 %feature("docstring")  casadi::Blocksqp::set_work(void *mem, const double
3538 **&arg, double **&res, casadi_int *&iw, double *&w) const  "
3539 
3540 [INTERNAL]  Set the (persistent) work vectors.
3541 
3542 ";
3543 
3544 %feature("docstring")  casadi::FunctionInternal::self() const  "
3545 
3546 [INTERNAL]  Get a public class instance.
3547 
3548 ";
3549 
3550 %feature("docstring")  casadi::Nlpsol::get_n_out()  "
3551 
3552 [INTERNAL]  Number of function inputs and outputs.
3553 
3554 ";
3555 
3556 %feature("docstring")  casadi::FunctionInternal::get_jacobian_sparsity()
3557 const  "
3558 
3559 [INTERNAL]  Get Jacobian sparsity.
3560 
3561 ";
3562 
3563 %feature("docstring")
3564 casadi::FunctionInternal::codegen_free_mem(CodeGenerator &g) const  "
3565 
3566 [INTERNAL]  Codegen for free_mem.
3567 
3568 ";
3569 
3570 %feature("docstring")  casadi::FunctionInternal::signature(const std::string
3571 &fname) const  "
3572 
3573 [INTERNAL]  Code generate the function.
3574 
3575 ";
3576 
3577 %feature("docstring")  casadi::FunctionInternal::replace_arg(const
3578 std::vector< M > &arg, casadi_int npar) const  "
3579 
3580 [INTERNAL]  Replace 0-by-0 inputs.
3581 
3582 ";
3583 
3584 %feature("docstring")  casadi::FunctionInternal::instructions_sx() const  "
3585 
3586 [INTERNAL]  get SX expression associated with instructions
3587 
3588 ";
3589 
3590 %feature("docstring")  casadi::FunctionInternal::tocache(const Function &f,
3591 const std::string &suffix="") const  "
3592 
3593 [INTERNAL]  Save function to cache.
3594 
3595 ";
3596 
3597 %feature("docstring")  casadi::FunctionInternal::sz_arg() const  "
3598 
3599 [INTERNAL]  Get required length of arg field.
3600 
3601 ";
3602 
3603 %feature("docstring")  casadi::SharedObjectInternal::weak() "
3604 
3605 [INTERNAL]  Get a weak reference to the object.
3606 
3607 ";
3608 
3609 %feature("docstring")  casadi::FunctionInternal::has_jacobian() const  "
3610 
3611 [INTERNAL]  Return Jacobian of all input elements with respect to all output
3612 elements.
3613 
3614 ";
3615 
3616 %feature("docstring")  casadi::FunctionInternal::slice(const std::string
3617 &name, const std::vector< casadi_int > &order_in, const std::vector<
3618 casadi_int > &order_out, const Dict &opts) const  "
3619 
3620 [INTERNAL]  returns a new function with a selection of inputs/outputs of the
3621 original
3622 
3623 ";
3624 
3625 %feature("docstring")  casadi::Nlpsol::get_default_in(casadi_int ind) const
3626 "
3627 
3628 [INTERNAL]  Get default input value.
3629 
3630 ";
3631 
3632 %feature("docstring")  casadi::Blocksqp::init(const Dict &opts)  "
3633 
3634 [INTERNAL]  Initialize.
3635 
3636 ";
3637 
3638 %feature("docstring")  casadi::Blocksqp::initStats(BlocksqpMemory *m) const
3639 "
3640 
3641 [INTERNAL] ";
3642 
3643 %feature("docstring")  casadi::Blocksqp::printInfo(BlocksqpMemory *m) const
3644 "
3645 
3646 [INTERNAL]  Print information about the SQP method.
3647 
3648 ";
3649 
3650 %feature("docstring")
3651 casadi::FunctionInternal::print_dimensions(std::ostream &stream) const  "
3652 
3653 [INTERNAL]  Print dimensions of inputs and outputs.
3654 
3655 ";
3656 
3657 %feature("docstring")
3658 casadi::FunctionInternal::getJacSparsityGen(casadi_int iind, casadi_int
3659 oind, bool symmetric, casadi_int gr_i=1, casadi_int gr_o=1) const  "
3660 
3661 [INTERNAL]  Get the sparsity pattern, forward mode.
3662 
3663 ";
3664 
3665 %feature("docstring")  casadi::FunctionInternal::which_depends(const
3666 std::string &s_in, const std::vector< std::string > &s_out, casadi_int
3667 order, bool tr=false) const  "
3668 
3669 [INTERNAL]  Which variables enter with some order.
3670 
3671 Parameters:
3672 -----------
3673 
3674 s_in:   Input name
3675 
3676 s_out:   Output name(s)
3677 
3678 order:  Only 1 (linear) and 2 (nonlinear) allowed
3679 
3680 tr:  Flip the relationship. Return which expressions contain the variables
3681 
3682 ";
3683 
3684 %feature("docstring")
3685 casadi::FunctionInternal::getJacSparsityHierarchicalSymm(casadi_int iind,
3686 casadi_int oind) const  "
3687 
3688 [INTERNAL]  A flavor of getJacSparsity that does hierarchical block
3689 structure recognition for symmetric Jacobians
3690 
3691 ";
3692 
3693 %feature("docstring")  casadi::Blocksqp::run(BlocksqpMemory *m, casadi_int
3694 maxIt, casadi_int warmStart=0) const  "
3695 
3696 [INTERNAL]  Main Loop of SQP method.
3697 
3698 ";
3699 
3700 %feature("docstring")  casadi::FunctionInternal::free_sx() const  "
3701 
3702 [INTERNAL]  Get free variables (SX)
3703 
3704 ";
3705 
3706 %feature("docstring")
3707 casadi::Blocksqp::calcHessianUpdateExact(BlocksqpMemory *m) const  "
3708 
3709 [INTERNAL] ";
3710 
3711 %feature("docstring")  casadi::Blocksqp::reduceSOCStepsize(BlocksqpMemory
3712 *m, double *alphaSOC) const  "
3713 
3714 [INTERNAL] ";
3715 
3716 %feature("docstring")  casadi::FunctionInternal::nnz_in() const  "
3717 
3718 [INTERNAL]  Number of input/output nonzeros.
3719 
3720 ";
3721 
3722 %feature("docstring")  casadi::FunctionInternal::nnz_in(casadi_int ind)
3723 const  "
3724 
3725 [INTERNAL]  Number of input/output nonzeros.
3726 
3727 ";
3728 
3729 %feature("docstring")  casadi::FunctionInternal::get_min_in(casadi_int ind)
3730 const  "
3731 
3732 [INTERNAL]  Get smallest input value.
3733 
3734 ";
3735 
3736 %feature("docstring")  casadi::FunctionInternal::project_arg(const
3737 std::vector< M > &arg, casadi_int npar) const  "
3738 
3739 [INTERNAL]   Project sparsities.
3740 
3741 ";
3742 
3743 %feature("docstring")  casadi::FunctionInternal::replace_fseed(const
3744 std::vector< std::vector< M >> &fseed, casadi_int npar) const  "
3745 
3746 [INTERNAL]  Replace 0-by-0 forward seeds.
3747 
3748 ";
3749 
3750 %feature("docstring")  casadi::FunctionInternal::replace_fseed(const
3751 std::vector< std::vector< M > > &fseed, casadi_int npar) const  "
3752 
3753 [INTERNAL] ";
3754 
3755 %feature("docstring")  casadi::Blocksqp::free_mem(void *mem) const  "
3756 
3757 [INTERNAL]  Free memory block.
3758 
3759 ";
3760 
3761 %feature("docstring")  casadi::FunctionInternal::has_free() const  "
3762 
3763 [INTERNAL]  Does the function have free variables.
3764 
3765 ";
3766 
3767 %feature("docstring")  casadi::Blocksqp::updateDeltaGamma(BlocksqpMemory *m)
3768 const  "
3769 
3770 [INTERNAL] ";
3771 
3772 %feature("docstring")  casadi::FunctionInternal::generate_in(const
3773 std::string &fname, const double **arg) const  "
3774 
3775 [INTERNAL]  Export an input file that can be passed to generate C code with
3776 a main.
3777 
3778 ";
3779 
3780 %feature("docstring")  casadi::ProtoFunction::serialize(SerializingStream
3781 &s) const  "
3782 
3783 [INTERNAL]  Serialize an object.
3784 
3785 ";
3786 
3787 %feature("docstring")  casadi::FunctionInternal::free_mx() const  "
3788 
3789 [INTERNAL]  Get free variables ( MX)
3790 
3791 ";
3792 
3793 %feature("docstring")  casadi::FunctionInternal::jacobian_sparsity() const
3794 "
3795 
3796 [INTERNAL]  Get Jacobian sparsity.
3797 
3798 ";
3799 
3800 %feature("docstring")
3801 casadi::FunctionInternal::instruction_output(casadi_int k) const  "
3802 
3803 [INTERNAL]  Get the (integer) output argument of an atomic operation.
3804 
3805 ";
3806 
3807 %feature("docstring")  casadi::OracleFunction::oracle() const  "
3808 
3809 [INTERNAL]  Get oracle.
3810 
3811 ";
3812 
3813 %feature("docstring")  casadi::ProtoFunction::release(int mem) const  "
3814 
3815 [INTERNAL]  Release a memory object.
3816 
3817 ";
3818 
3819 %feature("docstring")  casadi::OracleFunction::jit_dependencies(const
3820 std::string &fname)  "
3821 
3822 [INTERNAL]  JIT for dependencies.
3823 
3824 ";
3825 
3826 %feature("docstring")  casadi::FunctionInternal::size_out(casadi_int ind)
3827 const  "
3828 
3829 [INTERNAL]  Input/output dimensions.
3830 
3831 ";
3832 
3833 %feature("docstring")  casadi::ProtoFunction::print(const char *fmt,...)
3834 const  "
3835 
3836 [INTERNAL]  C-style formatted printing during evaluation.
3837 
3838 ";
3839 
3840 %feature("docstring")  casadi::FunctionInternal::fwdViaJac(casadi_int nfwd)
3841 const  "
3842 
3843 [INTERNAL]  Calculate derivatives by multiplying the full Jacobian and
3844 multiplying.
3845 
3846 ";
3847 
3848 %feature("docstring")
3849 casadi::FunctionInternal::codegen_declarations(CodeGenerator &g) const  "
3850 
3851 [INTERNAL]  Generate code for the declarations of the C function.
3852 
3853 ";
3854 
3855 %feature("docstring")  casadi::OracleFunction::generate_dependencies(const
3856 std::string &fname, const Dict &opts) const  "
3857 
3858 [INTERNAL]  Export / Generate C code for the generated functions.
3859 
3860 ";
3861 
3862 %feature("docstring")  casadi::FunctionInternal::sx_in(casadi_int ind) const
3863 "
3864 
3865 [INTERNAL]  Get function input(s) and output(s)
3866 
3867 ";
3868 
3869 %feature("docstring")  casadi::FunctionInternal::sx_in() const  "
3870 
3871 [INTERNAL]  Get function input(s) and output(s)
3872 
3873 ";
3874 
3875 %feature("docstring")  casadi::Blocksqp::calcSR1(BlocksqpMemory *m, const
3876 double *gamma, const double *delta, casadi_int b) const  "
3877 
3878 [INTERNAL] ";
3879 
3880 %feature("docstring")  casadi::FunctionInternal::symbolic_output(const
3881 std::vector< MX > &arg) const  "
3882 
3883 [INTERNAL]  Get a vector of symbolic variables corresponding to the outputs.
3884 
3885 ";
3886 
3887 %feature("docstring")  casadi::Nlpsol::serialize_type(SerializingStream &s)
3888 const  "
3889 
3890 [INTERNAL]  Serialize type information.
3891 
3892 ";
3893 
3894 %feature("docstring")  casadi::FunctionInternal::definition() const  "
3895 
3896 [INTERNAL]  Get function signature: name:(inputs)->(outputs)
3897 
3898 ";
3899 
3900 %feature("docstring")  casadi::FunctionInternal::has_derivative() const  "
3901 
3902 [INTERNAL]  Can derivatives be calculated in any way?
3903 
3904 ";
3905 
3906 %feature("docstring")
3907 casadi::FunctionInternal::jacobian_sparsity_filter(const Sparsity &sp) const
3908 "
3909 
3910 [INTERNAL]  Filter out nonzeros in the full sparsity jacobian according to
3911 is_diff_in/out.
3912 
3913 ";
3914 
3915 %feature("docstring")
3916 casadi::FunctionInternal::codegen_incref(CodeGenerator &g) const  "
3917 
3918 [INTERNAL]  Codegen incref for dependencies.
3919 
3920 ";
3921 
3922 %feature("docstring")  casadi::FunctionInternal::sparsity_out(casadi_int
3923 ind) const  "
3924 
3925 [INTERNAL]  Input/output sparsity.
3926 
3927 ";
3928 
3929 %feature("docstring")  casadi::FunctionInternal::matching_arg(const
3930 std::vector< M > &arg, casadi_int &npar) const  "
3931 
3932 [INTERNAL]  Check if input arguments that needs to be replaced.
3933 
3934 Raises errors
3935 
3936 Parameters:
3937 -----------
3938 
3939 npar[in]:  normal usage: 1, disallow pararallel calls: -1
3940 
3941 npar:  max number of horizontal repetitions across all arguments (or -1)
3942 
3943 ";
3944 
3945 %feature("docstring")  casadi::FunctionInternal::factory(const std::string
3946 &name, const std::vector< std::string > &s_in, const std::vector<
3947 std::string > &s_out, const Function::AuxOut &aux, const Dict &opts) const
3948 "
3949 
3950 [INTERNAL] ";
3951 
3952 %feature("docstring")  casadi::FunctionInternal::getJacSparsity(casadi_int
3953 iind, casadi_int oind, bool symmetric) const  "
3954 
3955 [INTERNAL]  Generate the sparsity of a Jacobian block.
3956 
3957 ";
3958 
3959 %feature("docstring")
3960 casadi::FunctionInternal::codegen_alloc_mem(CodeGenerator &g) const  "
3961 
3962 [INTERNAL]  Codegen decref for alloc_mem.
3963 
3964 ";
3965 
3966 %feature("docstring")  casadi::FunctionInternal::forward(casadi_int nfwd)
3967 const  "
3968 
3969 [INTERNAL]  Return function that calculates forward derivatives
3970 forward(nfwd) returns a cached instance if available, and calls  Function
3971 get_forward(casadi_int nfwd) if no cached version is available.
3972 
3973 ";
3974 
3975 %feature("docstring")  casadi::FunctionInternal::convert_res(const
3976 std::vector< M > &res) const  "
3977 
3978 [INTERNAL]  Convert from/to input/output lists/map.
3979 
3980 ";
3981 
3982 %feature("docstring")  casadi::FunctionInternal::convert_res(const std::map<
3983 std::string, M > &res) const  "
3984 
3985 [INTERNAL]  Convert from/to input/output lists/map.
3986 
3987 ";
3988 
3989 %feature("docstring")  casadi::Blocksqp::solveQP(BlocksqpMemory *m, double
3990 *deltaXi, double *lambdaQP, bool matricesChanged=true) const  "
3991 
3992 [INTERNAL] ";
3993 
3994 %feature("docstring")  casadi::Nlpsol::is_a(const std::string &type, bool
3995 recursive) const  "
3996 
3997 [INTERNAL]  Check if the function is of a particular type.
3998 
3999 ";
4000 
4001 %feature("docstring")  casadi::Nlpsol::get_stats(void *mem) const  "
4002 
4003 [INTERNAL]  Get all statistics.
4004 
4005 ";
4006 
4007 %feature("docstring")  casadi::FunctionInternal::generate_lifted(Function
4008 &vdef_fcn, Function &vinit_fcn) const  "
4009 
4010 [INTERNAL]  Extract the functions needed for the Lifted Newton method.
4011 
4012 ";
4013 
4014 %feature("docstring")  casadi::Blocksqp::reduceStepsize(BlocksqpMemory *m,
4015 double *alpha) const  "
4016 
4017 [INTERNAL] ";
4018 
4019 %feature("docstring")  casadi::FunctionInternal::sx_out(casadi_int ind)
4020 const  "
4021 
4022 [INTERNAL]  Get function input(s) and output(s)
4023 
4024 ";
4025 
4026 %feature("docstring")  casadi::FunctionInternal::sx_out() const  "
4027 
4028 [INTERNAL]  Get function input(s) and output(s)
4029 
4030 ";
4031 
4032 %feature("docstring")  casadi::Blocksqp::lInfConstraintNorm(BlocksqpMemory
4033 *m, const double *xk, const double *g) const  "
4034 
4035 [INTERNAL] ";
4036 
4037 %feature("docstring")  casadi::FunctionInternal::print_options(std::ostream
4038 &stream) const  "
4039 
4040 [INTERNAL]  Print list of options.
4041 
4042 ";
4043 
4044 %feature("docstring")  casadi::FunctionInternal::size1_out(casadi_int ind)
4045 const  "
4046 
4047 [INTERNAL]  Input/output dimensions.
4048 
4049 ";
4050 
4051 %feature("docstring")  casadi::FunctionInternal::index_out(const std::string
4052 &name) const  "
4053 
4054 [INTERNAL]  Get output scheme index by name.
4055 
4056 ";
4057 
4058 %feature("docstring")  casadi::FunctionInternal::numel_in() const  "
4059 
4060 [INTERNAL]  Number of input/output elements.
4061 
4062 ";
4063 
4064 %feature("docstring")  casadi::FunctionInternal::numel_in(casadi_int ind)
4065 const  "
4066 
4067 [INTERNAL]  Number of input/output elements.
4068 
4069 ";
4070 
4071 %feature("docstring")  casadi::Blocksqp::calcLagrangeGradient(BlocksqpMemory
4072 *m, const double *lam_x, const double *lam_g, const double *grad_f, const
4073 double *jacNz, double *grad_lag, casadi_int flag) const  "
4074 
4075 [INTERNAL]  Compute gradient of Lagrangian function (sparse version)
4076 
4077 ";
4078 
4079 %feature("docstring")  casadi::Blocksqp::calcLagrangeGradient(BlocksqpMemory
4080 *m, double *grad_lag, casadi_int flag) const  "
4081 
4082 [INTERNAL]  Overloaded function for convenience, uses current variables of
4083 SQPiterate vars.
4084 
4085 ";
4086 
4087 %feature("docstring")  casadi::FunctionInternal::eval_sx(const SXElem **arg,
4088 SXElem **res, casadi_int *iw, SXElem *w, void *mem) const  "
4089 
4090 [INTERNAL]  Evaluate with symbolic scalars.
4091 
4092 ";
4093 
4094 %feature("docstring")  casadi::FunctionInternal::get_abstol() const  "
4095 
4096 [INTERNAL]  Get absolute tolerance.
4097 
4098 ";
4099 
4100 %feature("docstring")  casadi::Blocksqp::init_mem(void *mem) const  "
4101 
4102 [INTERNAL]  Initalize memory block.
4103 
4104 ";
4105 
4106 %feature("docstring")  casadi::FunctionInternal::info() const  "
4107 
4108 [INTERNAL]  Obtain information about function
4109 
4110 ";
4111 
4112 %feature("docstring")  casadi::FunctionInternal::has_jac() const  "
4113 
4114 [INTERNAL]  Return Jacobian of all input elements with respect to all output
4115 elements.
4116 
4117 ";
4118 
4119 %feature("docstring")  casadi::FunctionInternal::export_code(const
4120 std::string &lang, std::ostream &stream, const Dict &options) const  "
4121 
4122 [INTERNAL]  Export function in a specific language.
4123 
4124 ";
4125 
4126 %feature("docstring")  casadi::FunctionInternal::size1_in(casadi_int ind)
4127 const  "
4128 
4129 [INTERNAL]  Input/output dimensions.
4130 
4131 ";
4132 
4133 %feature("docstring")  casadi::FunctionInternal::nnz_out() const  "
4134 
4135 [INTERNAL]  Number of input/output nonzeros.
4136 
4137 ";
4138 
4139 %feature("docstring")  casadi::FunctionInternal::nnz_out(casadi_int ind)
4140 const  "
4141 
4142 [INTERNAL]  Number of input/output nonzeros.
4143 
4144 ";
4145 
4146 %feature("docstring")  casadi::FunctionInternal::sparsity_in(casadi_int ind)
4147 const  "
4148 
4149 [INTERNAL]  Input/output sparsity.
4150 
4151 ";
4152 
4153 %feature("docstring")  casadi::Nlpsol::get_reverse(casadi_int nadj, const
4154 std::string &name, const std::vector< std::string > &inames, const
4155 std::vector< std::string > &onames, const Dict &opts) const  "
4156 
4157 [INTERNAL]  Generate a function that calculates reverse mode derivatives.
4158 
4159 ";
4160 
4161 %feature("docstring")  casadi::FunctionInternal::get_max_in(casadi_int ind)
4162 const  "
4163 
4164 [INTERNAL]  Get largest input value.
4165 
4166 ";
4167 
4168 %feature("docstring")  casadi::OracleFunction::set_temp(void *mem, const
4169 double **arg, double **res, casadi_int *iw, double *w) const  "
4170 
4171 [INTERNAL]  Set the work vectors.
4172 
4173 ";
4174 
4175 %feature("docstring")  casadi::Blocksqp::acceptStep(BlocksqpMemory *m, const
4176 double *deltaXi, const double *lambdaQP, double alpha, casadi_int nSOCS)
4177 const  "
4178 
4179 [INTERNAL]  Set new primal dual iterate.
4180 
4181 ";
4182 
4183 %feature("docstring")  casadi::Blocksqp::acceptStep(BlocksqpMemory *m,
4184 double alpha) const  "
4185 
4186 [INTERNAL] ";
4187 
4188 %feature("docstring")
4189 casadi::Blocksqp::feasibilityRestorationHeuristic(BlocksqpMemory *m) const
4190 "
4191 
4192 [INTERNAL] ";
4193 
4194 %feature("docstring")  casadi::FunctionInternal::print_option(const
4195 std::string &name, std::ostream &stream) const  "
4196 
4197 [INTERNAL]  Print all information there is to know about a certain option.
4198 
4199 ";
4200 
4201 %feature("docstring")  casadi::Nlpsol::get_sparsity_out(casadi_int i)  "
4202 
4203 [INTERNAL]  Sparsities of function inputs and outputs.
4204 
4205 ";
4206 
4207 %feature("docstring")  casadi::OracleFunction::create_function(const
4208 std::string &fname, const std::vector< std::string > &s_in, const
4209 std::vector< std::string > &s_out, const Function::AuxOut
4210 &aux=Function::AuxOut()) "
4211 
4212 [INTERNAL]  Create an oracle function
4213 
4214 ";
4215 
4216 %feature("docstring")  casadi::OracleFunction::calc_function(OracleMemory
4217 *m, const std::string &fcn, const double *const *arg=nullptr) const  "
4218 
4219 [INTERNAL] ";
4220 
4221 %feature("docstring")  casadi::FunctionInternal::eval_dm(const std::vector<
4222 DM > &arg) const  "
4223 
4224 [INTERNAL]  Evaluate with DM matrices.
4225 
4226 ";
4227 
4228 %feature("docstring")  casadi::OracleFunction::monitored(const std::string
4229 &name) const  "
4230 
4231 [INTERNAL] ";
4232 
4233 %feature("docstring")  casadi::FunctionInternal::codegen_meta(CodeGenerator
4234 &g) const  "
4235 
4236 [INTERNAL]  Generate meta-information allowing a user to evaluate a
4237 generated function.
4238 
4239 ";
4240 
4241 %feature("docstring")  casadi::Blocksqp::convertHessian(BlocksqpMemory *m)
4242 const  "
4243 
4244 [INTERNAL]  Convert *hess to column compressed sparse format.
4245 
4246 ";
4247 
4248 %feature("docstring")  casadi::Blocksqp::updateStats(BlocksqpMemory *m)
4249 const  "
4250 
4251 [INTERNAL] ";
4252 
4253 %feature("docstring")  casadi::FunctionInternal::convert_arg(const
4254 std::vector< M > &arg) const  "
4255 
4256 [INTERNAL]  Convert from/to input/output lists/map.
4257 
4258 ";
4259 
4260 %feature("docstring")  casadi::FunctionInternal::convert_arg(const std::map<
4261 std::string, M > &arg) const  "
4262 
4263 [INTERNAL]  Convert from/to input/output lists/map.
4264 
4265 ";
4266 
4267 
4268 // File: classcasadi_1_1BonMinMessageHandler.xml
4269 %feature("docstring") casadi::BonMinMessageHandler "
4270 
4271 [INTERNAL]
4272 
4273 >List of available options
4274 
4275 +------------------+------------------+------------------+-----------------+
4276 |        Id        |       Type       |   Description    |     Used in     |
4277 +==================+==================+==================+=================+
4278 | bonmin           | OT_DICT          | Options to be    | casadi::BonMinM |
4279 |                  |                  | passed to BONMIN | essageHandler   |
4280 +------------------+------------------+------------------+-----------------+
4281 | bound_consistenc | OT_BOOL          | Ensure that      | casadi::Nlpsol  |
4282 | y                |                  | primal-dual      |                 |
4283 |                  |                  | solution is      |                 |
4284 |                  |                  | consistent with  |                 |
4285 |                  |                  | the bounds       |                 |
4286 +------------------+------------------+------------------+-----------------+
4287 | calc_f           | OT_BOOL          | Calculate 'f' in | casadi::Nlpsol  |
4288 |                  |                  | the Nlpsol base  |                 |
4289 |                  |                  | class            |                 |
4290 +------------------+------------------+------------------+-----------------+
4291 | calc_g           | OT_BOOL          | Calculate 'g' in | casadi::Nlpsol  |
4292 |                  |                  | the Nlpsol base  |                 |
4293 |                  |                  | class            |                 |
4294 +------------------+------------------+------------------+-----------------+
4295 | calc_lam_p       | OT_BOOL          | Calculate        | casadi::Nlpsol  |
4296 |                  |                  | 'lam_p' in the   |                 |
4297 |                  |                  | Nlpsol base      |                 |
4298 |                  |                  | class            |                 |
4299 +------------------+------------------+------------------+-----------------+
4300 | calc_lam_x       | OT_BOOL          | Calculate        | casadi::Nlpsol  |
4301 |                  |                  | 'lam_x' in the   |                 |
4302 |                  |                  | Nlpsol base      |                 |
4303 |                  |                  | class            |                 |
4304 +------------------+------------------+------------------+-----------------+
4305 | calc_multipliers | OT_BOOL          | Calculate        | casadi::Nlpsol  |
4306 |                  |                  | Lagrange         |                 |
4307 |                  |                  | multipliers in   |                 |
4308 |                  |                  | the Nlpsol base  |                 |
4309 |                  |                  | class            |                 |
4310 +------------------+------------------+------------------+-----------------+
4311 | con_integer_md   | OT_DICT          | Integer metadata | casadi::BonMinM |
4312 |                  |                  | (a dictionary    | essageHandler   |
4313 |                  |                  | with lists of    |                 |
4314 |                  |                  | integers) about  |                 |
4315 |                  |                  | constraints to   |                 |
4316 |                  |                  | be passed to     |                 |
4317 |                  |                  | BONMIN           |                 |
4318 +------------------+------------------+------------------+-----------------+
4319 | con_numeric_md   | OT_DICT          | Numeric metadata | casadi::BonMinM |
4320 |                  |                  | (a dictionary    | essageHandler   |
4321 |                  |                  | with lists of    |                 |
4322 |                  |                  | reals) about     |                 |
4323 |                  |                  | constraints to   |                 |
4324 |                  |                  | be passed to     |                 |
4325 |                  |                  | BONMIN           |                 |
4326 +------------------+------------------+------------------+-----------------+
4327 | con_string_md    | OT_DICT          | String metadata  | casadi::BonMinM |
4328 |                  |                  | (a dictionary    | essageHandler   |
4329 |                  |                  | with lists of    |                 |
4330 |                  |                  | strings) about   |                 |
4331 |                  |                  | constraints to   |                 |
4332 |                  |                  | be passed to     |                 |
4333 |                  |                  | BONMIN           |                 |
4334 +------------------+------------------+------------------+-----------------+
4335 | discrete         | OT_BOOLVECTOR    | Indicates which  | casadi::Nlpsol  |
4336 |                  |                  | of the variables |                 |
4337 |                  |                  | are discrete,    |                 |
4338 |                  |                  | i.e. integer-    |                 |
4339 |                  |                  | valued           |                 |
4340 +------------------+------------------+------------------+-----------------+
4341 | error_on_fail    | OT_BOOL          | When the         | casadi::Nlpsol  |
4342 |                  |                  | numerical        |                 |
4343 |                  |                  | process returns  |                 |
4344 |                  |                  | unsuccessfully,  |                 |
4345 |                  |                  | raise an error   |                 |
4346 |                  |                  | (default false). |                 |
4347 +------------------+------------------+------------------+-----------------+
4348 | eval_errors_fata | OT_BOOL          | When errors      | casadi::Nlpsol  |
4349 | l                |                  | occur during     |                 |
4350 |                  |                  | evaluation of    |                 |
4351 |                  |                  | f,g,...,stop the |                 |
4352 |                  |                  | iterations       |                 |
4353 +------------------+------------------+------------------+-----------------+
4354 | grad_f           | OT_FUNCTION      | Function for     | casadi::BonMinM |
4355 |                  |                  | calculating the  | essageHandler   |
4356 |                  |                  | gradient of the  |                 |
4357 |                  |                  | objective        |                 |
4358 |                  |                  | (column,         |                 |
4359 |                  |                  | autogenerated by |                 |
4360 |                  |                  | default)         |                 |
4361 +------------------+------------------+------------------+-----------------+
4362 | grad_f_options   | OT_DICT          | Options for the  | casadi::BonMinM |
4363 |                  |                  | autogenerated    | essageHandler   |
4364 |                  |                  | gradient of the  |                 |
4365 |                  |                  | objective.       |                 |
4366 +------------------+------------------+------------------+-----------------+
4367 | hess_lag         | OT_FUNCTION      | Function for     | casadi::BonMinM |
4368 |                  |                  | calculating the  | essageHandler   |
4369 |                  |                  | Hessian of the   |                 |
4370 |                  |                  | Lagrangian       |                 |
4371 |                  |                  | (autogenerated   |                 |
4372 |                  |                  | by default)      |                 |
4373 +------------------+------------------+------------------+-----------------+
4374 | hess_lag_options | OT_DICT          | Options for the  | casadi::BonMinM |
4375 |                  |                  | autogenerated    | essageHandler   |
4376 |                  |                  | Hessian of the   |                 |
4377 |                  |                  | Lagrangian.      |                 |
4378 +------------------+------------------+------------------+-----------------+
4379 | ignore_check_vec | OT_BOOL          | If set to true,  | casadi::Nlpsol  |
4380 |                  |                  | the input shape  |                 |
4381 |                  |                  | of F will not be |                 |
4382 |                  |                  | checked.         |                 |
4383 +------------------+------------------+------------------+-----------------+
4384 | iteration_callba | OT_FUNCTION      | A function that  | casadi::Nlpsol  |
4385 | ck               |                  | will be called   |                 |
4386 |                  |                  | at each          |                 |
4387 |                  |                  | iteration with   |                 |
4388 |                  |                  | the solver as    |                 |
4389 |                  |                  | input. Check     |                 |
4390 |                  |                  | documentation of |                 |
4391 |                  |                  | Callback .       |                 |
4392 +------------------+------------------+------------------+-----------------+
4393 | iteration_callba | OT_BOOL          | If set to true,  | casadi::Nlpsol  |
4394 | ck_ignore_errors |                  | errors thrown by |                 |
4395 |                  |                  | iteration_callba |                 |
4396 |                  |                  | ck will be       |                 |
4397 |                  |                  | ignored.         |                 |
4398 +------------------+------------------+------------------+-----------------+
4399 | iteration_callba | OT_INT           | Only call the    | casadi::Nlpsol  |
4400 | ck_step          |                  | callback         |                 |
4401 |                  |                  | function every   |                 |
4402 |                  |                  | few iterations.  |                 |
4403 +------------------+------------------+------------------+-----------------+
4404 | jac_g            | OT_FUNCTION      | Function for     | casadi::BonMinM |
4405 |                  |                  | calculating the  | essageHandler   |
4406 |                  |                  | Jacobian of the  |                 |
4407 |                  |                  | constraints      |                 |
4408 |                  |                  | (autogenerated   |                 |
4409 |                  |                  | by default)      |                 |
4410 +------------------+------------------+------------------+-----------------+
4411 | jac_g_options    | OT_DICT          | Options for the  | casadi::BonMinM |
4412 |                  |                  | autogenerated    | essageHandler   |
4413 |                  |                  | Jacobian of the  |                 |
4414 |                  |                  | constraints.     |                 |
4415 +------------------+------------------+------------------+-----------------+
4416 | min_lam          | OT_DOUBLE        | Minimum allowed  | casadi::Nlpsol  |
4417 |                  |                  | multiplier value |                 |
4418 +------------------+------------------+------------------+-----------------+
4419 | no_nlp_grad      | OT_BOOL          | Prevent the      | casadi::Nlpsol  |
4420 |                  |                  | creation of the  |                 |
4421 |                  |                  | 'nlp_grad'       |                 |
4422 |                  |                  | function         |                 |
4423 +------------------+------------------+------------------+-----------------+
4424 | oracle_options   | OT_DICT          | Options to be    | casadi::Nlpsol  |
4425 |                  |                  | passed to the    |                 |
4426 |                  |                  | oracle function  |                 |
4427 +------------------+------------------+------------------+-----------------+
4428 | pass_nonlinear_c | OT_BOOL          | Pass list of     | casadi::BonMinM |
4429 | onstraints       |                  | constraints      | essageHandler   |
4430 |                  |                  | entering         |                 |
4431 |                  |                  | nonlinearly to   |                 |
4432 |                  |                  | BONMIN           |                 |
4433 +------------------+------------------+------------------+-----------------+
4434 | pass_nonlinear_v | OT_BOOL          | Pass list of     | casadi::BonMinM |
4435 | ariables         |                  | variables        | essageHandler   |
4436 |                  |                  | entering         |                 |
4437 |                  |                  | nonlinearly to   |                 |
4438 |                  |                  | BONMIN           |                 |
4439 +------------------+------------------+------------------+-----------------+
4440 | sens_linsol      | OT_STRING        | Linear solver    | casadi::Nlpsol  |
4441 |                  |                  | used for         |                 |
4442 |                  |                  | parametric       |                 |
4443 |                  |                  | sensitivities    |                 |
4444 |                  |                  | (default 'qr').  |                 |
4445 +------------------+------------------+------------------+-----------------+
4446 | sens_linsol_opti | OT_DICT          | Linear solver    | casadi::Nlpsol  |
4447 | ons              |                  | options used for |                 |
4448 |                  |                  | parametric       |                 |
4449 |                  |                  | sensitivities.   |                 |
4450 +------------------+------------------+------------------+-----------------+
4451 | sos1_groups      | OT_INTVECTORVECT | Options for the  | casadi::BonMinM |
4452 |                  | OR               | autogenerated    | essageHandler   |
4453 |                  |                  | gradient of the  |                 |
4454 |                  |                  | objective.       |                 |
4455 +------------------+------------------+------------------+-----------------+
4456 | sos1_priorities  | OT_INTVECTOR     | Options for the  | casadi::BonMinM |
4457 |                  |                  | autogenerated    | essageHandler   |
4458 |                  |                  | gradient of the  |                 |
4459 |                  |                  | objective.       |                 |
4460 +------------------+------------------+------------------+-----------------+
4461 | sos1_weights     | OT_DOUBLEVECTORV | Options for the  | casadi::BonMinM |
4462 |                  | ECTOR            | autogenerated    | essageHandler   |
4463 |                  |                  | gradient of the  |                 |
4464 |                  |                  | objective.       |                 |
4465 +------------------+------------------+------------------+-----------------+
4466 | var_integer_md   | OT_DICT          | Integer metadata | casadi::BonMinM |
4467 |                  |                  | (a dictionary    | essageHandler   |
4468 |                  |                  | with lists of    |                 |
4469 |                  |                  | integers) about  |                 |
4470 |                  |                  | variables to be  |                 |
4471 |                  |                  | passed to BONMIN |                 |
4472 +------------------+------------------+------------------+-----------------+
4473 | var_numeric_md   | OT_DICT          | Numeric metadata | casadi::BonMinM |
4474 |                  |                  | (a dictionary    | essageHandler   |
4475 |                  |                  | with lists of    |                 |
4476 |                  |                  | reals) about     |                 |
4477 |                  |                  | variables to be  |                 |
4478 |                  |                  | passed to BONMIN |                 |
4479 +------------------+------------------+------------------+-----------------+
4480 | var_string_md    | OT_DICT          | String metadata  | casadi::BonMinM |
4481 |                  |                  | (a dictionary    | essageHandler   |
4482 |                  |                  | with lists of    |                 |
4483 |                  |                  | strings) about   |                 |
4484 |                  |                  | variables to be  |                 |
4485 |                  |                  | passed to BONMIN |                 |
4486 +------------------+------------------+------------------+-----------------+
4487 | verbose_init     | OT_BOOL          | Print out timing | casadi::Nlpsol  |
4488 |                  |                  | information      |                 |
4489 |                  |                  | about the        |                 |
4490 |                  |                  | different stages |                 |
4491 |                  |                  | of               |                 |
4492 |                  |                  | initialization   |                 |
4493 +------------------+------------------+------------------+-----------------+
4494 | warn_initial_bou | OT_BOOL          | Warn if the      | casadi::Nlpsol  |
4495 | nds              |                  | initial guess    |                 |
4496 |                  |                  | does not satisfy |                 |
4497 |                  |                  | LBX and UBX      |                 |
4498 +------------------+------------------+------------------+-----------------+
4499 
4500 Diagrams
4501 --------
4502 
4503 
4504 
4505 C++ includes: b0_options.hpp ";
4506 
4507 
4508 // File: classcasadi_1_1BonminUserClass.xml
4509 %feature("docstring") casadi::BonminUserClass "
4510 
4511 [INTERNAL] C++ includes: bonmin_nlp.hpp ";
4512 
4513 %feature("docstring")
4514 casadi::BonminUserClass::finalize_solution(TMINLP::SolverReturn status,
4515 Index n, const Number *x, Number obj_value)  "
4516 
4517 [INTERNAL]  This method is called when the algorithm is complete so the TNLP
4518 can store/write the solution
4519 
4520 ";
4521 
4522 %feature("docstring")  casadi::BonminUserClass::eval_g(Index n, const Number
4523 *x, bool new_x, Index m, Number *g)  "
4524 
4525 [INTERNAL]  Method to return the constraint residuals
4526 
4527 ";
4528 
4529 %feature("docstring")  casadi::BonminUserClass::eval_f(Index n, const Number
4530 *x, bool new_x, Number &obj_value)  "
4531 
4532 [INTERNAL]  Method to return the objective value
4533 
4534 ";
4535 
4536 %feature("docstring")
4537 casadi::BonminUserClass::get_constraints_linearity(Index m,
4538 Ipopt::TNLP::LinearityType *const_types)  "
4539 
4540 [INTERNAL] ";
4541 
4542 %feature("docstring") casadi::BonminUserClass::BonminUserClass(const
4543 BonminInterface &bonminInterface, BonminMemory *mem) "
4544 
4545 [INTERNAL] ";
4546 
4547 %feature("docstring")  casadi::BonminUserClass::get_starting_point(Index n,
4548 bool init_x, Number *x, bool init_z, Number *z_L, Number *z_U, Index m, bool
4549 init_lambda, Number *lambda)  "
4550 
4551 [INTERNAL]  Method to return the starting point for the algorithm
4552 
4553 ";
4554 
4555 %feature("docstring")
4556 casadi::BonminUserClass::get_number_of_nonlinear_variables() "
4557 
4558 [INTERNAL]  Specify the number of variables that appear in the Hessian
4559 
4560 ";
4561 
4562 %feature("docstring")  casadi::BonminUserClass::eval_jac_g(Index n, const
4563 Number *x, bool new_x, Index m, Index nele_jac, Index *iRow, Index *jCol,
4564 Number *values)  "
4565 
4566 [INTERNAL]  Method to return: 1) The structure of the Jacobian (if
4567 \"values\" is NULL) 2) The values of the Jacobian (if \"values\" is not
4568 NULL)
4569 
4570 ";
4571 
4572 %feature("docstring")
4573 casadi::BonminUserClass::intermediate_callback(AlgorithmMode mode, Index
4574 iter, Number obj_value, Number inf_pr, Number inf_du, Number mu, Number
4575 d_norm, Number regularization_size, Number alpha_du, Number alpha_pr, Index
4576 ls_trials, const IpoptData *ip_data, IpoptCalculatedQuantities *ip_cq) "
4577 
4578 [INTERNAL]  This method is called at every iteration
4579 
4580 ";
4581 
4582 %feature("docstring")  casadi::BonminUserClass::eval_h(Index n, const Number
4583 *x, bool new_x, Number obj_factor, Index m, const Number *lambda, bool
4584 new_lambda, Index nele_hess, Index *iRow, Index *jCol, Number *values)  "
4585 
4586 [INTERNAL]  Method to return: 1) The structure of the hessian of the
4587 Lagrangian (if \"values\" is NULL) 2) The values of the hessian of the
4588 Lagrangian (if \"values\" is not NULL)
4589 
4590 ";
4591 
4592 %feature("docstring")  casadi::BonminUserClass::get_variables_types(Index n,
4593 VariableType *var_types)  "
4594 
4595 [INTERNAL] ";
4596 
4597 %feature("docstring") casadi::BonminUserClass::~BonminUserClass "
4598 
4599 [INTERNAL] ";
4600 
4601 %feature("docstring")
4602 casadi::BonminUserClass::get_list_of_nonlinear_variables(Index
4603 num_nonlin_vars, Index *pos_nonlin_vars) "
4604 
4605 [INTERNAL]  Specify which variables that appear in the Hessian
4606 
4607 ";
4608 
4609 %feature("docstring")  casadi::BonminUserClass::get_bounds_info(Index n,
4610 Number *x_l, Number *x_u, Index m, Number *g_l, Number *g_u)  "
4611 
4612 [INTERNAL]  Method to return the bounds for my problem
4613 
4614 ";
4615 
4616 %feature("docstring")  casadi::BonminUserClass::sosConstraints() const  "
4617 
4618 [INTERNAL] ";
4619 
4620 %feature("docstring")  casadi::BonminUserClass::get_nlp_info(Index &n, Index
4621 &m, Index &nnz_jac_g, Index &nnz_h_lag, TNLP::IndexStyleEnum &index_style)
4622 "
4623 
4624 [INTERNAL]  Method to return some info about the nlp
4625 
4626 ";
4627 
4628 %feature("docstring")  casadi::BonminUserClass::branchingInfo() const  "
4629 
4630 [INTERNAL] ";
4631 
4632 %feature("docstring")  casadi::BonminUserClass::eval_grad_f(Index n, const
4633 Number *x, bool new_x, Number *grad_f)  "
4634 
4635 [INTERNAL]  Method to return the gradient of the objective
4636 
4637 ";
4638 
4639 %feature("docstring")
4640 casadi::BonminUserClass::get_variables_linearity(Index n,
4641 Ipopt::TNLP::LinearityType *var_types)  "
4642 
4643 [INTERNAL] ";
4644 
4645 
4646 // File: classcasadi_1_1BSpline.xml
4647 
4648 
4649 // File: classcasadi_1_1BSplineCommon.xml
4650 
4651 
4652 // File: classcasadi_1_1BSplineInterpolant.xml
4653 %feature("docstring")  casadi::FunctionInternal::check_arg(const
4654 std::vector< M > &arg, casadi_int &npar) const  "
4655 
4656 [INTERNAL]  Check if input arguments have correct length and dimensions.
4657 
4658 Raises errors.
4659 
4660 Parameters:
4661 -----------
4662 
4663 npar[in]:  normal usage: 1, disallow pararallel calls: -1
4664 
4665 npar:  max number of horizontal repetitions across all arguments (or -1)
4666 
4667 ";
4668 
4669 %feature("docstring")  casadi::FunctionInternal::sparsity_jac(casadi_int
4670 iind, casadi_int oind, bool compact, bool symmetric) const  "
4671 
4672 [INTERNAL]  Get, if necessary generate, the sparsity of a Jacobian block.
4673 
4674 ";
4675 
4676 %feature("docstring")  casadi::SharedObjectInternal::weak() "
4677 
4678 [INTERNAL]  Get a weak reference to the object.
4679 
4680 ";
4681 
4682 %feature("docstring")  casadi::FunctionInternal::set_temp(void *mem, const
4683 double **arg, double **res, casadi_int *iw, double *w) const  "
4684 
4685 [INTERNAL]  Set the (temporary) work vectors.
4686 
4687 ";
4688 
4689 %feature("docstring")  casadi::FunctionInternal::index_in(const std::string
4690 &name) const  "
4691 
4692 [INTERNAL]  Get input scheme index by name.
4693 
4694 ";
4695 
4696 %feature("docstring")  casadi::FunctionInternal::size2_in(casadi_int ind)
4697 const  "
4698 
4699 [INTERNAL]  Input/output dimensions.
4700 
4701 ";
4702 
4703 %feature("docstring")  casadi::FunctionInternal::codegen(CodeGenerator &g,
4704 const std::string &fname) const  "
4705 
4706 [INTERNAL]  Generate code the function.
4707 
4708 ";
4709 
4710 %feature("docstring")  casadi::FunctionInternal::project_arg(const
4711 std::vector< M > &arg, casadi_int npar) const  "
4712 
4713 [INTERNAL]   Project sparsities.
4714 
4715 ";
4716 
4717 %feature("docstring")  casadi::FunctionInternal::print_option(const
4718 std::string &name, std::ostream &stream) const  "
4719 
4720 [INTERNAL]  Print all information there is to know about a certain option.
4721 
4722 ";
4723 
4724 %feature("docstring")  casadi::BSplineInterpolant::init(const Dict &opts)  "
4725 
4726 [INTERNAL]  Initialize.
4727 
4728 ";
4729 
4730 %feature("docstring")  casadi::FunctionInternal::eval_dm(const std::vector<
4731 DM > &arg) const  "
4732 
4733 [INTERNAL]  Evaluate with DM matrices.
4734 
4735 ";
4736 
4737 %feature("docstring")
4738 casadi::FunctionInternal::instruction_input(casadi_int k) const  "
4739 
4740 [INTERNAL]  Get the (integer) input arguments of an atomic operation.
4741 
4742 ";
4743 
4744 %feature("docstring")
4745 casadi::FunctionInternal::codegen_free_mem(CodeGenerator &g) const  "
4746 
4747 [INTERNAL]  Codegen for free_mem.
4748 
4749 ";
4750 
4751 %feature("docstring")  casadi::FunctionInternal::jacobian() const  "
4752 
4753 [INTERNAL]  Return Jacobian of all input elements with respect to all output
4754 elements.
4755 
4756 ";
4757 
4758 %feature("docstring")  casadi::FunctionInternal::size_in(casadi_int ind)
4759 const  "
4760 
4761 [INTERNAL]  Input/output dimensions.
4762 
4763 ";
4764 
4765 %feature("docstring")  casadi::FunctionInternal::alloc(const Function &f,
4766 bool persistent=false) "
4767 
4768 [INTERNAL]  Ensure work vectors long enough to evaluate function.
4769 
4770 ";
4771 
4772 %feature("docstring")  casadi::FunctionInternal::get_function() const  "
4773 
4774 [INTERNAL] ";
4775 
4776 %feature("docstring")  casadi::FunctionInternal::get_function(const
4777 std::string &name) const  "
4778 
4779 [INTERNAL] ";
4780 
4781 %feature("docstring")  casadi::FunctionInternal::is_a(const std::string
4782 &type, bool recursive) const  "
4783 
4784 [INTERNAL]  Check if the function is of a particular type.
4785 
4786 ";
4787 
4788 %feature("docstring")
4789 casadi::FunctionInternal::instruction_constant(casadi_int k) const  "
4790 
4791 [INTERNAL]  Get the floating point output argument of an atomic operation.
4792 
4793 ";
4794 
4795 %feature("docstring")  casadi::FunctionInternal::mx_in(casadi_int ind) const
4796 "
4797 
4798 [INTERNAL]  Get function input(s) and output(s)
4799 
4800 ";
4801 
4802 %feature("docstring")  casadi::FunctionInternal::mx_in() const  "
4803 
4804 [INTERNAL]  Get function input(s) and output(s)
4805 
4806 ";
4807 
4808 %feature("docstring")  casadi::FunctionInternal::wrap_as_needed(const Dict
4809 &opts) const  "
4810 
4811 [INTERNAL]  Wrap in an Function instance consisting of only one MX call.
4812 
4813 ";
4814 
4815 %feature("docstring")  casadi::ProtoFunction::clear_mem() "
4816 
4817 [INTERNAL]  Clear all memory (called from destructor)
4818 
4819 ";
4820 
4821 %feature("docstring")
4822 casadi::FunctionInternal::codegen_decref(CodeGenerator &g) const  "
4823 
4824 [INTERNAL]  Codegen decref for dependencies.
4825 
4826 ";
4827 
4828 %feature("docstring")
4829 casadi::FunctionInternal::codegen_incref(CodeGenerator &g) const  "
4830 
4831 [INTERNAL]  Codegen incref for dependencies.
4832 
4833 ";
4834 
4835 %feature("docstring")  casadi::FunctionInternal::eval_sx(const SXElem **arg,
4836 SXElem **res, casadi_int *iw, SXElem *w, void *mem) const  "
4837 
4838 [INTERNAL]  Evaluate with symbolic scalars.
4839 
4840 ";
4841 
4842 %feature("docstring")  casadi::FunctionInternal::sparsity_in(casadi_int ind)
4843 const  "
4844 
4845 [INTERNAL]  Input/output sparsity.
4846 
4847 ";
4848 
4849 %feature("docstring")  casadi::ProtoFunction::serialize(SerializingStream
4850 &s) const  "
4851 
4852 [INTERNAL]  Serialize an object.
4853 
4854 ";
4855 
4856 %feature("docstring")  casadi::FunctionInternal::instruction_id(casadi_int
4857 k) const  "
4858 
4859 [INTERNAL]  Get an atomic operation operator index.
4860 
4861 ";
4862 
4863 %feature("docstring")  casadi::FunctionInternal::mx_out(casadi_int ind)
4864 const  "
4865 
4866 [INTERNAL]  Get function input(s) and output(s)
4867 
4868 ";
4869 
4870 %feature("docstring")  casadi::FunctionInternal::mx_out() const  "
4871 
4872 [INTERNAL]  Get function input(s) and output(s)
4873 
4874 ";
4875 
4876 %feature("docstring")  casadi::FunctionInternal::get_free() const  "
4877 
4878 [INTERNAL]  Print free variables.
4879 
4880 ";
4881 
4882 %feature("docstring")  casadi::FunctionInternal::map(casadi_int n, const
4883 std::string &parallelization) const  "
4884 
4885 [INTERNAL]  Generate/retrieve cached serial map.
4886 
4887 ";
4888 
4889 %feature("docstring")  casadi::FunctionInternal::check_res(const
4890 std::vector< M > &res, casadi_int &npar) const  "
4891 
4892 [INTERNAL]  Check if output arguments have correct length and dimensions.
4893 
4894 Raises errors.
4895 
4896 Parameters:
4897 -----------
4898 
4899 npar[in]:  normal usage: 1, disallow pararallel calls: -1
4900 
4901 npar:  max number of horizontal repetitions across all arguments (or -1)
4902 
4903 ";
4904 
4905 %feature("docstring")  casadi::Interpolant::has_parametric_grid() const  "
4906 
4907 [INTERNAL]  Is parametric?
4908 
4909 ";
4910 
4911 %feature("docstring")  casadi::FunctionInternal::call_gen(const MXVector
4912 &arg, MXVector &res, casadi_int npar, bool always_inline, bool never_inline)
4913 const  "
4914 
4915 [INTERNAL]   Call a function, overloaded.
4916 
4917 ";
4918 
4919 %feature("docstring")  casadi::FunctionInternal::call_gen(const std::vector<
4920 MatrixCommon > &arg, std::vector< MatrixCommon > &res, casadi_int npar, bool
4921 always_inline, bool never_inline) const  "
4922 
4923 [INTERNAL]   Call a function, overloaded.
4924 
4925 ";
4926 
4927 %feature("docstring")  casadi::FunctionInternal::forward(casadi_int nfwd)
4928 const  "
4929 
4930 [INTERNAL]  Return function that calculates forward derivatives
4931 forward(nfwd) returns a cached instance if available, and calls  Function
4932 get_forward(casadi_int nfwd) if no cached version is available.
4933 
4934 ";
4935 
4936 %feature("docstring")  casadi::FunctionInternal::getJacSparsity(casadi_int
4937 iind, casadi_int oind, bool symmetric) const  "
4938 
4939 [INTERNAL]  Generate the sparsity of a Jacobian block.
4940 
4941 ";
4942 
4943 %feature("docstring")  casadi::FunctionInternal::self() const  "
4944 
4945 [INTERNAL]  Get a public class instance.
4946 
4947 ";
4948 
4949 %feature("docstring")  casadi::FunctionInternal::print_options(std::ostream
4950 &stream) const  "
4951 
4952 [INTERNAL]  Print list of options.
4953 
4954 ";
4955 
4956 %feature("docstring")  casadi::ProtoFunction::construct(const Dict &opts) "
4957 
4958 [INTERNAL]  Construct Prepares the function for evaluation.
4959 
4960 ";
4961 
4962 %feature("docstring")  casadi::Interpolant::has_parametric_values() const  "
4963 
4964 [INTERNAL]  Is parametric?
4965 
4966 ";
4967 
4968 %feature("docstring")  casadi::ProtoFunction::sprint(char *buf, size_t
4969 buf_sz, const char *fmt,...) const  "
4970 
4971 [INTERNAL]  C-style formatted printing to string.
4972 
4973 ";
4974 
4975 %feature("docstring")  casadi::FunctionInternal::definition() const  "
4976 
4977 [INTERNAL]  Get function signature: name:(inputs)->(outputs)
4978 
4979 ";
4980 
4981 %feature("docstring")  casadi::FunctionInternal::alloc_iw(size_t sz_iw, bool
4982 persistent=false) "
4983 
4984 [INTERNAL]  Ensure required length of iw field.
4985 
4986 ";
4987 
4988 %feature("docstring") casadi::BSplineInterpolant::~BSplineInterpolant "
4989 
4990 [INTERNAL] ";
4991 
4992 %feature("docstring")  casadi::FunctionInternal::replace_fseed(const
4993 std::vector< std::vector< M >> &fseed, casadi_int npar) const  "
4994 
4995 [INTERNAL]  Replace 0-by-0 forward seeds.
4996 
4997 ";
4998 
4999 %feature("docstring")  casadi::FunctionInternal::replace_fseed(const
5000 std::vector< std::vector< M > > &fseed, casadi_int npar) const  "
5001 
5002 [INTERNAL] ";
5003 
5004 %feature("docstring")  casadi::FunctionInternal::index_out(const std::string
5005 &name) const  "
5006 
5007 [INTERNAL]  Get output scheme index by name.
5008 
5009 ";
5010 
5011 %feature("docstring")  casadi::FunctionInternal::free_sx() const  "
5012 
5013 [INTERNAL]  Get free variables (SX)
5014 
5015 ";
5016 
5017 %feature("docstring")  casadi::FunctionInternal::convert_res(const
5018 std::vector< M > &res) const  "
5019 
5020 [INTERNAL]  Convert from/to input/output lists/map.
5021 
5022 ";
5023 
5024 %feature("docstring")  casadi::FunctionInternal::convert_res(const std::map<
5025 std::string, M > &res) const  "
5026 
5027 [INTERNAL]  Convert from/to input/output lists/map.
5028 
5029 ";
5030 
5031 %feature("docstring")  casadi::FunctionInternal::symbolic_output(const
5032 std::vector< MX > &arg) const  "
5033 
5034 [INTERNAL]  Get a vector of symbolic variables corresponding to the outputs.
5035 
5036 ";
5037 
5038 %feature("docstring")
5039 casadi::FunctionInternal::getJacSparsityHierarchical(casadi_int iind,
5040 casadi_int oind) const  "
5041 
5042 [INTERNAL]  A flavor of getJacSparsity that does hierarchical block
5043 structure recognition.
5044 
5045 ";
5046 
5047 %feature("docstring")
5048 casadi::BSplineInterpolant::serialize_body(SerializingStream &s) const  "
5049 
5050 [INTERNAL]  Serialize an object without type information.
5051 
5052 ";
5053 
5054 %feature("docstring")  casadi::BSplineInterpolant::get_options() const  "
5055 
5056 [INTERNAL]  Options.
5057 
5058 ";
5059 
5060 %feature("docstring")  casadi::FunctionInternal::has_eval_dm() const  "
5061 
5062 [INTERNAL]  Evaluate with DM matrices.
5063 
5064 ";
5065 
5066 %feature("docstring")  casadi::Interpolant::get_n_in()  "
5067 
5068 [INTERNAL]  Number of function inputs and outputs.
5069 
5070 ";
5071 
5072 %feature("docstring")  casadi::FunctionInternal::finalize()  "
5073 
5074 [INTERNAL]  Finalize the object creation.
5075 
5076 ";
5077 
5078 %feature("docstring")  casadi::FunctionInternal::mapsum_mx(const
5079 std::vector< MX > &arg, const std::string &parallelization) "
5080 
5081 [INTERNAL]  Parallel evaluation.
5082 
5083 ";
5084 
5085 %feature("docstring")  casadi::FunctionInternal::setup(void *mem, const
5086 double **arg, double **res, casadi_int *iw, double *w) const  "
5087 
5088 [INTERNAL]  Set the (persistent and temporary) work vectors.
5089 
5090 ";
5091 
5092 %feature("docstring")  casadi::Interpolant::arg_values() const  "
5093 
5094 [INTERNAL] ";
5095 
5096 %feature("docstring")
5097 casadi::BSplineInterpolant::codegen_declarations(CodeGenerator &g) const  "
5098 
5099 [INTERNAL]  Generate code for the declarations of the C function.
5100 
5101 ";
5102 
5103 %feature("docstring")  casadi::FunctionInternal::slice(const std::string
5104 &name, const std::vector< casadi_int > &order_in, const std::vector<
5105 casadi_int > &order_out, const Dict &opts) const  "
5106 
5107 [INTERNAL]  returns a new function with a selection of inputs/outputs of the
5108 original
5109 
5110 ";
5111 
5112 %feature("docstring")  casadi::FunctionInternal::adjViaJac(casadi_int nadj)
5113 const  "
5114 
5115 [INTERNAL]  Calculate derivatives by multiplying the full Jacobian and
5116 multiplying.
5117 
5118 ";
5119 
5120 %feature("docstring")  casadi::FunctionInternal::jac() const  "
5121 
5122 [INTERNAL]  Return Jacobian of all input elements with respect to all output
5123 elements.
5124 
5125 ";
5126 
5127 %feature("docstring")  casadi::Interpolant::serialize_base_function() const
5128 "
5129 
5130 [INTERNAL]  String used to identify the immediate FunctionInternal subclass.
5131 
5132 ";
5133 
5134 %feature("docstring")  casadi::Interpolant::coeff_size() const  "
5135 
5136 [INTERNAL]  Size of the flattened coefficients vector.
5137 
5138 ";
5139 
5140 %feature("docstring")  casadi::ProtoFunction::print(const char *fmt,...)
5141 const  "
5142 
5143 [INTERNAL]  C-style formatted printing during evaluation.
5144 
5145 ";
5146 
5147 %feature("docstring")  casadi::ProtoFunction::memory(int ind) const  "
5148 
5149 [INTERNAL]  Memory objects.
5150 
5151 ";
5152 
5153 %feature("docstring") casadi::BSplineInterpolant "
5154 
5155 'bspline' plugin for Interpolant
5156 
5157 N-dimensional BSpline interpolator
5158 
5159 Uses not-a-knot conditions. For 1D and 2D cases, this code is equivalent to
5160 fitpack
5161 
5162 >List of available options
5163 
5164 +-----------------------+--------------+-----------------------------------+
5165 |          Id           |     Type     |            Description            |
5166 +=======================+==============+===================================+
5167 | algorithm             | OT_STRING    | Algorithm used for fitting the    |
5168 |                       |              | data: 'not_a_knot' (default, same |
5169 |                       |              | as Matlab), 'smooth_linear'.      |
5170 +-----------------------+--------------+-----------------------------------+
5171 | degree                | OT_INTVECTOR | Sets, for each grid dimension,    |
5172 |                       |              | the degree of the spline.         |
5173 +-----------------------+--------------+-----------------------------------+
5174 | linear_solver         | OT_STRING    | Solver used for constructing the  |
5175 |                       |              | coefficient tensor.               |
5176 +-----------------------+--------------+-----------------------------------+
5177 | linear_solver_options | OT_DICT      | Options to be passed to the       |
5178 |                       |              | linear solver.                    |
5179 +-----------------------+--------------+-----------------------------------+
5180 | smooth_linear_frac    | OT_DOUBLE    | When 'smooth_linear' algorithm is |
5181 |                       |              | active, determines sharpness      |
5182 |                       |              | between 0 (sharp, as linear       |
5183 |                       |              | interpolation) and 0.5            |
5184 |                       |              | (smooth).Default value is 0.1.    |
5185 +-----------------------+--------------+-----------------------------------+
5186 
5187 Joris Gillis
5188 
5189 >List of available options
5190 
5191 +------------------+-----------------+------------------+------------------+
5192 |        Id        |      Type       |   Description    |     Used in      |
5193 +==================+=================+==================+==================+
5194 | algorithm        | OT_STRING       | Algorithm used   | casadi::BSplineI |
5195 |                  |                 | for fitting the  | nterpolant       |
5196 |                  |                 | data:            |                  |
5197 |                  |                 | 'not_a_knot'     |                  |
5198 |                  |                 | (default, same   |                  |
5199 |                  |                 | as Matlab),      |                  |
5200 |                  |                 | 'smooth_linear'. |                  |
5201 +------------------+-----------------+------------------+------------------+
5202 | batch_x          | OT_INT          | Evaluate a batch | casadi::Interpol |
5203 |                  |                 | of different     | ant              |
5204 |                  |                 | inputs at once   |                  |
5205 |                  |                 | (default 1).     |                  |
5206 +------------------+-----------------+------------------+------------------+
5207 | degree           | OT_INTVECTOR    | Sets, for each   | casadi::BSplineI |
5208 |                  |                 | grid dimension,  | nterpolant       |
5209 |                  |                 | the degree of    |                  |
5210 |                  |                 | the spline.      |                  |
5211 +------------------+-----------------+------------------+------------------+
5212 | inline           | OT_BOOL         | Implement the    | casadi::Interpol |
5213 |                  |                 | lookup table in  | ant              |
5214 |                  |                 | MX primitives.   |                  |
5215 |                  |                 | Useful when you  |                  |
5216 |                  |                 | need derivatives |                  |
5217 |                  |                 | with respect to  |                  |
5218 |                  |                 | grid and/or      |                  |
5219 |                  |                 | coefficients.    |                  |
5220 |                  |                 | Such derivatives |                  |
5221 |                  |                 | are              |                  |
5222 |                  |                 | fundamentally    |                  |
5223 |                  |                 | dense, so use    |                  |
5224 |                  |                 | with caution.    |                  |
5225 +------------------+-----------------+------------------+------------------+
5226 | linear_solver    | OT_STRING       | Solver used for  | casadi::BSplineI |
5227 |                  |                 | constructing the | nterpolant       |
5228 |                  |                 | coefficient      |                  |
5229 |                  |                 | tensor.          |                  |
5230 +------------------+-----------------+------------------+------------------+
5231 | linear_solver_op | OT_DICT         | Options to be    | casadi::BSplineI |
5232 | tions            |                 | passed to the    | nterpolant       |
5233 |                  |                 | linear solver.   |                  |
5234 +------------------+-----------------+------------------+------------------+
5235 | lookup_mode      | OT_STRINGVECTOR | Specifies, for   | casadi::Interpol |
5236 |                  |                 | each grid        | ant              |
5237 |                  |                 | dimenion, the    |                  |
5238 |                  |                 | lookup algorithm |                  |
5239 |                  |                 | used to find the |                  |
5240 |                  |                 | correct index.   |                  |
5241 |                  |                 | 'linear' uses a  |                  |
5242 |                  |                 | for-loop +       |                  |
5243 |                  |                 | break; (default  |                  |
5244 |                  |                 | when             |                  |
5245 |                  |                 | #knots<=100),    |                  |
5246 |                  |                 | 'exact' uses     |                  |
5247 |                  |                 | floored division |                  |
5248 |                  |                 | (only for        |                  |
5249 |                  |                 | uniform grids),  |                  |
5250 |                  |                 | 'binary' uses a  |                  |
5251 |                  |                 | binary search.   |                  |
5252 |                  |                 | (default when    |                  |
5253 |                  |                 | #knots>100).     |                  |
5254 +------------------+-----------------+------------------+------------------+
5255 | smooth_linear_fr | OT_DOUBLE       | When             | casadi::BSplineI |
5256 | ac               |                 | 'smooth_linear'  | nterpolant       |
5257 |                  |                 | algorithm is     |                  |
5258 |                  |                 | active,          |                  |
5259 |                  |                 | determines       |                  |
5260 |                  |                 | sharpness        |                  |
5261 |                  |                 | between 0        |                  |
5262 |                  |                 | (sharp, as       |                  |
5263 |                  |                 | linear           |                  |
5264 |                  |                 | interpolation)   |                  |
5265 |                  |                 | and 0.5          |                  |
5266 |                  |                 | (smooth).Default |                  |
5267 |                  |                 | value is 0.1.    |                  |
5268 +------------------+-----------------+------------------+------------------+
5269 
5270 Diagrams
5271 --------
5272 
5273 
5274 
5275 C++ includes: bspline_interpolant.hpp ";
5276 
5277 %feature("docstring")  casadi::FunctionInternal::set_work(void *mem, const
5278 double **&arg, double **&res, casadi_int *&iw, double *&w) const  "
5279 
5280 [INTERNAL]  Set the (persistent) work vectors.
5281 
5282 ";
5283 
5284 %feature("docstring")  casadi::FunctionInternal::alloc_res(size_t sz_res,
5285 bool persistent=false) "
5286 
5287 [INTERNAL]  Ensure required length of res field.
5288 
5289 ";
5290 
5291 %feature("docstring")  casadi::FunctionInternal::has_jac() const  "
5292 
5293 [INTERNAL]  Return Jacobian of all input elements with respect to all output
5294 elements.
5295 
5296 ";
5297 
5298 %feature("docstring")  casadi::FunctionInternal::generate_options(bool
5299 is_temp=false) const  "
5300 
5301 [INTERNAL]  Reconstruct options dict.
5302 
5303 ";
5304 
5305 %feature("docstring")  casadi::FunctionInternal::uses_output() const  "
5306 
5307 [INTERNAL]  Do the derivative functions need nondifferentiated outputs?
5308 
5309 ";
5310 
5311 %feature("docstring")  casadi::FunctionInternal::disp_more(std::ostream
5312 &stream) const  "
5313 
5314 [INTERNAL]  Print more.
5315 
5316 ";
5317 
5318 %feature("docstring")  casadi::FunctionInternal::matching_arg(const
5319 std::vector< M > &arg, casadi_int &npar) const  "
5320 
5321 [INTERNAL]  Check if input arguments that needs to be replaced.
5322 
5323 Raises errors
5324 
5325 Parameters:
5326 -----------
5327 
5328 npar[in]:  normal usage: 1, disallow pararallel calls: -1
5329 
5330 npar:  max number of horizontal repetitions across all arguments (or -1)
5331 
5332 ";
5333 
5334 %feature("docstring")  casadi::FunctionInternal::numel_out(casadi_int ind)
5335 const  "
5336 
5337 [INTERNAL]  Number of input/output elements.
5338 
5339 ";
5340 
5341 %feature("docstring")  casadi::FunctionInternal::numel_out() const  "
5342 
5343 [INTERNAL]  Number of input/output elements.
5344 
5345 ";
5346 
5347 %feature("docstring")  casadi::SharedObjectInternal::getCount() const  "
5348 
5349 [INTERNAL]  Get the reference count.
5350 
5351 ";
5352 
5353 %feature("docstring")  casadi::Interpolant::get_sparsity_in(casadi_int i)  "
5354 
5355 [INTERNAL]  Sparsities of function inputs and outputs.
5356 
5357 ";
5358 
5359 %feature("docstring")  casadi::BSplineInterpolant::sp_forward(const bvec_t
5360 **arg, bvec_t **res, casadi_int *iw, bvec_t *w, void *mem) const  "
5361 
5362 [INTERNAL]  Propagate sparsity forward.
5363 
5364 ";
5365 
5366 %feature("docstring")  casadi::FunctionInternal::codegen_mem(CodeGenerator
5367 &g, const std::string &index="mem") const  "
5368 
5369 [INTERNAL]  Get thread-local memory object.
5370 
5371 ";
5372 
5373 %feature("docstring")  casadi::FunctionInternal::call(const std::vector< M >
5374 &arg, std::vector< M > &res, bool always_inline, bool never_inline) const  "
5375 
5376 [INTERNAL]   Call a function, templated.
5377 
5378 ";
5379 
5380 %feature("docstring")  casadi::BSplineInterpolant::has_forward(casadi_int
5381 nfwd) const  "
5382 
5383 [INTERNAL]  Return function that calculates forward derivatives
5384 forward(nfwd) returns a cached instance if available, and calls  Function
5385 get_forward(casadi_int nfwd) if no cached version is available.
5386 
5387 ";
5388 
5389 %feature("docstring")  casadi::FunctionInternal::nz_in(const std::vector< DM
5390 > &arg) const  "
5391 
5392 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
5393 
5394 ";
5395 
5396 %feature("docstring")  casadi::FunctionInternal::nz_in(const std::vector<
5397 double > &arg) const  "
5398 
5399 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
5400 
5401 ";
5402 
5403 %feature("docstring")  casadi::FunctionInternal::all_scalar() const  "
5404 
5405 [INTERNAL]  Are all inputs and outputs scalar.
5406 
5407 ";
5408 
5409 %feature("docstring")  casadi::FunctionInternal::jacobian_sparsity() const
5410 "
5411 
5412 [INTERNAL]  Get Jacobian sparsity.
5413 
5414 ";
5415 
5416 %feature("docstring")  casadi::FunctionInternal::is_diff_out(casadi_int i) "
5417 
5418 [INTERNAL] ";
5419 
5420 %feature("docstring")  casadi::FunctionInternal::instruction_MX(casadi_int
5421 k) const  "
5422 
5423 [INTERNAL]  get MX expression associated with instruction
5424 
5425 ";
5426 
5427 %feature("docstring")  casadi::ProtoFunction::release(int mem) const  "
5428 
5429 [INTERNAL]  Release a memory object.
5430 
5431 ";
5432 
5433 %feature("docstring")  casadi::FunctionInternal::ad_weight() const  "
5434 
5435 [INTERNAL]  Weighting factor for chosing forward/reverse mode.
5436 
5437 ";
5438 
5439 %feature("docstring")  casadi::FunctionInternal::sx_out(casadi_int ind)
5440 const  "
5441 
5442 [INTERNAL]  Get function input(s) and output(s)
5443 
5444 ";
5445 
5446 %feature("docstring")  casadi::FunctionInternal::sx_out() const  "
5447 
5448 [INTERNAL]  Get function input(s) and output(s)
5449 
5450 ";
5451 
5452 %feature("docstring")  casadi::FunctionInternal::disp(std::ostream &stream,
5453 bool more) const  "
5454 
5455 [INTERNAL]  Display object.
5456 
5457 ";
5458 
5459 %feature("docstring")  casadi::BSplineInterpolant::has_jacobian() const  "
5460 
5461 [INTERNAL]  Full Jacobian.
5462 
5463 ";
5464 
5465 %feature("docstring")  casadi::FunctionInternal::sz_res() const  "
5466 
5467 [INTERNAL]  Get required length of res field.
5468 
5469 ";
5470 
5471 %feature("docstring")  casadi::FunctionInternal::get_default_in(casadi_int
5472 ind) const  "
5473 
5474 [INTERNAL]  Get default input value.
5475 
5476 ";
5477 
5478 %feature("docstring")  casadi::FunctionInternal::has_function(const
5479 std::string &fname) const  "
5480 
5481 [INTERNAL] ";
5482 
5483 %feature("docstring")  casadi::ProtoFunction::checkout() const  "
5484 
5485 [INTERNAL]  Checkout a memory object.
5486 
5487 ";
5488 
5489 %feature("docstring")  casadi::ProtoFunction::free_mem(void *mem) const  "
5490 
5491 [INTERNAL]  Free memory block.
5492 
5493 ";
5494 
5495 %feature("docstring")  casadi::FunctionInternal::call_reverse(const
5496 std::vector< MX > &arg, const std::vector< MX > &res, const std::vector<
5497 std::vector< MX > > &aseed, std::vector< std::vector< MX > > &asens, bool
5498 always_inline, bool never_inline) const  "
5499 
5500 [INTERNAL]  Reverse mode, virtual functions overloaded in derived classes.
5501 
5502 ";
5503 
5504 %feature("docstring")  casadi::FunctionInternal::call_reverse(const
5505 std::vector< SX > &arg, const std::vector< SX > &res, const std::vector<
5506 std::vector< SX > > &aseed, std::vector< std::vector< SX > > &asens, bool
5507 always_inline, bool never_inline) const  "
5508 
5509 [INTERNAL]  Reverse mode, virtual functions overloaded in derived classes.
5510 
5511 ";
5512 
5513 %feature("docstring")  casadi::BSplineInterpolant::is_diff_in(casadi_int i)
5514 "
5515 
5516 [INTERNAL] ";
5517 
5518 %feature("docstring")  casadi::FunctionInternal::symbolicAdjSeed(casadi_int
5519 nadj, const std::vector< MatType > &v) const  "
5520 
5521 [INTERNAL]  Symbolic expressions for the adjoint seeds.
5522 
5523 ";
5524 
5525 %feature("docstring")  casadi::FunctionInternal::has_spfwd() const  "
5526 
5527 [INTERNAL]  Is the class able to propagate seeds through the algorithm?
5528 
5529 ";
5530 
5531 %feature("docstring")  casadi::Interpolant::get_n_out()  "
5532 
5533 [INTERNAL]  Number of function inputs and outputs.
5534 
5535 ";
5536 
5537 %feature("docstring")  casadi::FunctionInternal::factory(const std::string
5538 &name, const std::vector< std::string > &s_in, const std::vector<
5539 std::string > &s_out, const Function::AuxOut &aux, const Dict &opts) const
5540 "
5541 
5542 [INTERNAL] ";
5543 
5544 %feature("docstring")
5545 casadi::FunctionInternal::getJacSparsityGen(casadi_int iind, casadi_int
5546 oind, bool symmetric, casadi_int gr_i=1, casadi_int gr_o=1) const  "
5547 
5548 [INTERNAL]  Get the sparsity pattern, forward mode.
5549 
5550 ";
5551 
5552 %feature("docstring")  casadi::FunctionInternal::replace_res(const
5553 std::vector< M > &res, casadi_int npar) const  "
5554 
5555 [INTERNAL]  Replace 0-by-0 outputs.
5556 
5557 ";
5558 
5559 %feature("docstring")  casadi::ProtoFunction::init_mem(void *mem) const  "
5560 
5561 [INTERNAL]  Initalize memory block.
5562 
5563 ";
5564 
5565 %feature("docstring")  casadi::FunctionInternal::get_jacobian_sparsity()
5566 const  "
5567 
5568 [INTERNAL]  Get Jacobian sparsity.
5569 
5570 ";
5571 
5572 %feature("docstring")  casadi::FunctionInternal::wrap() const  "
5573 
5574 [INTERNAL]  Wrap in an Function instance consisting of only one MX call.
5575 
5576 ";
5577 
5578 %feature("docstring")  casadi::FunctionInternal::sz_w() const  "
5579 
5580 [INTERNAL]  Get required length of w field.
5581 
5582 ";
5583 
5584 %feature("docstring")  casadi::FunctionInternal::nnz_in() const  "
5585 
5586 [INTERNAL]  Number of input/output nonzeros.
5587 
5588 ";
5589 
5590 %feature("docstring")  casadi::FunctionInternal::nnz_in(casadi_int ind)
5591 const  "
5592 
5593 [INTERNAL]  Number of input/output nonzeros.
5594 
5595 ";
5596 
5597 %feature("docstring")  casadi::FunctionInternal::size_out(casadi_int ind)
5598 const  "
5599 
5600 [INTERNAL]  Input/output dimensions.
5601 
5602 ";
5603 
5604 %feature("docstring")
5605 casadi::FunctionInternal::instruction_output(casadi_int k) const  "
5606 
5607 [INTERNAL]  Get the (integer) output argument of an atomic operation.
5608 
5609 ";
5610 
5611 %feature("docstring")  casadi::FunctionInternal::matching_res(const
5612 std::vector< M > &arg, casadi_int &npar) const  "
5613 
5614 [INTERNAL]  Check if output arguments that needs to be replaced.
5615 
5616 Raises errors
5617 
5618 Parameters:
5619 -----------
5620 
5621 npar[in]:  normal usage: 1, disallow pararallel calls: -1
5622 
5623 npar:  max number of horizontal repetitions across all arguments (or -1)
5624 
5625 ";
5626 
5627 %feature("docstring")  casadi::ProtoFunction::alloc_mem() const  "
5628 
5629 [INTERNAL]  Create memory block.
5630 
5631 ";
5632 
5633 %feature("docstring")  casadi::BSplineInterpolant::get_forward(casadi_int
5634 nfwd, const std::string &name, const std::vector< std::string > &inames,
5635 const std::vector< std::string > &onames, const Dict &opts) const  "
5636 
5637 [INTERNAL]  Return function that calculates forward derivatives
5638 forward(nfwd) returns a cached instance if available, and calls  Function
5639 get_forward(casadi_int nfwd) if no cached version is available.
5640 
5641 ";
5642 
5643 %feature("docstring")  casadi::Interpolant::get_sparsity_out(casadi_int i)
5644 "
5645 
5646 [INTERNAL]  Sparsities of function inputs and outputs.
5647 
5648 ";
5649 
5650 %feature("docstring")
5651 casadi::FunctionInternal::jacobian_sparsity_filter(const Sparsity &sp) const
5652 "
5653 
5654 [INTERNAL]  Filter out nonzeros in the full sparsity jacobian according to
5655 is_diff_in/out.
5656 
5657 ";
5658 
5659 %feature("docstring")  casadi::FunctionInternal::fwd_seed(casadi_int nfwd)
5660 const  "
5661 
5662 [INTERNAL]  Symbolic expressions for the forward seeds.
5663 
5664 ";
5665 
5666 %feature("docstring")  casadi::FunctionInternal::sz_work(size_t &sz_arg,
5667 size_t &sz_res, size_t &sz_iw, size_t &sz_w) const  "
5668 
5669 [INTERNAL]  Get number of temporary variables needed.
5670 
5671 ";
5672 
5673 %feature("docstring")  casadi::FunctionInternal::project_res(const
5674 std::vector< M > &arg, casadi_int npar) const  "
5675 
5676 [INTERNAL]   Project sparsities.
5677 
5678 ";
5679 
5680 %feature("docstring")  casadi::FunctionInternal::get_jac(const std::string
5681 &name, const std::vector< std::string > &inames, const std::vector<
5682 std::string > &onames, const Dict &opts) const  "
5683 
5684 [INTERNAL]  Return Jacobian of all input elements with respect to all output
5685 elements.
5686 
5687 ";
5688 
5689 %feature("docstring")  casadi::FunctionInternal::sz_arg() const  "
5690 
5691 [INTERNAL]  Get required length of arg field.
5692 
5693 ";
5694 
5695 %feature("docstring")  casadi::FunctionInternal::replace_aseed(const
5696 std::vector< std::vector< M >> &aseed, casadi_int npar) const  "
5697 
5698 [INTERNAL]  Replace 0-by-0 reverse seeds.
5699 
5700 ";
5701 
5702 %feature("docstring")  casadi::FunctionInternal::replace_aseed(const
5703 std::vector< std::vector< M > > &aseed, casadi_int npar) const  "
5704 
5705 [INTERNAL] ";
5706 
5707 %feature("docstring")  casadi::FunctionInternal::get_min_in(casadi_int ind)
5708 const  "
5709 
5710 [INTERNAL]  Get smallest input value.
5711 
5712 ";
5713 
5714 %feature("docstring")  casadi::Interpolant::get_name_out(casadi_int i)  "
5715 
5716 [INTERNAL]  Names of function input and outputs.
5717 
5718 ";
5719 
5720 %feature("docstring")  casadi::FunctionInternal::which_depends(const
5721 std::string &s_in, const std::vector< std::string > &s_out, casadi_int
5722 order, bool tr=false) const  "
5723 
5724 [INTERNAL]  Which variables enter with some order.
5725 
5726 Parameters:
5727 -----------
5728 
5729 s_in:   Input name
5730 
5731 s_out:   Output name(s)
5732 
5733 order:  Only 1 (linear) and 2 (nonlinear) allowed
5734 
5735 tr:  Flip the relationship. Return which expressions contain the variables
5736 
5737 ";
5738 
5739 %feature("docstring")  casadi::FunctionInternal::eval_gen(const double
5740 **arg, double **res, casadi_int *iw, double *w, void *mem) const  "
5741 
5742 [INTERNAL]  Evaluate numerically.
5743 
5744 ";
5745 
5746 %feature("docstring")  casadi::FunctionInternal::eval_gen(const SXElem
5747 **arg, SXElem **res, casadi_int *iw, SXElem *w, void *mem) const  "
5748 
5749 [INTERNAL]  Evaluate a function, overloaded.
5750 
5751 ";
5752 
5753 %feature("docstring")  casadi::FunctionInternal::eval_gen(const bvec_t
5754 **arg, bvec_t **res, casadi_int *iw, bvec_t *w, void *mem) const  "
5755 
5756 [INTERNAL]  Evaluate a function, overloaded.
5757 
5758 ";
5759 
5760 %feature("docstring")  casadi::FunctionInternal::incache(const std::string
5761 &fname, Function &f, const std::string &suffix="") const  "
5762 
5763 [INTERNAL]  Get function in cache.
5764 
5765 ";
5766 
5767 %feature("docstring")  casadi::Interpolant::arg_grid() const  "
5768 
5769 [INTERNAL] ";
5770 
5771 %feature("docstring")  casadi::FunctionInternal::generate_out(const
5772 std::string &fname, double **res) const  "
5773 
5774 [INTERNAL] ";
5775 
5776 %feature("docstring")  casadi::FunctionInternal::sx_in(casadi_int ind) const
5777 "
5778 
5779 [INTERNAL]  Get function input(s) and output(s)
5780 
5781 ";
5782 
5783 %feature("docstring")  casadi::FunctionInternal::sx_in() const  "
5784 
5785 [INTERNAL]  Get function input(s) and output(s)
5786 
5787 ";
5788 
5789 %feature("docstring")  casadi::FunctionInternal::dm_out(casadi_int ind)
5790 const  "
5791 
5792 [INTERNAL]  Get function input(s) and output(s)
5793 
5794 ";
5795 
5796 %feature("docstring")  casadi::FunctionInternal::dm_out() const  "
5797 
5798 [INTERNAL]  Get function input(s) and output(s)
5799 
5800 ";
5801 
5802 %feature("docstring")  casadi::FunctionInternal::dm_in(casadi_int ind) const
5803 "
5804 
5805 [INTERNAL]  Get function input(s) and output(s)
5806 
5807 ";
5808 
5809 %feature("docstring")  casadi::FunctionInternal::dm_in() const  "
5810 
5811 [INTERNAL]  Get function input(s) and output(s)
5812 
5813 ";
5814 
5815 %feature("docstring")
5816 casadi::BSplineInterpolant::codegen_body(CodeGenerator &g) const  "
5817 
5818 [INTERNAL]  Generate code for the body of the C function.
5819 
5820 ";
5821 
5822 %feature("docstring")  casadi::FunctionInternal::nz_out(const std::vector<
5823 DM > &res) const  "
5824 
5825 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
5826 
5827 ";
5828 
5829 %feature("docstring")  casadi::FunctionInternal::nz_out(const std::vector<
5830 double > &res) const  "
5831 
5832 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
5833 
5834 ";
5835 
5836 %feature("docstring")  casadi::FunctionInternal::sz_iw() const  "
5837 
5838 [INTERNAL]  Get required length of iw field.
5839 
5840 ";
5841 
5842 %feature("docstring")
5843 casadi::FunctionInternal::codegen_sparsities(CodeGenerator &g) const  "
5844 
5845 [INTERNAL]  Codegen sparsities.
5846 
5847 ";
5848 
5849 %feature("docstring")  casadi::FunctionInternal::alloc_arg(size_t sz_arg,
5850 bool persistent=false) "
5851 
5852 [INTERNAL]  Ensure required length of arg field.
5853 
5854 ";
5855 
5856 %feature("docstring")  casadi::FunctionInternal::nnz_out() const  "
5857 
5858 [INTERNAL]  Number of input/output nonzeros.
5859 
5860 ";
5861 
5862 %feature("docstring")  casadi::FunctionInternal::nnz_out(casadi_int ind)
5863 const  "
5864 
5865 [INTERNAL]  Number of input/output nonzeros.
5866 
5867 ";
5868 
5869 %feature("docstring")  casadi::FunctionInternal::generate_in(const
5870 std::string &fname, const double **arg) const  "
5871 
5872 [INTERNAL]  Export an input file that can be passed to generate C code with
5873 a main.
5874 
5875 ";
5876 
5877 %feature("docstring")  casadi::FunctionInternal::has_jacobian_sparsity()
5878 const  "
5879 
5880 [INTERNAL]  Get Jacobian sparsity.
5881 
5882 ";
5883 
5884 %feature("docstring")  casadi::FunctionInternal::size1_out(casadi_int ind)
5885 const  "
5886 
5887 [INTERNAL]  Input/output dimensions.
5888 
5889 ";
5890 
5891 %feature("docstring")  casadi::FunctionInternal::codegen_name(const
5892 CodeGenerator &g, bool ns=true) const  "
5893 
5894 [INTERNAL]  Get name in codegen.
5895 
5896 ";
5897 
5898 %feature("docstring")
5899 casadi::FunctionInternal::print_dimensions(std::ostream &stream) const  "
5900 
5901 [INTERNAL]  Print dimensions of inputs and outputs.
5902 
5903 ";
5904 
5905 %feature("docstring")  casadi::BSplineInterpolant::get_reverse(casadi_int
5906 nadj, const std::string &name, const std::vector< std::string > &inames,
5907 const std::vector< std::string > &onames, const Dict &opts) const  "
5908 
5909 [INTERNAL]  Return function that calculates adjoint derivatives
5910 reverse(nadj) returns a cached instance if available, and calls  Function
5911 get_reverse(casadi_int nadj) if no cached version is available.
5912 
5913 ";
5914 
5915 %feature("docstring")  casadi::FunctionInternal::size2_out(casadi_int ind)
5916 const  "
5917 
5918 [INTERNAL]  Input/output dimensions.
5919 
5920 ";
5921 
5922 %feature("docstring")  casadi::ProtoFunction::format_time(char *buffer,
5923 double time) const  "
5924 
5925 [INTERNAL]  Format time in a fixed width 8 format.
5926 
5927 ";
5928 
5929 %feature("docstring")  casadi::FunctionInternal::replace_arg(const
5930 std::vector< M > &arg, casadi_int npar) const  "
5931 
5932 [INTERNAL]  Replace 0-by-0 inputs.
5933 
5934 ";
5935 
5936 %feature("docstring")  casadi::BSplineInterpolant::plugin_name() const  "
5937 
5938 [INTERNAL] ";
5939 
5940 %feature("docstring")  casadi::FunctionInternal::getAdaptorSolverName()
5941 const  "
5942 
5943 [INTERNAL]  Obtain solver name from Adaptor.
5944 
5945 ";
5946 
5947 %feature("docstring")  casadi::FunctionInternal::check_mat(const Sparsity
5948 &arg, const Sparsity &inp, casadi_int &npar) "
5949 
5950 [INTERNAL]  Helper function
5951 
5952 Parameters:
5953 -----------
5954 
5955 npar[in]:  normal usage: 1, disallow pararallel calls: -1
5956 
5957 npar[out]:  required number of parallel calls (or -1)
5958 
5959 ";
5960 
5961 %feature("docstring")  casadi::FunctionInternal::sp_weight() const  "
5962 
5963 [INTERNAL]  Weighting factor for chosing forward/reverse mode, sparsity
5964 propagation.
5965 
5966 ";
5967 
5968 %feature("docstring")  casadi::FunctionInternal::has_sprev() const  "
5969 
5970 [INTERNAL]  Is the class able to propagate seeds through the algorithm?
5971 
5972 ";
5973 
5974 %feature("docstring") casadi::BSplineInterpolant::BSplineInterpolant(const
5975 std::string &name, const std::vector< double > &grid, const std::vector<
5976 casadi_int > &offset, const std::vector< double > &values, casadi_int m) "
5977 
5978 [INTERNAL] ";
5979 
5980 %feature("docstring")  casadi::FunctionInternal::has_free() const  "
5981 
5982 [INTERNAL]  Does the function have free variables.
5983 
5984 ";
5985 
5986 %feature("docstring")  casadi::FunctionInternal::n_nodes() const  "
5987 
5988 [INTERNAL]  Number of nodes in the algorithm.
5989 
5990 ";
5991 
5992 %feature("docstring")  casadi::ProtoFunction::get_stats(void *mem) const  "
5993 
5994 [INTERNAL]  Get all statistics.
5995 
5996 ";
5997 
5998 %feature("docstring")  casadi::FunctionInternal::get_reltol() const  "
5999 
6000 [INTERNAL]  Get relative tolerance.
6001 
6002 ";
6003 
6004 %feature("docstring")  casadi::FunctionInternal::eval_mx(const MXVector
6005 &arg, MXVector &res, bool always_inline, bool never_inline) const  "
6006 
6007 [INTERNAL]  Evaluate with symbolic matrices.
6008 
6009 ";
6010 
6011 %feature("docstring")  casadi::FunctionInternal::convert_arg(const
6012 std::vector< M > &arg) const  "
6013 
6014 [INTERNAL]  Convert from/to input/output lists/map.
6015 
6016 ";
6017 
6018 %feature("docstring")  casadi::FunctionInternal::convert_arg(const std::map<
6019 std::string, M > &arg) const  "
6020 
6021 [INTERNAL]  Convert from/to input/output lists/map.
6022 
6023 ";
6024 
6025 %feature("docstring")  casadi::FunctionInternal::oracle() const  "
6026 
6027 [INTERNAL]  Get oracle.
6028 
6029 ";
6030 
6031 %feature("docstring")  casadi::FunctionInternal::jit_dependencies(const
6032 std::string &fname) "
6033 
6034 [INTERNAL]  Jit dependencies.
6035 
6036 ";
6037 
6038 %feature("docstring")  casadi::FunctionInternal::free_mx() const  "
6039 
6040 [INTERNAL]  Get free variables ( MX)
6041 
6042 ";
6043 
6044 %feature("docstring")  casadi::FunctionInternal::has_derivative() const  "
6045 
6046 [INTERNAL]  Can derivatives be calculated in any way?
6047 
6048 ";
6049 
6050 %feature("docstring")  casadi::FunctionInternal::generate_lifted(Function
6051 &vdef_fcn, Function &vinit_fcn) const  "
6052 
6053 [INTERNAL]  Extract the functions needed for the Lifted Newton method.
6054 
6055 ";
6056 
6057 %feature("docstring")  casadi::FunctionInternal::codegen_meta(CodeGenerator
6058 &g) const  "
6059 
6060 [INTERNAL]  Generate meta-information allowing a user to evaluate a
6061 generated function.
6062 
6063 ";
6064 
6065 %feature("docstring")  casadi::Interpolant::serialize_type(SerializingStream
6066 &s) const  "
6067 
6068 [INTERNAL]  Serialize type information.
6069 
6070 ";
6071 
6072 %feature("docstring")  casadi::FunctionInternal::generate_dependencies(const
6073 std::string &fname, const Dict &opts) const  "
6074 
6075 [INTERNAL]  Export / Generate C code for the dependency function.
6076 
6077 ";
6078 
6079 %feature("docstring")  casadi::BSplineInterpolant::get_jacobian(const
6080 std::string &name, const std::vector< std::string > &inames, const
6081 std::vector< std::string > &onames, const Dict &opts) const  "
6082 
6083 [INTERNAL]  Full Jacobian.
6084 
6085 ";
6086 
6087 %feature("docstring")  casadi::FunctionInternal::export_code(const
6088 std::string &lang, std::ostream &stream, const Dict &options) const  "
6089 
6090 [INTERNAL]  Export function in a specific language.
6091 
6092 ";
6093 
6094 %feature("docstring")  casadi::FunctionInternal::get_max_in(casadi_int ind)
6095 const  "
6096 
6097 [INTERNAL]  Get largest input value.
6098 
6099 ";
6100 
6101 %feature("docstring")  casadi::FunctionInternal::call_forward(const
6102 std::vector< MX > &arg, const std::vector< MX > &res, const std::vector<
6103 std::vector< MX > > &fseed, std::vector< std::vector< MX > > &fsens, bool
6104 always_inline, bool never_inline) const  "
6105 
6106 [INTERNAL]  Forward mode AD, virtual functions overloaded in derived
6107 classes.
6108 
6109 ";
6110 
6111 %feature("docstring")  casadi::FunctionInternal::call_forward(const
6112 std::vector< SX > &arg, const std::vector< SX > &res, const std::vector<
6113 std::vector< SX > > &fseed, std::vector< std::vector< SX > > &fsens, bool
6114 always_inline, bool never_inline) const  "
6115 
6116 [INTERNAL]  Forward mode AD, virtual functions overloaded in derived
6117 classes.
6118 
6119 ";
6120 
6121 %feature("docstring")  casadi::FunctionInternal::get_abstol() const  "
6122 
6123 [INTERNAL]  Get absolute tolerance.
6124 
6125 ";
6126 
6127 %feature("docstring")  casadi::FunctionInternal::fwdViaJac(casadi_int nfwd)
6128 const  "
6129 
6130 [INTERNAL]  Calculate derivatives by multiplying the full Jacobian and
6131 multiplying.
6132 
6133 ";
6134 
6135 %feature("docstring")  casadi::FunctionInternal::tocache(const Function &f,
6136 const std::string &suffix="") const  "
6137 
6138 [INTERNAL]  Save function to cache.
6139 
6140 ";
6141 
6142 %feature("docstring")
6143 casadi::FunctionInternal::codegen_init_mem(CodeGenerator &g) const  "
6144 
6145 [INTERNAL]  Codegen decref for init_mem.
6146 
6147 ";
6148 
6149 %feature("docstring")  casadi::BSplineInterpolant::class_name() const  "
6150 
6151 [INTERNAL]  Get type name.
6152 
6153 ";
6154 
6155 %feature("docstring")  casadi::FunctionInternal::codegen_mem_type() const  "
6156 
6157 [INTERNAL]  Thread-local memory object type.
6158 
6159 ";
6160 
6161 %feature("docstring")  casadi::FunctionInternal::size1_in(casadi_int ind)
6162 const  "
6163 
6164 [INTERNAL]  Input/output dimensions.
6165 
6166 ";
6167 
6168 %feature("docstring")  casadi::BSplineInterpolant::sp_reverse(bvec_t **arg,
6169 bvec_t **res, casadi_int *iw, bvec_t *w, void *mem) const  "
6170 
6171 [INTERNAL]  Propagate sparsity backwards.
6172 
6173 ";
6174 
6175 %feature("docstring")  casadi::FunctionInternal::numel_in() const  "
6176 
6177 [INTERNAL]  Number of input/output elements.
6178 
6179 ";
6180 
6181 %feature("docstring")  casadi::FunctionInternal::numel_in(casadi_int ind)
6182 const  "
6183 
6184 [INTERNAL]  Number of input/output elements.
6185 
6186 ";
6187 
6188 %feature("docstring")  casadi::FunctionInternal::sparsity_out(casadi_int
6189 ind) const  "
6190 
6191 [INTERNAL]  Input/output sparsity.
6192 
6193 ";
6194 
6195 %feature("docstring")  casadi::BSplineInterpolant::eval(const double **arg,
6196 double **res, casadi_int *iw, double *w, void *mem) const  "
6197 
6198 [INTERNAL]  Evaluate numerically.
6199 
6200 ";
6201 
6202 %feature("docstring")  casadi::BSplineInterpolant::has_codegen() const  "
6203 
6204 [INTERNAL]  Is codegen supported?
6205 
6206 ";
6207 
6208 %feature("docstring")
6209 casadi::FunctionInternal::codegen_alloc_mem(CodeGenerator &g) const  "
6210 
6211 [INTERNAL]  Codegen decref for alloc_mem.
6212 
6213 ";
6214 
6215 %feature("docstring")  casadi::FunctionInternal::reverse(casadi_int nadj)
6216 const  "
6217 
6218 [INTERNAL]  Return function that calculates adjoint derivatives
6219 reverse(nadj) returns a cached instance if available, and calls  Function
6220 get_reverse(casadi_int nadj) if no cached version is available.
6221 
6222 ";
6223 
6224 %feature("docstring")  casadi::FunctionInternal::alloc_w(size_t sz_w, bool
6225 persistent=false) "
6226 
6227 [INTERNAL]  Ensure required length of w field.
6228 
6229 ";
6230 
6231 %feature("docstring")  casadi::FunctionInternal::info() const  "
6232 
6233 [INTERNAL]  Obtain information about function
6234 
6235 ";
6236 
6237 %feature("docstring")  casadi::FunctionInternal::n_instructions() const  "
6238 
6239 [INTERNAL]  Get the number of atomic operations.
6240 
6241 ";
6242 
6243 %feature("docstring")  casadi::FunctionInternal::signature(const std::string
6244 &fname) const  "
6245 
6246 [INTERNAL]  Code generate the function.
6247 
6248 ";
6249 
6250 %feature("docstring")
6251 casadi::FunctionInternal::getJacSparsityHierarchicalSymm(casadi_int iind,
6252 casadi_int oind) const  "
6253 
6254 [INTERNAL]  A flavor of getJacSparsity that does hierarchical block
6255 structure recognition for symmetric Jacobians
6256 
6257 ";
6258 
6259 %feature("docstring")  casadi::FunctionInternal::instructions_sx() const  "
6260 
6261 [INTERNAL]  get SX expression associated with instructions
6262 
6263 ";
6264 
6265 %feature("docstring")  casadi::BSplineInterpolant::has_reverse(casadi_int
6266 nadj) const  "
6267 
6268 [INTERNAL]  Return function that calculates adjoint derivatives
6269 reverse(nadj) returns a cached instance if available, and calls  Function
6270 get_reverse(casadi_int nadj) if no cached version is available.
6271 
6272 ";
6273 
6274 %feature("docstring")  casadi::FunctionInternal::get_partition(casadi_int
6275 iind, casadi_int oind, Sparsity &D1, Sparsity &D2, bool compact, bool
6276 symmetric, bool allow_forward, bool allow_reverse) const  "
6277 
6278 [INTERNAL]  Get the unidirectional or bidirectional partition.
6279 
6280 ";
6281 
6282 %feature("docstring")  casadi::ProtoFunction::print_time(const std::map<
6283 std::string, FStats > &fstats) const  "
6284 
6285 [INTERNAL]  Print timing statistics.
6286 
6287 ";
6288 
6289 %feature("docstring")  casadi::Interpolant::get_name_in(casadi_int i)  "
6290 
6291 [INTERNAL]  Names of function input and outputs.
6292 
6293 ";
6294 
6295 
6296 // File: classcasadi_1_1BSplineParametric.xml
6297 
6298 
6299 // File: classcasadi_1_1Call.xml
6300 
6301 
6302 // File: classcasadi_1_1Callback.xml
6303 %feature("docstring")  casadi::Function::convert_out(const std::vector< DM >
6304 &arg) const  "
6305 
6306 Convert from/to input/output lists/map.
6307 
6308 Will raise an error when an unknown key is used or a list has incorrect
6309 size. Does not perform sparsity checking.
6310 
6311 ";
6312 
6313 %feature("docstring")  casadi::Function::convert_out(const DMDict &arg)
6314 const  "
6315 
6316 Convert from/to input/output lists/map.
6317 
6318 Will raise an error when an unknown key is used or a list has incorrect
6319 size. Does not perform sparsity checking.
6320 
6321 ";
6322 
6323 %feature("docstring")  casadi::Function::convert_out(const std::vector< SX >
6324 &arg) const  "
6325 
6326 Convert from/to input/output lists/map.
6327 
6328 Will raise an error when an unknown key is used or a list has incorrect
6329 size. Does not perform sparsity checking.
6330 
6331 ";
6332 
6333 %feature("docstring")  casadi::Function::convert_out(const SXDict &arg)
6334 const  "
6335 
6336 Convert from/to input/output lists/map.
6337 
6338 Will raise an error when an unknown key is used or a list has incorrect
6339 size. Does not perform sparsity checking.
6340 
6341 ";
6342 
6343 %feature("docstring")  casadi::Function::convert_out(const std::vector< MX >
6344 &arg) const  "
6345 
6346 Convert from/to input/output lists/map.
6347 
6348 Will raise an error when an unknown key is used or a list has incorrect
6349 size. Does not perform sparsity checking.
6350 
6351 ";
6352 
6353 %feature("docstring")  casadi::Function::convert_out(const MXDict &arg)
6354 const  "
6355 
6356 Convert from/to input/output lists/map.
6357 
6358 Will raise an error when an unknown key is used or a list has incorrect
6359 size. Does not perform sparsity checking.
6360 
6361 ";
6362 
6363 %feature("docstring")  casadi::Callback::has_forward(casadi_int nfwd) const
6364 "
6365 
6366 Return function that calculates forward derivatives forward(nfwd) returns a
6367 cached instance if available, and calls  Function get_forward(casadi_int
6368 nfwd) if no cached version is available.
6369 
6370 ";
6371 
6372 %feature("docstring")  casadi::Function::size2_in(casadi_int ind) const  "
6373 
6374 Get input dimension.
6375 
6376 ";
6377 
6378 %feature("docstring")  casadi::Function::size2_in(const std::string &iname)
6379 const  "
6380 
6381 Get input dimension.
6382 
6383 ";
6384 
6385 %feature("docstring")  casadi::Function::call(const std::vector< DM > &arg,
6386 std::vector< DM > &output_res, bool always_inline=false, bool
6387 never_inline=false) const  "
6388 
6389 Evaluate the function symbolically or numerically.
6390 
6391 ";
6392 
6393 %feature("docstring")  casadi::Function::call(const std::vector< SX > &arg,
6394 std::vector< SX > &output_res, bool always_inline=false, bool
6395 never_inline=false) const  "
6396 
6397 Generate a Jacobian function of output oind with respect to input iind.
6398 
6399 Parameters:
6400 -----------
6401 
6402 iind:  The index of the input
6403 
6404 oind:  The index of the output Legacy function: To be deprecated in a future
6405 version of CasADi. Exists only for compatibility with Function::jacobian
6406 pre-CasADi 3.2
6407 
6408 ";
6409 
6410 %feature("docstring")  casadi::Function::call(const std::vector< MX > &arg,
6411 std::vector< MX > &output_res, bool always_inline=false, bool
6412 never_inline=false) const  "
6413 
6414 Generate a Jacobian function of output oind with respect to input iind.
6415 
6416 Parameters:
6417 -----------
6418 
6419 iind:  The index of the input
6420 
6421 oind:  The index of the output Legacy function: To be deprecated in a future
6422 version of CasADi. Exists only for compatibility with Function::jacobian
6423 pre-CasADi 3.2
6424 
6425 ";
6426 
6427 %feature("docstring")  casadi::Function::call(const DMDict &arg, DMDict
6428 &output_res, bool always_inline=false, bool never_inline=false) const  "
6429 
6430 Generate a Jacobian function of output oind with respect to input iind.
6431 
6432 Parameters:
6433 -----------
6434 
6435 iind:  The index of the input
6436 
6437 oind:  The index of the output Legacy function: To be deprecated in a future
6438 version of CasADi. Exists only for compatibility with Function::jacobian
6439 pre-CasADi 3.2
6440 
6441 ";
6442 
6443 %feature("docstring")  casadi::Function::call(const SXDict &arg, SXDict
6444 &output_res, bool always_inline=false, bool never_inline=false) const  "
6445 
6446 Generate a Jacobian function of output oind with respect to input iind.
6447 
6448 Parameters:
6449 -----------
6450 
6451 iind:  The index of the input
6452 
6453 oind:  The index of the output Legacy function: To be deprecated in a future
6454 version of CasADi. Exists only for compatibility with Function::jacobian
6455 pre-CasADi 3.2
6456 
6457 ";
6458 
6459 %feature("docstring")  casadi::Function::call(const MXDict &arg, MXDict
6460 &output_res, bool always_inline=false, bool never_inline=false) const  "
6461 
6462 Generate a Jacobian function of output oind with respect to input iind.
6463 
6464 Parameters:
6465 -----------
6466 
6467 iind:  The index of the input
6468 
6469 oind:  The index of the output Legacy function: To be deprecated in a future
6470 version of CasADi. Exists only for compatibility with Function::jacobian
6471 pre-CasADi 3.2
6472 
6473 ";
6474 
6475 %feature("docstring")  casadi::Function::generate_dependencies(const
6476 std::string &fname, const Dict &opts=Dict()) const  "
6477 
6478 Export / Generate C code for the dependency function.
6479 
6480 ";
6481 
6482 %feature("docstring")  casadi::Callback::get_n_in() "
6483 
6484 Get the number of inputs This function is called during construction.
6485 
6486 ";
6487 
6488 %feature("docstring")  casadi::Callback::get_n_out() "
6489 
6490 Get the number of outputs This function is called during construction.
6491 
6492 ";
6493 
6494 %feature("docstring")  casadi::Function::size_in(casadi_int ind) const  "
6495 
6496 Get input dimension.
6497 
6498 ";
6499 
6500 %feature("docstring")  casadi::Function::size_in(const std::string &iname)
6501 const  "
6502 
6503 Get input dimension.
6504 
6505 ";
6506 
6507 %feature("docstring")  casadi::Function::reverse(casadi_int nadj) const  "
6508 
6509 Get a function that calculates nadj adjoint derivatives.
6510 
6511 Returns a function with n_in + n_out + n_out inputs and n_in outputs. The
6512 first n_in inputs correspond to nondifferentiated inputs. The next n_out
6513 inputs correspond to nondifferentiated outputs. and the last n_out inputs
6514 correspond to adjoint seeds, stacked horizontally The n_in outputs
6515 correspond to adjoint sensitivities, stacked horizontally. * (n_in = n_in(),
6516 n_out = n_out())
6517 
6518 (n_in = n_in(), n_out = n_out())
6519 
6520 The functions returned are cached, meaning that if called multiple timed
6521 with the same value, then multiple references to the same function will be
6522 returned.
6523 
6524 ";
6525 
6526 %feature("docstring") casadi::casadi_reverse "
6527 
6528 Get a function that calculates nadj adjoint derivatives.
6529 
6530 Returns a function with n_in + n_out + n_out inputs and n_in outputs. The
6531 first n_in inputs correspond to nondifferentiated inputs. The next n_out
6532 inputs correspond to nondifferentiated outputs. and the last n_out inputs
6533 correspond to adjoint seeds, stacked horizontally The n_in outputs
6534 correspond to adjoint sensitivities, stacked horizontally. * (n_in = n_in(),
6535 n_out = n_out())
6536 
6537 (n_in = n_in(), n_out = n_out())
6538 
6539 The functions returned are cached, meaning that if called multiple timed
6540 with the same value, then multiple references to the same function will be
6541 returned.
6542 
6543 ";
6544 
6545 %feature("docstring")  casadi::Function::casadi_reverse "
6546 
6547 Get a function that calculates nadj adjoint derivatives.
6548 
6549 Returns a function with n_in + n_out + n_out inputs and n_in outputs. The
6550 first n_in inputs correspond to nondifferentiated inputs. The next n_out
6551 inputs correspond to nondifferentiated outputs. and the last n_out inputs
6552 correspond to adjoint seeds, stacked horizontally The n_in outputs
6553 correspond to adjoint sensitivities, stacked horizontally. * (n_in = n_in(),
6554 n_out = n_out())
6555 
6556 (n_in = n_in(), n_out = n_out())
6557 
6558 The functions returned are cached, meaning that if called multiple timed
6559 with the same value, then multiple references to the same function will be
6560 returned.
6561 
6562 ";
6563 
6564 %feature("docstring")  casadi::Callback::get_jacobian_sparsity() const  "
6565 
6566 Return sparsity of Jacobian of all input elements with respect to all output
6567 elements.
6568 
6569 ";
6570 
6571 %feature("docstring")  casadi::Function::instruction_id(casadi_int k) const
6572 "
6573 
6574 Identifier index of the instruction (SXFunction/MXFunction)
6575 
6576 ";
6577 
6578 %feature("docstring")  casadi::Function::wrap_as_needed(const Dict &opts)
6579 const  "
6580 
6581 Wrap in a Function with options.
6582 
6583 ";
6584 
6585 %feature("docstring")  casadi::Function::sz_arg() const  "
6586 
6587 Get required length of arg field.
6588 
6589 ";
6590 
6591 %feature("docstring")  casadi::Function::slice(const std::string &name,
6592 const std::vector< casadi_int > &order_in, const std::vector< casadi_int >
6593 &order_out, const Dict &opts=Dict()) const  "
6594 
6595 returns a new function with a selection of inputs/outputs of the original
6596 
6597 ";
6598 
6599 %feature("docstring") casadi::casadi_slice "
6600 
6601 returns a new function with a selection of inputs/outputs of the original
6602 
6603 ";
6604 
6605 %feature("docstring")  casadi::Function::casadi_slice "
6606 
6607 returns a new function with a selection of inputs/outputs of the original
6608 
6609 ";
6610 
6611 %feature("docstring")  casadi::Function::export_code(const std::string
6612 &lang, const std::string &fname, const Dict &options=Dict()) const  "
6613 
6614 Export function in specific language.
6615 
6616 Only allowed for (a subset of) SX/MX Functions
6617 
6618 ";
6619 
6620 %feature("docstring")  casadi::Function::export_code(const std::string
6621 &lang, const Dict &options=Dict()) const  "
6622 
6623 Export function in specific language.
6624 
6625 Only allowed for (a subset of) SX/MX Functions
6626 
6627 ";
6628 
6629 %feature("docstring")  casadi::Function::hessian_old(casadi_int iind,
6630 casadi_int oind) const  "
6631 
6632 Generate a Hessian function of output oind with respect to input iind.
6633 
6634 Parameters:
6635 -----------
6636 
6637 iind:  The index of the input
6638 
6639 oind:  The index of the output Legacy function: To be deprecated in a future
6640 version of CasADi. Exists only for compatibility with Function::hessian pre-
6641 CasADi 3.2
6642 
6643 ";
6644 
6645 %feature("docstring")  casadi::Function::nnz_out() const  "
6646 
6647 Get number of output nonzeros.
6648 
6649 For a particular output or for all of the outputs
6650 
6651 ";
6652 
6653 %feature("docstring")  casadi::Function::nnz_out(casadi_int ind) const  "
6654 
6655 Get number of output nonzeros.
6656 
6657 For a particular output or for all of the outputs
6658 
6659 ";
6660 
6661 %feature("docstring")  casadi::Function::nnz_out(const std::string &oname)
6662 const  "
6663 
6664 Get number of output nonzeros.
6665 
6666 For a particular output or for all of the outputs
6667 
6668 ";
6669 
6670 %feature("docstring")  casadi::Function::mapsum(const std::vector< MX > &x,
6671 const std::string &parallelization="serial") const  "
6672 
6673 Evaluate symbolically in parallel and sum (matrix graph)
6674 
6675 Parameters:
6676 -----------
6677 
6678 parallelization:  Type of parallelization used: unroll|serial|openmp
6679 
6680 ";
6681 
6682 %feature("docstring")  casadi::Function::free_sx() const  "
6683 
6684 Get all the free variables of the function.
6685 
6686 ";
6687 
6688 %feature("docstring")  casadi::Function::name_out() const  "
6689 
6690 Get output scheme.
6691 
6692 ";
6693 
6694 %feature("docstring")  casadi::Function::name_out(casadi_int ind) const  "
6695 
6696 Get output scheme name by index.
6697 
6698 ";
6699 
6700 %feature("docstring")  casadi::Function::nnz_in() const  "
6701 
6702 Get number of input nonzeros.
6703 
6704 For a particular input or for all of the inputs
6705 
6706 ";
6707 
6708 %feature("docstring")  casadi::Function::nnz_in(casadi_int ind) const  "
6709 
6710 Get number of input nonzeros.
6711 
6712 For a particular input or for all of the inputs
6713 
6714 ";
6715 
6716 %feature("docstring")  casadi::Function::nnz_in(const std::string &iname)
6717 const  "
6718 
6719 Get number of input nonzeros.
6720 
6721 For a particular input or for all of the inputs
6722 
6723 ";
6724 
6725 %feature("docstring")  casadi::Function::forward(casadi_int nfwd) const  "
6726 
6727 Get a function that calculates nfwd forward derivatives.
6728 
6729 Returns a function with n_in + n_out + n_in inputs and nfwd outputs. The
6730 first n_in inputs correspond to nondifferentiated inputs. The next n_out
6731 inputs correspond to nondifferentiated outputs. and the last n_in inputs
6732 correspond to forward seeds, stacked horizontally The n_out outputs
6733 correspond to forward sensitivities, stacked horizontally. * (n_in = n_in(),
6734 n_out = n_out())
6735 
6736 The functions returned are cached, meaning that if called multiple timed
6737 with the same value, then multiple references to the same function will be
6738 returned.
6739 
6740 ";
6741 
6742 %feature("docstring") casadi::casadi_forward "
6743 
6744 Get a function that calculates nfwd forward derivatives.
6745 
6746 Returns a function with n_in + n_out + n_in inputs and nfwd outputs. The
6747 first n_in inputs correspond to nondifferentiated inputs. The next n_out
6748 inputs correspond to nondifferentiated outputs. and the last n_in inputs
6749 correspond to forward seeds, stacked horizontally The n_out outputs
6750 correspond to forward sensitivities, stacked horizontally. * (n_in = n_in(),
6751 n_out = n_out())
6752 
6753 The functions returned are cached, meaning that if called multiple timed
6754 with the same value, then multiple references to the same function will be
6755 returned.
6756 
6757 ";
6758 
6759 %feature("docstring")  casadi::Function::casadi_forward "
6760 
6761 Get a function that calculates nfwd forward derivatives.
6762 
6763 Returns a function with n_in + n_out + n_in inputs and nfwd outputs. The
6764 first n_in inputs correspond to nondifferentiated inputs. The next n_out
6765 inputs correspond to nondifferentiated outputs. and the last n_in inputs
6766 correspond to forward seeds, stacked horizontally The n_out outputs
6767 correspond to forward sensitivities, stacked horizontally. * (n_in = n_in(),
6768 n_out = n_out())
6769 
6770 The functions returned are cached, meaning that if called multiple timed
6771 with the same value, then multiple references to the same function will be
6772 returned.
6773 
6774 ";
6775 
6776 %feature("docstring")  casadi::Function::default_in(casadi_int ind) const  "
6777 
6778 Get default input value.
6779 
6780 ";
6781 
6782 %feature("docstring")  casadi::Callback::init() "
6783 
6784 Initialize the object This function is called after the object construction
6785 (for the whole class hierarchy) is complete, but before the finalization
6786 step. It is called recursively for the whole class hierarchy, starting with
6787 the lowest level.
6788 
6789 ";
6790 
6791 %feature("docstring")  casadi::Function::numel_out() const  "
6792 
6793 Get number of output elements.
6794 
6795 For a particular output or for all of the outputs
6796 
6797 ";
6798 
6799 %feature("docstring")  casadi::Function::numel_out(casadi_int ind) const  "
6800 
6801 Get number of output elements.
6802 
6803 For a particular output or for all of the outputs
6804 
6805 ";
6806 
6807 %feature("docstring")  casadi::Function::numel_out(const std::string &oname)
6808 const  "
6809 
6810 Get number of output elements.
6811 
6812 For a particular output or for all of the outputs
6813 
6814 ";
6815 
6816 %feature("docstring")  casadi::Function::print_dimensions(std::ostream
6817 &stream=casadi::uout()) const  "
6818 
6819 Print dimensions of inputs and outputs.
6820 
6821 ";
6822 
6823 %feature("docstring")  casadi::Function::generate(const std::string &fname,
6824 const Dict &opts=Dict()) const  "
6825 
6826 Export / Generate C code for the function.
6827 
6828 ";
6829 
6830 %feature("docstring")  casadi::Function::generate(const Dict &opts=Dict())
6831 const  "
6832 
6833 Export / Generate C code for the function.
6834 
6835 ";
6836 
6837 %feature("docstring")  casadi::Function::instruction_input(casadi_int k)
6838 const  "
6839 
6840 Locations in the work vector for the inputs of the instruction
6841 (SXFunction/MXFunction)
6842 
6843 ";
6844 
6845 %feature("docstring")  casadi::Function::sz_iw() const  "
6846 
6847 Get required length of iw field.
6848 
6849 ";
6850 
6851 %feature("docstring")  casadi::SharedObject::is_null() const  "
6852 
6853 Is a null pointer?
6854 
6855 ";
6856 
6857 %feature("docstring")  casadi::Function::is_diff_in(casadi_int ind) const  "
6858 
6859 Get differentiability of inputs/output.
6860 
6861 ";
6862 
6863 %feature("docstring")  casadi::Function::is_diff_in() const  "
6864 
6865 Get differentiability of inputs/output.
6866 
6867 ";
6868 
6869 %feature("docstring")  casadi::Callback::has_reverse(casadi_int nadj) const
6870 "
6871 
6872 Return function that calculates adjoint derivatives reverse(nadj) returns a
6873 cached instance if available, and calls  Function get_reverse(casadi_int
6874 nadj) if no cached version is available.
6875 
6876 ";
6877 
6878 %feature("docstring")  casadi::Function::jacobian() const  "
6879 
6880 Generate a Jacobian function of all the inputs elements with respect to all
6881 the output elements).
6882 
6883 ";
6884 
6885 %feature("docstring") casadi::casadi_jacobian "
6886 
6887 Generate a Jacobian function of all the inputs elements with respect to all
6888 the output elements).
6889 
6890 ";
6891 
6892 %feature("docstring")  casadi::Function::casadi_jacobian "
6893 
6894 Generate a Jacobian function of all the inputs elements with respect to all
6895 the output elements).
6896 
6897 ";
6898 
6899 %feature("docstring")  casadi::Function::expand() const  "
6900 
6901 Expand a function to SX.
6902 
6903 ";
6904 
6905 %feature("docstring") casadi::casadi_expand "
6906 
6907 Expand a function to SX.
6908 
6909 ";
6910 
6911 %feature("docstring")  casadi::Function::casadi_expand "
6912 
6913 Expand a function to SX.
6914 
6915 ";
6916 
6917 %feature("docstring")  casadi::Function::expand(const std::string &name,
6918 const Dict &opts=Dict()) const  "
6919 
6920 Expand a function to SX.
6921 
6922 ";
6923 
6924 %feature("docstring") casadi::casadi_expand "
6925 
6926 Expand a function to SX.
6927 
6928 ";
6929 
6930 %feature("docstring")  casadi::Function::casadi_expand "
6931 
6932 Expand a function to SX.
6933 
6934 ";
6935 
6936 %feature("docstring")  casadi::Function::sx_out(casadi_int oind) const  "
6937 
6938 Get symbolic primitives equivalent to the output expressions There is no
6939 guarantee that subsequent calls return unique answers.
6940 
6941 ";
6942 
6943 %feature("docstring")  casadi::Function::sx_out(const std::string &oname)
6944 const  "
6945 
6946 Get symbolic primitives equivalent to the output expressions There is no
6947 guarantee that subsequent calls return unique answers.
6948 
6949 ";
6950 
6951 %feature("docstring")  casadi::Function::sx_out() const  "
6952 
6953 Get symbolic primitives equivalent to the output expressions There is no
6954 guarantee that subsequent calls return unique answers.
6955 
6956 ";
6957 
6958 %feature("docstring")  casadi::Function::print_options(std::ostream
6959 &stream=casadi::uout()) const  "
6960 
6961 Print options to a stream.
6962 
6963 ";
6964 
6965 %feature("docstring")  casadi::Function::generate_out(const std::string
6966 &fname, const std::vector< DM > &arg) "
6967 
6968 Export an output file that can be checked with generated C code output.
6969 
6970 generate_in  convert_out to convert between dict/map and vector
6971 
6972 ";
6973 
6974 %feature("docstring")  casadi::Function::generate_out(const std::string
6975 &fname) "
6976 
6977 Export an output file that can be checked with generated C code output.
6978 
6979 generate_in  convert_out to convert between dict/map and vector
6980 
6981 ";
6982 
6983 %feature("docstring")  casadi::Function::checkout() const  "
6984 
6985 Checkout a memory object.
6986 
6987 ";
6988 
6989 %feature("docstring") casadi::Callback::Callback() "
6990 
6991 Default constructor.
6992 
6993 ";
6994 
6995 %feature("docstring") casadi::Callback::Callback(const Callback &obj) "
6996 
6997 Copy constructor (throws an error)
6998 
6999 ";
7000 
7001 %feature("docstring") casadi::Callback::~Callback "
7002 
7003 Destructor.
7004 
7005 ";
7006 
7007 %feature("docstring")  casadi::Function::instruction_output(casadi_int k)
7008 const  "
7009 
7010 Location in the work vector for the output of the instruction
7011 (SXFunction/MXFunction)
7012 
7013 ";
7014 
7015 %feature("docstring")  casadi::Callback::uses_output() const  "
7016 
7017 Do the derivative functions need nondifferentiated outputs?
7018 
7019 ";
7020 
7021 %feature("docstring")  casadi::Function::jac() const  "
7022 
7023 Calculate all Jacobian blocks Generates a function that takes all non-
7024 differentiated inputs and outputs and calculates all Jacobian blocks. Inputs
7025 that are not needed by the routine are all-zero sparse matrices with the
7026 correct dimensions. Output blocks that are not calculated, e.g. if the
7027 corresponding input or output is marked non-differentiated are also all-zero
7028 sparse. The Jacobian blocks are sorted starting by all the blocks for the
7029 first output, then all the blocks for the second output and so on. E.g.
7030 f:(x,y)->(r,s) results in the function jac_f:(x,y,r,s)->(dr_dx, dr_dy,
7031 ds_dx, ds_dy) This function is cached.
7032 
7033 ";
7034 
7035 %feature("docstring")  casadi::Function::has_spfwd() const  "
7036 
7037 Is the class able to propagate seeds through the algorithm?
7038 
7039 ";
7040 
7041 %feature("docstring")  casadi::Function::which_depends(const std::string
7042 &s_in, const std::vector< std::string > &s_out, casadi_int order=1, bool
7043 tr=false) const  "
7044 
7045 Which variables enter with some order.
7046 
7047 Parameters:
7048 -----------
7049 
7050 order:  Only 1 (linear) and 2 (nonlinear) allowed
7051 
7052 tr:  Flip the relationship. Return which expressions contain the variables
7053 
7054 ";
7055 
7056 %feature("docstring") casadi::casadi_which_depends "
7057 
7058 Which variables enter with some order.
7059 
7060 Parameters:
7061 -----------
7062 
7063 order:  Only 1 (linear) and 2 (nonlinear) allowed
7064 
7065 tr:  Flip the relationship. Return which expressions contain the variables
7066 
7067 ";
7068 
7069 %feature("docstring")  casadi::Function::casadi_which_depends "
7070 
7071 Which variables enter with some order.
7072 
7073 Parameters:
7074 -----------
7075 
7076 order:  Only 1 (linear) and 2 (nonlinear) allowed
7077 
7078 tr:  Flip the relationship. Return which expressions contain the variables
7079 
7080 ";
7081 
7082 %feature("docstring")  casadi::Function::jit(const std::string &name, const
7083 std::string &body, const std::vector< std::string > &name_in, const
7084 std::vector< std::string > &name_out, const Dict &opts=Dict()) "
7085 
7086 To resolve ambiguity on some compilers.
7087 
7088 Create a just-in-time compiled function from a C language string The names
7089 and sparsity patterns of all the inputs and outputs must be provided. If
7090 sparsities are not provided, all inputs and outputs are assumed to be
7091 scalar. Only specify the function body, assuming that input and output
7092 nonzeros are stored in arrays with the specified naming convension. The data
7093 type used is 'casadi_real', which is typically equal to 'double` or another
7094 data type with the same API as 'double'.
7095 
7096 Inputs may be null pointers. This means that the all entries are zero.
7097 Outputs may be null points. This means that the corresponding result can be
7098 ignored.
7099 
7100 If an error occurs in the evaluation, issue \"return 1;\";
7101 
7102 The final generated function will have a structure similar to:
7103 
7104 casadi_int fname(const casadi_real** arg, casadi_real** res, casadi_int* iw,
7105 casadi_real* w, void* mem) { const casadi_real *x1, *x2; casadi_real *r1,
7106 *r2; x1 = *arg++; x2 = *arg++; r1 = *res++; r2 = *res++; <FUNCTION_BODY>
7107 return 0; }
7108 
7109 ";
7110 
7111 %feature("docstring")  casadi::Function::jit(const std::string &name, const
7112 std::string &body, const std::vector< std::string > &name_in, const
7113 std::vector< std::string > &name_out, const std::vector< Sparsity >
7114 &sparsity_in, const std::vector< Sparsity > &sparsity_out, const Dict
7115 &opts=Dict()) "
7116 
7117 To resolve ambiguity on some compilers.
7118 
7119 Create a just-in-time compiled function from a C language string The names
7120 and sparsity patterns of all the inputs and outputs must be provided. If
7121 sparsities are not provided, all inputs and outputs are assumed to be
7122 scalar. Only specify the function body, assuming that input and output
7123 nonzeros are stored in arrays with the specified naming convension. The data
7124 type used is 'casadi_real', which is typically equal to 'double` or another
7125 data type with the same API as 'double'.
7126 
7127 Inputs may be null pointers. This means that the all entries are zero.
7128 Outputs may be null points. This means that the corresponding result can be
7129 ignored.
7130 
7131 If an error occurs in the evaluation, issue \"return 1;\";
7132 
7133 The final generated function will have a structure similar to:
7134 
7135 casadi_int fname(const casadi_real** arg, casadi_real** res, casadi_int* iw,
7136 casadi_real* w, void* mem) { const casadi_real *x1, *x2; casadi_real *r1,
7137 *r2; x1 = *arg++; x2 = *arg++; r1 = *res++; r2 = *res++; <FUNCTION_BODY>
7138 return 0; }
7139 
7140 ";
7141 
7142 %feature("docstring")  casadi::Function::get_free() const  "
7143 
7144 Get free variables as a string.
7145 
7146 ";
7147 
7148 %feature("docstring")  casadi::Function::index_out(const std::string &name)
7149 const  "
7150 
7151 Find the index for a string describing a particular entry of an output
7152 scheme.
7153 
7154 example: schemeEntry(\"x_opt\") -> returns NLPSOL_X if FunctionInternal
7155 adheres to SCHEME_NLPINput
7156 
7157 ";
7158 
7159 %feature("docstring")  casadi::Callback::construct(const std::string &name,
7160 const Dict &opts=Dict()) "
7161 
7162 Construct internal object This is the step that actually construct the
7163 internal object, as the class constructor only creates a null pointer. It
7164 should be called from the user constructor.
7165 
7166 ";
7167 
7168 %feature("docstring")  casadi::Function::save(const std::string &fname,
7169 const Dict &opts=Dict()) const  "
7170 
7171 Export function in specific language.
7172 
7173 Only allowed for (a subset of) SX/MX Functions
7174 
7175 ";
7176 
7177 %feature("docstring")  casadi::Function::has_sprev() const  "
7178 
7179 Is the class able to propagate seeds through the algorithm?
7180 
7181 ";
7182 
7183 %feature("docstring")  casadi::Function::sx_in(casadi_int iind) const  "
7184 
7185 Get symbolic primitives equivalent to the input expressions There is no
7186 guarantee that subsequent calls return unique answers.
7187 
7188 ";
7189 
7190 %feature("docstring")  casadi::Function::sx_in(const std::string &iname)
7191 const  "
7192 
7193 Get symbolic primitives equivalent to the input expressions There is no
7194 guarantee that subsequent calls return unique answers.
7195 
7196 ";
7197 
7198 %feature("docstring")  casadi::Function::sx_in() const  "
7199 
7200 Get symbolic primitives equivalent to the input expressions There is no
7201 guarantee that subsequent calls return unique answers.
7202 
7203 ";
7204 
7205 %feature("docstring")  casadi::Callback::get_forward(casadi_int nfwd, const
7206 std::string &name, const std::vector< std::string > &inames, const
7207 std::vector< std::string > &onames, const Dict &opts) const  "
7208 
7209 Return function that calculates forward derivatives forward(nfwd) returns a
7210 cached instance if available, and calls  Function get_forward(casadi_int
7211 nfwd) if no cached version is available.
7212 
7213 ";
7214 
7215 %feature("docstring")  casadi::Function::max_in(casadi_int ind) const  "
7216 
7217 Get largest input value.
7218 
7219 ";
7220 
7221 %feature("docstring")  casadi::Function::min_in(casadi_int ind) const  "
7222 
7223 Get smallest input value.
7224 
7225 ";
7226 
7227 %feature("docstring")  casadi::Function::nz_from_out(const std::vector< DM >
7228 &arg) const  "
7229 
7230 Convert from/to flat vector of input/output nonzeros.
7231 
7232 ";
7233 
7234 %feature("docstring")  casadi::Function::sparsity_jac(casadi_int iind,
7235 casadi_int oind, bool compact=false, bool symmetric=false) const  "
7236 
7237 Get, if necessary generate, the sparsity of a Jacobian block
7238 
7239 ";
7240 
7241 %feature("docstring")  casadi::Function::sparsity_jac(const std::string
7242 &iind, casadi_int oind=0, bool compact=false, bool symmetric=false) const  "
7243 
7244 Get, if necessary generate, the sparsity of a Jacobian block
7245 
7246 ";
7247 
7248 %feature("docstring")  casadi::Function::sparsity_jac(casadi_int iind, const
7249 std::string &oind, bool compact=false, bool symmetric=false) const  "
7250 
7251 Get, if necessary generate, the sparsity of a Jacobian block
7252 
7253 ";
7254 
7255 %feature("docstring")  casadi::Function::sparsity_jac(const std::string
7256 &iind, const std::string &oind, bool compact=false, bool symmetric=false)
7257 const  "
7258 
7259 Get, if necessary generate, the sparsity of a Jacobian block
7260 
7261 ";
7262 
7263 %feature("docstring")  casadi::SharedObject::class_name() const  "
7264 
7265 Get class name.
7266 
7267 ";
7268 
7269 %feature("docstring")  casadi::Function::nz_to_out(const std::vector< double
7270 > &arg) const  "
7271 
7272 Convert from/to flat vector of input/output nonzeros.
7273 
7274 ";
7275 
7276 %feature("docstring")  casadi::Function::nz_to_in(const std::vector< double
7277 > &arg) const  "
7278 
7279 Convert from/to flat vector of input/output nonzeros.
7280 
7281 ";
7282 
7283 %feature("docstring")  casadi::SharedObject::get_str(bool more=false) const
7284 "
7285 
7286 Get string representation.
7287 
7288 ";
7289 
7290 %feature("docstring")  casadi::Callback::eval_buffer(const double **arg,
7291 const std::vector< casadi_int > &sizes_arg, double **res, const std::vector<
7292 casadi_int > &sizes_res) const  "
7293 
7294 A copy-free low level interface.
7295 
7296 In Python, you will be passed two tuples of memoryview objects
7297 
7298 ";
7299 
7300 %feature("docstring")  casadi::Function::free_mx() const  "
7301 
7302 Get all the free variables of the function.
7303 
7304 ";
7305 
7306 %feature("docstring")  casadi::Function::serialize(const Dict &opts=Dict())
7307 const  "
7308 
7309 Serialize.
7310 
7311 ";
7312 
7313 %feature("docstring")  casadi::Function::size1_out(casadi_int ind) const  "
7314 
7315 Get output dimension.
7316 
7317 ";
7318 
7319 %feature("docstring")  casadi::Function::size1_out(const std::string &oname)
7320 const  "
7321 
7322 Get output dimension.
7323 
7324 ";
7325 
7326 %feature("docstring")  casadi::Function::n_instructions() const  "
7327 
7328 Number of instruction in the algorithm (SXFunction/MXFunction)
7329 
7330 ";
7331 
7332 %feature("docstring")  casadi::Function::instruction_constant(casadi_int k)
7333 const  "
7334 
7335 Get the floating point output argument of an instruction ( SXFunction)
7336 
7337 ";
7338 
7339 %feature("docstring")  casadi::Callback::has_jacobian() const  "
7340 
7341 Return Jacobian of all input elements with respect to all output elements.
7342 
7343 ";
7344 
7345 %feature("docstring")  casadi::Callback::finalize() "
7346 
7347 Finalize the object This function is called after the construction and init
7348 steps are completed, but before user functions are called. It is called
7349 recursively for the whole class hierarchy, starting with the highest level.
7350 
7351 ";
7352 
7353 %feature("docstring")  casadi::Function::size2_out(casadi_int ind) const  "
7354 
7355 Get output dimension.
7356 
7357 ";
7358 
7359 %feature("docstring")  casadi::Function::size2_out(const std::string &oname)
7360 const  "
7361 
7362 Get output dimension.
7363 
7364 ";
7365 
7366 %feature("docstring")  casadi::Function::mx_in(casadi_int ind) const  "
7367 
7368 Get symbolic primitives equivalent to the input expressions There is no
7369 guarantee that subsequent calls return unique answers.
7370 
7371 ";
7372 
7373 %feature("docstring")  casadi::Function::mx_in(const std::string &iname)
7374 const  "
7375 
7376 Get symbolic primitives equivalent to the input expressions There is no
7377 guarantee that subsequent calls return unique answers.
7378 
7379 ";
7380 
7381 %feature("docstring")  casadi::Function::mx_in() const  "
7382 
7383 Get symbolic primitives equivalent to the input expressions There is no
7384 guarantee that subsequent calls return unique answers.
7385 
7386 ";
7387 
7388 %feature("docstring")  casadi::Function::release(int mem) const  "
7389 
7390 Release a memory object.
7391 
7392 ";
7393 
7394 %feature("docstring")  casadi::Function::is_a(const std::string &type, bool
7395 recursive=true) const  "
7396 
7397 Check if the function is of a particular type Optionally check if name
7398 matches one of the base classes (default true)
7399 
7400 ";
7401 
7402 %feature("docstring")  casadi::Function::is_diff_out(casadi_int ind) const
7403 "
7404 
7405 Get differentiability of inputs/output.
7406 
7407 ";
7408 
7409 %feature("docstring")  casadi::Function::is_diff_out() const  "
7410 
7411 Get differentiability of inputs/output.
7412 
7413 ";
7414 
7415 %feature("docstring")  casadi::Function::wrap() const  "
7416 
7417 Wrap in an Function instance consisting of only one MX call.
7418 
7419 ";
7420 
7421 %feature("docstring")  casadi::Callback::get_sparsity_out(casadi_int i) "
7422 
7423 Get the sparsity of an output This function is called during construction.
7424 
7425 ";
7426 
7427 %feature("docstring")  casadi::Function::assert_size_out(casadi_int i,
7428 casadi_int nrow, casadi_int ncol) const  "
7429 
7430 Assert that an output dimension is equal so some given value.
7431 
7432 ";
7433 
7434 %feature("docstring")  casadi::Function::name_in() const  "
7435 
7436 Get input scheme.
7437 
7438 ";
7439 
7440 %feature("docstring")  casadi::Function::name_in(casadi_int ind) const  "
7441 
7442 Get input scheme name by index.
7443 
7444 ";
7445 
7446 %feature("docstring")  casadi::Function::has_free() const  "
7447 
7448 Does the function have free variables.
7449 
7450 ";
7451 
7452 %feature("docstring")  casadi::Function::instructions_sx() const  "
7453 
7454 Get the SX node corresponding to all instructions ( SXFunction)
7455 
7456 Note: input and output instructions have no SX representation. This method
7457 returns nan for those instructions.
7458 
7459 ";
7460 
7461 %feature("docstring")  casadi::Function::assert_size_in(casadi_int i,
7462 casadi_int nrow, casadi_int ncol) const  "
7463 
7464 Assert that an input dimension is equal so some given value.
7465 
7466 ";
7467 
7468 %feature("docstring")  casadi::Callback::get_sparsity_in(casadi_int i) "
7469 
7470 Get the sparsity of an input This function is called during construction.
7471 
7472 ";
7473 
7474 %feature("docstring")  casadi::SharedObject::disp(std::ostream &stream, bool
7475 more=false) const  "
7476 
7477 Print a description of the object.
7478 
7479 ";
7480 
7481 %feature("docstring")  casadi::Function::n_in() const  "
7482 
7483 Get the number of function inputs.
7484 
7485 ";
7486 
7487 %feature("docstring")  casadi::Function::sz_w() const  "
7488 
7489 Get required length of w field.
7490 
7491 ";
7492 
7493 %feature("docstring")  casadi::Function::info() const  "
7494 
7495 Obtain information about function
7496 
7497 ";
7498 
7499 %feature("docstring")  casadi::Function::instruction_MX(casadi_int k) const
7500 "
7501 
7502 Get the MX node corresponding to an instruction ( MXFunction)
7503 
7504 ";
7505 
7506 %feature("docstring")  casadi::Callback::has_jacobian_sparsity() const  "
7507 
7508 Return sparsity of Jacobian of all input elements with respect to all output
7509 elements.
7510 
7511 ";
7512 
7513 %feature("docstring")  casadi::Function::sz_res() const  "
7514 
7515 Get required length of res field.
7516 
7517 ";
7518 
7519 %feature("docstring")  casadi::SharedObject::print_ptr(std::ostream
7520 &stream=casadi::uout()) const  "
7521 
7522 [INTERNAL]  Print the pointer to the internal class
7523 
7524 ";
7525 
7526 %feature("docstring")  casadi::Callback::get_jacobian(const std::string
7527 &name, const std::vector< std::string > &inames, const std::vector<
7528 std::string > &onames, const Dict &opts) const  "
7529 
7530 Return Jacobian of all input elements with respect to all output elements.
7531 
7532 ";
7533 
7534 %feature("docstring")  casadi::Function::nz_from_in(const std::vector< DM >
7535 &arg) const  "
7536 
7537 Convert from/to flat vector of input/output nonzeros.
7538 
7539 ";
7540 
7541 %feature("docstring")  casadi::Function::n_nodes() const  "
7542 
7543 Number of nodes in the algorithm.
7544 
7545 ";
7546 
7547 %feature("docstring")  casadi::Function::oracle() const  "
7548 
7549 Get oracle.
7550 
7551 ";
7552 
7553 %feature("docstring")  casadi::Callback::eval(const std::vector< DM > &arg)
7554 const  "
7555 
7556 Evaluate numerically, using temporary matrices and work vectors.
7557 
7558 This signature is not thread-safe. For guaranteed thread-safety, use
7559 eval_buffer
7560 
7561 ";
7562 
7563 %feature("docstring")  casadi::Function::convert_in(const std::vector< DM >
7564 &arg) const  "
7565 
7566 Convert from/to input/output lists/map.
7567 
7568 Will raise an error when an unknown key is used or a list has incorrect
7569 size. Does not perform sparsity checking.
7570 
7571 ";
7572 
7573 %feature("docstring")  casadi::Function::convert_in(const DMDict &arg) const
7574 "
7575 
7576 Convert from/to input/output lists/map.
7577 
7578 Will raise an error when an unknown key is used or a list has incorrect
7579 size. Does not perform sparsity checking.
7580 
7581 ";
7582 
7583 %feature("docstring")  casadi::Function::convert_in(const std::vector< SX >
7584 &arg) const  "
7585 
7586 Convert from/to input/output lists/map.
7587 
7588 Will raise an error when an unknown key is used or a list has incorrect
7589 size. Does not perform sparsity checking.
7590 
7591 ";
7592 
7593 %feature("docstring")  casadi::Function::convert_in(const SXDict &arg) const
7594 "
7595 
7596 Convert from/to input/output lists/map.
7597 
7598 Will raise an error when an unknown key is used or a list has incorrect
7599 size. Does not perform sparsity checking.
7600 
7601 ";
7602 
7603 %feature("docstring")  casadi::Function::convert_in(const std::vector< MX >
7604 &arg) const  "
7605 
7606 Convert from/to input/output lists/map.
7607 
7608 Will raise an error when an unknown key is used or a list has incorrect
7609 size. Does not perform sparsity checking.
7610 
7611 ";
7612 
7613 %feature("docstring")  casadi::Function::convert_in(const MXDict &arg) const
7614 "
7615 
7616 Convert from/to input/output lists/map.
7617 
7618 Will raise an error when an unknown key is used or a list has incorrect
7619 size. Does not perform sparsity checking.
7620 
7621 ";
7622 
7623 %feature("docstring")  casadi::Function::numel_in() const  "
7624 
7625 Get number of input elements.
7626 
7627 For a particular input or for all of the inputs
7628 
7629 ";
7630 
7631 %feature("docstring")  casadi::Function::numel_in(casadi_int ind) const  "
7632 
7633 Get number of input elements.
7634 
7635 For a particular input or for all of the inputs
7636 
7637 ";
7638 
7639 %feature("docstring")  casadi::Function::numel_in(const std::string &iname)
7640 const  "
7641 
7642 Get number of input elements.
7643 
7644 For a particular input or for all of the inputs
7645 
7646 ";
7647 
7648 %feature("docstring")  casadi::Function::map(const std::string &name, const
7649 std::string &parallelization, casadi_int n, const std::vector< casadi_int >
7650 &reduce_in, const std::vector< casadi_int > &reduce_out, const Dict
7651 &opts=Dict()) const  "
7652 
7653 Map with reduction A subset of the inputs are non-repeated and a subset of
7654 the outputs summed up.
7655 
7656 ";
7657 
7658 %feature("docstring") casadi::casadi_map "
7659 
7660 Map with reduction A subset of the inputs are non-repeated and a subset of
7661 the outputs summed up.
7662 
7663 ";
7664 
7665 %feature("docstring")  casadi::Function::casadi_map "
7666 
7667 Map with reduction A subset of the inputs are non-repeated and a subset of
7668 the outputs summed up.
7669 
7670 ";
7671 
7672 %feature("docstring")  casadi::Function::map(const std::string &name, const
7673 std::string &parallelization, casadi_int n, const std::vector< std::string >
7674 &reduce_in, const std::vector< std::string > &reduce_out, const Dict
7675 &opts=Dict()) const  "
7676 
7677 Map with reduction A subset of the inputs are non-repeated and a subset of
7678 the outputs summed up.
7679 
7680 ";
7681 
7682 %feature("docstring") casadi::casadi_map "
7683 
7684 Map with reduction A subset of the inputs are non-repeated and a subset of
7685 the outputs summed up.
7686 
7687 ";
7688 
7689 %feature("docstring")  casadi::Function::casadi_map "
7690 
7691 Map with reduction A subset of the inputs are non-repeated and a subset of
7692 the outputs summed up.
7693 
7694 ";
7695 
7696 %feature("docstring")  casadi::Function::map(casadi_int n, const
7697 std::vector< bool > &reduce_in, const std::vector< bool >
7698 &reduce_out=std::vector< bool >(), const Dict &opts=Dict()) const  "
7699 
7700 Map with reduction A subset of the inputs are non-repeated and a subset of
7701 the outputs summed up.
7702 
7703 ";
7704 
7705 %feature("docstring") casadi::casadi_map "
7706 
7707 Map with reduction A subset of the inputs are non-repeated and a subset of
7708 the outputs summed up.
7709 
7710 ";
7711 
7712 %feature("docstring")  casadi::Function::casadi_map "
7713 
7714 Map with reduction A subset of the inputs are non-repeated and a subset of
7715 the outputs summed up.
7716 
7717 ";
7718 
7719 %feature("docstring")  casadi::Function::map(casadi_int n, const std::string
7720 &parallelization="serial") const  "
7721 
7722 Create a mapped version of this function.
7723 
7724 Suppose the function has a signature of:
7725 
7726 ::
7727 
7728      f: (a, p) -> ( s )
7729 
7730 
7731 
7732 
7733 The the mapped version has the signature:
7734 
7735 ::
7736 
7737      F: (A, P) -> (S )
7738 
7739       with
7740           A: horzcat([a0, a1, ..., a_(N-1)])
7741           P: horzcat([p0, p1, ..., p_(N-1)])
7742           S: horzcat([s0, s1, ..., s_(N-1)])
7743       and
7744           s0 <- f(a0, p0)
7745           s1 <- f(a1, p1)
7746           ...
7747           s_(N-1) <- f(a_(N-1), p_(N-1))
7748 
7749 
7750 
7751 
7752 Parameters:
7753 -----------
7754 
7755 parallelization:  Type of parallelization used: unroll|serial|openmp
7756 
7757 ";
7758 
7759 %feature("docstring") casadi::casadi_map "
7760 
7761 Create a mapped version of this function.
7762 
7763 Suppose the function has a signature of:
7764 
7765 ::
7766 
7767      f: (a, p) -> ( s )
7768 
7769 
7770 
7771 
7772 The the mapped version has the signature:
7773 
7774 ::
7775 
7776      F: (A, P) -> (S )
7777 
7778       with
7779           A: horzcat([a0, a1, ..., a_(N-1)])
7780           P: horzcat([p0, p1, ..., p_(N-1)])
7781           S: horzcat([s0, s1, ..., s_(N-1)])
7782       and
7783           s0 <- f(a0, p0)
7784           s1 <- f(a1, p1)
7785           ...
7786           s_(N-1) <- f(a_(N-1), p_(N-1))
7787 
7788 
7789 
7790 
7791 Parameters:
7792 -----------
7793 
7794 parallelization:  Type of parallelization used: unroll|serial|openmp
7795 
7796 ";
7797 
7798 %feature("docstring")  casadi::Function::casadi_map "
7799 
7800 Create a mapped version of this function.
7801 
7802 Suppose the function has a signature of:
7803 
7804 ::
7805 
7806      f: (a, p) -> ( s )
7807 
7808 
7809 
7810 
7811 The the mapped version has the signature:
7812 
7813 ::
7814 
7815      F: (A, P) -> (S )
7816 
7817       with
7818           A: horzcat([a0, a1, ..., a_(N-1)])
7819           P: horzcat([p0, p1, ..., p_(N-1)])
7820           S: horzcat([s0, s1, ..., s_(N-1)])
7821       and
7822           s0 <- f(a0, p0)
7823           s1 <- f(a1, p1)
7824           ...
7825           s_(N-1) <- f(a_(N-1), p_(N-1))
7826 
7827 
7828 
7829 
7830 Parameters:
7831 -----------
7832 
7833 parallelization:  Type of parallelization used: unroll|serial|openmp
7834 
7835 ";
7836 
7837 %feature("docstring")  casadi::Function::print_option(const std::string
7838 &name, std::ostream &stream=casadi::uout()) const  "
7839 
7840 Print all information there is to know about a certain option.
7841 
7842 ";
7843 
7844 %feature("docstring")  casadi::Function::mapaccum(const std::string &name,
7845 casadi_int N, const Dict &opts=Dict()) const  "
7846 
7847 Create a mapaccumulated version of this function.
7848 
7849 Suppose the function has a signature of:
7850 
7851 ::
7852 
7853      f: (x, u) -> (x_next , y )
7854 
7855 
7856 
7857 
7858 The the mapaccumulated version has the signature:
7859 
7860 ::
7861 
7862      F: (x0, U) -> (X , Y )
7863 
7864       with
7865           U: horzcat([u0, u1, ..., u_(N-1)])
7866           X: horzcat([x1, x2, ..., x_N])
7867           Y: horzcat([y0, y1, ..., y_(N-1)])
7868 
7869       and
7870           x1, y0 <- f(x0, u0)
7871           x2, y1 <- f(x1, u1)
7872           ...
7873           x_N, y_(N-1) <- f(x_(N-1), u_(N-1))
7874 
7875 
7876 
7877 
7878 Mapaccum has the following benefits over writing an equivalent for- loop:
7879 much faster at construction time
7880 
7881 potentially much faster compilation times (for codegen)
7882 
7883 offers a trade-off between memory and evaluation time
7884 
7885 The base (settable through the options dictionary, default 10), is used to
7886 create a tower of function calls, containing unrolled for- loops of length
7887 maximum base.
7888 
7889 This technique is much more scalable in terms of memory-usage, but slightly
7890 slower at evaluation, than a plain for-loop. The effect is similar to that
7891 of a for-loop with a check-pointing instruction after each chunk of
7892 iterations with size base.
7893 
7894 Set base to -1 to unroll all the way; no gains in memory efficiency here.
7895 
7896 ";
7897 
7898 %feature("docstring")  casadi::Function::mapaccum(const std::string &name,
7899 casadi_int N, casadi_int n_accum, const Dict &opts=Dict()) const  "
7900 
7901 Create a mapaccumulated version of this function.
7902 
7903 Suppose the function has a signature of:
7904 
7905 ::
7906 
7907      f: (x, u) -> (x_next , y )
7908 
7909 
7910 
7911 
7912 The the mapaccumulated version has the signature:
7913 
7914 ::
7915 
7916      F: (x0, U) -> (X , Y )
7917 
7918       with
7919           U: horzcat([u0, u1, ..., u_(N-1)])
7920           X: horzcat([x1, x2, ..., x_N])
7921           Y: horzcat([y0, y1, ..., y_(N-1)])
7922 
7923       and
7924           x1, y0 <- f(x0, u0)
7925           x2, y1 <- f(x1, u1)
7926           ...
7927           x_N, y_(N-1) <- f(x_(N-1), u_(N-1))
7928 
7929 
7930 
7931 
7932 Mapaccum has the following benefits over writing an equivalent for- loop:
7933 much faster at construction time
7934 
7935 potentially much faster compilation times (for codegen)
7936 
7937 offers a trade-off between memory and evaluation time
7938 
7939 The base (settable through the options dictionary, default 10), is used to
7940 create a tower of function calls, containing unrolled for- loops of length
7941 maximum base.
7942 
7943 This technique is much more scalable in terms of memory-usage, but slightly
7944 slower at evaluation, than a plain for-loop. The effect is similar to that
7945 of a for-loop with a check-pointing instruction after each chunk of
7946 iterations with size base.
7947 
7948 Set base to -1 to unroll all the way; no gains in memory efficiency here.
7949 
7950 ";
7951 
7952 %feature("docstring")  casadi::Function::mapaccum(const std::string &name,
7953 casadi_int n, const std::vector< casadi_int > &accum_in, const std::vector<
7954 casadi_int > &accum_out, const Dict &opts=Dict()) const  "
7955 
7956 Create a mapaccumulated version of this function.
7957 
7958 Suppose the function has a signature of:
7959 
7960 ::
7961 
7962      f: (x, u) -> (x_next , y )
7963 
7964 
7965 
7966 
7967 The the mapaccumulated version has the signature:
7968 
7969 ::
7970 
7971      F: (x0, U) -> (X , Y )
7972 
7973       with
7974           U: horzcat([u0, u1, ..., u_(N-1)])
7975           X: horzcat([x1, x2, ..., x_N])
7976           Y: horzcat([y0, y1, ..., y_(N-1)])
7977 
7978       and
7979           x1, y0 <- f(x0, u0)
7980           x2, y1 <- f(x1, u1)
7981           ...
7982           x_N, y_(N-1) <- f(x_(N-1), u_(N-1))
7983 
7984 
7985 
7986 
7987 Mapaccum has the following benefits over writing an equivalent for- loop:
7988 much faster at construction time
7989 
7990 potentially much faster compilation times (for codegen)
7991 
7992 offers a trade-off between memory and evaluation time
7993 
7994 The base (settable through the options dictionary, default 10), is used to
7995 create a tower of function calls, containing unrolled for- loops of length
7996 maximum base.
7997 
7998 This technique is much more scalable in terms of memory-usage, but slightly
7999 slower at evaluation, than a plain for-loop. The effect is similar to that
8000 of a for-loop with a check-pointing instruction after each chunk of
8001 iterations with size base.
8002 
8003 Set base to -1 to unroll all the way; no gains in memory efficiency here.
8004 
8005 ";
8006 
8007 %feature("docstring")  casadi::Function::mapaccum(const std::string &name,
8008 casadi_int n, const std::vector< std::string > &accum_in, const std::vector<
8009 std::string > &accum_out, const Dict &opts=Dict()) const  "
8010 
8011 Create a mapaccumulated version of this function.
8012 
8013 Suppose the function has a signature of:
8014 
8015 ::
8016 
8017      f: (x, u) -> (x_next , y )
8018 
8019 
8020 
8021 
8022 The the mapaccumulated version has the signature:
8023 
8024 ::
8025 
8026      F: (x0, U) -> (X , Y )
8027 
8028       with
8029           U: horzcat([u0, u1, ..., u_(N-1)])
8030           X: horzcat([x1, x2, ..., x_N])
8031           Y: horzcat([y0, y1, ..., y_(N-1)])
8032 
8033       and
8034           x1, y0 <- f(x0, u0)
8035           x2, y1 <- f(x1, u1)
8036           ...
8037           x_N, y_(N-1) <- f(x_(N-1), u_(N-1))
8038 
8039 
8040 
8041 
8042 Mapaccum has the following benefits over writing an equivalent for- loop:
8043 much faster at construction time
8044 
8045 potentially much faster compilation times (for codegen)
8046 
8047 offers a trade-off between memory and evaluation time
8048 
8049 The base (settable through the options dictionary, default 10), is used to
8050 create a tower of function calls, containing unrolled for- loops of length
8051 maximum base.
8052 
8053 This technique is much more scalable in terms of memory-usage, but slightly
8054 slower at evaluation, than a plain for-loop. The effect is similar to that
8055 of a for-loop with a check-pointing instruction after each chunk of
8056 iterations with size base.
8057 
8058 Set base to -1 to unroll all the way; no gains in memory efficiency here.
8059 
8060 ";
8061 
8062 %feature("docstring")  casadi::Function::mapaccum(casadi_int N, const Dict
8063 &opts=Dict()) const  "
8064 
8065 Create a mapaccumulated version of this function.
8066 
8067 Suppose the function has a signature of:
8068 
8069 ::
8070 
8071      f: (x, u) -> (x_next , y )
8072 
8073 
8074 
8075 
8076 The the mapaccumulated version has the signature:
8077 
8078 ::
8079 
8080      F: (x0, U) -> (X , Y )
8081 
8082       with
8083           U: horzcat([u0, u1, ..., u_(N-1)])
8084           X: horzcat([x1, x2, ..., x_N])
8085           Y: horzcat([y0, y1, ..., y_(N-1)])
8086 
8087       and
8088           x1, y0 <- f(x0, u0)
8089           x2, y1 <- f(x1, u1)
8090           ...
8091           x_N, y_(N-1) <- f(x_(N-1), u_(N-1))
8092 
8093 
8094 
8095 
8096 Mapaccum has the following benefits over writing an equivalent for- loop:
8097 much faster at construction time
8098 
8099 potentially much faster compilation times (for codegen)
8100 
8101 offers a trade-off between memory and evaluation time
8102 
8103 The base (settable through the options dictionary, default 10), is used to
8104 create a tower of function calls, containing unrolled for- loops of length
8105 maximum base.
8106 
8107 This technique is much more scalable in terms of memory-usage, but slightly
8108 slower at evaluation, than a plain for-loop. The effect is similar to that
8109 of a for-loop with a check-pointing instruction after each chunk of
8110 iterations with size base.
8111 
8112 Set base to -1 to unroll all the way; no gains in memory efficiency here.
8113 
8114 ";
8115 
8116 %feature("docstring")  casadi::Function::size1_in(casadi_int ind) const  "
8117 
8118 Get input dimension.
8119 
8120 ";
8121 
8122 %feature("docstring")  casadi::Function::size1_in(const std::string &iname)
8123 const  "
8124 
8125 Get input dimension.
8126 
8127 ";
8128 
8129 %feature("docstring")  casadi::Function::sparsity_in(casadi_int ind) const
8130 "
8131 
8132 Get sparsity of a given input.
8133 
8134 ";
8135 
8136 %feature("docstring")  casadi::Function::sparsity_in(const std::string
8137 &iname) const  "
8138 
8139 Get sparsity of a given input.
8140 
8141 ";
8142 
8143 %feature("docstring")  casadi::Callback::get_reverse(casadi_int nadj, const
8144 std::string &name, const std::vector< std::string > &inames, const
8145 std::vector< std::string > &onames, const Dict &opts) const  "
8146 
8147 Return function that calculates adjoint derivatives reverse(nadj) returns a
8148 cached instance if available, and calls  Function get_reverse(casadi_int
8149 nadj) if no cached version is available.
8150 
8151 ";
8152 
8153 %feature("docstring")  casadi::Function::generate_in(const std::string
8154 &fname, const std::vector< DM > &arg) "
8155 
8156 Export an input file that can be passed to generate C code with a main.
8157 
8158 generate_out  convert_in to convert between dict/map and vector
8159 
8160 ";
8161 
8162 %feature("docstring")  casadi::Function::generate_in(const std::string
8163 &fname) "
8164 
8165 Export an input file that can be passed to generate C code with a main.
8166 
8167 generate_out  convert_in to convert between dict/map and vector
8168 
8169 ";
8170 
8171 %feature("docstring") casadi::Callback "
8172 
8173 Callback function functionality.
8174 
8175 This class provides a public API to the FunctionInternal class that can be
8176 subclassed by the user, who is then able to implement the different virtual
8177 method. Note that the Function class also provides a public API to
8178 FunctionInternal, but only allows calling, not being called.
8179 
8180 The user is responsible for not deleting this class for the lifetime of the
8181 internal function object.
8182 
8183 Joris Gillis, Joel Andersson
8184 
8185 C++ includes: callback.hpp ";
8186 
8187 %feature("docstring")  casadi::Function::n_out() const  "
8188 
8189 Get the number of function outputs.
8190 
8191 ";
8192 
8193 %feature("docstring")  casadi::Function::jacobian_old(casadi_int iind,
8194 casadi_int oind) const  "
8195 
8196 Generate a Jacobian function of output oind with respect to input iind.
8197 
8198 Parameters:
8199 -----------
8200 
8201 iind:  The index of the input
8202 
8203 oind:  The index of the output Legacy function: To be deprecated in a future
8204 version of CasADi. Exists only for compatibility with Function::jacobian
8205 pre-CasADi 3.2
8206 
8207 ";
8208 
8209 %feature("docstring") casadi::Callback::__hash__ "
8210 
8211 Returns a number that is unique for a given Node. If the Object does not
8212 point to any node, \"0\" is returned.
8213 
8214 ";
8215 
8216 %feature("docstring")  casadi::Function::fold(casadi_int N, const Dict
8217 &opts=Dict()) const  "
8218 
8219 Create a mapaccumulated version of this function.
8220 
8221 Suppose the function has a signature of:
8222 
8223 ::
8224 
8225      f: (x, u) -> (x_next , y )
8226 
8227 
8228 
8229 
8230 The the mapaccumulated version has the signature:
8231 
8232 ::
8233 
8234      F: (x0, U) -> (X , Y )
8235 
8236       with
8237           U: horzcat([u0, u1, ..., u_(N-1)])
8238           X: horzcat([x1, x2, ..., x_N])
8239           Y: horzcat([y0, y1, ..., y_(N-1)])
8240 
8241       and
8242           x1, y0 <- f(x0, u0)
8243           x2, y1 <- f(x1, u1)
8244           ...
8245           x_N, y_(N-1) <- f(x_(N-1), u_(N-1))
8246 
8247 
8248 
8249 
8250 Mapaccum has the following benefits over writing an equivalent for- loop:
8251 much faster at construction time
8252 
8253 potentially much faster compilation times (for codegen)
8254 
8255 offers a trade-off between memory and evaluation time
8256 
8257 The base (settable through the options dictionary, default 10), is used to
8258 create a tower of function calls, containing unrolled for- loops of length
8259 maximum base.
8260 
8261 This technique is much more scalable in terms of memory-usage, but slightly
8262 slower at evaluation, than a plain for-loop. The effect is similar to that
8263 of a for-loop with a check-pointing instruction after each chunk of
8264 iterations with size base.
8265 
8266 Set base to -1 to unroll all the way; no gains in memory efficiency here.
8267 
8268 ";
8269 
8270 %feature("docstring")  casadi::Function::index_in(const std::string &name)
8271 const  "
8272 
8273 Find the index for a string describing a particular entry of an input
8274 scheme.
8275 
8276 example: schemeEntry(\"x_opt\") -> returns NLPSOL_X if FunctionInternal
8277 adheres to SCHEME_NLPINput
8278 
8279 ";
8280 
8281 %feature("docstring")  casadi::Function::generate_lifted(Function
8282 &output_vdef_fcn, Function &output_vinit_fcn) const  "
8283 
8284 Extract the functions needed for the Lifted Newton method.
8285 
8286 ";
8287 
8288 %feature("docstring")  casadi::Function::sparsity_out(casadi_int ind) const
8289 "
8290 
8291 Get sparsity of a given output.
8292 
8293 ";
8294 
8295 %feature("docstring")  casadi::Function::sparsity_out(const std::string
8296 &iname) const  "
8297 
8298 Get sparsity of a given output.
8299 
8300 ";
8301 
8302 %feature("docstring")  casadi::Function::stats(int mem=0) const  "
8303 
8304 Get all statistics obtained at the end of the last evaluate call.
8305 
8306 ";
8307 
8308 %feature("docstring")  casadi::Function::name() const  "
8309 
8310 Name of the function.
8311 
8312 ";
8313 
8314 %feature("docstring")  casadi::Function::size_out(casadi_int ind) const  "
8315 
8316 Get output dimension.
8317 
8318 ";
8319 
8320 %feature("docstring")  casadi::Function::size_out(const std::string &oname)
8321 const  "
8322 
8323 Get output dimension.
8324 
8325 ";
8326 
8327 %feature("docstring")  casadi::Callback::get_name_in(casadi_int i) "
8328 
8329 Get the sparsity of an input This function is called during construction.
8330 
8331 ";
8332 
8333 %feature("docstring")  casadi::Callback::get_name_out(casadi_int i) "
8334 
8335 Get the sparsity of an output This function is called during construction.
8336 
8337 ";
8338 
8339 %feature("docstring")  casadi::Function::mx_out(casadi_int ind) const  "
8340 
8341 Get symbolic primitives equivalent to the output expressions There is no
8342 guarantee that subsequent calls return unique answers.
8343 
8344 ";
8345 
8346 %feature("docstring")  casadi::Function::mx_out(const std::string &oname)
8347 const  "
8348 
8349 Get symbolic primitives equivalent to the output expressions There is no
8350 guarantee that subsequent calls return unique answers.
8351 
8352 ";
8353 
8354 %feature("docstring")  casadi::Function::mx_out() const  "
8355 
8356 Get symbolic primitives equivalent to the output expressions There is no
8357 guarantee that subsequent calls return unique answers.
8358 
8359 ";
8360 
8361 
8362 // File: classcasadi_1_1casadi__limits.xml
8363 %feature("docstring") casadi::casadi_limits "
8364 
8365 casadi_limits class
8366 
8367 The following class, which acts as a complements to the standard
8368 numeric_limits class, allows specifying certain properties of scalar
8369 objects. The template can be specialized for e.g. symbolic scalars Joel
8370 Andersson
8371 
8372 C++ includes: casadi_limits.hpp ";
8373 
8374 
8375 // File: classcasadi_1_1CasadiException.xml
8376 %feature("docstring")  casadi::CasadiException::what() const  "
8377 
8378 throw () Display error.
8379 
8380 ";
8381 
8382 %feature("docstring") casadi::CasadiException::CasadiException() "
8383 
8384 Default constructor.
8385 
8386 ";
8387 
8388 %feature("docstring") casadi::CasadiException::CasadiException(const
8389 std::string &msg) "
8390 
8391 Form message string.
8392 
8393 ";
8394 
8395 %feature("docstring") casadi::CasadiException "
8396 
8397 Casadi exception class.
8398 
8399 Joel Andersson
8400 
8401 C++ includes: exception.hpp ";
8402 
8403 %feature("docstring") casadi::CasadiException::~CasadiException "
8404 
8405 throw () Destructor.
8406 
8407 ";
8408 
8409 
8410 // File: classcasadi_1_1CasadiMeta.xml
8411 %feature("docstring") casadi::CasadiMeta "
8412 
8413 Collects global CasADi meta information.
8414 
8415 Joris Gillis
8416 
8417 C++ includes: casadi_meta.hpp ";
8418 
8419 
8420 // File: classcasadi_1_1CentralDiff.xml
8421 %feature("docstring")  casadi::FunctionInternal::matching_arg(const
8422 std::vector< M > &arg, casadi_int &npar) const  "
8423 
8424 [INTERNAL]  Check if input arguments that needs to be replaced.
8425 
8426 Raises errors
8427 
8428 Parameters:
8429 -----------
8430 
8431 npar[in]:  normal usage: 1, disallow pararallel calls: -1
8432 
8433 npar:  max number of horizontal repetitions across all arguments (or -1)
8434 
8435 ";
8436 
8437 %feature("docstring")  casadi::FunctionInternal::get_jacobian_sparsity()
8438 const  "
8439 
8440 [INTERNAL]  Get Jacobian sparsity.
8441 
8442 ";
8443 
8444 %feature("docstring")  casadi::FunctionInternal::forward(casadi_int nfwd)
8445 const  "
8446 
8447 [INTERNAL]  Return function that calculates forward derivatives
8448 forward(nfwd) returns a cached instance if available, and calls  Function
8449 get_forward(casadi_int nfwd) if no cached version is available.
8450 
8451 ";
8452 
8453 %feature("docstring")  casadi::FunctionInternal::generate_lifted(Function
8454 &vdef_fcn, Function &vinit_fcn) const  "
8455 
8456 [INTERNAL]  Extract the functions needed for the Lifted Newton method.
8457 
8458 ";
8459 
8460 %feature("docstring")  casadi::FunctionInternal::symbolicAdjSeed(casadi_int
8461 nadj, const std::vector< MatType > &v) const  "
8462 
8463 [INTERNAL]  Symbolic expressions for the adjoint seeds.
8464 
8465 ";
8466 
8467 %feature("docstring")  casadi::SharedObjectInternal::weak() "
8468 
8469 [INTERNAL]  Get a weak reference to the object.
8470 
8471 ";
8472 
8473 %feature("docstring")  casadi::FunctionInternal::sparsity_in(casadi_int ind)
8474 const  "
8475 
8476 [INTERNAL]  Input/output sparsity.
8477 
8478 ";
8479 
8480 %feature("docstring")  casadi::FunctionInternal::dm_in(casadi_int ind) const
8481 "
8482 
8483 [INTERNAL]  Get function input(s) and output(s)
8484 
8485 ";
8486 
8487 %feature("docstring")  casadi::FunctionInternal::dm_in() const  "
8488 
8489 [INTERNAL]  Get function input(s) and output(s)
8490 
8491 ";
8492 
8493 %feature("docstring")  casadi::FiniteDiff::uses_output() const  "
8494 
8495 [INTERNAL]  Is the scheme using the (nondifferentiated) output?
8496 
8497 ";
8498 
8499 %feature("docstring")  casadi::FunctionInternal::generate_options(bool
8500 is_temp=false) const  "
8501 
8502 [INTERNAL]  Reconstruct options dict.
8503 
8504 ";
8505 
8506 %feature("docstring")
8507 casadi::FunctionInternal::codegen_decref(CodeGenerator &g) const  "
8508 
8509 [INTERNAL]  Codegen decref for dependencies.
8510 
8511 ";
8512 
8513 %feature("docstring")  casadi::FunctionInternal::call(const std::vector< M >
8514 &arg, std::vector< M > &res, bool always_inline, bool never_inline) const  "
8515 
8516 [INTERNAL]   Call a function, templated.
8517 
8518 ";
8519 
8520 %feature("docstring")  casadi::FunctionInternal::mapsum_mx(const
8521 std::vector< MX > &arg, const std::string &parallelization) "
8522 
8523 [INTERNAL]  Parallel evaluation.
8524 
8525 ";
8526 
8527 %feature("docstring")
8528 casadi::FunctionInternal::getJacSparsityHierarchical(casadi_int iind,
8529 casadi_int oind) const  "
8530 
8531 [INTERNAL]  A flavor of getJacSparsity that does hierarchical block
8532 structure recognition.
8533 
8534 ";
8535 
8536 %feature("docstring")  casadi::FiniteDiff::get_sparsity_out(casadi_int i)  "
8537 
8538 [INTERNAL]  Sparsities of function inputs and outputs.
8539 
8540 ";
8541 
8542 %feature("docstring")  casadi::FunctionInternal::eval_gen(const double
8543 **arg, double **res, casadi_int *iw, double *w, void *mem) const  "
8544 
8545 [INTERNAL]  Evaluate numerically.
8546 
8547 ";
8548 
8549 %feature("docstring")  casadi::FunctionInternal::eval_gen(const SXElem
8550 **arg, SXElem **res, casadi_int *iw, SXElem *w, void *mem) const  "
8551 
8552 [INTERNAL]  Evaluate a function, overloaded.
8553 
8554 ";
8555 
8556 %feature("docstring")  casadi::FunctionInternal::eval_gen(const bvec_t
8557 **arg, bvec_t **res, casadi_int *iw, bvec_t *w, void *mem) const  "
8558 
8559 [INTERNAL]  Evaluate a function, overloaded.
8560 
8561 ";
8562 
8563 %feature("docstring")  casadi::FunctionInternal::get_reverse(casadi_int
8564 nadj, const std::string &name, const std::vector< std::string > &inames,
8565 const std::vector< std::string > &onames, const Dict &opts) const  "
8566 
8567 [INTERNAL]  Return function that calculates adjoint derivatives
8568 reverse(nadj) returns a cached instance if available, and calls  Function
8569 get_reverse(casadi_int nadj) if no cached version is available.
8570 
8571 ";
8572 
8573 %feature("docstring")  casadi::FunctionInternal::set_temp(void *mem, const
8574 double **arg, double **res, casadi_int *iw, double *w) const  "
8575 
8576 [INTERNAL]  Set the (temporary) work vectors.
8577 
8578 ";
8579 
8580 %feature("docstring")
8581 casadi::FunctionInternal::codegen_init_mem(CodeGenerator &g) const  "
8582 
8583 [INTERNAL]  Codegen decref for init_mem.
8584 
8585 ";
8586 
8587 %feature("docstring")  casadi::ProtoFunction::alloc_mem() const  "
8588 
8589 [INTERNAL]  Create memory block.
8590 
8591 ";
8592 
8593 %feature("docstring")  casadi::CentralDiff::get_forward(casadi_int nfwd,
8594 const std::string &name, const std::vector< std::string > &inames, const
8595 std::vector< std::string > &onames, const Dict &opts) const  "
8596 
8597 [INTERNAL]  Second order derivatives.
8598 
8599 ";
8600 
8601 %feature("docstring")  casadi::FunctionInternal::has_eval_dm() const  "
8602 
8603 [INTERNAL]  Evaluate with DM matrices.
8604 
8605 ";
8606 
8607 %feature("docstring")  casadi::FunctionInternal::n_nodes() const  "
8608 
8609 [INTERNAL]  Number of nodes in the algorithm.
8610 
8611 ";
8612 
8613 %feature("docstring")  casadi::FunctionInternal::eval_sx(const SXElem **arg,
8614 SXElem **res, casadi_int *iw, SXElem *w, void *mem) const  "
8615 
8616 [INTERNAL]  Evaluate with symbolic scalars.
8617 
8618 ";
8619 
8620 %feature("docstring")  casadi::FunctionInternal::has_jacobian() const  "
8621 
8622 [INTERNAL]  Return Jacobian of all input elements with respect to all output
8623 elements.
8624 
8625 ";
8626 
8627 %feature("docstring")  casadi::ProtoFunction::serialize(SerializingStream
8628 &s) const  "
8629 
8630 [INTERNAL]  Serialize an object.
8631 
8632 ";
8633 
8634 %feature("docstring")  casadi::FunctionInternal::nnz_out() const  "
8635 
8636 [INTERNAL]  Number of input/output nonzeros.
8637 
8638 ";
8639 
8640 %feature("docstring")  casadi::FunctionInternal::nnz_out(casadi_int ind)
8641 const  "
8642 
8643 [INTERNAL]  Number of input/output nonzeros.
8644 
8645 ";
8646 
8647 %feature("docstring")  casadi::FunctionInternal::export_code(const
8648 std::string &lang, std::ostream &stream, const Dict &options) const  "
8649 
8650 [INTERNAL]  Export function in a specific language.
8651 
8652 ";
8653 
8654 %feature("docstring")  casadi::FunctionInternal::generate_dependencies(const
8655 std::string &fname, const Dict &opts) const  "
8656 
8657 [INTERNAL]  Export / Generate C code for the dependency function.
8658 
8659 ";
8660 
8661 %feature("docstring")  casadi::FunctionInternal::sz_res() const  "
8662 
8663 [INTERNAL]  Get required length of res field.
8664 
8665 ";
8666 
8667 %feature("docstring")  casadi::FunctionInternal::fwdViaJac(casadi_int nfwd)
8668 const  "
8669 
8670 [INTERNAL]  Calculate derivatives by multiplying the full Jacobian and
8671 multiplying.
8672 
8673 ";
8674 
8675 %feature("docstring")  casadi::FunctionInternal::incache(const std::string
8676 &fname, Function &f, const std::string &suffix="") const  "
8677 
8678 [INTERNAL]  Get function in cache.
8679 
8680 ";
8681 
8682 %feature("docstring")  casadi::FunctionInternal::size2_out(casadi_int ind)
8683 const  "
8684 
8685 [INTERNAL]  Input/output dimensions.
8686 
8687 ";
8688 
8689 %feature("docstring")  casadi::FunctionInternal::matching_res(const
8690 std::vector< M > &arg, casadi_int &npar) const  "
8691 
8692 [INTERNAL]  Check if output arguments that needs to be replaced.
8693 
8694 Raises errors
8695 
8696 Parameters:
8697 -----------
8698 
8699 npar[in]:  normal usage: 1, disallow pararallel calls: -1
8700 
8701 npar:  max number of horizontal repetitions across all arguments (or -1)
8702 
8703 ";
8704 
8705 %feature("docstring")  casadi::FiniteDiff::get_n_in()  "
8706 
8707 [INTERNAL]  Number of function inputs and outputs.
8708 
8709 ";
8710 
8711 %feature("docstring")  casadi::FunctionInternal::codegen_mem(CodeGenerator
8712 &g, const std::string &index="mem") const  "
8713 
8714 [INTERNAL]  Get thread-local memory object.
8715 
8716 ";
8717 
8718 %feature("docstring")  casadi::FunctionInternal::size2_in(casadi_int ind)
8719 const  "
8720 
8721 [INTERNAL]  Input/output dimensions.
8722 
8723 ";
8724 
8725 %feature("docstring")  casadi::FunctionInternal::eval_mx(const MXVector
8726 &arg, MXVector &res, bool always_inline, bool never_inline) const  "
8727 
8728 [INTERNAL]  Evaluate with symbolic matrices.
8729 
8730 ";
8731 
8732 %feature("docstring")  casadi::FunctionInternal::call_forward(const
8733 std::vector< MX > &arg, const std::vector< MX > &res, const std::vector<
8734 std::vector< MX > > &fseed, std::vector< std::vector< MX > > &fsens, bool
8735 always_inline, bool never_inline) const  "
8736 
8737 [INTERNAL]  Forward mode AD, virtual functions overloaded in derived
8738 classes.
8739 
8740 ";
8741 
8742 %feature("docstring")  casadi::FunctionInternal::call_forward(const
8743 std::vector< SX > &arg, const std::vector< SX > &res, const std::vector<
8744 std::vector< SX > > &fseed, std::vector< std::vector< SX > > &fsens, bool
8745 always_inline, bool never_inline) const  "
8746 
8747 [INTERNAL]  Forward mode AD, virtual functions overloaded in derived
8748 classes.
8749 
8750 ";
8751 
8752 %feature("docstring")  casadi::FunctionInternal::check_arg(const
8753 std::vector< M > &arg, casadi_int &npar) const  "
8754 
8755 [INTERNAL]  Check if input arguments have correct length and dimensions.
8756 
8757 Raises errors.
8758 
8759 Parameters:
8760 -----------
8761 
8762 npar[in]:  normal usage: 1, disallow pararallel calls: -1
8763 
8764 npar:  max number of horizontal repetitions across all arguments (or -1)
8765 
8766 ";
8767 
8768 %feature("docstring")  casadi::FunctionInternal::print_option(const
8769 std::string &name, std::ostream &stream) const  "
8770 
8771 [INTERNAL]  Print all information there is to know about a certain option.
8772 
8773 ";
8774 
8775 %feature("docstring")  casadi::ProtoFunction::clear_mem() "
8776 
8777 [INTERNAL]  Clear all memory (called from destructor)
8778 
8779 ";
8780 
8781 %feature("docstring")  casadi::FunctionInternal::ad_weight() const  "
8782 
8783 [INTERNAL]  Weighting factor for chosing forward/reverse mode.
8784 
8785 ";
8786 
8787 %feature("docstring")  casadi::CentralDiff::has_err() const  "
8788 
8789 [INTERNAL] ";
8790 
8791 %feature("docstring")  casadi::FunctionInternal::is_diff_out(casadi_int i) "
8792 
8793 [INTERNAL] ";
8794 
8795 %feature("docstring")
8796 casadi::FunctionInternal::codegen_alloc_mem(CodeGenerator &g) const  "
8797 
8798 [INTERNAL]  Codegen decref for alloc_mem.
8799 
8800 ";
8801 
8802 %feature("docstring")  casadi::ProtoFunction::format_time(char *buffer,
8803 double time) const  "
8804 
8805 [INTERNAL]  Format time in a fixed width 8 format.
8806 
8807 ";
8808 
8809 %feature("docstring")  casadi::FunctionInternal::numel_out(casadi_int ind)
8810 const  "
8811 
8812 [INTERNAL]  Number of input/output elements.
8813 
8814 ";
8815 
8816 %feature("docstring")  casadi::FunctionInternal::numel_out() const  "
8817 
8818 [INTERNAL]  Number of input/output elements.
8819 
8820 ";
8821 
8822 %feature("docstring")  casadi::FunctionInternal::sparsity_jac(casadi_int
8823 iind, casadi_int oind, bool compact, bool symmetric) const  "
8824 
8825 [INTERNAL]  Get, if necessary generate, the sparsity of a Jacobian block.
8826 
8827 ";
8828 
8829 %feature("docstring")  casadi::FunctionInternal::disp(std::ostream &stream,
8830 bool more) const  "
8831 
8832 [INTERNAL]  Display object.
8833 
8834 ";
8835 
8836 %feature("docstring")  casadi::FunctionInternal::convert_arg(const
8837 std::vector< M > &arg) const  "
8838 
8839 [INTERNAL]  Convert from/to input/output lists/map.
8840 
8841 ";
8842 
8843 %feature("docstring")  casadi::FunctionInternal::convert_arg(const std::map<
8844 std::string, M > &arg) const  "
8845 
8846 [INTERNAL]  Convert from/to input/output lists/map.
8847 
8848 ";
8849 
8850 %feature("docstring")  casadi::FunctionInternal::generate_in(const
8851 std::string &fname, const double **arg) const  "
8852 
8853 [INTERNAL]  Export an input file that can be passed to generate C code with
8854 a main.
8855 
8856 ";
8857 
8858 %feature("docstring")  casadi::FunctionInternal::get_function() const  "
8859 
8860 [INTERNAL] ";
8861 
8862 %feature("docstring")  casadi::FunctionInternal::get_function(const
8863 std::string &name) const  "
8864 
8865 [INTERNAL] ";
8866 
8867 %feature("docstring")  casadi::FunctionInternal::mx_in(casadi_int ind) const
8868 "
8869 
8870 [INTERNAL]  Get function input(s) and output(s)
8871 
8872 ";
8873 
8874 %feature("docstring")  casadi::FunctionInternal::mx_in() const  "
8875 
8876 [INTERNAL]  Get function input(s) and output(s)
8877 
8878 ";
8879 
8880 %feature("docstring")  casadi::CentralDiff::get_abstol() const  "
8881 
8882 [INTERNAL]  Get absolute tolerance.
8883 
8884 ";
8885 
8886 %feature("docstring")  casadi::FunctionInternal::instruction_MX(casadi_int
8887 k) const  "
8888 
8889 [INTERNAL]  get MX expression associated with instruction
8890 
8891 ";
8892 
8893 %feature("docstring")  casadi::FunctionInternal::replace_res(const
8894 std::vector< M > &res, casadi_int npar) const  "
8895 
8896 [INTERNAL]  Replace 0-by-0 outputs.
8897 
8898 ";
8899 
8900 %feature("docstring")  casadi::SharedObjectInternal::getCount() const  "
8901 
8902 [INTERNAL]  Get the reference count.
8903 
8904 ";
8905 
8906 %feature("docstring")  casadi::FunctionInternal::instructions_sx() const  "
8907 
8908 [INTERNAL]  get SX expression associated with instructions
8909 
8910 ";
8911 
8912 %feature("docstring")  casadi::FunctionInternal::replace_arg(const
8913 std::vector< M > &arg, casadi_int npar) const  "
8914 
8915 [INTERNAL]  Replace 0-by-0 inputs.
8916 
8917 ";
8918 
8919 %feature("docstring")  casadi::CentralDiff::calc_stepsize(double abstol)
8920 const  "
8921 
8922 [INTERNAL] ";
8923 
8924 %feature("docstring")  casadi::FunctionInternal::disp_more(std::ostream
8925 &stream) const  "
8926 
8927 [INTERNAL]  Print more.
8928 
8929 ";
8930 
8931 %feature("docstring")  casadi::FunctionInternal::setup(void *mem, const
8932 double **arg, double **res, casadi_int *iw, double *w) const  "
8933 
8934 [INTERNAL]  Set the (persistent and temporary) work vectors.
8935 
8936 ";
8937 
8938 %feature("docstring")  casadi::ProtoFunction::init_mem(void *mem) const  "
8939 
8940 [INTERNAL]  Initalize memory block.
8941 
8942 ";
8943 
8944 %feature("docstring")  casadi::FunctionInternal::alloc_w(size_t sz_w, bool
8945 persistent=false) "
8946 
8947 [INTERNAL]  Ensure required length of w field.
8948 
8949 ";
8950 
8951 %feature("docstring")  casadi::CentralDiff::pert(const std::string &k) const
8952 "
8953 
8954 [INTERNAL] ";
8955 
8956 %feature("docstring")  casadi::CentralDiff::pert(casadi_int k, double h)
8957 const  "
8958 
8959 [INTERNAL] ";
8960 
8961 %feature("docstring")  casadi::FunctionInternal::sz_arg() const  "
8962 
8963 [INTERNAL]  Get required length of arg field.
8964 
8965 ";
8966 
8967 %feature("docstring")
8968 casadi::FunctionInternal::instruction_input(casadi_int k) const  "
8969 
8970 [INTERNAL]  Get the (integer) input arguments of an atomic operation.
8971 
8972 ";
8973 
8974 %feature("docstring")
8975 casadi::FunctionInternal::instruction_output(casadi_int k) const  "
8976 
8977 [INTERNAL]  Get the (integer) output argument of an atomic operation.
8978 
8979 ";
8980 
8981 %feature("docstring")  casadi::FiniteDiff::get_name_out(casadi_int i)  "
8982 
8983 [INTERNAL]  Names of function input and outputs.
8984 
8985 ";
8986 
8987 %feature("docstring")  casadi::FunctionInternal::oracle() const  "
8988 
8989 [INTERNAL]  Get oracle.
8990 
8991 ";
8992 
8993 %feature("docstring")  casadi::FiniteDiff::get_name_in(casadi_int i)  "
8994 
8995 [INTERNAL]  Names of function input and outputs.
8996 
8997 ";
8998 
8999 %feature("docstring")
9000 casadi::FunctionInternal::jacobian_sparsity_filter(const Sparsity &sp) const
9001 "
9002 
9003 [INTERNAL]  Filter out nonzeros in the full sparsity jacobian according to
9004 is_diff_in/out.
9005 
9006 ";
9007 
9008 %feature("docstring")  casadi::FunctionInternal::sz_w() const  "
9009 
9010 [INTERNAL]  Get required length of w field.
9011 
9012 ";
9013 
9014 %feature("docstring")
9015 casadi::FunctionInternal::getJacSparsityGen(casadi_int iind, casadi_int
9016 oind, bool symmetric, casadi_int gr_i=1, casadi_int gr_o=1) const  "
9017 
9018 [INTERNAL]  Get the sparsity pattern, forward mode.
9019 
9020 ";
9021 
9022 %feature("docstring")  casadi::FunctionInternal::jacobian() const  "
9023 
9024 [INTERNAL]  Return Jacobian of all input elements with respect to all output
9025 elements.
9026 
9027 ";
9028 
9029 %feature("docstring")  casadi::FunctionInternal::generate_out(const
9030 std::string &fname, double **res) const  "
9031 
9032 [INTERNAL] ";
9033 
9034 %feature("docstring") casadi::CentralDiff::CentralDiff(const std::string
9035 &name, casadi_int n) "
9036 
9037 [INTERNAL] ";
9038 
9039 %feature("docstring")  casadi::FunctionInternal::alloc_iw(size_t sz_iw, bool
9040 persistent=false) "
9041 
9042 [INTERNAL]  Ensure required length of iw field.
9043 
9044 ";
9045 
9046 %feature("docstring")  casadi::FunctionInternal::print_options(std::ostream
9047 &stream) const  "
9048 
9049 [INTERNAL]  Print list of options.
9050 
9051 ";
9052 
9053 %feature("docstring")  casadi::FunctionInternal::convert_res(const
9054 std::vector< M > &res) const  "
9055 
9056 [INTERNAL]  Convert from/to input/output lists/map.
9057 
9058 ";
9059 
9060 %feature("docstring")  casadi::FunctionInternal::convert_res(const std::map<
9061 std::string, M > &res) const  "
9062 
9063 [INTERNAL]  Convert from/to input/output lists/map.
9064 
9065 ";
9066 
9067 %feature("docstring")  casadi::FunctionInternal::replace_fseed(const
9068 std::vector< std::vector< M >> &fseed, casadi_int npar) const  "
9069 
9070 [INTERNAL]  Replace 0-by-0 forward seeds.
9071 
9072 ";
9073 
9074 %feature("docstring")  casadi::FunctionInternal::replace_fseed(const
9075 std::vector< std::vector< M > > &fseed, casadi_int npar) const  "
9076 
9077 [INTERNAL] ";
9078 
9079 %feature("docstring")  casadi::FunctionInternal::finalize()  "
9080 
9081 [INTERNAL]  Finalize the object creation.
9082 
9083 ";
9084 
9085 %feature("docstring")
9086 casadi::FunctionInternal::serialize_body(SerializingStream &s) const  "
9087 
9088 [INTERNAL]  Serialize an object without type information.
9089 
9090 ";
9091 
9092 %feature("docstring")  casadi::FunctionInternal::map(casadi_int n, const
9093 std::string &parallelization) const  "
9094 
9095 [INTERNAL]  Generate/retrieve cached serial map.
9096 
9097 ";
9098 
9099 %feature("docstring")  casadi::CentralDiff::calc_fd(double **yk, double *y0,
9100 double *J, double h) const  "
9101 
9102 [INTERNAL] ";
9103 
9104 %feature("docstring")  casadi::CentralDiff::calc_fd() const  "
9105 
9106 [INTERNAL] ";
9107 
9108 %feature("docstring")  casadi::ProtoFunction::sprint(char *buf, size_t
9109 buf_sz, const char *fmt,...) const  "
9110 
9111 [INTERNAL]  C-style formatted printing to string.
9112 
9113 ";
9114 
9115 %feature("docstring")  casadi::ProtoFunction::free_mem(void *mem) const  "
9116 
9117 [INTERNAL]  Free memory block.
9118 
9119 ";
9120 
9121 %feature("docstring")  casadi::FunctionInternal::project_res(const
9122 std::vector< M > &arg, casadi_int npar) const  "
9123 
9124 [INTERNAL]   Project sparsities.
9125 
9126 ";
9127 
9128 %feature("docstring")  casadi::FunctionInternal::fwd_seed(casadi_int nfwd)
9129 const  "
9130 
9131 [INTERNAL]  Symbolic expressions for the forward seeds.
9132 
9133 ";
9134 
9135 %feature("docstring")  casadi::CentralDiff::class_name() const  "
9136 
9137 [INTERNAL]  Get type name.
9138 
9139 ";
9140 
9141 %feature("docstring")  casadi::FunctionInternal::nnz_in() const  "
9142 
9143 [INTERNAL]  Number of input/output nonzeros.
9144 
9145 ";
9146 
9147 %feature("docstring")  casadi::FunctionInternal::nnz_in(casadi_int ind)
9148 const  "
9149 
9150 [INTERNAL]  Number of input/output nonzeros.
9151 
9152 ";
9153 
9154 %feature("docstring")  casadi::FunctionInternal::has_jac() const  "
9155 
9156 [INTERNAL]  Return Jacobian of all input elements with respect to all output
9157 elements.
9158 
9159 ";
9160 
9161 %feature("docstring")  casadi::FunctionInternal::project_arg(const
9162 std::vector< M > &arg, casadi_int npar) const  "
9163 
9164 [INTERNAL]   Project sparsities.
9165 
9166 ";
9167 
9168 %feature("docstring")  casadi::FunctionInternal::get_partition(casadi_int
9169 iind, casadi_int oind, Sparsity &D1, Sparsity &D2, bool compact, bool
9170 symmetric, bool allow_forward, bool allow_reverse) const  "
9171 
9172 [INTERNAL]  Get the unidirectional or bidirectional partition.
9173 
9174 ";
9175 
9176 %feature("docstring")  casadi::FunctionInternal::free_sx() const  "
9177 
9178 [INTERNAL]  Get free variables (SX)
9179 
9180 ";
9181 
9182 %feature("docstring")
9183 casadi::FunctionInternal::codegen_free_mem(CodeGenerator &g) const  "
9184 
9185 [INTERNAL]  Codegen for free_mem.
9186 
9187 ";
9188 
9189 %feature("docstring")  casadi::FunctionInternal::nz_in(const std::vector< DM
9190 > &arg) const  "
9191 
9192 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
9193 
9194 ";
9195 
9196 %feature("docstring")  casadi::FunctionInternal::nz_in(const std::vector<
9197 double > &arg) const  "
9198 
9199 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
9200 
9201 ";
9202 
9203 %feature("docstring")  casadi::FunctionInternal::getJacSparsity(casadi_int
9204 iind, casadi_int oind, bool symmetric) const  "
9205 
9206 [INTERNAL]  Generate the sparsity of a Jacobian block.
9207 
9208 ";
9209 
9210 %feature("docstring")  casadi::ProtoFunction::print_time(const std::map<
9211 std::string, FStats > &fstats) const  "
9212 
9213 [INTERNAL]  Print timing statistics.
9214 
9215 ";
9216 
9217 %feature("docstring")  casadi::FunctionInternal::is_a(const std::string
9218 &type, bool recursive) const  "
9219 
9220 [INTERNAL]  Check if the function is of a particular type.
9221 
9222 ";
9223 
9224 %feature("docstring")  casadi::ProtoFunction::checkout() const  "
9225 
9226 [INTERNAL]  Checkout a memory object.
9227 
9228 ";
9229 
9230 %feature("docstring")  casadi::FunctionInternal::which_depends(const
9231 std::string &s_in, const std::vector< std::string > &s_out, casadi_int
9232 order, bool tr=false) const  "
9233 
9234 [INTERNAL]  Which variables enter with some order.
9235 
9236 Parameters:
9237 -----------
9238 
9239 s_in:   Input name
9240 
9241 s_out:   Output name(s)
9242 
9243 order:  Only 1 (linear) and 2 (nonlinear) allowed
9244 
9245 tr:  Flip the relationship. Return which expressions contain the variables
9246 
9247 ";
9248 
9249 %feature("docstring")  casadi::FunctionInternal::n_instructions() const  "
9250 
9251 [INTERNAL]  Get the number of atomic operations.
9252 
9253 ";
9254 
9255 %feature("docstring")  casadi::FunctionInternal::get_jacobian(const
9256 std::string &name, const std::vector< std::string > &inames, const
9257 std::vector< std::string > &onames, const Dict &opts) const  "
9258 
9259 [INTERNAL]  Return Jacobian of all input elements with respect to all output
9260 elements.
9261 
9262 ";
9263 
9264 %feature("docstring")  casadi::FunctionInternal::numel_in() const  "
9265 
9266 [INTERNAL]  Number of input/output elements.
9267 
9268 ";
9269 
9270 %feature("docstring")  casadi::FunctionInternal::numel_in(casadi_int ind)
9271 const  "
9272 
9273 [INTERNAL]  Number of input/output elements.
9274 
9275 ";
9276 
9277 %feature("docstring")  casadi::FunctionInternal::get_jac(const std::string
9278 &name, const std::vector< std::string > &inames, const std::vector<
9279 std::string > &onames, const Dict &opts) const  "
9280 
9281 [INTERNAL]  Return Jacobian of all input elements with respect to all output
9282 elements.
9283 
9284 ";
9285 
9286 %feature("docstring")  casadi::ProtoFunction::get_stats(void *mem) const  "
9287 
9288 [INTERNAL]  Get all statistics.
9289 
9290 ";
9291 
9292 %feature("docstring")  casadi::FunctionInternal::has_spfwd() const  "
9293 
9294 [INTERNAL]  Is the class able to propagate seeds through the algorithm?
9295 
9296 ";
9297 
9298 %feature("docstring")  casadi::FunctionInternal::get_max_in(casadi_int ind)
9299 const  "
9300 
9301 [INTERNAL]  Get largest input value.
9302 
9303 ";
9304 
9305 %feature("docstring")  casadi::FunctionInternal::wrap() const  "
9306 
9307 [INTERNAL]  Wrap in an Function instance consisting of only one MX call.
9308 
9309 ";
9310 
9311 %feature("docstring")  casadi::FiniteDiff::has_codegen() const  "
9312 
9313 [INTERNAL]  Is codegen supported?
9314 
9315 ";
9316 
9317 %feature("docstring")  casadi::ProtoFunction::print(const char *fmt,...)
9318 const  "
9319 
9320 [INTERNAL]  C-style formatted printing during evaluation.
9321 
9322 ";
9323 
9324 %feature("docstring")  casadi::FunctionInternal::check_mat(const Sparsity
9325 &arg, const Sparsity &inp, casadi_int &npar) "
9326 
9327 [INTERNAL]  Helper function
9328 
9329 Parameters:
9330 -----------
9331 
9332 npar[in]:  normal usage: 1, disallow pararallel calls: -1
9333 
9334 npar[out]:  required number of parallel calls (or -1)
9335 
9336 ";
9337 
9338 %feature("docstring")  casadi::FunctionInternal::slice(const std::string
9339 &name, const std::vector< casadi_int > &order_in, const std::vector<
9340 casadi_int > &order_out, const Dict &opts) const  "
9341 
9342 [INTERNAL]  returns a new function with a selection of inputs/outputs of the
9343 original
9344 
9345 ";
9346 
9347 %feature("docstring")
9348 casadi::FunctionInternal::codegen_incref(CodeGenerator &g) const  "
9349 
9350 [INTERNAL]  Codegen incref for dependencies.
9351 
9352 ";
9353 
9354 %feature("docstring")  casadi::ProtoFunction::release(int mem) const  "
9355 
9356 [INTERNAL]  Release a memory object.
9357 
9358 ";
9359 
9360 %feature("docstring")  casadi::ProtoFunction::memory(int ind) const  "
9361 
9362 [INTERNAL]  Memory objects.
9363 
9364 ";
9365 
9366 %feature("docstring")  casadi::FunctionInternal::has_sprev() const  "
9367 
9368 [INTERNAL]  Is the class able to propagate seeds through the algorithm?
9369 
9370 ";
9371 
9372 %feature("docstring")  casadi::FunctionInternal::call_reverse(const
9373 std::vector< MX > &arg, const std::vector< MX > &res, const std::vector<
9374 std::vector< MX > > &aseed, std::vector< std::vector< MX > > &asens, bool
9375 always_inline, bool never_inline) const  "
9376 
9377 [INTERNAL]  Reverse mode, virtual functions overloaded in derived classes.
9378 
9379 ";
9380 
9381 %feature("docstring")  casadi::FunctionInternal::call_reverse(const
9382 std::vector< SX > &arg, const std::vector< SX > &res, const std::vector<
9383 std::vector< SX > > &aseed, std::vector< std::vector< SX > > &asens, bool
9384 always_inline, bool never_inline) const  "
9385 
9386 [INTERNAL]  Reverse mode, virtual functions overloaded in derived classes.
9387 
9388 ";
9389 
9390 %feature("docstring")  casadi::FiniteDiff::get_sparsity_in(casadi_int i)  "
9391 
9392 [INTERNAL]  Sparsities of function inputs and outputs.
9393 
9394 ";
9395 
9396 %feature("docstring")  casadi::FunctionInternal::sp_reverse(bvec_t **arg,
9397 bvec_t **res, casadi_int *iw, bvec_t *w, void *mem) const  "
9398 
9399 [INTERNAL]  Propagate sparsity backwards.
9400 
9401 ";
9402 
9403 %feature("docstring")  casadi::FunctionInternal::get_free() const  "
9404 
9405 [INTERNAL]  Print free variables.
9406 
9407 ";
9408 
9409 %feature("docstring")  casadi::FunctionInternal::symbolic_output(const
9410 std::vector< MX > &arg) const  "
9411 
9412 [INTERNAL]  Get a vector of symbolic variables corresponding to the outputs.
9413 
9414 ";
9415 
9416 %feature("docstring")  casadi::FunctionInternal::mx_out(casadi_int ind)
9417 const  "
9418 
9419 [INTERNAL]  Get function input(s) and output(s)
9420 
9421 ";
9422 
9423 %feature("docstring")  casadi::FunctionInternal::mx_out() const  "
9424 
9425 [INTERNAL]  Get function input(s) and output(s)
9426 
9427 ";
9428 
9429 %feature("docstring")  casadi::FunctionInternal::has_free() const  "
9430 
9431 [INTERNAL]  Does the function have free variables.
9432 
9433 ";
9434 
9435 %feature("docstring")  casadi::FunctionInternal::sp_forward(const bvec_t
9436 **arg, bvec_t **res, casadi_int *iw, bvec_t *w, void *mem) const  "
9437 
9438 [INTERNAL]  Propagate sparsity forward.
9439 
9440 ";
9441 
9442 %feature("docstring")  casadi::FunctionInternal::jacobian_sparsity() const
9443 "
9444 
9445 [INTERNAL]  Get Jacobian sparsity.
9446 
9447 ";
9448 
9449 %feature("docstring")  casadi::FunctionInternal::check_res(const
9450 std::vector< M > &res, casadi_int &npar) const  "
9451 
9452 [INTERNAL]  Check if output arguments have correct length and dimensions.
9453 
9454 Raises errors.
9455 
9456 Parameters:
9457 -----------
9458 
9459 npar[in]:  normal usage: 1, disallow pararallel calls: -1
9460 
9461 npar:  max number of horizontal repetitions across all arguments (or -1)
9462 
9463 ";
9464 
9465 %feature("docstring")  casadi::FunctionInternal::sx_in(casadi_int ind) const
9466 "
9467 
9468 [INTERNAL]  Get function input(s) and output(s)
9469 
9470 ";
9471 
9472 %feature("docstring")  casadi::FunctionInternal::sx_in() const  "
9473 
9474 [INTERNAL]  Get function input(s) and output(s)
9475 
9476 ";
9477 
9478 %feature("docstring")  casadi::FunctionInternal::sparsity_out(casadi_int
9479 ind) const  "
9480 
9481 [INTERNAL]  Input/output sparsity.
9482 
9483 ";
9484 
9485 %feature("docstring")  casadi::FunctionInternal::codegen(CodeGenerator &g,
9486 const std::string &fname) const  "
9487 
9488 [INTERNAL]  Generate code the function.
9489 
9490 ";
9491 
9492 %feature("docstring")  casadi::FunctionInternal::free_mx() const  "
9493 
9494 [INTERNAL]  Get free variables ( MX)
9495 
9496 ";
9497 
9498 %feature("docstring")  casadi::FunctionInternal::self() const  "
9499 
9500 [INTERNAL]  Get a public class instance.
9501 
9502 ";
9503 
9504 %feature("docstring") casadi::CentralDiff::~CentralDiff "
9505 
9506 [INTERNAL]  Destructor.
9507 
9508 ";
9509 
9510 %feature("docstring")  casadi::FunctionInternal::index_out(const std::string
9511 &name) const  "
9512 
9513 [INTERNAL]  Get output scheme index by name.
9514 
9515 ";
9516 
9517 %feature("docstring")  casadi::FunctionInternal::alloc(const Function &f,
9518 bool persistent=false) "
9519 
9520 [INTERNAL]  Ensure work vectors long enough to evaluate function.
9521 
9522 ";
9523 
9524 %feature("docstring")  casadi::FiniteDiff::eval(const double **arg, double
9525 **res, casadi_int *iw, double *w, void *mem) const  "
9526 
9527 [INTERNAL]  Evaluate numerically.
9528 
9529 ";
9530 
9531 %feature("docstring")  casadi::FunctionInternal::info() const  "
9532 
9533 [INTERNAL]  Obtain information about function
9534 
9535 ";
9536 
9537 %feature("docstring")
9538 casadi::FiniteDiff::codegen_declarations(CodeGenerator &g) const  "
9539 
9540 [INTERNAL]  Generate code for the declarations of the C function.
9541 
9542 ";
9543 
9544 %feature("docstring")
9545 casadi::FunctionInternal::getJacSparsityHierarchicalSymm(casadi_int iind,
9546 casadi_int oind) const  "
9547 
9548 [INTERNAL]  A flavor of getJacSparsity that does hierarchical block
9549 structure recognition for symmetric Jacobians
9550 
9551 ";
9552 
9553 %feature("docstring")  casadi::FunctionInternal::size_out(casadi_int ind)
9554 const  "
9555 
9556 [INTERNAL]  Input/output dimensions.
9557 
9558 ";
9559 
9560 %feature("docstring")  casadi::FunctionInternal::sz_iw() const  "
9561 
9562 [INTERNAL]  Get required length of iw field.
9563 
9564 ";
9565 
9566 %feature("docstring")  casadi::FunctionInternal::size1_in(casadi_int ind)
9567 const  "
9568 
9569 [INTERNAL]  Input/output dimensions.
9570 
9571 ";
9572 
9573 %feature("docstring")  casadi::FunctionInternal::sp_weight() const  "
9574 
9575 [INTERNAL]  Weighting factor for chosing forward/reverse mode, sparsity
9576 propagation.
9577 
9578 ";
9579 
9580 %feature("docstring")
9581 casadi::FunctionInternal::print_dimensions(std::ostream &stream) const  "
9582 
9583 [INTERNAL]  Print dimensions of inputs and outputs.
9584 
9585 ";
9586 
9587 %feature("docstring")  casadi::FunctionInternal::get_reltol() const  "
9588 
9589 [INTERNAL]  Get relative tolerance.
9590 
9591 ";
9592 
9593 %feature("docstring")  casadi::FunctionInternal::size_in(casadi_int ind)
9594 const  "
9595 
9596 [INTERNAL]  Input/output dimensions.
9597 
9598 ";
9599 
9600 %feature("docstring")  casadi::CentralDiff::n_pert() const  "
9601 
9602 [INTERNAL] ";
9603 
9604 %feature("docstring")  casadi::FunctionInternal::all_scalar() const  "
9605 
9606 [INTERNAL]  Are all inputs and outputs scalar.
9607 
9608 ";
9609 
9610 %feature("docstring")  casadi::FunctionInternal::has_reverse(casadi_int
9611 nadj) const  "
9612 
9613 [INTERNAL]  Return function that calculates adjoint derivatives
9614 reverse(nadj) returns a cached instance if available, and calls  Function
9615 get_reverse(casadi_int nadj) if no cached version is available.
9616 
9617 ";
9618 
9619 %feature("docstring")  casadi::FunctionInternal::sx_out(casadi_int ind)
9620 const  "
9621 
9622 [INTERNAL]  Get function input(s) and output(s)
9623 
9624 ";
9625 
9626 %feature("docstring")  casadi::FunctionInternal::sx_out() const  "
9627 
9628 [INTERNAL]  Get function input(s) and output(s)
9629 
9630 ";
9631 
9632 %feature("docstring")  casadi::FunctionInternal::sz_work(size_t &sz_arg,
9633 size_t &sz_res, size_t &sz_iw, size_t &sz_w) const  "
9634 
9635 [INTERNAL]  Get number of temporary variables needed.
9636 
9637 ";
9638 
9639 %feature("docstring")  casadi::FunctionInternal::tocache(const Function &f,
9640 const std::string &suffix="") const  "
9641 
9642 [INTERNAL]  Save function to cache.
9643 
9644 ";
9645 
9646 %feature("docstring")
9647 casadi::FunctionInternal::serialize_type(SerializingStream &s) const  "
9648 
9649 [INTERNAL]  Serialize type information.
9650 
9651 ";
9652 
9653 %feature("docstring")  casadi::ProtoFunction::construct(const Dict &opts) "
9654 
9655 [INTERNAL]  Construct Prepares the function for evaluation.
9656 
9657 ";
9658 
9659 %feature("docstring")
9660 casadi::FunctionInternal::instruction_constant(casadi_int k) const  "
9661 
9662 [INTERNAL]  Get the floating point output argument of an atomic operation.
9663 
9664 ";
9665 
9666 %feature("docstring")
9667 casadi::FunctionInternal::codegen_sparsities(CodeGenerator &g) const  "
9668 
9669 [INTERNAL]  Codegen sparsities.
9670 
9671 ";
9672 
9673 %feature("docstring")  casadi::FiniteDiff::get_n_out()  "
9674 
9675 [INTERNAL]  Number of function inputs and outputs.
9676 
9677 ";
9678 
9679 %feature("docstring")  casadi::FiniteDiff::init(const Dict &opts)  "
9680 
9681 [INTERNAL]  Initialize.
9682 
9683 ";
9684 
9685 %feature("docstring")  casadi::FunctionInternal::jit_dependencies(const
9686 std::string &fname) "
9687 
9688 [INTERNAL]  Jit dependencies.
9689 
9690 ";
9691 
9692 %feature("docstring")  casadi::FunctionInternal::alloc_arg(size_t sz_arg,
9693 bool persistent=false) "
9694 
9695 [INTERNAL]  Ensure required length of arg field.
9696 
9697 ";
9698 
9699 %feature("docstring")  casadi::FunctionInternal::index_in(const std::string
9700 &name) const  "
9701 
9702 [INTERNAL]  Get input scheme index by name.
9703 
9704 ";
9705 
9706 %feature("docstring")  casadi::FunctionInternal::codegen_name(const
9707 CodeGenerator &g, bool ns=true) const  "
9708 
9709 [INTERNAL]  Get name in codegen.
9710 
9711 ";
9712 
9713 %feature("docstring")  casadi::FunctionInternal::has_jacobian_sparsity()
9714 const  "
9715 
9716 [INTERNAL]  Get Jacobian sparsity.
9717 
9718 ";
9719 
9720 %feature("docstring")  casadi::FunctionInternal::codegen_meta(CodeGenerator
9721 &g) const  "
9722 
9723 [INTERNAL]  Generate meta-information allowing a user to evaluate a
9724 generated function.
9725 
9726 ";
9727 
9728 %feature("docstring")  casadi::FunctionInternal::eval_dm(const std::vector<
9729 DM > &arg) const  "
9730 
9731 [INTERNAL]  Evaluate with DM matrices.
9732 
9733 ";
9734 
9735 %feature("docstring")  casadi::FunctionInternal::dm_out(casadi_int ind)
9736 const  "
9737 
9738 [INTERNAL]  Get function input(s) and output(s)
9739 
9740 ";
9741 
9742 %feature("docstring")  casadi::FunctionInternal::dm_out() const  "
9743 
9744 [INTERNAL]  Get function input(s) and output(s)
9745 
9746 ";
9747 
9748 %feature("docstring")  casadi::FunctionInternal::set_work(void *mem, const
9749 double **&arg, double **&res, casadi_int *&iw, double *&w) const  "
9750 
9751 [INTERNAL]  Set the (persistent) work vectors.
9752 
9753 ";
9754 
9755 %feature("docstring")  casadi::FunctionInternal::signature(const std::string
9756 &fname) const  "
9757 
9758 [INTERNAL]  Code generate the function.
9759 
9760 ";
9761 
9762 %feature("docstring")  casadi::CentralDiff::has_forward(casadi_int nfwd)
9763 const  "
9764 
9765 [INTERNAL]  Second order derivatives.
9766 
9767 ";
9768 
9769 %feature("docstring")  casadi::FunctionInternal::replace_aseed(const
9770 std::vector< std::vector< M >> &aseed, casadi_int npar) const  "
9771 
9772 [INTERNAL]  Replace 0-by-0 reverse seeds.
9773 
9774 ";
9775 
9776 %feature("docstring")  casadi::FunctionInternal::replace_aseed(const
9777 std::vector< std::vector< M > > &aseed, casadi_int npar) const  "
9778 
9779 [INTERNAL] ";
9780 
9781 %feature("docstring")  casadi::FunctionInternal::factory(const std::string
9782 &name, const std::vector< std::string > &s_in, const std::vector<
9783 std::string > &s_out, const Function::AuxOut &aux, const Dict &opts) const
9784 "
9785 
9786 [INTERNAL] ";
9787 
9788 %feature("docstring")  casadi::FunctionInternal::get_min_in(casadi_int ind)
9789 const  "
9790 
9791 [INTERNAL]  Get smallest input value.
9792 
9793 ";
9794 
9795 %feature("docstring")  casadi::FunctionInternal::has_derivative() const  "
9796 
9797 [INTERNAL]  Can derivatives be calculated in any way?
9798 
9799 ";
9800 
9801 %feature("docstring")  casadi::FunctionInternal::getAdaptorSolverName()
9802 const  "
9803 
9804 [INTERNAL]  Obtain solver name from Adaptor.
9805 
9806 ";
9807 
9808 %feature("docstring") casadi::CentralDiff "
9809 
9810 [INTERNAL]  Calculate derivative using central differences Joel Andersson
9811 
9812 >List of available options
9813 
9814 +------------------+-----------------+------------------+------------------+
9815 |        Id        |      Type       |   Description    |     Used in      |
9816 +==================+=================+==================+==================+
9817 | abstol           | OT_DOUBLE       | Accuracy of      | casadi::CentralD |
9818 |                  |                 | function outputs | iff              |
9819 |                  |                 | [default: query  |                  |
9820 |                  |                 | object]          |                  |
9821 +------------------+-----------------+------------------+------------------+
9822 | ad_weight        | OT_DOUBLE       | Weighting factor | casadi::Function |
9823 |                  |                 | for derivative   | Internal         |
9824 |                  |                 | calculation.When |                  |
9825 |                  |                 | there is an      |                  |
9826 |                  |                 | option of either |                  |
9827 |                  |                 | using forward or |                  |
9828 |                  |                 | reverse mode     |                  |
9829 |                  |                 | directional      |                  |
9830 |                  |                 | derivatives, the |                  |
9831 |                  |                 | condition ad_wei |                  |
9832 |                  |                 | ght*nf<=(1-ad_we |                  |
9833 |                  |                 | ight)*na is used |                  |
9834 |                  |                 | where nf and na  |                  |
9835 |                  |                 | are estimates of |                  |
9836 |                  |                 | the number of    |                  |
9837 |                  |                 | forward/reverse  |                  |
9838 |                  |                 | mode directional |                  |
9839 |                  |                 | derivatives      |                  |
9840 |                  |                 | needed. By       |                  |
9841 |                  |                 | default,         |                  |
9842 |                  |                 | ad_weight is     |                  |
9843 |                  |                 | calculated       |                  |
9844 |                  |                 | automatically,   |                  |
9845 |                  |                 | but this can be  |                  |
9846 |                  |                 | overridden by    |                  |
9847 |                  |                 | setting this     |                  |
9848 |                  |                 | option. In       |                  |
9849 |                  |                 | particular, 0    |                  |
9850 |                  |                 | means forcing    |                  |
9851 |                  |                 | forward mode and |                  |
9852 |                  |                 | 1 forcing        |                  |
9853 |                  |                 | reverse mode.    |                  |
9854 |                  |                 | Leave unset for  |                  |
9855 |                  |                 | (class specific) |                  |
9856 |                  |                 | heuristics.      |                  |
9857 +------------------+-----------------+------------------+------------------+
9858 | ad_weight_sp     | OT_DOUBLE       | Weighting factor | casadi::Function |
9859 |                  |                 | for sparsity     | Internal         |
9860 |                  |                 | pattern          |                  |
9861 |                  |                 | calculation calc |                  |
9862 |                  |                 | ulation.Override |                  |
9863 |                  |                 | s default        |                  |
9864 |                  |                 | behavior. Set to |                  |
9865 |                  |                 | 0 and 1 to force |                  |
9866 |                  |                 | forward and      |                  |
9867 |                  |                 | reverse mode     |                  |
9868 |                  |                 | respectively.    |                  |
9869 |                  |                 | Cf. option       |                  |
9870 |                  |                 | \"ad_weight\".     |                  |
9871 |                  |                 | When set to -1,  |                  |
9872 |                  |                 | sparsity is      |                  |
9873 |                  |                 | completely       |                  |
9874 |                  |                 | ignored and      |                  |
9875 |                  |                 | dense matrices   |                  |
9876 |                  |                 | are used.        |                  |
9877 +------------------+-----------------+------------------+------------------+
9878 | always_inline    | OT_BOOL         | Force inlining.  | casadi::Function |
9879 |                  |                 |                  | Internal         |
9880 +------------------+-----------------+------------------+------------------+
9881 | compiler         | OT_STRING       | Just-in-time     | casadi::Function |
9882 |                  |                 | compiler plugin  | Internal         |
9883 |                  |                 | to be used.      |                  |
9884 +------------------+-----------------+------------------+------------------+
9885 | custom_jacobian  | OT_FUNCTION     | Override         | casadi::Function |
9886 |                  |                 | CasADi's AD. Use | Internal         |
9887 |                  |                 | together with    |                  |
9888 |                  |                 | 'jac_penalty':   |                  |
9889 |                  |                 | 0. Note: Highly  |                  |
9890 |                  |                 | experimental.    |                  |
9891 |                  |                 | Syntax may break |                  |
9892 |                  |                 | often.           |                  |
9893 +------------------+-----------------+------------------+------------------+
9894 | derivative_of    | OT_FUNCTION     | The function is  | casadi::Function |
9895 |                  |                 | a derivative of  | Internal         |
9896 |                  |                 | another          |                  |
9897 |                  |                 | function. The    |                  |
9898 |                  |                 | type of          |                  |
9899 |                  |                 | derivative       |                  |
9900 |                  |                 | (directional     |                  |
9901 |                  |                 | derivative,      |                  |
9902 |                  |                 | Jacobian) is     |                  |
9903 |                  |                 | inferred from    |                  |
9904 |                  |                 | the function     |                  |
9905 |                  |                 | name.            |                  |
9906 +------------------+-----------------+------------------+------------------+
9907 | dump             | OT_BOOL         | Dump function to | casadi::Function |
9908 |                  |                 | file upon first  | Internal         |
9909 |                  |                 | evaluation.      |                  |
9910 |                  |                 | [false]          |                  |
9911 +------------------+-----------------+------------------+------------------+
9912 | dump_dir         | OT_STRING       | Directory to     | casadi::Function |
9913 |                  |                 | dump             | Internal         |
9914 |                  |                 | inputs/outputs   |                  |
9915 |                  |                 | to. Make sure    |                  |
9916 |                  |                 | the directory    |                  |
9917 |                  |                 | exists [.]       |                  |
9918 +------------------+-----------------+------------------+------------------+
9919 | dump_format      | OT_STRING       | Choose file      | casadi::Function |
9920 |                  |                 | format to dump   | Internal         |
9921 |                  |                 | matrices. See    |                  |
9922 |                  |                 | DM.from_file     |                  |
9923 |                  |                 | [mtx]            |                  |
9924 +------------------+-----------------+------------------+------------------+
9925 | dump_in          | OT_BOOL         | Dump numerical   | casadi::Function |
9926 |                  |                 | values of inputs | Internal         |
9927 |                  |                 | to file          |                  |
9928 |                  |                 | (readable with   |                  |
9929 |                  |                 | DM.from_file )   |                  |
9930 |                  |                 | [default: false] |                  |
9931 +------------------+-----------------+------------------+------------------+
9932 | dump_out         | OT_BOOL         | Dump numerical   | casadi::Function |
9933 |                  |                 | values of        | Internal         |
9934 |                  |                 | outputs to file  |                  |
9935 |                  |                 | (readable with   |                  |
9936 |                  |                 | DM.from_file )   |                  |
9937 |                  |                 | [default: false] |                  |
9938 +------------------+-----------------+------------------+------------------+
9939 | enable_fd        | OT_BOOL         | Enable           | casadi::Function |
9940 |                  |                 | derivative       | Internal         |
9941 |                  |                 | calculation by   |                  |
9942 |                  |                 | finite           |                  |
9943 |                  |                 | differencing.    |                  |
9944 |                  |                 | [default:        |                  |
9945 |                  |                 | false]]          |                  |
9946 +------------------+-----------------+------------------+------------------+
9947 | enable_forward   | OT_BOOL         | Enable           | casadi::Function |
9948 |                  |                 | derivative       | Internal         |
9949 |                  |                 | calculation      |                  |
9950 |                  |                 | using generated  |                  |
9951 |                  |                 | functions for    |                  |
9952 |                  |                 | Jacobian-times-  |                  |
9953 |                  |                 | vector products  |                  |
9954 |                  |                 | - typically      |                  |
9955 |                  |                 | using forward    |                  |
9956 |                  |                 | mode AD - if     |                  |
9957 |                  |                 | available.       |                  |
9958 |                  |                 | [default: true]  |                  |
9959 +------------------+-----------------+------------------+------------------+
9960 | enable_jacobian  | OT_BOOL         | Enable           | casadi::Function |
9961 |                  |                 | derivative       | Internal         |
9962 |                  |                 | calculation      |                  |
9963 |                  |                 | using generated  |                  |
9964 |                  |                 | functions for    |                  |
9965 |                  |                 | Jacobians of all |                  |
9966 |                  |                 | differentiable   |                  |
9967 |                  |                 | outputs with     |                  |
9968 |                  |                 | respect to all   |                  |
9969 |                  |                 | differentiable   |                  |
9970 |                  |                 | inputs - if      |                  |
9971 |                  |                 | available.       |                  |
9972 |                  |                 | [default: true]  |                  |
9973 +------------------+-----------------+------------------+------------------+
9974 | enable_reverse   | OT_BOOL         | Enable           | casadi::Function |
9975 |                  |                 | derivative       | Internal         |
9976 |                  |                 | calculation      |                  |
9977 |                  |                 | using generated  |                  |
9978 |                  |                 | functions for    |                  |
9979 |                  |                 | transposed       |                  |
9980 |                  |                 | Jacobian-times-  |                  |
9981 |                  |                 | vector products  |                  |
9982 |                  |                 | - typically      |                  |
9983 |                  |                 | using reverse    |                  |
9984 |                  |                 | mode AD - if     |                  |
9985 |                  |                 | available.       |                  |
9986 |                  |                 | [default: true]  |                  |
9987 +------------------+-----------------+------------------+------------------+
9988 | fd_method        | OT_STRING       | Method for       | casadi::Function |
9989 |                  |                 | finite           | Internal         |
9990 |                  |                 | differencing     |                  |
9991 |                  |                 | [default         |                  |
9992 |                  |                 | 'central']       |                  |
9993 +------------------+-----------------+------------------+------------------+
9994 | fd_options       | OT_DICT         | Options to be    | casadi::Function |
9995 |                  |                 | passed to the    | Internal         |
9996 |                  |                 | finite           |                  |
9997 |                  |                 | difference       |                  |
9998 |                  |                 | instance         |                  |
9999 +------------------+-----------------+------------------+------------------+
10000 | forward_options  | OT_DICT         | Options to be    | casadi::Function |
10001 |                  |                 | passed to a      | Internal         |
10002 |                  |                 | forward mode     |                  |
10003 |                  |                 | constructor      |                  |
10004 +------------------+-----------------+------------------+------------------+
10005 | gather_stats     | OT_BOOL         | Deprecated       | casadi::Function |
10006 |                  |                 | option           | Internal         |
10007 |                  |                 | (ignored):       |                  |
10008 |                  |                 | Statistics are   |                  |
10009 |                  |                 | now always       |                  |
10010 |                  |                 | collected.       |                  |
10011 +------------------+-----------------+------------------+------------------+
10012 | h                | OT_DOUBLE       | Step size        | casadi::CentralD |
10013 |                  |                 | [default:        | iff              |
10014 |                  |                 | computed from    |                  |
10015 |                  |                 | abstol]          |                  |
10016 +------------------+-----------------+------------------+------------------+
10017 | h_iter           | OT_INT          | Number of        | casadi::CentralD |
10018 |                  |                 | iterations to    | iff              |
10019 |                  |                 | improve on the   |                  |
10020 |                  |                 | step-size        |                  |
10021 |                  |                 | [default: 1 if   |                  |
10022 |                  |                 | error estimate   |                  |
10023 |                  |                 | available,       |                  |
10024 |                  |                 | otherwise 0]     |                  |
10025 +------------------+-----------------+------------------+------------------+
10026 | h_max            | OT_DOUBLE       | Maximum step     | casadi::CentralD |
10027 |                  |                 | size [default 0] | iff              |
10028 +------------------+-----------------+------------------+------------------+
10029 | h_min            | OT_DOUBLE       | Minimum step     | casadi::CentralD |
10030 |                  |                 | size [default    | iff              |
10031 |                  |                 | inf]             |                  |
10032 +------------------+-----------------+------------------+------------------+
10033 | input_scheme     | OT_STRINGVECTOR | Deprecated       | casadi::Function |
10034 |                  |                 | option (ignored) | Internal         |
10035 +------------------+-----------------+------------------+------------------+
10036 | inputs_check     | OT_BOOL         | Throw exceptions | casadi::Function |
10037 |                  |                 | when the         | Internal         |
10038 |                  |                 | numerical values |                  |
10039 |                  |                 | of the inputs    |                  |
10040 |                  |                 | don't make sense |                  |
10041 +------------------+-----------------+------------------+------------------+
10042 | is_diff_in       | OT_BOOLVECTOR   | Indicate for     | casadi::Function |
10043 |                  |                 | each input if it | Internal         |
10044 |                  |                 | should be        |                  |
10045 |                  |                 | differentiable.  |                  |
10046 +------------------+-----------------+------------------+------------------+
10047 | is_diff_out      | OT_BOOLVECTOR   | Indicate for     | casadi::Function |
10048 |                  |                 | each output if   | Internal         |
10049 |                  |                 | it should be     |                  |
10050 |                  |                 | differentiable.  |                  |
10051 +------------------+-----------------+------------------+------------------+
10052 | jac_penalty      | OT_DOUBLE       | When requested   | casadi::Function |
10053 |                  |                 | for a number of  | Internal         |
10054 |                  |                 | forward/reverse  |                  |
10055 |                  |                 | directions, it   |                  |
10056 |                  |                 | may be cheaper   |                  |
10057 |                  |                 | to compute first |                  |
10058 |                  |                 | the full         |                  |
10059 |                  |                 | jacobian and     |                  |
10060 |                  |                 | then multiply    |                  |
10061 |                  |                 | with seeds,      |                  |
10062 |                  |                 | rather than      |                  |
10063 |                  |                 | obtain the       |                  |
10064 |                  |                 | requested        |                  |
10065 |                  |                 | directions in a  |                  |
10066 |                  |                 | straightforward  |                  |
10067 |                  |                 | manner. Casadi   |                  |
10068 |                  |                 | uses a heuristic |                  |
10069 |                  |                 | to decide which  |                  |
10070 |                  |                 | is cheaper. A    |                  |
10071 |                  |                 | high value of    |                  |
10072 |                  |                 | 'jac_penalty'    |                  |
10073 |                  |                 | makes it less    |                  |
10074 |                  |                 | likely for the   |                  |
10075 |                  |                 | heurstic to      |                  |
10076 |                  |                 | chose the full   |                  |
10077 |                  |                 | Jacobian         |                  |
10078 |                  |                 | strategy. The    |                  |
10079 |                  |                 | special value -1 |                  |
10080 |                  |                 | indicates never  |                  |
10081 |                  |                 | to use the full  |                  |
10082 |                  |                 | Jacobian         |                  |
10083 |                  |                 | strategy         |                  |
10084 +------------------+-----------------+------------------+------------------+
10085 | jit              | OT_BOOL         | Use just-in-time | casadi::Function |
10086 |                  |                 | compiler to      | Internal         |
10087 |                  |                 | speed up the     |                  |
10088 |                  |                 | evaluation       |                  |
10089 +------------------+-----------------+------------------+------------------+
10090 | jit_cleanup      | OT_BOOL         | Cleanup up the   | casadi::Function |
10091 |                  |                 | temporary source | Internal         |
10092 |                  |                 | file that jit    |                  |
10093 |                  |                 | creates.         |                  |
10094 |                  |                 | Default: true    |                  |
10095 +------------------+-----------------+------------------+------------------+
10096 | jit_name         | OT_STRING       | The file name    | casadi::Function |
10097 |                  |                 | used to write    | Internal         |
10098 |                  |                 | out code. The    |                  |
10099 |                  |                 | actual file      |                  |
10100 |                  |                 | names used       |                  |
10101 |                  |                 | depend on 'jit_t |                  |
10102 |                  |                 | emp_suffix' and  |                  |
10103 |                  |                 | include          |                  |
10104 |                  |                 | extensions.      |                  |
10105 |                  |                 | Default:         |                  |
10106 |                  |                 | 'jit_tmp'        |                  |
10107 +------------------+-----------------+------------------+------------------+
10108 | jit_options      | OT_DICT         | Options to be    | casadi::Function |
10109 |                  |                 | passed to the    | Internal         |
10110 |                  |                 | jit compiler.    |                  |
10111 +------------------+-----------------+------------------+------------------+
10112 | jit_serialize    | OT_STRING       | Specify          | casadi::Function |
10113 |                  |                 | behaviour when   | Internal         |
10114 |                  |                 | serializing a    |                  |
10115 |                  |                 | jitted function: |                  |
10116 |                  |                 | SOURCE|link|embe |                  |
10117 |                  |                 | d.               |                  |
10118 +------------------+-----------------+------------------+------------------+
10119 | jit_temp_suffix  | OT_BOOL         | Use a temporary  | casadi::Function |
10120 |                  |                 | (seemingly       | Internal         |
10121 |                  |                 | random) filename |                  |
10122 |                  |                 | suffix for       |                  |
10123 |                  |                 | generated code   |                  |
10124 |                  |                 | and libraries.   |                  |
10125 |                  |                 | This is desired  |                  |
10126 |                  |                 | for thread-      |                  |
10127 |                  |                 | safety. This     |                  |
10128 |                  |                 | behaviour may    |                  |
10129 |                  |                 | defeat caching   |                  |
10130 |                  |                 | compiler         |                  |
10131 |                  |                 | wrappers.        |                  |
10132 |                  |                 | Default: true    |                  |
10133 +------------------+-----------------+------------------+------------------+
10134 | max_num_dir      | OT_INT          | Specify the      | casadi::Function |
10135 |                  |                 | maximum number   | Internal         |
10136 |                  |                 | of directions    |                  |
10137 |                  |                 | for derivative   |                  |
10138 |                  |                 | functions.       |                  |
10139 |                  |                 | Overrules the    |                  |
10140 |                  |                 | builtin optimize |                  |
10141 |                  |                 | d_num_dir.       |                  |
10142 +------------------+-----------------+------------------+------------------+
10143 | never_inline     | OT_BOOL         | Forbid inlining. | casadi::Function |
10144 |                  |                 |                  | Internal         |
10145 +------------------+-----------------+------------------+------------------+
10146 | output_scheme    | OT_STRINGVECTOR | Deprecated       | casadi::Function |
10147 |                  |                 | option (ignored) | Internal         |
10148 +------------------+-----------------+------------------+------------------+
10149 | print_in         | OT_BOOL         | Print numerical  | casadi::Function |
10150 |                  |                 | values of inputs | Internal         |
10151 |                  |                 | [default: false] |                  |
10152 +------------------+-----------------+------------------+------------------+
10153 | print_out        | OT_BOOL         | Print numerical  | casadi::Function |
10154 |                  |                 | values of        | Internal         |
10155 |                  |                 | outputs          |                  |
10156 |                  |                 | [default: false] |                  |
10157 +------------------+-----------------+------------------+------------------+
10158 | print_time       | OT_BOOL         | print            | casadi::Function |
10159 |                  |                 | information      | Internal         |
10160 |                  |                 | about execution  |                  |
10161 |                  |                 | time. Implies    |                  |
10162 |                  |                 | record_time.     |                  |
10163 +------------------+-----------------+------------------+------------------+
10164 | record_time      | OT_BOOL         | record           | casadi::Function |
10165 |                  |                 | information      | Internal         |
10166 |                  |                 | about execution  |                  |
10167 |                  |                 | time, for        |                  |
10168 |                  |                 | retrieval with   |                  |
10169 |                  |                 | stats().         |                  |
10170 +------------------+-----------------+------------------+------------------+
10171 | regularity_check | OT_BOOL         | Throw exceptions | casadi::Function |
10172 |                  |                 | when NaN or Inf  | Internal         |
10173 |                  |                 | appears during   |                  |
10174 |                  |                 | evaluation       |                  |
10175 +------------------+-----------------+------------------+------------------+
10176 | reltol           | OT_DOUBLE       | Accuracy of      | casadi::CentralD |
10177 |                  |                 | function inputs  | iff              |
10178 |                  |                 | [default: query  |                  |
10179 |                  |                 | object]          |                  |
10180 +------------------+-----------------+------------------+------------------+
10181 | reverse_options  | OT_DICT         | Options to be    | casadi::Function |
10182 |                  |                 | passed to a      | Internal         |
10183 |                  |                 | reverse mode     |                  |
10184 |                  |                 | constructor      |                  |
10185 +------------------+-----------------+------------------+------------------+
10186 | second_order_ste | OT_DOUBLE       | Second order     | casadi::CentralD |
10187 | psize            |                 | perturbation     | iff              |
10188 |                  |                 | size [default:   |                  |
10189 |                  |                 | 1e-3]            |                  |
10190 +------------------+-----------------+------------------+------------------+
10191 | smoothing        | OT_DOUBLE       | Smoothing        | casadi::CentralD |
10192 |                  |                 | regularization   | iff              |
10193 |                  |                 | [default:        |                  |
10194 |                  |                 | machine          |                  |
10195 |                  |                 | precision]       |                  |
10196 +------------------+-----------------+------------------+------------------+
10197 | u_aim            | OT_DOUBLE       | Target ratio of  | casadi::CentralD |
10198 |                  |                 | roundoff error   | iff              |
10199 |                  |                 | to truncation    |                  |
10200 |                  |                 | error [default:  |                  |
10201 |                  |                 | 100.]            |                  |
10202 +------------------+-----------------+------------------+------------------+
10203 | user_data        | OT_VOIDPTR      | A user-defined   | casadi::Function |
10204 |                  |                 | field that can   | Internal         |
10205 |                  |                 | be used to       |                  |
10206 |                  |                 | identify the     |                  |
10207 |                  |                 | function or pass |                  |
10208 |                  |                 | additional       |                  |
10209 |                  |                 | information      |                  |
10210 +------------------+-----------------+------------------+------------------+
10211 | verbose          | OT_BOOL         | Verbose          | casadi::Function |
10212 |                  |                 | evaluation  for  | Internal         |
10213 |                  |                 | debugging        |                  |
10214 +------------------+-----------------+------------------+------------------+
10215 
10216 Diagrams
10217 --------
10218 
10219 
10220 
10221 C++ includes: finite_differences.hpp ";
10222 
10223 %feature("docstring")  casadi::FunctionInternal::call_gen(const MXVector
10224 &arg, MXVector &res, casadi_int npar, bool always_inline, bool never_inline)
10225 const  "
10226 
10227 [INTERNAL]   Call a function, overloaded.
10228 
10229 ";
10230 
10231 %feature("docstring")  casadi::FunctionInternal::call_gen(const std::vector<
10232 MatrixCommon > &arg, std::vector< MatrixCommon > &res, casadi_int npar, bool
10233 always_inline, bool never_inline) const  "
10234 
10235 [INTERNAL]   Call a function, overloaded.
10236 
10237 ";
10238 
10239 %feature("docstring")  casadi::FunctionInternal::size1_out(casadi_int ind)
10240 const  "
10241 
10242 [INTERNAL]  Input/output dimensions.
10243 
10244 ";
10245 
10246 %feature("docstring")  casadi::FunctionInternal::adjViaJac(casadi_int nadj)
10247 const  "
10248 
10249 [INTERNAL]  Calculate derivatives by multiplying the full Jacobian and
10250 multiplying.
10251 
10252 ";
10253 
10254 %feature("docstring")  casadi::FunctionInternal::reverse(casadi_int nadj)
10255 const  "
10256 
10257 [INTERNAL]  Return function that calculates adjoint derivatives
10258 reverse(nadj) returns a cached instance if available, and calls  Function
10259 get_reverse(casadi_int nadj) if no cached version is available.
10260 
10261 ";
10262 
10263 %feature("docstring")  casadi::FunctionInternal::wrap_as_needed(const Dict
10264 &opts) const  "
10265 
10266 [INTERNAL]  Wrap in an Function instance consisting of only one MX call.
10267 
10268 ";
10269 
10270 %feature("docstring")  casadi::FunctionInternal::jac() const  "
10271 
10272 [INTERNAL]  Return Jacobian of all input elements with respect to all output
10273 elements.
10274 
10275 ";
10276 
10277 %feature("docstring")  casadi::FunctionInternal::instruction_id(casadi_int
10278 k) const  "
10279 
10280 [INTERNAL]  Get an atomic operation operator index.
10281 
10282 ";
10283 
10284 %feature("docstring")  casadi::FiniteDiff::get_options() const  "
10285 
10286 [INTERNAL]  Options.
10287 
10288 ";
10289 
10290 %feature("docstring")  casadi::FunctionInternal::nz_out(const std::vector<
10291 DM > &res) const  "
10292 
10293 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
10294 
10295 ";
10296 
10297 %feature("docstring")  casadi::FunctionInternal::nz_out(const std::vector<
10298 double > &res) const  "
10299 
10300 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
10301 
10302 ";
10303 
10304 %feature("docstring")  casadi::FiniteDiff::codegen_body(CodeGenerator &g)
10305 const  "
10306 
10307 [INTERNAL]  Generate code for the body of the C function.
10308 
10309 ";
10310 
10311 %feature("docstring")  casadi::FunctionInternal::codegen_mem_type() const  "
10312 
10313 [INTERNAL]  Thread-local memory object type.
10314 
10315 ";
10316 
10317 %feature("docstring")  casadi::ProtoFunction::serialize_base_function()
10318 const  "
10319 
10320 [INTERNAL]  String used to identify the immediate FunctionInternal subclass.
10321 
10322 ";
10323 
10324 %feature("docstring")  casadi::FiniteDiff::get_default_in(casadi_int ind)
10325 const  "
10326 
10327 [INTERNAL]  Get default input value.
10328 
10329 ";
10330 
10331 %feature("docstring")  casadi::FunctionInternal::has_function(const
10332 std::string &fname) const  "
10333 
10334 [INTERNAL] ";
10335 
10336 %feature("docstring")  casadi::FunctionInternal::definition() const  "
10337 
10338 [INTERNAL]  Get function signature: name:(inputs)->(outputs)
10339 
10340 ";
10341 
10342 %feature("docstring")  casadi::FunctionInternal::is_diff_in(casadi_int i) "
10343 
10344 [INTERNAL] ";
10345 
10346 %feature("docstring")  casadi::FunctionInternal::alloc_res(size_t sz_res,
10347 bool persistent=false) "
10348 
10349 [INTERNAL]  Ensure required length of res field.
10350 
10351 ";
10352 
10353 
10354 // File: classcasadi_1_1ClangCompiler.xml
10355 %feature("docstring") casadi::ClangCompiler::ClangCompiler(const std::string
10356 &name) "
10357 
10358 [INTERNAL]  Constructor.
10359 
10360 ";
10361 
10362 %feature("docstring")  casadi::ImporterInternal::can_have_meta() const  "
10363 
10364 [INTERNAL]  Can meta information be read?
10365 
10366 ";
10367 
10368 %feature("docstring")  casadi::ImporterInternal::inlined(const std::string
10369 &symname) const  "
10370 
10371 [INTERNAL] ";
10372 
10373 %feature("docstring")  casadi::ClangCompiler::get_function(const std::string
10374 &symname)  "
10375 
10376 [INTERNAL]  Get a function pointer for numerical evaluation.
10377 
10378 ";
10379 
10380 %feature("docstring")  casadi::ImporterInternal::construct(const Dict &opts)
10381 "
10382 
10383 [INTERNAL]  Construct Prepares the function for evaluation.
10384 
10385 ";
10386 
10387 %feature("docstring")  casadi::ImporterInternal::finalize() "
10388 
10389 [INTERNAL] ";
10390 
10391 %feature("docstring")  casadi::ImporterInternal::read_external(const
10392 std::string &sym, bool inlined, std::istream &file, casadi_int &offset) "
10393 
10394 [INTERNAL]  Get an external function declaration.
10395 
10396 ";
10397 
10398 %feature("docstring")  casadi::ImporterInternal::disp(std::ostream &stream,
10399 bool more) const  "
10400 
10401 [INTERNAL]  Print.
10402 
10403 ";
10404 
10405 %feature("docstring")  casadi::ImporterInternal::library() const  "
10406 
10407 [INTERNAL]  Get library name.
10408 
10409 ";
10410 
10411 %feature("docstring") casadi::ClangCompiler "
10412 
10413 'clang' plugin for Importer
10414 
10415 Joris Gillis  Interface to the JIT compiler CLANG
10416 
10417 >List of available options
10418 
10419 +--------------+-----------------+-----------------------------------------+
10420 |      Id      |      Type       |               Description               |
10421 +==============+=================+=========================================+
10422 | flags        | OT_STRINGVECTOR | Compile flags for the JIT compiler.     |
10423 |              |                 | Default: None                           |
10424 +--------------+-----------------+-----------------------------------------+
10425 | include_path | OT_STRING       | Include paths for the JIT compiler. The |
10426 |              |                 | include directory shipped with CasADi   |
10427 |              |                 | will be automatically appended.         |
10428 +--------------+-----------------+-----------------------------------------+
10429 
10430 >List of available options
10431 
10432 +--------------+-----------------+--------------------+--------------------+
10433 |      Id      |      Type       |    Description     |      Used in       |
10434 +==============+=================+====================+====================+
10435 | flags        | OT_STRINGVECTOR | Compile flags for  | casadi::ClangCompi |
10436 |              |                 | the JIT compiler.  | ler                |
10437 |              |                 | Default: None      |                    |
10438 +--------------+-----------------+--------------------+--------------------+
10439 | include_path | OT_STRING       | Include paths for  | casadi::ClangCompi |
10440 |              |                 | the JIT compiler.  | ler                |
10441 |              |                 | The include        |                    |
10442 |              |                 | directory shipped  |                    |
10443 |              |                 | with CasADi will   |                    |
10444 |              |                 | be automatically   |                    |
10445 |              |                 | appended.          |                    |
10446 +--------------+-----------------+--------------------+--------------------+
10447 | verbose      | OT_BOOL         | Verbose evaluation | casadi::ImporterIn |
10448 |              |                 | for debugging      | ternal             |
10449 +--------------+-----------------+--------------------+--------------------+
10450 
10451 Diagrams
10452 --------
10453 
10454 
10455 
10456 C++ includes: clang_compiler.hpp ";
10457 
10458 %feature("docstring")  casadi::SharedObjectInternal::weak() "
10459 
10460 [INTERNAL]  Get a weak reference to the object.
10461 
10462 ";
10463 
10464 %feature("docstring") casadi::ClangCompiler::~ClangCompiler "
10465 
10466 [INTERNAL]  Destructor.
10467 
10468 ";
10469 
10470 %feature("docstring")  casadi::ClangCompiler::plugin_name() const  "
10471 
10472 [INTERNAL]  Get name of plugin.
10473 
10474 ";
10475 
10476 %feature("docstring")
10477 casadi::ImporterInternal::serialize_body(SerializingStream &s) const  "
10478 
10479 [INTERNAL] ";
10480 
10481 %feature("docstring")  casadi::ClangCompiler::get_options() const  "
10482 
10483 [INTERNAL]  Options.
10484 
10485 ";
10486 
10487 %feature("docstring")  casadi::ImporterInternal::read_meta(std::istream
10488 &file, casadi_int &offset) "
10489 
10490 [INTERNAL]  Get meta information.
10491 
10492 ";
10493 
10494 %feature("docstring")  casadi::ImporterInternal::to_text(const std::string
10495 &cmd, casadi_int ind=-1) const  "
10496 
10497 [INTERNAL]  Get entry as a text.
10498 
10499 ";
10500 
10501 %feature("docstring")  casadi::ClangCompiler::class_name() const  "
10502 
10503 [INTERNAL]  Get type name.
10504 
10505 ";
10506 
10507 %feature("docstring")
10508 casadi::ImporterInternal::serialize_type(SerializingStream &s) const  "
10509 
10510 [INTERNAL] ";
10511 
10512 %feature("docstring")  casadi::ImporterInternal::has_meta(const std::string
10513 &cmd, casadi_int ind=-1) const  "
10514 
10515 [INTERNAL]  Does an entry exist?
10516 
10517 ";
10518 
10519 %feature("docstring")  casadi::ClangCompiler::init(const Dict &opts)  "
10520 
10521 [INTERNAL]  Initialize.
10522 
10523 ";
10524 
10525 %feature("docstring")  casadi::ImporterInternal::serialize(SerializingStream
10526 &s) const  "
10527 
10528 [INTERNAL] ";
10529 
10530 %feature("docstring")  casadi::ImporterInternal::body(const std::string
10531 &symname) const  "
10532 
10533 [INTERNAL]  Get the function body, if inlined.
10534 
10535 ";
10536 
10537 %feature("docstring")  casadi::ImporterInternal::get_meta(const std::string
10538 &cmd, casadi_int ind=-1) const  "
10539 
10540 [INTERNAL]  Get entry as a text.
10541 
10542 ";
10543 
10544 %feature("docstring")  casadi::SharedObjectInternal::getCount() const  "
10545 
10546 [INTERNAL]  Get the reference count.
10547 
10548 ";
10549 
10550 %feature("docstring")  casadi::ImporterInternal::has_function(const
10551 std::string &symname) const  "
10552 
10553 [INTERNAL]  Get a function pointer for numerical evaluation.
10554 
10555 ";
10556 
10557 
10558 // File: classcasadi_1_1CodeGenerator.xml
10559 %feature("docstring")  casadi::CodeGenerator::add_include(const std::string
10560 &new_include, bool relative_path=false, const std::string
10561 &use_ifdef=std::string()) "
10562 
10563 Add an include file optionally using a relative path \"...\" instead of an
10564 absolute path <...>
10565 
10566 ";
10567 
10568 %feature("docstring") casadi::CodeGenerator "
10569 
10570 Helper class for C code generation.
10571 
10572 Joel Andersson
10573 
10574 C++ includes: code_generator.hpp ";
10575 
10576 %feature("docstring")  casadi::CodeGenerator::dump() "
10577 
10578 Generate a file, return code as string.
10579 
10580 ";
10581 
10582 %feature("docstring")  casadi::CodeGenerator::add(const Function &f, bool
10583 with_jac_sparsity=false) "
10584 
10585 Add a function (name generated)
10586 
10587 ";
10588 
10589 %feature("docstring") casadi::CodeGenerator::CodeGenerator(const std::string
10590 &name, const Dict &opts=Dict()) "
10591 
10592 Constructor.
10593 
10594 ";
10595 
10596 %feature("docstring")  casadi::CodeGenerator::generate(const std::string
10597 &prefix="") "
10598 
10599 Generate file(s) The \"prefix\" argument will be prepended to the generated
10600 files and may be a directory or a file prefix. returns the filename.
10601 
10602 ";
10603 
10604 
10605 // File: classcasadi_1_1Collocation.xml
10606 %feature("docstring")  casadi::Collocation::class_name() const  "
10607 
10608 [INTERNAL]  Readable name of the internal class.
10609 
10610 ";
10611 
10612 %feature("docstring")  casadi::FunctionInternal::nz_out(const std::vector<
10613 DM > &res) const  "
10614 
10615 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
10616 
10617 ";
10618 
10619 %feature("docstring")  casadi::FunctionInternal::nz_out(const std::vector<
10620 double > &res) const  "
10621 
10622 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
10623 
10624 ";
10625 
10626 %feature("docstring")  casadi::Integrator::sp_reverse(bvec_t **arg, bvec_t
10627 **res, casadi_int *iw, bvec_t *w, void *mem) const  "
10628 
10629 [INTERNAL]  Propagate sparsity backwards.
10630 
10631 ";
10632 
10633 %feature("docstring")  casadi::FunctionInternal::print_option(const
10634 std::string &name, std::ostream &stream) const  "
10635 
10636 [INTERNAL]  Print all information there is to know about a certain option.
10637 
10638 ";
10639 
10640 %feature("docstring")  casadi::FunctionInternal::convert_arg(const
10641 std::vector< M > &arg) const  "
10642 
10643 [INTERNAL]  Convert from/to input/output lists/map.
10644 
10645 ";
10646 
10647 %feature("docstring")  casadi::FunctionInternal::convert_arg(const std::map<
10648 std::string, M > &arg) const  "
10649 
10650 [INTERNAL]  Convert from/to input/output lists/map.
10651 
10652 ";
10653 
10654 %feature("docstring")  casadi::FunctionInternal::index_in(const std::string
10655 &name) const  "
10656 
10657 [INTERNAL]  Get input scheme index by name.
10658 
10659 ";
10660 
10661 %feature("docstring")  casadi::FunctionInternal::call_gen(const MXVector
10662 &arg, MXVector &res, casadi_int npar, bool always_inline, bool never_inline)
10663 const  "
10664 
10665 [INTERNAL]   Call a function, overloaded.
10666 
10667 ";
10668 
10669 %feature("docstring")  casadi::FunctionInternal::call_gen(const std::vector<
10670 MatrixCommon > &arg, std::vector< MatrixCommon > &res, casadi_int npar, bool
10671 always_inline, bool never_inline) const  "
10672 
10673 [INTERNAL]   Call a function, overloaded.
10674 
10675 ";
10676 
10677 %feature("docstring")  casadi::FunctionInternal::sz_work(size_t &sz_arg,
10678 size_t &sz_res, size_t &sz_iw, size_t &sz_w) const  "
10679 
10680 [INTERNAL]  Get number of temporary variables needed.
10681 
10682 ";
10683 
10684 %feature("docstring")
10685 casadi::FunctionInternal::getJacSparsityHierarchicalSymm(casadi_int iind,
10686 casadi_int oind) const  "
10687 
10688 [INTERNAL]  A flavor of getJacSparsity that does hierarchical block
10689 structure recognition for symmetric Jacobians
10690 
10691 ";
10692 
10693 %feature("docstring")  casadi::FunctionInternal::get_min_in(casadi_int ind)
10694 const  "
10695 
10696 [INTERNAL]  Get smallest input value.
10697 
10698 ";
10699 
10700 %feature("docstring")  casadi::ProtoFunction::print(const char *fmt,...)
10701 const  "
10702 
10703 [INTERNAL]  C-style formatted printing during evaluation.
10704 
10705 ";
10706 
10707 %feature("docstring")  casadi::FunctionInternal::project_res(const
10708 std::vector< M > &arg, casadi_int npar) const  "
10709 
10710 [INTERNAL]   Project sparsities.
10711 
10712 ";
10713 
10714 %feature("docstring")  casadi::SharedObjectInternal::weak() "
10715 
10716 [INTERNAL]  Get a weak reference to the object.
10717 
10718 ";
10719 
10720 %feature("docstring")  casadi::Integrator::serialize_type(SerializingStream
10721 &s) const  "
10722 
10723 [INTERNAL]  Serialize type information.
10724 
10725 ";
10726 
10727 %feature("docstring")  casadi::Integrator::sp_forward(const bvec_t **arg,
10728 bvec_t **res, casadi_int *iw, bvec_t *w, void *mem) const  "
10729 
10730 [INTERNAL]  Propagate sparsity forward.
10731 
10732 ";
10733 
10734 %feature("docstring")
10735 casadi::FunctionInternal::codegen_decref(CodeGenerator &g) const  "
10736 
10737 [INTERNAL]  Codegen decref for dependencies.
10738 
10739 ";
10740 
10741 %feature("docstring")
10742 casadi::FunctionInternal::codegen_init_mem(CodeGenerator &g) const  "
10743 
10744 [INTERNAL]  Codegen decref for init_mem.
10745 
10746 ";
10747 
10748 %feature("docstring")  casadi::FunctionInternal::nz_in(const std::vector< DM
10749 > &arg) const  "
10750 
10751 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
10752 
10753 ";
10754 
10755 %feature("docstring")  casadi::FunctionInternal::nz_in(const std::vector<
10756 double > &arg) const  "
10757 
10758 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
10759 
10760 ";
10761 
10762 %feature("docstring")  casadi::FunctionInternal::get_reltol() const  "
10763 
10764 [INTERNAL]  Get relative tolerance.
10765 
10766 ";
10767 
10768 %feature("docstring")  casadi::FunctionInternal::instruction_id(casadi_int
10769 k) const  "
10770 
10771 [INTERNAL]  Get an atomic operation operator index.
10772 
10773 ";
10774 
10775 %feature("docstring")  casadi::FunctionInternal::uses_output() const  "
10776 
10777 [INTERNAL]  Do the derivative functions need nondifferentiated outputs?
10778 
10779 ";
10780 
10781 %feature("docstring")  casadi::FunctionInternal::sz_arg() const  "
10782 
10783 [INTERNAL]  Get required length of arg field.
10784 
10785 ";
10786 
10787 %feature("docstring")  casadi::Integrator::has_forward(casadi_int nfwd)
10788 const  "
10789 
10790 [INTERNAL]  Generate a function that calculates nfwd forward derivatives.
10791 
10792 ";
10793 
10794 %feature("docstring") casadi::Collocation::Collocation(const std::string
10795 &name, const Function &dae) "
10796 
10797 [INTERNAL]  Constructor.
10798 
10799 ";
10800 
10801 %feature("docstring")  casadi::FunctionInternal::free_mx() const  "
10802 
10803 [INTERNAL]  Get free variables ( MX)
10804 
10805 ";
10806 
10807 %feature("docstring")  casadi::Integrator::get_sparsity_in(casadi_int i)  "
10808 
10809 [INTERNAL]  Sparsities of function inputs and outputs.
10810 
10811 ";
10812 
10813 %feature("docstring")  casadi::FunctionInternal::slice(const std::string
10814 &name, const std::vector< casadi_int > &order_in, const std::vector<
10815 casadi_int > &order_out, const Dict &opts) const  "
10816 
10817 [INTERNAL]  returns a new function with a selection of inputs/outputs of the
10818 original
10819 
10820 ";
10821 
10822 %feature("docstring")  casadi::FunctionInternal::eval_mx(const MXVector
10823 &arg, MXVector &res, bool always_inline, bool never_inline) const  "
10824 
10825 [INTERNAL]  Evaluate with symbolic matrices.
10826 
10827 ";
10828 
10829 %feature("docstring")  casadi::FunctionInternal::codegen_body(CodeGenerator
10830 &g) const  "
10831 
10832 [INTERNAL]  Generate code for the function body.
10833 
10834 ";
10835 
10836 %feature("docstring")  casadi::OracleFunction::set_function(const Function
10837 &fcn, const std::string &fname, bool jit=false) "
10838 
10839 [INTERNAL]  Register the function for evaluation and statistics gathering
10840 
10841 ";
10842 
10843 %feature("docstring")  casadi::OracleFunction::set_function(const Function
10844 &fcn) "
10845 
10846 [INTERNAL]  Register the function for evaluation and statistics gathering
10847 
10848 ";
10849 
10850 %feature("docstring")  casadi::FunctionInternal::size_out(casadi_int ind)
10851 const  "
10852 
10853 [INTERNAL]  Input/output dimensions.
10854 
10855 ";
10856 
10857 %feature("docstring")
10858 casadi::FunctionInternal::codegen_free_mem(CodeGenerator &g) const  "
10859 
10860 [INTERNAL]  Codegen for free_mem.
10861 
10862 ";
10863 
10864 %feature("docstring") casadi::Collocation::~Collocation "
10865 
10866 [INTERNAL]  Destructor.
10867 
10868 ";
10869 
10870 %feature("docstring")  casadi::Collocation::algebraic_state_init(const MX
10871 &x0, const MX &z0) const  "
10872 
10873 [INTERNAL] ";
10874 
10875 %feature("docstring")  casadi::FunctionInternal::self() const  "
10876 
10877 [INTERNAL]  Get a public class instance.
10878 
10879 ";
10880 
10881 %feature("docstring")  casadi::ProtoFunction::release(int mem) const  "
10882 
10883 [INTERNAL]  Release a memory object.
10884 
10885 ";
10886 
10887 %feature("docstring")  casadi::FunctionInternal::signature(const std::string
10888 &fname) const  "
10889 
10890 [INTERNAL]  Code generate the function.
10891 
10892 ";
10893 
10894 %feature("docstring")  casadi::FunctionInternal::generate_out(const
10895 std::string &fname, double **res) const  "
10896 
10897 [INTERNAL] ";
10898 
10899 %feature("docstring")  casadi::OracleFunction::oracle() const  "
10900 
10901 [INTERNAL]  Get oracle.
10902 
10903 ";
10904 
10905 %feature("docstring")  casadi::FunctionInternal::codegen_name(const
10906 CodeGenerator &g, bool ns=true) const  "
10907 
10908 [INTERNAL]  Get name in codegen.
10909 
10910 ";
10911 
10912 %feature("docstring")  casadi::OracleFunction::set_temp(void *mem, const
10913 double **arg, double **res, casadi_int *iw, double *w) const  "
10914 
10915 [INTERNAL]  Set the work vectors.
10916 
10917 ";
10918 
10919 %feature("docstring")
10920 casadi::FunctionInternal::getJacSparsityGen(casadi_int iind, casadi_int
10921 oind, bool symmetric, casadi_int gr_i=1, casadi_int gr_o=1) const  "
10922 
10923 [INTERNAL]  Get the sparsity pattern, forward mode.
10924 
10925 ";
10926 
10927 %feature("docstring")  casadi::FunctionInternal::mapsum_mx(const
10928 std::vector< MX > &arg, const std::string &parallelization) "
10929 
10930 [INTERNAL]  Parallel evaluation.
10931 
10932 ";
10933 
10934 %feature("docstring")  casadi::FunctionInternal::wrap_as_needed(const Dict
10935 &opts) const  "
10936 
10937 [INTERNAL]  Wrap in an Function instance consisting of only one MX call.
10938 
10939 ";
10940 
10941 %feature("docstring")  casadi::FunctionInternal::check_arg(const
10942 std::vector< M > &arg, casadi_int &npar) const  "
10943 
10944 [INTERNAL]  Check if input arguments have correct length and dimensions.
10945 
10946 Raises errors.
10947 
10948 Parameters:
10949 -----------
10950 
10951 npar[in]:  normal usage: 1, disallow pararallel calls: -1
10952 
10953 npar:  max number of horizontal repetitions across all arguments (or -1)
10954 
10955 ";
10956 
10957 %feature("docstring")  casadi::Collocation::plugin_name() const  "
10958 
10959 [INTERNAL] ";
10960 
10961 %feature("docstring")  casadi::ProtoFunction::format_time(char *buffer,
10962 double time) const  "
10963 
10964 [INTERNAL]  Format time in a fixed width 8 format.
10965 
10966 ";
10967 
10968 %feature("docstring")  casadi::FunctionInternal::print_options(std::ostream
10969 &stream) const  "
10970 
10971 [INTERNAL]  Print list of options.
10972 
10973 ";
10974 
10975 %feature("docstring")  casadi::FunctionInternal::index_out(const std::string
10976 &name) const  "
10977 
10978 [INTERNAL]  Get output scheme index by name.
10979 
10980 ";
10981 
10982 %feature("docstring")  casadi::ImplicitFixedStepIntegrator::getExplicitB()
10983 const  "
10984 
10985 [INTERNAL]  Get explicit dynamics (backward problem)
10986 
10987 ";
10988 
10989 %feature("docstring")  casadi::FunctionInternal::replace_res(const
10990 std::vector< M > &res, casadi_int npar) const  "
10991 
10992 [INTERNAL]  Replace 0-by-0 outputs.
10993 
10994 ";
10995 
10996 %feature("docstring")  casadi::FunctionInternal::replace_arg(const
10997 std::vector< M > &arg, casadi_int npar) const  "
10998 
10999 [INTERNAL]  Replace 0-by-0 inputs.
11000 
11001 ";
11002 
11003 %feature("docstring")  casadi::Collocation::setupFG()  "
11004 
11005 [INTERNAL]  Setup F and G.
11006 
11007 ";
11008 
11009 %feature("docstring")  casadi::FunctionInternal::get_free() const  "
11010 
11011 [INTERNAL]  Print free variables.
11012 
11013 ";
11014 
11015 %feature("docstring")  casadi::FunctionInternal::get_partition(casadi_int
11016 iind, casadi_int oind, Sparsity &D1, Sparsity &D2, bool compact, bool
11017 symmetric, bool allow_forward, bool allow_reverse) const  "
11018 
11019 [INTERNAL]  Get the unidirectional or bidirectional partition.
11020 
11021 ";
11022 
11023 %feature("docstring")  casadi::FunctionInternal::sz_w() const  "
11024 
11025 [INTERNAL]  Get required length of w field.
11026 
11027 ";
11028 
11029 %feature("docstring")  casadi::Integrator::print_stats(IntegratorMemory
11030 *mem) const  "
11031 
11032 [INTERNAL]  Print solver statistics.
11033 
11034 ";
11035 
11036 %feature("docstring")  casadi::OracleFunction::has_function(const
11037 std::string &fname) const  "
11038 
11039 [INTERNAL] ";
11040 
11041 %feature("docstring")  casadi::Integrator::eval(const double **arg, double
11042 **res, casadi_int *iw, double *w, void *mem) const  "
11043 
11044 [INTERNAL]  evaluate
11045 
11046 ";
11047 
11048 %feature("docstring")  casadi::Integrator::get_name_in(casadi_int i)  "
11049 
11050 [INTERNAL]  Names of function input and outputs.
11051 
11052 ";
11053 
11054 %feature("docstring")  casadi::Integrator::get_n_in()  "
11055 
11056 [INTERNAL]  Number of function inputs and outputs.
11057 
11058 ";
11059 
11060 %feature("docstring")
11061 casadi::FunctionInternal::instruction_output(casadi_int k) const  "
11062 
11063 [INTERNAL]  Get the (integer) output argument of an atomic operation.
11064 
11065 ";
11066 
11067 %feature("docstring")  casadi::FunctionInternal::eval_sx(const SXElem **arg,
11068 SXElem **res, casadi_int *iw, SXElem *w, void *mem) const  "
11069 
11070 [INTERNAL]  Evaluate with symbolic scalars.
11071 
11072 ";
11073 
11074 %feature("docstring")  casadi::FunctionInternal::which_depends(const
11075 std::string &s_in, const std::vector< std::string > &s_out, casadi_int
11076 order, bool tr=false) const  "
11077 
11078 [INTERNAL]  Which variables enter with some order.
11079 
11080 Parameters:
11081 -----------
11082 
11083 s_in:   Input name
11084 
11085 s_out:   Output name(s)
11086 
11087 order:  Only 1 (linear) and 2 (nonlinear) allowed
11088 
11089 tr:  Flip the relationship. Return which expressions contain the variables
11090 
11091 ";
11092 
11093 %feature("docstring")  casadi::FunctionInternal::call_forward(const
11094 std::vector< MX > &arg, const std::vector< MX > &res, const std::vector<
11095 std::vector< MX > > &fseed, std::vector< std::vector< MX > > &fsens, bool
11096 always_inline, bool never_inline) const  "
11097 
11098 [INTERNAL]  Forward mode AD, virtual functions overloaded in derived
11099 classes.
11100 
11101 ";
11102 
11103 %feature("docstring")  casadi::FunctionInternal::call_forward(const
11104 std::vector< SX > &arg, const std::vector< SX > &res, const std::vector<
11105 std::vector< SX > > &fseed, std::vector< std::vector< SX > > &fsens, bool
11106 always_inline, bool never_inline) const  "
11107 
11108 [INTERNAL]  Forward mode AD, virtual functions overloaded in derived
11109 classes.
11110 
11111 ";
11112 
11113 %feature("docstring")  casadi::FunctionInternal::jacobian_sparsity() const
11114 "
11115 
11116 [INTERNAL]  Get Jacobian sparsity.
11117 
11118 ";
11119 
11120 %feature("docstring")  casadi::FunctionInternal::fwd_seed(casadi_int nfwd)
11121 const  "
11122 
11123 [INTERNAL]  Symbolic expressions for the forward seeds.
11124 
11125 ";
11126 
11127 %feature("docstring")  casadi::FunctionInternal::is_a(const std::string
11128 &type, bool recursive) const  "
11129 
11130 [INTERNAL]  Check if the function is of a particular type.
11131 
11132 ";
11133 
11134 %feature("docstring")  casadi::FunctionInternal::generate_options(bool
11135 is_temp=false) const  "
11136 
11137 [INTERNAL]  Reconstruct options dict.
11138 
11139 ";
11140 
11141 %feature("docstring")  casadi::FixedStepIntegrator::create_advanced(const
11142 Dict &opts)  "
11143 
11144 [INTERNAL]  Helper for a more powerful 'integrator' factory
11145 
11146 ";
11147 
11148 %feature("docstring")  casadi::FunctionInternal::is_diff_in(casadi_int i) "
11149 
11150 [INTERNAL] ";
11151 
11152 %feature("docstring")
11153 casadi::FunctionInternal::codegen_sparsities(CodeGenerator &g) const  "
11154 
11155 [INTERNAL]  Codegen sparsities.
11156 
11157 ";
11158 
11159 %feature("docstring")  casadi::FunctionInternal::alloc_arg(size_t sz_arg,
11160 bool persistent=false) "
11161 
11162 [INTERNAL]  Ensure required length of arg field.
11163 
11164 ";
11165 
11166 %feature("docstring")  casadi::ProtoFunction::checkout() const  "
11167 
11168 [INTERNAL]  Checkout a memory object.
11169 
11170 ";
11171 
11172 %feature("docstring")  casadi::FunctionInternal::has_jac() const  "
11173 
11174 [INTERNAL]  Return Jacobian of all input elements with respect to all output
11175 elements.
11176 
11177 ";
11178 
11179 %feature("docstring")  casadi::OracleFunction::generate_dependencies(const
11180 std::string &fname, const Dict &opts) const  "
11181 
11182 [INTERNAL]  Export / Generate C code for the generated functions.
11183 
11184 ";
11185 
11186 %feature("docstring")  casadi::FunctionInternal::alloc_res(size_t sz_res,
11187 bool persistent=false) "
11188 
11189 [INTERNAL]  Ensure required length of res field.
11190 
11191 ";
11192 
11193 %feature("docstring")  casadi::ProtoFunction::serialize(SerializingStream
11194 &s) const  "
11195 
11196 [INTERNAL]  Serialize an object.
11197 
11198 ";
11199 
11200 %feature("docstring")  casadi::FunctionInternal::disp(std::ostream &stream,
11201 bool more) const  "
11202 
11203 [INTERNAL]  Display object.
11204 
11205 ";
11206 
11207 %feature("docstring")  casadi::FunctionInternal::project_arg(const
11208 std::vector< M > &arg, casadi_int npar) const  "
11209 
11210 [INTERNAL]   Project sparsities.
11211 
11212 ";
11213 
11214 %feature("docstring")  casadi::OracleFunction::expand() "
11215 
11216 [INTERNAL] ";
11217 
11218 %feature("docstring")  casadi::FunctionInternal::eval_dm(const std::vector<
11219 DM > &arg) const  "
11220 
11221 [INTERNAL]  Evaluate with DM matrices.
11222 
11223 ";
11224 
11225 %feature("docstring")  casadi::SharedObjectInternal::getCount() const  "
11226 
11227 [INTERNAL]  Get the reference count.
11228 
11229 ";
11230 
11231 %feature("docstring")  casadi::Integrator::x() const  "
11232 
11233 [INTERNAL] ";
11234 
11235 %feature("docstring")
11236 casadi::FunctionInternal::jacobian_sparsity_filter(const Sparsity &sp) const
11237 "
11238 
11239 [INTERNAL]  Filter out nonzeros in the full sparsity jacobian according to
11240 is_diff_in/out.
11241 
11242 ";
11243 
11244 %feature("docstring")  casadi::FunctionInternal::factory(const std::string
11245 &name, const std::vector< std::string > &s_in, const std::vector<
11246 std::string > &s_out, const Function::AuxOut &aux, const Dict &opts) const
11247 "
11248 
11249 [INTERNAL] ";
11250 
11251 %feature("docstring")  casadi::Integrator::has_sprev() const  "
11252 
11253 [INTERNAL]  Is the class able to propagate seeds through the algorithm?
11254 
11255 ";
11256 
11257 %feature("docstring")  casadi::FunctionInternal::get_max_in(casadi_int ind)
11258 const  "
11259 
11260 [INTERNAL]  Get largest input value.
11261 
11262 ";
11263 
11264 %feature("docstring")  casadi::FunctionInternal::incache(const std::string
11265 &fname, Function &f, const std::string &suffix="") const  "
11266 
11267 [INTERNAL]  Get function in cache.
11268 
11269 ";
11270 
11271 %feature("docstring")  casadi::Collocation::serialize_body(SerializingStream
11272 &s) const  "
11273 
11274 [INTERNAL]  Serialize an object without type information.
11275 
11276 ";
11277 
11278 %feature("docstring")  casadi::FunctionInternal::size2_out(casadi_int ind)
11279 const  "
11280 
11281 [INTERNAL]  Input/output dimensions.
11282 
11283 ";
11284 
11285 %feature("docstring")  casadi::FixedStepIntegrator::advance(IntegratorMemory
11286 *mem, double t, double *x, double *z, double *q) const  "
11287 
11288 [INTERNAL]  Advance solution in time.
11289 
11290 ";
11291 
11292 %feature("docstring")  casadi::Integrator::has_reverse(casadi_int nadj)
11293 const  "
11294 
11295 [INTERNAL]  Generate a function that calculates nadj adjoint derivatives.
11296 
11297 ";
11298 
11299 %feature("docstring")  casadi::FunctionInternal::call(const std::vector< M >
11300 &arg, std::vector< M > &res, bool always_inline, bool never_inline) const  "
11301 
11302 [INTERNAL]   Call a function, templated.
11303 
11304 ";
11305 
11306 %feature("docstring")  casadi::FunctionInternal::definition() const  "
11307 
11308 [INTERNAL]  Get function signature: name:(inputs)->(outputs)
11309 
11310 ";
11311 
11312 %feature("docstring")  casadi::FunctionInternal::has_eval_dm() const  "
11313 
11314 [INTERNAL]  Evaluate with DM matrices.
11315 
11316 ";
11317 
11318 %feature("docstring")  casadi::FunctionInternal::free_sx() const  "
11319 
11320 [INTERNAL]  Get free variables (SX)
11321 
11322 ";
11323 
11324 %feature("docstring")  casadi::Integrator::getDerivativeOptions(bool fwd)
11325 const  "
11326 
11327 [INTERNAL]  Set solver specific options to generated augmented integrators.
11328 
11329 ";
11330 
11331 %feature("docstring")  casadi::Integrator::aug_adj(casadi_int nadj) const  "
11332 
11333 [INTERNAL]  Generate a augmented DAE system with nadj adjoint sensitivities.
11334 
11335 ";
11336 
11337 %feature("docstring")  casadi::FunctionInternal::getAdaptorSolverName()
11338 const  "
11339 
11340 [INTERNAL]  Obtain solver name from Adaptor.
11341 
11342 ";
11343 
11344 %feature("docstring")  casadi::FunctionInternal::jac() const  "
11345 
11346 [INTERNAL]  Return Jacobian of all input elements with respect to all output
11347 elements.
11348 
11349 ";
11350 
11351 %feature("docstring")  casadi::FunctionInternal::alloc_iw(size_t sz_iw, bool
11352 persistent=false) "
11353 
11354 [INTERNAL]  Ensure required length of iw field.
11355 
11356 ";
11357 
11358 %feature("docstring")  casadi::FunctionInternal::sz_iw() const  "
11359 
11360 [INTERNAL]  Get required length of iw field.
11361 
11362 ";
11363 
11364 %feature("docstring")  casadi::FunctionInternal::jacobian() const  "
11365 
11366 [INTERNAL]  Return Jacobian of all input elements with respect to all output
11367 elements.
11368 
11369 ";
11370 
11371 %feature("docstring")  casadi::FunctionInternal::dm_in(casadi_int ind) const
11372 "
11373 
11374 [INTERNAL]  Get function input(s) and output(s)
11375 
11376 ";
11377 
11378 %feature("docstring")  casadi::FunctionInternal::dm_in() const  "
11379 
11380 [INTERNAL]  Get function input(s) and output(s)
11381 
11382 ";
11383 
11384 %feature("docstring")  casadi::ProtoFunction::print_time(const std::map<
11385 std::string, FStats > &fstats) const  "
11386 
11387 [INTERNAL]  Print timing statistics.
11388 
11389 ";
11390 
11391 %feature("docstring")  casadi::FunctionInternal::n_instructions() const  "
11392 
11393 [INTERNAL]  Get the number of atomic operations.
11394 
11395 ";
11396 
11397 %feature("docstring")  casadi::FunctionInternal::get_default_in(casadi_int
11398 ind) const  "
11399 
11400 [INTERNAL]  Get default input value.
11401 
11402 ";
11403 
11404 %feature("docstring")
11405 casadi::FunctionInternal::print_dimensions(std::ostream &stream) const  "
11406 
11407 [INTERNAL]  Print dimensions of inputs and outputs.
11408 
11409 ";
11410 
11411 %feature("docstring")  casadi::OracleFunction::calc_function(OracleMemory
11412 *m, const std::string &fcn, const double *const *arg=nullptr) const  "
11413 
11414 [INTERNAL] ";
11415 
11416 %feature("docstring")  casadi::FunctionInternal::has_jacobian_sparsity()
11417 const  "
11418 
11419 [INTERNAL]  Get Jacobian sparsity.
11420 
11421 ";
11422 
11423 %feature("docstring")  casadi::Integrator::get_forward(casadi_int nfwd,
11424 const std::string &name, const std::vector< std::string > &inames, const
11425 std::vector< std::string > &onames, const Dict &opts) const  "
11426 
11427 [INTERNAL]  Generate a function that calculates nfwd forward derivatives.
11428 
11429 ";
11430 
11431 %feature("docstring")  casadi::FunctionInternal::mx_out(casadi_int ind)
11432 const  "
11433 
11434 [INTERNAL]  Get function input(s) and output(s)
11435 
11436 ";
11437 
11438 %feature("docstring")  casadi::FunctionInternal::mx_out() const  "
11439 
11440 [INTERNAL]  Get function input(s) and output(s)
11441 
11442 ";
11443 
11444 %feature("docstring")
11445 casadi::FunctionInternal::codegen_incref(CodeGenerator &g) const  "
11446 
11447 [INTERNAL]  Codegen incref for dependencies.
11448 
11449 ";
11450 
11451 %feature("docstring")  casadi::FunctionInternal::all_scalar() const  "
11452 
11453 [INTERNAL]  Are all inputs and outputs scalar.
11454 
11455 ";
11456 
11457 %feature("docstring")  casadi::FunctionInternal::generate_lifted(Function
11458 &vdef_fcn, Function &vinit_fcn) const  "
11459 
11460 [INTERNAL]  Extract the functions needed for the Lifted Newton method.
11461 
11462 ";
11463 
11464 %feature("docstring")  casadi::FunctionInternal::matching_arg(const
11465 std::vector< M > &arg, casadi_int &npar) const  "
11466 
11467 [INTERNAL]  Check if input arguments that needs to be replaced.
11468 
11469 Raises errors
11470 
11471 Parameters:
11472 -----------
11473 
11474 npar[in]:  normal usage: 1, disallow pararallel calls: -1
11475 
11476 npar:  max number of horizontal repetitions across all arguments (or -1)
11477 
11478 ";
11479 
11480 %feature("docstring")  casadi::FunctionInternal::has_derivative() const  "
11481 
11482 [INTERNAL]  Can derivatives be calculated in any way?
11483 
11484 ";
11485 
11486 %feature("docstring")  casadi::Integrator::sp_jac_dae() "
11487 
11488 [INTERNAL]  Create sparsity pattern of the extended Jacobian (forward
11489 problem)
11490 
11491 ";
11492 
11493 %feature("docstring")  casadi::ProtoFunction::clear_mem() "
11494 
11495 [INTERNAL]  Clear all memory (called from destructor)
11496 
11497 ";
11498 
11499 %feature("docstring")  casadi::FunctionInternal::sparsity_in(casadi_int ind)
11500 const  "
11501 
11502 [INTERNAL]  Input/output sparsity.
11503 
11504 ";
11505 
11506 %feature("docstring")  casadi::FunctionInternal::is_diff_out(casadi_int i) "
11507 
11508 [INTERNAL] ";
11509 
11510 %feature("docstring")  casadi::Integrator::serialize_base_function() const
11511 "
11512 
11513 [INTERNAL]  String used to identify the immediate FunctionInternal subclass.
11514 
11515 ";
11516 
11517 %feature("docstring")  casadi::FunctionInternal::get_jac(const std::string
11518 &name, const std::vector< std::string > &inames, const std::vector<
11519 std::string > &onames, const Dict &opts) const  "
11520 
11521 [INTERNAL]  Return Jacobian of all input elements with respect to all output
11522 elements.
11523 
11524 ";
11525 
11526 %feature("docstring")  casadi::FunctionInternal::mx_in(casadi_int ind) const
11527 "
11528 
11529 [INTERNAL]  Get function input(s) and output(s)
11530 
11531 ";
11532 
11533 %feature("docstring")  casadi::FunctionInternal::mx_in() const  "
11534 
11535 [INTERNAL]  Get function input(s) and output(s)
11536 
11537 ";
11538 
11539 %feature("docstring")  casadi::Integrator::z() const  "
11540 
11541 [INTERNAL] ";
11542 
11543 %feature("docstring")  casadi::FixedStepIntegrator::free_mem(void *mem)
11544 const  "
11545 
11546 [INTERNAL]  Free memory block.
11547 
11548 ";
11549 
11550 %feature("docstring")  casadi::FunctionInternal::reverse(casadi_int nadj)
11551 const  "
11552 
11553 [INTERNAL]  Return function that calculates adjoint derivatives
11554 reverse(nadj) returns a cached instance if available, and calls  Function
11555 get_reverse(casadi_int nadj) if no cached version is available.
11556 
11557 ";
11558 
11559 %feature("docstring")  casadi::FixedStepIntegrator::alloc_mem() const  "
11560 
11561 [INTERNAL]  Create memory block.
11562 
11563 ";
11564 
11565 %feature("docstring")  casadi::Integrator::p() const  "
11566 
11567 [INTERNAL] ";
11568 
11569 %feature("docstring")  casadi::Integrator::q() const  "
11570 
11571 [INTERNAL] ";
11572 
11573 %feature("docstring")  casadi::Integrator::t() const  "
11574 
11575 [INTERNAL] ";
11576 
11577 %feature("docstring")  casadi::FunctionInternal::has_free() const  "
11578 
11579 [INTERNAL]  Does the function have free variables.
11580 
11581 ";
11582 
11583 %feature("docstring")  casadi::FunctionInternal::set_work(void *mem, const
11584 double **&arg, double **&res, casadi_int *&iw, double *&w) const  "
11585 
11586 [INTERNAL]  Set the (persistent) work vectors.
11587 
11588 ";
11589 
11590 %feature("docstring")  casadi::FunctionInternal::nnz_in() const  "
11591 
11592 [INTERNAL]  Number of input/output nonzeros.
11593 
11594 ";
11595 
11596 %feature("docstring")  casadi::FunctionInternal::nnz_in(casadi_int ind)
11597 const  "
11598 
11599 [INTERNAL]  Number of input/output nonzeros.
11600 
11601 ";
11602 
11603 %feature("docstring")  casadi::FunctionInternal::disp_more(std::ostream
11604 &stream) const  "
11605 
11606 [INTERNAL]  Print more.
11607 
11608 ";
11609 
11610 %feature("docstring")  casadi::Integrator::get_sparsity_out(casadi_int i)  "
11611 
11612 [INTERNAL]  Sparsities of function inputs and outputs.
11613 
11614 ";
11615 
11616 %feature("docstring")
11617 casadi::FunctionInternal::getJacSparsityHierarchical(casadi_int iind,
11618 casadi_int oind) const  "
11619 
11620 [INTERNAL]  A flavor of getJacSparsity that does hierarchical block
11621 structure recognition.
11622 
11623 ";
11624 
11625 %feature("docstring")  casadi::FunctionInternal::tocache(const Function &f,
11626 const std::string &suffix="") const  "
11627 
11628 [INTERNAL]  Save function to cache.
11629 
11630 ";
11631 
11632 %feature("docstring")  casadi::FixedStepIntegrator::init_mem(void *mem)
11633 const  "
11634 
11635 [INTERNAL]  Initalize memory block.
11636 
11637 ";
11638 
11639 %feature("docstring")  casadi::Integrator::setStopTime(IntegratorMemory
11640 *mem, double tf) const  "
11641 
11642 [INTERNAL]  Set stop time for the integration.
11643 
11644 ";
11645 
11646 %feature("docstring")  casadi::FunctionInternal::matching_res(const
11647 std::vector< M > &arg, casadi_int &npar) const  "
11648 
11649 [INTERNAL]  Check if output arguments that needs to be replaced.
11650 
11651 Raises errors
11652 
11653 Parameters:
11654 -----------
11655 
11656 npar[in]:  normal usage: 1, disallow pararallel calls: -1
11657 
11658 npar:  max number of horizontal repetitions across all arguments (or -1)
11659 
11660 ";
11661 
11662 %feature("docstring")  casadi::FunctionInternal::dm_out(casadi_int ind)
11663 const  "
11664 
11665 [INTERNAL]  Get function input(s) and output(s)
11666 
11667 ";
11668 
11669 %feature("docstring")  casadi::FunctionInternal::dm_out() const  "
11670 
11671 [INTERNAL]  Get function input(s) and output(s)
11672 
11673 ";
11674 
11675 %feature("docstring")  casadi::FunctionInternal::setup(void *mem, const
11676 double **arg, double **res, casadi_int *iw, double *w) const  "
11677 
11678 [INTERNAL]  Set the (persistent and temporary) work vectors.
11679 
11680 ";
11681 
11682 %feature("docstring")  casadi::FunctionInternal::call_reverse(const
11683 std::vector< MX > &arg, const std::vector< MX > &res, const std::vector<
11684 std::vector< MX > > &aseed, std::vector< std::vector< MX > > &asens, bool
11685 always_inline, bool never_inline) const  "
11686 
11687 [INTERNAL]  Reverse mode, virtual functions overloaded in derived classes.
11688 
11689 ";
11690 
11691 %feature("docstring")  casadi::FunctionInternal::call_reverse(const
11692 std::vector< SX > &arg, const std::vector< SX > &res, const std::vector<
11693 std::vector< SX > > &aseed, std::vector< std::vector< SX > > &asens, bool
11694 always_inline, bool never_inline) const  "
11695 
11696 [INTERNAL]  Reverse mode, virtual functions overloaded in derived classes.
11697 
11698 ";
11699 
11700 %feature("docstring")  casadi::FunctionInternal::adjViaJac(casadi_int nadj)
11701 const  "
11702 
11703 [INTERNAL]  Calculate derivatives by multiplying the full Jacobian and
11704 multiplying.
11705 
11706 ";
11707 
11708 %feature("docstring") casadi::Collocation "
11709 
11710 'collocation' plugin for Integrator
11711 
11712 Fixed-step implicit Runge-Kutta integrator ODE/DAE integrator based on
11713 collocation schemes
11714 
11715 The method is still under development
11716 
11717 >List of available options
11718 
11719 +---------------------------+-----------------+----------------------------+
11720 |            Id             |      Type       |        Description         |
11721 +===========================+=================+============================+
11722 | augmented_options         | OT_DICT         | Options to be passed down  |
11723 |                           |                 | to the augmented           |
11724 |                           |                 | integrator, if one is      |
11725 |                           |                 | constructed.               |
11726 +---------------------------+-----------------+----------------------------+
11727 | collocation_scheme        | OT_STRING       | Collocation scheme:        |
11728 |                           |                 | radau|legendre             |
11729 +---------------------------+-----------------+----------------------------+
11730 | expand                    | OT_BOOL         | Replace MX with SX         |
11731 |                           |                 | expressions in problem     |
11732 |                           |                 | formulation [false]        |
11733 +---------------------------+-----------------+----------------------------+
11734 | grid                      | OT_DOUBLEVECTOR | Time grid                  |
11735 +---------------------------+-----------------+----------------------------+
11736 | interpolation_order       | OT_INT          | Order of the interpolating |
11737 |                           |                 | polynomials                |
11738 +---------------------------+-----------------+----------------------------+
11739 | number_of_finite_elements | OT_INT          | Number of finite elements  |
11740 +---------------------------+-----------------+----------------------------+
11741 | output_t0                 | OT_BOOL         | Output the state at the    |
11742 |                           |                 | initial time               |
11743 +---------------------------+-----------------+----------------------------+
11744 | print_stats               | OT_BOOL         | Print out statistics after |
11745 |                           |                 | integration                |
11746 +---------------------------+-----------------+----------------------------+
11747 | rootfinder                | OT_STRING       | An implicit function       |
11748 |                           |                 | solver                     |
11749 +---------------------------+-----------------+----------------------------+
11750 | rootfinder_options        | OT_DICT         | Options to be passed to    |
11751 |                           |                 | the NLP Solver             |
11752 +---------------------------+-----------------+----------------------------+
11753 | simplify                  | OT_BOOL         | Implement as MX  Function  |
11754 |                           |                 | (codegeneratable/serializa |
11755 |                           |                 | ble) default: false        |
11756 +---------------------------+-----------------+----------------------------+
11757 | simplify_options          | OT_DICT         | Any options to pass to     |
11758 |                           |                 | simplified form Function   |
11759 |                           |                 | constructor                |
11760 +---------------------------+-----------------+----------------------------+
11761 | t0                        | OT_DOUBLE       | Beginning of the time      |
11762 |                           |                 | horizon                    |
11763 +---------------------------+-----------------+----------------------------+
11764 | tf                        | OT_DOUBLE       | End of the time horizon    |
11765 +---------------------------+-----------------+----------------------------+
11766 
11767 Joel Andersson
11768 
11769 >List of available options
11770 
11771 +------------------+-----------------+------------------+------------------+
11772 |        Id        |      Type       |   Description    |     Used in      |
11773 +==================+=================+==================+==================+
11774 | augmented_option | OT_DICT         | Options to be    | casadi::Implicit |
11775 | s                |                 | passed down to   | FixedStepIntegra |
11776 |                  |                 | the augmented    | tor              |
11777 |                  |                 | integrator, if   |                  |
11778 |                  |                 | one is           |                  |
11779 |                  |                 | constructed.     |                  |
11780 +------------------+-----------------+------------------+------------------+
11781 | collocation_sche | OT_STRING       | Collocation      | casadi::Collocat |
11782 | me               |                 | scheme:          | ion              |
11783 |                  |                 | radau|legendre   |                  |
11784 +------------------+-----------------+------------------+------------------+
11785 | expand           | OT_BOOL         | Replace MX with  | casadi::Implicit |
11786 |                  |                 | SX expressions   | FixedStepIntegra |
11787 |                  |                 | in problem       | tor              |
11788 |                  |                 | formulation      |                  |
11789 |                  |                 | [false]          |                  |
11790 +------------------+-----------------+------------------+------------------+
11791 | grid             | OT_DOUBLEVECTOR | Time grid        | casadi::Implicit |
11792 |                  |                 |                  | FixedStepIntegra |
11793 |                  |                 |                  | tor              |
11794 +------------------+-----------------+------------------+------------------+
11795 | interpolation_or | OT_INT          | Order of the     | casadi::Collocat |
11796 | der              |                 | interpolating    | ion              |
11797 |                  |                 | polynomials      |                  |
11798 +------------------+-----------------+------------------+------------------+
11799 | number_of_finite | OT_INT          | Number of finite | casadi::Implicit |
11800 | _elements        |                 | elements         | FixedStepIntegra |
11801 |                  |                 |                  | tor              |
11802 +------------------+-----------------+------------------+------------------+
11803 | output_t0        | OT_BOOL         | Output the state | casadi::Implicit |
11804 |                  |                 | at the initial   | FixedStepIntegra |
11805 |                  |                 | time             | tor              |
11806 +------------------+-----------------+------------------+------------------+
11807 | print_stats      | OT_BOOL         | Print out        | casadi::Implicit |
11808 |                  |                 | statistics after | FixedStepIntegra |
11809 |                  |                 | integration      | tor              |
11810 +------------------+-----------------+------------------+------------------+
11811 | rootfinder       | OT_STRING       | An implicit      | casadi::Implicit |
11812 |                  |                 | function solver  | FixedStepIntegra |
11813 |                  |                 |                  | tor              |
11814 +------------------+-----------------+------------------+------------------+
11815 | rootfinder_optio | OT_DICT         | Options to be    | casadi::Implicit |
11816 | ns               |                 | passed to the    | FixedStepIntegra |
11817 |                  |                 | NLP Solver       | tor              |
11818 +------------------+-----------------+------------------+------------------+
11819 | simplify         | OT_BOOL         | Implement as MX  | casadi::Implicit |
11820 |                  |                 | Function (codege | FixedStepIntegra |
11821 |                  |                 | neratable/serial | tor              |
11822 |                  |                 | izable) default: |                  |
11823 |                  |                 | false            |                  |
11824 +------------------+-----------------+------------------+------------------+
11825 | simplify_options | OT_DICT         | Any options to   | casadi::Implicit |
11826 |                  |                 | pass to          | FixedStepIntegra |
11827 |                  |                 | simplified form  | tor              |
11828 |                  |                 | Function         |                  |
11829 |                  |                 | constructor      |                  |
11830 +------------------+-----------------+------------------+------------------+
11831 | t0               | OT_DOUBLE       | Beginning of the | casadi::Implicit |
11832 |                  |                 | time horizon     | FixedStepIntegra |
11833 |                  |                 |                  | tor              |
11834 +------------------+-----------------+------------------+------------------+
11835 | tf               | OT_DOUBLE       | End of the time  | casadi::Implicit |
11836 |                  |                 | horizon          | FixedStepIntegra |
11837 |                  |                 |                  | tor              |
11838 +------------------+-----------------+------------------+------------------+
11839 
11840 Diagrams
11841 --------
11842 
11843 
11844 
11845 C++ includes: collocation.hpp ";
11846 
11847 %feature("docstring")  casadi::FunctionInternal::instructions_sx() const  "
11848 
11849 [INTERNAL]  get SX expression associated with instructions
11850 
11851 ";
11852 
11853 %feature("docstring")  casadi::Integrator::rx() const  "
11854 
11855 [INTERNAL] ";
11856 
11857 %feature("docstring")  casadi::Integrator::rz() const  "
11858 
11859 [INTERNAL] ";
11860 
11861 %feature("docstring")  casadi::Integrator::get_reverse(casadi_int nadj,
11862 const std::string &name, const std::vector< std::string > &inames, const
11863 std::vector< std::string > &onames, const Dict &opts) const  "
11864 
11865 [INTERNAL]  Generate a function that calculates nadj adjoint derivatives.
11866 
11867 ";
11868 
11869 %feature("docstring")  casadi::Integrator::rq() const  "
11870 
11871 [INTERNAL] ";
11872 
11873 %feature("docstring")  casadi::Integrator::rp() const  "
11874 
11875 [INTERNAL] ";
11876 
11877 %feature("docstring")  casadi::FunctionInternal::sparsity_jac(casadi_int
11878 iind, casadi_int oind, bool compact, bool symmetric) const  "
11879 
11880 [INTERNAL]  Get, if necessary generate, the sparsity of a Jacobian block.
11881 
11882 ";
11883 
11884 %feature("docstring")  casadi::FunctionInternal::getJacSparsity(casadi_int
11885 iind, casadi_int oind, bool symmetric) const  "
11886 
11887 [INTERNAL]  Generate the sparsity of a Jacobian block.
11888 
11889 ";
11890 
11891 %feature("docstring")  casadi::FunctionInternal::alloc(const Function &f,
11892 bool persistent=false) "
11893 
11894 [INTERNAL]  Ensure work vectors long enough to evaluate function.
11895 
11896 ";
11897 
11898 %feature("docstring")  casadi::Integrator::sp_jac_rdae() "
11899 
11900 [INTERNAL]  Create sparsity pattern of the extended Jacobian (backward
11901 problem)
11902 
11903 ";
11904 
11905 %feature("docstring")  casadi::FunctionInternal::sp_weight() const  "
11906 
11907 [INTERNAL]  Weighting factor for chosing forward/reverse mode, sparsity
11908 propagation.
11909 
11910 ";
11911 
11912 %feature("docstring")  casadi::OracleFunction::create_function(const
11913 std::string &fname, const std::vector< std::string > &s_in, const
11914 std::vector< std::string > &s_out, const Function::AuxOut
11915 &aux=Function::AuxOut()) "
11916 
11917 [INTERNAL]  Create an oracle function
11918 
11919 ";
11920 
11921 %feature("docstring")  casadi::FunctionInternal::codegen_meta(CodeGenerator
11922 &g) const  "
11923 
11924 [INTERNAL]  Generate meta-information allowing a user to evaluate a
11925 generated function.
11926 
11927 ";
11928 
11929 %feature("docstring")  casadi::OracleFunction::get_stats(void *mem) const  "
11930 
11931 [INTERNAL]  Get all statistics.
11932 
11933 ";
11934 
11935 %feature("docstring")  casadi::FunctionInternal::get_abstol() const  "
11936 
11937 [INTERNAL]  Get absolute tolerance.
11938 
11939 ";
11940 
11941 %feature("docstring")  casadi::FunctionInternal::ad_weight() const  "
11942 
11943 [INTERNAL]  Weighting factor for chosing forward/reverse mode.
11944 
11945 ";
11946 
11947 %feature("docstring")
11948 casadi::FunctionInternal::codegen_alloc_mem(CodeGenerator &g) const  "
11949 
11950 [INTERNAL]  Codegen decref for alloc_mem.
11951 
11952 ";
11953 
11954 %feature("docstring")  casadi::OracleFunction::get_function() const  "
11955 
11956 [INTERNAL]  Get list of dependency functions -1 Indicates irregularity.
11957 
11958 ";
11959 
11960 %feature("docstring")  casadi::OracleFunction::get_function(const
11961 std::string &name) const  "
11962 
11963 [INTERNAL] ";
11964 
11965 %feature("docstring")  casadi::FunctionInternal::size1_in(casadi_int ind)
11966 const  "
11967 
11968 [INTERNAL]  Input/output dimensions.
11969 
11970 ";
11971 
11972 %feature("docstring")  casadi::Collocation::algebraic_state_output(const MX
11973 &Z) const  "
11974 
11975 [INTERNAL] ";
11976 
11977 %feature("docstring")  casadi::FunctionInternal::numel_in() const  "
11978 
11979 [INTERNAL]  Number of input/output elements.
11980 
11981 ";
11982 
11983 %feature("docstring")  casadi::FunctionInternal::numel_in(casadi_int ind)
11984 const  "
11985 
11986 [INTERNAL]  Number of input/output elements.
11987 
11988 ";
11989 
11990 %feature("docstring")  casadi::FunctionInternal::sx_out(casadi_int ind)
11991 const  "
11992 
11993 [INTERNAL]  Get function input(s) and output(s)
11994 
11995 ";
11996 
11997 %feature("docstring")  casadi::FunctionInternal::sx_out() const  "
11998 
11999 [INTERNAL]  Get function input(s) and output(s)
12000 
12001 ";
12002 
12003 %feature("docstring")  casadi::FunctionInternal::check_res(const
12004 std::vector< M > &res, casadi_int &npar) const  "
12005 
12006 [INTERNAL]  Check if output arguments have correct length and dimensions.
12007 
12008 Raises errors.
12009 
12010 Parameters:
12011 -----------
12012 
12013 npar[in]:  normal usage: 1, disallow pararallel calls: -1
12014 
12015 npar:  max number of horizontal repetitions across all arguments (or -1)
12016 
12017 ";
12018 
12019 %feature("docstring")
12020 casadi::FunctionInternal::instruction_constant(casadi_int k) const  "
12021 
12022 [INTERNAL]  Get the floating point output argument of an atomic operation.
12023 
12024 ";
12025 
12026 %feature("docstring")  casadi::ImplicitFixedStepIntegrator::getExplicit()
12027 const  "
12028 
12029 [INTERNAL]  Get explicit dynamics.
12030 
12031 ";
12032 
12033 %feature("docstring")  casadi::FunctionInternal::codegen_mem_type() const  "
12034 
12035 [INTERNAL]  Thread-local memory object type.
12036 
12037 ";
12038 
12039 %feature("docstring")  casadi::FunctionInternal::sx_in(casadi_int ind) const
12040 "
12041 
12042 [INTERNAL]  Get function input(s) and output(s)
12043 
12044 ";
12045 
12046 %feature("docstring")  casadi::FunctionInternal::sx_in() const  "
12047 
12048 [INTERNAL]  Get function input(s) and output(s)
12049 
12050 ";
12051 
12052 %feature("docstring")  casadi::FunctionInternal::symbolic_output(const
12053 std::vector< MX > &arg) const  "
12054 
12055 [INTERNAL]  Get a vector of symbolic variables corresponding to the outputs.
12056 
12057 ";
12058 
12059 %feature("docstring")  casadi::ProtoFunction::sprint(char *buf, size_t
12060 buf_sz, const char *fmt,...) const  "
12061 
12062 [INTERNAL]  C-style formatted printing to string.
12063 
12064 ";
12065 
12066 %feature("docstring")  casadi::Collocation::init(const Dict &opts)  "
12067 
12068 [INTERNAL]  Initialize stage.
12069 
12070 ";
12071 
12072 %feature("docstring")  casadi::FunctionInternal::eval_gen(const double
12073 **arg, double **res, casadi_int *iw, double *w, void *mem) const  "
12074 
12075 [INTERNAL]  Evaluate numerically.
12076 
12077 ";
12078 
12079 %feature("docstring")  casadi::FunctionInternal::eval_gen(const SXElem
12080 **arg, SXElem **res, casadi_int *iw, SXElem *w, void *mem) const  "
12081 
12082 [INTERNAL]  Evaluate a function, overloaded.
12083 
12084 ";
12085 
12086 %feature("docstring")  casadi::FunctionInternal::eval_gen(const bvec_t
12087 **arg, bvec_t **res, casadi_int *iw, bvec_t *w, void *mem) const  "
12088 
12089 [INTERNAL]  Evaluate a function, overloaded.
12090 
12091 ";
12092 
12093 %feature("docstring")  casadi::FunctionInternal::replace_aseed(const
12094 std::vector< std::vector< M >> &aseed, casadi_int npar) const  "
12095 
12096 [INTERNAL]  Replace 0-by-0 reverse seeds.
12097 
12098 ";
12099 
12100 %feature("docstring")  casadi::FunctionInternal::replace_aseed(const
12101 std::vector< std::vector< M > > &aseed, casadi_int npar) const  "
12102 
12103 [INTERNAL] ";
12104 
12105 %feature("docstring")  casadi::FunctionInternal::symbolicAdjSeed(casadi_int
12106 nadj, const std::vector< MatType > &v) const  "
12107 
12108 [INTERNAL]  Symbolic expressions for the adjoint seeds.
12109 
12110 ";
12111 
12112 %feature("docstring")  casadi::OracleFunction::jit_dependencies(const
12113 std::string &fname)  "
12114 
12115 [INTERNAL]  JIT for dependencies.
12116 
12117 ";
12118 
12119 %feature("docstring")
12120 casadi::FunctionInternal::instruction_input(casadi_int k) const  "
12121 
12122 [INTERNAL]  Get the (integer) input arguments of an atomic operation.
12123 
12124 ";
12125 
12126 %feature("docstring")  casadi::OracleFunction::finalize()  "
12127 
12128 [INTERNAL]  Finalize initialization.
12129 
12130 ";
12131 
12132 %feature("docstring")  casadi::Collocation::resetB(IntegratorMemory *mem,
12133 double t, const double *rx, const double *rz, const double *rp) const  "
12134 
12135 [INTERNAL]  Reset the backward problem and take time to tf.
12136 
12137 ";
12138 
12139 %feature("docstring")  casadi::Integrator::get_n_out()  "
12140 
12141 [INTERNAL]  Number of function inputs and outputs.
12142 
12143 ";
12144 
12145 %feature("docstring")  casadi::FunctionInternal::codegen_mem(CodeGenerator
12146 &g, const std::string &index="mem") const  "
12147 
12148 [INTERNAL]  Get thread-local memory object.
12149 
12150 ";
12151 
12152 %feature("docstring")  casadi::FunctionInternal::numel_out(casadi_int ind)
12153 const  "
12154 
12155 [INTERNAL]  Number of input/output elements.
12156 
12157 ";
12158 
12159 %feature("docstring")  casadi::FunctionInternal::numel_out() const  "
12160 
12161 [INTERNAL]  Number of input/output elements.
12162 
12163 ";
12164 
12165 %feature("docstring")  casadi::FunctionInternal::info() const  "
12166 
12167 [INTERNAL]  Obtain information about function
12168 
12169 ";
12170 
12171 %feature("docstring")  casadi::FunctionInternal::get_jacobian(const
12172 std::string &name, const std::vector< std::string > &inames, const
12173 std::vector< std::string > &onames, const Dict &opts) const  "
12174 
12175 [INTERNAL]  Return Jacobian of all input elements with respect to all output
12176 elements.
12177 
12178 ";
12179 
12180 %feature("docstring")  casadi::OracleFunction::monitored(const std::string
12181 &name) const  "
12182 
12183 [INTERNAL] ";
12184 
12185 %feature("docstring")  casadi::FunctionInternal::nnz_out() const  "
12186 
12187 [INTERNAL]  Number of input/output nonzeros.
12188 
12189 ";
12190 
12191 %feature("docstring")  casadi::FunctionInternal::nnz_out(casadi_int ind)
12192 const  "
12193 
12194 [INTERNAL]  Number of input/output nonzeros.
12195 
12196 ";
12197 
12198 %feature("docstring")  casadi::FunctionInternal::size_in(casadi_int ind)
12199 const  "
12200 
12201 [INTERNAL]  Input/output dimensions.
12202 
12203 ";
12204 
12205 %feature("docstring")  casadi::FunctionInternal::get_jacobian_sparsity()
12206 const  "
12207 
12208 [INTERNAL]  Get Jacobian sparsity.
12209 
12210 ";
12211 
12212 %feature("docstring")  casadi::FunctionInternal::has_jacobian() const  "
12213 
12214 [INTERNAL]  Return Jacobian of all input elements with respect to all output
12215 elements.
12216 
12217 ";
12218 
12219 %feature("docstring")  casadi::Integrator::aug_fwd(casadi_int nfwd) const  "
12220 
12221 [INTERNAL]  Generate a augmented DAE system with nfwd forward sensitivities.
12222 
12223 ";
12224 
12225 %feature("docstring")  casadi::FunctionInternal::instruction_MX(casadi_int
12226 k) const  "
12227 
12228 [INTERNAL]  get MX expression associated with instruction
12229 
12230 ";
12231 
12232 %feature("docstring")  casadi::FunctionInternal::wrap() const  "
12233 
12234 [INTERNAL]  Wrap in an Function instance consisting of only one MX call.
12235 
12236 ";
12237 
12238 %feature("docstring")  casadi::FunctionInternal::n_nodes() const  "
12239 
12240 [INTERNAL]  Number of nodes in the algorithm.
12241 
12242 ";
12243 
12244 %feature("docstring")  casadi::ProtoFunction::construct(const Dict &opts) "
12245 
12246 [INTERNAL]  Construct Prepares the function for evaluation.
12247 
12248 ";
12249 
12250 %feature("docstring")  casadi::FunctionInternal::replace_fseed(const
12251 std::vector< std::vector< M >> &fseed, casadi_int npar) const  "
12252 
12253 [INTERNAL]  Replace 0-by-0 forward seeds.
12254 
12255 ";
12256 
12257 %feature("docstring")  casadi::FunctionInternal::replace_fseed(const
12258 std::vector< std::vector< M > > &fseed, casadi_int npar) const  "
12259 
12260 [INTERNAL] ";
12261 
12262 %feature("docstring")  casadi::FunctionInternal::forward(casadi_int nfwd)
12263 const  "
12264 
12265 [INTERNAL]  Return function that calculates forward derivatives
12266 forward(nfwd) returns a cached instance if available, and calls  Function
12267 get_forward(casadi_int nfwd) if no cached version is available.
12268 
12269 ";
12270 
12271 %feature("docstring")  casadi::FunctionInternal::export_code(const
12272 std::string &lang, std::ostream &stream, const Dict &options) const  "
12273 
12274 [INTERNAL]  Export function in a specific language.
12275 
12276 ";
12277 
12278 %feature("docstring")  casadi::FunctionInternal::fwdViaJac(casadi_int nfwd)
12279 const  "
12280 
12281 [INTERNAL]  Calculate derivatives by multiplying the full Jacobian and
12282 multiplying.
12283 
12284 ";
12285 
12286 %feature("docstring")  casadi::FunctionInternal::sparsity_out(casadi_int
12287 ind) const  "
12288 
12289 [INTERNAL]  Input/output sparsity.
12290 
12291 ";
12292 
12293 %feature("docstring")  casadi::FunctionInternal::has_codegen() const  "
12294 
12295 [INTERNAL]  Is codegen supported?
12296 
12297 ";
12298 
12299 %feature("docstring")  casadi::FunctionInternal::size1_out(casadi_int ind)
12300 const  "
12301 
12302 [INTERNAL]  Input/output dimensions.
12303 
12304 ";
12305 
12306 %feature("docstring")  casadi::FunctionInternal::generate_in(const
12307 std::string &fname, const double **arg) const  "
12308 
12309 [INTERNAL]  Export an input file that can be passed to generate C code with
12310 a main.
12311 
12312 ";
12313 
12314 %feature("docstring")  casadi::FunctionInternal::check_mat(const Sparsity
12315 &arg, const Sparsity &inp, casadi_int &npar) "
12316 
12317 [INTERNAL]  Helper function
12318 
12319 Parameters:
12320 -----------
12321 
12322 npar[in]:  normal usage: 1, disallow pararallel calls: -1
12323 
12324 npar[out]:  required number of parallel calls (or -1)
12325 
12326 ";
12327 
12328 %feature("docstring")  casadi::FunctionInternal::size2_in(casadi_int ind)
12329 const  "
12330 
12331 [INTERNAL]  Input/output dimensions.
12332 
12333 ";
12334 
12335 %feature("docstring")  casadi::FunctionInternal::codegen(CodeGenerator &g,
12336 const std::string &fname) const  "
12337 
12338 [INTERNAL]  Generate code the function.
12339 
12340 ";
12341 
12342 %feature("docstring")  casadi::FunctionInternal::convert_res(const
12343 std::vector< M > &res) const  "
12344 
12345 [INTERNAL]  Convert from/to input/output lists/map.
12346 
12347 ";
12348 
12349 %feature("docstring")  casadi::FunctionInternal::convert_res(const std::map<
12350 std::string, M > &res) const  "
12351 
12352 [INTERNAL]  Convert from/to input/output lists/map.
12353 
12354 ";
12355 
12356 %feature("docstring")  casadi::Integrator::has_spfwd() const  "
12357 
12358 [INTERNAL]  Is the class able to propagate seeds through the algorithm?
12359 
12360 ";
12361 
12362 %feature("docstring")  casadi::Collocation::get_options() const  "
12363 
12364 [INTERNAL]  Options.
12365 
12366 ";
12367 
12368 %feature("docstring")
12369 casadi::FunctionInternal::codegen_declarations(CodeGenerator &g) const  "
12370 
12371 [INTERNAL]  Generate code for the declarations of the C function.
12372 
12373 ";
12374 
12375 %feature("docstring")  casadi::FixedStepIntegrator::retreat(IntegratorMemory
12376 *mem, double t, double *rx, double *rz, double *rq) const  "
12377 
12378 [INTERNAL]  Retreat solution in time.
12379 
12380 ";
12381 
12382 %feature("docstring")  casadi::Integrator::get_name_out(casadi_int i)  "
12383 
12384 [INTERNAL]  Names of function input and outputs.
12385 
12386 ";
12387 
12388 %feature("docstring")  casadi::FunctionInternal::alloc_w(size_t sz_w, bool
12389 persistent=false) "
12390 
12391 [INTERNAL]  Ensure required length of w field.
12392 
12393 ";
12394 
12395 %feature("docstring")  casadi::Collocation::reset(IntegratorMemory *mem,
12396 double t, const double *x, const double *z, const double *p) const  "
12397 
12398 [INTERNAL]  Reset the forward problem.
12399 
12400 ";
12401 
12402 %feature("docstring")  casadi::ProtoFunction::memory(int ind) const  "
12403 
12404 [INTERNAL]  Memory objects.
12405 
12406 ";
12407 
12408 %feature("docstring")  casadi::FunctionInternal::sz_res() const  "
12409 
12410 [INTERNAL]  Get required length of res field.
12411 
12412 ";
12413 
12414 %feature("docstring")  casadi::FunctionInternal::map(casadi_int n, const
12415 std::string &parallelization) const  "
12416 
12417 [INTERNAL]  Generate/retrieve cached serial map.
12418 
12419 ";
12420 
12421 
12422 // File: classcasadi_1_1Concat.xml
12423 
12424 
12425 // File: classcasadi_1_1Conic.xml
12426 %feature("docstring")  casadi::FunctionInternal::replace_fseed(const
12427 std::vector< std::vector< M >> &fseed, casadi_int npar) const  "
12428 
12429 [INTERNAL]  Replace 0-by-0 forward seeds.
12430 
12431 ";
12432 
12433 %feature("docstring")  casadi::FunctionInternal::replace_fseed(const
12434 std::vector< std::vector< M > > &fseed, casadi_int npar) const  "
12435 
12436 [INTERNAL] ";
12437 
12438 %feature("docstring")  casadi::FunctionInternal::call_forward(const
12439 std::vector< MX > &arg, const std::vector< MX > &res, const std::vector<
12440 std::vector< MX > > &fseed, std::vector< std::vector< MX > > &fsens, bool
12441 always_inline, bool never_inline) const  "
12442 
12443 [INTERNAL]  Forward mode AD, virtual functions overloaded in derived
12444 classes.
12445 
12446 ";
12447 
12448 %feature("docstring")  casadi::FunctionInternal::call_forward(const
12449 std::vector< SX > &arg, const std::vector< SX > &res, const std::vector<
12450 std::vector< SX > > &fseed, std::vector< std::vector< SX > > &fsens, bool
12451 always_inline, bool never_inline) const  "
12452 
12453 [INTERNAL]  Forward mode AD, virtual functions overloaded in derived
12454 classes.
12455 
12456 ";
12457 
12458 %feature("docstring")  casadi::FunctionInternal::call(const std::vector< M >
12459 &arg, std::vector< M > &res, bool always_inline, bool never_inline) const  "
12460 
12461 [INTERNAL]   Call a function, templated.
12462 
12463 ";
12464 
12465 %feature("docstring")  casadi::ProtoFunction::sprint(char *buf, size_t
12466 buf_sz, const char *fmt,...) const  "
12467 
12468 [INTERNAL]  C-style formatted printing to string.
12469 
12470 ";
12471 
12472 %feature("docstring")  casadi::FunctionInternal::has_jac() const  "
12473 
12474 [INTERNAL]  Return Jacobian of all input elements with respect to all output
12475 elements.
12476 
12477 ";
12478 
12479 %feature("docstring")  casadi::FunctionInternal::eval_dm(const std::vector<
12480 DM > &arg) const  "
12481 
12482 [INTERNAL]  Evaluate with DM matrices.
12483 
12484 ";
12485 
12486 %feature("docstring")  casadi::FunctionInternal::ad_weight() const  "
12487 
12488 [INTERNAL]  Weighting factor for chosing forward/reverse mode.
12489 
12490 ";
12491 
12492 %feature("docstring")  casadi::FunctionInternal::index_in(const std::string
12493 &name) const  "
12494 
12495 [INTERNAL]  Get input scheme index by name.
12496 
12497 ";
12498 
12499 %feature("docstring")  casadi::FunctionInternal::self() const  "
12500 
12501 [INTERNAL]  Get a public class instance.
12502 
12503 ";
12504 
12505 %feature("docstring")  casadi::FunctionInternal::has_function(const
12506 std::string &fname) const  "
12507 
12508 [INTERNAL] ";
12509 
12510 %feature("docstring")
12511 casadi::FunctionInternal::jacobian_sparsity_filter(const Sparsity &sp) const
12512 "
12513 
12514 [INTERNAL]  Filter out nonzeros in the full sparsity jacobian according to
12515 is_diff_in/out.
12516 
12517 ";
12518 
12519 %feature("docstring")  casadi::FunctionInternal::get_free() const  "
12520 
12521 [INTERNAL]  Print free variables.
12522 
12523 ";
12524 
12525 %feature("docstring")  casadi::Conic::init(const Dict &opts)  "
12526 
12527 [INTERNAL]  Initialize Initialize and make the object ready for setting
12528 arguments and evaluation. This method is typically called after setting
12529 options but before evaluating. If passed to another class (in the
12530 constructor), this class should invoke this function when initialized.
12531 
12532 ";
12533 
12534 %feature("docstring")  casadi::FunctionInternal::nz_in(const std::vector< DM
12535 > &arg) const  "
12536 
12537 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
12538 
12539 ";
12540 
12541 %feature("docstring")  casadi::FunctionInternal::nz_in(const std::vector<
12542 double > &arg) const  "
12543 
12544 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
12545 
12546 ";
12547 
12548 %feature("docstring")  casadi::FunctionInternal::symbolic_output(const
12549 std::vector< MX > &arg) const  "
12550 
12551 [INTERNAL]  Get a vector of symbolic variables corresponding to the outputs.
12552 
12553 ";
12554 
12555 %feature("docstring")  casadi::FunctionInternal::sparsity_out(casadi_int
12556 ind) const  "
12557 
12558 [INTERNAL]  Input/output sparsity.
12559 
12560 ";
12561 
12562 %feature("docstring")  casadi::FunctionInternal::numel_out(casadi_int ind)
12563 const  "
12564 
12565 [INTERNAL]  Number of input/output elements.
12566 
12567 ";
12568 
12569 %feature("docstring")  casadi::FunctionInternal::numel_out() const  "
12570 
12571 [INTERNAL]  Number of input/output elements.
12572 
12573 ";
12574 
12575 %feature("docstring")  casadi::FunctionInternal::which_depends(const
12576 std::string &s_in, const std::vector< std::string > &s_out, casadi_int
12577 order, bool tr=false) const  "
12578 
12579 [INTERNAL]  Which variables enter with some order.
12580 
12581 Parameters:
12582 -----------
12583 
12584 s_in:   Input name
12585 
12586 s_out:   Output name(s)
12587 
12588 order:  Only 1 (linear) and 2 (nonlinear) allowed
12589 
12590 tr:  Flip the relationship. Return which expressions contain the variables
12591 
12592 ";
12593 
12594 %feature("docstring")  casadi::FunctionInternal::dm_out(casadi_int ind)
12595 const  "
12596 
12597 [INTERNAL]  Get function input(s) and output(s)
12598 
12599 ";
12600 
12601 %feature("docstring")  casadi::FunctionInternal::dm_out() const  "
12602 
12603 [INTERNAL]  Get function input(s) and output(s)
12604 
12605 ";
12606 
12607 %feature("docstring")  casadi::FunctionInternal::has_jacobian() const  "
12608 
12609 [INTERNAL]  Return Jacobian of all input elements with respect to all output
12610 elements.
12611 
12612 ";
12613 
12614 %feature("docstring")  casadi::FunctionInternal::alloc_res(size_t sz_res,
12615 bool persistent=false) "
12616 
12617 [INTERNAL]  Ensure required length of res field.
12618 
12619 ";
12620 
12621 %feature("docstring")  casadi::FunctionInternal::instruction_MX(casadi_int
12622 k) const  "
12623 
12624 [INTERNAL]  get MX expression associated with instruction
12625 
12626 ";
12627 
12628 %feature("docstring")  casadi::Conic::generateNativeCode(std::ostream &file)
12629 const  "
12630 
12631 [INTERNAL]  Generate native code in the interfaced language for debugging
12632 
12633 ";
12634 
12635 %feature("docstring")
12636 casadi::FunctionInternal::codegen_decref(CodeGenerator &g) const  "
12637 
12638 [INTERNAL]  Codegen decref for dependencies.
12639 
12640 ";
12641 
12642 %feature("docstring")  casadi::FunctionInternal::n_instructions() const  "
12643 
12644 [INTERNAL]  Get the number of atomic operations.
12645 
12646 ";
12647 
12648 %feature("docstring")  casadi::FunctionInternal::size1_out(casadi_int ind)
12649 const  "
12650 
12651 [INTERNAL]  Input/output dimensions.
12652 
12653 ";
12654 
12655 %feature("docstring")  casadi::FunctionInternal::nnz_in() const  "
12656 
12657 [INTERNAL]  Number of input/output nonzeros.
12658 
12659 ";
12660 
12661 %feature("docstring")  casadi::FunctionInternal::nnz_in(casadi_int ind)
12662 const  "
12663 
12664 [INTERNAL]  Number of input/output nonzeros.
12665 
12666 ";
12667 
12668 %feature("docstring")  casadi::FunctionInternal::call_reverse(const
12669 std::vector< MX > &arg, const std::vector< MX > &res, const std::vector<
12670 std::vector< MX > > &aseed, std::vector< std::vector< MX > > &asens, bool
12671 always_inline, bool never_inline) const  "
12672 
12673 [INTERNAL]  Reverse mode, virtual functions overloaded in derived classes.
12674 
12675 ";
12676 
12677 %feature("docstring")  casadi::FunctionInternal::call_reverse(const
12678 std::vector< SX > &arg, const std::vector< SX > &res, const std::vector<
12679 std::vector< SX > > &aseed, std::vector< std::vector< SX > > &asens, bool
12680 always_inline, bool never_inline) const  "
12681 
12682 [INTERNAL]  Reverse mode, virtual functions overloaded in derived classes.
12683 
12684 ";
12685 
12686 %feature("docstring")  casadi::FunctionInternal::print_option(const
12687 std::string &name, std::ostream &stream) const  "
12688 
12689 [INTERNAL]  Print all information there is to know about a certain option.
12690 
12691 ";
12692 
12693 %feature("docstring")  casadi::Conic::eval(const double **arg, double **res,
12694 casadi_int *iw, double *w, void *mem) const final "
12695 
12696 [INTERNAL]   Solve the QP.
12697 
12698 ";
12699 
12700 %feature("docstring")  casadi::FunctionInternal::nz_out(const std::vector<
12701 DM > &res) const  "
12702 
12703 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
12704 
12705 ";
12706 
12707 %feature("docstring")  casadi::FunctionInternal::nz_out(const std::vector<
12708 double > &res) const  "
12709 
12710 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
12711 
12712 ";
12713 
12714 %feature("docstring")  casadi::FunctionInternal::get_reverse(casadi_int
12715 nadj, const std::string &name, const std::vector< std::string > &inames,
12716 const std::vector< std::string > &onames, const Dict &opts) const  "
12717 
12718 [INTERNAL]  Return function that calculates adjoint derivatives
12719 reverse(nadj) returns a cached instance if available, and calls  Function
12720 get_reverse(casadi_int nadj) if no cached version is available.
12721 
12722 ";
12723 
12724 %feature("docstring")  casadi::FunctionInternal::finalize()  "
12725 
12726 [INTERNAL]  Finalize the object creation.
12727 
12728 ";
12729 
12730 %feature("docstring")  casadi::FunctionInternal::get_abstol() const  "
12731 
12732 [INTERNAL]  Get absolute tolerance.
12733 
12734 ";
12735 
12736 %feature("docstring")  casadi::FunctionInternal::get_partition(casadi_int
12737 iind, casadi_int oind, Sparsity &D1, Sparsity &D2, bool compact, bool
12738 symmetric, bool allow_forward, bool allow_reverse) const  "
12739 
12740 [INTERNAL]  Get the unidirectional or bidirectional partition.
12741 
12742 ";
12743 
12744 %feature("docstring")  casadi::FunctionInternal::convert_arg(const
12745 std::vector< M > &arg) const  "
12746 
12747 [INTERNAL]  Convert from/to input/output lists/map.
12748 
12749 ";
12750 
12751 %feature("docstring")  casadi::FunctionInternal::convert_arg(const std::map<
12752 std::string, M > &arg) const  "
12753 
12754 [INTERNAL]  Convert from/to input/output lists/map.
12755 
12756 ";
12757 
12758 %feature("docstring")  casadi::FunctionInternal::convert_res(const
12759 std::vector< M > &res) const  "
12760 
12761 [INTERNAL]  Convert from/to input/output lists/map.
12762 
12763 ";
12764 
12765 %feature("docstring")  casadi::FunctionInternal::convert_res(const std::map<
12766 std::string, M > &res) const  "
12767 
12768 [INTERNAL]  Convert from/to input/output lists/map.
12769 
12770 ";
12771 
12772 %feature("docstring")  casadi::FunctionInternal::sparsity_jac(casadi_int
12773 iind, casadi_int oind, bool compact, bool symmetric) const  "
12774 
12775 [INTERNAL]  Get, if necessary generate, the sparsity of a Jacobian block.
12776 
12777 ";
12778 
12779 %feature("docstring")  casadi::FunctionInternal::disp_more(std::ostream
12780 &stream) const  "
12781 
12782 [INTERNAL]  Print more.
12783 
12784 ";
12785 
12786 %feature("docstring")  casadi::FunctionInternal::generate_options(bool
12787 is_temp=false) const  "
12788 
12789 [INTERNAL]  Reconstruct options dict.
12790 
12791 ";
12792 
12793 %feature("docstring")  casadi::FunctionInternal::slice(const std::string
12794 &name, const std::vector< casadi_int > &order_in, const std::vector<
12795 casadi_int > &order_out, const Dict &opts) const  "
12796 
12797 [INTERNAL]  returns a new function with a selection of inputs/outputs of the
12798 original
12799 
12800 ";
12801 
12802 %feature("docstring")  casadi::FunctionInternal::eval_sx(const SXElem **arg,
12803 SXElem **res, casadi_int *iw, SXElem *w, void *mem) const  "
12804 
12805 [INTERNAL]  Evaluate with symbolic scalars.
12806 
12807 ";
12808 
12809 %feature("docstring")  casadi::FunctionInternal::sz_arg() const  "
12810 
12811 [INTERNAL]  Get required length of arg field.
12812 
12813 ";
12814 
12815 %feature("docstring")  casadi::FunctionInternal::eval_gen(const double
12816 **arg, double **res, casadi_int *iw, double *w, void *mem) const  "
12817 
12818 [INTERNAL]  Evaluate numerically.
12819 
12820 ";
12821 
12822 %feature("docstring")  casadi::FunctionInternal::eval_gen(const SXElem
12823 **arg, SXElem **res, casadi_int *iw, SXElem *w, void *mem) const  "
12824 
12825 [INTERNAL]  Evaluate a function, overloaded.
12826 
12827 ";
12828 
12829 %feature("docstring")  casadi::FunctionInternal::eval_gen(const bvec_t
12830 **arg, bvec_t **res, casadi_int *iw, bvec_t *w, void *mem) const  "
12831 
12832 [INTERNAL]  Evaluate a function, overloaded.
12833 
12834 ";
12835 
12836 %feature("docstring")  casadi::FunctionInternal::adjViaJac(casadi_int nadj)
12837 const  "
12838 
12839 [INTERNAL]  Calculate derivatives by multiplying the full Jacobian and
12840 multiplying.
12841 
12842 ";
12843 
12844 %feature("docstring")  casadi::FunctionInternal::free_sx() const  "
12845 
12846 [INTERNAL]  Get free variables (SX)
12847 
12848 ";
12849 
12850 %feature("docstring")  casadi::ProtoFunction::clear_mem() "
12851 
12852 [INTERNAL]  Clear all memory (called from destructor)
12853 
12854 ";
12855 
12856 %feature("docstring")  casadi::FunctionInternal::alloc_iw(size_t sz_iw, bool
12857 persistent=false) "
12858 
12859 [INTERNAL]  Ensure required length of iw field.
12860 
12861 ";
12862 
12863 %feature("docstring")  casadi::FunctionInternal::alloc_w(size_t sz_w, bool
12864 persistent=false) "
12865 
12866 [INTERNAL]  Ensure required length of w field.
12867 
12868 ";
12869 
12870 %feature("docstring")  casadi::Conic::get_n_out()  "
12871 
12872 [INTERNAL]  Number of function inputs and outputs.
12873 
12874 ";
12875 
12876 %feature("docstring")  casadi::FunctionInternal::get_jacobian(const
12877 std::string &name, const std::vector< std::string > &inames, const
12878 std::vector< std::string > &onames, const Dict &opts) const  "
12879 
12880 [INTERNAL]  Return Jacobian of all input elements with respect to all output
12881 elements.
12882 
12883 ";
12884 
12885 %feature("docstring")  casadi::FunctionInternal::get_forward(casadi_int
12886 nfwd, const std::string &name, const std::vector< std::string > &inames,
12887 const std::vector< std::string > &onames, const Dict &opts) const  "
12888 
12889 [INTERNAL]  Return function that calculates forward derivatives
12890 forward(nfwd) returns a cached instance if available, and calls  Function
12891 get_forward(casadi_int nfwd) if no cached version is available.
12892 
12893 ";
12894 
12895 %feature("docstring")  casadi::FunctionInternal::get_min_in(casadi_int ind)
12896 const  "
12897 
12898 [INTERNAL]  Get smallest input value.
12899 
12900 ";
12901 
12902 %feature("docstring")  casadi::FunctionInternal::get_jac(const std::string
12903 &name, const std::vector< std::string > &inames, const std::vector<
12904 std::string > &onames, const Dict &opts) const  "
12905 
12906 [INTERNAL]  Return Jacobian of all input elements with respect to all output
12907 elements.
12908 
12909 ";
12910 
12911 %feature("docstring")  casadi::FunctionInternal::sz_w() const  "
12912 
12913 [INTERNAL]  Get required length of w field.
12914 
12915 ";
12916 
12917 %feature("docstring")  casadi::FunctionInternal::all_scalar() const  "
12918 
12919 [INTERNAL]  Are all inputs and outputs scalar.
12920 
12921 ";
12922 
12923 %feature("docstring")  casadi::FunctionInternal::n_nodes() const  "
12924 
12925 [INTERNAL]  Number of nodes in the algorithm.
12926 
12927 ";
12928 
12929 %feature("docstring")  casadi::FunctionInternal::codegen_mem(CodeGenerator
12930 &g, const std::string &index="mem") const  "
12931 
12932 [INTERNAL]  Get thread-local memory object.
12933 
12934 ";
12935 
12936 %feature("docstring")  casadi::Conic::get_default_in(casadi_int ind) const
12937 "
12938 
12939 [INTERNAL]  Get default input value.
12940 
12941 ";
12942 
12943 %feature("docstring")  casadi::Conic::get_sparsity_out(casadi_int i)  "
12944 
12945 [INTERNAL]  Sparsities of function inputs and outputs.
12946 
12947 ";
12948 
12949 %feature("docstring")  casadi::FunctionInternal::mx_out(casadi_int ind)
12950 const  "
12951 
12952 [INTERNAL]  Get function input(s) and output(s)
12953 
12954 ";
12955 
12956 %feature("docstring")  casadi::FunctionInternal::mx_out() const  "
12957 
12958 [INTERNAL]  Get function input(s) and output(s)
12959 
12960 ";
12961 
12962 %feature("docstring")  casadi::FunctionInternal::jacobian() const  "
12963 
12964 [INTERNAL]  Return Jacobian of all input elements with respect to all output
12965 elements.
12966 
12967 ";
12968 
12969 %feature("docstring")  casadi::Conic::set_work(void *mem, const double
12970 **&arg, double **&res, casadi_int *&iw, double *&w) const  "
12971 
12972 [INTERNAL]  Set the (persistent) work vectors.
12973 
12974 ";
12975 
12976 %feature("docstring")  casadi::FunctionInternal::symbolicAdjSeed(casadi_int
12977 nadj, const std::vector< MatType > &v) const  "
12978 
12979 [INTERNAL]  Symbolic expressions for the adjoint seeds.
12980 
12981 ";
12982 
12983 %feature("docstring")  casadi::FunctionInternal::set_temp(void *mem, const
12984 double **arg, double **res, casadi_int *iw, double *w) const  "
12985 
12986 [INTERNAL]  Set the (temporary) work vectors.
12987 
12988 ";
12989 
12990 %feature("docstring")  casadi::FunctionInternal::mapsum_mx(const
12991 std::vector< MX > &arg, const std::string &parallelization) "
12992 
12993 [INTERNAL]  Parallel evaluation.
12994 
12995 ";
12996 
12997 %feature("docstring")  casadi::FunctionInternal::sx_out(casadi_int ind)
12998 const  "
12999 
13000 [INTERNAL]  Get function input(s) and output(s)
13001 
13002 ";
13003 
13004 %feature("docstring")  casadi::FunctionInternal::sx_out() const  "
13005 
13006 [INTERNAL]  Get function input(s) and output(s)
13007 
13008 ";
13009 
13010 %feature("docstring")  casadi::ProtoFunction::format_time(char *buffer,
13011 double time) const  "
13012 
13013 [INTERNAL]  Format time in a fixed width 8 format.
13014 
13015 ";
13016 
13017 %feature("docstring")  casadi::FunctionInternal::check_res(const
13018 std::vector< M > &res, casadi_int &npar) const  "
13019 
13020 [INTERNAL]  Check if output arguments have correct length and dimensions.
13021 
13022 Raises errors.
13023 
13024 Parameters:
13025 -----------
13026 
13027 npar[in]:  normal usage: 1, disallow pararallel calls: -1
13028 
13029 npar:  max number of horizontal repetitions across all arguments (or -1)
13030 
13031 ";
13032 
13033 %feature("docstring")  casadi::FunctionInternal::free_mx() const  "
13034 
13035 [INTERNAL]  Get free variables ( MX)
13036 
13037 ";
13038 
13039 %feature("docstring")  casadi::SharedObjectInternal::weak() "
13040 
13041 [INTERNAL]  Get a weak reference to the object.
13042 
13043 ";
13044 
13045 %feature("docstring")  casadi::ProtoFunction::serialize(SerializingStream
13046 &s) const  "
13047 
13048 [INTERNAL]  Serialize an object.
13049 
13050 ";
13051 
13052 %feature("docstring")  casadi::FunctionInternal::check_mat(const Sparsity
13053 &arg, const Sparsity &inp, casadi_int &npar) "
13054 
13055 [INTERNAL]  Helper function
13056 
13057 Parameters:
13058 -----------
13059 
13060 npar[in]:  normal usage: 1, disallow pararallel calls: -1
13061 
13062 npar[out]:  required number of parallel calls (or -1)
13063 
13064 ";
13065 
13066 %feature("docstring")  casadi::FunctionInternal::definition() const  "
13067 
13068 [INTERNAL]  Get function signature: name:(inputs)->(outputs)
13069 
13070 ";
13071 
13072 %feature("docstring")  casadi::FunctionInternal::size2_in(casadi_int ind)
13073 const  "
13074 
13075 [INTERNAL]  Input/output dimensions.
13076 
13077 ";
13078 
13079 %feature("docstring")  casadi::Conic::integer_support() const  "
13080 
13081 [INTERNAL]  Can discrete variables be treated.
13082 
13083 ";
13084 
13085 %feature("docstring")  casadi::FunctionInternal::generate_dependencies(const
13086 std::string &fname, const Dict &opts) const  "
13087 
13088 [INTERNAL]  Export / Generate C code for the dependency function.
13089 
13090 ";
13091 
13092 %feature("docstring")  casadi::FunctionInternal::signature(const std::string
13093 &fname) const  "
13094 
13095 [INTERNAL]  Code generate the function.
13096 
13097 ";
13098 
13099 %feature("docstring")  casadi::FunctionInternal::matching_arg(const
13100 std::vector< M > &arg, casadi_int &npar) const  "
13101 
13102 [INTERNAL]  Check if input arguments that needs to be replaced.
13103 
13104 Raises errors
13105 
13106 Parameters:
13107 -----------
13108 
13109 npar[in]:  normal usage: 1, disallow pararallel calls: -1
13110 
13111 npar:  max number of horizontal repetitions across all arguments (or -1)
13112 
13113 ";
13114 
13115 %feature("docstring")  casadi::Conic::serialize_base_function() const  "
13116 
13117 [INTERNAL]  String used to identify the immediate FunctionInternal subclass.
13118 
13119 ";
13120 
13121 %feature("docstring")  casadi::FunctionInternal::replace_aseed(const
13122 std::vector< std::vector< M >> &aseed, casadi_int npar) const  "
13123 
13124 [INTERNAL]  Replace 0-by-0 reverse seeds.
13125 
13126 ";
13127 
13128 %feature("docstring")  casadi::FunctionInternal::replace_aseed(const
13129 std::vector< std::vector< M > > &aseed, casadi_int npar) const  "
13130 
13131 [INTERNAL] ";
13132 
13133 %feature("docstring")  casadi::Conic::get_name_in(casadi_int i)  "
13134 
13135 [INTERNAL]  Names of function input and outputs.
13136 
13137 ";
13138 
13139 %feature("docstring")  casadi::FunctionInternal::has_reverse(casadi_int
13140 nadj) const  "
13141 
13142 [INTERNAL]  Return function that calculates adjoint derivatives
13143 reverse(nadj) returns a cached instance if available, and calls  Function
13144 get_reverse(casadi_int nadj) if no cached version is available.
13145 
13146 ";
13147 
13148 %feature("docstring") casadi::Conic::~Conic "
13149 
13150 [INTERNAL] ";
13151 
13152 %feature("docstring")  casadi::FunctionInternal::sz_work(size_t &sz_arg,
13153 size_t &sz_res, size_t &sz_iw, size_t &sz_w) const  "
13154 
13155 [INTERNAL]  Get number of temporary variables needed.
13156 
13157 ";
13158 
13159 %feature("docstring")  casadi::FunctionInternal::sz_iw() const  "
13160 
13161 [INTERNAL]  Get required length of iw field.
13162 
13163 ";
13164 
13165 %feature("docstring")  casadi::FunctionInternal::getJacSparsity(casadi_int
13166 iind, casadi_int oind, bool symmetric) const  "
13167 
13168 [INTERNAL]  Generate the sparsity of a Jacobian block.
13169 
13170 ";
13171 
13172 %feature("docstring")  casadi::FunctionInternal::alloc_arg(size_t sz_arg,
13173 bool persistent=false) "
13174 
13175 [INTERNAL]  Ensure required length of arg field.
13176 
13177 ";
13178 
13179 %feature("docstring")  casadi::PluginInterface< Conic  >::plugin_name()
13180 const  "
13181 
13182 [INTERNAL] ";
13183 
13184 %feature("docstring")  casadi::FunctionInternal::jit_dependencies(const
13185 std::string &fname) "
13186 
13187 [INTERNAL]  Jit dependencies.
13188 
13189 ";
13190 
13191 %feature("docstring") casadi::Conic::Conic(const std::string &name, const
13192 std::map< std::string, Sparsity > &st) "
13193 
13194 [INTERNAL] ";
13195 
13196 %feature("docstring")  casadi::FunctionInternal::incache(const std::string
13197 &fname, Function &f, const std::string &suffix="") const  "
13198 
13199 [INTERNAL]  Get function in cache.
13200 
13201 ";
13202 
13203 %feature("docstring")  casadi::FunctionInternal::check_arg(const
13204 std::vector< M > &arg, casadi_int &npar) const  "
13205 
13206 [INTERNAL]  Check if input arguments have correct length and dimensions.
13207 
13208 Raises errors.
13209 
13210 Parameters:
13211 -----------
13212 
13213 npar[in]:  normal usage: 1, disallow pararallel calls: -1
13214 
13215 npar:  max number of horizontal repetitions across all arguments (or -1)
13216 
13217 ";
13218 
13219 %feature("docstring")  casadi::FunctionInternal::fwdViaJac(casadi_int nfwd)
13220 const  "
13221 
13222 [INTERNAL]  Calculate derivatives by multiplying the full Jacobian and
13223 multiplying.
13224 
13225 ";
13226 
13227 %feature("docstring")  casadi::FunctionInternal::project_arg(const
13228 std::vector< M > &arg, casadi_int npar) const  "
13229 
13230 [INTERNAL]   Project sparsities.
13231 
13232 ";
13233 
13234 %feature("docstring")  casadi::FunctionInternal::has_derivative() const  "
13235 
13236 [INTERNAL]  Can derivatives be calculated in any way?
13237 
13238 ";
13239 
13240 %feature("docstring")  casadi::FunctionInternal::sx_in(casadi_int ind) const
13241 "
13242 
13243 [INTERNAL]  Get function input(s) and output(s)
13244 
13245 ";
13246 
13247 %feature("docstring")  casadi::FunctionInternal::sx_in() const  "
13248 
13249 [INTERNAL]  Get function input(s) and output(s)
13250 
13251 ";
13252 
13253 %feature("docstring")  casadi::Conic::serialize_body(SerializingStream &s)
13254 const  "
13255 
13256 [INTERNAL]  Serialize an object without type information.
13257 
13258 ";
13259 
13260 %feature("docstring")  casadi::FunctionInternal::eval_mx(const MXVector
13261 &arg, MXVector &res, bool always_inline, bool never_inline) const  "
13262 
13263 [INTERNAL]  Evaluate with symbolic matrices.
13264 
13265 ";
13266 
13267 %feature("docstring")  casadi::FunctionInternal::setup(void *mem, const
13268 double **arg, double **res, casadi_int *iw, double *w) const  "
13269 
13270 [INTERNAL]  Set the (persistent and temporary) work vectors.
13271 
13272 ";
13273 
13274 %feature("docstring")  casadi::FunctionInternal::fwd_seed(casadi_int nfwd)
13275 const  "
13276 
13277 [INTERNAL]  Symbolic expressions for the forward seeds.
13278 
13279 ";
13280 
13281 %feature("docstring")  casadi::FunctionInternal::reverse(casadi_int nadj)
13282 const  "
13283 
13284 [INTERNAL]  Return function that calculates adjoint derivatives
13285 reverse(nadj) returns a cached instance if available, and calls  Function
13286 get_reverse(casadi_int nadj) if no cached version is available.
13287 
13288 ";
13289 
13290 %feature("docstring")  casadi::FunctionInternal::disp(std::ostream &stream,
13291 bool more) const  "
13292 
13293 [INTERNAL]  Display object.
13294 
13295 ";
13296 
13297 %feature("docstring")  casadi::FunctionInternal::call_gen(const MXVector
13298 &arg, MXVector &res, casadi_int npar, bool always_inline, bool never_inline)
13299 const  "
13300 
13301 [INTERNAL]   Call a function, overloaded.
13302 
13303 ";
13304 
13305 %feature("docstring")  casadi::FunctionInternal::call_gen(const std::vector<
13306 MatrixCommon > &arg, std::vector< MatrixCommon > &res, casadi_int npar, bool
13307 always_inline, bool never_inline) const  "
13308 
13309 [INTERNAL]   Call a function, overloaded.
13310 
13311 ";
13312 
13313 %feature("docstring")  casadi::FunctionInternal::index_out(const std::string
13314 &name) const  "
13315 
13316 [INTERNAL]  Get output scheme index by name.
13317 
13318 ";
13319 
13320 %feature("docstring")
13321 casadi::FunctionInternal::codegen_free_mem(CodeGenerator &g) const  "
13322 
13323 [INTERNAL]  Codegen for free_mem.
13324 
13325 ";
13326 
13327 %feature("docstring")  casadi::FunctionInternal::replace_res(const
13328 std::vector< M > &res, casadi_int npar) const  "
13329 
13330 [INTERNAL]  Replace 0-by-0 outputs.
13331 
13332 ";
13333 
13334 %feature("docstring")  casadi::FunctionInternal::generate_in(const
13335 std::string &fname, const double **arg) const  "
13336 
13337 [INTERNAL]  Export an input file that can be passed to generate C code with
13338 a main.
13339 
13340 ";
13341 
13342 %feature("docstring")  casadi::FunctionInternal::dm_in(casadi_int ind) const
13343 "
13344 
13345 [INTERNAL]  Get function input(s) and output(s)
13346 
13347 ";
13348 
13349 %feature("docstring")  casadi::FunctionInternal::dm_in() const  "
13350 
13351 [INTERNAL]  Get function input(s) and output(s)
13352 
13353 ";
13354 
13355 %feature("docstring")  casadi::FunctionInternal::has_eval_dm() const  "
13356 
13357 [INTERNAL]  Evaluate with DM matrices.
13358 
13359 ";
13360 
13361 %feature("docstring")  casadi::FunctionInternal::codegen(CodeGenerator &g,
13362 const std::string &fname) const  "
13363 
13364 [INTERNAL]  Generate code the function.
13365 
13366 ";
13367 
13368 %feature("docstring")  casadi::SharedObjectInternal::class_name() const  "
13369 
13370 [INTERNAL]  Readable name of the internal class.
13371 
13372 ";
13373 
13374 %feature("docstring")
13375 casadi::FunctionInternal::instruction_input(casadi_int k) const  "
13376 
13377 [INTERNAL]  Get the (integer) input arguments of an atomic operation.
13378 
13379 ";
13380 
13381 %feature("docstring")  casadi::Conic::check_inputs(const double *lbx, const
13382 double *ubx, const double *lba, const double *uba) const  "
13383 
13384 [INTERNAL]  Check if the numerical values of the supplied bounds make sense.
13385 
13386 ";
13387 
13388 %feature("docstring")  casadi::FunctionInternal::mx_in(casadi_int ind) const
13389 "
13390 
13391 [INTERNAL]  Get function input(s) and output(s)
13392 
13393 ";
13394 
13395 %feature("docstring")  casadi::FunctionInternal::mx_in() const  "
13396 
13397 [INTERNAL]  Get function input(s) and output(s)
13398 
13399 ";
13400 
13401 %feature("docstring")
13402 casadi::FunctionInternal::codegen_sparsities(CodeGenerator &g) const  "
13403 
13404 [INTERNAL]  Codegen sparsities.
13405 
13406 ";
13407 
13408 %feature("docstring")  casadi::FunctionInternal::get_function() const  "
13409 
13410 [INTERNAL] ";
13411 
13412 %feature("docstring")  casadi::FunctionInternal::get_function(const
13413 std::string &name) const  "
13414 
13415 [INTERNAL] ";
13416 
13417 %feature("docstring")  casadi::FunctionInternal::has_jacobian_sparsity()
13418 const  "
13419 
13420 [INTERNAL]  Get Jacobian sparsity.
13421 
13422 ";
13423 
13424 %feature("docstring")  casadi::FunctionInternal::codegen_body(CodeGenerator
13425 &g) const  "
13426 
13427 [INTERNAL]  Generate code for the function body.
13428 
13429 ";
13430 
13431 %feature("docstring")  casadi::FunctionInternal::sp_forward(const bvec_t
13432 **arg, bvec_t **res, casadi_int *iw, bvec_t *w, void *mem) const  "
13433 
13434 [INTERNAL]  Propagate sparsity forward.
13435 
13436 ";
13437 
13438 %feature("docstring")  casadi::FunctionInternal::get_reltol() const  "
13439 
13440 [INTERNAL]  Get relative tolerance.
13441 
13442 ";
13443 
13444 %feature("docstring")  casadi::FunctionInternal::getAdaptorSolverName()
13445 const  "
13446 
13447 [INTERNAL]  Obtain solver name from Adaptor.
13448 
13449 ";
13450 
13451 %feature("docstring")
13452 casadi::FunctionInternal::getJacSparsityHierarchicalSymm(casadi_int iind,
13453 casadi_int oind) const  "
13454 
13455 [INTERNAL]  A flavor of getJacSparsity that does hierarchical block
13456 structure recognition for symmetric Jacobians
13457 
13458 ";
13459 
13460 %feature("docstring")  casadi::FunctionInternal::has_spfwd() const  "
13461 
13462 [INTERNAL]  Is the class able to propagate seeds through the algorithm?
13463 
13464 ";
13465 
13466 %feature("docstring")  casadi::ProtoFunction::construct(const Dict &opts) "
13467 
13468 [INTERNAL]  Construct Prepares the function for evaluation.
13469 
13470 ";
13471 
13472 %feature("docstring")  casadi::Conic::serialize_type(SerializingStream &s)
13473 const  "
13474 
13475 [INTERNAL]  Serialize type information.
13476 
13477 ";
13478 
13479 %feature("docstring")  casadi::FunctionInternal::size1_in(casadi_int ind)
13480 const  "
13481 
13482 [INTERNAL]  Input/output dimensions.
13483 
13484 ";
13485 
13486 %feature("docstring")
13487 casadi::FunctionInternal::instruction_constant(casadi_int k) const  "
13488 
13489 [INTERNAL]  Get the floating point output argument of an atomic operation.
13490 
13491 ";
13492 
13493 %feature("docstring")  casadi::Conic::get_n_in()  "
13494 
13495 [INTERNAL]  Number of function inputs and outputs.
13496 
13497 ";
13498 
13499 %feature("docstring")  casadi::FunctionInternal::generate_lifted(Function
13500 &vdef_fcn, Function &vinit_fcn) const  "
13501 
13502 [INTERNAL]  Extract the functions needed for the Lifted Newton method.
13503 
13504 ";
13505 
13506 %feature("docstring")  casadi::FunctionInternal::generate_out(const
13507 std::string &fname, double **res) const  "
13508 
13509 [INTERNAL] ";
13510 
13511 %feature("docstring")  casadi::FunctionInternal::numel_in() const  "
13512 
13513 [INTERNAL]  Number of input/output elements.
13514 
13515 ";
13516 
13517 %feature("docstring")  casadi::FunctionInternal::numel_in(casadi_int ind)
13518 const  "
13519 
13520 [INTERNAL]  Number of input/output elements.
13521 
13522 ";
13523 
13524 %feature("docstring")
13525 casadi::FunctionInternal::instruction_output(casadi_int k) const  "
13526 
13527 [INTERNAL]  Get the (integer) output argument of an atomic operation.
13528 
13529 ";
13530 
13531 %feature("docstring")
13532 casadi::FunctionInternal::print_dimensions(std::ostream &stream) const  "
13533 
13534 [INTERNAL]  Print dimensions of inputs and outputs.
13535 
13536 ";
13537 
13538 %feature("docstring")  casadi::ProtoFunction::print_time(const std::map<
13539 std::string, FStats > &fstats) const  "
13540 
13541 [INTERNAL]  Print timing statistics.
13542 
13543 ";
13544 
13545 %feature("docstring")  casadi::FunctionInternal::map(casadi_int n, const
13546 std::string &parallelization) const  "
13547 
13548 [INTERNAL]  Generate/retrieve cached serial map.
13549 
13550 ";
13551 
13552 %feature("docstring")  casadi::FunctionInternal::export_code(const
13553 std::string &lang, std::ostream &stream, const Dict &options) const  "
13554 
13555 [INTERNAL]  Export function in a specific language.
13556 
13557 ";
13558 
13559 %feature("docstring")  casadi::FunctionInternal::sparsity_in(casadi_int ind)
13560 const  "
13561 
13562 [INTERNAL]  Input/output sparsity.
13563 
13564 ";
13565 
13566 %feature("docstring")  casadi::ProtoFunction::release(int mem) const  "
13567 
13568 [INTERNAL]  Release a memory object.
13569 
13570 ";
13571 
13572 %feature("docstring")  casadi::FunctionInternal::instruction_id(casadi_int
13573 k) const  "
13574 
13575 [INTERNAL]  Get an atomic operation operator index.
13576 
13577 ";
13578 
13579 %feature("docstring")  casadi::FunctionInternal::jac() const  "
13580 
13581 [INTERNAL]  Return Jacobian of all input elements with respect to all output
13582 elements.
13583 
13584 ";
13585 
13586 %feature("docstring")  casadi::FunctionInternal::alloc(const Function &f,
13587 bool persistent=false) "
13588 
13589 [INTERNAL]  Ensure work vectors long enough to evaluate function.
13590 
13591 ";
13592 
13593 %feature("docstring")  casadi::FunctionInternal::is_diff_in(casadi_int i) "
13594 
13595 [INTERNAL] ";
13596 
13597 %feature("docstring")  casadi::Conic::is_a(const std::string &type, bool
13598 recursive) const  "
13599 
13600 [INTERNAL]  Check if the function is of a particular type.
13601 
13602 ";
13603 
13604 %feature("docstring")  casadi::FunctionInternal::matching_res(const
13605 std::vector< M > &arg, casadi_int &npar) const  "
13606 
13607 [INTERNAL]  Check if output arguments that needs to be replaced.
13608 
13609 Raises errors
13610 
13611 Parameters:
13612 -----------
13613 
13614 npar[in]:  normal usage: 1, disallow pararallel calls: -1
13615 
13616 npar:  max number of horizontal repetitions across all arguments (or -1)
13617 
13618 ";
13619 
13620 %feature("docstring")  casadi::FunctionInternal::nnz_out() const  "
13621 
13622 [INTERNAL]  Number of input/output nonzeros.
13623 
13624 ";
13625 
13626 %feature("docstring")  casadi::FunctionInternal::nnz_out(casadi_int ind)
13627 const  "
13628 
13629 [INTERNAL]  Number of input/output nonzeros.
13630 
13631 ";
13632 
13633 %feature("docstring")  casadi::FunctionInternal::info() const  "
13634 
13635 [INTERNAL]  Obtain information about function
13636 
13637 ";
13638 
13639 %feature("docstring")  casadi::FunctionInternal::jacobian_sparsity() const
13640 "
13641 
13642 [INTERNAL]  Get Jacobian sparsity.
13643 
13644 ";
13645 
13646 %feature("docstring")  casadi::Conic::solve(const double **arg, double
13647 **res, casadi_int *iw, double *w, void *mem) const  "
13648 
13649 [INTERNAL]   Solve the QP.
13650 
13651 ";
13652 
13653 %feature("docstring") casadi::casadi_solve "
13654 
13655 Solve the QP.
13656 
13657 ";
13658 
13659 %feature("docstring")  casadi::Conic::casadi_solve "
13660 
13661 Solve the QP.
13662 
13663 ";
13664 
13665 %feature("docstring")  casadi::FunctionInternal::sz_res() const  "
13666 
13667 [INTERNAL]  Get required length of res field.
13668 
13669 ";
13670 
13671 %feature("docstring")
13672 casadi::FunctionInternal::codegen_incref(CodeGenerator &g) const  "
13673 
13674 [INTERNAL]  Codegen incref for dependencies.
13675 
13676 ";
13677 
13678 %feature("docstring")  casadi::FunctionInternal::oracle() const  "
13679 
13680 [INTERNAL]  Get oracle.
13681 
13682 ";
13683 
13684 %feature("docstring")  casadi::FunctionInternal::factory(const std::string
13685 &name, const std::vector< std::string > &s_in, const std::vector<
13686 std::string > &s_out, const Function::AuxOut &aux, const Dict &opts) const
13687 "
13688 
13689 [INTERNAL] ";
13690 
13691 %feature("docstring")  casadi::Conic::get_stats(void *mem) const  "
13692 
13693 [INTERNAL]  Get all statistics.
13694 
13695 ";
13696 
13697 %feature("docstring")  casadi::FunctionInternal::codegen_name(const
13698 CodeGenerator &g, bool ns=true) const  "
13699 
13700 [INTERNAL]  Get name in codegen.
13701 
13702 ";
13703 
13704 %feature("docstring")  casadi::FunctionInternal::has_sprev() const  "
13705 
13706 [INTERNAL]  Is the class able to propagate seeds through the algorithm?
13707 
13708 ";
13709 
13710 %feature("docstring")  casadi::ProtoFunction::free_mem(void *mem) const  "
13711 
13712 [INTERNAL]  Free memory block.
13713 
13714 ";
13715 
13716 %feature("docstring")
13717 casadi::FunctionInternal::codegen_alloc_mem(CodeGenerator &g) const  "
13718 
13719 [INTERNAL]  Codegen decref for alloc_mem.
13720 
13721 ";
13722 
13723 %feature("docstring")  casadi::Conic::get_name_out(casadi_int i)  "
13724 
13725 [INTERNAL]  Names of function input and outputs.
13726 
13727 ";
13728 
13729 %feature("docstring")  casadi::FunctionInternal::sp_reverse(bvec_t **arg,
13730 bvec_t **res, casadi_int *iw, bvec_t *w, void *mem) const  "
13731 
13732 [INTERNAL]  Propagate sparsity backwards.
13733 
13734 ";
13735 
13736 %feature("docstring")  casadi::SharedObjectInternal::getCount() const  "
13737 
13738 [INTERNAL]  Get the reference count.
13739 
13740 ";
13741 
13742 %feature("docstring")  casadi::FunctionInternal::has_free() const  "
13743 
13744 [INTERNAL]  Does the function have free variables.
13745 
13746 ";
13747 
13748 %feature("docstring")  casadi::FunctionInternal::instructions_sx() const  "
13749 
13750 [INTERNAL]  get SX expression associated with instructions
13751 
13752 ";
13753 
13754 %feature("docstring")  casadi::FunctionInternal::get_max_in(casadi_int ind)
13755 const  "
13756 
13757 [INTERNAL]  Get largest input value.
13758 
13759 ";
13760 
13761 %feature("docstring")
13762 casadi::FunctionInternal::getJacSparsityGen(casadi_int iind, casadi_int
13763 oind, bool symmetric, casadi_int gr_i=1, casadi_int gr_o=1) const  "
13764 
13765 [INTERNAL]  Get the sparsity pattern, forward mode.
13766 
13767 ";
13768 
13769 %feature("docstring")  casadi::FunctionInternal::is_diff_out(casadi_int i) "
13770 
13771 [INTERNAL] ";
13772 
13773 %feature("docstring")  casadi::FunctionInternal::uses_output() const  "
13774 
13775 [INTERNAL]  Do the derivative functions need nondifferentiated outputs?
13776 
13777 ";
13778 
13779 %feature("docstring")  casadi::Conic::psd_support() const  "
13780 
13781 [INTERNAL]  Can psd constraints be treated.
13782 
13783 ";
13784 
13785 %feature("docstring")  casadi::FunctionInternal::project_res(const
13786 std::vector< M > &arg, casadi_int npar) const  "
13787 
13788 [INTERNAL]   Project sparsities.
13789 
13790 ";
13791 
13792 %feature("docstring")  casadi::ProtoFunction::checkout() const  "
13793 
13794 [INTERNAL]  Checkout a memory object.
13795 
13796 ";
13797 
13798 %feature("docstring")
13799 casadi::FunctionInternal::codegen_declarations(CodeGenerator &g) const  "
13800 
13801 [INTERNAL]  Generate code for the declarations of the C function.
13802 
13803 ";
13804 
13805 %feature("docstring")  casadi::FunctionInternal::size_out(casadi_int ind)
13806 const  "
13807 
13808 [INTERNAL]  Input/output dimensions.
13809 
13810 ";
13811 
13812 %feature("docstring")  casadi::Conic::get_options() const  "
13813 
13814 [INTERNAL]  Options.
13815 
13816 ";
13817 
13818 %feature("docstring")
13819 casadi::FunctionInternal::getJacSparsityHierarchical(casadi_int iind,
13820 casadi_int oind) const  "
13821 
13822 [INTERNAL]  A flavor of getJacSparsity that does hierarchical block
13823 structure recognition.
13824 
13825 ";
13826 
13827 %feature("docstring")  casadi::FunctionInternal::size2_out(casadi_int ind)
13828 const  "
13829 
13830 [INTERNAL]  Input/output dimensions.
13831 
13832 ";
13833 
13834 %feature("docstring")  casadi::Conic::get_sparsity_in(casadi_int i)  "
13835 
13836 [INTERNAL]  Sparsities of function inputs and outputs.
13837 
13838 ";
13839 
13840 %feature("docstring")  casadi::FunctionInternal::codegen_mem_type() const  "
13841 
13842 [INTERNAL]  Thread-local memory object type.
13843 
13844 ";
13845 
13846 %feature("docstring")  casadi::FunctionInternal::print_options(std::ostream
13847 &stream) const  "
13848 
13849 [INTERNAL]  Print list of options.
13850 
13851 ";
13852 
13853 %feature("docstring")
13854 casadi::FunctionInternal::codegen_init_mem(CodeGenerator &g) const  "
13855 
13856 [INTERNAL]  Codegen decref for init_mem.
13857 
13858 ";
13859 
13860 %feature("docstring")  casadi::FunctionInternal::codegen_meta(CodeGenerator
13861 &g) const  "
13862 
13863 [INTERNAL]  Generate meta-information allowing a user to evaluate a
13864 generated function.
13865 
13866 ";
13867 
13868 %feature("docstring")  casadi::ProtoFunction::alloc_mem() const  "
13869 
13870 [INTERNAL]  Create memory block.
13871 
13872 ";
13873 
13874 %feature("docstring")  casadi::FunctionInternal::has_codegen() const  "
13875 
13876 [INTERNAL]  Is codegen supported?
13877 
13878 ";
13879 
13880 %feature("docstring")  casadi::FunctionInternal::sp_weight() const  "
13881 
13882 [INTERNAL]  Weighting factor for chosing forward/reverse mode, sparsity
13883 propagation.
13884 
13885 ";
13886 
13887 %feature("docstring")  casadi::FunctionInternal::size_in(casadi_int ind)
13888 const  "
13889 
13890 [INTERNAL]  Input/output dimensions.
13891 
13892 ";
13893 
13894 %feature("docstring") casadi::Conic "
13895 
13896 Internal class.
13897 
13898 >List of available options
13899 
13900 +------------------+-----------------+------------------+------------------+
13901 |        Id        |      Type       |   Description    |     Used in      |
13902 +==================+=================+==================+==================+
13903 | ad_weight        | OT_DOUBLE       | Weighting factor | casadi::Function |
13904 |                  |                 | for derivative   | Internal         |
13905 |                  |                 | calculation.When |                  |
13906 |                  |                 | there is an      |                  |
13907 |                  |                 | option of either |                  |
13908 |                  |                 | using forward or |                  |
13909 |                  |                 | reverse mode     |                  |
13910 |                  |                 | directional      |                  |
13911 |                  |                 | derivatives, the |                  |
13912 |                  |                 | condition ad_wei |                  |
13913 |                  |                 | ght*nf<=(1-ad_we |                  |
13914 |                  |                 | ight)*na is used |                  |
13915 |                  |                 | where nf and na  |                  |
13916 |                  |                 | are estimates of |                  |
13917 |                  |                 | the number of    |                  |
13918 |                  |                 | forward/reverse  |                  |
13919 |                  |                 | mode directional |                  |
13920 |                  |                 | derivatives      |                  |
13921 |                  |                 | needed. By       |                  |
13922 |                  |                 | default,         |                  |
13923 |                  |                 | ad_weight is     |                  |
13924 |                  |                 | calculated       |                  |
13925 |                  |                 | automatically,   |                  |
13926 |                  |                 | but this can be  |                  |
13927 |                  |                 | overridden by    |                  |
13928 |                  |                 | setting this     |                  |
13929 |                  |                 | option. In       |                  |
13930 |                  |                 | particular, 0    |                  |
13931 |                  |                 | means forcing    |                  |
13932 |                  |                 | forward mode and |                  |
13933 |                  |                 | 1 forcing        |                  |
13934 |                  |                 | reverse mode.    |                  |
13935 |                  |                 | Leave unset for  |                  |
13936 |                  |                 | (class specific) |                  |
13937 |                  |                 | heuristics.      |                  |
13938 +------------------+-----------------+------------------+------------------+
13939 | ad_weight_sp     | OT_DOUBLE       | Weighting factor | casadi::Function |
13940 |                  |                 | for sparsity     | Internal         |
13941 |                  |                 | pattern          |                  |
13942 |                  |                 | calculation calc |                  |
13943 |                  |                 | ulation.Override |                  |
13944 |                  |                 | s default        |                  |
13945 |                  |                 | behavior. Set to |                  |
13946 |                  |                 | 0 and 1 to force |                  |
13947 |                  |                 | forward and      |                  |
13948 |                  |                 | reverse mode     |                  |
13949 |                  |                 | respectively.    |                  |
13950 |                  |                 | Cf. option       |                  |
13951 |                  |                 | \"ad_weight\".     |                  |
13952 |                  |                 | When set to -1,  |                  |
13953 |                  |                 | sparsity is      |                  |
13954 |                  |                 | completely       |                  |
13955 |                  |                 | ignored and      |                  |
13956 |                  |                 | dense matrices   |                  |
13957 |                  |                 | are used.        |                  |
13958 +------------------+-----------------+------------------+------------------+
13959 | always_inline    | OT_BOOL         | Force inlining.  | casadi::Function |
13960 |                  |                 |                  | Internal         |
13961 +------------------+-----------------+------------------+------------------+
13962 | compiler         | OT_STRING       | Just-in-time     | casadi::Function |
13963 |                  |                 | compiler plugin  | Internal         |
13964 |                  |                 | to be used.      |                  |
13965 +------------------+-----------------+------------------+------------------+
13966 | custom_jacobian  | OT_FUNCTION     | Override         | casadi::Function |
13967 |                  |                 | CasADi's AD. Use | Internal         |
13968 |                  |                 | together with    |                  |
13969 |                  |                 | 'jac_penalty':   |                  |
13970 |                  |                 | 0. Note: Highly  |                  |
13971 |                  |                 | experimental.    |                  |
13972 |                  |                 | Syntax may break |                  |
13973 |                  |                 | often.           |                  |
13974 +------------------+-----------------+------------------+------------------+
13975 | derivative_of    | OT_FUNCTION     | The function is  | casadi::Function |
13976 |                  |                 | a derivative of  | Internal         |
13977 |                  |                 | another          |                  |
13978 |                  |                 | function. The    |                  |
13979 |                  |                 | type of          |                  |
13980 |                  |                 | derivative       |                  |
13981 |                  |                 | (directional     |                  |
13982 |                  |                 | derivative,      |                  |
13983 |                  |                 | Jacobian) is     |                  |
13984 |                  |                 | inferred from    |                  |
13985 |                  |                 | the function     |                  |
13986 |                  |                 | name.            |                  |
13987 +------------------+-----------------+------------------+------------------+
13988 | discrete         | OT_BOOLVECTOR   | Indicates which  | casadi::Conic    |
13989 |                  |                 | of the variables |                  |
13990 |                  |                 | are discrete,    |                  |
13991 |                  |                 | i.e. integer-    |                  |
13992 |                  |                 | valued           |                  |
13993 +------------------+-----------------+------------------+------------------+
13994 | dump             | OT_BOOL         | Dump function to | casadi::Function |
13995 |                  |                 | file upon first  | Internal         |
13996 |                  |                 | evaluation.      |                  |
13997 |                  |                 | [false]          |                  |
13998 +------------------+-----------------+------------------+------------------+
13999 | dump_dir         | OT_STRING       | Directory to     | casadi::Function |
14000 |                  |                 | dump             | Internal         |
14001 |                  |                 | inputs/outputs   |                  |
14002 |                  |                 | to. Make sure    |                  |
14003 |                  |                 | the directory    |                  |
14004 |                  |                 | exists [.]       |                  |
14005 +------------------+-----------------+------------------+------------------+
14006 | dump_format      | OT_STRING       | Choose file      | casadi::Function |
14007 |                  |                 | format to dump   | Internal         |
14008 |                  |                 | matrices. See    |                  |
14009 |                  |                 | DM.from_file     |                  |
14010 |                  |                 | [mtx]            |                  |
14011 +------------------+-----------------+------------------+------------------+
14012 | dump_in          | OT_BOOL         | Dump numerical   | casadi::Function |
14013 |                  |                 | values of inputs | Internal         |
14014 |                  |                 | to file          |                  |
14015 |                  |                 | (readable with   |                  |
14016 |                  |                 | DM.from_file )   |                  |
14017 |                  |                 | [default: false] |                  |
14018 +------------------+-----------------+------------------+------------------+
14019 | dump_out         | OT_BOOL         | Dump numerical   | casadi::Function |
14020 |                  |                 | values of        | Internal         |
14021 |                  |                 | outputs to file  |                  |
14022 |                  |                 | (readable with   |                  |
14023 |                  |                 | DM.from_file )   |                  |
14024 |                  |                 | [default: false] |                  |
14025 +------------------+-----------------+------------------+------------------+
14026 | enable_fd        | OT_BOOL         | Enable           | casadi::Function |
14027 |                  |                 | derivative       | Internal         |
14028 |                  |                 | calculation by   |                  |
14029 |                  |                 | finite           |                  |
14030 |                  |                 | differencing.    |                  |
14031 |                  |                 | [default:        |                  |
14032 |                  |                 | false]]          |                  |
14033 +------------------+-----------------+------------------+------------------+
14034 | enable_forward   | OT_BOOL         | Enable           | casadi::Function |
14035 |                  |                 | derivative       | Internal         |
14036 |                  |                 | calculation      |                  |
14037 |                  |                 | using generated  |                  |
14038 |                  |                 | functions for    |                  |
14039 |                  |                 | Jacobian-times-  |                  |
14040 |                  |                 | vector products  |                  |
14041 |                  |                 | - typically      |                  |
14042 |                  |                 | using forward    |                  |
14043 |                  |                 | mode AD - if     |                  |
14044 |                  |                 | available.       |                  |
14045 |                  |                 | [default: true]  |                  |
14046 +------------------+-----------------+------------------+------------------+
14047 | enable_jacobian  | OT_BOOL         | Enable           | casadi::Function |
14048 |                  |                 | derivative       | Internal         |
14049 |                  |                 | calculation      |                  |
14050 |                  |                 | using generated  |                  |
14051 |                  |                 | functions for    |                  |
14052 |                  |                 | Jacobians of all |                  |
14053 |                  |                 | differentiable   |                  |
14054 |                  |                 | outputs with     |                  |
14055 |                  |                 | respect to all   |                  |
14056 |                  |                 | differentiable   |                  |
14057 |                  |                 | inputs - if      |                  |
14058 |                  |                 | available.       |                  |
14059 |                  |                 | [default: true]  |                  |
14060 +------------------+-----------------+------------------+------------------+
14061 | enable_reverse   | OT_BOOL         | Enable           | casadi::Function |
14062 |                  |                 | derivative       | Internal         |
14063 |                  |                 | calculation      |                  |
14064 |                  |                 | using generated  |                  |
14065 |                  |                 | functions for    |                  |
14066 |                  |                 | transposed       |                  |
14067 |                  |                 | Jacobian-times-  |                  |
14068 |                  |                 | vector products  |                  |
14069 |                  |                 | - typically      |                  |
14070 |                  |                 | using reverse    |                  |
14071 |                  |                 | mode AD - if     |                  |
14072 |                  |                 | available.       |                  |
14073 |                  |                 | [default: true]  |                  |
14074 +------------------+-----------------+------------------+------------------+
14075 | error_on_fail    | OT_BOOL         | When the         | casadi::Conic    |
14076 |                  |                 | numerical        |                  |
14077 |                  |                 | process returns  |                  |
14078 |                  |                 | unsuccessfully,  |                  |
14079 |                  |                 | raise an error   |                  |
14080 |                  |                 | (default false). |                  |
14081 +------------------+-----------------+------------------+------------------+
14082 | fd_method        | OT_STRING       | Method for       | casadi::Function |
14083 |                  |                 | finite           | Internal         |
14084 |                  |                 | differencing     |                  |
14085 |                  |                 | [default         |                  |
14086 |                  |                 | 'central']       |                  |
14087 +------------------+-----------------+------------------+------------------+
14088 | fd_options       | OT_DICT         | Options to be    | casadi::Function |
14089 |                  |                 | passed to the    | Internal         |
14090 |                  |                 | finite           |                  |
14091 |                  |                 | difference       |                  |
14092 |                  |                 | instance         |                  |
14093 +------------------+-----------------+------------------+------------------+
14094 | forward_options  | OT_DICT         | Options to be    | casadi::Function |
14095 |                  |                 | passed to a      | Internal         |
14096 |                  |                 | forward mode     |                  |
14097 |                  |                 | constructor      |                  |
14098 +------------------+-----------------+------------------+------------------+
14099 | gather_stats     | OT_BOOL         | Deprecated       | casadi::Function |
14100 |                  |                 | option           | Internal         |
14101 |                  |                 | (ignored):       |                  |
14102 |                  |                 | Statistics are   |                  |
14103 |                  |                 | now always       |                  |
14104 |                  |                 | collected.       |                  |
14105 +------------------+-----------------+------------------+------------------+
14106 | input_scheme     | OT_STRINGVECTOR | Deprecated       | casadi::Function |
14107 |                  |                 | option (ignored) | Internal         |
14108 +------------------+-----------------+------------------+------------------+
14109 | inputs_check     | OT_BOOL         | Throw exceptions | casadi::Function |
14110 |                  |                 | when the         | Internal         |
14111 |                  |                 | numerical values |                  |
14112 |                  |                 | of the inputs    |                  |
14113 |                  |                 | don't make sense |                  |
14114 +------------------+-----------------+------------------+------------------+
14115 | is_diff_in       | OT_BOOLVECTOR   | Indicate for     | casadi::Function |
14116 |                  |                 | each input if it | Internal         |
14117 |                  |                 | should be        |                  |
14118 |                  |                 | differentiable.  |                  |
14119 +------------------+-----------------+------------------+------------------+
14120 | is_diff_out      | OT_BOOLVECTOR   | Indicate for     | casadi::Function |
14121 |                  |                 | each output if   | Internal         |
14122 |                  |                 | it should be     |                  |
14123 |                  |                 | differentiable.  |                  |
14124 +------------------+-----------------+------------------+------------------+
14125 | jac_penalty      | OT_DOUBLE       | When requested   | casadi::Function |
14126 |                  |                 | for a number of  | Internal         |
14127 |                  |                 | forward/reverse  |                  |
14128 |                  |                 | directions, it   |                  |
14129 |                  |                 | may be cheaper   |                  |
14130 |                  |                 | to compute first |                  |
14131 |                  |                 | the full         |                  |
14132 |                  |                 | jacobian and     |                  |
14133 |                  |                 | then multiply    |                  |
14134 |                  |                 | with seeds,      |                  |
14135 |                  |                 | rather than      |                  |
14136 |                  |                 | obtain the       |                  |
14137 |                  |                 | requested        |                  |
14138 |                  |                 | directions in a  |                  |
14139 |                  |                 | straightforward  |                  |
14140 |                  |                 | manner. Casadi   |                  |
14141 |                  |                 | uses a heuristic |                  |
14142 |                  |                 | to decide which  |                  |
14143 |                  |                 | is cheaper. A    |                  |
14144 |                  |                 | high value of    |                  |
14145 |                  |                 | 'jac_penalty'    |                  |
14146 |                  |                 | makes it less    |                  |
14147 |                  |                 | likely for the   |                  |
14148 |                  |                 | heurstic to      |                  |
14149 |                  |                 | chose the full   |                  |
14150 |                  |                 | Jacobian         |                  |
14151 |                  |                 | strategy. The    |                  |
14152 |                  |                 | special value -1 |                  |
14153 |                  |                 | indicates never  |                  |
14154 |                  |                 | to use the full  |                  |
14155 |                  |                 | Jacobian         |                  |
14156 |                  |                 | strategy         |                  |
14157 +------------------+-----------------+------------------+------------------+
14158 | jit              | OT_BOOL         | Use just-in-time | casadi::Function |
14159 |                  |                 | compiler to      | Internal         |
14160 |                  |                 | speed up the     |                  |
14161 |                  |                 | evaluation       |                  |
14162 +------------------+-----------------+------------------+------------------+
14163 | jit_cleanup      | OT_BOOL         | Cleanup up the   | casadi::Function |
14164 |                  |                 | temporary source | Internal         |
14165 |                  |                 | file that jit    |                  |
14166 |                  |                 | creates.         |                  |
14167 |                  |                 | Default: true    |                  |
14168 +------------------+-----------------+------------------+------------------+
14169 | jit_name         | OT_STRING       | The file name    | casadi::Function |
14170 |                  |                 | used to write    | Internal         |
14171 |                  |                 | out code. The    |                  |
14172 |                  |                 | actual file      |                  |
14173 |                  |                 | names used       |                  |
14174 |                  |                 | depend on 'jit_t |                  |
14175 |                  |                 | emp_suffix' and  |                  |
14176 |                  |                 | include          |                  |
14177 |                  |                 | extensions.      |                  |
14178 |                  |                 | Default:         |                  |
14179 |                  |                 | 'jit_tmp'        |                  |
14180 +------------------+-----------------+------------------+------------------+
14181 | jit_options      | OT_DICT         | Options to be    | casadi::Function |
14182 |                  |                 | passed to the    | Internal         |
14183 |                  |                 | jit compiler.    |                  |
14184 +------------------+-----------------+------------------+------------------+
14185 | jit_serialize    | OT_STRING       | Specify          | casadi::Function |
14186 |                  |                 | behaviour when   | Internal         |
14187 |                  |                 | serializing a    |                  |
14188 |                  |                 | jitted function: |                  |
14189 |                  |                 | SOURCE|link|embe |                  |
14190 |                  |                 | d.               |                  |
14191 +------------------+-----------------+------------------+------------------+
14192 | jit_temp_suffix  | OT_BOOL         | Use a temporary  | casadi::Function |
14193 |                  |                 | (seemingly       | Internal         |
14194 |                  |                 | random) filename |                  |
14195 |                  |                 | suffix for       |                  |
14196 |                  |                 | generated code   |                  |
14197 |                  |                 | and libraries.   |                  |
14198 |                  |                 | This is desired  |                  |
14199 |                  |                 | for thread-      |                  |
14200 |                  |                 | safety. This     |                  |
14201 |                  |                 | behaviour may    |                  |
14202 |                  |                 | defeat caching   |                  |
14203 |                  |                 | compiler         |                  |
14204 |                  |                 | wrappers.        |                  |
14205 |                  |                 | Default: true    |                  |
14206 +------------------+-----------------+------------------+------------------+
14207 | max_num_dir      | OT_INT          | Specify the      | casadi::Function |
14208 |                  |                 | maximum number   | Internal         |
14209 |                  |                 | of directions    |                  |
14210 |                  |                 | for derivative   |                  |
14211 |                  |                 | functions.       |                  |
14212 |                  |                 | Overrules the    |                  |
14213 |                  |                 | builtin optimize |                  |
14214 |                  |                 | d_num_dir.       |                  |
14215 +------------------+-----------------+------------------+------------------+
14216 | never_inline     | OT_BOOL         | Forbid inlining. | casadi::Function |
14217 |                  |                 |                  | Internal         |
14218 +------------------+-----------------+------------------+------------------+
14219 | output_scheme    | OT_STRINGVECTOR | Deprecated       | casadi::Function |
14220 |                  |                 | option (ignored) | Internal         |
14221 +------------------+-----------------+------------------+------------------+
14222 | print_in         | OT_BOOL         | Print numerical  | casadi::Function |
14223 |                  |                 | values of inputs | Internal         |
14224 |                  |                 | [default: false] |                  |
14225 +------------------+-----------------+------------------+------------------+
14226 | print_out        | OT_BOOL         | Print numerical  | casadi::Function |
14227 |                  |                 | values of        | Internal         |
14228 |                  |                 | outputs          |                  |
14229 |                  |                 | [default: false] |                  |
14230 +------------------+-----------------+------------------+------------------+
14231 | print_problem    | OT_BOOL         | Print a numeric  | casadi::Conic    |
14232 |                  |                 | description of   |                  |
14233 |                  |                 | the problem      |                  |
14234 +------------------+-----------------+------------------+------------------+
14235 | print_time       | OT_BOOL         | print            | casadi::Function |
14236 |                  |                 | information      | Internal         |
14237 |                  |                 | about execution  |                  |
14238 |                  |                 | time. Implies    |                  |
14239 |                  |                 | record_time.     |                  |
14240 +------------------+-----------------+------------------+------------------+
14241 | record_time      | OT_BOOL         | record           | casadi::Function |
14242 |                  |                 | information      | Internal         |
14243 |                  |                 | about execution  |                  |
14244 |                  |                 | time, for        |                  |
14245 |                  |                 | retrieval with   |                  |
14246 |                  |                 | stats().         |                  |
14247 +------------------+-----------------+------------------+------------------+
14248 | regularity_check | OT_BOOL         | Throw exceptions | casadi::Function |
14249 |                  |                 | when NaN or Inf  | Internal         |
14250 |                  |                 | appears during   |                  |
14251 |                  |                 | evaluation       |                  |
14252 +------------------+-----------------+------------------+------------------+
14253 | reverse_options  | OT_DICT         | Options to be    | casadi::Function |
14254 |                  |                 | passed to a      | Internal         |
14255 |                  |                 | reverse mode     |                  |
14256 |                  |                 | constructor      |                  |
14257 +------------------+-----------------+------------------+------------------+
14258 | user_data        | OT_VOIDPTR      | A user-defined   | casadi::Function |
14259 |                  |                 | field that can   | Internal         |
14260 |                  |                 | be used to       |                  |
14261 |                  |                 | identify the     |                  |
14262 |                  |                 | function or pass |                  |
14263 |                  |                 | additional       |                  |
14264 |                  |                 | information      |                  |
14265 +------------------+-----------------+------------------+------------------+
14266 | verbose          | OT_BOOL         | Verbose          | casadi::Function |
14267 |                  |                 | evaluation  for  | Internal         |
14268 |                  |                 | debugging        |                  |
14269 +------------------+-----------------+------------------+------------------+
14270 
14271 Diagrams
14272 --------
14273 
14274 
14275 
14276 C++ includes: conic_impl.hpp ";
14277 
14278 %feature("docstring")  casadi::ProtoFunction::memory(int ind) const  "
14279 
14280 [INTERNAL]  Memory objects.
14281 
14282 ";
14283 
14284 %feature("docstring")  casadi::Conic::init_mem(void *mem) const  "
14285 
14286 [INTERNAL]  Initalize memory block.
14287 
14288 ";
14289 
14290 %feature("docstring")  casadi::FunctionInternal::wrap() const  "
14291 
14292 [INTERNAL]  Wrap in an Function instance consisting of only one MX call.
14293 
14294 ";
14295 
14296 %feature("docstring")  casadi::FunctionInternal::replace_arg(const
14297 std::vector< M > &arg, casadi_int npar) const  "
14298 
14299 [INTERNAL]  Replace 0-by-0 inputs.
14300 
14301 ";
14302 
14303 %feature("docstring")  casadi::FunctionInternal::forward(casadi_int nfwd)
14304 const  "
14305 
14306 [INTERNAL]  Return function that calculates forward derivatives
14307 forward(nfwd) returns a cached instance if available, and calls  Function
14308 get_forward(casadi_int nfwd) if no cached version is available.
14309 
14310 ";
14311 
14312 %feature("docstring")  casadi::FunctionInternal::has_forward(casadi_int
14313 nfwd) const  "
14314 
14315 [INTERNAL]  Return function that calculates forward derivatives
14316 forward(nfwd) returns a cached instance if available, and calls  Function
14317 get_forward(casadi_int nfwd) if no cached version is available.
14318 
14319 ";
14320 
14321 %feature("docstring")  casadi::FunctionInternal::get_jacobian_sparsity()
14322 const  "
14323 
14324 [INTERNAL]  Get Jacobian sparsity.
14325 
14326 ";
14327 
14328 %feature("docstring")  casadi::FunctionInternal::tocache(const Function &f,
14329 const std::string &suffix="") const  "
14330 
14331 [INTERNAL]  Save function to cache.
14332 
14333 ";
14334 
14335 %feature("docstring")  casadi::FunctionInternal::wrap_as_needed(const Dict
14336 &opts) const  "
14337 
14338 [INTERNAL]  Wrap in an Function instance consisting of only one MX call.
14339 
14340 ";
14341 
14342 %feature("docstring")  casadi::ProtoFunction::print(const char *fmt,...)
14343 const  "
14344 
14345 [INTERNAL]  C-style formatted printing during evaluation.
14346 
14347 ";
14348 
14349 
14350 // File: classcasadi_1_1Constant.xml
14351 
14352 
14353 // File: classcasadi_1_1ConstantDM.xml
14354 
14355 
14356 // File: classcasadi_1_1ConstantFile.xml
14357 
14358 
14359 // File: classcasadi_1_1ConstantMX.xml
14360 
14361 
14362 // File: classcasadi_1_1ConstantSX.xml
14363 
14364 
14365 // File: classcasadi_1_1Convexify.xml
14366 
14367 
14368 // File: classcasadi_1_1DaeBuilder.xml
14369 
14370 
14371 /*  Variables and equations  */
14372 
14373 /* Public data members
14374 
14375 */
14376 
14377 /*  Symbolic modeling  */
14378 
14379 /* Formulate an optimal control problem
14380 
14381 */
14382 
14383 /*  Manipulation  */
14384 
14385 /* Reformulate the dynamic optimization problem.
14386 
14387 */
14388 
14389 /*  Functions  */
14390 
14391 /* Add or load auxiliary functions
14392 
14393 */
14394 
14395 /*  Import and export  */ %feature("docstring")
14396 casadi::DaeBuilder::add_s(const std::string &name=std::string(), casadi_int
14397 n=1) "
14398 
14399 Add a implicit state.
14400 
14401 ";
14402 
14403 %feature("docstring")  casadi::DaeBuilder::add_fun(const std::string &name,
14404 const std::vector< std::string > &arg, const std::vector< std::string >
14405 &res, const Dict &opts=Dict()) "
14406 
14407 Add a function from loaded expressions.
14408 
14409 ";
14410 
14411 %feature("docstring")  casadi::DaeBuilder::add_fun(const Function &f) "
14412 
14413 Add an already existing function.
14414 
14415 ";
14416 
14417 %feature("docstring")  casadi::DaeBuilder::add_fun(const std::string &name,
14418 const Importer &compiler, const Dict &opts=Dict()) "
14419 
14420 Add an external function.
14421 
14422 ";
14423 
14424 %feature("docstring")  casadi::DaeBuilder::sanity_check() const  "
14425 
14426 Check if dimensions match.
14427 
14428 ";
14429 
14430 %feature("docstring")  casadi::DaeBuilder::set_unit(const std::string &name,
14431 const std::string &val) "
14432 
14433 Set the unit for a component.
14434 
14435 ";
14436 
14437 %feature("docstring") casadi::DaeBuilder::DaeBuilder() "
14438 
14439 Default constructor.
14440 
14441 ";
14442 
14443 %feature("docstring")  casadi::DaeBuilder::sort_dae() "
14444 
14445 Sort the DAE and implicitly defined states.
14446 
14447 ";
14448 
14449 %feature("docstring")  casadi::DaeBuilder::start(const std::string &name,
14450 bool normalized=false) const  "
14451 
14452 Get the (optionally normalized) value at time 0 by name.
14453 
14454 ";
14455 
14456 %feature("docstring")  casadi::DaeBuilder::start(const MX &var, bool
14457 normalized=false) const  "
14458 
14459 Get the (optionally normalized) value(s) at time 0 by expression.
14460 
14461 ";
14462 
14463 %feature("docstring")  casadi::DaeBuilder::add_aux(const std::string
14464 &name=std::string(), casadi_int n=1) "
14465 
14466 Add an auxiliary variable.
14467 
14468 ";
14469 
14470 %feature("docstring")  casadi::DaeBuilder::min(const std::string &name, bool
14471 normalized=false) const  "
14472 
14473 Get the lower bound by name.
14474 
14475 ";
14476 
14477 %feature("docstring") casadi::casadi_min "
14478 
14479 Get the lower bound by name.
14480 
14481 ";
14482 
14483 %feature("docstring")  casadi::DaeBuilder::casadi_min "
14484 
14485 Get the lower bound by name.
14486 
14487 ";
14488 
14489 %feature("docstring")  casadi::DaeBuilder::min(const MX &var, bool
14490 normalized=false) const  "
14491 
14492 Get the lower bound(s) by expression.
14493 
14494 ";
14495 
14496 %feature("docstring") casadi::casadi_min "
14497 
14498 Get the lower bound(s) by expression.
14499 
14500 ";
14501 
14502 %feature("docstring")  casadi::DaeBuilder::casadi_min "
14503 
14504 Get the lower bound(s) by expression.
14505 
14506 ";
14507 
14508 %feature("docstring")  casadi::DaeBuilder::add_quad(const std::string &name,
14509 const MX &new_quad) "
14510 
14511 Add a quadrature equation.
14512 
14513 ";
14514 
14515 %feature("docstring")  casadi::DaeBuilder::nominal(const std::string &name)
14516 const  "
14517 
14518 Get the nominal value by name.
14519 
14520 ";
14521 
14522 %feature("docstring")  casadi::DaeBuilder::nominal(const MX &var) const  "
14523 
14524 Get the nominal value(s) by expression.
14525 
14526 ";
14527 
14528 %feature("docstring")  casadi::DaeBuilder::max(const std::string &name, bool
14529 normalized=false) const  "
14530 
14531 Get the upper bound by name.
14532 
14533 ";
14534 
14535 %feature("docstring") casadi::casadi_max "
14536 
14537 Get the upper bound by name.
14538 
14539 ";
14540 
14541 %feature("docstring")  casadi::DaeBuilder::casadi_max "
14542 
14543 Get the upper bound by name.
14544 
14545 ";
14546 
14547 %feature("docstring")  casadi::DaeBuilder::max(const MX &var, bool
14548 normalized=false) const  "
14549 
14550 Get the upper bound(s) by expression.
14551 
14552 ";
14553 
14554 %feature("docstring") casadi::casadi_max "
14555 
14556 Get the upper bound(s) by expression.
14557 
14558 ";
14559 
14560 %feature("docstring")  casadi::DaeBuilder::casadi_max "
14561 
14562 Get the upper bound(s) by expression.
14563 
14564 ";
14565 
14566 %feature("docstring")  casadi::DaeBuilder::make_semi_explicit() "
14567 
14568 Transform the implicit DAE to a semi-explicit DAE.
14569 
14570 ";
14571 
14572 %feature("docstring")  casadi::DaeBuilder::set_derivative_start(const
14573 std::string &name, double val, bool normalized=false) "
14574 
14575 Set the (optionally normalized) derivative value at time 0 by name.
14576 
14577 ";
14578 
14579 %feature("docstring")  casadi::DaeBuilder::set_derivative_start(const MX
14580 &var, const std::vector< double > &val, bool normalized=false) "
14581 
14582 Set the (optionally normalized) derivative value(s) at time 0 by expression.
14583 
14584 ";
14585 
14586 %feature("docstring")  casadi::DaeBuilder::add_lc(const std::string &name,
14587 const std::vector< std::string > &f_out) "
14588 
14589 Add a named linear combination of output expressions.
14590 
14591 ";
14592 
14593 %feature("docstring")  casadi::DaeBuilder::sort_d() "
14594 
14595 Sort dependent parameters.
14596 
14597 ";
14598 
14599 %feature("docstring")  casadi::DaeBuilder::sort_alg() "
14600 
14601 Sort the algebraic equations and algebraic states.
14602 
14603 ";
14604 
14605 %feature("docstring")  casadi::DaeBuilder::fun(const std::string &name)
14606 const  "
14607 
14608 Get function by name.
14609 
14610 ";
14611 
14612 %feature("docstring")  casadi::DaeBuilder::add_dae(const std::string &name,
14613 const MX &new_dae) "
14614 
14615 Add a differential-algebraic equation.
14616 
14617 ";
14618 
14619 %feature("docstring")  casadi::DaeBuilder::make_explicit() "
14620 
14621 Transform the implicit DAE or semi-explicit DAE into an explicit ODE.
14622 
14623 ";
14624 
14625 %feature("docstring") casadi::DaeBuilder "
14626 
14627 An initial-value problem in differential-algebraic equations.
14628 
14629 Independent variables:
14630 ======================
14631 
14632 
14633 
14634 
14635 
14636 ::
14637 
14638   t:      time
14639 
14640 
14641 
14642 
14643 Time-continuous variables:
14644 ==========================
14645 
14646 
14647 
14648 
14649 
14650 ::
14651 
14652   x:      states defined by ODE
14653   s:      implicitly defined states
14654   z:      algebraic variables
14655   u:      control signals
14656   q:      quadrature states
14657   y:      outputs
14658 
14659 
14660 
14661 
14662 Time-constant variables:
14663 ========================
14664 
14665 
14666 
14667 
14668 
14669 ::
14670 
14671   p:      free parameters
14672   d:      dependent parameters
14673 
14674 
14675 
14676 
14677 Dynamic constraints (imposed everywhere):
14678 =========================================
14679 
14680 
14681 
14682 
14683 
14684 ::
14685 
14686   ODE                    \\\\dot{x} ==  ode(t, x, s, z, u, p, d)
14687   DAE or implicit ODE:         0 ==  dae(t, x, s, z, u, p, d, sdot)
14688   algebraic equations:         0 ==  alg(t, x, s, z, u, p, d)
14689   quadrature equations:  \\\\dot{q} == quad(t, x, s, z, u, p, d)
14690   dependent parameters:        d == ddef(t, x, s, z, u, p, d)
14691   output equations:            y == ydef(t, x, s, z, u, p, d)
14692 
14693 
14694 
14695 
14696 Point constraints (imposed pointwise):
14697 ======================================
14698 
14699 
14700 
14701 
14702 
14703 ::
14704 
14705   Initial equations:           0 == init(t, x, s, z, u, p, d, sdot)
14706 
14707 
14708 
14709 
14710 Joel Andersson
14711 
14712 C++ includes: dae_builder.hpp ";
14713 
14714 %feature("docstring")  casadi::DaeBuilder::add_q(const std::string
14715 &name=std::string(), casadi_int n=1) "
14716 
14717 Add a new quadrature state.
14718 
14719 ";
14720 
14721 %feature("docstring")  casadi::DaeBuilder::add_p(const std::string
14722 &name=std::string(), casadi_int n=1) "
14723 
14724 Add a new parameter
14725 
14726 ";
14727 
14728 %feature("docstring")  casadi::DaeBuilder::var(const std::string &name)
14729 const  "
14730 
14731 Get variable expression by name.
14732 
14733 ";
14734 
14735 %feature("docstring")  casadi::DaeBuilder::add_u(const std::string
14736 &name=std::string(), casadi_int n=1) "
14737 
14738 Add a new control.
14739 
14740 ";
14741 
14742 %feature("docstring")  casadi::DaeBuilder::has_fun(const std::string &name)
14743 const  "
14744 
14745 Does a particular function already exist?
14746 
14747 ";
14748 
14749 %feature("docstring")  casadi::DaeBuilder::add_z(const std::string
14750 &name=std::string(), casadi_int n=1) "
14751 
14752 Add a new algebraic variable.
14753 
14754 ";
14755 
14756 %feature("docstring")  casadi::DaeBuilder::add_y(const std::string &name,
14757 const MX &new_ydef) "
14758 
14759 Add a new output.
14760 
14761 ";
14762 
14763 %feature("docstring")  casadi::DaeBuilder::add_x(const std::string
14764 &name=std::string(), casadi_int n=1) "
14765 
14766 Add a new differential state.
14767 
14768 ";
14769 
14770 %feature("docstring")  casadi::DaeBuilder::eliminate_quad() "
14771 
14772 Eliminate quadrature states and turn them into ODE states.
14773 
14774 ";
14775 
14776 %feature("docstring")  casadi::DaeBuilder::derivative_start(const
14777 std::string &name, bool normalized=false) const  "
14778 
14779 Get the (optionally normalized) derivative value at time 0 by name.
14780 
14781 ";
14782 
14783 %feature("docstring")  casadi::DaeBuilder::derivative_start(const MX &var,
14784 bool normalized=false) const  "
14785 
14786 Get the (optionally normalized) derivative value(s) at time 0 by expression.
14787 
14788 ";
14789 
14790 %feature("docstring")  casadi::DaeBuilder::set_nominal(const std::string
14791 &name, double val) "
14792 
14793 Set the nominal value by name.
14794 
14795 ";
14796 
14797 %feature("docstring")  casadi::DaeBuilder::set_nominal(const MX &var, const
14798 std::vector< double > &val) "
14799 
14800 Set the nominal value(s) by expression.
14801 
14802 ";
14803 
14804 %feature("docstring")  casadi::DaeBuilder::parse_fmi(const std::string
14805 &filename) "
14806 
14807 Import existing problem from FMI/XML
14808 
14809 ";
14810 
14811 %feature("docstring")  casadi::DaeBuilder::add_variable(const std::string
14812 &name, const Variable &var) "
14813 
14814 Add a variable.
14815 
14816 ";
14817 
14818 %feature("docstring")  casadi::DaeBuilder::add_variable(const std::string
14819 &name, casadi_int n=1) "
14820 
14821 Add a new variable: returns corresponding symbolic expression.
14822 
14823 ";
14824 
14825 %feature("docstring")  casadi::DaeBuilder::add_variable(const std::string
14826 &name, const Sparsity &sp) "
14827 
14828 Add a new variable: returns corresponding symbolic expression.
14829 
14830 ";
14831 
14832 %feature("docstring")  casadi::DaeBuilder::add_d(const std::string &name,
14833 const MX &new_ddef) "
14834 
14835 Add a new dependent parameter.
14836 
14837 ";
14838 
14839 %feature("docstring")  casadi::DaeBuilder::split_dae() "
14840 
14841 Identify and separate the algebraic variables and equations in the DAE.
14842 
14843 ";
14844 
14845 %feature("docstring")  casadi::DaeBuilder::set_guess(const std::string
14846 &name, double val, bool normalized=false) "
14847 
14848 Set the initial guess by name.
14849 
14850 ";
14851 
14852 %feature("docstring")  casadi::DaeBuilder::set_guess(const MX &var, const
14853 std::vector< double > &val, bool normalized=false) "
14854 
14855 Set the initial guess(es) by expression.
14856 
14857 ";
14858 
14859 %feature("docstring")  casadi::DaeBuilder::add_alg(const std::string &name,
14860 const MX &new_alg) "
14861 
14862 Add an algebraic equation.
14863 
14864 ";
14865 
14866 %feature("docstring")  casadi::DaeBuilder::create(const std::string &fname,
14867 const std::vector< std::string > &s_in, const std::vector< std::string >
14868 &s_out) const  "
14869 
14870 Construct a function object.
14871 
14872 ";
14873 
14874 %feature("docstring")  casadi::DaeBuilder::guess(const std::string &name,
14875 bool normalized=false) const  "
14876 
14877 Get the initial guess by name.
14878 
14879 ";
14880 
14881 %feature("docstring")  casadi::DaeBuilder::guess(const MX &var, bool
14882 normalized=false) const  "
14883 
14884 Get the initial guess(es) by expression.
14885 
14886 ";
14887 
14888 %feature("docstring")  casadi::DaeBuilder::variable(const std::string &name)
14889 "
14890 
14891 Access a variable by name
14892 
14893 ";
14894 
14895 %feature("docstring")  casadi::DaeBuilder::variable(const std::string &name)
14896 const  "
14897 
14898 Access a variable by name
14899 
14900 ";
14901 
14902 %feature("docstring")  casadi::DaeBuilder::set_max(const std::string &name,
14903 double val, bool normalized=false) "
14904 
14905 Set the upper bound by name.
14906 
14907 ";
14908 
14909 %feature("docstring")  casadi::DaeBuilder::set_max(const MX &var, const
14910 std::vector< double > &val, bool normalized=false) "
14911 
14912 Set the upper bound(s) by expression.
14913 
14914 ";
14915 
14916 %feature("docstring")  casadi::DaeBuilder::eliminate_alg() "
14917 
14918 Eliminate algebraic variables and equations transforming them into outputs.
14919 
14920 ";
14921 
14922 %feature("docstring")  casadi::DaeBuilder::set_min(const std::string &name,
14923 double val, bool normalized=false) "
14924 
14925 Set the lower bound by name.
14926 
14927 ";
14928 
14929 %feature("docstring")  casadi::DaeBuilder::set_min(const MX &var, const
14930 std::vector< double > &val, bool normalized=false) "
14931 
14932 Set the lower bound(s) by expression.
14933 
14934 ";
14935 
14936 %feature("docstring")  casadi::DaeBuilder::set_start(const std::string
14937 &name, double val, bool normalized=false) "
14938 
14939 Set the (optionally normalized) value at time 0 by name.
14940 
14941 ";
14942 
14943 %feature("docstring")  casadi::DaeBuilder::set_start(const MX &var, const
14944 std::vector< double > &val, bool normalized=false) "
14945 
14946 Set the (optionally normalized) value(s) at time 0 by expression.
14947 
14948 ";
14949 
14950 %feature("docstring")  casadi::DaeBuilder::unit(const std::string &name)
14951 const  "
14952 
14953 Get the unit for a component.
14954 
14955 ";
14956 
14957 %feature("docstring")  casadi::DaeBuilder::unit(const MX &var) const  "
14958 
14959 Get the unit given a vector of symbolic variables (all units must be
14960 identical)
14961 
14962 ";
14963 
14964 %feature("docstring")  casadi::DaeBuilder::scale_variables() "
14965 
14966 Scale the variables.
14967 
14968 ";
14969 
14970 %feature("docstring")  casadi::DaeBuilder::split_d() "
14971 
14972 Eliminate interdependencies amongst dependent parameters.
14973 
14974 ";
14975 
14976 %feature("docstring")  casadi::DaeBuilder::eliminate_d() "
14977 
14978 Eliminate dependent parameters.
14979 
14980 ";
14981 
14982 %feature("docstring")  casadi::DaeBuilder::disp(std::ostream &stream, bool
14983 more=false) const  "
14984 
14985 Print representation.
14986 
14987 ";
14988 
14989 %feature("docstring")  casadi::DaeBuilder::der(const std::string &name)
14990 const  "
14991 
14992 Get a derivative expression by name.
14993 
14994 ";
14995 
14996 %feature("docstring")  casadi::DaeBuilder::der(const MX &var) const  "
14997 
14998 Get a derivative expression by non-differentiated expression.
14999 
15000 ";
15001 
15002 %feature("docstring")  casadi::DaeBuilder::type_name() const  "
15003 
15004 Readable name of the class.
15005 
15006 ";
15007 
15008 %feature("docstring")  casadi::DaeBuilder::scale_equations() "
15009 
15010 Scale the implicit equations.
15011 
15012 ";
15013 
15014 %feature("docstring")  casadi::DaeBuilder::get_str(bool more=false) const  "
15015 
15016 Get string representation.
15017 
15018 ";
15019 
15020 %feature("docstring")  casadi::DaeBuilder::add_ode(const std::string &name,
15021 const MX &new_ode) "
15022 
15023 Add an ordinary differential equation.
15024 
15025 ";
15026 
15027 
15028 // File: classcasadi_1_1DenseMultiplication.xml
15029 
15030 
15031 // File: classcasadi_1_1DenseTranspose.xml
15032 
15033 
15034 // File: classcasadi_1_1Densify.xml
15035 
15036 
15037 // File: classcasadi_1_1DeserializerBase.xml
15038 %feature("docstring") casadi::DeserializerBase "
15039 
15040 C++ includes: serializer.hpp ";
15041 
15042 
15043 // File: classcasadi_1_1DeserializingStream.xml
15044 %feature("docstring")
15045 casadi::DeserializingStream::DeserializingStream(std::istream &in_s) "
15046 
15047 Constructor.
15048 
15049 ";
15050 
15051 %feature("docstring")  casadi::DeserializingStream::unpack(Sparsity &e) "
15052 
15053 Reconstruct an object from the input stream.
15054 
15055 If the reference is not of the same type as the object encoded in the
15056 stream. an error will be raised.
15057 
15058 ";
15059 
15060 %feature("docstring")  casadi::DeserializingStream::unpack(MX &e) "
15061 
15062 Reconstruct an object from the input stream.
15063 
15064 If the reference is not of the same type as the object encoded in the
15065 stream. an error will be raised.
15066 
15067 ";
15068 
15069 %feature("docstring")  casadi::DeserializingStream::unpack(SXElem &e) "
15070 
15071 Reconstruct an object from the input stream.
15072 
15073 If the reference is not of the same type as the object encoded in the
15074 stream. an error will be raised.
15075 
15076 ";
15077 
15078 %feature("docstring")  casadi::DeserializingStream::unpack(Linsol &e) "
15079 
15080 Reconstruct an object from the input stream.
15081 
15082 If the reference is not of the same type as the object encoded in the
15083 stream. an error will be raised.
15084 
15085 ";
15086 
15087 %feature("docstring")  casadi::DeserializingStream::unpack(MatrixCommon &e)
15088 "
15089 
15090 Reconstruct an object from the input stream.
15091 
15092 If the reference is not of the same type as the object encoded in the
15093 stream. an error will be raised.
15094 
15095 ";
15096 
15097 %feature("docstring")  casadi::DeserializingStream::unpack(Function &e) "
15098 
15099 Reconstruct an object from the input stream.
15100 
15101 If the reference is not of the same type as the object encoded in the
15102 stream. an error will be raised.
15103 
15104 ";
15105 
15106 %feature("docstring")  casadi::DeserializingStream::unpack(Importer &e) "
15107 
15108 Reconstruct an object from the input stream.
15109 
15110 If the reference is not of the same type as the object encoded in the
15111 stream. an error will be raised.
15112 
15113 ";
15114 
15115 %feature("docstring")  casadi::DeserializingStream::unpack(GenericType &e) "
15116 
15117 Reconstruct an object from the input stream.
15118 
15119 If the reference is not of the same type as the object encoded in the
15120 stream. an error will be raised.
15121 
15122 ";
15123 
15124 %feature("docstring")  casadi::DeserializingStream::unpack(std::ostream &s)
15125 "
15126 
15127 Reconstruct an object from the input stream.
15128 
15129 If the reference is not of the same type as the object encoded in the
15130 stream. an error will be raised.
15131 
15132 ";
15133 
15134 %feature("docstring")  casadi::DeserializingStream::unpack(Slice &e) "
15135 
15136 Reconstruct an object from the input stream.
15137 
15138 If the reference is not of the same type as the object encoded in the
15139 stream. an error will be raised.
15140 
15141 ";
15142 
15143 %feature("docstring")  casadi::DeserializingStream::unpack(int &e) "
15144 
15145 Reconstruct an object from the input stream.
15146 
15147 If the reference is not of the same type as the object encoded in the
15148 stream. an error will be raised.
15149 
15150 ";
15151 
15152 %feature("docstring")  casadi::DeserializingStream::unpack(bool &e) "
15153 
15154 Reconstruct an object from the input stream.
15155 
15156 If the reference is not of the same type as the object encoded in the
15157 stream. an error will be raised.
15158 
15159 ";
15160 
15161 %feature("docstring")  casadi::DeserializingStream::unpack(casadi_int &e) "
15162 
15163 Reconstruct an object from the input stream.
15164 
15165 If the reference is not of the same type as the object encoded in the
15166 stream. an error will be raised.
15167 
15168 ";
15169 
15170 %feature("docstring")  casadi::DeserializingStream::unpack(size_t &e) "
15171 
15172 Reconstruct an object from the input stream.
15173 
15174 If the reference is not of the same type as the object encoded in the
15175 stream. an error will be raised.
15176 
15177 ";
15178 
15179 %feature("docstring")  casadi::DeserializingStream::unpack(std::string &e) "
15180 
15181 Reconstruct an object from the input stream.
15182 
15183 If the reference is not of the same type as the object encoded in the
15184 stream. an error will be raised.
15185 
15186 ";
15187 
15188 %feature("docstring")  casadi::DeserializingStream::unpack(double &e) "
15189 
15190 Reconstruct an object from the input stream.
15191 
15192 If the reference is not of the same type as the object encoded in the
15193 stream. an error will be raised.
15194 
15195 ";
15196 
15197 %feature("docstring")  casadi::DeserializingStream::unpack(char &e) "
15198 
15199 Reconstruct an object from the input stream.
15200 
15201 If the reference is not of the same type as the object encoded in the
15202 stream. an error will be raised.
15203 
15204 ";
15205 
15206 %feature("docstring")  casadi::DeserializingStream::unpack(std::vector< T >
15207 &e) "
15208 
15209 Reconstruct an object from the input stream.
15210 
15211 If the reference is not of the same type as the object encoded in the
15212 stream. an error will be raised.
15213 
15214 ";
15215 
15216 %feature("docstring")  casadi::DeserializingStream::unpack(std::map< K, V >
15217 &e) "
15218 
15219 Reconstruct an object from the input stream.
15220 
15221 If the reference is not of the same type as the object encoded in the
15222 stream. an error will be raised.
15223 
15224 ";
15225 
15226 %feature("docstring")  casadi::DeserializingStream::unpack(std::pair< A, B >
15227 &e) "
15228 
15229 Reconstruct an object from the input stream.
15230 
15231 If the reference is not of the same type as the object encoded in the
15232 stream. an error will be raised.
15233 
15234 ";
15235 
15236 %feature("docstring")  casadi::DeserializingStream::unpack(const std::string
15237 &descr, T &e) "
15238 
15239 Reconstruct an object from the input stream.
15240 
15241 If the reference is not of the same type as the object encoded in the
15242 stream. an error will be raised.
15243 
15244 ";
15245 
15246 %feature("docstring") casadi::DeserializingStream "
15247 
15248 Helper class for Serialization.
15249 
15250 Joris Gillis
15251 
15252 C++ includes: serializing_stream.hpp ";
15253 
15254 
15255 // File: classcasadi_1_1Determinant.xml
15256 
15257 
15258 // File: classcasadi_1_1Diagcat.xml
15259 
15260 
15261 // File: classcasadi_1_1Diagsplit.xml
15262 
15263 
15264 // File: classcasadi_1_1DllLibrary.xml
15265 %feature("docstring")  casadi::ImporterInternal::plugin_name() const  "
15266 
15267 [INTERNAL]  Queery plugin name.
15268 
15269 ";
15270 
15271 %feature("docstring") casadi::DllLibrary::DllLibrary(const std::string
15272 &bin_name) "
15273 
15274 [INTERNAL] ";
15275 
15276 %feature("docstring")  casadi::DllLibrary::init_handle() "
15277 
15278 [INTERNAL] ";
15279 
15280 %feature("docstring")  casadi::SharedObjectInternal::getCount() const  "
15281 
15282 [INTERNAL]  Get the reference count.
15283 
15284 ";
15285 
15286 %feature("docstring")  casadi::DllLibrary::get_function(const std::string
15287 &symname)  "
15288 
15289 [INTERNAL]  Get a function pointer for numerical evaluation.
15290 
15291 ";
15292 
15293 %feature("docstring")  casadi::ImporterInternal::get_options() const  "
15294 
15295 [INTERNAL]  Options.
15296 
15297 ";
15298 
15299 %feature("docstring")  casadi::ImporterInternal::to_text(const std::string
15300 &cmd, casadi_int ind=-1) const  "
15301 
15302 [INTERNAL]  Get entry as a text.
15303 
15304 ";
15305 
15306 %feature("docstring")  casadi::SharedObjectInternal::weak() "
15307 
15308 [INTERNAL]  Get a weak reference to the object.
15309 
15310 ";
15311 
15312 %feature("docstring")  casadi::ImporterInternal::get_meta(const std::string
15313 &cmd, casadi_int ind=-1) const  "
15314 
15315 [INTERNAL]  Get entry as a text.
15316 
15317 ";
15318 
15319 %feature("docstring")  casadi::ImporterInternal::disp(std::ostream &stream,
15320 bool more) const  "
15321 
15322 [INTERNAL]  Print.
15323 
15324 ";
15325 
15326 %feature("docstring")
15327 casadi::ImporterInternal::serialize_body(SerializingStream &s) const  "
15328 
15329 [INTERNAL] ";
15330 
15331 %feature("docstring")  casadi::ImporterInternal::body(const std::string
15332 &symname) const  "
15333 
15334 [INTERNAL]  Get the function body, if inlined.
15335 
15336 ";
15337 
15338 %feature("docstring")  casadi::ImporterInternal::has_function(const
15339 std::string &symname) const  "
15340 
15341 [INTERNAL]  Get a function pointer for numerical evaluation.
15342 
15343 ";
15344 
15345 %feature("docstring")  casadi::ImporterInternal::construct(const Dict &opts)
15346 "
15347 
15348 [INTERNAL]  Construct Prepares the function for evaluation.
15349 
15350 ";
15351 
15352 %feature("docstring") casadi::DllLibrary "
15353 
15354 Dynamically linked library.
15355 
15356 Joel Andersson
15357 
15358 >List of available options
15359 
15360 +---------+---------+---------------------------------+--------------------+
15361 |   Id    |  Type   |           Description           |      Used in       |
15362 +=========+=========+=================================+====================+
15363 | verbose | OT_BOOL | Verbose evaluation  for         | casadi::DllLibrary |
15364 |         |         | debugging                       |                    |
15365 +---------+---------+---------------------------------+--------------------+
15366 
15367 Diagrams
15368 --------
15369 
15370 
15371 
15372 C++ includes: importer_internal.hpp ";
15373 
15374 %feature("docstring")  casadi::ImporterInternal::read_meta(std::istream
15375 &file, casadi_int &offset) "
15376 
15377 [INTERNAL]  Get meta information.
15378 
15379 ";
15380 
15381 %feature("docstring")  casadi::DllLibrary::class_name() const  "
15382 
15383 [INTERNAL]  Get type name.
15384 
15385 ";
15386 
15387 %feature("docstring")  casadi::ImporterInternal::init(const Dict &opts) "
15388 
15389 [INTERNAL]  Initialize.
15390 
15391 ";
15392 
15393 %feature("docstring") casadi::DllLibrary::~DllLibrary "
15394 
15395 [INTERNAL] ";
15396 
15397 %feature("docstring")  casadi::DllLibrary::finalize()  "
15398 
15399 [INTERNAL] ";
15400 
15401 %feature("docstring")  casadi::ImporterInternal::serialize(SerializingStream
15402 &s) const  "
15403 
15404 [INTERNAL] ";
15405 
15406 %feature("docstring")  casadi::DllLibrary::library() const  "
15407 
15408 [INTERNAL]  Get library name.
15409 
15410 ";
15411 
15412 %feature("docstring")  casadi::DllLibrary::can_have_meta() const  "
15413 
15414 [INTERNAL]  Can meta information be read?
15415 
15416 ";
15417 
15418 %feature("docstring")  casadi::ImporterInternal::read_external(const
15419 std::string &sym, bool inlined, std::istream &file, casadi_int &offset) "
15420 
15421 [INTERNAL]  Get an external function declaration.
15422 
15423 ";
15424 
15425 %feature("docstring")  casadi::ImporterInternal::inlined(const std::string
15426 &symname) const  "
15427 
15428 [INTERNAL] ";
15429 
15430 %feature("docstring")
15431 casadi::ImporterInternal::serialize_type(SerializingStream &s) const  "
15432 
15433 [INTERNAL] ";
15434 
15435 %feature("docstring")  casadi::ImporterInternal::has_meta(const std::string
15436 &cmd, casadi_int ind=-1) const  "
15437 
15438 [INTERNAL]  Does an entry exist?
15439 
15440 ";
15441 
15442 
15443 // File: classcasadi_1_1Dot.xml
15444 
15445 
15446 // File: classcasadi_1_1Dple.xml
15447 %feature("docstring")  casadi::FunctionInternal::sz_w() const  "
15448 
15449 [INTERNAL]  Get required length of w field.
15450 
15451 ";
15452 
15453 %feature("docstring")  casadi::FunctionInternal::eval(const double **arg,
15454 double **res, casadi_int *iw, double *w, void *mem) const  "
15455 
15456 [INTERNAL]  Evaluate numerically.
15457 
15458 ";
15459 
15460 %feature("docstring")  casadi::FunctionInternal::generate_lifted(Function
15461 &vdef_fcn, Function &vinit_fcn) const  "
15462 
15463 [INTERNAL]  Extract the functions needed for the Lifted Newton method.
15464 
15465 ";
15466 
15467 %feature("docstring")  casadi::ProtoFunction::checkout() const  "
15468 
15469 [INTERNAL]  Checkout a memory object.
15470 
15471 ";
15472 
15473 %feature("docstring")  casadi::FunctionInternal::fwdViaJac(casadi_int nfwd)
15474 const  "
15475 
15476 [INTERNAL]  Calculate derivatives by multiplying the full Jacobian and
15477 multiplying.
15478 
15479 ";
15480 
15481 %feature("docstring")  casadi::FunctionInternal::sx_in(casadi_int ind) const
15482 "
15483 
15484 [INTERNAL]  Get function input(s) and output(s)
15485 
15486 ";
15487 
15488 %feature("docstring")  casadi::FunctionInternal::sx_in() const  "
15489 
15490 [INTERNAL]  Get function input(s) and output(s)
15491 
15492 ";
15493 
15494 %feature("docstring")  casadi::FunctionInternal::get_function() const  "
15495 
15496 [INTERNAL] ";
15497 
15498 %feature("docstring")  casadi::FunctionInternal::get_function(const
15499 std::string &name) const  "
15500 
15501 [INTERNAL] ";
15502 
15503 %feature("docstring")  casadi::ProtoFunction::print(const char *fmt,...)
15504 const  "
15505 
15506 [INTERNAL]  C-style formatted printing during evaluation.
15507 
15508 ";
15509 
15510 %feature("docstring")  casadi::FunctionInternal::factory(const std::string
15511 &name, const std::vector< std::string > &s_in, const std::vector<
15512 std::string > &s_out, const Function::AuxOut &aux, const Dict &opts) const
15513 "
15514 
15515 [INTERNAL] ";
15516 
15517 %feature("docstring")  casadi::FunctionInternal::set_temp(void *mem, const
15518 double **arg, double **res, casadi_int *iw, double *w) const  "
15519 
15520 [INTERNAL]  Set the (temporary) work vectors.
15521 
15522 ";
15523 
15524 %feature("docstring")  casadi::FunctionInternal::sparsity_jac(casadi_int
15525 iind, casadi_int oind, bool compact, bool symmetric) const  "
15526 
15527 [INTERNAL]  Get, if necessary generate, the sparsity of a Jacobian block.
15528 
15529 ";
15530 
15531 %feature("docstring")  casadi::FunctionInternal::generate_options(bool
15532 is_temp=false) const  "
15533 
15534 [INTERNAL]  Reconstruct options dict.
15535 
15536 ";
15537 
15538 %feature("docstring")  casadi::FunctionInternal::forward(casadi_int nfwd)
15539 const  "
15540 
15541 [INTERNAL]  Return function that calculates forward derivatives
15542 forward(nfwd) returns a cached instance if available, and calls  Function
15543 get_forward(casadi_int nfwd) if no cached version is available.
15544 
15545 ";
15546 
15547 %feature("docstring")  casadi::FunctionInternal::getJacSparsity(casadi_int
15548 iind, casadi_int oind, bool symmetric) const  "
15549 
15550 [INTERNAL]  Generate the sparsity of a Jacobian block.
15551 
15552 ";
15553 
15554 %feature("docstring")  casadi::FunctionInternal::jit_dependencies(const
15555 std::string &fname) "
15556 
15557 [INTERNAL]  Jit dependencies.
15558 
15559 ";
15560 
15561 %feature("docstring")  casadi::FunctionInternal::sz_res() const  "
15562 
15563 [INTERNAL]  Get required length of res field.
15564 
15565 ";
15566 
15567 %feature("docstring")  casadi::FunctionInternal::convert_res(const
15568 std::vector< M > &res) const  "
15569 
15570 [INTERNAL]  Convert from/to input/output lists/map.
15571 
15572 ";
15573 
15574 %feature("docstring")  casadi::FunctionInternal::convert_res(const std::map<
15575 std::string, M > &res) const  "
15576 
15577 [INTERNAL]  Convert from/to input/output lists/map.
15578 
15579 ";
15580 
15581 %feature("docstring")  casadi::FunctionInternal::symbolic_output(const
15582 std::vector< MX > &arg) const  "
15583 
15584 [INTERNAL]  Get a vector of symbolic variables corresponding to the outputs.
15585 
15586 ";
15587 
15588 %feature("docstring") casadi::Dple "
15589 
15590 Internal class.
15591 
15592 >List of available options
15593 
15594 +------------------+-----------------+------------------+------------------+
15595 |        Id        |      Type       |   Description    |     Used in      |
15596 +==================+=================+==================+==================+
15597 | ad_weight        | OT_DOUBLE       | Weighting factor | casadi::Function |
15598 |                  |                 | for derivative   | Internal         |
15599 |                  |                 | calculation.When |                  |
15600 |                  |                 | there is an      |                  |
15601 |                  |                 | option of either |                  |
15602 |                  |                 | using forward or |                  |
15603 |                  |                 | reverse mode     |                  |
15604 |                  |                 | directional      |                  |
15605 |                  |                 | derivatives, the |                  |
15606 |                  |                 | condition ad_wei |                  |
15607 |                  |                 | ght*nf<=(1-ad_we |                  |
15608 |                  |                 | ight)*na is used |                  |
15609 |                  |                 | where nf and na  |                  |
15610 |                  |                 | are estimates of |                  |
15611 |                  |                 | the number of    |                  |
15612 |                  |                 | forward/reverse  |                  |
15613 |                  |                 | mode directional |                  |
15614 |                  |                 | derivatives      |                  |
15615 |                  |                 | needed. By       |                  |
15616 |                  |                 | default,         |                  |
15617 |                  |                 | ad_weight is     |                  |
15618 |                  |                 | calculated       |                  |
15619 |                  |                 | automatically,   |                  |
15620 |                  |                 | but this can be  |                  |
15621 |                  |                 | overridden by    |                  |
15622 |                  |                 | setting this     |                  |
15623 |                  |                 | option. In       |                  |
15624 |                  |                 | particular, 0    |                  |
15625 |                  |                 | means forcing    |                  |
15626 |                  |                 | forward mode and |                  |
15627 |                  |                 | 1 forcing        |                  |
15628 |                  |                 | reverse mode.    |                  |
15629 |                  |                 | Leave unset for  |                  |
15630 |                  |                 | (class specific) |                  |
15631 |                  |                 | heuristics.      |                  |
15632 +------------------+-----------------+------------------+------------------+
15633 | ad_weight_sp     | OT_DOUBLE       | Weighting factor | casadi::Function |
15634 |                  |                 | for sparsity     | Internal         |
15635 |                  |                 | pattern          |                  |
15636 |                  |                 | calculation calc |                  |
15637 |                  |                 | ulation.Override |                  |
15638 |                  |                 | s default        |                  |
15639 |                  |                 | behavior. Set to |                  |
15640 |                  |                 | 0 and 1 to force |                  |
15641 |                  |                 | forward and      |                  |
15642 |                  |                 | reverse mode     |                  |
15643 |                  |                 | respectively.    |                  |
15644 |                  |                 | Cf. option       |                  |
15645 |                  |                 | \"ad_weight\".     |                  |
15646 |                  |                 | When set to -1,  |                  |
15647 |                  |                 | sparsity is      |                  |
15648 |                  |                 | completely       |                  |
15649 |                  |                 | ignored and      |                  |
15650 |                  |                 | dense matrices   |                  |
15651 |                  |                 | are used.        |                  |
15652 +------------------+-----------------+------------------+------------------+
15653 | always_inline    | OT_BOOL         | Force inlining.  | casadi::Function |
15654 |                  |                 |                  | Internal         |
15655 +------------------+-----------------+------------------+------------------+
15656 | compiler         | OT_STRING       | Just-in-time     | casadi::Function |
15657 |                  |                 | compiler plugin  | Internal         |
15658 |                  |                 | to be used.      |                  |
15659 +------------------+-----------------+------------------+------------------+
15660 | const_dim        | OT_BOOL         | Assume constant  | casadi::Dple     |
15661 |                  |                 | dimension of P   |                  |
15662 +------------------+-----------------+------------------+------------------+
15663 | custom_jacobian  | OT_FUNCTION     | Override         | casadi::Function |
15664 |                  |                 | CasADi's AD. Use | Internal         |
15665 |                  |                 | together with    |                  |
15666 |                  |                 | 'jac_penalty':   |                  |
15667 |                  |                 | 0. Note: Highly  |                  |
15668 |                  |                 | experimental.    |                  |
15669 |                  |                 | Syntax may break |                  |
15670 |                  |                 | often.           |                  |
15671 +------------------+-----------------+------------------+------------------+
15672 | derivative_of    | OT_FUNCTION     | The function is  | casadi::Function |
15673 |                  |                 | a derivative of  | Internal         |
15674 |                  |                 | another          |                  |
15675 |                  |                 | function. The    |                  |
15676 |                  |                 | type of          |                  |
15677 |                  |                 | derivative       |                  |
15678 |                  |                 | (directional     |                  |
15679 |                  |                 | derivative,      |                  |
15680 |                  |                 | Jacobian) is     |                  |
15681 |                  |                 | inferred from    |                  |
15682 |                  |                 | the function     |                  |
15683 |                  |                 | name.            |                  |
15684 +------------------+-----------------+------------------+------------------+
15685 | dump             | OT_BOOL         | Dump function to | casadi::Function |
15686 |                  |                 | file upon first  | Internal         |
15687 |                  |                 | evaluation.      |                  |
15688 |                  |                 | [false]          |                  |
15689 +------------------+-----------------+------------------+------------------+
15690 | dump_dir         | OT_STRING       | Directory to     | casadi::Function |
15691 |                  |                 | dump             | Internal         |
15692 |                  |                 | inputs/outputs   |                  |
15693 |                  |                 | to. Make sure    |                  |
15694 |                  |                 | the directory    |                  |
15695 |                  |                 | exists [.]       |                  |
15696 +------------------+-----------------+------------------+------------------+
15697 | dump_format      | OT_STRING       | Choose file      | casadi::Function |
15698 |                  |                 | format to dump   | Internal         |
15699 |                  |                 | matrices. See    |                  |
15700 |                  |                 | DM.from_file     |                  |
15701 |                  |                 | [mtx]            |                  |
15702 +------------------+-----------------+------------------+------------------+
15703 | dump_in          | OT_BOOL         | Dump numerical   | casadi::Function |
15704 |                  |                 | values of inputs | Internal         |
15705 |                  |                 | to file          |                  |
15706 |                  |                 | (readable with   |                  |
15707 |                  |                 | DM.from_file )   |                  |
15708 |                  |                 | [default: false] |                  |
15709 +------------------+-----------------+------------------+------------------+
15710 | dump_out         | OT_BOOL         | Dump numerical   | casadi::Function |
15711 |                  |                 | values of        | Internal         |
15712 |                  |                 | outputs to file  |                  |
15713 |                  |                 | (readable with   |                  |
15714 |                  |                 | DM.from_file )   |                  |
15715 |                  |                 | [default: false] |                  |
15716 +------------------+-----------------+------------------+------------------+
15717 | enable_fd        | OT_BOOL         | Enable           | casadi::Function |
15718 |                  |                 | derivative       | Internal         |
15719 |                  |                 | calculation by   |                  |
15720 |                  |                 | finite           |                  |
15721 |                  |                 | differencing.    |                  |
15722 |                  |                 | [default:        |                  |
15723 |                  |                 | false]]          |                  |
15724 +------------------+-----------------+------------------+------------------+
15725 | enable_forward   | OT_BOOL         | Enable           | casadi::Function |
15726 |                  |                 | derivative       | Internal         |
15727 |                  |                 | calculation      |                  |
15728 |                  |                 | using generated  |                  |
15729 |                  |                 | functions for    |                  |
15730 |                  |                 | Jacobian-times-  |                  |
15731 |                  |                 | vector products  |                  |
15732 |                  |                 | - typically      |                  |
15733 |                  |                 | using forward    |                  |
15734 |                  |                 | mode AD - if     |                  |
15735 |                  |                 | available.       |                  |
15736 |                  |                 | [default: true]  |                  |
15737 +------------------+-----------------+------------------+------------------+
15738 | enable_jacobian  | OT_BOOL         | Enable           | casadi::Function |
15739 |                  |                 | derivative       | Internal         |
15740 |                  |                 | calculation      |                  |
15741 |                  |                 | using generated  |                  |
15742 |                  |                 | functions for    |                  |
15743 |                  |                 | Jacobians of all |                  |
15744 |                  |                 | differentiable   |                  |
15745 |                  |                 | outputs with     |                  |
15746 |                  |                 | respect to all   |                  |
15747 |                  |                 | differentiable   |                  |
15748 |                  |                 | inputs - if      |                  |
15749 |                  |                 | available.       |                  |
15750 |                  |                 | [default: true]  |                  |
15751 +------------------+-----------------+------------------+------------------+
15752 | enable_reverse   | OT_BOOL         | Enable           | casadi::Function |
15753 |                  |                 | derivative       | Internal         |
15754 |                  |                 | calculation      |                  |
15755 |                  |                 | using generated  |                  |
15756 |                  |                 | functions for    |                  |
15757 |                  |                 | transposed       |                  |
15758 |                  |                 | Jacobian-times-  |                  |
15759 |                  |                 | vector products  |                  |
15760 |                  |                 | - typically      |                  |
15761 |                  |                 | using reverse    |                  |
15762 |                  |                 | mode AD - if     |                  |
15763 |                  |                 | available.       |                  |
15764 |                  |                 | [default: true]  |                  |
15765 +------------------+-----------------+------------------+------------------+
15766 | eps_unstable     | OT_DOUBLE       | A margin for     | casadi::Dple     |
15767 |                  |                 | unstability      |                  |
15768 |                  |                 | detection        |                  |
15769 +------------------+-----------------+------------------+------------------+
15770 | error_unstable   | OT_BOOL         | Throw an         | casadi::Dple     |
15771 |                  |                 | exception when   |                  |
15772 |                  |                 | it is detected   |                  |
15773 |                  |                 | that             |                  |
15774 |                  |                 | Product(A_i,     |                  |
15775 |                  |                 | i=N..1)has       |                  |
15776 |                  |                 | eigenvalues      |                  |
15777 |                  |                 | greater than     |                  |
15778 |                  |                 | 1-eps_unstable   |                  |
15779 +------------------+-----------------+------------------+------------------+
15780 | fd_method        | OT_STRING       | Method for       | casadi::Function |
15781 |                  |                 | finite           | Internal         |
15782 |                  |                 | differencing     |                  |
15783 |                  |                 | [default         |                  |
15784 |                  |                 | 'central']       |                  |
15785 +------------------+-----------------+------------------+------------------+
15786 | fd_options       | OT_DICT         | Options to be    | casadi::Function |
15787 |                  |                 | passed to the    | Internal         |
15788 |                  |                 | finite           |                  |
15789 |                  |                 | difference       |                  |
15790 |                  |                 | instance         |                  |
15791 +------------------+-----------------+------------------+------------------+
15792 | forward_options  | OT_DICT         | Options to be    | casadi::Function |
15793 |                  |                 | passed to a      | Internal         |
15794 |                  |                 | forward mode     |                  |
15795 |                  |                 | constructor      |                  |
15796 +------------------+-----------------+------------------+------------------+
15797 | gather_stats     | OT_BOOL         | Deprecated       | casadi::Function |
15798 |                  |                 | option           | Internal         |
15799 |                  |                 | (ignored):       |                  |
15800 |                  |                 | Statistics are   |                  |
15801 |                  |                 | now always       |                  |
15802 |                  |                 | collected.       |                  |
15803 +------------------+-----------------+------------------+------------------+
15804 | input_scheme     | OT_STRINGVECTOR | Deprecated       | casadi::Function |
15805 |                  |                 | option (ignored) | Internal         |
15806 +------------------+-----------------+------------------+------------------+
15807 | inputs_check     | OT_BOOL         | Throw exceptions | casadi::Function |
15808 |                  |                 | when the         | Internal         |
15809 |                  |                 | numerical values |                  |
15810 |                  |                 | of the inputs    |                  |
15811 |                  |                 | don't make sense |                  |
15812 +------------------+-----------------+------------------+------------------+
15813 | is_diff_in       | OT_BOOLVECTOR   | Indicate for     | casadi::Function |
15814 |                  |                 | each input if it | Internal         |
15815 |                  |                 | should be        |                  |
15816 |                  |                 | differentiable.  |                  |
15817 +------------------+-----------------+------------------+------------------+
15818 | is_diff_out      | OT_BOOLVECTOR   | Indicate for     | casadi::Function |
15819 |                  |                 | each output if   | Internal         |
15820 |                  |                 | it should be     |                  |
15821 |                  |                 | differentiable.  |                  |
15822 +------------------+-----------------+------------------+------------------+
15823 | jac_penalty      | OT_DOUBLE       | When requested   | casadi::Function |
15824 |                  |                 | for a number of  | Internal         |
15825 |                  |                 | forward/reverse  |                  |
15826 |                  |                 | directions, it   |                  |
15827 |                  |                 | may be cheaper   |                  |
15828 |                  |                 | to compute first |                  |
15829 |                  |                 | the full         |                  |
15830 |                  |                 | jacobian and     |                  |
15831 |                  |                 | then multiply    |                  |
15832 |                  |                 | with seeds,      |                  |
15833 |                  |                 | rather than      |                  |
15834 |                  |                 | obtain the       |                  |
15835 |                  |                 | requested        |                  |
15836 |                  |                 | directions in a  |                  |
15837 |                  |                 | straightforward  |                  |
15838 |                  |                 | manner. Casadi   |                  |
15839 |                  |                 | uses a heuristic |                  |
15840 |                  |                 | to decide which  |                  |
15841 |                  |                 | is cheaper. A    |                  |
15842 |                  |                 | high value of    |                  |
15843 |                  |                 | 'jac_penalty'    |                  |
15844 |                  |                 | makes it less    |                  |
15845 |                  |                 | likely for the   |                  |
15846 |                  |                 | heurstic to      |                  |
15847 |                  |                 | chose the full   |                  |
15848 |                  |                 | Jacobian         |                  |
15849 |                  |                 | strategy. The    |                  |
15850 |                  |                 | special value -1 |                  |
15851 |                  |                 | indicates never  |                  |
15852 |                  |                 | to use the full  |                  |
15853 |                  |                 | Jacobian         |                  |
15854 |                  |                 | strategy         |                  |
15855 +------------------+-----------------+------------------+------------------+
15856 | jit              | OT_BOOL         | Use just-in-time | casadi::Function |
15857 |                  |                 | compiler to      | Internal         |
15858 |                  |                 | speed up the     |                  |
15859 |                  |                 | evaluation       |                  |
15860 +------------------+-----------------+------------------+------------------+
15861 | jit_cleanup      | OT_BOOL         | Cleanup up the   | casadi::Function |
15862 |                  |                 | temporary source | Internal         |
15863 |                  |                 | file that jit    |                  |
15864 |                  |                 | creates.         |                  |
15865 |                  |                 | Default: true    |                  |
15866 +------------------+-----------------+------------------+------------------+
15867 | jit_name         | OT_STRING       | The file name    | casadi::Function |
15868 |                  |                 | used to write    | Internal         |
15869 |                  |                 | out code. The    |                  |
15870 |                  |                 | actual file      |                  |
15871 |                  |                 | names used       |                  |
15872 |                  |                 | depend on 'jit_t |                  |
15873 |                  |                 | emp_suffix' and  |                  |
15874 |                  |                 | include          |                  |
15875 |                  |                 | extensions.      |                  |
15876 |                  |                 | Default:         |                  |
15877 |                  |                 | 'jit_tmp'        |                  |
15878 +------------------+-----------------+------------------+------------------+
15879 | jit_options      | OT_DICT         | Options to be    | casadi::Function |
15880 |                  |                 | passed to the    | Internal         |
15881 |                  |                 | jit compiler.    |                  |
15882 +------------------+-----------------+------------------+------------------+
15883 | jit_serialize    | OT_STRING       | Specify          | casadi::Function |
15884 |                  |                 | behaviour when   | Internal         |
15885 |                  |                 | serializing a    |                  |
15886 |                  |                 | jitted function: |                  |
15887 |                  |                 | SOURCE|link|embe |                  |
15888 |                  |                 | d.               |                  |
15889 +------------------+-----------------+------------------+------------------+
15890 | jit_temp_suffix  | OT_BOOL         | Use a temporary  | casadi::Function |
15891 |                  |                 | (seemingly       | Internal         |
15892 |                  |                 | random) filename |                  |
15893 |                  |                 | suffix for       |                  |
15894 |                  |                 | generated code   |                  |
15895 |                  |                 | and libraries.   |                  |
15896 |                  |                 | This is desired  |                  |
15897 |                  |                 | for thread-      |                  |
15898 |                  |                 | safety. This     |                  |
15899 |                  |                 | behaviour may    |                  |
15900 |                  |                 | defeat caching   |                  |
15901 |                  |                 | compiler         |                  |
15902 |                  |                 | wrappers.        |                  |
15903 |                  |                 | Default: true    |                  |
15904 +------------------+-----------------+------------------+------------------+
15905 | max_num_dir      | OT_INT          | Specify the      | casadi::Function |
15906 |                  |                 | maximum number   | Internal         |
15907 |                  |                 | of directions    |                  |
15908 |                  |                 | for derivative   |                  |
15909 |                  |                 | functions.       |                  |
15910 |                  |                 | Overrules the    |                  |
15911 |                  |                 | builtin optimize |                  |
15912 |                  |                 | d_num_dir.       |                  |
15913 +------------------+-----------------+------------------+------------------+
15914 | never_inline     | OT_BOOL         | Forbid inlining. | casadi::Function |
15915 |                  |                 |                  | Internal         |
15916 +------------------+-----------------+------------------+------------------+
15917 | output_scheme    | OT_STRINGVECTOR | Deprecated       | casadi::Function |
15918 |                  |                 | option (ignored) | Internal         |
15919 +------------------+-----------------+------------------+------------------+
15920 | pos_def          | OT_BOOL         | Assume P         | casadi::Dple     |
15921 |                  |                 | positive         |                  |
15922 |                  |                 | definite         |                  |
15923 +------------------+-----------------+------------------+------------------+
15924 | print_in         | OT_BOOL         | Print numerical  | casadi::Function |
15925 |                  |                 | values of inputs | Internal         |
15926 |                  |                 | [default: false] |                  |
15927 +------------------+-----------------+------------------+------------------+
15928 | print_out        | OT_BOOL         | Print numerical  | casadi::Function |
15929 |                  |                 | values of        | Internal         |
15930 |                  |                 | outputs          |                  |
15931 |                  |                 | [default: false] |                  |
15932 +------------------+-----------------+------------------+------------------+
15933 | print_time       | OT_BOOL         | print            | casadi::Function |
15934 |                  |                 | information      | Internal         |
15935 |                  |                 | about execution  |                  |
15936 |                  |                 | time. Implies    |                  |
15937 |                  |                 | record_time.     |                  |
15938 +------------------+-----------------+------------------+------------------+
15939 | record_time      | OT_BOOL         | record           | casadi::Function |
15940 |                  |                 | information      | Internal         |
15941 |                  |                 | about execution  |                  |
15942 |                  |                 | time, for        |                  |
15943 |                  |                 | retrieval with   |                  |
15944 |                  |                 | stats().         |                  |
15945 +------------------+-----------------+------------------+------------------+
15946 | regularity_check | OT_BOOL         | Throw exceptions | casadi::Function |
15947 |                  |                 | when NaN or Inf  | Internal         |
15948 |                  |                 | appears during   |                  |
15949 |                  |                 | evaluation       |                  |
15950 +------------------+-----------------+------------------+------------------+
15951 | reverse_options  | OT_DICT         | Options to be    | casadi::Function |
15952 |                  |                 | passed to a      | Internal         |
15953 |                  |                 | reverse mode     |                  |
15954 |                  |                 | constructor      |                  |
15955 +------------------+-----------------+------------------+------------------+
15956 | user_data        | OT_VOIDPTR      | A user-defined   | casadi::Function |
15957 |                  |                 | field that can   | Internal         |
15958 |                  |                 | be used to       |                  |
15959 |                  |                 | identify the     |                  |
15960 |                  |                 | function or pass |                  |
15961 |                  |                 | additional       |                  |
15962 |                  |                 | information      |                  |
15963 +------------------+-----------------+------------------+------------------+
15964 | verbose          | OT_BOOL         | Verbose          | casadi::Function |
15965 |                  |                 | evaluation  for  | Internal         |
15966 |                  |                 | debugging        |                  |
15967 +------------------+-----------------+------------------+------------------+
15968 
15969 Diagrams
15970 --------
15971 
15972 
15973 
15974 C++ includes: dple_impl.hpp ";
15975 
15976 %feature("docstring")  casadi::FunctionInternal::n_nodes() const  "
15977 
15978 [INTERNAL]  Number of nodes in the algorithm.
15979 
15980 ";
15981 
15982 %feature("docstring")  casadi::FunctionInternal::replace_fseed(const
15983 std::vector< std::vector< M >> &fseed, casadi_int npar) const  "
15984 
15985 [INTERNAL]  Replace 0-by-0 forward seeds.
15986 
15987 ";
15988 
15989 %feature("docstring")  casadi::FunctionInternal::replace_fseed(const
15990 std::vector< std::vector< M > > &fseed, casadi_int npar) const  "
15991 
15992 [INTERNAL] ";
15993 
15994 %feature("docstring")  casadi::ProtoFunction::get_stats(void *mem) const  "
15995 
15996 [INTERNAL]  Get all statistics.
15997 
15998 ";
15999 
16000 %feature("docstring")
16001 casadi::FunctionInternal::codegen_decref(CodeGenerator &g) const  "
16002 
16003 [INTERNAL]  Codegen decref for dependencies.
16004 
16005 ";
16006 
16007 %feature("docstring")  casadi::FunctionInternal::eval_sx(const SXElem **arg,
16008 SXElem **res, casadi_int *iw, SXElem *w, void *mem) const  "
16009 
16010 [INTERNAL]  Evaluate with symbolic scalars.
16011 
16012 ";
16013 
16014 %feature("docstring")  casadi::FunctionInternal::generate_out(const
16015 std::string &fname, double **res) const  "
16016 
16017 [INTERNAL] ";
16018 
16019 %feature("docstring")  casadi::FunctionInternal::print_options(std::ostream
16020 &stream) const  "
16021 
16022 [INTERNAL]  Print list of options.
16023 
16024 ";
16025 
16026 %feature("docstring")  casadi::FunctionInternal::get_reltol() const  "
16027 
16028 [INTERNAL]  Get relative tolerance.
16029 
16030 ";
16031 
16032 %feature("docstring")
16033 casadi::FunctionInternal::codegen_declarations(CodeGenerator &g) const  "
16034 
16035 [INTERNAL]  Generate code for the declarations of the C function.
16036 
16037 ";
16038 
16039 %feature("docstring")  casadi::FunctionInternal::size1_out(casadi_int ind)
16040 const  "
16041 
16042 [INTERNAL]  Input/output dimensions.
16043 
16044 ";
16045 
16046 %feature("docstring")  casadi::FunctionInternal::instruction_id(casadi_int
16047 k) const  "
16048 
16049 [INTERNAL]  Get an atomic operation operator index.
16050 
16051 ";
16052 
16053 %feature("docstring")  casadi::FunctionInternal::nnz_out() const  "
16054 
16055 [INTERNAL]  Number of input/output nonzeros.
16056 
16057 ";
16058 
16059 %feature("docstring")  casadi::FunctionInternal::nnz_out(casadi_int ind)
16060 const  "
16061 
16062 [INTERNAL]  Number of input/output nonzeros.
16063 
16064 ";
16065 
16066 %feature("docstring")  casadi::FunctionInternal::has_jac() const  "
16067 
16068 [INTERNAL]  Return Jacobian of all input elements with respect to all output
16069 elements.
16070 
16071 ";
16072 
16073 %feature("docstring")  casadi::FunctionInternal::symbolicAdjSeed(casadi_int
16074 nadj, const std::vector< MatType > &v) const  "
16075 
16076 [INTERNAL]  Symbolic expressions for the adjoint seeds.
16077 
16078 ";
16079 
16080 %feature("docstring")  casadi::FunctionInternal::replace_aseed(const
16081 std::vector< std::vector< M >> &aseed, casadi_int npar) const  "
16082 
16083 [INTERNAL]  Replace 0-by-0 reverse seeds.
16084 
16085 ";
16086 
16087 %feature("docstring")  casadi::FunctionInternal::replace_aseed(const
16088 std::vector< std::vector< M > > &aseed, casadi_int npar) const  "
16089 
16090 [INTERNAL] ";
16091 
16092 %feature("docstring")  casadi::FunctionInternal::which_depends(const
16093 std::string &s_in, const std::vector< std::string > &s_out, casadi_int
16094 order, bool tr=false) const  "
16095 
16096 [INTERNAL]  Which variables enter with some order.
16097 
16098 Parameters:
16099 -----------
16100 
16101 s_in:   Input name
16102 
16103 s_out:   Output name(s)
16104 
16105 order:  Only 1 (linear) and 2 (nonlinear) allowed
16106 
16107 tr:  Flip the relationship. Return which expressions contain the variables
16108 
16109 ";
16110 
16111 %feature("docstring")  casadi::FunctionInternal::eval_dm(const std::vector<
16112 DM > &arg) const  "
16113 
16114 [INTERNAL]  Evaluate with DM matrices.
16115 
16116 ";
16117 
16118 %feature("docstring")  casadi::FunctionInternal::sparsity_in(casadi_int ind)
16119 const  "
16120 
16121 [INTERNAL]  Input/output sparsity.
16122 
16123 ";
16124 
16125 %feature("docstring")  casadi::SharedObjectInternal::weak() "
16126 
16127 [INTERNAL]  Get a weak reference to the object.
16128 
16129 ";
16130 
16131 %feature("docstring")  casadi::Dple::get_reverse(casadi_int nadj, const
16132 std::string &name, const std::vector< std::string > &inames, const
16133 std::vector< std::string > &onames, const Dict &opts) const  "
16134 
16135 [INTERNAL]  Generate a function that calculates nadj adjoint derivatives.
16136 
16137 ";
16138 
16139 %feature("docstring")  casadi::FunctionInternal::instruction_MX(casadi_int
16140 k) const  "
16141 
16142 [INTERNAL]  get MX expression associated with instruction
16143 
16144 ";
16145 
16146 %feature("docstring")  casadi::FunctionInternal::free_sx() const  "
16147 
16148 [INTERNAL]  Get free variables (SX)
16149 
16150 ";
16151 
16152 %feature("docstring")  casadi::FunctionInternal::call(const std::vector< M >
16153 &arg, std::vector< M > &res, bool always_inline, bool never_inline) const  "
16154 
16155 [INTERNAL]   Call a function, templated.
16156 
16157 ";
16158 
16159 %feature("docstring")  casadi::FunctionInternal::convert_arg(const
16160 std::vector< M > &arg) const  "
16161 
16162 [INTERNAL]  Convert from/to input/output lists/map.
16163 
16164 ";
16165 
16166 %feature("docstring")  casadi::FunctionInternal::convert_arg(const std::map<
16167 std::string, M > &arg) const  "
16168 
16169 [INTERNAL]  Convert from/to input/output lists/map.
16170 
16171 ";
16172 
16173 %feature("docstring")  casadi::FunctionInternal::index_out(const std::string
16174 &name) const  "
16175 
16176 [INTERNAL]  Get output scheme index by name.
16177 
16178 ";
16179 
16180 %feature("docstring")  casadi::FunctionInternal::get_max_in(casadi_int ind)
16181 const  "
16182 
16183 [INTERNAL]  Get largest input value.
16184 
16185 ";
16186 
16187 %feature("docstring")  casadi::ProtoFunction::alloc_mem() const  "
16188 
16189 [INTERNAL]  Create memory block.
16190 
16191 ";
16192 
16193 %feature("docstring")
16194 casadi::FunctionInternal::print_dimensions(std::ostream &stream) const  "
16195 
16196 [INTERNAL]  Print dimensions of inputs and outputs.
16197 
16198 ";
16199 
16200 %feature("docstring")  casadi::Dple::get_options() const  "
16201 
16202 [INTERNAL]  Options.
16203 
16204 ";
16205 
16206 %feature("docstring")
16207 casadi::FunctionInternal::serialize_body(SerializingStream &s) const  "
16208 
16209 [INTERNAL]  Serialize an object without type information.
16210 
16211 ";
16212 
16213 %feature("docstring")  casadi::FunctionInternal::definition() const  "
16214 
16215 [INTERNAL]  Get function signature: name:(inputs)->(outputs)
16216 
16217 ";
16218 
16219 %feature("docstring")
16220 casadi::FunctionInternal::codegen_init_mem(CodeGenerator &g) const  "
16221 
16222 [INTERNAL]  Codegen decref for init_mem.
16223 
16224 ";
16225 
16226 %feature("docstring")  casadi::FunctionInternal::codegen_mem_type() const  "
16227 
16228 [INTERNAL]  Thread-local memory object type.
16229 
16230 ";
16231 
16232 %feature("docstring")  casadi::Dple::get_forward(casadi_int nfwd, const
16233 std::string &name, const std::vector< std::string > &inames, const
16234 std::vector< std::string > &onames, const Dict &opts) const  "
16235 
16236 [INTERNAL]  Generate a function that calculates nfwd forward derivatives.
16237 
16238 ";
16239 
16240 %feature("docstring")  casadi::PluginInterface< Dple  >::plugin_name() const
16241 "
16242 
16243 [INTERNAL] ";
16244 
16245 %feature("docstring")  casadi::ProtoFunction::clear_mem() "
16246 
16247 [INTERNAL]  Clear all memory (called from destructor)
16248 
16249 ";
16250 
16251 %feature("docstring")  casadi::FunctionInternal::call_reverse(const
16252 std::vector< MX > &arg, const std::vector< MX > &res, const std::vector<
16253 std::vector< MX > > &aseed, std::vector< std::vector< MX > > &asens, bool
16254 always_inline, bool never_inline) const  "
16255 
16256 [INTERNAL]  Reverse mode, virtual functions overloaded in derived classes.
16257 
16258 ";
16259 
16260 %feature("docstring")  casadi::FunctionInternal::call_reverse(const
16261 std::vector< SX > &arg, const std::vector< SX > &res, const std::vector<
16262 std::vector< SX > > &aseed, std::vector< std::vector< SX > > &asens, bool
16263 always_inline, bool never_inline) const  "
16264 
16265 [INTERNAL]  Reverse mode, virtual functions overloaded in derived classes.
16266 
16267 ";
16268 
16269 %feature("docstring")  casadi::FunctionInternal::adjViaJac(casadi_int nadj)
16270 const  "
16271 
16272 [INTERNAL]  Calculate derivatives by multiplying the full Jacobian and
16273 multiplying.
16274 
16275 ";
16276 
16277 %feature("docstring")  casadi::FunctionInternal::dm_out(casadi_int ind)
16278 const  "
16279 
16280 [INTERNAL]  Get function input(s) and output(s)
16281 
16282 ";
16283 
16284 %feature("docstring")  casadi::FunctionInternal::dm_out() const  "
16285 
16286 [INTERNAL]  Get function input(s) and output(s)
16287 
16288 ";
16289 
16290 %feature("docstring") casadi::Dple::Dple(const std::string &name, const
16291 SpDict &st) "
16292 
16293 [INTERNAL] ";
16294 
16295 %feature("docstring")  casadi::FunctionInternal::nz_out(const std::vector<
16296 DM > &res) const  "
16297 
16298 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
16299 
16300 ";
16301 
16302 %feature("docstring")  casadi::FunctionInternal::nz_out(const std::vector<
16303 double > &res) const  "
16304 
16305 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
16306 
16307 ";
16308 
16309 %feature("docstring")  casadi::FunctionInternal::eval_gen(const double
16310 **arg, double **res, casadi_int *iw, double *w, void *mem) const  "
16311 
16312 [INTERNAL]  Evaluate numerically.
16313 
16314 ";
16315 
16316 %feature("docstring")  casadi::FunctionInternal::eval_gen(const SXElem
16317 **arg, SXElem **res, casadi_int *iw, SXElem *w, void *mem) const  "
16318 
16319 [INTERNAL]  Evaluate a function, overloaded.
16320 
16321 ";
16322 
16323 %feature("docstring")  casadi::FunctionInternal::eval_gen(const bvec_t
16324 **arg, bvec_t **res, casadi_int *iw, bvec_t *w, void *mem) const  "
16325 
16326 [INTERNAL]  Evaluate a function, overloaded.
16327 
16328 ";
16329 
16330 %feature("docstring")  casadi::FunctionInternal::getAdaptorSolverName()
16331 const  "
16332 
16333 [INTERNAL]  Obtain solver name from Adaptor.
16334 
16335 ";
16336 
16337 %feature("docstring")  casadi::FunctionInternal::get_jacobian(const
16338 std::string &name, const std::vector< std::string > &inames, const
16339 std::vector< std::string > &onames, const Dict &opts) const  "
16340 
16341 [INTERNAL]  Return Jacobian of all input elements with respect to all output
16342 elements.
16343 
16344 ";
16345 
16346 %feature("docstring")  casadi::ProtoFunction::construct(const Dict &opts) "
16347 
16348 [INTERNAL]  Construct Prepares the function for evaluation.
16349 
16350 ";
16351 
16352 %feature("docstring")  casadi::FunctionInternal::project_res(const
16353 std::vector< M > &arg, casadi_int npar) const  "
16354 
16355 [INTERNAL]   Project sparsities.
16356 
16357 ";
16358 
16359 %feature("docstring")  casadi::FunctionInternal::size_in(casadi_int ind)
16360 const  "
16361 
16362 [INTERNAL]  Input/output dimensions.
16363 
16364 ";
16365 
16366 %feature("docstring")
16367 casadi::FunctionInternal::codegen_alloc_mem(CodeGenerator &g) const  "
16368 
16369 [INTERNAL]  Codegen decref for alloc_mem.
16370 
16371 ";
16372 
16373 %feature("docstring")  casadi::FunctionInternal::check_res(const
16374 std::vector< M > &res, casadi_int &npar) const  "
16375 
16376 [INTERNAL]  Check if output arguments have correct length and dimensions.
16377 
16378 Raises errors.
16379 
16380 Parameters:
16381 -----------
16382 
16383 npar[in]:  normal usage: 1, disallow pararallel calls: -1
16384 
16385 npar:  max number of horizontal repetitions across all arguments (or -1)
16386 
16387 ";
16388 
16389 %feature("docstring")  casadi::FunctionInternal::set_work(void *mem, const
16390 double **&arg, double **&res, casadi_int *&iw, double *&w) const  "
16391 
16392 [INTERNAL]  Set the (persistent) work vectors.
16393 
16394 ";
16395 
16396 %feature("docstring")  casadi::FunctionInternal::info() const  "
16397 
16398 [INTERNAL]  Obtain information about function
16399 
16400 ";
16401 
16402 %feature("docstring")  casadi::Dple::get_sparsity_in(casadi_int i)  "
16403 
16404 [INTERNAL]  Sparsities of function inputs and outputs.
16405 
16406 ";
16407 
16408 %feature("docstring")  casadi::SharedObjectInternal::getCount() const  "
16409 
16410 [INTERNAL]  Get the reference count.
16411 
16412 ";
16413 
16414 %feature("docstring")  casadi::FunctionInternal::sz_arg() const  "
16415 
16416 [INTERNAL]  Get required length of arg field.
16417 
16418 ";
16419 
16420 %feature("docstring")  casadi::FunctionInternal::alloc_arg(size_t sz_arg,
16421 bool persistent=false) "
16422 
16423 [INTERNAL]  Ensure required length of arg field.
16424 
16425 ";
16426 
16427 %feature("docstring")  casadi::FunctionInternal::has_jacobian() const  "
16428 
16429 [INTERNAL]  Return Jacobian of all input elements with respect to all output
16430 elements.
16431 
16432 ";
16433 
16434 %feature("docstring")  casadi::FunctionInternal::has_codegen() const  "
16435 
16436 [INTERNAL]  Is codegen supported?
16437 
16438 ";
16439 
16440 %feature("docstring")  casadi::FunctionInternal::self() const  "
16441 
16442 [INTERNAL]  Get a public class instance.
16443 
16444 ";
16445 
16446 %feature("docstring")  casadi::FunctionInternal::get_default_in(casadi_int
16447 ind) const  "
16448 
16449 [INTERNAL]  Get default input value.
16450 
16451 ";
16452 
16453 %feature("docstring")  casadi::FunctionInternal::print_option(const
16454 std::string &name, std::ostream &stream) const  "
16455 
16456 [INTERNAL]  Print all information there is to know about a certain option.
16457 
16458 ";
16459 
16460 %feature("docstring")  casadi::Dple::get_name_in(casadi_int i)  "
16461 
16462 [INTERNAL]  Names of function input and outputs.
16463 
16464 ";
16465 
16466 %feature("docstring")  casadi::Dple::has_reverse(casadi_int nadj) const  "
16467 
16468 [INTERNAL]  Generate a function that calculates nadj adjoint derivatives.
16469 
16470 ";
16471 
16472 %feature("docstring")  casadi::FunctionInternal::dm_in(casadi_int ind) const
16473 "
16474 
16475 [INTERNAL]  Get function input(s) and output(s)
16476 
16477 ";
16478 
16479 %feature("docstring")  casadi::FunctionInternal::dm_in() const  "
16480 
16481 [INTERNAL]  Get function input(s) and output(s)
16482 
16483 ";
16484 
16485 %feature("docstring")  casadi::FunctionInternal::generate_in(const
16486 std::string &fname, const double **arg) const  "
16487 
16488 [INTERNAL]  Export an input file that can be passed to generate C code with
16489 a main.
16490 
16491 ";
16492 
16493 %feature("docstring")  casadi::ProtoFunction::free_mem(void *mem) const  "
16494 
16495 [INTERNAL]  Free memory block.
16496 
16497 ";
16498 
16499 %feature("docstring")  casadi::FunctionInternal::has_free() const  "
16500 
16501 [INTERNAL]  Does the function have free variables.
16502 
16503 ";
16504 
16505 %feature("docstring")  casadi::FunctionInternal::nnz_in() const  "
16506 
16507 [INTERNAL]  Number of input/output nonzeros.
16508 
16509 ";
16510 
16511 %feature("docstring")  casadi::FunctionInternal::nnz_in(casadi_int ind)
16512 const  "
16513 
16514 [INTERNAL]  Number of input/output nonzeros.
16515 
16516 ";
16517 
16518 %feature("docstring")  casadi::FunctionInternal::get_free() const  "
16519 
16520 [INTERNAL]  Print free variables.
16521 
16522 ";
16523 
16524 %feature("docstring")  casadi::FunctionInternal::sp_forward(const bvec_t
16525 **arg, bvec_t **res, casadi_int *iw, bvec_t *w, void *mem) const  "
16526 
16527 [INTERNAL]  Propagate sparsity forward.
16528 
16529 ";
16530 
16531 %feature("docstring")  casadi::FunctionInternal::nz_in(const std::vector< DM
16532 > &arg) const  "
16533 
16534 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
16535 
16536 ";
16537 
16538 %feature("docstring")  casadi::FunctionInternal::nz_in(const std::vector<
16539 double > &arg) const  "
16540 
16541 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
16542 
16543 ";
16544 
16545 %feature("docstring")  casadi::FunctionInternal::index_in(const std::string
16546 &name) const  "
16547 
16548 [INTERNAL]  Get input scheme index by name.
16549 
16550 ";
16551 
16552 %feature("docstring")  casadi::FunctionInternal::oracle() const  "
16553 
16554 [INTERNAL]  Get oracle.
16555 
16556 ";
16557 
16558 %feature("docstring")  casadi::FunctionInternal::setup(void *mem, const
16559 double **arg, double **res, casadi_int *iw, double *w) const  "
16560 
16561 [INTERNAL]  Set the (persistent and temporary) work vectors.
16562 
16563 ";
16564 
16565 %feature("docstring")  casadi::FunctionInternal::alloc_res(size_t sz_res,
16566 bool persistent=false) "
16567 
16568 [INTERNAL]  Ensure required length of res field.
16569 
16570 ";
16571 
16572 %feature("docstring")
16573 casadi::FunctionInternal::codegen_free_mem(CodeGenerator &g) const  "
16574 
16575 [INTERNAL]  Codegen for free_mem.
16576 
16577 ";
16578 
16579 %feature("docstring")  casadi::FunctionInternal::codegen_mem(CodeGenerator
16580 &g, const std::string &index="mem") const  "
16581 
16582 [INTERNAL]  Get thread-local memory object.
16583 
16584 ";
16585 
16586 %feature("docstring")  casadi::FunctionInternal::size_out(casadi_int ind)
16587 const  "
16588 
16589 [INTERNAL]  Input/output dimensions.
16590 
16591 ";
16592 
16593 %feature("docstring")  casadi::FunctionInternal::slice(const std::string
16594 &name, const std::vector< casadi_int > &order_in, const std::vector<
16595 casadi_int > &order_out, const Dict &opts) const  "
16596 
16597 [INTERNAL]  returns a new function with a selection of inputs/outputs of the
16598 original
16599 
16600 ";
16601 
16602 %feature("docstring")  casadi::FunctionInternal::codegen_meta(CodeGenerator
16603 &g) const  "
16604 
16605 [INTERNAL]  Generate meta-information allowing a user to evaluate a
16606 generated function.
16607 
16608 ";
16609 
16610 %feature("docstring")  casadi::FunctionInternal::has_sprev() const  "
16611 
16612 [INTERNAL]  Is the class able to propagate seeds through the algorithm?
16613 
16614 ";
16615 
16616 %feature("docstring")
16617 casadi::FunctionInternal::instruction_output(casadi_int k) const  "
16618 
16619 [INTERNAL]  Get the (integer) output argument of an atomic operation.
16620 
16621 ";
16622 
16623 %feature("docstring")  casadi::FunctionInternal::eval_mx(const MXVector
16624 &arg, MXVector &res, bool always_inline, bool never_inline) const  "
16625 
16626 [INTERNAL]  Evaluate with symbolic matrices.
16627 
16628 ";
16629 
16630 %feature("docstring")  casadi::FunctionInternal::sp_weight() const  "
16631 
16632 [INTERNAL]  Weighting factor for chosing forward/reverse mode, sparsity
16633 propagation.
16634 
16635 ";
16636 
16637 %feature("docstring")
16638 casadi::FunctionInternal::jacobian_sparsity_filter(const Sparsity &sp) const
16639 "
16640 
16641 [INTERNAL]  Filter out nonzeros in the full sparsity jacobian according to
16642 is_diff_in/out.
16643 
16644 ";
16645 
16646 %feature("docstring")  casadi::FunctionInternal::is_a(const std::string
16647 &type, bool recursive) const  "
16648 
16649 [INTERNAL]  Check if the function is of a particular type.
16650 
16651 ";
16652 
16653 %feature("docstring")  casadi::FunctionInternal::sparsity_out(casadi_int
16654 ind) const  "
16655 
16656 [INTERNAL]  Input/output sparsity.
16657 
16658 ";
16659 
16660 %feature("docstring")  casadi::FunctionInternal::incache(const std::string
16661 &fname, Function &f, const std::string &suffix="") const  "
16662 
16663 [INTERNAL]  Get function in cache.
16664 
16665 ";
16666 
16667 %feature("docstring")  casadi::ProtoFunction::format_time(char *buffer,
16668 double time) const  "
16669 
16670 [INTERNAL]  Format time in a fixed width 8 format.
16671 
16672 ";
16673 
16674 %feature("docstring")  casadi::Dple::has_forward(casadi_int nfwd) const  "
16675 
16676 [INTERNAL]  Generate a function that calculates nfwd forward derivatives.
16677 
16678 ";
16679 
16680 %feature("docstring")  casadi::FunctionInternal::n_instructions() const  "
16681 
16682 [INTERNAL]  Get the number of atomic operations.
16683 
16684 ";
16685 
16686 %feature("docstring")
16687 casadi::FunctionInternal::codegen_incref(CodeGenerator &g) const  "
16688 
16689 [INTERNAL]  Codegen incref for dependencies.
16690 
16691 ";
16692 
16693 %feature("docstring")  casadi::FunctionInternal::is_diff_out(casadi_int i) "
16694 
16695 [INTERNAL] ";
16696 
16697 %feature("docstring")  casadi::FunctionInternal::has_derivative() const  "
16698 
16699 [INTERNAL]  Can derivatives be calculated in any way?
16700 
16701 ";
16702 
16703 %feature("docstring")  casadi::FunctionInternal::get_jac(const std::string
16704 &name, const std::vector< std::string > &inames, const std::vector<
16705 std::string > &onames, const Dict &opts) const  "
16706 
16707 [INTERNAL]  Return Jacobian of all input elements with respect to all output
16708 elements.
16709 
16710 ";
16711 
16712 %feature("docstring")  casadi::FunctionInternal::sx_out(casadi_int ind)
16713 const  "
16714 
16715 [INTERNAL]  Get function input(s) and output(s)
16716 
16717 ";
16718 
16719 %feature("docstring")  casadi::FunctionInternal::sx_out() const  "
16720 
16721 [INTERNAL]  Get function input(s) and output(s)
16722 
16723 ";
16724 
16725 %feature("docstring")  casadi::FunctionInternal::replace_res(const
16726 std::vector< M > &res, casadi_int npar) const  "
16727 
16728 [INTERNAL]  Replace 0-by-0 outputs.
16729 
16730 ";
16731 
16732 %feature("docstring")  casadi::FunctionInternal::sz_iw() const  "
16733 
16734 [INTERNAL]  Get required length of iw field.
16735 
16736 ";
16737 
16738 %feature("docstring")  casadi::FunctionInternal::ad_weight() const  "
16739 
16740 [INTERNAL]  Weighting factor for chosing forward/reverse mode.
16741 
16742 ";
16743 
16744 %feature("docstring")  casadi::FunctionInternal::codegen_body(CodeGenerator
16745 &g) const  "
16746 
16747 [INTERNAL]  Generate code for the function body.
16748 
16749 ";
16750 
16751 %feature("docstring") casadi::Dple::~Dple "
16752 
16753 [INTERNAL] ";
16754 
16755 %feature("docstring")  casadi::FunctionInternal::numel_in() const  "
16756 
16757 [INTERNAL]  Number of input/output elements.
16758 
16759 ";
16760 
16761 %feature("docstring")  casadi::FunctionInternal::numel_in(casadi_int ind)
16762 const  "
16763 
16764 [INTERNAL]  Number of input/output elements.
16765 
16766 ";
16767 
16768 %feature("docstring")  casadi::FunctionInternal::sz_work(size_t &sz_arg,
16769 size_t &sz_res, size_t &sz_iw, size_t &sz_w) const  "
16770 
16771 [INTERNAL]  Get number of temporary variables needed.
16772 
16773 ";
16774 
16775 %feature("docstring")  casadi::FunctionInternal::get_abstol() const  "
16776 
16777 [INTERNAL]  Get absolute tolerance.
16778 
16779 ";
16780 
16781 %feature("docstring")  casadi::FunctionInternal::check_arg(const
16782 std::vector< M > &arg, casadi_int &npar) const  "
16783 
16784 [INTERNAL]  Check if input arguments have correct length and dimensions.
16785 
16786 Raises errors.
16787 
16788 Parameters:
16789 -----------
16790 
16791 npar[in]:  normal usage: 1, disallow pararallel calls: -1
16792 
16793 npar:  max number of horizontal repetitions across all arguments (or -1)
16794 
16795 ";
16796 
16797 %feature("docstring")  casadi::FunctionInternal::size1_in(casadi_int ind)
16798 const  "
16799 
16800 [INTERNAL]  Input/output dimensions.
16801 
16802 ";
16803 
16804 %feature("docstring")  casadi::FunctionInternal::uses_output() const  "
16805 
16806 [INTERNAL]  Do the derivative functions need nondifferentiated outputs?
16807 
16808 ";
16809 
16810 %feature("docstring")  casadi::Dple::get_sparsity_out(casadi_int i)  "
16811 
16812 [INTERNAL]  Sparsities of function inputs and outputs.
16813 
16814 ";
16815 
16816 %feature("docstring")  casadi::FunctionInternal::size2_out(casadi_int ind)
16817 const  "
16818 
16819 [INTERNAL]  Input/output dimensions.
16820 
16821 ";
16822 
16823 %feature("docstring")  casadi::FunctionInternal::map(casadi_int n, const
16824 std::string &parallelization) const  "
16825 
16826 [INTERNAL]  Generate/retrieve cached serial map.
16827 
16828 ";
16829 
16830 %feature("docstring")  casadi::FunctionInternal::mx_in(casadi_int ind) const
16831 "
16832 
16833 [INTERNAL]  Get function input(s) and output(s)
16834 
16835 ";
16836 
16837 %feature("docstring")  casadi::FunctionInternal::mx_in() const  "
16838 
16839 [INTERNAL]  Get function input(s) and output(s)
16840 
16841 ";
16842 
16843 %feature("docstring")  casadi::ProtoFunction::init_mem(void *mem) const  "
16844 
16845 [INTERNAL]  Initalize memory block.
16846 
16847 ";
16848 
16849 %feature("docstring")  casadi::ProtoFunction::print_time(const std::map<
16850 std::string, FStats > &fstats) const  "
16851 
16852 [INTERNAL]  Print timing statistics.
16853 
16854 ";
16855 
16856 %feature("docstring")  casadi::FunctionInternal::check_mat(const Sparsity
16857 &arg, const Sparsity &inp, casadi_int &npar) "
16858 
16859 [INTERNAL]  Helper function
16860 
16861 Parameters:
16862 -----------
16863 
16864 npar[in]:  normal usage: 1, disallow pararallel calls: -1
16865 
16866 npar[out]:  required number of parallel calls (or -1)
16867 
16868 ";
16869 
16870 %feature("docstring")  casadi::ProtoFunction::release(int mem) const  "
16871 
16872 [INTERNAL]  Release a memory object.
16873 
16874 ";
16875 
16876 %feature("docstring")  casadi::FunctionInternal::generate_dependencies(const
16877 std::string &fname, const Dict &opts) const  "
16878 
16879 [INTERNAL]  Export / Generate C code for the dependency function.
16880 
16881 ";
16882 
16883 %feature("docstring")  casadi::FunctionInternal::numel_out(casadi_int ind)
16884 const  "
16885 
16886 [INTERNAL]  Number of input/output elements.
16887 
16888 ";
16889 
16890 %feature("docstring")  casadi::FunctionInternal::numel_out() const  "
16891 
16892 [INTERNAL]  Number of input/output elements.
16893 
16894 ";
16895 
16896 %feature("docstring")
16897 casadi::FunctionInternal::instruction_input(casadi_int k) const  "
16898 
16899 [INTERNAL]  Get the (integer) input arguments of an atomic operation.
16900 
16901 ";
16902 
16903 %feature("docstring")  casadi::FunctionInternal::alloc_iw(size_t sz_iw, bool
16904 persistent=false) "
16905 
16906 [INTERNAL]  Ensure required length of iw field.
16907 
16908 ";
16909 
16910 %feature("docstring")  casadi::ProtoFunction::memory(int ind) const  "
16911 
16912 [INTERNAL]  Memory objects.
16913 
16914 ";
16915 
16916 %feature("docstring")  casadi::FunctionInternal::reverse(casadi_int nadj)
16917 const  "
16918 
16919 [INTERNAL]  Return function that calculates adjoint derivatives
16920 reverse(nadj) returns a cached instance if available, and calls  Function
16921 get_reverse(casadi_int nadj) if no cached version is available.
16922 
16923 ";
16924 
16925 %feature("docstring")  casadi::FunctionInternal::has_eval_dm() const  "
16926 
16927 [INTERNAL]  Evaluate with DM matrices.
16928 
16929 ";
16930 
16931 %feature("docstring")
16932 casadi::FunctionInternal::getJacSparsityHierarchical(casadi_int iind,
16933 casadi_int oind) const  "
16934 
16935 [INTERNAL]  A flavor of getJacSparsity that does hierarchical block
16936 structure recognition.
16937 
16938 ";
16939 
16940 %feature("docstring")
16941 casadi::FunctionInternal::instruction_constant(casadi_int k) const  "
16942 
16943 [INTERNAL]  Get the floating point output argument of an atomic operation.
16944 
16945 ";
16946 
16947 %feature("docstring")  casadi::FunctionInternal::instructions_sx() const  "
16948 
16949 [INTERNAL]  get SX expression associated with instructions
16950 
16951 ";
16952 
16953 %feature("docstring")  casadi::FunctionInternal::matching_res(const
16954 std::vector< M > &arg, casadi_int &npar) const  "
16955 
16956 [INTERNAL]  Check if output arguments that needs to be replaced.
16957 
16958 Raises errors
16959 
16960 Parameters:
16961 -----------
16962 
16963 npar[in]:  normal usage: 1, disallow pararallel calls: -1
16964 
16965 npar:  max number of horizontal repetitions across all arguments (or -1)
16966 
16967 ";
16968 
16969 %feature("docstring")  casadi::Dple::get_name_out(casadi_int i)  "
16970 
16971 [INTERNAL]  Names of function input and outputs.
16972 
16973 ";
16974 
16975 %feature("docstring")  casadi::FunctionInternal::codegen(CodeGenerator &g,
16976 const std::string &fname) const  "
16977 
16978 [INTERNAL]  Generate code the function.
16979 
16980 ";
16981 
16982 %feature("docstring")  casadi::FunctionInternal::get_min_in(casadi_int ind)
16983 const  "
16984 
16985 [INTERNAL]  Get smallest input value.
16986 
16987 ";
16988 
16989 %feature("docstring")  casadi::FunctionInternal::alloc(const Function &f,
16990 bool persistent=false) "
16991 
16992 [INTERNAL]  Ensure work vectors long enough to evaluate function.
16993 
16994 ";
16995 
16996 %feature("docstring")  casadi::FunctionInternal::jac() const  "
16997 
16998 [INTERNAL]  Return Jacobian of all input elements with respect to all output
16999 elements.
17000 
17001 ";
17002 
17003 %feature("docstring")  casadi::FunctionInternal::mx_out(casadi_int ind)
17004 const  "
17005 
17006 [INTERNAL]  Get function input(s) and output(s)
17007 
17008 ";
17009 
17010 %feature("docstring")  casadi::FunctionInternal::mx_out() const  "
17011 
17012 [INTERNAL]  Get function input(s) and output(s)
17013 
17014 ";
17015 
17016 %feature("docstring")  casadi::FunctionInternal::finalize()  "
17017 
17018 [INTERNAL]  Finalize the object creation.
17019 
17020 ";
17021 
17022 %feature("docstring")  casadi::FunctionInternal::has_jacobian_sparsity()
17023 const  "
17024 
17025 [INTERNAL]  Get Jacobian sparsity.
17026 
17027 ";
17028 
17029 %feature("docstring")  casadi::FunctionInternal::get_partition(casadi_int
17030 iind, casadi_int oind, Sparsity &D1, Sparsity &D2, bool compact, bool
17031 symmetric, bool allow_forward, bool allow_reverse) const  "
17032 
17033 [INTERNAL]  Get the unidirectional or bidirectional partition.
17034 
17035 ";
17036 
17037 %feature("docstring")  casadi::FunctionInternal::wrap() const  "
17038 
17039 [INTERNAL]  Wrap in an Function instance consisting of only one MX call.
17040 
17041 ";
17042 
17043 %feature("docstring")
17044 casadi::FunctionInternal::getJacSparsityHierarchicalSymm(casadi_int iind,
17045 casadi_int oind) const  "
17046 
17047 [INTERNAL]  A flavor of getJacSparsity that does hierarchical block
17048 structure recognition for symmetric Jacobians
17049 
17050 ";
17051 
17052 %feature("docstring")  casadi::ProtoFunction::serialize_base_function()
17053 const  "
17054 
17055 [INTERNAL]  String used to identify the immediate FunctionInternal subclass.
17056 
17057 ";
17058 
17059 %feature("docstring")  casadi::FunctionInternal::alloc_w(size_t sz_w, bool
17060 persistent=false) "
17061 
17062 [INTERNAL]  Ensure required length of w field.
17063 
17064 ";
17065 
17066 %feature("docstring")  casadi::Dple::init(const Dict &opts)  "
17067 
17068 [INTERNAL]  Initialize Initialize and make the object ready for setting
17069 arguments and evaluation. This method is typically called after setting
17070 options but before evaluating. If passed to another class (in the
17071 constructor), this class should invoke this function when initialized.
17072 
17073 ";
17074 
17075 %feature("docstring")  casadi::ProtoFunction::serialize(SerializingStream
17076 &s) const  "
17077 
17078 [INTERNAL]  Serialize an object.
17079 
17080 ";
17081 
17082 %feature("docstring")  casadi::Dple::get_n_out()  "
17083 
17084 [INTERNAL]  Number of function inputs and outputs.
17085 
17086 ";
17087 
17088 %feature("docstring")  casadi::FunctionInternal::get_jacobian_sparsity()
17089 const  "
17090 
17091 [INTERNAL]  Get Jacobian sparsity.
17092 
17093 ";
17094 
17095 %feature("docstring")  casadi::FunctionInternal::disp(std::ostream &stream,
17096 bool more) const  "
17097 
17098 [INTERNAL]  Display object.
17099 
17100 ";
17101 
17102 %feature("docstring")
17103 casadi::FunctionInternal::codegen_sparsities(CodeGenerator &g) const  "
17104 
17105 [INTERNAL]  Codegen sparsities.
17106 
17107 ";
17108 
17109 %feature("docstring")  casadi::FunctionInternal::replace_arg(const
17110 std::vector< M > &arg, casadi_int npar) const  "
17111 
17112 [INTERNAL]  Replace 0-by-0 inputs.
17113 
17114 ";
17115 
17116 %feature("docstring")  casadi::FunctionInternal::codegen_name(const
17117 CodeGenerator &g, bool ns=true) const  "
17118 
17119 [INTERNAL]  Get name in codegen.
17120 
17121 ";
17122 
17123 %feature("docstring")  casadi::FunctionInternal::jacobian_sparsity() const
17124 "
17125 
17126 [INTERNAL]  Get Jacobian sparsity.
17127 
17128 ";
17129 
17130 %feature("docstring")  casadi::FunctionInternal::tocache(const Function &f,
17131 const std::string &suffix="") const  "
17132 
17133 [INTERNAL]  Save function to cache.
17134 
17135 ";
17136 
17137 %feature("docstring")  casadi::FunctionInternal::export_code(const
17138 std::string &lang, std::ostream &stream, const Dict &options) const  "
17139 
17140 [INTERNAL]  Export function in a specific language.
17141 
17142 ";
17143 
17144 %feature("docstring")  casadi::ProtoFunction::sprint(char *buf, size_t
17145 buf_sz, const char *fmt,...) const  "
17146 
17147 [INTERNAL]  C-style formatted printing to string.
17148 
17149 ";
17150 
17151 %feature("docstring")  casadi::FunctionInternal::signature(const std::string
17152 &fname) const  "
17153 
17154 [INTERNAL]  Code generate the function.
17155 
17156 ";
17157 
17158 %feature("docstring")  casadi::FunctionInternal::fwd_seed(casadi_int nfwd)
17159 const  "
17160 
17161 [INTERNAL]  Symbolic expressions for the forward seeds.
17162 
17163 ";
17164 
17165 %feature("docstring")  casadi::FunctionInternal::is_diff_in(casadi_int i) "
17166 
17167 [INTERNAL] ";
17168 
17169 %feature("docstring")  casadi::FunctionInternal::has_spfwd() const  "
17170 
17171 [INTERNAL]  Is the class able to propagate seeds through the algorithm?
17172 
17173 ";
17174 
17175 %feature("docstring")  casadi::SharedObjectInternal::class_name() const  "
17176 
17177 [INTERNAL]  Readable name of the internal class.
17178 
17179 ";
17180 
17181 %feature("docstring")  casadi::FunctionInternal::wrap_as_needed(const Dict
17182 &opts) const  "
17183 
17184 [INTERNAL]  Wrap in an Function instance consisting of only one MX call.
17185 
17186 ";
17187 
17188 %feature("docstring")  casadi::FunctionInternal::matching_arg(const
17189 std::vector< M > &arg, casadi_int &npar) const  "
17190 
17191 [INTERNAL]  Check if input arguments that needs to be replaced.
17192 
17193 Raises errors
17194 
17195 Parameters:
17196 -----------
17197 
17198 npar[in]:  normal usage: 1, disallow pararallel calls: -1
17199 
17200 npar:  max number of horizontal repetitions across all arguments (or -1)
17201 
17202 ";
17203 
17204 %feature("docstring")  casadi::FunctionInternal::has_function(const
17205 std::string &fname) const  "
17206 
17207 [INTERNAL] ";
17208 
17209 %feature("docstring")  casadi::FunctionInternal::size2_in(casadi_int ind)
17210 const  "
17211 
17212 [INTERNAL]  Input/output dimensions.
17213 
17214 ";
17215 
17216 %feature("docstring")  casadi::FunctionInternal::call_forward(const
17217 std::vector< MX > &arg, const std::vector< MX > &res, const std::vector<
17218 std::vector< MX > > &fseed, std::vector< std::vector< MX > > &fsens, bool
17219 always_inline, bool never_inline) const  "
17220 
17221 [INTERNAL]  Forward mode AD, virtual functions overloaded in derived
17222 classes.
17223 
17224 ";
17225 
17226 %feature("docstring")  casadi::FunctionInternal::call_forward(const
17227 std::vector< SX > &arg, const std::vector< SX > &res, const std::vector<
17228 std::vector< SX > > &fseed, std::vector< std::vector< SX > > &fsens, bool
17229 always_inline, bool never_inline) const  "
17230 
17231 [INTERNAL]  Forward mode AD, virtual functions overloaded in derived
17232 classes.
17233 
17234 ";
17235 
17236 %feature("docstring")
17237 casadi::FunctionInternal::getJacSparsityGen(casadi_int iind, casadi_int
17238 oind, bool symmetric, casadi_int gr_i=1, casadi_int gr_o=1) const  "
17239 
17240 [INTERNAL]  Get the sparsity pattern, forward mode.
17241 
17242 ";
17243 
17244 %feature("docstring")
17245 casadi::FunctionInternal::serialize_type(SerializingStream &s) const  "
17246 
17247 [INTERNAL]  Serialize type information.
17248 
17249 ";
17250 
17251 %feature("docstring")  casadi::PluginInterface< Dple
17252 >::serialize_type(SerializingStream &s) const "
17253 
17254 [INTERNAL]  Serialize type information.
17255 
17256 ";
17257 
17258 %feature("docstring")  casadi::FunctionInternal::disp_more(std::ostream
17259 &stream) const  "
17260 
17261 [INTERNAL]  Print more.
17262 
17263 ";
17264 
17265 %feature("docstring")  casadi::FunctionInternal::jacobian() const  "
17266 
17267 [INTERNAL]  Return Jacobian of all input elements with respect to all output
17268 elements.
17269 
17270 ";
17271 
17272 %feature("docstring")  casadi::FunctionInternal::project_arg(const
17273 std::vector< M > &arg, casadi_int npar) const  "
17274 
17275 [INTERNAL]   Project sparsities.
17276 
17277 ";
17278 
17279 %feature("docstring")  casadi::FunctionInternal::mapsum_mx(const
17280 std::vector< MX > &arg, const std::string &parallelization) "
17281 
17282 [INTERNAL]  Parallel evaluation.
17283 
17284 ";
17285 
17286 %feature("docstring")  casadi::Dple::get_n_in()  "
17287 
17288 [INTERNAL]  Number of function inputs and outputs.
17289 
17290 ";
17291 
17292 %feature("docstring")  casadi::FunctionInternal::sp_reverse(bvec_t **arg,
17293 bvec_t **res, casadi_int *iw, bvec_t *w, void *mem) const  "
17294 
17295 [INTERNAL]  Propagate sparsity backwards.
17296 
17297 ";
17298 
17299 %feature("docstring")  casadi::FunctionInternal::free_mx() const  "
17300 
17301 [INTERNAL]  Get free variables ( MX)
17302 
17303 ";
17304 
17305 %feature("docstring")  casadi::FunctionInternal::all_scalar() const  "
17306 
17307 [INTERNAL]  Are all inputs and outputs scalar.
17308 
17309 ";
17310 
17311 %feature("docstring")  casadi::FunctionInternal::call_gen(const MXVector
17312 &arg, MXVector &res, casadi_int npar, bool always_inline, bool never_inline)
17313 const  "
17314 
17315 [INTERNAL]   Call a function, overloaded.
17316 
17317 ";
17318 
17319 %feature("docstring")  casadi::FunctionInternal::call_gen(const std::vector<
17320 MatrixCommon > &arg, std::vector< MatrixCommon > &res, casadi_int npar, bool
17321 always_inline, bool never_inline) const  "
17322 
17323 [INTERNAL]   Call a function, overloaded.
17324 
17325 ";
17326 
17327 
17328 // File: classcasadi_1_1Einstein.xml
17329 
17330 
17331 // File: classcasadi_1_1Expm.xml
17332 %feature("docstring")  casadi::FunctionInternal::get_min_in(casadi_int ind)
17333 const  "
17334 
17335 [INTERNAL]  Get smallest input value.
17336 
17337 ";
17338 
17339 %feature("docstring")  casadi::ProtoFunction::free_mem(void *mem) const  "
17340 
17341 [INTERNAL]  Free memory block.
17342 
17343 ";
17344 
17345 %feature("docstring")  casadi::FunctionInternal::has_free() const  "
17346 
17347 [INTERNAL]  Does the function have free variables.
17348 
17349 ";
17350 
17351 %feature("docstring")  casadi::FunctionInternal::incache(const std::string
17352 &fname, Function &f, const std::string &suffix="") const  "
17353 
17354 [INTERNAL]  Get function in cache.
17355 
17356 ";
17357 
17358 %feature("docstring")  casadi::FunctionInternal::replace_aseed(const
17359 std::vector< std::vector< M >> &aseed, casadi_int npar) const  "
17360 
17361 [INTERNAL]  Replace 0-by-0 reverse seeds.
17362 
17363 ";
17364 
17365 %feature("docstring")  casadi::FunctionInternal::replace_aseed(const
17366 std::vector< std::vector< M > > &aseed, casadi_int npar) const  "
17367 
17368 [INTERNAL] ";
17369 
17370 %feature("docstring")  casadi::FunctionInternal::self() const  "
17371 
17372 [INTERNAL]  Get a public class instance.
17373 
17374 ";
17375 
17376 %feature("docstring")  casadi::FunctionInternal::symbolic_output(const
17377 std::vector< MX > &arg) const  "
17378 
17379 [INTERNAL]  Get a vector of symbolic variables corresponding to the outputs.
17380 
17381 ";
17382 
17383 %feature("docstring")  casadi::FunctionInternal::matching_res(const
17384 std::vector< M > &arg, casadi_int &npar) const  "
17385 
17386 [INTERNAL]  Check if output arguments that needs to be replaced.
17387 
17388 Raises errors
17389 
17390 Parameters:
17391 -----------
17392 
17393 npar[in]:  normal usage: 1, disallow pararallel calls: -1
17394 
17395 npar:  max number of horizontal repetitions across all arguments (or -1)
17396 
17397 ";
17398 
17399 %feature("docstring")  casadi::FunctionInternal::convert_arg(const
17400 std::vector< M > &arg) const  "
17401 
17402 [INTERNAL]  Convert from/to input/output lists/map.
17403 
17404 ";
17405 
17406 %feature("docstring")  casadi::FunctionInternal::convert_arg(const std::map<
17407 std::string, M > &arg) const  "
17408 
17409 [INTERNAL]  Convert from/to input/output lists/map.
17410 
17411 ";
17412 
17413 %feature("docstring")  casadi::FunctionInternal::size1_in(casadi_int ind)
17414 const  "
17415 
17416 [INTERNAL]  Input/output dimensions.
17417 
17418 ";
17419 
17420 %feature("docstring")  casadi::FunctionInternal::size2_in(casadi_int ind)
17421 const  "
17422 
17423 [INTERNAL]  Input/output dimensions.
17424 
17425 ";
17426 
17427 %feature("docstring")  casadi::FunctionInternal::finalize()  "
17428 
17429 [INTERNAL]  Finalize the object creation.
17430 
17431 ";
17432 
17433 %feature("docstring")  casadi::FunctionInternal::get_reltol() const  "
17434 
17435 [INTERNAL]  Get relative tolerance.
17436 
17437 ";
17438 
17439 %feature("docstring")  casadi::FunctionInternal::replace_res(const
17440 std::vector< M > &res, casadi_int npar) const  "
17441 
17442 [INTERNAL]  Replace 0-by-0 outputs.
17443 
17444 ";
17445 
17446 %feature("docstring")  casadi::FunctionInternal::alloc_w(size_t sz_w, bool
17447 persistent=false) "
17448 
17449 [INTERNAL]  Ensure required length of w field.
17450 
17451 ";
17452 
17453 %feature("docstring")  casadi::FunctionInternal::factory(const std::string
17454 &name, const std::vector< std::string > &s_in, const std::vector<
17455 std::string > &s_out, const Function::AuxOut &aux, const Dict &opts) const
17456 "
17457 
17458 [INTERNAL] ";
17459 
17460 %feature("docstring")  casadi::FunctionInternal::info() const  "
17461 
17462 [INTERNAL]  Obtain information about function
17463 
17464 ";
17465 
17466 %feature("docstring")  casadi::FunctionInternal::sz_res() const  "
17467 
17468 [INTERNAL]  Get required length of res field.
17469 
17470 ";
17471 
17472 %feature("docstring")  casadi::FunctionInternal::replace_arg(const
17473 std::vector< M > &arg, casadi_int npar) const  "
17474 
17475 [INTERNAL]  Replace 0-by-0 inputs.
17476 
17477 ";
17478 
17479 %feature("docstring")
17480 casadi::FunctionInternal::print_dimensions(std::ostream &stream) const  "
17481 
17482 [INTERNAL]  Print dimensions of inputs and outputs.
17483 
17484 ";
17485 
17486 %feature("docstring")  casadi::FunctionInternal::has_sprev() const  "
17487 
17488 [INTERNAL]  Is the class able to propagate seeds through the algorithm?
17489 
17490 ";
17491 
17492 %feature("docstring")
17493 casadi::FunctionInternal::jacobian_sparsity_filter(const Sparsity &sp) const
17494 "
17495 
17496 [INTERNAL]  Filter out nonzeros in the full sparsity jacobian according to
17497 is_diff_in/out.
17498 
17499 ";
17500 
17501 %feature("docstring")  casadi::FunctionInternal::codegen_body(CodeGenerator
17502 &g) const  "
17503 
17504 [INTERNAL]  Generate code for the function body.
17505 
17506 ";
17507 
17508 %feature("docstring")  casadi::FunctionInternal::disp_more(std::ostream
17509 &stream) const  "
17510 
17511 [INTERNAL]  Print more.
17512 
17513 ";
17514 
17515 %feature("docstring")  casadi::FunctionInternal::fwdViaJac(casadi_int nfwd)
17516 const  "
17517 
17518 [INTERNAL]  Calculate derivatives by multiplying the full Jacobian and
17519 multiplying.
17520 
17521 ";
17522 
17523 %feature("docstring")  casadi::FunctionInternal::sparsity_out(casadi_int
17524 ind) const  "
17525 
17526 [INTERNAL]  Input/output sparsity.
17527 
17528 ";
17529 
17530 %feature("docstring")  casadi::FunctionInternal::get_name_in(casadi_int i) "
17531 
17532 [INTERNAL]  Names of function input and outputs.
17533 
17534 ";
17535 
17536 %feature("docstring")  casadi::FunctionInternal::convert_res(const
17537 std::vector< M > &res) const  "
17538 
17539 [INTERNAL]  Convert from/to input/output lists/map.
17540 
17541 ";
17542 
17543 %feature("docstring")  casadi::FunctionInternal::convert_res(const std::map<
17544 std::string, M > &res) const  "
17545 
17546 [INTERNAL]  Convert from/to input/output lists/map.
17547 
17548 ";
17549 
17550 %feature("docstring")  casadi::FunctionInternal::uses_output() const  "
17551 
17552 [INTERNAL]  Do the derivative functions need nondifferentiated outputs?
17553 
17554 ";
17555 
17556 %feature("docstring")
17557 casadi::FunctionInternal::serialize_body(SerializingStream &s) const  "
17558 
17559 [INTERNAL]  Serialize an object without type information.
17560 
17561 ";
17562 
17563 %feature("docstring")  casadi::FunctionInternal::index_out(const std::string
17564 &name) const  "
17565 
17566 [INTERNAL]  Get output scheme index by name.
17567 
17568 ";
17569 
17570 %feature("docstring")  casadi::FunctionInternal::free_sx() const  "
17571 
17572 [INTERNAL]  Get free variables (SX)
17573 
17574 ";
17575 
17576 %feature("docstring")  casadi::FunctionInternal::jit_dependencies(const
17577 std::string &fname) "
17578 
17579 [INTERNAL]  Jit dependencies.
17580 
17581 ";
17582 
17583 %feature("docstring") casadi::Expm::Expm(const std::string &name, const
17584 Sparsity &A) "
17585 
17586 [INTERNAL] ";
17587 
17588 %feature("docstring")  casadi::FunctionInternal::has_jacobian() const  "
17589 
17590 [INTERNAL]  Return Jacobian of all input elements with respect to all output
17591 elements.
17592 
17593 ";
17594 
17595 %feature("docstring")  casadi::FunctionInternal::n_instructions() const  "
17596 
17597 [INTERNAL]  Get the number of atomic operations.
17598 
17599 ";
17600 
17601 %feature("docstring")  casadi::FunctionInternal::dm_in(casadi_int ind) const
17602 "
17603 
17604 [INTERNAL]  Get function input(s) and output(s)
17605 
17606 ";
17607 
17608 %feature("docstring")  casadi::FunctionInternal::dm_in() const  "
17609 
17610 [INTERNAL]  Get function input(s) and output(s)
17611 
17612 ";
17613 
17614 %feature("docstring")
17615 casadi::FunctionInternal::codegen_sparsities(CodeGenerator &g) const  "
17616 
17617 [INTERNAL]  Codegen sparsities.
17618 
17619 ";
17620 
17621 %feature("docstring")  casadi::Expm::get_n_in()  "
17622 
17623 [INTERNAL]  Number of function inputs and outputs.
17624 
17625 ";
17626 
17627 %feature("docstring")  casadi::FunctionInternal::size2_out(casadi_int ind)
17628 const  "
17629 
17630 [INTERNAL]  Input/output dimensions.
17631 
17632 ";
17633 
17634 %feature("docstring")  casadi::FunctionInternal::has_function(const
17635 std::string &fname) const  "
17636 
17637 [INTERNAL] ";
17638 
17639 %feature("docstring")  casadi::FunctionInternal::alloc_iw(size_t sz_iw, bool
17640 persistent=false) "
17641 
17642 [INTERNAL]  Ensure required length of iw field.
17643 
17644 ";
17645 
17646 %feature("docstring")  casadi::FunctionInternal::get_function() const  "
17647 
17648 [INTERNAL] ";
17649 
17650 %feature("docstring")  casadi::FunctionInternal::get_function(const
17651 std::string &name) const  "
17652 
17653 [INTERNAL] ";
17654 
17655 %feature("docstring")  casadi::FunctionInternal::instructions_sx() const  "
17656 
17657 [INTERNAL]  get SX expression associated with instructions
17658 
17659 ";
17660 
17661 %feature("docstring")  casadi::FunctionInternal::codegen_mem(CodeGenerator
17662 &g, const std::string &index="mem") const  "
17663 
17664 [INTERNAL]  Get thread-local memory object.
17665 
17666 ";
17667 
17668 %feature("docstring")  casadi::FunctionInternal::sp_weight() const  "
17669 
17670 [INTERNAL]  Weighting factor for chosing forward/reverse mode, sparsity
17671 propagation.
17672 
17673 ";
17674 
17675 %feature("docstring")  casadi::Expm::get_options() const  "
17676 
17677 [INTERNAL]  Options.
17678 
17679 ";
17680 
17681 %feature("docstring")  casadi::FunctionInternal::has_jacobian_sparsity()
17682 const  "
17683 
17684 [INTERNAL]  Get Jacobian sparsity.
17685 
17686 ";
17687 
17688 %feature("docstring")  casadi::SharedObjectInternal::getCount() const  "
17689 
17690 [INTERNAL]  Get the reference count.
17691 
17692 ";
17693 
17694 %feature("docstring")  casadi::FunctionInternal::call_reverse(const
17695 std::vector< MX > &arg, const std::vector< MX > &res, const std::vector<
17696 std::vector< MX > > &aseed, std::vector< std::vector< MX > > &asens, bool
17697 always_inline, bool never_inline) const  "
17698 
17699 [INTERNAL]  Reverse mode, virtual functions overloaded in derived classes.
17700 
17701 ";
17702 
17703 %feature("docstring")  casadi::FunctionInternal::call_reverse(const
17704 std::vector< SX > &arg, const std::vector< SX > &res, const std::vector<
17705 std::vector< SX > > &aseed, std::vector< std::vector< SX > > &asens, bool
17706 always_inline, bool never_inline) const  "
17707 
17708 [INTERNAL]  Reverse mode, virtual functions overloaded in derived classes.
17709 
17710 ";
17711 
17712 %feature("docstring")  casadi::FunctionInternal::nnz_in() const  "
17713 
17714 [INTERNAL]  Number of input/output nonzeros.
17715 
17716 ";
17717 
17718 %feature("docstring")  casadi::FunctionInternal::nnz_in(casadi_int ind)
17719 const  "
17720 
17721 [INTERNAL]  Number of input/output nonzeros.
17722 
17723 ";
17724 
17725 %feature("docstring")  casadi::FunctionInternal::eval_gen(const double
17726 **arg, double **res, casadi_int *iw, double *w, void *mem) const  "
17727 
17728 [INTERNAL]  Evaluate numerically.
17729 
17730 ";
17731 
17732 %feature("docstring")  casadi::FunctionInternal::eval_gen(const SXElem
17733 **arg, SXElem **res, casadi_int *iw, SXElem *w, void *mem) const  "
17734 
17735 [INTERNAL]  Evaluate a function, overloaded.
17736 
17737 ";
17738 
17739 %feature("docstring")  casadi::FunctionInternal::eval_gen(const bvec_t
17740 **arg, bvec_t **res, casadi_int *iw, bvec_t *w, void *mem) const  "
17741 
17742 [INTERNAL]  Evaluate a function, overloaded.
17743 
17744 ";
17745 
17746 %feature("docstring")  casadi::FunctionInternal::forward(casadi_int nfwd)
17747 const  "
17748 
17749 [INTERNAL]  Return function that calculates forward derivatives
17750 forward(nfwd) returns a cached instance if available, and calls  Function
17751 get_forward(casadi_int nfwd) if no cached version is available.
17752 
17753 ";
17754 
17755 %feature("docstring")  casadi::FunctionInternal::eval_sx(const SXElem **arg,
17756 SXElem **res, casadi_int *iw, SXElem *w, void *mem) const  "
17757 
17758 [INTERNAL]  Evaluate with symbolic scalars.
17759 
17760 ";
17761 
17762 %feature("docstring")  casadi::FunctionInternal::numel_in() const  "
17763 
17764 [INTERNAL]  Number of input/output elements.
17765 
17766 ";
17767 
17768 %feature("docstring")  casadi::FunctionInternal::numel_in(casadi_int ind)
17769 const  "
17770 
17771 [INTERNAL]  Number of input/output elements.
17772 
17773 ";
17774 
17775 %feature("docstring")  casadi::ProtoFunction::print(const char *fmt,...)
17776 const  "
17777 
17778 [INTERNAL]  C-style formatted printing during evaluation.
17779 
17780 ";
17781 
17782 %feature("docstring")  casadi::FunctionInternal::numel_out(casadi_int ind)
17783 const  "
17784 
17785 [INTERNAL]  Number of input/output elements.
17786 
17787 ";
17788 
17789 %feature("docstring")  casadi::FunctionInternal::numel_out() const  "
17790 
17791 [INTERNAL]  Number of input/output elements.
17792 
17793 ";
17794 
17795 %feature("docstring")  casadi::FunctionInternal::matching_arg(const
17796 std::vector< M > &arg, casadi_int &npar) const  "
17797 
17798 [INTERNAL]  Check if input arguments that needs to be replaced.
17799 
17800 Raises errors
17801 
17802 Parameters:
17803 -----------
17804 
17805 npar[in]:  normal usage: 1, disallow pararallel calls: -1
17806 
17807 npar:  max number of horizontal repetitions across all arguments (or -1)
17808 
17809 ";
17810 
17811 %feature("docstring")
17812 casadi::FunctionInternal::codegen_decref(CodeGenerator &g) const  "
17813 
17814 [INTERNAL]  Codegen decref for dependencies.
17815 
17816 ";
17817 
17818 %feature("docstring")  casadi::FunctionInternal::set_temp(void *mem, const
17819 double **arg, double **res, casadi_int *iw, double *w) const  "
17820 
17821 [INTERNAL]  Set the (temporary) work vectors.
17822 
17823 ";
17824 
17825 %feature("docstring")  casadi::FunctionInternal::jacobian() const  "
17826 
17827 [INTERNAL]  Return Jacobian of all input elements with respect to all output
17828 elements.
17829 
17830 ";
17831 
17832 %feature("docstring")  casadi::FunctionInternal::eval_dm(const std::vector<
17833 DM > &arg) const  "
17834 
17835 [INTERNAL]  Evaluate with DM matrices.
17836 
17837 ";
17838 
17839 %feature("docstring")  casadi::FunctionInternal::index_in(const std::string
17840 &name) const  "
17841 
17842 [INTERNAL]  Get input scheme index by name.
17843 
17844 ";
17845 
17846 %feature("docstring")  casadi::FunctionInternal::mapsum_mx(const
17847 std::vector< MX > &arg, const std::string &parallelization) "
17848 
17849 [INTERNAL]  Parallel evaluation.
17850 
17851 ";
17852 
17853 %feature("docstring")  casadi::FunctionInternal::wrap() const  "
17854 
17855 [INTERNAL]  Wrap in an Function instance consisting of only one MX call.
17856 
17857 ";
17858 
17859 %feature("docstring")  casadi::FunctionInternal::jac() const  "
17860 
17861 [INTERNAL]  Return Jacobian of all input elements with respect to all output
17862 elements.
17863 
17864 ";
17865 
17866 %feature("docstring")  casadi::FunctionInternal::call(const std::vector< M >
17867 &arg, std::vector< M > &res, bool always_inline, bool never_inline) const  "
17868 
17869 [INTERNAL]   Call a function, templated.
17870 
17871 ";
17872 
17873 %feature("docstring")  casadi::FunctionInternal::export_code(const
17874 std::string &lang, std::ostream &stream, const Dict &options) const  "
17875 
17876 [INTERNAL]  Export function in a specific language.
17877 
17878 ";
17879 
17880 %feature("docstring")  casadi::FunctionInternal::adjViaJac(casadi_int nadj)
17881 const  "
17882 
17883 [INTERNAL]  Calculate derivatives by multiplying the full Jacobian and
17884 multiplying.
17885 
17886 ";
17887 
17888 %feature("docstring")  casadi::FunctionInternal::sx_in(casadi_int ind) const
17889 "
17890 
17891 [INTERNAL]  Get function input(s) and output(s)
17892 
17893 ";
17894 
17895 %feature("docstring")  casadi::FunctionInternal::sx_in() const  "
17896 
17897 [INTERNAL]  Get function input(s) and output(s)
17898 
17899 ";
17900 
17901 %feature("docstring")  casadi::FunctionInternal::mx_out(casadi_int ind)
17902 const  "
17903 
17904 [INTERNAL]  Get function input(s) and output(s)
17905 
17906 ";
17907 
17908 %feature("docstring")  casadi::FunctionInternal::mx_out() const  "
17909 
17910 [INTERNAL]  Get function input(s) and output(s)
17911 
17912 ";
17913 
17914 %feature("docstring")  casadi::Expm::get_sparsity_in(casadi_int i)  "
17915 
17916 [INTERNAL]  Sparsities of function inputs and outputs.
17917 
17918 ";
17919 
17920 %feature("docstring")  casadi::Expm::init(const Dict &opts)  "
17921 
17922 [INTERNAL]  Initialize Initialize and make the object ready for setting
17923 arguments and evaluation. This method is typically called after setting
17924 options but before evaluating. If passed to another class (in the
17925 constructor), this class should invoke this function when initialized.
17926 
17927 ";
17928 
17929 %feature("docstring")  casadi::FunctionInternal::free_mx() const  "
17930 
17931 [INTERNAL]  Get free variables ( MX)
17932 
17933 ";
17934 
17935 %feature("docstring")  casadi::Expm::get_n_out()  "
17936 
17937 [INTERNAL]  Number of function inputs and outputs.
17938 
17939 ";
17940 
17941 %feature("docstring")
17942 casadi::FunctionInternal::instruction_output(casadi_int k) const  "
17943 
17944 [INTERNAL]  Get the (integer) output argument of an atomic operation.
17945 
17946 ";
17947 
17948 %feature("docstring")  casadi::FunctionInternal::sz_w() const  "
17949 
17950 [INTERNAL]  Get required length of w field.
17951 
17952 ";
17953 
17954 %feature("docstring")  casadi::FunctionInternal::setup(void *mem, const
17955 double **arg, double **res, casadi_int *iw, double *w) const  "
17956 
17957 [INTERNAL]  Set the (persistent and temporary) work vectors.
17958 
17959 ";
17960 
17961 %feature("docstring")  casadi::FunctionInternal::has_codegen() const  "
17962 
17963 [INTERNAL]  Is codegen supported?
17964 
17965 ";
17966 
17967 %feature("docstring")  casadi::PluginInterface< Expm  >::plugin_name() const
17968 "
17969 
17970 [INTERNAL] ";
17971 
17972 %feature("docstring")  casadi::FunctionInternal::check_mat(const Sparsity
17973 &arg, const Sparsity &inp, casadi_int &npar) "
17974 
17975 [INTERNAL]  Helper function
17976 
17977 Parameters:
17978 -----------
17979 
17980 npar[in]:  normal usage: 1, disallow pararallel calls: -1
17981 
17982 npar[out]:  required number of parallel calls (or -1)
17983 
17984 ";
17985 
17986 %feature("docstring")  casadi::ProtoFunction::clear_mem() "
17987 
17988 [INTERNAL]  Clear all memory (called from destructor)
17989 
17990 ";
17991 
17992 %feature("docstring")  casadi::ProtoFunction::get_stats(void *mem) const  "
17993 
17994 [INTERNAL]  Get all statistics.
17995 
17996 ";
17997 
17998 %feature("docstring")  casadi::FunctionInternal::codegen_meta(CodeGenerator
17999 &g) const  "
18000 
18001 [INTERNAL]  Generate meta-information allowing a user to evaluate a
18002 generated function.
18003 
18004 ";
18005 
18006 %feature("docstring")  casadi::FunctionInternal::mx_in(casadi_int ind) const
18007 "
18008 
18009 [INTERNAL]  Get function input(s) and output(s)
18010 
18011 ";
18012 
18013 %feature("docstring")  casadi::FunctionInternal::mx_in() const  "
18014 
18015 [INTERNAL]  Get function input(s) and output(s)
18016 
18017 ";
18018 
18019 %feature("docstring")  casadi::FunctionInternal::generate_lifted(Function
18020 &vdef_fcn, Function &vinit_fcn) const  "
18021 
18022 [INTERNAL]  Extract the functions needed for the Lifted Newton method.
18023 
18024 ";
18025 
18026 %feature("docstring")  casadi::ProtoFunction::alloc_mem() const  "
18027 
18028 [INTERNAL]  Create memory block.
18029 
18030 ";
18031 
18032 %feature("docstring")  casadi::FunctionInternal::sz_iw() const  "
18033 
18034 [INTERNAL]  Get required length of iw field.
18035 
18036 ";
18037 
18038 %feature("docstring")  casadi::FunctionInternal::which_depends(const
18039 std::string &s_in, const std::vector< std::string > &s_out, casadi_int
18040 order, bool tr=false) const  "
18041 
18042 [INTERNAL]  Which variables enter with some order.
18043 
18044 Parameters:
18045 -----------
18046 
18047 s_in:   Input name
18048 
18049 s_out:   Output name(s)
18050 
18051 order:  Only 1 (linear) and 2 (nonlinear) allowed
18052 
18053 tr:  Flip the relationship. Return which expressions contain the variables
18054 
18055 ";
18056 
18057 %feature("docstring")  casadi::ProtoFunction::format_time(char *buffer,
18058 double time) const  "
18059 
18060 [INTERNAL]  Format time in a fixed width 8 format.
18061 
18062 ";
18063 
18064 %feature("docstring")  casadi::FunctionInternal::alloc_arg(size_t sz_arg,
18065 bool persistent=false) "
18066 
18067 [INTERNAL]  Ensure required length of arg field.
18068 
18069 ";
18070 
18071 %feature("docstring")  casadi::FunctionInternal::fwd_seed(casadi_int nfwd)
18072 const  "
18073 
18074 [INTERNAL]  Symbolic expressions for the forward seeds.
18075 
18076 ";
18077 
18078 %feature("docstring")  casadi::FunctionInternal::sz_arg() const  "
18079 
18080 [INTERNAL]  Get required length of arg field.
18081 
18082 ";
18083 
18084 %feature("docstring")  casadi::FunctionInternal::project_arg(const
18085 std::vector< M > &arg, casadi_int npar) const  "
18086 
18087 [INTERNAL]   Project sparsities.
18088 
18089 ";
18090 
18091 %feature("docstring")  casadi::FunctionInternal::codegen(CodeGenerator &g,
18092 const std::string &fname) const  "
18093 
18094 [INTERNAL]  Generate code the function.
18095 
18096 ";
18097 
18098 %feature("docstring")  casadi::Expm::get_sparsity_out(casadi_int i)  "
18099 
18100 [INTERNAL]  Sparsities of function inputs and outputs.
18101 
18102 ";
18103 
18104 %feature("docstring")  casadi::FunctionInternal::instruction_id(casadi_int
18105 k) const  "
18106 
18107 [INTERNAL]  Get an atomic operation operator index.
18108 
18109 ";
18110 
18111 %feature("docstring")  casadi::FunctionInternal::has_eval_dm() const  "
18112 
18113 [INTERNAL]  Evaluate with DM matrices.
18114 
18115 ";
18116 
18117 %feature("docstring")  casadi::FunctionInternal::generate_options(bool
18118 is_temp=false) const  "
18119 
18120 [INTERNAL]  Reconstruct options dict.
18121 
18122 ";
18123 
18124 %feature("docstring")  casadi::FunctionInternal::replace_fseed(const
18125 std::vector< std::vector< M >> &fseed, casadi_int npar) const  "
18126 
18127 [INTERNAL]  Replace 0-by-0 forward seeds.
18128 
18129 ";
18130 
18131 %feature("docstring")  casadi::FunctionInternal::replace_fseed(const
18132 std::vector< std::vector< M > > &fseed, casadi_int npar) const  "
18133 
18134 [INTERNAL] ";
18135 
18136 %feature("docstring")  casadi::FunctionInternal::has_spfwd() const  "
18137 
18138 [INTERNAL]  Is the class able to propagate seeds through the algorithm?
18139 
18140 ";
18141 
18142 %feature("docstring")  casadi::ProtoFunction::checkout() const  "
18143 
18144 [INTERNAL]  Checkout a memory object.
18145 
18146 ";
18147 
18148 %feature("docstring")  casadi::FunctionInternal::map(casadi_int n, const
18149 std::string &parallelization) const  "
18150 
18151 [INTERNAL]  Generate/retrieve cached serial map.
18152 
18153 ";
18154 
18155 %feature("docstring")  casadi::FunctionInternal::is_diff_in(casadi_int i) "
18156 
18157 [INTERNAL] ";
18158 
18159 %feature("docstring")
18160 casadi::FunctionInternal::instruction_constant(casadi_int k) const  "
18161 
18162 [INTERNAL]  Get the floating point output argument of an atomic operation.
18163 
18164 ";
18165 
18166 %feature("docstring")  casadi::FunctionInternal::is_diff_out(casadi_int i) "
18167 
18168 [INTERNAL] ";
18169 
18170 %feature("docstring")
18171 casadi::FunctionInternal::codegen_alloc_mem(CodeGenerator &g) const  "
18172 
18173 [INTERNAL]  Codegen decref for alloc_mem.
18174 
18175 ";
18176 
18177 %feature("docstring")  casadi::FunctionInternal::wrap_as_needed(const Dict
18178 &opts) const  "
18179 
18180 [INTERNAL]  Wrap in an Function instance consisting of only one MX call.
18181 
18182 ";
18183 
18184 %feature("docstring")  casadi::FunctionInternal::get_partition(casadi_int
18185 iind, casadi_int oind, Sparsity &D1, Sparsity &D2, bool compact, bool
18186 symmetric, bool allow_forward, bool allow_reverse) const  "
18187 
18188 [INTERNAL]  Get the unidirectional or bidirectional partition.
18189 
18190 ";
18191 
18192 %feature("docstring")  casadi::FunctionInternal::sz_work(size_t &sz_arg,
18193 size_t &sz_res, size_t &sz_iw, size_t &sz_w) const  "
18194 
18195 [INTERNAL]  Get number of temporary variables needed.
18196 
18197 ";
18198 
18199 %feature("docstring")  casadi::FunctionInternal::reverse(casadi_int nadj)
18200 const  "
18201 
18202 [INTERNAL]  Return function that calculates adjoint derivatives
18203 reverse(nadj) returns a cached instance if available, and calls  Function
18204 get_reverse(casadi_int nadj) if no cached version is available.
18205 
18206 ";
18207 
18208 %feature("docstring")  casadi::FunctionInternal::project_res(const
18209 std::vector< M > &arg, casadi_int npar) const  "
18210 
18211 [INTERNAL]   Project sparsities.
18212 
18213 ";
18214 
18215 %feature("docstring")  casadi::FunctionInternal::alloc(const Function &f,
18216 bool persistent=false) "
18217 
18218 [INTERNAL]  Ensure work vectors long enough to evaluate function.
18219 
18220 ";
18221 
18222 %feature("docstring")  casadi::FunctionInternal::check_res(const
18223 std::vector< M > &res, casadi_int &npar) const  "
18224 
18225 [INTERNAL]  Check if output arguments have correct length and dimensions.
18226 
18227 Raises errors.
18228 
18229 Parameters:
18230 -----------
18231 
18232 npar[in]:  normal usage: 1, disallow pararallel calls: -1
18233 
18234 npar:  max number of horizontal repetitions across all arguments (or -1)
18235 
18236 ";
18237 
18238 %feature("docstring")  casadi::FunctionInternal::get_name_out(casadi_int i)
18239 "
18240 
18241 [INTERNAL]  Names of function input and outputs.
18242 
18243 ";
18244 
18245 %feature("docstring")  casadi::FunctionInternal::all_scalar() const  "
18246 
18247 [INTERNAL]  Are all inputs and outputs scalar.
18248 
18249 ";
18250 
18251 %feature("docstring")  casadi::FunctionInternal::nz_in(const std::vector< DM
18252 > &arg) const  "
18253 
18254 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
18255 
18256 ";
18257 
18258 %feature("docstring")  casadi::FunctionInternal::nz_in(const std::vector<
18259 double > &arg) const  "
18260 
18261 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
18262 
18263 ";
18264 
18265 %feature("docstring")
18266 casadi::FunctionInternal::getJacSparsityGen(casadi_int iind, casadi_int
18267 oind, bool symmetric, casadi_int gr_i=1, casadi_int gr_o=1) const  "
18268 
18269 [INTERNAL]  Get the sparsity pattern, forward mode.
18270 
18271 ";
18272 
18273 %feature("docstring")  casadi::Expm::get_forward(casadi_int nfwd, const
18274 std::string &name, const std::vector< std::string > &inames, const
18275 std::vector< std::string > &onames, const Dict &opts) const  "
18276 
18277 [INTERNAL]  Generate a function that calculates nfwd forward derivatives.
18278 
18279 ";
18280 
18281 %feature("docstring")  casadi::FunctionInternal::call_forward(const
18282 std::vector< MX > &arg, const std::vector< MX > &res, const std::vector<
18283 std::vector< MX > > &fseed, std::vector< std::vector< MX > > &fsens, bool
18284 always_inline, bool never_inline) const  "
18285 
18286 [INTERNAL]  Forward mode AD, virtual functions overloaded in derived
18287 classes.
18288 
18289 ";
18290 
18291 %feature("docstring")  casadi::FunctionInternal::call_forward(const
18292 std::vector< SX > &arg, const std::vector< SX > &res, const std::vector<
18293 std::vector< SX > > &fseed, std::vector< std::vector< SX > > &fsens, bool
18294 always_inline, bool never_inline) const  "
18295 
18296 [INTERNAL]  Forward mode AD, virtual functions overloaded in derived
18297 classes.
18298 
18299 ";
18300 
18301 %feature("docstring")  casadi::FunctionInternal::sx_out(casadi_int ind)
18302 const  "
18303 
18304 [INTERNAL]  Get function input(s) and output(s)
18305 
18306 ";
18307 
18308 %feature("docstring")  casadi::FunctionInternal::sx_out() const  "
18309 
18310 [INTERNAL]  Get function input(s) and output(s)
18311 
18312 ";
18313 
18314 %feature("docstring")
18315 casadi::FunctionInternal::codegen_declarations(CodeGenerator &g) const  "
18316 
18317 [INTERNAL]  Generate code for the declarations of the C function.
18318 
18319 ";
18320 
18321 %feature("docstring")  casadi::FunctionInternal::set_work(void *mem, const
18322 double **&arg, double **&res, casadi_int *&iw, double *&w) const  "
18323 
18324 [INTERNAL]  Set the (persistent) work vectors.
18325 
18326 ";
18327 
18328 %feature("docstring")  casadi::FunctionInternal::has_jac() const  "
18329 
18330 [INTERNAL]  Return Jacobian of all input elements with respect to all output
18331 elements.
18332 
18333 ";
18334 
18335 %feature("docstring")  casadi::FunctionInternal::size_in(casadi_int ind)
18336 const  "
18337 
18338 [INTERNAL]  Input/output dimensions.
18339 
18340 ";
18341 
18342 %feature("docstring")  casadi::ProtoFunction::serialize(SerializingStream
18343 &s) const  "
18344 
18345 [INTERNAL]  Serialize an object.
18346 
18347 ";
18348 
18349 %feature("docstring")  casadi::FunctionInternal::size_out(casadi_int ind)
18350 const  "
18351 
18352 [INTERNAL]  Input/output dimensions.
18353 
18354 ";
18355 
18356 %feature("docstring")  casadi::FunctionInternal::instruction_MX(casadi_int
18357 k) const  "
18358 
18359 [INTERNAL]  get MX expression associated with instruction
18360 
18361 ";
18362 
18363 %feature("docstring")  casadi::FunctionInternal::disp(std::ostream &stream,
18364 bool more) const  "
18365 
18366 [INTERNAL]  Display object.
18367 
18368 ";
18369 
18370 %feature("docstring")  casadi::FunctionInternal::nz_out(const std::vector<
18371 DM > &res) const  "
18372 
18373 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
18374 
18375 ";
18376 
18377 %feature("docstring")  casadi::FunctionInternal::nz_out(const std::vector<
18378 double > &res) const  "
18379 
18380 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
18381 
18382 ";
18383 
18384 %feature("docstring")
18385 casadi::FunctionInternal::getJacSparsityHierarchicalSymm(casadi_int iind,
18386 casadi_int oind) const  "
18387 
18388 [INTERNAL]  A flavor of getJacSparsity that does hierarchical block
18389 structure recognition for symmetric Jacobians
18390 
18391 ";
18392 
18393 %feature("docstring") casadi::Expm "
18394 
18395 Internal class.
18396 
18397 >List of available options
18398 
18399 +------------------+-----------------+------------------+------------------+
18400 |        Id        |      Type       |   Description    |     Used in      |
18401 +==================+=================+==================+==================+
18402 | ad_weight        | OT_DOUBLE       | Weighting factor | casadi::Function |
18403 |                  |                 | for derivative   | Internal         |
18404 |                  |                 | calculation.When |                  |
18405 |                  |                 | there is an      |                  |
18406 |                  |                 | option of either |                  |
18407 |                  |                 | using forward or |                  |
18408 |                  |                 | reverse mode     |                  |
18409 |                  |                 | directional      |                  |
18410 |                  |                 | derivatives, the |                  |
18411 |                  |                 | condition ad_wei |                  |
18412 |                  |                 | ght*nf<=(1-ad_we |                  |
18413 |                  |                 | ight)*na is used |                  |
18414 |                  |                 | where nf and na  |                  |
18415 |                  |                 | are estimates of |                  |
18416 |                  |                 | the number of    |                  |
18417 |                  |                 | forward/reverse  |                  |
18418 |                  |                 | mode directional |                  |
18419 |                  |                 | derivatives      |                  |
18420 |                  |                 | needed. By       |                  |
18421 |                  |                 | default,         |                  |
18422 |                  |                 | ad_weight is     |                  |
18423 |                  |                 | calculated       |                  |
18424 |                  |                 | automatically,   |                  |
18425 |                  |                 | but this can be  |                  |
18426 |                  |                 | overridden by    |                  |
18427 |                  |                 | setting this     |                  |
18428 |                  |                 | option. In       |                  |
18429 |                  |                 | particular, 0    |                  |
18430 |                  |                 | means forcing    |                  |
18431 |                  |                 | forward mode and |                  |
18432 |                  |                 | 1 forcing        |                  |
18433 |                  |                 | reverse mode.    |                  |
18434 |                  |                 | Leave unset for  |                  |
18435 |                  |                 | (class specific) |                  |
18436 |                  |                 | heuristics.      |                  |
18437 +------------------+-----------------+------------------+------------------+
18438 | ad_weight_sp     | OT_DOUBLE       | Weighting factor | casadi::Function |
18439 |                  |                 | for sparsity     | Internal         |
18440 |                  |                 | pattern          |                  |
18441 |                  |                 | calculation calc |                  |
18442 |                  |                 | ulation.Override |                  |
18443 |                  |                 | s default        |                  |
18444 |                  |                 | behavior. Set to |                  |
18445 |                  |                 | 0 and 1 to force |                  |
18446 |                  |                 | forward and      |                  |
18447 |                  |                 | reverse mode     |                  |
18448 |                  |                 | respectively.    |                  |
18449 |                  |                 | Cf. option       |                  |
18450 |                  |                 | \"ad_weight\".     |                  |
18451 |                  |                 | When set to -1,  |                  |
18452 |                  |                 | sparsity is      |                  |
18453 |                  |                 | completely       |                  |
18454 |                  |                 | ignored and      |                  |
18455 |                  |                 | dense matrices   |                  |
18456 |                  |                 | are used.        |                  |
18457 +------------------+-----------------+------------------+------------------+
18458 | always_inline    | OT_BOOL         | Force inlining.  | casadi::Function |
18459 |                  |                 |                  | Internal         |
18460 +------------------+-----------------+------------------+------------------+
18461 | compiler         | OT_STRING       | Just-in-time     | casadi::Function |
18462 |                  |                 | compiler plugin  | Internal         |
18463 |                  |                 | to be used.      |                  |
18464 +------------------+-----------------+------------------+------------------+
18465 | const_A          | OT_BOOL         | Assume A is      | casadi::Expm     |
18466 |                  |                 | constant.        |                  |
18467 |                  |                 | Default: false.  |                  |
18468 +------------------+-----------------+------------------+------------------+
18469 | custom_jacobian  | OT_FUNCTION     | Override         | casadi::Function |
18470 |                  |                 | CasADi's AD. Use | Internal         |
18471 |                  |                 | together with    |                  |
18472 |                  |                 | 'jac_penalty':   |                  |
18473 |                  |                 | 0. Note: Highly  |                  |
18474 |                  |                 | experimental.    |                  |
18475 |                  |                 | Syntax may break |                  |
18476 |                  |                 | often.           |                  |
18477 +------------------+-----------------+------------------+------------------+
18478 | derivative_of    | OT_FUNCTION     | The function is  | casadi::Function |
18479 |                  |                 | a derivative of  | Internal         |
18480 |                  |                 | another          |                  |
18481 |                  |                 | function. The    |                  |
18482 |                  |                 | type of          |                  |
18483 |                  |                 | derivative       |                  |
18484 |                  |                 | (directional     |                  |
18485 |                  |                 | derivative,      |                  |
18486 |                  |                 | Jacobian) is     |                  |
18487 |                  |                 | inferred from    |                  |
18488 |                  |                 | the function     |                  |
18489 |                  |                 | name.            |                  |
18490 +------------------+-----------------+------------------+------------------+
18491 | dump             | OT_BOOL         | Dump function to | casadi::Function |
18492 |                  |                 | file upon first  | Internal         |
18493 |                  |                 | evaluation.      |                  |
18494 |                  |                 | [false]          |                  |
18495 +------------------+-----------------+------------------+------------------+
18496 | dump_dir         | OT_STRING       | Directory to     | casadi::Function |
18497 |                  |                 | dump             | Internal         |
18498 |                  |                 | inputs/outputs   |                  |
18499 |                  |                 | to. Make sure    |                  |
18500 |                  |                 | the directory    |                  |
18501 |                  |                 | exists [.]       |                  |
18502 +------------------+-----------------+------------------+------------------+
18503 | dump_format      | OT_STRING       | Choose file      | casadi::Function |
18504 |                  |                 | format to dump   | Internal         |
18505 |                  |                 | matrices. See    |                  |
18506 |                  |                 | DM.from_file     |                  |
18507 |                  |                 | [mtx]            |                  |
18508 +------------------+-----------------+------------------+------------------+
18509 | dump_in          | OT_BOOL         | Dump numerical   | casadi::Function |
18510 |                  |                 | values of inputs | Internal         |
18511 |                  |                 | to file          |                  |
18512 |                  |                 | (readable with   |                  |
18513 |                  |                 | DM.from_file )   |                  |
18514 |                  |                 | [default: false] |                  |
18515 +------------------+-----------------+------------------+------------------+
18516 | dump_out         | OT_BOOL         | Dump numerical   | casadi::Function |
18517 |                  |                 | values of        | Internal         |
18518 |                  |                 | outputs to file  |                  |
18519 |                  |                 | (readable with   |                  |
18520 |                  |                 | DM.from_file )   |                  |
18521 |                  |                 | [default: false] |                  |
18522 +------------------+-----------------+------------------+------------------+
18523 | enable_fd        | OT_BOOL         | Enable           | casadi::Function |
18524 |                  |                 | derivative       | Internal         |
18525 |                  |                 | calculation by   |                  |
18526 |                  |                 | finite           |                  |
18527 |                  |                 | differencing.    |                  |
18528 |                  |                 | [default:        |                  |
18529 |                  |                 | false]]          |                  |
18530 +------------------+-----------------+------------------+------------------+
18531 | enable_forward   | OT_BOOL         | Enable           | casadi::Function |
18532 |                  |                 | derivative       | Internal         |
18533 |                  |                 | calculation      |                  |
18534 |                  |                 | using generated  |                  |
18535 |                  |                 | functions for    |                  |
18536 |                  |                 | Jacobian-times-  |                  |
18537 |                  |                 | vector products  |                  |
18538 |                  |                 | - typically      |                  |
18539 |                  |                 | using forward    |                  |
18540 |                  |                 | mode AD - if     |                  |
18541 |                  |                 | available.       |                  |
18542 |                  |                 | [default: true]  |                  |
18543 +------------------+-----------------+------------------+------------------+
18544 | enable_jacobian  | OT_BOOL         | Enable           | casadi::Function |
18545 |                  |                 | derivative       | Internal         |
18546 |                  |                 | calculation      |                  |
18547 |                  |                 | using generated  |                  |
18548 |                  |                 | functions for    |                  |
18549 |                  |                 | Jacobians of all |                  |
18550 |                  |                 | differentiable   |                  |
18551 |                  |                 | outputs with     |                  |
18552 |                  |                 | respect to all   |                  |
18553 |                  |                 | differentiable   |                  |
18554 |                  |                 | inputs - if      |                  |
18555 |                  |                 | available.       |                  |
18556 |                  |                 | [default: true]  |                  |
18557 +------------------+-----------------+------------------+------------------+
18558 | enable_reverse   | OT_BOOL         | Enable           | casadi::Function |
18559 |                  |                 | derivative       | Internal         |
18560 |                  |                 | calculation      |                  |
18561 |                  |                 | using generated  |                  |
18562 |                  |                 | functions for    |                  |
18563 |                  |                 | transposed       |                  |
18564 |                  |                 | Jacobian-times-  |                  |
18565 |                  |                 | vector products  |                  |
18566 |                  |                 | - typically      |                  |
18567 |                  |                 | using reverse    |                  |
18568 |                  |                 | mode AD - if     |                  |
18569 |                  |                 | available.       |                  |
18570 |                  |                 | [default: true]  |                  |
18571 +------------------+-----------------+------------------+------------------+
18572 | fd_method        | OT_STRING       | Method for       | casadi::Function |
18573 |                  |                 | finite           | Internal         |
18574 |                  |                 | differencing     |                  |
18575 |                  |                 | [default         |                  |
18576 |                  |                 | 'central']       |                  |
18577 +------------------+-----------------+------------------+------------------+
18578 | fd_options       | OT_DICT         | Options to be    | casadi::Function |
18579 |                  |                 | passed to the    | Internal         |
18580 |                  |                 | finite           |                  |
18581 |                  |                 | difference       |                  |
18582 |                  |                 | instance         |                  |
18583 +------------------+-----------------+------------------+------------------+
18584 | forward_options  | OT_DICT         | Options to be    | casadi::Function |
18585 |                  |                 | passed to a      | Internal         |
18586 |                  |                 | forward mode     |                  |
18587 |                  |                 | constructor      |                  |
18588 +------------------+-----------------+------------------+------------------+
18589 | gather_stats     | OT_BOOL         | Deprecated       | casadi::Function |
18590 |                  |                 | option           | Internal         |
18591 |                  |                 | (ignored):       |                  |
18592 |                  |                 | Statistics are   |                  |
18593 |                  |                 | now always       |                  |
18594 |                  |                 | collected.       |                  |
18595 +------------------+-----------------+------------------+------------------+
18596 | input_scheme     | OT_STRINGVECTOR | Deprecated       | casadi::Function |
18597 |                  |                 | option (ignored) | Internal         |
18598 +------------------+-----------------+------------------+------------------+
18599 | inputs_check     | OT_BOOL         | Throw exceptions | casadi::Function |
18600 |                  |                 | when the         | Internal         |
18601 |                  |                 | numerical values |                  |
18602 |                  |                 | of the inputs    |                  |
18603 |                  |                 | don't make sense |                  |
18604 +------------------+-----------------+------------------+------------------+
18605 | is_diff_in       | OT_BOOLVECTOR   | Indicate for     | casadi::Function |
18606 |                  |                 | each input if it | Internal         |
18607 |                  |                 | should be        |                  |
18608 |                  |                 | differentiable.  |                  |
18609 +------------------+-----------------+------------------+------------------+
18610 | is_diff_out      | OT_BOOLVECTOR   | Indicate for     | casadi::Function |
18611 |                  |                 | each output if   | Internal         |
18612 |                  |                 | it should be     |                  |
18613 |                  |                 | differentiable.  |                  |
18614 +------------------+-----------------+------------------+------------------+
18615 | jac_penalty      | OT_DOUBLE       | When requested   | casadi::Function |
18616 |                  |                 | for a number of  | Internal         |
18617 |                  |                 | forward/reverse  |                  |
18618 |                  |                 | directions, it   |                  |
18619 |                  |                 | may be cheaper   |                  |
18620 |                  |                 | to compute first |                  |
18621 |                  |                 | the full         |                  |
18622 |                  |                 | jacobian and     |                  |
18623 |                  |                 | then multiply    |                  |
18624 |                  |                 | with seeds,      |                  |
18625 |                  |                 | rather than      |                  |
18626 |                  |                 | obtain the       |                  |
18627 |                  |                 | requested        |                  |
18628 |                  |                 | directions in a  |                  |
18629 |                  |                 | straightforward  |                  |
18630 |                  |                 | manner. Casadi   |                  |
18631 |                  |                 | uses a heuristic |                  |
18632 |                  |                 | to decide which  |                  |
18633 |                  |                 | is cheaper. A    |                  |
18634 |                  |                 | high value of    |                  |
18635 |                  |                 | 'jac_penalty'    |                  |
18636 |                  |                 | makes it less    |                  |
18637 |                  |                 | likely for the   |                  |
18638 |                  |                 | heurstic to      |                  |
18639 |                  |                 | chose the full   |                  |
18640 |                  |                 | Jacobian         |                  |
18641 |                  |                 | strategy. The    |                  |
18642 |                  |                 | special value -1 |                  |
18643 |                  |                 | indicates never  |                  |
18644 |                  |                 | to use the full  |                  |
18645 |                  |                 | Jacobian         |                  |
18646 |                  |                 | strategy         |                  |
18647 +------------------+-----------------+------------------+------------------+
18648 | jit              | OT_BOOL         | Use just-in-time | casadi::Function |
18649 |                  |                 | compiler to      | Internal         |
18650 |                  |                 | speed up the     |                  |
18651 |                  |                 | evaluation       |                  |
18652 +------------------+-----------------+------------------+------------------+
18653 | jit_cleanup      | OT_BOOL         | Cleanup up the   | casadi::Function |
18654 |                  |                 | temporary source | Internal         |
18655 |                  |                 | file that jit    |                  |
18656 |                  |                 | creates.         |                  |
18657 |                  |                 | Default: true    |                  |
18658 +------------------+-----------------+------------------+------------------+
18659 | jit_name         | OT_STRING       | The file name    | casadi::Function |
18660 |                  |                 | used to write    | Internal         |
18661 |                  |                 | out code. The    |                  |
18662 |                  |                 | actual file      |                  |
18663 |                  |                 | names used       |                  |
18664 |                  |                 | depend on 'jit_t |                  |
18665 |                  |                 | emp_suffix' and  |                  |
18666 |                  |                 | include          |                  |
18667 |                  |                 | extensions.      |                  |
18668 |                  |                 | Default:         |                  |
18669 |                  |                 | 'jit_tmp'        |                  |
18670 +------------------+-----------------+------------------+------------------+
18671 | jit_options      | OT_DICT         | Options to be    | casadi::Function |
18672 |                  |                 | passed to the    | Internal         |
18673 |                  |                 | jit compiler.    |                  |
18674 +------------------+-----------------+------------------+------------------+
18675 | jit_serialize    | OT_STRING       | Specify          | casadi::Function |
18676 |                  |                 | behaviour when   | Internal         |
18677 |                  |                 | serializing a    |                  |
18678 |                  |                 | jitted function: |                  |
18679 |                  |                 | SOURCE|link|embe |                  |
18680 |                  |                 | d.               |                  |
18681 +------------------+-----------------+------------------+------------------+
18682 | jit_temp_suffix  | OT_BOOL         | Use a temporary  | casadi::Function |
18683 |                  |                 | (seemingly       | Internal         |
18684 |                  |                 | random) filename |                  |
18685 |                  |                 | suffix for       |                  |
18686 |                  |                 | generated code   |                  |
18687 |                  |                 | and libraries.   |                  |
18688 |                  |                 | This is desired  |                  |
18689 |                  |                 | for thread-      |                  |
18690 |                  |                 | safety. This     |                  |
18691 |                  |                 | behaviour may    |                  |
18692 |                  |                 | defeat caching   |                  |
18693 |                  |                 | compiler         |                  |
18694 |                  |                 | wrappers.        |                  |
18695 |                  |                 | Default: true    |                  |
18696 +------------------+-----------------+------------------+------------------+
18697 | max_num_dir      | OT_INT          | Specify the      | casadi::Function |
18698 |                  |                 | maximum number   | Internal         |
18699 |                  |                 | of directions    |                  |
18700 |                  |                 | for derivative   |                  |
18701 |                  |                 | functions.       |                  |
18702 |                  |                 | Overrules the    |                  |
18703 |                  |                 | builtin optimize |                  |
18704 |                  |                 | d_num_dir.       |                  |
18705 +------------------+-----------------+------------------+------------------+
18706 | never_inline     | OT_BOOL         | Forbid inlining. | casadi::Function |
18707 |                  |                 |                  | Internal         |
18708 +------------------+-----------------+------------------+------------------+
18709 | output_scheme    | OT_STRINGVECTOR | Deprecated       | casadi::Function |
18710 |                  |                 | option (ignored) | Internal         |
18711 +------------------+-----------------+------------------+------------------+
18712 | print_in         | OT_BOOL         | Print numerical  | casadi::Function |
18713 |                  |                 | values of inputs | Internal         |
18714 |                  |                 | [default: false] |                  |
18715 +------------------+-----------------+------------------+------------------+
18716 | print_out        | OT_BOOL         | Print numerical  | casadi::Function |
18717 |                  |                 | values of        | Internal         |
18718 |                  |                 | outputs          |                  |
18719 |                  |                 | [default: false] |                  |
18720 +------------------+-----------------+------------------+------------------+
18721 | print_time       | OT_BOOL         | print            | casadi::Function |
18722 |                  |                 | information      | Internal         |
18723 |                  |                 | about execution  |                  |
18724 |                  |                 | time. Implies    |                  |
18725 |                  |                 | record_time.     |                  |
18726 +------------------+-----------------+------------------+------------------+
18727 | record_time      | OT_BOOL         | record           | casadi::Function |
18728 |                  |                 | information      | Internal         |
18729 |                  |                 | about execution  |                  |
18730 |                  |                 | time, for        |                  |
18731 |                  |                 | retrieval with   |                  |
18732 |                  |                 | stats().         |                  |
18733 +------------------+-----------------+------------------+------------------+
18734 | regularity_check | OT_BOOL         | Throw exceptions | casadi::Function |
18735 |                  |                 | when NaN or Inf  | Internal         |
18736 |                  |                 | appears during   |                  |
18737 |                  |                 | evaluation       |                  |
18738 +------------------+-----------------+------------------+------------------+
18739 | reverse_options  | OT_DICT         | Options to be    | casadi::Function |
18740 |                  |                 | passed to a      | Internal         |
18741 |                  |                 | reverse mode     |                  |
18742 |                  |                 | constructor      |                  |
18743 +------------------+-----------------+------------------+------------------+
18744 | user_data        | OT_VOIDPTR      | A user-defined   | casadi::Function |
18745 |                  |                 | field that can   | Internal         |
18746 |                  |                 | be used to       |                  |
18747 |                  |                 | identify the     |                  |
18748 |                  |                 | function or pass |                  |
18749 |                  |                 | additional       |                  |
18750 |                  |                 | information      |                  |
18751 +------------------+-----------------+------------------+------------------+
18752 | verbose          | OT_BOOL         | Verbose          | casadi::Function |
18753 |                  |                 | evaluation  for  | Internal         |
18754 |                  |                 | debugging        |                  |
18755 +------------------+-----------------+------------------+------------------+
18756 
18757 Diagrams
18758 --------
18759 
18760 
18761 
18762 C++ includes: expm_impl.hpp ";
18763 
18764 %feature("docstring")  casadi::FunctionInternal::get_abstol() const  "
18765 
18766 [INTERNAL]  Get absolute tolerance.
18767 
18768 ";
18769 
18770 %feature("docstring")  casadi::FunctionInternal::size1_out(casadi_int ind)
18771 const  "
18772 
18773 [INTERNAL]  Input/output dimensions.
18774 
18775 ";
18776 
18777 %feature("docstring")  casadi::FunctionInternal::sparsity_in(casadi_int ind)
18778 const  "
18779 
18780 [INTERNAL]  Input/output sparsity.
18781 
18782 ";
18783 
18784 %feature("docstring")  casadi::FunctionInternal::call_gen(const MXVector
18785 &arg, MXVector &res, casadi_int npar, bool always_inline, bool never_inline)
18786 const  "
18787 
18788 [INTERNAL]   Call a function, overloaded.
18789 
18790 ";
18791 
18792 %feature("docstring")  casadi::FunctionInternal::call_gen(const std::vector<
18793 MatrixCommon > &arg, std::vector< MatrixCommon > &res, casadi_int npar, bool
18794 always_inline, bool never_inline) const  "
18795 
18796 [INTERNAL]   Call a function, overloaded.
18797 
18798 ";
18799 
18800 %feature("docstring")
18801 casadi::FunctionInternal::codegen_init_mem(CodeGenerator &g) const  "
18802 
18803 [INTERNAL]  Codegen decref for init_mem.
18804 
18805 ";
18806 
18807 %feature("docstring")  casadi::FunctionInternal::generate_dependencies(const
18808 std::string &fname, const Dict &opts) const  "
18809 
18810 [INTERNAL]  Export / Generate C code for the dependency function.
18811 
18812 ";
18813 
18814 %feature("docstring")
18815 casadi::FunctionInternal::serialize_type(SerializingStream &s) const  "
18816 
18817 [INTERNAL]  Serialize type information.
18818 
18819 ";
18820 
18821 %feature("docstring")  casadi::PluginInterface< Expm
18822 >::serialize_type(SerializingStream &s) const "
18823 
18824 [INTERNAL]  Serialize type information.
18825 
18826 ";
18827 
18828 %feature("docstring")  casadi::FunctionInternal::get_jacobian(const
18829 std::string &name, const std::vector< std::string > &inames, const
18830 std::vector< std::string > &onames, const Dict &opts) const  "
18831 
18832 [INTERNAL]  Return Jacobian of all input elements with respect to all output
18833 elements.
18834 
18835 ";
18836 
18837 %feature("docstring")
18838 casadi::FunctionInternal::instruction_input(casadi_int k) const  "
18839 
18840 [INTERNAL]  Get the (integer) input arguments of an atomic operation.
18841 
18842 ";
18843 
18844 %feature("docstring")  casadi::FunctionInternal::n_nodes() const  "
18845 
18846 [INTERNAL]  Number of nodes in the algorithm.
18847 
18848 ";
18849 
18850 %feature("docstring")  casadi::FunctionInternal::codegen_name(const
18851 CodeGenerator &g, bool ns=true) const  "
18852 
18853 [INTERNAL]  Get name in codegen.
18854 
18855 ";
18856 
18857 %feature("docstring")  casadi::FunctionInternal::has_derivative() const  "
18858 
18859 [INTERNAL]  Can derivatives be calculated in any way?
18860 
18861 ";
18862 
18863 %feature("docstring")  casadi::ProtoFunction::serialize_base_function()
18864 const  "
18865 
18866 [INTERNAL]  String used to identify the immediate FunctionInternal subclass.
18867 
18868 ";
18869 
18870 %feature("docstring")  casadi::FunctionInternal::dm_out(casadi_int ind)
18871 const  "
18872 
18873 [INTERNAL]  Get function input(s) and output(s)
18874 
18875 ";
18876 
18877 %feature("docstring")  casadi::FunctionInternal::dm_out() const  "
18878 
18879 [INTERNAL]  Get function input(s) and output(s)
18880 
18881 ";
18882 
18883 %feature("docstring")  casadi::ProtoFunction::init_mem(void *mem) const  "
18884 
18885 [INTERNAL]  Initalize memory block.
18886 
18887 ";
18888 
18889 %feature("docstring")  casadi::FunctionInternal::codegen_mem_type() const  "
18890 
18891 [INTERNAL]  Thread-local memory object type.
18892 
18893 ";
18894 
18895 %feature("docstring")  casadi::FunctionInternal::symbolicAdjSeed(casadi_int
18896 nadj, const std::vector< MatType > &v) const  "
18897 
18898 [INTERNAL]  Symbolic expressions for the adjoint seeds.
18899 
18900 ";
18901 
18902 %feature("docstring")  casadi::ProtoFunction::release(int mem) const  "
18903 
18904 [INTERNAL]  Release a memory object.
18905 
18906 ";
18907 
18908 %feature("docstring")  casadi::FunctionInternal::signature(const std::string
18909 &fname) const  "
18910 
18911 [INTERNAL]  Code generate the function.
18912 
18913 ";
18914 
18915 %feature("docstring")  casadi::FunctionInternal::check_arg(const
18916 std::vector< M > &arg, casadi_int &npar) const  "
18917 
18918 [INTERNAL]  Check if input arguments have correct length and dimensions.
18919 
18920 Raises errors.
18921 
18922 Parameters:
18923 -----------
18924 
18925 npar[in]:  normal usage: 1, disallow pararallel calls: -1
18926 
18927 npar:  max number of horizontal repetitions across all arguments (or -1)
18928 
18929 ";
18930 
18931 %feature("docstring")  casadi::FunctionInternal::get_jacobian_sparsity()
18932 const  "
18933 
18934 [INTERNAL]  Get Jacobian sparsity.
18935 
18936 ";
18937 
18938 %feature("docstring")  casadi::Expm::has_reverse(casadi_int nadj) const  "
18939 
18940 [INTERNAL]  Generate a function that calculates nadj adjoint derivatives.
18941 
18942 ";
18943 
18944 %feature("docstring")  casadi::Expm::getJacSparsity(casadi_int iind,
18945 casadi_int oind, bool symmetric) const  "
18946 
18947 [INTERNAL]  Generate the sparsity of a Jacobian block.
18948 
18949 ";
18950 
18951 %feature("docstring")  casadi::FunctionInternal::eval_mx(const MXVector
18952 &arg, MXVector &res, bool always_inline, bool never_inline) const  "
18953 
18954 [INTERNAL]  Evaluate with symbolic matrices.
18955 
18956 ";
18957 
18958 %feature("docstring")  casadi::FunctionInternal::is_a(const std::string
18959 &type, bool recursive) const  "
18960 
18961 [INTERNAL]  Check if the function is of a particular type.
18962 
18963 ";
18964 
18965 %feature("docstring")  casadi::FunctionInternal::print_option(const
18966 std::string &name, std::ostream &stream) const  "
18967 
18968 [INTERNAL]  Print all information there is to know about a certain option.
18969 
18970 ";
18971 
18972 %feature("docstring")  casadi::FunctionInternal::oracle() const  "
18973 
18974 [INTERNAL]  Get oracle.
18975 
18976 ";
18977 
18978 %feature("docstring")  casadi::Expm::get_reverse(casadi_int nadj, const
18979 std::string &name, const std::vector< std::string > &inames, const
18980 std::vector< std::string > &onames, const Dict &opts) const  "
18981 
18982 [INTERNAL]  Generate a function that calculates nadj adjoint derivatives.
18983 
18984 ";
18985 
18986 %feature("docstring")  casadi::FunctionInternal::generate_out(const
18987 std::string &fname, double **res) const  "
18988 
18989 [INTERNAL] ";
18990 
18991 %feature("docstring")  casadi::FunctionInternal::get_free() const  "
18992 
18993 [INTERNAL]  Print free variables.
18994 
18995 ";
18996 
18997 %feature("docstring")  casadi::FunctionInternal::get_jac(const std::string
18998 &name, const std::vector< std::string > &inames, const std::vector<
18999 std::string > &onames, const Dict &opts) const  "
19000 
19001 [INTERNAL]  Return Jacobian of all input elements with respect to all output
19002 elements.
19003 
19004 ";
19005 
19006 %feature("docstring")  casadi::FunctionInternal::definition() const  "
19007 
19008 [INTERNAL]  Get function signature: name:(inputs)->(outputs)
19009 
19010 ";
19011 
19012 %feature("docstring")  casadi::Expm::has_forward(casadi_int nfwd) const  "
19013 
19014 [INTERNAL]  Generate a function that calculates nfwd forward derivatives.
19015 
19016 ";
19017 
19018 %feature("docstring")  casadi::FunctionInternal::jacobian_sparsity() const
19019 "
19020 
19021 [INTERNAL]  Get Jacobian sparsity.
19022 
19023 ";
19024 
19025 %feature("docstring")  casadi::FunctionInternal::tocache(const Function &f,
19026 const std::string &suffix="") const  "
19027 
19028 [INTERNAL]  Save function to cache.
19029 
19030 ";
19031 
19032 %feature("docstring")  casadi::FunctionInternal::sp_forward(const bvec_t
19033 **arg, bvec_t **res, casadi_int *iw, bvec_t *w, void *mem) const  "
19034 
19035 [INTERNAL]  Propagate sparsity forward.
19036 
19037 ";
19038 
19039 %feature("docstring")  casadi::SharedObjectInternal::weak() "
19040 
19041 [INTERNAL]  Get a weak reference to the object.
19042 
19043 ";
19044 
19045 %feature("docstring")  casadi::FunctionInternal::generate_in(const
19046 std::string &fname, const double **arg) const  "
19047 
19048 [INTERNAL]  Export an input file that can be passed to generate C code with
19049 a main.
19050 
19051 ";
19052 
19053 %feature("docstring")  casadi::FunctionInternal::alloc_res(size_t sz_res,
19054 bool persistent=false) "
19055 
19056 [INTERNAL]  Ensure required length of res field.
19057 
19058 ";
19059 
19060 %feature("docstring")  casadi::ProtoFunction::construct(const Dict &opts) "
19061 
19062 [INTERNAL]  Construct Prepares the function for evaluation.
19063 
19064 ";
19065 
19066 %feature("docstring")
19067 casadi::FunctionInternal::getJacSparsityHierarchical(casadi_int iind,
19068 casadi_int oind) const  "
19069 
19070 [INTERNAL]  A flavor of getJacSparsity that does hierarchical block
19071 structure recognition.
19072 
19073 ";
19074 
19075 %feature("docstring")  casadi::FunctionInternal::print_options(std::ostream
19076 &stream) const  "
19077 
19078 [INTERNAL]  Print list of options.
19079 
19080 ";
19081 
19082 %feature("docstring")  casadi::FunctionInternal::ad_weight() const  "
19083 
19084 [INTERNAL]  Weighting factor for chosing forward/reverse mode.
19085 
19086 ";
19087 
19088 %feature("docstring")  casadi::FunctionInternal::eval(const double **arg,
19089 double **res, casadi_int *iw, double *w, void *mem) const  "
19090 
19091 [INTERNAL]  Evaluate numerically.
19092 
19093 ";
19094 
19095 %feature("docstring")  casadi::FunctionInternal::sp_reverse(bvec_t **arg,
19096 bvec_t **res, casadi_int *iw, bvec_t *w, void *mem) const  "
19097 
19098 [INTERNAL]  Propagate sparsity backwards.
19099 
19100 ";
19101 
19102 %feature("docstring") casadi::Expm::~Expm "
19103 
19104 [INTERNAL] ";
19105 
19106 %feature("docstring")
19107 casadi::FunctionInternal::codegen_incref(CodeGenerator &g) const  "
19108 
19109 [INTERNAL]  Codegen incref for dependencies.
19110 
19111 ";
19112 
19113 %feature("docstring")
19114 casadi::FunctionInternal::codegen_free_mem(CodeGenerator &g) const  "
19115 
19116 [INTERNAL]  Codegen for free_mem.
19117 
19118 ";
19119 
19120 %feature("docstring")  casadi::FunctionInternal::nnz_out() const  "
19121 
19122 [INTERNAL]  Number of input/output nonzeros.
19123 
19124 ";
19125 
19126 %feature("docstring")  casadi::FunctionInternal::nnz_out(casadi_int ind)
19127 const  "
19128 
19129 [INTERNAL]  Number of input/output nonzeros.
19130 
19131 ";
19132 
19133 %feature("docstring")  casadi::FunctionInternal::get_max_in(casadi_int ind)
19134 const  "
19135 
19136 [INTERNAL]  Get largest input value.
19137 
19138 ";
19139 
19140 %feature("docstring")  casadi::ProtoFunction::print_time(const std::map<
19141 std::string, FStats > &fstats) const  "
19142 
19143 [INTERNAL]  Print timing statistics.
19144 
19145 ";
19146 
19147 %feature("docstring")  casadi::FunctionInternal::getAdaptorSolverName()
19148 const  "
19149 
19150 [INTERNAL]  Obtain solver name from Adaptor.
19151 
19152 ";
19153 
19154 %feature("docstring")  casadi::FunctionInternal::get_default_in(casadi_int
19155 ind) const  "
19156 
19157 [INTERNAL]  Get default input value.
19158 
19159 ";
19160 
19161 %feature("docstring")  casadi::FunctionInternal::slice(const std::string
19162 &name, const std::vector< casadi_int > &order_in, const std::vector<
19163 casadi_int > &order_out, const Dict &opts) const  "
19164 
19165 [INTERNAL]  returns a new function with a selection of inputs/outputs of the
19166 original
19167 
19168 ";
19169 
19170 %feature("docstring")  casadi::SharedObjectInternal::class_name() const  "
19171 
19172 [INTERNAL]  Readable name of the internal class.
19173 
19174 ";
19175 
19176 %feature("docstring")  casadi::FunctionInternal::sparsity_jac(casadi_int
19177 iind, casadi_int oind, bool compact, bool symmetric) const  "
19178 
19179 [INTERNAL]  Get, if necessary generate, the sparsity of a Jacobian block.
19180 
19181 ";
19182 
19183 %feature("docstring")  casadi::ProtoFunction::memory(int ind) const  "
19184 
19185 [INTERNAL]  Memory objects.
19186 
19187 ";
19188 
19189 %feature("docstring")  casadi::ProtoFunction::sprint(char *buf, size_t
19190 buf_sz, const char *fmt,...) const  "
19191 
19192 [INTERNAL]  C-style formatted printing to string.
19193 
19194 ";
19195 
19196 
19197 // File: classcasadi_1_1External.xml
19198 %feature("docstring")  casadi::FunctionInternal::call_reverse(const
19199 std::vector< MX > &arg, const std::vector< MX > &res, const std::vector<
19200 std::vector< MX > > &aseed, std::vector< std::vector< MX > > &asens, bool
19201 always_inline, bool never_inline) const  "
19202 
19203 [INTERNAL]  Reverse mode, virtual functions overloaded in derived classes.
19204 
19205 ";
19206 
19207 %feature("docstring")  casadi::FunctionInternal::call_reverse(const
19208 std::vector< SX > &arg, const std::vector< SX > &res, const std::vector<
19209 std::vector< SX > > &aseed, std::vector< std::vector< SX > > &asens, bool
19210 always_inline, bool never_inline) const  "
19211 
19212 [INTERNAL]  Reverse mode, virtual functions overloaded in derived classes.
19213 
19214 ";
19215 
19216 %feature("docstring")  casadi::FunctionInternal::jacobian() const  "
19217 
19218 [INTERNAL]  Return Jacobian of all input elements with respect to all output
19219 elements.
19220 
19221 ";
19222 
19223 %feature("docstring")  casadi::FunctionInternal::check_arg(const
19224 std::vector< M > &arg, casadi_int &npar) const  "
19225 
19226 [INTERNAL]  Check if input arguments have correct length and dimensions.
19227 
19228 Raises errors.
19229 
19230 Parameters:
19231 -----------
19232 
19233 npar[in]:  normal usage: 1, disallow pararallel calls: -1
19234 
19235 npar:  max number of horizontal repetitions across all arguments (or -1)
19236 
19237 ";
19238 
19239 %feature("docstring")  casadi::FunctionInternal::project_arg(const
19240 std::vector< M > &arg, casadi_int npar) const  "
19241 
19242 [INTERNAL]   Project sparsities.
19243 
19244 ";
19245 
19246 %feature("docstring")  casadi::FunctionInternal::generate_in(const
19247 std::string &fname, const double **arg) const  "
19248 
19249 [INTERNAL]  Export an input file that can be passed to generate C code with
19250 a main.
19251 
19252 ";
19253 
19254 %feature("docstring")  casadi::FunctionInternal::nnz_in() const  "
19255 
19256 [INTERNAL]  Number of input/output nonzeros.
19257 
19258 ";
19259 
19260 %feature("docstring")  casadi::FunctionInternal::nnz_in(casadi_int ind)
19261 const  "
19262 
19263 [INTERNAL]  Number of input/output nonzeros.
19264 
19265 ";
19266 
19267 %feature("docstring")  casadi::FunctionInternal::alloc_res(size_t sz_res,
19268 bool persistent=false) "
19269 
19270 [INTERNAL]  Ensure required length of res field.
19271 
19272 ";
19273 
19274 %feature("docstring")  casadi::FunctionInternal::sparsity_out(casadi_int
19275 ind) const  "
19276 
19277 [INTERNAL]  Input/output sparsity.
19278 
19279 ";
19280 
19281 %feature("docstring")  casadi::FunctionInternal::replace_arg(const
19282 std::vector< M > &arg, casadi_int npar) const  "
19283 
19284 [INTERNAL]  Replace 0-by-0 inputs.
19285 
19286 ";
19287 
19288 %feature("docstring")  casadi::FunctionInternal::alloc_arg(size_t sz_arg,
19289 bool persistent=false) "
19290 
19291 [INTERNAL]  Ensure required length of arg field.
19292 
19293 ";
19294 
19295 %feature("docstring")  casadi::ProtoFunction::init_mem(void *mem) const  "
19296 
19297 [INTERNAL]  Initalize memory block.
19298 
19299 ";
19300 
19301 %feature("docstring")  casadi::External::get_name_in(casadi_int i)  "
19302 
19303 [INTERNAL]  Names of function input and outputs.
19304 
19305 ";
19306 
19307 %feature("docstring")
19308 casadi::FunctionInternal::codegen_decref(CodeGenerator &g) const  "
19309 
19310 [INTERNAL]  Codegen decref for dependencies.
19311 
19312 ";
19313 
19314 %feature("docstring")  casadi::FunctionInternal::mapsum_mx(const
19315 std::vector< MX > &arg, const std::string &parallelization) "
19316 
19317 [INTERNAL]  Parallel evaluation.
19318 
19319 ";
19320 
19321 %feature("docstring")  casadi::FunctionInternal::sx_out(casadi_int ind)
19322 const  "
19323 
19324 [INTERNAL]  Get function input(s) and output(s)
19325 
19326 ";
19327 
19328 %feature("docstring")  casadi::FunctionInternal::sx_out() const  "
19329 
19330 [INTERNAL]  Get function input(s) and output(s)
19331 
19332 ";
19333 
19334 %feature("docstring")  casadi::FunctionInternal::get_jacobian_sparsity()
19335 const  "
19336 
19337 [INTERNAL]  Get Jacobian sparsity.
19338 
19339 ";
19340 
19341 %feature("docstring")  casadi::External::has_forward(casadi_int nfwd) const
19342 "
19343 
19344 [INTERNAL]  Forward mode derivatives.
19345 
19346 ";
19347 
19348 %feature("docstring")  casadi::FunctionInternal::call(const std::vector< M >
19349 &arg, std::vector< M > &res, bool always_inline, bool never_inline) const  "
19350 
19351 [INTERNAL]   Call a function, templated.
19352 
19353 ";
19354 
19355 %feature("docstring")
19356 casadi::FunctionInternal::instruction_output(casadi_int k) const  "
19357 
19358 [INTERNAL]  Get the (integer) output argument of an atomic operation.
19359 
19360 ";
19361 
19362 %feature("docstring")  casadi::FunctionInternal::call_forward(const
19363 std::vector< MX > &arg, const std::vector< MX > &res, const std::vector<
19364 std::vector< MX > > &fseed, std::vector< std::vector< MX > > &fsens, bool
19365 always_inline, bool never_inline) const  "
19366 
19367 [INTERNAL]  Forward mode AD, virtual functions overloaded in derived
19368 classes.
19369 
19370 ";
19371 
19372 %feature("docstring")  casadi::FunctionInternal::call_forward(const
19373 std::vector< SX > &arg, const std::vector< SX > &res, const std::vector<
19374 std::vector< SX > > &fseed, std::vector< std::vector< SX > > &fsens, bool
19375 always_inline, bool never_inline) const  "
19376 
19377 [INTERNAL]  Forward mode AD, virtual functions overloaded in derived
19378 classes.
19379 
19380 ";
19381 
19382 %feature("docstring")  casadi::ProtoFunction::checkout() const  "
19383 
19384 [INTERNAL]  Checkout a memory object.
19385 
19386 ";
19387 
19388 %feature("docstring")  casadi::External::serialize_base_function() const  "
19389 
19390 [INTERNAL]  String used to identify the immediate FunctionInternal subclass.
19391 
19392 ";
19393 
19394 %feature("docstring")  casadi::FunctionInternal::map(casadi_int n, const
19395 std::string &parallelization) const  "
19396 
19397 [INTERNAL]  Generate/retrieve cached serial map.
19398 
19399 ";
19400 
19401 %feature("docstring")  casadi::External::class_name() const  "
19402 
19403 [INTERNAL]  Get type name.
19404 
19405 ";
19406 
19407 %feature("docstring")  casadi::FunctionInternal::disp_more(std::ostream
19408 &stream) const  "
19409 
19410 [INTERNAL]  Print more.
19411 
19412 ";
19413 
19414 %feature("docstring")  casadi::FunctionInternal::dm_out(casadi_int ind)
19415 const  "
19416 
19417 [INTERNAL]  Get function input(s) and output(s)
19418 
19419 ";
19420 
19421 %feature("docstring")  casadi::FunctionInternal::dm_out() const  "
19422 
19423 [INTERNAL]  Get function input(s) and output(s)
19424 
19425 ";
19426 
19427 %feature("docstring")
19428 casadi::FunctionInternal::instruction_input(casadi_int k) const  "
19429 
19430 [INTERNAL]  Get the (integer) input arguments of an atomic operation.
19431 
19432 ";
19433 
19434 %feature("docstring")  casadi::FunctionInternal::free_mx() const  "
19435 
19436 [INTERNAL]  Get free variables ( MX)
19437 
19438 ";
19439 
19440 %feature("docstring")  casadi::FunctionInternal::check_mat(const Sparsity
19441 &arg, const Sparsity &inp, casadi_int &npar) "
19442 
19443 [INTERNAL]  Helper function
19444 
19445 Parameters:
19446 -----------
19447 
19448 npar[in]:  normal usage: 1, disallow pararallel calls: -1
19449 
19450 npar[out]:  required number of parallel calls (or -1)
19451 
19452 ";
19453 
19454 %feature("docstring")  casadi::FunctionInternal::signature(const std::string
19455 &fname) const  "
19456 
19457 [INTERNAL]  Code generate the function.
19458 
19459 ";
19460 
19461 %feature("docstring")  casadi::FunctionInternal::index_out(const std::string
19462 &name) const  "
19463 
19464 [INTERNAL]  Get output scheme index by name.
19465 
19466 ";
19467 
19468 %feature("docstring")  casadi::FunctionInternal::sparsity_in(casadi_int ind)
19469 const  "
19470 
19471 [INTERNAL]  Input/output sparsity.
19472 
19473 ";
19474 
19475 %feature("docstring")  casadi::FunctionInternal::sx_in(casadi_int ind) const
19476 "
19477 
19478 [INTERNAL]  Get function input(s) and output(s)
19479 
19480 ";
19481 
19482 %feature("docstring")  casadi::FunctionInternal::sx_in() const  "
19483 
19484 [INTERNAL]  Get function input(s) and output(s)
19485 
19486 ";
19487 
19488 %feature("docstring")  casadi::FunctionInternal::sp_weight() const  "
19489 
19490 [INTERNAL]  Weighting factor for chosing forward/reverse mode, sparsity
19491 propagation.
19492 
19493 ";
19494 
19495 %feature("docstring")  casadi::FunctionInternal::alloc(const Function &f,
19496 bool persistent=false) "
19497 
19498 [INTERNAL]  Ensure work vectors long enough to evaluate function.
19499 
19500 ";
19501 
19502 %feature("docstring")  casadi::FunctionInternal::get_jac(const std::string
19503 &name, const std::vector< std::string > &inames, const std::vector<
19504 std::string > &onames, const Dict &opts) const  "
19505 
19506 [INTERNAL]  Return Jacobian of all input elements with respect to all output
19507 elements.
19508 
19509 ";
19510 
19511 %feature("docstring")  casadi::FunctionInternal::codegen_mem_type() const  "
19512 
19513 [INTERNAL]  Thread-local memory object type.
19514 
19515 ";
19516 
19517 %feature("docstring")  casadi::FunctionInternal::ad_weight() const  "
19518 
19519 [INTERNAL]  Weighting factor for chosing forward/reverse mode.
19520 
19521 ";
19522 
19523 %feature("docstring")  casadi::FunctionInternal::tocache(const Function &f,
19524 const std::string &suffix="") const  "
19525 
19526 [INTERNAL]  Save function to cache.
19527 
19528 ";
19529 
19530 %feature("docstring")  casadi::FunctionInternal::size_out(casadi_int ind)
19531 const  "
19532 
19533 [INTERNAL]  Input/output dimensions.
19534 
19535 ";
19536 
19537 %feature("docstring")  casadi::FunctionInternal::has_derivative() const  "
19538 
19539 [INTERNAL]  Can derivatives be calculated in any way?
19540 
19541 ";
19542 
19543 %feature("docstring")  casadi::ProtoFunction::sprint(char *buf, size_t
19544 buf_sz, const char *fmt,...) const  "
19545 
19546 [INTERNAL]  C-style formatted printing to string.
19547 
19548 ";
19549 
19550 %feature("docstring")  casadi::FunctionInternal::is_a(const std::string
19551 &type, bool recursive) const  "
19552 
19553 [INTERNAL]  Check if the function is of a particular type.
19554 
19555 ";
19556 
19557 %feature("docstring")  casadi::FunctionInternal::get_free() const  "
19558 
19559 [INTERNAL]  Print free variables.
19560 
19561 ";
19562 
19563 %feature("docstring")  casadi::FunctionInternal::export_code(const
19564 std::string &lang, std::ostream &stream, const Dict &options) const  "
19565 
19566 [INTERNAL]  Export function in a specific language.
19567 
19568 ";
19569 
19570 %feature("docstring")  casadi::FunctionInternal::getAdaptorSolverName()
19571 const  "
19572 
19573 [INTERNAL]  Obtain solver name from Adaptor.
19574 
19575 ";
19576 
19577 %feature("docstring")  casadi::FunctionInternal::sz_arg() const  "
19578 
19579 [INTERNAL]  Get required length of arg field.
19580 
19581 ";
19582 
19583 %feature("docstring")  casadi::FunctionInternal::set_temp(void *mem, const
19584 double **arg, double **res, casadi_int *iw, double *w) const  "
19585 
19586 [INTERNAL]  Set the (temporary) work vectors.
19587 
19588 ";
19589 
19590 %feature("docstring")  casadi::FunctionInternal::codegen_name(const
19591 CodeGenerator &g, bool ns=true) const  "
19592 
19593 [INTERNAL]  Get name in codegen.
19594 
19595 ";
19596 
19597 %feature("docstring")  casadi::FunctionInternal::disp(std::ostream &stream,
19598 bool more) const  "
19599 
19600 [INTERNAL]  Display object.
19601 
19602 ";
19603 
19604 %feature("docstring")  casadi::FunctionInternal::jacobian_sparsity() const
19605 "
19606 
19607 [INTERNAL]  Get Jacobian sparsity.
19608 
19609 ";
19610 
19611 %feature("docstring")
19612 casadi::FunctionInternal::print_dimensions(std::ostream &stream) const  "
19613 
19614 [INTERNAL]  Print dimensions of inputs and outputs.
19615 
19616 ";
19617 
19618 %feature("docstring")  casadi::ProtoFunction::serialize(SerializingStream
19619 &s) const  "
19620 
19621 [INTERNAL]  Serialize an object.
19622 
19623 ";
19624 
19625 %feature("docstring")  casadi::FunctionInternal::replace_res(const
19626 std::vector< M > &res, casadi_int npar) const  "
19627 
19628 [INTERNAL]  Replace 0-by-0 outputs.
19629 
19630 ";
19631 
19632 %feature("docstring")
19633 casadi::FunctionInternal::jacobian_sparsity_filter(const Sparsity &sp) const
19634 "
19635 
19636 [INTERNAL]  Filter out nonzeros in the full sparsity jacobian according to
19637 is_diff_in/out.
19638 
19639 ";
19640 
19641 %feature("docstring")  casadi::FunctionInternal::all_scalar() const  "
19642 
19643 [INTERNAL]  Are all inputs and outputs scalar.
19644 
19645 ";
19646 
19647 %feature("docstring")  casadi::FunctionInternal::get_sparsity_out(casadi_int
19648 i) "
19649 
19650 [INTERNAL]  Get sparsity of a given output.
19651 
19652 ";
19653 
19654 %feature("docstring")  casadi::External::get_reverse(casadi_int nadj, const
19655 std::string &name, const std::vector< std::string > &inames, const
19656 std::vector< std::string > &onames, const Dict &opts) const  "
19657 
19658 [INTERNAL]  Reverse mode derivatives.
19659 
19660 ";
19661 
19662 %feature("docstring")  casadi::FunctionInternal::convert_res(const
19663 std::vector< M > &res) const  "
19664 
19665 [INTERNAL]  Convert from/to input/output lists/map.
19666 
19667 ";
19668 
19669 %feature("docstring")  casadi::FunctionInternal::convert_res(const std::map<
19670 std::string, M > &res) const  "
19671 
19672 [INTERNAL]  Convert from/to input/output lists/map.
19673 
19674 ";
19675 
19676 %feature("docstring")  casadi::ProtoFunction::print(const char *fmt,...)
19677 const  "
19678 
19679 [INTERNAL]  C-style formatted printing during evaluation.
19680 
19681 ";
19682 
19683 %feature("docstring")  casadi::FunctionInternal::has_eval_dm() const  "
19684 
19685 [INTERNAL]  Evaluate with DM matrices.
19686 
19687 ";
19688 
19689 %feature("docstring")
19690 casadi::FunctionInternal::serialize_type(SerializingStream &s) const  "
19691 
19692 [INTERNAL]  Serialize type information.
19693 
19694 ";
19695 
19696 %feature("docstring")  casadi::External::factory(const std::string &name,
19697 const std::vector< std::string > &s_in, const std::vector< std::string >
19698 &s_out, const Function::AuxOut &aux, const Dict &opts) const  "
19699 
19700 [INTERNAL] ";
19701 
19702 %feature("docstring")  casadi::FunctionInternal::codegen_mem(CodeGenerator
19703 &g, const std::string &index="mem") const  "
19704 
19705 [INTERNAL]  Get thread-local memory object.
19706 
19707 ";
19708 
19709 %feature("docstring")  casadi::FunctionInternal::self() const  "
19710 
19711 [INTERNAL]  Get a public class instance.
19712 
19713 ";
19714 
19715 %feature("docstring")  casadi::ProtoFunction::free_mem(void *mem) const  "
19716 
19717 [INTERNAL]  Free memory block.
19718 
19719 ";
19720 
19721 %feature("docstring") casadi::External "
19722 
19723 [INTERNAL] C++ includes: external_impl.hpp ";
19724 
19725 %feature("docstring")
19726 casadi::FunctionInternal::codegen_sparsities(CodeGenerator &g) const  "
19727 
19728 [INTERNAL]  Codegen sparsities.
19729 
19730 ";
19731 
19732 %feature("docstring")  casadi::FunctionInternal::has_free() const  "
19733 
19734 [INTERNAL]  Does the function have free variables.
19735 
19736 ";
19737 
19738 %feature("docstring")  casadi::FunctionInternal::get_reltol() const  "
19739 
19740 [INTERNAL]  Get relative tolerance.
19741 
19742 ";
19743 
19744 %feature("docstring")  casadi::FunctionInternal::alloc_w(size_t sz_w, bool
19745 persistent=false) "
19746 
19747 [INTERNAL]  Ensure required length of w field.
19748 
19749 ";
19750 
19751 %feature("docstring")  casadi::FunctionInternal::matching_res(const
19752 std::vector< M > &arg, casadi_int &npar) const  "
19753 
19754 [INTERNAL]  Check if output arguments that needs to be replaced.
19755 
19756 Raises errors
19757 
19758 Parameters:
19759 -----------
19760 
19761 npar[in]:  normal usage: 1, disallow pararallel calls: -1
19762 
19763 npar:  max number of horizontal repetitions across all arguments (or -1)
19764 
19765 ";
19766 
19767 %feature("docstring")  casadi::ProtoFunction::format_time(char *buffer,
19768 double time) const  "
19769 
19770 [INTERNAL]  Format time in a fixed width 8 format.
19771 
19772 ";
19773 
19774 %feature("docstring")  casadi::SharedObjectInternal::weak() "
19775 
19776 [INTERNAL]  Get a weak reference to the object.
19777 
19778 ";
19779 
19780 %feature("docstring")  casadi::ProtoFunction::construct(const Dict &opts) "
19781 
19782 [INTERNAL]  Construct Prepares the function for evaluation.
19783 
19784 ";
19785 
19786 %feature("docstring")  casadi::FunctionInternal::has_jacobian_sparsity()
19787 const  "
19788 
19789 [INTERNAL]  Get Jacobian sparsity.
19790 
19791 ";
19792 
19793 %feature("docstring")  casadi::FunctionInternal::mx_out(casadi_int ind)
19794 const  "
19795 
19796 [INTERNAL]  Get function input(s) and output(s)
19797 
19798 ";
19799 
19800 %feature("docstring")  casadi::FunctionInternal::mx_out() const  "
19801 
19802 [INTERNAL]  Get function input(s) and output(s)
19803 
19804 ";
19805 
19806 %feature("docstring") casadi::External::External(const std::string &name,
19807 const Importer &li) "
19808 
19809 [INTERNAL]  Constructor.
19810 
19811 ";
19812 
19813 %feature("docstring")  casadi::FunctionInternal::print_options(std::ostream
19814 &stream) const  "
19815 
19816 [INTERNAL]  Print list of options.
19817 
19818 ";
19819 
19820 %feature("docstring")  casadi::FunctionInternal::is_diff_in(casadi_int i) "
19821 
19822 [INTERNAL] ";
19823 
19824 %feature("docstring")  casadi::FunctionInternal::get_function() const  "
19825 
19826 [INTERNAL] ";
19827 
19828 %feature("docstring")  casadi::FunctionInternal::get_function(const
19829 std::string &name) const  "
19830 
19831 [INTERNAL] ";
19832 
19833 %feature("docstring")  casadi::FunctionInternal::set_work(void *mem, const
19834 double **&arg, double **&res, casadi_int *&iw, double *&w) const  "
19835 
19836 [INTERNAL]  Set the (persistent) work vectors.
19837 
19838 ";
19839 
19840 %feature("docstring")  casadi::FunctionInternal::fwd_seed(casadi_int nfwd)
19841 const  "
19842 
19843 [INTERNAL]  Symbolic expressions for the forward seeds.
19844 
19845 ";
19846 
19847 %feature("docstring")  casadi::FunctionInternal::reverse(casadi_int nadj)
19848 const  "
19849 
19850 [INTERNAL]  Return function that calculates adjoint derivatives
19851 reverse(nadj) returns a cached instance if available, and calls  Function
19852 get_reverse(casadi_int nadj) if no cached version is available.
19853 
19854 ";
19855 
19856 %feature("docstring")
19857 casadi::FunctionInternal::codegen_incref(CodeGenerator &g) const  "
19858 
19859 [INTERNAL]  Codegen incref for dependencies.
19860 
19861 ";
19862 
19863 %feature("docstring")  casadi::External::codegen_declarations(CodeGenerator
19864 &g) const  "
19865 
19866 [INTERNAL]  Generate code for the declarations of the C function.
19867 
19868 ";
19869 
19870 %feature("docstring")  casadi::FunctionInternal::has_codegen() const  "
19871 
19872 [INTERNAL]  Is codegen supported?
19873 
19874 ";
19875 
19876 %feature("docstring")  casadi::FunctionInternal::size1_in(casadi_int ind)
19877 const  "
19878 
19879 [INTERNAL]  Input/output dimensions.
19880 
19881 ";
19882 
19883 %feature("docstring")  casadi::External::init_external() "
19884 
19885 [INTERNAL]  Initialize members that are unique.
19886 
19887 ";
19888 
19889 %feature("docstring")  casadi::FunctionInternal::has_function(const
19890 std::string &fname) const  "
19891 
19892 [INTERNAL] ";
19893 
19894 %feature("docstring")  casadi::FunctionInternal::dm_in(casadi_int ind) const
19895 "
19896 
19897 [INTERNAL]  Get function input(s) and output(s)
19898 
19899 ";
19900 
19901 %feature("docstring")  casadi::FunctionInternal::dm_in() const  "
19902 
19903 [INTERNAL]  Get function input(s) and output(s)
19904 
19905 ";
19906 
19907 %feature("docstring")  casadi::ProtoFunction::get_stats(void *mem) const  "
19908 
19909 [INTERNAL]  Get all statistics.
19910 
19911 ";
19912 
19913 %feature("docstring")  casadi::FunctionInternal::sp_forward(const bvec_t
19914 **arg, bvec_t **res, casadi_int *iw, bvec_t *w, void *mem) const  "
19915 
19916 [INTERNAL]  Propagate sparsity forward.
19917 
19918 ";
19919 
19920 %feature("docstring")  casadi::External::init(const Dict &opts)  "
19921 
19922 [INTERNAL]  Initialize.
19923 
19924 ";
19925 
19926 %feature("docstring")  casadi::FunctionInternal::symbolic_output(const
19927 std::vector< MX > &arg) const  "
19928 
19929 [INTERNAL]  Get a vector of symbolic variables corresponding to the outputs.
19930 
19931 ";
19932 
19933 %feature("docstring")  casadi::FunctionInternal::generate_out(const
19934 std::string &fname, double **res) const  "
19935 
19936 [INTERNAL] ";
19937 
19938 %feature("docstring")  casadi::FunctionInternal::eval_mx(const MXVector
19939 &arg, MXVector &res, bool always_inline, bool never_inline) const  "
19940 
19941 [INTERNAL]  Evaluate with symbolic matrices.
19942 
19943 ";
19944 
19945 %feature("docstring")  casadi::FunctionInternal::index_in(const std::string
19946 &name) const  "
19947 
19948 [INTERNAL]  Get input scheme index by name.
19949 
19950 ";
19951 
19952 %feature("docstring")  casadi::FunctionInternal::forward(casadi_int nfwd)
19953 const  "
19954 
19955 [INTERNAL]  Return function that calculates forward derivatives
19956 forward(nfwd) returns a cached instance if available, and calls  Function
19957 get_forward(casadi_int nfwd) if no cached version is available.
19958 
19959 ";
19960 
19961 %feature("docstring")  casadi::ProtoFunction::memory(int ind) const  "
19962 
19963 [INTERNAL]  Memory objects.
19964 
19965 ";
19966 
19967 %feature("docstring")  casadi::FunctionInternal::jac() const  "
19968 
19969 [INTERNAL]  Return Jacobian of all input elements with respect to all output
19970 elements.
19971 
19972 ";
19973 
19974 %feature("docstring")
19975 casadi::FunctionInternal::codegen_init_mem(CodeGenerator &g) const  "
19976 
19977 [INTERNAL]  Codegen decref for init_mem.
19978 
19979 ";
19980 
19981 %feature("docstring")  casadi::External::get_n_out()  "
19982 
19983 [INTERNAL]  Number of function inputs and outputs.
19984 
19985 ";
19986 
19987 %feature("docstring") casadi::External::~External "
19988 
19989 [INTERNAL]  Destructor.
19990 
19991 ";
19992 
19993 %feature("docstring")  casadi::FunctionInternal::slice(const std::string
19994 &name, const std::vector< casadi_int > &order_in, const std::vector<
19995 casadi_int > &order_out, const Dict &opts) const  "
19996 
19997 [INTERNAL]  returns a new function with a selection of inputs/outputs of the
19998 original
19999 
20000 ";
20001 
20002 %feature("docstring")  casadi::FunctionInternal::alloc_iw(size_t sz_iw, bool
20003 persistent=false) "
20004 
20005 [INTERNAL]  Ensure required length of iw field.
20006 
20007 ";
20008 
20009 %feature("docstring")  casadi::FunctionInternal::sparsity_jac(casadi_int
20010 iind, casadi_int oind, bool compact, bool symmetric) const  "
20011 
20012 [INTERNAL]  Get, if necessary generate, the sparsity of a Jacobian block.
20013 
20014 ";
20015 
20016 %feature("docstring")  casadi::FunctionInternal::n_nodes() const  "
20017 
20018 [INTERNAL]  Number of nodes in the algorithm.
20019 
20020 ";
20021 
20022 %feature("docstring")
20023 casadi::FunctionInternal::instruction_constant(casadi_int k) const  "
20024 
20025 [INTERNAL]  Get the floating point output argument of an atomic operation.
20026 
20027 ";
20028 
20029 %feature("docstring")  casadi::FunctionInternal::instruction_id(casadi_int
20030 k) const  "
20031 
20032 [INTERNAL]  Get an atomic operation operator index.
20033 
20034 ";
20035 
20036 %feature("docstring")  casadi::FunctionInternal::call_gen(const MXVector
20037 &arg, MXVector &res, casadi_int npar, bool always_inline, bool never_inline)
20038 const  "
20039 
20040 [INTERNAL]   Call a function, overloaded.
20041 
20042 ";
20043 
20044 %feature("docstring")  casadi::FunctionInternal::call_gen(const std::vector<
20045 MatrixCommon > &arg, std::vector< MatrixCommon > &res, casadi_int npar, bool
20046 always_inline, bool never_inline) const  "
20047 
20048 [INTERNAL]   Call a function, overloaded.
20049 
20050 ";
20051 
20052 %feature("docstring")  casadi::FunctionInternal::has_spfwd() const  "
20053 
20054 [INTERNAL]  Is the class able to propagate seeds through the algorithm?
20055 
20056 ";
20057 
20058 %feature("docstring")  casadi::FunctionInternal::replace_fseed(const
20059 std::vector< std::vector< M >> &fseed, casadi_int npar) const  "
20060 
20061 [INTERNAL]  Replace 0-by-0 forward seeds.
20062 
20063 ";
20064 
20065 %feature("docstring")  casadi::FunctionInternal::replace_fseed(const
20066 std::vector< std::vector< M > > &fseed, casadi_int npar) const  "
20067 
20068 [INTERNAL] ";
20069 
20070 %feature("docstring")  casadi::External::get_name_out(casadi_int i)  "
20071 
20072 [INTERNAL]  Names of function input and outputs.
20073 
20074 ";
20075 
20076 %feature("docstring")  casadi::FunctionInternal::getJacSparsity(casadi_int
20077 iind, casadi_int oind, bool symmetric) const  "
20078 
20079 [INTERNAL]  Generate the sparsity of a Jacobian block.
20080 
20081 ";
20082 
20083 %feature("docstring")  casadi::FunctionInternal::instruction_MX(casadi_int
20084 k) const  "
20085 
20086 [INTERNAL]  get MX expression associated with instruction
20087 
20088 ";
20089 
20090 %feature("docstring")  casadi::FunctionInternal::sz_res() const  "
20091 
20092 [INTERNAL]  Get required length of res field.
20093 
20094 ";
20095 
20096 %feature("docstring")  casadi::FunctionInternal::get_options() const  "
20097 
20098 [INTERNAL]  Options.
20099 
20100 ";
20101 
20102 %feature("docstring")  casadi::FunctionInternal::has_jac() const  "
20103 
20104 [INTERNAL]  Return Jacobian of all input elements with respect to all output
20105 elements.
20106 
20107 ";
20108 
20109 %feature("docstring")
20110 casadi::FunctionInternal::codegen_free_mem(CodeGenerator &g) const  "
20111 
20112 [INTERNAL]  Codegen for free_mem.
20113 
20114 ";
20115 
20116 %feature("docstring")  casadi::ProtoFunction::alloc_mem() const  "
20117 
20118 [INTERNAL]  Create memory block.
20119 
20120 ";
20121 
20122 %feature("docstring")  casadi::FunctionInternal::numel_in() const  "
20123 
20124 [INTERNAL]  Number of input/output elements.
20125 
20126 ";
20127 
20128 %feature("docstring")  casadi::FunctionInternal::numel_in(casadi_int ind)
20129 const  "
20130 
20131 [INTERNAL]  Number of input/output elements.
20132 
20133 ";
20134 
20135 %feature("docstring")  casadi::ProtoFunction::release(int mem) const  "
20136 
20137 [INTERNAL]  Release a memory object.
20138 
20139 ";
20140 
20141 %feature("docstring")  casadi::ProtoFunction::print_time(const std::map<
20142 std::string, FStats > &fstats) const  "
20143 
20144 [INTERNAL]  Print timing statistics.
20145 
20146 ";
20147 
20148 %feature("docstring")  casadi::FunctionInternal::incache(const std::string
20149 &fname, Function &f, const std::string &suffix="") const  "
20150 
20151 [INTERNAL]  Get function in cache.
20152 
20153 ";
20154 
20155 %feature("docstring")  casadi::FunctionInternal::sz_w() const  "
20156 
20157 [INTERNAL]  Get required length of w field.
20158 
20159 ";
20160 
20161 %feature("docstring")  casadi::FunctionInternal::nz_in(const std::vector< DM
20162 > &arg) const  "
20163 
20164 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
20165 
20166 ";
20167 
20168 %feature("docstring")  casadi::FunctionInternal::nz_in(const std::vector<
20169 double > &arg) const  "
20170 
20171 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
20172 
20173 ";
20174 
20175 %feature("docstring")  casadi::FunctionInternal::has_sprev() const  "
20176 
20177 [INTERNAL]  Is the class able to propagate seeds through the algorithm?
20178 
20179 ";
20180 
20181 %feature("docstring")  casadi::FunctionInternal::definition() const  "
20182 
20183 [INTERNAL]  Get function signature: name:(inputs)->(outputs)
20184 
20185 ";
20186 
20187 %feature("docstring")  casadi::FunctionInternal::generate_options(bool
20188 is_temp=false) const  "
20189 
20190 [INTERNAL]  Reconstruct options dict.
20191 
20192 ";
20193 
20194 %feature("docstring")  casadi::FunctionInternal::uses_output() const  "
20195 
20196 [INTERNAL]  Do the derivative functions need nondifferentiated outputs?
20197 
20198 ";
20199 
20200 %feature("docstring")
20201 casadi::FunctionInternal::getJacSparsityGen(casadi_int iind, casadi_int
20202 oind, bool symmetric, casadi_int gr_i=1, casadi_int gr_o=1) const  "
20203 
20204 [INTERNAL]  Get the sparsity pattern, forward mode.
20205 
20206 ";
20207 
20208 %feature("docstring")  casadi::FunctionInternal::size_in(casadi_int ind)
20209 const  "
20210 
20211 [INTERNAL]  Input/output dimensions.
20212 
20213 ";
20214 
20215 %feature("docstring")  casadi::External::get_n_in()  "
20216 
20217 [INTERNAL]  Number of function inputs and outputs.
20218 
20219 ";
20220 
20221 %feature("docstring")  casadi::FunctionInternal::wrap_as_needed(const Dict
20222 &opts) const  "
20223 
20224 [INTERNAL]  Wrap in an Function instance consisting of only one MX call.
20225 
20226 ";
20227 
20228 %feature("docstring")  casadi::External::has_reverse(casadi_int nadj) const
20229 "
20230 
20231 [INTERNAL]  Reverse mode derivatives.
20232 
20233 ";
20234 
20235 %feature("docstring")  casadi::FunctionInternal::mx_in(casadi_int ind) const
20236 "
20237 
20238 [INTERNAL]  Get function input(s) and output(s)
20239 
20240 ";
20241 
20242 %feature("docstring")  casadi::FunctionInternal::mx_in() const  "
20243 
20244 [INTERNAL]  Get function input(s) and output(s)
20245 
20246 ";
20247 
20248 %feature("docstring")
20249 casadi::FunctionInternal::getJacSparsityHierarchical(casadi_int iind,
20250 casadi_int oind) const  "
20251 
20252 [INTERNAL]  A flavor of getJacSparsity that does hierarchical block
20253 structure recognition.
20254 
20255 ";
20256 
20257 %feature("docstring")  casadi::FunctionInternal::size2_out(casadi_int ind)
20258 const  "
20259 
20260 [INTERNAL]  Input/output dimensions.
20261 
20262 ";
20263 
20264 %feature("docstring")  casadi::External::has_jacobian() const  "
20265 
20266 [INTERNAL]  Full Jacobian.
20267 
20268 ";
20269 
20270 %feature("docstring")  casadi::SharedObjectInternal::getCount() const  "
20271 
20272 [INTERNAL]  Get the reference count.
20273 
20274 ";
20275 
20276 %feature("docstring")  casadi::FunctionInternal::is_diff_out(casadi_int i) "
20277 
20278 [INTERNAL] ";
20279 
20280 %feature("docstring")  casadi::FunctionInternal::size1_out(casadi_int ind)
20281 const  "
20282 
20283 [INTERNAL]  Input/output dimensions.
20284 
20285 ";
20286 
20287 %feature("docstring")  casadi::FunctionInternal::eval_gen(const double
20288 **arg, double **res, casadi_int *iw, double *w, void *mem) const  "
20289 
20290 [INTERNAL]  Evaluate numerically.
20291 
20292 ";
20293 
20294 %feature("docstring")  casadi::FunctionInternal::eval_gen(const SXElem
20295 **arg, SXElem **res, casadi_int *iw, SXElem *w, void *mem) const  "
20296 
20297 [INTERNAL]  Evaluate a function, overloaded.
20298 
20299 ";
20300 
20301 %feature("docstring")  casadi::FunctionInternal::eval_gen(const bvec_t
20302 **arg, bvec_t **res, casadi_int *iw, bvec_t *w, void *mem) const  "
20303 
20304 [INTERNAL]  Evaluate a function, overloaded.
20305 
20306 ";
20307 
20308 %feature("docstring")  casadi::External::codegen_body(CodeGenerator &g)
20309 const  "
20310 
20311 [INTERNAL]  Generate code for the body of the C function.
20312 
20313 ";
20314 
20315 %feature("docstring")  casadi::FunctionInternal::replace_aseed(const
20316 std::vector< std::vector< M >> &aseed, casadi_int npar) const  "
20317 
20318 [INTERNAL]  Replace 0-by-0 reverse seeds.
20319 
20320 ";
20321 
20322 %feature("docstring")  casadi::FunctionInternal::replace_aseed(const
20323 std::vector< std::vector< M > > &aseed, casadi_int npar) const  "
20324 
20325 [INTERNAL] ";
20326 
20327 %feature("docstring")  casadi::FunctionInternal::get_max_in(casadi_int ind)
20328 const  "
20329 
20330 [INTERNAL]  Get largest input value.
20331 
20332 ";
20333 
20334 %feature("docstring")  casadi::FunctionInternal::free_sx() const  "
20335 
20336 [INTERNAL]  Get free variables (SX)
20337 
20338 ";
20339 
20340 %feature("docstring")  casadi::FunctionInternal::sz_work(size_t &sz_arg,
20341 size_t &sz_res, size_t &sz_iw, size_t &sz_w) const  "
20342 
20343 [INTERNAL]  Get number of temporary variables needed.
20344 
20345 ";
20346 
20347 %feature("docstring")  casadi::FunctionInternal::get_min_in(casadi_int ind)
20348 const  "
20349 
20350 [INTERNAL]  Get smallest input value.
20351 
20352 ";
20353 
20354 %feature("docstring")  casadi::External::any_symbol_found() const  "
20355 
20356 [INTERNAL]  Any symbol found?
20357 
20358 ";
20359 
20360 %feature("docstring")  casadi::FunctionInternal::jit_dependencies(const
20361 std::string &fname) "
20362 
20363 [INTERNAL]  Jit dependencies.
20364 
20365 ";
20366 
20367 %feature("docstring")  casadi::FunctionInternal::nnz_out() const  "
20368 
20369 [INTERNAL]  Number of input/output nonzeros.
20370 
20371 ";
20372 
20373 %feature("docstring")  casadi::FunctionInternal::nnz_out(casadi_int ind)
20374 const  "
20375 
20376 [INTERNAL]  Number of input/output nonzeros.
20377 
20378 ";
20379 
20380 %feature("docstring")  casadi::FunctionInternal::eval(const double **arg,
20381 double **res, casadi_int *iw, double *w, void *mem) const  "
20382 
20383 [INTERNAL]  Evaluate numerically.
20384 
20385 ";
20386 
20387 %feature("docstring")  casadi::FunctionInternal::generate_lifted(Function
20388 &vdef_fcn, Function &vinit_fcn) const  "
20389 
20390 [INTERNAL]  Extract the functions needed for the Lifted Newton method.
20391 
20392 ";
20393 
20394 %feature("docstring")  casadi::External::get_jacobian(const std::string
20395 &name, const std::vector< std::string > &inames, const std::vector<
20396 std::string > &onames, const Dict &opts) const  "
20397 
20398 [INTERNAL]  Full Jacobian.
20399 
20400 ";
20401 
20402 %feature("docstring")  casadi::FunctionInternal::get_sparsity_in(casadi_int
20403 i) "
20404 
20405 [INTERNAL]  Get sparsity of a given input.
20406 
20407 ";
20408 
20409 %feature("docstring")  casadi::FunctionInternal::numel_out(casadi_int ind)
20410 const  "
20411 
20412 [INTERNAL]  Number of input/output elements.
20413 
20414 ";
20415 
20416 %feature("docstring")  casadi::FunctionInternal::numel_out() const  "
20417 
20418 [INTERNAL]  Number of input/output elements.
20419 
20420 ";
20421 
20422 %feature("docstring")  casadi::FunctionInternal::get_partition(casadi_int
20423 iind, casadi_int oind, Sparsity &D1, Sparsity &D2, bool compact, bool
20424 symmetric, bool allow_forward, bool allow_reverse) const  "
20425 
20426 [INTERNAL]  Get the unidirectional or bidirectional partition.
20427 
20428 ";
20429 
20430 %feature("docstring")  casadi::External::get_default_in(casadi_int i) const
20431 "
20432 
20433 [INTERNAL]  Default inputs.
20434 
20435 ";
20436 
20437 %feature("docstring")  casadi::FunctionInternal::finalize()  "
20438 
20439 [INTERNAL]  Finalize the object creation.
20440 
20441 ";
20442 
20443 %feature("docstring")  casadi::FunctionInternal::size2_in(casadi_int ind)
20444 const  "
20445 
20446 [INTERNAL]  Input/output dimensions.
20447 
20448 ";
20449 
20450 %feature("docstring")  casadi::FunctionInternal::convert_arg(const
20451 std::vector< M > &arg) const  "
20452 
20453 [INTERNAL]  Convert from/to input/output lists/map.
20454 
20455 ";
20456 
20457 %feature("docstring")  casadi::FunctionInternal::convert_arg(const std::map<
20458 std::string, M > &arg) const  "
20459 
20460 [INTERNAL]  Convert from/to input/output lists/map.
20461 
20462 ";
20463 
20464 %feature("docstring")  casadi::FunctionInternal::instructions_sx() const  "
20465 
20466 [INTERNAL]  get SX expression associated with instructions
20467 
20468 ";
20469 
20470 %feature("docstring")  casadi::ProtoFunction::clear_mem() "
20471 
20472 [INTERNAL]  Clear all memory (called from destructor)
20473 
20474 ";
20475 
20476 %feature("docstring")  casadi::FunctionInternal::adjViaJac(casadi_int nadj)
20477 const  "
20478 
20479 [INTERNAL]  Calculate derivatives by multiplying the full Jacobian and
20480 multiplying.
20481 
20482 ";
20483 
20484 %feature("docstring")  casadi::External::get_forward(casadi_int nfwd, const
20485 std::string &name, const std::vector< std::string > &inames, const
20486 std::vector< std::string > &onames, const Dict &opts) const  "
20487 
20488 [INTERNAL]  Forward mode derivatives.
20489 
20490 ";
20491 
20492 %feature("docstring")  casadi::FunctionInternal::sp_reverse(bvec_t **arg,
20493 bvec_t **res, casadi_int *iw, bvec_t *w, void *mem) const  "
20494 
20495 [INTERNAL]  Propagate sparsity backwards.
20496 
20497 ";
20498 
20499 %feature("docstring")  casadi::FunctionInternal::oracle() const  "
20500 
20501 [INTERNAL]  Get oracle.
20502 
20503 ";
20504 
20505 %feature("docstring")  casadi::FunctionInternal::check_res(const
20506 std::vector< M > &res, casadi_int &npar) const  "
20507 
20508 [INTERNAL]  Check if output arguments have correct length and dimensions.
20509 
20510 Raises errors.
20511 
20512 Parameters:
20513 -----------
20514 
20515 npar[in]:  normal usage: 1, disallow pararallel calls: -1
20516 
20517 npar:  max number of horizontal repetitions across all arguments (or -1)
20518 
20519 ";
20520 
20521 %feature("docstring")  casadi::FunctionInternal::eval_dm(const std::vector<
20522 DM > &arg) const  "
20523 
20524 [INTERNAL]  Evaluate with DM matrices.
20525 
20526 ";
20527 
20528 %feature("docstring")  casadi::FunctionInternal::matching_arg(const
20529 std::vector< M > &arg, casadi_int &npar) const  "
20530 
20531 [INTERNAL]  Check if input arguments that needs to be replaced.
20532 
20533 Raises errors
20534 
20535 Parameters:
20536 -----------
20537 
20538 npar[in]:  normal usage: 1, disallow pararallel calls: -1
20539 
20540 npar:  max number of horizontal repetitions across all arguments (or -1)
20541 
20542 ";
20543 
20544 %feature("docstring")
20545 casadi::FunctionInternal::getJacSparsityHierarchicalSymm(casadi_int iind,
20546 casadi_int oind) const  "
20547 
20548 [INTERNAL]  A flavor of getJacSparsity that does hierarchical block
20549 structure recognition for symmetric Jacobians
20550 
20551 ";
20552 
20553 %feature("docstring")  casadi::FunctionInternal::codegen_meta(CodeGenerator
20554 &g) const  "
20555 
20556 [INTERNAL]  Generate meta-information allowing a user to evaluate a
20557 generated function.
20558 
20559 ";
20560 
20561 %feature("docstring")  casadi::FunctionInternal::which_depends(const
20562 std::string &s_in, const std::vector< std::string > &s_out, casadi_int
20563 order, bool tr=false) const  "
20564 
20565 [INTERNAL]  Which variables enter with some order.
20566 
20567 Parameters:
20568 -----------
20569 
20570 s_in:   Input name
20571 
20572 s_out:   Output name(s)
20573 
20574 order:  Only 1 (linear) and 2 (nonlinear) allowed
20575 
20576 tr:  Flip the relationship. Return which expressions contain the variables
20577 
20578 ";
20579 
20580 %feature("docstring")  casadi::FunctionInternal::generate_dependencies(const
20581 std::string &fname, const Dict &opts) const  "
20582 
20583 [INTERNAL]  Export / Generate C code for the dependency function.
20584 
20585 ";
20586 
20587 %feature("docstring")  casadi::FunctionInternal::get_abstol() const  "
20588 
20589 [INTERNAL]  Get absolute tolerance.
20590 
20591 ";
20592 
20593 %feature("docstring")  casadi::FunctionInternal::codegen(CodeGenerator &g,
20594 const std::string &fname) const  "
20595 
20596 [INTERNAL]  Generate code the function.
20597 
20598 ";
20599 
20600 %feature("docstring")  casadi::FunctionInternal::setup(void *mem, const
20601 double **arg, double **res, casadi_int *iw, double *w) const  "
20602 
20603 [INTERNAL]  Set the (persistent and temporary) work vectors.
20604 
20605 ";
20606 
20607 %feature("docstring")  casadi::FunctionInternal::eval_sx(const SXElem **arg,
20608 SXElem **res, casadi_int *iw, SXElem *w, void *mem) const  "
20609 
20610 [INTERNAL]  Evaluate with symbolic scalars.
20611 
20612 ";
20613 
20614 %feature("docstring")  casadi::FunctionInternal::project_res(const
20615 std::vector< M > &arg, casadi_int npar) const  "
20616 
20617 [INTERNAL]   Project sparsities.
20618 
20619 ";
20620 
20621 %feature("docstring")  casadi::FunctionInternal::n_instructions() const  "
20622 
20623 [INTERNAL]  Get the number of atomic operations.
20624 
20625 ";
20626 
20627 %feature("docstring")  casadi::FunctionInternal::sz_iw() const  "
20628 
20629 [INTERNAL]  Get required length of iw field.
20630 
20631 ";
20632 
20633 %feature("docstring")  casadi::FunctionInternal::wrap() const  "
20634 
20635 [INTERNAL]  Wrap in an Function instance consisting of only one MX call.
20636 
20637 ";
20638 
20639 %feature("docstring")  casadi::FunctionInternal::info() const  "
20640 
20641 [INTERNAL]  Obtain information about function
20642 
20643 ";
20644 
20645 %feature("docstring")  casadi::External::serialize_body(SerializingStream
20646 &s) const  "
20647 
20648 [INTERNAL]  Serialize an object without type information.
20649 
20650 ";
20651 
20652 %feature("docstring")  casadi::FunctionInternal::fwdViaJac(casadi_int nfwd)
20653 const  "
20654 
20655 [INTERNAL]  Calculate derivatives by multiplying the full Jacobian and
20656 multiplying.
20657 
20658 ";
20659 
20660 %feature("docstring")  casadi::FunctionInternal::print_option(const
20661 std::string &name, std::ostream &stream) const  "
20662 
20663 [INTERNAL]  Print all information there is to know about a certain option.
20664 
20665 ";
20666 
20667 %feature("docstring")  casadi::FunctionInternal::symbolicAdjSeed(casadi_int
20668 nadj, const std::vector< MatType > &v) const  "
20669 
20670 [INTERNAL]  Symbolic expressions for the adjoint seeds.
20671 
20672 ";
20673 
20674 %feature("docstring")
20675 casadi::FunctionInternal::codegen_alloc_mem(CodeGenerator &g) const  "
20676 
20677 [INTERNAL]  Codegen decref for alloc_mem.
20678 
20679 ";
20680 
20681 %feature("docstring")  casadi::FunctionInternal::nz_out(const std::vector<
20682 DM > &res) const  "
20683 
20684 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
20685 
20686 ";
20687 
20688 %feature("docstring")  casadi::FunctionInternal::nz_out(const std::vector<
20689 double > &res) const  "
20690 
20691 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
20692 
20693 ";
20694 
20695 
20696 // File: classcasadi_1_1Factory.xml
20697 %feature("docstring")  casadi::Factory< MatType >::has_in(const std::string
20698 &s) const  "
20699 
20700 [INTERNAL] ";
20701 
20702 %feature("docstring")  casadi::Factory< MatType >::add_output(const
20703 std::string &s, const MatType &e, bool is_diff) "
20704 
20705 [INTERNAL] ";
20706 
20707 %feature("docstring")  casadi::Factory< MatType >::calculate(const Dict
20708 &opts=Dict()) "
20709 
20710 [INTERNAL] ";
20711 
20712 %feature("docstring")  casadi::Factory< MatType >::get_output(const
20713 std::string &s) "
20714 
20715 [INTERNAL] ";
20716 
20717 %feature("docstring") casadi::Factory "
20718 
20719 [INTERNAL] C++ includes: factory.hpp ";
20720 
20721 %feature("docstring")  casadi::Factory< MatType >::request_output(const
20722 std::string &s) "
20723 
20724 [INTERNAL] ";
20725 
20726 %feature("docstring")  casadi::Factory< MatType >::get_input(const
20727 std::string &s) "
20728 
20729 [INTERNAL] ";
20730 
20731 %feature("docstring")  casadi::Factory< MatType >::add_input(const
20732 std::string &s, const MatType &e, bool is_diff) "
20733 
20734 [INTERNAL] ";
20735 
20736 %feature("docstring")  casadi::Factory< MatType >::has_out(const std::string
20737 &s) const  "
20738 
20739 [INTERNAL] ";
20740 
20741 %feature("docstring")  casadi::Factory< MatType >::request_input(const
20742 std::string &s) "
20743 
20744 [INTERNAL] ";
20745 
20746 %feature("docstring")  casadi::Factory< MatType >::name_out() const  "
20747 
20748 [INTERNAL] ";
20749 
20750 %feature("docstring") casadi::Factory< MatType >::Factory(const
20751 Function::AuxOut &aux) "
20752 
20753 [INTERNAL] ";
20754 
20755 %feature("docstring")  casadi::Factory< MatType >::name_in() const  "
20756 
20757 [INTERNAL] ";
20758 
20759 
20760 // File: classcasadi_1_1FastNewton.xml
20761 %feature("docstring")  casadi::FunctionInternal::check_res(const
20762 std::vector< M > &res, casadi_int &npar) const  "
20763 
20764 [INTERNAL]  Check if output arguments have correct length and dimensions.
20765 
20766 Raises errors.
20767 
20768 Parameters:
20769 -----------
20770 
20771 npar[in]:  normal usage: 1, disallow pararallel calls: -1
20772 
20773 npar:  max number of horizontal repetitions across all arguments (or -1)
20774 
20775 ";
20776 
20777 %feature("docstring")  casadi::FunctionInternal::convert_arg(const
20778 std::vector< M > &arg) const  "
20779 
20780 [INTERNAL]  Convert from/to input/output lists/map.
20781 
20782 ";
20783 
20784 %feature("docstring")  casadi::FunctionInternal::convert_arg(const std::map<
20785 std::string, M > &arg) const  "
20786 
20787 [INTERNAL]  Convert from/to input/output lists/map.
20788 
20789 ";
20790 
20791 %feature("docstring")  casadi::FunctionInternal::sz_arg() const  "
20792 
20793 [INTERNAL]  Get required length of arg field.
20794 
20795 ";
20796 
20797 %feature("docstring")  casadi::FunctionInternal::sz_w() const  "
20798 
20799 [INTERNAL]  Get required length of w field.
20800 
20801 ";
20802 
20803 %feature("docstring")  casadi::FunctionInternal::nnz_in() const  "
20804 
20805 [INTERNAL]  Number of input/output nonzeros.
20806 
20807 ";
20808 
20809 %feature("docstring")  casadi::FunctionInternal::nnz_in(casadi_int ind)
20810 const  "
20811 
20812 [INTERNAL]  Number of input/output nonzeros.
20813 
20814 ";
20815 
20816 %feature("docstring")  casadi::FunctionInternal::symbolic_output(const
20817 std::vector< MX > &arg) const  "
20818 
20819 [INTERNAL]  Get a vector of symbolic variables corresponding to the outputs.
20820 
20821 ";
20822 
20823 %feature("docstring")  casadi::Rootfinder::ad_forward(const std::vector< MX
20824 > &arg, const std::vector< MX > &res, const std::vector< std::vector< MX > >
20825 &fseed, std::vector< std::vector< MX > > &fsens, bool always_inline, bool
20826 never_inline) const  "
20827 
20828 [INTERNAL]  Create call to (cached) derivative function, forward mode.
20829 
20830 ";
20831 
20832 %feature("docstring")  casadi::FastNewton::alloc_mem() const  "
20833 
20834 [INTERNAL]  Create memory block.
20835 
20836 ";
20837 
20838 %feature("docstring")  casadi::FunctionInternal::disp(std::ostream &stream,
20839 bool more) const  "
20840 
20841 [INTERNAL]  Display object.
20842 
20843 ";
20844 
20845 %feature("docstring")  casadi::FunctionInternal::jacobian() const  "
20846 
20847 [INTERNAL]  Return Jacobian of all input elements with respect to all output
20848 elements.
20849 
20850 ";
20851 
20852 %feature("docstring")  casadi::FunctionInternal::eval_dm(const std::vector<
20853 DM > &arg) const  "
20854 
20855 [INTERNAL]  Evaluate with DM matrices.
20856 
20857 ";
20858 
20859 %feature("docstring")
20860 casadi::FunctionInternal::getJacSparsityHierarchical(casadi_int iind,
20861 casadi_int oind) const  "
20862 
20863 [INTERNAL]  A flavor of getJacSparsity that does hierarchical block
20864 structure recognition.
20865 
20866 ";
20867 
20868 %feature("docstring")  casadi::ProtoFunction::release(int mem) const  "
20869 
20870 [INTERNAL]  Release a memory object.
20871 
20872 ";
20873 
20874 %feature("docstring")  casadi::Rootfinder::sp_forward(const bvec_t **arg,
20875 bvec_t **res, casadi_int *iw, bvec_t *w, void *mem) const  "
20876 
20877 [INTERNAL]  Propagate sparsity forward.
20878 
20879 ";
20880 
20881 %feature("docstring")  casadi::FunctionInternal::wrap_as_needed(const Dict
20882 &opts) const  "
20883 
20884 [INTERNAL]  Wrap in an Function instance consisting of only one MX call.
20885 
20886 ";
20887 
20888 %feature("docstring")  casadi::FunctionInternal::print_option(const
20889 std::string &name, std::ostream &stream) const  "
20890 
20891 [INTERNAL]  Print all information there is to know about a certain option.
20892 
20893 ";
20894 
20895 %feature("docstring")  casadi::FastNewton::get_options() const  "
20896 
20897 [INTERNAL]  Options.
20898 
20899 ";
20900 
20901 %feature("docstring")  casadi::FunctionInternal::is_diff_in(casadi_int i) "
20902 
20903 [INTERNAL] ";
20904 
20905 %feature("docstring")  casadi::FunctionInternal::alloc(const Function &f,
20906 bool persistent=false) "
20907 
20908 [INTERNAL]  Ensure work vectors long enough to evaluate function.
20909 
20910 ";
20911 
20912 %feature("docstring")  casadi::FunctionInternal::disp_more(std::ostream
20913 &stream) const  "
20914 
20915 [INTERNAL]  Print more.
20916 
20917 ";
20918 
20919 %feature("docstring")  casadi::FunctionInternal::has_eval_dm() const  "
20920 
20921 [INTERNAL]  Evaluate with DM matrices.
20922 
20923 ";
20924 
20925 %feature("docstring")  casadi::OracleFunction::set_function(const Function
20926 &fcn, const std::string &fname, bool jit=false) "
20927 
20928 [INTERNAL]  Register the function for evaluation and statistics gathering
20929 
20930 ";
20931 
20932 %feature("docstring")  casadi::OracleFunction::set_function(const Function
20933 &fcn) "
20934 
20935 [INTERNAL]  Register the function for evaluation and statistics gathering
20936 
20937 ";
20938 
20939 %feature("docstring")  casadi::FunctionInternal::print_options(std::ostream
20940 &stream) const  "
20941 
20942 [INTERNAL]  Print list of options.
20943 
20944 ";
20945 
20946 %feature("docstring")  casadi::FunctionInternal::codegen_mem(CodeGenerator
20947 &g, const std::string &index="mem") const  "
20948 
20949 [INTERNAL]  Get thread-local memory object.
20950 
20951 ";
20952 
20953 %feature("docstring")  casadi::FunctionInternal::mapsum_mx(const
20954 std::vector< MX > &arg, const std::string &parallelization) "
20955 
20956 [INTERNAL]  Parallel evaluation.
20957 
20958 ";
20959 
20960 %feature("docstring")  casadi::FunctionInternal::check_mat(const Sparsity
20961 &arg, const Sparsity &inp, casadi_int &npar) "
20962 
20963 [INTERNAL]  Helper function
20964 
20965 Parameters:
20966 -----------
20967 
20968 npar[in]:  normal usage: 1, disallow pararallel calls: -1
20969 
20970 npar[out]:  required number of parallel calls (or -1)
20971 
20972 ";
20973 
20974 %feature("docstring")  casadi::FunctionInternal::get_jacobian_sparsity()
20975 const  "
20976 
20977 [INTERNAL]  Get Jacobian sparsity.
20978 
20979 ";
20980 
20981 %feature("docstring")  casadi::FastNewton::solve(void *mem) const  "
20982 
20983 [INTERNAL]   Solve the system of equations and calculate derivatives.
20984 
20985 ";
20986 
20987 %feature("docstring") casadi::casadi_solve "
20988 
20989 Solve the system of equations and calculate derivatives.
20990 
20991 ";
20992 
20993 %feature("docstring")  casadi::FastNewton::casadi_solve "
20994 
20995 Solve the system of equations and calculate derivatives.
20996 
20997 ";
20998 
20999 %feature("docstring")  casadi::FunctionInternal::getJacSparsity(casadi_int
21000 iind, casadi_int oind, bool symmetric) const  "
21001 
21002 [INTERNAL]  Generate the sparsity of a Jacobian block.
21003 
21004 ";
21005 
21006 %feature("docstring")  casadi::FunctionInternal::matching_res(const
21007 std::vector< M > &arg, casadi_int &npar) const  "
21008 
21009 [INTERNAL]  Check if output arguments that needs to be replaced.
21010 
21011 Raises errors
21012 
21013 Parameters:
21014 -----------
21015 
21016 npar[in]:  normal usage: 1, disallow pararallel calls: -1
21017 
21018 npar:  max number of horizontal repetitions across all arguments (or -1)
21019 
21020 ";
21021 
21022 %feature("docstring")  casadi::Rootfinder::has_spfwd() const  "
21023 
21024 [INTERNAL]  Is the class able to propagate seeds through the algorithm?
21025 
21026 ";
21027 
21028 %feature("docstring")  casadi::FunctionInternal::incache(const std::string
21029 &fname, Function &f, const std::string &suffix="") const  "
21030 
21031 [INTERNAL]  Get function in cache.
21032 
21033 ";
21034 
21035 %feature("docstring")  casadi::ProtoFunction::checkout() const  "
21036 
21037 [INTERNAL]  Checkout a memory object.
21038 
21039 ";
21040 
21041 %feature("docstring")  casadi::FunctionInternal::instructions_sx() const  "
21042 
21043 [INTERNAL]  get SX expression associated with instructions
21044 
21045 ";
21046 
21047 %feature("docstring")  casadi::FunctionInternal::eval_gen(const double
21048 **arg, double **res, casadi_int *iw, double *w, void *mem) const  "
21049 
21050 [INTERNAL]  Evaluate numerically.
21051 
21052 ";
21053 
21054 %feature("docstring")  casadi::FunctionInternal::eval_gen(const SXElem
21055 **arg, SXElem **res, casadi_int *iw, SXElem *w, void *mem) const  "
21056 
21057 [INTERNAL]  Evaluate a function, overloaded.
21058 
21059 ";
21060 
21061 %feature("docstring")  casadi::FunctionInternal::eval_gen(const bvec_t
21062 **arg, bvec_t **res, casadi_int *iw, bvec_t *w, void *mem) const  "
21063 
21064 [INTERNAL]  Evaluate a function, overloaded.
21065 
21066 ";
21067 
21068 %feature("docstring")  casadi::FunctionInternal::has_derivative() const  "
21069 
21070 [INTERNAL]  Can derivatives be calculated in any way?
21071 
21072 ";
21073 
21074 %feature("docstring")  casadi::FunctionInternal::codegen_meta(CodeGenerator
21075 &g) const  "
21076 
21077 [INTERNAL]  Generate meta-information allowing a user to evaluate a
21078 generated function.
21079 
21080 ";
21081 
21082 %feature("docstring")  casadi::FastNewton::free_mem(void *mem) const  "
21083 
21084 [INTERNAL]  Free memory block.
21085 
21086 ";
21087 
21088 %feature("docstring")  casadi::FunctionInternal::size1_out(casadi_int ind)
21089 const  "
21090 
21091 [INTERNAL]  Input/output dimensions.
21092 
21093 ";
21094 
21095 %feature("docstring")  casadi::FunctionInternal::eval_mx(const MXVector
21096 &arg, MXVector &res, bool always_inline, bool never_inline) const  "
21097 
21098 [INTERNAL]  Evaluate with symbolic matrices.
21099 
21100 ";
21101 
21102 %feature("docstring")  casadi::Rootfinder::get_n_in()  "
21103 
21104 [INTERNAL]  Number of function inputs and outputs.
21105 
21106 ";
21107 
21108 %feature("docstring")  casadi::FunctionInternal::signature(const std::string
21109 &fname) const  "
21110 
21111 [INTERNAL]  Code generate the function.
21112 
21113 ";
21114 
21115 %feature("docstring")  casadi::FunctionInternal::dm_in(casadi_int ind) const
21116 "
21117 
21118 [INTERNAL]  Get function input(s) and output(s)
21119 
21120 ";
21121 
21122 %feature("docstring")  casadi::FunctionInternal::dm_in() const  "
21123 
21124 [INTERNAL]  Get function input(s) and output(s)
21125 
21126 ";
21127 
21128 %feature("docstring")  casadi::ProtoFunction::sprint(char *buf, size_t
21129 buf_sz, const char *fmt,...) const  "
21130 
21131 [INTERNAL]  C-style formatted printing to string.
21132 
21133 ";
21134 
21135 %feature("docstring")  casadi::FunctionInternal::fwd_seed(casadi_int nfwd)
21136 const  "
21137 
21138 [INTERNAL]  Symbolic expressions for the forward seeds.
21139 
21140 ";
21141 
21142 %feature("docstring")  casadi::Rootfinder::eval(const double **arg, double
21143 **res, casadi_int *iw, double *w, void *mem) const  "
21144 
21145 [INTERNAL]  Evaluate numerically.
21146 
21147 ";
21148 
21149 %feature("docstring")  casadi::FunctionInternal::get_abstol() const  "
21150 
21151 [INTERNAL]  Get absolute tolerance.
21152 
21153 ";
21154 
21155 %feature("docstring")  casadi::FunctionInternal::sparsity_in(casadi_int ind)
21156 const  "
21157 
21158 [INTERNAL]  Input/output sparsity.
21159 
21160 ";
21161 
21162 %feature("docstring") casadi::FastNewton::~FastNewton "
21163 
21164 [INTERNAL]  Destructor.
21165 
21166 ";
21167 
21168 %feature("docstring")  casadi::FunctionInternal::factory(const std::string
21169 &name, const std::vector< std::string > &s_in, const std::vector<
21170 std::string > &s_out, const Function::AuxOut &aux, const Dict &opts) const
21171 "
21172 
21173 [INTERNAL] ";
21174 
21175 %feature("docstring") casadi::FastNewton "
21176 
21177 'fast_newton' plugin for Rootfinder
21178 
21179 Implements simple newton iterations to solve an implicit function.
21180 
21181 >List of available options
21182 
21183 +------------+-----------+-------------------------------------------------+
21184 |     Id     |   Type    |                   Description                   |
21185 +============+===========+=================================================+
21186 | abstol     | OT_DOUBLE | Stopping criterion tolerance on ||g||__inf)     |
21187 +------------+-----------+-------------------------------------------------+
21188 | abstolStep | OT_DOUBLE | Stopping criterion tolerance on step size       |
21189 +------------+-----------+-------------------------------------------------+
21190 | max_iter   | OT_INT    | Maximum number of Newton iterations to perform  |
21191 |            |           | before returning.                               |
21192 +------------+-----------+-------------------------------------------------+
21193 
21194 Joris Gillis
21195 
21196 >List of available options
21197 
21198 +-------------------+--------------+-------------------+-------------------+
21199 |        Id         |     Type     |    Description    |      Used in      |
21200 +===================+==============+===================+===================+
21201 | abstol            | OT_DOUBLE    | Stopping          | casadi::FastNewto |
21202 |                   |              | criterion         | n                 |
21203 |                   |              | tolerance on      |                   |
21204 |                   |              | ||g||__inf)       |                   |
21205 +-------------------+--------------+-------------------+-------------------+
21206 | abstolStep        | OT_DOUBLE    | Stopping          | casadi::FastNewto |
21207 |                   |              | criterion         | n                 |
21208 |                   |              | tolerance on step |                   |
21209 |                   |              | size              |                   |
21210 +-------------------+--------------+-------------------+-------------------+
21211 | constraints       | OT_INTVECTOR | Constrain the     | casadi::Rootfinde |
21212 |                   |              | unknowns. 0       | r                 |
21213 |                   |              | (default): no     |                   |
21214 |                   |              | constraint on ui, |                   |
21215 |                   |              | 1: ui >= 0.0, -1: |                   |
21216 |                   |              | ui <= 0.0, 2: ui  |                   |
21217 |                   |              | > 0.0, -2: ui <   |                   |
21218 |                   |              | 0.0.              |                   |
21219 +-------------------+--------------+-------------------+-------------------+
21220 | error_on_fail     | OT_BOOL      | When the          | casadi::Rootfinde |
21221 |                   |              | numerical process | r                 |
21222 |                   |              | returns           |                   |
21223 |                   |              | unsuccessfully,   |                   |
21224 |                   |              | raise an error    |                   |
21225 |                   |              | (default false).  |                   |
21226 +-------------------+--------------+-------------------+-------------------+
21227 | implicit_input    | OT_INT       | Index of the      | casadi::Rootfinde |
21228 |                   |              | input that        | r                 |
21229 |                   |              | corresponds to    |                   |
21230 |                   |              | the actual root-  |                   |
21231 |                   |              | finding           |                   |
21232 +-------------------+--------------+-------------------+-------------------+
21233 | implicit_output   | OT_INT       | Index of the      | casadi::Rootfinde |
21234 |                   |              | output that       | r                 |
21235 |                   |              | corresponds to    |                   |
21236 |                   |              | the actual root-  |                   |
21237 |                   |              | finding           |                   |
21238 +-------------------+--------------+-------------------+-------------------+
21239 | jacobian_function | OT_FUNCTION  | Function object   | casadi::Rootfinde |
21240 |                   |              | for calculating   | r                 |
21241 |                   |              | the Jacobian      |                   |
21242 |                   |              | (autogenerated by |                   |
21243 |                   |              | default)          |                   |
21244 +-------------------+--------------+-------------------+-------------------+
21245 | linear_solver     | OT_STRING    | User-defined      | casadi::Rootfinde |
21246 |                   |              | linear solver     | r                 |
21247 |                   |              | class. Needed for |                   |
21248 |                   |              | sensitivities.    |                   |
21249 +-------------------+--------------+-------------------+-------------------+
21250 | linear_solver_opt | OT_DICT      | Options to be     | casadi::Rootfinde |
21251 | ions              |              | passed to the     | r                 |
21252 |                   |              | linear solver.    |                   |
21253 +-------------------+--------------+-------------------+-------------------+
21254 | max_iter          | OT_INT       | Maximum number of | casadi::FastNewto |
21255 |                   |              | Newton iterations | n                 |
21256 |                   |              | to perform before |                   |
21257 |                   |              | returning.        |                   |
21258 +-------------------+--------------+-------------------+-------------------+
21259 
21260 Diagrams
21261 --------
21262 
21263 
21264 
21265 C++ includes: fast_newton.hpp ";
21266 
21267 %feature("docstring")  casadi::FunctionInternal::alloc_res(size_t sz_res,
21268 bool persistent=false) "
21269 
21270 [INTERNAL]  Ensure required length of res field.
21271 
21272 ";
21273 
21274 %feature("docstring")  casadi::FunctionInternal::map(casadi_int n, const
21275 std::string &parallelization) const  "
21276 
21277 [INTERNAL]  Generate/retrieve cached serial map.
21278 
21279 ";
21280 
21281 %feature("docstring")  casadi::FunctionInternal::nz_out(const std::vector<
21282 DM > &res) const  "
21283 
21284 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
21285 
21286 ";
21287 
21288 %feature("docstring")  casadi::FunctionInternal::nz_out(const std::vector<
21289 double > &res) const  "
21290 
21291 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
21292 
21293 ";
21294 
21295 %feature("docstring")  casadi::FastNewton::codegen_body(CodeGenerator &g)
21296 const  "
21297 
21298 [INTERNAL]  Generate code for the function body.
21299 
21300 ";
21301 
21302 %feature("docstring")  casadi::FastNewton::set_work(void *mem, const double
21303 **&arg, double **&res, casadi_int *&iw, double *&w) const  "
21304 
21305 [INTERNAL]  Set the (persistent) work vectors.
21306 
21307 ";
21308 
21309 %feature("docstring")  casadi::FunctionInternal::has_codegen() const  "
21310 
21311 [INTERNAL]  Is codegen supported?
21312 
21313 ";
21314 
21315 %feature("docstring")
21316 casadi::FunctionInternal::instruction_output(casadi_int k) const  "
21317 
21318 [INTERNAL]  Get the (integer) output argument of an atomic operation.
21319 
21320 ";
21321 
21322 %feature("docstring")  casadi::OracleFunction::generate_dependencies(const
21323 std::string &fname, const Dict &opts) const  "
21324 
21325 [INTERNAL]  Export / Generate C code for the generated functions.
21326 
21327 ";
21328 
21329 %feature("docstring")  casadi::FunctionInternal::n_instructions() const  "
21330 
21331 [INTERNAL]  Get the number of atomic operations.
21332 
21333 ";
21334 
21335 %feature("docstring")  casadi::Rootfinder::get_name_out(casadi_int i)  "
21336 
21337 [INTERNAL]  Names of function input and outputs.
21338 
21339 ";
21340 
21341 %feature("docstring")  casadi::FastNewton::get_stats(void *mem) const  "
21342 
21343 [INTERNAL]  Get all statistics.
21344 
21345 ";
21346 
21347 %feature("docstring")  casadi::FunctionInternal::fwdViaJac(casadi_int nfwd)
21348 const  "
21349 
21350 [INTERNAL]  Calculate derivatives by multiplying the full Jacobian and
21351 multiplying.
21352 
21353 ";
21354 
21355 %feature("docstring")  casadi::FunctionInternal::get_partition(casadi_int
21356 iind, casadi_int oind, Sparsity &D1, Sparsity &D2, bool compact, bool
21357 symmetric, bool allow_forward, bool allow_reverse) const  "
21358 
21359 [INTERNAL]  Get the unidirectional or bidirectional partition.
21360 
21361 ";
21362 
21363 %feature("docstring")  casadi::FunctionInternal::call(const std::vector< M >
21364 &arg, std::vector< M > &res, bool always_inline, bool never_inline) const  "
21365 
21366 [INTERNAL]   Call a function, templated.
21367 
21368 ";
21369 
21370 %feature("docstring")  casadi::FunctionInternal::instruction_MX(casadi_int
21371 k) const  "
21372 
21373 [INTERNAL]  get MX expression associated with instruction
21374 
21375 ";
21376 
21377 %feature("docstring")  casadi::FunctionInternal::adjViaJac(casadi_int nadj)
21378 const  "
21379 
21380 [INTERNAL]  Calculate derivatives by multiplying the full Jacobian and
21381 multiplying.
21382 
21383 ";
21384 
21385 %feature("docstring")  casadi::FunctionInternal::replace_arg(const
21386 std::vector< M > &arg, casadi_int npar) const  "
21387 
21388 [INTERNAL]  Replace 0-by-0 inputs.
21389 
21390 ";
21391 
21392 %feature("docstring")  casadi::FunctionInternal::alloc_w(size_t sz_w, bool
21393 persistent=false) "
21394 
21395 [INTERNAL]  Ensure required length of w field.
21396 
21397 ";
21398 
21399 %feature("docstring")  casadi::FunctionInternal::project_res(const
21400 std::vector< M > &arg, casadi_int npar) const  "
21401 
21402 [INTERNAL]   Project sparsities.
21403 
21404 ";
21405 
21406 %feature("docstring")  casadi::FunctionInternal::size_in(casadi_int ind)
21407 const  "
21408 
21409 [INTERNAL]  Input/output dimensions.
21410 
21411 ";
21412 
21413 %feature("docstring")  casadi::OracleFunction::set_temp(void *mem, const
21414 double **arg, double **res, casadi_int *iw, double *w) const  "
21415 
21416 [INTERNAL]  Set the work vectors.
21417 
21418 ";
21419 
21420 %feature("docstring")  casadi::ProtoFunction::print(const char *fmt,...)
21421 const  "
21422 
21423 [INTERNAL]  C-style formatted printing during evaluation.
21424 
21425 ";
21426 
21427 %feature("docstring")  casadi::FunctionInternal::get_free() const  "
21428 
21429 [INTERNAL]  Print free variables.
21430 
21431 ";
21432 
21433 %feature("docstring")  casadi::Rootfinder::get_reverse(casadi_int nadj,
21434 const std::string &name, const std::vector< std::string > &inames, const
21435 std::vector< std::string > &onames, const Dict &opts) const  "
21436 
21437 [INTERNAL]  Generate a function that calculates nadj adjoint derivatives.
21438 
21439 ";
21440 
21441 %feature("docstring")  casadi::FunctionInternal::get_jac(const std::string
21442 &name, const std::vector< std::string > &inames, const std::vector<
21443 std::string > &onames, const Dict &opts) const  "
21444 
21445 [INTERNAL]  Return Jacobian of all input elements with respect to all output
21446 elements.
21447 
21448 ";
21449 
21450 %feature("docstring")  casadi::FunctionInternal::codegen_name(const
21451 CodeGenerator &g, bool ns=true) const  "
21452 
21453 [INTERNAL]  Get name in codegen.
21454 
21455 ";
21456 
21457 %feature("docstring")  casadi::FunctionInternal::get_max_in(casadi_int ind)
21458 const  "
21459 
21460 [INTERNAL]  Get largest input value.
21461 
21462 ";
21463 
21464 %feature("docstring")  casadi::FunctionInternal::size1_in(casadi_int ind)
21465 const  "
21466 
21467 [INTERNAL]  Input/output dimensions.
21468 
21469 ";
21470 
21471 %feature("docstring")  casadi::FunctionInternal::reverse(casadi_int nadj)
21472 const  "
21473 
21474 [INTERNAL]  Return function that calculates adjoint derivatives
21475 reverse(nadj) returns a cached instance if available, and calls  Function
21476 get_reverse(casadi_int nadj) if no cached version is available.
21477 
21478 ";
21479 
21480 %feature("docstring")  casadi::FunctionInternal::symbolicAdjSeed(casadi_int
21481 nadj, const std::vector< MatType > &v) const  "
21482 
21483 [INTERNAL]  Symbolic expressions for the adjoint seeds.
21484 
21485 ";
21486 
21487 %feature("docstring")  casadi::ProtoFunction::memory(int ind) const  "
21488 
21489 [INTERNAL]  Memory objects.
21490 
21491 ";
21492 
21493 %feature("docstring")  casadi::FastNewton::init_mem(void *mem) const  "
21494 
21495 [INTERNAL]  Initalize memory block.
21496 
21497 ";
21498 
21499 %feature("docstring")  casadi::FunctionInternal::sz_work(size_t &sz_arg,
21500 size_t &sz_res, size_t &sz_iw, size_t &sz_w) const  "
21501 
21502 [INTERNAL]  Get number of temporary variables needed.
21503 
21504 ";
21505 
21506 %feature("docstring")  casadi::FunctionInternal::size2_out(casadi_int ind)
21507 const  "
21508 
21509 [INTERNAL]  Input/output dimensions.
21510 
21511 ";
21512 
21513 %feature("docstring")  casadi::Rootfinder::serialize_base_function() const
21514 "
21515 
21516 [INTERNAL]  String used to identify the immediate FunctionInternal subclass.
21517 
21518 ";
21519 
21520 %feature("docstring")  casadi::FunctionInternal::sz_res() const  "
21521 
21522 [INTERNAL]  Get required length of res field.
21523 
21524 ";
21525 
21526 %feature("docstring")  casadi::FunctionInternal::sp_weight() const  "
21527 
21528 [INTERNAL]  Weighting factor for chosing forward/reverse mode, sparsity
21529 propagation.
21530 
21531 ";
21532 
21533 %feature("docstring")  casadi::FunctionInternal::get_min_in(casadi_int ind)
21534 const  "
21535 
21536 [INTERNAL]  Get smallest input value.
21537 
21538 ";
21539 
21540 %feature("docstring")  casadi::FunctionInternal::jacobian_sparsity() const
21541 "
21542 
21543 [INTERNAL]  Get Jacobian sparsity.
21544 
21545 ";
21546 
21547 %feature("docstring")  casadi::OracleFunction::finalize()  "
21548 
21549 [INTERNAL]  Finalize initialization.
21550 
21551 ";
21552 
21553 %feature("docstring")  casadi::FastNewton::class_name() const  "
21554 
21555 [INTERNAL]  Readable name of the internal class.
21556 
21557 ";
21558 
21559 %feature("docstring")  casadi::FunctionInternal::replace_aseed(const
21560 std::vector< std::vector< M >> &aseed, casadi_int npar) const  "
21561 
21562 [INTERNAL]  Replace 0-by-0 reverse seeds.
21563 
21564 ";
21565 
21566 %feature("docstring")  casadi::FunctionInternal::replace_aseed(const
21567 std::vector< std::vector< M > > &aseed, casadi_int npar) const  "
21568 
21569 [INTERNAL] ";
21570 
21571 %feature("docstring")  casadi::Rootfinder::get_forward(casadi_int nfwd,
21572 const std::string &name, const std::vector< std::string > &inames, const
21573 std::vector< std::string > &onames, const Dict &opts) const  "
21574 
21575 [INTERNAL]  Generate a function that calculates nfwd forward derivatives.
21576 
21577 ";
21578 
21579 %feature("docstring")  casadi::FunctionInternal::instruction_id(casadi_int
21580 k) const  "
21581 
21582 [INTERNAL]  Get an atomic operation operator index.
21583 
21584 ";
21585 
21586 %feature("docstring")  casadi::OracleFunction::oracle() const  "
21587 
21588 [INTERNAL]  Get oracle.
21589 
21590 ";
21591 
21592 %feature("docstring")  casadi::FunctionInternal::setup(void *mem, const
21593 double **arg, double **res, casadi_int *iw, double *w) const  "
21594 
21595 [INTERNAL]  Set the (persistent and temporary) work vectors.
21596 
21597 ";
21598 
21599 %feature("docstring")  casadi::Rootfinder::get_sparsity_in(casadi_int i)  "
21600 
21601 [INTERNAL]  Sparsities of function inputs and outputs.
21602 
21603 ";
21604 
21605 %feature("docstring")  casadi::OracleFunction::calc_function(OracleMemory
21606 *m, const std::string &fcn, const double *const *arg=nullptr) const  "
21607 
21608 [INTERNAL] ";
21609 
21610 %feature("docstring")  casadi::ProtoFunction::print_time(const std::map<
21611 std::string, FStats > &fstats) const  "
21612 
21613 [INTERNAL]  Print timing statistics.
21614 
21615 ";
21616 
21617 %feature("docstring")  casadi::FunctionInternal::generate_options(bool
21618 is_temp=false) const  "
21619 
21620 [INTERNAL]  Reconstruct options dict.
21621 
21622 ";
21623 
21624 %feature("docstring")  casadi::FunctionInternal::numel_out(casadi_int ind)
21625 const  "
21626 
21627 [INTERNAL]  Number of input/output elements.
21628 
21629 ";
21630 
21631 %feature("docstring")  casadi::FunctionInternal::numel_out() const  "
21632 
21633 [INTERNAL]  Number of input/output elements.
21634 
21635 ";
21636 
21637 %feature("docstring")  casadi::ProtoFunction::serialize(SerializingStream
21638 &s) const  "
21639 
21640 [INTERNAL]  Serialize an object.
21641 
21642 ";
21643 
21644 %feature("docstring")  casadi::FastNewton::plugin_name() const  "
21645 
21646 [INTERNAL] ";
21647 
21648 %feature("docstring")
21649 casadi::FunctionInternal::codegen_free_mem(CodeGenerator &g) const  "
21650 
21651 [INTERNAL]  Codegen for free_mem.
21652 
21653 ";
21654 
21655 %feature("docstring")  casadi::SharedObjectInternal::weak() "
21656 
21657 [INTERNAL]  Get a weak reference to the object.
21658 
21659 ";
21660 
21661 %feature("docstring")  casadi::FunctionInternal::project_arg(const
21662 std::vector< M > &arg, casadi_int npar) const  "
21663 
21664 [INTERNAL]   Project sparsities.
21665 
21666 ";
21667 
21668 %feature("docstring")  casadi::FunctionInternal::getAdaptorSolverName()
21669 const  "
21670 
21671 [INTERNAL]  Obtain solver name from Adaptor.
21672 
21673 ";
21674 
21675 %feature("docstring")  casadi::FunctionInternal::sz_iw() const  "
21676 
21677 [INTERNAL]  Get required length of iw field.
21678 
21679 ";
21680 
21681 %feature("docstring")  casadi::FunctionInternal::is_a(const std::string
21682 &type, bool recursive) const  "
21683 
21684 [INTERNAL]  Check if the function is of a particular type.
21685 
21686 ";
21687 
21688 %feature("docstring")  casadi::FunctionInternal::ad_weight() const  "
21689 
21690 [INTERNAL]  Weighting factor for chosing forward/reverse mode.
21691 
21692 ";
21693 
21694 %feature("docstring")  casadi::Rootfinder::has_reverse(casadi_int nadj)
21695 const  "
21696 
21697 [INTERNAL]  Generate a function that calculates nadj adjoint derivatives.
21698 
21699 ";
21700 
21701 %feature("docstring")  casadi::FunctionInternal::generate_lifted(Function
21702 &vdef_fcn, Function &vinit_fcn) const  "
21703 
21704 [INTERNAL]  Extract the functions needed for the Lifted Newton method.
21705 
21706 ";
21707 
21708 %feature("docstring")  casadi::FunctionInternal::generate_in(const
21709 std::string &fname, const double **arg) const  "
21710 
21711 [INTERNAL]  Export an input file that can be passed to generate C code with
21712 a main.
21713 
21714 ";
21715 
21716 %feature("docstring")  casadi::FunctionInternal::tocache(const Function &f,
21717 const std::string &suffix="") const  "
21718 
21719 [INTERNAL]  Save function to cache.
21720 
21721 ";
21722 
21723 %feature("docstring")  casadi::FunctionInternal::get_default_in(casadi_int
21724 ind) const  "
21725 
21726 [INTERNAL]  Get default input value.
21727 
21728 ";
21729 
21730 %feature("docstring")  casadi::ProtoFunction::format_time(char *buffer,
21731 double time) const  "
21732 
21733 [INTERNAL]  Format time in a fixed width 8 format.
21734 
21735 ";
21736 
21737 %feature("docstring")  casadi::OracleFunction::expand() "
21738 
21739 [INTERNAL] ";
21740 
21741 %feature("docstring")  casadi::FunctionInternal::check_arg(const
21742 std::vector< M > &arg, casadi_int &npar) const  "
21743 
21744 [INTERNAL]  Check if input arguments have correct length and dimensions.
21745 
21746 Raises errors.
21747 
21748 Parameters:
21749 -----------
21750 
21751 npar[in]:  normal usage: 1, disallow pararallel calls: -1
21752 
21753 npar:  max number of horizontal repetitions across all arguments (or -1)
21754 
21755 ";
21756 
21757 %feature("docstring") casadi::FastNewton::FastNewton(const std::string
21758 &name, const Function &f) "
21759 
21760 [INTERNAL]  Constructor.
21761 
21762 ";
21763 
21764 %feature("docstring")  casadi::FunctionInternal::forward(casadi_int nfwd)
21765 const  "
21766 
21767 [INTERNAL]  Return function that calculates forward derivatives
21768 forward(nfwd) returns a cached instance if available, and calls  Function
21769 get_forward(casadi_int nfwd) if no cached version is available.
21770 
21771 ";
21772 
21773 %feature("docstring")  casadi::FunctionInternal::call_forward(const
21774 std::vector< MX > &arg, const std::vector< MX > &res, const std::vector<
21775 std::vector< MX > > &fseed, std::vector< std::vector< MX > > &fsens, bool
21776 always_inline, bool never_inline) const  "
21777 
21778 [INTERNAL]  Forward mode AD, virtual functions overloaded in derived
21779 classes.
21780 
21781 ";
21782 
21783 %feature("docstring")  casadi::FunctionInternal::call_forward(const
21784 std::vector< SX > &arg, const std::vector< SX > &res, const std::vector<
21785 std::vector< SX > > &fseed, std::vector< std::vector< SX > > &fsens, bool
21786 always_inline, bool never_inline) const  "
21787 
21788 [INTERNAL]  Forward mode AD, virtual functions overloaded in derived
21789 classes.
21790 
21791 ";
21792 
21793 %feature("docstring")
21794 casadi::FastNewton::codegen_declarations(CodeGenerator &g) const  "
21795 
21796 [INTERNAL]  Generate code for the declarations of the C function.
21797 
21798 ";
21799 
21800 %feature("docstring")  casadi::FunctionInternal::slice(const std::string
21801 &name, const std::vector< casadi_int > &order_in, const std::vector<
21802 casadi_int > &order_out, const Dict &opts) const  "
21803 
21804 [INTERNAL]  returns a new function with a selection of inputs/outputs of the
21805 original
21806 
21807 ";
21808 
21809 %feature("docstring")
21810 casadi::FunctionInternal::print_dimensions(std::ostream &stream) const  "
21811 
21812 [INTERNAL]  Print dimensions of inputs and outputs.
21813 
21814 ";
21815 
21816 %feature("docstring")  casadi::FunctionInternal::nnz_out() const  "
21817 
21818 [INTERNAL]  Number of input/output nonzeros.
21819 
21820 ";
21821 
21822 %feature("docstring")  casadi::FunctionInternal::nnz_out(casadi_int ind)
21823 const  "
21824 
21825 [INTERNAL]  Number of input/output nonzeros.
21826 
21827 ";
21828 
21829 %feature("docstring")  casadi::FunctionInternal::mx_in(casadi_int ind) const
21830 "
21831 
21832 [INTERNAL]  Get function input(s) and output(s)
21833 
21834 ";
21835 
21836 %feature("docstring")  casadi::FunctionInternal::mx_in() const  "
21837 
21838 [INTERNAL]  Get function input(s) and output(s)
21839 
21840 ";
21841 
21842 %feature("docstring")  casadi::OracleFunction::jit_dependencies(const
21843 std::string &fname)  "
21844 
21845 [INTERNAL]  JIT for dependencies.
21846 
21847 ";
21848 
21849 %feature("docstring")
21850 casadi::FunctionInternal::jacobian_sparsity_filter(const Sparsity &sp) const
21851 "
21852 
21853 [INTERNAL]  Filter out nonzeros in the full sparsity jacobian according to
21854 is_diff_in/out.
21855 
21856 ";
21857 
21858 %feature("docstring")  casadi::FunctionInternal::self() const  "
21859 
21860 [INTERNAL]  Get a public class instance.
21861 
21862 ";
21863 
21864 %feature("docstring")  casadi::FunctionInternal::numel_in() const  "
21865 
21866 [INTERNAL]  Number of input/output elements.
21867 
21868 ";
21869 
21870 %feature("docstring")  casadi::FunctionInternal::numel_in(casadi_int ind)
21871 const  "
21872 
21873 [INTERNAL]  Number of input/output elements.
21874 
21875 ";
21876 
21877 %feature("docstring")  casadi::FunctionInternal::wrap() const  "
21878 
21879 [INTERNAL]  Wrap in an Function instance consisting of only one MX call.
21880 
21881 ";
21882 
21883 %feature("docstring")  casadi::FunctionInternal::definition() const  "
21884 
21885 [INTERNAL]  Get function signature: name:(inputs)->(outputs)
21886 
21887 ";
21888 
21889 %feature("docstring")
21890 casadi::FunctionInternal::instruction_input(casadi_int k) const  "
21891 
21892 [INTERNAL]  Get the (integer) input arguments of an atomic operation.
21893 
21894 ";
21895 
21896 %feature("docstring")
21897 casadi::FunctionInternal::instruction_constant(casadi_int k) const  "
21898 
21899 [INTERNAL]  Get the floating point output argument of an atomic operation.
21900 
21901 ";
21902 
21903 %feature("docstring")  casadi::SharedObjectInternal::getCount() const  "
21904 
21905 [INTERNAL]  Get the reference count.
21906 
21907 ";
21908 
21909 %feature("docstring")  casadi::FunctionInternal::has_jac() const  "
21910 
21911 [INTERNAL]  Return Jacobian of all input elements with respect to all output
21912 elements.
21913 
21914 ";
21915 
21916 %feature("docstring")  casadi::FunctionInternal::nz_in(const std::vector< DM
21917 > &arg) const  "
21918 
21919 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
21920 
21921 ";
21922 
21923 %feature("docstring")  casadi::FunctionInternal::nz_in(const std::vector<
21924 double > &arg) const  "
21925 
21926 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
21927 
21928 ";
21929 
21930 %feature("docstring")  casadi::FunctionInternal::call_reverse(const
21931 std::vector< MX > &arg, const std::vector< MX > &res, const std::vector<
21932 std::vector< MX > > &aseed, std::vector< std::vector< MX > > &asens, bool
21933 always_inline, bool never_inline) const  "
21934 
21935 [INTERNAL]  Reverse mode, virtual functions overloaded in derived classes.
21936 
21937 ";
21938 
21939 %feature("docstring")  casadi::FunctionInternal::call_reverse(const
21940 std::vector< SX > &arg, const std::vector< SX > &res, const std::vector<
21941 std::vector< SX > > &aseed, std::vector< std::vector< SX > > &asens, bool
21942 always_inline, bool never_inline) const  "
21943 
21944 [INTERNAL]  Reverse mode, virtual functions overloaded in derived classes.
21945 
21946 ";
21947 
21948 %feature("docstring")  casadi::FunctionInternal::has_jacobian_sparsity()
21949 const  "
21950 
21951 [INTERNAL]  Get Jacobian sparsity.
21952 
21953 ";
21954 
21955 %feature("docstring")  casadi::ProtoFunction::clear_mem() "
21956 
21957 [INTERNAL]  Clear all memory (called from destructor)
21958 
21959 ";
21960 
21961 %feature("docstring")  casadi::Rootfinder::get_name_in(casadi_int i)  "
21962 
21963 [INTERNAL]  Names of function input and outputs.
21964 
21965 ";
21966 
21967 %feature("docstring")  casadi::OracleFunction::get_function() const  "
21968 
21969 [INTERNAL]  Get list of dependency functions -1 Indicates irregularity.
21970 
21971 ";
21972 
21973 %feature("docstring")  casadi::OracleFunction::get_function(const
21974 std::string &name) const  "
21975 
21976 [INTERNAL] ";
21977 
21978 %feature("docstring")  casadi::Rootfinder::ad_reverse(const std::vector< MX
21979 > &arg, const std::vector< MX > &res, const std::vector< std::vector< MX > >
21980 &aseed, std::vector< std::vector< MX > > &asens, bool always_inline, bool
21981 never_inline) const  "
21982 
21983 [INTERNAL]  Create call to (cached) derivative function, reverse mode.
21984 
21985 ";
21986 
21987 %feature("docstring")  casadi::Rootfinder::has_forward(casadi_int nfwd)
21988 const  "
21989 
21990 [INTERNAL]  Generate a function that calculates nfwd forward derivatives.
21991 
21992 ";
21993 
21994 %feature("docstring")  casadi::Rootfinder::uses_output() const  "
21995 
21996 [INTERNAL]  Do the derivative functions need nondifferentiated outputs?
21997 
21998 ";
21999 
22000 %feature("docstring")  casadi::FunctionInternal::codegen(CodeGenerator &g,
22001 const std::string &fname) const  "
22002 
22003 [INTERNAL]  Generate code the function.
22004 
22005 ";
22006 
22007 %feature("docstring")  casadi::OracleFunction::has_function(const
22008 std::string &fname) const  "
22009 
22010 [INTERNAL] ";
22011 
22012 %feature("docstring")  casadi::Rootfinder::has_sprev() const  "
22013 
22014 [INTERNAL]  Is the class able to propagate seeds through the algorithm?
22015 
22016 ";
22017 
22018 %feature("docstring")  casadi::OracleFunction::monitored(const std::string
22019 &name) const  "
22020 
22021 [INTERNAL] ";
22022 
22023 %feature("docstring")  casadi::FunctionInternal::size_out(casadi_int ind)
22024 const  "
22025 
22026 [INTERNAL]  Input/output dimensions.
22027 
22028 ";
22029 
22030 %feature("docstring")  casadi::FunctionInternal::get_reltol() const  "
22031 
22032 [INTERNAL]  Get relative tolerance.
22033 
22034 ";
22035 
22036 %feature("docstring")
22037 casadi::FunctionInternal::codegen_incref(CodeGenerator &g) const  "
22038 
22039 [INTERNAL]  Codegen incref for dependencies.
22040 
22041 ";
22042 
22043 %feature("docstring")  casadi::FunctionInternal::get_jacobian(const
22044 std::string &name, const std::vector< std::string > &inames, const
22045 std::vector< std::string > &onames, const Dict &opts) const  "
22046 
22047 [INTERNAL]  Return Jacobian of all input elements with respect to all output
22048 elements.
22049 
22050 ";
22051 
22052 %feature("docstring")  casadi::Rootfinder::serialize_type(SerializingStream
22053 &s) const  "
22054 
22055 [INTERNAL]  Serialize type information.
22056 
22057 ";
22058 
22059 %feature("docstring")
22060 casadi::FunctionInternal::getJacSparsityHierarchicalSymm(casadi_int iind,
22061 casadi_int oind) const  "
22062 
22063 [INTERNAL]  A flavor of getJacSparsity that does hierarchical block
22064 structure recognition for symmetric Jacobians
22065 
22066 ";
22067 
22068 %feature("docstring")  casadi::FunctionInternal::free_mx() const  "
22069 
22070 [INTERNAL]  Get free variables ( MX)
22071 
22072 ";
22073 
22074 %feature("docstring")  casadi::FunctionInternal::is_diff_out(casadi_int i) "
22075 
22076 [INTERNAL] ";
22077 
22078 %feature("docstring")
22079 casadi::FunctionInternal::codegen_sparsities(CodeGenerator &g) const  "
22080 
22081 [INTERNAL]  Codegen sparsities.
22082 
22083 ";
22084 
22085 %feature("docstring")  casadi::FunctionInternal::mx_out(casadi_int ind)
22086 const  "
22087 
22088 [INTERNAL]  Get function input(s) and output(s)
22089 
22090 ";
22091 
22092 %feature("docstring")  casadi::FunctionInternal::mx_out() const  "
22093 
22094 [INTERNAL]  Get function input(s) and output(s)
22095 
22096 ";
22097 
22098 %feature("docstring")  casadi::FunctionInternal::codegen_mem_type() const  "
22099 
22100 [INTERNAL]  Thread-local memory object type.
22101 
22102 ";
22103 
22104 %feature("docstring")  casadi::FunctionInternal::replace_fseed(const
22105 std::vector< std::vector< M >> &fseed, casadi_int npar) const  "
22106 
22107 [INTERNAL]  Replace 0-by-0 forward seeds.
22108 
22109 ";
22110 
22111 %feature("docstring")  casadi::FunctionInternal::replace_fseed(const
22112 std::vector< std::vector< M > > &fseed, casadi_int npar) const  "
22113 
22114 [INTERNAL] ";
22115 
22116 %feature("docstring")  casadi::FunctionInternal::eval_sx(const SXElem **arg,
22117 SXElem **res, casadi_int *iw, SXElem *w, void *mem) const  "
22118 
22119 [INTERNAL]  Evaluate with symbolic scalars.
22120 
22121 ";
22122 
22123 %feature("docstring")  casadi::FunctionInternal::convert_res(const
22124 std::vector< M > &res) const  "
22125 
22126 [INTERNAL]  Convert from/to input/output lists/map.
22127 
22128 ";
22129 
22130 %feature("docstring")  casadi::FunctionInternal::convert_res(const std::map<
22131 std::string, M > &res) const  "
22132 
22133 [INTERNAL]  Convert from/to input/output lists/map.
22134 
22135 ";
22136 
22137 %feature("docstring")  casadi::FunctionInternal::size2_in(casadi_int ind)
22138 const  "
22139 
22140 [INTERNAL]  Input/output dimensions.
22141 
22142 ";
22143 
22144 %feature("docstring")
22145 casadi::FunctionInternal::codegen_decref(CodeGenerator &g) const  "
22146 
22147 [INTERNAL]  Codegen decref for dependencies.
22148 
22149 ";
22150 
22151 %feature("docstring")  casadi::Rootfinder::sp_reverse(bvec_t **arg, bvec_t
22152 **res, casadi_int *iw, bvec_t *w, void *mem) const  "
22153 
22154 [INTERNAL]  Propagate sparsity backwards.
22155 
22156 ";
22157 
22158 %feature("docstring")  casadi::FunctionInternal::which_depends(const
22159 std::string &s_in, const std::vector< std::string > &s_out, casadi_int
22160 order, bool tr=false) const  "
22161 
22162 [INTERNAL]  Which variables enter with some order.
22163 
22164 Parameters:
22165 -----------
22166 
22167 s_in:   Input name
22168 
22169 s_out:   Output name(s)
22170 
22171 order:  Only 1 (linear) and 2 (nonlinear) allowed
22172 
22173 tr:  Flip the relationship. Return which expressions contain the variables
22174 
22175 ";
22176 
22177 %feature("docstring")  casadi::FunctionInternal::matching_arg(const
22178 std::vector< M > &arg, casadi_int &npar) const  "
22179 
22180 [INTERNAL]  Check if input arguments that needs to be replaced.
22181 
22182 Raises errors
22183 
22184 Parameters:
22185 -----------
22186 
22187 npar[in]:  normal usage: 1, disallow pararallel calls: -1
22188 
22189 npar:  max number of horizontal repetitions across all arguments (or -1)
22190 
22191 ";
22192 
22193 %feature("docstring")  casadi::FunctionInternal::jac() const  "
22194 
22195 [INTERNAL]  Return Jacobian of all input elements with respect to all output
22196 elements.
22197 
22198 ";
22199 
22200 %feature("docstring")  casadi::FastNewton::init(const Dict &opts)  "
22201 
22202 [INTERNAL]  Initialize.
22203 
22204 ";
22205 
22206 %feature("docstring")  casadi::FunctionInternal::free_sx() const  "
22207 
22208 [INTERNAL]  Get free variables (SX)
22209 
22210 ";
22211 
22212 %feature("docstring")  casadi::FunctionInternal::index_out(const std::string
22213 &name) const  "
22214 
22215 [INTERNAL]  Get output scheme index by name.
22216 
22217 ";
22218 
22219 %feature("docstring")  casadi::FunctionInternal::dm_out(casadi_int ind)
22220 const  "
22221 
22222 [INTERNAL]  Get function input(s) and output(s)
22223 
22224 ";
22225 
22226 %feature("docstring")  casadi::FunctionInternal::dm_out() const  "
22227 
22228 [INTERNAL]  Get function input(s) and output(s)
22229 
22230 ";
22231 
22232 %feature("docstring")  casadi::FunctionInternal::generate_out(const
22233 std::string &fname, double **res) const  "
22234 
22235 [INTERNAL] ";
22236 
22237 %feature("docstring")  casadi::Rootfinder::get_n_out()  "
22238 
22239 [INTERNAL]  Number of function inputs and outputs.
22240 
22241 ";
22242 
22243 %feature("docstring")  casadi::FunctionInternal::alloc_iw(size_t sz_iw, bool
22244 persistent=false) "
22245 
22246 [INTERNAL]  Ensure required length of iw field.
22247 
22248 ";
22249 
22250 %feature("docstring")  casadi::FunctionInternal::replace_res(const
22251 std::vector< M > &res, casadi_int npar) const  "
22252 
22253 [INTERNAL]  Replace 0-by-0 outputs.
22254 
22255 ";
22256 
22257 %feature("docstring")  casadi::FunctionInternal::alloc_arg(size_t sz_arg,
22258 bool persistent=false) "
22259 
22260 [INTERNAL]  Ensure required length of arg field.
22261 
22262 ";
22263 
22264 %feature("docstring")  casadi::FunctionInternal::sx_out(casadi_int ind)
22265 const  "
22266 
22267 [INTERNAL]  Get function input(s) and output(s)
22268 
22269 ";
22270 
22271 %feature("docstring")  casadi::FunctionInternal::sx_out() const  "
22272 
22273 [INTERNAL]  Get function input(s) and output(s)
22274 
22275 ";
22276 
22277 %feature("docstring")  casadi::FunctionInternal::n_nodes() const  "
22278 
22279 [INTERNAL]  Number of nodes in the algorithm.
22280 
22281 ";
22282 
22283 %feature("docstring")  casadi::FunctionInternal::has_free() const  "
22284 
22285 [INTERNAL]  Does the function have free variables.
22286 
22287 ";
22288 
22289 %feature("docstring")  casadi::ProtoFunction::construct(const Dict &opts) "
22290 
22291 [INTERNAL]  Construct Prepares the function for evaluation.
22292 
22293 ";
22294 
22295 %feature("docstring")  casadi::FunctionInternal::has_jacobian() const  "
22296 
22297 [INTERNAL]  Return Jacobian of all input elements with respect to all output
22298 elements.
22299 
22300 ";
22301 
22302 %feature("docstring")  casadi::FunctionInternal::all_scalar() const  "
22303 
22304 [INTERNAL]  Are all inputs and outputs scalar.
22305 
22306 ";
22307 
22308 %feature("docstring")  casadi::FunctionInternal::export_code(const
22309 std::string &lang, std::ostream &stream, const Dict &options) const  "
22310 
22311 [INTERNAL]  Export function in a specific language.
22312 
22313 ";
22314 
22315 %feature("docstring")
22316 casadi::FunctionInternal::getJacSparsityGen(casadi_int iind, casadi_int
22317 oind, bool symmetric, casadi_int gr_i=1, casadi_int gr_o=1) const  "
22318 
22319 [INTERNAL]  Get the sparsity pattern, forward mode.
22320 
22321 ";
22322 
22323 %feature("docstring")  casadi::FastNewton::serialize_body(SerializingStream
22324 &s) const  "
22325 
22326 [INTERNAL]  Serialize an object without type information.
22327 
22328 ";
22329 
22330 %feature("docstring")  casadi::FunctionInternal::call_gen(const MXVector
22331 &arg, MXVector &res, casadi_int npar, bool always_inline, bool never_inline)
22332 const  "
22333 
22334 [INTERNAL]   Call a function, overloaded.
22335 
22336 ";
22337 
22338 %feature("docstring")  casadi::FunctionInternal::call_gen(const std::vector<
22339 MatrixCommon > &arg, std::vector< MatrixCommon > &res, casadi_int npar, bool
22340 always_inline, bool never_inline) const  "
22341 
22342 [INTERNAL]   Call a function, overloaded.
22343 
22344 ";
22345 
22346 %feature("docstring")  casadi::FunctionInternal::sparsity_out(casadi_int
22347 ind) const  "
22348 
22349 [INTERNAL]  Input/output sparsity.
22350 
22351 ";
22352 
22353 %feature("docstring")  casadi::Rootfinder::get_sparsity_out(casadi_int i)  "
22354 
22355 [INTERNAL]  Sparsities of function inputs and outputs.
22356 
22357 ";
22358 
22359 %feature("docstring")  casadi::FunctionInternal::sparsity_jac(casadi_int
22360 iind, casadi_int oind, bool compact, bool symmetric) const  "
22361 
22362 [INTERNAL]  Get, if necessary generate, the sparsity of a Jacobian block.
22363 
22364 ";
22365 
22366 %feature("docstring")  casadi::FunctionInternal::sx_in(casadi_int ind) const
22367 "
22368 
22369 [INTERNAL]  Get function input(s) and output(s)
22370 
22371 ";
22372 
22373 %feature("docstring")  casadi::FunctionInternal::sx_in() const  "
22374 
22375 [INTERNAL]  Get function input(s) and output(s)
22376 
22377 ";
22378 
22379 %feature("docstring")  casadi::FunctionInternal::index_in(const std::string
22380 &name) const  "
22381 
22382 [INTERNAL]  Get input scheme index by name.
22383 
22384 ";
22385 
22386 %feature("docstring")  casadi::FunctionInternal::info() const  "
22387 
22388 [INTERNAL]  Obtain information about function
22389 
22390 ";
22391 
22392 %feature("docstring")
22393 casadi::FunctionInternal::codegen_init_mem(CodeGenerator &g) const  "
22394 
22395 [INTERNAL]  Codegen decref for init_mem.
22396 
22397 ";
22398 
22399 %feature("docstring")  casadi::OracleFunction::create_function(const
22400 std::string &fname, const std::vector< std::string > &s_in, const
22401 std::vector< std::string > &s_out, const Function::AuxOut
22402 &aux=Function::AuxOut()) "
22403 
22404 [INTERNAL]  Create an oracle function
22405 
22406 ";
22407 
22408 %feature("docstring")
22409 casadi::FunctionInternal::codegen_alloc_mem(CodeGenerator &g) const  "
22410 
22411 [INTERNAL]  Codegen decref for alloc_mem.
22412 
22413 ";
22414 
22415 
22416 // File: classcasadi_1_1FileDeserializer.xml
22417 %feature("docstring") casadi::FileDeserializer::FileDeserializer(const
22418 std::string &fname) "
22419 
22420 Advanced deserialization of CasADi objects.
22421 
22422 FileSerializer
22423 
22424 ";
22425 
22426 %feature("docstring") casadi::FileDeserializer "
22427 
22428 C++ includes: serializer.hpp ";
22429 
22430 
22431 // File: classcasadi_1_1FileSerializer.xml
22432 %feature("docstring") casadi::FileSerializer::FileSerializer(const
22433 std::string &fname, const Dict &opts=Dict()) "
22434 
22435 Advanced serialization of CasADi objects.
22436 
22437 StringSerializer, FileDeserializer
22438 
22439 ";
22440 
22441 %feature("docstring") casadi::FileSerializer "
22442 
22443 C++ includes: serializer.hpp ";
22444 
22445 
22446 // File: classcasadi_1_1Find.xml
22447 
22448 
22449 // File: classcasadi_1_1FiniteDiff.xml
22450 %feature("docstring")  casadi::FunctionInternal::codegen_mem(CodeGenerator
22451 &g, const std::string &index="mem") const  "
22452 
22453 [INTERNAL]  Get thread-local memory object.
22454 
22455 ";
22456 
22457 %feature("docstring")  casadi::FunctionInternal::print_options(std::ostream
22458 &stream) const  "
22459 
22460 [INTERNAL]  Print list of options.
22461 
22462 ";
22463 
22464 %feature("docstring")  casadi::FunctionInternal::factory(const std::string
22465 &name, const std::vector< std::string > &s_in, const std::vector<
22466 std::string > &s_out, const Function::AuxOut &aux, const Dict &opts) const
22467 "
22468 
22469 [INTERNAL] ";
22470 
22471 %feature("docstring")  casadi::ProtoFunction::format_time(char *buffer,
22472 double time) const  "
22473 
22474 [INTERNAL]  Format time in a fixed width 8 format.
22475 
22476 ";
22477 
22478 %feature("docstring")  casadi::FunctionInternal::alloc(const Function &f,
22479 bool persistent=false) "
22480 
22481 [INTERNAL]  Ensure work vectors long enough to evaluate function.
22482 
22483 ";
22484 
22485 %feature("docstring")  casadi::FunctionInternal::get_min_in(casadi_int ind)
22486 const  "
22487 
22488 [INTERNAL]  Get smallest input value.
22489 
22490 ";
22491 
22492 %feature("docstring")  casadi::FunctionInternal::is_diff_out(casadi_int i) "
22493 
22494 [INTERNAL] ";
22495 
22496 %feature("docstring")  casadi::FunctionInternal::get_max_in(casadi_int ind)
22497 const  "
22498 
22499 [INTERNAL]  Get largest input value.
22500 
22501 ";
22502 
22503 %feature("docstring")  casadi::FunctionInternal::convert_arg(const
22504 std::vector< M > &arg) const  "
22505 
22506 [INTERNAL]  Convert from/to input/output lists/map.
22507 
22508 ";
22509 
22510 %feature("docstring")  casadi::FunctionInternal::convert_arg(const std::map<
22511 std::string, M > &arg) const  "
22512 
22513 [INTERNAL]  Convert from/to input/output lists/map.
22514 
22515 ";
22516 
22517 %feature("docstring")  casadi::FunctionInternal::sp_forward(const bvec_t
22518 **arg, bvec_t **res, casadi_int *iw, bvec_t *w, void *mem) const  "
22519 
22520 [INTERNAL]  Propagate sparsity forward.
22521 
22522 ";
22523 
22524 %feature("docstring") casadi::FiniteDiff "
22525 
22526 [INTERNAL]  Calculate derivative using finite differences Joel Andersson
22527 
22528 >List of available options
22529 
22530 +------------------+-----------------+------------------+------------------+
22531 |        Id        |      Type       |   Description    |     Used in      |
22532 +==================+=================+==================+==================+
22533 | abstol           | OT_DOUBLE       | Accuracy of      | casadi::FiniteDi |
22534 |                  |                 | function outputs | ff               |
22535 |                  |                 | [default: query  |                  |
22536 |                  |                 | object]          |                  |
22537 +------------------+-----------------+------------------+------------------+
22538 | ad_weight        | OT_DOUBLE       | Weighting factor | casadi::Function |
22539 |                  |                 | for derivative   | Internal         |
22540 |                  |                 | calculation.When |                  |
22541 |                  |                 | there is an      |                  |
22542 |                  |                 | option of either |                  |
22543 |                  |                 | using forward or |                  |
22544 |                  |                 | reverse mode     |                  |
22545 |                  |                 | directional      |                  |
22546 |                  |                 | derivatives, the |                  |
22547 |                  |                 | condition ad_wei |                  |
22548 |                  |                 | ght*nf<=(1-ad_we |                  |
22549 |                  |                 | ight)*na is used |                  |
22550 |                  |                 | where nf and na  |                  |
22551 |                  |                 | are estimates of |                  |
22552 |                  |                 | the number of    |                  |
22553 |                  |                 | forward/reverse  |                  |
22554 |                  |                 | mode directional |                  |
22555 |                  |                 | derivatives      |                  |
22556 |                  |                 | needed. By       |                  |
22557 |                  |                 | default,         |                  |
22558 |                  |                 | ad_weight is     |                  |
22559 |                  |                 | calculated       |                  |
22560 |                  |                 | automatically,   |                  |
22561 |                  |                 | but this can be  |                  |
22562 |                  |                 | overridden by    |                  |
22563 |                  |                 | setting this     |                  |
22564 |                  |                 | option. In       |                  |
22565 |                  |                 | particular, 0    |                  |
22566 |                  |                 | means forcing    |                  |
22567 |                  |                 | forward mode and |                  |
22568 |                  |                 | 1 forcing        |                  |
22569 |                  |                 | reverse mode.    |                  |
22570 |                  |                 | Leave unset for  |                  |
22571 |                  |                 | (class specific) |                  |
22572 |                  |                 | heuristics.      |                  |
22573 +------------------+-----------------+------------------+------------------+
22574 | ad_weight_sp     | OT_DOUBLE       | Weighting factor | casadi::Function |
22575 |                  |                 | for sparsity     | Internal         |
22576 |                  |                 | pattern          |                  |
22577 |                  |                 | calculation calc |                  |
22578 |                  |                 | ulation.Override |                  |
22579 |                  |                 | s default        |                  |
22580 |                  |                 | behavior. Set to |                  |
22581 |                  |                 | 0 and 1 to force |                  |
22582 |                  |                 | forward and      |                  |
22583 |                  |                 | reverse mode     |                  |
22584 |                  |                 | respectively.    |                  |
22585 |                  |                 | Cf. option       |                  |
22586 |                  |                 | \"ad_weight\".     |                  |
22587 |                  |                 | When set to -1,  |                  |
22588 |                  |                 | sparsity is      |                  |
22589 |                  |                 | completely       |                  |
22590 |                  |                 | ignored and      |                  |
22591 |                  |                 | dense matrices   |                  |
22592 |                  |                 | are used.        |                  |
22593 +------------------+-----------------+------------------+------------------+
22594 | always_inline    | OT_BOOL         | Force inlining.  | casadi::Function |
22595 |                  |                 |                  | Internal         |
22596 +------------------+-----------------+------------------+------------------+
22597 | compiler         | OT_STRING       | Just-in-time     | casadi::Function |
22598 |                  |                 | compiler plugin  | Internal         |
22599 |                  |                 | to be used.      |                  |
22600 +------------------+-----------------+------------------+------------------+
22601 | custom_jacobian  | OT_FUNCTION     | Override         | casadi::Function |
22602 |                  |                 | CasADi's AD. Use | Internal         |
22603 |                  |                 | together with    |                  |
22604 |                  |                 | 'jac_penalty':   |                  |
22605 |                  |                 | 0. Note: Highly  |                  |
22606 |                  |                 | experimental.    |                  |
22607 |                  |                 | Syntax may break |                  |
22608 |                  |                 | often.           |                  |
22609 +------------------+-----------------+------------------+------------------+
22610 | derivative_of    | OT_FUNCTION     | The function is  | casadi::Function |
22611 |                  |                 | a derivative of  | Internal         |
22612 |                  |                 | another          |                  |
22613 |                  |                 | function. The    |                  |
22614 |                  |                 | type of          |                  |
22615 |                  |                 | derivative       |                  |
22616 |                  |                 | (directional     |                  |
22617 |                  |                 | derivative,      |                  |
22618 |                  |                 | Jacobian) is     |                  |
22619 |                  |                 | inferred from    |                  |
22620 |                  |                 | the function     |                  |
22621 |                  |                 | name.            |                  |
22622 +------------------+-----------------+------------------+------------------+
22623 | dump             | OT_BOOL         | Dump function to | casadi::Function |
22624 |                  |                 | file upon first  | Internal         |
22625 |                  |                 | evaluation.      |                  |
22626 |                  |                 | [false]          |                  |
22627 +------------------+-----------------+------------------+------------------+
22628 | dump_dir         | OT_STRING       | Directory to     | casadi::Function |
22629 |                  |                 | dump             | Internal         |
22630 |                  |                 | inputs/outputs   |                  |
22631 |                  |                 | to. Make sure    |                  |
22632 |                  |                 | the directory    |                  |
22633 |                  |                 | exists [.]       |                  |
22634 +------------------+-----------------+------------------+------------------+
22635 | dump_format      | OT_STRING       | Choose file      | casadi::Function |
22636 |                  |                 | format to dump   | Internal         |
22637 |                  |                 | matrices. See    |                  |
22638 |                  |                 | DM.from_file     |                  |
22639 |                  |                 | [mtx]            |                  |
22640 +------------------+-----------------+------------------+------------------+
22641 | dump_in          | OT_BOOL         | Dump numerical   | casadi::Function |
22642 |                  |                 | values of inputs | Internal         |
22643 |                  |                 | to file          |                  |
22644 |                  |                 | (readable with   |                  |
22645 |                  |                 | DM.from_file )   |                  |
22646 |                  |                 | [default: false] |                  |
22647 +------------------+-----------------+------------------+------------------+
22648 | dump_out         | OT_BOOL         | Dump numerical   | casadi::Function |
22649 |                  |                 | values of        | Internal         |
22650 |                  |                 | outputs to file  |                  |
22651 |                  |                 | (readable with   |                  |
22652 |                  |                 | DM.from_file )   |                  |
22653 |                  |                 | [default: false] |                  |
22654 +------------------+-----------------+------------------+------------------+
22655 | enable_fd        | OT_BOOL         | Enable           | casadi::Function |
22656 |                  |                 | derivative       | Internal         |
22657 |                  |                 | calculation by   |                  |
22658 |                  |                 | finite           |                  |
22659 |                  |                 | differencing.    |                  |
22660 |                  |                 | [default:        |                  |
22661 |                  |                 | false]]          |                  |
22662 +------------------+-----------------+------------------+------------------+
22663 | enable_forward   | OT_BOOL         | Enable           | casadi::Function |
22664 |                  |                 | derivative       | Internal         |
22665 |                  |                 | calculation      |                  |
22666 |                  |                 | using generated  |                  |
22667 |                  |                 | functions for    |                  |
22668 |                  |                 | Jacobian-times-  |                  |
22669 |                  |                 | vector products  |                  |
22670 |                  |                 | - typically      |                  |
22671 |                  |                 | using forward    |                  |
22672 |                  |                 | mode AD - if     |                  |
22673 |                  |                 | available.       |                  |
22674 |                  |                 | [default: true]  |                  |
22675 +------------------+-----------------+------------------+------------------+
22676 | enable_jacobian  | OT_BOOL         | Enable           | casadi::Function |
22677 |                  |                 | derivative       | Internal         |
22678 |                  |                 | calculation      |                  |
22679 |                  |                 | using generated  |                  |
22680 |                  |                 | functions for    |                  |
22681 |                  |                 | Jacobians of all |                  |
22682 |                  |                 | differentiable   |                  |
22683 |                  |                 | outputs with     |                  |
22684 |                  |                 | respect to all   |                  |
22685 |                  |                 | differentiable   |                  |
22686 |                  |                 | inputs - if      |                  |
22687 |                  |                 | available.       |                  |
22688 |                  |                 | [default: true]  |                  |
22689 +------------------+-----------------+------------------+------------------+
22690 | enable_reverse   | OT_BOOL         | Enable           | casadi::Function |
22691 |                  |                 | derivative       | Internal         |
22692 |                  |                 | calculation      |                  |
22693 |                  |                 | using generated  |                  |
22694 |                  |                 | functions for    |                  |
22695 |                  |                 | transposed       |                  |
22696 |                  |                 | Jacobian-times-  |                  |
22697 |                  |                 | vector products  |                  |
22698 |                  |                 | - typically      |                  |
22699 |                  |                 | using reverse    |                  |
22700 |                  |                 | mode AD - if     |                  |
22701 |                  |                 | available.       |                  |
22702 |                  |                 | [default: true]  |                  |
22703 +------------------+-----------------+------------------+------------------+
22704 | fd_method        | OT_STRING       | Method for       | casadi::Function |
22705 |                  |                 | finite           | Internal         |
22706 |                  |                 | differencing     |                  |
22707 |                  |                 | [default         |                  |
22708 |                  |                 | 'central']       |                  |
22709 +------------------+-----------------+------------------+------------------+
22710 | fd_options       | OT_DICT         | Options to be    | casadi::Function |
22711 |                  |                 | passed to the    | Internal         |
22712 |                  |                 | finite           |                  |
22713 |                  |                 | difference       |                  |
22714 |                  |                 | instance         |                  |
22715 +------------------+-----------------+------------------+------------------+
22716 | forward_options  | OT_DICT         | Options to be    | casadi::Function |
22717 |                  |                 | passed to a      | Internal         |
22718 |                  |                 | forward mode     |                  |
22719 |                  |                 | constructor      |                  |
22720 +------------------+-----------------+------------------+------------------+
22721 | gather_stats     | OT_BOOL         | Deprecated       | casadi::Function |
22722 |                  |                 | option           | Internal         |
22723 |                  |                 | (ignored):       |                  |
22724 |                  |                 | Statistics are   |                  |
22725 |                  |                 | now always       |                  |
22726 |                  |                 | collected.       |                  |
22727 +------------------+-----------------+------------------+------------------+
22728 | h                | OT_DOUBLE       | Step size        | casadi::FiniteDi |
22729 |                  |                 | [default:        | ff               |
22730 |                  |                 | computed from    |                  |
22731 |                  |                 | abstol]          |                  |
22732 +------------------+-----------------+------------------+------------------+
22733 | h_iter           | OT_INT          | Number of        | casadi::FiniteDi |
22734 |                  |                 | iterations to    | ff               |
22735 |                  |                 | improve on the   |                  |
22736 |                  |                 | step-size        |                  |
22737 |                  |                 | [default: 1 if   |                  |
22738 |                  |                 | error estimate   |                  |
22739 |                  |                 | available,       |                  |
22740 |                  |                 | otherwise 0]     |                  |
22741 +------------------+-----------------+------------------+------------------+
22742 | h_max            | OT_DOUBLE       | Maximum step     | casadi::FiniteDi |
22743 |                  |                 | size [default 0] | ff               |
22744 +------------------+-----------------+------------------+------------------+
22745 | h_min            | OT_DOUBLE       | Minimum step     | casadi::FiniteDi |
22746 |                  |                 | size [default    | ff               |
22747 |                  |                 | inf]             |                  |
22748 +------------------+-----------------+------------------+------------------+
22749 | input_scheme     | OT_STRINGVECTOR | Deprecated       | casadi::Function |
22750 |                  |                 | option (ignored) | Internal         |
22751 +------------------+-----------------+------------------+------------------+
22752 | inputs_check     | OT_BOOL         | Throw exceptions | casadi::Function |
22753 |                  |                 | when the         | Internal         |
22754 |                  |                 | numerical values |                  |
22755 |                  |                 | of the inputs    |                  |
22756 |                  |                 | don't make sense |                  |
22757 +------------------+-----------------+------------------+------------------+
22758 | is_diff_in       | OT_BOOLVECTOR   | Indicate for     | casadi::Function |
22759 |                  |                 | each input if it | Internal         |
22760 |                  |                 | should be        |                  |
22761 |                  |                 | differentiable.  |                  |
22762 +------------------+-----------------+------------------+------------------+
22763 | is_diff_out      | OT_BOOLVECTOR   | Indicate for     | casadi::Function |
22764 |                  |                 | each output if   | Internal         |
22765 |                  |                 | it should be     |                  |
22766 |                  |                 | differentiable.  |                  |
22767 +------------------+-----------------+------------------+------------------+
22768 | jac_penalty      | OT_DOUBLE       | When requested   | casadi::Function |
22769 |                  |                 | for a number of  | Internal         |
22770 |                  |                 | forward/reverse  |                  |
22771 |                  |                 | directions, it   |                  |
22772 |                  |                 | may be cheaper   |                  |
22773 |                  |                 | to compute first |                  |
22774 |                  |                 | the full         |                  |
22775 |                  |                 | jacobian and     |                  |
22776 |                  |                 | then multiply    |                  |
22777 |                  |                 | with seeds,      |                  |
22778 |                  |                 | rather than      |                  |
22779 |                  |                 | obtain the       |                  |
22780 |                  |                 | requested        |                  |
22781 |                  |                 | directions in a  |                  |
22782 |                  |                 | straightforward  |                  |
22783 |                  |                 | manner. Casadi   |                  |
22784 |                  |                 | uses a heuristic |                  |
22785 |                  |                 | to decide which  |                  |
22786 |                  |                 | is cheaper. A    |                  |
22787 |                  |                 | high value of    |                  |
22788 |                  |                 | 'jac_penalty'    |                  |
22789 |                  |                 | makes it less    |                  |
22790 |                  |                 | likely for the   |                  |
22791 |                  |                 | heurstic to      |                  |
22792 |                  |                 | chose the full   |                  |
22793 |                  |                 | Jacobian         |                  |
22794 |                  |                 | strategy. The    |                  |
22795 |                  |                 | special value -1 |                  |
22796 |                  |                 | indicates never  |                  |
22797 |                  |                 | to use the full  |                  |
22798 |                  |                 | Jacobian         |                  |
22799 |                  |                 | strategy         |                  |
22800 +------------------+-----------------+------------------+------------------+
22801 | jit              | OT_BOOL         | Use just-in-time | casadi::Function |
22802 |                  |                 | compiler to      | Internal         |
22803 |                  |                 | speed up the     |                  |
22804 |                  |                 | evaluation       |                  |
22805 +------------------+-----------------+------------------+------------------+
22806 | jit_cleanup      | OT_BOOL         | Cleanup up the   | casadi::Function |
22807 |                  |                 | temporary source | Internal         |
22808 |                  |                 | file that jit    |                  |
22809 |                  |                 | creates.         |                  |
22810 |                  |                 | Default: true    |                  |
22811 +------------------+-----------------+------------------+------------------+
22812 | jit_name         | OT_STRING       | The file name    | casadi::Function |
22813 |                  |                 | used to write    | Internal         |
22814 |                  |                 | out code. The    |                  |
22815 |                  |                 | actual file      |                  |
22816 |                  |                 | names used       |                  |
22817 |                  |                 | depend on 'jit_t |                  |
22818 |                  |                 | emp_suffix' and  |                  |
22819 |                  |                 | include          |                  |
22820 |                  |                 | extensions.      |                  |
22821 |                  |                 | Default:         |                  |
22822 |                  |                 | 'jit_tmp'        |                  |
22823 +------------------+-----------------+------------------+------------------+
22824 | jit_options      | OT_DICT         | Options to be    | casadi::Function |
22825 |                  |                 | passed to the    | Internal         |
22826 |                  |                 | jit compiler.    |                  |
22827 +------------------+-----------------+------------------+------------------+
22828 | jit_serialize    | OT_STRING       | Specify          | casadi::Function |
22829 |                  |                 | behaviour when   | Internal         |
22830 |                  |                 | serializing a    |                  |
22831 |                  |                 | jitted function: |                  |
22832 |                  |                 | SOURCE|link|embe |                  |
22833 |                  |                 | d.               |                  |
22834 +------------------+-----------------+------------------+------------------+
22835 | jit_temp_suffix  | OT_BOOL         | Use a temporary  | casadi::Function |
22836 |                  |                 | (seemingly       | Internal         |
22837 |                  |                 | random) filename |                  |
22838 |                  |                 | suffix for       |                  |
22839 |                  |                 | generated code   |                  |
22840 |                  |                 | and libraries.   |                  |
22841 |                  |                 | This is desired  |                  |
22842 |                  |                 | for thread-      |                  |
22843 |                  |                 | safety. This     |                  |
22844 |                  |                 | behaviour may    |                  |
22845 |                  |                 | defeat caching   |                  |
22846 |                  |                 | compiler         |                  |
22847 |                  |                 | wrappers.        |                  |
22848 |                  |                 | Default: true    |                  |
22849 +------------------+-----------------+------------------+------------------+
22850 | max_num_dir      | OT_INT          | Specify the      | casadi::Function |
22851 |                  |                 | maximum number   | Internal         |
22852 |                  |                 | of directions    |                  |
22853 |                  |                 | for derivative   |                  |
22854 |                  |                 | functions.       |                  |
22855 |                  |                 | Overrules the    |                  |
22856 |                  |                 | builtin optimize |                  |
22857 |                  |                 | d_num_dir.       |                  |
22858 +------------------+-----------------+------------------+------------------+
22859 | never_inline     | OT_BOOL         | Forbid inlining. | casadi::Function |
22860 |                  |                 |                  | Internal         |
22861 +------------------+-----------------+------------------+------------------+
22862 | output_scheme    | OT_STRINGVECTOR | Deprecated       | casadi::Function |
22863 |                  |                 | option (ignored) | Internal         |
22864 +------------------+-----------------+------------------+------------------+
22865 | print_in         | OT_BOOL         | Print numerical  | casadi::Function |
22866 |                  |                 | values of inputs | Internal         |
22867 |                  |                 | [default: false] |                  |
22868 +------------------+-----------------+------------------+------------------+
22869 | print_out        | OT_BOOL         | Print numerical  | casadi::Function |
22870 |                  |                 | values of        | Internal         |
22871 |                  |                 | outputs          |                  |
22872 |                  |                 | [default: false] |                  |
22873 +------------------+-----------------+------------------+------------------+
22874 | print_time       | OT_BOOL         | print            | casadi::Function |
22875 |                  |                 | information      | Internal         |
22876 |                  |                 | about execution  |                  |
22877 |                  |                 | time. Implies    |                  |
22878 |                  |                 | record_time.     |                  |
22879 +------------------+-----------------+------------------+------------------+
22880 | record_time      | OT_BOOL         | record           | casadi::Function |
22881 |                  |                 | information      | Internal         |
22882 |                  |                 | about execution  |                  |
22883 |                  |                 | time, for        |                  |
22884 |                  |                 | retrieval with   |                  |
22885 |                  |                 | stats().         |                  |
22886 +------------------+-----------------+------------------+------------------+
22887 | regularity_check | OT_BOOL         | Throw exceptions | casadi::Function |
22888 |                  |                 | when NaN or Inf  | Internal         |
22889 |                  |                 | appears during   |                  |
22890 |                  |                 | evaluation       |                  |
22891 +------------------+-----------------+------------------+------------------+
22892 | reltol           | OT_DOUBLE       | Accuracy of      | casadi::FiniteDi |
22893 |                  |                 | function inputs  | ff               |
22894 |                  |                 | [default: query  |                  |
22895 |                  |                 | object]          |                  |
22896 +------------------+-----------------+------------------+------------------+
22897 | reverse_options  | OT_DICT         | Options to be    | casadi::Function |
22898 |                  |                 | passed to a      | Internal         |
22899 |                  |                 | reverse mode     |                  |
22900 |                  |                 | constructor      |                  |
22901 +------------------+-----------------+------------------+------------------+
22902 | second_order_ste | OT_DOUBLE       | Second order     | casadi::FiniteDi |
22903 | psize            |                 | perturbation     | ff               |
22904 |                  |                 | size [default:   |                  |
22905 |                  |                 | 1e-3]            |                  |
22906 +------------------+-----------------+------------------+------------------+
22907 | smoothing        | OT_DOUBLE       | Smoothing        | casadi::FiniteDi |
22908 |                  |                 | regularization   | ff               |
22909 |                  |                 | [default:        |                  |
22910 |                  |                 | machine          |                  |
22911 |                  |                 | precision]       |                  |
22912 +------------------+-----------------+------------------+------------------+
22913 | u_aim            | OT_DOUBLE       | Target ratio of  | casadi::FiniteDi |
22914 |                  |                 | roundoff error   | ff               |
22915 |                  |                 | to truncation    |                  |
22916 |                  |                 | error [default:  |                  |
22917 |                  |                 | 100.]            |                  |
22918 +------------------+-----------------+------------------+------------------+
22919 | user_data        | OT_VOIDPTR      | A user-defined   | casadi::Function |
22920 |                  |                 | field that can   | Internal         |
22921 |                  |                 | be used to       |                  |
22922 |                  |                 | identify the     |                  |
22923 |                  |                 | function or pass |                  |
22924 |                  |                 | additional       |                  |
22925 |                  |                 | information      |                  |
22926 +------------------+-----------------+------------------+------------------+
22927 | verbose          | OT_BOOL         | Verbose          | casadi::Function |
22928 |                  |                 | evaluation  for  | Internal         |
22929 |                  |                 | debugging        |                  |
22930 +------------------+-----------------+------------------+------------------+
22931 
22932 Diagrams
22933 --------
22934 
22935 
22936 
22937 C++ includes: finite_differences.hpp ";
22938 
22939 %feature("docstring")  casadi::FiniteDiff::get_default_in(casadi_int ind)
22940 const  "
22941 
22942 [INTERNAL]  Get default input value.
22943 
22944 ";
22945 
22946 %feature("docstring")  casadi::FunctionInternal::n_nodes() const  "
22947 
22948 [INTERNAL]  Number of nodes in the algorithm.
22949 
22950 ";
22951 
22952 %feature("docstring")  casadi::FunctionInternal::getAdaptorSolverName()
22953 const  "
22954 
22955 [INTERNAL]  Obtain solver name from Adaptor.
22956 
22957 ";
22958 
22959 %feature("docstring")  casadi::FunctionInternal::has_jacobian_sparsity()
22960 const  "
22961 
22962 [INTERNAL]  Get Jacobian sparsity.
22963 
22964 ";
22965 
22966 %feature("docstring")
22967 casadi::FunctionInternal::instruction_input(casadi_int k) const  "
22968 
22969 [INTERNAL]  Get the (integer) input arguments of an atomic operation.
22970 
22971 ";
22972 
22973 %feature("docstring")  casadi::FunctionInternal::generate_lifted(Function
22974 &vdef_fcn, Function &vinit_fcn) const  "
22975 
22976 [INTERNAL]  Extract the functions needed for the Lifted Newton method.
22977 
22978 ";
22979 
22980 %feature("docstring")  casadi::FunctionInternal::has_jacobian() const  "
22981 
22982 [INTERNAL]  Return Jacobian of all input elements with respect to all output
22983 elements.
22984 
22985 ";
22986 
22987 %feature("docstring")
22988 casadi::FunctionInternal::serialize_type(SerializingStream &s) const  "
22989 
22990 [INTERNAL]  Serialize type information.
22991 
22992 ";
22993 
22994 %feature("docstring")  casadi::FiniteDiff::eval(const double **arg, double
22995 **res, casadi_int *iw, double *w, void *mem) const  "
22996 
22997 [INTERNAL]  Evaluate numerically.
22998 
22999 ";
23000 
23001 %feature("docstring")  casadi::FunctionInternal::sz_w() const  "
23002 
23003 [INTERNAL]  Get required length of w field.
23004 
23005 ";
23006 
23007 %feature("docstring")  casadi::FunctionInternal::incache(const std::string
23008 &fname, Function &f, const std::string &suffix="") const  "
23009 
23010 [INTERNAL]  Get function in cache.
23011 
23012 ";
23013 
23014 %feature("docstring")  casadi::FunctionInternal::print_option(const
23015 std::string &name, std::ostream &stream) const  "
23016 
23017 [INTERNAL]  Print all information there is to know about a certain option.
23018 
23019 ";
23020 
23021 %feature("docstring")  casadi::FunctionInternal::get_abstol() const  "
23022 
23023 [INTERNAL]  Get absolute tolerance.
23024 
23025 ";
23026 
23027 %feature("docstring")  casadi::FunctionInternal::alloc_arg(size_t sz_arg,
23028 bool persistent=false) "
23029 
23030 [INTERNAL]  Ensure required length of arg field.
23031 
23032 ";
23033 
23034 %feature("docstring")  casadi::FunctionInternal::n_instructions() const  "
23035 
23036 [INTERNAL]  Get the number of atomic operations.
23037 
23038 ";
23039 
23040 %feature("docstring")  casadi::FunctionInternal::has_eval_dm() const  "
23041 
23042 [INTERNAL]  Evaluate with DM matrices.
23043 
23044 ";
23045 
23046 %feature("docstring")  casadi::FunctionInternal::adjViaJac(casadi_int nadj)
23047 const  "
23048 
23049 [INTERNAL]  Calculate derivatives by multiplying the full Jacobian and
23050 multiplying.
23051 
23052 ";
23053 
23054 %feature("docstring")  casadi::FunctionInternal::is_diff_in(casadi_int i) "
23055 
23056 [INTERNAL] ";
23057 
23058 %feature("docstring")  casadi::FunctionInternal::definition() const  "
23059 
23060 [INTERNAL]  Get function signature: name:(inputs)->(outputs)
23061 
23062 ";
23063 
23064 %feature("docstring")  casadi::ProtoFunction::init_mem(void *mem) const  "
23065 
23066 [INTERNAL]  Initalize memory block.
23067 
23068 ";
23069 
23070 %feature("docstring")  casadi::FiniteDiff::init(const Dict &opts)  "
23071 
23072 [INTERNAL]  Initialize.
23073 
23074 ";
23075 
23076 %feature("docstring")  casadi::FunctionInternal::sz_iw() const  "
23077 
23078 [INTERNAL]  Get required length of iw field.
23079 
23080 ";
23081 
23082 %feature("docstring")  casadi::FunctionInternal::free_sx() const  "
23083 
23084 [INTERNAL]  Get free variables (SX)
23085 
23086 ";
23087 
23088 %feature("docstring")  casadi::FunctionInternal::has_function(const
23089 std::string &fname) const  "
23090 
23091 [INTERNAL] ";
23092 
23093 %feature("docstring")  casadi::FunctionInternal::has_free() const  "
23094 
23095 [INTERNAL]  Does the function have free variables.
23096 
23097 ";
23098 
23099 %feature("docstring")  casadi::FunctionInternal::sx_out(casadi_int ind)
23100 const  "
23101 
23102 [INTERNAL]  Get function input(s) and output(s)
23103 
23104 ";
23105 
23106 %feature("docstring")  casadi::FunctionInternal::sx_out() const  "
23107 
23108 [INTERNAL]  Get function input(s) and output(s)
23109 
23110 ";
23111 
23112 %feature("docstring")  casadi::ProtoFunction::serialize(SerializingStream
23113 &s) const  "
23114 
23115 [INTERNAL]  Serialize an object.
23116 
23117 ";
23118 
23119 %feature("docstring")  casadi::FunctionInternal::is_a(const std::string
23120 &type, bool recursive) const  "
23121 
23122 [INTERNAL]  Check if the function is of a particular type.
23123 
23124 ";
23125 
23126 %feature("docstring")  casadi::FunctionInternal::generate_out(const
23127 std::string &fname, double **res) const  "
23128 
23129 [INTERNAL] ";
23130 
23131 %feature("docstring")  casadi::FunctionInternal::matching_res(const
23132 std::vector< M > &arg, casadi_int &npar) const  "
23133 
23134 [INTERNAL]  Check if output arguments that needs to be replaced.
23135 
23136 Raises errors
23137 
23138 Parameters:
23139 -----------
23140 
23141 npar[in]:  normal usage: 1, disallow pararallel calls: -1
23142 
23143 npar:  max number of horizontal repetitions across all arguments (or -1)
23144 
23145 ";
23146 
23147 %feature("docstring")  casadi::FunctionInternal::call(const std::vector< M >
23148 &arg, std::vector< M > &res, bool always_inline, bool never_inline) const  "
23149 
23150 [INTERNAL]   Call a function, templated.
23151 
23152 ";
23153 
23154 %feature("docstring") casadi::FiniteDiff::FiniteDiff(const std::string
23155 &name, casadi_int n) "
23156 
23157 [INTERNAL] ";
23158 
23159 %feature("docstring")  casadi::ProtoFunction::sprint(char *buf, size_t
23160 buf_sz, const char *fmt,...) const  "
23161 
23162 [INTERNAL]  C-style formatted printing to string.
23163 
23164 ";
23165 
23166 %feature("docstring")  casadi::FunctionInternal::sp_reverse(bvec_t **arg,
23167 bvec_t **res, casadi_int *iw, bvec_t *w, void *mem) const  "
23168 
23169 [INTERNAL]  Propagate sparsity backwards.
23170 
23171 ";
23172 
23173 %feature("docstring")  casadi::FunctionInternal::eval_gen(const double
23174 **arg, double **res, casadi_int *iw, double *w, void *mem) const  "
23175 
23176 [INTERNAL]  Evaluate numerically.
23177 
23178 ";
23179 
23180 %feature("docstring")  casadi::FunctionInternal::eval_gen(const SXElem
23181 **arg, SXElem **res, casadi_int *iw, SXElem *w, void *mem) const  "
23182 
23183 [INTERNAL]  Evaluate a function, overloaded.
23184 
23185 ";
23186 
23187 %feature("docstring")  casadi::FunctionInternal::eval_gen(const bvec_t
23188 **arg, bvec_t **res, casadi_int *iw, bvec_t *w, void *mem) const  "
23189 
23190 [INTERNAL]  Evaluate a function, overloaded.
23191 
23192 ";
23193 
23194 %feature("docstring")  casadi::FunctionInternal::size2_out(casadi_int ind)
23195 const  "
23196 
23197 [INTERNAL]  Input/output dimensions.
23198 
23199 ";
23200 
23201 %feature("docstring")
23202 casadi::FunctionInternal::getJacSparsityHierarchicalSymm(casadi_int iind,
23203 casadi_int oind) const  "
23204 
23205 [INTERNAL]  A flavor of getJacSparsity that does hierarchical block
23206 structure recognition for symmetric Jacobians
23207 
23208 ";
23209 
23210 %feature("docstring")  casadi::FunctionInternal::forward(casadi_int nfwd)
23211 const  "
23212 
23213 [INTERNAL]  Return function that calculates forward derivatives
23214 forward(nfwd) returns a cached instance if available, and calls  Function
23215 get_forward(casadi_int nfwd) if no cached version is available.
23216 
23217 ";
23218 
23219 %feature("docstring")  casadi::FunctionInternal::call_reverse(const
23220 std::vector< MX > &arg, const std::vector< MX > &res, const std::vector<
23221 std::vector< MX > > &aseed, std::vector< std::vector< MX > > &asens, bool
23222 always_inline, bool never_inline) const  "
23223 
23224 [INTERNAL]  Reverse mode, virtual functions overloaded in derived classes.
23225 
23226 ";
23227 
23228 %feature("docstring")  casadi::FunctionInternal::call_reverse(const
23229 std::vector< SX > &arg, const std::vector< SX > &res, const std::vector<
23230 std::vector< SX > > &aseed, std::vector< std::vector< SX > > &asens, bool
23231 always_inline, bool never_inline) const  "
23232 
23233 [INTERNAL]  Reverse mode, virtual functions overloaded in derived classes.
23234 
23235 ";
23236 
23237 %feature("docstring")
23238 casadi::FiniteDiff::codegen_declarations(CodeGenerator &g) const  "
23239 
23240 [INTERNAL]  Generate code for the declarations of the C function.
23241 
23242 ";
23243 
23244 %feature("docstring")  casadi::FunctionInternal::eval_dm(const std::vector<
23245 DM > &arg) const  "
23246 
23247 [INTERNAL]  Evaluate with DM matrices.
23248 
23249 ";
23250 
23251 %feature("docstring")  casadi::FunctionInternal::setup(void *mem, const
23252 double **arg, double **res, casadi_int *iw, double *w) const  "
23253 
23254 [INTERNAL]  Set the (persistent and temporary) work vectors.
23255 
23256 ";
23257 
23258 %feature("docstring")  casadi::FunctionInternal::alloc_w(size_t sz_w, bool
23259 persistent=false) "
23260 
23261 [INTERNAL]  Ensure required length of w field.
23262 
23263 ";
23264 
23265 %feature("docstring")  casadi::FunctionInternal::jit_dependencies(const
23266 std::string &fname) "
23267 
23268 [INTERNAL]  Jit dependencies.
23269 
23270 ";
23271 
23272 %feature("docstring")  casadi::ProtoFunction::alloc_mem() const  "
23273 
23274 [INTERNAL]  Create memory block.
23275 
23276 ";
23277 
23278 %feature("docstring")  casadi::FunctionInternal::mx_in(casadi_int ind) const
23279 "
23280 
23281 [INTERNAL]  Get function input(s) and output(s)
23282 
23283 ";
23284 
23285 %feature("docstring")  casadi::FunctionInternal::mx_in() const  "
23286 
23287 [INTERNAL]  Get function input(s) and output(s)
23288 
23289 ";
23290 
23291 %feature("docstring")  casadi::FunctionInternal::instruction_MX(casadi_int
23292 k) const  "
23293 
23294 [INTERNAL]  get MX expression associated with instruction
23295 
23296 ";
23297 
23298 %feature("docstring")  casadi::FunctionInternal::sparsity_out(casadi_int
23299 ind) const  "
23300 
23301 [INTERNAL]  Input/output sparsity.
23302 
23303 ";
23304 
23305 %feature("docstring")  casadi::FunctionInternal::all_scalar() const  "
23306 
23307 [INTERNAL]  Are all inputs and outputs scalar.
23308 
23309 ";
23310 
23311 %feature("docstring")  casadi::FunctionInternal::finalize()  "
23312 
23313 [INTERNAL]  Finalize the object creation.
23314 
23315 ";
23316 
23317 %feature("docstring")  casadi::FunctionInternal::index_in(const std::string
23318 &name) const  "
23319 
23320 [INTERNAL]  Get input scheme index by name.
23321 
23322 ";
23323 
23324 %feature("docstring")  casadi::FunctionInternal::tocache(const Function &f,
23325 const std::string &suffix="") const  "
23326 
23327 [INTERNAL]  Save function to cache.
23328 
23329 ";
23330 
23331 %feature("docstring")  casadi::FunctionInternal::size2_in(casadi_int ind)
23332 const  "
23333 
23334 [INTERNAL]  Input/output dimensions.
23335 
23336 ";
23337 
23338 %feature("docstring")  casadi::FunctionInternal::get_jacobian_sparsity()
23339 const  "
23340 
23341 [INTERNAL]  Get Jacobian sparsity.
23342 
23343 ";
23344 
23345 %feature("docstring")  casadi::SharedObjectInternal::class_name() const  "
23346 
23347 [INTERNAL]  Readable name of the internal class.
23348 
23349 ";
23350 
23351 %feature("docstring")  casadi::ProtoFunction::release(int mem) const  "
23352 
23353 [INTERNAL]  Release a memory object.
23354 
23355 ";
23356 
23357 %feature("docstring")  casadi::FunctionInternal::nz_in(const std::vector< DM
23358 > &arg) const  "
23359 
23360 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
23361 
23362 ";
23363 
23364 %feature("docstring")  casadi::FunctionInternal::nz_in(const std::vector<
23365 double > &arg) const  "
23366 
23367 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
23368 
23369 ";
23370 
23371 %feature("docstring")
23372 casadi::FunctionInternal::getJacSparsityGen(casadi_int iind, casadi_int
23373 oind, bool symmetric, casadi_int gr_i=1, casadi_int gr_o=1) const  "
23374 
23375 [INTERNAL]  Get the sparsity pattern, forward mode.
23376 
23377 ";
23378 
23379 %feature("docstring")  casadi::FiniteDiff::get_sparsity_in(casadi_int i)  "
23380 
23381 [INTERNAL]  Sparsities of function inputs and outputs.
23382 
23383 ";
23384 
23385 %feature("docstring")  casadi::FunctionInternal::wrap_as_needed(const Dict
23386 &opts) const  "
23387 
23388 [INTERNAL]  Wrap in an Function instance consisting of only one MX call.
23389 
23390 ";
23391 
23392 %feature("docstring")  casadi::FunctionInternal::sx_in(casadi_int ind) const
23393 "
23394 
23395 [INTERNAL]  Get function input(s) and output(s)
23396 
23397 ";
23398 
23399 %feature("docstring")  casadi::FunctionInternal::sx_in() const  "
23400 
23401 [INTERNAL]  Get function input(s) and output(s)
23402 
23403 ";
23404 
23405 %feature("docstring")  casadi::FunctionInternal::get_partition(casadi_int
23406 iind, casadi_int oind, Sparsity &D1, Sparsity &D2, bool compact, bool
23407 symmetric, bool allow_forward, bool allow_reverse) const  "
23408 
23409 [INTERNAL]  Get the unidirectional or bidirectional partition.
23410 
23411 ";
23412 
23413 %feature("docstring")  casadi::FunctionInternal::sp_weight() const  "
23414 
23415 [INTERNAL]  Weighting factor for chosing forward/reverse mode, sparsity
23416 propagation.
23417 
23418 ";
23419 
23420 %feature("docstring")
23421 casadi::FunctionInternal::codegen_init_mem(CodeGenerator &g) const  "
23422 
23423 [INTERNAL]  Codegen decref for init_mem.
23424 
23425 ";
23426 
23427 %feature("docstring")
23428 casadi::FunctionInternal::instruction_output(casadi_int k) const  "
23429 
23430 [INTERNAL]  Get the (integer) output argument of an atomic operation.
23431 
23432 ";
23433 
23434 %feature("docstring")  casadi::FunctionInternal::disp(std::ostream &stream,
23435 bool more) const  "
23436 
23437 [INTERNAL]  Display object.
23438 
23439 ";
23440 
23441 %feature("docstring")  casadi::FunctionInternal::numel_out(casadi_int ind)
23442 const  "
23443 
23444 [INTERNAL]  Number of input/output elements.
23445 
23446 ";
23447 
23448 %feature("docstring")  casadi::FunctionInternal::numel_out() const  "
23449 
23450 [INTERNAL]  Number of input/output elements.
23451 
23452 ";
23453 
23454 %feature("docstring")  casadi::FunctionInternal::nnz_out() const  "
23455 
23456 [INTERNAL]  Number of input/output nonzeros.
23457 
23458 ";
23459 
23460 %feature("docstring")  casadi::FunctionInternal::nnz_out(casadi_int ind)
23461 const  "
23462 
23463 [INTERNAL]  Number of input/output nonzeros.
23464 
23465 ";
23466 
23467 %feature("docstring")  casadi::FunctionInternal::instructions_sx() const  "
23468 
23469 [INTERNAL]  get SX expression associated with instructions
23470 
23471 ";
23472 
23473 %feature("docstring")  casadi::FunctionInternal::matching_arg(const
23474 std::vector< M > &arg, casadi_int &npar) const  "
23475 
23476 [INTERNAL]  Check if input arguments that needs to be replaced.
23477 
23478 Raises errors
23479 
23480 Parameters:
23481 -----------
23482 
23483 npar[in]:  normal usage: 1, disallow pararallel calls: -1
23484 
23485 npar:  max number of horizontal repetitions across all arguments (or -1)
23486 
23487 ";
23488 
23489 %feature("docstring")
23490 casadi::FunctionInternal::print_dimensions(std::ostream &stream) const  "
23491 
23492 [INTERNAL]  Print dimensions of inputs and outputs.
23493 
23494 ";
23495 
23496 %feature("docstring")  casadi::FunctionInternal::nnz_in() const  "
23497 
23498 [INTERNAL]  Number of input/output nonzeros.
23499 
23500 ";
23501 
23502 %feature("docstring")  casadi::FunctionInternal::nnz_in(casadi_int ind)
23503 const  "
23504 
23505 [INTERNAL]  Number of input/output nonzeros.
23506 
23507 ";
23508 
23509 %feature("docstring")  casadi::ProtoFunction::serialize_base_function()
23510 const  "
23511 
23512 [INTERNAL]  String used to identify the immediate FunctionInternal subclass.
23513 
23514 ";
23515 
23516 %feature("docstring")  casadi::FiniteDiff::get_n_in()  "
23517 
23518 [INTERNAL]  Number of function inputs and outputs.
23519 
23520 ";
23521 
23522 %feature("docstring")  casadi::FunctionInternal::numel_in() const  "
23523 
23524 [INTERNAL]  Number of input/output elements.
23525 
23526 ";
23527 
23528 %feature("docstring")  casadi::FunctionInternal::numel_in(casadi_int ind)
23529 const  "
23530 
23531 [INTERNAL]  Number of input/output elements.
23532 
23533 ";
23534 
23535 %feature("docstring")  casadi::FunctionInternal::self() const  "
23536 
23537 [INTERNAL]  Get a public class instance.
23538 
23539 ";
23540 
23541 %feature("docstring")
23542 casadi::FunctionInternal::codegen_free_mem(CodeGenerator &g) const  "
23543 
23544 [INTERNAL]  Codegen for free_mem.
23545 
23546 ";
23547 
23548 %feature("docstring")  casadi::FiniteDiff::get_name_out(casadi_int i)  "
23549 
23550 [INTERNAL]  Names of function input and outputs.
23551 
23552 ";
23553 
23554 %feature("docstring")  casadi::ProtoFunction::print(const char *fmt,...)
23555 const  "
23556 
23557 [INTERNAL]  C-style formatted printing during evaluation.
23558 
23559 ";
23560 
23561 %feature("docstring")  casadi::FunctionInternal::wrap() const  "
23562 
23563 [INTERNAL]  Wrap in an Function instance consisting of only one MX call.
23564 
23565 ";
23566 
23567 %feature("docstring")  casadi::FunctionInternal::codegen_name(const
23568 CodeGenerator &g, bool ns=true) const  "
23569 
23570 [INTERNAL]  Get name in codegen.
23571 
23572 ";
23573 
23574 %feature("docstring")  casadi::FunctionInternal::slice(const std::string
23575 &name, const std::vector< casadi_int > &order_in, const std::vector<
23576 casadi_int > &order_out, const Dict &opts) const  "
23577 
23578 [INTERNAL]  returns a new function with a selection of inputs/outputs of the
23579 original
23580 
23581 ";
23582 
23583 %feature("docstring")  casadi::FunctionInternal::getJacSparsity(casadi_int
23584 iind, casadi_int oind, bool symmetric) const  "
23585 
23586 [INTERNAL]  Generate the sparsity of a Jacobian block.
23587 
23588 ";
23589 
23590 %feature("docstring")  casadi::FunctionInternal::mx_out(casadi_int ind)
23591 const  "
23592 
23593 [INTERNAL]  Get function input(s) and output(s)
23594 
23595 ";
23596 
23597 %feature("docstring")  casadi::FunctionInternal::mx_out() const  "
23598 
23599 [INTERNAL]  Get function input(s) and output(s)
23600 
23601 ";
23602 
23603 %feature("docstring")  casadi::FunctionInternal::check_arg(const
23604 std::vector< M > &arg, casadi_int &npar) const  "
23605 
23606 [INTERNAL]  Check if input arguments have correct length and dimensions.
23607 
23608 Raises errors.
23609 
23610 Parameters:
23611 -----------
23612 
23613 npar[in]:  normal usage: 1, disallow pararallel calls: -1
23614 
23615 npar:  max number of horizontal repetitions across all arguments (or -1)
23616 
23617 ";
23618 
23619 %feature("docstring")  casadi::FiniteDiff::get_n_out()  "
23620 
23621 [INTERNAL]  Number of function inputs and outputs.
23622 
23623 ";
23624 
23625 %feature("docstring")  casadi::FunctionInternal::index_out(const std::string
23626 &name) const  "
23627 
23628 [INTERNAL]  Get output scheme index by name.
23629 
23630 ";
23631 
23632 %feature("docstring")  casadi::FunctionInternal::size1_in(casadi_int ind)
23633 const  "
23634 
23635 [INTERNAL]  Input/output dimensions.
23636 
23637 ";
23638 
23639 %feature("docstring")  casadi::FunctionInternal::symbolic_output(const
23640 std::vector< MX > &arg) const  "
23641 
23642 [INTERNAL]  Get a vector of symbolic variables corresponding to the outputs.
23643 
23644 ";
23645 
23646 %feature("docstring")  casadi::FunctionInternal::signature(const std::string
23647 &fname) const  "
23648 
23649 [INTERNAL]  Code generate the function.
23650 
23651 ";
23652 
23653 %feature("docstring")  casadi::FunctionInternal::generate_dependencies(const
23654 std::string &fname, const Dict &opts) const  "
23655 
23656 [INTERNAL]  Export / Generate C code for the dependency function.
23657 
23658 ";
23659 
23660 %feature("docstring")  casadi::FiniteDiff::uses_output() const  "
23661 
23662 [INTERNAL]  Is the scheme using the (nondifferentiated) output?
23663 
23664 ";
23665 
23666 %feature("docstring")
23667 casadi::FunctionInternal::serialize_body(SerializingStream &s) const  "
23668 
23669 [INTERNAL]  Serialize an object without type information.
23670 
23671 ";
23672 
23673 %feature("docstring")  casadi::FiniteDiff::get_options() const  "
23674 
23675 [INTERNAL]  Options.
23676 
23677 ";
23678 
23679 %feature("docstring")  casadi::FunctionInternal::sparsity_in(casadi_int ind)
23680 const  "
23681 
23682 [INTERNAL]  Input/output sparsity.
23683 
23684 ";
23685 
23686 %feature("docstring")  casadi::FunctionInternal::dm_in(casadi_int ind) const
23687 "
23688 
23689 [INTERNAL]  Get function input(s) and output(s)
23690 
23691 ";
23692 
23693 %feature("docstring")  casadi::FunctionInternal::dm_in() const  "
23694 
23695 [INTERNAL]  Get function input(s) and output(s)
23696 
23697 ";
23698 
23699 %feature("docstring")  casadi::ProtoFunction::free_mem(void *mem) const  "
23700 
23701 [INTERNAL]  Free memory block.
23702 
23703 ";
23704 
23705 %feature("docstring")  casadi::FunctionInternal::replace_fseed(const
23706 std::vector< std::vector< M >> &fseed, casadi_int npar) const  "
23707 
23708 [INTERNAL]  Replace 0-by-0 forward seeds.
23709 
23710 ";
23711 
23712 %feature("docstring")  casadi::FunctionInternal::replace_fseed(const
23713 std::vector< std::vector< M > > &fseed, casadi_int npar) const  "
23714 
23715 [INTERNAL] ";
23716 
23717 %feature("docstring")  casadi::FunctionInternal::fwdViaJac(casadi_int nfwd)
23718 const  "
23719 
23720 [INTERNAL]  Calculate derivatives by multiplying the full Jacobian and
23721 multiplying.
23722 
23723 ";
23724 
23725 %feature("docstring")  casadi::FunctionInternal::get_free() const  "
23726 
23727 [INTERNAL]  Print free variables.
23728 
23729 ";
23730 
23731 %feature("docstring")  casadi::FunctionInternal::call_gen(const MXVector
23732 &arg, MXVector &res, casadi_int npar, bool always_inline, bool never_inline)
23733 const  "
23734 
23735 [INTERNAL]   Call a function, overloaded.
23736 
23737 ";
23738 
23739 %feature("docstring")  casadi::FunctionInternal::call_gen(const std::vector<
23740 MatrixCommon > &arg, std::vector< MatrixCommon > &res, casadi_int npar, bool
23741 always_inline, bool never_inline) const  "
23742 
23743 [INTERNAL]   Call a function, overloaded.
23744 
23745 ";
23746 
23747 %feature("docstring")
23748 casadi::FunctionInternal::codegen_alloc_mem(CodeGenerator &g) const  "
23749 
23750 [INTERNAL]  Codegen decref for alloc_mem.
23751 
23752 ";
23753 
23754 %feature("docstring")  casadi::FunctionInternal::has_sprev() const  "
23755 
23756 [INTERNAL]  Is the class able to propagate seeds through the algorithm?
23757 
23758 ";
23759 
23760 %feature("docstring")  casadi::FunctionInternal::replace_arg(const
23761 std::vector< M > &arg, casadi_int npar) const  "
23762 
23763 [INTERNAL]  Replace 0-by-0 inputs.
23764 
23765 ";
23766 
23767 %feature("docstring")  casadi::FunctionInternal::eval_mx(const MXVector
23768 &arg, MXVector &res, bool always_inline, bool never_inline) const  "
23769 
23770 [INTERNAL]  Evaluate with symbolic matrices.
23771 
23772 ";
23773 
23774 %feature("docstring")  casadi::FunctionInternal::get_jacobian(const
23775 std::string &name, const std::vector< std::string > &inames, const
23776 std::vector< std::string > &onames, const Dict &opts) const  "
23777 
23778 [INTERNAL]  Return Jacobian of all input elements with respect to all output
23779 elements.
23780 
23781 ";
23782 
23783 %feature("docstring")  casadi::FunctionInternal::dm_out(casadi_int ind)
23784 const  "
23785 
23786 [INTERNAL]  Get function input(s) and output(s)
23787 
23788 ";
23789 
23790 %feature("docstring")  casadi::FunctionInternal::dm_out() const  "
23791 
23792 [INTERNAL]  Get function input(s) and output(s)
23793 
23794 ";
23795 
23796 %feature("docstring")  casadi::FunctionInternal::map(casadi_int n, const
23797 std::string &parallelization) const  "
23798 
23799 [INTERNAL]  Generate/retrieve cached serial map.
23800 
23801 ";
23802 
23803 %feature("docstring")  casadi::FunctionInternal::alloc_iw(size_t sz_iw, bool
23804 persistent=false) "
23805 
23806 [INTERNAL]  Ensure required length of iw field.
23807 
23808 ";
23809 
23810 %feature("docstring")  casadi::FunctionInternal::get_reverse(casadi_int
23811 nadj, const std::string &name, const std::vector< std::string > &inames,
23812 const std::vector< std::string > &onames, const Dict &opts) const  "
23813 
23814 [INTERNAL]  Return function that calculates adjoint derivatives
23815 reverse(nadj) returns a cached instance if available, and calls  Function
23816 get_reverse(casadi_int nadj) if no cached version is available.
23817 
23818 ";
23819 
23820 %feature("docstring")  casadi::FunctionInternal::sparsity_jac(casadi_int
23821 iind, casadi_int oind, bool compact, bool symmetric) const  "
23822 
23823 [INTERNAL]  Get, if necessary generate, the sparsity of a Jacobian block.
23824 
23825 ";
23826 
23827 %feature("docstring")  casadi::FunctionInternal::replace_aseed(const
23828 std::vector< std::vector< M >> &aseed, casadi_int npar) const  "
23829 
23830 [INTERNAL]  Replace 0-by-0 reverse seeds.
23831 
23832 ";
23833 
23834 %feature("docstring")  casadi::FunctionInternal::replace_aseed(const
23835 std::vector< std::vector< M > > &aseed, casadi_int npar) const  "
23836 
23837 [INTERNAL] ";
23838 
23839 %feature("docstring")  casadi::ProtoFunction::checkout() const  "
23840 
23841 [INTERNAL]  Checkout a memory object.
23842 
23843 ";
23844 
23845 %feature("docstring")
23846 casadi::FunctionInternal::instruction_constant(casadi_int k) const  "
23847 
23848 [INTERNAL]  Get the floating point output argument of an atomic operation.
23849 
23850 ";
23851 
23852 %feature("docstring")  casadi::FiniteDiff::codegen_body(CodeGenerator &g)
23853 const  "
23854 
23855 [INTERNAL]  Generate code for the body of the C function.
23856 
23857 ";
23858 
23859 %feature("docstring")  casadi::FunctionInternal::project_arg(const
23860 std::vector< M > &arg, casadi_int npar) const  "
23861 
23862 [INTERNAL]   Project sparsities.
23863 
23864 ";
23865 
23866 %feature("docstring")  casadi::FunctionInternal::sz_arg() const  "
23867 
23868 [INTERNAL]  Get required length of arg field.
23869 
23870 ";
23871 
23872 %feature("docstring")  casadi::FunctionInternal::get_reltol() const  "
23873 
23874 [INTERNAL]  Get relative tolerance.
23875 
23876 ";
23877 
23878 %feature("docstring")  casadi::SharedObjectInternal::weak() "
23879 
23880 [INTERNAL]  Get a weak reference to the object.
23881 
23882 ";
23883 
23884 %feature("docstring")  casadi::FunctionInternal::project_res(const
23885 std::vector< M > &arg, casadi_int npar) const  "
23886 
23887 [INTERNAL]   Project sparsities.
23888 
23889 ";
23890 
23891 %feature("docstring")  casadi::FunctionInternal::size_in(casadi_int ind)
23892 const  "
23893 
23894 [INTERNAL]  Input/output dimensions.
23895 
23896 ";
23897 
23898 %feature("docstring")  casadi::ProtoFunction::get_stats(void *mem) const  "
23899 
23900 [INTERNAL]  Get all statistics.
23901 
23902 ";
23903 
23904 %feature("docstring")  casadi::FunctionInternal::call_forward(const
23905 std::vector< MX > &arg, const std::vector< MX > &res, const std::vector<
23906 std::vector< MX > > &fseed, std::vector< std::vector< MX > > &fsens, bool
23907 always_inline, bool never_inline) const  "
23908 
23909 [INTERNAL]  Forward mode AD, virtual functions overloaded in derived
23910 classes.
23911 
23912 ";
23913 
23914 %feature("docstring")  casadi::FunctionInternal::call_forward(const
23915 std::vector< SX > &arg, const std::vector< SX > &res, const std::vector<
23916 std::vector< SX > > &fseed, std::vector< std::vector< SX > > &fsens, bool
23917 always_inline, bool never_inline) const  "
23918 
23919 [INTERNAL]  Forward mode AD, virtual functions overloaded in derived
23920 classes.
23921 
23922 ";
23923 
23924 %feature("docstring")  casadi::ProtoFunction::print_time(const std::map<
23925 std::string, FStats > &fstats) const  "
23926 
23927 [INTERNAL]  Print timing statistics.
23928 
23929 ";
23930 
23931 %feature("docstring")  casadi::FiniteDiff::has_codegen() const  "
23932 
23933 [INTERNAL]  Is codegen supported?
23934 
23935 ";
23936 
23937 %feature("docstring")  casadi::ProtoFunction::construct(const Dict &opts) "
23938 
23939 [INTERNAL]  Construct Prepares the function for evaluation.
23940 
23941 ";
23942 
23943 %feature("docstring")  casadi::FunctionInternal::generate_in(const
23944 std::string &fname, const double **arg) const  "
23945 
23946 [INTERNAL]  Export an input file that can be passed to generate C code with
23947 a main.
23948 
23949 ";
23950 
23951 %feature("docstring")  casadi::FunctionInternal::has_derivative() const  "
23952 
23953 [INTERNAL]  Can derivatives be calculated in any way?
23954 
23955 ";
23956 
23957 %feature("docstring")  casadi::FunctionInternal::codegen(CodeGenerator &g,
23958 const std::string &fname) const  "
23959 
23960 [INTERNAL]  Generate code the function.
23961 
23962 ";
23963 
23964 %feature("docstring")  casadi::FunctionInternal::replace_res(const
23965 std::vector< M > &res, casadi_int npar) const  "
23966 
23967 [INTERNAL]  Replace 0-by-0 outputs.
23968 
23969 ";
23970 
23971 %feature("docstring")  casadi::FunctionInternal::get_function() const  "
23972 
23973 [INTERNAL] ";
23974 
23975 %feature("docstring")  casadi::FunctionInternal::get_function(const
23976 std::string &name) const  "
23977 
23978 [INTERNAL] ";
23979 
23980 %feature("docstring")  casadi::FunctionInternal::set_work(void *mem, const
23981 double **&arg, double **&res, casadi_int *&iw, double *&w) const  "
23982 
23983 [INTERNAL]  Set the (persistent) work vectors.
23984 
23985 ";
23986 
23987 %feature("docstring")  casadi::FunctionInternal::which_depends(const
23988 std::string &s_in, const std::vector< std::string > &s_out, casadi_int
23989 order, bool tr=false) const  "
23990 
23991 [INTERNAL]  Which variables enter with some order.
23992 
23993 Parameters:
23994 -----------
23995 
23996 s_in:   Input name
23997 
23998 s_out:   Output name(s)
23999 
24000 order:  Only 1 (linear) and 2 (nonlinear) allowed
24001 
24002 tr:  Flip the relationship. Return which expressions contain the variables
24003 
24004 ";
24005 
24006 %feature("docstring")  casadi::FunctionInternal::get_jac(const std::string
24007 &name, const std::vector< std::string > &inames, const std::vector<
24008 std::string > &onames, const Dict &opts) const  "
24009 
24010 [INTERNAL]  Return Jacobian of all input elements with respect to all output
24011 elements.
24012 
24013 ";
24014 
24015 %feature("docstring")  casadi::FunctionInternal::jacobian_sparsity() const
24016 "
24017 
24018 [INTERNAL]  Get Jacobian sparsity.
24019 
24020 ";
24021 
24022 %feature("docstring")
24023 casadi::FunctionInternal::codegen_decref(CodeGenerator &g) const  "
24024 
24025 [INTERNAL]  Codegen decref for dependencies.
24026 
24027 ";
24028 
24029 %feature("docstring")  casadi::ProtoFunction::clear_mem() "
24030 
24031 [INTERNAL]  Clear all memory (called from destructor)
24032 
24033 ";
24034 
24035 %feature("docstring")  casadi::FunctionInternal::has_forward(casadi_int
24036 nfwd) const  "
24037 
24038 [INTERNAL]  Return function that calculates forward derivatives
24039 forward(nfwd) returns a cached instance if available, and calls  Function
24040 get_forward(casadi_int nfwd) if no cached version is available.
24041 
24042 ";
24043 
24044 %feature("docstring")  casadi::FunctionInternal::sz_work(size_t &sz_arg,
24045 size_t &sz_res, size_t &sz_iw, size_t &sz_w) const  "
24046 
24047 [INTERNAL]  Get number of temporary variables needed.
24048 
24049 ";
24050 
24051 %feature("docstring")  casadi::FunctionInternal::size1_out(casadi_int ind)
24052 const  "
24053 
24054 [INTERNAL]  Input/output dimensions.
24055 
24056 ";
24057 
24058 %feature("docstring")  casadi::FunctionInternal::codegen_meta(CodeGenerator
24059 &g) const  "
24060 
24061 [INTERNAL]  Generate meta-information allowing a user to evaluate a
24062 generated function.
24063 
24064 ";
24065 
24066 %feature("docstring")  casadi::FunctionInternal::mapsum_mx(const
24067 std::vector< MX > &arg, const std::string &parallelization) "
24068 
24069 [INTERNAL]  Parallel evaluation.
24070 
24071 ";
24072 
24073 %feature("docstring")
24074 casadi::FunctionInternal::codegen_sparsities(CodeGenerator &g) const  "
24075 
24076 [INTERNAL]  Codegen sparsities.
24077 
24078 ";
24079 
24080 %feature("docstring")  casadi::FunctionInternal::export_code(const
24081 std::string &lang, std::ostream &stream, const Dict &options) const  "
24082 
24083 [INTERNAL]  Export function in a specific language.
24084 
24085 ";
24086 
24087 %feature("docstring")  casadi::FunctionInternal::has_spfwd() const  "
24088 
24089 [INTERNAL]  Is the class able to propagate seeds through the algorithm?
24090 
24091 ";
24092 
24093 %feature("docstring")  casadi::SharedObjectInternal::getCount() const  "
24094 
24095 [INTERNAL]  Get the reference count.
24096 
24097 ";
24098 
24099 %feature("docstring")
24100 casadi::FunctionInternal::getJacSparsityHierarchical(casadi_int iind,
24101 casadi_int oind) const  "
24102 
24103 [INTERNAL]  A flavor of getJacSparsity that does hierarchical block
24104 structure recognition.
24105 
24106 ";
24107 
24108 %feature("docstring")  casadi::FunctionInternal::free_mx() const  "
24109 
24110 [INTERNAL]  Get free variables ( MX)
24111 
24112 ";
24113 
24114 %feature("docstring")  casadi::FunctionInternal::nz_out(const std::vector<
24115 DM > &res) const  "
24116 
24117 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
24118 
24119 ";
24120 
24121 %feature("docstring")  casadi::FunctionInternal::nz_out(const std::vector<
24122 double > &res) const  "
24123 
24124 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
24125 
24126 ";
24127 
24128 %feature("docstring")  casadi::FunctionInternal::has_jac() const  "
24129 
24130 [INTERNAL]  Return Jacobian of all input elements with respect to all output
24131 elements.
24132 
24133 ";
24134 
24135 %feature("docstring")  casadi::FunctionInternal::alloc_res(size_t sz_res,
24136 bool persistent=false) "
24137 
24138 [INTERNAL]  Ensure required length of res field.
24139 
24140 ";
24141 
24142 %feature("docstring")  casadi::FunctionInternal::sz_res() const  "
24143 
24144 [INTERNAL]  Get required length of res field.
24145 
24146 ";
24147 
24148 %feature("docstring")
24149 casadi::FunctionInternal::jacobian_sparsity_filter(const Sparsity &sp) const
24150 "
24151 
24152 [INTERNAL]  Filter out nonzeros in the full sparsity jacobian according to
24153 is_diff_in/out.
24154 
24155 ";
24156 
24157 %feature("docstring")  casadi::FunctionInternal::generate_options(bool
24158 is_temp=false) const  "
24159 
24160 [INTERNAL]  Reconstruct options dict.
24161 
24162 ";
24163 
24164 %feature("docstring")  casadi::FunctionInternal::disp_more(std::ostream
24165 &stream) const  "
24166 
24167 [INTERNAL]  Print more.
24168 
24169 ";
24170 
24171 %feature("docstring")  casadi::FunctionInternal::jacobian() const  "
24172 
24173 [INTERNAL]  Return Jacobian of all input elements with respect to all output
24174 elements.
24175 
24176 ";
24177 
24178 %feature("docstring")  casadi::ProtoFunction::memory(int ind) const  "
24179 
24180 [INTERNAL]  Memory objects.
24181 
24182 ";
24183 
24184 %feature("docstring") casadi::FiniteDiff::~FiniteDiff "
24185 
24186 [INTERNAL]  Destructor.
24187 
24188 ";
24189 
24190 %feature("docstring")  casadi::FunctionInternal::symbolicAdjSeed(casadi_int
24191 nadj, const std::vector< MatType > &v) const  "
24192 
24193 [INTERNAL]  Symbolic expressions for the adjoint seeds.
24194 
24195 ";
24196 
24197 %feature("docstring")  casadi::FunctionInternal::oracle() const  "
24198 
24199 [INTERNAL]  Get oracle.
24200 
24201 ";
24202 
24203 %feature("docstring")  casadi::FiniteDiff::get_sparsity_out(casadi_int i)  "
24204 
24205 [INTERNAL]  Sparsities of function inputs and outputs.
24206 
24207 ";
24208 
24209 %feature("docstring")  casadi::FunctionInternal::instruction_id(casadi_int
24210 k) const  "
24211 
24212 [INTERNAL]  Get an atomic operation operator index.
24213 
24214 ";
24215 
24216 %feature("docstring")
24217 casadi::FunctionInternal::codegen_incref(CodeGenerator &g) const  "
24218 
24219 [INTERNAL]  Codegen incref for dependencies.
24220 
24221 ";
24222 
24223 %feature("docstring")  casadi::FunctionInternal::codegen_mem_type() const  "
24224 
24225 [INTERNAL]  Thread-local memory object type.
24226 
24227 ";
24228 
24229 %feature("docstring")  casadi::FunctionInternal::fwd_seed(casadi_int nfwd)
24230 const  "
24231 
24232 [INTERNAL]  Symbolic expressions for the forward seeds.
24233 
24234 ";
24235 
24236 %feature("docstring")  casadi::FunctionInternal::has_reverse(casadi_int
24237 nadj) const  "
24238 
24239 [INTERNAL]  Return function that calculates adjoint derivatives
24240 reverse(nadj) returns a cached instance if available, and calls  Function
24241 get_reverse(casadi_int nadj) if no cached version is available.
24242 
24243 ";
24244 
24245 %feature("docstring")  casadi::FunctionInternal::set_temp(void *mem, const
24246 double **arg, double **res, casadi_int *iw, double *w) const  "
24247 
24248 [INTERNAL]  Set the (temporary) work vectors.
24249 
24250 ";
24251 
24252 %feature("docstring")  casadi::FunctionInternal::check_res(const
24253 std::vector< M > &res, casadi_int &npar) const  "
24254 
24255 [INTERNAL]  Check if output arguments have correct length and dimensions.
24256 
24257 Raises errors.
24258 
24259 Parameters:
24260 -----------
24261 
24262 npar[in]:  normal usage: 1, disallow pararallel calls: -1
24263 
24264 npar:  max number of horizontal repetitions across all arguments (or -1)
24265 
24266 ";
24267 
24268 %feature("docstring")  casadi::FunctionInternal::convert_res(const
24269 std::vector< M > &res) const  "
24270 
24271 [INTERNAL]  Convert from/to input/output lists/map.
24272 
24273 ";
24274 
24275 %feature("docstring")  casadi::FunctionInternal::convert_res(const std::map<
24276 std::string, M > &res) const  "
24277 
24278 [INTERNAL]  Convert from/to input/output lists/map.
24279 
24280 ";
24281 
24282 %feature("docstring")  casadi::FiniteDiff::get_name_in(casadi_int i)  "
24283 
24284 [INTERNAL]  Names of function input and outputs.
24285 
24286 ";
24287 
24288 %feature("docstring")  casadi::FunctionInternal::ad_weight() const  "
24289 
24290 [INTERNAL]  Weighting factor for chosing forward/reverse mode.
24291 
24292 ";
24293 
24294 %feature("docstring")  casadi::FunctionInternal::reverse(casadi_int nadj)
24295 const  "
24296 
24297 [INTERNAL]  Return function that calculates adjoint derivatives
24298 reverse(nadj) returns a cached instance if available, and calls  Function
24299 get_reverse(casadi_int nadj) if no cached version is available.
24300 
24301 ";
24302 
24303 %feature("docstring")  casadi::FunctionInternal::size_out(casadi_int ind)
24304 const  "
24305 
24306 [INTERNAL]  Input/output dimensions.
24307 
24308 ";
24309 
24310 %feature("docstring")  casadi::FunctionInternal::eval_sx(const SXElem **arg,
24311 SXElem **res, casadi_int *iw, SXElem *w, void *mem) const  "
24312 
24313 [INTERNAL]  Evaluate with symbolic scalars.
24314 
24315 ";
24316 
24317 %feature("docstring")  casadi::FunctionInternal::get_forward(casadi_int
24318 nfwd, const std::string &name, const std::vector< std::string > &inames,
24319 const std::vector< std::string > &onames, const Dict &opts) const  "
24320 
24321 [INTERNAL]  Return function that calculates forward derivatives
24322 forward(nfwd) returns a cached instance if available, and calls  Function
24323 get_forward(casadi_int nfwd) if no cached version is available.
24324 
24325 ";
24326 
24327 %feature("docstring")  casadi::FunctionInternal::jac() const  "
24328 
24329 [INTERNAL]  Return Jacobian of all input elements with respect to all output
24330 elements.
24331 
24332 ";
24333 
24334 %feature("docstring")  casadi::FunctionInternal::info() const  "
24335 
24336 [INTERNAL]  Obtain information about function
24337 
24338 ";
24339 
24340 %feature("docstring")  casadi::FunctionInternal::check_mat(const Sparsity
24341 &arg, const Sparsity &inp, casadi_int &npar) "
24342 
24343 [INTERNAL]  Helper function
24344 
24345 Parameters:
24346 -----------
24347 
24348 npar[in]:  normal usage: 1, disallow pararallel calls: -1
24349 
24350 npar[out]:  required number of parallel calls (or -1)
24351 
24352 ";
24353 
24354 
24355 // File: classcasadi_1_1FixedStepIntegrator.xml
24356 %feature("docstring")  casadi::SharedObjectInternal::getCount() const  "
24357 
24358 [INTERNAL]  Get the reference count.
24359 
24360 ";
24361 
24362 %feature("docstring")  casadi::FunctionInternal::alloc_iw(size_t sz_iw, bool
24363 persistent=false) "
24364 
24365 [INTERNAL]  Ensure required length of iw field.
24366 
24367 ";
24368 
24369 %feature("docstring")  casadi::FunctionInternal::has_eval_dm() const  "
24370 
24371 [INTERNAL]  Evaluate with DM matrices.
24372 
24373 ";
24374 
24375 %feature("docstring")  casadi::SharedObjectInternal::class_name() const  "
24376 
24377 [INTERNAL]  Readable name of the internal class.
24378 
24379 ";
24380 
24381 %feature("docstring")  casadi::OracleFunction::calc_function(OracleMemory
24382 *m, const std::string &fcn, const double *const *arg=nullptr) const  "
24383 
24384 [INTERNAL] ";
24385 
24386 %feature("docstring")  casadi::OracleFunction::jit_dependencies(const
24387 std::string &fname)  "
24388 
24389 [INTERNAL]  JIT for dependencies.
24390 
24391 ";
24392 
24393 %feature("docstring")  casadi::Integrator::aug_fwd(casadi_int nfwd) const  "
24394 
24395 [INTERNAL]  Generate a augmented DAE system with nfwd forward sensitivities.
24396 
24397 ";
24398 
24399 %feature("docstring")  casadi::FunctionInternal::codegen(CodeGenerator &g,
24400 const std::string &fname) const  "
24401 
24402 [INTERNAL]  Generate code the function.
24403 
24404 ";
24405 
24406 %feature("docstring")  casadi::Integrator::z() const  "
24407 
24408 [INTERNAL] ";
24409 
24410 %feature("docstring")  casadi::Integrator::x() const  "
24411 
24412 [INTERNAL] ";
24413 
24414 %feature("docstring")  casadi::FunctionInternal::all_scalar() const  "
24415 
24416 [INTERNAL]  Are all inputs and outputs scalar.
24417 
24418 ";
24419 
24420 %feature("docstring")  casadi::Integrator::sp_reverse(bvec_t **arg, bvec_t
24421 **res, casadi_int *iw, bvec_t *w, void *mem) const  "
24422 
24423 [INTERNAL]  Propagate sparsity backwards.
24424 
24425 ";
24426 
24427 %feature("docstring")  casadi::FunctionInternal::set_work(void *mem, const
24428 double **&arg, double **&res, casadi_int *&iw, double *&w) const  "
24429 
24430 [INTERNAL]  Set the (persistent) work vectors.
24431 
24432 ";
24433 
24434 %feature("docstring")  casadi::Integrator::p() const  "
24435 
24436 [INTERNAL] ";
24437 
24438 %feature("docstring")  casadi::Integrator::q() const  "
24439 
24440 [INTERNAL] ";
24441 
24442 %feature("docstring")  casadi::FunctionInternal::has_jacobian_sparsity()
24443 const  "
24444 
24445 [INTERNAL]  Get Jacobian sparsity.
24446 
24447 ";
24448 
24449 %feature("docstring")  casadi::FixedStepIntegrator::init_mem(void *mem)
24450 const  "
24451 
24452 [INTERNAL]  Initalize memory block.
24453 
24454 ";
24455 
24456 %feature("docstring")  casadi::Integrator::t() const  "
24457 
24458 [INTERNAL] ";
24459 
24460 %feature("docstring")  casadi::FunctionInternal::jacobian_sparsity() const
24461 "
24462 
24463 [INTERNAL]  Get Jacobian sparsity.
24464 
24465 ";
24466 
24467 %feature("docstring")  casadi::FunctionInternal::get_max_in(casadi_int ind)
24468 const  "
24469 
24470 [INTERNAL]  Get largest input value.
24471 
24472 ";
24473 
24474 %feature("docstring")
24475 casadi::FunctionInternal::instruction_constant(casadi_int k) const  "
24476 
24477 [INTERNAL]  Get the floating point output argument of an atomic operation.
24478 
24479 ";
24480 
24481 %feature("docstring")  casadi::Integrator::get_name_in(casadi_int i)  "
24482 
24483 [INTERNAL]  Names of function input and outputs.
24484 
24485 ";
24486 
24487 %feature("docstring")  casadi::FunctionInternal::matching_arg(const
24488 std::vector< M > &arg, casadi_int &npar) const  "
24489 
24490 [INTERNAL]  Check if input arguments that needs to be replaced.
24491 
24492 Raises errors
24493 
24494 Parameters:
24495 -----------
24496 
24497 npar[in]:  normal usage: 1, disallow pararallel calls: -1
24498 
24499 npar:  max number of horizontal repetitions across all arguments (or -1)
24500 
24501 ";
24502 
24503 %feature("docstring")
24504 casadi::FunctionInternal::codegen_decref(CodeGenerator &g) const  "
24505 
24506 [INTERNAL]  Codegen decref for dependencies.
24507 
24508 ";
24509 
24510 %feature("docstring")  casadi::FunctionInternal::sparsity_out(casadi_int
24511 ind) const  "
24512 
24513 [INTERNAL]  Input/output sparsity.
24514 
24515 ";
24516 
24517 %feature("docstring")  casadi::FunctionInternal::sz_w() const  "
24518 
24519 [INTERNAL]  Get required length of w field.
24520 
24521 ";
24522 
24523 %feature("docstring")  casadi::FunctionInternal::codegen_name(const
24524 CodeGenerator &g, bool ns=true) const  "
24525 
24526 [INTERNAL]  Get name in codegen.
24527 
24528 ";
24529 
24530 %feature("docstring")  casadi::FunctionInternal::generate_options(bool
24531 is_temp=false) const  "
24532 
24533 [INTERNAL]  Reconstruct options dict.
24534 
24535 ";
24536 
24537 %feature("docstring")  casadi::FunctionInternal::eval_gen(const double
24538 **arg, double **res, casadi_int *iw, double *w, void *mem) const  "
24539 
24540 [INTERNAL]  Evaluate numerically.
24541 
24542 ";
24543 
24544 %feature("docstring")  casadi::FunctionInternal::eval_gen(const SXElem
24545 **arg, SXElem **res, casadi_int *iw, SXElem *w, void *mem) const  "
24546 
24547 [INTERNAL]  Evaluate a function, overloaded.
24548 
24549 ";
24550 
24551 %feature("docstring")  casadi::FunctionInternal::eval_gen(const bvec_t
24552 **arg, bvec_t **res, casadi_int *iw, bvec_t *w, void *mem) const  "
24553 
24554 [INTERNAL]  Evaluate a function, overloaded.
24555 
24556 ";
24557 
24558 %feature("docstring")  casadi::FunctionInternal::tocache(const Function &f,
24559 const std::string &suffix="") const  "
24560 
24561 [INTERNAL]  Save function to cache.
24562 
24563 ";
24564 
24565 %feature("docstring")  casadi::FunctionInternal::codegen_mem_type() const  "
24566 
24567 [INTERNAL]  Thread-local memory object type.
24568 
24569 ";
24570 
24571 %feature("docstring")  casadi::OracleFunction::expand() "
24572 
24573 [INTERNAL] ";
24574 
24575 %feature("docstring")  casadi::FunctionInternal::n_instructions() const  "
24576 
24577 [INTERNAL]  Get the number of atomic operations.
24578 
24579 ";
24580 
24581 %feature("docstring")  casadi::FunctionInternal::project_res(const
24582 std::vector< M > &arg, casadi_int npar) const  "
24583 
24584 [INTERNAL]   Project sparsities.
24585 
24586 ";
24587 
24588 %feature("docstring")
24589 casadi::FunctionInternal::codegen_init_mem(CodeGenerator &g) const  "
24590 
24591 [INTERNAL]  Codegen decref for init_mem.
24592 
24593 ";
24594 
24595 %feature("docstring")  casadi::FunctionInternal::getJacSparsity(casadi_int
24596 iind, casadi_int oind, bool symmetric) const  "
24597 
24598 [INTERNAL]  Generate the sparsity of a Jacobian block.
24599 
24600 ";
24601 
24602 %feature("docstring")  casadi::FunctionInternal::uses_output() const  "
24603 
24604 [INTERNAL]  Do the derivative functions need nondifferentiated outputs?
24605 
24606 ";
24607 
24608 %feature("docstring")  casadi::FunctionInternal::get_free() const  "
24609 
24610 [INTERNAL]  Print free variables.
24611 
24612 ";
24613 
24614 %feature("docstring")  casadi::FunctionInternal::disp_more(std::ostream
24615 &stream) const  "
24616 
24617 [INTERNAL]  Print more.
24618 
24619 ";
24620 
24621 %feature("docstring")  casadi::Integrator::get_reverse(casadi_int nadj,
24622 const std::string &name, const std::vector< std::string > &inames, const
24623 std::vector< std::string > &onames, const Dict &opts) const  "
24624 
24625 [INTERNAL]  Generate a function that calculates nadj adjoint derivatives.
24626 
24627 ";
24628 
24629 %feature("docstring")  casadi::Integrator::serialize_base_function() const
24630 "
24631 
24632 [INTERNAL]  String used to identify the immediate FunctionInternal subclass.
24633 
24634 ";
24635 
24636 %feature("docstring")  casadi::FunctionInternal::export_code(const
24637 std::string &lang, std::ostream &stream, const Dict &options) const  "
24638 
24639 [INTERNAL]  Export function in a specific language.
24640 
24641 ";
24642 
24643 %feature("docstring")  casadi::FixedStepIntegrator::get_options() const  "
24644 
24645 [INTERNAL]  Options.
24646 
24647 ";
24648 
24649 %feature("docstring")  casadi::FunctionInternal::matching_res(const
24650 std::vector< M > &arg, casadi_int &npar) const  "
24651 
24652 [INTERNAL]  Check if output arguments that needs to be replaced.
24653 
24654 Raises errors
24655 
24656 Parameters:
24657 -----------
24658 
24659 npar[in]:  normal usage: 1, disallow pararallel calls: -1
24660 
24661 npar:  max number of horizontal repetitions across all arguments (or -1)
24662 
24663 ";
24664 
24665 %feature("docstring")  casadi::FunctionInternal::wrap_as_needed(const Dict
24666 &opts) const  "
24667 
24668 [INTERNAL]  Wrap in an Function instance consisting of only one MX call.
24669 
24670 ";
24671 
24672 %feature("docstring")  casadi::Integrator::get_sparsity_out(casadi_int i)  "
24673 
24674 [INTERNAL]  Sparsities of function inputs and outputs.
24675 
24676 ";
24677 
24678 %feature("docstring")  casadi::FunctionInternal::has_jac() const  "
24679 
24680 [INTERNAL]  Return Jacobian of all input elements with respect to all output
24681 elements.
24682 
24683 ";
24684 
24685 %feature("docstring")  casadi::FunctionInternal::size2_out(casadi_int ind)
24686 const  "
24687 
24688 [INTERNAL]  Input/output dimensions.
24689 
24690 ";
24691 
24692 %feature("docstring")  casadi::Integrator::setStopTime(IntegratorMemory
24693 *mem, double tf) const  "
24694 
24695 [INTERNAL]  Set stop time for the integration.
24696 
24697 ";
24698 
24699 %feature("docstring")  casadi::FunctionInternal::sparsity_in(casadi_int ind)
24700 const  "
24701 
24702 [INTERNAL]  Input/output sparsity.
24703 
24704 ";
24705 
24706 %feature("docstring")  casadi::FunctionInternal::sz_iw() const  "
24707 
24708 [INTERNAL]  Get required length of iw field.
24709 
24710 ";
24711 
24712 %feature("docstring")  casadi::FunctionInternal::fwdViaJac(casadi_int nfwd)
24713 const  "
24714 
24715 [INTERNAL]  Calculate derivatives by multiplying the full Jacobian and
24716 multiplying.
24717 
24718 ";
24719 
24720 %feature("docstring")  casadi::FunctionInternal::nz_out(const std::vector<
24721 DM > &res) const  "
24722 
24723 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
24724 
24725 ";
24726 
24727 %feature("docstring")  casadi::FunctionInternal::nz_out(const std::vector<
24728 double > &res) const  "
24729 
24730 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
24731 
24732 ";
24733 
24734 %feature("docstring")  casadi::FunctionInternal::check_arg(const
24735 std::vector< M > &arg, casadi_int &npar) const  "
24736 
24737 [INTERNAL]  Check if input arguments have correct length and dimensions.
24738 
24739 Raises errors.
24740 
24741 Parameters:
24742 -----------
24743 
24744 npar[in]:  normal usage: 1, disallow pararallel calls: -1
24745 
24746 npar:  max number of horizontal repetitions across all arguments (or -1)
24747 
24748 ";
24749 
24750 %feature("docstring")  casadi::FunctionInternal::map(casadi_int n, const
24751 std::string &parallelization) const  "
24752 
24753 [INTERNAL]  Generate/retrieve cached serial map.
24754 
24755 ";
24756 
24757 %feature("docstring")  casadi::FunctionInternal::sx_out(casadi_int ind)
24758 const  "
24759 
24760 [INTERNAL]  Get function input(s) and output(s)
24761 
24762 ";
24763 
24764 %feature("docstring")  casadi::FunctionInternal::sx_out() const  "
24765 
24766 [INTERNAL]  Get function input(s) and output(s)
24767 
24768 ";
24769 
24770 %feature("docstring")  casadi::FunctionInternal::eval_dm(const std::vector<
24771 DM > &arg) const  "
24772 
24773 [INTERNAL]  Evaluate with DM matrices.
24774 
24775 ";
24776 
24777 %feature("docstring")  casadi::FixedStepIntegrator::resetB(IntegratorMemory
24778 *mem, double t, const double *rx, const double *rz, const double *rp) const
24779 "
24780 
24781 [INTERNAL]  Reset the backward problem and take time to tf.
24782 
24783 ";
24784 
24785 %feature("docstring")  casadi::FunctionInternal::check_mat(const Sparsity
24786 &arg, const Sparsity &inp, casadi_int &npar) "
24787 
24788 [INTERNAL]  Helper function
24789 
24790 Parameters:
24791 -----------
24792 
24793 npar[in]:  normal usage: 1, disallow pararallel calls: -1
24794 
24795 npar[out]:  required number of parallel calls (or -1)
24796 
24797 ";
24798 
24799 %feature("docstring")  casadi::FixedStepIntegrator::create_advanced(const
24800 Dict &opts)  "
24801 
24802 [INTERNAL]  Helper for a more powerful 'integrator' factory
24803 
24804 ";
24805 
24806 %feature("docstring")  casadi::FunctionInternal::slice(const std::string
24807 &name, const std::vector< casadi_int > &order_in, const std::vector<
24808 casadi_int > &order_out, const Dict &opts) const  "
24809 
24810 [INTERNAL]  returns a new function with a selection of inputs/outputs of the
24811 original
24812 
24813 ";
24814 
24815 %feature("docstring")  casadi::FunctionInternal::convert_res(const
24816 std::vector< M > &res) const  "
24817 
24818 [INTERNAL]  Convert from/to input/output lists/map.
24819 
24820 ";
24821 
24822 %feature("docstring")  casadi::FunctionInternal::convert_res(const std::map<
24823 std::string, M > &res) const  "
24824 
24825 [INTERNAL]  Convert from/to input/output lists/map.
24826 
24827 ";
24828 
24829 %feature("docstring")  casadi::FunctionInternal::instruction_MX(casadi_int
24830 k) const  "
24831 
24832 [INTERNAL]  get MX expression associated with instruction
24833 
24834 ";
24835 
24836 %feature("docstring")  casadi::FunctionInternal::get_abstol() const  "
24837 
24838 [INTERNAL]  Get absolute tolerance.
24839 
24840 ";
24841 
24842 %feature("docstring")  casadi::FunctionInternal::replace_aseed(const
24843 std::vector< std::vector< M >> &aseed, casadi_int npar) const  "
24844 
24845 [INTERNAL]  Replace 0-by-0 reverse seeds.
24846 
24847 ";
24848 
24849 %feature("docstring")  casadi::FunctionInternal::replace_aseed(const
24850 std::vector< std::vector< M > > &aseed, casadi_int npar) const  "
24851 
24852 [INTERNAL] ";
24853 
24854 %feature("docstring")  casadi::FunctionInternal::get_default_in(casadi_int
24855 ind) const  "
24856 
24857 [INTERNAL]  Get default input value.
24858 
24859 ";
24860 
24861 %feature("docstring") casadi::FixedStepIntegrator::~FixedStepIntegrator "
24862 
24863 [INTERNAL]  Destructor.
24864 
24865 ";
24866 
24867 %feature("docstring")
24868 casadi::FunctionInternal::instruction_input(casadi_int k) const  "
24869 
24870 [INTERNAL]  Get the (integer) input arguments of an atomic operation.
24871 
24872 ";
24873 
24874 %feature("docstring")  casadi::FunctionInternal::mx_in(casadi_int ind) const
24875 "
24876 
24877 [INTERNAL]  Get function input(s) and output(s)
24878 
24879 ";
24880 
24881 %feature("docstring")  casadi::FunctionInternal::mx_in() const  "
24882 
24883 [INTERNAL]  Get function input(s) and output(s)
24884 
24885 ";
24886 
24887 %feature("docstring")  casadi::FixedStepIntegrator::advance(IntegratorMemory
24888 *mem, double t, double *x, double *z, double *q) const  "
24889 
24890 [INTERNAL]  Advance solution in time.
24891 
24892 ";
24893 
24894 %feature("docstring")  casadi::ProtoFunction::construct(const Dict &opts) "
24895 
24896 [INTERNAL]  Construct Prepares the function for evaluation.
24897 
24898 ";
24899 
24900 %feature("docstring")  casadi::FunctionInternal::ad_weight() const  "
24901 
24902 [INTERNAL]  Weighting factor for chosing forward/reverse mode.
24903 
24904 ";
24905 
24906 %feature("docstring")  casadi::FunctionInternal::reverse(casadi_int nadj)
24907 const  "
24908 
24909 [INTERNAL]  Return function that calculates adjoint derivatives
24910 reverse(nadj) returns a cached instance if available, and calls  Function
24911 get_reverse(casadi_int nadj) if no cached version is available.
24912 
24913 ";
24914 
24915 %feature("docstring")  casadi::FunctionInternal::codegen_mem(CodeGenerator
24916 &g, const std::string &index="mem") const  "
24917 
24918 [INTERNAL]  Get thread-local memory object.
24919 
24920 ";
24921 
24922 %feature("docstring")  casadi::FunctionInternal::size_out(casadi_int ind)
24923 const  "
24924 
24925 [INTERNAL]  Input/output dimensions.
24926 
24927 ";
24928 
24929 %feature("docstring")  casadi::Integrator::get_name_out(casadi_int i)  "
24930 
24931 [INTERNAL]  Names of function input and outputs.
24932 
24933 ";
24934 
24935 %feature("docstring")  casadi::FunctionInternal::convert_arg(const
24936 std::vector< M > &arg) const  "
24937 
24938 [INTERNAL]  Convert from/to input/output lists/map.
24939 
24940 ";
24941 
24942 %feature("docstring")  casadi::FunctionInternal::convert_arg(const std::map<
24943 std::string, M > &arg) const  "
24944 
24945 [INTERNAL]  Convert from/to input/output lists/map.
24946 
24947 ";
24948 
24949 %feature("docstring")  casadi::FunctionInternal::alloc_w(size_t sz_w, bool
24950 persistent=false) "
24951 
24952 [INTERNAL]  Ensure required length of w field.
24953 
24954 ";
24955 
24956 %feature("docstring")  casadi::FunctionInternal::sp_weight() const  "
24957 
24958 [INTERNAL]  Weighting factor for chosing forward/reverse mode, sparsity
24959 propagation.
24960 
24961 ";
24962 
24963 %feature("docstring")  casadi::OracleFunction::create_function(const
24964 std::string &fname, const std::vector< std::string > &s_in, const
24965 std::vector< std::string > &s_out, const Function::AuxOut
24966 &aux=Function::AuxOut()) "
24967 
24968 [INTERNAL]  Create an oracle function
24969 
24970 ";
24971 
24972 %feature("docstring")  casadi::FunctionInternal::numel_out(casadi_int ind)
24973 const  "
24974 
24975 [INTERNAL]  Number of input/output elements.
24976 
24977 ";
24978 
24979 %feature("docstring")  casadi::FunctionInternal::numel_out() const  "
24980 
24981 [INTERNAL]  Number of input/output elements.
24982 
24983 ";
24984 
24985 %feature("docstring")  casadi::OracleFunction::monitored(const std::string
24986 &name) const  "
24987 
24988 [INTERNAL] ";
24989 
24990 %feature("docstring")  casadi::FunctionInternal::has_free() const  "
24991 
24992 [INTERNAL]  Does the function have free variables.
24993 
24994 ";
24995 
24996 %feature("docstring")  casadi::FunctionInternal::eval_mx(const MXVector
24997 &arg, MXVector &res, bool always_inline, bool never_inline) const  "
24998 
24999 [INTERNAL]  Evaluate with symbolic matrices.
25000 
25001 ";
25002 
25003 %feature("docstring")
25004 casadi::FunctionInternal::print_dimensions(std::ostream &stream) const  "
25005 
25006 [INTERNAL]  Print dimensions of inputs and outputs.
25007 
25008 ";
25009 
25010 %feature("docstring")  casadi::ProtoFunction::serialize(SerializingStream
25011 &s) const  "
25012 
25013 [INTERNAL]  Serialize an object.
25014 
25015 ";
25016 
25017 %feature("docstring")  casadi::FixedStepIntegrator::retreat(IntegratorMemory
25018 *mem, double t, double *rx, double *rz, double *rq) const  "
25019 
25020 [INTERNAL]  Retreat solution in time.
25021 
25022 ";
25023 
25024 %feature("docstring")  casadi::FunctionInternal::get_jac(const std::string
25025 &name, const std::vector< std::string > &inames, const std::vector<
25026 std::string > &onames, const Dict &opts) const  "
25027 
25028 [INTERNAL]  Return Jacobian of all input elements with respect to all output
25029 elements.
25030 
25031 ";
25032 
25033 %feature("docstring")  casadi::FunctionInternal::nz_in(const std::vector< DM
25034 > &arg) const  "
25035 
25036 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
25037 
25038 ";
25039 
25040 %feature("docstring")  casadi::FunctionInternal::nz_in(const std::vector<
25041 double > &arg) const  "
25042 
25043 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
25044 
25045 ";
25046 
25047 %feature("docstring")  casadi::FunctionInternal::factory(const std::string
25048 &name, const std::vector< std::string > &s_in, const std::vector<
25049 std::string > &s_out, const Function::AuxOut &aux, const Dict &opts) const
25050 "
25051 
25052 [INTERNAL] ";
25053 
25054 %feature("docstring")  casadi::FunctionInternal::sx_in(casadi_int ind) const
25055 "
25056 
25057 [INTERNAL]  Get function input(s) and output(s)
25058 
25059 ";
25060 
25061 %feature("docstring")  casadi::FunctionInternal::sx_in() const  "
25062 
25063 [INTERNAL]  Get function input(s) and output(s)
25064 
25065 ";
25066 
25067 %feature("docstring")  casadi::FunctionInternal::alloc(const Function &f,
25068 bool persistent=false) "
25069 
25070 [INTERNAL]  Ensure work vectors long enough to evaluate function.
25071 
25072 ";
25073 
25074 %feature("docstring")  casadi::FunctionInternal::info() const  "
25075 
25076 [INTERNAL]  Obtain information about function
25077 
25078 ";
25079 
25080 %feature("docstring")  casadi::FunctionInternal::nnz_out() const  "
25081 
25082 [INTERNAL]  Number of input/output nonzeros.
25083 
25084 ";
25085 
25086 %feature("docstring")  casadi::FunctionInternal::nnz_out(casadi_int ind)
25087 const  "
25088 
25089 [INTERNAL]  Number of input/output nonzeros.
25090 
25091 ";
25092 
25093 %feature("docstring")  casadi::Integrator::serialize_type(SerializingStream
25094 &s) const  "
25095 
25096 [INTERNAL]  Serialize type information.
25097 
25098 ";
25099 
25100 %feature("docstring")  casadi::FunctionInternal::free_mx() const  "
25101 
25102 [INTERNAL]  Get free variables ( MX)
25103 
25104 ";
25105 
25106 %feature("docstring")  casadi::OracleFunction::finalize()  "
25107 
25108 [INTERNAL]  Finalize initialization.
25109 
25110 ";
25111 
25112 %feature("docstring")  casadi::FunctionInternal::eval_sx(const SXElem **arg,
25113 SXElem **res, casadi_int *iw, SXElem *w, void *mem) const  "
25114 
25115 [INTERNAL]  Evaluate with symbolic scalars.
25116 
25117 ";
25118 
25119 %feature("docstring")  casadi::FunctionInternal::generate_out(const
25120 std::string &fname, double **res) const  "
25121 
25122 [INTERNAL] ";
25123 
25124 %feature("docstring")  casadi::FunctionInternal::generate_lifted(Function
25125 &vdef_fcn, Function &vinit_fcn) const  "
25126 
25127 [INTERNAL]  Extract the functions needed for the Lifted Newton method.
25128 
25129 ";
25130 
25131 %feature("docstring")  casadi::FixedStepIntegrator::setupFG() "
25132 
25133 [INTERNAL]  Setup F and G.
25134 
25135 ";
25136 
25137 %feature("docstring")  casadi::FunctionInternal::forward(casadi_int nfwd)
25138 const  "
25139 
25140 [INTERNAL]  Return function that calculates forward derivatives
25141 forward(nfwd) returns a cached instance if available, and calls  Function
25142 get_forward(casadi_int nfwd) if no cached version is available.
25143 
25144 ";
25145 
25146 %feature("docstring")  casadi::OracleFunction::generate_dependencies(const
25147 std::string &fname, const Dict &opts) const  "
25148 
25149 [INTERNAL]  Export / Generate C code for the generated functions.
25150 
25151 ";
25152 
25153 %feature("docstring")  casadi::FunctionInternal::has_codegen() const  "
25154 
25155 [INTERNAL]  Is codegen supported?
25156 
25157 ";
25158 
25159 %feature("docstring")  casadi::FunctionInternal::incache(const std::string
25160 &fname, Function &f, const std::string &suffix="") const  "
25161 
25162 [INTERNAL]  Get function in cache.
25163 
25164 ";
25165 
25166 %feature("docstring")  casadi::Integrator::algebraic_state_init(const MX
25167 &x0, const MX &z0) const  "
25168 
25169 [INTERNAL] ";
25170 
25171 %feature("docstring")  casadi::FixedStepIntegrator::init(const Dict &opts)
25172 "
25173 
25174 [INTERNAL]  Initialize stage.
25175 
25176 ";
25177 
25178 %feature("docstring")  casadi::Integrator::sp_jac_rdae() "
25179 
25180 [INTERNAL]  Create sparsity pattern of the extended Jacobian (backward
25181 problem)
25182 
25183 ";
25184 
25185 %feature("docstring")  casadi::FunctionInternal::print_option(const
25186 std::string &name, std::ostream &stream) const  "
25187 
25188 [INTERNAL]  Print all information there is to know about a certain option.
25189 
25190 ";
25191 
25192 %feature("docstring") casadi::FixedStepIntegrator::FixedStepIntegrator(const
25193 std::string &name, const Function &dae) "
25194 
25195 [INTERNAL]  Constructor.
25196 
25197 ";
25198 
25199 %feature("docstring")
25200 casadi::FunctionInternal::jacobian_sparsity_filter(const Sparsity &sp) const
25201 "
25202 
25203 [INTERNAL]  Filter out nonzeros in the full sparsity jacobian according to
25204 is_diff_in/out.
25205 
25206 ";
25207 
25208 %feature("docstring")  casadi::OracleFunction::get_stats(void *mem) const  "
25209 
25210 [INTERNAL]  Get all statistics.
25211 
25212 ";
25213 
25214 %feature("docstring")  casadi::Integrator::get_sparsity_in(casadi_int i)  "
25215 
25216 [INTERNAL]  Sparsities of function inputs and outputs.
25217 
25218 ";
25219 
25220 %feature("docstring")  casadi::FunctionInternal::which_depends(const
25221 std::string &s_in, const std::vector< std::string > &s_out, casadi_int
25222 order, bool tr=false) const  "
25223 
25224 [INTERNAL]  Which variables enter with some order.
25225 
25226 Parameters:
25227 -----------
25228 
25229 s_in:   Input name
25230 
25231 s_out:   Output name(s)
25232 
25233 order:  Only 1 (linear) and 2 (nonlinear) allowed
25234 
25235 tr:  Flip the relationship. Return which expressions contain the variables
25236 
25237 ";
25238 
25239 %feature("docstring")  casadi::ProtoFunction::format_time(char *buffer,
25240 double time) const  "
25241 
25242 [INTERNAL]  Format time in a fixed width 8 format.
25243 
25244 ";
25245 
25246 %feature("docstring")  casadi::FunctionInternal::print_options(std::ostream
25247 &stream) const  "
25248 
25249 [INTERNAL]  Print list of options.
25250 
25251 ";
25252 
25253 %feature("docstring")  casadi::SharedObjectInternal::weak() "
25254 
25255 [INTERNAL]  Get a weak reference to the object.
25256 
25257 ";
25258 
25259 %feature("docstring")  casadi::FunctionInternal::numel_in() const  "
25260 
25261 [INTERNAL]  Number of input/output elements.
25262 
25263 ";
25264 
25265 %feature("docstring")  casadi::FunctionInternal::numel_in(casadi_int ind)
25266 const  "
25267 
25268 [INTERNAL]  Number of input/output elements.
25269 
25270 ";
25271 
25272 %feature("docstring")  casadi::FunctionInternal::free_sx() const  "
25273 
25274 [INTERNAL]  Get free variables (SX)
25275 
25276 ";
25277 
25278 %feature("docstring")  casadi::FunctionInternal::has_jacobian() const  "
25279 
25280 [INTERNAL]  Return Jacobian of all input elements with respect to all output
25281 elements.
25282 
25283 ";
25284 
25285 %feature("docstring")  casadi::FunctionInternal::replace_res(const
25286 std::vector< M > &res, casadi_int npar) const  "
25287 
25288 [INTERNAL]  Replace 0-by-0 outputs.
25289 
25290 ";
25291 
25292 %feature("docstring")  casadi::FunctionInternal::getAdaptorSolverName()
25293 const  "
25294 
25295 [INTERNAL]  Obtain solver name from Adaptor.
25296 
25297 ";
25298 
25299 %feature("docstring") casadi::FixedStepIntegrator "
25300 
25301 
25302 
25303 >List of available options
25304 
25305 +------------------+-----------------+------------------+------------------+
25306 |        Id        |      Type       |   Description    |     Used in      |
25307 +==================+=================+==================+==================+
25308 | augmented_option | OT_DICT         | Options to be    | casadi::FixedSte |
25309 | s                |                 | passed down to   | pIntegrator      |
25310 |                  |                 | the augmented    |                  |
25311 |                  |                 | integrator, if   |                  |
25312 |                  |                 | one is           |                  |
25313 |                  |                 | constructed.     |                  |
25314 +------------------+-----------------+------------------+------------------+
25315 | common_options   | OT_DICT         | Options for      | casadi::OracleFu |
25316 |                  |                 | auto-generated   | nction           |
25317 |                  |                 | functions        |                  |
25318 +------------------+-----------------+------------------+------------------+
25319 | expand           | OT_BOOL         | Replace MX with  | casadi::FixedSte |
25320 |                  |                 | SX expressions   | pIntegrator      |
25321 |                  |                 | in problem       |                  |
25322 |                  |                 | formulation      |                  |
25323 |                  |                 | [false]          |                  |
25324 +------------------+-----------------+------------------+------------------+
25325 | grid             | OT_DOUBLEVECTOR | Time grid        | casadi::FixedSte |
25326 |                  |                 |                  | pIntegrator      |
25327 +------------------+-----------------+------------------+------------------+
25328 | monitor          | OT_STRINGVECTOR | Set of user      | casadi::OracleFu |
25329 |                  |                 | problem          | nction           |
25330 |                  |                 | functions to be  |                  |
25331 |                  |                 | monitored        |                  |
25332 +------------------+-----------------+------------------+------------------+
25333 | number_of_finite | OT_INT          | Number of finite | casadi::FixedSte |
25334 | _elements        |                 | elements         | pIntegrator      |
25335 +------------------+-----------------+------------------+------------------+
25336 | output_t0        | OT_BOOL         | Output the state | casadi::FixedSte |
25337 |                  |                 | at the initial   | pIntegrator      |
25338 |                  |                 | time             |                  |
25339 +------------------+-----------------+------------------+------------------+
25340 | print_stats      | OT_BOOL         | Print out        | casadi::FixedSte |
25341 |                  |                 | statistics after | pIntegrator      |
25342 |                  |                 | integration      |                  |
25343 +------------------+-----------------+------------------+------------------+
25344 | rootfinder       | OT_STRING       | An implicit      | casadi::FixedSte |
25345 |                  |                 | function solver  | pIntegrator      |
25346 +------------------+-----------------+------------------+------------------+
25347 | rootfinder_optio | OT_DICT         | Options to be    | casadi::FixedSte |
25348 | ns               |                 | passed to the    | pIntegrator      |
25349 |                  |                 | NLP Solver       |                  |
25350 +------------------+-----------------+------------------+------------------+
25351 | show_eval_warnin | OT_BOOL         | Show warnings    | casadi::OracleFu |
25352 | gs               |                 | generated from   | nction           |
25353 |                  |                 | function         |                  |
25354 |                  |                 | evaluations      |                  |
25355 |                  |                 | [true]           |                  |
25356 +------------------+-----------------+------------------+------------------+
25357 | simplify         | OT_BOOL         | Implement as MX  | casadi::FixedSte |
25358 |                  |                 | Function (codege | pIntegrator      |
25359 |                  |                 | neratable/serial |                  |
25360 |                  |                 | izable) default: |                  |
25361 |                  |                 | false            |                  |
25362 +------------------+-----------------+------------------+------------------+
25363 | simplify_options | OT_DICT         | Any options to   | casadi::FixedSte |
25364 |                  |                 | pass to          | pIntegrator      |
25365 |                  |                 | simplified form  |                  |
25366 |                  |                 | Function         |                  |
25367 |                  |                 | constructor      |                  |
25368 +------------------+-----------------+------------------+------------------+
25369 | specific_options | OT_DICT         | Options for      | casadi::OracleFu |
25370 |                  |                 | specific auto-   | nction           |
25371 |                  |                 | generated        |                  |
25372 |                  |                 | functions,       |                  |
25373 |                  |                 | overwriting the  |                  |
25374 |                  |                 | defaults from    |                  |
25375 |                  |                 | common_options.  |                  |
25376 |                  |                 | Nested           |                  |
25377 |                  |                 | dictionary.      |                  |
25378 +------------------+-----------------+------------------+------------------+
25379 | t0               | OT_DOUBLE       | Beginning of the | casadi::FixedSte |
25380 |                  |                 | time horizon     | pIntegrator      |
25381 +------------------+-----------------+------------------+------------------+
25382 | tf               | OT_DOUBLE       | End of the time  | casadi::FixedSte |
25383 |                  |                 | horizon          | pIntegrator      |
25384 +------------------+-----------------+------------------+------------------+
25385 
25386 Diagrams
25387 --------
25388 
25389 
25390 
25391 C++ includes: integrator_impl.hpp ";
25392 
25393 %feature("docstring")  casadi::Integrator::aug_adj(casadi_int nadj) const  "
25394 
25395 [INTERNAL]  Generate a augmented DAE system with nadj adjoint sensitivities.
25396 
25397 ";
25398 
25399 %feature("docstring")
25400 casadi::FunctionInternal::codegen_free_mem(CodeGenerator &g) const  "
25401 
25402 [INTERNAL]  Codegen for free_mem.
25403 
25404 ";
25405 
25406 %feature("docstring")  casadi::FunctionInternal::instruction_id(casadi_int
25407 k) const  "
25408 
25409 [INTERNAL]  Get an atomic operation operator index.
25410 
25411 ";
25412 
25413 %feature("docstring")
25414 casadi::FunctionInternal::codegen_sparsities(CodeGenerator &g) const  "
25415 
25416 [INTERNAL]  Codegen sparsities.
25417 
25418 ";
25419 
25420 %feature("docstring")  casadi::FixedStepIntegrator::free_mem(void *mem)
25421 const  "
25422 
25423 [INTERNAL]  Free memory block.
25424 
25425 ";
25426 
25427 %feature("docstring")  casadi::Integrator::has_forward(casadi_int nfwd)
25428 const  "
25429 
25430 [INTERNAL]  Generate a function that calculates nfwd forward derivatives.
25431 
25432 ";
25433 
25434 %feature("docstring")  casadi::FunctionInternal::call_forward(const
25435 std::vector< MX > &arg, const std::vector< MX > &res, const std::vector<
25436 std::vector< MX > > &fseed, std::vector< std::vector< MX > > &fsens, bool
25437 always_inline, bool never_inline) const  "
25438 
25439 [INTERNAL]  Forward mode AD, virtual functions overloaded in derived
25440 classes.
25441 
25442 ";
25443 
25444 %feature("docstring")  casadi::FunctionInternal::call_forward(const
25445 std::vector< SX > &arg, const std::vector< SX > &res, const std::vector<
25446 std::vector< SX > > &fseed, std::vector< std::vector< SX > > &fsens, bool
25447 always_inline, bool never_inline) const  "
25448 
25449 [INTERNAL]  Forward mode AD, virtual functions overloaded in derived
25450 classes.
25451 
25452 ";
25453 
25454 %feature("docstring")  casadi::FunctionInternal::setup(void *mem, const
25455 double **arg, double **res, casadi_int *iw, double *w) const  "
25456 
25457 [INTERNAL]  Set the (persistent and temporary) work vectors.
25458 
25459 ";
25460 
25461 %feature("docstring")  casadi::Integrator::eval(const double **arg, double
25462 **res, casadi_int *iw, double *w, void *mem) const  "
25463 
25464 [INTERNAL]  evaluate
25465 
25466 ";
25467 
25468 %feature("docstring")  casadi::FunctionInternal::signature(const std::string
25469 &fname) const  "
25470 
25471 [INTERNAL]  Code generate the function.
25472 
25473 ";
25474 
25475 %feature("docstring")  casadi::FunctionInternal::mapsum_mx(const
25476 std::vector< MX > &arg, const std::string &parallelization) "
25477 
25478 [INTERNAL]  Parallel evaluation.
25479 
25480 ";
25481 
25482 %feature("docstring")  casadi::FunctionInternal::get_jacobian(const
25483 std::string &name, const std::vector< std::string > &inames, const
25484 std::vector< std::string > &onames, const Dict &opts) const  "
25485 
25486 [INTERNAL]  Return Jacobian of all input elements with respect to all output
25487 elements.
25488 
25489 ";
25490 
25491 %feature("docstring")  casadi::FunctionInternal::project_arg(const
25492 std::vector< M > &arg, casadi_int npar) const  "
25493 
25494 [INTERNAL]   Project sparsities.
25495 
25496 ";
25497 
25498 %feature("docstring")  casadi::FunctionInternal::size1_out(casadi_int ind)
25499 const  "
25500 
25501 [INTERNAL]  Input/output dimensions.
25502 
25503 ";
25504 
25505 %feature("docstring")  casadi::FunctionInternal::symbolicAdjSeed(casadi_int
25506 nadj, const std::vector< MatType > &v) const  "
25507 
25508 [INTERNAL]  Symbolic expressions for the adjoint seeds.
25509 
25510 ";
25511 
25512 %feature("docstring")  casadi::ProtoFunction::print(const char *fmt,...)
25513 const  "
25514 
25515 [INTERNAL]  C-style formatted printing during evaluation.
25516 
25517 ";
25518 
25519 %feature("docstring")  casadi::FunctionInternal::n_nodes() const  "
25520 
25521 [INTERNAL]  Number of nodes in the algorithm.
25522 
25523 ";
25524 
25525 %feature("docstring")  casadi::FunctionInternal::index_out(const std::string
25526 &name) const  "
25527 
25528 [INTERNAL]  Get output scheme index by name.
25529 
25530 ";
25531 
25532 %feature("docstring")  casadi::FunctionInternal::call_gen(const MXVector
25533 &arg, MXVector &res, casadi_int npar, bool always_inline, bool never_inline)
25534 const  "
25535 
25536 [INTERNAL]   Call a function, overloaded.
25537 
25538 ";
25539 
25540 %feature("docstring")  casadi::FunctionInternal::call_gen(const std::vector<
25541 MatrixCommon > &arg, std::vector< MatrixCommon > &res, casadi_int npar, bool
25542 always_inline, bool never_inline) const  "
25543 
25544 [INTERNAL]   Call a function, overloaded.
25545 
25546 ";
25547 
25548 %feature("docstring")
25549 casadi::FunctionInternal::getJacSparsityHierarchicalSymm(casadi_int iind,
25550 casadi_int oind) const  "
25551 
25552 [INTERNAL]  A flavor of getJacSparsity that does hierarchical block
25553 structure recognition for symmetric Jacobians
25554 
25555 ";
25556 
25557 %feature("docstring")  casadi::FunctionInternal::sz_res() const  "
25558 
25559 [INTERNAL]  Get required length of res field.
25560 
25561 ";
25562 
25563 %feature("docstring")  casadi::FunctionInternal::sz_work(size_t &sz_arg,
25564 size_t &sz_res, size_t &sz_iw, size_t &sz_w) const  "
25565 
25566 [INTERNAL]  Get number of temporary variables needed.
25567 
25568 ";
25569 
25570 %feature("docstring")  casadi::Integrator::get_forward(casadi_int nfwd,
25571 const std::string &name, const std::vector< std::string > &inames, const
25572 std::vector< std::string > &onames, const Dict &opts) const  "
25573 
25574 [INTERNAL]  Generate a function that calculates nfwd forward derivatives.
25575 
25576 ";
25577 
25578 %feature("docstring")  casadi::Integrator::sp_jac_dae() "
25579 
25580 [INTERNAL]  Create sparsity pattern of the extended Jacobian (forward
25581 problem)
25582 
25583 ";
25584 
25585 %feature("docstring")
25586 casadi::FunctionInternal::codegen_alloc_mem(CodeGenerator &g) const  "
25587 
25588 [INTERNAL]  Codegen decref for alloc_mem.
25589 
25590 ";
25591 
25592 %feature("docstring")  casadi::FunctionInternal::index_in(const std::string
25593 &name) const  "
25594 
25595 [INTERNAL]  Get input scheme index by name.
25596 
25597 ";
25598 
25599 %feature("docstring")  casadi::FunctionInternal::get_jacobian_sparsity()
25600 const  "
25601 
25602 [INTERNAL]  Get Jacobian sparsity.
25603 
25604 ";
25605 
25606 %feature("docstring")  casadi::FunctionInternal::check_res(const
25607 std::vector< M > &res, casadi_int &npar) const  "
25608 
25609 [INTERNAL]  Check if output arguments have correct length and dimensions.
25610 
25611 Raises errors.
25612 
25613 Parameters:
25614 -----------
25615 
25616 npar[in]:  normal usage: 1, disallow pararallel calls: -1
25617 
25618 npar:  max number of horizontal repetitions across all arguments (or -1)
25619 
25620 ";
25621 
25622 %feature("docstring")  casadi::FunctionInternal::replace_arg(const
25623 std::vector< M > &arg, casadi_int npar) const  "
25624 
25625 [INTERNAL]  Replace 0-by-0 inputs.
25626 
25627 ";
25628 
25629 %feature("docstring")  casadi::FunctionInternal::nnz_in() const  "
25630 
25631 [INTERNAL]  Number of input/output nonzeros.
25632 
25633 ";
25634 
25635 %feature("docstring")  casadi::FunctionInternal::nnz_in(casadi_int ind)
25636 const  "
25637 
25638 [INTERNAL]  Number of input/output nonzeros.
25639 
25640 ";
25641 
25642 %feature("docstring")
25643 casadi::FunctionInternal::getJacSparsityGen(casadi_int iind, casadi_int
25644 oind, bool symmetric, casadi_int gr_i=1, casadi_int gr_o=1) const  "
25645 
25646 [INTERNAL]  Get the sparsity pattern, forward mode.
25647 
25648 ";
25649 
25650 %feature("docstring")  casadi::FixedStepIntegrator::getExplicitB() const  "
25651 
25652 [INTERNAL]  Get explicit dynamics (backward problem)
25653 
25654 ";
25655 
25656 %feature("docstring")  casadi::FixedStepIntegrator::getExplicit() const  "
25657 
25658 [INTERNAL]  Get explicit dynamics.
25659 
25660 ";
25661 
25662 %feature("docstring")
25663 casadi::FunctionInternal::codegen_incref(CodeGenerator &g) const  "
25664 
25665 [INTERNAL]  Codegen incref for dependencies.
25666 
25667 ";
25668 
25669 %feature("docstring")  casadi::FunctionInternal::symbolic_output(const
25670 std::vector< MX > &arg) const  "
25671 
25672 [INTERNAL]  Get a vector of symbolic variables corresponding to the outputs.
25673 
25674 ";
25675 
25676 %feature("docstring")  casadi::OracleFunction::oracle() const  "
25677 
25678 [INTERNAL]  Get oracle.
25679 
25680 ";
25681 
25682 %feature("docstring")  casadi::FunctionInternal::size1_in(casadi_int ind)
25683 const  "
25684 
25685 [INTERNAL]  Input/output dimensions.
25686 
25687 ";
25688 
25689 %feature("docstring")  casadi::FunctionInternal::codegen_meta(CodeGenerator
25690 &g) const  "
25691 
25692 [INTERNAL]  Generate meta-information allowing a user to evaluate a
25693 generated function.
25694 
25695 ";
25696 
25697 %feature("docstring")  casadi::FunctionInternal::get_partition(casadi_int
25698 iind, casadi_int oind, Sparsity &D1, Sparsity &D2, bool compact, bool
25699 symmetric, bool allow_forward, bool allow_reverse) const  "
25700 
25701 [INTERNAL]  Get the unidirectional or bidirectional partition.
25702 
25703 ";
25704 
25705 %feature("docstring")  casadi::FunctionInternal::codegen_body(CodeGenerator
25706 &g) const  "
25707 
25708 [INTERNAL]  Generate code for the function body.
25709 
25710 ";
25711 
25712 %feature("docstring")  casadi::ProtoFunction::sprint(char *buf, size_t
25713 buf_sz, const char *fmt,...) const  "
25714 
25715 [INTERNAL]  C-style formatted printing to string.
25716 
25717 ";
25718 
25719 %feature("docstring")  casadi::FunctionInternal::adjViaJac(casadi_int nadj)
25720 const  "
25721 
25722 [INTERNAL]  Calculate derivatives by multiplying the full Jacobian and
25723 multiplying.
25724 
25725 ";
25726 
25727 %feature("docstring")  casadi::FunctionInternal::call(const std::vector< M >
25728 &arg, std::vector< M > &res, bool always_inline, bool never_inline) const  "
25729 
25730 [INTERNAL]   Call a function, templated.
25731 
25732 ";
25733 
25734 %feature("docstring")  casadi::FunctionInternal::sz_arg() const  "
25735 
25736 [INTERNAL]  Get required length of arg field.
25737 
25738 ";
25739 
25740 %feature("docstring")  casadi::FunctionInternal::get_min_in(casadi_int ind)
25741 const  "
25742 
25743 [INTERNAL]  Get smallest input value.
25744 
25745 ";
25746 
25747 %feature("docstring")  casadi::FixedStepIntegrator::reset(IntegratorMemory
25748 *mem, double t, const double *x, const double *z, const double *p) const  "
25749 
25750 [INTERNAL]  Reset the forward problem.
25751 
25752 ";
25753 
25754 %feature("docstring")  casadi::ProtoFunction::checkout() const  "
25755 
25756 [INTERNAL]  Checkout a memory object.
25757 
25758 ";
25759 
25760 %feature("docstring")  casadi::FunctionInternal::self() const  "
25761 
25762 [INTERNAL]  Get a public class instance.
25763 
25764 ";
25765 
25766 %feature("docstring")  casadi::FunctionInternal::dm_out(casadi_int ind)
25767 const  "
25768 
25769 [INTERNAL]  Get function input(s) and output(s)
25770 
25771 ";
25772 
25773 %feature("docstring")  casadi::FunctionInternal::dm_out() const  "
25774 
25775 [INTERNAL]  Get function input(s) and output(s)
25776 
25777 ";
25778 
25779 %feature("docstring")  casadi::FunctionInternal::fwd_seed(casadi_int nfwd)
25780 const  "
25781 
25782 [INTERNAL]  Symbolic expressions for the forward seeds.
25783 
25784 ";
25785 
25786 %feature("docstring")  casadi::FunctionInternal::is_diff_out(casadi_int i) "
25787 
25788 [INTERNAL] ";
25789 
25790 %feature("docstring")  casadi::ProtoFunction::memory(int ind) const  "
25791 
25792 [INTERNAL]  Memory objects.
25793 
25794 ";
25795 
25796 %feature("docstring")
25797 casadi::FunctionInternal::instruction_output(casadi_int k) const  "
25798 
25799 [INTERNAL]  Get the (integer) output argument of an atomic operation.
25800 
25801 ";
25802 
25803 %feature("docstring")  casadi::ProtoFunction::print_time(const std::map<
25804 std::string, FStats > &fstats) const  "
25805 
25806 [INTERNAL]  Print timing statistics.
25807 
25808 ";
25809 
25810 %feature("docstring")  casadi::FunctionInternal::jac() const  "
25811 
25812 [INTERNAL]  Return Jacobian of all input elements with respect to all output
25813 elements.
25814 
25815 ";
25816 
25817 %feature("docstring")  casadi::ProtoFunction::clear_mem() "
25818 
25819 [INTERNAL]  Clear all memory (called from destructor)
25820 
25821 ";
25822 
25823 %feature("docstring")  casadi::Integrator::algebraic_state_output(const MX
25824 &Z) const  "
25825 
25826 [INTERNAL] ";
25827 
25828 %feature("docstring")  casadi::FunctionInternal::definition() const  "
25829 
25830 [INTERNAL]  Get function signature: name:(inputs)->(outputs)
25831 
25832 ";
25833 
25834 %feature("docstring")  casadi::OracleFunction::set_temp(void *mem, const
25835 double **arg, double **res, casadi_int *iw, double *w) const  "
25836 
25837 [INTERNAL]  Set the work vectors.
25838 
25839 ";
25840 
25841 %feature("docstring")  casadi::FunctionInternal::call_reverse(const
25842 std::vector< MX > &arg, const std::vector< MX > &res, const std::vector<
25843 std::vector< MX > > &aseed, std::vector< std::vector< MX > > &asens, bool
25844 always_inline, bool never_inline) const  "
25845 
25846 [INTERNAL]  Reverse mode, virtual functions overloaded in derived classes.
25847 
25848 ";
25849 
25850 %feature("docstring")  casadi::FunctionInternal::call_reverse(const
25851 std::vector< SX > &arg, const std::vector< SX > &res, const std::vector<
25852 std::vector< SX > > &aseed, std::vector< std::vector< SX > > &asens, bool
25853 always_inline, bool never_inline) const  "
25854 
25855 [INTERNAL]  Reverse mode, virtual functions overloaded in derived classes.
25856 
25857 ";
25858 
25859 %feature("docstring")  casadi::Integrator::has_reverse(casadi_int nadj)
25860 const  "
25861 
25862 [INTERNAL]  Generate a function that calculates nadj adjoint derivatives.
25863 
25864 ";
25865 
25866 %feature("docstring")  casadi::Integrator::print_stats(IntegratorMemory
25867 *mem) const  "
25868 
25869 [INTERNAL]  Print solver statistics.
25870 
25871 ";
25872 
25873 %feature("docstring")  casadi::FunctionInternal::sparsity_jac(casadi_int
25874 iind, casadi_int oind, bool compact, bool symmetric) const  "
25875 
25876 [INTERNAL]  Get, if necessary generate, the sparsity of a Jacobian block.
25877 
25878 ";
25879 
25880 %feature("docstring")  casadi::FunctionInternal::generate_in(const
25881 std::string &fname, const double **arg) const  "
25882 
25883 [INTERNAL]  Export an input file that can be passed to generate C code with
25884 a main.
25885 
25886 ";
25887 
25888 %feature("docstring")
25889 casadi::FixedStepIntegrator::serialize_body(SerializingStream &s) const  "
25890 
25891 [INTERNAL]  Serialize an object without type information.
25892 
25893 ";
25894 
25895 %feature("docstring")  casadi::FunctionInternal::size2_in(casadi_int ind)
25896 const  "
25897 
25898 [INTERNAL]  Input/output dimensions.
25899 
25900 ";
25901 
25902 %feature("docstring")
25903 casadi::FunctionInternal::getJacSparsityHierarchical(casadi_int iind,
25904 casadi_int oind) const  "
25905 
25906 [INTERNAL]  A flavor of getJacSparsity that does hierarchical block
25907 structure recognition.
25908 
25909 ";
25910 
25911 %feature("docstring")  casadi::Integrator::sp_forward(const bvec_t **arg,
25912 bvec_t **res, casadi_int *iw, bvec_t *w, void *mem) const  "
25913 
25914 [INTERNAL]  Propagate sparsity forward.
25915 
25916 ";
25917 
25918 %feature("docstring")  casadi::Integrator::rz() const  "
25919 
25920 [INTERNAL] ";
25921 
25922 %feature("docstring")  casadi::FunctionInternal::jacobian() const  "
25923 
25924 [INTERNAL]  Return Jacobian of all input elements with respect to all output
25925 elements.
25926 
25927 ";
25928 
25929 %feature("docstring")  casadi::Integrator::has_sprev() const  "
25930 
25931 [INTERNAL]  Is the class able to propagate seeds through the algorithm?
25932 
25933 ";
25934 
25935 %feature("docstring")  casadi::FunctionInternal::mx_out(casadi_int ind)
25936 const  "
25937 
25938 [INTERNAL]  Get function input(s) and output(s)
25939 
25940 ";
25941 
25942 %feature("docstring")  casadi::FunctionInternal::mx_out() const  "
25943 
25944 [INTERNAL]  Get function input(s) and output(s)
25945 
25946 ";
25947 
25948 %feature("docstring")  casadi::OracleFunction::get_function() const  "
25949 
25950 [INTERNAL]  Get list of dependency functions -1 Indicates irregularity.
25951 
25952 ";
25953 
25954 %feature("docstring")  casadi::OracleFunction::get_function(const
25955 std::string &name) const  "
25956 
25957 [INTERNAL] ";
25958 
25959 %feature("docstring")  casadi::Integrator::has_spfwd() const  "
25960 
25961 [INTERNAL]  Is the class able to propagate seeds through the algorithm?
25962 
25963 ";
25964 
25965 %feature("docstring")  casadi::FunctionInternal::get_reltol() const  "
25966 
25967 [INTERNAL]  Get relative tolerance.
25968 
25969 ";
25970 
25971 %feature("docstring")  casadi::FunctionInternal::replace_fseed(const
25972 std::vector< std::vector< M >> &fseed, casadi_int npar) const  "
25973 
25974 [INTERNAL]  Replace 0-by-0 forward seeds.
25975 
25976 ";
25977 
25978 %feature("docstring")  casadi::FunctionInternal::replace_fseed(const
25979 std::vector< std::vector< M > > &fseed, casadi_int npar) const  "
25980 
25981 [INTERNAL] ";
25982 
25983 %feature("docstring")  casadi::FunctionInternal::is_a(const std::string
25984 &type, bool recursive) const  "
25985 
25986 [INTERNAL]  Check if the function is of a particular type.
25987 
25988 ";
25989 
25990 %feature("docstring")  casadi::Integrator::get_n_in()  "
25991 
25992 [INTERNAL]  Number of function inputs and outputs.
25993 
25994 ";
25995 
25996 %feature("docstring")  casadi::FunctionInternal::has_derivative() const  "
25997 
25998 [INTERNAL]  Can derivatives be calculated in any way?
25999 
26000 ";
26001 
26002 %feature("docstring")  casadi::FunctionInternal::alloc_res(size_t sz_res,
26003 bool persistent=false) "
26004 
26005 [INTERNAL]  Ensure required length of res field.
26006 
26007 ";
26008 
26009 %feature("docstring")  casadi::OracleFunction::has_function(const
26010 std::string &fname) const  "
26011 
26012 [INTERNAL] ";
26013 
26014 %feature("docstring")  casadi::FunctionInternal::dm_in(casadi_int ind) const
26015 "
26016 
26017 [INTERNAL]  Get function input(s) and output(s)
26018 
26019 ";
26020 
26021 %feature("docstring")  casadi::FunctionInternal::dm_in() const  "
26022 
26023 [INTERNAL]  Get function input(s) and output(s)
26024 
26025 ";
26026 
26027 %feature("docstring")  casadi::FunctionInternal::alloc_arg(size_t sz_arg,
26028 bool persistent=false) "
26029 
26030 [INTERNAL]  Ensure required length of arg field.
26031 
26032 ";
26033 
26034 %feature("docstring")  casadi::FunctionInternal::wrap() const  "
26035 
26036 [INTERNAL]  Wrap in an Function instance consisting of only one MX call.
26037 
26038 ";
26039 
26040 %feature("docstring")  casadi::FixedStepIntegrator::alloc_mem() const  "
26041 
26042 [INTERNAL]  Create memory block.
26043 
26044 ";
26045 
26046 %feature("docstring")  casadi::OracleFunction::set_function(const Function
26047 &fcn, const std::string &fname, bool jit=false) "
26048 
26049 [INTERNAL]  Register the function for evaluation and statistics gathering
26050 
26051 ";
26052 
26053 %feature("docstring")  casadi::OracleFunction::set_function(const Function
26054 &fcn) "
26055 
26056 [INTERNAL]  Register the function for evaluation and statistics gathering
26057 
26058 ";
26059 
26060 %feature("docstring")  casadi::ProtoFunction::release(int mem) const  "
26061 
26062 [INTERNAL]  Release a memory object.
26063 
26064 ";
26065 
26066 %feature("docstring")
26067 casadi::FunctionInternal::codegen_declarations(CodeGenerator &g) const  "
26068 
26069 [INTERNAL]  Generate code for the declarations of the C function.
26070 
26071 ";
26072 
26073 %feature("docstring")  casadi::FunctionInternal::instructions_sx() const  "
26074 
26075 [INTERNAL]  get SX expression associated with instructions
26076 
26077 ";
26078 
26079 %feature("docstring")  casadi::PluginInterface< Integrator  >::plugin_name()
26080 const  "
26081 
26082 [INTERNAL] ";
26083 
26084 %feature("docstring")  casadi::Integrator::get_n_out()  "
26085 
26086 [INTERNAL]  Number of function inputs and outputs.
26087 
26088 ";
26089 
26090 %feature("docstring")  casadi::Integrator::rx() const  "
26091 
26092 [INTERNAL] ";
26093 
26094 %feature("docstring")  casadi::FunctionInternal::size_in(casadi_int ind)
26095 const  "
26096 
26097 [INTERNAL]  Input/output dimensions.
26098 
26099 ";
26100 
26101 %feature("docstring")  casadi::FunctionInternal::disp(std::ostream &stream,
26102 bool more) const  "
26103 
26104 [INTERNAL]  Display object.
26105 
26106 ";
26107 
26108 %feature("docstring")  casadi::Integrator::getDerivativeOptions(bool fwd)
26109 const  "
26110 
26111 [INTERNAL]  Set solver specific options to generated augmented integrators.
26112 
26113 ";
26114 
26115 %feature("docstring")  casadi::Integrator::rq() const  "
26116 
26117 [INTERNAL] ";
26118 
26119 %feature("docstring")  casadi::Integrator::rp() const  "
26120 
26121 [INTERNAL] ";
26122 
26123 %feature("docstring")  casadi::FunctionInternal::is_diff_in(casadi_int i) "
26124 
26125 [INTERNAL] ";
26126 
26127 
26128 // File: classcasadi_1_1ForwardDiff.xml
26129 %feature("docstring")  casadi::ProtoFunction::serialize(SerializingStream
26130 &s) const  "
26131 
26132 [INTERNAL]  Serialize an object.
26133 
26134 ";
26135 
26136 %feature("docstring")  casadi::FunctionInternal::fwdViaJac(casadi_int nfwd)
26137 const  "
26138 
26139 [INTERNAL]  Calculate derivatives by multiplying the full Jacobian and
26140 multiplying.
26141 
26142 ";
26143 
26144 %feature("docstring")  casadi::FunctionInternal::symbolicAdjSeed(casadi_int
26145 nadj, const std::vector< MatType > &v) const  "
26146 
26147 [INTERNAL]  Symbolic expressions for the adjoint seeds.
26148 
26149 ";
26150 
26151 %feature("docstring")  casadi::FiniteDiff::get_sparsity_out(casadi_int i)  "
26152 
26153 [INTERNAL]  Sparsities of function inputs and outputs.
26154 
26155 ";
26156 
26157 %feature("docstring")  casadi::FunctionInternal::has_jacobian_sparsity()
26158 const  "
26159 
26160 [INTERNAL]  Get Jacobian sparsity.
26161 
26162 ";
26163 
26164 %feature("docstring")  casadi::FunctionInternal::oracle() const  "
26165 
26166 [INTERNAL]  Get oracle.
26167 
26168 ";
26169 
26170 %feature("docstring")  casadi::FunctionInternal::fwd_seed(casadi_int nfwd)
26171 const  "
26172 
26173 [INTERNAL]  Symbolic expressions for the forward seeds.
26174 
26175 ";
26176 
26177 %feature("docstring")  casadi::ForwardDiff::calc_stepsize(double abstol)
26178 const  "
26179 
26180 [INTERNAL] ";
26181 
26182 %feature("docstring")  casadi::FunctionInternal::sparsity_out(casadi_int
26183 ind) const  "
26184 
26185 [INTERNAL]  Input/output sparsity.
26186 
26187 ";
26188 
26189 %feature("docstring")  casadi::FunctionInternal::numel_out(casadi_int ind)
26190 const  "
26191 
26192 [INTERNAL]  Number of input/output elements.
26193 
26194 ";
26195 
26196 %feature("docstring")  casadi::FunctionInternal::numel_out() const  "
26197 
26198 [INTERNAL]  Number of input/output elements.
26199 
26200 ";
26201 
26202 %feature("docstring")  casadi::FunctionInternal::call(const std::vector< M >
26203 &arg, std::vector< M > &res, bool always_inline, bool never_inline) const  "
26204 
26205 [INTERNAL]   Call a function, templated.
26206 
26207 ";
26208 
26209 %feature("docstring")
26210 casadi::FunctionInternal::codegen_free_mem(CodeGenerator &g) const  "
26211 
26212 [INTERNAL]  Codegen for free_mem.
26213 
26214 ";
26215 
26216 %feature("docstring")  casadi::FunctionInternal::wrap_as_needed(const Dict
26217 &opts) const  "
26218 
26219 [INTERNAL]  Wrap in an Function instance consisting of only one MX call.
26220 
26221 ";
26222 
26223 %feature("docstring")  casadi::ProtoFunction::memory(int ind) const  "
26224 
26225 [INTERNAL]  Memory objects.
26226 
26227 ";
26228 
26229 %feature("docstring")  casadi::FunctionInternal::incache(const std::string
26230 &fname, Function &f, const std::string &suffix="") const  "
26231 
26232 [INTERNAL]  Get function in cache.
26233 
26234 ";
26235 
26236 %feature("docstring")  casadi::FunctionInternal::get_max_in(casadi_int ind)
26237 const  "
26238 
26239 [INTERNAL]  Get largest input value.
26240 
26241 ";
26242 
26243 %feature("docstring")  casadi::FunctionInternal::codegen(CodeGenerator &g,
26244 const std::string &fname) const  "
26245 
26246 [INTERNAL]  Generate code the function.
26247 
26248 ";
26249 
26250 %feature("docstring")  casadi::FunctionInternal::size_in(casadi_int ind)
26251 const  "
26252 
26253 [INTERNAL]  Input/output dimensions.
26254 
26255 ";
26256 
26257 %feature("docstring")  casadi::FunctionInternal::get_reltol() const  "
26258 
26259 [INTERNAL]  Get relative tolerance.
26260 
26261 ";
26262 
26263 %feature("docstring")
26264 casadi::FunctionInternal::instruction_constant(casadi_int k) const  "
26265 
26266 [INTERNAL]  Get the floating point output argument of an atomic operation.
26267 
26268 ";
26269 
26270 %feature("docstring")  casadi::FunctionInternal::call_forward(const
26271 std::vector< MX > &arg, const std::vector< MX > &res, const std::vector<
26272 std::vector< MX > > &fseed, std::vector< std::vector< MX > > &fsens, bool
26273 always_inline, bool never_inline) const  "
26274 
26275 [INTERNAL]  Forward mode AD, virtual functions overloaded in derived
26276 classes.
26277 
26278 ";
26279 
26280 %feature("docstring")  casadi::FunctionInternal::call_forward(const
26281 std::vector< SX > &arg, const std::vector< SX > &res, const std::vector<
26282 std::vector< SX > > &fseed, std::vector< std::vector< SX > > &fsens, bool
26283 always_inline, bool never_inline) const  "
26284 
26285 [INTERNAL]  Forward mode AD, virtual functions overloaded in derived
26286 classes.
26287 
26288 ";
26289 
26290 %feature("docstring")  casadi::FunctionInternal::has_spfwd() const  "
26291 
26292 [INTERNAL]  Is the class able to propagate seeds through the algorithm?
26293 
26294 ";
26295 
26296 %feature("docstring")
26297 casadi::FunctionInternal::codegen_decref(CodeGenerator &g) const  "
26298 
26299 [INTERNAL]  Codegen decref for dependencies.
26300 
26301 ";
26302 
26303 %feature("docstring")  casadi::ForwardDiff::get_forward(casadi_int nfwd,
26304 const std::string &name, const std::vector< std::string > &inames, const
26305 std::vector< std::string > &onames, const Dict &opts) const  "
26306 
26307 [INTERNAL]  Second order derivatives.
26308 
26309 ";
26310 
26311 %feature("docstring")  casadi::FunctionInternal::get_jacobian_sparsity()
26312 const  "
26313 
26314 [INTERNAL]  Get Jacobian sparsity.
26315 
26316 ";
26317 
26318 %feature("docstring")  casadi::FunctionInternal::has_derivative() const  "
26319 
26320 [INTERNAL]  Can derivatives be calculated in any way?
26321 
26322 ";
26323 
26324 %feature("docstring")  casadi::FunctionInternal::dm_out(casadi_int ind)
26325 const  "
26326 
26327 [INTERNAL]  Get function input(s) and output(s)
26328 
26329 ";
26330 
26331 %feature("docstring")  casadi::FunctionInternal::dm_out() const  "
26332 
26333 [INTERNAL]  Get function input(s) and output(s)
26334 
26335 ";
26336 
26337 %feature("docstring")  casadi::FunctionInternal::matching_arg(const
26338 std::vector< M > &arg, casadi_int &npar) const  "
26339 
26340 [INTERNAL]  Check if input arguments that needs to be replaced.
26341 
26342 Raises errors
26343 
26344 Parameters:
26345 -----------
26346 
26347 npar[in]:  normal usage: 1, disallow pararallel calls: -1
26348 
26349 npar:  max number of horizontal repetitions across all arguments (or -1)
26350 
26351 ";
26352 
26353 %feature("docstring")  casadi::FunctionInternal::nnz_out() const  "
26354 
26355 [INTERNAL]  Number of input/output nonzeros.
26356 
26357 ";
26358 
26359 %feature("docstring")  casadi::FunctionInternal::nnz_out(casadi_int ind)
26360 const  "
26361 
26362 [INTERNAL]  Number of input/output nonzeros.
26363 
26364 ";
26365 
26366 %feature("docstring")  casadi::FunctionInternal::replace_fseed(const
26367 std::vector< std::vector< M >> &fseed, casadi_int npar) const  "
26368 
26369 [INTERNAL]  Replace 0-by-0 forward seeds.
26370 
26371 ";
26372 
26373 %feature("docstring")  casadi::FunctionInternal::replace_fseed(const
26374 std::vector< std::vector< M > > &fseed, casadi_int npar) const  "
26375 
26376 [INTERNAL] ";
26377 
26378 %feature("docstring")  casadi::FunctionInternal::nz_in(const std::vector< DM
26379 > &arg) const  "
26380 
26381 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
26382 
26383 ";
26384 
26385 %feature("docstring")  casadi::FunctionInternal::nz_in(const std::vector<
26386 double > &arg) const  "
26387 
26388 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
26389 
26390 ";
26391 
26392 %feature("docstring")  casadi::FunctionInternal::n_nodes() const  "
26393 
26394 [INTERNAL]  Number of nodes in the algorithm.
26395 
26396 ";
26397 
26398 %feature("docstring")  casadi::FunctionInternal::is_diff_out(casadi_int i) "
26399 
26400 [INTERNAL] ";
26401 
26402 %feature("docstring")  casadi::FunctionInternal::jac() const  "
26403 
26404 [INTERNAL]  Return Jacobian of all input elements with respect to all output
26405 elements.
26406 
26407 ";
26408 
26409 %feature("docstring")  casadi::FunctionInternal::instruction_MX(casadi_int
26410 k) const  "
26411 
26412 [INTERNAL]  get MX expression associated with instruction
26413 
26414 ";
26415 
26416 %feature("docstring")  casadi::FunctionInternal::print_options(std::ostream
26417 &stream) const  "
26418 
26419 [INTERNAL]  Print list of options.
26420 
26421 ";
26422 
26423 %feature("docstring")  casadi::FunctionInternal::size1_out(casadi_int ind)
26424 const  "
26425 
26426 [INTERNAL]  Input/output dimensions.
26427 
26428 ";
26429 
26430 %feature("docstring")  casadi::FunctionInternal::sz_w() const  "
26431 
26432 [INTERNAL]  Get required length of w field.
26433 
26434 ";
26435 
26436 %feature("docstring")  casadi::FunctionInternal::get_free() const  "
26437 
26438 [INTERNAL]  Print free variables.
26439 
26440 ";
26441 
26442 %feature("docstring")  casadi::FunctionInternal::size2_out(casadi_int ind)
26443 const  "
26444 
26445 [INTERNAL]  Input/output dimensions.
26446 
26447 ";
26448 
26449 %feature("docstring")  casadi::FunctionInternal::codegen_mem(CodeGenerator
26450 &g, const std::string &index="mem") const  "
26451 
26452 [INTERNAL]  Get thread-local memory object.
26453 
26454 ";
26455 
26456 %feature("docstring")  casadi::ProtoFunction::get_stats(void *mem) const  "
26457 
26458 [INTERNAL]  Get all statistics.
26459 
26460 ";
26461 
26462 %feature("docstring")  casadi::FunctionInternal::is_a(const std::string
26463 &type, bool recursive) const  "
26464 
26465 [INTERNAL]  Check if the function is of a particular type.
26466 
26467 ";
26468 
26469 %feature("docstring")  casadi::FunctionInternal::convert_res(const
26470 std::vector< M > &res) const  "
26471 
26472 [INTERNAL]  Convert from/to input/output lists/map.
26473 
26474 ";
26475 
26476 %feature("docstring")  casadi::FunctionInternal::convert_res(const std::map<
26477 std::string, M > &res) const  "
26478 
26479 [INTERNAL]  Convert from/to input/output lists/map.
26480 
26481 ";
26482 
26483 %feature("docstring")  casadi::FunctionInternal::project_arg(const
26484 std::vector< M > &arg, casadi_int npar) const  "
26485 
26486 [INTERNAL]   Project sparsities.
26487 
26488 ";
26489 
26490 %feature("docstring")  casadi::FunctionInternal::codegen_name(const
26491 CodeGenerator &g, bool ns=true) const  "
26492 
26493 [INTERNAL]  Get name in codegen.
26494 
26495 ";
26496 
26497 %feature("docstring")  casadi::ProtoFunction::init_mem(void *mem) const  "
26498 
26499 [INTERNAL]  Initalize memory block.
26500 
26501 ";
26502 
26503 %feature("docstring")  casadi::FunctionInternal::alloc_w(size_t sz_w, bool
26504 persistent=false) "
26505 
26506 [INTERNAL]  Ensure required length of w field.
26507 
26508 ";
26509 
26510 %feature("docstring")  casadi::FunctionInternal::sparsity_in(casadi_int ind)
26511 const  "
26512 
26513 [INTERNAL]  Input/output sparsity.
26514 
26515 ";
26516 
26517 %feature("docstring")  casadi::FunctionInternal::has_function(const
26518 std::string &fname) const  "
26519 
26520 [INTERNAL] ";
26521 
26522 %feature("docstring")  casadi::FunctionInternal::call_gen(const MXVector
26523 &arg, MXVector &res, casadi_int npar, bool always_inline, bool never_inline)
26524 const  "
26525 
26526 [INTERNAL]   Call a function, overloaded.
26527 
26528 ";
26529 
26530 %feature("docstring")  casadi::FunctionInternal::call_gen(const std::vector<
26531 MatrixCommon > &arg, std::vector< MatrixCommon > &res, casadi_int npar, bool
26532 always_inline, bool never_inline) const  "
26533 
26534 [INTERNAL]   Call a function, overloaded.
26535 
26536 ";
26537 
26538 %feature("docstring")  casadi::FunctionInternal::replace_res(const
26539 std::vector< M > &res, casadi_int npar) const  "
26540 
26541 [INTERNAL]  Replace 0-by-0 outputs.
26542 
26543 ";
26544 
26545 %feature("docstring")  casadi::FunctionInternal::generate_out(const
26546 std::string &fname, double **res) const  "
26547 
26548 [INTERNAL] ";
26549 
26550 %feature("docstring")  casadi::FunctionInternal::has_reverse(casadi_int
26551 nadj) const  "
26552 
26553 [INTERNAL]  Return function that calculates adjoint derivatives
26554 reverse(nadj) returns a cached instance if available, and calls  Function
26555 get_reverse(casadi_int nadj) if no cached version is available.
26556 
26557 ";
26558 
26559 %feature("docstring")  casadi::FunctionInternal::eval_gen(const double
26560 **arg, double **res, casadi_int *iw, double *w, void *mem) const  "
26561 
26562 [INTERNAL]  Evaluate numerically.
26563 
26564 ";
26565 
26566 %feature("docstring")  casadi::FunctionInternal::eval_gen(const SXElem
26567 **arg, SXElem **res, casadi_int *iw, SXElem *w, void *mem) const  "
26568 
26569 [INTERNAL]  Evaluate a function, overloaded.
26570 
26571 ";
26572 
26573 %feature("docstring")  casadi::FunctionInternal::eval_gen(const bvec_t
26574 **arg, bvec_t **res, casadi_int *iw, bvec_t *w, void *mem) const  "
26575 
26576 [INTERNAL]  Evaluate a function, overloaded.
26577 
26578 ";
26579 
26580 %feature("docstring")  casadi::FunctionInternal::get_partition(casadi_int
26581 iind, casadi_int oind, Sparsity &D1, Sparsity &D2, bool compact, bool
26582 symmetric, bool allow_forward, bool allow_reverse) const  "
26583 
26584 [INTERNAL]  Get the unidirectional or bidirectional partition.
26585 
26586 ";
26587 
26588 %feature("docstring")  casadi::FunctionInternal::free_sx() const  "
26589 
26590 [INTERNAL]  Get free variables (SX)
26591 
26592 ";
26593 
26594 %feature("docstring")
26595 casadi::FunctionInternal::getJacSparsityHierarchicalSymm(casadi_int iind,
26596 casadi_int oind) const  "
26597 
26598 [INTERNAL]  A flavor of getJacSparsity that does hierarchical block
26599 structure recognition for symmetric Jacobians
26600 
26601 ";
26602 
26603 %feature("docstring")  casadi::FunctionInternal::is_diff_in(casadi_int i) "
26604 
26605 [INTERNAL] ";
26606 
26607 %feature("docstring")  casadi::SharedObjectInternal::weak() "
26608 
26609 [INTERNAL]  Get a weak reference to the object.
26610 
26611 ";
26612 
26613 %feature("docstring")  casadi::ForwardDiff::class_name() const  "
26614 
26615 [INTERNAL]  Get type name.
26616 
26617 ";
26618 
26619 %feature("docstring")  casadi::FunctionInternal::mx_in(casadi_int ind) const
26620 "
26621 
26622 [INTERNAL]  Get function input(s) and output(s)
26623 
26624 ";
26625 
26626 %feature("docstring")  casadi::FunctionInternal::mx_in() const  "
26627 
26628 [INTERNAL]  Get function input(s) and output(s)
26629 
26630 ";
26631 
26632 %feature("docstring")  casadi::FunctionInternal::sz_res() const  "
26633 
26634 [INTERNAL]  Get required length of res field.
26635 
26636 ";
26637 
26638 %feature("docstring")  casadi::FunctionInternal::map(casadi_int n, const
26639 std::string &parallelization) const  "
26640 
26641 [INTERNAL]  Generate/retrieve cached serial map.
26642 
26643 ";
26644 
26645 %feature("docstring")  casadi::FunctionInternal::has_eval_dm() const  "
26646 
26647 [INTERNAL]  Evaluate with DM matrices.
26648 
26649 ";
26650 
26651 %feature("docstring") casadi::ForwardDiff "
26652 
26653 [INTERNAL]  Calculate derivative using forward differences Joel Andersson
26654 
26655 >List of available options
26656 
26657 +------------------+-----------------+------------------+------------------+
26658 |        Id        |      Type       |   Description    |     Used in      |
26659 +==================+=================+==================+==================+
26660 | abstol           | OT_DOUBLE       | Accuracy of      | casadi::ForwardD |
26661 |                  |                 | function outputs | iff              |
26662 |                  |                 | [default: query  |                  |
26663 |                  |                 | object]          |                  |
26664 +------------------+-----------------+------------------+------------------+
26665 | ad_weight        | OT_DOUBLE       | Weighting factor | casadi::Function |
26666 |                  |                 | for derivative   | Internal         |
26667 |                  |                 | calculation.When |                  |
26668 |                  |                 | there is an      |                  |
26669 |                  |                 | option of either |                  |
26670 |                  |                 | using forward or |                  |
26671 |                  |                 | reverse mode     |                  |
26672 |                  |                 | directional      |                  |
26673 |                  |                 | derivatives, the |                  |
26674 |                  |                 | condition ad_wei |                  |
26675 |                  |                 | ght*nf<=(1-ad_we |                  |
26676 |                  |                 | ight)*na is used |                  |
26677 |                  |                 | where nf and na  |                  |
26678 |                  |                 | are estimates of |                  |
26679 |                  |                 | the number of    |                  |
26680 |                  |                 | forward/reverse  |                  |
26681 |                  |                 | mode directional |                  |
26682 |                  |                 | derivatives      |                  |
26683 |                  |                 | needed. By       |                  |
26684 |                  |                 | default,         |                  |
26685 |                  |                 | ad_weight is     |                  |
26686 |                  |                 | calculated       |                  |
26687 |                  |                 | automatically,   |                  |
26688 |                  |                 | but this can be  |                  |
26689 |                  |                 | overridden by    |                  |
26690 |                  |                 | setting this     |                  |
26691 |                  |                 | option. In       |                  |
26692 |                  |                 | particular, 0    |                  |
26693 |                  |                 | means forcing    |                  |
26694 |                  |                 | forward mode and |                  |
26695 |                  |                 | 1 forcing        |                  |
26696 |                  |                 | reverse mode.    |                  |
26697 |                  |                 | Leave unset for  |                  |
26698 |                  |                 | (class specific) |                  |
26699 |                  |                 | heuristics.      |                  |
26700 +------------------+-----------------+------------------+------------------+
26701 | ad_weight_sp     | OT_DOUBLE       | Weighting factor | casadi::Function |
26702 |                  |                 | for sparsity     | Internal         |
26703 |                  |                 | pattern          |                  |
26704 |                  |                 | calculation calc |                  |
26705 |                  |                 | ulation.Override |                  |
26706 |                  |                 | s default        |                  |
26707 |                  |                 | behavior. Set to |                  |
26708 |                  |                 | 0 and 1 to force |                  |
26709 |                  |                 | forward and      |                  |
26710 |                  |                 | reverse mode     |                  |
26711 |                  |                 | respectively.    |                  |
26712 |                  |                 | Cf. option       |                  |
26713 |                  |                 | \"ad_weight\".     |                  |
26714 |                  |                 | When set to -1,  |                  |
26715 |                  |                 | sparsity is      |                  |
26716 |                  |                 | completely       |                  |
26717 |                  |                 | ignored and      |                  |
26718 |                  |                 | dense matrices   |                  |
26719 |                  |                 | are used.        |                  |
26720 +------------------+-----------------+------------------+------------------+
26721 | always_inline    | OT_BOOL         | Force inlining.  | casadi::Function |
26722 |                  |                 |                  | Internal         |
26723 +------------------+-----------------+------------------+------------------+
26724 | compiler         | OT_STRING       | Just-in-time     | casadi::Function |
26725 |                  |                 | compiler plugin  | Internal         |
26726 |                  |                 | to be used.      |                  |
26727 +------------------+-----------------+------------------+------------------+
26728 | custom_jacobian  | OT_FUNCTION     | Override         | casadi::Function |
26729 |                  |                 | CasADi's AD. Use | Internal         |
26730 |                  |                 | together with    |                  |
26731 |                  |                 | 'jac_penalty':   |                  |
26732 |                  |                 | 0. Note: Highly  |                  |
26733 |                  |                 | experimental.    |                  |
26734 |                  |                 | Syntax may break |                  |
26735 |                  |                 | often.           |                  |
26736 +------------------+-----------------+------------------+------------------+
26737 | derivative_of    | OT_FUNCTION     | The function is  | casadi::Function |
26738 |                  |                 | a derivative of  | Internal         |
26739 |                  |                 | another          |                  |
26740 |                  |                 | function. The    |                  |
26741 |                  |                 | type of          |                  |
26742 |                  |                 | derivative       |                  |
26743 |                  |                 | (directional     |                  |
26744 |                  |                 | derivative,      |                  |
26745 |                  |                 | Jacobian) is     |                  |
26746 |                  |                 | inferred from    |                  |
26747 |                  |                 | the function     |                  |
26748 |                  |                 | name.            |                  |
26749 +------------------+-----------------+------------------+------------------+
26750 | dump             | OT_BOOL         | Dump function to | casadi::Function |
26751 |                  |                 | file upon first  | Internal         |
26752 |                  |                 | evaluation.      |                  |
26753 |                  |                 | [false]          |                  |
26754 +------------------+-----------------+------------------+------------------+
26755 | dump_dir         | OT_STRING       | Directory to     | casadi::Function |
26756 |                  |                 | dump             | Internal         |
26757 |                  |                 | inputs/outputs   |                  |
26758 |                  |                 | to. Make sure    |                  |
26759 |                  |                 | the directory    |                  |
26760 |                  |                 | exists [.]       |                  |
26761 +------------------+-----------------+------------------+------------------+
26762 | dump_format      | OT_STRING       | Choose file      | casadi::Function |
26763 |                  |                 | format to dump   | Internal         |
26764 |                  |                 | matrices. See    |                  |
26765 |                  |                 | DM.from_file     |                  |
26766 |                  |                 | [mtx]            |                  |
26767 +------------------+-----------------+------------------+------------------+
26768 | dump_in          | OT_BOOL         | Dump numerical   | casadi::Function |
26769 |                  |                 | values of inputs | Internal         |
26770 |                  |                 | to file          |                  |
26771 |                  |                 | (readable with   |                  |
26772 |                  |                 | DM.from_file )   |                  |
26773 |                  |                 | [default: false] |                  |
26774 +------------------+-----------------+------------------+------------------+
26775 | dump_out         | OT_BOOL         | Dump numerical   | casadi::Function |
26776 |                  |                 | values of        | Internal         |
26777 |                  |                 | outputs to file  |                  |
26778 |                  |                 | (readable with   |                  |
26779 |                  |                 | DM.from_file )   |                  |
26780 |                  |                 | [default: false] |                  |
26781 +------------------+-----------------+------------------+------------------+
26782 | enable_fd        | OT_BOOL         | Enable           | casadi::Function |
26783 |                  |                 | derivative       | Internal         |
26784 |                  |                 | calculation by   |                  |
26785 |                  |                 | finite           |                  |
26786 |                  |                 | differencing.    |                  |
26787 |                  |                 | [default:        |                  |
26788 |                  |                 | false]]          |                  |
26789 +------------------+-----------------+------------------+------------------+
26790 | enable_forward   | OT_BOOL         | Enable           | casadi::Function |
26791 |                  |                 | derivative       | Internal         |
26792 |                  |                 | calculation      |                  |
26793 |                  |                 | using generated  |                  |
26794 |                  |                 | functions for    |                  |
26795 |                  |                 | Jacobian-times-  |                  |
26796 |                  |                 | vector products  |                  |
26797 |                  |                 | - typically      |                  |
26798 |                  |                 | using forward    |                  |
26799 |                  |                 | mode AD - if     |                  |
26800 |                  |                 | available.       |                  |
26801 |                  |                 | [default: true]  |                  |
26802 +------------------+-----------------+------------------+------------------+
26803 | enable_jacobian  | OT_BOOL         | Enable           | casadi::Function |
26804 |                  |                 | derivative       | Internal         |
26805 |                  |                 | calculation      |                  |
26806 |                  |                 | using generated  |                  |
26807 |                  |                 | functions for    |                  |
26808 |                  |                 | Jacobians of all |                  |
26809 |                  |                 | differentiable   |                  |
26810 |                  |                 | outputs with     |                  |
26811 |                  |                 | respect to all   |                  |
26812 |                  |                 | differentiable   |                  |
26813 |                  |                 | inputs - if      |                  |
26814 |                  |                 | available.       |                  |
26815 |                  |                 | [default: true]  |                  |
26816 +------------------+-----------------+------------------+------------------+
26817 | enable_reverse   | OT_BOOL         | Enable           | casadi::Function |
26818 |                  |                 | derivative       | Internal         |
26819 |                  |                 | calculation      |                  |
26820 |                  |                 | using generated  |                  |
26821 |                  |                 | functions for    |                  |
26822 |                  |                 | transposed       |                  |
26823 |                  |                 | Jacobian-times-  |                  |
26824 |                  |                 | vector products  |                  |
26825 |                  |                 | - typically      |                  |
26826 |                  |                 | using reverse    |                  |
26827 |                  |                 | mode AD - if     |                  |
26828 |                  |                 | available.       |                  |
26829 |                  |                 | [default: true]  |                  |
26830 +------------------+-----------------+------------------+------------------+
26831 | fd_method        | OT_STRING       | Method for       | casadi::Function |
26832 |                  |                 | finite           | Internal         |
26833 |                  |                 | differencing     |                  |
26834 |                  |                 | [default         |                  |
26835 |                  |                 | 'central']       |                  |
26836 +------------------+-----------------+------------------+------------------+
26837 | fd_options       | OT_DICT         | Options to be    | casadi::Function |
26838 |                  |                 | passed to the    | Internal         |
26839 |                  |                 | finite           |                  |
26840 |                  |                 | difference       |                  |
26841 |                  |                 | instance         |                  |
26842 +------------------+-----------------+------------------+------------------+
26843 | forward_options  | OT_DICT         | Options to be    | casadi::Function |
26844 |                  |                 | passed to a      | Internal         |
26845 |                  |                 | forward mode     |                  |
26846 |                  |                 | constructor      |                  |
26847 +------------------+-----------------+------------------+------------------+
26848 | gather_stats     | OT_BOOL         | Deprecated       | casadi::Function |
26849 |                  |                 | option           | Internal         |
26850 |                  |                 | (ignored):       |                  |
26851 |                  |                 | Statistics are   |                  |
26852 |                  |                 | now always       |                  |
26853 |                  |                 | collected.       |                  |
26854 +------------------+-----------------+------------------+------------------+
26855 | h                | OT_DOUBLE       | Step size        | casadi::ForwardD |
26856 |                  |                 | [default:        | iff              |
26857 |                  |                 | computed from    |                  |
26858 |                  |                 | abstol]          |                  |
26859 +------------------+-----------------+------------------+------------------+
26860 | h_iter           | OT_INT          | Number of        | casadi::ForwardD |
26861 |                  |                 | iterations to    | iff              |
26862 |                  |                 | improve on the   |                  |
26863 |                  |                 | step-size        |                  |
26864 |                  |                 | [default: 1 if   |                  |
26865 |                  |                 | error estimate   |                  |
26866 |                  |                 | available,       |                  |
26867 |                  |                 | otherwise 0]     |                  |
26868 +------------------+-----------------+------------------+------------------+
26869 | h_max            | OT_DOUBLE       | Maximum step     | casadi::ForwardD |
26870 |                  |                 | size [default 0] | iff              |
26871 +------------------+-----------------+------------------+------------------+
26872 | h_min            | OT_DOUBLE       | Minimum step     | casadi::ForwardD |
26873 |                  |                 | size [default    | iff              |
26874 |                  |                 | inf]             |                  |
26875 +------------------+-----------------+------------------+------------------+
26876 | input_scheme     | OT_STRINGVECTOR | Deprecated       | casadi::Function |
26877 |                  |                 | option (ignored) | Internal         |
26878 +------------------+-----------------+------------------+------------------+
26879 | inputs_check     | OT_BOOL         | Throw exceptions | casadi::Function |
26880 |                  |                 | when the         | Internal         |
26881 |                  |                 | numerical values |                  |
26882 |                  |                 | of the inputs    |                  |
26883 |                  |                 | don't make sense |                  |
26884 +------------------+-----------------+------------------+------------------+
26885 | is_diff_in       | OT_BOOLVECTOR   | Indicate for     | casadi::Function |
26886 |                  |                 | each input if it | Internal         |
26887 |                  |                 | should be        |                  |
26888 |                  |                 | differentiable.  |                  |
26889 +------------------+-----------------+------------------+------------------+
26890 | is_diff_out      | OT_BOOLVECTOR   | Indicate for     | casadi::Function |
26891 |                  |                 | each output if   | Internal         |
26892 |                  |                 | it should be     |                  |
26893 |                  |                 | differentiable.  |                  |
26894 +------------------+-----------------+------------------+------------------+
26895 | jac_penalty      | OT_DOUBLE       | When requested   | casadi::Function |
26896 |                  |                 | for a number of  | Internal         |
26897 |                  |                 | forward/reverse  |                  |
26898 |                  |                 | directions, it   |                  |
26899 |                  |                 | may be cheaper   |                  |
26900 |                  |                 | to compute first |                  |
26901 |                  |                 | the full         |                  |
26902 |                  |                 | jacobian and     |                  |
26903 |                  |                 | then multiply    |                  |
26904 |                  |                 | with seeds,      |                  |
26905 |                  |                 | rather than      |                  |
26906 |                  |                 | obtain the       |                  |
26907 |                  |                 | requested        |                  |
26908 |                  |                 | directions in a  |                  |
26909 |                  |                 | straightforward  |                  |
26910 |                  |                 | manner. Casadi   |                  |
26911 |                  |                 | uses a heuristic |                  |
26912 |                  |                 | to decide which  |                  |
26913 |                  |                 | is cheaper. A    |                  |
26914 |                  |                 | high value of    |                  |
26915 |                  |                 | 'jac_penalty'    |                  |
26916 |                  |                 | makes it less    |                  |
26917 |                  |                 | likely for the   |                  |
26918 |                  |                 | heurstic to      |                  |
26919 |                  |                 | chose the full   |                  |
26920 |                  |                 | Jacobian         |                  |
26921 |                  |                 | strategy. The    |                  |
26922 |                  |                 | special value -1 |                  |
26923 |                  |                 | indicates never  |                  |
26924 |                  |                 | to use the full  |                  |
26925 |                  |                 | Jacobian         |                  |
26926 |                  |                 | strategy         |                  |
26927 +------------------+-----------------+------------------+------------------+
26928 | jit              | OT_BOOL         | Use just-in-time | casadi::Function |
26929 |                  |                 | compiler to      | Internal         |
26930 |                  |                 | speed up the     |                  |
26931 |                  |                 | evaluation       |                  |
26932 +------------------+-----------------+------------------+------------------+
26933 | jit_cleanup      | OT_BOOL         | Cleanup up the   | casadi::Function |
26934 |                  |                 | temporary source | Internal         |
26935 |                  |                 | file that jit    |                  |
26936 |                  |                 | creates.         |                  |
26937 |                  |                 | Default: true    |                  |
26938 +------------------+-----------------+------------------+------------------+
26939 | jit_name         | OT_STRING       | The file name    | casadi::Function |
26940 |                  |                 | used to write    | Internal         |
26941 |                  |                 | out code. The    |                  |
26942 |                  |                 | actual file      |                  |
26943 |                  |                 | names used       |                  |
26944 |                  |                 | depend on 'jit_t |                  |
26945 |                  |                 | emp_suffix' and  |                  |
26946 |                  |                 | include          |                  |
26947 |                  |                 | extensions.      |                  |
26948 |                  |                 | Default:         |                  |
26949 |                  |                 | 'jit_tmp'        |                  |
26950 +------------------+-----------------+------------------+------------------+
26951 | jit_options      | OT_DICT         | Options to be    | casadi::Function |
26952 |                  |                 | passed to the    | Internal         |
26953 |                  |                 | jit compiler.    |                  |
26954 +------------------+-----------------+------------------+------------------+
26955 | jit_serialize    | OT_STRING       | Specify          | casadi::Function |
26956 |                  |                 | behaviour when   | Internal         |
26957 |                  |                 | serializing a    |                  |
26958 |                  |                 | jitted function: |                  |
26959 |                  |                 | SOURCE|link|embe |                  |
26960 |                  |                 | d.               |                  |
26961 +------------------+-----------------+------------------+------------------+
26962 | jit_temp_suffix  | OT_BOOL         | Use a temporary  | casadi::Function |
26963 |                  |                 | (seemingly       | Internal         |
26964 |                  |                 | random) filename |                  |
26965 |                  |                 | suffix for       |                  |
26966 |                  |                 | generated code   |                  |
26967 |                  |                 | and libraries.   |                  |
26968 |                  |                 | This is desired  |                  |
26969 |                  |                 | for thread-      |                  |
26970 |                  |                 | safety. This     |                  |
26971 |                  |                 | behaviour may    |                  |
26972 |                  |                 | defeat caching   |                  |
26973 |                  |                 | compiler         |                  |
26974 |                  |                 | wrappers.        |                  |
26975 |                  |                 | Default: true    |                  |
26976 +------------------+-----------------+------------------+------------------+
26977 | max_num_dir      | OT_INT          | Specify the      | casadi::Function |
26978 |                  |                 | maximum number   | Internal         |
26979 |                  |                 | of directions    |                  |
26980 |                  |                 | for derivative   |                  |
26981 |                  |                 | functions.       |                  |
26982 |                  |                 | Overrules the    |                  |
26983 |                  |                 | builtin optimize |                  |
26984 |                  |                 | d_num_dir.       |                  |
26985 +------------------+-----------------+------------------+------------------+
26986 | never_inline     | OT_BOOL         | Forbid inlining. | casadi::Function |
26987 |                  |                 |                  | Internal         |
26988 +------------------+-----------------+------------------+------------------+
26989 | output_scheme    | OT_STRINGVECTOR | Deprecated       | casadi::Function |
26990 |                  |                 | option (ignored) | Internal         |
26991 +------------------+-----------------+------------------+------------------+
26992 | print_in         | OT_BOOL         | Print numerical  | casadi::Function |
26993 |                  |                 | values of inputs | Internal         |
26994 |                  |                 | [default: false] |                  |
26995 +------------------+-----------------+------------------+------------------+
26996 | print_out        | OT_BOOL         | Print numerical  | casadi::Function |
26997 |                  |                 | values of        | Internal         |
26998 |                  |                 | outputs          |                  |
26999 |                  |                 | [default: false] |                  |
27000 +------------------+-----------------+------------------+------------------+
27001 | print_time       | OT_BOOL         | print            | casadi::Function |
27002 |                  |                 | information      | Internal         |
27003 |                  |                 | about execution  |                  |
27004 |                  |                 | time. Implies    |                  |
27005 |                  |                 | record_time.     |                  |
27006 +------------------+-----------------+------------------+------------------+
27007 | record_time      | OT_BOOL         | record           | casadi::Function |
27008 |                  |                 | information      | Internal         |
27009 |                  |                 | about execution  |                  |
27010 |                  |                 | time, for        |                  |
27011 |                  |                 | retrieval with   |                  |
27012 |                  |                 | stats().         |                  |
27013 +------------------+-----------------+------------------+------------------+
27014 | regularity_check | OT_BOOL         | Throw exceptions | casadi::Function |
27015 |                  |                 | when NaN or Inf  | Internal         |
27016 |                  |                 | appears during   |                  |
27017 |                  |                 | evaluation       |                  |
27018 +------------------+-----------------+------------------+------------------+
27019 | reltol           | OT_DOUBLE       | Accuracy of      | casadi::ForwardD |
27020 |                  |                 | function inputs  | iff              |
27021 |                  |                 | [default: query  |                  |
27022 |                  |                 | object]          |                  |
27023 +------------------+-----------------+------------------+------------------+
27024 | reverse_options  | OT_DICT         | Options to be    | casadi::Function |
27025 |                  |                 | passed to a      | Internal         |
27026 |                  |                 | reverse mode     |                  |
27027 |                  |                 | constructor      |                  |
27028 +------------------+-----------------+------------------+------------------+
27029 | second_order_ste | OT_DOUBLE       | Second order     | casadi::ForwardD |
27030 | psize            |                 | perturbation     | iff              |
27031 |                  |                 | size [default:   |                  |
27032 |                  |                 | 1e-3]            |                  |
27033 +------------------+-----------------+------------------+------------------+
27034 | smoothing        | OT_DOUBLE       | Smoothing        | casadi::ForwardD |
27035 |                  |                 | regularization   | iff              |
27036 |                  |                 | [default:        |                  |
27037 |                  |                 | machine          |                  |
27038 |                  |                 | precision]       |                  |
27039 +------------------+-----------------+------------------+------------------+
27040 | u_aim            | OT_DOUBLE       | Target ratio of  | casadi::ForwardD |
27041 |                  |                 | roundoff error   | iff              |
27042 |                  |                 | to truncation    |                  |
27043 |                  |                 | error [default:  |                  |
27044 |                  |                 | 100.]            |                  |
27045 +------------------+-----------------+------------------+------------------+
27046 | user_data        | OT_VOIDPTR      | A user-defined   | casadi::Function |
27047 |                  |                 | field that can   | Internal         |
27048 |                  |                 | be used to       |                  |
27049 |                  |                 | identify the     |                  |
27050 |                  |                 | function or pass |                  |
27051 |                  |                 | additional       |                  |
27052 |                  |                 | information      |                  |
27053 +------------------+-----------------+------------------+------------------+
27054 | verbose          | OT_BOOL         | Verbose          | casadi::Function |
27055 |                  |                 | evaluation  for  | Internal         |
27056 |                  |                 | debugging        |                  |
27057 +------------------+-----------------+------------------+------------------+
27058 
27059 Diagrams
27060 --------
27061 
27062 
27063 
27064 C++ includes: finite_differences.hpp ";
27065 
27066 %feature("docstring")  casadi::FunctionInternal::slice(const std::string
27067 &name, const std::vector< casadi_int > &order_in, const std::vector<
27068 casadi_int > &order_out, const Dict &opts) const  "
27069 
27070 [INTERNAL]  returns a new function with a selection of inputs/outputs of the
27071 original
27072 
27073 ";
27074 
27075 %feature("docstring")  casadi::ProtoFunction::sprint(char *buf, size_t
27076 buf_sz, const char *fmt,...) const  "
27077 
27078 [INTERNAL]  C-style formatted printing to string.
27079 
27080 ";
27081 
27082 %feature("docstring")  casadi::ProtoFunction::checkout() const  "
27083 
27084 [INTERNAL]  Checkout a memory object.
27085 
27086 ";
27087 
27088 %feature("docstring")  casadi::FunctionInternal::free_mx() const  "
27089 
27090 [INTERNAL]  Get free variables ( MX)
27091 
27092 ";
27093 
27094 %feature("docstring")
27095 casadi::FunctionInternal::codegen_incref(CodeGenerator &g) const  "
27096 
27097 [INTERNAL]  Codegen incref for dependencies.
27098 
27099 ";
27100 
27101 %feature("docstring")  casadi::FunctionInternal::instructions_sx() const  "
27102 
27103 [INTERNAL]  get SX expression associated with instructions
27104 
27105 ";
27106 
27107 %feature("docstring")  casadi::ForwardDiff::calc_fd(double **yk, double *y0,
27108 double *J, double h) const  "
27109 
27110 [INTERNAL] ";
27111 
27112 %feature("docstring")  casadi::ForwardDiff::calc_fd() const  "
27113 
27114 [INTERNAL] ";
27115 
27116 %feature("docstring")  casadi::FunctionInternal::export_code(const
27117 std::string &lang, std::ostream &stream, const Dict &options) const  "
27118 
27119 [INTERNAL]  Export function in a specific language.
27120 
27121 ";
27122 
27123 %feature("docstring")  casadi::FunctionInternal::which_depends(const
27124 std::string &s_in, const std::vector< std::string > &s_out, casadi_int
27125 order, bool tr=false) const  "
27126 
27127 [INTERNAL]  Which variables enter with some order.
27128 
27129 Parameters:
27130 -----------
27131 
27132 s_in:   Input name
27133 
27134 s_out:   Output name(s)
27135 
27136 order:  Only 1 (linear) and 2 (nonlinear) allowed
27137 
27138 tr:  Flip the relationship. Return which expressions contain the variables
27139 
27140 ";
27141 
27142 %feature("docstring")
27143 casadi::FunctionInternal::serialize_type(SerializingStream &s) const  "
27144 
27145 [INTERNAL]  Serialize type information.
27146 
27147 ";
27148 
27149 %feature("docstring")  casadi::FunctionInternal::size2_in(casadi_int ind)
27150 const  "
27151 
27152 [INTERNAL]  Input/output dimensions.
27153 
27154 ";
27155 
27156 %feature("docstring")  casadi::FunctionInternal::has_jacobian() const  "
27157 
27158 [INTERNAL]  Return Jacobian of all input elements with respect to all output
27159 elements.
27160 
27161 ";
27162 
27163 %feature("docstring")  casadi::ForwardDiff::get_abstol() const  "
27164 
27165 [INTERNAL]  Get absolute tolerance.
27166 
27167 ";
27168 
27169 %feature("docstring")  casadi::FunctionInternal::wrap() const  "
27170 
27171 [INTERNAL]  Wrap in an Function instance consisting of only one MX call.
27172 
27173 ";
27174 
27175 %feature("docstring")  casadi::FunctionInternal::sz_iw() const  "
27176 
27177 [INTERNAL]  Get required length of iw field.
27178 
27179 ";
27180 
27181 %feature("docstring")  casadi::FunctionInternal::codegen_mem_type() const  "
27182 
27183 [INTERNAL]  Thread-local memory object type.
27184 
27185 ";
27186 
27187 %feature("docstring")  casadi::FunctionInternal::get_function() const  "
27188 
27189 [INTERNAL] ";
27190 
27191 %feature("docstring")  casadi::FunctionInternal::get_function(const
27192 std::string &name) const  "
27193 
27194 [INTERNAL] ";
27195 
27196 %feature("docstring")  casadi::FunctionInternal::forward(casadi_int nfwd)
27197 const  "
27198 
27199 [INTERNAL]  Return function that calculates forward derivatives
27200 forward(nfwd) returns a cached instance if available, and calls  Function
27201 get_forward(casadi_int nfwd) if no cached version is available.
27202 
27203 ";
27204 
27205 %feature("docstring")
27206 casadi::FunctionInternal::print_dimensions(std::ostream &stream) const  "
27207 
27208 [INTERNAL]  Print dimensions of inputs and outputs.
27209 
27210 ";
27211 
27212 %feature("docstring")  casadi::FiniteDiff::has_codegen() const  "
27213 
27214 [INTERNAL]  Is codegen supported?
27215 
27216 ";
27217 
27218 %feature("docstring")  casadi::FunctionInternal::jacobian_sparsity() const
27219 "
27220 
27221 [INTERNAL]  Get Jacobian sparsity.
27222 
27223 ";
27224 
27225 %feature("docstring")  casadi::FiniteDiff::get_name_in(casadi_int i)  "
27226 
27227 [INTERNAL]  Names of function input and outputs.
27228 
27229 ";
27230 
27231 %feature("docstring")  casadi::FunctionInternal::alloc_res(size_t sz_res,
27232 bool persistent=false) "
27233 
27234 [INTERNAL]  Ensure required length of res field.
27235 
27236 ";
27237 
27238 %feature("docstring")  casadi::FunctionInternal::getAdaptorSolverName()
27239 const  "
27240 
27241 [INTERNAL]  Obtain solver name from Adaptor.
27242 
27243 ";
27244 
27245 %feature("docstring")  casadi::FunctionInternal::instruction_id(casadi_int
27246 k) const  "
27247 
27248 [INTERNAL]  Get an atomic operation operator index.
27249 
27250 ";
27251 
27252 %feature("docstring")  casadi::FunctionInternal::info() const  "
27253 
27254 [INTERNAL]  Obtain information about function
27255 
27256 ";
27257 
27258 %feature("docstring")  casadi::FunctionInternal::check_mat(const Sparsity
27259 &arg, const Sparsity &inp, casadi_int &npar) "
27260 
27261 [INTERNAL]  Helper function
27262 
27263 Parameters:
27264 -----------
27265 
27266 npar[in]:  normal usage: 1, disallow pararallel calls: -1
27267 
27268 npar[out]:  required number of parallel calls (or -1)
27269 
27270 ";
27271 
27272 %feature("docstring")  casadi::FunctionInternal::symbolic_output(const
27273 std::vector< MX > &arg) const  "
27274 
27275 [INTERNAL]  Get a vector of symbolic variables corresponding to the outputs.
27276 
27277 ";
27278 
27279 %feature("docstring")  casadi::FunctionInternal::mapsum_mx(const
27280 std::vector< MX > &arg, const std::string &parallelization) "
27281 
27282 [INTERNAL]  Parallel evaluation.
27283 
27284 ";
27285 
27286 %feature("docstring")  casadi::FunctionInternal::disp_more(std::ostream
27287 &stream) const  "
27288 
27289 [INTERNAL]  Print more.
27290 
27291 ";
27292 
27293 %feature("docstring")  casadi::FunctionInternal::tocache(const Function &f,
27294 const std::string &suffix="") const  "
27295 
27296 [INTERNAL]  Save function to cache.
27297 
27298 ";
27299 
27300 %feature("docstring")  casadi::FunctionInternal::eval_dm(const std::vector<
27301 DM > &arg) const  "
27302 
27303 [INTERNAL]  Evaluate with DM matrices.
27304 
27305 ";
27306 
27307 %feature("docstring")
27308 casadi::FunctionInternal::jacobian_sparsity_filter(const Sparsity &sp) const
27309 "
27310 
27311 [INTERNAL]  Filter out nonzeros in the full sparsity jacobian according to
27312 is_diff_in/out.
27313 
27314 ";
27315 
27316 %feature("docstring") casadi::ForwardDiff::~ForwardDiff "
27317 
27318 [INTERNAL]  Destructor.
27319 
27320 ";
27321 
27322 %feature("docstring")  casadi::FunctionInternal::ad_weight() const  "
27323 
27324 [INTERNAL]  Weighting factor for chosing forward/reverse mode.
27325 
27326 ";
27327 
27328 %feature("docstring")  casadi::FunctionInternal::mx_out(casadi_int ind)
27329 const  "
27330 
27331 [INTERNAL]  Get function input(s) and output(s)
27332 
27333 ";
27334 
27335 %feature("docstring")  casadi::FunctionInternal::mx_out() const  "
27336 
27337 [INTERNAL]  Get function input(s) and output(s)
27338 
27339 ";
27340 
27341 %feature("docstring")  casadi::FunctionInternal::get_reverse(casadi_int
27342 nadj, const std::string &name, const std::vector< std::string > &inames,
27343 const std::vector< std::string > &onames, const Dict &opts) const  "
27344 
27345 [INTERNAL]  Return function that calculates adjoint derivatives
27346 reverse(nadj) returns a cached instance if available, and calls  Function
27347 get_reverse(casadi_int nadj) if no cached version is available.
27348 
27349 ";
27350 
27351 %feature("docstring")  casadi::ProtoFunction::free_mem(void *mem) const  "
27352 
27353 [INTERNAL]  Free memory block.
27354 
27355 ";
27356 
27357 %feature("docstring")  casadi::ForwardDiff::pert(const std::string &k) const
27358 "
27359 
27360 [INTERNAL] ";
27361 
27362 %feature("docstring")  casadi::ForwardDiff::pert(casadi_int k, double h)
27363 const  "
27364 
27365 [INTERNAL] ";
27366 
27367 %feature("docstring")  casadi::ProtoFunction::format_time(char *buffer,
27368 double time) const  "
27369 
27370 [INTERNAL]  Format time in a fixed width 8 format.
27371 
27372 ";
27373 
27374 %feature("docstring")  casadi::FiniteDiff::eval(const double **arg, double
27375 **res, casadi_int *iw, double *w, void *mem) const  "
27376 
27377 [INTERNAL]  Evaluate numerically.
27378 
27379 ";
27380 
27381 %feature("docstring")
27382 casadi::FunctionInternal::instruction_input(casadi_int k) const  "
27383 
27384 [INTERNAL]  Get the (integer) input arguments of an atomic operation.
27385 
27386 ";
27387 
27388 %feature("docstring") casadi::ForwardDiff::ForwardDiff(const std::string
27389 &name, casadi_int n) "
27390 
27391 [INTERNAL] ";
27392 
27393 %feature("docstring")  casadi::FunctionInternal::setup(void *mem, const
27394 double **arg, double **res, casadi_int *iw, double *w) const  "
27395 
27396 [INTERNAL]  Set the (persistent and temporary) work vectors.
27397 
27398 ";
27399 
27400 %feature("docstring")  casadi::SharedObjectInternal::getCount() const  "
27401 
27402 [INTERNAL]  Get the reference count.
27403 
27404 ";
27405 
27406 %feature("docstring")  casadi::FunctionInternal::project_res(const
27407 std::vector< M > &arg, casadi_int npar) const  "
27408 
27409 [INTERNAL]   Project sparsities.
27410 
27411 ";
27412 
27413 %feature("docstring")  casadi::FiniteDiff::get_sparsity_in(casadi_int i)  "
27414 
27415 [INTERNAL]  Sparsities of function inputs and outputs.
27416 
27417 ";
27418 
27419 %feature("docstring")  casadi::FunctionInternal::get_jac(const std::string
27420 &name, const std::vector< std::string > &inames, const std::vector<
27421 std::string > &onames, const Dict &opts) const  "
27422 
27423 [INTERNAL]  Return Jacobian of all input elements with respect to all output
27424 elements.
27425 
27426 ";
27427 
27428 %feature("docstring")  casadi::FunctionInternal::replace_arg(const
27429 std::vector< M > &arg, casadi_int npar) const  "
27430 
27431 [INTERNAL]  Replace 0-by-0 inputs.
27432 
27433 ";
27434 
27435 %feature("docstring")  casadi::FunctionInternal::finalize()  "
27436 
27437 [INTERNAL]  Finalize the object creation.
27438 
27439 ";
27440 
27441 %feature("docstring")  casadi::FunctionInternal::jit_dependencies(const
27442 std::string &fname) "
27443 
27444 [INTERNAL]  Jit dependencies.
27445 
27446 ";
27447 
27448 %feature("docstring")  casadi::FunctionInternal::sp_forward(const bvec_t
27449 **arg, bvec_t **res, casadi_int *iw, bvec_t *w, void *mem) const  "
27450 
27451 [INTERNAL]  Propagate sparsity forward.
27452 
27453 ";
27454 
27455 %feature("docstring")  casadi::FunctionInternal::alloc_arg(size_t sz_arg,
27456 bool persistent=false) "
27457 
27458 [INTERNAL]  Ensure required length of arg field.
27459 
27460 ";
27461 
27462 %feature("docstring")  casadi::FunctionInternal::get_jacobian(const
27463 std::string &name, const std::vector< std::string > &inames, const
27464 std::vector< std::string > &onames, const Dict &opts) const  "
27465 
27466 [INTERNAL]  Return Jacobian of all input elements with respect to all output
27467 elements.
27468 
27469 ";
27470 
27471 %feature("docstring")
27472 casadi::FunctionInternal::codegen_alloc_mem(CodeGenerator &g) const  "
27473 
27474 [INTERNAL]  Codegen decref for alloc_mem.
27475 
27476 ";
27477 
27478 %feature("docstring")  casadi::FunctionInternal::nz_out(const std::vector<
27479 DM > &res) const  "
27480 
27481 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
27482 
27483 ";
27484 
27485 %feature("docstring")  casadi::FunctionInternal::nz_out(const std::vector<
27486 double > &res) const  "
27487 
27488 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
27489 
27490 ";
27491 
27492 %feature("docstring")  casadi::FunctionInternal::has_jac() const  "
27493 
27494 [INTERNAL]  Return Jacobian of all input elements with respect to all output
27495 elements.
27496 
27497 ";
27498 
27499 %feature("docstring")  casadi::FunctionInternal::call_reverse(const
27500 std::vector< MX > &arg, const std::vector< MX > &res, const std::vector<
27501 std::vector< MX > > &aseed, std::vector< std::vector< MX > > &asens, bool
27502 always_inline, bool never_inline) const  "
27503 
27504 [INTERNAL]  Reverse mode, virtual functions overloaded in derived classes.
27505 
27506 ";
27507 
27508 %feature("docstring")  casadi::FunctionInternal::call_reverse(const
27509 std::vector< SX > &arg, const std::vector< SX > &res, const std::vector<
27510 std::vector< SX > > &aseed, std::vector< std::vector< SX > > &asens, bool
27511 always_inline, bool never_inline) const  "
27512 
27513 [INTERNAL]  Reverse mode, virtual functions overloaded in derived classes.
27514 
27515 ";
27516 
27517 %feature("docstring")  casadi::FunctionInternal::alloc(const Function &f,
27518 bool persistent=false) "
27519 
27520 [INTERNAL]  Ensure work vectors long enough to evaluate function.
27521 
27522 ";
27523 
27524 %feature("docstring")  casadi::FunctionInternal::generate_dependencies(const
27525 std::string &fname, const Dict &opts) const  "
27526 
27527 [INTERNAL]  Export / Generate C code for the dependency function.
27528 
27529 ";
27530 
27531 %feature("docstring")  casadi::FunctionInternal::alloc_iw(size_t sz_iw, bool
27532 persistent=false) "
27533 
27534 [INTERNAL]  Ensure required length of iw field.
27535 
27536 ";
27537 
27538 %feature("docstring")  casadi::ProtoFunction::print(const char *fmt,...)
27539 const  "
27540 
27541 [INTERNAL]  C-style formatted printing during evaluation.
27542 
27543 ";
27544 
27545 %feature("docstring")  casadi::FunctionInternal::size1_in(casadi_int ind)
27546 const  "
27547 
27548 [INTERNAL]  Input/output dimensions.
27549 
27550 ";
27551 
27552 %feature("docstring")  casadi::FunctionInternal::generate_lifted(Function
27553 &vdef_fcn, Function &vinit_fcn) const  "
27554 
27555 [INTERNAL]  Extract the functions needed for the Lifted Newton method.
27556 
27557 ";
27558 
27559 %feature("docstring")  casadi::FunctionInternal::all_scalar() const  "
27560 
27561 [INTERNAL]  Are all inputs and outputs scalar.
27562 
27563 ";
27564 
27565 %feature("docstring")  casadi::FunctionInternal::set_work(void *mem, const
27566 double **&arg, double **&res, casadi_int *&iw, double *&w) const  "
27567 
27568 [INTERNAL]  Set the (persistent) work vectors.
27569 
27570 ";
27571 
27572 %feature("docstring")  casadi::ForwardDiff::has_err() const  "
27573 
27574 [INTERNAL] ";
27575 
27576 %feature("docstring")  casadi::FunctionInternal::sz_arg() const  "
27577 
27578 [INTERNAL]  Get required length of arg field.
27579 
27580 ";
27581 
27582 %feature("docstring")  casadi::FunctionInternal::reverse(casadi_int nadj)
27583 const  "
27584 
27585 [INTERNAL]  Return function that calculates adjoint derivatives
27586 reverse(nadj) returns a cached instance if available, and calls  Function
27587 get_reverse(casadi_int nadj) if no cached version is available.
27588 
27589 ";
27590 
27591 %feature("docstring")  casadi::ForwardDiff::has_forward(casadi_int nfwd)
27592 const  "
27593 
27594 [INTERNAL]  Second order derivatives.
27595 
27596 ";
27597 
27598 %feature("docstring")
27599 casadi::FiniteDiff::codegen_declarations(CodeGenerator &g) const  "
27600 
27601 [INTERNAL]  Generate code for the declarations of the C function.
27602 
27603 ";
27604 
27605 %feature("docstring")  casadi::FunctionInternal::matching_res(const
27606 std::vector< M > &arg, casadi_int &npar) const  "
27607 
27608 [INTERNAL]  Check if output arguments that needs to be replaced.
27609 
27610 Raises errors
27611 
27612 Parameters:
27613 -----------
27614 
27615 npar[in]:  normal usage: 1, disallow pararallel calls: -1
27616 
27617 npar:  max number of horizontal repetitions across all arguments (or -1)
27618 
27619 ";
27620 
27621 %feature("docstring")  casadi::FunctionInternal::sx_in(casadi_int ind) const
27622 "
27623 
27624 [INTERNAL]  Get function input(s) and output(s)
27625 
27626 ";
27627 
27628 %feature("docstring")  casadi::FunctionInternal::sx_in() const  "
27629 
27630 [INTERNAL]  Get function input(s) and output(s)
27631 
27632 ";
27633 
27634 %feature("docstring")  casadi::FunctionInternal::index_out(const std::string
27635 &name) const  "
27636 
27637 [INTERNAL]  Get output scheme index by name.
27638 
27639 ";
27640 
27641 %feature("docstring")  casadi::FiniteDiff::uses_output() const  "
27642 
27643 [INTERNAL]  Is the scheme using the (nondifferentiated) output?
27644 
27645 ";
27646 
27647 %feature("docstring")  casadi::FunctionInternal::self() const  "
27648 
27649 [INTERNAL]  Get a public class instance.
27650 
27651 ";
27652 
27653 %feature("docstring")  casadi::FunctionInternal::n_instructions() const  "
27654 
27655 [INTERNAL]  Get the number of atomic operations.
27656 
27657 ";
27658 
27659 %feature("docstring")
27660 casadi::FunctionInternal::serialize_body(SerializingStream &s) const  "
27661 
27662 [INTERNAL]  Serialize an object without type information.
27663 
27664 ";
27665 
27666 %feature("docstring")  casadi::FunctionInternal::generate_in(const
27667 std::string &fname, const double **arg) const  "
27668 
27669 [INTERNAL]  Export an input file that can be passed to generate C code with
27670 a main.
27671 
27672 ";
27673 
27674 %feature("docstring")  casadi::FunctionInternal::eval_sx(const SXElem **arg,
27675 SXElem **res, casadi_int *iw, SXElem *w, void *mem) const  "
27676 
27677 [INTERNAL]  Evaluate with symbolic scalars.
27678 
27679 ";
27680 
27681 %feature("docstring")  casadi::FunctionInternal::sp_reverse(bvec_t **arg,
27682 bvec_t **res, casadi_int *iw, bvec_t *w, void *mem) const  "
27683 
27684 [INTERNAL]  Propagate sparsity backwards.
27685 
27686 ";
27687 
27688 %feature("docstring")  casadi::FunctionInternal::check_arg(const
27689 std::vector< M > &arg, casadi_int &npar) const  "
27690 
27691 [INTERNAL]  Check if input arguments have correct length and dimensions.
27692 
27693 Raises errors.
27694 
27695 Parameters:
27696 -----------
27697 
27698 npar[in]:  normal usage: 1, disallow pararallel calls: -1
27699 
27700 npar:  max number of horizontal repetitions across all arguments (or -1)
27701 
27702 ";
27703 
27704 %feature("docstring")  casadi::FunctionInternal::nnz_in() const  "
27705 
27706 [INTERNAL]  Number of input/output nonzeros.
27707 
27708 ";
27709 
27710 %feature("docstring")  casadi::FunctionInternal::nnz_in(casadi_int ind)
27711 const  "
27712 
27713 [INTERNAL]  Number of input/output nonzeros.
27714 
27715 ";
27716 
27717 %feature("docstring")
27718 casadi::FunctionInternal::instruction_output(casadi_int k) const  "
27719 
27720 [INTERNAL]  Get the (integer) output argument of an atomic operation.
27721 
27722 ";
27723 
27724 %feature("docstring")  casadi::FunctionInternal::factory(const std::string
27725 &name, const std::vector< std::string > &s_in, const std::vector<
27726 std::string > &s_out, const Function::AuxOut &aux, const Dict &opts) const
27727 "
27728 
27729 [INTERNAL] ";
27730 
27731 %feature("docstring")  casadi::FunctionInternal::sparsity_jac(casadi_int
27732 iind, casadi_int oind, bool compact, bool symmetric) const  "
27733 
27734 [INTERNAL]  Get, if necessary generate, the sparsity of a Jacobian block.
27735 
27736 ";
27737 
27738 %feature("docstring")  casadi::FiniteDiff::get_n_out()  "
27739 
27740 [INTERNAL]  Number of function inputs and outputs.
27741 
27742 ";
27743 
27744 %feature("docstring")  casadi::FunctionInternal::disp(std::ostream &stream,
27745 bool more) const  "
27746 
27747 [INTERNAL]  Display object.
27748 
27749 ";
27750 
27751 %feature("docstring")  casadi::FunctionInternal::index_in(const std::string
27752 &name) const  "
27753 
27754 [INTERNAL]  Get input scheme index by name.
27755 
27756 ";
27757 
27758 %feature("docstring")  casadi::FunctionInternal::print_option(const
27759 std::string &name, std::ostream &stream) const  "
27760 
27761 [INTERNAL]  Print all information there is to know about a certain option.
27762 
27763 ";
27764 
27765 %feature("docstring")  casadi::FiniteDiff::init(const Dict &opts)  "
27766 
27767 [INTERNAL]  Initialize.
27768 
27769 ";
27770 
27771 %feature("docstring")  casadi::FunctionInternal::check_res(const
27772 std::vector< M > &res, casadi_int &npar) const  "
27773 
27774 [INTERNAL]  Check if output arguments have correct length and dimensions.
27775 
27776 Raises errors.
27777 
27778 Parameters:
27779 -----------
27780 
27781 npar[in]:  normal usage: 1, disallow pararallel calls: -1
27782 
27783 npar:  max number of horizontal repetitions across all arguments (or -1)
27784 
27785 ";
27786 
27787 %feature("docstring")  casadi::FunctionInternal::numel_in() const  "
27788 
27789 [INTERNAL]  Number of input/output elements.
27790 
27791 ";
27792 
27793 %feature("docstring")  casadi::FunctionInternal::numel_in(casadi_int ind)
27794 const  "
27795 
27796 [INTERNAL]  Number of input/output elements.
27797 
27798 ";
27799 
27800 %feature("docstring")  casadi::FunctionInternal::dm_in(casadi_int ind) const
27801 "
27802 
27803 [INTERNAL]  Get function input(s) and output(s)
27804 
27805 ";
27806 
27807 %feature("docstring")  casadi::FunctionInternal::dm_in() const  "
27808 
27809 [INTERNAL]  Get function input(s) and output(s)
27810 
27811 ";
27812 
27813 %feature("docstring")
27814 casadi::FunctionInternal::codegen_sparsities(CodeGenerator &g) const  "
27815 
27816 [INTERNAL]  Codegen sparsities.
27817 
27818 ";
27819 
27820 %feature("docstring")
27821 casadi::FunctionInternal::getJacSparsityHierarchical(casadi_int iind,
27822 casadi_int oind) const  "
27823 
27824 [INTERNAL]  A flavor of getJacSparsity that does hierarchical block
27825 structure recognition.
27826 
27827 ";
27828 
27829 %feature("docstring")  casadi::FiniteDiff::get_n_in()  "
27830 
27831 [INTERNAL]  Number of function inputs and outputs.
27832 
27833 ";
27834 
27835 %feature("docstring")  casadi::FunctionInternal::getJacSparsity(casadi_int
27836 iind, casadi_int oind, bool symmetric) const  "
27837 
27838 [INTERNAL]  Generate the sparsity of a Jacobian block.
27839 
27840 ";
27841 
27842 %feature("docstring")
27843 casadi::FunctionInternal::getJacSparsityGen(casadi_int iind, casadi_int
27844 oind, bool symmetric, casadi_int gr_i=1, casadi_int gr_o=1) const  "
27845 
27846 [INTERNAL]  Get the sparsity pattern, forward mode.
27847 
27848 ";
27849 
27850 %feature("docstring")
27851 casadi::FunctionInternal::codegen_init_mem(CodeGenerator &g) const  "
27852 
27853 [INTERNAL]  Codegen decref for init_mem.
27854 
27855 ";
27856 
27857 %feature("docstring")  casadi::ProtoFunction::clear_mem() "
27858 
27859 [INTERNAL]  Clear all memory (called from destructor)
27860 
27861 ";
27862 
27863 %feature("docstring")  casadi::FunctionInternal::generate_options(bool
27864 is_temp=false) const  "
27865 
27866 [INTERNAL]  Reconstruct options dict.
27867 
27868 ";
27869 
27870 %feature("docstring")  casadi::ProtoFunction::alloc_mem() const  "
27871 
27872 [INTERNAL]  Create memory block.
27873 
27874 ";
27875 
27876 %feature("docstring")  casadi::ProtoFunction::construct(const Dict &opts) "
27877 
27878 [INTERNAL]  Construct Prepares the function for evaluation.
27879 
27880 ";
27881 
27882 %feature("docstring")  casadi::FiniteDiff::codegen_body(CodeGenerator &g)
27883 const  "
27884 
27885 [INTERNAL]  Generate code for the body of the C function.
27886 
27887 ";
27888 
27889 %feature("docstring")  casadi::FiniteDiff::get_name_out(casadi_int i)  "
27890 
27891 [INTERNAL]  Names of function input and outputs.
27892 
27893 ";
27894 
27895 %feature("docstring")  casadi::FiniteDiff::get_options() const  "
27896 
27897 [INTERNAL]  Options.
27898 
27899 ";
27900 
27901 %feature("docstring")  casadi::FunctionInternal::set_temp(void *mem, const
27902 double **arg, double **res, casadi_int *iw, double *w) const  "
27903 
27904 [INTERNAL]  Set the (temporary) work vectors.
27905 
27906 ";
27907 
27908 %feature("docstring")  casadi::FunctionInternal::eval_mx(const MXVector
27909 &arg, MXVector &res, bool always_inline, bool never_inline) const  "
27910 
27911 [INTERNAL]  Evaluate with symbolic matrices.
27912 
27913 ";
27914 
27915 %feature("docstring")  casadi::FunctionInternal::has_sprev() const  "
27916 
27917 [INTERNAL]  Is the class able to propagate seeds through the algorithm?
27918 
27919 ";
27920 
27921 %feature("docstring")  casadi::FunctionInternal::codegen_meta(CodeGenerator
27922 &g) const  "
27923 
27924 [INTERNAL]  Generate meta-information allowing a user to evaluate a
27925 generated function.
27926 
27927 ";
27928 
27929 %feature("docstring")  casadi::ProtoFunction::serialize_base_function()
27930 const  "
27931 
27932 [INTERNAL]  String used to identify the immediate FunctionInternal subclass.
27933 
27934 ";
27935 
27936 %feature("docstring")  casadi::FunctionInternal::convert_arg(const
27937 std::vector< M > &arg) const  "
27938 
27939 [INTERNAL]  Convert from/to input/output lists/map.
27940 
27941 ";
27942 
27943 %feature("docstring")  casadi::FunctionInternal::convert_arg(const std::map<
27944 std::string, M > &arg) const  "
27945 
27946 [INTERNAL]  Convert from/to input/output lists/map.
27947 
27948 ";
27949 
27950 %feature("docstring")  casadi::ProtoFunction::release(int mem) const  "
27951 
27952 [INTERNAL]  Release a memory object.
27953 
27954 ";
27955 
27956 %feature("docstring")  casadi::FunctionInternal::size_out(casadi_int ind)
27957 const  "
27958 
27959 [INTERNAL]  Input/output dimensions.
27960 
27961 ";
27962 
27963 %feature("docstring")  casadi::FunctionInternal::signature(const std::string
27964 &fname) const  "
27965 
27966 [INTERNAL]  Code generate the function.
27967 
27968 ";
27969 
27970 %feature("docstring")  casadi::FunctionInternal::sp_weight() const  "
27971 
27972 [INTERNAL]  Weighting factor for chosing forward/reverse mode, sparsity
27973 propagation.
27974 
27975 ";
27976 
27977 %feature("docstring")  casadi::FunctionInternal::sz_work(size_t &sz_arg,
27978 size_t &sz_res, size_t &sz_iw, size_t &sz_w) const  "
27979 
27980 [INTERNAL]  Get number of temporary variables needed.
27981 
27982 ";
27983 
27984 %feature("docstring")  casadi::FunctionInternal::definition() const  "
27985 
27986 [INTERNAL]  Get function signature: name:(inputs)->(outputs)
27987 
27988 ";
27989 
27990 %feature("docstring")  casadi::FunctionInternal::get_min_in(casadi_int ind)
27991 const  "
27992 
27993 [INTERNAL]  Get smallest input value.
27994 
27995 ";
27996 
27997 %feature("docstring")  casadi::FunctionInternal::adjViaJac(casadi_int nadj)
27998 const  "
27999 
28000 [INTERNAL]  Calculate derivatives by multiplying the full Jacobian and
28001 multiplying.
28002 
28003 ";
28004 
28005 %feature("docstring")  casadi::ProtoFunction::print_time(const std::map<
28006 std::string, FStats > &fstats) const  "
28007 
28008 [INTERNAL]  Print timing statistics.
28009 
28010 ";
28011 
28012 %feature("docstring")  casadi::FunctionInternal::sx_out(casadi_int ind)
28013 const  "
28014 
28015 [INTERNAL]  Get function input(s) and output(s)
28016 
28017 ";
28018 
28019 %feature("docstring")  casadi::FunctionInternal::sx_out() const  "
28020 
28021 [INTERNAL]  Get function input(s) and output(s)
28022 
28023 ";
28024 
28025 %feature("docstring")  casadi::FunctionInternal::jacobian() const  "
28026 
28027 [INTERNAL]  Return Jacobian of all input elements with respect to all output
28028 elements.
28029 
28030 ";
28031 
28032 %feature("docstring")  casadi::ForwardDiff::n_pert() const  "
28033 
28034 [INTERNAL] ";
28035 
28036 %feature("docstring")  casadi::FiniteDiff::get_default_in(casadi_int ind)
28037 const  "
28038 
28039 [INTERNAL]  Get default input value.
28040 
28041 ";
28042 
28043 %feature("docstring")  casadi::FunctionInternal::has_free() const  "
28044 
28045 [INTERNAL]  Does the function have free variables.
28046 
28047 ";
28048 
28049 %feature("docstring")  casadi::FunctionInternal::replace_aseed(const
28050 std::vector< std::vector< M >> &aseed, casadi_int npar) const  "
28051 
28052 [INTERNAL]  Replace 0-by-0 reverse seeds.
28053 
28054 ";
28055 
28056 %feature("docstring")  casadi::FunctionInternal::replace_aseed(const
28057 std::vector< std::vector< M > > &aseed, casadi_int npar) const  "
28058 
28059 [INTERNAL] ";
28060 
28061 
28062 // File: classcasadi_1_1FStats.xml
28063 %feature("docstring")  casadi::FStats::tic() "
28064 
28065 [INTERNAL]  Start timing.
28066 
28067 ";
28068 
28069 %feature("docstring")  casadi::FStats::reset() "
28070 
28071 [INTERNAL]  Reset the statistics.
28072 
28073 ";
28074 
28075 %feature("docstring") casadi::FStats::FStats() "
28076 
28077 [INTERNAL]  Constructor.
28078 
28079 ";
28080 
28081 %feature("docstring") casadi::FStats "
28082 
28083 [INTERNAL]  Timer class
28084 
28085 FStats hack; hack.tic(); .... hack.toc();
28086 
28087 C++ includes: timing.hpp ";
28088 
28089 %feature("docstring")  casadi::FStats::toc() "
28090 
28091 [INTERNAL]  Stop timing.
28092 
28093 ";
28094 
28095 
28096 // File: classcasadi_1_1Function.xml
28097 %feature("docstring")  casadi::Function::n_instructions() const  "
28098 
28099 Number of instruction in the algorithm (SXFunction/MXFunction)
28100 
28101 ";
28102 
28103 %feature("docstring")  casadi::Function::nnz_in() const  "
28104 
28105 Get number of input nonzeros.
28106 
28107 For a particular input or for all of the inputs
28108 
28109 ";
28110 
28111 %feature("docstring")  casadi::Function::nnz_in(casadi_int ind) const  "
28112 
28113 Get number of input nonzeros.
28114 
28115 For a particular input or for all of the inputs
28116 
28117 ";
28118 
28119 %feature("docstring")  casadi::Function::nnz_in(const std::string &iname)
28120 const  "
28121 
28122 Get number of input nonzeros.
28123 
28124 For a particular input or for all of the inputs
28125 
28126 ";
28127 
28128 %feature("docstring")  casadi::Function::has_spfwd() const  "
28129 
28130 Is the class able to propagate seeds through the algorithm?
28131 
28132 ";
28133 
28134 %feature("docstring")  casadi::Function::name() const  "
28135 
28136 Name of the function.
28137 
28138 ";
28139 
28140 %feature("docstring")  casadi::Function::jacobian() const  "
28141 
28142 Generate a Jacobian function of all the inputs elements with respect to all
28143 the output elements).
28144 
28145 ";
28146 
28147 %feature("docstring") casadi::casadi_jacobian "
28148 
28149 Generate a Jacobian function of all the inputs elements with respect to all
28150 the output elements).
28151 
28152 ";
28153 
28154 %feature("docstring")  casadi::Function::casadi_jacobian "
28155 
28156 Generate a Jacobian function of all the inputs elements with respect to all
28157 the output elements).
28158 
28159 ";
28160 
28161 %feature("docstring")  casadi::Function::stats(int mem=0) const  "
28162 
28163 Get all statistics obtained at the end of the last evaluate call.
28164 
28165 ";
28166 
28167 %feature("docstring")  casadi::Function::fold(casadi_int N, const Dict
28168 &opts=Dict()) const  "
28169 
28170 Create a mapaccumulated version of this function.
28171 
28172 Suppose the function has a signature of:
28173 
28174 ::
28175 
28176      f: (x, u) -> (x_next , y )
28177 
28178 
28179 
28180 
28181 The the mapaccumulated version has the signature:
28182 
28183 ::
28184 
28185      F: (x0, U) -> (X , Y )
28186 
28187       with
28188           U: horzcat([u0, u1, ..., u_(N-1)])
28189           X: horzcat([x1, x2, ..., x_N])
28190           Y: horzcat([y0, y1, ..., y_(N-1)])
28191 
28192       and
28193           x1, y0 <- f(x0, u0)
28194           x2, y1 <- f(x1, u1)
28195           ...
28196           x_N, y_(N-1) <- f(x_(N-1), u_(N-1))
28197 
28198 
28199 
28200 
28201 Mapaccum has the following benefits over writing an equivalent for- loop:
28202 much faster at construction time
28203 
28204 potentially much faster compilation times (for codegen)
28205 
28206 offers a trade-off between memory and evaluation time
28207 
28208 The base (settable through the options dictionary, default 10), is used to
28209 create a tower of function calls, containing unrolled for- loops of length
28210 maximum base.
28211 
28212 This technique is much more scalable in terms of memory-usage, but slightly
28213 slower at evaluation, than a plain for-loop. The effect is similar to that
28214 of a for-loop with a check-pointing instruction after each chunk of
28215 iterations with size base.
28216 
28217 Set base to -1 to unroll all the way; no gains in memory efficiency here.
28218 
28219 ";
28220 
28221 %feature("docstring")  casadi::Function::sparsity_out(casadi_int ind) const
28222 "
28223 
28224 Get sparsity of a given output.
28225 
28226 ";
28227 
28228 %feature("docstring")  casadi::Function::sparsity_out(const std::string
28229 &iname) const  "
28230 
28231 Get sparsity of a given output.
28232 
28233 ";
28234 
28235 %feature("docstring")  casadi::Function::oracle() const  "
28236 
28237 Get oracle.
28238 
28239 ";
28240 
28241 %feature("docstring")  casadi::Function::instruction_id(casadi_int k) const
28242 "
28243 
28244 Identifier index of the instruction (SXFunction/MXFunction)
28245 
28246 ";
28247 
28248 %feature("docstring")  casadi::Function::wrap() const  "
28249 
28250 Wrap in an Function instance consisting of only one MX call.
28251 
28252 ";
28253 
28254 %feature("docstring")  casadi::Function::wrap_as_needed(const Dict &opts)
28255 const  "
28256 
28257 Wrap in a Function with options.
28258 
28259 ";
28260 
28261 %feature("docstring")  casadi::Function::nz_from_out(const std::vector< DM >
28262 &arg) const  "
28263 
28264 Convert from/to flat vector of input/output nonzeros.
28265 
28266 ";
28267 
28268 %feature("docstring")  casadi::Function::convert_out(const std::vector< DM >
28269 &arg) const  "
28270 
28271 Convert from/to input/output lists/map.
28272 
28273 Will raise an error when an unknown key is used or a list has incorrect
28274 size. Does not perform sparsity checking.
28275 
28276 ";
28277 
28278 %feature("docstring")  casadi::Function::convert_out(const DMDict &arg)
28279 const  "
28280 
28281 Convert from/to input/output lists/map.
28282 
28283 Will raise an error when an unknown key is used or a list has incorrect
28284 size. Does not perform sparsity checking.
28285 
28286 ";
28287 
28288 %feature("docstring")  casadi::Function::convert_out(const std::vector< SX >
28289 &arg) const  "
28290 
28291 Convert from/to input/output lists/map.
28292 
28293 Will raise an error when an unknown key is used or a list has incorrect
28294 size. Does not perform sparsity checking.
28295 
28296 ";
28297 
28298 %feature("docstring")  casadi::Function::convert_out(const SXDict &arg)
28299 const  "
28300 
28301 Convert from/to input/output lists/map.
28302 
28303 Will raise an error when an unknown key is used or a list has incorrect
28304 size. Does not perform sparsity checking.
28305 
28306 ";
28307 
28308 %feature("docstring")  casadi::Function::convert_out(const std::vector< MX >
28309 &arg) const  "
28310 
28311 Convert from/to input/output lists/map.
28312 
28313 Will raise an error when an unknown key is used or a list has incorrect
28314 size. Does not perform sparsity checking.
28315 
28316 ";
28317 
28318 %feature("docstring")  casadi::Function::convert_out(const MXDict &arg)
28319 const  "
28320 
28321 Convert from/to input/output lists/map.
28322 
28323 Will raise an error when an unknown key is used or a list has incorrect
28324 size. Does not perform sparsity checking.
28325 
28326 ";
28327 
28328 %feature("docstring")  casadi::Function::numel_out() const  "
28329 
28330 Get number of output elements.
28331 
28332 For a particular output or for all of the outputs
28333 
28334 ";
28335 
28336 %feature("docstring")  casadi::Function::numel_out(casadi_int ind) const  "
28337 
28338 Get number of output elements.
28339 
28340 For a particular output or for all of the outputs
28341 
28342 ";
28343 
28344 %feature("docstring")  casadi::Function::numel_out(const std::string &oname)
28345 const  "
28346 
28347 Get number of output elements.
28348 
28349 For a particular output or for all of the outputs
28350 
28351 ";
28352 
28353 %feature("docstring")  casadi::Function::print_dimensions(std::ostream
28354 &stream=casadi::uout()) const  "
28355 
28356 Print dimensions of inputs and outputs.
28357 
28358 ";
28359 
28360 %feature("docstring")  casadi::SharedObject::get_str(bool more=false) const
28361 "
28362 
28363 Get string representation.
28364 
28365 ";
28366 
28367 %feature("docstring")  casadi::Function::get_free() const  "
28368 
28369 Get free variables as a string.
28370 
28371 ";
28372 
28373 %feature("docstring")  casadi::SharedObject::disp(std::ostream &stream, bool
28374 more=false) const  "
28375 
28376 Print a description of the object.
28377 
28378 ";
28379 
28380 %feature("docstring")  casadi::Function::name_out() const  "
28381 
28382 Get output scheme.
28383 
28384 ";
28385 
28386 %feature("docstring")  casadi::Function::name_out(casadi_int ind) const  "
28387 
28388 Get output scheme name by index.
28389 
28390 ";
28391 
28392 %feature("docstring")  casadi::Function::n_in() const  "
28393 
28394 Get the number of function inputs.
28395 
28396 ";
28397 
28398 %feature("docstring")  casadi::Function::mx_out(casadi_int ind) const  "
28399 
28400 Get symbolic primitives equivalent to the output expressions There is no
28401 guarantee that subsequent calls return unique answers.
28402 
28403 ";
28404 
28405 %feature("docstring")  casadi::Function::mx_out(const std::string &oname)
28406 const  "
28407 
28408 Get symbolic primitives equivalent to the output expressions There is no
28409 guarantee that subsequent calls return unique answers.
28410 
28411 ";
28412 
28413 %feature("docstring")  casadi::Function::mx_out() const  "
28414 
28415 Get symbolic primitives equivalent to the output expressions There is no
28416 guarantee that subsequent calls return unique answers.
28417 
28418 ";
28419 
28420 %feature("docstring")  casadi::Function::max_in(casadi_int ind) const  "
28421 
28422 Get largest input value.
28423 
28424 ";
28425 
28426 %feature("docstring")  casadi::Function::generate_dependencies(const
28427 std::string &fname, const Dict &opts=Dict()) const  "
28428 
28429 Export / Generate C code for the dependency function.
28430 
28431 ";
28432 
28433 %feature("docstring")  casadi::Function::free_sx() const  "
28434 
28435 Get all the free variables of the function.
28436 
28437 ";
28438 
28439 %feature("docstring")  casadi::Function::mapaccum(const std::string &name,
28440 casadi_int N, const Dict &opts=Dict()) const  "
28441 
28442 Create a mapaccumulated version of this function.
28443 
28444 Suppose the function has a signature of:
28445 
28446 ::
28447 
28448      f: (x, u) -> (x_next , y )
28449 
28450 
28451 
28452 
28453 The the mapaccumulated version has the signature:
28454 
28455 ::
28456 
28457      F: (x0, U) -> (X , Y )
28458 
28459       with
28460           U: horzcat([u0, u1, ..., u_(N-1)])
28461           X: horzcat([x1, x2, ..., x_N])
28462           Y: horzcat([y0, y1, ..., y_(N-1)])
28463 
28464       and
28465           x1, y0 <- f(x0, u0)
28466           x2, y1 <- f(x1, u1)
28467           ...
28468           x_N, y_(N-1) <- f(x_(N-1), u_(N-1))
28469 
28470 
28471 
28472 
28473 Mapaccum has the following benefits over writing an equivalent for- loop:
28474 much faster at construction time
28475 
28476 potentially much faster compilation times (for codegen)
28477 
28478 offers a trade-off between memory and evaluation time
28479 
28480 The base (settable through the options dictionary, default 10), is used to
28481 create a tower of function calls, containing unrolled for- loops of length
28482 maximum base.
28483 
28484 This technique is much more scalable in terms of memory-usage, but slightly
28485 slower at evaluation, than a plain for-loop. The effect is similar to that
28486 of a for-loop with a check-pointing instruction after each chunk of
28487 iterations with size base.
28488 
28489 Set base to -1 to unroll all the way; no gains in memory efficiency here.
28490 
28491 ";
28492 
28493 %feature("docstring")  casadi::Function::mapaccum(const std::string &name,
28494 casadi_int N, casadi_int n_accum, const Dict &opts=Dict()) const  "
28495 
28496 Create a mapaccumulated version of this function.
28497 
28498 Suppose the function has a signature of:
28499 
28500 ::
28501 
28502      f: (x, u) -> (x_next , y )
28503 
28504 
28505 
28506 
28507 The the mapaccumulated version has the signature:
28508 
28509 ::
28510 
28511      F: (x0, U) -> (X , Y )
28512 
28513       with
28514           U: horzcat([u0, u1, ..., u_(N-1)])
28515           X: horzcat([x1, x2, ..., x_N])
28516           Y: horzcat([y0, y1, ..., y_(N-1)])
28517 
28518       and
28519           x1, y0 <- f(x0, u0)
28520           x2, y1 <- f(x1, u1)
28521           ...
28522           x_N, y_(N-1) <- f(x_(N-1), u_(N-1))
28523 
28524 
28525 
28526 
28527 Mapaccum has the following benefits over writing an equivalent for- loop:
28528 much faster at construction time
28529 
28530 potentially much faster compilation times (for codegen)
28531 
28532 offers a trade-off between memory and evaluation time
28533 
28534 The base (settable through the options dictionary, default 10), is used to
28535 create a tower of function calls, containing unrolled for- loops of length
28536 maximum base.
28537 
28538 This technique is much more scalable in terms of memory-usage, but slightly
28539 slower at evaluation, than a plain for-loop. The effect is similar to that
28540 of a for-loop with a check-pointing instruction after each chunk of
28541 iterations with size base.
28542 
28543 Set base to -1 to unroll all the way; no gains in memory efficiency here.
28544 
28545 ";
28546 
28547 %feature("docstring")  casadi::Function::mapaccum(const std::string &name,
28548 casadi_int n, const std::vector< casadi_int > &accum_in, const std::vector<
28549 casadi_int > &accum_out, const Dict &opts=Dict()) const  "
28550 
28551 Create a mapaccumulated version of this function.
28552 
28553 Suppose the function has a signature of:
28554 
28555 ::
28556 
28557      f: (x, u) -> (x_next , y )
28558 
28559 
28560 
28561 
28562 The the mapaccumulated version has the signature:
28563 
28564 ::
28565 
28566      F: (x0, U) -> (X , Y )
28567 
28568       with
28569           U: horzcat([u0, u1, ..., u_(N-1)])
28570           X: horzcat([x1, x2, ..., x_N])
28571           Y: horzcat([y0, y1, ..., y_(N-1)])
28572 
28573       and
28574           x1, y0 <- f(x0, u0)
28575           x2, y1 <- f(x1, u1)
28576           ...
28577           x_N, y_(N-1) <- f(x_(N-1), u_(N-1))
28578 
28579 
28580 
28581 
28582 Mapaccum has the following benefits over writing an equivalent for- loop:
28583 much faster at construction time
28584 
28585 potentially much faster compilation times (for codegen)
28586 
28587 offers a trade-off between memory and evaluation time
28588 
28589 The base (settable through the options dictionary, default 10), is used to
28590 create a tower of function calls, containing unrolled for- loops of length
28591 maximum base.
28592 
28593 This technique is much more scalable in terms of memory-usage, but slightly
28594 slower at evaluation, than a plain for-loop. The effect is similar to that
28595 of a for-loop with a check-pointing instruction after each chunk of
28596 iterations with size base.
28597 
28598 Set base to -1 to unroll all the way; no gains in memory efficiency here.
28599 
28600 ";
28601 
28602 %feature("docstring")  casadi::Function::mapaccum(const std::string &name,
28603 casadi_int n, const std::vector< std::string > &accum_in, const std::vector<
28604 std::string > &accum_out, const Dict &opts=Dict()) const  "
28605 
28606 Create a mapaccumulated version of this function.
28607 
28608 Suppose the function has a signature of:
28609 
28610 ::
28611 
28612      f: (x, u) -> (x_next , y )
28613 
28614 
28615 
28616 
28617 The the mapaccumulated version has the signature:
28618 
28619 ::
28620 
28621      F: (x0, U) -> (X , Y )
28622 
28623       with
28624           U: horzcat([u0, u1, ..., u_(N-1)])
28625           X: horzcat([x1, x2, ..., x_N])
28626           Y: horzcat([y0, y1, ..., y_(N-1)])
28627 
28628       and
28629           x1, y0 <- f(x0, u0)
28630           x2, y1 <- f(x1, u1)
28631           ...
28632           x_N, y_(N-1) <- f(x_(N-1), u_(N-1))
28633 
28634 
28635 
28636 
28637 Mapaccum has the following benefits over writing an equivalent for- loop:
28638 much faster at construction time
28639 
28640 potentially much faster compilation times (for codegen)
28641 
28642 offers a trade-off between memory and evaluation time
28643 
28644 The base (settable through the options dictionary, default 10), is used to
28645 create a tower of function calls, containing unrolled for- loops of length
28646 maximum base.
28647 
28648 This technique is much more scalable in terms of memory-usage, but slightly
28649 slower at evaluation, than a plain for-loop. The effect is similar to that
28650 of a for-loop with a check-pointing instruction after each chunk of
28651 iterations with size base.
28652 
28653 Set base to -1 to unroll all the way; no gains in memory efficiency here.
28654 
28655 ";
28656 
28657 %feature("docstring")  casadi::Function::mapaccum(casadi_int N, const Dict
28658 &opts=Dict()) const  "
28659 
28660 Create a mapaccumulated version of this function.
28661 
28662 Suppose the function has a signature of:
28663 
28664 ::
28665 
28666      f: (x, u) -> (x_next , y )
28667 
28668 
28669 
28670 
28671 The the mapaccumulated version has the signature:
28672 
28673 ::
28674 
28675      F: (x0, U) -> (X , Y )
28676 
28677       with
28678           U: horzcat([u0, u1, ..., u_(N-1)])
28679           X: horzcat([x1, x2, ..., x_N])
28680           Y: horzcat([y0, y1, ..., y_(N-1)])
28681 
28682       and
28683           x1, y0 <- f(x0, u0)
28684           x2, y1 <- f(x1, u1)
28685           ...
28686           x_N, y_(N-1) <- f(x_(N-1), u_(N-1))
28687 
28688 
28689 
28690 
28691 Mapaccum has the following benefits over writing an equivalent for- loop:
28692 much faster at construction time
28693 
28694 potentially much faster compilation times (for codegen)
28695 
28696 offers a trade-off between memory and evaluation time
28697 
28698 The base (settable through the options dictionary, default 10), is used to
28699 create a tower of function calls, containing unrolled for- loops of length
28700 maximum base.
28701 
28702 This technique is much more scalable in terms of memory-usage, but slightly
28703 slower at evaluation, than a plain for-loop. The effect is similar to that
28704 of a for-loop with a check-pointing instruction after each chunk of
28705 iterations with size base.
28706 
28707 Set base to -1 to unroll all the way; no gains in memory efficiency here.
28708 
28709 ";
28710 
28711 %feature("docstring") casadi::Function::Function(const std::string &name,
28712 const std::vector< SX > &ex_in, const std::vector< SX > &ex_out, const Dict
28713 &opts=Dict()) "
28714 
28715 Construct an SX function.
28716 
28717 ";
28718 
28719 %feature("docstring") casadi::Function::Function(const std::string &name,
28720 const std::vector< SX > &ex_in, const std::vector< SX > &ex_out, const
28721 std::vector< std::string > &name_in, const std::vector< std::string >
28722 &name_out, const Dict &opts=Dict()) "
28723 
28724 Construct an SX function.
28725 
28726 ";
28727 
28728 %feature("docstring") casadi::Function::Function(const std::string &name,
28729 const std::map< std::string, SX > &dict, const std::vector< std::string >
28730 &name_in, const std::vector< std::string > &name_out, const Dict
28731 &opts=Dict()) "
28732 
28733 Construct an SX function.
28734 
28735 ";
28736 
28737 %feature("docstring") casadi::Function::Function(const std::string &name,
28738 const std::vector< MX > &ex_in, const std::vector< MX > &ex_out, const Dict
28739 &opts=Dict()) "
28740 
28741 Construct an MX function.
28742 
28743 ";
28744 
28745 %feature("docstring") casadi::Function::Function(const std::string &name,
28746 const std::vector< MX > &ex_in, const std::vector< MX > &ex_out, const
28747 std::vector< std::string > &name_in, const std::vector< std::string >
28748 &name_out, const Dict &opts=Dict()) "
28749 
28750 Construct an MX function.
28751 
28752 ";
28753 
28754 %feature("docstring") casadi::Function::Function(const std::string &name,
28755 const std::map< std::string, MX > &dict, const std::vector< std::string >
28756 &name_in, const std::vector< std::string > &name_out, const Dict
28757 &opts=Dict()) "
28758 
28759 Construct an MX function.
28760 
28761 ";
28762 
28763 %feature("docstring") casadi::Function::Function() "
28764 
28765 Default constructor, null pointer.
28766 
28767 ";
28768 
28769 %feature("docstring") casadi::Function::Function(const std::string &fname) "
28770 
28771 Construct from a file.
28772 
28773 ";
28774 
28775 %feature("docstring")  casadi::Function::numel_in() const  "
28776 
28777 Get number of input elements.
28778 
28779 For a particular input or for all of the inputs
28780 
28781 ";
28782 
28783 %feature("docstring")  casadi::Function::numel_in(casadi_int ind) const  "
28784 
28785 Get number of input elements.
28786 
28787 For a particular input or for all of the inputs
28788 
28789 ";
28790 
28791 %feature("docstring")  casadi::Function::numel_in(const std::string &iname)
28792 const  "
28793 
28794 Get number of input elements.
28795 
28796 For a particular input or for all of the inputs
28797 
28798 ";
28799 
28800 %feature("docstring")  casadi::Function::serialize(const Dict &opts=Dict())
28801 const  "
28802 
28803 Serialize.
28804 
28805 ";
28806 
28807 %feature("docstring")  casadi::Function::sz_res() const  "
28808 
28809 Get required length of res field.
28810 
28811 ";
28812 
28813 %feature("docstring")  casadi::SharedObject::is_null() const  "
28814 
28815 Is a null pointer?
28816 
28817 ";
28818 
28819 %feature("docstring")  casadi::Function::generate_in(const std::string
28820 &fname, const std::vector< DM > &arg) "
28821 
28822 Export an input file that can be passed to generate C code with a main.
28823 
28824 generate_out  convert_in to convert between dict/map and vector
28825 
28826 ";
28827 
28828 %feature("docstring")  casadi::Function::generate_in(const std::string
28829 &fname) "
28830 
28831 Export an input file that can be passed to generate C code with a main.
28832 
28833 generate_out  convert_in to convert between dict/map and vector
28834 
28835 ";
28836 
28837 %feature("docstring")  casadi::Function::forward(casadi_int nfwd) const  "
28838 
28839 Get a function that calculates nfwd forward derivatives.
28840 
28841 Returns a function with n_in + n_out + n_in inputs and nfwd outputs. The
28842 first n_in inputs correspond to nondifferentiated inputs. The next n_out
28843 inputs correspond to nondifferentiated outputs. and the last n_in inputs
28844 correspond to forward seeds, stacked horizontally The n_out outputs
28845 correspond to forward sensitivities, stacked horizontally. * (n_in = n_in(),
28846 n_out = n_out())
28847 
28848 The functions returned are cached, meaning that if called multiple timed
28849 with the same value, then multiple references to the same function will be
28850 returned.
28851 
28852 ";
28853 
28854 %feature("docstring") casadi::casadi_forward "
28855 
28856 Get a function that calculates nfwd forward derivatives.
28857 
28858 Returns a function with n_in + n_out + n_in inputs and nfwd outputs. The
28859 first n_in inputs correspond to nondifferentiated inputs. The next n_out
28860 inputs correspond to nondifferentiated outputs. and the last n_in inputs
28861 correspond to forward seeds, stacked horizontally The n_out outputs
28862 correspond to forward sensitivities, stacked horizontally. * (n_in = n_in(),
28863 n_out = n_out())
28864 
28865 The functions returned are cached, meaning that if called multiple timed
28866 with the same value, then multiple references to the same function will be
28867 returned.
28868 
28869 ";
28870 
28871 %feature("docstring")  casadi::Function::casadi_forward "
28872 
28873 Get a function that calculates nfwd forward derivatives.
28874 
28875 Returns a function with n_in + n_out + n_in inputs and nfwd outputs. The
28876 first n_in inputs correspond to nondifferentiated inputs. The next n_out
28877 inputs correspond to nondifferentiated outputs. and the last n_in inputs
28878 correspond to forward seeds, stacked horizontally The n_out outputs
28879 correspond to forward sensitivities, stacked horizontally. * (n_in = n_in(),
28880 n_out = n_out())
28881 
28882 The functions returned are cached, meaning that if called multiple timed
28883 with the same value, then multiple references to the same function will be
28884 returned.
28885 
28886 ";
28887 
28888 %feature("docstring")  casadi::Function::n_out() const  "
28889 
28890 Get the number of function outputs.
28891 
28892 ";
28893 
28894 %feature("docstring")  casadi::Function::instruction_output(casadi_int k)
28895 const  "
28896 
28897 Location in the work vector for the output of the instruction
28898 (SXFunction/MXFunction)
28899 
28900 ";
28901 
28902 %feature("docstring")  casadi::Function::uses_output() const  "
28903 
28904 Do the derivative functions need nondifferentiated outputs?
28905 
28906 ";
28907 
28908 %feature("docstring")  casadi::SharedObject::print_ptr(std::ostream
28909 &stream=casadi::uout()) const  "
28910 
28911 [INTERNAL]  Print the pointer to the internal class
28912 
28913 ";
28914 
28915 %feature("docstring")  casadi::Function::min_in(casadi_int ind) const  "
28916 
28917 Get smallest input value.
28918 
28919 ";
28920 
28921 %feature("docstring")  casadi::Function::assert_size_out(casadi_int i,
28922 casadi_int nrow, casadi_int ncol) const  "
28923 
28924 Assert that an output dimension is equal so some given value.
28925 
28926 ";
28927 
28928 %feature("docstring") casadi::Function::~Function "
28929 
28930 Destructor.
28931 
28932 ";
28933 
28934 %feature("docstring") casadi::Function::__hash__ "
28935 
28936 Returns a number that is unique for a given Node. If the Object does not
28937 point to any node, \"0\" is returned.
28938 
28939 ";
28940 
28941 %feature("docstring")  casadi::Function::index_out(const std::string &name)
28942 const  "
28943 
28944 Find the index for a string describing a particular entry of an output
28945 scheme.
28946 
28947 example: schemeEntry(\"x_opt\") -> returns NLPSOL_X if FunctionInternal
28948 adheres to SCHEME_NLPINput
28949 
28950 ";
28951 
28952 %feature("docstring")  casadi::Function::free_mx() const  "
28953 
28954 Get all the free variables of the function.
28955 
28956 ";
28957 
28958 %feature("docstring")  casadi::Function::export_code(const std::string
28959 &lang, const std::string &fname, const Dict &options=Dict()) const  "
28960 
28961 Export function in specific language.
28962 
28963 Only allowed for (a subset of) SX/MX Functions
28964 
28965 ";
28966 
28967 %feature("docstring")  casadi::Function::export_code(const std::string
28968 &lang, const Dict &options=Dict()) const  "
28969 
28970 Export function in specific language.
28971 
28972 Only allowed for (a subset of) SX/MX Functions
28973 
28974 ";
28975 
28976 %feature("docstring")  casadi::Function::is_diff_in(casadi_int ind) const  "
28977 
28978 Get differentiability of inputs/output.
28979 
28980 ";
28981 
28982 %feature("docstring")  casadi::Function::is_diff_in() const  "
28983 
28984 Get differentiability of inputs/output.
28985 
28986 ";
28987 
28988 %feature("docstring")  casadi::SharedObject::class_name() const  "
28989 
28990 Get class name.
28991 
28992 ";
28993 
28994 %feature("docstring")  casadi::Function::instruction_input(casadi_int k)
28995 const  "
28996 
28997 Locations in the work vector for the inputs of the instruction
28998 (SXFunction/MXFunction)
28999 
29000 ";
29001 
29002 %feature("docstring")  casadi::Function::info() const  "
29003 
29004 Obtain information about function
29005 
29006 ";
29007 
29008 %feature("docstring")  casadi::Function::slice(const std::string &name,
29009 const std::vector< casadi_int > &order_in, const std::vector< casadi_int >
29010 &order_out, const Dict &opts=Dict()) const  "
29011 
29012 returns a new function with a selection of inputs/outputs of the original
29013 
29014 ";
29015 
29016 %feature("docstring") casadi::casadi_slice "
29017 
29018 returns a new function with a selection of inputs/outputs of the original
29019 
29020 ";
29021 
29022 %feature("docstring")  casadi::Function::casadi_slice "
29023 
29024 returns a new function with a selection of inputs/outputs of the original
29025 
29026 ";
29027 
29028 %feature("docstring")  casadi::Function::mapsum(const std::vector< MX > &x,
29029 const std::string &parallelization="serial") const  "
29030 
29031 Evaluate symbolically in parallel and sum (matrix graph)
29032 
29033 Parameters:
29034 -----------
29035 
29036 parallelization:  Type of parallelization used: unroll|serial|openmp
29037 
29038 ";
29039 
29040 %feature("docstring")  casadi::Function::nnz_out() const  "
29041 
29042 Get number of output nonzeros.
29043 
29044 For a particular output or for all of the outputs
29045 
29046 ";
29047 
29048 %feature("docstring")  casadi::Function::nnz_out(casadi_int ind) const  "
29049 
29050 Get number of output nonzeros.
29051 
29052 For a particular output or for all of the outputs
29053 
29054 ";
29055 
29056 %feature("docstring")  casadi::Function::nnz_out(const std::string &oname)
29057 const  "
29058 
29059 Get number of output nonzeros.
29060 
29061 For a particular output or for all of the outputs
29062 
29063 ";
29064 
29065 %feature("docstring")  casadi::Function::sparsity_jac(casadi_int iind,
29066 casadi_int oind, bool compact=false, bool symmetric=false) const  "
29067 
29068 Get, if necessary generate, the sparsity of a Jacobian block
29069 
29070 ";
29071 
29072 %feature("docstring")  casadi::Function::sparsity_jac(const std::string
29073 &iind, casadi_int oind=0, bool compact=false, bool symmetric=false) const  "
29074 
29075 Get, if necessary generate, the sparsity of a Jacobian block
29076 
29077 ";
29078 
29079 %feature("docstring")  casadi::Function::sparsity_jac(casadi_int iind, const
29080 std::string &oind, bool compact=false, bool symmetric=false) const  "
29081 
29082 Get, if necessary generate, the sparsity of a Jacobian block
29083 
29084 ";
29085 
29086 %feature("docstring")  casadi::Function::sparsity_jac(const std::string
29087 &iind, const std::string &oind, bool compact=false, bool symmetric=false)
29088 const  "
29089 
29090 Get, if necessary generate, the sparsity of a Jacobian block
29091 
29092 ";
29093 
29094 %feature("docstring")  casadi::Function::index_in(const std::string &name)
29095 const  "
29096 
29097 Find the index for a string describing a particular entry of an input
29098 scheme.
29099 
29100 example: schemeEntry(\"x_opt\") -> returns NLPSOL_X if FunctionInternal
29101 adheres to SCHEME_NLPINput
29102 
29103 ";
29104 
29105 %feature("docstring")  casadi::Function::size_out(casadi_int ind) const  "
29106 
29107 Get output dimension.
29108 
29109 ";
29110 
29111 %feature("docstring")  casadi::Function::size_out(const std::string &oname)
29112 const  "
29113 
29114 Get output dimension.
29115 
29116 ";
29117 
29118 %feature("docstring")  casadi::Function::checkout() const  "
29119 
29120 Checkout a memory object.
29121 
29122 ";
29123 
29124 %feature("docstring")  casadi::Function::print_option(const std::string
29125 &name, std::ostream &stream=casadi::uout()) const  "
29126 
29127 Print all information there is to know about a certain option.
29128 
29129 ";
29130 
29131 %feature("docstring")  casadi::Function::hessian_old(casadi_int iind,
29132 casadi_int oind) const  "
29133 
29134 Generate a Hessian function of output oind with respect to input iind.
29135 
29136 Parameters:
29137 -----------
29138 
29139 iind:  The index of the input
29140 
29141 oind:  The index of the output Legacy function: To be deprecated in a future
29142 version of CasADi. Exists only for compatibility with Function::hessian pre-
29143 CasADi 3.2
29144 
29145 ";
29146 
29147 %feature("docstring")  casadi::Function::map(const std::string &name, const
29148 std::string &parallelization, casadi_int n, const std::vector< casadi_int >
29149 &reduce_in, const std::vector< casadi_int > &reduce_out, const Dict
29150 &opts=Dict()) const  "
29151 
29152 Map with reduction A subset of the inputs are non-repeated and a subset of
29153 the outputs summed up.
29154 
29155 ";
29156 
29157 %feature("docstring") casadi::casadi_map "
29158 
29159 Map with reduction A subset of the inputs are non-repeated and a subset of
29160 the outputs summed up.
29161 
29162 ";
29163 
29164 %feature("docstring")  casadi::Function::casadi_map "
29165 
29166 Map with reduction A subset of the inputs are non-repeated and a subset of
29167 the outputs summed up.
29168 
29169 ";
29170 
29171 %feature("docstring")  casadi::Function::map(const std::string &name, const
29172 std::string &parallelization, casadi_int n, const std::vector< std::string >
29173 &reduce_in, const std::vector< std::string > &reduce_out, const Dict
29174 &opts=Dict()) const  "
29175 
29176 Map with reduction A subset of the inputs are non-repeated and a subset of
29177 the outputs summed up.
29178 
29179 ";
29180 
29181 %feature("docstring") casadi::casadi_map "
29182 
29183 Map with reduction A subset of the inputs are non-repeated and a subset of
29184 the outputs summed up.
29185 
29186 ";
29187 
29188 %feature("docstring")  casadi::Function::casadi_map "
29189 
29190 Map with reduction A subset of the inputs are non-repeated and a subset of
29191 the outputs summed up.
29192 
29193 ";
29194 
29195 %feature("docstring")  casadi::Function::map(casadi_int n, const
29196 std::vector< bool > &reduce_in, const std::vector< bool >
29197 &reduce_out=std::vector< bool >(), const Dict &opts=Dict()) const  "
29198 
29199 Map with reduction A subset of the inputs are non-repeated and a subset of
29200 the outputs summed up.
29201 
29202 ";
29203 
29204 %feature("docstring") casadi::casadi_map "
29205 
29206 Map with reduction A subset of the inputs are non-repeated and a subset of
29207 the outputs summed up.
29208 
29209 ";
29210 
29211 %feature("docstring")  casadi::Function::casadi_map "
29212 
29213 Map with reduction A subset of the inputs are non-repeated and a subset of
29214 the outputs summed up.
29215 
29216 ";
29217 
29218 %feature("docstring")  casadi::Function::map(casadi_int n, const std::string
29219 &parallelization="serial") const  "
29220 
29221 Create a mapped version of this function.
29222 
29223 Suppose the function has a signature of:
29224 
29225 ::
29226 
29227      f: (a, p) -> ( s )
29228 
29229 
29230 
29231 
29232 The the mapped version has the signature:
29233 
29234 ::
29235 
29236      F: (A, P) -> (S )
29237 
29238       with
29239           A: horzcat([a0, a1, ..., a_(N-1)])
29240           P: horzcat([p0, p1, ..., p_(N-1)])
29241           S: horzcat([s0, s1, ..., s_(N-1)])
29242       and
29243           s0 <- f(a0, p0)
29244           s1 <- f(a1, p1)
29245           ...
29246           s_(N-1) <- f(a_(N-1), p_(N-1))
29247 
29248 
29249 
29250 
29251 Parameters:
29252 -----------
29253 
29254 parallelization:  Type of parallelization used: unroll|serial|openmp
29255 
29256 ";
29257 
29258 %feature("docstring") casadi::casadi_map "
29259 
29260 Create a mapped version of this function.
29261 
29262 Suppose the function has a signature of:
29263 
29264 ::
29265 
29266      f: (a, p) -> ( s )
29267 
29268 
29269 
29270 
29271 The the mapped version has the signature:
29272 
29273 ::
29274 
29275      F: (A, P) -> (S )
29276 
29277       with
29278           A: horzcat([a0, a1, ..., a_(N-1)])
29279           P: horzcat([p0, p1, ..., p_(N-1)])
29280           S: horzcat([s0, s1, ..., s_(N-1)])
29281       and
29282           s0 <- f(a0, p0)
29283           s1 <- f(a1, p1)
29284           ...
29285           s_(N-1) <- f(a_(N-1), p_(N-1))
29286 
29287 
29288 
29289 
29290 Parameters:
29291 -----------
29292 
29293 parallelization:  Type of parallelization used: unroll|serial|openmp
29294 
29295 ";
29296 
29297 %feature("docstring")  casadi::Function::casadi_map "
29298 
29299 Create a mapped version of this function.
29300 
29301 Suppose the function has a signature of:
29302 
29303 ::
29304 
29305      f: (a, p) -> ( s )
29306 
29307 
29308 
29309 
29310 The the mapped version has the signature:
29311 
29312 ::
29313 
29314      F: (A, P) -> (S )
29315 
29316       with
29317           A: horzcat([a0, a1, ..., a_(N-1)])
29318           P: horzcat([p0, p1, ..., p_(N-1)])
29319           S: horzcat([s0, s1, ..., s_(N-1)])
29320       and
29321           s0 <- f(a0, p0)
29322           s1 <- f(a1, p1)
29323           ...
29324           s_(N-1) <- f(a_(N-1), p_(N-1))
29325 
29326 
29327 
29328 
29329 Parameters:
29330 -----------
29331 
29332 parallelization:  Type of parallelization used: unroll|serial|openmp
29333 
29334 ";
29335 
29336 %feature("docstring")  casadi::Function::sx_in(casadi_int iind) const  "
29337 
29338 Get symbolic primitives equivalent to the input expressions There is no
29339 guarantee that subsequent calls return unique answers.
29340 
29341 ";
29342 
29343 %feature("docstring")  casadi::Function::sx_in(const std::string &iname)
29344 const  "
29345 
29346 Get symbolic primitives equivalent to the input expressions There is no
29347 guarantee that subsequent calls return unique answers.
29348 
29349 ";
29350 
29351 %feature("docstring")  casadi::Function::sx_in() const  "
29352 
29353 Get symbolic primitives equivalent to the input expressions There is no
29354 guarantee that subsequent calls return unique answers.
29355 
29356 ";
29357 
29358 %feature("docstring")  casadi::Function::size1_in(casadi_int ind) const  "
29359 
29360 Get input dimension.
29361 
29362 ";
29363 
29364 %feature("docstring")  casadi::Function::size1_in(const std::string &iname)
29365 const  "
29366 
29367 Get input dimension.
29368 
29369 ";
29370 
29371 %feature("docstring")  casadi::Function::instructions_sx() const  "
29372 
29373 Get the SX node corresponding to all instructions ( SXFunction)
29374 
29375 Note: input and output instructions have no SX representation. This method
29376 returns nan for those instructions.
29377 
29378 ";
29379 
29380 %feature("docstring")  casadi::Function::nz_to_in(const std::vector< double
29381 > &arg) const  "
29382 
29383 Convert from/to flat vector of input/output nonzeros.
29384 
29385 ";
29386 
29387 %feature("docstring")  casadi::Function::sz_iw() const  "
29388 
29389 Get required length of iw field.
29390 
29391 ";
29392 
29393 %feature("docstring")  casadi::Function::is_a(const std::string &type, bool
29394 recursive=true) const  "
29395 
29396 Check if the function is of a particular type Optionally check if name
29397 matches one of the base classes (default true)
29398 
29399 ";
29400 
29401 %feature("docstring")  casadi::Function::name_in() const  "
29402 
29403 Get input scheme.
29404 
29405 ";
29406 
29407 %feature("docstring")  casadi::Function::name_in(casadi_int ind) const  "
29408 
29409 Get input scheme name by index.
29410 
29411 ";
29412 
29413 %feature("docstring")  casadi::Function::mx_in(casadi_int ind) const  "
29414 
29415 Get symbolic primitives equivalent to the input expressions There is no
29416 guarantee that subsequent calls return unique answers.
29417 
29418 ";
29419 
29420 %feature("docstring")  casadi::Function::mx_in(const std::string &iname)
29421 const  "
29422 
29423 Get symbolic primitives equivalent to the input expressions There is no
29424 guarantee that subsequent calls return unique answers.
29425 
29426 ";
29427 
29428 %feature("docstring")  casadi::Function::mx_in() const  "
29429 
29430 Get symbolic primitives equivalent to the input expressions There is no
29431 guarantee that subsequent calls return unique answers.
29432 
29433 ";
29434 
29435 %feature("docstring")  casadi::Function::nz_to_out(const std::vector< double
29436 > &arg) const  "
29437 
29438 Convert from/to flat vector of input/output nonzeros.
29439 
29440 ";
29441 
29442 %feature("docstring")  casadi::Function::reverse(casadi_int nadj) const  "
29443 
29444 Get a function that calculates nadj adjoint derivatives.
29445 
29446 Returns a function with n_in + n_out + n_out inputs and n_in outputs. The
29447 first n_in inputs correspond to nondifferentiated inputs. The next n_out
29448 inputs correspond to nondifferentiated outputs. and the last n_out inputs
29449 correspond to adjoint seeds, stacked horizontally The n_in outputs
29450 correspond to adjoint sensitivities, stacked horizontally. * (n_in = n_in(),
29451 n_out = n_out())
29452 
29453 (n_in = n_in(), n_out = n_out())
29454 
29455 The functions returned are cached, meaning that if called multiple timed
29456 with the same value, then multiple references to the same function will be
29457 returned.
29458 
29459 ";
29460 
29461 %feature("docstring") casadi::casadi_reverse "
29462 
29463 Get a function that calculates nadj adjoint derivatives.
29464 
29465 Returns a function with n_in + n_out + n_out inputs and n_in outputs. The
29466 first n_in inputs correspond to nondifferentiated inputs. The next n_out
29467 inputs correspond to nondifferentiated outputs. and the last n_out inputs
29468 correspond to adjoint seeds, stacked horizontally The n_in outputs
29469 correspond to adjoint sensitivities, stacked horizontally. * (n_in = n_in(),
29470 n_out = n_out())
29471 
29472 (n_in = n_in(), n_out = n_out())
29473 
29474 The functions returned are cached, meaning that if called multiple timed
29475 with the same value, then multiple references to the same function will be
29476 returned.
29477 
29478 ";
29479 
29480 %feature("docstring")  casadi::Function::casadi_reverse "
29481 
29482 Get a function that calculates nadj adjoint derivatives.
29483 
29484 Returns a function with n_in + n_out + n_out inputs and n_in outputs. The
29485 first n_in inputs correspond to nondifferentiated inputs. The next n_out
29486 inputs correspond to nondifferentiated outputs. and the last n_out inputs
29487 correspond to adjoint seeds, stacked horizontally The n_in outputs
29488 correspond to adjoint sensitivities, stacked horizontally. * (n_in = n_in(),
29489 n_out = n_out())
29490 
29491 (n_in = n_in(), n_out = n_out())
29492 
29493 The functions returned are cached, meaning that if called multiple timed
29494 with the same value, then multiple references to the same function will be
29495 returned.
29496 
29497 ";
29498 
29499 %feature("docstring") casadi::Function "
29500 
29501 Function object A Function instance is a general multiple-input, multiple-
29502 output function where each input and output can be a sparse matrix. .
29503 
29504 For an introduction to this class, see the CasADi user guide. Function is a
29505 reference counted and immutable class; copying a class instance is very
29506 cheap and its behavior (with some exceptions) is not affected by calling its
29507 member functions. Joel Andersson >List of available options
29508 
29509 +------------------+-----------------+------------------+------------------+
29510 |        Id        |      Type       |   Description    |     Used in      |
29511 +==================+=================+==================+==================+
29512 | ad_weight        | OT_DOUBLE       | Weighting factor | casadi::Function |
29513 |                  |                 | for derivative   | Internal         |
29514 |                  |                 | calculation.When |                  |
29515 |                  |                 | there is an      |                  |
29516 |                  |                 | option of either |                  |
29517 |                  |                 | using forward or |                  |
29518 |                  |                 | reverse mode     |                  |
29519 |                  |                 | directional      |                  |
29520 |                  |                 | derivatives, the |                  |
29521 |                  |                 | condition ad_wei |                  |
29522 |                  |                 | ght*nf<=(1-ad_we |                  |
29523 |                  |                 | ight)*na is used |                  |
29524 |                  |                 | where nf and na  |                  |
29525 |                  |                 | are estimates of |                  |
29526 |                  |                 | the number of    |                  |
29527 |                  |                 | forward/reverse  |                  |
29528 |                  |                 | mode directional |                  |
29529 |                  |                 | derivatives      |                  |
29530 |                  |                 | needed. By       |                  |
29531 |                  |                 | default,         |                  |
29532 |                  |                 | ad_weight is     |                  |
29533 |                  |                 | calculated       |                  |
29534 |                  |                 | automatically,   |                  |
29535 |                  |                 | but this can be  |                  |
29536 |                  |                 | overridden by    |                  |
29537 |                  |                 | setting this     |                  |
29538 |                  |                 | option. In       |                  |
29539 |                  |                 | particular, 0    |                  |
29540 |                  |                 | means forcing    |                  |
29541 |                  |                 | forward mode and |                  |
29542 |                  |                 | 1 forcing        |                  |
29543 |                  |                 | reverse mode.    |                  |
29544 |                  |                 | Leave unset for  |                  |
29545 |                  |                 | (class specific) |                  |
29546 |                  |                 | heuristics.      |                  |
29547 +------------------+-----------------+------------------+------------------+
29548 | ad_weight_sp     | OT_DOUBLE       | Weighting factor | casadi::Function |
29549 |                  |                 | for sparsity     | Internal         |
29550 |                  |                 | pattern          |                  |
29551 |                  |                 | calculation calc |                  |
29552 |                  |                 | ulation.Override |                  |
29553 |                  |                 | s default        |                  |
29554 |                  |                 | behavior. Set to |                  |
29555 |                  |                 | 0 and 1 to force |                  |
29556 |                  |                 | forward and      |                  |
29557 |                  |                 | reverse mode     |                  |
29558 |                  |                 | respectively.    |                  |
29559 |                  |                 | Cf. option       |                  |
29560 |                  |                 | \"ad_weight\".     |                  |
29561 |                  |                 | When set to -1,  |                  |
29562 |                  |                 | sparsity is      |                  |
29563 |                  |                 | completely       |                  |
29564 |                  |                 | ignored and      |                  |
29565 |                  |                 | dense matrices   |                  |
29566 |                  |                 | are used.        |                  |
29567 +------------------+-----------------+------------------+------------------+
29568 | always_inline    | OT_BOOL         | Force inlining.  | casadi::Function |
29569 |                  |                 |                  | Internal         |
29570 +------------------+-----------------+------------------+------------------+
29571 | compiler         | OT_STRING       | Just-in-time     | casadi::Function |
29572 |                  |                 | compiler plugin  | Internal         |
29573 |                  |                 | to be used.      |                  |
29574 +------------------+-----------------+------------------+------------------+
29575 | custom_jacobian  | OT_FUNCTION     | Override         | casadi::Function |
29576 |                  |                 | CasADi's AD. Use | Internal         |
29577 |                  |                 | together with    |                  |
29578 |                  |                 | 'jac_penalty':   |                  |
29579 |                  |                 | 0. Note: Highly  |                  |
29580 |                  |                 | experimental.    |                  |
29581 |                  |                 | Syntax may break |                  |
29582 |                  |                 | often.           |                  |
29583 +------------------+-----------------+------------------+------------------+
29584 | derivative_of    | OT_FUNCTION     | The function is  | casadi::Function |
29585 |                  |                 | a derivative of  | Internal         |
29586 |                  |                 | another          |                  |
29587 |                  |                 | function. The    |                  |
29588 |                  |                 | type of          |                  |
29589 |                  |                 | derivative       |                  |
29590 |                  |                 | (directional     |                  |
29591 |                  |                 | derivative,      |                  |
29592 |                  |                 | Jacobian) is     |                  |
29593 |                  |                 | inferred from    |                  |
29594 |                  |                 | the function     |                  |
29595 |                  |                 | name.            |                  |
29596 +------------------+-----------------+------------------+------------------+
29597 | dump             | OT_BOOL         | Dump function to | casadi::Function |
29598 |                  |                 | file upon first  | Internal         |
29599 |                  |                 | evaluation.      |                  |
29600 |                  |                 | [false]          |                  |
29601 +------------------+-----------------+------------------+------------------+
29602 | dump_dir         | OT_STRING       | Directory to     | casadi::Function |
29603 |                  |                 | dump             | Internal         |
29604 |                  |                 | inputs/outputs   |                  |
29605 |                  |                 | to. Make sure    |                  |
29606 |                  |                 | the directory    |                  |
29607 |                  |                 | exists [.]       |                  |
29608 +------------------+-----------------+------------------+------------------+
29609 | dump_format      | OT_STRING       | Choose file      | casadi::Function |
29610 |                  |                 | format to dump   | Internal         |
29611 |                  |                 | matrices. See    |                  |
29612 |                  |                 | DM.from_file     |                  |
29613 |                  |                 | [mtx]            |                  |
29614 +------------------+-----------------+------------------+------------------+
29615 | dump_in          | OT_BOOL         | Dump numerical   | casadi::Function |
29616 |                  |                 | values of inputs | Internal         |
29617 |                  |                 | to file          |                  |
29618 |                  |                 | (readable with   |                  |
29619 |                  |                 | DM.from_file )   |                  |
29620 |                  |                 | [default: false] |                  |
29621 +------------------+-----------------+------------------+------------------+
29622 | dump_out         | OT_BOOL         | Dump numerical   | casadi::Function |
29623 |                  |                 | values of        | Internal         |
29624 |                  |                 | outputs to file  |                  |
29625 |                  |                 | (readable with   |                  |
29626 |                  |                 | DM.from_file )   |                  |
29627 |                  |                 | [default: false] |                  |
29628 +------------------+-----------------+------------------+------------------+
29629 | enable_fd        | OT_BOOL         | Enable           | casadi::Function |
29630 |                  |                 | derivative       | Internal         |
29631 |                  |                 | calculation by   |                  |
29632 |                  |                 | finite           |                  |
29633 |                  |                 | differencing.    |                  |
29634 |                  |                 | [default:        |                  |
29635 |                  |                 | false]]          |                  |
29636 +------------------+-----------------+------------------+------------------+
29637 | enable_forward   | OT_BOOL         | Enable           | casadi::Function |
29638 |                  |                 | derivative       | Internal         |
29639 |                  |                 | calculation      |                  |
29640 |                  |                 | using generated  |                  |
29641 |                  |                 | functions for    |                  |
29642 |                  |                 | Jacobian-times-  |                  |
29643 |                  |                 | vector products  |                  |
29644 |                  |                 | - typically      |                  |
29645 |                  |                 | using forward    |                  |
29646 |                  |                 | mode AD - if     |                  |
29647 |                  |                 | available.       |                  |
29648 |                  |                 | [default: true]  |                  |
29649 +------------------+-----------------+------------------+------------------+
29650 | enable_jacobian  | OT_BOOL         | Enable           | casadi::Function |
29651 |                  |                 | derivative       | Internal         |
29652 |                  |                 | calculation      |                  |
29653 |                  |                 | using generated  |                  |
29654 |                  |                 | functions for    |                  |
29655 |                  |                 | Jacobians of all |                  |
29656 |                  |                 | differentiable   |                  |
29657 |                  |                 | outputs with     |                  |
29658 |                  |                 | respect to all   |                  |
29659 |                  |                 | differentiable   |                  |
29660 |                  |                 | inputs - if      |                  |
29661 |                  |                 | available.       |                  |
29662 |                  |                 | [default: true]  |                  |
29663 +------------------+-----------------+------------------+------------------+
29664 | enable_reverse   | OT_BOOL         | Enable           | casadi::Function |
29665 |                  |                 | derivative       | Internal         |
29666 |                  |                 | calculation      |                  |
29667 |                  |                 | using generated  |                  |
29668 |                  |                 | functions for    |                  |
29669 |                  |                 | transposed       |                  |
29670 |                  |                 | Jacobian-times-  |                  |
29671 |                  |                 | vector products  |                  |
29672 |                  |                 | - typically      |                  |
29673 |                  |                 | using reverse    |                  |
29674 |                  |                 | mode AD - if     |                  |
29675 |                  |                 | available.       |                  |
29676 |                  |                 | [default: true]  |                  |
29677 +------------------+-----------------+------------------+------------------+
29678 | fd_method        | OT_STRING       | Method for       | casadi::Function |
29679 |                  |                 | finite           | Internal         |
29680 |                  |                 | differencing     |                  |
29681 |                  |                 | [default         |                  |
29682 |                  |                 | 'central']       |                  |
29683 +------------------+-----------------+------------------+------------------+
29684 | fd_options       | OT_DICT         | Options to be    | casadi::Function |
29685 |                  |                 | passed to the    | Internal         |
29686 |                  |                 | finite           |                  |
29687 |                  |                 | difference       |                  |
29688 |                  |                 | instance         |                  |
29689 +------------------+-----------------+------------------+------------------+
29690 | forward_options  | OT_DICT         | Options to be    | casadi::Function |
29691 |                  |                 | passed to a      | Internal         |
29692 |                  |                 | forward mode     |                  |
29693 |                  |                 | constructor      |                  |
29694 +------------------+-----------------+------------------+------------------+
29695 | gather_stats     | OT_BOOL         | Deprecated       | casadi::Function |
29696 |                  |                 | option           | Internal         |
29697 |                  |                 | (ignored):       |                  |
29698 |                  |                 | Statistics are   |                  |
29699 |                  |                 | now always       |                  |
29700 |                  |                 | collected.       |                  |
29701 +------------------+-----------------+------------------+------------------+
29702 | input_scheme     | OT_STRINGVECTOR | Deprecated       | casadi::Function |
29703 |                  |                 | option (ignored) | Internal         |
29704 +------------------+-----------------+------------------+------------------+
29705 | inputs_check     | OT_BOOL         | Throw exceptions | casadi::Function |
29706 |                  |                 | when the         | Internal         |
29707 |                  |                 | numerical values |                  |
29708 |                  |                 | of the inputs    |                  |
29709 |                  |                 | don't make sense |                  |
29710 +------------------+-----------------+------------------+------------------+
29711 | is_diff_in       | OT_BOOLVECTOR   | Indicate for     | casadi::Function |
29712 |                  |                 | each input if it | Internal         |
29713 |                  |                 | should be        |                  |
29714 |                  |                 | differentiable.  |                  |
29715 +------------------+-----------------+------------------+------------------+
29716 | is_diff_out      | OT_BOOLVECTOR   | Indicate for     | casadi::Function |
29717 |                  |                 | each output if   | Internal         |
29718 |                  |                 | it should be     |                  |
29719 |                  |                 | differentiable.  |                  |
29720 +------------------+-----------------+------------------+------------------+
29721 | jac_penalty      | OT_DOUBLE       | When requested   | casadi::Function |
29722 |                  |                 | for a number of  | Internal         |
29723 |                  |                 | forward/reverse  |                  |
29724 |                  |                 | directions, it   |                  |
29725 |                  |                 | may be cheaper   |                  |
29726 |                  |                 | to compute first |                  |
29727 |                  |                 | the full         |                  |
29728 |                  |                 | jacobian and     |                  |
29729 |                  |                 | then multiply    |                  |
29730 |                  |                 | with seeds,      |                  |
29731 |                  |                 | rather than      |                  |
29732 |                  |                 | obtain the       |                  |
29733 |                  |                 | requested        |                  |
29734 |                  |                 | directions in a  |                  |
29735 |                  |                 | straightforward  |                  |
29736 |                  |                 | manner. Casadi   |                  |
29737 |                  |                 | uses a heuristic |                  |
29738 |                  |                 | to decide which  |                  |
29739 |                  |                 | is cheaper. A    |                  |
29740 |                  |                 | high value of    |                  |
29741 |                  |                 | 'jac_penalty'    |                  |
29742 |                  |                 | makes it less    |                  |
29743 |                  |                 | likely for the   |                  |
29744 |                  |                 | heurstic to      |                  |
29745 |                  |                 | chose the full   |                  |
29746 |                  |                 | Jacobian         |                  |
29747 |                  |                 | strategy. The    |                  |
29748 |                  |                 | special value -1 |                  |
29749 |                  |                 | indicates never  |                  |
29750 |                  |                 | to use the full  |                  |
29751 |                  |                 | Jacobian         |                  |
29752 |                  |                 | strategy         |                  |
29753 +------------------+-----------------+------------------+------------------+
29754 | jit              | OT_BOOL         | Use just-in-time | casadi::Function |
29755 |                  |                 | compiler to      | Internal         |
29756 |                  |                 | speed up the     |                  |
29757 |                  |                 | evaluation       |                  |
29758 +------------------+-----------------+------------------+------------------+
29759 | jit_cleanup      | OT_BOOL         | Cleanup up the   | casadi::Function |
29760 |                  |                 | temporary source | Internal         |
29761 |                  |                 | file that jit    |                  |
29762 |                  |                 | creates.         |                  |
29763 |                  |                 | Default: true    |                  |
29764 +------------------+-----------------+------------------+------------------+
29765 | jit_name         | OT_STRING       | The file name    | casadi::Function |
29766 |                  |                 | used to write    | Internal         |
29767 |                  |                 | out code. The    |                  |
29768 |                  |                 | actual file      |                  |
29769 |                  |                 | names used       |                  |
29770 |                  |                 | depend on 'jit_t |                  |
29771 |                  |                 | emp_suffix' and  |                  |
29772 |                  |                 | include          |                  |
29773 |                  |                 | extensions.      |                  |
29774 |                  |                 | Default:         |                  |
29775 |                  |                 | 'jit_tmp'        |                  |
29776 +------------------+-----------------+------------------+------------------+
29777 | jit_options      | OT_DICT         | Options to be    | casadi::Function |
29778 |                  |                 | passed to the    | Internal         |
29779 |                  |                 | jit compiler.    |                  |
29780 +------------------+-----------------+------------------+------------------+
29781 | jit_serialize    | OT_STRING       | Specify          | casadi::Function |
29782 |                  |                 | behaviour when   | Internal         |
29783 |                  |                 | serializing a    |                  |
29784 |                  |                 | jitted function: |                  |
29785 |                  |                 | SOURCE|link|embe |                  |
29786 |                  |                 | d.               |                  |
29787 +------------------+-----------------+------------------+------------------+
29788 | jit_temp_suffix  | OT_BOOL         | Use a temporary  | casadi::Function |
29789 |                  |                 | (seemingly       | Internal         |
29790 |                  |                 | random) filename |                  |
29791 |                  |                 | suffix for       |                  |
29792 |                  |                 | generated code   |                  |
29793 |                  |                 | and libraries.   |                  |
29794 |                  |                 | This is desired  |                  |
29795 |                  |                 | for thread-      |                  |
29796 |                  |                 | safety. This     |                  |
29797 |                  |                 | behaviour may    |                  |
29798 |                  |                 | defeat caching   |                  |
29799 |                  |                 | compiler         |                  |
29800 |                  |                 | wrappers.        |                  |
29801 |                  |                 | Default: true    |                  |
29802 +------------------+-----------------+------------------+------------------+
29803 | max_num_dir      | OT_INT          | Specify the      | casadi::Function |
29804 |                  |                 | maximum number   | Internal         |
29805 |                  |                 | of directions    |                  |
29806 |                  |                 | for derivative   |                  |
29807 |                  |                 | functions.       |                  |
29808 |                  |                 | Overrules the    |                  |
29809 |                  |                 | builtin optimize |                  |
29810 |                  |                 | d_num_dir.       |                  |
29811 +------------------+-----------------+------------------+------------------+
29812 | never_inline     | OT_BOOL         | Forbid inlining. | casadi::Function |
29813 |                  |                 |                  | Internal         |
29814 +------------------+-----------------+------------------+------------------+
29815 | output_scheme    | OT_STRINGVECTOR | Deprecated       | casadi::Function |
29816 |                  |                 | option (ignored) | Internal         |
29817 +------------------+-----------------+------------------+------------------+
29818 | print_in         | OT_BOOL         | Print numerical  | casadi::Function |
29819 |                  |                 | values of inputs | Internal         |
29820 |                  |                 | [default: false] |                  |
29821 +------------------+-----------------+------------------+------------------+
29822 | print_out        | OT_BOOL         | Print numerical  | casadi::Function |
29823 |                  |                 | values of        | Internal         |
29824 |                  |                 | outputs          |                  |
29825 |                  |                 | [default: false] |                  |
29826 +------------------+-----------------+------------------+------------------+
29827 | print_time       | OT_BOOL         | print            | casadi::Function |
29828 |                  |                 | information      | Internal         |
29829 |                  |                 | about execution  |                  |
29830 |                  |                 | time. Implies    |                  |
29831 |                  |                 | record_time.     |                  |
29832 +------------------+-----------------+------------------+------------------+
29833 | record_time      | OT_BOOL         | record           | casadi::Function |
29834 |                  |                 | information      | Internal         |
29835 |                  |                 | about execution  |                  |
29836 |                  |                 | time, for        |                  |
29837 |                  |                 | retrieval with   |                  |
29838 |                  |                 | stats() .        |                  |
29839 +------------------+-----------------+------------------+------------------+
29840 | regularity_check | OT_BOOL         | Throw exceptions | casadi::Function |
29841 |                  |                 | when NaN or Inf  | Internal         |
29842 |                  |                 | appears during   |                  |
29843 |                  |                 | evaluation       |                  |
29844 +------------------+-----------------+------------------+------------------+
29845 | reverse_options  | OT_DICT         | Options to be    | casadi::Function |
29846 |                  |                 | passed to a      | Internal         |
29847 |                  |                 | reverse mode     |                  |
29848 |                  |                 | constructor      |                  |
29849 +------------------+-----------------+------------------+------------------+
29850 | user_data        | OT_VOIDPTR      | A user-defined   | casadi::Function |
29851 |                  |                 | field that can   | Internal         |
29852 |                  |                 | be used to       |                  |
29853 |                  |                 | identify the     |                  |
29854 |                  |                 | function or pass |                  |
29855 |                  |                 | additional       |                  |
29856 |                  |                 | information      |                  |
29857 +------------------+-----------------+------------------+------------------+
29858 | verbose          | OT_BOOL         | Verbose          | casadi::Function |
29859 |                  |                 | evaluation  for  | Internal         |
29860 |                  |                 | debugging        |                  |
29861 +------------------+-----------------+------------------+------------------+
29862 
29863 C++ includes: function.hpp ";
29864 
29865 %feature("docstring")  casadi::Function::instruction_MX(casadi_int k) const
29866 "
29867 
29868 Get the MX node corresponding to an instruction ( MXFunction)
29869 
29870 ";
29871 
29872 %feature("docstring")  casadi::Function::release(int mem) const  "
29873 
29874 Release a memory object.
29875 
29876 ";
29877 
29878 %feature("docstring")  casadi::Function::generate(const std::string &fname,
29879 const Dict &opts=Dict()) const  "
29880 
29881 Export / Generate C code for the function.
29882 
29883 ";
29884 
29885 %feature("docstring")  casadi::Function::generate(const Dict &opts=Dict())
29886 const  "
29887 
29888 Export / Generate C code for the function.
29889 
29890 ";
29891 
29892 %feature("docstring")  casadi::Function::has_free() const  "
29893 
29894 Does the function have free variables.
29895 
29896 ";
29897 
29898 %feature("docstring")  casadi::Function::assert_size_in(casadi_int i,
29899 casadi_int nrow, casadi_int ncol) const  "
29900 
29901 Assert that an input dimension is equal so some given value.
29902 
29903 ";
29904 
29905 %feature("docstring")  casadi::Function::n_nodes() const  "
29906 
29907 Number of nodes in the algorithm.
29908 
29909 ";
29910 
29911 %feature("docstring")  casadi::Function::is_diff_out(casadi_int ind) const
29912 "
29913 
29914 Get differentiability of inputs/output.
29915 
29916 ";
29917 
29918 %feature("docstring")  casadi::Function::is_diff_out() const  "
29919 
29920 Get differentiability of inputs/output.
29921 
29922 ";
29923 
29924 %feature("docstring")  casadi::Function::size_in(casadi_int ind) const  "
29925 
29926 Get input dimension.
29927 
29928 ";
29929 
29930 %feature("docstring")  casadi::Function::size_in(const std::string &iname)
29931 const  "
29932 
29933 Get input dimension.
29934 
29935 ";
29936 
29937 %feature("docstring")  casadi::Function::jit(const std::string &name, const
29938 std::string &body, const std::vector< std::string > &name_in, const
29939 std::vector< std::string > &name_out, const Dict &opts=Dict()) "
29940 
29941 To resolve ambiguity on some compilers.
29942 
29943 Create a just-in-time compiled function from a C language string The names
29944 and sparsity patterns of all the inputs and outputs must be provided. If
29945 sparsities are not provided, all inputs and outputs are assumed to be
29946 scalar. Only specify the function body, assuming that input and output
29947 nonzeros are stored in arrays with the specified naming convension. The data
29948 type used is 'casadi_real', which is typically equal to 'double` or another
29949 data type with the same API as 'double'.
29950 
29951 Inputs may be null pointers. This means that the all entries are zero.
29952 Outputs may be null points. This means that the corresponding result can be
29953 ignored.
29954 
29955 If an error occurs in the evaluation, issue \"return 1;\";
29956 
29957 The final generated function will have a structure similar to:
29958 
29959 casadi_int fname(const casadi_real** arg, casadi_real** res, casadi_int* iw,
29960 casadi_real* w, void* mem) { const casadi_real *x1, *x2; casadi_real *r1,
29961 *r2; x1 = *arg++; x2 = *arg++; r1 = *res++; r2 = *res++; <FUNCTION_BODY>
29962 return 0; }
29963 
29964 ";
29965 
29966 %feature("docstring")  casadi::Function::jit(const std::string &name, const
29967 std::string &body, const std::vector< std::string > &name_in, const
29968 std::vector< std::string > &name_out, const std::vector< Sparsity >
29969 &sparsity_in, const std::vector< Sparsity > &sparsity_out, const Dict
29970 &opts=Dict()) "
29971 
29972 To resolve ambiguity on some compilers.
29973 
29974 Create a just-in-time compiled function from a C language string The names
29975 and sparsity patterns of all the inputs and outputs must be provided. If
29976 sparsities are not provided, all inputs and outputs are assumed to be
29977 scalar. Only specify the function body, assuming that input and output
29978 nonzeros are stored in arrays with the specified naming convension. The data
29979 type used is 'casadi_real', which is typically equal to 'double` or another
29980 data type with the same API as 'double'.
29981 
29982 Inputs may be null pointers. This means that the all entries are zero.
29983 Outputs may be null points. This means that the corresponding result can be
29984 ignored.
29985 
29986 If an error occurs in the evaluation, issue \"return 1;\";
29987 
29988 The final generated function will have a structure similar to:
29989 
29990 casadi_int fname(const casadi_real** arg, casadi_real** res, casadi_int* iw,
29991 casadi_real* w, void* mem) { const casadi_real *x1, *x2; casadi_real *r1,
29992 *r2; x1 = *arg++; x2 = *arg++; r1 = *res++; r2 = *res++; <FUNCTION_BODY>
29993 return 0; }
29994 
29995 ";
29996 
29997 %feature("docstring")  casadi::Function::size2_out(casadi_int ind) const  "
29998 
29999 Get output dimension.
30000 
30001 ";
30002 
30003 %feature("docstring")  casadi::Function::size2_out(const std::string &oname)
30004 const  "
30005 
30006 Get output dimension.
30007 
30008 ";
30009 
30010 %feature("docstring")  casadi::Function::jac() const  "
30011 
30012 Calculate all Jacobian blocks Generates a function that takes all non-
30013 differentiated inputs and outputs and calculates all Jacobian blocks. Inputs
30014 that are not needed by the routine are all-zero sparse matrices with the
30015 correct dimensions. Output blocks that are not calculated, e.g. if the
30016 corresponding input or output is marked non-differentiated are also all-zero
30017 sparse. The Jacobian blocks are sorted starting by all the blocks for the
30018 first output, then all the blocks for the second output and so on. E.g.
30019 f:(x,y)->(r,s) results in the function jac_f:(x,y,r,s)->(dr_dx, dr_dy,
30020 ds_dx, ds_dy) This function is cached.
30021 
30022 ";
30023 
30024 %feature("docstring")  casadi::Function::convert_in(const std::vector< DM >
30025 &arg) const  "
30026 
30027 Convert from/to input/output lists/map.
30028 
30029 Will raise an error when an unknown key is used or a list has incorrect
30030 size. Does not perform sparsity checking.
30031 
30032 ";
30033 
30034 %feature("docstring")  casadi::Function::convert_in(const DMDict &arg) const
30035 "
30036 
30037 Convert from/to input/output lists/map.
30038 
30039 Will raise an error when an unknown key is used or a list has incorrect
30040 size. Does not perform sparsity checking.
30041 
30042 ";
30043 
30044 %feature("docstring")  casadi::Function::convert_in(const std::vector< SX >
30045 &arg) const  "
30046 
30047 Convert from/to input/output lists/map.
30048 
30049 Will raise an error when an unknown key is used or a list has incorrect
30050 size. Does not perform sparsity checking.
30051 
30052 ";
30053 
30054 %feature("docstring")  casadi::Function::convert_in(const SXDict &arg) const
30055 "
30056 
30057 Convert from/to input/output lists/map.
30058 
30059 Will raise an error when an unknown key is used or a list has incorrect
30060 size. Does not perform sparsity checking.
30061 
30062 ";
30063 
30064 %feature("docstring")  casadi::Function::convert_in(const std::vector< MX >
30065 &arg) const  "
30066 
30067 Convert from/to input/output lists/map.
30068 
30069 Will raise an error when an unknown key is used or a list has incorrect
30070 size. Does not perform sparsity checking.
30071 
30072 ";
30073 
30074 %feature("docstring")  casadi::Function::convert_in(const MXDict &arg) const
30075 "
30076 
30077 Convert from/to input/output lists/map.
30078 
30079 Will raise an error when an unknown key is used or a list has incorrect
30080 size. Does not perform sparsity checking.
30081 
30082 ";
30083 
30084 %feature("docstring")  casadi::Function::size1_out(casadi_int ind) const  "
30085 
30086 Get output dimension.
30087 
30088 ";
30089 
30090 %feature("docstring")  casadi::Function::size1_out(const std::string &oname)
30091 const  "
30092 
30093 Get output dimension.
30094 
30095 ";
30096 
30097 %feature("docstring")  casadi::Function::generate_lifted(Function
30098 &output_vdef_fcn, Function &output_vinit_fcn) const  "
30099 
30100 Extract the functions needed for the Lifted Newton method.
30101 
30102 ";
30103 
30104 %feature("docstring")  casadi::Function::sparsity_in(casadi_int ind) const
30105 "
30106 
30107 Get sparsity of a given input.
30108 
30109 ";
30110 
30111 %feature("docstring")  casadi::Function::sparsity_in(const std::string
30112 &iname) const  "
30113 
30114 Get sparsity of a given input.
30115 
30116 ";
30117 
30118 %feature("docstring")  casadi::Function::which_depends(const std::string
30119 &s_in, const std::vector< std::string > &s_out, casadi_int order=1, bool
30120 tr=false) const  "
30121 
30122 Which variables enter with some order.
30123 
30124 Parameters:
30125 -----------
30126 
30127 order:  Only 1 (linear) and 2 (nonlinear) allowed
30128 
30129 tr:  Flip the relationship. Return which expressions contain the variables
30130 
30131 ";
30132 
30133 %feature("docstring") casadi::casadi_which_depends "
30134 
30135 Which variables enter with some order.
30136 
30137 Parameters:
30138 -----------
30139 
30140 order:  Only 1 (linear) and 2 (nonlinear) allowed
30141 
30142 tr:  Flip the relationship. Return which expressions contain the variables
30143 
30144 ";
30145 
30146 %feature("docstring")  casadi::Function::casadi_which_depends "
30147 
30148 Which variables enter with some order.
30149 
30150 Parameters:
30151 -----------
30152 
30153 order:  Only 1 (linear) and 2 (nonlinear) allowed
30154 
30155 tr:  Flip the relationship. Return which expressions contain the variables
30156 
30157 ";
30158 
30159 %feature("docstring")  casadi::Function::generate_out(const std::string
30160 &fname, const std::vector< DM > &arg) "
30161 
30162 Export an output file that can be checked with generated C code output.
30163 
30164 generate_in  convert_out to convert between dict/map and vector
30165 
30166 ";
30167 
30168 %feature("docstring")  casadi::Function::generate_out(const std::string
30169 &fname) "
30170 
30171 Export an output file that can be checked with generated C code output.
30172 
30173 generate_in  convert_out to convert between dict/map and vector
30174 
30175 ";
30176 
30177 %feature("docstring")  casadi::Function::call(const std::vector< DM > &arg,
30178 std::vector< DM > &output_res, bool always_inline=false, bool
30179 never_inline=false) const  "
30180 
30181 Evaluate the function symbolically or numerically.
30182 
30183 ";
30184 
30185 %feature("docstring")  casadi::Function::call(const std::vector< SX > &arg,
30186 std::vector< SX > &output_res, bool always_inline=false, bool
30187 never_inline=false) const  "
30188 
30189 Generate a Jacobian function of output oind with respect to input iind.
30190 
30191 Parameters:
30192 -----------
30193 
30194 iind:  The index of the input
30195 
30196 oind:  The index of the output Legacy function: To be deprecated in a future
30197 version of CasADi. Exists only for compatibility with Function::jacobian
30198 pre-CasADi 3.2
30199 
30200 ";
30201 
30202 %feature("docstring")  casadi::Function::call(const std::vector< MX > &arg,
30203 std::vector< MX > &output_res, bool always_inline=false, bool
30204 never_inline=false) const  "
30205 
30206 Generate a Jacobian function of output oind with respect to input iind.
30207 
30208 Parameters:
30209 -----------
30210 
30211 iind:  The index of the input
30212 
30213 oind:  The index of the output Legacy function: To be deprecated in a future
30214 version of CasADi. Exists only for compatibility with Function::jacobian
30215 pre-CasADi 3.2
30216 
30217 ";
30218 
30219 %feature("docstring")  casadi::Function::call(const DMDict &arg, DMDict
30220 &output_res, bool always_inline=false, bool never_inline=false) const  "
30221 
30222 Generate a Jacobian function of output oind with respect to input iind.
30223 
30224 Parameters:
30225 -----------
30226 
30227 iind:  The index of the input
30228 
30229 oind:  The index of the output Legacy function: To be deprecated in a future
30230 version of CasADi. Exists only for compatibility with Function::jacobian
30231 pre-CasADi 3.2
30232 
30233 ";
30234 
30235 %feature("docstring")  casadi::Function::call(const SXDict &arg, SXDict
30236 &output_res, bool always_inline=false, bool never_inline=false) const  "
30237 
30238 Generate a Jacobian function of output oind with respect to input iind.
30239 
30240 Parameters:
30241 -----------
30242 
30243 iind:  The index of the input
30244 
30245 oind:  The index of the output Legacy function: To be deprecated in a future
30246 version of CasADi. Exists only for compatibility with Function::jacobian
30247 pre-CasADi 3.2
30248 
30249 ";
30250 
30251 %feature("docstring")  casadi::Function::call(const MXDict &arg, MXDict
30252 &output_res, bool always_inline=false, bool never_inline=false) const  "
30253 
30254 Generate a Jacobian function of output oind with respect to input iind.
30255 
30256 Parameters:
30257 -----------
30258 
30259 iind:  The index of the input
30260 
30261 oind:  The index of the output Legacy function: To be deprecated in a future
30262 version of CasADi. Exists only for compatibility with Function::jacobian
30263 pre-CasADi 3.2
30264 
30265 ";
30266 
30267 %feature("docstring")  casadi::Function::jacobian_old(casadi_int iind,
30268 casadi_int oind) const  "
30269 
30270 Generate a Jacobian function of output oind with respect to input iind.
30271 
30272 Parameters:
30273 -----------
30274 
30275 iind:  The index of the input
30276 
30277 oind:  The index of the output Legacy function: To be deprecated in a future
30278 version of CasADi. Exists only for compatibility with Function::jacobian
30279 pre-CasADi 3.2
30280 
30281 ";
30282 
30283 %feature("docstring")  casadi::Function::sz_arg() const  "
30284 
30285 Get required length of arg field.
30286 
30287 ";
30288 
30289 %feature("docstring")  casadi::Function::save(const std::string &fname,
30290 const Dict &opts=Dict()) const  "
30291 
30292 Export function in specific language.
30293 
30294 Only allowed for (a subset of) SX/MX Functions
30295 
30296 ";
30297 
30298 %feature("docstring")  casadi::Function::print_options(std::ostream
30299 &stream=casadi::uout()) const  "
30300 
30301 Print options to a stream.
30302 
30303 ";
30304 
30305 %feature("docstring")  casadi::Function::size2_in(casadi_int ind) const  "
30306 
30307 Get input dimension.
30308 
30309 ";
30310 
30311 %feature("docstring")  casadi::Function::size2_in(const std::string &iname)
30312 const  "
30313 
30314 Get input dimension.
30315 
30316 ";
30317 
30318 %feature("docstring")  casadi::Function::has_sprev() const  "
30319 
30320 Is the class able to propagate seeds through the algorithm?
30321 
30322 ";
30323 
30324 %feature("docstring")  casadi::Function::instruction_constant(casadi_int k)
30325 const  "
30326 
30327 Get the floating point output argument of an instruction ( SXFunction)
30328 
30329 ";
30330 
30331 %feature("docstring")  casadi::Function::sz_w() const  "
30332 
30333 Get required length of w field.
30334 
30335 ";
30336 
30337 %feature("docstring")  casadi::Function::expand() const  "
30338 
30339 Expand a function to SX.
30340 
30341 ";
30342 
30343 %feature("docstring") casadi::casadi_expand "
30344 
30345 Expand a function to SX.
30346 
30347 ";
30348 
30349 %feature("docstring")  casadi::Function::casadi_expand "
30350 
30351 Expand a function to SX.
30352 
30353 ";
30354 
30355 %feature("docstring")  casadi::Function::expand(const std::string &name,
30356 const Dict &opts=Dict()) const  "
30357 
30358 Expand a function to SX.
30359 
30360 ";
30361 
30362 %feature("docstring") casadi::casadi_expand "
30363 
30364 Expand a function to SX.
30365 
30366 ";
30367 
30368 %feature("docstring")  casadi::Function::casadi_expand "
30369 
30370 Expand a function to SX.
30371 
30372 ";
30373 
30374 %feature("docstring")  casadi::Function::sx_out(casadi_int oind) const  "
30375 
30376 Get symbolic primitives equivalent to the output expressions There is no
30377 guarantee that subsequent calls return unique answers.
30378 
30379 ";
30380 
30381 %feature("docstring")  casadi::Function::sx_out(const std::string &oname)
30382 const  "
30383 
30384 Get symbolic primitives equivalent to the output expressions There is no
30385 guarantee that subsequent calls return unique answers.
30386 
30387 ";
30388 
30389 %feature("docstring")  casadi::Function::sx_out() const  "
30390 
30391 Get symbolic primitives equivalent to the output expressions There is no
30392 guarantee that subsequent calls return unique answers.
30393 
30394 ";
30395 
30396 %feature("docstring")  casadi::Function::default_in(casadi_int ind) const  "
30397 
30398 Get default input value.
30399 
30400 ";
30401 
30402 %feature("docstring")  casadi::Function::nz_from_in(const std::vector< DM >
30403 &arg) const  "
30404 
30405 Convert from/to flat vector of input/output nonzeros.
30406 
30407 ";
30408 
30409 
30410 // File: classcasadi_1_1FunctionBuffer.xml
30411 %feature("docstring") casadi::FunctionBuffer "
30412 
30413 Class to achieve minimal overhead function evaluations.
30414 
30415 C++ includes: function.hpp ";
30416 
30417 %feature("docstring") casadi::FunctionBuffer::FunctionBuffer(const Function
30418 &f) "
30419 
30420 Main constructor.
30421 
30422 ";
30423 
30424 %feature("docstring")  casadi::FunctionBuffer::set_arg(casadi_int i, const
30425 double *a, casadi_int size) "
30426 
30427 Set input buffer for input i.
30428 
30429 mem.set_arg(0, memoryview(a))
30430 
30431 Note that CasADi uses 'fortran' order: column-by-column
30432 
30433 ";
30434 
30435 %feature("docstring")  casadi::FunctionBuffer::set_res(casadi_int i, double
30436 *a, casadi_int size) "
30437 
30438 Set output buffer for ouput i.
30439 
30440 mem.set_res(0, memoryview(a))
30441 
30442 Note that CasADi uses 'fortran' order: column-by-column
30443 
30444 ";
30445 
30446 %feature("docstring")  casadi::FunctionBuffer::ret() "
30447 
30448 Get last return value.
30449 
30450 ";
30451 
30452 
30453 // File: classcasadi_1_1GenericExternal.xml
30454 %feature("docstring")  casadi::FunctionInternal::size_in(casadi_int ind)
30455 const  "
30456 
30457 [INTERNAL]  Input/output dimensions.
30458 
30459 ";
30460 
30461 %feature("docstring")  casadi::FunctionInternal::tocache(const Function &f,
30462 const std::string &suffix="") const  "
30463 
30464 [INTERNAL]  Save function to cache.
30465 
30466 ";
30467 
30468 %feature("docstring")  casadi::FunctionInternal::index_in(const std::string
30469 &name) const  "
30470 
30471 [INTERNAL]  Get input scheme index by name.
30472 
30473 ";
30474 
30475 %feature("docstring")  casadi::FunctionInternal::project_res(const
30476 std::vector< M > &arg, casadi_int npar) const  "
30477 
30478 [INTERNAL]   Project sparsities.
30479 
30480 ";
30481 
30482 %feature("docstring")  casadi::FunctionInternal::matching_res(const
30483 std::vector< M > &arg, casadi_int &npar) const  "
30484 
30485 [INTERNAL]  Check if output arguments that needs to be replaced.
30486 
30487 Raises errors
30488 
30489 Parameters:
30490 -----------
30491 
30492 npar[in]:  normal usage: 1, disallow pararallel calls: -1
30493 
30494 npar:  max number of horizontal repetitions across all arguments (or -1)
30495 
30496 ";
30497 
30498 %feature("docstring")  casadi::FunctionInternal::call_gen(const MXVector
30499 &arg, MXVector &res, casadi_int npar, bool always_inline, bool never_inline)
30500 const  "
30501 
30502 [INTERNAL]   Call a function, overloaded.
30503 
30504 ";
30505 
30506 %feature("docstring")  casadi::FunctionInternal::call_gen(const std::vector<
30507 MatrixCommon > &arg, std::vector< MatrixCommon > &res, casadi_int npar, bool
30508 always_inline, bool never_inline) const  "
30509 
30510 [INTERNAL]   Call a function, overloaded.
30511 
30512 ";
30513 
30514 %feature("docstring")  casadi::FunctionInternal::get_jacobian_sparsity()
30515 const  "
30516 
30517 [INTERNAL]  Get Jacobian sparsity.
30518 
30519 ";
30520 
30521 %feature("docstring")  casadi::FunctionInternal::get_reltol() const  "
30522 
30523 [INTERNAL]  Get relative tolerance.
30524 
30525 ";
30526 
30527 %feature("docstring")
30528 casadi::FunctionInternal::codegen_incref(CodeGenerator &g) const  "
30529 
30530 [INTERNAL]  Codegen incref for dependencies.
30531 
30532 ";
30533 
30534 %feature("docstring") casadi::GenericExternal::~GenericExternal "
30535 
30536 [INTERNAL]  Destructor.
30537 
30538 ";
30539 
30540 %feature("docstring")  casadi::FunctionInternal::fwdViaJac(casadi_int nfwd)
30541 const  "
30542 
30543 [INTERNAL]  Calculate derivatives by multiplying the full Jacobian and
30544 multiplying.
30545 
30546 ";
30547 
30548 %feature("docstring")  casadi::FunctionInternal::numel_out(casadi_int ind)
30549 const  "
30550 
30551 [INTERNAL]  Number of input/output elements.
30552 
30553 ";
30554 
30555 %feature("docstring")  casadi::FunctionInternal::numel_out() const  "
30556 
30557 [INTERNAL]  Number of input/output elements.
30558 
30559 ";
30560 
30561 %feature("docstring")  casadi::FunctionInternal::nnz_out() const  "
30562 
30563 [INTERNAL]  Number of input/output nonzeros.
30564 
30565 ";
30566 
30567 %feature("docstring")  casadi::FunctionInternal::nnz_out(casadi_int ind)
30568 const  "
30569 
30570 [INTERNAL]  Number of input/output nonzeros.
30571 
30572 ";
30573 
30574 %feature("docstring")  casadi::FunctionInternal::jac() const  "
30575 
30576 [INTERNAL]  Return Jacobian of all input elements with respect to all output
30577 elements.
30578 
30579 ";
30580 
30581 %feature("docstring")  casadi::FunctionInternal::symbolicAdjSeed(casadi_int
30582 nadj, const std::vector< MatType > &v) const  "
30583 
30584 [INTERNAL]  Symbolic expressions for the adjoint seeds.
30585 
30586 ";
30587 
30588 %feature("docstring")  casadi::FunctionInternal::replace_aseed(const
30589 std::vector< std::vector< M >> &aseed, casadi_int npar) const  "
30590 
30591 [INTERNAL]  Replace 0-by-0 reverse seeds.
30592 
30593 ";
30594 
30595 %feature("docstring")  casadi::FunctionInternal::replace_aseed(const
30596 std::vector< std::vector< M > > &aseed, casadi_int npar) const  "
30597 
30598 [INTERNAL] ";
30599 
30600 %feature("docstring")
30601 casadi::FunctionInternal::codegen_sparsities(CodeGenerator &g) const  "
30602 
30603 [INTERNAL]  Codegen sparsities.
30604 
30605 ";
30606 
30607 %feature("docstring")  casadi::FunctionInternal::jacobian_sparsity() const
30608 "
30609 
30610 [INTERNAL]  Get Jacobian sparsity.
30611 
30612 ";
30613 
30614 %feature("docstring")  casadi::FunctionInternal::symbolic_output(const
30615 std::vector< MX > &arg) const  "
30616 
30617 [INTERNAL]  Get a vector of symbolic variables corresponding to the outputs.
30618 
30619 ";
30620 
30621 %feature("docstring")  casadi::FunctionInternal::sparsity_out(casadi_int
30622 ind) const  "
30623 
30624 [INTERNAL]  Input/output sparsity.
30625 
30626 ";
30627 
30628 %feature("docstring")  casadi::FunctionInternal::has_sprev() const  "
30629 
30630 [INTERNAL]  Is the class able to propagate seeds through the algorithm?
30631 
30632 ";
30633 
30634 %feature("docstring")  casadi::FunctionInternal::has_derivative() const  "
30635 
30636 [INTERNAL]  Can derivatives be calculated in any way?
30637 
30638 ";
30639 
30640 %feature("docstring")  casadi::FunctionInternal::generate_lifted(Function
30641 &vdef_fcn, Function &vinit_fcn) const  "
30642 
30643 [INTERNAL]  Extract the functions needed for the Lifted Newton method.
30644 
30645 ";
30646 
30647 %feature("docstring")  casadi::ProtoFunction::serialize(SerializingStream
30648 &s) const  "
30649 
30650 [INTERNAL]  Serialize an object.
30651 
30652 ";
30653 
30654 %feature("docstring")  casadi::FunctionInternal::mapsum_mx(const
30655 std::vector< MX > &arg, const std::string &parallelization) "
30656 
30657 [INTERNAL]  Parallel evaluation.
30658 
30659 ";
30660 
30661 %feature("docstring")  casadi::FunctionInternal::export_code(const
30662 std::string &lang, std::ostream &stream, const Dict &options) const  "
30663 
30664 [INTERNAL]  Export function in a specific language.
30665 
30666 ";
30667 
30668 %feature("docstring")  casadi::FunctionInternal::getAdaptorSolverName()
30669 const  "
30670 
30671 [INTERNAL]  Obtain solver name from Adaptor.
30672 
30673 ";
30674 
30675 %feature("docstring")  casadi::FunctionInternal::set_work(void *mem, const
30676 double **&arg, double **&res, casadi_int *&iw, double *&w) const  "
30677 
30678 [INTERNAL]  Set the (persistent) work vectors.
30679 
30680 ";
30681 
30682 %feature("docstring")  casadi::FunctionInternal::all_scalar() const  "
30683 
30684 [INTERNAL]  Are all inputs and outputs scalar.
30685 
30686 ";
30687 
30688 %feature("docstring")  casadi::FunctionInternal::print_options(std::ostream
30689 &stream) const  "
30690 
30691 [INTERNAL]  Print list of options.
30692 
30693 ";
30694 
30695 %feature("docstring")  casadi::FunctionInternal::get_max_in(casadi_int ind)
30696 const  "
30697 
30698 [INTERNAL]  Get largest input value.
30699 
30700 ";
30701 
30702 %feature("docstring")  casadi::External::has_jacobian() const  "
30703 
30704 [INTERNAL]  Full Jacobian.
30705 
30706 ";
30707 
30708 %feature("docstring")  casadi::FunctionInternal::is_diff_in(casadi_int i) "
30709 
30710 [INTERNAL] ";
30711 
30712 %feature("docstring")  casadi::ProtoFunction::alloc_mem() const  "
30713 
30714 [INTERNAL]  Create memory block.
30715 
30716 ";
30717 
30718 %feature("docstring")  casadi::External::has_forward(casadi_int nfwd) const
30719 "
30720 
30721 [INTERNAL]  Forward mode derivatives.
30722 
30723 ";
30724 
30725 %feature("docstring")  casadi::FunctionInternal::nz_out(const std::vector<
30726 DM > &res) const  "
30727 
30728 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
30729 
30730 ";
30731 
30732 %feature("docstring")  casadi::FunctionInternal::nz_out(const std::vector<
30733 double > &res) const  "
30734 
30735 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
30736 
30737 ";
30738 
30739 %feature("docstring")  casadi::FunctionInternal::check_arg(const
30740 std::vector< M > &arg, casadi_int &npar) const  "
30741 
30742 [INTERNAL]  Check if input arguments have correct length and dimensions.
30743 
30744 Raises errors.
30745 
30746 Parameters:
30747 -----------
30748 
30749 npar[in]:  normal usage: 1, disallow pararallel calls: -1
30750 
30751 npar:  max number of horizontal repetitions across all arguments (or -1)
30752 
30753 ";
30754 
30755 %feature("docstring")
30756 casadi::FunctionInternal::getJacSparsityHierarchical(casadi_int iind,
30757 casadi_int oind) const  "
30758 
30759 [INTERNAL]  A flavor of getJacSparsity that does hierarchical block
30760 structure recognition.
30761 
30762 ";
30763 
30764 %feature("docstring")  casadi::FunctionInternal::getJacSparsity(casadi_int
30765 iind, casadi_int oind, bool symmetric) const  "
30766 
30767 [INTERNAL]  Generate the sparsity of a Jacobian block.
30768 
30769 ";
30770 
30771 %feature("docstring")  casadi::FunctionInternal::jacobian() const  "
30772 
30773 [INTERNAL]  Return Jacobian of all input elements with respect to all output
30774 elements.
30775 
30776 ";
30777 
30778 %feature("docstring")  casadi::FunctionInternal::check_mat(const Sparsity
30779 &arg, const Sparsity &inp, casadi_int &npar) "
30780 
30781 [INTERNAL]  Helper function
30782 
30783 Parameters:
30784 -----------
30785 
30786 npar[in]:  normal usage: 1, disallow pararallel calls: -1
30787 
30788 npar[out]:  required number of parallel calls (or -1)
30789 
30790 ";
30791 
30792 %feature("docstring")  casadi::FunctionInternal::oracle() const  "
30793 
30794 [INTERNAL]  Get oracle.
30795 
30796 ";
30797 
30798 %feature("docstring")  casadi::FunctionInternal::index_out(const std::string
30799 &name) const  "
30800 
30801 [INTERNAL]  Get output scheme index by name.
30802 
30803 ";
30804 
30805 %feature("docstring")  casadi::FunctionInternal::sz_arg() const  "
30806 
30807 [INTERNAL]  Get required length of arg field.
30808 
30809 ";
30810 
30811 %feature("docstring")  casadi::FunctionInternal::eval_gen(const double
30812 **arg, double **res, casadi_int *iw, double *w, void *mem) const  "
30813 
30814 [INTERNAL]  Evaluate numerically.
30815 
30816 ";
30817 
30818 %feature("docstring")  casadi::FunctionInternal::eval_gen(const SXElem
30819 **arg, SXElem **res, casadi_int *iw, SXElem *w, void *mem) const  "
30820 
30821 [INTERNAL]  Evaluate a function, overloaded.
30822 
30823 ";
30824 
30825 %feature("docstring")  casadi::FunctionInternal::eval_gen(const bvec_t
30826 **arg, bvec_t **res, casadi_int *iw, bvec_t *w, void *mem) const  "
30827 
30828 [INTERNAL]  Evaluate a function, overloaded.
30829 
30830 ";
30831 
30832 %feature("docstring")  casadi::FunctionInternal::replace_fseed(const
30833 std::vector< std::vector< M >> &fseed, casadi_int npar) const  "
30834 
30835 [INTERNAL]  Replace 0-by-0 forward seeds.
30836 
30837 ";
30838 
30839 %feature("docstring")  casadi::FunctionInternal::replace_fseed(const
30840 std::vector< std::vector< M > > &fseed, casadi_int npar) const  "
30841 
30842 [INTERNAL] ";
30843 
30844 %feature("docstring")  casadi::FunctionInternal::dm_in(casadi_int ind) const
30845 "
30846 
30847 [INTERNAL]  Get function input(s) and output(s)
30848 
30849 ";
30850 
30851 %feature("docstring")  casadi::FunctionInternal::dm_in() const  "
30852 
30853 [INTERNAL]  Get function input(s) and output(s)
30854 
30855 ";
30856 
30857 %feature("docstring")  casadi::FunctionInternal::has_codegen() const  "
30858 
30859 [INTERNAL]  Is codegen supported?
30860 
30861 ";
30862 
30863 %feature("docstring")
30864 casadi::FunctionInternal::codegen_init_mem(CodeGenerator &g) const  "
30865 
30866 [INTERNAL]  Codegen decref for init_mem.
30867 
30868 ";
30869 
30870 %feature("docstring")  casadi::FunctionInternal::wrap_as_needed(const Dict
30871 &opts) const  "
30872 
30873 [INTERNAL]  Wrap in an Function instance consisting of only one MX call.
30874 
30875 ";
30876 
30877 %feature("docstring")  casadi::FunctionInternal::size_out(casadi_int ind)
30878 const  "
30879 
30880 [INTERNAL]  Input/output dimensions.
30881 
30882 ";
30883 
30884 %feature("docstring")  casadi::FunctionInternal::convert_res(const
30885 std::vector< M > &res) const  "
30886 
30887 [INTERNAL]  Convert from/to input/output lists/map.
30888 
30889 ";
30890 
30891 %feature("docstring")  casadi::FunctionInternal::convert_res(const std::map<
30892 std::string, M > &res) const  "
30893 
30894 [INTERNAL]  Convert from/to input/output lists/map.
30895 
30896 ";
30897 
30898 %feature("docstring")  casadi::External::get_default_in(casadi_int i) const
30899 "
30900 
30901 [INTERNAL]  Default inputs.
30902 
30903 ";
30904 
30905 %feature("docstring")  casadi::FunctionInternal::check_res(const
30906 std::vector< M > &res, casadi_int &npar) const  "
30907 
30908 [INTERNAL]  Check if output arguments have correct length and dimensions.
30909 
30910 Raises errors.
30911 
30912 Parameters:
30913 -----------
30914 
30915 npar[in]:  normal usage: 1, disallow pararallel calls: -1
30916 
30917 npar:  max number of horizontal repetitions across all arguments (or -1)
30918 
30919 ";
30920 
30921 %feature("docstring")  casadi::ProtoFunction::memory(int ind) const  "
30922 
30923 [INTERNAL]  Memory objects.
30924 
30925 ";
30926 
30927 %feature("docstring")  casadi::FunctionInternal::call_forward(const
30928 std::vector< MX > &arg, const std::vector< MX > &res, const std::vector<
30929 std::vector< MX > > &fseed, std::vector< std::vector< MX > > &fsens, bool
30930 always_inline, bool never_inline) const  "
30931 
30932 [INTERNAL]  Forward mode AD, virtual functions overloaded in derived
30933 classes.
30934 
30935 ";
30936 
30937 %feature("docstring")  casadi::FunctionInternal::call_forward(const
30938 std::vector< SX > &arg, const std::vector< SX > &res, const std::vector<
30939 std::vector< SX > > &fseed, std::vector< std::vector< SX > > &fsens, bool
30940 always_inline, bool never_inline) const  "
30941 
30942 [INTERNAL]  Forward mode AD, virtual functions overloaded in derived
30943 classes.
30944 
30945 ";
30946 
30947 %feature("docstring")
30948 casadi::FunctionInternal::codegen_alloc_mem(CodeGenerator &g) const  "
30949 
30950 [INTERNAL]  Codegen decref for alloc_mem.
30951 
30952 ";
30953 
30954 %feature("docstring")  casadi::FunctionInternal::numel_in() const  "
30955 
30956 [INTERNAL]  Number of input/output elements.
30957 
30958 ";
30959 
30960 %feature("docstring")  casadi::FunctionInternal::numel_in(casadi_int ind)
30961 const  "
30962 
30963 [INTERNAL]  Number of input/output elements.
30964 
30965 ";
30966 
30967 %feature("docstring")  casadi::ProtoFunction::print_time(const std::map<
30968 std::string, FStats > &fstats) const  "
30969 
30970 [INTERNAL]  Print timing statistics.
30971 
30972 ";
30973 
30974 %feature("docstring")  casadi::FunctionInternal::get_function() const  "
30975 
30976 [INTERNAL] ";
30977 
30978 %feature("docstring")  casadi::FunctionInternal::get_function(const
30979 std::string &name) const  "
30980 
30981 [INTERNAL] ";
30982 
30983 %feature("docstring")  casadi::FunctionInternal::sz_res() const  "
30984 
30985 [INTERNAL]  Get required length of res field.
30986 
30987 ";
30988 
30989 %feature("docstring")  casadi::FunctionInternal::is_diff_out(casadi_int i) "
30990 
30991 [INTERNAL] ";
30992 
30993 %feature("docstring")  casadi::FunctionInternal::has_jacobian_sparsity()
30994 const  "
30995 
30996 [INTERNAL]  Get Jacobian sparsity.
30997 
30998 ";
30999 
31000 %feature("docstring")  casadi::External::get_reverse(casadi_int nadj, const
31001 std::string &name, const std::vector< std::string > &inames, const
31002 std::vector< std::string > &onames, const Dict &opts) const  "
31003 
31004 [INTERNAL]  Reverse mode derivatives.
31005 
31006 ";
31007 
31008 %feature("docstring")
31009 casadi::FunctionInternal::print_dimensions(std::ostream &stream) const  "
31010 
31011 [INTERNAL]  Print dimensions of inputs and outputs.
31012 
31013 ";
31014 
31015 %feature("docstring")  casadi::FunctionInternal::instructions_sx() const  "
31016 
31017 [INTERNAL]  get SX expression associated with instructions
31018 
31019 ";
31020 
31021 %feature("docstring") casadi::GenericExternal::GenericExternal(const
31022 std::string &name, const Importer &li) "
31023 
31024 [INTERNAL]  Constructor.
31025 
31026 ";
31027 
31028 %feature("docstring")
31029 casadi::GenericExternal::GenericExternal(DeserializingStream &s) "
31030 
31031 [INTERNAL]  Deserializing constructor.
31032 
31033 ";
31034 
31035 %feature("docstring")  casadi::GenericExternal::get_sparsity_in(casadi_int
31036 i)  "
31037 
31038 [INTERNAL]  Retreive sparsities.
31039 
31040 ";
31041 
31042 %feature("docstring")  casadi::FunctionInternal::uses_output() const  "
31043 
31044 [INTERNAL]  Do the derivative functions need nondifferentiated outputs?
31045 
31046 ";
31047 
31048 %feature("docstring")  casadi::FunctionInternal::map(casadi_int n, const
31049 std::string &parallelization) const  "
31050 
31051 [INTERNAL]  Generate/retrieve cached serial map.
31052 
31053 ";
31054 
31055 %feature("docstring")  casadi::FunctionInternal::alloc_arg(size_t sz_arg,
31056 bool persistent=false) "
31057 
31058 [INTERNAL]  Ensure required length of arg field.
31059 
31060 ";
31061 
31062 %feature("docstring")  casadi::FunctionInternal::jit_dependencies(const
31063 std::string &fname) "
31064 
31065 [INTERNAL]  Jit dependencies.
31066 
31067 ";
31068 
31069 %feature("docstring")  casadi::FunctionInternal::eval_mx(const MXVector
31070 &arg, MXVector &res, bool always_inline, bool never_inline) const  "
31071 
31072 [INTERNAL]  Evaluate with symbolic matrices.
31073 
31074 ";
31075 
31076 %feature("docstring")  casadi::FunctionInternal::nnz_in() const  "
31077 
31078 [INTERNAL]  Number of input/output nonzeros.
31079 
31080 ";
31081 
31082 %feature("docstring")  casadi::FunctionInternal::nnz_in(casadi_int ind)
31083 const  "
31084 
31085 [INTERNAL]  Number of input/output nonzeros.
31086 
31087 ";
31088 
31089 %feature("docstring")  casadi::FunctionInternal::n_nodes() const  "
31090 
31091 [INTERNAL]  Number of nodes in the algorithm.
31092 
31093 ";
31094 
31095 %feature("docstring")  casadi::FunctionInternal::forward(casadi_int nfwd)
31096 const  "
31097 
31098 [INTERNAL]  Return function that calculates forward derivatives
31099 forward(nfwd) returns a cached instance if available, and calls  Function
31100 get_forward(casadi_int nfwd) if no cached version is available.
31101 
31102 ";
31103 
31104 %feature("docstring")  casadi::FunctionInternal::alloc_res(size_t sz_res,
31105 bool persistent=false) "
31106 
31107 [INTERNAL]  Ensure required length of res field.
31108 
31109 ";
31110 
31111 %feature("docstring")  casadi::FunctionInternal::print_option(const
31112 std::string &name, std::ostream &stream) const  "
31113 
31114 [INTERNAL]  Print all information there is to know about a certain option.
31115 
31116 ";
31117 
31118 %feature("docstring")  casadi::FunctionInternal::codegen_meta(CodeGenerator
31119 &g) const  "
31120 
31121 [INTERNAL]  Generate meta-information allowing a user to evaluate a
31122 generated function.
31123 
31124 ";
31125 
31126 %feature("docstring")  casadi::FunctionInternal::sz_iw() const  "
31127 
31128 [INTERNAL]  Get required length of iw field.
31129 
31130 ";
31131 
31132 %feature("docstring")  casadi::FunctionInternal::instruction_MX(casadi_int
31133 k) const  "
31134 
31135 [INTERNAL]  get MX expression associated with instruction
31136 
31137 ";
31138 
31139 %feature("docstring")  casadi::SharedObjectInternal::getCount() const  "
31140 
31141 [INTERNAL]  Get the reference count.
31142 
31143 ";
31144 
31145 %feature("docstring")  casadi::FunctionInternal::sx_out(casadi_int ind)
31146 const  "
31147 
31148 [INTERNAL]  Get function input(s) and output(s)
31149 
31150 ";
31151 
31152 %feature("docstring")  casadi::FunctionInternal::sx_out() const  "
31153 
31154 [INTERNAL]  Get function input(s) and output(s)
31155 
31156 ";
31157 
31158 %feature("docstring")  casadi::FunctionInternal::instruction_id(casadi_int
31159 k) const  "
31160 
31161 [INTERNAL]  Get an atomic operation operator index.
31162 
31163 ";
31164 
31165 %feature("docstring")  casadi::GenericExternal::any_symbol_found() const  "
31166 
31167 [INTERNAL]  Any symbol found?
31168 
31169 ";
31170 
31171 %feature("docstring")  casadi::FunctionInternal::definition() const  "
31172 
31173 [INTERNAL]  Get function signature: name:(inputs)->(outputs)
31174 
31175 ";
31176 
31177 %feature("docstring")  casadi::External::get_name_out(casadi_int i)  "
31178 
31179 [INTERNAL]  Names of function input and outputs.
31180 
31181 ";
31182 
31183 %feature("docstring")  casadi::ProtoFunction::format_time(char *buffer,
31184 double time) const  "
31185 
31186 [INTERNAL]  Format time in a fixed width 8 format.
31187 
31188 ";
31189 
31190 %feature("docstring")
31191 casadi::GenericExternal::serialize_type(SerializingStream &s) const  "
31192 
31193 [INTERNAL]  Serialize type information.
31194 
31195 ";
31196 
31197 %feature("docstring")  casadi::FunctionInternal::codegen_mem_type() const  "
31198 
31199 [INTERNAL]  Thread-local memory object type.
31200 
31201 ";
31202 
31203 %feature("docstring")  casadi::FunctionInternal::generate_in(const
31204 std::string &fname, const double **arg) const  "
31205 
31206 [INTERNAL]  Export an input file that can be passed to generate C code with
31207 a main.
31208 
31209 ";
31210 
31211 %feature("docstring")  casadi::FunctionInternal::sp_reverse(bvec_t **arg,
31212 bvec_t **res, casadi_int *iw, bvec_t *w, void *mem) const  "
31213 
31214 [INTERNAL]  Propagate sparsity backwards.
31215 
31216 ";
31217 
31218 %feature("docstring")  casadi::FunctionInternal::eval_dm(const std::vector<
31219 DM > &arg) const  "
31220 
31221 [INTERNAL]  Evaluate with DM matrices.
31222 
31223 ";
31224 
31225 %feature("docstring")  casadi::External::get_jacobian(const std::string
31226 &name, const std::vector< std::string > &inames, const std::vector<
31227 std::string > &onames, const Dict &opts) const  "
31228 
31229 [INTERNAL]  Full Jacobian.
31230 
31231 ";
31232 
31233 %feature("docstring")  casadi::FunctionInternal::sp_weight() const  "
31234 
31235 [INTERNAL]  Weighting factor for chosing forward/reverse mode, sparsity
31236 propagation.
31237 
31238 ";
31239 
31240 %feature("docstring")  casadi::FunctionInternal::replace_res(const
31241 std::vector< M > &res, casadi_int npar) const  "
31242 
31243 [INTERNAL]  Replace 0-by-0 outputs.
31244 
31245 ";
31246 
31247 %feature("docstring")  casadi::FunctionInternal::size1_in(casadi_int ind)
31248 const  "
31249 
31250 [INTERNAL]  Input/output dimensions.
31251 
31252 ";
31253 
31254 %feature("docstring")  casadi::FunctionInternal::mx_in(casadi_int ind) const
31255 "
31256 
31257 [INTERNAL]  Get function input(s) and output(s)
31258 
31259 ";
31260 
31261 %feature("docstring")  casadi::FunctionInternal::mx_in() const  "
31262 
31263 [INTERNAL]  Get function input(s) and output(s)
31264 
31265 ";
31266 
31267 %feature("docstring")  casadi::FunctionInternal::eval(const double **arg,
31268 double **res, casadi_int *iw, double *w, void *mem) const  "
31269 
31270 [INTERNAL]  Evaluate numerically.
31271 
31272 ";
31273 
31274 %feature("docstring")  casadi::FunctionInternal::free_sx() const  "
31275 
31276 [INTERNAL]  Get free variables (SX)
31277 
31278 ";
31279 
31280 %feature("docstring")  casadi::FunctionInternal::has_function(const
31281 std::string &fname) const  "
31282 
31283 [INTERNAL] ";
31284 
31285 %feature("docstring")  casadi::ProtoFunction::release(int mem) const  "
31286 
31287 [INTERNAL]  Release a memory object.
31288 
31289 ";
31290 
31291 %feature("docstring")  casadi::External::serialize_base_function() const  "
31292 
31293 [INTERNAL]  String used to identify the immediate FunctionInternal subclass.
31294 
31295 ";
31296 
31297 %feature("docstring")  casadi::FunctionInternal::call(const std::vector< M >
31298 &arg, std::vector< M > &res, bool always_inline, bool never_inline) const  "
31299 
31300 [INTERNAL]   Call a function, templated.
31301 
31302 ";
31303 
31304 %feature("docstring")
31305 casadi::FunctionInternal::jacobian_sparsity_filter(const Sparsity &sp) const
31306 "
31307 
31308 [INTERNAL]  Filter out nonzeros in the full sparsity jacobian according to
31309 is_diff_in/out.
31310 
31311 ";
31312 
31313 %feature("docstring")  casadi::FunctionInternal::finalize()  "
31314 
31315 [INTERNAL]  Finalize the object creation.
31316 
31317 ";
31318 
31319 %feature("docstring")  casadi::GenericExternal::init_external()  "
31320 
31321 [INTERNAL]  Initialize members that are unique.
31322 
31323 ";
31324 
31325 %feature("docstring")  casadi::External::factory(const std::string &name,
31326 const std::vector< std::string > &s_in, const std::vector< std::string >
31327 &s_out, const Function::AuxOut &aux, const Dict &opts) const  "
31328 
31329 [INTERNAL] ";
31330 
31331 %feature("docstring")  casadi::FunctionInternal::slice(const std::string
31332 &name, const std::vector< casadi_int > &order_in, const std::vector<
31333 casadi_int > &order_out, const Dict &opts) const  "
31334 
31335 [INTERNAL]  returns a new function with a selection of inputs/outputs of the
31336 original
31337 
31338 ";
31339 
31340 %feature("docstring")  casadi::FunctionInternal::project_arg(const
31341 std::vector< M > &arg, casadi_int npar) const  "
31342 
31343 [INTERNAL]   Project sparsities.
31344 
31345 ";
31346 
31347 %feature("docstring")  casadi::FunctionInternal::signature(const std::string
31348 &fname) const  "
31349 
31350 [INTERNAL]  Code generate the function.
31351 
31352 ";
31353 
31354 %feature("docstring")  casadi::FunctionInternal::sz_w() const  "
31355 
31356 [INTERNAL]  Get required length of w field.
31357 
31358 ";
31359 
31360 %feature("docstring")  casadi::FunctionInternal::dm_out(casadi_int ind)
31361 const  "
31362 
31363 [INTERNAL]  Get function input(s) and output(s)
31364 
31365 ";
31366 
31367 %feature("docstring")  casadi::FunctionInternal::dm_out() const  "
31368 
31369 [INTERNAL]  Get function input(s) and output(s)
31370 
31371 ";
31372 
31373 %feature("docstring")  casadi::FunctionInternal::fwd_seed(casadi_int nfwd)
31374 const  "
31375 
31376 [INTERNAL]  Symbolic expressions for the forward seeds.
31377 
31378 ";
31379 
31380 %feature("docstring")  casadi::External::class_name() const  "
31381 
31382 [INTERNAL]  Get type name.
31383 
31384 ";
31385 
31386 %feature("docstring")  casadi::FunctionInternal::generate_dependencies(const
31387 std::string &fname, const Dict &opts) const  "
31388 
31389 [INTERNAL]  Export / Generate C code for the dependency function.
31390 
31391 ";
31392 
31393 %feature("docstring")
31394 casadi::FunctionInternal::instruction_input(casadi_int k) const  "
31395 
31396 [INTERNAL]  Get the (integer) input arguments of an atomic operation.
31397 
31398 ";
31399 
31400 %feature("docstring")  casadi::FunctionInternal::alloc(const Function &f,
31401 bool persistent=false) "
31402 
31403 [INTERNAL]  Ensure work vectors long enough to evaluate function.
31404 
31405 ";
31406 
31407 %feature("docstring")  casadi::ProtoFunction::clear_mem() "
31408 
31409 [INTERNAL]  Clear all memory (called from destructor)
31410 
31411 ";
31412 
31413 %feature("docstring")  casadi::FunctionInternal::reverse(casadi_int nadj)
31414 const  "
31415 
31416 [INTERNAL]  Return function that calculates adjoint derivatives
31417 reverse(nadj) returns a cached instance if available, and calls  Function
31418 get_reverse(casadi_int nadj) if no cached version is available.
31419 
31420 ";
31421 
31422 %feature("docstring")
31423 casadi::FunctionInternal::codegen_free_mem(CodeGenerator &g) const  "
31424 
31425 [INTERNAL]  Codegen for free_mem.
31426 
31427 ";
31428 
31429 %feature("docstring")  casadi::FunctionInternal::get_partition(casadi_int
31430 iind, casadi_int oind, Sparsity &D1, Sparsity &D2, bool compact, bool
31431 symmetric, bool allow_forward, bool allow_reverse) const  "
31432 
31433 [INTERNAL]  Get the unidirectional or bidirectional partition.
31434 
31435 ";
31436 
31437 %feature("docstring")  casadi::External::serialize_body(SerializingStream
31438 &s) const  "
31439 
31440 [INTERNAL]  Serialize an object without type information.
31441 
31442 ";
31443 
31444 %feature("docstring")  casadi::FunctionInternal::get_abstol() const  "
31445 
31446 [INTERNAL]  Get absolute tolerance.
31447 
31448 ";
31449 
31450 %feature("docstring")  casadi::FunctionInternal::n_instructions() const  "
31451 
31452 [INTERNAL]  Get the number of atomic operations.
31453 
31454 ";
31455 
31456 %feature("docstring")  casadi::FunctionInternal::convert_arg(const
31457 std::vector< M > &arg) const  "
31458 
31459 [INTERNAL]  Convert from/to input/output lists/map.
31460 
31461 ";
31462 
31463 %feature("docstring")  casadi::FunctionInternal::convert_arg(const std::map<
31464 std::string, M > &arg) const  "
31465 
31466 [INTERNAL]  Convert from/to input/output lists/map.
31467 
31468 ";
31469 
31470 %feature("docstring")  casadi::ProtoFunction::sprint(char *buf, size_t
31471 buf_sz, const char *fmt,...) const  "
31472 
31473 [INTERNAL]  C-style formatted printing to string.
31474 
31475 ";
31476 
31477 %feature("docstring")  casadi::FunctionInternal::get_options() const  "
31478 
31479 [INTERNAL]  Options.
31480 
31481 ";
31482 
31483 %feature("docstring")
31484 casadi::FunctionInternal::getJacSparsityHierarchicalSymm(casadi_int iind,
31485 casadi_int oind) const  "
31486 
31487 [INTERNAL]  A flavor of getJacSparsity that does hierarchical block
31488 structure recognition for symmetric Jacobians
31489 
31490 ";
31491 
31492 %feature("docstring")  casadi::FunctionInternal::adjViaJac(casadi_int nadj)
31493 const  "
31494 
31495 [INTERNAL]  Calculate derivatives by multiplying the full Jacobian and
31496 multiplying.
31497 
31498 ";
31499 
31500 %feature("docstring")  casadi::FunctionInternal::generate_options(bool
31501 is_temp=false) const  "
31502 
31503 [INTERNAL]  Reconstruct options dict.
31504 
31505 ";
31506 
31507 %feature("docstring")  casadi::FunctionInternal::alloc_w(size_t sz_w, bool
31508 persistent=false) "
31509 
31510 [INTERNAL]  Ensure required length of w field.
31511 
31512 ";
31513 
31514 %feature("docstring")  casadi::FunctionInternal::incache(const std::string
31515 &fname, Function &f, const std::string &suffix="") const  "
31516 
31517 [INTERNAL]  Get function in cache.
31518 
31519 ";
31520 
31521 %feature("docstring")  casadi::FunctionInternal::ad_weight() const  "
31522 
31523 [INTERNAL]  Weighting factor for chosing forward/reverse mode.
31524 
31525 ";
31526 
31527 %feature("docstring")  casadi::External::codegen_declarations(CodeGenerator
31528 &g) const  "
31529 
31530 [INTERNAL]  Generate code for the declarations of the C function.
31531 
31532 ";
31533 
31534 %feature("docstring")  casadi::FunctionInternal::get_min_in(casadi_int ind)
31535 const  "
31536 
31537 [INTERNAL]  Get smallest input value.
31538 
31539 ";
31540 
31541 %feature("docstring")  casadi::External::get_forward(casadi_int nfwd, const
31542 std::string &name, const std::vector< std::string > &inames, const
31543 std::vector< std::string > &onames, const Dict &opts) const  "
31544 
31545 [INTERNAL]  Forward mode derivatives.
31546 
31547 ";
31548 
31549 %feature("docstring")  casadi::FunctionInternal::codegen_mem(CodeGenerator
31550 &g, const std::string &index="mem") const  "
31551 
31552 [INTERNAL]  Get thread-local memory object.
31553 
31554 ";
31555 
31556 %feature("docstring")  casadi::External::codegen_body(CodeGenerator &g)
31557 const  "
31558 
31559 [INTERNAL]  Generate code for the body of the C function.
31560 
31561 ";
31562 
31563 %feature("docstring")  casadi::FunctionInternal::get_jac(const std::string
31564 &name, const std::vector< std::string > &inames, const std::vector<
31565 std::string > &onames, const Dict &opts) const  "
31566 
31567 [INTERNAL]  Return Jacobian of all input elements with respect to all output
31568 elements.
31569 
31570 ";
31571 
31572 %feature("docstring")  casadi::ProtoFunction::free_mem(void *mem) const  "
31573 
31574 [INTERNAL]  Free memory block.
31575 
31576 ";
31577 
31578 %feature("docstring")  casadi::FunctionInternal::sz_work(size_t &sz_arg,
31579 size_t &sz_res, size_t &sz_iw, size_t &sz_w) const  "
31580 
31581 [INTERNAL]  Get number of temporary variables needed.
31582 
31583 ";
31584 
31585 %feature("docstring")  casadi::FunctionInternal::eval_sx(const SXElem **arg,
31586 SXElem **res, casadi_int *iw, SXElem *w, void *mem) const  "
31587 
31588 [INTERNAL]  Evaluate with symbolic scalars.
31589 
31590 ";
31591 
31592 %feature("docstring")  casadi::FunctionInternal::self() const  "
31593 
31594 [INTERNAL]  Get a public class instance.
31595 
31596 ";
31597 
31598 %feature("docstring")  casadi::ProtoFunction::get_stats(void *mem) const  "
31599 
31600 [INTERNAL]  Get all statistics.
31601 
31602 ";
31603 
31604 %feature("docstring")  casadi::FunctionInternal::has_free() const  "
31605 
31606 [INTERNAL]  Does the function have free variables.
31607 
31608 ";
31609 
31610 %feature("docstring")  casadi::FunctionInternal::wrap() const  "
31611 
31612 [INTERNAL]  Wrap in an Function instance consisting of only one MX call.
31613 
31614 ";
31615 
31616 %feature("docstring")  casadi::FunctionInternal::codegen_name(const
31617 CodeGenerator &g, bool ns=true) const  "
31618 
31619 [INTERNAL]  Get name in codegen.
31620 
31621 ";
31622 
31623 %feature("docstring")  casadi::ProtoFunction::init_mem(void *mem) const  "
31624 
31625 [INTERNAL]  Initalize memory block.
31626 
31627 ";
31628 
31629 %feature("docstring")  casadi::ProtoFunction::checkout() const  "
31630 
31631 [INTERNAL]  Checkout a memory object.
31632 
31633 ";
31634 
31635 %feature("docstring")  casadi::FunctionInternal::sx_in(casadi_int ind) const
31636 "
31637 
31638 [INTERNAL]  Get function input(s) and output(s)
31639 
31640 ";
31641 
31642 %feature("docstring")  casadi::FunctionInternal::sx_in() const  "
31643 
31644 [INTERNAL]  Get function input(s) and output(s)
31645 
31646 ";
31647 
31648 %feature("docstring")  casadi::External::has_reverse(casadi_int nadj) const
31649 "
31650 
31651 [INTERNAL]  Reverse mode derivatives.
31652 
31653 ";
31654 
31655 %feature("docstring")  casadi::FunctionInternal::disp_more(std::ostream
31656 &stream) const  "
31657 
31658 [INTERNAL]  Print more.
31659 
31660 ";
31661 
31662 %feature("docstring")  casadi::FunctionInternal::nz_in(const std::vector< DM
31663 > &arg) const  "
31664 
31665 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
31666 
31667 ";
31668 
31669 %feature("docstring")  casadi::FunctionInternal::nz_in(const std::vector<
31670 double > &arg) const  "
31671 
31672 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
31673 
31674 ";
31675 
31676 %feature("docstring")  casadi::FunctionInternal::size1_out(casadi_int ind)
31677 const  "
31678 
31679 [INTERNAL]  Input/output dimensions.
31680 
31681 ";
31682 
31683 %feature("docstring")  casadi::FunctionInternal::alloc_iw(size_t sz_iw, bool
31684 persistent=false) "
31685 
31686 [INTERNAL]  Ensure required length of iw field.
31687 
31688 ";
31689 
31690 %feature("docstring")  casadi::External::get_n_out()  "
31691 
31692 [INTERNAL]  Number of function inputs and outputs.
31693 
31694 ";
31695 
31696 %feature("docstring")  casadi::FunctionInternal::which_depends(const
31697 std::string &s_in, const std::vector< std::string > &s_out, casadi_int
31698 order, bool tr=false) const  "
31699 
31700 [INTERNAL]  Which variables enter with some order.
31701 
31702 Parameters:
31703 -----------
31704 
31705 s_in:   Input name
31706 
31707 s_out:   Output name(s)
31708 
31709 order:  Only 1 (linear) and 2 (nonlinear) allowed
31710 
31711 tr:  Flip the relationship. Return which expressions contain the variables
31712 
31713 ";
31714 
31715 %feature("docstring")  casadi::FunctionInternal::generate_out(const
31716 std::string &fname, double **res) const  "
31717 
31718 [INTERNAL] ";
31719 
31720 %feature("docstring")  casadi::FunctionInternal::info() const  "
31721 
31722 [INTERNAL]  Obtain information about function
31723 
31724 ";
31725 
31726 %feature("docstring")  casadi::FunctionInternal::codegen(CodeGenerator &g,
31727 const std::string &fname) const  "
31728 
31729 [INTERNAL]  Generate code the function.
31730 
31731 ";
31732 
31733 %feature("docstring")
31734 casadi::FunctionInternal::codegen_decref(CodeGenerator &g) const  "
31735 
31736 [INTERNAL]  Codegen decref for dependencies.
31737 
31738 ";
31739 
31740 %feature("docstring")  casadi::FunctionInternal::free_mx() const  "
31741 
31742 [INTERNAL]  Get free variables ( MX)
31743 
31744 ";
31745 
31746 %feature("docstring")  casadi::ProtoFunction::construct(const Dict &opts) "
31747 
31748 [INTERNAL]  Construct Prepares the function for evaluation.
31749 
31750 ";
31751 
31752 %feature("docstring")  casadi::External::get_name_in(casadi_int i)  "
31753 
31754 [INTERNAL]  Names of function input and outputs.
31755 
31756 ";
31757 
31758 %feature("docstring")  casadi::FunctionInternal::has_jac() const  "
31759 
31760 [INTERNAL]  Return Jacobian of all input elements with respect to all output
31761 elements.
31762 
31763 ";
31764 
31765 %feature("docstring")  casadi::FunctionInternal::size2_in(casadi_int ind)
31766 const  "
31767 
31768 [INTERNAL]  Input/output dimensions.
31769 
31770 ";
31771 
31772 %feature("docstring")  casadi::FunctionInternal::call_reverse(const
31773 std::vector< MX > &arg, const std::vector< MX > &res, const std::vector<
31774 std::vector< MX > > &aseed, std::vector< std::vector< MX > > &asens, bool
31775 always_inline, bool never_inline) const  "
31776 
31777 [INTERNAL]  Reverse mode, virtual functions overloaded in derived classes.
31778 
31779 ";
31780 
31781 %feature("docstring")  casadi::FunctionInternal::call_reverse(const
31782 std::vector< SX > &arg, const std::vector< SX > &res, const std::vector<
31783 std::vector< SX > > &aseed, std::vector< std::vector< SX > > &asens, bool
31784 always_inline, bool never_inline) const  "
31785 
31786 [INTERNAL]  Reverse mode, virtual functions overloaded in derived classes.
31787 
31788 ";
31789 
31790 %feature("docstring")  casadi::FunctionInternal::has_spfwd() const  "
31791 
31792 [INTERNAL]  Is the class able to propagate seeds through the algorithm?
31793 
31794 ";
31795 
31796 %feature("docstring") casadi::GenericExternal "
31797 
31798 [INTERNAL] C++ includes: external_impl.hpp ";
31799 
31800 %feature("docstring")  casadi::FunctionInternal::get_free() const  "
31801 
31802 [INTERNAL]  Print free variables.
31803 
31804 ";
31805 
31806 %feature("docstring")  casadi::FunctionInternal::sparsity_jac(casadi_int
31807 iind, casadi_int oind, bool compact, bool symmetric) const  "
31808 
31809 [INTERNAL]  Get, if necessary generate, the sparsity of a Jacobian block.
31810 
31811 ";
31812 
31813 %feature("docstring")  casadi::FunctionInternal::set_temp(void *mem, const
31814 double **arg, double **res, casadi_int *iw, double *w) const  "
31815 
31816 [INTERNAL]  Set the (temporary) work vectors.
31817 
31818 ";
31819 
31820 %feature("docstring")  casadi::FunctionInternal::sparsity_in(casadi_int ind)
31821 const  "
31822 
31823 [INTERNAL]  Input/output sparsity.
31824 
31825 ";
31826 
31827 %feature("docstring")  casadi::External::get_n_in()  "
31828 
31829 [INTERNAL]  Number of function inputs and outputs.
31830 
31831 ";
31832 
31833 %feature("docstring")  casadi::FunctionInternal::has_eval_dm() const  "
31834 
31835 [INTERNAL]  Evaluate with DM matrices.
31836 
31837 ";
31838 
31839 %feature("docstring")  casadi::GenericExternal::get_sparsity_out(casadi_int
31840 i)  "
31841 
31842 [INTERNAL]  Retreive sparsities.
31843 
31844 ";
31845 
31846 %feature("docstring")
31847 casadi::FunctionInternal::instruction_output(casadi_int k) const  "
31848 
31849 [INTERNAL]  Get the (integer) output argument of an atomic operation.
31850 
31851 ";
31852 
31853 %feature("docstring")  casadi::FunctionInternal::sp_forward(const bvec_t
31854 **arg, bvec_t **res, casadi_int *iw, bvec_t *w, void *mem) const  "
31855 
31856 [INTERNAL]  Propagate sparsity forward.
31857 
31858 ";
31859 
31860 %feature("docstring")  casadi::FunctionInternal::mx_out(casadi_int ind)
31861 const  "
31862 
31863 [INTERNAL]  Get function input(s) and output(s)
31864 
31865 ";
31866 
31867 %feature("docstring")  casadi::FunctionInternal::mx_out() const  "
31868 
31869 [INTERNAL]  Get function input(s) and output(s)
31870 
31871 ";
31872 
31873 %feature("docstring")
31874 casadi::FunctionInternal::getJacSparsityGen(casadi_int iind, casadi_int
31875 oind, bool symmetric, casadi_int gr_i=1, casadi_int gr_o=1) const  "
31876 
31877 [INTERNAL]  Get the sparsity pattern, forward mode.
31878 
31879 ";
31880 
31881 %feature("docstring")  casadi::FunctionInternal::is_a(const std::string
31882 &type, bool recursive) const  "
31883 
31884 [INTERNAL]  Check if the function is of a particular type.
31885 
31886 ";
31887 
31888 %feature("docstring")  casadi::FunctionInternal::setup(void *mem, const
31889 double **arg, double **res, casadi_int *iw, double *w) const  "
31890 
31891 [INTERNAL]  Set the (persistent and temporary) work vectors.
31892 
31893 ";
31894 
31895 %feature("docstring")  casadi::ProtoFunction::print(const char *fmt,...)
31896 const  "
31897 
31898 [INTERNAL]  C-style formatted printing during evaluation.
31899 
31900 ";
31901 
31902 %feature("docstring")  casadi::FunctionInternal::matching_arg(const
31903 std::vector< M > &arg, casadi_int &npar) const  "
31904 
31905 [INTERNAL]  Check if input arguments that needs to be replaced.
31906 
31907 Raises errors
31908 
31909 Parameters:
31910 -----------
31911 
31912 npar[in]:  normal usage: 1, disallow pararallel calls: -1
31913 
31914 npar:  max number of horizontal repetitions across all arguments (or -1)
31915 
31916 ";
31917 
31918 %feature("docstring")  casadi::SharedObjectInternal::weak() "
31919 
31920 [INTERNAL]  Get a weak reference to the object.
31921 
31922 ";
31923 
31924 %feature("docstring")  casadi::FunctionInternal::size2_out(casadi_int ind)
31925 const  "
31926 
31927 [INTERNAL]  Input/output dimensions.
31928 
31929 ";
31930 
31931 %feature("docstring")
31932 casadi::FunctionInternal::instruction_constant(casadi_int k) const  "
31933 
31934 [INTERNAL]  Get the floating point output argument of an atomic operation.
31935 
31936 ";
31937 
31938 %feature("docstring")  casadi::GenericExternal::init(const Dict &opts)  "
31939 
31940 [INTERNAL]  Initialize.
31941 
31942 ";
31943 
31944 %feature("docstring")  casadi::FunctionInternal::disp(std::ostream &stream,
31945 bool more) const  "
31946 
31947 [INTERNAL]  Display object.
31948 
31949 ";
31950 
31951 %feature("docstring")  casadi::FunctionInternal::replace_arg(const
31952 std::vector< M > &arg, casadi_int npar) const  "
31953 
31954 [INTERNAL]  Replace 0-by-0 inputs.
31955 
31956 ";
31957 
31958 
31959 // File: classcasadi_1_1GenericMatrix.xml
31960 
31961 
31962 /*  Construct symbolic primitives  */
31963 
31964 /* The \"sym\" function is intended to work in a similar way as \"sym\" used
31965 in the Symbolic Toolbox for Matlab but instead creating a CasADi symbolic
31966 primitive.
31967 
31968 */ %feature("docstring")  casadi::GenericMatrixCommon::dot(const MatType &x,
31969 const MatType &y) "
31970 
31971 [INTERNAL]  Inner product of two matrices with x and y matrices of the same
31972 dimension.
31973 
31974 ";
31975 
31976 %feature("docstring") casadi::casadi_dot "
31977 
31978 Inner product of two matrices with x and y matrices of the same dimension.
31979 
31980 ";
31981 
31982 %feature("docstring")  casadi::GenericMatrixCommon::casadi_dot "
31983 
31984 Inner product of two matrices with x and y matrices of the same dimension.
31985 
31986 ";
31987 
31988 %feature("docstring")  casadi::GenericMatrixCommon::is_quadratic(const
31989 MatType &expr, const MatType &var) "
31990 
31991 Is expr quadratic in var?
31992 
31993 False negatives are possible (an expression may not be recognised as
31994 quadratic while it really is), false positives not.
31995 
31996 ";
31997 
31998 %feature("docstring") casadi::casadi_is_quadratic "
31999 
32000 Is expr quadratic in var?
32001 
32002 False negatives are possible (an expression may not be recognised as
32003 quadratic while it really is), false positives not.
32004 
32005 ";
32006 
32007 %feature("docstring")  casadi::GenericMatrixCommon::casadi_is_quadratic "
32008 
32009 Is expr quadratic in var?
32010 
32011 False negatives are possible (an expression may not be recognised as
32012 quadratic while it really is), false positives not.
32013 
32014 ";
32015 
32016 %feature("docstring")  casadi::GenericMatrixCommon::solve(const MatType &A,
32017 const MatType &b) "
32018 
32019 [INTERNAL]   Solve a system of equations: A*x = b The solve routine works
32020 similar to Matlab's backslash when A is square and nonsingular. The
32021 algorithm used is the following:
32022 
32023 A simple forward or backward substitution if A is upper or lower triangular
32024 
32025 If the linear system is at most 3-by-3, form the inverse via minor expansion
32026 and multiply
32027 
32028 Permute the variables and equations as to get a (structurally) nonzero
32029 diagonal, then perform a QR factorization without pivoting and solve the
32030 factorized system.
32031 
32032 Note 1: If there are entries of the linear system known to be zero, these
32033 will be removed. Elements that are very small, or will evaluate to be zero,
32034 can still cause numerical errors, due to the lack of pivoting (which is not
32035 possible since cannot compare the size of entries)
32036 
32037 Note 2: When permuting the linear system, a BLT (block lower triangular)
32038 transformation is formed. Only the permutation part of this is however used.
32039 An improvement would be to solve block-by-block if there are multiple BLT
32040 blocks.
32041 
32042 ";
32043 
32044 %feature("docstring") casadi::casadi_solve "
32045 
32046 Solve a system of equations: A*x = b The solve routine works similar to
32047 Matlab's backslash when A is square and nonsingular. The algorithm used is
32048 the following:
32049 
32050 A simple forward or backward substitution if A is upper or lower triangular
32051 
32052 If the linear system is at most 3-by-3, form the inverse via minor expansion
32053 and multiply
32054 
32055 Permute the variables and equations as to get a (structurally) nonzero
32056 diagonal, then perform a QR factorization without pivoting and solve the
32057 factorized system.
32058 
32059 Note 1: If there are entries of the linear system known to be zero, these
32060 will be removed. Elements that are very small, or will evaluate to be zero,
32061 can still cause numerical errors, due to the lack of pivoting (which is not
32062 possible since cannot compare the size of entries)
32063 
32064 Note 2: When permuting the linear system, a BLT (block lower triangular)
32065 transformation is formed. Only the permutation part of this is however used.
32066 An improvement would be to solve block-by-block if there are multiple BLT
32067 blocks.
32068 
32069 ";
32070 
32071 %feature("docstring")  casadi::GenericMatrixCommon::casadi_solve "
32072 
32073 Solve a system of equations: A*x = b The solve routine works similar to
32074 Matlab's backslash when A is square and nonsingular. The algorithm used is
32075 the following:
32076 
32077 A simple forward or backward substitution if A is upper or lower triangular
32078 
32079 If the linear system is at most 3-by-3, form the inverse via minor expansion
32080 and multiply
32081 
32082 Permute the variables and equations as to get a (structurally) nonzero
32083 diagonal, then perform a QR factorization without pivoting and solve the
32084 factorized system.
32085 
32086 Note 1: If there are entries of the linear system known to be zero, these
32087 will be removed. Elements that are very small, or will evaluate to be zero,
32088 can still cause numerical errors, due to the lack of pivoting (which is not
32089 possible since cannot compare the size of entries)
32090 
32091 Note 2: When permuting the linear system, a BLT (block lower triangular)
32092 transformation is formed. Only the permutation part of this is however used.
32093 An improvement would be to solve block-by-block if there are multiple BLT
32094 blocks.
32095 
32096 ";
32097 
32098 %feature("docstring")  casadi::GenericMatrixCommon::solve(const MatType &A,
32099 const MatType &b, const std::string &lsolver, const Dict &dict=Dict()) "
32100 
32101 [INTERNAL]   Solve a system of equations: A*x = b.
32102 
32103 ";
32104 
32105 %feature("docstring") casadi::casadi_solve "
32106 
32107 Solve a system of equations: A*x = b.
32108 
32109 ";
32110 
32111 %feature("docstring")  casadi::GenericMatrixCommon::casadi_solve "
32112 
32113 Solve a system of equations: A*x = b.
32114 
32115 ";
32116 
32117 %feature("docstring")  casadi::GenericMatrixCommon::pinv(const MatType &A) "
32118 
32119 [INTERNAL]  Computes the Moore-Penrose pseudo-inverse.
32120 
32121 If the matrix A is fat (size1<size2), mul(A, pinv(A)) is unity.
32122 
32123 pinv(A)' = (AA')^(-1) A
32124 
32125 If the matrix A is slender (size1>size2), mul(pinv(A), A) is unity.
32126 
32127 pinv(A) = (A'A)^(-1) A'
32128 
32129 ";
32130 
32131 %feature("docstring") casadi::casadi_pinv "
32132 
32133 Computes the Moore-Penrose pseudo-inverse.
32134 
32135 If the matrix A is fat (size1<size2), mul(A, pinv(A)) is unity.
32136 
32137 pinv(A)' = (AA')^(-1) A
32138 
32139 If the matrix A is slender (size1>size2), mul(pinv(A), A) is unity.
32140 
32141 pinv(A) = (A'A)^(-1) A'
32142 
32143 ";
32144 
32145 %feature("docstring")  casadi::GenericMatrixCommon::casadi_pinv "
32146 
32147 Computes the Moore-Penrose pseudo-inverse.
32148 
32149 If the matrix A is fat (size1<size2), mul(A, pinv(A)) is unity.
32150 
32151 pinv(A)' = (AA')^(-1) A
32152 
32153 If the matrix A is slender (size1>size2), mul(pinv(A), A) is unity.
32154 
32155 pinv(A) = (A'A)^(-1) A'
32156 
32157 ";
32158 
32159 %feature("docstring")  casadi::GenericMatrixCommon::pinv(const MatType &A,
32160 const std::string &lsolver, const Dict &dict=Dict()) "
32161 
32162 [INTERNAL]  Computes the Moore-Penrose pseudo-inverse.
32163 
32164 If the matrix A is fat (size1>size2), mul(A, pinv(A)) is unity. If the
32165 matrix A is slender (size2<size1), mul(pinv(A), A) is unity.
32166 
32167 ";
32168 
32169 %feature("docstring") casadi::casadi_pinv "
32170 
32171 Computes the Moore-Penrose pseudo-inverse.
32172 
32173 If the matrix A is fat (size1>size2), mul(A, pinv(A)) is unity. If the
32174 matrix A is slender (size2<size1), mul(pinv(A), A) is unity.
32175 
32176 ";
32177 
32178 %feature("docstring")  casadi::GenericMatrixCommon::casadi_pinv "
32179 
32180 Computes the Moore-Penrose pseudo-inverse.
32181 
32182 If the matrix A is fat (size1>size2), mul(A, pinv(A)) is unity. If the
32183 matrix A is slender (size2<size1), mul(pinv(A), A) is unity.
32184 
32185 ";
32186 
32187 %feature("docstring")  casadi::GenericMatrixCommon::jacobian(const MatType
32188 &ex, const MatType &arg, const Dict &opts=Dict()) "
32189 
32190 [INTERNAL]  Calculate Jacobian.
32191 
32192 ";
32193 
32194 %feature("docstring") casadi::casadi_jacobian "
32195 
32196 Calculate Jacobian.
32197 
32198 ";
32199 
32200 %feature("docstring")  casadi::GenericMatrixCommon::casadi_jacobian "
32201 
32202 Calculate Jacobian.
32203 
32204 ";
32205 
32206 %feature("docstring")  casadi::GenericMatrixCommon::substitute_inplace(const
32207 std::vector< MatType > &v, std::vector< MatType > &inout_vdef, std::vector<
32208 MatType > &inout_ex, bool reverse=false) "
32209 
32210 [INTERNAL]  Inplace substitution with piggyback expressions Substitute
32211 variables v out of the expressions vdef sequentially, as well as out of a
32212 number of other expressions piggyback.
32213 
32214 ";
32215 
32216 %feature("docstring") casadi::casadi_substitute_inplace "
32217 
32218 Inplace substitution with piggyback expressions Substitute variables v out
32219 of the expressions vdef sequentially, as well as out of a number of other
32220 expressions piggyback.
32221 
32222 ";
32223 
32224 %feature("docstring")
32225 casadi::GenericMatrixCommon::casadi_substitute_inplace "
32226 
32227 Inplace substitution with piggyback expressions Substitute variables v out
32228 of the expressions vdef sequentially, as well as out of a number of other
32229 expressions piggyback.
32230 
32231 ";
32232 
32233 %feature("docstring")  casadi::GenericMatrixCommon::simplify(const MatType
32234 &x) "
32235 
32236 [INTERNAL]  Simplify an expression.
32237 
32238 ";
32239 
32240 %feature("docstring") casadi::casadi_simplify "
32241 
32242 Simplify an expression.
32243 
32244 ";
32245 
32246 %feature("docstring")  casadi::GenericMatrixCommon::casadi_simplify "
32247 
32248 Simplify an expression.
32249 
32250 ";
32251 
32252 %feature("docstring")  casadi::GenericMatrixCommon::cumsum(const MatType &x,
32253 casadi_int axis=-1) "
32254 
32255 [INTERNAL]  Returns cumulative sum along given axis (MATLAB convention)
32256 
32257 ";
32258 
32259 %feature("docstring") casadi::casadi_cumsum "
32260 
32261 Returns cumulative sum along given axis (MATLAB convention)
32262 
32263 ";
32264 
32265 %feature("docstring")  casadi::GenericMatrixCommon::casadi_cumsum "
32266 
32267 Returns cumulative sum along given axis (MATLAB convention)
32268 
32269 ";
32270 
32271 %feature("docstring")  casadi::GenericMatrixCommon::nnz_diag() const  "
32272 
32273 Get get the number of non-zeros on the diagonal.
32274 
32275 ";
32276 
32277 %feature("docstring")  casadi::GenericMatrixCommon::conditional(const
32278 MatType &ind, const std::vector< MatType > &x, const MatType &x_default,
32279 bool short_circuit=false) "
32280 
32281 [INTERNAL]  Create a switch.
32282 
32283 If the condition
32284 
32285 Parameters:
32286 -----------
32287 
32288 ind:  evaluates to the integer k, where 0<=k<f.size(), then x[k] will be
32289 returned, otherwise
32290 
32291 x_default:  will be returned.
32292 
32293 ";
32294 
32295 %feature("docstring") casadi::casadi_conditional "
32296 
32297 Create a switch.
32298 
32299 If the condition
32300 
32301 Parameters:
32302 -----------
32303 
32304 ind:  evaluates to the integer k, where 0<=k<f.size(), then x[k] will be
32305 returned, otherwise
32306 
32307 x_default:  will be returned.
32308 
32309 ";
32310 
32311 %feature("docstring")  casadi::GenericMatrixCommon::casadi_conditional "
32312 
32313 Create a switch.
32314 
32315 If the condition
32316 
32317 Parameters:
32318 -----------
32319 
32320 ind:  evaluates to the integer k, where 0<=k<f.size(), then x[k] will be
32321 returned, otherwise
32322 
32323 x_default:  will be returned.
32324 
32325 ";
32326 
32327 %feature("docstring")  casadi::GenericMatrixCommon::print_operator(const
32328 MatType &xb, const std::vector< std::string > &args) "
32329 
32330 [INTERNAL]  Get a string representation for a binary MatType, using custom
32331 arguments.
32332 
32333 ";
32334 
32335 %feature("docstring") casadi::casadi_print_operator "
32336 
32337 Get a string representation for a binary MatType, using custom arguments.
32338 
32339 ";
32340 
32341 %feature("docstring")  casadi::GenericMatrixCommon::casadi_print_operator "
32342 
32343 Get a string representation for a binary MatType, using custom arguments.
32344 
32345 ";
32346 
32347 %feature("docstring")  casadi::GenericMatrixCommon::trace(const MatType &x)
32348 "
32349 
32350 [INTERNAL]   Matrix trace.
32351 
32352 ";
32353 
32354 %feature("docstring") casadi::casadi_trace "
32355 
32356 Matrix trace.
32357 
32358 ";
32359 
32360 %feature("docstring")  casadi::GenericMatrixCommon::casadi_trace "
32361 
32362 Matrix trace.
32363 
32364 ";
32365 
32366 %feature("docstring")  casadi::GenericMatrixCommon::mmax(const MatType &x) "
32367 
32368 [INTERNAL]  Largest element in a matrix.
32369 
32370 ";
32371 
32372 %feature("docstring") casadi::casadi_mmax "
32373 
32374 Largest element in a matrix.
32375 
32376 ";
32377 
32378 %feature("docstring")  casadi::GenericMatrixCommon::casadi_mmax "
32379 
32380 Largest element in a matrix.
32381 
32382 ";
32383 
32384 %feature("docstring")  casadi::GenericMatrixCommon::get_row() const  "
32385 
32386 Get the sparsity pattern. See the Sparsity class for details.
32387 
32388 ";
32389 
32390 %feature("docstring")  casadi::GenericMatrixCommon::n_nodes(const MatType
32391 &A) "
32392 
32393 [INTERNAL]  Count number of nodes
32394 
32395 ";
32396 
32397 %feature("docstring")  casadi::GenericMatrixCommon::norm_inf(const MatType
32398 &x) "
32399 
32400 [INTERNAL]  Infinity-norm.
32401 
32402 ";
32403 
32404 %feature("docstring") casadi::casadi_norm_inf "
32405 
32406 Infinity-norm.
32407 
32408 ";
32409 
32410 %feature("docstring")  casadi::GenericMatrixCommon::casadi_norm_inf "
32411 
32412 Infinity-norm.
32413 
32414 ";
32415 
32416 %feature("docstring")  casadi::GenericMatrixCommon::mmin(const MatType &x) "
32417 
32418 [INTERNAL]  Smallest element in a matrix.
32419 
32420 ";
32421 
32422 %feature("docstring") casadi::casadi_mmin "
32423 
32424 Smallest element in a matrix.
32425 
32426 ";
32427 
32428 %feature("docstring")  casadi::GenericMatrixCommon::casadi_mmin "
32429 
32430 Smallest element in a matrix.
32431 
32432 ";
32433 
32434 %feature("docstring")  casadi::GenericMatrixCommon::is_dense() const  "
32435 
32436 Check if the matrix expression is dense.
32437 
32438 ";
32439 
32440 %feature("docstring")  casadi::GenericMatrixCommon::tril2symm(const MatType
32441 &a) "
32442 
32443 Convert a lower triangular matrix to a symmetric one.
32444 
32445 ";
32446 
32447 %feature("docstring") casadi::casadi_tril2symm "
32448 
32449 Convert a lower triangular matrix to a symmetric one.
32450 
32451 ";
32452 
32453 %feature("docstring")  casadi::GenericMatrixCommon::casadi_tril2symm "
32454 
32455 Convert a lower triangular matrix to a symmetric one.
32456 
32457 ";
32458 
32459 %feature("docstring")  casadi::GenericMatrixCommon::nnz_lower() const  "
32460 
32461 Get the number of non-zeros in the lower triangular half.
32462 
32463 ";
32464 
32465 %feature("docstring")  casadi::GenericMatrixCommon::diag(const MatType &A) "
32466 
32467 [INTERNAL]  Get the diagonal of a matrix or construct a diagonal When the
32468 input is square, the diagonal elements are returned. If the input is vector-
32469 like, a diagonal matrix is constructed with it.
32470 
32471 ";
32472 
32473 %feature("docstring") casadi::casadi_diag "
32474 
32475 Get the diagonal of a matrix or construct a diagonal When the input is
32476 square, the diagonal elements are returned. If the input is vector- like, a
32477 diagonal matrix is constructed with it.
32478 
32479 ";
32480 
32481 %feature("docstring")  casadi::GenericMatrixCommon::casadi_diag "
32482 
32483 Get the diagonal of a matrix or construct a diagonal When the input is
32484 square, the diagonal elements are returned. If the input is vector- like, a
32485 diagonal matrix is constructed with it.
32486 
32487 ";
32488 
32489 %feature("docstring")  casadi::GenericMatrixCommon::is_linear(const MatType
32490 &expr, const MatType &var) "
32491 
32492 Is expr linear in var?
32493 
32494 False negatives are possible (an expression may not be recognised as linear
32495 while it really is), false positives not.
32496 
32497 ";
32498 
32499 %feature("docstring") casadi::casadi_is_linear "
32500 
32501 Is expr linear in var?
32502 
32503 False negatives are possible (an expression may not be recognised as linear
32504 while it really is), false positives not.
32505 
32506 ";
32507 
32508 %feature("docstring")  casadi::GenericMatrixCommon::casadi_is_linear "
32509 
32510 Is expr linear in var?
32511 
32512 False negatives are possible (an expression may not be recognised as linear
32513 while it really is), false positives not.
32514 
32515 ";
32516 
32517 %feature("docstring")  casadi::GenericMatrixCommon::unite(const MatType &A,
32518 const MatType &B) "
32519 
32520 [INTERNAL]  Unite two matrices no overlapping sparsity.
32521 
32522 ";
32523 
32524 %feature("docstring") casadi::casadi_unite "
32525 
32526 Unite two matrices no overlapping sparsity.
32527 
32528 ";
32529 
32530 %feature("docstring")  casadi::GenericMatrixCommon::casadi_unite "
32531 
32532 Unite two matrices no overlapping sparsity.
32533 
32534 ";
32535 
32536 %feature("docstring")  casadi::GenericMatrixCommon::rank1(const MatType &A,
32537 const MatType &alpha, const MatType &x, const MatType &y) "
32538 
32539 Make a rank-1 update to a matrix A Calculates A + 1/2 * alpha * x*y'.
32540 
32541 ";
32542 
32543 %feature("docstring") casadi::casadi_rank1 "
32544 
32545 Make a rank-1 update to a matrix A Calculates A + 1/2 * alpha * x*y'.
32546 
32547 ";
32548 
32549 %feature("docstring")  casadi::GenericMatrixCommon::casadi_rank1 "
32550 
32551 Make a rank-1 update to a matrix A Calculates A + 1/2 * alpha * x*y'.
32552 
32553 ";
32554 
32555 %feature("docstring")  casadi::GenericMatrixCommon::rank1(const MatType &A,
32556 const MatType &alpha, const MatType &x, const MatType &y) "
32557 
32558 Make a rank-1 update to a matrix A Calculates A + 1/2 * alpha * x*y'.
32559 
32560 ";
32561 
32562 %feature("docstring") casadi::casadi_rank1 "
32563 
32564 Make a rank-1 update to a matrix A Calculates A + 1/2 * alpha * x*y'.
32565 
32566 ";
32567 
32568 %feature("docstring")  casadi::GenericMatrixCommon::casadi_rank1 "
32569 
32570 Make a rank-1 update to a matrix A Calculates A + 1/2 * alpha * x*y'.
32571 
32572 ";
32573 
32574 %feature("docstring")  casadi::GenericMatrixCommon::gradient(const MatType
32575 &ex, const MatType &arg, const Dict &opts=Dict()) "
32576 
32577 Calculate Jacobian.
32578 
32579 ";
32580 
32581 %feature("docstring") casadi::casadi_gradient "
32582 
32583 Calculate Jacobian.
32584 
32585 ";
32586 
32587 %feature("docstring")  casadi::GenericMatrixCommon::casadi_gradient "
32588 
32589 Calculate Jacobian.
32590 
32591 ";
32592 
32593 %feature("docstring")  casadi::GenericMatrixCommon::gradient(const MatType
32594 &ex, const MatType &arg, const Dict &opts=Dict()) "
32595 
32596 Functions called by friend functions defined here
32597 
32598 ";
32599 
32600 %feature("docstring")  casadi::GenericMatrixCommon::symvar(const MatType &x)
32601 "
32602 
32603 [INTERNAL]  Get all symbols contained in the supplied expression Get all
32604 symbols on which the supplied expression depends.
32605 
32606 See:  SXFunction::getFree(), MXFunction::getFree()
32607 
32608 ";
32609 
32610 %feature("docstring") casadi::casadi_symvar "
32611 
32612 Get all symbols contained in the supplied expression Get all symbols on
32613 which the supplied expression depends.
32614 
32615 See:  SXFunction::getFree(), MXFunction::getFree()
32616 
32617 ";
32618 
32619 %feature("docstring")  casadi::GenericMatrixCommon::casadi_symvar "
32620 
32621 Get all symbols contained in the supplied expression Get all symbols on
32622 which the supplied expression depends.
32623 
32624 See:  SXFunction::getFree(), MXFunction::getFree()
32625 
32626 ";
32627 
32628 %feature("docstring")  casadi::GenericMatrixCommon::skew(const MatType &a) "
32629 
32630 Generate a skew symmetric matrix from a 3-vector.
32631 
32632 ";
32633 
32634 %feature("docstring") casadi::casadi_skew "
32635 
32636 Generate a skew symmetric matrix from a 3-vector.
32637 
32638 ";
32639 
32640 %feature("docstring")  casadi::GenericMatrixCommon::casadi_skew "
32641 
32642 Generate a skew symmetric matrix from a 3-vector.
32643 
32644 ";
32645 
32646 %feature("docstring")  casadi::GenericMatrixCommon::is_scalar(bool
32647 scalar_and_dense=false) const  "
32648 
32649 Check if the matrix expression is scalar.
32650 
32651 ";
32652 
32653 %feature("docstring")  casadi::GenericMatrixCommon::expm_const(const MatType
32654 &A, const MatType &t) "
32655 
32656 [INTERNAL] ";
32657 
32658 %feature("docstring")  casadi::GenericMatrixCommon::columns() const  "
32659 
32660 Get the number of columns, Octave-style syntax.
32661 
32662 ";
32663 
32664 %feature("docstring")  casadi::GenericMatrixCommon::is_column() const  "
32665 
32666 Check if the matrix is a column vector (i.e. size2()==1)
32667 
32668 ";
32669 
32670 %feature("docstring")  casadi::GenericMatrixCommon::quadratic_coeff(const
32671 MatType &expr, const MatType &var, MatType &A, MatType &b, MatType &c, bool
32672 check=true) "
32673 
32674 Recognizes quadratic form in scalar expression.
32675 
32676 1/2*x' A x + b' x + c
32677 
32678 e = 0.5*bilin(A,x,x)+dot(b,x)+c
32679 
32680 Parameters:
32681 -----------
32682 
32683 check[in]:  When true (default), A is checked to be independent of x.
32684 Provided to deal with false positive dependency checks.
32685 
32686 ";
32687 
32688 %feature("docstring") casadi::casadi_quadratic_coeff "
32689 
32690 Recognizes quadratic form in scalar expression.
32691 
32692 1/2*x' A x + b' x + c
32693 
32694 e = 0.5*bilin(A,x,x)+dot(b,x)+c
32695 
32696 Parameters:
32697 -----------
32698 
32699 check[in]:  When true (default), A is checked to be independent of x.
32700 Provided to deal with false positive dependency checks.
32701 
32702 ";
32703 
32704 %feature("docstring")  casadi::GenericMatrixCommon::casadi_quadratic_coeff "
32705 
32706 Recognizes quadratic form in scalar expression.
32707 
32708 1/2*x' A x + b' x + c
32709 
32710 e = 0.5*bilin(A,x,x)+dot(b,x)+c
32711 
32712 Parameters:
32713 -----------
32714 
32715 check[in]:  When true (default), A is checked to be independent of x.
32716 Provided to deal with false positive dependency checks.
32717 
32718 ";
32719 
32720 %feature("docstring")  casadi::GenericMatrixCommon::is_tril() const  "
32721 
32722 Check if the matrix is lower triangular.
32723 
32724 ";
32725 
32726 %feature("docstring")  casadi::GenericMatrixCommon::colind(casadi_int col)
32727 const  "
32728 
32729 Get the sparsity pattern. See the Sparsity class for details.
32730 
32731 ";
32732 
32733 %feature("docstring")  casadi::GenericMatrixCommon::is_triu() const  "
32734 
32735 Check if the matrix is upper triangular.
32736 
32737 ";
32738 
32739 %feature("docstring")  casadi::GenericMatrixCommon::depends_on(const MatType
32740 &f, const MatType &arg) "
32741 
32742 [INTERNAL]  Check if expression depends on the argument The argument must be
32743 symbolic.
32744 
32745 ";
32746 
32747 %feature("docstring") casadi::casadi_depends_on "
32748 
32749 Check if expression depends on the argument The argument must be symbolic.
32750 
32751 ";
32752 
32753 %feature("docstring")  casadi::GenericMatrixCommon::casadi_depends_on "
32754 
32755 Check if expression depends on the argument The argument must be symbolic.
32756 
32757 ";
32758 
32759 %feature("docstring")  casadi::GenericMatrixCommon::dim(bool with_nz=false)
32760 const  "
32761 
32762 Get string representation of dimensions. The representation is e.g. \"4x5\"
32763 or \"4x5,10nz\".
32764 
32765 ";
32766 
32767 %feature("docstring")  casadi::GenericMatrixCommon::mrdivide(const MatType
32768 &x, const MatType &n) "
32769 
32770 [INTERNAL]   Matrix divide (cf. slash '/' in MATLAB)
32771 
32772 ";
32773 
32774 %feature("docstring") casadi::casadi_mrdivide "
32775 
32776 Matrix divide (cf. slash '/' in MATLAB)
32777 
32778 ";
32779 
32780 %feature("docstring")  casadi::GenericMatrixCommon::casadi_mrdivide "
32781 
32782 Matrix divide (cf. slash '/' in MATLAB)
32783 
32784 ";
32785 
32786 %feature("docstring")  casadi::GenericMatrixCommon::linspace(const MatType
32787 &a, const MatType &b, casadi_int nsteps) "
32788 
32789 Matlab's linspace command.
32790 
32791 ";
32792 
32793 %feature("docstring") casadi::casadi_linspace "
32794 
32795 Matlab's linspace command.
32796 
32797 ";
32798 
32799 %feature("docstring")  casadi::GenericMatrixCommon::casadi_linspace "
32800 
32801 Matlab's linspace command.
32802 
32803 ";
32804 
32805 %feature("docstring")  casadi::GenericMatrixCommon::triu2symm(const MatType
32806 &a) "
32807 
32808 Convert a upper triangular matrix to a symmetric one.
32809 
32810 ";
32811 
32812 %feature("docstring") casadi::casadi_triu2symm "
32813 
32814 Convert a upper triangular matrix to a symmetric one.
32815 
32816 ";
32817 
32818 %feature("docstring")  casadi::GenericMatrixCommon::casadi_triu2symm "
32819 
32820 Convert a upper triangular matrix to a symmetric one.
32821 
32822 ";
32823 
32824 %feature("docstring")  casadi::GenericMatrixCommon::size1() const  "
32825 
32826 Get the first dimension (i.e. number of rows)
32827 
32828 ";
32829 
32830 %feature("docstring")  casadi::GenericMatrixCommon::size2() const  "
32831 
32832 Get the second dimension (i.e. number of columns)
32833 
32834 ";
32835 
32836 %feature("docstring")  casadi::GenericMatrixCommon::cross(const MatType &a,
32837 const MatType &b, casadi_int dim=-1) "
32838 
32839 Matlab's cross command.
32840 
32841 ";
32842 
32843 %feature("docstring") casadi::casadi_cross "
32844 
32845 Matlab's cross command.
32846 
32847 ";
32848 
32849 %feature("docstring")  casadi::GenericMatrixCommon::casadi_cross "
32850 
32851 Matlab's cross command.
32852 
32853 ";
32854 
32855 %feature("docstring")  casadi::GenericMatrixCommon::mldivide(const MatType
32856 &x, const MatType &n) "
32857 
32858 [INTERNAL]   Matrix divide (cf. backslash '\\\\' in MATLAB)
32859 
32860 ";
32861 
32862 %feature("docstring") casadi::casadi_mldivide "
32863 
32864 Matrix divide (cf. backslash '\\\\' in MATLAB)
32865 
32866 ";
32867 
32868 %feature("docstring")  casadi::GenericMatrixCommon::casadi_mldivide "
32869 
32870 Matrix divide (cf. backslash '\\\\' in MATLAB)
32871 
32872 ";
32873 
32874 %feature("docstring")  casadi::GenericMatrixCommon::tangent(const MatType
32875 &ex, const MatType &arg, const Dict &opts=Dict()) "
32876 
32877 Calculate Jacobian.
32878 
32879 ";
32880 
32881 %feature("docstring") casadi::casadi_tangent "
32882 
32883 Calculate Jacobian.
32884 
32885 ";
32886 
32887 %feature("docstring")  casadi::GenericMatrixCommon::casadi_tangent "
32888 
32889 Calculate Jacobian.
32890 
32891 ";
32892 
32893 %feature("docstring")  casadi::GenericMatrixCommon::tangent(const MatType
32894 &ex, const MatType &arg, const Dict &opts=Dict()) "
32895 
32896 Functions called by friend functions defined here
32897 
32898 ";
32899 
32900 %feature("docstring")  casadi::GenericMatrixCommon::substitute(const MatType
32901 &ex, const MatType &v, const MatType &vdef) "
32902 
32903 [INTERNAL]  Substitute variable v with expression vdef in an expression ex.
32904 
32905 ";
32906 
32907 %feature("docstring") casadi::casadi_substitute "
32908 
32909 Substitute variable v with expression vdef in an expression ex.
32910 
32911 ";
32912 
32913 %feature("docstring")  casadi::GenericMatrixCommon::casadi_substitute "
32914 
32915 Substitute variable v with expression vdef in an expression ex.
32916 
32917 ";
32918 
32919 %feature("docstring")  casadi::GenericMatrixCommon::substitute(const
32920 std::vector< MatType > &ex, const std::vector< MatType > &v, const
32921 std::vector< MatType > &vdef) "
32922 
32923 [INTERNAL]  Substitute variable var with expression expr in multiple
32924 expressions.
32925 
32926 ";
32927 
32928 %feature("docstring") casadi::casadi_substitute "
32929 
32930 Substitute variable var with expression expr in multiple expressions.
32931 
32932 ";
32933 
32934 %feature("docstring")  casadi::GenericMatrixCommon::casadi_substitute "
32935 
32936 Substitute variable var with expression expr in multiple expressions.
32937 
32938 ";
32939 
32940 %feature("docstring")  casadi::GenericMatrixCommon::inv_skew(const MatType
32941 &a) "
32942 
32943 Generate the 3-vector progenitor of a skew symmetric matrix.
32944 
32945 ";
32946 
32947 %feature("docstring") casadi::casadi_inv_skew "
32948 
32949 Generate the 3-vector progenitor of a skew symmetric matrix.
32950 
32951 ";
32952 
32953 %feature("docstring")  casadi::GenericMatrixCommon::casadi_inv_skew "
32954 
32955 Generate the 3-vector progenitor of a skew symmetric matrix.
32956 
32957 ";
32958 
32959 %feature("docstring")  casadi::GenericMatrixCommon::bilin(const MatType &A,
32960 const MatType &x, const MatType &y) "
32961 
32962 Calculate bilinear form x^T A y.
32963 
32964 ";
32965 
32966 %feature("docstring") casadi::casadi_bilin "
32967 
32968 Calculate bilinear form x^T A y.
32969 
32970 ";
32971 
32972 %feature("docstring")  casadi::GenericMatrixCommon::casadi_bilin "
32973 
32974 Calculate bilinear form x^T A y.
32975 
32976 ";
32977 
32978 %feature("docstring")  casadi::GenericMatrixCommon::bilin(const MatType &A,
32979 const MatType &x, const MatType &y) "
32980 
32981 Calculate bilinear form x^T A y.
32982 
32983 ";
32984 
32985 %feature("docstring") casadi::casadi_bilin "
32986 
32987 Calculate bilinear form x^T A y.
32988 
32989 ";
32990 
32991 %feature("docstring")  casadi::GenericMatrixCommon::casadi_bilin "
32992 
32993 Calculate bilinear form x^T A y.
32994 
32995 ";
32996 
32997 %feature("docstring")  casadi::GenericMatrixCommon::inv_minor(const MatType
32998 &A) "
32999 
33000 [INTERNAL]   Matrix inverse (experimental)
33001 
33002 ";
33003 
33004 %feature("docstring") casadi::casadi_inv_minor "
33005 
33006 Matrix inverse (experimental)
33007 
33008 ";
33009 
33010 %feature("docstring")  casadi::GenericMatrixCommon::casadi_inv_minor "
33011 
33012 Matrix inverse (experimental)
33013 
33014 ";
33015 
33016 %feature("docstring")  casadi::GenericMatrixCommon::norm_1(const MatType &x)
33017 "
33018 
33019 [INTERNAL]  1-norm
33020 
33021 ";
33022 
33023 %feature("docstring") casadi::casadi_norm_1 "
33024 
33025 1-norm
33026 
33027 ";
33028 
33029 %feature("docstring")  casadi::GenericMatrixCommon::casadi_norm_1 "
33030 
33031 1-norm
33032 
33033 ";
33034 
33035 %feature("docstring")  casadi::GenericMatrixCommon::norm_2(const MatType &x)
33036 "
33037 
33038 [INTERNAL]  2-norm
33039 
33040 ";
33041 
33042 %feature("docstring") casadi::casadi_norm_2 "
33043 
33044 2-norm
33045 
33046 ";
33047 
33048 %feature("docstring")  casadi::GenericMatrixCommon::casadi_norm_2 "
33049 
33050 2-norm
33051 
33052 ";
33053 
33054 %feature("docstring")  casadi::GenericMatrixCommon::get_colind() const  "
33055 
33056 Get the sparsity pattern. See the Sparsity class for details.
33057 
33058 ";
33059 
33060 %feature("docstring")  casadi::GenericMatrixCommon::is_empty(bool
33061 both=false) const  "
33062 
33063 Check if the sparsity is empty, i.e. if one of the dimensions is zero (or
33064 optionally both dimensions)
33065 
33066 ";
33067 
33068 %feature("docstring")  casadi::GenericMatrixCommon::is_row() const  "
33069 
33070 Check if the matrix is a row vector (i.e. size1()==1)
33071 
33072 ";
33073 
33074 %feature("docstring")  casadi::GenericMatrixCommon::soc(const MatType &x,
33075 const MatType &y) "
33076 
33077 Construct second-order-convex.
33078 
33079 Parameters:
33080 -----------
33081 
33082 x:  vector expression of size n
33083 
33084 y:  scalar expression
33085 
33086 soc(x,y) computes [y*eye(n) x; x' y]
33087 
33088 soc(x,y) positive semi definite <=> || x ||_2 <= y
33089 
33090 ";
33091 
33092 %feature("docstring") casadi::casadi_soc "
33093 
33094 Construct second-order-convex.
33095 
33096 Parameters:
33097 -----------
33098 
33099 x:  vector expression of size n
33100 
33101 y:  scalar expression
33102 
33103 soc(x,y) computes [y*eye(n) x; x' y]
33104 
33105 soc(x,y) positive semi definite <=> || x ||_2 <= y
33106 
33107 ";
33108 
33109 %feature("docstring")  casadi::GenericMatrixCommon::casadi_soc "
33110 
33111 Construct second-order-convex.
33112 
33113 Parameters:
33114 -----------
33115 
33116 x:  vector expression of size n
33117 
33118 y:  scalar expression
33119 
33120 soc(x,y) computes [y*eye(n) x; x' y]
33121 
33122 soc(x,y) positive semi definite <=> || x ||_2 <= y
33123 
33124 ";
33125 
33126 %feature("docstring")  casadi::GenericMatrixCommon::soc(const MatType &x,
33127 const MatType &y) "
33128 
33129 Functions called by friend functions defined here
33130 
33131 ";
33132 
33133 %feature("docstring")  casadi::GenericMatrixCommon::is_square() const  "
33134 
33135 Check if the matrix expression is square.
33136 
33137 ";
33138 
33139 %feature("docstring")  casadi::GenericMatrixCommon::jtimes(const MatType
33140 &ex, const MatType &arg, const MatType &v, bool tr=false, const Dict
33141 &opts=Dict()) "
33142 
33143 Functions called by friend functions defined here
33144 
33145 ";
33146 
33147 %feature("docstring")  casadi::GenericMatrixCommon::jtimes(const MatType
33148 &ex, const MatType &arg, const MatType &v, bool tr=false, const Dict
33149 &opts=Dict()) "
33150 
33151 Calculate the Jacobian and multiply by a vector from the right This is
33152 equivalent to mul(jacobian(ex, arg), v) or mul(jacobian(ex, arg).T, v) for
33153 tr set to false and true respectively. If contrast to these expressions, it
33154 will use directional derivatives which is typically (but not necessarily)
33155 more efficient if the complete Jacobian is not needed and v has few rows.
33156 
33157 ";
33158 
33159 %feature("docstring") casadi::casadi_jtimes "
33160 
33161 Calculate the Jacobian and multiply by a vector from the right This is
33162 equivalent to mul(jacobian(ex, arg), v) or mul(jacobian(ex, arg).T, v) for
33163 tr set to false and true respectively. If contrast to these expressions, it
33164 will use directional derivatives which is typically (but not necessarily)
33165 more efficient if the complete Jacobian is not needed and v has few rows.
33166 
33167 ";
33168 
33169 %feature("docstring")  casadi::GenericMatrixCommon::casadi_jtimes "
33170 
33171 Calculate the Jacobian and multiply by a vector from the right This is
33172 equivalent to mul(jacobian(ex, arg), v) or mul(jacobian(ex, arg).T, v) for
33173 tr set to false and true respectively. If contrast to these expressions, it
33174 will use directional derivatives which is typically (but not necessarily)
33175 more efficient if the complete Jacobian is not needed and v has few rows.
33176 
33177 ";
33178 
33179 %feature("docstring")  casadi::GenericMatrixCommon::numel() const  "
33180 
33181 Get the number of elements.
33182 
33183 ";
33184 
33185 %feature("docstring")  casadi::GenericMatrixCommon::linear_coeff(const
33186 MatType &expr, const MatType &var, MatType &A, MatType &b, bool check=true)
33187 "
33188 
33189 Recognizes linear form in vector expression.
33190 
33191 A x + b
33192 
33193 Parameters:
33194 -----------
33195 
33196 check[in]:  When true (default)m, A is checked to be independent of x.
33197 Provided to deal with false positive dependency checks.
33198 
33199 ";
33200 
33201 %feature("docstring") casadi::casadi_linear_coeff "
33202 
33203 Recognizes linear form in vector expression.
33204 
33205 A x + b
33206 
33207 Parameters:
33208 -----------
33209 
33210 check[in]:  When true (default)m, A is checked to be independent of x.
33211 Provided to deal with false positive dependency checks.
33212 
33213 ";
33214 
33215 %feature("docstring")  casadi::GenericMatrixCommon::casadi_linear_coeff "
33216 
33217 Recognizes linear form in vector expression.
33218 
33219 A x + b
33220 
33221 Parameters:
33222 -----------
33223 
33224 check[in]:  When true (default)m, A is checked to be independent of x.
33225 Provided to deal with false positive dependency checks.
33226 
33227 ";
33228 
33229 %feature("docstring")  casadi::GenericMatrixCommon::repsum(const MatType &A,
33230 casadi_int n, casadi_int m=1) "
33231 
33232 Given a repeated matrix, computes the sum of repeated parts.
33233 
33234 ";
33235 
33236 %feature("docstring") casadi::casadi_repsum "
33237 
33238 Given a repeated matrix, computes the sum of repeated parts.
33239 
33240 ";
33241 
33242 %feature("docstring")  casadi::GenericMatrixCommon::casadi_repsum "
33243 
33244 Given a repeated matrix, computes the sum of repeated parts.
33245 
33246 ";
33247 
33248 %feature("docstring")  casadi::GenericMatrixCommon::einstein(const MatType
33249 &A, const MatType &B, const MatType &C, const std::vector< casadi_int >
33250 &dim_a, const std::vector< casadi_int > &dim_b, const std::vector<
33251 casadi_int > &dim_c, const std::vector< casadi_int > &a, const std::vector<
33252 casadi_int > &b, const std::vector< casadi_int > &c) "
33253 
33254 [INTERNAL]  Compute any contraction of two dense tensors, using
33255 index/einstein notation einstein(A, B, a, b, c) -> C.
33256 
33257 Given two tensors, A and B, computes a third tensor C such that:
33258 
33259 C_c = A_a * B_b
33260 
33261 With a, b, c representing einstein indices. Instead of the classical index
33262 labels i,j,k,... we employ -1,-2,-3,...
33263 
33264 A, B, C are represented as CasADi vectors, with dim_a, dim_b, dim_c
33265 indictating theire tensorial dimensions.
33266 
33267 ";
33268 
33269 %feature("docstring") casadi::casadi_einstein "
33270 
33271 Compute any contraction of two dense tensors, using index/einstein notation
33272 einstein(A, B, a, b, c) -> C.
33273 
33274 Given two tensors, A and B, computes a third tensor C such that:
33275 
33276 C_c = A_a * B_b
33277 
33278 With a, b, c representing einstein indices. Instead of the classical index
33279 labels i,j,k,... we employ -1,-2,-3,...
33280 
33281 A, B, C are represented as CasADi vectors, with dim_a, dim_b, dim_c
33282 indictating theire tensorial dimensions.
33283 
33284 ";
33285 
33286 %feature("docstring")  casadi::GenericMatrixCommon::casadi_einstein "
33287 
33288 Compute any contraction of two dense tensors, using index/einstein notation
33289 einstein(A, B, a, b, c) -> C.
33290 
33291 Given two tensors, A and B, computes a third tensor C such that:
33292 
33293 C_c = A_a * B_b
33294 
33295 With a, b, c representing einstein indices. Instead of the classical index
33296 labels i,j,k,... we employ -1,-2,-3,...
33297 
33298 A, B, C are represented as CasADi vectors, with dim_a, dim_b, dim_c
33299 indictating theire tensorial dimensions.
33300 
33301 ";
33302 
33303 %feature("docstring")  casadi::GenericMatrixCommon::einstein(const MatType
33304 &A, const MatType &B, const std::vector< casadi_int > &dim_a, const
33305 std::vector< casadi_int > &dim_b, const std::vector< casadi_int > &dim_c,
33306 const std::vector< casadi_int > &a, const std::vector< casadi_int > &b,
33307 const std::vector< casadi_int > &c) "
33308 
33309 [INTERNAL]  Performs 1d linear interpolation.
33310 
33311 The data-points to be interpolated are given as (x[i], v[i]). xq[j] is used
33312 as interplating value
33313 
33314 ";
33315 
33316 %feature("docstring") casadi::casadi_einstein "
33317 
33318 Performs 1d linear interpolation.
33319 
33320 The data-points to be interpolated are given as (x[i], v[i]). xq[j] is used
33321 as interplating value
33322 
33323 ";
33324 
33325 %feature("docstring")  casadi::GenericMatrixCommon::casadi_einstein "
33326 
33327 Performs 1d linear interpolation.
33328 
33329 The data-points to be interpolated are given as (x[i], v[i]). xq[j] is used
33330 as interplating value
33331 
33332 ";
33333 
33334 %feature("docstring")  casadi::GenericMatrixCommon::polyval(const MatType
33335 &p, const MatType &x) "
33336 
33337 [INTERNAL]  Evaluate a polynomial with coefficients p in x.
33338 
33339 ";
33340 
33341 %feature("docstring") casadi::casadi_polyval "
33342 
33343 Evaluate a polynomial with coefficients p in x.
33344 
33345 ";
33346 
33347 %feature("docstring")  casadi::GenericMatrixCommon::casadi_polyval "
33348 
33349 Evaluate a polynomial with coefficients p in x.
33350 
33351 ";
33352 
33353 %feature("docstring")  casadi::GenericMatrixCommon::nnz() const  "
33354 
33355 Get the number of (structural) non-zero elements.
33356 
33357 ";
33358 
33359 %feature("docstring")  casadi::GenericMatrixCommon::sym(const std::string
33360 &name, casadi_int nrow=1, casadi_int ncol=1) "
33361 
33362 Create an nrow-by-ncol symbolic primitive.
33363 
33364 ";
33365 
33366 %feature("docstring")  casadi::GenericMatrixCommon::sym(const std::string
33367 &name, const std::pair< casadi_int, casadi_int > &rc) "
33368 
33369 Construct a symbolic primitive with given dimensions.
33370 
33371 ";
33372 
33373 %feature("docstring")  casadi::GenericMatrixCommon::sym(const std::string
33374 &name, const Sparsity &sp) "
33375 
33376 Create symbolic primitive with a given sparsity pattern.
33377 
33378 ";
33379 
33380 %feature("docstring")  casadi::GenericMatrixCommon::sym(const std::string
33381 &name, const Sparsity &sp, casadi_int p) "
33382 
33383 Create a vector of length p with with matrices with symbolic primitives of
33384 given sparsity.
33385 
33386 ";
33387 
33388 %feature("docstring")  casadi::GenericMatrixCommon::sym(const std::string
33389 &name, casadi_int nrow, casadi_int ncol, casadi_int p) "
33390 
33391 Create a vector of length p with nrow-by-ncol symbolic primitives.
33392 
33393 ";
33394 
33395 %feature("docstring")  casadi::GenericMatrixCommon::sym(const std::string
33396 &name, const Sparsity &sp, casadi_int p, casadi_int r) "
33397 
33398 Create a vector of length r of vectors of length p with symbolic primitives
33399 with given sparsity.
33400 
33401 ";
33402 
33403 %feature("docstring")  casadi::GenericMatrixCommon::sym(const std::string
33404 &name, casadi_int nrow, casadi_int ncol, casadi_int p, casadi_int r) "
33405 
33406 Create a vector of length r of vectors of length p with nrow-by-ncol
33407 symbolic primitives.
33408 
33409 ";
33410 
33411 %feature("docstring")  casadi::GenericMatrixCommon::row(casadi_int el) const
33412 "
33413 
33414 Get the sparsity pattern. See the Sparsity class for details.
33415 
33416 ";
33417 
33418 %feature("docstring")  casadi::GenericMatrixCommon::diff(const MatType &x,
33419 casadi_int n=1, casadi_int axis=-1) "
33420 
33421 Returns difference (n-th order) along given axis (MATLAB convention)
33422 
33423 ";
33424 
33425 %feature("docstring") casadi::casadi_diff "
33426 
33427 Returns difference (n-th order) along given axis (MATLAB convention)
33428 
33429 ";
33430 
33431 %feature("docstring")  casadi::GenericMatrixCommon::casadi_diff "
33432 
33433 Returns difference (n-th order) along given axis (MATLAB convention)
33434 
33435 ";
33436 
33437 %feature("docstring")  casadi::GenericMatrixCommon::nullspace(const MatType
33438 &A) "
33439 
33440 [INTERNAL]  Computes the nullspace of a matrix A.
33441 
33442 Finds Z m-by-(m-n) such that AZ = 0 with A n-by-m with m > n
33443 
33444 Assumes A is full rank
33445 
33446 Inspired by Numerical Methods in Scientific Computing by Ake Bjorck
33447 
33448 ";
33449 
33450 %feature("docstring") casadi::casadi_nullspace "
33451 
33452 Computes the nullspace of a matrix A.
33453 
33454 Finds Z m-by-(m-n) such that AZ = 0 with A n-by-m with m > n
33455 
33456 Assumes A is full rank
33457 
33458 Inspired by Numerical Methods in Scientific Computing by Ake Bjorck
33459 
33460 ";
33461 
33462 %feature("docstring")  casadi::GenericMatrixCommon::casadi_nullspace "
33463 
33464 Computes the nullspace of a matrix A.
33465 
33466 Finds Z m-by-(m-n) such that AZ = 0 with A n-by-m with m > n
33467 
33468 Assumes A is full rank
33469 
33470 Inspired by Numerical Methods in Scientific Computing by Ake Bjorck
33471 
33472 ";
33473 
33474 %feature("docstring")  casadi::GenericMatrixCommon::nnz_upper() const  "
33475 
33476 Get the number of non-zeros in the upper triangular half.
33477 
33478 ";
33479 
33480 %feature("docstring")  casadi::GenericMatrixCommon::sumsqr(const MatType &x)
33481 "
33482 
33483 [INTERNAL]  Calculate sum of squares: sum_ij X_ij^2.
33484 
33485 ";
33486 
33487 %feature("docstring") casadi::casadi_sumsqr "
33488 
33489 Calculate sum of squares: sum_ij X_ij^2.
33490 
33491 ";
33492 
33493 %feature("docstring")  casadi::GenericMatrixCommon::casadi_sumsqr "
33494 
33495 Calculate sum of squares: sum_ij X_ij^2.
33496 
33497 ";
33498 
33499 %feature("docstring")  casadi::GenericMatrixCommon::norm_fro(const MatType
33500 &x) "
33501 
33502 [INTERNAL]  Frobenius norm.
33503 
33504 ";
33505 
33506 %feature("docstring") casadi::casadi_norm_fro "
33507 
33508 Frobenius norm.
33509 
33510 ";
33511 
33512 %feature("docstring")  casadi::GenericMatrixCommon::casadi_norm_fro "
33513 
33514 Frobenius norm.
33515 
33516 ";
33517 
33518 %feature("docstring")  casadi::GenericMatrixCommon::sparsity() const  "
33519 
33520 Get the sparsity pattern.
33521 
33522 ";
33523 
33524 %feature("docstring") casadi::casadi_sparsity "
33525 
33526 Get the sparsity pattern.
33527 
33528 ";
33529 
33530 %feature("docstring")  casadi::GenericMatrixCommon::casadi_sparsity "
33531 
33532 Get the sparsity pattern.
33533 
33534 ";
33535 
33536 %feature("docstring")  casadi::GenericMatrixCommon::inv(const MatType &A) "
33537 
33538 [INTERNAL]   Matrix inverse.
33539 
33540 ";
33541 
33542 %feature("docstring") casadi::casadi_inv "
33543 
33544 Matrix inverse.
33545 
33546 ";
33547 
33548 %feature("docstring")  casadi::GenericMatrixCommon::casadi_inv "
33549 
33550 Matrix inverse.
33551 
33552 ";
33553 
33554 %feature("docstring")  casadi::GenericMatrixCommon::inv(const MatType &A,
33555 const std::string &lsolver, const Dict &options=Dict()) "
33556 
33557 [INTERNAL]   Matrix inverse.
33558 
33559 ";
33560 
33561 %feature("docstring") casadi::casadi_inv "
33562 
33563 Matrix inverse.
33564 
33565 ";
33566 
33567 %feature("docstring")  casadi::GenericMatrixCommon::casadi_inv "
33568 
33569 Matrix inverse.
33570 
33571 ";
33572 
33573 %feature("docstring")  casadi::GenericMatrixCommon::interp1d(const
33574 std::vector< double > &x, const MatType &v, const std::vector< double > &xq,
33575 const std::string &mode, bool equidistant=false) "
33576 
33577 Performs 1d linear interpolation.
33578 
33579 The data-points to be interpolated are given as (x[i], v[i]). xq[j] is used
33580 as interplating value
33581 
33582 ";
33583 
33584 %feature("docstring") casadi::casadi_interp1d "
33585 
33586 Performs 1d linear interpolation.
33587 
33588 The data-points to be interpolated are given as (x[i], v[i]). xq[j] is used
33589 as interplating value
33590 
33591 ";
33592 
33593 %feature("docstring")  casadi::GenericMatrixCommon::casadi_interp1d "
33594 
33595 Performs 1d linear interpolation.
33596 
33597 The data-points to be interpolated are given as (x[i], v[i]). xq[j] is used
33598 as interplating value
33599 
33600 ";
33601 
33602 %feature("docstring")  casadi::GenericMatrixCommon::mpower(const MatType &x,
33603 const MatType &n) "
33604 
33605 Matrix power x^n.
33606 
33607 ";
33608 
33609 %feature("docstring") casadi::casadi_mpower "
33610 
33611 Matrix power x^n.
33612 
33613 ";
33614 
33615 %feature("docstring")  casadi::GenericMatrixCommon::casadi_mpower "
33616 
33617 Matrix power x^n.
33618 
33619 ";
33620 
33621 %feature("docstring")  casadi::GenericMatrixCommon::mpower(const MatType &x,
33622 const MatType &y) "
33623 
33624 Functions called by friend functions defined here
33625 
33626 ";
33627 
33628 %feature("docstring")  casadi::GenericMatrixCommon::hessian(const MatType
33629 &ex, const MatType &arg, const Dict &opts=Dict()) "
33630 
33631 [INTERNAL] ";
33632 
33633 %feature("docstring")  casadi::GenericMatrixCommon::hessian(const MatType
33634 &ex, const MatType &arg, MatType &output_g, const Dict &opts=Dict()) "
33635 
33636 [INTERNAL] ";
33637 
33638 %feature("docstring")  casadi::GenericMatrixCommon::reverse(const
33639 std::vector< MatType > &ex, const std::vector< MatType > &arg, const
33640 std::vector< std::vector< MatType > > &v, const Dict &opts=Dict()) "
33641 
33642 [INTERNAL]  Reverse directional derivative.
33643 
33644 ";
33645 
33646 %feature("docstring") casadi::casadi_reverse "
33647 
33648 Reverse directional derivative.
33649 
33650 ";
33651 
33652 %feature("docstring")  casadi::GenericMatrixCommon::casadi_reverse "
33653 
33654 Reverse directional derivative.
33655 
33656 ";
33657 
33658 %feature("docstring")  casadi::GenericMatrixCommon::which_depends(const
33659 MatType &expr, const MatType &var, casadi_int order, bool tr) "
33660 
33661 [INTERNAL]   Find out which variables enter with some order.
33662 
33663 ";
33664 
33665 %feature("docstring") casadi::casadi_which_depends "
33666 
33667 Find out which variables enter with some order.
33668 
33669 ";
33670 
33671 %feature("docstring")  casadi::GenericMatrixCommon::casadi_which_depends "
33672 
33673 Find out which variables enter with some order.
33674 
33675 ";
33676 
33677 %feature("docstring")  casadi::GenericMatrixCommon::forward(const
33678 std::vector< MatType > &ex, const std::vector< MatType > &arg, const
33679 std::vector< std::vector< MatType > > &v, const Dict &opts=Dict()) "
33680 
33681 [INTERNAL]  Forward directional derivative.
33682 
33683 ";
33684 
33685 %feature("docstring") casadi::casadi_forward "
33686 
33687 Forward directional derivative.
33688 
33689 ";
33690 
33691 %feature("docstring")  casadi::GenericMatrixCommon::casadi_forward "
33692 
33693 Forward directional derivative.
33694 
33695 ";
33696 
33697 %feature("docstring")  casadi::GenericMatrixCommon::size() const  "
33698 
33699 Get the shape.
33700 
33701 ";
33702 
33703 %feature("docstring")  casadi::GenericMatrixCommon::size(casadi_int axis)
33704 const  "
33705 
33706 Get the size along a particular dimensions.
33707 
33708 ";
33709 
33710 %feature("docstring") casadi::GenericMatrixCommon "
33711 
33712 Matrix base class.
33713 
33714 This is a common base class for MX and Matrix<>, introducing a uniform
33715 syntax and implementing common functionality using the curiously recurring
33716 template pattern (CRTP) idiom.  The class is designed with the idea that
33717 \"everything is a matrix\", that is, also scalars and vectors. This
33718 philosophy makes it easy to use and to interface in particularly with Python
33719 and Matlab/Octave.  The syntax tries to stay as close as possible to the
33720 ublas syntax when it comes to vector/matrix operations.  Index starts with
33721 0. Index vec happens as follows: (rr, cc) -> k = rr+cc*size1() Vectors are
33722 column vectors.  The storage format is Compressed Column Storage (CCS),
33723 similar to that used for sparse matrices in Matlab, but unlike this format,
33724 we do allow for elements to be structurally non-zero but numerically zero.
33725 The sparsity pattern, which is reference counted and cached, can be accessed
33726 with Sparsity& sparsity() Joel Andersson
33727 
33728 C++ includes: generic_matrix.hpp ";
33729 
33730 %feature("docstring")  casadi::GenericMatrixCommon::project(const MatType
33731 &A, const Sparsity &sp, bool intersect=false) "
33732 
33733 [INTERNAL]  Create a new matrix with a given sparsity pattern but with the
33734 nonzeros taken from an existing matrix.
33735 
33736 ";
33737 
33738 %feature("docstring") casadi::casadi_project "
33739 
33740 Create a new matrix with a given sparsity pattern but with the nonzeros
33741 taken from an existing matrix.
33742 
33743 ";
33744 
33745 %feature("docstring")  casadi::GenericMatrixCommon::casadi_project "
33746 
33747 Create a new matrix with a given sparsity pattern but with the nonzeros
33748 taken from an existing matrix.
33749 
33750 ";
33751 
33752 %feature("docstring")  casadi::GenericMatrixCommon::expm(const MatType &A) "
33753 
33754 [INTERNAL] ";
33755 
33756 %feature("docstring")  casadi::GenericMatrixCommon::densify(const MatType
33757 &x) "
33758 
33759 [INTERNAL]  Make the matrix dense if not already.
33760 
33761 ";
33762 
33763 %feature("docstring") casadi::casadi_densify "
33764 
33765 Make the matrix dense if not already.
33766 
33767 ";
33768 
33769 %feature("docstring")  casadi::GenericMatrixCommon::casadi_densify "
33770 
33771 Make the matrix dense if not already.
33772 
33773 ";
33774 
33775 %feature("docstring")  casadi::GenericMatrixCommon::densify(const MatType
33776 &x, const MatType &val) "
33777 
33778 [INTERNAL]  Make the matrix dense and assign nonzeros to a value.
33779 
33780 ";
33781 
33782 %feature("docstring") casadi::casadi_densify "
33783 
33784 Make the matrix dense and assign nonzeros to a value.
33785 
33786 ";
33787 
33788 %feature("docstring")  casadi::GenericMatrixCommon::casadi_densify "
33789 
33790 Make the matrix dense and assign nonzeros to a value.
33791 
33792 ";
33793 
33794 %feature("docstring")  casadi::GenericMatrixCommon::is_vector() const  "
33795 
33796 Check if the matrix is a row or column vector.
33797 
33798 ";
33799 
33800 %feature("docstring")  casadi::GenericMatrixCommon::det(const MatType &A) "
33801 
33802 [INTERNAL]   Matrix determinant (experimental)
33803 
33804 ";
33805 
33806 %feature("docstring") casadi::casadi_det "
33807 
33808 Matrix determinant (experimental)
33809 
33810 ";
33811 
33812 %feature("docstring")  casadi::GenericMatrixCommon::casadi_det "
33813 
33814 Matrix determinant (experimental)
33815 
33816 ";
33817 
33818 %feature("docstring")  casadi::GenericMatrixCommon::shared(std::vector<
33819 MatType > &ex, std::vector< MatType > &v, std::vector< MatType > &vdef,
33820 const std::string &v_prefix="v_", const std::string &v_suffix="") "
33821 
33822 [INTERNAL]  Extract shared subexpressions from an set of expressions.
33823 
33824 ";
33825 
33826 %feature("docstring") casadi::casadi_shared "
33827 
33828 Extract shared subexpressions from an set of expressions.
33829 
33830 ";
33831 
33832 %feature("docstring")  casadi::GenericMatrixCommon::casadi_shared "
33833 
33834 Extract shared subexpressions from an set of expressions.
33835 
33836 ";
33837 
33838 %feature("docstring")  casadi::GenericMatrixCommon::shared(const
33839 std::vector< MatType > &ex, std::vector< MatType > &ex_output, std::vector<
33840 MatType > &v, std::vector< MatType > &vdef, const std::string
33841 &v_prefix="v_", const std::string &v_suffix="") "
33842 
33843 [INTERNAL]  Extract shared subexpressions from an set of expressions.
33844 
33845 ";
33846 
33847 %feature("docstring") casadi::casadi_shared "
33848 
33849 Extract shared subexpressions from an set of expressions.
33850 
33851 ";
33852 
33853 %feature("docstring")  casadi::GenericMatrixCommon::casadi_shared "
33854 
33855 Extract shared subexpressions from an set of expressions.
33856 
33857 ";
33858 
33859 %feature("docstring")  casadi::GenericMatrixCommon::zeros(casadi_int nrow=1,
33860 casadi_int ncol=1) "
33861 
33862 Create a dense matrix or a matrix with specified sparsity with all entries
33863 zero.
33864 
33865 ";
33866 
33867 %feature("docstring")  casadi::GenericMatrixCommon::zeros(const Sparsity
33868 &sp) "
33869 
33870 Create a dense matrix or a matrix with specified sparsity with all entries
33871 zero.
33872 
33873 ";
33874 
33875 %feature("docstring")  casadi::GenericMatrixCommon::zeros(const std::pair<
33876 casadi_int, casadi_int > &rc) "
33877 
33878 Create a dense matrix or a matrix with specified sparsity with all entries
33879 zero.
33880 
33881 ";
33882 
33883 %feature("docstring")  casadi::GenericMatrixCommon::if_else(const MatType
33884 &cond, const MatType &if_true, const MatType &if_false, bool
33885 short_circuit=false) "
33886 
33887 [INTERNAL]  Branching on MX nodes Ternary operator, \"cond ? if_true :
33888 if_false\".
33889 
33890 ";
33891 
33892 %feature("docstring") casadi::casadi_if_else "
33893 
33894 Branching on MX nodes Ternary operator, \"cond ? if_true : if_false\".
33895 
33896 ";
33897 
33898 %feature("docstring")  casadi::GenericMatrixCommon::casadi_if_else "
33899 
33900 Branching on MX nodes Ternary operator, \"cond ? if_true : if_false\".
33901 
33902 ";
33903 
33904 %feature("docstring")  casadi::GenericMatrixCommon::rows() const  "
33905 
33906 Get the number of rows, Octave-style syntax.
33907 
33908 ";
33909 
33910 %feature("docstring")  casadi::GenericMatrixCommon::linearize(const MatType
33911 &f, const MatType &x, const MatType &x0, const Dict &opts=Dict()) "
33912 
33913 Functions called by friend functions defined here
33914 
33915 ";
33916 
33917 %feature("docstring")  casadi::GenericMatrixCommon::linearize(const MatType
33918 &f, const MatType &x, const MatType &x0, const Dict &opts=Dict()) "
33919 
33920 Linearize an expression.
33921 
33922 ";
33923 
33924 %feature("docstring") casadi::casadi_linearize "
33925 
33926 Linearize an expression.
33927 
33928 ";
33929 
33930 %feature("docstring")  casadi::GenericMatrixCommon::casadi_linearize "
33931 
33932 Linearize an expression.
33933 
33934 ";
33935 
33936 %feature("docstring")  casadi::GenericMatrixCommon::ones(casadi_int nrow=1,
33937 casadi_int ncol=1) "
33938 
33939 Create a dense matrix or a matrix with specified sparsity with all entries
33940 one.
33941 
33942 ";
33943 
33944 %feature("docstring")  casadi::GenericMatrixCommon::ones(const Sparsity &sp)
33945 "
33946 
33947 Create a dense matrix or a matrix with specified sparsity with all entries
33948 one.
33949 
33950 ";
33951 
33952 %feature("docstring")  casadi::GenericMatrixCommon::ones(const std::pair<
33953 casadi_int, casadi_int > &rc) "
33954 
33955 Create a dense matrix or a matrix with specified sparsity with all entries
33956 one.
33957 
33958 ";
33959 
33960 
33961 // File: classcasadi_1_1GenericType.xml
33962 %feature("docstring")  casadi::GenericType::serialize(SerializingStream &s)
33963 const  "
33964 
33965 Serialize an object.
33966 
33967 ";
33968 
33969 %feature("docstring") casadi::GenericType "
33970 
33971 Generic data type, can hold different types such as bool, casadi_int, string
33972 etc.
33973 
33974 Joel Andersson
33975 
33976 C++ includes: generic_type.hpp ";
33977 
33978 
33979 // File: classcasadi_1_1GenericTypeBase.xml
33980 %feature("docstring") casadi::GenericTypeBase::~GenericTypeBase "
33981 
33982 [INTERNAL] ";
33983 
33984 %feature("docstring")  casadi::SharedObjectInternal::weak() "
33985 
33986 [INTERNAL]  Get a weak reference to the object.
33987 
33988 ";
33989 
33990 %feature("docstring")  casadi::SharedObjectInternal::class_name() const  "
33991 
33992 [INTERNAL]  Readable name of the internal class.
33993 
33994 ";
33995 
33996 %feature("docstring")  casadi::GenericTypeBase::getType() const  "
33997 
33998 [INTERNAL] ";
33999 
34000 %feature("docstring")  casadi::GenericTypeBase::serialize(SerializingStream
34001 &s) const  "
34002 
34003 [INTERNAL] ";
34004 
34005 %feature("docstring")  casadi::SharedObjectInternal::disp(std::ostream
34006 &stream, bool more) const  "
34007 
34008 [INTERNAL]  Print a description of the object.
34009 
34010 ";
34011 
34012 %feature("docstring")  casadi::SharedObjectInternal::getCount() const  "
34013 
34014 [INTERNAL]  Get the reference count.
34015 
34016 ";
34017 
34018 %feature("docstring") casadi::GenericTypeBase "
34019 
34020 [INTERNAL] C++ includes: generic_type_internal.hpp ";
34021 
34022 
34023 // File: classcasadi_1_1GetNonzeros.xml
34024 
34025 
34026 // File: classcasadi_1_1GetNonzerosParam.xml
34027 
34028 
34029 // File: classcasadi_1_1GetNonzerosParamParam.xml
34030 
34031 
34032 // File: classcasadi_1_1GetNonzerosParamSlice.xml
34033 
34034 
34035 // File: classcasadi_1_1GetNonzerosParamVector.xml
34036 
34037 
34038 // File: classcasadi_1_1GetNonzerosSlice.xml
34039 
34040 
34041 // File: classcasadi_1_1GetNonzerosSlice2.xml
34042 
34043 
34044 // File: classcasadi_1_1GetNonzerosSliceParam.xml
34045 
34046 
34047 // File: classcasadi_1_1GetNonzerosVector.xml
34048 
34049 
34050 // File: classcasadi_1_1GlobalOptions.xml
34051 %feature("docstring") casadi::GlobalOptions "
34052 
34053 Collects global CasADi options.
34054 
34055 Note to developers: use sparingly. Global options are - in general - a
34056 rather bad idea
34057 
34058 this class must never be instantiated. Access its static members directly
34059 Joris Gillis
34060 
34061 C++ includes: global_options.hpp ";
34062 
34063 
34064 // File: classcasadi_1_1Horzcat.xml
34065 
34066 
34067 // File: classcasadi_1_1HorzRepmat.xml
34068 
34069 
34070 // File: classcasadi_1_1HorzRepsum.xml
34071 
34072 
34073 // File: classcasadi_1_1Horzsplit.xml
34074 
34075 
34076 // File: classcasadi_1_1ImplicitFixedStepIntegrator.xml
34077 %feature("docstring")  casadi::ProtoFunction::memory(int ind) const  "
34078 
34079 [INTERNAL]  Memory objects.
34080 
34081 ";
34082 
34083 %feature("docstring")  casadi::FunctionInternal::generate_options(bool
34084 is_temp=false) const  "
34085 
34086 [INTERNAL]  Reconstruct options dict.
34087 
34088 ";
34089 
34090 %feature("docstring")  casadi::FunctionInternal::set_work(void *mem, const
34091 double **&arg, double **&res, casadi_int *&iw, double *&w) const  "
34092 
34093 [INTERNAL]  Set the (persistent) work vectors.
34094 
34095 ";
34096 
34097 %feature("docstring")  casadi::FunctionInternal::disp_more(std::ostream
34098 &stream) const  "
34099 
34100 [INTERNAL]  Print more.
34101 
34102 ";
34103 
34104 %feature("docstring")  casadi::FunctionInternal::call_gen(const MXVector
34105 &arg, MXVector &res, casadi_int npar, bool always_inline, bool never_inline)
34106 const  "
34107 
34108 [INTERNAL]   Call a function, overloaded.
34109 
34110 ";
34111 
34112 %feature("docstring")  casadi::FunctionInternal::call_gen(const std::vector<
34113 MatrixCommon > &arg, std::vector< MatrixCommon > &res, casadi_int npar, bool
34114 always_inline, bool never_inline) const  "
34115 
34116 [INTERNAL]   Call a function, overloaded.
34117 
34118 ";
34119 
34120 %feature("docstring")  casadi::SharedObjectInternal::class_name() const  "
34121 
34122 [INTERNAL]  Readable name of the internal class.
34123 
34124 ";
34125 
34126 %feature("docstring")  casadi::FunctionInternal::nz_out(const std::vector<
34127 DM > &res) const  "
34128 
34129 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
34130 
34131 ";
34132 
34133 %feature("docstring")  casadi::FunctionInternal::nz_out(const std::vector<
34134 double > &res) const  "
34135 
34136 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
34137 
34138 ";
34139 
34140 %feature("docstring")  casadi::FunctionInternal::jacobian_sparsity() const
34141 "
34142 
34143 [INTERNAL]  Get Jacobian sparsity.
34144 
34145 ";
34146 
34147 %feature("docstring")  casadi::FunctionInternal::fwdViaJac(casadi_int nfwd)
34148 const  "
34149 
34150 [INTERNAL]  Calculate derivatives by multiplying the full Jacobian and
34151 multiplying.
34152 
34153 ";
34154 
34155 %feature("docstring")  casadi::ImplicitFixedStepIntegrator::init(const Dict
34156 &opts)  "
34157 
34158 [INTERNAL]  Initialize stage.
34159 
34160 ";
34161 
34162 %feature("docstring")  casadi::FunctionInternal::index_in(const std::string
34163 &name) const  "
34164 
34165 [INTERNAL]  Get input scheme index by name.
34166 
34167 ";
34168 
34169 %feature("docstring")  casadi::ProtoFunction::serialize(SerializingStream
34170 &s) const  "
34171 
34172 [INTERNAL]  Serialize an object.
34173 
34174 ";
34175 
34176 %feature("docstring")
34177 casadi::FunctionInternal::instruction_input(casadi_int k) const  "
34178 
34179 [INTERNAL]  Get the (integer) input arguments of an atomic operation.
34180 
34181 ";
34182 
34183 %feature("docstring")  casadi::FunctionInternal::generate_out(const
34184 std::string &fname, double **res) const  "
34185 
34186 [INTERNAL] ";
34187 
34188 %feature("docstring")
34189 casadi::FunctionInternal::codegen_init_mem(CodeGenerator &g) const  "
34190 
34191 [INTERNAL]  Codegen decref for init_mem.
34192 
34193 ";
34194 
34195 %feature("docstring")  casadi::Integrator::setStopTime(IntegratorMemory
34196 *mem, double tf) const  "
34197 
34198 [INTERNAL]  Set stop time for the integration.
34199 
34200 ";
34201 
34202 %feature("docstring")  casadi::SharedObjectInternal::getCount() const  "
34203 
34204 [INTERNAL]  Get the reference count.
34205 
34206 ";
34207 
34208 %feature("docstring")  casadi::FunctionInternal::has_derivative() const  "
34209 
34210 [INTERNAL]  Can derivatives be calculated in any way?
34211 
34212 ";
34213 
34214 %feature("docstring")  casadi::FunctionInternal::codegen_meta(CodeGenerator
34215 &g) const  "
34216 
34217 [INTERNAL]  Generate meta-information allowing a user to evaluate a
34218 generated function.
34219 
34220 ";
34221 
34222 %feature("docstring")  casadi::FunctionInternal::nz_in(const std::vector< DM
34223 > &arg) const  "
34224 
34225 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
34226 
34227 ";
34228 
34229 %feature("docstring")  casadi::FunctionInternal::nz_in(const std::vector<
34230 double > &arg) const  "
34231 
34232 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
34233 
34234 ";
34235 
34236 %feature("docstring")  casadi::Integrator::has_sprev() const  "
34237 
34238 [INTERNAL]  Is the class able to propagate seeds through the algorithm?
34239 
34240 ";
34241 
34242 %feature("docstring")  casadi::FunctionInternal::sp_weight() const  "
34243 
34244 [INTERNAL]  Weighting factor for chosing forward/reverse mode, sparsity
34245 propagation.
34246 
34247 ";
34248 
34249 %feature("docstring")  casadi::FunctionInternal::replace_fseed(const
34250 std::vector< std::vector< M >> &fseed, casadi_int npar) const  "
34251 
34252 [INTERNAL]  Replace 0-by-0 forward seeds.
34253 
34254 ";
34255 
34256 %feature("docstring")  casadi::FunctionInternal::replace_fseed(const
34257 std::vector< std::vector< M > > &fseed, casadi_int npar) const  "
34258 
34259 [INTERNAL] ";
34260 
34261 %feature("docstring")  casadi::Integrator::getDerivativeOptions(bool fwd)
34262 const  "
34263 
34264 [INTERNAL]  Set solver specific options to generated augmented integrators.
34265 
34266 ";
34267 
34268 %feature("docstring")  casadi::FunctionInternal::has_jacobian() const  "
34269 
34270 [INTERNAL]  Return Jacobian of all input elements with respect to all output
34271 elements.
34272 
34273 ";
34274 
34275 %feature("docstring")  casadi::FunctionInternal::export_code(const
34276 std::string &lang, std::ostream &stream, const Dict &options) const  "
34277 
34278 [INTERNAL]  Export function in a specific language.
34279 
34280 ";
34281 
34282 %feature("docstring")  casadi::FunctionInternal::sx_out(casadi_int ind)
34283 const  "
34284 
34285 [INTERNAL]  Get function input(s) and output(s)
34286 
34287 ";
34288 
34289 %feature("docstring")  casadi::FunctionInternal::sx_out() const  "
34290 
34291 [INTERNAL]  Get function input(s) and output(s)
34292 
34293 ";
34294 
34295 %feature("docstring")  casadi::FunctionInternal::print_option(const
34296 std::string &name, std::ostream &stream) const  "
34297 
34298 [INTERNAL]  Print all information there is to know about a certain option.
34299 
34300 ";
34301 
34302 %feature("docstring")  casadi::FunctionInternal::matching_arg(const
34303 std::vector< M > &arg, casadi_int &npar) const  "
34304 
34305 [INTERNAL]  Check if input arguments that needs to be replaced.
34306 
34307 Raises errors
34308 
34309 Parameters:
34310 -----------
34311 
34312 npar[in]:  normal usage: 1, disallow pararallel calls: -1
34313 
34314 npar:  max number of horizontal repetitions across all arguments (or -1)
34315 
34316 ";
34317 
34318 %feature("docstring")  casadi::OracleFunction::jit_dependencies(const
34319 std::string &fname)  "
34320 
34321 [INTERNAL]  JIT for dependencies.
34322 
34323 ";
34324 
34325 %feature("docstring")  casadi::FixedStepIntegrator::advance(IntegratorMemory
34326 *mem, double t, double *x, double *z, double *q) const  "
34327 
34328 [INTERNAL]  Advance solution in time.
34329 
34330 ";
34331 
34332 %feature("docstring")  casadi::FunctionInternal::eval_mx(const MXVector
34333 &arg, MXVector &res, bool always_inline, bool never_inline) const  "
34334 
34335 [INTERNAL]  Evaluate with symbolic matrices.
34336 
34337 ";
34338 
34339 %feature("docstring")  casadi::FunctionInternal::get_jacobian_sparsity()
34340 const  "
34341 
34342 [INTERNAL]  Get Jacobian sparsity.
34343 
34344 ";
34345 
34346 %feature("docstring")
34347 casadi::FunctionInternal::codegen_decref(CodeGenerator &g) const  "
34348 
34349 [INTERNAL]  Codegen decref for dependencies.
34350 
34351 ";
34352 
34353 %feature("docstring")
34354 casadi::FunctionInternal::jacobian_sparsity_filter(const Sparsity &sp) const
34355 "
34356 
34357 [INTERNAL]  Filter out nonzeros in the full sparsity jacobian according to
34358 is_diff_in/out.
34359 
34360 ";
34361 
34362 %feature("docstring")
34363 casadi::FunctionInternal::codegen_alloc_mem(CodeGenerator &g) const  "
34364 
34365 [INTERNAL]  Codegen decref for alloc_mem.
34366 
34367 ";
34368 
34369 %feature("docstring")  casadi::Integrator::get_sparsity_in(casadi_int i)  "
34370 
34371 [INTERNAL]  Sparsities of function inputs and outputs.
34372 
34373 ";
34374 
34375 %feature("docstring")  casadi::FunctionInternal::convert_arg(const
34376 std::vector< M > &arg) const  "
34377 
34378 [INTERNAL]  Convert from/to input/output lists/map.
34379 
34380 ";
34381 
34382 %feature("docstring")  casadi::FunctionInternal::convert_arg(const std::map<
34383 std::string, M > &arg) const  "
34384 
34385 [INTERNAL]  Convert from/to input/output lists/map.
34386 
34387 ";
34388 
34389 %feature("docstring")  casadi::FunctionInternal::nnz_in() const  "
34390 
34391 [INTERNAL]  Number of input/output nonzeros.
34392 
34393 ";
34394 
34395 %feature("docstring")  casadi::FunctionInternal::nnz_in(casadi_int ind)
34396 const  "
34397 
34398 [INTERNAL]  Number of input/output nonzeros.
34399 
34400 ";
34401 
34402 %feature("docstring")  casadi::FunctionInternal::forward(casadi_int nfwd)
34403 const  "
34404 
34405 [INTERNAL]  Return function that calculates forward derivatives
34406 forward(nfwd) returns a cached instance if available, and calls  Function
34407 get_forward(casadi_int nfwd) if no cached version is available.
34408 
34409 ";
34410 
34411 %feature("docstring")  casadi::ProtoFunction::release(int mem) const  "
34412 
34413 [INTERNAL]  Release a memory object.
34414 
34415 ";
34416 
34417 %feature("docstring")  casadi::OracleFunction::get_stats(void *mem) const  "
34418 
34419 [INTERNAL]  Get all statistics.
34420 
34421 ";
34422 
34423 %feature("docstring")  casadi::FunctionInternal::alloc_iw(size_t sz_iw, bool
34424 persistent=false) "
34425 
34426 [INTERNAL]  Ensure required length of iw field.
34427 
34428 ";
34429 
34430 %feature("docstring")  casadi::FunctionInternal::call(const std::vector< M >
34431 &arg, std::vector< M > &res, bool always_inline, bool never_inline) const  "
34432 
34433 [INTERNAL]   Call a function, templated.
34434 
34435 ";
34436 
34437 %feature("docstring")  casadi::FunctionInternal::index_out(const std::string
34438 &name) const  "
34439 
34440 [INTERNAL]  Get output scheme index by name.
34441 
34442 ";
34443 
34444 %feature("docstring")  casadi::FunctionInternal::print_options(std::ostream
34445 &stream) const  "
34446 
34447 [INTERNAL]  Print list of options.
34448 
34449 ";
34450 
34451 %feature("docstring")  casadi::FunctionInternal::size1_in(casadi_int ind)
34452 const  "
34453 
34454 [INTERNAL]  Input/output dimensions.
34455 
34456 ";
34457 
34458 %feature("docstring")
34459 casadi::FunctionInternal::instruction_constant(casadi_int k) const  "
34460 
34461 [INTERNAL]  Get the floating point output argument of an atomic operation.
34462 
34463 ";
34464 
34465 %feature("docstring")  casadi::FixedStepIntegrator::alloc_mem() const  "
34466 
34467 [INTERNAL]  Create memory block.
34468 
34469 ";
34470 
34471 %feature("docstring")  casadi::FunctionInternal::get_partition(casadi_int
34472 iind, casadi_int oind, Sparsity &D1, Sparsity &D2, bool compact, bool
34473 symmetric, bool allow_forward, bool allow_reverse) const  "
34474 
34475 [INTERNAL]  Get the unidirectional or bidirectional partition.
34476 
34477 ";
34478 
34479 %feature("docstring")  casadi::Integrator::sp_reverse(bvec_t **arg, bvec_t
34480 **res, casadi_int *iw, bvec_t *w, void *mem) const  "
34481 
34482 [INTERNAL]  Propagate sparsity backwards.
34483 
34484 ";
34485 
34486 %feature("docstring")  casadi::FunctionInternal::ad_weight() const  "
34487 
34488 [INTERNAL]  Weighting factor for chosing forward/reverse mode.
34489 
34490 ";
34491 
34492 %feature("docstring")  casadi::FunctionInternal::matching_res(const
34493 std::vector< M > &arg, casadi_int &npar) const  "
34494 
34495 [INTERNAL]  Check if output arguments that needs to be replaced.
34496 
34497 Raises errors
34498 
34499 Parameters:
34500 -----------
34501 
34502 npar[in]:  normal usage: 1, disallow pararallel calls: -1
34503 
34504 npar:  max number of horizontal repetitions across all arguments (or -1)
34505 
34506 ";
34507 
34508 %feature("docstring")  casadi::OracleFunction::set_function(const Function
34509 &fcn, const std::string &fname, bool jit=false) "
34510 
34511 [INTERNAL]  Register the function for evaluation and statistics gathering
34512 
34513 ";
34514 
34515 %feature("docstring")  casadi::OracleFunction::set_function(const Function
34516 &fcn) "
34517 
34518 [INTERNAL]  Register the function for evaluation and statistics gathering
34519 
34520 ";
34521 
34522 %feature("docstring")  casadi::FunctionInternal::codegen_body(CodeGenerator
34523 &g) const  "
34524 
34525 [INTERNAL]  Generate code for the function body.
34526 
34527 ";
34528 
34529 %feature("docstring")  casadi::FunctionInternal::sparsity_in(casadi_int ind)
34530 const  "
34531 
34532 [INTERNAL]  Input/output sparsity.
34533 
34534 ";
34535 
34536 %feature("docstring")  casadi::FunctionInternal::get_free() const  "
34537 
34538 [INTERNAL]  Print free variables.
34539 
34540 ";
34541 
34542 %feature("docstring") casadi::ImplicitFixedStepIntegrator "
34543 
34544 
34545 
34546 >List of available options
34547 
34548 +------------------+-----------------+------------------+------------------+
34549 |        Id        |      Type       |   Description    |     Used in      |
34550 +==================+=================+==================+==================+
34551 | augmented_option | OT_DICT         | Options to be    | casadi::Implicit |
34552 | s                |                 | passed down to   | FixedStepIntegra |
34553 |                  |                 | the augmented    | tor              |
34554 |                  |                 | integrator, if   |                  |
34555 |                  |                 | one is           |                  |
34556 |                  |                 | constructed.     |                  |
34557 +------------------+-----------------+------------------+------------------+
34558 | common_options   | OT_DICT         | Options for      | casadi::OracleFu |
34559 |                  |                 | auto-generated   | nction           |
34560 |                  |                 | functions        |                  |
34561 +------------------+-----------------+------------------+------------------+
34562 | expand           | OT_BOOL         | Replace MX with  | casadi::Implicit |
34563 |                  |                 | SX expressions   | FixedStepIntegra |
34564 |                  |                 | in problem       | tor              |
34565 |                  |                 | formulation      |                  |
34566 |                  |                 | [false]          |                  |
34567 +------------------+-----------------+------------------+------------------+
34568 | grid             | OT_DOUBLEVECTOR | Time grid        | casadi::Implicit |
34569 |                  |                 |                  | FixedStepIntegra |
34570 |                  |                 |                  | tor              |
34571 +------------------+-----------------+------------------+------------------+
34572 | monitor          | OT_STRINGVECTOR | Set of user      | casadi::OracleFu |
34573 |                  |                 | problem          | nction           |
34574 |                  |                 | functions to be  |                  |
34575 |                  |                 | monitored        |                  |
34576 +------------------+-----------------+------------------+------------------+
34577 | number_of_finite | OT_INT          | Number of finite | casadi::Implicit |
34578 | _elements        |                 | elements         | FixedStepIntegra |
34579 |                  |                 |                  | tor              |
34580 +------------------+-----------------+------------------+------------------+
34581 | output_t0        | OT_BOOL         | Output the state | casadi::Implicit |
34582 |                  |                 | at the initial   | FixedStepIntegra |
34583 |                  |                 | time             | tor              |
34584 +------------------+-----------------+------------------+------------------+
34585 | print_stats      | OT_BOOL         | Print out        | casadi::Implicit |
34586 |                  |                 | statistics after | FixedStepIntegra |
34587 |                  |                 | integration      | tor              |
34588 +------------------+-----------------+------------------+------------------+
34589 | rootfinder       | OT_STRING       | An implicit      | casadi::Implicit |
34590 |                  |                 | function solver  | FixedStepIntegra |
34591 |                  |                 |                  | tor              |
34592 +------------------+-----------------+------------------+------------------+
34593 | rootfinder_optio | OT_DICT         | Options to be    | casadi::Implicit |
34594 | ns               |                 | passed to the    | FixedStepIntegra |
34595 |                  |                 | NLP Solver       | tor              |
34596 +------------------+-----------------+------------------+------------------+
34597 | show_eval_warnin | OT_BOOL         | Show warnings    | casadi::OracleFu |
34598 | gs               |                 | generated from   | nction           |
34599 |                  |                 | function         |                  |
34600 |                  |                 | evaluations      |                  |
34601 |                  |                 | [true]           |                  |
34602 +------------------+-----------------+------------------+------------------+
34603 | simplify         | OT_BOOL         | Implement as MX  | casadi::Implicit |
34604 |                  |                 | Function (codege | FixedStepIntegra |
34605 |                  |                 | neratable/serial | tor              |
34606 |                  |                 | izable) default: |                  |
34607 |                  |                 | false            |                  |
34608 +------------------+-----------------+------------------+------------------+
34609 | simplify_options | OT_DICT         | Any options to   | casadi::Implicit |
34610 |                  |                 | pass to          | FixedStepIntegra |
34611 |                  |                 | simplified form  | tor              |
34612 |                  |                 | Function         |                  |
34613 |                  |                 | constructor      |                  |
34614 +------------------+-----------------+------------------+------------------+
34615 | specific_options | OT_DICT         | Options for      | casadi::OracleFu |
34616 |                  |                 | specific auto-   | nction           |
34617 |                  |                 | generated        |                  |
34618 |                  |                 | functions,       |                  |
34619 |                  |                 | overwriting the  |                  |
34620 |                  |                 | defaults from    |                  |
34621 |                  |                 | common_options.  |                  |
34622 |                  |                 | Nested           |                  |
34623 |                  |                 | dictionary.      |                  |
34624 +------------------+-----------------+------------------+------------------+
34625 | t0               | OT_DOUBLE       | Beginning of the | casadi::Implicit |
34626 |                  |                 | time horizon     | FixedStepIntegra |
34627 |                  |                 |                  | tor              |
34628 +------------------+-----------------+------------------+------------------+
34629 | tf               | OT_DOUBLE       | End of the time  | casadi::Implicit |
34630 |                  |                 | horizon          | FixedStepIntegra |
34631 |                  |                 |                  | tor              |
34632 +------------------+-----------------+------------------+------------------+
34633 
34634 Diagrams
34635 --------
34636 
34637 
34638 
34639 C++ includes: integrator_impl.hpp ";
34640 
34641 %feature("docstring")  casadi::FunctionInternal::alloc(const Function &f,
34642 bool persistent=false) "
34643 
34644 [INTERNAL]  Ensure work vectors long enough to evaluate function.
34645 
34646 ";
34647 
34648 %feature("docstring")
34649 casadi::ImplicitFixedStepIntegrator::serialize_body(SerializingStream &s)
34650 const  "
34651 
34652 [INTERNAL]  Serialize an object without type information.
34653 
34654 ";
34655 
34656 %feature("docstring")  casadi::SharedObjectInternal::weak() "
34657 
34658 [INTERNAL]  Get a weak reference to the object.
34659 
34660 ";
34661 
34662 %feature("docstring")  casadi::FunctionInternal::get_reltol() const  "
34663 
34664 [INTERNAL]  Get relative tolerance.
34665 
34666 ";
34667 
34668 %feature("docstring")  casadi::Integrator::q() const  "
34669 
34670 [INTERNAL] ";
34671 
34672 %feature("docstring")  casadi::Integrator::p() const  "
34673 
34674 [INTERNAL] ";
34675 
34676 %feature("docstring")  casadi::FunctionInternal::size2_out(casadi_int ind)
34677 const  "
34678 
34679 [INTERNAL]  Input/output dimensions.
34680 
34681 ";
34682 
34683 %feature("docstring")  casadi::Integrator::algebraic_state_output(const MX
34684 &Z) const  "
34685 
34686 [INTERNAL] ";
34687 
34688 %feature("docstring")  casadi::Integrator::t() const  "
34689 
34690 [INTERNAL] ";
34691 
34692 %feature("docstring")
34693 casadi::ImplicitFixedStepIntegrator::~ImplicitFixedStepIntegrator "
34694 
34695 [INTERNAL]  Destructor.
34696 
34697 ";
34698 
34699 %feature("docstring")  casadi::Integrator::z() const  "
34700 
34701 [INTERNAL] ";
34702 
34703 %feature("docstring")  casadi::Integrator::x() const  "
34704 
34705 [INTERNAL] ";
34706 
34707 %feature("docstring")  casadi::FunctionInternal::disp(std::ostream &stream,
34708 bool more) const  "
34709 
34710 [INTERNAL]  Display object.
34711 
34712 ";
34713 
34714 %feature("docstring")  casadi::FunctionInternal::sz_w() const  "
34715 
34716 [INTERNAL]  Get required length of w field.
34717 
34718 ";
34719 
34720 %feature("docstring")  casadi::FunctionInternal::all_scalar() const  "
34721 
34722 [INTERNAL]  Are all inputs and outputs scalar.
34723 
34724 ";
34725 
34726 %feature("docstring")  casadi::FixedStepIntegrator::create_advanced(const
34727 Dict &opts)  "
34728 
34729 [INTERNAL]  Helper for a more powerful 'integrator' factory
34730 
34731 ";
34732 
34733 %feature("docstring")  casadi::FixedStepIntegrator::reset(IntegratorMemory
34734 *mem, double t, const double *x, const double *z, const double *p) const  "
34735 
34736 [INTERNAL]  Reset the forward problem.
34737 
34738 ";
34739 
34740 %feature("docstring")  casadi::FunctionInternal::eval_sx(const SXElem **arg,
34741 SXElem **res, casadi_int *iw, SXElem *w, void *mem) const  "
34742 
34743 [INTERNAL]  Evaluate with symbolic scalars.
34744 
34745 ";
34746 
34747 %feature("docstring")  casadi::FunctionInternal::alloc_w(size_t sz_w, bool
34748 persistent=false) "
34749 
34750 [INTERNAL]  Ensure required length of w field.
34751 
34752 ";
34753 
34754 %feature("docstring")  casadi::FunctionInternal::slice(const std::string
34755 &name, const std::vector< casadi_int > &order_in, const std::vector<
34756 casadi_int > &order_out, const Dict &opts) const  "
34757 
34758 [INTERNAL]  returns a new function with a selection of inputs/outputs of the
34759 original
34760 
34761 ";
34762 
34763 %feature("docstring")  casadi::FunctionInternal::check_arg(const
34764 std::vector< M > &arg, casadi_int &npar) const  "
34765 
34766 [INTERNAL]  Check if input arguments have correct length and dimensions.
34767 
34768 Raises errors.
34769 
34770 Parameters:
34771 -----------
34772 
34773 npar[in]:  normal usage: 1, disallow pararallel calls: -1
34774 
34775 npar:  max number of horizontal repetitions across all arguments (or -1)
34776 
34777 ";
34778 
34779 %feature("docstring")  casadi::OracleFunction::monitored(const std::string
34780 &name) const  "
34781 
34782 [INTERNAL] ";
34783 
34784 %feature("docstring")  casadi::FunctionInternal::mx_out(casadi_int ind)
34785 const  "
34786 
34787 [INTERNAL]  Get function input(s) and output(s)
34788 
34789 ";
34790 
34791 %feature("docstring")  casadi::FunctionInternal::mx_out() const  "
34792 
34793 [INTERNAL]  Get function input(s) and output(s)
34794 
34795 ";
34796 
34797 %feature("docstring")
34798 casadi::FunctionInternal::instruction_output(casadi_int k) const  "
34799 
34800 [INTERNAL]  Get the (integer) output argument of an atomic operation.
34801 
34802 ";
34803 
34804 %feature("docstring")  casadi::FunctionInternal::instructions_sx() const  "
34805 
34806 [INTERNAL]  get SX expression associated with instructions
34807 
34808 ";
34809 
34810 %feature("docstring")  casadi::FunctionInternal::size2_in(casadi_int ind)
34811 const  "
34812 
34813 [INTERNAL]  Input/output dimensions.
34814 
34815 ";
34816 
34817 %feature("docstring")
34818 casadi::FunctionInternal::getJacSparsityGen(casadi_int iind, casadi_int
34819 oind, bool symmetric, casadi_int gr_i=1, casadi_int gr_o=1) const  "
34820 
34821 [INTERNAL]  Get the sparsity pattern, forward mode.
34822 
34823 ";
34824 
34825 %feature("docstring")  casadi::Integrator::algebraic_state_init(const MX
34826 &x0, const MX &z0) const  "
34827 
34828 [INTERNAL] ";
34829 
34830 %feature("docstring")  casadi::FunctionInternal::sx_in(casadi_int ind) const
34831 "
34832 
34833 [INTERNAL]  Get function input(s) and output(s)
34834 
34835 ";
34836 
34837 %feature("docstring")  casadi::FunctionInternal::sx_in() const  "
34838 
34839 [INTERNAL]  Get function input(s) and output(s)
34840 
34841 ";
34842 
34843 %feature("docstring")  casadi::FunctionInternal::info() const  "
34844 
34845 [INTERNAL]  Obtain information about function
34846 
34847 ";
34848 
34849 %feature("docstring")  casadi::Integrator::sp_jac_dae() "
34850 
34851 [INTERNAL]  Create sparsity pattern of the extended Jacobian (forward
34852 problem)
34853 
34854 ";
34855 
34856 %feature("docstring")  casadi::FunctionInternal::has_jacobian_sparsity()
34857 const  "
34858 
34859 [INTERNAL]  Get Jacobian sparsity.
34860 
34861 ";
34862 
34863 %feature("docstring")  casadi::FunctionInternal::has_free() const  "
34864 
34865 [INTERNAL]  Does the function have free variables.
34866 
34867 ";
34868 
34869 %feature("docstring")  casadi::Integrator::print_stats(IntegratorMemory
34870 *mem) const  "
34871 
34872 [INTERNAL]  Print solver statistics.
34873 
34874 ";
34875 
34876 %feature("docstring")  casadi::OracleFunction::finalize()  "
34877 
34878 [INTERNAL]  Finalize initialization.
34879 
34880 ";
34881 
34882 %feature("docstring")  casadi::FunctionInternal::sz_iw() const  "
34883 
34884 [INTERNAL]  Get required length of iw field.
34885 
34886 ";
34887 
34888 %feature("docstring")  casadi::FunctionInternal::is_diff_in(casadi_int i) "
34889 
34890 [INTERNAL] ";
34891 
34892 %feature("docstring")  casadi::FunctionInternal::generate_lifted(Function
34893 &vdef_fcn, Function &vinit_fcn) const  "
34894 
34895 [INTERNAL]  Extract the functions needed for the Lifted Newton method.
34896 
34897 ";
34898 
34899 %feature("docstring")  casadi::ProtoFunction::checkout() const  "
34900 
34901 [INTERNAL]  Checkout a memory object.
34902 
34903 ";
34904 
34905 %feature("docstring")  casadi::FunctionInternal::sparsity_jac(casadi_int
34906 iind, casadi_int oind, bool compact, bool symmetric) const  "
34907 
34908 [INTERNAL]  Get, if necessary generate, the sparsity of a Jacobian block.
34909 
34910 ";
34911 
34912 %feature("docstring")  casadi::OracleFunction::expand() "
34913 
34914 [INTERNAL] ";
34915 
34916 %feature("docstring")  casadi::FixedStepIntegrator::free_mem(void *mem)
34917 const  "
34918 
34919 [INTERNAL]  Free memory block.
34920 
34921 ";
34922 
34923 %feature("docstring")  casadi::FunctionInternal::eval_gen(const double
34924 **arg, double **res, casadi_int *iw, double *w, void *mem) const  "
34925 
34926 [INTERNAL]  Evaluate numerically.
34927 
34928 ";
34929 
34930 %feature("docstring")  casadi::FunctionInternal::eval_gen(const SXElem
34931 **arg, SXElem **res, casadi_int *iw, SXElem *w, void *mem) const  "
34932 
34933 [INTERNAL]  Evaluate a function, overloaded.
34934 
34935 ";
34936 
34937 %feature("docstring")  casadi::FunctionInternal::eval_gen(const bvec_t
34938 **arg, bvec_t **res, casadi_int *iw, bvec_t *w, void *mem) const  "
34939 
34940 [INTERNAL]  Evaluate a function, overloaded.
34941 
34942 ";
34943 
34944 %feature("docstring")  casadi::ImplicitFixedStepIntegrator::getExplicitB()
34945 const  "
34946 
34947 [INTERNAL]  Get explicit dynamics (backward problem)
34948 
34949 ";
34950 
34951 %feature("docstring")  casadi::FunctionInternal::dm_in(casadi_int ind) const
34952 "
34953 
34954 [INTERNAL]  Get function input(s) and output(s)
34955 
34956 ";
34957 
34958 %feature("docstring")  casadi::FunctionInternal::dm_in() const  "
34959 
34960 [INTERNAL]  Get function input(s) and output(s)
34961 
34962 ";
34963 
34964 %feature("docstring")  casadi::Integrator::get_sparsity_out(casadi_int i)  "
34965 
34966 [INTERNAL]  Sparsities of function inputs and outputs.
34967 
34968 ";
34969 
34970 %feature("docstring")
34971 casadi::FunctionInternal::codegen_sparsities(CodeGenerator &g) const  "
34972 
34973 [INTERNAL]  Codegen sparsities.
34974 
34975 ";
34976 
34977 %feature("docstring")  casadi::ProtoFunction::print(const char *fmt,...)
34978 const  "
34979 
34980 [INTERNAL]  C-style formatted printing during evaluation.
34981 
34982 ";
34983 
34984 %feature("docstring")  casadi::Integrator::has_forward(casadi_int nfwd)
34985 const  "
34986 
34987 [INTERNAL]  Generate a function that calculates nfwd forward derivatives.
34988 
34989 ";
34990 
34991 %feature("docstring")  casadi::FunctionInternal::n_nodes() const  "
34992 
34993 [INTERNAL]  Number of nodes in the algorithm.
34994 
34995 ";
34996 
34997 %feature("docstring")  casadi::FunctionInternal::has_codegen() const  "
34998 
34999 [INTERNAL]  Is codegen supported?
35000 
35001 ";
35002 
35003 %feature("docstring")  casadi::FunctionInternal::instruction_MX(casadi_int
35004 k) const  "
35005 
35006 [INTERNAL]  get MX expression associated with instruction
35007 
35008 ";
35009 
35010 %feature("docstring")  casadi::FunctionInternal::wrap() const  "
35011 
35012 [INTERNAL]  Wrap in an Function instance consisting of only one MX call.
35013 
35014 ";
35015 
35016 %feature("docstring")
35017 casadi::FunctionInternal::print_dimensions(std::ostream &stream) const  "
35018 
35019 [INTERNAL]  Print dimensions of inputs and outputs.
35020 
35021 ";
35022 
35023 %feature("docstring")  casadi::ImplicitFixedStepIntegrator::get_options()
35024 const  "
35025 
35026 [INTERNAL]  Options.
35027 
35028 ";
35029 
35030 %feature("docstring")  casadi::FunctionInternal::fwd_seed(casadi_int nfwd)
35031 const  "
35032 
35033 [INTERNAL]  Symbolic expressions for the forward seeds.
35034 
35035 ";
35036 
35037 %feature("docstring")  casadi::FunctionInternal::getJacSparsity(casadi_int
35038 iind, casadi_int oind, bool symmetric) const  "
35039 
35040 [INTERNAL]  Generate the sparsity of a Jacobian block.
35041 
35042 ";
35043 
35044 %feature("docstring")  casadi::FunctionInternal::get_jac(const std::string
35045 &name, const std::vector< std::string > &inames, const std::vector<
35046 std::string > &onames, const Dict &opts) const  "
35047 
35048 [INTERNAL]  Return Jacobian of all input elements with respect to all output
35049 elements.
35050 
35051 ";
35052 
35053 %feature("docstring")  casadi::FunctionInternal::check_mat(const Sparsity
35054 &arg, const Sparsity &inp, casadi_int &npar) "
35055 
35056 [INTERNAL]  Helper function
35057 
35058 Parameters:
35059 -----------
35060 
35061 npar[in]:  normal usage: 1, disallow pararallel calls: -1
35062 
35063 npar[out]:  required number of parallel calls (or -1)
35064 
35065 ";
35066 
35067 %feature("docstring")  casadi::FunctionInternal::codegen(CodeGenerator &g,
35068 const std::string &fname) const  "
35069 
35070 [INTERNAL]  Generate code the function.
35071 
35072 ";
35073 
35074 %feature("docstring")  casadi::FunctionInternal::free_sx() const  "
35075 
35076 [INTERNAL]  Get free variables (SX)
35077 
35078 ";
35079 
35080 %feature("docstring")  casadi::FunctionInternal::size1_out(casadi_int ind)
35081 const  "
35082 
35083 [INTERNAL]  Input/output dimensions.
35084 
35085 ";
35086 
35087 %feature("docstring")  casadi::FixedStepIntegrator::setupFG() "
35088 
35089 [INTERNAL]  Setup F and G.
35090 
35091 ";
35092 
35093 %feature("docstring")  casadi::Integrator::aug_adj(casadi_int nadj) const  "
35094 
35095 [INTERNAL]  Generate a augmented DAE system with nadj adjoint sensitivities.
35096 
35097 ";
35098 
35099 %feature("docstring")  casadi::FunctionInternal::has_jac() const  "
35100 
35101 [INTERNAL]  Return Jacobian of all input elements with respect to all output
35102 elements.
35103 
35104 ";
35105 
35106 %feature("docstring")  casadi::FunctionInternal::codegen_mem_type() const  "
35107 
35108 [INTERNAL]  Thread-local memory object type.
35109 
35110 ";
35111 
35112 %feature("docstring")  casadi::FunctionInternal::sz_arg() const  "
35113 
35114 [INTERNAL]  Get required length of arg field.
35115 
35116 ";
35117 
35118 %feature("docstring")  casadi::ImplicitFixedStepIntegrator::getExplicit()
35119 const  "
35120 
35121 [INTERNAL]  Get explicit dynamics.
35122 
35123 ";
35124 
35125 %feature("docstring")  casadi::FunctionInternal::dm_out(casadi_int ind)
35126 const  "
35127 
35128 [INTERNAL]  Get function input(s) and output(s)
35129 
35130 ";
35131 
35132 %feature("docstring")  casadi::FunctionInternal::dm_out() const  "
35133 
35134 [INTERNAL]  Get function input(s) and output(s)
35135 
35136 ";
35137 
35138 %feature("docstring")  casadi::Integrator::get_name_out(casadi_int i)  "
35139 
35140 [INTERNAL]  Names of function input and outputs.
35141 
35142 ";
35143 
35144 %feature("docstring")
35145 casadi::FunctionInternal::getJacSparsityHierarchicalSymm(casadi_int iind,
35146 casadi_int oind) const  "
35147 
35148 [INTERNAL]  A flavor of getJacSparsity that does hierarchical block
35149 structure recognition for symmetric Jacobians
35150 
35151 ";
35152 
35153 %feature("docstring")
35154 casadi::FunctionInternal::codegen_incref(CodeGenerator &g) const  "
35155 
35156 [INTERNAL]  Codegen incref for dependencies.
35157 
35158 ";
35159 
35160 %feature("docstring")
35161 casadi::FunctionInternal::getJacSparsityHierarchical(casadi_int iind,
35162 casadi_int oind) const  "
35163 
35164 [INTERNAL]  A flavor of getJacSparsity that does hierarchical block
35165 structure recognition.
35166 
35167 ";
35168 
35169 %feature("docstring")  casadi::Integrator::aug_fwd(casadi_int nfwd) const  "
35170 
35171 [INTERNAL]  Generate a augmented DAE system with nfwd forward sensitivities.
35172 
35173 ";
35174 
35175 %feature("docstring")
35176 casadi::FunctionInternal::codegen_declarations(CodeGenerator &g) const  "
35177 
35178 [INTERNAL]  Generate code for the declarations of the C function.
35179 
35180 ";
35181 
35182 %feature("docstring")  casadi::FunctionInternal::codegen_mem(CodeGenerator
35183 &g, const std::string &index="mem") const  "
35184 
35185 [INTERNAL]  Get thread-local memory object.
35186 
35187 ";
35188 
35189 %feature("docstring")  casadi::FunctionInternal::which_depends(const
35190 std::string &s_in, const std::vector< std::string > &s_out, casadi_int
35191 order, bool tr=false) const  "
35192 
35193 [INTERNAL]  Which variables enter with some order.
35194 
35195 Parameters:
35196 -----------
35197 
35198 s_in:   Input name
35199 
35200 s_out:   Output name(s)
35201 
35202 order:  Only 1 (linear) and 2 (nonlinear) allowed
35203 
35204 tr:  Flip the relationship. Return which expressions contain the variables
35205 
35206 ";
35207 
35208 %feature("docstring")  casadi::ProtoFunction::print_time(const std::map<
35209 std::string, FStats > &fstats) const  "
35210 
35211 [INTERNAL]  Print timing statistics.
35212 
35213 ";
35214 
35215 %feature("docstring")  casadi::OracleFunction::oracle() const  "
35216 
35217 [INTERNAL]  Get oracle.
35218 
35219 ";
35220 
35221 %feature("docstring")  casadi::OracleFunction::get_function() const  "
35222 
35223 [INTERNAL]  Get list of dependency functions -1 Indicates irregularity.
35224 
35225 ";
35226 
35227 %feature("docstring")  casadi::OracleFunction::get_function(const
35228 std::string &name) const  "
35229 
35230 [INTERNAL] ";
35231 
35232 %feature("docstring")  casadi::FunctionInternal::adjViaJac(casadi_int nadj)
35233 const  "
35234 
35235 [INTERNAL]  Calculate derivatives by multiplying the full Jacobian and
35236 multiplying.
35237 
35238 ";
35239 
35240 %feature("docstring")  casadi::OracleFunction::generate_dependencies(const
35241 std::string &fname, const Dict &opts) const  "
35242 
35243 [INTERNAL]  Export / Generate C code for the generated functions.
35244 
35245 ";
35246 
35247 %feature("docstring")  casadi::FunctionInternal::size_in(casadi_int ind)
35248 const  "
35249 
35250 [INTERNAL]  Input/output dimensions.
35251 
35252 ";
35253 
35254 %feature("docstring")  casadi::FunctionInternal::definition() const  "
35255 
35256 [INTERNAL]  Get function signature: name:(inputs)->(outputs)
35257 
35258 ";
35259 
35260 %feature("docstring")  casadi::FunctionInternal::factory(const std::string
35261 &name, const std::vector< std::string > &s_in, const std::vector<
35262 std::string > &s_out, const Function::AuxOut &aux, const Dict &opts) const
35263 "
35264 
35265 [INTERNAL] ";
35266 
35267 %feature("docstring")  casadi::FunctionInternal::replace_aseed(const
35268 std::vector< std::vector< M >> &aseed, casadi_int npar) const  "
35269 
35270 [INTERNAL]  Replace 0-by-0 reverse seeds.
35271 
35272 ";
35273 
35274 %feature("docstring")  casadi::FunctionInternal::replace_aseed(const
35275 std::vector< std::vector< M > > &aseed, casadi_int npar) const  "
35276 
35277 [INTERNAL] ";
35278 
35279 %feature("docstring")  casadi::FunctionInternal::sz_res() const  "
35280 
35281 [INTERNAL]  Get required length of res field.
35282 
35283 ";
35284 
35285 %feature("docstring")  casadi::FunctionInternal::self() const  "
35286 
35287 [INTERNAL]  Get a public class instance.
35288 
35289 ";
35290 
35291 %feature("docstring")  casadi::FunctionInternal::check_res(const
35292 std::vector< M > &res, casadi_int &npar) const  "
35293 
35294 [INTERNAL]  Check if output arguments have correct length and dimensions.
35295 
35296 Raises errors.
35297 
35298 Parameters:
35299 -----------
35300 
35301 npar[in]:  normal usage: 1, disallow pararallel calls: -1
35302 
35303 npar:  max number of horizontal repetitions across all arguments (or -1)
35304 
35305 ";
35306 
35307 %feature("docstring")  casadi::FunctionInternal::nnz_out() const  "
35308 
35309 [INTERNAL]  Number of input/output nonzeros.
35310 
35311 ";
35312 
35313 %feature("docstring")  casadi::FunctionInternal::nnz_out(casadi_int ind)
35314 const  "
35315 
35316 [INTERNAL]  Number of input/output nonzeros.
35317 
35318 ";
35319 
35320 %feature("docstring")
35321 casadi::FunctionInternal::codegen_free_mem(CodeGenerator &g) const  "
35322 
35323 [INTERNAL]  Codegen for free_mem.
35324 
35325 ";
35326 
35327 %feature("docstring")  casadi::FunctionInternal::signature(const std::string
35328 &fname) const  "
35329 
35330 [INTERNAL]  Code generate the function.
35331 
35332 ";
35333 
35334 %feature("docstring")  casadi::FunctionInternal::n_instructions() const  "
35335 
35336 [INTERNAL]  Get the number of atomic operations.
35337 
35338 ";
35339 
35340 %feature("docstring")  casadi::PluginInterface< Integrator  >::plugin_name()
35341 const  "
35342 
35343 [INTERNAL] ";
35344 
35345 %feature("docstring")  casadi::FunctionInternal::get_min_in(casadi_int ind)
35346 const  "
35347 
35348 [INTERNAL]  Get smallest input value.
35349 
35350 ";
35351 
35352 %feature("docstring")  casadi::Integrator::eval(const double **arg, double
35353 **res, casadi_int *iw, double *w, void *mem) const  "
35354 
35355 [INTERNAL]  evaluate
35356 
35357 ";
35358 
35359 %feature("docstring")  casadi::FunctionInternal::symbolic_output(const
35360 std::vector< MX > &arg) const  "
35361 
35362 [INTERNAL]  Get a vector of symbolic variables corresponding to the outputs.
35363 
35364 ";
35365 
35366 %feature("docstring")  casadi::FunctionInternal::mapsum_mx(const
35367 std::vector< MX > &arg, const std::string &parallelization) "
35368 
35369 [INTERNAL]  Parallel evaluation.
35370 
35371 ";
35372 
35373 %feature("docstring")  casadi::FunctionInternal::project_arg(const
35374 std::vector< M > &arg, casadi_int npar) const  "
35375 
35376 [INTERNAL]   Project sparsities.
35377 
35378 ";
35379 
35380 %feature("docstring")  casadi::FunctionInternal::getAdaptorSolverName()
35381 const  "
35382 
35383 [INTERNAL]  Obtain solver name from Adaptor.
35384 
35385 ";
35386 
35387 %feature("docstring")  casadi::OracleFunction::has_function(const
35388 std::string &fname) const  "
35389 
35390 [INTERNAL] ";
35391 
35392 %feature("docstring")  casadi::FunctionInternal::get_abstol() const  "
35393 
35394 [INTERNAL]  Get absolute tolerance.
35395 
35396 ";
35397 
35398 %feature("docstring")  casadi::FunctionInternal::call_reverse(const
35399 std::vector< MX > &arg, const std::vector< MX > &res, const std::vector<
35400 std::vector< MX > > &aseed, std::vector< std::vector< MX > > &asens, bool
35401 always_inline, bool never_inline) const  "
35402 
35403 [INTERNAL]  Reverse mode, virtual functions overloaded in derived classes.
35404 
35405 ";
35406 
35407 %feature("docstring")  casadi::FunctionInternal::call_reverse(const
35408 std::vector< SX > &arg, const std::vector< SX > &res, const std::vector<
35409 std::vector< SX > > &aseed, std::vector< std::vector< SX > > &asens, bool
35410 always_inline, bool never_inline) const  "
35411 
35412 [INTERNAL]  Reverse mode, virtual functions overloaded in derived classes.
35413 
35414 ";
35415 
35416 %feature("docstring")  casadi::FunctionInternal::tocache(const Function &f,
35417 const std::string &suffix="") const  "
35418 
35419 [INTERNAL]  Save function to cache.
35420 
35421 ";
35422 
35423 %feature("docstring")  casadi::FunctionInternal::free_mx() const  "
35424 
35425 [INTERNAL]  Get free variables ( MX)
35426 
35427 ";
35428 
35429 %feature("docstring")  casadi::FunctionInternal::get_default_in(casadi_int
35430 ind) const  "
35431 
35432 [INTERNAL]  Get default input value.
35433 
35434 ";
35435 
35436 %feature("docstring")  casadi::FunctionInternal::alloc_res(size_t sz_res,
35437 bool persistent=false) "
35438 
35439 [INTERNAL]  Ensure required length of res field.
35440 
35441 ";
35442 
35443 %feature("docstring")  casadi::FunctionInternal::sz_work(size_t &sz_arg,
35444 size_t &sz_res, size_t &sz_iw, size_t &sz_w) const  "
35445 
35446 [INTERNAL]  Get number of temporary variables needed.
35447 
35448 ";
35449 
35450 %feature("docstring")  casadi::FunctionInternal::project_res(const
35451 std::vector< M > &arg, casadi_int npar) const  "
35452 
35453 [INTERNAL]   Project sparsities.
35454 
35455 ";
35456 
35457 %feature("docstring")  casadi::FixedStepIntegrator::init_mem(void *mem)
35458 const  "
35459 
35460 [INTERNAL]  Initalize memory block.
35461 
35462 ";
35463 
35464 %feature("docstring")  casadi::FunctionInternal::get_jacobian(const
35465 std::string &name, const std::vector< std::string > &inames, const
35466 std::vector< std::string > &onames, const Dict &opts) const  "
35467 
35468 [INTERNAL]  Return Jacobian of all input elements with respect to all output
35469 elements.
35470 
35471 ";
35472 
35473 %feature("docstring")  casadi::FunctionInternal::setup(void *mem, const
35474 double **arg, double **res, casadi_int *iw, double *w) const  "
35475 
35476 [INTERNAL]  Set the (persistent and temporary) work vectors.
35477 
35478 ";
35479 
35480 %feature("docstring")  casadi::ProtoFunction::construct(const Dict &opts) "
35481 
35482 [INTERNAL]  Construct Prepares the function for evaluation.
35483 
35484 ";
35485 
35486 %feature("docstring")  casadi::FunctionInternal::reverse(casadi_int nadj)
35487 const  "
35488 
35489 [INTERNAL]  Return function that calculates adjoint derivatives
35490 reverse(nadj) returns a cached instance if available, and calls  Function
35491 get_reverse(casadi_int nadj) if no cached version is available.
35492 
35493 ";
35494 
35495 %feature("docstring")  casadi::FixedStepIntegrator::retreat(IntegratorMemory
35496 *mem, double t, double *rx, double *rz, double *rq) const  "
35497 
35498 [INTERNAL]  Retreat solution in time.
35499 
35500 ";
35501 
35502 %feature("docstring")  casadi::FunctionInternal::replace_arg(const
35503 std::vector< M > &arg, casadi_int npar) const  "
35504 
35505 [INTERNAL]  Replace 0-by-0 inputs.
35506 
35507 ";
35508 
35509 %feature("docstring")  casadi::FunctionInternal::numel_in() const  "
35510 
35511 [INTERNAL]  Number of input/output elements.
35512 
35513 ";
35514 
35515 %feature("docstring")  casadi::FunctionInternal::numel_in(casadi_int ind)
35516 const  "
35517 
35518 [INTERNAL]  Number of input/output elements.
35519 
35520 ";
35521 
35522 %feature("docstring")  casadi::ProtoFunction::format_time(char *buffer,
35523 double time) const  "
35524 
35525 [INTERNAL]  Format time in a fixed width 8 format.
35526 
35527 ";
35528 
35529 %feature("docstring")  casadi::OracleFunction::set_temp(void *mem, const
35530 double **arg, double **res, casadi_int *iw, double *w) const  "
35531 
35532 [INTERNAL]  Set the work vectors.
35533 
35534 ";
35535 
35536 %feature("docstring")  casadi::FunctionInternal::is_a(const std::string
35537 &type, bool recursive) const  "
35538 
35539 [INTERNAL]  Check if the function is of a particular type.
35540 
35541 ";
35542 
35543 %feature("docstring")  casadi::ProtoFunction::sprint(char *buf, size_t
35544 buf_sz, const char *fmt,...) const  "
35545 
35546 [INTERNAL]  C-style formatted printing to string.
35547 
35548 ";
35549 
35550 %feature("docstring")  casadi::Integrator::get_reverse(casadi_int nadj,
35551 const std::string &name, const std::vector< std::string > &inames, const
35552 std::vector< std::string > &onames, const Dict &opts) const  "
35553 
35554 [INTERNAL]  Generate a function that calculates nadj adjoint derivatives.
35555 
35556 ";
35557 
35558 %feature("docstring")  casadi::FunctionInternal::get_max_in(casadi_int ind)
35559 const  "
35560 
35561 [INTERNAL]  Get largest input value.
35562 
35563 ";
35564 
35565 %feature("docstring")  casadi::Integrator::rp() const  "
35566 
35567 [INTERNAL] ";
35568 
35569 %feature("docstring")  casadi::Integrator::rq() const  "
35570 
35571 [INTERNAL] ";
35572 
35573 %feature("docstring")  casadi::Integrator::has_reverse(casadi_int nadj)
35574 const  "
35575 
35576 [INTERNAL]  Generate a function that calculates nadj adjoint derivatives.
35577 
35578 ";
35579 
35580 %feature("docstring")  casadi::Integrator::get_forward(casadi_int nfwd,
35581 const std::string &name, const std::vector< std::string > &inames, const
35582 std::vector< std::string > &onames, const Dict &opts) const  "
35583 
35584 [INTERNAL]  Generate a function that calculates nfwd forward derivatives.
35585 
35586 ";
35587 
35588 %feature("docstring")  casadi::Integrator::rz() const  "
35589 
35590 [INTERNAL] ";
35591 
35592 %feature("docstring")  casadi::Integrator::get_n_in()  "
35593 
35594 [INTERNAL]  Number of function inputs and outputs.
35595 
35596 ";
35597 
35598 %feature("docstring")  casadi::Integrator::rx() const  "
35599 
35600 [INTERNAL] ";
35601 
35602 %feature("docstring")  casadi::FunctionInternal::instruction_id(casadi_int
35603 k) const  "
35604 
35605 [INTERNAL]  Get an atomic operation operator index.
35606 
35607 ";
35608 
35609 %feature("docstring")  casadi::FunctionInternal::is_diff_out(casadi_int i) "
35610 
35611 [INTERNAL] ";
35612 
35613 %feature("docstring")  casadi::FunctionInternal::convert_res(const
35614 std::vector< M > &res) const  "
35615 
35616 [INTERNAL]  Convert from/to input/output lists/map.
35617 
35618 ";
35619 
35620 %feature("docstring")  casadi::FunctionInternal::convert_res(const std::map<
35621 std::string, M > &res) const  "
35622 
35623 [INTERNAL]  Convert from/to input/output lists/map.
35624 
35625 ";
35626 
35627 %feature("docstring")  casadi::FunctionInternal::call_forward(const
35628 std::vector< MX > &arg, const std::vector< MX > &res, const std::vector<
35629 std::vector< MX > > &fseed, std::vector< std::vector< MX > > &fsens, bool
35630 always_inline, bool never_inline) const  "
35631 
35632 [INTERNAL]  Forward mode AD, virtual functions overloaded in derived
35633 classes.
35634 
35635 ";
35636 
35637 %feature("docstring")  casadi::FunctionInternal::call_forward(const
35638 std::vector< SX > &arg, const std::vector< SX > &res, const std::vector<
35639 std::vector< SX > > &fseed, std::vector< std::vector< SX > > &fsens, bool
35640 always_inline, bool never_inline) const  "
35641 
35642 [INTERNAL]  Forward mode AD, virtual functions overloaded in derived
35643 classes.
35644 
35645 ";
35646 
35647 %feature("docstring")  casadi::FunctionInternal::wrap_as_needed(const Dict
35648 &opts) const  "
35649 
35650 [INTERNAL]  Wrap in an Function instance consisting of only one MX call.
35651 
35652 ";
35653 
35654 %feature("docstring")  casadi::FunctionInternal::incache(const std::string
35655 &fname, Function &f, const std::string &suffix="") const  "
35656 
35657 [INTERNAL]  Get function in cache.
35658 
35659 ";
35660 
35661 %feature("docstring")  casadi::FunctionInternal::size_out(casadi_int ind)
35662 const  "
35663 
35664 [INTERNAL]  Input/output dimensions.
35665 
35666 ";
35667 
35668 %feature("docstring")  casadi::Integrator::get_n_out()  "
35669 
35670 [INTERNAL]  Number of function inputs and outputs.
35671 
35672 ";
35673 
35674 %feature("docstring")  casadi::FunctionInternal::uses_output() const  "
35675 
35676 [INTERNAL]  Do the derivative functions need nondifferentiated outputs?
35677 
35678 ";
35679 
35680 %feature("docstring")  casadi::Integrator::sp_jac_rdae() "
35681 
35682 [INTERNAL]  Create sparsity pattern of the extended Jacobian (backward
35683 problem)
35684 
35685 ";
35686 
35687 %feature("docstring")  casadi::Integrator::get_name_in(casadi_int i)  "
35688 
35689 [INTERNAL]  Names of function input and outputs.
35690 
35691 ";
35692 
35693 %feature("docstring")  casadi::FunctionInternal::has_eval_dm() const  "
35694 
35695 [INTERNAL]  Evaluate with DM matrices.
35696 
35697 ";
35698 
35699 %feature("docstring")  casadi::OracleFunction::calc_function(OracleMemory
35700 *m, const std::string &fcn, const double *const *arg=nullptr) const  "
35701 
35702 [INTERNAL] ";
35703 
35704 %feature("docstring")  casadi::FunctionInternal::mx_in(casadi_int ind) const
35705 "
35706 
35707 [INTERNAL]  Get function input(s) and output(s)
35708 
35709 ";
35710 
35711 %feature("docstring")  casadi::FunctionInternal::mx_in() const  "
35712 
35713 [INTERNAL]  Get function input(s) and output(s)
35714 
35715 ";
35716 
35717 %feature("docstring")  casadi::FunctionInternal::codegen_name(const
35718 CodeGenerator &g, bool ns=true) const  "
35719 
35720 [INTERNAL]  Get name in codegen.
35721 
35722 ";
35723 
35724 %feature("docstring")  casadi::Integrator::sp_forward(const bvec_t **arg,
35725 bvec_t **res, casadi_int *iw, bvec_t *w, void *mem) const  "
35726 
35727 [INTERNAL]  Propagate sparsity forward.
35728 
35729 ";
35730 
35731 %feature("docstring")  casadi::FunctionInternal::jac() const  "
35732 
35733 [INTERNAL]  Return Jacobian of all input elements with respect to all output
35734 elements.
35735 
35736 ";
35737 
35738 %feature("docstring")  casadi::Integrator::serialize_type(SerializingStream
35739 &s) const  "
35740 
35741 [INTERNAL]  Serialize type information.
35742 
35743 ";
35744 
35745 %feature("docstring")  casadi::FunctionInternal::sparsity_out(casadi_int
35746 ind) const  "
35747 
35748 [INTERNAL]  Input/output sparsity.
35749 
35750 ";
35751 
35752 %feature("docstring")  casadi::FunctionInternal::symbolicAdjSeed(casadi_int
35753 nadj, const std::vector< MatType > &v) const  "
35754 
35755 [INTERNAL]  Symbolic expressions for the adjoint seeds.
35756 
35757 ";
35758 
35759 %feature("docstring")  casadi::FixedStepIntegrator::resetB(IntegratorMemory
35760 *mem, double t, const double *rx, const double *rz, const double *rp) const
35761 "
35762 
35763 [INTERNAL]  Reset the backward problem and take time to tf.
35764 
35765 ";
35766 
35767 %feature("docstring")  casadi::ProtoFunction::clear_mem() "
35768 
35769 [INTERNAL]  Clear all memory (called from destructor)
35770 
35771 ";
35772 
35773 %feature("docstring")  casadi::Integrator::has_spfwd() const  "
35774 
35775 [INTERNAL]  Is the class able to propagate seeds through the algorithm?
35776 
35777 ";
35778 
35779 %feature("docstring")  casadi::FunctionInternal::eval_dm(const std::vector<
35780 DM > &arg) const  "
35781 
35782 [INTERNAL]  Evaluate with DM matrices.
35783 
35784 ";
35785 
35786 %feature("docstring")  casadi::FunctionInternal::jacobian() const  "
35787 
35788 [INTERNAL]  Return Jacobian of all input elements with respect to all output
35789 elements.
35790 
35791 ";
35792 
35793 %feature("docstring")  casadi::FunctionInternal::map(casadi_int n, const
35794 std::string &parallelization) const  "
35795 
35796 [INTERNAL]  Generate/retrieve cached serial map.
35797 
35798 ";
35799 
35800 %feature("docstring")  casadi::FunctionInternal::numel_out(casadi_int ind)
35801 const  "
35802 
35803 [INTERNAL]  Number of input/output elements.
35804 
35805 ";
35806 
35807 %feature("docstring")  casadi::FunctionInternal::numel_out() const  "
35808 
35809 [INTERNAL]  Number of input/output elements.
35810 
35811 ";
35812 
35813 %feature("docstring")  casadi::FunctionInternal::replace_res(const
35814 std::vector< M > &res, casadi_int npar) const  "
35815 
35816 [INTERNAL]  Replace 0-by-0 outputs.
35817 
35818 ";
35819 
35820 %feature("docstring")  casadi::FunctionInternal::generate_in(const
35821 std::string &fname, const double **arg) const  "
35822 
35823 [INTERNAL]  Export an input file that can be passed to generate C code with
35824 a main.
35825 
35826 ";
35827 
35828 %feature("docstring")  casadi::OracleFunction::create_function(const
35829 std::string &fname, const std::vector< std::string > &s_in, const
35830 std::vector< std::string > &s_out, const Function::AuxOut
35831 &aux=Function::AuxOut()) "
35832 
35833 [INTERNAL]  Create an oracle function
35834 
35835 ";
35836 
35837 %feature("docstring")  casadi::Integrator::serialize_base_function() const
35838 "
35839 
35840 [INTERNAL]  String used to identify the immediate FunctionInternal subclass.
35841 
35842 ";
35843 
35844 %feature("docstring")
35845 casadi::ImplicitFixedStepIntegrator::ImplicitFixedStepIntegrator(const
35846 std::string &name, const Function &dae) "
35847 
35848 [INTERNAL]  Constructor.
35849 
35850 ";
35851 
35852 %feature("docstring")  casadi::FunctionInternal::alloc_arg(size_t sz_arg,
35853 bool persistent=false) "
35854 
35855 [INTERNAL]  Ensure required length of arg field.
35856 
35857 ";
35858 
35859 
35860 // File: classcasadi_1_1ImplicitToNlp.xml
35861 %feature("docstring")  casadi::OracleFunction::create_function(const
35862 std::string &fname, const std::vector< std::string > &s_in, const
35863 std::vector< std::string > &s_out, const Function::AuxOut
35864 &aux=Function::AuxOut()) "
35865 
35866 [INTERNAL]  Create an oracle function
35867 
35868 ";
35869 
35870 %feature("docstring") casadi::ImplicitToNlp::ImplicitToNlp(const std::string
35871 &name, const Function &f) "
35872 
35873 [INTERNAL]  Constructor.
35874 
35875 ";
35876 
35877 %feature("docstring")  casadi::FunctionInternal::mx_out(casadi_int ind)
35878 const  "
35879 
35880 [INTERNAL]  Get function input(s) and output(s)
35881 
35882 ";
35883 
35884 %feature("docstring")  casadi::FunctionInternal::mx_out() const  "
35885 
35886 [INTERNAL]  Get function input(s) and output(s)
35887 
35888 ";
35889 
35890 %feature("docstring")  casadi::FunctionInternal::sz_iw() const  "
35891 
35892 [INTERNAL]  Get required length of iw field.
35893 
35894 ";
35895 
35896 %feature("docstring")  casadi::FunctionInternal::signature(const std::string
35897 &fname) const  "
35898 
35899 [INTERNAL]  Code generate the function.
35900 
35901 ";
35902 
35903 %feature("docstring")  casadi::FunctionInternal::mapsum_mx(const
35904 std::vector< MX > &arg, const std::string &parallelization) "
35905 
35906 [INTERNAL]  Parallel evaluation.
35907 
35908 ";
35909 
35910 %feature("docstring")  casadi::FunctionInternal::matching_res(const
35911 std::vector< M > &arg, casadi_int &npar) const  "
35912 
35913 [INTERNAL]  Check if output arguments that needs to be replaced.
35914 
35915 Raises errors
35916 
35917 Parameters:
35918 -----------
35919 
35920 npar[in]:  normal usage: 1, disallow pararallel calls: -1
35921 
35922 npar:  max number of horizontal repetitions across all arguments (or -1)
35923 
35924 ";
35925 
35926 %feature("docstring")  casadi::FunctionInternal::check_arg(const
35927 std::vector< M > &arg, casadi_int &npar) const  "
35928 
35929 [INTERNAL]  Check if input arguments have correct length and dimensions.
35930 
35931 Raises errors.
35932 
35933 Parameters:
35934 -----------
35935 
35936 npar[in]:  normal usage: 1, disallow pararallel calls: -1
35937 
35938 npar:  max number of horizontal repetitions across all arguments (or -1)
35939 
35940 ";
35941 
35942 %feature("docstring")  casadi::FunctionInternal::which_depends(const
35943 std::string &s_in, const std::vector< std::string > &s_out, casadi_int
35944 order, bool tr=false) const  "
35945 
35946 [INTERNAL]  Which variables enter with some order.
35947 
35948 Parameters:
35949 -----------
35950 
35951 s_in:   Input name
35952 
35953 s_out:   Output name(s)
35954 
35955 order:  Only 1 (linear) and 2 (nonlinear) allowed
35956 
35957 tr:  Flip the relationship. Return which expressions contain the variables
35958 
35959 ";
35960 
35961 %feature("docstring")  casadi::FunctionInternal::free_mx() const  "
35962 
35963 [INTERNAL]  Get free variables ( MX)
35964 
35965 ";
35966 
35967 %feature("docstring")  casadi::FunctionInternal::sparsity_in(casadi_int ind)
35968 const  "
35969 
35970 [INTERNAL]  Input/output sparsity.
35971 
35972 ";
35973 
35974 %feature("docstring")  casadi::ProtoFunction::memory(int ind) const  "
35975 
35976 [INTERNAL]  Memory objects.
35977 
35978 ";
35979 
35980 %feature("docstring")  casadi::FunctionInternal::get_default_in(casadi_int
35981 ind) const  "
35982 
35983 [INTERNAL]  Get default input value.
35984 
35985 ";
35986 
35987 %feature("docstring")  casadi::Rootfinder::has_spfwd() const  "
35988 
35989 [INTERNAL]  Is the class able to propagate seeds through the algorithm?
35990 
35991 ";
35992 
35993 %feature("docstring")  casadi::FunctionInternal::replace_fseed(const
35994 std::vector< std::vector< M >> &fseed, casadi_int npar) const  "
35995 
35996 [INTERNAL]  Replace 0-by-0 forward seeds.
35997 
35998 ";
35999 
36000 %feature("docstring")  casadi::FunctionInternal::replace_fseed(const
36001 std::vector< std::vector< M > > &fseed, casadi_int npar) const  "
36002 
36003 [INTERNAL] ";
36004 
36005 %feature("docstring")
36006 casadi::FunctionInternal::codegen_incref(CodeGenerator &g) const  "
36007 
36008 [INTERNAL]  Codegen incref for dependencies.
36009 
36010 ";
36011 
36012 %feature("docstring")  casadi::FunctionInternal::generate_options(bool
36013 is_temp=false) const  "
36014 
36015 [INTERNAL]  Reconstruct options dict.
36016 
36017 ";
36018 
36019 %feature("docstring")  casadi::FunctionInternal::dm_in(casadi_int ind) const
36020 "
36021 
36022 [INTERNAL]  Get function input(s) and output(s)
36023 
36024 ";
36025 
36026 %feature("docstring")  casadi::FunctionInternal::dm_in() const  "
36027 
36028 [INTERNAL]  Get function input(s) and output(s)
36029 
36030 ";
36031 
36032 %feature("docstring")  casadi::ProtoFunction::print_time(const std::map<
36033 std::string, FStats > &fstats) const  "
36034 
36035 [INTERNAL]  Print timing statistics.
36036 
36037 ";
36038 
36039 %feature("docstring")  casadi::FunctionInternal::sz_work(size_t &sz_arg,
36040 size_t &sz_res, size_t &sz_iw, size_t &sz_w) const  "
36041 
36042 [INTERNAL]  Get number of temporary variables needed.
36043 
36044 ";
36045 
36046 %feature("docstring")  casadi::FunctionInternal::size1_out(casadi_int ind)
36047 const  "
36048 
36049 [INTERNAL]  Input/output dimensions.
36050 
36051 ";
36052 
36053 %feature("docstring")  casadi::SharedObjectInternal::getCount() const  "
36054 
36055 [INTERNAL]  Get the reference count.
36056 
36057 ";
36058 
36059 %feature("docstring")  casadi::FunctionInternal::sparsity_out(casadi_int
36060 ind) const  "
36061 
36062 [INTERNAL]  Input/output sparsity.
36063 
36064 ";
36065 
36066 %feature("docstring")  casadi::FunctionInternal::free_sx() const  "
36067 
36068 [INTERNAL]  Get free variables (SX)
36069 
36070 ";
36071 
36072 %feature("docstring")  casadi::FunctionInternal::check_mat(const Sparsity
36073 &arg, const Sparsity &inp, casadi_int &npar) "
36074 
36075 [INTERNAL]  Helper function
36076 
36077 Parameters:
36078 -----------
36079 
36080 npar[in]:  normal usage: 1, disallow pararallel calls: -1
36081 
36082 npar[out]:  required number of parallel calls (or -1)
36083 
36084 ";
36085 
36086 %feature("docstring")  casadi::FunctionInternal::call_gen(const MXVector
36087 &arg, MXVector &res, casadi_int npar, bool always_inline, bool never_inline)
36088 const  "
36089 
36090 [INTERNAL]   Call a function, overloaded.
36091 
36092 ";
36093 
36094 %feature("docstring")  casadi::FunctionInternal::call_gen(const std::vector<
36095 MatrixCommon > &arg, std::vector< MatrixCommon > &res, casadi_int npar, bool
36096 always_inline, bool never_inline) const  "
36097 
36098 [INTERNAL]   Call a function, overloaded.
36099 
36100 ";
36101 
36102 %feature("docstring")  casadi::FunctionInternal::replace_res(const
36103 std::vector< M > &res, casadi_int npar) const  "
36104 
36105 [INTERNAL]  Replace 0-by-0 outputs.
36106 
36107 ";
36108 
36109 %feature("docstring")  casadi::FunctionInternal::has_derivative() const  "
36110 
36111 [INTERNAL]  Can derivatives be calculated in any way?
36112 
36113 ";
36114 
36115 %feature("docstring")  casadi::FunctionInternal::call_forward(const
36116 std::vector< MX > &arg, const std::vector< MX > &res, const std::vector<
36117 std::vector< MX > > &fseed, std::vector< std::vector< MX > > &fsens, bool
36118 always_inline, bool never_inline) const  "
36119 
36120 [INTERNAL]  Forward mode AD, virtual functions overloaded in derived
36121 classes.
36122 
36123 ";
36124 
36125 %feature("docstring")  casadi::FunctionInternal::call_forward(const
36126 std::vector< SX > &arg, const std::vector< SX > &res, const std::vector<
36127 std::vector< SX > > &fseed, std::vector< std::vector< SX > > &fsens, bool
36128 always_inline, bool never_inline) const  "
36129 
36130 [INTERNAL]  Forward mode AD, virtual functions overloaded in derived
36131 classes.
36132 
36133 ";
36134 
36135 %feature("docstring")  casadi::FunctionInternal::nz_out(const std::vector<
36136 DM > &res) const  "
36137 
36138 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
36139 
36140 ";
36141 
36142 %feature("docstring")  casadi::FunctionInternal::nz_out(const std::vector<
36143 double > &res) const  "
36144 
36145 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
36146 
36147 ";
36148 
36149 %feature("docstring")  casadi::FunctionInternal::nnz_out() const  "
36150 
36151 [INTERNAL]  Number of input/output nonzeros.
36152 
36153 ";
36154 
36155 %feature("docstring")  casadi::FunctionInternal::nnz_out(casadi_int ind)
36156 const  "
36157 
36158 [INTERNAL]  Number of input/output nonzeros.
36159 
36160 ";
36161 
36162 %feature("docstring")  casadi::FunctionInternal::index_in(const std::string
36163 &name) const  "
36164 
36165 [INTERNAL]  Get input scheme index by name.
36166 
36167 ";
36168 
36169 %feature("docstring")  casadi::FunctionInternal::generate_lifted(Function
36170 &vdef_fcn, Function &vinit_fcn) const  "
36171 
36172 [INTERNAL]  Extract the functions needed for the Lifted Newton method.
36173 
36174 ";
36175 
36176 %feature("docstring")  casadi::Rootfinder::sp_forward(const bvec_t **arg,
36177 bvec_t **res, casadi_int *iw, bvec_t *w, void *mem) const  "
36178 
36179 [INTERNAL]  Propagate sparsity forward.
36180 
36181 ";
36182 
36183 %feature("docstring")
36184 casadi::FunctionInternal::codegen_alloc_mem(CodeGenerator &g) const  "
36185 
36186 [INTERNAL]  Codegen decref for alloc_mem.
36187 
36188 ";
36189 
36190 %feature("docstring")  casadi::ProtoFunction::construct(const Dict &opts) "
36191 
36192 [INTERNAL]  Construct Prepares the function for evaluation.
36193 
36194 ";
36195 
36196 %feature("docstring")  casadi::FunctionInternal::alloc_res(size_t sz_res,
36197 bool persistent=false) "
36198 
36199 [INTERNAL]  Ensure required length of res field.
36200 
36201 ";
36202 
36203 %feature("docstring")  casadi::FunctionInternal::sx_out(casadi_int ind)
36204 const  "
36205 
36206 [INTERNAL]  Get function input(s) and output(s)
36207 
36208 ";
36209 
36210 %feature("docstring")  casadi::FunctionInternal::sx_out() const  "
36211 
36212 [INTERNAL]  Get function input(s) and output(s)
36213 
36214 ";
36215 
36216 %feature("docstring")  casadi::FunctionInternal::disp(std::ostream &stream,
36217 bool more) const  "
36218 
36219 [INTERNAL]  Display object.
36220 
36221 ";
36222 
36223 %feature("docstring")  casadi::Rootfinder::ad_forward(const std::vector< MX
36224 > &arg, const std::vector< MX > &res, const std::vector< std::vector< MX > >
36225 &fseed, std::vector< std::vector< MX > > &fsens, bool always_inline, bool
36226 never_inline) const  "
36227 
36228 [INTERNAL]  Create call to (cached) derivative function, forward mode.
36229 
36230 ";
36231 
36232 %feature("docstring") casadi::ImplicitToNlp "
36233 
36234 'nlp' plugin for Rootfinder
36235 
36236 Use an Nlpsol as Rootfinder solver
36237 
36238 >List of available options
36239 
36240 +----------------+-----------+---------------------------------+
36241 |       Id       |   Type    |           Description           |
36242 +================+===========+=================================+
36243 | nlpsol         | OT_STRING | Name of solver.                 |
36244 +----------------+-----------+---------------------------------+
36245 | nlpsol_options | OT_DICT   | Options to be passed to solver. |
36246 +----------------+-----------+---------------------------------+
36247 
36248 Joris Gillis
36249 
36250 >List of available options
36251 
36252 +-------------------+--------------+-------------------+-------------------+
36253 |        Id         |     Type     |    Description    |      Used in      |
36254 +===================+==============+===================+===================+
36255 | constraints       | OT_INTVECTOR | Constrain the     | casadi::Rootfinde |
36256 |                   |              | unknowns. 0       | r                 |
36257 |                   |              | (default): no     |                   |
36258 |                   |              | constraint on ui, |                   |
36259 |                   |              | 1: ui >= 0.0, -1: |                   |
36260 |                   |              | ui <= 0.0, 2: ui  |                   |
36261 |                   |              | > 0.0, -2: ui <   |                   |
36262 |                   |              | 0.0.              |                   |
36263 +-------------------+--------------+-------------------+-------------------+
36264 | error_on_fail     | OT_BOOL      | When the          | casadi::Rootfinde |
36265 |                   |              | numerical process | r                 |
36266 |                   |              | returns           |                   |
36267 |                   |              | unsuccessfully,   |                   |
36268 |                   |              | raise an error    |                   |
36269 |                   |              | (default false).  |                   |
36270 +-------------------+--------------+-------------------+-------------------+
36271 | implicit_input    | OT_INT       | Index of the      | casadi::Rootfinde |
36272 |                   |              | input that        | r                 |
36273 |                   |              | corresponds to    |                   |
36274 |                   |              | the actual root-  |                   |
36275 |                   |              | finding           |                   |
36276 +-------------------+--------------+-------------------+-------------------+
36277 | implicit_output   | OT_INT       | Index of the      | casadi::Rootfinde |
36278 |                   |              | output that       | r                 |
36279 |                   |              | corresponds to    |                   |
36280 |                   |              | the actual root-  |                   |
36281 |                   |              | finding           |                   |
36282 +-------------------+--------------+-------------------+-------------------+
36283 | jacobian_function | OT_FUNCTION  | Function object   | casadi::Rootfinde |
36284 |                   |              | for calculating   | r                 |
36285 |                   |              | the Jacobian      |                   |
36286 |                   |              | (autogenerated by |                   |
36287 |                   |              | default)          |                   |
36288 +-------------------+--------------+-------------------+-------------------+
36289 | linear_solver     | OT_STRING    | User-defined      | casadi::Rootfinde |
36290 |                   |              | linear solver     | r                 |
36291 |                   |              | class. Needed for |                   |
36292 |                   |              | sensitivities.    |                   |
36293 +-------------------+--------------+-------------------+-------------------+
36294 | linear_solver_opt | OT_DICT      | Options to be     | casadi::Rootfinde |
36295 | ions              |              | passed to the     | r                 |
36296 |                   |              | linear solver.    |                   |
36297 +-------------------+--------------+-------------------+-------------------+
36298 | nlpsol            | OT_STRING    | Name of solver.   | casadi::ImplicitT |
36299 |                   |              |                   | oNlp              |
36300 +-------------------+--------------+-------------------+-------------------+
36301 | nlpsol_options    | OT_DICT      | Options to be     | casadi::ImplicitT |
36302 |                   |              | passed to solver. | oNlp              |
36303 +-------------------+--------------+-------------------+-------------------+
36304 
36305 Diagrams
36306 --------
36307 
36308 
36309 
36310 C++ includes: implicit_to_nlp.hpp ";
36311 
36312 %feature("docstring")  casadi::Rootfinder::has_reverse(casadi_int nadj)
36313 const  "
36314 
36315 [INTERNAL]  Generate a function that calculates nadj adjoint derivatives.
36316 
36317 ";
36318 
36319 %feature("docstring")  casadi::FunctionInternal::codegen_body(CodeGenerator
36320 &g) const  "
36321 
36322 [INTERNAL]  Generate code for the function body.
36323 
36324 ";
36325 
36326 %feature("docstring")  casadi::FunctionInternal::get_reltol() const  "
36327 
36328 [INTERNAL]  Get relative tolerance.
36329 
36330 ";
36331 
36332 %feature("docstring")  casadi::ImplicitToNlp::solve(void *mem) const  "
36333 
36334 [INTERNAL]   Solve the system of equations and calculate derivatives.
36335 
36336 ";
36337 
36338 %feature("docstring") casadi::casadi_solve "
36339 
36340 Solve the system of equations and calculate derivatives.
36341 
36342 ";
36343 
36344 %feature("docstring")  casadi::ImplicitToNlp::casadi_solve "
36345 
36346 Solve the system of equations and calculate derivatives.
36347 
36348 ";
36349 
36350 %feature("docstring")  casadi::ImplicitToNlp::get_options() const  "
36351 
36352 [INTERNAL]  Options.
36353 
36354 ";
36355 
36356 %feature("docstring")  casadi::OracleFunction::jit_dependencies(const
36357 std::string &fname)  "
36358 
36359 [INTERNAL]  JIT for dependencies.
36360 
36361 ";
36362 
36363 %feature("docstring")  casadi::FunctionInternal::print_option(const
36364 std::string &name, std::ostream &stream) const  "
36365 
36366 [INTERNAL]  Print all information there is to know about a certain option.
36367 
36368 ";
36369 
36370 %feature("docstring")  casadi::FunctionInternal::get_free() const  "
36371 
36372 [INTERNAL]  Print free variables.
36373 
36374 ";
36375 
36376 %feature("docstring")  casadi::FunctionInternal::sparsity_jac(casadi_int
36377 iind, casadi_int oind, bool compact, bool symmetric) const  "
36378 
36379 [INTERNAL]  Get, if necessary generate, the sparsity of a Jacobian block.
36380 
36381 ";
36382 
36383 %feature("docstring")  casadi::Rootfinder::get_name_in(casadi_int i)  "
36384 
36385 [INTERNAL]  Names of function input and outputs.
36386 
36387 ";
36388 
36389 %feature("docstring")  casadi::Rootfinder::init_mem(void *mem) const  "
36390 
36391 [INTERNAL]  Initalize memory block.
36392 
36393 ";
36394 
36395 %feature("docstring")  casadi::FunctionInternal::has_codegen() const  "
36396 
36397 [INTERNAL]  Is codegen supported?
36398 
36399 ";
36400 
36401 %feature("docstring")  casadi::FunctionInternal::info() const  "
36402 
36403 [INTERNAL]  Obtain information about function
36404 
36405 ";
36406 
36407 %feature("docstring")  casadi::FunctionInternal::sz_res() const  "
36408 
36409 [INTERNAL]  Get required length of res field.
36410 
36411 ";
36412 
36413 %feature("docstring")  casadi::OracleFunction::set_function(const Function
36414 &fcn, const std::string &fname, bool jit=false) "
36415 
36416 [INTERNAL]  Register the function for evaluation and statistics gathering
36417 
36418 ";
36419 
36420 %feature("docstring")  casadi::OracleFunction::set_function(const Function
36421 &fcn) "
36422 
36423 [INTERNAL]  Register the function for evaluation and statistics gathering
36424 
36425 ";
36426 
36427 %feature("docstring")  casadi::FunctionInternal::has_eval_dm() const  "
36428 
36429 [INTERNAL]  Evaluate with DM matrices.
36430 
36431 ";
36432 
36433 %feature("docstring")  casadi::ImplicitToNlp::init(const Dict &opts)  "
36434 
36435 [INTERNAL]  Initialize.
36436 
36437 ";
36438 
36439 %feature("docstring")  casadi::ProtoFunction::serialize(SerializingStream
36440 &s) const  "
36441 
36442 [INTERNAL]  Serialize an object.
36443 
36444 ";
36445 
36446 %feature("docstring")  casadi::FunctionInternal::is_diff_out(casadi_int i) "
36447 
36448 [INTERNAL] ";
36449 
36450 %feature("docstring")  casadi::FunctionInternal::setup(void *mem, const
36451 double **arg, double **res, casadi_int *iw, double *w) const  "
36452 
36453 [INTERNAL]  Set the (persistent and temporary) work vectors.
36454 
36455 ";
36456 
36457 %feature("docstring")  casadi::FunctionInternal::eval_gen(const double
36458 **arg, double **res, casadi_int *iw, double *w, void *mem) const  "
36459 
36460 [INTERNAL]  Evaluate numerically.
36461 
36462 ";
36463 
36464 %feature("docstring")  casadi::FunctionInternal::eval_gen(const SXElem
36465 **arg, SXElem **res, casadi_int *iw, SXElem *w, void *mem) const  "
36466 
36467 [INTERNAL]  Evaluate a function, overloaded.
36468 
36469 ";
36470 
36471 %feature("docstring")  casadi::FunctionInternal::eval_gen(const bvec_t
36472 **arg, bvec_t **res, casadi_int *iw, bvec_t *w, void *mem) const  "
36473 
36474 [INTERNAL]  Evaluate a function, overloaded.
36475 
36476 ";
36477 
36478 %feature("docstring")
36479 casadi::FunctionInternal::getJacSparsityHierarchical(casadi_int iind,
36480 casadi_int oind) const  "
36481 
36482 [INTERNAL]  A flavor of getJacSparsity that does hierarchical block
36483 structure recognition.
36484 
36485 ";
36486 
36487 %feature("docstring")  casadi::FunctionInternal::print_options(std::ostream
36488 &stream) const  "
36489 
36490 [INTERNAL]  Print list of options.
36491 
36492 ";
36493 
36494 %feature("docstring")  casadi::FunctionInternal::call(const std::vector< M >
36495 &arg, std::vector< M > &res, bool always_inline, bool never_inline) const  "
36496 
36497 [INTERNAL]   Call a function, templated.
36498 
36499 ";
36500 
36501 %feature("docstring")  casadi::FunctionInternal::sz_w() const  "
36502 
36503 [INTERNAL]  Get required length of w field.
36504 
36505 ";
36506 
36507 %feature("docstring")  casadi::ImplicitToNlp::class_name() const  "
36508 
36509 [INTERNAL]  Readable name of the internal class.
36510 
36511 ";
36512 
36513 %feature("docstring")  casadi::FunctionInternal::symbolicAdjSeed(casadi_int
36514 nadj, const std::vector< MatType > &v) const  "
36515 
36516 [INTERNAL]  Symbolic expressions for the adjoint seeds.
36517 
36518 ";
36519 
36520 %feature("docstring") casadi::ImplicitToNlp::~ImplicitToNlp "
36521 
36522 [INTERNAL]  Destructor.
36523 
36524 ";
36525 
36526 %feature("docstring")  casadi::Rootfinder::get_name_out(casadi_int i)  "
36527 
36528 [INTERNAL]  Names of function input and outputs.
36529 
36530 ";
36531 
36532 %feature("docstring")  casadi::FunctionInternal::size_out(casadi_int ind)
36533 const  "
36534 
36535 [INTERNAL]  Input/output dimensions.
36536 
36537 ";
36538 
36539 %feature("docstring")  casadi::FunctionInternal::get_max_in(casadi_int ind)
36540 const  "
36541 
36542 [INTERNAL]  Get largest input value.
36543 
36544 ";
36545 
36546 %feature("docstring")  casadi::FunctionInternal::codegen_mem(CodeGenerator
36547 &g, const std::string &index="mem") const  "
36548 
36549 [INTERNAL]  Get thread-local memory object.
36550 
36551 ";
36552 
36553 %feature("docstring")  casadi::Rootfinder::get_n_out()  "
36554 
36555 [INTERNAL]  Number of function inputs and outputs.
36556 
36557 ";
36558 
36559 %feature("docstring")  casadi::Rootfinder::get_forward(casadi_int nfwd,
36560 const std::string &name, const std::vector< std::string > &inames, const
36561 std::vector< std::string > &onames, const Dict &opts) const  "
36562 
36563 [INTERNAL]  Generate a function that calculates nfwd forward derivatives.
36564 
36565 ";
36566 
36567 %feature("docstring")  casadi::ProtoFunction::sprint(char *buf, size_t
36568 buf_sz, const char *fmt,...) const  "
36569 
36570 [INTERNAL]  C-style formatted printing to string.
36571 
36572 ";
36573 
36574 %feature("docstring")  casadi::FunctionInternal::numel_out(casadi_int ind)
36575 const  "
36576 
36577 [INTERNAL]  Number of input/output elements.
36578 
36579 ";
36580 
36581 %feature("docstring")  casadi::FunctionInternal::numel_out() const  "
36582 
36583 [INTERNAL]  Number of input/output elements.
36584 
36585 ";
36586 
36587 %feature("docstring")  casadi::FunctionInternal::generate_in(const
36588 std::string &fname, const double **arg) const  "
36589 
36590 [INTERNAL]  Export an input file that can be passed to generate C code with
36591 a main.
36592 
36593 ";
36594 
36595 %feature("docstring")  casadi::FunctionInternal::size_in(casadi_int ind)
36596 const  "
36597 
36598 [INTERNAL]  Input/output dimensions.
36599 
36600 ";
36601 
36602 %feature("docstring")  casadi::Rootfinder::has_forward(casadi_int nfwd)
36603 const  "
36604 
36605 [INTERNAL]  Generate a function that calculates nfwd forward derivatives.
36606 
36607 ";
36608 
36609 %feature("docstring")  casadi::FunctionInternal::alloc_w(size_t sz_w, bool
36610 persistent=false) "
36611 
36612 [INTERNAL]  Ensure required length of w field.
36613 
36614 ";
36615 
36616 %feature("docstring")  casadi::ProtoFunction::format_time(char *buffer,
36617 double time) const  "
36618 
36619 [INTERNAL]  Format time in a fixed width 8 format.
36620 
36621 ";
36622 
36623 %feature("docstring")  casadi::Rootfinder::serialize_type(SerializingStream
36624 &s) const  "
36625 
36626 [INTERNAL]  Serialize type information.
36627 
36628 ";
36629 
36630 %feature("docstring")  casadi::FunctionInternal::instructions_sx() const  "
36631 
36632 [INTERNAL]  get SX expression associated with instructions
36633 
36634 ";
36635 
36636 %feature("docstring")  casadi::ProtoFunction::checkout() const  "
36637 
36638 [INTERNAL]  Checkout a memory object.
36639 
36640 ";
36641 
36642 %feature("docstring")  casadi::FunctionInternal::alloc_arg(size_t sz_arg,
36643 bool persistent=false) "
36644 
36645 [INTERNAL]  Ensure required length of arg field.
36646 
36647 ";
36648 
36649 %feature("docstring")  casadi::FunctionInternal::getAdaptorSolverName()
36650 const  "
36651 
36652 [INTERNAL]  Obtain solver name from Adaptor.
36653 
36654 ";
36655 
36656 %feature("docstring")
36657 casadi::FunctionInternal::getJacSparsityHierarchicalSymm(casadi_int iind,
36658 casadi_int oind) const  "
36659 
36660 [INTERNAL]  A flavor of getJacSparsity that does hierarchical block
36661 structure recognition for symmetric Jacobians
36662 
36663 ";
36664 
36665 %feature("docstring")  casadi::FunctionInternal::map(casadi_int n, const
36666 std::string &parallelization) const  "
36667 
36668 [INTERNAL]  Generate/retrieve cached serial map.
36669 
36670 ";
36671 
36672 %feature("docstring")  casadi::FunctionInternal::check_res(const
36673 std::vector< M > &res, casadi_int &npar) const  "
36674 
36675 [INTERNAL]  Check if output arguments have correct length and dimensions.
36676 
36677 Raises errors.
36678 
36679 Parameters:
36680 -----------
36681 
36682 npar[in]:  normal usage: 1, disallow pararallel calls: -1
36683 
36684 npar:  max number of horizontal repetitions across all arguments (or -1)
36685 
36686 ";
36687 
36688 %feature("docstring")  casadi::FunctionInternal::size2_in(casadi_int ind)
36689 const  "
36690 
36691 [INTERNAL]  Input/output dimensions.
36692 
36693 ";
36694 
36695 %feature("docstring")  casadi::ImplicitToNlp::set_work(void *mem, const
36696 double **&arg, double **&res, casadi_int *&iw, double *&w) const  "
36697 
36698 [INTERNAL]  Set the (persistent) work vectors.
36699 
36700 ";
36701 
36702 %feature("docstring")  casadi::SharedObjectInternal::weak() "
36703 
36704 [INTERNAL]  Get a weak reference to the object.
36705 
36706 ";
36707 
36708 %feature("docstring")  casadi::FunctionInternal::index_out(const std::string
36709 &name) const  "
36710 
36711 [INTERNAL]  Get output scheme index by name.
36712 
36713 ";
36714 
36715 %feature("docstring")  casadi::FunctionInternal::get_abstol() const  "
36716 
36717 [INTERNAL]  Get absolute tolerance.
36718 
36719 ";
36720 
36721 %feature("docstring")  casadi::FunctionInternal::definition() const  "
36722 
36723 [INTERNAL]  Get function signature: name:(inputs)->(outputs)
36724 
36725 ";
36726 
36727 %feature("docstring")  casadi::ImplicitToNlp::plugin_name() const  "
36728 
36729 [INTERNAL] ";
36730 
36731 %feature("docstring")
36732 casadi::FunctionInternal::codegen_declarations(CodeGenerator &g) const  "
36733 
36734 [INTERNAL]  Generate code for the declarations of the C function.
36735 
36736 ";
36737 
36738 %feature("docstring")  casadi::Rootfinder::serialize_body(SerializingStream
36739 &s) const  "
36740 
36741 [INTERNAL]  Serialize an object without type information.
36742 
36743 ";
36744 
36745 %feature("docstring")  casadi::Rootfinder::has_sprev() const  "
36746 
36747 [INTERNAL]  Is the class able to propagate seeds through the algorithm?
36748 
36749 ";
36750 
36751 %feature("docstring")  casadi::FunctionInternal::factory(const std::string
36752 &name, const std::vector< std::string > &s_in, const std::vector<
36753 std::string > &s_out, const Function::AuxOut &aux, const Dict &opts) const
36754 "
36755 
36756 [INTERNAL] ";
36757 
36758 %feature("docstring")  casadi::FunctionInternal::size1_in(casadi_int ind)
36759 const  "
36760 
36761 [INTERNAL]  Input/output dimensions.
36762 
36763 ";
36764 
36765 %feature("docstring")  casadi::Rootfinder::sp_reverse(bvec_t **arg, bvec_t
36766 **res, casadi_int *iw, bvec_t *w, void *mem) const  "
36767 
36768 [INTERNAL]  Propagate sparsity backwards.
36769 
36770 ";
36771 
36772 %feature("docstring")  casadi::FunctionInternal::disp_more(std::ostream
36773 &stream) const  "
36774 
36775 [INTERNAL]  Print more.
36776 
36777 ";
36778 
36779 %feature("docstring")  casadi::Rootfinder::get_reverse(casadi_int nadj,
36780 const std::string &name, const std::vector< std::string > &inames, const
36781 std::vector< std::string > &onames, const Dict &opts) const  "
36782 
36783 [INTERNAL]  Generate a function that calculates nadj adjoint derivatives.
36784 
36785 ";
36786 
36787 %feature("docstring")  casadi::OracleFunction::set_temp(void *mem, const
36788 double **arg, double **res, casadi_int *iw, double *w) const  "
36789 
36790 [INTERNAL]  Set the work vectors.
36791 
36792 ";
36793 
36794 %feature("docstring")  casadi::FunctionInternal::instruction_id(casadi_int
36795 k) const  "
36796 
36797 [INTERNAL]  Get an atomic operation operator index.
36798 
36799 ";
36800 
36801 %feature("docstring")  casadi::FunctionInternal::codegen_name(const
36802 CodeGenerator &g, bool ns=true) const  "
36803 
36804 [INTERNAL]  Get name in codegen.
36805 
36806 ";
36807 
36808 %feature("docstring")  casadi::FunctionInternal::has_jac() const  "
36809 
36810 [INTERNAL]  Return Jacobian of all input elements with respect to all output
36811 elements.
36812 
36813 ";
36814 
36815 %feature("docstring")  casadi::Rootfinder::eval(const double **arg, double
36816 **res, casadi_int *iw, double *w, void *mem) const  "
36817 
36818 [INTERNAL]  Evaluate numerically.
36819 
36820 ";
36821 
36822 %feature("docstring")  casadi::FunctionInternal::eval_dm(const std::vector<
36823 DM > &arg) const  "
36824 
36825 [INTERNAL]  Evaluate with DM matrices.
36826 
36827 ";
36828 
36829 %feature("docstring")  casadi::FunctionInternal::slice(const std::string
36830 &name, const std::vector< casadi_int > &order_in, const std::vector<
36831 casadi_int > &order_out, const Dict &opts) const  "
36832 
36833 [INTERNAL]  returns a new function with a selection of inputs/outputs of the
36834 original
36835 
36836 ";
36837 
36838 %feature("docstring")  casadi::FunctionInternal::project_arg(const
36839 std::vector< M > &arg, casadi_int npar) const  "
36840 
36841 [INTERNAL]   Project sparsities.
36842 
36843 ";
36844 
36845 %feature("docstring")  casadi::FunctionInternal::all_scalar() const  "
36846 
36847 [INTERNAL]  Are all inputs and outputs scalar.
36848 
36849 ";
36850 
36851 %feature("docstring")  casadi::Rootfinder::serialize_base_function() const
36852 "
36853 
36854 [INTERNAL]  String used to identify the immediate FunctionInternal subclass.
36855 
36856 ";
36857 
36858 %feature("docstring")  casadi::FunctionInternal::fwd_seed(casadi_int nfwd)
36859 const  "
36860 
36861 [INTERNAL]  Symbolic expressions for the forward seeds.
36862 
36863 ";
36864 
36865 %feature("docstring")  casadi::FunctionInternal::sz_arg() const  "
36866 
36867 [INTERNAL]  Get required length of arg field.
36868 
36869 ";
36870 
36871 %feature("docstring")  casadi::FunctionInternal::replace_aseed(const
36872 std::vector< std::vector< M >> &aseed, casadi_int npar) const  "
36873 
36874 [INTERNAL]  Replace 0-by-0 reverse seeds.
36875 
36876 ";
36877 
36878 %feature("docstring")  casadi::FunctionInternal::replace_aseed(const
36879 std::vector< std::vector< M > > &aseed, casadi_int npar) const  "
36880 
36881 [INTERNAL] ";
36882 
36883 %feature("docstring")
36884 casadi::FunctionInternal::print_dimensions(std::ostream &stream) const  "
36885 
36886 [INTERNAL]  Print dimensions of inputs and outputs.
36887 
36888 ";
36889 
36890 %feature("docstring")  casadi::FunctionInternal::matching_arg(const
36891 std::vector< M > &arg, casadi_int &npar) const  "
36892 
36893 [INTERNAL]  Check if input arguments that needs to be replaced.
36894 
36895 Raises errors
36896 
36897 Parameters:
36898 -----------
36899 
36900 npar[in]:  normal usage: 1, disallow pararallel calls: -1
36901 
36902 npar:  max number of horizontal repetitions across all arguments (or -1)
36903 
36904 ";
36905 
36906 %feature("docstring")  casadi::FunctionInternal::sp_weight() const  "
36907 
36908 [INTERNAL]  Weighting factor for chosing forward/reverse mode, sparsity
36909 propagation.
36910 
36911 ";
36912 
36913 %feature("docstring")  casadi::FunctionInternal::convert_arg(const
36914 std::vector< M > &arg) const  "
36915 
36916 [INTERNAL]  Convert from/to input/output lists/map.
36917 
36918 ";
36919 
36920 %feature("docstring")  casadi::FunctionInternal::convert_arg(const std::map<
36921 std::string, M > &arg) const  "
36922 
36923 [INTERNAL]  Convert from/to input/output lists/map.
36924 
36925 ";
36926 
36927 %feature("docstring")  casadi::FunctionInternal::ad_weight() const  "
36928 
36929 [INTERNAL]  Weighting factor for chosing forward/reverse mode.
36930 
36931 ";
36932 
36933 %feature("docstring")
36934 casadi::FunctionInternal::instruction_input(casadi_int k) const  "
36935 
36936 [INTERNAL]  Get the (integer) input arguments of an atomic operation.
36937 
36938 ";
36939 
36940 %feature("docstring")  casadi::OracleFunction::has_function(const
36941 std::string &fname) const  "
36942 
36943 [INTERNAL] ";
36944 
36945 %feature("docstring")  casadi::FunctionInternal::eval_sx(const SXElem **arg,
36946 SXElem **res, casadi_int *iw, SXElem *w, void *mem) const  "
36947 
36948 [INTERNAL]  Evaluate with symbolic scalars.
36949 
36950 ";
36951 
36952 %feature("docstring")  casadi::ProtoFunction::clear_mem() "
36953 
36954 [INTERNAL]  Clear all memory (called from destructor)
36955 
36956 ";
36957 
36958 %feature("docstring")  casadi::FunctionInternal::jac() const  "
36959 
36960 [INTERNAL]  Return Jacobian of all input elements with respect to all output
36961 elements.
36962 
36963 ";
36964 
36965 %feature("docstring")  casadi::FunctionInternal::alloc(const Function &f,
36966 bool persistent=false) "
36967 
36968 [INTERNAL]  Ensure work vectors long enough to evaluate function.
36969 
36970 ";
36971 
36972 %feature("docstring")  casadi::Rootfinder::get_sparsity_in(casadi_int i)  "
36973 
36974 [INTERNAL]  Sparsities of function inputs and outputs.
36975 
36976 ";
36977 
36978 %feature("docstring")  casadi::OracleFunction::monitored(const std::string
36979 &name) const  "
36980 
36981 [INTERNAL] ";
36982 
36983 %feature("docstring")  casadi::FunctionInternal::convert_res(const
36984 std::vector< M > &res) const  "
36985 
36986 [INTERNAL]  Convert from/to input/output lists/map.
36987 
36988 ";
36989 
36990 %feature("docstring")  casadi::FunctionInternal::convert_res(const std::map<
36991 std::string, M > &res) const  "
36992 
36993 [INTERNAL]  Convert from/to input/output lists/map.
36994 
36995 ";
36996 
36997 %feature("docstring")  casadi::FunctionInternal::jacobian() const  "
36998 
36999 [INTERNAL]  Return Jacobian of all input elements with respect to all output
37000 elements.
37001 
37002 ";
37003 
37004 %feature("docstring")  casadi::FunctionInternal::get_jacobian(const
37005 std::string &name, const std::vector< std::string > &inames, const
37006 std::vector< std::string > &onames, const Dict &opts) const  "
37007 
37008 [INTERNAL]  Return Jacobian of all input elements with respect to all output
37009 elements.
37010 
37011 ";
37012 
37013 %feature("docstring")  casadi::FunctionInternal::has_jacobian_sparsity()
37014 const  "
37015 
37016 [INTERNAL]  Get Jacobian sparsity.
37017 
37018 ";
37019 
37020 %feature("docstring")  casadi::FunctionInternal::codegen_meta(CodeGenerator
37021 &g) const  "
37022 
37023 [INTERNAL]  Generate meta-information allowing a user to evaluate a
37024 generated function.
37025 
37026 ";
37027 
37028 %feature("docstring")  casadi::Rootfinder::get_n_in()  "
37029 
37030 [INTERNAL]  Number of function inputs and outputs.
37031 
37032 ";
37033 
37034 %feature("docstring")  casadi::FunctionInternal::symbolic_output(const
37035 std::vector< MX > &arg) const  "
37036 
37037 [INTERNAL]  Get a vector of symbolic variables corresponding to the outputs.
37038 
37039 ";
37040 
37041 %feature("docstring")  casadi::FunctionInternal::getJacSparsity(casadi_int
37042 iind, casadi_int oind, bool symmetric) const  "
37043 
37044 [INTERNAL]  Generate the sparsity of a Jacobian block.
37045 
37046 ";
37047 
37048 %feature("docstring")  casadi::OracleFunction::get_function() const  "
37049 
37050 [INTERNAL]  Get list of dependency functions -1 Indicates irregularity.
37051 
37052 ";
37053 
37054 %feature("docstring")  casadi::OracleFunction::get_function(const
37055 std::string &name) const  "
37056 
37057 [INTERNAL] ";
37058 
37059 %feature("docstring")  casadi::OracleFunction::finalize()  "
37060 
37061 [INTERNAL]  Finalize initialization.
37062 
37063 ";
37064 
37065 %feature("docstring")  casadi::FunctionInternal::nz_in(const std::vector< DM
37066 > &arg) const  "
37067 
37068 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
37069 
37070 ";
37071 
37072 %feature("docstring")  casadi::FunctionInternal::nz_in(const std::vector<
37073 double > &arg) const  "
37074 
37075 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
37076 
37077 ";
37078 
37079 %feature("docstring")  casadi::FunctionInternal::alloc_iw(size_t sz_iw, bool
37080 persistent=false) "
37081 
37082 [INTERNAL]  Ensure required length of iw field.
37083 
37084 ";
37085 
37086 %feature("docstring")
37087 casadi::FunctionInternal::codegen_free_mem(CodeGenerator &g) const  "
37088 
37089 [INTERNAL]  Codegen for free_mem.
37090 
37091 ";
37092 
37093 %feature("docstring")  casadi::FunctionInternal::incache(const std::string
37094 &fname, Function &f, const std::string &suffix="") const  "
37095 
37096 [INTERNAL]  Get function in cache.
37097 
37098 ";
37099 
37100 %feature("docstring")  casadi::FunctionInternal::tocache(const Function &f,
37101 const std::string &suffix="") const  "
37102 
37103 [INTERNAL]  Save function to cache.
37104 
37105 ";
37106 
37107 %feature("docstring")  casadi::ProtoFunction::print(const char *fmt,...)
37108 const  "
37109 
37110 [INTERNAL]  C-style formatted printing during evaluation.
37111 
37112 ";
37113 
37114 %feature("docstring")  casadi::Rootfinder::ad_reverse(const std::vector< MX
37115 > &arg, const std::vector< MX > &res, const std::vector< std::vector< MX > >
37116 &aseed, std::vector< std::vector< MX > > &asens, bool always_inline, bool
37117 never_inline) const  "
37118 
37119 [INTERNAL]  Create call to (cached) derivative function, reverse mode.
37120 
37121 ";
37122 
37123 %feature("docstring")  casadi::FunctionInternal::get_min_in(casadi_int ind)
37124 const  "
37125 
37126 [INTERNAL]  Get smallest input value.
37127 
37128 ";
37129 
37130 %feature("docstring")  casadi::ImplicitToNlp::alloc_mem() const  "
37131 
37132 [INTERNAL]  Create memory block.
37133 
37134 ";
37135 
37136 %feature("docstring")
37137 casadi::FunctionInternal::codegen_sparsities(CodeGenerator &g) const  "
37138 
37139 [INTERNAL]  Codegen sparsities.
37140 
37141 ";
37142 
37143 %feature("docstring")  casadi::FunctionInternal::dm_out(casadi_int ind)
37144 const  "
37145 
37146 [INTERNAL]  Get function input(s) and output(s)
37147 
37148 ";
37149 
37150 %feature("docstring")  casadi::FunctionInternal::dm_out() const  "
37151 
37152 [INTERNAL]  Get function input(s) and output(s)
37153 
37154 ";
37155 
37156 %feature("docstring")  casadi::FunctionInternal::sx_in(casadi_int ind) const
37157 "
37158 
37159 [INTERNAL]  Get function input(s) and output(s)
37160 
37161 ";
37162 
37163 %feature("docstring")  casadi::FunctionInternal::sx_in() const  "
37164 
37165 [INTERNAL]  Get function input(s) and output(s)
37166 
37167 ";
37168 
37169 %feature("docstring")  casadi::FunctionInternal::fwdViaJac(casadi_int nfwd)
37170 const  "
37171 
37172 [INTERNAL]  Calculate derivatives by multiplying the full Jacobian and
37173 multiplying.
37174 
37175 ";
37176 
37177 %feature("docstring")  casadi::FunctionInternal::reverse(casadi_int nadj)
37178 const  "
37179 
37180 [INTERNAL]  Return function that calculates adjoint derivatives
37181 reverse(nadj) returns a cached instance if available, and calls  Function
37182 get_reverse(casadi_int nadj) if no cached version is available.
37183 
37184 ";
37185 
37186 %feature("docstring")  casadi::FunctionInternal::instruction_MX(casadi_int
37187 k) const  "
37188 
37189 [INTERNAL]  get MX expression associated with instruction
37190 
37191 ";
37192 
37193 %feature("docstring")  casadi::OracleFunction::calc_function(OracleMemory
37194 *m, const std::string &fcn, const double *const *arg=nullptr) const  "
37195 
37196 [INTERNAL] ";
37197 
37198 %feature("docstring")  casadi::FunctionInternal::has_free() const  "
37199 
37200 [INTERNAL]  Does the function have free variables.
37201 
37202 ";
37203 
37204 %feature("docstring")  casadi::FunctionInternal::n_nodes() const  "
37205 
37206 [INTERNAL]  Number of nodes in the algorithm.
37207 
37208 ";
37209 
37210 %feature("docstring")  casadi::FunctionInternal::get_partition(casadi_int
37211 iind, casadi_int oind, Sparsity &D1, Sparsity &D2, bool compact, bool
37212 symmetric, bool allow_forward, bool allow_reverse) const  "
37213 
37214 [INTERNAL]  Get the unidirectional or bidirectional partition.
37215 
37216 ";
37217 
37218 %feature("docstring")  casadi::FunctionInternal::generate_out(const
37219 std::string &fname, double **res) const  "
37220 
37221 [INTERNAL] ";
37222 
37223 %feature("docstring")  casadi::FunctionInternal::wrap_as_needed(const Dict
37224 &opts) const  "
37225 
37226 [INTERNAL]  Wrap in an Function instance consisting of only one MX call.
37227 
37228 ";
37229 
37230 %feature("docstring")  casadi::FunctionInternal::codegen(CodeGenerator &g,
37231 const std::string &fname) const  "
37232 
37233 [INTERNAL]  Generate code the function.
37234 
37235 ";
37236 
37237 %feature("docstring")  casadi::FunctionInternal::replace_arg(const
37238 std::vector< M > &arg, casadi_int npar) const  "
37239 
37240 [INTERNAL]  Replace 0-by-0 inputs.
37241 
37242 ";
37243 
37244 %feature("docstring")
37245 casadi::FunctionInternal::codegen_decref(CodeGenerator &g) const  "
37246 
37247 [INTERNAL]  Codegen decref for dependencies.
37248 
37249 ";
37250 
37251 %feature("docstring")  casadi::FunctionInternal::has_jacobian() const  "
37252 
37253 [INTERNAL]  Return Jacobian of all input elements with respect to all output
37254 elements.
37255 
37256 ";
37257 
37258 %feature("docstring")  casadi::Rootfinder::uses_output() const  "
37259 
37260 [INTERNAL]  Do the derivative functions need nondifferentiated outputs?
37261 
37262 ";
37263 
37264 %feature("docstring")  casadi::FunctionInternal::forward(casadi_int nfwd)
37265 const  "
37266 
37267 [INTERNAL]  Return function that calculates forward derivatives
37268 forward(nfwd) returns a cached instance if available, and calls  Function
37269 get_forward(casadi_int nfwd) if no cached version is available.
37270 
37271 ";
37272 
37273 %feature("docstring")  casadi::FunctionInternal::export_code(const
37274 std::string &lang, std::ostream &stream, const Dict &options) const  "
37275 
37276 [INTERNAL]  Export function in a specific language.
37277 
37278 ";
37279 
37280 %feature("docstring")  casadi::FunctionInternal::nnz_in() const  "
37281 
37282 [INTERNAL]  Number of input/output nonzeros.
37283 
37284 ";
37285 
37286 %feature("docstring")  casadi::FunctionInternal::nnz_in(casadi_int ind)
37287 const  "
37288 
37289 [INTERNAL]  Number of input/output nonzeros.
37290 
37291 ";
37292 
37293 %feature("docstring")  casadi::FunctionInternal::wrap() const  "
37294 
37295 [INTERNAL]  Wrap in an Function instance consisting of only one MX call.
37296 
37297 ";
37298 
37299 %feature("docstring")
37300 casadi::FunctionInternal::codegen_init_mem(CodeGenerator &g) const  "
37301 
37302 [INTERNAL]  Codegen decref for init_mem.
37303 
37304 ";
37305 
37306 %feature("docstring")  casadi::FunctionInternal::n_instructions() const  "
37307 
37308 [INTERNAL]  Get the number of atomic operations.
37309 
37310 ";
37311 
37312 %feature("docstring")  casadi::FunctionInternal::project_res(const
37313 std::vector< M > &arg, casadi_int npar) const  "
37314 
37315 [INTERNAL]   Project sparsities.
37316 
37317 ";
37318 
37319 %feature("docstring")
37320 casadi::FunctionInternal::jacobian_sparsity_filter(const Sparsity &sp) const
37321 "
37322 
37323 [INTERNAL]  Filter out nonzeros in the full sparsity jacobian according to
37324 is_diff_in/out.
37325 
37326 ";
37327 
37328 %feature("docstring")  casadi::OracleFunction::generate_dependencies(const
37329 std::string &fname, const Dict &opts) const  "
37330 
37331 [INTERNAL]  Export / Generate C code for the generated functions.
37332 
37333 ";
37334 
37335 %feature("docstring")  casadi::FunctionInternal::get_jacobian_sparsity()
37336 const  "
37337 
37338 [INTERNAL]  Get Jacobian sparsity.
37339 
37340 ";
37341 
37342 %feature("docstring")  casadi::OracleFunction::expand() "
37343 
37344 [INTERNAL] ";
37345 
37346 %feature("docstring")
37347 casadi::FunctionInternal::instruction_constant(casadi_int k) const  "
37348 
37349 [INTERNAL]  Get the floating point output argument of an atomic operation.
37350 
37351 ";
37352 
37353 %feature("docstring")  casadi::FunctionInternal::get_jac(const std::string
37354 &name, const std::vector< std::string > &inames, const std::vector<
37355 std::string > &onames, const Dict &opts) const  "
37356 
37357 [INTERNAL]  Return Jacobian of all input elements with respect to all output
37358 elements.
37359 
37360 ";
37361 
37362 %feature("docstring")  casadi::ImplicitToNlp::get_stats(void *mem) const  "
37363 
37364 [INTERNAL]  Get all statistics.
37365 
37366 ";
37367 
37368 %feature("docstring")  casadi::FunctionInternal::jacobian_sparsity() const
37369 "
37370 
37371 [INTERNAL]  Get Jacobian sparsity.
37372 
37373 ";
37374 
37375 %feature("docstring")  casadi::FunctionInternal::codegen_mem_type() const  "
37376 
37377 [INTERNAL]  Thread-local memory object type.
37378 
37379 ";
37380 
37381 %feature("docstring")  casadi::FunctionInternal::numel_in() const  "
37382 
37383 [INTERNAL]  Number of input/output elements.
37384 
37385 ";
37386 
37387 %feature("docstring")  casadi::FunctionInternal::numel_in(casadi_int ind)
37388 const  "
37389 
37390 [INTERNAL]  Number of input/output elements.
37391 
37392 ";
37393 
37394 %feature("docstring")  casadi::FunctionInternal::adjViaJac(casadi_int nadj)
37395 const  "
37396 
37397 [INTERNAL]  Calculate derivatives by multiplying the full Jacobian and
37398 multiplying.
37399 
37400 ";
37401 
37402 %feature("docstring")
37403 casadi::FunctionInternal::instruction_output(casadi_int k) const  "
37404 
37405 [INTERNAL]  Get the (integer) output argument of an atomic operation.
37406 
37407 ";
37408 
37409 %feature("docstring")  casadi::FunctionInternal::size2_out(casadi_int ind)
37410 const  "
37411 
37412 [INTERNAL]  Input/output dimensions.
37413 
37414 ";
37415 
37416 %feature("docstring")  casadi::OracleFunction::oracle() const  "
37417 
37418 [INTERNAL]  Get oracle.
37419 
37420 ";
37421 
37422 %feature("docstring")  casadi::FunctionInternal::eval_mx(const MXVector
37423 &arg, MXVector &res, bool always_inline, bool never_inline) const  "
37424 
37425 [INTERNAL]  Evaluate with symbolic matrices.
37426 
37427 ";
37428 
37429 %feature("docstring")  casadi::Rootfinder::get_sparsity_out(casadi_int i)  "
37430 
37431 [INTERNAL]  Sparsities of function inputs and outputs.
37432 
37433 ";
37434 
37435 %feature("docstring")  casadi::ProtoFunction::release(int mem) const  "
37436 
37437 [INTERNAL]  Release a memory object.
37438 
37439 ";
37440 
37441 %feature("docstring")  casadi::FunctionInternal::self() const  "
37442 
37443 [INTERNAL]  Get a public class instance.
37444 
37445 ";
37446 
37447 %feature("docstring")  casadi::ImplicitToNlp::free_mem(void *mem) const  "
37448 
37449 [INTERNAL]  Free memory block.
37450 
37451 ";
37452 
37453 %feature("docstring")
37454 casadi::FunctionInternal::getJacSparsityGen(casadi_int iind, casadi_int
37455 oind, bool symmetric, casadi_int gr_i=1, casadi_int gr_o=1) const  "
37456 
37457 [INTERNAL]  Get the sparsity pattern, forward mode.
37458 
37459 ";
37460 
37461 %feature("docstring")  casadi::FunctionInternal::mx_in(casadi_int ind) const
37462 "
37463 
37464 [INTERNAL]  Get function input(s) and output(s)
37465 
37466 ";
37467 
37468 %feature("docstring")  casadi::FunctionInternal::mx_in() const  "
37469 
37470 [INTERNAL]  Get function input(s) and output(s)
37471 
37472 ";
37473 
37474 %feature("docstring")  casadi::FunctionInternal::is_a(const std::string
37475 &type, bool recursive) const  "
37476 
37477 [INTERNAL]  Check if the function is of a particular type.
37478 
37479 ";
37480 
37481 %feature("docstring")  casadi::FunctionInternal::is_diff_in(casadi_int i) "
37482 
37483 [INTERNAL] ";
37484 
37485 %feature("docstring")  casadi::FunctionInternal::call_reverse(const
37486 std::vector< MX > &arg, const std::vector< MX > &res, const std::vector<
37487 std::vector< MX > > &aseed, std::vector< std::vector< MX > > &asens, bool
37488 always_inline, bool never_inline) const  "
37489 
37490 [INTERNAL]  Reverse mode, virtual functions overloaded in derived classes.
37491 
37492 ";
37493 
37494 %feature("docstring")  casadi::FunctionInternal::call_reverse(const
37495 std::vector< SX > &arg, const std::vector< SX > &res, const std::vector<
37496 std::vector< SX > > &aseed, std::vector< std::vector< SX > > &asens, bool
37497 always_inline, bool never_inline) const  "
37498 
37499 [INTERNAL]  Reverse mode, virtual functions overloaded in derived classes.
37500 
37501 ";
37502 
37503 
37504 // File: classcasadi_1_1Importer.xml
37505 %feature("docstring")  casadi::SharedObject::get_str(bool more=false) const
37506 "
37507 
37508 Get string representation.
37509 
37510 ";
37511 
37512 %feature("docstring")  casadi::Importer::body(const std::string &symname)
37513 const  "
37514 
37515 Get the function body, if inlined.
37516 
37517 ";
37518 
37519 %feature("docstring")  casadi::Importer::library() const  "
37520 
37521 Get library name.
37522 
37523 ";
37524 
37525 %feature("docstring")  casadi::Importer::serialize(SerializingStream &s)
37526 const  "
37527 
37528 Serialize an object.
37529 
37530 ";
37531 
37532 %feature("docstring")  casadi::Importer::has_meta(const std::string &cmd,
37533 casadi_int ind=-1) const  "
37534 
37535 Does a meta entry exist?
37536 
37537 ";
37538 
37539 %feature("docstring")  casadi::SharedObject::disp(std::ostream &stream, bool
37540 more=false) const  "
37541 
37542 Print a description of the object.
37543 
37544 ";
37545 
37546 %feature("docstring")  casadi::SharedObject::is_null() const  "
37547 
37548 Is a null pointer?
37549 
37550 ";
37551 
37552 %feature("docstring") casadi::Importer "
37553 
37554 Importer.
37555 
37556 Just-in-time compilation of code
37557 
37558 General information
37559 ===================
37560 
37561 
37562 
37563 List of plugins
37564 ===============
37565 
37566 
37567 
37568 - clang
37569 
37570 - shell
37571 
37572 Note: some of the plugins in this list might not be available on your
37573 system. Also, there might be extra plugins available to you that are not
37574 listed here. You can obtain their documentation with
37575 Importer.doc(\"myextraplugin\")
37576 
37577 
37578 
37579 --------------------------------------------------------------------------------
37580 
37581 clang
37582 -----
37583 
37584 
37585 
37586 Interface to the JIT compiler CLANG
37587 
37588 >List of available options
37589 
37590 +--------------+-----------------+-----------------------------------------+
37591 |      Id      |      Type       |               Description               |
37592 +==============+=================+=========================================+
37593 | flags        | OT_STRINGVECTOR | Compile flags for the JIT compiler.     |
37594 |              |                 | Default: None                           |
37595 +--------------+-----------------+-----------------------------------------+
37596 | include_path | OT_STRING       | Include paths for the JIT compiler. The |
37597 |              |                 | include directory shipped with CasADi   |
37598 |              |                 | will be automatically appended.         |
37599 +--------------+-----------------+-----------------------------------------+
37600 
37601 --------------------------------------------------------------------------------
37602 
37603 
37604 
37605 --------------------------------------------------------------------------------
37606 
37607 shell
37608 -----
37609 
37610 
37611 
37612 Interface to the JIT compiler SHELL
37613 
37614 >List of available options
37615 
37616 +----------------------+-----------------+---------------------------------+
37617 |          Id          |      Type       |           Description           |
37618 +======================+=================+=================================+
37619 | cleanup              | OT_BOOL         | Cleanup temporary files when    |
37620 |                      |                 | unloading. Default: true        |
37621 +----------------------+-----------------+---------------------------------+
37622 | compiler             | OT_STRING       | Compiler command                |
37623 +----------------------+-----------------+---------------------------------+
37624 | compiler_flags       | OT_STRINGVECTOR | Alias for 'compiler_flags'      |
37625 +----------------------+-----------------+---------------------------------+
37626 | compiler_output_flag | OT_STRING       | Compiler flag to denote object  |
37627 |                      |                 | output. Default: '-o '          |
37628 +----------------------+-----------------+---------------------------------+
37629 | compiler_setup       | OT_STRING       | Compiler setup command.         |
37630 |                      |                 | Intended to be fixed. The       |
37631 |                      |                 | 'flag' option is the prefered   |
37632 |                      |                 | way to set custom flags.        |
37633 +----------------------+-----------------+---------------------------------+
37634 | extra_suffixes       | OT_STRINGVECTOR | List of suffixes for extra      |
37635 |                      |                 | files that the compiler may     |
37636 |                      |                 | generate. Default: None         |
37637 +----------------------+-----------------+---------------------------------+
37638 | flags                | OT_STRINGVECTOR | Compile flags for the JIT       |
37639 |                      |                 | compiler. Default: None         |
37640 +----------------------+-----------------+---------------------------------+
37641 | folder               | OT_STRING       | Folder to put temporary objects |
37642 |                      |                 | in.                             |
37643 +----------------------+-----------------+---------------------------------+
37644 | linker               | OT_STRING       | Linker command                  |
37645 +----------------------+-----------------+---------------------------------+
37646 | linker_flags         | OT_STRINGVECTOR | Linker flags for the JIT        |
37647 |                      |                 | compiler. Default: None         |
37648 +----------------------+-----------------+---------------------------------+
37649 | linker_output_flag   | OT_STRING       | Linker flag to denote shared    |
37650 |                      |                 | library output. Default: '-o '  |
37651 +----------------------+-----------------+---------------------------------+
37652 | linker_setup         | OT_STRING       | Linker setup command. Intended  |
37653 |                      |                 | to be fixed. The 'flag' option  |
37654 |                      |                 | is the prefered way to set      |
37655 |                      |                 | custom flags.                   |
37656 +----------------------+-----------------+---------------------------------+
37657 | name                 | OT_STRING       | The file name used to write out |
37658 |                      |                 | compiled objects/libraries. The |
37659 |                      |                 | actual file names used depend   |
37660 |                      |                 | on 'temp_suffix' and include    |
37661 |                      |                 | extensions. Default:            |
37662 |                      |                 | 'tmp_casadi_compiler_shell'     |
37663 +----------------------+-----------------+---------------------------------+
37664 | temp_suffix          | OT_BOOL         | Use a temporary (seemingly      |
37665 |                      |                 | random) filename suffix for     |
37666 |                      |                 | file names. This is desired for |
37667 |                      |                 | thread-safety. This behaviour   |
37668 |                      |                 | may defeat caching compiler     |
37669 |                      |                 | wrappers. Default: true         |
37670 +----------------------+-----------------+---------------------------------+
37671 
37672 --------------------------------------------------------------------------------
37673 
37674 
37675 
37676 Joris Gillis
37677 
37678 C++ includes: importer.hpp ";
37679 
37680 %feature("docstring")  casadi::Importer::plugin_name() const  "
37681 
37682 Query plugin name.
37683 
37684 ";
37685 
37686 %feature("docstring") casadi::Importer::Importer() "
37687 
37688 Default constructor.
37689 
37690 ";
37691 
37692 %feature("docstring") casadi::Importer::Importer(const std::string &name,
37693 const std::string &compiler, const Dict &opts=Dict()) "
37694 
37695 Importer factory.
37696 
37697 ";
37698 
37699 %feature("docstring")  casadi::SharedObject::class_name() const  "
37700 
37701 Get class name.
37702 
37703 ";
37704 
37705 %feature("docstring")  casadi::Importer::get_meta(const std::string &cmd,
37706 casadi_int ind=-1) const  "
37707 
37708 Get entry as a text.
37709 
37710 ";
37711 
37712 %feature("docstring")  casadi::SharedObject::print_ptr(std::ostream
37713 &stream=casadi::uout()) const  "
37714 
37715 [INTERNAL]  Print the pointer to the internal class
37716 
37717 ";
37718 
37719 %feature("docstring") casadi::Importer::__hash__ "
37720 
37721 Returns a number that is unique for a given Node. If the Object does not
37722 point to any node, \"0\" is returned.
37723 
37724 ";
37725 
37726 %feature("docstring")  casadi::Importer::inlined(const std::string &symname)
37727 const  "
37728 
37729 Check if a function is inlined.
37730 
37731 ";
37732 
37733 
37734 // File: classcasadi_1_1InfSX.xml
37735 
37736 
37737 // File: classcasadi_1_1Input.xml
37738 
37739 
37740 // File: classcasadi_1_1IntegerSX.xml
37741 
37742 
37743 // File: classcasadi_1_1Integrator.xml
37744 %feature("docstring")  casadi::OracleFunction::has_function(const
37745 std::string &fname) const  "
37746 
37747 [INTERNAL] ";
37748 
37749 %feature("docstring")  casadi::FunctionInternal::matching_res(const
37750 std::vector< M > &arg, casadi_int &npar) const  "
37751 
37752 [INTERNAL]  Check if output arguments that needs to be replaced.
37753 
37754 Raises errors
37755 
37756 Parameters:
37757 -----------
37758 
37759 npar[in]:  normal usage: 1, disallow pararallel calls: -1
37760 
37761 npar:  max number of horizontal repetitions across all arguments (or -1)
37762 
37763 ";
37764 
37765 %feature("docstring")  casadi::FunctionInternal::sz_arg() const  "
37766 
37767 [INTERNAL]  Get required length of arg field.
37768 
37769 ";
37770 
37771 %feature("docstring")  casadi::FunctionInternal::project_arg(const
37772 std::vector< M > &arg, casadi_int npar) const  "
37773 
37774 [INTERNAL]   Project sparsities.
37775 
37776 ";
37777 
37778 %feature("docstring")  casadi::FunctionInternal::size_in(casadi_int ind)
37779 const  "
37780 
37781 [INTERNAL]  Input/output dimensions.
37782 
37783 ";
37784 
37785 %feature("docstring")  casadi::ProtoFunction::sprint(char *buf, size_t
37786 buf_sz, const char *fmt,...) const  "
37787 
37788 [INTERNAL]  C-style formatted printing to string.
37789 
37790 ";
37791 
37792 %feature("docstring")  casadi::FunctionInternal::symbolic_output(const
37793 std::vector< MX > &arg) const  "
37794 
37795 [INTERNAL]  Get a vector of symbolic variables corresponding to the outputs.
37796 
37797 ";
37798 
37799 %feature("docstring")  casadi::OracleFunction::set_function(const Function
37800 &fcn, const std::string &fname, bool jit=false) "
37801 
37802 [INTERNAL]  Register the function for evaluation and statistics gathering
37803 
37804 ";
37805 
37806 %feature("docstring")  casadi::OracleFunction::set_function(const Function
37807 &fcn) "
37808 
37809 [INTERNAL]  Register the function for evaluation and statistics gathering
37810 
37811 ";
37812 
37813 %feature("docstring")  casadi::FunctionInternal::replace_aseed(const
37814 std::vector< std::vector< M >> &aseed, casadi_int npar) const  "
37815 
37816 [INTERNAL]  Replace 0-by-0 reverse seeds.
37817 
37818 ";
37819 
37820 %feature("docstring")  casadi::FunctionInternal::replace_aseed(const
37821 std::vector< std::vector< M > > &aseed, casadi_int npar) const  "
37822 
37823 [INTERNAL] ";
37824 
37825 %feature("docstring")  casadi::Integrator::aug_fwd(casadi_int nfwd) const  "
37826 
37827 [INTERNAL]  Generate a augmented DAE system with nfwd forward sensitivities.
37828 
37829 ";
37830 
37831 %feature("docstring")
37832 casadi::FunctionInternal::codegen_declarations(CodeGenerator &g) const  "
37833 
37834 [INTERNAL]  Generate code for the declarations of the C function.
37835 
37836 ";
37837 
37838 %feature("docstring")  casadi::FunctionInternal::sz_iw() const  "
37839 
37840 [INTERNAL]  Get required length of iw field.
37841 
37842 ";
37843 
37844 %feature("docstring")  casadi::FunctionInternal::has_free() const  "
37845 
37846 [INTERNAL]  Does the function have free variables.
37847 
37848 ";
37849 
37850 %feature("docstring")  casadi::FunctionInternal::wrap() const  "
37851 
37852 [INTERNAL]  Wrap in an Function instance consisting of only one MX call.
37853 
37854 ";
37855 
37856 %feature("docstring")  casadi::FunctionInternal::jacobian() const  "
37857 
37858 [INTERNAL]  Return Jacobian of all input elements with respect to all output
37859 elements.
37860 
37861 ";
37862 
37863 %feature("docstring")  casadi::FunctionInternal::factory(const std::string
37864 &name, const std::vector< std::string > &s_in, const std::vector<
37865 std::string > &s_out, const Function::AuxOut &aux, const Dict &opts) const
37866 "
37867 
37868 [INTERNAL] ";
37869 
37870 %feature("docstring")  casadi::FunctionInternal::size1_in(casadi_int ind)
37871 const  "
37872 
37873 [INTERNAL]  Input/output dimensions.
37874 
37875 ";
37876 
37877 %feature("docstring")  casadi::Integrator::z() const  "
37878 
37879 [INTERNAL] ";
37880 
37881 %feature("docstring")  casadi::Integrator::x() const  "
37882 
37883 [INTERNAL] ";
37884 
37885 %feature("docstring")  casadi::FunctionInternal::tocache(const Function &f,
37886 const std::string &suffix="") const  "
37887 
37888 [INTERNAL]  Save function to cache.
37889 
37890 ";
37891 
37892 %feature("docstring")  casadi::FunctionInternal::eval_sx(const SXElem **arg,
37893 SXElem **res, casadi_int *iw, SXElem *w, void *mem) const  "
37894 
37895 [INTERNAL]  Evaluate with symbolic scalars.
37896 
37897 ";
37898 
37899 %feature("docstring")  casadi::Integrator::q() const  "
37900 
37901 [INTERNAL] ";
37902 
37903 %feature("docstring")  casadi::Integrator::p() const  "
37904 
37905 [INTERNAL] ";
37906 
37907 %feature("docstring")  casadi::FunctionInternal::instructions_sx() const  "
37908 
37909 [INTERNAL]  get SX expression associated with instructions
37910 
37911 ";
37912 
37913 %feature("docstring")  casadi::Integrator::t() const  "
37914 
37915 [INTERNAL] ";
37916 
37917 %feature("docstring")  casadi::FunctionInternal::is_diff_in(casadi_int i) "
37918 
37919 [INTERNAL] ";
37920 
37921 %feature("docstring")  casadi::SharedObjectInternal::weak() "
37922 
37923 [INTERNAL]  Get a weak reference to the object.
37924 
37925 ";
37926 
37927 %feature("docstring")  casadi::FunctionInternal::adjViaJac(casadi_int nadj)
37928 const  "
37929 
37930 [INTERNAL]  Calculate derivatives by multiplying the full Jacobian and
37931 multiplying.
37932 
37933 ";
37934 
37935 %feature("docstring")  casadi::OracleFunction::calc_function(OracleMemory
37936 *m, const std::string &fcn, const double *const *arg=nullptr) const  "
37937 
37938 [INTERNAL] ";
37939 
37940 %feature("docstring")  casadi::FunctionInternal::get_jac(const std::string
37941 &name, const std::vector< std::string > &inames, const std::vector<
37942 std::string > &onames, const Dict &opts) const  "
37943 
37944 [INTERNAL]  Return Jacobian of all input elements with respect to all output
37945 elements.
37946 
37947 ";
37948 
37949 %feature("docstring")  casadi::FunctionInternal::codegen(CodeGenerator &g,
37950 const std::string &fname) const  "
37951 
37952 [INTERNAL]  Generate code the function.
37953 
37954 ";
37955 
37956 %feature("docstring")  casadi::OracleFunction::jit_dependencies(const
37957 std::string &fname)  "
37958 
37959 [INTERNAL]  JIT for dependencies.
37960 
37961 ";
37962 
37963 %feature("docstring")
37964 casadi::FunctionInternal::codegen_free_mem(CodeGenerator &g) const  "
37965 
37966 [INTERNAL]  Codegen for free_mem.
37967 
37968 ";
37969 
37970 %feature("docstring")  casadi::FunctionInternal::jacobian_sparsity() const
37971 "
37972 
37973 [INTERNAL]  Get Jacobian sparsity.
37974 
37975 ";
37976 
37977 %feature("docstring")  casadi::FunctionInternal::nz_out(const std::vector<
37978 DM > &res) const  "
37979 
37980 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
37981 
37982 ";
37983 
37984 %feature("docstring")  casadi::FunctionInternal::nz_out(const std::vector<
37985 double > &res) const  "
37986 
37987 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
37988 
37989 ";
37990 
37991 %feature("docstring")  casadi::FunctionInternal::setup(void *mem, const
37992 double **arg, double **res, casadi_int *iw, double *w) const  "
37993 
37994 [INTERNAL]  Set the (persistent and temporary) work vectors.
37995 
37996 ";
37997 
37998 %feature("docstring")  casadi::FunctionInternal::alloc_iw(size_t sz_iw, bool
37999 persistent=false) "
38000 
38001 [INTERNAL]  Ensure required length of iw field.
38002 
38003 ";
38004 
38005 %feature("docstring")  casadi::FunctionInternal::sx_out(casadi_int ind)
38006 const  "
38007 
38008 [INTERNAL]  Get function input(s) and output(s)
38009 
38010 ";
38011 
38012 %feature("docstring")  casadi::FunctionInternal::sx_out() const  "
38013 
38014 [INTERNAL]  Get function input(s) and output(s)
38015 
38016 ";
38017 
38018 %feature("docstring")  casadi::FunctionInternal::n_instructions() const  "
38019 
38020 [INTERNAL]  Get the number of atomic operations.
38021 
38022 ";
38023 
38024 %feature("docstring")  casadi::FunctionInternal::reverse(casadi_int nadj)
38025 const  "
38026 
38027 [INTERNAL]  Return function that calculates adjoint derivatives
38028 reverse(nadj) returns a cached instance if available, and calls  Function
38029 get_reverse(casadi_int nadj) if no cached version is available.
38030 
38031 ";
38032 
38033 %feature("docstring")  casadi::FunctionInternal::sparsity_jac(casadi_int
38034 iind, casadi_int oind, bool compact, bool symmetric) const  "
38035 
38036 [INTERNAL]  Get, if necessary generate, the sparsity of a Jacobian block.
38037 
38038 ";
38039 
38040 %feature("docstring")  casadi::FunctionInternal::mapsum_mx(const
38041 std::vector< MX > &arg, const std::string &parallelization) "
38042 
38043 [INTERNAL]  Parallel evaluation.
38044 
38045 ";
38046 
38047 %feature("docstring")
38048 casadi::FunctionInternal::codegen_sparsities(CodeGenerator &g) const  "
38049 
38050 [INTERNAL]  Codegen sparsities.
38051 
38052 ";
38053 
38054 %feature("docstring")  casadi::Integrator::eval(const double **arg, double
38055 **res, casadi_int *iw, double *w, void *mem) const  "
38056 
38057 [INTERNAL]  evaluate
38058 
38059 ";
38060 
38061 %feature("docstring")  casadi::OracleFunction::generate_dependencies(const
38062 std::string &fname, const Dict &opts) const  "
38063 
38064 [INTERNAL]  Export / Generate C code for the generated functions.
38065 
38066 ";
38067 
38068 %feature("docstring")  casadi::FunctionInternal::dm_in(casadi_int ind) const
38069 "
38070 
38071 [INTERNAL]  Get function input(s) and output(s)
38072 
38073 ";
38074 
38075 %feature("docstring")  casadi::FunctionInternal::dm_in() const  "
38076 
38077 [INTERNAL]  Get function input(s) and output(s)
38078 
38079 ";
38080 
38081 %feature("docstring")
38082 casadi::FunctionInternal::getJacSparsityGen(casadi_int iind, casadi_int
38083 oind, bool symmetric, casadi_int gr_i=1, casadi_int gr_o=1) const  "
38084 
38085 [INTERNAL]  Get the sparsity pattern, forward mode.
38086 
38087 ";
38088 
38089 %feature("docstring")  casadi::Integrator::resetB(IntegratorMemory *mem,
38090 double t, const double *rx, const double *rz, const double *rp) const  "
38091 
38092 [INTERNAL]  Reset the backward problem.
38093 
38094 ";
38095 
38096 %feature("docstring")  casadi::FunctionInternal::call(const std::vector< M >
38097 &arg, std::vector< M > &res, bool always_inline, bool never_inline) const  "
38098 
38099 [INTERNAL]   Call a function, templated.
38100 
38101 ";
38102 
38103 %feature("docstring")  casadi::OracleFunction::monitored(const std::string
38104 &name) const  "
38105 
38106 [INTERNAL] ";
38107 
38108 %feature("docstring")  casadi::Integrator::init_mem(void *mem) const  "
38109 
38110 [INTERNAL]  Initalize memory block.
38111 
38112 ";
38113 
38114 %feature("docstring")  casadi::ProtoFunction::format_time(char *buffer,
38115 double time) const  "
38116 
38117 [INTERNAL]  Format time in a fixed width 8 format.
38118 
38119 ";
38120 
38121 %feature("docstring")  casadi::FunctionInternal::has_jacobian_sparsity()
38122 const  "
38123 
38124 [INTERNAL]  Get Jacobian sparsity.
38125 
38126 ";
38127 
38128 %feature("docstring")  casadi::FunctionInternal::check_arg(const
38129 std::vector< M > &arg, casadi_int &npar) const  "
38130 
38131 [INTERNAL]  Check if input arguments have correct length and dimensions.
38132 
38133 Raises errors.
38134 
38135 Parameters:
38136 -----------
38137 
38138 npar[in]:  normal usage: 1, disallow pararallel calls: -1
38139 
38140 npar:  max number of horizontal repetitions across all arguments (or -1)
38141 
38142 ";
38143 
38144 %feature("docstring")  casadi::FunctionInternal::instruction_id(casadi_int
38145 k) const  "
38146 
38147 [INTERNAL]  Get an atomic operation operator index.
38148 
38149 ";
38150 
38151 %feature("docstring")  casadi::FunctionInternal::sz_w() const  "
38152 
38153 [INTERNAL]  Get required length of w field.
38154 
38155 ";
38156 
38157 %feature("docstring")  casadi::FunctionInternal::get_abstol() const  "
38158 
38159 [INTERNAL]  Get absolute tolerance.
38160 
38161 ";
38162 
38163 %feature("docstring")  casadi::FunctionInternal::is_diff_out(casadi_int i) "
38164 
38165 [INTERNAL] ";
38166 
38167 %feature("docstring")  casadi::Integrator::serialize_body(SerializingStream
38168 &s) const  "
38169 
38170 [INTERNAL]  Serialize an object without type information.
38171 
38172 ";
38173 
38174 %feature("docstring")  casadi::FunctionInternal::get_free() const  "
38175 
38176 [INTERNAL]  Print free variables.
38177 
38178 ";
38179 
38180 %feature("docstring")  casadi::FunctionInternal::is_a(const std::string
38181 &type, bool recursive) const  "
38182 
38183 [INTERNAL]  Check if the function is of a particular type.
38184 
38185 ";
38186 
38187 %feature("docstring")  casadi::Integrator::sp_reverse(bvec_t **arg, bvec_t
38188 **res, casadi_int *iw, bvec_t *w, void *mem) const  "
38189 
38190 [INTERNAL]  Propagate sparsity backwards.
38191 
38192 ";
38193 
38194 %feature("docstring")  casadi::FunctionInternal::codegen_name(const
38195 CodeGenerator &g, bool ns=true) const  "
38196 
38197 [INTERNAL]  Get name in codegen.
38198 
38199 ";
38200 
38201 %feature("docstring")  casadi::FunctionInternal::generate_in(const
38202 std::string &fname, const double **arg) const  "
38203 
38204 [INTERNAL]  Export an input file that can be passed to generate C code with
38205 a main.
38206 
38207 ";
38208 
38209 %feature("docstring")  casadi::ProtoFunction::print(const char *fmt,...)
38210 const  "
38211 
38212 [INTERNAL]  C-style formatted printing during evaluation.
38213 
38214 ";
38215 
38216 %feature("docstring")  casadi::FunctionInternal::eval_dm(const std::vector<
38217 DM > &arg) const  "
38218 
38219 [INTERNAL]  Evaluate with DM matrices.
38220 
38221 ";
38222 
38223 %feature("docstring") casadi::Integrator::Integrator(const std::string
38224 &name, const Function &oracle) "
38225 
38226 [INTERNAL]  Constructor.
38227 
38228 ";
38229 
38230 %feature("docstring")  casadi::FunctionInternal::project_res(const
38231 std::vector< M > &arg, casadi_int npar) const  "
38232 
38233 [INTERNAL]   Project sparsities.
38234 
38235 ";
38236 
38237 %feature("docstring")  casadi::Integrator::sp_jac_dae() "
38238 
38239 [INTERNAL]  Create sparsity pattern of the extended Jacobian (forward
38240 problem)
38241 
38242 ";
38243 
38244 %feature("docstring")  casadi::FunctionInternal::call_reverse(const
38245 std::vector< MX > &arg, const std::vector< MX > &res, const std::vector<
38246 std::vector< MX > > &aseed, std::vector< std::vector< MX > > &asens, bool
38247 always_inline, bool never_inline) const  "
38248 
38249 [INTERNAL]  Reverse mode, virtual functions overloaded in derived classes.
38250 
38251 ";
38252 
38253 %feature("docstring")  casadi::FunctionInternal::call_reverse(const
38254 std::vector< SX > &arg, const std::vector< SX > &res, const std::vector<
38255 std::vector< SX > > &aseed, std::vector< std::vector< SX > > &asens, bool
38256 always_inline, bool never_inline) const  "
38257 
38258 [INTERNAL]  Reverse mode, virtual functions overloaded in derived classes.
38259 
38260 ";
38261 
38262 %feature("docstring")  casadi::Integrator::has_sprev() const  "
38263 
38264 [INTERNAL]  Is the class able to propagate seeds through the algorithm?
38265 
38266 ";
38267 
38268 %feature("docstring")  casadi::Integrator::advance(IntegratorMemory *mem,
38269 double t, double *x, double *z, double *q) const  "
38270 
38271 [INTERNAL]  Advance solution in time.
38272 
38273 ";
38274 
38275 %feature("docstring")  casadi::FunctionInternal::codegen_body(CodeGenerator
38276 &g) const  "
38277 
38278 [INTERNAL]  Generate code for the function body.
38279 
38280 ";
38281 
38282 %feature("docstring")  casadi::OracleFunction::create_function(const
38283 std::string &fname, const std::vector< std::string > &s_in, const
38284 std::vector< std::string > &s_out, const Function::AuxOut
38285 &aux=Function::AuxOut()) "
38286 
38287 [INTERNAL]  Create an oracle function
38288 
38289 ";
38290 
38291 %feature("docstring")  casadi::FunctionInternal::get_jacobian(const
38292 std::string &name, const std::vector< std::string > &inames, const
38293 std::vector< std::string > &onames, const Dict &opts) const  "
38294 
38295 [INTERNAL]  Return Jacobian of all input elements with respect to all output
38296 elements.
38297 
38298 ";
38299 
38300 %feature("docstring")
38301 casadi::FunctionInternal::codegen_incref(CodeGenerator &g) const  "
38302 
38303 [INTERNAL]  Codegen incref for dependencies.
38304 
38305 ";
38306 
38307 %feature("docstring")  casadi::Integrator::serialize_type(SerializingStream
38308 &s) const  "
38309 
38310 [INTERNAL]  Serialize type information.
38311 
38312 ";
38313 
38314 %feature("docstring")  casadi::FunctionInternal::getJacSparsity(casadi_int
38315 iind, casadi_int oind, bool symmetric) const  "
38316 
38317 [INTERNAL]  Generate the sparsity of a Jacobian block.
38318 
38319 ";
38320 
38321 %feature("docstring")  casadi::Integrator::retreat(IntegratorMemory *mem,
38322 double t, double *rx, double *rz, double *rq) const  "
38323 
38324 [INTERNAL]  Retreat solution in time.
38325 
38326 ";
38327 
38328 %feature("docstring")  casadi::Integrator::has_reverse(casadi_int nadj)
38329 const  "
38330 
38331 [INTERNAL]  Generate a function that calculates nadj adjoint derivatives.
38332 
38333 ";
38334 
38335 %feature("docstring")  casadi::FunctionInternal::matching_arg(const
38336 std::vector< M > &arg, casadi_int &npar) const  "
38337 
38338 [INTERNAL]  Check if input arguments that needs to be replaced.
38339 
38340 Raises errors
38341 
38342 Parameters:
38343 -----------
38344 
38345 npar[in]:  normal usage: 1, disallow pararallel calls: -1
38346 
38347 npar:  max number of horizontal repetitions across all arguments (or -1)
38348 
38349 ";
38350 
38351 %feature("docstring")  casadi::FunctionInternal::has_eval_dm() const  "
38352 
38353 [INTERNAL]  Evaluate with DM matrices.
38354 
38355 ";
38356 
38357 %feature("docstring")  casadi::FunctionInternal::set_work(void *mem, const
38358 double **&arg, double **&res, casadi_int *&iw, double *&w) const  "
38359 
38360 [INTERNAL]  Set the (persistent) work vectors.
38361 
38362 ";
38363 
38364 %feature("docstring")  casadi::FunctionInternal::convert_res(const
38365 std::vector< M > &res) const  "
38366 
38367 [INTERNAL]  Convert from/to input/output lists/map.
38368 
38369 ";
38370 
38371 %feature("docstring")  casadi::FunctionInternal::convert_res(const std::map<
38372 std::string, M > &res) const  "
38373 
38374 [INTERNAL]  Convert from/to input/output lists/map.
38375 
38376 ";
38377 
38378 %feature("docstring")  casadi::FunctionInternal::get_default_in(casadi_int
38379 ind) const  "
38380 
38381 [INTERNAL]  Get default input value.
38382 
38383 ";
38384 
38385 %feature("docstring")  casadi::ProtoFunction::print_time(const std::map<
38386 std::string, FStats > &fstats) const  "
38387 
38388 [INTERNAL]  Print timing statistics.
38389 
38390 ";
38391 
38392 %feature("docstring") casadi::Integrator "
38393 
38394 Internal storage for integrator related data.
38395 
38396 Joel Andersson
38397 
38398 >List of available options
38399 
38400 +------------------+-----------------+------------------+------------------+
38401 |        Id        |      Type       |   Description    |     Used in      |
38402 +==================+=================+==================+==================+
38403 | augmented_option | OT_DICT         | Options to be    | casadi::Integrat |
38404 | s                |                 | passed down to   | or               |
38405 |                  |                 | the augmented    |                  |
38406 |                  |                 | integrator, if   |                  |
38407 |                  |                 | one is           |                  |
38408 |                  |                 | constructed.     |                  |
38409 +------------------+-----------------+------------------+------------------+
38410 | common_options   | OT_DICT         | Options for      | casadi::OracleFu |
38411 |                  |                 | auto-generated   | nction           |
38412 |                  |                 | functions        |                  |
38413 +------------------+-----------------+------------------+------------------+
38414 | expand           | OT_BOOL         | Replace MX with  | casadi::Integrat |
38415 |                  |                 | SX expressions   | or               |
38416 |                  |                 | in problem       |                  |
38417 |                  |                 | formulation      |                  |
38418 |                  |                 | [false]          |                  |
38419 +------------------+-----------------+------------------+------------------+
38420 | grid             | OT_DOUBLEVECTOR | Time grid        | casadi::Integrat |
38421 |                  |                 |                  | or               |
38422 +------------------+-----------------+------------------+------------------+
38423 | monitor          | OT_STRINGVECTOR | Set of user      | casadi::OracleFu |
38424 |                  |                 | problem          | nction           |
38425 |                  |                 | functions to be  |                  |
38426 |                  |                 | monitored        |                  |
38427 +------------------+-----------------+------------------+------------------+
38428 | number_of_finite | OT_INT          | Number of finite | casadi::Integrat |
38429 | _elements        |                 | elements         | or               |
38430 +------------------+-----------------+------------------+------------------+
38431 | output_t0        | OT_BOOL         | Output the state | casadi::Integrat |
38432 |                  |                 | at the initial   | or               |
38433 |                  |                 | time             |                  |
38434 +------------------+-----------------+------------------+------------------+
38435 | print_stats      | OT_BOOL         | Print out        | casadi::Integrat |
38436 |                  |                 | statistics after | or               |
38437 |                  |                 | integration      |                  |
38438 +------------------+-----------------+------------------+------------------+
38439 | rootfinder       | OT_STRING       | An implicit      | casadi::Integrat |
38440 |                  |                 | function solver  | or               |
38441 +------------------+-----------------+------------------+------------------+
38442 | rootfinder_optio | OT_DICT         | Options to be    | casadi::Integrat |
38443 | ns               |                 | passed to the    | or               |
38444 |                  |                 | NLP Solver       |                  |
38445 +------------------+-----------------+------------------+------------------+
38446 | show_eval_warnin | OT_BOOL         | Show warnings    | casadi::OracleFu |
38447 | gs               |                 | generated from   | nction           |
38448 |                  |                 | function         |                  |
38449 |                  |                 | evaluations      |                  |
38450 |                  |                 | [true]           |                  |
38451 +------------------+-----------------+------------------+------------------+
38452 | simplify         | OT_BOOL         | Implement as MX  | casadi::Integrat |
38453 |                  |                 | Function (codege | or               |
38454 |                  |                 | neratable/serial |                  |
38455 |                  |                 | izable) default: |                  |
38456 |                  |                 | false            |                  |
38457 +------------------+-----------------+------------------+------------------+
38458 | simplify_options | OT_DICT         | Any options to   | casadi::Integrat |
38459 |                  |                 | pass to          | or               |
38460 |                  |                 | simplified form  |                  |
38461 |                  |                 | Function         |                  |
38462 |                  |                 | constructor      |                  |
38463 +------------------+-----------------+------------------+------------------+
38464 | specific_options | OT_DICT         | Options for      | casadi::OracleFu |
38465 |                  |                 | specific auto-   | nction           |
38466 |                  |                 | generated        |                  |
38467 |                  |                 | functions,       |                  |
38468 |                  |                 | overwriting the  |                  |
38469 |                  |                 | defaults from    |                  |
38470 |                  |                 | common_options.  |                  |
38471 |                  |                 | Nested           |                  |
38472 |                  |                 | dictionary.      |                  |
38473 +------------------+-----------------+------------------+------------------+
38474 | t0               | OT_DOUBLE       | Beginning of the | casadi::Integrat |
38475 |                  |                 | time horizon     | or               |
38476 +------------------+-----------------+------------------+------------------+
38477 | tf               | OT_DOUBLE       | End of the time  | casadi::Integrat |
38478 |                  |                 | horizon          | or               |
38479 +------------------+-----------------+------------------+------------------+
38480 
38481 Diagrams
38482 --------
38483 
38484 
38485 
38486 C++ includes: integrator_impl.hpp ";
38487 
38488 %feature("docstring")  casadi::FunctionInternal::free_sx() const  "
38489 
38490 [INTERNAL]  Get free variables (SX)
38491 
38492 ";
38493 
38494 %feature("docstring")  casadi::FunctionInternal::symbolicAdjSeed(casadi_int
38495 nadj, const std::vector< MatType > &v) const  "
38496 
38497 [INTERNAL]  Symbolic expressions for the adjoint seeds.
38498 
38499 ";
38500 
38501 %feature("docstring")  casadi::FunctionInternal::get_jacobian_sparsity()
38502 const  "
38503 
38504 [INTERNAL]  Get Jacobian sparsity.
38505 
38506 ";
38507 
38508 %feature("docstring")  casadi::Integrator::setStopTime(IntegratorMemory
38509 *mem, double tf) const  "
38510 
38511 [INTERNAL]  Set stop time for the integration.
38512 
38513 ";
38514 
38515 %feature("docstring")  casadi::FunctionInternal::eval_mx(const MXVector
38516 &arg, MXVector &res, bool always_inline, bool never_inline) const  "
38517 
38518 [INTERNAL]  Evaluate with symbolic matrices.
38519 
38520 ";
38521 
38522 %feature("docstring")  casadi::FunctionInternal::all_scalar() const  "
38523 
38524 [INTERNAL]  Are all inputs and outputs scalar.
38525 
38526 ";
38527 
38528 %feature("docstring")  casadi::Integrator::has_spfwd() const  "
38529 
38530 [INTERNAL]  Is the class able to propagate seeds through the algorithm?
38531 
38532 ";
38533 
38534 %feature("docstring")  casadi::FunctionInternal::nz_in(const std::vector< DM
38535 > &arg) const  "
38536 
38537 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
38538 
38539 ";
38540 
38541 %feature("docstring")  casadi::FunctionInternal::nz_in(const std::vector<
38542 double > &arg) const  "
38543 
38544 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
38545 
38546 ";
38547 
38548 %feature("docstring")  casadi::FunctionInternal::slice(const std::string
38549 &name, const std::vector< casadi_int > &order_in, const std::vector<
38550 casadi_int > &order_out, const Dict &opts) const  "
38551 
38552 [INTERNAL]  returns a new function with a selection of inputs/outputs of the
38553 original
38554 
38555 ";
38556 
38557 %feature("docstring")  casadi::FunctionInternal::getAdaptorSolverName()
38558 const  "
38559 
38560 [INTERNAL]  Obtain solver name from Adaptor.
38561 
38562 ";
38563 
38564 %feature("docstring")  casadi::FunctionInternal::generate_options(bool
38565 is_temp=false) const  "
38566 
38567 [INTERNAL]  Reconstruct options dict.
38568 
38569 ";
38570 
38571 %feature("docstring")  casadi::OracleFunction::set_temp(void *mem, const
38572 double **arg, double **res, casadi_int *iw, double *w) const  "
38573 
38574 [INTERNAL]  Set the work vectors.
38575 
38576 ";
38577 
38578 %feature("docstring")  casadi::FunctionInternal::codegen_mem(CodeGenerator
38579 &g, const std::string &index="mem") const  "
38580 
38581 [INTERNAL]  Get thread-local memory object.
38582 
38583 ";
38584 
38585 %feature("docstring")
38586 casadi::FunctionInternal::instruction_output(casadi_int k) const  "
38587 
38588 [INTERNAL]  Get the (integer) output argument of an atomic operation.
38589 
38590 ";
38591 
38592 %feature("docstring")
38593 casadi::FunctionInternal::instruction_constant(casadi_int k) const  "
38594 
38595 [INTERNAL]  Get the floating point output argument of an atomic operation.
38596 
38597 ";
38598 
38599 %feature("docstring")  casadi::FunctionInternal::sparsity_in(casadi_int ind)
38600 const  "
38601 
38602 [INTERNAL]  Input/output sparsity.
38603 
38604 ";
38605 
38606 %feature("docstring")  casadi::FunctionInternal::size_out(casadi_int ind)
38607 const  "
38608 
38609 [INTERNAL]  Input/output dimensions.
38610 
38611 ";
38612 
38613 %feature("docstring")  casadi::Integrator::getDerivativeOptions(bool fwd)
38614 const  "
38615 
38616 [INTERNAL]  Set solver specific options to generated augmented integrators.
38617 
38618 ";
38619 
38620 %feature("docstring")  casadi::FunctionInternal::instruction_MX(casadi_int
38621 k) const  "
38622 
38623 [INTERNAL]  get MX expression associated with instruction
38624 
38625 ";
38626 
38627 %feature("docstring")  casadi::SharedObjectInternal::class_name() const  "
38628 
38629 [INTERNAL]  Readable name of the internal class.
38630 
38631 ";
38632 
38633 %feature("docstring")  casadi::FunctionInternal::nnz_out() const  "
38634 
38635 [INTERNAL]  Number of input/output nonzeros.
38636 
38637 ";
38638 
38639 %feature("docstring")  casadi::FunctionInternal::nnz_out(casadi_int ind)
38640 const  "
38641 
38642 [INTERNAL]  Number of input/output nonzeros.
38643 
38644 ";
38645 
38646 %feature("docstring")  casadi::SharedObjectInternal::getCount() const  "
38647 
38648 [INTERNAL]  Get the reference count.
38649 
38650 ";
38651 
38652 %feature("docstring")  casadi::FunctionInternal::alloc_arg(size_t sz_arg,
38653 bool persistent=false) "
38654 
38655 [INTERNAL]  Ensure required length of arg field.
38656 
38657 ";
38658 
38659 %feature("docstring")
38660 casadi::FunctionInternal::getJacSparsityHierarchicalSymm(casadi_int iind,
38661 casadi_int oind) const  "
38662 
38663 [INTERNAL]  A flavor of getJacSparsity that does hierarchical block
38664 structure recognition for symmetric Jacobians
38665 
38666 ";
38667 
38668 %feature("docstring")  casadi::Integrator::sp_jac_rdae() "
38669 
38670 [INTERNAL]  Create sparsity pattern of the extended Jacobian (backward
38671 problem)
38672 
38673 ";
38674 
38675 %feature("docstring")  casadi::FunctionInternal::numel_out(casadi_int ind)
38676 const  "
38677 
38678 [INTERNAL]  Number of input/output elements.
38679 
38680 ";
38681 
38682 %feature("docstring")  casadi::FunctionInternal::numel_out() const  "
38683 
38684 [INTERNAL]  Number of input/output elements.
38685 
38686 ";
38687 
38688 %feature("docstring")  casadi::FunctionInternal::get_max_in(casadi_int ind)
38689 const  "
38690 
38691 [INTERNAL]  Get largest input value.
38692 
38693 ";
38694 
38695 %feature("docstring")  casadi::FunctionInternal::codegen_meta(CodeGenerator
38696 &g) const  "
38697 
38698 [INTERNAL]  Generate meta-information allowing a user to evaluate a
38699 generated function.
38700 
38701 ";
38702 
38703 %feature("docstring")  casadi::FunctionInternal::convert_arg(const
38704 std::vector< M > &arg) const  "
38705 
38706 [INTERNAL]  Convert from/to input/output lists/map.
38707 
38708 ";
38709 
38710 %feature("docstring")  casadi::FunctionInternal::convert_arg(const std::map<
38711 std::string, M > &arg) const  "
38712 
38713 [INTERNAL]  Convert from/to input/output lists/map.
38714 
38715 ";
38716 
38717 %feature("docstring")  casadi::Integrator::get_n_out()  "
38718 
38719 [INTERNAL]  Number of function inputs and outputs.
38720 
38721 ";
38722 
38723 %feature("docstring")  casadi::Integrator::get_name_in(casadi_int i)  "
38724 
38725 [INTERNAL]  Names of function input and outputs.
38726 
38727 ";
38728 
38729 %feature("docstring")  casadi::FunctionInternal::has_jacobian() const  "
38730 
38731 [INTERNAL]  Return Jacobian of all input elements with respect to all output
38732 elements.
38733 
38734 ";
38735 
38736 %feature("docstring")  casadi::FunctionInternal::export_code(const
38737 std::string &lang, std::ostream &stream, const Dict &options) const  "
38738 
38739 [INTERNAL]  Export function in a specific language.
38740 
38741 ";
38742 
38743 %feature("docstring")  casadi::Integrator::get_n_in()  "
38744 
38745 [INTERNAL]  Number of function inputs and outputs.
38746 
38747 ";
38748 
38749 %feature("docstring")  casadi::FunctionInternal::check_mat(const Sparsity
38750 &arg, const Sparsity &inp, casadi_int &npar) "
38751 
38752 [INTERNAL]  Helper function
38753 
38754 Parameters:
38755 -----------
38756 
38757 npar[in]:  normal usage: 1, disallow pararallel calls: -1
38758 
38759 npar[out]:  required number of parallel calls (or -1)
38760 
38761 ";
38762 
38763 %feature("docstring")  casadi::FunctionInternal::forward(casadi_int nfwd)
38764 const  "
38765 
38766 [INTERNAL]  Return function that calculates forward derivatives
38767 forward(nfwd) returns a cached instance if available, and calls  Function
38768 get_forward(casadi_int nfwd) if no cached version is available.
38769 
38770 ";
38771 
38772 %feature("docstring")  casadi::FunctionInternal::sz_work(size_t &sz_arg,
38773 size_t &sz_res, size_t &sz_iw, size_t &sz_w) const  "
38774 
38775 [INTERNAL]  Get number of temporary variables needed.
38776 
38777 ";
38778 
38779 %feature("docstring")
38780 casadi::FunctionInternal::print_dimensions(std::ostream &stream) const  "
38781 
38782 [INTERNAL]  Print dimensions of inputs and outputs.
38783 
38784 ";
38785 
38786 %feature("docstring")  casadi::FunctionInternal::fwd_seed(casadi_int nfwd)
38787 const  "
38788 
38789 [INTERNAL]  Symbolic expressions for the forward seeds.
38790 
38791 ";
38792 
38793 %feature("docstring")  casadi::ProtoFunction::construct(const Dict &opts) "
38794 
38795 [INTERNAL]  Construct Prepares the function for evaluation.
38796 
38797 ";
38798 
38799 %feature("docstring")  casadi::FunctionInternal::dm_out(casadi_int ind)
38800 const  "
38801 
38802 [INTERNAL]  Get function input(s) and output(s)
38803 
38804 ";
38805 
38806 %feature("docstring")  casadi::FunctionInternal::dm_out() const  "
38807 
38808 [INTERNAL]  Get function input(s) and output(s)
38809 
38810 ";
38811 
38812 %feature("docstring")  casadi::ProtoFunction::memory(int ind) const  "
38813 
38814 [INTERNAL]  Memory objects.
38815 
38816 ";
38817 
38818 %feature("docstring")
38819 casadi::FunctionInternal::codegen_alloc_mem(CodeGenerator &g) const  "
38820 
38821 [INTERNAL]  Codegen decref for alloc_mem.
38822 
38823 ";
38824 
38825 %feature("docstring")  casadi::FunctionInternal::free_mx() const  "
38826 
38827 [INTERNAL]  Get free variables ( MX)
38828 
38829 ";
38830 
38831 %feature("docstring")  casadi::FunctionInternal::self() const  "
38832 
38833 [INTERNAL]  Get a public class instance.
38834 
38835 ";
38836 
38837 %feature("docstring")  casadi::FunctionInternal::jac() const  "
38838 
38839 [INTERNAL]  Return Jacobian of all input elements with respect to all output
38840 elements.
38841 
38842 ";
38843 
38844 %feature("docstring")  casadi::Integrator::algebraic_state_output(const MX
38845 &Z) const  "
38846 
38847 [INTERNAL] ";
38848 
38849 %feature("docstring")  casadi::Integrator::algebraic_state_init(const MX
38850 &x0, const MX &z0) const  "
38851 
38852 [INTERNAL] ";
38853 
38854 %feature("docstring")  casadi::FunctionInternal::replace_res(const
38855 std::vector< M > &res, casadi_int npar) const  "
38856 
38857 [INTERNAL]  Replace 0-by-0 outputs.
38858 
38859 ";
38860 
38861 %feature("docstring")  casadi::Integrator::aug_adj(casadi_int nadj) const  "
38862 
38863 [INTERNAL]  Generate a augmented DAE system with nadj adjoint sensitivities.
38864 
38865 ";
38866 
38867 %feature("docstring")  casadi::Integrator::create_advanced(const Dict &opts)
38868 "
38869 
38870 [INTERNAL]  Helper for a more powerful 'integrator' factory
38871 
38872 ";
38873 
38874 %feature("docstring")
38875 casadi::FunctionInternal::instruction_input(casadi_int k) const  "
38876 
38877 [INTERNAL]  Get the (integer) input arguments of an atomic operation.
38878 
38879 ";
38880 
38881 %feature("docstring")  casadi::FunctionInternal::replace_fseed(const
38882 std::vector< std::vector< M >> &fseed, casadi_int npar) const  "
38883 
38884 [INTERNAL]  Replace 0-by-0 forward seeds.
38885 
38886 ";
38887 
38888 %feature("docstring")  casadi::FunctionInternal::replace_fseed(const
38889 std::vector< std::vector< M > > &fseed, casadi_int npar) const  "
38890 
38891 [INTERNAL] ";
38892 
38893 %feature("docstring")  casadi::FunctionInternal::generate_lifted(Function
38894 &vdef_fcn, Function &vinit_fcn) const  "
38895 
38896 [INTERNAL]  Extract the functions needed for the Lifted Newton method.
38897 
38898 ";
38899 
38900 %feature("docstring")  casadi::OracleFunction::alloc_mem() const  "
38901 
38902 [INTERNAL]  Create memory block.
38903 
38904 ";
38905 
38906 %feature("docstring")  casadi::FunctionInternal::has_codegen() const  "
38907 
38908 [INTERNAL]  Is codegen supported?
38909 
38910 ";
38911 
38912 %feature("docstring")  casadi::FunctionInternal::get_partition(casadi_int
38913 iind, casadi_int oind, Sparsity &D1, Sparsity &D2, bool compact, bool
38914 symmetric, bool allow_forward, bool allow_reverse) const  "
38915 
38916 [INTERNAL]  Get the unidirectional or bidirectional partition.
38917 
38918 ";
38919 
38920 %feature("docstring")  casadi::Integrator::get_sparsity_out(casadi_int i)  "
38921 
38922 [INTERNAL]  Sparsities of function inputs and outputs.
38923 
38924 ";
38925 
38926 %feature("docstring")  casadi::FunctionInternal::disp(std::ostream &stream,
38927 bool more) const  "
38928 
38929 [INTERNAL]  Display object.
38930 
38931 ";
38932 
38933 %feature("docstring") casadi::Integrator::~Integrator "
38934 
38935 [INTERNAL]  Destructor.
38936 
38937 ";
38938 
38939 %feature("docstring")  casadi::FunctionInternal::print_option(const
38940 std::string &name, std::ostream &stream) const  "
38941 
38942 [INTERNAL]  Print all information there is to know about a certain option.
38943 
38944 ";
38945 
38946 %feature("docstring")  casadi::FunctionInternal::print_options(std::ostream
38947 &stream) const  "
38948 
38949 [INTERNAL]  Print list of options.
38950 
38951 ";
38952 
38953 %feature("docstring")  casadi::FunctionInternal::mx_in(casadi_int ind) const
38954 "
38955 
38956 [INTERNAL]  Get function input(s) and output(s)
38957 
38958 ";
38959 
38960 %feature("docstring")  casadi::FunctionInternal::mx_in() const  "
38961 
38962 [INTERNAL]  Get function input(s) and output(s)
38963 
38964 ";
38965 
38966 %feature("docstring")  casadi::Integrator::print_stats(IntegratorMemory
38967 *mem) const  "
38968 
38969 [INTERNAL]  Print solver statistics.
38970 
38971 ";
38972 
38973 %feature("docstring")  casadi::FunctionInternal::has_jac() const  "
38974 
38975 [INTERNAL]  Return Jacobian of all input elements with respect to all output
38976 elements.
38977 
38978 ";
38979 
38980 %feature("docstring")  casadi::ProtoFunction::clear_mem() "
38981 
38982 [INTERNAL]  Clear all memory (called from destructor)
38983 
38984 ";
38985 
38986 %feature("docstring")  casadi::FunctionInternal::n_nodes() const  "
38987 
38988 [INTERNAL]  Number of nodes in the algorithm.
38989 
38990 ";
38991 
38992 %feature("docstring")  casadi::FunctionInternal::nnz_in() const  "
38993 
38994 [INTERNAL]  Number of input/output nonzeros.
38995 
38996 ";
38997 
38998 %feature("docstring")  casadi::FunctionInternal::nnz_in(casadi_int ind)
38999 const  "
39000 
39001 [INTERNAL]  Number of input/output nonzeros.
39002 
39003 ";
39004 
39005 %feature("docstring")  casadi::FunctionInternal::size2_out(casadi_int ind)
39006 const  "
39007 
39008 [INTERNAL]  Input/output dimensions.
39009 
39010 ";
39011 
39012 %feature("docstring")  casadi::PluginInterface< Integrator  >::plugin_name()
39013 const  "
39014 
39015 [INTERNAL] ";
39016 
39017 %feature("docstring")  casadi::Integrator::get_sparsity_in(casadi_int i)  "
39018 
39019 [INTERNAL]  Sparsities of function inputs and outputs.
39020 
39021 ";
39022 
39023 %feature("docstring")  casadi::OracleFunction::oracle() const  "
39024 
39025 [INTERNAL]  Get oracle.
39026 
39027 ";
39028 
39029 %feature("docstring")  casadi::Integrator::has_forward(casadi_int nfwd)
39030 const  "
39031 
39032 [INTERNAL]  Generate a function that calculates nfwd forward derivatives.
39033 
39034 ";
39035 
39036 %feature("docstring")  casadi::FunctionInternal::wrap_as_needed(const Dict
39037 &opts) const  "
39038 
39039 [INTERNAL]  Wrap in an Function instance consisting of only one MX call.
39040 
39041 ";
39042 
39043 %feature("docstring")  casadi::FunctionInternal::codegen_mem_type() const  "
39044 
39045 [INTERNAL]  Thread-local memory object type.
39046 
39047 ";
39048 
39049 %feature("docstring")  casadi::FunctionInternal::call_gen(const MXVector
39050 &arg, MXVector &res, casadi_int npar, bool always_inline, bool never_inline)
39051 const  "
39052 
39053 [INTERNAL]   Call a function, overloaded.
39054 
39055 ";
39056 
39057 %feature("docstring")  casadi::FunctionInternal::call_gen(const std::vector<
39058 MatrixCommon > &arg, std::vector< MatrixCommon > &res, casadi_int npar, bool
39059 always_inline, bool never_inline) const  "
39060 
39061 [INTERNAL]   Call a function, overloaded.
39062 
39063 ";
39064 
39065 %feature("docstring")  casadi::FunctionInternal::sparsity_out(casadi_int
39066 ind) const  "
39067 
39068 [INTERNAL]  Input/output sparsity.
39069 
39070 ";
39071 
39072 %feature("docstring")  casadi::FunctionInternal::incache(const std::string
39073 &fname, Function &f, const std::string &suffix="") const  "
39074 
39075 [INTERNAL]  Get function in cache.
39076 
39077 ";
39078 
39079 %feature("docstring")  casadi::ProtoFunction::serialize(SerializingStream
39080 &s) const  "
39081 
39082 [INTERNAL]  Serialize an object.
39083 
39084 ";
39085 
39086 %feature("docstring")  casadi::FunctionInternal::info() const  "
39087 
39088 [INTERNAL]  Obtain information about function
39089 
39090 ";
39091 
39092 %feature("docstring")  casadi::FunctionInternal::check_res(const
39093 std::vector< M > &res, casadi_int &npar) const  "
39094 
39095 [INTERNAL]  Check if output arguments have correct length and dimensions.
39096 
39097 Raises errors.
39098 
39099 Parameters:
39100 -----------
39101 
39102 npar[in]:  normal usage: 1, disallow pararallel calls: -1
39103 
39104 npar:  max number of horizontal repetitions across all arguments (or -1)
39105 
39106 ";
39107 
39108 %feature("docstring")  casadi::OracleFunction::finalize()  "
39109 
39110 [INTERNAL]  Finalize initialization.
39111 
39112 ";
39113 
39114 %feature("docstring")  casadi::FunctionInternal::size2_in(casadi_int ind)
39115 const  "
39116 
39117 [INTERNAL]  Input/output dimensions.
39118 
39119 ";
39120 
39121 %feature("docstring")  casadi::FunctionInternal::eval_gen(const double
39122 **arg, double **res, casadi_int *iw, double *w, void *mem) const  "
39123 
39124 [INTERNAL]  Evaluate numerically.
39125 
39126 ";
39127 
39128 %feature("docstring")  casadi::FunctionInternal::eval_gen(const SXElem
39129 **arg, SXElem **res, casadi_int *iw, SXElem *w, void *mem) const  "
39130 
39131 [INTERNAL]  Evaluate a function, overloaded.
39132 
39133 ";
39134 
39135 %feature("docstring")  casadi::FunctionInternal::eval_gen(const bvec_t
39136 **arg, bvec_t **res, casadi_int *iw, bvec_t *w, void *mem) const  "
39137 
39138 [INTERNAL]  Evaluate a function, overloaded.
39139 
39140 ";
39141 
39142 %feature("docstring")  casadi::Integrator::serialize_base_function() const
39143 "
39144 
39145 [INTERNAL]  String used to identify the immediate FunctionInternal subclass.
39146 
39147 ";
39148 
39149 %feature("docstring")  casadi::FunctionInternal::index_in(const std::string
39150 &name) const  "
39151 
39152 [INTERNAL]  Get input scheme index by name.
39153 
39154 ";
39155 
39156 %feature("docstring")  casadi::FunctionInternal::sx_in(casadi_int ind) const
39157 "
39158 
39159 [INTERNAL]  Get function input(s) and output(s)
39160 
39161 ";
39162 
39163 %feature("docstring")  casadi::FunctionInternal::sx_in() const  "
39164 
39165 [INTERNAL]  Get function input(s) and output(s)
39166 
39167 ";
39168 
39169 %feature("docstring")  casadi::OracleFunction::free_mem(void *mem) const  "
39170 
39171 [INTERNAL]  Free memory block.
39172 
39173 ";
39174 
39175 %feature("docstring")  casadi::FunctionInternal::definition() const  "
39176 
39177 [INTERNAL]  Get function signature: name:(inputs)->(outputs)
39178 
39179 ";
39180 
39181 %feature("docstring")  casadi::FunctionInternal::ad_weight() const  "
39182 
39183 [INTERNAL]  Weighting factor for chosing forward/reverse mode.
39184 
39185 ";
39186 
39187 %feature("docstring")  casadi::FunctionInternal::uses_output() const  "
39188 
39189 [INTERNAL]  Do the derivative functions need nondifferentiated outputs?
39190 
39191 ";
39192 
39193 %feature("docstring")  casadi::Integrator::get_options() const  "
39194 
39195 [INTERNAL]  Options.
39196 
39197 ";
39198 
39199 %feature("docstring")  casadi::FunctionInternal::get_reltol() const  "
39200 
39201 [INTERNAL]  Get relative tolerance.
39202 
39203 ";
39204 
39205 %feature("docstring")  casadi::FunctionInternal::generate_out(const
39206 std::string &fname, double **res) const  "
39207 
39208 [INTERNAL] ";
39209 
39210 %feature("docstring")  casadi::FunctionInternal::alloc(const Function &f,
39211 bool persistent=false) "
39212 
39213 [INTERNAL]  Ensure work vectors long enough to evaluate function.
39214 
39215 ";
39216 
39217 %feature("docstring")  casadi::FunctionInternal::index_out(const std::string
39218 &name) const  "
39219 
39220 [INTERNAL]  Get output scheme index by name.
39221 
39222 ";
39223 
39224 %feature("docstring")  casadi::FunctionInternal::sp_weight() const  "
39225 
39226 [INTERNAL]  Weighting factor for chosing forward/reverse mode, sparsity
39227 propagation.
39228 
39229 ";
39230 
39231 %feature("docstring")  casadi::FunctionInternal::alloc_w(size_t sz_w, bool
39232 persistent=false) "
39233 
39234 [INTERNAL]  Ensure required length of w field.
39235 
39236 ";
39237 
39238 %feature("docstring")  casadi::OracleFunction::get_function() const  "
39239 
39240 [INTERNAL]  Get list of dependency functions -1 Indicates irregularity.
39241 
39242 ";
39243 
39244 %feature("docstring")  casadi::OracleFunction::get_function(const
39245 std::string &name) const  "
39246 
39247 [INTERNAL] ";
39248 
39249 %feature("docstring")  casadi::FunctionInternal::alloc_res(size_t sz_res,
39250 bool persistent=false) "
39251 
39252 [INTERNAL]  Ensure required length of res field.
39253 
39254 ";
39255 
39256 %feature("docstring")  casadi::FunctionInternal::numel_in() const  "
39257 
39258 [INTERNAL]  Number of input/output elements.
39259 
39260 ";
39261 
39262 %feature("docstring")  casadi::FunctionInternal::numel_in(casadi_int ind)
39263 const  "
39264 
39265 [INTERNAL]  Number of input/output elements.
39266 
39267 ";
39268 
39269 %feature("docstring")  casadi::FunctionInternal::mx_out(casadi_int ind)
39270 const  "
39271 
39272 [INTERNAL]  Get function input(s) and output(s)
39273 
39274 ";
39275 
39276 %feature("docstring")  casadi::FunctionInternal::mx_out() const  "
39277 
39278 [INTERNAL]  Get function input(s) and output(s)
39279 
39280 ";
39281 
39282 %feature("docstring")  casadi::ProtoFunction::release(int mem) const  "
39283 
39284 [INTERNAL]  Release a memory object.
39285 
39286 ";
39287 
39288 %feature("docstring")  casadi::Integrator::get_forward(casadi_int nfwd,
39289 const std::string &name, const std::vector< std::string > &inames, const
39290 std::vector< std::string > &onames, const Dict &opts) const  "
39291 
39292 [INTERNAL]  Generate a function that calculates nfwd forward derivatives.
39293 
39294 ";
39295 
39296 %feature("docstring")  casadi::FunctionInternal::fwdViaJac(casadi_int nfwd)
39297 const  "
39298 
39299 [INTERNAL]  Calculate derivatives by multiplying the full Jacobian and
39300 multiplying.
39301 
39302 ";
39303 
39304 %feature("docstring")  casadi::FunctionInternal::map(casadi_int n, const
39305 std::string &parallelization) const  "
39306 
39307 [INTERNAL]  Generate/retrieve cached serial map.
39308 
39309 ";
39310 
39311 %feature("docstring")  casadi::FunctionInternal::which_depends(const
39312 std::string &s_in, const std::vector< std::string > &s_out, casadi_int
39313 order, bool tr=false) const  "
39314 
39315 [INTERNAL]  Which variables enter with some order.
39316 
39317 Parameters:
39318 -----------
39319 
39320 s_in:   Input name
39321 
39322 s_out:   Output name(s)
39323 
39324 order:  Only 1 (linear) and 2 (nonlinear) allowed
39325 
39326 tr:  Flip the relationship. Return which expressions contain the variables
39327 
39328 ";
39329 
39330 %feature("docstring")  casadi::Integrator::get_name_out(casadi_int i)  "
39331 
39332 [INTERNAL]  Names of function input and outputs.
39333 
39334 ";
39335 
39336 %feature("docstring")  casadi::Integrator::reset(IntegratorMemory *mem,
39337 double t, const double *x, const double *z, const double *p) const  "
39338 
39339 [INTERNAL]  Reset the forward problem.
39340 
39341 ";
39342 
39343 %feature("docstring")  casadi::OracleFunction::expand() "
39344 
39345 [INTERNAL] ";
39346 
39347 %feature("docstring")
39348 casadi::FunctionInternal::codegen_init_mem(CodeGenerator &g) const  "
39349 
39350 [INTERNAL]  Codegen decref for init_mem.
39351 
39352 ";
39353 
39354 %feature("docstring")  casadi::Integrator::get_reverse(casadi_int nadj,
39355 const std::string &name, const std::vector< std::string > &inames, const
39356 std::vector< std::string > &onames, const Dict &opts) const  "
39357 
39358 [INTERNAL]  Generate a function that calculates nadj adjoint derivatives.
39359 
39360 ";
39361 
39362 %feature("docstring")  casadi::FunctionInternal::disp_more(std::ostream
39363 &stream) const  "
39364 
39365 [INTERNAL]  Print more.
39366 
39367 ";
39368 
39369 %feature("docstring")  casadi::FunctionInternal::sz_res() const  "
39370 
39371 [INTERNAL]  Get required length of res field.
39372 
39373 ";
39374 
39375 %feature("docstring")  casadi::ProtoFunction::checkout() const  "
39376 
39377 [INTERNAL]  Checkout a memory object.
39378 
39379 ";
39380 
39381 %feature("docstring")  casadi::FunctionInternal::call_forward(const
39382 std::vector< MX > &arg, const std::vector< MX > &res, const std::vector<
39383 std::vector< MX > > &fseed, std::vector< std::vector< MX > > &fsens, bool
39384 always_inline, bool never_inline) const  "
39385 
39386 [INTERNAL]  Forward mode AD, virtual functions overloaded in derived
39387 classes.
39388 
39389 ";
39390 
39391 %feature("docstring")  casadi::FunctionInternal::call_forward(const
39392 std::vector< SX > &arg, const std::vector< SX > &res, const std::vector<
39393 std::vector< SX > > &fseed, std::vector< std::vector< SX > > &fsens, bool
39394 always_inline, bool never_inline) const  "
39395 
39396 [INTERNAL]  Forward mode AD, virtual functions overloaded in derived
39397 classes.
39398 
39399 ";
39400 
39401 %feature("docstring")
39402 casadi::FunctionInternal::getJacSparsityHierarchical(casadi_int iind,
39403 casadi_int oind) const  "
39404 
39405 [INTERNAL]  A flavor of getJacSparsity that does hierarchical block
39406 structure recognition.
39407 
39408 ";
39409 
39410 %feature("docstring")  casadi::Integrator::rp() const  "
39411 
39412 [INTERNAL] ";
39413 
39414 %feature("docstring")  casadi::Integrator::rq() const  "
39415 
39416 [INTERNAL] ";
39417 
39418 %feature("docstring")
39419 casadi::FunctionInternal::codegen_decref(CodeGenerator &g) const  "
39420 
39421 [INTERNAL]  Codegen decref for dependencies.
39422 
39423 ";
39424 
39425 %feature("docstring")  casadi::FunctionInternal::size1_out(casadi_int ind)
39426 const  "
39427 
39428 [INTERNAL]  Input/output dimensions.
39429 
39430 ";
39431 
39432 %feature("docstring")  casadi::FunctionInternal::signature(const std::string
39433 &fname) const  "
39434 
39435 [INTERNAL]  Code generate the function.
39436 
39437 ";
39438 
39439 %feature("docstring")  casadi::Integrator::rz() const  "
39440 
39441 [INTERNAL] ";
39442 
39443 %feature("docstring")  casadi::FunctionInternal::has_derivative() const  "
39444 
39445 [INTERNAL]  Can derivatives be calculated in any way?
39446 
39447 ";
39448 
39449 %feature("docstring")  casadi::Integrator::rx() const  "
39450 
39451 [INTERNAL] ";
39452 
39453 %feature("docstring")  casadi::OracleFunction::get_stats(void *mem) const  "
39454 
39455 [INTERNAL]  Get all statistics.
39456 
39457 ";
39458 
39459 %feature("docstring")  casadi::FunctionInternal::get_min_in(casadi_int ind)
39460 const  "
39461 
39462 [INTERNAL]  Get smallest input value.
39463 
39464 ";
39465 
39466 %feature("docstring")  casadi::Integrator::init(const Dict &opts)  "
39467 
39468 [INTERNAL]  Initialize.
39469 
39470 ";
39471 
39472 %feature("docstring")  casadi::FunctionInternal::replace_arg(const
39473 std::vector< M > &arg, casadi_int npar) const  "
39474 
39475 [INTERNAL]  Replace 0-by-0 inputs.
39476 
39477 ";
39478 
39479 %feature("docstring")
39480 casadi::FunctionInternal::jacobian_sparsity_filter(const Sparsity &sp) const
39481 "
39482 
39483 [INTERNAL]  Filter out nonzeros in the full sparsity jacobian according to
39484 is_diff_in/out.
39485 
39486 ";
39487 
39488 %feature("docstring")  casadi::Integrator::sp_forward(const bvec_t **arg,
39489 bvec_t **res, casadi_int *iw, bvec_t *w, void *mem) const  "
39490 
39491 [INTERNAL]  Propagate sparsity forward.
39492 
39493 ";
39494 
39495 
39496 // File: classcasadi_1_1Interpolant.xml
39497 %feature("docstring")  casadi::FunctionInternal::oracle() const  "
39498 
39499 [INTERNAL]  Get oracle.
39500 
39501 ";
39502 
39503 %feature("docstring")  casadi::FunctionInternal::convert_res(const
39504 std::vector< M > &res) const  "
39505 
39506 [INTERNAL]  Convert from/to input/output lists/map.
39507 
39508 ";
39509 
39510 %feature("docstring")  casadi::FunctionInternal::convert_res(const std::map<
39511 std::string, M > &res) const  "
39512 
39513 [INTERNAL]  Convert from/to input/output lists/map.
39514 
39515 ";
39516 
39517 %feature("docstring")  casadi::FunctionInternal::check_mat(const Sparsity
39518 &arg, const Sparsity &inp, casadi_int &npar) "
39519 
39520 [INTERNAL]  Helper function
39521 
39522 Parameters:
39523 -----------
39524 
39525 npar[in]:  normal usage: 1, disallow pararallel calls: -1
39526 
39527 npar[out]:  required number of parallel calls (or -1)
39528 
39529 ";
39530 
39531 %feature("docstring")  casadi::FunctionInternal::size1_out(casadi_int ind)
39532 const  "
39533 
39534 [INTERNAL]  Input/output dimensions.
39535 
39536 ";
39537 
39538 %feature("docstring")  casadi::FunctionInternal::get_reltol() const  "
39539 
39540 [INTERNAL]  Get relative tolerance.
39541 
39542 ";
39543 
39544 %feature("docstring")  casadi::FunctionInternal::jacobian_sparsity() const
39545 "
39546 
39547 [INTERNAL]  Get Jacobian sparsity.
39548 
39549 ";
39550 
39551 %feature("docstring")  casadi::FunctionInternal::project_res(const
39552 std::vector< M > &arg, casadi_int npar) const  "
39553 
39554 [INTERNAL]   Project sparsities.
39555 
39556 ";
39557 
39558 %feature("docstring")  casadi::FunctionInternal::get_jacobian(const
39559 std::string &name, const std::vector< std::string > &inames, const
39560 std::vector< std::string > &onames, const Dict &opts) const  "
39561 
39562 [INTERNAL]  Return Jacobian of all input elements with respect to all output
39563 elements.
39564 
39565 ";
39566 
39567 %feature("docstring")  casadi::FunctionInternal::tocache(const Function &f,
39568 const std::string &suffix="") const  "
39569 
39570 [INTERNAL]  Save function to cache.
39571 
39572 ";
39573 
39574 %feature("docstring")  casadi::FunctionInternal::generate_in(const
39575 std::string &fname, const double **arg) const  "
39576 
39577 [INTERNAL]  Export an input file that can be passed to generate C code with
39578 a main.
39579 
39580 ";
39581 
39582 %feature("docstring")  casadi::Interpolant::serialize_type(SerializingStream
39583 &s) const  "
39584 
39585 [INTERNAL]  Serialize type information.
39586 
39587 ";
39588 
39589 %feature("docstring")  casadi::FunctionInternal::has_jac() const  "
39590 
39591 [INTERNAL]  Return Jacobian of all input elements with respect to all output
39592 elements.
39593 
39594 ";
39595 
39596 %feature("docstring")  casadi::FunctionInternal::get_function() const  "
39597 
39598 [INTERNAL] ";
39599 
39600 %feature("docstring")  casadi::FunctionInternal::get_function(const
39601 std::string &name) const  "
39602 
39603 [INTERNAL] ";
39604 
39605 %feature("docstring")  casadi::FunctionInternal::matching_arg(const
39606 std::vector< M > &arg, casadi_int &npar) const  "
39607 
39608 [INTERNAL]  Check if input arguments that needs to be replaced.
39609 
39610 Raises errors
39611 
39612 Parameters:
39613 -----------
39614 
39615 npar[in]:  normal usage: 1, disallow pararallel calls: -1
39616 
39617 npar:  max number of horizontal repetitions across all arguments (or -1)
39618 
39619 ";
39620 
39621 %feature("docstring")  casadi::FunctionInternal::mx_in(casadi_int ind) const
39622 "
39623 
39624 [INTERNAL]  Get function input(s) and output(s)
39625 
39626 ";
39627 
39628 %feature("docstring")  casadi::FunctionInternal::mx_in() const  "
39629 
39630 [INTERNAL]  Get function input(s) and output(s)
39631 
39632 ";
39633 
39634 %feature("docstring")
39635 casadi::FunctionInternal::instruction_input(casadi_int k) const  "
39636 
39637 [INTERNAL]  Get the (integer) input arguments of an atomic operation.
39638 
39639 ";
39640 
39641 %feature("docstring")  casadi::ProtoFunction::clear_mem() "
39642 
39643 [INTERNAL]  Clear all memory (called from destructor)
39644 
39645 ";
39646 
39647 %feature("docstring")  casadi::Interpolant::get_sparsity_in(casadi_int i)  "
39648 
39649 [INTERNAL]  Sparsities of function inputs and outputs.
39650 
39651 ";
39652 
39653 %feature("docstring")  casadi::FunctionInternal::call_forward(const
39654 std::vector< MX > &arg, const std::vector< MX > &res, const std::vector<
39655 std::vector< MX > > &fseed, std::vector< std::vector< MX > > &fsens, bool
39656 always_inline, bool never_inline) const  "
39657 
39658 [INTERNAL]  Forward mode AD, virtual functions overloaded in derived
39659 classes.
39660 
39661 ";
39662 
39663 %feature("docstring")  casadi::FunctionInternal::call_forward(const
39664 std::vector< SX > &arg, const std::vector< SX > &res, const std::vector<
39665 std::vector< SX > > &fseed, std::vector< std::vector< SX > > &fsens, bool
39666 always_inline, bool never_inline) const  "
39667 
39668 [INTERNAL]  Forward mode AD, virtual functions overloaded in derived
39669 classes.
39670 
39671 ";
39672 
39673 %feature("docstring")  casadi::FunctionInternal::codegen_meta(CodeGenerator
39674 &g) const  "
39675 
39676 [INTERNAL]  Generate meta-information allowing a user to evaluate a
39677 generated function.
39678 
39679 ";
39680 
39681 %feature("docstring")  casadi::ProtoFunction::alloc_mem() const  "
39682 
39683 [INTERNAL]  Create memory block.
39684 
39685 ";
39686 
39687 %feature("docstring")  casadi::FunctionInternal::disp_more(std::ostream
39688 &stream) const  "
39689 
39690 [INTERNAL]  Print more.
39691 
39692 ";
39693 
39694 %feature("docstring")  casadi::Interpolant::get_options() const  "
39695 
39696 [INTERNAL]  Options.
39697 
39698 ";
39699 
39700 %feature("docstring")  casadi::ProtoFunction::format_time(char *buffer,
39701 double time) const  "
39702 
39703 [INTERNAL]  Format time in a fixed width 8 format.
39704 
39705 ";
39706 
39707 %feature("docstring")  casadi::FunctionInternal::is_diff_out(casadi_int i) "
39708 
39709 [INTERNAL] ";
39710 
39711 %feature("docstring")  casadi::FunctionInternal::replace_fseed(const
39712 std::vector< std::vector< M >> &fseed, casadi_int npar) const  "
39713 
39714 [INTERNAL]  Replace 0-by-0 forward seeds.
39715 
39716 ";
39717 
39718 %feature("docstring")  casadi::FunctionInternal::replace_fseed(const
39719 std::vector< std::vector< M > > &fseed, casadi_int npar) const  "
39720 
39721 [INTERNAL] ";
39722 
39723 %feature("docstring")  casadi::FunctionInternal::sx_out(casadi_int ind)
39724 const  "
39725 
39726 [INTERNAL]  Get function input(s) and output(s)
39727 
39728 ";
39729 
39730 %feature("docstring")  casadi::FunctionInternal::sx_out() const  "
39731 
39732 [INTERNAL]  Get function input(s) and output(s)
39733 
39734 ";
39735 
39736 %feature("docstring")  casadi::FunctionInternal::wrap() const  "
39737 
39738 [INTERNAL]  Wrap in an Function instance consisting of only one MX call.
39739 
39740 ";
39741 
39742 %feature("docstring")  casadi::FunctionInternal::get_default_in(casadi_int
39743 ind) const  "
39744 
39745 [INTERNAL]  Get default input value.
39746 
39747 ";
39748 
39749 %feature("docstring")  casadi::FunctionInternal::alloc(const Function &f,
39750 bool persistent=false) "
39751 
39752 [INTERNAL]  Ensure work vectors long enough to evaluate function.
39753 
39754 ";
39755 
39756 %feature("docstring")  casadi::FunctionInternal::has_spfwd() const  "
39757 
39758 [INTERNAL]  Is the class able to propagate seeds through the algorithm?
39759 
39760 ";
39761 
39762 %feature("docstring")
39763 casadi::FunctionInternal::codegen_declarations(CodeGenerator &g) const  "
39764 
39765 [INTERNAL]  Generate code for the declarations of the C function.
39766 
39767 ";
39768 
39769 %feature("docstring")  casadi::FunctionInternal::symbolic_output(const
39770 std::vector< MX > &arg) const  "
39771 
39772 [INTERNAL]  Get a vector of symbolic variables corresponding to the outputs.
39773 
39774 ";
39775 
39776 %feature("docstring")  casadi::FunctionInternal::codegen_mem_type() const  "
39777 
39778 [INTERNAL]  Thread-local memory object type.
39779 
39780 ";
39781 
39782 %feature("docstring")  casadi::FunctionInternal::instructions_sx() const  "
39783 
39784 [INTERNAL]  get SX expression associated with instructions
39785 
39786 ";
39787 
39788 %feature("docstring")
39789 casadi::FunctionInternal::codegen_sparsities(CodeGenerator &g) const  "
39790 
39791 [INTERNAL]  Codegen sparsities.
39792 
39793 ";
39794 
39795 %feature("docstring")  casadi::FunctionInternal::get_min_in(casadi_int ind)
39796 const  "
39797 
39798 [INTERNAL]  Get smallest input value.
39799 
39800 ";
39801 
39802 %feature("docstring")  casadi::FunctionInternal::instruction_MX(casadi_int
39803 k) const  "
39804 
39805 [INTERNAL]  get MX expression associated with instruction
39806 
39807 ";
39808 
39809 %feature("docstring")  casadi::FunctionInternal::set_temp(void *mem, const
39810 double **arg, double **res, casadi_int *iw, double *w) const  "
39811 
39812 [INTERNAL]  Set the (temporary) work vectors.
39813 
39814 ";
39815 
39816 %feature("docstring")  casadi::FunctionInternal::has_jacobian() const  "
39817 
39818 [INTERNAL]  Return Jacobian of all input elements with respect to all output
39819 elements.
39820 
39821 ";
39822 
39823 %feature("docstring")  casadi::FunctionInternal::n_nodes() const  "
39824 
39825 [INTERNAL]  Number of nodes in the algorithm.
39826 
39827 ";
39828 
39829 %feature("docstring")  casadi::FunctionInternal::finalize()  "
39830 
39831 [INTERNAL]  Finalize the object creation.
39832 
39833 ";
39834 
39835 %feature("docstring")  casadi::FunctionInternal::get_reverse(casadi_int
39836 nadj, const std::string &name, const std::vector< std::string > &inames,
39837 const std::vector< std::string > &onames, const Dict &opts) const  "
39838 
39839 [INTERNAL]  Return function that calculates adjoint derivatives
39840 reverse(nadj) returns a cached instance if available, and calls  Function
39841 get_reverse(casadi_int nadj) if no cached version is available.
39842 
39843 ";
39844 
39845 %feature("docstring")  casadi::FunctionInternal::replace_arg(const
39846 std::vector< M > &arg, casadi_int npar) const  "
39847 
39848 [INTERNAL]  Replace 0-by-0 inputs.
39849 
39850 ";
39851 
39852 %feature("docstring")  casadi::FunctionInternal::size1_in(casadi_int ind)
39853 const  "
39854 
39855 [INTERNAL]  Input/output dimensions.
39856 
39857 ";
39858 
39859 %feature("docstring")  casadi::Interpolant::get_sparsity_out(casadi_int i)
39860 "
39861 
39862 [INTERNAL]  Sparsities of function inputs and outputs.
39863 
39864 ";
39865 
39866 %feature("docstring")  casadi::Interpolant::coeff_size() const  "
39867 
39868 [INTERNAL]  Size of the flattened coefficients vector.
39869 
39870 ";
39871 
39872 %feature("docstring")  casadi::FunctionInternal::has_codegen() const  "
39873 
39874 [INTERNAL]  Is codegen supported?
39875 
39876 ";
39877 
39878 %feature("docstring")  casadi::FunctionInternal::all_scalar() const  "
39879 
39880 [INTERNAL]  Are all inputs and outputs scalar.
39881 
39882 ";
39883 
39884 %feature("docstring")  casadi::FunctionInternal::alloc_arg(size_t sz_arg,
39885 bool persistent=false) "
39886 
39887 [INTERNAL]  Ensure required length of arg field.
39888 
39889 ";
39890 
39891 %feature("docstring")  casadi::FunctionInternal::getJacSparsity(casadi_int
39892 iind, casadi_int oind, bool symmetric) const  "
39893 
39894 [INTERNAL]  Generate the sparsity of a Jacobian block.
39895 
39896 ";
39897 
39898 %feature("docstring")  casadi::ProtoFunction::memory(int ind) const  "
39899 
39900 [INTERNAL]  Memory objects.
39901 
39902 ";
39903 
39904 %feature("docstring")  casadi::FunctionInternal::reverse(casadi_int nadj)
39905 const  "
39906 
39907 [INTERNAL]  Return function that calculates adjoint derivatives
39908 reverse(nadj) returns a cached instance if available, and calls  Function
39909 get_reverse(casadi_int nadj) if no cached version is available.
39910 
39911 ";
39912 
39913 %feature("docstring")  casadi::FunctionInternal::get_jacobian_sparsity()
39914 const  "
39915 
39916 [INTERNAL]  Get Jacobian sparsity.
39917 
39918 ";
39919 
39920 %feature("docstring")  casadi::FunctionInternal::alloc_res(size_t sz_res,
39921 bool persistent=false) "
39922 
39923 [INTERNAL]  Ensure required length of res field.
39924 
39925 ";
39926 
39927 %feature("docstring")  casadi::FunctionInternal::sparsity_out(casadi_int
39928 ind) const  "
39929 
39930 [INTERNAL]  Input/output sparsity.
39931 
39932 ";
39933 
39934 %feature("docstring")
39935 casadi::FunctionInternal::getJacSparsityHierarchical(casadi_int iind,
39936 casadi_int oind) const  "
39937 
39938 [INTERNAL]  A flavor of getJacSparsity that does hierarchical block
39939 structure recognition.
39940 
39941 ";
39942 
39943 %feature("docstring")  casadi::SharedObjectInternal::weak() "
39944 
39945 [INTERNAL]  Get a weak reference to the object.
39946 
39947 ";
39948 
39949 %feature("docstring")  casadi::FunctionInternal::has_derivative() const  "
39950 
39951 [INTERNAL]  Can derivatives be calculated in any way?
39952 
39953 ";
39954 
39955 %feature("docstring")  casadi::FunctionInternal::get_forward(casadi_int
39956 nfwd, const std::string &name, const std::vector< std::string > &inames,
39957 const std::vector< std::string > &onames, const Dict &opts) const  "
39958 
39959 [INTERNAL]  Return function that calculates forward derivatives
39960 forward(nfwd) returns a cached instance if available, and calls  Function
39961 get_forward(casadi_int nfwd) if no cached version is available.
39962 
39963 ";
39964 
39965 %feature("docstring")  casadi::FunctionInternal::nnz_in() const  "
39966 
39967 [INTERNAL]  Number of input/output nonzeros.
39968 
39969 ";
39970 
39971 %feature("docstring")  casadi::FunctionInternal::nnz_in(casadi_int ind)
39972 const  "
39973 
39974 [INTERNAL]  Number of input/output nonzeros.
39975 
39976 ";
39977 
39978 %feature("docstring")  casadi::Interpolant::serialize_body(SerializingStream
39979 &s) const  "
39980 
39981 [INTERNAL]  Serialize an object without type information.
39982 
39983 ";
39984 
39985 %feature("docstring")
39986 casadi::FunctionInternal::codegen_decref(CodeGenerator &g) const  "
39987 
39988 [INTERNAL]  Codegen decref for dependencies.
39989 
39990 ";
39991 
39992 %feature("docstring")  casadi::FunctionInternal::check_res(const
39993 std::vector< M > &res, casadi_int &npar) const  "
39994 
39995 [INTERNAL]  Check if output arguments have correct length and dimensions.
39996 
39997 Raises errors.
39998 
39999 Parameters:
40000 -----------
40001 
40002 npar[in]:  normal usage: 1, disallow pararallel calls: -1
40003 
40004 npar:  max number of horizontal repetitions across all arguments (or -1)
40005 
40006 ";
40007 
40008 %feature("docstring")  casadi::FunctionInternal::adjViaJac(casadi_int nadj)
40009 const  "
40010 
40011 [INTERNAL]  Calculate derivatives by multiplying the full Jacobian and
40012 multiplying.
40013 
40014 ";
40015 
40016 %feature("docstring")  casadi::Interpolant::get_n_in()  "
40017 
40018 [INTERNAL]  Number of function inputs and outputs.
40019 
40020 ";
40021 
40022 %feature("docstring")  casadi::Interpolant::has_parametric_grid() const  "
40023 
40024 [INTERNAL]  Is parametric?
40025 
40026 ";
40027 
40028 %feature("docstring")
40029 casadi::FunctionInternal::getJacSparsityHierarchicalSymm(casadi_int iind,
40030 casadi_int oind) const  "
40031 
40032 [INTERNAL]  A flavor of getJacSparsity that does hierarchical block
40033 structure recognition for symmetric Jacobians
40034 
40035 ";
40036 
40037 %feature("docstring")  casadi::FunctionInternal::sz_res() const  "
40038 
40039 [INTERNAL]  Get required length of res field.
40040 
40041 ";
40042 
40043 %feature("docstring")  casadi::Interpolant::get_name_in(casadi_int i)  "
40044 
40045 [INTERNAL]  Names of function input and outputs.
40046 
40047 ";
40048 
40049 %feature("docstring")  casadi::FunctionInternal::factory(const std::string
40050 &name, const std::vector< std::string > &s_in, const std::vector<
40051 std::string > &s_out, const Function::AuxOut &aux, const Dict &opts) const
40052 "
40053 
40054 [INTERNAL] ";
40055 
40056 %feature("docstring")
40057 casadi::FunctionInternal::codegen_init_mem(CodeGenerator &g) const  "
40058 
40059 [INTERNAL]  Codegen decref for init_mem.
40060 
40061 ";
40062 
40063 %feature("docstring")  casadi::FunctionInternal::nnz_out() const  "
40064 
40065 [INTERNAL]  Number of input/output nonzeros.
40066 
40067 ";
40068 
40069 %feature("docstring")  casadi::FunctionInternal::nnz_out(casadi_int ind)
40070 const  "
40071 
40072 [INTERNAL]  Number of input/output nonzeros.
40073 
40074 ";
40075 
40076 %feature("docstring")  casadi::FunctionInternal::export_code(const
40077 std::string &lang, std::ostream &stream, const Dict &options) const  "
40078 
40079 [INTERNAL]  Export function in a specific language.
40080 
40081 ";
40082 
40083 %feature("docstring")  casadi::FunctionInternal::n_instructions() const  "
40084 
40085 [INTERNAL]  Get the number of atomic operations.
40086 
40087 ";
40088 
40089 %feature("docstring")  casadi::FunctionInternal::sp_forward(const bvec_t
40090 **arg, bvec_t **res, casadi_int *iw, bvec_t *w, void *mem) const  "
40091 
40092 [INTERNAL]  Propagate sparsity forward.
40093 
40094 ";
40095 
40096 %feature("docstring")  casadi::FunctionInternal::info() const  "
40097 
40098 [INTERNAL]  Obtain information about function
40099 
40100 ";
40101 
40102 %feature("docstring")  casadi::FunctionInternal::generate_options(bool
40103 is_temp=false) const  "
40104 
40105 [INTERNAL]  Reconstruct options dict.
40106 
40107 ";
40108 
40109 %feature("docstring")  casadi::FunctionInternal::print_option(const
40110 std::string &name, std::ostream &stream) const  "
40111 
40112 [INTERNAL]  Print all information there is to know about a certain option.
40113 
40114 ";
40115 
40116 %feature("docstring")  casadi::FunctionInternal::free_mx() const  "
40117 
40118 [INTERNAL]  Get free variables ( MX)
40119 
40120 ";
40121 
40122 %feature("docstring")  casadi::FunctionInternal::get_max_in(casadi_int ind)
40123 const  "
40124 
40125 [INTERNAL]  Get largest input value.
40126 
40127 ";
40128 
40129 %feature("docstring")  casadi::FunctionInternal::is_a(const std::string
40130 &type, bool recursive) const  "
40131 
40132 [INTERNAL]  Check if the function is of a particular type.
40133 
40134 ";
40135 
40136 %feature("docstring")  casadi::FunctionInternal::has_free() const  "
40137 
40138 [INTERNAL]  Does the function have free variables.
40139 
40140 ";
40141 
40142 %feature("docstring")
40143 casadi::FunctionInternal::codegen_alloc_mem(CodeGenerator &g) const  "
40144 
40145 [INTERNAL]  Codegen decref for alloc_mem.
40146 
40147 ";
40148 
40149 %feature("docstring")  casadi::FunctionInternal::has_function(const
40150 std::string &fname) const  "
40151 
40152 [INTERNAL] ";
40153 
40154 %feature("docstring")  casadi::FunctionInternal::dm_out(casadi_int ind)
40155 const  "
40156 
40157 [INTERNAL]  Get function input(s) and output(s)
40158 
40159 ";
40160 
40161 %feature("docstring")  casadi::FunctionInternal::dm_out() const  "
40162 
40163 [INTERNAL]  Get function input(s) and output(s)
40164 
40165 ";
40166 
40167 %feature("docstring")  casadi::FunctionInternal::generate_out(const
40168 std::string &fname, double **res) const  "
40169 
40170 [INTERNAL] ";
40171 
40172 %feature("docstring")  casadi::ProtoFunction::serialize(SerializingStream
40173 &s) const  "
40174 
40175 [INTERNAL]  Serialize an object.
40176 
40177 ";
40178 
40179 %feature("docstring")  casadi::FunctionInternal::replace_res(const
40180 std::vector< M > &res, casadi_int npar) const  "
40181 
40182 [INTERNAL]  Replace 0-by-0 outputs.
40183 
40184 ";
40185 
40186 %feature("docstring")
40187 casadi::FunctionInternal::getJacSparsityGen(casadi_int iind, casadi_int
40188 oind, bool symmetric, casadi_int gr_i=1, casadi_int gr_o=1) const  "
40189 
40190 [INTERNAL]  Get the sparsity pattern, forward mode.
40191 
40192 ";
40193 
40194 %feature("docstring")  casadi::Interpolant::serialize_base_function() const
40195 "
40196 
40197 [INTERNAL]  String used to identify the immediate FunctionInternal subclass.
40198 
40199 ";
40200 
40201 %feature("docstring")
40202 casadi::FunctionInternal::codegen_incref(CodeGenerator &g) const  "
40203 
40204 [INTERNAL]  Codegen incref for dependencies.
40205 
40206 ";
40207 
40208 %feature("docstring")  casadi::FunctionInternal::jac() const  "
40209 
40210 [INTERNAL]  Return Jacobian of all input elements with respect to all output
40211 elements.
40212 
40213 ";
40214 
40215 %feature("docstring")
40216 casadi::FunctionInternal::instruction_output(casadi_int k) const  "
40217 
40218 [INTERNAL]  Get the (integer) output argument of an atomic operation.
40219 
40220 ";
40221 
40222 %feature("docstring")  casadi::FunctionInternal::size2_in(casadi_int ind)
40223 const  "
40224 
40225 [INTERNAL]  Input/output dimensions.
40226 
40227 ";
40228 
40229 %feature("docstring")  casadi::FunctionInternal::codegen(CodeGenerator &g,
40230 const std::string &fname) const  "
40231 
40232 [INTERNAL]  Generate code the function.
40233 
40234 ";
40235 
40236 %feature("docstring")  casadi::FunctionInternal::project_arg(const
40237 std::vector< M > &arg, casadi_int npar) const  "
40238 
40239 [INTERNAL]   Project sparsities.
40240 
40241 ";
40242 
40243 %feature("docstring")  casadi::FunctionInternal::set_work(void *mem, const
40244 double **&arg, double **&res, casadi_int *&iw, double *&w) const  "
40245 
40246 [INTERNAL]  Set the (persistent) work vectors.
40247 
40248 ";
40249 
40250 %feature("docstring")  casadi::FunctionInternal::fwdViaJac(casadi_int nfwd)
40251 const  "
40252 
40253 [INTERNAL]  Calculate derivatives by multiplying the full Jacobian and
40254 multiplying.
40255 
40256 ";
40257 
40258 %feature("docstring")  casadi::FunctionInternal::self() const  "
40259 
40260 [INTERNAL]  Get a public class instance.
40261 
40262 ";
40263 
40264 %feature("docstring")  casadi::FunctionInternal::generate_lifted(Function
40265 &vdef_fcn, Function &vinit_fcn) const  "
40266 
40267 [INTERNAL]  Extract the functions needed for the Lifted Newton method.
40268 
40269 ";
40270 
40271 %feature("docstring")  casadi::Interpolant::get_n_out()  "
40272 
40273 [INTERNAL]  Number of function inputs and outputs.
40274 
40275 ";
40276 
40277 %feature("docstring")  casadi::FunctionInternal::has_reverse(casadi_int
40278 nadj) const  "
40279 
40280 [INTERNAL]  Return function that calculates adjoint derivatives
40281 reverse(nadj) returns a cached instance if available, and calls  Function
40282 get_reverse(casadi_int nadj) if no cached version is available.
40283 
40284 ";
40285 
40286 %feature("docstring")  casadi::FunctionInternal::signature(const std::string
40287 &fname) const  "
40288 
40289 [INTERNAL]  Code generate the function.
40290 
40291 ";
40292 
40293 %feature("docstring")  casadi::ProtoFunction::sprint(char *buf, size_t
40294 buf_sz, const char *fmt,...) const  "
40295 
40296 [INTERNAL]  C-style formatted printing to string.
40297 
40298 ";
40299 
40300 %feature("docstring")  casadi::FunctionInternal::alloc_w(size_t sz_w, bool
40301 persistent=false) "
40302 
40303 [INTERNAL]  Ensure required length of w field.
40304 
40305 ";
40306 
40307 %feature("docstring")  casadi::FunctionInternal::sparsity_jac(casadi_int
40308 iind, casadi_int oind, bool compact, bool symmetric) const  "
40309 
40310 [INTERNAL]  Get, if necessary generate, the sparsity of a Jacobian block.
40311 
40312 ";
40313 
40314 %feature("docstring")  casadi::FunctionInternal::wrap_as_needed(const Dict
40315 &opts) const  "
40316 
40317 [INTERNAL]  Wrap in an Function instance consisting of only one MX call.
40318 
40319 ";
40320 
40321 %feature("docstring")
40322 casadi::FunctionInternal::jacobian_sparsity_filter(const Sparsity &sp) const
40323 "
40324 
40325 [INTERNAL]  Filter out nonzeros in the full sparsity jacobian according to
40326 is_diff_in/out.
40327 
40328 ";
40329 
40330 %feature("docstring")
40331 casadi::FunctionInternal::instruction_constant(casadi_int k) const  "
40332 
40333 [INTERNAL]  Get the floating point output argument of an atomic operation.
40334 
40335 ";
40336 
40337 %feature("docstring")  casadi::FunctionInternal::size_in(casadi_int ind)
40338 const  "
40339 
40340 [INTERNAL]  Input/output dimensions.
40341 
40342 ";
40343 
40344 %feature("docstring")  casadi::FunctionInternal::has_forward(casadi_int
40345 nfwd) const  "
40346 
40347 [INTERNAL]  Return function that calculates forward derivatives
40348 forward(nfwd) returns a cached instance if available, and calls  Function
40349 get_forward(casadi_int nfwd) if no cached version is available.
40350 
40351 ";
40352 
40353 %feature("docstring")  casadi::FunctionInternal::matching_res(const
40354 std::vector< M > &arg, casadi_int &npar) const  "
40355 
40356 [INTERNAL]  Check if output arguments that needs to be replaced.
40357 
40358 Raises errors
40359 
40360 Parameters:
40361 -----------
40362 
40363 npar[in]:  normal usage: 1, disallow pararallel calls: -1
40364 
40365 npar:  max number of horizontal repetitions across all arguments (or -1)
40366 
40367 ";
40368 
40369 %feature("docstring")  casadi::FunctionInternal::jacobian() const  "
40370 
40371 [INTERNAL]  Return Jacobian of all input elements with respect to all output
40372 elements.
40373 
40374 ";
40375 
40376 %feature("docstring")  casadi::FunctionInternal::call(const std::vector< M >
40377 &arg, std::vector< M > &res, bool always_inline, bool never_inline) const  "
40378 
40379 [INTERNAL]   Call a function, templated.
40380 
40381 ";
40382 
40383 %feature("docstring")  casadi::FunctionInternal::has_eval_dm() const  "
40384 
40385 [INTERNAL]  Evaluate with DM matrices.
40386 
40387 ";
40388 
40389 %feature("docstring")
40390 casadi::FunctionInternal::codegen_free_mem(CodeGenerator &g) const  "
40391 
40392 [INTERNAL]  Codegen for free_mem.
40393 
40394 ";
40395 
40396 %feature("docstring")  casadi::FunctionInternal::codegen_mem(CodeGenerator
40397 &g, const std::string &index="mem") const  "
40398 
40399 [INTERNAL]  Get thread-local memory object.
40400 
40401 ";
40402 
40403 %feature("docstring")  casadi::Interpolant::arg_values() const  "
40404 
40405 [INTERNAL] ";
40406 
40407 %feature("docstring")  casadi::FunctionInternal::mx_out(casadi_int ind)
40408 const  "
40409 
40410 [INTERNAL]  Get function input(s) and output(s)
40411 
40412 ";
40413 
40414 %feature("docstring")  casadi::FunctionInternal::mx_out() const  "
40415 
40416 [INTERNAL]  Get function input(s) and output(s)
40417 
40418 ";
40419 
40420 %feature("docstring")  casadi::FunctionInternal::alloc_iw(size_t sz_iw, bool
40421 persistent=false) "
40422 
40423 [INTERNAL]  Ensure required length of iw field.
40424 
40425 ";
40426 
40427 %feature("docstring")  casadi::FunctionInternal::get_jac(const std::string
40428 &name, const std::vector< std::string > &inames, const std::vector<
40429 std::string > &onames, const Dict &opts) const  "
40430 
40431 [INTERNAL]  Return Jacobian of all input elements with respect to all output
40432 elements.
40433 
40434 ";
40435 
40436 %feature("docstring")  casadi::ProtoFunction::init_mem(void *mem) const  "
40437 
40438 [INTERNAL]  Initalize memory block.
40439 
40440 ";
40441 
40442 %feature("docstring")  casadi::ProtoFunction::free_mem(void *mem) const  "
40443 
40444 [INTERNAL]  Free memory block.
40445 
40446 ";
40447 
40448 %feature("docstring")  casadi::FunctionInternal::eval(const double **arg,
40449 double **res, casadi_int *iw, double *w, void *mem) const  "
40450 
40451 [INTERNAL]  Evaluate numerically.
40452 
40453 ";
40454 
40455 %feature("docstring")  casadi::ProtoFunction::construct(const Dict &opts) "
40456 
40457 [INTERNAL]  Construct Prepares the function for evaluation.
40458 
40459 ";
40460 
40461 %feature("docstring")  casadi::FunctionInternal::fwd_seed(casadi_int nfwd)
40462 const  "
40463 
40464 [INTERNAL]  Symbolic expressions for the forward seeds.
40465 
40466 ";
40467 
40468 %feature("docstring")  casadi::ProtoFunction::release(int mem) const  "
40469 
40470 [INTERNAL]  Release a memory object.
40471 
40472 ";
40473 
40474 %feature("docstring")  casadi::FunctionInternal::check_arg(const
40475 std::vector< M > &arg, casadi_int &npar) const  "
40476 
40477 [INTERNAL]  Check if input arguments have correct length and dimensions.
40478 
40479 Raises errors.
40480 
40481 Parameters:
40482 -----------
40483 
40484 npar[in]:  normal usage: 1, disallow pararallel calls: -1
40485 
40486 npar:  max number of horizontal repetitions across all arguments (or -1)
40487 
40488 ";
40489 
40490 %feature("docstring") casadi::Interpolant "
40491 
40492 Internal class
40493 
40494 >List of available options
40495 
40496 +------------------+-----------------+------------------+------------------+
40497 |        Id        |      Type       |   Description    |     Used in      |
40498 +==================+=================+==================+==================+
40499 | ad_weight        | OT_DOUBLE       | Weighting factor | casadi::Function |
40500 |                  |                 | for derivative   | Internal         |
40501 |                  |                 | calculation.When |                  |
40502 |                  |                 | there is an      |                  |
40503 |                  |                 | option of either |                  |
40504 |                  |                 | using forward or |                  |
40505 |                  |                 | reverse mode     |                  |
40506 |                  |                 | directional      |                  |
40507 |                  |                 | derivatives, the |                  |
40508 |                  |                 | condition ad_wei |                  |
40509 |                  |                 | ght*nf<=(1-ad_we |                  |
40510 |                  |                 | ight)*na is used |                  |
40511 |                  |                 | where nf and na  |                  |
40512 |                  |                 | are estimates of |                  |
40513 |                  |                 | the number of    |                  |
40514 |                  |                 | forward/reverse  |                  |
40515 |                  |                 | mode directional |                  |
40516 |                  |                 | derivatives      |                  |
40517 |                  |                 | needed. By       |                  |
40518 |                  |                 | default,         |                  |
40519 |                  |                 | ad_weight is     |                  |
40520 |                  |                 | calculated       |                  |
40521 |                  |                 | automatically,   |                  |
40522 |                  |                 | but this can be  |                  |
40523 |                  |                 | overridden by    |                  |
40524 |                  |                 | setting this     |                  |
40525 |                  |                 | option. In       |                  |
40526 |                  |                 | particular, 0    |                  |
40527 |                  |                 | means forcing    |                  |
40528 |                  |                 | forward mode and |                  |
40529 |                  |                 | 1 forcing        |                  |
40530 |                  |                 | reverse mode.    |                  |
40531 |                  |                 | Leave unset for  |                  |
40532 |                  |                 | (class specific) |                  |
40533 |                  |                 | heuristics.      |                  |
40534 +------------------+-----------------+------------------+------------------+
40535 | ad_weight_sp     | OT_DOUBLE       | Weighting factor | casadi::Function |
40536 |                  |                 | for sparsity     | Internal         |
40537 |                  |                 | pattern          |                  |
40538 |                  |                 | calculation calc |                  |
40539 |                  |                 | ulation.Override |                  |
40540 |                  |                 | s default        |                  |
40541 |                  |                 | behavior. Set to |                  |
40542 |                  |                 | 0 and 1 to force |                  |
40543 |                  |                 | forward and      |                  |
40544 |                  |                 | reverse mode     |                  |
40545 |                  |                 | respectively.    |                  |
40546 |                  |                 | Cf. option       |                  |
40547 |                  |                 | \"ad_weight\".     |                  |
40548 |                  |                 | When set to -1,  |                  |
40549 |                  |                 | sparsity is      |                  |
40550 |                  |                 | completely       |                  |
40551 |                  |                 | ignored and      |                  |
40552 |                  |                 | dense matrices   |                  |
40553 |                  |                 | are used.        |                  |
40554 +------------------+-----------------+------------------+------------------+
40555 | always_inline    | OT_BOOL         | Force inlining.  | casadi::Function |
40556 |                  |                 |                  | Internal         |
40557 +------------------+-----------------+------------------+------------------+
40558 | batch_x          | OT_INT          | Evaluate a batch | casadi::Interpol |
40559 |                  |                 | of different     | ant              |
40560 |                  |                 | inputs at once   |                  |
40561 |                  |                 | (default 1).     |                  |
40562 +------------------+-----------------+------------------+------------------+
40563 | compiler         | OT_STRING       | Just-in-time     | casadi::Function |
40564 |                  |                 | compiler plugin  | Internal         |
40565 |                  |                 | to be used.      |                  |
40566 +------------------+-----------------+------------------+------------------+
40567 | custom_jacobian  | OT_FUNCTION     | Override         | casadi::Function |
40568 |                  |                 | CasADi's AD. Use | Internal         |
40569 |                  |                 | together with    |                  |
40570 |                  |                 | 'jac_penalty':   |                  |
40571 |                  |                 | 0. Note: Highly  |                  |
40572 |                  |                 | experimental.    |                  |
40573 |                  |                 | Syntax may break |                  |
40574 |                  |                 | often.           |                  |
40575 +------------------+-----------------+------------------+------------------+
40576 | derivative_of    | OT_FUNCTION     | The function is  | casadi::Function |
40577 |                  |                 | a derivative of  | Internal         |
40578 |                  |                 | another          |                  |
40579 |                  |                 | function. The    |                  |
40580 |                  |                 | type of          |                  |
40581 |                  |                 | derivative       |                  |
40582 |                  |                 | (directional     |                  |
40583 |                  |                 | derivative,      |                  |
40584 |                  |                 | Jacobian) is     |                  |
40585 |                  |                 | inferred from    |                  |
40586 |                  |                 | the function     |                  |
40587 |                  |                 | name.            |                  |
40588 +------------------+-----------------+------------------+------------------+
40589 | dump             | OT_BOOL         | Dump function to | casadi::Function |
40590 |                  |                 | file upon first  | Internal         |
40591 |                  |                 | evaluation.      |                  |
40592 |                  |                 | [false]          |                  |
40593 +------------------+-----------------+------------------+------------------+
40594 | dump_dir         | OT_STRING       | Directory to     | casadi::Function |
40595 |                  |                 | dump             | Internal         |
40596 |                  |                 | inputs/outputs   |                  |
40597 |                  |                 | to. Make sure    |                  |
40598 |                  |                 | the directory    |                  |
40599 |                  |                 | exists [.]       |                  |
40600 +------------------+-----------------+------------------+------------------+
40601 | dump_format      | OT_STRING       | Choose file      | casadi::Function |
40602 |                  |                 | format to dump   | Internal         |
40603 |                  |                 | matrices. See    |                  |
40604 |                  |                 | DM.from_file     |                  |
40605 |                  |                 | [mtx]            |                  |
40606 +------------------+-----------------+------------------+------------------+
40607 | dump_in          | OT_BOOL         | Dump numerical   | casadi::Function |
40608 |                  |                 | values of inputs | Internal         |
40609 |                  |                 | to file          |                  |
40610 |                  |                 | (readable with   |                  |
40611 |                  |                 | DM.from_file )   |                  |
40612 |                  |                 | [default: false] |                  |
40613 +------------------+-----------------+------------------+------------------+
40614 | dump_out         | OT_BOOL         | Dump numerical   | casadi::Function |
40615 |                  |                 | values of        | Internal         |
40616 |                  |                 | outputs to file  |                  |
40617 |                  |                 | (readable with   |                  |
40618 |                  |                 | DM.from_file )   |                  |
40619 |                  |                 | [default: false] |                  |
40620 +------------------+-----------------+------------------+------------------+
40621 | enable_fd        | OT_BOOL         | Enable           | casadi::Function |
40622 |                  |                 | derivative       | Internal         |
40623 |                  |                 | calculation by   |                  |
40624 |                  |                 | finite           |                  |
40625 |                  |                 | differencing.    |                  |
40626 |                  |                 | [default:        |                  |
40627 |                  |                 | false]]          |                  |
40628 +------------------+-----------------+------------------+------------------+
40629 | enable_forward   | OT_BOOL         | Enable           | casadi::Function |
40630 |                  |                 | derivative       | Internal         |
40631 |                  |                 | calculation      |                  |
40632 |                  |                 | using generated  |                  |
40633 |                  |                 | functions for    |                  |
40634 |                  |                 | Jacobian-times-  |                  |
40635 |                  |                 | vector products  |                  |
40636 |                  |                 | - typically      |                  |
40637 |                  |                 | using forward    |                  |
40638 |                  |                 | mode AD - if     |                  |
40639 |                  |                 | available.       |                  |
40640 |                  |                 | [default: true]  |                  |
40641 +------------------+-----------------+------------------+------------------+
40642 | enable_jacobian  | OT_BOOL         | Enable           | casadi::Function |
40643 |                  |                 | derivative       | Internal         |
40644 |                  |                 | calculation      |                  |
40645 |                  |                 | using generated  |                  |
40646 |                  |                 | functions for    |                  |
40647 |                  |                 | Jacobians of all |                  |
40648 |                  |                 | differentiable   |                  |
40649 |                  |                 | outputs with     |                  |
40650 |                  |                 | respect to all   |                  |
40651 |                  |                 | differentiable   |                  |
40652 |                  |                 | inputs - if      |                  |
40653 |                  |                 | available.       |                  |
40654 |                  |                 | [default: true]  |                  |
40655 +------------------+-----------------+------------------+------------------+
40656 | enable_reverse   | OT_BOOL         | Enable           | casadi::Function |
40657 |                  |                 | derivative       | Internal         |
40658 |                  |                 | calculation      |                  |
40659 |                  |                 | using generated  |                  |
40660 |                  |                 | functions for    |                  |
40661 |                  |                 | transposed       |                  |
40662 |                  |                 | Jacobian-times-  |                  |
40663 |                  |                 | vector products  |                  |
40664 |                  |                 | - typically      |                  |
40665 |                  |                 | using reverse    |                  |
40666 |                  |                 | mode AD - if     |                  |
40667 |                  |                 | available.       |                  |
40668 |                  |                 | [default: true]  |                  |
40669 +------------------+-----------------+------------------+------------------+
40670 | fd_method        | OT_STRING       | Method for       | casadi::Function |
40671 |                  |                 | finite           | Internal         |
40672 |                  |                 | differencing     |                  |
40673 |                  |                 | [default         |                  |
40674 |                  |                 | 'central']       |                  |
40675 +------------------+-----------------+------------------+------------------+
40676 | fd_options       | OT_DICT         | Options to be    | casadi::Function |
40677 |                  |                 | passed to the    | Internal         |
40678 |                  |                 | finite           |                  |
40679 |                  |                 | difference       |                  |
40680 |                  |                 | instance         |                  |
40681 +------------------+-----------------+------------------+------------------+
40682 | forward_options  | OT_DICT         | Options to be    | casadi::Function |
40683 |                  |                 | passed to a      | Internal         |
40684 |                  |                 | forward mode     |                  |
40685 |                  |                 | constructor      |                  |
40686 +------------------+-----------------+------------------+------------------+
40687 | gather_stats     | OT_BOOL         | Deprecated       | casadi::Function |
40688 |                  |                 | option           | Internal         |
40689 |                  |                 | (ignored):       |                  |
40690 |                  |                 | Statistics are   |                  |
40691 |                  |                 | now always       |                  |
40692 |                  |                 | collected.       |                  |
40693 +------------------+-----------------+------------------+------------------+
40694 | inline           | OT_BOOL         | Implement the    | casadi::Interpol |
40695 |                  |                 | lookup table in  | ant              |
40696 |                  |                 | MX primitives.   |                  |
40697 |                  |                 | Useful when you  |                  |
40698 |                  |                 | need derivatives |                  |
40699 |                  |                 | with respect to  |                  |
40700 |                  |                 | grid and/or      |                  |
40701 |                  |                 | coefficients.    |                  |
40702 |                  |                 | Such derivatives |                  |
40703 |                  |                 | are              |                  |
40704 |                  |                 | fundamentally    |                  |
40705 |                  |                 | dense, so use    |                  |
40706 |                  |                 | with caution.    |                  |
40707 +------------------+-----------------+------------------+------------------+
40708 | input_scheme     | OT_STRINGVECTOR | Deprecated       | casadi::Function |
40709 |                  |                 | option (ignored) | Internal         |
40710 +------------------+-----------------+------------------+------------------+
40711 | inputs_check     | OT_BOOL         | Throw exceptions | casadi::Function |
40712 |                  |                 | when the         | Internal         |
40713 |                  |                 | numerical values |                  |
40714 |                  |                 | of the inputs    |                  |
40715 |                  |                 | don't make sense |                  |
40716 +------------------+-----------------+------------------+------------------+
40717 | is_diff_in       | OT_BOOLVECTOR   | Indicate for     | casadi::Function |
40718 |                  |                 | each input if it | Internal         |
40719 |                  |                 | should be        |                  |
40720 |                  |                 | differentiable.  |                  |
40721 +------------------+-----------------+------------------+------------------+
40722 | is_diff_out      | OT_BOOLVECTOR   | Indicate for     | casadi::Function |
40723 |                  |                 | each output if   | Internal         |
40724 |                  |                 | it should be     |                  |
40725 |                  |                 | differentiable.  |                  |
40726 +------------------+-----------------+------------------+------------------+
40727 | jac_penalty      | OT_DOUBLE       | When requested   | casadi::Function |
40728 |                  |                 | for a number of  | Internal         |
40729 |                  |                 | forward/reverse  |                  |
40730 |                  |                 | directions, it   |                  |
40731 |                  |                 | may be cheaper   |                  |
40732 |                  |                 | to compute first |                  |
40733 |                  |                 | the full         |                  |
40734 |                  |                 | jacobian and     |                  |
40735 |                  |                 | then multiply    |                  |
40736 |                  |                 | with seeds,      |                  |
40737 |                  |                 | rather than      |                  |
40738 |                  |                 | obtain the       |                  |
40739 |                  |                 | requested        |                  |
40740 |                  |                 | directions in a  |                  |
40741 |                  |                 | straightforward  |                  |
40742 |                  |                 | manner. Casadi   |                  |
40743 |                  |                 | uses a heuristic |                  |
40744 |                  |                 | to decide which  |                  |
40745 |                  |                 | is cheaper. A    |                  |
40746 |                  |                 | high value of    |                  |
40747 |                  |                 | 'jac_penalty'    |                  |
40748 |                  |                 | makes it less    |                  |
40749 |                  |                 | likely for the   |                  |
40750 |                  |                 | heurstic to      |                  |
40751 |                  |                 | chose the full   |                  |
40752 |                  |                 | Jacobian         |                  |
40753 |                  |                 | strategy. The    |                  |
40754 |                  |                 | special value -1 |                  |
40755 |                  |                 | indicates never  |                  |
40756 |                  |                 | to use the full  |                  |
40757 |                  |                 | Jacobian         |                  |
40758 |                  |                 | strategy         |                  |
40759 +------------------+-----------------+------------------+------------------+
40760 | jit              | OT_BOOL         | Use just-in-time | casadi::Function |
40761 |                  |                 | compiler to      | Internal         |
40762 |                  |                 | speed up the     |                  |
40763 |                  |                 | evaluation       |                  |
40764 +------------------+-----------------+------------------+------------------+
40765 | jit_cleanup      | OT_BOOL         | Cleanup up the   | casadi::Function |
40766 |                  |                 | temporary source | Internal         |
40767 |                  |                 | file that jit    |                  |
40768 |                  |                 | creates.         |                  |
40769 |                  |                 | Default: true    |                  |
40770 +------------------+-----------------+------------------+------------------+
40771 | jit_name         | OT_STRING       | The file name    | casadi::Function |
40772 |                  |                 | used to write    | Internal         |
40773 |                  |                 | out code. The    |                  |
40774 |                  |                 | actual file      |                  |
40775 |                  |                 | names used       |                  |
40776 |                  |                 | depend on 'jit_t |                  |
40777 |                  |                 | emp_suffix' and  |                  |
40778 |                  |                 | include          |                  |
40779 |                  |                 | extensions.      |                  |
40780 |                  |                 | Default:         |                  |
40781 |                  |                 | 'jit_tmp'        |                  |
40782 +------------------+-----------------+------------------+------------------+
40783 | jit_options      | OT_DICT         | Options to be    | casadi::Function |
40784 |                  |                 | passed to the    | Internal         |
40785 |                  |                 | jit compiler.    |                  |
40786 +------------------+-----------------+------------------+------------------+
40787 | jit_serialize    | OT_STRING       | Specify          | casadi::Function |
40788 |                  |                 | behaviour when   | Internal         |
40789 |                  |                 | serializing a    |                  |
40790 |                  |                 | jitted function: |                  |
40791 |                  |                 | SOURCE|link|embe |                  |
40792 |                  |                 | d.               |                  |
40793 +------------------+-----------------+------------------+------------------+
40794 | jit_temp_suffix  | OT_BOOL         | Use a temporary  | casadi::Function |
40795 |                  |                 | (seemingly       | Internal         |
40796 |                  |                 | random) filename |                  |
40797 |                  |                 | suffix for       |                  |
40798 |                  |                 | generated code   |                  |
40799 |                  |                 | and libraries.   |                  |
40800 |                  |                 | This is desired  |                  |
40801 |                  |                 | for thread-      |                  |
40802 |                  |                 | safety. This     |                  |
40803 |                  |                 | behaviour may    |                  |
40804 |                  |                 | defeat caching   |                  |
40805 |                  |                 | compiler         |                  |
40806 |                  |                 | wrappers.        |                  |
40807 |                  |                 | Default: true    |                  |
40808 +------------------+-----------------+------------------+------------------+
40809 | lookup_mode      | OT_STRINGVECTOR | Specifies, for   | casadi::Interpol |
40810 |                  |                 | each grid        | ant              |
40811 |                  |                 | dimenion, the    |                  |
40812 |                  |                 | lookup algorithm |                  |
40813 |                  |                 | used to find the |                  |
40814 |                  |                 | correct index.   |                  |
40815 |                  |                 | 'linear' uses a  |                  |
40816 |                  |                 | for-loop +       |                  |
40817 |                  |                 | break; (default  |                  |
40818 |                  |                 | when             |                  |
40819 |                  |                 | #knots<=100),    |                  |
40820 |                  |                 | 'exact' uses     |                  |
40821 |                  |                 | floored division |                  |
40822 |                  |                 | (only for        |                  |
40823 |                  |                 | uniform grids),  |                  |
40824 |                  |                 | 'binary' uses a  |                  |
40825 |                  |                 | binary search.   |                  |
40826 |                  |                 | (default when    |                  |
40827 |                  |                 | #knots>100).     |                  |
40828 +------------------+-----------------+------------------+------------------+
40829 | max_num_dir      | OT_INT          | Specify the      | casadi::Function |
40830 |                  |                 | maximum number   | Internal         |
40831 |                  |                 | of directions    |                  |
40832 |                  |                 | for derivative   |                  |
40833 |                  |                 | functions.       |                  |
40834 |                  |                 | Overrules the    |                  |
40835 |                  |                 | builtin optimize |                  |
40836 |                  |                 | d_num_dir.       |                  |
40837 +------------------+-----------------+------------------+------------------+
40838 | never_inline     | OT_BOOL         | Forbid inlining. | casadi::Function |
40839 |                  |                 |                  | Internal         |
40840 +------------------+-----------------+------------------+------------------+
40841 | output_scheme    | OT_STRINGVECTOR | Deprecated       | casadi::Function |
40842 |                  |                 | option (ignored) | Internal         |
40843 +------------------+-----------------+------------------+------------------+
40844 | print_in         | OT_BOOL         | Print numerical  | casadi::Function |
40845 |                  |                 | values of inputs | Internal         |
40846 |                  |                 | [default: false] |                  |
40847 +------------------+-----------------+------------------+------------------+
40848 | print_out        | OT_BOOL         | Print numerical  | casadi::Function |
40849 |                  |                 | values of        | Internal         |
40850 |                  |                 | outputs          |                  |
40851 |                  |                 | [default: false] |                  |
40852 +------------------+-----------------+------------------+------------------+
40853 | print_time       | OT_BOOL         | print            | casadi::Function |
40854 |                  |                 | information      | Internal         |
40855 |                  |                 | about execution  |                  |
40856 |                  |                 | time. Implies    |                  |
40857 |                  |                 | record_time.     |                  |
40858 +------------------+-----------------+------------------+------------------+
40859 | record_time      | OT_BOOL         | record           | casadi::Function |
40860 |                  |                 | information      | Internal         |
40861 |                  |                 | about execution  |                  |
40862 |                  |                 | time, for        |                  |
40863 |                  |                 | retrieval with   |                  |
40864 |                  |                 | stats().         |                  |
40865 +------------------+-----------------+------------------+------------------+
40866 | regularity_check | OT_BOOL         | Throw exceptions | casadi::Function |
40867 |                  |                 | when NaN or Inf  | Internal         |
40868 |                  |                 | appears during   |                  |
40869 |                  |                 | evaluation       |                  |
40870 +------------------+-----------------+------------------+------------------+
40871 | reverse_options  | OT_DICT         | Options to be    | casadi::Function |
40872 |                  |                 | passed to a      | Internal         |
40873 |                  |                 | reverse mode     |                  |
40874 |                  |                 | constructor      |                  |
40875 +------------------+-----------------+------------------+------------------+
40876 | user_data        | OT_VOIDPTR      | A user-defined   | casadi::Function |
40877 |                  |                 | field that can   | Internal         |
40878 |                  |                 | be used to       |                  |
40879 |                  |                 | identify the     |                  |
40880 |                  |                 | function or pass |                  |
40881 |                  |                 | additional       |                  |
40882 |                  |                 | information      |                  |
40883 +------------------+-----------------+------------------+------------------+
40884 | verbose          | OT_BOOL         | Verbose          | casadi::Function |
40885 |                  |                 | evaluation  for  | Internal         |
40886 |                  |                 | debugging        |                  |
40887 +------------------+-----------------+------------------+------------------+
40888 
40889 Diagrams
40890 --------
40891 
40892 
40893 
40894 C++ includes: interpolant_impl.hpp ";
40895 
40896 %feature("docstring")  casadi::FunctionInternal::ad_weight() const  "
40897 
40898 [INTERNAL]  Weighting factor for chosing forward/reverse mode.
40899 
40900 ";
40901 
40902 %feature("docstring")  casadi::FunctionInternal::free_sx() const  "
40903 
40904 [INTERNAL]  Get free variables (SX)
40905 
40906 ";
40907 
40908 %feature("docstring")  casadi::FunctionInternal::sx_in(casadi_int ind) const
40909 "
40910 
40911 [INTERNAL]  Get function input(s) and output(s)
40912 
40913 ";
40914 
40915 %feature("docstring")  casadi::FunctionInternal::sx_in() const  "
40916 
40917 [INTERNAL]  Get function input(s) and output(s)
40918 
40919 ";
40920 
40921 %feature("docstring")  casadi::FunctionInternal::eval_mx(const MXVector
40922 &arg, MXVector &res, bool always_inline, bool never_inline) const  "
40923 
40924 [INTERNAL]  Evaluate with symbolic matrices.
40925 
40926 ";
40927 
40928 %feature("docstring")  casadi::FunctionInternal::slice(const std::string
40929 &name, const std::vector< casadi_int > &order_in, const std::vector<
40930 casadi_int > &order_out, const Dict &opts) const  "
40931 
40932 [INTERNAL]  returns a new function with a selection of inputs/outputs of the
40933 original
40934 
40935 ";
40936 
40937 %feature("docstring")  casadi::FunctionInternal::size_out(casadi_int ind)
40938 const  "
40939 
40940 [INTERNAL]  Input/output dimensions.
40941 
40942 ";
40943 
40944 %feature("docstring")  casadi::FunctionInternal::forward(casadi_int nfwd)
40945 const  "
40946 
40947 [INTERNAL]  Return function that calculates forward derivatives
40948 forward(nfwd) returns a cached instance if available, and calls  Function
40949 get_forward(casadi_int nfwd) if no cached version is available.
40950 
40951 ";
40952 
40953 %feature("docstring")  casadi::FunctionInternal::which_depends(const
40954 std::string &s_in, const std::vector< std::string > &s_out, casadi_int
40955 order, bool tr=false) const  "
40956 
40957 [INTERNAL]  Which variables enter with some order.
40958 
40959 Parameters:
40960 -----------
40961 
40962 s_in:   Input name
40963 
40964 s_out:   Output name(s)
40965 
40966 order:  Only 1 (linear) and 2 (nonlinear) allowed
40967 
40968 tr:  Flip the relationship. Return which expressions contain the variables
40969 
40970 ";
40971 
40972 %feature("docstring")  casadi::FunctionInternal::nz_in(const std::vector< DM
40973 > &arg) const  "
40974 
40975 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
40976 
40977 ";
40978 
40979 %feature("docstring")  casadi::FunctionInternal::nz_in(const std::vector<
40980 double > &arg) const  "
40981 
40982 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
40983 
40984 ";
40985 
40986 %feature("docstring")  casadi::FunctionInternal::sz_iw() const  "
40987 
40988 [INTERNAL]  Get required length of iw field.
40989 
40990 ";
40991 
40992 %feature("docstring")  casadi::FunctionInternal::has_sprev() const  "
40993 
40994 [INTERNAL]  Is the class able to propagate seeds through the algorithm?
40995 
40996 ";
40997 
40998 %feature("docstring")  casadi::FunctionInternal::sp_weight() const  "
40999 
41000 [INTERNAL]  Weighting factor for chosing forward/reverse mode, sparsity
41001 propagation.
41002 
41003 ";
41004 
41005 %feature("docstring")  casadi::FunctionInternal::sz_work(size_t &sz_arg,
41006 size_t &sz_res, size_t &sz_iw, size_t &sz_w) const  "
41007 
41008 [INTERNAL]  Get number of temporary variables needed.
41009 
41010 ";
41011 
41012 %feature("docstring")  casadi::FunctionInternal::call_reverse(const
41013 std::vector< MX > &arg, const std::vector< MX > &res, const std::vector<
41014 std::vector< MX > > &aseed, std::vector< std::vector< MX > > &asens, bool
41015 always_inline, bool never_inline) const  "
41016 
41017 [INTERNAL]  Reverse mode, virtual functions overloaded in derived classes.
41018 
41019 ";
41020 
41021 %feature("docstring")  casadi::FunctionInternal::call_reverse(const
41022 std::vector< SX > &arg, const std::vector< SX > &res, const std::vector<
41023 std::vector< SX > > &aseed, std::vector< std::vector< SX > > &asens, bool
41024 always_inline, bool never_inline) const  "
41025 
41026 [INTERNAL]  Reverse mode, virtual functions overloaded in derived classes.
41027 
41028 ";
41029 
41030 %feature("docstring")  casadi::FunctionInternal::print_options(std::ostream
41031 &stream) const  "
41032 
41033 [INTERNAL]  Print list of options.
41034 
41035 ";
41036 
41037 %feature("docstring")  casadi::FunctionInternal::dm_in(casadi_int ind) const
41038 "
41039 
41040 [INTERNAL]  Get function input(s) and output(s)
41041 
41042 ";
41043 
41044 %feature("docstring")  casadi::FunctionInternal::dm_in() const  "
41045 
41046 [INTERNAL]  Get function input(s) and output(s)
41047 
41048 ";
41049 
41050 %feature("docstring")  casadi::FunctionInternal::eval_dm(const std::vector<
41051 DM > &arg) const  "
41052 
41053 [INTERNAL]  Evaluate with DM matrices.
41054 
41055 ";
41056 
41057 %feature("docstring")  casadi::FunctionInternal::sp_reverse(bvec_t **arg,
41058 bvec_t **res, casadi_int *iw, bvec_t *w, void *mem) const  "
41059 
41060 [INTERNAL]  Propagate sparsity backwards.
41061 
41062 ";
41063 
41064 %feature("docstring") casadi::Interpolant::Interpolant(const std::string
41065 &name, const std::vector< double > &grid, const std::vector< casadi_int >
41066 &offset, const std::vector< double > &values, casadi_int m) "
41067 
41068 [INTERNAL]  Constructor.
41069 
41070 ";
41071 
41072 %feature("docstring")  casadi::Interpolant::arg_grid() const  "
41073 
41074 [INTERNAL] ";
41075 
41076 %feature("docstring")  casadi::SharedObjectInternal::getCount() const  "
41077 
41078 [INTERNAL]  Get the reference count.
41079 
41080 ";
41081 
41082 %feature("docstring")  casadi::FunctionInternal::sparsity_in(casadi_int ind)
41083 const  "
41084 
41085 [INTERNAL]  Input/output sparsity.
41086 
41087 ";
41088 
41089 %feature("docstring")  casadi::FunctionInternal::call_gen(const MXVector
41090 &arg, MXVector &res, casadi_int npar, bool always_inline, bool never_inline)
41091 const  "
41092 
41093 [INTERNAL]   Call a function, overloaded.
41094 
41095 ";
41096 
41097 %feature("docstring")  casadi::FunctionInternal::call_gen(const std::vector<
41098 MatrixCommon > &arg, std::vector< MatrixCommon > &res, casadi_int npar, bool
41099 always_inline, bool never_inline) const  "
41100 
41101 [INTERNAL]   Call a function, overloaded.
41102 
41103 ";
41104 
41105 %feature("docstring")  casadi::FunctionInternal::index_in(const std::string
41106 &name) const  "
41107 
41108 [INTERNAL]  Get input scheme index by name.
41109 
41110 ";
41111 
41112 %feature("docstring")  casadi::FunctionInternal::index_out(const std::string
41113 &name) const  "
41114 
41115 [INTERNAL]  Get output scheme index by name.
41116 
41117 ";
41118 
41119 %feature("docstring")  casadi::FunctionInternal::sz_arg() const  "
41120 
41121 [INTERNAL]  Get required length of arg field.
41122 
41123 ";
41124 
41125 %feature("docstring")  casadi::FunctionInternal::map(casadi_int n, const
41126 std::string &parallelization) const  "
41127 
41128 [INTERNAL]  Generate/retrieve cached serial map.
41129 
41130 ";
41131 
41132 %feature("docstring") casadi::Interpolant::~Interpolant "
41133 
41134 [INTERNAL]  Destructor.
41135 
41136 ";
41137 
41138 %feature("docstring")  casadi::FunctionInternal::codegen_body(CodeGenerator
41139 &g) const  "
41140 
41141 [INTERNAL]  Generate code for the function body.
41142 
41143 ";
41144 
41145 %feature("docstring")  casadi::Interpolant::class_name() const  "
41146 
41147 [INTERNAL]  Get type name.
41148 
41149 ";
41150 
41151 %feature("docstring")  casadi::FunctionInternal::symbolicAdjSeed(casadi_int
41152 nadj, const std::vector< MatType > &v) const  "
41153 
41154 [INTERNAL]  Symbolic expressions for the adjoint seeds.
41155 
41156 ";
41157 
41158 %feature("docstring")  casadi::Interpolant::is_diff_in(casadi_int i)  "
41159 
41160 [INTERNAL] ";
41161 
41162 %feature("docstring")  casadi::Interpolant::has_parametric_values() const  "
41163 
41164 [INTERNAL]  Is parametric?
41165 
41166 ";
41167 
41168 %feature("docstring")  casadi::ProtoFunction::print(const char *fmt,...)
41169 const  "
41170 
41171 [INTERNAL]  C-style formatted printing during evaluation.
41172 
41173 ";
41174 
41175 %feature("docstring")  casadi::FunctionInternal::definition() const  "
41176 
41177 [INTERNAL]  Get function signature: name:(inputs)->(outputs)
41178 
41179 ";
41180 
41181 %feature("docstring")  casadi::FunctionInternal::setup(void *mem, const
41182 double **arg, double **res, casadi_int *iw, double *w) const  "
41183 
41184 [INTERNAL]  Set the (persistent and temporary) work vectors.
41185 
41186 ";
41187 
41188 %feature("docstring")  casadi::FunctionInternal::nz_out(const std::vector<
41189 DM > &res) const  "
41190 
41191 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
41192 
41193 ";
41194 
41195 %feature("docstring")  casadi::FunctionInternal::nz_out(const std::vector<
41196 double > &res) const  "
41197 
41198 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
41199 
41200 ";
41201 
41202 %feature("docstring")  casadi::FunctionInternal::get_abstol() const  "
41203 
41204 [INTERNAL]  Get absolute tolerance.
41205 
41206 ";
41207 
41208 %feature("docstring")  casadi::FunctionInternal::jit_dependencies(const
41209 std::string &fname) "
41210 
41211 [INTERNAL]  Jit dependencies.
41212 
41213 ";
41214 
41215 %feature("docstring")  casadi::ProtoFunction::checkout() const  "
41216 
41217 [INTERNAL]  Checkout a memory object.
41218 
41219 ";
41220 
41221 %feature("docstring")  casadi::ProtoFunction::get_stats(void *mem) const  "
41222 
41223 [INTERNAL]  Get all statistics.
41224 
41225 ";
41226 
41227 %feature("docstring")
41228 casadi::FunctionInternal::print_dimensions(std::ostream &stream) const  "
41229 
41230 [INTERNAL]  Print dimensions of inputs and outputs.
41231 
41232 ";
41233 
41234 %feature("docstring")  casadi::FunctionInternal::disp(std::ostream &stream,
41235 bool more) const  "
41236 
41237 [INTERNAL]  Display object.
41238 
41239 ";
41240 
41241 %feature("docstring")  casadi::FunctionInternal::get_partition(casadi_int
41242 iind, casadi_int oind, Sparsity &D1, Sparsity &D2, bool compact, bool
41243 symmetric, bool allow_forward, bool allow_reverse) const  "
41244 
41245 [INTERNAL]  Get the unidirectional or bidirectional partition.
41246 
41247 ";
41248 
41249 %feature("docstring")  casadi::FunctionInternal::eval_sx(const SXElem **arg,
41250 SXElem **res, casadi_int *iw, SXElem *w, void *mem) const  "
41251 
41252 [INTERNAL]  Evaluate with symbolic scalars.
41253 
41254 ";
41255 
41256 %feature("docstring")  casadi::FunctionInternal::get_free() const  "
41257 
41258 [INTERNAL]  Print free variables.
41259 
41260 ";
41261 
41262 %feature("docstring")  casadi::FunctionInternal::instruction_id(casadi_int
41263 k) const  "
41264 
41265 [INTERNAL]  Get an atomic operation operator index.
41266 
41267 ";
41268 
41269 %feature("docstring")  casadi::FunctionInternal::has_jacobian_sparsity()
41270 const  "
41271 
41272 [INTERNAL]  Get Jacobian sparsity.
41273 
41274 ";
41275 
41276 %feature("docstring")  casadi::FunctionInternal::convert_arg(const
41277 std::vector< M > &arg) const  "
41278 
41279 [INTERNAL]  Convert from/to input/output lists/map.
41280 
41281 ";
41282 
41283 %feature("docstring")  casadi::FunctionInternal::convert_arg(const std::map<
41284 std::string, M > &arg) const  "
41285 
41286 [INTERNAL]  Convert from/to input/output lists/map.
41287 
41288 ";
41289 
41290 %feature("docstring")  casadi::FunctionInternal::sz_w() const  "
41291 
41292 [INTERNAL]  Get required length of w field.
41293 
41294 ";
41295 
41296 %feature("docstring")  casadi::FunctionInternal::numel_in() const  "
41297 
41298 [INTERNAL]  Number of input/output elements.
41299 
41300 ";
41301 
41302 %feature("docstring")  casadi::FunctionInternal::numel_in(casadi_int ind)
41303 const  "
41304 
41305 [INTERNAL]  Number of input/output elements.
41306 
41307 ";
41308 
41309 %feature("docstring")  casadi::ProtoFunction::print_time(const std::map<
41310 std::string, FStats > &fstats) const  "
41311 
41312 [INTERNAL]  Print timing statistics.
41313 
41314 ";
41315 
41316 %feature("docstring")  casadi::FunctionInternal::generate_dependencies(const
41317 std::string &fname, const Dict &opts) const  "
41318 
41319 [INTERNAL]  Export / Generate C code for the dependency function.
41320 
41321 ";
41322 
41323 %feature("docstring")  casadi::FunctionInternal::uses_output() const  "
41324 
41325 [INTERNAL]  Do the derivative functions need nondifferentiated outputs?
41326 
41327 ";
41328 
41329 %feature("docstring")  casadi::FunctionInternal::replace_aseed(const
41330 std::vector< std::vector< M >> &aseed, casadi_int npar) const  "
41331 
41332 [INTERNAL]  Replace 0-by-0 reverse seeds.
41333 
41334 ";
41335 
41336 %feature("docstring")  casadi::FunctionInternal::replace_aseed(const
41337 std::vector< std::vector< M > > &aseed, casadi_int npar) const  "
41338 
41339 [INTERNAL] ";
41340 
41341 %feature("docstring")  casadi::FunctionInternal::mapsum_mx(const
41342 std::vector< MX > &arg, const std::string &parallelization) "
41343 
41344 [INTERNAL]  Parallel evaluation.
41345 
41346 ";
41347 
41348 %feature("docstring")  casadi::Interpolant::get_name_out(casadi_int i)  "
41349 
41350 [INTERNAL]  Names of function input and outputs.
41351 
41352 ";
41353 
41354 %feature("docstring")  casadi::FunctionInternal::codegen_name(const
41355 CodeGenerator &g, bool ns=true) const  "
41356 
41357 [INTERNAL]  Get name in codegen.
41358 
41359 ";
41360 
41361 %feature("docstring")  casadi::FunctionInternal::getAdaptorSolverName()
41362 const  "
41363 
41364 [INTERNAL]  Obtain solver name from Adaptor.
41365 
41366 ";
41367 
41368 %feature("docstring")  casadi::PluginInterface< Interpolant
41369 >::plugin_name() const  "
41370 
41371 [INTERNAL] ";
41372 
41373 %feature("docstring")  casadi::FunctionInternal::incache(const std::string
41374 &fname, Function &f, const std::string &suffix="") const  "
41375 
41376 [INTERNAL]  Get function in cache.
41377 
41378 ";
41379 
41380 %feature("docstring")  casadi::FunctionInternal::eval_gen(const double
41381 **arg, double **res, casadi_int *iw, double *w, void *mem) const  "
41382 
41383 [INTERNAL]  Evaluate numerically.
41384 
41385 ";
41386 
41387 %feature("docstring")  casadi::FunctionInternal::eval_gen(const SXElem
41388 **arg, SXElem **res, casadi_int *iw, SXElem *w, void *mem) const  "
41389 
41390 [INTERNAL]  Evaluate a function, overloaded.
41391 
41392 ";
41393 
41394 %feature("docstring")  casadi::FunctionInternal::eval_gen(const bvec_t
41395 **arg, bvec_t **res, casadi_int *iw, bvec_t *w, void *mem) const  "
41396 
41397 [INTERNAL]  Evaluate a function, overloaded.
41398 
41399 ";
41400 
41401 %feature("docstring")  casadi::Interpolant::init(const Dict &opts)  "
41402 
41403 [INTERNAL]  Initialize.
41404 
41405 ";
41406 
41407 %feature("docstring")  casadi::FunctionInternal::numel_out(casadi_int ind)
41408 const  "
41409 
41410 [INTERNAL]  Number of input/output elements.
41411 
41412 ";
41413 
41414 %feature("docstring")  casadi::FunctionInternal::numel_out() const  "
41415 
41416 [INTERNAL]  Number of input/output elements.
41417 
41418 ";
41419 
41420 %feature("docstring")  casadi::FunctionInternal::size2_out(casadi_int ind)
41421 const  "
41422 
41423 [INTERNAL]  Input/output dimensions.
41424 
41425 ";
41426 
41427 
41428 // File: classcasadi_1_1InterruptHandler.xml
41429 %feature("docstring") casadi::InterruptHandler "
41430 
41431 [INTERNAL]  Takes care of user interrupts (Ctrl+C)
41432 
41433 This is an internal class.
41434 
41435 Joris Gillis
41436 
41437 C++ includes: casadi_interrupt.hpp ";
41438 
41439 
41440 // File: classcasadi_1_1Inverse.xml
41441 
41442 
41443 // File: classcasadi_1_1IOInstruction.xml
41444 
41445 
41446 // File: classcasadi_1_1IpoptUserClass.xml
41447 %feature("docstring")  casadi::IpoptUserClass::get_starting_point(Index n,
41448 bool init_x, Number *x, bool init_z, Number *z_L, Number *z_U, Index m, bool
41449 init_lambda, Number *lambda)  "
41450 
41451 [INTERNAL]  Method to return the starting point for the algorithm
41452 
41453 ";
41454 
41455 %feature("docstring")
41456 casadi::IpoptUserClass::finalize_solution(SolverReturn status, Index n,
41457 const Number *x, const Number *z_L, const Number *z_U, Index m, const Number
41458 *g, const Number *lambda, Number obj_value, const IpoptData *ip_data,
41459 IpoptCalculatedQuantities *ip_cq)  "
41460 
41461 [INTERNAL]  This method is called when the algorithm is complete so the TNLP
41462 can store/write the solution
41463 
41464 ";
41465 
41466 %feature("docstring") casadi::IpoptUserClass "
41467 
41468 [INTERNAL] C++ includes: ipopt_nlp.hpp ";
41469 
41470 %feature("docstring")
41471 casadi::IpoptUserClass::get_list_of_nonlinear_variables(Index
41472 num_nonlin_vars, Index *pos_nonlin_vars)  "
41473 
41474 [INTERNAL]  Specify which variables that appear in the Hessian
41475 
41476 ";
41477 
41478 %feature("docstring")  casadi::IpoptUserClass::eval_grad_f(Index n, const
41479 Number *x, bool new_x, Number *grad_f)  "
41480 
41481 [INTERNAL]  Method to return the gradient of the objective
41482 
41483 ";
41484 
41485 %feature("docstring")  casadi::IpoptUserClass::get_var_con_metadata(Index n,
41486 StringMetaDataMapType &var_string_md, IntegerMetaDataMapType
41487 &var_integer_md, NumericMetaDataMapType &var_numeric_md, Index m,
41488 StringMetaDataMapType &con_string_md, IntegerMetaDataMapType
41489 &con_integer_md, NumericMetaDataMapType &con_numeric_md)  "
41490 
41491 [INTERNAL]  Allows setting information about variables and constraints
41492 
41493 ";
41494 
41495 %feature("docstring") casadi::IpoptUserClass::~IpoptUserClass "
41496 
41497 [INTERNAL] ";
41498 
41499 %feature("docstring")  casadi::IpoptUserClass::eval_g(Index n, const Number
41500 *x, bool new_x, Index m, Number *g)  "
41501 
41502 [INTERNAL]  Method to return the constraint residuals
41503 
41504 ";
41505 
41506 %feature("docstring")  casadi::IpoptUserClass::get_nlp_info(Index &n, Index
41507 &m, Index &nnz_jac_g, Index &nnz_h_lag, IndexStyleEnum &index_style)  "
41508 
41509 [INTERNAL]  Method to return some info about the nlp
41510 
41511 ";
41512 
41513 %feature("docstring")  casadi::IpoptUserClass::eval_f(Index n, const Number
41514 *x, bool new_x, Number &obj_value)  "
41515 
41516 [INTERNAL]  Method to return the objective value
41517 
41518 ";
41519 
41520 %feature("docstring")
41521 casadi::IpoptUserClass::get_number_of_nonlinear_variables()  "
41522 
41523 [INTERNAL]  Specify the number of variables that appear in the Hessian
41524 
41525 ";
41526 
41527 %feature("docstring")  casadi::IpoptUserClass::eval_jac_g(Index n, const
41528 Number *x, bool new_x, Index m, Index nele_jac, Index *iRow, Index *jCol,
41529 Number *values)  "
41530 
41531 [INTERNAL]  Method to return: 1) The structure of the Jacobian (if
41532 \"values\" is NULL) 2) The values of the Jacobian (if \"values\" is not
41533 NULL)
41534 
41535 ";
41536 
41537 %feature("docstring")  casadi::IpoptUserClass::finalize_metadata(Index n,
41538 const StringMetaDataMapType &var_string_md, const IntegerMetaDataMapType
41539 &var_integer_md, const NumericMetaDataMapType &var_numeric_md, Index m,
41540 const StringMetaDataMapType &con_string_md, const IntegerMetaDataMapType
41541 &con_integer_md, const NumericMetaDataMapType &con_numeric_md)  "
41542 
41543 [INTERNAL]  Retrieve information about variables and constraints
41544 
41545 ";
41546 
41547 %feature("docstring")  casadi::IpoptUserClass::get_bounds_info(Index n,
41548 Number *x_l, Number *x_u, Index m, Number *g_l, Number *g_u)  "
41549 
41550 [INTERNAL]  Method to return the bounds for my problem
41551 
41552 ";
41553 
41554 %feature("docstring")  casadi::IpoptUserClass::eval_h(Index n, const Number
41555 *x, bool new_x, Number obj_factor, Index m, const Number *lambda, bool
41556 new_lambda, Index nele_hess, Index *iRow, Index *jCol, Number *values)  "
41557 
41558 [INTERNAL]  Method to return: 1) The structure of the hessian of the
41559 Lagrangian (if \"values\" is NULL) 2) The values of the hessian of the
41560 Lagrangian (if \"values\" is not NULL)
41561 
41562 ";
41563 
41564 %feature("docstring")
41565 casadi::IpoptUserClass::intermediate_callback(AlgorithmMode mode, Index
41566 iter, Number obj_value, Number inf_pr, Number inf_du, Number mu, Number
41567 d_norm, Number regularization_size, Number alpha_du, Number alpha_pr, Index
41568 ls_trials, const IpoptData *ip_data, IpoptCalculatedQuantities *ip_cq)  "
41569 
41570 [INTERNAL]  This method is called at every iteration
41571 
41572 ";
41573 
41574 %feature("docstring") casadi::IpoptUserClass::IpoptUserClass(const
41575 IpoptInterface &solver, IpoptMemory *mem) "
41576 
41577 [INTERNAL] ";
41578 
41579 
41580 // File: classcasadi_1_1JitFunction.xml
41581 %feature("docstring")  casadi::FunctionInternal::convert_arg(const
41582 std::vector< M > &arg) const  "
41583 
41584 [INTERNAL]  Convert from/to input/output lists/map.
41585 
41586 ";
41587 
41588 %feature("docstring")  casadi::FunctionInternal::convert_arg(const std::map<
41589 std::string, M > &arg) const  "
41590 
41591 [INTERNAL]  Convert from/to input/output lists/map.
41592 
41593 ";
41594 
41595 %feature("docstring")
41596 casadi::FunctionInternal::codegen_incref(CodeGenerator &g) const  "
41597 
41598 [INTERNAL]  Codegen incref for dependencies.
41599 
41600 ";
41601 
41602 %feature("docstring")  casadi::FunctionInternal::project_arg(const
41603 std::vector< M > &arg, casadi_int npar) const  "
41604 
41605 [INTERNAL]   Project sparsities.
41606 
41607 ";
41608 
41609 %feature("docstring")  casadi::FunctionInternal::instruction_MX(casadi_int
41610 k) const  "
41611 
41612 [INTERNAL]  get MX expression associated with instruction
41613 
41614 ";
41615 
41616 %feature("docstring")  casadi::FunctionInternal::get_name_out(casadi_int i)
41617 "
41618 
41619 [INTERNAL]  Names of function input and outputs.
41620 
41621 ";
41622 
41623 %feature("docstring")  casadi::FunctionInternal::has_sprev() const  "
41624 
41625 [INTERNAL]  Is the class able to propagate seeds through the algorithm?
41626 
41627 ";
41628 
41629 %feature("docstring")  casadi::FunctionInternal::size1_out(casadi_int ind)
41630 const  "
41631 
41632 [INTERNAL]  Input/output dimensions.
41633 
41634 ";
41635 
41636 %feature("docstring")  casadi::FunctionInternal::sp_forward(const bvec_t
41637 **arg, bvec_t **res, casadi_int *iw, bvec_t *w, void *mem) const  "
41638 
41639 [INTERNAL]  Propagate sparsity forward.
41640 
41641 ";
41642 
41643 %feature("docstring")  casadi::FunctionInternal::free_sx() const  "
41644 
41645 [INTERNAL]  Get free variables (SX)
41646 
41647 ";
41648 
41649 %feature("docstring")  casadi::JitFunction::get_n_in()  "
41650 
41651 [INTERNAL]  Number of function inputs and outputs.
41652 
41653 ";
41654 
41655 %feature("docstring")  casadi::FunctionInternal::check_res(const
41656 std::vector< M > &res, casadi_int &npar) const  "
41657 
41658 [INTERNAL]  Check if output arguments have correct length and dimensions.
41659 
41660 Raises errors.
41661 
41662 Parameters:
41663 -----------
41664 
41665 npar[in]:  normal usage: 1, disallow pararallel calls: -1
41666 
41667 npar:  max number of horizontal repetitions across all arguments (or -1)
41668 
41669 ";
41670 
41671 %feature("docstring")  casadi::JitFunction::get_options() const  "
41672 
41673 [INTERNAL]  Options.
41674 
41675 ";
41676 
41677 %feature("docstring")  casadi::FunctionInternal::oracle() const  "
41678 
41679 [INTERNAL]  Get oracle.
41680 
41681 ";
41682 
41683 %feature("docstring")
41684 casadi::FunctionInternal::serialize_type(SerializingStream &s) const  "
41685 
41686 [INTERNAL]  Serialize type information.
41687 
41688 ";
41689 
41690 %feature("docstring")  casadi::ProtoFunction::format_time(char *buffer,
41691 double time) const  "
41692 
41693 [INTERNAL]  Format time in a fixed width 8 format.
41694 
41695 ";
41696 
41697 %feature("docstring")  casadi::FunctionInternal::has_function(const
41698 std::string &fname) const  "
41699 
41700 [INTERNAL] ";
41701 
41702 %feature("docstring")  casadi::FunctionInternal::codegen(CodeGenerator &g,
41703 const std::string &fname) const  "
41704 
41705 [INTERNAL]  Generate code the function.
41706 
41707 ";
41708 
41709 %feature("docstring")  casadi::FunctionInternal::symbolic_output(const
41710 std::vector< MX > &arg) const  "
41711 
41712 [INTERNAL]  Get a vector of symbolic variables corresponding to the outputs.
41713 
41714 ";
41715 
41716 %feature("docstring")  casadi::FunctionInternal::get_function() const  "
41717 
41718 [INTERNAL] ";
41719 
41720 %feature("docstring")  casadi::FunctionInternal::get_function(const
41721 std::string &name) const  "
41722 
41723 [INTERNAL] ";
41724 
41725 %feature("docstring")  casadi::FunctionInternal::fwd_seed(casadi_int nfwd)
41726 const  "
41727 
41728 [INTERNAL]  Symbolic expressions for the forward seeds.
41729 
41730 ";
41731 
41732 %feature("docstring")
41733 casadi::FunctionInternal::codegen_alloc_mem(CodeGenerator &g) const  "
41734 
41735 [INTERNAL]  Codegen decref for alloc_mem.
41736 
41737 ";
41738 
41739 %feature("docstring")  casadi::FunctionInternal::free_mx() const  "
41740 
41741 [INTERNAL]  Get free variables ( MX)
41742 
41743 ";
41744 
41745 %feature("docstring")  casadi::FunctionInternal::eval(const double **arg,
41746 double **res, casadi_int *iw, double *w, void *mem) const  "
41747 
41748 [INTERNAL]  Evaluate numerically.
41749 
41750 ";
41751 
41752 %feature("docstring")  casadi::FunctionInternal::codegen_mem(CodeGenerator
41753 &g, const std::string &index="mem") const  "
41754 
41755 [INTERNAL]  Get thread-local memory object.
41756 
41757 ";
41758 
41759 %feature("docstring")  casadi::ProtoFunction::clear_mem() "
41760 
41761 [INTERNAL]  Clear all memory (called from destructor)
41762 
41763 ";
41764 
41765 %feature("docstring")  casadi::FunctionInternal::sz_w() const  "
41766 
41767 [INTERNAL]  Get required length of w field.
41768 
41769 ";
41770 
41771 %feature("docstring")  casadi::FunctionInternal::sz_arg() const  "
41772 
41773 [INTERNAL]  Get required length of arg field.
41774 
41775 ";
41776 
41777 %feature("docstring")  casadi::FunctionInternal::n_nodes() const  "
41778 
41779 [INTERNAL]  Number of nodes in the algorithm.
41780 
41781 ";
41782 
41783 %feature("docstring") casadi::JitFunction "
41784 
41785 [INTERNAL]
41786 
41787 >List of available options
41788 
41789 +------------------+-----------------+------------------+------------------+
41790 |        Id        |      Type       |   Description    |     Used in      |
41791 +==================+=================+==================+==================+
41792 | ad_weight        | OT_DOUBLE       | Weighting factor | casadi::Function |
41793 |                  |                 | for derivative   | Internal         |
41794 |                  |                 | calculation.When |                  |
41795 |                  |                 | there is an      |                  |
41796 |                  |                 | option of either |                  |
41797 |                  |                 | using forward or |                  |
41798 |                  |                 | reverse mode     |                  |
41799 |                  |                 | directional      |                  |
41800 |                  |                 | derivatives, the |                  |
41801 |                  |                 | condition ad_wei |                  |
41802 |                  |                 | ght*nf<=(1-ad_we |                  |
41803 |                  |                 | ight)*na is used |                  |
41804 |                  |                 | where nf and na  |                  |
41805 |                  |                 | are estimates of |                  |
41806 |                  |                 | the number of    |                  |
41807 |                  |                 | forward/reverse  |                  |
41808 |                  |                 | mode directional |                  |
41809 |                  |                 | derivatives      |                  |
41810 |                  |                 | needed. By       |                  |
41811 |                  |                 | default,         |                  |
41812 |                  |                 | ad_weight is     |                  |
41813 |                  |                 | calculated       |                  |
41814 |                  |                 | automatically,   |                  |
41815 |                  |                 | but this can be  |                  |
41816 |                  |                 | overridden by    |                  |
41817 |                  |                 | setting this     |                  |
41818 |                  |                 | option. In       |                  |
41819 |                  |                 | particular, 0    |                  |
41820 |                  |                 | means forcing    |                  |
41821 |                  |                 | forward mode and |                  |
41822 |                  |                 | 1 forcing        |                  |
41823 |                  |                 | reverse mode.    |                  |
41824 |                  |                 | Leave unset for  |                  |
41825 |                  |                 | (class specific) |                  |
41826 |                  |                 | heuristics.      |                  |
41827 +------------------+-----------------+------------------+------------------+
41828 | ad_weight_sp     | OT_DOUBLE       | Weighting factor | casadi::Function |
41829 |                  |                 | for sparsity     | Internal         |
41830 |                  |                 | pattern          |                  |
41831 |                  |                 | calculation calc |                  |
41832 |                  |                 | ulation.Override |                  |
41833 |                  |                 | s default        |                  |
41834 |                  |                 | behavior. Set to |                  |
41835 |                  |                 | 0 and 1 to force |                  |
41836 |                  |                 | forward and      |                  |
41837 |                  |                 | reverse mode     |                  |
41838 |                  |                 | respectively.    |                  |
41839 |                  |                 | Cf. option       |                  |
41840 |                  |                 | \"ad_weight\".     |                  |
41841 |                  |                 | When set to -1,  |                  |
41842 |                  |                 | sparsity is      |                  |
41843 |                  |                 | completely       |                  |
41844 |                  |                 | ignored and      |                  |
41845 |                  |                 | dense matrices   |                  |
41846 |                  |                 | are used.        |                  |
41847 +------------------+-----------------+------------------+------------------+
41848 | always_inline    | OT_BOOL         | Force inlining.  | casadi::Function |
41849 |                  |                 |                  | Internal         |
41850 +------------------+-----------------+------------------+------------------+
41851 | buffered         | OT_BOOL         | Buffer the       | casadi::JitFunct |
41852 |                  |                 | calls, user does | ion              |
41853 |                  |                 | not need to      |                  |
41854 +------------------+-----------------+------------------+------------------+
41855 | compiler         | OT_STRING       | Just-in-time     | casadi::Function |
41856 |                  |                 | compiler plugin  | Internal         |
41857 |                  |                 | to be used.      |                  |
41858 +------------------+-----------------+------------------+------------------+
41859 | custom_jacobian  | OT_FUNCTION     | Override         | casadi::Function |
41860 |                  |                 | CasADi's AD. Use | Internal         |
41861 |                  |                 | together with    |                  |
41862 |                  |                 | 'jac_penalty':   |                  |
41863 |                  |                 | 0. Note: Highly  |                  |
41864 |                  |                 | experimental.    |                  |
41865 |                  |                 | Syntax may break |                  |
41866 |                  |                 | often.           |                  |
41867 +------------------+-----------------+------------------+------------------+
41868 | derivative_of    | OT_FUNCTION     | The function is  | casadi::Function |
41869 |                  |                 | a derivative of  | Internal         |
41870 |                  |                 | another          |                  |
41871 |                  |                 | function. The    |                  |
41872 |                  |                 | type of          |                  |
41873 |                  |                 | derivative       |                  |
41874 |                  |                 | (directional     |                  |
41875 |                  |                 | derivative,      |                  |
41876 |                  |                 | Jacobian) is     |                  |
41877 |                  |                 | inferred from    |                  |
41878 |                  |                 | the function     |                  |
41879 |                  |                 | name.            |                  |
41880 +------------------+-----------------+------------------+------------------+
41881 | dump             | OT_BOOL         | Dump function to | casadi::Function |
41882 |                  |                 | file upon first  | Internal         |
41883 |                  |                 | evaluation.      |                  |
41884 |                  |                 | [false]          |                  |
41885 +------------------+-----------------+------------------+------------------+
41886 | dump_dir         | OT_STRING       | Directory to     | casadi::Function |
41887 |                  |                 | dump             | Internal         |
41888 |                  |                 | inputs/outputs   |                  |
41889 |                  |                 | to. Make sure    |                  |
41890 |                  |                 | the directory    |                  |
41891 |                  |                 | exists [.]       |                  |
41892 +------------------+-----------------+------------------+------------------+
41893 | dump_format      | OT_STRING       | Choose file      | casadi::Function |
41894 |                  |                 | format to dump   | Internal         |
41895 |                  |                 | matrices. See    |                  |
41896 |                  |                 | DM.from_file     |                  |
41897 |                  |                 | [mtx]            |                  |
41898 +------------------+-----------------+------------------+------------------+
41899 | dump_in          | OT_BOOL         | Dump numerical   | casadi::Function |
41900 |                  |                 | values of inputs | Internal         |
41901 |                  |                 | to file          |                  |
41902 |                  |                 | (readable with   |                  |
41903 |                  |                 | DM.from_file )   |                  |
41904 |                  |                 | [default: false] |                  |
41905 +------------------+-----------------+------------------+------------------+
41906 | dump_out         | OT_BOOL         | Dump numerical   | casadi::Function |
41907 |                  |                 | values of        | Internal         |
41908 |                  |                 | outputs to file  |                  |
41909 |                  |                 | (readable with   |                  |
41910 |                  |                 | DM.from_file )   |                  |
41911 |                  |                 | [default: false] |                  |
41912 +------------------+-----------------+------------------+------------------+
41913 | enable_fd        | OT_BOOL         | Enable           | casadi::Function |
41914 |                  |                 | derivative       | Internal         |
41915 |                  |                 | calculation by   |                  |
41916 |                  |                 | finite           |                  |
41917 |                  |                 | differencing.    |                  |
41918 |                  |                 | [default:        |                  |
41919 |                  |                 | false]]          |                  |
41920 +------------------+-----------------+------------------+------------------+
41921 | enable_forward   | OT_BOOL         | Enable           | casadi::Function |
41922 |                  |                 | derivative       | Internal         |
41923 |                  |                 | calculation      |                  |
41924 |                  |                 | using generated  |                  |
41925 |                  |                 | functions for    |                  |
41926 |                  |                 | Jacobian-times-  |                  |
41927 |                  |                 | vector products  |                  |
41928 |                  |                 | - typically      |                  |
41929 |                  |                 | using forward    |                  |
41930 |                  |                 | mode AD - if     |                  |
41931 |                  |                 | available.       |                  |
41932 |                  |                 | [default: true]  |                  |
41933 +------------------+-----------------+------------------+------------------+
41934 | enable_jacobian  | OT_BOOL         | Enable           | casadi::Function |
41935 |                  |                 | derivative       | Internal         |
41936 |                  |                 | calculation      |                  |
41937 |                  |                 | using generated  |                  |
41938 |                  |                 | functions for    |                  |
41939 |                  |                 | Jacobians of all |                  |
41940 |                  |                 | differentiable   |                  |
41941 |                  |                 | outputs with     |                  |
41942 |                  |                 | respect to all   |                  |
41943 |                  |                 | differentiable   |                  |
41944 |                  |                 | inputs - if      |                  |
41945 |                  |                 | available.       |                  |
41946 |                  |                 | [default: true]  |                  |
41947 +------------------+-----------------+------------------+------------------+
41948 | enable_reverse   | OT_BOOL         | Enable           | casadi::Function |
41949 |                  |                 | derivative       | Internal         |
41950 |                  |                 | calculation      |                  |
41951 |                  |                 | using generated  |                  |
41952 |                  |                 | functions for    |                  |
41953 |                  |                 | transposed       |                  |
41954 |                  |                 | Jacobian-times-  |                  |
41955 |                  |                 | vector products  |                  |
41956 |                  |                 | - typically      |                  |
41957 |                  |                 | using reverse    |                  |
41958 |                  |                 | mode AD - if     |                  |
41959 |                  |                 | available.       |                  |
41960 |                  |                 | [default: true]  |                  |
41961 +------------------+-----------------+------------------+------------------+
41962 | fd_method        | OT_STRING       | Method for       | casadi::Function |
41963 |                  |                 | finite           | Internal         |
41964 |                  |                 | differencing     |                  |
41965 |                  |                 | [default         |                  |
41966 |                  |                 | 'central']       |                  |
41967 +------------------+-----------------+------------------+------------------+
41968 | fd_options       | OT_DICT         | Options to be    | casadi::Function |
41969 |                  |                 | passed to the    | Internal         |
41970 |                  |                 | finite           |                  |
41971 |                  |                 | difference       |                  |
41972 |                  |                 | instance         |                  |
41973 +------------------+-----------------+------------------+------------------+
41974 | forward_options  | OT_DICT         | Options to be    | casadi::Function |
41975 |                  |                 | passed to a      | Internal         |
41976 |                  |                 | forward mode     |                  |
41977 |                  |                 | constructor      |                  |
41978 +------------------+-----------------+------------------+------------------+
41979 | gather_stats     | OT_BOOL         | Deprecated       | casadi::Function |
41980 |                  |                 | option           | Internal         |
41981 |                  |                 | (ignored):       |                  |
41982 |                  |                 | Statistics are   |                  |
41983 |                  |                 | now always       |                  |
41984 |                  |                 | collected.       |                  |
41985 +------------------+-----------------+------------------+------------------+
41986 | hess             | OT_STRING       | Function body    | casadi::JitFunct |
41987 |                  |                 | for Hessian      | ion              |
41988 +------------------+-----------------+------------------+------------------+
41989 | input_scheme     | OT_STRINGVECTOR | Deprecated       | casadi::Function |
41990 |                  |                 | option (ignored) | Internal         |
41991 +------------------+-----------------+------------------+------------------+
41992 | inputs_check     | OT_BOOL         | Throw exceptions | casadi::Function |
41993 |                  |                 | when the         | Internal         |
41994 |                  |                 | numerical values |                  |
41995 |                  |                 | of the inputs    |                  |
41996 |                  |                 | don't make sense |                  |
41997 +------------------+-----------------+------------------+------------------+
41998 | is_diff_in       | OT_BOOLVECTOR   | Indicate for     | casadi::Function |
41999 |                  |                 | each input if it | Internal         |
42000 |                  |                 | should be        |                  |
42001 |                  |                 | differentiable.  |                  |
42002 +------------------+-----------------+------------------+------------------+
42003 | is_diff_out      | OT_BOOLVECTOR   | Indicate for     | casadi::Function |
42004 |                  |                 | each output if   | Internal         |
42005 |                  |                 | it should be     |                  |
42006 |                  |                 | differentiable.  |                  |
42007 +------------------+-----------------+------------------+------------------+
42008 | jac              | OT_STRING       | Function body    | casadi::JitFunct |
42009 |                  |                 | for Jacobian     | ion              |
42010 +------------------+-----------------+------------------+------------------+
42011 | jac_penalty      | OT_DOUBLE       | When requested   | casadi::Function |
42012 |                  |                 | for a number of  | Internal         |
42013 |                  |                 | forward/reverse  |                  |
42014 |                  |                 | directions, it   |                  |
42015 |                  |                 | may be cheaper   |                  |
42016 |                  |                 | to compute first |                  |
42017 |                  |                 | the full         |                  |
42018 |                  |                 | jacobian and     |                  |
42019 |                  |                 | then multiply    |                  |
42020 |                  |                 | with seeds,      |                  |
42021 |                  |                 | rather than      |                  |
42022 |                  |                 | obtain the       |                  |
42023 |                  |                 | requested        |                  |
42024 |                  |                 | directions in a  |                  |
42025 |                  |                 | straightforward  |                  |
42026 |                  |                 | manner. Casadi   |                  |
42027 |                  |                 | uses a heuristic |                  |
42028 |                  |                 | to decide which  |                  |
42029 |                  |                 | is cheaper. A    |                  |
42030 |                  |                 | high value of    |                  |
42031 |                  |                 | 'jac_penalty'    |                  |
42032 |                  |                 | makes it less    |                  |
42033 |                  |                 | likely for the   |                  |
42034 |                  |                 | heurstic to      |                  |
42035 |                  |                 | chose the full   |                  |
42036 |                  |                 | Jacobian         |                  |
42037 |                  |                 | strategy. The    |                  |
42038 |                  |                 | special value -1 |                  |
42039 |                  |                 | indicates never  |                  |
42040 |                  |                 | to use the full  |                  |
42041 |                  |                 | Jacobian         |                  |
42042 |                  |                 | strategy         |                  |
42043 +------------------+-----------------+------------------+------------------+
42044 | jit              | OT_BOOL         | Use just-in-time | casadi::Function |
42045 |                  |                 | compiler to      | Internal         |
42046 |                  |                 | speed up the     |                  |
42047 |                  |                 | evaluation       |                  |
42048 +------------------+-----------------+------------------+------------------+
42049 | jit_cleanup      | OT_BOOL         | Cleanup up the   | casadi::Function |
42050 |                  |                 | temporary source | Internal         |
42051 |                  |                 | file that jit    |                  |
42052 |                  |                 | creates.         |                  |
42053 |                  |                 | Default: true    |                  |
42054 +------------------+-----------------+------------------+------------------+
42055 | jit_name         | OT_STRING       | The file name    | casadi::Function |
42056 |                  |                 | used to write    | Internal         |
42057 |                  |                 | out code. The    |                  |
42058 |                  |                 | actual file      |                  |
42059 |                  |                 | names used       |                  |
42060 |                  |                 | depend on 'jit_t |                  |
42061 |                  |                 | emp_suffix' and  |                  |
42062 |                  |                 | include          |                  |
42063 |                  |                 | extensions.      |                  |
42064 |                  |                 | Default:         |                  |
42065 |                  |                 | 'jit_tmp'        |                  |
42066 +------------------+-----------------+------------------+------------------+
42067 | jit_options      | OT_DICT         | Options to be    | casadi::Function |
42068 |                  |                 | passed to the    | Internal         |
42069 |                  |                 | jit compiler.    |                  |
42070 +------------------+-----------------+------------------+------------------+
42071 | jit_serialize    | OT_STRING       | Specify          | casadi::Function |
42072 |                  |                 | behaviour when   | Internal         |
42073 |                  |                 | serializing a    |                  |
42074 |                  |                 | jitted function: |                  |
42075 |                  |                 | SOURCE|link|embe |                  |
42076 |                  |                 | d.               |                  |
42077 +------------------+-----------------+------------------+------------------+
42078 | jit_temp_suffix  | OT_BOOL         | Use a temporary  | casadi::Function |
42079 |                  |                 | (seemingly       | Internal         |
42080 |                  |                 | random) filename |                  |
42081 |                  |                 | suffix for       |                  |
42082 |                  |                 | generated code   |                  |
42083 |                  |                 | and libraries.   |                  |
42084 |                  |                 | This is desired  |                  |
42085 |                  |                 | for thread-      |                  |
42086 |                  |                 | safety. This     |                  |
42087 |                  |                 | behaviour may    |                  |
42088 |                  |                 | defeat caching   |                  |
42089 |                  |                 | compiler         |                  |
42090 |                  |                 | wrappers.        |                  |
42091 |                  |                 | Default: true    |                  |
42092 +------------------+-----------------+------------------+------------------+
42093 | max_num_dir      | OT_INT          | Specify the      | casadi::Function |
42094 |                  |                 | maximum number   | Internal         |
42095 |                  |                 | of directions    |                  |
42096 |                  |                 | for derivative   |                  |
42097 |                  |                 | functions.       |                  |
42098 |                  |                 | Overrules the    |                  |
42099 |                  |                 | builtin optimize |                  |
42100 |                  |                 | d_num_dir.       |                  |
42101 +------------------+-----------------+------------------+------------------+
42102 | never_inline     | OT_BOOL         | Forbid inlining. | casadi::Function |
42103 |                  |                 |                  | Internal         |
42104 +------------------+-----------------+------------------+------------------+
42105 | output_scheme    | OT_STRINGVECTOR | Deprecated       | casadi::Function |
42106 |                  |                 | option (ignored) | Internal         |
42107 +------------------+-----------------+------------------+------------------+
42108 | print_in         | OT_BOOL         | Print numerical  | casadi::Function |
42109 |                  |                 | values of inputs | Internal         |
42110 |                  |                 | [default: false] |                  |
42111 +------------------+-----------------+------------------+------------------+
42112 | print_out        | OT_BOOL         | Print numerical  | casadi::Function |
42113 |                  |                 | values of        | Internal         |
42114 |                  |                 | outputs          |                  |
42115 |                  |                 | [default: false] |                  |
42116 +------------------+-----------------+------------------+------------------+
42117 | print_time       | OT_BOOL         | print            | casadi::Function |
42118 |                  |                 | information      | Internal         |
42119 |                  |                 | about execution  |                  |
42120 |                  |                 | time. Implies    |                  |
42121 |                  |                 | record_time.     |                  |
42122 +------------------+-----------------+------------------+------------------+
42123 | record_time      | OT_BOOL         | record           | casadi::Function |
42124 |                  |                 | information      | Internal         |
42125 |                  |                 | about execution  |                  |
42126 |                  |                 | time, for        |                  |
42127 |                  |                 | retrieval with   |                  |
42128 |                  |                 | stats().         |                  |
42129 +------------------+-----------------+------------------+------------------+
42130 | regularity_check | OT_BOOL         | Throw exceptions | casadi::Function |
42131 |                  |                 | when NaN or Inf  | Internal         |
42132 |                  |                 | appears during   |                  |
42133 |                  |                 | evaluation       |                  |
42134 +------------------+-----------------+------------------+------------------+
42135 | reverse_options  | OT_DICT         | Options to be    | casadi::Function |
42136 |                  |                 | passed to a      | Internal         |
42137 |                  |                 | reverse mode     |                  |
42138 |                  |                 | constructor      |                  |
42139 +------------------+-----------------+------------------+------------------+
42140 | user_data        | OT_VOIDPTR      | A user-defined   | casadi::Function |
42141 |                  |                 | field that can   | Internal         |
42142 |                  |                 | be used to       |                  |
42143 |                  |                 | identify the     |                  |
42144 |                  |                 | function or pass |                  |
42145 |                  |                 | additional       |                  |
42146 |                  |                 | information      |                  |
42147 +------------------+-----------------+------------------+------------------+
42148 | verbose          | OT_BOOL         | Verbose          | casadi::Function |
42149 |                  |                 | evaluation  for  | Internal         |
42150 |                  |                 | debugging        |                  |
42151 +------------------+-----------------+------------------+------------------+
42152 
42153 Diagrams
42154 --------
42155 
42156 
42157 
42158 C++ includes: jit_function.hpp ";
42159 
42160 %feature("docstring")  casadi::FunctionInternal::generate_in(const
42161 std::string &fname, const double **arg) const  "
42162 
42163 [INTERNAL]  Export an input file that can be passed to generate C code with
42164 a main.
42165 
42166 ";
42167 
42168 %feature("docstring")
42169 casadi::FunctionInternal::instruction_output(casadi_int k) const  "
42170 
42171 [INTERNAL]  Get the (integer) output argument of an atomic operation.
42172 
42173 ";
42174 
42175 %feature("docstring")  casadi::ProtoFunction::checkout() const  "
42176 
42177 [INTERNAL]  Checkout a memory object.
42178 
42179 ";
42180 
42181 %feature("docstring")  casadi::JitFunction::has_codegen() const  "
42182 
42183 [INTERNAL]  Is codegen supported?
42184 
42185 ";
42186 
42187 %feature("docstring")  casadi::FunctionInternal::numel_out(casadi_int ind)
42188 const  "
42189 
42190 [INTERNAL]  Number of input/output elements.
42191 
42192 ";
42193 
42194 %feature("docstring")  casadi::FunctionInternal::numel_out() const  "
42195 
42196 [INTERNAL]  Number of input/output elements.
42197 
42198 ";
42199 
42200 %feature("docstring")  casadi::FunctionInternal::generate_out(const
42201 std::string &fname, double **res) const  "
42202 
42203 [INTERNAL] ";
42204 
42205 %feature("docstring")  casadi::FunctionInternal::sp_reverse(bvec_t **arg,
42206 bvec_t **res, casadi_int *iw, bvec_t *w, void *mem) const  "
42207 
42208 [INTERNAL]  Propagate sparsity backwards.
42209 
42210 ";
42211 
42212 %feature("docstring")  casadi::FunctionInternal::get_free() const  "
42213 
42214 [INTERNAL]  Print free variables.
42215 
42216 ";
42217 
42218 %feature("docstring")  casadi::FunctionInternal::get_reltol() const  "
42219 
42220 [INTERNAL]  Get relative tolerance.
42221 
42222 ";
42223 
42224 %feature("docstring")  casadi::SharedObjectInternal::getCount() const  "
42225 
42226 [INTERNAL]  Get the reference count.
42227 
42228 ";
42229 
42230 %feature("docstring")
42231 casadi::FunctionInternal::getJacSparsityHierarchical(casadi_int iind,
42232 casadi_int oind) const  "
42233 
42234 [INTERNAL]  A flavor of getJacSparsity that does hierarchical block
42235 structure recognition.
42236 
42237 ";
42238 
42239 %feature("docstring")  casadi::ProtoFunction::serialize_base_function()
42240 const  "
42241 
42242 [INTERNAL]  String used to identify the immediate FunctionInternal subclass.
42243 
42244 ";
42245 
42246 %feature("docstring")  casadi::FunctionInternal::jacobian_sparsity() const
42247 "
42248 
42249 [INTERNAL]  Get Jacobian sparsity.
42250 
42251 ";
42252 
42253 %feature("docstring")  casadi::FunctionInternal::has_derivative() const  "
42254 
42255 [INTERNAL]  Can derivatives be calculated in any way?
42256 
42257 ";
42258 
42259 %feature("docstring")
42260 casadi::FunctionInternal::jacobian_sparsity_filter(const Sparsity &sp) const
42261 "
42262 
42263 [INTERNAL]  Filter out nonzeros in the full sparsity jacobian according to
42264 is_diff_in/out.
42265 
42266 ";
42267 
42268 %feature("docstring")  casadi::ProtoFunction::get_stats(void *mem) const  "
42269 
42270 [INTERNAL]  Get all statistics.
42271 
42272 ";
42273 
42274 %feature("docstring")  casadi::FunctionInternal::info() const  "
42275 
42276 [INTERNAL]  Obtain information about function
42277 
42278 ";
42279 
42280 %feature("docstring")
42281 casadi::FunctionInternal::getJacSparsityHierarchicalSymm(casadi_int iind,
42282 casadi_int oind) const  "
42283 
42284 [INTERNAL]  A flavor of getJacSparsity that does hierarchical block
42285 structure recognition for symmetric Jacobians
42286 
42287 ";
42288 
42289 %feature("docstring")  casadi::FunctionInternal::jit_dependencies(const
42290 std::string &fname) "
42291 
42292 [INTERNAL]  Jit dependencies.
42293 
42294 ";
42295 
42296 %feature("docstring")  casadi::FunctionInternal::sparsity_in(casadi_int ind)
42297 const  "
42298 
42299 [INTERNAL]  Input/output sparsity.
42300 
42301 ";
42302 
42303 %feature("docstring")  casadi::FunctionInternal::print_options(std::ostream
42304 &stream) const  "
42305 
42306 [INTERNAL]  Print list of options.
42307 
42308 ";
42309 
42310 %feature("docstring") casadi::JitFunction::JitFunction(const std::string
42311 &name, const std::string &body, const std::vector< std::string > &name_in,
42312 const std::vector< std::string > &name_out, const std::vector< Sparsity >
42313 &sparsity_in, const std::vector< Sparsity > &sparsity_out) "
42314 
42315 [INTERNAL]  Constructor.
42316 
42317 ";
42318 
42319 %feature("docstring")  casadi::ProtoFunction::release(int mem) const  "
42320 
42321 [INTERNAL]  Release a memory object.
42322 
42323 ";
42324 
42325 %feature("docstring")  casadi::FunctionInternal::nz_in(const std::vector< DM
42326 > &arg) const  "
42327 
42328 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
42329 
42330 ";
42331 
42332 %feature("docstring")  casadi::FunctionInternal::nz_in(const std::vector<
42333 double > &arg) const  "
42334 
42335 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
42336 
42337 ";
42338 
42339 %feature("docstring")  casadi::ProtoFunction::construct(const Dict &opts) "
42340 
42341 [INTERNAL]  Construct Prepares the function for evaluation.
42342 
42343 ";
42344 
42345 %feature("docstring")  casadi::FunctionInternal::dm_in(casadi_int ind) const
42346 "
42347 
42348 [INTERNAL]  Get function input(s) and output(s)
42349 
42350 ";
42351 
42352 %feature("docstring")  casadi::FunctionInternal::dm_in() const  "
42353 
42354 [INTERNAL]  Get function input(s) and output(s)
42355 
42356 ";
42357 
42358 %feature("docstring")  casadi::FunctionInternal::eval_sx(const SXElem **arg,
42359 SXElem **res, casadi_int *iw, SXElem *w, void *mem) const  "
42360 
42361 [INTERNAL]  Evaluate with symbolic scalars.
42362 
42363 ";
42364 
42365 %feature("docstring")  casadi::FunctionInternal::size_in(casadi_int ind)
42366 const  "
42367 
42368 [INTERNAL]  Input/output dimensions.
42369 
42370 ";
42371 
42372 %feature("docstring")  casadi::FunctionInternal::get_max_in(casadi_int ind)
42373 const  "
42374 
42375 [INTERNAL]  Get largest input value.
42376 
42377 ";
42378 
42379 %feature("docstring")  casadi::JitFunction::init(const Dict &opts)  "
42380 
42381 [INTERNAL]  Initialize.
42382 
42383 ";
42384 
42385 %feature("docstring")  casadi::FunctionInternal::has_jacobian_sparsity()
42386 const  "
42387 
42388 [INTERNAL]  Get Jacobian sparsity.
42389 
42390 ";
42391 
42392 %feature("docstring")  casadi::FunctionInternal::sparsity_out(casadi_int
42393 ind) const  "
42394 
42395 [INTERNAL]  Input/output sparsity.
42396 
42397 ";
42398 
42399 %feature("docstring")  casadi::FunctionInternal::get_default_in(casadi_int
42400 ind) const  "
42401 
42402 [INTERNAL]  Get default input value.
42403 
42404 ";
42405 
42406 %feature("docstring")  casadi::FunctionInternal::project_res(const
42407 std::vector< M > &arg, casadi_int npar) const  "
42408 
42409 [INTERNAL]   Project sparsities.
42410 
42411 ";
42412 
42413 %feature("docstring")  casadi::ProtoFunction::alloc_mem() const  "
42414 
42415 [INTERNAL]  Create memory block.
42416 
42417 ";
42418 
42419 %feature("docstring")  casadi::FunctionInternal::wrap() const  "
42420 
42421 [INTERNAL]  Wrap in an Function instance consisting of only one MX call.
42422 
42423 ";
42424 
42425 %feature("docstring")  casadi::ProtoFunction::serialize(SerializingStream
42426 &s) const  "
42427 
42428 [INTERNAL]  Serialize an object.
42429 
42430 ";
42431 
42432 %feature("docstring")
42433 casadi::FunctionInternal::instruction_constant(casadi_int k) const  "
42434 
42435 [INTERNAL]  Get the floating point output argument of an atomic operation.
42436 
42437 ";
42438 
42439 %feature("docstring")  casadi::FunctionInternal::mx_out(casadi_int ind)
42440 const  "
42441 
42442 [INTERNAL]  Get function input(s) and output(s)
42443 
42444 ";
42445 
42446 %feature("docstring")  casadi::FunctionInternal::mx_out() const  "
42447 
42448 [INTERNAL]  Get function input(s) and output(s)
42449 
42450 ";
42451 
42452 %feature("docstring")  casadi::JitFunction::codegen_body(CodeGenerator &g)
42453 const  "
42454 
42455 [INTERNAL]  Generate code for the function body.
42456 
42457 ";
42458 
42459 %feature("docstring")  casadi::FunctionInternal::alloc(const Function &f,
42460 bool persistent=false) "
42461 
42462 [INTERNAL]  Ensure work vectors long enough to evaluate function.
42463 
42464 ";
42465 
42466 %feature("docstring")  casadi::FunctionInternal::map(casadi_int n, const
42467 std::string &parallelization) const  "
42468 
42469 [INTERNAL]  Generate/retrieve cached serial map.
42470 
42471 ";
42472 
42473 %feature("docstring")  casadi::FunctionInternal::instructions_sx() const  "
42474 
42475 [INTERNAL]  get SX expression associated with instructions
42476 
42477 ";
42478 
42479 %feature("docstring")  casadi::FunctionInternal::mapsum_mx(const
42480 std::vector< MX > &arg, const std::string &parallelization) "
42481 
42482 [INTERNAL]  Parallel evaluation.
42483 
42484 ";
42485 
42486 %feature("docstring")  casadi::FunctionInternal::generate_dependencies(const
42487 std::string &fname, const Dict &opts) const  "
42488 
42489 [INTERNAL]  Export / Generate C code for the dependency function.
42490 
42491 ";
42492 
42493 %feature("docstring")  casadi::FunctionInternal::dm_out(casadi_int ind)
42494 const  "
42495 
42496 [INTERNAL]  Get function input(s) and output(s)
42497 
42498 ";
42499 
42500 %feature("docstring")  casadi::FunctionInternal::dm_out() const  "
42501 
42502 [INTERNAL]  Get function input(s) and output(s)
42503 
42504 ";
42505 
42506 %feature("docstring")  casadi::FunctionInternal::forward(casadi_int nfwd)
42507 const  "
42508 
42509 [INTERNAL]  Return function that calculates forward derivatives
42510 forward(nfwd) returns a cached instance if available, and calls  Function
42511 get_forward(casadi_int nfwd) if no cached version is available.
42512 
42513 ";
42514 
42515 %feature("docstring")  casadi::FunctionInternal::sz_res() const  "
42516 
42517 [INTERNAL]  Get required length of res field.
42518 
42519 ";
42520 
42521 %feature("docstring")  casadi::FunctionInternal::uses_output() const  "
42522 
42523 [INTERNAL]  Do the derivative functions need nondifferentiated outputs?
42524 
42525 ";
42526 
42527 %feature("docstring")
42528 casadi::FunctionInternal::serialize_body(SerializingStream &s) const  "
42529 
42530 [INTERNAL]  Serialize an object without type information.
42531 
42532 ";
42533 
42534 %feature("docstring")  casadi::FunctionInternal::signature(const std::string
42535 &fname) const  "
42536 
42537 [INTERNAL]  Code generate the function.
42538 
42539 ";
42540 
42541 %feature("docstring")  casadi::FunctionInternal::has_reverse(casadi_int
42542 nadj) const  "
42543 
42544 [INTERNAL]  Return function that calculates adjoint derivatives
42545 reverse(nadj) returns a cached instance if available, and calls  Function
42546 get_reverse(casadi_int nadj) if no cached version is available.
42547 
42548 ";
42549 
42550 %feature("docstring")  casadi::FunctionInternal::replace_arg(const
42551 std::vector< M > &arg, casadi_int npar) const  "
42552 
42553 [INTERNAL]  Replace 0-by-0 inputs.
42554 
42555 ";
42556 
42557 %feature("docstring")  casadi::FunctionInternal::size2_out(casadi_int ind)
42558 const  "
42559 
42560 [INTERNAL]  Input/output dimensions.
42561 
42562 ";
42563 
42564 %feature("docstring")  casadi::FunctionInternal::call_gen(const MXVector
42565 &arg, MXVector &res, casadi_int npar, bool always_inline, bool never_inline)
42566 const  "
42567 
42568 [INTERNAL]   Call a function, overloaded.
42569 
42570 ";
42571 
42572 %feature("docstring")  casadi::FunctionInternal::call_gen(const std::vector<
42573 MatrixCommon > &arg, std::vector< MatrixCommon > &res, casadi_int npar, bool
42574 always_inline, bool never_inline) const  "
42575 
42576 [INTERNAL]   Call a function, overloaded.
42577 
42578 ";
42579 
42580 %feature("docstring")  casadi::FunctionInternal::adjViaJac(casadi_int nadj)
42581 const  "
42582 
42583 [INTERNAL]  Calculate derivatives by multiplying the full Jacobian and
42584 multiplying.
42585 
42586 ";
42587 
42588 %feature("docstring")  casadi::FunctionInternal::generate_options(bool
42589 is_temp=false) const  "
42590 
42591 [INTERNAL]  Reconstruct options dict.
42592 
42593 ";
42594 
42595 %feature("docstring")  casadi::FunctionInternal::symbolicAdjSeed(casadi_int
42596 nadj, const std::vector< MatType > &v) const  "
42597 
42598 [INTERNAL]  Symbolic expressions for the adjoint seeds.
42599 
42600 ";
42601 
42602 %feature("docstring")  casadi::FunctionInternal::codegen_mem_type() const  "
42603 
42604 [INTERNAL]  Thread-local memory object type.
42605 
42606 ";
42607 
42608 %feature("docstring")  casadi::FunctionInternal::fwdViaJac(casadi_int nfwd)
42609 const  "
42610 
42611 [INTERNAL]  Calculate derivatives by multiplying the full Jacobian and
42612 multiplying.
42613 
42614 ";
42615 
42616 %feature("docstring")  casadi::FunctionInternal::set_work(void *mem, const
42617 double **&arg, double **&res, casadi_int *&iw, double *&w) const  "
42618 
42619 [INTERNAL]  Set the (persistent) work vectors.
42620 
42621 ";
42622 
42623 %feature("docstring")  casadi::FunctionInternal::size1_in(casadi_int ind)
42624 const  "
42625 
42626 [INTERNAL]  Input/output dimensions.
42627 
42628 ";
42629 
42630 %feature("docstring")  casadi::FunctionInternal::eval_gen(const double
42631 **arg, double **res, casadi_int *iw, double *w, void *mem) const  "
42632 
42633 [INTERNAL]  Evaluate numerically.
42634 
42635 ";
42636 
42637 %feature("docstring")  casadi::FunctionInternal::eval_gen(const SXElem
42638 **arg, SXElem **res, casadi_int *iw, SXElem *w, void *mem) const  "
42639 
42640 [INTERNAL]  Evaluate a function, overloaded.
42641 
42642 ";
42643 
42644 %feature("docstring")  casadi::FunctionInternal::eval_gen(const bvec_t
42645 **arg, bvec_t **res, casadi_int *iw, bvec_t *w, void *mem) const  "
42646 
42647 [INTERNAL]  Evaluate a function, overloaded.
42648 
42649 ";
42650 
42651 %feature("docstring")  casadi::FunctionInternal::mx_in(casadi_int ind) const
42652 "
42653 
42654 [INTERNAL]  Get function input(s) and output(s)
42655 
42656 ";
42657 
42658 %feature("docstring")  casadi::FunctionInternal::mx_in() const  "
42659 
42660 [INTERNAL]  Get function input(s) and output(s)
42661 
42662 ";
42663 
42664 %feature("docstring")  casadi::FunctionInternal::is_diff_out(casadi_int i) "
42665 
42666 [INTERNAL] ";
42667 
42668 %feature("docstring")
42669 casadi::FunctionInternal::codegen_decref(CodeGenerator &g) const  "
42670 
42671 [INTERNAL]  Codegen decref for dependencies.
42672 
42673 ";
42674 
42675 %feature("docstring")  casadi::FunctionInternal::all_scalar() const  "
42676 
42677 [INTERNAL]  Are all inputs and outputs scalar.
42678 
42679 ";
42680 
42681 %feature("docstring")  casadi::JitFunction::get_n_out()  "
42682 
42683 [INTERNAL]  Number of function inputs and outputs.
42684 
42685 ";
42686 
42687 %feature("docstring")  casadi::FunctionInternal::codegen_name(const
42688 CodeGenerator &g, bool ns=true) const  "
42689 
42690 [INTERNAL]  Get name in codegen.
42691 
42692 ";
42693 
42694 %feature("docstring")  casadi::FunctionInternal::get_reverse(casadi_int
42695 nadj, const std::string &name, const std::vector< std::string > &inames,
42696 const std::vector< std::string > &onames, const Dict &opts) const  "
42697 
42698 [INTERNAL]  Return function that calculates adjoint derivatives
42699 reverse(nadj) returns a cached instance if available, and calls  Function
42700 get_reverse(casadi_int nadj) if no cached version is available.
42701 
42702 ";
42703 
42704 %feature("docstring")  casadi::FunctionInternal::disp(std::ostream &stream,
42705 bool more) const  "
42706 
42707 [INTERNAL]  Display object.
42708 
42709 ";
42710 
42711 %feature("docstring")  casadi::FunctionInternal::factory(const std::string
42712 &name, const std::vector< std::string > &s_in, const std::vector<
42713 std::string > &s_out, const Function::AuxOut &aux, const Dict &opts) const
42714 "
42715 
42716 [INTERNAL] ";
42717 
42718 %feature("docstring")  casadi::ProtoFunction::memory(int ind) const  "
42719 
42720 [INTERNAL]  Memory objects.
42721 
42722 ";
42723 
42724 %feature("docstring")  casadi::FunctionInternal::has_jac() const  "
42725 
42726 [INTERNAL]  Return Jacobian of all input elements with respect to all output
42727 elements.
42728 
42729 ";
42730 
42731 %feature("docstring")  casadi::FunctionInternal::getJacSparsity(casadi_int
42732 iind, casadi_int oind, bool symmetric) const  "
42733 
42734 [INTERNAL]  Generate the sparsity of a Jacobian block.
42735 
42736 ";
42737 
42738 %feature("docstring")  casadi::JitFunction::has_jacobian() const  "
42739 
42740 [INTERNAL]  Jacobian of all outputs with respect to all inputs.
42741 
42742 ";
42743 
42744 %feature("docstring")  casadi::FunctionInternal::reverse(casadi_int nadj)
42745 const  "
42746 
42747 [INTERNAL]  Return function that calculates adjoint derivatives
42748 reverse(nadj) returns a cached instance if available, and calls  Function
42749 get_reverse(casadi_int nadj) if no cached version is available.
42750 
42751 ";
42752 
42753 %feature("docstring")  casadi::FunctionInternal::nnz_out() const  "
42754 
42755 [INTERNAL]  Number of input/output nonzeros.
42756 
42757 ";
42758 
42759 %feature("docstring")  casadi::FunctionInternal::nnz_out(casadi_int ind)
42760 const  "
42761 
42762 [INTERNAL]  Number of input/output nonzeros.
42763 
42764 ";
42765 
42766 %feature("docstring")  casadi::FunctionInternal::nz_out(const std::vector<
42767 DM > &res) const  "
42768 
42769 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
42770 
42771 ";
42772 
42773 %feature("docstring")  casadi::FunctionInternal::nz_out(const std::vector<
42774 double > &res) const  "
42775 
42776 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
42777 
42778 ";
42779 
42780 %feature("docstring")  casadi::FunctionInternal::setup(void *mem, const
42781 double **arg, double **res, casadi_int *iw, double *w) const  "
42782 
42783 [INTERNAL]  Set the (persistent and temporary) work vectors.
42784 
42785 ";
42786 
42787 %feature("docstring")  casadi::FunctionInternal::index_in(const std::string
42788 &name) const  "
42789 
42790 [INTERNAL]  Get input scheme index by name.
42791 
42792 ";
42793 
42794 %feature("docstring")  casadi::FunctionInternal::disp_more(std::ostream
42795 &stream) const  "
42796 
42797 [INTERNAL]  Print more.
42798 
42799 ";
42800 
42801 %feature("docstring")
42802 casadi::FunctionInternal::codegen_sparsities(CodeGenerator &g) const  "
42803 
42804 [INTERNAL]  Codegen sparsities.
42805 
42806 ";
42807 
42808 %feature("docstring")  casadi::FunctionInternal::size2_in(casadi_int ind)
42809 const  "
42810 
42811 [INTERNAL]  Input/output dimensions.
42812 
42813 ";
42814 
42815 %feature("docstring")
42816 casadi::FunctionInternal::instruction_input(casadi_int k) const  "
42817 
42818 [INTERNAL]  Get the (integer) input arguments of an atomic operation.
42819 
42820 ";
42821 
42822 %feature("docstring")  casadi::FunctionInternal::sz_work(size_t &sz_arg,
42823 size_t &sz_res, size_t &sz_iw, size_t &sz_w) const  "
42824 
42825 [INTERNAL]  Get number of temporary variables needed.
42826 
42827 ";
42828 
42829 %feature("docstring")  casadi::JitFunction::class_name() const  "
42830 
42831 [INTERNAL]  Get type name.
42832 
42833 ";
42834 
42835 %feature("docstring")  casadi::FunctionInternal::call_reverse(const
42836 std::vector< MX > &arg, const std::vector< MX > &res, const std::vector<
42837 std::vector< MX > > &aseed, std::vector< std::vector< MX > > &asens, bool
42838 always_inline, bool never_inline) const  "
42839 
42840 [INTERNAL]  Reverse mode, virtual functions overloaded in derived classes.
42841 
42842 ";
42843 
42844 %feature("docstring")  casadi::FunctionInternal::call_reverse(const
42845 std::vector< SX > &arg, const std::vector< SX > &res, const std::vector<
42846 std::vector< SX > > &aseed, std::vector< std::vector< SX > > &asens, bool
42847 always_inline, bool never_inline) const  "
42848 
42849 [INTERNAL]  Reverse mode, virtual functions overloaded in derived classes.
42850 
42851 ";
42852 
42853 %feature("docstring")  casadi::FunctionInternal::nnz_in() const  "
42854 
42855 [INTERNAL]  Number of input/output nonzeros.
42856 
42857 ";
42858 
42859 %feature("docstring")  casadi::FunctionInternal::nnz_in(casadi_int ind)
42860 const  "
42861 
42862 [INTERNAL]  Number of input/output nonzeros.
42863 
42864 ";
42865 
42866 %feature("docstring")  casadi::FunctionInternal::alloc_res(size_t sz_res,
42867 bool persistent=false) "
42868 
42869 [INTERNAL]  Ensure required length of res field.
42870 
42871 ";
42872 
42873 %feature("docstring")  casadi::FunctionInternal::generate_lifted(Function
42874 &vdef_fcn, Function &vinit_fcn) const  "
42875 
42876 [INTERNAL]  Extract the functions needed for the Lifted Newton method.
42877 
42878 ";
42879 
42880 %feature("docstring")  casadi::FunctionInternal::get_partition(casadi_int
42881 iind, casadi_int oind, Sparsity &D1, Sparsity &D2, bool compact, bool
42882 symmetric, bool allow_forward, bool allow_reverse) const  "
42883 
42884 [INTERNAL]  Get the unidirectional or bidirectional partition.
42885 
42886 ";
42887 
42888 %feature("docstring")  casadi::FunctionInternal::incache(const std::string
42889 &fname, Function &f, const std::string &suffix="") const  "
42890 
42891 [INTERNAL]  Get function in cache.
42892 
42893 ";
42894 
42895 %feature("docstring")  casadi::FunctionInternal::is_diff_in(casadi_int i) "
42896 
42897 [INTERNAL] ";
42898 
42899 %feature("docstring")  casadi::FunctionInternal::sparsity_jac(casadi_int
42900 iind, casadi_int oind, bool compact, bool symmetric) const  "
42901 
42902 [INTERNAL]  Get, if necessary generate, the sparsity of a Jacobian block.
42903 
42904 ";
42905 
42906 %feature("docstring")  casadi::FunctionInternal::wrap_as_needed(const Dict
42907 &opts) const  "
42908 
42909 [INTERNAL]  Wrap in an Function instance consisting of only one MX call.
42910 
42911 ";
42912 
42913 %feature("docstring")  casadi::FunctionInternal::sx_in(casadi_int ind) const
42914 "
42915 
42916 [INTERNAL]  Get function input(s) and output(s)
42917 
42918 ";
42919 
42920 %feature("docstring")  casadi::FunctionInternal::sx_in() const  "
42921 
42922 [INTERNAL]  Get function input(s) and output(s)
42923 
42924 ";
42925 
42926 %feature("docstring")  casadi::FunctionInternal::matching_res(const
42927 std::vector< M > &arg, casadi_int &npar) const  "
42928 
42929 [INTERNAL]  Check if output arguments that needs to be replaced.
42930 
42931 Raises errors
42932 
42933 Parameters:
42934 -----------
42935 
42936 npar[in]:  normal usage: 1, disallow pararallel calls: -1
42937 
42938 npar:  max number of horizontal repetitions across all arguments (or -1)
42939 
42940 ";
42941 
42942 %feature("docstring")  casadi::FunctionInternal::tocache(const Function &f,
42943 const std::string &suffix="") const  "
42944 
42945 [INTERNAL]  Save function to cache.
42946 
42947 ";
42948 
42949 %feature("docstring")  casadi::ProtoFunction::print(const char *fmt,...)
42950 const  "
42951 
42952 [INTERNAL]  C-style formatted printing during evaluation.
42953 
42954 ";
42955 
42956 %feature("docstring")  casadi::ProtoFunction::init_mem(void *mem) const  "
42957 
42958 [INTERNAL]  Initalize memory block.
42959 
42960 ";
42961 
42962 %feature("docstring")  casadi::FunctionInternal::instruction_id(casadi_int
42963 k) const  "
42964 
42965 [INTERNAL]  Get an atomic operation operator index.
42966 
42967 ";
42968 
42969 %feature("docstring")  casadi::FunctionInternal::call_forward(const
42970 std::vector< MX > &arg, const std::vector< MX > &res, const std::vector<
42971 std::vector< MX > > &fseed, std::vector< std::vector< MX > > &fsens, bool
42972 always_inline, bool never_inline) const  "
42973 
42974 [INTERNAL]  Forward mode AD, virtual functions overloaded in derived
42975 classes.
42976 
42977 ";
42978 
42979 %feature("docstring")  casadi::FunctionInternal::call_forward(const
42980 std::vector< SX > &arg, const std::vector< SX > &res, const std::vector<
42981 std::vector< SX > > &fseed, std::vector< std::vector< SX > > &fsens, bool
42982 always_inline, bool never_inline) const  "
42983 
42984 [INTERNAL]  Forward mode AD, virtual functions overloaded in derived
42985 classes.
42986 
42987 ";
42988 
42989 %feature("docstring")  casadi::FunctionInternal::slice(const std::string
42990 &name, const std::vector< casadi_int > &order_in, const std::vector<
42991 casadi_int > &order_out, const Dict &opts) const  "
42992 
42993 [INTERNAL]  returns a new function with a selection of inputs/outputs of the
42994 original
42995 
42996 ";
42997 
42998 %feature("docstring")  casadi::FunctionInternal::n_instructions() const  "
42999 
43000 [INTERNAL]  Get the number of atomic operations.
43001 
43002 ";
43003 
43004 %feature("docstring")  casadi::FunctionInternal::has_forward(casadi_int
43005 nfwd) const  "
43006 
43007 [INTERNAL]  Return function that calculates forward derivatives
43008 forward(nfwd) returns a cached instance if available, and calls  Function
43009 get_forward(casadi_int nfwd) if no cached version is available.
43010 
43011 ";
43012 
43013 %feature("docstring")
43014 casadi::FunctionInternal::codegen_free_mem(CodeGenerator &g) const  "
43015 
43016 [INTERNAL]  Codegen for free_mem.
43017 
43018 ";
43019 
43020 %feature("docstring")  casadi::FunctionInternal::codegen_meta(CodeGenerator
43021 &g) const  "
43022 
43023 [INTERNAL]  Generate meta-information allowing a user to evaluate a
43024 generated function.
43025 
43026 ";
43027 
43028 %feature("docstring")  casadi::FunctionInternal::size_out(casadi_int ind)
43029 const  "
43030 
43031 [INTERNAL]  Input/output dimensions.
43032 
43033 ";
43034 
43035 %feature("docstring")  casadi::FunctionInternal::which_depends(const
43036 std::string &s_in, const std::vector< std::string > &s_out, casadi_int
43037 order, bool tr=false) const  "
43038 
43039 [INTERNAL]  Which variables enter with some order.
43040 
43041 Parameters:
43042 -----------
43043 
43044 s_in:   Input name
43045 
43046 s_out:   Output name(s)
43047 
43048 order:  Only 1 (linear) and 2 (nonlinear) allowed
43049 
43050 tr:  Flip the relationship. Return which expressions contain the variables
43051 
43052 ";
43053 
43054 %feature("docstring")  casadi::FunctionInternal::get_forward(casadi_int
43055 nfwd, const std::string &name, const std::vector< std::string > &inames,
43056 const std::vector< std::string > &onames, const Dict &opts) const  "
43057 
43058 [INTERNAL]  Return function that calculates forward derivatives
43059 forward(nfwd) returns a cached instance if available, and calls  Function
43060 get_forward(casadi_int nfwd) if no cached version is available.
43061 
43062 ";
43063 
43064 %feature("docstring")  casadi::FunctionInternal::alloc_iw(size_t sz_iw, bool
43065 persistent=false) "
43066 
43067 [INTERNAL]  Ensure required length of iw field.
43068 
43069 ";
43070 
43071 %feature("docstring")  casadi::FunctionInternal::alloc_arg(size_t sz_arg,
43072 bool persistent=false) "
43073 
43074 [INTERNAL]  Ensure required length of arg field.
43075 
43076 ";
43077 
43078 %feature("docstring")  casadi::FunctionInternal::ad_weight() const  "
43079 
43080 [INTERNAL]  Weighting factor for chosing forward/reverse mode.
43081 
43082 ";
43083 
43084 %feature("docstring")  casadi::FunctionInternal::get_sparsity_out(casadi_int
43085 i) "
43086 
43087 [INTERNAL]  Get sparsity of a given output.
43088 
43089 ";
43090 
43091 %feature("docstring")
43092 casadi::FunctionInternal::print_dimensions(std::ostream &stream) const  "
43093 
43094 [INTERNAL]  Print dimensions of inputs and outputs.
43095 
43096 ";
43097 
43098 %feature("docstring")  casadi::FunctionInternal::get_name_in(casadi_int i) "
43099 
43100 [INTERNAL]  Names of function input and outputs.
43101 
43102 ";
43103 
43104 %feature("docstring")  casadi::FunctionInternal::definition() const  "
43105 
43106 [INTERNAL]  Get function signature: name:(inputs)->(outputs)
43107 
43108 ";
43109 
43110 %feature("docstring")  casadi::FunctionInternal::getAdaptorSolverName()
43111 const  "
43112 
43113 [INTERNAL]  Obtain solver name from Adaptor.
43114 
43115 ";
43116 
43117 %feature("docstring")  casadi::FunctionInternal::numel_in() const  "
43118 
43119 [INTERNAL]  Number of input/output elements.
43120 
43121 ";
43122 
43123 %feature("docstring")  casadi::FunctionInternal::numel_in(casadi_int ind)
43124 const  "
43125 
43126 [INTERNAL]  Number of input/output elements.
43127 
43128 ";
43129 
43130 %feature("docstring")
43131 casadi::FunctionInternal::codegen_init_mem(CodeGenerator &g) const  "
43132 
43133 [INTERNAL]  Codegen decref for init_mem.
43134 
43135 ";
43136 
43137 %feature("docstring")  casadi::FunctionInternal::sz_iw() const  "
43138 
43139 [INTERNAL]  Get required length of iw field.
43140 
43141 ";
43142 
43143 %feature("docstring")  casadi::FunctionInternal::is_a(const std::string
43144 &type, bool recursive) const  "
43145 
43146 [INTERNAL]  Check if the function is of a particular type.
43147 
43148 ";
43149 
43150 %feature("docstring")  casadi::FunctionInternal::replace_fseed(const
43151 std::vector< std::vector< M >> &fseed, casadi_int npar) const  "
43152 
43153 [INTERNAL]  Replace 0-by-0 forward seeds.
43154 
43155 ";
43156 
43157 %feature("docstring")  casadi::FunctionInternal::replace_fseed(const
43158 std::vector< std::vector< M > > &fseed, casadi_int npar) const  "
43159 
43160 [INTERNAL] ";
43161 
43162 %feature("docstring")  casadi::ProtoFunction::print_time(const std::map<
43163 std::string, FStats > &fstats) const  "
43164 
43165 [INTERNAL]  Print timing statistics.
43166 
43167 ";
43168 
43169 %feature("docstring")  casadi::FunctionInternal::jac() const  "
43170 
43171 [INTERNAL]  Return Jacobian of all input elements with respect to all output
43172 elements.
43173 
43174 ";
43175 
43176 %feature("docstring")  casadi::FunctionInternal::eval_dm(const std::vector<
43177 DM > &arg) const  "
43178 
43179 [INTERNAL]  Evaluate with DM matrices.
43180 
43181 ";
43182 
43183 %feature("docstring")  casadi::ProtoFunction::free_mem(void *mem) const  "
43184 
43185 [INTERNAL]  Free memory block.
43186 
43187 ";
43188 
43189 %feature("docstring") casadi::JitFunction::~JitFunction "
43190 
43191 [INTERNAL]  Destructor.
43192 
43193 ";
43194 
43195 %feature("docstring")  casadi::FunctionInternal::get_abstol() const  "
43196 
43197 [INTERNAL]  Get absolute tolerance.
43198 
43199 ";
43200 
43201 %feature("docstring")  casadi::FunctionInternal::get_jac(const std::string
43202 &name, const std::vector< std::string > &inames, const std::vector<
43203 std::string > &onames, const Dict &opts) const  "
43204 
43205 [INTERNAL]  Return Jacobian of all input elements with respect to all output
43206 elements.
43207 
43208 ";
43209 
43210 %feature("docstring")  casadi::FunctionInternal::has_eval_dm() const  "
43211 
43212 [INTERNAL]  Evaluate with DM matrices.
43213 
43214 ";
43215 
43216 %feature("docstring")
43217 casadi::FunctionInternal::codegen_declarations(CodeGenerator &g) const  "
43218 
43219 [INTERNAL]  Generate code for the declarations of the C function.
43220 
43221 ";
43222 
43223 %feature("docstring")  casadi::FunctionInternal::matching_arg(const
43224 std::vector< M > &arg, casadi_int &npar) const  "
43225 
43226 [INTERNAL]  Check if input arguments that needs to be replaced.
43227 
43228 Raises errors
43229 
43230 Parameters:
43231 -----------
43232 
43233 npar[in]:  normal usage: 1, disallow pararallel calls: -1
43234 
43235 npar:  max number of horizontal repetitions across all arguments (or -1)
43236 
43237 ";
43238 
43239 %feature("docstring")  casadi::FunctionInternal::jacobian() const  "
43240 
43241 [INTERNAL]  Return Jacobian of all input elements with respect to all output
43242 elements.
43243 
43244 ";
43245 
43246 %feature("docstring")  casadi::FunctionInternal::replace_res(const
43247 std::vector< M > &res, casadi_int npar) const  "
43248 
43249 [INTERNAL]  Replace 0-by-0 outputs.
43250 
43251 ";
43252 
43253 %feature("docstring")  casadi::FunctionInternal::alloc_w(size_t sz_w, bool
43254 persistent=false) "
43255 
43256 [INTERNAL]  Ensure required length of w field.
43257 
43258 ";
43259 
43260 %feature("docstring")  casadi::FunctionInternal::eval_mx(const MXVector
43261 &arg, MXVector &res, bool always_inline, bool never_inline) const  "
43262 
43263 [INTERNAL]  Evaluate with symbolic matrices.
43264 
43265 ";
43266 
43267 %feature("docstring")  casadi::FunctionInternal::check_arg(const
43268 std::vector< M > &arg, casadi_int &npar) const  "
43269 
43270 [INTERNAL]  Check if input arguments have correct length and dimensions.
43271 
43272 Raises errors.
43273 
43274 Parameters:
43275 -----------
43276 
43277 npar[in]:  normal usage: 1, disallow pararallel calls: -1
43278 
43279 npar:  max number of horizontal repetitions across all arguments (or -1)
43280 
43281 ";
43282 
43283 %feature("docstring")  casadi::FunctionInternal::set_temp(void *mem, const
43284 double **arg, double **res, casadi_int *iw, double *w) const  "
43285 
43286 [INTERNAL]  Set the (temporary) work vectors.
43287 
43288 ";
43289 
43290 %feature("docstring")  casadi::FunctionInternal::index_out(const std::string
43291 &name) const  "
43292 
43293 [INTERNAL]  Get output scheme index by name.
43294 
43295 ";
43296 
43297 %feature("docstring")  casadi::FunctionInternal::print_option(const
43298 std::string &name, std::ostream &stream) const  "
43299 
43300 [INTERNAL]  Print all information there is to know about a certain option.
43301 
43302 ";
43303 
43304 %feature("docstring")  casadi::FunctionInternal::has_spfwd() const  "
43305 
43306 [INTERNAL]  Is the class able to propagate seeds through the algorithm?
43307 
43308 ";
43309 
43310 %feature("docstring")  casadi::FunctionInternal::get_min_in(casadi_int ind)
43311 const  "
43312 
43313 [INTERNAL]  Get smallest input value.
43314 
43315 ";
43316 
43317 %feature("docstring")  casadi::FunctionInternal::self() const  "
43318 
43319 [INTERNAL]  Get a public class instance.
43320 
43321 ";
43322 
43323 %feature("docstring")  casadi::FunctionInternal::get_jacobian_sparsity()
43324 const  "
43325 
43326 [INTERNAL]  Get Jacobian sparsity.
43327 
43328 ";
43329 
43330 %feature("docstring")  casadi::FunctionInternal::replace_aseed(const
43331 std::vector< std::vector< M >> &aseed, casadi_int npar) const  "
43332 
43333 [INTERNAL]  Replace 0-by-0 reverse seeds.
43334 
43335 ";
43336 
43337 %feature("docstring")  casadi::FunctionInternal::replace_aseed(const
43338 std::vector< std::vector< M > > &aseed, casadi_int npar) const  "
43339 
43340 [INTERNAL] ";
43341 
43342 %feature("docstring")  casadi::FunctionInternal::get_sparsity_in(casadi_int
43343 i) "
43344 
43345 [INTERNAL]  Get sparsity of a given input.
43346 
43347 ";
43348 
43349 %feature("docstring")  casadi::FunctionInternal::call(const std::vector< M >
43350 &arg, std::vector< M > &res, bool always_inline, bool never_inline) const  "
43351 
43352 [INTERNAL]   Call a function, templated.
43353 
43354 ";
43355 
43356 %feature("docstring")  casadi::SharedObjectInternal::weak() "
43357 
43358 [INTERNAL]  Get a weak reference to the object.
43359 
43360 ";
43361 
43362 %feature("docstring")  casadi::FunctionInternal::export_code(const
43363 std::string &lang, std::ostream &stream, const Dict &options) const  "
43364 
43365 [INTERNAL]  Export function in a specific language.
43366 
43367 ";
43368 
43369 %feature("docstring")  casadi::FunctionInternal::has_free() const  "
43370 
43371 [INTERNAL]  Does the function have free variables.
43372 
43373 ";
43374 
43375 %feature("docstring")  casadi::JitFunction::get_jacobian(const std::string
43376 &name, const std::vector< std::string > &inames, const std::vector<
43377 std::string > &onames, const Dict &opts) const  "
43378 
43379 [INTERNAL]  Jacobian of all outputs with respect to all inputs.
43380 
43381 ";
43382 
43383 %feature("docstring")  casadi::FunctionInternal::finalize()  "
43384 
43385 [INTERNAL]  Finalize the object creation.
43386 
43387 ";
43388 
43389 %feature("docstring")  casadi::FunctionInternal::sp_weight() const  "
43390 
43391 [INTERNAL]  Weighting factor for chosing forward/reverse mode, sparsity
43392 propagation.
43393 
43394 ";
43395 
43396 %feature("docstring")  casadi::ProtoFunction::sprint(char *buf, size_t
43397 buf_sz, const char *fmt,...) const  "
43398 
43399 [INTERNAL]  C-style formatted printing to string.
43400 
43401 ";
43402 
43403 %feature("docstring")
43404 casadi::FunctionInternal::getJacSparsityGen(casadi_int iind, casadi_int
43405 oind, bool symmetric, casadi_int gr_i=1, casadi_int gr_o=1) const  "
43406 
43407 [INTERNAL]  Get the sparsity pattern, forward mode.
43408 
43409 ";
43410 
43411 %feature("docstring")  casadi::FunctionInternal::sx_out(casadi_int ind)
43412 const  "
43413 
43414 [INTERNAL]  Get function input(s) and output(s)
43415 
43416 ";
43417 
43418 %feature("docstring")  casadi::FunctionInternal::sx_out() const  "
43419 
43420 [INTERNAL]  Get function input(s) and output(s)
43421 
43422 ";
43423 
43424 %feature("docstring")  casadi::FunctionInternal::check_mat(const Sparsity
43425 &arg, const Sparsity &inp, casadi_int &npar) "
43426 
43427 [INTERNAL]  Helper function
43428 
43429 Parameters:
43430 -----------
43431 
43432 npar[in]:  normal usage: 1, disallow pararallel calls: -1
43433 
43434 npar[out]:  required number of parallel calls (or -1)
43435 
43436 ";
43437 
43438 %feature("docstring")  casadi::FunctionInternal::convert_res(const
43439 std::vector< M > &res) const  "
43440 
43441 [INTERNAL]  Convert from/to input/output lists/map.
43442 
43443 ";
43444 
43445 %feature("docstring")  casadi::FunctionInternal::convert_res(const std::map<
43446 std::string, M > &res) const  "
43447 
43448 [INTERNAL]  Convert from/to input/output lists/map.
43449 
43450 ";
43451 
43452 
43453 // File: classcasadi_1_1KeyboardInterruptException.xml
43454 %feature("docstring")  casadi::CasadiException::what() const  "
43455 
43456 throw () Display error.
43457 
43458 ";
43459 
43460 %feature("docstring")
43461 casadi::KeyboardInterruptException::~KeyboardInterruptException "
43462 
43463 throw () Destructor.
43464 
43465 ";
43466 
43467 %feature("docstring")
43468 casadi::KeyboardInterruptException::KeyboardInterruptException() "
43469 
43470 Default constructor.
43471 
43472 ";
43473 
43474 %feature("docstring") casadi::KeyboardInterruptException "
43475 
43476 C++ includes: exception.hpp ";
43477 
43478 
43479 // File: classcasadi_1_1LapackLu.xml
43480 %feature("docstring")  casadi::ProtoFunction::print(const char *fmt,...)
43481 const  "
43482 
43483 [INTERNAL]  C-style formatted printing during evaluation.
43484 
43485 ";
43486 
43487 %feature("docstring")  casadi::LapackLu::nfact(void *mem, const double *A)
43488 const  "
43489 
43490 [INTERNAL]  Numeric factorization.
43491 
43492 ";
43493 
43494 %feature("docstring")  casadi::LinsolInternal::nrow() const  "
43495 
43496 [INTERNAL]  Get sparsity pattern.
43497 
43498 ";
43499 
43500 %feature("docstring")  casadi::LapackLu::solve(void *mem, const double *A,
43501 double *x, casadi_int nrhs, bool tr) const  "
43502 
43503 [INTERNAL] ";
43504 
43505 %feature("docstring")  casadi::ProtoFunction::serialize(SerializingStream
43506 &s) const  "
43507 
43508 [INTERNAL]  Serialize an object.
43509 
43510 ";
43511 
43512 %feature("docstring")  casadi::LapackLu::init(const Dict &opts)  "
43513 
43514 [INTERNAL]  Initialize the solver.
43515 
43516 ";
43517 
43518 %feature("docstring") casadi::LapackLu::~LapackLu "
43519 
43520 [INTERNAL]  Destructor.
43521 
43522 ";
43523 
43524 %feature("docstring")  casadi::ProtoFunction::construct(const Dict &opts) "
43525 
43526 [INTERNAL]  Construct Prepares the function for evaluation.
43527 
43528 ";
43529 
43530 %feature("docstring")  casadi::LapackLu::serialize_body(SerializingStream
43531 &s) const  "
43532 
43533 [INTERNAL]  Serialize an object without type information.
43534 
43535 ";
43536 
43537 %feature("docstring")  casadi::LapackLu::init_mem(void *mem) const  "
43538 
43539 [INTERNAL]  Initalize memory block.
43540 
43541 ";
43542 
43543 %feature("docstring")  casadi::ProtoFunction::memory(int ind) const  "
43544 
43545 [INTERNAL]  Memory objects.
43546 
43547 ";
43548 
43549 %feature("docstring")  casadi::LinsolInternal::sfact(void *mem, const double
43550 *A) const  "
43551 
43552 [INTERNAL] ";
43553 
43554 %feature("docstring")  casadi::LinsolInternal::generate(CodeGenerator &g,
43555 const std::string &A, const std::string &x, casadi_int nrhs, bool tr) const
43556 "
43557 
43558 [INTERNAL]  Generate C code.
43559 
43560 ";
43561 
43562 %feature("docstring")  casadi::LinsolInternal::linsol_eval_sx(const SXElem
43563 **arg, SXElem **res, casadi_int *iw, SXElem *w, void *mem, bool tr,
43564 casadi_int nrhs) const  "
43565 
43566 [INTERNAL]  Evaluate SX, possibly transposed.
43567 
43568 ";
43569 
43570 %feature("docstring")  casadi::ProtoFunction::serialize_base_function()
43571 const  "
43572 
43573 [INTERNAL]  String used to identify the immediate FunctionInternal subclass.
43574 
43575 ";
43576 
43577 %feature("docstring")  casadi::LinsolInternal::ncol() const  "
43578 
43579 [INTERNAL] ";
43580 
43581 %feature("docstring")  casadi::ProtoFunction::clear_mem() "
43582 
43583 [INTERNAL]  Clear all memory (called from destructor)
43584 
43585 ";
43586 
43587 %feature("docstring")  casadi::ProtoFunction::sprint(char *buf, size_t
43588 buf_sz, const char *fmt,...) const  "
43589 
43590 [INTERNAL]  C-style formatted printing to string.
43591 
43592 ";
43593 
43594 %feature("docstring") casadi::LapackLu::LapackLu(const std::string &name,
43595 const Sparsity &sp) "
43596 
43597 [INTERNAL] ";
43598 
43599 %feature("docstring")  casadi::LinsolInternal::disp(std::ostream &stream,
43600 bool more) const  "
43601 
43602 [INTERNAL]  Display object.
43603 
43604 ";
43605 
43606 %feature("docstring")  casadi::LapackLu::free_mem(void *mem) const  "
43607 
43608 [INTERNAL]  Free memory block.
43609 
43610 ";
43611 
43612 %feature("docstring")  casadi::ProtoFunction::finalize() "
43613 
43614 [INTERNAL]  Finalize the object creation This function, which visits the
43615 class hierarchy in reverse order is run after init() has been completed.
43616 
43617 ";
43618 
43619 %feature("docstring")  casadi::ProtoFunction::checkout() const  "
43620 
43621 [INTERNAL]  Checkout a memory object.
43622 
43623 ";
43624 
43625 %feature("docstring")  casadi::LinsolInternal::rank(void *mem, const double
43626 *A) const  "
43627 
43628 [INTERNAL]   Matrix rank.
43629 
43630 ";
43631 
43632 %feature("docstring")  casadi::LinsolInternal::colind() const  "
43633 
43634 [INTERNAL] ";
43635 
43636 %feature("docstring")  casadi::LapackLu::alloc_mem() const  "
43637 
43638 [INTERNAL]  Create memory block.
43639 
43640 ";
43641 
43642 %feature("docstring")  casadi::SharedObjectInternal::weak() "
43643 
43644 [INTERNAL]  Get a weak reference to the object.
43645 
43646 ";
43647 
43648 %feature("docstring")  casadi::LinsolInternal::nnz() const  "
43649 
43650 [INTERNAL] ";
43651 
43652 %feature("docstring")  casadi::ProtoFunction::generate_options(bool
43653 is_temp=false) const  "
43654 
43655 [INTERNAL]  Reconstruct options dict.
43656 
43657 ";
43658 
43659 %feature("docstring")
43660 casadi::LinsolInternal::serialize_type(SerializingStream &s) const  "
43661 
43662 [INTERNAL]  Serialize type information.
43663 
43664 ";
43665 
43666 %feature("docstring")  casadi::ProtoFunction::release(int mem) const  "
43667 
43668 [INTERNAL]  Release a memory object.
43669 
43670 ";
43671 
43672 %feature("docstring") casadi::LapackLu "
43673 
43674 'lapacklu' plugin for Linsol
43675 
43676 This class solves the linear system A.x=b by making an LU factorization of
43677 A: A = L.U, with L lower and U upper triangular
43678 
43679 >List of available options
43680 
43681 +-----------------------------+---------+----------------------------------+
43682 |             Id              |  Type   |           Description            |
43683 +=============================+=========+==================================+
43684 | allow_equilibration_failure | OT_BOOL | Non-fatal error when             |
43685 |                             |         | equilibration fails              |
43686 +-----------------------------+---------+----------------------------------+
43687 | equilibration               | OT_BOOL | Equilibrate the matrix           |
43688 +-----------------------------+---------+----------------------------------+
43689 
43690 >List of available options
43691 
43692 +------------------+-----------------+------------------+------------------+
43693 |        Id        |      Type       |   Description    |     Used in      |
43694 +==================+=================+==================+==================+
43695 | ad_weight        | OT_DOUBLE       | Weighting factor | casadi::Function |
43696 |                  |                 | for derivative   | Internal         |
43697 |                  |                 | calculation.When |                  |
43698 |                  |                 | there is an      |                  |
43699 |                  |                 | option of either |                  |
43700 |                  |                 | using forward or |                  |
43701 |                  |                 | reverse mode     |                  |
43702 |                  |                 | directional      |                  |
43703 |                  |                 | derivatives, the |                  |
43704 |                  |                 | condition ad_wei |                  |
43705 |                  |                 | ght*nf<=(1-ad_we |                  |
43706 |                  |                 | ight)*na is used |                  |
43707 |                  |                 | where nf and na  |                  |
43708 |                  |                 | are estimates of |                  |
43709 |                  |                 | the number of    |                  |
43710 |                  |                 | forward/reverse  |                  |
43711 |                  |                 | mode directional |                  |
43712 |                  |                 | derivatives      |                  |
43713 |                  |                 | needed. By       |                  |
43714 |                  |                 | default,         |                  |
43715 |                  |                 | ad_weight is     |                  |
43716 |                  |                 | calculated       |                  |
43717 |                  |                 | automatically,   |                  |
43718 |                  |                 | but this can be  |                  |
43719 |                  |                 | overridden by    |                  |
43720 |                  |                 | setting this     |                  |
43721 |                  |                 | option. In       |                  |
43722 |                  |                 | particular, 0    |                  |
43723 |                  |                 | means forcing    |                  |
43724 |                  |                 | forward mode and |                  |
43725 |                  |                 | 1 forcing        |                  |
43726 |                  |                 | reverse mode.    |                  |
43727 |                  |                 | Leave unset for  |                  |
43728 |                  |                 | (class specific) |                  |
43729 |                  |                 | heuristics.      |                  |
43730 +------------------+-----------------+------------------+------------------+
43731 | ad_weight_sp     | OT_DOUBLE       | Weighting factor | casadi::Function |
43732 |                  |                 | for sparsity     | Internal         |
43733 |                  |                 | pattern          |                  |
43734 |                  |                 | calculation calc |                  |
43735 |                  |                 | ulation.Override |                  |
43736 |                  |                 | s default        |                  |
43737 |                  |                 | behavior. Set to |                  |
43738 |                  |                 | 0 and 1 to force |                  |
43739 |                  |                 | forward and      |                  |
43740 |                  |                 | reverse mode     |                  |
43741 |                  |                 | respectively.    |                  |
43742 |                  |                 | Cf. option       |                  |
43743 |                  |                 | \"ad_weight\".     |                  |
43744 |                  |                 | When set to -1,  |                  |
43745 |                  |                 | sparsity is      |                  |
43746 |                  |                 | completely       |                  |
43747 |                  |                 | ignored and      |                  |
43748 |                  |                 | dense matrices   |                  |
43749 |                  |                 | are used.        |                  |
43750 +------------------+-----------------+------------------+------------------+
43751 | allow_equilibrat | OT_BOOL         | Non-fatal error  | casadi::LapackLu |
43752 | ion_failure      |                 | when             |                  |
43753 |                  |                 | equilibration    |                  |
43754 |                  |                 | fails            |                  |
43755 +------------------+-----------------+------------------+------------------+
43756 | always_inline    | OT_BOOL         | Force inlining.  | casadi::Function |
43757 |                  |                 |                  | Internal         |
43758 +------------------+-----------------+------------------+------------------+
43759 | compiler         | OT_STRING       | Just-in-time     | casadi::Function |
43760 |                  |                 | compiler plugin  | Internal         |
43761 |                  |                 | to be used.      |                  |
43762 +------------------+-----------------+------------------+------------------+
43763 | custom_jacobian  | OT_FUNCTION     | Override         | casadi::Function |
43764 |                  |                 | CasADi's AD. Use | Internal         |
43765 |                  |                 | together with    |                  |
43766 |                  |                 | 'jac_penalty':   |                  |
43767 |                  |                 | 0. Note: Highly  |                  |
43768 |                  |                 | experimental.    |                  |
43769 |                  |                 | Syntax may break |                  |
43770 |                  |                 | often.           |                  |
43771 +------------------+-----------------+------------------+------------------+
43772 | derivative_of    | OT_FUNCTION     | The function is  | casadi::Function |
43773 |                  |                 | a derivative of  | Internal         |
43774 |                  |                 | another          |                  |
43775 |                  |                 | function. The    |                  |
43776 |                  |                 | type of          |                  |
43777 |                  |                 | derivative       |                  |
43778 |                  |                 | (directional     |                  |
43779 |                  |                 | derivative,      |                  |
43780 |                  |                 | Jacobian) is     |                  |
43781 |                  |                 | inferred from    |                  |
43782 |                  |                 | the function     |                  |
43783 |                  |                 | name.            |                  |
43784 +------------------+-----------------+------------------+------------------+
43785 | dump             | OT_BOOL         | Dump function to | casadi::Function |
43786 |                  |                 | file upon first  | Internal         |
43787 |                  |                 | evaluation.      |                  |
43788 |                  |                 | [false]          |                  |
43789 +------------------+-----------------+------------------+------------------+
43790 | dump_dir         | OT_STRING       | Directory to     | casadi::Function |
43791 |                  |                 | dump             | Internal         |
43792 |                  |                 | inputs/outputs   |                  |
43793 |                  |                 | to. Make sure    |                  |
43794 |                  |                 | the directory    |                  |
43795 |                  |                 | exists [.]       |                  |
43796 +------------------+-----------------+------------------+------------------+
43797 | dump_format      | OT_STRING       | Choose file      | casadi::Function |
43798 |                  |                 | format to dump   | Internal         |
43799 |                  |                 | matrices. See    |                  |
43800 |                  |                 | DM.from_file     |                  |
43801 |                  |                 | [mtx]            |                  |
43802 +------------------+-----------------+------------------+------------------+
43803 | dump_in          | OT_BOOL         | Dump numerical   | casadi::Function |
43804 |                  |                 | values of inputs | Internal         |
43805 |                  |                 | to file          |                  |
43806 |                  |                 | (readable with   |                  |
43807 |                  |                 | DM.from_file )   |                  |
43808 |                  |                 | [default: false] |                  |
43809 +------------------+-----------------+------------------+------------------+
43810 | dump_out         | OT_BOOL         | Dump numerical   | casadi::Function |
43811 |                  |                 | values of        | Internal         |
43812 |                  |                 | outputs to file  |                  |
43813 |                  |                 | (readable with   |                  |
43814 |                  |                 | DM.from_file )   |                  |
43815 |                  |                 | [default: false] |                  |
43816 +------------------+-----------------+------------------+------------------+
43817 | enable_fd        | OT_BOOL         | Enable           | casadi::Function |
43818 |                  |                 | derivative       | Internal         |
43819 |                  |                 | calculation by   |                  |
43820 |                  |                 | finite           |                  |
43821 |                  |                 | differencing.    |                  |
43822 |                  |                 | [default:        |                  |
43823 |                  |                 | false]]          |                  |
43824 +------------------+-----------------+------------------+------------------+
43825 | enable_forward   | OT_BOOL         | Enable           | casadi::Function |
43826 |                  |                 | derivative       | Internal         |
43827 |                  |                 | calculation      |                  |
43828 |                  |                 | using generated  |                  |
43829 |                  |                 | functions for    |                  |
43830 |                  |                 | Jacobian-times-  |                  |
43831 |                  |                 | vector products  |                  |
43832 |                  |                 | - typically      |                  |
43833 |                  |                 | using forward    |                  |
43834 |                  |                 | mode AD - if     |                  |
43835 |                  |                 | available.       |                  |
43836 |                  |                 | [default: true]  |                  |
43837 +------------------+-----------------+------------------+------------------+
43838 | enable_jacobian  | OT_BOOL         | Enable           | casadi::Function |
43839 |                  |                 | derivative       | Internal         |
43840 |                  |                 | calculation      |                  |
43841 |                  |                 | using generated  |                  |
43842 |                  |                 | functions for    |                  |
43843 |                  |                 | Jacobians of all |                  |
43844 |                  |                 | differentiable   |                  |
43845 |                  |                 | outputs with     |                  |
43846 |                  |                 | respect to all   |                  |
43847 |                  |                 | differentiable   |                  |
43848 |                  |                 | inputs - if      |                  |
43849 |                  |                 | available.       |                  |
43850 |                  |                 | [default: true]  |                  |
43851 +------------------+-----------------+------------------+------------------+
43852 | enable_reverse   | OT_BOOL         | Enable           | casadi::Function |
43853 |                  |                 | derivative       | Internal         |
43854 |                  |                 | calculation      |                  |
43855 |                  |                 | using generated  |                  |
43856 |                  |                 | functions for    |                  |
43857 |                  |                 | transposed       |                  |
43858 |                  |                 | Jacobian-times-  |                  |
43859 |                  |                 | vector products  |                  |
43860 |                  |                 | - typically      |                  |
43861 |                  |                 | using reverse    |                  |
43862 |                  |                 | mode AD - if     |                  |
43863 |                  |                 | available.       |                  |
43864 |                  |                 | [default: true]  |                  |
43865 +------------------+-----------------+------------------+------------------+
43866 | equilibration    | OT_BOOL         | Equilibrate the  | casadi::LapackLu |
43867 |                  |                 | matrix           |                  |
43868 +------------------+-----------------+------------------+------------------+
43869 | fd_method        | OT_STRING       | Method for       | casadi::Function |
43870 |                  |                 | finite           | Internal         |
43871 |                  |                 | differencing     |                  |
43872 |                  |                 | [default         |                  |
43873 |                  |                 | 'central']       |                  |
43874 +------------------+-----------------+------------------+------------------+
43875 | fd_options       | OT_DICT         | Options to be    | casadi::Function |
43876 |                  |                 | passed to the    | Internal         |
43877 |                  |                 | finite           |                  |
43878 |                  |                 | difference       |                  |
43879 |                  |                 | instance         |                  |
43880 +------------------+-----------------+------------------+------------------+
43881 | forward_options  | OT_DICT         | Options to be    | casadi::Function |
43882 |                  |                 | passed to a      | Internal         |
43883 |                  |                 | forward mode     |                  |
43884 |                  |                 | constructor      |                  |
43885 +------------------+-----------------+------------------+------------------+
43886 | gather_stats     | OT_BOOL         | Deprecated       | casadi::Function |
43887 |                  |                 | option           | Internal         |
43888 |                  |                 | (ignored):       |                  |
43889 |                  |                 | Statistics are   |                  |
43890 |                  |                 | now always       |                  |
43891 |                  |                 | collected.       |                  |
43892 +------------------+-----------------+------------------+------------------+
43893 | input_scheme     | OT_STRINGVECTOR | Deprecated       | casadi::Function |
43894 |                  |                 | option (ignored) | Internal         |
43895 +------------------+-----------------+------------------+------------------+
43896 | inputs_check     | OT_BOOL         | Throw exceptions | casadi::Function |
43897 |                  |                 | when the         | Internal         |
43898 |                  |                 | numerical values |                  |
43899 |                  |                 | of the inputs    |                  |
43900 |                  |                 | don't make sense |                  |
43901 +------------------+-----------------+------------------+------------------+
43902 | is_diff_in       | OT_BOOLVECTOR   | Indicate for     | casadi::Function |
43903 |                  |                 | each input if it | Internal         |
43904 |                  |                 | should be        |                  |
43905 |                  |                 | differentiable.  |                  |
43906 +------------------+-----------------+------------------+------------------+
43907 | is_diff_out      | OT_BOOLVECTOR   | Indicate for     | casadi::Function |
43908 |                  |                 | each output if   | Internal         |
43909 |                  |                 | it should be     |                  |
43910 |                  |                 | differentiable.  |                  |
43911 +------------------+-----------------+------------------+------------------+
43912 | jac_penalty      | OT_DOUBLE       | When requested   | casadi::Function |
43913 |                  |                 | for a number of  | Internal         |
43914 |                  |                 | forward/reverse  |                  |
43915 |                  |                 | directions, it   |                  |
43916 |                  |                 | may be cheaper   |                  |
43917 |                  |                 | to compute first |                  |
43918 |                  |                 | the full         |                  |
43919 |                  |                 | jacobian and     |                  |
43920 |                  |                 | then multiply    |                  |
43921 |                  |                 | with seeds,      |                  |
43922 |                  |                 | rather than      |                  |
43923 |                  |                 | obtain the       |                  |
43924 |                  |                 | requested        |                  |
43925 |                  |                 | directions in a  |                  |
43926 |                  |                 | straightforward  |                  |
43927 |                  |                 | manner. Casadi   |                  |
43928 |                  |                 | uses a heuristic |                  |
43929 |                  |                 | to decide which  |                  |
43930 |                  |                 | is cheaper. A    |                  |
43931 |                  |                 | high value of    |                  |
43932 |                  |                 | 'jac_penalty'    |                  |
43933 |                  |                 | makes it less    |                  |
43934 |                  |                 | likely for the   |                  |
43935 |                  |                 | heurstic to      |                  |
43936 |                  |                 | chose the full   |                  |
43937 |                  |                 | Jacobian         |                  |
43938 |                  |                 | strategy. The    |                  |
43939 |                  |                 | special value -1 |                  |
43940 |                  |                 | indicates never  |                  |
43941 |                  |                 | to use the full  |                  |
43942 |                  |                 | Jacobian         |                  |
43943 |                  |                 | strategy         |                  |
43944 +------------------+-----------------+------------------+------------------+
43945 | jit              | OT_BOOL         | Use just-in-time | casadi::Function |
43946 |                  |                 | compiler to      | Internal         |
43947 |                  |                 | speed up the     |                  |
43948 |                  |                 | evaluation       |                  |
43949 +------------------+-----------------+------------------+------------------+
43950 | jit_cleanup      | OT_BOOL         | Cleanup up the   | casadi::Function |
43951 |                  |                 | temporary source | Internal         |
43952 |                  |                 | file that jit    |                  |
43953 |                  |                 | creates.         |                  |
43954 |                  |                 | Default: true    |                  |
43955 +------------------+-----------------+------------------+------------------+
43956 | jit_name         | OT_STRING       | The file name    | casadi::Function |
43957 |                  |                 | used to write    | Internal         |
43958 |                  |                 | out code. The    |                  |
43959 |                  |                 | actual file      |                  |
43960 |                  |                 | names used       |                  |
43961 |                  |                 | depend on 'jit_t |                  |
43962 |                  |                 | emp_suffix' and  |                  |
43963 |                  |                 | include          |                  |
43964 |                  |                 | extensions.      |                  |
43965 |                  |                 | Default:         |                  |
43966 |                  |                 | 'jit_tmp'        |                  |
43967 +------------------+-----------------+------------------+------------------+
43968 | jit_options      | OT_DICT         | Options to be    | casadi::Function |
43969 |                  |                 | passed to the    | Internal         |
43970 |                  |                 | jit compiler.    |                  |
43971 +------------------+-----------------+------------------+------------------+
43972 | jit_serialize    | OT_STRING       | Specify          | casadi::Function |
43973 |                  |                 | behaviour when   | Internal         |
43974 |                  |                 | serializing a    |                  |
43975 |                  |                 | jitted function: |                  |
43976 |                  |                 | SOURCE|link|embe |                  |
43977 |                  |                 | d.               |                  |
43978 +------------------+-----------------+------------------+------------------+
43979 | jit_temp_suffix  | OT_BOOL         | Use a temporary  | casadi::Function |
43980 |                  |                 | (seemingly       | Internal         |
43981 |                  |                 | random) filename |                  |
43982 |                  |                 | suffix for       |                  |
43983 |                  |                 | generated code   |                  |
43984 |                  |                 | and libraries.   |                  |
43985 |                  |                 | This is desired  |                  |
43986 |                  |                 | for thread-      |                  |
43987 |                  |                 | safety. This     |                  |
43988 |                  |                 | behaviour may    |                  |
43989 |                  |                 | defeat caching   |                  |
43990 |                  |                 | compiler         |                  |
43991 |                  |                 | wrappers.        |                  |
43992 |                  |                 | Default: true    |                  |
43993 +------------------+-----------------+------------------+------------------+
43994 | max_num_dir      | OT_INT          | Specify the      | casadi::Function |
43995 |                  |                 | maximum number   | Internal         |
43996 |                  |                 | of directions    |                  |
43997 |                  |                 | for derivative   |                  |
43998 |                  |                 | functions.       |                  |
43999 |                  |                 | Overrules the    |                  |
44000 |                  |                 | builtin optimize |                  |
44001 |                  |                 | d_num_dir.       |                  |
44002 +------------------+-----------------+------------------+------------------+
44003 | never_inline     | OT_BOOL         | Forbid inlining. | casadi::Function |
44004 |                  |                 |                  | Internal         |
44005 +------------------+-----------------+------------------+------------------+
44006 | output_scheme    | OT_STRINGVECTOR | Deprecated       | casadi::Function |
44007 |                  |                 | option (ignored) | Internal         |
44008 +------------------+-----------------+------------------+------------------+
44009 | print_in         | OT_BOOL         | Print numerical  | casadi::Function |
44010 |                  |                 | values of inputs | Internal         |
44011 |                  |                 | [default: false] |                  |
44012 +------------------+-----------------+------------------+------------------+
44013 | print_out        | OT_BOOL         | Print numerical  | casadi::Function |
44014 |                  |                 | values of        | Internal         |
44015 |                  |                 | outputs          |                  |
44016 |                  |                 | [default: false] |                  |
44017 +------------------+-----------------+------------------+------------------+
44018 | print_time       | OT_BOOL         | print            | casadi::Function |
44019 |                  |                 | information      | Internal         |
44020 |                  |                 | about execution  |                  |
44021 |                  |                 | time. Implies    |                  |
44022 |                  |                 | record_time.     |                  |
44023 +------------------+-----------------+------------------+------------------+
44024 | record_time      | OT_BOOL         | record           | casadi::Function |
44025 |                  |                 | information      | Internal         |
44026 |                  |                 | about execution  |                  |
44027 |                  |                 | time, for        |                  |
44028 |                  |                 | retrieval with   |                  |
44029 |                  |                 | stats().         |                  |
44030 +------------------+-----------------+------------------+------------------+
44031 | regularity_check | OT_BOOL         | Throw exceptions | casadi::Function |
44032 |                  |                 | when NaN or Inf  | Internal         |
44033 |                  |                 | appears during   |                  |
44034 |                  |                 | evaluation       |                  |
44035 +------------------+-----------------+------------------+------------------+
44036 | reverse_options  | OT_DICT         | Options to be    | casadi::Function |
44037 |                  |                 | passed to a      | Internal         |
44038 |                  |                 | reverse mode     |                  |
44039 |                  |                 | constructor      |                  |
44040 +------------------+-----------------+------------------+------------------+
44041 | user_data        | OT_VOIDPTR      | A user-defined   | casadi::Function |
44042 |                  |                 | field that can   | Internal         |
44043 |                  |                 | be used to       |                  |
44044 |                  |                 | identify the     |                  |
44045 |                  |                 | function or pass |                  |
44046 |                  |                 | additional       |                  |
44047 |                  |                 | information      |                  |
44048 +------------------+-----------------+------------------+------------------+
44049 | verbose          | OT_BOOL         | Verbose          | casadi::Function |
44050 |                  |                 | evaluation  for  | Internal         |
44051 |                  |                 | debugging        |                  |
44052 +------------------+-----------------+------------------+------------------+
44053 
44054 Diagrams
44055 --------
44056 
44057 
44058 
44059 C++ includes: lapack_lu.hpp ";
44060 
44061 %feature("docstring")  casadi::LinsolInternal::row() const  "
44062 
44063 [INTERNAL] ";
44064 
44065 %feature("docstring")  casadi::LapackLu::get_options() const  "
44066 
44067 [INTERNAL]  Options.
44068 
44069 ";
44070 
44071 %feature("docstring")  casadi::SharedObjectInternal::getCount() const  "
44072 
44073 [INTERNAL]  Get the reference count.
44074 
44075 ";
44076 
44077 %feature("docstring")  casadi::ProtoFunction::print_time(const std::map<
44078 std::string, FStats > &fstats) const  "
44079 
44080 [INTERNAL]  Print timing statistics.
44081 
44082 ";
44083 
44084 %feature("docstring")  casadi::LinsolInternal::disp_more(std::ostream
44085 &stream) const  "
44086 
44087 [INTERNAL]  Print more.
44088 
44089 ";
44090 
44091 %feature("docstring")  casadi::LinsolInternal::neig(void *mem, const double
44092 *A) const  "
44093 
44094 [INTERNAL]  Number of negative eigenvalues.
44095 
44096 ";
44097 
44098 %feature("docstring")  casadi::ProtoFunction::get_stats(void *mem) const  "
44099 
44100 [INTERNAL]  Get all statistics.
44101 
44102 ";
44103 
44104 %feature("docstring")  casadi::ProtoFunction::format_time(char *buffer,
44105 double time) const  "
44106 
44107 [INTERNAL]  Format time in a fixed width 8 format.
44108 
44109 ";
44110 
44111 
44112 // File: classcasadi_1_1LapackQr.xml
44113 %feature("docstring")  casadi::LapackQr::get_options() const  "
44114 
44115 [INTERNAL]  Options.
44116 
44117 ";
44118 
44119 %feature("docstring")  casadi::LapackQr::free_mem(void *mem) const  "
44120 
44121 [INTERNAL]  Free memory block.
44122 
44123 ";
44124 
44125 %feature("docstring")  casadi::SharedObjectInternal::getCount() const  "
44126 
44127 [INTERNAL]  Get the reference count.
44128 
44129 ";
44130 
44131 %feature("docstring")  casadi::ProtoFunction::memory(int ind) const  "
44132 
44133 [INTERNAL]  Memory objects.
44134 
44135 ";
44136 
44137 %feature("docstring")  casadi::LinsolInternal::sfact(void *mem, const double
44138 *A) const  "
44139 
44140 [INTERNAL] ";
44141 
44142 %feature("docstring")  casadi::LapackQr::alloc_mem() const  "
44143 
44144 [INTERNAL]  Create memory block.
44145 
44146 ";
44147 
44148 %feature("docstring")  casadi::LinsolInternal::disp_more(std::ostream
44149 &stream) const  "
44150 
44151 [INTERNAL]  Print more.
44152 
44153 ";
44154 
44155 %feature("docstring")  casadi::ProtoFunction::get_stats(void *mem) const  "
44156 
44157 [INTERNAL]  Get all statistics.
44158 
44159 ";
44160 
44161 %feature("docstring")  casadi::LinsolInternal::ncol() const  "
44162 
44163 [INTERNAL] ";
44164 
44165 %feature("docstring")  casadi::ProtoFunction::sprint(char *buf, size_t
44166 buf_sz, const char *fmt,...) const  "
44167 
44168 [INTERNAL]  C-style formatted printing to string.
44169 
44170 ";
44171 
44172 %feature("docstring")  casadi::LinsolInternal::disp(std::ostream &stream,
44173 bool more) const  "
44174 
44175 [INTERNAL]  Display object.
44176 
44177 ";
44178 
44179 %feature("docstring")  casadi::ProtoFunction::finalize() "
44180 
44181 [INTERNAL]  Finalize the object creation This function, which visits the
44182 class hierarchy in reverse order is run after init() has been completed.
44183 
44184 ";
44185 
44186 %feature("docstring")  casadi::LapackQr::solve_batch(void *mem, const double
44187 *A, double *x, casadi_int nrhs, bool tr) const  "
44188 
44189 [INTERNAL] ";
44190 
44191 %feature("docstring")  casadi::ProtoFunction::checkout() const  "
44192 
44193 [INTERNAL]  Checkout a memory object.
44194 
44195 ";
44196 
44197 %feature("docstring")  casadi::LinsolInternal::rank(void *mem, const double
44198 *A) const  "
44199 
44200 [INTERNAL]   Matrix rank.
44201 
44202 ";
44203 
44204 %feature("docstring")  casadi::LinsolInternal::colind() const  "
44205 
44206 [INTERNAL] ";
44207 
44208 %feature("docstring")  casadi::SharedObjectInternal::weak() "
44209 
44210 [INTERNAL]  Get a weak reference to the object.
44211 
44212 ";
44213 
44214 %feature("docstring")  casadi::LinsolInternal::nnz() const  "
44215 
44216 [INTERNAL] ";
44217 
44218 %feature("docstring")  casadi::ProtoFunction::generate_options(bool
44219 is_temp=false) const  "
44220 
44221 [INTERNAL]  Reconstruct options dict.
44222 
44223 ";
44224 
44225 %feature("docstring")
44226 casadi::LinsolInternal::serialize_type(SerializingStream &s) const  "
44227 
44228 [INTERNAL]  Serialize type information.
44229 
44230 ";
44231 
44232 %feature("docstring")  casadi::ProtoFunction::release(int mem) const  "
44233 
44234 [INTERNAL]  Release a memory object.
44235 
44236 ";
44237 
44238 %feature("docstring") casadi::LapackQr "
44239 
44240 'lapackqr' plugin for Linsol
44241 
44242 This class solves the linear system A.x=b by making an QR factorization of
44243 A: A = Q.R, with Q orthogonal and R upper triangular
44244 
44245 >List of available options
44246 
44247 +----------+--------+------------------------------------------------------+
44248 |    Id    |  Type  |                     Description                      |
44249 +==========+========+======================================================+
44250 | max_nrhs | OT_INT | Maximum number of right-hand-sides that get          |
44251 |          |        | processed in a single pass [default:10].             |
44252 +----------+--------+------------------------------------------------------+
44253 
44254 >List of available options
44255 
44256 +------------------+-----------------+------------------+------------------+
44257 |        Id        |      Type       |   Description    |     Used in      |
44258 +==================+=================+==================+==================+
44259 | ad_weight        | OT_DOUBLE       | Weighting factor | casadi::Function |
44260 |                  |                 | for derivative   | Internal         |
44261 |                  |                 | calculation.When |                  |
44262 |                  |                 | there is an      |                  |
44263 |                  |                 | option of either |                  |
44264 |                  |                 | using forward or |                  |
44265 |                  |                 | reverse mode     |                  |
44266 |                  |                 | directional      |                  |
44267 |                  |                 | derivatives, the |                  |
44268 |                  |                 | condition ad_wei |                  |
44269 |                  |                 | ght*nf<=(1-ad_we |                  |
44270 |                  |                 | ight)*na is used |                  |
44271 |                  |                 | where nf and na  |                  |
44272 |                  |                 | are estimates of |                  |
44273 |                  |                 | the number of    |                  |
44274 |                  |                 | forward/reverse  |                  |
44275 |                  |                 | mode directional |                  |
44276 |                  |                 | derivatives      |                  |
44277 |                  |                 | needed. By       |                  |
44278 |                  |                 | default,         |                  |
44279 |                  |                 | ad_weight is     |                  |
44280 |                  |                 | calculated       |                  |
44281 |                  |                 | automatically,   |                  |
44282 |                  |                 | but this can be  |                  |
44283 |                  |                 | overridden by    |                  |
44284 |                  |                 | setting this     |                  |
44285 |                  |                 | option. In       |                  |
44286 |                  |                 | particular, 0    |                  |
44287 |                  |                 | means forcing    |                  |
44288 |                  |                 | forward mode and |                  |
44289 |                  |                 | 1 forcing        |                  |
44290 |                  |                 | reverse mode.    |                  |
44291 |                  |                 | Leave unset for  |                  |
44292 |                  |                 | (class specific) |                  |
44293 |                  |                 | heuristics.      |                  |
44294 +------------------+-----------------+------------------+------------------+
44295 | ad_weight_sp     | OT_DOUBLE       | Weighting factor | casadi::Function |
44296 |                  |                 | for sparsity     | Internal         |
44297 |                  |                 | pattern          |                  |
44298 |                  |                 | calculation calc |                  |
44299 |                  |                 | ulation.Override |                  |
44300 |                  |                 | s default        |                  |
44301 |                  |                 | behavior. Set to |                  |
44302 |                  |                 | 0 and 1 to force |                  |
44303 |                  |                 | forward and      |                  |
44304 |                  |                 | reverse mode     |                  |
44305 |                  |                 | respectively.    |                  |
44306 |                  |                 | Cf. option       |                  |
44307 |                  |                 | \"ad_weight\".     |                  |
44308 |                  |                 | When set to -1,  |                  |
44309 |                  |                 | sparsity is      |                  |
44310 |                  |                 | completely       |                  |
44311 |                  |                 | ignored and      |                  |
44312 |                  |                 | dense matrices   |                  |
44313 |                  |                 | are used.        |                  |
44314 +------------------+-----------------+------------------+------------------+
44315 | always_inline    | OT_BOOL         | Force inlining.  | casadi::Function |
44316 |                  |                 |                  | Internal         |
44317 +------------------+-----------------+------------------+------------------+
44318 | compiler         | OT_STRING       | Just-in-time     | casadi::Function |
44319 |                  |                 | compiler plugin  | Internal         |
44320 |                  |                 | to be used.      |                  |
44321 +------------------+-----------------+------------------+------------------+
44322 | custom_jacobian  | OT_FUNCTION     | Override         | casadi::Function |
44323 |                  |                 | CasADi's AD. Use | Internal         |
44324 |                  |                 | together with    |                  |
44325 |                  |                 | 'jac_penalty':   |                  |
44326 |                  |                 | 0. Note: Highly  |                  |
44327 |                  |                 | experimental.    |                  |
44328 |                  |                 | Syntax may break |                  |
44329 |                  |                 | often.           |                  |
44330 +------------------+-----------------+------------------+------------------+
44331 | derivative_of    | OT_FUNCTION     | The function is  | casadi::Function |
44332 |                  |                 | a derivative of  | Internal         |
44333 |                  |                 | another          |                  |
44334 |                  |                 | function. The    |                  |
44335 |                  |                 | type of          |                  |
44336 |                  |                 | derivative       |                  |
44337 |                  |                 | (directional     |                  |
44338 |                  |                 | derivative,      |                  |
44339 |                  |                 | Jacobian) is     |                  |
44340 |                  |                 | inferred from    |                  |
44341 |                  |                 | the function     |                  |
44342 |                  |                 | name.            |                  |
44343 +------------------+-----------------+------------------+------------------+
44344 | dump             | OT_BOOL         | Dump function to | casadi::Function |
44345 |                  |                 | file upon first  | Internal         |
44346 |                  |                 | evaluation.      |                  |
44347 |                  |                 | [false]          |                  |
44348 +------------------+-----------------+------------------+------------------+
44349 | dump_dir         | OT_STRING       | Directory to     | casadi::Function |
44350 |                  |                 | dump             | Internal         |
44351 |                  |                 | inputs/outputs   |                  |
44352 |                  |                 | to. Make sure    |                  |
44353 |                  |                 | the directory    |                  |
44354 |                  |                 | exists [.]       |                  |
44355 +------------------+-----------------+------------------+------------------+
44356 | dump_format      | OT_STRING       | Choose file      | casadi::Function |
44357 |                  |                 | format to dump   | Internal         |
44358 |                  |                 | matrices. See    |                  |
44359 |                  |                 | DM.from_file     |                  |
44360 |                  |                 | [mtx]            |                  |
44361 +------------------+-----------------+------------------+------------------+
44362 | dump_in          | OT_BOOL         | Dump numerical   | casadi::Function |
44363 |                  |                 | values of inputs | Internal         |
44364 |                  |                 | to file          |                  |
44365 |                  |                 | (readable with   |                  |
44366 |                  |                 | DM.from_file )   |                  |
44367 |                  |                 | [default: false] |                  |
44368 +------------------+-----------------+------------------+------------------+
44369 | dump_out         | OT_BOOL         | Dump numerical   | casadi::Function |
44370 |                  |                 | values of        | Internal         |
44371 |                  |                 | outputs to file  |                  |
44372 |                  |                 | (readable with   |                  |
44373 |                  |                 | DM.from_file )   |                  |
44374 |                  |                 | [default: false] |                  |
44375 +------------------+-----------------+------------------+------------------+
44376 | enable_fd        | OT_BOOL         | Enable           | casadi::Function |
44377 |                  |                 | derivative       | Internal         |
44378 |                  |                 | calculation by   |                  |
44379 |                  |                 | finite           |                  |
44380 |                  |                 | differencing.    |                  |
44381 |                  |                 | [default:        |                  |
44382 |                  |                 | false]]          |                  |
44383 +------------------+-----------------+------------------+------------------+
44384 | enable_forward   | OT_BOOL         | Enable           | casadi::Function |
44385 |                  |                 | derivative       | Internal         |
44386 |                  |                 | calculation      |                  |
44387 |                  |                 | using generated  |                  |
44388 |                  |                 | functions for    |                  |
44389 |                  |                 | Jacobian-times-  |                  |
44390 |                  |                 | vector products  |                  |
44391 |                  |                 | - typically      |                  |
44392 |                  |                 | using forward    |                  |
44393 |                  |                 | mode AD - if     |                  |
44394 |                  |                 | available.       |                  |
44395 |                  |                 | [default: true]  |                  |
44396 +------------------+-----------------+------------------+------------------+
44397 | enable_jacobian  | OT_BOOL         | Enable           | casadi::Function |
44398 |                  |                 | derivative       | Internal         |
44399 |                  |                 | calculation      |                  |
44400 |                  |                 | using generated  |                  |
44401 |                  |                 | functions for    |                  |
44402 |                  |                 | Jacobians of all |                  |
44403 |                  |                 | differentiable   |                  |
44404 |                  |                 | outputs with     |                  |
44405 |                  |                 | respect to all   |                  |
44406 |                  |                 | differentiable   |                  |
44407 |                  |                 | inputs - if      |                  |
44408 |                  |                 | available.       |                  |
44409 |                  |                 | [default: true]  |                  |
44410 +------------------+-----------------+------------------+------------------+
44411 | enable_reverse   | OT_BOOL         | Enable           | casadi::Function |
44412 |                  |                 | derivative       | Internal         |
44413 |                  |                 | calculation      |                  |
44414 |                  |                 | using generated  |                  |
44415 |                  |                 | functions for    |                  |
44416 |                  |                 | transposed       |                  |
44417 |                  |                 | Jacobian-times-  |                  |
44418 |                  |                 | vector products  |                  |
44419 |                  |                 | - typically      |                  |
44420 |                  |                 | using reverse    |                  |
44421 |                  |                 | mode AD - if     |                  |
44422 |                  |                 | available.       |                  |
44423 |                  |                 | [default: true]  |                  |
44424 +------------------+-----------------+------------------+------------------+
44425 | fd_method        | OT_STRING       | Method for       | casadi::Function |
44426 |                  |                 | finite           | Internal         |
44427 |                  |                 | differencing     |                  |
44428 |                  |                 | [default         |                  |
44429 |                  |                 | 'central']       |                  |
44430 +------------------+-----------------+------------------+------------------+
44431 | fd_options       | OT_DICT         | Options to be    | casadi::Function |
44432 |                  |                 | passed to the    | Internal         |
44433 |                  |                 | finite           |                  |
44434 |                  |                 | difference       |                  |
44435 |                  |                 | instance         |                  |
44436 +------------------+-----------------+------------------+------------------+
44437 | forward_options  | OT_DICT         | Options to be    | casadi::Function |
44438 |                  |                 | passed to a      | Internal         |
44439 |                  |                 | forward mode     |                  |
44440 |                  |                 | constructor      |                  |
44441 +------------------+-----------------+------------------+------------------+
44442 | gather_stats     | OT_BOOL         | Deprecated       | casadi::Function |
44443 |                  |                 | option           | Internal         |
44444 |                  |                 | (ignored):       |                  |
44445 |                  |                 | Statistics are   |                  |
44446 |                  |                 | now always       |                  |
44447 |                  |                 | collected.       |                  |
44448 +------------------+-----------------+------------------+------------------+
44449 | input_scheme     | OT_STRINGVECTOR | Deprecated       | casadi::Function |
44450 |                  |                 | option (ignored) | Internal         |
44451 +------------------+-----------------+------------------+------------------+
44452 | inputs_check     | OT_BOOL         | Throw exceptions | casadi::Function |
44453 |                  |                 | when the         | Internal         |
44454 |                  |                 | numerical values |                  |
44455 |                  |                 | of the inputs    |                  |
44456 |                  |                 | don't make sense |                  |
44457 +------------------+-----------------+------------------+------------------+
44458 | is_diff_in       | OT_BOOLVECTOR   | Indicate for     | casadi::Function |
44459 |                  |                 | each input if it | Internal         |
44460 |                  |                 | should be        |                  |
44461 |                  |                 | differentiable.  |                  |
44462 +------------------+-----------------+------------------+------------------+
44463 | is_diff_out      | OT_BOOLVECTOR   | Indicate for     | casadi::Function |
44464 |                  |                 | each output if   | Internal         |
44465 |                  |                 | it should be     |                  |
44466 |                  |                 | differentiable.  |                  |
44467 +------------------+-----------------+------------------+------------------+
44468 | jac_penalty      | OT_DOUBLE       | When requested   | casadi::Function |
44469 |                  |                 | for a number of  | Internal         |
44470 |                  |                 | forward/reverse  |                  |
44471 |                  |                 | directions, it   |                  |
44472 |                  |                 | may be cheaper   |                  |
44473 |                  |                 | to compute first |                  |
44474 |                  |                 | the full         |                  |
44475 |                  |                 | jacobian and     |                  |
44476 |                  |                 | then multiply    |                  |
44477 |                  |                 | with seeds,      |                  |
44478 |                  |                 | rather than      |                  |
44479 |                  |                 | obtain the       |                  |
44480 |                  |                 | requested        |                  |
44481 |                  |                 | directions in a  |                  |
44482 |                  |                 | straightforward  |                  |
44483 |                  |                 | manner. Casadi   |                  |
44484 |                  |                 | uses a heuristic |                  |
44485 |                  |                 | to decide which  |                  |
44486 |                  |                 | is cheaper. A    |                  |
44487 |                  |                 | high value of    |                  |
44488 |                  |                 | 'jac_penalty'    |                  |
44489 |                  |                 | makes it less    |                  |
44490 |                  |                 | likely for the   |                  |
44491 |                  |                 | heurstic to      |                  |
44492 |                  |                 | chose the full   |                  |
44493 |                  |                 | Jacobian         |                  |
44494 |                  |                 | strategy. The    |                  |
44495 |                  |                 | special value -1 |                  |
44496 |                  |                 | indicates never  |                  |
44497 |                  |                 | to use the full  |                  |
44498 |                  |                 | Jacobian         |                  |
44499 |                  |                 | strategy         |                  |
44500 +------------------+-----------------+------------------+------------------+
44501 | jit              | OT_BOOL         | Use just-in-time | casadi::Function |
44502 |                  |                 | compiler to      | Internal         |
44503 |                  |                 | speed up the     |                  |
44504 |                  |                 | evaluation       |                  |
44505 +------------------+-----------------+------------------+------------------+
44506 | jit_cleanup      | OT_BOOL         | Cleanup up the   | casadi::Function |
44507 |                  |                 | temporary source | Internal         |
44508 |                  |                 | file that jit    |                  |
44509 |                  |                 | creates.         |                  |
44510 |                  |                 | Default: true    |                  |
44511 +------------------+-----------------+------------------+------------------+
44512 | jit_name         | OT_STRING       | The file name    | casadi::Function |
44513 |                  |                 | used to write    | Internal         |
44514 |                  |                 | out code. The    |                  |
44515 |                  |                 | actual file      |                  |
44516 |                  |                 | names used       |                  |
44517 |                  |                 | depend on 'jit_t |                  |
44518 |                  |                 | emp_suffix' and  |                  |
44519 |                  |                 | include          |                  |
44520 |                  |                 | extensions.      |                  |
44521 |                  |                 | Default:         |                  |
44522 |                  |                 | 'jit_tmp'        |                  |
44523 +------------------+-----------------+------------------+------------------+
44524 | jit_options      | OT_DICT         | Options to be    | casadi::Function |
44525 |                  |                 | passed to the    | Internal         |
44526 |                  |                 | jit compiler.    |                  |
44527 +------------------+-----------------+------------------+------------------+
44528 | jit_serialize    | OT_STRING       | Specify          | casadi::Function |
44529 |                  |                 | behaviour when   | Internal         |
44530 |                  |                 | serializing a    |                  |
44531 |                  |                 | jitted function: |                  |
44532 |                  |                 | SOURCE|link|embe |                  |
44533 |                  |                 | d.               |                  |
44534 +------------------+-----------------+------------------+------------------+
44535 | jit_temp_suffix  | OT_BOOL         | Use a temporary  | casadi::Function |
44536 |                  |                 | (seemingly       | Internal         |
44537 |                  |                 | random) filename |                  |
44538 |                  |                 | suffix for       |                  |
44539 |                  |                 | generated code   |                  |
44540 |                  |                 | and libraries.   |                  |
44541 |                  |                 | This is desired  |                  |
44542 |                  |                 | for thread-      |                  |
44543 |                  |                 | safety. This     |                  |
44544 |                  |                 | behaviour may    |                  |
44545 |                  |                 | defeat caching   |                  |
44546 |                  |                 | compiler         |                  |
44547 |                  |                 | wrappers.        |                  |
44548 |                  |                 | Default: true    |                  |
44549 +------------------+-----------------+------------------+------------------+
44550 | max_nrhs         | OT_INT          | Maximum number   | casadi::LapackQr |
44551 |                  |                 | of right-hand-   |                  |
44552 |                  |                 | sides that get   |                  |
44553 |                  |                 | processed in a   |                  |
44554 |                  |                 | single pass      |                  |
44555 |                  |                 | [default:10].    |                  |
44556 +------------------+-----------------+------------------+------------------+
44557 | max_num_dir      | OT_INT          | Specify the      | casadi::Function |
44558 |                  |                 | maximum number   | Internal         |
44559 |                  |                 | of directions    |                  |
44560 |                  |                 | for derivative   |                  |
44561 |                  |                 | functions.       |                  |
44562 |                  |                 | Overrules the    |                  |
44563 |                  |                 | builtin optimize |                  |
44564 |                  |                 | d_num_dir.       |                  |
44565 +------------------+-----------------+------------------+------------------+
44566 | never_inline     | OT_BOOL         | Forbid inlining. | casadi::Function |
44567 |                  |                 |                  | Internal         |
44568 +------------------+-----------------+------------------+------------------+
44569 | output_scheme    | OT_STRINGVECTOR | Deprecated       | casadi::Function |
44570 |                  |                 | option (ignored) | Internal         |
44571 +------------------+-----------------+------------------+------------------+
44572 | print_in         | OT_BOOL         | Print numerical  | casadi::Function |
44573 |                  |                 | values of inputs | Internal         |
44574 |                  |                 | [default: false] |                  |
44575 +------------------+-----------------+------------------+------------------+
44576 | print_out        | OT_BOOL         | Print numerical  | casadi::Function |
44577 |                  |                 | values of        | Internal         |
44578 |                  |                 | outputs          |                  |
44579 |                  |                 | [default: false] |                  |
44580 +------------------+-----------------+------------------+------------------+
44581 | print_time       | OT_BOOL         | print            | casadi::Function |
44582 |                  |                 | information      | Internal         |
44583 |                  |                 | about execution  |                  |
44584 |                  |                 | time. Implies    |                  |
44585 |                  |                 | record_time.     |                  |
44586 +------------------+-----------------+------------------+------------------+
44587 | record_time      | OT_BOOL         | record           | casadi::Function |
44588 |                  |                 | information      | Internal         |
44589 |                  |                 | about execution  |                  |
44590 |                  |                 | time, for        |                  |
44591 |                  |                 | retrieval with   |                  |
44592 |                  |                 | stats().         |                  |
44593 +------------------+-----------------+------------------+------------------+
44594 | regularity_check | OT_BOOL         | Throw exceptions | casadi::Function |
44595 |                  |                 | when NaN or Inf  | Internal         |
44596 |                  |                 | appears during   |                  |
44597 |                  |                 | evaluation       |                  |
44598 +------------------+-----------------+------------------+------------------+
44599 | reverse_options  | OT_DICT         | Options to be    | casadi::Function |
44600 |                  |                 | passed to a      | Internal         |
44601 |                  |                 | reverse mode     |                  |
44602 |                  |                 | constructor      |                  |
44603 +------------------+-----------------+------------------+------------------+
44604 | user_data        | OT_VOIDPTR      | A user-defined   | casadi::Function |
44605 |                  |                 | field that can   | Internal         |
44606 |                  |                 | be used to       |                  |
44607 |                  |                 | identify the     |                  |
44608 |                  |                 | function or pass |                  |
44609 |                  |                 | additional       |                  |
44610 |                  |                 | information      |                  |
44611 +------------------+-----------------+------------------+------------------+
44612 | verbose          | OT_BOOL         | Verbose          | casadi::Function |
44613 |                  |                 | evaluation  for  | Internal         |
44614 |                  |                 | debugging        |                  |
44615 +------------------+-----------------+------------------+------------------+
44616 
44617 Diagrams
44618 --------
44619 
44620 
44621 
44622 C++ includes: lapack_qr.hpp ";
44623 
44624 %feature("docstring")  casadi::LinsolInternal::row() const  "
44625 
44626 [INTERNAL] ";
44627 
44628 %feature("docstring")  casadi::LapackQr::init_mem(void *mem) const  "
44629 
44630 [INTERNAL]  Initalize memory block.
44631 
44632 ";
44633 
44634 %feature("docstring")  casadi::ProtoFunction::print(const char *fmt,...)
44635 const  "
44636 
44637 [INTERNAL]  C-style formatted printing during evaluation.
44638 
44639 ";
44640 
44641 %feature("docstring")  casadi::LinsolInternal::linsol_eval_sx(const SXElem
44642 **arg, SXElem **res, casadi_int *iw, SXElem *w, void *mem, bool tr,
44643 casadi_int nrhs) const  "
44644 
44645 [INTERNAL]  Evaluate SX, possibly transposed.
44646 
44647 ";
44648 
44649 %feature("docstring")  casadi::LinsolInternal::neig(void *mem, const double
44650 *A) const  "
44651 
44652 [INTERNAL]  Number of negative eigenvalues.
44653 
44654 ";
44655 
44656 %feature("docstring")  casadi::LinsolInternal::generate(CodeGenerator &g,
44657 const std::string &A, const std::string &x, casadi_int nrhs, bool tr) const
44658 "
44659 
44660 [INTERNAL]  Generate C code.
44661 
44662 ";
44663 
44664 %feature("docstring")  casadi::ProtoFunction::serialize_base_function()
44665 const  "
44666 
44667 [INTERNAL]  String used to identify the immediate FunctionInternal subclass.
44668 
44669 ";
44670 
44671 %feature("docstring")  casadi::ProtoFunction::clear_mem() "
44672 
44673 [INTERNAL]  Clear all memory (called from destructor)
44674 
44675 ";
44676 
44677 %feature("docstring") casadi::LapackQr::LapackQr(const std::string &name,
44678 const Sparsity &sp) "
44679 
44680 [INTERNAL] ";
44681 
44682 %feature("docstring")  casadi::LapackQr::class_name() const  "
44683 
44684 [INTERNAL]  Readable name of the internal class.
44685 
44686 ";
44687 
44688 %feature("docstring")  casadi::LapackQr::nfact(void *mem, const double *A)
44689 const  "
44690 
44691 [INTERNAL]  Numeric factorization.
44692 
44693 ";
44694 
44695 %feature("docstring")  casadi::LinsolInternal::nrow() const  "
44696 
44697 [INTERNAL]  Get sparsity pattern.
44698 
44699 ";
44700 
44701 %feature("docstring")  casadi::LapackQr::solve(void *mem, const double *A,
44702 double *x, casadi_int nrhs, bool tr) const  "
44703 
44704 [INTERNAL] ";
44705 
44706 %feature("docstring")  casadi::ProtoFunction::serialize(SerializingStream
44707 &s) const  "
44708 
44709 [INTERNAL]  Serialize an object.
44710 
44711 ";
44712 
44713 %feature("docstring") casadi::LapackQr::~LapackQr "
44714 
44715 [INTERNAL] ";
44716 
44717 %feature("docstring")  casadi::LapackQr::init(const Dict &opts)  "
44718 
44719 [INTERNAL]  Initialize.
44720 
44721 ";
44722 
44723 %feature("docstring")  casadi::ProtoFunction::print_time(const std::map<
44724 std::string, FStats > &fstats) const  "
44725 
44726 [INTERNAL]  Print timing statistics.
44727 
44728 ";
44729 
44730 %feature("docstring")  casadi::ProtoFunction::construct(const Dict &opts) "
44731 
44732 [INTERNAL]  Construct Prepares the function for evaluation.
44733 
44734 ";
44735 
44736 %feature("docstring")  casadi::ProtoFunction::format_time(char *buffer,
44737 double time) const  "
44738 
44739 [INTERNAL]  Format time in a fixed width 8 format.
44740 
44741 ";
44742 
44743 %feature("docstring")  casadi::LapackQr::plugin_name() const  "
44744 
44745 [INTERNAL] ";
44746 
44747 %feature("docstring")  casadi::LapackQr::serialize_body(SerializingStream
44748 &s) const  "
44749 
44750 [INTERNAL]  Serialize an object without type information.
44751 
44752 ";
44753 
44754 
44755 // File: classcasadi_1_1LinearInterpolant.xml
44756 %feature("docstring")  casadi::Interpolant::get_sparsity_out(casadi_int i)
44757 "
44758 
44759 [INTERNAL]  Sparsities of function inputs and outputs.
44760 
44761 ";
44762 
44763 %feature("docstring")  casadi::ProtoFunction::print(const char *fmt,...)
44764 const  "
44765 
44766 [INTERNAL]  C-style formatted printing during evaluation.
44767 
44768 ";
44769 
44770 %feature("docstring")  casadi::FunctionInternal::incache(const std::string
44771 &fname, Function &f, const std::string &suffix="") const  "
44772 
44773 [INTERNAL]  Get function in cache.
44774 
44775 ";
44776 
44777 %feature("docstring")  casadi::FunctionInternal::replace_res(const
44778 std::vector< M > &res, casadi_int npar) const  "
44779 
44780 [INTERNAL]  Replace 0-by-0 outputs.
44781 
44782 ";
44783 
44784 %feature("docstring")  casadi::FunctionInternal::slice(const std::string
44785 &name, const std::vector< casadi_int > &order_in, const std::vector<
44786 casadi_int > &order_out, const Dict &opts) const  "
44787 
44788 [INTERNAL]  returns a new function with a selection of inputs/outputs of the
44789 original
44790 
44791 ";
44792 
44793 %feature("docstring")  casadi::FunctionInternal::n_instructions() const  "
44794 
44795 [INTERNAL]  Get the number of atomic operations.
44796 
44797 ";
44798 
44799 %feature("docstring")  casadi::FunctionInternal::check_arg(const
44800 std::vector< M > &arg, casadi_int &npar) const  "
44801 
44802 [INTERNAL]  Check if input arguments have correct length and dimensions.
44803 
44804 Raises errors.
44805 
44806 Parameters:
44807 -----------
44808 
44809 npar[in]:  normal usage: 1, disallow pararallel calls: -1
44810 
44811 npar:  max number of horizontal repetitions across all arguments (or -1)
44812 
44813 ";
44814 
44815 %feature("docstring")  casadi::FunctionInternal::sz_w() const  "
44816 
44817 [INTERNAL]  Get required length of w field.
44818 
44819 ";
44820 
44821 %feature("docstring")  casadi::FunctionInternal::get_abstol() const  "
44822 
44823 [INTERNAL]  Get absolute tolerance.
44824 
44825 ";
44826 
44827 %feature("docstring")  casadi::FunctionInternal::alloc_iw(size_t sz_iw, bool
44828 persistent=false) "
44829 
44830 [INTERNAL]  Ensure required length of iw field.
44831 
44832 ";
44833 
44834 %feature("docstring")  casadi::FunctionInternal::size1_in(casadi_int ind)
44835 const  "
44836 
44837 [INTERNAL]  Input/output dimensions.
44838 
44839 ";
44840 
44841 %feature("docstring")  casadi::FunctionInternal::call_reverse(const
44842 std::vector< MX > &arg, const std::vector< MX > &res, const std::vector<
44843 std::vector< MX > > &aseed, std::vector< std::vector< MX > > &asens, bool
44844 always_inline, bool never_inline) const  "
44845 
44846 [INTERNAL]  Reverse mode, virtual functions overloaded in derived classes.
44847 
44848 ";
44849 
44850 %feature("docstring")  casadi::FunctionInternal::call_reverse(const
44851 std::vector< SX > &arg, const std::vector< SX > &res, const std::vector<
44852 std::vector< SX > > &aseed, std::vector< std::vector< SX > > &asens, bool
44853 always_inline, bool never_inline) const  "
44854 
44855 [INTERNAL]  Reverse mode, virtual functions overloaded in derived classes.
44856 
44857 ";
44858 
44859 %feature("docstring")  casadi::FunctionInternal::generate_lifted(Function
44860 &vdef_fcn, Function &vinit_fcn) const  "
44861 
44862 [INTERNAL]  Extract the functions needed for the Lifted Newton method.
44863 
44864 ";
44865 
44866 %feature("docstring")  casadi::FunctionInternal::sp_weight() const  "
44867 
44868 [INTERNAL]  Weighting factor for chosing forward/reverse mode, sparsity
44869 propagation.
44870 
44871 ";
44872 
44873 %feature("docstring")
44874 casadi::FunctionInternal::codegen_sparsities(CodeGenerator &g) const  "
44875 
44876 [INTERNAL]  Codegen sparsities.
44877 
44878 ";
44879 
44880 %feature("docstring")
44881 casadi::LinearInterpolant::serialize_body(SerializingStream &s) const  "
44882 
44883 [INTERNAL]  Serialize an object without type information.
44884 
44885 ";
44886 
44887 %feature("docstring")  casadi::FunctionInternal::set_work(void *mem, const
44888 double **&arg, double **&res, casadi_int *&iw, double *&w) const  "
44889 
44890 [INTERNAL]  Set the (persistent) work vectors.
44891 
44892 ";
44893 
44894 %feature("docstring")  casadi::FunctionInternal::project_arg(const
44895 std::vector< M > &arg, casadi_int npar) const  "
44896 
44897 [INTERNAL]   Project sparsities.
44898 
44899 ";
44900 
44901 %feature("docstring")  casadi::FunctionInternal::mx_in(casadi_int ind) const
44902 "
44903 
44904 [INTERNAL]  Get function input(s) and output(s)
44905 
44906 ";
44907 
44908 %feature("docstring")  casadi::FunctionInternal::mx_in() const  "
44909 
44910 [INTERNAL]  Get function input(s) and output(s)
44911 
44912 ";
44913 
44914 %feature("docstring")
44915 casadi::FunctionInternal::codegen_alloc_mem(CodeGenerator &g) const  "
44916 
44917 [INTERNAL]  Codegen decref for alloc_mem.
44918 
44919 ";
44920 
44921 %feature("docstring")  casadi::LinearInterpolant::get_jacobian(const
44922 std::string &name, const std::vector< std::string > &inames, const
44923 std::vector< std::string > &onames, const Dict &opts) const  "
44924 
44925 [INTERNAL]  Full Jacobian.
44926 
44927 ";
44928 
44929 %feature("docstring")  casadi::FunctionInternal::replace_fseed(const
44930 std::vector< std::vector< M >> &fseed, casadi_int npar) const  "
44931 
44932 [INTERNAL]  Replace 0-by-0 forward seeds.
44933 
44934 ";
44935 
44936 %feature("docstring")  casadi::FunctionInternal::replace_fseed(const
44937 std::vector< std::vector< M > > &fseed, casadi_int npar) const  "
44938 
44939 [INTERNAL] ";
44940 
44941 %feature("docstring")  casadi::FunctionInternal::instruction_id(casadi_int
44942 k) const  "
44943 
44944 [INTERNAL]  Get an atomic operation operator index.
44945 
44946 ";
44947 
44948 %feature("docstring")  casadi::FunctionInternal::has_eval_dm() const  "
44949 
44950 [INTERNAL]  Evaluate with DM matrices.
44951 
44952 ";
44953 
44954 %feature("docstring")  casadi::FunctionInternal::symbolic_output(const
44955 std::vector< MX > &arg) const  "
44956 
44957 [INTERNAL]  Get a vector of symbolic variables corresponding to the outputs.
44958 
44959 ";
44960 
44961 %feature("docstring")  casadi::LinearInterpolant::has_jacobian() const  "
44962 
44963 [INTERNAL]  Full Jacobian.
44964 
44965 ";
44966 
44967 %feature("docstring")  casadi::FunctionInternal::size2_in(casadi_int ind)
44968 const  "
44969 
44970 [INTERNAL]  Input/output dimensions.
44971 
44972 ";
44973 
44974 %feature("docstring")  casadi::FunctionInternal::get_max_in(casadi_int ind)
44975 const  "
44976 
44977 [INTERNAL]  Get largest input value.
44978 
44979 ";
44980 
44981 %feature("docstring")  casadi::FunctionInternal::convert_arg(const
44982 std::vector< M > &arg) const  "
44983 
44984 [INTERNAL]  Convert from/to input/output lists/map.
44985 
44986 ";
44987 
44988 %feature("docstring")  casadi::FunctionInternal::convert_arg(const std::map<
44989 std::string, M > &arg) const  "
44990 
44991 [INTERNAL]  Convert from/to input/output lists/map.
44992 
44993 ";
44994 
44995 %feature("docstring")  casadi::SharedObjectInternal::weak() "
44996 
44997 [INTERNAL]  Get a weak reference to the object.
44998 
44999 ";
45000 
45001 %feature("docstring")  casadi::FunctionInternal::sx_in(casadi_int ind) const
45002 "
45003 
45004 [INTERNAL]  Get function input(s) and output(s)
45005 
45006 ";
45007 
45008 %feature("docstring")  casadi::FunctionInternal::sx_in() const  "
45009 
45010 [INTERNAL]  Get function input(s) and output(s)
45011 
45012 ";
45013 
45014 %feature("docstring")  casadi::ProtoFunction::alloc_mem() const  "
45015 
45016 [INTERNAL]  Create memory block.
45017 
45018 ";
45019 
45020 %feature("docstring")
45021 casadi::FunctionInternal::instruction_output(casadi_int k) const  "
45022 
45023 [INTERNAL]  Get the (integer) output argument of an atomic operation.
45024 
45025 ";
45026 
45027 %feature("docstring")  casadi::FunctionInternal::jac() const  "
45028 
45029 [INTERNAL]  Return Jacobian of all input elements with respect to all output
45030 elements.
45031 
45032 ";
45033 
45034 %feature("docstring")  casadi::FunctionInternal::get_forward(casadi_int
45035 nfwd, const std::string &name, const std::vector< std::string > &inames,
45036 const std::vector< std::string > &onames, const Dict &opts) const  "
45037 
45038 [INTERNAL]  Return function that calculates forward derivatives
45039 forward(nfwd) returns a cached instance if available, and calls  Function
45040 get_forward(casadi_int nfwd) if no cached version is available.
45041 
45042 ";
45043 
45044 %feature("docstring")  casadi::FunctionInternal::index_out(const std::string
45045 &name) const  "
45046 
45047 [INTERNAL]  Get output scheme index by name.
45048 
45049 ";
45050 
45051 %feature("docstring")
45052 casadi::FunctionInternal::codegen_init_mem(CodeGenerator &g) const  "
45053 
45054 [INTERNAL]  Codegen decref for init_mem.
45055 
45056 ";
45057 
45058 %feature("docstring")  casadi::Interpolant::coeff_size() const  "
45059 
45060 [INTERNAL]  Size of the flattened coefficients vector.
45061 
45062 ";
45063 
45064 %feature("docstring")  casadi::FunctionInternal::free_mx() const  "
45065 
45066 [INTERNAL]  Get free variables ( MX)
45067 
45068 ";
45069 
45070 %feature("docstring")
45071 casadi::FunctionInternal::jacobian_sparsity_filter(const Sparsity &sp) const
45072 "
45073 
45074 [INTERNAL]  Filter out nonzeros in the full sparsity jacobian according to
45075 is_diff_in/out.
45076 
45077 ";
45078 
45079 %feature("docstring")  casadi::FunctionInternal::convert_res(const
45080 std::vector< M > &res) const  "
45081 
45082 [INTERNAL]  Convert from/to input/output lists/map.
45083 
45084 ";
45085 
45086 %feature("docstring")  casadi::FunctionInternal::convert_res(const std::map<
45087 std::string, M > &res) const  "
45088 
45089 [INTERNAL]  Convert from/to input/output lists/map.
45090 
45091 ";
45092 
45093 %feature("docstring")  casadi::FunctionInternal::get_partition(casadi_int
45094 iind, casadi_int oind, Sparsity &D1, Sparsity &D2, bool compact, bool
45095 symmetric, bool allow_forward, bool allow_reverse) const  "
45096 
45097 [INTERNAL]  Get the unidirectional or bidirectional partition.
45098 
45099 ";
45100 
45101 %feature("docstring")  casadi::Interpolant::arg_grid() const  "
45102 
45103 [INTERNAL] ";
45104 
45105 %feature("docstring")  casadi::FunctionInternal::size_in(casadi_int ind)
45106 const  "
45107 
45108 [INTERNAL]  Input/output dimensions.
45109 
45110 ";
45111 
45112 %feature("docstring")  casadi::FunctionInternal::get_jacobian_sparsity()
45113 const  "
45114 
45115 [INTERNAL]  Get Jacobian sparsity.
45116 
45117 ";
45118 
45119 %feature("docstring")  casadi::FunctionInternal::alloc(const Function &f,
45120 bool persistent=false) "
45121 
45122 [INTERNAL]  Ensure work vectors long enough to evaluate function.
45123 
45124 ";
45125 
45126 %feature("docstring")  casadi::Interpolant::get_n_in()  "
45127 
45128 [INTERNAL]  Number of function inputs and outputs.
45129 
45130 ";
45131 
45132 %feature("docstring")  casadi::FunctionInternal::has_derivative() const  "
45133 
45134 [INTERNAL]  Can derivatives be calculated in any way?
45135 
45136 ";
45137 
45138 %feature("docstring")  casadi::FunctionInternal::print_options(std::ostream
45139 &stream) const  "
45140 
45141 [INTERNAL]  Print list of options.
45142 
45143 ";
45144 
45145 %feature("docstring")  casadi::FunctionInternal::sx_out(casadi_int ind)
45146 const  "
45147 
45148 [INTERNAL]  Get function input(s) and output(s)
45149 
45150 ";
45151 
45152 %feature("docstring")  casadi::FunctionInternal::sx_out() const  "
45153 
45154 [INTERNAL]  Get function input(s) and output(s)
45155 
45156 ";
45157 
45158 %feature("docstring")  casadi::SharedObjectInternal::getCount() const  "
45159 
45160 [INTERNAL]  Get the reference count.
45161 
45162 ";
45163 
45164 %feature("docstring")  casadi::ProtoFunction::free_mem(void *mem) const  "
45165 
45166 [INTERNAL]  Free memory block.
45167 
45168 ";
45169 
45170 %feature("docstring")  casadi::FunctionInternal::nnz_in() const  "
45171 
45172 [INTERNAL]  Number of input/output nonzeros.
45173 
45174 ";
45175 
45176 %feature("docstring")  casadi::FunctionInternal::nnz_in(casadi_int ind)
45177 const  "
45178 
45179 [INTERNAL]  Number of input/output nonzeros.
45180 
45181 ";
45182 
45183 %feature("docstring")  casadi::FunctionInternal::which_depends(const
45184 std::string &s_in, const std::vector< std::string > &s_out, casadi_int
45185 order, bool tr=false) const  "
45186 
45187 [INTERNAL]  Which variables enter with some order.
45188 
45189 Parameters:
45190 -----------
45191 
45192 s_in:   Input name
45193 
45194 s_out:   Output name(s)
45195 
45196 order:  Only 1 (linear) and 2 (nonlinear) allowed
45197 
45198 tr:  Flip the relationship. Return which expressions contain the variables
45199 
45200 ";
45201 
45202 %feature("docstring")  casadi::FunctionInternal::size_out(casadi_int ind)
45203 const  "
45204 
45205 [INTERNAL]  Input/output dimensions.
45206 
45207 ";
45208 
45209 %feature("docstring")  casadi::FunctionInternal::check_mat(const Sparsity
45210 &arg, const Sparsity &inp, casadi_int &npar) "
45211 
45212 [INTERNAL]  Helper function
45213 
45214 Parameters:
45215 -----------
45216 
45217 npar[in]:  normal usage: 1, disallow pararallel calls: -1
45218 
45219 npar[out]:  required number of parallel calls (or -1)
45220 
45221 ";
45222 
45223 %feature("docstring")  casadi::FunctionInternal::print_option(const
45224 std::string &name, std::ostream &stream) const  "
45225 
45226 [INTERNAL]  Print all information there is to know about a certain option.
45227 
45228 ";
45229 
45230 %feature("docstring")  casadi::FunctionInternal::forward(casadi_int nfwd)
45231 const  "
45232 
45233 [INTERNAL]  Return function that calculates forward derivatives
45234 forward(nfwd) returns a cached instance if available, and calls  Function
45235 get_forward(casadi_int nfwd) if no cached version is available.
45236 
45237 ";
45238 
45239 %feature("docstring")  casadi::Interpolant::arg_values() const  "
45240 
45241 [INTERNAL] ";
45242 
45243 %feature("docstring")  casadi::FunctionInternal::symbolicAdjSeed(casadi_int
45244 nadj, const std::vector< MatType > &v) const  "
45245 
45246 [INTERNAL]  Symbolic expressions for the adjoint seeds.
45247 
45248 ";
45249 
45250 %feature("docstring")  casadi::FunctionInternal::codegen(CodeGenerator &g,
45251 const std::string &fname) const  "
45252 
45253 [INTERNAL]  Generate code the function.
45254 
45255 ";
45256 
45257 %feature("docstring")
45258 casadi::FunctionInternal::instruction_input(casadi_int k) const  "
45259 
45260 [INTERNAL]  Get the (integer) input arguments of an atomic operation.
45261 
45262 ";
45263 
45264 %feature("docstring")  casadi::FunctionInternal::eval_mx(const MXVector
45265 &arg, MXVector &res, bool always_inline, bool never_inline) const  "
45266 
45267 [INTERNAL]  Evaluate with symbolic matrices.
45268 
45269 ";
45270 
45271 %feature("docstring")  casadi::FunctionInternal::get_function() const  "
45272 
45273 [INTERNAL] ";
45274 
45275 %feature("docstring")  casadi::FunctionInternal::get_function(const
45276 std::string &name) const  "
45277 
45278 [INTERNAL] ";
45279 
45280 %feature("docstring")  casadi::FunctionInternal::setup(void *mem, const
45281 double **arg, double **res, casadi_int *iw, double *w) const  "
45282 
45283 [INTERNAL]  Set the (persistent and temporary) work vectors.
45284 
45285 ";
45286 
45287 %feature("docstring")  casadi::FunctionInternal::eval_gen(const double
45288 **arg, double **res, casadi_int *iw, double *w, void *mem) const  "
45289 
45290 [INTERNAL]  Evaluate numerically.
45291 
45292 ";
45293 
45294 %feature("docstring")  casadi::FunctionInternal::eval_gen(const SXElem
45295 **arg, SXElem **res, casadi_int *iw, SXElem *w, void *mem) const  "
45296 
45297 [INTERNAL]  Evaluate a function, overloaded.
45298 
45299 ";
45300 
45301 %feature("docstring")  casadi::FunctionInternal::eval_gen(const bvec_t
45302 **arg, bvec_t **res, casadi_int *iw, bvec_t *w, void *mem) const  "
45303 
45304 [INTERNAL]  Evaluate a function, overloaded.
45305 
45306 ";
45307 
45308 %feature("docstring")  casadi::FunctionInternal::disp_more(std::ostream
45309 &stream) const  "
45310 
45311 [INTERNAL]  Print more.
45312 
45313 ";
45314 
45315 %feature("docstring")  casadi::FunctionInternal::tocache(const Function &f,
45316 const std::string &suffix="") const  "
45317 
45318 [INTERNAL]  Save function to cache.
45319 
45320 ";
45321 
45322 %feature("docstring")  casadi::ProtoFunction::construct(const Dict &opts) "
45323 
45324 [INTERNAL]  Construct Prepares the function for evaluation.
45325 
45326 ";
45327 
45328 %feature("docstring")  casadi::FunctionInternal::sz_iw() const  "
45329 
45330 [INTERNAL]  Get required length of iw field.
45331 
45332 ";
45333 
45334 %feature("docstring")  casadi::FunctionInternal::sz_arg() const  "
45335 
45336 [INTERNAL]  Get required length of arg field.
45337 
45338 ";
45339 
45340 %feature("docstring")  casadi::Interpolant::is_diff_in(casadi_int i)  "
45341 
45342 [INTERNAL] ";
45343 
45344 %feature("docstring")  casadi::FunctionInternal::free_sx() const  "
45345 
45346 [INTERNAL]  Get free variables (SX)
45347 
45348 ";
45349 
45350 %feature("docstring")  casadi::FunctionInternal::disp(std::ostream &stream,
45351 bool more) const  "
45352 
45353 [INTERNAL]  Display object.
45354 
45355 ";
45356 
45357 %feature("docstring")  casadi::FunctionInternal::generate_options(bool
45358 is_temp=false) const  "
45359 
45360 [INTERNAL]  Reconstruct options dict.
45361 
45362 ";
45363 
45364 %feature("docstring")  casadi::FunctionInternal::matching_arg(const
45365 std::vector< M > &arg, casadi_int &npar) const  "
45366 
45367 [INTERNAL]  Check if input arguments that needs to be replaced.
45368 
45369 Raises errors
45370 
45371 Parameters:
45372 -----------
45373 
45374 npar[in]:  normal usage: 1, disallow pararallel calls: -1
45375 
45376 npar:  max number of horizontal repetitions across all arguments (or -1)
45377 
45378 ";
45379 
45380 %feature("docstring")  casadi::FunctionInternal::alloc_res(size_t sz_res,
45381 bool persistent=false) "
45382 
45383 [INTERNAL]  Ensure required length of res field.
45384 
45385 ";
45386 
45387 %feature("docstring")  casadi::FunctionInternal::has_spfwd() const  "
45388 
45389 [INTERNAL]  Is the class able to propagate seeds through the algorithm?
45390 
45391 ";
45392 
45393 %feature("docstring")  casadi::LinearInterpolant::init(const Dict &opts)  "
45394 
45395 [INTERNAL]  Initialize.
45396 
45397 ";
45398 
45399 %feature("docstring")  casadi::FunctionInternal::jacobian_sparsity() const
45400 "
45401 
45402 [INTERNAL]  Get Jacobian sparsity.
45403 
45404 ";
45405 
45406 %feature("docstring")  casadi::FunctionInternal::map(casadi_int n, const
45407 std::string &parallelization) const  "
45408 
45409 [INTERNAL]  Generate/retrieve cached serial map.
45410 
45411 ";
45412 
45413 %feature("docstring")  casadi::FunctionInternal::is_diff_out(casadi_int i) "
45414 
45415 [INTERNAL] ";
45416 
45417 %feature("docstring")
45418 casadi::FunctionInternal::codegen_incref(CodeGenerator &g) const  "
45419 
45420 [INTERNAL]  Codegen incref for dependencies.
45421 
45422 ";
45423 
45424 %feature("docstring")  casadi::FunctionInternal::has_sprev() const  "
45425 
45426 [INTERNAL]  Is the class able to propagate seeds through the algorithm?
45427 
45428 ";
45429 
45430 %feature("docstring")  casadi::FunctionInternal::all_scalar() const  "
45431 
45432 [INTERNAL]  Are all inputs and outputs scalar.
45433 
45434 ";
45435 
45436 %feature("docstring")  casadi::FunctionInternal::n_nodes() const  "
45437 
45438 [INTERNAL]  Number of nodes in the algorithm.
45439 
45440 ";
45441 
45442 %feature("docstring")  casadi::FunctionInternal::jit_dependencies(const
45443 std::string &fname) "
45444 
45445 [INTERNAL]  Jit dependencies.
45446 
45447 ";
45448 
45449 %feature("docstring")  casadi::Interpolant::get_name_out(casadi_int i)  "
45450 
45451 [INTERNAL]  Names of function input and outputs.
45452 
45453 ";
45454 
45455 %feature("docstring")  casadi::FunctionInternal::eval_sx(const SXElem **arg,
45456 SXElem **res, casadi_int *iw, SXElem *w, void *mem) const  "
45457 
45458 [INTERNAL]  Evaluate with symbolic scalars.
45459 
45460 ";
45461 
45462 %feature("docstring")  casadi::FunctionInternal::project_res(const
45463 std::vector< M > &arg, casadi_int npar) const  "
45464 
45465 [INTERNAL]   Project sparsities.
45466 
45467 ";
45468 
45469 %feature("docstring")  casadi::FunctionInternal::signature(const std::string
45470 &fname) const  "
45471 
45472 [INTERNAL]  Code generate the function.
45473 
45474 ";
45475 
45476 %feature("docstring") casadi::LinearInterpolant::LinearInterpolant(const
45477 std::string &name, const std::vector< double > &grid, const std::vector<
45478 casadi_int > &offset, const std::vector< double > &values, casadi_int m) "
45479 
45480 [INTERNAL] ";
45481 
45482 %feature("docstring")  casadi::FunctionInternal::sz_res() const  "
45483 
45484 [INTERNAL]  Get required length of res field.
45485 
45486 ";
45487 
45488 %feature("docstring")  casadi::FunctionInternal::definition() const  "
45489 
45490 [INTERNAL]  Get function signature: name:(inputs)->(outputs)
45491 
45492 ";
45493 
45494 %feature("docstring")  casadi::FunctionInternal::instruction_MX(casadi_int
45495 k) const  "
45496 
45497 [INTERNAL]  get MX expression associated with instruction
45498 
45499 ";
45500 
45501 %feature("docstring")
45502 casadi::FunctionInternal::getJacSparsityGen(casadi_int iind, casadi_int
45503 oind, bool symmetric, casadi_int gr_i=1, casadi_int gr_o=1) const  "
45504 
45505 [INTERNAL]  Get the sparsity pattern, forward mode.
45506 
45507 ";
45508 
45509 %feature("docstring")
45510 casadi::FunctionInternal::instruction_constant(casadi_int k) const  "
45511 
45512 [INTERNAL]  Get the floating point output argument of an atomic operation.
45513 
45514 ";
45515 
45516 %feature("docstring")  casadi::FunctionInternal::replace_arg(const
45517 std::vector< M > &arg, casadi_int npar) const  "
45518 
45519 [INTERNAL]  Replace 0-by-0 inputs.
45520 
45521 ";
45522 
45523 %feature("docstring")  casadi::FunctionInternal::ad_weight() const  "
45524 
45525 [INTERNAL]  Weighting factor for chosing forward/reverse mode.
45526 
45527 ";
45528 
45529 %feature("docstring")  casadi::FunctionInternal::sz_work(size_t &sz_arg,
45530 size_t &sz_res, size_t &sz_iw, size_t &sz_w) const  "
45531 
45532 [INTERNAL]  Get number of temporary variables needed.
45533 
45534 ";
45535 
45536 %feature("docstring")  casadi::ProtoFunction::format_time(char *buffer,
45537 double time) const  "
45538 
45539 [INTERNAL]  Format time in a fixed width 8 format.
45540 
45541 ";
45542 
45543 %feature("docstring")  casadi::LinearInterpolant::has_codegen() const  "
45544 
45545 [INTERNAL]  Is codegen supported?
45546 
45547 ";
45548 
45549 %feature("docstring")  casadi::ProtoFunction::release(int mem) const  "
45550 
45551 [INTERNAL]  Release a memory object.
45552 
45553 ";
45554 
45555 %feature("docstring")
45556 casadi::FunctionInternal::codegen_declarations(CodeGenerator &g) const  "
45557 
45558 [INTERNAL]  Generate code for the declarations of the C function.
45559 
45560 ";
45561 
45562 %feature("docstring")  casadi::FunctionInternal::nz_out(const std::vector<
45563 DM > &res) const  "
45564 
45565 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
45566 
45567 ";
45568 
45569 %feature("docstring")  casadi::FunctionInternal::nz_out(const std::vector<
45570 double > &res) const  "
45571 
45572 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
45573 
45574 ";
45575 
45576 %feature("docstring")  casadi::FunctionInternal::get_free() const  "
45577 
45578 [INTERNAL]  Print free variables.
45579 
45580 ";
45581 
45582 %feature("docstring")  casadi::FunctionInternal::reverse(casadi_int nadj)
45583 const  "
45584 
45585 [INTERNAL]  Return function that calculates adjoint derivatives
45586 reverse(nadj) returns a cached instance if available, and calls  Function
45587 get_reverse(casadi_int nadj) if no cached version is available.
45588 
45589 ";
45590 
45591 %feature("docstring")  casadi::ProtoFunction::memory(int ind) const  "
45592 
45593 [INTERNAL]  Memory objects.
45594 
45595 ";
45596 
45597 %feature("docstring")  casadi::Interpolant::get_name_in(casadi_int i)  "
45598 
45599 [INTERNAL]  Names of function input and outputs.
45600 
45601 ";
45602 
45603 %feature("docstring")  casadi::FunctionInternal::wrap() const  "
45604 
45605 [INTERNAL]  Wrap in an Function instance consisting of only one MX call.
45606 
45607 ";
45608 
45609 %feature("docstring")  casadi::ProtoFunction::serialize(SerializingStream
45610 &s) const  "
45611 
45612 [INTERNAL]  Serialize an object.
45613 
45614 ";
45615 
45616 %feature("docstring")  casadi::FunctionInternal::sparsity_out(casadi_int
45617 ind) const  "
45618 
45619 [INTERNAL]  Input/output sparsity.
45620 
45621 ";
45622 
45623 %feature("docstring")  casadi::FunctionInternal::export_code(const
45624 std::string &lang, std::ostream &stream, const Dict &options) const  "
45625 
45626 [INTERNAL]  Export function in a specific language.
45627 
45628 ";
45629 
45630 %feature("docstring")  casadi::FunctionInternal::sp_forward(const bvec_t
45631 **arg, bvec_t **res, casadi_int *iw, bvec_t *w, void *mem) const  "
45632 
45633 [INTERNAL]  Propagate sparsity forward.
45634 
45635 ";
45636 
45637 %feature("docstring")  casadi::FunctionInternal::alloc_arg(size_t sz_arg,
45638 bool persistent=false) "
45639 
45640 [INTERNAL]  Ensure required length of arg field.
45641 
45642 ";
45643 
45644 %feature("docstring")  casadi::FunctionInternal::mx_out(casadi_int ind)
45645 const  "
45646 
45647 [INTERNAL]  Get function input(s) and output(s)
45648 
45649 ";
45650 
45651 %feature("docstring")  casadi::FunctionInternal::mx_out() const  "
45652 
45653 [INTERNAL]  Get function input(s) and output(s)
45654 
45655 ";
45656 
45657 %feature("docstring")  casadi::FunctionInternal::has_reverse(casadi_int
45658 nadj) const  "
45659 
45660 [INTERNAL]  Return function that calculates adjoint derivatives
45661 reverse(nadj) returns a cached instance if available, and calls  Function
45662 get_reverse(casadi_int nadj) if no cached version is available.
45663 
45664 ";
45665 
45666 %feature("docstring")  casadi::ProtoFunction::clear_mem() "
45667 
45668 [INTERNAL]  Clear all memory (called from destructor)
45669 
45670 ";
45671 
45672 %feature("docstring")  casadi::FunctionInternal::dm_out(casadi_int ind)
45673 const  "
45674 
45675 [INTERNAL]  Get function input(s) and output(s)
45676 
45677 ";
45678 
45679 %feature("docstring")  casadi::FunctionInternal::dm_out() const  "
45680 
45681 [INTERNAL]  Get function input(s) and output(s)
45682 
45683 ";
45684 
45685 %feature("docstring")  casadi::ProtoFunction::print_time(const std::map<
45686 std::string, FStats > &fstats) const  "
45687 
45688 [INTERNAL]  Print timing statistics.
45689 
45690 ";
45691 
45692 %feature("docstring")  casadi::FunctionInternal::generate_dependencies(const
45693 std::string &fname, const Dict &opts) const  "
45694 
45695 [INTERNAL]  Export / Generate C code for the dependency function.
45696 
45697 ";
45698 
45699 %feature("docstring")  casadi::FunctionInternal::uses_output() const  "
45700 
45701 [INTERNAL]  Do the derivative functions need nondifferentiated outputs?
45702 
45703 ";
45704 
45705 %feature("docstring")  casadi::LinearInterpolant::plugin_name() const  "
45706 
45707 [INTERNAL] ";
45708 
45709 %feature("docstring")  casadi::FunctionInternal::get_default_in(casadi_int
45710 ind) const  "
45711 
45712 [INTERNAL]  Get default input value.
45713 
45714 ";
45715 
45716 %feature("docstring")  casadi::FunctionInternal::factory(const std::string
45717 &name, const std::vector< std::string > &s_in, const std::vector<
45718 std::string > &s_out, const Function::AuxOut &aux, const Dict &opts) const
45719 "
45720 
45721 [INTERNAL] ";
45722 
45723 %feature("docstring")  casadi::FunctionInternal::info() const  "
45724 
45725 [INTERNAL]  Obtain information about function
45726 
45727 ";
45728 
45729 %feature("docstring")  casadi::FunctionInternal::get_min_in(casadi_int ind)
45730 const  "
45731 
45732 [INTERNAL]  Get smallest input value.
45733 
45734 ";
45735 
45736 %feature("docstring")  casadi::FunctionInternal::index_in(const std::string
45737 &name) const  "
45738 
45739 [INTERNAL]  Get input scheme index by name.
45740 
45741 ";
45742 
45743 %feature("docstring")  casadi::FunctionInternal::instructions_sx() const  "
45744 
45745 [INTERNAL]  get SX expression associated with instructions
45746 
45747 ";
45748 
45749 %feature("docstring")  casadi::Interpolant::get_n_out()  "
45750 
45751 [INTERNAL]  Number of function inputs and outputs.
45752 
45753 ";
45754 
45755 %feature("docstring")  casadi::FunctionInternal::has_jacobian_sparsity()
45756 const  "
45757 
45758 [INTERNAL]  Get Jacobian sparsity.
45759 
45760 ";
45761 
45762 %feature("docstring")
45763 casadi::FunctionInternal::getJacSparsityHierarchicalSymm(casadi_int iind,
45764 casadi_int oind) const  "
45765 
45766 [INTERNAL]  A flavor of getJacSparsity that does hierarchical block
45767 structure recognition for symmetric Jacobians
45768 
45769 ";
45770 
45771 %feature("docstring")  casadi::FunctionInternal::call_forward(const
45772 std::vector< MX > &arg, const std::vector< MX > &res, const std::vector<
45773 std::vector< MX > > &fseed, std::vector< std::vector< MX > > &fsens, bool
45774 always_inline, bool never_inline) const  "
45775 
45776 [INTERNAL]  Forward mode AD, virtual functions overloaded in derived
45777 classes.
45778 
45779 ";
45780 
45781 %feature("docstring")  casadi::FunctionInternal::call_forward(const
45782 std::vector< SX > &arg, const std::vector< SX > &res, const std::vector<
45783 std::vector< SX > > &fseed, std::vector< std::vector< SX > > &fsens, bool
45784 always_inline, bool never_inline) const  "
45785 
45786 [INTERNAL]  Forward mode AD, virtual functions overloaded in derived
45787 classes.
45788 
45789 ";
45790 
45791 %feature("docstring")  casadi::FunctionInternal::is_a(const std::string
45792 &type, bool recursive) const  "
45793 
45794 [INTERNAL]  Check if the function is of a particular type.
45795 
45796 ";
45797 
45798 %feature("docstring")  casadi::FunctionInternal::get_reverse(casadi_int
45799 nadj, const std::string &name, const std::vector< std::string > &inames,
45800 const std::vector< std::string > &onames, const Dict &opts) const  "
45801 
45802 [INTERNAL]  Return function that calculates adjoint derivatives
45803 reverse(nadj) returns a cached instance if available, and calls  Function
45804 get_reverse(casadi_int nadj) if no cached version is available.
45805 
45806 ";
45807 
45808 %feature("docstring")  casadi::FunctionInternal::mapsum_mx(const
45809 std::vector< MX > &arg, const std::string &parallelization) "
45810 
45811 [INTERNAL]  Parallel evaluation.
45812 
45813 ";
45814 
45815 %feature("docstring")  casadi::FunctionInternal::nnz_out() const  "
45816 
45817 [INTERNAL]  Number of input/output nonzeros.
45818 
45819 ";
45820 
45821 %feature("docstring")  casadi::FunctionInternal::nnz_out(casadi_int ind)
45822 const  "
45823 
45824 [INTERNAL]  Number of input/output nonzeros.
45825 
45826 ";
45827 
45828 %feature("docstring") casadi::LinearInterpolant "
45829 
45830 'linear' plugin for Interpolant Implements a multilinear interpolant: For
45831 1D, the interpolating polynomial will be linear. For 2D, the interpolating
45832 polynomial will be bilinear, etc.
45833 
45834 >List of available options
45835 
45836 +-------------+-----------------+------------------------------------------+
45837 |     Id      |      Type       |               Description                |
45838 +=============+=================+==========================================+
45839 | lookup_mode | OT_STRINGVECTOR | Sets, for each grid dimenion, the lookup |
45840 |             |                 | algorithm used to find the correct       |
45841 |             |                 | index. 'linear' uses a for-loop + break; |
45842 |             |                 | 'exact' uses floored division (only for  |
45843 |             |                 | uniform grids).                          |
45844 +-------------+-----------------+------------------------------------------+
45845 
45846 Joel Andersson
45847 
45848 >List of available options
45849 
45850 +-------------+-----------------+---------------------+--------------------+
45851 |     Id      |      Type       |     Description     |      Used in       |
45852 +=============+=================+=====================+====================+
45853 | batch_x     | OT_INT          | Evaluate a batch of | casadi::Interpolan |
45854 |             |                 | different inputs at | t                  |
45855 |             |                 | once (default 1).   |                    |
45856 +-------------+-----------------+---------------------+--------------------+
45857 | inline      | OT_BOOL         | Implement the       | casadi::Interpolan |
45858 |             |                 | lookup table in MX  | t                  |
45859 |             |                 | primitives. Useful  |                    |
45860 |             |                 | when you need       |                    |
45861 |             |                 | derivatives with    |                    |
45862 |             |                 | respect to grid     |                    |
45863 |             |                 | and/or              |                    |
45864 |             |                 | coefficients. Such  |                    |
45865 |             |                 | derivatives are     |                    |
45866 |             |                 | fundamentally       |                    |
45867 |             |                 | dense, so use with  |                    |
45868 |             |                 | caution.            |                    |
45869 +-------------+-----------------+---------------------+--------------------+
45870 | lookup_mode | OT_STRINGVECTOR | Sets, for each grid | casadi::LinearInte |
45871 |             |                 | dimenion, the       | rpolant            |
45872 |             |                 | lookup algorithm    |                    |
45873 |             |                 | used to find the    |                    |
45874 |             |                 | correct index.      |                    |
45875 |             |                 | 'linear' uses a     |                    |
45876 |             |                 | for-loop + break;   |                    |
45877 |             |                 | 'exact' uses        |                    |
45878 |             |                 | floored division    |                    |
45879 |             |                 | (only for uniform   |                    |
45880 |             |                 | grids).             |                    |
45881 +-------------+-----------------+---------------------+--------------------+
45882 
45883 Diagrams
45884 --------
45885 
45886 
45887 
45888 C++ includes: linear_interpolant.hpp ";
45889 
45890 %feature("docstring")  casadi::FunctionInternal::codegen_mem_type() const  "
45891 
45892 [INTERNAL]  Thread-local memory object type.
45893 
45894 ";
45895 
45896 %feature("docstring")  casadi::Interpolant::has_parametric_values() const  "
45897 
45898 [INTERNAL]  Is parametric?
45899 
45900 ";
45901 
45902 %feature("docstring")  casadi::FunctionInternal::sp_reverse(bvec_t **arg,
45903 bvec_t **res, casadi_int *iw, bvec_t *w, void *mem) const  "
45904 
45905 [INTERNAL]  Propagate sparsity backwards.
45906 
45907 ";
45908 
45909 %feature("docstring")  casadi::FunctionInternal::get_jac(const std::string
45910 &name, const std::vector< std::string > &inames, const std::vector<
45911 std::string > &onames, const Dict &opts) const  "
45912 
45913 [INTERNAL]  Return Jacobian of all input elements with respect to all output
45914 elements.
45915 
45916 ";
45917 
45918 %feature("docstring")  casadi::FunctionInternal::eval_dm(const std::vector<
45919 DM > &arg) const  "
45920 
45921 [INTERNAL]  Evaluate with DM matrices.
45922 
45923 ";
45924 
45925 %feature("docstring")
45926 casadi::FunctionInternal::codegen_decref(CodeGenerator &g) const  "
45927 
45928 [INTERNAL]  Codegen decref for dependencies.
45929 
45930 ";
45931 
45932 %feature("docstring")  casadi::FunctionInternal::size2_out(casadi_int ind)
45933 const  "
45934 
45935 [INTERNAL]  Input/output dimensions.
45936 
45937 ";
45938 
45939 %feature("docstring")  casadi::FunctionInternal::has_forward(casadi_int
45940 nfwd) const  "
45941 
45942 [INTERNAL]  Return function that calculates forward derivatives
45943 forward(nfwd) returns a cached instance if available, and calls  Function
45944 get_forward(casadi_int nfwd) if no cached version is available.
45945 
45946 ";
45947 
45948 %feature("docstring")  casadi::Interpolant::serialize_base_function() const
45949 "
45950 
45951 [INTERNAL]  String used to identify the immediate FunctionInternal subclass.
45952 
45953 ";
45954 
45955 %feature("docstring")  casadi::FunctionInternal::numel_in() const  "
45956 
45957 [INTERNAL]  Number of input/output elements.
45958 
45959 ";
45960 
45961 %feature("docstring")  casadi::FunctionInternal::numel_in(casadi_int ind)
45962 const  "
45963 
45964 [INTERNAL]  Number of input/output elements.
45965 
45966 ";
45967 
45968 %feature("docstring")  casadi::FunctionInternal::finalize()  "
45969 
45970 [INTERNAL]  Finalize the object creation.
45971 
45972 ";
45973 
45974 %feature("docstring")
45975 casadi::FunctionInternal::getJacSparsityHierarchical(casadi_int iind,
45976 casadi_int oind) const  "
45977 
45978 [INTERNAL]  A flavor of getJacSparsity that does hierarchical block
45979 structure recognition.
45980 
45981 ";
45982 
45983 %feature("docstring")  casadi::FunctionInternal::nz_in(const std::vector< DM
45984 > &arg) const  "
45985 
45986 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
45987 
45988 ";
45989 
45990 %feature("docstring")  casadi::FunctionInternal::nz_in(const std::vector<
45991 double > &arg) const  "
45992 
45993 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
45994 
45995 ";
45996 
45997 %feature("docstring")  casadi::LinearInterpolant::class_name() const  "
45998 
45999 [INTERNAL]  Get type name.
46000 
46001 ";
46002 
46003 %feature("docstring")  casadi::FunctionInternal::getAdaptorSolverName()
46004 const  "
46005 
46006 [INTERNAL]  Obtain solver name from Adaptor.
46007 
46008 ";
46009 
46010 %feature("docstring")
46011 casadi::LinearInterpolant::serialize_type(SerializingStream &s) const  "
46012 
46013 [INTERNAL]  Serialize type information.
46014 
46015 ";
46016 
46017 %feature("docstring")  casadi::FunctionInternal::sparsity_jac(casadi_int
46018 iind, casadi_int oind, bool compact, bool symmetric) const  "
46019 
46020 [INTERNAL]  Get, if necessary generate, the sparsity of a Jacobian block.
46021 
46022 ";
46023 
46024 %feature("docstring")  casadi::FunctionInternal::numel_out(casadi_int ind)
46025 const  "
46026 
46027 [INTERNAL]  Number of input/output elements.
46028 
46029 ";
46030 
46031 %feature("docstring")  casadi::FunctionInternal::numel_out() const  "
46032 
46033 [INTERNAL]  Number of input/output elements.
46034 
46035 ";
46036 
46037 %feature("docstring")  casadi::FunctionInternal::codegen_name(const
46038 CodeGenerator &g, bool ns=true) const  "
46039 
46040 [INTERNAL]  Get name in codegen.
46041 
46042 ";
46043 
46044 %feature("docstring")  casadi::FunctionInternal::has_free() const  "
46045 
46046 [INTERNAL]  Does the function have free variables.
46047 
46048 ";
46049 
46050 %feature("docstring")  casadi::FunctionInternal::call_gen(const MXVector
46051 &arg, MXVector &res, casadi_int npar, bool always_inline, bool never_inline)
46052 const  "
46053 
46054 [INTERNAL]   Call a function, overloaded.
46055 
46056 ";
46057 
46058 %feature("docstring")  casadi::FunctionInternal::call_gen(const std::vector<
46059 MatrixCommon > &arg, std::vector< MatrixCommon > &res, casadi_int npar, bool
46060 always_inline, bool never_inline) const  "
46061 
46062 [INTERNAL]   Call a function, overloaded.
46063 
46064 ";
46065 
46066 %feature("docstring")  casadi::FunctionInternal::call(const std::vector< M >
46067 &arg, std::vector< M > &res, bool always_inline, bool never_inline) const  "
46068 
46069 [INTERNAL]   Call a function, templated.
46070 
46071 ";
46072 
46073 %feature("docstring")  casadi::Interpolant::has_parametric_grid() const  "
46074 
46075 [INTERNAL]  Is parametric?
46076 
46077 ";
46078 
46079 %feature("docstring")  casadi::FunctionInternal::wrap_as_needed(const Dict
46080 &opts) const  "
46081 
46082 [INTERNAL]  Wrap in an Function instance consisting of only one MX call.
46083 
46084 ";
46085 
46086 %feature("docstring")  casadi::FunctionInternal::size1_out(casadi_int ind)
46087 const  "
46088 
46089 [INTERNAL]  Input/output dimensions.
46090 
46091 ";
46092 
46093 %feature("docstring")  casadi::FunctionInternal::generate_out(const
46094 std::string &fname, double **res) const  "
46095 
46096 [INTERNAL] ";
46097 
46098 %feature("docstring")  casadi::ProtoFunction::get_stats(void *mem) const  "
46099 
46100 [INTERNAL]  Get all statistics.
46101 
46102 ";
46103 
46104 %feature("docstring")  casadi::LinearInterpolant::eval(const double **arg,
46105 double **res, casadi_int *iw, double *w, void *mem) const  "
46106 
46107 [INTERNAL]  Evaluate numerically.
46108 
46109 ";
46110 
46111 %feature("docstring")  casadi::ProtoFunction::init_mem(void *mem) const  "
46112 
46113 [INTERNAL]  Initalize memory block.
46114 
46115 ";
46116 
46117 %feature("docstring")  casadi::FunctionInternal::codegen_meta(CodeGenerator
46118 &g) const  "
46119 
46120 [INTERNAL]  Generate meta-information allowing a user to evaluate a
46121 generated function.
46122 
46123 ";
46124 
46125 %feature("docstring")  casadi::FunctionInternal::check_res(const
46126 std::vector< M > &res, casadi_int &npar) const  "
46127 
46128 [INTERNAL]  Check if output arguments have correct length and dimensions.
46129 
46130 Raises errors.
46131 
46132 Parameters:
46133 -----------
46134 
46135 npar[in]:  normal usage: 1, disallow pararallel calls: -1
46136 
46137 npar:  max number of horizontal repetitions across all arguments (or -1)
46138 
46139 ";
46140 
46141 %feature("docstring")  casadi::ProtoFunction::checkout() const  "
46142 
46143 [INTERNAL]  Checkout a memory object.
46144 
46145 ";
46146 
46147 %feature("docstring")  casadi::Interpolant::get_sparsity_in(casadi_int i)  "
46148 
46149 [INTERNAL]  Sparsities of function inputs and outputs.
46150 
46151 ";
46152 
46153 %feature("docstring")  casadi::FunctionInternal::replace_aseed(const
46154 std::vector< std::vector< M >> &aseed, casadi_int npar) const  "
46155 
46156 [INTERNAL]  Replace 0-by-0 reverse seeds.
46157 
46158 ";
46159 
46160 %feature("docstring")  casadi::FunctionInternal::replace_aseed(const
46161 std::vector< std::vector< M > > &aseed, casadi_int npar) const  "
46162 
46163 [INTERNAL] ";
46164 
46165 %feature("docstring")  casadi::FunctionInternal::jacobian() const  "
46166 
46167 [INTERNAL]  Return Jacobian of all input elements with respect to all output
46168 elements.
46169 
46170 ";
46171 
46172 %feature("docstring")  casadi::FunctionInternal::fwdViaJac(casadi_int nfwd)
46173 const  "
46174 
46175 [INTERNAL]  Calculate derivatives by multiplying the full Jacobian and
46176 multiplying.
46177 
46178 ";
46179 
46180 %feature("docstring")  casadi::LinearInterpolant::codegen_body(CodeGenerator
46181 &g) const  "
46182 
46183 [INTERNAL]  Generate code for the body of the C function.
46184 
46185 ";
46186 
46187 %feature("docstring")  casadi::FunctionInternal::getJacSparsity(casadi_int
46188 iind, casadi_int oind, bool symmetric) const  "
46189 
46190 [INTERNAL]  Generate the sparsity of a Jacobian block.
46191 
46192 ";
46193 
46194 %feature("docstring")  casadi::FunctionInternal::dm_in(casadi_int ind) const
46195 "
46196 
46197 [INTERNAL]  Get function input(s) and output(s)
46198 
46199 ";
46200 
46201 %feature("docstring")  casadi::FunctionInternal::dm_in() const  "
46202 
46203 [INTERNAL]  Get function input(s) and output(s)
46204 
46205 ";
46206 
46207 %feature("docstring")  casadi::FunctionInternal::fwd_seed(casadi_int nfwd)
46208 const  "
46209 
46210 [INTERNAL]  Symbolic expressions for the forward seeds.
46211 
46212 ";
46213 
46214 %feature("docstring")  casadi::LinearInterpolant::get_options() const  "
46215 
46216 [INTERNAL]  Options.
46217 
46218 ";
46219 
46220 %feature("docstring")  casadi::FunctionInternal::codegen_mem(CodeGenerator
46221 &g, const std::string &index="mem") const  "
46222 
46223 [INTERNAL]  Get thread-local memory object.
46224 
46225 ";
46226 
46227 %feature("docstring")  casadi::FunctionInternal::self() const  "
46228 
46229 [INTERNAL]  Get a public class instance.
46230 
46231 ";
46232 
46233 %feature("docstring")  casadi::FunctionInternal::sparsity_in(casadi_int ind)
46234 const  "
46235 
46236 [INTERNAL]  Input/output sparsity.
46237 
46238 ";
46239 
46240 %feature("docstring")  casadi::FunctionInternal::generate_in(const
46241 std::string &fname, const double **arg) const  "
46242 
46243 [INTERNAL]  Export an input file that can be passed to generate C code with
46244 a main.
46245 
46246 ";
46247 
46248 %feature("docstring") casadi::LinearInterpolant::~LinearInterpolant "
46249 
46250 [INTERNAL] ";
46251 
46252 %feature("docstring")  casadi::FunctionInternal::has_jac() const  "
46253 
46254 [INTERNAL]  Return Jacobian of all input elements with respect to all output
46255 elements.
46256 
46257 ";
46258 
46259 %feature("docstring")  casadi::ProtoFunction::sprint(char *buf, size_t
46260 buf_sz, const char *fmt,...) const  "
46261 
46262 [INTERNAL]  C-style formatted printing to string.
46263 
46264 ";
46265 
46266 %feature("docstring")
46267 casadi::FunctionInternal::codegen_free_mem(CodeGenerator &g) const  "
46268 
46269 [INTERNAL]  Codegen for free_mem.
46270 
46271 ";
46272 
46273 %feature("docstring")  casadi::FunctionInternal::has_function(const
46274 std::string &fname) const  "
46275 
46276 [INTERNAL] ";
46277 
46278 %feature("docstring")  casadi::FunctionInternal::set_temp(void *mem, const
46279 double **arg, double **res, casadi_int *iw, double *w) const  "
46280 
46281 [INTERNAL]  Set the (temporary) work vectors.
46282 
46283 ";
46284 
46285 %feature("docstring")  casadi::FunctionInternal::get_reltol() const  "
46286 
46287 [INTERNAL]  Get relative tolerance.
46288 
46289 ";
46290 
46291 %feature("docstring")  casadi::FunctionInternal::alloc_w(size_t sz_w, bool
46292 persistent=false) "
46293 
46294 [INTERNAL]  Ensure required length of w field.
46295 
46296 ";
46297 
46298 %feature("docstring")
46299 casadi::FunctionInternal::print_dimensions(std::ostream &stream) const  "
46300 
46301 [INTERNAL]  Print dimensions of inputs and outputs.
46302 
46303 ";
46304 
46305 %feature("docstring")  casadi::FunctionInternal::oracle() const  "
46306 
46307 [INTERNAL]  Get oracle.
46308 
46309 ";
46310 
46311 %feature("docstring")  casadi::FunctionInternal::adjViaJac(casadi_int nadj)
46312 const  "
46313 
46314 [INTERNAL]  Calculate derivatives by multiplying the full Jacobian and
46315 multiplying.
46316 
46317 ";
46318 
46319 %feature("docstring")  casadi::FunctionInternal::matching_res(const
46320 std::vector< M > &arg, casadi_int &npar) const  "
46321 
46322 [INTERNAL]  Check if output arguments that needs to be replaced.
46323 
46324 Raises errors
46325 
46326 Parameters:
46327 -----------
46328 
46329 npar[in]:  normal usage: 1, disallow pararallel calls: -1
46330 
46331 npar:  max number of horizontal repetitions across all arguments (or -1)
46332 
46333 ";
46334 
46335 
46336 // File: classcasadi_1_1LinearInterpolantJac.xml
46337 %feature("docstring")  casadi::FunctionInternal::get_options() const  "
46338 
46339 [INTERNAL]  Options.
46340 
46341 ";
46342 
46343 %feature("docstring")  casadi::FunctionInternal::map(casadi_int n, const
46344 std::string &parallelization) const  "
46345 
46346 [INTERNAL]  Generate/retrieve cached serial map.
46347 
46348 ";
46349 
46350 %feature("docstring")  casadi::FunctionInternal::size_out(casadi_int ind)
46351 const  "
46352 
46353 [INTERNAL]  Input/output dimensions.
46354 
46355 ";
46356 
46357 %feature("docstring")  casadi::LinearInterpolantJac::get_jacobian(const
46358 std::string &name, const std::vector< std::string > &inames, const
46359 std::vector< std::string > &onames, const Dict &opts) const  "
46360 
46361 [INTERNAL]  Full Jacobian.
46362 
46363 ";
46364 
46365 %feature("docstring")  casadi::LinearInterpolantJac::init(const Dict &opts)
46366 "
46367 
46368 [INTERNAL]  Initialize.
46369 
46370 ";
46371 
46372 %feature("docstring")  casadi::ProtoFunction::free_mem(void *mem) const  "
46373 
46374 [INTERNAL]  Free memory block.
46375 
46376 ";
46377 
46378 %feature("docstring")  casadi::FunctionInternal::codegen(CodeGenerator &g,
46379 const std::string &fname) const  "
46380 
46381 [INTERNAL]  Generate code the function.
46382 
46383 ";
46384 
46385 %feature("docstring")  casadi::FunctionInternal::get_name_out(casadi_int i)
46386 "
46387 
46388 [INTERNAL]  Names of function input and outputs.
46389 
46390 ";
46391 
46392 %feature("docstring")  casadi::FunctionInternal::check_arg(const
46393 std::vector< M > &arg, casadi_int &npar) const  "
46394 
46395 [INTERNAL]  Check if input arguments have correct length and dimensions.
46396 
46397 Raises errors.
46398 
46399 Parameters:
46400 -----------
46401 
46402 npar[in]:  normal usage: 1, disallow pararallel calls: -1
46403 
46404 npar:  max number of horizontal repetitions across all arguments (or -1)
46405 
46406 ";
46407 
46408 %feature("docstring") casadi::LinearInterpolantJac::~LinearInterpolantJac "
46409 
46410 [INTERNAL]  Destructor.
46411 
46412 ";
46413 
46414 %feature("docstring")  casadi::FunctionInternal::factory(const std::string
46415 &name, const std::vector< std::string > &s_in, const std::vector<
46416 std::string > &s_out, const Function::AuxOut &aux, const Dict &opts) const
46417 "
46418 
46419 [INTERNAL] ";
46420 
46421 %feature("docstring")  casadi::FunctionInternal::set_temp(void *mem, const
46422 double **arg, double **res, casadi_int *iw, double *w) const  "
46423 
46424 [INTERNAL]  Set the (temporary) work vectors.
46425 
46426 ";
46427 
46428 %feature("docstring")  casadi::ProtoFunction::construct(const Dict &opts) "
46429 
46430 [INTERNAL]  Construct Prepares the function for evaluation.
46431 
46432 ";
46433 
46434 %feature("docstring")  casadi::FunctionInternal::symbolicAdjSeed(casadi_int
46435 nadj, const std::vector< MatType > &v) const  "
46436 
46437 [INTERNAL]  Symbolic expressions for the adjoint seeds.
46438 
46439 ";
46440 
46441 %feature("docstring")  casadi::FunctionInternal::call(const std::vector< M >
46442 &arg, std::vector< M > &res, bool always_inline, bool never_inline) const  "
46443 
46444 [INTERNAL]   Call a function, templated.
46445 
46446 ";
46447 
46448 %feature("docstring")  casadi::FunctionInternal::eval_sx(const SXElem **arg,
46449 SXElem **res, casadi_int *iw, SXElem *w, void *mem) const  "
46450 
46451 [INTERNAL]  Evaluate with symbolic scalars.
46452 
46453 ";
46454 
46455 %feature("docstring")  casadi::ProtoFunction::checkout() const  "
46456 
46457 [INTERNAL]  Checkout a memory object.
46458 
46459 ";
46460 
46461 %feature("docstring")  casadi::FunctionInternal::get_partition(casadi_int
46462 iind, casadi_int oind, Sparsity &D1, Sparsity &D2, bool compact, bool
46463 symmetric, bool allow_forward, bool allow_reverse) const  "
46464 
46465 [INTERNAL]  Get the unidirectional or bidirectional partition.
46466 
46467 ";
46468 
46469 %feature("docstring")  casadi::FunctionInternal::uses_output() const  "
46470 
46471 [INTERNAL]  Do the derivative functions need nondifferentiated outputs?
46472 
46473 ";
46474 
46475 %feature("docstring")
46476 casadi::FunctionInternal::instruction_output(casadi_int k) const  "
46477 
46478 [INTERNAL]  Get the (integer) output argument of an atomic operation.
46479 
46480 ";
46481 
46482 %feature("docstring")  casadi::FunctionInternal::call_gen(const MXVector
46483 &arg, MXVector &res, casadi_int npar, bool always_inline, bool never_inline)
46484 const  "
46485 
46486 [INTERNAL]   Call a function, overloaded.
46487 
46488 ";
46489 
46490 %feature("docstring")  casadi::FunctionInternal::call_gen(const std::vector<
46491 MatrixCommon > &arg, std::vector< MatrixCommon > &res, casadi_int npar, bool
46492 always_inline, bool never_inline) const  "
46493 
46494 [INTERNAL]   Call a function, overloaded.
46495 
46496 ";
46497 
46498 %feature("docstring")  casadi::FunctionInternal::convert_res(const
46499 std::vector< M > &res) const  "
46500 
46501 [INTERNAL]  Convert from/to input/output lists/map.
46502 
46503 ";
46504 
46505 %feature("docstring")  casadi::FunctionInternal::convert_res(const std::map<
46506 std::string, M > &res) const  "
46507 
46508 [INTERNAL]  Convert from/to input/output lists/map.
46509 
46510 ";
46511 
46512 %feature("docstring")  casadi::ProtoFunction::get_stats(void *mem) const  "
46513 
46514 [INTERNAL]  Get all statistics.
46515 
46516 ";
46517 
46518 %feature("docstring")  casadi::LinearInterpolantJac::class_name() const  "
46519 
46520 [INTERNAL]  Get type name.
46521 
46522 ";
46523 
46524 %feature("docstring")  casadi::FunctionInternal::check_mat(const Sparsity
46525 &arg, const Sparsity &inp, casadi_int &npar) "
46526 
46527 [INTERNAL]  Helper function
46528 
46529 Parameters:
46530 -----------
46531 
46532 npar[in]:  normal usage: 1, disallow pararallel calls: -1
46533 
46534 npar[out]:  required number of parallel calls (or -1)
46535 
46536 ";
46537 
46538 %feature("docstring")  casadi::FunctionInternal::jit_dependencies(const
46539 std::string &fname) "
46540 
46541 [INTERNAL]  Jit dependencies.
46542 
46543 ";
46544 
46545 %feature("docstring")  casadi::FunctionInternal::codegen_mem_type() const  "
46546 
46547 [INTERNAL]  Thread-local memory object type.
46548 
46549 ";
46550 
46551 %feature("docstring")  casadi::FunctionInternal::replace_fseed(const
46552 std::vector< std::vector< M >> &fseed, casadi_int npar) const  "
46553 
46554 [INTERNAL]  Replace 0-by-0 forward seeds.
46555 
46556 ";
46557 
46558 %feature("docstring")  casadi::FunctionInternal::replace_fseed(const
46559 std::vector< std::vector< M > > &fseed, casadi_int npar) const  "
46560 
46561 [INTERNAL] ";
46562 
46563 %feature("docstring")  casadi::FunctionInternal::has_function(const
46564 std::string &fname) const  "
46565 
46566 [INTERNAL] ";
46567 
46568 %feature("docstring")  casadi::FunctionInternal::sx_in(casadi_int ind) const
46569 "
46570 
46571 [INTERNAL]  Get function input(s) and output(s)
46572 
46573 ";
46574 
46575 %feature("docstring")  casadi::FunctionInternal::sx_in() const  "
46576 
46577 [INTERNAL]  Get function input(s) and output(s)
46578 
46579 ";
46580 
46581 %feature("docstring")
46582 casadi::FunctionInternal::codegen_decref(CodeGenerator &g) const  "
46583 
46584 [INTERNAL]  Codegen decref for dependencies.
46585 
46586 ";
46587 
46588 %feature("docstring")  casadi::FunctionInternal::get_default_in(casadi_int
46589 ind) const  "
46590 
46591 [INTERNAL]  Get default input value.
46592 
46593 ";
46594 
46595 %feature("docstring")  casadi::FunctionInternal::project_res(const
46596 std::vector< M > &arg, casadi_int npar) const  "
46597 
46598 [INTERNAL]   Project sparsities.
46599 
46600 ";
46601 
46602 %feature("docstring")  casadi::FunctionInternal::sparsity_out(casadi_int
46603 ind) const  "
46604 
46605 [INTERNAL]  Input/output sparsity.
46606 
46607 ";
46608 
46609 %feature("docstring")  casadi::FunctionInternal::free_sx() const  "
46610 
46611 [INTERNAL]  Get free variables (SX)
46612 
46613 ";
46614 
46615 %feature("docstring")  casadi::FunctionInternal::export_code(const
46616 std::string &lang, std::ostream &stream, const Dict &options) const  "
46617 
46618 [INTERNAL]  Export function in a specific language.
46619 
46620 ";
46621 
46622 %feature("docstring")  casadi::FunctionInternal::numel_in() const  "
46623 
46624 [INTERNAL]  Number of input/output elements.
46625 
46626 ";
46627 
46628 %feature("docstring")  casadi::FunctionInternal::numel_in(casadi_int ind)
46629 const  "
46630 
46631 [INTERNAL]  Number of input/output elements.
46632 
46633 ";
46634 
46635 %feature("docstring")  casadi::FunctionInternal::size1_out(casadi_int ind)
46636 const  "
46637 
46638 [INTERNAL]  Input/output dimensions.
46639 
46640 ";
46641 
46642 %feature("docstring")  casadi::FunctionInternal::disp_more(std::ostream
46643 &stream) const  "
46644 
46645 [INTERNAL]  Print more.
46646 
46647 ";
46648 
46649 %feature("docstring")  casadi::FunctionInternal::alloc_iw(size_t sz_iw, bool
46650 persistent=false) "
46651 
46652 [INTERNAL]  Ensure required length of iw field.
46653 
46654 ";
46655 
46656 %feature("docstring")  casadi::FunctionInternal::adjViaJac(casadi_int nadj)
46657 const  "
46658 
46659 [INTERNAL]  Calculate derivatives by multiplying the full Jacobian and
46660 multiplying.
46661 
46662 ";
46663 
46664 %feature("docstring")  casadi::LinearInterpolantJac::has_parametric_grid()
46665 const  "
46666 
46667 [INTERNAL] ";
46668 
46669 %feature("docstring")  casadi::FunctionInternal::nz_in(const std::vector< DM
46670 > &arg) const  "
46671 
46672 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
46673 
46674 ";
46675 
46676 %feature("docstring")  casadi::FunctionInternal::nz_in(const std::vector<
46677 double > &arg) const  "
46678 
46679 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
46680 
46681 ";
46682 
46683 %feature("docstring")  casadi::FunctionInternal::reverse(casadi_int nadj)
46684 const  "
46685 
46686 [INTERNAL]  Return function that calculates adjoint derivatives
46687 reverse(nadj) returns a cached instance if available, and calls  Function
46688 get_reverse(casadi_int nadj) if no cached version is available.
46689 
46690 ";
46691 
46692 %feature("docstring")
46693 casadi::FunctionInternal::codegen_alloc_mem(CodeGenerator &g) const  "
46694 
46695 [INTERNAL]  Codegen decref for alloc_mem.
46696 
46697 ";
46698 
46699 %feature("docstring")  casadi::FunctionInternal::get_name_in(casadi_int i) "
46700 
46701 [INTERNAL]  Names of function input and outputs.
46702 
46703 ";
46704 
46705 %feature("docstring")  casadi::FunctionInternal::has_jacobian_sparsity()
46706 const  "
46707 
46708 [INTERNAL]  Get Jacobian sparsity.
46709 
46710 ";
46711 
46712 %feature("docstring")  casadi::FunctionInternal::info() const  "
46713 
46714 [INTERNAL]  Obtain information about function
46715 
46716 ";
46717 
46718 %feature("docstring")  casadi::FunctionInternal::call_reverse(const
46719 std::vector< MX > &arg, const std::vector< MX > &res, const std::vector<
46720 std::vector< MX > > &aseed, std::vector< std::vector< MX > > &asens, bool
46721 always_inline, bool never_inline) const  "
46722 
46723 [INTERNAL]  Reverse mode, virtual functions overloaded in derived classes.
46724 
46725 ";
46726 
46727 %feature("docstring")  casadi::FunctionInternal::call_reverse(const
46728 std::vector< SX > &arg, const std::vector< SX > &res, const std::vector<
46729 std::vector< SX > > &aseed, std::vector< std::vector< SX > > &asens, bool
46730 always_inline, bool never_inline) const  "
46731 
46732 [INTERNAL]  Reverse mode, virtual functions overloaded in derived classes.
46733 
46734 ";
46735 
46736 %feature("docstring")  casadi::FunctionInternal::get_reltol() const  "
46737 
46738 [INTERNAL]  Get relative tolerance.
46739 
46740 ";
46741 
46742 %feature("docstring")  casadi::LinearInterpolantJac::eval(const double
46743 **arg, double **res, casadi_int *iw, double *w, void *mem) const  "
46744 
46745 [INTERNAL]  Evaluate numerically.
46746 
46747 ";
46748 
46749 %feature("docstring")  casadi::FunctionInternal::size2_in(casadi_int ind)
46750 const  "
46751 
46752 [INTERNAL]  Input/output dimensions.
46753 
46754 ";
46755 
46756 %feature("docstring")  casadi::FunctionInternal::is_a(const std::string
46757 &type, bool recursive) const  "
46758 
46759 [INTERNAL]  Check if the function is of a particular type.
46760 
46761 ";
46762 
46763 %feature("docstring")  casadi::FunctionInternal::getAdaptorSolverName()
46764 const  "
46765 
46766 [INTERNAL]  Obtain solver name from Adaptor.
46767 
46768 ";
46769 
46770 %feature("docstring")  casadi::FunctionInternal::generate_options(bool
46771 is_temp=false) const  "
46772 
46773 [INTERNAL]  Reconstruct options dict.
46774 
46775 ";
46776 
46777 %feature("docstring")  casadi::ProtoFunction::format_time(char *buffer,
46778 double time) const  "
46779 
46780 [INTERNAL]  Format time in a fixed width 8 format.
46781 
46782 ";
46783 
46784 %feature("docstring")
46785 casadi::LinearInterpolantJac::codegen_body(CodeGenerator &g) const  "
46786 
46787 [INTERNAL]  Generate code for the body of the C function.
46788 
46789 ";
46790 
46791 %feature("docstring")  casadi::FunctionInternal::sparsity_in(casadi_int ind)
46792 const  "
46793 
46794 [INTERNAL]  Input/output sparsity.
46795 
46796 ";
46797 
46798 %feature("docstring")  casadi::FunctionInternal::project_arg(const
46799 std::vector< M > &arg, casadi_int npar) const  "
46800 
46801 [INTERNAL]   Project sparsities.
46802 
46803 ";
46804 
46805 %feature("docstring")
46806 casadi::FunctionInternal::instruction_input(casadi_int k) const  "
46807 
46808 [INTERNAL]  Get the (integer) input arguments of an atomic operation.
46809 
46810 ";
46811 
46812 %feature("docstring")  casadi::FunctionInternal::has_derivative() const  "
46813 
46814 [INTERNAL]  Can derivatives be calculated in any way?
46815 
46816 ";
46817 
46818 %feature("docstring")  casadi::FunctionInternal::jacobian_sparsity() const
46819 "
46820 
46821 [INTERNAL]  Get Jacobian sparsity.
46822 
46823 ";
46824 
46825 %feature("docstring")  casadi::FunctionInternal::disp(std::ostream &stream,
46826 bool more) const  "
46827 
46828 [INTERNAL]  Display object.
46829 
46830 ";
46831 
46832 %feature("docstring")
46833 casadi::FunctionInternal::getJacSparsityGen(casadi_int iind, casadi_int
46834 oind, bool symmetric, casadi_int gr_i=1, casadi_int gr_o=1) const  "
46835 
46836 [INTERNAL]  Get the sparsity pattern, forward mode.
46837 
46838 ";
46839 
46840 %feature("docstring")  casadi::ProtoFunction::serialize(SerializingStream
46841 &s) const  "
46842 
46843 [INTERNAL]  Serialize an object.
46844 
46845 ";
46846 
46847 %feature("docstring")  casadi::FunctionInternal::get_abstol() const  "
46848 
46849 [INTERNAL]  Get absolute tolerance.
46850 
46851 ";
46852 
46853 %feature("docstring")
46854 casadi::FunctionInternal::codegen_declarations(CodeGenerator &g) const  "
46855 
46856 [INTERNAL]  Generate code for the declarations of the C function.
46857 
46858 ";
46859 
46860 %feature("docstring")  casadi::FunctionInternal::nnz_in() const  "
46861 
46862 [INTERNAL]  Number of input/output nonzeros.
46863 
46864 ";
46865 
46866 %feature("docstring")  casadi::FunctionInternal::nnz_in(casadi_int ind)
46867 const  "
46868 
46869 [INTERNAL]  Number of input/output nonzeros.
46870 
46871 ";
46872 
46873 %feature("docstring")  casadi::FunctionInternal::codegen_name(const
46874 CodeGenerator &g, bool ns=true) const  "
46875 
46876 [INTERNAL]  Get name in codegen.
46877 
46878 ";
46879 
46880 %feature("docstring")  casadi::FunctionInternal::generate_in(const
46881 std::string &fname, const double **arg) const  "
46882 
46883 [INTERNAL]  Export an input file that can be passed to generate C code with
46884 a main.
46885 
46886 ";
46887 
46888 %feature("docstring")  casadi::FunctionInternal::get_sparsity_out(casadi_int
46889 i) "
46890 
46891 [INTERNAL]  Get sparsity of a given output.
46892 
46893 ";
46894 
46895 %feature("docstring")  casadi::FunctionInternal::forward(casadi_int nfwd)
46896 const  "
46897 
46898 [INTERNAL]  Return function that calculates forward derivatives
46899 forward(nfwd) returns a cached instance if available, and calls  Function
46900 get_forward(casadi_int nfwd) if no cached version is available.
46901 
46902 ";
46903 
46904 %feature("docstring")  casadi::FunctionInternal::get_sparsity_in(casadi_int
46905 i) "
46906 
46907 [INTERNAL]  Get sparsity of a given input.
46908 
46909 ";
46910 
46911 %feature("docstring")
46912 casadi::FunctionInternal::codegen_sparsities(CodeGenerator &g) const  "
46913 
46914 [INTERNAL]  Codegen sparsities.
46915 
46916 ";
46917 
46918 %feature("docstring")  casadi::FunctionInternal::get_jacobian_sparsity()
46919 const  "
46920 
46921 [INTERNAL]  Get Jacobian sparsity.
46922 
46923 ";
46924 
46925 %feature("docstring")  casadi::ProtoFunction::alloc_mem() const  "
46926 
46927 [INTERNAL]  Create memory block.
46928 
46929 ";
46930 
46931 %feature("docstring")  casadi::FunctionInternal::oracle() const  "
46932 
46933 [INTERNAL]  Get oracle.
46934 
46935 ";
46936 
46937 %feature("docstring")  casadi::FunctionInternal::which_depends(const
46938 std::string &s_in, const std::vector< std::string > &s_out, casadi_int
46939 order, bool tr=false) const  "
46940 
46941 [INTERNAL]  Which variables enter with some order.
46942 
46943 Parameters:
46944 -----------
46945 
46946 s_in:   Input name
46947 
46948 s_out:   Output name(s)
46949 
46950 order:  Only 1 (linear) and 2 (nonlinear) allowed
46951 
46952 tr:  Flip the relationship. Return which expressions contain the variables
46953 
46954 ";
46955 
46956 %feature("docstring")  casadi::LinearInterpolantJac::has_parametric_values()
46957 const  "
46958 
46959 [INTERNAL]  Is parametric?
46960 
46961 ";
46962 
46963 %feature("docstring")  casadi::FunctionInternal::generate_out(const
46964 std::string &fname, double **res) const  "
46965 
46966 [INTERNAL] ";
46967 
46968 %feature("docstring")  casadi::FunctionInternal::has_sprev() const  "
46969 
46970 [INTERNAL]  Is the class able to propagate seeds through the algorithm?
46971 
46972 ";
46973 
46974 %feature("docstring")  casadi::FunctionInternal::matching_arg(const
46975 std::vector< M > &arg, casadi_int &npar) const  "
46976 
46977 [INTERNAL]  Check if input arguments that needs to be replaced.
46978 
46979 Raises errors
46980 
46981 Parameters:
46982 -----------
46983 
46984 npar[in]:  normal usage: 1, disallow pararallel calls: -1
46985 
46986 npar:  max number of horizontal repetitions across all arguments (or -1)
46987 
46988 ";
46989 
46990 %feature("docstring")  casadi::FunctionInternal::size1_in(casadi_int ind)
46991 const  "
46992 
46993 [INTERNAL]  Input/output dimensions.
46994 
46995 ";
46996 
46997 %feature("docstring")  casadi::FunctionInternal::has_spfwd() const  "
46998 
46999 [INTERNAL]  Is the class able to propagate seeds through the algorithm?
47000 
47001 ";
47002 
47003 %feature("docstring")  casadi::FunctionInternal::sp_reverse(bvec_t **arg,
47004 bvec_t **res, casadi_int *iw, bvec_t *w, void *mem) const  "
47005 
47006 [INTERNAL]  Propagate sparsity backwards.
47007 
47008 ";
47009 
47010 %feature("docstring")  casadi::FunctionInternal::alloc(const Function &f,
47011 bool persistent=false) "
47012 
47013 [INTERNAL]  Ensure work vectors long enough to evaluate function.
47014 
47015 ";
47016 
47017 %feature("docstring")  casadi::ProtoFunction::print(const char *fmt,...)
47018 const  "
47019 
47020 [INTERNAL]  C-style formatted printing during evaluation.
47021 
47022 ";
47023 
47024 %feature("docstring")  casadi::FunctionInternal::convert_arg(const
47025 std::vector< M > &arg) const  "
47026 
47027 [INTERNAL]  Convert from/to input/output lists/map.
47028 
47029 ";
47030 
47031 %feature("docstring")  casadi::FunctionInternal::convert_arg(const std::map<
47032 std::string, M > &arg) const  "
47033 
47034 [INTERNAL]  Convert from/to input/output lists/map.
47035 
47036 ";
47037 
47038 %feature("docstring")  casadi::FunctionInternal::replace_res(const
47039 std::vector< M > &res, casadi_int npar) const  "
47040 
47041 [INTERNAL]  Replace 0-by-0 outputs.
47042 
47043 ";
47044 
47045 %feature("docstring")  casadi::SharedObjectInternal::getCount() const  "
47046 
47047 [INTERNAL]  Get the reference count.
47048 
47049 ";
47050 
47051 %feature("docstring")
47052 casadi::LinearInterpolantJac::serialize_type(SerializingStream &s) const  "
47053 
47054 [INTERNAL]  Serialize type information.
47055 
47056 ";
47057 
47058 %feature("docstring")
47059 casadi::FunctionInternal::codegen_init_mem(CodeGenerator &g) const  "
47060 
47061 [INTERNAL]  Codegen decref for init_mem.
47062 
47063 ";
47064 
47065 %feature("docstring")  casadi::FunctionInternal::wrap() const  "
47066 
47067 [INTERNAL]  Wrap in an Function instance consisting of only one MX call.
47068 
47069 ";
47070 
47071 %feature("docstring")  casadi::FunctionInternal::get_reverse(casadi_int
47072 nadj, const std::string &name, const std::vector< std::string > &inames,
47073 const std::vector< std::string > &onames, const Dict &opts) const  "
47074 
47075 [INTERNAL]  Return function that calculates adjoint derivatives
47076 reverse(nadj) returns a cached instance if available, and calls  Function
47077 get_reverse(casadi_int nadj) if no cached version is available.
47078 
47079 ";
47080 
47081 %feature("docstring")  casadi::ProtoFunction::print_time(const std::map<
47082 std::string, FStats > &fstats) const  "
47083 
47084 [INTERNAL]  Print timing statistics.
47085 
47086 ";
47087 
47088 %feature("docstring")  casadi::FunctionInternal::instruction_id(casadi_int
47089 k) const  "
47090 
47091 [INTERNAL]  Get an atomic operation operator index.
47092 
47093 ";
47094 
47095 %feature("docstring")  casadi::FunctionInternal::call_forward(const
47096 std::vector< MX > &arg, const std::vector< MX > &res, const std::vector<
47097 std::vector< MX > > &fseed, std::vector< std::vector< MX > > &fsens, bool
47098 always_inline, bool never_inline) const  "
47099 
47100 [INTERNAL]  Forward mode AD, virtual functions overloaded in derived
47101 classes.
47102 
47103 ";
47104 
47105 %feature("docstring")  casadi::FunctionInternal::call_forward(const
47106 std::vector< SX > &arg, const std::vector< SX > &res, const std::vector<
47107 std::vector< SX > > &fseed, std::vector< std::vector< SX > > &fsens, bool
47108 always_inline, bool never_inline) const  "
47109 
47110 [INTERNAL]  Forward mode AD, virtual functions overloaded in derived
47111 classes.
47112 
47113 ";
47114 
47115 %feature("docstring")  casadi::FunctionInternal::n_nodes() const  "
47116 
47117 [INTERNAL]  Number of nodes in the algorithm.
47118 
47119 ";
47120 
47121 %feature("docstring")  casadi::FunctionInternal::numel_out(casadi_int ind)
47122 const  "
47123 
47124 [INTERNAL]  Number of input/output elements.
47125 
47126 ";
47127 
47128 %feature("docstring")  casadi::FunctionInternal::numel_out() const  "
47129 
47130 [INTERNAL]  Number of input/output elements.
47131 
47132 ";
47133 
47134 %feature("docstring")  casadi::FunctionInternal::get_free() const  "
47135 
47136 [INTERNAL]  Print free variables.
47137 
47138 ";
47139 
47140 %feature("docstring")  casadi::FunctionInternal::mx_in(casadi_int ind) const
47141 "
47142 
47143 [INTERNAL]  Get function input(s) and output(s)
47144 
47145 ";
47146 
47147 %feature("docstring")  casadi::FunctionInternal::mx_in() const  "
47148 
47149 [INTERNAL]  Get function input(s) and output(s)
47150 
47151 ";
47152 
47153 %feature("docstring")  casadi::FunctionInternal::definition() const  "
47154 
47155 [INTERNAL]  Get function signature: name:(inputs)->(outputs)
47156 
47157 ";
47158 
47159 %feature("docstring")  casadi::FunctionInternal::dm_out(casadi_int ind)
47160 const  "
47161 
47162 [INTERNAL]  Get function input(s) and output(s)
47163 
47164 ";
47165 
47166 %feature("docstring")  casadi::FunctionInternal::dm_out() const  "
47167 
47168 [INTERNAL]  Get function input(s) and output(s)
47169 
47170 ";
47171 
47172 %feature("docstring")  casadi::FunctionInternal::n_instructions() const  "
47173 
47174 [INTERNAL]  Get the number of atomic operations.
47175 
47176 ";
47177 
47178 %feature("docstring")  casadi::FunctionInternal::fwdViaJac(casadi_int nfwd)
47179 const  "
47180 
47181 [INTERNAL]  Calculate derivatives by multiplying the full Jacobian and
47182 multiplying.
47183 
47184 ";
47185 
47186 %feature("docstring")
47187 casadi::FunctionInternal::codegen_incref(CodeGenerator &g) const  "
47188 
47189 [INTERNAL]  Codegen incref for dependencies.
47190 
47191 ";
47192 
47193 %feature("docstring")  casadi::FunctionInternal::eval_gen(const double
47194 **arg, double **res, casadi_int *iw, double *w, void *mem) const  "
47195 
47196 [INTERNAL]  Evaluate numerically.
47197 
47198 ";
47199 
47200 %feature("docstring")  casadi::FunctionInternal::eval_gen(const SXElem
47201 **arg, SXElem **res, casadi_int *iw, SXElem *w, void *mem) const  "
47202 
47203 [INTERNAL]  Evaluate a function, overloaded.
47204 
47205 ";
47206 
47207 %feature("docstring")  casadi::FunctionInternal::eval_gen(const bvec_t
47208 **arg, bvec_t **res, casadi_int *iw, bvec_t *w, void *mem) const  "
47209 
47210 [INTERNAL]  Evaluate a function, overloaded.
47211 
47212 ";
47213 
47214 %feature("docstring")  casadi::FunctionInternal::getJacSparsity(casadi_int
47215 iind, casadi_int oind, bool symmetric) const  "
47216 
47217 [INTERNAL]  Generate the sparsity of a Jacobian block.
47218 
47219 ";
47220 
47221 %feature("docstring")  casadi::ProtoFunction::clear_mem() "
47222 
47223 [INTERNAL]  Clear all memory (called from destructor)
47224 
47225 ";
47226 
47227 %feature("docstring")  casadi::FunctionInternal::codegen_meta(CodeGenerator
47228 &g) const  "
47229 
47230 [INTERNAL]  Generate meta-information allowing a user to evaluate a
47231 generated function.
47232 
47233 ";
47234 
47235 %feature("docstring")  casadi::FunctionInternal::sp_forward(const bvec_t
47236 **arg, bvec_t **res, casadi_int *iw, bvec_t *w, void *mem) const  "
47237 
47238 [INTERNAL]  Propagate sparsity forward.
47239 
47240 ";
47241 
47242 %feature("docstring")  casadi::FunctionInternal::instruction_MX(casadi_int
47243 k) const  "
47244 
47245 [INTERNAL]  get MX expression associated with instruction
47246 
47247 ";
47248 
47249 %feature("docstring")  casadi::FunctionInternal::get_forward(casadi_int
47250 nfwd, const std::string &name, const std::vector< std::string > &inames,
47251 const std::vector< std::string > &onames, const Dict &opts) const  "
47252 
47253 [INTERNAL]  Return function that calculates forward derivatives
47254 forward(nfwd) returns a cached instance if available, and calls  Function
47255 get_forward(casadi_int nfwd) if no cached version is available.
47256 
47257 ";
47258 
47259 %feature("docstring")  casadi::FunctionInternal::setup(void *mem, const
47260 double **arg, double **res, casadi_int *iw, double *w) const  "
47261 
47262 [INTERNAL]  Set the (persistent and temporary) work vectors.
47263 
47264 ";
47265 
47266 %feature("docstring")  casadi::FunctionInternal::has_eval_dm() const  "
47267 
47268 [INTERNAL]  Evaluate with DM matrices.
47269 
47270 ";
47271 
47272 %feature("docstring")  casadi::FunctionInternal::sparsity_jac(casadi_int
47273 iind, casadi_int oind, bool compact, bool symmetric) const  "
47274 
47275 [INTERNAL]  Get, if necessary generate, the sparsity of a Jacobian block.
47276 
47277 ";
47278 
47279 %feature("docstring")  casadi::FunctionInternal::sz_res() const  "
47280 
47281 [INTERNAL]  Get required length of res field.
47282 
47283 ";
47284 
47285 %feature("docstring")  casadi::FunctionInternal::tocache(const Function &f,
47286 const std::string &suffix="") const  "
47287 
47288 [INTERNAL]  Save function to cache.
47289 
47290 ";
47291 
47292 %feature("docstring")  casadi::FunctionInternal::sx_out(casadi_int ind)
47293 const  "
47294 
47295 [INTERNAL]  Get function input(s) and output(s)
47296 
47297 ";
47298 
47299 %feature("docstring")  casadi::FunctionInternal::sx_out() const  "
47300 
47301 [INTERNAL]  Get function input(s) and output(s)
47302 
47303 ";
47304 
47305 %feature("docstring")  casadi::FunctionInternal::eval_dm(const std::vector<
47306 DM > &arg) const  "
47307 
47308 [INTERNAL]  Evaluate with DM matrices.
47309 
47310 ";
47311 
47312 %feature("docstring")  casadi::FunctionInternal::eval_mx(const MXVector
47313 &arg, MXVector &res, bool always_inline, bool never_inline) const  "
47314 
47315 [INTERNAL]  Evaluate with symbolic matrices.
47316 
47317 ";
47318 
47319 %feature("docstring")
47320 casadi::FunctionInternal::getJacSparsityHierarchical(casadi_int iind,
47321 casadi_int oind) const  "
47322 
47323 [INTERNAL]  A flavor of getJacSparsity that does hierarchical block
47324 structure recognition.
47325 
47326 ";
47327 
47328 %feature("docstring")  casadi::FunctionInternal::wrap_as_needed(const Dict
47329 &opts) const  "
47330 
47331 [INTERNAL]  Wrap in an Function instance consisting of only one MX call.
47332 
47333 ";
47334 
47335 %feature("docstring")  casadi::FunctionInternal::index_in(const std::string
47336 &name) const  "
47337 
47338 [INTERNAL]  Get input scheme index by name.
47339 
47340 ";
47341 
47342 %feature("docstring")  casadi::FunctionInternal::jacobian() const  "
47343 
47344 [INTERNAL]  Return Jacobian of all input elements with respect to all output
47345 elements.
47346 
47347 ";
47348 
47349 %feature("docstring")  casadi::FunctionInternal::index_out(const std::string
47350 &name) const  "
47351 
47352 [INTERNAL]  Get output scheme index by name.
47353 
47354 ";
47355 
47356 %feature("docstring")  casadi::FunctionInternal::sz_work(size_t &sz_arg,
47357 size_t &sz_res, size_t &sz_iw, size_t &sz_w) const  "
47358 
47359 [INTERNAL]  Get number of temporary variables needed.
47360 
47361 ";
47362 
47363 %feature("docstring")  casadi::ProtoFunction::memory(int ind) const  "
47364 
47365 [INTERNAL]  Memory objects.
47366 
47367 ";
47368 
47369 %feature("docstring")  casadi::LinearInterpolantJac::has_jacobian() const  "
47370 
47371 [INTERNAL]  Full Jacobian.
47372 
47373 ";
47374 
47375 %feature("docstring")  casadi::FunctionInternal::free_mx() const  "
47376 
47377 [INTERNAL]  Get free variables ( MX)
47378 
47379 ";
47380 
47381 %feature("docstring")
47382 casadi::FunctionInternal::jacobian_sparsity_filter(const Sparsity &sp) const
47383 "
47384 
47385 [INTERNAL]  Filter out nonzeros in the full sparsity jacobian according to
47386 is_diff_in/out.
47387 
47388 ";
47389 
47390 %feature("docstring")
47391 casadi::LinearInterpolantJac::serialize_base_function() const  "
47392 
47393 [INTERNAL]  String used to identify the immediate FunctionInternal subclass.
47394 
47395 ";
47396 
47397 %feature("docstring")  casadi::FunctionInternal::signature(const std::string
47398 &fname) const  "
47399 
47400 [INTERNAL]  Code generate the function.
47401 
47402 ";
47403 
47404 %feature("docstring")  casadi::FunctionInternal::has_reverse(casadi_int
47405 nadj) const  "
47406 
47407 [INTERNAL]  Return function that calculates adjoint derivatives
47408 reverse(nadj) returns a cached instance if available, and calls  Function
47409 get_reverse(casadi_int nadj) if no cached version is available.
47410 
47411 ";
47412 
47413 %feature("docstring")  casadi::FunctionInternal::is_diff_in(casadi_int i) "
47414 
47415 [INTERNAL] ";
47416 
47417 %feature("docstring") casadi::LinearInterpolantJac "
47418 
47419 [INTERNAL]  First order derivatives
47420 
47421 >List of available options
47422 
47423 +-------------+-----------------+---------------------+--------------------+
47424 |     Id      |      Type       |     Description     |      Used in       |
47425 +=============+=================+=====================+====================+
47426 | batch_x     | OT_INT          | Evaluate a batch of | casadi::Interpolan |
47427 |             |                 | different inputs at | t                  |
47428 |             |                 | once (default 1).   |                    |
47429 +-------------+-----------------+---------------------+--------------------+
47430 | inline      | OT_BOOL         | Implement the       | casadi::Interpolan |
47431 |             |                 | lookup table in MX  | t                  |
47432 |             |                 | primitives. Useful  |                    |
47433 |             |                 | when you need       |                    |
47434 |             |                 | derivatives with    |                    |
47435 |             |                 | respect to grid     |                    |
47436 |             |                 | and/or              |                    |
47437 |             |                 | coefficients. Such  |                    |
47438 |             |                 | derivatives are     |                    |
47439 |             |                 | fundamentally       |                    |
47440 |             |                 | dense, so use with  |                    |
47441 |             |                 | caution.            |                    |
47442 +-------------+-----------------+---------------------+--------------------+
47443 | lookup_mode | OT_STRINGVECTOR | Sets, for each grid | casadi::LinearInte |
47444 |             |                 | dimenion, the       | rpolantJac         |
47445 |             |                 | lookup algorithm    |                    |
47446 |             |                 | used to find the    |                    |
47447 |             |                 | correct index.      |                    |
47448 |             |                 | 'linear' uses a     |                    |
47449 |             |                 | for-loop + break;   |                    |
47450 |             |                 | 'exact' uses        |                    |
47451 |             |                 | floored division    |                    |
47452 |             |                 | (only for uniform   |                    |
47453 |             |                 | grids).             |                    |
47454 +-------------+-----------------+---------------------+--------------------+
47455 
47456 Diagrams
47457 --------
47458 
47459 
47460 
47461 C++ includes: linear_interpolant.hpp ";
47462 
47463 %feature("docstring")  casadi::FunctionInternal::check_res(const
47464 std::vector< M > &res, casadi_int &npar) const  "
47465 
47466 [INTERNAL]  Check if output arguments have correct length and dimensions.
47467 
47468 Raises errors.
47469 
47470 Parameters:
47471 -----------
47472 
47473 npar[in]:  normal usage: 1, disallow pararallel calls: -1
47474 
47475 npar:  max number of horizontal repetitions across all arguments (or -1)
47476 
47477 ";
47478 
47479 %feature("docstring")  casadi::FunctionInternal::get_function() const  "
47480 
47481 [INTERNAL] ";
47482 
47483 %feature("docstring")  casadi::FunctionInternal::get_function(const
47484 std::string &name) const  "
47485 
47486 [INTERNAL] ";
47487 
47488 %feature("docstring")  casadi::FunctionInternal::sz_arg() const  "
47489 
47490 [INTERNAL]  Get required length of arg field.
47491 
47492 ";
47493 
47494 %feature("docstring")
47495 casadi::FunctionInternal::instruction_constant(casadi_int k) const  "
47496 
47497 [INTERNAL]  Get the floating point output argument of an atomic operation.
47498 
47499 ";
47500 
47501 %feature("docstring")  casadi::ProtoFunction::sprint(char *buf, size_t
47502 buf_sz, const char *fmt,...) const  "
47503 
47504 [INTERNAL]  C-style formatted printing to string.
47505 
47506 ";
47507 
47508 %feature("docstring")  casadi::ProtoFunction::release(int mem) const  "
47509 
47510 [INTERNAL]  Release a memory object.
47511 
47512 ";
47513 
47514 %feature("docstring")  casadi::FunctionInternal::codegen_mem(CodeGenerator
47515 &g, const std::string &index="mem") const  "
47516 
47517 [INTERNAL]  Get thread-local memory object.
47518 
47519 ";
47520 
47521 %feature("docstring")  casadi::FunctionInternal::sz_w() const  "
47522 
47523 [INTERNAL]  Get required length of w field.
47524 
47525 ";
47526 
47527 %feature("docstring")  casadi::FunctionInternal::mapsum_mx(const
47528 std::vector< MX > &arg, const std::string &parallelization) "
47529 
47530 [INTERNAL]  Parallel evaluation.
47531 
47532 ";
47533 
47534 %feature("docstring")  casadi::FunctionInternal::has_free() const  "
47535 
47536 [INTERNAL]  Does the function have free variables.
47537 
47538 ";
47539 
47540 %feature("docstring")  casadi::FunctionInternal::incache(const std::string
47541 &fname, Function &f, const std::string &suffix="") const  "
47542 
47543 [INTERNAL]  Get function in cache.
47544 
47545 ";
47546 
47547 %feature("docstring")  casadi::FunctionInternal::has_forward(casadi_int
47548 nfwd) const  "
47549 
47550 [INTERNAL]  Return function that calculates forward derivatives
47551 forward(nfwd) returns a cached instance if available, and calls  Function
47552 get_forward(casadi_int nfwd) if no cached version is available.
47553 
47554 ";
47555 
47556 %feature("docstring")  casadi::FunctionInternal::print_options(std::ostream
47557 &stream) const  "
47558 
47559 [INTERNAL]  Print list of options.
47560 
47561 ";
47562 
47563 %feature("docstring")  casadi::FunctionInternal::nnz_out() const  "
47564 
47565 [INTERNAL]  Number of input/output nonzeros.
47566 
47567 ";
47568 
47569 %feature("docstring")  casadi::FunctionInternal::nnz_out(casadi_int ind)
47570 const  "
47571 
47572 [INTERNAL]  Number of input/output nonzeros.
47573 
47574 ";
47575 
47576 %feature("docstring")  casadi::FunctionInternal::matching_res(const
47577 std::vector< M > &arg, casadi_int &npar) const  "
47578 
47579 [INTERNAL]  Check if output arguments that needs to be replaced.
47580 
47581 Raises errors
47582 
47583 Parameters:
47584 -----------
47585 
47586 npar[in]:  normal usage: 1, disallow pararallel calls: -1
47587 
47588 npar:  max number of horizontal repetitions across all arguments (or -1)
47589 
47590 ";
47591 
47592 %feature("docstring")  casadi::FunctionInternal::slice(const std::string
47593 &name, const std::vector< casadi_int > &order_in, const std::vector<
47594 casadi_int > &order_out, const Dict &opts) const  "
47595 
47596 [INTERNAL]  returns a new function with a selection of inputs/outputs of the
47597 original
47598 
47599 ";
47600 
47601 %feature("docstring")  casadi::FunctionInternal::replace_arg(const
47602 std::vector< M > &arg, casadi_int npar) const  "
47603 
47604 [INTERNAL]  Replace 0-by-0 inputs.
47605 
47606 ";
47607 
47608 %feature("docstring")  casadi::FunctionInternal::alloc_res(size_t sz_res,
47609 bool persistent=false) "
47610 
47611 [INTERNAL]  Ensure required length of res field.
47612 
47613 ";
47614 
47615 %feature("docstring")  casadi::FunctionInternal::get_min_in(casadi_int ind)
47616 const  "
47617 
47618 [INTERNAL]  Get smallest input value.
47619 
47620 ";
47621 
47622 %feature("docstring")
47623 casadi::FunctionInternal::getJacSparsityHierarchicalSymm(casadi_int iind,
47624 casadi_int oind) const  "
47625 
47626 [INTERNAL]  A flavor of getJacSparsity that does hierarchical block
47627 structure recognition for symmetric Jacobians
47628 
47629 ";
47630 
47631 %feature("docstring")  casadi::FunctionInternal::symbolic_output(const
47632 std::vector< MX > &arg) const  "
47633 
47634 [INTERNAL]  Get a vector of symbolic variables corresponding to the outputs.
47635 
47636 ";
47637 
47638 %feature("docstring")  casadi::FunctionInternal::get_n_out() "
47639 
47640 [INTERNAL]  Are all inputs and outputs scalar.
47641 
47642 ";
47643 
47644 %feature("docstring")  casadi::FunctionInternal::size_in(casadi_int ind)
47645 const  "
47646 
47647 [INTERNAL]  Input/output dimensions.
47648 
47649 ";
47650 
47651 %feature("docstring")  casadi::FunctionInternal::sz_iw() const  "
47652 
47653 [INTERNAL]  Get required length of iw field.
47654 
47655 ";
47656 
47657 %feature("docstring")  casadi::FunctionInternal::mx_out(casadi_int ind)
47658 const  "
47659 
47660 [INTERNAL]  Get function input(s) and output(s)
47661 
47662 ";
47663 
47664 %feature("docstring")  casadi::FunctionInternal::mx_out() const  "
47665 
47666 [INTERNAL]  Get function input(s) and output(s)
47667 
47668 ";
47669 
47670 %feature("docstring")
47671 casadi::FunctionInternal::codegen_free_mem(CodeGenerator &g) const  "
47672 
47673 [INTERNAL]  Codegen for free_mem.
47674 
47675 ";
47676 
47677 %feature("docstring")  casadi::SharedObjectInternal::weak() "
47678 
47679 [INTERNAL]  Get a weak reference to the object.
47680 
47681 ";
47682 
47683 %feature("docstring")  casadi::FunctionInternal::generate_lifted(Function
47684 &vdef_fcn, Function &vinit_fcn) const  "
47685 
47686 [INTERNAL]  Extract the functions needed for the Lifted Newton method.
47687 
47688 ";
47689 
47690 %feature("docstring")  casadi::FunctionInternal::get_jac(const std::string
47691 &name, const std::vector< std::string > &inames, const std::vector<
47692 std::string > &onames, const Dict &opts) const  "
47693 
47694 [INTERNAL]  Return Jacobian of all input elements with respect to all output
47695 elements.
47696 
47697 ";
47698 
47699 %feature("docstring")  casadi::FunctionInternal::ad_weight() const  "
47700 
47701 [INTERNAL]  Weighting factor for chosing forward/reverse mode.
47702 
47703 ";
47704 
47705 %feature("docstring")  casadi::FunctionInternal::nz_out(const std::vector<
47706 DM > &res) const  "
47707 
47708 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
47709 
47710 ";
47711 
47712 %feature("docstring")  casadi::FunctionInternal::nz_out(const std::vector<
47713 double > &res) const  "
47714 
47715 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
47716 
47717 ";
47718 
47719 %feature("docstring")  casadi::FunctionInternal::fwd_seed(casadi_int nfwd)
47720 const  "
47721 
47722 [INTERNAL]  Symbolic expressions for the forward seeds.
47723 
47724 ";
47725 
47726 %feature("docstring")  casadi::FunctionInternal::alloc_w(size_t sz_w, bool
47727 persistent=false) "
47728 
47729 [INTERNAL]  Ensure required length of w field.
47730 
47731 ";
47732 
47733 %feature("docstring")  casadi::FunctionInternal::alloc_arg(size_t sz_arg,
47734 bool persistent=false) "
47735 
47736 [INTERNAL]  Ensure required length of arg field.
47737 
47738 ";
47739 
47740 %feature("docstring")  casadi::ProtoFunction::init_mem(void *mem) const  "
47741 
47742 [INTERNAL]  Initalize memory block.
47743 
47744 ";
47745 
47746 %feature("docstring")  casadi::FunctionInternal::finalize()  "
47747 
47748 [INTERNAL]  Finalize the object creation.
47749 
47750 ";
47751 
47752 %feature("docstring")
47753 casadi::FunctionInternal::serialize_body(SerializingStream &s) const  "
47754 
47755 [INTERNAL]  Serialize an object without type information.
47756 
47757 ";
47758 
47759 %feature("docstring")  casadi::FunctionInternal::dm_in(casadi_int ind) const
47760 "
47761 
47762 [INTERNAL]  Get function input(s) and output(s)
47763 
47764 ";
47765 
47766 %feature("docstring")  casadi::FunctionInternal::dm_in() const  "
47767 
47768 [INTERNAL]  Get function input(s) and output(s)
47769 
47770 ";
47771 
47772 %feature("docstring")  casadi::FunctionInternal::jac() const  "
47773 
47774 [INTERNAL]  Return Jacobian of all input elements with respect to all output
47775 elements.
47776 
47777 ";
47778 
47779 %feature("docstring")  casadi::FunctionInternal::get_n_in() "
47780 
47781 [INTERNAL]  Number of function inputs and outputs.
47782 
47783 ";
47784 
47785 %feature("docstring")  casadi::FunctionInternal::is_diff_out(casadi_int i) "
47786 
47787 [INTERNAL] ";
47788 
47789 %feature("docstring")  casadi::FunctionInternal::generate_dependencies(const
47790 std::string &fname, const Dict &opts) const  "
47791 
47792 [INTERNAL]  Export / Generate C code for the dependency function.
47793 
47794 ";
47795 
47796 %feature("docstring")  casadi::FunctionInternal::replace_aseed(const
47797 std::vector< std::vector< M >> &aseed, casadi_int npar) const  "
47798 
47799 [INTERNAL]  Replace 0-by-0 reverse seeds.
47800 
47801 ";
47802 
47803 %feature("docstring")  casadi::FunctionInternal::replace_aseed(const
47804 std::vector< std::vector< M > > &aseed, casadi_int npar) const  "
47805 
47806 [INTERNAL] ";
47807 
47808 %feature("docstring")  casadi::FunctionInternal::set_work(void *mem, const
47809 double **&arg, double **&res, casadi_int *&iw, double *&w) const  "
47810 
47811 [INTERNAL]  Set the (persistent) work vectors.
47812 
47813 ";
47814 
47815 %feature("docstring")  casadi::FunctionInternal::print_option(const
47816 std::string &name, std::ostream &stream) const  "
47817 
47818 [INTERNAL]  Print all information there is to know about a certain option.
47819 
47820 ";
47821 
47822 %feature("docstring")  casadi::FunctionInternal::instructions_sx() const  "
47823 
47824 [INTERNAL]  get SX expression associated with instructions
47825 
47826 ";
47827 
47828 %feature("docstring")  casadi::FunctionInternal::size2_out(casadi_int ind)
47829 const  "
47830 
47831 [INTERNAL]  Input/output dimensions.
47832 
47833 ";
47834 
47835 %feature("docstring")  casadi::FunctionInternal::get_max_in(casadi_int ind)
47836 const  "
47837 
47838 [INTERNAL]  Get largest input value.
47839 
47840 ";
47841 
47842 %feature("docstring")  casadi::FunctionInternal::has_jac() const  "
47843 
47844 [INTERNAL]  Return Jacobian of all input elements with respect to all output
47845 elements.
47846 
47847 ";
47848 
47849 %feature("docstring")  casadi::LinearInterpolantJac::has_codegen() const  "
47850 
47851 [INTERNAL]  Is codegen supported?
47852 
47853 ";
47854 
47855 %feature("docstring")
47856 casadi::FunctionInternal::print_dimensions(std::ostream &stream) const  "
47857 
47858 [INTERNAL]  Print dimensions of inputs and outputs.
47859 
47860 ";
47861 
47862 %feature("docstring")  casadi::FunctionInternal::all_scalar() const  "
47863 
47864 [INTERNAL]  Are all inputs and outputs scalar.
47865 
47866 ";
47867 
47868 %feature("docstring")  casadi::FunctionInternal::sp_weight() const  "
47869 
47870 [INTERNAL]  Weighting factor for chosing forward/reverse mode, sparsity
47871 propagation.
47872 
47873 ";
47874 
47875 %feature("docstring")
47876 casadi::LinearInterpolantJac::LinearInterpolantJac(const std::string &name)
47877 "
47878 
47879 [INTERNAL]  Constructor.
47880 
47881 ";
47882 
47883 %feature("docstring")
47884 casadi::LinearInterpolantJac::LinearInterpolantJac(DeserializingStream &s) "
47885 
47886 [INTERNAL]  Deserializing constructor.
47887 
47888 ";
47889 
47890 %feature("docstring")  casadi::FunctionInternal::self() const  "
47891 
47892 [INTERNAL]  Get a public class instance.
47893 
47894 ";
47895 
47896 
47897 // File: classcasadi_1_1Linsol.xml
47898 %feature("docstring")  casadi::Linsol::neig(const DM &A) const  "
47899 
47900 Number of negative eigenvalues Not available for all solvers.
47901 
47902 ";
47903 
47904 %feature("docstring")  casadi::SharedObject::class_name() const  "
47905 
47906 Get class name.
47907 
47908 ";
47909 
47910 %feature("docstring")  casadi::SharedObject::is_null() const  "
47911 
47912 Is a null pointer?
47913 
47914 ";
47915 
47916 %feature("docstring")  casadi::Linsol::nfact(const DM &A) const  "
47917 
47918 Numeric factorization of the linear system.
47919 
47920 ";
47921 
47922 %feature("docstring")  casadi::Linsol::solve(const DM &A, const DM &B, bool
47923 tr=false) const  "
47924 
47925 Solve linear system of equations
47926 
47927 ";
47928 
47929 %feature("docstring") casadi::casadi_solve "
47930 
47931 Solve linear system of equations
47932 
47933 ";
47934 
47935 %feature("docstring")  casadi::Linsol::casadi_solve "
47936 
47937 Solve linear system of equations
47938 
47939 ";
47940 
47941 %feature("docstring")  casadi::Linsol::solve(const MX &A, const MX &B, bool
47942 tr=false) const  "
47943 
47944 Solve linear system of equations
47945 
47946 ";
47947 
47948 %feature("docstring") casadi::casadi_solve "
47949 
47950 Solve linear system of equations
47951 
47952 ";
47953 
47954 %feature("docstring")  casadi::Linsol::casadi_solve "
47955 
47956 Solve linear system of equations
47957 
47958 ";
47959 
47960 %feature("docstring") casadi::Linsol::Linsol() "
47961 
47962 Default constructor.
47963 
47964 ";
47965 
47966 %feature("docstring") casadi::Linsol::Linsol(const std::string &name, const
47967 std::string &solver, const Sparsity &sp, const Dict &opts=Dict()) "
47968 
47969 Constructor.
47970 
47971 ";
47972 
47973 %feature("docstring") casadi::Linsol::__hash__ "
47974 
47975 Returns a number that is unique for a given Node. If the Object does not
47976 point to any node, \"0\" is returned.
47977 
47978 ";
47979 
47980 %feature("docstring") casadi::Linsol "
47981 
47982 Linear solver Create a solver for linear systems of equations Solves the
47983 linear system A*X = B or A^T*X = B for X with A square and non- singular.
47984 
47985 If A is structurally singular, an error will be thrown during init. If A is
47986 numerically singular, the prepare step will fail.
47987 
47988 General information
47989 ===================
47990 
47991 
47992 
47993 List of plugins
47994 ===============
47995 
47996 
47997 
47998 - csparsecholesky
47999 
48000 - csparse
48001 
48002 - ma27
48003 
48004 - lapacklu
48005 
48006 - lapackqr
48007 
48008 - mumps
48009 
48010 - ldl
48011 
48012 - qr
48013 
48014 - tridiag
48015 
48016 - symbolicqr
48017 
48018 Note: some of the plugins in this list might not be available on your
48019 system. Also, there might be extra plugins available to you that are not
48020 listed here. You can obtain their documentation with
48021 Linsol.doc(\"myextraplugin\")
48022 
48023 
48024 
48025 --------------------------------------------------------------------------------
48026 
48027 csparsecholesky
48028 ---------------
48029 
48030 
48031 
48032 Linsol with CSparseCholesky Interface
48033 
48034 --------------------------------------------------------------------------------
48035 
48036 
48037 
48038 
48039 
48040 --------------------------------------------------------------------------------
48041 
48042 csparse
48043 -------
48044 
48045 
48046 
48047 Linsol with CSparse Interface
48048 
48049 --------------------------------------------------------------------------------
48050 
48051 
48052 
48053 
48054 
48055 --------------------------------------------------------------------------------
48056 
48057 ma27
48058 ----
48059 
48060 
48061 
48062 Interface to the sparse direct linear solver MA27 Works for symmetric
48063 indefinite systems Partly adopted from qpOASES 3.2 Joel Andersson
48064 
48065 --------------------------------------------------------------------------------
48066 
48067 lapacklu
48068 --------
48069 
48070 
48071 
48072 This class solves the linear system A.x=b by making an LU factorization of
48073 A: A = L.U, with L lower and U upper triangular
48074 
48075 >List of available options
48076 
48077 +-----------------------------+---------+----------------------------------+
48078 |             Id              |  Type   |           Description            |
48079 +=============================+=========+==================================+
48080 | allow_equilibration_failure | OT_BOOL | Non-fatal error when             |
48081 |                             |         | equilibration fails              |
48082 +-----------------------------+---------+----------------------------------+
48083 | equilibration               | OT_BOOL | Equilibrate the matrix           |
48084 +-----------------------------+---------+----------------------------------+
48085 
48086 --------------------------------------------------------------------------------
48087 
48088 
48089 
48090 --------------------------------------------------------------------------------
48091 
48092 lapackqr
48093 --------
48094 
48095 
48096 
48097 This class solves the linear system A.x=b by making an QR factorization of
48098 A: A = Q.R, with Q orthogonal and R upper triangular
48099 
48100 >List of available options
48101 
48102 +----------+--------+------------------------------------------------------+
48103 |    Id    |  Type  |                     Description                      |
48104 +==========+========+======================================================+
48105 | max_nrhs | OT_INT | Maximum number of right-hand-sides that get          |
48106 |          |        | processed in a single pass [default:10].             |
48107 +----------+--------+------------------------------------------------------+
48108 
48109 --------------------------------------------------------------------------------
48110 
48111 
48112 
48113 --------------------------------------------------------------------------------
48114 
48115 mumps
48116 -----
48117 
48118 
48119 
48120 Interface to the sparse direct linear solver MUMPS Works for symmetric
48121 indefinite systems Joel Andersson
48122 
48123 >List of available options
48124 
48125 +-----------+---------+-------------------+
48126 |    Id     |  Type   |    Description    |
48127 +===========+=========+===================+
48128 | posdef    | OT_BOOL | Positive definite |
48129 +-----------+---------+-------------------+
48130 | symmetric | OT_BOOL | Symmetric matrix  |
48131 +-----------+---------+-------------------+
48132 
48133 --------------------------------------------------------------------------------
48134 
48135 
48136 
48137 --------------------------------------------------------------------------------
48138 
48139 ldl
48140 ---
48141 
48142 
48143 
48144 Linear solver using sparse direct LDL factorization
48145 
48146 --------------------------------------------------------------------------------
48147 
48148 
48149 
48150 
48151 
48152 --------------------------------------------------------------------------------
48153 
48154 qr --
48155 
48156 
48157 
48158 Linear solver using sparse direct QR factorization
48159 
48160 --------------------------------------------------------------------------------
48161 
48162 
48163 
48164 
48165 
48166 --------------------------------------------------------------------------------
48167 
48168 tridiag
48169 -------
48170 
48171 
48172 
48173 Linear solver for tridiagonal matrices
48174 
48175 --------------------------------------------------------------------------------
48176 
48177 
48178 
48179 
48180 
48181 --------------------------------------------------------------------------------
48182 
48183 symbolicqr
48184 ----------
48185 
48186 
48187 
48188 Linear solver for sparse least-squares problems Inspired
48189 fromhttps://github.com/scipy/scipy/blob/v0.14.0/scipy/sparse/linalg/isolve/lsqr.py#L96
48190 
48191 Linsol based on QR factorization with sparsity pattern based reordering
48192 without partial pivoting
48193 
48194 >List of available options
48195 
48196 +-------+---------+----------------------------------------------------+
48197 |  Id   |  Type   |                    Description                     |
48198 +=======+=========+====================================================+
48199 | fopts | OT_DICT | Options to be passed to generated function objects |
48200 +-------+---------+----------------------------------------------------+
48201 
48202 --------------------------------------------------------------------------------
48203 
48204 
48205 
48206 Joel Andersson
48207 
48208 C++ includes: linsol.hpp ";
48209 
48210 %feature("docstring")  casadi::Linsol::sfact(const DM &A) const  "
48211 
48212 Symbolic factorization of the linear system, e.g. selecting pivots.
48213 
48214 ";
48215 
48216 %feature("docstring")  casadi::Linsol::rank(const DM &A) const  "
48217 
48218 Matrix rank Not available for all solvers.
48219 
48220 ";
48221 
48222 %feature("docstring")  casadi::SharedObject::disp(std::ostream &stream, bool
48223 more=false) const  "
48224 
48225 Print a description of the object.
48226 
48227 ";
48228 
48229 %feature("docstring")  casadi::SharedObject::get_str(bool more=false) const
48230 "
48231 
48232 Get string representation.
48233 
48234 ";
48235 
48236 %feature("docstring")  casadi::Linsol::stats(int mem=1) const  "
48237 
48238 Get all statistics obtained at the end of the last evaluate call.
48239 
48240 ";
48241 
48242 %feature("docstring")  casadi::Linsol::plugin_name() const  "
48243 
48244 Query plugin name.
48245 
48246 ";
48247 
48248 %feature("docstring")  casadi::SharedObject::print_ptr(std::ostream
48249 &stream=casadi::uout()) const  "
48250 
48251 [INTERNAL]  Print the pointer to the internal class
48252 
48253 ";
48254 
48255 %feature("docstring")  casadi::Linsol::sparsity() const  "
48256 
48257 Get linear system sparsity.
48258 
48259 ";
48260 
48261 %feature("docstring") casadi::casadi_sparsity "
48262 
48263 Get linear system sparsity.
48264 
48265 ";
48266 
48267 %feature("docstring")  casadi::Linsol::casadi_sparsity "
48268 
48269 Get linear system sparsity.
48270 
48271 ";
48272 
48273 
48274 // File: classcasadi_1_1LinsolLdl.xml
48275 %feature("docstring")  casadi::LinsolInternal::nnz() const  "
48276 
48277 [INTERNAL] ";
48278 
48279 %feature("docstring")  casadi::ProtoFunction::sprint(char *buf, size_t
48280 buf_sz, const char *fmt,...) const  "
48281 
48282 [INTERNAL]  C-style formatted printing to string.
48283 
48284 ";
48285 
48286 %feature("docstring")  casadi::LinsolInternal::ncol() const  "
48287 
48288 [INTERNAL] ";
48289 
48290 %feature("docstring")  casadi::LinsolInternal::row() const  "
48291 
48292 [INTERNAL] ";
48293 
48294 %feature("docstring")  casadi::LinsolLdl::serialize_body(SerializingStream
48295 &s) const  "
48296 
48297 [INTERNAL]  Serialize an object without type information.
48298 
48299 ";
48300 
48301 %feature("docstring")  casadi::LinsolInternal::disp(std::ostream &stream,
48302 bool more) const  "
48303 
48304 [INTERNAL]  Display object.
48305 
48306 ";
48307 
48308 %feature("docstring")  casadi::LinsolLdl::get_options() const  "
48309 
48310 [INTERNAL]  Options.
48311 
48312 ";
48313 
48314 %feature("docstring")  casadi::LinsolInternal::disp_more(std::ostream
48315 &stream) const  "
48316 
48317 [INTERNAL]  Print more.
48318 
48319 ";
48320 
48321 %feature("docstring")  casadi::ProtoFunction::format_time(char *buffer,
48322 double time) const  "
48323 
48324 [INTERNAL]  Format time in a fixed width 8 format.
48325 
48326 ";
48327 
48328 %feature("docstring")  casadi::LinsolLdl::neig(void *mem, const double *A)
48329 const  "
48330 
48331 [INTERNAL]  Number of negative eigenvalues.
48332 
48333 ";
48334 
48335 %feature("docstring")  casadi::LinsolLdl::rank(void *mem, const double *A)
48336 const  "
48337 
48338 [INTERNAL]   Matrix rank.
48339 
48340 ";
48341 
48342 %feature("docstring")  casadi::ProtoFunction::serialize(SerializingStream
48343 &s) const  "
48344 
48345 [INTERNAL]  Serialize an object.
48346 
48347 ";
48348 
48349 %feature("docstring")  casadi::LinsolLdl::class_name() const  "
48350 
48351 [INTERNAL]  Readable name of the internal class.
48352 
48353 ";
48354 
48355 %feature("docstring") casadi::LinsolLdl::~LinsolLdl "
48356 
48357 [INTERNAL] ";
48358 
48359 %feature("docstring")  casadi::LinsolLdl::init(const Dict &opts)  "
48360 
48361 [INTERNAL]  Initialize.
48362 
48363 ";
48364 
48365 %feature("docstring")  casadi::LinsolLdl::alloc_mem() const  "
48366 
48367 [INTERNAL]  Create memory block.
48368 
48369 ";
48370 
48371 %feature("docstring")  casadi::ProtoFunction::print_time(const std::map<
48372 std::string, FStats > &fstats) const  "
48373 
48374 [INTERNAL]  Print timing statistics.
48375 
48376 ";
48377 
48378 %feature("docstring")  casadi::ProtoFunction::memory(int ind) const  "
48379 
48380 [INTERNAL]  Memory objects.
48381 
48382 ";
48383 
48384 %feature("docstring")  casadi::ProtoFunction::clear_mem() "
48385 
48386 [INTERNAL]  Clear all memory (called from destructor)
48387 
48388 ";
48389 
48390 %feature("docstring")  casadi::SharedObjectInternal::weak() "
48391 
48392 [INTERNAL]  Get a weak reference to the object.
48393 
48394 ";
48395 
48396 %feature("docstring")  casadi::ProtoFunction::checkout() const  "
48397 
48398 [INTERNAL]  Checkout a memory object.
48399 
48400 ";
48401 
48402 %feature("docstring")
48403 casadi::LinsolInternal::serialize_type(SerializingStream &s) const  "
48404 
48405 [INTERNAL]  Serialize type information.
48406 
48407 ";
48408 
48409 %feature("docstring") casadi::LinsolLdl::LinsolLdl(const std::string &name,
48410 const Sparsity &sp) "
48411 
48412 [INTERNAL] ";
48413 
48414 %feature("docstring")  casadi::ProtoFunction::construct(const Dict &opts) "
48415 
48416 [INTERNAL]  Construct Prepares the function for evaluation.
48417 
48418 ";
48419 
48420 %feature("docstring") casadi::LinsolLdl "
48421 
48422 'ldl' plugin for LinsolInternal
48423 
48424 >List of available options
48425 
48426 +-------------+---------+-----------------------------------------------+
48427 |     Id      |  Type   |                  Description                  |
48428 +=============+=========+===============================================+
48429 | incomplete  | OT_BOOL | Incomplete factorization, without any fill-in |
48430 +-------------+---------+-----------------------------------------------+
48431 | preordering | OT_BOOL | Approximate minimal degree (AMD) preordering  |
48432 +-------------+---------+-----------------------------------------------+
48433 
48434 >List of available options
48435 
48436 +------------------+-----------------+------------------+------------------+
48437 |        Id        |      Type       |   Description    |     Used in      |
48438 +==================+=================+==================+==================+
48439 | ad_weight        | OT_DOUBLE       | Weighting factor | casadi::ProtoFun |
48440 |                  |                 | for derivative   | ction            |
48441 |                  |                 | calculation.When |                  |
48442 |                  |                 | there is an      |                  |
48443 |                  |                 | option of either |                  |
48444 |                  |                 | using forward or |                  |
48445 |                  |                 | reverse mode     |                  |
48446 |                  |                 | directional      |                  |
48447 |                  |                 | derivatives, the |                  |
48448 |                  |                 | condition ad_wei |                  |
48449 |                  |                 | ght*nf<=(1-ad_we |                  |
48450 |                  |                 | ight)*na is used |                  |
48451 |                  |                 | where nf and na  |                  |
48452 |                  |                 | are estimates of |                  |
48453 |                  |                 | the number of    |                  |
48454 |                  |                 | forward/reverse  |                  |
48455 |                  |                 | mode directional |                  |
48456 |                  |                 | derivatives      |                  |
48457 |                  |                 | needed. By       |                  |
48458 |                  |                 | default,         |                  |
48459 |                  |                 | ad_weight is     |                  |
48460 |                  |                 | calculated       |                  |
48461 |                  |                 | automatically,   |                  |
48462 |                  |                 | but this can be  |                  |
48463 |                  |                 | overridden by    |                  |
48464 |                  |                 | setting this     |                  |
48465 |                  |                 | option. In       |                  |
48466 |                  |                 | particular, 0    |                  |
48467 |                  |                 | means forcing    |                  |
48468 |                  |                 | forward mode and |                  |
48469 |                  |                 | 1 forcing        |                  |
48470 |                  |                 | reverse mode.    |                  |
48471 |                  |                 | Leave unset for  |                  |
48472 |                  |                 | (class specific) |                  |
48473 |                  |                 | heuristics.      |                  |
48474 +------------------+-----------------+------------------+------------------+
48475 | ad_weight_sp     | OT_DOUBLE       | Weighting factor | casadi::ProtoFun |
48476 |                  |                 | for sparsity     | ction            |
48477 |                  |                 | pattern          |                  |
48478 |                  |                 | calculation calc |                  |
48479 |                  |                 | ulation.Override |                  |
48480 |                  |                 | s default        |                  |
48481 |                  |                 | behavior. Set to |                  |
48482 |                  |                 | 0 and 1 to force |                  |
48483 |                  |                 | forward and      |                  |
48484 |                  |                 | reverse mode     |                  |
48485 |                  |                 | respectively.    |                  |
48486 |                  |                 | Cf. option       |                  |
48487 |                  |                 | \"ad_weight\".     |                  |
48488 |                  |                 | When set to -1,  |                  |
48489 |                  |                 | sparsity is      |                  |
48490 |                  |                 | completely       |                  |
48491 |                  |                 | ignored and      |                  |
48492 |                  |                 | dense matrices   |                  |
48493 |                  |                 | are used.        |                  |
48494 +------------------+-----------------+------------------+------------------+
48495 | always_inline    | OT_BOOL         | Force inlining.  | casadi::ProtoFun |
48496 |                  |                 |                  | ction            |
48497 +------------------+-----------------+------------------+------------------+
48498 | compiler         | OT_STRING       | Just-in-time     | casadi::ProtoFun |
48499 |                  |                 | compiler plugin  | ction            |
48500 |                  |                 | to be used.      |                  |
48501 +------------------+-----------------+------------------+------------------+
48502 | custom_jacobian  | OT_FUNCTION     | Override         | casadi::ProtoFun |
48503 |                  |                 | CasADi's AD. Use | ction            |
48504 |                  |                 | together with    |                  |
48505 |                  |                 | 'jac_penalty':   |                  |
48506 |                  |                 | 0. Note: Highly  |                  |
48507 |                  |                 | experimental.    |                  |
48508 |                  |                 | Syntax may break |                  |
48509 |                  |                 | often.           |                  |
48510 +------------------+-----------------+------------------+------------------+
48511 | derivative_of    | OT_FUNCTION     | The function is  | casadi::ProtoFun |
48512 |                  |                 | a derivative of  | ction            |
48513 |                  |                 | another          |                  |
48514 |                  |                 | function. The    |                  |
48515 |                  |                 | type of          |                  |
48516 |                  |                 | derivative       |                  |
48517 |                  |                 | (directional     |                  |
48518 |                  |                 | derivative,      |                  |
48519 |                  |                 | Jacobian) is     |                  |
48520 |                  |                 | inferred from    |                  |
48521 |                  |                 | the function     |                  |
48522 |                  |                 | name.            |                  |
48523 +------------------+-----------------+------------------+------------------+
48524 | dump             | OT_BOOL         | Dump function to | casadi::ProtoFun |
48525 |                  |                 | file upon first  | ction            |
48526 |                  |                 | evaluation.      |                  |
48527 |                  |                 | [false]          |                  |
48528 +------------------+-----------------+------------------+------------------+
48529 | dump_dir         | OT_STRING       | Directory to     | casadi::ProtoFun |
48530 |                  |                 | dump             | ction            |
48531 |                  |                 | inputs/outputs   |                  |
48532 |                  |                 | to. Make sure    |                  |
48533 |                  |                 | the directory    |                  |
48534 |                  |                 | exists [.]       |                  |
48535 +------------------+-----------------+------------------+------------------+
48536 | dump_format      | OT_STRING       | Choose file      | casadi::ProtoFun |
48537 |                  |                 | format to dump   | ction            |
48538 |                  |                 | matrices. See    |                  |
48539 |                  |                 | DM.from_file     |                  |
48540 |                  |                 | [mtx]            |                  |
48541 +------------------+-----------------+------------------+------------------+
48542 | dump_in          | OT_BOOL         | Dump numerical   | casadi::ProtoFun |
48543 |                  |                 | values of inputs | ction            |
48544 |                  |                 | to file          |                  |
48545 |                  |                 | (readable with   |                  |
48546 |                  |                 | DM.from_file )   |                  |
48547 |                  |                 | [default: false] |                  |
48548 +------------------+-----------------+------------------+------------------+
48549 | dump_out         | OT_BOOL         | Dump numerical   | casadi::ProtoFun |
48550 |                  |                 | values of        | ction            |
48551 |                  |                 | outputs to file  |                  |
48552 |                  |                 | (readable with   |                  |
48553 |                  |                 | DM.from_file )   |                  |
48554 |                  |                 | [default: false] |                  |
48555 +------------------+-----------------+------------------+------------------+
48556 | enable_fd        | OT_BOOL         | Enable           | casadi::ProtoFun |
48557 |                  |                 | derivative       | ction            |
48558 |                  |                 | calculation by   |                  |
48559 |                  |                 | finite           |                  |
48560 |                  |                 | differencing.    |                  |
48561 |                  |                 | [default:        |                  |
48562 |                  |                 | false]]          |                  |
48563 +------------------+-----------------+------------------+------------------+
48564 | enable_forward   | OT_BOOL         | Enable           | casadi::ProtoFun |
48565 |                  |                 | derivative       | ction            |
48566 |                  |                 | calculation      |                  |
48567 |                  |                 | using generated  |                  |
48568 |                  |                 | functions for    |                  |
48569 |                  |                 | Jacobian-times-  |                  |
48570 |                  |                 | vector products  |                  |
48571 |                  |                 | - typically      |                  |
48572 |                  |                 | using forward    |                  |
48573 |                  |                 | mode AD - if     |                  |
48574 |                  |                 | available.       |                  |
48575 |                  |                 | [default: true]  |                  |
48576 +------------------+-----------------+------------------+------------------+
48577 | enable_jacobian  | OT_BOOL         | Enable           | casadi::ProtoFun |
48578 |                  |                 | derivative       | ction            |
48579 |                  |                 | calculation      |                  |
48580 |                  |                 | using generated  |                  |
48581 |                  |                 | functions for    |                  |
48582 |                  |                 | Jacobians of all |                  |
48583 |                  |                 | differentiable   |                  |
48584 |                  |                 | outputs with     |                  |
48585 |                  |                 | respect to all   |                  |
48586 |                  |                 | differentiable   |                  |
48587 |                  |                 | inputs - if      |                  |
48588 |                  |                 | available.       |                  |
48589 |                  |                 | [default: true]  |                  |
48590 +------------------+-----------------+------------------+------------------+
48591 | enable_reverse   | OT_BOOL         | Enable           | casadi::ProtoFun |
48592 |                  |                 | derivative       | ction            |
48593 |                  |                 | calculation      |                  |
48594 |                  |                 | using generated  |                  |
48595 |                  |                 | functions for    |                  |
48596 |                  |                 | transposed       |                  |
48597 |                  |                 | Jacobian-times-  |                  |
48598 |                  |                 | vector products  |                  |
48599 |                  |                 | - typically      |                  |
48600 |                  |                 | using reverse    |                  |
48601 |                  |                 | mode AD - if     |                  |
48602 |                  |                 | available.       |                  |
48603 |                  |                 | [default: true]  |                  |
48604 +------------------+-----------------+------------------+------------------+
48605 | fd_method        | OT_STRING       | Method for       | casadi::ProtoFun |
48606 |                  |                 | finite           | ction            |
48607 |                  |                 | differencing     |                  |
48608 |                  |                 | [default         |                  |
48609 |                  |                 | 'central']       |                  |
48610 +------------------+-----------------+------------------+------------------+
48611 | fd_options       | OT_DICT         | Options to be    | casadi::ProtoFun |
48612 |                  |                 | passed to the    | ction            |
48613 |                  |                 | finite           |                  |
48614 |                  |                 | difference       |                  |
48615 |                  |                 | instance         |                  |
48616 +------------------+-----------------+------------------+------------------+
48617 | forward_options  | OT_DICT         | Options to be    | casadi::ProtoFun |
48618 |                  |                 | passed to a      | ction            |
48619 |                  |                 | forward mode     |                  |
48620 |                  |                 | constructor      |                  |
48621 +------------------+-----------------+------------------+------------------+
48622 | gather_stats     | OT_BOOL         | Deprecated       | casadi::ProtoFun |
48623 |                  |                 | option           | ction            |
48624 |                  |                 | (ignored):       |                  |
48625 |                  |                 | Statistics are   |                  |
48626 |                  |                 | now always       |                  |
48627 |                  |                 | collected.       |                  |
48628 +------------------+-----------------+------------------+------------------+
48629 | incomplete       | OT_BOOL         | Incomplete       | casadi::LinsolLd |
48630 |                  |                 | factorization,   | l                |
48631 |                  |                 | without any      |                  |
48632 |                  |                 | fill-in          |                  |
48633 +------------------+-----------------+------------------+------------------+
48634 | input_scheme     | OT_STRINGVECTOR | Deprecated       | casadi::ProtoFun |
48635 |                  |                 | option (ignored) | ction            |
48636 +------------------+-----------------+------------------+------------------+
48637 | inputs_check     | OT_BOOL         | Throw exceptions | casadi::ProtoFun |
48638 |                  |                 | when the         | ction            |
48639 |                  |                 | numerical values |                  |
48640 |                  |                 | of the inputs    |                  |
48641 |                  |                 | don't make sense |                  |
48642 +------------------+-----------------+------------------+------------------+
48643 | is_diff_in       | OT_BOOLVECTOR   | Indicate for     | casadi::ProtoFun |
48644 |                  |                 | each input if it | ction            |
48645 |                  |                 | should be        |                  |
48646 |                  |                 | differentiable.  |                  |
48647 +------------------+-----------------+------------------+------------------+
48648 | is_diff_out      | OT_BOOLVECTOR   | Indicate for     | casadi::ProtoFun |
48649 |                  |                 | each output if   | ction            |
48650 |                  |                 | it should be     |                  |
48651 |                  |                 | differentiable.  |                  |
48652 +------------------+-----------------+------------------+------------------+
48653 | jac_penalty      | OT_DOUBLE       | When requested   | casadi::ProtoFun |
48654 |                  |                 | for a number of  | ction            |
48655 |                  |                 | forward/reverse  |                  |
48656 |                  |                 | directions, it   |                  |
48657 |                  |                 | may be cheaper   |                  |
48658 |                  |                 | to compute first |                  |
48659 |                  |                 | the full         |                  |
48660 |                  |                 | jacobian and     |                  |
48661 |                  |                 | then multiply    |                  |
48662 |                  |                 | with seeds,      |                  |
48663 |                  |                 | rather than      |                  |
48664 |                  |                 | obtain the       |                  |
48665 |                  |                 | requested        |                  |
48666 |                  |                 | directions in a  |                  |
48667 |                  |                 | straightforward  |                  |
48668 |                  |                 | manner. Casadi   |                  |
48669 |                  |                 | uses a heuristic |                  |
48670 |                  |                 | to decide which  |                  |
48671 |                  |                 | is cheaper. A    |                  |
48672 |                  |                 | high value of    |                  |
48673 |                  |                 | 'jac_penalty'    |                  |
48674 |                  |                 | makes it less    |                  |
48675 |                  |                 | likely for the   |                  |
48676 |                  |                 | heurstic to      |                  |
48677 |                  |                 | chose the full   |                  |
48678 |                  |                 | Jacobian         |                  |
48679 |                  |                 | strategy. The    |                  |
48680 |                  |                 | special value -1 |                  |
48681 |                  |                 | indicates never  |                  |
48682 |                  |                 | to use the full  |                  |
48683 |                  |                 | Jacobian         |                  |
48684 |                  |                 | strategy         |                  |
48685 +------------------+-----------------+------------------+------------------+
48686 | jit              | OT_BOOL         | Use just-in-time | casadi::ProtoFun |
48687 |                  |                 | compiler to      | ction            |
48688 |                  |                 | speed up the     |                  |
48689 |                  |                 | evaluation       |                  |
48690 +------------------+-----------------+------------------+------------------+
48691 | jit_cleanup      | OT_BOOL         | Cleanup up the   | casadi::ProtoFun |
48692 |                  |                 | temporary source | ction            |
48693 |                  |                 | file that jit    |                  |
48694 |                  |                 | creates.         |                  |
48695 |                  |                 | Default: true    |                  |
48696 +------------------+-----------------+------------------+------------------+
48697 | jit_name         | OT_STRING       | The file name    | casadi::ProtoFun |
48698 |                  |                 | used to write    | ction            |
48699 |                  |                 | out code. The    |                  |
48700 |                  |                 | actual file      |                  |
48701 |                  |                 | names used       |                  |
48702 |                  |                 | depend on 'jit_t |                  |
48703 |                  |                 | emp_suffix' and  |                  |
48704 |                  |                 | include          |                  |
48705 |                  |                 | extensions.      |                  |
48706 |                  |                 | Default:         |                  |
48707 |                  |                 | 'jit_tmp'        |                  |
48708 +------------------+-----------------+------------------+------------------+
48709 | jit_options      | OT_DICT         | Options to be    | casadi::ProtoFun |
48710 |                  |                 | passed to the    | ction            |
48711 |                  |                 | jit compiler.    |                  |
48712 +------------------+-----------------+------------------+------------------+
48713 | jit_serialize    | OT_STRING       | Specify          | casadi::ProtoFun |
48714 |                  |                 | behaviour when   | ction            |
48715 |                  |                 | serializing a    |                  |
48716 |                  |                 | jitted function: |                  |
48717 |                  |                 | SOURCE|link|embe |                  |
48718 |                  |                 | d.               |                  |
48719 +------------------+-----------------+------------------+------------------+
48720 | jit_temp_suffix  | OT_BOOL         | Use a temporary  | casadi::ProtoFun |
48721 |                  |                 | (seemingly       | ction            |
48722 |                  |                 | random) filename |                  |
48723 |                  |                 | suffix for       |                  |
48724 |                  |                 | generated code   |                  |
48725 |                  |                 | and libraries.   |                  |
48726 |                  |                 | This is desired  |                  |
48727 |                  |                 | for thread-      |                  |
48728 |                  |                 | safety. This     |                  |
48729 |                  |                 | behaviour may    |                  |
48730 |                  |                 | defeat caching   |                  |
48731 |                  |                 | compiler         |                  |
48732 |                  |                 | wrappers.        |                  |
48733 |                  |                 | Default: true    |                  |
48734 +------------------+-----------------+------------------+------------------+
48735 | max_num_dir      | OT_INT          | Specify the      | casadi::ProtoFun |
48736 |                  |                 | maximum number   | ction            |
48737 |                  |                 | of directions    |                  |
48738 |                  |                 | for derivative   |                  |
48739 |                  |                 | functions.       |                  |
48740 |                  |                 | Overrules the    |                  |
48741 |                  |                 | builtin optimize |                  |
48742 |                  |                 | d_num_dir.       |                  |
48743 +------------------+-----------------+------------------+------------------+
48744 | never_inline     | OT_BOOL         | Forbid inlining. | casadi::ProtoFun |
48745 |                  |                 |                  | ction            |
48746 +------------------+-----------------+------------------+------------------+
48747 | output_scheme    | OT_STRINGVECTOR | Deprecated       | casadi::ProtoFun |
48748 |                  |                 | option (ignored) | ction            |
48749 +------------------+-----------------+------------------+------------------+
48750 | preordering      | OT_BOOL         | Approximate      | casadi::LinsolLd |
48751 |                  |                 | minimal degree   | l                |
48752 |                  |                 | (AMD)            |                  |
48753 |                  |                 | preordering      |                  |
48754 +------------------+-----------------+------------------+------------------+
48755 | print_in         | OT_BOOL         | Print numerical  | casadi::ProtoFun |
48756 |                  |                 | values of inputs | ction            |
48757 |                  |                 | [default: false] |                  |
48758 +------------------+-----------------+------------------+------------------+
48759 | print_out        | OT_BOOL         | Print numerical  | casadi::ProtoFun |
48760 |                  |                 | values of        | ction            |
48761 |                  |                 | outputs          |                  |
48762 |                  |                 | [default: false] |                  |
48763 +------------------+-----------------+------------------+------------------+
48764 | print_time       | OT_BOOL         | print            | casadi::ProtoFun |
48765 |                  |                 | information      | ction            |
48766 |                  |                 | about execution  |                  |
48767 |                  |                 | time. Implies    |                  |
48768 |                  |                 | record_time.     |                  |
48769 +------------------+-----------------+------------------+------------------+
48770 | record_time      | OT_BOOL         | record           | casadi::ProtoFun |
48771 |                  |                 | information      | ction            |
48772 |                  |                 | about execution  |                  |
48773 |                  |                 | time, for        |                  |
48774 |                  |                 | retrieval with   |                  |
48775 |                  |                 | stats().         |                  |
48776 +------------------+-----------------+------------------+------------------+
48777 | regularity_check | OT_BOOL         | Throw exceptions | casadi::ProtoFun |
48778 |                  |                 | when NaN or Inf  | ction            |
48779 |                  |                 | appears during   |                  |
48780 |                  |                 | evaluation       |                  |
48781 +------------------+-----------------+------------------+------------------+
48782 | reverse_options  | OT_DICT         | Options to be    | casadi::ProtoFun |
48783 |                  |                 | passed to a      | ction            |
48784 |                  |                 | reverse mode     |                  |
48785 |                  |                 | constructor      |                  |
48786 +------------------+-----------------+------------------+------------------+
48787 | user_data        | OT_VOIDPTR      | A user-defined   | casadi::ProtoFun |
48788 |                  |                 | field that can   | ction            |
48789 |                  |                 | be used to       |                  |
48790 |                  |                 | identify the     |                  |
48791 |                  |                 | function or pass |                  |
48792 |                  |                 | additional       |                  |
48793 |                  |                 | information      |                  |
48794 +------------------+-----------------+------------------+------------------+
48795 | verbose          | OT_BOOL         | Verbose          | casadi::ProtoFun |
48796 |                  |                 | evaluation  for  | ction            |
48797 |                  |                 | debugging        |                  |
48798 +------------------+-----------------+------------------+------------------+
48799 
48800 Diagrams
48801 --------
48802 
48803 
48804 
48805 C++ includes: linsol_ldl.hpp ";
48806 
48807 %feature("docstring")  casadi::LinsolLdl::nfact(void *mem, const double *A)
48808 const  "
48809 
48810 [INTERNAL]  Numeric factorization.
48811 
48812 ";
48813 
48814 %feature("docstring")  casadi::LinsolLdl::sfact(void *mem, const double *A)
48815 const  "
48816 
48817 [INTERNAL] ";
48818 
48819 %feature("docstring")  casadi::SharedObjectInternal::getCount() const  "
48820 
48821 [INTERNAL]  Get the reference count.
48822 
48823 ";
48824 
48825 %feature("docstring")  casadi::LinsolInternal::linsol_eval_sx(const SXElem
48826 **arg, SXElem **res, casadi_int *iw, SXElem *w, void *mem, bool tr,
48827 casadi_int nrhs) const  "
48828 
48829 [INTERNAL]  Evaluate SX, possibly transposed.
48830 
48831 ";
48832 
48833 %feature("docstring")  casadi::LinsolLdl::generate(CodeGenerator &g, const
48834 std::string &A, const std::string &x, casadi_int nrhs, bool tr) const  "
48835 
48836 [INTERNAL]  Generate C code.
48837 
48838 ";
48839 
48840 %feature("docstring")  casadi::ProtoFunction::get_stats(void *mem) const  "
48841 
48842 [INTERNAL]  Get all statistics.
48843 
48844 ";
48845 
48846 %feature("docstring")  casadi::ProtoFunction::finalize() "
48847 
48848 [INTERNAL]  Finalize the object creation This function, which visits the
48849 class hierarchy in reverse order is run after init() has been completed.
48850 
48851 ";
48852 
48853 %feature("docstring")  casadi::LinsolLdl::plugin_name() const  "
48854 
48855 [INTERNAL] ";
48856 
48857 %feature("docstring")  casadi::ProtoFunction::print(const char *fmt,...)
48858 const  "
48859 
48860 [INTERNAL]  C-style formatted printing during evaluation.
48861 
48862 ";
48863 
48864 %feature("docstring")  casadi::ProtoFunction::release(int mem) const  "
48865 
48866 [INTERNAL]  Release a memory object.
48867 
48868 ";
48869 
48870 %feature("docstring")  casadi::LinsolLdl::solve(void *mem, const double *A,
48871 double *x, casadi_int nrhs, bool tr) const  "
48872 
48873 [INTERNAL] ";
48874 
48875 %feature("docstring")  casadi::ProtoFunction::serialize_base_function()
48876 const  "
48877 
48878 [INTERNAL]  String used to identify the immediate FunctionInternal subclass.
48879 
48880 ";
48881 
48882 %feature("docstring")  casadi::LinsolInternal::nrow() const  "
48883 
48884 [INTERNAL]  Get sparsity pattern.
48885 
48886 ";
48887 
48888 %feature("docstring")  casadi::LinsolLdl::init_mem(void *mem) const  "
48889 
48890 [INTERNAL]  Initalize memory block.
48891 
48892 ";
48893 
48894 %feature("docstring")  casadi::LinsolInternal::colind() const  "
48895 
48896 [INTERNAL] ";
48897 
48898 %feature("docstring")  casadi::ProtoFunction::generate_options(bool
48899 is_temp=false) const  "
48900 
48901 [INTERNAL]  Reconstruct options dict.
48902 
48903 ";
48904 
48905 %feature("docstring")  casadi::LinsolLdl::free_mem(void *mem) const  "
48906 
48907 [INTERNAL]  Free memory block.
48908 
48909 ";
48910 
48911 
48912 // File: classcasadi_1_1LinsolQr.xml
48913 %feature("docstring")  casadi::LinsolInternal::disp(std::ostream &stream,
48914 bool more) const  "
48915 
48916 [INTERNAL]  Display object.
48917 
48918 ";
48919 
48920 %feature("docstring")  casadi::LinsolInternal::neig(void *mem, const double
48921 *A) const  "
48922 
48923 [INTERNAL]  Number of negative eigenvalues.
48924 
48925 ";
48926 
48927 %feature("docstring")  casadi::LinsolQr::solve(void *mem, const double *A,
48928 double *x, casadi_int nrhs, bool tr) const  "
48929 
48930 [INTERNAL] ";
48931 
48932 %feature("docstring") casadi::LinsolQr "
48933 
48934 'qr' plugin for LinsolInternal
48935 
48936 >List of available options
48937 
48938 +-------+-----------+------------------------------------------------------+
48939 |  Id   |   Type    |                     Description                      |
48940 +=======+===========+======================================================+
48941 | cache | OT_DOUBLE | Amount of factorisations to remember (thread-local)  |
48942 |       |           | [0]                                                  |
48943 +-------+-----------+------------------------------------------------------+
48944 | eps   | OT_DOUBLE | Minimum R entry before singularity is declared       |
48945 |       |           | [1e-12]                                              |
48946 +-------+-----------+------------------------------------------------------+
48947 
48948 >List of available options
48949 
48950 +-------+-----------+-----------------------------------+------------------+
48951 |  Id   |   Type    |            Description            |     Used in      |
48952 +=======+===========+===================================+==================+
48953 | cache | OT_DOUBLE | Amount of factorisations to       | casadi::LinsolQr |
48954 |       |           | remember (thread-local) [0]       |                  |
48955 +-------+-----------+-----------------------------------+------------------+
48956 | eps   | OT_DOUBLE | Minimum R entry before            | casadi::LinsolQr |
48957 |       |           | singularity is declared [1e-12]   |                  |
48958 +-------+-----------+-----------------------------------+------------------+
48959 
48960 Diagrams
48961 --------
48962 
48963 
48964 
48965 C++ includes: linsol_qr.hpp ";
48966 
48967 %feature("docstring")  casadi::LinsolQr::class_name() const  "
48968 
48969 [INTERNAL]  Readable name of the internal class.
48970 
48971 ";
48972 
48973 %feature("docstring")  casadi::LinsolQr::serialize_body(SerializingStream
48974 &s) const  "
48975 
48976 [INTERNAL]  Serialize an object without type information.
48977 
48978 ";
48979 
48980 %feature("docstring")  casadi::ProtoFunction::print_time(const std::map<
48981 std::string, FStats > &fstats) const  "
48982 
48983 [INTERNAL]  Print timing statistics.
48984 
48985 ";
48986 
48987 %feature("docstring")  casadi::ProtoFunction::clear_mem() "
48988 
48989 [INTERNAL]  Clear all memory (called from destructor)
48990 
48991 ";
48992 
48993 %feature("docstring")  casadi::LinsolQr::plugin_name() const  "
48994 
48995 [INTERNAL] ";
48996 
48997 %feature("docstring") casadi::LinsolQr::~LinsolQr "
48998 
48999 [INTERNAL] ";
49000 
49001 %feature("docstring")  casadi::LinsolInternal::ncol() const  "
49002 
49003 [INTERNAL] ";
49004 
49005 %feature("docstring")  casadi::ProtoFunction::sprint(char *buf, size_t
49006 buf_sz, const char *fmt,...) const  "
49007 
49008 [INTERNAL]  C-style formatted printing to string.
49009 
49010 ";
49011 
49012 %feature("docstring")  casadi::ProtoFunction::memory(int ind) const  "
49013 
49014 [INTERNAL]  Memory objects.
49015 
49016 ";
49017 
49018 %feature("docstring")  casadi::LinsolQr::free_mem(void *mem) const  "
49019 
49020 [INTERNAL]  Free memory block.
49021 
49022 ";
49023 
49024 %feature("docstring")  casadi::LinsolQr::finalize()  "
49025 
49026 [INTERNAL]  Finalize the object creation.
49027 
49028 ";
49029 
49030 %feature("docstring")  casadi::SharedObjectInternal::weak() "
49031 
49032 [INTERNAL]  Get a weak reference to the object.
49033 
49034 ";
49035 
49036 %feature("docstring")  casadi::ProtoFunction::get_stats(void *mem) const  "
49037 
49038 [INTERNAL]  Get all statistics.
49039 
49040 ";
49041 
49042 %feature("docstring")  casadi::LinsolQr::init(const Dict &opts)  "
49043 
49044 [INTERNAL]  Initialize.
49045 
49046 ";
49047 
49048 %feature("docstring")  casadi::LinsolQr::nfact(void *mem, const double *A)
49049 const  "
49050 
49051 [INTERNAL]  Numeric factorization.
49052 
49053 ";
49054 
49055 %feature("docstring")  casadi::ProtoFunction::serialize_base_function()
49056 const  "
49057 
49058 [INTERNAL]  String used to identify the immediate FunctionInternal subclass.
49059 
49060 ";
49061 
49062 %feature("docstring")  casadi::LinsolInternal::disp_more(std::ostream
49063 &stream) const  "
49064 
49065 [INTERNAL]  Print more.
49066 
49067 ";
49068 
49069 %feature("docstring")  casadi::LinsolQr::alloc_mem() const  "
49070 
49071 [INTERNAL]  Create memory block.
49072 
49073 ";
49074 
49075 %feature("docstring")  casadi::LinsolInternal::nnz() const  "
49076 
49077 [INTERNAL] ";
49078 
49079 %feature("docstring")
49080 casadi::LinsolInternal::serialize_type(SerializingStream &s) const  "
49081 
49082 [INTERNAL]  Serialize type information.
49083 
49084 ";
49085 
49086 %feature("docstring")  casadi::ProtoFunction::release(int mem) const  "
49087 
49088 [INTERNAL]  Release a memory object.
49089 
49090 ";
49091 
49092 %feature("docstring")  casadi::ProtoFunction::generate_options(bool
49093 is_temp=false) const  "
49094 
49095 [INTERNAL]  Reconstruct options dict.
49096 
49097 ";
49098 
49099 %feature("docstring")  casadi::LinsolInternal::linsol_eval_sx(const SXElem
49100 **arg, SXElem **res, casadi_int *iw, SXElem *w, void *mem, bool tr,
49101 casadi_int nrhs) const  "
49102 
49103 [INTERNAL]  Evaluate SX, possibly transposed.
49104 
49105 ";
49106 
49107 %feature("docstring")  casadi::ProtoFunction::serialize(SerializingStream
49108 &s) const  "
49109 
49110 [INTERNAL]  Serialize an object.
49111 
49112 ";
49113 
49114 %feature("docstring")  casadi::LinsolInternal::nrow() const  "
49115 
49116 [INTERNAL]  Get sparsity pattern.
49117 
49118 ";
49119 
49120 %feature("docstring")  casadi::LinsolInternal::rank(void *mem, const double
49121 *A) const  "
49122 
49123 [INTERNAL]   Matrix rank.
49124 
49125 ";
49126 
49127 %feature("docstring")  casadi::LinsolInternal::row() const  "
49128 
49129 [INTERNAL] ";
49130 
49131 %feature("docstring")  casadi::ProtoFunction::print(const char *fmt,...)
49132 const  "
49133 
49134 [INTERNAL]  C-style formatted printing during evaluation.
49135 
49136 ";
49137 
49138 %feature("docstring")  casadi::LinsolInternal::colind() const  "
49139 
49140 [INTERNAL] ";
49141 
49142 %feature("docstring")  casadi::LinsolQr::init_mem(void *mem) const  "
49143 
49144 [INTERNAL]  Initalize memory block.
49145 
49146 ";
49147 
49148 %feature("docstring")  casadi::LinsolQr::sfact(void *mem, const double *A)
49149 const  "
49150 
49151 [INTERNAL] ";
49152 
49153 %feature("docstring")  casadi::LinsolQr::generate(CodeGenerator &g, const
49154 std::string &A, const std::string &x, casadi_int nrhs, bool tr) const  "
49155 
49156 [INTERNAL]  Generate C code.
49157 
49158 ";
49159 
49160 %feature("docstring")  casadi::LinsolQr::get_options() const  "
49161 
49162 [INTERNAL]  Options.
49163 
49164 ";
49165 
49166 %feature("docstring") casadi::LinsolQr::LinsolQr(const std::string &name,
49167 const Sparsity &sp) "
49168 
49169 [INTERNAL] ";
49170 
49171 %feature("docstring")  casadi::ProtoFunction::checkout() const  "
49172 
49173 [INTERNAL]  Checkout a memory object.
49174 
49175 ";
49176 
49177 %feature("docstring")  casadi::ProtoFunction::format_time(char *buffer,
49178 double time) const  "
49179 
49180 [INTERNAL]  Format time in a fixed width 8 format.
49181 
49182 ";
49183 
49184 %feature("docstring")  casadi::SharedObjectInternal::getCount() const  "
49185 
49186 [INTERNAL]  Get the reference count.
49187 
49188 ";
49189 
49190 %feature("docstring")  casadi::ProtoFunction::construct(const Dict &opts) "
49191 
49192 [INTERNAL]  Construct Prepares the function for evaluation.
49193 
49194 ";
49195 
49196 
49197 // File: classcasadi_1_1LinsolTridiag.xml
49198 %feature("docstring")  casadi::LinsolInternal::nnz() const  "
49199 
49200 [INTERNAL] ";
49201 
49202 %feature("docstring")  casadi::ProtoFunction::clear_mem() "
49203 
49204 [INTERNAL]  Clear all memory (called from destructor)
49205 
49206 ";
49207 
49208 %feature("docstring")
49209 casadi::LinsolInternal::serialize_type(SerializingStream &s) const  "
49210 
49211 [INTERNAL]  Serialize type information.
49212 
49213 ";
49214 
49215 %feature("docstring")  casadi::LinsolTridiag::init_mem(void *mem) const  "
49216 
49217 [INTERNAL]  Initalize memory block.
49218 
49219 ";
49220 
49221 %feature("docstring")  casadi::SharedObjectInternal::getCount() const  "
49222 
49223 [INTERNAL]  Get the reference count.
49224 
49225 ";
49226 
49227 %feature("docstring")  casadi::ProtoFunction::get_stats(void *mem) const  "
49228 
49229 [INTERNAL]  Get all statistics.
49230 
49231 ";
49232 
49233 %feature("docstring")  casadi::LinsolTridiag::init(const Dict &opts)  "
49234 
49235 [INTERNAL]  Initialize.
49236 
49237 ";
49238 
49239 %feature("docstring")  casadi::LinsolInternal::disp(std::ostream &stream,
49240 bool more) const  "
49241 
49242 [INTERNAL]  Display object.
49243 
49244 ";
49245 
49246 %feature("docstring")  casadi::LinsolInternal::disp_more(std::ostream
49247 &stream) const  "
49248 
49249 [INTERNAL]  Print more.
49250 
49251 ";
49252 
49253 %feature("docstring")  casadi::ProtoFunction::construct(const Dict &opts) "
49254 
49255 [INTERNAL]  Construct Prepares the function for evaluation.
49256 
49257 ";
49258 
49259 %feature("docstring")  casadi::SharedObjectInternal::weak() "
49260 
49261 [INTERNAL]  Get a weak reference to the object.
49262 
49263 ";
49264 
49265 %feature("docstring")  casadi::LinsolInternal::rank(void *mem, const double
49266 *A) const  "
49267 
49268 [INTERNAL]   Matrix rank.
49269 
49270 ";
49271 
49272 %feature("docstring")  casadi::ProtoFunction::serialize(SerializingStream
49273 &s) const  "
49274 
49275 [INTERNAL]  Serialize an object.
49276 
49277 ";
49278 
49279 %feature("docstring")  casadi::ProtoFunction::checkout() const  "
49280 
49281 [INTERNAL]  Checkout a memory object.
49282 
49283 ";
49284 
49285 %feature("docstring")  casadi::ProtoFunction::serialize_base_function()
49286 const  "
49287 
49288 [INTERNAL]  String used to identify the immediate FunctionInternal subclass.
49289 
49290 ";
49291 
49292 %feature("docstring")  casadi::ProtoFunction::generate_options(bool
49293 is_temp=false) const  "
49294 
49295 [INTERNAL]  Reconstruct options dict.
49296 
49297 ";
49298 
49299 %feature("docstring")  casadi::ProtoFunction::finalize() "
49300 
49301 [INTERNAL]  Finalize the object creation This function, which visits the
49302 class hierarchy in reverse order is run after init() has been completed.
49303 
49304 ";
49305 
49306 %feature("docstring")  casadi::ProtoFunction::get_options() const  "
49307 
49308 [INTERNAL]  Options.
49309 
49310 ";
49311 
49312 %feature("docstring")  casadi::LinsolTridiag::alloc_mem() const  "
49313 
49314 [INTERNAL]  Create memory block.
49315 
49316 ";
49317 
49318 %feature("docstring")  casadi::ProtoFunction::print_time(const std::map<
49319 std::string, FStats > &fstats) const  "
49320 
49321 [INTERNAL]  Print timing statistics.
49322 
49323 ";
49324 
49325 %feature("docstring")  casadi::LinsolTridiag::solve(void *mem, const double
49326 *A, double *x, casadi_int nrhs, bool tr) const  "
49327 
49328 [INTERNAL] ";
49329 
49330 %feature("docstring")  casadi::LinsolTridiag::nfact(void *mem, const double
49331 *A) const  "
49332 
49333 [INTERNAL]  Numeric factorization.
49334 
49335 ";
49336 
49337 %feature("docstring")  casadi::LinsolTridiag::sfact(void *mem, const double
49338 *A) const  "
49339 
49340 [INTERNAL] ";
49341 
49342 %feature("docstring")  casadi::LinsolTridiag::class_name() const  "
49343 
49344 [INTERNAL]  Readable name of the internal class.
49345 
49346 ";
49347 
49348 %feature("docstring") casadi::LinsolTridiag::LinsolTridiag(const std::string
49349 &name, const Sparsity &sp) "
49350 
49351 [INTERNAL] ";
49352 
49353 %feature("docstring")  casadi::LinsolTridiag::free_mem(void *mem) const  "
49354 
49355 [INTERNAL]  Free memory block.
49356 
49357 ";
49358 
49359 %feature("docstring")  casadi::LinsolInternal::row() const  "
49360 
49361 [INTERNAL] ";
49362 
49363 %feature("docstring")  casadi::ProtoFunction::format_time(char *buffer,
49364 double time) const  "
49365 
49366 [INTERNAL]  Format time in a fixed width 8 format.
49367 
49368 ";
49369 
49370 %feature("docstring")  casadi::LinsolInternal::nrow() const  "
49371 
49372 [INTERNAL]  Get sparsity pattern.
49373 
49374 ";
49375 
49376 %feature("docstring")  casadi::LinsolInternal::colind() const  "
49377 
49378 [INTERNAL] ";
49379 
49380 %feature("docstring")  casadi::ProtoFunction::memory(int ind) const  "
49381 
49382 [INTERNAL]  Memory objects.
49383 
49384 ";
49385 
49386 %feature("docstring")  casadi::LinsolInternal::neig(void *mem, const double
49387 *A) const  "
49388 
49389 [INTERNAL]  Number of negative eigenvalues.
49390 
49391 ";
49392 
49393 %feature("docstring")  casadi::LinsolInternal::linsol_eval_sx(const SXElem
49394 **arg, SXElem **res, casadi_int *iw, SXElem *w, void *mem, bool tr,
49395 casadi_int nrhs) const  "
49396 
49397 [INTERNAL]  Evaluate SX, possibly transposed.
49398 
49399 ";
49400 
49401 %feature("docstring")  casadi::ProtoFunction::print(const char *fmt,...)
49402 const  "
49403 
49404 [INTERNAL]  C-style formatted printing during evaluation.
49405 
49406 ";
49407 
49408 %feature("docstring")  casadi::LinsolTridiag::generate(CodeGenerator &g,
49409 const std::string &A, const std::string &x, casadi_int nrhs, bool tr) const
49410 "
49411 
49412 [INTERNAL]  Generate C code.
49413 
49414 ";
49415 
49416 %feature("docstring")  casadi::LinsolInternal::ncol() const  "
49417 
49418 [INTERNAL] ";
49419 
49420 %feature("docstring") casadi::LinsolTridiag "
49421 
49422 [INTERNAL]  'tridiag' plugin for LinsolInternal
49423 
49424 C++ includes: linsol_tridiag.hpp ";
49425 
49426 %feature("docstring")
49427 casadi::LinsolInternal::serialize_body(SerializingStream &s) const  "
49428 
49429 [INTERNAL]  Serialize an object without type information.
49430 
49431 ";
49432 
49433 %feature("docstring")  casadi::LinsolTridiag::plugin_name() const  "
49434 
49435 [INTERNAL] ";
49436 
49437 %feature("docstring")  casadi::ProtoFunction::release(int mem) const  "
49438 
49439 [INTERNAL]  Release a memory object.
49440 
49441 ";
49442 
49443 %feature("docstring") casadi::LinsolTridiag::~LinsolTridiag "
49444 
49445 [INTERNAL] ";
49446 
49447 %feature("docstring")  casadi::ProtoFunction::sprint(char *buf, size_t
49448 buf_sz, const char *fmt,...) const  "
49449 
49450 [INTERNAL]  C-style formatted printing to string.
49451 
49452 ";
49453 
49454 
49455 // File: classcasadi_1_1Logger.xml
49456 %feature("docstring") casadi::Logger "
49457 
49458 Keeps track of logging output to screen and/or files. All printout from
49459 CasADi routines should go through this files.
49460 
49461 Joel Andersson
49462 
49463 C++ includes: casadi_logger.hpp ";
49464 
49465 
49466 // File: classcasadi_1_1Low.xml
49467 
49468 
49469 // File: classcasadi_1_1Lsqr.xml
49470 %feature("docstring")  casadi::LinsolInternal::row() const  "
49471 
49472 [INTERNAL] ";
49473 
49474 %feature("docstring")  casadi::Lsqr::nfact(void *mem, const double *A) const
49475 "
49476 
49477 [INTERNAL]  Numeric factorization.
49478 
49479 ";
49480 
49481 %feature("docstring")  casadi::LinsolInternal::sfact(void *mem, const double
49482 *A) const  "
49483 
49484 [INTERNAL] ";
49485 
49486 %feature("docstring")  casadi::Lsqr::generate(CodeGenerator &g, const
49487 std::string &A, const std::string &x, casadi_int nrhs, bool tr) const  "
49488 
49489 [INTERNAL]  Generate C code.
49490 
49491 ";
49492 
49493 %feature("docstring")  casadi::Lsqr::solve(void *mem, const double *A,
49494 double *x, casadi_int nrhs, bool tr) const  "
49495 
49496 [INTERNAL] ";
49497 
49498 %feature("docstring")  casadi::LinsolInternal::nnz() const  "
49499 
49500 [INTERNAL] ";
49501 
49502 %feature("docstring")  casadi::ProtoFunction::print(const char *fmt,...)
49503 const  "
49504 
49505 [INTERNAL]  C-style formatted printing during evaluation.
49506 
49507 ";
49508 
49509 %feature("docstring")  casadi::ProtoFunction::clear_mem() "
49510 
49511 [INTERNAL]  Clear all memory (called from destructor)
49512 
49513 ";
49514 
49515 %feature("docstring")  casadi::ProtoFunction::get_stats(void *mem) const  "
49516 
49517 [INTERNAL]  Get all statistics.
49518 
49519 ";
49520 
49521 %feature("docstring")  casadi::ProtoFunction::release(int mem) const  "
49522 
49523 [INTERNAL]  Release a memory object.
49524 
49525 ";
49526 
49527 %feature("docstring")  casadi::LinsolInternal::init(const Dict &opts)  "
49528 
49529 [INTERNAL]  Initialize.
49530 
49531 ";
49532 
49533 %feature("docstring")  casadi::LinsolInternal::neig(void *mem, const double
49534 *A) const  "
49535 
49536 [INTERNAL]  Number of negative eigenvalues.
49537 
49538 ";
49539 
49540 %feature("docstring")  casadi::ProtoFunction::format_time(char *buffer,
49541 double time) const  "
49542 
49543 [INTERNAL]  Format time in a fixed width 8 format.
49544 
49545 ";
49546 
49547 %feature("docstring")  casadi::ProtoFunction::serialize(SerializingStream
49548 &s) const  "
49549 
49550 [INTERNAL]  Serialize an object.
49551 
49552 ";
49553 
49554 %feature("docstring")  casadi::SharedObjectInternal::weak() "
49555 
49556 [INTERNAL]  Get a weak reference to the object.
49557 
49558 ";
49559 
49560 %feature("docstring")  casadi::LinsolInternal::colind() const  "
49561 
49562 [INTERNAL] ";
49563 
49564 %feature("docstring")  casadi::Lsqr::class_name() const  "
49565 
49566 [INTERNAL]  Readable name of the internal class.
49567 
49568 ";
49569 
49570 %feature("docstring")  casadi::ProtoFunction::serialize_base_function()
49571 const  "
49572 
49573 [INTERNAL]  String used to identify the immediate FunctionInternal subclass.
49574 
49575 ";
49576 
49577 %feature("docstring")  casadi::ProtoFunction::construct(const Dict &opts) "
49578 
49579 [INTERNAL]  Construct Prepares the function for evaluation.
49580 
49581 ";
49582 
49583 %feature("docstring")  casadi::ProtoFunction::print_time(const std::map<
49584 std::string, FStats > &fstats) const  "
49585 
49586 [INTERNAL]  Print timing statistics.
49587 
49588 ";
49589 
49590 %feature("docstring")  casadi::ProtoFunction::checkout() const  "
49591 
49592 [INTERNAL]  Checkout a memory object.
49593 
49594 ";
49595 
49596 %feature("docstring")  casadi::ProtoFunction::get_options() const  "
49597 
49598 [INTERNAL]  Options.
49599 
49600 ";
49601 
49602 %feature("docstring")  casadi::LinsolInternal::rank(void *mem, const double
49603 *A) const  "
49604 
49605 [INTERNAL]   Matrix rank.
49606 
49607 ";
49608 
49609 %feature("docstring")
49610 casadi::LinsolInternal::serialize_type(SerializingStream &s) const  "
49611 
49612 [INTERNAL]  Serialize type information.
49613 
49614 ";
49615 
49616 %feature("docstring") casadi::Lsqr::~Lsqr "
49617 
49618 [INTERNAL] ";
49619 
49620 %feature("docstring")  casadi::LinsolInternal::linsol_eval_sx(const SXElem
49621 **arg, SXElem **res, casadi_int *iw, SXElem *w, void *mem, bool tr,
49622 casadi_int nrhs) const  "
49623 
49624 [INTERNAL]  Evaluate SX, possibly transposed.
49625 
49626 ";
49627 
49628 %feature("docstring")  casadi::Lsqr::plugin_name() const  "
49629 
49630 [INTERNAL] ";
49631 
49632 %feature("docstring")  casadi::Lsqr::alloc_mem() const  "
49633 
49634 [INTERNAL]  Create memory block.
49635 
49636 ";
49637 
49638 %feature("docstring")  casadi::SharedObjectInternal::getCount() const  "
49639 
49640 [INTERNAL]  Get the reference count.
49641 
49642 ";
49643 
49644 %feature("docstring")  casadi::ProtoFunction::finalize() "
49645 
49646 [INTERNAL]  Finalize the object creation This function, which visits the
49647 class hierarchy in reverse order is run after init() has been completed.
49648 
49649 ";
49650 
49651 %feature("docstring")  casadi::LinsolInternal::disp(std::ostream &stream,
49652 bool more) const  "
49653 
49654 [INTERNAL]  Display object.
49655 
49656 ";
49657 
49658 %feature("docstring") casadi::Lsqr "
49659 
49660 [INTERNAL]  'symbolicqr' plugin for Linsol
49661 
49662 Linear solver for sparse least-squares problems Inspired
49663 fromhttps://github.com/scipy/scipy/blob/v0.14.0/scipy/sparse/linalg/isolve/lsqr.py#L96
49664 
49665 Linsol based on QR factorization with sparsity pattern based reordering
49666 without partial pivoting
49667 
49668 >List of available options
49669 
49670 +-------+---------+----------------------------------------------------+
49671 |  Id   |  Type   |                    Description                     |
49672 +=======+=========+====================================================+
49673 | fopts | OT_DICT | Options to be passed to generated function objects |
49674 +-------+---------+----------------------------------------------------+
49675 
49676 Joel Andersson
49677 
49678 C++ includes: lsqr.hpp ";
49679 
49680 %feature("docstring")  casadi::ProtoFunction::memory(int ind) const  "
49681 
49682 [INTERNAL]  Memory objects.
49683 
49684 ";
49685 
49686 %feature("docstring")  casadi::ProtoFunction::generate_options(bool
49687 is_temp=false) const  "
49688 
49689 [INTERNAL]  Reconstruct options dict.
49690 
49691 ";
49692 
49693 %feature("docstring")  casadi::Lsqr::init_mem(void *mem) const  "
49694 
49695 [INTERNAL]  Initalize memory block.
49696 
49697 ";
49698 
49699 %feature("docstring")  casadi::LinsolInternal::disp_more(std::ostream
49700 &stream) const  "
49701 
49702 [INTERNAL]  Print more.
49703 
49704 ";
49705 
49706 %feature("docstring")  casadi::ProtoFunction::sprint(char *buf, size_t
49707 buf_sz, const char *fmt,...) const  "
49708 
49709 [INTERNAL]  C-style formatted printing to string.
49710 
49711 ";
49712 
49713 %feature("docstring")
49714 casadi::LinsolInternal::serialize_body(SerializingStream &s) const  "
49715 
49716 [INTERNAL]  Serialize an object without type information.
49717 
49718 ";
49719 
49720 %feature("docstring")  casadi::LinsolInternal::nrow() const  "
49721 
49722 [INTERNAL]  Get sparsity pattern.
49723 
49724 ";
49725 
49726 %feature("docstring")  casadi::Lsqr::free_mem(void *mem) const  "
49727 
49728 [INTERNAL]  Free memory block.
49729 
49730 ";
49731 
49732 %feature("docstring") casadi::Lsqr::Lsqr(const std::string &name, const
49733 Sparsity &sp) "
49734 
49735 [INTERNAL] ";
49736 
49737 %feature("docstring")  casadi::LinsolInternal::ncol() const  "
49738 
49739 [INTERNAL] ";
49740 
49741 
49742 // File: classcasadi_1_1Map.xml
49743 %feature("docstring")  casadi::FunctionInternal::is_diff_out(casadi_int i) "
49744 
49745 [INTERNAL] ";
49746 
49747 %feature("docstring")  casadi::ProtoFunction::sprint(char *buf, size_t
49748 buf_sz, const char *fmt,...) const  "
49749 
49750 [INTERNAL]  C-style formatted printing to string.
49751 
49752 ";
49753 
49754 %feature("docstring")  casadi::FunctionInternal::fwdViaJac(casadi_int nfwd)
49755 const  "
49756 
49757 [INTERNAL]  Calculate derivatives by multiplying the full Jacobian and
49758 multiplying.
49759 
49760 ";
49761 
49762 %feature("docstring")  casadi::FunctionInternal::self() const  "
49763 
49764 [INTERNAL]  Get a public class instance.
49765 
49766 ";
49767 
49768 %feature("docstring")  casadi::Map::get_n_out()  "
49769 
49770 [INTERNAL]  Number of function inputs and outputs.
49771 
49772 ";
49773 
49774 %feature("docstring")  casadi::FunctionInternal::mapsum_mx(const
49775 std::vector< MX > &arg, const std::string &parallelization) "
49776 
49777 [INTERNAL]  Parallel evaluation.
49778 
49779 ";
49780 
49781 %feature("docstring")  casadi::FunctionInternal::jacobian() const  "
49782 
49783 [INTERNAL]  Return Jacobian of all input elements with respect to all output
49784 elements.
49785 
49786 ";
49787 
49788 %feature("docstring")  casadi::FunctionInternal::call(const std::vector< M >
49789 &arg, std::vector< M > &res, bool always_inline, bool never_inline) const  "
49790 
49791 [INTERNAL]   Call a function, templated.
49792 
49793 ";
49794 
49795 %feature("docstring")
49796 casadi::FunctionInternal::jacobian_sparsity_filter(const Sparsity &sp) const
49797 "
49798 
49799 [INTERNAL]  Filter out nonzeros in the full sparsity jacobian according to
49800 is_diff_in/out.
49801 
49802 ";
49803 
49804 %feature("docstring")
49805 casadi::FunctionInternal::instruction_constant(casadi_int k) const  "
49806 
49807 [INTERNAL]  Get the floating point output argument of an atomic operation.
49808 
49809 ";
49810 
49811 %feature("docstring")  casadi::FunctionInternal::size_in(casadi_int ind)
49812 const  "
49813 
49814 [INTERNAL]  Input/output dimensions.
49815 
49816 ";
49817 
49818 %feature("docstring")  casadi::FunctionInternal::codegen_mem(CodeGenerator
49819 &g, const std::string &index="mem") const  "
49820 
49821 [INTERNAL]  Get thread-local memory object.
49822 
49823 ";
49824 
49825 %feature("docstring")  casadi::Map::has_forward(casadi_int nfwd) const  "
49826 
49827 [INTERNAL]  Generate a function that calculates nfwd forward derivatives.
49828 
49829 ";
49830 
49831 %feature("docstring")  casadi::FunctionInternal::matching_res(const
49832 std::vector< M > &arg, casadi_int &npar) const  "
49833 
49834 [INTERNAL]  Check if output arguments that needs to be replaced.
49835 
49836 Raises errors
49837 
49838 Parameters:
49839 -----------
49840 
49841 npar[in]:  normal usage: 1, disallow pararallel calls: -1
49842 
49843 npar:  max number of horizontal repetitions across all arguments (or -1)
49844 
49845 ";
49846 
49847 %feature("docstring")  casadi::FunctionInternal::has_eval_dm() const  "
49848 
49849 [INTERNAL]  Evaluate with DM matrices.
49850 
49851 ";
49852 
49853 %feature("docstring")  casadi::Map::has_reverse(casadi_int nadj) const  "
49854 
49855 [INTERNAL]  Generate a function that calculates nadj adjoint derivatives.
49856 
49857 ";
49858 
49859 %feature("docstring")  casadi::ProtoFunction::free_mem(void *mem) const  "
49860 
49861 [INTERNAL]  Free memory block.
49862 
49863 ";
49864 
49865 %feature("docstring")  casadi::Map::eval(const double **arg, double **res,
49866 casadi_int *iw, double *w, void *mem) const  "
49867 
49868 [INTERNAL]  Evaluate the function numerically.
49869 
49870 ";
49871 
49872 %feature("docstring")  casadi::FunctionInternal::wrap_as_needed(const Dict
49873 &opts) const  "
49874 
49875 [INTERNAL]  Wrap in an Function instance consisting of only one MX call.
49876 
49877 ";
49878 
49879 %feature("docstring")  casadi::FunctionInternal::mx_out(casadi_int ind)
49880 const  "
49881 
49882 [INTERNAL]  Get function input(s) and output(s)
49883 
49884 ";
49885 
49886 %feature("docstring")  casadi::FunctionInternal::mx_out() const  "
49887 
49888 [INTERNAL]  Get function input(s) and output(s)
49889 
49890 ";
49891 
49892 %feature("docstring")  casadi::FunctionInternal::alloc_iw(size_t sz_iw, bool
49893 persistent=false) "
49894 
49895 [INTERNAL]  Ensure required length of iw field.
49896 
49897 ";
49898 
49899 %feature("docstring")  casadi::FunctionInternal::get_min_in(casadi_int ind)
49900 const  "
49901 
49902 [INTERNAL]  Get smallest input value.
49903 
49904 ";
49905 
49906 %feature("docstring")  casadi::FunctionInternal::get_jac(const std::string
49907 &name, const std::vector< std::string > &inames, const std::vector<
49908 std::string > &onames, const Dict &opts) const  "
49909 
49910 [INTERNAL]  Return Jacobian of all input elements with respect to all output
49911 elements.
49912 
49913 ";
49914 
49915 %feature("docstring")  casadi::SharedObjectInternal::getCount() const  "
49916 
49917 [INTERNAL]  Get the reference count.
49918 
49919 ";
49920 
49921 %feature("docstring")  casadi::FunctionInternal::disp(std::ostream &stream,
49922 bool more) const  "
49923 
49924 [INTERNAL]  Display object.
49925 
49926 ";
49927 
49928 %feature("docstring")  casadi::FunctionInternal::replace_res(const
49929 std::vector< M > &res, casadi_int npar) const  "
49930 
49931 [INTERNAL]  Replace 0-by-0 outputs.
49932 
49933 ";
49934 
49935 %feature("docstring")  casadi::FunctionInternal::oracle() const  "
49936 
49937 [INTERNAL]  Get oracle.
49938 
49939 ";
49940 
49941 %feature("docstring")  casadi::FunctionInternal::call_reverse(const
49942 std::vector< MX > &arg, const std::vector< MX > &res, const std::vector<
49943 std::vector< MX > > &aseed, std::vector< std::vector< MX > > &asens, bool
49944 always_inline, bool never_inline) const  "
49945 
49946 [INTERNAL]  Reverse mode, virtual functions overloaded in derived classes.
49947 
49948 ";
49949 
49950 %feature("docstring")  casadi::FunctionInternal::call_reverse(const
49951 std::vector< SX > &arg, const std::vector< SX > &res, const std::vector<
49952 std::vector< SX > > &aseed, std::vector< std::vector< SX > > &asens, bool
49953 always_inline, bool never_inline) const  "
49954 
49955 [INTERNAL]  Reverse mode, virtual functions overloaded in derived classes.
49956 
49957 ";
49958 
49959 %feature("docstring")  casadi::FunctionInternal::generate_in(const
49960 std::string &fname, const double **arg) const  "
49961 
49962 [INTERNAL]  Export an input file that can be passed to generate C code with
49963 a main.
49964 
49965 ";
49966 
49967 %feature("docstring") casadi::Map "
49968 
49969 [INTERNAL]  Evaluate in parallel Joel Andersson
49970 
49971 C++ includes: map.hpp ";
49972 
49973 %feature("docstring")  casadi::FunctionInternal::print_options(std::ostream
49974 &stream) const  "
49975 
49976 [INTERNAL]  Print list of options.
49977 
49978 ";
49979 
49980 %feature("docstring")  casadi::FunctionInternal::which_depends(const
49981 std::string &s_in, const std::vector< std::string > &s_out, casadi_int
49982 order, bool tr=false) const  "
49983 
49984 [INTERNAL]  Which variables enter with some order.
49985 
49986 Parameters:
49987 -----------
49988 
49989 s_in:   Input name
49990 
49991 s_out:   Output name(s)
49992 
49993 order:  Only 1 (linear) and 2 (nonlinear) allowed
49994 
49995 tr:  Flip the relationship. Return which expressions contain the variables
49996 
49997 ";
49998 
49999 %feature("docstring")  casadi::FunctionInternal::free_sx() const  "
50000 
50001 [INTERNAL]  Get free variables (SX)
50002 
50003 ";
50004 
50005 %feature("docstring")  casadi::FunctionInternal::sx_in(casadi_int ind) const
50006 "
50007 
50008 [INTERNAL]  Get function input(s) and output(s)
50009 
50010 ";
50011 
50012 %feature("docstring")  casadi::FunctionInternal::sx_in() const  "
50013 
50014 [INTERNAL]  Get function input(s) and output(s)
50015 
50016 ";
50017 
50018 %feature("docstring")  casadi::FunctionInternal::eval_mx(const MXVector
50019 &arg, MXVector &res, bool always_inline, bool never_inline) const  "
50020 
50021 [INTERNAL]  Evaluate with symbolic matrices.
50022 
50023 ";
50024 
50025 %feature("docstring")  casadi::FunctionInternal::slice(const std::string
50026 &name, const std::vector< casadi_int > &order_in, const std::vector<
50027 casadi_int > &order_out, const Dict &opts) const  "
50028 
50029 [INTERNAL]  returns a new function with a selection of inputs/outputs of the
50030 original
50031 
50032 ";
50033 
50034 %feature("docstring")  casadi::FunctionInternal::check_arg(const
50035 std::vector< M > &arg, casadi_int &npar) const  "
50036 
50037 [INTERNAL]  Check if input arguments have correct length and dimensions.
50038 
50039 Raises errors.
50040 
50041 Parameters:
50042 -----------
50043 
50044 npar[in]:  normal usage: 1, disallow pararallel calls: -1
50045 
50046 npar:  max number of horizontal repetitions across all arguments (or -1)
50047 
50048 ";
50049 
50050 %feature("docstring")  casadi::FunctionInternal::ad_weight() const  "
50051 
50052 [INTERNAL]  Weighting factor for chosing forward/reverse mode.
50053 
50054 ";
50055 
50056 %feature("docstring")  casadi::FunctionInternal::forward(casadi_int nfwd)
50057 const  "
50058 
50059 [INTERNAL]  Return function that calculates forward derivatives
50060 forward(nfwd) returns a cached instance if available, and calls  Function
50061 get_forward(casadi_int nfwd) if no cached version is available.
50062 
50063 ";
50064 
50065 %feature("docstring")  casadi::FunctionInternal::nz_in(const std::vector< DM
50066 > &arg) const  "
50067 
50068 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
50069 
50070 ";
50071 
50072 %feature("docstring")  casadi::FunctionInternal::nz_in(const std::vector<
50073 double > &arg) const  "
50074 
50075 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
50076 
50077 ";
50078 
50079 %feature("docstring")  casadi::ProtoFunction::format_time(char *buffer,
50080 double time) const  "
50081 
50082 [INTERNAL]  Format time in a fixed width 8 format.
50083 
50084 ";
50085 
50086 %feature("docstring")  casadi::FunctionInternal::codegen_meta(CodeGenerator
50087 &g) const  "
50088 
50089 [INTERNAL]  Generate meta-information allowing a user to evaluate a
50090 generated function.
50091 
50092 ";
50093 
50094 %feature("docstring")  casadi::FunctionInternal::sz_iw() const  "
50095 
50096 [INTERNAL]  Get required length of iw field.
50097 
50098 ";
50099 
50100 %feature("docstring")  casadi::FunctionInternal::size_out(casadi_int ind)
50101 const  "
50102 
50103 [INTERNAL]  Input/output dimensions.
50104 
50105 ";
50106 
50107 %feature("docstring")  casadi::FunctionInternal::factory(const std::string
50108 &name, const std::vector< std::string > &s_in, const std::vector<
50109 std::string > &s_out, const Function::AuxOut &aux, const Dict &opts) const
50110 "
50111 
50112 [INTERNAL] ";
50113 
50114 %feature("docstring")  casadi::Map::get_n_in()  "
50115 
50116 [INTERNAL]  Number of function inputs and outputs.
50117 
50118 ";
50119 
50120 %feature("docstring")  casadi::FunctionInternal::dm_in(casadi_int ind) const
50121 "
50122 
50123 [INTERNAL]  Get function input(s) and output(s)
50124 
50125 ";
50126 
50127 %feature("docstring")  casadi::FunctionInternal::dm_in() const  "
50128 
50129 [INTERNAL]  Get function input(s) and output(s)
50130 
50131 ";
50132 
50133 %feature("docstring")  casadi::FunctionInternal::eval_dm(const std::vector<
50134 DM > &arg) const  "
50135 
50136 [INTERNAL]  Evaluate with DM matrices.
50137 
50138 ";
50139 
50140 %feature("docstring")  casadi::Map::has_sprev() const  "
50141 
50142 [INTERNAL]  Is the class able to propagate seeds through the algorithm?
50143 
50144 ";
50145 
50146 %feature("docstring")  casadi::FunctionInternal::sp_weight() const  "
50147 
50148 [INTERNAL]  Weighting factor for chosing forward/reverse mode, sparsity
50149 propagation.
50150 
50151 ";
50152 
50153 %feature("docstring")  casadi::FunctionInternal::sz_work(size_t &sz_arg,
50154 size_t &sz_res, size_t &sz_iw, size_t &sz_w) const  "
50155 
50156 [INTERNAL]  Get number of temporary variables needed.
50157 
50158 ";
50159 
50160 %feature("docstring")
50161 casadi::FunctionInternal::print_dimensions(std::ostream &stream) const  "
50162 
50163 [INTERNAL]  Print dimensions of inputs and outputs.
50164 
50165 ";
50166 
50167 %feature("docstring")  casadi::FunctionInternal::get_max_in(casadi_int ind)
50168 const  "
50169 
50170 [INTERNAL]  Get largest input value.
50171 
50172 ";
50173 
50174 %feature("docstring")  casadi::FunctionInternal::jit_dependencies(const
50175 std::string &fname) "
50176 
50177 [INTERNAL]  Jit dependencies.
50178 
50179 ";
50180 
50181 %feature("docstring")  casadi::Map::sp_reverse(bvec_t **arg, bvec_t **res,
50182 casadi_int *iw, bvec_t *w, void *mem) const  "
50183 
50184 [INTERNAL]  Propagate sparsity backwards.
50185 
50186 ";
50187 
50188 %feature("docstring")  casadi::FunctionInternal::has_derivative() const  "
50189 
50190 [INTERNAL]  Can derivatives be calculated in any way?
50191 
50192 ";
50193 
50194 %feature("docstring")  casadi::FunctionInternal::get_abstol() const  "
50195 
50196 [INTERNAL]  Get absolute tolerance.
50197 
50198 ";
50199 
50200 %feature("docstring")  casadi::FunctionInternal::uses_output() const  "
50201 
50202 [INTERNAL]  Do the derivative functions need nondifferentiated outputs?
50203 
50204 ";
50205 
50206 %feature("docstring")  casadi::FunctionInternal::map(casadi_int n, const
50207 std::string &parallelization) const  "
50208 
50209 [INTERNAL]  Generate/retrieve cached serial map.
50210 
50211 ";
50212 
50213 %feature("docstring")  casadi::Map::codegen_body(CodeGenerator &g) const  "
50214 
50215 [INTERNAL]  Generate code for the body of the C function.
50216 
50217 ";
50218 
50219 %feature("docstring")  casadi::FunctionInternal::call_gen(const MXVector
50220 &arg, MXVector &res, casadi_int npar, bool always_inline, bool never_inline)
50221 const  "
50222 
50223 [INTERNAL]   Call a function, overloaded.
50224 
50225 ";
50226 
50227 %feature("docstring")  casadi::FunctionInternal::call_gen(const std::vector<
50228 MatrixCommon > &arg, std::vector< MatrixCommon > &res, casadi_int npar, bool
50229 always_inline, bool never_inline) const  "
50230 
50231 [INTERNAL]   Call a function, overloaded.
50232 
50233 ";
50234 
50235 %feature("docstring")  casadi::FunctionInternal::index_in(const std::string
50236 &name) const  "
50237 
50238 [INTERNAL]  Get input scheme index by name.
50239 
50240 ";
50241 
50242 %feature("docstring")  casadi::FunctionInternal::symbolicAdjSeed(casadi_int
50243 nadj, const std::vector< MatType > &v) const  "
50244 
50245 [INTERNAL]  Symbolic expressions for the adjoint seeds.
50246 
50247 ";
50248 
50249 %feature("docstring")  casadi::FunctionInternal::generate_lifted(Function
50250 &vdef_fcn, Function &vinit_fcn) const  "
50251 
50252 [INTERNAL]  Extract the functions needed for the Lifted Newton method.
50253 
50254 ";
50255 
50256 %feature("docstring")  casadi::FunctionInternal::definition() const  "
50257 
50258 [INTERNAL]  Get function signature: name:(inputs)->(outputs)
50259 
50260 ";
50261 
50262 %feature("docstring")  casadi::FunctionInternal::setup(void *mem, const
50263 double **arg, double **res, casadi_int *iw, double *w) const  "
50264 
50265 [INTERNAL]  Set the (persistent and temporary) work vectors.
50266 
50267 ";
50268 
50269 %feature("docstring")  casadi::FunctionInternal::nz_out(const std::vector<
50270 DM > &res) const  "
50271 
50272 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
50273 
50274 ";
50275 
50276 %feature("docstring")  casadi::FunctionInternal::nz_out(const std::vector<
50277 double > &res) const  "
50278 
50279 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
50280 
50281 ";
50282 
50283 %feature("docstring")  casadi::FunctionInternal::alloc_w(size_t sz_w, bool
50284 persistent=false) "
50285 
50286 [INTERNAL]  Ensure required length of w field.
50287 
50288 ";
50289 
50290 %feature("docstring")  casadi::FunctionInternal::sparsity_in(casadi_int ind)
50291 const  "
50292 
50293 [INTERNAL]  Input/output sparsity.
50294 
50295 ";
50296 
50297 %feature("docstring")  casadi::Map::class_name() const  "
50298 
50299 [INTERNAL]  Get type name.
50300 
50301 ";
50302 
50303 %feature("docstring")  casadi::FunctionInternal::is_diff_in(casadi_int i) "
50304 
50305 [INTERNAL] ";
50306 
50307 %feature("docstring")  casadi::ProtoFunction::checkout() const  "
50308 
50309 [INTERNAL]  Checkout a memory object.
50310 
50311 ";
50312 
50313 %feature("docstring")  casadi::ProtoFunction::get_stats(void *mem) const  "
50314 
50315 [INTERNAL]  Get all statistics.
50316 
50317 ";
50318 
50319 %feature("docstring")  casadi::FunctionInternal::replace_aseed(const
50320 std::vector< std::vector< M >> &aseed, casadi_int npar) const  "
50321 
50322 [INTERNAL]  Replace 0-by-0 reverse seeds.
50323 
50324 ";
50325 
50326 %feature("docstring")  casadi::FunctionInternal::replace_aseed(const
50327 std::vector< std::vector< M > > &aseed, casadi_int npar) const  "
50328 
50329 [INTERNAL] ";
50330 
50331 %feature("docstring")  casadi::FunctionInternal::has_jacobian_sparsity()
50332 const  "
50333 
50334 [INTERNAL]  Get Jacobian sparsity.
50335 
50336 ";
50337 
50338 %feature("docstring")  casadi::Map::get_default_in(casadi_int ind) const  "
50339 
50340 [INTERNAL]  Get default input value.
50341 
50342 ";
50343 
50344 %feature("docstring")  casadi::Map::eval_sx(const SXElem **arg, SXElem
50345 **res, casadi_int *iw, SXElem *w, void *mem) const  "
50346 
50347 [INTERNAL]  evaluate symbolically while also propagating directional
50348 derivatives
50349 
50350 ";
50351 
50352 %feature("docstring")  casadi::FunctionInternal::get_free() const  "
50353 
50354 [INTERNAL]  Print free variables.
50355 
50356 ";
50357 
50358 %feature("docstring")
50359 casadi::FunctionInternal::codegen_alloc_mem(CodeGenerator &g) const  "
50360 
50361 [INTERNAL]  Codegen decref for alloc_mem.
50362 
50363 ";
50364 
50365 %feature("docstring")  casadi::FunctionInternal::generate_dependencies(const
50366 std::string &fname, const Dict &opts) const  "
50367 
50368 [INTERNAL]  Export / Generate C code for the dependency function.
50369 
50370 ";
50371 
50372 %feature("docstring")  casadi::FunctionInternal::sz_w() const  "
50373 
50374 [INTERNAL]  Get required length of w field.
50375 
50376 ";
50377 
50378 %feature("docstring")  casadi::Map::get_name_out(casadi_int i)  "
50379 
50380 [INTERNAL]  Names of function input and outputs.
50381 
50382 ";
50383 
50384 %feature("docstring")  casadi::FunctionInternal::codegen_name(const
50385 CodeGenerator &g, bool ns=true) const  "
50386 
50387 [INTERNAL]  Get name in codegen.
50388 
50389 ";
50390 
50391 %feature("docstring")  casadi::FunctionInternal::getAdaptorSolverName()
50392 const  "
50393 
50394 [INTERNAL]  Obtain solver name from Adaptor.
50395 
50396 ";
50397 
50398 %feature("docstring")  casadi::FunctionInternal::fwd_seed(casadi_int nfwd)
50399 const  "
50400 
50401 [INTERNAL]  Symbolic expressions for the forward seeds.
50402 
50403 ";
50404 
50405 %feature("docstring")  casadi::FunctionInternal::signature(const std::string
50406 &fname) const  "
50407 
50408 [INTERNAL]  Code generate the function.
50409 
50410 ";
50411 
50412 %feature("docstring")  casadi::FunctionInternal::get_jacobian(const
50413 std::string &name, const std::vector< std::string > &inames, const
50414 std::vector< std::string > &onames, const Dict &opts) const  "
50415 
50416 [INTERNAL]  Return Jacobian of all input elements with respect to all output
50417 elements.
50418 
50419 ";
50420 
50421 %feature("docstring")  casadi::Map::init(const Dict &opts)  "
50422 
50423 [INTERNAL]  Initialize.
50424 
50425 ";
50426 
50427 %feature("docstring")
50428 casadi::FunctionInternal::codegen_init_mem(CodeGenerator &g) const  "
50429 
50430 [INTERNAL]  Codegen decref for init_mem.
50431 
50432 ";
50433 
50434 %feature("docstring")  casadi::FunctionInternal::size2_out(casadi_int ind)
50435 const  "
50436 
50437 [INTERNAL]  Input/output dimensions.
50438 
50439 ";
50440 
50441 %feature("docstring")  casadi::FunctionInternal::get_partition(casadi_int
50442 iind, casadi_int oind, Sparsity &D1, Sparsity &D2, bool compact, bool
50443 symmetric, bool allow_forward, bool allow_reverse) const  "
50444 
50445 [INTERNAL]  Get the unidirectional or bidirectional partition.
50446 
50447 ";
50448 
50449 %feature("docstring")
50450 casadi::FunctionInternal::codegen_decref(CodeGenerator &g) const  "
50451 
50452 [INTERNAL]  Codegen decref for dependencies.
50453 
50454 ";
50455 
50456 %feature("docstring")  casadi::FunctionInternal::incache(const std::string
50457 &fname, Function &f, const std::string &suffix="") const  "
50458 
50459 [INTERNAL]  Get function in cache.
50460 
50461 ";
50462 
50463 %feature("docstring")  casadi::FunctionInternal::convert_arg(const
50464 std::vector< M > &arg) const  "
50465 
50466 [INTERNAL]  Convert from/to input/output lists/map.
50467 
50468 ";
50469 
50470 %feature("docstring")  casadi::FunctionInternal::convert_arg(const std::map<
50471 std::string, M > &arg) const  "
50472 
50473 [INTERNAL]  Convert from/to input/output lists/map.
50474 
50475 ";
50476 
50477 %feature("docstring")  casadi::FunctionInternal::size1_out(casadi_int ind)
50478 const  "
50479 
50480 [INTERNAL]  Input/output dimensions.
50481 
50482 ";
50483 
50484 %feature("docstring")  casadi::FunctionInternal::get_reltol() const  "
50485 
50486 [INTERNAL]  Get relative tolerance.
50487 
50488 ";
50489 
50490 %feature("docstring")  casadi::FunctionInternal::sz_arg() const  "
50491 
50492 [INTERNAL]  Get required length of arg field.
50493 
50494 ";
50495 
50496 %feature("docstring")  casadi::FunctionInternal::get_options() const  "
50497 
50498 [INTERNAL]  Options.
50499 
50500 ";
50501 
50502 %feature("docstring")  casadi::Map::codegen_declarations(CodeGenerator &g)
50503 const  "
50504 
50505 [INTERNAL]  Generate code for the declarations of the C function.
50506 
50507 ";
50508 
50509 %feature("docstring")  casadi::FunctionInternal::check_mat(const Sparsity
50510 &arg, const Sparsity &inp, casadi_int &npar) "
50511 
50512 [INTERNAL]  Helper function
50513 
50514 Parameters:
50515 -----------
50516 
50517 npar[in]:  normal usage: 1, disallow pararallel calls: -1
50518 
50519 npar[out]:  required number of parallel calls (or -1)
50520 
50521 ";
50522 
50523 %feature("docstring")
50524 casadi::FunctionInternal::instruction_input(casadi_int k) const  "
50525 
50526 [INTERNAL]  Get the (integer) input arguments of an atomic operation.
50527 
50528 ";
50529 
50530 %feature("docstring")  casadi::Map::get_sparsity_in(casadi_int i)  "
50531 
50532 [INTERNAL]  Sparsities of function inputs and outputs.
50533 
50534 ";
50535 
50536 %feature("docstring")  casadi::FunctionInternal::call_forward(const
50537 std::vector< MX > &arg, const std::vector< MX > &res, const std::vector<
50538 std::vector< MX > > &fseed, std::vector< std::vector< MX > > &fsens, bool
50539 always_inline, bool never_inline) const  "
50540 
50541 [INTERNAL]  Forward mode AD, virtual functions overloaded in derived
50542 classes.
50543 
50544 ";
50545 
50546 %feature("docstring")  casadi::FunctionInternal::call_forward(const
50547 std::vector< SX > &arg, const std::vector< SX > &res, const std::vector<
50548 std::vector< SX > > &fseed, std::vector< std::vector< SX > > &fsens, bool
50549 always_inline, bool never_inline) const  "
50550 
50551 [INTERNAL]  Forward mode AD, virtual functions overloaded in derived
50552 classes.
50553 
50554 ";
50555 
50556 %feature("docstring")  casadi::Map::get_function() const  "
50557 
50558 [INTERNAL] ";
50559 
50560 %feature("docstring")  casadi::Map::get_function(const std::string &name)
50561 const  "
50562 
50563 [INTERNAL] ";
50564 
50565 %feature("docstring")  casadi::FunctionInternal::matching_arg(const
50566 std::vector< M > &arg, casadi_int &npar) const  "
50567 
50568 [INTERNAL]  Check if input arguments that needs to be replaced.
50569 
50570 Raises errors
50571 
50572 Parameters:
50573 -----------
50574 
50575 npar[in]:  normal usage: 1, disallow pararallel calls: -1
50576 
50577 npar:  max number of horizontal repetitions across all arguments (or -1)
50578 
50579 ";
50580 
50581 %feature("docstring")  casadi::ProtoFunction::init_mem(void *mem) const  "
50582 
50583 [INTERNAL]  Initalize memory block.
50584 
50585 ";
50586 
50587 %feature("docstring")  casadi::FunctionInternal::size2_in(casadi_int ind)
50588 const  "
50589 
50590 [INTERNAL]  Input/output dimensions.
50591 
50592 ";
50593 
50594 %feature("docstring")  casadi::Map::serialize_type(SerializingStream &s)
50595 const  "
50596 
50597 [INTERNAL]  Serialize type information.
50598 
50599 ";
50600 
50601 %feature("docstring")  casadi::FunctionInternal::has_jac() const  "
50602 
50603 [INTERNAL]  Return Jacobian of all input elements with respect to all output
50604 elements.
50605 
50606 ";
50607 
50608 %feature("docstring")  casadi::Map::parallelization() const  "
50609 
50610 [INTERNAL]  Type of parallellization.
50611 
50612 ";
50613 
50614 %feature("docstring")  casadi::FunctionInternal::mx_in(casadi_int ind) const
50615 "
50616 
50617 [INTERNAL]  Get function input(s) and output(s)
50618 
50619 ";
50620 
50621 %feature("docstring")  casadi::FunctionInternal::mx_in() const  "
50622 
50623 [INTERNAL]  Get function input(s) and output(s)
50624 
50625 ";
50626 
50627 %feature("docstring") casadi::Map::~Map "
50628 
50629 [INTERNAL]  Destructor.
50630 
50631 ";
50632 
50633 %feature("docstring")  casadi::FunctionInternal::numel_in() const  "
50634 
50635 [INTERNAL]  Number of input/output elements.
50636 
50637 ";
50638 
50639 %feature("docstring")  casadi::FunctionInternal::numel_in(casadi_int ind)
50640 const  "
50641 
50642 [INTERNAL]  Number of input/output elements.
50643 
50644 ";
50645 
50646 %feature("docstring")  casadi::FunctionInternal::jacobian_sparsity() const
50647 "
50648 
50649 [INTERNAL]  Get Jacobian sparsity.
50650 
50651 ";
50652 
50653 %feature("docstring")  casadi::FunctionInternal::project_res(const
50654 std::vector< M > &arg, casadi_int npar) const  "
50655 
50656 [INTERNAL]   Project sparsities.
50657 
50658 ";
50659 
50660 %feature("docstring")  casadi::ProtoFunction::alloc_mem() const  "
50661 
50662 [INTERNAL]  Create memory block.
50663 
50664 ";
50665 
50666 %feature("docstring")  casadi::FunctionInternal::disp_more(std::ostream
50667 &stream) const  "
50668 
50669 [INTERNAL]  Print more.
50670 
50671 ";
50672 
50673 %feature("docstring")  casadi::FunctionInternal::convert_res(const
50674 std::vector< M > &res) const  "
50675 
50676 [INTERNAL]  Convert from/to input/output lists/map.
50677 
50678 ";
50679 
50680 %feature("docstring")  casadi::FunctionInternal::convert_res(const std::map<
50681 std::string, M > &res) const  "
50682 
50683 [INTERNAL]  Convert from/to input/output lists/map.
50684 
50685 ";
50686 
50687 %feature("docstring")  casadi::Map::has_spfwd() const  "
50688 
50689 [INTERNAL]  Is the class able to propagate seeds through the algorithm?
50690 
50691 ";
50692 
50693 %feature("docstring")  casadi::FunctionInternal::sparsity_out(casadi_int
50694 ind) const  "
50695 
50696 [INTERNAL]  Input/output sparsity.
50697 
50698 ";
50699 
50700 %feature("docstring")  casadi::FunctionInternal::sparsity_jac(casadi_int
50701 iind, casadi_int oind, bool compact, bool symmetric) const  "
50702 
50703 [INTERNAL]  Get, if necessary generate, the sparsity of a Jacobian block.
50704 
50705 ";
50706 
50707 %feature("docstring")  casadi::FunctionInternal::getJacSparsity(casadi_int
50708 iind, casadi_int oind, bool symmetric) const  "
50709 
50710 [INTERNAL]  Generate the sparsity of a Jacobian block.
50711 
50712 ";
50713 
50714 %feature("docstring")  casadi::FunctionInternal::sx_out(casadi_int ind)
50715 const  "
50716 
50717 [INTERNAL]  Get function input(s) and output(s)
50718 
50719 ";
50720 
50721 %feature("docstring")  casadi::FunctionInternal::sx_out() const  "
50722 
50723 [INTERNAL]  Get function input(s) and output(s)
50724 
50725 ";
50726 
50727 %feature("docstring")  casadi::FunctionInternal::wrap() const  "
50728 
50729 [INTERNAL]  Wrap in an Function instance consisting of only one MX call.
50730 
50731 ";
50732 
50733 %feature("docstring")  casadi::FunctionInternal::alloc(const Function &f,
50734 bool persistent=false) "
50735 
50736 [INTERNAL]  Ensure work vectors long enough to evaluate function.
50737 
50738 ";
50739 
50740 %feature("docstring")  casadi::ProtoFunction::clear_mem() "
50741 
50742 [INTERNAL]  Clear all memory (called from destructor)
50743 
50744 ";
50745 
50746 %feature("docstring")  casadi::Map::has_codegen() const  "
50747 
50748 [INTERNAL]  Is codegen supported?
50749 
50750 ";
50751 
50752 %feature("docstring")  casadi::FunctionInternal::n_nodes() const  "
50753 
50754 [INTERNAL]  Number of nodes in the algorithm.
50755 
50756 ";
50757 
50758 %feature("docstring")  casadi::Map::get_reverse(casadi_int nadj, const
50759 std::string &name, const std::vector< std::string > &inames, const
50760 std::vector< std::string > &onames, const Dict &opts) const  "
50761 
50762 [INTERNAL]  Generate a function that calculates nadj adjoint derivatives.
50763 
50764 ";
50765 
50766 %feature("docstring")  casadi::FunctionInternal::replace_arg(const
50767 std::vector< M > &arg, casadi_int npar) const  "
50768 
50769 [INTERNAL]  Replace 0-by-0 inputs.
50770 
50771 ";
50772 
50773 %feature("docstring")  casadi::Map::get_sparsity_out(casadi_int i)  "
50774 
50775 [INTERNAL]  Sparsities of function inputs and outputs.
50776 
50777 ";
50778 
50779 %feature("docstring")  casadi::FunctionInternal::index_out(const std::string
50780 &name) const  "
50781 
50782 [INTERNAL]  Get output scheme index by name.
50783 
50784 ";
50785 
50786 %feature("docstring")  casadi::FunctionInternal::instruction_MX(casadi_int
50787 k) const  "
50788 
50789 [INTERNAL]  get MX expression associated with instruction
50790 
50791 ";
50792 
50793 %feature("docstring")  casadi::FunctionInternal::has_jacobian() const  "
50794 
50795 [INTERNAL]  Return Jacobian of all input elements with respect to all output
50796 elements.
50797 
50798 ";
50799 
50800 %feature("docstring")  casadi::FunctionInternal::all_scalar() const  "
50801 
50802 [INTERNAL]  Are all inputs and outputs scalar.
50803 
50804 ";
50805 
50806 %feature("docstring")  casadi::FunctionInternal::alloc_arg(size_t sz_arg,
50807 bool persistent=false) "
50808 
50809 [INTERNAL]  Ensure required length of arg field.
50810 
50811 ";
50812 
50813 %feature("docstring")  casadi::FunctionInternal::codegen_mem_type() const  "
50814 
50815 [INTERNAL]  Thread-local memory object type.
50816 
50817 ";
50818 
50819 %feature("docstring")  casadi::FunctionInternal::finalize()  "
50820 
50821 [INTERNAL]  Finalize the object creation.
50822 
50823 ";
50824 
50825 %feature("docstring")
50826 casadi::FunctionInternal::codegen_sparsities(CodeGenerator &g) const  "
50827 
50828 [INTERNAL]  Codegen sparsities.
50829 
50830 ";
50831 
50832 %feature("docstring")  casadi::FunctionInternal::size1_in(casadi_int ind)
50833 const  "
50834 
50835 [INTERNAL]  Input/output dimensions.
50836 
50837 ";
50838 
50839 %feature("docstring")  casadi::FunctionInternal::alloc_res(size_t sz_res,
50840 bool persistent=false) "
50841 
50842 [INTERNAL]  Ensure required length of res field.
50843 
50844 ";
50845 
50846 %feature("docstring")
50847 casadi::FunctionInternal::getJacSparsityHierarchical(casadi_int iind,
50848 casadi_int oind) const  "
50849 
50850 [INTERNAL]  A flavor of getJacSparsity that does hierarchical block
50851 structure recognition.
50852 
50853 ";
50854 
50855 %feature("docstring")  casadi::FunctionInternal::symbolic_output(const
50856 std::vector< MX > &arg) const  "
50857 
50858 [INTERNAL]  Get a vector of symbolic variables corresponding to the outputs.
50859 
50860 ";
50861 
50862 %feature("docstring")  casadi::ProtoFunction::memory(int ind) const  "
50863 
50864 [INTERNAL]  Memory objects.
50865 
50866 ";
50867 
50868 %feature("docstring")  casadi::FunctionInternal::reverse(casadi_int nadj)
50869 const  "
50870 
50871 [INTERNAL]  Return function that calculates adjoint derivatives
50872 reverse(nadj) returns a cached instance if available, and calls  Function
50873 get_reverse(casadi_int nadj) if no cached version is available.
50874 
50875 ";
50876 
50877 %feature("docstring")  casadi::FunctionInternal::get_jacobian_sparsity()
50878 const  "
50879 
50880 [INTERNAL]  Get Jacobian sparsity.
50881 
50882 ";
50883 
50884 %feature("docstring")  casadi::FunctionInternal::instructions_sx() const  "
50885 
50886 [INTERNAL]  get SX expression associated with instructions
50887 
50888 ";
50889 
50890 %feature("docstring")  casadi::FunctionInternal::export_code(const
50891 std::string &lang, std::ostream &stream, const Dict &options) const  "
50892 
50893 [INTERNAL]  Export function in a specific language.
50894 
50895 ";
50896 
50897 %feature("docstring")  casadi::FunctionInternal::n_instructions() const  "
50898 
50899 [INTERNAL]  Get the number of atomic operations.
50900 
50901 ";
50902 
50903 %feature("docstring")  casadi::SharedObjectInternal::weak() "
50904 
50905 [INTERNAL]  Get a weak reference to the object.
50906 
50907 ";
50908 
50909 %feature("docstring")  casadi::FunctionInternal::nnz_in() const  "
50910 
50911 [INTERNAL]  Number of input/output nonzeros.
50912 
50913 ";
50914 
50915 %feature("docstring")  casadi::FunctionInternal::nnz_in(casadi_int ind)
50916 const  "
50917 
50918 [INTERNAL]  Number of input/output nonzeros.
50919 
50920 ";
50921 
50922 %feature("docstring")  casadi::FunctionInternal::check_res(const
50923 std::vector< M > &res, casadi_int &npar) const  "
50924 
50925 [INTERNAL]  Check if output arguments have correct length and dimensions.
50926 
50927 Raises errors.
50928 
50929 Parameters:
50930 -----------
50931 
50932 npar[in]:  normal usage: 1, disallow pararallel calls: -1
50933 
50934 npar:  max number of horizontal repetitions across all arguments (or -1)
50935 
50936 ";
50937 
50938 %feature("docstring")  casadi::Map::get_name_in(casadi_int i)  "
50939 
50940 [INTERNAL]  Names of function input and outputs.
50941 
50942 ";
50943 
50944 %feature("docstring")  casadi::FunctionInternal::sz_res() const  "
50945 
50946 [INTERNAL]  Get required length of res field.
50947 
50948 ";
50949 
50950 %feature("docstring")  casadi::FunctionInternal::eval_gen(const double
50951 **arg, double **res, casadi_int *iw, double *w, void *mem) const  "
50952 
50953 [INTERNAL]  Evaluate numerically.
50954 
50955 ";
50956 
50957 %feature("docstring")  casadi::FunctionInternal::eval_gen(const SXElem
50958 **arg, SXElem **res, casadi_int *iw, SXElem *w, void *mem) const  "
50959 
50960 [INTERNAL]  Evaluate a function, overloaded.
50961 
50962 ";
50963 
50964 %feature("docstring")  casadi::FunctionInternal::eval_gen(const bvec_t
50965 **arg, bvec_t **res, casadi_int *iw, bvec_t *w, void *mem) const  "
50966 
50967 [INTERNAL]  Evaluate a function, overloaded.
50968 
50969 ";
50970 
50971 %feature("docstring")  casadi::Map::eval_gen(const T **arg, T **res,
50972 casadi_int *iw, T *w, int mem=0) const  "
50973 
50974 [INTERNAL]  Evaluate or propagate sparsities.
50975 
50976 ";
50977 
50978 %feature("docstring")  casadi::FunctionInternal::adjViaJac(casadi_int nadj)
50979 const  "
50980 
50981 [INTERNAL]  Calculate derivatives by multiplying the full Jacobian and
50982 multiplying.
50983 
50984 ";
50985 
50986 %feature("docstring")  casadi::FunctionInternal::instruction_id(casadi_int
50987 k) const  "
50988 
50989 [INTERNAL]  Get an atomic operation operator index.
50990 
50991 ";
50992 
50993 %feature("docstring")  casadi::FunctionInternal::nnz_out() const  "
50994 
50995 [INTERNAL]  Number of input/output nonzeros.
50996 
50997 ";
50998 
50999 %feature("docstring")  casadi::FunctionInternal::nnz_out(casadi_int ind)
51000 const  "
51001 
51002 [INTERNAL]  Number of input/output nonzeros.
51003 
51004 ";
51005 
51006 %feature("docstring")  casadi::FunctionInternal::set_temp(void *mem, const
51007 double **arg, double **res, casadi_int *iw, double *w) const  "
51008 
51009 [INTERNAL]  Set the (temporary) work vectors.
51010 
51011 ";
51012 
51013 %feature("docstring")  casadi::Map::serialize_body(SerializingStream &s)
51014 const  "
51015 
51016 [INTERNAL]  Serialize an object without type information.
51017 
51018 ";
51019 
51020 %feature("docstring")
51021 casadi::FunctionInternal::getJacSparsityHierarchicalSymm(casadi_int iind,
51022 casadi_int oind) const  "
51023 
51024 [INTERNAL]  A flavor of getJacSparsity that does hierarchical block
51025 structure recognition for symmetric Jacobians
51026 
51027 ";
51028 
51029 %feature("docstring")  casadi::Map::sp_forward(const bvec_t **arg, bvec_t
51030 **res, casadi_int *iw, bvec_t *w, void *mem) const  "
51031 
51032 [INTERNAL]  Propagate sparsity forward.
51033 
51034 ";
51035 
51036 %feature("docstring")  casadi::Map::get_forward(casadi_int nfwd, const
51037 std::string &name, const std::vector< std::string > &inames, const
51038 std::vector< std::string > &onames, const Dict &opts) const  "
51039 
51040 [INTERNAL]  Generate a function that calculates nfwd forward derivatives.
51041 
51042 ";
51043 
51044 %feature("docstring")
51045 casadi::FunctionInternal::codegen_free_mem(CodeGenerator &g) const  "
51046 
51047 [INTERNAL]  Codegen for free_mem.
51048 
51049 ";
51050 
51051 %feature("docstring")  casadi::FunctionInternal::project_arg(const
51052 std::vector< M > &arg, casadi_int npar) const  "
51053 
51054 [INTERNAL]   Project sparsities.
51055 
51056 ";
51057 
51058 %feature("docstring")  casadi::ProtoFunction::print_time(const std::map<
51059 std::string, FStats > &fstats) const  "
51060 
51061 [INTERNAL]  Print timing statistics.
51062 
51063 ";
51064 
51065 %feature("docstring")  casadi::Map::is_a(const std::string &type, bool
51066 recursive) const  "
51067 
51068 [INTERNAL]  Check if the function is of a particular type.
51069 
51070 ";
51071 
51072 %feature("docstring")  casadi::FunctionInternal::tocache(const Function &f,
51073 const std::string &suffix="") const  "
51074 
51075 [INTERNAL]  Save function to cache.
51076 
51077 ";
51078 
51079 %feature("docstring")  casadi::Map::info() const  "
51080 
51081 [INTERNAL]  Obtain information about node
51082 
51083 ";
51084 
51085 %feature("docstring")  casadi::FunctionInternal::replace_fseed(const
51086 std::vector< std::vector< M >> &fseed, casadi_int npar) const  "
51087 
51088 [INTERNAL]  Replace 0-by-0 forward seeds.
51089 
51090 ";
51091 
51092 %feature("docstring")  casadi::FunctionInternal::replace_fseed(const
51093 std::vector< std::vector< M > > &fseed, casadi_int npar) const  "
51094 
51095 [INTERNAL] ";
51096 
51097 %feature("docstring")
51098 casadi::FunctionInternal::instruction_output(casadi_int k) const  "
51099 
51100 [INTERNAL]  Get the (integer) output argument of an atomic operation.
51101 
51102 ";
51103 
51104 %feature("docstring")  casadi::FunctionInternal::numel_out(casadi_int ind)
51105 const  "
51106 
51107 [INTERNAL]  Number of input/output elements.
51108 
51109 ";
51110 
51111 %feature("docstring")  casadi::FunctionInternal::numel_out() const  "
51112 
51113 [INTERNAL]  Number of input/output elements.
51114 
51115 ";
51116 
51117 %feature("docstring")  casadi::FunctionInternal::free_mx() const  "
51118 
51119 [INTERNAL]  Get free variables ( MX)
51120 
51121 ";
51122 
51123 %feature("docstring")
51124 casadi::FunctionInternal::getJacSparsityGen(casadi_int iind, casadi_int
51125 oind, bool symmetric, casadi_int gr_i=1, casadi_int gr_o=1) const  "
51126 
51127 [INTERNAL]  Get the sparsity pattern, forward mode.
51128 
51129 ";
51130 
51131 %feature("docstring")
51132 casadi::FunctionInternal::codegen_incref(CodeGenerator &g) const  "
51133 
51134 [INTERNAL]  Codegen incref for dependencies.
51135 
51136 ";
51137 
51138 %feature("docstring")  casadi::FunctionInternal::has_free() const  "
51139 
51140 [INTERNAL]  Does the function have free variables.
51141 
51142 ";
51143 
51144 %feature("docstring")  casadi::FunctionInternal::generate_out(const
51145 std::string &fname, double **res) const  "
51146 
51147 [INTERNAL] ";
51148 
51149 %feature("docstring")  casadi::Map::serialize_base_function() const  "
51150 
51151 [INTERNAL]  String used to identify the immediate FunctionInternal subclass.
51152 
51153 ";
51154 
51155 %feature("docstring")  casadi::Map::has_function(const std::string &fname)
51156 const  "
51157 
51158 [INTERNAL] ";
51159 
51160 %feature("docstring")  casadi::FunctionInternal::dm_out(casadi_int ind)
51161 const  "
51162 
51163 [INTERNAL]  Get function input(s) and output(s)
51164 
51165 ";
51166 
51167 %feature("docstring")  casadi::FunctionInternal::dm_out() const  "
51168 
51169 [INTERNAL]  Get function input(s) and output(s)
51170 
51171 ";
51172 
51173 %feature("docstring")  casadi::ProtoFunction::serialize(SerializingStream
51174 &s) const  "
51175 
51176 [INTERNAL]  Serialize an object.
51177 
51178 ";
51179 
51180 %feature("docstring")  casadi::FunctionInternal::codegen(CodeGenerator &g,
51181 const std::string &fname) const  "
51182 
51183 [INTERNAL]  Generate code the function.
51184 
51185 ";
51186 
51187 %feature("docstring")  casadi::ProtoFunction::release(int mem) const  "
51188 
51189 [INTERNAL]  Release a memory object.
51190 
51191 ";
51192 
51193 %feature("docstring")  casadi::FunctionInternal::set_work(void *mem, const
51194 double **&arg, double **&res, casadi_int *&iw, double *&w) const  "
51195 
51196 [INTERNAL]  Set the (persistent) work vectors.
51197 
51198 ";
51199 
51200 %feature("docstring")  casadi::ProtoFunction::construct(const Dict &opts) "
51201 
51202 [INTERNAL]  Construct Prepares the function for evaluation.
51203 
51204 ";
51205 
51206 %feature("docstring")  casadi::FunctionInternal::jac() const  "
51207 
51208 [INTERNAL]  Return Jacobian of all input elements with respect to all output
51209 elements.
51210 
51211 ";
51212 
51213 %feature("docstring")  casadi::FunctionInternal::generate_options(bool
51214 is_temp=false) const  "
51215 
51216 [INTERNAL]  Reconstruct options dict.
51217 
51218 ";
51219 
51220 %feature("docstring")  casadi::FunctionInternal::print_option(const
51221 std::string &name, std::ostream &stream) const  "
51222 
51223 [INTERNAL]  Print all information there is to know about a certain option.
51224 
51225 ";
51226 
51227 %feature("docstring")  casadi::ProtoFunction::print(const char *fmt,...)
51228 const  "
51229 
51230 [INTERNAL]  C-style formatted printing during evaluation.
51231 
51232 ";
51233 
51234 
51235 // File: classcasadi_1_1MapSum.xml
51236 %feature("docstring")  casadi::FunctionInternal::has_derivative() const  "
51237 
51238 [INTERNAL]  Can derivatives be calculated in any way?
51239 
51240 ";
51241 
51242 %feature("docstring")  casadi::MapSum::serialize_base_function() const  "
51243 
51244 [INTERNAL]  String used to identify the immediate FunctionInternal subclass.
51245 
51246 ";
51247 
51248 %feature("docstring")  casadi::MapSum::has_sprev() const  "
51249 
51250 [INTERNAL]  Is the class able to propagate seeds through the algorithm?
51251 
51252 ";
51253 
51254 %feature("docstring")  casadi::FunctionInternal::set_work(void *mem, const
51255 double **&arg, double **&res, casadi_int *&iw, double *&w) const  "
51256 
51257 [INTERNAL]  Set the (persistent) work vectors.
51258 
51259 ";
51260 
51261 %feature("docstring")  casadi::FunctionInternal::map(casadi_int n, const
51262 std::string &parallelization) const  "
51263 
51264 [INTERNAL]  Generate/retrieve cached serial map.
51265 
51266 ";
51267 
51268 %feature("docstring")  casadi::FunctionInternal::free_sx() const  "
51269 
51270 [INTERNAL]  Get free variables (SX)
51271 
51272 ";
51273 
51274 %feature("docstring")  casadi::MapSum::get_reverse(casadi_int nadj, const
51275 std::string &name, const std::vector< std::string > &inames, const
51276 std::vector< std::string > &onames, const Dict &opts) const  "
51277 
51278 [INTERNAL]  Generate a function that calculates nadj adjoint derivatives.
51279 
51280 ";
51281 
51282 %feature("docstring")  casadi::FunctionInternal::sz_res() const  "
51283 
51284 [INTERNAL]  Get required length of res field.
51285 
51286 ";
51287 
51288 %feature("docstring")  casadi::FunctionInternal::print_options(std::ostream
51289 &stream) const  "
51290 
51291 [INTERNAL]  Print list of options.
51292 
51293 ";
51294 
51295 %feature("docstring")  casadi::ProtoFunction::checkout() const  "
51296 
51297 [INTERNAL]  Checkout a memory object.
51298 
51299 ";
51300 
51301 %feature("docstring")  casadi::FunctionInternal::all_scalar() const  "
51302 
51303 [INTERNAL]  Are all inputs and outputs scalar.
51304 
51305 ";
51306 
51307 %feature("docstring")  casadi::FunctionInternal::sz_w() const  "
51308 
51309 [INTERNAL]  Get required length of w field.
51310 
51311 ";
51312 
51313 %feature("docstring")  casadi::FunctionInternal::get_abstol() const  "
51314 
51315 [INTERNAL]  Get absolute tolerance.
51316 
51317 ";
51318 
51319 %feature("docstring")  casadi::MapSum::parallelization() const  "
51320 
51321 [INTERNAL]  Type of parallellization.
51322 
51323 ";
51324 
51325 %feature("docstring")  casadi::FunctionInternal::which_depends(const
51326 std::string &s_in, const std::vector< std::string > &s_out, casadi_int
51327 order, bool tr=false) const  "
51328 
51329 [INTERNAL]  Which variables enter with some order.
51330 
51331 Parameters:
51332 -----------
51333 
51334 s_in:   Input name
51335 
51336 s_out:   Output name(s)
51337 
51338 order:  Only 1 (linear) and 2 (nonlinear) allowed
51339 
51340 tr:  Flip the relationship. Return which expressions contain the variables
51341 
51342 ";
51343 
51344 %feature("docstring")  casadi::FunctionInternal::size2_out(casadi_int ind)
51345 const  "
51346 
51347 [INTERNAL]  Input/output dimensions.
51348 
51349 ";
51350 
51351 %feature("docstring")  casadi::FunctionInternal::eval_mx(const MXVector
51352 &arg, MXVector &res, bool always_inline, bool never_inline) const  "
51353 
51354 [INTERNAL]  Evaluate with symbolic matrices.
51355 
51356 ";
51357 
51358 %feature("docstring")  casadi::FunctionInternal::matching_arg(const
51359 std::vector< M > &arg, casadi_int &npar) const  "
51360 
51361 [INTERNAL]  Check if input arguments that needs to be replaced.
51362 
51363 Raises errors
51364 
51365 Parameters:
51366 -----------
51367 
51368 npar[in]:  normal usage: 1, disallow pararallel calls: -1
51369 
51370 npar:  max number of horizontal repetitions across all arguments (or -1)
51371 
51372 ";
51373 
51374 %feature("docstring")  casadi::FunctionInternal::replace_arg(const
51375 std::vector< M > &arg, casadi_int npar) const  "
51376 
51377 [INTERNAL]  Replace 0-by-0 inputs.
51378 
51379 ";
51380 
51381 %feature("docstring")  casadi::FunctionInternal::getJacSparsity(casadi_int
51382 iind, casadi_int oind, bool symmetric) const  "
51383 
51384 [INTERNAL]  Generate the sparsity of a Jacobian block.
51385 
51386 ";
51387 
51388 %feature("docstring")  casadi::FunctionInternal::call_reverse(const
51389 std::vector< MX > &arg, const std::vector< MX > &res, const std::vector<
51390 std::vector< MX > > &aseed, std::vector< std::vector< MX > > &asens, bool
51391 always_inline, bool never_inline) const  "
51392 
51393 [INTERNAL]  Reverse mode, virtual functions overloaded in derived classes.
51394 
51395 ";
51396 
51397 %feature("docstring")  casadi::FunctionInternal::call_reverse(const
51398 std::vector< SX > &arg, const std::vector< SX > &res, const std::vector<
51399 std::vector< SX > > &aseed, std::vector< std::vector< SX > > &asens, bool
51400 always_inline, bool never_inline) const  "
51401 
51402 [INTERNAL]  Reverse mode, virtual functions overloaded in derived classes.
51403 
51404 ";
51405 
51406 %feature("docstring")  casadi::ProtoFunction::print_time(const std::map<
51407 std::string, FStats > &fstats) const  "
51408 
51409 [INTERNAL]  Print timing statistics.
51410 
51411 ";
51412 
51413 %feature("docstring")  casadi::FunctionInternal::size_out(casadi_int ind)
51414 const  "
51415 
51416 [INTERNAL]  Input/output dimensions.
51417 
51418 ";
51419 
51420 %feature("docstring")  casadi::FunctionInternal::alloc_arg(size_t sz_arg,
51421 bool persistent=false) "
51422 
51423 [INTERNAL]  Ensure required length of arg field.
51424 
51425 ";
51426 
51427 %feature("docstring")  casadi::FunctionInternal::get_max_in(casadi_int ind)
51428 const  "
51429 
51430 [INTERNAL]  Get largest input value.
51431 
51432 ";
51433 
51434 %feature("docstring")  casadi::FunctionInternal::convert_arg(const
51435 std::vector< M > &arg) const  "
51436 
51437 [INTERNAL]  Convert from/to input/output lists/map.
51438 
51439 ";
51440 
51441 %feature("docstring")  casadi::FunctionInternal::convert_arg(const std::map<
51442 std::string, M > &arg) const  "
51443 
51444 [INTERNAL]  Convert from/to input/output lists/map.
51445 
51446 ";
51447 
51448 %feature("docstring")  casadi::FunctionInternal::has_free() const  "
51449 
51450 [INTERNAL]  Does the function have free variables.
51451 
51452 ";
51453 
51454 %feature("docstring")
51455 casadi::FunctionInternal::codegen_incref(CodeGenerator &g) const  "
51456 
51457 [INTERNAL]  Codegen incref for dependencies.
51458 
51459 ";
51460 
51461 %feature("docstring")  casadi::MapSum::has_reverse(casadi_int nadj) const  "
51462 
51463 [INTERNAL]  Generate a function that calculates nadj adjoint derivatives.
51464 
51465 ";
51466 
51467 %feature("docstring")  casadi::FunctionInternal::symbolic_output(const
51468 std::vector< MX > &arg) const  "
51469 
51470 [INTERNAL]  Get a vector of symbolic variables corresponding to the outputs.
51471 
51472 ";
51473 
51474 %feature("docstring")  casadi::FunctionInternal::codegen_meta(CodeGenerator
51475 &g) const  "
51476 
51477 [INTERNAL]  Generate meta-information allowing a user to evaluate a
51478 generated function.
51479 
51480 ";
51481 
51482 %feature("docstring")  casadi::MapSum::class_name() const  "
51483 
51484 [INTERNAL]  Get type name.
51485 
51486 ";
51487 
51488 %feature("docstring")  casadi::FunctionInternal::disp_more(std::ostream
51489 &stream) const  "
51490 
51491 [INTERNAL]  Print more.
51492 
51493 ";
51494 
51495 %feature("docstring")  casadi::MapSum::eval_sx(const SXElem **arg, SXElem
51496 **res, casadi_int *iw, SXElem *w, void *mem) const  "
51497 
51498 [INTERNAL]  evaluate symbolically while also propagating directional
51499 derivatives
51500 
51501 ";
51502 
51503 %feature("docstring")  casadi::FunctionInternal::matching_res(const
51504 std::vector< M > &arg, casadi_int &npar) const  "
51505 
51506 [INTERNAL]  Check if output arguments that needs to be replaced.
51507 
51508 Raises errors
51509 
51510 Parameters:
51511 -----------
51512 
51513 npar[in]:  normal usage: 1, disallow pararallel calls: -1
51514 
51515 npar:  max number of horizontal repetitions across all arguments (or -1)
51516 
51517 ";
51518 
51519 %feature("docstring")  casadi::FunctionInternal::sparsity_out(casadi_int
51520 ind) const  "
51521 
51522 [INTERNAL]  Input/output sparsity.
51523 
51524 ";
51525 
51526 %feature("docstring")  casadi::FunctionInternal::is_diff_in(casadi_int i) "
51527 
51528 [INTERNAL] ";
51529 
51530 %feature("docstring")  casadi::FunctionInternal::eval_gen(const double
51531 **arg, double **res, casadi_int *iw, double *w, void *mem) const  "
51532 
51533 [INTERNAL]  Evaluate numerically.
51534 
51535 ";
51536 
51537 %feature("docstring")  casadi::FunctionInternal::eval_gen(const SXElem
51538 **arg, SXElem **res, casadi_int *iw, SXElem *w, void *mem) const  "
51539 
51540 [INTERNAL]  Evaluate a function, overloaded.
51541 
51542 ";
51543 
51544 %feature("docstring")  casadi::FunctionInternal::eval_gen(const bvec_t
51545 **arg, bvec_t **res, casadi_int *iw, bvec_t *w, void *mem) const  "
51546 
51547 [INTERNAL]  Evaluate a function, overloaded.
51548 
51549 ";
51550 
51551 %feature("docstring")  casadi::MapSum::eval_gen(const T **arg, T **res,
51552 casadi_int *iw, T *w, int mem=0) const  "
51553 
51554 [INTERNAL]  Evaluate or propagate sparsities.
51555 
51556 ";
51557 
51558 %feature("docstring")  casadi::FunctionInternal::check_mat(const Sparsity
51559 &arg, const Sparsity &inp, casadi_int &npar) "
51560 
51561 [INTERNAL]  Helper function
51562 
51563 Parameters:
51564 -----------
51565 
51566 npar[in]:  normal usage: 1, disallow pararallel calls: -1
51567 
51568 npar[out]:  required number of parallel calls (or -1)
51569 
51570 ";
51571 
51572 %feature("docstring")  casadi::FunctionInternal::nz_out(const std::vector<
51573 DM > &res) const  "
51574 
51575 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
51576 
51577 ";
51578 
51579 %feature("docstring")  casadi::FunctionInternal::nz_out(const std::vector<
51580 double > &res) const  "
51581 
51582 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
51583 
51584 ";
51585 
51586 %feature("docstring")  casadi::ProtoFunction::alloc_mem() const  "
51587 
51588 [INTERNAL]  Create memory block.
51589 
51590 ";
51591 
51592 %feature("docstring")  casadi::FunctionInternal::signature(const std::string
51593 &fname) const  "
51594 
51595 [INTERNAL]  Code generate the function.
51596 
51597 ";
51598 
51599 %feature("docstring")  casadi::FunctionInternal::disp(std::ostream &stream,
51600 bool more) const  "
51601 
51602 [INTERNAL]  Display object.
51603 
51604 ";
51605 
51606 %feature("docstring")
51607 casadi::FunctionInternal::codegen_free_mem(CodeGenerator &g) const  "
51608 
51609 [INTERNAL]  Codegen for free_mem.
51610 
51611 ";
51612 
51613 %feature("docstring")  casadi::SharedObjectInternal::getCount() const  "
51614 
51615 [INTERNAL]  Get the reference count.
51616 
51617 ";
51618 
51619 %feature("docstring")  casadi::FunctionInternal::nnz_in() const  "
51620 
51621 [INTERNAL]  Number of input/output nonzeros.
51622 
51623 ";
51624 
51625 %feature("docstring")  casadi::FunctionInternal::nnz_in(casadi_int ind)
51626 const  "
51627 
51628 [INTERNAL]  Number of input/output nonzeros.
51629 
51630 ";
51631 
51632 %feature("docstring")  casadi::FunctionInternal::reverse(casadi_int nadj)
51633 const  "
51634 
51635 [INTERNAL]  Return function that calculates adjoint derivatives
51636 reverse(nadj) returns a cached instance if available, and calls  Function
51637 get_reverse(casadi_int nadj) if no cached version is available.
51638 
51639 ";
51640 
51641 %feature("docstring")  casadi::FunctionInternal::mapsum_mx(const
51642 std::vector< MX > &arg, const std::string &parallelization) "
51643 
51644 [INTERNAL]  Parallel evaluation.
51645 
51646 ";
51647 
51648 %feature("docstring")  casadi::FunctionInternal::mx_in(casadi_int ind) const
51649 "
51650 
51651 [INTERNAL]  Get function input(s) and output(s)
51652 
51653 ";
51654 
51655 %feature("docstring")  casadi::FunctionInternal::mx_in() const  "
51656 
51657 [INTERNAL]  Get function input(s) and output(s)
51658 
51659 ";
51660 
51661 %feature("docstring")  casadi::FunctionInternal::get_reltol() const  "
51662 
51663 [INTERNAL]  Get relative tolerance.
51664 
51665 ";
51666 
51667 %feature("docstring")  casadi::FunctionInternal::getAdaptorSolverName()
51668 const  "
51669 
51670 [INTERNAL]  Obtain solver name from Adaptor.
51671 
51672 ";
51673 
51674 %feature("docstring")  casadi::MapSum::has_forward(casadi_int nfwd) const  "
51675 
51676 [INTERNAL]  Generate a function that calculates nfwd forward derivatives.
51677 
51678 ";
51679 
51680 %feature("docstring")  casadi::FunctionInternal::get_function() const  "
51681 
51682 [INTERNAL] ";
51683 
51684 %feature("docstring")  casadi::FunctionInternal::get_function(const
51685 std::string &name) const  "
51686 
51687 [INTERNAL] ";
51688 
51689 %feature("docstring")  casadi::FunctionInternal::generate_dependencies(const
51690 std::string &fname, const Dict &opts) const  "
51691 
51692 [INTERNAL]  Export / Generate C code for the dependency function.
51693 
51694 ";
51695 
51696 %feature("docstring")  casadi::FunctionInternal::call_gen(const MXVector
51697 &arg, MXVector &res, casadi_int npar, bool always_inline, bool never_inline)
51698 const  "
51699 
51700 [INTERNAL]   Call a function, overloaded.
51701 
51702 ";
51703 
51704 %feature("docstring")  casadi::FunctionInternal::call_gen(const std::vector<
51705 MatrixCommon > &arg, std::vector< MatrixCommon > &res, casadi_int npar, bool
51706 always_inline, bool never_inline) const  "
51707 
51708 [INTERNAL]   Call a function, overloaded.
51709 
51710 ";
51711 
51712 %feature("docstring")  casadi::FunctionInternal::oracle() const  "
51713 
51714 [INTERNAL]  Get oracle.
51715 
51716 ";
51717 
51718 %feature("docstring")
51719 casadi::FunctionInternal::getJacSparsityGen(casadi_int iind, casadi_int
51720 oind, bool symmetric, casadi_int gr_i=1, casadi_int gr_o=1) const  "
51721 
51722 [INTERNAL]  Get the sparsity pattern, forward mode.
51723 
51724 ";
51725 
51726 %feature("docstring")  casadi::FunctionInternal::get_min_in(casadi_int ind)
51727 const  "
51728 
51729 [INTERNAL]  Get smallest input value.
51730 
51731 ";
51732 
51733 %feature("docstring")  casadi::ProtoFunction::memory(int ind) const  "
51734 
51735 [INTERNAL]  Memory objects.
51736 
51737 ";
51738 
51739 %feature("docstring")  casadi::ProtoFunction::init_mem(void *mem) const  "
51740 
51741 [INTERNAL]  Initalize memory block.
51742 
51743 ";
51744 
51745 %feature("docstring")  casadi::FunctionInternal::check_res(const
51746 std::vector< M > &res, casadi_int &npar) const  "
51747 
51748 [INTERNAL]  Check if output arguments have correct length and dimensions.
51749 
51750 Raises errors.
51751 
51752 Parameters:
51753 -----------
51754 
51755 npar[in]:  normal usage: 1, disallow pararallel calls: -1
51756 
51757 npar:  max number of horizontal repetitions across all arguments (or -1)
51758 
51759 ";
51760 
51761 %feature("docstring")  casadi::FunctionInternal::has_jacobian_sparsity()
51762 const  "
51763 
51764 [INTERNAL]  Get Jacobian sparsity.
51765 
51766 ";
51767 
51768 %feature("docstring")  casadi::FunctionInternal::is_diff_out(casadi_int i) "
51769 
51770 [INTERNAL] ";
51771 
51772 %feature("docstring")
51773 casadi::FunctionInternal::codegen_alloc_mem(CodeGenerator &g) const  "
51774 
51775 [INTERNAL]  Codegen decref for alloc_mem.
51776 
51777 ";
51778 
51779 %feature("docstring")  casadi::FunctionInternal::sx_in(casadi_int ind) const
51780 "
51781 
51782 [INTERNAL]  Get function input(s) and output(s)
51783 
51784 ";
51785 
51786 %feature("docstring")  casadi::FunctionInternal::sx_in() const  "
51787 
51788 [INTERNAL]  Get function input(s) and output(s)
51789 
51790 ";
51791 
51792 %feature("docstring")  casadi::MapSum::get_default_in(casadi_int ind) const
51793 "
51794 
51795 [INTERNAL]  Get default input value.
51796 
51797 ";
51798 
51799 %feature("docstring")  casadi::MapSum::sp_reverse(bvec_t **arg, bvec_t
51800 **res, casadi_int *iw, bvec_t *w, void *mem) const  "
51801 
51802 [INTERNAL]  Propagate sparsity backwards.
51803 
51804 ";
51805 
51806 %feature("docstring")  casadi::FunctionInternal::codegen_name(const
51807 CodeGenerator &g, bool ns=true) const  "
51808 
51809 [INTERNAL]  Get name in codegen.
51810 
51811 ";
51812 
51813 %feature("docstring")  casadi::ProtoFunction::free_mem(void *mem) const  "
51814 
51815 [INTERNAL]  Free memory block.
51816 
51817 ";
51818 
51819 %feature("docstring")  casadi::FunctionInternal::eval_dm(const std::vector<
51820 DM > &arg) const  "
51821 
51822 [INTERNAL]  Evaluate with DM matrices.
51823 
51824 ";
51825 
51826 %feature("docstring")  casadi::FunctionInternal::get_options() const  "
51827 
51828 [INTERNAL]  Options.
51829 
51830 ";
51831 
51832 %feature("docstring")  casadi::MapSum::codegen_declarations(CodeGenerator
51833 &g) const  "
51834 
51835 [INTERNAL]  Generate code for the declarations of the C function.
51836 
51837 ";
51838 
51839 %feature("docstring") casadi::MapSum::~MapSum "
51840 
51841 [INTERNAL]  Destructor.
51842 
51843 ";
51844 
51845 %feature("docstring")  casadi::ProtoFunction::print(const char *fmt,...)
51846 const  "
51847 
51848 [INTERNAL]  C-style formatted printing during evaluation.
51849 
51850 ";
51851 
51852 %feature("docstring")  casadi::FunctionInternal::index_out(const std::string
51853 &name) const  "
51854 
51855 [INTERNAL]  Get output scheme index by name.
51856 
51857 ";
51858 
51859 %feature("docstring")  casadi::FunctionInternal::generate_in(const
51860 std::string &fname, const double **arg) const  "
51861 
51862 [INTERNAL]  Export an input file that can be passed to generate C code with
51863 a main.
51864 
51865 ";
51866 
51867 %feature("docstring")  casadi::FunctionInternal::instructions_sx() const  "
51868 
51869 [INTERNAL]  get SX expression associated with instructions
51870 
51871 ";
51872 
51873 %feature("docstring")  casadi::FunctionInternal::alloc_res(size_t sz_res,
51874 bool persistent=false) "
51875 
51876 [INTERNAL]  Ensure required length of res field.
51877 
51878 ";
51879 
51880 %feature("docstring")  casadi::FunctionInternal::numel_in() const  "
51881 
51882 [INTERNAL]  Number of input/output elements.
51883 
51884 ";
51885 
51886 %feature("docstring")  casadi::FunctionInternal::numel_in(casadi_int ind)
51887 const  "
51888 
51889 [INTERNAL]  Number of input/output elements.
51890 
51891 ";
51892 
51893 %feature("docstring") casadi::MapSum "
51894 
51895 [INTERNAL]   Map with reduce_in/reduce_out Joris Gillis
51896 
51897 C++ includes: mapsum.hpp ";
51898 
51899 %feature("docstring")  casadi::FunctionInternal::generate_out(const
51900 std::string &fname, double **res) const  "
51901 
51902 [INTERNAL] ";
51903 
51904 %feature("docstring")  casadi::FunctionInternal::get_free() const  "
51905 
51906 [INTERNAL]  Print free variables.
51907 
51908 ";
51909 
51910 %feature("docstring")
51911 casadi::FunctionInternal::codegen_init_mem(CodeGenerator &g) const  "
51912 
51913 [INTERNAL]  Codegen decref for init_mem.
51914 
51915 ";
51916 
51917 %feature("docstring")  casadi::FunctionInternal::fwdViaJac(casadi_int nfwd)
51918 const  "
51919 
51920 [INTERNAL]  Calculate derivatives by multiplying the full Jacobian and
51921 multiplying.
51922 
51923 ";
51924 
51925 %feature("docstring")  casadi::FunctionInternal::adjViaJac(casadi_int nadj)
51926 const  "
51927 
51928 [INTERNAL]  Calculate derivatives by multiplying the full Jacobian and
51929 multiplying.
51930 
51931 ";
51932 
51933 %feature("docstring")  casadi::FunctionInternal::mx_out(casadi_int ind)
51934 const  "
51935 
51936 [INTERNAL]  Get function input(s) and output(s)
51937 
51938 ";
51939 
51940 %feature("docstring")  casadi::FunctionInternal::mx_out() const  "
51941 
51942 [INTERNAL]  Get function input(s) and output(s)
51943 
51944 ";
51945 
51946 %feature("docstring")  casadi::MapSum::get_forward(casadi_int nfwd, const
51947 std::string &name, const std::vector< std::string > &inames, const
51948 std::vector< std::string > &onames, const Dict &opts) const  "
51949 
51950 [INTERNAL]  Generate a function that calculates nfwd forward derivatives.
51951 
51952 ";
51953 
51954 %feature("docstring")  casadi::FunctionInternal::convert_res(const
51955 std::vector< M > &res) const  "
51956 
51957 [INTERNAL]  Convert from/to input/output lists/map.
51958 
51959 ";
51960 
51961 %feature("docstring")  casadi::FunctionInternal::convert_res(const std::map<
51962 std::string, M > &res) const  "
51963 
51964 [INTERNAL]  Convert from/to input/output lists/map.
51965 
51966 ";
51967 
51968 %feature("docstring")  casadi::FunctionInternal::codegen(CodeGenerator &g,
51969 const std::string &fname) const  "
51970 
51971 [INTERNAL]  Generate code the function.
51972 
51973 ";
51974 
51975 %feature("docstring")
51976 casadi::FunctionInternal::codegen_decref(CodeGenerator &g) const  "
51977 
51978 [INTERNAL]  Codegen decref for dependencies.
51979 
51980 ";
51981 
51982 %feature("docstring")  casadi::ProtoFunction::get_stats(void *mem) const  "
51983 
51984 [INTERNAL]  Get all statistics.
51985 
51986 ";
51987 
51988 %feature("docstring")  casadi::FunctionInternal::sz_arg() const  "
51989 
51990 [INTERNAL]  Get required length of arg field.
51991 
51992 ";
51993 
51994 %feature("docstring")  casadi::FunctionInternal::replace_fseed(const
51995 std::vector< std::vector< M >> &fseed, casadi_int npar) const  "
51996 
51997 [INTERNAL]  Replace 0-by-0 forward seeds.
51998 
51999 ";
52000 
52001 %feature("docstring")  casadi::FunctionInternal::replace_fseed(const
52002 std::vector< std::vector< M > > &fseed, casadi_int npar) const  "
52003 
52004 [INTERNAL] ";
52005 
52006 %feature("docstring")  casadi::FunctionInternal::call_forward(const
52007 std::vector< MX > &arg, const std::vector< MX > &res, const std::vector<
52008 std::vector< MX > > &fseed, std::vector< std::vector< MX > > &fsens, bool
52009 always_inline, bool never_inline) const  "
52010 
52011 [INTERNAL]  Forward mode AD, virtual functions overloaded in derived
52012 classes.
52013 
52014 ";
52015 
52016 %feature("docstring")  casadi::FunctionInternal::call_forward(const
52017 std::vector< SX > &arg, const std::vector< SX > &res, const std::vector<
52018 std::vector< SX > > &fseed, std::vector< std::vector< SX > > &fsens, bool
52019 always_inline, bool never_inline) const  "
52020 
52021 [INTERNAL]  Forward mode AD, virtual functions overloaded in derived
52022 classes.
52023 
52024 ";
52025 
52026 %feature("docstring")  casadi::FunctionInternal::slice(const std::string
52027 &name, const std::vector< casadi_int > &order_in, const std::vector<
52028 casadi_int > &order_out, const Dict &opts) const  "
52029 
52030 [INTERNAL]  returns a new function with a selection of inputs/outputs of the
52031 original
52032 
52033 ";
52034 
52035 %feature("docstring")  casadi::MapSum::has_spfwd() const  "
52036 
52037 [INTERNAL]  Is the class able to propagate seeds through the algorithm?
52038 
52039 ";
52040 
52041 %feature("docstring")
52042 casadi::FunctionInternal::getJacSparsityHierarchical(casadi_int iind,
52043 casadi_int oind) const  "
52044 
52045 [INTERNAL]  A flavor of getJacSparsity that does hierarchical block
52046 structure recognition.
52047 
52048 ";
52049 
52050 %feature("docstring")  casadi::FunctionInternal::nz_in(const std::vector< DM
52051 > &arg) const  "
52052 
52053 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
52054 
52055 ";
52056 
52057 %feature("docstring")  casadi::FunctionInternal::nz_in(const std::vector<
52058 double > &arg) const  "
52059 
52060 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
52061 
52062 ";
52063 
52064 %feature("docstring")  casadi::FunctionInternal::has_jac() const  "
52065 
52066 [INTERNAL]  Return Jacobian of all input elements with respect to all output
52067 elements.
52068 
52069 ";
52070 
52071 %feature("docstring")  casadi::FunctionInternal::jac() const  "
52072 
52073 [INTERNAL]  Return Jacobian of all input elements with respect to all output
52074 elements.
52075 
52076 ";
52077 
52078 %feature("docstring")  casadi::FunctionInternal::self() const  "
52079 
52080 [INTERNAL]  Get a public class instance.
52081 
52082 ";
52083 
52084 %feature("docstring")  casadi::FunctionInternal::get_jacobian_sparsity()
52085 const  "
52086 
52087 [INTERNAL]  Get Jacobian sparsity.
52088 
52089 ";
52090 
52091 %feature("docstring")  casadi::FunctionInternal::codegen_mem(CodeGenerator
52092 &g, const std::string &index="mem") const  "
52093 
52094 [INTERNAL]  Get thread-local memory object.
52095 
52096 ";
52097 
52098 %feature("docstring")
52099 casadi::FunctionInternal::jacobian_sparsity_filter(const Sparsity &sp) const
52100 "
52101 
52102 [INTERNAL]  Filter out nonzeros in the full sparsity jacobian according to
52103 is_diff_in/out.
52104 
52105 ";
52106 
52107 %feature("docstring")  casadi::MapSum::serialize_type(SerializingStream &s)
52108 const  "
52109 
52110 [INTERNAL]  Serialize type information.
52111 
52112 ";
52113 
52114 %feature("docstring")  casadi::FunctionInternal::sparsity_in(casadi_int ind)
52115 const  "
52116 
52117 [INTERNAL]  Input/output sparsity.
52118 
52119 ";
52120 
52121 %feature("docstring")  casadi::FunctionInternal::get_jacobian(const
52122 std::string &name, const std::vector< std::string > &inames, const
52123 std::vector< std::string > &onames, const Dict &opts) const  "
52124 
52125 [INTERNAL]  Return Jacobian of all input elements with respect to all output
52126 elements.
52127 
52128 ";
52129 
52130 %feature("docstring")  casadi::MapSum::sp_forward(const bvec_t **arg, bvec_t
52131 **res, casadi_int *iw, bvec_t *w, void *mem) const  "
52132 
52133 [INTERNAL]  Propagate sparsity forward.
52134 
52135 ";
52136 
52137 %feature("docstring")
52138 casadi::FunctionInternal::instruction_output(casadi_int k) const  "
52139 
52140 [INTERNAL]  Get the (integer) output argument of an atomic operation.
52141 
52142 ";
52143 
52144 %feature("docstring")
52145 casadi::FunctionInternal::instruction_constant(casadi_int k) const  "
52146 
52147 [INTERNAL]  Get the floating point output argument of an atomic operation.
52148 
52149 ";
52150 
52151 %feature("docstring")  casadi::FunctionInternal::size_in(casadi_int ind)
52152 const  "
52153 
52154 [INTERNAL]  Input/output dimensions.
52155 
52156 ";
52157 
52158 %feature("docstring")  casadi::FunctionInternal::uses_output() const  "
52159 
52160 [INTERNAL]  Do the derivative functions need nondifferentiated outputs?
52161 
52162 ";
52163 
52164 %feature("docstring")  casadi::ProtoFunction::construct(const Dict &opts) "
52165 
52166 [INTERNAL]  Construct Prepares the function for evaluation.
52167 
52168 ";
52169 
52170 %feature("docstring")  casadi::FunctionInternal::nnz_out() const  "
52171 
52172 [INTERNAL]  Number of input/output nonzeros.
52173 
52174 ";
52175 
52176 %feature("docstring")  casadi::FunctionInternal::nnz_out(casadi_int ind)
52177 const  "
52178 
52179 [INTERNAL]  Number of input/output nonzeros.
52180 
52181 ";
52182 
52183 %feature("docstring")  casadi::FunctionInternal::set_temp(void *mem, const
52184 double **arg, double **res, casadi_int *iw, double *w) const  "
52185 
52186 [INTERNAL]  Set the (temporary) work vectors.
52187 
52188 ";
52189 
52190 %feature("docstring")  casadi::FunctionInternal::sz_iw() const  "
52191 
52192 [INTERNAL]  Get required length of iw field.
52193 
52194 ";
52195 
52196 %feature("docstring")  casadi::FunctionInternal::project_arg(const
52197 std::vector< M > &arg, casadi_int npar) const  "
52198 
52199 [INTERNAL]   Project sparsities.
52200 
52201 ";
52202 
52203 %feature("docstring")  casadi::MapSum::init(const Dict &opts)  "
52204 
52205 [INTERNAL]  Initialize.
52206 
52207 ";
52208 
52209 %feature("docstring")
52210 casadi::FunctionInternal::getJacSparsityHierarchicalSymm(casadi_int iind,
52211 casadi_int oind) const  "
52212 
52213 [INTERNAL]  A flavor of getJacSparsity that does hierarchical block
52214 structure recognition for symmetric Jacobians
52215 
52216 ";
52217 
52218 %feature("docstring")  casadi::FunctionInternal::alloc_iw(size_t sz_iw, bool
52219 persistent=false) "
52220 
52221 [INTERNAL]  Ensure required length of iw field.
52222 
52223 ";
52224 
52225 %feature("docstring")  casadi::FunctionInternal::numel_out(casadi_int ind)
52226 const  "
52227 
52228 [INTERNAL]  Number of input/output elements.
52229 
52230 ";
52231 
52232 %feature("docstring")  casadi::FunctionInternal::numel_out() const  "
52233 
52234 [INTERNAL]  Number of input/output elements.
52235 
52236 ";
52237 
52238 %feature("docstring")  casadi::SharedObjectInternal::weak() "
52239 
52240 [INTERNAL]  Get a weak reference to the object.
52241 
52242 ";
52243 
52244 %feature("docstring")  casadi::FunctionInternal::symbolicAdjSeed(casadi_int
52245 nadj, const std::vector< MatType > &v) const  "
52246 
52247 [INTERNAL]  Symbolic expressions for the adjoint seeds.
52248 
52249 ";
52250 
52251 %feature("docstring")  casadi::ProtoFunction::sprint(char *buf, size_t
52252 buf_sz, const char *fmt,...) const  "
52253 
52254 [INTERNAL]  C-style formatted printing to string.
52255 
52256 ";
52257 
52258 %feature("docstring")  casadi::ProtoFunction::release(int mem) const  "
52259 
52260 [INTERNAL]  Release a memory object.
52261 
52262 ";
52263 
52264 %feature("docstring")  casadi::FunctionInternal::has_jacobian() const  "
52265 
52266 [INTERNAL]  Return Jacobian of all input elements with respect to all output
52267 elements.
52268 
52269 ";
52270 
52271 %feature("docstring")  casadi::FunctionInternal::sz_work(size_t &sz_arg,
52272 size_t &sz_res, size_t &sz_iw, size_t &sz_w) const  "
52273 
52274 [INTERNAL]  Get number of temporary variables needed.
52275 
52276 ";
52277 
52278 %feature("docstring")  casadi::MapSum::get_n_in()  "
52279 
52280 [INTERNAL]  Number of function inputs and outputs.
52281 
52282 ";
52283 
52284 %feature("docstring")  casadi::FunctionInternal::replace_aseed(const
52285 std::vector< std::vector< M >> &aseed, casadi_int npar) const  "
52286 
52287 [INTERNAL]  Replace 0-by-0 reverse seeds.
52288 
52289 ";
52290 
52291 %feature("docstring")  casadi::FunctionInternal::replace_aseed(const
52292 std::vector< std::vector< M > > &aseed, casadi_int npar) const  "
52293 
52294 [INTERNAL] ";
52295 
52296 %feature("docstring")  casadi::MapSum::get_name_in(casadi_int i)  "
52297 
52298 [INTERNAL]  Names of function input and outputs.
52299 
52300 ";
52301 
52302 %feature("docstring")  casadi::FunctionInternal::forward(casadi_int nfwd)
52303 const  "
52304 
52305 [INTERNAL]  Return function that calculates forward derivatives
52306 forward(nfwd) returns a cached instance if available, and calls  Function
52307 get_forward(casadi_int nfwd) if no cached version is available.
52308 
52309 ";
52310 
52311 %feature("docstring")  casadi::FunctionInternal::factory(const std::string
52312 &name, const std::vector< std::string > &s_in, const std::vector<
52313 std::string > &s_out, const Function::AuxOut &aux, const Dict &opts) const
52314 "
52315 
52316 [INTERNAL] ";
52317 
52318 %feature("docstring")
52319 casadi::FunctionInternal::print_dimensions(std::ostream &stream) const  "
52320 
52321 [INTERNAL]  Print dimensions of inputs and outputs.
52322 
52323 ";
52324 
52325 %feature("docstring")  casadi::FunctionInternal::fwd_seed(casadi_int nfwd)
52326 const  "
52327 
52328 [INTERNAL]  Symbolic expressions for the forward seeds.
52329 
52330 ";
52331 
52332 %feature("docstring")  casadi::FunctionInternal::generate_options(bool
52333 is_temp=false) const  "
52334 
52335 [INTERNAL]  Reconstruct options dict.
52336 
52337 ";
52338 
52339 %feature("docstring")  casadi::FunctionInternal::jacobian() const  "
52340 
52341 [INTERNAL]  Return Jacobian of all input elements with respect to all output
52342 elements.
52343 
52344 ";
52345 
52346 %feature("docstring")  casadi::FunctionInternal::info() const  "
52347 
52348 [INTERNAL]  Obtain information about function
52349 
52350 ";
52351 
52352 %feature("docstring")  casadi::FunctionInternal::free_mx() const  "
52353 
52354 [INTERNAL]  Get free variables ( MX)
52355 
52356 ";
52357 
52358 %feature("docstring")  casadi::FunctionInternal::dm_out(casadi_int ind)
52359 const  "
52360 
52361 [INTERNAL]  Get function input(s) and output(s)
52362 
52363 ";
52364 
52365 %feature("docstring")  casadi::FunctionInternal::dm_out() const  "
52366 
52367 [INTERNAL]  Get function input(s) and output(s)
52368 
52369 ";
52370 
52371 %feature("docstring")  casadi::FunctionInternal::instruction_MX(casadi_int
52372 k) const  "
52373 
52374 [INTERNAL]  get MX expression associated with instruction
52375 
52376 ";
52377 
52378 %feature("docstring")  casadi::FunctionInternal::tocache(const Function &f,
52379 const std::string &suffix="") const  "
52380 
52381 [INTERNAL]  Save function to cache.
52382 
52383 ";
52384 
52385 %feature("docstring")  casadi::FunctionInternal::has_function(const
52386 std::string &fname) const  "
52387 
52388 [INTERNAL] ";
52389 
52390 %feature("docstring")  casadi::FunctionInternal::sp_weight() const  "
52391 
52392 [INTERNAL]  Weighting factor for chosing forward/reverse mode, sparsity
52393 propagation.
52394 
52395 ";
52396 
52397 %feature("docstring")  casadi::FunctionInternal::wrap_as_needed(const Dict
52398 &opts) const  "
52399 
52400 [INTERNAL]  Wrap in an Function instance consisting of only one MX call.
52401 
52402 ";
52403 
52404 %feature("docstring")  casadi::MapSum::get_sparsity_in(casadi_int i)  "
52405 
52406 [INTERNAL]  Sparsities of function inputs and outputs.
52407 
52408 ";
52409 
52410 %feature("docstring")  casadi::FunctionInternal::replace_res(const
52411 std::vector< M > &res, casadi_int npar) const  "
52412 
52413 [INTERNAL]  Replace 0-by-0 outputs.
52414 
52415 ";
52416 
52417 %feature("docstring")  casadi::FunctionInternal::sparsity_jac(casadi_int
52418 iind, casadi_int oind, bool compact, bool symmetric) const  "
52419 
52420 [INTERNAL]  Get, if necessary generate, the sparsity of a Jacobian block.
52421 
52422 ";
52423 
52424 %feature("docstring")  casadi::MapSum::has_codegen() const  "
52425 
52426 [INTERNAL]  Is codegen supported?
52427 
52428 ";
52429 
52430 %feature("docstring")
52431 casadi::FunctionInternal::instruction_input(casadi_int k) const  "
52432 
52433 [INTERNAL]  Get the (integer) input arguments of an atomic operation.
52434 
52435 ";
52436 
52437 %feature("docstring")  casadi::FunctionInternal::jacobian_sparsity() const
52438 "
52439 
52440 [INTERNAL]  Get Jacobian sparsity.
52441 
52442 ";
52443 
52444 %feature("docstring")  casadi::FunctionInternal::n_instructions() const  "
52445 
52446 [INTERNAL]  Get the number of atomic operations.
52447 
52448 ";
52449 
52450 %feature("docstring")  casadi::FunctionInternal::definition() const  "
52451 
52452 [INTERNAL]  Get function signature: name:(inputs)->(outputs)
52453 
52454 ";
52455 
52456 %feature("docstring")  casadi::MapSum::get_sparsity_out(casadi_int i)  "
52457 
52458 [INTERNAL]  Sparsities of function inputs and outputs.
52459 
52460 ";
52461 
52462 %feature("docstring")  casadi::FunctionInternal::get_jac(const std::string
52463 &name, const std::vector< std::string > &inames, const std::vector<
52464 std::string > &onames, const Dict &opts) const  "
52465 
52466 [INTERNAL]  Return Jacobian of all input elements with respect to all output
52467 elements.
52468 
52469 ";
52470 
52471 %feature("docstring")  casadi::FunctionInternal::alloc_w(size_t sz_w, bool
52472 persistent=false) "
52473 
52474 [INTERNAL]  Ensure required length of w field.
52475 
52476 ";
52477 
52478 %feature("docstring")  casadi::FunctionInternal::print_option(const
52479 std::string &name, std::ostream &stream) const  "
52480 
52481 [INTERNAL]  Print all information there is to know about a certain option.
52482 
52483 ";
52484 
52485 %feature("docstring")  casadi::FunctionInternal::size1_out(casadi_int ind)
52486 const  "
52487 
52488 [INTERNAL]  Input/output dimensions.
52489 
52490 ";
52491 
52492 %feature("docstring")  casadi::FunctionInternal::export_code(const
52493 std::string &lang, std::ostream &stream, const Dict &options) const  "
52494 
52495 [INTERNAL]  Export function in a specific language.
52496 
52497 ";
52498 
52499 %feature("docstring")  casadi::FunctionInternal::get_partition(casadi_int
52500 iind, casadi_int oind, Sparsity &D1, Sparsity &D2, bool compact, bool
52501 symmetric, bool allow_forward, bool allow_reverse) const  "
52502 
52503 [INTERNAL]  Get the unidirectional or bidirectional partition.
52504 
52505 ";
52506 
52507 %feature("docstring")  casadi::FunctionInternal::sx_out(casadi_int ind)
52508 const  "
52509 
52510 [INTERNAL]  Get function input(s) and output(s)
52511 
52512 ";
52513 
52514 %feature("docstring")  casadi::FunctionInternal::sx_out() const  "
52515 
52516 [INTERNAL]  Get function input(s) and output(s)
52517 
52518 ";
52519 
52520 %feature("docstring")  casadi::FunctionInternal::generate_lifted(Function
52521 &vdef_fcn, Function &vinit_fcn) const  "
52522 
52523 [INTERNAL]  Extract the functions needed for the Lifted Newton method.
52524 
52525 ";
52526 
52527 %feature("docstring")
52528 casadi::FunctionInternal::codegen_sparsities(CodeGenerator &g) const  "
52529 
52530 [INTERNAL]  Codegen sparsities.
52531 
52532 ";
52533 
52534 %feature("docstring")  casadi::FunctionInternal::setup(void *mem, const
52535 double **arg, double **res, casadi_int *iw, double *w) const  "
52536 
52537 [INTERNAL]  Set the (persistent and temporary) work vectors.
52538 
52539 ";
52540 
52541 %feature("docstring")  casadi::MapSum::codegen_body(CodeGenerator &g) const
52542 "
52543 
52544 [INTERNAL]  Generate code for the body of the C function.
52545 
52546 ";
52547 
52548 %feature("docstring")  casadi::ProtoFunction::clear_mem() "
52549 
52550 [INTERNAL]  Clear all memory (called from destructor)
52551 
52552 ";
52553 
52554 %feature("docstring")  casadi::FunctionInternal::call(const std::vector< M >
52555 &arg, std::vector< M > &res, bool always_inline, bool never_inline) const  "
52556 
52557 [INTERNAL]   Call a function, templated.
52558 
52559 ";
52560 
52561 %feature("docstring")  casadi::FunctionInternal::dm_in(casadi_int ind) const
52562 "
52563 
52564 [INTERNAL]  Get function input(s) and output(s)
52565 
52566 ";
52567 
52568 %feature("docstring")  casadi::FunctionInternal::dm_in() const  "
52569 
52570 [INTERNAL]  Get function input(s) and output(s)
52571 
52572 ";
52573 
52574 %feature("docstring")  casadi::FunctionInternal::has_eval_dm() const  "
52575 
52576 [INTERNAL]  Evaluate with DM matrices.
52577 
52578 ";
52579 
52580 %feature("docstring")  casadi::FunctionInternal::wrap() const  "
52581 
52582 [INTERNAL]  Wrap in an Function instance consisting of only one MX call.
52583 
52584 ";
52585 
52586 %feature("docstring")  casadi::FunctionInternal::codegen_mem_type() const  "
52587 
52588 [INTERNAL]  Thread-local memory object type.
52589 
52590 ";
52591 
52592 %feature("docstring")  casadi::MapSum::get_n_out()  "
52593 
52594 [INTERNAL]  Number of function inputs and outputs.
52595 
52596 ";
52597 
52598 %feature("docstring")  casadi::FunctionInternal::check_arg(const
52599 std::vector< M > &arg, casadi_int &npar) const  "
52600 
52601 [INTERNAL]  Check if input arguments have correct length and dimensions.
52602 
52603 Raises errors.
52604 
52605 Parameters:
52606 -----------
52607 
52608 npar[in]:  normal usage: 1, disallow pararallel calls: -1
52609 
52610 npar:  max number of horizontal repetitions across all arguments (or -1)
52611 
52612 ";
52613 
52614 %feature("docstring")  casadi::FunctionInternal::incache(const std::string
52615 &fname, Function &f, const std::string &suffix="") const  "
52616 
52617 [INTERNAL]  Get function in cache.
52618 
52619 ";
52620 
52621 %feature("docstring")  casadi::FunctionInternal::is_a(const std::string
52622 &type, bool recursive) const  "
52623 
52624 [INTERNAL]  Check if the function is of a particular type.
52625 
52626 ";
52627 
52628 %feature("docstring")  casadi::FunctionInternal::instruction_id(casadi_int
52629 k) const  "
52630 
52631 [INTERNAL]  Get an atomic operation operator index.
52632 
52633 ";
52634 
52635 %feature("docstring")  casadi::FunctionInternal::finalize()  "
52636 
52637 [INTERNAL]  Finalize the object creation.
52638 
52639 ";
52640 
52641 %feature("docstring")  casadi::MapSum::eval(const double **arg, double
52642 **res, casadi_int *iw, double *w, void *mem) const  "
52643 
52644 [INTERNAL]  Evaluate the function numerically.
52645 
52646 ";
52647 
52648 %feature("docstring")  casadi::FunctionInternal::index_in(const std::string
52649 &name) const  "
52650 
52651 [INTERNAL]  Get input scheme index by name.
52652 
52653 ";
52654 
52655 %feature("docstring")  casadi::ProtoFunction::serialize(SerializingStream
52656 &s) const  "
52657 
52658 [INTERNAL]  Serialize an object.
52659 
52660 ";
52661 
52662 %feature("docstring")  casadi::FunctionInternal::alloc(const Function &f,
52663 bool persistent=false) "
52664 
52665 [INTERNAL]  Ensure work vectors long enough to evaluate function.
52666 
52667 ";
52668 
52669 %feature("docstring")  casadi::ProtoFunction::format_time(char *buffer,
52670 double time) const  "
52671 
52672 [INTERNAL]  Format time in a fixed width 8 format.
52673 
52674 ";
52675 
52676 %feature("docstring")  casadi::FunctionInternal::n_nodes() const  "
52677 
52678 [INTERNAL]  Number of nodes in the algorithm.
52679 
52680 ";
52681 
52682 %feature("docstring")  casadi::MapSum::get_name_out(casadi_int i)  "
52683 
52684 [INTERNAL]  Names of function input and outputs.
52685 
52686 ";
52687 
52688 %feature("docstring")  casadi::MapSum::serialize_body(SerializingStream &s)
52689 const  "
52690 
52691 [INTERNAL]  Serialize an object without type information.
52692 
52693 ";
52694 
52695 %feature("docstring")  casadi::FunctionInternal::jit_dependencies(const
52696 std::string &fname) "
52697 
52698 [INTERNAL]  Jit dependencies.
52699 
52700 ";
52701 
52702 %feature("docstring")  casadi::FunctionInternal::project_res(const
52703 std::vector< M > &arg, casadi_int npar) const  "
52704 
52705 [INTERNAL]   Project sparsities.
52706 
52707 ";
52708 
52709 %feature("docstring")  casadi::FunctionInternal::size1_in(casadi_int ind)
52710 const  "
52711 
52712 [INTERNAL]  Input/output dimensions.
52713 
52714 ";
52715 
52716 %feature("docstring")  casadi::FunctionInternal::ad_weight() const  "
52717 
52718 [INTERNAL]  Weighting factor for chosing forward/reverse mode.
52719 
52720 ";
52721 
52722 %feature("docstring")  casadi::FunctionInternal::size2_in(casadi_int ind)
52723 const  "
52724 
52725 [INTERNAL]  Input/output dimensions.
52726 
52727 ";
52728 
52729 
52730 // File: classcasadi_1_1Matrix.xml
52731 
52732 
52733 /*  Construct symbolic primitives  */
52734 
52735 /* The \"sym\" function is intended to work in a similar way as \"sym\" used
52736 in the Symbolic Toolbox for Matlab but instead creating a CasADi symbolic
52737 primitive.
52738 
52739 */ %feature("docstring")  casadi::MatrixCommon::taylor(const MatrixCommon
52740 &ex, const MatrixCommon &x, const MatrixCommon &a, casadi_int order=1) "
52741 
52742 univariate Taylor series expansion
52743 
52744 Calculate the Taylor expansion of expression 'ex' up to order 'order' with
52745 respect to variable 'x' around the point 'a'
52746 
52747 $(x)=f(a)+f'(a)(x-a)+f''(a)\\\\frac
52748 {(x-a)^2}{2!}+f'''(a)\\\\frac{(x-a)^3}{3!}+\\\\ldots$
52749 
52750 Example usage:
52751 
52752 ::
52753 
52754 >>   x
52755 
52756 
52757 
52758 ";
52759 
52760 %feature("docstring") casadi::casadi_taylor "
52761 
52762 univariate Taylor series expansion
52763 
52764 Calculate the Taylor expansion of expression 'ex' up to order 'order' with
52765 respect to variable 'x' around the point 'a'
52766 
52767 $(x)=f(a)+f'(a)(x-a)+f''(a)\\\\frac
52768 {(x-a)^2}{2!}+f'''(a)\\\\frac{(x-a)^3}{3!}+\\\\ldots$
52769 
52770 Example usage:
52771 
52772 ::
52773 
52774 >>   x
52775 
52776 
52777 
52778 ";
52779 
52780 %feature("docstring")  casadi::MatrixCommon::casadi_taylor "
52781 
52782 univariate Taylor series expansion
52783 
52784 Calculate the Taylor expansion of expression 'ex' up to order 'order' with
52785 respect to variable 'x' around the point 'a'
52786 
52787 $(x)=f(a)+f'(a)(x-a)+f''(a)\\\\frac
52788 {(x-a)^2}{2!}+f'''(a)\\\\frac{(x-a)^3}{3!}+\\\\ldots$
52789 
52790 Example usage:
52791 
52792 ::
52793 
52794 >>   x
52795 
52796 
52797 
52798 ";
52799 
52800 %feature("docstring")  casadi::MatrixCommon::taylor(const MatrixCommon &ex,
52801 const MatrixCommon &x) "
52802 
52803 [INTERNAL]  univariate Taylor series expansion
52804 
52805 Calculate the Taylor expansion of expression 'ex' up to order 'order' with
52806 respect to variable 'x' around the point 'a'
52807 
52808 $(x)=f(a)+f'(a)(x-a)+f''(a)\\\\frac
52809 {(x-a)^2}{2!}+f'''(a)\\\\frac{(x-a)^3}{3!}+\\\\ldots$
52810 
52811 Example usage:
52812 
52813 ::
52814 
52815 >>   x
52816 
52817 
52818 
52819 ";
52820 
52821 %feature("docstring") casadi::casadi_taylor "
52822 
52823 univariate Taylor series expansion
52824 
52825 Calculate the Taylor expansion of expression 'ex' up to order 'order' with
52826 respect to variable 'x' around the point 'a'
52827 
52828 $(x)=f(a)+f'(a)(x-a)+f''(a)\\\\frac
52829 {(x-a)^2}{2!}+f'''(a)\\\\frac{(x-a)^3}{3!}+\\\\ldots$
52830 
52831 Example usage:
52832 
52833 ::
52834 
52835 >>   x
52836 
52837 
52838 
52839 ";
52840 
52841 %feature("docstring")  casadi::MatrixCommon::casadi_taylor "
52842 
52843 univariate Taylor series expansion
52844 
52845 Calculate the Taylor expansion of expression 'ex' up to order 'order' with
52846 respect to variable 'x' around the point 'a'
52847 
52848 $(x)=f(a)+f'(a)(x-a)+f''(a)\\\\frac
52849 {(x-a)^2}{2!}+f'''(a)\\\\frac{(x-a)^3}{3!}+\\\\ldots$
52850 
52851 Example usage:
52852 
52853 ::
52854 
52855 >>   x
52856 
52857 
52858 
52859 ";
52860 
52861 %feature("docstring")  casadi::MatrixCommon::print_scalar(std::ostream
52862 &stream) const  "
52863 
52864 Print scalar.
52865 
52866 ";
52867 
52868 %feature("docstring")  casadi::GenericMatrixCommon::nnz_upper() const "
52869 
52870 Get the number of non-zeros in the upper triangular half.
52871 
52872 ";
52873 
52874 %feature("docstring")  casadi::MatrixCommon::is_constant() const  "
52875 
52876 Check if the matrix is constant (note that false negative answers are
52877 possible)
52878 
52879 ";
52880 
52881 %feature("docstring")  casadi::MatrixCommon::mtaylor(const MatrixCommon &ex,
52882 const MatrixCommon &x, const MatrixCommon &a, casadi_int order=1) "
52883 
52884 multivariate Taylor series expansion
52885 
52886 Do Taylor expansions until the aggregated order of a term is equal to
52887 'order'. The aggregated order of $x^n y^m$ equals $n+m$.
52888 
52889 ";
52890 
52891 %feature("docstring") casadi::casadi_mtaylor "
52892 
52893 multivariate Taylor series expansion
52894 
52895 Do Taylor expansions until the aggregated order of a term is equal to
52896 'order'. The aggregated order of $x^n y^m$ equals $n+m$.
52897 
52898 ";
52899 
52900 %feature("docstring")  casadi::MatrixCommon::casadi_mtaylor "
52901 
52902 multivariate Taylor series expansion
52903 
52904 Do Taylor expansions until the aggregated order of a term is equal to
52905 'order'. The aggregated order of $x^n y^m$ equals $n+m$.
52906 
52907 ";
52908 
52909 %feature("docstring")  casadi::MatrixCommon::mtaylor(const MatrixCommon &ex,
52910 const MatrixCommon &x, const MatrixCommon &a, casadi_int order, const
52911 std::vector< casadi_int > &order_contributions) "
52912 
52913 multivariate Taylor series expansion
52914 
52915 Do Taylor expansions until the aggregated order of a term is equal to
52916 'order'. The aggregated order of $x^n y^m$ equals $n+m$.
52917 
52918 The argument order_contributions can denote how match each variable
52919 contributes to the aggregated order. If x=[x, y] and order_contributions=[1,
52920 2], then the aggregated order of $x^n y^m$ equals $1n+2m$.
52921 
52922 Example usage
52923 
52924 $ \\\\sin(b+a)+\\\\cos(b+a)(x-a)+\\\\cos(b+a)(y-b) $ $ y+x-(x^3+3y x^2+3 y^2
52925 x+y^3)/6 $ $ (-3 x^2 y-x^3)/6+y+x $
52926 
52927 ";
52928 
52929 %feature("docstring") casadi::casadi_mtaylor "
52930 
52931 multivariate Taylor series expansion
52932 
52933 Do Taylor expansions until the aggregated order of a term is equal to
52934 'order'. The aggregated order of $x^n y^m$ equals $n+m$.
52935 
52936 The argument order_contributions can denote how match each variable
52937 contributes to the aggregated order. If x=[x, y] and order_contributions=[1,
52938 2], then the aggregated order of $x^n y^m$ equals $1n+2m$.
52939 
52940 Example usage
52941 
52942 $ \\\\sin(b+a)+\\\\cos(b+a)(x-a)+\\\\cos(b+a)(y-b) $ $ y+x-(x^3+3y x^2+3 y^2
52943 x+y^3)/6 $ $ (-3 x^2 y-x^3)/6+y+x $
52944 
52945 ";
52946 
52947 %feature("docstring")  casadi::MatrixCommon::casadi_mtaylor "
52948 
52949 multivariate Taylor series expansion
52950 
52951 Do Taylor expansions until the aggregated order of a term is equal to
52952 'order'. The aggregated order of $x^n y^m$ equals $n+m$.
52953 
52954 The argument order_contributions can denote how match each variable
52955 contributes to the aggregated order. If x=[x, y] and order_contributions=[1,
52956 2], then the aggregated order of $x^n y^m$ equals $1n+2m$.
52957 
52958 Example usage
52959 
52960 $ \\\\sin(b+a)+\\\\cos(b+a)(x-a)+\\\\cos(b+a)(y-b) $ $ y+x-(x^3+3y x^2+3 y^2
52961 x+y^3)/6 $ $ (-3 x^2 y-x^3)/6+y+x $
52962 
52963 ";
52964 
52965 %feature("docstring")  casadi::MatrixCommon::get_elements() const  "
52966 
52967 Get all elements.
52968 
52969 ";
52970 
52971 %feature("docstring")  casadi::MatrixCommon::set(const MatrixCommon &m, bool
52972 ind1, const Slice &rr) "
52973 
52974 Set a submatrix, single argument
52975 
52976 ";
52977 
52978 %feature("docstring")  casadi::MatrixCommon::set(const MatrixCommon &m, bool
52979 ind1, const MatrixCommon &rr) "
52980 
52981 Set a submatrix, single argument
52982 
52983 ";
52984 
52985 %feature("docstring")  casadi::MatrixCommon::set(const MatrixCommon &m, bool
52986 ind1, const Sparsity &sp) "
52987 
52988 Set a submatrix, single argument
52989 
52990 ";
52991 
52992 %feature("docstring")  casadi::MatrixCommon::set(const MatrixCommon &m, bool
52993 ind1, const Slice &rr, const Slice &cc) "
52994 
52995 Set a submatrix, two arguments
52996 
52997 ";
52998 
52999 %feature("docstring")  casadi::MatrixCommon::set(const MatrixCommon &m, bool
53000 ind1, const Slice &rr, const MatrixCommon &cc) "
53001 
53002 Set a submatrix, two arguments
53003 
53004 ";
53005 
53006 %feature("docstring")  casadi::MatrixCommon::set(const MatrixCommon &m, bool
53007 ind1, const MatrixCommon &rr, const Slice &cc) "
53008 
53009 Set a submatrix, two arguments
53010 
53011 ";
53012 
53013 %feature("docstring")  casadi::MatrixCommon::set(const MatrixCommon &m, bool
53014 ind1, const MatrixCommon &rr, const MatrixCommon &cc) "
53015 
53016 Set a submatrix, two arguments
53017 
53018 ";
53019 
53020 %feature("docstring")  casadi::GenericMatrixCommon::nnz() const "
53021 
53022 Get the number of (structural) non-zero elements.
53023 
53024 ";
53025 
53026 %feature("docstring")  casadi::MatrixCommon::remove(const std::vector<
53027 casadi_int > &rr, const std::vector< casadi_int > &cc) "
53028 
53029 Remove columns and rows Remove/delete rows and/or columns of a matrix.
53030 
53031 ";
53032 
53033 %feature("docstring")  casadi::MatrixCommon::get(MatrixCommon &output_m,
53034 bool ind1, const Slice &rr) const  "
53035 
53036 Get a submatrix, single argument
53037 
53038 ";
53039 
53040 %feature("docstring")  casadi::MatrixCommon::get(MatrixCommon &output_m,
53041 bool ind1, const MatrixCommon &rr) const  "
53042 
53043 Get a submatrix, single argument
53044 
53045 ";
53046 
53047 %feature("docstring")  casadi::MatrixCommon::get(MatrixCommon &output_m,
53048 bool ind1, const Sparsity &sp) const  "
53049 
53050 Get a submatrix, single argument
53051 
53052 ";
53053 
53054 %feature("docstring")  casadi::MatrixCommon::get(MatrixCommon &output_m,
53055 bool ind1, const Slice &rr, const Slice &cc) const  "
53056 
53057 Get a submatrix, two arguments
53058 
53059 ";
53060 
53061 %feature("docstring")  casadi::MatrixCommon::get(MatrixCommon &output_m,
53062 bool ind1, const Slice &rr, const MatrixCommon &cc) const  "
53063 
53064 Get a submatrix, two arguments
53065 
53066 ";
53067 
53068 %feature("docstring")  casadi::MatrixCommon::get(MatrixCommon &output_m,
53069 bool ind1, const MatrixCommon &rr, const Slice &cc) const  "
53070 
53071 Get a submatrix, two arguments
53072 
53073 ";
53074 
53075 %feature("docstring")  casadi::MatrixCommon::get(MatrixCommon &output_m,
53076 bool ind1, const MatrixCommon &rr, const MatrixCommon &cc) const  "
53077 
53078 Get a submatrix, two arguments
53079 
53080 ";
53081 
53082 %feature("docstring")  casadi::MatrixCommon::export_code(const std::string
53083 &lang, std::ostream &stream=casadi::uout(), const Dict &options=Dict())
53084 const  "
53085 
53086 Export matrix in specific language.
53087 
53088 lang: only 'matlab' supported for now
53089 
53090 ::
53091 
53092   * options:
53093   *   inline: Indicates if you want everything on a single line (default: False)
53094   *   name: Name of exported variable (default: 'm')
53095   *   indent_level: Level of indentation (default: 0)
53096   *   spoof_zero: Replace numerical zero by a 1e-200 (default: false)
53097   *               might be needed for matlab sparse construct,
53098   *               which doesn't allow numerical zero
53099   *
53100 
53101 
53102 
53103 ";
53104 
53105 %feature("docstring")  casadi::MatrixCommon::from_file(const std::string
53106 &filename, const std::string &format_hint="") "
53107 
53108 Export numerical matrix to file
53109 
53110 Supported formats:
53111 
53112 
53113 
53114 ::
53115 
53116   *   - .mtx   Matrix Market (sparse)
53117   *   - .txt   Ascii full precision representation (sparse)
53118   *            Whitespace separated, aligned.
53119   *            Comments with # % or /
53120   *            Uses C locale
53121   *            Structural zeros represented by 00
53122   *            Does not scale well for large sparse matrices
53123   *
53124 
53125 
53126 
53127 ";
53128 
53129 %feature("docstring")  casadi::MatrixCommon::set_width(casadi_int width) "
53130 
53131 Set the 'precision, width & scientific' used in printing and serializing to
53132 streams.
53133 
53134 ";
53135 
53136 %feature("docstring")  casadi::MatrixCommon::sanity_check(bool
53137 complete=false) const  "
53138 
53139 [DEPRECATED] Correctness is checked during construction
53140 
53141 ";
53142 
53143 %feature("docstring")  casadi::MatrixCommon::rand(casadi_int nrow=1,
53144 casadi_int ncol=1) "
53145 
53146 Create a matrix with uniformly distributed random numbers.
53147 
53148 ";
53149 
53150 %feature("docstring")  casadi::MatrixCommon::rand(const Sparsity &sp) "
53151 
53152 Create a matrix with uniformly distributed random numbers.
53153 
53154 ";
53155 
53156 %feature("docstring")  casadi::MatrixCommon::rand(const std::pair<
53157 casadi_int, casadi_int > &rc) "
53158 
53159 Create a matrix with uniformly distributed random numbers.
53160 
53161 ";
53162 
53163 %feature("docstring")  casadi::MatrixCommon::print_split(std::vector<
53164 std::string > &output_nz, std::vector< std::string > &output_inter) const  "
53165 
53166 Get strings corresponding to the nonzeros and the interdependencies.
53167 
53168 ";
53169 
53170 %feature("docstring")  casadi::MatrixCommon::chol(const MatrixCommon &A) "
53171 
53172 Obtain a Cholesky factorisation of a matrix Performs and LDL transformation
53173 [L,D] = ldl(A) and returns diag(sqrt(D))*L'.
53174 
53175 ";
53176 
53177 %feature("docstring") casadi::casadi_chol "
53178 
53179 Obtain a Cholesky factorisation of a matrix Performs and LDL transformation
53180 [L,D] = ldl(A) and returns diag(sqrt(D))*L'.
53181 
53182 ";
53183 
53184 %feature("docstring")  casadi::MatrixCommon::casadi_chol "
53185 
53186 Obtain a Cholesky factorisation of a matrix Performs and LDL transformation
53187 [L,D] = ldl(A) and returns diag(sqrt(D))*L'.
53188 
53189 ";
53190 
53191 %feature("docstring")  casadi::MatrixCommon::set_precision(casadi_int
53192 precision) "
53193 
53194 Set the 'precision, width & scientific' used in printing and serializing to
53195 streams.
53196 
53197 ";
53198 
53199 %feature("docstring")  casadi::GenericMatrixCommon::is_tril() const "
53200 
53201 Check if the matrix is lower triangular.
53202 
53203 ";
53204 
53205 %feature("docstring")  casadi::MatrixCommon::is_integer() const  "
53206 
53207 Check if the matrix is integer-valued (note that false negative answers are
53208 possible)
53209 
53210 ";
53211 
53212 %feature("docstring")  casadi::GenericMatrixCommon::numel() const "
53213 
53214 Get the number of elements.
53215 
53216 ";
53217 
53218 %feature("docstring")  casadi::GenericMatrixCommon::is_triu() const "
53219 
53220 Check if the matrix is upper triangular.
53221 
53222 ";
53223 
53224 %feature("docstring")  casadi::SX::is_op(casadi_int op) const  "
53225 
53226 Is it a certain operation.
53227 
53228 ";
53229 
53230 %feature("docstring")  casadi::SX::is_regular() const  "
53231 
53232 Checks if expression does not contain NaN or Inf.
53233 
53234 ";
53235 
53236 %feature("docstring")  casadi::MatrixCommon::set_nz(const MatrixCommon &m,
53237 bool ind1, const Slice &k) "
53238 
53239 Set a set of nonzeros
53240 
53241 ";
53242 
53243 %feature("docstring")  casadi::MatrixCommon::set_nz(const MatrixCommon &m,
53244 bool ind1, const MatrixCommon &k) "
53245 
53246 Set a set of nonzeros
53247 
53248 ";
53249 
53250 %feature("docstring")  casadi::GenericMatrixCommon::nnz_diag() const "
53251 
53252 Get get the number of non-zeros on the diagonal.
53253 
53254 ";
53255 
53256 %feature("docstring")  casadi::GenericMatrixCommon::gradient(const
53257 MatrixCommon &ex, const MatrixCommon &arg, const Dict &opts=Dict()) "
53258 
53259 Functions called by friend functions defined here
53260 
53261 ";
53262 
53263 %feature("docstring")  casadi::SX::op() const  "
53264 
53265 Get operation type.
53266 
53267 ";
53268 
53269 %feature("docstring")  casadi::MatrixCommon::pw_const(const MatrixCommon &t,
53270 const MatrixCommon &tval, const MatrixCommon &val) "
53271 
53272 Create a piecewise constant function Create a piecewise constant function
53273 with n=val.size() intervals.
53274 
53275 Inputs:
53276 
53277 Parameters:
53278 -----------
53279 
53280 t:  a scalar variable (e.g. time)
53281 
53282 tval:  vector with the discrete values of t at the interval transitions
53283 (length n-1)
53284 
53285 val:  vector with the value of the function for each interval (length n)
53286 
53287 ";
53288 
53289 %feature("docstring") casadi::casadi_pw_const "
53290 
53291 Create a piecewise constant function Create a piecewise constant function
53292 with n=val.size() intervals.
53293 
53294 Inputs:
53295 
53296 Parameters:
53297 -----------
53298 
53299 t:  a scalar variable (e.g. time)
53300 
53301 tval:  vector with the discrete values of t at the interval transitions
53302 (length n-1)
53303 
53304 val:  vector with the value of the function for each interval (length n)
53305 
53306 ";
53307 
53308 %feature("docstring")  casadi::MatrixCommon::casadi_pw_const "
53309 
53310 Create a piecewise constant function Create a piecewise constant function
53311 with n=val.size() intervals.
53312 
53313 Inputs:
53314 
53315 Parameters:
53316 -----------
53317 
53318 t:  a scalar variable (e.g. time)
53319 
53320 tval:  vector with the discrete values of t at the interval transitions
53321 (length n-1)
53322 
53323 val:  vector with the value of the function for each interval (length n)
53324 
53325 ";
53326 
53327 %feature("docstring")  casadi::GenericMatrixCommon::sparsity() const "
53328 
53329 Get the sparsity pattern.
53330 
53331 ";
53332 
53333 %feature("docstring") casadi::casadi_sparsity "
53334 
53335 Get the sparsity pattern.
53336 
53337 ";
53338 
53339 %feature("docstring")  casadi::GenericMatrixCommon::casadi_sparsity "
53340 
53341 Get the sparsity pattern.
53342 
53343 ";
53344 
53345 %feature("docstring")  casadi::MatrixCommon::ldl(const MatrixCommon &A,
53346 MatrixCommon &D, MatrixCommon &LT, std::vector< casadi_int > &p, bool
53347 amd=true) "
53348 
53349 Sparse LDL^T factorization Returns D and the strictly upper triangular
53350 entries of L^T I.e. ones on the diagonal are ignored. Only guarenteed to
53351 work for positive definite matrices.
53352 
53353 ";
53354 
53355 %feature("docstring") casadi::casadi_ldl "
53356 
53357 Sparse LDL^T factorization Returns D and the strictly upper triangular
53358 entries of L^T I.e. ones on the diagonal are ignored. Only guarenteed to
53359 work for positive definite matrices.
53360 
53361 ";
53362 
53363 %feature("docstring")  casadi::MatrixCommon::casadi_ldl "
53364 
53365 Sparse LDL^T factorization Returns D and the strictly upper triangular
53366 entries of L^T I.e. ones on the diagonal are ignored. Only guarenteed to
53367 work for positive definite matrices.
53368 
53369 ";
53370 
53371 %feature("docstring")  casadi::MatrixCommon::get_sparsity() const  "
53372 
53373 Get an owning reference to the sparsity pattern.
53374 
53375 ";
53376 
53377 %feature("docstring")  casadi::GenericMatrixCommon::bilin(const MatrixCommon
53378 &A, const MatrixCommon &x, const MatrixCommon &y) "
53379 
53380 Calculate bilinear form x^T A y.
53381 
53382 ";
53383 
53384 %feature("docstring") casadi::casadi_bilin "
53385 
53386 Calculate bilinear form x^T A y.
53387 
53388 ";
53389 
53390 %feature("docstring")  casadi::GenericMatrixCommon::casadi_bilin "
53391 
53392 Calculate bilinear form x^T A y.
53393 
53394 ";
53395 
53396 %feature("docstring")  casadi::MatrixCommon::expand(const MatrixCommon &ex,
53397 MatrixCommon &weights, MatrixCommon &terms) "
53398 
53399 Expand the expression as a weighted sum (with constant weights)
53400 
53401 ";
53402 
53403 %feature("docstring") casadi::casadi_expand "
53404 
53405 Expand the expression as a weighted sum (with constant weights)
53406 
53407 ";
53408 
53409 %feature("docstring")  casadi::MatrixCommon::casadi_expand "
53410 
53411 Expand the expression as a weighted sum (with constant weights)
53412 
53413 ";
53414 
53415 %feature("docstring")  casadi::GenericMatrixCommon::mpower(const
53416 MatrixCommon &x, const MatrixCommon &y) "
53417 
53418 Functions called by friend functions defined here
53419 
53420 ";
53421 
53422 %feature("docstring")  casadi::GenericMatrixCommon::dim(bool with_nz=false)
53423 const "
53424 
53425 Get string representation of dimensions. The representation is e.g. \"4x5\"
53426 or \"4x5,10nz\".
53427 
53428 ";
53429 
53430 %feature("docstring")  casadi::MatrixCommon::get_nz(MatrixCommon &output_m,
53431 bool ind1, const Slice &k) const  "
53432 
53433 Get a set of nonzeros
53434 
53435 ";
53436 
53437 %feature("docstring")  casadi::MatrixCommon::get_nz(MatrixCommon &output_m,
53438 bool ind1, const MatrixCommon &k) const  "
53439 
53440 Get a set of nonzeros
53441 
53442 ";
53443 
53444 %feature("docstring")  casadi::GenericMatrixCommon::columns() const "
53445 
53446 Get the number of columns, Octave-style syntax.
53447 
53448 ";
53449 
53450 %feature("docstring")  casadi::MatrixCommon::is_one() const  "
53451 
53452 check if the matrix is 1 (note that false negative answers are possible)
53453 
53454 ";
53455 
53456 %feature("docstring")  casadi::MatrixCommon::T() const  "
53457 
53458 Transpose the matrix.
53459 
53460 ";
53461 
53462 %feature("docstring")  casadi::SX::is_smooth() const  "
53463 
53464 Check if smooth.
53465 
53466 ";
53467 
53468 %feature("docstring")  casadi::MatrixCommon::norm_inf_mul(const MatrixCommon
53469 &x, const MatrixCommon &y) "
53470 
53471 Inf-norm of a Matrix-Matrix product.
53472 
53473 ";
53474 
53475 %feature("docstring") casadi::casadi_norm_inf_mul "
53476 
53477 Inf-norm of a Matrix-Matrix product.
53478 
53479 ";
53480 
53481 %feature("docstring")  casadi::MatrixCommon::casadi_norm_inf_mul "
53482 
53483 Inf-norm of a Matrix-Matrix product.
53484 
53485 ";
53486 
53487 %feature("docstring")  casadi::GenericMatrixCommon::rows() const "
53488 
53489 Get the number of rows, Octave-style syntax.
53490 
53491 ";
53492 
53493 %feature("docstring")  casadi::MatrixCommon::is_minus_one() const  "
53494 
53495 check if the matrix is -1 (note that false negative answers are possible)
53496 
53497 ";
53498 
53499 %feature("docstring")  casadi::MatrixCommon::eig_symbolic(const MatrixCommon
53500 &m) "
53501 
53502 Attempts to find the eigenvalues of a symbolic matrix This will only work
53503 for up to 3x3 matrices.
53504 
53505 ";
53506 
53507 %feature("docstring") casadi::casadi_eig_symbolic "
53508 
53509 Attempts to find the eigenvalues of a symbolic matrix This will only work
53510 for up to 3x3 matrices.
53511 
53512 ";
53513 
53514 %feature("docstring")  casadi::MatrixCommon::casadi_eig_symbolic "
53515 
53516 Attempts to find the eigenvalues of a symbolic matrix This will only work
53517 for up to 3x3 matrices.
53518 
53519 ";
53520 
53521 %feature("docstring")  casadi::SX::info() const  "
53522 
53523 Obtain information about sparsity
53524 
53525 ";
53526 
53527 %feature("docstring")  casadi::MatrixCommon::triangle(const MatrixCommon &x)
53528 "
53529 
53530 triangle function
53531 
53532 \\\\[ \\\\begin {cases} \\\\Lambda(x) = 0 & |x| >= 1 \\\\\\\\ \\\\Lambda(x)
53533 = 1-|x| & |x| < 1 \\\\end {cases} \\\\]
53534 
53535 ";
53536 
53537 %feature("docstring") casadi::casadi_triangle "
53538 
53539 triangle function
53540 
53541 \\\\[ \\\\begin {cases} \\\\Lambda(x) = 0 & |x| >= 1 \\\\\\\\ \\\\Lambda(x)
53542 = 1-|x| & |x| < 1 \\\\end {cases} \\\\]
53543 
53544 ";
53545 
53546 %feature("docstring")  casadi::MatrixCommon::casadi_triangle "
53547 
53548 triangle function
53549 
53550 \\\\[ \\\\begin {cases} \\\\Lambda(x) = 0 & |x| >= 1 \\\\\\\\ \\\\Lambda(x)
53551 = 1-|x| & |x| < 1 \\\\end {cases} \\\\]
53552 
53553 ";
53554 
53555 %feature("docstring")  casadi::SX::n_dep() const  "
53556 
53557 Get the number of dependencies of a binary SXElem Only defined if symbolic
53558 scalar.
53559 
53560 ";
53561 
53562 %feature("docstring")  casadi::GenericMatrixCommon::is_dense() const "
53563 
53564 Check if the matrix expression is dense.
53565 
53566 ";
53567 
53568 %feature("docstring")  casadi::MatrixCommon::print_sparse(std::ostream
53569 &stream, bool truncate=true) const  "
53570 
53571 Print sparse matrix style.
53572 
53573 ";
53574 
53575 %feature("docstring")  casadi::GenericMatrixCommon::nnz_lower() const "
53576 
53577 Get the number of non-zeros in the lower triangular half.
53578 
53579 ";
53580 
53581 %feature("docstring")  casadi::MatrixCommon::erase(const std::vector<
53582 casadi_int > &rr, const std::vector< casadi_int > &cc, bool ind1=false) "
53583 
53584 Erase a submatrix (leaving structural zeros in its place) Erase rows and/or
53585 columns of a matrix.
53586 
53587 ";
53588 
53589 %feature("docstring")  casadi::MatrixCommon::erase(const std::vector<
53590 casadi_int > &rr, bool ind1=false) "
53591 
53592 Erase a submatrix (leaving structural zeros in its place) Erase elements of
53593 a matrix.
53594 
53595 ";
53596 
53597 %feature("docstring")  casadi::MatrixCommon::any(const MatrixCommon &x) "
53598 
53599 Returns true only if any element in the matrix is true.
53600 
53601 ";
53602 
53603 %feature("docstring") casadi::casadi_any "
53604 
53605 Returns true only if any element in the matrix is true.
53606 
53607 ";
53608 
53609 %feature("docstring")  casadi::MatrixCommon::casadi_any "
53610 
53611 Returns true only if any element in the matrix is true.
53612 
53613 ";
53614 
53615 %feature("docstring")  casadi::MatrixCommon::inf(const Sparsity &sp) "
53616 
53617 create a matrix with all inf
53618 
53619 ";
53620 
53621 %feature("docstring")  casadi::MatrixCommon::inf(casadi_int nrow=1,
53622 casadi_int ncol=1) "
53623 
53624 create a matrix with all inf
53625 
53626 ";
53627 
53628 %feature("docstring")  casadi::MatrixCommon::inf(const std::pair<
53629 casadi_int, casadi_int > &rc) "
53630 
53631 create a matrix with all inf
53632 
53633 ";
53634 
53635 %feature("docstring")  casadi::SX::element_hash() const  "
53636 
53637 Returns a number that is unique for a given symbolic scalar.
53638 
53639 Only defined if symbolic scalar.
53640 
53641 ";
53642 
53643 %feature("docstring")  casadi::MatrixCommon::scalar_matrix(casadi_int op,
53644 const MatrixCommon &x, const MatrixCommon &y) "
53645 
53646 [INTERNAL]  Create nodes by their ID.
53647 
53648 ";
53649 
53650 %feature("docstring")  casadi::MatrixCommon::print_vector(std::ostream
53651 &stream, bool truncate=true) const  "
53652 
53653 Print vector-style.
53654 
53655 ";
53656 
53657 %feature("docstring")  casadi::GenericMatrixCommon::ones(casadi_int nrow=1,
53658 casadi_int ncol=1) "
53659 
53660 Create a dense matrix or a matrix with specified sparsity with all entries
53661 one.
53662 
53663 ";
53664 
53665 %feature("docstring")  casadi::GenericMatrixCommon::ones(const Sparsity &sp)
53666 "
53667 
53668 Create a dense matrix or a matrix with specified sparsity with all entries
53669 one.
53670 
53671 ";
53672 
53673 %feature("docstring")  casadi::GenericMatrixCommon::ones(const std::pair<
53674 casadi_int, casadi_int > &rc) "
53675 
53676 Create a dense matrix or a matrix with specified sparsity with all entries
53677 one.
53678 
53679 ";
53680 
53681 %feature("docstring")  casadi::MatrixCommon::has_zeros() const  "
53682 
53683 Check if the matrix has any zero entries which are not structural zeros.
53684 
53685 ";
53686 
53687 %feature("docstring")  casadi::MatrixCommon::heaviside(const MatrixCommon
53688 &x) "
53689 
53690 Heaviside function.
53691 
53692 \\\\[ \\\\begin {cases} H(x) = 0 & x<0 \\\\\\\\ H(x) = 1/2 & x=0 \\\\\\\\
53693 H(x) = 1 & x>0 \\\\\\\\ \\\\end {cases} \\\\]
53694 
53695 ";
53696 
53697 %feature("docstring") casadi::casadi_heaviside "
53698 
53699 Heaviside function.
53700 
53701 \\\\[ \\\\begin {cases} H(x) = 0 & x<0 \\\\\\\\ H(x) = 1/2 & x=0 \\\\\\\\
53702 H(x) = 1 & x>0 \\\\\\\\ \\\\end {cases} \\\\]
53703 
53704 ";
53705 
53706 %feature("docstring")  casadi::MatrixCommon::casadi_heaviside "
53707 
53708 Heaviside function.
53709 
53710 \\\\[ \\\\begin {cases} H(x) = 0 & x<0 \\\\\\\\ H(x) = 1/2 & x=0 \\\\\\\\
53711 H(x) = 1 & x>0 \\\\\\\\ \\\\end {cases} \\\\]
53712 
53713 ";
53714 
53715 %feature("docstring")  casadi::MatrixCommon::poly_roots(const MatrixCommon
53716 &p) "
53717 
53718 Attempts to find the roots of a polynomial.
53719 
53720 This will only work for polynomials up to order 3 It is assumed that the
53721 roots are real.
53722 
53723 ";
53724 
53725 %feature("docstring") casadi::casadi_poly_roots "
53726 
53727 Attempts to find the roots of a polynomial.
53728 
53729 This will only work for polynomials up to order 3 It is assumed that the
53730 roots are real.
53731 
53732 ";
53733 
53734 %feature("docstring")  casadi::MatrixCommon::casadi_poly_roots "
53735 
53736 Attempts to find the roots of a polynomial.
53737 
53738 This will only work for polynomials up to order 3 It is assumed that the
53739 roots are real.
53740 
53741 ";
53742 
53743 %feature("docstring")  casadi::GenericMatrixCommon::row(casadi_int el) const
53744 "
53745 
53746 Get the sparsity pattern. See the Sparsity class for details.
53747 
53748 ";
53749 
53750 %feature("docstring")  casadi::GenericMatrixCommon::zeros(casadi_int nrow=1,
53751 casadi_int ncol=1) "
53752 
53753 Create a dense matrix or a matrix with specified sparsity with all entries
53754 zero.
53755 
53756 ";
53757 
53758 %feature("docstring")  casadi::GenericMatrixCommon::zeros(const Sparsity
53759 &sp) "
53760 
53761 Create a dense matrix or a matrix with specified sparsity with all entries
53762 zero.
53763 
53764 ";
53765 
53766 %feature("docstring")  casadi::GenericMatrixCommon::zeros(const std::pair<
53767 casadi_int, casadi_int > &rc) "
53768 
53769 Create a dense matrix or a matrix with specified sparsity with all entries
53770 zero.
53771 
53772 ";
53773 
53774 %feature("docstring")  casadi::GenericMatrixCommon::rank1(const MatrixCommon
53775 &A, const MatrixCommon &alpha, const MatrixCommon &x, const MatrixCommon &y)
53776 "
53777 
53778 Make a rank-1 update to a matrix A Calculates A + 1/2 * alpha * x*y'.
53779 
53780 ";
53781 
53782 %feature("docstring") casadi::casadi_rank1 "
53783 
53784 Make a rank-1 update to a matrix A Calculates A + 1/2 * alpha * x*y'.
53785 
53786 ";
53787 
53788 %feature("docstring")  casadi::GenericMatrixCommon::casadi_rank1 "
53789 
53790 Make a rank-1 update to a matrix A Calculates A + 1/2 * alpha * x*y'.
53791 
53792 ";
53793 
53794 %feature("docstring") casadi::MatrixCommon "
53795 
53796 Sparse matrix class. SX and DM are specializations.
53797 
53798 General sparse matrix class that is designed with the idea that \"everything
53799 is a matrix\", that is, also scalars and vectors. This philosophy makes it
53800 easy to use and to interface in particularly with Python and Matlab/Octave.
53801 Index starts with 0. Index vec happens as follows: (rr, cc) -> k =
53802 rr+cc*size1() Vectors are column vectors.  The storage format is Compressed
53803 Column Storage (CCS), similar to that used for sparse matrices in Matlab,
53804 but unlike this format, we do allow for elements to be structurally non-zero
53805 but numerically zero.  Matrix<Scalar> is polymorphic with a
53806 std::vector<Scalar> that contain all non-identical-zero elements. The
53807 sparsity can be accessed with Sparsity& sparsity() Joel Andersson
53808 
53809 C++ includes: casadi_common.hpp ";
53810 
53811 %feature("docstring")  casadi::SX::dep(casadi_int ch=0) const  "
53812 
53813 Get expressions of the children of the expression Only defined if symbolic
53814 scalar. Wraps SXElem SXElem::dep(casadi_int ch=0) const.
53815 
53816 ";
53817 
53818 %feature("docstring")  casadi::MatrixCommon::is_zero() const  "
53819 
53820 check if the matrix is 0 (note that false negative answers are possible)
53821 
53822 ";
53823 
53824 %feature("docstring")  casadi::MatrixCommon::evalf(const MatrixCommon &expr)
53825 "
53826 
53827 Evaluates the expression numerically.
53828 
53829 An error is raised when the expression contains symbols
53830 
53831 ";
53832 
53833 %feature("docstring") casadi::casadi_evalf "
53834 
53835 Evaluates the expression numerically.
53836 
53837 An error is raised when the expression contains symbols
53838 
53839 ";
53840 
53841 %feature("docstring")  casadi::MatrixCommon::casadi_evalf "
53842 
53843 Evaluates the expression numerically.
53844 
53845 An error is raised when the expression contains symbols
53846 
53847 ";
53848 
53849 %feature("docstring")  casadi::SX::is_leaf() const  "
53850 
53851 Check if SX is a leaf of the SX graph.
53852 
53853 Only defined if symbolic scalar.
53854 
53855 ";
53856 
53857 %feature("docstring")  casadi::MatrixCommon::qr(const MatrixCommon &A,
53858 MatrixCommon &Q, MatrixCommon &R) "
53859 
53860 QR factorization using the modified Gram-Schmidt algorithm More stable than
53861 the classical Gram-Schmidt, but may break down if the rows of A are nearly
53862 linearly dependent See J. Demmel: Applied Numerical Linear Algebra
53863 (algorithm 3.1.). Note that in SWIG, Q and R are returned by value.
53864 
53865 ";
53866 
53867 %feature("docstring") casadi::casadi_qr "
53868 
53869 QR factorization using the modified Gram-Schmidt algorithm More stable than
53870 the classical Gram-Schmidt, but may break down if the rows of A are nearly
53871 linearly dependent See J. Demmel: Applied Numerical Linear Algebra
53872 (algorithm 3.1.). Note that in SWIG, Q and R are returned by value.
53873 
53874 ";
53875 
53876 %feature("docstring")  casadi::MatrixCommon::casadi_qr "
53877 
53878 QR factorization using the modified Gram-Schmidt algorithm More stable than
53879 the classical Gram-Schmidt, but may break down if the rows of A are nearly
53880 linearly dependent See J. Demmel: Applied Numerical Linear Algebra
53881 (algorithm 3.1.). Note that in SWIG, Q and R are returned by value.
53882 
53883 ";
53884 
53885 %feature("docstring")  casadi::GenericMatrixCommon::colind(casadi_int col)
53886 const "
53887 
53888 Get the sparsity pattern. See the Sparsity class for details.
53889 
53890 ";
53891 
53892 %feature("docstring")  casadi::MatrixCommon::poly_coeff(const MatrixCommon
53893 &f, const MatrixCommon &x) "
53894 
53895 extracts polynomial coefficients from an expression
53896 
53897 Parameters:
53898 -----------
53899 
53900 ex:  Scalar expression that represents a polynomial
53901 
53902 x:  Scalar symbol that the polynomial is build up with
53903 
53904 ";
53905 
53906 %feature("docstring") casadi::casadi_poly_coeff "
53907 
53908 extracts polynomial coefficients from an expression
53909 
53910 Parameters:
53911 -----------
53912 
53913 ex:  Scalar expression that represents a polynomial
53914 
53915 x:  Scalar symbol that the polynomial is build up with
53916 
53917 ";
53918 
53919 %feature("docstring")  casadi::MatrixCommon::casadi_poly_coeff "
53920 
53921 extracts polynomial coefficients from an expression
53922 
53923 Parameters:
53924 -----------
53925 
53926 ex:  Scalar expression that represents a polynomial
53927 
53928 x:  Scalar symbol that the polynomial is build up with
53929 
53930 ";
53931 
53932 %feature("docstring")  casadi::MatrixCommon::print_dense(std::ostream
53933 &stream, bool truncate=true) const  "
53934 
53935 Print dense matrix-stype.
53936 
53937 ";
53938 
53939 %feature("docstring")  casadi::MatrixCommon::has_nz(casadi_int rr,
53940 casadi_int cc) const  "
53941 
53942 Returns true if the matrix has a non-zero at location rr, cc.
53943 
53944 ";
53945 
53946 %feature("docstring")  casadi::MatrixCommon::matrix_scalar(casadi_int op,
53947 const MatrixCommon &x, const MatrixCommon &y) "
53948 
53949 [INTERNAL]  Create nodes by their ID.
53950 
53951 ";
53952 
53953 %feature("docstring")  casadi::MatrixCommon::nan(const Sparsity &sp) "
53954 
53955 create a matrix with all nan
53956 
53957 ";
53958 
53959 %feature("docstring")  casadi::MatrixCommon::nan(casadi_int nrow=1,
53960 casadi_int ncol=1) "
53961 
53962 create a matrix with all nan
53963 
53964 ";
53965 
53966 %feature("docstring")  casadi::MatrixCommon::nan(const std::pair<
53967 casadi_int, casadi_int > &rc) "
53968 
53969 create a matrix with all nan
53970 
53971 ";
53972 
53973 %feature("docstring")  casadi::SX::is_commutative() const  "
53974 
53975 Check whether a binary SX is commutative.
53976 
53977 Only defined if symbolic scalar.
53978 
53979 ";
53980 
53981 %feature("docstring")  casadi::SX::is_valid_input() const  "
53982 
53983 Check if matrix can be used to define function inputs. Sparse matrices can
53984 return true if all non-zero elements are symbolic.
53985 
53986 ";
53987 
53988 %feature("docstring")  casadi::GenericMatrixCommon::size2() const "
53989 
53990 Get the second dimension (i.e. number of columns)
53991 
53992 ";
53993 
53994 %feature("docstring")  casadi::GenericMatrixCommon::size() const "
53995 
53996 Get the shape.
53997 
53998 ";
53999 
54000 %feature("docstring")  casadi::GenericMatrixCommon::size(casadi_int axis)
54001 const "
54002 
54003 Get the size along a particular dimensions.
54004 
54005 ";
54006 
54007 %feature("docstring")  casadi::MatrixCommon::pw_lin(const MatrixCommon &t,
54008 const MatrixCommon &tval, const MatrixCommon &val) "
54009 
54010 t a scalar variable (e.g. time)
54011 
54012 Create a piecewise linear function Create a piecewise linear function:
54013 
54014 Inputs: tval vector with the the discrete values of t (monotonically
54015 increasing) val vector with the corresponding function values (same length
54016 as tval)
54017 
54018 ";
54019 
54020 %feature("docstring") casadi::casadi_pw_lin "
54021 
54022 t a scalar variable (e.g. time)
54023 
54024 Create a piecewise linear function Create a piecewise linear function:
54025 
54026 Inputs: tval vector with the the discrete values of t (monotonically
54027 increasing) val vector with the corresponding function values (same length
54028 as tval)
54029 
54030 ";
54031 
54032 %feature("docstring")  casadi::MatrixCommon::casadi_pw_lin "
54033 
54034 t a scalar variable (e.g. time)
54035 
54036 Create a piecewise linear function Create a piecewise linear function:
54037 
54038 Inputs: tval vector with the the discrete values of t (monotonically
54039 increasing) val vector with the corresponding function values (same length
54040 as tval)
54041 
54042 ";
54043 
54044 %feature("docstring")  casadi::GenericMatrixCommon::jtimes(const
54045 MatrixCommon &ex, const MatrixCommon &arg, const MatrixCommon &v, bool
54046 tr=false, const Dict &opts=Dict()) "
54047 
54048 Functions called by friend functions defined here
54049 
54050 ";
54051 
54052 %feature("docstring")  casadi::GenericMatrixCommon::size1() const "
54053 
54054 Get the first dimension (i.e. number of rows)
54055 
54056 ";
54057 
54058 %feature("docstring")  casadi::MatrixCommon::serialize() const  "
54059 
54060 Serialize.
54061 
54062 ";
54063 
54064 %feature("docstring")  casadi::MatrixCommon::serialize(SerializingStream &s)
54065 const  "
54066 
54067 Serialize an object.
54068 
54069 ";
54070 
54071 %feature("docstring")  casadi::MatrixCommon::to_file(const std::string
54072 &filename, const std::string &format="") const  "
54073 
54074 Export numerical matrix to file
54075 
54076 Supported formats:
54077 
54078 
54079 
54080 ::
54081 
54082   *   - .mtx   Matrix Market (sparse)
54083   *   - .txt   Ascii full precision representation (sparse)
54084   *            Whitespace separated, aligned.
54085   *            Comments with # % or /
54086   *            Uses C locale
54087   *            Structural zeros represented by 00
54088   *            Does not scale well for large sparse matrices
54089   *
54090 
54091 
54092 
54093 ";
54094 
54095 %feature("docstring")  casadi::GenericMatrixCommon::is_row() const "
54096 
54097 Check if the matrix is a row vector (i.e. size1()==1)
54098 
54099 ";
54100 
54101 %feature("docstring") casadi::MatrixCommon::__nonzero__ "
54102 
54103 Returns the truth value of a Matrix.
54104 
54105 ";
54106 
54107 %feature("docstring")  casadi::MatrixCommon::all(const MatrixCommon &x) "
54108 
54109 Returns true only if every element in the matrix is true.
54110 
54111 ";
54112 
54113 %feature("docstring") casadi::casadi_all "
54114 
54115 Returns true only if every element in the matrix is true.
54116 
54117 ";
54118 
54119 %feature("docstring")  casadi::MatrixCommon::casadi_all "
54120 
54121 Returns true only if every element in the matrix is true.
54122 
54123 ";
54124 
54125 %feature("docstring")  casadi::GenericMatrixCommon::soc(const MatrixCommon
54126 &x, const MatrixCommon &y) "
54127 
54128 Functions called by friend functions defined here
54129 
54130 ";
54131 
54132 %feature("docstring")  casadi::GenericMatrixCommon::is_square() const "
54133 
54134 Check if the matrix expression is square.
54135 
54136 ";
54137 
54138 %feature("docstring")  casadi::GenericMatrixCommon::tangent(const
54139 MatrixCommon &ex, const MatrixCommon &arg, const Dict &opts=Dict()) "
54140 
54141 Functions called by friend functions defined here
54142 
54143 ";
54144 
54145 %feature("docstring")  casadi::MatrixCommon::qr_solve(const MatrixCommon &b,
54146 const MatrixCommon &v, const MatrixCommon &r, const MatrixCommon &beta,
54147 const std::vector< casadi_int > &prinv, const std::vector< casadi_int > &pc,
54148 bool tr=false) "
54149 
54150 Solve using a sparse QR factorization.
54151 
54152 ";
54153 
54154 %feature("docstring") casadi::casadi_qr_solve "
54155 
54156 Solve using a sparse QR factorization.
54157 
54158 ";
54159 
54160 %feature("docstring")  casadi::MatrixCommon::casadi_qr_solve "
54161 
54162 Solve using a sparse QR factorization.
54163 
54164 ";
54165 
54166 %feature("docstring")  casadi::MatrixCommon::is_eye() const  "
54167 
54168 check if the matrix is an identity matrix (note that false negative answers
54169 are possible)
54170 
54171 ";
54172 
54173 %feature("docstring")  casadi::MatrixCommon::adj(const MatrixCommon &A) "
54174 
54175 Matrix adjoint.
54176 
54177 ";
54178 
54179 %feature("docstring") casadi::casadi_adj "
54180 
54181 Matrix adjoint.
54182 
54183 ";
54184 
54185 %feature("docstring")  casadi::MatrixCommon::casadi_adj "
54186 
54187 Matrix adjoint.
54188 
54189 ";
54190 
54191 %feature("docstring")  casadi::GenericMatrixCommon::is_empty(bool
54192 both=false) const "
54193 
54194 Check if the sparsity is empty, i.e. if one of the dimensions is zero (or
54195 optionally both dimensions)
54196 
54197 ";
54198 
54199 %feature("docstring")  casadi::MatrixCommon::gauss_quadrature(const
54200 MatrixCommon &f, const MatrixCommon &x, const MatrixCommon &a, const
54201 MatrixCommon &b, casadi_int order=5) "
54202 
54203 Integrate f from a to b using Gaussian quadrature with n points.
54204 
54205 ";
54206 
54207 %feature("docstring") casadi::casadi_gauss_quadrature "
54208 
54209 Integrate f from a to b using Gaussian quadrature with n points.
54210 
54211 ";
54212 
54213 %feature("docstring")  casadi::MatrixCommon::casadi_gauss_quadrature "
54214 
54215 Integrate f from a to b using Gaussian quadrature with n points.
54216 
54217 ";
54218 
54219 %feature("docstring")  casadi::MatrixCommon::gauss_quadrature(const
54220 MatrixCommon &f, const MatrixCommon &x, const MatrixCommon &a, const
54221 MatrixCommon &b, casadi_int order, const MatrixCommon &w) "
54222 
54223 Matrix adjoint.
54224 
54225 ";
54226 
54227 %feature("docstring") casadi::casadi_gauss_quadrature "
54228 
54229 Matrix adjoint.
54230 
54231 ";
54232 
54233 %feature("docstring")  casadi::MatrixCommon::casadi_gauss_quadrature "
54234 
54235 Matrix adjoint.
54236 
54237 ";
54238 
54239 %feature("docstring")  casadi::GenericMatrixCommon::linearize(const
54240 MatrixCommon &f, const MatrixCommon &x, const MatrixCommon &x0, const Dict
54241 &opts=Dict()) "
54242 
54243 Functions called by friend functions defined here
54244 
54245 ";
54246 
54247 %feature("docstring")  casadi::MatrixCommon::unary(casadi_int op, const
54248 MatrixCommon &x) "
54249 
54250 [INTERNAL]  Create nodes by their ID.
54251 
54252 ";
54253 
54254 %feature("docstring")  casadi::SX::reset_input() const  "
54255 
54256 [INTERNAL]  Reset the marker for an input expression.
54257 
54258 ";
54259 
54260 %feature("docstring")  casadi::MatrixCommon::qr_sparse(const MatrixCommon
54261 &A, MatrixCommon &V, MatrixCommon &R, MatrixCommon &beta, std::vector<
54262 casadi_int > &prinv, std::vector< casadi_int > &pc, bool amd=true) "
54263 
54264 Sparse direct QR factorization See T. Davis: Direct Methods for Sparse
54265 Linear Systems.
54266 
54267 ";
54268 
54269 %feature("docstring") casadi::casadi_qr_sparse "
54270 
54271 Sparse direct QR factorization See T. Davis: Direct Methods for Sparse
54272 Linear Systems.
54273 
54274 ";
54275 
54276 %feature("docstring")  casadi::MatrixCommon::casadi_qr_sparse "
54277 
54278 Sparse direct QR factorization See T. Davis: Direct Methods for Sparse
54279 Linear Systems.
54280 
54281 ";
54282 
54283 %feature("docstring")  casadi::GenericMatrixCommon::get_row() const "
54284 
54285 Get the sparsity pattern. See the Sparsity class for details.
54286 
54287 ";
54288 
54289 %feature("docstring")  casadi::MatrixCommon::enlarge(casadi_int nrow,
54290 casadi_int ncol, const std::vector< casadi_int > &rr, const std::vector<
54291 casadi_int > &cc, bool ind1=false) "
54292 
54293 Enlarge matrix Make the matrix larger by inserting empty rows and columns,
54294 keeping the existing non-zeros.
54295 
54296 ";
54297 
54298 %feature("docstring")  casadi::MatrixCommon::rectangle(const MatrixCommon
54299 &x) "
54300 
54301 rectangle function
54302 
54303 \\\\[ \\\\begin {cases} \\\\Pi(x) = 1 & |x| < 1/2 \\\\\\\\ \\\\Pi(x) = 1/2 &
54304 |x| = 1/2 \\\\\\\\ \\\\Pi(x) = 0 & |x| > 1/2 \\\\\\\\ \\\\end {cases} \\\\]
54305 
54306 Also called: gate function, block function, band function, pulse function,
54307 window function
54308 
54309 ";
54310 
54311 %feature("docstring") casadi::casadi_rectangle "
54312 
54313 rectangle function
54314 
54315 \\\\[ \\\\begin {cases} \\\\Pi(x) = 1 & |x| < 1/2 \\\\\\\\ \\\\Pi(x) = 1/2 &
54316 |x| = 1/2 \\\\\\\\ \\\\Pi(x) = 0 & |x| > 1/2 \\\\\\\\ \\\\end {cases} \\\\]
54317 
54318 Also called: gate function, block function, band function, pulse function,
54319 window function
54320 
54321 ";
54322 
54323 %feature("docstring")  casadi::MatrixCommon::casadi_rectangle "
54324 
54325 rectangle function
54326 
54327 \\\\[ \\\\begin {cases} \\\\Pi(x) = 1 & |x| < 1/2 \\\\\\\\ \\\\Pi(x) = 1/2 &
54328 |x| = 1/2 \\\\\\\\ \\\\Pi(x) = 0 & |x| > 1/2 \\\\\\\\ \\\\end {cases} \\\\]
54329 
54330 Also called: gate function, block function, band function, pulse function,
54331 window function
54332 
54333 ";
54334 
54335 %feature("docstring")  casadi::MatrixCommon::get_str(bool more=false) const
54336 "
54337 
54338 Get string representation.
54339 
54340 ";
54341 
54342 %feature("docstring")  casadi::MatrixCommon::minor(const MatrixCommon &x,
54343 casadi_int i, casadi_int j) "
54344 
54345 Get the (i,j) minor matrix.
54346 
54347 ";
54348 
54349 %feature("docstring") casadi::casadi_minor "
54350 
54351 Get the (i,j) minor matrix.
54352 
54353 ";
54354 
54355 %feature("docstring")  casadi::MatrixCommon::casadi_minor "
54356 
54357 Get the (i,j) minor matrix.
54358 
54359 ";
54360 
54361 %feature("docstring")  casadi::SX::is_symbolic() const  "
54362 
54363 Check if symbolic (Dense) Sparse matrices invariable return false.
54364 
54365 ";
54366 
54367 %feature("docstring")  casadi::GenericMatrixCommon::is_column() const "
54368 
54369 Check if the matrix is a column vector (i.e. size2()==1)
54370 
54371 ";
54372 
54373 %feature("docstring") casadi::MatrixCommon::MatrixCommon() "
54374 
54375 constructors
54376 
54377 empty 0-by-0 matrix constructor
54378 
54379 ";
54380 
54381 %feature("docstring") casadi::MatrixCommon::MatrixCommon(const MatrixCommon
54382 &m) "
54383 
54384 Copy constructor.
54385 
54386 ";
54387 
54388 %feature("docstring") casadi::MatrixCommon::MatrixCommon(casadi_int nrow,
54389 casadi_int ncol) "
54390 
54391 Create a sparse matrix with all structural zeros.
54392 
54393 ";
54394 
54395 %feature("docstring") casadi::MatrixCommon::MatrixCommon(const Sparsity &sp)
54396 "
54397 
54398 Create a sparse matrix from a sparsity pattern. Same as
54399 Matrix::ones(sparsity)
54400 
54401 ";
54402 
54403 %feature("docstring") casadi::MatrixCommon::MatrixCommon(const Sparsity &sp,
54404 const MatrixCommon &d) "
54405 
54406 Construct matrix with a given sparsity and nonzeros.
54407 
54408 ";
54409 
54410 %feature("docstring") casadi::MatrixCommon::MatrixCommon(double val) "
54411 
54412 This constructor enables implicit type conversion from a numeric type.
54413 
54414 ";
54415 
54416 %feature("docstring") casadi::MatrixCommon::MatrixCommon(const std::vector<
54417 std::vector< double > > &m) "
54418 
54419 Dense matrix constructor with data given as vector of vectors.
54420 
54421 ";
54422 
54423 %feature("docstring") casadi::MatrixCommon::MatrixCommon(const std::vector<
54424 A > &x) "
54425 
54426 Create an expression from a vector.
54427 
54428 ";
54429 
54430 %feature("docstring") casadi::MatrixCommon::MatrixCommon(const MatrixCommon
54431 &x) "
54432 
54433 Create a matrix from another matrix with a different entry type Assumes that
54434 the scalar conversion is valid.
54435 
54436 ";
54437 
54438 %feature("docstring")  casadi::MatrixCommon::cofactor(const MatrixCommon &x,
54439 casadi_int i, casadi_int j) "
54440 
54441 Get the (i,j) cofactor matrix.
54442 
54443 ";
54444 
54445 %feature("docstring") casadi::casadi_cofactor "
54446 
54447 Get the (i,j) cofactor matrix.
54448 
54449 ";
54450 
54451 %feature("docstring")  casadi::MatrixCommon::casadi_cofactor "
54452 
54453 Get the (i,j) cofactor matrix.
54454 
54455 ";
54456 
54457 %feature("docstring")  casadi::MatrixCommon::ramp(const MatrixCommon &x) "
54458 
54459 ramp function
54460 
54461 \\\\[ \\\\begin {cases} R(x) = 0 & x <= 1 \\\\\\\\ R(x) = x & x > 1 \\\\\\\\
54462 \\\\end {cases} \\\\]
54463 
54464 Also called: slope function
54465 
54466 ";
54467 
54468 %feature("docstring") casadi::casadi_ramp "
54469 
54470 ramp function
54471 
54472 \\\\[ \\\\begin {cases} R(x) = 0 & x <= 1 \\\\\\\\ R(x) = x & x > 1 \\\\\\\\
54473 \\\\end {cases} \\\\]
54474 
54475 Also called: slope function
54476 
54477 ";
54478 
54479 %feature("docstring")  casadi::MatrixCommon::casadi_ramp "
54480 
54481 ramp function
54482 
54483 \\\\[ \\\\begin {cases} R(x) = 0 & x <= 1 \\\\\\\\ R(x) = x & x > 1 \\\\\\\\
54484 \\\\end {cases} \\\\]
54485 
54486 Also called: slope function
54487 
54488 ";
54489 
54490 %feature("docstring")  casadi::GenericMatrixCommon::sym(const std::string
54491 &name, casadi_int nrow=1, casadi_int ncol=1) "
54492 
54493 Create an nrow-by-ncol symbolic primitive.
54494 
54495 ";
54496 
54497 %feature("docstring")  casadi::GenericMatrixCommon::sym(const std::string
54498 &name, const std::pair< casadi_int, casadi_int > &rc) "
54499 
54500 Construct a symbolic primitive with given dimensions.
54501 
54502 ";
54503 
54504 %feature("docstring")  casadi::GenericMatrixCommon::sym(const std::string
54505 &name, const Sparsity &sp) "
54506 
54507 Create symbolic primitive with a given sparsity pattern.
54508 
54509 ";
54510 
54511 %feature("docstring")  casadi::GenericMatrixCommon::sym(const std::string
54512 &name, const Sparsity &sp, casadi_int p) "
54513 
54514 Create a vector of length p with with matrices with symbolic primitives of
54515 given sparsity.
54516 
54517 ";
54518 
54519 %feature("docstring")  casadi::GenericMatrixCommon::sym(const std::string
54520 &name, casadi_int nrow, casadi_int ncol, casadi_int p) "
54521 
54522 Create a vector of length p with nrow-by-ncol symbolic primitives.
54523 
54524 ";
54525 
54526 %feature("docstring")  casadi::GenericMatrixCommon::sym(const std::string
54527 &name, const Sparsity &sp, casadi_int p, casadi_int r) "
54528 
54529 Create a vector of length r of vectors of length p with symbolic primitives
54530 with given sparsity.
54531 
54532 ";
54533 
54534 %feature("docstring")  casadi::GenericMatrixCommon::sym(const std::string
54535 &name, casadi_int nrow, casadi_int ncol, casadi_int p, casadi_int r) "
54536 
54537 Create a vector of length r of vectors of length p with nrow-by-ncol
54538 symbolic primitives.
54539 
54540 ";
54541 
54542 %feature("docstring")  casadi::GenericMatrixCommon::is_vector() const "
54543 
54544 Check if the matrix is a row or column vector.
54545 
54546 ";
54547 
54548 %feature("docstring")  casadi::MatrixCommon::matrix_matrix(casadi_int op,
54549 const MatrixCommon &x, const MatrixCommon &y) "
54550 
54551 [INTERNAL]  Create nodes by their ID.
54552 
54553 ";
54554 
54555 %feature("docstring")  casadi::MatrixCommon::binary(casadi_int op, const
54556 MatrixCommon &x, const MatrixCommon &y) "
54557 
54558 [INTERNAL]  Create nodes by their ID.
54559 
54560 ";
54561 
54562 %feature("docstring")  casadi::MatrixCommon::set_scientific(bool scientific)
54563 "
54564 
54565 Set the 'precision, width & scientific' used in printing and serializing to
54566 streams.
54567 
54568 ";
54569 
54570 %feature("docstring")  casadi::MatrixCommon::get_nonzeros() const  "
54571 
54572 Get all nonzeros.
54573 
54574 Implementation of Matrix::get_nonzeros (in public API)
54575 
54576 ";
54577 
54578 %feature("docstring")  casadi::MatrixCommon::disp(std::ostream &stream, bool
54579 more=false) const  "
54580 
54581 Print a representation of the object.
54582 
54583 ";
54584 
54585 %feature("docstring")  casadi::SX::has_duplicates() const  "
54586 
54587 [INTERNAL]  Detect duplicate symbolic expressions If there are symbolic
54588 primitives appearing more than once, the function will return true and the
54589 names of the duplicate expressions will be passed to casadi_warning. Note:
54590 Will mark the node using SXElem::set_temp. Make sure to call reset_input()
54591 after usage.
54592 
54593 ";
54594 
54595 %feature("docstring")  casadi::SX::name() const  "
54596 
54597 Get name (only if symbolic scalar)
54598 
54599 ";
54600 
54601 %feature("docstring")  casadi::MatrixCommon::sparsify(const MatrixCommon &A,
54602 double tol=0) "
54603 
54604 Make a matrix sparse by removing numerical zeros.
54605 
54606 ";
54607 
54608 %feature("docstring") casadi::casadi_sparsify "
54609 
54610 Make a matrix sparse by removing numerical zeros.
54611 
54612 ";
54613 
54614 %feature("docstring")  casadi::MatrixCommon::casadi_sparsify "
54615 
54616 Make a matrix sparse by removing numerical zeros.
54617 
54618 ";
54619 
54620 %feature("docstring")  casadi::GenericMatrixCommon::is_scalar(bool
54621 scalar_and_dense=false) const "
54622 
54623 Check if the matrix expression is scalar.
54624 
54625 ";
54626 
54627 %feature("docstring")  casadi::GenericMatrixCommon::get_colind() const "
54628 
54629 Get the sparsity pattern. See the Sparsity class for details.
54630 
54631 ";
54632 
54633 %feature("docstring")  casadi::MatrixCommon::ldl_solve(const MatrixCommon
54634 &b, const MatrixCommon &D, const MatrixCommon &LT, const std::vector<
54635 casadi_int > &p) "
54636 
54637 Solve using a sparse LDL^T factorization.
54638 
54639 ";
54640 
54641 %feature("docstring") casadi::casadi_ldl_solve "
54642 
54643 Solve using a sparse LDL^T factorization.
54644 
54645 ";
54646 
54647 %feature("docstring")  casadi::MatrixCommon::casadi_ldl_solve "
54648 
54649 Solve using a sparse LDL^T factorization.
54650 
54651 ";
54652 
54653 
54654 // File: classcasadi_1_1MinusInfSX.xml
54655 
54656 
54657 // File: classcasadi_1_1MinusOneSX.xml
54658 
54659 
54660 // File: classcasadi_1_1MMax.xml
54661 
54662 
54663 // File: classcasadi_1_1MMin.xml
54664 
54665 
54666 // File: classcasadi_1_1Monitor.xml
54667 
54668 
54669 // File: classcasadi_1_1MultipleOutput.xml
54670 
54671 
54672 // File: classcasadi_1_1Multiplication.xml
54673 
54674 
54675 // File: classcasadi_1_1MX.xml
54676 
54677 
54678 /*  Construct symbolic primitives  */
54679 
54680 /* The \"sym\" function is intended to work in a similar way as \"sym\" used
54681 in the Symbolic Toolbox for Matlab but instead creating a CasADi symbolic
54682 primitive.
54683 
54684 */ %feature("docstring")  casadi::MX::get_output(casadi_int oind) const  "
54685 
54686 Get an output.
54687 
54688 ";
54689 
54690 %feature("docstring")  casadi::SharedObject::disp(std::ostream &stream, bool
54691 more=false) const  "
54692 
54693 Print a description of the object.
54694 
54695 ";
54696 
54697 %feature("docstring")  casadi::MX::attachAssert(const MX &y, const
54698 std::string &fail_message="") const  "
54699 
54700 returns itself, but with an assertion attached
54701 
54702 If y does not evaluate to 1, a runtime error is raised
54703 
54704 ";
54705 
54706 %feature("docstring")  casadi::GenericMatrixCommon::jtimes(const MX &ex,
54707 const MX &arg, const MX &v, bool tr=false, const Dict &opts=Dict()) "
54708 
54709 Functions called by friend functions defined here
54710 
54711 ";
54712 
54713 %feature("docstring") casadi::MX "
54714 
54715 MX - Matrix expression.
54716 
54717 The MX class is used to build up trees made up from MXNodes. It is a more
54718 general graph representation than the scalar expression, SX, and much less
54719 efficient for small objects. On the other hand, the class allows much more
54720 general operations than does SX, in particular matrix valued operations and
54721 calls to arbitrary differentiable functions.
54722 
54723 The MX class is designed to have identical syntax with the Matrix<> template
54724 class, and uses DM (i.e. Matrix<double>) as its internal representation of
54725 the values at a node. By keeping the syntaxes identical, it is possible to
54726 switch from one class to the other, as well as inlining MX functions to
54727 SXElem functions.
54728 
54729 Note that an operation is always \"lazy\", making a matrix multiplication
54730 will create a matrix multiplication node, not perform the actual
54731 multiplication.
54732 
54733 Joel Andersson
54734 
54735 C++ includes: mx.hpp ";
54736 
54737 %feature("docstring")  casadi::MX::bspline_dual(const std::vector< double >
54738 &x, const std::vector< std::vector< double > > &knots, const std::vector<
54739 casadi_int > &degree, const Dict &opts=Dict()) "
54740 
54741 Find first nonzero If failed, returns the number of rows.
54742 
54743 ";
54744 
54745 %feature("docstring")  casadi::MX::erase(const std::vector< casadi_int >
54746 &rr, const std::vector< casadi_int > &cc, bool ind1=false) "
54747 
54748 Erase a submatrix (leaving structural zeros in its place) Erase rows and/or
54749 columns of a matrix.
54750 
54751 ";
54752 
54753 %feature("docstring")  casadi::MX::erase(const std::vector< casadi_int >
54754 &rr, bool ind1=false) "
54755 
54756 Erase a submatrix (leaving structural zeros in its place) Erase elements of
54757 a matrix.
54758 
54759 ";
54760 
54761 %feature("docstring")  casadi::MX::monitor(const std::string &comment) const
54762 "
54763 
54764 Monitor an expression Returns itself, but with the side effect of printing
54765 the nonzeros along with a comment.
54766 
54767 ";
54768 
54769 %feature("docstring")  casadi::MX::primitives() const  "
54770 
54771 Get primitives.
54772 
54773 ";
54774 
54775 %feature("docstring")  casadi::SharedObject::print_ptr(std::ostream
54776 &stream=casadi::uout()) const  "
54777 
54778 [INTERNAL]  Print the pointer to the internal class
54779 
54780 ";
54781 
54782 %feature("docstring")  casadi::GenericMatrixCommon::columns() const "
54783 
54784 Get the number of columns, Octave-style syntax.
54785 
54786 ";
54787 
54788 %feature("docstring")  casadi::MX::is_constant() const  "
54789 
54790 Check if constant.
54791 
54792 ";
54793 
54794 %feature("docstring")  casadi::MX::is_output() const  "
54795 
54796 Check if evaluation output.
54797 
54798 ";
54799 
54800 %feature("docstring")  casadi::MX::set(const MX &m, bool ind1, const Slice
54801 &rr) "
54802 
54803 Set a submatrix, single argument
54804 
54805 ";
54806 
54807 %feature("docstring")  casadi::MX::set(const MX &m, bool ind1, const
54808 MatrixCommon &rr) "
54809 
54810 Set a submatrix, single argument
54811 
54812 ";
54813 
54814 %feature("docstring")  casadi::MX::set(const MX &m, bool ind1, const
54815 Sparsity &sp) "
54816 
54817 Set a submatrix, single argument
54818 
54819 ";
54820 
54821 %feature("docstring")  casadi::MX::is_valid_input() const  "
54822 
54823 Check if matrix can be used to define function inputs. Valid inputs for
54824 MXFunctions are combinations of Reshape, concatenations and SymbolicMX.
54825 
54826 ";
54827 
54828 %feature("docstring")  casadi::MX::evalf(const MX &expr) "
54829 
54830 [INTERNAL]  Evaluates the expression numerically.
54831 
54832 An error is raised when the expression contains symbols
54833 
54834 ";
54835 
54836 %feature("docstring") casadi::casadi_evalf "
54837 
54838 Evaluates the expression numerically.
54839 
54840 An error is raised when the expression contains symbols
54841 
54842 ";
54843 
54844 %feature("docstring")  casadi::MX::casadi_evalf "
54845 
54846 Evaluates the expression numerically.
54847 
54848 An error is raised when the expression contains symbols
54849 
54850 ";
54851 
54852 %feature("docstring")  casadi::MX::inv_node(const MX &x) "
54853 
54854 [INTERNAL]   Inverse node.
54855 
54856 ";
54857 
54858 %feature("docstring") casadi::casadi_inv_node "
54859 
54860 Inverse node.
54861 
54862 ";
54863 
54864 %feature("docstring")  casadi::MX::casadi_inv_node "
54865 
54866 Inverse node.
54867 
54868 ";
54869 
54870 %feature("docstring")  casadi::MX::binary(casadi_int op, const MX &x, const
54871 MX &y) "
54872 
54873 Create nodes by their ID.
54874 
54875 ";
54876 
54877 %feature("docstring")  casadi::GenericMatrixCommon::sparsity() const "
54878 
54879 Get the sparsity pattern.
54880 
54881 ";
54882 
54883 %feature("docstring") casadi::casadi_sparsity "
54884 
54885 Get the sparsity pattern.
54886 
54887 ";
54888 
54889 %feature("docstring")  casadi::GenericMatrixCommon::casadi_sparsity "
54890 
54891 Get the sparsity pattern.
54892 
54893 ";
54894 
54895 %feature("docstring")  casadi::GenericMatrixCommon::is_tril() const "
54896 
54897 Check if the matrix is lower triangular.
54898 
54899 ";
54900 
54901 %feature("docstring")  casadi::GenericMatrixCommon::gradient(const MX &ex,
54902 const MX &arg, const Dict &opts=Dict()) "
54903 
54904 Functions called by friend functions defined here
54905 
54906 ";
54907 
54908 %feature("docstring")  casadi::MX::n_out() const  "
54909 
54910 Number of outputs.
54911 
54912 ";
54913 
54914 %feature("docstring")  casadi::GenericMatrixCommon::size1() const "
54915 
54916 Get the first dimension (i.e. number of rows)
54917 
54918 ";
54919 
54920 %feature("docstring")  casadi::GenericMatrixCommon::linearize(const MX &f,
54921 const MX &x, const MX &x0, const Dict &opts=Dict()) "
54922 
54923 Functions called by friend functions defined here
54924 
54925 ";
54926 
54927 %feature("docstring")  casadi::MX::is_op(casadi_int op) const  "
54928 
54929 Is it a certain operation.
54930 
54931 ";
54932 
54933 %feature("docstring")  casadi::GenericMatrixCommon::is_triu() const "
54934 
54935 Check if the matrix is upper triangular.
54936 
54937 ";
54938 
54939 %feature("docstring") casadi::MX::~MX "
54940 
54941 [INTERNAL]  Destructor.
54942 
54943 ";
54944 
54945 %feature("docstring")  casadi::MX::lift(const MX &x, const MX &x_guess) "
54946 
54947 [INTERNAL]  Lift the expression Experimental feature.
54948 
54949 ";
54950 
54951 %feature("docstring")  casadi::MX::set_nz(const MX &m, bool ind1, const
54952 Slice &kk) "
54953 
54954 Set a set of nonzeros
54955 
54956 ";
54957 
54958 %feature("docstring")  casadi::MX::set_nz(const MX &m, bool ind1, const
54959 MatrixCommon &kk) "
54960 
54961 Set a set of nonzeros
54962 
54963 ";
54964 
54965 %feature("docstring")  casadi::MX::set_nz(const MX &m, bool ind1, const MX
54966 &kk) "
54967 
54968 Set a set of nonzeros
54969 
54970 ";
54971 
54972 %feature("docstring")  casadi::MX::set_nz(const MX &m, bool ind1, casadi_int
54973 kk) "
54974 
54975 Set a set of nonzeros
54976 
54977 ";
54978 
54979 %feature("docstring")  casadi::GenericMatrixCommon::size2() const "
54980 
54981 Get the second dimension (i.e. number of columns)
54982 
54983 ";
54984 
54985 %feature("docstring")  casadi::MX::set_temp(casadi_int t) const  "
54986 
54987 [INTERNAL]  Set the temporary variable.
54988 
54989 ";
54990 
54991 %feature("docstring")  casadi::GenericMatrixCommon::rows() const "
54992 
54993 Get the number of rows, Octave-style syntax.
54994 
54995 ";
54996 
54997 %feature("docstring")  casadi::MX::is_one() const  "
54998 
54999 check if zero (note that false negative answers are possible)
55000 
55001 ";
55002 
55003 %feature("docstring")  casadi::GenericMatrixCommon::is_empty(bool
55004 both=false) const "
55005 
55006 Check if the sparsity is empty, i.e. if one of the dimensions is zero (or
55007 optionally both dimensions)
55008 
55009 ";
55010 
55011 %feature("docstring")  casadi::MX::get_nz(MX &output_m, bool ind1, const
55012 Slice &kk) const  "
55013 
55014 Get a set of nonzeros
55015 
55016 ";
55017 
55018 %feature("docstring")  casadi::MX::get_nz(MX &output_m, bool ind1, const
55019 MatrixCommon &kk) const  "
55020 
55021 Get a set of nonzeros
55022 
55023 ";
55024 
55025 %feature("docstring")  casadi::MX::get_nz(MX &output_m, bool ind1, const MX
55026 &kk) const  "
55027 
55028 Get a set of nonzeros
55029 
55030 ";
55031 
55032 %feature("docstring")  casadi::MX::get_nz(MX &output_m, bool ind1,
55033 casadi_int kk) const  "
55034 
55035 Get a set of nonzeros
55036 
55037 ";
55038 
55039 %feature("docstring")  casadi::MX::get_nz(MX &output_m, bool ind1, const MX
55040 &inner, const Slice &outer) const  "
55041 
55042 Get a set of nonzeros
55043 
55044 ";
55045 
55046 %feature("docstring")  casadi::MX::get_nz(MX &output_m, bool ind1, const
55047 Slice &inner, const MX &outer) const  "
55048 
55049 Get a set of nonzeros
55050 
55051 ";
55052 
55053 %feature("docstring")  casadi::MX::get_nz(MX &output_m, bool ind1, const MX
55054 &inner, const MX &outer) const  "
55055 
55056 Get a set of nonzeros
55057 
55058 ";
55059 
55060 %feature("docstring")  casadi::MX::low(const MX &v, const MX &p, const Dict
55061 &options=Dict()) "
55062 
55063 [INTERNAL]   Find first nonzero If failed, returns the number of rows.
55064 
55065 ";
55066 
55067 %feature("docstring") casadi::casadi_low "
55068 
55069 Find first nonzero If failed, returns the number of rows.
55070 
55071 ";
55072 
55073 %feature("docstring")  casadi::MX::casadi_low "
55074 
55075 Find first nonzero If failed, returns the number of rows.
55076 
55077 ";
55078 
55079 %feature("docstring")  casadi::GenericMatrixCommon::ones(casadi_int nrow=1,
55080 casadi_int ncol=1) "
55081 
55082 Create a dense matrix or a matrix with specified sparsity with all entries
55083 one.
55084 
55085 ";
55086 
55087 %feature("docstring")  casadi::GenericMatrixCommon::ones(const Sparsity &sp)
55088 "
55089 
55090 Create a dense matrix or a matrix with specified sparsity with all entries
55091 one.
55092 
55093 ";
55094 
55095 %feature("docstring")  casadi::GenericMatrixCommon::ones(const std::pair<
55096 casadi_int, casadi_int > &rc) "
55097 
55098 Create a dense matrix or a matrix with specified sparsity with all entries
55099 one.
55100 
55101 ";
55102 
55103 %feature("docstring")  casadi::MX::is_transpose() const  "
55104 
55105 Is the expression a transpose?
55106 
55107 ";
55108 
55109 %feature("docstring")  casadi::GenericMatrixCommon::is_scalar(bool
55110 scalar_and_dense=false) const "
55111 
55112 Check if the matrix expression is scalar.
55113 
55114 ";
55115 
55116 %feature("docstring")  casadi::MX::is_binary() const  "
55117 
55118 Is binary operation.
55119 
55120 ";
55121 
55122 %feature("docstring")  casadi::MX::convexify(const MX &H, const Dict
55123 &opts=Dict()) "
55124 
55125 [INTERNAL]   Find first nonzero If failed, returns the number of rows.
55126 
55127 ";
55128 
55129 %feature("docstring") casadi::casadi_convexify "
55130 
55131 Find first nonzero If failed, returns the number of rows.
55132 
55133 ";
55134 
55135 %feature("docstring")  casadi::MX::casadi_convexify "
55136 
55137 Find first nonzero If failed, returns the number of rows.
55138 
55139 ";
55140 
55141 %feature("docstring")  casadi::MX::inf(const Sparsity &sp) "
55142 
55143 create a matrix with all inf
55144 
55145 ";
55146 
55147 %feature("docstring")  casadi::MX::inf(casadi_int nrow=1, casadi_int ncol=1)
55148 "
55149 
55150 create a matrix with all inf
55151 
55152 ";
55153 
55154 %feature("docstring")  casadi::MX::inf(const std::pair< casadi_int,
55155 casadi_int > &rc) "
55156 
55157 create a matrix with all inf
55158 
55159 ";
55160 
55161 %feature("docstring")  casadi::GenericMatrixCommon::colind(casadi_int col)
55162 const "
55163 
55164 Get the sparsity pattern. See the Sparsity class for details.
55165 
55166 ";
55167 
55168 %feature("docstring")  casadi::MX::is_symbolic() const  "
55169 
55170 Check if symbolic.
55171 
55172 ";
55173 
55174 %feature("docstring")  casadi::MX::is_eye() const  "
55175 
55176 check if identity
55177 
55178 ";
55179 
55180 %feature("docstring")  casadi::MX::join_primitives(const std::vector< MX >
55181 &v) const  "
55182 
55183 Join an expression along symbolic primitives.
55184 
55185 ";
55186 
55187 %feature("docstring")  casadi::MX::reset_input() const  "
55188 
55189 [INTERNAL]  Reset the marker for an input expression.
55190 
55191 ";
55192 
55193 %feature("docstring")  casadi::GenericMatrixCommon::get_colind() const "
55194 
55195 Get the sparsity pattern. See the Sparsity class for details.
55196 
55197 ";
55198 
55199 %feature("docstring")  casadi::SharedObject::is_null() const  "
55200 
55201 Is a null pointer?
55202 
55203 ";
55204 
55205 %feature("docstring")  casadi::MX::is_multiplication() const  "
55206 
55207 Check if multiplication.
55208 
55209 ";
55210 
55211 %feature("docstring")  casadi::GenericMatrixCommon::nnz() const "
55212 
55213 Get the number of (structural) non-zero elements.
55214 
55215 ";
55216 
55217 %feature("docstring")  casadi::MX::find(const MX &x) "
55218 
55219 [INTERNAL]   Find first nonzero If failed, returns the number of rows.
55220 
55221 ";
55222 
55223 %feature("docstring") casadi::casadi_find "
55224 
55225 Find first nonzero If failed, returns the number of rows.
55226 
55227 ";
55228 
55229 %feature("docstring")  casadi::MX::casadi_find "
55230 
55231 Find first nonzero If failed, returns the number of rows.
55232 
55233 ";
55234 
55235 %feature("docstring")  casadi::GenericMatrixCommon::dim(bool with_nz=false)
55236 const "
55237 
55238 Get string representation of dimensions. The representation is e.g. \"4x5\"
55239 or \"4x5,10nz\".
55240 
55241 ";
55242 
55243 %feature("docstring")  casadi::MX::is_minus_one() const  "
55244 
55245 check if zero (note that false negative answers are possible)
55246 
55247 ";
55248 
55249 %feature("docstring")  casadi::GenericMatrixCommon::get_row() const "
55250 
55251 Get the sparsity pattern. See the Sparsity class for details.
55252 
55253 ";
55254 
55255 %feature("docstring")  casadi::MX::is_call() const  "
55256 
55257 Check if evaluation.
55258 
55259 ";
55260 
55261 %feature("docstring")  casadi::GenericMatrixCommon::nnz_upper() const "
55262 
55263 Get the number of non-zeros in the upper triangular half.
55264 
55265 ";
55266 
55267 %feature("docstring")  casadi::MX::get_temp() const  "
55268 
55269 [INTERNAL]  Get the temporary variable
55270 
55271 ";
55272 
55273 %feature("docstring") casadi::MX::__hash__ "
55274 
55275 Returns a number that is unique for a given Node. If the Object does not
55276 point to any node, \"0\" is returned.
55277 
55278 ";
55279 
55280 %feature("docstring")  casadi::GenericMatrixCommon::zeros(casadi_int nrow=1,
55281 casadi_int ncol=1) "
55282 
55283 Create a dense matrix or a matrix with specified sparsity with all entries
55284 zero.
55285 
55286 ";
55287 
55288 %feature("docstring")  casadi::GenericMatrixCommon::zeros(const Sparsity
55289 &sp) "
55290 
55291 Create a dense matrix or a matrix with specified sparsity with all entries
55292 zero.
55293 
55294 ";
55295 
55296 %feature("docstring")  casadi::GenericMatrixCommon::zeros(const std::pair<
55297 casadi_int, casadi_int > &rc) "
55298 
55299 Create a dense matrix or a matrix with specified sparsity with all entries
55300 zero.
55301 
55302 ";
55303 
55304 %feature("docstring")  casadi::MX::is_zero() const  "
55305 
55306 check if zero (note that false negative answers are possible)
55307 
55308 ";
55309 
55310 %feature("docstring")  casadi::SharedObject::get_str(bool more=false) const
55311 "
55312 
55313 Get string representation.
55314 
55315 ";
55316 
55317 %feature("docstring")  casadi::GenericMatrixCommon::size() const "
55318 
55319 Get the shape.
55320 
55321 ";
55322 
55323 %feature("docstring")  casadi::GenericMatrixCommon::size(casadi_int axis)
55324 const "
55325 
55326 Get the size along a particular dimensions.
55327 
55328 ";
55329 
55330 %feature("docstring")  casadi::MX::T() const  "
55331 
55332 Transpose the matrix.
55333 
55334 ";
55335 
55336 %feature("docstring")  casadi::GenericMatrixCommon::is_vector() const "
55337 
55338 Check if the matrix is a row or column vector.
55339 
55340 ";
55341 
55342 %feature("docstring")  casadi::MX::matrix_expand(const MX &e, const
55343 std::vector< MX > &boundary=std::vector< MX >(), const Dict &options=Dict())
55344 "
55345 
55346 [INTERNAL]  Expand MX graph to SXFunction call.
55347 
55348 Expand the given expression e, optionally supplying expressions contained in
55349 it at which expansion should stop.
55350 
55351 ";
55352 
55353 %feature("docstring") casadi::casadi_matrix_expand "
55354 
55355 Expand MX graph to SXFunction call.
55356 
55357 Expand the given expression e, optionally supplying expressions contained in
55358 it at which expansion should stop.
55359 
55360 ";
55361 
55362 %feature("docstring")  casadi::MX::casadi_matrix_expand "
55363 
55364 Expand MX graph to SXFunction call.
55365 
55366 Expand the given expression e, optionally supplying expressions contained in
55367 it at which expansion should stop.
55368 
55369 ";
55370 
55371 %feature("docstring")  casadi::MX::matrix_expand(const std::vector< MX > &e,
55372 const std::vector< MX > &boundary=std::vector< MX >(), const Dict
55373 &options=Dict()) "
55374 
55375 [INTERNAL]  Expand MX graph to SXFunction call.
55376 
55377 Expand the given expression e, optionally supplying expressions contained in
55378 it at which expansion should stop.
55379 
55380 ";
55381 
55382 %feature("docstring") casadi::casadi_matrix_expand "
55383 
55384 Expand MX graph to SXFunction call.
55385 
55386 Expand the given expression e, optionally supplying expressions contained in
55387 it at which expansion should stop.
55388 
55389 ";
55390 
55391 %feature("docstring")  casadi::MX::casadi_matrix_expand "
55392 
55393 Expand MX graph to SXFunction call.
55394 
55395 Expand the given expression e, optionally supplying expressions contained in
55396 it at which expansion should stop.
55397 
55398 ";
55399 
55400 %feature("docstring")  casadi::MX::nan(const Sparsity &sp) "
55401 
55402 create a matrix with all nan
55403 
55404 ";
55405 
55406 %feature("docstring")  casadi::MX::nan(casadi_int nrow=1, casadi_int ncol=1)
55407 "
55408 
55409 create a matrix with all nan
55410 
55411 ";
55412 
55413 %feature("docstring")  casadi::MX::nan(const std::pair< casadi_int,
55414 casadi_int > &rc) "
55415 
55416 create a matrix with all nan
55417 
55418 ";
55419 
55420 %feature("docstring")  casadi::GenericMatrixCommon::row(casadi_int el) const
55421 "
55422 
55423 Get the sparsity pattern. See the Sparsity class for details.
55424 
55425 ";
55426 
55427 %feature("docstring")  casadi::MX::n_dep() const  "
55428 
55429 Get the number of dependencies of a binary SXElem.
55430 
55431 ";
55432 
55433 %feature("docstring")  casadi::MX::bspline(const MX &x, const DM &coeffs,
55434 const std::vector< std::vector< double > > &knots, const std::vector<
55435 casadi_int > &degree, casadi_int m, const Dict &opts=Dict()) "
55436 
55437 [INTERNAL]   Find first nonzero If failed, returns the number of rows.
55438 
55439 ";
55440 
55441 %feature("docstring") casadi::casadi_bspline "
55442 
55443 Find first nonzero If failed, returns the number of rows.
55444 
55445 ";
55446 
55447 %feature("docstring")  casadi::MX::casadi_bspline "
55448 
55449 Find first nonzero If failed, returns the number of rows.
55450 
55451 ";
55452 
55453 %feature("docstring")  casadi::MX::bspline(const MX &x, const MX &coeffs,
55454 const std::vector< std::vector< double > > &knots, const std::vector<
55455 casadi_int > &degree, casadi_int m, const Dict &opts=Dict()) "
55456 
55457 [INTERNAL]   Find first nonzero If failed, returns the number of rows.
55458 
55459 ";
55460 
55461 %feature("docstring") casadi::casadi_bspline "
55462 
55463 Find first nonzero If failed, returns the number of rows.
55464 
55465 ";
55466 
55467 %feature("docstring")  casadi::MX::casadi_bspline "
55468 
55469 Find first nonzero If failed, returns the number of rows.
55470 
55471 ";
55472 
55473 %feature("docstring")  casadi::MX::has_duplicates() const  "
55474 
55475 [INTERNAL]  Detect duplicate symbolic expressions If there are symbolic
55476 primitives appearing more than once, the function will return true and the
55477 names of the duplicate expressions will be passed to casadi_warning. Note:
55478 Will mark the node using MX::set_temp. Make sure to call reset_input() after
55479 usage.
55480 
55481 ";
55482 
55483 %feature("docstring")  casadi::SharedObject::class_name() const  "
55484 
55485 Get class name.
55486 
55487 ";
55488 
55489 %feature("docstring")  casadi::MX::is_norm() const  "
55490 
55491 Check if norm.
55492 
55493 ";
55494 
55495 %feature("docstring")  casadi::GenericMatrixCommon::mpower(const MX &x,
55496 const MX &y) "
55497 
55498 Functions called by friend functions defined here
55499 
55500 ";
55501 
55502 %feature("docstring")  casadi::GenericMatrixCommon::numel() const "
55503 
55504 Get the number of elements.
55505 
55506 ";
55507 
55508 %feature("docstring")  casadi::MX::enlarge(casadi_int nrow, casadi_int ncol,
55509 const std::vector< casadi_int > &rr, const std::vector< casadi_int > &cc,
55510 bool ind1=false) "
55511 
55512 Enlarge matrix Make the matrix larger by inserting empty rows and columns,
55513 keeping the existing non-zeros.
55514 
55515 ";
55516 
55517 %feature("docstring")  casadi::GenericMatrixCommon::sym(const std::string
55518 &name, casadi_int nrow=1, casadi_int ncol=1) "
55519 
55520 Create an nrow-by-ncol symbolic primitive.
55521 
55522 ";
55523 
55524 %feature("docstring")  casadi::GenericMatrixCommon::sym(const std::string
55525 &name, const std::pair< casadi_int, casadi_int > &rc) "
55526 
55527 Construct a symbolic primitive with given dimensions.
55528 
55529 ";
55530 
55531 %feature("docstring")  casadi::GenericMatrixCommon::sym(const std::string
55532 &name, const Sparsity &sp) "
55533 
55534 Create symbolic primitive with a given sparsity pattern.
55535 
55536 ";
55537 
55538 %feature("docstring")  casadi::GenericMatrixCommon::sym(const std::string
55539 &name, const Sparsity &sp, casadi_int p) "
55540 
55541 Create a vector of length p with with matrices with symbolic primitives of
55542 given sparsity.
55543 
55544 ";
55545 
55546 %feature("docstring")  casadi::GenericMatrixCommon::sym(const std::string
55547 &name, casadi_int nrow, casadi_int ncol, casadi_int p) "
55548 
55549 Create a vector of length p with nrow-by-ncol symbolic primitives.
55550 
55551 ";
55552 
55553 %feature("docstring")  casadi::GenericMatrixCommon::sym(const std::string
55554 &name, const Sparsity &sp, casadi_int p, casadi_int r) "
55555 
55556 Create a vector of length r of vectors of length p with symbolic primitives
55557 with given sparsity.
55558 
55559 ";
55560 
55561 %feature("docstring")  casadi::GenericMatrixCommon::sym(const std::string
55562 &name, casadi_int nrow, casadi_int ncol, casadi_int p, casadi_int r) "
55563 
55564 Create a vector of length r of vectors of length p with nrow-by-ncol
55565 symbolic primitives.
55566 
55567 ";
55568 
55569 %feature("docstring")  casadi::GenericMatrixCommon::tangent(const MX &ex,
55570 const MX &arg, const Dict &opts=Dict()) "
55571 
55572 Functions called by friend functions defined here
55573 
55574 ";
55575 
55576 %feature("docstring")  casadi::MX::serialize(SerializingStream &s) const  "
55577 
55578 Serialize an object.
55579 
55580 ";
55581 
55582 %feature("docstring")  casadi::GenericMatrixCommon::is_square() const "
55583 
55584 Check if the matrix expression is square.
55585 
55586 ";
55587 
55588 %feature("docstring")  casadi::MX::get(MX &output_m, bool ind1, const Slice
55589 &rr) const  "
55590 
55591 Get a submatrix, single argument
55592 
55593 ";
55594 
55595 %feature("docstring")  casadi::MX::get(MX &output_m, bool ind1, const
55596 MatrixCommon &rr) const  "
55597 
55598 Get a submatrix, single argument
55599 
55600 ";
55601 
55602 %feature("docstring")  casadi::MX::get(MX &output_m, bool ind1, const
55603 Sparsity &sp) const  "
55604 
55605 Get a submatrix, single argument
55606 
55607 ";
55608 
55609 %feature("docstring")  casadi::MX::get(MX &output_m, bool ind1, const MX
55610 &rr) const  "
55611 
55612 Get a submatrix, single argument
55613 
55614 ";
55615 
55616 %feature("docstring")  casadi::MX::get(MX &output_m, bool ind1, const
55617 casadi_int rr) const  "
55618 
55619 Get a submatrix, single argument
55620 
55621 ";
55622 
55623 %feature("docstring")  casadi::MX::get(MX &output_m, bool ind1, const Slice
55624 &rr, const Slice &cc) const  "
55625 
55626 Get a submatrix, two arguments
55627 
55628 ";
55629 
55630 %feature("docstring")  casadi::MX::get(MX &output_m, bool ind1, const Slice
55631 &rr, const MatrixCommon &cc) const  "
55632 
55633 Get a submatrix, two arguments
55634 
55635 ";
55636 
55637 %feature("docstring")  casadi::MX::get(MX &output_m, bool ind1, const Slice
55638 &rr, casadi_int cc) const  "
55639 
55640 Get a submatrix, two arguments
55641 
55642 ";
55643 
55644 %feature("docstring")  casadi::MX::get(MX &output_m, bool ind1, const
55645 MatrixCommon &rr, const Slice &cc) const  "
55646 
55647 Get a submatrix, two arguments
55648 
55649 ";
55650 
55651 %feature("docstring")  casadi::MX::get(MX &output_m, bool ind1, casadi_int
55652 rr, const Slice &cc) const  "
55653 
55654 Get a submatrix, two arguments
55655 
55656 ";
55657 
55658 %feature("docstring")  casadi::MX::get(MX &output_m, bool ind1, const
55659 MatrixCommon &rr, const MatrixCommon &cc) const  "
55660 
55661 Get a submatrix, two arguments
55662 
55663 ";
55664 
55665 %feature("docstring")  casadi::MX::get(MX &output_m, bool ind1, casadi_int
55666 rr, casadi_int cc) const  "
55667 
55668 Get a submatrix, two arguments
55669 
55670 ";
55671 
55672 %feature("docstring")  casadi::MX::get(MX &output_m, bool ind1, const MX
55673 &rr, const Slice &cc) const  "
55674 
55675 Get a submatrix, two arguments
55676 
55677 ";
55678 
55679 %feature("docstring")  casadi::MX::get(MX &output_m, bool ind1, const Slice
55680 &rr, const MX &cc) const  "
55681 
55682 Get a submatrix, two arguments
55683 
55684 ";
55685 
55686 %feature("docstring")  casadi::MX::get(MX &output_m, bool ind1, const MX
55687 &rr, const MX &cc) const  "
55688 
55689 Get a submatrix, two arguments
55690 
55691 ";
55692 
55693 %feature("docstring")  casadi::MX::einstein(const MX &A, const MX &B, const
55694 MX &C, const std::vector< casadi_int > &dim_a, const std::vector< casadi_int
55695 > &dim_b, const std::vector< casadi_int > &dim_c, const std::vector<
55696 casadi_int > &a, const std::vector< casadi_int > &b, const std::vector<
55697 casadi_int > &c) "
55698 
55699 Computes an einstein dense tensor contraction.
55700 
55701 Computes the product: C_c = A_a + B_b where a b c are index/einstein
55702 notation in an encoded form
55703 
55704 For example, an matrix-matrix product may be written as: C_ij = A_ik B_kj
55705 
55706 The encoded form uses strictly negative numbers to indicate labels. For the
55707 above example, we would have: a {-1, -3} b {-3, -2} c {-1 -2}
55708 
55709 ";
55710 
55711 %feature("docstring") casadi::casadi_einstein "
55712 
55713 Computes an einstein dense tensor contraction.
55714 
55715 Computes the product: C_c = A_a + B_b where a b c are index/einstein
55716 notation in an encoded form
55717 
55718 For example, an matrix-matrix product may be written as: C_ij = A_ik B_kj
55719 
55720 The encoded form uses strictly negative numbers to indicate labels. For the
55721 above example, we would have: a {-1, -3} b {-3, -2} c {-1 -2}
55722 
55723 ";
55724 
55725 %feature("docstring")  casadi::MX::casadi_einstein "
55726 
55727 Computes an einstein dense tensor contraction.
55728 
55729 Computes the product: C_c = A_a + B_b where a b c are index/einstein
55730 notation in an encoded form
55731 
55732 For example, an matrix-matrix product may be written as: C_ij = A_ik B_kj
55733 
55734 The encoded form uses strictly negative numbers to indicate labels. For the
55735 above example, we would have: a {-1, -3} b {-3, -2} c {-1 -2}
55736 
55737 ";
55738 
55739 %feature("docstring")  casadi::MX::einstein(const MX &A, const MX &B, const
55740 std::vector< casadi_int > &dim_a, const std::vector< casadi_int > &dim_b,
55741 const std::vector< casadi_int > &dim_c, const std::vector< casadi_int > &a,
55742 const std::vector< casadi_int > &b, const std::vector< casadi_int > &c) "
55743 
55744 Computes an einstein dense tensor contraction.
55745 
55746 Computes the product: C_c = A_a + B_b where a b c are index/einstein
55747 notation in an encoded form
55748 
55749 For example, an matrix-matrix product may be written as: C_ij = A_ik B_kj
55750 
55751 The encoded form uses strictly negative numbers to indicate labels. For the
55752 above example, we would have: a {-1, -3} b {-3, -2} c {-1 -2}
55753 
55754 ";
55755 
55756 %feature("docstring") casadi::casadi_einstein "
55757 
55758 Computes an einstein dense tensor contraction.
55759 
55760 Computes the product: C_c = A_a + B_b where a b c are index/einstein
55761 notation in an encoded form
55762 
55763 For example, an matrix-matrix product may be written as: C_ij = A_ik B_kj
55764 
55765 The encoded form uses strictly negative numbers to indicate labels. For the
55766 above example, we would have: a {-1, -3} b {-3, -2} c {-1 -2}
55767 
55768 ";
55769 
55770 %feature("docstring")  casadi::MX::casadi_einstein "
55771 
55772 Computes an einstein dense tensor contraction.
55773 
55774 Computes the product: C_c = A_a + B_b where a b c are index/einstein
55775 notation in an encoded form
55776 
55777 For example, an matrix-matrix product may be written as: C_ij = A_ik B_kj
55778 
55779 The encoded form uses strictly negative numbers to indicate labels. For the
55780 above example, we would have: a {-1, -3} b {-3, -2} c {-1 -2}
55781 
55782 ";
55783 
55784 %feature("docstring")  casadi::GenericMatrixCommon::is_column() const "
55785 
55786 Check if the matrix is a column vector (i.e. size2()==1)
55787 
55788 ";
55789 
55790 %feature("docstring") casadi::MX::__nonzero__ "
55791 
55792 Returns the truth value of an MX expression.
55793 
55794 ";
55795 
55796 %feature("docstring")  casadi::MX::name() const  "
55797 
55798 Get the name.
55799 
55800 ";
55801 
55802 %feature("docstring")  casadi::MX::info() const  "
55803 
55804 Obtain information about node
55805 
55806 ";
55807 
55808 %feature("docstring")  casadi::MX::which_function() const  "
55809 
55810 Get function - only valid when is_call() is true.
55811 
55812 ";
55813 
55814 %feature("docstring") casadi::MX::MX() "
55815 
55816 Default constructor.
55817 
55818 ";
55819 
55820 %feature("docstring") casadi::MX::MX(casadi_int nrow, casadi_int ncol) "
55821 
55822 Create a sparse matrix with all structural zeros.
55823 
55824 ";
55825 
55826 %feature("docstring") casadi::MX::MX(const Sparsity &sp) "
55827 
55828 Create a sparse matrix from a sparsity pattern. Same as MX::ones(sparsity)
55829 
55830 ";
55831 
55832 %feature("docstring") casadi::MX::MX(const Sparsity &sp, const MX &val) "
55833 
55834 Construct matrix with a given sparsity and nonzeros.
55835 
55836 ";
55837 
55838 %feature("docstring") casadi::MX::MX(const Sparsity &sp, const std::string
55839 &fname) "
55840 
55841 Construct matrix with a given sparsity and a file with nonzeros.
55842 
55843 ";
55844 
55845 %feature("docstring") casadi::MX::MX(double x) "
55846 
55847 Create scalar constant (also implicit type conversion)
55848 
55849 ";
55850 
55851 %feature("docstring") casadi::MX::MX(const MX &x) "
55852 
55853 Copy constructor.
55854 
55855 ";
55856 
55857 %feature("docstring") casadi::MX::MX(const MatrixCommon &x) "
55858 
55859 Create sparse matrix constant (also implicit type conversion)
55860 
55861 ";
55862 
55863 %feature("docstring")  casadi::GenericMatrixCommon::soc(const MX &x, const
55864 MX &y) "
55865 
55866 Functions called by friend functions defined here
55867 
55868 ";
55869 
55870 %feature("docstring")  casadi::GenericMatrixCommon::rank1(const MX &A, const
55871 MX &alpha, const MX &x, const MX &y) "
55872 
55873 Make a rank-1 update to a matrix A Calculates A + 1/2 * alpha * x*y'.
55874 
55875 ";
55876 
55877 %feature("docstring") casadi::casadi_rank1 "
55878 
55879 Make a rank-1 update to a matrix A Calculates A + 1/2 * alpha * x*y'.
55880 
55881 ";
55882 
55883 %feature("docstring")  casadi::GenericMatrixCommon::casadi_rank1 "
55884 
55885 Make a rank-1 update to a matrix A Calculates A + 1/2 * alpha * x*y'.
55886 
55887 ";
55888 
55889 %feature("docstring")  casadi::GenericMatrixCommon::bilin(const MX &A, const
55890 MX &x, const MX &y) "
55891 
55892 Calculate bilinear form x^T A y.
55893 
55894 ";
55895 
55896 %feature("docstring") casadi::casadi_bilin "
55897 
55898 Calculate bilinear form x^T A y.
55899 
55900 ";
55901 
55902 %feature("docstring")  casadi::GenericMatrixCommon::casadi_bilin "
55903 
55904 Calculate bilinear form x^T A y.
55905 
55906 ";
55907 
55908 %feature("docstring")  casadi::GenericMatrixCommon::nnz_lower() const "
55909 
55910 Get the number of non-zeros in the lower triangular half.
55911 
55912 ";
55913 
55914 %feature("docstring")  casadi::MX::is_unary() const  "
55915 
55916 Is unary operation.
55917 
55918 ";
55919 
55920 %feature("docstring")  casadi::MX::is_commutative() const  "
55921 
55922 Check if commutative operation.
55923 
55924 ";
55925 
55926 %feature("docstring")  casadi::MX::mapping() const  "
55927 
55928 Get an IM representation of a GetNonzeros or SetNonzeros node.
55929 
55930 ";
55931 
55932 %feature("docstring")  casadi::MX::split_primitives(const MX &x) const  "
55933 
55934 Split up an expression along symbolic primitives.
55935 
55936 ";
55937 
55938 %feature("docstring")  casadi::MX::graph_substitute(const MX &ex, const
55939 std::vector< MX > &v, const std::vector< MX > &vdef) "
55940 
55941 [INTERNAL]  Substitute single expression in graph Substitute variable v with
55942 expression vdef in an expression ex, preserving nodes.
55943 
55944 ";
55945 
55946 %feature("docstring") casadi::casadi_graph_substitute "
55947 
55948 Substitute single expression in graph Substitute variable v with expression
55949 vdef in an expression ex, preserving nodes.
55950 
55951 ";
55952 
55953 %feature("docstring")  casadi::MX::casadi_graph_substitute "
55954 
55955 Substitute single expression in graph Substitute variable v with expression
55956 vdef in an expression ex, preserving nodes.
55957 
55958 ";
55959 
55960 %feature("docstring")  casadi::MX::graph_substitute(const std::vector< MX >
55961 &ex, const std::vector< MX > &v, const std::vector< MX > &vdef) "
55962 
55963 [INTERNAL]  Substitute multiple expressions in graph Substitute variable var
55964 with expression expr in multiple expressions, preserving nodes.
55965 
55966 ";
55967 
55968 %feature("docstring") casadi::casadi_graph_substitute "
55969 
55970 Substitute multiple expressions in graph Substitute variable var with
55971 expression expr in multiple expressions, preserving nodes.
55972 
55973 ";
55974 
55975 %feature("docstring")  casadi::MX::casadi_graph_substitute "
55976 
55977 Substitute multiple expressions in graph Substitute variable var with
55978 expression expr in multiple expressions, preserving nodes.
55979 
55980 ";
55981 
55982 %feature("docstring")  casadi::GenericMatrixCommon::is_dense() const "
55983 
55984 Check if the matrix expression is dense.
55985 
55986 ";
55987 
55988 %feature("docstring")  casadi::MX::op() const  "
55989 
55990 Get operation type.
55991 
55992 ";
55993 
55994 %feature("docstring")  casadi::MX::n_primitives() const  "
55995 
55996 Get the number of primitives for MXFunction inputs/outputs.
55997 
55998 ";
55999 
56000 %feature("docstring")  casadi::MX::dep(casadi_int ch=0) const  "
56001 
56002 Get the nth dependency as MX.
56003 
56004 ";
56005 
56006 %feature("docstring")  casadi::MX::get_sparsity() const  "
56007 
56008 Get an owning reference to the sparsity pattern.
56009 
56010 ";
56011 
56012 %feature("docstring")  casadi::GenericMatrixCommon::nnz_diag() const "
56013 
56014 Get get the number of non-zeros on the diagonal.
56015 
56016 ";
56017 
56018 %feature("docstring")  casadi::MX::unary(casadi_int op, const MX &x) "
56019 
56020 Create nodes by their ID.
56021 
56022 ";
56023 
56024 %feature("docstring")  casadi::MX::which_output() const  "
56025 
56026 Get the index of evaluation output - only valid when is_output() is true.
56027 
56028 ";
56029 
56030 %feature("docstring")  casadi::MX::is_regular() const  "
56031 
56032 Checks if expression does not contain NaN or Inf.
56033 
56034 ";
56035 
56036 %feature("docstring")  casadi::GenericMatrixCommon::is_row() const "
56037 
56038 Check if the matrix is a row vector (i.e. size1()==1)
56039 
56040 ";
56041 
56042 
56043 // File: classcasadi_1_1MXFunction.xml
56044 
56045 
56046 // File: classcasadi_1_1NanSX.xml
56047 
56048 
56049 // File: classcasadi_1_1Newton.xml
56050 %feature("docstring")  casadi::ProtoFunction::print(const char *fmt,...)
56051 const  "
56052 
56053 [INTERNAL]  C-style formatted printing during evaluation.
56054 
56055 ";
56056 
56057 %feature("docstring")  casadi::FunctionInternal::get_max_in(casadi_int ind)
56058 const  "
56059 
56060 [INTERNAL]  Get largest input value.
56061 
56062 ";
56063 
56064 %feature("docstring")
56065 casadi::FunctionInternal::codegen_alloc_mem(CodeGenerator &g) const  "
56066 
56067 [INTERNAL]  Codegen decref for alloc_mem.
56068 
56069 ";
56070 
56071 %feature("docstring")  casadi::OracleFunction::jit_dependencies(const
56072 std::string &fname)  "
56073 
56074 [INTERNAL]  JIT for dependencies.
56075 
56076 ";
56077 
56078 %feature("docstring")  casadi::FunctionInternal::print_options(std::ostream
56079 &stream) const  "
56080 
56081 [INTERNAL]  Print list of options.
56082 
56083 ";
56084 
56085 %feature("docstring")  casadi::FunctionInternal::tocache(const Function &f,
56086 const std::string &suffix="") const  "
56087 
56088 [INTERNAL]  Save function to cache.
56089 
56090 ";
56091 
56092 %feature("docstring")  casadi::FunctionInternal::symbolic_output(const
56093 std::vector< MX > &arg) const  "
56094 
56095 [INTERNAL]  Get a vector of symbolic variables corresponding to the outputs.
56096 
56097 ";
56098 
56099 %feature("docstring")  casadi::FunctionInternal::replace_fseed(const
56100 std::vector< std::vector< M >> &fseed, casadi_int npar) const  "
56101 
56102 [INTERNAL]  Replace 0-by-0 forward seeds.
56103 
56104 ";
56105 
56106 %feature("docstring")  casadi::FunctionInternal::replace_fseed(const
56107 std::vector< std::vector< M > > &fseed, casadi_int npar) const  "
56108 
56109 [INTERNAL] ";
56110 
56111 %feature("docstring")  casadi::ProtoFunction::clear_mem() "
56112 
56113 [INTERNAL]  Clear all memory (called from destructor)
56114 
56115 ";
56116 
56117 %feature("docstring") casadi::Newton::Newton(const std::string &name, const
56118 Function &f) "
56119 
56120 [INTERNAL]  Constructor.
56121 
56122 ";
56123 
56124 %feature("docstring")  casadi::FunctionInternal::adjViaJac(casadi_int nadj)
56125 const  "
56126 
56127 [INTERNAL]  Calculate derivatives by multiplying the full Jacobian and
56128 multiplying.
56129 
56130 ";
56131 
56132 %feature("docstring")  casadi::FunctionInternal::jac() const  "
56133 
56134 [INTERNAL]  Return Jacobian of all input elements with respect to all output
56135 elements.
56136 
56137 ";
56138 
56139 %feature("docstring")  casadi::OracleFunction::expand() "
56140 
56141 [INTERNAL] ";
56142 
56143 %feature("docstring")  casadi::Rootfinder::get_sparsity_in(casadi_int i)  "
56144 
56145 [INTERNAL]  Sparsities of function inputs and outputs.
56146 
56147 ";
56148 
56149 %feature("docstring")  casadi::Rootfinder::get_reverse(casadi_int nadj,
56150 const std::string &name, const std::vector< std::string > &inames, const
56151 std::vector< std::string > &onames, const Dict &opts) const  "
56152 
56153 [INTERNAL]  Generate a function that calculates nadj adjoint derivatives.
56154 
56155 ";
56156 
56157 %feature("docstring")  casadi::FunctionInternal::get_default_in(casadi_int
56158 ind) const  "
56159 
56160 [INTERNAL]  Get default input value.
56161 
56162 ";
56163 
56164 %feature("docstring")  casadi::OracleFunction::calc_function(OracleMemory
56165 *m, const std::string &fcn, const double *const *arg=nullptr) const  "
56166 
56167 [INTERNAL] ";
56168 
56169 %feature("docstring")  casadi::ProtoFunction::checkout() const  "
56170 
56171 [INTERNAL]  Checkout a memory object.
56172 
56173 ";
56174 
56175 %feature("docstring")  casadi::FunctionInternal::jacobian() const  "
56176 
56177 [INTERNAL]  Return Jacobian of all input elements with respect to all output
56178 elements.
56179 
56180 ";
56181 
56182 %feature("docstring")  casadi::FunctionInternal::has_eval_dm() const  "
56183 
56184 [INTERNAL]  Evaluate with DM matrices.
56185 
56186 ";
56187 
56188 %feature("docstring")  casadi::FunctionInternal::get_free() const  "
56189 
56190 [INTERNAL]  Print free variables.
56191 
56192 ";
56193 
56194 %feature("docstring")  casadi::FunctionInternal::sparsity_jac(casadi_int
56195 iind, casadi_int oind, bool compact, bool symmetric) const  "
56196 
56197 [INTERNAL]  Get, if necessary generate, the sparsity of a Jacobian block.
56198 
56199 ";
56200 
56201 %feature("docstring")  casadi::Newton::class_name() const  "
56202 
56203 [INTERNAL]  Readable name of the internal class.
56204 
56205 ";
56206 
56207 %feature("docstring")
56208 casadi::FunctionInternal::codegen_sparsities(CodeGenerator &g) const  "
56209 
56210 [INTERNAL]  Codegen sparsities.
56211 
56212 ";
56213 
56214 %feature("docstring")  casadi::FunctionInternal::get_partition(casadi_int
56215 iind, casadi_int oind, Sparsity &D1, Sparsity &D2, bool compact, bool
56216 symmetric, bool allow_forward, bool allow_reverse) const  "
56217 
56218 [INTERNAL]  Get the unidirectional or bidirectional partition.
56219 
56220 ";
56221 
56222 %feature("docstring")  casadi::ProtoFunction::format_time(char *buffer,
56223 double time) const  "
56224 
56225 [INTERNAL]  Format time in a fixed width 8 format.
56226 
56227 ";
56228 
56229 %feature("docstring")  casadi::FunctionInternal::export_code(const
56230 std::string &lang, std::ostream &stream, const Dict &options) const  "
56231 
56232 [INTERNAL]  Export function in a specific language.
56233 
56234 ";
56235 
56236 %feature("docstring")  casadi::FunctionInternal::definition() const  "
56237 
56238 [INTERNAL]  Get function signature: name:(inputs)->(outputs)
56239 
56240 ";
56241 
56242 %feature("docstring")
56243 casadi::FunctionInternal::instruction_input(casadi_int k) const  "
56244 
56245 [INTERNAL]  Get the (integer) input arguments of an atomic operation.
56246 
56247 ";
56248 
56249 %feature("docstring")  casadi::FunctionInternal::getJacSparsity(casadi_int
56250 iind, casadi_int oind, bool symmetric) const  "
56251 
56252 [INTERNAL]  Generate the sparsity of a Jacobian block.
56253 
56254 ";
56255 
56256 %feature("docstring")  casadi::FunctionInternal::get_abstol() const  "
56257 
56258 [INTERNAL]  Get absolute tolerance.
56259 
56260 ";
56261 
56262 %feature("docstring")  casadi::FunctionInternal::jacobian_sparsity() const
56263 "
56264 
56265 [INTERNAL]  Get Jacobian sparsity.
56266 
56267 ";
56268 
56269 %feature("docstring")  casadi::OracleFunction::set_temp(void *mem, const
56270 double **arg, double **res, casadi_int *iw, double *w) const  "
56271 
56272 [INTERNAL]  Set the work vectors.
56273 
56274 ";
56275 
56276 %feature("docstring")  casadi::FunctionInternal::dm_out(casadi_int ind)
56277 const  "
56278 
56279 [INTERNAL]  Get function input(s) and output(s)
56280 
56281 ";
56282 
56283 %feature("docstring")  casadi::FunctionInternal::dm_out() const  "
56284 
56285 [INTERNAL]  Get function input(s) and output(s)
56286 
56287 ";
56288 
56289 %feature("docstring")  casadi::FunctionInternal::is_a(const std::string
56290 &type, bool recursive) const  "
56291 
56292 [INTERNAL]  Check if the function is of a particular type.
56293 
56294 ";
56295 
56296 %feature("docstring")  casadi::FunctionInternal::slice(const std::string
56297 &name, const std::vector< casadi_int > &order_in, const std::vector<
56298 casadi_int > &order_out, const Dict &opts) const  "
56299 
56300 [INTERNAL]  returns a new function with a selection of inputs/outputs of the
56301 original
56302 
56303 ";
56304 
56305 %feature("docstring")  casadi::ProtoFunction::release(int mem) const  "
56306 
56307 [INTERNAL]  Release a memory object.
56308 
56309 ";
56310 
56311 %feature("docstring")  casadi::FunctionInternal::alloc_res(size_t sz_res,
56312 bool persistent=false) "
56313 
56314 [INTERNAL]  Ensure required length of res field.
56315 
56316 ";
56317 
56318 %feature("docstring")  casadi::Rootfinder::get_n_out()  "
56319 
56320 [INTERNAL]  Number of function inputs and outputs.
56321 
56322 ";
56323 
56324 %feature("docstring")  casadi::FunctionInternal::project_arg(const
56325 std::vector< M > &arg, casadi_int npar) const  "
56326 
56327 [INTERNAL]   Project sparsities.
56328 
56329 ";
56330 
56331 %feature("docstring")  casadi::Rootfinder::get_sparsity_out(casadi_int i)  "
56332 
56333 [INTERNAL]  Sparsities of function inputs and outputs.
56334 
56335 ";
56336 
56337 %feature("docstring")  casadi::SharedObjectInternal::getCount() const  "
56338 
56339 [INTERNAL]  Get the reference count.
56340 
56341 ";
56342 
56343 %feature("docstring")  casadi::ProtoFunction::construct(const Dict &opts) "
56344 
56345 [INTERNAL]  Construct Prepares the function for evaluation.
56346 
56347 ";
56348 
56349 %feature("docstring")  casadi::Newton::plugin_name() const  "
56350 
56351 [INTERNAL] ";
56352 
56353 %feature("docstring")  casadi::Rootfinder::sp_forward(const bvec_t **arg,
56354 bvec_t **res, casadi_int *iw, bvec_t *w, void *mem) const  "
56355 
56356 [INTERNAL]  Propagate sparsity forward.
56357 
56358 ";
56359 
56360 %feature("docstring")  casadi::FunctionInternal::which_depends(const
56361 std::string &s_in, const std::vector< std::string > &s_out, casadi_int
56362 order, bool tr=false) const  "
56363 
56364 [INTERNAL]  Which variables enter with some order.
56365 
56366 Parameters:
56367 -----------
56368 
56369 s_in:   Input name
56370 
56371 s_out:   Output name(s)
56372 
56373 order:  Only 1 (linear) and 2 (nonlinear) allowed
56374 
56375 tr:  Flip the relationship. Return which expressions contain the variables
56376 
56377 ";
56378 
56379 %feature("docstring")  casadi::OracleFunction::has_function(const
56380 std::string &fname) const  "
56381 
56382 [INTERNAL] ";
56383 
56384 %feature("docstring")  casadi::FunctionInternal::reverse(casadi_int nadj)
56385 const  "
56386 
56387 [INTERNAL]  Return function that calculates adjoint derivatives
56388 reverse(nadj) returns a cached instance if available, and calls  Function
56389 get_reverse(casadi_int nadj) if no cached version is available.
56390 
56391 ";
56392 
56393 %feature("docstring")  casadi::FunctionInternal::incache(const std::string
56394 &fname, Function &f, const std::string &suffix="") const  "
56395 
56396 [INTERNAL]  Get function in cache.
56397 
56398 ";
56399 
56400 %feature("docstring")  casadi::FunctionInternal::alloc_iw(size_t sz_iw, bool
56401 persistent=false) "
56402 
56403 [INTERNAL]  Ensure required length of iw field.
56404 
56405 ";
56406 
56407 %feature("docstring")
56408 casadi::FunctionInternal::instruction_constant(casadi_int k) const  "
56409 
56410 [INTERNAL]  Get the floating point output argument of an atomic operation.
56411 
56412 ";
56413 
56414 %feature("docstring")  casadi::Rootfinder::serialize_base_function() const
56415 "
56416 
56417 [INTERNAL]  String used to identify the immediate FunctionInternal subclass.
56418 
56419 ";
56420 
56421 %feature("docstring")  casadi::Newton::serialize_body(SerializingStream &s)
56422 const  "
56423 
56424 [INTERNAL]  Serialize an object without type information.
56425 
56426 ";
56427 
56428 %feature("docstring")
56429 casadi::FunctionInternal::getJacSparsityHierarchicalSymm(casadi_int iind,
56430 casadi_int oind) const  "
56431 
56432 [INTERNAL]  A flavor of getJacSparsity that does hierarchical block
56433 structure recognition for symmetric Jacobians
56434 
56435 ";
56436 
56437 %feature("docstring")
56438 casadi::FunctionInternal::codegen_declarations(CodeGenerator &g) const  "
56439 
56440 [INTERNAL]  Generate code for the declarations of the C function.
56441 
56442 ";
56443 
56444 %feature("docstring")  casadi::Newton::init(const Dict &opts)  "
56445 
56446 [INTERNAL]  Initialize.
56447 
56448 ";
56449 
56450 %feature("docstring")  casadi::FunctionInternal::eval_sx(const SXElem **arg,
56451 SXElem **res, casadi_int *iw, SXElem *w, void *mem) const  "
56452 
56453 [INTERNAL]  Evaluate with symbolic scalars.
56454 
56455 ";
56456 
56457 %feature("docstring")  casadi::FunctionInternal::codegen_body(CodeGenerator
56458 &g) const  "
56459 
56460 [INTERNAL]  Generate code for the function body.
56461 
56462 ";
56463 
56464 %feature("docstring")
56465 casadi::FunctionInternal::jacobian_sparsity_filter(const Sparsity &sp) const
56466 "
56467 
56468 [INTERNAL]  Filter out nonzeros in the full sparsity jacobian according to
56469 is_diff_in/out.
56470 
56471 ";
56472 
56473 %feature("docstring")  casadi::FunctionInternal::alloc_arg(size_t sz_arg,
56474 bool persistent=false) "
56475 
56476 [INTERNAL]  Ensure required length of arg field.
56477 
56478 ";
56479 
56480 %feature("docstring")  casadi::FunctionInternal::n_nodes() const  "
56481 
56482 [INTERNAL]  Number of nodes in the algorithm.
56483 
56484 ";
56485 
56486 %feature("docstring")  casadi::FunctionInternal::numel_in() const  "
56487 
56488 [INTERNAL]  Number of input/output elements.
56489 
56490 ";
56491 
56492 %feature("docstring")  casadi::FunctionInternal::numel_in(casadi_int ind)
56493 const  "
56494 
56495 [INTERNAL]  Number of input/output elements.
56496 
56497 ";
56498 
56499 %feature("docstring")  casadi::OracleFunction::get_function() const  "
56500 
56501 [INTERNAL]  Get list of dependency functions -1 Indicates irregularity.
56502 
56503 ";
56504 
56505 %feature("docstring")  casadi::OracleFunction::get_function(const
56506 std::string &name) const  "
56507 
56508 [INTERNAL] ";
56509 
56510 %feature("docstring")  casadi::FunctionInternal::sx_in(casadi_int ind) const
56511 "
56512 
56513 [INTERNAL]  Get function input(s) and output(s)
56514 
56515 ";
56516 
56517 %feature("docstring")  casadi::FunctionInternal::sx_in() const  "
56518 
56519 [INTERNAL]  Get function input(s) and output(s)
56520 
56521 ";
56522 
56523 %feature("docstring")
56524 casadi::FunctionInternal::codegen_init_mem(CodeGenerator &g) const  "
56525 
56526 [INTERNAL]  Codegen decref for init_mem.
56527 
56528 ";
56529 
56530 %feature("docstring")  casadi::Rootfinder::serialize_type(SerializingStream
56531 &s) const  "
56532 
56533 [INTERNAL]  Serialize type information.
56534 
56535 ";
56536 
56537 %feature("docstring") casadi::Newton::~Newton "
56538 
56539 [INTERNAL]  Destructor.
56540 
56541 ";
56542 
56543 %feature("docstring")  casadi::OracleFunction::oracle() const  "
56544 
56545 [INTERNAL]  Get oracle.
56546 
56547 ";
56548 
56549 %feature("docstring")  casadi::FunctionInternal::generate_out(const
56550 std::string &fname, double **res) const  "
56551 
56552 [INTERNAL] ";
56553 
56554 %feature("docstring")  casadi::ProtoFunction::sprint(char *buf, size_t
56555 buf_sz, const char *fmt,...) const  "
56556 
56557 [INTERNAL]  C-style formatted printing to string.
56558 
56559 ";
56560 
56561 %feature("docstring")  casadi::FunctionInternal::alloc(const Function &f,
56562 bool persistent=false) "
56563 
56564 [INTERNAL]  Ensure work vectors long enough to evaluate function.
56565 
56566 ";
56567 
56568 %feature("docstring")  casadi::FunctionInternal::sz_res() const  "
56569 
56570 [INTERNAL]  Get required length of res field.
56571 
56572 ";
56573 
56574 %feature("docstring")  casadi::Rootfinder::ad_forward(const std::vector< MX
56575 > &arg, const std::vector< MX > &res, const std::vector< std::vector< MX > >
56576 &fseed, std::vector< std::vector< MX > > &fsens, bool always_inline, bool
56577 never_inline) const  "
56578 
56579 [INTERNAL]  Create call to (cached) derivative function, forward mode.
56580 
56581 ";
56582 
56583 %feature("docstring")  casadi::FunctionInternal::replace_aseed(const
56584 std::vector< std::vector< M >> &aseed, casadi_int npar) const  "
56585 
56586 [INTERNAL]  Replace 0-by-0 reverse seeds.
56587 
56588 ";
56589 
56590 %feature("docstring")  casadi::FunctionInternal::replace_aseed(const
56591 std::vector< std::vector< M > > &aseed, casadi_int npar) const  "
56592 
56593 [INTERNAL] ";
56594 
56595 %feature("docstring")  casadi::FunctionInternal::getAdaptorSolverName()
56596 const  "
56597 
56598 [INTERNAL]  Obtain solver name from Adaptor.
56599 
56600 ";
56601 
56602 %feature("docstring")  casadi::FunctionInternal::info() const  "
56603 
56604 [INTERNAL]  Obtain information about function
56605 
56606 ";
56607 
56608 %feature("docstring")  casadi::FunctionInternal::size1_out(casadi_int ind)
56609 const  "
56610 
56611 [INTERNAL]  Input/output dimensions.
56612 
56613 ";
56614 
56615 %feature("docstring")  casadi::FunctionInternal::convert_arg(const
56616 std::vector< M > &arg) const  "
56617 
56618 [INTERNAL]  Convert from/to input/output lists/map.
56619 
56620 ";
56621 
56622 %feature("docstring")  casadi::FunctionInternal::convert_arg(const std::map<
56623 std::string, M > &arg) const  "
56624 
56625 [INTERNAL]  Convert from/to input/output lists/map.
56626 
56627 ";
56628 
56629 %feature("docstring")  casadi::Rootfinder::sp_reverse(bvec_t **arg, bvec_t
56630 **res, casadi_int *iw, bvec_t *w, void *mem) const  "
56631 
56632 [INTERNAL]  Propagate sparsity backwards.
56633 
56634 ";
56635 
56636 %feature("docstring")  casadi::FunctionInternal::instruction_id(casadi_int
56637 k) const  "
56638 
56639 [INTERNAL]  Get an atomic operation operator index.
56640 
56641 ";
56642 
56643 %feature("docstring")  casadi::Rootfinder::has_spfwd() const  "
56644 
56645 [INTERNAL]  Is the class able to propagate seeds through the algorithm?
56646 
56647 ";
56648 
56649 %feature("docstring")  casadi::Rootfinder::ad_reverse(const std::vector< MX
56650 > &arg, const std::vector< MX > &res, const std::vector< std::vector< MX > >
56651 &aseed, std::vector< std::vector< MX > > &asens, bool always_inline, bool
56652 never_inline) const  "
56653 
56654 [INTERNAL]  Create call to (cached) derivative function, reverse mode.
56655 
56656 ";
56657 
56658 %feature("docstring")  casadi::Rootfinder::has_reverse(casadi_int nadj)
56659 const  "
56660 
56661 [INTERNAL]  Generate a function that calculates nadj adjoint derivatives.
56662 
56663 ";
56664 
56665 %feature("docstring")  casadi::FunctionInternal::generate_lifted(Function
56666 &vdef_fcn, Function &vinit_fcn) const  "
56667 
56668 [INTERNAL]  Extract the functions needed for the Lifted Newton method.
56669 
56670 ";
56671 
56672 %feature("docstring")  casadi::FunctionInternal::is_diff_in(casadi_int i) "
56673 
56674 [INTERNAL] ";
56675 
56676 %feature("docstring")  casadi::FunctionInternal::nnz_out() const  "
56677 
56678 [INTERNAL]  Number of input/output nonzeros.
56679 
56680 ";
56681 
56682 %feature("docstring")  casadi::FunctionInternal::nnz_out(casadi_int ind)
56683 const  "
56684 
56685 [INTERNAL]  Number of input/output nonzeros.
56686 
56687 ";
56688 
56689 %feature("docstring") casadi::Newton "
56690 
56691 'newton' plugin for Rootfinder
56692 
56693 Implements simple newton iterations to solve an implicit function.
56694 
56695 >List of available options
56696 
56697 +-----------------+-----------+--------------------------------------------+
56698 |       Id        |   Type    |                Description                 |
56699 +=================+===========+============================================+
56700 | abstol          | OT_DOUBLE | Stopping criterion tolerance on max(|F|)   |
56701 +-----------------+-----------+--------------------------------------------+
56702 | abstolStep      | OT_DOUBLE | Stopping criterion tolerance on step size  |
56703 +-----------------+-----------+--------------------------------------------+
56704 | line_search     | OT_BOOL   | Enable line-search (default: true)         |
56705 +-----------------+-----------+--------------------------------------------+
56706 | max_iter        | OT_INT    | Maximum number of Newton iterations to     |
56707 |                 |           | perform before returning.                  |
56708 +-----------------+-----------+--------------------------------------------+
56709 | print_iteration | OT_BOOL   | Print information about each iteration     |
56710 +-----------------+-----------+--------------------------------------------+
56711 
56712 Joris Gillis
56713 
56714 >List of available options
56715 
56716 +-------------------+--------------+-------------------+-------------------+
56717 |        Id         |     Type     |    Description    |      Used in      |
56718 +===================+==============+===================+===================+
56719 | abstol            | OT_DOUBLE    | Stopping          | casadi::Newton    |
56720 |                   |              | criterion         |                   |
56721 |                   |              | tolerance on      |                   |
56722 |                   |              | max(|F|)          |                   |
56723 +-------------------+--------------+-------------------+-------------------+
56724 | abstolStep        | OT_DOUBLE    | Stopping          | casadi::Newton    |
56725 |                   |              | criterion         |                   |
56726 |                   |              | tolerance on step |                   |
56727 |                   |              | size              |                   |
56728 +-------------------+--------------+-------------------+-------------------+
56729 | constraints       | OT_INTVECTOR | Constrain the     | casadi::Rootfinde |
56730 |                   |              | unknowns. 0       | r                 |
56731 |                   |              | (default): no     |                   |
56732 |                   |              | constraint on ui, |                   |
56733 |                   |              | 1: ui >= 0.0, -1: |                   |
56734 |                   |              | ui <= 0.0, 2: ui  |                   |
56735 |                   |              | > 0.0, -2: ui <   |                   |
56736 |                   |              | 0.0.              |                   |
56737 +-------------------+--------------+-------------------+-------------------+
56738 | error_on_fail     | OT_BOOL      | When the          | casadi::Rootfinde |
56739 |                   |              | numerical process | r                 |
56740 |                   |              | returns           |                   |
56741 |                   |              | unsuccessfully,   |                   |
56742 |                   |              | raise an error    |                   |
56743 |                   |              | (default false).  |                   |
56744 +-------------------+--------------+-------------------+-------------------+
56745 | implicit_input    | OT_INT       | Index of the      | casadi::Rootfinde |
56746 |                   |              | input that        | r                 |
56747 |                   |              | corresponds to    |                   |
56748 |                   |              | the actual root-  |                   |
56749 |                   |              | finding           |                   |
56750 +-------------------+--------------+-------------------+-------------------+
56751 | implicit_output   | OT_INT       | Index of the      | casadi::Rootfinde |
56752 |                   |              | output that       | r                 |
56753 |                   |              | corresponds to    |                   |
56754 |                   |              | the actual root-  |                   |
56755 |                   |              | finding           |                   |
56756 +-------------------+--------------+-------------------+-------------------+
56757 | jacobian_function | OT_FUNCTION  | Function object   | casadi::Rootfinde |
56758 |                   |              | for calculating   | r                 |
56759 |                   |              | the Jacobian      |                   |
56760 |                   |              | (autogenerated by |                   |
56761 |                   |              | default)          |                   |
56762 +-------------------+--------------+-------------------+-------------------+
56763 | line_search       | OT_BOOL      | Enable line-      | casadi::Newton    |
56764 |                   |              | search (default:  |                   |
56765 |                   |              | true)             |                   |
56766 +-------------------+--------------+-------------------+-------------------+
56767 | linear_solver     | OT_STRING    | User-defined      | casadi::Rootfinde |
56768 |                   |              | linear solver     | r                 |
56769 |                   |              | class. Needed for |                   |
56770 |                   |              | sensitivities.    |                   |
56771 +-------------------+--------------+-------------------+-------------------+
56772 | linear_solver_opt | OT_DICT      | Options to be     | casadi::Rootfinde |
56773 | ions              |              | passed to the     | r                 |
56774 |                   |              | linear solver.    |                   |
56775 +-------------------+--------------+-------------------+-------------------+
56776 | max_iter          | OT_INT       | Maximum number of | casadi::Newton    |
56777 |                   |              | Newton iterations |                   |
56778 |                   |              | to perform before |                   |
56779 |                   |              | returning.        |                   |
56780 +-------------------+--------------+-------------------+-------------------+
56781 | print_iteration   | OT_BOOL      | Print information | casadi::Newton    |
56782 |                   |              | about each        |                   |
56783 |                   |              | iteration         |                   |
56784 +-------------------+--------------+-------------------+-------------------+
56785 
56786 Diagrams
56787 --------
56788 
56789 
56790 
56791 C++ includes: newton.hpp ";
56792 
56793 %feature("docstring")  casadi::FunctionInternal::check_res(const
56794 std::vector< M > &res, casadi_int &npar) const  "
56795 
56796 [INTERNAL]  Check if output arguments have correct length and dimensions.
56797 
56798 Raises errors.
56799 
56800 Parameters:
56801 -----------
56802 
56803 npar[in]:  normal usage: 1, disallow pararallel calls: -1
56804 
56805 npar:  max number of horizontal repetitions across all arguments (or -1)
56806 
56807 ";
56808 
56809 %feature("docstring")  casadi::FunctionInternal::sparsity_out(casadi_int
56810 ind) const  "
56811 
56812 [INTERNAL]  Input/output sparsity.
56813 
56814 ";
56815 
56816 %feature("docstring")  casadi::FunctionInternal::codegen_meta(CodeGenerator
56817 &g) const  "
56818 
56819 [INTERNAL]  Generate meta-information allowing a user to evaluate a
56820 generated function.
56821 
56822 ";
56823 
56824 %feature("docstring")  casadi::OracleFunction::monitored(const std::string
56825 &name) const  "
56826 
56827 [INTERNAL] ";
56828 
56829 %feature("docstring")  casadi::FunctionInternal::check_mat(const Sparsity
56830 &arg, const Sparsity &inp, casadi_int &npar) "
56831 
56832 [INTERNAL]  Helper function
56833 
56834 Parameters:
56835 -----------
56836 
56837 npar[in]:  normal usage: 1, disallow pararallel calls: -1
56838 
56839 npar[out]:  required number of parallel calls (or -1)
56840 
56841 ";
56842 
56843 %feature("docstring")
56844 casadi::FunctionInternal::print_dimensions(std::ostream &stream) const  "
56845 
56846 [INTERNAL]  Print dimensions of inputs and outputs.
56847 
56848 ";
56849 
56850 %feature("docstring")  casadi::FunctionInternal::mx_out(casadi_int ind)
56851 const  "
56852 
56853 [INTERNAL]  Get function input(s) and output(s)
56854 
56855 ";
56856 
56857 %feature("docstring")  casadi::FunctionInternal::mx_out() const  "
56858 
56859 [INTERNAL]  Get function input(s) and output(s)
56860 
56861 ";
56862 
56863 %feature("docstring")  casadi::FunctionInternal::sz_arg() const  "
56864 
56865 [INTERNAL]  Get required length of arg field.
56866 
56867 ";
56868 
56869 %feature("docstring")  casadi::FunctionInternal::get_reltol() const  "
56870 
56871 [INTERNAL]  Get relative tolerance.
56872 
56873 ";
56874 
56875 %feature("docstring")  casadi::FunctionInternal::sz_w() const  "
56876 
56877 [INTERNAL]  Get required length of w field.
56878 
56879 ";
56880 
56881 %feature("docstring")  casadi::FunctionInternal::has_jacobian() const  "
56882 
56883 [INTERNAL]  Return Jacobian of all input elements with respect to all output
56884 elements.
56885 
56886 ";
56887 
56888 %feature("docstring")  casadi::FunctionInternal::convert_res(const
56889 std::vector< M > &res) const  "
56890 
56891 [INTERNAL]  Convert from/to input/output lists/map.
56892 
56893 ";
56894 
56895 %feature("docstring")  casadi::FunctionInternal::convert_res(const std::map<
56896 std::string, M > &res) const  "
56897 
56898 [INTERNAL]  Convert from/to input/output lists/map.
56899 
56900 ";
56901 
56902 %feature("docstring")  casadi::FunctionInternal::symbolicAdjSeed(casadi_int
56903 nadj, const std::vector< MatType > &v) const  "
56904 
56905 [INTERNAL]  Symbolic expressions for the adjoint seeds.
56906 
56907 ";
56908 
56909 %feature("docstring")
56910 casadi::FunctionInternal::codegen_free_mem(CodeGenerator &g) const  "
56911 
56912 [INTERNAL]  Codegen for free_mem.
56913 
56914 ";
56915 
56916 %feature("docstring")  casadi::Newton::free_mem(void *mem) const  "
56917 
56918 [INTERNAL]  Free memory block.
56919 
56920 ";
56921 
56922 %feature("docstring")  casadi::FunctionInternal::sparsity_in(casadi_int ind)
56923 const  "
56924 
56925 [INTERNAL]  Input/output sparsity.
56926 
56927 ";
56928 
56929 %feature("docstring")  casadi::FunctionInternal::disp_more(std::ostream
56930 &stream) const  "
56931 
56932 [INTERNAL]  Print more.
56933 
56934 ";
56935 
56936 %feature("docstring")  casadi::Rootfinder::get_name_in(casadi_int i)  "
56937 
56938 [INTERNAL]  Names of function input and outputs.
56939 
56940 ";
56941 
56942 %feature("docstring")  casadi::ProtoFunction::print_time(const std::map<
56943 std::string, FStats > &fstats) const  "
56944 
56945 [INTERNAL]  Print timing statistics.
56946 
56947 ";
56948 
56949 %feature("docstring")
56950 casadi::FunctionInternal::codegen_incref(CodeGenerator &g) const  "
56951 
56952 [INTERNAL]  Codegen incref for dependencies.
56953 
56954 ";
56955 
56956 %feature("docstring")  casadi::FunctionInternal::get_jacobian(const
56957 std::string &name, const std::vector< std::string > &inames, const
56958 std::vector< std::string > &onames, const Dict &opts) const  "
56959 
56960 [INTERNAL]  Return Jacobian of all input elements with respect to all output
56961 elements.
56962 
56963 ";
56964 
56965 %feature("docstring")  casadi::FunctionInternal::instruction_MX(casadi_int
56966 k) const  "
56967 
56968 [INTERNAL]  get MX expression associated with instruction
56969 
56970 ";
56971 
56972 %feature("docstring")  casadi::FunctionInternal::sz_iw() const  "
56973 
56974 [INTERNAL]  Get required length of iw field.
56975 
56976 ";
56977 
56978 %feature("docstring")  casadi::FunctionInternal::project_res(const
56979 std::vector< M > &arg, casadi_int npar) const  "
56980 
56981 [INTERNAL]   Project sparsities.
56982 
56983 ";
56984 
56985 %feature("docstring")  casadi::FunctionInternal::codegen(CodeGenerator &g,
56986 const std::string &fname) const  "
56987 
56988 [INTERNAL]  Generate code the function.
56989 
56990 ";
56991 
56992 %feature("docstring")  casadi::Rootfinder::has_sprev() const  "
56993 
56994 [INTERNAL]  Is the class able to propagate seeds through the algorithm?
56995 
56996 ";
56997 
56998 %feature("docstring")  casadi::FunctionInternal::index_in(const std::string
56999 &name) const  "
57000 
57001 [INTERNAL]  Get input scheme index by name.
57002 
57003 ";
57004 
57005 %feature("docstring")  casadi::FunctionInternal::generate_options(bool
57006 is_temp=false) const  "
57007 
57008 [INTERNAL]  Reconstruct options dict.
57009 
57010 ";
57011 
57012 %feature("docstring")  casadi::FunctionInternal::generate_in(const
57013 std::string &fname, const double **arg) const  "
57014 
57015 [INTERNAL]  Export an input file that can be passed to generate C code with
57016 a main.
57017 
57018 ";
57019 
57020 %feature("docstring")  casadi::FunctionInternal::n_instructions() const  "
57021 
57022 [INTERNAL]  Get the number of atomic operations.
57023 
57024 ";
57025 
57026 %feature("docstring")  casadi::FunctionInternal::check_arg(const
57027 std::vector< M > &arg, casadi_int &npar) const  "
57028 
57029 [INTERNAL]  Check if input arguments have correct length and dimensions.
57030 
57031 Raises errors.
57032 
57033 Parameters:
57034 -----------
57035 
57036 npar[in]:  normal usage: 1, disallow pararallel calls: -1
57037 
57038 npar:  max number of horizontal repetitions across all arguments (or -1)
57039 
57040 ";
57041 
57042 %feature("docstring")  casadi::FunctionInternal::call(const std::vector< M >
57043 &arg, std::vector< M > &res, bool always_inline, bool never_inline) const  "
57044 
57045 [INTERNAL]   Call a function, templated.
57046 
57047 ";
57048 
57049 %feature("docstring")  casadi::FunctionInternal::fwd_seed(casadi_int nfwd)
57050 const  "
57051 
57052 [INTERNAL]  Symbolic expressions for the forward seeds.
57053 
57054 ";
57055 
57056 %feature("docstring")  casadi::FunctionInternal::self() const  "
57057 
57058 [INTERNAL]  Get a public class instance.
57059 
57060 ";
57061 
57062 %feature("docstring")  casadi::FunctionInternal::fwdViaJac(casadi_int nfwd)
57063 const  "
57064 
57065 [INTERNAL]  Calculate derivatives by multiplying the full Jacobian and
57066 multiplying.
57067 
57068 ";
57069 
57070 %feature("docstring")  casadi::FunctionInternal::nz_in(const std::vector< DM
57071 > &arg) const  "
57072 
57073 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
57074 
57075 ";
57076 
57077 %feature("docstring")  casadi::FunctionInternal::nz_in(const std::vector<
57078 double > &arg) const  "
57079 
57080 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
57081 
57082 ";
57083 
57084 %feature("docstring")  casadi::FunctionInternal::nz_out(const std::vector<
57085 DM > &res) const  "
57086 
57087 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
57088 
57089 ";
57090 
57091 %feature("docstring")  casadi::FunctionInternal::nz_out(const std::vector<
57092 double > &res) const  "
57093 
57094 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
57095 
57096 ";
57097 
57098 %feature("docstring")  casadi::Newton::get_options() const  "
57099 
57100 [INTERNAL]  Options.
57101 
57102 ";
57103 
57104 %feature("docstring")  casadi::FunctionInternal::nnz_in() const  "
57105 
57106 [INTERNAL]  Number of input/output nonzeros.
57107 
57108 ";
57109 
57110 %feature("docstring")  casadi::FunctionInternal::nnz_in(casadi_int ind)
57111 const  "
57112 
57113 [INTERNAL]  Number of input/output nonzeros.
57114 
57115 ";
57116 
57117 %feature("docstring")  casadi::OracleFunction::generate_dependencies(const
57118 std::string &fname, const Dict &opts) const  "
57119 
57120 [INTERNAL]  Export / Generate C code for the generated functions.
57121 
57122 ";
57123 
57124 %feature("docstring")  casadi::FunctionInternal::setup(void *mem, const
57125 double **arg, double **res, casadi_int *iw, double *w) const  "
57126 
57127 [INTERNAL]  Set the (persistent and temporary) work vectors.
57128 
57129 ";
57130 
57131 %feature("docstring")  casadi::FunctionInternal::alloc_w(size_t sz_w, bool
57132 persistent=false) "
57133 
57134 [INTERNAL]  Ensure required length of w field.
57135 
57136 ";
57137 
57138 %feature("docstring")  casadi::FunctionInternal::has_jac() const  "
57139 
57140 [INTERNAL]  Return Jacobian of all input elements with respect to all output
57141 elements.
57142 
57143 ";
57144 
57145 %feature("docstring")  casadi::FunctionInternal::all_scalar() const  "
57146 
57147 [INTERNAL]  Are all inputs and outputs scalar.
57148 
57149 ";
57150 
57151 %feature("docstring")  casadi::FunctionInternal::codegen_name(const
57152 CodeGenerator &g, bool ns=true) const  "
57153 
57154 [INTERNAL]  Get name in codegen.
57155 
57156 ";
57157 
57158 %feature("docstring")  casadi::FunctionInternal::sp_weight() const  "
57159 
57160 [INTERNAL]  Weighting factor for chosing forward/reverse mode, sparsity
57161 propagation.
57162 
57163 ";
57164 
57165 %feature("docstring")  casadi::Rootfinder::get_forward(casadi_int nfwd,
57166 const std::string &name, const std::vector< std::string > &inames, const
57167 std::vector< std::string > &onames, const Dict &opts) const  "
57168 
57169 [INTERNAL]  Generate a function that calculates nfwd forward derivatives.
57170 
57171 ";
57172 
57173 %feature("docstring")  casadi::FunctionInternal::codegen_mem_type() const  "
57174 
57175 [INTERNAL]  Thread-local memory object type.
57176 
57177 ";
57178 
57179 %feature("docstring")  casadi::Rootfinder::uses_output() const  "
57180 
57181 [INTERNAL]  Do the derivative functions need nondifferentiated outputs?
57182 
57183 ";
57184 
57185 %feature("docstring")  casadi::Newton::alloc_mem() const  "
57186 
57187 [INTERNAL]  Create memory block.
57188 
57189 ";
57190 
57191 %feature("docstring")  casadi::FunctionInternal::has_codegen() const  "
57192 
57193 [INTERNAL]  Is codegen supported?
57194 
57195 ";
57196 
57197 %feature("docstring")
57198 casadi::FunctionInternal::codegen_decref(CodeGenerator &g) const  "
57199 
57200 [INTERNAL]  Codegen decref for dependencies.
57201 
57202 ";
57203 
57204 %feature("docstring")  casadi::FunctionInternal::forward(casadi_int nfwd)
57205 const  "
57206 
57207 [INTERNAL]  Return function that calculates forward derivatives
57208 forward(nfwd) returns a cached instance if available, and calls  Function
57209 get_forward(casadi_int nfwd) if no cached version is available.
57210 
57211 ";
57212 
57213 %feature("docstring")  casadi::FunctionInternal::matching_res(const
57214 std::vector< M > &arg, casadi_int &npar) const  "
57215 
57216 [INTERNAL]  Check if output arguments that needs to be replaced.
57217 
57218 Raises errors
57219 
57220 Parameters:
57221 -----------
57222 
57223 npar[in]:  normal usage: 1, disallow pararallel calls: -1
57224 
57225 npar:  max number of horizontal repetitions across all arguments (or -1)
57226 
57227 ";
57228 
57229 %feature("docstring")
57230 casadi::FunctionInternal::getJacSparsityHierarchical(casadi_int iind,
57231 casadi_int oind) const  "
57232 
57233 [INTERNAL]  A flavor of getJacSparsity that does hierarchical block
57234 structure recognition.
57235 
57236 ";
57237 
57238 %feature("docstring")  casadi::FunctionInternal::mapsum_mx(const
57239 std::vector< MX > &arg, const std::string &parallelization) "
57240 
57241 [INTERNAL]  Parallel evaluation.
57242 
57243 ";
57244 
57245 %feature("docstring")  casadi::FunctionInternal::size2_in(casadi_int ind)
57246 const  "
57247 
57248 [INTERNAL]  Input/output dimensions.
57249 
57250 ";
57251 
57252 %feature("docstring")  casadi::FunctionInternal::mx_in(casadi_int ind) const
57253 "
57254 
57255 [INTERNAL]  Get function input(s) and output(s)
57256 
57257 ";
57258 
57259 %feature("docstring")  casadi::FunctionInternal::mx_in() const  "
57260 
57261 [INTERNAL]  Get function input(s) and output(s)
57262 
57263 ";
57264 
57265 %feature("docstring")  casadi::OracleFunction::create_function(const
57266 std::string &fname, const std::vector< std::string > &s_in, const
57267 std::vector< std::string > &s_out, const Function::AuxOut
57268 &aux=Function::AuxOut()) "
57269 
57270 [INTERNAL]  Create an oracle function
57271 
57272 ";
57273 
57274 %feature("docstring")  casadi::FunctionInternal::call_forward(const
57275 std::vector< MX > &arg, const std::vector< MX > &res, const std::vector<
57276 std::vector< MX > > &fseed, std::vector< std::vector< MX > > &fsens, bool
57277 always_inline, bool never_inline) const  "
57278 
57279 [INTERNAL]  Forward mode AD, virtual functions overloaded in derived
57280 classes.
57281 
57282 ";
57283 
57284 %feature("docstring")  casadi::FunctionInternal::call_forward(const
57285 std::vector< SX > &arg, const std::vector< SX > &res, const std::vector<
57286 std::vector< SX > > &fseed, std::vector< std::vector< SX > > &fsens, bool
57287 always_inline, bool never_inline) const  "
57288 
57289 [INTERNAL]  Forward mode AD, virtual functions overloaded in derived
57290 classes.
57291 
57292 ";
57293 
57294 %feature("docstring")  casadi::FunctionInternal::dm_in(casadi_int ind) const
57295 "
57296 
57297 [INTERNAL]  Get function input(s) and output(s)
57298 
57299 ";
57300 
57301 %feature("docstring")  casadi::FunctionInternal::dm_in() const  "
57302 
57303 [INTERNAL]  Get function input(s) and output(s)
57304 
57305 ";
57306 
57307 %feature("docstring")  casadi::FunctionInternal::index_out(const std::string
57308 &name) const  "
57309 
57310 [INTERNAL]  Get output scheme index by name.
57311 
57312 ";
57313 
57314 %feature("docstring")  casadi::Newton::get_stats(void *mem) const  "
57315 
57316 [INTERNAL]  Get all statistics.
57317 
57318 ";
57319 
57320 %feature("docstring")  casadi::FunctionInternal::codegen_mem(CodeGenerator
57321 &g, const std::string &index="mem") const  "
57322 
57323 [INTERNAL]  Get thread-local memory object.
57324 
57325 ";
57326 
57327 %feature("docstring")  casadi::FunctionInternal::signature(const std::string
57328 &fname) const  "
57329 
57330 [INTERNAL]  Code generate the function.
57331 
57332 ";
57333 
57334 %feature("docstring")  casadi::FunctionInternal::size_in(casadi_int ind)
57335 const  "
57336 
57337 [INTERNAL]  Input/output dimensions.
57338 
57339 ";
57340 
57341 %feature("docstring")  casadi::FunctionInternal::ad_weight() const  "
57342 
57343 [INTERNAL]  Weighting factor for chosing forward/reverse mode.
57344 
57345 ";
57346 
57347 %feature("docstring")  casadi::FunctionInternal::get_jac(const std::string
57348 &name, const std::vector< std::string > &inames, const std::vector<
57349 std::string > &onames, const Dict &opts) const  "
57350 
57351 [INTERNAL]  Return Jacobian of all input elements with respect to all output
57352 elements.
57353 
57354 ";
57355 
57356 %feature("docstring")
57357 casadi::FunctionInternal::getJacSparsityGen(casadi_int iind, casadi_int
57358 oind, bool symmetric, casadi_int gr_i=1, casadi_int gr_o=1) const  "
57359 
57360 [INTERNAL]  Get the sparsity pattern, forward mode.
57361 
57362 ";
57363 
57364 %feature("docstring")  casadi::Rootfinder::get_name_out(casadi_int i)  "
57365 
57366 [INTERNAL]  Names of function input and outputs.
57367 
57368 ";
57369 
57370 %feature("docstring")  casadi::FunctionInternal::map(casadi_int n, const
57371 std::string &parallelization) const  "
57372 
57373 [INTERNAL]  Generate/retrieve cached serial map.
57374 
57375 ";
57376 
57377 %feature("docstring")  casadi::ProtoFunction::memory(int ind) const  "
57378 
57379 [INTERNAL]  Memory objects.
57380 
57381 ";
57382 
57383 %feature("docstring")  casadi::FunctionInternal::wrap() const  "
57384 
57385 [INTERNAL]  Wrap in an Function instance consisting of only one MX call.
57386 
57387 ";
57388 
57389 %feature("docstring")  casadi::FunctionInternal::numel_out(casadi_int ind)
57390 const  "
57391 
57392 [INTERNAL]  Number of input/output elements.
57393 
57394 ";
57395 
57396 %feature("docstring")  casadi::FunctionInternal::numel_out() const  "
57397 
57398 [INTERNAL]  Number of input/output elements.
57399 
57400 ";
57401 
57402 %feature("docstring")  casadi::Rootfinder::get_n_in()  "
57403 
57404 [INTERNAL]  Number of function inputs and outputs.
57405 
57406 ";
57407 
57408 %feature("docstring")  casadi::FunctionInternal::eval_gen(const double
57409 **arg, double **res, casadi_int *iw, double *w, void *mem) const  "
57410 
57411 [INTERNAL]  Evaluate numerically.
57412 
57413 ";
57414 
57415 %feature("docstring")  casadi::FunctionInternal::eval_gen(const SXElem
57416 **arg, SXElem **res, casadi_int *iw, SXElem *w, void *mem) const  "
57417 
57418 [INTERNAL]  Evaluate a function, overloaded.
57419 
57420 ";
57421 
57422 %feature("docstring")  casadi::FunctionInternal::eval_gen(const bvec_t
57423 **arg, bvec_t **res, casadi_int *iw, bvec_t *w, void *mem) const  "
57424 
57425 [INTERNAL]  Evaluate a function, overloaded.
57426 
57427 ";
57428 
57429 %feature("docstring")
57430 casadi::FunctionInternal::instruction_output(casadi_int k) const  "
57431 
57432 [INTERNAL]  Get the (integer) output argument of an atomic operation.
57433 
57434 ";
57435 
57436 %feature("docstring")  casadi::OracleFunction::set_function(const Function
57437 &fcn, const std::string &fname, bool jit=false) "
57438 
57439 [INTERNAL]  Register the function for evaluation and statistics gathering
57440 
57441 ";
57442 
57443 %feature("docstring")  casadi::OracleFunction::set_function(const Function
57444 &fcn) "
57445 
57446 [INTERNAL]  Register the function for evaluation and statistics gathering
57447 
57448 ";
57449 
57450 %feature("docstring")  casadi::FunctionInternal::matching_arg(const
57451 std::vector< M > &arg, casadi_int &npar) const  "
57452 
57453 [INTERNAL]  Check if input arguments that needs to be replaced.
57454 
57455 Raises errors
57456 
57457 Parameters:
57458 -----------
57459 
57460 npar[in]:  normal usage: 1, disallow pararallel calls: -1
57461 
57462 npar:  max number of horizontal repetitions across all arguments (or -1)
57463 
57464 ";
57465 
57466 %feature("docstring")  casadi::FunctionInternal::disp(std::ostream &stream,
57467 bool more) const  "
57468 
57469 [INTERNAL]  Display object.
57470 
57471 ";
57472 
57473 %feature("docstring")  casadi::FunctionInternal::size1_in(casadi_int ind)
57474 const  "
57475 
57476 [INTERNAL]  Input/output dimensions.
57477 
57478 ";
57479 
57480 %feature("docstring")  casadi::SharedObjectInternal::weak() "
57481 
57482 [INTERNAL]  Get a weak reference to the object.
57483 
57484 ";
57485 
57486 %feature("docstring")  casadi::FunctionInternal::free_sx() const  "
57487 
57488 [INTERNAL]  Get free variables (SX)
57489 
57490 ";
57491 
57492 %feature("docstring")  casadi::Newton::set_work(void *mem, const double
57493 **&arg, double **&res, casadi_int *&iw, double *&w) const  "
57494 
57495 [INTERNAL]  Set the (persistent) work vectors.
57496 
57497 ";
57498 
57499 %feature("docstring")  casadi::FunctionInternal::get_min_in(casadi_int ind)
57500 const  "
57501 
57502 [INTERNAL]  Get smallest input value.
57503 
57504 ";
57505 
57506 %feature("docstring")  casadi::FunctionInternal::replace_arg(const
57507 std::vector< M > &arg, casadi_int npar) const  "
57508 
57509 [INTERNAL]  Replace 0-by-0 inputs.
57510 
57511 ";
57512 
57513 %feature("docstring")  casadi::FunctionInternal::replace_res(const
57514 std::vector< M > &res, casadi_int npar) const  "
57515 
57516 [INTERNAL]  Replace 0-by-0 outputs.
57517 
57518 ";
57519 
57520 %feature("docstring")  casadi::FunctionInternal::size2_out(casadi_int ind)
57521 const  "
57522 
57523 [INTERNAL]  Input/output dimensions.
57524 
57525 ";
57526 
57527 %feature("docstring")  casadi::FunctionInternal::has_derivative() const  "
57528 
57529 [INTERNAL]  Can derivatives be calculated in any way?
57530 
57531 ";
57532 
57533 %feature("docstring")  casadi::FunctionInternal::is_diff_out(casadi_int i) "
57534 
57535 [INTERNAL] ";
57536 
57537 %feature("docstring")  casadi::FunctionInternal::call_reverse(const
57538 std::vector< MX > &arg, const std::vector< MX > &res, const std::vector<
57539 std::vector< MX > > &aseed, std::vector< std::vector< MX > > &asens, bool
57540 always_inline, bool never_inline) const  "
57541 
57542 [INTERNAL]  Reverse mode, virtual functions overloaded in derived classes.
57543 
57544 ";
57545 
57546 %feature("docstring")  casadi::FunctionInternal::call_reverse(const
57547 std::vector< SX > &arg, const std::vector< SX > &res, const std::vector<
57548 std::vector< SX > > &aseed, std::vector< std::vector< SX > > &asens, bool
57549 always_inline, bool never_inline) const  "
57550 
57551 [INTERNAL]  Reverse mode, virtual functions overloaded in derived classes.
57552 
57553 ";
57554 
57555 %feature("docstring")  casadi::Newton::init_mem(void *mem) const  "
57556 
57557 [INTERNAL]  Initalize memory block.
57558 
57559 ";
57560 
57561 %feature("docstring")  casadi::FunctionInternal::eval_dm(const std::vector<
57562 DM > &arg) const  "
57563 
57564 [INTERNAL]  Evaluate with DM matrices.
57565 
57566 ";
57567 
57568 %feature("docstring")  casadi::FunctionInternal::sz_work(size_t &sz_arg,
57569 size_t &sz_res, size_t &sz_iw, size_t &sz_w) const  "
57570 
57571 [INTERNAL]  Get number of temporary variables needed.
57572 
57573 ";
57574 
57575 %feature("docstring")  casadi::FunctionInternal::factory(const std::string
57576 &name, const std::vector< std::string > &s_in, const std::vector<
57577 std::string > &s_out, const Function::AuxOut &aux, const Dict &opts) const
57578 "
57579 
57580 [INTERNAL] ";
57581 
57582 %feature("docstring")  casadi::FunctionInternal::has_free() const  "
57583 
57584 [INTERNAL]  Does the function have free variables.
57585 
57586 ";
57587 
57588 %feature("docstring")  casadi::FunctionInternal::size_out(casadi_int ind)
57589 const  "
57590 
57591 [INTERNAL]  Input/output dimensions.
57592 
57593 ";
57594 
57595 %feature("docstring")  casadi::FunctionInternal::get_jacobian_sparsity()
57596 const  "
57597 
57598 [INTERNAL]  Get Jacobian sparsity.
57599 
57600 ";
57601 
57602 %feature("docstring")  casadi::FunctionInternal::instructions_sx() const  "
57603 
57604 [INTERNAL]  get SX expression associated with instructions
57605 
57606 ";
57607 
57608 %feature("docstring")  casadi::Rootfinder::has_forward(casadi_int nfwd)
57609 const  "
57610 
57611 [INTERNAL]  Generate a function that calculates nfwd forward derivatives.
57612 
57613 ";
57614 
57615 %feature("docstring")  casadi::Rootfinder::eval(const double **arg, double
57616 **res, casadi_int *iw, double *w, void *mem) const  "
57617 
57618 [INTERNAL]  Evaluate numerically.
57619 
57620 ";
57621 
57622 %feature("docstring")  casadi::FunctionInternal::call_gen(const MXVector
57623 &arg, MXVector &res, casadi_int npar, bool always_inline, bool never_inline)
57624 const  "
57625 
57626 [INTERNAL]   Call a function, overloaded.
57627 
57628 ";
57629 
57630 %feature("docstring")  casadi::FunctionInternal::call_gen(const std::vector<
57631 MatrixCommon > &arg, std::vector< MatrixCommon > &res, casadi_int npar, bool
57632 always_inline, bool never_inline) const  "
57633 
57634 [INTERNAL]   Call a function, overloaded.
57635 
57636 ";
57637 
57638 %feature("docstring")  casadi::ProtoFunction::serialize(SerializingStream
57639 &s) const  "
57640 
57641 [INTERNAL]  Serialize an object.
57642 
57643 ";
57644 
57645 %feature("docstring")  casadi::FunctionInternal::eval_mx(const MXVector
57646 &arg, MXVector &res, bool always_inline, bool never_inline) const  "
57647 
57648 [INTERNAL]  Evaluate with symbolic matrices.
57649 
57650 ";
57651 
57652 %feature("docstring")  casadi::FunctionInternal::sx_out(casadi_int ind)
57653 const  "
57654 
57655 [INTERNAL]  Get function input(s) and output(s)
57656 
57657 ";
57658 
57659 %feature("docstring")  casadi::FunctionInternal::sx_out() const  "
57660 
57661 [INTERNAL]  Get function input(s) and output(s)
57662 
57663 ";
57664 
57665 %feature("docstring")  casadi::FunctionInternal::wrap_as_needed(const Dict
57666 &opts) const  "
57667 
57668 [INTERNAL]  Wrap in an Function instance consisting of only one MX call.
57669 
57670 ";
57671 
57672 %feature("docstring")  casadi::FunctionInternal::free_mx() const  "
57673 
57674 [INTERNAL]  Get free variables ( MX)
57675 
57676 ";
57677 
57678 %feature("docstring")  casadi::FunctionInternal::has_jacobian_sparsity()
57679 const  "
57680 
57681 [INTERNAL]  Get Jacobian sparsity.
57682 
57683 ";
57684 
57685 %feature("docstring")  casadi::Newton::solve(void *mem) const  "
57686 
57687 [INTERNAL]   Solve the system of equations and calculate derivatives.
57688 
57689 ";
57690 
57691 %feature("docstring") casadi::casadi_solve "
57692 
57693 Solve the system of equations and calculate derivatives.
57694 
57695 ";
57696 
57697 %feature("docstring")  casadi::Newton::casadi_solve "
57698 
57699 Solve the system of equations and calculate derivatives.
57700 
57701 ";
57702 
57703 %feature("docstring")  casadi::OracleFunction::finalize()  "
57704 
57705 [INTERNAL]  Finalize initialization.
57706 
57707 ";
57708 
57709 %feature("docstring")  casadi::FunctionInternal::print_option(const
57710 std::string &name, std::ostream &stream) const  "
57711 
57712 [INTERNAL]  Print all information there is to know about a certain option.
57713 
57714 ";
57715 
57716 
57717 // File: classcasadi_1_1NlpBuilder.xml
57718 
57719 
57720 /*  Symbolic representation of the NLP  */
57721 
57722 /* Data members
57723 
57724 */ %feature("docstring") casadi::NlpBuilder "
57725 
57726 A symbolic NLP representation.
57727 
57728 Joel Andersson
57729 
57730 C++ includes: nlp_builder.hpp ";
57731 
57732 %feature("docstring")  casadi::NlpBuilder::type_name() const  "
57733 
57734 Readable name of the class.
57735 
57736 ";
57737 
57738 %feature("docstring")  casadi::NlpBuilder::import_nl(const std::string
57739 &filename, const Dict &opts=Dict()) "
57740 
57741 Import an .nl file.
57742 
57743 ";
57744 
57745 %feature("docstring")  casadi::NlpBuilder::get_str(bool more=false) const  "
57746 
57747 Get string representation.
57748 
57749 ";
57750 
57751 %feature("docstring")  casadi::NlpBuilder::disp(std::ostream &stream, bool
57752 more=false) const  "
57753 
57754 Print a description of the object.
57755 
57756 ";
57757 
57758 
57759 // File: classcasadi_1_1Nlpsol.xml
57760 %feature("docstring")  casadi::Nlpsol::callback(NlpsolMemory *m) const  "
57761 
57762 [INTERNAL] ";
57763 
57764 %feature("docstring")  casadi::FunctionInternal::check_mat(const Sparsity
57765 &arg, const Sparsity &inp, casadi_int &npar) "
57766 
57767 [INTERNAL]  Helper function
57768 
57769 Parameters:
57770 -----------
57771 
57772 npar[in]:  normal usage: 1, disallow pararallel calls: -1
57773 
57774 npar[out]:  required number of parallel calls (or -1)
57775 
57776 ";
57777 
57778 %feature("docstring")  casadi::FunctionInternal::is_diff_out(casadi_int i) "
57779 
57780 [INTERNAL] ";
57781 
57782 %feature("docstring")  casadi::FunctionInternal::alloc(const Function &f,
57783 bool persistent=false) "
57784 
57785 [INTERNAL]  Ensure work vectors long enough to evaluate function.
57786 
57787 ";
57788 
57789 %feature("docstring")
57790 casadi::FunctionInternal::codegen_declarations(CodeGenerator &g) const  "
57791 
57792 [INTERNAL]  Generate code for the declarations of the C function.
57793 
57794 ";
57795 
57796 %feature("docstring")  casadi::FunctionInternal::jacobian_sparsity() const
57797 "
57798 
57799 [INTERNAL]  Get Jacobian sparsity.
57800 
57801 ";
57802 
57803 %feature("docstring")  casadi::FunctionInternal::mapsum_mx(const
57804 std::vector< MX > &arg, const std::string &parallelization) "
57805 
57806 [INTERNAL]  Parallel evaluation.
57807 
57808 ";
57809 
57810 %feature("docstring")  casadi::ProtoFunction::format_time(char *buffer,
57811 double time) const  "
57812 
57813 [INTERNAL]  Format time in a fixed width 8 format.
57814 
57815 ";
57816 
57817 %feature("docstring")  casadi::ProtoFunction::memory(int ind) const  "
57818 
57819 [INTERNAL]  Memory objects.
57820 
57821 ";
57822 
57823 %feature("docstring")  casadi::FunctionInternal::get_reltol() const  "
57824 
57825 [INTERNAL]  Get relative tolerance.
57826 
57827 ";
57828 
57829 %feature("docstring")  casadi::FunctionInternal::size1_out(casadi_int ind)
57830 const  "
57831 
57832 [INTERNAL]  Input/output dimensions.
57833 
57834 ";
57835 
57836 %feature("docstring")  casadi::Nlpsol::get_sparsity_in(casadi_int i)  "
57837 
57838 [INTERNAL]  Sparsities of function inputs and outputs.
57839 
57840 ";
57841 
57842 %feature("docstring")  casadi::FunctionInternal::sz_iw() const  "
57843 
57844 [INTERNAL]  Get required length of iw field.
57845 
57846 ";
57847 
57848 %feature("docstring")  casadi::FunctionInternal::call_forward(const
57849 std::vector< MX > &arg, const std::vector< MX > &res, const std::vector<
57850 std::vector< MX > > &fseed, std::vector< std::vector< MX > > &fsens, bool
57851 always_inline, bool never_inline) const  "
57852 
57853 [INTERNAL]  Forward mode AD, virtual functions overloaded in derived
57854 classes.
57855 
57856 ";
57857 
57858 %feature("docstring")  casadi::FunctionInternal::call_forward(const
57859 std::vector< SX > &arg, const std::vector< SX > &res, const std::vector<
57860 std::vector< SX > > &fseed, std::vector< std::vector< SX > > &fsens, bool
57861 always_inline, bool never_inline) const  "
57862 
57863 [INTERNAL]  Forward mode AD, virtual functions overloaded in derived
57864 classes.
57865 
57866 ";
57867 
57868 %feature("docstring")  casadi::FunctionInternal::matching_arg(const
57869 std::vector< M > &arg, casadi_int &npar) const  "
57870 
57871 [INTERNAL]  Check if input arguments that needs to be replaced.
57872 
57873 Raises errors
57874 
57875 Parameters:
57876 -----------
57877 
57878 npar[in]:  normal usage: 1, disallow pararallel calls: -1
57879 
57880 npar:  max number of horizontal repetitions across all arguments (or -1)
57881 
57882 ";
57883 
57884 %feature("docstring")  casadi::OracleFunction::get_function() const  "
57885 
57886 [INTERNAL]  Get list of dependency functions -1 Indicates irregularity.
57887 
57888 ";
57889 
57890 %feature("docstring")  casadi::OracleFunction::get_function(const
57891 std::string &name) const  "
57892 
57893 [INTERNAL] ";
57894 
57895 %feature("docstring")  casadi::Nlpsol::serialize_type(SerializingStream &s)
57896 const  "
57897 
57898 [INTERNAL]  Serialize type information.
57899 
57900 ";
57901 
57902 %feature("docstring")  casadi::ProtoFunction::clear_mem() "
57903 
57904 [INTERNAL]  Clear all memory (called from destructor)
57905 
57906 ";
57907 
57908 %feature("docstring")  casadi::FunctionInternal::signature(const std::string
57909 &fname) const  "
57910 
57911 [INTERNAL]  Code generate the function.
57912 
57913 ";
57914 
57915 %feature("docstring")  casadi::FunctionInternal::mx_in(casadi_int ind) const
57916 "
57917 
57918 [INTERNAL]  Get function input(s) and output(s)
57919 
57920 ";
57921 
57922 %feature("docstring")  casadi::FunctionInternal::mx_in() const  "
57923 
57924 [INTERNAL]  Get function input(s) and output(s)
57925 
57926 ";
57927 
57928 %feature("docstring")  casadi::FunctionInternal::has_jac() const  "
57929 
57930 [INTERNAL]  Return Jacobian of all input elements with respect to all output
57931 elements.
57932 
57933 ";
57934 
57935 %feature("docstring")  casadi::FunctionInternal::get_jacobian(const
57936 std::string &name, const std::vector< std::string > &inames, const
57937 std::vector< std::string > &onames, const Dict &opts) const  "
57938 
57939 [INTERNAL]  Return Jacobian of all input elements with respect to all output
57940 elements.
57941 
57942 ";
57943 
57944 %feature("docstring")
57945 casadi::FunctionInternal::instruction_input(casadi_int k) const  "
57946 
57947 [INTERNAL]  Get the (integer) input arguments of an atomic operation.
57948 
57949 ";
57950 
57951 %feature("docstring")  casadi::ProtoFunction::sprint(char *buf, size_t
57952 buf_sz, const char *fmt,...) const  "
57953 
57954 [INTERNAL]  C-style formatted printing to string.
57955 
57956 ";
57957 
57958 %feature("docstring") casadi::Nlpsol::Nlpsol(const std::string &name, const
57959 Function &oracle) "
57960 
57961 [INTERNAL]  Constructor.
57962 
57963 ";
57964 
57965 %feature("docstring")  casadi::FunctionInternal::project_res(const
57966 std::vector< M > &arg, casadi_int npar) const  "
57967 
57968 [INTERNAL]   Project sparsities.
57969 
57970 ";
57971 
57972 %feature("docstring")  casadi::Nlpsol::disp_more(std::ostream &stream) const
57973 "
57974 
57975 [INTERNAL]  Print description.
57976 
57977 ";
57978 
57979 %feature("docstring")  casadi::Nlpsol::alloc_mem() const  "
57980 
57981 [INTERNAL]  Create memory block.
57982 
57983 ";
57984 
57985 %feature("docstring")  casadi::FunctionInternal::convert_res(const
57986 std::vector< M > &res) const  "
57987 
57988 [INTERNAL]  Convert from/to input/output lists/map.
57989 
57990 ";
57991 
57992 %feature("docstring")  casadi::FunctionInternal::convert_res(const std::map<
57993 std::string, M > &res) const  "
57994 
57995 [INTERNAL]  Convert from/to input/output lists/map.
57996 
57997 ";
57998 
57999 %feature("docstring")  casadi::Nlpsol::getReducedHessian() "
58000 
58001 [INTERNAL] ";
58002 
58003 %feature("docstring")  casadi::FunctionInternal::sparsity_out(casadi_int
58004 ind) const  "
58005 
58006 [INTERNAL]  Input/output sparsity.
58007 
58008 ";
58009 
58010 %feature("docstring")  casadi::FunctionInternal::generate_in(const
58011 std::string &fname, const double **arg) const  "
58012 
58013 [INTERNAL]  Export an input file that can be passed to generate C code with
58014 a main.
58015 
58016 ";
58017 
58018 %feature("docstring")  casadi::FunctionInternal::wrap() const  "
58019 
58020 [INTERNAL]  Wrap in an Function instance consisting of only one MX call.
58021 
58022 ";
58023 
58024 %feature("docstring")  casadi::FunctionInternal::getJacSparsity(casadi_int
58025 iind, casadi_int oind, bool symmetric) const  "
58026 
58027 [INTERNAL]  Generate the sparsity of a Jacobian block.
58028 
58029 ";
58030 
58031 %feature("docstring")  casadi::FunctionInternal::get_abstol() const  "
58032 
58033 [INTERNAL]  Get absolute tolerance.
58034 
58035 ";
58036 
58037 %feature("docstring")  casadi::FunctionInternal::has_spfwd() const  "
58038 
58039 [INTERNAL]  Is the class able to propagate seeds through the algorithm?
58040 
58041 ";
58042 
58043 %feature("docstring")
58044 casadi::FunctionInternal::codegen_sparsities(CodeGenerator &g) const  "
58045 
58046 [INTERNAL]  Codegen sparsities.
58047 
58048 ";
58049 
58050 %feature("docstring")  casadi::SharedObjectInternal::getCount() const  "
58051 
58052 [INTERNAL]  Get the reference count.
58053 
58054 ";
58055 
58056 %feature("docstring")  casadi::FunctionInternal::get_min_in(casadi_int ind)
58057 const  "
58058 
58059 [INTERNAL]  Get smallest input value.
58060 
58061 ";
58062 
58063 %feature("docstring")  casadi::FunctionInternal::n_nodes() const  "
58064 
58065 [INTERNAL]  Number of nodes in the algorithm.
58066 
58067 ";
58068 
58069 %feature("docstring")  casadi::FunctionInternal::codegen_mem_type() const  "
58070 
58071 [INTERNAL]  Thread-local memory object type.
58072 
58073 ";
58074 
58075 %feature("docstring")  casadi::FunctionInternal::has_codegen() const  "
58076 
58077 [INTERNAL]  Is codegen supported?
58078 
58079 ";
58080 
58081 %feature("docstring")  casadi::Nlpsol::get_options() const  "
58082 
58083 [INTERNAL]  Options.
58084 
58085 ";
58086 
58087 %feature("docstring")  casadi::FunctionInternal::replace_arg(const
58088 std::vector< M > &arg, casadi_int npar) const  "
58089 
58090 [INTERNAL]  Replace 0-by-0 inputs.
58091 
58092 ";
58093 
58094 %feature("docstring")  casadi::Nlpsol::get_reverse(casadi_int nadj, const
58095 std::string &name, const std::vector< std::string > &inames, const
58096 std::vector< std::string > &onames, const Dict &opts) const  "
58097 
58098 [INTERNAL]  Generate a function that calculates reverse mode derivatives.
58099 
58100 ";
58101 
58102 %feature("docstring")  casadi::FunctionInternal::has_jacobian() const  "
58103 
58104 [INTERNAL]  Return Jacobian of all input elements with respect to all output
58105 elements.
58106 
58107 ";
58108 
58109 %feature("docstring")  casadi::Nlpsol::get_sparsity_out(casadi_int i)  "
58110 
58111 [INTERNAL]  Sparsities of function inputs and outputs.
58112 
58113 ";
58114 
58115 %feature("docstring")  casadi::FunctionInternal::size1_in(casadi_int ind)
58116 const  "
58117 
58118 [INTERNAL]  Input/output dimensions.
58119 
58120 ";
58121 
58122 %feature("docstring")
58123 casadi::FunctionInternal::codegen_free_mem(CodeGenerator &g) const  "
58124 
58125 [INTERNAL]  Codegen for free_mem.
58126 
58127 ";
58128 
58129 %feature("docstring")  casadi::Nlpsol::nlpsol_codegen_body(CodeGenerator &g)
58130 const  "
58131 
58132 [INTERNAL]  Generate code for the function body.
58133 
58134 ";
58135 
58136 %feature("docstring")  casadi::OracleFunction::finalize()  "
58137 
58138 [INTERNAL]  Finalize initialization.
58139 
58140 ";
58141 
58142 %feature("docstring")  casadi::FunctionInternal::alloc_arg(size_t sz_arg,
58143 bool persistent=false) "
58144 
58145 [INTERNAL]  Ensure required length of arg field.
58146 
58147 ";
58148 
58149 %feature("docstring")  casadi::Nlpsol::eval(const double **arg, double
58150 **res, casadi_int *iw, double *w, void *mem) const final "
58151 
58152 [INTERNAL]  Evaluate numerically.
58153 
58154 ";
58155 
58156 %feature("docstring")  casadi::FunctionInternal::all_scalar() const  "
58157 
58158 [INTERNAL]  Are all inputs and outputs scalar.
58159 
58160 ";
58161 
58162 %feature("docstring")  casadi::OracleFunction::monitored(const std::string
58163 &name) const  "
58164 
58165 [INTERNAL] ";
58166 
58167 %feature("docstring")  casadi::FunctionInternal::symbolic_output(const
58168 std::vector< MX > &arg) const  "
58169 
58170 [INTERNAL]  Get a vector of symbolic variables corresponding to the outputs.
58171 
58172 ";
58173 
58174 %feature("docstring")  casadi::FunctionInternal::factory(const std::string
58175 &name, const std::vector< std::string > &s_in, const std::vector<
58176 std::string > &s_out, const Function::AuxOut &aux, const Dict &opts) const
58177 "
58178 
58179 [INTERNAL] ";
58180 
58181 %feature("docstring")  casadi::FunctionInternal::get_jacobian_sparsity()
58182 const  "
58183 
58184 [INTERNAL]  Get Jacobian sparsity.
58185 
58186 ";
58187 
58188 %feature("docstring")  casadi::FunctionInternal::tocache(const Function &f,
58189 const std::string &suffix="") const  "
58190 
58191 [INTERNAL]  Save function to cache.
58192 
58193 ";
58194 
58195 %feature("docstring")
58196 casadi::FunctionInternal::getJacSparsityHierarchical(casadi_int iind,
58197 casadi_int oind) const  "
58198 
58199 [INTERNAL]  A flavor of getJacSparsity that does hierarchical block
58200 structure recognition.
58201 
58202 ";
58203 
58204 %feature("docstring")  casadi::FunctionInternal::reverse(casadi_int nadj)
58205 const  "
58206 
58207 [INTERNAL]  Return function that calculates adjoint derivatives
58208 reverse(nadj) returns a cached instance if available, and calls  Function
58209 get_reverse(casadi_int nadj) if no cached version is available.
58210 
58211 ";
58212 
58213 %feature("docstring")  casadi::FunctionInternal::n_instructions() const  "
58214 
58215 [INTERNAL]  Get the number of atomic operations.
58216 
58217 ";
58218 
58219 %feature("docstring")  casadi::FunctionInternal::export_code(const
58220 std::string &lang, std::ostream &stream, const Dict &options) const  "
58221 
58222 [INTERNAL]  Export function in a specific language.
58223 
58224 ";
58225 
58226 %feature("docstring")  casadi::FunctionInternal::instructions_sx() const  "
58227 
58228 [INTERNAL]  get SX expression associated with instructions
58229 
58230 ";
58231 
58232 %feature("docstring")  casadi::FunctionInternal::nnz_in() const  "
58233 
58234 [INTERNAL]  Number of input/output nonzeros.
58235 
58236 ";
58237 
58238 %feature("docstring")  casadi::FunctionInternal::nnz_in(casadi_int ind)
58239 const  "
58240 
58241 [INTERNAL]  Number of input/output nonzeros.
58242 
58243 ";
58244 
58245 %feature("docstring")  casadi::SharedObjectInternal::weak() "
58246 
58247 [INTERNAL]  Get a weak reference to the object.
58248 
58249 ";
58250 
58251 %feature("docstring")  casadi::Nlpsol::setOptionsFromFile(const std::string
58252 &file) "
58253 
58254 [INTERNAL]  Read options from parameter xml.
58255 
58256 ";
58257 
58258 %feature("docstring")  casadi::Nlpsol::get_name_in(casadi_int i)  "
58259 
58260 [INTERNAL]  Names of function input and outputs.
58261 
58262 ";
58263 
58264 %feature("docstring")  casadi::FunctionInternal::check_res(const
58265 std::vector< M > &res, casadi_int &npar) const  "
58266 
58267 [INTERNAL]  Check if output arguments have correct length and dimensions.
58268 
58269 Raises errors.
58270 
58271 Parameters:
58272 -----------
58273 
58274 npar[in]:  normal usage: 1, disallow pararallel calls: -1
58275 
58276 npar:  max number of horizontal repetitions across all arguments (or -1)
58277 
58278 ";
58279 
58280 %feature("docstring")  casadi::FunctionInternal::sz_res() const  "
58281 
58282 [INTERNAL]  Get required length of res field.
58283 
58284 ";
58285 
58286 %feature("docstring")  casadi::FunctionInternal::adjViaJac(casadi_int nadj)
58287 const  "
58288 
58289 [INTERNAL]  Calculate derivatives by multiplying the full Jacobian and
58290 multiplying.
58291 
58292 ";
58293 
58294 %feature("docstring")  casadi::OracleFunction::set_function(const Function
58295 &fcn, const std::string &fname, bool jit=false) "
58296 
58297 [INTERNAL]  Register the function for evaluation and statistics gathering
58298 
58299 ";
58300 
58301 %feature("docstring")  casadi::OracleFunction::set_function(const Function
58302 &fcn) "
58303 
58304 [INTERNAL]  Register the function for evaluation and statistics gathering
58305 
58306 ";
58307 
58308 %feature("docstring")  casadi::ProtoFunction::release(int mem) const  "
58309 
58310 [INTERNAL]  Release a memory object.
58311 
58312 ";
58313 
58314 %feature("docstring")
58315 casadi::FunctionInternal::getJacSparsityHierarchicalSymm(casadi_int iind,
58316 casadi_int oind) const  "
58317 
58318 [INTERNAL]  A flavor of getJacSparsity that does hierarchical block
58319 structure recognition for symmetric Jacobians
58320 
58321 ";
58322 
58323 %feature("docstring")  casadi::FunctionInternal::nnz_out() const  "
58324 
58325 [INTERNAL]  Number of input/output nonzeros.
58326 
58327 ";
58328 
58329 %feature("docstring")  casadi::FunctionInternal::nnz_out(casadi_int ind)
58330 const  "
58331 
58332 [INTERNAL]  Number of input/output nonzeros.
58333 
58334 ";
58335 
58336 %feature("docstring")  casadi::Nlpsol::get_n_in()  "
58337 
58338 [INTERNAL]  Number of function inputs and outputs.
58339 
58340 ";
58341 
58342 %feature("docstring")  casadi::Nlpsol::serialize_body(SerializingStream &s)
58343 const  "
58344 
58345 [INTERNAL]  Serialize an object without type information.
58346 
58347 ";
58348 
58349 %feature("docstring")  casadi::FunctionInternal::sp_forward(const bvec_t
58350 **arg, bvec_t **res, casadi_int *iw, bvec_t *w, void *mem) const  "
58351 
58352 [INTERNAL]  Propagate sparsity forward.
58353 
58354 ";
58355 
58356 %feature("docstring")  casadi::Nlpsol::uses_output() const  "
58357 
58358 [INTERNAL]  Do the derivative functions need nondifferentiated outputs?
58359 
58360 ";
58361 
58362 %feature("docstring")  casadi::OracleFunction::set_temp(void *mem, const
58363 double **arg, double **res, casadi_int *iw, double *w) const  "
58364 
58365 [INTERNAL]  Set the work vectors.
58366 
58367 ";
58368 
58369 %feature("docstring")  casadi::Nlpsol::get_forward(casadi_int nfwd, const
58370 std::string &name, const std::vector< std::string > &inames, const
58371 std::vector< std::string > &onames, const Dict &opts) const  "
58372 
58373 [INTERNAL]  Generate a function that calculates forward mode derivatives.
58374 
58375 ";
58376 
58377 %feature("docstring")  casadi::Nlpsol::is_a(const std::string &type, bool
58378 recursive) const  "
58379 
58380 [INTERNAL]  Check if the function is of a particular type.
58381 
58382 ";
58383 
58384 %feature("docstring")  casadi::FunctionInternal::project_arg(const
58385 std::vector< M > &arg, casadi_int npar) const  "
58386 
58387 [INTERNAL]   Project sparsities.
58388 
58389 ";
58390 
58391 %feature("docstring")  casadi::FunctionInternal::generate_options(bool
58392 is_temp=false) const  "
58393 
58394 [INTERNAL]  Reconstruct options dict.
58395 
58396 ";
58397 
58398 %feature("docstring")  casadi::FunctionInternal::get_max_in(casadi_int ind)
58399 const  "
58400 
58401 [INTERNAL]  Get largest input value.
58402 
58403 ";
58404 
58405 %feature("docstring")  casadi::FunctionInternal::info() const  "
58406 
58407 [INTERNAL]  Obtain information about function
58408 
58409 ";
58410 
58411 %feature("docstring")  casadi::FunctionInternal::replace_fseed(const
58412 std::vector< std::vector< M >> &fseed, casadi_int npar) const  "
58413 
58414 [INTERNAL]  Replace 0-by-0 forward seeds.
58415 
58416 ";
58417 
58418 %feature("docstring")  casadi::FunctionInternal::replace_fseed(const
58419 std::vector< std::vector< M > > &fseed, casadi_int npar) const  "
58420 
58421 [INTERNAL] ";
58422 
58423 %feature("docstring")
58424 casadi::FunctionInternal::codegen_init_mem(CodeGenerator &g) const  "
58425 
58426 [INTERNAL]  Codegen decref for init_mem.
58427 
58428 ";
58429 
58430 %feature("docstring")
58431 casadi::FunctionInternal::codegen_incref(CodeGenerator &g) const  "
58432 
58433 [INTERNAL]  Codegen incref for dependencies.
58434 
58435 ";
58436 
58437 %feature("docstring")  casadi::FunctionInternal::has_free() const  "
58438 
58439 [INTERNAL]  Does the function have free variables.
58440 
58441 ";
58442 
58443 %feature("docstring")  casadi::FunctionInternal::free_mx() const  "
58444 
58445 [INTERNAL]  Get free variables ( MX)
58446 
58447 ";
58448 
58449 %feature("docstring")  casadi::FunctionInternal::generate_out(const
58450 std::string &fname, double **res) const  "
58451 
58452 [INTERNAL] ";
58453 
58454 %feature("docstring")  casadi::FunctionInternal::free_sx() const  "
58455 
58456 [INTERNAL]  Get free variables (SX)
58457 
58458 ";
58459 
58460 %feature("docstring")  casadi::OracleFunction::has_function(const
58461 std::string &fname) const  "
58462 
58463 [INTERNAL] ";
58464 
58465 %feature("docstring")  casadi::Nlpsol::serialize_base_function() const  "
58466 
58467 [INTERNAL]  String used to identify the immediate FunctionInternal subclass.
58468 
58469 ";
58470 
58471 %feature("docstring")
58472 casadi::FunctionInternal::getJacSparsityGen(casadi_int iind, casadi_int
58473 oind, bool symmetric, casadi_int gr_i=1, casadi_int gr_o=1) const  "
58474 
58475 [INTERNAL]  Get the sparsity pattern, forward mode.
58476 
58477 ";
58478 
58479 %feature("docstring")  casadi::FunctionInternal::dm_out(casadi_int ind)
58480 const  "
58481 
58482 [INTERNAL]  Get function input(s) and output(s)
58483 
58484 ";
58485 
58486 %feature("docstring")  casadi::FunctionInternal::dm_out() const  "
58487 
58488 [INTERNAL]  Get function input(s) and output(s)
58489 
58490 ";
58491 
58492 %feature("docstring")  casadi::FunctionInternal::codegen(CodeGenerator &g,
58493 const std::string &fname) const  "
58494 
58495 [INTERNAL]  Generate code the function.
58496 
58497 ";
58498 
58499 %feature("docstring")  casadi::FunctionInternal::alloc_res(size_t sz_res,
58500 bool persistent=false) "
58501 
58502 [INTERNAL]  Ensure required length of res field.
58503 
58504 ";
58505 
58506 %feature("docstring")
58507 casadi::FunctionInternal::instruction_output(casadi_int k) const  "
58508 
58509 [INTERNAL]  Get the (integer) output argument of an atomic operation.
58510 
58511 ";
58512 
58513 %feature("docstring")  casadi::Nlpsol::set_work(void *mem, const double
58514 **&arg, double **&res, casadi_int *&iw, double *&w) const  "
58515 
58516 [INTERNAL]  Set the (persistent) work vectors.
58517 
58518 ";
58519 
58520 %feature("docstring")  casadi::FunctionInternal::jac() const  "
58521 
58522 [INTERNAL]  Return Jacobian of all input elements with respect to all output
58523 elements.
58524 
58525 ";
58526 
58527 %feature("docstring")  casadi::ProtoFunction::print_time(const std::map<
58528 std::string, FStats > &fstats) const  "
58529 
58530 [INTERNAL]  Print timing statistics.
58531 
58532 ";
58533 
58534 %feature("docstring")  casadi::FunctionInternal::print_option(const
58535 std::string &name, std::ostream &stream) const  "
58536 
58537 [INTERNAL]  Print all information there is to know about a certain option.
58538 
58539 ";
58540 
58541 %feature("docstring")
58542 casadi::FunctionInternal::codegen_alloc_mem(CodeGenerator &g) const  "
58543 
58544 [INTERNAL]  Codegen decref for alloc_mem.
58545 
58546 ";
58547 
58548 %feature("docstring")  casadi::Nlpsol::get_n_out()  "
58549 
58550 [INTERNAL]  Number of function inputs and outputs.
58551 
58552 ";
58553 
58554 %feature("docstring")  casadi::FunctionInternal::numel_in() const  "
58555 
58556 [INTERNAL]  Number of input/output elements.
58557 
58558 ";
58559 
58560 %feature("docstring")  casadi::FunctionInternal::numel_in(casadi_int ind)
58561 const  "
58562 
58563 [INTERNAL]  Number of input/output elements.
58564 
58565 ";
58566 
58567 %feature("docstring")  casadi::FunctionInternal::fwdViaJac(casadi_int nfwd)
58568 const  "
58569 
58570 [INTERNAL]  Calculate derivatives by multiplying the full Jacobian and
58571 multiplying.
58572 
58573 ";
58574 
58575 %feature("docstring")  casadi::Nlpsol::init_mem(void *mem) const  "
58576 
58577 [INTERNAL]  Initalize memory block.
58578 
58579 ";
58580 
58581 %feature("docstring")  casadi::FunctionInternal::self() const  "
58582 
58583 [INTERNAL]  Get a public class instance.
58584 
58585 ";
58586 
58587 %feature("docstring")  casadi::FunctionInternal::call(const std::vector< M >
58588 &arg, std::vector< M > &res, bool always_inline, bool never_inline) const  "
58589 
58590 [INTERNAL]   Call a function, templated.
58591 
58592 ";
58593 
58594 %feature("docstring")  casadi::Nlpsol::kkt() const  "
58595 
58596 [INTERNAL] ";
58597 
58598 %feature("docstring")  casadi::Nlpsol::solve(void *mem) const  "
58599 
58600 [INTERNAL] ";
58601 
58602 %feature("docstring")
58603 casadi::FunctionInternal::jacobian_sparsity_filter(const Sparsity &sp) const
58604 "
58605 
58606 [INTERNAL]  Filter out nonzeros in the full sparsity jacobian according to
58607 is_diff_in/out.
58608 
58609 ";
58610 
58611 %feature("docstring")  casadi::FunctionInternal::codegen_mem(CodeGenerator
58612 &g, const std::string &index="mem") const  "
58613 
58614 [INTERNAL]  Get thread-local memory object.
58615 
58616 ";
58617 
58618 %feature("docstring")  casadi::FunctionInternal::jacobian() const  "
58619 
58620 [INTERNAL]  Return Jacobian of all input elements with respect to all output
58621 elements.
58622 
58623 ";
58624 
58625 %feature("docstring")  casadi::FunctionInternal::size_in(casadi_int ind)
58626 const  "
58627 
58628 [INTERNAL]  Input/output dimensions.
58629 
58630 ";
58631 
58632 %feature("docstring")  casadi::Nlpsol::has_forward(casadi_int nfwd) const  "
58633 
58634 [INTERNAL]  Generate a function that calculates forward mode derivatives.
58635 
58636 ";
58637 
58638 %feature("docstring")  casadi::OracleFunction::expand() "
58639 
58640 [INTERNAL] ";
58641 
58642 %feature("docstring")  casadi::FunctionInternal::has_eval_dm() const  "
58643 
58644 [INTERNAL]  Evaluate with DM matrices.
58645 
58646 ";
58647 
58648 %feature("docstring")  casadi::FunctionInternal::matching_res(const
58649 std::vector< M > &arg, casadi_int &npar) const  "
58650 
58651 [INTERNAL]  Check if output arguments that needs to be replaced.
58652 
58653 Raises errors
58654 
58655 Parameters:
58656 -----------
58657 
58658 npar[in]:  normal usage: 1, disallow pararallel calls: -1
58659 
58660 npar:  max number of horizontal repetitions across all arguments (or -1)
58661 
58662 ";
58663 
58664 %feature("docstring")  casadi::OracleFunction::calc_function(OracleMemory
58665 *m, const std::string &fcn, const double *const *arg=nullptr) const  "
58666 
58667 [INTERNAL] ";
58668 
58669 %feature("docstring")  casadi::FunctionInternal::wrap_as_needed(const Dict
58670 &opts) const  "
58671 
58672 [INTERNAL]  Wrap in an Function instance consisting of only one MX call.
58673 
58674 ";
58675 
58676 %feature("docstring")  casadi::Nlpsol::has_reverse(casadi_int nadj) const  "
58677 
58678 [INTERNAL]  Generate a function that calculates reverse mode derivatives.
58679 
58680 ";
58681 
58682 %feature("docstring")  casadi::FunctionInternal::alloc_iw(size_t sz_iw, bool
58683 persistent=false) "
58684 
58685 [INTERNAL]  Ensure required length of iw field.
58686 
58687 ";
58688 
58689 %feature("docstring")  casadi::Nlpsol::free_mem(void *mem) const  "
58690 
58691 [INTERNAL]  Free memory block.
58692 
58693 ";
58694 
58695 %feature("docstring")  casadi::FunctionInternal::mx_out(casadi_int ind)
58696 const  "
58697 
58698 [INTERNAL]  Get function input(s) and output(s)
58699 
58700 ";
58701 
58702 %feature("docstring")  casadi::FunctionInternal::mx_out() const  "
58703 
58704 [INTERNAL]  Get function input(s) and output(s)
58705 
58706 ";
58707 
58708 %feature("docstring")  casadi::FunctionInternal::get_jac(const std::string
58709 &name, const std::vector< std::string > &inames, const std::vector<
58710 std::string > &onames, const Dict &opts) const  "
58711 
58712 [INTERNAL]  Return Jacobian of all input elements with respect to all output
58713 elements.
58714 
58715 ";
58716 
58717 %feature("docstring")  casadi::ProtoFunction::serialize(SerializingStream
58718 &s) const  "
58719 
58720 [INTERNAL]  Serialize an object.
58721 
58722 ";
58723 
58724 %feature("docstring")  casadi::Nlpsol::get_default_in(casadi_int ind) const
58725 "
58726 
58727 [INTERNAL]  Get default input value.
58728 
58729 ";
58730 
58731 %feature("docstring")  casadi::OracleFunction::oracle() const  "
58732 
58733 [INTERNAL]  Get oracle.
58734 
58735 ";
58736 
58737 %feature("docstring")  casadi::FunctionInternal::replace_res(const
58738 std::vector< M > &res, casadi_int npar) const  "
58739 
58740 [INTERNAL]  Replace 0-by-0 outputs.
58741 
58742 ";
58743 
58744 %feature("docstring")  casadi::FunctionInternal::print_options(std::ostream
58745 &stream) const  "
58746 
58747 [INTERNAL]  Print list of options.
58748 
58749 ";
58750 
58751 %feature("docstring")  casadi::FunctionInternal::sparsity_jac(casadi_int
58752 iind, casadi_int oind, bool compact, bool symmetric) const  "
58753 
58754 [INTERNAL]  Get, if necessary generate, the sparsity of a Jacobian block.
58755 
58756 ";
58757 
58758 %feature("docstring") casadi::Nlpsol "
58759 
58760 NLP solver storage class.
58761 
58762 Joel Andersson
58763 
58764 >List of available options
58765 
58766 +------------------+-----------------+------------------+------------------+
58767 |        Id        |      Type       |   Description    |     Used in      |
58768 +==================+=================+==================+==================+
58769 | bound_consistenc | OT_BOOL         | Ensure that      | casadi::Nlpsol   |
58770 | y                |                 | primal-dual      |                  |
58771 |                  |                 | solution is      |                  |
58772 |                  |                 | consistent with  |                  |
58773 |                  |                 | the bounds       |                  |
58774 +------------------+-----------------+------------------+------------------+
58775 | calc_f           | OT_BOOL         | Calculate 'f' in | casadi::Nlpsol   |
58776 |                  |                 | the Nlpsol base  |                  |
58777 |                  |                 | class            |                  |
58778 +------------------+-----------------+------------------+------------------+
58779 | calc_g           | OT_BOOL         | Calculate 'g' in | casadi::Nlpsol   |
58780 |                  |                 | the Nlpsol base  |                  |
58781 |                  |                 | class            |                  |
58782 +------------------+-----------------+------------------+------------------+
58783 | calc_lam_p       | OT_BOOL         | Calculate        | casadi::Nlpsol   |
58784 |                  |                 | 'lam_p' in the   |                  |
58785 |                  |                 | Nlpsol base      |                  |
58786 |                  |                 | class            |                  |
58787 +------------------+-----------------+------------------+------------------+
58788 | calc_lam_x       | OT_BOOL         | Calculate        | casadi::Nlpsol   |
58789 |                  |                 | 'lam_x' in the   |                  |
58790 |                  |                 | Nlpsol base      |                  |
58791 |                  |                 | class            |                  |
58792 +------------------+-----------------+------------------+------------------+
58793 | calc_multipliers | OT_BOOL         | Calculate        | casadi::Nlpsol   |
58794 |                  |                 | Lagrange         |                  |
58795 |                  |                 | multipliers in   |                  |
58796 |                  |                 | the Nlpsol base  |                  |
58797 |                  |                 | class            |                  |
58798 +------------------+-----------------+------------------+------------------+
58799 | common_options   | OT_DICT         | Options for      | casadi::OracleFu |
58800 |                  |                 | auto-generated   | nction           |
58801 |                  |                 | functions        |                  |
58802 +------------------+-----------------+------------------+------------------+
58803 | discrete         | OT_BOOLVECTOR   | Indicates which  | casadi::Nlpsol   |
58804 |                  |                 | of the variables |                  |
58805 |                  |                 | are discrete,    |                  |
58806 |                  |                 | i.e. integer-    |                  |
58807 |                  |                 | valued           |                  |
58808 +------------------+-----------------+------------------+------------------+
58809 | error_on_fail    | OT_BOOL         | When the         | casadi::Nlpsol   |
58810 |                  |                 | numerical        |                  |
58811 |                  |                 | process returns  |                  |
58812 |                  |                 | unsuccessfully,  |                  |
58813 |                  |                 | raise an error   |                  |
58814 |                  |                 | (default false). |                  |
58815 +------------------+-----------------+------------------+------------------+
58816 | eval_errors_fata | OT_BOOL         | When errors      | casadi::Nlpsol   |
58817 | l                |                 | occur during     |                  |
58818 |                  |                 | evaluation of    |                  |
58819 |                  |                 | f,g,...,stop the |                  |
58820 |                  |                 | iterations       |                  |
58821 +------------------+-----------------+------------------+------------------+
58822 | expand           | OT_BOOL         | Replace MX with  | casadi::OracleFu |
58823 |                  |                 | SX expressions   | nction           |
58824 |                  |                 | in problem       |                  |
58825 |                  |                 | formulation      |                  |
58826 |                  |                 | [false]          |                  |
58827 +------------------+-----------------+------------------+------------------+
58828 | ignore_check_vec | OT_BOOL         | If set to true,  | casadi::Nlpsol   |
58829 |                  |                 | the input shape  |                  |
58830 |                  |                 | of F will not be |                  |
58831 |                  |                 | checked.         |                  |
58832 +------------------+-----------------+------------------+------------------+
58833 | iteration_callba | OT_FUNCTION     | A function that  | casadi::Nlpsol   |
58834 | ck               |                 | will be called   |                  |
58835 |                  |                 | at each          |                  |
58836 |                  |                 | iteration with   |                  |
58837 |                  |                 | the solver as    |                  |
58838 |                  |                 | input. Check     |                  |
58839 |                  |                 | documentation of |                  |
58840 |                  |                 | Callback .       |                  |
58841 +------------------+-----------------+------------------+------------------+
58842 | iteration_callba | OT_BOOL         | If set to true,  | casadi::Nlpsol   |
58843 | ck_ignore_errors |                 | errors thrown by |                  |
58844 |                  |                 | iteration_callba |                  |
58845 |                  |                 | ck will be       |                  |
58846 |                  |                 | ignored.         |                  |
58847 +------------------+-----------------+------------------+------------------+
58848 | iteration_callba | OT_INT          | Only call the    | casadi::Nlpsol   |
58849 | ck_step          |                 | callback         |                  |
58850 |                  |                 | function every   |                  |
58851 |                  |                 | few iterations.  |                  |
58852 +------------------+-----------------+------------------+------------------+
58853 | min_lam          | OT_DOUBLE       | Minimum allowed  | casadi::Nlpsol   |
58854 |                  |                 | multiplier value |                  |
58855 +------------------+-----------------+------------------+------------------+
58856 | monitor          | OT_STRINGVECTOR | Set of user      | casadi::OracleFu |
58857 |                  |                 | problem          | nction           |
58858 |                  |                 | functions to be  |                  |
58859 |                  |                 | monitored        |                  |
58860 +------------------+-----------------+------------------+------------------+
58861 | no_nlp_grad      | OT_BOOL         | Prevent the      | casadi::Nlpsol   |
58862 |                  |                 | creation of the  |                  |
58863 |                  |                 | 'nlp_grad'       |                  |
58864 |                  |                 | function         |                  |
58865 +------------------+-----------------+------------------+------------------+
58866 | oracle_options   | OT_DICT         | Options to be    | casadi::Nlpsol   |
58867 |                  |                 | passed to the    |                  |
58868 |                  |                 | oracle function  |                  |
58869 +------------------+-----------------+------------------+------------------+
58870 | sens_linsol      | OT_STRING       | Linear solver    | casadi::Nlpsol   |
58871 |                  |                 | used for         |                  |
58872 |                  |                 | parametric       |                  |
58873 |                  |                 | sensitivities    |                  |
58874 |                  |                 | (default 'qr').  |                  |
58875 +------------------+-----------------+------------------+------------------+
58876 | sens_linsol_opti | OT_DICT         | Linear solver    | casadi::Nlpsol   |
58877 | ons              |                 | options used for |                  |
58878 |                  |                 | parametric       |                  |
58879 |                  |                 | sensitivities.   |                  |
58880 +------------------+-----------------+------------------+------------------+
58881 | show_eval_warnin | OT_BOOL         | Show warnings    | casadi::OracleFu |
58882 | gs               |                 | generated from   | nction           |
58883 |                  |                 | function         |                  |
58884 |                  |                 | evaluations      |                  |
58885 |                  |                 | [true]           |                  |
58886 +------------------+-----------------+------------------+------------------+
58887 | specific_options | OT_DICT         | Options for      | casadi::OracleFu |
58888 |                  |                 | specific auto-   | nction           |
58889 |                  |                 | generated        |                  |
58890 |                  |                 | functions,       |                  |
58891 |                  |                 | overwriting the  |                  |
58892 |                  |                 | defaults from    |                  |
58893 |                  |                 | common_options.  |                  |
58894 |                  |                 | Nested           |                  |
58895 |                  |                 | dictionary.      |                  |
58896 +------------------+-----------------+------------------+------------------+
58897 | verbose_init     | OT_BOOL         | Print out timing | casadi::Nlpsol   |
58898 |                  |                 | information      |                  |
58899 |                  |                 | about the        |                  |
58900 |                  |                 | different stages |                  |
58901 |                  |                 | of               |                  |
58902 |                  |                 | initialization   |                  |
58903 +------------------+-----------------+------------------+------------------+
58904 | warn_initial_bou | OT_BOOL         | Warn if the      | casadi::Nlpsol   |
58905 | nds              |                 | initial guess    |                  |
58906 |                  |                 | does not satisfy |                  |
58907 |                  |                 | LBX and UBX      |                  |
58908 +------------------+-----------------+------------------+------------------+
58909 
58910 Diagrams
58911 --------
58912 
58913 
58914 
58915 C++ includes: nlpsol_impl.hpp ";
58916 
58917 %feature("docstring")  casadi::FunctionInternal::call_reverse(const
58918 std::vector< MX > &arg, const std::vector< MX > &res, const std::vector<
58919 std::vector< MX > > &aseed, std::vector< std::vector< MX > > &asens, bool
58920 always_inline, bool never_inline) const  "
58921 
58922 [INTERNAL]  Reverse mode, virtual functions overloaded in derived classes.
58923 
58924 ";
58925 
58926 %feature("docstring")  casadi::FunctionInternal::call_reverse(const
58927 std::vector< SX > &arg, const std::vector< SX > &res, const std::vector<
58928 std::vector< SX > > &aseed, std::vector< std::vector< SX > > &asens, bool
58929 always_inline, bool never_inline) const  "
58930 
58931 [INTERNAL]  Reverse mode, virtual functions overloaded in derived classes.
58932 
58933 ";
58934 
58935 %feature("docstring")  casadi::FunctionInternal::slice(const std::string
58936 &name, const std::vector< casadi_int > &order_in, const std::vector<
58937 casadi_int > &order_out, const Dict &opts) const  "
58938 
58939 [INTERNAL]  returns a new function with a selection of inputs/outputs of the
58940 original
58941 
58942 ";
58943 
58944 %feature("docstring")  casadi::FunctionInternal::sx_in(casadi_int ind) const
58945 "
58946 
58947 [INTERNAL]  Get function input(s) and output(s)
58948 
58949 ";
58950 
58951 %feature("docstring")  casadi::FunctionInternal::sx_in() const  "
58952 
58953 [INTERNAL]  Get function input(s) and output(s)
58954 
58955 ";
58956 
58957 %feature("docstring")  casadi::FunctionInternal::which_depends(const
58958 std::string &s_in, const std::vector< std::string > &s_out, casadi_int
58959 order, bool tr=false) const  "
58960 
58961 [INTERNAL]  Which variables enter with some order.
58962 
58963 Parameters:
58964 -----------
58965 
58966 s_in:   Input name
58967 
58968 s_out:   Output name(s)
58969 
58970 order:  Only 1 (linear) and 2 (nonlinear) allowed
58971 
58972 tr:  Flip the relationship. Return which expressions contain the variables
58973 
58974 ";
58975 
58976 %feature("docstring")  casadi::FunctionInternal::eval_mx(const MXVector
58977 &arg, MXVector &res, bool always_inline, bool never_inline) const  "
58978 
58979 [INTERNAL]  Evaluate with symbolic matrices.
58980 
58981 ";
58982 
58983 %feature("docstring")  casadi::FunctionInternal::check_arg(const
58984 std::vector< M > &arg, casadi_int &npar) const  "
58985 
58986 [INTERNAL]  Check if input arguments have correct length and dimensions.
58987 
58988 Raises errors.
58989 
58990 Parameters:
58991 -----------
58992 
58993 npar[in]:  normal usage: 1, disallow pararallel calls: -1
58994 
58995 npar:  max number of horizontal repetitions across all arguments (or -1)
58996 
58997 ";
58998 
58999 %feature("docstring")  casadi::FunctionInternal::codegen_meta(CodeGenerator
59000 &g) const  "
59001 
59002 [INTERNAL]  Generate meta-information allowing a user to evaluate a
59003 generated function.
59004 
59005 ";
59006 
59007 %feature("docstring")  casadi::FunctionInternal::forward(casadi_int nfwd)
59008 const  "
59009 
59010 [INTERNAL]  Return function that calculates forward derivatives
59011 forward(nfwd) returns a cached instance if available, and calls  Function
59012 get_forward(casadi_int nfwd) if no cached version is available.
59013 
59014 ";
59015 
59016 %feature("docstring")  casadi::FunctionInternal::nz_in(const std::vector< DM
59017 > &arg) const  "
59018 
59019 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
59020 
59021 ";
59022 
59023 %feature("docstring")  casadi::FunctionInternal::nz_in(const std::vector<
59024 double > &arg) const  "
59025 
59026 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
59027 
59028 ";
59029 
59030 %feature("docstring")  casadi::FunctionInternal::disp(std::ostream &stream,
59031 bool more) const  "
59032 
59033 [INTERNAL]  Display object.
59034 
59035 ";
59036 
59037 %feature("docstring")  casadi::FunctionInternal::instruction_MX(casadi_int
59038 k) const  "
59039 
59040 [INTERNAL]  get MX expression associated with instruction
59041 
59042 ";
59043 
59044 %feature("docstring")  casadi::FunctionInternal::size_out(casadi_int ind)
59045 const  "
59046 
59047 [INTERNAL]  Input/output dimensions.
59048 
59049 ";
59050 
59051 %feature("docstring")  casadi::Nlpsol::check_inputs(void *mem) const  "
59052 
59053 [INTERNAL]  Check if the inputs correspond to a well-posed problem.
59054 
59055 ";
59056 
59057 %feature("docstring")  casadi::FunctionInternal::dm_in(casadi_int ind) const
59058 "
59059 
59060 [INTERNAL]  Get function input(s) and output(s)
59061 
59062 ";
59063 
59064 %feature("docstring")  casadi::FunctionInternal::dm_in() const  "
59065 
59066 [INTERNAL]  Get function input(s) and output(s)
59067 
59068 ";
59069 
59070 %feature("docstring")  casadi::FunctionInternal::eval_dm(const std::vector<
59071 DM > &arg) const  "
59072 
59073 [INTERNAL]  Evaluate with DM matrices.
59074 
59075 ";
59076 
59077 %feature("docstring")  casadi::FunctionInternal::sp_weight() const  "
59078 
59079 [INTERNAL]  Weighting factor for chosing forward/reverse mode, sparsity
59080 propagation.
59081 
59082 ";
59083 
59084 %feature("docstring")  casadi::FunctionInternal::has_sprev() const  "
59085 
59086 [INTERNAL]  Is the class able to propagate seeds through the algorithm?
59087 
59088 ";
59089 
59090 %feature("docstring")  casadi::FunctionInternal::sz_work(size_t &sz_arg,
59091 size_t &sz_res, size_t &sz_iw, size_t &sz_w) const  "
59092 
59093 [INTERNAL]  Get number of temporary variables needed.
59094 
59095 ";
59096 
59097 %feature("docstring")  casadi::FunctionInternal::sp_reverse(bvec_t **arg,
59098 bvec_t **res, casadi_int *iw, bvec_t *w, void *mem) const  "
59099 
59100 [INTERNAL]  Propagate sparsity backwards.
59101 
59102 ";
59103 
59104 %feature("docstring")  casadi::FunctionInternal::map(casadi_int n, const
59105 std::string &parallelization) const  "
59106 
59107 [INTERNAL]  Generate/retrieve cached serial map.
59108 
59109 ";
59110 
59111 %feature("docstring")  casadi::PluginInterface< Nlpsol  >::plugin_name()
59112 const  "
59113 
59114 [INTERNAL] ";
59115 
59116 %feature("docstring")  casadi::FunctionInternal::index_in(const std::string
59117 &name) const  "
59118 
59119 [INTERNAL]  Get input scheme index by name.
59120 
59121 ";
59122 
59123 %feature("docstring")  casadi::FunctionInternal::call_gen(const MXVector
59124 &arg, MXVector &res, casadi_int npar, bool always_inline, bool never_inline)
59125 const  "
59126 
59127 [INTERNAL]   Call a function, overloaded.
59128 
59129 ";
59130 
59131 %feature("docstring")  casadi::FunctionInternal::call_gen(const std::vector<
59132 MatrixCommon > &arg, std::vector< MatrixCommon > &res, casadi_int npar, bool
59133 always_inline, bool never_inline) const  "
59134 
59135 [INTERNAL]   Call a function, overloaded.
59136 
59137 ";
59138 
59139 %feature("docstring")  casadi::OracleFunction::create_function(const
59140 std::string &fname, const std::vector< std::string > &s_in, const
59141 std::vector< std::string > &s_out, const Function::AuxOut
59142 &aux=Function::AuxOut()) "
59143 
59144 [INTERNAL]  Create an oracle function
59145 
59146 ";
59147 
59148 %feature("docstring")  casadi::FunctionInternal::symbolicAdjSeed(casadi_int
59149 nadj, const std::vector< MatType > &v) const  "
59150 
59151 [INTERNAL]  Symbolic expressions for the adjoint seeds.
59152 
59153 ";
59154 
59155 %feature("docstring")  casadi::FunctionInternal::codegen_body(CodeGenerator
59156 &g) const  "
59157 
59158 [INTERNAL]  Generate code for the function body.
59159 
59160 ";
59161 
59162 %feature("docstring")  casadi::Nlpsol::class_name() const  "
59163 
59164 [INTERNAL]  Get type name.
59165 
59166 ";
59167 
59168 %feature("docstring")  casadi::FunctionInternal::is_diff_in(casadi_int i) "
59169 
59170 [INTERNAL] ";
59171 
59172 %feature("docstring")  casadi::FunctionInternal::setup(void *mem, const
59173 double **arg, double **res, casadi_int *iw, double *w) const  "
59174 
59175 [INTERNAL]  Set the (persistent and temporary) work vectors.
59176 
59177 ";
59178 
59179 %feature("docstring") casadi::Nlpsol::~Nlpsol "
59180 
59181 [INTERNAL]  Destructor.
59182 
59183 ";
59184 
59185 %feature("docstring")  casadi::ProtoFunction::print(const char *fmt,...)
59186 const  "
59187 
59188 [INTERNAL]  C-style formatted printing during evaluation.
59189 
59190 ";
59191 
59192 %feature("docstring")  casadi::FunctionInternal::sparsity_in(casadi_int ind)
59193 const  "
59194 
59195 [INTERNAL]  Input/output sparsity.
59196 
59197 ";
59198 
59199 %feature("docstring")  casadi::FunctionInternal::definition() const  "
59200 
59201 [INTERNAL]  Get function signature: name:(inputs)->(outputs)
59202 
59203 ";
59204 
59205 %feature("docstring")  casadi::ProtoFunction::checkout() const  "
59206 
59207 [INTERNAL]  Checkout a memory object.
59208 
59209 ";
59210 
59211 %feature("docstring")  casadi::Nlpsol::get_stats(void *mem) const  "
59212 
59213 [INTERNAL]  Get all statistics.
59214 
59215 ";
59216 
59217 %feature("docstring")  casadi::OracleFunction::jit_dependencies(const
59218 std::string &fname)  "
59219 
59220 [INTERNAL]  JIT for dependencies.
59221 
59222 ";
59223 
59224 %feature("docstring")  casadi::FunctionInternal::sz_arg() const  "
59225 
59226 [INTERNAL]  Get required length of arg field.
59227 
59228 ";
59229 
59230 %feature("docstring")  casadi::FunctionInternal::index_out(const std::string
59231 &name) const  "
59232 
59233 [INTERNAL]  Get output scheme index by name.
59234 
59235 ";
59236 
59237 %feature("docstring")
59238 casadi::FunctionInternal::print_dimensions(std::ostream &stream) const  "
59239 
59240 [INTERNAL]  Print dimensions of inputs and outputs.
59241 
59242 ";
59243 
59244 %feature("docstring")  casadi::FunctionInternal::get_free() const  "
59245 
59246 [INTERNAL]  Print free variables.
59247 
59248 ";
59249 
59250 %feature("docstring")  casadi::FunctionInternal::alloc_w(size_t sz_w, bool
59251 persistent=false) "
59252 
59253 [INTERNAL]  Ensure required length of w field.
59254 
59255 ";
59256 
59257 %feature("docstring")  casadi::Nlpsol::integer_support() const  "
59258 
59259 [INTERNAL]  Can discrete variables be treated.
59260 
59261 ";
59262 
59263 %feature("docstring")  casadi::FunctionInternal::has_jacobian_sparsity()
59264 const  "
59265 
59266 [INTERNAL]  Get Jacobian sparsity.
59267 
59268 ";
59269 
59270 %feature("docstring")  casadi::FunctionInternal::replace_aseed(const
59271 std::vector< std::vector< M >> &aseed, casadi_int npar) const  "
59272 
59273 [INTERNAL]  Replace 0-by-0 reverse seeds.
59274 
59275 ";
59276 
59277 %feature("docstring")  casadi::FunctionInternal::replace_aseed(const
59278 std::vector< std::vector< M > > &aseed, casadi_int npar) const  "
59279 
59280 [INTERNAL] ";
59281 
59282 %feature("docstring")  casadi::FunctionInternal::has_derivative() const  "
59283 
59284 [INTERNAL]  Can derivatives be calculated in any way?
59285 
59286 ";
59287 
59288 %feature("docstring")  casadi::FunctionInternal::eval_sx(const SXElem **arg,
59289 SXElem **res, casadi_int *iw, SXElem *w, void *mem) const  "
59290 
59291 [INTERNAL]  Evaluate with symbolic scalars.
59292 
59293 ";
59294 
59295 %feature("docstring")  casadi::FunctionInternal::instruction_id(casadi_int
59296 k) const  "
59297 
59298 [INTERNAL]  Get an atomic operation operator index.
59299 
59300 ";
59301 
59302 %feature("docstring")  casadi::FunctionInternal::numel_out(casadi_int ind)
59303 const  "
59304 
59305 [INTERNAL]  Number of input/output elements.
59306 
59307 ";
59308 
59309 %feature("docstring")  casadi::FunctionInternal::numel_out() const  "
59310 
59311 [INTERNAL]  Number of input/output elements.
59312 
59313 ";
59314 
59315 %feature("docstring")
59316 casadi::FunctionInternal::instruction_constant(casadi_int k) const  "
59317 
59318 [INTERNAL]  Get the floating point output argument of an atomic operation.
59319 
59320 ";
59321 
59322 %feature("docstring")  casadi::OracleFunction::generate_dependencies(const
59323 std::string &fname, const Dict &opts) const  "
59324 
59325 [INTERNAL]  Export / Generate C code for the generated functions.
59326 
59327 ";
59328 
59329 %feature("docstring")  casadi::FunctionInternal::size2_in(casadi_int ind)
59330 const  "
59331 
59332 [INTERNAL]  Input/output dimensions.
59333 
59334 ";
59335 
59336 %feature("docstring")  casadi::FunctionInternal::codegen_name(const
59337 CodeGenerator &g, bool ns=true) const  "
59338 
59339 [INTERNAL]  Get name in codegen.
59340 
59341 ";
59342 
59343 %feature("docstring")  casadi::FunctionInternal::sx_out(casadi_int ind)
59344 const  "
59345 
59346 [INTERNAL]  Get function input(s) and output(s)
59347 
59348 ";
59349 
59350 %feature("docstring")  casadi::FunctionInternal::sx_out() const  "
59351 
59352 [INTERNAL]  Get function input(s) and output(s)
59353 
59354 ";
59355 
59356 %feature("docstring")  casadi::FunctionInternal::sz_w() const  "
59357 
59358 [INTERNAL]  Get required length of w field.
59359 
59360 ";
59361 
59362 %feature("docstring")  casadi::Nlpsol::get_name_out(casadi_int i)  "
59363 
59364 [INTERNAL]  Names of function input and outputs.
59365 
59366 ";
59367 
59368 %feature("docstring")  casadi::FunctionInternal::ad_weight() const  "
59369 
59370 [INTERNAL]  Weighting factor for chosing forward/reverse mode.
59371 
59372 ";
59373 
59374 %feature("docstring")  casadi::FunctionInternal::fwd_seed(casadi_int nfwd)
59375 const  "
59376 
59377 [INTERNAL]  Symbolic expressions for the forward seeds.
59378 
59379 ";
59380 
59381 %feature("docstring")  casadi::FunctionInternal::nz_out(const std::vector<
59382 DM > &res) const  "
59383 
59384 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
59385 
59386 ";
59387 
59388 %feature("docstring")  casadi::FunctionInternal::nz_out(const std::vector<
59389 double > &res) const  "
59390 
59391 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
59392 
59393 ";
59394 
59395 %feature("docstring")  casadi::FunctionInternal::getAdaptorSolverName()
59396 const  "
59397 
59398 [INTERNAL]  Obtain solver name from Adaptor.
59399 
59400 ";
59401 
59402 %feature("docstring")  casadi::FunctionInternal::get_partition(casadi_int
59403 iind, casadi_int oind, Sparsity &D1, Sparsity &D2, bool compact, bool
59404 symmetric, bool allow_forward, bool allow_reverse) const  "
59405 
59406 [INTERNAL]  Get the unidirectional or bidirectional partition.
59407 
59408 ";
59409 
59410 %feature("docstring")  casadi::FunctionInternal::generate_lifted(Function
59411 &vdef_fcn, Function &vinit_fcn) const  "
59412 
59413 [INTERNAL]  Extract the functions needed for the Lifted Newton method.
59414 
59415 ";
59416 
59417 %feature("docstring")  casadi::ProtoFunction::construct(const Dict &opts) "
59418 
59419 [INTERNAL]  Construct Prepares the function for evaluation.
59420 
59421 ";
59422 
59423 %feature("docstring")  casadi::FunctionInternal::convert_arg(const
59424 std::vector< M > &arg) const  "
59425 
59426 [INTERNAL]  Convert from/to input/output lists/map.
59427 
59428 ";
59429 
59430 %feature("docstring")  casadi::FunctionInternal::convert_arg(const std::map<
59431 std::string, M > &arg) const  "
59432 
59433 [INTERNAL]  Convert from/to input/output lists/map.
59434 
59435 ";
59436 
59437 %feature("docstring")  casadi::Nlpsol::init(const Dict &opts)  "
59438 
59439 [INTERNAL]  Initialize.
59440 
59441 ";
59442 
59443 %feature("docstring")  casadi::FunctionInternal::size2_out(casadi_int ind)
59444 const  "
59445 
59446 [INTERNAL]  Input/output dimensions.
59447 
59448 ";
59449 
59450 %feature("docstring")  casadi::FunctionInternal::eval_gen(const double
59451 **arg, double **res, casadi_int *iw, double *w, void *mem) const  "
59452 
59453 [INTERNAL]  Evaluate numerically.
59454 
59455 ";
59456 
59457 %feature("docstring")  casadi::FunctionInternal::eval_gen(const SXElem
59458 **arg, SXElem **res, casadi_int *iw, SXElem *w, void *mem) const  "
59459 
59460 [INTERNAL]  Evaluate a function, overloaded.
59461 
59462 ";
59463 
59464 %feature("docstring")  casadi::FunctionInternal::eval_gen(const bvec_t
59465 **arg, bvec_t **res, casadi_int *iw, bvec_t *w, void *mem) const  "
59466 
59467 [INTERNAL]  Evaluate a function, overloaded.
59468 
59469 ";
59470 
59471 %feature("docstring")  casadi::FunctionInternal::incache(const std::string
59472 &fname, Function &f, const std::string &suffix="") const  "
59473 
59474 [INTERNAL]  Get function in cache.
59475 
59476 ";
59477 
59478 %feature("docstring")
59479 casadi::FunctionInternal::codegen_decref(CodeGenerator &g) const  "
59480 
59481 [INTERNAL]  Codegen decref for dependencies.
59482 
59483 ";
59484 
59485 
59486 // File: classcasadi_1_1NonZeros.xml
59487 %feature("docstring") casadi::NonZeros< M, K >::NonZeros(M &mat, const K &k)
59488 "
59489 
59490 Constructor.
59491 
59492 ";
59493 
59494 %feature("docstring") casadi::NonZeros "
59495 
59496 Access to a set of nonzeros.
59497 
59498 NonZeros class for Matrix NonZeros is the return type for operator[] of the
59499 Matrix class, it allows access to the value as well as changing the parent
59500 object Joel Andersson
59501 
59502 C++ includes: nonzeros.hpp ";
59503 
59504 
59505 // File: classcasadi_1_1Norm.xml
59506 
59507 
59508 // File: classcasadi_1_1Norm1.xml
59509 
59510 
59511 // File: classcasadi_1_1Norm2.xml
59512 
59513 
59514 // File: classcasadi_1_1NormF.xml
59515 
59516 
59517 // File: classcasadi_1_1NormInf.xml
59518 
59519 
59520 // File: classcasadi_1_1OmpMap.xml
59521 %feature("docstring")  casadi::FunctionInternal::disp_more(std::ostream
59522 &stream) const  "
59523 
59524 [INTERNAL]  Print more.
59525 
59526 ";
59527 
59528 %feature("docstring")  casadi::FunctionInternal::uses_output() const  "
59529 
59530 [INTERNAL]  Do the derivative functions need nondifferentiated outputs?
59531 
59532 ";
59533 
59534 %feature("docstring")
59535 casadi::FunctionInternal::getJacSparsityGen(casadi_int iind, casadi_int
59536 oind, bool symmetric, casadi_int gr_i=1, casadi_int gr_o=1) const  "
59537 
59538 [INTERNAL]  Get the sparsity pattern, forward mode.
59539 
59540 ";
59541 
59542 %feature("docstring")  casadi::FunctionInternal::sx_in(casadi_int ind) const
59543 "
59544 
59545 [INTERNAL]  Get function input(s) and output(s)
59546 
59547 ";
59548 
59549 %feature("docstring")  casadi::FunctionInternal::sx_in() const  "
59550 
59551 [INTERNAL]  Get function input(s) and output(s)
59552 
59553 ";
59554 
59555 %feature("docstring")  casadi::FunctionInternal::incache(const std::string
59556 &fname, Function &f, const std::string &suffix="") const  "
59557 
59558 [INTERNAL]  Get function in cache.
59559 
59560 ";
59561 
59562 %feature("docstring")  casadi::Map::get_n_out()  "
59563 
59564 [INTERNAL]  Number of function inputs and outputs.
59565 
59566 ";
59567 
59568 %feature("docstring")  casadi::FunctionInternal::jacobian_sparsity() const
59569 "
59570 
59571 [INTERNAL]  Get Jacobian sparsity.
59572 
59573 ";
59574 
59575 %feature("docstring")  casadi::FunctionInternal::index_in(const std::string
59576 &name) const  "
59577 
59578 [INTERNAL]  Get input scheme index by name.
59579 
59580 ";
59581 
59582 %feature("docstring")
59583 casadi::FunctionInternal::getJacSparsityHierarchicalSymm(casadi_int iind,
59584 casadi_int oind) const  "
59585 
59586 [INTERNAL]  A flavor of getJacSparsity that does hierarchical block
59587 structure recognition for symmetric Jacobians
59588 
59589 ";
59590 
59591 %feature("docstring")  casadi::FunctionInternal::replace_fseed(const
59592 std::vector< std::vector< M >> &fseed, casadi_int npar) const  "
59593 
59594 [INTERNAL]  Replace 0-by-0 forward seeds.
59595 
59596 ";
59597 
59598 %feature("docstring")  casadi::FunctionInternal::replace_fseed(const
59599 std::vector< std::vector< M > > &fseed, casadi_int npar) const  "
59600 
59601 [INTERNAL] ";
59602 
59603 %feature("docstring")  casadi::FunctionInternal::sz_work(size_t &sz_arg,
59604 size_t &sz_res, size_t &sz_iw, size_t &sz_w) const  "
59605 
59606 [INTERNAL]  Get number of temporary variables needed.
59607 
59608 ";
59609 
59610 %feature("docstring")  casadi::OmpMap::eval(const double **arg, double
59611 **res, casadi_int *iw, double *w, void *mem) const  "
59612 
59613 [INTERNAL]  Evaluate the function numerically.
59614 
59615 ";
59616 
59617 %feature("docstring")  casadi::FunctionInternal::sp_weight() const  "
59618 
59619 [INTERNAL]  Weighting factor for chosing forward/reverse mode, sparsity
59620 propagation.
59621 
59622 ";
59623 
59624 %feature("docstring")  casadi::FunctionInternal::adjViaJac(casadi_int nadj)
59625 const  "
59626 
59627 [INTERNAL]  Calculate derivatives by multiplying the full Jacobian and
59628 multiplying.
59629 
59630 ";
59631 
59632 %feature("docstring")  casadi::Map::eval_sx(const SXElem **arg, SXElem
59633 **res, casadi_int *iw, SXElem *w, void *mem) const  "
59634 
59635 [INTERNAL]  evaluate symbolically while also propagating directional
59636 derivatives
59637 
59638 ";
59639 
59640 %feature("docstring")  casadi::FunctionInternal::wrap() const  "
59641 
59642 [INTERNAL]  Wrap in an Function instance consisting of only one MX call.
59643 
59644 ";
59645 
59646 %feature("docstring")  casadi::FunctionInternal::fwdViaJac(casadi_int nfwd)
59647 const  "
59648 
59649 [INTERNAL]  Calculate derivatives by multiplying the full Jacobian and
59650 multiplying.
59651 
59652 ";
59653 
59654 %feature("docstring")  casadi::FunctionInternal::size1_out(casadi_int ind)
59655 const  "
59656 
59657 [INTERNAL]  Input/output dimensions.
59658 
59659 ";
59660 
59661 %feature("docstring")  casadi::Map::has_spfwd() const  "
59662 
59663 [INTERNAL]  Is the class able to propagate seeds through the algorithm?
59664 
59665 ";
59666 
59667 %feature("docstring")  casadi::FunctionInternal::getJacSparsity(casadi_int
59668 iind, casadi_int oind, bool symmetric) const  "
59669 
59670 [INTERNAL]  Generate the sparsity of a Jacobian block.
59671 
59672 ";
59673 
59674 %feature("docstring")  casadi::FunctionInternal::eval_dm(const std::vector<
59675 DM > &arg) const  "
59676 
59677 [INTERNAL]  Evaluate with DM matrices.
59678 
59679 ";
59680 
59681 %feature("docstring")  casadi::FunctionInternal::which_depends(const
59682 std::string &s_in, const std::vector< std::string > &s_out, casadi_int
59683 order, bool tr=false) const  "
59684 
59685 [INTERNAL]  Which variables enter with some order.
59686 
59687 Parameters:
59688 -----------
59689 
59690 s_in:   Input name
59691 
59692 s_out:   Output name(s)
59693 
59694 order:  Only 1 (linear) and 2 (nonlinear) allowed
59695 
59696 tr:  Flip the relationship. Return which expressions contain the variables
59697 
59698 ";
59699 
59700 %feature("docstring")  casadi::FunctionInternal::call_forward(const
59701 std::vector< MX > &arg, const std::vector< MX > &res, const std::vector<
59702 std::vector< MX > > &fseed, std::vector< std::vector< MX > > &fsens, bool
59703 always_inline, bool never_inline) const  "
59704 
59705 [INTERNAL]  Forward mode AD, virtual functions overloaded in derived
59706 classes.
59707 
59708 ";
59709 
59710 %feature("docstring")  casadi::FunctionInternal::call_forward(const
59711 std::vector< SX > &arg, const std::vector< SX > &res, const std::vector<
59712 std::vector< SX > > &fseed, std::vector< std::vector< SX > > &fsens, bool
59713 always_inline, bool never_inline) const  "
59714 
59715 [INTERNAL]  Forward mode AD, virtual functions overloaded in derived
59716 classes.
59717 
59718 ";
59719 
59720 %feature("docstring") casadi::OmpMap::OmpMap(const std::string &name, const
59721 Function &f, casadi_int n) "
59722 
59723 [INTERNAL] ";
59724 
59725 %feature("docstring")  casadi::FunctionInternal::alloc_w(size_t sz_w, bool
59726 persistent=false) "
59727 
59728 [INTERNAL]  Ensure required length of w field.
59729 
59730 ";
59731 
59732 %feature("docstring")  casadi::FunctionInternal::matching_res(const
59733 std::vector< M > &arg, casadi_int &npar) const  "
59734 
59735 [INTERNAL]  Check if output arguments that needs to be replaced.
59736 
59737 Raises errors
59738 
59739 Parameters:
59740 -----------
59741 
59742 npar[in]:  normal usage: 1, disallow pararallel calls: -1
59743 
59744 npar:  max number of horizontal repetitions across all arguments (or -1)
59745 
59746 ";
59747 
59748 %feature("docstring")  casadi::FunctionInternal::project_res(const
59749 std::vector< M > &arg, casadi_int npar) const  "
59750 
59751 [INTERNAL]   Project sparsities.
59752 
59753 ";
59754 
59755 %feature("docstring")  casadi::FunctionInternal::generate_options(bool
59756 is_temp=false) const  "
59757 
59758 [INTERNAL]  Reconstruct options dict.
59759 
59760 ";
59761 
59762 %feature("docstring")  casadi::ProtoFunction::init_mem(void *mem) const  "
59763 
59764 [INTERNAL]  Initalize memory block.
59765 
59766 ";
59767 
59768 %feature("docstring")  casadi::FunctionInternal::alloc_arg(size_t sz_arg,
59769 bool persistent=false) "
59770 
59771 [INTERNAL]  Ensure required length of arg field.
59772 
59773 ";
59774 
59775 %feature("docstring") casadi::OmpMap::~OmpMap "
59776 
59777 [INTERNAL]  Destructor.
59778 
59779 ";
59780 
59781 %feature("docstring")  casadi::FunctionInternal::disp(std::ostream &stream,
59782 bool more) const  "
59783 
59784 [INTERNAL]  Display object.
59785 
59786 ";
59787 
59788 %feature("docstring")  casadi::Map::get_function() const  "
59789 
59790 [INTERNAL] ";
59791 
59792 %feature("docstring")  casadi::Map::get_function(const std::string &name)
59793 const  "
59794 
59795 [INTERNAL] ";
59796 
59797 %feature("docstring")  casadi::FunctionInternal::export_code(const
59798 std::string &lang, std::ostream &stream, const Dict &options) const  "
59799 
59800 [INTERNAL]  Export function in a specific language.
59801 
59802 ";
59803 
59804 %feature("docstring")  casadi::FunctionInternal::set_work(void *mem, const
59805 double **&arg, double **&res, casadi_int *&iw, double *&w) const  "
59806 
59807 [INTERNAL]  Set the (persistent) work vectors.
59808 
59809 ";
59810 
59811 %feature("docstring")  casadi::OmpMap::is_a(const std::string &type, bool
59812 recursive) const  "
59813 
59814 [INTERNAL]  Check if the function is of a particular type.
59815 
59816 ";
59817 
59818 %feature("docstring")  casadi::FunctionInternal::has_jac() const  "
59819 
59820 [INTERNAL]  Return Jacobian of all input elements with respect to all output
59821 elements.
59822 
59823 ";
59824 
59825 %feature("docstring")  casadi::FunctionInternal::definition() const  "
59826 
59827 [INTERNAL]  Get function signature: name:(inputs)->(outputs)
59828 
59829 ";
59830 
59831 %feature("docstring")  casadi::Map::codegen_declarations(CodeGenerator &g)
59832 const  "
59833 
59834 [INTERNAL]  Generate code for the declarations of the C function.
59835 
59836 ";
59837 
59838 %feature("docstring")  casadi::FunctionInternal::replace_res(const
59839 std::vector< M > &res, casadi_int npar) const  "
59840 
59841 [INTERNAL]  Replace 0-by-0 outputs.
59842 
59843 ";
59844 
59845 %feature("docstring")  casadi::FunctionInternal::signature(const std::string
59846 &fname) const  "
59847 
59848 [INTERNAL]  Code generate the function.
59849 
59850 ";
59851 
59852 %feature("docstring")  casadi::Map::sp_reverse(bvec_t **arg, bvec_t **res,
59853 casadi_int *iw, bvec_t *w, void *mem) const  "
59854 
59855 [INTERNAL]  Propagate sparsity backwards.
59856 
59857 ";
59858 
59859 %feature("docstring")  casadi::FunctionInternal::replace_arg(const
59860 std::vector< M > &arg, casadi_int npar) const  "
59861 
59862 [INTERNAL]  Replace 0-by-0 inputs.
59863 
59864 ";
59865 
59866 %feature("docstring")  casadi::Map::get_name_in(casadi_int i)  "
59867 
59868 [INTERNAL]  Names of function input and outputs.
59869 
59870 ";
59871 
59872 %feature("docstring")  casadi::FunctionInternal::get_min_in(casadi_int ind)
59873 const  "
59874 
59875 [INTERNAL]  Get smallest input value.
59876 
59877 ";
59878 
59879 %feature("docstring")  casadi::FunctionInternal::jac() const  "
59880 
59881 [INTERNAL]  Return Jacobian of all input elements with respect to all output
59882 elements.
59883 
59884 ";
59885 
59886 %feature("docstring")  casadi::FunctionInternal::alloc(const Function &f,
59887 bool persistent=false) "
59888 
59889 [INTERNAL]  Ensure work vectors long enough to evaluate function.
59890 
59891 ";
59892 
59893 %feature("docstring")  casadi::FunctionInternal::generate_lifted(Function
59894 &vdef_fcn, Function &vinit_fcn) const  "
59895 
59896 [INTERNAL]  Extract the functions needed for the Lifted Newton method.
59897 
59898 ";
59899 
59900 %feature("docstring")  casadi::FunctionInternal::print_options(std::ostream
59901 &stream) const  "
59902 
59903 [INTERNAL]  Print list of options.
59904 
59905 ";
59906 
59907 %feature("docstring")
59908 casadi::FunctionInternal::codegen_decref(CodeGenerator &g) const  "
59909 
59910 [INTERNAL]  Codegen decref for dependencies.
59911 
59912 ";
59913 
59914 %feature("docstring")  casadi::FunctionInternal::numel_in() const  "
59915 
59916 [INTERNAL]  Number of input/output elements.
59917 
59918 ";
59919 
59920 %feature("docstring")  casadi::FunctionInternal::numel_in(casadi_int ind)
59921 const  "
59922 
59923 [INTERNAL]  Number of input/output elements.
59924 
59925 ";
59926 
59927 %feature("docstring")  casadi::FunctionInternal::mapsum_mx(const
59928 std::vector< MX > &arg, const std::string &parallelization) "
59929 
59930 [INTERNAL]  Parallel evaluation.
59931 
59932 ";
59933 
59934 %feature("docstring")  casadi::FunctionInternal::codegen_meta(CodeGenerator
59935 &g) const  "
59936 
59937 [INTERNAL]  Generate meta-information allowing a user to evaluate a
59938 generated function.
59939 
59940 ";
59941 
59942 %feature("docstring")
59943 casadi::FunctionInternal::codegen_sparsities(CodeGenerator &g) const  "
59944 
59945 [INTERNAL]  Codegen sparsities.
59946 
59947 ";
59948 
59949 %feature("docstring")
59950 casadi::FunctionInternal::codegen_incref(CodeGenerator &g) const  "
59951 
59952 [INTERNAL]  Codegen incref for dependencies.
59953 
59954 ";
59955 
59956 %feature("docstring")  casadi::FunctionInternal::sx_out(casadi_int ind)
59957 const  "
59958 
59959 [INTERNAL]  Get function input(s) and output(s)
59960 
59961 ";
59962 
59963 %feature("docstring")  casadi::FunctionInternal::sx_out() const  "
59964 
59965 [INTERNAL]  Get function input(s) and output(s)
59966 
59967 ";
59968 
59969 %feature("docstring")  casadi::FunctionInternal::get_max_in(casadi_int ind)
59970 const  "
59971 
59972 [INTERNAL]  Get largest input value.
59973 
59974 ";
59975 
59976 %feature("docstring")  casadi::Map::serialize_body(SerializingStream &s)
59977 const  "
59978 
59979 [INTERNAL]  Serialize an object without type information.
59980 
59981 ";
59982 
59983 %feature("docstring")  casadi::FunctionInternal::symbolic_output(const
59984 std::vector< MX > &arg) const  "
59985 
59986 [INTERNAL]  Get a vector of symbolic variables corresponding to the outputs.
59987 
59988 ";
59989 
59990 %feature("docstring")  casadi::Map::has_codegen() const  "
59991 
59992 [INTERNAL]  Is codegen supported?
59993 
59994 ";
59995 
59996 %feature("docstring")  casadi::FunctionInternal::get_partition(casadi_int
59997 iind, casadi_int oind, Sparsity &D1, Sparsity &D2, bool compact, bool
59998 symmetric, bool allow_forward, bool allow_reverse) const  "
59999 
60000 [INTERNAL]  Get the unidirectional or bidirectional partition.
60001 
60002 ";
60003 
60004 %feature("docstring")  casadi::Map::has_forward(casadi_int nfwd) const  "
60005 
60006 [INTERNAL]  Generate a function that calculates nfwd forward derivatives.
60007 
60008 ";
60009 
60010 %feature("docstring")  casadi::FunctionInternal::dm_in(casadi_int ind) const
60011 "
60012 
60013 [INTERNAL]  Get function input(s) and output(s)
60014 
60015 ";
60016 
60017 %feature("docstring")  casadi::FunctionInternal::dm_in() const  "
60018 
60019 [INTERNAL]  Get function input(s) and output(s)
60020 
60021 ";
60022 
60023 %feature("docstring")  casadi::ProtoFunction::construct(const Dict &opts) "
60024 
60025 [INTERNAL]  Construct Prepares the function for evaluation.
60026 
60027 ";
60028 
60029 %feature("docstring")  casadi::FunctionInternal::has_derivative() const  "
60030 
60031 [INTERNAL]  Can derivatives be calculated in any way?
60032 
60033 ";
60034 
60035 %feature("docstring")  casadi::FunctionInternal::get_jacobian(const
60036 std::string &name, const std::vector< std::string > &inames, const
60037 std::vector< std::string > &onames, const Dict &opts) const  "
60038 
60039 [INTERNAL]  Return Jacobian of all input elements with respect to all output
60040 elements.
60041 
60042 ";
60043 
60044 %feature("docstring")
60045 casadi::FunctionInternal::instruction_input(casadi_int k) const  "
60046 
60047 [INTERNAL]  Get the (integer) input arguments of an atomic operation.
60048 
60049 ";
60050 
60051 %feature("docstring")  casadi::ProtoFunction::print_time(const std::map<
60052 std::string, FStats > &fstats) const  "
60053 
60054 [INTERNAL]  Print timing statistics.
60055 
60056 ";
60057 
60058 %feature("docstring")  casadi::Map::get_reverse(casadi_int nadj, const
60059 std::string &name, const std::vector< std::string > &inames, const
60060 std::vector< std::string > &onames, const Dict &opts) const  "
60061 
60062 [INTERNAL]  Generate a function that calculates nadj adjoint derivatives.
60063 
60064 ";
60065 
60066 %feature("docstring")  casadi::ProtoFunction::print(const char *fmt,...)
60067 const  "
60068 
60069 [INTERNAL]  C-style formatted printing during evaluation.
60070 
60071 ";
60072 
60073 %feature("docstring")  casadi::FunctionInternal::symbolicAdjSeed(casadi_int
60074 nadj, const std::vector< MatType > &v) const  "
60075 
60076 [INTERNAL]  Symbolic expressions for the adjoint seeds.
60077 
60078 ";
60079 
60080 %feature("docstring")  casadi::FunctionInternal::has_jacobian_sparsity()
60081 const  "
60082 
60083 [INTERNAL]  Get Jacobian sparsity.
60084 
60085 ";
60086 
60087 %feature("docstring")  casadi::FunctionInternal::factory(const std::string
60088 &name, const std::vector< std::string > &s_in, const std::vector<
60089 std::string > &s_out, const Function::AuxOut &aux, const Dict &opts) const
60090 "
60091 
60092 [INTERNAL] ";
60093 
60094 %feature("docstring")  casadi::FunctionInternal::alloc_iw(size_t sz_iw, bool
60095 persistent=false) "
60096 
60097 [INTERNAL]  Ensure required length of iw field.
60098 
60099 ";
60100 
60101 %feature("docstring")  casadi::FunctionInternal::self() const  "
60102 
60103 [INTERNAL]  Get a public class instance.
60104 
60105 ";
60106 
60107 %feature("docstring")  casadi::FunctionInternal::nz_in(const std::vector< DM
60108 > &arg) const  "
60109 
60110 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
60111 
60112 ";
60113 
60114 %feature("docstring")  casadi::FunctionInternal::nz_in(const std::vector<
60115 double > &arg) const  "
60116 
60117 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
60118 
60119 ";
60120 
60121 %feature("docstring")  casadi::FunctionInternal::size_out(casadi_int ind)
60122 const  "
60123 
60124 [INTERNAL]  Input/output dimensions.
60125 
60126 ";
60127 
60128 %feature("docstring")  casadi::Map::get_name_out(casadi_int i)  "
60129 
60130 [INTERNAL]  Names of function input and outputs.
60131 
60132 ";
60133 
60134 %feature("docstring")  casadi::FunctionInternal::call(const std::vector< M >
60135 &arg, std::vector< M > &res, bool always_inline, bool never_inline) const  "
60136 
60137 [INTERNAL]   Call a function, templated.
60138 
60139 ";
60140 
60141 %feature("docstring")  casadi::FunctionInternal::project_arg(const
60142 std::vector< M > &arg, casadi_int npar) const  "
60143 
60144 [INTERNAL]   Project sparsities.
60145 
60146 ";
60147 
60148 %feature("docstring")  casadi::FunctionInternal::get_options() const  "
60149 
60150 [INTERNAL]  Options.
60151 
60152 ";
60153 
60154 %feature("docstring")  casadi::FunctionInternal::map(casadi_int n, const
60155 std::string &parallelization) const  "
60156 
60157 [INTERNAL]  Generate/retrieve cached serial map.
60158 
60159 ";
60160 
60161 %feature("docstring")  casadi::FunctionInternal::sparsity_jac(casadi_int
60162 iind, casadi_int oind, bool compact, bool symmetric) const  "
60163 
60164 [INTERNAL]  Get, if necessary generate, the sparsity of a Jacobian block.
60165 
60166 ";
60167 
60168 %feature("docstring")  casadi::FunctionInternal::sz_arg() const  "
60169 
60170 [INTERNAL]  Get required length of arg field.
60171 
60172 ";
60173 
60174 %feature("docstring")  casadi::FunctionInternal::instruction_id(casadi_int
60175 k) const  "
60176 
60177 [INTERNAL]  Get an atomic operation operator index.
60178 
60179 ";
60180 
60181 %feature("docstring")  casadi::FunctionInternal::get_jacobian_sparsity()
60182 const  "
60183 
60184 [INTERNAL]  Get Jacobian sparsity.
60185 
60186 ";
60187 
60188 %feature("docstring")  casadi::FunctionInternal::forward(casadi_int nfwd)
60189 const  "
60190 
60191 [INTERNAL]  Return function that calculates forward derivatives
60192 forward(nfwd) returns a cached instance if available, and calls  Function
60193 get_forward(casadi_int nfwd) if no cached version is available.
60194 
60195 ";
60196 
60197 %feature("docstring")  casadi::FunctionInternal::size1_in(casadi_int ind)
60198 const  "
60199 
60200 [INTERNAL]  Input/output dimensions.
60201 
60202 ";
60203 
60204 %feature("docstring")  casadi::Map::get_sparsity_out(casadi_int i)  "
60205 
60206 [INTERNAL]  Sparsities of function inputs and outputs.
60207 
60208 ";
60209 
60210 %feature("docstring") casadi::OmpMap "
60211 
60212 [INTERNAL]  A map Evaluate in parallel using OpenMP Note: Do not use this
60213 class with much more than the intended number of threads for the parallel
60214 evaluation as it will cause excessive memory use.
60215 
60216 Joel Andersson
60217 
60218 C++ includes: map.hpp ";
60219 
60220 %feature("docstring")  casadi::Map::sp_forward(const bvec_t **arg, bvec_t
60221 **res, casadi_int *iw, bvec_t *w, void *mem) const  "
60222 
60223 [INTERNAL]  Propagate sparsity forward.
60224 
60225 ";
60226 
60227 %feature("docstring")  casadi::FunctionInternal::alloc_res(size_t sz_res,
60228 bool persistent=false) "
60229 
60230 [INTERNAL]  Ensure required length of res field.
60231 
60232 ";
60233 
60234 %feature("docstring")  casadi::Map::get_n_in()  "
60235 
60236 [INTERNAL]  Number of function inputs and outputs.
60237 
60238 ";
60239 
60240 %feature("docstring")  casadi::FunctionInternal::tocache(const Function &f,
60241 const std::string &suffix="") const  "
60242 
60243 [INTERNAL]  Save function to cache.
60244 
60245 ";
60246 
60247 %feature("docstring")  casadi::FunctionInternal::sz_iw() const  "
60248 
60249 [INTERNAL]  Get required length of iw field.
60250 
60251 ";
60252 
60253 %feature("docstring")  casadi::FunctionInternal::generate_in(const
60254 std::string &fname, const double **arg) const  "
60255 
60256 [INTERNAL]  Export an input file that can be passed to generate C code with
60257 a main.
60258 
60259 ";
60260 
60261 %feature("docstring")  casadi::ProtoFunction::format_time(char *buffer,
60262 double time) const  "
60263 
60264 [INTERNAL]  Format time in a fixed width 8 format.
60265 
60266 ";
60267 
60268 %feature("docstring")  casadi::FunctionInternal::size_in(casadi_int ind)
60269 const  "
60270 
60271 [INTERNAL]  Input/output dimensions.
60272 
60273 ";
60274 
60275 %feature("docstring")  casadi::OmpMap::codegen_body(CodeGenerator &g) const
60276 "
60277 
60278 [INTERNAL]  Generate code for the body of the C function.
60279 
60280 ";
60281 
60282 %feature("docstring")  casadi::FunctionInternal::convert_arg(const
60283 std::vector< M > &arg) const  "
60284 
60285 [INTERNAL]  Convert from/to input/output lists/map.
60286 
60287 ";
60288 
60289 %feature("docstring")  casadi::FunctionInternal::convert_arg(const std::map<
60290 std::string, M > &arg) const  "
60291 
60292 [INTERNAL]  Convert from/to input/output lists/map.
60293 
60294 ";
60295 
60296 %feature("docstring")
60297 casadi::FunctionInternal::jacobian_sparsity_filter(const Sparsity &sp) const
60298 "
60299 
60300 [INTERNAL]  Filter out nonzeros in the full sparsity jacobian according to
60301 is_diff_in/out.
60302 
60303 ";
60304 
60305 %feature("docstring")  casadi::Map::has_sprev() const  "
60306 
60307 [INTERNAL]  Is the class able to propagate seeds through the algorithm?
60308 
60309 ";
60310 
60311 %feature("docstring")  casadi::FunctionInternal::generate_dependencies(const
60312 std::string &fname, const Dict &opts) const  "
60313 
60314 [INTERNAL]  Export / Generate C code for the dependency function.
60315 
60316 ";
60317 
60318 %feature("docstring")  casadi::FunctionInternal::get_reltol() const  "
60319 
60320 [INTERNAL]  Get relative tolerance.
60321 
60322 ";
60323 
60324 %feature("docstring")  casadi::OmpMap::init(const Dict &opts)  "
60325 
60326 [INTERNAL]  Initialize.
60327 
60328 ";
60329 
60330 %feature("docstring")  casadi::FunctionInternal::jacobian() const  "
60331 
60332 [INTERNAL]  Return Jacobian of all input elements with respect to all output
60333 elements.
60334 
60335 ";
60336 
60337 %feature("docstring")  casadi::FunctionInternal::matching_arg(const
60338 std::vector< M > &arg, casadi_int &npar) const  "
60339 
60340 [INTERNAL]  Check if input arguments that needs to be replaced.
60341 
60342 Raises errors
60343 
60344 Parameters:
60345 -----------
60346 
60347 npar[in]:  normal usage: 1, disallow pararallel calls: -1
60348 
60349 npar:  max number of horizontal repetitions across all arguments (or -1)
60350 
60351 ";
60352 
60353 %feature("docstring")  casadi::FunctionInternal::convert_res(const
60354 std::vector< M > &res) const  "
60355 
60356 [INTERNAL]  Convert from/to input/output lists/map.
60357 
60358 ";
60359 
60360 %feature("docstring")  casadi::FunctionInternal::convert_res(const std::map<
60361 std::string, M > &res) const  "
60362 
60363 [INTERNAL]  Convert from/to input/output lists/map.
60364 
60365 ";
60366 
60367 %feature("docstring")  casadi::SharedObjectInternal::getCount() const  "
60368 
60369 [INTERNAL]  Get the reference count.
60370 
60371 ";
60372 
60373 %feature("docstring")  casadi::Map::get_default_in(casadi_int ind) const  "
60374 
60375 [INTERNAL]  Get default input value.
60376 
60377 ";
60378 
60379 %feature("docstring")  casadi::ProtoFunction::free_mem(void *mem) const  "
60380 
60381 [INTERNAL]  Free memory block.
60382 
60383 ";
60384 
60385 %feature("docstring")  casadi::ProtoFunction::serialize(SerializingStream
60386 &s) const  "
60387 
60388 [INTERNAL]  Serialize an object.
60389 
60390 ";
60391 
60392 %feature("docstring")  casadi::FunctionInternal::codegen(CodeGenerator &g,
60393 const std::string &fname) const  "
60394 
60395 [INTERNAL]  Generate code the function.
60396 
60397 ";
60398 
60399 %feature("docstring")  casadi::FunctionInternal::wrap_as_needed(const Dict
60400 &opts) const  "
60401 
60402 [INTERNAL]  Wrap in an Function instance consisting of only one MX call.
60403 
60404 ";
60405 
60406 %feature("docstring")  casadi::FunctionInternal::is_diff_out(casadi_int i) "
60407 
60408 [INTERNAL] ";
60409 
60410 %feature("docstring")  casadi::FunctionInternal::is_diff_in(casadi_int i) "
60411 
60412 [INTERNAL] ";
60413 
60414 %feature("docstring")  casadi::FunctionInternal::mx_out(casadi_int ind)
60415 const  "
60416 
60417 [INTERNAL]  Get function input(s) and output(s)
60418 
60419 ";
60420 
60421 %feature("docstring")  casadi::FunctionInternal::mx_out() const  "
60422 
60423 [INTERNAL]  Get function input(s) and output(s)
60424 
60425 ";
60426 
60427 %feature("docstring")  casadi::Map::has_reverse(casadi_int nadj) const  "
60428 
60429 [INTERNAL]  Generate a function that calculates nadj adjoint derivatives.
60430 
60431 ";
60432 
60433 %feature("docstring")  casadi::FunctionInternal::eval_gen(const double
60434 **arg, double **res, casadi_int *iw, double *w, void *mem) const  "
60435 
60436 [INTERNAL]  Evaluate numerically.
60437 
60438 ";
60439 
60440 %feature("docstring")  casadi::FunctionInternal::eval_gen(const SXElem
60441 **arg, SXElem **res, casadi_int *iw, SXElem *w, void *mem) const  "
60442 
60443 [INTERNAL]  Evaluate a function, overloaded.
60444 
60445 ";
60446 
60447 %feature("docstring")  casadi::FunctionInternal::eval_gen(const bvec_t
60448 **arg, bvec_t **res, casadi_int *iw, bvec_t *w, void *mem) const  "
60449 
60450 [INTERNAL]  Evaluate a function, overloaded.
60451 
60452 ";
60453 
60454 %feature("docstring")  casadi::Map::eval_gen(const T **arg, T **res,
60455 casadi_int *iw, T *w, int mem=0) const  "
60456 
60457 [INTERNAL]  Evaluate or propagate sparsities.
60458 
60459 ";
60460 
60461 %feature("docstring")  casadi::FunctionInternal::jit_dependencies(const
60462 std::string &fname) "
60463 
60464 [INTERNAL]  Jit dependencies.
60465 
60466 ";
60467 
60468 %feature("docstring")  casadi::ProtoFunction::release(int mem) const  "
60469 
60470 [INTERNAL]  Release a memory object.
60471 
60472 ";
60473 
60474 %feature("docstring")  casadi::FunctionInternal::nnz_in() const  "
60475 
60476 [INTERNAL]  Number of input/output nonzeros.
60477 
60478 ";
60479 
60480 %feature("docstring")  casadi::FunctionInternal::nnz_in(casadi_int ind)
60481 const  "
60482 
60483 [INTERNAL]  Number of input/output nonzeros.
60484 
60485 ";
60486 
60487 %feature("docstring")  casadi::ProtoFunction::get_stats(void *mem) const  "
60488 
60489 [INTERNAL]  Get all statistics.
60490 
60491 ";
60492 
60493 %feature("docstring")  casadi::FunctionInternal::check_res(const
60494 std::vector< M > &res, casadi_int &npar) const  "
60495 
60496 [INTERNAL]  Check if output arguments have correct length and dimensions.
60497 
60498 Raises errors.
60499 
60500 Parameters:
60501 -----------
60502 
60503 npar[in]:  normal usage: 1, disallow pararallel calls: -1
60504 
60505 npar:  max number of horizontal repetitions across all arguments (or -1)
60506 
60507 ";
60508 
60509 %feature("docstring")  casadi::FunctionInternal::get_jac(const std::string
60510 &name, const std::vector< std::string > &inames, const std::vector<
60511 std::string > &onames, const Dict &opts) const  "
60512 
60513 [INTERNAL]  Return Jacobian of all input elements with respect to all output
60514 elements.
60515 
60516 ";
60517 
60518 %feature("docstring")  casadi::FunctionInternal::finalize()  "
60519 
60520 [INTERNAL]  Finalize the object creation.
60521 
60522 ";
60523 
60524 %feature("docstring")  casadi::FunctionInternal::fwd_seed(casadi_int nfwd)
60525 const  "
60526 
60527 [INTERNAL]  Symbolic expressions for the forward seeds.
60528 
60529 ";
60530 
60531 %feature("docstring")  casadi::Map::serialize_type(SerializingStream &s)
60532 const  "
60533 
60534 [INTERNAL]  Serialize type information.
60535 
60536 ";
60537 
60538 %feature("docstring")  casadi::ProtoFunction::checkout() const  "
60539 
60540 [INTERNAL]  Checkout a memory object.
60541 
60542 ";
60543 
60544 %feature("docstring")  casadi::FunctionInternal::has_eval_dm() const  "
60545 
60546 [INTERNAL]  Evaluate with DM matrices.
60547 
60548 ";
60549 
60550 %feature("docstring")
60551 casadi::FunctionInternal::instruction_constant(casadi_int k) const  "
60552 
60553 [INTERNAL]  Get the floating point output argument of an atomic operation.
60554 
60555 ";
60556 
60557 %feature("docstring")  casadi::FunctionInternal::replace_aseed(const
60558 std::vector< std::vector< M >> &aseed, casadi_int npar) const  "
60559 
60560 [INTERNAL]  Replace 0-by-0 reverse seeds.
60561 
60562 ";
60563 
60564 %feature("docstring")  casadi::FunctionInternal::replace_aseed(const
60565 std::vector< std::vector< M > > &aseed, casadi_int npar) const  "
60566 
60567 [INTERNAL] ";
60568 
60569 %feature("docstring")  casadi::FunctionInternal::print_option(const
60570 std::string &name, std::ostream &stream) const  "
60571 
60572 [INTERNAL]  Print all information there is to know about a certain option.
60573 
60574 ";
60575 
60576 %feature("docstring")  casadi::FunctionInternal::has_free() const  "
60577 
60578 [INTERNAL]  Does the function have free variables.
60579 
60580 ";
60581 
60582 %feature("docstring")
60583 casadi::FunctionInternal::print_dimensions(std::ostream &stream) const  "
60584 
60585 [INTERNAL]  Print dimensions of inputs and outputs.
60586 
60587 ";
60588 
60589 %feature("docstring")  casadi::OmpMap::parallelization() const  "
60590 
60591 [INTERNAL]  Type of parallellization.
60592 
60593 ";
60594 
60595 %feature("docstring")  casadi::FunctionInternal::codegen_mem_type() const  "
60596 
60597 [INTERNAL]  Thread-local memory object type.
60598 
60599 ";
60600 
60601 %feature("docstring")  casadi::FunctionInternal::sparsity_in(casadi_int ind)
60602 const  "
60603 
60604 [INTERNAL]  Input/output sparsity.
60605 
60606 ";
60607 
60608 %feature("docstring")  casadi::FunctionInternal::getAdaptorSolverName()
60609 const  "
60610 
60611 [INTERNAL]  Obtain solver name from Adaptor.
60612 
60613 ";
60614 
60615 %feature("docstring")  casadi::FunctionInternal::codegen_mem(CodeGenerator
60616 &g, const std::string &index="mem") const  "
60617 
60618 [INTERNAL]  Get thread-local memory object.
60619 
60620 ";
60621 
60622 %feature("docstring")
60623 casadi::FunctionInternal::codegen_init_mem(CodeGenerator &g) const  "
60624 
60625 [INTERNAL]  Codegen decref for init_mem.
60626 
60627 ";
60628 
60629 %feature("docstring")  casadi::ProtoFunction::memory(int ind) const  "
60630 
60631 [INTERNAL]  Memory objects.
60632 
60633 ";
60634 
60635 %feature("docstring")  casadi::Map::get_sparsity_in(casadi_int i)  "
60636 
60637 [INTERNAL]  Sparsities of function inputs and outputs.
60638 
60639 ";
60640 
60641 %feature("docstring")  casadi::FunctionInternal::size2_out(casadi_int ind)
60642 const  "
60643 
60644 [INTERNAL]  Input/output dimensions.
60645 
60646 ";
60647 
60648 %feature("docstring")
60649 casadi::FunctionInternal::getJacSparsityHierarchical(casadi_int iind,
60650 casadi_int oind) const  "
60651 
60652 [INTERNAL]  A flavor of getJacSparsity that does hierarchical block
60653 structure recognition.
60654 
60655 ";
60656 
60657 %feature("docstring")  casadi::FunctionInternal::sz_w() const  "
60658 
60659 [INTERNAL]  Get required length of w field.
60660 
60661 ";
60662 
60663 %feature("docstring")  casadi::FunctionInternal::reverse(casadi_int nadj)
60664 const  "
60665 
60666 [INTERNAL]  Return function that calculates adjoint derivatives
60667 reverse(nadj) returns a cached instance if available, and calls  Function
60668 get_reverse(casadi_int nadj) if no cached version is available.
60669 
60670 ";
60671 
60672 %feature("docstring")  casadi::FunctionInternal::get_free() const  "
60673 
60674 [INTERNAL]  Print free variables.
60675 
60676 ";
60677 
60678 %feature("docstring")  casadi::FunctionInternal::has_jacobian() const  "
60679 
60680 [INTERNAL]  Return Jacobian of all input elements with respect to all output
60681 elements.
60682 
60683 ";
60684 
60685 %feature("docstring")  casadi::FunctionInternal::index_out(const std::string
60686 &name) const  "
60687 
60688 [INTERNAL]  Get output scheme index by name.
60689 
60690 ";
60691 
60692 %feature("docstring")  casadi::FunctionInternal::codegen_name(const
60693 CodeGenerator &g, bool ns=true) const  "
60694 
60695 [INTERNAL]  Get name in codegen.
60696 
60697 ";
60698 
60699 %feature("docstring")  casadi::FunctionInternal::sparsity_out(casadi_int
60700 ind) const  "
60701 
60702 [INTERNAL]  Input/output sparsity.
60703 
60704 ";
60705 
60706 %feature("docstring")
60707 casadi::FunctionInternal::codegen_free_mem(CodeGenerator &g) const  "
60708 
60709 [INTERNAL]  Codegen for free_mem.
60710 
60711 ";
60712 
60713 %feature("docstring")  casadi::Map::has_function(const std::string &fname)
60714 const  "
60715 
60716 [INTERNAL] ";
60717 
60718 %feature("docstring")  casadi::FunctionInternal::slice(const std::string
60719 &name, const std::vector< casadi_int > &order_in, const std::vector<
60720 casadi_int > &order_out, const Dict &opts) const  "
60721 
60722 [INTERNAL]  returns a new function with a selection of inputs/outputs of the
60723 original
60724 
60725 ";
60726 
60727 %feature("docstring")  casadi::FunctionInternal::check_mat(const Sparsity
60728 &arg, const Sparsity &inp, casadi_int &npar) "
60729 
60730 [INTERNAL]  Helper function
60731 
60732 Parameters:
60733 -----------
60734 
60735 npar[in]:  normal usage: 1, disallow pararallel calls: -1
60736 
60737 npar[out]:  required number of parallel calls (or -1)
60738 
60739 ";
60740 
60741 %feature("docstring")  casadi::FunctionInternal::ad_weight() const  "
60742 
60743 [INTERNAL]  Weighting factor for chosing forward/reverse mode.
60744 
60745 ";
60746 
60747 %feature("docstring")  casadi::FunctionInternal::instruction_MX(casadi_int
60748 k) const  "
60749 
60750 [INTERNAL]  get MX expression associated with instruction
60751 
60752 ";
60753 
60754 %feature("docstring")  casadi::FunctionInternal::oracle() const  "
60755 
60756 [INTERNAL]  Get oracle.
60757 
60758 ";
60759 
60760 %feature("docstring")  casadi::FunctionInternal::mx_in(casadi_int ind) const
60761 "
60762 
60763 [INTERNAL]  Get function input(s) and output(s)
60764 
60765 ";
60766 
60767 %feature("docstring")  casadi::FunctionInternal::mx_in() const  "
60768 
60769 [INTERNAL]  Get function input(s) and output(s)
60770 
60771 ";
60772 
60773 %feature("docstring")  casadi::FunctionInternal::n_instructions() const  "
60774 
60775 [INTERNAL]  Get the number of atomic operations.
60776 
60777 ";
60778 
60779 %feature("docstring")  casadi::FunctionInternal::eval_mx(const MXVector
60780 &arg, MXVector &res, bool always_inline, bool never_inline) const  "
60781 
60782 [INTERNAL]  Evaluate with symbolic matrices.
60783 
60784 ";
60785 
60786 %feature("docstring")  casadi::Map::serialize_base_function() const  "
60787 
60788 [INTERNAL]  String used to identify the immediate FunctionInternal subclass.
60789 
60790 ";
60791 
60792 %feature("docstring")  casadi::FunctionInternal::size2_in(casadi_int ind)
60793 const  "
60794 
60795 [INTERNAL]  Input/output dimensions.
60796 
60797 ";
60798 
60799 %feature("docstring")
60800 casadi::FunctionInternal::instruction_output(casadi_int k) const  "
60801 
60802 [INTERNAL]  Get the (integer) output argument of an atomic operation.
60803 
60804 ";
60805 
60806 %feature("docstring")  casadi::FunctionInternal::get_abstol() const  "
60807 
60808 [INTERNAL]  Get absolute tolerance.
60809 
60810 ";
60811 
60812 %feature("docstring")  casadi::FunctionInternal::call_gen(const MXVector
60813 &arg, MXVector &res, casadi_int npar, bool always_inline, bool never_inline)
60814 const  "
60815 
60816 [INTERNAL]   Call a function, overloaded.
60817 
60818 ";
60819 
60820 %feature("docstring")  casadi::FunctionInternal::call_gen(const std::vector<
60821 MatrixCommon > &arg, std::vector< MatrixCommon > &res, casadi_int npar, bool
60822 always_inline, bool never_inline) const  "
60823 
60824 [INTERNAL]   Call a function, overloaded.
60825 
60826 ";
60827 
60828 %feature("docstring")  casadi::FunctionInternal::set_temp(void *mem, const
60829 double **arg, double **res, casadi_int *iw, double *w) const  "
60830 
60831 [INTERNAL]  Set the (temporary) work vectors.
60832 
60833 ";
60834 
60835 %feature("docstring")  casadi::FunctionInternal::nz_out(const std::vector<
60836 DM > &res) const  "
60837 
60838 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
60839 
60840 ";
60841 
60842 %feature("docstring")  casadi::FunctionInternal::nz_out(const std::vector<
60843 double > &res) const  "
60844 
60845 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
60846 
60847 ";
60848 
60849 %feature("docstring")  casadi::FunctionInternal::free_mx() const  "
60850 
60851 [INTERNAL]  Get free variables ( MX)
60852 
60853 ";
60854 
60855 %feature("docstring")  casadi::FunctionInternal::all_scalar() const  "
60856 
60857 [INTERNAL]  Are all inputs and outputs scalar.
60858 
60859 ";
60860 
60861 %feature("docstring")  casadi::FunctionInternal::n_nodes() const  "
60862 
60863 [INTERNAL]  Number of nodes in the algorithm.
60864 
60865 ";
60866 
60867 %feature("docstring")  casadi::FunctionInternal::dm_out(casadi_int ind)
60868 const  "
60869 
60870 [INTERNAL]  Get function input(s) and output(s)
60871 
60872 ";
60873 
60874 %feature("docstring")  casadi::FunctionInternal::dm_out() const  "
60875 
60876 [INTERNAL]  Get function input(s) and output(s)
60877 
60878 ";
60879 
60880 %feature("docstring")  casadi::FunctionInternal::call_reverse(const
60881 std::vector< MX > &arg, const std::vector< MX > &res, const std::vector<
60882 std::vector< MX > > &aseed, std::vector< std::vector< MX > > &asens, bool
60883 always_inline, bool never_inline) const  "
60884 
60885 [INTERNAL]  Reverse mode, virtual functions overloaded in derived classes.
60886 
60887 ";
60888 
60889 %feature("docstring")  casadi::FunctionInternal::call_reverse(const
60890 std::vector< SX > &arg, const std::vector< SX > &res, const std::vector<
60891 std::vector< SX > > &aseed, std::vector< std::vector< SX > > &asens, bool
60892 always_inline, bool never_inline) const  "
60893 
60894 [INTERNAL]  Reverse mode, virtual functions overloaded in derived classes.
60895 
60896 ";
60897 
60898 %feature("docstring")  casadi::FunctionInternal::instructions_sx() const  "
60899 
60900 [INTERNAL]  get SX expression associated with instructions
60901 
60902 ";
60903 
60904 %feature("docstring")  casadi::ProtoFunction::clear_mem() "
60905 
60906 [INTERNAL]  Clear all memory (called from destructor)
60907 
60908 ";
60909 
60910 %feature("docstring")  casadi::FunctionInternal::setup(void *mem, const
60911 double **arg, double **res, casadi_int *iw, double *w) const  "
60912 
60913 [INTERNAL]  Set the (persistent and temporary) work vectors.
60914 
60915 ";
60916 
60917 %feature("docstring")  casadi::FunctionInternal::free_sx() const  "
60918 
60919 [INTERNAL]  Get free variables (SX)
60920 
60921 ";
60922 
60923 %feature("docstring")  casadi::FunctionInternal::numel_out(casadi_int ind)
60924 const  "
60925 
60926 [INTERNAL]  Number of input/output elements.
60927 
60928 ";
60929 
60930 %feature("docstring")  casadi::FunctionInternal::numel_out() const  "
60931 
60932 [INTERNAL]  Number of input/output elements.
60933 
60934 ";
60935 
60936 %feature("docstring")  casadi::Map::info() const  "
60937 
60938 [INTERNAL]  Obtain information about node
60939 
60940 ";
60941 
60942 %feature("docstring")
60943 casadi::FunctionInternal::codegen_alloc_mem(CodeGenerator &g) const  "
60944 
60945 [INTERNAL]  Codegen decref for alloc_mem.
60946 
60947 ";
60948 
60949 %feature("docstring")  casadi::FunctionInternal::check_arg(const
60950 std::vector< M > &arg, casadi_int &npar) const  "
60951 
60952 [INTERNAL]  Check if input arguments have correct length and dimensions.
60953 
60954 Raises errors.
60955 
60956 Parameters:
60957 -----------
60958 
60959 npar[in]:  normal usage: 1, disallow pararallel calls: -1
60960 
60961 npar:  max number of horizontal repetitions across all arguments (or -1)
60962 
60963 ";
60964 
60965 %feature("docstring")  casadi::FunctionInternal::sz_res() const  "
60966 
60967 [INTERNAL]  Get required length of res field.
60968 
60969 ";
60970 
60971 %feature("docstring")  casadi::ProtoFunction::sprint(char *buf, size_t
60972 buf_sz, const char *fmt,...) const  "
60973 
60974 [INTERNAL]  C-style formatted printing to string.
60975 
60976 ";
60977 
60978 %feature("docstring")  casadi::FunctionInternal::generate_out(const
60979 std::string &fname, double **res) const  "
60980 
60981 [INTERNAL] ";
60982 
60983 %feature("docstring")  casadi::SharedObjectInternal::weak() "
60984 
60985 [INTERNAL]  Get a weak reference to the object.
60986 
60987 ";
60988 
60989 %feature("docstring")  casadi::FunctionInternal::nnz_out() const  "
60990 
60991 [INTERNAL]  Number of input/output nonzeros.
60992 
60993 ";
60994 
60995 %feature("docstring")  casadi::FunctionInternal::nnz_out(casadi_int ind)
60996 const  "
60997 
60998 [INTERNAL]  Number of input/output nonzeros.
60999 
61000 ";
61001 
61002 %feature("docstring")  casadi::OmpMap::class_name() const  "
61003 
61004 [INTERNAL]  Get type name.
61005 
61006 ";
61007 
61008 %feature("docstring")  casadi::Map::get_forward(casadi_int nfwd, const
61009 std::string &name, const std::vector< std::string > &inames, const
61010 std::vector< std::string > &onames, const Dict &opts) const  "
61011 
61012 [INTERNAL]  Generate a function that calculates nfwd forward derivatives.
61013 
61014 ";
61015 
61016 %feature("docstring")  casadi::ProtoFunction::alloc_mem() const  "
61017 
61018 [INTERNAL]  Create memory block.
61019 
61020 ";
61021 
61022 
61023 // File: classcasadi_1_1OneSX.xml
61024 
61025 
61026 // File: classcasadi_1_1Opti.xml
61027 %feature("docstring")  casadi::Opti::stats() const  "
61028 
61029 Get statistics.
61030 
61031 nlpsol stats are passed as-is. No stability can be guaranteed about this
61032 part of the API
61033 
61034 ";
61035 
61036 %feature("docstring")  casadi::Opti::f() const  "
61037 
61038 Get objective expression.
61039 
61040 ";
61041 
61042 %feature("docstring")  casadi::Opti::g() const  "
61043 
61044 Get all (scalarised) constraint expressions as a column vector.
61045 
61046 ";
61047 
61048 %feature("docstring")  casadi::Opti::debug() const  "
61049 
61050 Get a copy with advanced functionality.
61051 
61052 You get access to more methods, but you have no guarantees about API
61053 stability
61054 
61055 The copy is effectively a deep copy: Updating the state of the copy does not
61056 update the original.
61057 
61058 ";
61059 
61060 %feature("docstring")  casadi::Opti::solve_limited() "
61061 
61062 Crunch the numbers; solve the problem.
61063 
61064 Allows the solver to return without error when an iteration or time limit is
61065 reached
61066 
61067 ";
61068 
61069 %feature("docstring") casadi::Opti::__hash__ "
61070 
61071 Returns a number that is unique for a given Node. If the Object does not
61072 point to any node, \"0\" is returned.
61073 
61074 ";
61075 
61076 %feature("docstring")  casadi::Opti::parameter(casadi_int n=1, casadi_int
61077 m=1, const std::string &attribute="full") "
61078 
61079 Create a parameter (symbol); fixed during optimization.
61080 
61081 The order of creation does not matter. It is not required for parameter to
61082 actualy appear in the optimization problem. Parameters that do appear, must
61083 be given a value before the problem can be solved.
61084 
61085 Parameters:
61086 -----------
61087 
61088 n:  number of rows (default 1)
61089 
61090 m:  number of columnss (default 1)
61091 
61092 attribute:  'full' (default) or 'symmetric'
61093 
61094 ";
61095 
61096 %feature("docstring")  casadi::Opti::p() const  "
61097 
61098 Get all (scalarised) parameters as a symbolic column vector.
61099 
61100 ";
61101 
61102 %feature("docstring")  casadi::Opti::set_value(const MX &x, const DM &v) "
61103 
61104 Set value of parameter.
61105 
61106 Each parameter must be given a value before 'solve' can be called
61107 
61108 ";
61109 
61110 %feature("docstring")  casadi::Opti::set_value(const std::vector< MX >
61111 &assignments) "
61112 
61113 Set value of parameter.
61114 
61115 Each parameter must be given a value before 'solve' can be called
61116 
61117 ";
61118 
61119 %feature("docstring")  casadi::Opti::lam_g() const  "
61120 
61121 Get all (scalarised) dual variables as a symbolic column vector.
61122 
61123 Useful for obtaining the Lagrange Hessian:
61124 
61125 ::
61126 
61127   * sol.value(hessian(opti.f+opti.lam_g'*opti.g,opti.x)) % MATLAB
61128   * sol.value(hessian(opti.f+dot(opti.lam_g,opti.g),opti.x)[0]) # Python
61129   *
61130 
61131 
61132 
61133 ";
61134 
61135 %feature("docstring")  casadi::Opti::solve() "
61136 
61137 Crunch the numbers; solve the problem.
61138 
61139 ";
61140 
61141 %feature("docstring") casadi::casadi_solve "
61142 
61143 Crunch the numbers; solve the problem.
61144 
61145 ";
61146 
61147 %feature("docstring")  casadi::Opti::casadi_solve "
61148 
61149 Crunch the numbers; solve the problem.
61150 
61151 ";
61152 
61153 %feature("docstring")  casadi::Opti::x() const  "
61154 
61155 Get all (scalarised) decision variables as a symbolic column vector.
61156 
61157 ";
61158 
61159 %feature("docstring")  casadi::Opti::initial() const  "
61160 
61161 get assignment expressions for initial values
61162 
61163 ";
61164 
61165 %feature("docstring")  casadi::Opti::get_str(bool more=false) const  "
61166 
61167 Get string representation.
61168 
61169 ";
61170 
61171 %feature("docstring")  casadi::Opti::np() const  "
61172 
61173 Number of (scalarised) parameters.
61174 
61175 ";
61176 
61177 %feature("docstring")  casadi::Opti::set_initial(const MX &x, const DM &v) "
61178 
61179 Set initial guess for decision variables
61180 
61181 ::
61182 
61183   * opti.set_initial(x, 2)
61184   * opti.set_initial(10*x(1), 2)
61185   *
61186 
61187 
61188 
61189 ";
61190 
61191 %feature("docstring")  casadi::Opti::set_initial(const std::vector< MX >
61192 &assignments) "
61193 
61194 Set initial guess for decision variables
61195 
61196 ::
61197 
61198   * opti.set_initial(x, 2)
61199   * opti.set_initial(10*x(1), 2)
61200   *
61201 
61202 
61203 
61204 ";
61205 
61206 %feature("docstring")  casadi::Opti::callback_class(OptiCallback *callback)
61207 "
61208 
61209 Helper methods for callback()
61210 
61211 Do not use directly.
61212 
61213 ";
61214 
61215 %feature("docstring")  casadi::Opti::callback_class() "
61216 
61217 Helper methods for callback()
61218 
61219 Do not use directly.
61220 
61221 ";
61222 
61223 %feature("docstring")  casadi::Opti::nx() const  "
61224 
61225 Number of (scalarised) decision variables.
61226 
61227 ";
61228 
61229 %feature("docstring")  casadi::SharedObject::is_null() const  "
61230 
61231 Is a null pointer?
61232 
61233 ";
61234 
61235 %feature("docstring")  casadi::Opti::ng() const  "
61236 
61237 Number of (scalarised) constraints.
61238 
61239 ";
61240 
61241 %feature("docstring") casadi::Opti::Opti(const std::string
61242 &problem_type="nlp") "
61243 
61244 Create Opti Context.
61245 
61246 Parameters:
61247 -----------
61248 
61249 problem_type:  of optimization 'nlp' or 'conic' (default nlp)
61250 
61251 ";
61252 
61253 %feature("docstring")  casadi::Opti::type_name() const  "
61254 
61255 Readable name of the class.
61256 
61257 ";
61258 
61259 %feature("docstring")  casadi::Opti::value(const MX &x, const std::vector<
61260 MX > &values=std::vector< MX >()) const  "
61261 
61262 Obtain value of expression at the current value
61263 
61264 In regular mode, teh current value is the converged solution In debug mode,
61265 the value can be non-converged
61266 
61267 Parameters:
61268 -----------
61269 
61270 values:  Optional assignment expressions (e.g. x==3) to overrule the current
61271 value
61272 
61273 ";
61274 
61275 %feature("docstring")  casadi::Opti::value(const DM &x, const std::vector<
61276 MX > &values=std::vector< MX >()) const  "
61277 
61278 Obtain value of expression at the current value
61279 
61280 In regular mode, teh current value is the converged solution In debug mode,
61281 the value can be non-converged
61282 
61283 Parameters:
61284 -----------
61285 
61286 values:  Optional assignment expressions (e.g. x==3) to overrule the current
61287 value
61288 
61289 ";
61290 
61291 %feature("docstring")  casadi::Opti::value(const SX &x, const std::vector<
61292 MX > &values=std::vector< MX >()) const  "
61293 
61294 Obtain value of expression at the current value
61295 
61296 In regular mode, teh current value is the converged solution In debug mode,
61297 the value can be non-converged
61298 
61299 Parameters:
61300 -----------
61301 
61302 values:  Optional assignment expressions (e.g. x==3) to overrule the current
61303 value
61304 
61305 ";
61306 
61307 %feature("docstring")  casadi::Opti::variable(casadi_int n=1, casadi_int
61308 m=1, const std::string &attribute="full") "
61309 
61310 Create a decision variable (symbol)
61311 
61312 The order of creation matters. The order will be reflected in the
61313 optimization problem. It is not required for decision variables to actualy
61314 appear in the optimization problem.
61315 
61316 Parameters:
61317 -----------
61318 
61319 n:  number of rows (default 1)
61320 
61321 m:  number of columnss (default 1)
61322 
61323 attribute:  'full' (default) or 'symmetric'
61324 
61325 ";
61326 
61327 %feature("docstring") casadi::Opti "
61328 
61329 A simplified interface for NLP modeling/solving.
61330 
61331 This class offers a view with model description facilities The API is
61332 guaranteed to be stable.
61333 
61334 Example NLP:
61335 
61336 ::
61337 
61338     opti = casadi.Opti();
61339 
61340     x = opti.variable();
61341     y = opti.variable();
61342 
61343     opti.minimize(  (y-x^2)^2   );
61344     opti.subject_to( x^2+y^2==1 );
61345     opti.subject_to(     x+y>=1 );
61346 
61347     opti.solver('ipopt');
61348     sol = opti.solve();
61349 
61350     sol.value(x)
61351     sol.value(y)
61352 
61353 
61354 
61355 Example parametric NLP:
61356 
61357 ::
61358 
61359     opti = casadi.Opti();
61360 
61361     x = opti.variable(2,1);
61362     p = opti.parameter();
61363 
61364     opti.minimize(  (p*x(2)-x(1)^2)^2   );
61365     opti.subject_to( 1<=sum(x)<=2 );
61366 
61367     opti.solver('ipopt');
61368 
61369     opti.set_value(p, 3);
61370     sol = opti.solve();
61371     sol.value(x)
61372 
61373     opti.set_value(p, 5);
61374     sol = opti.solve();
61375     sol.value(x)
61376 
61377 
61378 
61379 Joris Gillis, Erik Lambrechts, Joel Andersson
61380 
61381 C++ includes: optistack.hpp ";
61382 
61383 %feature("docstring")  casadi::Opti::lbg() const  "
61384 
61385 Get all (scalarised) bounds on constraints as a column vector.
61386 
61387 ";
61388 
61389 %feature("docstring")  casadi::Opti::return_status() const  "
61390 
61391 Get return status of solver passed as-is from nlpsol No stability can be
61392 guaranteed about this part of the API.
61393 
61394 ";
61395 
61396 %feature("docstring")  casadi::Opti::copy() const  "
61397 
61398 Get a copy of the.
61399 
61400 The copy is effectively a deep copy: Updating the state of the copy does not
61401 update the original.
61402 
61403 ";
61404 
61405 %feature("docstring") casadi::casadi_copy "
61406 
61407 Get a copy of the.
61408 
61409 The copy is effectively a deep copy: Updating the state of the copy does not
61410 update the original.
61411 
61412 ";
61413 
61414 %feature("docstring")  casadi::Opti::casadi_copy "
61415 
61416 Get a copy of the.
61417 
61418 The copy is effectively a deep copy: Updating the state of the copy does not
61419 update the original.
61420 
61421 ";
61422 
61423 %feature("docstring")  casadi::SharedObject::class_name() const  "
61424 
61425 Get class name.
61426 
61427 ";
61428 
61429 %feature("docstring")  casadi::Opti::subject_to(const MX &g) "
61430 
61431 Add constraints.
61432 
61433 Examples:
61434 
61435 ::
61436 
61437   * \\\\begin{itemize}
61438   * opti.subject_to( sqrt(x+y) >= 1);
61439   * opti.subject_to( sqrt(x+y) > 1)}: same as above
61440   * opti.subject_to( 1<= sqrt(x+y) )}: same as above
61441   * opti.subject_to( 5*x+y==1 )}: equality
61442   *
61443   * Python
61444   * opti.subject_to([x*y>=1,x==3])
61445   * opti.subject_to(opti.bounded(0,x,1))
61446   *
61447   * MATLAB
61448   * opti.subject_to({x*y>=1,x==3})
61449   * opti.subject_to( 0<=x<=1 )
61450   *
61451 
61452 
61453 
61454 Related functionalities: opti.lbg,opti.g,opti.ubg represent the vector of
61455 flattened constraints
61456 
61457 opti.debug.show_infeasibilities() may be used to inspect which constraints
61458 are violated
61459 
61460 ";
61461 
61462 %feature("docstring")  casadi::Opti::subject_to(const std::vector< MX > &g)
61463 "
61464 
61465 Add constraints.
61466 
61467 Examples:
61468 
61469 ::
61470 
61471   * \\\\begin{itemize}
61472   * opti.subject_to( sqrt(x+y) >= 1);
61473   * opti.subject_to( sqrt(x+y) > 1)}: same as above
61474   * opti.subject_to( 1<= sqrt(x+y) )}: same as above
61475   * opti.subject_to( 5*x+y==1 )}: equality
61476   *
61477   * Python
61478   * opti.subject_to([x*y>=1,x==3])
61479   * opti.subject_to(opti.bounded(0,x,1))
61480   *
61481   * MATLAB
61482   * opti.subject_to({x*y>=1,x==3})
61483   * opti.subject_to( 0<=x<=1 )
61484   *
61485 
61486 
61487 
61488 Related functionalities: opti.lbg,opti.g,opti.ubg represent the vector of
61489 flattened constraints
61490 
61491 opti.debug.show_infeasibilities() may be used to inspect which constraints
61492 are violated
61493 
61494 ";
61495 
61496 %feature("docstring")  casadi::Opti::subject_to() "
61497 
61498 Clear constraints.
61499 
61500 ";
61501 
61502 %feature("docstring")  casadi::Opti::minimize(const MX &f) "
61503 
61504 Set objective.
61505 
61506 Objective must be a scalar. Default objective: 0 When method is called
61507 multiple times, the last call takes effect
61508 
61509 ";
61510 
61511 %feature("docstring")  casadi::Opti::value_variables() const  "
61512 
61513 get assignment expressions for latest values
61514 
61515 ";
61516 
61517 %feature("docstring")  casadi::Opti::user_dict(const MX &m) const  "
61518 
61519 Get user data.
61520 
61521 ";
61522 
61523 %feature("docstring")  casadi::Opti::to_function(const std::string &name,
61524 const std::vector< MX > &args, const std::vector< MX > &res, const Dict
61525 &opts=Dict()) "
61526 
61527 Create a CasADi Function from the Opti solver.
61528 
61529 ";
61530 
61531 %feature("docstring")  casadi::Opti::advanced() const  "
61532 
61533 Get a copy with advanced functionality.
61534 
61535 You get access to more methods, but you have no guarantees about API
61536 stability
61537 
61538 The copy is effectively a deep copy: Updating the state of the copy does not
61539 update the original.
61540 
61541 ";
61542 
61543 %feature("docstring")  casadi::Opti::solver(const std::string &solver, const
61544 Dict &plugin_options=Dict(), const Dict &solver_options=Dict()) "
61545 
61546 Set a solver.
61547 
61548 Parameters:
61549 -----------
61550 
61551 solver:  any of the nlpsol plugins can be used here In practice, not all
61552 nlpsol plugins may be supported yet
61553 
61554 options:  passed on to nlpsol plugin No stability can be guaranteed about
61555 this part of the API
61556 
61557 options:  to be passed to nlpsol solver No stability can be guaranteed about
61558 this part of the API
61559 
61560 ";
61561 
61562 %feature("docstring") casadi::casadi_solver "
61563 
61564 Set a solver.
61565 
61566 Parameters:
61567 -----------
61568 
61569 solver:  any of the nlpsol plugins can be used here In practice, not all
61570 nlpsol plugins may be supported yet
61571 
61572 options:  passed on to nlpsol plugin No stability can be guaranteed about
61573 this part of the API
61574 
61575 options:  to be passed to nlpsol solver No stability can be guaranteed about
61576 this part of the API
61577 
61578 ";
61579 
61580 %feature("docstring")  casadi::Opti::casadi_solver "
61581 
61582 Set a solver.
61583 
61584 Parameters:
61585 -----------
61586 
61587 solver:  any of the nlpsol plugins can be used here In practice, not all
61588 nlpsol plugins may be supported yet
61589 
61590 options:  passed on to nlpsol plugin No stability can be guaranteed about
61591 this part of the API
61592 
61593 options:  to be passed to nlpsol solver No stability can be guaranteed about
61594 this part of the API
61595 
61596 ";
61597 
61598 %feature("docstring")  casadi::Opti::dual(const MX &m) const  "
61599 
61600 get the dual variable
61601 
61602 m must be a constraint expression. The returned value is still a symbolic
61603 expression. Use value on it to obtain the numerical value.
61604 
61605 ";
61606 
61607 %feature("docstring")  casadi::SharedObject::print_ptr(std::ostream
61608 &stream=casadi::uout()) const  "
61609 
61610 [INTERNAL]  Print the pointer to the internal class
61611 
61612 ";
61613 
61614 %feature("docstring")  casadi::Opti::disp(std::ostream &stream, bool
61615 more=false) const  "
61616 
61617 Print representation.
61618 
61619 ";
61620 
61621 %feature("docstring")  casadi::Opti::update_user_dict(const MX &m, const
61622 Dict &meta) "
61623 
61624 add user data Add arbitrary data in the form of a dictionary to symbols or
61625 constraints
61626 
61627 ";
61628 
61629 
61630 // File: classcasadi_1_1OptiAdvanced.xml
61631 %feature("docstring")  casadi::Opti::dual(const MX &m) const  "
61632 
61633 get the dual variable
61634 
61635 m must be a constraint expression. The returned value is still a symbolic
61636 expression. Use value on it to obtain the numerical value.
61637 
61638 ";
61639 
61640 %feature("docstring")  casadi::Opti::parameter(casadi_int n=1, casadi_int
61641 m=1, const std::string &attribute="full") "
61642 
61643 Create a parameter (symbol); fixed during optimization.
61644 
61645 The order of creation does not matter. It is not required for parameter to
61646 actualy appear in the optimization problem. Parameters that do appear, must
61647 be given a value before the problem can be solved.
61648 
61649 Parameters:
61650 -----------
61651 
61652 n:  number of rows (default 1)
61653 
61654 m:  number of columnss (default 1)
61655 
61656 attribute:  'full' (default) or 'symmetric'
61657 
61658 ";
61659 
61660 %feature("docstring")  casadi::Opti::lam_g() const  "
61661 
61662 Get all (scalarised) dual variables as a symbolic column vector.
61663 
61664 Useful for obtaining the Lagrange Hessian:
61665 
61666 ::
61667 
61668   * sol.value(hessian(opti.f+opti.lam_g'*opti.g,opti.x)) % MATLAB
61669   * sol.value(hessian(opti.f+dot(opti.lam_g,opti.g),opti.x)[0]) # Python
61670   *
61671 
61672 
61673 
61674 ";
61675 
61676 %feature("docstring")  casadi::SharedObject::class_name() const  "
61677 
61678 Get class name.
61679 
61680 ";
61681 
61682 %feature("docstring")  casadi::OptiAdvanced::canon_expr(const MX &expr)
61683 const  "
61684 
61685 Interpret an expression (for internal use only)
61686 
61687 ";
61688 
61689 %feature("docstring")  casadi::OptiAdvanced::get_meta_con(const MX &m) const
61690 "
61691 
61692 Get meta-data of symbol (for internal use only)
61693 
61694 ";
61695 
61696 %feature("docstring")  casadi::OptiAdvanced::set_meta(const MX &m, const
61697 MetaVar &meta) "
61698 
61699 Set meta-data of an expression.
61700 
61701 ";
61702 
61703 %feature("docstring")  casadi::Opti::user_dict(const MX &m) const  "
61704 
61705 Get user data.
61706 
61707 ";
61708 
61709 %feature("docstring") casadi::OptiAdvanced::__hash__ "
61710 
61711 Returns a number that is unique for a given Node. If the Object does not
61712 point to any node, \"0\" is returned.
61713 
61714 ";
61715 
61716 %feature("docstring")  casadi::Opti::disp(std::ostream &stream, bool
61717 more=false) const  "
61718 
61719 Print representation.
61720 
61721 ";
61722 
61723 %feature("docstring")  casadi::OptiAdvanced::set_meta_con(const MX &m, const
61724 MetaCon &meta) "
61725 
61726 Set meta-data of an expression.
61727 
61728 ";
61729 
61730 %feature("docstring")  casadi::Opti::variable(casadi_int n=1, casadi_int
61731 m=1, const std::string &attribute="full") "
61732 
61733 Create a decision variable (symbol)
61734 
61735 The order of creation matters. The order will be reflected in the
61736 optimization problem. It is not required for decision variables to actualy
61737 appear in the optimization problem.
61738 
61739 Parameters:
61740 -----------
61741 
61742 n:  number of rows (default 1)
61743 
61744 m:  number of columnss (default 1)
61745 
61746 attribute:  'full' (default) or 'symmetric'
61747 
61748 ";
61749 
61750 %feature("docstring")  casadi::Opti::value_variables() const  "
61751 
61752 get assignment expressions for latest values
61753 
61754 ";
61755 
61756 %feature("docstring")  casadi::Opti::solve() "
61757 
61758 Crunch the numbers; solve the problem.
61759 
61760 ";
61761 
61762 %feature("docstring") casadi::casadi_solve "
61763 
61764 Crunch the numbers; solve the problem.
61765 
61766 ";
61767 
61768 %feature("docstring")  casadi::Opti::casadi_solve "
61769 
61770 Crunch the numbers; solve the problem.
61771 
61772 ";
61773 
61774 %feature("docstring")  casadi::Opti::copy() const  "
61775 
61776 Get a copy of the.
61777 
61778 The copy is effectively a deep copy: Updating the state of the copy does not
61779 update the original.
61780 
61781 ";
61782 
61783 %feature("docstring") casadi::casadi_copy "
61784 
61785 Get a copy of the.
61786 
61787 The copy is effectively a deep copy: Updating the state of the copy does not
61788 update the original.
61789 
61790 ";
61791 
61792 %feature("docstring")  casadi::Opti::casadi_copy "
61793 
61794 Get a copy of the.
61795 
61796 The copy is effectively a deep copy: Updating the state of the copy does not
61797 update the original.
61798 
61799 ";
61800 
61801 %feature("docstring") casadi::OptiAdvanced "
61802 
61803 C++ includes: optistack.hpp ";
61804 
61805 %feature("docstring")  casadi::Opti::value(const MX &x, const std::vector<
61806 MX > &values=std::vector< MX >()) const  "
61807 
61808 Obtain value of expression at the current value
61809 
61810 In regular mode, teh current value is the converged solution In debug mode,
61811 the value can be non-converged
61812 
61813 Parameters:
61814 -----------
61815 
61816 values:  Optional assignment expressions (e.g. x==3) to overrule the current
61817 value
61818 
61819 ";
61820 
61821 %feature("docstring")  casadi::Opti::value(const DM &x, const std::vector<
61822 MX > &values=std::vector< MX >()) const  "
61823 
61824 Obtain value of expression at the current value
61825 
61826 In regular mode, teh current value is the converged solution In debug mode,
61827 the value can be non-converged
61828 
61829 Parameters:
61830 -----------
61831 
61832 values:  Optional assignment expressions (e.g. x==3) to overrule the current
61833 value
61834 
61835 ";
61836 
61837 %feature("docstring")  casadi::Opti::value(const SX &x, const std::vector<
61838 MX > &values=std::vector< MX >()) const  "
61839 
61840 Obtain value of expression at the current value
61841 
61842 In regular mode, teh current value is the converged solution In debug mode,
61843 the value can be non-converged
61844 
61845 Parameters:
61846 -----------
61847 
61848 values:  Optional assignment expressions (e.g. x==3) to overrule the current
61849 value
61850 
61851 ";
61852 
61853 %feature("docstring")  casadi::OptiAdvanced::casadi_solver() const  "
61854 
61855 Get the underlying CasADi solver of the Opti stack.
61856 
61857 ";
61858 
61859 %feature("docstring")  casadi::Opti::update_user_dict(const MX &m, const
61860 Dict &meta) "
61861 
61862 add user data Add arbitrary data in the form of a dictionary to symbols or
61863 constraints
61864 
61865 ";
61866 
61867 %feature("docstring")  casadi::Opti::set_initial(const MX &x, const DM &v) "
61868 
61869 Set initial guess for decision variables
61870 
61871 ::
61872 
61873   * opti.set_initial(x, 2)
61874   * opti.set_initial(10*x(1), 2)
61875   *
61876 
61877 
61878 
61879 ";
61880 
61881 %feature("docstring")  casadi::Opti::set_initial(const std::vector< MX >
61882 &assignments) "
61883 
61884 Set initial guess for decision variables
61885 
61886 ::
61887 
61888   * opti.set_initial(x, 2)
61889   * opti.set_initial(10*x(1), 2)
61890   *
61891 
61892 
61893 
61894 ";
61895 
61896 %feature("docstring") casadi::OptiAdvanced::~OptiAdvanced "
61897 
61898 Destructor.
61899 
61900 ";
61901 
61902 %feature("docstring")  casadi::Opti::callback_class(OptiCallback *callback)
61903 "
61904 
61905 Helper methods for callback()
61906 
61907 Do not use directly.
61908 
61909 ";
61910 
61911 %feature("docstring")  casadi::Opti::callback_class() "
61912 
61913 Helper methods for callback()
61914 
61915 Do not use directly.
61916 
61917 ";
61918 
61919 %feature("docstring")  casadi::Opti::get_str(bool more=false) const  "
61920 
61921 Get string representation.
61922 
61923 ";
61924 
61925 %feature("docstring")  casadi::Opti::to_function(const std::string &name,
61926 const std::vector< MX > &args, const std::vector< MX > &res, const Dict
61927 &opts=Dict()) "
61928 
61929 Create a CasADi Function from the Opti solver.
61930 
61931 ";
61932 
61933 %feature("docstring")  casadi::Opti::lbg() const  "
61934 
61935 Get all (scalarised) bounds on constraints as a column vector.
61936 
61937 ";
61938 
61939 %feature("docstring")  casadi::Opti::ng() const  "
61940 
61941 Number of (scalarised) constraints.
61942 
61943 ";
61944 
61945 %feature("docstring")  casadi::OptiAdvanced::get_meta(const MX &m) const  "
61946 
61947 Get meta-data of symbol (for internal use only)
61948 
61949 ";
61950 
61951 %feature("docstring")  casadi::Opti::subject_to(const MX &g) "
61952 
61953 Add constraints.
61954 
61955 Examples:
61956 
61957 ::
61958 
61959   * \\\\begin{itemize}
61960   * opti.subject_to( sqrt(x+y) >= 1);
61961   * opti.subject_to( sqrt(x+y) > 1)}: same as above
61962   * opti.subject_to( 1<= sqrt(x+y) )}: same as above
61963   * opti.subject_to( 5*x+y==1 )}: equality
61964   *
61965   * Python
61966   * opti.subject_to([x*y>=1,x==3])
61967   * opti.subject_to(opti.bounded(0,x,1))
61968   *
61969   * MATLAB
61970   * opti.subject_to({x*y>=1,x==3})
61971   * opti.subject_to( 0<=x<=1 )
61972   *
61973 
61974 
61975 
61976 Related functionalities: opti.lbg,opti.g,opti.ubg represent the vector of
61977 flattened constraints
61978 
61979 opti.debug.show_infeasibilities() may be used to inspect which constraints
61980 are violated
61981 
61982 ";
61983 
61984 %feature("docstring")  casadi::Opti::subject_to(const std::vector< MX > &g)
61985 "
61986 
61987 Add constraints.
61988 
61989 Examples:
61990 
61991 ::
61992 
61993   * \\\\begin{itemize}
61994   * opti.subject_to( sqrt(x+y) >= 1);
61995   * opti.subject_to( sqrt(x+y) > 1)}: same as above
61996   * opti.subject_to( 1<= sqrt(x+y) )}: same as above
61997   * opti.subject_to( 5*x+y==1 )}: equality
61998   *
61999   * Python
62000   * opti.subject_to([x*y>=1,x==3])
62001   * opti.subject_to(opti.bounded(0,x,1))
62002   *
62003   * MATLAB
62004   * opti.subject_to({x*y>=1,x==3})
62005   * opti.subject_to( 0<=x<=1 )
62006   *
62007 
62008 
62009 
62010 Related functionalities: opti.lbg,opti.g,opti.ubg represent the vector of
62011 flattened constraints
62012 
62013 opti.debug.show_infeasibilities() may be used to inspect which constraints
62014 are violated
62015 
62016 ";
62017 
62018 %feature("docstring")  casadi::Opti::subject_to() "
62019 
62020 Clear constraints.
62021 
62022 ";
62023 
62024 %feature("docstring")  casadi::Opti::initial() const  "
62025 
62026 get assignment expressions for initial values
62027 
62028 ";
62029 
62030 %feature("docstring")  casadi::Opti::type_name() const  "
62031 
62032 Readable name of the class.
62033 
62034 ";
62035 
62036 %feature("docstring")  casadi::Opti::nx() const  "
62037 
62038 Number of (scalarised) decision variables.
62039 
62040 ";
62041 
62042 %feature("docstring")  casadi::Opti::set_value(const MX &x, const DM &v) "
62043 
62044 Set value of parameter.
62045 
62046 Each parameter must be given a value before 'solve' can be called
62047 
62048 ";
62049 
62050 %feature("docstring")  casadi::Opti::set_value(const std::vector< MX >
62051 &assignments) "
62052 
62053 Set value of parameter.
62054 
62055 Each parameter must be given a value before 'solve' can be called
62056 
62057 ";
62058 
62059 %feature("docstring")  casadi::Opti::debug() const  "
62060 
62061 Get a copy with advanced functionality.
62062 
62063 You get access to more methods, but you have no guarantees about API
62064 stability
62065 
62066 The copy is effectively a deep copy: Updating the state of the copy does not
62067 update the original.
62068 
62069 ";
62070 
62071 %feature("docstring")  casadi::SharedObject::print_ptr(std::ostream
62072 &stream=casadi::uout()) const  "
62073 
62074 [INTERNAL]  Print the pointer to the internal class
62075 
62076 ";
62077 
62078 %feature("docstring")  casadi::Opti::np() const  "
62079 
62080 Number of (scalarised) parameters.
62081 
62082 ";
62083 
62084 %feature("docstring")  casadi::OptiAdvanced::symvar() const  "
62085 
62086 Get symbols present in expression.
62087 
62088 Returned vector is ordered according to the order of variable()/parameter()
62089 calls used to create the variables
62090 
62091 ";
62092 
62093 %feature("docstring") casadi::casadi_symvar "
62094 
62095 Get symbols present in expression.
62096 
62097 Returned vector is ordered according to the order of variable()/parameter()
62098 calls used to create the variables
62099 
62100 ";
62101 
62102 %feature("docstring")  casadi::OptiAdvanced::casadi_symvar "
62103 
62104 Get symbols present in expression.
62105 
62106 Returned vector is ordered according to the order of variable()/parameter()
62107 calls used to create the variables
62108 
62109 ";
62110 
62111 %feature("docstring")  casadi::OptiAdvanced::symvar(const MX &expr) const  "
62112 
62113 Get symbols present in expression.
62114 
62115 Returned vector is ordered according to the order of variable()/parameter()
62116 calls used to create the variables
62117 
62118 ";
62119 
62120 %feature("docstring") casadi::casadi_symvar "
62121 
62122 Get symbols present in expression.
62123 
62124 Returned vector is ordered according to the order of variable()/parameter()
62125 calls used to create the variables
62126 
62127 ";
62128 
62129 %feature("docstring")  casadi::OptiAdvanced::casadi_symvar "
62130 
62131 Get symbols present in expression.
62132 
62133 Returned vector is ordered according to the order of variable()/parameter()
62134 calls used to create the variables
62135 
62136 ";
62137 
62138 %feature("docstring")  casadi::OptiAdvanced::symvar(const MX &expr,
62139 VariableType type) const  "
62140 
62141 Get symbols present in expression.
62142 
62143 Returned vector is ordered according to the order of variable()/parameter()
62144 calls used to create the variables
62145 
62146 ";
62147 
62148 %feature("docstring") casadi::casadi_symvar "
62149 
62150 Get symbols present in expression.
62151 
62152 Returned vector is ordered according to the order of variable()/parameter()
62153 calls used to create the variables
62154 
62155 ";
62156 
62157 %feature("docstring")  casadi::OptiAdvanced::casadi_symvar "
62158 
62159 Get symbols present in expression.
62160 
62161 Returned vector is ordered according to the order of variable()/parameter()
62162 calls used to create the variables
62163 
62164 ";
62165 
62166 %feature("docstring")  casadi::Opti::advanced() const  "
62167 
62168 Get a copy with advanced functionality.
62169 
62170 You get access to more methods, but you have no guarantees about API
62171 stability
62172 
62173 The copy is effectively a deep copy: Updating the state of the copy does not
62174 update the original.
62175 
62176 ";
62177 
62178 %feature("docstring")  casadi::Opti::f() const  "
62179 
62180 Get objective expression.
62181 
62182 ";
62183 
62184 %feature("docstring")  casadi::Opti::g() const  "
62185 
62186 Get all (scalarised) constraint expressions as a column vector.
62187 
62188 ";
62189 
62190 %feature("docstring")  casadi::Opti::stats() const  "
62191 
62192 Get statistics.
62193 
62194 nlpsol stats are passed as-is. No stability can be guaranteed about this
62195 part of the API
62196 
62197 ";
62198 
62199 %feature("docstring")  casadi::SharedObject::is_null() const  "
62200 
62201 Is a null pointer?
62202 
62203 ";
62204 
62205 %feature("docstring")  casadi::Opti::return_status() const  "
62206 
62207 Get return status of solver passed as-is from nlpsol No stability can be
62208 guaranteed about this part of the API.
62209 
62210 ";
62211 
62212 %feature("docstring")  casadi::Opti::solve_limited() "
62213 
62214 Crunch the numbers; solve the problem.
62215 
62216 Allows the solver to return without error when an iteration or time limit is
62217 reached
62218 
62219 ";
62220 
62221 %feature("docstring")  casadi::OptiAdvanced::bake() "
62222 
62223 Fix the structure of the optimization problem.
62224 
62225 ";
62226 
62227 %feature("docstring")  casadi::OptiAdvanced::is_parametric(const MX &expr)
62228 const  "
62229 
62230 return true if expression is only dependant on Opti parameters, not
62231 variables
62232 
62233 ";
62234 
62235 %feature("docstring")  casadi::Opti::p() const  "
62236 
62237 Get all (scalarised) parameters as a symbolic column vector.
62238 
62239 ";
62240 
62241 %feature("docstring")  casadi::Opti::solver(const std::string &solver, const
62242 Dict &plugin_options=Dict(), const Dict &solver_options=Dict()) "
62243 
62244 Set a solver.
62245 
62246 Parameters:
62247 -----------
62248 
62249 solver:  any of the nlpsol plugins can be used here In practice, not all
62250 nlpsol plugins may be supported yet
62251 
62252 options:  passed on to nlpsol plugin No stability can be guaranteed about
62253 this part of the API
62254 
62255 options:  to be passed to nlpsol solver No stability can be guaranteed about
62256 this part of the API
62257 
62258 ";
62259 
62260 %feature("docstring") casadi::casadi_solver "
62261 
62262 Set a solver.
62263 
62264 Parameters:
62265 -----------
62266 
62267 solver:  any of the nlpsol plugins can be used here In practice, not all
62268 nlpsol plugins may be supported yet
62269 
62270 options:  passed on to nlpsol plugin No stability can be guaranteed about
62271 this part of the API
62272 
62273 options:  to be passed to nlpsol solver No stability can be guaranteed about
62274 this part of the API
62275 
62276 ";
62277 
62278 %feature("docstring")  casadi::Opti::casadi_solver "
62279 
62280 Set a solver.
62281 
62282 Parameters:
62283 -----------
62284 
62285 solver:  any of the nlpsol plugins can be used here In practice, not all
62286 nlpsol plugins may be supported yet
62287 
62288 options:  passed on to nlpsol plugin No stability can be guaranteed about
62289 this part of the API
62290 
62291 options:  to be passed to nlpsol solver No stability can be guaranteed about
62292 this part of the API
62293 
62294 ";
62295 
62296 %feature("docstring")  casadi::Opti::minimize(const MX &f) "
62297 
62298 Set objective.
62299 
62300 Objective must be a scalar. Default objective: 0 When method is called
62301 multiple times, the last call takes effect
62302 
62303 ";
62304 
62305 %feature("docstring")  casadi::Opti::x() const  "
62306 
62307 Get all (scalarised) decision variables as a symbolic column vector.
62308 
62309 ";
62310 
62311 
62312 // File: classcasadi_1_1OptiCallback.xml
62313 %feature("docstring") casadi::OptiCallback "
62314 
62315 C++ includes: optistack.hpp ";
62316 
62317 
62318 // File: classcasadi_1_1OptiSol.xml
62319 %feature("docstring")  casadi::OptiSol::value_variables() const  "
62320 
62321 get assignment expressions for the optimal solution
62322 
62323 ";
62324 
62325 %feature("docstring")  casadi::OptiSol::stats() const  "
62326 
62327 Get statistics.
62328 
62329 nlpsol stats are passed as-is. No stability can be guaranteed about this
62330 part of the API
62331 
62332 ";
62333 
62334 %feature("docstring")  casadi::OptiSol::value(const MX &x, const
62335 std::vector< MX > &values=std::vector< MX >()) const  "
62336 
62337 Obtain value of expression at the current value
62338 
62339 In regular mode, teh current value is the converged solution In debug mode,
62340 the value can be non-converged
62341 
62342 Parameters:
62343 -----------
62344 
62345 values:  Optional assignment expressions (e.g. x==3) to overrule the current
62346 value
62347 
62348 ";
62349 
62350 %feature("docstring")  casadi::OptiSol::value(const DM &x, const
62351 std::vector< MX > &values=std::vector< MX >()) const  "
62352 
62353 Obtain value of expression at the current value
62354 
62355 In regular mode, teh current value is the converged solution In debug mode,
62356 the value can be non-converged
62357 
62358 Parameters:
62359 -----------
62360 
62361 values:  Optional assignment expressions (e.g. x==3) to overrule the current
62362 value
62363 
62364 ";
62365 
62366 %feature("docstring")  casadi::OptiSol::value(const SX &x, const
62367 std::vector< MX > &values=std::vector< MX >()) const  "
62368 
62369 Obtain value of expression at the current value
62370 
62371 In regular mode, teh current value is the converged solution In debug mode,
62372 the value can be non-converged
62373 
62374 Parameters:
62375 -----------
62376 
62377 values:  Optional assignment expressions (e.g. x==3) to overrule the current
62378 value
62379 
62380 ";
62381 
62382 %feature("docstring") casadi::OptiSol "
62383 
62384 A simplified interface for NLP modeling/solving.
62385 
62386 This class offers a view with solution retrieval facilities The API is
62387 guaranteed to be stable.
62388 
62389 Joris Gillis, Erik Lambrechts
62390 
62391 C++ includes: optistack.hpp ";
62392 
62393 
62394 // File: classcasadi_1_1OracleFunction.xml
62395 %feature("docstring")  casadi::FunctionInternal::get_reverse(casadi_int
62396 nadj, const std::string &name, const std::vector< std::string > &inames,
62397 const std::vector< std::string > &onames, const Dict &opts) const  "
62398 
62399 [INTERNAL]  Return function that calculates adjoint derivatives
62400 reverse(nadj) returns a cached instance if available, and calls  Function
62401 get_reverse(casadi_int nadj) if no cached version is available.
62402 
62403 ";
62404 
62405 %feature("docstring")  casadi::FunctionInternal::sz_w() const  "
62406 
62407 [INTERNAL]  Get required length of w field.
62408 
62409 ";
62410 
62411 %feature("docstring")  casadi::ProtoFunction::construct(const Dict &opts) "
62412 
62413 [INTERNAL]  Construct Prepares the function for evaluation.
62414 
62415 ";
62416 
62417 %feature("docstring")  casadi::FunctionInternal::n_instructions() const  "
62418 
62419 [INTERNAL]  Get the number of atomic operations.
62420 
62421 ";
62422 
62423 %feature("docstring")
62424 casadi::FunctionInternal::codegen_free_mem(CodeGenerator &g) const  "
62425 
62426 [INTERNAL]  Codegen for free_mem.
62427 
62428 ";
62429 
62430 %feature("docstring")  casadi::FunctionInternal::get_partition(casadi_int
62431 iind, casadi_int oind, Sparsity &D1, Sparsity &D2, bool compact, bool
62432 symmetric, bool allow_forward, bool allow_reverse) const  "
62433 
62434 [INTERNAL]  Get the unidirectional or bidirectional partition.
62435 
62436 ";
62437 
62438 %feature("docstring")  casadi::FunctionInternal::has_forward(casadi_int
62439 nfwd) const  "
62440 
62441 [INTERNAL]  Return function that calculates forward derivatives
62442 forward(nfwd) returns a cached instance if available, and calls  Function
62443 get_forward(casadi_int nfwd) if no cached version is available.
62444 
62445 ";
62446 
62447 %feature("docstring")  casadi::FunctionInternal::instruction_MX(casadi_int
62448 k) const  "
62449 
62450 [INTERNAL]  get MX expression associated with instruction
62451 
62452 ";
62453 
62454 %feature("docstring")  casadi::ProtoFunction::clear_mem() "
62455 
62456 [INTERNAL]  Clear all memory (called from destructor)
62457 
62458 ";
62459 
62460 %feature("docstring")  casadi::FunctionInternal::get_sparsity_out(casadi_int
62461 i) "
62462 
62463 [INTERNAL]  Get sparsity of a given output.
62464 
62465 ";
62466 
62467 %feature("docstring")  casadi::FunctionInternal::symbolic_output(const
62468 std::vector< MX > &arg) const  "
62469 
62470 [INTERNAL]  Get a vector of symbolic variables corresponding to the outputs.
62471 
62472 ";
62473 
62474 %feature("docstring")  casadi::FunctionInternal::has_codegen() const  "
62475 
62476 [INTERNAL]  Is codegen supported?
62477 
62478 ";
62479 
62480 %feature("docstring")  casadi::ProtoFunction::print(const char *fmt,...)
62481 const  "
62482 
62483 [INTERNAL]  C-style formatted printing during evaluation.
62484 
62485 ";
62486 
62487 %feature("docstring")  casadi::ProtoFunction::format_time(char *buffer,
62488 double time) const  "
62489 
62490 [INTERNAL]  Format time in a fixed width 8 format.
62491 
62492 ";
62493 
62494 %feature("docstring")  casadi::FunctionInternal::codegen_body(CodeGenerator
62495 &g) const  "
62496 
62497 [INTERNAL]  Generate code for the function body.
62498 
62499 ";
62500 
62501 %feature("docstring") casadi::OracleFunction::~OracleFunction "
62502 
62503 [INTERNAL]  Destructor.
62504 
62505 ";
62506 
62507 %feature("docstring")  casadi::OracleFunction::has_function(const
62508 std::string &fname) const  "
62509 
62510 [INTERNAL] ";
62511 
62512 %feature("docstring")  casadi::FunctionInternal::dm_in(casadi_int ind) const
62513 "
62514 
62515 [INTERNAL]  Get function input(s) and output(s)
62516 
62517 ";
62518 
62519 %feature("docstring")  casadi::FunctionInternal::dm_in() const  "
62520 
62521 [INTERNAL]  Get function input(s) and output(s)
62522 
62523 ";
62524 
62525 %feature("docstring")  casadi::FunctionInternal::symbolicAdjSeed(casadi_int
62526 nadj, const std::vector< MatType > &v) const  "
62527 
62528 [INTERNAL]  Symbolic expressions for the adjoint seeds.
62529 
62530 ";
62531 
62532 %feature("docstring")  casadi::OracleFunction::oracle() const  "
62533 
62534 [INTERNAL]  Get oracle.
62535 
62536 ";
62537 
62538 %feature("docstring")  casadi::FunctionInternal::codegen_name(const
62539 CodeGenerator &g, bool ns=true) const  "
62540 
62541 [INTERNAL]  Get name in codegen.
62542 
62543 ";
62544 
62545 %feature("docstring")  casadi::FunctionInternal::project_arg(const
62546 std::vector< M > &arg, casadi_int npar) const  "
62547 
62548 [INTERNAL]   Project sparsities.
62549 
62550 ";
62551 
62552 %feature("docstring")  casadi::FunctionInternal::sparsity_out(casadi_int
62553 ind) const  "
62554 
62555 [INTERNAL]  Input/output sparsity.
62556 
62557 ";
62558 
62559 %feature("docstring")
62560 casadi::FunctionInternal::instruction_input(casadi_int k) const  "
62561 
62562 [INTERNAL]  Get the (integer) input arguments of an atomic operation.
62563 
62564 ";
62565 
62566 %feature("docstring")  casadi::FunctionInternal::has_jacobian() const  "
62567 
62568 [INTERNAL]  Return Jacobian of all input elements with respect to all output
62569 elements.
62570 
62571 ";
62572 
62573 %feature("docstring")  casadi::FunctionInternal::n_nodes() const  "
62574 
62575 [INTERNAL]  Number of nodes in the algorithm.
62576 
62577 ";
62578 
62579 %feature("docstring")  casadi::FunctionInternal::codegen_mem(CodeGenerator
62580 &g, const std::string &index="mem") const  "
62581 
62582 [INTERNAL]  Get thread-local memory object.
62583 
62584 ";
62585 
62586 %feature("docstring")  casadi::FunctionInternal::print_options(std::ostream
62587 &stream) const  "
62588 
62589 [INTERNAL]  Print list of options.
62590 
62591 ";
62592 
62593 %feature("docstring")
62594 casadi::FunctionInternal::codegen_init_mem(CodeGenerator &g) const  "
62595 
62596 [INTERNAL]  Codegen decref for init_mem.
62597 
62598 ";
62599 
62600 %feature("docstring")  casadi::FunctionInternal::has_jacobian_sparsity()
62601 const  "
62602 
62603 [INTERNAL]  Get Jacobian sparsity.
62604 
62605 ";
62606 
62607 %feature("docstring")  casadi::FunctionInternal::generate_in(const
62608 std::string &fname, const double **arg) const  "
62609 
62610 [INTERNAL]  Export an input file that can be passed to generate C code with
62611 a main.
62612 
62613 ";
62614 
62615 %feature("docstring")  casadi::FunctionInternal::alloc_arg(size_t sz_arg,
62616 bool persistent=false) "
62617 
62618 [INTERNAL]  Ensure required length of arg field.
62619 
62620 ";
62621 
62622 %feature("docstring")
62623 casadi::FunctionInternal::instruction_output(casadi_int k) const  "
62624 
62625 [INTERNAL]  Get the (integer) output argument of an atomic operation.
62626 
62627 ";
62628 
62629 %feature("docstring")  casadi::SharedObjectInternal::class_name() const  "
62630 
62631 [INTERNAL]  Readable name of the internal class.
62632 
62633 ";
62634 
62635 %feature("docstring")  casadi::FunctionInternal::dm_out(casadi_int ind)
62636 const  "
62637 
62638 [INTERNAL]  Get function input(s) and output(s)
62639 
62640 ";
62641 
62642 %feature("docstring")  casadi::FunctionInternal::dm_out() const  "
62643 
62644 [INTERNAL]  Get function input(s) and output(s)
62645 
62646 ";
62647 
62648 %feature("docstring")  casadi::FunctionInternal::index_out(const std::string
62649 &name) const  "
62650 
62651 [INTERNAL]  Get output scheme index by name.
62652 
62653 ";
62654 
62655 %feature("docstring")  casadi::FunctionInternal::nz_in(const std::vector< DM
62656 > &arg) const  "
62657 
62658 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
62659 
62660 ";
62661 
62662 %feature("docstring")  casadi::FunctionInternal::nz_in(const std::vector<
62663 double > &arg) const  "
62664 
62665 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
62666 
62667 ";
62668 
62669 %feature("docstring")  casadi::FunctionInternal::sz_res() const  "
62670 
62671 [INTERNAL]  Get required length of res field.
62672 
62673 ";
62674 
62675 %feature("docstring")  casadi::FunctionInternal::nz_out(const std::vector<
62676 DM > &res) const  "
62677 
62678 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
62679 
62680 ";
62681 
62682 %feature("docstring")  casadi::FunctionInternal::nz_out(const std::vector<
62683 double > &res) const  "
62684 
62685 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
62686 
62687 ";
62688 
62689 %feature("docstring")  casadi::FunctionInternal::wrap_as_needed(const Dict
62690 &opts) const  "
62691 
62692 [INTERNAL]  Wrap in an Function instance consisting of only one MX call.
62693 
62694 ";
62695 
62696 %feature("docstring")  casadi::FunctionInternal::factory(const std::string
62697 &name, const std::vector< std::string > &s_in, const std::vector<
62698 std::string > &s_out, const Function::AuxOut &aux, const Dict &opts) const
62699 "
62700 
62701 [INTERNAL] ";
62702 
62703 %feature("docstring")  casadi::OracleFunction::get_options() const  "
62704 
62705 [INTERNAL]  Options.
62706 
62707 ";
62708 
62709 %feature("docstring")
62710 casadi::FunctionInternal::codegen_sparsities(CodeGenerator &g) const  "
62711 
62712 [INTERNAL]  Codegen sparsities.
62713 
62714 ";
62715 
62716 %feature("docstring")  casadi::FunctionInternal::call_reverse(const
62717 std::vector< MX > &arg, const std::vector< MX > &res, const std::vector<
62718 std::vector< MX > > &aseed, std::vector< std::vector< MX > > &asens, bool
62719 always_inline, bool never_inline) const  "
62720 
62721 [INTERNAL]  Reverse mode, virtual functions overloaded in derived classes.
62722 
62723 ";
62724 
62725 %feature("docstring")  casadi::FunctionInternal::call_reverse(const
62726 std::vector< SX > &arg, const std::vector< SX > &res, const std::vector<
62727 std::vector< SX > > &aseed, std::vector< std::vector< SX > > &asens, bool
62728 always_inline, bool never_inline) const  "
62729 
62730 [INTERNAL]  Reverse mode, virtual functions overloaded in derived classes.
62731 
62732 ";
62733 
62734 %feature("docstring")  casadi::ProtoFunction::sprint(char *buf, size_t
62735 buf_sz, const char *fmt,...) const  "
62736 
62737 [INTERNAL]  C-style formatted printing to string.
62738 
62739 ";
62740 
62741 %feature("docstring")  casadi::FunctionInternal::get_jacobian_sparsity()
62742 const  "
62743 
62744 [INTERNAL]  Get Jacobian sparsity.
62745 
62746 ";
62747 
62748 %feature("docstring")  casadi::FunctionInternal::alloc_iw(size_t sz_iw, bool
62749 persistent=false) "
62750 
62751 [INTERNAL]  Ensure required length of iw field.
62752 
62753 ";
62754 
62755 %feature("docstring")  casadi::FunctionInternal::get_name_out(casadi_int i)
62756 "
62757 
62758 [INTERNAL]  Names of function input and outputs.
62759 
62760 ";
62761 
62762 %feature("docstring")  casadi::ProtoFunction::release(int mem) const  "
62763 
62764 [INTERNAL]  Release a memory object.
62765 
62766 ";
62767 
62768 %feature("docstring")  casadi::FunctionInternal::all_scalar() const  "
62769 
62770 [INTERNAL]  Are all inputs and outputs scalar.
62771 
62772 ";
62773 
62774 %feature("docstring")  casadi::FunctionInternal::info() const  "
62775 
62776 [INTERNAL]  Obtain information about function
62777 
62778 ";
62779 
62780 %feature("docstring")  casadi::FunctionInternal::free_mx() const  "
62781 
62782 [INTERNAL]  Get free variables ( MX)
62783 
62784 ";
62785 
62786 %feature("docstring")  casadi::FunctionInternal::tocache(const Function &f,
62787 const std::string &suffix="") const  "
62788 
62789 [INTERNAL]  Save function to cache.
62790 
62791 ";
62792 
62793 %feature("docstring")  casadi::FunctionInternal::sz_iw() const  "
62794 
62795 [INTERNAL]  Get required length of iw field.
62796 
62797 ";
62798 
62799 %feature("docstring")  casadi::FunctionInternal::size2_in(casadi_int ind)
62800 const  "
62801 
62802 [INTERNAL]  Input/output dimensions.
62803 
62804 ";
62805 
62806 %feature("docstring")  casadi::FunctionInternal::get_abstol() const  "
62807 
62808 [INTERNAL]  Get absolute tolerance.
62809 
62810 ";
62811 
62812 %feature("docstring")  casadi::FunctionInternal::eval_mx(const MXVector
62813 &arg, MXVector &res, bool always_inline, bool never_inline) const  "
62814 
62815 [INTERNAL]  Evaluate with symbolic matrices.
62816 
62817 ";
62818 
62819 %feature("docstring")  casadi::FunctionInternal::setup(void *mem, const
62820 double **arg, double **res, casadi_int *iw, double *w) const  "
62821 
62822 [INTERNAL]  Set the (persistent and temporary) work vectors.
62823 
62824 ";
62825 
62826 %feature("docstring")  casadi::OracleFunction::get_stats(void *mem) const  "
62827 
62828 [INTERNAL]  Get all statistics.
62829 
62830 ";
62831 
62832 %feature("docstring")  casadi::FunctionInternal::call_forward(const
62833 std::vector< MX > &arg, const std::vector< MX > &res, const std::vector<
62834 std::vector< MX > > &fseed, std::vector< std::vector< MX > > &fsens, bool
62835 always_inline, bool never_inline) const  "
62836 
62837 [INTERNAL]  Forward mode AD, virtual functions overloaded in derived
62838 classes.
62839 
62840 ";
62841 
62842 %feature("docstring")  casadi::FunctionInternal::call_forward(const
62843 std::vector< SX > &arg, const std::vector< SX > &res, const std::vector<
62844 std::vector< SX > > &fseed, std::vector< std::vector< SX > > &fsens, bool
62845 always_inline, bool never_inline) const  "
62846 
62847 [INTERNAL]  Forward mode AD, virtual functions overloaded in derived
62848 classes.
62849 
62850 ";
62851 
62852 %feature("docstring")  casadi::FunctionInternal::check_res(const
62853 std::vector< M > &res, casadi_int &npar) const  "
62854 
62855 [INTERNAL]  Check if output arguments have correct length and dimensions.
62856 
62857 Raises errors.
62858 
62859 Parameters:
62860 -----------
62861 
62862 npar[in]:  normal usage: 1, disallow pararallel calls: -1
62863 
62864 npar:  max number of horizontal repetitions across all arguments (or -1)
62865 
62866 ";
62867 
62868 %feature("docstring")  casadi::FunctionInternal::has_reverse(casadi_int
62869 nadj) const  "
62870 
62871 [INTERNAL]  Return function that calculates adjoint derivatives
62872 reverse(nadj) returns a cached instance if available, and calls  Function
62873 get_reverse(casadi_int nadj) if no cached version is available.
62874 
62875 ";
62876 
62877 %feature("docstring")  casadi::FunctionInternal::alloc_res(size_t sz_res,
62878 bool persistent=false) "
62879 
62880 [INTERNAL]  Ensure required length of res field.
62881 
62882 ";
62883 
62884 %feature("docstring")  casadi::FunctionInternal::size_in(casadi_int ind)
62885 const  "
62886 
62887 [INTERNAL]  Input/output dimensions.
62888 
62889 ";
62890 
62891 %feature("docstring")  casadi::FunctionInternal::getJacSparsity(casadi_int
62892 iind, casadi_int oind, bool symmetric) const  "
62893 
62894 [INTERNAL]  Generate the sparsity of a Jacobian block.
62895 
62896 ";
62897 
62898 %feature("docstring")
62899 casadi::FunctionInternal::getJacSparsityHierarchicalSymm(casadi_int iind,
62900 casadi_int oind) const  "
62901 
62902 [INTERNAL]  A flavor of getJacSparsity that does hierarchical block
62903 structure recognition for symmetric Jacobians
62904 
62905 ";
62906 
62907 %feature("docstring")  casadi::FunctionInternal::set_work(void *mem, const
62908 double **&arg, double **&res, casadi_int *&iw, double *&w) const  "
62909 
62910 [INTERNAL]  Set the (persistent) work vectors.
62911 
62912 ";
62913 
62914 %feature("docstring")
62915 casadi::FunctionInternal::codegen_incref(CodeGenerator &g) const  "
62916 
62917 [INTERNAL]  Codegen incref for dependencies.
62918 
62919 ";
62920 
62921 %feature("docstring")  casadi::FunctionInternal::size_out(casadi_int ind)
62922 const  "
62923 
62924 [INTERNAL]  Input/output dimensions.
62925 
62926 ";
62927 
62928 %feature("docstring")  casadi::FunctionInternal::convert_res(const
62929 std::vector< M > &res) const  "
62930 
62931 [INTERNAL]  Convert from/to input/output lists/map.
62932 
62933 ";
62934 
62935 %feature("docstring")  casadi::FunctionInternal::convert_res(const std::map<
62936 std::string, M > &res) const  "
62937 
62938 [INTERNAL]  Convert from/to input/output lists/map.
62939 
62940 ";
62941 
62942 %feature("docstring")  casadi::FunctionInternal::replace_res(const
62943 std::vector< M > &res, casadi_int npar) const  "
62944 
62945 [INTERNAL]  Replace 0-by-0 outputs.
62946 
62947 ";
62948 
62949 %feature("docstring")  casadi::FunctionInternal::eval(const double **arg,
62950 double **res, casadi_int *iw, double *w, void *mem) const  "
62951 
62952 [INTERNAL]  Evaluate numerically.
62953 
62954 ";
62955 
62956 %feature("docstring")  casadi::FunctionInternal::convert_arg(const
62957 std::vector< M > &arg) const  "
62958 
62959 [INTERNAL]  Convert from/to input/output lists/map.
62960 
62961 ";
62962 
62963 %feature("docstring")  casadi::FunctionInternal::convert_arg(const std::map<
62964 std::string, M > &arg) const  "
62965 
62966 [INTERNAL]  Convert from/to input/output lists/map.
62967 
62968 ";
62969 
62970 %feature("docstring")  casadi::FunctionInternal::generate_out(const
62971 std::string &fname, double **res) const  "
62972 
62973 [INTERNAL] ";
62974 
62975 %feature("docstring")  casadi::FunctionInternal::has_sprev() const  "
62976 
62977 [INTERNAL]  Is the class able to propagate seeds through the algorithm?
62978 
62979 ";
62980 
62981 %feature("docstring")  casadi::FunctionInternal::codegen(CodeGenerator &g,
62982 const std::string &fname) const  "
62983 
62984 [INTERNAL]  Generate code the function.
62985 
62986 ";
62987 
62988 %feature("docstring")  casadi::FunctionInternal::get_sparsity_in(casadi_int
62989 i) "
62990 
62991 [INTERNAL]  Get sparsity of a given input.
62992 
62993 ";
62994 
62995 %feature("docstring")  casadi::FunctionInternal::codegen_mem_type() const  "
62996 
62997 [INTERNAL]  Thread-local memory object type.
62998 
62999 ";
63000 
63001 %feature("docstring")  casadi::FunctionInternal::get_jac(const std::string
63002 &name, const std::vector< std::string > &inames, const std::vector<
63003 std::string > &onames, const Dict &opts) const  "
63004 
63005 [INTERNAL]  Return Jacobian of all input elements with respect to all output
63006 elements.
63007 
63008 ";
63009 
63010 %feature("docstring")  casadi::FunctionInternal::size2_out(casadi_int ind)
63011 const  "
63012 
63013 [INTERNAL]  Input/output dimensions.
63014 
63015 ";
63016 
63017 %feature("docstring")  casadi::FunctionInternal::sp_reverse(bvec_t **arg,
63018 bvec_t **res, casadi_int *iw, bvec_t *w, void *mem) const  "
63019 
63020 [INTERNAL]  Propagate sparsity backwards.
63021 
63022 ";
63023 
63024 %feature("docstring")  casadi::FunctionInternal::map(casadi_int n, const
63025 std::string &parallelization) const  "
63026 
63027 [INTERNAL]  Generate/retrieve cached serial map.
63028 
63029 ";
63030 
63031 %feature("docstring")  casadi::FunctionInternal::is_a(const std::string
63032 &type, bool recursive) const  "
63033 
63034 [INTERNAL]  Check if the function is of a particular type.
63035 
63036 ";
63037 
63038 %feature("docstring")  casadi::FunctionInternal::sparsity_in(casadi_int ind)
63039 const  "
63040 
63041 [INTERNAL]  Input/output sparsity.
63042 
63043 ";
63044 
63045 %feature("docstring")  casadi::FunctionInternal::export_code(const
63046 std::string &lang, std::ostream &stream, const Dict &options) const  "
63047 
63048 [INTERNAL]  Export function in a specific language.
63049 
63050 ";
63051 
63052 %feature("docstring")  casadi::FunctionInternal::definition() const  "
63053 
63054 [INTERNAL]  Get function signature: name:(inputs)->(outputs)
63055 
63056 ";
63057 
63058 %feature("docstring")  casadi::FunctionInternal::incache(const std::string
63059 &fname, Function &f, const std::string &suffix="") const  "
63060 
63061 [INTERNAL]  Get function in cache.
63062 
63063 ";
63064 
63065 %feature("docstring")  casadi::OracleFunction::get_function() const  "
63066 
63067 [INTERNAL]  Get list of dependency functions -1 Indicates irregularity.
63068 
63069 ";
63070 
63071 %feature("docstring")  casadi::OracleFunction::get_function(const
63072 std::string &name) const  "
63073 
63074 [INTERNAL] ";
63075 
63076 %feature("docstring")  casadi::FunctionInternal::fwdViaJac(casadi_int nfwd)
63077 const  "
63078 
63079 [INTERNAL]  Calculate derivatives by multiplying the full Jacobian and
63080 multiplying.
63081 
63082 ";
63083 
63084 %feature("docstring")  casadi::OracleFunction::expand() "
63085 
63086 [INTERNAL] ";
63087 
63088 %feature("docstring")  casadi::FunctionInternal::has_eval_dm() const  "
63089 
63090 [INTERNAL]  Evaluate with DM matrices.
63091 
63092 ";
63093 
63094 %feature("docstring")  casadi::OracleFunction::create_function(const
63095 std::string &fname, const std::vector< std::string > &s_in, const
63096 std::vector< std::string > &s_out, const Function::AuxOut
63097 &aux=Function::AuxOut()) "
63098 
63099 [INTERNAL]  Create an oracle function
63100 
63101 ";
63102 
63103 %feature("docstring")
63104 casadi::FunctionInternal::codegen_declarations(CodeGenerator &g) const  "
63105 
63106 [INTERNAL]  Generate code for the declarations of the C function.
63107 
63108 ";
63109 
63110 %feature("docstring")  casadi::FunctionInternal::replace_aseed(const
63111 std::vector< std::vector< M >> &aseed, casadi_int npar) const  "
63112 
63113 [INTERNAL]  Replace 0-by-0 reverse seeds.
63114 
63115 ";
63116 
63117 %feature("docstring")  casadi::FunctionInternal::replace_aseed(const
63118 std::vector< std::vector< M > > &aseed, casadi_int npar) const  "
63119 
63120 [INTERNAL] ";
63121 
63122 %feature("docstring")  casadi::FunctionInternal::get_n_in() "
63123 
63124 [INTERNAL]  Number of function inputs and outputs.
63125 
63126 ";
63127 
63128 %feature("docstring")  casadi::FunctionInternal::forward(casadi_int nfwd)
63129 const  "
63130 
63131 [INTERNAL]  Return function that calculates forward derivatives
63132 forward(nfwd) returns a cached instance if available, and calls  Function
63133 get_forward(casadi_int nfwd) if no cached version is available.
63134 
63135 ";
63136 
63137 %feature("docstring")  casadi::FunctionInternal::mapsum_mx(const
63138 std::vector< MX > &arg, const std::string &parallelization) "
63139 
63140 [INTERNAL]  Parallel evaluation.
63141 
63142 ";
63143 
63144 %feature("docstring")  casadi::FunctionInternal::codegen_meta(CodeGenerator
63145 &g) const  "
63146 
63147 [INTERNAL]  Generate meta-information allowing a user to evaluate a
63148 generated function.
63149 
63150 ";
63151 
63152 %feature("docstring")  casadi::ProtoFunction::print_time(const std::map<
63153 std::string, FStats > &fstats) const  "
63154 
63155 [INTERNAL]  Print timing statistics.
63156 
63157 ";
63158 
63159 %feature("docstring")  casadi::FunctionInternal::reverse(casadi_int nadj)
63160 const  "
63161 
63162 [INTERNAL]  Return function that calculates adjoint derivatives
63163 reverse(nadj) returns a cached instance if available, and calls  Function
63164 get_reverse(casadi_int nadj) if no cached version is available.
63165 
63166 ";
63167 
63168 %feature("docstring")  casadi::FunctionInternal::has_derivative() const  "
63169 
63170 [INTERNAL]  Can derivatives be calculated in any way?
63171 
63172 ";
63173 
63174 %feature("docstring")  casadi::FunctionInternal::get_jacobian(const
63175 std::string &name, const std::vector< std::string > &inames, const
63176 std::vector< std::string > &onames, const Dict &opts) const  "
63177 
63178 [INTERNAL]  Return Jacobian of all input elements with respect to all output
63179 elements.
63180 
63181 ";
63182 
63183 %feature("docstring")  casadi::FunctionInternal::sx_out(casadi_int ind)
63184 const  "
63185 
63186 [INTERNAL]  Get function input(s) and output(s)
63187 
63188 ";
63189 
63190 %feature("docstring")  casadi::FunctionInternal::sx_out() const  "
63191 
63192 [INTERNAL]  Get function input(s) and output(s)
63193 
63194 ";
63195 
63196 %feature("docstring")
63197 casadi::OracleFunction::serialize_body(SerializingStream &s) const  "
63198 
63199 [INTERNAL]  Serialize an object without type information.
63200 
63201 ";
63202 
63203 %feature("docstring")  casadi::FunctionInternal::check_mat(const Sparsity
63204 &arg, const Sparsity &inp, casadi_int &npar) "
63205 
63206 [INTERNAL]  Helper function
63207 
63208 Parameters:
63209 -----------
63210 
63211 npar[in]:  normal usage: 1, disallow pararallel calls: -1
63212 
63213 npar[out]:  required number of parallel calls (or -1)
63214 
63215 ";
63216 
63217 %feature("docstring")  casadi::FunctionInternal::ad_weight() const  "
63218 
63219 [INTERNAL]  Weighting factor for chosing forward/reverse mode.
63220 
63221 ";
63222 
63223 %feature("docstring")  casadi::FunctionInternal::get_default_in(casadi_int
63224 ind) const  "
63225 
63226 [INTERNAL]  Get default input value.
63227 
63228 ";
63229 
63230 %feature("docstring")  casadi::SharedObjectInternal::weak() "
63231 
63232 [INTERNAL]  Get a weak reference to the object.
63233 
63234 ";
63235 
63236 %feature("docstring")  casadi::FunctionInternal::get_max_in(casadi_int ind)
63237 const  "
63238 
63239 [INTERNAL]  Get largest input value.
63240 
63241 ";
63242 
63243 %feature("docstring")  casadi::FunctionInternal::numel_in() const  "
63244 
63245 [INTERNAL]  Number of input/output elements.
63246 
63247 ";
63248 
63249 %feature("docstring")  casadi::FunctionInternal::numel_in(casadi_int ind)
63250 const  "
63251 
63252 [INTERNAL]  Number of input/output elements.
63253 
63254 ";
63255 
63256 %feature("docstring")  casadi::FunctionInternal::slice(const std::string
63257 &name, const std::vector< casadi_int > &order_in, const std::vector<
63258 casadi_int > &order_out, const Dict &opts) const  "
63259 
63260 [INTERNAL]  returns a new function with a selection of inputs/outputs of the
63261 original
63262 
63263 ";
63264 
63265 %feature("docstring")  casadi::OracleFunction::generate_dependencies(const
63266 std::string &fname, const Dict &opts) const  "
63267 
63268 [INTERNAL]  Export / Generate C code for the generated functions.
63269 
63270 ";
63271 
63272 %feature("docstring")  casadi::FunctionInternal::free_sx() const  "
63273 
63274 [INTERNAL]  Get free variables (SX)
63275 
63276 ";
63277 
63278 %feature("docstring")
63279 casadi::FunctionInternal::codegen_decref(CodeGenerator &g) const  "
63280 
63281 [INTERNAL]  Codegen decref for dependencies.
63282 
63283 ";
63284 
63285 %feature("docstring")  casadi::OracleFunction::set_temp(void *mem, const
63286 double **arg, double **res, casadi_int *iw, double *w) const  "
63287 
63288 [INTERNAL]  Set the work vectors.
63289 
63290 ";
63291 
63292 %feature("docstring")  casadi::ProtoFunction::serialize_base_function()
63293 const  "
63294 
63295 [INTERNAL]  String used to identify the immediate FunctionInternal subclass.
63296 
63297 ";
63298 
63299 %feature("docstring")  casadi::OracleFunction::calc_function(OracleMemory
63300 *m, const std::string &fcn, const double *const *arg=nullptr) const  "
63301 
63302 [INTERNAL] ";
63303 
63304 %feature("docstring")  casadi::FunctionInternal::get_min_in(casadi_int ind)
63305 const  "
63306 
63307 [INTERNAL]  Get smallest input value.
63308 
63309 ";
63310 
63311 %feature("docstring")  casadi::FunctionInternal::mx_in(casadi_int ind) const
63312 "
63313 
63314 [INTERNAL]  Get function input(s) and output(s)
63315 
63316 ";
63317 
63318 %feature("docstring")  casadi::FunctionInternal::mx_in() const  "
63319 
63320 [INTERNAL]  Get function input(s) and output(s)
63321 
63322 ";
63323 
63324 %feature("docstring")  casadi::FunctionInternal::alloc_w(size_t sz_w, bool
63325 persistent=false) "
63326 
63327 [INTERNAL]  Ensure required length of w field.
63328 
63329 ";
63330 
63331 %feature("docstring")  casadi::FunctionInternal::get_forward(casadi_int
63332 nfwd, const std::string &name, const std::vector< std::string > &inames,
63333 const std::vector< std::string > &onames, const Dict &opts) const  "
63334 
63335 [INTERNAL]  Return function that calculates forward derivatives
63336 forward(nfwd) returns a cached instance if available, and calls  Function
63337 get_forward(casadi_int nfwd) if no cached version is available.
63338 
63339 ";
63340 
63341 %feature("docstring")  casadi::FunctionInternal::jac() const  "
63342 
63343 [INTERNAL]  Return Jacobian of all input elements with respect to all output
63344 elements.
63345 
63346 ";
63347 
63348 %feature("docstring")  casadi::FunctionInternal::size1_in(casadi_int ind)
63349 const  "
63350 
63351 [INTERNAL]  Input/output dimensions.
63352 
63353 ";
63354 
63355 %feature("docstring")  casadi::FunctionInternal::sp_forward(const bvec_t
63356 **arg, bvec_t **res, casadi_int *iw, bvec_t *w, void *mem) const  "
63357 
63358 [INTERNAL]  Propagate sparsity forward.
63359 
63360 ";
63361 
63362 %feature("docstring")  casadi::FunctionInternal::matching_res(const
63363 std::vector< M > &arg, casadi_int &npar) const  "
63364 
63365 [INTERNAL]  Check if output arguments that needs to be replaced.
63366 
63367 Raises errors
63368 
63369 Parameters:
63370 -----------
63371 
63372 npar[in]:  normal usage: 1, disallow pararallel calls: -1
63373 
63374 npar:  max number of horizontal repetitions across all arguments (or -1)
63375 
63376 ";
63377 
63378 %feature("docstring")  casadi::FunctionInternal::sparsity_jac(casadi_int
63379 iind, casadi_int oind, bool compact, bool symmetric) const  "
63380 
63381 [INTERNAL]  Get, if necessary generate, the sparsity of a Jacobian block.
63382 
63383 ";
63384 
63385 %feature("docstring")  casadi::FunctionInternal::instruction_id(casadi_int
63386 k) const  "
63387 
63388 [INTERNAL]  Get an atomic operation operator index.
63389 
63390 ";
63391 
63392 %feature("docstring")  casadi::OracleFunction::finalize()  "
63393 
63394 [INTERNAL]  Finalize initialization.
63395 
63396 ";
63397 
63398 %feature("docstring")  casadi::FunctionInternal::wrap() const  "
63399 
63400 [INTERNAL]  Wrap in an Function instance consisting of only one MX call.
63401 
63402 ";
63403 
63404 %feature("docstring")  casadi::FunctionInternal::print_option(const
63405 std::string &name, std::ostream &stream) const  "
63406 
63407 [INTERNAL]  Print all information there is to know about a certain option.
63408 
63409 ";
63410 
63411 %feature("docstring")  casadi::FunctionInternal::numel_out(casadi_int ind)
63412 const  "
63413 
63414 [INTERNAL]  Number of input/output elements.
63415 
63416 ";
63417 
63418 %feature("docstring")  casadi::FunctionInternal::numel_out() const  "
63419 
63420 [INTERNAL]  Number of input/output elements.
63421 
63422 ";
63423 
63424 %feature("docstring")  casadi::OracleFunction::monitored(const std::string
63425 &name) const  "
63426 
63427 [INTERNAL] ";
63428 
63429 %feature("docstring")  casadi::ProtoFunction::memory(int ind) const  "
63430 
63431 [INTERNAL]  Memory objects.
63432 
63433 ";
63434 
63435 %feature("docstring")
63436 casadi::FunctionInternal::codegen_alloc_mem(CodeGenerator &g) const  "
63437 
63438 [INTERNAL]  Codegen decref for alloc_mem.
63439 
63440 ";
63441 
63442 %feature("docstring")  casadi::FunctionInternal::instructions_sx() const  "
63443 
63444 [INTERNAL]  get SX expression associated with instructions
63445 
63446 ";
63447 
63448 %feature("docstring")  casadi::FunctionInternal::call(const std::vector< M >
63449 &arg, std::vector< M > &res, bool always_inline, bool never_inline) const  "
63450 
63451 [INTERNAL]   Call a function, templated.
63452 
63453 ";
63454 
63455 %feature("docstring") casadi::OracleFunction "
63456 
63457 [INTERNAL]  Base class for functions that perform calculation with an
63458 oracle.
63459 
63460 Joel Andersson
63461 
63462 >List of available options
63463 
63464 +------------------+-----------------+------------------+------------------+
63465 |        Id        |      Type       |   Description    |     Used in      |
63466 +==================+=================+==================+==================+
63467 | ad_weight        | OT_DOUBLE       | Weighting factor | casadi::Function |
63468 |                  |                 | for derivative   | Internal         |
63469 |                  |                 | calculation.When |                  |
63470 |                  |                 | there is an      |                  |
63471 |                  |                 | option of either |                  |
63472 |                  |                 | using forward or |                  |
63473 |                  |                 | reverse mode     |                  |
63474 |                  |                 | directional      |                  |
63475 |                  |                 | derivatives, the |                  |
63476 |                  |                 | condition ad_wei |                  |
63477 |                  |                 | ght*nf<=(1-ad_we |                  |
63478 |                  |                 | ight)*na is used |                  |
63479 |                  |                 | where nf and na  |                  |
63480 |                  |                 | are estimates of |                  |
63481 |                  |                 | the number of    |                  |
63482 |                  |                 | forward/reverse  |                  |
63483 |                  |                 | mode directional |                  |
63484 |                  |                 | derivatives      |                  |
63485 |                  |                 | needed. By       |                  |
63486 |                  |                 | default,         |                  |
63487 |                  |                 | ad_weight is     |                  |
63488 |                  |                 | calculated       |                  |
63489 |                  |                 | automatically,   |                  |
63490 |                  |                 | but this can be  |                  |
63491 |                  |                 | overridden by    |                  |
63492 |                  |                 | setting this     |                  |
63493 |                  |                 | option. In       |                  |
63494 |                  |                 | particular, 0    |                  |
63495 |                  |                 | means forcing    |                  |
63496 |                  |                 | forward mode and |                  |
63497 |                  |                 | 1 forcing        |                  |
63498 |                  |                 | reverse mode.    |                  |
63499 |                  |                 | Leave unset for  |                  |
63500 |                  |                 | (class specific) |                  |
63501 |                  |                 | heuristics.      |                  |
63502 +------------------+-----------------+------------------+------------------+
63503 | ad_weight_sp     | OT_DOUBLE       | Weighting factor | casadi::Function |
63504 |                  |                 | for sparsity     | Internal         |
63505 |                  |                 | pattern          |                  |
63506 |                  |                 | calculation calc |                  |
63507 |                  |                 | ulation.Override |                  |
63508 |                  |                 | s default        |                  |
63509 |                  |                 | behavior. Set to |                  |
63510 |                  |                 | 0 and 1 to force |                  |
63511 |                  |                 | forward and      |                  |
63512 |                  |                 | reverse mode     |                  |
63513 |                  |                 | respectively.    |                  |
63514 |                  |                 | Cf. option       |                  |
63515 |                  |                 | \"ad_weight\".     |                  |
63516 |                  |                 | When set to -1,  |                  |
63517 |                  |                 | sparsity is      |                  |
63518 |                  |                 | completely       |                  |
63519 |                  |                 | ignored and      |                  |
63520 |                  |                 | dense matrices   |                  |
63521 |                  |                 | are used.        |                  |
63522 +------------------+-----------------+------------------+------------------+
63523 | always_inline    | OT_BOOL         | Force inlining.  | casadi::Function |
63524 |                  |                 |                  | Internal         |
63525 +------------------+-----------------+------------------+------------------+
63526 | common_options   | OT_DICT         | Options for      | casadi::OracleFu |
63527 |                  |                 | auto-generated   | nction           |
63528 |                  |                 | functions        |                  |
63529 +------------------+-----------------+------------------+------------------+
63530 | compiler         | OT_STRING       | Just-in-time     | casadi::Function |
63531 |                  |                 | compiler plugin  | Internal         |
63532 |                  |                 | to be used.      |                  |
63533 +------------------+-----------------+------------------+------------------+
63534 | custom_jacobian  | OT_FUNCTION     | Override         | casadi::Function |
63535 |                  |                 | CasADi's AD. Use | Internal         |
63536 |                  |                 | together with    |                  |
63537 |                  |                 | 'jac_penalty':   |                  |
63538 |                  |                 | 0. Note: Highly  |                  |
63539 |                  |                 | experimental.    |                  |
63540 |                  |                 | Syntax may break |                  |
63541 |                  |                 | often.           |                  |
63542 +------------------+-----------------+------------------+------------------+
63543 | derivative_of    | OT_FUNCTION     | The function is  | casadi::Function |
63544 |                  |                 | a derivative of  | Internal         |
63545 |                  |                 | another          |                  |
63546 |                  |                 | function. The    |                  |
63547 |                  |                 | type of          |                  |
63548 |                  |                 | derivative       |                  |
63549 |                  |                 | (directional     |                  |
63550 |                  |                 | derivative,      |                  |
63551 |                  |                 | Jacobian) is     |                  |
63552 |                  |                 | inferred from    |                  |
63553 |                  |                 | the function     |                  |
63554 |                  |                 | name.            |                  |
63555 +------------------+-----------------+------------------+------------------+
63556 | dump             | OT_BOOL         | Dump function to | casadi::Function |
63557 |                  |                 | file upon first  | Internal         |
63558 |                  |                 | evaluation.      |                  |
63559 |                  |                 | [false]          |                  |
63560 +------------------+-----------------+------------------+------------------+
63561 | dump_dir         | OT_STRING       | Directory to     | casadi::Function |
63562 |                  |                 | dump             | Internal         |
63563 |                  |                 | inputs/outputs   |                  |
63564 |                  |                 | to. Make sure    |                  |
63565 |                  |                 | the directory    |                  |
63566 |                  |                 | exists [.]       |                  |
63567 +------------------+-----------------+------------------+------------------+
63568 | dump_format      | OT_STRING       | Choose file      | casadi::Function |
63569 |                  |                 | format to dump   | Internal         |
63570 |                  |                 | matrices. See    |                  |
63571 |                  |                 | DM.from_file     |                  |
63572 |                  |                 | [mtx]            |                  |
63573 +------------------+-----------------+------------------+------------------+
63574 | dump_in          | OT_BOOL         | Dump numerical   | casadi::Function |
63575 |                  |                 | values of inputs | Internal         |
63576 |                  |                 | to file          |                  |
63577 |                  |                 | (readable with   |                  |
63578 |                  |                 | DM.from_file )   |                  |
63579 |                  |                 | [default: false] |                  |
63580 +------------------+-----------------+------------------+------------------+
63581 | dump_out         | OT_BOOL         | Dump numerical   | casadi::Function |
63582 |                  |                 | values of        | Internal         |
63583 |                  |                 | outputs to file  |                  |
63584 |                  |                 | (readable with   |                  |
63585 |                  |                 | DM.from_file )   |                  |
63586 |                  |                 | [default: false] |                  |
63587 +------------------+-----------------+------------------+------------------+
63588 | enable_fd        | OT_BOOL         | Enable           | casadi::Function |
63589 |                  |                 | derivative       | Internal         |
63590 |                  |                 | calculation by   |                  |
63591 |                  |                 | finite           |                  |
63592 |                  |                 | differencing.    |                  |
63593 |                  |                 | [default:        |                  |
63594 |                  |                 | false]]          |                  |
63595 +------------------+-----------------+------------------+------------------+
63596 | enable_forward   | OT_BOOL         | Enable           | casadi::Function |
63597 |                  |                 | derivative       | Internal         |
63598 |                  |                 | calculation      |                  |
63599 |                  |                 | using generated  |                  |
63600 |                  |                 | functions for    |                  |
63601 |                  |                 | Jacobian-times-  |                  |
63602 |                  |                 | vector products  |                  |
63603 |                  |                 | - typically      |                  |
63604 |                  |                 | using forward    |                  |
63605 |                  |                 | mode AD - if     |                  |
63606 |                  |                 | available.       |                  |
63607 |                  |                 | [default: true]  |                  |
63608 +------------------+-----------------+------------------+------------------+
63609 | enable_jacobian  | OT_BOOL         | Enable           | casadi::Function |
63610 |                  |                 | derivative       | Internal         |
63611 |                  |                 | calculation      |                  |
63612 |                  |                 | using generated  |                  |
63613 |                  |                 | functions for    |                  |
63614 |                  |                 | Jacobians of all |                  |
63615 |                  |                 | differentiable   |                  |
63616 |                  |                 | outputs with     |                  |
63617 |                  |                 | respect to all   |                  |
63618 |                  |                 | differentiable   |                  |
63619 |                  |                 | inputs - if      |                  |
63620 |                  |                 | available.       |                  |
63621 |                  |                 | [default: true]  |                  |
63622 +------------------+-----------------+------------------+------------------+
63623 | enable_reverse   | OT_BOOL         | Enable           | casadi::Function |
63624 |                  |                 | derivative       | Internal         |
63625 |                  |                 | calculation      |                  |
63626 |                  |                 | using generated  |                  |
63627 |                  |                 | functions for    |                  |
63628 |                  |                 | transposed       |                  |
63629 |                  |                 | Jacobian-times-  |                  |
63630 |                  |                 | vector products  |                  |
63631 |                  |                 | - typically      |                  |
63632 |                  |                 | using reverse    |                  |
63633 |                  |                 | mode AD - if     |                  |
63634 |                  |                 | available.       |                  |
63635 |                  |                 | [default: true]  |                  |
63636 +------------------+-----------------+------------------+------------------+
63637 | expand           | OT_BOOL         | Replace MX with  | casadi::OracleFu |
63638 |                  |                 | SX expressions   | nction           |
63639 |                  |                 | in problem       |                  |
63640 |                  |                 | formulation      |                  |
63641 |                  |                 | [false]          |                  |
63642 +------------------+-----------------+------------------+------------------+
63643 | fd_method        | OT_STRING       | Method for       | casadi::Function |
63644 |                  |                 | finite           | Internal         |
63645 |                  |                 | differencing     |                  |
63646 |                  |                 | [default         |                  |
63647 |                  |                 | 'central']       |                  |
63648 +------------------+-----------------+------------------+------------------+
63649 | fd_options       | OT_DICT         | Options to be    | casadi::Function |
63650 |                  |                 | passed to the    | Internal         |
63651 |                  |                 | finite           |                  |
63652 |                  |                 | difference       |                  |
63653 |                  |                 | instance         |                  |
63654 +------------------+-----------------+------------------+------------------+
63655 | forward_options  | OT_DICT         | Options to be    | casadi::Function |
63656 |                  |                 | passed to a      | Internal         |
63657 |                  |                 | forward mode     |                  |
63658 |                  |                 | constructor      |                  |
63659 +------------------+-----------------+------------------+------------------+
63660 | gather_stats     | OT_BOOL         | Deprecated       | casadi::Function |
63661 |                  |                 | option           | Internal         |
63662 |                  |                 | (ignored):       |                  |
63663 |                  |                 | Statistics are   |                  |
63664 |                  |                 | now always       |                  |
63665 |                  |                 | collected.       |                  |
63666 +------------------+-----------------+------------------+------------------+
63667 | input_scheme     | OT_STRINGVECTOR | Deprecated       | casadi::Function |
63668 |                  |                 | option (ignored) | Internal         |
63669 +------------------+-----------------+------------------+------------------+
63670 | inputs_check     | OT_BOOL         | Throw exceptions | casadi::Function |
63671 |                  |                 | when the         | Internal         |
63672 |                  |                 | numerical values |                  |
63673 |                  |                 | of the inputs    |                  |
63674 |                  |                 | don't make sense |                  |
63675 +------------------+-----------------+------------------+------------------+
63676 | is_diff_in       | OT_BOOLVECTOR   | Indicate for     | casadi::Function |
63677 |                  |                 | each input if it | Internal         |
63678 |                  |                 | should be        |                  |
63679 |                  |                 | differentiable.  |                  |
63680 +------------------+-----------------+------------------+------------------+
63681 | is_diff_out      | OT_BOOLVECTOR   | Indicate for     | casadi::Function |
63682 |                  |                 | each output if   | Internal         |
63683 |                  |                 | it should be     |                  |
63684 |                  |                 | differentiable.  |                  |
63685 +------------------+-----------------+------------------+------------------+
63686 | jac_penalty      | OT_DOUBLE       | When requested   | casadi::Function |
63687 |                  |                 | for a number of  | Internal         |
63688 |                  |                 | forward/reverse  |                  |
63689 |                  |                 | directions, it   |                  |
63690 |                  |                 | may be cheaper   |                  |
63691 |                  |                 | to compute first |                  |
63692 |                  |                 | the full         |                  |
63693 |                  |                 | jacobian and     |                  |
63694 |                  |                 | then multiply    |                  |
63695 |                  |                 | with seeds,      |                  |
63696 |                  |                 | rather than      |                  |
63697 |                  |                 | obtain the       |                  |
63698 |                  |                 | requested        |                  |
63699 |                  |                 | directions in a  |                  |
63700 |                  |                 | straightforward  |                  |
63701 |                  |                 | manner. Casadi   |                  |
63702 |                  |                 | uses a heuristic |                  |
63703 |                  |                 | to decide which  |                  |
63704 |                  |                 | is cheaper. A    |                  |
63705 |                  |                 | high value of    |                  |
63706 |                  |                 | 'jac_penalty'    |                  |
63707 |                  |                 | makes it less    |                  |
63708 |                  |                 | likely for the   |                  |
63709 |                  |                 | heurstic to      |                  |
63710 |                  |                 | chose the full   |                  |
63711 |                  |                 | Jacobian         |                  |
63712 |                  |                 | strategy. The    |                  |
63713 |                  |                 | special value -1 |                  |
63714 |                  |                 | indicates never  |                  |
63715 |                  |                 | to use the full  |                  |
63716 |                  |                 | Jacobian         |                  |
63717 |                  |                 | strategy         |                  |
63718 +------------------+-----------------+------------------+------------------+
63719 | jit              | OT_BOOL         | Use just-in-time | casadi::Function |
63720 |                  |                 | compiler to      | Internal         |
63721 |                  |                 | speed up the     |                  |
63722 |                  |                 | evaluation       |                  |
63723 +------------------+-----------------+------------------+------------------+
63724 | jit_cleanup      | OT_BOOL         | Cleanup up the   | casadi::Function |
63725 |                  |                 | temporary source | Internal         |
63726 |                  |                 | file that jit    |                  |
63727 |                  |                 | creates.         |                  |
63728 |                  |                 | Default: true    |                  |
63729 +------------------+-----------------+------------------+------------------+
63730 | jit_name         | OT_STRING       | The file name    | casadi::Function |
63731 |                  |                 | used to write    | Internal         |
63732 |                  |                 | out code. The    |                  |
63733 |                  |                 | actual file      |                  |
63734 |                  |                 | names used       |                  |
63735 |                  |                 | depend on 'jit_t |                  |
63736 |                  |                 | emp_suffix' and  |                  |
63737 |                  |                 | include          |                  |
63738 |                  |                 | extensions.      |                  |
63739 |                  |                 | Default:         |                  |
63740 |                  |                 | 'jit_tmp'        |                  |
63741 +------------------+-----------------+------------------+------------------+
63742 | jit_options      | OT_DICT         | Options to be    | casadi::Function |
63743 |                  |                 | passed to the    | Internal         |
63744 |                  |                 | jit compiler.    |                  |
63745 +------------------+-----------------+------------------+------------------+
63746 | jit_serialize    | OT_STRING       | Specify          | casadi::Function |
63747 |                  |                 | behaviour when   | Internal         |
63748 |                  |                 | serializing a    |                  |
63749 |                  |                 | jitted function: |                  |
63750 |                  |                 | SOURCE|link|embe |                  |
63751 |                  |                 | d.               |                  |
63752 +------------------+-----------------+------------------+------------------+
63753 | jit_temp_suffix  | OT_BOOL         | Use a temporary  | casadi::Function |
63754 |                  |                 | (seemingly       | Internal         |
63755 |                  |                 | random) filename |                  |
63756 |                  |                 | suffix for       |                  |
63757 |                  |                 | generated code   |                  |
63758 |                  |                 | and libraries.   |                  |
63759 |                  |                 | This is desired  |                  |
63760 |                  |                 | for thread-      |                  |
63761 |                  |                 | safety. This     |                  |
63762 |                  |                 | behaviour may    |                  |
63763 |                  |                 | defeat caching   |                  |
63764 |                  |                 | compiler         |                  |
63765 |                  |                 | wrappers.        |                  |
63766 |                  |                 | Default: true    |                  |
63767 +------------------+-----------------+------------------+------------------+
63768 | max_num_dir      | OT_INT          | Specify the      | casadi::Function |
63769 |                  |                 | maximum number   | Internal         |
63770 |                  |                 | of directions    |                  |
63771 |                  |                 | for derivative   |                  |
63772 |                  |                 | functions.       |                  |
63773 |                  |                 | Overrules the    |                  |
63774 |                  |                 | builtin optimize |                  |
63775 |                  |                 | d_num_dir.       |                  |
63776 +------------------+-----------------+------------------+------------------+
63777 | monitor          | OT_STRINGVECTOR | Set of user      | casadi::OracleFu |
63778 |                  |                 | problem          | nction           |
63779 |                  |                 | functions to be  |                  |
63780 |                  |                 | monitored        |                  |
63781 +------------------+-----------------+------------------+------------------+
63782 | never_inline     | OT_BOOL         | Forbid inlining. | casadi::Function |
63783 |                  |                 |                  | Internal         |
63784 +------------------+-----------------+------------------+------------------+
63785 | output_scheme    | OT_STRINGVECTOR | Deprecated       | casadi::Function |
63786 |                  |                 | option (ignored) | Internal         |
63787 +------------------+-----------------+------------------+------------------+
63788 | print_in         | OT_BOOL         | Print numerical  | casadi::Function |
63789 |                  |                 | values of inputs | Internal         |
63790 |                  |                 | [default: false] |                  |
63791 +------------------+-----------------+------------------+------------------+
63792 | print_out        | OT_BOOL         | Print numerical  | casadi::Function |
63793 |                  |                 | values of        | Internal         |
63794 |                  |                 | outputs          |                  |
63795 |                  |                 | [default: false] |                  |
63796 +------------------+-----------------+------------------+------------------+
63797 | print_time       | OT_BOOL         | print            | casadi::Function |
63798 |                  |                 | information      | Internal         |
63799 |                  |                 | about execution  |                  |
63800 |                  |                 | time. Implies    |                  |
63801 |                  |                 | record_time.     |                  |
63802 +------------------+-----------------+------------------+------------------+
63803 | record_time      | OT_BOOL         | record           | casadi::Function |
63804 |                  |                 | information      | Internal         |
63805 |                  |                 | about execution  |                  |
63806 |                  |                 | time, for        |                  |
63807 |                  |                 | retrieval with   |                  |
63808 |                  |                 | stats().         |                  |
63809 +------------------+-----------------+------------------+------------------+
63810 | regularity_check | OT_BOOL         | Throw exceptions | casadi::Function |
63811 |                  |                 | when NaN or Inf  | Internal         |
63812 |                  |                 | appears during   |                  |
63813 |                  |                 | evaluation       |                  |
63814 +------------------+-----------------+------------------+------------------+
63815 | reverse_options  | OT_DICT         | Options to be    | casadi::Function |
63816 |                  |                 | passed to a      | Internal         |
63817 |                  |                 | reverse mode     |                  |
63818 |                  |                 | constructor      |                  |
63819 +------------------+-----------------+------------------+------------------+
63820 | show_eval_warnin | OT_BOOL         | Show warnings    | casadi::OracleFu |
63821 | gs               |                 | generated from   | nction           |
63822 |                  |                 | function         |                  |
63823 |                  |                 | evaluations      |                  |
63824 |                  |                 | [true]           |                  |
63825 +------------------+-----------------+------------------+------------------+
63826 | specific_options | OT_DICT         | Options for      | casadi::OracleFu |
63827 |                  |                 | specific auto-   | nction           |
63828 |                  |                 | generated        |                  |
63829 |                  |                 | functions,       |                  |
63830 |                  |                 | overwriting the  |                  |
63831 |                  |                 | defaults from    |                  |
63832 |                  |                 | common_options.  |                  |
63833 |                  |                 | Nested           |                  |
63834 |                  |                 | dictionary.      |                  |
63835 +------------------+-----------------+------------------+------------------+
63836 | user_data        | OT_VOIDPTR      | A user-defined   | casadi::Function |
63837 |                  |                 | field that can   | Internal         |
63838 |                  |                 | be used to       |                  |
63839 |                  |                 | identify the     |                  |
63840 |                  |                 | function or pass |                  |
63841 |                  |                 | additional       |                  |
63842 |                  |                 | information      |                  |
63843 +------------------+-----------------+------------------+------------------+
63844 | verbose          | OT_BOOL         | Verbose          | casadi::Function |
63845 |                  |                 | evaluation  for  | Internal         |
63846 |                  |                 | debugging        |                  |
63847 +------------------+-----------------+------------------+------------------+
63848 
63849 Diagrams
63850 --------
63851 
63852 
63853 
63854 C++ includes: oracle_function.hpp ";
63855 
63856 %feature("docstring")  casadi::OracleFunction::set_function(const Function
63857 &fcn, const std::string &fname, bool jit=false) "
63858 
63859 [INTERNAL]  Register the function for evaluation and statistics gathering
63860 
63861 ";
63862 
63863 %feature("docstring")  casadi::OracleFunction::set_function(const Function
63864 &fcn) "
63865 
63866 [INTERNAL]  Register the function for evaluation and statistics gathering
63867 
63868 ";
63869 
63870 %feature("docstring")  casadi::FunctionInternal::get_free() const  "
63871 
63872 [INTERNAL]  Print free variables.
63873 
63874 ";
63875 
63876 %feature("docstring")  casadi::FunctionInternal::disp(std::ostream &stream,
63877 bool more) const  "
63878 
63879 [INTERNAL]  Display object.
63880 
63881 ";
63882 
63883 %feature("docstring")  casadi::FunctionInternal::nnz_out() const  "
63884 
63885 [INTERNAL]  Number of input/output nonzeros.
63886 
63887 ";
63888 
63889 %feature("docstring")  casadi::FunctionInternal::nnz_out(casadi_int ind)
63890 const  "
63891 
63892 [INTERNAL]  Number of input/output nonzeros.
63893 
63894 ";
63895 
63896 %feature("docstring")  casadi::FunctionInternal::sx_in(casadi_int ind) const
63897 "
63898 
63899 [INTERNAL]  Get function input(s) and output(s)
63900 
63901 ";
63902 
63903 %feature("docstring")  casadi::FunctionInternal::sx_in() const  "
63904 
63905 [INTERNAL]  Get function input(s) and output(s)
63906 
63907 ";
63908 
63909 %feature("docstring")  casadi::FunctionInternal::generate_lifted(Function
63910 &vdef_fcn, Function &vinit_fcn) const  "
63911 
63912 [INTERNAL]  Extract the functions needed for the Lifted Newton method.
63913 
63914 ";
63915 
63916 %feature("docstring")  casadi::FunctionInternal::which_depends(const
63917 std::string &s_in, const std::vector< std::string > &s_out, casadi_int
63918 order, bool tr=false) const  "
63919 
63920 [INTERNAL]  Which variables enter with some order.
63921 
63922 Parameters:
63923 -----------
63924 
63925 s_in:   Input name
63926 
63927 s_out:   Output name(s)
63928 
63929 order:  Only 1 (linear) and 2 (nonlinear) allowed
63930 
63931 tr:  Flip the relationship. Return which expressions contain the variables
63932 
63933 ";
63934 
63935 %feature("docstring")  casadi::FunctionInternal::generate_options(bool
63936 is_temp=false) const  "
63937 
63938 [INTERNAL]  Reconstruct options dict.
63939 
63940 ";
63941 
63942 %feature("docstring")  casadi::FunctionInternal::jacobian_sparsity() const
63943 "
63944 
63945 [INTERNAL]  Get Jacobian sparsity.
63946 
63947 ";
63948 
63949 %feature("docstring")  casadi::FunctionInternal::size1_out(casadi_int ind)
63950 const  "
63951 
63952 [INTERNAL]  Input/output dimensions.
63953 
63954 ";
63955 
63956 %feature("docstring")  casadi::FunctionInternal::eval_gen(const double
63957 **arg, double **res, casadi_int *iw, double *w, void *mem) const  "
63958 
63959 [INTERNAL]  Evaluate numerically.
63960 
63961 ";
63962 
63963 %feature("docstring")  casadi::FunctionInternal::eval_gen(const SXElem
63964 **arg, SXElem **res, casadi_int *iw, SXElem *w, void *mem) const  "
63965 
63966 [INTERNAL]  Evaluate a function, overloaded.
63967 
63968 ";
63969 
63970 %feature("docstring")  casadi::FunctionInternal::eval_gen(const bvec_t
63971 **arg, bvec_t **res, casadi_int *iw, bvec_t *w, void *mem) const  "
63972 
63973 [INTERNAL]  Evaluate a function, overloaded.
63974 
63975 ";
63976 
63977 %feature("docstring")  casadi::FunctionInternal::has_spfwd() const  "
63978 
63979 [INTERNAL]  Is the class able to propagate seeds through the algorithm?
63980 
63981 ";
63982 
63983 %feature("docstring")
63984 casadi::FunctionInternal::getJacSparsityGen(casadi_int iind, casadi_int
63985 oind, bool symmetric, casadi_int gr_i=1, casadi_int gr_o=1) const  "
63986 
63987 [INTERNAL]  Get the sparsity pattern, forward mode.
63988 
63989 ";
63990 
63991 %feature("docstring")  casadi::FunctionInternal::sp_weight() const  "
63992 
63993 [INTERNAL]  Weighting factor for chosing forward/reverse mode, sparsity
63994 propagation.
63995 
63996 ";
63997 
63998 %feature("docstring")  casadi::FunctionInternal::adjViaJac(casadi_int nadj)
63999 const  "
64000 
64001 [INTERNAL]  Calculate derivatives by multiplying the full Jacobian and
64002 multiplying.
64003 
64004 ";
64005 
64006 %feature("docstring")
64007 casadi::FunctionInternal::jacobian_sparsity_filter(const Sparsity &sp) const
64008 "
64009 
64010 [INTERNAL]  Filter out nonzeros in the full sparsity jacobian according to
64011 is_diff_in/out.
64012 
64013 ";
64014 
64015 %feature("docstring")  casadi::FunctionInternal::is_diff_in(casadi_int i) "
64016 
64017 [INTERNAL] ";
64018 
64019 %feature("docstring")  casadi::FunctionInternal::matching_arg(const
64020 std::vector< M > &arg, casadi_int &npar) const  "
64021 
64022 [INTERNAL]  Check if input arguments that needs to be replaced.
64023 
64024 Raises errors
64025 
64026 Parameters:
64027 -----------
64028 
64029 npar[in]:  normal usage: 1, disallow pararallel calls: -1
64030 
64031 npar:  max number of horizontal repetitions across all arguments (or -1)
64032 
64033 ";
64034 
64035 %feature("docstring")  casadi::OracleFunction::init(const Dict &opts)  "
64036 
64037 [INTERNAL]  Initialize
64038 
64039 ";
64040 
64041 %feature("docstring")  casadi::OracleFunction::free_mem(void *mem) const  "
64042 
64043 [INTERNAL]  Free memory block.
64044 
64045 ";
64046 
64047 %feature("docstring")  casadi::FunctionInternal::jacobian() const  "
64048 
64049 [INTERNAL]  Return Jacobian of all input elements with respect to all output
64050 elements.
64051 
64052 ";
64053 
64054 %feature("docstring")  casadi::FunctionInternal::eval_sx(const SXElem **arg,
64055 SXElem **res, casadi_int *iw, SXElem *w, void *mem) const  "
64056 
64057 [INTERNAL]  Evaluate with symbolic scalars.
64058 
64059 ";
64060 
64061 %feature("docstring")  casadi::FunctionInternal::replace_fseed(const
64062 std::vector< std::vector< M >> &fseed, casadi_int npar) const  "
64063 
64064 [INTERNAL]  Replace 0-by-0 forward seeds.
64065 
64066 ";
64067 
64068 %feature("docstring")  casadi::FunctionInternal::replace_fseed(const
64069 std::vector< std::vector< M > > &fseed, casadi_int npar) const  "
64070 
64071 [INTERNAL] ";
64072 
64073 %feature("docstring")  casadi::SharedObjectInternal::getCount() const  "
64074 
64075 [INTERNAL]  Get the reference count.
64076 
64077 ";
64078 
64079 %feature("docstring")  casadi::FunctionInternal::mx_out(casadi_int ind)
64080 const  "
64081 
64082 [INTERNAL]  Get function input(s) and output(s)
64083 
64084 ";
64085 
64086 %feature("docstring")  casadi::FunctionInternal::mx_out() const  "
64087 
64088 [INTERNAL]  Get function input(s) and output(s)
64089 
64090 ";
64091 
64092 %feature("docstring")  casadi::FunctionInternal::get_reltol() const  "
64093 
64094 [INTERNAL]  Get relative tolerance.
64095 
64096 ";
64097 
64098 %feature("docstring")  casadi::FunctionInternal::sz_work(size_t &sz_arg,
64099 size_t &sz_res, size_t &sz_iw, size_t &sz_w) const  "
64100 
64101 [INTERNAL]  Get number of temporary variables needed.
64102 
64103 ";
64104 
64105 %feature("docstring")  casadi::FunctionInternal::sz_arg() const  "
64106 
64107 [INTERNAL]  Get required length of arg field.
64108 
64109 ";
64110 
64111 %feature("docstring")  casadi::FunctionInternal::nnz_in() const  "
64112 
64113 [INTERNAL]  Number of input/output nonzeros.
64114 
64115 ";
64116 
64117 %feature("docstring")  casadi::FunctionInternal::nnz_in(casadi_int ind)
64118 const  "
64119 
64120 [INTERNAL]  Number of input/output nonzeros.
64121 
64122 ";
64123 
64124 %feature("docstring")  casadi::FunctionInternal::eval_dm(const std::vector<
64125 DM > &arg) const  "
64126 
64127 [INTERNAL]  Evaluate with DM matrices.
64128 
64129 ";
64130 
64131 %feature("docstring")  casadi::FunctionInternal::get_n_out() "
64132 
64133 [INTERNAL]  Are all inputs and outputs scalar.
64134 
64135 ";
64136 
64137 %feature("docstring")  casadi::ProtoFunction::checkout() const  "
64138 
64139 [INTERNAL]  Checkout a memory object.
64140 
64141 ";
64142 
64143 %feature("docstring")  casadi::FunctionInternal::disp_more(std::ostream
64144 &stream) const  "
64145 
64146 [INTERNAL]  Print more.
64147 
64148 ";
64149 
64150 %feature("docstring")
64151 casadi::FunctionInternal::serialize_type(SerializingStream &s) const  "
64152 
64153 [INTERNAL]  Serialize type information.
64154 
64155 ";
64156 
64157 %feature("docstring")  casadi::FunctionInternal::uses_output() const  "
64158 
64159 [INTERNAL]  Do the derivative functions need nondifferentiated outputs?
64160 
64161 ";
64162 
64163 %feature("docstring")  casadi::OracleFunction::jit_dependencies(const
64164 std::string &fname)  "
64165 
64166 [INTERNAL]  JIT for dependencies.
64167 
64168 ";
64169 
64170 %feature("docstring")  casadi::FunctionInternal::get_name_in(casadi_int i) "
64171 
64172 [INTERNAL]  Names of function input and outputs.
64173 
64174 ";
64175 
64176 %feature("docstring")  casadi::FunctionInternal::alloc(const Function &f,
64177 bool persistent=false) "
64178 
64179 [INTERNAL]  Ensure work vectors long enough to evaluate function.
64180 
64181 ";
64182 
64183 %feature("docstring")  casadi::ProtoFunction::serialize(SerializingStream
64184 &s) const  "
64185 
64186 [INTERNAL]  Serialize an object.
64187 
64188 ";
64189 
64190 %feature("docstring")  casadi::FunctionInternal::signature(const std::string
64191 &fname) const  "
64192 
64193 [INTERNAL]  Code generate the function.
64194 
64195 ";
64196 
64197 %feature("docstring")
64198 casadi::FunctionInternal::print_dimensions(std::ostream &stream) const  "
64199 
64200 [INTERNAL]  Print dimensions of inputs and outputs.
64201 
64202 ";
64203 
64204 %feature("docstring")  casadi::FunctionInternal::self() const  "
64205 
64206 [INTERNAL]  Get a public class instance.
64207 
64208 ";
64209 
64210 %feature("docstring")  casadi::FunctionInternal::replace_arg(const
64211 std::vector< M > &arg, casadi_int npar) const  "
64212 
64213 [INTERNAL]  Replace 0-by-0 inputs.
64214 
64215 ";
64216 
64217 %feature("docstring")  casadi::OracleFunction::init_mem(void *mem) const  "
64218 
64219 [INTERNAL]  Initalize memory block.
64220 
64221 ";
64222 
64223 %feature("docstring")
64224 casadi::FunctionInternal::instruction_constant(casadi_int k) const  "
64225 
64226 [INTERNAL]  Get the floating point output argument of an atomic operation.
64227 
64228 ";
64229 
64230 %feature("docstring")  casadi::FunctionInternal::index_in(const std::string
64231 &name) const  "
64232 
64233 [INTERNAL]  Get input scheme index by name.
64234 
64235 ";
64236 
64237 %feature("docstring")  casadi::FunctionInternal::has_free() const  "
64238 
64239 [INTERNAL]  Does the function have free variables.
64240 
64241 ";
64242 
64243 %feature("docstring")
64244 casadi::FunctionInternal::getJacSparsityHierarchical(casadi_int iind,
64245 casadi_int oind) const  "
64246 
64247 [INTERNAL]  A flavor of getJacSparsity that does hierarchical block
64248 structure recognition.
64249 
64250 ";
64251 
64252 %feature("docstring")  casadi::FunctionInternal::check_arg(const
64253 std::vector< M > &arg, casadi_int &npar) const  "
64254 
64255 [INTERNAL]  Check if input arguments have correct length and dimensions.
64256 
64257 Raises errors.
64258 
64259 Parameters:
64260 -----------
64261 
64262 npar[in]:  normal usage: 1, disallow pararallel calls: -1
64263 
64264 npar:  max number of horizontal repetitions across all arguments (or -1)
64265 
64266 ";
64267 
64268 %feature("docstring")  casadi::FunctionInternal::has_jac() const  "
64269 
64270 [INTERNAL]  Return Jacobian of all input elements with respect to all output
64271 elements.
64272 
64273 ";
64274 
64275 %feature("docstring")  casadi::FunctionInternal::getAdaptorSolverName()
64276 const  "
64277 
64278 [INTERNAL]  Obtain solver name from Adaptor.
64279 
64280 ";
64281 
64282 %feature("docstring")  casadi::OracleFunction::alloc_mem() const  "
64283 
64284 [INTERNAL]  Create memory block.
64285 
64286 ";
64287 
64288 %feature("docstring") casadi::OracleFunction::OracleFunction(const
64289 std::string &name, const Function &oracle) "
64290 
64291 [INTERNAL]  Constructor.
64292 
64293 ";
64294 
64295 %feature("docstring")  casadi::FunctionInternal::fwd_seed(casadi_int nfwd)
64296 const  "
64297 
64298 [INTERNAL]  Symbolic expressions for the forward seeds.
64299 
64300 ";
64301 
64302 %feature("docstring")  casadi::FunctionInternal::call_gen(const MXVector
64303 &arg, MXVector &res, casadi_int npar, bool always_inline, bool never_inline)
64304 const  "
64305 
64306 [INTERNAL]   Call a function, overloaded.
64307 
64308 ";
64309 
64310 %feature("docstring")  casadi::FunctionInternal::call_gen(const std::vector<
64311 MatrixCommon > &arg, std::vector< MatrixCommon > &res, casadi_int npar, bool
64312 always_inline, bool never_inline) const  "
64313 
64314 [INTERNAL]   Call a function, overloaded.
64315 
64316 ";
64317 
64318 %feature("docstring")  casadi::FunctionInternal::project_res(const
64319 std::vector< M > &arg, casadi_int npar) const  "
64320 
64321 [INTERNAL]   Project sparsities.
64322 
64323 ";
64324 
64325 %feature("docstring")  casadi::FunctionInternal::is_diff_out(casadi_int i) "
64326 
64327 [INTERNAL] ";
64328 
64329 
64330 // File: classcasadi_1_1Output.xml
64331 
64332 
64333 // File: classcasadi_1_1Polynomial.xml
64334 %feature("docstring") casadi::Polynomial "
64335 
64336 Helper class for differentiating and integrating polynomials.
64337 
64338 Joel Andersson
64339 
64340 C++ includes: polynomial.hpp ";
64341 
64342 %feature("docstring")  casadi::Polynomial::derivative() const  "
64343 
64344 Create a new polynomial for the derivative.
64345 
64346 ";
64347 
64348 %feature("docstring") casadi::Polynomial::Polynomial(double scalar=1) "
64349 
64350 Construct a constant polynomial.
64351 
64352 ";
64353 
64354 %feature("docstring") casadi::Polynomial::Polynomial(double p0, double p1) "
64355 
64356 Construct a linear polynomial.
64357 
64358 ";
64359 
64360 %feature("docstring") casadi::Polynomial::Polynomial(double p0, double p1,
64361 double p2) "
64362 
64363 Construct a quadratic polynomial.
64364 
64365 ";
64366 
64367 %feature("docstring") casadi::Polynomial::Polynomial(double p0, double p1,
64368 double p2, double p3) "
64369 
64370 Construct a cubic polynomial.
64371 
64372 ";
64373 
64374 %feature("docstring") casadi::Polynomial::Polynomial(const std::vector< T >
64375 &coeff) "
64376 
64377 Construct from a vector of polynomial coefficients.
64378 
64379 ";
64380 
64381 %feature("docstring")  casadi::Polynomial::type_name() const  "
64382 
64383 Readable name of the class.
64384 
64385 ";
64386 
64387 %feature("docstring")  casadi::Polynomial::anti_derivative() const  "
64388 
64389 Create a new polynomial for the anti-derivative (primitive function)
64390 
64391 ";
64392 
64393 %feature("docstring")  casadi::Polynomial::scalar() const  "
64394 
64395 Get scalar value (error if degree()!=0)
64396 
64397 ";
64398 
64399 %feature("docstring")  casadi::Polynomial::degree() const  "
64400 
64401 Degree of the polynomial.
64402 
64403 ";
64404 
64405 %feature("docstring")  casadi::Polynomial::disp(std::ostream &stream, bool
64406 more=false) const  "
64407 
64408 Print a description of the object.
64409 
64410 ";
64411 
64412 %feature("docstring")  casadi::Polynomial::trim() "
64413 
64414 Remove excess zeros.
64415 
64416 ";
64417 
64418 
64419 // File: classcasadi_1_1Project.xml
64420 
64421 
64422 // File: classcasadi_1_1ProtoFunction.xml
64423 
64424 
64425 // File: classcasadi_1_1QpToNlp.xml
64426 %feature("docstring")  casadi::Conic::get_name_out(casadi_int i)  "
64427 
64428 [INTERNAL]  Names of function input and outputs.
64429 
64430 ";
64431 
64432 %feature("docstring")  casadi::FunctionInternal::sp_reverse(bvec_t **arg,
64433 bvec_t **res, casadi_int *iw, bvec_t *w, void *mem) const  "
64434 
64435 [INTERNAL]  Propagate sparsity backwards.
64436 
64437 ";
64438 
64439 %feature("docstring")  casadi::FunctionInternal::has_codegen() const  "
64440 
64441 [INTERNAL]  Is codegen supported?
64442 
64443 ";
64444 
64445 %feature("docstring")  casadi::FunctionInternal::convert_arg(const
64446 std::vector< M > &arg) const  "
64447 
64448 [INTERNAL]  Convert from/to input/output lists/map.
64449 
64450 ";
64451 
64452 %feature("docstring")  casadi::FunctionInternal::convert_arg(const std::map<
64453 std::string, M > &arg) const  "
64454 
64455 [INTERNAL]  Convert from/to input/output lists/map.
64456 
64457 ";
64458 
64459 %feature("docstring")  casadi::FunctionInternal::info() const  "
64460 
64461 [INTERNAL]  Obtain information about function
64462 
64463 ";
64464 
64465 %feature("docstring")  casadi::FunctionInternal::size2_in(casadi_int ind)
64466 const  "
64467 
64468 [INTERNAL]  Input/output dimensions.
64469 
64470 ";
64471 
64472 %feature("docstring")  casadi::FunctionInternal::call_forward(const
64473 std::vector< MX > &arg, const std::vector< MX > &res, const std::vector<
64474 std::vector< MX > > &fseed, std::vector< std::vector< MX > > &fsens, bool
64475 always_inline, bool never_inline) const  "
64476 
64477 [INTERNAL]  Forward mode AD, virtual functions overloaded in derived
64478 classes.
64479 
64480 ";
64481 
64482 %feature("docstring")  casadi::FunctionInternal::call_forward(const
64483 std::vector< SX > &arg, const std::vector< SX > &res, const std::vector<
64484 std::vector< SX > > &fseed, std::vector< std::vector< SX > > &fsens, bool
64485 always_inline, bool never_inline) const  "
64486 
64487 [INTERNAL]  Forward mode AD, virtual functions overloaded in derived
64488 classes.
64489 
64490 ";
64491 
64492 %feature("docstring")  casadi::FunctionInternal::free_mx() const  "
64493 
64494 [INTERNAL]  Get free variables ( MX)
64495 
64496 ";
64497 
64498 %feature("docstring")  casadi::FunctionInternal::fwdViaJac(casadi_int nfwd)
64499 const  "
64500 
64501 [INTERNAL]  Calculate derivatives by multiplying the full Jacobian and
64502 multiplying.
64503 
64504 ";
64505 
64506 %feature("docstring")  casadi::FunctionInternal::get_reltol() const  "
64507 
64508 [INTERNAL]  Get relative tolerance.
64509 
64510 ";
64511 
64512 %feature("docstring")  casadi::QpToNlp::get_stats(void *mem) const  "
64513 
64514 [INTERNAL]  Get all statistics.
64515 
64516 ";
64517 
64518 %feature("docstring")
64519 casadi::FunctionInternal::getJacSparsityHierarchical(casadi_int iind,
64520 casadi_int oind) const  "
64521 
64522 [INTERNAL]  A flavor of getJacSparsity that does hierarchical block
64523 structure recognition.
64524 
64525 ";
64526 
64527 %feature("docstring")
64528 casadi::FunctionInternal::codegen_incref(CodeGenerator &g) const  "
64529 
64530 [INTERNAL]  Codegen incref for dependencies.
64531 
64532 ";
64533 
64534 %feature("docstring")
64535 casadi::FunctionInternal::codegen_alloc_mem(CodeGenerator &g) const  "
64536 
64537 [INTERNAL]  Codegen decref for alloc_mem.
64538 
64539 ";
64540 
64541 %feature("docstring")  casadi::FunctionInternal::matching_res(const
64542 std::vector< M > &arg, casadi_int &npar) const  "
64543 
64544 [INTERNAL]  Check if output arguments that needs to be replaced.
64545 
64546 Raises errors
64547 
64548 Parameters:
64549 -----------
64550 
64551 npar[in]:  normal usage: 1, disallow pararallel calls: -1
64552 
64553 npar:  max number of horizontal repetitions across all arguments (or -1)
64554 
64555 ";
64556 
64557 %feature("docstring")  casadi::FunctionInternal::nnz_in() const  "
64558 
64559 [INTERNAL]  Number of input/output nonzeros.
64560 
64561 ";
64562 
64563 %feature("docstring")  casadi::FunctionInternal::nnz_in(casadi_int ind)
64564 const  "
64565 
64566 [INTERNAL]  Number of input/output nonzeros.
64567 
64568 ";
64569 
64570 %feature("docstring")  casadi::Conic::get_n_out()  "
64571 
64572 [INTERNAL]  Number of function inputs and outputs.
64573 
64574 ";
64575 
64576 %feature("docstring")  casadi::QpToNlp::alloc_mem() const  "
64577 
64578 [INTERNAL]  Create memory block.
64579 
64580 ";
64581 
64582 %feature("docstring")
64583 casadi::FunctionInternal::instruction_constant(casadi_int k) const  "
64584 
64585 [INTERNAL]  Get the floating point output argument of an atomic operation.
64586 
64587 ";
64588 
64589 %feature("docstring")  casadi::FunctionInternal::check_mat(const Sparsity
64590 &arg, const Sparsity &inp, casadi_int &npar) "
64591 
64592 [INTERNAL]  Helper function
64593 
64594 Parameters:
64595 -----------
64596 
64597 npar[in]:  normal usage: 1, disallow pararallel calls: -1
64598 
64599 npar[out]:  required number of parallel calls (or -1)
64600 
64601 ";
64602 
64603 %feature("docstring")  casadi::ProtoFunction::print(const char *fmt,...)
64604 const  "
64605 
64606 [INTERNAL]  C-style formatted printing during evaluation.
64607 
64608 ";
64609 
64610 %feature("docstring")  casadi::FunctionInternal::codegen_mem_type() const  "
64611 
64612 [INTERNAL]  Thread-local memory object type.
64613 
64614 ";
64615 
64616 %feature("docstring")  casadi::FunctionInternal::tocache(const Function &f,
64617 const std::string &suffix="") const  "
64618 
64619 [INTERNAL]  Save function to cache.
64620 
64621 ";
64622 
64623 %feature("docstring")  casadi::FunctionInternal::sp_forward(const bvec_t
64624 **arg, bvec_t **res, casadi_int *iw, bvec_t *w, void *mem) const  "
64625 
64626 [INTERNAL]  Propagate sparsity forward.
64627 
64628 ";
64629 
64630 %feature("docstring")  casadi::FunctionInternal::has_jac() const  "
64631 
64632 [INTERNAL]  Return Jacobian of all input elements with respect to all output
64633 elements.
64634 
64635 ";
64636 
64637 %feature("docstring")  casadi::FunctionInternal::has_derivative() const  "
64638 
64639 [INTERNAL]  Can derivatives be calculated in any way?
64640 
64641 ";
64642 
64643 %feature("docstring")  casadi::FunctionInternal::sx_in(casadi_int ind) const
64644 "
64645 
64646 [INTERNAL]  Get function input(s) and output(s)
64647 
64648 ";
64649 
64650 %feature("docstring")  casadi::FunctionInternal::sx_in() const  "
64651 
64652 [INTERNAL]  Get function input(s) and output(s)
64653 
64654 ";
64655 
64656 %feature("docstring")  casadi::FunctionInternal::sx_out(casadi_int ind)
64657 const  "
64658 
64659 [INTERNAL]  Get function input(s) and output(s)
64660 
64661 ";
64662 
64663 %feature("docstring")  casadi::FunctionInternal::sx_out() const  "
64664 
64665 [INTERNAL]  Get function input(s) and output(s)
64666 
64667 ";
64668 
64669 %feature("docstring")  casadi::FunctionInternal::eval_sx(const SXElem **arg,
64670 SXElem **res, casadi_int *iw, SXElem *w, void *mem) const  "
64671 
64672 [INTERNAL]  Evaluate with symbolic scalars.
64673 
64674 ";
64675 
64676 %feature("docstring")  casadi::FunctionInternal::call(const std::vector< M >
64677 &arg, std::vector< M > &res, bool always_inline, bool never_inline) const  "
64678 
64679 [INTERNAL]   Call a function, templated.
64680 
64681 ";
64682 
64683 %feature("docstring")  casadi::FunctionInternal::numel_out(casadi_int ind)
64684 const  "
64685 
64686 [INTERNAL]  Number of input/output elements.
64687 
64688 ";
64689 
64690 %feature("docstring")  casadi::FunctionInternal::numel_out() const  "
64691 
64692 [INTERNAL]  Number of input/output elements.
64693 
64694 ";
64695 
64696 %feature("docstring")  casadi::Conic::init_mem(void *mem) const  "
64697 
64698 [INTERNAL]  Initalize memory block.
64699 
64700 ";
64701 
64702 %feature("docstring")  casadi::ProtoFunction::sprint(char *buf, size_t
64703 buf_sz, const char *fmt,...) const  "
64704 
64705 [INTERNAL]  C-style formatted printing to string.
64706 
64707 ";
64708 
64709 %feature("docstring")  casadi::FunctionInternal::matching_arg(const
64710 std::vector< M > &arg, casadi_int &npar) const  "
64711 
64712 [INTERNAL]  Check if input arguments that needs to be replaced.
64713 
64714 Raises errors
64715 
64716 Parameters:
64717 -----------
64718 
64719 npar[in]:  normal usage: 1, disallow pararallel calls: -1
64720 
64721 npar:  max number of horizontal repetitions across all arguments (or -1)
64722 
64723 ";
64724 
64725 %feature("docstring")  casadi::SharedObjectInternal::weak() "
64726 
64727 [INTERNAL]  Get a weak reference to the object.
64728 
64729 ";
64730 
64731 %feature("docstring")  casadi::FunctionInternal::jit_dependencies(const
64732 std::string &fname) "
64733 
64734 [INTERNAL]  Jit dependencies.
64735 
64736 ";
64737 
64738 %feature("docstring")  casadi::FunctionInternal::jacobian_sparsity() const
64739 "
64740 
64741 [INTERNAL]  Get Jacobian sparsity.
64742 
64743 ";
64744 
64745 %feature("docstring")  casadi::FunctionInternal::set_temp(void *mem, const
64746 double **arg, double **res, casadi_int *iw, double *w) const  "
64747 
64748 [INTERNAL]  Set the (temporary) work vectors.
64749 
64750 ";
64751 
64752 %feature("docstring")  casadi::FunctionInternal::self() const  "
64753 
64754 [INTERNAL]  Get a public class instance.
64755 
64756 ";
64757 
64758 %feature("docstring")  casadi::FunctionInternal::size_in(casadi_int ind)
64759 const  "
64760 
64761 [INTERNAL]  Input/output dimensions.
64762 
64763 ";
64764 
64765 %feature("docstring")  casadi::SharedObjectInternal::getCount() const  "
64766 
64767 [INTERNAL]  Get the reference count.
64768 
64769 ";
64770 
64771 %feature("docstring")  casadi::FunctionInternal::mx_in(casadi_int ind) const
64772 "
64773 
64774 [INTERNAL]  Get function input(s) and output(s)
64775 
64776 ";
64777 
64778 %feature("docstring")  casadi::FunctionInternal::mx_in() const  "
64779 
64780 [INTERNAL]  Get function input(s) and output(s)
64781 
64782 ";
64783 
64784 %feature("docstring")  casadi::FunctionInternal::sz_iw() const  "
64785 
64786 [INTERNAL]  Get required length of iw field.
64787 
64788 ";
64789 
64790 %feature("docstring")  casadi::FunctionInternal::symbolic_output(const
64791 std::vector< MX > &arg) const  "
64792 
64793 [INTERNAL]  Get a vector of symbolic variables corresponding to the outputs.
64794 
64795 ";
64796 
64797 %feature("docstring")  casadi::FunctionInternal::jac() const  "
64798 
64799 [INTERNAL]  Return Jacobian of all input elements with respect to all output
64800 elements.
64801 
64802 ";
64803 
64804 %feature("docstring")  casadi::FunctionInternal::size_out(casadi_int ind)
64805 const  "
64806 
64807 [INTERNAL]  Input/output dimensions.
64808 
64809 ";
64810 
64811 %feature("docstring")  casadi::FunctionInternal::call_reverse(const
64812 std::vector< MX > &arg, const std::vector< MX > &res, const std::vector<
64813 std::vector< MX > > &aseed, std::vector< std::vector< MX > > &asens, bool
64814 always_inline, bool never_inline) const  "
64815 
64816 [INTERNAL]  Reverse mode, virtual functions overloaded in derived classes.
64817 
64818 ";
64819 
64820 %feature("docstring")  casadi::FunctionInternal::call_reverse(const
64821 std::vector< SX > &arg, const std::vector< SX > &res, const std::vector<
64822 std::vector< SX > > &aseed, std::vector< std::vector< SX > > &asens, bool
64823 always_inline, bool never_inline) const  "
64824 
64825 [INTERNAL]  Reverse mode, virtual functions overloaded in derived classes.
64826 
64827 ";
64828 
64829 %feature("docstring")  casadi::FunctionInternal::sparsity_out(casadi_int
64830 ind) const  "
64831 
64832 [INTERNAL]  Input/output sparsity.
64833 
64834 ";
64835 
64836 %feature("docstring")  casadi::Conic::eval(const double **arg, double **res,
64837 casadi_int *iw, double *w, void *mem) const final "
64838 
64839 [INTERNAL]   Solve the QP.
64840 
64841 ";
64842 
64843 %feature("docstring") casadi::QpToNlp::~QpToNlp "
64844 
64845 [INTERNAL]  Destructor.
64846 
64847 ";
64848 
64849 %feature("docstring")  casadi::FunctionInternal::instruction_id(casadi_int
64850 k) const  "
64851 
64852 [INTERNAL]  Get an atomic operation operator index.
64853 
64854 ";
64855 
64856 %feature("docstring")  casadi::FunctionInternal::dm_out(casadi_int ind)
64857 const  "
64858 
64859 [INTERNAL]  Get function input(s) and output(s)
64860 
64861 ";
64862 
64863 %feature("docstring")  casadi::FunctionInternal::dm_out() const  "
64864 
64865 [INTERNAL]  Get function input(s) and output(s)
64866 
64867 ";
64868 
64869 %feature("docstring")  casadi::FunctionInternal::generate_lifted(Function
64870 &vdef_fcn, Function &vinit_fcn) const  "
64871 
64872 [INTERNAL]  Extract the functions needed for the Lifted Newton method.
64873 
64874 ";
64875 
64876 %feature("docstring")
64877 casadi::FunctionInternal::getJacSparsityGen(casadi_int iind, casadi_int
64878 oind, bool symmetric, casadi_int gr_i=1, casadi_int gr_o=1) const  "
64879 
64880 [INTERNAL]  Get the sparsity pattern, forward mode.
64881 
64882 ";
64883 
64884 %feature("docstring")  casadi::FunctionInternal::nz_in(const std::vector< DM
64885 > &arg) const  "
64886 
64887 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
64888 
64889 ";
64890 
64891 %feature("docstring")  casadi::FunctionInternal::nz_in(const std::vector<
64892 double > &arg) const  "
64893 
64894 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
64895 
64896 ";
64897 
64898 %feature("docstring")  casadi::FunctionInternal::setup(void *mem, const
64899 double **arg, double **res, casadi_int *iw, double *w) const  "
64900 
64901 [INTERNAL]  Set the (persistent and temporary) work vectors.
64902 
64903 ";
64904 
64905 %feature("docstring")  casadi::FunctionInternal::get_abstol() const  "
64906 
64907 [INTERNAL]  Get absolute tolerance.
64908 
64909 ";
64910 
64911 %feature("docstring")  casadi::FunctionInternal::get_free() const  "
64912 
64913 [INTERNAL]  Print free variables.
64914 
64915 ";
64916 
64917 %feature("docstring")  casadi::FunctionInternal::definition() const  "
64918 
64919 [INTERNAL]  Get function signature: name:(inputs)->(outputs)
64920 
64921 ";
64922 
64923 %feature("docstring")  casadi::FunctionInternal::print_option(const
64924 std::string &name, std::ostream &stream) const  "
64925 
64926 [INTERNAL]  Print all information there is to know about a certain option.
64927 
64928 ";
64929 
64930 %feature("docstring")  casadi::ProtoFunction::memory(int ind) const  "
64931 
64932 [INTERNAL]  Memory objects.
64933 
64934 ";
64935 
64936 %feature("docstring")  casadi::FunctionInternal::wrap() const  "
64937 
64938 [INTERNAL]  Wrap in an Function instance consisting of only one MX call.
64939 
64940 ";
64941 
64942 %feature("docstring")  casadi::FunctionInternal::has_eval_dm() const  "
64943 
64944 [INTERNAL]  Evaluate with DM matrices.
64945 
64946 ";
64947 
64948 %feature("docstring")  casadi::Conic::get_sparsity_out(casadi_int i)  "
64949 
64950 [INTERNAL]  Sparsities of function inputs and outputs.
64951 
64952 ";
64953 
64954 %feature("docstring")  casadi::ProtoFunction::checkout() const  "
64955 
64956 [INTERNAL]  Checkout a memory object.
64957 
64958 ";
64959 
64960 %feature("docstring")  casadi::FunctionInternal::replace_aseed(const
64961 std::vector< std::vector< M >> &aseed, casadi_int npar) const  "
64962 
64963 [INTERNAL]  Replace 0-by-0 reverse seeds.
64964 
64965 ";
64966 
64967 %feature("docstring")  casadi::FunctionInternal::replace_aseed(const
64968 std::vector< std::vector< M > > &aseed, casadi_int npar) const  "
64969 
64970 [INTERNAL] ";
64971 
64972 %feature("docstring")  casadi::Conic::get_default_in(casadi_int ind) const
64973 "
64974 
64975 [INTERNAL]  Get default input value.
64976 
64977 ";
64978 
64979 %feature("docstring")  casadi::FunctionInternal::uses_output() const  "
64980 
64981 [INTERNAL]  Do the derivative functions need nondifferentiated outputs?
64982 
64983 ";
64984 
64985 %feature("docstring")  casadi::FunctionInternal::mapsum_mx(const
64986 std::vector< MX > &arg, const std::string &parallelization) "
64987 
64988 [INTERNAL]  Parallel evaluation.
64989 
64990 ";
64991 
64992 %feature("docstring")  casadi::FunctionInternal::sparsity_in(casadi_int ind)
64993 const  "
64994 
64995 [INTERNAL]  Input/output sparsity.
64996 
64997 ";
64998 
64999 %feature("docstring")  casadi::FunctionInternal::reverse(casadi_int nadj)
65000 const  "
65001 
65002 [INTERNAL]  Return function that calculates adjoint derivatives
65003 reverse(nadj) returns a cached instance if available, and calls  Function
65004 get_reverse(casadi_int nadj) if no cached version is available.
65005 
65006 ";
65007 
65008 %feature("docstring")  casadi::FunctionInternal::mx_out(casadi_int ind)
65009 const  "
65010 
65011 [INTERNAL]  Get function input(s) and output(s)
65012 
65013 ";
65014 
65015 %feature("docstring")  casadi::FunctionInternal::mx_out() const  "
65016 
65017 [INTERNAL]  Get function input(s) and output(s)
65018 
65019 ";
65020 
65021 %feature("docstring")  casadi::FunctionInternal::alloc_res(size_t sz_res,
65022 bool persistent=false) "
65023 
65024 [INTERNAL]  Ensure required length of res field.
65025 
65026 ";
65027 
65028 %feature("docstring")
65029 casadi::FunctionInternal::codegen_declarations(CodeGenerator &g) const  "
65030 
65031 [INTERNAL]  Generate code for the declarations of the C function.
65032 
65033 ";
65034 
65035 %feature("docstring")  casadi::FunctionInternal::factory(const std::string
65036 &name, const std::vector< std::string > &s_in, const std::vector<
65037 std::string > &s_out, const Function::AuxOut &aux, const Dict &opts) const
65038 "
65039 
65040 [INTERNAL] ";
65041 
65042 %feature("docstring") casadi::QpToNlp "
65043 
65044 'nlpsol' plugin for Conic
65045 
65046 Solve QPs using an Nlpsol Use the 'nlpsol' option to specify the NLP solver
65047 to use.
65048 
65049 >List of available options
65050 
65051 +----------------+-----------+---------------------------------+
65052 |       Id       |   Type    |           Description           |
65053 +================+===========+=================================+
65054 | nlpsol         | OT_STRING | Name of solver.                 |
65055 +----------------+-----------+---------------------------------+
65056 | nlpsol_options | OT_DICT   | Options to be passed to solver. |
65057 +----------------+-----------+---------------------------------+
65058 
65059 Joris Gillis
65060 
65061 >List of available options
65062 
65063 +----------------+---------------+-----------------------+-----------------+
65064 |       Id       |     Type      |      Description      |     Used in     |
65065 +================+===============+=======================+=================+
65066 | discrete       | OT_BOOLVECTOR | Indicates which of    | casadi::Conic   |
65067 |                |               | the variables are     |                 |
65068 |                |               | discrete, i.e.        |                 |
65069 |                |               | integer-valued        |                 |
65070 +----------------+---------------+-----------------------+-----------------+
65071 | error_on_fail  | OT_BOOL       | When the numerical    | casadi::Conic   |
65072 |                |               | process returns       |                 |
65073 |                |               | unsuccessfully, raise |                 |
65074 |                |               | an error (default     |                 |
65075 |                |               | false).               |                 |
65076 +----------------+---------------+-----------------------+-----------------+
65077 | nlpsol         | OT_STRING     | Name of solver.       | casadi::QpToNlp |
65078 +----------------+---------------+-----------------------+-----------------+
65079 | nlpsol_options | OT_DICT       | Options to be passed  | casadi::QpToNlp |
65080 |                |               | to solver.            |                 |
65081 +----------------+---------------+-----------------------+-----------------+
65082 | print_problem  | OT_BOOL       | Print a numeric       | casadi::Conic   |
65083 |                |               | description of the    |                 |
65084 |                |               | problem               |                 |
65085 +----------------+---------------+-----------------------+-----------------+
65086 
65087 Diagrams
65088 --------
65089 
65090 
65091 
65092 C++ includes: qp_to_nlp.hpp ";
65093 
65094 %feature("docstring")  casadi::FunctionInternal::oracle() const  "
65095 
65096 [INTERNAL]  Get oracle.
65097 
65098 ";
65099 
65100 %feature("docstring")  casadi::Conic::serialize_base_function() const  "
65101 
65102 [INTERNAL]  String used to identify the immediate FunctionInternal subclass.
65103 
65104 ";
65105 
65106 %feature("docstring")  casadi::Conic::get_sparsity_in(casadi_int i)  "
65107 
65108 [INTERNAL]  Sparsities of function inputs and outputs.
65109 
65110 ";
65111 
65112 %feature("docstring")  casadi::Conic::check_inputs(const double *lbx, const
65113 double *ubx, const double *lba, const double *uba) const  "
65114 
65115 [INTERNAL]  Check if the numerical values of the supplied bounds make sense.
65116 
65117 ";
65118 
65119 %feature("docstring")  casadi::FunctionInternal::slice(const std::string
65120 &name, const std::vector< casadi_int > &order_in, const std::vector<
65121 casadi_int > &order_out, const Dict &opts) const  "
65122 
65123 [INTERNAL]  returns a new function with a selection of inputs/outputs of the
65124 original
65125 
65126 ";
65127 
65128 %feature("docstring")  casadi::FunctionInternal::has_free() const  "
65129 
65130 [INTERNAL]  Does the function have free variables.
65131 
65132 ";
65133 
65134 %feature("docstring")  casadi::FunctionInternal::codegen_meta(CodeGenerator
65135 &g) const  "
65136 
65137 [INTERNAL]  Generate meta-information allowing a user to evaluate a
65138 generated function.
65139 
65140 ";
65141 
65142 %feature("docstring")  casadi::FunctionInternal::instruction_MX(casadi_int
65143 k) const  "
65144 
65145 [INTERNAL]  get MX expression associated with instruction
65146 
65147 ";
65148 
65149 %feature("docstring")  casadi::FunctionInternal::codegen(CodeGenerator &g,
65150 const std::string &fname) const  "
65151 
65152 [INTERNAL]  Generate code the function.
65153 
65154 ";
65155 
65156 %feature("docstring")
65157 casadi::FunctionInternal::instruction_output(casadi_int k) const  "
65158 
65159 [INTERNAL]  Get the (integer) output argument of an atomic operation.
65160 
65161 ";
65162 
65163 %feature("docstring")  casadi::FunctionInternal::n_instructions() const  "
65164 
65165 [INTERNAL]  Get the number of atomic operations.
65166 
65167 ";
65168 
65169 %feature("docstring")  casadi::FunctionInternal::replace_res(const
65170 std::vector< M > &res, casadi_int npar) const  "
65171 
65172 [INTERNAL]  Replace 0-by-0 outputs.
65173 
65174 ";
65175 
65176 %feature("docstring")  casadi::FunctionInternal::get_jacobian(const
65177 std::string &name, const std::vector< std::string > &inames, const
65178 std::vector< std::string > &onames, const Dict &opts) const  "
65179 
65180 [INTERNAL]  Return Jacobian of all input elements with respect to all output
65181 elements.
65182 
65183 ";
65184 
65185 %feature("docstring")  casadi::FunctionInternal::check_res(const
65186 std::vector< M > &res, casadi_int &npar) const  "
65187 
65188 [INTERNAL]  Check if output arguments have correct length and dimensions.
65189 
65190 Raises errors.
65191 
65192 Parameters:
65193 -----------
65194 
65195 npar[in]:  normal usage: 1, disallow pararallel calls: -1
65196 
65197 npar:  max number of horizontal repetitions across all arguments (or -1)
65198 
65199 ";
65200 
65201 %feature("docstring")  casadi::FunctionInternal::forward(casadi_int nfwd)
65202 const  "
65203 
65204 [INTERNAL]  Return function that calculates forward derivatives
65205 forward(nfwd) returns a cached instance if available, and calls  Function
65206 get_forward(casadi_int nfwd) if no cached version is available.
65207 
65208 ";
65209 
65210 %feature("docstring")  casadi::FunctionInternal::get_function() const  "
65211 
65212 [INTERNAL] ";
65213 
65214 %feature("docstring")  casadi::FunctionInternal::get_function(const
65215 std::string &name) const  "
65216 
65217 [INTERNAL] ";
65218 
65219 %feature("docstring")  casadi::QpToNlp::class_name() const  "
65220 
65221 [INTERNAL]  Readable name of the internal class.
65222 
65223 ";
65224 
65225 %feature("docstring")  casadi::FunctionInternal::get_forward(casadi_int
65226 nfwd, const std::string &name, const std::vector< std::string > &inames,
65227 const std::vector< std::string > &onames, const Dict &opts) const  "
65228 
65229 [INTERNAL]  Return function that calculates forward derivatives
65230 forward(nfwd) returns a cached instance if available, and calls  Function
65231 get_forward(casadi_int nfwd) if no cached version is available.
65232 
65233 ";
65234 
65235 %feature("docstring")  casadi::FunctionInternal::incache(const std::string
65236 &fname, Function &f, const std::string &suffix="") const  "
65237 
65238 [INTERNAL]  Get function in cache.
65239 
65240 ";
65241 
65242 %feature("docstring")  casadi::FunctionInternal::generate_options(bool
65243 is_temp=false) const  "
65244 
65245 [INTERNAL]  Reconstruct options dict.
65246 
65247 ";
65248 
65249 %feature("docstring")  casadi::QpToNlp::plugin_name() const  "
65250 
65251 [INTERNAL] ";
65252 
65253 %feature("docstring")  casadi::FunctionInternal::all_scalar() const  "
65254 
65255 [INTERNAL]  Are all inputs and outputs scalar.
65256 
65257 ";
65258 
65259 %feature("docstring")  casadi::FunctionInternal::has_jacobian() const  "
65260 
65261 [INTERNAL]  Return Jacobian of all input elements with respect to all output
65262 elements.
65263 
65264 ";
65265 
65266 %feature("docstring")  casadi::QpToNlp::serialize_body(SerializingStream &s)
65267 const  "
65268 
65269 [INTERNAL]  Serialize an object without type information.
65270 
65271 ";
65272 
65273 %feature("docstring")  casadi::FunctionInternal::convert_res(const
65274 std::vector< M > &res) const  "
65275 
65276 [INTERNAL]  Convert from/to input/output lists/map.
65277 
65278 ";
65279 
65280 %feature("docstring")  casadi::FunctionInternal::convert_res(const std::map<
65281 std::string, M > &res) const  "
65282 
65283 [INTERNAL]  Convert from/to input/output lists/map.
65284 
65285 ";
65286 
65287 %feature("docstring")  casadi::FunctionInternal::alloc(const Function &f,
65288 bool persistent=false) "
65289 
65290 [INTERNAL]  Ensure work vectors long enough to evaluate function.
65291 
65292 ";
65293 
65294 %feature("docstring")  casadi::FunctionInternal::n_nodes() const  "
65295 
65296 [INTERNAL]  Number of nodes in the algorithm.
65297 
65298 ";
65299 
65300 %feature("docstring")
65301 casadi::FunctionInternal::print_dimensions(std::ostream &stream) const  "
65302 
65303 [INTERNAL]  Print dimensions of inputs and outputs.
65304 
65305 ";
65306 
65307 %feature("docstring")  casadi::Conic::psd_support() const  "
65308 
65309 [INTERNAL]  Can psd constraints be treated.
65310 
65311 ";
65312 
65313 %feature("docstring")  casadi::FunctionInternal::size1_out(casadi_int ind)
65314 const  "
65315 
65316 [INTERNAL]  Input/output dimensions.
65317 
65318 ";
65319 
65320 %feature("docstring")  casadi::FunctionInternal::which_depends(const
65321 std::string &s_in, const std::vector< std::string > &s_out, casadi_int
65322 order, bool tr=false) const  "
65323 
65324 [INTERNAL]  Which variables enter with some order.
65325 
65326 Parameters:
65327 -----------
65328 
65329 s_in:   Input name
65330 
65331 s_out:   Output name(s)
65332 
65333 order:  Only 1 (linear) and 2 (nonlinear) allowed
65334 
65335 tr:  Flip the relationship. Return which expressions contain the variables
65336 
65337 ";
65338 
65339 %feature("docstring")
65340 casadi::FunctionInternal::codegen_decref(CodeGenerator &g) const  "
65341 
65342 [INTERNAL]  Codegen decref for dependencies.
65343 
65344 ";
65345 
65346 %feature("docstring")  casadi::Conic::set_work(void *mem, const double
65347 **&arg, double **&res, casadi_int *&iw, double *&w) const  "
65348 
65349 [INTERNAL]  Set the (persistent) work vectors.
65350 
65351 ";
65352 
65353 %feature("docstring")  casadi::FunctionInternal::has_function(const
65354 std::string &fname) const  "
65355 
65356 [INTERNAL] ";
65357 
65358 %feature("docstring")  casadi::FunctionInternal::has_sprev() const  "
65359 
65360 [INTERNAL]  Is the class able to propagate seeds through the algorithm?
65361 
65362 ";
65363 
65364 %feature("docstring")  casadi::FunctionInternal::getAdaptorSolverName()
65365 const  "
65366 
65367 [INTERNAL]  Obtain solver name from Adaptor.
65368 
65369 ";
65370 
65371 %feature("docstring")  casadi::FunctionInternal::size2_out(casadi_int ind)
65372 const  "
65373 
65374 [INTERNAL]  Input/output dimensions.
65375 
65376 ";
65377 
65378 %feature("docstring")  casadi::FunctionInternal::alloc_iw(size_t sz_iw, bool
65379 persistent=false) "
65380 
65381 [INTERNAL]  Ensure required length of iw field.
65382 
65383 ";
65384 
65385 %feature("docstring")  casadi::QpToNlp::solve(const double **arg, double
65386 **res, casadi_int *iw, double *w, void *mem) const  "
65387 
65388 [INTERNAL]   Solve the QP.
65389 
65390 ";
65391 
65392 %feature("docstring") casadi::casadi_solve "
65393 
65394 Solve the QP.
65395 
65396 ";
65397 
65398 %feature("docstring")  casadi::QpToNlp::casadi_solve "
65399 
65400 Solve the QP.
65401 
65402 ";
65403 
65404 %feature("docstring")  casadi::FunctionInternal::print_options(std::ostream
65405 &stream) const  "
65406 
65407 [INTERNAL]  Print list of options.
65408 
65409 ";
65410 
65411 %feature("docstring")  casadi::FunctionInternal::has_spfwd() const  "
65412 
65413 [INTERNAL]  Is the class able to propagate seeds through the algorithm?
65414 
65415 ";
65416 
65417 %feature("docstring")  casadi::FunctionInternal::free_sx() const  "
65418 
65419 [INTERNAL]  Get free variables (SX)
65420 
65421 ";
65422 
65423 %feature("docstring")
65424 casadi::FunctionInternal::instruction_input(casadi_int k) const  "
65425 
65426 [INTERNAL]  Get the (integer) input arguments of an atomic operation.
65427 
65428 ";
65429 
65430 %feature("docstring")
65431 casadi::FunctionInternal::jacobian_sparsity_filter(const Sparsity &sp) const
65432 "
65433 
65434 [INTERNAL]  Filter out nonzeros in the full sparsity jacobian according to
65435 is_diff_in/out.
65436 
65437 ";
65438 
65439 %feature("docstring")  casadi::ProtoFunction::clear_mem() "
65440 
65441 [INTERNAL]  Clear all memory (called from destructor)
65442 
65443 ";
65444 
65445 %feature("docstring")  casadi::FunctionInternal::signature(const std::string
65446 &fname) const  "
65447 
65448 [INTERNAL]  Code generate the function.
65449 
65450 ";
65451 
65452 %feature("docstring")  casadi::QpToNlp::free_mem(void *mem) const  "
65453 
65454 [INTERNAL]  Free memory block.
65455 
65456 ";
65457 
65458 %feature("docstring")  casadi::FunctionInternal::generate_dependencies(const
65459 std::string &fname, const Dict &opts) const  "
65460 
65461 [INTERNAL]  Export / Generate C code for the dependency function.
65462 
65463 ";
65464 
65465 %feature("docstring")  casadi::FunctionInternal::sp_weight() const  "
65466 
65467 [INTERNAL]  Weighting factor for chosing forward/reverse mode, sparsity
65468 propagation.
65469 
65470 ";
65471 
65472 %feature("docstring")  casadi::QpToNlp::get_options() const  "
65473 
65474 [INTERNAL]  Options.
65475 
65476 ";
65477 
65478 %feature("docstring")  casadi::FunctionInternal::codegen_mem(CodeGenerator
65479 &g, const std::string &index="mem") const  "
65480 
65481 [INTERNAL]  Get thread-local memory object.
65482 
65483 ";
65484 
65485 %feature("docstring")  casadi::Conic::serialize_type(SerializingStream &s)
65486 const  "
65487 
65488 [INTERNAL]  Serialize type information.
65489 
65490 ";
65491 
65492 %feature("docstring")  casadi::FunctionInternal::has_reverse(casadi_int
65493 nadj) const  "
65494 
65495 [INTERNAL]  Return function that calculates adjoint derivatives
65496 reverse(nadj) returns a cached instance if available, and calls  Function
65497 get_reverse(casadi_int nadj) if no cached version is available.
65498 
65499 ";
65500 
65501 %feature("docstring")  casadi::Conic::integer_support() const  "
65502 
65503 [INTERNAL]  Can discrete variables be treated.
65504 
65505 ";
65506 
65507 %feature("docstring")  casadi::QpToNlp::init(const Dict &opts)  "
65508 
65509 [INTERNAL]  Initialize.
65510 
65511 ";
65512 
65513 %feature("docstring")
65514 casadi::FunctionInternal::codegen_free_mem(CodeGenerator &g) const  "
65515 
65516 [INTERNAL]  Codegen for free_mem.
65517 
65518 ";
65519 
65520 %feature("docstring")  casadi::FunctionInternal::sz_work(size_t &sz_arg,
65521 size_t &sz_res, size_t &sz_iw, size_t &sz_w) const  "
65522 
65523 [INTERNAL]  Get number of temporary variables needed.
65524 
65525 ";
65526 
65527 %feature("docstring")
65528 casadi::FunctionInternal::codegen_init_mem(CodeGenerator &g) const  "
65529 
65530 [INTERNAL]  Codegen decref for init_mem.
65531 
65532 ";
65533 
65534 %feature("docstring")  casadi::FunctionInternal::sz_w() const  "
65535 
65536 [INTERNAL]  Get required length of w field.
65537 
65538 ";
65539 
65540 %feature("docstring")  casadi::ProtoFunction::release(int mem) const  "
65541 
65542 [INTERNAL]  Release a memory object.
65543 
65544 ";
65545 
65546 %feature("docstring")  casadi::FunctionInternal::fwd_seed(casadi_int nfwd)
65547 const  "
65548 
65549 [INTERNAL]  Symbolic expressions for the forward seeds.
65550 
65551 ";
65552 
65553 %feature("docstring")  casadi::FunctionInternal::alloc_w(size_t sz_w, bool
65554 persistent=false) "
65555 
65556 [INTERNAL]  Ensure required length of w field.
65557 
65558 ";
65559 
65560 %feature("docstring")  casadi::FunctionInternal::alloc_arg(size_t sz_arg,
65561 bool persistent=false) "
65562 
65563 [INTERNAL]  Ensure required length of arg field.
65564 
65565 ";
65566 
65567 %feature("docstring")  casadi::Conic::is_a(const std::string &type, bool
65568 recursive) const  "
65569 
65570 [INTERNAL]  Check if the function is of a particular type.
65571 
65572 ";
65573 
65574 %feature("docstring") casadi::QpToNlp::QpToNlp(const std::string &name,
65575 const std::map< std::string, Sparsity > &st) "
65576 
65577 [INTERNAL]  Create a new Solver.
65578 
65579 ";
65580 
65581 %feature("docstring")  casadi::FunctionInternal::get_max_in(casadi_int ind)
65582 const  "
65583 
65584 [INTERNAL]  Get largest input value.
65585 
65586 ";
65587 
65588 %feature("docstring")
65589 casadi::FunctionInternal::getJacSparsityHierarchicalSymm(casadi_int iind,
65590 casadi_int oind) const  "
65591 
65592 [INTERNAL]  A flavor of getJacSparsity that does hierarchical block
65593 structure recognition for symmetric Jacobians
65594 
65595 ";
65596 
65597 %feature("docstring")  casadi::FunctionInternal::has_jacobian_sparsity()
65598 const  "
65599 
65600 [INTERNAL]  Get Jacobian sparsity.
65601 
65602 ";
65603 
65604 %feature("docstring")  casadi::FunctionInternal::get_partition(casadi_int
65605 iind, casadi_int oind, Sparsity &D1, Sparsity &D2, bool compact, bool
65606 symmetric, bool allow_forward, bool allow_reverse) const  "
65607 
65608 [INTERNAL]  Get the unidirectional or bidirectional partition.
65609 
65610 ";
65611 
65612 %feature("docstring")  casadi::ProtoFunction::serialize(SerializingStream
65613 &s) const  "
65614 
65615 [INTERNAL]  Serialize an object.
65616 
65617 ";
65618 
65619 %feature("docstring")  casadi::FunctionInternal::sz_res() const  "
65620 
65621 [INTERNAL]  Get required length of res field.
65622 
65623 ";
65624 
65625 %feature("docstring")  casadi::FunctionInternal::index_in(const std::string
65626 &name) const  "
65627 
65628 [INTERNAL]  Get input scheme index by name.
65629 
65630 ";
65631 
65632 %feature("docstring")  casadi::Conic::get_name_in(casadi_int i)  "
65633 
65634 [INTERNAL]  Names of function input and outputs.
65635 
65636 ";
65637 
65638 %feature("docstring")  casadi::FunctionInternal::project_arg(const
65639 std::vector< M > &arg, casadi_int npar) const  "
65640 
65641 [INTERNAL]   Project sparsities.
65642 
65643 ";
65644 
65645 %feature("docstring")  casadi::FunctionInternal::codegen_body(CodeGenerator
65646 &g) const  "
65647 
65648 [INTERNAL]  Generate code for the function body.
65649 
65650 ";
65651 
65652 %feature("docstring")  casadi::FunctionInternal::dm_in(casadi_int ind) const
65653 "
65654 
65655 [INTERNAL]  Get function input(s) and output(s)
65656 
65657 ";
65658 
65659 %feature("docstring")  casadi::FunctionInternal::dm_in() const  "
65660 
65661 [INTERNAL]  Get function input(s) and output(s)
65662 
65663 ";
65664 
65665 %feature("docstring")  casadi::FunctionInternal::replace_arg(const
65666 std::vector< M > &arg, casadi_int npar) const  "
65667 
65668 [INTERNAL]  Replace 0-by-0 inputs.
65669 
65670 ";
65671 
65672 %feature("docstring")  casadi::FunctionInternal::eval_gen(const double
65673 **arg, double **res, casadi_int *iw, double *w, void *mem) const  "
65674 
65675 [INTERNAL]  Evaluate numerically.
65676 
65677 ";
65678 
65679 %feature("docstring")  casadi::FunctionInternal::eval_gen(const SXElem
65680 **arg, SXElem **res, casadi_int *iw, SXElem *w, void *mem) const  "
65681 
65682 [INTERNAL]  Evaluate a function, overloaded.
65683 
65684 ";
65685 
65686 %feature("docstring")  casadi::FunctionInternal::eval_gen(const bvec_t
65687 **arg, bvec_t **res, casadi_int *iw, bvec_t *w, void *mem) const  "
65688 
65689 [INTERNAL]  Evaluate a function, overloaded.
65690 
65691 ";
65692 
65693 %feature("docstring")  casadi::FunctionInternal::call_gen(const MXVector
65694 &arg, MXVector &res, casadi_int npar, bool always_inline, bool never_inline)
65695 const  "
65696 
65697 [INTERNAL]   Call a function, overloaded.
65698 
65699 ";
65700 
65701 %feature("docstring")  casadi::FunctionInternal::call_gen(const std::vector<
65702 MatrixCommon > &arg, std::vector< MatrixCommon > &res, casadi_int npar, bool
65703 always_inline, bool never_inline) const  "
65704 
65705 [INTERNAL]   Call a function, overloaded.
65706 
65707 ";
65708 
65709 %feature("docstring")  casadi::FunctionInternal::sparsity_jac(casadi_int
65710 iind, casadi_int oind, bool compact, bool symmetric) const  "
65711 
65712 [INTERNAL]  Get, if necessary generate, the sparsity of a Jacobian block.
65713 
65714 ";
65715 
65716 %feature("docstring")  casadi::FunctionInternal::jacobian() const  "
65717 
65718 [INTERNAL]  Return Jacobian of all input elements with respect to all output
65719 elements.
65720 
65721 ";
65722 
65723 %feature("docstring")  casadi::FunctionInternal::generate_out(const
65724 std::string &fname, double **res) const  "
65725 
65726 [INTERNAL] ";
65727 
65728 %feature("docstring")  casadi::FunctionInternal::symbolicAdjSeed(casadi_int
65729 nadj, const std::vector< MatType > &v) const  "
65730 
65731 [INTERNAL]  Symbolic expressions for the adjoint seeds.
65732 
65733 ";
65734 
65735 %feature("docstring")  casadi::FunctionInternal::disp(std::ostream &stream,
65736 bool more) const  "
65737 
65738 [INTERNAL]  Display object.
65739 
65740 ";
65741 
65742 %feature("docstring")  casadi::Conic::get_n_in()  "
65743 
65744 [INTERNAL]  Number of function inputs and outputs.
65745 
65746 ";
65747 
65748 %feature("docstring")  casadi::FunctionInternal::numel_in() const  "
65749 
65750 [INTERNAL]  Number of input/output elements.
65751 
65752 ";
65753 
65754 %feature("docstring")  casadi::FunctionInternal::numel_in(casadi_int ind)
65755 const  "
65756 
65757 [INTERNAL]  Number of input/output elements.
65758 
65759 ";
65760 
65761 %feature("docstring")  casadi::FunctionInternal::codegen_name(const
65762 CodeGenerator &g, bool ns=true) const  "
65763 
65764 [INTERNAL]  Get name in codegen.
65765 
65766 ";
65767 
65768 %feature("docstring")  casadi::FunctionInternal::sz_arg() const  "
65769 
65770 [INTERNAL]  Get required length of arg field.
65771 
65772 ";
65773 
65774 %feature("docstring")  casadi::FunctionInternal::wrap_as_needed(const Dict
65775 &opts) const  "
65776 
65777 [INTERNAL]  Wrap in an Function instance consisting of only one MX call.
65778 
65779 ";
65780 
65781 %feature("docstring")  casadi::FunctionInternal::map(casadi_int n, const
65782 std::string &parallelization) const  "
65783 
65784 [INTERNAL]  Generate/retrieve cached serial map.
65785 
65786 ";
65787 
65788 %feature("docstring")  casadi::ProtoFunction::print_time(const std::map<
65789 std::string, FStats > &fstats) const  "
65790 
65791 [INTERNAL]  Print timing statistics.
65792 
65793 ";
65794 
65795 %feature("docstring")  casadi::FunctionInternal::has_forward(casadi_int
65796 nfwd) const  "
65797 
65798 [INTERNAL]  Return function that calculates forward derivatives
65799 forward(nfwd) returns a cached instance if available, and calls  Function
65800 get_forward(casadi_int nfwd) if no cached version is available.
65801 
65802 ";
65803 
65804 %feature("docstring")
65805 casadi::FunctionInternal::codegen_sparsities(CodeGenerator &g) const  "
65806 
65807 [INTERNAL]  Codegen sparsities.
65808 
65809 ";
65810 
65811 %feature("docstring")  casadi::FunctionInternal::is_diff_out(casadi_int i) "
65812 
65813 [INTERNAL] ";
65814 
65815 %feature("docstring")  casadi::Conic::generateNativeCode(std::ostream &file)
65816 const  "
65817 
65818 [INTERNAL]  Generate native code in the interfaced language for debugging
65819 
65820 ";
65821 
65822 %feature("docstring")  casadi::FunctionInternal::nz_out(const std::vector<
65823 DM > &res) const  "
65824 
65825 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
65826 
65827 ";
65828 
65829 %feature("docstring")  casadi::FunctionInternal::nz_out(const std::vector<
65830 double > &res) const  "
65831 
65832 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
65833 
65834 ";
65835 
65836 %feature("docstring")  casadi::FunctionInternal::instructions_sx() const  "
65837 
65838 [INTERNAL]  get SX expression associated with instructions
65839 
65840 ";
65841 
65842 %feature("docstring")  casadi::FunctionInternal::disp_more(std::ostream
65843 &stream) const  "
65844 
65845 [INTERNAL]  Print more.
65846 
65847 ";
65848 
65849 %feature("docstring")  casadi::FunctionInternal::replace_fseed(const
65850 std::vector< std::vector< M >> &fseed, casadi_int npar) const  "
65851 
65852 [INTERNAL]  Replace 0-by-0 forward seeds.
65853 
65854 ";
65855 
65856 %feature("docstring")  casadi::FunctionInternal::replace_fseed(const
65857 std::vector< std::vector< M > > &fseed, casadi_int npar) const  "
65858 
65859 [INTERNAL] ";
65860 
65861 %feature("docstring")  casadi::FunctionInternal::project_res(const
65862 std::vector< M > &arg, casadi_int npar) const  "
65863 
65864 [INTERNAL]   Project sparsities.
65865 
65866 ";
65867 
65868 %feature("docstring")  casadi::FunctionInternal::is_diff_in(casadi_int i) "
65869 
65870 [INTERNAL] ";
65871 
65872 %feature("docstring")  casadi::FunctionInternal::get_min_in(casadi_int ind)
65873 const  "
65874 
65875 [INTERNAL]  Get smallest input value.
65876 
65877 ";
65878 
65879 %feature("docstring")  casadi::FunctionInternal::nnz_out() const  "
65880 
65881 [INTERNAL]  Number of input/output nonzeros.
65882 
65883 ";
65884 
65885 %feature("docstring")  casadi::FunctionInternal::nnz_out(casadi_int ind)
65886 const  "
65887 
65888 [INTERNAL]  Number of input/output nonzeros.
65889 
65890 ";
65891 
65892 %feature("docstring")  casadi::FunctionInternal::finalize()  "
65893 
65894 [INTERNAL]  Finalize the object creation.
65895 
65896 ";
65897 
65898 %feature("docstring")  casadi::FunctionInternal::get_jac(const std::string
65899 &name, const std::vector< std::string > &inames, const std::vector<
65900 std::string > &onames, const Dict &opts) const  "
65901 
65902 [INTERNAL]  Return Jacobian of all input elements with respect to all output
65903 elements.
65904 
65905 ";
65906 
65907 %feature("docstring")  casadi::FunctionInternal::eval_mx(const MXVector
65908 &arg, MXVector &res, bool always_inline, bool never_inline) const  "
65909 
65910 [INTERNAL]  Evaluate with symbolic matrices.
65911 
65912 ";
65913 
65914 %feature("docstring")  casadi::FunctionInternal::size1_in(casadi_int ind)
65915 const  "
65916 
65917 [INTERNAL]  Input/output dimensions.
65918 
65919 ";
65920 
65921 %feature("docstring")  casadi::FunctionInternal::index_out(const std::string
65922 &name) const  "
65923 
65924 [INTERNAL]  Get output scheme index by name.
65925 
65926 ";
65927 
65928 %feature("docstring")  casadi::ProtoFunction::format_time(char *buffer,
65929 double time) const  "
65930 
65931 [INTERNAL]  Format time in a fixed width 8 format.
65932 
65933 ";
65934 
65935 %feature("docstring")  casadi::FunctionInternal::getJacSparsity(casadi_int
65936 iind, casadi_int oind, bool symmetric) const  "
65937 
65938 [INTERNAL]  Generate the sparsity of a Jacobian block.
65939 
65940 ";
65941 
65942 %feature("docstring")  casadi::FunctionInternal::get_reverse(casadi_int
65943 nadj, const std::string &name, const std::vector< std::string > &inames,
65944 const std::vector< std::string > &onames, const Dict &opts) const  "
65945 
65946 [INTERNAL]  Return function that calculates adjoint derivatives
65947 reverse(nadj) returns a cached instance if available, and calls  Function
65948 get_reverse(casadi_int nadj) if no cached version is available.
65949 
65950 ";
65951 
65952 %feature("docstring")  casadi::FunctionInternal::ad_weight() const  "
65953 
65954 [INTERNAL]  Weighting factor for chosing forward/reverse mode.
65955 
65956 ";
65957 
65958 %feature("docstring")  casadi::FunctionInternal::export_code(const
65959 std::string &lang, std::ostream &stream, const Dict &options) const  "
65960 
65961 [INTERNAL]  Export function in a specific language.
65962 
65963 ";
65964 
65965 %feature("docstring")  casadi::FunctionInternal::check_arg(const
65966 std::vector< M > &arg, casadi_int &npar) const  "
65967 
65968 [INTERNAL]  Check if input arguments have correct length and dimensions.
65969 
65970 Raises errors.
65971 
65972 Parameters:
65973 -----------
65974 
65975 npar[in]:  normal usage: 1, disallow pararallel calls: -1
65976 
65977 npar:  max number of horizontal repetitions across all arguments (or -1)
65978 
65979 ";
65980 
65981 %feature("docstring")  casadi::FunctionInternal::generate_in(const
65982 std::string &fname, const double **arg) const  "
65983 
65984 [INTERNAL]  Export an input file that can be passed to generate C code with
65985 a main.
65986 
65987 ";
65988 
65989 %feature("docstring")  casadi::FunctionInternal::get_jacobian_sparsity()
65990 const  "
65991 
65992 [INTERNAL]  Get Jacobian sparsity.
65993 
65994 ";
65995 
65996 %feature("docstring")  casadi::FunctionInternal::adjViaJac(casadi_int nadj)
65997 const  "
65998 
65999 [INTERNAL]  Calculate derivatives by multiplying the full Jacobian and
66000 multiplying.
66001 
66002 ";
66003 
66004 %feature("docstring")  casadi::ProtoFunction::construct(const Dict &opts) "
66005 
66006 [INTERNAL]  Construct Prepares the function for evaluation.
66007 
66008 ";
66009 
66010 %feature("docstring")  casadi::FunctionInternal::eval_dm(const std::vector<
66011 DM > &arg) const  "
66012 
66013 [INTERNAL]  Evaluate with DM matrices.
66014 
66015 ";
66016 
66017 
66018 // File: classcasadi_1_1Qrqp.xml
66019 %feature("docstring")  casadi::FunctionInternal::get_jacobian(const
66020 std::string &name, const std::vector< std::string > &inames, const
66021 std::vector< std::string > &onames, const Dict &opts) const  "
66022 
66023 [INTERNAL]  Return Jacobian of all input elements with respect to all output
66024 elements.
66025 
66026 ";
66027 
66028 %feature("docstring")  casadi::FunctionInternal::oracle() const  "
66029 
66030 [INTERNAL]  Get oracle.
66031 
66032 ";
66033 
66034 %feature("docstring")  casadi::FunctionInternal::codegen_name(const
66035 CodeGenerator &g, bool ns=true) const  "
66036 
66037 [INTERNAL]  Get name in codegen.
66038 
66039 ";
66040 
66041 %feature("docstring")  casadi::FunctionInternal::has_derivative() const  "
66042 
66043 [INTERNAL]  Can derivatives be calculated in any way?
66044 
66045 ";
66046 
66047 %feature("docstring")  casadi::FunctionInternal::dm_out(casadi_int ind)
66048 const  "
66049 
66050 [INTERNAL]  Get function input(s) and output(s)
66051 
66052 ";
66053 
66054 %feature("docstring")  casadi::FunctionInternal::dm_out() const  "
66055 
66056 [INTERNAL]  Get function input(s) and output(s)
66057 
66058 ";
66059 
66060 %feature("docstring")  casadi::FunctionInternal::forward(casadi_int nfwd)
66061 const  "
66062 
66063 [INTERNAL]  Return function that calculates forward derivatives
66064 forward(nfwd) returns a cached instance if available, and calls  Function
66065 get_forward(casadi_int nfwd) if no cached version is available.
66066 
66067 ";
66068 
66069 %feature("docstring")  casadi::FunctionInternal::definition() const  "
66070 
66071 [INTERNAL]  Get function signature: name:(inputs)->(outputs)
66072 
66073 ";
66074 
66075 %feature("docstring")  casadi::FunctionInternal::map(casadi_int n, const
66076 std::string &parallelization) const  "
66077 
66078 [INTERNAL]  Generate/retrieve cached serial map.
66079 
66080 ";
66081 
66082 %feature("docstring")
66083 casadi::FunctionInternal::codegen_free_mem(CodeGenerator &g) const  "
66084 
66085 [INTERNAL]  Codegen for free_mem.
66086 
66087 ";
66088 
66089 %feature("docstring")  casadi::FunctionInternal::numel_out(casadi_int ind)
66090 const  "
66091 
66092 [INTERNAL]  Number of input/output elements.
66093 
66094 ";
66095 
66096 %feature("docstring")  casadi::FunctionInternal::numel_out() const  "
66097 
66098 [INTERNAL]  Number of input/output elements.
66099 
66100 ";
66101 
66102 %feature("docstring")  casadi::FunctionInternal::getJacSparsity(casadi_int
66103 iind, casadi_int oind, bool symmetric) const  "
66104 
66105 [INTERNAL]  Generate the sparsity of a Jacobian block.
66106 
66107 ";
66108 
66109 %feature("docstring")  casadi::FunctionInternal::eval_dm(const std::vector<
66110 DM > &arg) const  "
66111 
66112 [INTERNAL]  Evaluate with DM matrices.
66113 
66114 ";
66115 
66116 %feature("docstring")  casadi::Conic::is_a(const std::string &type, bool
66117 recursive) const  "
66118 
66119 [INTERNAL]  Check if the function is of a particular type.
66120 
66121 ";
66122 
66123 %feature("docstring")  casadi::FunctionInternal::mapsum_mx(const
66124 std::vector< MX > &arg, const std::string &parallelization) "
66125 
66126 [INTERNAL]  Parallel evaluation.
66127 
66128 ";
66129 
66130 %feature("docstring")  casadi::FunctionInternal::jac() const  "
66131 
66132 [INTERNAL]  Return Jacobian of all input elements with respect to all output
66133 elements.
66134 
66135 ";
66136 
66137 %feature("docstring")  casadi::FunctionInternal::export_code(const
66138 std::string &lang, std::ostream &stream, const Dict &options) const  "
66139 
66140 [INTERNAL]  Export function in a specific language.
66141 
66142 ";
66143 
66144 %feature("docstring")  casadi::FunctionInternal::adjViaJac(casadi_int nadj)
66145 const  "
66146 
66147 [INTERNAL]  Calculate derivatives by multiplying the full Jacobian and
66148 multiplying.
66149 
66150 ";
66151 
66152 %feature("docstring")  casadi::FunctionInternal::dm_in(casadi_int ind) const
66153 "
66154 
66155 [INTERNAL]  Get function input(s) and output(s)
66156 
66157 ";
66158 
66159 %feature("docstring")  casadi::FunctionInternal::dm_in() const  "
66160 
66161 [INTERNAL]  Get function input(s) and output(s)
66162 
66163 ";
66164 
66165 %feature("docstring")  casadi::Conic::get_sparsity_in(casadi_int i)  "
66166 
66167 [INTERNAL]  Sparsities of function inputs and outputs.
66168 
66169 ";
66170 
66171 %feature("docstring")  casadi::FunctionInternal::sp_forward(const bvec_t
66172 **arg, bvec_t **res, casadi_int *iw, bvec_t *w, void *mem) const  "
66173 
66174 [INTERNAL]  Propagate sparsity forward.
66175 
66176 ";
66177 
66178 %feature("docstring")  casadi::SharedObjectInternal::weak() "
66179 
66180 [INTERNAL]  Get a weak reference to the object.
66181 
66182 ";
66183 
66184 %feature("docstring")  casadi::ProtoFunction::format_time(char *buffer,
66185 double time) const  "
66186 
66187 [INTERNAL]  Format time in a fixed width 8 format.
66188 
66189 ";
66190 
66191 %feature("docstring")  casadi::FunctionInternal::free_mx() const  "
66192 
66193 [INTERNAL]  Get free variables ( MX)
66194 
66195 ";
66196 
66197 %feature("docstring")
66198 casadi::FunctionInternal::codegen_incref(CodeGenerator &g) const  "
66199 
66200 [INTERNAL]  Codegen incref for dependencies.
66201 
66202 ";
66203 
66204 %feature("docstring")
66205 casadi::FunctionInternal::getJacSparsityHierarchical(casadi_int iind,
66206 casadi_int oind) const  "
66207 
66208 [INTERNAL]  A flavor of getJacSparsity that does hierarchical block
66209 structure recognition.
66210 
66211 ";
66212 
66213 %feature("docstring")  casadi::Conic::get_n_out()  "
66214 
66215 [INTERNAL]  Number of function inputs and outputs.
66216 
66217 ";
66218 
66219 %feature("docstring")  casadi::Conic::eval(const double **arg, double **res,
66220 casadi_int *iw, double *w, void *mem) const final "
66221 
66222 [INTERNAL]   Solve the QP.
66223 
66224 ";
66225 
66226 %feature("docstring")  casadi::FunctionInternal::setup(void *mem, const
66227 double **arg, double **res, casadi_int *iw, double *w) const  "
66228 
66229 [INTERNAL]  Set the (persistent and temporary) work vectors.
66230 
66231 ";
66232 
66233 %feature("docstring")  casadi::FunctionInternal::has_codegen() const  "
66234 
66235 [INTERNAL]  Is codegen supported?
66236 
66237 ";
66238 
66239 %feature("docstring")  casadi::FunctionInternal::sp_reverse(bvec_t **arg,
66240 bvec_t **res, casadi_int *iw, bvec_t *w, void *mem) const  "
66241 
66242 [INTERNAL]  Propagate sparsity backwards.
66243 
66244 ";
66245 
66246 %feature("docstring")  casadi::FunctionInternal::check_mat(const Sparsity
66247 &arg, const Sparsity &inp, casadi_int &npar) "
66248 
66249 [INTERNAL]  Helper function
66250 
66251 Parameters:
66252 -----------
66253 
66254 npar[in]:  normal usage: 1, disallow pararallel calls: -1
66255 
66256 npar[out]:  required number of parallel calls (or -1)
66257 
66258 ";
66259 
66260 %feature("docstring")  casadi::ProtoFunction::clear_mem() "
66261 
66262 [INTERNAL]  Clear all memory (called from destructor)
66263 
66264 ";
66265 
66266 %feature("docstring")  casadi::Qrqp::get_stats(void *mem) const  "
66267 
66268 [INTERNAL]  Get all statistics.
66269 
66270 ";
66271 
66272 %feature("docstring")  casadi::FunctionInternal::mx_in(casadi_int ind) const
66273 "
66274 
66275 [INTERNAL]  Get function input(s) and output(s)
66276 
66277 ";
66278 
66279 %feature("docstring")  casadi::FunctionInternal::mx_in() const  "
66280 
66281 [INTERNAL]  Get function input(s) and output(s)
66282 
66283 ";
66284 
66285 %feature("docstring")  casadi::FunctionInternal::generate_lifted(Function
66286 &vdef_fcn, Function &vinit_fcn) const  "
66287 
66288 [INTERNAL]  Extract the functions needed for the Lifted Newton method.
66289 
66290 ";
66291 
66292 %feature("docstring")  casadi::Qrqp::alloc_mem() const  "
66293 
66294 [INTERNAL]  Create memory block.
66295 
66296 ";
66297 
66298 %feature("docstring")  casadi::FunctionInternal::get_max_in(casadi_int ind)
66299 const  "
66300 
66301 [INTERNAL]  Get largest input value.
66302 
66303 ";
66304 
66305 %feature("docstring")  casadi::FunctionInternal::which_depends(const
66306 std::string &s_in, const std::vector< std::string > &s_out, casadi_int
66307 order, bool tr=false) const  "
66308 
66309 [INTERNAL]  Which variables enter with some order.
66310 
66311 Parameters:
66312 -----------
66313 
66314 s_in:   Input name
66315 
66316 s_out:   Output name(s)
66317 
66318 order:  Only 1 (linear) and 2 (nonlinear) allowed
66319 
66320 tr:  Flip the relationship. Return which expressions contain the variables
66321 
66322 ";
66323 
66324 %feature("docstring")  casadi::FunctionInternal::alloc_arg(size_t sz_arg,
66325 bool persistent=false) "
66326 
66327 [INTERNAL]  Ensure required length of arg field.
66328 
66329 ";
66330 
66331 %feature("docstring")  casadi::FunctionInternal::getAdaptorSolverName()
66332 const  "
66333 
66334 [INTERNAL]  Obtain solver name from Adaptor.
66335 
66336 ";
66337 
66338 %feature("docstring")  casadi::ProtoFunction::release(int mem) const  "
66339 
66340 [INTERNAL]  Release a memory object.
66341 
66342 ";
66343 
66344 %feature("docstring")  casadi::FunctionInternal::project_arg(const
66345 std::vector< M > &arg, casadi_int npar) const  "
66346 
66347 [INTERNAL]   Project sparsities.
66348 
66349 ";
66350 
66351 %feature("docstring")  casadi::FunctionInternal::get_free() const  "
66352 
66353 [INTERNAL]  Print free variables.
66354 
66355 ";
66356 
66357 %feature("docstring")  casadi::ProtoFunction::memory(int ind) const  "
66358 
66359 [INTERNAL]  Memory objects.
66360 
66361 ";
66362 
66363 %feature("docstring")  casadi::FunctionInternal::sz_res() const  "
66364 
66365 [INTERNAL]  Get required length of res field.
66366 
66367 ";
66368 
66369 %feature("docstring")  casadi::FunctionInternal::has_eval_dm() const  "
66370 
66371 [INTERNAL]  Evaluate with DM matrices.
66372 
66373 ";
66374 
66375 %feature("docstring")  casadi::FunctionInternal::has_free() const  "
66376 
66377 [INTERNAL]  Does the function have free variables.
66378 
66379 ";
66380 
66381 %feature("docstring")  casadi::FunctionInternal::sz_iw() const  "
66382 
66383 [INTERNAL]  Get required length of iw field.
66384 
66385 ";
66386 
66387 %feature("docstring")  casadi::FunctionInternal::replace_fseed(const
66388 std::vector< std::vector< M >> &fseed, casadi_int npar) const  "
66389 
66390 [INTERNAL]  Replace 0-by-0 forward seeds.
66391 
66392 ";
66393 
66394 %feature("docstring")  casadi::FunctionInternal::replace_fseed(const
66395 std::vector< std::vector< M > > &fseed, casadi_int npar) const  "
66396 
66397 [INTERNAL] ";
66398 
66399 %feature("docstring")  casadi::FunctionInternal::has_spfwd() const  "
66400 
66401 [INTERNAL]  Is the class able to propagate seeds through the algorithm?
66402 
66403 ";
66404 
66405 %feature("docstring")  casadi::FunctionInternal::symbolicAdjSeed(casadi_int
66406 nadj, const std::vector< MatType > &v) const  "
66407 
66408 [INTERNAL]  Symbolic expressions for the adjoint seeds.
66409 
66410 ";
66411 
66412 %feature("docstring")  casadi::FunctionInternal::get_min_in(casadi_int ind)
66413 const  "
66414 
66415 [INTERNAL]  Get smallest input value.
66416 
66417 ";
66418 
66419 %feature("docstring")  casadi::FunctionInternal::size2_in(casadi_int ind)
66420 const  "
66421 
66422 [INTERNAL]  Input/output dimensions.
66423 
66424 ";
66425 
66426 %feature("docstring")  casadi::FunctionInternal::sparsity_jac(casadi_int
66427 iind, casadi_int oind, bool compact, bool symmetric) const  "
66428 
66429 [INTERNAL]  Get, if necessary generate, the sparsity of a Jacobian block.
66430 
66431 ";
66432 
66433 %feature("docstring")  casadi::FunctionInternal::get_reltol() const  "
66434 
66435 [INTERNAL]  Get relative tolerance.
66436 
66437 ";
66438 
66439 %feature("docstring")  casadi::FunctionInternal::is_diff_out(casadi_int i) "
66440 
66441 [INTERNAL] ";
66442 
66443 %feature("docstring")  casadi::ProtoFunction::print(const char *fmt,...)
66444 const  "
66445 
66446 [INTERNAL]  C-style formatted printing during evaluation.
66447 
66448 ";
66449 
66450 %feature("docstring")
66451 casadi::FunctionInternal::codegen_alloc_mem(CodeGenerator &g) const  "
66452 
66453 [INTERNAL]  Codegen decref for alloc_mem.
66454 
66455 ";
66456 
66457 %feature("docstring")  casadi::Conic::get_sparsity_out(casadi_int i)  "
66458 
66459 [INTERNAL]  Sparsities of function inputs and outputs.
66460 
66461 ";
66462 
66463 %feature("docstring")  casadi::Conic::integer_support() const  "
66464 
66465 [INTERNAL]  Can discrete variables be treated.
66466 
66467 ";
66468 
66469 %feature("docstring")  casadi::FunctionInternal::sz_work(size_t &sz_arg,
66470 size_t &sz_res, size_t &sz_iw, size_t &sz_w) const  "
66471 
66472 [INTERNAL]  Get number of temporary variables needed.
66473 
66474 ";
66475 
66476 %feature("docstring")
66477 casadi::FunctionInternal::print_dimensions(std::ostream &stream) const  "
66478 
66479 [INTERNAL]  Print dimensions of inputs and outputs.
66480 
66481 ";
66482 
66483 %feature("docstring")
66484 casadi::FunctionInternal::jacobian_sparsity_filter(const Sparsity &sp) const
66485 "
66486 
66487 [INTERNAL]  Filter out nonzeros in the full sparsity jacobian according to
66488 is_diff_in/out.
66489 
66490 ";
66491 
66492 %feature("docstring")  casadi::FunctionInternal::reverse(casadi_int nadj)
66493 const  "
66494 
66495 [INTERNAL]  Return function that calculates adjoint derivatives
66496 reverse(nadj) returns a cached instance if available, and calls  Function
66497 get_reverse(casadi_int nadj) if no cached version is available.
66498 
66499 ";
66500 
66501 %feature("docstring")  casadi::FunctionInternal::fwd_seed(casadi_int nfwd)
66502 const  "
66503 
66504 [INTERNAL]  Symbolic expressions for the forward seeds.
66505 
66506 ";
66507 
66508 %feature("docstring")  casadi::FunctionInternal::project_res(const
66509 std::vector< M > &arg, casadi_int npar) const  "
66510 
66511 [INTERNAL]   Project sparsities.
66512 
66513 ";
66514 
66515 %feature("docstring")  casadi::Qrqp::solve(const double **arg, double **res,
66516 casadi_int *iw, double *w, void *mem) const  "
66517 
66518 [INTERNAL]   Solve the QP.
66519 
66520 ";
66521 
66522 %feature("docstring") casadi::casadi_solve "
66523 
66524 Solve the QP.
66525 
66526 ";
66527 
66528 %feature("docstring")  casadi::Qrqp::casadi_solve "
66529 
66530 Solve the QP.
66531 
66532 ";
66533 
66534 %feature("docstring")  casadi::FunctionInternal::check_res(const
66535 std::vector< M > &res, casadi_int &npar) const  "
66536 
66537 [INTERNAL]  Check if output arguments have correct length and dimensions.
66538 
66539 Raises errors.
66540 
66541 Parameters:
66542 -----------
66543 
66544 npar[in]:  normal usage: 1, disallow pararallel calls: -1
66545 
66546 npar:  max number of horizontal repetitions across all arguments (or -1)
66547 
66548 ";
66549 
66550 %feature("docstring")  casadi::FunctionInternal::sparsity_out(casadi_int
66551 ind) const  "
66552 
66553 [INTERNAL]  Input/output sparsity.
66554 
66555 ";
66556 
66557 %feature("docstring")  casadi::FunctionInternal::eval_mx(const MXVector
66558 &arg, MXVector &res, bool always_inline, bool never_inline) const  "
66559 
66560 [INTERNAL]  Evaluate with symbolic matrices.
66561 
66562 ";
66563 
66564 %feature("docstring")  casadi::FunctionInternal::nz_in(const std::vector< DM
66565 > &arg) const  "
66566 
66567 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
66568 
66569 ";
66570 
66571 %feature("docstring")  casadi::FunctionInternal::nz_in(const std::vector<
66572 double > &arg) const  "
66573 
66574 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
66575 
66576 ";
66577 
66578 %feature("docstring")
66579 casadi::FunctionInternal::getJacSparsityGen(casadi_int iind, casadi_int
66580 oind, bool symmetric, casadi_int gr_i=1, casadi_int gr_o=1) const  "
66581 
66582 [INTERNAL]  Get the sparsity pattern, forward mode.
66583 
66584 ";
66585 
66586 %feature("docstring")  casadi::FunctionInternal::get_forward(casadi_int
66587 nfwd, const std::string &name, const std::vector< std::string > &inames,
66588 const std::vector< std::string > &onames, const Dict &opts) const  "
66589 
66590 [INTERNAL]  Return function that calculates forward derivatives
66591 forward(nfwd) returns a cached instance if available, and calls  Function
66592 get_forward(casadi_int nfwd) if no cached version is available.
66593 
66594 ";
66595 
66596 %feature("docstring")  casadi::FunctionInternal::tocache(const Function &f,
66597 const std::string &suffix="") const  "
66598 
66599 [INTERNAL]  Save function to cache.
66600 
66601 ";
66602 
66603 %feature("docstring")  casadi::Qrqp::serialize_body(SerializingStream &s)
66604 const  "
66605 
66606 [INTERNAL]  Serialize an object without type information.
66607 
66608 ";
66609 
66610 %feature("docstring")  casadi::FunctionInternal::has_jac() const  "
66611 
66612 [INTERNAL]  Return Jacobian of all input elements with respect to all output
66613 elements.
66614 
66615 ";
66616 
66617 %feature("docstring")  casadi::FunctionInternal::size_in(casadi_int ind)
66618 const  "
66619 
66620 [INTERNAL]  Input/output dimensions.
66621 
66622 ";
66623 
66624 %feature("docstring")  casadi::ProtoFunction::serialize(SerializingStream
66625 &s) const  "
66626 
66627 [INTERNAL]  Serialize an object.
66628 
66629 ";
66630 
66631 %feature("docstring")  casadi::FunctionInternal::jit_dependencies(const
66632 std::string &fname) "
66633 
66634 [INTERNAL]  Jit dependencies.
66635 
66636 ";
66637 
66638 %feature("docstring")  casadi::FunctionInternal::has_jacobian() const  "
66639 
66640 [INTERNAL]  Return Jacobian of all input elements with respect to all output
66641 elements.
66642 
66643 ";
66644 
66645 %feature("docstring")
66646 casadi::FunctionInternal::instruction_input(casadi_int k) const  "
66647 
66648 [INTERNAL]  Get the (integer) input arguments of an atomic operation.
66649 
66650 ";
66651 
66652 %feature("docstring")
66653 casadi::FunctionInternal::codegen_declarations(CodeGenerator &g) const  "
66654 
66655 [INTERNAL]  Generate code for the declarations of the C function.
66656 
66657 ";
66658 
66659 %feature("docstring")
66660 casadi::FunctionInternal::codegen_sparsities(CodeGenerator &g) const  "
66661 
66662 [INTERNAL]  Codegen sparsities.
66663 
66664 ";
66665 
66666 %feature("docstring")  casadi::FunctionInternal::generate_out(const
66667 std::string &fname, double **res) const  "
66668 
66669 [INTERNAL] ";
66670 
66671 %feature("docstring")  casadi::Conic::get_n_in()  "
66672 
66673 [INTERNAL]  Number of function inputs and outputs.
66674 
66675 ";
66676 
66677 %feature("docstring")  casadi::FunctionInternal::print_option(const
66678 std::string &name, std::ostream &stream) const  "
66679 
66680 [INTERNAL]  Print all information there is to know about a certain option.
66681 
66682 ";
66683 
66684 %feature("docstring")  casadi::FunctionInternal::has_function(const
66685 std::string &fname) const  "
66686 
66687 [INTERNAL] ";
66688 
66689 %feature("docstring")  casadi::FunctionInternal::alloc_iw(size_t sz_iw, bool
66690 persistent=false) "
66691 
66692 [INTERNAL]  Ensure required length of iw field.
66693 
66694 ";
66695 
66696 %feature("docstring")  casadi::FunctionInternal::numel_in() const  "
66697 
66698 [INTERNAL]  Number of input/output elements.
66699 
66700 ";
66701 
66702 %feature("docstring")  casadi::FunctionInternal::numel_in(casadi_int ind)
66703 const  "
66704 
66705 [INTERNAL]  Number of input/output elements.
66706 
66707 ";
66708 
66709 %feature("docstring")  casadi::FunctionInternal::size1_out(casadi_int ind)
66710 const  "
66711 
66712 [INTERNAL]  Input/output dimensions.
66713 
66714 ";
66715 
66716 %feature("docstring")  casadi::FunctionInternal::sparsity_in(casadi_int ind)
66717 const  "
66718 
66719 [INTERNAL]  Input/output sparsity.
66720 
66721 ";
66722 
66723 %feature("docstring")  casadi::FunctionInternal::index_out(const std::string
66724 &name) const  "
66725 
66726 [INTERNAL]  Get output scheme index by name.
66727 
66728 ";
66729 
66730 %feature("docstring")  casadi::FunctionInternal::is_diff_in(casadi_int i) "
66731 
66732 [INTERNAL] ";
66733 
66734 %feature("docstring")  casadi::FunctionInternal::codegen(CodeGenerator &g,
66735 const std::string &fname) const  "
66736 
66737 [INTERNAL]  Generate code the function.
66738 
66739 ";
66740 
66741 %feature("docstring")  casadi::Qrqp::plugin_name() const  "
66742 
66743 [INTERNAL] ";
66744 
66745 %feature("docstring")  casadi::ProtoFunction::sprint(char *buf, size_t
66746 buf_sz, const char *fmt,...) const  "
66747 
66748 [INTERNAL]  C-style formatted printing to string.
66749 
66750 ";
66751 
66752 %feature("docstring")  casadi::Conic::generateNativeCode(std::ostream &file)
66753 const  "
66754 
66755 [INTERNAL]  Generate native code in the interfaced language for debugging
66756 
66757 ";
66758 
66759 %feature("docstring")  casadi::FunctionInternal::n_nodes() const  "
66760 
66761 [INTERNAL]  Number of nodes in the algorithm.
66762 
66763 ";
66764 
66765 %feature("docstring")  casadi::FunctionInternal::replace_aseed(const
66766 std::vector< std::vector< M >> &aseed, casadi_int npar) const  "
66767 
66768 [INTERNAL]  Replace 0-by-0 reverse seeds.
66769 
66770 ";
66771 
66772 %feature("docstring")  casadi::FunctionInternal::replace_aseed(const
66773 std::vector< std::vector< M > > &aseed, casadi_int npar) const  "
66774 
66775 [INTERNAL] ";
66776 
66777 %feature("docstring")  casadi::Conic::serialize_base_function() const  "
66778 
66779 [INTERNAL]  String used to identify the immediate FunctionInternal subclass.
66780 
66781 ";
66782 
66783 %feature("docstring")  casadi::FunctionInternal::call_reverse(const
66784 std::vector< MX > &arg, const std::vector< MX > &res, const std::vector<
66785 std::vector< MX > > &aseed, std::vector< std::vector< MX > > &asens, bool
66786 always_inline, bool never_inline) const  "
66787 
66788 [INTERNAL]  Reverse mode, virtual functions overloaded in derived classes.
66789 
66790 ";
66791 
66792 %feature("docstring")  casadi::FunctionInternal::call_reverse(const
66793 std::vector< SX > &arg, const std::vector< SX > &res, const std::vector<
66794 std::vector< SX > > &aseed, std::vector< std::vector< SX > > &asens, bool
66795 always_inline, bool never_inline) const  "
66796 
66797 [INTERNAL]  Reverse mode, virtual functions overloaded in derived classes.
66798 
66799 ";
66800 
66801 %feature("docstring")  casadi::FunctionInternal::nnz_in() const  "
66802 
66803 [INTERNAL]  Number of input/output nonzeros.
66804 
66805 ";
66806 
66807 %feature("docstring")  casadi::FunctionInternal::nnz_in(casadi_int ind)
66808 const  "
66809 
66810 [INTERNAL]  Number of input/output nonzeros.
66811 
66812 ";
66813 
66814 %feature("docstring")  casadi::FunctionInternal::eval_gen(const double
66815 **arg, double **res, casadi_int *iw, double *w, void *mem) const  "
66816 
66817 [INTERNAL]  Evaluate numerically.
66818 
66819 ";
66820 
66821 %feature("docstring")  casadi::FunctionInternal::eval_gen(const SXElem
66822 **arg, SXElem **res, casadi_int *iw, SXElem *w, void *mem) const  "
66823 
66824 [INTERNAL]  Evaluate a function, overloaded.
66825 
66826 ";
66827 
66828 %feature("docstring")  casadi::FunctionInternal::eval_gen(const bvec_t
66829 **arg, bvec_t **res, casadi_int *iw, bvec_t *w, void *mem) const  "
66830 
66831 [INTERNAL]  Evaluate a function, overloaded.
66832 
66833 ";
66834 
66835 %feature("docstring")  casadi::FunctionInternal::size1_in(casadi_int ind)
66836 const  "
66837 
66838 [INTERNAL]  Input/output dimensions.
66839 
66840 ";
66841 
66842 %feature("docstring")  casadi::FunctionInternal::get_abstol() const  "
66843 
66844 [INTERNAL]  Get absolute tolerance.
66845 
66846 ";
66847 
66848 %feature("docstring")  casadi::FunctionInternal::matching_res(const
66849 std::vector< M > &arg, casadi_int &npar) const  "
66850 
66851 [INTERNAL]  Check if output arguments that needs to be replaced.
66852 
66853 Raises errors
66854 
66855 Parameters:
66856 -----------
66857 
66858 npar[in]:  normal usage: 1, disallow pararallel calls: -1
66859 
66860 npar:  max number of horizontal repetitions across all arguments (or -1)
66861 
66862 ";
66863 
66864 %feature("docstring")  casadi::FunctionInternal::signature(const std::string
66865 &fname) const  "
66866 
66867 [INTERNAL]  Code generate the function.
66868 
66869 ";
66870 
66871 %feature("docstring")  casadi::FunctionInternal::check_arg(const
66872 std::vector< M > &arg, casadi_int &npar) const  "
66873 
66874 [INTERNAL]  Check if input arguments have correct length and dimensions.
66875 
66876 Raises errors.
66877 
66878 Parameters:
66879 -----------
66880 
66881 npar[in]:  normal usage: 1, disallow pararallel calls: -1
66882 
66883 npar:  max number of horizontal repetitions across all arguments (or -1)
66884 
66885 ";
66886 
66887 %feature("docstring")  casadi::FunctionInternal::get_jacobian_sparsity()
66888 const  "
66889 
66890 [INTERNAL]  Get Jacobian sparsity.
66891 
66892 ";
66893 
66894 %feature("docstring")  casadi::FunctionInternal::matching_arg(const
66895 std::vector< M > &arg, casadi_int &npar) const  "
66896 
66897 [INTERNAL]  Check if input arguments that needs to be replaced.
66898 
66899 Raises errors
66900 
66901 Parameters:
66902 -----------
66903 
66904 npar[in]:  normal usage: 1, disallow pararallel calls: -1
66905 
66906 npar:  max number of horizontal repetitions across all arguments (or -1)
66907 
66908 ";
66909 
66910 %feature("docstring")
66911 casadi::FunctionInternal::codegen_decref(CodeGenerator &g) const  "
66912 
66913 [INTERNAL]  Codegen decref for dependencies.
66914 
66915 ";
66916 
66917 %feature("docstring")  casadi::FunctionInternal::set_temp(void *mem, const
66918 double **arg, double **res, casadi_int *iw, double *w) const  "
66919 
66920 [INTERNAL]  Set the (temporary) work vectors.
66921 
66922 ";
66923 
66924 %feature("docstring")  casadi::FunctionInternal::has_reverse(casadi_int
66925 nadj) const  "
66926 
66927 [INTERNAL]  Return function that calculates adjoint derivatives
66928 reverse(nadj) returns a cached instance if available, and calls  Function
66929 get_reverse(casadi_int nadj) if no cached version is available.
66930 
66931 ";
66932 
66933 %feature("docstring")  casadi::FunctionInternal::jacobian() const  "
66934 
66935 [INTERNAL]  Return Jacobian of all input elements with respect to all output
66936 elements.
66937 
66938 ";
66939 
66940 %feature("docstring")  casadi::FunctionInternal::info() const  "
66941 
66942 [INTERNAL]  Obtain information about function
66943 
66944 ";
66945 
66946 %feature("docstring")  casadi::ProtoFunction::print_time(const std::map<
66947 std::string, FStats > &fstats) const  "
66948 
66949 [INTERNAL]  Print timing statistics.
66950 
66951 ";
66952 
66953 %feature("docstring")  casadi::FunctionInternal::index_in(const std::string
66954 &name) const  "
66955 
66956 [INTERNAL]  Get input scheme index by name.
66957 
66958 ";
66959 
66960 %feature("docstring")  casadi::FunctionInternal::get_reverse(casadi_int
66961 nadj, const std::string &name, const std::vector< std::string > &inames,
66962 const std::vector< std::string > &onames, const Dict &opts) const  "
66963 
66964 [INTERNAL]  Return function that calculates adjoint derivatives
66965 reverse(nadj) returns a cached instance if available, and calls  Function
66966 get_reverse(casadi_int nadj) if no cached version is available.
66967 
66968 ";
66969 
66970 %feature("docstring")  casadi::FunctionInternal::wrap() const  "
66971 
66972 [INTERNAL]  Wrap in an Function instance consisting of only one MX call.
66973 
66974 ";
66975 
66976 %feature("docstring")  casadi::FunctionInternal::call(const std::vector< M >
66977 &arg, std::vector< M > &res, bool always_inline, bool never_inline) const  "
66978 
66979 [INTERNAL]   Call a function, templated.
66980 
66981 ";
66982 
66983 %feature("docstring")  casadi::FunctionInternal::get_jac(const std::string
66984 &name, const std::vector< std::string > &inames, const std::vector<
66985 std::string > &onames, const Dict &opts) const  "
66986 
66987 [INTERNAL]  Return Jacobian of all input elements with respect to all output
66988 elements.
66989 
66990 ";
66991 
66992 %feature("docstring")  casadi::FunctionInternal::instruction_MX(casadi_int
66993 k) const  "
66994 
66995 [INTERNAL]  get MX expression associated with instruction
66996 
66997 ";
66998 
66999 %feature("docstring")  casadi::Qrqp::free_mem(void *mem) const  "
67000 
67001 [INTERNAL]  Free memory block.
67002 
67003 ";
67004 
67005 %feature("docstring")  casadi::FunctionInternal::has_forward(casadi_int
67006 nfwd) const  "
67007 
67008 [INTERNAL]  Return function that calculates forward derivatives
67009 forward(nfwd) returns a cached instance if available, and calls  Function
67010 get_forward(casadi_int nfwd) if no cached version is available.
67011 
67012 ";
67013 
67014 %feature("docstring")  casadi::SharedObjectInternal::getCount() const  "
67015 
67016 [INTERNAL]  Get the reference count.
67017 
67018 ";
67019 
67020 %feature("docstring")  casadi::FunctionInternal::jacobian_sparsity() const
67021 "
67022 
67023 [INTERNAL]  Get Jacobian sparsity.
67024 
67025 ";
67026 
67027 %feature("docstring")  casadi::FunctionInternal::self() const  "
67028 
67029 [INTERNAL]  Get a public class instance.
67030 
67031 ";
67032 
67033 %feature("docstring")  casadi::FunctionInternal::mx_out(casadi_int ind)
67034 const  "
67035 
67036 [INTERNAL]  Get function input(s) and output(s)
67037 
67038 ";
67039 
67040 %feature("docstring")  casadi::FunctionInternal::mx_out() const  "
67041 
67042 [INTERNAL]  Get function input(s) and output(s)
67043 
67044 ";
67045 
67046 %feature("docstring")  casadi::Qrqp::init(const Dict &opts)  "
67047 
67048 [INTERNAL]  Initialize.
67049 
67050 ";
67051 
67052 %feature("docstring")  casadi::FunctionInternal::generate_in(const
67053 std::string &fname, const double **arg) const  "
67054 
67055 [INTERNAL]  Export an input file that can be passed to generate C code with
67056 a main.
67057 
67058 ";
67059 
67060 %feature("docstring")  casadi::FunctionInternal::alloc_res(size_t sz_res,
67061 bool persistent=false) "
67062 
67063 [INTERNAL]  Ensure required length of res field.
67064 
67065 ";
67066 
67067 %feature("docstring")  casadi::ProtoFunction::construct(const Dict &opts) "
67068 
67069 [INTERNAL]  Construct Prepares the function for evaluation.
67070 
67071 ";
67072 
67073 %feature("docstring")  casadi::FunctionInternal::print_options(std::ostream
67074 &stream) const  "
67075 
67076 [INTERNAL]  Print list of options.
67077 
67078 ";
67079 
67080 %feature("docstring")
67081 casadi::FunctionInternal::instruction_output(casadi_int k) const  "
67082 
67083 [INTERNAL]  Get the (integer) output argument of an atomic operation.
67084 
67085 ";
67086 
67087 %feature("docstring")  casadi::FunctionInternal::sz_w() const  "
67088 
67089 [INTERNAL]  Get required length of w field.
67090 
67091 ";
67092 
67093 %feature("docstring")  casadi::FunctionInternal::get_partition(casadi_int
67094 iind, casadi_int oind, Sparsity &D1, Sparsity &D2, bool compact, bool
67095 symmetric, bool allow_forward, bool allow_reverse) const  "
67096 
67097 [INTERNAL]  Get the unidirectional or bidirectional partition.
67098 
67099 ";
67100 
67101 %feature("docstring")  casadi::Qrqp::class_name() const  "
67102 
67103 [INTERNAL]  Readable name of the internal class.
67104 
67105 ";
67106 
67107 %feature("docstring")  casadi::FunctionInternal::codegen_meta(CodeGenerator
67108 &g) const  "
67109 
67110 [INTERNAL]  Generate meta-information allowing a user to evaluate a
67111 generated function.
67112 
67113 ";
67114 
67115 %feature("docstring")  casadi::FunctionInternal::nnz_out() const  "
67116 
67117 [INTERNAL]  Number of input/output nonzeros.
67118 
67119 ";
67120 
67121 %feature("docstring")  casadi::FunctionInternal::nnz_out(casadi_int ind)
67122 const  "
67123 
67124 [INTERNAL]  Number of input/output nonzeros.
67125 
67126 ";
67127 
67128 %feature("docstring") casadi::Qrqp "
67129 
67130 'qrqp' plugin for Conic
67131 
67132 Solve QPs using an active-set method
67133 
67134 >List of available options
67135 
67136 +-----------------+-----------+--------------------------------------------+
67137 |       Id        |   Type    |                Description                 |
67138 +=================+===========+============================================+
67139 | constr_viol_tol | OT_DOUBLE | Constraint violation tolerance [1e-8].     |
67140 +-----------------+-----------+--------------------------------------------+
67141 | dual_inf_tol    | OT_DOUBLE | Dual feasibility violation tolerance       |
67142 |                 |           | [1e-8]                                     |
67143 +-----------------+-----------+--------------------------------------------+
67144 | max_iter        | OT_INT    | Maximum number of iterations [1000].       |
67145 +-----------------+-----------+--------------------------------------------+
67146 | min_lam         | OT_DOUBLE | Smallest multiplier treated as inactive    |
67147 |                 |           | for the initial active set [0].            |
67148 +-----------------+-----------+--------------------------------------------+
67149 | print_header    | OT_BOOL   | Print header [true].                       |
67150 +-----------------+-----------+--------------------------------------------+
67151 | print_info      | OT_BOOL   | Print info [true].                         |
67152 +-----------------+-----------+--------------------------------------------+
67153 | print_iter      | OT_BOOL   | Print iterations [true].                   |
67154 +-----------------+-----------+--------------------------------------------+
67155 | print_lincomb   | OT_BOOL   | Print dependant linear combinations of     |
67156 |                 |           | constraints [false]. Printed numbers are   |
67157 |                 |           | 0-based indices into the vector of [simple |
67158 |                 |           | bounds;linear bounds]                      |
67159 +-----------------+-----------+--------------------------------------------+
67160 
67161 Joel Andersson
67162 
67163 >List of available options
67164 
67165 +-----------------+---------------+------------------------+---------------+
67166 |       Id        |     Type      |      Description       |    Used in    |
67167 +=================+===============+========================+===============+
67168 | constr_viol_tol | OT_DOUBLE     | Constraint violation   | casadi::Qrqp  |
67169 |                 |               | tolerance [1e-8].      |               |
67170 +-----------------+---------------+------------------------+---------------+
67171 | discrete        | OT_BOOLVECTOR | Indicates which of the | casadi::Conic |
67172 |                 |               | variables are          |               |
67173 |                 |               | discrete, i.e.         |               |
67174 |                 |               | integer-valued         |               |
67175 +-----------------+---------------+------------------------+---------------+
67176 | dual_inf_tol    | OT_DOUBLE     | Dual feasibility       | casadi::Qrqp  |
67177 |                 |               | violation tolerance    |               |
67178 |                 |               | [1e-8]                 |               |
67179 +-----------------+---------------+------------------------+---------------+
67180 | error_on_fail   | OT_BOOL       | When the numerical     | casadi::Conic |
67181 |                 |               | process returns        |               |
67182 |                 |               | unsuccessfully, raise  |               |
67183 |                 |               | an error (default      |               |
67184 |                 |               | false).                |               |
67185 +-----------------+---------------+------------------------+---------------+
67186 | max_iter        | OT_INT        | Maximum number of      | casadi::Qrqp  |
67187 |                 |               | iterations [1000].     |               |
67188 +-----------------+---------------+------------------------+---------------+
67189 | min_lam         | OT_DOUBLE     | Smallest multiplier    | casadi::Qrqp  |
67190 |                 |               | treated as inactive    |               |
67191 |                 |               | for the initial active |               |
67192 |                 |               | set [0].               |               |
67193 +-----------------+---------------+------------------------+---------------+
67194 | print_header    | OT_BOOL       | Print header [true].   | casadi::Qrqp  |
67195 +-----------------+---------------+------------------------+---------------+
67196 | print_info      | OT_BOOL       | Print info [true].     | casadi::Qrqp  |
67197 +-----------------+---------------+------------------------+---------------+
67198 | print_iter      | OT_BOOL       | Print iterations       | casadi::Qrqp  |
67199 |                 |               | [true].                |               |
67200 +-----------------+---------------+------------------------+---------------+
67201 | print_lincomb   | OT_BOOL       | Print dependant linear | casadi::Qrqp  |
67202 |                 |               | combinations of        |               |
67203 |                 |               | constraints [false].   |               |
67204 |                 |               | Printed numbers are    |               |
67205 |                 |               | 0-based indices into   |               |
67206 |                 |               | the vector of [simple  |               |
67207 |                 |               | bounds;linear bounds]  |               |
67208 +-----------------+---------------+------------------------+---------------+
67209 | print_problem   | OT_BOOL       | Print a numeric        | casadi::Conic |
67210 |                 |               | description of the     |               |
67211 |                 |               | problem                |               |
67212 +-----------------+---------------+------------------------+---------------+
67213 
67214 Diagrams
67215 --------
67216 
67217 
67218 
67219 C++ includes: qrqp.hpp ";
67220 
67221 %feature("docstring")  casadi::FunctionInternal::codegen_mem_type() const  "
67222 
67223 [INTERNAL]  Thread-local memory object type.
67224 
67225 ";
67226 
67227 %feature("docstring")  casadi::Qrqp::init_mem(void *mem) const  "
67228 
67229 [INTERNAL]  Initalize memory block.
67230 
67231 ";
67232 
67233 %feature("docstring")  casadi::FunctionInternal::slice(const std::string
67234 &name, const std::vector< casadi_int > &order_in, const std::vector<
67235 casadi_int > &order_out, const Dict &opts) const  "
67236 
67237 [INTERNAL]  returns a new function with a selection of inputs/outputs of the
67238 original
67239 
67240 ";
67241 
67242 %feature("docstring")  casadi::FunctionInternal::sz_arg() const  "
67243 
67244 [INTERNAL]  Get required length of arg field.
67245 
67246 ";
67247 
67248 %feature("docstring")  casadi::FunctionInternal::ad_weight() const  "
67249 
67250 [INTERNAL]  Weighting factor for chosing forward/reverse mode.
67251 
67252 ";
67253 
67254 %feature("docstring") casadi::Qrqp::~Qrqp "
67255 
67256 [INTERNAL]  Destructor.
67257 
67258 ";
67259 
67260 %feature("docstring")  casadi::FunctionInternal::instruction_id(casadi_int
67261 k) const  "
67262 
67263 [INTERNAL]  Get an atomic operation operator index.
67264 
67265 ";
67266 
67267 %feature("docstring")  casadi::FunctionInternal::generate_options(bool
67268 is_temp=false) const  "
67269 
67270 [INTERNAL]  Reconstruct options dict.
67271 
67272 ";
67273 
67274 %feature("docstring")  casadi::FunctionInternal::incache(const std::string
67275 &fname, Function &f, const std::string &suffix="") const  "
67276 
67277 [INTERNAL]  Get function in cache.
67278 
67279 ";
67280 
67281 %feature("docstring")  casadi::FunctionInternal::symbolic_output(const
67282 std::vector< MX > &arg) const  "
67283 
67284 [INTERNAL]  Get a vector of symbolic variables corresponding to the outputs.
67285 
67286 ";
67287 
67288 %feature("docstring")  casadi::FunctionInternal::eval_sx(const SXElem **arg,
67289 SXElem **res, casadi_int *iw, SXElem *w, void *mem) const  "
67290 
67291 [INTERNAL]  Evaluate with symbolic scalars.
67292 
67293 ";
67294 
67295 %feature("docstring")  casadi::FunctionInternal::get_function() const  "
67296 
67297 [INTERNAL] ";
67298 
67299 %feature("docstring")  casadi::FunctionInternal::get_function(const
67300 std::string &name) const  "
67301 
67302 [INTERNAL] ";
67303 
67304 %feature("docstring")  casadi::FunctionInternal::convert_arg(const
67305 std::vector< M > &arg) const  "
67306 
67307 [INTERNAL]  Convert from/to input/output lists/map.
67308 
67309 ";
67310 
67311 %feature("docstring")  casadi::FunctionInternal::convert_arg(const std::map<
67312 std::string, M > &arg) const  "
67313 
67314 [INTERNAL]  Convert from/to input/output lists/map.
67315 
67316 ";
67317 
67318 %feature("docstring")  casadi::FunctionInternal::sx_in(casadi_int ind) const
67319 "
67320 
67321 [INTERNAL]  Get function input(s) and output(s)
67322 
67323 ";
67324 
67325 %feature("docstring")  casadi::FunctionInternal::sx_in() const  "
67326 
67327 [INTERNAL]  Get function input(s) and output(s)
67328 
67329 ";
67330 
67331 %feature("docstring")  casadi::Conic::check_inputs(const double *lbx, const
67332 double *ubx, const double *lba, const double *uba) const  "
67333 
67334 [INTERNAL]  Check if the numerical values of the supplied bounds make sense.
67335 
67336 ";
67337 
67338 %feature("docstring")
67339 casadi::FunctionInternal::instruction_constant(casadi_int k) const  "
67340 
67341 [INTERNAL]  Get the floating point output argument of an atomic operation.
67342 
67343 ";
67344 
67345 %feature("docstring")  casadi::FunctionInternal::replace_res(const
67346 std::vector< M > &res, casadi_int npar) const  "
67347 
67348 [INTERNAL]  Replace 0-by-0 outputs.
67349 
67350 ";
67351 
67352 %feature("docstring")  casadi::FunctionInternal::alloc_w(size_t sz_w, bool
67353 persistent=false) "
67354 
67355 [INTERNAL]  Ensure required length of w field.
67356 
67357 ";
67358 
67359 %feature("docstring")  casadi::FunctionInternal::factory(const std::string
67360 &name, const std::vector< std::string > &s_in, const std::vector<
67361 std::string > &s_out, const Function::AuxOut &aux, const Dict &opts) const
67362 "
67363 
67364 [INTERNAL] ";
67365 
67366 %feature("docstring")  casadi::FunctionInternal::n_instructions() const  "
67367 
67368 [INTERNAL]  Get the number of atomic operations.
67369 
67370 ";
67371 
67372 %feature("docstring")  casadi::FunctionInternal::wrap_as_needed(const Dict
67373 &opts) const  "
67374 
67375 [INTERNAL]  Wrap in an Function instance consisting of only one MX call.
67376 
67377 ";
67378 
67379 %feature("docstring")  casadi::FunctionInternal::has_sprev() const  "
67380 
67381 [INTERNAL]  Is the class able to propagate seeds through the algorithm?
67382 
67383 ";
67384 
67385 %feature("docstring")  casadi::FunctionInternal::alloc(const Function &f,
67386 bool persistent=false) "
67387 
67388 [INTERNAL]  Ensure work vectors long enough to evaluate function.
67389 
67390 ";
67391 
67392 %feature("docstring")  casadi::FunctionInternal::finalize()  "
67393 
67394 [INTERNAL]  Finalize the object creation.
67395 
67396 ";
67397 
67398 %feature("docstring")  casadi::FunctionInternal::disp_more(std::ostream
67399 &stream) const  "
67400 
67401 [INTERNAL]  Print more.
67402 
67403 ";
67404 
67405 %feature("docstring")  casadi::FunctionInternal::fwdViaJac(casadi_int nfwd)
67406 const  "
67407 
67408 [INTERNAL]  Calculate derivatives by multiplying the full Jacobian and
67409 multiplying.
67410 
67411 ";
67412 
67413 %feature("docstring")  casadi::Conic::get_name_out(casadi_int i)  "
67414 
67415 [INTERNAL]  Names of function input and outputs.
67416 
67417 ";
67418 
67419 %feature("docstring")  casadi::FunctionInternal::all_scalar() const  "
67420 
67421 [INTERNAL]  Are all inputs and outputs scalar.
67422 
67423 ";
67424 
67425 %feature("docstring")  casadi::FunctionInternal::call_forward(const
67426 std::vector< MX > &arg, const std::vector< MX > &res, const std::vector<
67427 std::vector< MX > > &fseed, std::vector< std::vector< MX > > &fsens, bool
67428 always_inline, bool never_inline) const  "
67429 
67430 [INTERNAL]  Forward mode AD, virtual functions overloaded in derived
67431 classes.
67432 
67433 ";
67434 
67435 %feature("docstring")  casadi::FunctionInternal::call_forward(const
67436 std::vector< SX > &arg, const std::vector< SX > &res, const std::vector<
67437 std::vector< SX > > &fseed, std::vector< std::vector< SX > > &fsens, bool
67438 always_inline, bool never_inline) const  "
67439 
67440 [INTERNAL]  Forward mode AD, virtual functions overloaded in derived
67441 classes.
67442 
67443 ";
67444 
67445 %feature("docstring")  casadi::Conic::get_name_in(casadi_int i)  "
67446 
67447 [INTERNAL]  Names of function input and outputs.
67448 
67449 ";
67450 
67451 %feature("docstring")  casadi::FunctionInternal::convert_res(const
67452 std::vector< M > &res) const  "
67453 
67454 [INTERNAL]  Convert from/to input/output lists/map.
67455 
67456 ";
67457 
67458 %feature("docstring")  casadi::FunctionInternal::convert_res(const std::map<
67459 std::string, M > &res) const  "
67460 
67461 [INTERNAL]  Convert from/to input/output lists/map.
67462 
67463 ";
67464 
67465 %feature("docstring")  casadi::FunctionInternal::sx_out(casadi_int ind)
67466 const  "
67467 
67468 [INTERNAL]  Get function input(s) and output(s)
67469 
67470 ";
67471 
67472 %feature("docstring")  casadi::FunctionInternal::sx_out() const  "
67473 
67474 [INTERNAL]  Get function input(s) and output(s)
67475 
67476 ";
67477 
67478 %feature("docstring")  casadi::FunctionInternal::uses_output() const  "
67479 
67480 [INTERNAL]  Do the derivative functions need nondifferentiated outputs?
67481 
67482 ";
67483 
67484 %feature("docstring")  casadi::Conic::set_work(void *mem, const double
67485 **&arg, double **&res, casadi_int *&iw, double *&w) const  "
67486 
67487 [INTERNAL]  Set the (persistent) work vectors.
67488 
67489 ";
67490 
67491 %feature("docstring")  casadi::Conic::get_default_in(casadi_int ind) const
67492 "
67493 
67494 [INTERNAL]  Get default input value.
67495 
67496 ";
67497 
67498 %feature("docstring")  casadi::FunctionInternal::free_sx() const  "
67499 
67500 [INTERNAL]  Get free variables (SX)
67501 
67502 ";
67503 
67504 %feature("docstring")  casadi::FunctionInternal::generate_dependencies(const
67505 std::string &fname, const Dict &opts) const  "
67506 
67507 [INTERNAL]  Export / Generate C code for the dependency function.
67508 
67509 ";
67510 
67511 %feature("docstring")  casadi::FunctionInternal::size_out(casadi_int ind)
67512 const  "
67513 
67514 [INTERNAL]  Input/output dimensions.
67515 
67516 ";
67517 
67518 %feature("docstring")  casadi::FunctionInternal::replace_arg(const
67519 std::vector< M > &arg, casadi_int npar) const  "
67520 
67521 [INTERNAL]  Replace 0-by-0 inputs.
67522 
67523 ";
67524 
67525 %feature("docstring")  casadi::Qrqp::codegen_body(CodeGenerator &g) const  "
67526 
67527 [INTERNAL]  Generate code for the function body.
67528 
67529 ";
67530 
67531 %feature("docstring")  casadi::FunctionInternal::disp(std::ostream &stream,
67532 bool more) const  "
67533 
67534 [INTERNAL]  Display object.
67535 
67536 ";
67537 
67538 %feature("docstring")  casadi::FunctionInternal::nz_out(const std::vector<
67539 DM > &res) const  "
67540 
67541 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
67542 
67543 ";
67544 
67545 %feature("docstring")  casadi::FunctionInternal::nz_out(const std::vector<
67546 double > &res) const  "
67547 
67548 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
67549 
67550 ";
67551 
67552 %feature("docstring")
67553 casadi::FunctionInternal::getJacSparsityHierarchicalSymm(casadi_int iind,
67554 casadi_int oind) const  "
67555 
67556 [INTERNAL]  A flavor of getJacSparsity that does hierarchical block
67557 structure recognition for symmetric Jacobians
67558 
67559 ";
67560 
67561 %feature("docstring") casadi::Qrqp::Qrqp(const std::string &name, const
67562 std::map< std::string, Sparsity > &st) "
67563 
67564 [INTERNAL]  Create a new Solver.
67565 
67566 ";
67567 
67568 %feature("docstring")  casadi::FunctionInternal::size2_out(casadi_int ind)
67569 const  "
67570 
67571 [INTERNAL]  Input/output dimensions.
67572 
67573 ";
67574 
67575 %feature("docstring")  casadi::Conic::psd_support() const  "
67576 
67577 [INTERNAL]  Can psd constraints be treated.
67578 
67579 ";
67580 
67581 %feature("docstring")  casadi::FunctionInternal::instructions_sx() const  "
67582 
67583 [INTERNAL]  get SX expression associated with instructions
67584 
67585 ";
67586 
67587 %feature("docstring")  casadi::ProtoFunction::checkout() const  "
67588 
67589 [INTERNAL]  Checkout a memory object.
67590 
67591 ";
67592 
67593 %feature("docstring")  casadi::FunctionInternal::call_gen(const MXVector
67594 &arg, MXVector &res, casadi_int npar, bool always_inline, bool never_inline)
67595 const  "
67596 
67597 [INTERNAL]   Call a function, overloaded.
67598 
67599 ";
67600 
67601 %feature("docstring")  casadi::FunctionInternal::call_gen(const std::vector<
67602 MatrixCommon > &arg, std::vector< MatrixCommon > &res, casadi_int npar, bool
67603 always_inline, bool never_inline) const  "
67604 
67605 [INTERNAL]   Call a function, overloaded.
67606 
67607 ";
67608 
67609 %feature("docstring")
67610 casadi::FunctionInternal::codegen_init_mem(CodeGenerator &g) const  "
67611 
67612 [INTERNAL]  Codegen decref for init_mem.
67613 
67614 ";
67615 
67616 %feature("docstring")  casadi::FunctionInternal::codegen_mem(CodeGenerator
67617 &g, const std::string &index="mem") const  "
67618 
67619 [INTERNAL]  Get thread-local memory object.
67620 
67621 ";
67622 
67623 %feature("docstring")  casadi::FunctionInternal::sp_weight() const  "
67624 
67625 [INTERNAL]  Weighting factor for chosing forward/reverse mode, sparsity
67626 propagation.
67627 
67628 ";
67629 
67630 %feature("docstring")  casadi::Qrqp::get_options() const  "
67631 
67632 [INTERNAL]  Options.
67633 
67634 ";
67635 
67636 %feature("docstring")  casadi::FunctionInternal::has_jacobian_sparsity()
67637 const  "
67638 
67639 [INTERNAL]  Get Jacobian sparsity.
67640 
67641 ";
67642 
67643 %feature("docstring")  casadi::Conic::serialize_type(SerializingStream &s)
67644 const  "
67645 
67646 [INTERNAL]  Serialize type information.
67647 
67648 ";
67649 
67650 
67651 // File: classcasadi_1_1Qrsqp.xml
67652 %feature("docstring")  casadi::FunctionInternal::wrap_as_needed(const Dict
67653 &opts) const  "
67654 
67655 [INTERNAL]  Wrap in an Function instance consisting of only one MX call.
67656 
67657 ";
67658 
67659 %feature("docstring")  casadi::FunctionInternal::mx_in(casadi_int ind) const
67660 "
67661 
67662 [INTERNAL]  Get function input(s) and output(s)
67663 
67664 ";
67665 
67666 %feature("docstring")  casadi::FunctionInternal::mx_in() const  "
67667 
67668 [INTERNAL]  Get function input(s) and output(s)
67669 
67670 ";
67671 
67672 %feature("docstring")  casadi::FunctionInternal::alloc_arg(size_t sz_arg,
67673 bool persistent=false) "
67674 
67675 [INTERNAL]  Ensure required length of arg field.
67676 
67677 ";
67678 
67679 %feature("docstring")  casadi::FunctionInternal::codegen_mem_type() const  "
67680 
67681 [INTERNAL]  Thread-local memory object type.
67682 
67683 ";
67684 
67685 %feature("docstring")  casadi::FunctionInternal::eval_sx(const SXElem **arg,
67686 SXElem **res, casadi_int *iw, SXElem *w, void *mem) const  "
67687 
67688 [INTERNAL]  Evaluate with symbolic scalars.
67689 
67690 ";
67691 
67692 %feature("docstring")
67693 casadi::FunctionInternal::codegen_incref(CodeGenerator &g) const  "
67694 
67695 [INTERNAL]  Codegen incref for dependencies.
67696 
67697 ";
67698 
67699 %feature("docstring")  casadi::ProtoFunction::memory(int ind) const  "
67700 
67701 [INTERNAL]  Memory objects.
67702 
67703 ";
67704 
67705 %feature("docstring")  casadi::FunctionInternal::is_diff_out(casadi_int i) "
67706 
67707 [INTERNAL] ";
67708 
67709 %feature("docstring")  casadi::Nlpsol::is_a(const std::string &type, bool
67710 recursive) const  "
67711 
67712 [INTERNAL]  Check if the function is of a particular type.
67713 
67714 ";
67715 
67716 %feature("docstring")  casadi::FunctionInternal::jacobian() const  "
67717 
67718 [INTERNAL]  Return Jacobian of all input elements with respect to all output
67719 elements.
67720 
67721 ";
67722 
67723 %feature("docstring")  casadi::OracleFunction::get_function() const  "
67724 
67725 [INTERNAL]  Get list of dependency functions -1 Indicates irregularity.
67726 
67727 ";
67728 
67729 %feature("docstring")  casadi::OracleFunction::get_function(const
67730 std::string &name) const  "
67731 
67732 [INTERNAL] ";
67733 
67734 %feature("docstring")  casadi::FunctionInternal::size_in(casadi_int ind)
67735 const  "
67736 
67737 [INTERNAL]  Input/output dimensions.
67738 
67739 ";
67740 
67741 %feature("docstring")  casadi::FunctionInternal::alloc(const Function &f,
67742 bool persistent=false) "
67743 
67744 [INTERNAL]  Ensure work vectors long enough to evaluate function.
67745 
67746 ";
67747 
67748 %feature("docstring")
67749 casadi::FunctionInternal::instruction_constant(casadi_int k) const  "
67750 
67751 [INTERNAL]  Get the floating point output argument of an atomic operation.
67752 
67753 ";
67754 
67755 %feature("docstring")  casadi::FunctionInternal::setup(void *mem, const
67756 double **arg, double **res, casadi_int *iw, double *w) const  "
67757 
67758 [INTERNAL]  Set the (persistent and temporary) work vectors.
67759 
67760 ";
67761 
67762 %feature("docstring")  casadi::FunctionInternal::codegen(CodeGenerator &g,
67763 const std::string &fname) const  "
67764 
67765 [INTERNAL]  Generate code the function.
67766 
67767 ";
67768 
67769 %feature("docstring")  casadi::Nlpsol::setOptionsFromFile(const std::string
67770 &file) "
67771 
67772 [INTERNAL]  Read options from parameter xml.
67773 
67774 ";
67775 
67776 %feature("docstring")  casadi::FunctionInternal::eval_dm(const std::vector<
67777 DM > &arg) const  "
67778 
67779 [INTERNAL]  Evaluate with DM matrices.
67780 
67781 ";
67782 
67783 %feature("docstring")  casadi::FunctionInternal::sz_work(size_t &sz_arg,
67784 size_t &sz_res, size_t &sz_iw, size_t &sz_w) const  "
67785 
67786 [INTERNAL]  Get number of temporary variables needed.
67787 
67788 ";
67789 
67790 %feature("docstring")  casadi::FunctionInternal::sparsity_jac(casadi_int
67791 iind, casadi_int oind, bool compact, bool symmetric) const  "
67792 
67793 [INTERNAL]  Get, if necessary generate, the sparsity of a Jacobian block.
67794 
67795 ";
67796 
67797 %feature("docstring")  casadi::FunctionInternal::check_arg(const
67798 std::vector< M > &arg, casadi_int &npar) const  "
67799 
67800 [INTERNAL]  Check if input arguments have correct length and dimensions.
67801 
67802 Raises errors.
67803 
67804 Parameters:
67805 -----------
67806 
67807 npar[in]:  normal usage: 1, disallow pararallel calls: -1
67808 
67809 npar:  max number of horizontal repetitions across all arguments (or -1)
67810 
67811 ";
67812 
67813 %feature("docstring")  casadi::FunctionInternal::print_options(std::ostream
67814 &stream) const  "
67815 
67816 [INTERNAL]  Print list of options.
67817 
67818 ";
67819 
67820 %feature("docstring")  casadi::FunctionInternal::size2_in(casadi_int ind)
67821 const  "
67822 
67823 [INTERNAL]  Input/output dimensions.
67824 
67825 ";
67826 
67827 %feature("docstring")  casadi::FunctionInternal::index_in(const std::string
67828 &name) const  "
67829 
67830 [INTERNAL]  Get input scheme index by name.
67831 
67832 ";
67833 
67834 %feature("docstring")  casadi::OracleFunction::set_temp(void *mem, const
67835 double **arg, double **res, casadi_int *iw, double *w) const  "
67836 
67837 [INTERNAL]  Set the work vectors.
67838 
67839 ";
67840 
67841 %feature("docstring")
67842 casadi::FunctionInternal::codegen_free_mem(CodeGenerator &g) const  "
67843 
67844 [INTERNAL]  Codegen for free_mem.
67845 
67846 ";
67847 
67848 %feature("docstring")  casadi::Nlpsol::get_n_out()  "
67849 
67850 [INTERNAL]  Number of function inputs and outputs.
67851 
67852 ";
67853 
67854 %feature("docstring")  casadi::FunctionInternal::replace_aseed(const
67855 std::vector< std::vector< M >> &aseed, casadi_int npar) const  "
67856 
67857 [INTERNAL]  Replace 0-by-0 reverse seeds.
67858 
67859 ";
67860 
67861 %feature("docstring")  casadi::FunctionInternal::replace_aseed(const
67862 std::vector< std::vector< M > > &aseed, casadi_int npar) const  "
67863 
67864 [INTERNAL] ";
67865 
67866 %feature("docstring")  casadi::FunctionInternal::convert_res(const
67867 std::vector< M > &res) const  "
67868 
67869 [INTERNAL]  Convert from/to input/output lists/map.
67870 
67871 ";
67872 
67873 %feature("docstring")  casadi::FunctionInternal::convert_res(const std::map<
67874 std::string, M > &res) const  "
67875 
67876 [INTERNAL]  Convert from/to input/output lists/map.
67877 
67878 ";
67879 
67880 %feature("docstring")  casadi::FunctionInternal::instructions_sx() const  "
67881 
67882 [INTERNAL]  get SX expression associated with instructions
67883 
67884 ";
67885 
67886 %feature("docstring")  casadi::Nlpsol::serialize_body(SerializingStream &s)
67887 const  "
67888 
67889 [INTERNAL]  Serialize an object without type information.
67890 
67891 ";
67892 
67893 %feature("docstring")  casadi::OracleFunction::monitored(const std::string
67894 &name) const  "
67895 
67896 [INTERNAL] ";
67897 
67898 %feature("docstring")  casadi::FunctionInternal::index_out(const std::string
67899 &name) const  "
67900 
67901 [INTERNAL]  Get output scheme index by name.
67902 
67903 ";
67904 
67905 %feature("docstring")  casadi::FunctionInternal::export_code(const
67906 std::string &lang, std::ostream &stream, const Dict &options) const  "
67907 
67908 [INTERNAL]  Export function in a specific language.
67909 
67910 ";
67911 
67912 %feature("docstring")
67913 casadi::FunctionInternal::instruction_input(casadi_int k) const  "
67914 
67915 [INTERNAL]  Get the (integer) input arguments of an atomic operation.
67916 
67917 ";
67918 
67919 %feature("docstring")  casadi::ProtoFunction::sprint(char *buf, size_t
67920 buf_sz, const char *fmt,...) const  "
67921 
67922 [INTERNAL]  C-style formatted printing to string.
67923 
67924 ";
67925 
67926 %feature("docstring")
67927 casadi::FunctionInternal::codegen_sparsities(CodeGenerator &g) const  "
67928 
67929 [INTERNAL]  Codegen sparsities.
67930 
67931 ";
67932 
67933 %feature("docstring")  casadi::ProtoFunction::format_time(char *buffer,
67934 double time) const  "
67935 
67936 [INTERNAL]  Format time in a fixed width 8 format.
67937 
67938 ";
67939 
67940 %feature("docstring")  casadi::FunctionInternal::replace_fseed(const
67941 std::vector< std::vector< M >> &fseed, casadi_int npar) const  "
67942 
67943 [INTERNAL]  Replace 0-by-0 forward seeds.
67944 
67945 ";
67946 
67947 %feature("docstring")  casadi::FunctionInternal::replace_fseed(const
67948 std::vector< std::vector< M > > &fseed, casadi_int npar) const  "
67949 
67950 [INTERNAL] ";
67951 
67952 %feature("docstring")  casadi::FunctionInternal::alloc_iw(size_t sz_iw, bool
67953 persistent=false) "
67954 
67955 [INTERNAL]  Ensure required length of iw field.
67956 
67957 ";
67958 
67959 %feature("docstring")
67960 casadi::FunctionInternal::getJacSparsityHierarchical(casadi_int iind,
67961 casadi_int oind) const  "
67962 
67963 [INTERNAL]  A flavor of getJacSparsity that does hierarchical block
67964 structure recognition.
67965 
67966 ";
67967 
67968 %feature("docstring")  casadi::ProtoFunction::construct(const Dict &opts) "
67969 
67970 [INTERNAL]  Construct Prepares the function for evaluation.
67971 
67972 ";
67973 
67974 %feature("docstring")  casadi::FunctionInternal::call_gen(const MXVector
67975 &arg, MXVector &res, casadi_int npar, bool always_inline, bool never_inline)
67976 const  "
67977 
67978 [INTERNAL]   Call a function, overloaded.
67979 
67980 ";
67981 
67982 %feature("docstring")  casadi::FunctionInternal::call_gen(const std::vector<
67983 MatrixCommon > &arg, std::vector< MatrixCommon > &res, casadi_int npar, bool
67984 always_inline, bool never_inline) const  "
67985 
67986 [INTERNAL]   Call a function, overloaded.
67987 
67988 ";
67989 
67990 %feature("docstring")  casadi::FunctionInternal::self() const  "
67991 
67992 [INTERNAL]  Get a public class instance.
67993 
67994 ";
67995 
67996 %feature("docstring")  casadi::FunctionInternal::forward(casadi_int nfwd)
67997 const  "
67998 
67999 [INTERNAL]  Return function that calculates forward derivatives
68000 forward(nfwd) returns a cached instance if available, and calls  Function
68001 get_forward(casadi_int nfwd) if no cached version is available.
68002 
68003 ";
68004 
68005 %feature("docstring")  casadi::FunctionInternal::getJacSparsity(casadi_int
68006 iind, casadi_int oind, bool symmetric) const  "
68007 
68008 [INTERNAL]  Generate the sparsity of a Jacobian block.
68009 
68010 ";
68011 
68012 %feature("docstring")  casadi::FunctionInternal::check_res(const
68013 std::vector< M > &res, casadi_int &npar) const  "
68014 
68015 [INTERNAL]  Check if output arguments have correct length and dimensions.
68016 
68017 Raises errors.
68018 
68019 Parameters:
68020 -----------
68021 
68022 npar[in]:  normal usage: 1, disallow pararallel calls: -1
68023 
68024 npar:  max number of horizontal repetitions across all arguments (or -1)
68025 
68026 ";
68027 
68028 %feature("docstring")  casadi::Nlpsol::nlpsol_codegen_body(CodeGenerator &g)
68029 const  "
68030 
68031 [INTERNAL]  Generate code for the function body.
68032 
68033 ";
68034 
68035 %feature("docstring")  casadi::FunctionInternal::codegen_body(CodeGenerator
68036 &g) const  "
68037 
68038 [INTERNAL]  Generate code for the function body.
68039 
68040 ";
68041 
68042 %feature("docstring")  casadi::FunctionInternal::generate_out(const
68043 std::string &fname, double **res) const  "
68044 
68045 [INTERNAL] ";
68046 
68047 %feature("docstring")  casadi::OracleFunction::has_function(const
68048 std::string &fname) const  "
68049 
68050 [INTERNAL] ";
68051 
68052 %feature("docstring") casadi::Qrsqp::~Qrsqp "
68053 
68054 [INTERNAL] ";
68055 
68056 %feature("docstring")  casadi::FunctionInternal::get_free() const  "
68057 
68058 [INTERNAL]  Print free variables.
68059 
68060 ";
68061 
68062 %feature("docstring")  casadi::FunctionInternal::sparsity_in(casadi_int ind)
68063 const  "
68064 
68065 [INTERNAL]  Input/output sparsity.
68066 
68067 ";
68068 
68069 %feature("docstring")
68070 casadi::FunctionInternal::codegen_declarations(CodeGenerator &g) const  "
68071 
68072 [INTERNAL]  Generate code for the declarations of the C function.
68073 
68074 ";
68075 
68076 %feature("docstring")  casadi::Nlpsol::serialize_base_function() const  "
68077 
68078 [INTERNAL]  String used to identify the immediate FunctionInternal subclass.
68079 
68080 ";
68081 
68082 %feature("docstring")  casadi::Nlpsol::kkt() const  "
68083 
68084 [INTERNAL] ";
68085 
68086 %feature("docstring")  casadi::SharedObjectInternal::getCount() const  "
68087 
68088 [INTERNAL]  Get the reference count.
68089 
68090 ";
68091 
68092 %feature("docstring")  casadi::Nlpsol::integer_support() const  "
68093 
68094 [INTERNAL]  Can discrete variables be treated.
68095 
68096 ";
68097 
68098 %feature("docstring") casadi::Qrsqp "
68099 
68100 'sqsqp' plugin for Nlpsol
68101 
68102 A textbook SQPMethod
68103 
68104 >List of available options
68105 
68106 +--------------------+---------------+--------------------+----------------+
68107 |         Id         |     Type      |    Description     |    Used in     |
68108 +====================+===============+====================+================+
68109 | beta               | OT_DOUBLE     | Line-search        | casadi::Qrsqp  |
68110 |                    |               | parameter,         |                |
68111 |                    |               | restoration factor |                |
68112 |                    |               | of stepsize        |                |
68113 +--------------------+---------------+--------------------+----------------+
68114 | bound_consistency  | OT_BOOL       | Ensure that        | casadi::Nlpsol |
68115 |                    |               | primal-dual        |                |
68116 |                    |               | solution is        |                |
68117 |                    |               | consistent with    |                |
68118 |                    |               | the bounds         |                |
68119 +--------------------+---------------+--------------------+----------------+
68120 | c1                 | OT_DOUBLE     | Armijo condition,  | casadi::Qrsqp  |
68121 |                    |               | coefficient of     |                |
68122 |                    |               | decrease in merit  |                |
68123 +--------------------+---------------+--------------------+----------------+
68124 | calc_f             | OT_BOOL       | Calculate 'f' in   | casadi::Nlpsol |
68125 |                    |               | the Nlpsol base    |                |
68126 |                    |               | class              |                |
68127 +--------------------+---------------+--------------------+----------------+
68128 | calc_g             | OT_BOOL       | Calculate 'g' in   | casadi::Nlpsol |
68129 |                    |               | the Nlpsol base    |                |
68130 |                    |               | class              |                |
68131 +--------------------+---------------+--------------------+----------------+
68132 | calc_lam_p         | OT_BOOL       | Calculate 'lam_p'  | casadi::Nlpsol |
68133 |                    |               | in the Nlpsol base |                |
68134 |                    |               | class              |                |
68135 +--------------------+---------------+--------------------+----------------+
68136 | calc_lam_x         | OT_BOOL       | Calculate 'lam_x'  | casadi::Nlpsol |
68137 |                    |               | in the Nlpsol base |                |
68138 |                    |               | class              |                |
68139 +--------------------+---------------+--------------------+----------------+
68140 | calc_multipliers   | OT_BOOL       | Calculate Lagrange | casadi::Nlpsol |
68141 |                    |               | multipliers in the |                |
68142 |                    |               | Nlpsol base class  |                |
68143 +--------------------+---------------+--------------------+----------------+
68144 | discrete           | OT_BOOLVECTOR | Indicates which of | casadi::Nlpsol |
68145 |                    |               | the variables are  |                |
68146 |                    |               | discrete, i.e.     |                |
68147 |                    |               | integer-valued     |                |
68148 +--------------------+---------------+--------------------+----------------+
68149 | error_on_fail      | OT_BOOL       | When the numerical | casadi::Nlpsol |
68150 |                    |               | process returns    |                |
68151 |                    |               | unsuccessfully,    |                |
68152 |                    |               | raise an error     |                |
68153 |                    |               | (default false).   |                |
68154 +--------------------+---------------+--------------------+----------------+
68155 | eval_errors_fatal  | OT_BOOL       | When errors occur  | casadi::Nlpsol |
68156 |                    |               | during evaluation  |                |
68157 |                    |               | of f,g,...,stop    |                |
68158 |                    |               | the iterations     |                |
68159 +--------------------+---------------+--------------------+----------------+
68160 | hessian_approximat | OT_STRING     | limited-           | casadi::Qrsqp  |
68161 | ion                |               | memory|exact       |                |
68162 +--------------------+---------------+--------------------+----------------+
68163 | ignore_check_vec   | OT_BOOL       | If set to true,    | casadi::Nlpsol |
68164 |                    |               | the input shape of |                |
68165 |                    |               | F will not be      |                |
68166 |                    |               | checked.           |                |
68167 +--------------------+---------------+--------------------+----------------+
68168 | iteration_callback | OT_FUNCTION   | A function that    | casadi::Nlpsol |
68169 |                    |               | will be called at  |                |
68170 |                    |               | each iteration     |                |
68171 |                    |               | with the solver as |                |
68172 |                    |               | input. Check       |                |
68173 |                    |               | documentation of   |                |
68174 |                    |               | Callback .         |                |
68175 +--------------------+---------------+--------------------+----------------+
68176 | iteration_callback | OT_BOOL       | If set to true,    | casadi::Nlpsol |
68177 | _ignore_errors     |               | errors thrown by   |                |
68178 |                    |               | iteration_callback |                |
68179 |                    |               | will be ignored.   |                |
68180 +--------------------+---------------+--------------------+----------------+
68181 | iteration_callback | OT_INT        | Only call the      | casadi::Nlpsol |
68182 | _step              |               | callback function  |                |
68183 |                    |               | every few          |                |
68184 |                    |               | iterations.        |                |
68185 +--------------------+---------------+--------------------+----------------+
68186 | lbfgs_memory       | OT_INT        | Size of L-BFGS     | casadi::Qrsqp  |
68187 |                    |               | memory.            |                |
68188 +--------------------+---------------+--------------------+----------------+
68189 | max_iter           | OT_INT        | Maximum number of  | casadi::Qrsqp  |
68190 |                    |               | SQP iterations     |                |
68191 +--------------------+---------------+--------------------+----------------+
68192 | max_iter_ls        | OT_INT        | Maximum number of  | casadi::Qrsqp  |
68193 |                    |               | linesearch         |                |
68194 |                    |               | iterations         |                |
68195 +--------------------+---------------+--------------------+----------------+
68196 | merit_memory       | OT_INT        | Size of memory to  | casadi::Qrsqp  |
68197 |                    |               | store history of   |                |
68198 |                    |               | merit function     |                |
68199 |                    |               | values             |                |
68200 +--------------------+---------------+--------------------+----------------+
68201 | min_iter           | OT_INT        | Minimum number of  | casadi::Qrsqp  |
68202 |                    |               | SQP iterations     |                |
68203 +--------------------+---------------+--------------------+----------------+
68204 | min_lam            | OT_DOUBLE     | Minimum allowed    | casadi::Nlpsol |
68205 |                    |               | multiplier value   |                |
68206 +--------------------+---------------+--------------------+----------------+
68207 | min_step_size      | OT_DOUBLE     | The size (inf-     | casadi::Qrsqp  |
68208 |                    |               | norm) of the step  |                |
68209 |                    |               | size should not    |                |
68210 |                    |               | become smaller     |                |
68211 |                    |               | than this.         |                |
68212 +--------------------+---------------+--------------------+----------------+
68213 | no_nlp_grad        | OT_BOOL       | Prevent the        | casadi::Nlpsol |
68214 |                    |               | creation of the    |                |
68215 |                    |               | 'nlp_grad'         |                |
68216 |                    |               | function           |                |
68217 +--------------------+---------------+--------------------+----------------+
68218 | oracle_options     | OT_DICT       | Options to be      | casadi::Nlpsol |
68219 |                    |               | passed to the      |                |
68220 |                    |               | oracle function    |                |
68221 +--------------------+---------------+--------------------+----------------+
68222 | print_header       | OT_BOOL       | Print the header   | casadi::Qrsqp  |
68223 |                    |               | with problem       |                |
68224 |                    |               | statistics         |                |
68225 +--------------------+---------------+--------------------+----------------+
68226 | print_iteration    | OT_BOOL       | Print the          | casadi::Qrsqp  |
68227 |                    |               | iterations         |                |
68228 +--------------------+---------------+--------------------+----------------+
68229 | qpsol              | OT_STRING     | The QP solver to   | casadi::Qrsqp  |
68230 |                    |               | be used by the SQP |                |
68231 |                    |               | method [qrqp]      |                |
68232 +--------------------+---------------+--------------------+----------------+
68233 | qpsol_options      | OT_DICT       | Options to be      | casadi::Qrsqp  |
68234 |                    |               | passed to the QP   |                |
68235 |                    |               | solver             |                |
68236 +--------------------+---------------+--------------------+----------------+
68237 | regularize         | OT_BOOL       | Automatic          | casadi::Qrsqp  |
68238 |                    |               | regularization of  |                |
68239 |                    |               | Lagrange Hessian.  |                |
68240 +--------------------+---------------+--------------------+----------------+
68241 | sens_linsol        | OT_STRING     | Linear solver used | casadi::Nlpsol |
68242 |                    |               | for parametric     |                |
68243 |                    |               | sensitivities      |                |
68244 |                    |               | (default 'qr').    |                |
68245 +--------------------+---------------+--------------------+----------------+
68246 | sens_linsol_option | OT_DICT       | Linear solver      | casadi::Nlpsol |
68247 | s                  |               | options used for   |                |
68248 |                    |               | parametric         |                |
68249 |                    |               | sensitivities.     |                |
68250 +--------------------+---------------+--------------------+----------------+
68251 | tol_du             | OT_DOUBLE     | Stopping criterion | casadi::Qrsqp  |
68252 |                    |               | for dual           |                |
68253 |                    |               | infeasability      |                |
68254 +--------------------+---------------+--------------------+----------------+
68255 | tol_pr             | OT_DOUBLE     | Stopping criterion | casadi::Qrsqp  |
68256 |                    |               | for primal         |                |
68257 |                    |               | infeasibility      |                |
68258 +--------------------+---------------+--------------------+----------------+
68259 | verbose_init       | OT_BOOL       | Print out timing   | casadi::Nlpsol |
68260 |                    |               | information about  |                |
68261 |                    |               | the different      |                |
68262 |                    |               | stages of          |                |
68263 |                    |               | initialization     |                |
68264 +--------------------+---------------+--------------------+----------------+
68265 | warn_initial_bound | OT_BOOL       | Warn if the        | casadi::Nlpsol |
68266 | s                  |               | initial guess does |                |
68267 |                    |               | not satisfy LBX    |                |
68268 |                    |               | and UBX            |                |
68269 +--------------------+---------------+--------------------+----------------+
68270 
68271 Diagrams
68272 --------
68273 
68274 
68275 
68276 C++ includes: qrsqp.hpp ";
68277 
68278 %feature("docstring")  casadi::FunctionInternal::numel_out(casadi_int ind)
68279 const  "
68280 
68281 [INTERNAL]  Number of input/output elements.
68282 
68283 ";
68284 
68285 %feature("docstring")  casadi::FunctionInternal::numel_out() const  "
68286 
68287 [INTERNAL]  Number of input/output elements.
68288 
68289 ";
68290 
68291 %feature("docstring")  casadi::Nlpsol::disp_more(std::ostream &stream) const
68292 "
68293 
68294 [INTERNAL]  Print description.
68295 
68296 ";
68297 
68298 %feature("docstring")  casadi::Qrsqp::set_work(void *mem, const double
68299 **&arg, double **&res, casadi_int *&iw, double *&w) const  "
68300 
68301 [INTERNAL]  Set the (persistent) work vectors.
68302 
68303 ";
68304 
68305 %feature("docstring")  casadi::OracleFunction::calc_function(OracleMemory
68306 *m, const std::string &fcn, const double *const *arg=nullptr) const  "
68307 
68308 [INTERNAL] ";
68309 
68310 %feature("docstring")  casadi::FunctionInternal::jac() const  "
68311 
68312 [INTERNAL]  Return Jacobian of all input elements with respect to all output
68313 elements.
68314 
68315 ";
68316 
68317 %feature("docstring")  casadi::FunctionInternal::generate_options(bool
68318 is_temp=false) const  "
68319 
68320 [INTERNAL]  Reconstruct options dict.
68321 
68322 ";
68323 
68324 %feature("docstring")  casadi::FunctionInternal::alloc_res(size_t sz_res,
68325 bool persistent=false) "
68326 
68327 [INTERNAL]  Ensure required length of res field.
68328 
68329 ";
68330 
68331 %feature("docstring")  casadi::FunctionInternal::has_jac() const  "
68332 
68333 [INTERNAL]  Return Jacobian of all input elements with respect to all output
68334 elements.
68335 
68336 ";
68337 
68338 %feature("docstring")  casadi::FunctionInternal::n_instructions() const  "
68339 
68340 [INTERNAL]  Get the number of atomic operations.
68341 
68342 ";
68343 
68344 %feature("docstring")  casadi::FunctionInternal::matching_res(const
68345 std::vector< M > &arg, casadi_int &npar) const  "
68346 
68347 [INTERNAL]  Check if output arguments that needs to be replaced.
68348 
68349 Raises errors
68350 
68351 Parameters:
68352 -----------
68353 
68354 npar[in]:  normal usage: 1, disallow pararallel calls: -1
68355 
68356 npar:  max number of horizontal repetitions across all arguments (or -1)
68357 
68358 ";
68359 
68360 %feature("docstring")  casadi::ProtoFunction::clear_mem() "
68361 
68362 [INTERNAL]  Clear all memory (called from destructor)
68363 
68364 ";
68365 
68366 %feature("docstring")  casadi::FunctionInternal::slice(const std::string
68367 &name, const std::vector< casadi_int > &order_in, const std::vector<
68368 casadi_int > &order_out, const Dict &opts) const  "
68369 
68370 [INTERNAL]  returns a new function with a selection of inputs/outputs of the
68371 original
68372 
68373 ";
68374 
68375 %feature("docstring")  casadi::Nlpsol::init_mem(void *mem) const  "
68376 
68377 [INTERNAL]  Initalize memory block.
68378 
68379 ";
68380 
68381 %feature("docstring")  casadi::FunctionInternal::adjViaJac(casadi_int nadj)
68382 const  "
68383 
68384 [INTERNAL]  Calculate derivatives by multiplying the full Jacobian and
68385 multiplying.
68386 
68387 ";
68388 
68389 %feature("docstring")  casadi::FunctionInternal::replace_arg(const
68390 std::vector< M > &arg, casadi_int npar) const  "
68391 
68392 [INTERNAL]  Replace 0-by-0 inputs.
68393 
68394 ";
68395 
68396 %feature("docstring")  casadi::ProtoFunction::print(const char *fmt,...)
68397 const  "
68398 
68399 [INTERNAL]  C-style formatted printing during evaluation.
68400 
68401 ";
68402 
68403 %feature("docstring")  casadi::Nlpsol::get_n_in()  "
68404 
68405 [INTERNAL]  Number of function inputs and outputs.
68406 
68407 ";
68408 
68409 %feature("docstring")  casadi::FunctionInternal::mapsum_mx(const
68410 std::vector< MX > &arg, const std::string &parallelization) "
68411 
68412 [INTERNAL]  Parallel evaluation.
68413 
68414 ";
68415 
68416 %feature("docstring")  casadi::OracleFunction::finalize()  "
68417 
68418 [INTERNAL]  Finalize initialization.
68419 
68420 ";
68421 
68422 %feature("docstring")  casadi::OracleFunction::oracle() const  "
68423 
68424 [INTERNAL]  Get oracle.
68425 
68426 ";
68427 
68428 %feature("docstring")  casadi::Qrsqp::get_options() const  "
68429 
68430 [INTERNAL]  Options.
68431 
68432 ";
68433 
68434 %feature("docstring")  casadi::FunctionInternal::has_eval_dm() const  "
68435 
68436 [INTERNAL]  Evaluate with DM matrices.
68437 
68438 ";
68439 
68440 %feature("docstring")  casadi::FunctionInternal::call_reverse(const
68441 std::vector< MX > &arg, const std::vector< MX > &res, const std::vector<
68442 std::vector< MX > > &aseed, std::vector< std::vector< MX > > &asens, bool
68443 always_inline, bool never_inline) const  "
68444 
68445 [INTERNAL]  Reverse mode, virtual functions overloaded in derived classes.
68446 
68447 ";
68448 
68449 %feature("docstring")  casadi::FunctionInternal::call_reverse(const
68450 std::vector< SX > &arg, const std::vector< SX > &res, const std::vector<
68451 std::vector< SX > > &aseed, std::vector< std::vector< SX > > &asens, bool
68452 always_inline, bool never_inline) const  "
68453 
68454 [INTERNAL]  Reverse mode, virtual functions overloaded in derived classes.
68455 
68456 ";
68457 
68458 %feature("docstring")  casadi::FunctionInternal::symbolicAdjSeed(casadi_int
68459 nadj, const std::vector< MatType > &v) const  "
68460 
68461 [INTERNAL]  Symbolic expressions for the adjoint seeds.
68462 
68463 ";
68464 
68465 %feature("docstring")  casadi::FunctionInternal::jacobian_sparsity() const
68466 "
68467 
68468 [INTERNAL]  Get Jacobian sparsity.
68469 
68470 ";
68471 
68472 %feature("docstring")  casadi::FunctionInternal::has_spfwd() const  "
68473 
68474 [INTERNAL]  Is the class able to propagate seeds through the algorithm?
68475 
68476 ";
68477 
68478 %feature("docstring")  casadi::FunctionInternal::factory(const std::string
68479 &name, const std::vector< std::string > &s_in, const std::vector<
68480 std::string > &s_out, const Function::AuxOut &aux, const Dict &opts) const
68481 "
68482 
68483 [INTERNAL] ";
68484 
68485 %feature("docstring")  casadi::FunctionInternal::is_diff_in(casadi_int i) "
68486 
68487 [INTERNAL] ";
68488 
68489 %feature("docstring")  casadi::Qrsqp::get_stats(void *mem) const  "
68490 
68491 [INTERNAL]  Get all statistics.
68492 
68493 ";
68494 
68495 %feature("docstring")  casadi::OracleFunction::expand() "
68496 
68497 [INTERNAL] ";
68498 
68499 %feature("docstring")  casadi::FunctionInternal::disp(std::ostream &stream,
68500 bool more) const  "
68501 
68502 [INTERNAL]  Display object.
68503 
68504 ";
68505 
68506 %feature("docstring")  casadi::FunctionInternal::sz_res() const  "
68507 
68508 [INTERNAL]  Get required length of res field.
68509 
68510 ";
68511 
68512 %feature("docstring")  casadi::Nlpsol::getReducedHessian() "
68513 
68514 [INTERNAL] ";
68515 
68516 %feature("docstring")  casadi::Nlpsol::get_default_in(casadi_int ind) const
68517 "
68518 
68519 [INTERNAL]  Get default input value.
68520 
68521 ";
68522 
68523 %feature("docstring")  casadi::ProtoFunction::checkout() const  "
68524 
68525 [INTERNAL]  Checkout a memory object.
68526 
68527 ";
68528 
68529 %feature("docstring")  casadi::FunctionInternal::instruction_MX(casadi_int
68530 k) const  "
68531 
68532 [INTERNAL]  get MX expression associated with instruction
68533 
68534 ";
68535 
68536 %feature("docstring")  casadi::FunctionInternal::ad_weight() const  "
68537 
68538 [INTERNAL]  Weighting factor for chosing forward/reverse mode.
68539 
68540 ";
68541 
68542 %feature("docstring")  casadi::FunctionInternal::sx_out(casadi_int ind)
68543 const  "
68544 
68545 [INTERNAL]  Get function input(s) and output(s)
68546 
68547 ";
68548 
68549 %feature("docstring")  casadi::FunctionInternal::sx_out() const  "
68550 
68551 [INTERNAL]  Get function input(s) and output(s)
68552 
68553 ";
68554 
68555 %feature("docstring")  casadi::OracleFunction::set_function(const Function
68556 &fcn, const std::string &fname, bool jit=false) "
68557 
68558 [INTERNAL]  Register the function for evaluation and statistics gathering
68559 
68560 ";
68561 
68562 %feature("docstring")  casadi::OracleFunction::set_function(const Function
68563 &fcn) "
68564 
68565 [INTERNAL]  Register the function for evaluation and statistics gathering
68566 
68567 ";
68568 
68569 %feature("docstring")  casadi::ProtoFunction::release(int mem) const  "
68570 
68571 [INTERNAL]  Release a memory object.
68572 
68573 ";
68574 
68575 %feature("docstring")  casadi::Nlpsol::check_inputs(void *mem) const  "
68576 
68577 [INTERNAL]  Check if the inputs correspond to a well-posed problem.
68578 
68579 ";
68580 
68581 %feature("docstring")  casadi::FunctionInternal::nz_in(const std::vector< DM
68582 > &arg) const  "
68583 
68584 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
68585 
68586 ";
68587 
68588 %feature("docstring")  casadi::FunctionInternal::nz_in(const std::vector<
68589 double > &arg) const  "
68590 
68591 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
68592 
68593 ";
68594 
68595 %feature("docstring")
68596 casadi::FunctionInternal::getJacSparsityGen(casadi_int iind, casadi_int
68597 oind, bool symmetric, casadi_int gr_i=1, casadi_int gr_o=1) const  "
68598 
68599 [INTERNAL]  Get the sparsity pattern, forward mode.
68600 
68601 ";
68602 
68603 %feature("docstring")  casadi::FunctionInternal::all_scalar() const  "
68604 
68605 [INTERNAL]  Are all inputs and outputs scalar.
68606 
68607 ";
68608 
68609 %feature("docstring")  casadi::FunctionInternal::call(const std::vector< M >
68610 &arg, std::vector< M > &res, bool always_inline, bool never_inline) const  "
68611 
68612 [INTERNAL]   Call a function, templated.
68613 
68614 ";
68615 
68616 %feature("docstring")  casadi::Nlpsol::has_forward(casadi_int nfwd) const  "
68617 
68618 [INTERNAL]  Generate a function that calculates forward mode derivatives.
68619 
68620 ";
68621 
68622 %feature("docstring")  casadi::Nlpsol::uses_output() const  "
68623 
68624 [INTERNAL]  Do the derivative functions need nondifferentiated outputs?
68625 
68626 ";
68627 
68628 %feature("docstring")  casadi::FunctionInternal::mx_out(casadi_int ind)
68629 const  "
68630 
68631 [INTERNAL]  Get function input(s) and output(s)
68632 
68633 ";
68634 
68635 %feature("docstring")  casadi::FunctionInternal::mx_out() const  "
68636 
68637 [INTERNAL]  Get function input(s) and output(s)
68638 
68639 ";
68640 
68641 %feature("docstring")  casadi::Nlpsol::get_sparsity_in(casadi_int i)  "
68642 
68643 [INTERNAL]  Sparsities of function inputs and outputs.
68644 
68645 ";
68646 
68647 %feature("docstring")  casadi::FunctionInternal::sp_forward(const bvec_t
68648 **arg, bvec_t **res, casadi_int *iw, bvec_t *w, void *mem) const  "
68649 
68650 [INTERNAL]  Propagate sparsity forward.
68651 
68652 ";
68653 
68654 %feature("docstring")  casadi::FunctionInternal::codegen_mem(CodeGenerator
68655 &g, const std::string &index="mem") const  "
68656 
68657 [INTERNAL]  Get thread-local memory object.
68658 
68659 ";
68660 
68661 %feature("docstring")  casadi::FunctionInternal::get_jac(const std::string
68662 &name, const std::vector< std::string > &inames, const std::vector<
68663 std::string > &onames, const Dict &opts) const  "
68664 
68665 [INTERNAL]  Return Jacobian of all input elements with respect to all output
68666 elements.
68667 
68668 ";
68669 
68670 %feature("docstring")  casadi::FunctionInternal::fwd_seed(casadi_int nfwd)
68671 const  "
68672 
68673 [INTERNAL]  Symbolic expressions for the forward seeds.
68674 
68675 ";
68676 
68677 %feature("docstring")
68678 casadi::FunctionInternal::codegen_decref(CodeGenerator &g) const  "
68679 
68680 [INTERNAL]  Codegen decref for dependencies.
68681 
68682 ";
68683 
68684 %feature("docstring")  casadi::FunctionInternal::instruction_id(casadi_int
68685 k) const  "
68686 
68687 [INTERNAL]  Get an atomic operation operator index.
68688 
68689 ";
68690 
68691 %feature("docstring")  casadi::FunctionInternal::replace_res(const
68692 std::vector< M > &res, casadi_int npar) const  "
68693 
68694 [INTERNAL]  Replace 0-by-0 outputs.
68695 
68696 ";
68697 
68698 %feature("docstring")  casadi::OracleFunction::generate_dependencies(const
68699 std::string &fname, const Dict &opts) const  "
68700 
68701 [INTERNAL]  Export / Generate C code for the generated functions.
68702 
68703 ";
68704 
68705 %feature("docstring")  casadi::FunctionInternal::project_res(const
68706 std::vector< M > &arg, casadi_int npar) const  "
68707 
68708 [INTERNAL]   Project sparsities.
68709 
68710 ";
68711 
68712 %feature("docstring")  casadi::FunctionInternal::sz_arg() const  "
68713 
68714 [INTERNAL]  Get required length of arg field.
68715 
68716 ";
68717 
68718 %feature("docstring")  casadi::FunctionInternal::size_out(casadi_int ind)
68719 const  "
68720 
68721 [INTERNAL]  Input/output dimensions.
68722 
68723 ";
68724 
68725 %feature("docstring")  casadi::FunctionInternal::matching_arg(const
68726 std::vector< M > &arg, casadi_int &npar) const  "
68727 
68728 [INTERNAL]  Check if input arguments that needs to be replaced.
68729 
68730 Raises errors
68731 
68732 Parameters:
68733 -----------
68734 
68735 npar[in]:  normal usage: 1, disallow pararallel calls: -1
68736 
68737 npar:  max number of horizontal repetitions across all arguments (or -1)
68738 
68739 ";
68740 
68741 %feature("docstring")  casadi::Nlpsol::get_forward(casadi_int nfwd, const
68742 std::string &name, const std::vector< std::string > &inames, const
68743 std::vector< std::string > &onames, const Dict &opts) const  "
68744 
68745 [INTERNAL]  Generate a function that calculates forward mode derivatives.
68746 
68747 ";
68748 
68749 %feature("docstring")  casadi::Qrsqp::alloc_mem() const  "
68750 
68751 [INTERNAL]  Create memory block.
68752 
68753 ";
68754 
68755 %feature("docstring")  casadi::FunctionInternal::get_jacobian_sparsity()
68756 const  "
68757 
68758 [INTERNAL]  Get Jacobian sparsity.
68759 
68760 ";
68761 
68762 %feature("docstring")  casadi::Qrsqp::free_mem(void *mem) const  "
68763 
68764 [INTERNAL]  Free memory block.
68765 
68766 ";
68767 
68768 %feature("docstring")  casadi::Nlpsol::get_sparsity_out(casadi_int i)  "
68769 
68770 [INTERNAL]  Sparsities of function inputs and outputs.
68771 
68772 ";
68773 
68774 %feature("docstring")  casadi::ProtoFunction::serialize(SerializingStream
68775 &s) const  "
68776 
68777 [INTERNAL]  Serialize an object.
68778 
68779 ";
68780 
68781 %feature("docstring")
68782 casadi::FunctionInternal::jacobian_sparsity_filter(const Sparsity &sp) const
68783 "
68784 
68785 [INTERNAL]  Filter out nonzeros in the full sparsity jacobian according to
68786 is_diff_in/out.
68787 
68788 ";
68789 
68790 %feature("docstring")  casadi::Qrsqp::print_iteration() const  "
68791 
68792 [INTERNAL]  Print iteration header.
68793 
68794 ";
68795 
68796 %feature("docstring")  casadi::Qrsqp::print_iteration(casadi_int iter,
68797 double obj, double pr_inf, double du_inf, double dx_norm, double rg,
68798 casadi_int ls_trials, bool ls_success) const  "
68799 
68800 [INTERNAL]  Print iteration.
68801 
68802 ";
68803 
68804 %feature("docstring")  casadi::FunctionInternal::sz_w() const  "
68805 
68806 [INTERNAL]  Get required length of w field.
68807 
68808 ";
68809 
68810 %feature("docstring")  casadi::FunctionInternal::nnz_in() const  "
68811 
68812 [INTERNAL]  Number of input/output nonzeros.
68813 
68814 ";
68815 
68816 %feature("docstring")  casadi::FunctionInternal::nnz_in(casadi_int ind)
68817 const  "
68818 
68819 [INTERNAL]  Number of input/output nonzeros.
68820 
68821 ";
68822 
68823 %feature("docstring")  casadi::FunctionInternal::definition() const  "
68824 
68825 [INTERNAL]  Get function signature: name:(inputs)->(outputs)
68826 
68827 ";
68828 
68829 %feature("docstring")  casadi::SharedObjectInternal::weak() "
68830 
68831 [INTERNAL]  Get a weak reference to the object.
68832 
68833 ";
68834 
68835 %feature("docstring") casadi::Qrsqp::Qrsqp(const std::string &name, const
68836 Function &nlp) "
68837 
68838 [INTERNAL] ";
68839 
68840 %feature("docstring")  casadi::Qrsqp::solve_QP(QrsqpMemory *m, const double
68841 *H, const double *g, const double *lbdz, const double *ubdz, const double
68842 *A, double *x_opt, double *dlam) const  "
68843 
68844 [INTERNAL] ";
68845 
68846 %feature("docstring")  casadi::FunctionInternal::codegen_name(const
68847 CodeGenerator &g, bool ns=true) const  "
68848 
68849 [INTERNAL]  Get name in codegen.
68850 
68851 ";
68852 
68853 %feature("docstring")  casadi::Nlpsol::eval(const double **arg, double
68854 **res, casadi_int *iw, double *w, void *mem) const final "
68855 
68856 [INTERNAL]  Evaluate numerically.
68857 
68858 ";
68859 
68860 %feature("docstring")  casadi::FunctionInternal::generate_in(const
68861 std::string &fname, const double **arg) const  "
68862 
68863 [INTERNAL]  Export an input file that can be passed to generate C code with
68864 a main.
68865 
68866 ";
68867 
68868 %feature("docstring")
68869 casadi::FunctionInternal::print_dimensions(std::ostream &stream) const  "
68870 
68871 [INTERNAL]  Print dimensions of inputs and outputs.
68872 
68873 ";
68874 
68875 %feature("docstring")  casadi::FunctionInternal::sp_reverse(bvec_t **arg,
68876 bvec_t **res, casadi_int *iw, bvec_t *w, void *mem) const  "
68877 
68878 [INTERNAL]  Propagate sparsity backwards.
68879 
68880 ";
68881 
68882 %feature("docstring")  casadi::FunctionInternal::codegen_meta(CodeGenerator
68883 &g) const  "
68884 
68885 [INTERNAL]  Generate meta-information allowing a user to evaluate a
68886 generated function.
68887 
68888 ";
68889 
68890 %feature("docstring")  casadi::FunctionInternal::sz_iw() const  "
68891 
68892 [INTERNAL]  Get required length of iw field.
68893 
68894 ";
68895 
68896 %feature("docstring")  casadi::FunctionInternal::nnz_out() const  "
68897 
68898 [INTERNAL]  Number of input/output nonzeros.
68899 
68900 ";
68901 
68902 %feature("docstring")  casadi::FunctionInternal::nnz_out(casadi_int ind)
68903 const  "
68904 
68905 [INTERNAL]  Number of input/output nonzeros.
68906 
68907 ";
68908 
68909 %feature("docstring")  casadi::FunctionInternal::sx_in(casadi_int ind) const
68910 "
68911 
68912 [INTERNAL]  Get function input(s) and output(s)
68913 
68914 ";
68915 
68916 %feature("docstring")  casadi::FunctionInternal::sx_in() const  "
68917 
68918 [INTERNAL]  Get function input(s) and output(s)
68919 
68920 ";
68921 
68922 %feature("docstring")  casadi::FunctionInternal::has_jacobian_sparsity()
68923 const  "
68924 
68925 [INTERNAL]  Get Jacobian sparsity.
68926 
68927 ";
68928 
68929 %feature("docstring")  casadi::FunctionInternal::project_arg(const
68930 std::vector< M > &arg, casadi_int npar) const  "
68931 
68932 [INTERNAL]   Project sparsities.
68933 
68934 ";
68935 
68936 %feature("docstring")  casadi::ProtoFunction::print_time(const std::map<
68937 std::string, FStats > &fstats) const  "
68938 
68939 [INTERNAL]  Print timing statistics.
68940 
68941 ";
68942 
68943 %feature("docstring")  casadi::Qrsqp::init(const Dict &opts)  "
68944 
68945 [INTERNAL]  Initialize.
68946 
68947 ";
68948 
68949 %feature("docstring")
68950 casadi::FunctionInternal::codegen_alloc_mem(CodeGenerator &g) const  "
68951 
68952 [INTERNAL]  Codegen decref for alloc_mem.
68953 
68954 ";
68955 
68956 %feature("docstring")  casadi::FunctionInternal::nz_out(const std::vector<
68957 DM > &res) const  "
68958 
68959 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
68960 
68961 ";
68962 
68963 %feature("docstring")  casadi::FunctionInternal::nz_out(const std::vector<
68964 double > &res) const  "
68965 
68966 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
68967 
68968 ";
68969 
68970 %feature("docstring")  casadi::Nlpsol::get_name_out(casadi_int i)  "
68971 
68972 [INTERNAL]  Names of function input and outputs.
68973 
68974 ";
68975 
68976 %feature("docstring")  casadi::Qrsqp::solve(void *mem) const  "
68977 
68978 [INTERNAL] ";
68979 
68980 %feature("docstring")  casadi::FunctionInternal::get_reltol() const  "
68981 
68982 [INTERNAL]  Get relative tolerance.
68983 
68984 ";
68985 
68986 %feature("docstring")  casadi::FunctionInternal::incache(const std::string
68987 &fname, Function &f, const std::string &suffix="") const  "
68988 
68989 [INTERNAL]  Get function in cache.
68990 
68991 ";
68992 
68993 %feature("docstring")  casadi::FunctionInternal::eval_gen(const double
68994 **arg, double **res, casadi_int *iw, double *w, void *mem) const  "
68995 
68996 [INTERNAL]  Evaluate numerically.
68997 
68998 ";
68999 
69000 %feature("docstring")  casadi::FunctionInternal::eval_gen(const SXElem
69001 **arg, SXElem **res, casadi_int *iw, SXElem *w, void *mem) const  "
69002 
69003 [INTERNAL]  Evaluate a function, overloaded.
69004 
69005 ";
69006 
69007 %feature("docstring")  casadi::FunctionInternal::eval_gen(const bvec_t
69008 **arg, bvec_t **res, casadi_int *iw, bvec_t *w, void *mem) const  "
69009 
69010 [INTERNAL]  Evaluate a function, overloaded.
69011 
69012 ";
69013 
69014 %feature("docstring")  casadi::FunctionInternal::which_depends(const
69015 std::string &s_in, const std::vector< std::string > &s_out, casadi_int
69016 order, bool tr=false) const  "
69017 
69018 [INTERNAL]  Which variables enter with some order.
69019 
69020 Parameters:
69021 -----------
69022 
69023 s_in:   Input name
69024 
69025 s_out:   Output name(s)
69026 
69027 order:  Only 1 (linear) and 2 (nonlinear) allowed
69028 
69029 tr:  Flip the relationship. Return which expressions contain the variables
69030 
69031 ";
69032 
69033 %feature("docstring")  casadi::OracleFunction::jit_dependencies(const
69034 std::string &fname)  "
69035 
69036 [INTERNAL]  JIT for dependencies.
69037 
69038 ";
69039 
69040 %feature("docstring")  casadi::FunctionInternal::has_derivative() const  "
69041 
69042 [INTERNAL]  Can derivatives be calculated in any way?
69043 
69044 ";
69045 
69046 %feature("docstring")  casadi::FunctionInternal::getAdaptorSolverName()
69047 const  "
69048 
69049 [INTERNAL]  Obtain solver name from Adaptor.
69050 
69051 ";
69052 
69053 %feature("docstring")  casadi::Nlpsol::serialize_type(SerializingStream &s)
69054 const  "
69055 
69056 [INTERNAL]  Serialize type information.
69057 
69058 ";
69059 
69060 %feature("docstring")
69061 casadi::FunctionInternal::instruction_output(casadi_int k) const  "
69062 
69063 [INTERNAL]  Get the (integer) output argument of an atomic operation.
69064 
69065 ";
69066 
69067 %feature("docstring")  casadi::FunctionInternal::symbolic_output(const
69068 std::vector< MX > &arg) const  "
69069 
69070 [INTERNAL]  Get a vector of symbolic variables corresponding to the outputs.
69071 
69072 ";
69073 
69074 %feature("docstring")  casadi::FunctionInternal::free_sx() const  "
69075 
69076 [INTERNAL]  Get free variables (SX)
69077 
69078 ";
69079 
69080 %feature("docstring")  casadi::FunctionInternal::generate_lifted(Function
69081 &vdef_fcn, Function &vinit_fcn) const  "
69082 
69083 [INTERNAL]  Extract the functions needed for the Lifted Newton method.
69084 
69085 ";
69086 
69087 %feature("docstring")  casadi::FunctionInternal::convert_arg(const
69088 std::vector< M > &arg) const  "
69089 
69090 [INTERNAL]  Convert from/to input/output lists/map.
69091 
69092 ";
69093 
69094 %feature("docstring")  casadi::FunctionInternal::convert_arg(const std::map<
69095 std::string, M > &arg) const  "
69096 
69097 [INTERNAL]  Convert from/to input/output lists/map.
69098 
69099 ";
69100 
69101 %feature("docstring")  casadi::FunctionInternal::map(casadi_int n, const
69102 std::string &parallelization) const  "
69103 
69104 [INTERNAL]  Generate/retrieve cached serial map.
69105 
69106 ";
69107 
69108 %feature("docstring")  casadi::FunctionInternal::eval_mx(const MXVector
69109 &arg, MXVector &res, bool always_inline, bool never_inline) const  "
69110 
69111 [INTERNAL]  Evaluate with symbolic matrices.
69112 
69113 ";
69114 
69115 %feature("docstring")  casadi::FunctionInternal::print_option(const
69116 std::string &name, std::ostream &stream) const  "
69117 
69118 [INTERNAL]  Print all information there is to know about a certain option.
69119 
69120 ";
69121 
69122 %feature("docstring")  casadi::FunctionInternal::free_mx() const  "
69123 
69124 [INTERNAL]  Get free variables ( MX)
69125 
69126 ";
69127 
69128 %feature("docstring")  casadi::FunctionInternal::has_sprev() const  "
69129 
69130 [INTERNAL]  Is the class able to propagate seeds through the algorithm?
69131 
69132 ";
69133 
69134 %feature("docstring")  casadi::FunctionInternal::has_free() const  "
69135 
69136 [INTERNAL]  Does the function have free variables.
69137 
69138 ";
69139 
69140 %feature("docstring")  casadi::Qrsqp::getConic() const  "
69141 
69142 [INTERNAL]  Access Conic.
69143 
69144 ";
69145 
69146 %feature("docstring")  casadi::OracleFunction::create_function(const
69147 std::string &fname, const std::vector< std::string > &s_in, const
69148 std::vector< std::string > &s_out, const Function::AuxOut
69149 &aux=Function::AuxOut()) "
69150 
69151 [INTERNAL]  Create an oracle function
69152 
69153 ";
69154 
69155 %feature("docstring")  casadi::FunctionInternal::n_nodes() const  "
69156 
69157 [INTERNAL]  Number of nodes in the algorithm.
69158 
69159 ";
69160 
69161 %feature("docstring")  casadi::FunctionInternal::check_mat(const Sparsity
69162 &arg, const Sparsity &inp, casadi_int &npar) "
69163 
69164 [INTERNAL]  Helper function
69165 
69166 Parameters:
69167 -----------
69168 
69169 npar[in]:  normal usage: 1, disallow pararallel calls: -1
69170 
69171 npar[out]:  required number of parallel calls (or -1)
69172 
69173 ";
69174 
69175 %feature("docstring")  casadi::FunctionInternal::get_min_in(casadi_int ind)
69176 const  "
69177 
69178 [INTERNAL]  Get smallest input value.
69179 
69180 ";
69181 
69182 %feature("docstring")
69183 casadi::FunctionInternal::codegen_init_mem(CodeGenerator &g) const  "
69184 
69185 [INTERNAL]  Codegen decref for init_mem.
69186 
69187 ";
69188 
69189 %feature("docstring")  casadi::FunctionInternal::dm_out(casadi_int ind)
69190 const  "
69191 
69192 [INTERNAL]  Get function input(s) and output(s)
69193 
69194 ";
69195 
69196 %feature("docstring")  casadi::FunctionInternal::dm_out() const  "
69197 
69198 [INTERNAL]  Get function input(s) and output(s)
69199 
69200 ";
69201 
69202 %feature("docstring")  casadi::Qrsqp::plugin_name() const  "
69203 
69204 [INTERNAL] ";
69205 
69206 %feature("docstring")  casadi::Nlpsol::get_reverse(casadi_int nadj, const
69207 std::string &name, const std::vector< std::string > &inames, const
69208 std::vector< std::string > &onames, const Dict &opts) const  "
69209 
69210 [INTERNAL]  Generate a function that calculates reverse mode derivatives.
69211 
69212 ";
69213 
69214 %feature("docstring")  casadi::FunctionInternal::size2_out(casadi_int ind)
69215 const  "
69216 
69217 [INTERNAL]  Input/output dimensions.
69218 
69219 ";
69220 
69221 %feature("docstring")  casadi::Nlpsol::has_reverse(casadi_int nadj) const  "
69222 
69223 [INTERNAL]  Generate a function that calculates reverse mode derivatives.
69224 
69225 ";
69226 
69227 %feature("docstring")  casadi::Nlpsol::get_name_in(casadi_int i)  "
69228 
69229 [INTERNAL]  Names of function input and outputs.
69230 
69231 ";
69232 
69233 %feature("docstring")  casadi::FunctionInternal::info() const  "
69234 
69235 [INTERNAL]  Obtain information about function
69236 
69237 ";
69238 
69239 %feature("docstring")  casadi::FunctionInternal::get_jacobian(const
69240 std::string &name, const std::vector< std::string > &inames, const
69241 std::vector< std::string > &onames, const Dict &opts) const  "
69242 
69243 [INTERNAL]  Return Jacobian of all input elements with respect to all output
69244 elements.
69245 
69246 ";
69247 
69248 %feature("docstring")  casadi::FunctionInternal::sp_weight() const  "
69249 
69250 [INTERNAL]  Weighting factor for chosing forward/reverse mode, sparsity
69251 propagation.
69252 
69253 ";
69254 
69255 %feature("docstring")  casadi::FunctionInternal::dm_in(casadi_int ind) const
69256 "
69257 
69258 [INTERNAL]  Get function input(s) and output(s)
69259 
69260 ";
69261 
69262 %feature("docstring")  casadi::FunctionInternal::dm_in() const  "
69263 
69264 [INTERNAL]  Get function input(s) and output(s)
69265 
69266 ";
69267 
69268 %feature("docstring")  casadi::FunctionInternal::has_codegen() const  "
69269 
69270 [INTERNAL]  Is codegen supported?
69271 
69272 ";
69273 
69274 %feature("docstring")  casadi::FunctionInternal::sparsity_out(casadi_int
69275 ind) const  "
69276 
69277 [INTERNAL]  Input/output sparsity.
69278 
69279 ";
69280 
69281 %feature("docstring")  casadi::FunctionInternal::reverse(casadi_int nadj)
69282 const  "
69283 
69284 [INTERNAL]  Return function that calculates adjoint derivatives
69285 reverse(nadj) returns a cached instance if available, and calls  Function
69286 get_reverse(casadi_int nadj) if no cached version is available.
69287 
69288 ";
69289 
69290 %feature("docstring")  casadi::FunctionInternal::alloc_w(size_t sz_w, bool
69291 persistent=false) "
69292 
69293 [INTERNAL]  Ensure required length of w field.
69294 
69295 ";
69296 
69297 %feature("docstring")  casadi::FunctionInternal::get_partition(casadi_int
69298 iind, casadi_int oind, Sparsity &D1, Sparsity &D2, bool compact, bool
69299 symmetric, bool allow_forward, bool allow_reverse) const  "
69300 
69301 [INTERNAL]  Get the unidirectional or bidirectional partition.
69302 
69303 ";
69304 
69305 %feature("docstring")  casadi::Nlpsol::callback(NlpsolMemory *m) const  "
69306 
69307 [INTERNAL] ";
69308 
69309 %feature("docstring")  casadi::FunctionInternal::tocache(const Function &f,
69310 const std::string &suffix="") const  "
69311 
69312 [INTERNAL]  Save function to cache.
69313 
69314 ";
69315 
69316 %feature("docstring")  casadi::FunctionInternal::has_jacobian() const  "
69317 
69318 [INTERNAL]  Return Jacobian of all input elements with respect to all output
69319 elements.
69320 
69321 ";
69322 
69323 %feature("docstring")  casadi::Qrsqp::class_name() const  "
69324 
69325 [INTERNAL]  Get type name.
69326 
69327 ";
69328 
69329 %feature("docstring")  casadi::FunctionInternal::size1_in(casadi_int ind)
69330 const  "
69331 
69332 [INTERNAL]  Input/output dimensions.
69333 
69334 ";
69335 
69336 %feature("docstring")  casadi::FunctionInternal::wrap() const  "
69337 
69338 [INTERNAL]  Wrap in an Function instance consisting of only one MX call.
69339 
69340 ";
69341 
69342 %feature("docstring")  casadi::FunctionInternal::numel_in() const  "
69343 
69344 [INTERNAL]  Number of input/output elements.
69345 
69346 ";
69347 
69348 %feature("docstring")  casadi::FunctionInternal::numel_in(casadi_int ind)
69349 const  "
69350 
69351 [INTERNAL]  Number of input/output elements.
69352 
69353 ";
69354 
69355 %feature("docstring")  casadi::FunctionInternal::fwdViaJac(casadi_int nfwd)
69356 const  "
69357 
69358 [INTERNAL]  Calculate derivatives by multiplying the full Jacobian and
69359 multiplying.
69360 
69361 ";
69362 
69363 %feature("docstring")
69364 casadi::FunctionInternal::getJacSparsityHierarchicalSymm(casadi_int iind,
69365 casadi_int oind) const  "
69366 
69367 [INTERNAL]  A flavor of getJacSparsity that does hierarchical block
69368 structure recognition for symmetric Jacobians
69369 
69370 ";
69371 
69372 %feature("docstring")  casadi::FunctionInternal::get_abstol() const  "
69373 
69374 [INTERNAL]  Get absolute tolerance.
69375 
69376 ";
69377 
69378 %feature("docstring")  casadi::FunctionInternal::get_max_in(casadi_int ind)
69379 const  "
69380 
69381 [INTERNAL]  Get largest input value.
69382 
69383 ";
69384 
69385 %feature("docstring")  casadi::FunctionInternal::size1_out(casadi_int ind)
69386 const  "
69387 
69388 [INTERNAL]  Input/output dimensions.
69389 
69390 ";
69391 
69392 %feature("docstring")  casadi::FunctionInternal::call_forward(const
69393 std::vector< MX > &arg, const std::vector< MX > &res, const std::vector<
69394 std::vector< MX > > &fseed, std::vector< std::vector< MX > > &fsens, bool
69395 always_inline, bool never_inline) const  "
69396 
69397 [INTERNAL]  Forward mode AD, virtual functions overloaded in derived
69398 classes.
69399 
69400 ";
69401 
69402 %feature("docstring")  casadi::FunctionInternal::call_forward(const
69403 std::vector< SX > &arg, const std::vector< SX > &res, const std::vector<
69404 std::vector< SX > > &fseed, std::vector< std::vector< SX > > &fsens, bool
69405 always_inline, bool never_inline) const  "
69406 
69407 [INTERNAL]  Forward mode AD, virtual functions overloaded in derived
69408 classes.
69409 
69410 ";
69411 
69412 %feature("docstring")  casadi::FunctionInternal::signature(const std::string
69413 &fname) const  "
69414 
69415 [INTERNAL]  Code generate the function.
69416 
69417 ";
69418 
69419 
69420 // File: classcasadi_1_1Rank1.xml
69421 
69422 
69423 // File: classcasadi_1_1RealtypeSX.xml
69424 
69425 
69426 // File: classcasadi_1_1Reshape.xml
69427 
69428 
69429 // File: classcasadi_1_1Rootfinder.xml
69430 %feature("docstring")  casadi::FunctionInternal::definition() const  "
69431 
69432 [INTERNAL]  Get function signature: name:(inputs)->(outputs)
69433 
69434 ";
69435 
69436 %feature("docstring")  casadi::ProtoFunction::print_time(const std::map<
69437 std::string, FStats > &fstats) const  "
69438 
69439 [INTERNAL]  Print timing statistics.
69440 
69441 ";
69442 
69443 %feature("docstring")  casadi::FunctionInternal::generate_out(const
69444 std::string &fname, double **res) const  "
69445 
69446 [INTERNAL] ";
69447 
69448 %feature("docstring")  casadi::FunctionInternal::has_derivative() const  "
69449 
69450 [INTERNAL]  Can derivatives be calculated in any way?
69451 
69452 ";
69453 
69454 %feature("docstring")  casadi::FunctionInternal::slice(const std::string
69455 &name, const std::vector< casadi_int > &order_in, const std::vector<
69456 casadi_int > &order_out, const Dict &opts) const  "
69457 
69458 [INTERNAL]  returns a new function with a selection of inputs/outputs of the
69459 original
69460 
69461 ";
69462 
69463 %feature("docstring")
69464 casadi::FunctionInternal::codegen_incref(CodeGenerator &g) const  "
69465 
69466 [INTERNAL]  Codegen incref for dependencies.
69467 
69468 ";
69469 
69470 %feature("docstring")  casadi::OracleFunction::expand() "
69471 
69472 [INTERNAL] ";
69473 
69474 %feature("docstring")  casadi::FunctionInternal::has_free() const  "
69475 
69476 [INTERNAL]  Does the function have free variables.
69477 
69478 ";
69479 
69480 %feature("docstring")  casadi::FunctionInternal::replace_res(const
69481 std::vector< M > &res, casadi_int npar) const  "
69482 
69483 [INTERNAL]  Replace 0-by-0 outputs.
69484 
69485 ";
69486 
69487 %feature("docstring")  casadi::OracleFunction::set_temp(void *mem, const
69488 double **arg, double **res, casadi_int *iw, double *w) const  "
69489 
69490 [INTERNAL]  Set the work vectors.
69491 
69492 ";
69493 
69494 %feature("docstring")
69495 casadi::FunctionInternal::codegen_init_mem(CodeGenerator &g) const  "
69496 
69497 [INTERNAL]  Codegen decref for init_mem.
69498 
69499 ";
69500 
69501 %feature("docstring")  casadi::FunctionInternal::matching_arg(const
69502 std::vector< M > &arg, casadi_int &npar) const  "
69503 
69504 [INTERNAL]  Check if input arguments that needs to be replaced.
69505 
69506 Raises errors
69507 
69508 Parameters:
69509 -----------
69510 
69511 npar[in]:  normal usage: 1, disallow pararallel calls: -1
69512 
69513 npar:  max number of horizontal repetitions across all arguments (or -1)
69514 
69515 ";
69516 
69517 %feature("docstring")  casadi::Rootfinder::serialize_body(SerializingStream
69518 &s) const  "
69519 
69520 [INTERNAL]  Serialize an object without type information.
69521 
69522 ";
69523 
69524 %feature("docstring")  casadi::FunctionInternal::dm_in(casadi_int ind) const
69525 "
69526 
69527 [INTERNAL]  Get function input(s) and output(s)
69528 
69529 ";
69530 
69531 %feature("docstring")  casadi::FunctionInternal::dm_in() const  "
69532 
69533 [INTERNAL]  Get function input(s) and output(s)
69534 
69535 ";
69536 
69537 %feature("docstring")  casadi::OracleFunction::calc_function(OracleMemory
69538 *m, const std::string &fcn, const double *const *arg=nullptr) const  "
69539 
69540 [INTERNAL] ";
69541 
69542 %feature("docstring")  casadi::FunctionInternal::replace_fseed(const
69543 std::vector< std::vector< M >> &fseed, casadi_int npar) const  "
69544 
69545 [INTERNAL]  Replace 0-by-0 forward seeds.
69546 
69547 ";
69548 
69549 %feature("docstring")  casadi::FunctionInternal::replace_fseed(const
69550 std::vector< std::vector< M > > &fseed, casadi_int npar) const  "
69551 
69552 [INTERNAL] ";
69553 
69554 %feature("docstring")  casadi::FunctionInternal::size_in(casadi_int ind)
69555 const  "
69556 
69557 [INTERNAL]  Input/output dimensions.
69558 
69559 ";
69560 
69561 %feature("docstring")  casadi::OracleFunction::monitored(const std::string
69562 &name) const  "
69563 
69564 [INTERNAL] ";
69565 
69566 %feature("docstring")  casadi::FunctionInternal::check_res(const
69567 std::vector< M > &res, casadi_int &npar) const  "
69568 
69569 [INTERNAL]  Check if output arguments have correct length and dimensions.
69570 
69571 Raises errors.
69572 
69573 Parameters:
69574 -----------
69575 
69576 npar[in]:  normal usage: 1, disallow pararallel calls: -1
69577 
69578 npar:  max number of horizontal repetitions across all arguments (or -1)
69579 
69580 ";
69581 
69582 %feature("docstring")  casadi::Rootfinder::has_spfwd() const  "
69583 
69584 [INTERNAL]  Is the class able to propagate seeds through the algorithm?
69585 
69586 ";
69587 
69588 %feature("docstring")  casadi::FunctionInternal::alloc_arg(size_t sz_arg,
69589 bool persistent=false) "
69590 
69591 [INTERNAL]  Ensure required length of arg field.
69592 
69593 ";
69594 
69595 %feature("docstring")  casadi::FunctionInternal::nnz_out() const  "
69596 
69597 [INTERNAL]  Number of input/output nonzeros.
69598 
69599 ";
69600 
69601 %feature("docstring")  casadi::FunctionInternal::nnz_out(casadi_int ind)
69602 const  "
69603 
69604 [INTERNAL]  Number of input/output nonzeros.
69605 
69606 ";
69607 
69608 %feature("docstring")  casadi::FunctionInternal::self() const  "
69609 
69610 [INTERNAL]  Get a public class instance.
69611 
69612 ";
69613 
69614 %feature("docstring")  casadi::FunctionInternal::has_jac() const  "
69615 
69616 [INTERNAL]  Return Jacobian of all input elements with respect to all output
69617 elements.
69618 
69619 ";
69620 
69621 %feature("docstring")  casadi::FunctionInternal::instruction_MX(casadi_int
69622 k) const  "
69623 
69624 [INTERNAL]  get MX expression associated with instruction
69625 
69626 ";
69627 
69628 %feature("docstring")  casadi::FunctionInternal::get_min_in(casadi_int ind)
69629 const  "
69630 
69631 [INTERNAL]  Get smallest input value.
69632 
69633 ";
69634 
69635 %feature("docstring")  casadi::Rootfinder::has_reverse(casadi_int nadj)
69636 const  "
69637 
69638 [INTERNAL]  Generate a function that calculates nadj adjoint derivatives.
69639 
69640 ";
69641 
69642 %feature("docstring")  casadi::FunctionInternal::fwdViaJac(casadi_int nfwd)
69643 const  "
69644 
69645 [INTERNAL]  Calculate derivatives by multiplying the full Jacobian and
69646 multiplying.
69647 
69648 ";
69649 
69650 %feature("docstring")  casadi::FunctionInternal::generate_lifted(Function
69651 &vdef_fcn, Function &vinit_fcn) const  "
69652 
69653 [INTERNAL]  Extract the functions needed for the Lifted Newton method.
69654 
69655 ";
69656 
69657 %feature("docstring")  casadi::FunctionInternal::forward(casadi_int nfwd)
69658 const  "
69659 
69660 [INTERNAL]  Return function that calculates forward derivatives
69661 forward(nfwd) returns a cached instance if available, and calls  Function
69662 get_forward(casadi_int nfwd) if no cached version is available.
69663 
69664 ";
69665 
69666 %feature("docstring")  casadi::FunctionInternal::fwd_seed(casadi_int nfwd)
69667 const  "
69668 
69669 [INTERNAL]  Symbolic expressions for the forward seeds.
69670 
69671 ";
69672 
69673 %feature("docstring")  casadi::FunctionInternal::info() const  "
69674 
69675 [INTERNAL]  Obtain information about function
69676 
69677 ";
69678 
69679 %feature("docstring")  casadi::FunctionInternal::sx_out(casadi_int ind)
69680 const  "
69681 
69682 [INTERNAL]  Get function input(s) and output(s)
69683 
69684 ";
69685 
69686 %feature("docstring")  casadi::FunctionInternal::sx_out() const  "
69687 
69688 [INTERNAL]  Get function input(s) and output(s)
69689 
69690 ";
69691 
69692 %feature("docstring")  casadi::FunctionInternal::get_default_in(casadi_int
69693 ind) const  "
69694 
69695 [INTERNAL]  Get default input value.
69696 
69697 ";
69698 
69699 %feature("docstring")  casadi::FunctionInternal::get_abstol() const  "
69700 
69701 [INTERNAL]  Get absolute tolerance.
69702 
69703 ";
69704 
69705 %feature("docstring")  casadi::FunctionInternal::jacobian() const  "
69706 
69707 [INTERNAL]  Return Jacobian of all input elements with respect to all output
69708 elements.
69709 
69710 ";
69711 
69712 %feature("docstring")  casadi::FunctionInternal::index_out(const std::string
69713 &name) const  "
69714 
69715 [INTERNAL]  Get output scheme index by name.
69716 
69717 ";
69718 
69719 %feature("docstring")  casadi::FunctionInternal::reverse(casadi_int nadj)
69720 const  "
69721 
69722 [INTERNAL]  Return function that calculates adjoint derivatives
69723 reverse(nadj) returns a cached instance if available, and calls  Function
69724 get_reverse(casadi_int nadj) if no cached version is available.
69725 
69726 ";
69727 
69728 %feature("docstring")  casadi::FunctionInternal::eval_sx(const SXElem **arg,
69729 SXElem **res, casadi_int *iw, SXElem *w, void *mem) const  "
69730 
69731 [INTERNAL]  Evaluate with symbolic scalars.
69732 
69733 ";
69734 
69735 %feature("docstring")  casadi::Rootfinder::get_sparsity_out(casadi_int i)  "
69736 
69737 [INTERNAL]  Sparsities of function inputs and outputs.
69738 
69739 ";
69740 
69741 %feature("docstring")  casadi::FunctionInternal::is_diff_out(casadi_int i) "
69742 
69743 [INTERNAL] ";
69744 
69745 %feature("docstring")  casadi::FunctionInternal::replace_arg(const
69746 std::vector< M > &arg, casadi_int npar) const  "
69747 
69748 [INTERNAL]  Replace 0-by-0 inputs.
69749 
69750 ";
69751 
69752 %feature("docstring")  casadi::FunctionInternal::alloc_iw(size_t sz_iw, bool
69753 persistent=false) "
69754 
69755 [INTERNAL]  Ensure required length of iw field.
69756 
69757 ";
69758 
69759 %feature("docstring")  casadi::FunctionInternal::free_sx() const  "
69760 
69761 [INTERNAL]  Get free variables (SX)
69762 
69763 ";
69764 
69765 %feature("docstring")  casadi::FunctionInternal::numel_in() const  "
69766 
69767 [INTERNAL]  Number of input/output elements.
69768 
69769 ";
69770 
69771 %feature("docstring")  casadi::FunctionInternal::numel_in(casadi_int ind)
69772 const  "
69773 
69774 [INTERNAL]  Number of input/output elements.
69775 
69776 ";
69777 
69778 %feature("docstring")  casadi::OracleFunction::set_function(const Function
69779 &fcn, const std::string &fname, bool jit=false) "
69780 
69781 [INTERNAL]  Register the function for evaluation and statistics gathering
69782 
69783 ";
69784 
69785 %feature("docstring")  casadi::OracleFunction::set_function(const Function
69786 &fcn) "
69787 
69788 [INTERNAL]  Register the function for evaluation and statistics gathering
69789 
69790 ";
69791 
69792 %feature("docstring")  casadi::FunctionInternal::replace_aseed(const
69793 std::vector< std::vector< M >> &aseed, casadi_int npar) const  "
69794 
69795 [INTERNAL]  Replace 0-by-0 reverse seeds.
69796 
69797 ";
69798 
69799 %feature("docstring")  casadi::FunctionInternal::replace_aseed(const
69800 std::vector< std::vector< M > > &aseed, casadi_int npar) const  "
69801 
69802 [INTERNAL] ";
69803 
69804 %feature("docstring")  casadi::FunctionInternal::sparsity_jac(casadi_int
69805 iind, casadi_int oind, bool compact, bool symmetric) const  "
69806 
69807 [INTERNAL]  Get, if necessary generate, the sparsity of a Jacobian block.
69808 
69809 ";
69810 
69811 %feature("docstring")  casadi::FunctionInternal::symbolicAdjSeed(casadi_int
69812 nadj, const std::vector< MatType > &v) const  "
69813 
69814 [INTERNAL]  Symbolic expressions for the adjoint seeds.
69815 
69816 ";
69817 
69818 %feature("docstring")  casadi::SharedObjectInternal::getCount() const  "
69819 
69820 [INTERNAL]  Get the reference count.
69821 
69822 ";
69823 
69824 %feature("docstring")  casadi::Rootfinder::get_name_out(casadi_int i)  "
69825 
69826 [INTERNAL]  Names of function input and outputs.
69827 
69828 ";
69829 
69830 %feature("docstring")  casadi::FunctionInternal::sz_work(size_t &sz_arg,
69831 size_t &sz_res, size_t &sz_iw, size_t &sz_w) const  "
69832 
69833 [INTERNAL]  Get number of temporary variables needed.
69834 
69835 ";
69836 
69837 %feature("docstring")  casadi::FunctionInternal::nz_out(const std::vector<
69838 DM > &res) const  "
69839 
69840 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
69841 
69842 ";
69843 
69844 %feature("docstring")  casadi::FunctionInternal::nz_out(const std::vector<
69845 double > &res) const  "
69846 
69847 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
69848 
69849 ";
69850 
69851 %feature("docstring")  casadi::Rootfinder::init(const Dict &opts)  "
69852 
69853 [INTERNAL]  Initialize.
69854 
69855 ";
69856 
69857 %feature("docstring")  casadi::FunctionInternal::sz_iw() const  "
69858 
69859 [INTERNAL]  Get required length of iw field.
69860 
69861 ";
69862 
69863 %feature("docstring")  casadi::OracleFunction::free_mem(void *mem) const  "
69864 
69865 [INTERNAL]  Free memory block.
69866 
69867 ";
69868 
69869 %feature("docstring")  casadi::Rootfinder::serialize_type(SerializingStream
69870 &s) const  "
69871 
69872 [INTERNAL]  Serialize type information.
69873 
69874 ";
69875 
69876 %feature("docstring")  casadi::FunctionInternal::all_scalar() const  "
69877 
69878 [INTERNAL]  Are all inputs and outputs scalar.
69879 
69880 ";
69881 
69882 %feature("docstring")  casadi::FunctionInternal::sp_weight() const  "
69883 
69884 [INTERNAL]  Weighting factor for chosing forward/reverse mode, sparsity
69885 propagation.
69886 
69887 ";
69888 
69889 %feature("docstring") casadi::Rootfinder::Rootfinder(const std::string
69890 &name, const Function &oracle) "
69891 
69892 [INTERNAL]  Constructor.
69893 
69894 Parameters:
69895 -----------
69896 
69897 f:   Function mapping from (n+1) inputs to 1 output.
69898 
69899 ";
69900 
69901 %feature("docstring")  casadi::Rootfinder::get_n_in()  "
69902 
69903 [INTERNAL]  Number of function inputs and outputs.
69904 
69905 ";
69906 
69907 %feature("docstring")  casadi::OracleFunction::get_function() const  "
69908 
69909 [INTERNAL]  Get list of dependency functions -1 Indicates irregularity.
69910 
69911 ";
69912 
69913 %feature("docstring")  casadi::OracleFunction::get_function(const
69914 std::string &name) const  "
69915 
69916 [INTERNAL] ";
69917 
69918 %feature("docstring")  casadi::Rootfinder::has_forward(casadi_int nfwd)
69919 const  "
69920 
69921 [INTERNAL]  Generate a function that calculates nfwd forward derivatives.
69922 
69923 ";
69924 
69925 %feature("docstring")  casadi::FunctionInternal::n_nodes() const  "
69926 
69927 [INTERNAL]  Number of nodes in the algorithm.
69928 
69929 ";
69930 
69931 %feature("docstring")  casadi::FunctionInternal::jac() const  "
69932 
69933 [INTERNAL]  Return Jacobian of all input elements with respect to all output
69934 elements.
69935 
69936 ";
69937 
69938 %feature("docstring")  casadi::Rootfinder::solve(void *mem) const  "
69939 
69940 [INTERNAL] ";
69941 
69942 %feature("docstring")
69943 casadi::FunctionInternal::jacobian_sparsity_filter(const Sparsity &sp) const
69944 "
69945 
69946 [INTERNAL]  Filter out nonzeros in the full sparsity jacobian according to
69947 is_diff_in/out.
69948 
69949 ";
69950 
69951 %feature("docstring")  casadi::FunctionInternal::tocache(const Function &f,
69952 const std::string &suffix="") const  "
69953 
69954 [INTERNAL]  Save function to cache.
69955 
69956 ";
69957 
69958 %feature("docstring")  casadi::ProtoFunction::serialize(SerializingStream
69959 &s) const  "
69960 
69961 [INTERNAL]  Serialize an object.
69962 
69963 ";
69964 
69965 %feature("docstring")  casadi::FunctionInternal::check_mat(const Sparsity
69966 &arg, const Sparsity &inp, casadi_int &npar) "
69967 
69968 [INTERNAL]  Helper function
69969 
69970 Parameters:
69971 -----------
69972 
69973 npar[in]:  normal usage: 1, disallow pararallel calls: -1
69974 
69975 npar[out]:  required number of parallel calls (or -1)
69976 
69977 ";
69978 
69979 %feature("docstring")  casadi::FunctionInternal::wrap() const  "
69980 
69981 [INTERNAL]  Wrap in an Function instance consisting of only one MX call.
69982 
69983 ";
69984 
69985 %feature("docstring")  casadi::FunctionInternal::sz_w() const  "
69986 
69987 [INTERNAL]  Get required length of w field.
69988 
69989 ";
69990 
69991 %feature("docstring")
69992 casadi::FunctionInternal::print_dimensions(std::ostream &stream) const  "
69993 
69994 [INTERNAL]  Print dimensions of inputs and outputs.
69995 
69996 ";
69997 
69998 %feature("docstring")  casadi::ProtoFunction::memory(int ind) const  "
69999 
70000 [INTERNAL]  Memory objects.
70001 
70002 ";
70003 
70004 %feature("docstring")  casadi::FunctionInternal::call(const std::vector< M >
70005 &arg, std::vector< M > &res, bool always_inline, bool never_inline) const  "
70006 
70007 [INTERNAL]   Call a function, templated.
70008 
70009 ";
70010 
70011 %feature("docstring")  casadi::Rootfinder::get_name_in(casadi_int i)  "
70012 
70013 [INTERNAL]  Names of function input and outputs.
70014 
70015 ";
70016 
70017 %feature("docstring")  casadi::FunctionInternal::disp_more(std::ostream
70018 &stream) const  "
70019 
70020 [INTERNAL]  Print more.
70021 
70022 ";
70023 
70024 %feature("docstring")  casadi::FunctionInternal::generate_options(bool
70025 is_temp=false) const  "
70026 
70027 [INTERNAL]  Reconstruct options dict.
70028 
70029 ";
70030 
70031 %feature("docstring")  casadi::OracleFunction::oracle() const  "
70032 
70033 [INTERNAL]  Get oracle.
70034 
70035 ";
70036 
70037 %feature("docstring")  casadi::FunctionInternal::alloc_res(size_t sz_res,
70038 bool persistent=false) "
70039 
70040 [INTERNAL]  Ensure required length of res field.
70041 
70042 ";
70043 
70044 %feature("docstring")  casadi::FunctionInternal::instruction_id(casadi_int
70045 k) const  "
70046 
70047 [INTERNAL]  Get an atomic operation operator index.
70048 
70049 ";
70050 
70051 %feature("docstring")  casadi::FunctionInternal::codegen_mem_type() const  "
70052 
70053 [INTERNAL]  Thread-local memory object type.
70054 
70055 ";
70056 
70057 %feature("docstring")  casadi::FunctionInternal::call_reverse(const
70058 std::vector< MX > &arg, const std::vector< MX > &res, const std::vector<
70059 std::vector< MX > > &aseed, std::vector< std::vector< MX > > &asens, bool
70060 always_inline, bool never_inline) const  "
70061 
70062 [INTERNAL]  Reverse mode, virtual functions overloaded in derived classes.
70063 
70064 ";
70065 
70066 %feature("docstring")  casadi::FunctionInternal::call_reverse(const
70067 std::vector< SX > &arg, const std::vector< SX > &res, const std::vector<
70068 std::vector< SX > > &aseed, std::vector< std::vector< SX > > &asens, bool
70069 always_inline, bool never_inline) const  "
70070 
70071 [INTERNAL]  Reverse mode, virtual functions overloaded in derived classes.
70072 
70073 ";
70074 
70075 %feature("docstring")  casadi::FunctionInternal::get_free() const  "
70076 
70077 [INTERNAL]  Print free variables.
70078 
70079 ";
70080 
70081 %feature("docstring")  casadi::Rootfinder::ad_forward(const std::vector< MX
70082 > &arg, const std::vector< MX > &res, const std::vector< std::vector< MX > >
70083 &fseed, std::vector< std::vector< MX > > &fsens, bool always_inline, bool
70084 never_inline) const  "
70085 
70086 [INTERNAL]  Create call to (cached) derivative function, forward mode.
70087 
70088 ";
70089 
70090 %feature("docstring") casadi::Rootfinder::~Rootfinder "
70091 
70092 [INTERNAL]  Destructor.
70093 
70094 ";
70095 
70096 %feature("docstring")
70097 casadi::FunctionInternal::codegen_alloc_mem(CodeGenerator &g) const  "
70098 
70099 [INTERNAL]  Codegen decref for alloc_mem.
70100 
70101 ";
70102 
70103 %feature("docstring")  casadi::Rootfinder::has_sprev() const  "
70104 
70105 [INTERNAL]  Is the class able to propagate seeds through the algorithm?
70106 
70107 ";
70108 
70109 %feature("docstring")  casadi::FunctionInternal::print_option(const
70110 std::string &name, std::ostream &stream) const  "
70111 
70112 [INTERNAL]  Print all information there is to know about a certain option.
70113 
70114 ";
70115 
70116 %feature("docstring")  casadi::ProtoFunction::release(int mem) const  "
70117 
70118 [INTERNAL]  Release a memory object.
70119 
70120 ";
70121 
70122 %feature("docstring")  casadi::Rootfinder::init_mem(void *mem) const  "
70123 
70124 [INTERNAL]  Initalize memory block.
70125 
70126 ";
70127 
70128 %feature("docstring")
70129 casadi::FunctionInternal::instruction_input(casadi_int k) const  "
70130 
70131 [INTERNAL]  Get the (integer) input arguments of an atomic operation.
70132 
70133 ";
70134 
70135 %feature("docstring")  casadi::FunctionInternal::disp(std::ostream &stream,
70136 bool more) const  "
70137 
70138 [INTERNAL]  Display object.
70139 
70140 ";
70141 
70142 %feature("docstring")  casadi::FunctionInternal::convert_arg(const
70143 std::vector< M > &arg) const  "
70144 
70145 [INTERNAL]  Convert from/to input/output lists/map.
70146 
70147 ";
70148 
70149 %feature("docstring")  casadi::FunctionInternal::convert_arg(const std::map<
70150 std::string, M > &arg) const  "
70151 
70152 [INTERNAL]  Convert from/to input/output lists/map.
70153 
70154 ";
70155 
70156 %feature("docstring")  casadi::FunctionInternal::dm_out(casadi_int ind)
70157 const  "
70158 
70159 [INTERNAL]  Get function input(s) and output(s)
70160 
70161 ";
70162 
70163 %feature("docstring")  casadi::FunctionInternal::dm_out() const  "
70164 
70165 [INTERNAL]  Get function input(s) and output(s)
70166 
70167 ";
70168 
70169 %feature("docstring")  casadi::FunctionInternal::getAdaptorSolverName()
70170 const  "
70171 
70172 [INTERNAL]  Obtain solver name from Adaptor.
70173 
70174 ";
70175 
70176 %feature("docstring")  casadi::FunctionInternal::matching_res(const
70177 std::vector< M > &arg, casadi_int &npar) const  "
70178 
70179 [INTERNAL]  Check if output arguments that needs to be replaced.
70180 
70181 Raises errors
70182 
70183 Parameters:
70184 -----------
70185 
70186 npar[in]:  normal usage: 1, disallow pararallel calls: -1
70187 
70188 npar:  max number of horizontal repetitions across all arguments (or -1)
70189 
70190 ";
70191 
70192 %feature("docstring")  casadi::FunctionInternal::alloc_w(size_t sz_w, bool
70193 persistent=false) "
70194 
70195 [INTERNAL]  Ensure required length of w field.
70196 
70197 ";
70198 
70199 %feature("docstring")
70200 casadi::FunctionInternal::codegen_decref(CodeGenerator &g) const  "
70201 
70202 [INTERNAL]  Codegen decref for dependencies.
70203 
70204 ";
70205 
70206 %feature("docstring")  casadi::FunctionInternal::alloc(const Function &f,
70207 bool persistent=false) "
70208 
70209 [INTERNAL]  Ensure work vectors long enough to evaluate function.
70210 
70211 ";
70212 
70213 %feature("docstring")  casadi::FunctionInternal::codegen_name(const
70214 CodeGenerator &g, bool ns=true) const  "
70215 
70216 [INTERNAL]  Get name in codegen.
70217 
70218 ";
70219 
70220 %feature("docstring") casadi::Rootfinder "
70221 
70222 Internal class.
70223 
70224 >List of available options
70225 
70226 +------------------+-----------------+------------------+------------------+
70227 |        Id        |      Type       |   Description    |     Used in      |
70228 +==================+=================+==================+==================+
70229 | common_options   | OT_DICT         | Options for      | casadi::OracleFu |
70230 |                  |                 | auto-generated   | nction           |
70231 |                  |                 | functions        |                  |
70232 +------------------+-----------------+------------------+------------------+
70233 | constraints      | OT_INTVECTOR    | Constrain the    | casadi::Rootfind |
70234 |                  |                 | unknowns. 0      | er               |
70235 |                  |                 | (default): no    |                  |
70236 |                  |                 | constraint on    |                  |
70237 |                  |                 | ui, 1: ui >=     |                  |
70238 |                  |                 | 0.0, -1: ui <=   |                  |
70239 |                  |                 | 0.0, 2: ui >     |                  |
70240 |                  |                 | 0.0, -2: ui <    |                  |
70241 |                  |                 | 0.0.             |                  |
70242 +------------------+-----------------+------------------+------------------+
70243 | error_on_fail    | OT_BOOL         | When the         | casadi::Rootfind |
70244 |                  |                 | numerical        | er               |
70245 |                  |                 | process returns  |                  |
70246 |                  |                 | unsuccessfully,  |                  |
70247 |                  |                 | raise an error   |                  |
70248 |                  |                 | (default false). |                  |
70249 +------------------+-----------------+------------------+------------------+
70250 | expand           | OT_BOOL         | Replace MX with  | casadi::OracleFu |
70251 |                  |                 | SX expressions   | nction           |
70252 |                  |                 | in problem       |                  |
70253 |                  |                 | formulation      |                  |
70254 |                  |                 | [false]          |                  |
70255 +------------------+-----------------+------------------+------------------+
70256 | implicit_input   | OT_INT          | Index of the     | casadi::Rootfind |
70257 |                  |                 | input that       | er               |
70258 |                  |                 | corresponds to   |                  |
70259 |                  |                 | the actual root- |                  |
70260 |                  |                 | finding          |                  |
70261 +------------------+-----------------+------------------+------------------+
70262 | implicit_output  | OT_INT          | Index of the     | casadi::Rootfind |
70263 |                  |                 | output that      | er               |
70264 |                  |                 | corresponds to   |                  |
70265 |                  |                 | the actual root- |                  |
70266 |                  |                 | finding          |                  |
70267 +------------------+-----------------+------------------+------------------+
70268 | jacobian_functio | OT_FUNCTION     | Function object  | casadi::Rootfind |
70269 | n                |                 | for calculating  | er               |
70270 |                  |                 | the Jacobian     |                  |
70271 |                  |                 | (autogenerated   |                  |
70272 |                  |                 | by default)      |                  |
70273 +------------------+-----------------+------------------+------------------+
70274 | linear_solver    | OT_STRING       | User-defined     | casadi::Rootfind |
70275 |                  |                 | linear solver    | er               |
70276 |                  |                 | class. Needed    |                  |
70277 |                  |                 | for              |                  |
70278 |                  |                 | sensitivities.   |                  |
70279 +------------------+-----------------+------------------+------------------+
70280 | linear_solver_op | OT_DICT         | Options to be    | casadi::Rootfind |
70281 | tions            |                 | passed to the    | er               |
70282 |                  |                 | linear solver.   |                  |
70283 +------------------+-----------------+------------------+------------------+
70284 | monitor          | OT_STRINGVECTOR | Set of user      | casadi::OracleFu |
70285 |                  |                 | problem          | nction           |
70286 |                  |                 | functions to be  |                  |
70287 |                  |                 | monitored        |                  |
70288 +------------------+-----------------+------------------+------------------+
70289 | show_eval_warnin | OT_BOOL         | Show warnings    | casadi::OracleFu |
70290 | gs               |                 | generated from   | nction           |
70291 |                  |                 | function         |                  |
70292 |                  |                 | evaluations      |                  |
70293 |                  |                 | [true]           |                  |
70294 +------------------+-----------------+------------------+------------------+
70295 | specific_options | OT_DICT         | Options for      | casadi::OracleFu |
70296 |                  |                 | specific auto-   | nction           |
70297 |                  |                 | generated        |                  |
70298 |                  |                 | functions,       |                  |
70299 |                  |                 | overwriting the  |                  |
70300 |                  |                 | defaults from    |                  |
70301 |                  |                 | common_options.  |                  |
70302 |                  |                 | Nested           |                  |
70303 |                  |                 | dictionary.      |                  |
70304 +------------------+-----------------+------------------+------------------+
70305 
70306 Diagrams
70307 --------
70308 
70309 
70310 
70311 C++ includes: rootfinder_impl.hpp ";
70312 
70313 %feature("docstring")  casadi::FunctionInternal::mapsum_mx(const
70314 std::vector< MX > &arg, const std::string &parallelization) "
70315 
70316 [INTERNAL]  Parallel evaluation.
70317 
70318 ";
70319 
70320 %feature("docstring")  casadi::FunctionInternal::codegen_meta(CodeGenerator
70321 &g) const  "
70322 
70323 [INTERNAL]  Generate meta-information allowing a user to evaluate a
70324 generated function.
70325 
70326 ";
70327 
70328 %feature("docstring")  casadi::FunctionInternal::sx_in(casadi_int ind) const
70329 "
70330 
70331 [INTERNAL]  Get function input(s) and output(s)
70332 
70333 ";
70334 
70335 %feature("docstring")  casadi::FunctionInternal::sx_in() const  "
70336 
70337 [INTERNAL]  Get function input(s) and output(s)
70338 
70339 ";
70340 
70341 %feature("docstring")  casadi::FunctionInternal::call_gen(const MXVector
70342 &arg, MXVector &res, casadi_int npar, bool always_inline, bool never_inline)
70343 const  "
70344 
70345 [INTERNAL]   Call a function, overloaded.
70346 
70347 ";
70348 
70349 %feature("docstring")  casadi::FunctionInternal::call_gen(const std::vector<
70350 MatrixCommon > &arg, std::vector< MatrixCommon > &res, casadi_int npar, bool
70351 always_inline, bool never_inline) const  "
70352 
70353 [INTERNAL]   Call a function, overloaded.
70354 
70355 ";
70356 
70357 %feature("docstring")  casadi::OracleFunction::finalize()  "
70358 
70359 [INTERNAL]  Finalize initialization.
70360 
70361 ";
70362 
70363 %feature("docstring")  casadi::Rootfinder::get_n_out()  "
70364 
70365 [INTERNAL]  Number of function inputs and outputs.
70366 
70367 ";
70368 
70369 %feature("docstring")  casadi::FunctionInternal::which_depends(const
70370 std::string &s_in, const std::vector< std::string > &s_out, casadi_int
70371 order, bool tr=false) const  "
70372 
70373 [INTERNAL]  Which variables enter with some order.
70374 
70375 Parameters:
70376 -----------
70377 
70378 s_in:   Input name
70379 
70380 s_out:   Output name(s)
70381 
70382 order:  Only 1 (linear) and 2 (nonlinear) allowed
70383 
70384 tr:  Flip the relationship. Return which expressions contain the variables
70385 
70386 ";
70387 
70388 %feature("docstring")  casadi::FunctionInternal::convert_res(const
70389 std::vector< M > &res) const  "
70390 
70391 [INTERNAL]  Convert from/to input/output lists/map.
70392 
70393 ";
70394 
70395 %feature("docstring")  casadi::FunctionInternal::convert_res(const std::map<
70396 std::string, M > &res) const  "
70397 
70398 [INTERNAL]  Convert from/to input/output lists/map.
70399 
70400 ";
70401 
70402 %feature("docstring")  casadi::Rootfinder::sp_forward(const bvec_t **arg,
70403 bvec_t **res, casadi_int *iw, bvec_t *w, void *mem) const  "
70404 
70405 [INTERNAL]  Propagate sparsity forward.
70406 
70407 ";
70408 
70409 %feature("docstring")  casadi::OracleFunction::alloc_mem() const  "
70410 
70411 [INTERNAL]  Create memory block.
70412 
70413 ";
70414 
70415 %feature("docstring")  casadi::FunctionInternal::get_jacobian_sparsity()
70416 const  "
70417 
70418 [INTERNAL]  Get Jacobian sparsity.
70419 
70420 ";
70421 
70422 %feature("docstring")  casadi::SharedObjectInternal::class_name() const  "
70423 
70424 [INTERNAL]  Readable name of the internal class.
70425 
70426 ";
70427 
70428 %feature("docstring")  casadi::FunctionInternal::is_a(const std::string
70429 &type, bool recursive) const  "
70430 
70431 [INTERNAL]  Check if the function is of a particular type.
70432 
70433 ";
70434 
70435 %feature("docstring")  casadi::FunctionInternal::nz_in(const std::vector< DM
70436 > &arg) const  "
70437 
70438 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
70439 
70440 ";
70441 
70442 %feature("docstring")  casadi::FunctionInternal::nz_in(const std::vector<
70443 double > &arg) const  "
70444 
70445 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
70446 
70447 ";
70448 
70449 %feature("docstring")
70450 casadi::FunctionInternal::getJacSparsityGen(casadi_int iind, casadi_int
70451 oind, bool symmetric, casadi_int gr_i=1, casadi_int gr_o=1) const  "
70452 
70453 [INTERNAL]  Get the sparsity pattern, forward mode.
70454 
70455 ";
70456 
70457 %feature("docstring")  casadi::FunctionInternal::has_jacobian() const  "
70458 
70459 [INTERNAL]  Return Jacobian of all input elements with respect to all output
70460 elements.
70461 
70462 ";
70463 
70464 %feature("docstring")  casadi::FunctionInternal::get_jacobian(const
70465 std::string &name, const std::vector< std::string > &inames, const
70466 std::vector< std::string > &onames, const Dict &opts) const  "
70467 
70468 [INTERNAL]  Return Jacobian of all input elements with respect to all output
70469 elements.
70470 
70471 ";
70472 
70473 %feature("docstring")
70474 casadi::FunctionInternal::codegen_sparsities(CodeGenerator &g) const  "
70475 
70476 [INTERNAL]  Codegen sparsities.
70477 
70478 ";
70479 
70480 %feature("docstring")  casadi::Rootfinder::sp_reverse(bvec_t **arg, bvec_t
70481 **res, casadi_int *iw, bvec_t *w, void *mem) const  "
70482 
70483 [INTERNAL]  Propagate sparsity backwards.
70484 
70485 ";
70486 
70487 %feature("docstring")  casadi::FunctionInternal::export_code(const
70488 std::string &lang, std::ostream &stream, const Dict &options) const  "
70489 
70490 [INTERNAL]  Export function in a specific language.
70491 
70492 ";
70493 
70494 %feature("docstring")  casadi::FunctionInternal::map(casadi_int n, const
70495 std::string &parallelization) const  "
70496 
70497 [INTERNAL]  Generate/retrieve cached serial map.
70498 
70499 ";
70500 
70501 %feature("docstring")  casadi::FunctionInternal::eval_dm(const std::vector<
70502 DM > &arg) const  "
70503 
70504 [INTERNAL]  Evaluate with DM matrices.
70505 
70506 ";
70507 
70508 %feature("docstring")  casadi::FunctionInternal::setup(void *mem, const
70509 double **arg, double **res, casadi_int *iw, double *w) const  "
70510 
70511 [INTERNAL]  Set the (persistent and temporary) work vectors.
70512 
70513 ";
70514 
70515 %feature("docstring")  casadi::ProtoFunction::print(const char *fmt,...)
70516 const  "
70517 
70518 [INTERNAL]  C-style formatted printing during evaluation.
70519 
70520 ";
70521 
70522 %feature("docstring")  casadi::FunctionInternal::numel_out(casadi_int ind)
70523 const  "
70524 
70525 [INTERNAL]  Number of input/output elements.
70526 
70527 ";
70528 
70529 %feature("docstring")  casadi::FunctionInternal::numel_out() const  "
70530 
70531 [INTERNAL]  Number of input/output elements.
70532 
70533 ";
70534 
70535 %feature("docstring")  casadi::PluginInterface< Rootfinder  >::plugin_name()
70536 const  "
70537 
70538 [INTERNAL] ";
70539 
70540 %feature("docstring")  casadi::FunctionInternal::signature(const std::string
70541 &fname) const  "
70542 
70543 [INTERNAL]  Code generate the function.
70544 
70545 ";
70546 
70547 %feature("docstring")  casadi::FunctionInternal::size2_in(casadi_int ind)
70548 const  "
70549 
70550 [INTERNAL]  Input/output dimensions.
70551 
70552 ";
70553 
70554 %feature("docstring")  casadi::ProtoFunction::format_time(char *buffer,
70555 double time) const  "
70556 
70557 [INTERNAL]  Format time in a fixed width 8 format.
70558 
70559 ";
70560 
70561 %feature("docstring")  casadi::FunctionInternal::getJacSparsity(casadi_int
70562 iind, casadi_int oind, bool symmetric) const  "
70563 
70564 [INTERNAL]  Generate the sparsity of a Jacobian block.
70565 
70566 ";
70567 
70568 %feature("docstring")  casadi::FunctionInternal::get_partition(casadi_int
70569 iind, casadi_int oind, Sparsity &D1, Sparsity &D2, bool compact, bool
70570 symmetric, bool allow_forward, bool allow_reverse) const  "
70571 
70572 [INTERNAL]  Get the unidirectional or bidirectional partition.
70573 
70574 ";
70575 
70576 %feature("docstring")
70577 casadi::FunctionInternal::getJacSparsityHierarchical(casadi_int iind,
70578 casadi_int oind) const  "
70579 
70580 [INTERNAL]  A flavor of getJacSparsity that does hierarchical block
70581 structure recognition.
70582 
70583 ";
70584 
70585 %feature("docstring")  casadi::Rootfinder::ad_reverse(const std::vector< MX
70586 > &arg, const std::vector< MX > &res, const std::vector< std::vector< MX > >
70587 &aseed, std::vector< std::vector< MX > > &asens, bool always_inline, bool
70588 never_inline) const  "
70589 
70590 [INTERNAL]  Create call to (cached) derivative function, reverse mode.
70591 
70592 ";
70593 
70594 %feature("docstring")  casadi::Rootfinder::serialize_base_function() const
70595 "
70596 
70597 [INTERNAL]  String used to identify the immediate FunctionInternal subclass.
70598 
70599 ";
70600 
70601 %feature("docstring")  casadi::FunctionInternal::n_instructions() const  "
70602 
70603 [INTERNAL]  Get the number of atomic operations.
70604 
70605 ";
70606 
70607 %feature("docstring")  casadi::FunctionInternal::call_forward(const
70608 std::vector< MX > &arg, const std::vector< MX > &res, const std::vector<
70609 std::vector< MX > > &fseed, std::vector< std::vector< MX > > &fsens, bool
70610 always_inline, bool never_inline) const  "
70611 
70612 [INTERNAL]  Forward mode AD, virtual functions overloaded in derived
70613 classes.
70614 
70615 ";
70616 
70617 %feature("docstring")  casadi::FunctionInternal::call_forward(const
70618 std::vector< SX > &arg, const std::vector< SX > &res, const std::vector<
70619 std::vector< SX > > &fseed, std::vector< std::vector< SX > > &fsens, bool
70620 always_inline, bool never_inline) const  "
70621 
70622 [INTERNAL]  Forward mode AD, virtual functions overloaded in derived
70623 classes.
70624 
70625 ";
70626 
70627 %feature("docstring")  casadi::OracleFunction::create_function(const
70628 std::string &fname, const std::vector< std::string > &s_in, const
70629 std::vector< std::string > &s_out, const Function::AuxOut
70630 &aux=Function::AuxOut()) "
70631 
70632 [INTERNAL]  Create an oracle function
70633 
70634 ";
70635 
70636 %feature("docstring")  casadi::OracleFunction::jit_dependencies(const
70637 std::string &fname)  "
70638 
70639 [INTERNAL]  JIT for dependencies.
70640 
70641 ";
70642 
70643 %feature("docstring")  casadi::FunctionInternal::nnz_in() const  "
70644 
70645 [INTERNAL]  Number of input/output nonzeros.
70646 
70647 ";
70648 
70649 %feature("docstring")  casadi::FunctionInternal::nnz_in(casadi_int ind)
70650 const  "
70651 
70652 [INTERNAL]  Number of input/output nonzeros.
70653 
70654 ";
70655 
70656 %feature("docstring")  casadi::FunctionInternal::has_jacobian_sparsity()
70657 const  "
70658 
70659 [INTERNAL]  Get Jacobian sparsity.
70660 
70661 ";
70662 
70663 %feature("docstring")  casadi::Rootfinder::get_sparsity_in(casadi_int i)  "
70664 
70665 [INTERNAL]  Sparsities of function inputs and outputs.
70666 
70667 ";
70668 
70669 %feature("docstring")  casadi::FunctionInternal::sparsity_in(casadi_int ind)
70670 const  "
70671 
70672 [INTERNAL]  Input/output sparsity.
70673 
70674 ";
70675 
70676 %feature("docstring")  casadi::FunctionInternal::sz_res() const  "
70677 
70678 [INTERNAL]  Get required length of res field.
70679 
70680 ";
70681 
70682 %feature("docstring")  casadi::FunctionInternal::check_arg(const
70683 std::vector< M > &arg, casadi_int &npar) const  "
70684 
70685 [INTERNAL]  Check if input arguments have correct length and dimensions.
70686 
70687 Raises errors.
70688 
70689 Parameters:
70690 -----------
70691 
70692 npar[in]:  normal usage: 1, disallow pararallel calls: -1
70693 
70694 npar:  max number of horizontal repetitions across all arguments (or -1)
70695 
70696 ";
70697 
70698 %feature("docstring")  casadi::ProtoFunction::construct(const Dict &opts) "
70699 
70700 [INTERNAL]  Construct Prepares the function for evaluation.
70701 
70702 ";
70703 
70704 %feature("docstring")  casadi::FunctionInternal::jacobian_sparsity() const
70705 "
70706 
70707 [INTERNAL]  Get Jacobian sparsity.
70708 
70709 ";
70710 
70711 %feature("docstring")  casadi::FunctionInternal::has_eval_dm() const  "
70712 
70713 [INTERNAL]  Evaluate with DM matrices.
70714 
70715 ";
70716 
70717 %feature("docstring")  casadi::FunctionInternal::is_diff_in(casadi_int i) "
70718 
70719 [INTERNAL] ";
70720 
70721 %feature("docstring")  casadi::ProtoFunction::checkout() const  "
70722 
70723 [INTERNAL]  Checkout a memory object.
70724 
70725 ";
70726 
70727 %feature("docstring")  casadi::FunctionInternal::eval_mx(const MXVector
70728 &arg, MXVector &res, bool always_inline, bool never_inline) const  "
70729 
70730 [INTERNAL]  Evaluate with symbolic matrices.
70731 
70732 ";
70733 
70734 %feature("docstring")  casadi::FunctionInternal::index_in(const std::string
70735 &name) const  "
70736 
70737 [INTERNAL]  Get input scheme index by name.
70738 
70739 ";
70740 
70741 %feature("docstring")  casadi::OracleFunction::has_function(const
70742 std::string &fname) const  "
70743 
70744 [INTERNAL] ";
70745 
70746 %feature("docstring")  casadi::SharedObjectInternal::weak() "
70747 
70748 [INTERNAL]  Get a weak reference to the object.
70749 
70750 ";
70751 
70752 %feature("docstring")  casadi::FunctionInternal::mx_out(casadi_int ind)
70753 const  "
70754 
70755 [INTERNAL]  Get function input(s) and output(s)
70756 
70757 ";
70758 
70759 %feature("docstring")  casadi::FunctionInternal::mx_out() const  "
70760 
70761 [INTERNAL]  Get function input(s) and output(s)
70762 
70763 ";
70764 
70765 %feature("docstring")
70766 casadi::FunctionInternal::instruction_output(casadi_int k) const  "
70767 
70768 [INTERNAL]  Get the (integer) output argument of an atomic operation.
70769 
70770 ";
70771 
70772 %feature("docstring")  casadi::FunctionInternal::ad_weight() const  "
70773 
70774 [INTERNAL]  Weighting factor for chosing forward/reverse mode.
70775 
70776 ";
70777 
70778 %feature("docstring")  casadi::Rootfinder::get_stats(void *mem) const  "
70779 
70780 [INTERNAL]  Get all statistics.
70781 
70782 ";
70783 
70784 %feature("docstring")  casadi::FunctionInternal::size1_in(casadi_int ind)
70785 const  "
70786 
70787 [INTERNAL]  Input/output dimensions.
70788 
70789 ";
70790 
70791 %feature("docstring")  casadi::FunctionInternal::instructions_sx() const  "
70792 
70793 [INTERNAL]  get SX expression associated with instructions
70794 
70795 ";
70796 
70797 %feature("docstring")  casadi::FunctionInternal::has_codegen() const  "
70798 
70799 [INTERNAL]  Is codegen supported?
70800 
70801 ";
70802 
70803 %feature("docstring")  casadi::FunctionInternal::size_out(casadi_int ind)
70804 const  "
70805 
70806 [INTERNAL]  Input/output dimensions.
70807 
70808 ";
70809 
70810 %feature("docstring")  casadi::FunctionInternal::sz_arg() const  "
70811 
70812 [INTERNAL]  Get required length of arg field.
70813 
70814 ";
70815 
70816 %feature("docstring")
70817 casadi::FunctionInternal::instruction_constant(casadi_int k) const  "
70818 
70819 [INTERNAL]  Get the floating point output argument of an atomic operation.
70820 
70821 ";
70822 
70823 %feature("docstring")  casadi::FunctionInternal::project_arg(const
70824 std::vector< M > &arg, casadi_int npar) const  "
70825 
70826 [INTERNAL]   Project sparsities.
70827 
70828 ";
70829 
70830 %feature("docstring")  casadi::FunctionInternal::get_reltol() const  "
70831 
70832 [INTERNAL]  Get relative tolerance.
70833 
70834 ";
70835 
70836 %feature("docstring")  casadi::FunctionInternal::adjViaJac(casadi_int nadj)
70837 const  "
70838 
70839 [INTERNAL]  Calculate derivatives by multiplying the full Jacobian and
70840 multiplying.
70841 
70842 ";
70843 
70844 %feature("docstring")  casadi::FunctionInternal::size2_out(casadi_int ind)
70845 const  "
70846 
70847 [INTERNAL]  Input/output dimensions.
70848 
70849 ";
70850 
70851 %feature("docstring")
70852 casadi::FunctionInternal::getJacSparsityHierarchicalSymm(casadi_int iind,
70853 casadi_int oind) const  "
70854 
70855 [INTERNAL]  A flavor of getJacSparsity that does hierarchical block
70856 structure recognition for symmetric Jacobians
70857 
70858 ";
70859 
70860 %feature("docstring")
70861 casadi::FunctionInternal::codegen_free_mem(CodeGenerator &g) const  "
70862 
70863 [INTERNAL]  Codegen for free_mem.
70864 
70865 ";
70866 
70867 %feature("docstring")  casadi::FunctionInternal::size1_out(casadi_int ind)
70868 const  "
70869 
70870 [INTERNAL]  Input/output dimensions.
70871 
70872 ";
70873 
70874 %feature("docstring")  casadi::FunctionInternal::codegen_body(CodeGenerator
70875 &g) const  "
70876 
70877 [INTERNAL]  Generate code for the function body.
70878 
70879 ";
70880 
70881 %feature("docstring")  casadi::FunctionInternal::eval_gen(const double
70882 **arg, double **res, casadi_int *iw, double *w, void *mem) const  "
70883 
70884 [INTERNAL]  Evaluate numerically.
70885 
70886 ";
70887 
70888 %feature("docstring")  casadi::FunctionInternal::eval_gen(const SXElem
70889 **arg, SXElem **res, casadi_int *iw, SXElem *w, void *mem) const  "
70890 
70891 [INTERNAL]  Evaluate a function, overloaded.
70892 
70893 ";
70894 
70895 %feature("docstring")  casadi::FunctionInternal::eval_gen(const bvec_t
70896 **arg, bvec_t **res, casadi_int *iw, bvec_t *w, void *mem) const  "
70897 
70898 [INTERNAL]  Evaluate a function, overloaded.
70899 
70900 ";
70901 
70902 %feature("docstring")  casadi::Rootfinder::get_forward(casadi_int nfwd,
70903 const std::string &name, const std::vector< std::string > &inames, const
70904 std::vector< std::string > &onames, const Dict &opts) const  "
70905 
70906 [INTERNAL]  Generate a function that calculates nfwd forward derivatives.
70907 
70908 ";
70909 
70910 %feature("docstring")  casadi::Rootfinder::set_work(void *mem, const double
70911 **&arg, double **&res, casadi_int *&iw, double *&w) const  "
70912 
70913 [INTERNAL]  Set the (persistent) work vectors.
70914 
70915 ";
70916 
70917 %feature("docstring")  casadi::ProtoFunction::clear_mem() "
70918 
70919 [INTERNAL]  Clear all memory (called from destructor)
70920 
70921 ";
70922 
70923 %feature("docstring")  casadi::FunctionInternal::project_res(const
70924 std::vector< M > &arg, casadi_int npar) const  "
70925 
70926 [INTERNAL]   Project sparsities.
70927 
70928 ";
70929 
70930 %feature("docstring")  casadi::FunctionInternal::generate_in(const
70931 std::string &fname, const double **arg) const  "
70932 
70933 [INTERNAL]  Export an input file that can be passed to generate C code with
70934 a main.
70935 
70936 ";
70937 
70938 %feature("docstring")  casadi::FunctionInternal::symbolic_output(const
70939 std::vector< MX > &arg) const  "
70940 
70941 [INTERNAL]  Get a vector of symbolic variables corresponding to the outputs.
70942 
70943 ";
70944 
70945 %feature("docstring")  casadi::FunctionInternal::codegen_mem(CodeGenerator
70946 &g, const std::string &index="mem") const  "
70947 
70948 [INTERNAL]  Get thread-local memory object.
70949 
70950 ";
70951 
70952 %feature("docstring")  casadi::Rootfinder::get_options() const  "
70953 
70954 [INTERNAL]  Options.
70955 
70956 ";
70957 
70958 %feature("docstring")  casadi::Rootfinder::uses_output() const  "
70959 
70960 [INTERNAL]  Do the derivative functions need nondifferentiated outputs?
70961 
70962 ";
70963 
70964 %feature("docstring")  casadi::FunctionInternal::factory(const std::string
70965 &name, const std::vector< std::string > &s_in, const std::vector<
70966 std::string > &s_out, const Function::AuxOut &aux, const Dict &opts) const
70967 "
70968 
70969 [INTERNAL] ";
70970 
70971 %feature("docstring")  casadi::FunctionInternal::get_jac(const std::string
70972 &name, const std::vector< std::string > &inames, const std::vector<
70973 std::string > &onames, const Dict &opts) const  "
70974 
70975 [INTERNAL]  Return Jacobian of all input elements with respect to all output
70976 elements.
70977 
70978 ";
70979 
70980 %feature("docstring")  casadi::FunctionInternal::print_options(std::ostream
70981 &stream) const  "
70982 
70983 [INTERNAL]  Print list of options.
70984 
70985 ";
70986 
70987 %feature("docstring")  casadi::FunctionInternal::get_max_in(casadi_int ind)
70988 const  "
70989 
70990 [INTERNAL]  Get largest input value.
70991 
70992 ";
70993 
70994 %feature("docstring")  casadi::ProtoFunction::sprint(char *buf, size_t
70995 buf_sz, const char *fmt,...) const  "
70996 
70997 [INTERNAL]  C-style formatted printing to string.
70998 
70999 ";
71000 
71001 %feature("docstring")  casadi::FunctionInternal::sparsity_out(casadi_int
71002 ind) const  "
71003 
71004 [INTERNAL]  Input/output sparsity.
71005 
71006 ";
71007 
71008 %feature("docstring")  casadi::FunctionInternal::wrap_as_needed(const Dict
71009 &opts) const  "
71010 
71011 [INTERNAL]  Wrap in an Function instance consisting of only one MX call.
71012 
71013 ";
71014 
71015 %feature("docstring")  casadi::Rootfinder::eval(const double **arg, double
71016 **res, casadi_int *iw, double *w, void *mem) const  "
71017 
71018 [INTERNAL]  Evaluate numerically.
71019 
71020 ";
71021 
71022 %feature("docstring")  casadi::FunctionInternal::codegen(CodeGenerator &g,
71023 const std::string &fname) const  "
71024 
71025 [INTERNAL]  Generate code the function.
71026 
71027 ";
71028 
71029 %feature("docstring")
71030 casadi::FunctionInternal::codegen_declarations(CodeGenerator &g) const  "
71031 
71032 [INTERNAL]  Generate code for the declarations of the C function.
71033 
71034 ";
71035 
71036 %feature("docstring")  casadi::OracleFunction::generate_dependencies(const
71037 std::string &fname, const Dict &opts) const  "
71038 
71039 [INTERNAL]  Export / Generate C code for the generated functions.
71040 
71041 ";
71042 
71043 %feature("docstring")  casadi::Rootfinder::get_reverse(casadi_int nadj,
71044 const std::string &name, const std::vector< std::string > &inames, const
71045 std::vector< std::string > &onames, const Dict &opts) const  "
71046 
71047 [INTERNAL]  Generate a function that calculates nadj adjoint derivatives.
71048 
71049 ";
71050 
71051 %feature("docstring")  casadi::FunctionInternal::incache(const std::string
71052 &fname, Function &f, const std::string &suffix="") const  "
71053 
71054 [INTERNAL]  Get function in cache.
71055 
71056 ";
71057 
71058 %feature("docstring")  casadi::FunctionInternal::free_mx() const  "
71059 
71060 [INTERNAL]  Get free variables ( MX)
71061 
71062 ";
71063 
71064 %feature("docstring")  casadi::FunctionInternal::mx_in(casadi_int ind) const
71065 "
71066 
71067 [INTERNAL]  Get function input(s) and output(s)
71068 
71069 ";
71070 
71071 %feature("docstring")  casadi::FunctionInternal::mx_in() const  "
71072 
71073 [INTERNAL]  Get function input(s) and output(s)
71074 
71075 ";
71076 
71077 
71078 // File: classcasadi_1_1RungeKutta.xml
71079 %feature("docstring")  casadi::Integrator::rx() const  "
71080 
71081 [INTERNAL] ";
71082 
71083 %feature("docstring")  casadi::Integrator::rz() const  "
71084 
71085 [INTERNAL] ";
71086 
71087 %feature("docstring")  casadi::FunctionInternal::jacobian_sparsity() const
71088 "
71089 
71090 [INTERNAL]  Get Jacobian sparsity.
71091 
71092 ";
71093 
71094 %feature("docstring") casadi::RungeKutta::~RungeKutta "
71095 
71096 [INTERNAL]  Destructor.
71097 
71098 ";
71099 
71100 %feature("docstring")  casadi::Integrator::serialize_base_function() const
71101 "
71102 
71103 [INTERNAL]  String used to identify the immediate FunctionInternal subclass.
71104 
71105 ";
71106 
71107 %feature("docstring")  casadi::Integrator::rq() const  "
71108 
71109 [INTERNAL] ";
71110 
71111 %feature("docstring")  casadi::Integrator::rp() const  "
71112 
71113 [INTERNAL] ";
71114 
71115 %feature("docstring")  casadi::OracleFunction::jit_dependencies(const
71116 std::string &fname)  "
71117 
71118 [INTERNAL]  JIT for dependencies.
71119 
71120 ";
71121 
71122 %feature("docstring")  casadi::FunctionInternal::sz_arg() const  "
71123 
71124 [INTERNAL]  Get required length of arg field.
71125 
71126 ";
71127 
71128 %feature("docstring")  casadi::Integrator::has_forward(casadi_int nfwd)
71129 const  "
71130 
71131 [INTERNAL]  Generate a function that calculates nfwd forward derivatives.
71132 
71133 ";
71134 
71135 %feature("docstring")  casadi::Integrator::aug_fwd(casadi_int nfwd) const  "
71136 
71137 [INTERNAL]  Generate a augmented DAE system with nfwd forward sensitivities.
71138 
71139 ";
71140 
71141 %feature("docstring")  casadi::FunctionInternal::instruction_MX(casadi_int
71142 k) const  "
71143 
71144 [INTERNAL]  get MX expression associated with instruction
71145 
71146 ";
71147 
71148 %feature("docstring")  casadi::FunctionInternal::sparsity_out(casadi_int
71149 ind) const  "
71150 
71151 [INTERNAL]  Input/output sparsity.
71152 
71153 ";
71154 
71155 %feature("docstring")  casadi::FunctionInternal::all_scalar() const  "
71156 
71157 [INTERNAL]  Are all inputs and outputs scalar.
71158 
71159 ";
71160 
71161 %feature("docstring")  casadi::OracleFunction::finalize()  "
71162 
71163 [INTERNAL]  Finalize initialization.
71164 
71165 ";
71166 
71167 %feature("docstring")  casadi::FunctionInternal::call_gen(const MXVector
71168 &arg, MXVector &res, casadi_int npar, bool always_inline, bool never_inline)
71169 const  "
71170 
71171 [INTERNAL]   Call a function, overloaded.
71172 
71173 ";
71174 
71175 %feature("docstring")  casadi::FunctionInternal::call_gen(const std::vector<
71176 MatrixCommon > &arg, std::vector< MatrixCommon > &res, casadi_int npar, bool
71177 always_inline, bool never_inline) const  "
71178 
71179 [INTERNAL]   Call a function, overloaded.
71180 
71181 ";
71182 
71183 %feature("docstring")  casadi::FunctionInternal::export_code(const
71184 std::string &lang, std::ostream &stream, const Dict &options) const  "
71185 
71186 [INTERNAL]  Export function in a specific language.
71187 
71188 ";
71189 
71190 %feature("docstring")  casadi::Integrator::has_spfwd() const  "
71191 
71192 [INTERNAL]  Is the class able to propagate seeds through the algorithm?
71193 
71194 ";
71195 
71196 %feature("docstring")  casadi::FunctionInternal::size2_in(casadi_int ind)
71197 const  "
71198 
71199 [INTERNAL]  Input/output dimensions.
71200 
71201 ";
71202 
71203 %feature("docstring")  casadi::RungeKutta::class_name() const  "
71204 
71205 [INTERNAL]  Readable name of the internal class.
71206 
71207 ";
71208 
71209 %feature("docstring")  casadi::FunctionInternal::has_jac() const  "
71210 
71211 [INTERNAL]  Return Jacobian of all input elements with respect to all output
71212 elements.
71213 
71214 ";
71215 
71216 %feature("docstring")  casadi::FunctionInternal::alloc_res(size_t sz_res,
71217 bool persistent=false) "
71218 
71219 [INTERNAL]  Ensure required length of res field.
71220 
71221 ";
71222 
71223 %feature("docstring")  casadi::ProtoFunction::memory(int ind) const  "
71224 
71225 [INTERNAL]  Memory objects.
71226 
71227 ";
71228 
71229 %feature("docstring")  casadi::FixedStepIntegrator::create_advanced(const
71230 Dict &opts)  "
71231 
71232 [INTERNAL]  Helper for a more powerful 'integrator' factory
71233 
71234 ";
71235 
71236 %feature("docstring")  casadi::FunctionInternal::wrap_as_needed(const Dict
71237 &opts) const  "
71238 
71239 [INTERNAL]  Wrap in an Function instance consisting of only one MX call.
71240 
71241 ";
71242 
71243 %feature("docstring")  casadi::OracleFunction::expand() "
71244 
71245 [INTERNAL] ";
71246 
71247 %feature("docstring")  casadi::FunctionInternal::index_in(const std::string
71248 &name) const  "
71249 
71250 [INTERNAL]  Get input scheme index by name.
71251 
71252 ";
71253 
71254 %feature("docstring")  casadi::FunctionInternal::map(casadi_int n, const
71255 std::string &parallelization) const  "
71256 
71257 [INTERNAL]  Generate/retrieve cached serial map.
71258 
71259 ";
71260 
71261 %feature("docstring")  casadi::FunctionInternal::disp(std::ostream &stream,
71262 bool more) const  "
71263 
71264 [INTERNAL]  Display object.
71265 
71266 ";
71267 
71268 %feature("docstring")  casadi::Integrator::print_stats(IntegratorMemory
71269 *mem) const  "
71270 
71271 [INTERNAL]  Print solver statistics.
71272 
71273 ";
71274 
71275 %feature("docstring")  casadi::FunctionInternal::symbolicAdjSeed(casadi_int
71276 nadj, const std::vector< MatType > &v) const  "
71277 
71278 [INTERNAL]  Symbolic expressions for the adjoint seeds.
71279 
71280 ";
71281 
71282 %feature("docstring")  casadi::Integrator::setStopTime(IntegratorMemory
71283 *mem, double tf) const  "
71284 
71285 [INTERNAL]  Set stop time for the integration.
71286 
71287 ";
71288 
71289 %feature("docstring")  casadi::FunctionInternal::matching_arg(const
71290 std::vector< M > &arg, casadi_int &npar) const  "
71291 
71292 [INTERNAL]  Check if input arguments that needs to be replaced.
71293 
71294 Raises errors
71295 
71296 Parameters:
71297 -----------
71298 
71299 npar[in]:  normal usage: 1, disallow pararallel calls: -1
71300 
71301 npar:  max number of horizontal repetitions across all arguments (or -1)
71302 
71303 ";
71304 
71305 %feature("docstring")  casadi::FunctionInternal::nnz_in() const  "
71306 
71307 [INTERNAL]  Number of input/output nonzeros.
71308 
71309 ";
71310 
71311 %feature("docstring")  casadi::FunctionInternal::nnz_in(casadi_int ind)
71312 const  "
71313 
71314 [INTERNAL]  Number of input/output nonzeros.
71315 
71316 ";
71317 
71318 %feature("docstring")  casadi::FunctionInternal::sz_w() const  "
71319 
71320 [INTERNAL]  Get required length of w field.
71321 
71322 ";
71323 
71324 %feature("docstring")  casadi::Integrator::get_n_in()  "
71325 
71326 [INTERNAL]  Number of function inputs and outputs.
71327 
71328 ";
71329 
71330 %feature("docstring")  casadi::ProtoFunction::print(const char *fmt,...)
71331 const  "
71332 
71333 [INTERNAL]  C-style formatted printing during evaluation.
71334 
71335 ";
71336 
71337 %feature("docstring")  casadi::SharedObjectInternal::getCount() const  "
71338 
71339 [INTERNAL]  Get the reference count.
71340 
71341 ";
71342 
71343 %feature("docstring")  casadi::FunctionInternal::incache(const std::string
71344 &fname, Function &f, const std::string &suffix="") const  "
71345 
71346 [INTERNAL]  Get function in cache.
71347 
71348 ";
71349 
71350 %feature("docstring")  casadi::FunctionInternal::numel_in() const  "
71351 
71352 [INTERNAL]  Number of input/output elements.
71353 
71354 ";
71355 
71356 %feature("docstring")  casadi::FunctionInternal::numel_in(casadi_int ind)
71357 const  "
71358 
71359 [INTERNAL]  Number of input/output elements.
71360 
71361 ";
71362 
71363 %feature("docstring")  casadi::FunctionInternal::self() const  "
71364 
71365 [INTERNAL]  Get a public class instance.
71366 
71367 ";
71368 
71369 %feature("docstring")
71370 casadi::FunctionInternal::codegen_free_mem(CodeGenerator &g) const  "
71371 
71372 [INTERNAL]  Codegen for free_mem.
71373 
71374 ";
71375 
71376 %feature("docstring")  casadi::FixedStepIntegrator::getExplicit() const  "
71377 
71378 [INTERNAL]  Get explicit dynamics.
71379 
71380 ";
71381 
71382 %feature("docstring")  casadi::FunctionInternal::check_res(const
71383 std::vector< M > &res, casadi_int &npar) const  "
71384 
71385 [INTERNAL]  Check if output arguments have correct length and dimensions.
71386 
71387 Raises errors.
71388 
71389 Parameters:
71390 -----------
71391 
71392 npar[in]:  normal usage: 1, disallow pararallel calls: -1
71393 
71394 npar:  max number of horizontal repetitions across all arguments (or -1)
71395 
71396 ";
71397 
71398 %feature("docstring")  casadi::FunctionInternal::convert_res(const
71399 std::vector< M > &res) const  "
71400 
71401 [INTERNAL]  Convert from/to input/output lists/map.
71402 
71403 ";
71404 
71405 %feature("docstring")  casadi::FunctionInternal::convert_res(const std::map<
71406 std::string, M > &res) const  "
71407 
71408 [INTERNAL]  Convert from/to input/output lists/map.
71409 
71410 ";
71411 
71412 %feature("docstring")  casadi::Integrator::get_name_in(casadi_int i)  "
71413 
71414 [INTERNAL]  Names of function input and outputs.
71415 
71416 ";
71417 
71418 %feature("docstring")  casadi::FunctionInternal::reverse(casadi_int nadj)
71419 const  "
71420 
71421 [INTERNAL]  Return function that calculates adjoint derivatives
71422 reverse(nadj) returns a cached instance if available, and calls  Function
71423 get_reverse(casadi_int nadj) if no cached version is available.
71424 
71425 ";
71426 
71427 %feature("docstring")  casadi::FunctionInternal::get_jac(const std::string
71428 &name, const std::vector< std::string > &inames, const std::vector<
71429 std::string > &onames, const Dict &opts) const  "
71430 
71431 [INTERNAL]  Return Jacobian of all input elements with respect to all output
71432 elements.
71433 
71434 ";
71435 
71436 %feature("docstring")  casadi::FunctionInternal::eval_sx(const SXElem **arg,
71437 SXElem **res, casadi_int *iw, SXElem *w, void *mem) const  "
71438 
71439 [INTERNAL]  Evaluate with symbolic scalars.
71440 
71441 ";
71442 
71443 %feature("docstring")  casadi::Integrator::sp_jac_rdae() "
71444 
71445 [INTERNAL]  Create sparsity pattern of the extended Jacobian (backward
71446 problem)
71447 
71448 ";
71449 
71450 %feature("docstring")  casadi::FunctionInternal::codegen_name(const
71451 CodeGenerator &g, bool ns=true) const  "
71452 
71453 [INTERNAL]  Get name in codegen.
71454 
71455 ";
71456 
71457 %feature("docstring")  casadi::Integrator::p() const  "
71458 
71459 [INTERNAL] ";
71460 
71461 %feature("docstring")  casadi::Integrator::q() const  "
71462 
71463 [INTERNAL] ";
71464 
71465 %feature("docstring")  casadi::Integrator::t() const  "
71466 
71467 [INTERNAL] ";
71468 
71469 %feature("docstring")  casadi::Integrator::z() const  "
71470 
71471 [INTERNAL] ";
71472 
71473 %feature("docstring")  casadi::FunctionInternal::mx_out(casadi_int ind)
71474 const  "
71475 
71476 [INTERNAL]  Get function input(s) and output(s)
71477 
71478 ";
71479 
71480 %feature("docstring")  casadi::FunctionInternal::mx_out() const  "
71481 
71482 [INTERNAL]  Get function input(s) and output(s)
71483 
71484 ";
71485 
71486 %feature("docstring")  casadi::Integrator::x() const  "
71487 
71488 [INTERNAL] ";
71489 
71490 %feature("docstring")  casadi::FunctionInternal::check_mat(const Sparsity
71491 &arg, const Sparsity &inp, casadi_int &npar) "
71492 
71493 [INTERNAL]  Helper function
71494 
71495 Parameters:
71496 -----------
71497 
71498 npar[in]:  normal usage: 1, disallow pararallel calls: -1
71499 
71500 npar[out]:  required number of parallel calls (or -1)
71501 
71502 ";
71503 
71504 %feature("docstring")  casadi::FunctionInternal::size1_in(casadi_int ind)
71505 const  "
71506 
71507 [INTERNAL]  Input/output dimensions.
71508 
71509 ";
71510 
71511 %feature("docstring")  casadi::FunctionInternal::codegen_mem(CodeGenerator
71512 &g, const std::string &index="mem") const  "
71513 
71514 [INTERNAL]  Get thread-local memory object.
71515 
71516 ";
71517 
71518 %feature("docstring") casadi::RungeKutta::RungeKutta(const std::string
71519 &name, const Function &dae) "
71520 
71521 [INTERNAL]  Constructor.
71522 
71523 ";
71524 
71525 %feature("docstring")  casadi::Integrator::sp_forward(const bvec_t **arg,
71526 bvec_t **res, casadi_int *iw, bvec_t *w, void *mem) const  "
71527 
71528 [INTERNAL]  Propagate sparsity forward.
71529 
71530 ";
71531 
71532 %feature("docstring")  casadi::FunctionInternal::factory(const std::string
71533 &name, const std::vector< std::string > &s_in, const std::vector<
71534 std::string > &s_out, const Function::AuxOut &aux, const Dict &opts) const
71535 "
71536 
71537 [INTERNAL] ";
71538 
71539 %feature("docstring")  casadi::ProtoFunction::format_time(char *buffer,
71540 double time) const  "
71541 
71542 [INTERNAL]  Format time in a fixed width 8 format.
71543 
71544 ";
71545 
71546 %feature("docstring")  casadi::FunctionInternal::alloc(const Function &f,
71547 bool persistent=false) "
71548 
71549 [INTERNAL]  Ensure work vectors long enough to evaluate function.
71550 
71551 ";
71552 
71553 %feature("docstring")  casadi::FunctionInternal::is_diff_out(casadi_int i) "
71554 
71555 [INTERNAL] ";
71556 
71557 %feature("docstring")  casadi::RungeKutta::serialize_body(SerializingStream
71558 &s) const  "
71559 
71560 [INTERNAL]  Serialize an object without type information.
71561 
71562 ";
71563 
71564 %feature("docstring")  casadi::FunctionInternal::size1_out(casadi_int ind)
71565 const  "
71566 
71567 [INTERNAL]  Input/output dimensions.
71568 
71569 ";
71570 
71571 %feature("docstring")  casadi::FunctionInternal::convert_arg(const
71572 std::vector< M > &arg) const  "
71573 
71574 [INTERNAL]  Convert from/to input/output lists/map.
71575 
71576 ";
71577 
71578 %feature("docstring")  casadi::FunctionInternal::convert_arg(const std::map<
71579 std::string, M > &arg) const  "
71580 
71581 [INTERNAL]  Convert from/to input/output lists/map.
71582 
71583 ";
71584 
71585 %feature("docstring")  casadi::FunctionInternal::tocache(const Function &f,
71586 const std::string &suffix="") const  "
71587 
71588 [INTERNAL]  Save function to cache.
71589 
71590 ";
71591 
71592 %feature("docstring")  casadi::FunctionInternal::get_free() const  "
71593 
71594 [INTERNAL]  Print free variables.
71595 
71596 ";
71597 
71598 %feature("docstring")  casadi::FunctionInternal::mapsum_mx(const
71599 std::vector< MX > &arg, const std::string &parallelization) "
71600 
71601 [INTERNAL]  Parallel evaluation.
71602 
71603 ";
71604 
71605 %feature("docstring")  casadi::OracleFunction::create_function(const
71606 std::string &fname, const std::vector< std::string > &s_in, const
71607 std::vector< std::string > &s_out, const Function::AuxOut
71608 &aux=Function::AuxOut()) "
71609 
71610 [INTERNAL]  Create an oracle function
71611 
71612 ";
71613 
71614 %feature("docstring")  casadi::FunctionInternal::generate_out(const
71615 std::string &fname, double **res) const  "
71616 
71617 [INTERNAL] ";
71618 
71619 %feature("docstring")  casadi::Integrator::get_forward(casadi_int nfwd,
71620 const std::string &name, const std::vector< std::string > &inames, const
71621 std::vector< std::string > &onames, const Dict &opts) const  "
71622 
71623 [INTERNAL]  Generate a function that calculates nfwd forward derivatives.
71624 
71625 ";
71626 
71627 %feature("docstring")  casadi::FunctionInternal::has_jacobian_sparsity()
71628 const  "
71629 
71630 [INTERNAL]  Get Jacobian sparsity.
71631 
71632 ";
71633 
71634 %feature("docstring")
71635 casadi::FunctionInternal::instruction_input(casadi_int k) const  "
71636 
71637 [INTERNAL]  Get the (integer) input arguments of an atomic operation.
71638 
71639 ";
71640 
71641 %feature("docstring")  casadi::FunctionInternal::generate_lifted(Function
71642 &vdef_fcn, Function &vinit_fcn) const  "
71643 
71644 [INTERNAL]  Extract the functions needed for the Lifted Newton method.
71645 
71646 ";
71647 
71648 %feature("docstring")  casadi::FunctionInternal::get_jacobian(const
71649 std::string &name, const std::vector< std::string > &inames, const
71650 std::vector< std::string > &onames, const Dict &opts) const  "
71651 
71652 [INTERNAL]  Return Jacobian of all input elements with respect to all output
71653 elements.
71654 
71655 ";
71656 
71657 %feature("docstring")  casadi::FunctionInternal::dm_out(casadi_int ind)
71658 const  "
71659 
71660 [INTERNAL]  Get function input(s) and output(s)
71661 
71662 ";
71663 
71664 %feature("docstring")  casadi::FunctionInternal::dm_out() const  "
71665 
71666 [INTERNAL]  Get function input(s) and output(s)
71667 
71668 ";
71669 
71670 %feature("docstring")  casadi::FunctionInternal::codegen_body(CodeGenerator
71671 &g) const  "
71672 
71673 [INTERNAL]  Generate code for the function body.
71674 
71675 ";
71676 
71677 %feature("docstring")  casadi::FunctionInternal::alloc_arg(size_t sz_arg,
71678 bool persistent=false) "
71679 
71680 [INTERNAL]  Ensure required length of arg field.
71681 
71682 ";
71683 
71684 %feature("docstring")  casadi::FunctionInternal::jac() const  "
71685 
71686 [INTERNAL]  Return Jacobian of all input elements with respect to all output
71687 elements.
71688 
71689 ";
71690 
71691 %feature("docstring")  casadi::FunctionInternal::has_eval_dm() const  "
71692 
71693 [INTERNAL]  Evaluate with DM matrices.
71694 
71695 ";
71696 
71697 %feature("docstring")
71698 casadi::FunctionInternal::instruction_constant(casadi_int k) const  "
71699 
71700 [INTERNAL]  Get the floating point output argument of an atomic operation.
71701 
71702 ";
71703 
71704 %feature("docstring")  casadi::FunctionInternal::adjViaJac(casadi_int nadj)
71705 const  "
71706 
71707 [INTERNAL]  Calculate derivatives by multiplying the full Jacobian and
71708 multiplying.
71709 
71710 ";
71711 
71712 %feature("docstring")  casadi::FunctionInternal::getJacSparsity(casadi_int
71713 iind, casadi_int oind, bool symmetric) const  "
71714 
71715 [INTERNAL]  Generate the sparsity of a Jacobian block.
71716 
71717 ";
71718 
71719 %feature("docstring")  casadi::FunctionInternal::get_reltol() const  "
71720 
71721 [INTERNAL]  Get relative tolerance.
71722 
71723 ";
71724 
71725 %feature("docstring")  casadi::FunctionInternal::index_out(const std::string
71726 &name) const  "
71727 
71728 [INTERNAL]  Get output scheme index by name.
71729 
71730 ";
71731 
71732 %feature("docstring")  casadi::FunctionInternal::sz_iw() const  "
71733 
71734 [INTERNAL]  Get required length of iw field.
71735 
71736 ";
71737 
71738 %feature("docstring")  casadi::FunctionInternal::codegen_mem_type() const  "
71739 
71740 [INTERNAL]  Thread-local memory object type.
71741 
71742 ";
71743 
71744 %feature("docstring")  casadi::FunctionInternal::free_sx() const  "
71745 
71746 [INTERNAL]  Get free variables (SX)
71747 
71748 ";
71749 
71750 %feature("docstring")  casadi::ProtoFunction::serialize(SerializingStream
71751 &s) const  "
71752 
71753 [INTERNAL]  Serialize an object.
71754 
71755 ";
71756 
71757 %feature("docstring")  casadi::ProtoFunction::print_time(const std::map<
71758 std::string, FStats > &fstats) const  "
71759 
71760 [INTERNAL]  Print timing statistics.
71761 
71762 ";
71763 
71764 %feature("docstring")  casadi::Integrator::sp_jac_dae() "
71765 
71766 [INTERNAL]  Create sparsity pattern of the extended Jacobian (forward
71767 problem)
71768 
71769 ";
71770 
71771 %feature("docstring")  casadi::FunctionInternal::call_forward(const
71772 std::vector< MX > &arg, const std::vector< MX > &res, const std::vector<
71773 std::vector< MX > > &fseed, std::vector< std::vector< MX > > &fsens, bool
71774 always_inline, bool never_inline) const  "
71775 
71776 [INTERNAL]  Forward mode AD, virtual functions overloaded in derived
71777 classes.
71778 
71779 ";
71780 
71781 %feature("docstring")  casadi::FunctionInternal::call_forward(const
71782 std::vector< SX > &arg, const std::vector< SX > &res, const std::vector<
71783 std::vector< SX > > &fseed, std::vector< std::vector< SX > > &fsens, bool
71784 always_inline, bool never_inline) const  "
71785 
71786 [INTERNAL]  Forward mode AD, virtual functions overloaded in derived
71787 classes.
71788 
71789 ";
71790 
71791 %feature("docstring")  casadi::FunctionInternal::ad_weight() const  "
71792 
71793 [INTERNAL]  Weighting factor for chosing forward/reverse mode.
71794 
71795 ";
71796 
71797 %feature("docstring")
71798 casadi::FunctionInternal::getJacSparsityHierarchical(casadi_int iind,
71799 casadi_int oind) const  "
71800 
71801 [INTERNAL]  A flavor of getJacSparsity that does hierarchical block
71802 structure recognition.
71803 
71804 ";
71805 
71806 %feature("docstring")  casadi::FunctionInternal::set_work(void *mem, const
71807 double **&arg, double **&res, casadi_int *&iw, double *&w) const  "
71808 
71809 [INTERNAL]  Set the (persistent) work vectors.
71810 
71811 ";
71812 
71813 %feature("docstring")  casadi::OracleFunction::get_function() const  "
71814 
71815 [INTERNAL]  Get list of dependency functions -1 Indicates irregularity.
71816 
71817 ";
71818 
71819 %feature("docstring")  casadi::OracleFunction::get_function(const
71820 std::string &name) const  "
71821 
71822 [INTERNAL] ";
71823 
71824 %feature("docstring")  casadi::FunctionInternal::size2_out(casadi_int ind)
71825 const  "
71826 
71827 [INTERNAL]  Input/output dimensions.
71828 
71829 ";
71830 
71831 %feature("docstring")  casadi::Integrator::algebraic_state_output(const MX
71832 &Z) const  "
71833 
71834 [INTERNAL] ";
71835 
71836 %feature("docstring")  casadi::RungeKutta::setupFG()  "
71837 
71838 [INTERNAL]  Setup F and G.
71839 
71840 ";
71841 
71842 %feature("docstring")  casadi::FunctionInternal::forward(casadi_int nfwd)
71843 const  "
71844 
71845 [INTERNAL]  Return function that calculates forward derivatives
71846 forward(nfwd) returns a cached instance if available, and calls  Function
71847 get_forward(casadi_int nfwd) if no cached version is available.
71848 
71849 ";
71850 
71851 %feature("docstring")  casadi::FunctionInternal::free_mx() const  "
71852 
71853 [INTERNAL]  Get free variables ( MX)
71854 
71855 ";
71856 
71857 %feature("docstring")  casadi::FunctionInternal::eval_dm(const std::vector<
71858 DM > &arg) const  "
71859 
71860 [INTERNAL]  Evaluate with DM matrices.
71861 
71862 ";
71863 
71864 %feature("docstring")  casadi::FunctionInternal::setup(void *mem, const
71865 double **arg, double **res, casadi_int *iw, double *w) const  "
71866 
71867 [INTERNAL]  Set the (persistent and temporary) work vectors.
71868 
71869 ";
71870 
71871 %feature("docstring")  casadi::FunctionInternal::alloc_w(size_t sz_w, bool
71872 persistent=false) "
71873 
71874 [INTERNAL]  Ensure required length of w field.
71875 
71876 ";
71877 
71878 %feature("docstring")  casadi::FixedStepIntegrator::retreat(IntegratorMemory
71879 *mem, double t, double *rx, double *rz, double *rq) const  "
71880 
71881 [INTERNAL]  Retreat solution in time.
71882 
71883 ";
71884 
71885 %feature("docstring")
71886 casadi::FunctionInternal::codegen_decref(CodeGenerator &g) const  "
71887 
71888 [INTERNAL]  Codegen decref for dependencies.
71889 
71890 ";
71891 
71892 %feature("docstring")  casadi::FixedStepIntegrator::alloc_mem() const  "
71893 
71894 [INTERNAL]  Create memory block.
71895 
71896 ";
71897 
71898 %feature("docstring")  casadi::FunctionInternal::mx_in(casadi_int ind) const
71899 "
71900 
71901 [INTERNAL]  Get function input(s) and output(s)
71902 
71903 ";
71904 
71905 %feature("docstring")  casadi::FunctionInternal::mx_in() const  "
71906 
71907 [INTERNAL]  Get function input(s) and output(s)
71908 
71909 ";
71910 
71911 %feature("docstring")  casadi::FunctionInternal::wrap() const  "
71912 
71913 [INTERNAL]  Wrap in an Function instance consisting of only one MX call.
71914 
71915 ";
71916 
71917 %feature("docstring")  casadi::FunctionInternal::has_free() const  "
71918 
71919 [INTERNAL]  Does the function have free variables.
71920 
71921 ";
71922 
71923 %feature("docstring")  casadi::FunctionInternal::has_derivative() const  "
71924 
71925 [INTERNAL]  Can derivatives be calculated in any way?
71926 
71927 ";
71928 
71929 %feature("docstring")  casadi::FunctionInternal::codegen_meta(CodeGenerator
71930 &g) const  "
71931 
71932 [INTERNAL]  Generate meta-information allowing a user to evaluate a
71933 generated function.
71934 
71935 ";
71936 
71937 %feature("docstring")  casadi::FixedStepIntegrator::advance(IntegratorMemory
71938 *mem, double t, double *x, double *z, double *q) const  "
71939 
71940 [INTERNAL]  Advance solution in time.
71941 
71942 ";
71943 
71944 %feature("docstring")  casadi::ProtoFunction::clear_mem() "
71945 
71946 [INTERNAL]  Clear all memory (called from destructor)
71947 
71948 ";
71949 
71950 %feature("docstring")  casadi::ProtoFunction::release(int mem) const  "
71951 
71952 [INTERNAL]  Release a memory object.
71953 
71954 ";
71955 
71956 %feature("docstring")
71957 casadi::FunctionInternal::codegen_sparsities(CodeGenerator &g) const  "
71958 
71959 [INTERNAL]  Codegen sparsities.
71960 
71961 ";
71962 
71963 %feature("docstring")  casadi::FunctionInternal::n_nodes() const  "
71964 
71965 [INTERNAL]  Number of nodes in the algorithm.
71966 
71967 ";
71968 
71969 %feature("docstring")  casadi::FunctionInternal::sx_out(casadi_int ind)
71970 const  "
71971 
71972 [INTERNAL]  Get function input(s) and output(s)
71973 
71974 ";
71975 
71976 %feature("docstring")  casadi::FunctionInternal::sx_out() const  "
71977 
71978 [INTERNAL]  Get function input(s) and output(s)
71979 
71980 ";
71981 
71982 %feature("docstring")  casadi::FunctionInternal::which_depends(const
71983 std::string &s_in, const std::vector< std::string > &s_out, casadi_int
71984 order, bool tr=false) const  "
71985 
71986 [INTERNAL]  Which variables enter with some order.
71987 
71988 Parameters:
71989 -----------
71990 
71991 s_in:   Input name
71992 
71993 s_out:   Output name(s)
71994 
71995 order:  Only 1 (linear) and 2 (nonlinear) allowed
71996 
71997 tr:  Flip the relationship. Return which expressions contain the variables
71998 
71999 ";
72000 
72001 %feature("docstring")  casadi::FunctionInternal::sparsity_jac(casadi_int
72002 iind, casadi_int oind, bool compact, bool symmetric) const  "
72003 
72004 [INTERNAL]  Get, if necessary generate, the sparsity of a Jacobian block.
72005 
72006 ";
72007 
72008 %feature("docstring")  casadi::FunctionInternal::is_a(const std::string
72009 &type, bool recursive) const  "
72010 
72011 [INTERNAL]  Check if the function is of a particular type.
72012 
72013 ";
72014 
72015 %feature("docstring")  casadi::FunctionInternal::get_jacobian_sparsity()
72016 const  "
72017 
72018 [INTERNAL]  Get Jacobian sparsity.
72019 
72020 ";
72021 
72022 %feature("docstring")  casadi::ProtoFunction::checkout() const  "
72023 
72024 [INTERNAL]  Checkout a memory object.
72025 
72026 ";
72027 
72028 %feature("docstring") casadi::RungeKutta "
72029 
72030 [INTERNAL]  'rk' plugin for Integrator
72031 
72032 Fixed-step explicit Runge-Kutta integrator for ODEs Currently implements
72033 RK4.
72034 
72035 The method is still under development
72036 
72037 Joel Andersson
72038 
72039 C++ includes: runge_kutta.hpp ";
72040 
72041 %feature("docstring")  casadi::FunctionInternal::nz_in(const std::vector< DM
72042 > &arg) const  "
72043 
72044 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
72045 
72046 ";
72047 
72048 %feature("docstring")  casadi::FunctionInternal::nz_in(const std::vector<
72049 double > &arg) const  "
72050 
72051 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
72052 
72053 ";
72054 
72055 %feature("docstring")
72056 casadi::FunctionInternal::getJacSparsityGen(casadi_int iind, casadi_int
72057 oind, bool symmetric, casadi_int gr_i=1, casadi_int gr_o=1) const  "
72058 
72059 [INTERNAL]  Get the sparsity pattern, forward mode.
72060 
72061 ";
72062 
72063 %feature("docstring")  casadi::Integrator::get_sparsity_in(casadi_int i)  "
72064 
72065 [INTERNAL]  Sparsities of function inputs and outputs.
72066 
72067 ";
72068 
72069 %feature("docstring")  casadi::FunctionInternal::sx_in(casadi_int ind) const
72070 "
72071 
72072 [INTERNAL]  Get function input(s) and output(s)
72073 
72074 ";
72075 
72076 %feature("docstring")  casadi::FunctionInternal::sx_in() const  "
72077 
72078 [INTERNAL]  Get function input(s) and output(s)
72079 
72080 ";
72081 
72082 %feature("docstring")
72083 casadi::FunctionInternal::jacobian_sparsity_filter(const Sparsity &sp) const
72084 "
72085 
72086 [INTERNAL]  Filter out nonzeros in the full sparsity jacobian according to
72087 is_diff_in/out.
72088 
72089 ";
72090 
72091 %feature("docstring")  casadi::FunctionInternal::sp_weight() const  "
72092 
72093 [INTERNAL]  Weighting factor for chosing forward/reverse mode, sparsity
72094 propagation.
72095 
72096 ";
72097 
72098 %feature("docstring")  casadi::FunctionInternal::generate_options(bool
72099 is_temp=false) const  "
72100 
72101 [INTERNAL]  Reconstruct options dict.
72102 
72103 ";
72104 
72105 %feature("docstring")  casadi::Integrator::sp_reverse(bvec_t **arg, bvec_t
72106 **res, casadi_int *iw, bvec_t *w, void *mem) const  "
72107 
72108 [INTERNAL]  Propagate sparsity backwards.
72109 
72110 ";
72111 
72112 %feature("docstring")  casadi::FunctionInternal::print_options(std::ostream
72113 &stream) const  "
72114 
72115 [INTERNAL]  Print list of options.
72116 
72117 ";
72118 
72119 %feature("docstring")  casadi::FunctionInternal::jacobian() const  "
72120 
72121 [INTERNAL]  Return Jacobian of all input elements with respect to all output
72122 elements.
72123 
72124 ";
72125 
72126 %feature("docstring")  casadi::FunctionInternal::numel_out(casadi_int ind)
72127 const  "
72128 
72129 [INTERNAL]  Number of input/output elements.
72130 
72131 ";
72132 
72133 %feature("docstring")  casadi::FunctionInternal::numel_out() const  "
72134 
72135 [INTERNAL]  Number of input/output elements.
72136 
72137 ";
72138 
72139 %feature("docstring")  casadi::FunctionInternal::nnz_out() const  "
72140 
72141 [INTERNAL]  Number of input/output nonzeros.
72142 
72143 ";
72144 
72145 %feature("docstring")  casadi::FunctionInternal::nnz_out(casadi_int ind)
72146 const  "
72147 
72148 [INTERNAL]  Number of input/output nonzeros.
72149 
72150 ";
72151 
72152 %feature("docstring")  casadi::FunctionInternal::sz_res() const  "
72153 
72154 [INTERNAL]  Get required length of res field.
72155 
72156 ";
72157 
72158 %feature("docstring")  casadi::OracleFunction::oracle() const  "
72159 
72160 [INTERNAL]  Get oracle.
72161 
72162 ";
72163 
72164 %feature("docstring")  casadi::Integrator::get_sparsity_out(casadi_int i)  "
72165 
72166 [INTERNAL]  Sparsities of function inputs and outputs.
72167 
72168 ";
72169 
72170 %feature("docstring")  casadi::Integrator::has_reverse(casadi_int nadj)
72171 const  "
72172 
72173 [INTERNAL]  Generate a function that calculates nadj adjoint derivatives.
72174 
72175 ";
72176 
72177 %feature("docstring")  casadi::FunctionInternal::instruction_id(casadi_int
72178 k) const  "
72179 
72180 [INTERNAL]  Get an atomic operation operator index.
72181 
72182 ";
72183 
72184 %feature("docstring")
72185 casadi::FunctionInternal::codegen_incref(CodeGenerator &g) const  "
72186 
72187 [INTERNAL]  Codegen incref for dependencies.
72188 
72189 ";
72190 
72191 %feature("docstring")  casadi::FunctionInternal::get_partition(casadi_int
72192 iind, casadi_int oind, Sparsity &D1, Sparsity &D2, bool compact, bool
72193 symmetric, bool allow_forward, bool allow_reverse) const  "
72194 
72195 [INTERNAL]  Get the unidirectional or bidirectional partition.
72196 
72197 ";
72198 
72199 %feature("docstring")  casadi::FunctionInternal::fwd_seed(casadi_int nfwd)
72200 const  "
72201 
72202 [INTERNAL]  Symbolic expressions for the forward seeds.
72203 
72204 ";
72205 
72206 %feature("docstring")  casadi::FunctionInternal::alloc_iw(size_t sz_iw, bool
72207 persistent=false) "
72208 
72209 [INTERNAL]  Ensure required length of iw field.
72210 
72211 ";
72212 
72213 %feature("docstring")  casadi::OracleFunction::set_function(const Function
72214 &fcn, const std::string &fname, bool jit=false) "
72215 
72216 [INTERNAL]  Register the function for evaluation and statistics gathering
72217 
72218 ";
72219 
72220 %feature("docstring")  casadi::OracleFunction::set_function(const Function
72221 &fcn) "
72222 
72223 [INTERNAL]  Register the function for evaluation and statistics gathering
72224 
72225 ";
72226 
72227 %feature("docstring")  casadi::FixedStepIntegrator::getExplicitB() const  "
72228 
72229 [INTERNAL]  Get explicit dynamics (backward problem)
72230 
72231 ";
72232 
72233 %feature("docstring")  casadi::OracleFunction::set_temp(void *mem, const
72234 double **arg, double **res, casadi_int *iw, double *w) const  "
72235 
72236 [INTERNAL]  Set the work vectors.
72237 
72238 ";
72239 
72240 %feature("docstring")  casadi::FunctionInternal::replace_aseed(const
72241 std::vector< std::vector< M >> &aseed, casadi_int npar) const  "
72242 
72243 [INTERNAL]  Replace 0-by-0 reverse seeds.
72244 
72245 ";
72246 
72247 %feature("docstring")  casadi::FunctionInternal::replace_aseed(const
72248 std::vector< std::vector< M > > &aseed, casadi_int npar) const  "
72249 
72250 [INTERNAL] ";
72251 
72252 %feature("docstring")
72253 casadi::FunctionInternal::instruction_output(casadi_int k) const  "
72254 
72255 [INTERNAL]  Get the (integer) output argument of an atomic operation.
72256 
72257 ";
72258 
72259 %feature("docstring")  casadi::Integrator::get_name_out(casadi_int i)  "
72260 
72261 [INTERNAL]  Names of function input and outputs.
72262 
72263 ";
72264 
72265 %feature("docstring")  casadi::FunctionInternal::size_out(casadi_int ind)
72266 const  "
72267 
72268 [INTERNAL]  Input/output dimensions.
72269 
72270 ";
72271 
72272 %feature("docstring")  casadi::FunctionInternal::sz_work(size_t &sz_arg,
72273 size_t &sz_res, size_t &sz_iw, size_t &sz_w) const  "
72274 
72275 [INTERNAL]  Get number of temporary variables needed.
72276 
72277 ";
72278 
72279 %feature("docstring")  casadi::FunctionInternal::nz_out(const std::vector<
72280 DM > &res) const  "
72281 
72282 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
72283 
72284 ";
72285 
72286 %feature("docstring")  casadi::FunctionInternal::nz_out(const std::vector<
72287 double > &res) const  "
72288 
72289 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
72290 
72291 ";
72292 
72293 %feature("docstring")  casadi::FunctionInternal::slice(const std::string
72294 &name, const std::vector< casadi_int > &order_in, const std::vector<
72295 casadi_int > &order_out, const Dict &opts) const  "
72296 
72297 [INTERNAL]  returns a new function with a selection of inputs/outputs of the
72298 original
72299 
72300 ";
72301 
72302 %feature("docstring")  casadi::FunctionInternal::info() const  "
72303 
72304 [INTERNAL]  Obtain information about function
72305 
72306 ";
72307 
72308 %feature("docstring")  casadi::FunctionInternal::check_arg(const
72309 std::vector< M > &arg, casadi_int &npar) const  "
72310 
72311 [INTERNAL]  Check if input arguments have correct length and dimensions.
72312 
72313 Raises errors.
72314 
72315 Parameters:
72316 -----------
72317 
72318 npar[in]:  normal usage: 1, disallow pararallel calls: -1
72319 
72320 npar:  max number of horizontal repetitions across all arguments (or -1)
72321 
72322 ";
72323 
72324 %feature("docstring")  casadi::Integrator::get_n_out()  "
72325 
72326 [INTERNAL]  Number of function inputs and outputs.
72327 
72328 ";
72329 
72330 %feature("docstring")  casadi::OracleFunction::monitored(const std::string
72331 &name) const  "
72332 
72333 [INTERNAL] ";
72334 
72335 %feature("docstring")  casadi::FunctionInternal::symbolic_output(const
72336 std::vector< MX > &arg) const  "
72337 
72338 [INTERNAL]  Get a vector of symbolic variables corresponding to the outputs.
72339 
72340 ";
72341 
72342 %feature("docstring")  casadi::FunctionInternal::signature(const std::string
72343 &fname) const  "
72344 
72345 [INTERNAL]  Code generate the function.
72346 
72347 ";
72348 
72349 %feature("docstring")  casadi::FunctionInternal::uses_output() const  "
72350 
72351 [INTERNAL]  Do the derivative functions need nondifferentiated outputs?
72352 
72353 ";
72354 
72355 %feature("docstring")  casadi::FunctionInternal::print_option(const
72356 std::string &name, std::ostream &stream) const  "
72357 
72358 [INTERNAL]  Print all information there is to know about a certain option.
72359 
72360 ";
72361 
72362 %feature("docstring")
72363 casadi::FunctionInternal::print_dimensions(std::ostream &stream) const  "
72364 
72365 [INTERNAL]  Print dimensions of inputs and outputs.
72366 
72367 ";
72368 
72369 %feature("docstring")  casadi::FunctionInternal::get_min_in(casadi_int ind)
72370 const  "
72371 
72372 [INTERNAL]  Get smallest input value.
72373 
72374 ";
72375 
72376 %feature("docstring")  casadi::FunctionInternal::get_max_in(casadi_int ind)
72377 const  "
72378 
72379 [INTERNAL]  Get largest input value.
72380 
72381 ";
72382 
72383 %feature("docstring")  casadi::FixedStepIntegrator::get_options() const  "
72384 
72385 [INTERNAL]  Options.
72386 
72387 ";
72388 
72389 %feature("docstring")  casadi::FunctionInternal::sparsity_in(casadi_int ind)
72390 const  "
72391 
72392 [INTERNAL]  Input/output sparsity.
72393 
72394 ";
72395 
72396 %feature("docstring")  casadi::FunctionInternal::dm_in(casadi_int ind) const
72397 "
72398 
72399 [INTERNAL]  Get function input(s) and output(s)
72400 
72401 ";
72402 
72403 %feature("docstring")  casadi::FunctionInternal::dm_in() const  "
72404 
72405 [INTERNAL]  Get function input(s) and output(s)
72406 
72407 ";
72408 
72409 %feature("docstring")  casadi::ProtoFunction::sprint(char *buf, size_t
72410 buf_sz, const char *fmt,...) const  "
72411 
72412 [INTERNAL]  C-style formatted printing to string.
72413 
72414 ";
72415 
72416 %feature("docstring")  casadi::FunctionInternal::replace_fseed(const
72417 std::vector< std::vector< M >> &fseed, casadi_int npar) const  "
72418 
72419 [INTERNAL]  Replace 0-by-0 forward seeds.
72420 
72421 ";
72422 
72423 %feature("docstring")  casadi::FunctionInternal::replace_fseed(const
72424 std::vector< std::vector< M > > &fseed, casadi_int npar) const  "
72425 
72426 [INTERNAL] ";
72427 
72428 %feature("docstring")  casadi::FunctionInternal::fwdViaJac(casadi_int nfwd)
72429 const  "
72430 
72431 [INTERNAL]  Calculate derivatives by multiplying the full Jacobian and
72432 multiplying.
72433 
72434 ";
72435 
72436 %feature("docstring")  casadi::FunctionInternal::instructions_sx() const  "
72437 
72438 [INTERNAL]  get SX expression associated with instructions
72439 
72440 ";
72441 
72442 %feature("docstring")  casadi::FunctionInternal::getAdaptorSolverName()
72443 const  "
72444 
72445 [INTERNAL]  Obtain solver name from Adaptor.
72446 
72447 ";
72448 
72449 %feature("docstring")
72450 casadi::FunctionInternal::codegen_alloc_mem(CodeGenerator &g) const  "
72451 
72452 [INTERNAL]  Codegen decref for alloc_mem.
72453 
72454 ";
72455 
72456 %feature("docstring")  casadi::Integrator::has_sprev() const  "
72457 
72458 [INTERNAL]  Is the class able to propagate seeds through the algorithm?
72459 
72460 ";
72461 
72462 %feature("docstring")  casadi::FixedStepIntegrator::resetB(IntegratorMemory
72463 *mem, double t, const double *rx, const double *rz, const double *rp) const
72464 "
72465 
72466 [INTERNAL]  Reset the backward problem and take time to tf.
72467 
72468 ";
72469 
72470 %feature("docstring")  casadi::FunctionInternal::replace_arg(const
72471 std::vector< M > &arg, casadi_int npar) const  "
72472 
72473 [INTERNAL]  Replace 0-by-0 inputs.
72474 
72475 ";
72476 
72477 %feature("docstring")  casadi::FunctionInternal::eval_mx(const MXVector
72478 &arg, MXVector &res, bool always_inline, bool never_inline) const  "
72479 
72480 [INTERNAL]  Evaluate with symbolic matrices.
72481 
72482 ";
72483 
72484 %feature("docstring")  casadi::FunctionInternal::get_default_in(casadi_int
72485 ind) const  "
72486 
72487 [INTERNAL]  Get default input value.
72488 
72489 ";
72490 
72491 %feature("docstring")  casadi::FunctionInternal::has_jacobian() const  "
72492 
72493 [INTERNAL]  Return Jacobian of all input elements with respect to all output
72494 elements.
72495 
72496 ";
72497 
72498 %feature("docstring")  casadi::Integrator::serialize_type(SerializingStream
72499 &s) const  "
72500 
72501 [INTERNAL]  Serialize type information.
72502 
72503 ";
72504 
72505 %feature("docstring")  casadi::Integrator::eval(const double **arg, double
72506 **res, casadi_int *iw, double *w, void *mem) const  "
72507 
72508 [INTERNAL]  evaluate
72509 
72510 ";
72511 
72512 %feature("docstring")  casadi::OracleFunction::calc_function(OracleMemory
72513 *m, const std::string &fcn, const double *const *arg=nullptr) const  "
72514 
72515 [INTERNAL] ";
72516 
72517 %feature("docstring")  casadi::SharedObjectInternal::weak() "
72518 
72519 [INTERNAL]  Get a weak reference to the object.
72520 
72521 ";
72522 
72523 %feature("docstring")
72524 casadi::FunctionInternal::codegen_init_mem(CodeGenerator &g) const  "
72525 
72526 [INTERNAL]  Codegen decref for init_mem.
72527 
72528 ";
72529 
72530 %feature("docstring")  casadi::FunctionInternal::generate_in(const
72531 std::string &fname, const double **arg) const  "
72532 
72533 [INTERNAL]  Export an input file that can be passed to generate C code with
72534 a main.
72535 
72536 ";
72537 
72538 %feature("docstring")  casadi::Integrator::algebraic_state_init(const MX
72539 &x0, const MX &z0) const  "
72540 
72541 [INTERNAL] ";
72542 
72543 %feature("docstring")
72544 casadi::FunctionInternal::getJacSparsityHierarchicalSymm(casadi_int iind,
72545 casadi_int oind) const  "
72546 
72547 [INTERNAL]  A flavor of getJacSparsity that does hierarchical block
72548 structure recognition for symmetric Jacobians
72549 
72550 ";
72551 
72552 %feature("docstring")  casadi::FunctionInternal::get_abstol() const  "
72553 
72554 [INTERNAL]  Get absolute tolerance.
72555 
72556 ";
72557 
72558 %feature("docstring")  casadi::Integrator::get_reverse(casadi_int nadj,
72559 const std::string &name, const std::vector< std::string > &inames, const
72560 std::vector< std::string > &onames, const Dict &opts) const  "
72561 
72562 [INTERNAL]  Generate a function that calculates nadj adjoint derivatives.
72563 
72564 ";
72565 
72566 %feature("docstring")  casadi::FunctionInternal::n_instructions() const  "
72567 
72568 [INTERNAL]  Get the number of atomic operations.
72569 
72570 ";
72571 
72572 %feature("docstring")  casadi::FunctionInternal::disp_more(std::ostream
72573 &stream) const  "
72574 
72575 [INTERNAL]  Print more.
72576 
72577 ";
72578 
72579 %feature("docstring")  casadi::FixedStepIntegrator::reset(IntegratorMemory
72580 *mem, double t, const double *x, const double *z, const double *p) const  "
72581 
72582 [INTERNAL]  Reset the forward problem.
72583 
72584 ";
72585 
72586 %feature("docstring")  casadi::FunctionInternal::project_arg(const
72587 std::vector< M > &arg, casadi_int npar) const  "
72588 
72589 [INTERNAL]   Project sparsities.
72590 
72591 ";
72592 
72593 %feature("docstring")  casadi::FunctionInternal::is_diff_in(casadi_int i) "
72594 
72595 [INTERNAL] ";
72596 
72597 %feature("docstring")  casadi::FunctionInternal::definition() const  "
72598 
72599 [INTERNAL]  Get function signature: name:(inputs)->(outputs)
72600 
72601 ";
72602 
72603 %feature("docstring")  casadi::FixedStepIntegrator::init_mem(void *mem)
72604 const  "
72605 
72606 [INTERNAL]  Initalize memory block.
72607 
72608 ";
72609 
72610 %feature("docstring")  casadi::RungeKutta::init(const Dict &opts)  "
72611 
72612 [INTERNAL]  Initialize stage.
72613 
72614 ";
72615 
72616 %feature("docstring")  casadi::OracleFunction::generate_dependencies(const
72617 std::string &fname, const Dict &opts) const  "
72618 
72619 [INTERNAL]  Export / Generate C code for the generated functions.
72620 
72621 ";
72622 
72623 %feature("docstring")  casadi::Integrator::getDerivativeOptions(bool fwd)
72624 const  "
72625 
72626 [INTERNAL]  Set solver specific options to generated augmented integrators.
72627 
72628 ";
72629 
72630 %feature("docstring")  casadi::OracleFunction::has_function(const
72631 std::string &fname) const  "
72632 
72633 [INTERNAL] ";
72634 
72635 %feature("docstring")  casadi::FunctionInternal::project_res(const
72636 std::vector< M > &arg, casadi_int npar) const  "
72637 
72638 [INTERNAL]   Project sparsities.
72639 
72640 ";
72641 
72642 %feature("docstring")  casadi::FunctionInternal::size_in(casadi_int ind)
72643 const  "
72644 
72645 [INTERNAL]  Input/output dimensions.
72646 
72647 ";
72648 
72649 %feature("docstring")  casadi::OracleFunction::get_stats(void *mem) const  "
72650 
72651 [INTERNAL]  Get all statistics.
72652 
72653 ";
72654 
72655 %feature("docstring")  casadi::Integrator::aug_adj(casadi_int nadj) const  "
72656 
72657 [INTERNAL]  Generate a augmented DAE system with nadj adjoint sensitivities.
72658 
72659 ";
72660 
72661 %feature("docstring")  casadi::FunctionInternal::matching_res(const
72662 std::vector< M > &arg, casadi_int &npar) const  "
72663 
72664 [INTERNAL]  Check if output arguments that needs to be replaced.
72665 
72666 Raises errors
72667 
72668 Parameters:
72669 -----------
72670 
72671 npar[in]:  normal usage: 1, disallow pararallel calls: -1
72672 
72673 npar:  max number of horizontal repetitions across all arguments (or -1)
72674 
72675 ";
72676 
72677 %feature("docstring")  casadi::FunctionInternal::call(const std::vector< M >
72678 &arg, std::vector< M > &res, bool always_inline, bool never_inline) const  "
72679 
72680 [INTERNAL]   Call a function, templated.
72681 
72682 ";
72683 
72684 %feature("docstring")  casadi::RungeKutta::plugin_name() const  "
72685 
72686 [INTERNAL] ";
72687 
72688 %feature("docstring")  casadi::FunctionInternal::has_codegen() const  "
72689 
72690 [INTERNAL]  Is codegen supported?
72691 
72692 ";
72693 
72694 %feature("docstring")  casadi::ProtoFunction::construct(const Dict &opts) "
72695 
72696 [INTERNAL]  Construct Prepares the function for evaluation.
72697 
72698 ";
72699 
72700 %feature("docstring")  casadi::FunctionInternal::eval_gen(const double
72701 **arg, double **res, casadi_int *iw, double *w, void *mem) const  "
72702 
72703 [INTERNAL]  Evaluate numerically.
72704 
72705 ";
72706 
72707 %feature("docstring")  casadi::FunctionInternal::eval_gen(const SXElem
72708 **arg, SXElem **res, casadi_int *iw, SXElem *w, void *mem) const  "
72709 
72710 [INTERNAL]  Evaluate a function, overloaded.
72711 
72712 ";
72713 
72714 %feature("docstring")  casadi::FunctionInternal::eval_gen(const bvec_t
72715 **arg, bvec_t **res, casadi_int *iw, bvec_t *w, void *mem) const  "
72716 
72717 [INTERNAL]  Evaluate a function, overloaded.
72718 
72719 ";
72720 
72721 %feature("docstring")  casadi::FixedStepIntegrator::free_mem(void *mem)
72722 const  "
72723 
72724 [INTERNAL]  Free memory block.
72725 
72726 ";
72727 
72728 %feature("docstring")  casadi::FunctionInternal::codegen(CodeGenerator &g,
72729 const std::string &fname) const  "
72730 
72731 [INTERNAL]  Generate code the function.
72732 
72733 ";
72734 
72735 %feature("docstring")  casadi::FunctionInternal::call_reverse(const
72736 std::vector< MX > &arg, const std::vector< MX > &res, const std::vector<
72737 std::vector< MX > > &aseed, std::vector< std::vector< MX > > &asens, bool
72738 always_inline, bool never_inline) const  "
72739 
72740 [INTERNAL]  Reverse mode, virtual functions overloaded in derived classes.
72741 
72742 ";
72743 
72744 %feature("docstring")  casadi::FunctionInternal::call_reverse(const
72745 std::vector< SX > &arg, const std::vector< SX > &res, const std::vector<
72746 std::vector< SX > > &aseed, std::vector< std::vector< SX > > &asens, bool
72747 always_inline, bool never_inline) const  "
72748 
72749 [INTERNAL]  Reverse mode, virtual functions overloaded in derived classes.
72750 
72751 ";
72752 
72753 %feature("docstring")  casadi::FunctionInternal::replace_res(const
72754 std::vector< M > &res, casadi_int npar) const  "
72755 
72756 [INTERNAL]  Replace 0-by-0 outputs.
72757 
72758 ";
72759 
72760 %feature("docstring")
72761 casadi::FunctionInternal::codegen_declarations(CodeGenerator &g) const  "
72762 
72763 [INTERNAL]  Generate code for the declarations of the C function.
72764 
72765 ";
72766 
72767 
72768 // File: classcasadi_1_1ScopedTiming.xml
72769 %feature("docstring") casadi::ScopedTiming::~ScopedTiming "
72770 
72771 [INTERNAL] ";
72772 
72773 %feature("docstring") casadi::ScopedTiming "
72774 
72775 [INTERNAL] C++ includes: timing.hpp ";
72776 
72777 %feature("docstring") casadi::ScopedTiming::ScopedTiming(FStats &f) "
72778 
72779 [INTERNAL] ";
72780 
72781 
72782 // File: classcasadi_1_1Scpgen.xml
72783 %feature("docstring")  casadi::FunctionInternal::replace_aseed(const
72784 std::vector< std::vector< M >> &aseed, casadi_int npar) const  "
72785 
72786 [INTERNAL]  Replace 0-by-0 reverse seeds.
72787 
72788 ";
72789 
72790 %feature("docstring")  casadi::FunctionInternal::replace_aseed(const
72791 std::vector< std::vector< M > > &aseed, casadi_int npar) const  "
72792 
72793 [INTERNAL] ";
72794 
72795 %feature("docstring")  casadi::FunctionInternal::instruction_id(casadi_int
72796 k) const  "
72797 
72798 [INTERNAL]  Get an atomic operation operator index.
72799 
72800 ";
72801 
72802 %feature("docstring")  casadi::ProtoFunction::clear_mem() "
72803 
72804 [INTERNAL]  Clear all memory (called from destructor)
72805 
72806 ";
72807 
72808 %feature("docstring")  casadi::Nlpsol::get_name_in(casadi_int i)  "
72809 
72810 [INTERNAL]  Names of function input and outputs.
72811 
72812 ";
72813 
72814 %feature("docstring")  casadi::FunctionInternal::free_mx() const  "
72815 
72816 [INTERNAL]  Get free variables ( MX)
72817 
72818 ";
72819 
72820 %feature("docstring")  casadi::OracleFunction::create_function(const
72821 std::string &fname, const std::vector< std::string > &s_in, const
72822 std::vector< std::string > &s_out, const Function::AuxOut
72823 &aux=Function::AuxOut()) "
72824 
72825 [INTERNAL]  Create an oracle function
72826 
72827 ";
72828 
72829 %feature("docstring")
72830 casadi::FunctionInternal::codegen_alloc_mem(CodeGenerator &g) const  "
72831 
72832 [INTERNAL]  Codegen decref for alloc_mem.
72833 
72834 ";
72835 
72836 %feature("docstring")  casadi::FunctionInternal::get_abstol() const  "
72837 
72838 [INTERNAL]  Get absolute tolerance.
72839 
72840 ";
72841 
72842 %feature("docstring")  casadi::FunctionInternal::has_free() const  "
72843 
72844 [INTERNAL]  Does the function have free variables.
72845 
72846 ";
72847 
72848 %feature("docstring")  casadi::FunctionInternal::size1_in(casadi_int ind)
72849 const  "
72850 
72851 [INTERNAL]  Input/output dimensions.
72852 
72853 ";
72854 
72855 %feature("docstring")  casadi::Scpgen::eval_vec(ScpgenMemory *m) const  "
72856 
72857 [INTERNAL] ";
72858 
72859 %feature("docstring")  casadi::FunctionInternal::codegen_mem_type() const  "
72860 
72861 [INTERNAL]  Thread-local memory object type.
72862 
72863 ";
72864 
72865 %feature("docstring")  casadi::FunctionInternal::size1_out(casadi_int ind)
72866 const  "
72867 
72868 [INTERNAL]  Input/output dimensions.
72869 
72870 ";
72871 
72872 %feature("docstring")  casadi::Scpgen::eval_res(ScpgenMemory *m) const  "
72873 
72874 [INTERNAL] ";
72875 
72876 %feature("docstring")  casadi::FunctionInternal::symbolicAdjSeed(casadi_int
72877 nadj, const std::vector< MatType > &v) const  "
72878 
72879 [INTERNAL]  Symbolic expressions for the adjoint seeds.
72880 
72881 ";
72882 
72883 %feature("docstring")  casadi::FunctionInternal::ad_weight() const  "
72884 
72885 [INTERNAL]  Weighting factor for chosing forward/reverse mode.
72886 
72887 ";
72888 
72889 %feature("docstring")  casadi::FunctionInternal::sp_weight() const  "
72890 
72891 [INTERNAL]  Weighting factor for chosing forward/reverse mode, sparsity
72892 propagation.
72893 
72894 ";
72895 
72896 %feature("docstring")  casadi::ProtoFunction::print(const char *fmt,...)
72897 const  "
72898 
72899 [INTERNAL]  C-style formatted printing during evaluation.
72900 
72901 ";
72902 
72903 %feature("docstring")  casadi::FunctionInternal::signature(const std::string
72904 &fname) const  "
72905 
72906 [INTERNAL]  Code generate the function.
72907 
72908 ";
72909 
72910 %feature("docstring")  casadi::FunctionInternal::replace_fseed(const
72911 std::vector< std::vector< M >> &fseed, casadi_int npar) const  "
72912 
72913 [INTERNAL]  Replace 0-by-0 forward seeds.
72914 
72915 ";
72916 
72917 %feature("docstring")  casadi::FunctionInternal::replace_fseed(const
72918 std::vector< std::vector< M > > &fseed, casadi_int npar) const  "
72919 
72920 [INTERNAL] ";
72921 
72922 %feature("docstring")  casadi::FunctionInternal::alloc_w(size_t sz_w, bool
72923 persistent=false) "
72924 
72925 [INTERNAL]  Ensure required length of w field.
72926 
72927 ";
72928 
72929 %feature("docstring")  casadi::Nlpsol::nlpsol_codegen_body(CodeGenerator &g)
72930 const  "
72931 
72932 [INTERNAL]  Generate code for the function body.
72933 
72934 ";
72935 
72936 %feature("docstring")  casadi::FunctionInternal::alloc_res(size_t sz_res,
72937 bool persistent=false) "
72938 
72939 [INTERNAL]  Ensure required length of res field.
72940 
72941 ";
72942 
72943 %feature("docstring")  casadi::FunctionInternal::codegen_body(CodeGenerator
72944 &g) const  "
72945 
72946 [INTERNAL]  Generate code for the function body.
72947 
72948 ";
72949 
72950 %feature("docstring")  casadi::FunctionInternal::export_code(const
72951 std::string &lang, std::ostream &stream, const Dict &options) const  "
72952 
72953 [INTERNAL]  Export function in a specific language.
72954 
72955 ";
72956 
72957 %feature("docstring")  casadi::Scpgen::eval_mat(ScpgenMemory *m) const  "
72958 
72959 [INTERNAL] ";
72960 
72961 %feature("docstring")  casadi::FunctionInternal::getAdaptorSolverName()
72962 const  "
72963 
72964 [INTERNAL]  Obtain solver name from Adaptor.
72965 
72966 ";
72967 
72968 %feature("docstring")  casadi::FunctionInternal::matching_arg(const
72969 std::vector< M > &arg, casadi_int &npar) const  "
72970 
72971 [INTERNAL]  Check if input arguments that needs to be replaced.
72972 
72973 Raises errors
72974 
72975 Parameters:
72976 -----------
72977 
72978 npar[in]:  normal usage: 1, disallow pararallel calls: -1
72979 
72980 npar:  max number of horizontal repetitions across all arguments (or -1)
72981 
72982 ";
72983 
72984 %feature("docstring")  casadi::FunctionInternal::has_jacobian_sparsity()
72985 const  "
72986 
72987 [INTERNAL]  Get Jacobian sparsity.
72988 
72989 ";
72990 
72991 %feature("docstring")  casadi::FunctionInternal::fwdViaJac(casadi_int nfwd)
72992 const  "
72993 
72994 [INTERNAL]  Calculate derivatives by multiplying the full Jacobian and
72995 multiplying.
72996 
72997 ";
72998 
72999 %feature("docstring")  casadi::FunctionInternal::setup(void *mem, const
73000 double **arg, double **res, casadi_int *iw, double *w) const  "
73001 
73002 [INTERNAL]  Set the (persistent and temporary) work vectors.
73003 
73004 ";
73005 
73006 %feature("docstring")  casadi::Nlpsol::disp_more(std::ostream &stream) const
73007 "
73008 
73009 [INTERNAL]  Print description.
73010 
73011 ";
73012 
73013 %feature("docstring")  casadi::FunctionInternal::mapsum_mx(const
73014 std::vector< MX > &arg, const std::string &parallelization) "
73015 
73016 [INTERNAL]  Parallel evaluation.
73017 
73018 ";
73019 
73020 %feature("docstring")  casadi::FunctionInternal::index_in(const std::string
73021 &name) const  "
73022 
73023 [INTERNAL]  Get input scheme index by name.
73024 
73025 ";
73026 
73027 %feature("docstring")  casadi::FunctionInternal::fwd_seed(casadi_int nfwd)
73028 const  "
73029 
73030 [INTERNAL]  Symbolic expressions for the forward seeds.
73031 
73032 ";
73033 
73034 %feature("docstring")  casadi::FunctionInternal::mx_out(casadi_int ind)
73035 const  "
73036 
73037 [INTERNAL]  Get function input(s) and output(s)
73038 
73039 ";
73040 
73041 %feature("docstring")  casadi::FunctionInternal::mx_out() const  "
73042 
73043 [INTERNAL]  Get function input(s) and output(s)
73044 
73045 ";
73046 
73047 %feature("docstring")  casadi::ProtoFunction::format_time(char *buffer,
73048 double time) const  "
73049 
73050 [INTERNAL]  Format time in a fixed width 8 format.
73051 
73052 ";
73053 
73054 %feature("docstring")  casadi::OracleFunction::expand() "
73055 
73056 [INTERNAL] ";
73057 
73058 %feature("docstring")  casadi::Nlpsol::get_reverse(casadi_int nadj, const
73059 std::string &name, const std::vector< std::string > &inames, const
73060 std::vector< std::string > &onames, const Dict &opts) const  "
73061 
73062 [INTERNAL]  Generate a function that calculates reverse mode derivatives.
73063 
73064 ";
73065 
73066 %feature("docstring")  casadi::FunctionInternal::numel_out(casadi_int ind)
73067 const  "
73068 
73069 [INTERNAL]  Number of input/output elements.
73070 
73071 ";
73072 
73073 %feature("docstring")  casadi::FunctionInternal::numel_out() const  "
73074 
73075 [INTERNAL]  Number of input/output elements.
73076 
73077 ";
73078 
73079 %feature("docstring")  casadi::OracleFunction::oracle() const  "
73080 
73081 [INTERNAL]  Get oracle.
73082 
73083 ";
73084 
73085 %feature("docstring")  casadi::FunctionInternal::generate_out(const
73086 std::string &fname, double **res) const  "
73087 
73088 [INTERNAL] ";
73089 
73090 %feature("docstring")  casadi::FunctionInternal::incache(const std::string
73091 &fname, Function &f, const std::string &suffix="") const  "
73092 
73093 [INTERNAL]  Get function in cache.
73094 
73095 ";
73096 
73097 %feature("docstring")  casadi::FunctionInternal::get_max_in(casadi_int ind)
73098 const  "
73099 
73100 [INTERNAL]  Get largest input value.
73101 
73102 ";
73103 
73104 %feature("docstring")  casadi::ProtoFunction::memory(int ind) const  "
73105 
73106 [INTERNAL]  Memory objects.
73107 
73108 ";
73109 
73110 %feature("docstring")
73111 casadi::FunctionInternal::codegen_free_mem(CodeGenerator &g) const  "
73112 
73113 [INTERNAL]  Codegen for free_mem.
73114 
73115 ";
73116 
73117 %feature("docstring")  casadi::FunctionInternal::call(const std::vector< M >
73118 &arg, std::vector< M > &res, bool always_inline, bool never_inline) const  "
73119 
73120 [INTERNAL]   Call a function, templated.
73121 
73122 ";
73123 
73124 %feature("docstring") casadi::Scpgen::Scpgen(const std::string &name, const
73125 Function &nlp) "
73126 
73127 [INTERNAL] ";
73128 
73129 %feature("docstring")  casadi::Scpgen::free_mem(void *mem) const  "
73130 
73131 [INTERNAL]  Free memory block.
73132 
73133 ";
73134 
73135 %feature("docstring")  casadi::Nlpsol::setOptionsFromFile(const std::string
73136 &file) "
73137 
73138 [INTERNAL]  Read options from parameter xml.
73139 
73140 ";
73141 
73142 %feature("docstring")
73143 casadi::FunctionInternal::instruction_constant(casadi_int k) const  "
73144 
73145 [INTERNAL]  Get the floating point output argument of an atomic operation.
73146 
73147 ";
73148 
73149 %feature("docstring")  casadi::OracleFunction::finalize()  "
73150 
73151 [INTERNAL]  Finalize initialization.
73152 
73153 ";
73154 
73155 %feature("docstring")  casadi::FunctionInternal::all_scalar() const  "
73156 
73157 [INTERNAL]  Are all inputs and outputs scalar.
73158 
73159 ";
73160 
73161 %feature("docstring")  casadi::FunctionInternal::nz_in(const std::vector< DM
73162 > &arg) const  "
73163 
73164 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
73165 
73166 ";
73167 
73168 %feature("docstring")  casadi::FunctionInternal::nz_in(const std::vector<
73169 double > &arg) const  "
73170 
73171 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
73172 
73173 ";
73174 
73175 %feature("docstring")  casadi::FunctionInternal::check_res(const
73176 std::vector< M > &res, casadi_int &npar) const  "
73177 
73178 [INTERNAL]  Check if output arguments have correct length and dimensions.
73179 
73180 Raises errors.
73181 
73182 Parameters:
73183 -----------
73184 
73185 npar[in]:  normal usage: 1, disallow pararallel calls: -1
73186 
73187 npar:  max number of horizontal repetitions across all arguments (or -1)
73188 
73189 ";
73190 
73191 %feature("docstring")
73192 casadi::FunctionInternal::instruction_input(casadi_int k) const  "
73193 
73194 [INTERNAL]  Get the (integer) input arguments of an atomic operation.
73195 
73196 ";
73197 
73198 %feature("docstring")  casadi::Nlpsol::get_n_out()  "
73199 
73200 [INTERNAL]  Number of function inputs and outputs.
73201 
73202 ";
73203 
73204 %feature("docstring")  casadi::FunctionInternal::codegen_name(const
73205 CodeGenerator &g, bool ns=true) const  "
73206 
73207 [INTERNAL]  Get name in codegen.
73208 
73209 ";
73210 
73211 %feature("docstring")  casadi::FunctionInternal::nnz_out() const  "
73212 
73213 [INTERNAL]  Number of input/output nonzeros.
73214 
73215 ";
73216 
73217 %feature("docstring")  casadi::FunctionInternal::nnz_out(casadi_int ind)
73218 const  "
73219 
73220 [INTERNAL]  Number of input/output nonzeros.
73221 
73222 ";
73223 
73224 %feature("docstring")  casadi::FunctionInternal::nz_out(const std::vector<
73225 DM > &res) const  "
73226 
73227 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
73228 
73229 ";
73230 
73231 %feature("docstring")  casadi::FunctionInternal::nz_out(const std::vector<
73232 double > &res) const  "
73233 
73234 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
73235 
73236 ";
73237 
73238 %feature("docstring")  casadi::Scpgen::alloc_mem() const  "
73239 
73240 [INTERNAL]  Create memory block.
73241 
73242 ";
73243 
73244 %feature("docstring")  casadi::FunctionInternal::get_jacobian_sparsity()
73245 const  "
73246 
73247 [INTERNAL]  Get Jacobian sparsity.
73248 
73249 ";
73250 
73251 %feature("docstring")  casadi::Nlpsol::integer_support() const  "
73252 
73253 [INTERNAL]  Can discrete variables be treated.
73254 
73255 ";
73256 
73257 %feature("docstring")  casadi::FunctionInternal::size2_in(casadi_int ind)
73258 const  "
73259 
73260 [INTERNAL]  Input/output dimensions.
73261 
73262 ";
73263 
73264 %feature("docstring")  casadi::FunctionInternal::get_min_in(casadi_int ind)
73265 const  "
73266 
73267 [INTERNAL]  Get smallest input value.
73268 
73269 ";
73270 
73271 %feature("docstring")  casadi::ProtoFunction::release(int mem) const  "
73272 
73273 [INTERNAL]  Release a memory object.
73274 
73275 ";
73276 
73277 %feature("docstring")  casadi::FunctionInternal::is_diff_out(casadi_int i) "
73278 
73279 [INTERNAL] ";
73280 
73281 %feature("docstring")  casadi::FunctionInternal::reverse(casadi_int nadj)
73282 const  "
73283 
73284 [INTERNAL]  Return function that calculates adjoint derivatives
73285 reverse(nadj) returns a cached instance if available, and calls  Function
73286 get_reverse(casadi_int nadj) if no cached version is available.
73287 
73288 ";
73289 
73290 %feature("docstring")  casadi::Scpgen::set_work(void *mem, const double
73291 **&arg, double **&res, casadi_int *&iw, double *&w) const  "
73292 
73293 [INTERNAL]  Set the (persistent) work vectors.
73294 
73295 ";
73296 
73297 %feature("docstring")  casadi::FunctionInternal::wrap_as_needed(const Dict
73298 &opts) const  "
73299 
73300 [INTERNAL]  Wrap in an Function instance consisting of only one MX call.
73301 
73302 ";
73303 
73304 %feature("docstring")  casadi::FunctionInternal::get_free() const  "
73305 
73306 [INTERNAL]  Print free variables.
73307 
73308 ";
73309 
73310 %feature("docstring")  casadi::Scpgen::primalInfeasibility(ScpgenMemory *m)
73311 const  "
73312 
73313 [INTERNAL] ";
73314 
73315 %feature("docstring")  casadi::OracleFunction::set_function(const Function
73316 &fcn, const std::string &fname, bool jit=false) "
73317 
73318 [INTERNAL]  Register the function for evaluation and statistics gathering
73319 
73320 ";
73321 
73322 %feature("docstring")  casadi::OracleFunction::set_function(const Function
73323 &fcn) "
73324 
73325 [INTERNAL]  Register the function for evaluation and statistics gathering
73326 
73327 ";
73328 
73329 %feature("docstring")  casadi::FunctionInternal::call_reverse(const
73330 std::vector< MX > &arg, const std::vector< MX > &res, const std::vector<
73331 std::vector< MX > > &aseed, std::vector< std::vector< MX > > &asens, bool
73332 always_inline, bool never_inline) const  "
73333 
73334 [INTERNAL]  Reverse mode, virtual functions overloaded in derived classes.
73335 
73336 ";
73337 
73338 %feature("docstring")  casadi::FunctionInternal::call_reverse(const
73339 std::vector< SX > &arg, const std::vector< SX > &res, const std::vector<
73340 std::vector< SX > > &aseed, std::vector< std::vector< SX > > &asens, bool
73341 always_inline, bool never_inline) const  "
73342 
73343 [INTERNAL]  Reverse mode, virtual functions overloaded in derived classes.
73344 
73345 ";
73346 
73347 %feature("docstring")  casadi::FunctionInternal::self() const  "
73348 
73349 [INTERNAL]  Get a public class instance.
73350 
73351 ";
73352 
73353 %feature("docstring")  casadi::FunctionInternal::sz_iw() const  "
73354 
73355 [INTERNAL]  Get required length of iw field.
73356 
73357 ";
73358 
73359 %feature("docstring")  casadi::FunctionInternal::sx_in(casadi_int ind) const
73360 "
73361 
73362 [INTERNAL]  Get function input(s) and output(s)
73363 
73364 ";
73365 
73366 %feature("docstring")  casadi::FunctionInternal::sx_in() const  "
73367 
73368 [INTERNAL]  Get function input(s) and output(s)
73369 
73370 ";
73371 
73372 %feature("docstring")  casadi::Nlpsol::get_forward(casadi_int nfwd, const
73373 std::string &name, const std::vector< std::string > &inames, const
73374 std::vector< std::string > &onames, const Dict &opts) const  "
73375 
73376 [INTERNAL]  Generate a function that calculates forward mode derivatives.
73377 
73378 ";
73379 
73380 %feature("docstring")  casadi::Scpgen::getConic() const  "
73381 
73382 [INTERNAL]  Access qpsol.
73383 
73384 ";
73385 
73386 %feature("docstring")  casadi::FunctionInternal::alloc_iw(size_t sz_iw, bool
73387 persistent=false) "
73388 
73389 [INTERNAL]  Ensure required length of iw field.
73390 
73391 ";
73392 
73393 %feature("docstring")  casadi::FunctionInternal::alloc(const Function &f,
73394 bool persistent=false) "
73395 
73396 [INTERNAL]  Ensure work vectors long enough to evaluate function.
73397 
73398 ";
73399 
73400 %feature("docstring")  casadi::Scpgen::init_mem(void *mem) const  "
73401 
73402 [INTERNAL]  Initalize memory block.
73403 
73404 ";
73405 
73406 %feature("docstring")
73407 casadi::FunctionInternal::instruction_output(casadi_int k) const  "
73408 
73409 [INTERNAL]  Get the (integer) output argument of an atomic operation.
73410 
73411 ";
73412 
73413 %feature("docstring")  casadi::FunctionInternal::print_options(std::ostream
73414 &stream) const  "
73415 
73416 [INTERNAL]  Print list of options.
73417 
73418 ";
73419 
73420 %feature("docstring")  casadi::FunctionInternal::getJacSparsity(casadi_int
73421 iind, casadi_int oind, bool symmetric) const  "
73422 
73423 [INTERNAL]  Generate the sparsity of a Jacobian block.
73424 
73425 ";
73426 
73427 %feature("docstring")  casadi::FunctionInternal::call_gen(const MXVector
73428 &arg, MXVector &res, casadi_int npar, bool always_inline, bool never_inline)
73429 const  "
73430 
73431 [INTERNAL]   Call a function, overloaded.
73432 
73433 ";
73434 
73435 %feature("docstring")  casadi::FunctionInternal::call_gen(const std::vector<
73436 MatrixCommon > &arg, std::vector< MatrixCommon > &res, casadi_int npar, bool
73437 always_inline, bool never_inline) const  "
73438 
73439 [INTERNAL]   Call a function, overloaded.
73440 
73441 ";
73442 
73443 %feature("docstring")  casadi::FunctionInternal::alloc_arg(size_t sz_arg,
73444 bool persistent=false) "
73445 
73446 [INTERNAL]  Ensure required length of arg field.
73447 
73448 ";
73449 
73450 %feature("docstring")  casadi::Nlpsol::serialize_body(SerializingStream &s)
73451 const  "
73452 
73453 [INTERNAL]  Serialize an object without type information.
73454 
73455 ";
73456 
73457 %feature("docstring")  casadi::FunctionInternal::size_out(casadi_int ind)
73458 const  "
73459 
73460 [INTERNAL]  Input/output dimensions.
73461 
73462 ";
73463 
73464 %feature("docstring")  casadi::FunctionInternal::free_sx() const  "
73465 
73466 [INTERNAL]  Get free variables (SX)
73467 
73468 ";
73469 
73470 %feature("docstring")  casadi::FunctionInternal::eval_gen(const double
73471 **arg, double **res, casadi_int *iw, double *w, void *mem) const  "
73472 
73473 [INTERNAL]  Evaluate numerically.
73474 
73475 ";
73476 
73477 %feature("docstring")  casadi::FunctionInternal::eval_gen(const SXElem
73478 **arg, SXElem **res, casadi_int *iw, SXElem *w, void *mem) const  "
73479 
73480 [INTERNAL]  Evaluate a function, overloaded.
73481 
73482 ";
73483 
73484 %feature("docstring")  casadi::FunctionInternal::eval_gen(const bvec_t
73485 **arg, bvec_t **res, casadi_int *iw, bvec_t *w, void *mem) const  "
73486 
73487 [INTERNAL]  Evaluate a function, overloaded.
73488 
73489 ";
73490 
73491 %feature("docstring")  casadi::FunctionInternal::disp(std::ostream &stream,
73492 bool more) const  "
73493 
73494 [INTERNAL]  Display object.
73495 
73496 ";
73497 
73498 %feature("docstring")  casadi::FunctionInternal::sz_work(size_t &sz_arg,
73499 size_t &sz_res, size_t &sz_iw, size_t &sz_w) const  "
73500 
73501 [INTERNAL]  Get number of temporary variables needed.
73502 
73503 ";
73504 
73505 %feature("docstring")  casadi::FunctionInternal::get_partition(casadi_int
73506 iind, casadi_int oind, Sparsity &D1, Sparsity &D2, bool compact, bool
73507 symmetric, bool allow_forward, bool allow_reverse) const  "
73508 
73509 [INTERNAL]  Get the unidirectional or bidirectional partition.
73510 
73511 ";
73512 
73513 %feature("docstring")  casadi::FunctionInternal::numel_in() const  "
73514 
73515 [INTERNAL]  Number of input/output elements.
73516 
73517 ";
73518 
73519 %feature("docstring")  casadi::FunctionInternal::numel_in(casadi_int ind)
73520 const  "
73521 
73522 [INTERNAL]  Number of input/output elements.
73523 
73524 ";
73525 
73526 %feature("docstring")  casadi::FunctionInternal::has_spfwd() const  "
73527 
73528 [INTERNAL]  Is the class able to propagate seeds through the algorithm?
73529 
73530 ";
73531 
73532 %feature("docstring")  casadi::Scpgen::solve(void *mem) const  "
73533 
73534 [INTERNAL] ";
73535 
73536 %feature("docstring")  casadi::FunctionInternal::mx_in(casadi_int ind) const
73537 "
73538 
73539 [INTERNAL]  Get function input(s) and output(s)
73540 
73541 ";
73542 
73543 %feature("docstring")  casadi::FunctionInternal::mx_in() const  "
73544 
73545 [INTERNAL]  Get function input(s) and output(s)
73546 
73547 ";
73548 
73549 %feature("docstring")  casadi::Nlpsol::has_reverse(casadi_int nadj) const  "
73550 
73551 [INTERNAL]  Generate a function that calculates reverse mode derivatives.
73552 
73553 ";
73554 
73555 %feature("docstring")  casadi::SharedObjectInternal::weak() "
73556 
73557 [INTERNAL]  Get a weak reference to the object.
73558 
73559 ";
73560 
73561 %feature("docstring")  casadi::FunctionInternal::get_reltol() const  "
73562 
73563 [INTERNAL]  Get relative tolerance.
73564 
73565 ";
73566 
73567 %feature("docstring")  casadi::Scpgen::dualInfeasibility(ScpgenMemory *m)
73568 const  "
73569 
73570 [INTERNAL] ";
73571 
73572 %feature("docstring")  casadi::Scpgen::class_name() const  "
73573 
73574 [INTERNAL]  Get type name.
73575 
73576 ";
73577 
73578 %feature("docstring")
73579 casadi::FunctionInternal::getJacSparsityHierarchical(casadi_int iind,
73580 casadi_int oind) const  "
73581 
73582 [INTERNAL]  A flavor of getJacSparsity that does hierarchical block
73583 structure recognition.
73584 
73585 ";
73586 
73587 %feature("docstring")  casadi::FunctionInternal::replace_arg(const
73588 std::vector< M > &arg, casadi_int npar) const  "
73589 
73590 [INTERNAL]  Replace 0-by-0 inputs.
73591 
73592 ";
73593 
73594 %feature("docstring")  casadi::FunctionInternal::index_out(const std::string
73595 &name) const  "
73596 
73597 [INTERNAL]  Get output scheme index by name.
73598 
73599 ";
73600 
73601 %feature("docstring")  casadi::FunctionInternal::slice(const std::string
73602 &name, const std::vector< casadi_int > &order_in, const std::vector<
73603 casadi_int > &order_out, const Dict &opts) const  "
73604 
73605 [INTERNAL]  returns a new function with a selection of inputs/outputs of the
73606 original
73607 
73608 ";
73609 
73610 %feature("docstring")  casadi::Scpgen::solve_qp(ScpgenMemory *m) const  "
73611 
73612 [INTERNAL] ";
73613 
73614 %feature("docstring")  casadi::FunctionInternal::print_option(const
73615 std::string &name, std::ostream &stream) const  "
73616 
73617 [INTERNAL]  Print all information there is to know about a certain option.
73618 
73619 ";
73620 
73621 %feature("docstring")  casadi::FunctionInternal::sparsity_in(casadi_int ind)
73622 const  "
73623 
73624 [INTERNAL]  Input/output sparsity.
73625 
73626 ";
73627 
73628 %feature("docstring")  casadi::Scpgen::eval_exp(ScpgenMemory *m) const  "
73629 
73630 [INTERNAL] ";
73631 
73632 %feature("docstring")  casadi::Nlpsol::uses_output() const  "
73633 
73634 [INTERNAL]  Do the derivative functions need nondifferentiated outputs?
73635 
73636 ";
73637 
73638 %feature("docstring")  casadi::FunctionInternal::check_arg(const
73639 std::vector< M > &arg, casadi_int &npar) const  "
73640 
73641 [INTERNAL]  Check if input arguments have correct length and dimensions.
73642 
73643 Raises errors.
73644 
73645 Parameters:
73646 -----------
73647 
73648 npar[in]:  normal usage: 1, disallow pararallel calls: -1
73649 
73650 npar:  max number of horizontal repetitions across all arguments (or -1)
73651 
73652 ";
73653 
73654 %feature("docstring")  casadi::ProtoFunction::checkout() const  "
73655 
73656 [INTERNAL]  Checkout a memory object.
73657 
73658 ";
73659 
73660 %feature("docstring")  casadi::Nlpsol::get_default_in(casadi_int ind) const
73661 "
73662 
73663 [INTERNAL]  Get default input value.
73664 
73665 ";
73666 
73667 %feature("docstring")  casadi::FunctionInternal::has_codegen() const  "
73668 
73669 [INTERNAL]  Is codegen supported?
73670 
73671 ";
73672 
73673 %feature("docstring")  casadi::Scpgen::regularize(ScpgenMemory *m) const  "
73674 
73675 [INTERNAL] ";
73676 
73677 %feature("docstring")  casadi::OracleFunction::set_temp(void *mem, const
73678 double **arg, double **res, casadi_int *iw, double *w) const  "
73679 
73680 [INTERNAL]  Set the work vectors.
73681 
73682 ";
73683 
73684 %feature("docstring")  casadi::FunctionInternal::eval_mx(const MXVector
73685 &arg, MXVector &res, bool always_inline, bool never_inline) const  "
73686 
73687 [INTERNAL]  Evaluate with symbolic matrices.
73688 
73689 ";
73690 
73691 %feature("docstring")  casadi::Nlpsol::callback(NlpsolMemory *m) const  "
73692 
73693 [INTERNAL] ";
73694 
73695 %feature("docstring")  casadi::FunctionInternal::convert_arg(const
73696 std::vector< M > &arg) const  "
73697 
73698 [INTERNAL]  Convert from/to input/output lists/map.
73699 
73700 ";
73701 
73702 %feature("docstring")  casadi::FunctionInternal::convert_arg(const std::map<
73703 std::string, M > &arg) const  "
73704 
73705 [INTERNAL]  Convert from/to input/output lists/map.
73706 
73707 ";
73708 
73709 %feature("docstring")  casadi::FunctionInternal::has_sprev() const  "
73710 
73711 [INTERNAL]  Is the class able to propagate seeds through the algorithm?
73712 
73713 ";
73714 
73715 %feature("docstring")  casadi::FunctionInternal::codegen_meta(CodeGenerator
73716 &g) const  "
73717 
73718 [INTERNAL]  Generate meta-information allowing a user to evaluate a
73719 generated function.
73720 
73721 ";
73722 
73723 %feature("docstring")  casadi::FunctionInternal::wrap() const  "
73724 
73725 [INTERNAL]  Wrap in an Function instance consisting of only one MX call.
73726 
73727 ";
73728 
73729 %feature("docstring")  casadi::FunctionInternal::has_jacobian() const  "
73730 
73731 [INTERNAL]  Return Jacobian of all input elements with respect to all output
73732 elements.
73733 
73734 ";
73735 
73736 %feature("docstring")  casadi::FunctionInternal::forward(casadi_int nfwd)
73737 const  "
73738 
73739 [INTERNAL]  Return function that calculates forward derivatives
73740 forward(nfwd) returns a cached instance if available, and calls  Function
73741 get_forward(casadi_int nfwd) if no cached version is available.
73742 
73743 ";
73744 
73745 %feature("docstring")  casadi::Nlpsol::serialize_base_function() const  "
73746 
73747 [INTERNAL]  String used to identify the immediate FunctionInternal subclass.
73748 
73749 ";
73750 
73751 %feature("docstring")
73752 casadi::FunctionInternal::print_dimensions(std::ostream &stream) const  "
73753 
73754 [INTERNAL]  Print dimensions of inputs and outputs.
73755 
73756 ";
73757 
73758 %feature("docstring")  casadi::Scpgen::get_options() const  "
73759 
73760 [INTERNAL]  Options.
73761 
73762 ";
73763 
73764 %feature("docstring")  casadi::FunctionInternal::size2_out(casadi_int ind)
73765 const  "
73766 
73767 [INTERNAL]  Input/output dimensions.
73768 
73769 ";
73770 
73771 %feature("docstring")  casadi::Nlpsol::get_name_out(casadi_int i)  "
73772 
73773 [INTERNAL]  Names of function input and outputs.
73774 
73775 ";
73776 
73777 %feature("docstring")  casadi::Nlpsol::serialize_type(SerializingStream &s)
73778 const  "
73779 
73780 [INTERNAL]  Serialize type information.
73781 
73782 ";
73783 
73784 %feature("docstring")  casadi::ProtoFunction::print_time(const std::map<
73785 std::string, FStats > &fstats) const  "
73786 
73787 [INTERNAL]  Print timing statistics.
73788 
73789 ";
73790 
73791 %feature("docstring")  casadi::FunctionInternal::which_depends(const
73792 std::string &s_in, const std::vector< std::string > &s_out, casadi_int
73793 order, bool tr=false) const  "
73794 
73795 [INTERNAL]  Which variables enter with some order.
73796 
73797 Parameters:
73798 -----------
73799 
73800 s_in:   Input name
73801 
73802 s_out:   Output name(s)
73803 
73804 order:  Only 1 (linear) and 2 (nonlinear) allowed
73805 
73806 tr:  Flip the relationship. Return which expressions contain the variables
73807 
73808 ";
73809 
73810 %feature("docstring")  casadi::FunctionInternal::jacobian() const  "
73811 
73812 [INTERNAL]  Return Jacobian of all input elements with respect to all output
73813 elements.
73814 
73815 ";
73816 
73817 %feature("docstring")  casadi::FunctionInternal::adjViaJac(casadi_int nadj)
73818 const  "
73819 
73820 [INTERNAL]  Calculate derivatives by multiplying the full Jacobian and
73821 multiplying.
73822 
73823 ";
73824 
73825 %feature("docstring")  casadi::FunctionInternal::jacobian_sparsity() const
73826 "
73827 
73828 [INTERNAL]  Get Jacobian sparsity.
73829 
73830 ";
73831 
73832 %feature("docstring")  casadi::FunctionInternal::definition() const  "
73833 
73834 [INTERNAL]  Get function signature: name:(inputs)->(outputs)
73835 
73836 ";
73837 
73838 %feature("docstring")  casadi::FunctionInternal::sx_out(casadi_int ind)
73839 const  "
73840 
73841 [INTERNAL]  Get function input(s) and output(s)
73842 
73843 ";
73844 
73845 %feature("docstring")  casadi::FunctionInternal::sx_out() const  "
73846 
73847 [INTERNAL]  Get function input(s) and output(s)
73848 
73849 ";
73850 
73851 %feature("docstring")
73852 casadi::FunctionInternal::codegen_incref(CodeGenerator &g) const  "
73853 
73854 [INTERNAL]  Codegen incref for dependencies.
73855 
73856 ";
73857 
73858 %feature("docstring")  casadi::FunctionInternal::instructions_sx() const  "
73859 
73860 [INTERNAL]  get SX expression associated with instructions
73861 
73862 ";
73863 
73864 %feature("docstring")
73865 casadi::FunctionInternal::codegen_decref(CodeGenerator &g) const  "
73866 
73867 [INTERNAL]  Codegen decref for dependencies.
73868 
73869 ";
73870 
73871 %feature("docstring")  casadi::ProtoFunction::serialize(SerializingStream
73872 &s) const  "
73873 
73874 [INTERNAL]  Serialize an object.
73875 
73876 ";
73877 
73878 %feature("docstring")  casadi::Nlpsol::check_inputs(void *mem) const  "
73879 
73880 [INTERNAL]  Check if the inputs correspond to a well-posed problem.
73881 
73882 ";
73883 
73884 %feature("docstring")  casadi::FunctionInternal::call_forward(const
73885 std::vector< MX > &arg, const std::vector< MX > &res, const std::vector<
73886 std::vector< MX > > &fseed, std::vector< std::vector< MX > > &fsens, bool
73887 always_inline, bool never_inline) const  "
73888 
73889 [INTERNAL]  Forward mode AD, virtual functions overloaded in derived
73890 classes.
73891 
73892 ";
73893 
73894 %feature("docstring")  casadi::FunctionInternal::call_forward(const
73895 std::vector< SX > &arg, const std::vector< SX > &res, const std::vector<
73896 std::vector< SX > > &fseed, std::vector< std::vector< SX > > &fsens, bool
73897 always_inline, bool never_inline) const  "
73898 
73899 [INTERNAL]  Forward mode AD, virtual functions overloaded in derived
73900 classes.
73901 
73902 ";
73903 
73904 %feature("docstring")  casadi::FunctionInternal::project_res(const
73905 std::vector< M > &arg, casadi_int npar) const  "
73906 
73907 [INTERNAL]   Project sparsities.
73908 
73909 ";
73910 
73911 %feature("docstring")  casadi::Nlpsol::get_sparsity_in(casadi_int i)  "
73912 
73913 [INTERNAL]  Sparsities of function inputs and outputs.
73914 
73915 ";
73916 
73917 %feature("docstring")  casadi::FunctionInternal::check_mat(const Sparsity
73918 &arg, const Sparsity &inp, casadi_int &npar) "
73919 
73920 [INTERNAL]  Helper function
73921 
73922 Parameters:
73923 -----------
73924 
73925 npar[in]:  normal usage: 1, disallow pararallel calls: -1
73926 
73927 npar[out]:  required number of parallel calls (or -1)
73928 
73929 ";
73930 
73931 %feature("docstring")  casadi::Nlpsol::get_sparsity_out(casadi_int i)  "
73932 
73933 [INTERNAL]  Sparsities of function inputs and outputs.
73934 
73935 ";
73936 
73937 %feature("docstring")
73938 casadi::FunctionInternal::jacobian_sparsity_filter(const Sparsity &sp) const
73939 "
73940 
73941 [INTERNAL]  Filter out nonzeros in the full sparsity jacobian according to
73942 is_diff_in/out.
73943 
73944 ";
73945 
73946 %feature("docstring")  casadi::OracleFunction::generate_dependencies(const
73947 std::string &fname, const Dict &opts) const  "
73948 
73949 [INTERNAL]  Export / Generate C code for the generated functions.
73950 
73951 ";
73952 
73953 %feature("docstring")  casadi::OracleFunction::monitored(const std::string
73954 &name) const  "
73955 
73956 [INTERNAL] ";
73957 
73958 %feature("docstring")  casadi::FunctionInternal::eval_dm(const std::vector<
73959 DM > &arg) const  "
73960 
73961 [INTERNAL]  Evaluate with DM matrices.
73962 
73963 ";
73964 
73965 %feature("docstring")  casadi::OracleFunction::get_function() const  "
73966 
73967 [INTERNAL]  Get list of dependency functions -1 Indicates irregularity.
73968 
73969 ";
73970 
73971 %feature("docstring")  casadi::OracleFunction::get_function(const
73972 std::string &name) const  "
73973 
73974 [INTERNAL] ";
73975 
73976 %feature("docstring")  casadi::FunctionInternal::tocache(const Function &f,
73977 const std::string &suffix="") const  "
73978 
73979 [INTERNAL]  Save function to cache.
73980 
73981 ";
73982 
73983 %feature("docstring")  casadi::Nlpsol::getReducedHessian() "
73984 
73985 [INTERNAL] ";
73986 
73987 %feature("docstring")  casadi::FunctionInternal::sparsity_out(casadi_int
73988 ind) const  "
73989 
73990 [INTERNAL]  Input/output sparsity.
73991 
73992 ";
73993 
73994 %feature("docstring")  casadi::Nlpsol::kkt() const  "
73995 
73996 [INTERNAL] ";
73997 
73998 %feature("docstring")  casadi::Nlpsol::eval(const double **arg, double
73999 **res, casadi_int *iw, double *w, void *mem) const final "
74000 
74001 [INTERNAL]  Evaluate numerically.
74002 
74003 ";
74004 
74005 %feature("docstring")  casadi::FunctionInternal::dm_in(casadi_int ind) const
74006 "
74007 
74008 [INTERNAL]  Get function input(s) and output(s)
74009 
74010 ";
74011 
74012 %feature("docstring")  casadi::FunctionInternal::dm_in() const  "
74013 
74014 [INTERNAL]  Get function input(s) and output(s)
74015 
74016 ";
74017 
74018 %feature("docstring")  casadi::FunctionInternal::info() const  "
74019 
74020 [INTERNAL]  Obtain information about function
74021 
74022 ";
74023 
74024 %feature("docstring")  casadi::FunctionInternal::symbolic_output(const
74025 std::vector< MX > &arg) const  "
74026 
74027 [INTERNAL]  Get a vector of symbolic variables corresponding to the outputs.
74028 
74029 ";
74030 
74031 %feature("docstring")  casadi::FunctionInternal::get_jac(const std::string
74032 &name, const std::vector< std::string > &inames, const std::vector<
74033 std::string > &onames, const Dict &opts) const  "
74034 
74035 [INTERNAL]  Return Jacobian of all input elements with respect to all output
74036 elements.
74037 
74038 ";
74039 
74040 %feature("docstring")  casadi::SharedObjectInternal::getCount() const  "
74041 
74042 [INTERNAL]  Get the reference count.
74043 
74044 ";
74045 
74046 %feature("docstring")  casadi::FunctionInternal::codegen(CodeGenerator &g,
74047 const std::string &fname) const  "
74048 
74049 [INTERNAL]  Generate code the function.
74050 
74051 ";
74052 
74053 %feature("docstring")  casadi::FunctionInternal::sz_w() const  "
74054 
74055 [INTERNAL]  Get required length of w field.
74056 
74057 ";
74058 
74059 %feature("docstring")  casadi::OracleFunction::jit_dependencies(const
74060 std::string &fname)  "
74061 
74062 [INTERNAL]  JIT for dependencies.
74063 
74064 ";
74065 
74066 %feature("docstring")  casadi::FunctionInternal::size_in(casadi_int ind)
74067 const  "
74068 
74069 [INTERNAL]  Input/output dimensions.
74070 
74071 ";
74072 
74073 %feature("docstring")  casadi::FunctionInternal::convert_res(const
74074 std::vector< M > &res) const  "
74075 
74076 [INTERNAL]  Convert from/to input/output lists/map.
74077 
74078 ";
74079 
74080 %feature("docstring")  casadi::FunctionInternal::convert_res(const std::map<
74081 std::string, M > &res) const  "
74082 
74083 [INTERNAL]  Convert from/to input/output lists/map.
74084 
74085 ";
74086 
74087 %feature("docstring")  casadi::FunctionInternal::sp_forward(const bvec_t
74088 **arg, bvec_t **res, casadi_int *iw, bvec_t *w, void *mem) const  "
74089 
74090 [INTERNAL]  Propagate sparsity forward.
74091 
74092 ";
74093 
74094 %feature("docstring")  casadi::FunctionInternal::jac() const  "
74095 
74096 [INTERNAL]  Return Jacobian of all input elements with respect to all output
74097 elements.
74098 
74099 ";
74100 
74101 %feature("docstring")  casadi::FunctionInternal::project_arg(const
74102 std::vector< M > &arg, casadi_int npar) const  "
74103 
74104 [INTERNAL]   Project sparsities.
74105 
74106 ";
74107 
74108 %feature("docstring")  casadi::FunctionInternal::has_jac() const  "
74109 
74110 [INTERNAL]  Return Jacobian of all input elements with respect to all output
74111 elements.
74112 
74113 ";
74114 
74115 %feature("docstring")  casadi::FunctionInternal::codegen_mem(CodeGenerator
74116 &g, const std::string &index="mem") const  "
74117 
74118 [INTERNAL]  Get thread-local memory object.
74119 
74120 ";
74121 
74122 %feature("docstring")  casadi::FunctionInternal::dm_out(casadi_int ind)
74123 const  "
74124 
74125 [INTERNAL]  Get function input(s) and output(s)
74126 
74127 ";
74128 
74129 %feature("docstring")  casadi::FunctionInternal::dm_out() const  "
74130 
74131 [INTERNAL]  Get function input(s) and output(s)
74132 
74133 ";
74134 
74135 %feature("docstring")  casadi::Scpgen::line_search(ScpgenMemory *m,
74136 casadi_int &ls_iter, bool &ls_success) const  "
74137 
74138 [INTERNAL] ";
74139 
74140 %feature("docstring")  casadi::FunctionInternal::is_diff_in(casadi_int i) "
74141 
74142 [INTERNAL] ";
74143 
74144 %feature("docstring")  casadi::FunctionInternal::matching_res(const
74145 std::vector< M > &arg, casadi_int &npar) const  "
74146 
74147 [INTERNAL]  Check if output arguments that needs to be replaced.
74148 
74149 Raises errors
74150 
74151 Parameters:
74152 -----------
74153 
74154 npar[in]:  normal usage: 1, disallow pararallel calls: -1
74155 
74156 npar:  max number of horizontal repetitions across all arguments (or -1)
74157 
74158 ";
74159 
74160 %feature("docstring")  casadi::FunctionInternal::generate_lifted(Function
74161 &vdef_fcn, Function &vinit_fcn) const  "
74162 
74163 [INTERNAL]  Extract the functions needed for the Lifted Newton method.
74164 
74165 ";
74166 
74167 %feature("docstring")  casadi::Nlpsol::has_forward(casadi_int nfwd) const  "
74168 
74169 [INTERNAL]  Generate a function that calculates forward mode derivatives.
74170 
74171 ";
74172 
74173 %feature("docstring")  casadi::FunctionInternal::n_nodes() const  "
74174 
74175 [INTERNAL]  Number of nodes in the algorithm.
74176 
74177 ";
74178 
74179 %feature("docstring")  casadi::FunctionInternal::sparsity_jac(casadi_int
74180 iind, casadi_int oind, bool compact, bool symmetric) const  "
74181 
74182 [INTERNAL]  Get, if necessary generate, the sparsity of a Jacobian block.
74183 
74184 ";
74185 
74186 %feature("docstring")  casadi::FunctionInternal::instruction_MX(casadi_int
74187 k) const  "
74188 
74189 [INTERNAL]  get MX expression associated with instruction
74190 
74191 ";
74192 
74193 %feature("docstring")  casadi::ProtoFunction::sprint(char *buf, size_t
74194 buf_sz, const char *fmt,...) const  "
74195 
74196 [INTERNAL]  C-style formatted printing to string.
74197 
74198 ";
74199 
74200 %feature("docstring")  casadi::Scpgen::get_stats(void *mem) const  "
74201 
74202 [INTERNAL]  Get all statistics.
74203 
74204 ";
74205 
74206 %feature("docstring")  casadi::OracleFunction::calc_function(OracleMemory
74207 *m, const std::string &fcn, const double *const *arg=nullptr) const  "
74208 
74209 [INTERNAL] ";
74210 
74211 %feature("docstring")  casadi::FunctionInternal::generate_in(const
74212 std::string &fname, const double **arg) const  "
74213 
74214 [INTERNAL]  Export an input file that can be passed to generate C code with
74215 a main.
74216 
74217 ";
74218 
74219 %feature("docstring")  casadi::FunctionInternal::n_instructions() const  "
74220 
74221 [INTERNAL]  Get the number of atomic operations.
74222 
74223 ";
74224 
74225 %feature("docstring")  casadi::Nlpsol::is_a(const std::string &type, bool
74226 recursive) const  "
74227 
74228 [INTERNAL]  Check if the function is of a particular type.
74229 
74230 ";
74231 
74232 %feature("docstring")  casadi::FunctionInternal::generate_options(bool
74233 is_temp=false) const  "
74234 
74235 [INTERNAL]  Reconstruct options dict.
74236 
74237 ";
74238 
74239 %feature("docstring")  casadi::FunctionInternal::get_jacobian(const
74240 std::string &name, const std::vector< std::string > &inames, const
74241 std::vector< std::string > &onames, const Dict &opts) const  "
74242 
74243 [INTERNAL]  Return Jacobian of all input elements with respect to all output
74244 elements.
74245 
74246 ";
74247 
74248 %feature("docstring")
74249 casadi::FunctionInternal::codegen_declarations(CodeGenerator &g) const  "
74250 
74251 [INTERNAL]  Generate code for the declarations of the C function.
74252 
74253 ";
74254 
74255 %feature("docstring")  casadi::FunctionInternal::sz_res() const  "
74256 
74257 [INTERNAL]  Get required length of res field.
74258 
74259 ";
74260 
74261 %feature("docstring")  casadi::Scpgen::plugin_name() const  "
74262 
74263 [INTERNAL] ";
74264 
74265 %feature("docstring")  casadi::FunctionInternal::nnz_in() const  "
74266 
74267 [INTERNAL]  Number of input/output nonzeros.
74268 
74269 ";
74270 
74271 %feature("docstring")  casadi::FunctionInternal::nnz_in(casadi_int ind)
74272 const  "
74273 
74274 [INTERNAL]  Number of input/output nonzeros.
74275 
74276 ";
74277 
74278 %feature("docstring")  casadi::FunctionInternal::has_eval_dm() const  "
74279 
74280 [INTERNAL]  Evaluate with DM matrices.
74281 
74282 ";
74283 
74284 %feature("docstring")  casadi::FunctionInternal::has_derivative() const  "
74285 
74286 [INTERNAL]  Can derivatives be calculated in any way?
74287 
74288 ";
74289 
74290 %feature("docstring")  casadi::FunctionInternal::eval_sx(const SXElem **arg,
74291 SXElem **res, casadi_int *iw, SXElem *w, void *mem) const  "
74292 
74293 [INTERNAL]  Evaluate with symbolic scalars.
74294 
74295 ";
74296 
74297 %feature("docstring")  casadi::FunctionInternal::sp_reverse(bvec_t **arg,
74298 bvec_t **res, casadi_int *iw, bvec_t *w, void *mem) const  "
74299 
74300 [INTERNAL]  Propagate sparsity backwards.
74301 
74302 ";
74303 
74304 %feature("docstring")  casadi::Scpgen::init(const Dict &opts)  "
74305 
74306 [INTERNAL]  Initialize.
74307 
74308 ";
74309 
74310 %feature("docstring")  casadi::FunctionInternal::factory(const std::string
74311 &name, const std::vector< std::string > &s_in, const std::vector<
74312 std::string > &s_out, const Function::AuxOut &aux, const Dict &opts) const
74313 "
74314 
74315 [INTERNAL] ";
74316 
74317 %feature("docstring")  casadi::FunctionInternal::sz_arg() const  "
74318 
74319 [INTERNAL]  Get required length of arg field.
74320 
74321 ";
74322 
74323 %feature("docstring")  casadi::ProtoFunction::construct(const Dict &opts) "
74324 
74325 [INTERNAL]  Construct Prepares the function for evaluation.
74326 
74327 ";
74328 
74329 %feature("docstring") casadi::Scpgen "
74330 
74331 'scpgen' plugin for Nlpsol
74332 
74333 A structure-exploiting sequential quadratic programming (to be come
74334 sequential convex programming) method for nonlinear programming.
74335 
74336 >List of available options
74337 
74338 +-----------------------+-----------------+--------------------------------+
74339 |          Id           |      Type       |          Description           |
74340 +=======================+=================+================================+
74341 | beta                  | OT_DOUBLE       | Line-search parameter,         |
74342 |                       |                 | restoration factor of stepsize |
74343 +-----------------------+-----------------+--------------------------------+
74344 | c1                    | OT_DOUBLE       | Armijo condition, coefficient  |
74345 |                       |                 | of decrease in merit           |
74346 +-----------------------+-----------------+--------------------------------+
74347 | codegen               | OT_BOOL         | C-code generation              |
74348 +-----------------------+-----------------+--------------------------------+
74349 | hessian_approximation | OT_STRING       | gauss-newton|exact             |
74350 +-----------------------+-----------------+--------------------------------+
74351 | lbfgs_memory          | OT_INT          | Size of L-BFGS memory.         |
74352 +-----------------------+-----------------+--------------------------------+
74353 | max_iter              | OT_INT          | Maximum number of SQP          |
74354 |                       |                 | iterations                     |
74355 +-----------------------+-----------------+--------------------------------+
74356 | max_iter_ls           | OT_INT          | Maximum number of linesearch   |
74357 |                       |                 | iterations                     |
74358 +-----------------------+-----------------+--------------------------------+
74359 | merit_memsize         | OT_INT          | Size of memory to store        |
74360 |                       |                 | history of merit function      |
74361 |                       |                 | values                         |
74362 +-----------------------+-----------------+--------------------------------+
74363 | merit_start           | OT_DOUBLE       | Lower bound for the merit      |
74364 |                       |                 | function parameter             |
74365 +-----------------------+-----------------+--------------------------------+
74366 | name_x                | OT_STRINGVECTOR | Names of the variables.        |
74367 +-----------------------+-----------------+--------------------------------+
74368 | print_header          | OT_BOOL         | Print the header with problem  |
74369 |                       |                 | statistics                     |
74370 +-----------------------+-----------------+--------------------------------+
74371 | print_x               | OT_INTVECTOR    | Which variables to print.      |
74372 +-----------------------+-----------------+--------------------------------+
74373 | qpsol                 | OT_STRING       | The QP solver to be used by    |
74374 |                       |                 | the SQP method                 |
74375 +-----------------------+-----------------+--------------------------------+
74376 | qpsol_options         | OT_DICT         | Options to be passed to the QP |
74377 |                       |                 | solver                         |
74378 +-----------------------+-----------------+--------------------------------+
74379 | reg_threshold         | OT_DOUBLE       | Threshold for the              |
74380 |                       |                 | regularization.                |
74381 +-----------------------+-----------------+--------------------------------+
74382 | regularize            | OT_BOOL         | Automatic regularization of    |
74383 |                       |                 | Lagrange Hessian.              |
74384 +-----------------------+-----------------+--------------------------------+
74385 | tol_du                | OT_DOUBLE       | Stopping criterion for dual    |
74386 |                       |                 | infeasability                  |
74387 +-----------------------+-----------------+--------------------------------+
74388 | tol_pr                | OT_DOUBLE       | Stopping criterion for primal  |
74389 |                       |                 | infeasibility                  |
74390 +-----------------------+-----------------+--------------------------------+
74391 | tol_pr_step           | OT_DOUBLE       | Stopping criterion for the     |
74392 |                       |                 | step size                      |
74393 +-----------------------+-----------------+--------------------------------+
74394 | tol_reg               | OT_DOUBLE       | Stopping criterion for         |
74395 |                       |                 | regularization                 |
74396 +-----------------------+-----------------+--------------------------------+
74397 
74398 Joel Andersson, Attila Kozma and Joris Gillis
74399 
74400 >List of available options
74401 
74402 +-------------------+-----------------+-------------------+----------------+
74403 |        Id         |      Type       |    Description    |    Used in     |
74404 +===================+=================+===================+================+
74405 | beta              | OT_DOUBLE       | Line-search       | casadi::Scpgen |
74406 |                   |                 | parameter,        |                |
74407 |                   |                 | restoration       |                |
74408 |                   |                 | factor of         |                |
74409 |                   |                 | stepsize          |                |
74410 +-------------------+-----------------+-------------------+----------------+
74411 | bound_consistency | OT_BOOL         | Ensure that       | casadi::Nlpsol |
74412 |                   |                 | primal-dual       |                |
74413 |                   |                 | solution is       |                |
74414 |                   |                 | consistent with   |                |
74415 |                   |                 | the bounds        |                |
74416 +-------------------+-----------------+-------------------+----------------+
74417 | c1                | OT_DOUBLE       | Armijo condition, | casadi::Scpgen |
74418 |                   |                 | coefficient of    |                |
74419 |                   |                 | decrease in merit |                |
74420 +-------------------+-----------------+-------------------+----------------+
74421 | calc_f            | OT_BOOL         | Calculate 'f' in  | casadi::Nlpsol |
74422 |                   |                 | the Nlpsol base   |                |
74423 |                   |                 | class             |                |
74424 +-------------------+-----------------+-------------------+----------------+
74425 | calc_g            | OT_BOOL         | Calculate 'g' in  | casadi::Nlpsol |
74426 |                   |                 | the Nlpsol base   |                |
74427 |                   |                 | class             |                |
74428 +-------------------+-----------------+-------------------+----------------+
74429 | calc_lam_p        | OT_BOOL         | Calculate 'lam_p' | casadi::Nlpsol |
74430 |                   |                 | in the Nlpsol     |                |
74431 |                   |                 | base class        |                |
74432 +-------------------+-----------------+-------------------+----------------+
74433 | calc_lam_x        | OT_BOOL         | Calculate 'lam_x' | casadi::Nlpsol |
74434 |                   |                 | in the Nlpsol     |                |
74435 |                   |                 | base class        |                |
74436 +-------------------+-----------------+-------------------+----------------+
74437 | calc_multipliers  | OT_BOOL         | Calculate         | casadi::Nlpsol |
74438 |                   |                 | Lagrange          |                |
74439 |                   |                 | multipliers in    |                |
74440 |                   |                 | the Nlpsol base   |                |
74441 |                   |                 | class             |                |
74442 +-------------------+-----------------+-------------------+----------------+
74443 | codegen           | OT_BOOL         | C-code generation | casadi::Scpgen |
74444 +-------------------+-----------------+-------------------+----------------+
74445 | discrete          | OT_BOOLVECTOR   | Indicates which   | casadi::Nlpsol |
74446 |                   |                 | of the variables  |                |
74447 |                   |                 | are discrete,     |                |
74448 |                   |                 | i.e. integer-     |                |
74449 |                   |                 | valued            |                |
74450 +-------------------+-----------------+-------------------+----------------+
74451 | error_on_fail     | OT_BOOL         | When the          | casadi::Nlpsol |
74452 |                   |                 | numerical process |                |
74453 |                   |                 | returns           |                |
74454 |                   |                 | unsuccessfully,   |                |
74455 |                   |                 | raise an error    |                |
74456 |                   |                 | (default false).  |                |
74457 +-------------------+-----------------+-------------------+----------------+
74458 | eval_errors_fatal | OT_BOOL         | When errors occur | casadi::Nlpsol |
74459 |                   |                 | during evaluation |                |
74460 |                   |                 | of f,g,...,stop   |                |
74461 |                   |                 | the iterations    |                |
74462 +-------------------+-----------------+-------------------+----------------+
74463 | hessian_approxima | OT_STRING       | gauss-            | casadi::Scpgen |
74464 | tion              |                 | newton|exact      |                |
74465 +-------------------+-----------------+-------------------+----------------+
74466 | ignore_check_vec  | OT_BOOL         | If set to true,   | casadi::Nlpsol |
74467 |                   |                 | the input shape   |                |
74468 |                   |                 | of F will not be  |                |
74469 |                   |                 | checked.          |                |
74470 +-------------------+-----------------+-------------------+----------------+
74471 | iteration_callbac | OT_FUNCTION     | A function that   | casadi::Nlpsol |
74472 | k                 |                 | will be called at |                |
74473 |                   |                 | each iteration    |                |
74474 |                   |                 | with the solver   |                |
74475 |                   |                 | as input. Check   |                |
74476 |                   |                 | documentation of  |                |
74477 |                   |                 | Callback .        |                |
74478 +-------------------+-----------------+-------------------+----------------+
74479 | iteration_callbac | OT_BOOL         | If set to true,   | casadi::Nlpsol |
74480 | k_ignore_errors   |                 | errors thrown by  |                |
74481 |                   |                 | iteration_callbac |                |
74482 |                   |                 | k will be         |                |
74483 |                   |                 | ignored.          |                |
74484 +-------------------+-----------------+-------------------+----------------+
74485 | iteration_callbac | OT_INT          | Only call the     | casadi::Nlpsol |
74486 | k_step            |                 | callback function |                |
74487 |                   |                 | every few         |                |
74488 |                   |                 | iterations.       |                |
74489 +-------------------+-----------------+-------------------+----------------+
74490 | lbfgs_memory      | OT_INT          | Size of L-BFGS    | casadi::Scpgen |
74491 |                   |                 | memory.           |                |
74492 +-------------------+-----------------+-------------------+----------------+
74493 | max_iter          | OT_INT          | Maximum number of | casadi::Scpgen |
74494 |                   |                 | SQP iterations    |                |
74495 +-------------------+-----------------+-------------------+----------------+
74496 | max_iter_ls       | OT_INT          | Maximum number of | casadi::Scpgen |
74497 |                   |                 | linesearch        |                |
74498 |                   |                 | iterations        |                |
74499 +-------------------+-----------------+-------------------+----------------+
74500 | merit_memsize     | OT_INT          | Size of memory to | casadi::Scpgen |
74501 |                   |                 | store history of  |                |
74502 |                   |                 | merit function    |                |
74503 |                   |                 | values            |                |
74504 +-------------------+-----------------+-------------------+----------------+
74505 | merit_start       | OT_DOUBLE       | Lower bound for   | casadi::Scpgen |
74506 |                   |                 | the merit         |                |
74507 |                   |                 | function          |                |
74508 |                   |                 | parameter         |                |
74509 +-------------------+-----------------+-------------------+----------------+
74510 | min_lam           | OT_DOUBLE       | Minimum allowed   | casadi::Nlpsol |
74511 |                   |                 | multiplier value  |                |
74512 +-------------------+-----------------+-------------------+----------------+
74513 | name_x            | OT_STRINGVECTOR | Names of the      | casadi::Scpgen |
74514 |                   |                 | variables.        |                |
74515 +-------------------+-----------------+-------------------+----------------+
74516 | no_nlp_grad       | OT_BOOL         | Prevent the       | casadi::Nlpsol |
74517 |                   |                 | creation of the   |                |
74518 |                   |                 | 'nlp_grad'        |                |
74519 |                   |                 | function          |                |
74520 +-------------------+-----------------+-------------------+----------------+
74521 | oracle_options    | OT_DICT         | Options to be     | casadi::Nlpsol |
74522 |                   |                 | passed to the     |                |
74523 |                   |                 | oracle function   |                |
74524 +-------------------+-----------------+-------------------+----------------+
74525 | print_header      | OT_BOOL         | Print the header  | casadi::Scpgen |
74526 |                   |                 | with problem      |                |
74527 |                   |                 | statistics        |                |
74528 +-------------------+-----------------+-------------------+----------------+
74529 | print_x           | OT_INTVECTOR    | Which variables   | casadi::Scpgen |
74530 |                   |                 | to print.         |                |
74531 +-------------------+-----------------+-------------------+----------------+
74532 | qpsol             | OT_STRING       | The QP solver to  | casadi::Scpgen |
74533 |                   |                 | be used by the    |                |
74534 |                   |                 | SQP method        |                |
74535 +-------------------+-----------------+-------------------+----------------+
74536 | qpsol_options     | OT_DICT         | Options to be     | casadi::Scpgen |
74537 |                   |                 | passed to the QP  |                |
74538 |                   |                 | solver            |                |
74539 +-------------------+-----------------+-------------------+----------------+
74540 | reg_threshold     | OT_DOUBLE       | Threshold for the | casadi::Scpgen |
74541 |                   |                 | regularization.   |                |
74542 +-------------------+-----------------+-------------------+----------------+
74543 | regularize        | OT_BOOL         | Automatic         | casadi::Scpgen |
74544 |                   |                 | regularization of |                |
74545 |                   |                 | Lagrange Hessian. |                |
74546 +-------------------+-----------------+-------------------+----------------+
74547 | sens_linsol       | OT_STRING       | Linear solver     | casadi::Nlpsol |
74548 |                   |                 | used for          |                |
74549 |                   |                 | parametric        |                |
74550 |                   |                 | sensitivities     |                |
74551 |                   |                 | (default 'qr').   |                |
74552 +-------------------+-----------------+-------------------+----------------+
74553 | sens_linsol_optio | OT_DICT         | Linear solver     | casadi::Nlpsol |
74554 | ns                |                 | options used for  |                |
74555 |                   |                 | parametric        |                |
74556 |                   |                 | sensitivities.    |                |
74557 +-------------------+-----------------+-------------------+----------------+
74558 | tol_du            | OT_DOUBLE       | Stopping          | casadi::Scpgen |
74559 |                   |                 | criterion for     |                |
74560 |                   |                 | dual              |                |
74561 |                   |                 | infeasability     |                |
74562 +-------------------+-----------------+-------------------+----------------+
74563 | tol_pr            | OT_DOUBLE       | Stopping          | casadi::Scpgen |
74564 |                   |                 | criterion for     |                |
74565 |                   |                 | primal            |                |
74566 |                   |                 | infeasibility     |                |
74567 +-------------------+-----------------+-------------------+----------------+
74568 | tol_pr_step       | OT_DOUBLE       | Stopping          | casadi::Scpgen |
74569 |                   |                 | criterion for the |                |
74570 |                   |                 | step size         |                |
74571 +-------------------+-----------------+-------------------+----------------+
74572 | tol_reg           | OT_DOUBLE       | Stopping          | casadi::Scpgen |
74573 |                   |                 | criterion for     |                |
74574 |                   |                 | regularization    |                |
74575 +-------------------+-----------------+-------------------+----------------+
74576 | verbose_init      | OT_BOOL         | Print out timing  | casadi::Nlpsol |
74577 |                   |                 | information about |                |
74578 |                   |                 | the different     |                |
74579 |                   |                 | stages of         |                |
74580 |                   |                 | initialization    |                |
74581 +-------------------+-----------------+-------------------+----------------+
74582 | warn_initial_boun | OT_BOOL         | Warn if the       | casadi::Nlpsol |
74583 | ds                |                 | initial guess     |                |
74584 |                   |                 | does not satisfy  |                |
74585 |                   |                 | LBX and UBX       |                |
74586 +-------------------+-----------------+-------------------+----------------+
74587 
74588 Diagrams
74589 --------
74590 
74591 
74592 
74593 C++ includes: scpgen.hpp ";
74594 
74595 %feature("docstring")  casadi::Nlpsol::get_n_in()  "
74596 
74597 [INTERNAL]  Number of function inputs and outputs.
74598 
74599 ";
74600 
74601 %feature("docstring")  casadi::FunctionInternal::replace_res(const
74602 std::vector< M > &res, casadi_int npar) const  "
74603 
74604 [INTERNAL]  Replace 0-by-0 outputs.
74605 
74606 ";
74607 
74608 %feature("docstring")
74609 casadi::FunctionInternal::codegen_sparsities(CodeGenerator &g) const  "
74610 
74611 [INTERNAL]  Codegen sparsities.
74612 
74613 ";
74614 
74615 %feature("docstring") casadi::Scpgen::~Scpgen "
74616 
74617 [INTERNAL] ";
74618 
74619 %feature("docstring")
74620 casadi::FunctionInternal::getJacSparsityHierarchicalSymm(casadi_int iind,
74621 casadi_int oind) const  "
74622 
74623 [INTERNAL]  A flavor of getJacSparsity that does hierarchical block
74624 structure recognition for symmetric Jacobians
74625 
74626 ";
74627 
74628 %feature("docstring")
74629 casadi::FunctionInternal::getJacSparsityGen(casadi_int iind, casadi_int
74630 oind, bool symmetric, casadi_int gr_i=1, casadi_int gr_o=1) const  "
74631 
74632 [INTERNAL]  Get the sparsity pattern, forward mode.
74633 
74634 ";
74635 
74636 %feature("docstring")  casadi::OracleFunction::has_function(const
74637 std::string &fname) const  "
74638 
74639 [INTERNAL] ";
74640 
74641 %feature("docstring")  casadi::FunctionInternal::map(casadi_int n, const
74642 std::string &parallelization) const  "
74643 
74644 [INTERNAL]  Generate/retrieve cached serial map.
74645 
74646 ";
74647 
74648 %feature("docstring")  casadi::Scpgen::printIteration(ScpgenMemory *m,
74649 std::ostream &stream) const  "
74650 
74651 [INTERNAL] ";
74652 
74653 %feature("docstring")  casadi::Scpgen::printIteration(ScpgenMemory *m,
74654 std::ostream &stream, casadi_int iter, double obj, double pr_inf, double
74655 du_inf, double rg, casadi_int ls_trials, bool ls_success) const  "
74656 
74657 [INTERNAL] ";
74658 
74659 %feature("docstring")
74660 casadi::FunctionInternal::codegen_init_mem(CodeGenerator &g) const  "
74661 
74662 [INTERNAL]  Codegen decref for init_mem.
74663 
74664 ";
74665 
74666 
74667 // File: classcasadi_1_1SerializerBase.xml
74668 %feature("docstring") casadi::SerializerBase "
74669 
74670 C++ includes: serializer.hpp ";
74671 
74672 
74673 // File: classcasadi_1_1SerializingStream.xml
74674 %feature("docstring")  casadi::SerializingStream::pack(const Sparsity &e) "
74675 
74676 Serializes an object to the output stream.
74677 
74678 ";
74679 
74680 %feature("docstring")  casadi::SerializingStream::pack(const MX &e) "
74681 
74682 Serializes an object to the output stream.
74683 
74684 ";
74685 
74686 %feature("docstring")  casadi::SerializingStream::pack(const SXElem &e) "
74687 
74688 Serializes an object to the output stream.
74689 
74690 ";
74691 
74692 %feature("docstring")  casadi::SerializingStream::pack(const Linsol &e) "
74693 
74694 Serializes an object to the output stream.
74695 
74696 ";
74697 
74698 %feature("docstring")  casadi::SerializingStream::pack(const MatrixCommon
74699 &e) "
74700 
74701 Serializes an object to the output stream.
74702 
74703 ";
74704 
74705 %feature("docstring")  casadi::SerializingStream::pack(const Function &e) "
74706 
74707 Serializes an object to the output stream.
74708 
74709 ";
74710 
74711 %feature("docstring")  casadi::SerializingStream::pack(const Importer &e) "
74712 
74713 Serializes an object to the output stream.
74714 
74715 ";
74716 
74717 %feature("docstring")  casadi::SerializingStream::pack(const Slice &e) "
74718 
74719 Serializes an object to the output stream.
74720 
74721 ";
74722 
74723 %feature("docstring")  casadi::SerializingStream::pack(const GenericType &e)
74724 "
74725 
74726 Serializes an object to the output stream.
74727 
74728 ";
74729 
74730 %feature("docstring")  casadi::SerializingStream::pack(std::istream &s) "
74731 
74732 Serializes an object to the output stream.
74733 
74734 ";
74735 
74736 %feature("docstring")  casadi::SerializingStream::pack(int e) "
74737 
74738 Serializes an object to the output stream.
74739 
74740 ";
74741 
74742 %feature("docstring")  casadi::SerializingStream::pack(bool e) "
74743 
74744 Serializes an object to the output stream.
74745 
74746 ";
74747 
74748 %feature("docstring")  casadi::SerializingStream::pack(casadi_int e) "
74749 
74750 Serializes an object to the output stream.
74751 
74752 ";
74753 
74754 %feature("docstring")  casadi::SerializingStream::pack(size_t e) "
74755 
74756 Serializes an object to the output stream.
74757 
74758 ";
74759 
74760 %feature("docstring")  casadi::SerializingStream::pack(double e) "
74761 
74762 Serializes an object to the output stream.
74763 
74764 ";
74765 
74766 %feature("docstring")  casadi::SerializingStream::pack(const std::string &e)
74767 "
74768 
74769 Serializes an object to the output stream.
74770 
74771 ";
74772 
74773 %feature("docstring")  casadi::SerializingStream::pack(char e) "
74774 
74775 Serializes an object to the output stream.
74776 
74777 ";
74778 
74779 %feature("docstring")  casadi::SerializingStream::pack(const std::vector< T
74780 > &e) "
74781 
74782 Serializes an object to the output stream.
74783 
74784 ";
74785 
74786 %feature("docstring")  casadi::SerializingStream::pack(const std::map< K, V
74787 > &e) "
74788 
74789 Serializes an object to the output stream.
74790 
74791 ";
74792 
74793 %feature("docstring")  casadi::SerializingStream::pack(const std::pair< A, B
74794 > &e) "
74795 
74796 Serializes an object to the output stream.
74797 
74798 ";
74799 
74800 %feature("docstring")  casadi::SerializingStream::pack(const std::string
74801 &descr, const T &e) "
74802 
74803 Serializes an object to the output stream.
74804 
74805 ";
74806 
74807 %feature("docstring")  casadi::SerializingStream::pack(const std::string
74808 &descr, T &e) "
74809 
74810 Serializes an object to the output stream.
74811 
74812 ";
74813 
74814 %feature("docstring") casadi::SerializingStream "
74815 
74816 Helper class for Serialization.
74817 
74818 Joris Gillis
74819 
74820 C++ includes: serializing_stream.hpp ";
74821 
74822 %feature("docstring")
74823 casadi::SerializingStream::SerializingStream(std::ostream &out) "
74824 
74825 Constructor.
74826 
74827 ";
74828 
74829 
74830 // File: classcasadi_1_1SetNonzeros.xml
74831 
74832 
74833 // File: classcasadi_1_1SetNonzerosParam.xml
74834 
74835 
74836 // File: classcasadi_1_1SetNonzerosParamParam.xml
74837 
74838 
74839 // File: classcasadi_1_1SetNonzerosParamSlice.xml
74840 
74841 
74842 // File: classcasadi_1_1SetNonzerosParamVector.xml
74843 
74844 
74845 // File: classcasadi_1_1SetNonzerosSlice.xml
74846 
74847 
74848 // File: classcasadi_1_1SetNonzerosSlice2.xml
74849 
74850 
74851 // File: classcasadi_1_1SetNonzerosSliceParam.xml
74852 
74853 
74854 // File: classcasadi_1_1SetNonzerosVector.xml
74855 
74856 
74857 // File: classcasadi_1_1SharedObject.xml
74858 %feature("docstring")  casadi::SharedObject::class_name() const  "
74859 
74860 Get class name.
74861 
74862 ";
74863 
74864 %feature("docstring")  casadi::SharedObject::is_null() const  "
74865 
74866 Is a null pointer?
74867 
74868 ";
74869 
74870 %feature("docstring")  casadi::SharedObject::print_ptr(std::ostream
74871 &stream=casadi::uout()) const  "
74872 
74873 [INTERNAL]  Print the pointer to the internal class
74874 
74875 ";
74876 
74877 %feature("docstring")  casadi::SharedObject::disp(std::ostream &stream, bool
74878 more=false) const  "
74879 
74880 Print a description of the object.
74881 
74882 ";
74883 
74884 %feature("docstring")  casadi::SharedObject::get_str(bool more=false) const
74885 "
74886 
74887 Get string representation.
74888 
74889 ";
74890 
74891 %feature("docstring") casadi::SharedObject "
74892 
74893 SharedObject implements a reference counting framework similar for efficient
74894 and easily-maintained memory management.
74895 
74896 To use the class, both the SharedObject class (the public class), and the
74897 SharedObjectInternal class (the internal class) must be inherited from. It
74898 can be done in two different files and together with memory management, this
74899 approach provides a clear distinction of which methods of the class are to
74900 be considered \"public\", i.e. methods for public use that can be considered
74901 to remain over time with small changes, and the internal memory.
74902 
74903 When interfacing a software, which typically includes including some header
74904 file, this is best done only in the file where the internal class is
74905 defined, to avoid polluting the global namespace and other side effects.
74906 
74907 The default constructor always means creating a null pointer to an internal
74908 class only. To allocate an internal class (this works only when the internal
74909 class isn't abstract), use the constructor with arguments.
74910 
74911 The copy constructor and the assignment operator perform shallow copies
74912 only, to make a deep copy you must use the clone method explicitly. This
74913 will give a shared pointer instance.
74914 
74915 In an inheritance hierarchy, you can cast down automatically, e.g. (
74916 SXFunction is a child class of Function): SXFunction derived(...); Function
74917 base = derived;
74918 
74919 To cast up, use the shared_cast template function, which works analogously
74920 to dynamic_cast, static_cast, const_cast etc, e.g.: SXFunction derived(...);
74921 Function base = derived; SXFunction derived_from_base =
74922 shared_cast<SXFunction>(base);
74923 
74924 A failed shared_cast will result in a null pointer (cf. dynamic_cast)
74925 
74926 Joel Andersson
74927 
74928 C++ includes: shared_object.hpp ";
74929 
74930 %feature("docstring") casadi::SharedObject::__hash__ "
74931 
74932 Returns a number that is unique for a given Node. If the Object does not
74933 point to any node, \"0\" is returned.
74934 
74935 ";
74936 
74937 
74938 // File: classcasadi_1_1ShellCompiler.xml
74939 %feature("docstring")  casadi::ImporterInternal::read_external(const
74940 std::string &sym, bool inlined, std::istream &file, casadi_int &offset) "
74941 
74942 [INTERNAL]  Get an external function declaration.
74943 
74944 ";
74945 
74946 %feature("docstring")  casadi::SharedObjectInternal::weak() "
74947 
74948 [INTERNAL]  Get a weak reference to the object.
74949 
74950 ";
74951 
74952 %feature("docstring") casadi::ShellCompiler::~ShellCompiler "
74953 
74954 [INTERNAL]  Destructor.
74955 
74956 ";
74957 
74958 %feature("docstring")  casadi::ImporterInternal::finalize() "
74959 
74960 [INTERNAL] ";
74961 
74962 %feature("docstring")
74963 casadi::ImporterInternal::serialize_body(SerializingStream &s) const  "
74964 
74965 [INTERNAL] ";
74966 
74967 %feature("docstring")  casadi::ImporterInternal::disp(std::ostream &stream,
74968 bool more) const  "
74969 
74970 [INTERNAL]  Print.
74971 
74972 ";
74973 
74974 %feature("docstring")
74975 casadi::ImporterInternal::serialize_type(SerializingStream &s) const  "
74976 
74977 [INTERNAL] ";
74978 
74979 %feature("docstring")  casadi::ShellCompiler::plugin_name() const  "
74980 
74981 [INTERNAL]  Get name of plugin.
74982 
74983 ";
74984 
74985 %feature("docstring")  casadi::ImporterInternal::construct(const Dict &opts)
74986 "
74987 
74988 [INTERNAL]  Construct Prepares the function for evaluation.
74989 
74990 ";
74991 
74992 %feature("docstring")  casadi::ImporterInternal::to_text(const std::string
74993 &cmd, casadi_int ind=-1) const  "
74994 
74995 [INTERNAL]  Get entry as a text.
74996 
74997 ";
74998 
74999 %feature("docstring")  casadi::ShellCompiler::get_options() const  "
75000 
75001 [INTERNAL]  Options.
75002 
75003 ";
75004 
75005 %feature("docstring")  casadi::ShellCompiler::get_function(const std::string
75006 &symname)  "
75007 
75008 [INTERNAL]  Get a function pointer for numerical evaluation.
75009 
75010 ";
75011 
75012 %feature("docstring")  casadi::ShellCompiler::init(const Dict &opts)  "
75013 
75014 [INTERNAL]  Initialize.
75015 
75016 ";
75017 
75018 %feature("docstring")  casadi::ImporterInternal::serialize(SerializingStream
75019 &s) const  "
75020 
75021 [INTERNAL] ";
75022 
75023 %feature("docstring")  casadi::SharedObjectInternal::getCount() const  "
75024 
75025 [INTERNAL]  Get the reference count.
75026 
75027 ";
75028 
75029 %feature("docstring")  casadi::ShellCompiler::library() const  "
75030 
75031 [INTERNAL]  Get library name.
75032 
75033 ";
75034 
75035 %feature("docstring")  casadi::ShellCompiler::class_name() const  "
75036 
75037 [INTERNAL]  Get type name.
75038 
75039 ";
75040 
75041 %feature("docstring")  casadi::ImporterInternal::get_meta(const std::string
75042 &cmd, casadi_int ind=-1) const  "
75043 
75044 [INTERNAL]  Get entry as a text.
75045 
75046 ";
75047 
75048 %feature("docstring")  casadi::ImporterInternal::has_function(const
75049 std::string &symname) const  "
75050 
75051 [INTERNAL]  Get a function pointer for numerical evaluation.
75052 
75053 ";
75054 
75055 %feature("docstring")  casadi::ImporterInternal::body(const std::string
75056 &symname) const  "
75057 
75058 [INTERNAL]  Get the function body, if inlined.
75059 
75060 ";
75061 
75062 %feature("docstring")  casadi::ImporterInternal::has_meta(const std::string
75063 &cmd, casadi_int ind=-1) const  "
75064 
75065 [INTERNAL]  Does an entry exist?
75066 
75067 ";
75068 
75069 %feature("docstring") casadi::ShellCompiler "
75070 
75071 'shell' plugin for Importer
75072 
75073 Joel Andersson  Interface to the JIT compiler SHELL
75074 
75075 >List of available options
75076 
75077 +----------------------+-----------------+---------------------------------+
75078 |          Id          |      Type       |           Description           |
75079 +======================+=================+=================================+
75080 | cleanup              | OT_BOOL         | Cleanup temporary files when    |
75081 |                      |                 | unloading. Default: true        |
75082 +----------------------+-----------------+---------------------------------+
75083 | compiler             | OT_STRING       | Compiler command                |
75084 +----------------------+-----------------+---------------------------------+
75085 | compiler_flags       | OT_STRINGVECTOR | Alias for 'compiler_flags'      |
75086 +----------------------+-----------------+---------------------------------+
75087 | compiler_output_flag | OT_STRING       | Compiler flag to denote object  |
75088 |                      |                 | output. Default: '-o '          |
75089 +----------------------+-----------------+---------------------------------+
75090 | compiler_setup       | OT_STRING       | Compiler setup command.         |
75091 |                      |                 | Intended to be fixed. The       |
75092 |                      |                 | 'flag' option is the prefered   |
75093 |                      |                 | way to set custom flags.        |
75094 +----------------------+-----------------+---------------------------------+
75095 | extra_suffixes       | OT_STRINGVECTOR | List of suffixes for extra      |
75096 |                      |                 | files that the compiler may     |
75097 |                      |                 | generate. Default: None         |
75098 +----------------------+-----------------+---------------------------------+
75099 | flags                | OT_STRINGVECTOR | Compile flags for the JIT       |
75100 |                      |                 | compiler. Default: None         |
75101 +----------------------+-----------------+---------------------------------+
75102 | folder               | OT_STRING       | Folder to put temporary objects |
75103 |                      |                 | in.                             |
75104 +----------------------+-----------------+---------------------------------+
75105 | linker               | OT_STRING       | Linker command                  |
75106 +----------------------+-----------------+---------------------------------+
75107 | linker_flags         | OT_STRINGVECTOR | Linker flags for the JIT        |
75108 |                      |                 | compiler. Default: None         |
75109 +----------------------+-----------------+---------------------------------+
75110 | linker_output_flag   | OT_STRING       | Linker flag to denote shared    |
75111 |                      |                 | library output. Default: '-o '  |
75112 +----------------------+-----------------+---------------------------------+
75113 | linker_setup         | OT_STRING       | Linker setup command. Intended  |
75114 |                      |                 | to be fixed. The 'flag' option  |
75115 |                      |                 | is the prefered way to set      |
75116 |                      |                 | custom flags.                   |
75117 +----------------------+-----------------+---------------------------------+
75118 | name                 | OT_STRING       | The file name used to write out |
75119 |                      |                 | compiled objects/libraries. The |
75120 |                      |                 | actual file names used depend   |
75121 |                      |                 | on 'temp_suffix' and include    |
75122 |                      |                 | extensions. Default:            |
75123 |                      |                 | 'tmp_casadi_compiler_shell'     |
75124 +----------------------+-----------------+---------------------------------+
75125 | temp_suffix          | OT_BOOL         | Use a temporary (seemingly      |
75126 |                      |                 | random) filename suffix for     |
75127 |                      |                 | file names. This is desired for |
75128 |                      |                 | thread-safety. This behaviour   |
75129 |                      |                 | may defeat caching compiler     |
75130 |                      |                 | wrappers. Default: true         |
75131 +----------------------+-----------------+---------------------------------+
75132 
75133 >List of available options
75134 
75135 +------------------+-----------------+------------------+------------------+
75136 |        Id        |      Type       |   Description    |     Used in      |
75137 +==================+=================+==================+==================+
75138 | cleanup          | OT_BOOL         | Cleanup          | casadi::ShellCom |
75139 |                  |                 | temporary files  | piler            |
75140 |                  |                 | when unloading.  |                  |
75141 |                  |                 | Default: true    |                  |
75142 +------------------+-----------------+------------------+------------------+
75143 | compiler         | OT_STRING       | Compiler command | casadi::ShellCom |
75144 |                  |                 |                  | piler            |
75145 +------------------+-----------------+------------------+------------------+
75146 | compiler_flags   | OT_STRINGVECTOR | Alias for        | casadi::ShellCom |
75147 |                  |                 | 'compiler_flags' | piler            |
75148 +------------------+-----------------+------------------+------------------+
75149 | compiler_output_ | OT_STRING       | Compiler flag to | casadi::ShellCom |
75150 | flag             |                 | denote object    | piler            |
75151 |                  |                 | output. Default: |                  |
75152 |                  |                 | '-o '            |                  |
75153 +------------------+-----------------+------------------+------------------+
75154 | compiler_setup   | OT_STRING       | Compiler setup   | casadi::ShellCom |
75155 |                  |                 | command.         | piler            |
75156 |                  |                 | Intended to be   |                  |
75157 |                  |                 | fixed. The       |                  |
75158 |                  |                 | 'flag' option is |                  |
75159 |                  |                 | the prefered way |                  |
75160 |                  |                 | to set custom    |                  |
75161 |                  |                 | flags.           |                  |
75162 +------------------+-----------------+------------------+------------------+
75163 | extra_suffixes   | OT_STRINGVECTOR | List of suffixes | casadi::ShellCom |
75164 |                  |                 | for extra files  | piler            |
75165 |                  |                 | that the         |                  |
75166 |                  |                 | compiler may     |                  |
75167 |                  |                 | generate.        |                  |
75168 |                  |                 | Default: None    |                  |
75169 +------------------+-----------------+------------------+------------------+
75170 | flags            | OT_STRINGVECTOR | Compile flags    | casadi::ShellCom |
75171 |                  |                 | for the JIT      | piler            |
75172 |                  |                 | compiler.        |                  |
75173 |                  |                 | Default: None    |                  |
75174 +------------------+-----------------+------------------+------------------+
75175 | folder           | OT_STRING       | Folder to put    | casadi::ShellCom |
75176 |                  |                 | temporary        | piler            |
75177 |                  |                 | objects in.      |                  |
75178 +------------------+-----------------+------------------+------------------+
75179 | linker           | OT_STRING       | Linker command   | casadi::ShellCom |
75180 |                  |                 |                  | piler            |
75181 +------------------+-----------------+------------------+------------------+
75182 | linker_flags     | OT_STRINGVECTOR | Linker flags for | casadi::ShellCom |
75183 |                  |                 | the JIT          | piler            |
75184 |                  |                 | compiler.        |                  |
75185 |                  |                 | Default: None    |                  |
75186 +------------------+-----------------+------------------+------------------+
75187 | linker_output_fl | OT_STRING       | Linker flag to   | casadi::ShellCom |
75188 | ag               |                 | denote shared    | piler            |
75189 |                  |                 | library output.  |                  |
75190 |                  |                 | Default: '-o '   |                  |
75191 +------------------+-----------------+------------------+------------------+
75192 | linker_setup     | OT_STRING       | Linker setup     | casadi::ShellCom |
75193 |                  |                 | command.         | piler            |
75194 |                  |                 | Intended to be   |                  |
75195 |                  |                 | fixed. The       |                  |
75196 |                  |                 | 'flag' option is |                  |
75197 |                  |                 | the prefered way |                  |
75198 |                  |                 | to set custom    |                  |
75199 |                  |                 | flags.           |                  |
75200 +------------------+-----------------+------------------+------------------+
75201 | name             | OT_STRING       | The file name    | casadi::ShellCom |
75202 |                  |                 | used to write    | piler            |
75203 |                  |                 | out compiled obj |                  |
75204 |                  |                 | ects/libraries.  |                  |
75205 |                  |                 | The actual file  |                  |
75206 |                  |                 | names used       |                  |
75207 |                  |                 | depend on        |                  |
75208 |                  |                 | 'temp_suffix'    |                  |
75209 |                  |                 | and include      |                  |
75210 |                  |                 | extensions.      |                  |
75211 |                  |                 | Default: 'tmp_ca |                  |
75212 |                  |                 | sadi_compiler_sh |                  |
75213 |                  |                 | ell'             |                  |
75214 +------------------+-----------------+------------------+------------------+
75215 | temp_suffix      | OT_BOOL         | Use a temporary  | casadi::ShellCom |
75216 |                  |                 | (seemingly       | piler            |
75217 |                  |                 | random) filename |                  |
75218 |                  |                 | suffix for file  |                  |
75219 |                  |                 | names. This is   |                  |
75220 |                  |                 | desired for      |                  |
75221 |                  |                 | thread-safety.   |                  |
75222 |                  |                 | This behaviour   |                  |
75223 |                  |                 | may defeat       |                  |
75224 |                  |                 | caching compiler |                  |
75225 |                  |                 | wrappers.        |                  |
75226 |                  |                 | Default: true    |                  |
75227 +------------------+-----------------+------------------+------------------+
75228 | verbose          | OT_BOOL         | Verbose          | casadi::Importer |
75229 |                  |                 | evaluation  for  | Internal         |
75230 |                  |                 | debugging        |                  |
75231 +------------------+-----------------+------------------+------------------+
75232 
75233 Diagrams
75234 --------
75235 
75236 
75237 
75238 C++ includes: shell_compiler.hpp ";
75239 
75240 %feature("docstring")  casadi::ImporterInternal::read_meta(std::istream
75241 &file, casadi_int &offset) "
75242 
75243 [INTERNAL]  Get meta information.
75244 
75245 ";
75246 
75247 %feature("docstring")  casadi::ImporterInternal::can_have_meta() const  "
75248 
75249 [INTERNAL]  Can meta information be read?
75250 
75251 ";
75252 
75253 %feature("docstring")  casadi::ImporterInternal::inlined(const std::string
75254 &symname) const  "
75255 
75256 [INTERNAL] ";
75257 
75258 %feature("docstring") casadi::ShellCompiler::ShellCompiler(const std::string
75259 &name) "
75260 
75261 [INTERNAL]  Constructor.
75262 
75263 ";
75264 
75265 
75266 // File: classcasadi_1_1Slice.xml
75267 %feature("docstring")  casadi::Slice::is_scalar(casadi_int len) const  "
75268 
75269 Is the slice a scalar.
75270 
75271 ";
75272 
75273 %feature("docstring")  casadi::Slice::serialize(SerializingStream &s) const
75274 "
75275 
75276 Serialize an object.
75277 
75278 ";
75279 
75280 %feature("docstring")  casadi::Slice::disp(std::ostream &stream, bool
75281 more=false) const  "
75282 
75283 Print a description of the object.
75284 
75285 ";
75286 
75287 %feature("docstring")  casadi::Slice::scalar(casadi_int len) const  "
75288 
75289 Get scalar (if is_scalar)
75290 
75291 ";
75292 
75293 %feature("docstring")  casadi::Slice::size() const  "
75294 
75295 Get number of elements.
75296 
75297 ";
75298 
75299 %feature("docstring") casadi::Slice "
75300 
75301 Class representing a Slice.
75302 
75303 Note that Python or Octave do not need to use this class. They can just use
75304 slicing utility from the host language ( M[0:6] in Python, M(1:7) )
75305 
75306 C++ includes: slice.hpp ";
75307 
75308 %feature("docstring")  casadi::Slice::info() const  "
75309 
75310 Obtain information
75311 
75312 ";
75313 
75314 %feature("docstring")  casadi::Slice::all() const  "
75315 
75316 Get a vector of indices.
75317 
75318 ";
75319 
75320 %feature("docstring") casadi::casadi_all "
75321 
75322 Get a vector of indices.
75323 
75324 ";
75325 
75326 %feature("docstring")  casadi::Slice::casadi_all "
75327 
75328 Get a vector of indices.
75329 
75330 ";
75331 
75332 %feature("docstring")  casadi::Slice::all(casadi_int len, bool ind1=false)
75333 const  "
75334 
75335 Get a vector of indices.
75336 
75337 ";
75338 
75339 %feature("docstring") casadi::casadi_all "
75340 
75341 Get a vector of indices.
75342 
75343 ";
75344 
75345 %feature("docstring")  casadi::Slice::casadi_all "
75346 
75347 Get a vector of indices.
75348 
75349 ";
75350 
75351 %feature("docstring")  casadi::Slice::all(const Slice &outer, casadi_int
75352 len) const  "
75353 
75354 Get a vector of indices (nested slice)
75355 
75356 ";
75357 
75358 %feature("docstring") casadi::casadi_all "
75359 
75360 Get a vector of indices (nested slice)
75361 
75362 ";
75363 
75364 %feature("docstring")  casadi::Slice::casadi_all "
75365 
75366 Get a vector of indices (nested slice)
75367 
75368 ";
75369 
75370 %feature("docstring")  casadi::Slice::apply(casadi_int len, bool ind1=false)
75371 const  "
75372 
75373 Apply concrete length.
75374 
75375 ";
75376 
75377 %feature("docstring")  casadi::Slice::is_empty() const  "
75378 
75379 Check if slice is empty.
75380 
75381 ";
75382 
75383 %feature("docstring") casadi::Slice::Slice() "
75384 
75385 Default constructor - all elements.
75386 
75387 ";
75388 
75389 %feature("docstring") casadi::Slice::Slice(casadi_int i, bool ind1=false) "
75390 
75391 A single element (explicit to avoid ambiguity with IM overload.
75392 
75393 ";
75394 
75395 %feature("docstring") casadi::Slice::Slice(casadi_int start, casadi_int
75396 stop, casadi_int step=1) "
75397 
75398 A slice.
75399 
75400 ";
75401 
75402 %feature("docstring")  casadi::Slice::type_name() const  "
75403 
75404 Get name of the class.
75405 
75406 ";
75407 
75408 %feature("docstring")  casadi::Slice::get_str(bool more=false) const  "
75409 
75410 Get string representation.
75411 
75412 ";
75413 
75414 
75415 // File: classcasadi_1_1SlicotDple.xml
75416 %feature("docstring")  casadi::FunctionInternal::instructions_sx() const  "
75417 
75418 [INTERNAL]  get SX expression associated with instructions
75419 
75420 ";
75421 
75422 %feature("docstring")  casadi::Dple::get_name_out(casadi_int i)  "
75423 
75424 [INTERNAL]  Names of function input and outputs.
75425 
75426 ";
75427 
75428 %feature("docstring")  casadi::ProtoFunction::serialize_base_function()
75429 const  "
75430 
75431 [INTERNAL]  String used to identify the immediate FunctionInternal subclass.
75432 
75433 ";
75434 
75435 %feature("docstring")  casadi::FunctionInternal::export_code(const
75436 std::string &lang, std::ostream &stream, const Dict &options) const  "
75437 
75438 [INTERNAL]  Export function in a specific language.
75439 
75440 ";
75441 
75442 %feature("docstring")  casadi::SlicotDple::init(const Dict &opts)  "
75443 
75444 [INTERNAL]  Initialize.
75445 
75446 ";
75447 
75448 %feature("docstring")  casadi::FunctionInternal::size2_in(casadi_int ind)
75449 const  "
75450 
75451 [INTERNAL]  Input/output dimensions.
75452 
75453 ";
75454 
75455 %feature("docstring")
75456 casadi::FunctionInternal::codegen_free_mem(CodeGenerator &g) const  "
75457 
75458 [INTERNAL]  Codegen for free_mem.
75459 
75460 ";
75461 
75462 %feature("docstring")  casadi::FunctionInternal::generate_lifted(Function
75463 &vdef_fcn, Function &vinit_fcn) const  "
75464 
75465 [INTERNAL]  Extract the functions needed for the Lifted Newton method.
75466 
75467 ";
75468 
75469 %feature("docstring")  casadi::FunctionInternal::adjViaJac(casadi_int nadj)
75470 const  "
75471 
75472 [INTERNAL]  Calculate derivatives by multiplying the full Jacobian and
75473 multiplying.
75474 
75475 ";
75476 
75477 %feature("docstring")  casadi::FunctionInternal::eval_dm(const std::vector<
75478 DM > &arg) const  "
75479 
75480 [INTERNAL]  Evaluate with DM matrices.
75481 
75482 ";
75483 
75484 %feature("docstring")  casadi::FunctionInternal::replace_res(const
75485 std::vector< M > &res, casadi_int npar) const  "
75486 
75487 [INTERNAL]  Replace 0-by-0 outputs.
75488 
75489 ";
75490 
75491 %feature("docstring")  casadi::FunctionInternal::nnz_in() const  "
75492 
75493 [INTERNAL]  Number of input/output nonzeros.
75494 
75495 ";
75496 
75497 %feature("docstring")  casadi::FunctionInternal::nnz_in(casadi_int ind)
75498 const  "
75499 
75500 [INTERNAL]  Number of input/output nonzeros.
75501 
75502 ";
75503 
75504 %feature("docstring")  casadi::FunctionInternal::size2_out(casadi_int ind)
75505 const  "
75506 
75507 [INTERNAL]  Input/output dimensions.
75508 
75509 ";
75510 
75511 %feature("docstring")  casadi::FunctionInternal::oracle() const  "
75512 
75513 [INTERNAL]  Get oracle.
75514 
75515 ";
75516 
75517 %feature("docstring")  casadi::FunctionInternal::get_partition(casadi_int
75518 iind, casadi_int oind, Sparsity &D1, Sparsity &D2, bool compact, bool
75519 symmetric, bool allow_forward, bool allow_reverse) const  "
75520 
75521 [INTERNAL]  Get the unidirectional or bidirectional partition.
75522 
75523 ";
75524 
75525 %feature("docstring")  casadi::FunctionInternal::replace_fseed(const
75526 std::vector< std::vector< M >> &fseed, casadi_int npar) const  "
75527 
75528 [INTERNAL]  Replace 0-by-0 forward seeds.
75529 
75530 ";
75531 
75532 %feature("docstring")  casadi::FunctionInternal::replace_fseed(const
75533 std::vector< std::vector< M > > &fseed, casadi_int npar) const  "
75534 
75535 [INTERNAL] ";
75536 
75537 %feature("docstring")  casadi::FunctionInternal::has_jac() const  "
75538 
75539 [INTERNAL]  Return Jacobian of all input elements with respect to all output
75540 elements.
75541 
75542 ";
75543 
75544 %feature("docstring")  casadi::FunctionInternal::codegen(CodeGenerator &g,
75545 const std::string &fname) const  "
75546 
75547 [INTERNAL]  Generate code the function.
75548 
75549 ";
75550 
75551 %feature("docstring")  casadi::FunctionInternal::call_gen(const MXVector
75552 &arg, MXVector &res, casadi_int npar, bool always_inline, bool never_inline)
75553 const  "
75554 
75555 [INTERNAL]   Call a function, overloaded.
75556 
75557 ";
75558 
75559 %feature("docstring")  casadi::FunctionInternal::call_gen(const std::vector<
75560 MatrixCommon > &arg, std::vector< MatrixCommon > &res, casadi_int npar, bool
75561 always_inline, bool never_inline) const  "
75562 
75563 [INTERNAL]   Call a function, overloaded.
75564 
75565 ";
75566 
75567 %feature("docstring")  casadi::FunctionInternal::sp_weight() const  "
75568 
75569 [INTERNAL]  Weighting factor for chosing forward/reverse mode, sparsity
75570 propagation.
75571 
75572 ";
75573 
75574 %feature("docstring")  casadi::SlicotDple::plugin_name() const  "
75575 
75576 [INTERNAL] ";
75577 
75578 %feature("docstring")
75579 casadi::FunctionInternal::print_dimensions(std::ostream &stream) const  "
75580 
75581 [INTERNAL]  Print dimensions of inputs and outputs.
75582 
75583 ";
75584 
75585 %feature("docstring")  casadi::Dple::get_forward(casadi_int nfwd, const
75586 std::string &name, const std::vector< std::string > &inames, const
75587 std::vector< std::string > &onames, const Dict &opts) const  "
75588 
75589 [INTERNAL]  Generate a function that calculates nfwd forward derivatives.
75590 
75591 ";
75592 
75593 %feature("docstring")  casadi::FunctionInternal::generate_options(bool
75594 is_temp=false) const  "
75595 
75596 [INTERNAL]  Reconstruct options dict.
75597 
75598 ";
75599 
75600 %feature("docstring")  casadi::FunctionInternal::eval_mx(const MXVector
75601 &arg, MXVector &res, bool always_inline, bool never_inline) const  "
75602 
75603 [INTERNAL]  Evaluate with symbolic matrices.
75604 
75605 ";
75606 
75607 %feature("docstring")
75608 casadi::FunctionInternal::instruction_output(casadi_int k) const  "
75609 
75610 [INTERNAL]  Get the (integer) output argument of an atomic operation.
75611 
75612 ";
75613 
75614 %feature("docstring")  casadi::FunctionInternal::fwd_seed(casadi_int nfwd)
75615 const  "
75616 
75617 [INTERNAL]  Symbolic expressions for the forward seeds.
75618 
75619 ";
75620 
75621 %feature("docstring")  casadi::Dple::get_n_in()  "
75622 
75623 [INTERNAL]  Number of function inputs and outputs.
75624 
75625 ";
75626 
75627 %feature("docstring")  casadi::FunctionInternal::get_jacobian(const
75628 std::string &name, const std::vector< std::string > &inames, const
75629 std::vector< std::string > &onames, const Dict &opts) const  "
75630 
75631 [INTERNAL]  Return Jacobian of all input elements with respect to all output
75632 elements.
75633 
75634 ";
75635 
75636 %feature("docstring")  casadi::FunctionInternal::mx_in(casadi_int ind) const
75637 "
75638 
75639 [INTERNAL]  Get function input(s) and output(s)
75640 
75641 ";
75642 
75643 %feature("docstring")  casadi::FunctionInternal::mx_in() const  "
75644 
75645 [INTERNAL]  Get function input(s) and output(s)
75646 
75647 ";
75648 
75649 %feature("docstring")  casadi::FunctionInternal::print_option(const
75650 std::string &name, std::ostream &stream) const  "
75651 
75652 [INTERNAL]  Print all information there is to know about a certain option.
75653 
75654 ";
75655 
75656 %feature("docstring")
75657 casadi::FunctionInternal::codegen_incref(CodeGenerator &g) const  "
75658 
75659 [INTERNAL]  Codegen incref for dependencies.
75660 
75661 ";
75662 
75663 %feature("docstring")  casadi::SharedObjectInternal::weak() "
75664 
75665 [INTERNAL]  Get a weak reference to the object.
75666 
75667 ";
75668 
75669 %feature("docstring")  casadi::FunctionInternal::index_out(const std::string
75670 &name) const  "
75671 
75672 [INTERNAL]  Get output scheme index by name.
75673 
75674 ";
75675 
75676 %feature("docstring")  casadi::FunctionInternal::jacobian_sparsity() const
75677 "
75678 
75679 [INTERNAL]  Get Jacobian sparsity.
75680 
75681 ";
75682 
75683 %feature("docstring")  casadi::FunctionInternal::mx_out(casadi_int ind)
75684 const  "
75685 
75686 [INTERNAL]  Get function input(s) and output(s)
75687 
75688 ";
75689 
75690 %feature("docstring")  casadi::FunctionInternal::mx_out() const  "
75691 
75692 [INTERNAL]  Get function input(s) and output(s)
75693 
75694 ";
75695 
75696 %feature("docstring")  casadi::FunctionInternal::convert_res(const
75697 std::vector< M > &res) const  "
75698 
75699 [INTERNAL]  Convert from/to input/output lists/map.
75700 
75701 ";
75702 
75703 %feature("docstring")  casadi::FunctionInternal::convert_res(const std::map<
75704 std::string, M > &res) const  "
75705 
75706 [INTERNAL]  Convert from/to input/output lists/map.
75707 
75708 ";
75709 
75710 %feature("docstring")
75711 casadi::FunctionInternal::serialize_type(SerializingStream &s) const  "
75712 
75713 [INTERNAL]  Serialize type information.
75714 
75715 ";
75716 
75717 %feature("docstring")  casadi::PluginInterface< Dple
75718 >::serialize_type(SerializingStream &s) const "
75719 
75720 [INTERNAL]  Serialize type information.
75721 
75722 ";
75723 
75724 %feature("docstring")  casadi::FunctionInternal::has_jacobian() const  "
75725 
75726 [INTERNAL]  Return Jacobian of all input elements with respect to all output
75727 elements.
75728 
75729 ";
75730 
75731 %feature("docstring")  casadi::FunctionInternal::sparsity_in(casadi_int ind)
75732 const  "
75733 
75734 [INTERNAL]  Input/output sparsity.
75735 
75736 ";
75737 
75738 %feature("docstring")
75739 casadi::FunctionInternal::serialize_body(SerializingStream &s) const  "
75740 
75741 [INTERNAL]  Serialize an object without type information.
75742 
75743 ";
75744 
75745 %feature("docstring")  casadi::ProtoFunction::print_time(const std::map<
75746 std::string, FStats > &fstats) const  "
75747 
75748 [INTERNAL]  Print timing statistics.
75749 
75750 ";
75751 
75752 %feature("docstring")  casadi::FunctionInternal::codegen_mem(CodeGenerator
75753 &g, const std::string &index="mem") const  "
75754 
75755 [INTERNAL]  Get thread-local memory object.
75756 
75757 ";
75758 
75759 %feature("docstring")  casadi::FunctionInternal::mapsum_mx(const
75760 std::vector< MX > &arg, const std::string &parallelization) "
75761 
75762 [INTERNAL]  Parallel evaluation.
75763 
75764 ";
75765 
75766 %feature("docstring")  casadi::SlicotDple::eval(const double **arg, double
75767 **res, casadi_int *iw, double *w, void *mem) const  "
75768 
75769 [INTERNAL]  Evaluate numerically.
75770 
75771 ";
75772 
75773 %feature("docstring")  casadi::Dple::get_n_out()  "
75774 
75775 [INTERNAL]  Number of function inputs and outputs.
75776 
75777 ";
75778 
75779 %feature("docstring")  casadi::FunctionInternal::size_in(casadi_int ind)
75780 const  "
75781 
75782 [INTERNAL]  Input/output dimensions.
75783 
75784 ";
75785 
75786 %feature("docstring")  casadi::FunctionInternal::which_depends(const
75787 std::string &s_in, const std::vector< std::string > &s_out, casadi_int
75788 order, bool tr=false) const  "
75789 
75790 [INTERNAL]  Which variables enter with some order.
75791 
75792 Parameters:
75793 -----------
75794 
75795 s_in:   Input name
75796 
75797 s_out:   Output name(s)
75798 
75799 order:  Only 1 (linear) and 2 (nonlinear) allowed
75800 
75801 tr:  Flip the relationship. Return which expressions contain the variables
75802 
75803 ";
75804 
75805 %feature("docstring")  casadi::FunctionInternal::project_res(const
75806 std::vector< M > &arg, casadi_int npar) const  "
75807 
75808 [INTERNAL]   Project sparsities.
75809 
75810 ";
75811 
75812 %feature("docstring")  casadi::FunctionInternal::generate_out(const
75813 std::string &fname, double **res) const  "
75814 
75815 [INTERNAL] ";
75816 
75817 %feature("docstring") casadi::SlicotDple::SlicotDple() "
75818 
75819 [INTERNAL]  Constructor.
75820 
75821 ";
75822 
75823 %feature("docstring") casadi::SlicotDple::SlicotDple(const std::string
75824 &name, const SpDict &st) "
75825 
75826 [INTERNAL]  Constructor.
75827 
75828 Parameters:
75829 -----------
75830 
75831 st:
75832 
75833 Problem structure.
75834 
75835 ";
75836 
75837 %feature("docstring") casadi::SlicotDple::SlicotDple(const SpDict &st) "
75838 
75839 [INTERNAL] ";
75840 
75841 %feature("docstring")  casadi::FunctionInternal::setup(void *mem, const
75842 double **arg, double **res, casadi_int *iw, double *w) const  "
75843 
75844 [INTERNAL]  Set the (persistent and temporary) work vectors.
75845 
75846 ";
75847 
75848 %feature("docstring")  casadi::FunctionInternal::incache(const std::string
75849 &fname, Function &f, const std::string &suffix="") const  "
75850 
75851 [INTERNAL]  Get function in cache.
75852 
75853 ";
75854 
75855 %feature("docstring")  casadi::ProtoFunction::memory(int ind) const  "
75856 
75857 [INTERNAL]  Memory objects.
75858 
75859 ";
75860 
75861 %feature("docstring")  casadi::FunctionInternal::sz_arg() const  "
75862 
75863 [INTERNAL]  Get required length of arg field.
75864 
75865 ";
75866 
75867 %feature("docstring")  casadi::FunctionInternal::sz_w() const  "
75868 
75869 [INTERNAL]  Get required length of w field.
75870 
75871 ";
75872 
75873 %feature("docstring") casadi::SlicotDple "
75874 
75875 'slicot' plugin for Dple
75876 
75877 An efficient solver for Discrete Periodic Lyapunov Equations using SLICOT
75878 
75879 An efficient solver for Discrete Periodic Lyapunov Equations using SLICOT
75880 
75881 Uses Periodic Schur Decomposition ('psd') and does not assume positive
75882 definiteness. Based on Periodic Lyapunov equations: some applications and
75883 new algorithms. Int. J. Control, vol. 67, pp. 69-87, 1997.
75884 
75885 Overview of the method: J. Gillis Practical Methods for Approximate Robust
75886 Periodic Optimal Control ofNonlinear Mechanical Systems, PhD Thesis,
75887 KULeuven, 2015
75888 
75889 >List of available options
75890 
75891 +-----------------------+-----------+--------------------------------------+
75892 |          Id           |   Type    |             Description              |
75893 +=======================+===========+======================================+
75894 | linear_solver         | OT_STRING | User-defined linear solver class.    |
75895 |                       |           | Needed for sensitivities.            |
75896 +-----------------------+-----------+--------------------------------------+
75897 | linear_solver_options | OT_DICT   | Options to be passed to the linear   |
75898 |                       |           | solver.                              |
75899 +-----------------------+-----------+--------------------------------------+
75900 | psd_num_zero          | OT_DOUBLE | Numerical zero used in Periodic      |
75901 |                       |           | Schur decomposition with slicot.This |
75902 |                       |           | option is needed when your systems   |
75903 |                       |           | has Floquet multiplierszero or close |
75904 |                       |           | to zero                              |
75905 +-----------------------+-----------+--------------------------------------+
75906 
75907 Joris Gillis
75908 
75909 >List of available options
75910 
75911 +--------------------+-----------+--------------------+--------------------+
75912 |         Id         |   Type    |    Description     |      Used in       |
75913 +====================+===========+====================+====================+
75914 | const_dim          | OT_BOOL   | Assume constant    | casadi::Dple       |
75915 |                    |           | dimension of P     |                    |
75916 +--------------------+-----------+--------------------+--------------------+
75917 | eps_unstable       | OT_DOUBLE | A margin for       | casadi::Dple       |
75918 |                    |           | unstability        |                    |
75919 |                    |           | detection          |                    |
75920 +--------------------+-----------+--------------------+--------------------+
75921 | error_unstable     | OT_BOOL   | Throw an exception | casadi::Dple       |
75922 |                    |           | when it is         |                    |
75923 |                    |           | detected that      |                    |
75924 |                    |           | Product(A_i,       |                    |
75925 |                    |           | i=N..1)has         |                    |
75926 |                    |           | eigenvalues        |                    |
75927 |                    |           | greater than       |                    |
75928 |                    |           | 1-eps_unstable     |                    |
75929 +--------------------+-----------+--------------------+--------------------+
75930 | linear_solver      | OT_STRING | User-defined       | casadi::SlicotDple |
75931 |                    |           | linear solver      |                    |
75932 |                    |           | class. Needed for  |                    |
75933 |                    |           | sensitivities.     |                    |
75934 +--------------------+-----------+--------------------+--------------------+
75935 | linear_solver_opti | OT_DICT   | Options to be      | casadi::SlicotDple |
75936 | ons                |           | passed to the      |                    |
75937 |                    |           | linear solver.     |                    |
75938 +--------------------+-----------+--------------------+--------------------+
75939 | pos_def            | OT_BOOL   | Assume P positive  | casadi::Dple       |
75940 |                    |           | definite           |                    |
75941 +--------------------+-----------+--------------------+--------------------+
75942 | psd_num_zero       | OT_DOUBLE | Numerical zero     | casadi::SlicotDple |
75943 |                    |           | used in Periodic   |                    |
75944 |                    |           | Schur              |                    |
75945 |                    |           | decomposition with |                    |
75946 |                    |           | slicot.This option |                    |
75947 |                    |           | is needed when     |                    |
75948 |                    |           | your systems has   |                    |
75949 |                    |           | Floquet            |                    |
75950 |                    |           | multiplierszero or |                    |
75951 |                    |           | close to zero      |                    |
75952 +--------------------+-----------+--------------------+--------------------+
75953 
75954 Diagrams
75955 --------
75956 
75957 
75958 
75959 C++ includes: slicot_dple.hpp ";
75960 
75961 %feature("docstring")  casadi::FunctionInternal::sx_in(casadi_int ind) const
75962 "
75963 
75964 [INTERNAL]  Get function input(s) and output(s)
75965 
75966 ";
75967 
75968 %feature("docstring")  casadi::FunctionInternal::sx_in() const  "
75969 
75970 [INTERNAL]  Get function input(s) and output(s)
75971 
75972 ";
75973 
75974 %feature("docstring")  casadi::FunctionInternal::get_free() const  "
75975 
75976 [INTERNAL]  Print free variables.
75977 
75978 ";
75979 
75980 %feature("docstring")  casadi::FunctionInternal::symbolic_output(const
75981 std::vector< MX > &arg) const  "
75982 
75983 [INTERNAL]  Get a vector of symbolic variables corresponding to the outputs.
75984 
75985 ";
75986 
75987 %feature("docstring")  casadi::ProtoFunction::get_stats(void *mem) const  "
75988 
75989 [INTERNAL]  Get all statistics.
75990 
75991 ";
75992 
75993 %feature("docstring")
75994 casadi::FunctionInternal::getJacSparsityHierarchical(casadi_int iind,
75995 casadi_int oind) const  "
75996 
75997 [INTERNAL]  A flavor of getJacSparsity that does hierarchical block
75998 structure recognition.
75999 
76000 ";
76001 
76002 %feature("docstring")  casadi::FunctionInternal::nz_in(const std::vector< DM
76003 > &arg) const  "
76004 
76005 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
76006 
76007 ";
76008 
76009 %feature("docstring")  casadi::FunctionInternal::nz_in(const std::vector<
76010 double > &arg) const  "
76011 
76012 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
76013 
76014 ";
76015 
76016 %feature("docstring")  casadi::FunctionInternal::size1_in(casadi_int ind)
76017 const  "
76018 
76019 [INTERNAL]  Input/output dimensions.
76020 
76021 ";
76022 
76023 %feature("docstring")  casadi::FunctionInternal::wrap() const  "
76024 
76025 [INTERNAL]  Wrap in an Function instance consisting of only one MX call.
76026 
76027 ";
76028 
76029 %feature("docstring")  casadi::FunctionInternal::has_derivative() const  "
76030 
76031 [INTERNAL]  Can derivatives be calculated in any way?
76032 
76033 ";
76034 
76035 %feature("docstring")
76036 casadi::FunctionInternal::codegen_init_mem(CodeGenerator &g) const  "
76037 
76038 [INTERNAL]  Codegen decref for init_mem.
76039 
76040 ";
76041 
76042 %feature("docstring")  casadi::FunctionInternal::check_res(const
76043 std::vector< M > &res, casadi_int &npar) const  "
76044 
76045 [INTERNAL]  Check if output arguments have correct length and dimensions.
76046 
76047 Raises errors.
76048 
76049 Parameters:
76050 -----------
76051 
76052 npar[in]:  normal usage: 1, disallow pararallel calls: -1
76053 
76054 npar:  max number of horizontal repetitions across all arguments (or -1)
76055 
76056 ";
76057 
76058 %feature("docstring")  casadi::SlicotDple::init_mem(void *mem) const  "
76059 
76060 [INTERNAL]  Initalize memory block.
76061 
76062 ";
76063 
76064 %feature("docstring")  casadi::FunctionInternal::signature(const std::string
76065 &fname) const  "
76066 
76067 [INTERNAL]  Code generate the function.
76068 
76069 ";
76070 
76071 %feature("docstring")  casadi::FunctionInternal::matching_arg(const
76072 std::vector< M > &arg, casadi_int &npar) const  "
76073 
76074 [INTERNAL]  Check if input arguments that needs to be replaced.
76075 
76076 Raises errors
76077 
76078 Parameters:
76079 -----------
76080 
76081 npar[in]:  normal usage: 1, disallow pararallel calls: -1
76082 
76083 npar:  max number of horizontal repetitions across all arguments (or -1)
76084 
76085 ";
76086 
76087 %feature("docstring")  casadi::FunctionInternal::definition() const  "
76088 
76089 [INTERNAL]  Get function signature: name:(inputs)->(outputs)
76090 
76091 ";
76092 
76093 %feature("docstring")  casadi::ProtoFunction::checkout() const  "
76094 
76095 [INTERNAL]  Checkout a memory object.
76096 
76097 ";
76098 
76099 %feature("docstring")  casadi::FunctionInternal::n_instructions() const  "
76100 
76101 [INTERNAL]  Get the number of atomic operations.
76102 
76103 ";
76104 
76105 %feature("docstring")  casadi::FunctionInternal::alloc_res(size_t sz_res,
76106 bool persistent=false) "
76107 
76108 [INTERNAL]  Ensure required length of res field.
76109 
76110 ";
76111 
76112 %feature("docstring")  casadi::FunctionInternal::get_jacobian_sparsity()
76113 const  "
76114 
76115 [INTERNAL]  Get Jacobian sparsity.
76116 
76117 ";
76118 
76119 %feature("docstring")  casadi::FunctionInternal::project_arg(const
76120 std::vector< M > &arg, casadi_int npar) const  "
76121 
76122 [INTERNAL]   Project sparsities.
76123 
76124 ";
76125 
76126 %feature("docstring")  casadi::FunctionInternal::sz_work(size_t &sz_arg,
76127 size_t &sz_res, size_t &sz_iw, size_t &sz_w) const  "
76128 
76129 [INTERNAL]  Get number of temporary variables needed.
76130 
76131 ";
76132 
76133 %feature("docstring")  casadi::FunctionInternal::call(const std::vector< M >
76134 &arg, std::vector< M > &res, bool always_inline, bool never_inline) const  "
76135 
76136 [INTERNAL]   Call a function, templated.
76137 
76138 ";
76139 
76140 %feature("docstring")  casadi::ProtoFunction::serialize(SerializingStream
76141 &s) const  "
76142 
76143 [INTERNAL]  Serialize an object.
76144 
76145 ";
76146 
76147 %feature("docstring")  casadi::FunctionInternal::get_reltol() const  "
76148 
76149 [INTERNAL]  Get relative tolerance.
76150 
76151 ";
76152 
76153 %feature("docstring")  casadi::FunctionInternal::set_temp(void *mem, const
76154 double **arg, double **res, casadi_int *iw, double *w) const  "
76155 
76156 [INTERNAL]  Set the (temporary) work vectors.
76157 
76158 ";
76159 
76160 %feature("docstring")  casadi::FunctionInternal::ad_weight() const  "
76161 
76162 [INTERNAL]  Weighting factor for chosing forward/reverse mode.
76163 
76164 ";
76165 
76166 %feature("docstring")  casadi::FunctionInternal::codegen_body(CodeGenerator
76167 &g) const  "
76168 
76169 [INTERNAL]  Generate code for the function body.
76170 
76171 ";
76172 
76173 %feature("docstring")  casadi::FunctionInternal::eval_sx(const SXElem **arg,
76174 SXElem **res, casadi_int *iw, SXElem *w, void *mem) const  "
76175 
76176 [INTERNAL]  Evaluate with symbolic scalars.
76177 
76178 ";
76179 
76180 %feature("docstring")  casadi::FunctionInternal::alloc(const Function &f,
76181 bool persistent=false) "
76182 
76183 [INTERNAL]  Ensure work vectors long enough to evaluate function.
76184 
76185 ";
76186 
76187 %feature("docstring")  casadi::FunctionInternal::get_min_in(casadi_int ind)
76188 const  "
76189 
76190 [INTERNAL]  Get smallest input value.
76191 
76192 ";
76193 
76194 %feature("docstring")  casadi::FunctionInternal::getJacSparsity(casadi_int
76195 iind, casadi_int oind, bool symmetric) const  "
76196 
76197 [INTERNAL]  Generate the sparsity of a Jacobian block.
76198 
76199 ";
76200 
76201 %feature("docstring")
76202 casadi::FunctionInternal::codegen_alloc_mem(CodeGenerator &g) const  "
76203 
76204 [INTERNAL]  Codegen decref for alloc_mem.
76205 
76206 ";
76207 
76208 %feature("docstring")  casadi::FunctionInternal::replace_aseed(const
76209 std::vector< std::vector< M >> &aseed, casadi_int npar) const  "
76210 
76211 [INTERNAL]  Replace 0-by-0 reverse seeds.
76212 
76213 ";
76214 
76215 %feature("docstring")  casadi::FunctionInternal::replace_aseed(const
76216 std::vector< std::vector< M > > &aseed, casadi_int npar) const  "
76217 
76218 [INTERNAL] ";
76219 
76220 %feature("docstring")  casadi::FunctionInternal::sz_iw() const  "
76221 
76222 [INTERNAL]  Get required length of iw field.
76223 
76224 ";
76225 
76226 %feature("docstring")
76227 casadi::FunctionInternal::instruction_input(casadi_int k) const  "
76228 
76229 [INTERNAL]  Get the (integer) input arguments of an atomic operation.
76230 
76231 ";
76232 
76233 %feature("docstring")
76234 casadi::FunctionInternal::codegen_decref(CodeGenerator &g) const  "
76235 
76236 [INTERNAL]  Codegen decref for dependencies.
76237 
76238 ";
76239 
76240 %feature("docstring")  casadi::FunctionInternal::sparsity_out(casadi_int
76241 ind) const  "
76242 
76243 [INTERNAL]  Input/output sparsity.
76244 
76245 ";
76246 
76247 %feature("docstring")  casadi::FunctionInternal::n_nodes() const  "
76248 
76249 [INTERNAL]  Number of nodes in the algorithm.
76250 
76251 ";
76252 
76253 %feature("docstring") casadi::SlicotDple::~SlicotDple "
76254 
76255 [INTERNAL]  Destructor.
76256 
76257 ";
76258 
76259 %feature("docstring")  casadi::ProtoFunction::print(const char *fmt,...)
76260 const  "
76261 
76262 [INTERNAL]  C-style formatted printing during evaluation.
76263 
76264 ";
76265 
76266 %feature("docstring")  casadi::Dple::get_sparsity_in(casadi_int i)  "
76267 
76268 [INTERNAL]  Sparsities of function inputs and outputs.
76269 
76270 ";
76271 
76272 %feature("docstring")  casadi::ProtoFunction::construct(const Dict &opts) "
76273 
76274 [INTERNAL]  Construct Prepares the function for evaluation.
76275 
76276 ";
76277 
76278 %feature("docstring")  casadi::SlicotDple::class_name() const  "
76279 
76280 [INTERNAL]  Readable name of the internal class.
76281 
76282 ";
76283 
76284 %feature("docstring")  casadi::FunctionInternal::sz_res() const  "
76285 
76286 [INTERNAL]  Get required length of res field.
76287 
76288 ";
76289 
76290 %feature("docstring")  casadi::FunctionInternal::call_reverse(const
76291 std::vector< MX > &arg, const std::vector< MX > &res, const std::vector<
76292 std::vector< MX > > &aseed, std::vector< std::vector< MX > > &asens, bool
76293 always_inline, bool never_inline) const  "
76294 
76295 [INTERNAL]  Reverse mode, virtual functions overloaded in derived classes.
76296 
76297 ";
76298 
76299 %feature("docstring")  casadi::FunctionInternal::call_reverse(const
76300 std::vector< SX > &arg, const std::vector< SX > &res, const std::vector<
76301 std::vector< SX > > &aseed, std::vector< std::vector< SX > > &asens, bool
76302 always_inline, bool never_inline) const  "
76303 
76304 [INTERNAL]  Reverse mode, virtual functions overloaded in derived classes.
76305 
76306 ";
76307 
76308 %feature("docstring")  casadi::FunctionInternal::replace_arg(const
76309 std::vector< M > &arg, casadi_int npar) const  "
76310 
76311 [INTERNAL]  Replace 0-by-0 inputs.
76312 
76313 ";
76314 
76315 %feature("docstring")
76316 casadi::FunctionInternal::instruction_constant(casadi_int k) const  "
76317 
76318 [INTERNAL]  Get the floating point output argument of an atomic operation.
76319 
76320 ";
76321 
76322 %feature("docstring")  casadi::FunctionInternal::matching_res(const
76323 std::vector< M > &arg, casadi_int &npar) const  "
76324 
76325 [INTERNAL]  Check if output arguments that needs to be replaced.
76326 
76327 Raises errors
76328 
76329 Parameters:
76330 -----------
76331 
76332 npar[in]:  normal usage: 1, disallow pararallel calls: -1
76333 
76334 npar:  max number of horizontal repetitions across all arguments (or -1)
76335 
76336 ";
76337 
76338 %feature("docstring")  casadi::Dple::get_name_in(casadi_int i)  "
76339 
76340 [INTERNAL]  Names of function input and outputs.
76341 
76342 ";
76343 
76344 %feature("docstring")  casadi::FunctionInternal::jit_dependencies(const
76345 std::string &fname) "
76346 
76347 [INTERNAL]  Jit dependencies.
76348 
76349 ";
76350 
76351 %feature("docstring")  casadi::FunctionInternal::size1_out(casadi_int ind)
76352 const  "
76353 
76354 [INTERNAL]  Input/output dimensions.
76355 
76356 ";
76357 
76358 %feature("docstring")  casadi::FunctionInternal::dm_out(casadi_int ind)
76359 const  "
76360 
76361 [INTERNAL]  Get function input(s) and output(s)
76362 
76363 ";
76364 
76365 %feature("docstring")  casadi::FunctionInternal::dm_out() const  "
76366 
76367 [INTERNAL]  Get function input(s) and output(s)
76368 
76369 ";
76370 
76371 %feature("docstring")  casadi::FunctionInternal::codegen_name(const
76372 CodeGenerator &g, bool ns=true) const  "
76373 
76374 [INTERNAL]  Get name in codegen.
76375 
76376 ";
76377 
76378 %feature("docstring")  casadi::SlicotDple::get_options() const  "
76379 
76380 [INTERNAL]  Options.
76381 
76382 ";
76383 
76384 %feature("docstring")  casadi::FunctionInternal::nz_out(const std::vector<
76385 DM > &res) const  "
76386 
76387 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
76388 
76389 ";
76390 
76391 %feature("docstring")  casadi::FunctionInternal::nz_out(const std::vector<
76392 double > &res) const  "
76393 
76394 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
76395 
76396 ";
76397 
76398 %feature("docstring")  casadi::FunctionInternal::nnz_out() const  "
76399 
76400 [INTERNAL]  Number of input/output nonzeros.
76401 
76402 ";
76403 
76404 %feature("docstring")  casadi::FunctionInternal::nnz_out(casadi_int ind)
76405 const  "
76406 
76407 [INTERNAL]  Number of input/output nonzeros.
76408 
76409 ";
76410 
76411 %feature("docstring")  casadi::FunctionInternal::jac() const  "
76412 
76413 [INTERNAL]  Return Jacobian of all input elements with respect to all output
76414 elements.
76415 
76416 ";
76417 
76418 %feature("docstring")  casadi::FunctionInternal::sparsity_jac(casadi_int
76419 iind, casadi_int oind, bool compact, bool symmetric) const  "
76420 
76421 [INTERNAL]  Get, if necessary generate, the sparsity of a Jacobian block.
76422 
76423 ";
76424 
76425 %feature("docstring")  casadi::FunctionInternal::call_forward(const
76426 std::vector< MX > &arg, const std::vector< MX > &res, const std::vector<
76427 std::vector< MX > > &fseed, std::vector< std::vector< MX > > &fsens, bool
76428 always_inline, bool never_inline) const  "
76429 
76430 [INTERNAL]  Forward mode AD, virtual functions overloaded in derived
76431 classes.
76432 
76433 ";
76434 
76435 %feature("docstring")  casadi::FunctionInternal::call_forward(const
76436 std::vector< SX > &arg, const std::vector< SX > &res, const std::vector<
76437 std::vector< SX > > &fseed, std::vector< std::vector< SX > > &fsens, bool
76438 always_inline, bool never_inline) const  "
76439 
76440 [INTERNAL]  Forward mode AD, virtual functions overloaded in derived
76441 classes.
76442 
76443 ";
76444 
76445 %feature("docstring")  casadi::Dple::get_sparsity_out(casadi_int i)  "
76446 
76447 [INTERNAL]  Sparsities of function inputs and outputs.
76448 
76449 ";
76450 
76451 %feature("docstring")  casadi::FunctionInternal::has_free() const  "
76452 
76453 [INTERNAL]  Does the function have free variables.
76454 
76455 ";
76456 
76457 %feature("docstring")  casadi::FunctionInternal::size_out(casadi_int ind)
76458 const  "
76459 
76460 [INTERNAL]  Input/output dimensions.
76461 
76462 ";
76463 
76464 %feature("docstring")  casadi::FunctionInternal::codegen_mem_type() const  "
76465 
76466 [INTERNAL]  Thread-local memory object type.
76467 
76468 ";
76469 
76470 %feature("docstring")  casadi::FunctionInternal::has_jacobian_sparsity()
76471 const  "
76472 
76473 [INTERNAL]  Get Jacobian sparsity.
76474 
76475 ";
76476 
76477 %feature("docstring")  casadi::FunctionInternal::get_function() const  "
76478 
76479 [INTERNAL] ";
76480 
76481 %feature("docstring")  casadi::FunctionInternal::get_function(const
76482 std::string &name) const  "
76483 
76484 [INTERNAL] ";
76485 
76486 %feature("docstring")  casadi::FunctionInternal::sx_out(casadi_int ind)
76487 const  "
76488 
76489 [INTERNAL]  Get function input(s) and output(s)
76490 
76491 ";
76492 
76493 %feature("docstring")  casadi::FunctionInternal::sx_out() const  "
76494 
76495 [INTERNAL]  Get function input(s) and output(s)
76496 
76497 ";
76498 
76499 %feature("docstring")  casadi::FunctionInternal::has_codegen() const  "
76500 
76501 [INTERNAL]  Is codegen supported?
76502 
76503 ";
76504 
76505 %feature("docstring")
76506 casadi::FunctionInternal::codegen_sparsities(CodeGenerator &g) const  "
76507 
76508 [INTERNAL]  Codegen sparsities.
76509 
76510 ";
76511 
76512 %feature("docstring")  casadi::FunctionInternal::is_diff_in(casadi_int i) "
76513 
76514 [INTERNAL] ";
76515 
76516 %feature("docstring")  casadi::FunctionInternal::fwdViaJac(casadi_int nfwd)
76517 const  "
76518 
76519 [INTERNAL]  Calculate derivatives by multiplying the full Jacobian and
76520 multiplying.
76521 
76522 ";
76523 
76524 %feature("docstring")  casadi::ProtoFunction::sprint(char *buf, size_t
76525 buf_sz, const char *fmt,...) const  "
76526 
76527 [INTERNAL]  C-style formatted printing to string.
76528 
76529 ";
76530 
76531 %feature("docstring")  casadi::FunctionInternal::disp_more(std::ostream
76532 &stream) const  "
76533 
76534 [INTERNAL]  Print more.
76535 
76536 ";
76537 
76538 %feature("docstring")  casadi::SlicotDple::free_mem(void *mem) const  "
76539 
76540 [INTERNAL]  Free memory block.
76541 
76542 ";
76543 
76544 %feature("docstring")  casadi::FunctionInternal::slice(const std::string
76545 &name, const std::vector< casadi_int > &order_in, const std::vector<
76546 casadi_int > &order_out, const Dict &opts) const  "
76547 
76548 [INTERNAL]  returns a new function with a selection of inputs/outputs of the
76549 original
76550 
76551 ";
76552 
76553 %feature("docstring")  casadi::FunctionInternal::getAdaptorSolverName()
76554 const  "
76555 
76556 [INTERNAL]  Obtain solver name from Adaptor.
76557 
76558 ";
76559 
76560 %feature("docstring")  casadi::FunctionInternal::is_diff_out(casadi_int i) "
76561 
76562 [INTERNAL] ";
76563 
76564 %feature("docstring")  casadi::FunctionInternal::instruction_id(casadi_int
76565 k) const  "
76566 
76567 [INTERNAL]  Get an atomic operation operator index.
76568 
76569 ";
76570 
76571 %feature("docstring")  casadi::ProtoFunction::clear_mem() "
76572 
76573 [INTERNAL]  Clear all memory (called from destructor)
76574 
76575 ";
76576 
76577 %feature("docstring")  casadi::FunctionInternal::get_jac(const std::string
76578 &name, const std::vector< std::string > &inames, const std::vector<
76579 std::string > &onames, const Dict &opts) const  "
76580 
76581 [INTERNAL]  Return Jacobian of all input elements with respect to all output
76582 elements.
76583 
76584 ";
76585 
76586 %feature("docstring")  casadi::FunctionInternal::codegen_meta(CodeGenerator
76587 &g) const  "
76588 
76589 [INTERNAL]  Generate meta-information allowing a user to evaluate a
76590 generated function.
76591 
76592 ";
76593 
76594 %feature("docstring")  casadi::FunctionInternal::wrap_as_needed(const Dict
76595 &opts) const  "
76596 
76597 [INTERNAL]  Wrap in an Function instance consisting of only one MX call.
76598 
76599 ";
76600 
76601 %feature("docstring")  casadi::ProtoFunction::release(int mem) const  "
76602 
76603 [INTERNAL]  Release a memory object.
76604 
76605 ";
76606 
76607 %feature("docstring")  casadi::FunctionInternal::reverse(casadi_int nadj)
76608 const  "
76609 
76610 [INTERNAL]  Return function that calculates adjoint derivatives
76611 reverse(nadj) returns a cached instance if available, and calls  Function
76612 get_reverse(casadi_int nadj) if no cached version is available.
76613 
76614 ";
76615 
76616 %feature("docstring")  casadi::FunctionInternal::generate_in(const
76617 std::string &fname, const double **arg) const  "
76618 
76619 [INTERNAL]  Export an input file that can be passed to generate C code with
76620 a main.
76621 
76622 ";
76623 
76624 %feature("docstring")  casadi::FunctionInternal::alloc_iw(size_t sz_iw, bool
76625 persistent=false) "
76626 
76627 [INTERNAL]  Ensure required length of iw field.
76628 
76629 ";
76630 
76631 %feature("docstring")  casadi::FunctionInternal::get_default_in(casadi_int
76632 ind) const  "
76633 
76634 [INTERNAL]  Get default input value.
76635 
76636 ";
76637 
76638 %feature("docstring")  casadi::FunctionInternal::numel_out(casadi_int ind)
76639 const  "
76640 
76641 [INTERNAL]  Number of input/output elements.
76642 
76643 ";
76644 
76645 %feature("docstring")  casadi::FunctionInternal::numel_out() const  "
76646 
76647 [INTERNAL]  Number of input/output elements.
76648 
76649 ";
76650 
76651 %feature("docstring")  casadi::FunctionInternal::eval_gen(const double
76652 **arg, double **res, casadi_int *iw, double *w, void *mem) const  "
76653 
76654 [INTERNAL]  Evaluate numerically.
76655 
76656 ";
76657 
76658 %feature("docstring")  casadi::FunctionInternal::eval_gen(const SXElem
76659 **arg, SXElem **res, casadi_int *iw, SXElem *w, void *mem) const  "
76660 
76661 [INTERNAL]  Evaluate a function, overloaded.
76662 
76663 ";
76664 
76665 %feature("docstring")  casadi::FunctionInternal::eval_gen(const bvec_t
76666 **arg, bvec_t **res, casadi_int *iw, bvec_t *w, void *mem) const  "
76667 
76668 [INTERNAL]  Evaluate a function, overloaded.
76669 
76670 ";
76671 
76672 %feature("docstring")  casadi::FunctionInternal::generate_dependencies(const
76673 std::string &fname, const Dict &opts) const  "
76674 
76675 [INTERNAL]  Export / Generate C code for the dependency function.
76676 
76677 ";
76678 
76679 %feature("docstring")  casadi::ProtoFunction::format_time(char *buffer,
76680 double time) const  "
76681 
76682 [INTERNAL]  Format time in a fixed width 8 format.
76683 
76684 ";
76685 
76686 %feature("docstring")
76687 casadi::FunctionInternal::codegen_declarations(CodeGenerator &g) const  "
76688 
76689 [INTERNAL]  Generate code for the declarations of the C function.
76690 
76691 ";
76692 
76693 %feature("docstring")  casadi::FunctionInternal::get_abstol() const  "
76694 
76695 [INTERNAL]  Get absolute tolerance.
76696 
76697 ";
76698 
76699 %feature("docstring")  casadi::FunctionInternal::info() const  "
76700 
76701 [INTERNAL]  Obtain information about function
76702 
76703 ";
76704 
76705 %feature("docstring")  casadi::FunctionInternal::finalize()  "
76706 
76707 [INTERNAL]  Finalize the object creation.
76708 
76709 ";
76710 
76711 %feature("docstring")  casadi::FunctionInternal::free_sx() const  "
76712 
76713 [INTERNAL]  Get free variables (SX)
76714 
76715 ";
76716 
76717 %feature("docstring")  casadi::FunctionInternal::forward(casadi_int nfwd)
76718 const  "
76719 
76720 [INTERNAL]  Return function that calculates forward derivatives
76721 forward(nfwd) returns a cached instance if available, and calls  Function
76722 get_forward(casadi_int nfwd) if no cached version is available.
76723 
76724 ";
76725 
76726 %feature("docstring")  casadi::FunctionInternal::symbolicAdjSeed(casadi_int
76727 nadj, const std::vector< MatType > &v) const  "
76728 
76729 [INTERNAL]  Symbolic expressions for the adjoint seeds.
76730 
76731 ";
76732 
76733 %feature("docstring")  casadi::FunctionInternal::is_a(const std::string
76734 &type, bool recursive) const  "
76735 
76736 [INTERNAL]  Check if the function is of a particular type.
76737 
76738 ";
76739 
76740 %feature("docstring")  casadi::FunctionInternal::sp_reverse(bvec_t **arg,
76741 bvec_t **res, casadi_int *iw, bvec_t *w, void *mem) const  "
76742 
76743 [INTERNAL]  Propagate sparsity backwards.
76744 
76745 ";
76746 
76747 %feature("docstring")  casadi::SlicotDple::set_work(void *mem, const double
76748 **&arg, double **&res, casadi_int *&iw, double *&w) const  "
76749 
76750 [INTERNAL]  Set the (persistent) work vectors.
76751 
76752 ";
76753 
76754 %feature("docstring")  casadi::Dple::has_reverse(casadi_int nadj) const  "
76755 
76756 [INTERNAL]  Generate a function that calculates nadj adjoint derivatives.
76757 
76758 ";
76759 
76760 %feature("docstring")
76761 casadi::FunctionInternal::getJacSparsityGen(casadi_int iind, casadi_int
76762 oind, bool symmetric, casadi_int gr_i=1, casadi_int gr_o=1) const  "
76763 
76764 [INTERNAL]  Get the sparsity pattern, forward mode.
76765 
76766 ";
76767 
76768 %feature("docstring")  casadi::FunctionInternal::has_spfwd() const  "
76769 
76770 [INTERNAL]  Is the class able to propagate seeds through the algorithm?
76771 
76772 ";
76773 
76774 %feature("docstring")  casadi::FunctionInternal::check_arg(const
76775 std::vector< M > &arg, casadi_int &npar) const  "
76776 
76777 [INTERNAL]  Check if input arguments have correct length and dimensions.
76778 
76779 Raises errors.
76780 
76781 Parameters:
76782 -----------
76783 
76784 npar[in]:  normal usage: 1, disallow pararallel calls: -1
76785 
76786 npar:  max number of horizontal repetitions across all arguments (or -1)
76787 
76788 ";
76789 
76790 %feature("docstring")  casadi::Dple::has_forward(casadi_int nfwd) const  "
76791 
76792 [INTERNAL]  Generate a function that calculates nfwd forward derivatives.
76793 
76794 ";
76795 
76796 %feature("docstring")  casadi::FunctionInternal::alloc_w(size_t sz_w, bool
76797 persistent=false) "
76798 
76799 [INTERNAL]  Ensure required length of w field.
76800 
76801 ";
76802 
76803 %feature("docstring")  casadi::FunctionInternal::jacobian() const  "
76804 
76805 [INTERNAL]  Return Jacobian of all input elements with respect to all output
76806 elements.
76807 
76808 ";
76809 
76810 %feature("docstring")  casadi::FunctionInternal::map(casadi_int n, const
76811 std::string &parallelization) const  "
76812 
76813 [INTERNAL]  Generate/retrieve cached serial map.
76814 
76815 ";
76816 
76817 %feature("docstring")  casadi::FunctionInternal::all_scalar() const  "
76818 
76819 [INTERNAL]  Are all inputs and outputs scalar.
76820 
76821 ";
76822 
76823 %feature("docstring")  casadi::FunctionInternal::tocache(const Function &f,
76824 const std::string &suffix="") const  "
76825 
76826 [INTERNAL]  Save function to cache.
76827 
76828 ";
76829 
76830 %feature("docstring")  casadi::FunctionInternal::free_mx() const  "
76831 
76832 [INTERNAL]  Get free variables ( MX)
76833 
76834 ";
76835 
76836 %feature("docstring")  casadi::FunctionInternal::uses_output() const  "
76837 
76838 [INTERNAL]  Do the derivative functions need nondifferentiated outputs?
76839 
76840 ";
76841 
76842 %feature("docstring")
76843 casadi::FunctionInternal::getJacSparsityHierarchicalSymm(casadi_int iind,
76844 casadi_int oind) const  "
76845 
76846 [INTERNAL]  A flavor of getJacSparsity that does hierarchical block
76847 structure recognition for symmetric Jacobians
76848 
76849 ";
76850 
76851 %feature("docstring")  casadi::SharedObjectInternal::getCount() const  "
76852 
76853 [INTERNAL]  Get the reference count.
76854 
76855 ";
76856 
76857 %feature("docstring")  casadi::FunctionInternal::has_eval_dm() const  "
76858 
76859 [INTERNAL]  Evaluate with DM matrices.
76860 
76861 ";
76862 
76863 %feature("docstring")  casadi::FunctionInternal::check_mat(const Sparsity
76864 &arg, const Sparsity &inp, casadi_int &npar) "
76865 
76866 [INTERNAL]  Helper function
76867 
76868 Parameters:
76869 -----------
76870 
76871 npar[in]:  normal usage: 1, disallow pararallel calls: -1
76872 
76873 npar[out]:  required number of parallel calls (or -1)
76874 
76875 ";
76876 
76877 %feature("docstring")  casadi::SlicotDple::alloc_mem() const  "
76878 
76879 [INTERNAL]  Create memory block.
76880 
76881 ";
76882 
76883 %feature("docstring")  casadi::FunctionInternal::sp_forward(const bvec_t
76884 **arg, bvec_t **res, casadi_int *iw, bvec_t *w, void *mem) const  "
76885 
76886 [INTERNAL]  Propagate sparsity forward.
76887 
76888 ";
76889 
76890 %feature("docstring")  casadi::FunctionInternal::convert_arg(const
76891 std::vector< M > &arg) const  "
76892 
76893 [INTERNAL]  Convert from/to input/output lists/map.
76894 
76895 ";
76896 
76897 %feature("docstring")  casadi::FunctionInternal::convert_arg(const std::map<
76898 std::string, M > &arg) const  "
76899 
76900 [INTERNAL]  Convert from/to input/output lists/map.
76901 
76902 ";
76903 
76904 %feature("docstring")  casadi::FunctionInternal::print_options(std::ostream
76905 &stream) const  "
76906 
76907 [INTERNAL]  Print list of options.
76908 
76909 ";
76910 
76911 %feature("docstring")  casadi::FunctionInternal::self() const  "
76912 
76913 [INTERNAL]  Get a public class instance.
76914 
76915 ";
76916 
76917 %feature("docstring")  casadi::FunctionInternal::get_max_in(casadi_int ind)
76918 const  "
76919 
76920 [INTERNAL]  Get largest input value.
76921 
76922 ";
76923 
76924 %feature("docstring")  casadi::FunctionInternal::numel_in() const  "
76925 
76926 [INTERNAL]  Number of input/output elements.
76927 
76928 ";
76929 
76930 %feature("docstring")  casadi::FunctionInternal::numel_in(casadi_int ind)
76931 const  "
76932 
76933 [INTERNAL]  Number of input/output elements.
76934 
76935 ";
76936 
76937 %feature("docstring")  casadi::FunctionInternal::disp(std::ostream &stream,
76938 bool more) const  "
76939 
76940 [INTERNAL]  Display object.
76941 
76942 ";
76943 
76944 %feature("docstring")  casadi::FunctionInternal::dm_in(casadi_int ind) const
76945 "
76946 
76947 [INTERNAL]  Get function input(s) and output(s)
76948 
76949 ";
76950 
76951 %feature("docstring")  casadi::FunctionInternal::dm_in() const  "
76952 
76953 [INTERNAL]  Get function input(s) and output(s)
76954 
76955 ";
76956 
76957 %feature("docstring")  casadi::Dple::get_reverse(casadi_int nadj, const
76958 std::string &name, const std::vector< std::string > &inames, const
76959 std::vector< std::string > &onames, const Dict &opts) const  "
76960 
76961 [INTERNAL]  Generate a function that calculates nadj adjoint derivatives.
76962 
76963 ";
76964 
76965 %feature("docstring")  casadi::FunctionInternal::instruction_MX(casadi_int
76966 k) const  "
76967 
76968 [INTERNAL]  get MX expression associated with instruction
76969 
76970 ";
76971 
76972 %feature("docstring")  casadi::FunctionInternal::has_sprev() const  "
76973 
76974 [INTERNAL]  Is the class able to propagate seeds through the algorithm?
76975 
76976 ";
76977 
76978 %feature("docstring")  casadi::FunctionInternal::factory(const std::string
76979 &name, const std::vector< std::string > &s_in, const std::vector<
76980 std::string > &s_out, const Function::AuxOut &aux, const Dict &opts) const
76981 "
76982 
76983 [INTERNAL] ";
76984 
76985 %feature("docstring")  casadi::FunctionInternal::index_in(const std::string
76986 &name) const  "
76987 
76988 [INTERNAL]  Get input scheme index by name.
76989 
76990 ";
76991 
76992 %feature("docstring")  casadi::FunctionInternal::has_function(const
76993 std::string &fname) const  "
76994 
76995 [INTERNAL] ";
76996 
76997 %feature("docstring")
76998 casadi::FunctionInternal::jacobian_sparsity_filter(const Sparsity &sp) const
76999 "
77000 
77001 [INTERNAL]  Filter out nonzeros in the full sparsity jacobian according to
77002 is_diff_in/out.
77003 
77004 ";
77005 
77006 %feature("docstring")  casadi::FunctionInternal::alloc_arg(size_t sz_arg,
77007 bool persistent=false) "
77008 
77009 [INTERNAL]  Ensure required length of arg field.
77010 
77011 ";
77012 
77013 
77014 // File: classcasadi_1_1SlicotExpm.xml
77015 %feature("docstring")  casadi::SlicotExpm::plugin_name() const  "
77016 
77017 [INTERNAL] ";
77018 
77019 %feature("docstring")  casadi::FunctionInternal::get_abstol() const  "
77020 
77021 [INTERNAL]  Get absolute tolerance.
77022 
77023 ";
77024 
77025 %feature("docstring")
77026 casadi::FunctionInternal::instruction_constant(casadi_int k) const  "
77027 
77028 [INTERNAL]  Get the floating point output argument of an atomic operation.
77029 
77030 ";
77031 
77032 %feature("docstring")  casadi::FunctionInternal::get_jacobian_sparsity()
77033 const  "
77034 
77035 [INTERNAL]  Get Jacobian sparsity.
77036 
77037 ";
77038 
77039 %feature("docstring")  casadi::ProtoFunction::memory(int ind) const  "
77040 
77041 [INTERNAL]  Memory objects.
77042 
77043 ";
77044 
77045 %feature("docstring")  casadi::FunctionInternal::get_jac(const std::string
77046 &name, const std::vector< std::string > &inames, const std::vector<
77047 std::string > &onames, const Dict &opts) const  "
77048 
77049 [INTERNAL]  Return Jacobian of all input elements with respect to all output
77050 elements.
77051 
77052 ";
77053 
77054 %feature("docstring")  casadi::FunctionInternal::codegen_mem_type() const  "
77055 
77056 [INTERNAL]  Thread-local memory object type.
77057 
77058 ";
77059 
77060 %feature("docstring")  casadi::FunctionInternal::jacobian_sparsity() const
77061 "
77062 
77063 [INTERNAL]  Get Jacobian sparsity.
77064 
77065 ";
77066 
77067 %feature("docstring")  casadi::FunctionInternal::fwd_seed(casadi_int nfwd)
77068 const  "
77069 
77070 [INTERNAL]  Symbolic expressions for the forward seeds.
77071 
77072 ";
77073 
77074 %feature("docstring")  casadi::FunctionInternal::adjViaJac(casadi_int nadj)
77075 const  "
77076 
77077 [INTERNAL]  Calculate derivatives by multiplying the full Jacobian and
77078 multiplying.
77079 
77080 ";
77081 
77082 %feature("docstring")  casadi::FunctionInternal::getAdaptorSolverName()
77083 const  "
77084 
77085 [INTERNAL]  Obtain solver name from Adaptor.
77086 
77087 ";
77088 
77089 %feature("docstring")
77090 casadi::FunctionInternal::codegen_sparsities(CodeGenerator &g) const  "
77091 
77092 [INTERNAL]  Codegen sparsities.
77093 
77094 ";
77095 
77096 %feature("docstring")  casadi::ProtoFunction::checkout() const  "
77097 
77098 [INTERNAL]  Checkout a memory object.
77099 
77100 ";
77101 
77102 %feature("docstring")  casadi::SharedObjectInternal::weak() "
77103 
77104 [INTERNAL]  Get a weak reference to the object.
77105 
77106 ";
77107 
77108 %feature("docstring")  casadi::ProtoFunction::serialize_base_function()
77109 const  "
77110 
77111 [INTERNAL]  String used to identify the immediate FunctionInternal subclass.
77112 
77113 ";
77114 
77115 %feature("docstring")  casadi::FunctionInternal::numel_out(casadi_int ind)
77116 const  "
77117 
77118 [INTERNAL]  Number of input/output elements.
77119 
77120 ";
77121 
77122 %feature("docstring")  casadi::FunctionInternal::numel_out() const  "
77123 
77124 [INTERNAL]  Number of input/output elements.
77125 
77126 ";
77127 
77128 %feature("docstring")  casadi::FunctionInternal::oracle() const  "
77129 
77130 [INTERNAL]  Get oracle.
77131 
77132 ";
77133 
77134 %feature("docstring")  casadi::FunctionInternal::generate_in(const
77135 std::string &fname, const double **arg) const  "
77136 
77137 [INTERNAL]  Export an input file that can be passed to generate C code with
77138 a main.
77139 
77140 ";
77141 
77142 %feature("docstring")  casadi::Expm::get_n_out()  "
77143 
77144 [INTERNAL]  Number of function inputs and outputs.
77145 
77146 ";
77147 
77148 %feature("docstring")  casadi::FunctionInternal::print_option(const
77149 std::string &name, std::ostream &stream) const  "
77150 
77151 [INTERNAL]  Print all information there is to know about a certain option.
77152 
77153 ";
77154 
77155 %feature("docstring")
77156 casadi::FunctionInternal::codegen_incref(CodeGenerator &g) const  "
77157 
77158 [INTERNAL]  Codegen incref for dependencies.
77159 
77160 ";
77161 
77162 %feature("docstring")  casadi::FunctionInternal::sp_weight() const  "
77163 
77164 [INTERNAL]  Weighting factor for chosing forward/reverse mode, sparsity
77165 propagation.
77166 
77167 ";
77168 
77169 %feature("docstring")
77170 casadi::FunctionInternal::print_dimensions(std::ostream &stream) const  "
77171 
77172 [INTERNAL]  Print dimensions of inputs and outputs.
77173 
77174 ";
77175 
77176 %feature("docstring")  casadi::FunctionInternal::convert_arg(const
77177 std::vector< M > &arg) const  "
77178 
77179 [INTERNAL]  Convert from/to input/output lists/map.
77180 
77181 ";
77182 
77183 %feature("docstring")  casadi::FunctionInternal::convert_arg(const std::map<
77184 std::string, M > &arg) const  "
77185 
77186 [INTERNAL]  Convert from/to input/output lists/map.
77187 
77188 ";
77189 
77190 %feature("docstring")  casadi::FunctionInternal::factory(const std::string
77191 &name, const std::vector< std::string > &s_in, const std::vector<
77192 std::string > &s_out, const Function::AuxOut &aux, const Dict &opts) const
77193 "
77194 
77195 [INTERNAL] ";
77196 
77197 %feature("docstring")  casadi::FunctionInternal::codegen_name(const
77198 CodeGenerator &g, bool ns=true) const  "
77199 
77200 [INTERNAL]  Get name in codegen.
77201 
77202 ";
77203 
77204 %feature("docstring")  casadi::FunctionInternal::has_jac() const  "
77205 
77206 [INTERNAL]  Return Jacobian of all input elements with respect to all output
77207 elements.
77208 
77209 ";
77210 
77211 %feature("docstring")
77212 casadi::FunctionInternal::serialize_type(SerializingStream &s) const  "
77213 
77214 [INTERNAL]  Serialize type information.
77215 
77216 ";
77217 
77218 %feature("docstring")  casadi::PluginInterface< Expm
77219 >::serialize_type(SerializingStream &s) const "
77220 
77221 [INTERNAL]  Serialize type information.
77222 
77223 ";
77224 
77225 %feature("docstring")  casadi::FunctionInternal::get_max_in(casadi_int ind)
77226 const  "
77227 
77228 [INTERNAL]  Get largest input value.
77229 
77230 ";
77231 
77232 %feature("docstring") casadi::SlicotExpm::SlicotExpm() "
77233 
77234 [INTERNAL]  Constructor.
77235 
77236 ";
77237 
77238 %feature("docstring") casadi::SlicotExpm::SlicotExpm(const std::string
77239 &name, const Sparsity &A) "
77240 
77241 [INTERNAL]  Constructor.
77242 
77243 Parameters:
77244 -----------
77245 
77246 st:
77247 
77248 Problem structure.
77249 
77250 ";
77251 
77252 %feature("docstring")  casadi::FunctionInternal::check_arg(const
77253 std::vector< M > &arg, casadi_int &npar) const  "
77254 
77255 [INTERNAL]  Check if input arguments have correct length and dimensions.
77256 
77257 Raises errors.
77258 
77259 Parameters:
77260 -----------
77261 
77262 npar[in]:  normal usage: 1, disallow pararallel calls: -1
77263 
77264 npar:  max number of horizontal repetitions across all arguments (or -1)
77265 
77266 ";
77267 
77268 %feature("docstring")  casadi::Expm::get_reverse(casadi_int nadj, const
77269 std::string &name, const std::vector< std::string > &inames, const
77270 std::vector< std::string > &onames, const Dict &opts) const  "
77271 
77272 [INTERNAL]  Generate a function that calculates nadj adjoint derivatives.
77273 
77274 ";
77275 
77276 %feature("docstring")  casadi::FunctionInternal::sz_arg() const  "
77277 
77278 [INTERNAL]  Get required length of arg field.
77279 
77280 ";
77281 
77282 %feature("docstring")  casadi::FunctionInternal::disp_more(std::ostream
77283 &stream) const  "
77284 
77285 [INTERNAL]  Print more.
77286 
77287 ";
77288 
77289 %feature("docstring")  casadi::FunctionInternal::replace_res(const
77290 std::vector< M > &res, casadi_int npar) const  "
77291 
77292 [INTERNAL]  Replace 0-by-0 outputs.
77293 
77294 ";
77295 
77296 %feature("docstring")  casadi::FunctionInternal::sp_reverse(bvec_t **arg,
77297 bvec_t **res, casadi_int *iw, bvec_t *w, void *mem) const  "
77298 
77299 [INTERNAL]  Propagate sparsity backwards.
77300 
77301 ";
77302 
77303 %feature("docstring")  casadi::Expm::get_options() const  "
77304 
77305 [INTERNAL]  Options.
77306 
77307 ";
77308 
77309 %feature("docstring")  casadi::FunctionInternal::instruction_id(casadi_int
77310 k) const  "
77311 
77312 [INTERNAL]  Get an atomic operation operator index.
77313 
77314 ";
77315 
77316 %feature("docstring")  casadi::FunctionInternal::matching_arg(const
77317 std::vector< M > &arg, casadi_int &npar) const  "
77318 
77319 [INTERNAL]  Check if input arguments that needs to be replaced.
77320 
77321 Raises errors
77322 
77323 Parameters:
77324 -----------
77325 
77326 npar[in]:  normal usage: 1, disallow pararallel calls: -1
77327 
77328 npar:  max number of horizontal repetitions across all arguments (or -1)
77329 
77330 ";
77331 
77332 %feature("docstring")  casadi::SharedObjectInternal::getCount() const  "
77333 
77334 [INTERNAL]  Get the reference count.
77335 
77336 ";
77337 
77338 %feature("docstring")  casadi::ProtoFunction::sprint(char *buf, size_t
77339 buf_sz, const char *fmt,...) const  "
77340 
77341 [INTERNAL]  C-style formatted printing to string.
77342 
77343 ";
77344 
77345 %feature("docstring")  casadi::FunctionInternal::call_gen(const MXVector
77346 &arg, MXVector &res, casadi_int npar, bool always_inline, bool never_inline)
77347 const  "
77348 
77349 [INTERNAL]   Call a function, overloaded.
77350 
77351 ";
77352 
77353 %feature("docstring")  casadi::FunctionInternal::call_gen(const std::vector<
77354 MatrixCommon > &arg, std::vector< MatrixCommon > &res, casadi_int npar, bool
77355 always_inline, bool never_inline) const  "
77356 
77357 [INTERNAL]   Call a function, overloaded.
77358 
77359 ";
77360 
77361 %feature("docstring")  casadi::FunctionInternal::free_sx() const  "
77362 
77363 [INTERNAL]  Get free variables (SX)
77364 
77365 ";
77366 
77367 %feature("docstring")  casadi::FunctionInternal::jac() const  "
77368 
77369 [INTERNAL]  Return Jacobian of all input elements with respect to all output
77370 elements.
77371 
77372 ";
77373 
77374 %feature("docstring")  casadi::FunctionInternal::export_code(const
77375 std::string &lang, std::ostream &stream, const Dict &options) const  "
77376 
77377 [INTERNAL]  Export function in a specific language.
77378 
77379 ";
77380 
77381 %feature("docstring")  casadi::FunctionInternal::has_jacobian_sparsity()
77382 const  "
77383 
77384 [INTERNAL]  Get Jacobian sparsity.
77385 
77386 ";
77387 
77388 %feature("docstring")  casadi::FunctionInternal::call_forward(const
77389 std::vector< MX > &arg, const std::vector< MX > &res, const std::vector<
77390 std::vector< MX > > &fseed, std::vector< std::vector< MX > > &fsens, bool
77391 always_inline, bool never_inline) const  "
77392 
77393 [INTERNAL]  Forward mode AD, virtual functions overloaded in derived
77394 classes.
77395 
77396 ";
77397 
77398 %feature("docstring")  casadi::FunctionInternal::call_forward(const
77399 std::vector< SX > &arg, const std::vector< SX > &res, const std::vector<
77400 std::vector< SX > > &fseed, std::vector< std::vector< SX > > &fsens, bool
77401 always_inline, bool never_inline) const  "
77402 
77403 [INTERNAL]  Forward mode AD, virtual functions overloaded in derived
77404 classes.
77405 
77406 ";
77407 
77408 %feature("docstring")  casadi::FunctionInternal::get_jacobian(const
77409 std::string &name, const std::vector< std::string > &inames, const
77410 std::vector< std::string > &onames, const Dict &opts) const  "
77411 
77412 [INTERNAL]  Return Jacobian of all input elements with respect to all output
77413 elements.
77414 
77415 ";
77416 
77417 %feature("docstring")  casadi::FunctionInternal::symbolic_output(const
77418 std::vector< MX > &arg) const  "
77419 
77420 [INTERNAL]  Get a vector of symbolic variables corresponding to the outputs.
77421 
77422 ";
77423 
77424 %feature("docstring")  casadi::FunctionInternal::nnz_out() const  "
77425 
77426 [INTERNAL]  Number of input/output nonzeros.
77427 
77428 ";
77429 
77430 %feature("docstring")  casadi::FunctionInternal::nnz_out(casadi_int ind)
77431 const  "
77432 
77433 [INTERNAL]  Number of input/output nonzeros.
77434 
77435 ";
77436 
77437 %feature("docstring")
77438 casadi::FunctionInternal::codegen_alloc_mem(CodeGenerator &g) const  "
77439 
77440 [INTERNAL]  Codegen decref for alloc_mem.
77441 
77442 ";
77443 
77444 %feature("docstring")  casadi::FunctionInternal::alloc_res(size_t sz_res,
77445 bool persistent=false) "
77446 
77447 [INTERNAL]  Ensure required length of res field.
77448 
77449 ";
77450 
77451 %feature("docstring")  casadi::Expm::getJacSparsity(casadi_int iind,
77452 casadi_int oind, bool symmetric) const  "
77453 
77454 [INTERNAL]  Generate the sparsity of a Jacobian block.
77455 
77456 ";
77457 
77458 %feature("docstring")  casadi::FunctionInternal::finalize()  "
77459 
77460 [INTERNAL]  Finalize the object creation.
77461 
77462 ";
77463 
77464 %feature("docstring")  casadi::FunctionInternal::nz_in(const std::vector< DM
77465 > &arg) const  "
77466 
77467 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
77468 
77469 ";
77470 
77471 %feature("docstring")  casadi::FunctionInternal::nz_in(const std::vector<
77472 double > &arg) const  "
77473 
77474 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
77475 
77476 ";
77477 
77478 %feature("docstring")
77479 casadi::FunctionInternal::instruction_input(casadi_int k) const  "
77480 
77481 [INTERNAL]  Get the (integer) input arguments of an atomic operation.
77482 
77483 ";
77484 
77485 %feature("docstring")  casadi::FunctionInternal::tocache(const Function &f,
77486 const std::string &suffix="") const  "
77487 
77488 [INTERNAL]  Save function to cache.
77489 
77490 ";
77491 
77492 %feature("docstring") casadi::SlicotExpm "
77493 
77494 [INTERNAL]  'slicot' plugin for Expm
77495 
77496 An efficient solver for Discrete Periodic Lyapunov Equations using SLICOT
77497 
77498 Joris Gillis
77499 
77500 C++ includes: slicot_expm.hpp ";
77501 
77502 %feature("docstring")  casadi::FunctionInternal::size1_in(casadi_int ind)
77503 const  "
77504 
77505 [INTERNAL]  Input/output dimensions.
77506 
77507 ";
77508 
77509 %feature("docstring")  casadi::FunctionInternal::dm_out(casadi_int ind)
77510 const  "
77511 
77512 [INTERNAL]  Get function input(s) and output(s)
77513 
77514 ";
77515 
77516 %feature("docstring")  casadi::FunctionInternal::dm_out() const  "
77517 
77518 [INTERNAL]  Get function input(s) and output(s)
77519 
77520 ";
77521 
77522 %feature("docstring")  casadi::ProtoFunction::format_time(char *buffer,
77523 double time) const  "
77524 
77525 [INTERNAL]  Format time in a fixed width 8 format.
77526 
77527 ";
77528 
77529 %feature("docstring")
77530 casadi::FunctionInternal::codegen_decref(CodeGenerator &g) const  "
77531 
77532 [INTERNAL]  Codegen decref for dependencies.
77533 
77534 ";
77535 
77536 %feature("docstring")  casadi::FunctionInternal::get_free() const  "
77537 
77538 [INTERNAL]  Print free variables.
77539 
77540 ";
77541 
77542 %feature("docstring")  casadi::SlicotExpm::class_name() const  "
77543 
77544 [INTERNAL]  Readable name of the internal class.
77545 
77546 ";
77547 
77548 %feature("docstring")  casadi::FunctionInternal::sz_res() const  "
77549 
77550 [INTERNAL]  Get required length of res field.
77551 
77552 ";
77553 
77554 %feature("docstring")  casadi::SlicotExpm::init_mem(void *mem) const  "
77555 
77556 [INTERNAL]  Initalize memory block.
77557 
77558 ";
77559 
77560 %feature("docstring")  casadi::FunctionInternal::n_nodes() const  "
77561 
77562 [INTERNAL]  Number of nodes in the algorithm.
77563 
77564 ";
77565 
77566 %feature("docstring")  casadi::FunctionInternal::info() const  "
77567 
77568 [INTERNAL]  Obtain information about function
77569 
77570 ";
77571 
77572 %feature("docstring")  casadi::FunctionInternal::is_diff_out(casadi_int i) "
77573 
77574 [INTERNAL] ";
77575 
77576 %feature("docstring")  casadi::FunctionInternal::uses_output() const  "
77577 
77578 [INTERNAL]  Do the derivative functions need nondifferentiated outputs?
77579 
77580 ";
77581 
77582 %feature("docstring")
77583 casadi::FunctionInternal::codegen_init_mem(CodeGenerator &g) const  "
77584 
77585 [INTERNAL]  Codegen decref for init_mem.
77586 
77587 ";
77588 
77589 %feature("docstring")  casadi::SlicotExpm::init(const Dict &opts)  "
77590 
77591 [INTERNAL]  Initialize.
77592 
77593 ";
77594 
77595 %feature("docstring")  casadi::FunctionInternal::has_jacobian() const  "
77596 
77597 [INTERNAL]  Return Jacobian of all input elements with respect to all output
77598 elements.
77599 
77600 ";
77601 
77602 %feature("docstring")  casadi::Expm::get_sparsity_out(casadi_int i)  "
77603 
77604 [INTERNAL]  Sparsities of function inputs and outputs.
77605 
77606 ";
77607 
77608 %feature("docstring")  casadi::FunctionInternal::replace_arg(const
77609 std::vector< M > &arg, casadi_int npar) const  "
77610 
77611 [INTERNAL]  Replace 0-by-0 inputs.
77612 
77613 ";
77614 
77615 %feature("docstring")  casadi::FunctionInternal::eval_gen(const double
77616 **arg, double **res, casadi_int *iw, double *w, void *mem) const  "
77617 
77618 [INTERNAL]  Evaluate numerically.
77619 
77620 ";
77621 
77622 %feature("docstring")  casadi::FunctionInternal::eval_gen(const SXElem
77623 **arg, SXElem **res, casadi_int *iw, SXElem *w, void *mem) const  "
77624 
77625 [INTERNAL]  Evaluate a function, overloaded.
77626 
77627 ";
77628 
77629 %feature("docstring")  casadi::FunctionInternal::eval_gen(const bvec_t
77630 **arg, bvec_t **res, casadi_int *iw, bvec_t *w, void *mem) const  "
77631 
77632 [INTERNAL]  Evaluate a function, overloaded.
77633 
77634 ";
77635 
77636 %feature("docstring")  casadi::FunctionInternal::has_codegen() const  "
77637 
77638 [INTERNAL]  Is codegen supported?
77639 
77640 ";
77641 
77642 %feature("docstring")  casadi::FunctionInternal::forward(casadi_int nfwd)
77643 const  "
77644 
77645 [INTERNAL]  Return function that calculates forward derivatives
77646 forward(nfwd) returns a cached instance if available, and calls  Function
77647 get_forward(casadi_int nfwd) if no cached version is available.
77648 
77649 ";
77650 
77651 %feature("docstring")  casadi::FunctionInternal::generate_options(bool
77652 is_temp=false) const  "
77653 
77654 [INTERNAL]  Reconstruct options dict.
77655 
77656 ";
77657 
77658 %feature("docstring")  casadi::FunctionInternal::sz_w() const  "
77659 
77660 [INTERNAL]  Get required length of w field.
77661 
77662 ";
77663 
77664 %feature("docstring")
77665 casadi::FunctionInternal::getJacSparsityHierarchical(casadi_int iind,
77666 casadi_int oind) const  "
77667 
77668 [INTERNAL]  A flavor of getJacSparsity that does hierarchical block
77669 structure recognition.
77670 
77671 ";
77672 
77673 %feature("docstring") casadi::SlicotExpm::~SlicotExpm "
77674 
77675 [INTERNAL]  Destructor.
77676 
77677 ";
77678 
77679 %feature("docstring")  casadi::FunctionInternal::wrap() const  "
77680 
77681 [INTERNAL]  Wrap in an Function instance consisting of only one MX call.
77682 
77683 ";
77684 
77685 %feature("docstring")  casadi::FunctionInternal::symbolicAdjSeed(casadi_int
77686 nadj, const std::vector< MatType > &v) const  "
77687 
77688 [INTERNAL]  Symbolic expressions for the adjoint seeds.
77689 
77690 ";
77691 
77692 %feature("docstring")  casadi::FunctionInternal::fwdViaJac(casadi_int nfwd)
77693 const  "
77694 
77695 [INTERNAL]  Calculate derivatives by multiplying the full Jacobian and
77696 multiplying.
77697 
77698 ";
77699 
77700 %feature("docstring")  casadi::FunctionInternal::setup(void *mem, const
77701 double **arg, double **res, casadi_int *iw, double *w) const  "
77702 
77703 [INTERNAL]  Set the (persistent and temporary) work vectors.
77704 
77705 ";
77706 
77707 %feature("docstring")  casadi::FunctionInternal::size_out(casadi_int ind)
77708 const  "
77709 
77710 [INTERNAL]  Input/output dimensions.
77711 
77712 ";
77713 
77714 %feature("docstring")  casadi::FunctionInternal::definition() const  "
77715 
77716 [INTERNAL]  Get function signature: name:(inputs)->(outputs)
77717 
77718 ";
77719 
77720 %feature("docstring")  casadi::FunctionInternal::generate_dependencies(const
77721 std::string &fname, const Dict &opts) const  "
77722 
77723 [INTERNAL]  Export / Generate C code for the dependency function.
77724 
77725 ";
77726 
77727 %feature("docstring")  casadi::FunctionInternal::get_name_out(casadi_int i)
77728 "
77729 
77730 [INTERNAL]  Names of function input and outputs.
77731 
77732 ";
77733 
77734 %feature("docstring")  casadi::ProtoFunction::get_stats(void *mem) const  "
77735 
77736 [INTERNAL]  Get all statistics.
77737 
77738 ";
77739 
77740 %feature("docstring")  casadi::FunctionInternal::map(casadi_int n, const
77741 std::string &parallelization) const  "
77742 
77743 [INTERNAL]  Generate/retrieve cached serial map.
77744 
77745 ";
77746 
77747 %feature("docstring")
77748 casadi::FunctionInternal::instruction_output(casadi_int k) const  "
77749 
77750 [INTERNAL]  Get the (integer) output argument of an atomic operation.
77751 
77752 ";
77753 
77754 %feature("docstring")  casadi::FunctionInternal::alloc(const Function &f,
77755 bool persistent=false) "
77756 
77757 [INTERNAL]  Ensure work vectors long enough to evaluate function.
77758 
77759 ";
77760 
77761 %feature("docstring")  casadi::FunctionInternal::check_res(const
77762 std::vector< M > &res, casadi_int &npar) const  "
77763 
77764 [INTERNAL]  Check if output arguments have correct length and dimensions.
77765 
77766 Raises errors.
77767 
77768 Parameters:
77769 -----------
77770 
77771 npar[in]:  normal usage: 1, disallow pararallel calls: -1
77772 
77773 npar:  max number of horizontal repetitions across all arguments (or -1)
77774 
77775 ";
77776 
77777 %feature("docstring")  casadi::FunctionInternal::numel_in() const  "
77778 
77779 [INTERNAL]  Number of input/output elements.
77780 
77781 ";
77782 
77783 %feature("docstring")  casadi::FunctionInternal::numel_in(casadi_int ind)
77784 const  "
77785 
77786 [INTERNAL]  Number of input/output elements.
77787 
77788 ";
77789 
77790 %feature("docstring")
77791 casadi::FunctionInternal::getJacSparsityHierarchicalSymm(casadi_int iind,
77792 casadi_int oind) const  "
77793 
77794 [INTERNAL]  A flavor of getJacSparsity that does hierarchical block
77795 structure recognition for symmetric Jacobians
77796 
77797 ";
77798 
77799 %feature("docstring")  casadi::FunctionInternal::size_in(casadi_int ind)
77800 const  "
77801 
77802 [INTERNAL]  Input/output dimensions.
77803 
77804 ";
77805 
77806 %feature("docstring")  casadi::FunctionInternal::alloc_w(size_t sz_w, bool
77807 persistent=false) "
77808 
77809 [INTERNAL]  Ensure required length of w field.
77810 
77811 ";
77812 
77813 %feature("docstring")  casadi::Expm::get_n_in()  "
77814 
77815 [INTERNAL]  Number of function inputs and outputs.
77816 
77817 ";
77818 
77819 %feature("docstring")  casadi::Expm::has_forward(casadi_int nfwd) const  "
77820 
77821 [INTERNAL]  Generate a function that calculates nfwd forward derivatives.
77822 
77823 ";
77824 
77825 %feature("docstring")  casadi::FunctionInternal::instructions_sx() const  "
77826 
77827 [INTERNAL]  get SX expression associated with instructions
77828 
77829 ";
77830 
77831 %feature("docstring")  casadi::ProtoFunction::release(int mem) const  "
77832 
77833 [INTERNAL]  Release a memory object.
77834 
77835 ";
77836 
77837 %feature("docstring")  casadi::FunctionInternal::eval_mx(const MXVector
77838 &arg, MXVector &res, bool always_inline, bool never_inline) const  "
77839 
77840 [INTERNAL]  Evaluate with symbolic matrices.
77841 
77842 ";
77843 
77844 %feature("docstring")  casadi::FunctionInternal::self() const  "
77845 
77846 [INTERNAL]  Get a public class instance.
77847 
77848 ";
77849 
77850 %feature("docstring")  casadi::SlicotExpm::set_work(void *mem, const double
77851 **&arg, double **&res, casadi_int *&iw, double *&w) const  "
77852 
77853 [INTERNAL]  Set the (persistent) work vectors.
77854 
77855 ";
77856 
77857 %feature("docstring")  casadi::Expm::get_forward(casadi_int nfwd, const
77858 std::string &name, const std::vector< std::string > &inames, const
77859 std::vector< std::string > &onames, const Dict &opts) const  "
77860 
77861 [INTERNAL]  Generate a function that calculates nfwd forward derivatives.
77862 
77863 ";
77864 
77865 %feature("docstring")  casadi::FunctionInternal::jacobian() const  "
77866 
77867 [INTERNAL]  Return Jacobian of all input elements with respect to all output
77868 elements.
77869 
77870 ";
77871 
77872 %feature("docstring")  casadi::FunctionInternal::mx_in(casadi_int ind) const
77873 "
77874 
77875 [INTERNAL]  Get function input(s) and output(s)
77876 
77877 ";
77878 
77879 %feature("docstring")  casadi::FunctionInternal::mx_in() const  "
77880 
77881 [INTERNAL]  Get function input(s) and output(s)
77882 
77883 ";
77884 
77885 %feature("docstring")  casadi::FunctionInternal::codegen_mem(CodeGenerator
77886 &g, const std::string &index="mem") const  "
77887 
77888 [INTERNAL]  Get thread-local memory object.
77889 
77890 ";
77891 
77892 %feature("docstring")  casadi::FunctionInternal::call_reverse(const
77893 std::vector< MX > &arg, const std::vector< MX > &res, const std::vector<
77894 std::vector< MX > > &aseed, std::vector< std::vector< MX > > &asens, bool
77895 always_inline, bool never_inline) const  "
77896 
77897 [INTERNAL]  Reverse mode, virtual functions overloaded in derived classes.
77898 
77899 ";
77900 
77901 %feature("docstring")  casadi::FunctionInternal::call_reverse(const
77902 std::vector< SX > &arg, const std::vector< SX > &res, const std::vector<
77903 std::vector< SX > > &aseed, std::vector< std::vector< SX > > &asens, bool
77904 always_inline, bool never_inline) const  "
77905 
77906 [INTERNAL]  Reverse mode, virtual functions overloaded in derived classes.
77907 
77908 ";
77909 
77910 %feature("docstring")
77911 casadi::FunctionInternal::getJacSparsityGen(casadi_int iind, casadi_int
77912 oind, bool symmetric, casadi_int gr_i=1, casadi_int gr_o=1) const  "
77913 
77914 [INTERNAL]  Get the sparsity pattern, forward mode.
77915 
77916 ";
77917 
77918 %feature("docstring")
77919 casadi::FunctionInternal::serialize_body(SerializingStream &s) const  "
77920 
77921 [INTERNAL]  Serialize an object without type information.
77922 
77923 ";
77924 
77925 %feature("docstring")  casadi::FunctionInternal::alloc_arg(size_t sz_arg,
77926 bool persistent=false) "
77927 
77928 [INTERNAL]  Ensure required length of arg field.
77929 
77930 ";
77931 
77932 %feature("docstring")  casadi::FunctionInternal::ad_weight() const  "
77933 
77934 [INTERNAL]  Weighting factor for chosing forward/reverse mode.
77935 
77936 ";
77937 
77938 %feature("docstring")  casadi::ProtoFunction::print_time(const std::map<
77939 std::string, FStats > &fstats) const  "
77940 
77941 [INTERNAL]  Print timing statistics.
77942 
77943 ";
77944 
77945 %feature("docstring")  casadi::FunctionInternal::sparsity_out(casadi_int
77946 ind) const  "
77947 
77948 [INTERNAL]  Input/output sparsity.
77949 
77950 ";
77951 
77952 %feature("docstring")  casadi::FunctionInternal::dm_in(casadi_int ind) const
77953 "
77954 
77955 [INTERNAL]  Get function input(s) and output(s)
77956 
77957 ";
77958 
77959 %feature("docstring")  casadi::FunctionInternal::dm_in() const  "
77960 
77961 [INTERNAL]  Get function input(s) and output(s)
77962 
77963 ";
77964 
77965 %feature("docstring")  casadi::FunctionInternal::mx_out(casadi_int ind)
77966 const  "
77967 
77968 [INTERNAL]  Get function input(s) and output(s)
77969 
77970 ";
77971 
77972 %feature("docstring")  casadi::FunctionInternal::mx_out() const  "
77973 
77974 [INTERNAL]  Get function input(s) and output(s)
77975 
77976 ";
77977 
77978 %feature("docstring")  casadi::FunctionInternal::sx_in(casadi_int ind) const
77979 "
77980 
77981 [INTERNAL]  Get function input(s) and output(s)
77982 
77983 ";
77984 
77985 %feature("docstring")  casadi::FunctionInternal::sx_in() const  "
77986 
77987 [INTERNAL]  Get function input(s) and output(s)
77988 
77989 ";
77990 
77991 %feature("docstring")  casadi::FunctionInternal::eval_dm(const std::vector<
77992 DM > &arg) const  "
77993 
77994 [INTERNAL]  Evaluate with DM matrices.
77995 
77996 ";
77997 
77998 %feature("docstring")  casadi::FunctionInternal::has_eval_dm() const  "
77999 
78000 [INTERNAL]  Evaluate with DM matrices.
78001 
78002 ";
78003 
78004 %feature("docstring")  casadi::FunctionInternal::has_spfwd() const  "
78005 
78006 [INTERNAL]  Is the class able to propagate seeds through the algorithm?
78007 
78008 ";
78009 
78010 %feature("docstring")  casadi::ProtoFunction::print(const char *fmt,...)
78011 const  "
78012 
78013 [INTERNAL]  C-style formatted printing during evaluation.
78014 
78015 ";
78016 
78017 %feature("docstring")  casadi::FunctionInternal::free_mx() const  "
78018 
78019 [INTERNAL]  Get free variables ( MX)
78020 
78021 ";
78022 
78023 %feature("docstring")  casadi::FunctionInternal::slice(const std::string
78024 &name, const std::vector< casadi_int > &order_in, const std::vector<
78025 casadi_int > &order_out, const Dict &opts) const  "
78026 
78027 [INTERNAL]  returns a new function with a selection of inputs/outputs of the
78028 original
78029 
78030 ";
78031 
78032 %feature("docstring")  casadi::FunctionInternal::project_arg(const
78033 std::vector< M > &arg, casadi_int npar) const  "
78034 
78035 [INTERNAL]   Project sparsities.
78036 
78037 ";
78038 
78039 %feature("docstring")  casadi::FunctionInternal::all_scalar() const  "
78040 
78041 [INTERNAL]  Are all inputs and outputs scalar.
78042 
78043 ";
78044 
78045 %feature("docstring")  casadi::FunctionInternal::get_default_in(casadi_int
78046 ind) const  "
78047 
78048 [INTERNAL]  Get default input value.
78049 
78050 ";
78051 
78052 %feature("docstring")  casadi::FunctionInternal::sparsity_in(casadi_int ind)
78053 const  "
78054 
78055 [INTERNAL]  Input/output sparsity.
78056 
78057 ";
78058 
78059 %feature("docstring")  casadi::FunctionInternal::incache(const std::string
78060 &fname, Function &f, const std::string &suffix="") const  "
78061 
78062 [INTERNAL]  Get function in cache.
78063 
78064 ";
78065 
78066 %feature("docstring")  casadi::FunctionInternal::alloc_iw(size_t sz_iw, bool
78067 persistent=false) "
78068 
78069 [INTERNAL]  Ensure required length of iw field.
78070 
78071 ";
78072 
78073 %feature("docstring")  casadi::FunctionInternal::replace_fseed(const
78074 std::vector< std::vector< M >> &fseed, casadi_int npar) const  "
78075 
78076 [INTERNAL]  Replace 0-by-0 forward seeds.
78077 
78078 ";
78079 
78080 %feature("docstring")  casadi::FunctionInternal::replace_fseed(const
78081 std::vector< std::vector< M > > &fseed, casadi_int npar) const  "
78082 
78083 [INTERNAL] ";
78084 
78085 %feature("docstring")  casadi::FunctionInternal::generate_lifted(Function
78086 &vdef_fcn, Function &vinit_fcn) const  "
78087 
78088 [INTERNAL]  Extract the functions needed for the Lifted Newton method.
78089 
78090 ";
78091 
78092 %feature("docstring")  casadi::FunctionInternal::replace_aseed(const
78093 std::vector< std::vector< M >> &aseed, casadi_int npar) const  "
78094 
78095 [INTERNAL]  Replace 0-by-0 reverse seeds.
78096 
78097 ";
78098 
78099 %feature("docstring")  casadi::FunctionInternal::replace_aseed(const
78100 std::vector< std::vector< M > > &aseed, casadi_int npar) const  "
78101 
78102 [INTERNAL] ";
78103 
78104 %feature("docstring")  casadi::FunctionInternal::mapsum_mx(const
78105 std::vector< MX > &arg, const std::string &parallelization) "
78106 
78107 [INTERNAL]  Parallel evaluation.
78108 
78109 ";
78110 
78111 %feature("docstring")  casadi::FunctionInternal::eval_sx(const SXElem **arg,
78112 SXElem **res, casadi_int *iw, SXElem *w, void *mem) const  "
78113 
78114 [INTERNAL]  Evaluate with symbolic scalars.
78115 
78116 ";
78117 
78118 %feature("docstring")  casadi::FunctionInternal::sz_work(size_t &sz_arg,
78119 size_t &sz_res, size_t &sz_iw, size_t &sz_w) const  "
78120 
78121 [INTERNAL]  Get number of temporary variables needed.
78122 
78123 ";
78124 
78125 %feature("docstring")  casadi::FunctionInternal::has_sprev() const  "
78126 
78127 [INTERNAL]  Is the class able to propagate seeds through the algorithm?
78128 
78129 ";
78130 
78131 %feature("docstring")  casadi::FunctionInternal::is_a(const std::string
78132 &type, bool recursive) const  "
78133 
78134 [INTERNAL]  Check if the function is of a particular type.
78135 
78136 ";
78137 
78138 %feature("docstring")  casadi::FunctionInternal::has_function(const
78139 std::string &fname) const  "
78140 
78141 [INTERNAL] ";
78142 
78143 %feature("docstring")  casadi::FunctionInternal::index_in(const std::string
78144 &name) const  "
78145 
78146 [INTERNAL]  Get input scheme index by name.
78147 
78148 ";
78149 
78150 %feature("docstring")  casadi::Expm::get_sparsity_in(casadi_int i)  "
78151 
78152 [INTERNAL]  Sparsities of function inputs and outputs.
78153 
78154 ";
78155 
78156 %feature("docstring")  casadi::SlicotExpm::free_mem(void *mem) const  "
78157 
78158 [INTERNAL]  Free memory block.
78159 
78160 ";
78161 
78162 %feature("docstring")  casadi::FunctionInternal::nz_out(const std::vector<
78163 DM > &res) const  "
78164 
78165 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
78166 
78167 ";
78168 
78169 %feature("docstring")  casadi::FunctionInternal::nz_out(const std::vector<
78170 double > &res) const  "
78171 
78172 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
78173 
78174 ";
78175 
78176 %feature("docstring")  casadi::SlicotExpm::alloc_mem() const  "
78177 
78178 [INTERNAL]  Create memory block.
78179 
78180 ";
78181 
78182 %feature("docstring")  casadi::FunctionInternal::get_min_in(casadi_int ind)
78183 const  "
78184 
78185 [INTERNAL]  Get smallest input value.
78186 
78187 ";
78188 
78189 %feature("docstring")  casadi::Expm::has_reverse(casadi_int nadj) const  "
78190 
78191 [INTERNAL]  Generate a function that calculates nadj adjoint derivatives.
78192 
78193 ";
78194 
78195 %feature("docstring")  casadi::FunctionInternal::codegen_meta(CodeGenerator
78196 &g) const  "
78197 
78198 [INTERNAL]  Generate meta-information allowing a user to evaluate a
78199 generated function.
78200 
78201 ";
78202 
78203 %feature("docstring")  casadi::FunctionInternal::get_reltol() const  "
78204 
78205 [INTERNAL]  Get relative tolerance.
78206 
78207 ";
78208 
78209 %feature("docstring")  casadi::FunctionInternal::index_out(const std::string
78210 &name) const  "
78211 
78212 [INTERNAL]  Get output scheme index by name.
78213 
78214 ";
78215 
78216 %feature("docstring")  casadi::FunctionInternal::get_function() const  "
78217 
78218 [INTERNAL] ";
78219 
78220 %feature("docstring")  casadi::FunctionInternal::get_function(const
78221 std::string &name) const  "
78222 
78223 [INTERNAL] ";
78224 
78225 %feature("docstring")  casadi::FunctionInternal::size2_out(casadi_int ind)
78226 const  "
78227 
78228 [INTERNAL]  Input/output dimensions.
78229 
78230 ";
78231 
78232 %feature("docstring")  casadi::ProtoFunction::construct(const Dict &opts) "
78233 
78234 [INTERNAL]  Construct Prepares the function for evaluation.
78235 
78236 ";
78237 
78238 %feature("docstring")  casadi::FunctionInternal::sx_out(casadi_int ind)
78239 const  "
78240 
78241 [INTERNAL]  Get function input(s) and output(s)
78242 
78243 ";
78244 
78245 %feature("docstring")  casadi::FunctionInternal::sx_out() const  "
78246 
78247 [INTERNAL]  Get function input(s) and output(s)
78248 
78249 ";
78250 
78251 %feature("docstring")  casadi::FunctionInternal::disp(std::ostream &stream,
78252 bool more) const  "
78253 
78254 [INTERNAL]  Display object.
78255 
78256 ";
78257 
78258 %feature("docstring")  casadi::FunctionInternal::size2_in(casadi_int ind)
78259 const  "
78260 
78261 [INTERNAL]  Input/output dimensions.
78262 
78263 ";
78264 
78265 %feature("docstring")
78266 casadi::FunctionInternal::codegen_free_mem(CodeGenerator &g) const  "
78267 
78268 [INTERNAL]  Codegen for free_mem.
78269 
78270 ";
78271 
78272 %feature("docstring")  casadi::FunctionInternal::signature(const std::string
78273 &fname) const  "
78274 
78275 [INTERNAL]  Code generate the function.
78276 
78277 ";
78278 
78279 %feature("docstring")  casadi::FunctionInternal::sz_iw() const  "
78280 
78281 [INTERNAL]  Get required length of iw field.
78282 
78283 ";
78284 
78285 %feature("docstring")  casadi::FunctionInternal::convert_res(const
78286 std::vector< M > &res) const  "
78287 
78288 [INTERNAL]  Convert from/to input/output lists/map.
78289 
78290 ";
78291 
78292 %feature("docstring")  casadi::FunctionInternal::convert_res(const std::map<
78293 std::string, M > &res) const  "
78294 
78295 [INTERNAL]  Convert from/to input/output lists/map.
78296 
78297 ";
78298 
78299 %feature("docstring")  casadi::ProtoFunction::clear_mem() "
78300 
78301 [INTERNAL]  Clear all memory (called from destructor)
78302 
78303 ";
78304 
78305 %feature("docstring")  casadi::FunctionInternal::check_mat(const Sparsity
78306 &arg, const Sparsity &inp, casadi_int &npar) "
78307 
78308 [INTERNAL]  Helper function
78309 
78310 Parameters:
78311 -----------
78312 
78313 npar[in]:  normal usage: 1, disallow pararallel calls: -1
78314 
78315 npar[out]:  required number of parallel calls (or -1)
78316 
78317 ";
78318 
78319 %feature("docstring")  casadi::FunctionInternal::jit_dependencies(const
78320 std::string &fname) "
78321 
78322 [INTERNAL]  Jit dependencies.
78323 
78324 ";
78325 
78326 %feature("docstring")  casadi::FunctionInternal::size1_out(casadi_int ind)
78327 const  "
78328 
78329 [INTERNAL]  Input/output dimensions.
78330 
78331 ";
78332 
78333 %feature("docstring")  casadi::FunctionInternal::reverse(casadi_int nadj)
78334 const  "
78335 
78336 [INTERNAL]  Return function that calculates adjoint derivatives
78337 reverse(nadj) returns a cached instance if available, and calls  Function
78338 get_reverse(casadi_int nadj) if no cached version is available.
78339 
78340 ";
78341 
78342 %feature("docstring")  casadi::FunctionInternal::instruction_MX(casadi_int
78343 k) const  "
78344 
78345 [INTERNAL]  get MX expression associated with instruction
78346 
78347 ";
78348 
78349 %feature("docstring")  casadi::FunctionInternal::project_res(const
78350 std::vector< M > &arg, casadi_int npar) const  "
78351 
78352 [INTERNAL]   Project sparsities.
78353 
78354 ";
78355 
78356 %feature("docstring")  casadi::FunctionInternal::sparsity_jac(casadi_int
78357 iind, casadi_int oind, bool compact, bool symmetric) const  "
78358 
78359 [INTERNAL]  Get, if necessary generate, the sparsity of a Jacobian block.
78360 
78361 ";
78362 
78363 %feature("docstring")  casadi::FunctionInternal::has_free() const  "
78364 
78365 [INTERNAL]  Does the function have free variables.
78366 
78367 ";
78368 
78369 %feature("docstring")  casadi::FunctionInternal::matching_res(const
78370 std::vector< M > &arg, casadi_int &npar) const  "
78371 
78372 [INTERNAL]  Check if output arguments that needs to be replaced.
78373 
78374 Raises errors
78375 
78376 Parameters:
78377 -----------
78378 
78379 npar[in]:  normal usage: 1, disallow pararallel calls: -1
78380 
78381 npar:  max number of horizontal repetitions across all arguments (or -1)
78382 
78383 ";
78384 
78385 %feature("docstring")  casadi::FunctionInternal::get_partition(casadi_int
78386 iind, casadi_int oind, Sparsity &D1, Sparsity &D2, bool compact, bool
78387 symmetric, bool allow_forward, bool allow_reverse) const  "
78388 
78389 [INTERNAL]  Get the unidirectional or bidirectional partition.
78390 
78391 ";
78392 
78393 %feature("docstring")  casadi::FunctionInternal::is_diff_in(casadi_int i) "
78394 
78395 [INTERNAL] ";
78396 
78397 %feature("docstring")  casadi::FunctionInternal::codegen(CodeGenerator &g,
78398 const std::string &fname) const  "
78399 
78400 [INTERNAL]  Generate code the function.
78401 
78402 ";
78403 
78404 %feature("docstring")  casadi::FunctionInternal::generate_out(const
78405 std::string &fname, double **res) const  "
78406 
78407 [INTERNAL] ";
78408 
78409 %feature("docstring")  casadi::FunctionInternal::wrap_as_needed(const Dict
78410 &opts) const  "
78411 
78412 [INTERNAL]  Wrap in an Function instance consisting of only one MX call.
78413 
78414 ";
78415 
78416 %feature("docstring")  casadi::ProtoFunction::serialize(SerializingStream
78417 &s) const  "
78418 
78419 [INTERNAL]  Serialize an object.
78420 
78421 ";
78422 
78423 %feature("docstring")  casadi::FunctionInternal::has_derivative() const  "
78424 
78425 [INTERNAL]  Can derivatives be calculated in any way?
78426 
78427 ";
78428 
78429 %feature("docstring")
78430 casadi::FunctionInternal::jacobian_sparsity_filter(const Sparsity &sp) const
78431 "
78432 
78433 [INTERNAL]  Filter out nonzeros in the full sparsity jacobian according to
78434 is_diff_in/out.
78435 
78436 ";
78437 
78438 %feature("docstring")
78439 casadi::FunctionInternal::codegen_declarations(CodeGenerator &g) const  "
78440 
78441 [INTERNAL]  Generate code for the declarations of the C function.
78442 
78443 ";
78444 
78445 %feature("docstring")  casadi::FunctionInternal::sp_forward(const bvec_t
78446 **arg, bvec_t **res, casadi_int *iw, bvec_t *w, void *mem) const  "
78447 
78448 [INTERNAL]  Propagate sparsity forward.
78449 
78450 ";
78451 
78452 %feature("docstring")  casadi::FunctionInternal::codegen_body(CodeGenerator
78453 &g) const  "
78454 
78455 [INTERNAL]  Generate code for the function body.
78456 
78457 ";
78458 
78459 %feature("docstring")  casadi::FunctionInternal::nnz_in() const  "
78460 
78461 [INTERNAL]  Number of input/output nonzeros.
78462 
78463 ";
78464 
78465 %feature("docstring")  casadi::FunctionInternal::nnz_in(casadi_int ind)
78466 const  "
78467 
78468 [INTERNAL]  Number of input/output nonzeros.
78469 
78470 ";
78471 
78472 %feature("docstring")  casadi::FunctionInternal::which_depends(const
78473 std::string &s_in, const std::vector< std::string > &s_out, casadi_int
78474 order, bool tr=false) const  "
78475 
78476 [INTERNAL]  Which variables enter with some order.
78477 
78478 Parameters:
78479 -----------
78480 
78481 s_in:   Input name
78482 
78483 s_out:   Output name(s)
78484 
78485 order:  Only 1 (linear) and 2 (nonlinear) allowed
78486 
78487 tr:  Flip the relationship. Return which expressions contain the variables
78488 
78489 ";
78490 
78491 %feature("docstring")  casadi::FunctionInternal::set_temp(void *mem, const
78492 double **arg, double **res, casadi_int *iw, double *w) const  "
78493 
78494 [INTERNAL]  Set the (temporary) work vectors.
78495 
78496 ";
78497 
78498 %feature("docstring")  casadi::FunctionInternal::print_options(std::ostream
78499 &stream) const  "
78500 
78501 [INTERNAL]  Print list of options.
78502 
78503 ";
78504 
78505 %feature("docstring")  casadi::FunctionInternal::call(const std::vector< M >
78506 &arg, std::vector< M > &res, bool always_inline, bool never_inline) const  "
78507 
78508 [INTERNAL]   Call a function, templated.
78509 
78510 ";
78511 
78512 %feature("docstring")  casadi::FunctionInternal::get_name_in(casadi_int i) "
78513 
78514 [INTERNAL]  Names of function input and outputs.
78515 
78516 ";
78517 
78518 %feature("docstring")  casadi::FunctionInternal::n_instructions() const  "
78519 
78520 [INTERNAL]  Get the number of atomic operations.
78521 
78522 ";
78523 
78524 %feature("docstring")  casadi::SlicotExpm::eval(const double **arg, double
78525 **res, casadi_int *iw, double *w, void *mem) const  "
78526 
78527 [INTERNAL]  Evaluate numerically.
78528 
78529 ";
78530 
78531 
78532 // File: classcasadi_1_1Smoothing.xml
78533 %feature("docstring") casadi::Smoothing "
78534 
78535 [INTERNAL]  Calculate derivative using 3th order smoothing scheme Joel
78536 Andersson
78537 
78538 >List of available options
78539 
78540 +------------------+-----------------+------------------+------------------+
78541 |        Id        |      Type       |   Description    |     Used in      |
78542 +==================+=================+==================+==================+
78543 | abstol           | OT_DOUBLE       | Accuracy of      | casadi::Smoothin |
78544 |                  |                 | function outputs | g                |
78545 |                  |                 | [default: query  |                  |
78546 |                  |                 | object]          |                  |
78547 +------------------+-----------------+------------------+------------------+
78548 | ad_weight        | OT_DOUBLE       | Weighting factor | casadi::Function |
78549 |                  |                 | for derivative   | Internal         |
78550 |                  |                 | calculation.When |                  |
78551 |                  |                 | there is an      |                  |
78552 |                  |                 | option of either |                  |
78553 |                  |                 | using forward or |                  |
78554 |                  |                 | reverse mode     |                  |
78555 |                  |                 | directional      |                  |
78556 |                  |                 | derivatives, the |                  |
78557 |                  |                 | condition ad_wei |                  |
78558 |                  |                 | ght*nf<=(1-ad_we |                  |
78559 |                  |                 | ight)*na is used |                  |
78560 |                  |                 | where nf and na  |                  |
78561 |                  |                 | are estimates of |                  |
78562 |                  |                 | the number of    |                  |
78563 |                  |                 | forward/reverse  |                  |
78564 |                  |                 | mode directional |                  |
78565 |                  |                 | derivatives      |                  |
78566 |                  |                 | needed. By       |                  |
78567 |                  |                 | default,         |                  |
78568 |                  |                 | ad_weight is     |                  |
78569 |                  |                 | calculated       |                  |
78570 |                  |                 | automatically,   |                  |
78571 |                  |                 | but this can be  |                  |
78572 |                  |                 | overridden by    |                  |
78573 |                  |                 | setting this     |                  |
78574 |                  |                 | option. In       |                  |
78575 |                  |                 | particular, 0    |                  |
78576 |                  |                 | means forcing    |                  |
78577 |                  |                 | forward mode and |                  |
78578 |                  |                 | 1 forcing        |                  |
78579 |                  |                 | reverse mode.    |                  |
78580 |                  |                 | Leave unset for  |                  |
78581 |                  |                 | (class specific) |                  |
78582 |                  |                 | heuristics.      |                  |
78583 +------------------+-----------------+------------------+------------------+
78584 | ad_weight_sp     | OT_DOUBLE       | Weighting factor | casadi::Function |
78585 |                  |                 | for sparsity     | Internal         |
78586 |                  |                 | pattern          |                  |
78587 |                  |                 | calculation calc |                  |
78588 |                  |                 | ulation.Override |                  |
78589 |                  |                 | s default        |                  |
78590 |                  |                 | behavior. Set to |                  |
78591 |                  |                 | 0 and 1 to force |                  |
78592 |                  |                 | forward and      |                  |
78593 |                  |                 | reverse mode     |                  |
78594 |                  |                 | respectively.    |                  |
78595 |                  |                 | Cf. option       |                  |
78596 |                  |                 | \"ad_weight\".     |                  |
78597 |                  |                 | When set to -1,  |                  |
78598 |                  |                 | sparsity is      |                  |
78599 |                  |                 | completely       |                  |
78600 |                  |                 | ignored and      |                  |
78601 |                  |                 | dense matrices   |                  |
78602 |                  |                 | are used.        |                  |
78603 +------------------+-----------------+------------------+------------------+
78604 | always_inline    | OT_BOOL         | Force inlining.  | casadi::Function |
78605 |                  |                 |                  | Internal         |
78606 +------------------+-----------------+------------------+------------------+
78607 | compiler         | OT_STRING       | Just-in-time     | casadi::Function |
78608 |                  |                 | compiler plugin  | Internal         |
78609 |                  |                 | to be used.      |                  |
78610 +------------------+-----------------+------------------+------------------+
78611 | custom_jacobian  | OT_FUNCTION     | Override         | casadi::Function |
78612 |                  |                 | CasADi's AD. Use | Internal         |
78613 |                  |                 | together with    |                  |
78614 |                  |                 | 'jac_penalty':   |                  |
78615 |                  |                 | 0. Note: Highly  |                  |
78616 |                  |                 | experimental.    |                  |
78617 |                  |                 | Syntax may break |                  |
78618 |                  |                 | often.           |                  |
78619 +------------------+-----------------+------------------+------------------+
78620 | derivative_of    | OT_FUNCTION     | The function is  | casadi::Function |
78621 |                  |                 | a derivative of  | Internal         |
78622 |                  |                 | another          |                  |
78623 |                  |                 | function. The    |                  |
78624 |                  |                 | type of          |                  |
78625 |                  |                 | derivative       |                  |
78626 |                  |                 | (directional     |                  |
78627 |                  |                 | derivative,      |                  |
78628 |                  |                 | Jacobian) is     |                  |
78629 |                  |                 | inferred from    |                  |
78630 |                  |                 | the function     |                  |
78631 |                  |                 | name.            |                  |
78632 +------------------+-----------------+------------------+------------------+
78633 | dump             | OT_BOOL         | Dump function to | casadi::Function |
78634 |                  |                 | file upon first  | Internal         |
78635 |                  |                 | evaluation.      |                  |
78636 |                  |                 | [false]          |                  |
78637 +------------------+-----------------+------------------+------------------+
78638 | dump_dir         | OT_STRING       | Directory to     | casadi::Function |
78639 |                  |                 | dump             | Internal         |
78640 |                  |                 | inputs/outputs   |                  |
78641 |                  |                 | to. Make sure    |                  |
78642 |                  |                 | the directory    |                  |
78643 |                  |                 | exists [.]       |                  |
78644 +------------------+-----------------+------------------+------------------+
78645 | dump_format      | OT_STRING       | Choose file      | casadi::Function |
78646 |                  |                 | format to dump   | Internal         |
78647 |                  |                 | matrices. See    |                  |
78648 |                  |                 | DM.from_file     |                  |
78649 |                  |                 | [mtx]            |                  |
78650 +------------------+-----------------+------------------+------------------+
78651 | dump_in          | OT_BOOL         | Dump numerical   | casadi::Function |
78652 |                  |                 | values of inputs | Internal         |
78653 |                  |                 | to file          |                  |
78654 |                  |                 | (readable with   |                  |
78655 |                  |                 | DM.from_file )   |                  |
78656 |                  |                 | [default: false] |                  |
78657 +------------------+-----------------+------------------+------------------+
78658 | dump_out         | OT_BOOL         | Dump numerical   | casadi::Function |
78659 |                  |                 | values of        | Internal         |
78660 |                  |                 | outputs to file  |                  |
78661 |                  |                 | (readable with   |                  |
78662 |                  |                 | DM.from_file )   |                  |
78663 |                  |                 | [default: false] |                  |
78664 +------------------+-----------------+------------------+------------------+
78665 | enable_fd        | OT_BOOL         | Enable           | casadi::Function |
78666 |                  |                 | derivative       | Internal         |
78667 |                  |                 | calculation by   |                  |
78668 |                  |                 | finite           |                  |
78669 |                  |                 | differencing.    |                  |
78670 |                  |                 | [default:        |                  |
78671 |                  |                 | false]]          |                  |
78672 +------------------+-----------------+------------------+------------------+
78673 | enable_forward   | OT_BOOL         | Enable           | casadi::Function |
78674 |                  |                 | derivative       | Internal         |
78675 |                  |                 | calculation      |                  |
78676 |                  |                 | using generated  |                  |
78677 |                  |                 | functions for    |                  |
78678 |                  |                 | Jacobian-times-  |                  |
78679 |                  |                 | vector products  |                  |
78680 |                  |                 | - typically      |                  |
78681 |                  |                 | using forward    |                  |
78682 |                  |                 | mode AD - if     |                  |
78683 |                  |                 | available.       |                  |
78684 |                  |                 | [default: true]  |                  |
78685 +------------------+-----------------+------------------+------------------+
78686 | enable_jacobian  | OT_BOOL         | Enable           | casadi::Function |
78687 |                  |                 | derivative       | Internal         |
78688 |                  |                 | calculation      |                  |
78689 |                  |                 | using generated  |                  |
78690 |                  |                 | functions for    |                  |
78691 |                  |                 | Jacobians of all |                  |
78692 |                  |                 | differentiable   |                  |
78693 |                  |                 | outputs with     |                  |
78694 |                  |                 | respect to all   |                  |
78695 |                  |                 | differentiable   |                  |
78696 |                  |                 | inputs - if      |                  |
78697 |                  |                 | available.       |                  |
78698 |                  |                 | [default: true]  |                  |
78699 +------------------+-----------------+------------------+------------------+
78700 | enable_reverse   | OT_BOOL         | Enable           | casadi::Function |
78701 |                  |                 | derivative       | Internal         |
78702 |                  |                 | calculation      |                  |
78703 |                  |                 | using generated  |                  |
78704 |                  |                 | functions for    |                  |
78705 |                  |                 | transposed       |                  |
78706 |                  |                 | Jacobian-times-  |                  |
78707 |                  |                 | vector products  |                  |
78708 |                  |                 | - typically      |                  |
78709 |                  |                 | using reverse    |                  |
78710 |                  |                 | mode AD - if     |                  |
78711 |                  |                 | available.       |                  |
78712 |                  |                 | [default: true]  |                  |
78713 +------------------+-----------------+------------------+------------------+
78714 | fd_method        | OT_STRING       | Method for       | casadi::Function |
78715 |                  |                 | finite           | Internal         |
78716 |                  |                 | differencing     |                  |
78717 |                  |                 | [default         |                  |
78718 |                  |                 | 'central']       |                  |
78719 +------------------+-----------------+------------------+------------------+
78720 | fd_options       | OT_DICT         | Options to be    | casadi::Function |
78721 |                  |                 | passed to the    | Internal         |
78722 |                  |                 | finite           |                  |
78723 |                  |                 | difference       |                  |
78724 |                  |                 | instance         |                  |
78725 +------------------+-----------------+------------------+------------------+
78726 | forward_options  | OT_DICT         | Options to be    | casadi::Function |
78727 |                  |                 | passed to a      | Internal         |
78728 |                  |                 | forward mode     |                  |
78729 |                  |                 | constructor      |                  |
78730 +------------------+-----------------+------------------+------------------+
78731 | gather_stats     | OT_BOOL         | Deprecated       | casadi::Function |
78732 |                  |                 | option           | Internal         |
78733 |                  |                 | (ignored):       |                  |
78734 |                  |                 | Statistics are   |                  |
78735 |                  |                 | now always       |                  |
78736 |                  |                 | collected.       |                  |
78737 +------------------+-----------------+------------------+------------------+
78738 | h                | OT_DOUBLE       | Step size        | casadi::Smoothin |
78739 |                  |                 | [default:        | g                |
78740 |                  |                 | computed from    |                  |
78741 |                  |                 | abstol]          |                  |
78742 +------------------+-----------------+------------------+------------------+
78743 | h_iter           | OT_INT          | Number of        | casadi::Smoothin |
78744 |                  |                 | iterations to    | g                |
78745 |                  |                 | improve on the   |                  |
78746 |                  |                 | step-size        |                  |
78747 |                  |                 | [default: 1 if   |                  |
78748 |                  |                 | error estimate   |                  |
78749 |                  |                 | available,       |                  |
78750 |                  |                 | otherwise 0]     |                  |
78751 +------------------+-----------------+------------------+------------------+
78752 | h_max            | OT_DOUBLE       | Maximum step     | casadi::Smoothin |
78753 |                  |                 | size [default 0] | g                |
78754 +------------------+-----------------+------------------+------------------+
78755 | h_min            | OT_DOUBLE       | Minimum step     | casadi::Smoothin |
78756 |                  |                 | size [default    | g                |
78757 |                  |                 | inf]             |                  |
78758 +------------------+-----------------+------------------+------------------+
78759 | input_scheme     | OT_STRINGVECTOR | Deprecated       | casadi::Function |
78760 |                  |                 | option (ignored) | Internal         |
78761 +------------------+-----------------+------------------+------------------+
78762 | inputs_check     | OT_BOOL         | Throw exceptions | casadi::Function |
78763 |                  |                 | when the         | Internal         |
78764 |                  |                 | numerical values |                  |
78765 |                  |                 | of the inputs    |                  |
78766 |                  |                 | don't make sense |                  |
78767 +------------------+-----------------+------------------+------------------+
78768 | is_diff_in       | OT_BOOLVECTOR   | Indicate for     | casadi::Function |
78769 |                  |                 | each input if it | Internal         |
78770 |                  |                 | should be        |                  |
78771 |                  |                 | differentiable.  |                  |
78772 +------------------+-----------------+------------------+------------------+
78773 | is_diff_out      | OT_BOOLVECTOR   | Indicate for     | casadi::Function |
78774 |                  |                 | each output if   | Internal         |
78775 |                  |                 | it should be     |                  |
78776 |                  |                 | differentiable.  |                  |
78777 +------------------+-----------------+------------------+------------------+
78778 | jac_penalty      | OT_DOUBLE       | When requested   | casadi::Function |
78779 |                  |                 | for a number of  | Internal         |
78780 |                  |                 | forward/reverse  |                  |
78781 |                  |                 | directions, it   |                  |
78782 |                  |                 | may be cheaper   |                  |
78783 |                  |                 | to compute first |                  |
78784 |                  |                 | the full         |                  |
78785 |                  |                 | jacobian and     |                  |
78786 |                  |                 | then multiply    |                  |
78787 |                  |                 | with seeds,      |                  |
78788 |                  |                 | rather than      |                  |
78789 |                  |                 | obtain the       |                  |
78790 |                  |                 | requested        |                  |
78791 |                  |                 | directions in a  |                  |
78792 |                  |                 | straightforward  |                  |
78793 |                  |                 | manner. Casadi   |                  |
78794 |                  |                 | uses a heuristic |                  |
78795 |                  |                 | to decide which  |                  |
78796 |                  |                 | is cheaper. A    |                  |
78797 |                  |                 | high value of    |                  |
78798 |                  |                 | 'jac_penalty'    |                  |
78799 |                  |                 | makes it less    |                  |
78800 |                  |                 | likely for the   |                  |
78801 |                  |                 | heurstic to      |                  |
78802 |                  |                 | chose the full   |                  |
78803 |                  |                 | Jacobian         |                  |
78804 |                  |                 | strategy. The    |                  |
78805 |                  |                 | special value -1 |                  |
78806 |                  |                 | indicates never  |                  |
78807 |                  |                 | to use the full  |                  |
78808 |                  |                 | Jacobian         |                  |
78809 |                  |                 | strategy         |                  |
78810 +------------------+-----------------+------------------+------------------+
78811 | jit              | OT_BOOL         | Use just-in-time | casadi::Function |
78812 |                  |                 | compiler to      | Internal         |
78813 |                  |                 | speed up the     |                  |
78814 |                  |                 | evaluation       |                  |
78815 +------------------+-----------------+------------------+------------------+
78816 | jit_cleanup      | OT_BOOL         | Cleanup up the   | casadi::Function |
78817 |                  |                 | temporary source | Internal         |
78818 |                  |                 | file that jit    |                  |
78819 |                  |                 | creates.         |                  |
78820 |                  |                 | Default: true    |                  |
78821 +------------------+-----------------+------------------+------------------+
78822 | jit_name         | OT_STRING       | The file name    | casadi::Function |
78823 |                  |                 | used to write    | Internal         |
78824 |                  |                 | out code. The    |                  |
78825 |                  |                 | actual file      |                  |
78826 |                  |                 | names used       |                  |
78827 |                  |                 | depend on 'jit_t |                  |
78828 |                  |                 | emp_suffix' and  |                  |
78829 |                  |                 | include          |                  |
78830 |                  |                 | extensions.      |                  |
78831 |                  |                 | Default:         |                  |
78832 |                  |                 | 'jit_tmp'        |                  |
78833 +------------------+-----------------+------------------+------------------+
78834 | jit_options      | OT_DICT         | Options to be    | casadi::Function |
78835 |                  |                 | passed to the    | Internal         |
78836 |                  |                 | jit compiler.    |                  |
78837 +------------------+-----------------+------------------+------------------+
78838 | jit_serialize    | OT_STRING       | Specify          | casadi::Function |
78839 |                  |                 | behaviour when   | Internal         |
78840 |                  |                 | serializing a    |                  |
78841 |                  |                 | jitted function: |                  |
78842 |                  |                 | SOURCE|link|embe |                  |
78843 |                  |                 | d.               |                  |
78844 +------------------+-----------------+------------------+------------------+
78845 | jit_temp_suffix  | OT_BOOL         | Use a temporary  | casadi::Function |
78846 |                  |                 | (seemingly       | Internal         |
78847 |                  |                 | random) filename |                  |
78848 |                  |                 | suffix for       |                  |
78849 |                  |                 | generated code   |                  |
78850 |                  |                 | and libraries.   |                  |
78851 |                  |                 | This is desired  |                  |
78852 |                  |                 | for thread-      |                  |
78853 |                  |                 | safety. This     |                  |
78854 |                  |                 | behaviour may    |                  |
78855 |                  |                 | defeat caching   |                  |
78856 |                  |                 | compiler         |                  |
78857 |                  |                 | wrappers.        |                  |
78858 |                  |                 | Default: true    |                  |
78859 +------------------+-----------------+------------------+------------------+
78860 | max_num_dir      | OT_INT          | Specify the      | casadi::Function |
78861 |                  |                 | maximum number   | Internal         |
78862 |                  |                 | of directions    |                  |
78863 |                  |                 | for derivative   |                  |
78864 |                  |                 | functions.       |                  |
78865 |                  |                 | Overrules the    |                  |
78866 |                  |                 | builtin optimize |                  |
78867 |                  |                 | d_num_dir.       |                  |
78868 +------------------+-----------------+------------------+------------------+
78869 | never_inline     | OT_BOOL         | Forbid inlining. | casadi::Function |
78870 |                  |                 |                  | Internal         |
78871 +------------------+-----------------+------------------+------------------+
78872 | output_scheme    | OT_STRINGVECTOR | Deprecated       | casadi::Function |
78873 |                  |                 | option (ignored) | Internal         |
78874 +------------------+-----------------+------------------+------------------+
78875 | print_in         | OT_BOOL         | Print numerical  | casadi::Function |
78876 |                  |                 | values of inputs | Internal         |
78877 |                  |                 | [default: false] |                  |
78878 +------------------+-----------------+------------------+------------------+
78879 | print_out        | OT_BOOL         | Print numerical  | casadi::Function |
78880 |                  |                 | values of        | Internal         |
78881 |                  |                 | outputs          |                  |
78882 |                  |                 | [default: false] |                  |
78883 +------------------+-----------------+------------------+------------------+
78884 | print_time       | OT_BOOL         | print            | casadi::Function |
78885 |                  |                 | information      | Internal         |
78886 |                  |                 | about execution  |                  |
78887 |                  |                 | time. Implies    |                  |
78888 |                  |                 | record_time.     |                  |
78889 +------------------+-----------------+------------------+------------------+
78890 | record_time      | OT_BOOL         | record           | casadi::Function |
78891 |                  |                 | information      | Internal         |
78892 |                  |                 | about execution  |                  |
78893 |                  |                 | time, for        |                  |
78894 |                  |                 | retrieval with   |                  |
78895 |                  |                 | stats().         |                  |
78896 +------------------+-----------------+------------------+------------------+
78897 | regularity_check | OT_BOOL         | Throw exceptions | casadi::Function |
78898 |                  |                 | when NaN or Inf  | Internal         |
78899 |                  |                 | appears during   |                  |
78900 |                  |                 | evaluation       |                  |
78901 +------------------+-----------------+------------------+------------------+
78902 | reltol           | OT_DOUBLE       | Accuracy of      | casadi::Smoothin |
78903 |                  |                 | function inputs  | g                |
78904 |                  |                 | [default: query  |                  |
78905 |                  |                 | object]          |                  |
78906 +------------------+-----------------+------------------+------------------+
78907 | reverse_options  | OT_DICT         | Options to be    | casadi::Function |
78908 |                  |                 | passed to a      | Internal         |
78909 |                  |                 | reverse mode     |                  |
78910 |                  |                 | constructor      |                  |
78911 +------------------+-----------------+------------------+------------------+
78912 | second_order_ste | OT_DOUBLE       | Second order     | casadi::Smoothin |
78913 | psize            |                 | perturbation     | g                |
78914 |                  |                 | size [default:   |                  |
78915 |                  |                 | 1e-3]            |                  |
78916 +------------------+-----------------+------------------+------------------+
78917 | smoothing        | OT_DOUBLE       | Smoothing        | casadi::Smoothin |
78918 |                  |                 | regularization   | g                |
78919 |                  |                 | [default:        |                  |
78920 |                  |                 | machine          |                  |
78921 |                  |                 | precision]       |                  |
78922 +------------------+-----------------+------------------+------------------+
78923 | u_aim            | OT_DOUBLE       | Target ratio of  | casadi::Smoothin |
78924 |                  |                 | roundoff error   | g                |
78925 |                  |                 | to truncation    |                  |
78926 |                  |                 | error [default:  |                  |
78927 |                  |                 | 100.]            |                  |
78928 +------------------+-----------------+------------------+------------------+
78929 | user_data        | OT_VOIDPTR      | A user-defined   | casadi::Function |
78930 |                  |                 | field that can   | Internal         |
78931 |                  |                 | be used to       |                  |
78932 |                  |                 | identify the     |                  |
78933 |                  |                 | function or pass |                  |
78934 |                  |                 | additional       |                  |
78935 |                  |                 | information      |                  |
78936 +------------------+-----------------+------------------+------------------+
78937 | verbose          | OT_BOOL         | Verbose          | casadi::Function |
78938 |                  |                 | evaluation  for  | Internal         |
78939 |                  |                 | debugging        |                  |
78940 +------------------+-----------------+------------------+------------------+
78941 
78942 Diagrams
78943 --------
78944 
78945 
78946 
78947 C++ includes: finite_differences.hpp ";
78948 
78949 %feature("docstring")  casadi::FunctionInternal::call_gen(const MXVector
78950 &arg, MXVector &res, casadi_int npar, bool always_inline, bool never_inline)
78951 const  "
78952 
78953 [INTERNAL]   Call a function, overloaded.
78954 
78955 ";
78956 
78957 %feature("docstring")  casadi::FunctionInternal::call_gen(const std::vector<
78958 MatrixCommon > &arg, std::vector< MatrixCommon > &res, casadi_int npar, bool
78959 always_inline, bool never_inline) const  "
78960 
78961 [INTERNAL]   Call a function, overloaded.
78962 
78963 ";
78964 
78965 %feature("docstring")  casadi::FunctionInternal::call(const std::vector< M >
78966 &arg, std::vector< M > &res, bool always_inline, bool never_inline) const  "
78967 
78968 [INTERNAL]   Call a function, templated.
78969 
78970 ";
78971 
78972 %feature("docstring")  casadi::FunctionInternal::replace_fseed(const
78973 std::vector< std::vector< M >> &fseed, casadi_int npar) const  "
78974 
78975 [INTERNAL]  Replace 0-by-0 forward seeds.
78976 
78977 ";
78978 
78979 %feature("docstring")  casadi::FunctionInternal::replace_fseed(const
78980 std::vector< std::vector< M > > &fseed, casadi_int npar) const  "
78981 
78982 [INTERNAL] ";
78983 
78984 %feature("docstring")  casadi::FunctionInternal::size1_out(casadi_int ind)
78985 const  "
78986 
78987 [INTERNAL]  Input/output dimensions.
78988 
78989 ";
78990 
78991 %feature("docstring")  casadi::FunctionInternal::has_function(const
78992 std::string &fname) const  "
78993 
78994 [INTERNAL] ";
78995 
78996 %feature("docstring")  casadi::FunctionInternal::size2_out(casadi_int ind)
78997 const  "
78998 
78999 [INTERNAL]  Input/output dimensions.
79000 
79001 ";
79002 
79003 %feature("docstring")  casadi::Smoothing::calc_fd(double **yk, double *y0,
79004 double *J, double h) const  "
79005 
79006 [INTERNAL] ";
79007 
79008 %feature("docstring")  casadi::Smoothing::calc_fd() const  "
79009 
79010 [INTERNAL] ";
79011 
79012 %feature("docstring")  casadi::FunctionInternal::reverse(casadi_int nadj)
79013 const  "
79014 
79015 [INTERNAL]  Return function that calculates adjoint derivatives
79016 reverse(nadj) returns a cached instance if available, and calls  Function
79017 get_reverse(casadi_int nadj) if no cached version is available.
79018 
79019 ";
79020 
79021 %feature("docstring")  casadi::FunctionInternal::jac() const  "
79022 
79023 [INTERNAL]  Return Jacobian of all input elements with respect to all output
79024 elements.
79025 
79026 ";
79027 
79028 %feature("docstring")  casadi::FunctionInternal::nz_out(const std::vector<
79029 DM > &res) const  "
79030 
79031 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
79032 
79033 ";
79034 
79035 %feature("docstring")  casadi::FunctionInternal::nz_out(const std::vector<
79036 double > &res) const  "
79037 
79038 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
79039 
79040 ";
79041 
79042 %feature("docstring")  casadi::FunctionInternal::sparsity_out(casadi_int
79043 ind) const  "
79044 
79045 [INTERNAL]  Input/output sparsity.
79046 
79047 ";
79048 
79049 %feature("docstring")  casadi::FunctionInternal::free_sx() const  "
79050 
79051 [INTERNAL]  Get free variables (SX)
79052 
79053 ";
79054 
79055 %feature("docstring")  casadi::FunctionInternal::has_jac() const  "
79056 
79057 [INTERNAL]  Return Jacobian of all input elements with respect to all output
79058 elements.
79059 
79060 ";
79061 
79062 %feature("docstring")  casadi::FunctionInternal::size1_in(casadi_int ind)
79063 const  "
79064 
79065 [INTERNAL]  Input/output dimensions.
79066 
79067 ";
79068 
79069 %feature("docstring")  casadi::FunctionInternal::project_res(const
79070 std::vector< M > &arg, casadi_int npar) const  "
79071 
79072 [INTERNAL]   Project sparsities.
79073 
79074 ";
79075 
79076 %feature("docstring")  casadi::FiniteDiff::get_options() const  "
79077 
79078 [INTERNAL]  Options.
79079 
79080 ";
79081 
79082 %feature("docstring")  casadi::FiniteDiff::get_n_out()  "
79083 
79084 [INTERNAL]  Number of function inputs and outputs.
79085 
79086 ";
79087 
79088 %feature("docstring")  casadi::FunctionInternal::map(casadi_int n, const
79089 std::string &parallelization) const  "
79090 
79091 [INTERNAL]  Generate/retrieve cached serial map.
79092 
79093 ";
79094 
79095 %feature("docstring")  casadi::ProtoFunction::serialize_base_function()
79096 const  "
79097 
79098 [INTERNAL]  String used to identify the immediate FunctionInternal subclass.
79099 
79100 ";
79101 
79102 %feature("docstring")  casadi::FiniteDiff::get_default_in(casadi_int ind)
79103 const  "
79104 
79105 [INTERNAL]  Get default input value.
79106 
79107 ";
79108 
79109 %feature("docstring")  casadi::FunctionInternal::which_depends(const
79110 std::string &s_in, const std::vector< std::string > &s_out, casadi_int
79111 order, bool tr=false) const  "
79112 
79113 [INTERNAL]  Which variables enter with some order.
79114 
79115 Parameters:
79116 -----------
79117 
79118 s_in:   Input name
79119 
79120 s_out:   Output name(s)
79121 
79122 order:  Only 1 (linear) and 2 (nonlinear) allowed
79123 
79124 tr:  Flip the relationship. Return which expressions contain the variables
79125 
79126 ";
79127 
79128 %feature("docstring")  casadi::FunctionInternal::is_diff_in(casadi_int i) "
79129 
79130 [INTERNAL] ";
79131 
79132 %feature("docstring")  casadi::FunctionInternal::numel_in() const  "
79133 
79134 [INTERNAL]  Number of input/output elements.
79135 
79136 ";
79137 
79138 %feature("docstring")  casadi::FunctionInternal::numel_in(casadi_int ind)
79139 const  "
79140 
79141 [INTERNAL]  Number of input/output elements.
79142 
79143 ";
79144 
79145 %feature("docstring")  casadi::FunctionInternal::codegen_mem_type() const  "
79146 
79147 [INTERNAL]  Thread-local memory object type.
79148 
79149 ";
79150 
79151 %feature("docstring")  casadi::FunctionInternal::is_a(const std::string
79152 &type, bool recursive) const  "
79153 
79154 [INTERNAL]  Check if the function is of a particular type.
79155 
79156 ";
79157 
79158 %feature("docstring")  casadi::FunctionInternal::convert_res(const
79159 std::vector< M > &res) const  "
79160 
79161 [INTERNAL]  Convert from/to input/output lists/map.
79162 
79163 ";
79164 
79165 %feature("docstring")  casadi::FunctionInternal::convert_res(const std::map<
79166 std::string, M > &res) const  "
79167 
79168 [INTERNAL]  Convert from/to input/output lists/map.
79169 
79170 ";
79171 
79172 %feature("docstring")  casadi::FunctionInternal::forward(casadi_int nfwd)
79173 const  "
79174 
79175 [INTERNAL]  Return function that calculates forward derivatives
79176 forward(nfwd) returns a cached instance if available, and calls  Function
79177 get_forward(casadi_int nfwd) if no cached version is available.
79178 
79179 ";
79180 
79181 %feature("docstring")  casadi::FunctionInternal::get_jac(const std::string
79182 &name, const std::vector< std::string > &inames, const std::vector<
79183 std::string > &onames, const Dict &opts) const  "
79184 
79185 [INTERNAL]  Return Jacobian of all input elements with respect to all output
79186 elements.
79187 
79188 ";
79189 
79190 %feature("docstring")  casadi::FunctionInternal::get_max_in(casadi_int ind)
79191 const  "
79192 
79193 [INTERNAL]  Get largest input value.
79194 
79195 ";
79196 
79197 %feature("docstring")  casadi::FunctionInternal::check_mat(const Sparsity
79198 &arg, const Sparsity &inp, casadi_int &npar) "
79199 
79200 [INTERNAL]  Helper function
79201 
79202 Parameters:
79203 -----------
79204 
79205 npar[in]:  normal usage: 1, disallow pararallel calls: -1
79206 
79207 npar[out]:  required number of parallel calls (or -1)
79208 
79209 ";
79210 
79211 %feature("docstring")  casadi::FunctionInternal::sz_iw() const  "
79212 
79213 [INTERNAL]  Get required length of iw field.
79214 
79215 ";
79216 
79217 %feature("docstring")  casadi::FunctionInternal::alloc(const Function &f,
79218 bool persistent=false) "
79219 
79220 [INTERNAL]  Ensure work vectors long enough to evaluate function.
79221 
79222 ";
79223 
79224 %feature("docstring")  casadi::FunctionInternal::adjViaJac(casadi_int nadj)
79225 const  "
79226 
79227 [INTERNAL]  Calculate derivatives by multiplying the full Jacobian and
79228 multiplying.
79229 
79230 ";
79231 
79232 %feature("docstring")
79233 casadi::FunctionInternal::codegen_incref(CodeGenerator &g) const  "
79234 
79235 [INTERNAL]  Codegen incref for dependencies.
79236 
79237 ";
79238 
79239 %feature("docstring")  casadi::ProtoFunction::release(int mem) const  "
79240 
79241 [INTERNAL]  Release a memory object.
79242 
79243 ";
79244 
79245 %feature("docstring")  casadi::FiniteDiff::get_sparsity_out(casadi_int i)  "
79246 
79247 [INTERNAL]  Sparsities of function inputs and outputs.
79248 
79249 ";
79250 
79251 %feature("docstring")  casadi::FunctionInternal::wrap_as_needed(const Dict
79252 &opts) const  "
79253 
79254 [INTERNAL]  Wrap in an Function instance consisting of only one MX call.
79255 
79256 ";
79257 
79258 %feature("docstring")  casadi::ProtoFunction::checkout() const  "
79259 
79260 [INTERNAL]  Checkout a memory object.
79261 
79262 ";
79263 
79264 %feature("docstring")  casadi::FunctionInternal::get_partition(casadi_int
79265 iind, casadi_int oind, Sparsity &D1, Sparsity &D2, bool compact, bool
79266 symmetric, bool allow_forward, bool allow_reverse) const  "
79267 
79268 [INTERNAL]  Get the unidirectional or bidirectional partition.
79269 
79270 ";
79271 
79272 %feature("docstring")  casadi::FunctionInternal::sp_reverse(bvec_t **arg,
79273 bvec_t **res, casadi_int *iw, bvec_t *w, void *mem) const  "
79274 
79275 [INTERNAL]  Propagate sparsity backwards.
79276 
79277 ";
79278 
79279 %feature("docstring")  casadi::FunctionInternal::has_free() const  "
79280 
79281 [INTERNAL]  Does the function have free variables.
79282 
79283 ";
79284 
79285 %feature("docstring")
79286 casadi::FunctionInternal::codegen_init_mem(CodeGenerator &g) const  "
79287 
79288 [INTERNAL]  Codegen decref for init_mem.
79289 
79290 ";
79291 
79292 %feature("docstring")  casadi::FunctionInternal::symbolic_output(const
79293 std::vector< MX > &arg) const  "
79294 
79295 [INTERNAL]  Get a vector of symbolic variables corresponding to the outputs.
79296 
79297 ";
79298 
79299 %feature("docstring")  casadi::FunctionInternal::jacobian_sparsity() const
79300 "
79301 
79302 [INTERNAL]  Get Jacobian sparsity.
79303 
79304 ";
79305 
79306 %feature("docstring")  casadi::ProtoFunction::sprint(char *buf, size_t
79307 buf_sz, const char *fmt,...) const  "
79308 
79309 [INTERNAL]  C-style formatted printing to string.
79310 
79311 ";
79312 
79313 %feature("docstring")  casadi::FunctionInternal::check_res(const
79314 std::vector< M > &res, casadi_int &npar) const  "
79315 
79316 [INTERNAL]  Check if output arguments have correct length and dimensions.
79317 
79318 Raises errors.
79319 
79320 Parameters:
79321 -----------
79322 
79323 npar[in]:  normal usage: 1, disallow pararallel calls: -1
79324 
79325 npar:  max number of horizontal repetitions across all arguments (or -1)
79326 
79327 ";
79328 
79329 %feature("docstring")  casadi::FunctionInternal::n_nodes() const  "
79330 
79331 [INTERNAL]  Number of nodes in the algorithm.
79332 
79333 ";
79334 
79335 %feature("docstring")  casadi::FunctionInternal::free_mx() const  "
79336 
79337 [INTERNAL]  Get free variables ( MX)
79338 
79339 ";
79340 
79341 %feature("docstring")  casadi::FunctionInternal::generate_in(const
79342 std::string &fname, const double **arg) const  "
79343 
79344 [INTERNAL]  Export an input file that can be passed to generate C code with
79345 a main.
79346 
79347 ";
79348 
79349 %feature("docstring")  casadi::FunctionInternal::get_function() const  "
79350 
79351 [INTERNAL] ";
79352 
79353 %feature("docstring")  casadi::FunctionInternal::get_function(const
79354 std::string &name) const  "
79355 
79356 [INTERNAL] ";
79357 
79358 %feature("docstring")  casadi::FunctionInternal::sx_in(casadi_int ind) const
79359 "
79360 
79361 [INTERNAL]  Get function input(s) and output(s)
79362 
79363 ";
79364 
79365 %feature("docstring")  casadi::FunctionInternal::sx_in() const  "
79366 
79367 [INTERNAL]  Get function input(s) and output(s)
79368 
79369 ";
79370 
79371 %feature("docstring")  casadi::FunctionInternal::sparsity_jac(casadi_int
79372 iind, casadi_int oind, bool compact, bool symmetric) const  "
79373 
79374 [INTERNAL]  Get, if necessary generate, the sparsity of a Jacobian block.
79375 
79376 ";
79377 
79378 %feature("docstring")  casadi::FunctionInternal::jit_dependencies(const
79379 std::string &fname) "
79380 
79381 [INTERNAL]  Jit dependencies.
79382 
79383 ";
79384 
79385 %feature("docstring")  casadi::FunctionInternal::self() const  "
79386 
79387 [INTERNAL]  Get a public class instance.
79388 
79389 ";
79390 
79391 %feature("docstring")  casadi::FunctionInternal::wrap() const  "
79392 
79393 [INTERNAL]  Wrap in an Function instance consisting of only one MX call.
79394 
79395 ";
79396 
79397 %feature("docstring")  casadi::FunctionInternal::set_work(void *mem, const
79398 double **&arg, double **&res, casadi_int *&iw, double *&w) const  "
79399 
79400 [INTERNAL]  Set the (persistent) work vectors.
79401 
79402 ";
79403 
79404 %feature("docstring")  casadi::FunctionInternal::is_diff_out(casadi_int i) "
79405 
79406 [INTERNAL] ";
79407 
79408 %feature("docstring")  casadi::FunctionInternal::size_out(casadi_int ind)
79409 const  "
79410 
79411 [INTERNAL]  Input/output dimensions.
79412 
79413 ";
79414 
79415 %feature("docstring")  casadi::FunctionInternal::print_option(const
79416 std::string &name, std::ostream &stream) const  "
79417 
79418 [INTERNAL]  Print all information there is to know about a certain option.
79419 
79420 ";
79421 
79422 %feature("docstring")
79423 casadi::FunctionInternal::getJacSparsityHierarchicalSymm(casadi_int iind,
79424 casadi_int oind) const  "
79425 
79426 [INTERNAL]  A flavor of getJacSparsity that does hierarchical block
79427 structure recognition for symmetric Jacobians
79428 
79429 ";
79430 
79431 %feature("docstring")  casadi::FunctionInternal::call_forward(const
79432 std::vector< MX > &arg, const std::vector< MX > &res, const std::vector<
79433 std::vector< MX > > &fseed, std::vector< std::vector< MX > > &fsens, bool
79434 always_inline, bool never_inline) const  "
79435 
79436 [INTERNAL]  Forward mode AD, virtual functions overloaded in derived
79437 classes.
79438 
79439 ";
79440 
79441 %feature("docstring")  casadi::FunctionInternal::call_forward(const
79442 std::vector< SX > &arg, const std::vector< SX > &res, const std::vector<
79443 std::vector< SX > > &fseed, std::vector< std::vector< SX > > &fsens, bool
79444 always_inline, bool never_inline) const  "
79445 
79446 [INTERNAL]  Forward mode AD, virtual functions overloaded in derived
79447 classes.
79448 
79449 ";
79450 
79451 %feature("docstring")  casadi::FunctionInternal::fwd_seed(casadi_int nfwd)
79452 const  "
79453 
79454 [INTERNAL]  Symbolic expressions for the forward seeds.
79455 
79456 ";
79457 
79458 %feature("docstring")  casadi::FunctionInternal::codegen_mem(CodeGenerator
79459 &g, const std::string &index="mem") const  "
79460 
79461 [INTERNAL]  Get thread-local memory object.
79462 
79463 ";
79464 
79465 %feature("docstring")  casadi::FunctionInternal::get_reltol() const  "
79466 
79467 [INTERNAL]  Get relative tolerance.
79468 
79469 ";
79470 
79471 %feature("docstring")  casadi::FunctionInternal::check_arg(const
79472 std::vector< M > &arg, casadi_int &npar) const  "
79473 
79474 [INTERNAL]  Check if input arguments have correct length and dimensions.
79475 
79476 Raises errors.
79477 
79478 Parameters:
79479 -----------
79480 
79481 npar[in]:  normal usage: 1, disallow pararallel calls: -1
79482 
79483 npar:  max number of horizontal repetitions across all arguments (or -1)
79484 
79485 ";
79486 
79487 %feature("docstring")  casadi::FunctionInternal::eval_mx(const MXVector
79488 &arg, MXVector &res, bool always_inline, bool never_inline) const  "
79489 
79490 [INTERNAL]  Evaluate with symbolic matrices.
79491 
79492 ";
79493 
79494 %feature("docstring")
79495 casadi::FunctionInternal::codegen_alloc_mem(CodeGenerator &g) const  "
79496 
79497 [INTERNAL]  Codegen decref for alloc_mem.
79498 
79499 ";
79500 
79501 %feature("docstring")  casadi::Smoothing::has_err() const  "
79502 
79503 [INTERNAL] ";
79504 
79505 %feature("docstring")  casadi::FunctionInternal::size_in(casadi_int ind)
79506 const  "
79507 
79508 [INTERNAL]  Input/output dimensions.
79509 
79510 ";
79511 
79512 %feature("docstring")  casadi::FunctionInternal::sz_work(size_t &sz_arg,
79513 size_t &sz_res, size_t &sz_iw, size_t &sz_w) const  "
79514 
79515 [INTERNAL]  Get number of temporary variables needed.
79516 
79517 ";
79518 
79519 %feature("docstring")
79520 casadi::FunctionInternal::instruction_constant(casadi_int k) const  "
79521 
79522 [INTERNAL]  Get the floating point output argument of an atomic operation.
79523 
79524 ";
79525 
79526 %feature("docstring")  casadi::FunctionInternal::disp(std::ostream &stream,
79527 bool more) const  "
79528 
79529 [INTERNAL]  Display object.
79530 
79531 ";
79532 
79533 %feature("docstring")
79534 casadi::FunctionInternal::serialize_type(SerializingStream &s) const  "
79535 
79536 [INTERNAL]  Serialize type information.
79537 
79538 ";
79539 
79540 %feature("docstring")  casadi::FunctionInternal::has_jacobian() const  "
79541 
79542 [INTERNAL]  Return Jacobian of all input elements with respect to all output
79543 elements.
79544 
79545 ";
79546 
79547 %feature("docstring")  casadi::FunctionInternal::instruction_MX(casadi_int
79548 k) const  "
79549 
79550 [INTERNAL]  get MX expression associated with instruction
79551 
79552 ";
79553 
79554 %feature("docstring")  casadi::ProtoFunction::alloc_mem() const  "
79555 
79556 [INTERNAL]  Create memory block.
79557 
79558 ";
79559 
79560 %feature("docstring")  casadi::FiniteDiff::init(const Dict &opts)  "
79561 
79562 [INTERNAL]  Initialize.
79563 
79564 ";
79565 
79566 %feature("docstring")  casadi::FiniteDiff::has_codegen() const  "
79567 
79568 [INTERNAL]  Is codegen supported?
79569 
79570 ";
79571 
79572 %feature("docstring")  casadi::FunctionInternal::index_out(const std::string
79573 &name) const  "
79574 
79575 [INTERNAL]  Get output scheme index by name.
79576 
79577 ";
79578 
79579 %feature("docstring")  casadi::SharedObjectInternal::getCount() const  "
79580 
79581 [INTERNAL]  Get the reference count.
79582 
79583 ";
79584 
79585 %feature("docstring")  casadi::Smoothing::pert(const std::string &k) const
79586 "
79587 
79588 [INTERNAL] ";
79589 
79590 %feature("docstring")  casadi::Smoothing::pert(casadi_int k, double h) const
79591 "
79592 
79593 [INTERNAL] ";
79594 
79595 %feature("docstring")  casadi::FunctionInternal::setup(void *mem, const
79596 double **arg, double **res, casadi_int *iw, double *w) const  "
79597 
79598 [INTERNAL]  Set the (persistent and temporary) work vectors.
79599 
79600 ";
79601 
79602 %feature("docstring")  casadi::FunctionInternal::generate_out(const
79603 std::string &fname, double **res) const  "
79604 
79605 [INTERNAL] ";
79606 
79607 %feature("docstring")  casadi::FunctionInternal::codegen_meta(CodeGenerator
79608 &g) const  "
79609 
79610 [INTERNAL]  Generate meta-information allowing a user to evaluate a
79611 generated function.
79612 
79613 ";
79614 
79615 %feature("docstring")  casadi::FiniteDiff::get_name_out(casadi_int i)  "
79616 
79617 [INTERNAL]  Names of function input and outputs.
79618 
79619 ";
79620 
79621 %feature("docstring")  casadi::ProtoFunction::init_mem(void *mem) const  "
79622 
79623 [INTERNAL]  Initalize memory block.
79624 
79625 ";
79626 
79627 %feature("docstring")  casadi::FunctionInternal::index_in(const std::string
79628 &name) const  "
79629 
79630 [INTERNAL]  Get input scheme index by name.
79631 
79632 ";
79633 
79634 %feature("docstring")  casadi::FunctionInternal::has_jacobian_sparsity()
79635 const  "
79636 
79637 [INTERNAL]  Get Jacobian sparsity.
79638 
79639 ";
79640 
79641 %feature("docstring")
79642 casadi::FunctionInternal::instruction_input(casadi_int k) const  "
79643 
79644 [INTERNAL]  Get the (integer) input arguments of an atomic operation.
79645 
79646 ";
79647 
79648 %feature("docstring")  casadi::FunctionInternal::generate_options(bool
79649 is_temp=false) const  "
79650 
79651 [INTERNAL]  Reconstruct options dict.
79652 
79653 ";
79654 
79655 %feature("docstring")  casadi::FunctionInternal::jacobian() const  "
79656 
79657 [INTERNAL]  Return Jacobian of all input elements with respect to all output
79658 elements.
79659 
79660 ";
79661 
79662 %feature("docstring")
79663 casadi::FunctionInternal::jacobian_sparsity_filter(const Sparsity &sp) const
79664 "
79665 
79666 [INTERNAL]  Filter out nonzeros in the full sparsity jacobian according to
79667 is_diff_in/out.
79668 
79669 ";
79670 
79671 %feature("docstring")  casadi::FunctionInternal::eval_dm(const std::vector<
79672 DM > &arg) const  "
79673 
79674 [INTERNAL]  Evaluate with DM matrices.
79675 
79676 ";
79677 
79678 %feature("docstring")  casadi::FunctionInternal::signature(const std::string
79679 &fname) const  "
79680 
79681 [INTERNAL]  Code generate the function.
79682 
79683 ";
79684 
79685 %feature("docstring")  casadi::FunctionInternal::replace_aseed(const
79686 std::vector< std::vector< M >> &aseed, casadi_int npar) const  "
79687 
79688 [INTERNAL]  Replace 0-by-0 reverse seeds.
79689 
79690 ";
79691 
79692 %feature("docstring")  casadi::FunctionInternal::replace_aseed(const
79693 std::vector< std::vector< M > > &aseed, casadi_int npar) const  "
79694 
79695 [INTERNAL] ";
79696 
79697 %feature("docstring")  casadi::FunctionInternal::replace_res(const
79698 std::vector< M > &res, casadi_int npar) const  "
79699 
79700 [INTERNAL]  Replace 0-by-0 outputs.
79701 
79702 ";
79703 
79704 %feature("docstring")  casadi::FunctionInternal::alloc_iw(size_t sz_iw, bool
79705 persistent=false) "
79706 
79707 [INTERNAL]  Ensure required length of iw field.
79708 
79709 ";
79710 
79711 %feature("docstring") casadi::Smoothing::Smoothing(const std::string &name,
79712 casadi_int n) "
79713 
79714 [INTERNAL] ";
79715 
79716 %feature("docstring")  casadi::FunctionInternal::has_derivative() const  "
79717 
79718 [INTERNAL]  Can derivatives be calculated in any way?
79719 
79720 ";
79721 
79722 %feature("docstring")  casadi::FiniteDiff::get_name_in(casadi_int i)  "
79723 
79724 [INTERNAL]  Names of function input and outputs.
79725 
79726 ";
79727 
79728 %feature("docstring")  casadi::FunctionInternal::finalize()  "
79729 
79730 [INTERNAL]  Finalize the object creation.
79731 
79732 ";
79733 
79734 %feature("docstring")  casadi::FunctionInternal::get_jacobian(const
79735 std::string &name, const std::vector< std::string > &inames, const
79736 std::vector< std::string > &onames, const Dict &opts) const  "
79737 
79738 [INTERNAL]  Return Jacobian of all input elements with respect to all output
79739 elements.
79740 
79741 ";
79742 
79743 %feature("docstring")
79744 casadi::FunctionInternal::serialize_body(SerializingStream &s) const  "
79745 
79746 [INTERNAL]  Serialize an object without type information.
79747 
79748 ";
79749 
79750 %feature("docstring")  casadi::FunctionInternal::disp_more(std::ostream
79751 &stream) const  "
79752 
79753 [INTERNAL]  Print more.
79754 
79755 ";
79756 
79757 %feature("docstring")  casadi::FunctionInternal::nnz_out() const  "
79758 
79759 [INTERNAL]  Number of input/output nonzeros.
79760 
79761 ";
79762 
79763 %feature("docstring")  casadi::FunctionInternal::nnz_out(casadi_int ind)
79764 const  "
79765 
79766 [INTERNAL]  Number of input/output nonzeros.
79767 
79768 ";
79769 
79770 %feature("docstring")  casadi::FunctionInternal::sz_arg() const  "
79771 
79772 [INTERNAL]  Get required length of arg field.
79773 
79774 ";
79775 
79776 %feature("docstring")  casadi::FunctionInternal::instruction_id(casadi_int
79777 k) const  "
79778 
79779 [INTERNAL]  Get an atomic operation operator index.
79780 
79781 ";
79782 
79783 %feature("docstring")  casadi::FiniteDiff::codegen_body(CodeGenerator &g)
79784 const  "
79785 
79786 [INTERNAL]  Generate code for the body of the C function.
79787 
79788 ";
79789 
79790 %feature("docstring")  casadi::FunctionInternal::size2_in(casadi_int ind)
79791 const  "
79792 
79793 [INTERNAL]  Input/output dimensions.
79794 
79795 ";
79796 
79797 %feature("docstring")  casadi::FunctionInternal::project_arg(const
79798 std::vector< M > &arg, casadi_int npar) const  "
79799 
79800 [INTERNAL]   Project sparsities.
79801 
79802 ";
79803 
79804 %feature("docstring")  casadi::ProtoFunction::free_mem(void *mem) const  "
79805 
79806 [INTERNAL]  Free memory block.
79807 
79808 ";
79809 
79810 %feature("docstring")  casadi::FunctionInternal::nnz_in() const  "
79811 
79812 [INTERNAL]  Number of input/output nonzeros.
79813 
79814 ";
79815 
79816 %feature("docstring")  casadi::FunctionInternal::nnz_in(casadi_int ind)
79817 const  "
79818 
79819 [INTERNAL]  Number of input/output nonzeros.
79820 
79821 ";
79822 
79823 %feature("docstring")  casadi::Smoothing::class_name() const  "
79824 
79825 [INTERNAL]  Get type name.
79826 
79827 ";
79828 
79829 %feature("docstring")
79830 casadi::FunctionInternal::print_dimensions(std::ostream &stream) const  "
79831 
79832 [INTERNAL]  Print dimensions of inputs and outputs.
79833 
79834 ";
79835 
79836 %feature("docstring")  casadi::ProtoFunction::construct(const Dict &opts) "
79837 
79838 [INTERNAL]  Construct Prepares the function for evaluation.
79839 
79840 ";
79841 
79842 %feature("docstring")
79843 casadi::FunctionInternal::codegen_free_mem(CodeGenerator &g) const  "
79844 
79845 [INTERNAL]  Codegen for free_mem.
79846 
79847 ";
79848 
79849 %feature("docstring")  casadi::FunctionInternal::getJacSparsity(casadi_int
79850 iind, casadi_int oind, bool symmetric) const  "
79851 
79852 [INTERNAL]  Generate the sparsity of a Jacobian block.
79853 
79854 ";
79855 
79856 %feature("docstring")  casadi::FunctionInternal::sz_res() const  "
79857 
79858 [INTERNAL]  Get required length of res field.
79859 
79860 ";
79861 
79862 %feature("docstring")  casadi::FunctionInternal::definition() const  "
79863 
79864 [INTERNAL]  Get function signature: name:(inputs)->(outputs)
79865 
79866 ";
79867 
79868 %feature("docstring")  casadi::FunctionInternal::n_instructions() const  "
79869 
79870 [INTERNAL]  Get the number of atomic operations.
79871 
79872 ";
79873 
79874 %feature("docstring")  casadi::FunctionInternal::replace_arg(const
79875 std::vector< M > &arg, casadi_int npar) const  "
79876 
79877 [INTERNAL]  Replace 0-by-0 inputs.
79878 
79879 ";
79880 
79881 %feature("docstring")  casadi::FunctionInternal::generate_lifted(Function
79882 &vdef_fcn, Function &vinit_fcn) const  "
79883 
79884 [INTERNAL]  Extract the functions needed for the Lifted Newton method.
79885 
79886 ";
79887 
79888 %feature("docstring")  casadi::SharedObjectInternal::weak() "
79889 
79890 [INTERNAL]  Get a weak reference to the object.
79891 
79892 ";
79893 
79894 %feature("docstring")  casadi::ProtoFunction::get_stats(void *mem) const  "
79895 
79896 [INTERNAL]  Get all statistics.
79897 
79898 ";
79899 
79900 %feature("docstring")  casadi::FunctionInternal::has_eval_dm() const  "
79901 
79902 [INTERNAL]  Evaluate with DM matrices.
79903 
79904 ";
79905 
79906 %feature("docstring")  casadi::FunctionInternal::mapsum_mx(const
79907 std::vector< MX > &arg, const std::string &parallelization) "
79908 
79909 [INTERNAL]  Parallel evaluation.
79910 
79911 ";
79912 
79913 %feature("docstring")  casadi::Smoothing::get_forward(casadi_int nfwd, const
79914 std::string &name, const std::vector< std::string > &inames, const
79915 std::vector< std::string > &onames, const Dict &opts) const  "
79916 
79917 [INTERNAL]  Second order derivatives.
79918 
79919 ";
79920 
79921 %feature("docstring")  casadi::ProtoFunction::serialize(SerializingStream
79922 &s) const  "
79923 
79924 [INTERNAL]  Serialize an object.
79925 
79926 ";
79927 
79928 %feature("docstring")  casadi::FunctionInternal::symbolicAdjSeed(casadi_int
79929 nadj, const std::vector< MatType > &v) const  "
79930 
79931 [INTERNAL]  Symbolic expressions for the adjoint seeds.
79932 
79933 ";
79934 
79935 %feature("docstring")  casadi::ProtoFunction::print(const char *fmt,...)
79936 const  "
79937 
79938 [INTERNAL]  C-style formatted printing during evaluation.
79939 
79940 ";
79941 
79942 %feature("docstring")  casadi::FunctionInternal::dm_in(casadi_int ind) const
79943 "
79944 
79945 [INTERNAL]  Get function input(s) and output(s)
79946 
79947 ";
79948 
79949 %feature("docstring")  casadi::FunctionInternal::dm_in() const  "
79950 
79951 [INTERNAL]  Get function input(s) and output(s)
79952 
79953 ";
79954 
79955 %feature("docstring")  casadi::FunctionInternal::get_free() const  "
79956 
79957 [INTERNAL]  Print free variables.
79958 
79959 ";
79960 
79961 %feature("docstring")  casadi::ProtoFunction::format_time(char *buffer,
79962 double time) const  "
79963 
79964 [INTERNAL]  Format time in a fixed width 8 format.
79965 
79966 ";
79967 
79968 %feature("docstring")  casadi::FunctionInternal::get_reverse(casadi_int
79969 nadj, const std::string &name, const std::vector< std::string > &inames,
79970 const std::vector< std::string > &onames, const Dict &opts) const  "
79971 
79972 [INTERNAL]  Return function that calculates adjoint derivatives
79973 reverse(nadj) returns a cached instance if available, and calls  Function
79974 get_reverse(casadi_int nadj) if no cached version is available.
79975 
79976 ";
79977 
79978 %feature("docstring")  casadi::FunctionInternal::call_reverse(const
79979 std::vector< MX > &arg, const std::vector< MX > &res, const std::vector<
79980 std::vector< MX > > &aseed, std::vector< std::vector< MX > > &asens, bool
79981 always_inline, bool never_inline) const  "
79982 
79983 [INTERNAL]  Reverse mode, virtual functions overloaded in derived classes.
79984 
79985 ";
79986 
79987 %feature("docstring")  casadi::FunctionInternal::call_reverse(const
79988 std::vector< SX > &arg, const std::vector< SX > &res, const std::vector<
79989 std::vector< SX > > &aseed, std::vector< std::vector< SX > > &asens, bool
79990 always_inline, bool never_inline) const  "
79991 
79992 [INTERNAL]  Reverse mode, virtual functions overloaded in derived classes.
79993 
79994 ";
79995 
79996 %feature("docstring")  casadi::ProtoFunction::memory(int ind) const  "
79997 
79998 [INTERNAL]  Memory objects.
79999 
80000 ";
80001 
80002 %feature("docstring")
80003 casadi::FunctionInternal::getJacSparsityHierarchical(casadi_int iind,
80004 casadi_int oind) const  "
80005 
80006 [INTERNAL]  A flavor of getJacSparsity that does hierarchical block
80007 structure recognition.
80008 
80009 ";
80010 
80011 %feature("docstring")  casadi::FunctionInternal::eval_gen(const double
80012 **arg, double **res, casadi_int *iw, double *w, void *mem) const  "
80013 
80014 [INTERNAL]  Evaluate numerically.
80015 
80016 ";
80017 
80018 %feature("docstring")  casadi::FunctionInternal::eval_gen(const SXElem
80019 **arg, SXElem **res, casadi_int *iw, SXElem *w, void *mem) const  "
80020 
80021 [INTERNAL]  Evaluate a function, overloaded.
80022 
80023 ";
80024 
80025 %feature("docstring")  casadi::FunctionInternal::eval_gen(const bvec_t
80026 **arg, bvec_t **res, casadi_int *iw, bvec_t *w, void *mem) const  "
80027 
80028 [INTERNAL]  Evaluate a function, overloaded.
80029 
80030 ";
80031 
80032 %feature("docstring")  casadi::FunctionInternal::nz_in(const std::vector< DM
80033 > &arg) const  "
80034 
80035 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
80036 
80037 ";
80038 
80039 %feature("docstring")  casadi::FunctionInternal::nz_in(const std::vector<
80040 double > &arg) const  "
80041 
80042 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
80043 
80044 ";
80045 
80046 %feature("docstring")  casadi::FunctionInternal::has_sprev() const  "
80047 
80048 [INTERNAL]  Is the class able to propagate seeds through the algorithm?
80049 
80050 ";
80051 
80052 %feature("docstring")  casadi::FiniteDiff::get_sparsity_in(casadi_int i)  "
80053 
80054 [INTERNAL]  Sparsities of function inputs and outputs.
80055 
80056 ";
80057 
80058 %feature("docstring")  casadi::FunctionInternal::set_temp(void *mem, const
80059 double **arg, double **res, casadi_int *iw, double *w) const  "
80060 
80061 [INTERNAL]  Set the (temporary) work vectors.
80062 
80063 ";
80064 
80065 %feature("docstring")  casadi::FiniteDiff::uses_output() const  "
80066 
80067 [INTERNAL]  Is the scheme using the (nondifferentiated) output?
80068 
80069 ";
80070 
80071 %feature("docstring")  casadi::FunctionInternal::sparsity_in(casadi_int ind)
80072 const  "
80073 
80074 [INTERNAL]  Input/output sparsity.
80075 
80076 ";
80077 
80078 %feature("docstring")  casadi::FunctionInternal::ad_weight() const  "
80079 
80080 [INTERNAL]  Weighting factor for chosing forward/reverse mode.
80081 
80082 ";
80083 
80084 %feature("docstring")  casadi::FunctionInternal::mx_out(casadi_int ind)
80085 const  "
80086 
80087 [INTERNAL]  Get function input(s) and output(s)
80088 
80089 ";
80090 
80091 %feature("docstring")  casadi::FunctionInternal::mx_out() const  "
80092 
80093 [INTERNAL]  Get function input(s) and output(s)
80094 
80095 ";
80096 
80097 %feature("docstring")
80098 casadi::FiniteDiff::codegen_declarations(CodeGenerator &g) const  "
80099 
80100 [INTERNAL]  Generate code for the declarations of the C function.
80101 
80102 ";
80103 
80104 %feature("docstring")  casadi::FunctionInternal::eval_sx(const SXElem **arg,
80105 SXElem **res, casadi_int *iw, SXElem *w, void *mem) const  "
80106 
80107 [INTERNAL]  Evaluate with symbolic scalars.
80108 
80109 ";
80110 
80111 %feature("docstring")  casadi::FunctionInternal::sp_forward(const bvec_t
80112 **arg, bvec_t **res, casadi_int *iw, bvec_t *w, void *mem) const  "
80113 
80114 [INTERNAL]  Propagate sparsity forward.
80115 
80116 ";
80117 
80118 %feature("docstring")  casadi::FunctionInternal::sx_out(casadi_int ind)
80119 const  "
80120 
80121 [INTERNAL]  Get function input(s) and output(s)
80122 
80123 ";
80124 
80125 %feature("docstring")  casadi::FunctionInternal::sx_out() const  "
80126 
80127 [INTERNAL]  Get function input(s) and output(s)
80128 
80129 ";
80130 
80131 %feature("docstring")  casadi::FunctionInternal::matching_arg(const
80132 std::vector< M > &arg, casadi_int &npar) const  "
80133 
80134 [INTERNAL]  Check if input arguments that needs to be replaced.
80135 
80136 Raises errors
80137 
80138 Parameters:
80139 -----------
80140 
80141 npar[in]:  normal usage: 1, disallow pararallel calls: -1
80142 
80143 npar:  max number of horizontal repetitions across all arguments (or -1)
80144 
80145 ";
80146 
80147 %feature("docstring")  casadi::FunctionInternal::codegen(CodeGenerator &g,
80148 const std::string &fname) const  "
80149 
80150 [INTERNAL]  Generate code the function.
80151 
80152 ";
80153 
80154 %feature("docstring")  casadi::FunctionInternal::generate_dependencies(const
80155 std::string &fname, const Dict &opts) const  "
80156 
80157 [INTERNAL]  Export / Generate C code for the dependency function.
80158 
80159 ";
80160 
80161 %feature("docstring")  casadi::FunctionInternal::print_options(std::ostream
80162 &stream) const  "
80163 
80164 [INTERNAL]  Print list of options.
80165 
80166 ";
80167 
80168 %feature("docstring")  casadi::FunctionInternal::dm_out(casadi_int ind)
80169 const  "
80170 
80171 [INTERNAL]  Get function input(s) and output(s)
80172 
80173 ";
80174 
80175 %feature("docstring")  casadi::FunctionInternal::dm_out() const  "
80176 
80177 [INTERNAL]  Get function input(s) and output(s)
80178 
80179 ";
80180 
80181 %feature("docstring")  casadi::FunctionInternal::has_reverse(casadi_int
80182 nadj) const  "
80183 
80184 [INTERNAL]  Return function that calculates adjoint derivatives
80185 reverse(nadj) returns a cached instance if available, and calls  Function
80186 get_reverse(casadi_int nadj) if no cached version is available.
80187 
80188 ";
80189 
80190 %feature("docstring")  casadi::FunctionInternal::fwdViaJac(casadi_int nfwd)
80191 const  "
80192 
80193 [INTERNAL]  Calculate derivatives by multiplying the full Jacobian and
80194 multiplying.
80195 
80196 ";
80197 
80198 %feature("docstring")  casadi::FiniteDiff::get_n_in()  "
80199 
80200 [INTERNAL]  Number of function inputs and outputs.
80201 
80202 ";
80203 
80204 %feature("docstring")  casadi::FunctionInternal::info() const  "
80205 
80206 [INTERNAL]  Obtain information about function
80207 
80208 ";
80209 
80210 %feature("docstring")  casadi::FunctionInternal::incache(const std::string
80211 &fname, Function &f, const std::string &suffix="") const  "
80212 
80213 [INTERNAL]  Get function in cache.
80214 
80215 ";
80216 
80217 %feature("docstring")  casadi::FunctionInternal::has_spfwd() const  "
80218 
80219 [INTERNAL]  Is the class able to propagate seeds through the algorithm?
80220 
80221 ";
80222 
80223 %feature("docstring")  casadi::FunctionInternal::matching_res(const
80224 std::vector< M > &arg, casadi_int &npar) const  "
80225 
80226 [INTERNAL]  Check if output arguments that needs to be replaced.
80227 
80228 Raises errors
80229 
80230 Parameters:
80231 -----------
80232 
80233 npar[in]:  normal usage: 1, disallow pararallel calls: -1
80234 
80235 npar:  max number of horizontal repetitions across all arguments (or -1)
80236 
80237 ";
80238 
80239 %feature("docstring")  casadi::FiniteDiff::eval(const double **arg, double
80240 **res, casadi_int *iw, double *w, void *mem) const  "
80241 
80242 [INTERNAL]  Evaluate numerically.
80243 
80244 ";
80245 
80246 %feature("docstring")  casadi::ProtoFunction::clear_mem() "
80247 
80248 [INTERNAL]  Clear all memory (called from destructor)
80249 
80250 ";
80251 
80252 %feature("docstring")  casadi::FunctionInternal::all_scalar() const  "
80253 
80254 [INTERNAL]  Are all inputs and outputs scalar.
80255 
80256 ";
80257 
80258 %feature("docstring")  casadi::FunctionInternal::numel_out(casadi_int ind)
80259 const  "
80260 
80261 [INTERNAL]  Number of input/output elements.
80262 
80263 ";
80264 
80265 %feature("docstring")  casadi::FunctionInternal::numel_out() const  "
80266 
80267 [INTERNAL]  Number of input/output elements.
80268 
80269 ";
80270 
80271 %feature("docstring")  casadi::Smoothing::n_pert() const  "
80272 
80273 [INTERNAL] ";
80274 
80275 %feature("docstring")  casadi::FunctionInternal::export_code(const
80276 std::string &lang, std::ostream &stream, const Dict &options) const  "
80277 
80278 [INTERNAL]  Export function in a specific language.
80279 
80280 ";
80281 
80282 %feature("docstring")  casadi::FunctionInternal::tocache(const Function &f,
80283 const std::string &suffix="") const  "
80284 
80285 [INTERNAL]  Save function to cache.
80286 
80287 ";
80288 
80289 %feature("docstring")  casadi::ProtoFunction::print_time(const std::map<
80290 std::string, FStats > &fstats) const  "
80291 
80292 [INTERNAL]  Print timing statistics.
80293 
80294 ";
80295 
80296 %feature("docstring")  casadi::FunctionInternal::mx_in(casadi_int ind) const
80297 "
80298 
80299 [INTERNAL]  Get function input(s) and output(s)
80300 
80301 ";
80302 
80303 %feature("docstring")  casadi::FunctionInternal::mx_in() const  "
80304 
80305 [INTERNAL]  Get function input(s) and output(s)
80306 
80307 ";
80308 
80309 %feature("docstring")  casadi::FunctionInternal::slice(const std::string
80310 &name, const std::vector< casadi_int > &order_in, const std::vector<
80311 casadi_int > &order_out, const Dict &opts) const  "
80312 
80313 [INTERNAL]  returns a new function with a selection of inputs/outputs of the
80314 original
80315 
80316 ";
80317 
80318 %feature("docstring")
80319 casadi::FunctionInternal::codegen_sparsities(CodeGenerator &g) const  "
80320 
80321 [INTERNAL]  Codegen sparsities.
80322 
80323 ";
80324 
80325 %feature("docstring") casadi::Smoothing::~Smoothing "
80326 
80327 [INTERNAL]  Destructor.
80328 
80329 ";
80330 
80331 %feature("docstring")  casadi::Smoothing::get_abstol() const  "
80332 
80333 [INTERNAL]  Get absolute tolerance.
80334 
80335 ";
80336 
80337 %feature("docstring")  casadi::FunctionInternal::instructions_sx() const  "
80338 
80339 [INTERNAL]  get SX expression associated with instructions
80340 
80341 ";
80342 
80343 %feature("docstring")  casadi::Smoothing::has_forward(casadi_int nfwd) const
80344 "
80345 
80346 [INTERNAL]  Second order derivatives.
80347 
80348 ";
80349 
80350 %feature("docstring")  casadi::Smoothing::calc_stepsize(double abstol) const
80351 "
80352 
80353 [INTERNAL] ";
80354 
80355 %feature("docstring")  casadi::FunctionInternal::alloc_res(size_t sz_res,
80356 bool persistent=false) "
80357 
80358 [INTERNAL]  Ensure required length of res field.
80359 
80360 ";
80361 
80362 %feature("docstring")  casadi::FunctionInternal::alloc_arg(size_t sz_arg,
80363 bool persistent=false) "
80364 
80365 [INTERNAL]  Ensure required length of arg field.
80366 
80367 ";
80368 
80369 %feature("docstring")  casadi::FunctionInternal::convert_arg(const
80370 std::vector< M > &arg) const  "
80371 
80372 [INTERNAL]  Convert from/to input/output lists/map.
80373 
80374 ";
80375 
80376 %feature("docstring")  casadi::FunctionInternal::convert_arg(const std::map<
80377 std::string, M > &arg) const  "
80378 
80379 [INTERNAL]  Convert from/to input/output lists/map.
80380 
80381 ";
80382 
80383 %feature("docstring")  casadi::FunctionInternal::alloc_w(size_t sz_w, bool
80384 persistent=false) "
80385 
80386 [INTERNAL]  Ensure required length of w field.
80387 
80388 ";
80389 
80390 %feature("docstring")  casadi::FunctionInternal::codegen_name(const
80391 CodeGenerator &g, bool ns=true) const  "
80392 
80393 [INTERNAL]  Get name in codegen.
80394 
80395 ";
80396 
80397 %feature("docstring")  casadi::FunctionInternal::sz_w() const  "
80398 
80399 [INTERNAL]  Get required length of w field.
80400 
80401 ";
80402 
80403 %feature("docstring")
80404 casadi::FunctionInternal::instruction_output(casadi_int k) const  "
80405 
80406 [INTERNAL]  Get the (integer) output argument of an atomic operation.
80407 
80408 ";
80409 
80410 %feature("docstring")  casadi::FunctionInternal::get_jacobian_sparsity()
80411 const  "
80412 
80413 [INTERNAL]  Get Jacobian sparsity.
80414 
80415 ";
80416 
80417 %feature("docstring")  casadi::FunctionInternal::oracle() const  "
80418 
80419 [INTERNAL]  Get oracle.
80420 
80421 ";
80422 
80423 %feature("docstring")  casadi::FunctionInternal::sp_weight() const  "
80424 
80425 [INTERNAL]  Weighting factor for chosing forward/reverse mode, sparsity
80426 propagation.
80427 
80428 ";
80429 
80430 %feature("docstring")
80431 casadi::FunctionInternal::getJacSparsityGen(casadi_int iind, casadi_int
80432 oind, bool symmetric, casadi_int gr_i=1, casadi_int gr_o=1) const  "
80433 
80434 [INTERNAL]  Get the sparsity pattern, forward mode.
80435 
80436 ";
80437 
80438 %feature("docstring")  casadi::FunctionInternal::getAdaptorSolverName()
80439 const  "
80440 
80441 [INTERNAL]  Obtain solver name from Adaptor.
80442 
80443 ";
80444 
80445 %feature("docstring")  casadi::FunctionInternal::get_min_in(casadi_int ind)
80446 const  "
80447 
80448 [INTERNAL]  Get smallest input value.
80449 
80450 ";
80451 
80452 %feature("docstring")  casadi::FunctionInternal::factory(const std::string
80453 &name, const std::vector< std::string > &s_in, const std::vector<
80454 std::string > &s_out, const Function::AuxOut &aux, const Dict &opts) const
80455 "
80456 
80457 [INTERNAL] ";
80458 
80459 %feature("docstring")
80460 casadi::FunctionInternal::codegen_decref(CodeGenerator &g) const  "
80461 
80462 [INTERNAL]  Codegen decref for dependencies.
80463 
80464 ";
80465 
80466 
80467 // File: classcasadi_1_1Solve.xml
80468 
80469 
80470 // File: classcasadi_1_1SparseStorage.xml
80471 %feature("docstring")  casadi::SparseStorage< DataType >::has_nz(casadi_int
80472 rr, casadi_int cc) const  "
80473 
80474 [INTERNAL]  Returns true if the matrix has a non-zero at location rr, cc.
80475 
80476 ";
80477 
80478 %feature("docstring")  casadi::SparseStorage< DataType >::elem(casadi_int
80479 rr, casadi_int cc) "
80480 
80481 [INTERNAL]  get a reference to an element
80482 
80483 ";
80484 
80485 %feature("docstring")  casadi::SparseStorage< DataType >::clear() "
80486 
80487 [INTERNAL] ";
80488 
80489 %feature("docstring")  casadi::SparseStorage< DataType >::reserve(casadi_int
80490 nnz) "
80491 
80492 [INTERNAL] ";
80493 
80494 %feature("docstring")  casadi::SparseStorage< DataType >::reserve(casadi_int
80495 nnz, casadi_int ncol) "
80496 
80497 [INTERNAL] ";
80498 
80499 %feature("docstring")  casadi::SparseStorage< DataType >::resize(casadi_int
80500 nrow, casadi_int ncol) "
80501 
80502 [INTERNAL] ";
80503 
80504 %feature("docstring") casadi::SparseStorage "
80505 
80506 [INTERNAL] C++ includes: sparse_storage.hpp ";
80507 
80508 %feature("docstring")  casadi::SparseStorage< DataType >::sparsity() const
80509 "
80510 
80511 [INTERNAL]  Const access the sparsity - reference to data member.
80512 
80513 ";
80514 
80515 %feature("docstring") casadi::casadi_sparsity "
80516 
80517 Const access the sparsity - reference to data member.
80518 
80519 ";
80520 
80521 %feature("docstring")  casadi::SparseStorage< DataType >::casadi_sparsity "
80522 
80523 Const access the sparsity - reference to data member.
80524 
80525 ";
80526 
80527 %feature("docstring") casadi::SparseStorage< DataType >::SparseStorage(const
80528 Sparsity &sparsity, const DataType &val=DataType(0)) "
80529 
80530 [INTERNAL]  Sparse matrix with a given sparsity
80531 
80532 ";
80533 
80534 %feature("docstring") casadi::SparseStorage< DataType >::SparseStorage() "
80535 
80536 [INTERNAL]  constructors
80537 
80538 empty 0-by-0 matrix constructor
80539 
80540 ";
80541 
80542 %feature("docstring") casadi::SparseStorage< DataType >::SparseStorage(const
80543 SparseStorage< DataType > &m) "
80544 
80545 [INTERNAL]  Copy constructor.
80546 
80547 ";
80548 
80549 %feature("docstring")  casadi::SparseStorage< DataType >::nonzeros() "
80550 
80551 [INTERNAL]  Access the non-zero elements.
80552 
80553 ";
80554 
80555 %feature("docstring")  casadi::SparseStorage< DataType >::nonzeros() const
80556 "
80557 
80558 [INTERNAL]  Const access the non-zero elements.
80559 
80560 ";
80561 
80562 
80563 // File: classcasadi_1_1Sparsify.xml
80564 
80565 
80566 // File: classcasadi_1_1Sparsity.xml
80567 
80568 
80569 /*  Check if two sparsity patterns are identical  */
80570 
80571 /*  Size and element counting  */ %feature("docstring")
80572 casadi::Sparsity::enlargeRows(casadi_int nrow, const std::vector< casadi_int
80573 > &rr, bool ind1=false) "
80574 
80575 Enlarge the matrix along the first dimension (i.e. insert rows)
80576 
80577 ";
80578 
80579 %feature("docstring") casadi::Sparsity "
80580 
80581 General sparsity class.
80582 
80583 The storage format is a compressed column storage (CCS) format.  In this
80584 format, the structural non-zero elements are stored in column-major order,
80585 starting from the upper left corner of the matrix and ending in the lower
80586 right corner.
80587 
80588 In addition to the dimension ( size1(), size2()), (i.e. the number of rows
80589 and the number of columns respectively), there are also two vectors of
80590 integers:
80591 
80592 \"colind\" [length size2()+1], which contains the index to the first non-
80593 zero element on or after the corresponding column. All the non-zero elements
80594 of a particular i are thus the elements with index el that fulfills:
80595 colind[i] <= el < colind[i+1].
80596 
80597 \"row\" [same length as the number of non-zero elements, nnz()] The rows for
80598 each of the structural non-zeros.
80599 
80600 Note that with this format, it is cheap to loop over all the non-zero
80601 elements of a particular column, at constant time per element, but expensive
80602 to jump to access a location (i, j).
80603 
80604 If the matrix is dense, i.e. length(row) == size1()*size2(), the format
80605 reduces to standard dense column major format, which allows access to an
80606 arbitrary element in constant time.
80607 
80608 Since the object is reference counted (it inherits from SharedObject),
80609 several matrices are allowed to share the same sparsity pattern.
80610 
80611 The implementations of methods marked as such in this class has been taken
80612 from the CSparse package and modified to fit CasADi data structures and
80613 separation of sparsity pattern calculation and numerical evaluation. These
80614 functions are Copyright(c) Timothy A. Davis, 2006-2009 and licensed as a
80615 derivative work under the GNU LGPL
80616 
80617 See:   Matrix
80618 
80619 Joel Andersson
80620 
80621 C++ includes: sparsity.hpp ";
80622 
80623 %feature("docstring")  casadi::Sparsity::largest_first() const  "
80624 
80625 Order the columns by decreasing degree.
80626 
80627 ";
80628 
80629 %feature("docstring")  casadi::Sparsity::dim(bool with_nz=false) const  "
80630 
80631 Get the dimension as a string.
80632 
80633 ";
80634 
80635 %feature("docstring")  casadi::Sparsity::is_reshape(const Sparsity &y) const
80636 "
80637 
80638 Check if the sparsity is a reshape of another.
80639 
80640 ";
80641 
80642 %feature("docstring")  casadi::Sparsity::add_nz(casadi_int rr, casadi_int
80643 cc) "
80644 
80645 Get the index of a non-zero element Add the element if it does not exist and
80646 copy object if it's not unique.
80647 
80648 ";
80649 
80650 %feature("docstring")  casadi::Sparsity::is_scalar(bool
80651 scalar_and_dense=false) const  "
80652 
80653 Is scalar?
80654 
80655 ";
80656 
80657 %feature("docstring")  casadi::Sparsity::rowsSequential(bool strictly=true)
80658 const  "
80659 
80660 Do the rows appear sequentially on each column.
80661 
80662 Parameters:
80663 -----------
80664 
80665 strictly:  if true, then do not allow multiple entries
80666 
80667 ";
80668 
80669 %feature("docstring")  casadi::Sparsity::get_diag(std::vector< casadi_int >
80670 &output_mapping) const  "
80671 
80672 Get the diagonal of the matrix/create a diagonal matrix (mapping will
80673 contain the nonzero mapping) When the input is square, the diagonal elements
80674 are returned. If the input is vector-like, a diagonal matrix is constructed
80675 with it.
80676 
80677 ";
80678 
80679 %feature("docstring")  casadi::Sparsity::btf(std::vector< casadi_int >
80680 &output_rowperm, std::vector< casadi_int > &output_colperm, std::vector<
80681 casadi_int > &output_rowblock, std::vector< casadi_int > &output_colblock,
80682 std::vector< casadi_int > &output_coarse_rowblock, std::vector< casadi_int >
80683 &output_coarse_colblock) const  "
80684 
80685 Calculate the block triangular form (BTF) See Direct Methods for Sparse
80686 Linear Systems by Davis (2006).
80687 
80688 The function computes the Dulmage-Mendelsohn decomposition, which allows you
80689 to reorder the rows and columns of a matrix to bring it into block
80690 triangular form (BTF).
80691 
80692 It will not consider the distance of off-diagonal elements to the diagonal:
80693 there is no guarantee you will get a block-diagonal matrix if you supply a
80694 randomly permuted block-diagonal matrix.
80695 
80696 If your matrix is symmetrical, this method is of limited use; permutation
80697 can make it non-symmetric.
80698 
80699 See:   scc  The implementation is a modified version of cs_dmperm in CSparse
80700 Copyright(c) Timothy A. Davis, 2006-2009 Licensed as a derivative work under
80701 the GNU LGPL
80702 
80703 ";
80704 
80705 %feature("docstring")  casadi::Sparsity::is_triu() const  "
80706 
80707 Is upper triangular?
80708 
80709 ";
80710 
80711 %feature("docstring")  casadi::Sparsity::qr_sparse(Sparsity &output_V,
80712 Sparsity &output_R, std::vector< casadi_int > &output_prinv, std::vector<
80713 casadi_int > &output_pc, bool amd=true) const  "
80714 
80715 Symbolic QR factorization Returns the sparsity pattern of V (compact
80716 representation of Q) and R as well as vectors needed for the numerical
80717 factorization and solution. The implementation is a modified version of
80718 CSparse Copyright(c) Timothy A. Davis, 2006-2009 Licensed as a derivative
80719 work under the GNU LGPL.
80720 
80721 ";
80722 
80723 %feature("docstring") casadi::casadi_qr_sparse "
80724 
80725 Symbolic QR factorization Returns the sparsity pattern of V (compact
80726 representation of Q) and R as well as vectors needed for the numerical
80727 factorization and solution. The implementation is a modified version of
80728 CSparse Copyright(c) Timothy A. Davis, 2006-2009 Licensed as a derivative
80729 work under the GNU LGPL.
80730 
80731 ";
80732 
80733 %feature("docstring")  casadi::Sparsity::casadi_qr_sparse "
80734 
80735 Symbolic QR factorization Returns the sparsity pattern of V (compact
80736 representation of Q) and R as well as vectors needed for the numerical
80737 factorization and solution. The implementation is a modified version of
80738 CSparse Copyright(c) Timothy A. Davis, 2006-2009 Licensed as a derivative
80739 work under the GNU LGPL.
80740 
80741 ";
80742 
80743 %feature("docstring")  casadi::Sparsity::is_vector() const  "
80744 
80745 Check if the pattern is a row or column vector.
80746 
80747 ";
80748 
80749 %feature("docstring")  casadi::Sparsity::resize(casadi_int nrow, casadi_int
80750 ncol) "
80751 
80752 Resize.
80753 
80754 ";
80755 
80756 %feature("docstring")  casadi::SharedObject::disp(std::ostream &stream, bool
80757 more=false) const  "
80758 
80759 Print a description of the object.
80760 
80761 ";
80762 
80763 %feature("docstring")  casadi::Sparsity::find(bool ind1=false) const  "
80764 
80765 Get the location of all non-zero elements as they would appear in a Dense
80766 matrix A : DenseMatrix 4 x 3 B : SparseMatrix 4 x 3 , 5 structural non-
80767 zeros.
80768 
80769 k = A.find() A[k] will contain the elements of A that are non-zero in B
80770 
80771 Inverse of nonzeros.
80772 
80773 ";
80774 
80775 %feature("docstring") casadi::casadi_find "
80776 
80777 Get the location of all non-zero elements as they would appear in a Dense
80778 matrix A : DenseMatrix 4 x 3 B : SparseMatrix 4 x 3 , 5 structural non-
80779 zeros.
80780 
80781 k = A.find() A[k] will contain the elements of A that are non-zero in B
80782 
80783 Inverse of nonzeros.
80784 
80785 ";
80786 
80787 %feature("docstring")  casadi::Sparsity::casadi_find "
80788 
80789 Get the location of all non-zero elements as they would appear in a Dense
80790 matrix A : DenseMatrix 4 x 3 B : SparseMatrix 4 x 3 , 5 structural non-
80791 zeros.
80792 
80793 k = A.find() A[k] will contain the elements of A that are non-zero in B
80794 
80795 Inverse of nonzeros.
80796 
80797 ";
80798 
80799 %feature("docstring")  casadi::Sparsity::nnz_diag() const  "
80800 
80801 Number of non-zeros on the diagonal, i.e. the number of elements (i, j) with
80802 j==i.
80803 
80804 ";
80805 
80806 %feature("docstring")  casadi::Sparsity::bw_lower() const  "
80807 
80808 Lower half-bandwidth.
80809 
80810 ";
80811 
80812 %feature("docstring")  casadi::Sparsity::T() const  "
80813 
80814 Transpose the matrix.
80815 
80816 ";
80817 
80818 %feature("docstring")  casadi::Sparsity::repr_el(casadi_int k) const  "
80819 
80820 Describe the nonzero location k as a string.
80821 
80822 ";
80823 
80824 %feature("docstring") casadi::Sparsity::Sparsity(casadi_int dummy=0) "
80825 
80826 Default constructor.
80827 
80828 ";
80829 
80830 %feature("docstring") casadi::Sparsity::Sparsity(casadi_int nrow, casadi_int
80831 ncol) "
80832 
80833 Pattern with all structural zeros.
80834 
80835 ";
80836 
80837 %feature("docstring") casadi::Sparsity::Sparsity(casadi_int nrow, casadi_int
80838 ncol, const std::vector< casadi_int > &colind, const std::vector< casadi_int
80839 > &row, bool order_rows=false) "
80840 
80841 Construct from sparsity pattern vectors given in compressed column storage
80842 format.
80843 
80844 ";
80845 
80846 %feature("docstring") casadi::Sparsity::Sparsity(const std::pair<
80847 casadi_int, casadi_int > &rc) "
80848 
80849 Create a sparse matrix with all structural zeros.
80850 
80851 ";
80852 
80853 %feature("docstring")  casadi::Sparsity::to_file(const std::string
80854 &filename, const std::string &format_hint="") const  "
80855 
80856 Export sparsity pattern to file
80857 
80858 Supported formats: .mtx Matrix Market
80859 
80860 ";
80861 
80862 %feature("docstring")  casadi::Sparsity::colind(casadi_int cc) const  "
80863 
80864 Get a reference to the colindex of column cc (see class description)
80865 
80866 ";
80867 
80868 %feature("docstring")  casadi::Sparsity::is_stacked(const Sparsity &y,
80869 casadi_int n) const  "
80870 
80871 Check if pattern is horizontal repeat of another.
80872 
80873 ";
80874 
80875 %feature("docstring")  casadi::Sparsity::is_row() const  "
80876 
80877 Check if the pattern is a row vector (i.e. size1()==1)
80878 
80879 ";
80880 
80881 %feature("docstring")  casadi::Sparsity::numel() const  "
80882 
80883 The total number of elements, including structural zeros, i.e.
80884 size2()*size1() Beware of overflow.
80885 
80886 See:   nnz()
80887 
80888 ";
80889 
80890 %feature("docstring")  casadi::Sparsity::columns() const  "
80891 
80892 Get the number of columns, Octave-style syntax.
80893 
80894 ";
80895 
80896 %feature("docstring")  casadi::Sparsity::unite(const Sparsity &y) const  "
80897 
80898 Union of two sparsity patterns.
80899 
80900 ";
80901 
80902 %feature("docstring") casadi::casadi_unite "
80903 
80904 Union of two sparsity patterns.
80905 
80906 ";
80907 
80908 %feature("docstring")  casadi::Sparsity::casadi_unite "
80909 
80910 Union of two sparsity patterns.
80911 
80912 ";
80913 
80914 %feature("docstring")  casadi::Sparsity::is_transpose(const Sparsity &y)
80915 const  "
80916 
80917 Check if the sparsity is the transpose of another.
80918 
80919 ";
80920 
80921 %feature("docstring")  casadi::Sparsity::get_triplet(std::vector< casadi_int
80922 > &output_row, std::vector< casadi_int > &output_col) const  "
80923 
80924 Get the sparsity in sparse triplet format.
80925 
80926 ";
80927 
80928 %feature("docstring")  casadi::Sparsity::is_square() const  "
80929 
80930 Is square?
80931 
80932 ";
80933 
80934 %feature("docstring")  casadi::Sparsity::appendColumns(const Sparsity &sp) "
80935 
80936 Append another sparsity patten horizontally.
80937 
80938 ";
80939 
80940 %feature("docstring")  casadi::Sparsity::ldl(std::vector< casadi_int >
80941 &output_p, bool amd=true) const  "
80942 
80943 Symbolic LDL factorization Returns the sparsity pattern of L^T.
80944 
80945 The implementation is a modified version of LDL Copyright(c) Timothy A.
80946 Davis, 2005-2013 Licensed as a derivative work under the GNU LGPL
80947 
80948 ";
80949 
80950 %feature("docstring") casadi::casadi_ldl "
80951 
80952 Symbolic LDL factorization Returns the sparsity pattern of L^T.
80953 
80954 The implementation is a modified version of LDL Copyright(c) Timothy A.
80955 Davis, 2005-2013 Licensed as a derivative work under the GNU LGPL
80956 
80957 ";
80958 
80959 %feature("docstring")  casadi::Sparsity::casadi_ldl "
80960 
80961 Symbolic LDL factorization Returns the sparsity pattern of L^T.
80962 
80963 The implementation is a modified version of LDL Copyright(c) Timothy A.
80964 Davis, 2005-2013 Licensed as a derivative work under the GNU LGPL
80965 
80966 ";
80967 
80968 %feature("docstring")  casadi::Sparsity::get_ccs(std::vector< casadi_int >
80969 &output_colind, std::vector< casadi_int > &output_row) const  "
80970 
80971 Get the sparsity in compressed column storage (CCS) format.
80972 
80973 ";
80974 
80975 %feature("docstring")  casadi::Sparsity::removeDuplicates(std::vector<
80976 casadi_int > &INOUT) "
80977 
80978 Remove duplicate entries.
80979 
80980 The same indices will be removed from the mapping vector, which must have
80981 the same length as the number of nonzeros
80982 
80983 ";
80984 
80985 %feature("docstring")  casadi::Sparsity::is_empty(bool both=false) const  "
80986 
80987 Check if the sparsity is empty.
80988 
80989 A sparsity is considered empty if one of the dimensions is zero (or
80990 optionally both dimensions)
80991 
80992 ";
80993 
80994 %feature("docstring")  casadi::Sparsity::export_code(const std::string
80995 &lang, std::ostream &stream=casadi::uout(), const Dict &options=Dict())
80996 const  "
80997 
80998 Export matrix in specific language.
80999 
81000 lang: only 'matlab' supported for now
81001 
81002 ::
81003 
81004    * options:
81005    *   inline: Indicates if you want everything on a single line (default: False)
81006    *   name: Name of exported variable (default: 'sp')
81007    *   as_matrix: Matlab does not have a sparsity object. (default: false)
81008   *               With this option true, a numeric matrix will be constructed
81009    *
81010 
81011 
81012 
81013 ";
81014 
81015 %feature("docstring")  casadi::SharedObject::get_str(bool more=false) const
81016 "
81017 
81018 Get string representation.
81019 
81020 ";
81021 
81022 %feature("docstring")  casadi::Sparsity::makeDense(std::vector< casadi_int >
81023 &output_mapping) const  "
81024 
81025 Make a patten dense.
81026 
81027 ";
81028 
81029 %feature("docstring")  casadi::Sparsity::pattern_inverse() const  "
81030 
81031 Take the inverse of a sparsity pattern; flip zeros and non-zeros.
81032 
81033 ";
81034 
81035 %feature("docstring")  casadi::Sparsity::dense(casadi_int nrow, casadi_int
81036 ncol=1) "
81037 
81038 Create a dense rectangular sparsity pattern.
81039 
81040 ";
81041 
81042 %feature("docstring")  casadi::Sparsity::dense(const std::pair< casadi_int,
81043 casadi_int > &rc) "
81044 
81045 Create a dense rectangular sparsity pattern.
81046 
81047 ";
81048 
81049 %feature("docstring")  casadi::Sparsity::spy_matlab(const std::string
81050 &mfile) const  "
81051 
81052 Generate a script for Matlab or Octave which visualizes the sparsity using
81053 the spy command.
81054 
81055 ";
81056 
81057 %feature("docstring")  casadi::Sparsity::diag(casadi_int nrow) "
81058 
81059 Create diagonal sparsity pattern.
81060 
81061 ";
81062 
81063 %feature("docstring") casadi::casadi_diag "
81064 
81065 Create diagonal sparsity pattern.
81066 
81067 ";
81068 
81069 %feature("docstring")  casadi::Sparsity::casadi_diag "
81070 
81071 Create diagonal sparsity pattern.
81072 
81073 ";
81074 
81075 %feature("docstring")  casadi::Sparsity::diag(casadi_int nrow, casadi_int
81076 ncol) "
81077 
81078 Create diagonal sparsity pattern.
81079 
81080 ";
81081 
81082 %feature("docstring") casadi::casadi_diag "
81083 
81084 Create diagonal sparsity pattern.
81085 
81086 ";
81087 
81088 %feature("docstring")  casadi::Sparsity::casadi_diag "
81089 
81090 Create diagonal sparsity pattern.
81091 
81092 ";
81093 
81094 %feature("docstring")  casadi::Sparsity::diag(const std::pair< casadi_int,
81095 casadi_int > &rc) "
81096 
81097 Create diagonal sparsity pattern.
81098 
81099 ";
81100 
81101 %feature("docstring") casadi::casadi_diag "
81102 
81103 Create diagonal sparsity pattern.
81104 
81105 ";
81106 
81107 %feature("docstring")  casadi::Sparsity::casadi_diag "
81108 
81109 Create diagonal sparsity pattern.
81110 
81111 ";
81112 
81113 %feature("docstring")  casadi::SharedObject::print_ptr(std::ostream
81114 &stream=casadi::uout()) const  "
81115 
81116 [INTERNAL]  Print the pointer to the internal class
81117 
81118 ";
81119 
81120 %feature("docstring")  casadi::Sparsity::get_crs(std::vector< casadi_int >
81121 &output_rowind, std::vector< casadi_int > &output_col) const  "
81122 
81123 Get the sparsity in compressed row storage (CRS) format.
81124 
81125 ";
81126 
81127 %feature("docstring")  casadi::Sparsity::serialize() const  "
81128 
81129 Serialize.
81130 
81131 ";
81132 
81133 %feature("docstring")  casadi::Sparsity::serialize(SerializingStream &s)
81134 const  "
81135 
81136 Serialize an object.
81137 
81138 ";
81139 
81140 %feature("docstring")  casadi::Sparsity::sub(const std::vector< casadi_int >
81141 &rr, const std::vector< casadi_int > &cc, std::vector< casadi_int >
81142 &output_mapping, bool ind1=false) const  "
81143 
81144 Get a submatrix.
81145 
81146 Returns the sparsity of the submatrix, with a mapping such that submatrix[k]
81147 = originalmatrix[mapping[k]]
81148 
81149 ";
81150 
81151 %feature("docstring")  casadi::Sparsity::sub(const std::vector< casadi_int >
81152 &rr, const Sparsity &sp, std::vector< casadi_int > &output_mapping, bool
81153 ind1=false) const  "
81154 
81155 Get a set of elements.
81156 
81157 Returns the sparsity of the corresponding elements, with a mapping such that
81158 submatrix[k] = originalmatrix[mapping[k]]
81159 
81160 ";
81161 
81162 %feature("docstring")  casadi::Sparsity::unit(casadi_int n, casadi_int el) "
81163 
81164 Create the sparsity pattern for a unit vector of length n and a nonzero on
81165 position el.
81166 
81167 ";
81168 
81169 %feature("docstring")  casadi::SharedObject::is_null() const  "
81170 
81171 Is a null pointer?
81172 
81173 ";
81174 
81175 %feature("docstring")  casadi::Sparsity::append(const Sparsity &sp) "
81176 
81177 Append another sparsity patten vertically (NOTE: only efficient if vector)
81178 
81179 ";
81180 
81181 %feature("docstring")  casadi::Sparsity::combine(const Sparsity &y, bool
81182 f0x_is_zero, bool function0_is_zero) const  "
81183 
81184 Combine two sparsity patterns Returns the new sparsity pattern as well as a
81185 mapping with the same length as the number of non-zero elements The mapping
81186 matrix contains the arguments for each nonzero, the first bit indicates if
81187 the first argument is nonzero, the second bit indicates if the second
81188 argument is nonzero (note that none of, one of or both of the arguments can
81189 be nonzero)
81190 
81191 ";
81192 
81193 %feature("docstring")  casadi::Sparsity::nnz() const  "
81194 
81195 Get the number of (structural) non-zeros.
81196 
81197 See:   numel()
81198 
81199 ";
81200 
81201 %feature("docstring")  casadi::Sparsity::intersect(const Sparsity &y) const
81202 "
81203 
81204 Intersection of two sparsity patterns Returns the new sparsity pattern as
81205 well as a mapping with the same length as the number of non-zero elements
81206 The value is 1 if the non-zero comes from the first (i.e. this) object, 2 if
81207 it is from the second and 3 (i.e. 1 | 2) if from both.
81208 
81209 ";
81210 
81211 %feature("docstring")  casadi::Sparsity::row(casadi_int el) const  "
81212 
81213 Get the row of a non-zero element.
81214 
81215 ";
81216 
81217 %feature("docstring")  casadi::Sparsity::is_column() const  "
81218 
81219 Check if the pattern is a column vector (i.e. size2()==1)
81220 
81221 ";
81222 
81223 %feature("docstring")  casadi::Sparsity::get_colind() const  "
81224 
81225 Get the column index for each column Together with the row-vector, one
81226 obtains the sparsity pattern in the column compressed format.
81227 
81228 ";
81229 
81230 %feature("docstring")  casadi::Sparsity::get_row() const  "
81231 
81232 Get the row for each non-zero entry Together with the column-vector, this
81233 vector gives the sparsity of the matrix in sparse triplet format, and
81234 together with the colind vector, one obtains the sparsity in column
81235 compressed format.
81236 
81237 ";
81238 
81239 %feature("docstring")  casadi::Sparsity::is_symmetric() const  "
81240 
81241 Is symmetric?
81242 
81243 ";
81244 
81245 %feature("docstring")  casadi::Sparsity::is_subset(const Sparsity &rhs)
81246 const  "
81247 
81248 Is subset?
81249 
81250 ";
81251 
81252 %feature("docstring")  casadi::Sparsity::has_nz(casadi_int rr, casadi_int
81253 cc) const  "
81254 
81255 Returns true if the pattern has a non-zero at location rr, cc.
81256 
81257 ";
81258 
81259 %feature("docstring")  casadi::Sparsity::transpose(std::vector< casadi_int >
81260 &output_mapping, bool invert_mapping=false) const  "
81261 
81262 Transpose the matrix and get the reordering of the non-zero entries.
81263 
81264 Parameters:
81265 -----------
81266 
81267 mapping:  the non-zeros of the original matrix for each non-zero of the new
81268 matrix
81269 
81270 ";
81271 
81272 %feature("docstring") casadi::casadi_transpose "
81273 
81274 Transpose the matrix and get the reordering of the non-zero entries.
81275 
81276 Parameters:
81277 -----------
81278 
81279 mapping:  the non-zeros of the original matrix for each non-zero of the new
81280 matrix
81281 
81282 ";
81283 
81284 %feature("docstring")  casadi::Sparsity::casadi_transpose "
81285 
81286 Transpose the matrix and get the reordering of the non-zero entries.
81287 
81288 Parameters:
81289 -----------
81290 
81291 mapping:  the non-zeros of the original matrix for each non-zero of the new
81292 matrix
81293 
81294 ";
81295 
81296 %feature("docstring")  casadi::Sparsity::pmult(const std::vector< casadi_int
81297 > &p, bool permute_rows=true, bool permute_columns=true, bool
81298 invert_permutation=false) const  "
81299 
81300 Permute rows and/or columns Multiply the sparsity with a permutation matrix
81301 from the left and/or from the right P * A * trans(P), A * trans(P) or A *
81302 trans(P) with P defined by an index vector containing the row for each col.
81303 As an alternative, P can be transposed (inverted).
81304 
81305 ";
81306 
81307 %feature("docstring")  casadi::Sparsity::is_diag() const  "
81308 
81309 Is diagonal?
81310 
81311 ";
81312 
81313 %feature("docstring")  casadi::Sparsity::amd() const  "
81314 
81315 Approximate minimal degree preordering Fill-reducing ordering applied to the
81316 sparsity pattern of a linear system prior to factorization. The system must
81317 be symmetric, for an unsymmetric matrix A, first form the square of the
81318 pattern, A'*A.
81319 
81320 The implementation is a modified version of cs_amd in CSparse Copyright(c)
81321 Timothy A. Davis, 2006-2009 Licensed as a derivative work under the GNU LGPL
81322 
81323 ";
81324 
81325 %feature("docstring")  casadi::SharedObject::class_name() const  "
81326 
81327 Get class name.
81328 
81329 ";
81330 
81331 %feature("docstring")  casadi::Sparsity::nnz_lower(bool strictly=false)
81332 const  "
81333 
81334 Number of non-zeros in the lower triangular half, i.e. the number of
81335 elements (i, j) with j<=i.
81336 
81337 ";
81338 
81339 %feature("docstring")  casadi::Sparsity::get_lower() const  "
81340 
81341 Get nonzeros in lower triangular part.
81342 
81343 ";
81344 
81345 %feature("docstring")  casadi::Sparsity::is_singular() const  "
81346 
81347 Check whether the sparsity-pattern indicates structural singularity.
81348 
81349 ";
81350 
81351 %feature("docstring")  casadi::Sparsity::is_dense() const  "
81352 
81353 Is dense?
81354 
81355 ";
81356 
81357 %feature("docstring")  casadi::Sparsity::sanity_check(bool complete=false)
81358 const  "
81359 
81360 [DEPRECATED] Correctness of sparsity patterns are checked during
81361 construction
81362 
81363 ";
81364 
81365 %feature("docstring")  casadi::Sparsity::compressed(const std::vector<
81366 casadi_int > &v, bool order_rows=false) "
81367 
81368 Create from a single vector containing the pattern in compressed column
81369 storage format: The format: The first two entries are the number of rows
81370 (nrow) and columns (ncol) The next ncol+1 entries are the column offsets
81371 (colind). Note that the last element, colind[ncol], gives the number of
81372 nonzeros The last colind[ncol] entries are the row indices
81373 
81374 ";
81375 
81376 %feature("docstring")  casadi::Sparsity::uni_coloring(const Sparsity
81377 &AT=Sparsity(), casadi_int cutoff=std::numeric_limits< casadi_int >::max())
81378 const  "
81379 
81380 Perform a unidirectional coloring: A greedy distance-2 coloring algorithm
81381 (Algorithm 3.1 in A. H. GEBREMEDHIN, F. MANNE, A. POTHEN)
81382 
81383 ";
81384 
81385 %feature("docstring")  casadi::Sparsity::star_coloring(casadi_int
81386 ordering=1, casadi_int cutoff=std::numeric_limits< casadi_int >::max())
81387 const  "
81388 
81389 Perform a star coloring of a symmetric matrix: A greedy distance-2 coloring
81390 algorithm Algorithm 4.1 in What Color Is Your Jacobian? Graph Coloring for
81391 Computing Derivatives A. H. GEBREMEDHIN, F. MANNE, A. POTHEN SIAM Rev.,
81392 47(4), 629705 (2006)
81393 
81394 Ordering options: None (0), largest first (1)
81395 
81396 ";
81397 
81398 %feature("docstring")  casadi::Sparsity::density() const  "
81399 
81400 The percentage of nonzero Equivalent to (100.0 * nnz())/numel(), but avoids
81401 overflow.
81402 
81403 ";
81404 
81405 %feature("docstring")  casadi::Sparsity::enlarge(casadi_int nrow, casadi_int
81406 ncol, const std::vector< casadi_int > &rr, const std::vector< casadi_int >
81407 &cc, bool ind1=false) "
81408 
81409 Enlarge matrix Make the matrix larger by inserting empty rows and columns,
81410 keeping the existing non-zeros.
81411 
81412 For the matrices A to B A(m, n) length(jj)=m , length(ii)=n B(nrow, ncol)
81413 
81414 A=enlarge(m, n, ii, jj) makes sure that
81415 
81416 B[jj, ii] == A
81417 
81418 ";
81419 
81420 %feature("docstring")  casadi::Sparsity::compress() const  "
81421 
81422 Compress a sparsity pattern.
81423 
81424 ";
81425 
81426 %feature("docstring")  casadi::Sparsity::scc(std::vector< casadi_int >
81427 &output_index, std::vector< casadi_int > &output_offset) const  "
81428 
81429 Find the strongly connected components of the bigraph defined by the
81430 sparsity pattern of a square matrix.
81431 
81432 See Direct Methods for Sparse Linear Systems by Davis (2006). Returns:
81433 Number of components
81434 
81435 Offset for each components (length: 1 + number of components)
81436 
81437 Indices for each components, component i has indices index[offset[i]], ...,
81438 index[offset[i+1]]
81439 
81440 In the case that the matrix is symmetric, the result has a particular
81441 interpretation: Given a symmetric matrix A and n = A.scc(p, r)
81442 
81443 => A[p, p] will appear block-diagonal with n blocks and with the indices of
81444 the block boundaries to be found in r.
81445 
81446 The implementation is a modified version of cs_scc in CSparse Copyright(c)
81447 Timothy A. Davis, 2006-2009 Licensed as a derivative work under the GNU LGPL
81448 
81449 ";
81450 
81451 %feature("docstring")  casadi::Sparsity::info() const  "
81452 
81453 Obtain information about sparsity
81454 
81455 ";
81456 
81457 %feature("docstring")  casadi::Sparsity::get_upper() const  "
81458 
81459 Get nonzeros in upper triangular part.
81460 
81461 ";
81462 
81463 %feature("docstring")  casadi::Sparsity::dfs(casadi_int j, casadi_int top,
81464 std::vector< casadi_int > &INOUT, std::vector< casadi_int > &INOUT, const
81465 std::vector< casadi_int > &pinv, std::vector< bool > &INOUT) const  "
81466 
81467 Depth-first search on the adjacency graph of the sparsity See Direct Methods
81468 for Sparse Linear Systems by Davis (2006).
81469 
81470 ";
81471 
81472 %feature("docstring")  casadi::Sparsity::is_tril() const  "
81473 
81474 Is lower triangular?
81475 
81476 ";
81477 
81478 %feature("docstring")  casadi::Sparsity::size2() const  "
81479 
81480 Get the number of columns.
81481 
81482 ";
81483 
81484 %feature("docstring")  casadi::Sparsity::get_col() const  "
81485 
81486 Get the column for each non-zero entry Together with the row-vector, this
81487 vector gives the sparsity of the matrix in sparse triplet format, i.e. the
81488 column and row for each non-zero elements.
81489 
81490 ";
81491 
81492 %feature("docstring")  casadi::Sparsity::size1() const  "
81493 
81494 Get the number of rows.
81495 
81496 ";
81497 
81498 %feature("docstring")  casadi::Sparsity::star_coloring2(casadi_int
81499 ordering=1, casadi_int cutoff=std::numeric_limits< casadi_int >::max())
81500 const  "
81501 
81502 Perform a star coloring of a symmetric matrix: A new greedy distance-2
81503 coloring algorithm Algorithm 4.1 in NEW ACYCLIC AND STAR COLORING ALGORITHMS
81504 WITH APPLICATION TO COMPUTING HESSIANS A. H. GEBREMEDHIN, A. TARAFDAR, F.
81505 MANNE, A. POTHEN SIAM J. SCI. COMPUT. Vol. 29, No. 3, pp. 10421072 (2007)
81506 
81507 Ordering options: None (0), largest first (1)
81508 
81509 ";
81510 
81511 %feature("docstring")  casadi::Sparsity::spy(std::ostream
81512 &stream=casadi::uout()) const  "
81513 
81514 Print a textual representation of sparsity.
81515 
81516 ";
81517 
81518 %feature("docstring")  casadi::Sparsity::postfix_dim() const  "
81519 
81520 Dimension string as a postfix to a name Rules:
81521 
81522 Dense and scalar: \"\"
81523 
81524 0-by-0: \"[]\"
81525 
81526 Dense column vector: \"[5]\"
81527 
81528 Dense matrix: \"[5x10]\"
81529 
81530 Otherwise: \"[5x10,3nz]\"
81531 
81532 ";
81533 
81534 %feature("docstring")  casadi::Sparsity::enlargeColumns(casadi_int ncol,
81535 const std::vector< casadi_int > &cc, bool ind1=false) "
81536 
81537 Enlarge the matrix along the second dimension (i.e. insert columns)
81538 
81539 ";
81540 
81541 %feature("docstring")  casadi::Sparsity::rows() const  "
81542 
81543 Get the number of rows, Octave-style syntax.
81544 
81545 ";
81546 
81547 %feature("docstring") casadi::Sparsity::__hash__ "
81548 
81549 Returns a number that is unique for a given Node. If the Object does not
81550 point to any node, \"0\" is returned.
81551 
81552 ";
81553 
81554 %feature("docstring")  casadi::Sparsity::size() const  "
81555 
81556 Get the shape.
81557 
81558 ";
81559 
81560 %feature("docstring")  casadi::Sparsity::size(casadi_int axis) const  "
81561 
81562 Get the size along a particular dimensions.
81563 
81564 ";
81565 
81566 %feature("docstring")  casadi::Sparsity::etree(bool ata=false) const  "
81567 
81568 Calculate the elimination tree See Direct Methods for Sparse Linear Systems
81569 by Davis (2006). If the parameter ata is false, the algorithm is equivalent
81570 to MATLAB's etree(A), except that the indices are zero- based. If ata is
81571 true, the algorithm is equivalent to MATLAB's etree(A, 'col').
81572 
81573 The implementation is a modified version of cs_etree in CSparse Copyright(c)
81574 Timothy A. Davis, 2006-2009 Licensed as a derivative work under the GNU LGPL
81575 
81576 ";
81577 
81578 %feature("docstring")  casadi::Sparsity::get_nz(casadi_int rr, casadi_int
81579 cc) const  "
81580 
81581 Get the index of an existing non-zero element return -1 if the element does
81582 not exist.
81583 
81584 ";
81585 
81586 %feature("docstring")  casadi::Sparsity::get_nz(const std::vector<
81587 casadi_int > &rr, const std::vector< casadi_int > &cc) const  "
81588 
81589 Get a set of non-zero element return -1 if the element does not exist.
81590 
81591 ";
81592 
81593 %feature("docstring")  casadi::Sparsity::get_nz(std::vector< casadi_int >
81594 &INOUT) const  "
81595 
81596 Get the nonzero index for a set of elements The index vector is used both
81597 for input and outputs and must be sorted by increasing nonzero index, i.e.
81598 column-wise. Elements not found in the sparsity pattern are set to -1.
81599 
81600 ";
81601 
81602 %feature("docstring")  casadi::Sparsity::erase(const std::vector< casadi_int
81603 > &rr, const std::vector< casadi_int > &cc, bool ind1=false) "
81604 
81605 Erase rows and/or columns of a matrix.
81606 
81607 ";
81608 
81609 %feature("docstring")  casadi::Sparsity::erase(const std::vector< casadi_int
81610 > &rr, bool ind1=false) "
81611 
81612 Erase elements of a matrix.
81613 
81614 ";
81615 
81616 %feature("docstring")  casadi::Sparsity::bw_upper() const  "
81617 
81618 Upper half-bandwidth.
81619 
81620 ";
81621 
81622 %feature("docstring")  casadi::Sparsity::scalar(bool dense_scalar=true) "
81623 
81624 Create a scalar sparsity pattern.
81625 
81626 ";
81627 
81628 %feature("docstring")  casadi::Sparsity::nnz_upper(bool strictly=false)
81629 const  "
81630 
81631 Number of non-zeros in the upper triangular half, i.e. the number of
81632 elements (i, j) with j>=i.
81633 
81634 ";
81635 
81636 
81637 // File: classcasadi_1_1Split.xml
81638 
81639 
81640 // File: classcasadi_1_1Sqpmethod.xml
81641 %feature("docstring")  casadi::FunctionInternal::get_reltol() const  "
81642 
81643 [INTERNAL]  Get relative tolerance.
81644 
81645 ";
81646 
81647 %feature("docstring")  casadi::FunctionInternal::wrap() const  "
81648 
81649 [INTERNAL]  Wrap in an Function instance consisting of only one MX call.
81650 
81651 ";
81652 
81653 %feature("docstring")  casadi::Nlpsol::get_sparsity_out(casadi_int i)  "
81654 
81655 [INTERNAL]  Sparsities of function inputs and outputs.
81656 
81657 ";
81658 
81659 %feature("docstring")  casadi::FunctionInternal::nnz_in() const  "
81660 
81661 [INTERNAL]  Number of input/output nonzeros.
81662 
81663 ";
81664 
81665 %feature("docstring")  casadi::FunctionInternal::nnz_in(casadi_int ind)
81666 const  "
81667 
81668 [INTERNAL]  Number of input/output nonzeros.
81669 
81670 ";
81671 
81672 %feature("docstring")  casadi::FunctionInternal::has_free() const  "
81673 
81674 [INTERNAL]  Does the function have free variables.
81675 
81676 ";
81677 
81678 %feature("docstring")  casadi::FunctionInternal::check_mat(const Sparsity
81679 &arg, const Sparsity &inp, casadi_int &npar) "
81680 
81681 [INTERNAL]  Helper function
81682 
81683 Parameters:
81684 -----------
81685 
81686 npar[in]:  normal usage: 1, disallow pararallel calls: -1
81687 
81688 npar[out]:  required number of parallel calls (or -1)
81689 
81690 ";
81691 
81692 %feature("docstring")  casadi::FunctionInternal::call_gen(const MXVector
81693 &arg, MXVector &res, casadi_int npar, bool always_inline, bool never_inline)
81694 const  "
81695 
81696 [INTERNAL]   Call a function, overloaded.
81697 
81698 ";
81699 
81700 %feature("docstring")  casadi::FunctionInternal::call_gen(const std::vector<
81701 MatrixCommon > &arg, std::vector< MatrixCommon > &res, casadi_int npar, bool
81702 always_inline, bool never_inline) const  "
81703 
81704 [INTERNAL]   Call a function, overloaded.
81705 
81706 ";
81707 
81708 %feature("docstring")  casadi::FunctionInternal::numel_out(casadi_int ind)
81709 const  "
81710 
81711 [INTERNAL]  Number of input/output elements.
81712 
81713 ";
81714 
81715 %feature("docstring")  casadi::FunctionInternal::numel_out() const  "
81716 
81717 [INTERNAL]  Number of input/output elements.
81718 
81719 ";
81720 
81721 %feature("docstring")  casadi::Sqpmethod::init(const Dict &opts)  "
81722 
81723 [INTERNAL]  Initialize.
81724 
81725 ";
81726 
81727 %feature("docstring")  casadi::FunctionInternal::disp(std::ostream &stream,
81728 bool more) const  "
81729 
81730 [INTERNAL]  Display object.
81731 
81732 ";
81733 
81734 %feature("docstring")  casadi::ProtoFunction::sprint(char *buf, size_t
81735 buf_sz, const char *fmt,...) const  "
81736 
81737 [INTERNAL]  C-style formatted printing to string.
81738 
81739 ";
81740 
81741 %feature("docstring")  casadi::FunctionInternal::sz_work(size_t &sz_arg,
81742 size_t &sz_res, size_t &sz_iw, size_t &sz_w) const  "
81743 
81744 [INTERNAL]  Get number of temporary variables needed.
81745 
81746 ";
81747 
81748 %feature("docstring")  casadi::FunctionInternal::fwd_seed(casadi_int nfwd)
81749 const  "
81750 
81751 [INTERNAL]  Symbolic expressions for the forward seeds.
81752 
81753 ";
81754 
81755 %feature("docstring")  casadi::ProtoFunction::release(int mem) const  "
81756 
81757 [INTERNAL]  Release a memory object.
81758 
81759 ";
81760 
81761 %feature("docstring")  casadi::FunctionInternal::project_arg(const
81762 std::vector< M > &arg, casadi_int npar) const  "
81763 
81764 [INTERNAL]   Project sparsities.
81765 
81766 ";
81767 
81768 %feature("docstring")  casadi::FunctionInternal::self() const  "
81769 
81770 [INTERNAL]  Get a public class instance.
81771 
81772 ";
81773 
81774 %feature("docstring")  casadi::Sqpmethod::codegen_qp_solve(CodeGenerator
81775 &cg, const std::string &H, const std::string &g, const std::string &lbdz,
81776 const std::string &ubdz, const std::string &A, const std::string &x_opt,
81777 const std::string &dlam) const  "
81778 
81779 [INTERNAL] ";
81780 
81781 %feature("docstring")  casadi::OracleFunction::set_temp(void *mem, const
81782 double **arg, double **res, casadi_int *iw, double *w) const  "
81783 
81784 [INTERNAL]  Set the work vectors.
81785 
81786 ";
81787 
81788 %feature("docstring")  casadi::FunctionInternal::sp_weight() const  "
81789 
81790 [INTERNAL]  Weighting factor for chosing forward/reverse mode, sparsity
81791 propagation.
81792 
81793 ";
81794 
81795 %feature("docstring")
81796 casadi::FunctionInternal::getJacSparsityGen(casadi_int iind, casadi_int
81797 oind, bool symmetric, casadi_int gr_i=1, casadi_int gr_o=1) const  "
81798 
81799 [INTERNAL]  Get the sparsity pattern, forward mode.
81800 
81801 ";
81802 
81803 %feature("docstring")  casadi::FunctionInternal::nnz_out() const  "
81804 
81805 [INTERNAL]  Number of input/output nonzeros.
81806 
81807 ";
81808 
81809 %feature("docstring")  casadi::FunctionInternal::nnz_out(casadi_int ind)
81810 const  "
81811 
81812 [INTERNAL]  Number of input/output nonzeros.
81813 
81814 ";
81815 
81816 %feature("docstring")  casadi::FunctionInternal::get_jac(const std::string
81817 &name, const std::vector< std::string > &inames, const std::vector<
81818 std::string > &onames, const Dict &opts) const  "
81819 
81820 [INTERNAL]  Return Jacobian of all input elements with respect to all output
81821 elements.
81822 
81823 ";
81824 
81825 %feature("docstring")
81826 casadi::FunctionInternal::codegen_free_mem(CodeGenerator &g) const  "
81827 
81828 [INTERNAL]  Codegen for free_mem.
81829 
81830 ";
81831 
81832 %feature("docstring")  casadi::FunctionInternal::size2_in(casadi_int ind)
81833 const  "
81834 
81835 [INTERNAL]  Input/output dimensions.
81836 
81837 ";
81838 
81839 %feature("docstring")  casadi::FunctionInternal::eval_gen(const double
81840 **arg, double **res, casadi_int *iw, double *w, void *mem) const  "
81841 
81842 [INTERNAL]  Evaluate numerically.
81843 
81844 ";
81845 
81846 %feature("docstring")  casadi::FunctionInternal::eval_gen(const SXElem
81847 **arg, SXElem **res, casadi_int *iw, SXElem *w, void *mem) const  "
81848 
81849 [INTERNAL]  Evaluate a function, overloaded.
81850 
81851 ";
81852 
81853 %feature("docstring")  casadi::FunctionInternal::eval_gen(const bvec_t
81854 **arg, bvec_t **res, casadi_int *iw, bvec_t *w, void *mem) const  "
81855 
81856 [INTERNAL]  Evaluate a function, overloaded.
81857 
81858 ";
81859 
81860 %feature("docstring")  casadi::FunctionInternal::get_jacobian(const
81861 std::string &name, const std::vector< std::string > &inames, const
81862 std::vector< std::string > &onames, const Dict &opts) const  "
81863 
81864 [INTERNAL]  Return Jacobian of all input elements with respect to all output
81865 elements.
81866 
81867 ";
81868 
81869 %feature("docstring")  casadi::FunctionInternal::dm_out(casadi_int ind)
81870 const  "
81871 
81872 [INTERNAL]  Get function input(s) and output(s)
81873 
81874 ";
81875 
81876 %feature("docstring")  casadi::FunctionInternal::dm_out() const  "
81877 
81878 [INTERNAL]  Get function input(s) and output(s)
81879 
81880 ";
81881 
81882 %feature("docstring")  casadi::FunctionInternal::map(casadi_int n, const
81883 std::string &parallelization) const  "
81884 
81885 [INTERNAL]  Generate/retrieve cached serial map.
81886 
81887 ";
81888 
81889 %feature("docstring")  casadi::FunctionInternal::check_res(const
81890 std::vector< M > &res, casadi_int &npar) const  "
81891 
81892 [INTERNAL]  Check if output arguments have correct length and dimensions.
81893 
81894 Raises errors.
81895 
81896 Parameters:
81897 -----------
81898 
81899 npar[in]:  normal usage: 1, disallow pararallel calls: -1
81900 
81901 npar:  max number of horizontal repetitions across all arguments (or -1)
81902 
81903 ";
81904 
81905 %feature("docstring")  casadi::FunctionInternal::n_nodes() const  "
81906 
81907 [INTERNAL]  Number of nodes in the algorithm.
81908 
81909 ";
81910 
81911 %feature("docstring")  casadi::Sqpmethod::free_mem(void *mem) const  "
81912 
81913 [INTERNAL]  Free memory block.
81914 
81915 ";
81916 
81917 %feature("docstring")  casadi::FunctionInternal::print_options(std::ostream
81918 &stream) const  "
81919 
81920 [INTERNAL]  Print list of options.
81921 
81922 ";
81923 
81924 %feature("docstring")  casadi::FunctionInternal::jacobian_sparsity() const
81925 "
81926 
81927 [INTERNAL]  Get Jacobian sparsity.
81928 
81929 ";
81930 
81931 %feature("docstring")  casadi::FunctionInternal::codegen(CodeGenerator &g,
81932 const std::string &fname) const  "
81933 
81934 [INTERNAL]  Generate code the function.
81935 
81936 ";
81937 
81938 %feature("docstring")  casadi::FunctionInternal::mx_out(casadi_int ind)
81939 const  "
81940 
81941 [INTERNAL]  Get function input(s) and output(s)
81942 
81943 ";
81944 
81945 %feature("docstring")  casadi::FunctionInternal::mx_out() const  "
81946 
81947 [INTERNAL]  Get function input(s) and output(s)
81948 
81949 ";
81950 
81951 %feature("docstring")  casadi::FunctionInternal::codegen_name(const
81952 CodeGenerator &g, bool ns=true) const  "
81953 
81954 [INTERNAL]  Get name in codegen.
81955 
81956 ";
81957 
81958 %feature("docstring")  casadi::FunctionInternal::numel_in() const  "
81959 
81960 [INTERNAL]  Number of input/output elements.
81961 
81962 ";
81963 
81964 %feature("docstring")  casadi::FunctionInternal::numel_in(casadi_int ind)
81965 const  "
81966 
81967 [INTERNAL]  Number of input/output elements.
81968 
81969 ";
81970 
81971 %feature("docstring")  casadi::FunctionInternal::ad_weight() const  "
81972 
81973 [INTERNAL]  Weighting factor for chosing forward/reverse mode.
81974 
81975 ";
81976 
81977 %feature("docstring")  casadi::FunctionInternal::generate_out(const
81978 std::string &fname, double **res) const  "
81979 
81980 [INTERNAL] ";
81981 
81982 %feature("docstring")
81983 casadi::FunctionInternal::getJacSparsityHierarchical(casadi_int iind,
81984 casadi_int oind) const  "
81985 
81986 [INTERNAL]  A flavor of getJacSparsity that does hierarchical block
81987 structure recognition.
81988 
81989 ";
81990 
81991 %feature("docstring")  casadi::SharedObjectInternal::getCount() const  "
81992 
81993 [INTERNAL]  Get the reference count.
81994 
81995 ";
81996 
81997 %feature("docstring")  casadi::FunctionInternal::has_codegen() const  "
81998 
81999 [INTERNAL]  Is codegen supported?
82000 
82001 ";
82002 
82003 %feature("docstring")  casadi::FunctionInternal::size2_out(casadi_int ind)
82004 const  "
82005 
82006 [INTERNAL]  Input/output dimensions.
82007 
82008 ";
82009 
82010 %feature("docstring")  casadi::FunctionInternal::jac() const  "
82011 
82012 [INTERNAL]  Return Jacobian of all input elements with respect to all output
82013 elements.
82014 
82015 ";
82016 
82017 %feature("docstring")  casadi::FunctionInternal::adjViaJac(casadi_int nadj)
82018 const  "
82019 
82020 [INTERNAL]  Calculate derivatives by multiplying the full Jacobian and
82021 multiplying.
82022 
82023 ";
82024 
82025 %feature("docstring")  casadi::FunctionInternal::has_spfwd() const  "
82026 
82027 [INTERNAL]  Is the class able to propagate seeds through the algorithm?
82028 
82029 ";
82030 
82031 %feature("docstring")  casadi::FunctionInternal::alloc(const Function &f,
82032 bool persistent=false) "
82033 
82034 [INTERNAL]  Ensure work vectors long enough to evaluate function.
82035 
82036 ";
82037 
82038 %feature("docstring")  casadi::Nlpsol::has_reverse(casadi_int nadj) const  "
82039 
82040 [INTERNAL]  Generate a function that calculates reverse mode derivatives.
82041 
82042 ";
82043 
82044 %feature("docstring")  casadi::FunctionInternal::incache(const std::string
82045 &fname, Function &f, const std::string &suffix="") const  "
82046 
82047 [INTERNAL]  Get function in cache.
82048 
82049 ";
82050 
82051 %feature("docstring")  casadi::Nlpsol::get_reverse(casadi_int nadj, const
82052 std::string &name, const std::vector< std::string > &inames, const
82053 std::vector< std::string > &onames, const Dict &opts) const  "
82054 
82055 [INTERNAL]  Generate a function that calculates reverse mode derivatives.
82056 
82057 ";
82058 
82059 %feature("docstring")  casadi::FunctionInternal::sparsity_in(casadi_int ind)
82060 const  "
82061 
82062 [INTERNAL]  Input/output sparsity.
82063 
82064 ";
82065 
82066 %feature("docstring")  casadi::Sqpmethod::codegen_body(CodeGenerator &g)
82067 const  "
82068 
82069 [INTERNAL]  Generate code for the function body.
82070 
82071 ";
82072 
82073 %feature("docstring")  casadi::FunctionInternal::generate_in(const
82074 std::string &fname, const double **arg) const  "
82075 
82076 [INTERNAL]  Export an input file that can be passed to generate C code with
82077 a main.
82078 
82079 ";
82080 
82081 %feature("docstring")  casadi::FunctionInternal::getAdaptorSolverName()
82082 const  "
82083 
82084 [INTERNAL]  Obtain solver name from Adaptor.
82085 
82086 ";
82087 
82088 %feature("docstring") casadi::Sqpmethod "
82089 
82090 'sqpmethod' plugin for Nlpsol
82091 
82092 A textbook SQPMethod
82093 
82094 >List of available options
82095 
82096 +-----------------------+-------------+------------------------------------+
82097 |          Id           |    Type     |            Description             |
82098 +=======================+=============+====================================+
82099 | beta                  | OT_DOUBLE   | Line-search parameter, restoration |
82100 |                       |             | factor of stepsize                 |
82101 +-----------------------+-------------+------------------------------------+
82102 | c1                    | OT_DOUBLE   | Armijo condition, coefficient of   |
82103 |                       |             | decrease in merit                  |
82104 +-----------------------+-------------+------------------------------------+
82105 | convexify_margin      | OT_DOUBLE   | When using a convexification       |
82106 |                       |             | strategy, make sure that the       |
82107 |                       |             | smallest eigenvalue is at least    |
82108 |                       |             | this (default: 1e-7).              |
82109 +-----------------------+-------------+------------------------------------+
82110 | convexify_strategy    | OT_STRING   | NONE|regularize|eigen-reflect      |
82111 |                       |             | |eigen-clip. Strategy to convexify |
82112 |                       |             | the Lagrange Hessian before        |
82113 |                       |             | passing it to the solver.          |
82114 +-----------------------+-------------+------------------------------------+
82115 | hess_lag              | OT_FUNCTION | Function for calculating the       |
82116 |                       |             | Hessian of the Lagrangian          |
82117 |                       |             | (autogenerated by default)         |
82118 +-----------------------+-------------+------------------------------------+
82119 | hessian_approximation | OT_STRING   | limited-memory|exact               |
82120 +-----------------------+-------------+------------------------------------+
82121 | jac_fg                | OT_FUNCTION | Function for calculating the       |
82122 |                       |             | gradient of the objective and      |
82123 |                       |             | Jacobian of the constraints        |
82124 |                       |             | (autogenerated by default)         |
82125 +-----------------------+-------------+------------------------------------+
82126 | lbfgs_memory          | OT_INT      | Size of L-BFGS memory.             |
82127 +-----------------------+-------------+------------------------------------+
82128 | max_iter              | OT_INT      | Maximum number of SQP iterations   |
82129 +-----------------------+-------------+------------------------------------+
82130 | max_iter_eig          | OT_DOUBLE   | Maximum number of iterations to    |
82131 |                       |             | compute an eigenvalue              |
82132 |                       |             | decomposition (default: 50).       |
82133 +-----------------------+-------------+------------------------------------+
82134 | max_iter_ls           | OT_INT      | Maximum number of linesearch       |
82135 |                       |             | iterations                         |
82136 +-----------------------+-------------+------------------------------------+
82137 | merit_memory          | OT_INT      | Size of memory to store history of |
82138 |                       |             | merit function values              |
82139 +-----------------------+-------------+------------------------------------+
82140 | min_iter              | OT_INT      | Minimum number of SQP iterations   |
82141 +-----------------------+-------------+------------------------------------+
82142 | min_step_size         | OT_DOUBLE   | The size (inf-norm) of the step    |
82143 |                       |             | size should not become smaller     |
82144 |                       |             | than this.                         |
82145 +-----------------------+-------------+------------------------------------+
82146 | print_header          | OT_BOOL     | Print the header with problem      |
82147 |                       |             | statistics                         |
82148 +-----------------------+-------------+------------------------------------+
82149 | print_iteration       | OT_BOOL     | Print the iterations               |
82150 +-----------------------+-------------+------------------------------------+
82151 | print_status          | OT_BOOL     | Print a status message after       |
82152 |                       |             | solving                            |
82153 +-----------------------+-------------+------------------------------------+
82154 | qpsol                 | OT_STRING   | The QP solver to be used by the    |
82155 |                       |             | SQP method [qpoases]               |
82156 +-----------------------+-------------+------------------------------------+
82157 | qpsol_options         | OT_DICT     | Options to be passed to the QP     |
82158 |                       |             | solver                             |
82159 +-----------------------+-------------+------------------------------------+
82160 | tol_du                | OT_DOUBLE   | Stopping criterion for dual        |
82161 |                       |             | infeasability                      |
82162 +-----------------------+-------------+------------------------------------+
82163 | tol_pr                | OT_DOUBLE   | Stopping criterion for primal      |
82164 |                       |             | infeasibility                      |
82165 +-----------------------+-------------+------------------------------------+
82166 
82167 >List of available options
82168 
82169 +-------------------+---------------+-------------------+------------------+
82170 |        Id         |     Type      |    Description    |     Used in      |
82171 +===================+===============+===================+==================+
82172 | beta              | OT_DOUBLE     | Line-search       | casadi::Sqpmetho |
82173 |                   |               | parameter,        | d                |
82174 |                   |               | restoration       |                  |
82175 |                   |               | factor of         |                  |
82176 |                   |               | stepsize          |                  |
82177 +-------------------+---------------+-------------------+------------------+
82178 | bound_consistency | OT_BOOL       | Ensure that       | casadi::Nlpsol   |
82179 |                   |               | primal-dual       |                  |
82180 |                   |               | solution is       |                  |
82181 |                   |               | consistent with   |                  |
82182 |                   |               | the bounds        |                  |
82183 +-------------------+---------------+-------------------+------------------+
82184 | c1                | OT_DOUBLE     | Armijo condition, | casadi::Sqpmetho |
82185 |                   |               | coefficient of    | d                |
82186 |                   |               | decrease in merit |                  |
82187 +-------------------+---------------+-------------------+------------------+
82188 | calc_f            | OT_BOOL       | Calculate 'f' in  | casadi::Nlpsol   |
82189 |                   |               | the Nlpsol base   |                  |
82190 |                   |               | class             |                  |
82191 +-------------------+---------------+-------------------+------------------+
82192 | calc_g            | OT_BOOL       | Calculate 'g' in  | casadi::Nlpsol   |
82193 |                   |               | the Nlpsol base   |                  |
82194 |                   |               | class             |                  |
82195 +-------------------+---------------+-------------------+------------------+
82196 | calc_lam_p        | OT_BOOL       | Calculate 'lam_p' | casadi::Nlpsol   |
82197 |                   |               | in the Nlpsol     |                  |
82198 |                   |               | base class        |                  |
82199 +-------------------+---------------+-------------------+------------------+
82200 | calc_lam_x        | OT_BOOL       | Calculate 'lam_x' | casadi::Nlpsol   |
82201 |                   |               | in the Nlpsol     |                  |
82202 |                   |               | base class        |                  |
82203 +-------------------+---------------+-------------------+------------------+
82204 | calc_multipliers  | OT_BOOL       | Calculate         | casadi::Nlpsol   |
82205 |                   |               | Lagrange          |                  |
82206 |                   |               | multipliers in    |                  |
82207 |                   |               | the Nlpsol base   |                  |
82208 |                   |               | class             |                  |
82209 +-------------------+---------------+-------------------+------------------+
82210 | convexify_margin  | OT_DOUBLE     | When using a      | casadi::Sqpmetho |
82211 |                   |               | convexification   | d                |
82212 |                   |               | strategy, make    |                  |
82213 |                   |               | sure that the     |                  |
82214 |                   |               | smallest          |                  |
82215 |                   |               | eigenvalue is at  |                  |
82216 |                   |               | least this        |                  |
82217 |                   |               | (default: 1e-7).  |                  |
82218 +-------------------+---------------+-------------------+------------------+
82219 | convexify_strateg | OT_STRING     | NONE|regularize   | casadi::Sqpmetho |
82220 | y                 |               | |eigen-reflect    | d                |
82221 |                   |               | |eigen-clip.      |                  |
82222 |                   |               | Strategy to       |                  |
82223 |                   |               | convexify the     |                  |
82224 |                   |               | Lagrange Hessian  |                  |
82225 |                   |               | before passing it |                  |
82226 |                   |               | to the solver.    |                  |
82227 +-------------------+---------------+-------------------+------------------+
82228 | discrete          | OT_BOOLVECTOR | Indicates which   | casadi::Nlpsol   |
82229 |                   |               | of the variables  |                  |
82230 |                   |               | are discrete,     |                  |
82231 |                   |               | i.e. integer-     |                  |
82232 |                   |               | valued            |                  |
82233 +-------------------+---------------+-------------------+------------------+
82234 | error_on_fail     | OT_BOOL       | When the          | casadi::Nlpsol   |
82235 |                   |               | numerical process |                  |
82236 |                   |               | returns           |                  |
82237 |                   |               | unsuccessfully,   |                  |
82238 |                   |               | raise an error    |                  |
82239 |                   |               | (default false).  |                  |
82240 +-------------------+---------------+-------------------+------------------+
82241 | eval_errors_fatal | OT_BOOL       | When errors occur | casadi::Nlpsol   |
82242 |                   |               | during evaluation |                  |
82243 |                   |               | of f,g,...,stop   |                  |
82244 |                   |               | the iterations    |                  |
82245 +-------------------+---------------+-------------------+------------------+
82246 | hess_lag          | OT_FUNCTION   | Function for      | casadi::Sqpmetho |
82247 |                   |               | calculating the   | d                |
82248 |                   |               | Hessian of the    |                  |
82249 |                   |               | Lagrangian        |                  |
82250 |                   |               | (autogenerated by |                  |
82251 |                   |               | default)          |                  |
82252 +-------------------+---------------+-------------------+------------------+
82253 | hessian_approxima | OT_STRING     | limited-          | casadi::Sqpmetho |
82254 | tion              |               | memory|exact      | d                |
82255 +-------------------+---------------+-------------------+------------------+
82256 | ignore_check_vec  | OT_BOOL       | If set to true,   | casadi::Nlpsol   |
82257 |                   |               | the input shape   |                  |
82258 |                   |               | of F will not be  |                  |
82259 |                   |               | checked.          |                  |
82260 +-------------------+---------------+-------------------+------------------+
82261 | iteration_callbac | OT_FUNCTION   | A function that   | casadi::Nlpsol   |
82262 | k                 |               | will be called at |                  |
82263 |                   |               | each iteration    |                  |
82264 |                   |               | with the solver   |                  |
82265 |                   |               | as input. Check   |                  |
82266 |                   |               | documentation of  |                  |
82267 |                   |               | Callback .        |                  |
82268 +-------------------+---------------+-------------------+------------------+
82269 | iteration_callbac | OT_BOOL       | If set to true,   | casadi::Nlpsol   |
82270 | k_ignore_errors   |               | errors thrown by  |                  |
82271 |                   |               | iteration_callbac |                  |
82272 |                   |               | k will be         |                  |
82273 |                   |               | ignored.          |                  |
82274 +-------------------+---------------+-------------------+------------------+
82275 | iteration_callbac | OT_INT        | Only call the     | casadi::Nlpsol   |
82276 | k_step            |               | callback function |                  |
82277 |                   |               | every few         |                  |
82278 |                   |               | iterations.       |                  |
82279 +-------------------+---------------+-------------------+------------------+
82280 | jac_fg            | OT_FUNCTION   | Function for      | casadi::Sqpmetho |
82281 |                   |               | calculating the   | d                |
82282 |                   |               | gradient of the   |                  |
82283 |                   |               | objective and     |                  |
82284 |                   |               | Jacobian of the   |                  |
82285 |                   |               | constraints       |                  |
82286 |                   |               | (autogenerated by |                  |
82287 |                   |               | default)          |                  |
82288 +-------------------+---------------+-------------------+------------------+
82289 | lbfgs_memory      | OT_INT        | Size of L-BFGS    | casadi::Sqpmetho |
82290 |                   |               | memory.           | d                |
82291 +-------------------+---------------+-------------------+------------------+
82292 | max_iter          | OT_INT        | Maximum number of | casadi::Sqpmetho |
82293 |                   |               | SQP iterations    | d                |
82294 +-------------------+---------------+-------------------+------------------+
82295 | max_iter_eig      | OT_DOUBLE     | Maximum number of | casadi::Sqpmetho |
82296 |                   |               | iterations to     | d                |
82297 |                   |               | compute an        |                  |
82298 |                   |               | eigenvalue        |                  |
82299 |                   |               | decomposition     |                  |
82300 |                   |               | (default: 50).    |                  |
82301 +-------------------+---------------+-------------------+------------------+
82302 | max_iter_ls       | OT_INT        | Maximum number of | casadi::Sqpmetho |
82303 |                   |               | linesearch        | d                |
82304 |                   |               | iterations        |                  |
82305 +-------------------+---------------+-------------------+------------------+
82306 | merit_memory      | OT_INT        | Size of memory to | casadi::Sqpmetho |
82307 |                   |               | store history of  | d                |
82308 |                   |               | merit function    |                  |
82309 |                   |               | values            |                  |
82310 +-------------------+---------------+-------------------+------------------+
82311 | min_iter          | OT_INT        | Minimum number of | casadi::Sqpmetho |
82312 |                   |               | SQP iterations    | d                |
82313 +-------------------+---------------+-------------------+------------------+
82314 | min_lam           | OT_DOUBLE     | Minimum allowed   | casadi::Nlpsol   |
82315 |                   |               | multiplier value  |                  |
82316 +-------------------+---------------+-------------------+------------------+
82317 | min_step_size     | OT_DOUBLE     | The size (inf-    | casadi::Sqpmetho |
82318 |                   |               | norm) of the step | d                |
82319 |                   |               | size should not   |                  |
82320 |                   |               | become smaller    |                  |
82321 |                   |               | than this.        |                  |
82322 +-------------------+---------------+-------------------+------------------+
82323 | no_nlp_grad       | OT_BOOL       | Prevent the       | casadi::Nlpsol   |
82324 |                   |               | creation of the   |                  |
82325 |                   |               | 'nlp_grad'        |                  |
82326 |                   |               | function          |                  |
82327 +-------------------+---------------+-------------------+------------------+
82328 | oracle_options    | OT_DICT       | Options to be     | casadi::Nlpsol   |
82329 |                   |               | passed to the     |                  |
82330 |                   |               | oracle function   |                  |
82331 +-------------------+---------------+-------------------+------------------+
82332 | print_header      | OT_BOOL       | Print the header  | casadi::Sqpmetho |
82333 |                   |               | with problem      | d                |
82334 |                   |               | statistics        |                  |
82335 +-------------------+---------------+-------------------+------------------+
82336 | print_iteration   | OT_BOOL       | Print the         | casadi::Sqpmetho |
82337 |                   |               | iterations        | d                |
82338 +-------------------+---------------+-------------------+------------------+
82339 | print_status      | OT_BOOL       | Print a status    | casadi::Sqpmetho |
82340 |                   |               | message after     | d                |
82341 |                   |               | solving           |                  |
82342 +-------------------+---------------+-------------------+------------------+
82343 | qpsol             | OT_STRING     | The QP solver to  | casadi::Sqpmetho |
82344 |                   |               | be used by the    | d                |
82345 |                   |               | SQP method        |                  |
82346 |                   |               | [qpoases]         |                  |
82347 +-------------------+---------------+-------------------+------------------+
82348 | qpsol_options     | OT_DICT       | Options to be     | casadi::Sqpmetho |
82349 |                   |               | passed to the QP  | d                |
82350 |                   |               | solver            |                  |
82351 +-------------------+---------------+-------------------+------------------+
82352 | sens_linsol       | OT_STRING     | Linear solver     | casadi::Nlpsol   |
82353 |                   |               | used for          |                  |
82354 |                   |               | parametric        |                  |
82355 |                   |               | sensitivities     |                  |
82356 |                   |               | (default 'qr').   |                  |
82357 +-------------------+---------------+-------------------+------------------+
82358 | sens_linsol_optio | OT_DICT       | Linear solver     | casadi::Nlpsol   |
82359 | ns                |               | options used for  |                  |
82360 |                   |               | parametric        |                  |
82361 |                   |               | sensitivities.    |                  |
82362 +-------------------+---------------+-------------------+------------------+
82363 | tol_du            | OT_DOUBLE     | Stopping          | casadi::Sqpmetho |
82364 |                   |               | criterion for     | d                |
82365 |                   |               | dual              |                  |
82366 |                   |               | infeasability     |                  |
82367 +-------------------+---------------+-------------------+------------------+
82368 | tol_pr            | OT_DOUBLE     | Stopping          | casadi::Sqpmetho |
82369 |                   |               | criterion for     | d                |
82370 |                   |               | primal            |                  |
82371 |                   |               | infeasibility     |                  |
82372 +-------------------+---------------+-------------------+------------------+
82373 | verbose_init      | OT_BOOL       | Print out timing  | casadi::Nlpsol   |
82374 |                   |               | information about |                  |
82375 |                   |               | the different     |                  |
82376 |                   |               | stages of         |                  |
82377 |                   |               | initialization    |                  |
82378 +-------------------+---------------+-------------------+------------------+
82379 | warn_initial_boun | OT_BOOL       | Warn if the       | casadi::Nlpsol   |
82380 | ds                |               | initial guess     |                  |
82381 |                   |               | does not satisfy  |                  |
82382 |                   |               | LBX and UBX       |                  |
82383 +-------------------+---------------+-------------------+------------------+
82384 
82385 Diagrams
82386 --------
82387 
82388 
82389 
82390 C++ includes: sqpmethod.hpp ";
82391 
82392 %feature("docstring")  casadi::FunctionInternal::get_free() const  "
82393 
82394 [INTERNAL]  Print free variables.
82395 
82396 ";
82397 
82398 %feature("docstring")  casadi::FunctionInternal::eval_dm(const std::vector<
82399 DM > &arg) const  "
82400 
82401 [INTERNAL]  Evaluate with DM matrices.
82402 
82403 ";
82404 
82405 %feature("docstring")  casadi::FunctionInternal::sz_arg() const  "
82406 
82407 [INTERNAL]  Get required length of arg field.
82408 
82409 ";
82410 
82411 %feature("docstring")  casadi::FunctionInternal::index_out(const std::string
82412 &name) const  "
82413 
82414 [INTERNAL]  Get output scheme index by name.
82415 
82416 ";
82417 
82418 %feature("docstring")  casadi::OracleFunction::generate_dependencies(const
82419 std::string &fname, const Dict &opts) const  "
82420 
82421 [INTERNAL]  Export / Generate C code for the generated functions.
82422 
82423 ";
82424 
82425 %feature("docstring")  casadi::FunctionInternal::free_mx() const  "
82426 
82427 [INTERNAL]  Get free variables ( MX)
82428 
82429 ";
82430 
82431 %feature("docstring")  casadi::FunctionInternal::index_in(const std::string
82432 &name) const  "
82433 
82434 [INTERNAL]  Get input scheme index by name.
82435 
82436 ";
82437 
82438 %feature("docstring")  casadi::FunctionInternal::sp_reverse(bvec_t **arg,
82439 bvec_t **res, casadi_int *iw, bvec_t *w, void *mem) const  "
82440 
82441 [INTERNAL]  Propagate sparsity backwards.
82442 
82443 ";
82444 
82445 %feature("docstring")  casadi::Sqpmethod::get_options() const  "
82446 
82447 [INTERNAL]  Options.
82448 
82449 ";
82450 
82451 %feature("docstring")  casadi::FunctionInternal::has_sprev() const  "
82452 
82453 [INTERNAL]  Is the class able to propagate seeds through the algorithm?
82454 
82455 ";
82456 
82457 %feature("docstring")  casadi::FunctionInternal::symbolicAdjSeed(casadi_int
82458 nadj, const std::vector< MatType > &v) const  "
82459 
82460 [INTERNAL]  Symbolic expressions for the adjoint seeds.
82461 
82462 ";
82463 
82464 %feature("docstring")  casadi::Nlpsol::get_forward(casadi_int nfwd, const
82465 std::string &name, const std::vector< std::string > &inames, const
82466 std::vector< std::string > &onames, const Dict &opts) const  "
82467 
82468 [INTERNAL]  Generate a function that calculates forward mode derivatives.
82469 
82470 ";
82471 
82472 %feature("docstring")  casadi::Sqpmethod::alloc_mem() const  "
82473 
82474 [INTERNAL]  Create memory block.
82475 
82476 ";
82477 
82478 %feature("docstring")  casadi::FunctionInternal::eval_mx(const MXVector
82479 &arg, MXVector &res, bool always_inline, bool never_inline) const  "
82480 
82481 [INTERNAL]  Evaluate with symbolic matrices.
82482 
82483 ";
82484 
82485 %feature("docstring")  casadi::FunctionInternal::codegen_meta(CodeGenerator
82486 &g) const  "
82487 
82488 [INTERNAL]  Generate meta-information allowing a user to evaluate a
82489 generated function.
82490 
82491 ";
82492 
82493 %feature("docstring")  casadi::FunctionInternal::mapsum_mx(const
82494 std::vector< MX > &arg, const std::string &parallelization) "
82495 
82496 [INTERNAL]  Parallel evaluation.
82497 
82498 ";
82499 
82500 %feature("docstring")  casadi::Sqpmethod::init_mem(void *mem) const  "
82501 
82502 [INTERNAL]  Initalize memory block.
82503 
82504 ";
82505 
82506 %feature("docstring")  casadi::OracleFunction::get_function() const  "
82507 
82508 [INTERNAL]  Get list of dependency functions -1 Indicates irregularity.
82509 
82510 ";
82511 
82512 %feature("docstring")  casadi::OracleFunction::get_function(const
82513 std::string &name) const  "
82514 
82515 [INTERNAL] ";
82516 
82517 %feature("docstring")  casadi::Nlpsol::get_n_out()  "
82518 
82519 [INTERNAL]  Number of function inputs and outputs.
82520 
82521 ";
82522 
82523 %feature("docstring")  casadi::OracleFunction::jit_dependencies(const
82524 std::string &fname)  "
82525 
82526 [INTERNAL]  JIT for dependencies.
82527 
82528 ";
82529 
82530 %feature("docstring")  casadi::FunctionInternal::sparsity_out(casadi_int
82531 ind) const  "
82532 
82533 [INTERNAL]  Input/output sparsity.
82534 
82535 ";
82536 
82537 %feature("docstring")
82538 casadi::FunctionInternal::instruction_output(casadi_int k) const  "
82539 
82540 [INTERNAL]  Get the (integer) output argument of an atomic operation.
82541 
82542 ";
82543 
82544 %feature("docstring")  casadi::OracleFunction::set_function(const Function
82545 &fcn, const std::string &fname, bool jit=false) "
82546 
82547 [INTERNAL]  Register the function for evaluation and statistics gathering
82548 
82549 ";
82550 
82551 %feature("docstring")  casadi::OracleFunction::set_function(const Function
82552 &fcn) "
82553 
82554 [INTERNAL]  Register the function for evaluation and statistics gathering
82555 
82556 ";
82557 
82558 %feature("docstring")  casadi::Nlpsol::has_forward(casadi_int nfwd) const  "
82559 
82560 [INTERNAL]  Generate a function that calculates forward mode derivatives.
82561 
82562 ";
82563 
82564 %feature("docstring")  casadi::FunctionInternal::call(const std::vector< M >
82565 &arg, std::vector< M > &res, bool always_inline, bool never_inline) const  "
82566 
82567 [INTERNAL]   Call a function, templated.
82568 
82569 ";
82570 
82571 %feature("docstring")  casadi::FunctionInternal::sz_iw() const  "
82572 
82573 [INTERNAL]  Get required length of iw field.
82574 
82575 ";
82576 
82577 %feature("docstring")  casadi::FunctionInternal::alloc_w(size_t sz_w, bool
82578 persistent=false) "
82579 
82580 [INTERNAL]  Ensure required length of w field.
82581 
82582 ";
82583 
82584 %feature("docstring")  casadi::FunctionInternal::replace_res(const
82585 std::vector< M > &res, casadi_int npar) const  "
82586 
82587 [INTERNAL]  Replace 0-by-0 outputs.
82588 
82589 ";
82590 
82591 %feature("docstring")  casadi::FunctionInternal::get_jacobian_sparsity()
82592 const  "
82593 
82594 [INTERNAL]  Get Jacobian sparsity.
82595 
82596 ";
82597 
82598 %feature("docstring")  casadi::FunctionInternal::setup(void *mem, const
82599 double **arg, double **res, casadi_int *iw, double *w) const  "
82600 
82601 [INTERNAL]  Set the (persistent and temporary) work vectors.
82602 
82603 ";
82604 
82605 %feature("docstring")  casadi::Sqpmethod::plugin_name() const  "
82606 
82607 [INTERNAL] ";
82608 
82609 %feature("docstring")  casadi::FunctionInternal::size_in(casadi_int ind)
82610 const  "
82611 
82612 [INTERNAL]  Input/output dimensions.
82613 
82614 ";
82615 
82616 %feature("docstring")
82617 casadi::FunctionInternal::getJacSparsityHierarchicalSymm(casadi_int iind,
82618 casadi_int oind) const  "
82619 
82620 [INTERNAL]  A flavor of getJacSparsity that does hierarchical block
82621 structure recognition for symmetric Jacobians
82622 
82623 ";
82624 
82625 %feature("docstring")
82626 casadi::FunctionInternal::codegen_decref(CodeGenerator &g) const  "
82627 
82628 [INTERNAL]  Codegen decref for dependencies.
82629 
82630 ";
82631 
82632 %feature("docstring")  casadi::FunctionInternal::fwdViaJac(casadi_int nfwd)
82633 const  "
82634 
82635 [INTERNAL]  Calculate derivatives by multiplying the full Jacobian and
82636 multiplying.
82637 
82638 ";
82639 
82640 %feature("docstring")  casadi::FunctionInternal::has_eval_dm() const  "
82641 
82642 [INTERNAL]  Evaluate with DM matrices.
82643 
82644 ";
82645 
82646 %feature("docstring")  casadi::FunctionInternal::wrap_as_needed(const Dict
82647 &opts) const  "
82648 
82649 [INTERNAL]  Wrap in an Function instance consisting of only one MX call.
82650 
82651 ";
82652 
82653 %feature("docstring")  casadi::FunctionInternal::check_arg(const
82654 std::vector< M > &arg, casadi_int &npar) const  "
82655 
82656 [INTERNAL]  Check if input arguments have correct length and dimensions.
82657 
82658 Raises errors.
82659 
82660 Parameters:
82661 -----------
82662 
82663 npar[in]:  normal usage: 1, disallow pararallel calls: -1
82664 
82665 npar:  max number of horizontal repetitions across all arguments (or -1)
82666 
82667 ";
82668 
82669 %feature("docstring")
82670 casadi::FunctionInternal::codegen_init_mem(CodeGenerator &g) const  "
82671 
82672 [INTERNAL]  Codegen decref for init_mem.
82673 
82674 ";
82675 
82676 %feature("docstring")  casadi::Nlpsol::setOptionsFromFile(const std::string
82677 &file) "
82678 
82679 [INTERNAL]  Read options from parameter xml.
82680 
82681 ";
82682 
82683 %feature("docstring")  casadi::FunctionInternal::replace_fseed(const
82684 std::vector< std::vector< M >> &fseed, casadi_int npar) const  "
82685 
82686 [INTERNAL]  Replace 0-by-0 forward seeds.
82687 
82688 ";
82689 
82690 %feature("docstring")  casadi::FunctionInternal::replace_fseed(const
82691 std::vector< std::vector< M > > &fseed, casadi_int npar) const  "
82692 
82693 [INTERNAL] ";
82694 
82695 %feature("docstring")  casadi::ProtoFunction::serialize(SerializingStream
82696 &s) const  "
82697 
82698 [INTERNAL]  Serialize an object.
82699 
82700 ";
82701 
82702 %feature("docstring")  casadi::FunctionInternal::symbolic_output(const
82703 std::vector< MX > &arg) const  "
82704 
82705 [INTERNAL]  Get a vector of symbolic variables corresponding to the outputs.
82706 
82707 ";
82708 
82709 %feature("docstring")  casadi::FunctionInternal::generate_options(bool
82710 is_temp=false) const  "
82711 
82712 [INTERNAL]  Reconstruct options dict.
82713 
82714 ";
82715 
82716 %feature("docstring")  casadi::OracleFunction::finalize()  "
82717 
82718 [INTERNAL]  Finalize initialization.
82719 
82720 ";
82721 
82722 %feature("docstring")  casadi::FunctionInternal::mx_in(casadi_int ind) const
82723 "
82724 
82725 [INTERNAL]  Get function input(s) and output(s)
82726 
82727 ";
82728 
82729 %feature("docstring")  casadi::FunctionInternal::mx_in() const  "
82730 
82731 [INTERNAL]  Get function input(s) and output(s)
82732 
82733 ";
82734 
82735 %feature("docstring")  casadi::OracleFunction::has_function(const
82736 std::string &fname) const  "
82737 
82738 [INTERNAL] ";
82739 
82740 %feature("docstring")  casadi::ProtoFunction::print(const char *fmt,...)
82741 const  "
82742 
82743 [INTERNAL]  C-style formatted printing during evaluation.
82744 
82745 ";
82746 
82747 %feature("docstring")  casadi::FunctionInternal::size1_in(casadi_int ind)
82748 const  "
82749 
82750 [INTERNAL]  Input/output dimensions.
82751 
82752 ";
82753 
82754 %feature("docstring")  casadi::FunctionInternal::matching_arg(const
82755 std::vector< M > &arg, casadi_int &npar) const  "
82756 
82757 [INTERNAL]  Check if input arguments that needs to be replaced.
82758 
82759 Raises errors
82760 
82761 Parameters:
82762 -----------
82763 
82764 npar[in]:  normal usage: 1, disallow pararallel calls: -1
82765 
82766 npar:  max number of horizontal repetitions across all arguments (or -1)
82767 
82768 ";
82769 
82770 %feature("docstring")  casadi::FunctionInternal::is_diff_out(casadi_int i) "
82771 
82772 [INTERNAL] ";
82773 
82774 %feature("docstring")  casadi::FunctionInternal::codegen_mem(CodeGenerator
82775 &g, const std::string &index="mem") const  "
82776 
82777 [INTERNAL]  Get thread-local memory object.
82778 
82779 ";
82780 
82781 %feature("docstring")  casadi::FunctionInternal::call_forward(const
82782 std::vector< MX > &arg, const std::vector< MX > &res, const std::vector<
82783 std::vector< MX > > &fseed, std::vector< std::vector< MX > > &fsens, bool
82784 always_inline, bool never_inline) const  "
82785 
82786 [INTERNAL]  Forward mode AD, virtual functions overloaded in derived
82787 classes.
82788 
82789 ";
82790 
82791 %feature("docstring")  casadi::FunctionInternal::call_forward(const
82792 std::vector< SX > &arg, const std::vector< SX > &res, const std::vector<
82793 std::vector< SX > > &fseed, std::vector< std::vector< SX > > &fsens, bool
82794 always_inline, bool never_inline) const  "
82795 
82796 [INTERNAL]  Forward mode AD, virtual functions overloaded in derived
82797 classes.
82798 
82799 ";
82800 
82801 %feature("docstring")  casadi::FunctionInternal::free_sx() const  "
82802 
82803 [INTERNAL]  Get free variables (SX)
82804 
82805 ";
82806 
82807 %feature("docstring")  casadi::FunctionInternal::forward(casadi_int nfwd)
82808 const  "
82809 
82810 [INTERNAL]  Return function that calculates forward derivatives
82811 forward(nfwd) returns a cached instance if available, and calls  Function
82812 get_forward(casadi_int nfwd) if no cached version is available.
82813 
82814 ";
82815 
82816 %feature("docstring")  casadi::Nlpsol::callback(NlpsolMemory *m) const  "
82817 
82818 [INTERNAL] ";
82819 
82820 %feature("docstring")  casadi::FunctionInternal::alloc_res(size_t sz_res,
82821 bool persistent=false) "
82822 
82823 [INTERNAL]  Ensure required length of res field.
82824 
82825 ";
82826 
82827 %feature("docstring")  casadi::FunctionInternal::instructions_sx() const  "
82828 
82829 [INTERNAL]  get SX expression associated with instructions
82830 
82831 ";
82832 
82833 %feature("docstring")
82834 casadi::FunctionInternal::print_dimensions(std::ostream &stream) const  "
82835 
82836 [INTERNAL]  Print dimensions of inputs and outputs.
82837 
82838 ";
82839 
82840 %feature("docstring")
82841 casadi::FunctionInternal::codegen_sparsities(CodeGenerator &g) const  "
82842 
82843 [INTERNAL]  Codegen sparsities.
82844 
82845 ";
82846 
82847 %feature("docstring")  casadi::Sqpmethod::solve(void *mem) const  "
82848 
82849 [INTERNAL] ";
82850 
82851 %feature("docstring")  casadi::Nlpsol::get_sparsity_in(casadi_int i)  "
82852 
82853 [INTERNAL]  Sparsities of function inputs and outputs.
82854 
82855 ";
82856 
82857 %feature("docstring")  casadi::OracleFunction::expand() "
82858 
82859 [INTERNAL] ";
82860 
82861 %feature("docstring")
82862 casadi::FunctionInternal::instruction_input(casadi_int k) const  "
82863 
82864 [INTERNAL]  Get the (integer) input arguments of an atomic operation.
82865 
82866 ";
82867 
82868 %feature("docstring")  casadi::FunctionInternal::which_depends(const
82869 std::string &s_in, const std::vector< std::string > &s_out, casadi_int
82870 order, bool tr=false) const  "
82871 
82872 [INTERNAL]  Which variables enter with some order.
82873 
82874 Parameters:
82875 -----------
82876 
82877 s_in:   Input name
82878 
82879 s_out:   Output name(s)
82880 
82881 order:  Only 1 (linear) and 2 (nonlinear) allowed
82882 
82883 tr:  Flip the relationship. Return which expressions contain the variables
82884 
82885 ";
82886 
82887 %feature("docstring")  casadi::FunctionInternal::sz_w() const  "
82888 
82889 [INTERNAL]  Get required length of w field.
82890 
82891 ";
82892 
82893 %feature("docstring")  casadi::Sqpmethod::solve_QP(SqpmethodMemory *m, const
82894 double *H, const double *g, const double *lbdz, const double *ubdz, const
82895 double *A, double *x_opt, double *dlam) const  "
82896 
82897 [INTERNAL] ";
82898 
82899 %feature("docstring")  casadi::FunctionInternal::instruction_MX(casadi_int
82900 k) const  "
82901 
82902 [INTERNAL]  get MX expression associated with instruction
82903 
82904 ";
82905 
82906 %feature("docstring")  casadi::Sqpmethod::codegen_declarations(CodeGenerator
82907 &g) const  "
82908 
82909 [INTERNAL]  Generate code for the declarations of the C function.
82910 
82911 ";
82912 
82913 %feature("docstring")  casadi::FunctionInternal::info() const  "
82914 
82915 [INTERNAL]  Obtain information about function
82916 
82917 ";
82918 
82919 %feature("docstring")  casadi::FunctionInternal::is_diff_in(casadi_int i) "
82920 
82921 [INTERNAL] ";
82922 
82923 %feature("docstring")  casadi::FunctionInternal::has_jacobian_sparsity()
82924 const  "
82925 
82926 [INTERNAL]  Get Jacobian sparsity.
82927 
82928 ";
82929 
82930 %feature("docstring")  casadi::Nlpsol::get_default_in(casadi_int ind) const
82931 "
82932 
82933 [INTERNAL]  Get default input value.
82934 
82935 ";
82936 
82937 %feature("docstring")  casadi::ProtoFunction::clear_mem() "
82938 
82939 [INTERNAL]  Clear all memory (called from destructor)
82940 
82941 ";
82942 
82943 %feature("docstring")  casadi::FunctionInternal::getJacSparsity(casadi_int
82944 iind, casadi_int oind, bool symmetric) const  "
82945 
82946 [INTERNAL]  Generate the sparsity of a Jacobian block.
82947 
82948 ";
82949 
82950 %feature("docstring")  casadi::Nlpsol::nlpsol_codegen_body(CodeGenerator &g)
82951 const  "
82952 
82953 [INTERNAL]  Generate code for the function body.
82954 
82955 ";
82956 
82957 %feature("docstring")  casadi::FunctionInternal::replace_aseed(const
82958 std::vector< std::vector< M >> &aseed, casadi_int npar) const  "
82959 
82960 [INTERNAL]  Replace 0-by-0 reverse seeds.
82961 
82962 ";
82963 
82964 %feature("docstring")  casadi::FunctionInternal::replace_aseed(const
82965 std::vector< std::vector< M > > &aseed, casadi_int npar) const  "
82966 
82967 [INTERNAL] ";
82968 
82969 %feature("docstring")  casadi::FunctionInternal::jacobian() const  "
82970 
82971 [INTERNAL]  Return Jacobian of all input elements with respect to all output
82972 elements.
82973 
82974 ";
82975 
82976 %feature("docstring")  casadi::FunctionInternal::sz_res() const  "
82977 
82978 [INTERNAL]  Get required length of res field.
82979 
82980 ";
82981 
82982 %feature("docstring")  casadi::SharedObjectInternal::weak() "
82983 
82984 [INTERNAL]  Get a weak reference to the object.
82985 
82986 ";
82987 
82988 %feature("docstring")  casadi::FunctionInternal::convert_res(const
82989 std::vector< M > &res) const  "
82990 
82991 [INTERNAL]  Convert from/to input/output lists/map.
82992 
82993 ";
82994 
82995 %feature("docstring")  casadi::FunctionInternal::convert_res(const std::map<
82996 std::string, M > &res) const  "
82997 
82998 [INTERNAL]  Convert from/to input/output lists/map.
82999 
83000 ";
83001 
83002 %feature("docstring")  casadi::OracleFunction::create_function(const
83003 std::string &fname, const std::vector< std::string > &s_in, const
83004 std::vector< std::string > &s_out, const Function::AuxOut
83005 &aux=Function::AuxOut()) "
83006 
83007 [INTERNAL]  Create an oracle function
83008 
83009 ";
83010 
83011 %feature("docstring")  casadi::FunctionInternal::alloc_arg(size_t sz_arg,
83012 bool persistent=false) "
83013 
83014 [INTERNAL]  Ensure required length of arg field.
83015 
83016 ";
83017 
83018 %feature("docstring")  casadi::Nlpsol::getReducedHessian() "
83019 
83020 [INTERNAL] ";
83021 
83022 %feature("docstring")  casadi::Nlpsol::disp_more(std::ostream &stream) const
83023 "
83024 
83025 [INTERNAL]  Print description.
83026 
83027 ";
83028 
83029 %feature("docstring")  casadi::FunctionInternal::alloc_iw(size_t sz_iw, bool
83030 persistent=false) "
83031 
83032 [INTERNAL]  Ensure required length of iw field.
83033 
83034 ";
83035 
83036 %feature("docstring")  casadi::Sqpmethod::get_stats(void *mem) const  "
83037 
83038 [INTERNAL]  Get all statistics.
83039 
83040 ";
83041 
83042 %feature("docstring")  casadi::OracleFunction::monitored(const std::string
83043 &name) const  "
83044 
83045 [INTERNAL] ";
83046 
83047 %feature("docstring")  casadi::Nlpsol::integer_support() const  "
83048 
83049 [INTERNAL]  Can discrete variables be treated.
83050 
83051 ";
83052 
83053 %feature("docstring")  casadi::FunctionInternal::get_max_in(casadi_int ind)
83054 const  "
83055 
83056 [INTERNAL]  Get largest input value.
83057 
83058 ";
83059 
83060 %feature("docstring")  casadi::OracleFunction::oracle() const  "
83061 
83062 [INTERNAL]  Get oracle.
83063 
83064 ";
83065 
83066 %feature("docstring")  casadi::Sqpmethod::serialize_body(SerializingStream
83067 &s) const  "
83068 
83069 [INTERNAL]  Serialize an object without type information.
83070 
83071 ";
83072 
83073 %feature("docstring")  casadi::FunctionInternal::sx_out(casadi_int ind)
83074 const  "
83075 
83076 [INTERNAL]  Get function input(s) and output(s)
83077 
83078 ";
83079 
83080 %feature("docstring")  casadi::FunctionInternal::sx_out() const  "
83081 
83082 [INTERNAL]  Get function input(s) and output(s)
83083 
83084 ";
83085 
83086 %feature("docstring")  casadi::Sqpmethod::getConic() const  "
83087 
83088 [INTERNAL]  Access Conic.
83089 
83090 ";
83091 
83092 %feature("docstring")  casadi::Nlpsol::eval(const double **arg, double
83093 **res, casadi_int *iw, double *w, void *mem) const final "
83094 
83095 [INTERNAL]  Evaluate numerically.
83096 
83097 ";
83098 
83099 %feature("docstring")  casadi::FunctionInternal::size1_out(casadi_int ind)
83100 const  "
83101 
83102 [INTERNAL]  Input/output dimensions.
83103 
83104 ";
83105 
83106 %feature("docstring")  casadi::FunctionInternal::replace_arg(const
83107 std::vector< M > &arg, casadi_int npar) const  "
83108 
83109 [INTERNAL]  Replace 0-by-0 inputs.
83110 
83111 ";
83112 
83113 %feature("docstring")  casadi::Nlpsol::get_name_out(casadi_int i)  "
83114 
83115 [INTERNAL]  Names of function input and outputs.
83116 
83117 ";
83118 
83119 %feature("docstring")  casadi::ProtoFunction::checkout() const  "
83120 
83121 [INTERNAL]  Checkout a memory object.
83122 
83123 ";
83124 
83125 %feature("docstring")  casadi::FunctionInternal::reverse(casadi_int nadj)
83126 const  "
83127 
83128 [INTERNAL]  Return function that calculates adjoint derivatives
83129 reverse(nadj) returns a cached instance if available, and calls  Function
83130 get_reverse(casadi_int nadj) if no cached version is available.
83131 
83132 ";
83133 
83134 %feature("docstring")  casadi::FunctionInternal::eval_sx(const SXElem **arg,
83135 SXElem **res, casadi_int *iw, SXElem *w, void *mem) const  "
83136 
83137 [INTERNAL]  Evaluate with symbolic scalars.
83138 
83139 ";
83140 
83141 %feature("docstring")  casadi::FunctionInternal::print_option(const
83142 std::string &name, std::ostream &stream) const  "
83143 
83144 [INTERNAL]  Print all information there is to know about a certain option.
83145 
83146 ";
83147 
83148 %feature("docstring")  casadi::FunctionInternal::definition() const  "
83149 
83150 [INTERNAL]  Get function signature: name:(inputs)->(outputs)
83151 
83152 ";
83153 
83154 %feature("docstring")  casadi::Sqpmethod::print_iteration() const  "
83155 
83156 [INTERNAL]  Print iteration header.
83157 
83158 ";
83159 
83160 %feature("docstring")  casadi::Sqpmethod::print_iteration(casadi_int iter,
83161 double obj, double pr_inf, double du_inf, double dx_norm, double rg,
83162 casadi_int ls_trials, bool ls_success) const  "
83163 
83164 [INTERNAL]  Print iteration.
83165 
83166 ";
83167 
83168 %feature("docstring")  casadi::FunctionInternal::has_derivative() const  "
83169 
83170 [INTERNAL]  Can derivatives be calculated in any way?
83171 
83172 ";
83173 
83174 %feature("docstring")  casadi::Nlpsol::uses_output() const  "
83175 
83176 [INTERNAL]  Do the derivative functions need nondifferentiated outputs?
83177 
83178 ";
83179 
83180 %feature("docstring")  casadi::FunctionInternal::n_instructions() const  "
83181 
83182 [INTERNAL]  Get the number of atomic operations.
83183 
83184 ";
83185 
83186 %feature("docstring")  casadi::FunctionInternal::nz_in(const std::vector< DM
83187 > &arg) const  "
83188 
83189 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
83190 
83191 ";
83192 
83193 %feature("docstring")  casadi::FunctionInternal::nz_in(const std::vector<
83194 double > &arg) const  "
83195 
83196 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
83197 
83198 ";
83199 
83200 %feature("docstring")  casadi::FunctionInternal::export_code(const
83201 std::string &lang, std::ostream &stream, const Dict &options) const  "
83202 
83203 [INTERNAL]  Export function in a specific language.
83204 
83205 ";
83206 
83207 %feature("docstring")  casadi::Nlpsol::kkt() const  "
83208 
83209 [INTERNAL] ";
83210 
83211 %feature("docstring")  casadi::FunctionInternal::all_scalar() const  "
83212 
83213 [INTERNAL]  Are all inputs and outputs scalar.
83214 
83215 ";
83216 
83217 %feature("docstring")  casadi::FunctionInternal::generate_lifted(Function
83218 &vdef_fcn, Function &vinit_fcn) const  "
83219 
83220 [INTERNAL]  Extract the functions needed for the Lifted Newton method.
83221 
83222 ";
83223 
83224 %feature("docstring")  casadi::FunctionInternal::get_abstol() const  "
83225 
83226 [INTERNAL]  Get absolute tolerance.
83227 
83228 ";
83229 
83230 %feature("docstring")  casadi::FunctionInternal::convert_arg(const
83231 std::vector< M > &arg) const  "
83232 
83233 [INTERNAL]  Convert from/to input/output lists/map.
83234 
83235 ";
83236 
83237 %feature("docstring")  casadi::FunctionInternal::convert_arg(const std::map<
83238 std::string, M > &arg) const  "
83239 
83240 [INTERNAL]  Convert from/to input/output lists/map.
83241 
83242 ";
83243 
83244 %feature("docstring")  casadi::FunctionInternal::size_out(casadi_int ind)
83245 const  "
83246 
83247 [INTERNAL]  Input/output dimensions.
83248 
83249 ";
83250 
83251 %feature("docstring")  casadi::FunctionInternal::signature(const std::string
83252 &fname) const  "
83253 
83254 [INTERNAL]  Code generate the function.
83255 
83256 ";
83257 
83258 %feature("docstring")  casadi::ProtoFunction::construct(const Dict &opts) "
83259 
83260 [INTERNAL]  Construct Prepares the function for evaluation.
83261 
83262 ";
83263 
83264 %feature("docstring")  casadi::FunctionInternal::get_min_in(casadi_int ind)
83265 const  "
83266 
83267 [INTERNAL]  Get smallest input value.
83268 
83269 ";
83270 
83271 %feature("docstring")  casadi::OracleFunction::calc_function(OracleMemory
83272 *m, const std::string &fcn, const double *const *arg=nullptr) const  "
83273 
83274 [INTERNAL] ";
83275 
83276 %feature("docstring")
83277 casadi::FunctionInternal::jacobian_sparsity_filter(const Sparsity &sp) const
83278 "
83279 
83280 [INTERNAL]  Filter out nonzeros in the full sparsity jacobian according to
83281 is_diff_in/out.
83282 
83283 ";
83284 
83285 %feature("docstring")  casadi::FunctionInternal::sparsity_jac(casadi_int
83286 iind, casadi_int oind, bool compact, bool symmetric) const  "
83287 
83288 [INTERNAL]  Get, if necessary generate, the sparsity of a Jacobian block.
83289 
83290 ";
83291 
83292 %feature("docstring")
83293 casadi::FunctionInternal::codegen_alloc_mem(CodeGenerator &g) const  "
83294 
83295 [INTERNAL]  Codegen decref for alloc_mem.
83296 
83297 ";
83298 
83299 %feature("docstring")  casadi::FunctionInternal::call_reverse(const
83300 std::vector< MX > &arg, const std::vector< MX > &res, const std::vector<
83301 std::vector< MX > > &aseed, std::vector< std::vector< MX > > &asens, bool
83302 always_inline, bool never_inline) const  "
83303 
83304 [INTERNAL]  Reverse mode, virtual functions overloaded in derived classes.
83305 
83306 ";
83307 
83308 %feature("docstring")  casadi::FunctionInternal::call_reverse(const
83309 std::vector< SX > &arg, const std::vector< SX > &res, const std::vector<
83310 std::vector< SX > > &aseed, std::vector< std::vector< SX > > &asens, bool
83311 always_inline, bool never_inline) const  "
83312 
83313 [INTERNAL]  Reverse mode, virtual functions overloaded in derived classes.
83314 
83315 ";
83316 
83317 %feature("docstring")  casadi::FunctionInternal::tocache(const Function &f,
83318 const std::string &suffix="") const  "
83319 
83320 [INTERNAL]  Save function to cache.
83321 
83322 ";
83323 
83324 %feature("docstring")  casadi::FunctionInternal::sp_forward(const bvec_t
83325 **arg, bvec_t **res, casadi_int *iw, bvec_t *w, void *mem) const  "
83326 
83327 [INTERNAL]  Propagate sparsity forward.
83328 
83329 ";
83330 
83331 %feature("docstring")  casadi::Nlpsol::check_inputs(void *mem) const  "
83332 
83333 [INTERNAL]  Check if the inputs correspond to a well-posed problem.
83334 
83335 ";
83336 
83337 %feature("docstring")  casadi::ProtoFunction::format_time(char *buffer,
83338 double time) const  "
83339 
83340 [INTERNAL]  Format time in a fixed width 8 format.
83341 
83342 ";
83343 
83344 %feature("docstring")  casadi::Nlpsol::serialize_base_function() const  "
83345 
83346 [INTERNAL]  String used to identify the immediate FunctionInternal subclass.
83347 
83348 ";
83349 
83350 %feature("docstring")  casadi::FunctionInternal::nz_out(const std::vector<
83351 DM > &res) const  "
83352 
83353 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
83354 
83355 ";
83356 
83357 %feature("docstring")  casadi::FunctionInternal::nz_out(const std::vector<
83358 double > &res) const  "
83359 
83360 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
83361 
83362 ";
83363 
83364 %feature("docstring")  casadi::Nlpsol::serialize_type(SerializingStream &s)
83365 const  "
83366 
83367 [INTERNAL]  Serialize type information.
83368 
83369 ";
83370 
83371 %feature("docstring")
83372 casadi::FunctionInternal::codegen_incref(CodeGenerator &g) const  "
83373 
83374 [INTERNAL]  Codegen incref for dependencies.
83375 
83376 ";
83377 
83378 %feature("docstring")  casadi::FunctionInternal::project_res(const
83379 std::vector< M > &arg, casadi_int npar) const  "
83380 
83381 [INTERNAL]   Project sparsities.
83382 
83383 ";
83384 
83385 %feature("docstring")  casadi::FunctionInternal::codegen_mem_type() const  "
83386 
83387 [INTERNAL]  Thread-local memory object type.
83388 
83389 ";
83390 
83391 %feature("docstring")  casadi::Nlpsol::get_n_in()  "
83392 
83393 [INTERNAL]  Number of function inputs and outputs.
83394 
83395 ";
83396 
83397 %feature("docstring")  casadi::Sqpmethod::set_work(void *mem, const double
83398 **&arg, double **&res, casadi_int *&iw, double *&w) const  "
83399 
83400 [INTERNAL]  Set the (persistent) work vectors.
83401 
83402 ";
83403 
83404 %feature("docstring")  casadi::Nlpsol::get_name_in(casadi_int i)  "
83405 
83406 [INTERNAL]  Names of function input and outputs.
83407 
83408 ";
83409 
83410 %feature("docstring")  casadi::FunctionInternal::sx_in(casadi_int ind) const
83411 "
83412 
83413 [INTERNAL]  Get function input(s) and output(s)
83414 
83415 ";
83416 
83417 %feature("docstring")  casadi::FunctionInternal::sx_in() const  "
83418 
83419 [INTERNAL]  Get function input(s) and output(s)
83420 
83421 ";
83422 
83423 %feature("docstring")  casadi::FunctionInternal::slice(const std::string
83424 &name, const std::vector< casadi_int > &order_in, const std::vector<
83425 casadi_int > &order_out, const Dict &opts) const  "
83426 
83427 [INTERNAL]  returns a new function with a selection of inputs/outputs of the
83428 original
83429 
83430 ";
83431 
83432 %feature("docstring") casadi::Sqpmethod::Sqpmethod(const std::string &name,
83433 const Function &nlp) "
83434 
83435 [INTERNAL] ";
83436 
83437 %feature("docstring")  casadi::ProtoFunction::memory(int ind) const  "
83438 
83439 [INTERNAL]  Memory objects.
83440 
83441 ";
83442 
83443 %feature("docstring")  casadi::FunctionInternal::instruction_id(casadi_int
83444 k) const  "
83445 
83446 [INTERNAL]  Get an atomic operation operator index.
83447 
83448 ";
83449 
83450 %feature("docstring")  casadi::Sqpmethod::class_name() const  "
83451 
83452 [INTERNAL]  Get type name.
83453 
83454 ";
83455 
83456 %feature("docstring")
83457 casadi::FunctionInternal::instruction_constant(casadi_int k) const  "
83458 
83459 [INTERNAL]  Get the floating point output argument of an atomic operation.
83460 
83461 ";
83462 
83463 %feature("docstring")  casadi::FunctionInternal::has_jacobian() const  "
83464 
83465 [INTERNAL]  Return Jacobian of all input elements with respect to all output
83466 elements.
83467 
83468 ";
83469 
83470 %feature("docstring") casadi::Sqpmethod::~Sqpmethod "
83471 
83472 [INTERNAL] ";
83473 
83474 %feature("docstring")  casadi::FunctionInternal::dm_in(casadi_int ind) const
83475 "
83476 
83477 [INTERNAL]  Get function input(s) and output(s)
83478 
83479 ";
83480 
83481 %feature("docstring")  casadi::FunctionInternal::dm_in() const  "
83482 
83483 [INTERNAL]  Get function input(s) and output(s)
83484 
83485 ";
83486 
83487 %feature("docstring")  casadi::FunctionInternal::matching_res(const
83488 std::vector< M > &arg, casadi_int &npar) const  "
83489 
83490 [INTERNAL]  Check if output arguments that needs to be replaced.
83491 
83492 Raises errors
83493 
83494 Parameters:
83495 -----------
83496 
83497 npar[in]:  normal usage: 1, disallow pararallel calls: -1
83498 
83499 npar:  max number of horizontal repetitions across all arguments (or -1)
83500 
83501 ";
83502 
83503 %feature("docstring")  casadi::FunctionInternal::has_jac() const  "
83504 
83505 [INTERNAL]  Return Jacobian of all input elements with respect to all output
83506 elements.
83507 
83508 ";
83509 
83510 %feature("docstring")  casadi::ProtoFunction::print_time(const std::map<
83511 std::string, FStats > &fstats) const  "
83512 
83513 [INTERNAL]  Print timing statistics.
83514 
83515 ";
83516 
83517 %feature("docstring")  casadi::FunctionInternal::get_partition(casadi_int
83518 iind, casadi_int oind, Sparsity &D1, Sparsity &D2, bool compact, bool
83519 symmetric, bool allow_forward, bool allow_reverse) const  "
83520 
83521 [INTERNAL]  Get the unidirectional or bidirectional partition.
83522 
83523 ";
83524 
83525 %feature("docstring")  casadi::FunctionInternal::factory(const std::string
83526 &name, const std::vector< std::string > &s_in, const std::vector<
83527 std::string > &s_out, const Function::AuxOut &aux, const Dict &opts) const
83528 "
83529 
83530 [INTERNAL] ";
83531 
83532 %feature("docstring")  casadi::Nlpsol::is_a(const std::string &type, bool
83533 recursive) const  "
83534 
83535 [INTERNAL]  Check if the function is of a particular type.
83536 
83537 ";
83538 
83539 
83540 // File: classcasadi_1_1Logger_1_1Stream.xml
83541 %feature("docstring") casadi::Logger::Stream "
83542 
83543 C++ includes: casadi_logger.hpp ";
83544 
83545 
83546 // File: classcasadi_1_1Logger_1_1Streambuf.xml
83547 %feature("docstring") casadi::Logger::Streambuf "
83548 
83549 C++ includes: casadi_logger.hpp ";
83550 
83551 
83552 // File: classcasadi_1_1StringDeserializer.xml
83553 %feature("docstring") casadi::StringDeserializer "
83554 
83555 C++ includes: serializer.hpp ";
83556 
83557 %feature("docstring") casadi::StringDeserializer::StringDeserializer(const
83558 std::string &string) "
83559 
83560 Advanced deserialization of CasADi objects.
83561 
83562 StringDeserializer
83563 
83564 ";
83565 
83566 %feature("docstring")  casadi::StringDeserializer::decode(const std::string
83567 &string) "
83568 
83569 Sets the string to deserialize objects from.
83570 
83571 ";
83572 
83573 
83574 // File: classcasadi_1_1StringSerializer.xml
83575 %feature("docstring")  casadi::StringSerializer::encode() "
83576 
83577 Returns a string that holds the serialized objects.
83578 
83579 As a side effect, this method clears the internal buffer
83580 
83581 ";
83582 
83583 %feature("docstring") casadi::StringSerializer "
83584 
83585 C++ includes: serializer.hpp ";
83586 
83587 
83588 // File: classcasadi_1_1SubAssign.xml
83589 
83590 
83591 // File: classcasadi_1_1SubIndex.xml
83592 %feature("docstring") casadi::SubIndex "
83593 
83594 SubIndex class for Matrix Same as the above class but for single argument
83595 return for operator() Joel Andersson
83596 
83597 C++ includes: submatrix.hpp ";
83598 
83599 %feature("docstring") casadi::SubIndex< M, I >::SubIndex(M &mat, const I &i)
83600 "
83601 
83602 Constructor.
83603 
83604 ";
83605 
83606 
83607 // File: classcasadi_1_1SubMatrix.xml
83608 %feature("docstring") casadi::SubMatrix "
83609 
83610 SubMatrix class for Matrix SubMatrix is the return type for operator() of
83611 the Matrix class, it allows access to the value as well as changing the
83612 parent object Joel Andersson
83613 
83614 C++ includes: submatrix.hpp ";
83615 
83616 %feature("docstring") casadi::SubMatrix< M, I, J >::SubMatrix(M &mat, const
83617 I &i, const J &j) "
83618 
83619 Constructor.
83620 
83621 ";
83622 
83623 
83624 // File: classcasadi_1_1SubRef.xml
83625 
83626 
83627 // File: classcasadi_1_1Switch.xml
83628 %feature("docstring")  casadi::FunctionInternal::slice(const std::string
83629 &name, const std::vector< casadi_int > &order_in, const std::vector<
83630 casadi_int > &order_out, const Dict &opts) const  "
83631 
83632 [INTERNAL]  returns a new function with a selection of inputs/outputs of the
83633 original
83634 
83635 ";
83636 
83637 %feature("docstring")  casadi::FunctionInternal::call_forward(const
83638 std::vector< MX > &arg, const std::vector< MX > &res, const std::vector<
83639 std::vector< MX > > &fseed, std::vector< std::vector< MX > > &fsens, bool
83640 always_inline, bool never_inline) const  "
83641 
83642 [INTERNAL]  Forward mode AD, virtual functions overloaded in derived
83643 classes.
83644 
83645 ";
83646 
83647 %feature("docstring")  casadi::FunctionInternal::call_forward(const
83648 std::vector< SX > &arg, const std::vector< SX > &res, const std::vector<
83649 std::vector< SX > > &fseed, std::vector< std::vector< SX > > &fsens, bool
83650 always_inline, bool never_inline) const  "
83651 
83652 [INTERNAL]  Forward mode AD, virtual functions overloaded in derived
83653 classes.
83654 
83655 ";
83656 
83657 %feature("docstring")  casadi::FunctionInternal::symbolic_output(const
83658 std::vector< MX > &arg) const  "
83659 
83660 [INTERNAL]  Get a vector of symbolic variables corresponding to the outputs.
83661 
83662 ";
83663 
83664 %feature("docstring")  casadi::Switch::disp_more(std::ostream &stream) const
83665 "
83666 
83667 [INTERNAL]  Print description.
83668 
83669 ";
83670 
83671 %feature("docstring")  casadi::FunctionInternal::size2_out(casadi_int ind)
83672 const  "
83673 
83674 [INTERNAL]  Input/output dimensions.
83675 
83676 ";
83677 
83678 %feature("docstring")  casadi::FunctionInternal::n_nodes() const  "
83679 
83680 [INTERNAL]  Number of nodes in the algorithm.
83681 
83682 ";
83683 
83684 %feature("docstring")  casadi::FunctionInternal::symbolicAdjSeed(casadi_int
83685 nadj, const std::vector< MatType > &v) const  "
83686 
83687 [INTERNAL]  Symbolic expressions for the adjoint seeds.
83688 
83689 ";
83690 
83691 %feature("docstring")  casadi::FunctionInternal::check_res(const
83692 std::vector< M > &res, casadi_int &npar) const  "
83693 
83694 [INTERNAL]  Check if output arguments have correct length and dimensions.
83695 
83696 Raises errors.
83697 
83698 Parameters:
83699 -----------
83700 
83701 npar[in]:  normal usage: 1, disallow pararallel calls: -1
83702 
83703 npar:  max number of horizontal repetitions across all arguments (or -1)
83704 
83705 ";
83706 
83707 %feature("docstring")  casadi::FunctionInternal::has_jacobian() const  "
83708 
83709 [INTERNAL]  Return Jacobian of all input elements with respect to all output
83710 elements.
83711 
83712 ";
83713 
83714 %feature("docstring")  casadi::Switch::eval(const double **arg, double
83715 **res, casadi_int *iw, double *w, void *mem) const  "
83716 
83717 [INTERNAL]  Evaluate numerically, work vectors given.
83718 
83719 ";
83720 
83721 %feature("docstring")  casadi::FunctionInternal::replace_aseed(const
83722 std::vector< std::vector< M >> &aseed, casadi_int npar) const  "
83723 
83724 [INTERNAL]  Replace 0-by-0 reverse seeds.
83725 
83726 ";
83727 
83728 %feature("docstring")  casadi::FunctionInternal::replace_aseed(const
83729 std::vector< std::vector< M > > &aseed, casadi_int npar) const  "
83730 
83731 [INTERNAL] ";
83732 
83733 %feature("docstring")  casadi::FunctionInternal::fwdViaJac(casadi_int nfwd)
83734 const  "
83735 
83736 [INTERNAL]  Calculate derivatives by multiplying the full Jacobian and
83737 multiplying.
83738 
83739 ";
83740 
83741 %feature("docstring")  casadi::FunctionInternal::sparsity_in(casadi_int ind)
83742 const  "
83743 
83744 [INTERNAL]  Input/output sparsity.
83745 
83746 ";
83747 
83748 %feature("docstring")  casadi::FunctionInternal::getJacSparsity(casadi_int
83749 iind, casadi_int oind, bool symmetric) const  "
83750 
83751 [INTERNAL]  Generate the sparsity of a Jacobian block.
83752 
83753 ";
83754 
83755 %feature("docstring")  casadi::SharedObjectInternal::weak() "
83756 
83757 [INTERNAL]  Get a weak reference to the object.
83758 
83759 ";
83760 
83761 %feature("docstring")  casadi::FunctionInternal::size1_out(casadi_int ind)
83762 const  "
83763 
83764 [INTERNAL]  Input/output dimensions.
83765 
83766 ";
83767 
83768 %feature("docstring")  casadi::FunctionInternal::wrap_as_needed(const Dict
83769 &opts) const  "
83770 
83771 [INTERNAL]  Wrap in an Function instance consisting of only one MX call.
83772 
83773 ";
83774 
83775 %feature("docstring")  casadi::FunctionInternal::which_depends(const
83776 std::string &s_in, const std::vector< std::string > &s_out, casadi_int
83777 order, bool tr=false) const  "
83778 
83779 [INTERNAL]  Which variables enter with some order.
83780 
83781 Parameters:
83782 -----------
83783 
83784 s_in:   Input name
83785 
83786 s_out:   Output name(s)
83787 
83788 order:  Only 1 (linear) and 2 (nonlinear) allowed
83789 
83790 tr:  Flip the relationship. Return which expressions contain the variables
83791 
83792 ";
83793 
83794 %feature("docstring")  casadi::FunctionInternal::alloc_iw(size_t sz_iw, bool
83795 persistent=false) "
83796 
83797 [INTERNAL]  Ensure required length of iw field.
83798 
83799 ";
83800 
83801 %feature("docstring")  casadi::FunctionInternal::eval_gen(const double
83802 **arg, double **res, casadi_int *iw, double *w, void *mem) const  "
83803 
83804 [INTERNAL]  Evaluate numerically.
83805 
83806 ";
83807 
83808 %feature("docstring")  casadi::FunctionInternal::eval_gen(const SXElem
83809 **arg, SXElem **res, casadi_int *iw, SXElem *w, void *mem) const  "
83810 
83811 [INTERNAL]  Evaluate a function, overloaded.
83812 
83813 ";
83814 
83815 %feature("docstring")  casadi::FunctionInternal::eval_gen(const bvec_t
83816 **arg, bvec_t **res, casadi_int *iw, bvec_t *w, void *mem) const  "
83817 
83818 [INTERNAL]  Evaluate a function, overloaded.
83819 
83820 ";
83821 
83822 %feature("docstring")  casadi::Switch::get_forward(casadi_int nfwd, const
83823 std::string &name, const std::vector< std::string > &inames, const
83824 std::vector< std::string > &onames, const Dict &opts) const  "
83825 
83826 [INTERNAL]  Generate a function that calculates nfwd forward derivatives.
83827 
83828 ";
83829 
83830 %feature("docstring")  casadi::FunctionInternal::is_a(const std::string
83831 &type, bool recursive) const  "
83832 
83833 [INTERNAL]  Check if the function is of a particular type.
83834 
83835 ";
83836 
83837 %feature("docstring")  casadi::FunctionInternal::has_derivative() const  "
83838 
83839 [INTERNAL]  Can derivatives be calculated in any way?
83840 
83841 ";
83842 
83843 %feature("docstring")  casadi::FunctionInternal::has_jac() const  "
83844 
83845 [INTERNAL]  Return Jacobian of all input elements with respect to all output
83846 elements.
83847 
83848 ";
83849 
83850 %feature("docstring")  casadi::FunctionInternal::get_max_in(casadi_int ind)
83851 const  "
83852 
83853 [INTERNAL]  Get largest input value.
83854 
83855 ";
83856 
83857 %feature("docstring")  casadi::FunctionInternal::tocache(const Function &f,
83858 const std::string &suffix="") const  "
83859 
83860 [INTERNAL]  Save function to cache.
83861 
83862 ";
83863 
83864 %feature("docstring")
83865 casadi::FunctionInternal::codegen_sparsities(CodeGenerator &g) const  "
83866 
83867 [INTERNAL]  Codegen sparsities.
83868 
83869 ";
83870 
83871 %feature("docstring")  casadi::FunctionInternal::call(const std::vector< M >
83872 &arg, std::vector< M > &res, bool always_inline, bool never_inline) const  "
83873 
83874 [INTERNAL]   Call a function, templated.
83875 
83876 ";
83877 
83878 %feature("docstring")  casadi::FunctionInternal::nnz_out() const  "
83879 
83880 [INTERNAL]  Number of input/output nonzeros.
83881 
83882 ";
83883 
83884 %feature("docstring")  casadi::FunctionInternal::nnz_out(casadi_int ind)
83885 const  "
83886 
83887 [INTERNAL]  Number of input/output nonzeros.
83888 
83889 ";
83890 
83891 %feature("docstring")  casadi::FunctionInternal::get_name_in(casadi_int i) "
83892 
83893 [INTERNAL]  Names of function input and outputs.
83894 
83895 ";
83896 
83897 %feature("docstring")  casadi::Switch::serialize_body(SerializingStream &s)
83898 const  "
83899 
83900 [INTERNAL]  Serialize an object without type information.
83901 
83902 ";
83903 
83904 %feature("docstring")  casadi::FunctionInternal::numel_out(casadi_int ind)
83905 const  "
83906 
83907 [INTERNAL]  Number of input/output elements.
83908 
83909 ";
83910 
83911 %feature("docstring")  casadi::FunctionInternal::numel_out() const  "
83912 
83913 [INTERNAL]  Number of input/output elements.
83914 
83915 ";
83916 
83917 %feature("docstring")  casadi::FunctionInternal::set_work(void *mem, const
83918 double **&arg, double **&res, casadi_int *&iw, double *&w) const  "
83919 
83920 [INTERNAL]  Set the (persistent) work vectors.
83921 
83922 ";
83923 
83924 %feature("docstring")  casadi::FunctionInternal::replace_res(const
83925 std::vector< M > &res, casadi_int npar) const  "
83926 
83927 [INTERNAL]  Replace 0-by-0 outputs.
83928 
83929 ";
83930 
83931 %feature("docstring")  casadi::FunctionInternal::set_temp(void *mem, const
83932 double **arg, double **res, casadi_int *iw, double *w) const  "
83933 
83934 [INTERNAL]  Set the (temporary) work vectors.
83935 
83936 ";
83937 
83938 %feature("docstring")  casadi::FunctionInternal::get_partition(casadi_int
83939 iind, casadi_int oind, Sparsity &D1, Sparsity &D2, bool compact, bool
83940 symmetric, bool allow_forward, bool allow_reverse) const  "
83941 
83942 [INTERNAL]  Get the unidirectional or bidirectional partition.
83943 
83944 ";
83945 
83946 %feature("docstring")  casadi::Switch::has_forward(casadi_int nfwd) const  "
83947 
83948 [INTERNAL]  Generate a function that calculates nfwd forward derivatives.
83949 
83950 ";
83951 
83952 %feature("docstring")  casadi::ProtoFunction::serialize_base_function()
83953 const  "
83954 
83955 [INTERNAL]  String used to identify the immediate FunctionInternal subclass.
83956 
83957 ";
83958 
83959 %feature("docstring")  casadi::FunctionInternal::adjViaJac(casadi_int nadj)
83960 const  "
83961 
83962 [INTERNAL]  Calculate derivatives by multiplying the full Jacobian and
83963 multiplying.
83964 
83965 ";
83966 
83967 %feature("docstring")  casadi::FunctionInternal::jacobian_sparsity() const
83968 "
83969 
83970 [INTERNAL]  Get Jacobian sparsity.
83971 
83972 ";
83973 
83974 %feature("docstring")  casadi::FunctionInternal::free_sx() const  "
83975 
83976 [INTERNAL]  Get free variables (SX)
83977 
83978 ";
83979 
83980 %feature("docstring")  casadi::FunctionInternal::get_min_in(casadi_int ind)
83981 const  "
83982 
83983 [INTERNAL]  Get smallest input value.
83984 
83985 ";
83986 
83987 %feature("docstring")  casadi::Switch::has_codegen() const  "
83988 
83989 [INTERNAL]  Is codegen supported?
83990 
83991 ";
83992 
83993 %feature("docstring")  casadi::FunctionInternal::check_arg(const
83994 std::vector< M > &arg, casadi_int &npar) const  "
83995 
83996 [INTERNAL]  Check if input arguments have correct length and dimensions.
83997 
83998 Raises errors.
83999 
84000 Parameters:
84001 -----------
84002 
84003 npar[in]:  normal usage: 1, disallow pararallel calls: -1
84004 
84005 npar:  max number of horizontal repetitions across all arguments (or -1)
84006 
84007 ";
84008 
84009 %feature("docstring")  casadi::FunctionInternal::matching_arg(const
84010 std::vector< M > &arg, casadi_int &npar) const  "
84011 
84012 [INTERNAL]  Check if input arguments that needs to be replaced.
84013 
84014 Raises errors
84015 
84016 Parameters:
84017 -----------
84018 
84019 npar[in]:  normal usage: 1, disallow pararallel calls: -1
84020 
84021 npar:  max number of horizontal repetitions across all arguments (or -1)
84022 
84023 ";
84024 
84025 %feature("docstring")
84026 casadi::FunctionInternal::instruction_output(casadi_int k) const  "
84027 
84028 [INTERNAL]  Get the (integer) output argument of an atomic operation.
84029 
84030 ";
84031 
84032 %feature("docstring")  casadi::FunctionInternal::print_option(const
84033 std::string &name, std::ostream &stream) const  "
84034 
84035 [INTERNAL]  Print all information there is to know about a certain option.
84036 
84037 ";
84038 
84039 %feature("docstring")  casadi::FunctionInternal::size1_in(casadi_int ind)
84040 const  "
84041 
84042 [INTERNAL]  Input/output dimensions.
84043 
84044 ";
84045 
84046 %feature("docstring") casadi::Switch::~Switch "
84047 
84048 [INTERNAL]  Destructor.
84049 
84050 ";
84051 
84052 %feature("docstring")  casadi::ProtoFunction::free_mem(void *mem) const  "
84053 
84054 [INTERNAL]  Free memory block.
84055 
84056 ";
84057 
84058 %feature("docstring")  casadi::Switch::info() const  "
84059 
84060 [INTERNAL]  Obtain information about node
84061 
84062 ";
84063 
84064 %feature("docstring")  casadi::FunctionInternal::has_spfwd() const  "
84065 
84066 [INTERNAL]  Is the class able to propagate seeds through the algorithm?
84067 
84068 ";
84069 
84070 %feature("docstring")  casadi::FunctionInternal::sx_in(casadi_int ind) const
84071 "
84072 
84073 [INTERNAL]  Get function input(s) and output(s)
84074 
84075 ";
84076 
84077 %feature("docstring")  casadi::FunctionInternal::sx_in() const  "
84078 
84079 [INTERNAL]  Get function input(s) and output(s)
84080 
84081 ";
84082 
84083 %feature("docstring")  casadi::Switch::init(const Dict &opts)  "
84084 
84085 [INTERNAL]  Initialize.
84086 
84087 ";
84088 
84089 %feature("docstring")  casadi::ProtoFunction::print(const char *fmt,...)
84090 const  "
84091 
84092 [INTERNAL]  C-style formatted printing during evaluation.
84093 
84094 ";
84095 
84096 %feature("docstring")  casadi::FunctionInternal::codegen_mem(CodeGenerator
84097 &g, const std::string &index="mem") const  "
84098 
84099 [INTERNAL]  Get thread-local memory object.
84100 
84101 ";
84102 
84103 %feature("docstring")  casadi::Switch::codegen_body(CodeGenerator &g) const
84104 "
84105 
84106 [INTERNAL]  Generate code for the body of the C function.
84107 
84108 ";
84109 
84110 %feature("docstring")  casadi::FunctionInternal::n_instructions() const  "
84111 
84112 [INTERNAL]  Get the number of atomic operations.
84113 
84114 ";
84115 
84116 %feature("docstring")  casadi::ProtoFunction::init_mem(void *mem) const  "
84117 
84118 [INTERNAL]  Initalize memory block.
84119 
84120 ";
84121 
84122 %feature("docstring")  casadi::ProtoFunction::construct(const Dict &opts) "
84123 
84124 [INTERNAL]  Construct Prepares the function for evaluation.
84125 
84126 ";
84127 
84128 %feature("docstring")  casadi::FunctionInternal::generate_in(const
84129 std::string &fname, const double **arg) const  "
84130 
84131 [INTERNAL]  Export an input file that can be passed to generate C code with
84132 a main.
84133 
84134 ";
84135 
84136 %feature("docstring")  casadi::FunctionInternal::sz_work(size_t &sz_arg,
84137 size_t &sz_res, size_t &sz_iw, size_t &sz_w) const  "
84138 
84139 [INTERNAL]  Get number of temporary variables needed.
84140 
84141 ";
84142 
84143 %feature("docstring")  casadi::ProtoFunction::memory(int ind) const  "
84144 
84145 [INTERNAL]  Memory objects.
84146 
84147 ";
84148 
84149 %feature("docstring")  casadi::ProtoFunction::clear_mem() "
84150 
84151 [INTERNAL]  Clear all memory (called from destructor)
84152 
84153 ";
84154 
84155 %feature("docstring")  casadi::FunctionInternal::get_name_out(casadi_int i)
84156 "
84157 
84158 [INTERNAL]  Names of function input and outputs.
84159 
84160 ";
84161 
84162 %feature("docstring")  casadi::FunctionInternal::index_out(const std::string
84163 &name) const  "
84164 
84165 [INTERNAL]  Get output scheme index by name.
84166 
84167 ";
84168 
84169 %feature("docstring")  casadi::FunctionInternal::sz_iw() const  "
84170 
84171 [INTERNAL]  Get required length of iw field.
84172 
84173 ";
84174 
84175 %feature("docstring")  casadi::FunctionInternal::instructions_sx() const  "
84176 
84177 [INTERNAL]  get SX expression associated with instructions
84178 
84179 ";
84180 
84181 %feature("docstring")  casadi::FunctionInternal::replace_arg(const
84182 std::vector< M > &arg, casadi_int npar) const  "
84183 
84184 [INTERNAL]  Replace 0-by-0 inputs.
84185 
84186 ";
84187 
84188 %feature("docstring")  casadi::FunctionInternal::size_out(casadi_int ind)
84189 const  "
84190 
84191 [INTERNAL]  Input/output dimensions.
84192 
84193 ";
84194 
84195 %feature("docstring")  casadi::FunctionInternal::fwd_seed(casadi_int nfwd)
84196 const  "
84197 
84198 [INTERNAL]  Symbolic expressions for the forward seeds.
84199 
84200 ";
84201 
84202 %feature("docstring")
84203 casadi::FunctionInternal::codegen_free_mem(CodeGenerator &g) const  "
84204 
84205 [INTERNAL]  Codegen for free_mem.
84206 
84207 ";
84208 
84209 %feature("docstring")  casadi::FunctionInternal::codegen(CodeGenerator &g,
84210 const std::string &fname) const  "
84211 
84212 [INTERNAL]  Generate code the function.
84213 
84214 ";
84215 
84216 %feature("docstring")  casadi::FunctionInternal::dm_out(casadi_int ind)
84217 const  "
84218 
84219 [INTERNAL]  Get function input(s) and output(s)
84220 
84221 ";
84222 
84223 %feature("docstring")  casadi::FunctionInternal::dm_out() const  "
84224 
84225 [INTERNAL]  Get function input(s) and output(s)
84226 
84227 ";
84228 
84229 %feature("docstring")  casadi::ProtoFunction::get_stats(void *mem) const  "
84230 
84231 [INTERNAL]  Get all statistics.
84232 
84233 ";
84234 
84235 %feature("docstring")
84236 casadi::FunctionInternal::codegen_alloc_mem(CodeGenerator &g) const  "
84237 
84238 [INTERNAL]  Codegen decref for alloc_mem.
84239 
84240 ";
84241 
84242 %feature("docstring")  casadi::FunctionInternal::size2_in(casadi_int ind)
84243 const  "
84244 
84245 [INTERNAL]  Input/output dimensions.
84246 
84247 ";
84248 
84249 %feature("docstring")  casadi::FunctionInternal::get_jacobian_sparsity()
84250 const  "
84251 
84252 [INTERNAL]  Get Jacobian sparsity.
84253 
84254 ";
84255 
84256 %feature("docstring")  casadi::ProtoFunction::print_time(const std::map<
84257 std::string, FStats > &fstats) const  "
84258 
84259 [INTERNAL]  Print timing statistics.
84260 
84261 ";
84262 
84263 %feature("docstring")  casadi::FunctionInternal::check_mat(const Sparsity
84264 &arg, const Sparsity &inp, casadi_int &npar) "
84265 
84266 [INTERNAL]  Helper function
84267 
84268 Parameters:
84269 -----------
84270 
84271 npar[in]:  normal usage: 1, disallow pararallel calls: -1
84272 
84273 npar[out]:  required number of parallel calls (or -1)
84274 
84275 ";
84276 
84277 %feature("docstring")  casadi::FunctionInternal::generate_options(bool
84278 is_temp=false) const  "
84279 
84280 [INTERNAL]  Reconstruct options dict.
84281 
84282 ";
84283 
84284 %feature("docstring")  casadi::FunctionInternal::alloc(const Function &f,
84285 bool persistent=false) "
84286 
84287 [INTERNAL]  Ensure work vectors long enough to evaluate function.
84288 
84289 ";
84290 
84291 %feature("docstring")  casadi::FunctionInternal::get_default_in(casadi_int
84292 ind) const  "
84293 
84294 [INTERNAL]  Get default input value.
84295 
84296 ";
84297 
84298 %feature("docstring")  casadi::FunctionInternal::sx_out(casadi_int ind)
84299 const  "
84300 
84301 [INTERNAL]  Get function input(s) and output(s)
84302 
84303 ";
84304 
84305 %feature("docstring")  casadi::FunctionInternal::sx_out() const  "
84306 
84307 [INTERNAL]  Get function input(s) and output(s)
84308 
84309 ";
84310 
84311 %feature("docstring")  casadi::FunctionInternal::dm_in(casadi_int ind) const
84312 "
84313 
84314 [INTERNAL]  Get function input(s) and output(s)
84315 
84316 ";
84317 
84318 %feature("docstring")  casadi::FunctionInternal::dm_in() const  "
84319 
84320 [INTERNAL]  Get function input(s) and output(s)
84321 
84322 ";
84323 
84324 %feature("docstring")  casadi::FunctionInternal::sp_forward(const bvec_t
84325 **arg, bvec_t **res, casadi_int *iw, bvec_t *w, void *mem) const  "
84326 
84327 [INTERNAL]  Propagate sparsity forward.
84328 
84329 ";
84330 
84331 %feature("docstring")  casadi::FunctionInternal::mx_out(casadi_int ind)
84332 const  "
84333 
84334 [INTERNAL]  Get function input(s) and output(s)
84335 
84336 ";
84337 
84338 %feature("docstring")  casadi::FunctionInternal::mx_out() const  "
84339 
84340 [INTERNAL]  Get function input(s) and output(s)
84341 
84342 ";
84343 
84344 %feature("docstring")
84345 casadi::FunctionInternal::getJacSparsityGen(casadi_int iind, casadi_int
84346 oind, bool symmetric, casadi_int gr_i=1, casadi_int gr_o=1) const  "
84347 
84348 [INTERNAL]  Get the sparsity pattern, forward mode.
84349 
84350 ";
84351 
84352 %feature("docstring")  casadi::FunctionInternal::sz_res() const  "
84353 
84354 [INTERNAL]  Get required length of res field.
84355 
84356 ";
84357 
84358 %feature("docstring")  casadi::ProtoFunction::format_time(char *buffer,
84359 double time) const  "
84360 
84361 [INTERNAL]  Format time in a fixed width 8 format.
84362 
84363 ";
84364 
84365 %feature("docstring")  casadi::Switch::get_sparsity_in(casadi_int i)  "
84366 
84367 [INTERNAL]  Sparsities of function inputs and outputs.
84368 
84369 ";
84370 
84371 %feature("docstring")
84372 casadi::FunctionInternal::codegen_incref(CodeGenerator &g) const  "
84373 
84374 [INTERNAL]  Codegen incref for dependencies.
84375 
84376 ";
84377 
84378 %feature("docstring")  casadi::FunctionInternal::index_in(const std::string
84379 &name) const  "
84380 
84381 [INTERNAL]  Get input scheme index by name.
84382 
84383 ";
84384 
84385 %feature("docstring")  casadi::FunctionInternal::numel_in() const  "
84386 
84387 [INTERNAL]  Number of input/output elements.
84388 
84389 ";
84390 
84391 %feature("docstring")  casadi::FunctionInternal::numel_in(casadi_int ind)
84392 const  "
84393 
84394 [INTERNAL]  Number of input/output elements.
84395 
84396 ";
84397 
84398 %feature("docstring")  casadi::SharedObjectInternal::getCount() const  "
84399 
84400 [INTERNAL]  Get the reference count.
84401 
84402 ";
84403 
84404 %feature("docstring")  casadi::FunctionInternal::matching_res(const
84405 std::vector< M > &arg, casadi_int &npar) const  "
84406 
84407 [INTERNAL]  Check if output arguments that needs to be replaced.
84408 
84409 Raises errors
84410 
84411 Parameters:
84412 -----------
84413 
84414 npar[in]:  normal usage: 1, disallow pararallel calls: -1
84415 
84416 npar:  max number of horizontal repetitions across all arguments (or -1)
84417 
84418 ";
84419 
84420 %feature("docstring")  casadi::FunctionInternal::generate_dependencies(const
84421 std::string &fname, const Dict &opts) const  "
84422 
84423 [INTERNAL]  Export / Generate C code for the dependency function.
84424 
84425 ";
84426 
84427 %feature("docstring")
84428 casadi::FunctionInternal::instruction_constant(casadi_int k) const  "
84429 
84430 [INTERNAL]  Get the floating point output argument of an atomic operation.
84431 
84432 ";
84433 
84434 %feature("docstring")  casadi::FunctionInternal::size_in(casadi_int ind)
84435 const  "
84436 
84437 [INTERNAL]  Input/output dimensions.
84438 
84439 ";
84440 
84441 %feature("docstring")  casadi::FunctionInternal::codegen_meta(CodeGenerator
84442 &g) const  "
84443 
84444 [INTERNAL]  Generate meta-information allowing a user to evaluate a
84445 generated function.
84446 
84447 ";
84448 
84449 %feature("docstring")  casadi::FunctionInternal::sparsity_out(casadi_int
84450 ind) const  "
84451 
84452 [INTERNAL]  Input/output sparsity.
84453 
84454 ";
84455 
84456 %feature("docstring")  casadi::FunctionInternal::sparsity_jac(casadi_int
84457 iind, casadi_int oind, bool compact, bool symmetric) const  "
84458 
84459 [INTERNAL]  Get, if necessary generate, the sparsity of a Jacobian block.
84460 
84461 ";
84462 
84463 %feature("docstring")  casadi::FunctionInternal::alloc_w(size_t sz_w, bool
84464 persistent=false) "
84465 
84466 [INTERNAL]  Ensure required length of w field.
84467 
84468 ";
84469 
84470 %feature("docstring")  casadi::FunctionInternal::factory(const std::string
84471 &name, const std::vector< std::string > &s_in, const std::vector<
84472 std::string > &s_out, const Function::AuxOut &aux, const Dict &opts) const
84473 "
84474 
84475 [INTERNAL] ";
84476 
84477 %feature("docstring")  casadi::FunctionInternal::wrap() const  "
84478 
84479 [INTERNAL]  Wrap in an Function instance consisting of only one MX call.
84480 
84481 ";
84482 
84483 %feature("docstring")  casadi::Switch::codegen_declarations(CodeGenerator
84484 &g) const  "
84485 
84486 [INTERNAL]  Generate code for the declarations of the C function.
84487 
84488 ";
84489 
84490 %feature("docstring")  casadi::FunctionInternal::eval_mx(const MXVector
84491 &arg, MXVector &res, bool always_inline, bool never_inline) const  "
84492 
84493 [INTERNAL]  Evaluate with symbolic matrices.
84494 
84495 ";
84496 
84497 %feature("docstring")  casadi::FunctionInternal::self() const  "
84498 
84499 [INTERNAL]  Get a public class instance.
84500 
84501 ";
84502 
84503 %feature("docstring")
84504 casadi::FunctionInternal::getJacSparsityHierarchicalSymm(casadi_int iind,
84505 casadi_int oind) const  "
84506 
84507 [INTERNAL]  A flavor of getJacSparsity that does hierarchical block
84508 structure recognition for symmetric Jacobians
84509 
84510 ";
84511 
84512 %feature("docstring")
84513 casadi::FunctionInternal::codegen_init_mem(CodeGenerator &g) const  "
84514 
84515 [INTERNAL]  Codegen decref for init_mem.
84516 
84517 ";
84518 
84519 %feature("docstring")
84520 casadi::FunctionInternal::jacobian_sparsity_filter(const Sparsity &sp) const
84521 "
84522 
84523 [INTERNAL]  Filter out nonzeros in the full sparsity jacobian according to
84524 is_diff_in/out.
84525 
84526 ";
84527 
84528 %feature("docstring")  casadi::FunctionInternal::sp_weight() const  "
84529 
84530 [INTERNAL]  Weighting factor for chosing forward/reverse mode, sparsity
84531 propagation.
84532 
84533 ";
84534 
84535 %feature("docstring")
84536 casadi::FunctionInternal::serialize_type(SerializingStream &s) const  "
84537 
84538 [INTERNAL]  Serialize type information.
84539 
84540 ";
84541 
84542 %feature("docstring")  casadi::Switch::class_name() const  "
84543 
84544 [INTERNAL]  Get type name.
84545 
84546 ";
84547 
84548 %feature("docstring")  casadi::FunctionInternal::export_code(const
84549 std::string &lang, std::ostream &stream, const Dict &options) const  "
84550 
84551 [INTERNAL]  Export function in a specific language.
84552 
84553 ";
84554 
84555 %feature("docstring")  casadi::FunctionInternal::is_diff_out(casadi_int i) "
84556 
84557 [INTERNAL] ";
84558 
84559 %feature("docstring")  casadi::FunctionInternal::has_eval_dm() const  "
84560 
84561 [INTERNAL]  Evaluate with DM matrices.
84562 
84563 ";
84564 
84565 %feature("docstring")  casadi::FunctionInternal::signature(const std::string
84566 &fname) const  "
84567 
84568 [INTERNAL]  Code generate the function.
84569 
84570 ";
84571 
84572 %feature("docstring")  casadi::FunctionInternal::mx_in(casadi_int ind) const
84573 "
84574 
84575 [INTERNAL]  Get function input(s) and output(s)
84576 
84577 ";
84578 
84579 %feature("docstring")  casadi::FunctionInternal::mx_in() const  "
84580 
84581 [INTERNAL]  Get function input(s) and output(s)
84582 
84583 ";
84584 
84585 %feature("docstring")  casadi::FunctionInternal::get_options() const  "
84586 
84587 [INTERNAL]  Options.
84588 
84589 ";
84590 
84591 %feature("docstring")  casadi::FunctionInternal::disp(std::ostream &stream,
84592 bool more) const  "
84593 
84594 [INTERNAL]  Display object.
84595 
84596 ";
84597 
84598 %feature("docstring")  casadi::FunctionInternal::map(casadi_int n, const
84599 std::string &parallelization) const  "
84600 
84601 [INTERNAL]  Generate/retrieve cached serial map.
84602 
84603 ";
84604 
84605 %feature("docstring")  casadi::FunctionInternal::has_sprev() const  "
84606 
84607 [INTERNAL]  Is the class able to propagate seeds through the algorithm?
84608 
84609 ";
84610 
84611 %feature("docstring")  casadi::FunctionInternal::instruction_MX(casadi_int
84612 k) const  "
84613 
84614 [INTERNAL]  get MX expression associated with instruction
84615 
84616 ";
84617 
84618 %feature("docstring")  casadi::FunctionInternal::convert_res(const
84619 std::vector< M > &res) const  "
84620 
84621 [INTERNAL]  Convert from/to input/output lists/map.
84622 
84623 ";
84624 
84625 %feature("docstring")  casadi::FunctionInternal::convert_res(const std::map<
84626 std::string, M > &res) const  "
84627 
84628 [INTERNAL]  Convert from/to input/output lists/map.
84629 
84630 ";
84631 
84632 %feature("docstring")  casadi::FunctionInternal::get_free() const  "
84633 
84634 [INTERNAL]  Print free variables.
84635 
84636 ";
84637 
84638 %feature("docstring")  casadi::FunctionInternal::alloc_arg(size_t sz_arg,
84639 bool persistent=false) "
84640 
84641 [INTERNAL]  Ensure required length of arg field.
84642 
84643 ";
84644 
84645 %feature("docstring")  casadi::Switch::get_sparsity_out(casadi_int i)  "
84646 
84647 [INTERNAL]  Sparsities of function inputs and outputs.
84648 
84649 ";
84650 
84651 %feature("docstring")  casadi::FunctionInternal::has_jacobian_sparsity()
84652 const  "
84653 
84654 [INTERNAL]  Get Jacobian sparsity.
84655 
84656 ";
84657 
84658 %feature("docstring")  casadi::FunctionInternal::get_function() const  "
84659 
84660 [INTERNAL] ";
84661 
84662 %feature("docstring")  casadi::FunctionInternal::get_function(const
84663 std::string &name) const  "
84664 
84665 [INTERNAL] ";
84666 
84667 %feature("docstring")  casadi::FunctionInternal::getAdaptorSolverName()
84668 const  "
84669 
84670 [INTERNAL]  Obtain solver name from Adaptor.
84671 
84672 ";
84673 
84674 %feature("docstring")  casadi::Switch::eval_sx(const SXElem **arg, SXElem
84675 **res, casadi_int *iw, SXElem *w, void *mem) const  "
84676 
84677 [INTERNAL]  evaluate symbolically while also propagating directional
84678 derivatives
84679 
84680 ";
84681 
84682 %feature("docstring")  casadi::FunctionInternal::replace_fseed(const
84683 std::vector< std::vector< M >> &fseed, casadi_int npar) const  "
84684 
84685 [INTERNAL]  Replace 0-by-0 forward seeds.
84686 
84687 ";
84688 
84689 %feature("docstring")  casadi::FunctionInternal::replace_fseed(const
84690 std::vector< std::vector< M > > &fseed, casadi_int npar) const  "
84691 
84692 [INTERNAL] ";
84693 
84694 %feature("docstring")  casadi::FunctionInternal::has_free() const  "
84695 
84696 [INTERNAL]  Does the function have free variables.
84697 
84698 ";
84699 
84700 %feature("docstring")  casadi::FunctionInternal::instruction_id(casadi_int
84701 k) const  "
84702 
84703 [INTERNAL]  Get an atomic operation operator index.
84704 
84705 ";
84706 
84707 %feature("docstring")  casadi::FunctionInternal::codegen_name(const
84708 CodeGenerator &g, bool ns=true) const  "
84709 
84710 [INTERNAL]  Get name in codegen.
84711 
84712 ";
84713 
84714 %feature("docstring")
84715 casadi::FunctionInternal::codegen_decref(CodeGenerator &g) const  "
84716 
84717 [INTERNAL]  Codegen decref for dependencies.
84718 
84719 ";
84720 
84721 %feature("docstring")  casadi::FunctionInternal::alloc_res(size_t sz_res,
84722 bool persistent=false) "
84723 
84724 [INTERNAL]  Ensure required length of res field.
84725 
84726 ";
84727 
84728 %feature("docstring")  casadi::Switch::get_n_out()  "
84729 
84730 [INTERNAL]  Number of function inputs and outputs.
84731 
84732 ";
84733 
84734 %feature("docstring")  casadi::FunctionInternal::project_arg(const
84735 std::vector< M > &arg, casadi_int npar) const  "
84736 
84737 [INTERNAL]   Project sparsities.
84738 
84739 ";
84740 
84741 %feature("docstring") casadi::Switch::Switch(const std::string &name, const
84742 std::vector< Function > &f, const Function &f_def) "
84743 
84744 [INTERNAL]  Constructor (generic switch)
84745 
84746 ";
84747 
84748 %feature("docstring")  casadi::FunctionInternal::nz_in(const std::vector< DM
84749 > &arg) const  "
84750 
84751 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
84752 
84753 ";
84754 
84755 %feature("docstring")  casadi::FunctionInternal::nz_in(const std::vector<
84756 double > &arg) const  "
84757 
84758 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
84759 
84760 ";
84761 
84762 %feature("docstring")  casadi::ProtoFunction::sprint(char *buf, size_t
84763 buf_sz, const char *fmt,...) const  "
84764 
84765 [INTERNAL]  C-style formatted printing to string.
84766 
84767 ";
84768 
84769 %feature("docstring")
84770 casadi::FunctionInternal::print_dimensions(std::ostream &stream) const  "
84771 
84772 [INTERNAL]  Print dimensions of inputs and outputs.
84773 
84774 ";
84775 
84776 %feature("docstring")  casadi::FunctionInternal::codegen_mem_type() const  "
84777 
84778 [INTERNAL]  Thread-local memory object type.
84779 
84780 ";
84781 
84782 %feature("docstring")  casadi::FunctionInternal::mapsum_mx(const
84783 std::vector< MX > &arg, const std::string &parallelization) "
84784 
84785 [INTERNAL]  Parallel evaluation.
84786 
84787 ";
84788 
84789 %feature("docstring")  casadi::FunctionInternal::reverse(casadi_int nadj)
84790 const  "
84791 
84792 [INTERNAL]  Return function that calculates adjoint derivatives
84793 reverse(nadj) returns a cached instance if available, and calls  Function
84794 get_reverse(casadi_int nadj) if no cached version is available.
84795 
84796 ";
84797 
84798 %feature("docstring")  casadi::FunctionInternal::get_jac(const std::string
84799 &name, const std::vector< std::string > &inames, const std::vector<
84800 std::string > &onames, const Dict &opts) const  "
84801 
84802 [INTERNAL]  Return Jacobian of all input elements with respect to all output
84803 elements.
84804 
84805 ";
84806 
84807 %feature("docstring")  casadi::ProtoFunction::serialize(SerializingStream
84808 &s) const  "
84809 
84810 [INTERNAL]  Serialize an object.
84811 
84812 ";
84813 
84814 %feature("docstring")  casadi::Switch::has_reverse(casadi_int nadj) const  "
84815 
84816 [INTERNAL]  Generate a function that calculates nadj adjoint derivatives.
84817 
84818 ";
84819 
84820 %feature("docstring")  casadi::FunctionInternal::nz_out(const std::vector<
84821 DM > &res) const  "
84822 
84823 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
84824 
84825 ";
84826 
84827 %feature("docstring")  casadi::FunctionInternal::nz_out(const std::vector<
84828 double > &res) const  "
84829 
84830 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
84831 
84832 ";
84833 
84834 %feature("docstring")  casadi::FunctionInternal::eval_dm(const std::vector<
84835 DM > &arg) const  "
84836 
84837 [INTERNAL]  Evaluate with DM matrices.
84838 
84839 ";
84840 
84841 %feature("docstring") casadi::Switch "
84842 
84843 [INTERNAL]   Switch statement Joel Andersson
84844 
84845 C++ includes: switch.hpp ";
84846 
84847 %feature("docstring")  casadi::FunctionInternal::get_jacobian(const
84848 std::string &name, const std::vector< std::string > &inames, const
84849 std::vector< std::string > &onames, const Dict &opts) const  "
84850 
84851 [INTERNAL]  Return Jacobian of all input elements with respect to all output
84852 elements.
84853 
84854 ";
84855 
84856 %feature("docstring")  casadi::FunctionInternal::uses_output() const  "
84857 
84858 [INTERNAL]  Do the derivative functions need nondifferentiated outputs?
84859 
84860 ";
84861 
84862 %feature("docstring")  casadi::FunctionInternal::jit_dependencies(const
84863 std::string &fname) "
84864 
84865 [INTERNAL]  Jit dependencies.
84866 
84867 ";
84868 
84869 %feature("docstring")  casadi::FunctionInternal::call_gen(const MXVector
84870 &arg, MXVector &res, casadi_int npar, bool always_inline, bool never_inline)
84871 const  "
84872 
84873 [INTERNAL]   Call a function, overloaded.
84874 
84875 ";
84876 
84877 %feature("docstring")  casadi::FunctionInternal::call_gen(const std::vector<
84878 MatrixCommon > &arg, std::vector< MatrixCommon > &res, casadi_int npar, bool
84879 always_inline, bool never_inline) const  "
84880 
84881 [INTERNAL]   Call a function, overloaded.
84882 
84883 ";
84884 
84885 %feature("docstring")  casadi::ProtoFunction::alloc_mem() const  "
84886 
84887 [INTERNAL]  Create memory block.
84888 
84889 ";
84890 
84891 %feature("docstring")  casadi::FunctionInternal::generate_out(const
84892 std::string &fname, double **res) const  "
84893 
84894 [INTERNAL] ";
84895 
84896 %feature("docstring")
84897 casadi::FunctionInternal::getJacSparsityHierarchical(casadi_int iind,
84898 casadi_int oind) const  "
84899 
84900 [INTERNAL]  A flavor of getJacSparsity that does hierarchical block
84901 structure recognition.
84902 
84903 ";
84904 
84905 %feature("docstring")  casadi::Switch::get_n_in()  "
84906 
84907 [INTERNAL]  Number of function inputs and outputs.
84908 
84909 ";
84910 
84911 %feature("docstring")  casadi::FunctionInternal::setup(void *mem, const
84912 double **arg, double **res, casadi_int *iw, double *w) const  "
84913 
84914 [INTERNAL]  Set the (persistent and temporary) work vectors.
84915 
84916 ";
84917 
84918 %feature("docstring")  casadi::FunctionInternal::finalize()  "
84919 
84920 [INTERNAL]  Finalize the object creation.
84921 
84922 ";
84923 
84924 %feature("docstring")  casadi::FunctionInternal::print_options(std::ostream
84925 &stream) const  "
84926 
84927 [INTERNAL]  Print list of options.
84928 
84929 ";
84930 
84931 %feature("docstring")  casadi::FunctionInternal::sz_arg() const  "
84932 
84933 [INTERNAL]  Get required length of arg field.
84934 
84935 ";
84936 
84937 %feature("docstring")  casadi::ProtoFunction::release(int mem) const  "
84938 
84939 [INTERNAL]  Release a memory object.
84940 
84941 ";
84942 
84943 %feature("docstring")  casadi::FunctionInternal::definition() const  "
84944 
84945 [INTERNAL]  Get function signature: name:(inputs)->(outputs)
84946 
84947 ";
84948 
84949 %feature("docstring")  casadi::FunctionInternal::get_abstol() const  "
84950 
84951 [INTERNAL]  Get absolute tolerance.
84952 
84953 ";
84954 
84955 %feature("docstring")  casadi::FunctionInternal::free_mx() const  "
84956 
84957 [INTERNAL]  Get free variables ( MX)
84958 
84959 ";
84960 
84961 %feature("docstring")  casadi::FunctionInternal::ad_weight() const  "
84962 
84963 [INTERNAL]  Weighting factor for chosing forward/reverse mode.
84964 
84965 ";
84966 
84967 %feature("docstring")  casadi::ProtoFunction::checkout() const  "
84968 
84969 [INTERNAL]  Checkout a memory object.
84970 
84971 ";
84972 
84973 %feature("docstring")  casadi::FunctionInternal::jac() const  "
84974 
84975 [INTERNAL]  Return Jacobian of all input elements with respect to all output
84976 elements.
84977 
84978 ";
84979 
84980 %feature("docstring")  casadi::FunctionInternal::sz_w() const  "
84981 
84982 [INTERNAL]  Get required length of w field.
84983 
84984 ";
84985 
84986 %feature("docstring")  casadi::FunctionInternal::incache(const std::string
84987 &fname, Function &f, const std::string &suffix="") const  "
84988 
84989 [INTERNAL]  Get function in cache.
84990 
84991 ";
84992 
84993 %feature("docstring")  casadi::FunctionInternal::jacobian() const  "
84994 
84995 [INTERNAL]  Return Jacobian of all input elements with respect to all output
84996 elements.
84997 
84998 ";
84999 
85000 %feature("docstring")  casadi::FunctionInternal::sp_reverse(bvec_t **arg,
85001 bvec_t **res, casadi_int *iw, bvec_t *w, void *mem) const  "
85002 
85003 [INTERNAL]  Propagate sparsity backwards.
85004 
85005 ";
85006 
85007 %feature("docstring")  casadi::FunctionInternal::has_function(const
85008 std::string &fname) const  "
85009 
85010 [INTERNAL] ";
85011 
85012 %feature("docstring")  casadi::FunctionInternal::forward(casadi_int nfwd)
85013 const  "
85014 
85015 [INTERNAL]  Return function that calculates forward derivatives
85016 forward(nfwd) returns a cached instance if available, and calls  Function
85017 get_forward(casadi_int nfwd) if no cached version is available.
85018 
85019 ";
85020 
85021 %feature("docstring")  casadi::FunctionInternal::oracle() const  "
85022 
85023 [INTERNAL]  Get oracle.
85024 
85025 ";
85026 
85027 %feature("docstring")  casadi::FunctionInternal::call_reverse(const
85028 std::vector< MX > &arg, const std::vector< MX > &res, const std::vector<
85029 std::vector< MX > > &aseed, std::vector< std::vector< MX > > &asens, bool
85030 always_inline, bool never_inline) const  "
85031 
85032 [INTERNAL]  Reverse mode, virtual functions overloaded in derived classes.
85033 
85034 ";
85035 
85036 %feature("docstring")  casadi::FunctionInternal::call_reverse(const
85037 std::vector< SX > &arg, const std::vector< SX > &res, const std::vector<
85038 std::vector< SX > > &aseed, std::vector< std::vector< SX > > &asens, bool
85039 always_inline, bool never_inline) const  "
85040 
85041 [INTERNAL]  Reverse mode, virtual functions overloaded in derived classes.
85042 
85043 ";
85044 
85045 %feature("docstring")  casadi::FunctionInternal::generate_lifted(Function
85046 &vdef_fcn, Function &vinit_fcn) const  "
85047 
85048 [INTERNAL]  Extract the functions needed for the Lifted Newton method.
85049 
85050 ";
85051 
85052 %feature("docstring")  casadi::FunctionInternal::all_scalar() const  "
85053 
85054 [INTERNAL]  Are all inputs and outputs scalar.
85055 
85056 ";
85057 
85058 %feature("docstring")  casadi::FunctionInternal::convert_arg(const
85059 std::vector< M > &arg) const  "
85060 
85061 [INTERNAL]  Convert from/to input/output lists/map.
85062 
85063 ";
85064 
85065 %feature("docstring")  casadi::FunctionInternal::convert_arg(const std::map<
85066 std::string, M > &arg) const  "
85067 
85068 [INTERNAL]  Convert from/to input/output lists/map.
85069 
85070 ";
85071 
85072 %feature("docstring")  casadi::FunctionInternal::project_res(const
85073 std::vector< M > &arg, casadi_int npar) const  "
85074 
85075 [INTERNAL]   Project sparsities.
85076 
85077 ";
85078 
85079 %feature("docstring")  casadi::Switch::get_reverse(casadi_int nadj, const
85080 std::string &name, const std::vector< std::string > &inames, const
85081 std::vector< std::string > &onames, const Dict &opts) const  "
85082 
85083 [INTERNAL]  Generate a function that calculates nadj adjoint derivatives.
85084 
85085 ";
85086 
85087 %feature("docstring")  casadi::FunctionInternal::is_diff_in(casadi_int i) "
85088 
85089 [INTERNAL] ";
85090 
85091 %feature("docstring")  casadi::FunctionInternal::nnz_in() const  "
85092 
85093 [INTERNAL]  Number of input/output nonzeros.
85094 
85095 ";
85096 
85097 %feature("docstring")  casadi::FunctionInternal::nnz_in(casadi_int ind)
85098 const  "
85099 
85100 [INTERNAL]  Number of input/output nonzeros.
85101 
85102 ";
85103 
85104 %feature("docstring")  casadi::FunctionInternal::get_reltol() const  "
85105 
85106 [INTERNAL]  Get relative tolerance.
85107 
85108 ";
85109 
85110 %feature("docstring")
85111 casadi::FunctionInternal::instruction_input(casadi_int k) const  "
85112 
85113 [INTERNAL]  Get the (integer) input arguments of an atomic operation.
85114 
85115 ";
85116 
85117 
85118 // File: classcasadi_1_1SXFunction.xml
85119 
85120 
85121 // File: classcasadi_1_1SymbolicMX.xml
85122 
85123 
85124 // File: classcasadi_1_1SymbolicQr.xml
85125 %feature("docstring")  casadi::ProtoFunction::serialize_base_function()
85126 const  "
85127 
85128 [INTERNAL]  String used to identify the immediate FunctionInternal subclass.
85129 
85130 ";
85131 
85132 %feature("docstring")  casadi::LinsolInternal::neig(void *mem, const double
85133 *A) const  "
85134 
85135 [INTERNAL]  Number of negative eigenvalues.
85136 
85137 ";
85138 
85139 %feature("docstring")  casadi::SymbolicQr::class_name() const  "
85140 
85141 [INTERNAL]  Readable name of the internal class.
85142 
85143 ";
85144 
85145 %feature("docstring") casadi::SymbolicQr::SymbolicQr(const std::string
85146 &name, const Sparsity &sp) "
85147 
85148 [INTERNAL] ";
85149 
85150 %feature("docstring")  casadi::ProtoFunction::generate_options(bool
85151 is_temp=false) const  "
85152 
85153 [INTERNAL]  Reconstruct options dict.
85154 
85155 ";
85156 
85157 %feature("docstring")  casadi::SymbolicQr::alloc_mem() const  "
85158 
85159 [INTERNAL]  Create memory block.
85160 
85161 ";
85162 
85163 %feature("docstring")  casadi::ProtoFunction::checkout() const  "
85164 
85165 [INTERNAL]  Checkout a memory object.
85166 
85167 ";
85168 
85169 %feature("docstring")  casadi::SymbolicQr::linsol_eval_sx(const SXElem
85170 **arg, SXElem **res, casadi_int *iw, SXElem *w, void *mem, bool tr,
85171 casadi_int nrhs) const  "
85172 
85173 [INTERNAL]  Evaluate symbolically (SX)
85174 
85175 ";
85176 
85177 %feature("docstring") casadi::SymbolicQr::~SymbolicQr "
85178 
85179 [INTERNAL] ";
85180 
85181 %feature("docstring")  casadi::LinsolInternal::rank(void *mem, const double
85182 *A) const  "
85183 
85184 [INTERNAL]   Matrix rank.
85185 
85186 ";
85187 
85188 %feature("docstring")  casadi::ProtoFunction::memory(int ind) const  "
85189 
85190 [INTERNAL]  Memory objects.
85191 
85192 ";
85193 
85194 %feature("docstring")  casadi::ProtoFunction::get_stats(void *mem) const  "
85195 
85196 [INTERNAL]  Get all statistics.
85197 
85198 ";
85199 
85200 %feature("docstring")  casadi::LinsolInternal::disp_more(std::ostream
85201 &stream) const  "
85202 
85203 [INTERNAL]  Print more.
85204 
85205 ";
85206 
85207 %feature("docstring")  casadi::LinsolInternal::nrow() const  "
85208 
85209 [INTERNAL]  Get sparsity pattern.
85210 
85211 ";
85212 
85213 %feature("docstring") casadi::SymbolicQr "
85214 
85215 'symbolicqr' plugin for Linsol
85216 
85217 Linear solver for sparse least-squares problems Inspired
85218 fromhttps://github.com/scipy/scipy/blob/v0.14.0/scipy/sparse/linalg/isolve/lsqr.py#L96
85219 
85220 Linsol based on QR factorization with sparsity pattern based reordering
85221 without partial pivoting
85222 
85223 >List of available options
85224 
85225 +-------+---------+----------------------------------------------------+
85226 |  Id   |  Type   |                    Description                     |
85227 +=======+=========+====================================================+
85228 | fopts | OT_DICT | Options to be passed to generated function objects |
85229 +-------+---------+----------------------------------------------------+
85230 
85231 Joel Andersson
85232 
85233 >List of available options
85234 
85235 +------------------+-----------------+------------------+------------------+
85236 |        Id        |      Type       |   Description    |     Used in      |
85237 +==================+=================+==================+==================+
85238 | ad_weight        | OT_DOUBLE       | Weighting factor | casadi::Function |
85239 |                  |                 | for derivative   | Internal         |
85240 |                  |                 | calculation.When |                  |
85241 |                  |                 | there is an      |                  |
85242 |                  |                 | option of either |                  |
85243 |                  |                 | using forward or |                  |
85244 |                  |                 | reverse mode     |                  |
85245 |                  |                 | directional      |                  |
85246 |                  |                 | derivatives, the |                  |
85247 |                  |                 | condition ad_wei |                  |
85248 |                  |                 | ght*nf<=(1-ad_we |                  |
85249 |                  |                 | ight)*na is used |                  |
85250 |                  |                 | where nf and na  |                  |
85251 |                  |                 | are estimates of |                  |
85252 |                  |                 | the number of    |                  |
85253 |                  |                 | forward/reverse  |                  |
85254 |                  |                 | mode directional |                  |
85255 |                  |                 | derivatives      |                  |
85256 |                  |                 | needed. By       |                  |
85257 |                  |                 | default,         |                  |
85258 |                  |                 | ad_weight is     |                  |
85259 |                  |                 | calculated       |                  |
85260 |                  |                 | automatically,   |                  |
85261 |                  |                 | but this can be  |                  |
85262 |                  |                 | overridden by    |                  |
85263 |                  |                 | setting this     |                  |
85264 |                  |                 | option. In       |                  |
85265 |                  |                 | particular, 0    |                  |
85266 |                  |                 | means forcing    |                  |
85267 |                  |                 | forward mode and |                  |
85268 |                  |                 | 1 forcing        |                  |
85269 |                  |                 | reverse mode.    |                  |
85270 |                  |                 | Leave unset for  |                  |
85271 |                  |                 | (class specific) |                  |
85272 |                  |                 | heuristics.      |                  |
85273 +------------------+-----------------+------------------+------------------+
85274 | ad_weight_sp     | OT_DOUBLE       | Weighting factor | casadi::Function |
85275 |                  |                 | for sparsity     | Internal         |
85276 |                  |                 | pattern          |                  |
85277 |                  |                 | calculation calc |                  |
85278 |                  |                 | ulation.Override |                  |
85279 |                  |                 | s default        |                  |
85280 |                  |                 | behavior. Set to |                  |
85281 |                  |                 | 0 and 1 to force |                  |
85282 |                  |                 | forward and      |                  |
85283 |                  |                 | reverse mode     |                  |
85284 |                  |                 | respectively.    |                  |
85285 |                  |                 | Cf. option       |                  |
85286 |                  |                 | \"ad_weight\".     |                  |
85287 |                  |                 | When set to -1,  |                  |
85288 |                  |                 | sparsity is      |                  |
85289 |                  |                 | completely       |                  |
85290 |                  |                 | ignored and      |                  |
85291 |                  |                 | dense matrices   |                  |
85292 |                  |                 | are used.        |                  |
85293 +------------------+-----------------+------------------+------------------+
85294 | always_inline    | OT_BOOL         | Force inlining.  | casadi::Function |
85295 |                  |                 |                  | Internal         |
85296 +------------------+-----------------+------------------+------------------+
85297 | compiler         | OT_STRING       | Just-in-time     | casadi::Function |
85298 |                  |                 | compiler plugin  | Internal         |
85299 |                  |                 | to be used.      |                  |
85300 +------------------+-----------------+------------------+------------------+
85301 | custom_jacobian  | OT_FUNCTION     | Override         | casadi::Function |
85302 |                  |                 | CasADi's AD. Use | Internal         |
85303 |                  |                 | together with    |                  |
85304 |                  |                 | 'jac_penalty':   |                  |
85305 |                  |                 | 0. Note: Highly  |                  |
85306 |                  |                 | experimental.    |                  |
85307 |                  |                 | Syntax may break |                  |
85308 |                  |                 | often.           |                  |
85309 +------------------+-----------------+------------------+------------------+
85310 | derivative_of    | OT_FUNCTION     | The function is  | casadi::Function |
85311 |                  |                 | a derivative of  | Internal         |
85312 |                  |                 | another          |                  |
85313 |                  |                 | function. The    |                  |
85314 |                  |                 | type of          |                  |
85315 |                  |                 | derivative       |                  |
85316 |                  |                 | (directional     |                  |
85317 |                  |                 | derivative,      |                  |
85318 |                  |                 | Jacobian) is     |                  |
85319 |                  |                 | inferred from    |                  |
85320 |                  |                 | the function     |                  |
85321 |                  |                 | name.            |                  |
85322 +------------------+-----------------+------------------+------------------+
85323 | dump             | OT_BOOL         | Dump function to | casadi::Function |
85324 |                  |                 | file upon first  | Internal         |
85325 |                  |                 | evaluation.      |                  |
85326 |                  |                 | [false]          |                  |
85327 +------------------+-----------------+------------------+------------------+
85328 | dump_dir         | OT_STRING       | Directory to     | casadi::Function |
85329 |                  |                 | dump             | Internal         |
85330 |                  |                 | inputs/outputs   |                  |
85331 |                  |                 | to. Make sure    |                  |
85332 |                  |                 | the directory    |                  |
85333 |                  |                 | exists [.]       |                  |
85334 +------------------+-----------------+------------------+------------------+
85335 | dump_format      | OT_STRING       | Choose file      | casadi::Function |
85336 |                  |                 | format to dump   | Internal         |
85337 |                  |                 | matrices. See    |                  |
85338 |                  |                 | DM.from_file     |                  |
85339 |                  |                 | [mtx]            |                  |
85340 +------------------+-----------------+------------------+------------------+
85341 | dump_in          | OT_BOOL         | Dump numerical   | casadi::Function |
85342 |                  |                 | values of inputs | Internal         |
85343 |                  |                 | to file          |                  |
85344 |                  |                 | (readable with   |                  |
85345 |                  |                 | DM.from_file )   |                  |
85346 |                  |                 | [default: false] |                  |
85347 +------------------+-----------------+------------------+------------------+
85348 | dump_out         | OT_BOOL         | Dump numerical   | casadi::Function |
85349 |                  |                 | values of        | Internal         |
85350 |                  |                 | outputs to file  |                  |
85351 |                  |                 | (readable with   |                  |
85352 |                  |                 | DM.from_file )   |                  |
85353 |                  |                 | [default: false] |                  |
85354 +------------------+-----------------+------------------+------------------+
85355 | enable_fd        | OT_BOOL         | Enable           | casadi::Function |
85356 |                  |                 | derivative       | Internal         |
85357 |                  |                 | calculation by   |                  |
85358 |                  |                 | finite           |                  |
85359 |                  |                 | differencing.    |                  |
85360 |                  |                 | [default:        |                  |
85361 |                  |                 | false]]          |                  |
85362 +------------------+-----------------+------------------+------------------+
85363 | enable_forward   | OT_BOOL         | Enable           | casadi::Function |
85364 |                  |                 | derivative       | Internal         |
85365 |                  |                 | calculation      |                  |
85366 |                  |                 | using generated  |                  |
85367 |                  |                 | functions for    |                  |
85368 |                  |                 | Jacobian-times-  |                  |
85369 |                  |                 | vector products  |                  |
85370 |                  |                 | - typically      |                  |
85371 |                  |                 | using forward    |                  |
85372 |                  |                 | mode AD - if     |                  |
85373 |                  |                 | available.       |                  |
85374 |                  |                 | [default: true]  |                  |
85375 +------------------+-----------------+------------------+------------------+
85376 | enable_jacobian  | OT_BOOL         | Enable           | casadi::Function |
85377 |                  |                 | derivative       | Internal         |
85378 |                  |                 | calculation      |                  |
85379 |                  |                 | using generated  |                  |
85380 |                  |                 | functions for    |                  |
85381 |                  |                 | Jacobians of all |                  |
85382 |                  |                 | differentiable   |                  |
85383 |                  |                 | outputs with     |                  |
85384 |                  |                 | respect to all   |                  |
85385 |                  |                 | differentiable   |                  |
85386 |                  |                 | inputs - if      |                  |
85387 |                  |                 | available.       |                  |
85388 |                  |                 | [default: true]  |                  |
85389 +------------------+-----------------+------------------+------------------+
85390 | enable_reverse   | OT_BOOL         | Enable           | casadi::Function |
85391 |                  |                 | derivative       | Internal         |
85392 |                  |                 | calculation      |                  |
85393 |                  |                 | using generated  |                  |
85394 |                  |                 | functions for    |                  |
85395 |                  |                 | transposed       |                  |
85396 |                  |                 | Jacobian-times-  |                  |
85397 |                  |                 | vector products  |                  |
85398 |                  |                 | - typically      |                  |
85399 |                  |                 | using reverse    |                  |
85400 |                  |                 | mode AD - if     |                  |
85401 |                  |                 | available.       |                  |
85402 |                  |                 | [default: true]  |                  |
85403 +------------------+-----------------+------------------+------------------+
85404 | fd_method        | OT_STRING       | Method for       | casadi::Function |
85405 |                  |                 | finite           | Internal         |
85406 |                  |                 | differencing     |                  |
85407 |                  |                 | [default         |                  |
85408 |                  |                 | 'central']       |                  |
85409 +------------------+-----------------+------------------+------------------+
85410 | fd_options       | OT_DICT         | Options to be    | casadi::Function |
85411 |                  |                 | passed to the    | Internal         |
85412 |                  |                 | finite           |                  |
85413 |                  |                 | difference       |                  |
85414 |                  |                 | instance         |                  |
85415 +------------------+-----------------+------------------+------------------+
85416 | fopts            | OT_DICT         | Options to be    | casadi::Symbolic |
85417 |                  |                 | passed to        | Qr               |
85418 |                  |                 | generated        |                  |
85419 |                  |                 | function objects |                  |
85420 +------------------+-----------------+------------------+------------------+
85421 | forward_options  | OT_DICT         | Options to be    | casadi::Function |
85422 |                  |                 | passed to a      | Internal         |
85423 |                  |                 | forward mode     |                  |
85424 |                  |                 | constructor      |                  |
85425 +------------------+-----------------+------------------+------------------+
85426 | gather_stats     | OT_BOOL         | Deprecated       | casadi::Function |
85427 |                  |                 | option           | Internal         |
85428 |                  |                 | (ignored):       |                  |
85429 |                  |                 | Statistics are   |                  |
85430 |                  |                 | now always       |                  |
85431 |                  |                 | collected.       |                  |
85432 +------------------+-----------------+------------------+------------------+
85433 | input_scheme     | OT_STRINGVECTOR | Deprecated       | casadi::Function |
85434 |                  |                 | option (ignored) | Internal         |
85435 +------------------+-----------------+------------------+------------------+
85436 | inputs_check     | OT_BOOL         | Throw exceptions | casadi::Function |
85437 |                  |                 | when the         | Internal         |
85438 |                  |                 | numerical values |                  |
85439 |                  |                 | of the inputs    |                  |
85440 |                  |                 | don't make sense |                  |
85441 +------------------+-----------------+------------------+------------------+
85442 | is_diff_in       | OT_BOOLVECTOR   | Indicate for     | casadi::Function |
85443 |                  |                 | each input if it | Internal         |
85444 |                  |                 | should be        |                  |
85445 |                  |                 | differentiable.  |                  |
85446 +------------------+-----------------+------------------+------------------+
85447 | is_diff_out      | OT_BOOLVECTOR   | Indicate for     | casadi::Function |
85448 |                  |                 | each output if   | Internal         |
85449 |                  |                 | it should be     |                  |
85450 |                  |                 | differentiable.  |                  |
85451 +------------------+-----------------+------------------+------------------+
85452 | jac_penalty      | OT_DOUBLE       | When requested   | casadi::Function |
85453 |                  |                 | for a number of  | Internal         |
85454 |                  |                 | forward/reverse  |                  |
85455 |                  |                 | directions, it   |                  |
85456 |                  |                 | may be cheaper   |                  |
85457 |                  |                 | to compute first |                  |
85458 |                  |                 | the full         |                  |
85459 |                  |                 | jacobian and     |                  |
85460 |                  |                 | then multiply    |                  |
85461 |                  |                 | with seeds,      |                  |
85462 |                  |                 | rather than      |                  |
85463 |                  |                 | obtain the       |                  |
85464 |                  |                 | requested        |                  |
85465 |                  |                 | directions in a  |                  |
85466 |                  |                 | straightforward  |                  |
85467 |                  |                 | manner. Casadi   |                  |
85468 |                  |                 | uses a heuristic |                  |
85469 |                  |                 | to decide which  |                  |
85470 |                  |                 | is cheaper. A    |                  |
85471 |                  |                 | high value of    |                  |
85472 |                  |                 | 'jac_penalty'    |                  |
85473 |                  |                 | makes it less    |                  |
85474 |                  |                 | likely for the   |                  |
85475 |                  |                 | heurstic to      |                  |
85476 |                  |                 | chose the full   |                  |
85477 |                  |                 | Jacobian         |                  |
85478 |                  |                 | strategy. The    |                  |
85479 |                  |                 | special value -1 |                  |
85480 |                  |                 | indicates never  |                  |
85481 |                  |                 | to use the full  |                  |
85482 |                  |                 | Jacobian         |                  |
85483 |                  |                 | strategy         |                  |
85484 +------------------+-----------------+------------------+------------------+
85485 | jit              | OT_BOOL         | Use just-in-time | casadi::Function |
85486 |                  |                 | compiler to      | Internal         |
85487 |                  |                 | speed up the     |                  |
85488 |                  |                 | evaluation       |                  |
85489 +------------------+-----------------+------------------+------------------+
85490 | jit_cleanup      | OT_BOOL         | Cleanup up the   | casadi::Function |
85491 |                  |                 | temporary source | Internal         |
85492 |                  |                 | file that jit    |                  |
85493 |                  |                 | creates.         |                  |
85494 |                  |                 | Default: true    |                  |
85495 +------------------+-----------------+------------------+------------------+
85496 | jit_name         | OT_STRING       | The file name    | casadi::Function |
85497 |                  |                 | used to write    | Internal         |
85498 |                  |                 | out code. The    |                  |
85499 |                  |                 | actual file      |                  |
85500 |                  |                 | names used       |                  |
85501 |                  |                 | depend on 'jit_t |                  |
85502 |                  |                 | emp_suffix' and  |                  |
85503 |                  |                 | include          |                  |
85504 |                  |                 | extensions.      |                  |
85505 |                  |                 | Default:         |                  |
85506 |                  |                 | 'jit_tmp'        |                  |
85507 +------------------+-----------------+------------------+------------------+
85508 | jit_options      | OT_DICT         | Options to be    | casadi::Function |
85509 |                  |                 | passed to the    | Internal         |
85510 |                  |                 | jit compiler.    |                  |
85511 +------------------+-----------------+------------------+------------------+
85512 | jit_serialize    | OT_STRING       | Specify          | casadi::Function |
85513 |                  |                 | behaviour when   | Internal         |
85514 |                  |                 | serializing a    |                  |
85515 |                  |                 | jitted function: |                  |
85516 |                  |                 | SOURCE|link|embe |                  |
85517 |                  |                 | d.               |                  |
85518 +------------------+-----------------+------------------+------------------+
85519 | jit_temp_suffix  | OT_BOOL         | Use a temporary  | casadi::Function |
85520 |                  |                 | (seemingly       | Internal         |
85521 |                  |                 | random) filename |                  |
85522 |                  |                 | suffix for       |                  |
85523 |                  |                 | generated code   |                  |
85524 |                  |                 | and libraries.   |                  |
85525 |                  |                 | This is desired  |                  |
85526 |                  |                 | for thread-      |                  |
85527 |                  |                 | safety. This     |                  |
85528 |                  |                 | behaviour may    |                  |
85529 |                  |                 | defeat caching   |                  |
85530 |                  |                 | compiler         |                  |
85531 |                  |                 | wrappers.        |                  |
85532 |                  |                 | Default: true    |                  |
85533 +------------------+-----------------+------------------+------------------+
85534 | max_num_dir      | OT_INT          | Specify the      | casadi::Function |
85535 |                  |                 | maximum number   | Internal         |
85536 |                  |                 | of directions    |                  |
85537 |                  |                 | for derivative   |                  |
85538 |                  |                 | functions.       |                  |
85539 |                  |                 | Overrules the    |                  |
85540 |                  |                 | builtin optimize |                  |
85541 |                  |                 | d_num_dir.       |                  |
85542 +------------------+-----------------+------------------+------------------+
85543 | never_inline     | OT_BOOL         | Forbid inlining. | casadi::Function |
85544 |                  |                 |                  | Internal         |
85545 +------------------+-----------------+------------------+------------------+
85546 | output_scheme    | OT_STRINGVECTOR | Deprecated       | casadi::Function |
85547 |                  |                 | option (ignored) | Internal         |
85548 +------------------+-----------------+------------------+------------------+
85549 | print_in         | OT_BOOL         | Print numerical  | casadi::Function |
85550 |                  |                 | values of inputs | Internal         |
85551 |                  |                 | [default: false] |                  |
85552 +------------------+-----------------+------------------+------------------+
85553 | print_out        | OT_BOOL         | Print numerical  | casadi::Function |
85554 |                  |                 | values of        | Internal         |
85555 |                  |                 | outputs          |                  |
85556 |                  |                 | [default: false] |                  |
85557 +------------------+-----------------+------------------+------------------+
85558 | print_time       | OT_BOOL         | print            | casadi::Function |
85559 |                  |                 | information      | Internal         |
85560 |                  |                 | about execution  |                  |
85561 |                  |                 | time. Implies    |                  |
85562 |                  |                 | record_time.     |                  |
85563 +------------------+-----------------+------------------+------------------+
85564 | record_time      | OT_BOOL         | record           | casadi::Function |
85565 |                  |                 | information      | Internal         |
85566 |                  |                 | about execution  |                  |
85567 |                  |                 | time, for        |                  |
85568 |                  |                 | retrieval with   |                  |
85569 |                  |                 | stats().         |                  |
85570 +------------------+-----------------+------------------+------------------+
85571 | regularity_check | OT_BOOL         | Throw exceptions | casadi::Function |
85572 |                  |                 | when NaN or Inf  | Internal         |
85573 |                  |                 | appears during   |                  |
85574 |                  |                 | evaluation       |                  |
85575 +------------------+-----------------+------------------+------------------+
85576 | reverse_options  | OT_DICT         | Options to be    | casadi::Function |
85577 |                  |                 | passed to a      | Internal         |
85578 |                  |                 | reverse mode     |                  |
85579 |                  |                 | constructor      |                  |
85580 +------------------+-----------------+------------------+------------------+
85581 | user_data        | OT_VOIDPTR      | A user-defined   | casadi::Function |
85582 |                  |                 | field that can   | Internal         |
85583 |                  |                 | be used to       |                  |
85584 |                  |                 | identify the     |                  |
85585 |                  |                 | function or pass |                  |
85586 |                  |                 | additional       |                  |
85587 |                  |                 | information      |                  |
85588 +------------------+-----------------+------------------+------------------+
85589 | verbose          | OT_BOOL         | Verbose          | casadi::Function |
85590 |                  |                 | evaluation  for  | Internal         |
85591 |                  |                 | debugging        |                  |
85592 +------------------+-----------------+------------------+------------------+
85593 
85594 Diagrams
85595 --------
85596 
85597 
85598 
85599 C++ includes: symbolic_qr.hpp ";
85600 
85601 %feature("docstring")  casadi::LinsolInternal::nnz() const  "
85602 
85603 [INTERNAL] ";
85604 
85605 %feature("docstring")  casadi::ProtoFunction::print_time(const std::map<
85606 std::string, FStats > &fstats) const  "
85607 
85608 [INTERNAL]  Print timing statistics.
85609 
85610 ";
85611 
85612 %feature("docstring")  casadi::LinsolInternal::ncol() const  "
85613 
85614 [INTERNAL] ";
85615 
85616 %feature("docstring")  casadi::LinsolInternal::generate(CodeGenerator &g,
85617 const std::string &A, const std::string &x, casadi_int nrhs, bool tr) const
85618 "
85619 
85620 [INTERNAL]  Generate C code.
85621 
85622 ";
85623 
85624 %feature("docstring")  casadi::ProtoFunction::clear_mem() "
85625 
85626 [INTERNAL]  Clear all memory (called from destructor)
85627 
85628 ";
85629 
85630 %feature("docstring")  casadi::SymbolicQr::init(const Dict &opts)  "
85631 
85632 [INTERNAL]  Initialize.
85633 
85634 ";
85635 
85636 %feature("docstring")  casadi::SharedObjectInternal::weak() "
85637 
85638 [INTERNAL]  Get a weak reference to the object.
85639 
85640 ";
85641 
85642 %feature("docstring")  casadi::SymbolicQr::serialize_body(SerializingStream
85643 &s) const  "
85644 
85645 [INTERNAL]  Serialize an object without type information.
85646 
85647 ";
85648 
85649 %feature("docstring")  casadi::SymbolicQr::get_options() const  "
85650 
85651 [INTERNAL]  Options.
85652 
85653 ";
85654 
85655 %feature("docstring")  casadi::SymbolicQr::plugin_name() const  "
85656 
85657 [INTERNAL] ";
85658 
85659 %feature("docstring")  casadi::LinsolInternal::disp(std::ostream &stream,
85660 bool more) const  "
85661 
85662 [INTERNAL]  Display object.
85663 
85664 ";
85665 
85666 %feature("docstring")  casadi::ProtoFunction::finalize() "
85667 
85668 [INTERNAL]  Finalize the object creation This function, which visits the
85669 class hierarchy in reverse order is run after init() has been completed.
85670 
85671 ";
85672 
85673 %feature("docstring")  casadi::ProtoFunction::serialize(SerializingStream
85674 &s) const  "
85675 
85676 [INTERNAL]  Serialize an object.
85677 
85678 ";
85679 
85680 %feature("docstring")  casadi::SymbolicQr::solve(void *mem, const double *A,
85681 double *x, casadi_int nrhs, bool tr) const  "
85682 
85683 [INTERNAL] ";
85684 
85685 %feature("docstring")  casadi::ProtoFunction::print(const char *fmt,...)
85686 const  "
85687 
85688 [INTERNAL]  C-style formatted printing during evaluation.
85689 
85690 ";
85691 
85692 %feature("docstring")  casadi::SymbolicQr::nfact(void *mem, const double *A)
85693 const  "
85694 
85695 [INTERNAL]  Numeric factorization.
85696 
85697 ";
85698 
85699 %feature("docstring")  casadi::LinsolInternal::sfact(void *mem, const double
85700 *A) const  "
85701 
85702 [INTERNAL] ";
85703 
85704 %feature("docstring")  casadi::LinsolInternal::row() const  "
85705 
85706 [INTERNAL] ";
85707 
85708 %feature("docstring")  casadi::SharedObjectInternal::getCount() const  "
85709 
85710 [INTERNAL]  Get the reference count.
85711 
85712 ";
85713 
85714 %feature("docstring")  casadi::SymbolicQr::init_mem(void *mem) const  "
85715 
85716 [INTERNAL]  Initalize memory block.
85717 
85718 ";
85719 
85720 %feature("docstring")
85721 casadi::LinsolInternal::serialize_type(SerializingStream &s) const  "
85722 
85723 [INTERNAL]  Serialize type information.
85724 
85725 ";
85726 
85727 %feature("docstring")  casadi::ProtoFunction::format_time(char *buffer,
85728 double time) const  "
85729 
85730 [INTERNAL]  Format time in a fixed width 8 format.
85731 
85732 ";
85733 
85734 %feature("docstring")  casadi::ProtoFunction::construct(const Dict &opts) "
85735 
85736 [INTERNAL]  Construct Prepares the function for evaluation.
85737 
85738 ";
85739 
85740 %feature("docstring")  casadi::LinsolInternal::colind() const  "
85741 
85742 [INTERNAL] ";
85743 
85744 %feature("docstring")  casadi::SymbolicQr::free_mem(void *mem) const  "
85745 
85746 [INTERNAL]  Free memory block.
85747 
85748 ";
85749 
85750 %feature("docstring")  casadi::ProtoFunction::release(int mem) const  "
85751 
85752 [INTERNAL]  Release a memory object.
85753 
85754 ";
85755 
85756 %feature("docstring")  casadi::ProtoFunction::sprint(char *buf, size_t
85757 buf_sz, const char *fmt,...) const  "
85758 
85759 [INTERNAL]  C-style formatted printing to string.
85760 
85761 ";
85762 
85763 
85764 // File: classcasadi_1_1SymbolicSX.xml
85765 
85766 
85767 // File: classcasadi_1_1ThreadMap.xml
85768 %feature("docstring")  casadi::FunctionInternal::symbolicAdjSeed(casadi_int
85769 nadj, const std::vector< MatType > &v) const  "
85770 
85771 [INTERNAL]  Symbolic expressions for the adjoint seeds.
85772 
85773 ";
85774 
85775 %feature("docstring")  casadi::ProtoFunction::serialize(SerializingStream
85776 &s) const  "
85777 
85778 [INTERNAL]  Serialize an object.
85779 
85780 ";
85781 
85782 %feature("docstring")  casadi::ThreadMap::class_name() const  "
85783 
85784 [INTERNAL]  Get type name.
85785 
85786 ";
85787 
85788 %feature("docstring")
85789 casadi::FunctionInternal::getJacSparsityGen(casadi_int iind, casadi_int
85790 oind, bool symmetric, casadi_int gr_i=1, casadi_int gr_o=1) const  "
85791 
85792 [INTERNAL]  Get the sparsity pattern, forward mode.
85793 
85794 ";
85795 
85796 %feature("docstring")  casadi::FunctionInternal::self() const  "
85797 
85798 [INTERNAL]  Get a public class instance.
85799 
85800 ";
85801 
85802 %feature("docstring")  casadi::FunctionInternal::sparsity_in(casadi_int ind)
85803 const  "
85804 
85805 [INTERNAL]  Input/output sparsity.
85806 
85807 ";
85808 
85809 %feature("docstring")  casadi::Map::get_sparsity_in(casadi_int i)  "
85810 
85811 [INTERNAL]  Sparsities of function inputs and outputs.
85812 
85813 ";
85814 
85815 %feature("docstring")  casadi::FunctionInternal::sparsity_jac(casadi_int
85816 iind, casadi_int oind, bool compact, bool symmetric) const  "
85817 
85818 [INTERNAL]  Get, if necessary generate, the sparsity of a Jacobian block.
85819 
85820 ";
85821 
85822 %feature("docstring")  casadi::FunctionInternal::project_res(const
85823 std::vector< M > &arg, casadi_int npar) const  "
85824 
85825 [INTERNAL]   Project sparsities.
85826 
85827 ";
85828 
85829 %feature("docstring")  casadi::ProtoFunction::construct(const Dict &opts) "
85830 
85831 [INTERNAL]  Construct Prepares the function for evaluation.
85832 
85833 ";
85834 
85835 %feature("docstring")  casadi::FunctionInternal::finalize()  "
85836 
85837 [INTERNAL]  Finalize the object creation.
85838 
85839 ";
85840 
85841 %feature("docstring")  casadi::FunctionInternal::jac() const  "
85842 
85843 [INTERNAL]  Return Jacobian of all input elements with respect to all output
85844 elements.
85845 
85846 ";
85847 
85848 %feature("docstring")  casadi::FunctionInternal::sx_out(casadi_int ind)
85849 const  "
85850 
85851 [INTERNAL]  Get function input(s) and output(s)
85852 
85853 ";
85854 
85855 %feature("docstring")  casadi::FunctionInternal::sx_out() const  "
85856 
85857 [INTERNAL]  Get function input(s) and output(s)
85858 
85859 ";
85860 
85861 %feature("docstring")  casadi::FunctionInternal::tocache(const Function &f,
85862 const std::string &suffix="") const  "
85863 
85864 [INTERNAL]  Save function to cache.
85865 
85866 ";
85867 
85868 %feature("docstring")  casadi::FunctionInternal::disp(std::ostream &stream,
85869 bool more) const  "
85870 
85871 [INTERNAL]  Display object.
85872 
85873 ";
85874 
85875 %feature("docstring")  casadi::FunctionInternal::sz_arg() const  "
85876 
85877 [INTERNAL]  Get required length of arg field.
85878 
85879 ";
85880 
85881 %feature("docstring")  casadi::Map::serialize_body(SerializingStream &s)
85882 const  "
85883 
85884 [INTERNAL]  Serialize an object without type information.
85885 
85886 ";
85887 
85888 %feature("docstring")
85889 casadi::FunctionInternal::codegen_init_mem(CodeGenerator &g) const  "
85890 
85891 [INTERNAL]  Codegen decref for init_mem.
85892 
85893 ";
85894 
85895 %feature("docstring")  casadi::FunctionInternal::mapsum_mx(const
85896 std::vector< MX > &arg, const std::string &parallelization) "
85897 
85898 [INTERNAL]  Parallel evaluation.
85899 
85900 ";
85901 
85902 %feature("docstring")  casadi::FunctionInternal::check_arg(const
85903 std::vector< M > &arg, casadi_int &npar) const  "
85904 
85905 [INTERNAL]  Check if input arguments have correct length and dimensions.
85906 
85907 Raises errors.
85908 
85909 Parameters:
85910 -----------
85911 
85912 npar[in]:  normal usage: 1, disallow pararallel calls: -1
85913 
85914 npar:  max number of horizontal repetitions across all arguments (or -1)
85915 
85916 ";
85917 
85918 %feature("docstring")  casadi::FunctionInternal::size2_in(casadi_int ind)
85919 const  "
85920 
85921 [INTERNAL]  Input/output dimensions.
85922 
85923 ";
85924 
85925 %feature("docstring")  casadi::FunctionInternal::replace_arg(const
85926 std::vector< M > &arg, casadi_int npar) const  "
85927 
85928 [INTERNAL]  Replace 0-by-0 inputs.
85929 
85930 ";
85931 
85932 %feature("docstring") casadi::ThreadMap::ThreadMap(const std::string &name,
85933 const Function &f, casadi_int n) "
85934 
85935 [INTERNAL] ";
85936 
85937 %feature("docstring")  casadi::FunctionInternal::generate_out(const
85938 std::string &fname, double **res) const  "
85939 
85940 [INTERNAL] ";
85941 
85942 %feature("docstring")  casadi::FunctionInternal::eval_mx(const MXVector
85943 &arg, MXVector &res, bool always_inline, bool never_inline) const  "
85944 
85945 [INTERNAL]  Evaluate with symbolic matrices.
85946 
85947 ";
85948 
85949 %feature("docstring")  casadi::FunctionInternal::free_sx() const  "
85950 
85951 [INTERNAL]  Get free variables (SX)
85952 
85953 ";
85954 
85955 %feature("docstring")  casadi::FunctionInternal::dm_out(casadi_int ind)
85956 const  "
85957 
85958 [INTERNAL]  Get function input(s) and output(s)
85959 
85960 ";
85961 
85962 %feature("docstring")  casadi::FunctionInternal::dm_out() const  "
85963 
85964 [INTERNAL]  Get function input(s) and output(s)
85965 
85966 ";
85967 
85968 %feature("docstring")  casadi::FunctionInternal::has_jacobian() const  "
85969 
85970 [INTERNAL]  Return Jacobian of all input elements with respect to all output
85971 elements.
85972 
85973 ";
85974 
85975 %feature("docstring")  casadi::FunctionInternal::size_out(casadi_int ind)
85976 const  "
85977 
85978 [INTERNAL]  Input/output dimensions.
85979 
85980 ";
85981 
85982 %feature("docstring")
85983 casadi::FunctionInternal::instruction_input(casadi_int k) const  "
85984 
85985 [INTERNAL]  Get the (integer) input arguments of an atomic operation.
85986 
85987 ";
85988 
85989 %feature("docstring")  casadi::FunctionInternal::signature(const std::string
85990 &fname) const  "
85991 
85992 [INTERNAL]  Code generate the function.
85993 
85994 ";
85995 
85996 %feature("docstring")
85997 casadi::FunctionInternal::codegen_incref(CodeGenerator &g) const  "
85998 
85999 [INTERNAL]  Codegen incref for dependencies.
86000 
86001 ";
86002 
86003 %feature("docstring")  casadi::ProtoFunction::checkout() const  "
86004 
86005 [INTERNAL]  Checkout a memory object.
86006 
86007 ";
86008 
86009 %feature("docstring")  casadi::FunctionInternal::get_jacobian(const
86010 std::string &name, const std::vector< std::string > &inames, const
86011 std::vector< std::string > &onames, const Dict &opts) const  "
86012 
86013 [INTERNAL]  Return Jacobian of all input elements with respect to all output
86014 elements.
86015 
86016 ";
86017 
86018 %feature("docstring")  casadi::FunctionInternal::eval_dm(const std::vector<
86019 DM > &arg) const  "
86020 
86021 [INTERNAL]  Evaluate with DM matrices.
86022 
86023 ";
86024 
86025 %feature("docstring")
86026 casadi::FunctionInternal::print_dimensions(std::ostream &stream) const  "
86027 
86028 [INTERNAL]  Print dimensions of inputs and outputs.
86029 
86030 ";
86031 
86032 %feature("docstring")  casadi::FunctionInternal::eval_gen(const double
86033 **arg, double **res, casadi_int *iw, double *w, void *mem) const  "
86034 
86035 [INTERNAL]  Evaluate numerically.
86036 
86037 ";
86038 
86039 %feature("docstring")  casadi::FunctionInternal::eval_gen(const SXElem
86040 **arg, SXElem **res, casadi_int *iw, SXElem *w, void *mem) const  "
86041 
86042 [INTERNAL]  Evaluate a function, overloaded.
86043 
86044 ";
86045 
86046 %feature("docstring")  casadi::FunctionInternal::eval_gen(const bvec_t
86047 **arg, bvec_t **res, casadi_int *iw, bvec_t *w, void *mem) const  "
86048 
86049 [INTERNAL]  Evaluate a function, overloaded.
86050 
86051 ";
86052 
86053 %feature("docstring")  casadi::Map::eval_gen(const T **arg, T **res,
86054 casadi_int *iw, T *w, int mem=0) const  "
86055 
86056 [INTERNAL]  Evaluate or propagate sparsities.
86057 
86058 ";
86059 
86060 %feature("docstring")  casadi::FunctionInternal::get_partition(casadi_int
86061 iind, casadi_int oind, Sparsity &D1, Sparsity &D2, bool compact, bool
86062 symmetric, bool allow_forward, bool allow_reverse) const  "
86063 
86064 [INTERNAL]  Get the unidirectional or bidirectional partition.
86065 
86066 ";
86067 
86068 %feature("docstring")  casadi::FunctionInternal::alloc(const Function &f,
86069 bool persistent=false) "
86070 
86071 [INTERNAL]  Ensure work vectors long enough to evaluate function.
86072 
86073 ";
86074 
86075 %feature("docstring")  casadi::ProtoFunction::memory(int ind) const  "
86076 
86077 [INTERNAL]  Memory objects.
86078 
86079 ";
86080 
86081 %feature("docstring")  casadi::FunctionInternal::set_temp(void *mem, const
86082 double **arg, double **res, casadi_int *iw, double *w) const  "
86083 
86084 [INTERNAL]  Set the (temporary) work vectors.
86085 
86086 ";
86087 
86088 %feature("docstring")  casadi::FunctionInternal::get_options() const  "
86089 
86090 [INTERNAL]  Options.
86091 
86092 ";
86093 
86094 %feature("docstring")  casadi::FunctionInternal::get_max_in(casadi_int ind)
86095 const  "
86096 
86097 [INTERNAL]  Get largest input value.
86098 
86099 ";
86100 
86101 %feature("docstring")  casadi::FunctionInternal::wrap_as_needed(const Dict
86102 &opts) const  "
86103 
86104 [INTERNAL]  Wrap in an Function instance consisting of only one MX call.
86105 
86106 ";
86107 
86108 %feature("docstring")  casadi::Map::info() const  "
86109 
86110 [INTERNAL]  Obtain information about node
86111 
86112 ";
86113 
86114 %feature("docstring")  casadi::FunctionInternal::jacobian() const  "
86115 
86116 [INTERNAL]  Return Jacobian of all input elements with respect to all output
86117 elements.
86118 
86119 ";
86120 
86121 %feature("docstring")  casadi::FunctionInternal::get_free() const  "
86122 
86123 [INTERNAL]  Print free variables.
86124 
86125 ";
86126 
86127 %feature("docstring")  casadi::ThreadMap::parallelization() const  "
86128 
86129 [INTERNAL]  Type of parallellization.
86130 
86131 ";
86132 
86133 %feature("docstring")  casadi::FunctionInternal::call_gen(const MXVector
86134 &arg, MXVector &res, casadi_int npar, bool always_inline, bool never_inline)
86135 const  "
86136 
86137 [INTERNAL]   Call a function, overloaded.
86138 
86139 ";
86140 
86141 %feature("docstring")  casadi::FunctionInternal::call_gen(const std::vector<
86142 MatrixCommon > &arg, std::vector< MatrixCommon > &res, casadi_int npar, bool
86143 always_inline, bool never_inline) const  "
86144 
86145 [INTERNAL]   Call a function, overloaded.
86146 
86147 ";
86148 
86149 %feature("docstring")  casadi::FunctionInternal::check_res(const
86150 std::vector< M > &res, casadi_int &npar) const  "
86151 
86152 [INTERNAL]  Check if output arguments have correct length and dimensions.
86153 
86154 Raises errors.
86155 
86156 Parameters:
86157 -----------
86158 
86159 npar[in]:  normal usage: 1, disallow pararallel calls: -1
86160 
86161 npar:  max number of horizontal repetitions across all arguments (or -1)
86162 
86163 ";
86164 
86165 %feature("docstring")  casadi::FunctionInternal::alloc_iw(size_t sz_iw, bool
86166 persistent=false) "
86167 
86168 [INTERNAL]  Ensure required length of iw field.
86169 
86170 ";
86171 
86172 %feature("docstring")  casadi::Map::get_name_out(casadi_int i)  "
86173 
86174 [INTERNAL]  Names of function input and outputs.
86175 
86176 ";
86177 
86178 %feature("docstring")  casadi::FunctionInternal::matching_res(const
86179 std::vector< M > &arg, casadi_int &npar) const  "
86180 
86181 [INTERNAL]  Check if output arguments that needs to be replaced.
86182 
86183 Raises errors
86184 
86185 Parameters:
86186 -----------
86187 
86188 npar[in]:  normal usage: 1, disallow pararallel calls: -1
86189 
86190 npar:  max number of horizontal repetitions across all arguments (or -1)
86191 
86192 ";
86193 
86194 %feature("docstring")  casadi::Map::has_forward(casadi_int nfwd) const  "
86195 
86196 [INTERNAL]  Generate a function that calculates nfwd forward derivatives.
86197 
86198 ";
86199 
86200 %feature("docstring")  casadi::FunctionInternal::which_depends(const
86201 std::string &s_in, const std::vector< std::string > &s_out, casadi_int
86202 order, bool tr=false) const  "
86203 
86204 [INTERNAL]  Which variables enter with some order.
86205 
86206 Parameters:
86207 -----------
86208 
86209 s_in:   Input name
86210 
86211 s_out:   Output name(s)
86212 
86213 order:  Only 1 (linear) and 2 (nonlinear) allowed
86214 
86215 tr:  Flip the relationship. Return which expressions contain the variables
86216 
86217 ";
86218 
86219 %feature("docstring")  casadi::FunctionInternal::sz_res() const  "
86220 
86221 [INTERNAL]  Get required length of res field.
86222 
86223 ";
86224 
86225 %feature("docstring")
86226 casadi::FunctionInternal::instruction_output(casadi_int k) const  "
86227 
86228 [INTERNAL]  Get the (integer) output argument of an atomic operation.
86229 
86230 ";
86231 
86232 %feature("docstring")  casadi::ProtoFunction::alloc_mem() const  "
86233 
86234 [INTERNAL]  Create memory block.
86235 
86236 ";
86237 
86238 %feature("docstring")  casadi::FunctionInternal::reverse(casadi_int nadj)
86239 const  "
86240 
86241 [INTERNAL]  Return function that calculates adjoint derivatives
86242 reverse(nadj) returns a cached instance if available, and calls  Function
86243 get_reverse(casadi_int nadj) if no cached version is available.
86244 
86245 ";
86246 
86247 %feature("docstring")  casadi::ThreadMap::init(const Dict &opts)  "
86248 
86249 [INTERNAL]  Initialize.
86250 
86251 ";
86252 
86253 %feature("docstring")  casadi::Map::has_reverse(casadi_int nadj) const  "
86254 
86255 [INTERNAL]  Generate a function that calculates nadj adjoint derivatives.
86256 
86257 ";
86258 
86259 %feature("docstring")  casadi::FunctionInternal::replace_aseed(const
86260 std::vector< std::vector< M >> &aseed, casadi_int npar) const  "
86261 
86262 [INTERNAL]  Replace 0-by-0 reverse seeds.
86263 
86264 ";
86265 
86266 %feature("docstring")  casadi::FunctionInternal::replace_aseed(const
86267 std::vector< std::vector< M > > &aseed, casadi_int npar) const  "
86268 
86269 [INTERNAL] ";
86270 
86271 %feature("docstring")  casadi::SharedObjectInternal::getCount() const  "
86272 
86273 [INTERNAL]  Get the reference count.
86274 
86275 ";
86276 
86277 %feature("docstring")  casadi::FunctionInternal::nnz_out() const  "
86278 
86279 [INTERNAL]  Number of input/output nonzeros.
86280 
86281 ";
86282 
86283 %feature("docstring")  casadi::FunctionInternal::nnz_out(casadi_int ind)
86284 const  "
86285 
86286 [INTERNAL]  Number of input/output nonzeros.
86287 
86288 ";
86289 
86290 %feature("docstring")  casadi::Map::get_forward(casadi_int nfwd, const
86291 std::string &name, const std::vector< std::string > &inames, const
86292 std::vector< std::string > &onames, const Dict &opts) const  "
86293 
86294 [INTERNAL]  Generate a function that calculates nfwd forward derivatives.
86295 
86296 ";
86297 
86298 %feature("docstring")  casadi::Map::eval_sx(const SXElem **arg, SXElem
86299 **res, casadi_int *iw, SXElem *w, void *mem) const  "
86300 
86301 [INTERNAL]  evaluate symbolically while also propagating directional
86302 derivatives
86303 
86304 ";
86305 
86306 %feature("docstring")  casadi::FunctionInternal::is_diff_out(casadi_int i) "
86307 
86308 [INTERNAL] ";
86309 
86310 %feature("docstring")  casadi::FunctionInternal::project_arg(const
86311 std::vector< M > &arg, casadi_int npar) const  "
86312 
86313 [INTERNAL]   Project sparsities.
86314 
86315 ";
86316 
86317 %feature("docstring")  casadi::Map::has_spfwd() const  "
86318 
86319 [INTERNAL]  Is the class able to propagate seeds through the algorithm?
86320 
86321 ";
86322 
86323 %feature("docstring")  casadi::Map::codegen_declarations(CodeGenerator &g)
86324 const  "
86325 
86326 [INTERNAL]  Generate code for the declarations of the C function.
86327 
86328 ";
86329 
86330 %feature("docstring")  casadi::Map::get_name_in(casadi_int i)  "
86331 
86332 [INTERNAL]  Names of function input and outputs.
86333 
86334 ";
86335 
86336 %feature("docstring")  casadi::FunctionInternal::call(const std::vector< M >
86337 &arg, std::vector< M > &res, bool always_inline, bool never_inline) const  "
86338 
86339 [INTERNAL]   Call a function, templated.
86340 
86341 ";
86342 
86343 %feature("docstring")  casadi::FunctionInternal::map(casadi_int n, const
86344 std::string &parallelization) const  "
86345 
86346 [INTERNAL]  Generate/retrieve cached serial map.
86347 
86348 ";
86349 
86350 %feature("docstring")  casadi::FunctionInternal::has_free() const  "
86351 
86352 [INTERNAL]  Does the function have free variables.
86353 
86354 ";
86355 
86356 %feature("docstring")  casadi::Map::get_reverse(casadi_int nadj, const
86357 std::string &name, const std::vector< std::string > &inames, const
86358 std::vector< std::string > &onames, const Dict &opts) const  "
86359 
86360 [INTERNAL]  Generate a function that calculates nadj adjoint derivatives.
86361 
86362 ";
86363 
86364 %feature("docstring")  casadi::Map::sp_forward(const bvec_t **arg, bvec_t
86365 **res, casadi_int *iw, bvec_t *w, void *mem) const  "
86366 
86367 [INTERNAL]  Propagate sparsity forward.
86368 
86369 ";
86370 
86371 %feature("docstring")  casadi::Map::serialize_type(SerializingStream &s)
86372 const  "
86373 
86374 [INTERNAL]  Serialize type information.
86375 
86376 ";
86377 
86378 %feature("docstring")  casadi::FunctionInternal::sx_in(casadi_int ind) const
86379 "
86380 
86381 [INTERNAL]  Get function input(s) and output(s)
86382 
86383 ";
86384 
86385 %feature("docstring")  casadi::FunctionInternal::sx_in() const  "
86386 
86387 [INTERNAL]  Get function input(s) and output(s)
86388 
86389 ";
86390 
86391 %feature("docstring")  casadi::FunctionInternal::get_min_in(casadi_int ind)
86392 const  "
86393 
86394 [INTERNAL]  Get smallest input value.
86395 
86396 ";
86397 
86398 %feature("docstring")  casadi::FunctionInternal::has_eval_dm() const  "
86399 
86400 [INTERNAL]  Evaluate with DM matrices.
86401 
86402 ";
86403 
86404 %feature("docstring")  casadi::Map::get_sparsity_out(casadi_int i)  "
86405 
86406 [INTERNAL]  Sparsities of function inputs and outputs.
86407 
86408 ";
86409 
86410 %feature("docstring")  casadi::ProtoFunction::format_time(char *buffer,
86411 double time) const  "
86412 
86413 [INTERNAL]  Format time in a fixed width 8 format.
86414 
86415 ";
86416 
86417 %feature("docstring")  casadi::FunctionInternal::codegen_meta(CodeGenerator
86418 &g) const  "
86419 
86420 [INTERNAL]  Generate meta-information allowing a user to evaluate a
86421 generated function.
86422 
86423 ";
86424 
86425 %feature("docstring")  casadi::FunctionInternal::all_scalar() const  "
86426 
86427 [INTERNAL]  Are all inputs and outputs scalar.
86428 
86429 ";
86430 
86431 %feature("docstring")  casadi::FunctionInternal::fwdViaJac(casadi_int nfwd)
86432 const  "
86433 
86434 [INTERNAL]  Calculate derivatives by multiplying the full Jacobian and
86435 multiplying.
86436 
86437 ";
86438 
86439 %feature("docstring")  casadi::FunctionInternal::generate_lifted(Function
86440 &vdef_fcn, Function &vinit_fcn) const  "
86441 
86442 [INTERNAL]  Extract the functions needed for the Lifted Newton method.
86443 
86444 ";
86445 
86446 %feature("docstring")  casadi::ThreadMap::eval(const double **arg, double
86447 **res, casadi_int *iw, double *w, void *mem) const  "
86448 
86449 [INTERNAL]  Evaluate the function numerically.
86450 
86451 ";
86452 
86453 %feature("docstring")  casadi::FunctionInternal::convert_arg(const
86454 std::vector< M > &arg) const  "
86455 
86456 [INTERNAL]  Convert from/to input/output lists/map.
86457 
86458 ";
86459 
86460 %feature("docstring")  casadi::FunctionInternal::convert_arg(const std::map<
86461 std::string, M > &arg) const  "
86462 
86463 [INTERNAL]  Convert from/to input/output lists/map.
86464 
86465 ";
86466 
86467 %feature("docstring")  casadi::Map::has_sprev() const  "
86468 
86469 [INTERNAL]  Is the class able to propagate seeds through the algorithm?
86470 
86471 ";
86472 
86473 %feature("docstring")  casadi::FunctionInternal::get_jacobian_sparsity()
86474 const  "
86475 
86476 [INTERNAL]  Get Jacobian sparsity.
86477 
86478 ";
86479 
86480 %feature("docstring")  casadi::ProtoFunction::print_time(const std::map<
86481 std::string, FStats > &fstats) const  "
86482 
86483 [INTERNAL]  Print timing statistics.
86484 
86485 ";
86486 
86487 %feature("docstring")  casadi::FunctionInternal::size2_out(casadi_int ind)
86488 const  "
86489 
86490 [INTERNAL]  Input/output dimensions.
86491 
86492 ";
86493 
86494 %feature("docstring")  casadi::FunctionInternal::instructions_sx() const  "
86495 
86496 [INTERNAL]  get SX expression associated with instructions
86497 
86498 ";
86499 
86500 %feature("docstring")  casadi::FunctionInternal::nnz_in() const  "
86501 
86502 [INTERNAL]  Number of input/output nonzeros.
86503 
86504 ";
86505 
86506 %feature("docstring")  casadi::FunctionInternal::nnz_in(casadi_int ind)
86507 const  "
86508 
86509 [INTERNAL]  Number of input/output nonzeros.
86510 
86511 ";
86512 
86513 %feature("docstring")  casadi::Map::sp_reverse(bvec_t **arg, bvec_t **res,
86514 casadi_int *iw, bvec_t *w, void *mem) const  "
86515 
86516 [INTERNAL]  Propagate sparsity backwards.
86517 
86518 ";
86519 
86520 %feature("docstring")  casadi::FunctionInternal::export_code(const
86521 std::string &lang, std::ostream &stream, const Dict &options) const  "
86522 
86523 [INTERNAL]  Export function in a specific language.
86524 
86525 ";
86526 
86527 %feature("docstring")  casadi::FunctionInternal::instruction_id(casadi_int
86528 k) const  "
86529 
86530 [INTERNAL]  Get an atomic operation operator index.
86531 
86532 ";
86533 
86534 %feature("docstring")  casadi::FunctionInternal::wrap() const  "
86535 
86536 [INTERNAL]  Wrap in an Function instance consisting of only one MX call.
86537 
86538 ";
86539 
86540 %feature("docstring")  casadi::FunctionInternal::slice(const std::string
86541 &name, const std::vector< casadi_int > &order_in, const std::vector<
86542 casadi_int > &order_out, const Dict &opts) const  "
86543 
86544 [INTERNAL]  returns a new function with a selection of inputs/outputs of the
86545 original
86546 
86547 ";
86548 
86549 %feature("docstring")  casadi::FunctionInternal::call_forward(const
86550 std::vector< MX > &arg, const std::vector< MX > &res, const std::vector<
86551 std::vector< MX > > &fseed, std::vector< std::vector< MX > > &fsens, bool
86552 always_inline, bool never_inline) const  "
86553 
86554 [INTERNAL]  Forward mode AD, virtual functions overloaded in derived
86555 classes.
86556 
86557 ";
86558 
86559 %feature("docstring")  casadi::FunctionInternal::call_forward(const
86560 std::vector< SX > &arg, const std::vector< SX > &res, const std::vector<
86561 std::vector< SX > > &fseed, std::vector< std::vector< SX > > &fsens, bool
86562 always_inline, bool never_inline) const  "
86563 
86564 [INTERNAL]  Forward mode AD, virtual functions overloaded in derived
86565 classes.
86566 
86567 ";
86568 
86569 %feature("docstring")  casadi::FunctionInternal::codegen_mem(CodeGenerator
86570 &g, const std::string &index="mem") const  "
86571 
86572 [INTERNAL]  Get thread-local memory object.
86573 
86574 ";
86575 
86576 %feature("docstring")  casadi::FunctionInternal::index_out(const std::string
86577 &name) const  "
86578 
86579 [INTERNAL]  Get output scheme index by name.
86580 
86581 ";
86582 
86583 %feature("docstring")  casadi::ThreadMap::is_a(const std::string &type, bool
86584 recursive) const  "
86585 
86586 [INTERNAL]  Check if the function is of a particular type.
86587 
86588 ";
86589 
86590 %feature("docstring")  casadi::ThreadMap::codegen_body(CodeGenerator &g)
86591 const  "
86592 
86593 [INTERNAL]  Generate code for the body of the C function.
86594 
86595 ";
86596 
86597 %feature("docstring")  casadi::Map::get_function() const  "
86598 
86599 [INTERNAL] ";
86600 
86601 %feature("docstring")  casadi::Map::get_function(const std::string &name)
86602 const  "
86603 
86604 [INTERNAL] ";
86605 
86606 %feature("docstring")  casadi::FunctionInternal::mx_in(casadi_int ind) const
86607 "
86608 
86609 [INTERNAL]  Get function input(s) and output(s)
86610 
86611 ";
86612 
86613 %feature("docstring")  casadi::FunctionInternal::mx_in() const  "
86614 
86615 [INTERNAL]  Get function input(s) and output(s)
86616 
86617 ";
86618 
86619 %feature("docstring")  casadi::FunctionInternal::nz_out(const std::vector<
86620 DM > &res) const  "
86621 
86622 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
86623 
86624 ";
86625 
86626 %feature("docstring")  casadi::FunctionInternal::nz_out(const std::vector<
86627 double > &res) const  "
86628 
86629 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
86630 
86631 ";
86632 
86633 %feature("docstring")  casadi::FunctionInternal::sz_iw() const  "
86634 
86635 [INTERNAL]  Get required length of iw field.
86636 
86637 ";
86638 
86639 %feature("docstring")
86640 casadi::FunctionInternal::getJacSparsityHierarchicalSymm(casadi_int iind,
86641 casadi_int oind) const  "
86642 
86643 [INTERNAL]  A flavor of getJacSparsity that does hierarchical block
86644 structure recognition for symmetric Jacobians
86645 
86646 ";
86647 
86648 %feature("docstring")  casadi::FunctionInternal::incache(const std::string
86649 &fname, Function &f, const std::string &suffix="") const  "
86650 
86651 [INTERNAL]  Get function in cache.
86652 
86653 ";
86654 
86655 %feature("docstring")  casadi::FunctionInternal::n_instructions() const  "
86656 
86657 [INTERNAL]  Get the number of atomic operations.
86658 
86659 ";
86660 
86661 %feature("docstring")  casadi::ProtoFunction::get_stats(void *mem) const  "
86662 
86663 [INTERNAL]  Get all statistics.
86664 
86665 ";
86666 
86667 %feature("docstring")  casadi::FunctionInternal::convert_res(const
86668 std::vector< M > &res) const  "
86669 
86670 [INTERNAL]  Convert from/to input/output lists/map.
86671 
86672 ";
86673 
86674 %feature("docstring")  casadi::FunctionInternal::convert_res(const std::map<
86675 std::string, M > &res) const  "
86676 
86677 [INTERNAL]  Convert from/to input/output lists/map.
86678 
86679 ";
86680 
86681 %feature("docstring")
86682 casadi::FunctionInternal::getJacSparsityHierarchical(casadi_int iind,
86683 casadi_int oind) const  "
86684 
86685 [INTERNAL]  A flavor of getJacSparsity that does hierarchical block
86686 structure recognition.
86687 
86688 ";
86689 
86690 %feature("docstring")  casadi::FunctionInternal::codegen(CodeGenerator &g,
86691 const std::string &fname) const  "
86692 
86693 [INTERNAL]  Generate code the function.
86694 
86695 ";
86696 
86697 %feature("docstring")  casadi::FunctionInternal::sparsity_out(casadi_int
86698 ind) const  "
86699 
86700 [INTERNAL]  Input/output sparsity.
86701 
86702 ";
86703 
86704 %feature("docstring")  casadi::FunctionInternal::has_jacobian_sparsity()
86705 const  "
86706 
86707 [INTERNAL]  Get Jacobian sparsity.
86708 
86709 ";
86710 
86711 %feature("docstring")  casadi::FunctionInternal::get_abstol() const  "
86712 
86713 [INTERNAL]  Get absolute tolerance.
86714 
86715 ";
86716 
86717 %feature("docstring")  casadi::FunctionInternal::alloc_w(size_t sz_w, bool
86718 persistent=false) "
86719 
86720 [INTERNAL]  Ensure required length of w field.
86721 
86722 ";
86723 
86724 %feature("docstring")  casadi::FunctionInternal::call_reverse(const
86725 std::vector< MX > &arg, const std::vector< MX > &res, const std::vector<
86726 std::vector< MX > > &aseed, std::vector< std::vector< MX > > &asens, bool
86727 always_inline, bool never_inline) const  "
86728 
86729 [INTERNAL]  Reverse mode, virtual functions overloaded in derived classes.
86730 
86731 ";
86732 
86733 %feature("docstring")  casadi::FunctionInternal::call_reverse(const
86734 std::vector< SX > &arg, const std::vector< SX > &res, const std::vector<
86735 std::vector< SX > > &aseed, std::vector< std::vector< SX > > &asens, bool
86736 always_inline, bool never_inline) const  "
86737 
86738 [INTERNAL]  Reverse mode, virtual functions overloaded in derived classes.
86739 
86740 ";
86741 
86742 %feature("docstring")  casadi::SharedObjectInternal::weak() "
86743 
86744 [INTERNAL]  Get a weak reference to the object.
86745 
86746 ";
86747 
86748 %feature("docstring")  casadi::FunctionInternal::ad_weight() const  "
86749 
86750 [INTERNAL]  Weighting factor for chosing forward/reverse mode.
86751 
86752 ";
86753 
86754 %feature("docstring")  casadi::FunctionInternal::codegen_mem_type() const  "
86755 
86756 [INTERNAL]  Thread-local memory object type.
86757 
86758 ";
86759 
86760 %feature("docstring")  casadi::Map::get_n_in()  "
86761 
86762 [INTERNAL]  Number of function inputs and outputs.
86763 
86764 ";
86765 
86766 %feature("docstring")  casadi::FunctionInternal::disp_more(std::ostream
86767 &stream) const  "
86768 
86769 [INTERNAL]  Print more.
86770 
86771 ";
86772 
86773 %feature("docstring")  casadi::FunctionInternal::size1_in(casadi_int ind)
86774 const  "
86775 
86776 [INTERNAL]  Input/output dimensions.
86777 
86778 ";
86779 
86780 %feature("docstring")  casadi::FunctionInternal::fwd_seed(casadi_int nfwd)
86781 const  "
86782 
86783 [INTERNAL]  Symbolic expressions for the forward seeds.
86784 
86785 ";
86786 
86787 %feature("docstring")  casadi::FunctionInternal::nz_in(const std::vector< DM
86788 > &arg) const  "
86789 
86790 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
86791 
86792 ";
86793 
86794 %feature("docstring")  casadi::FunctionInternal::nz_in(const std::vector<
86795 double > &arg) const  "
86796 
86797 [INTERNAL]  Convert from/to flat vector of input/output nonzeros.
86798 
86799 ";
86800 
86801 %feature("docstring")  casadi::FunctionInternal::definition() const  "
86802 
86803 [INTERNAL]  Get function signature: name:(inputs)->(outputs)
86804 
86805 ";
86806 
86807 %feature("docstring")  casadi::FunctionInternal::getJacSparsity(casadi_int
86808 iind, casadi_int oind, bool symmetric) const  "
86809 
86810 [INTERNAL]  Generate the sparsity of a Jacobian block.
86811 
86812 ";
86813 
86814 %feature("docstring") casadi::ThreadMap::~ThreadMap "
86815 
86816 [INTERNAL]  Destructor.
86817 
86818 ";
86819 
86820 %feature("docstring")  casadi::ProtoFunction::init_mem(void *mem) const  "
86821 
86822 [INTERNAL]  Initalize memory block.
86823 
86824 ";
86825 
86826 %feature("docstring")  casadi::FunctionInternal::codegen_name(const
86827 CodeGenerator &g, bool ns=true) const  "
86828 
86829 [INTERNAL]  Get name in codegen.
86830 
86831 ";
86832 
86833 %feature("docstring")  casadi::FunctionInternal::set_work(void *mem, const
86834 double **&arg, double **&res, casadi_int *&iw, double *&w) const  "
86835 
86836 [INTERNAL]  Set the (persistent) work vectors.
86837 
86838 ";
86839 
86840 %feature("docstring")  casadi::FunctionInternal::numel_out(casadi_int ind)
86841 const  "
86842 
86843 [INTERNAL]  Number of input/output elements.
86844 
86845 ";
86846 
86847 %feature("docstring")  casadi::FunctionInternal::numel_out() const  "
86848 
86849 [INTERNAL]  Number of input/output elements.
86850 
86851 ";
86852 
86853 %feature("docstring")  casadi::FunctionInternal::dm_in(casadi_int ind) const
86854 "
86855 
86856 [INTERNAL]  Get function input(s) and output(s)
86857 
86858 ";
86859 
86860 %feature("docstring")  casadi::FunctionInternal::dm_in() const  "
86861 
86862 [INTERNAL]  Get function input(s) and output(s)
86863 
86864 ";
86865 
86866 %feature("docstring")
86867 casadi::FunctionInternal::codegen_decref(CodeGenerator &g) const  "
86868 
86869 [INTERNAL]  Codegen decref for dependencies.
86870 
86871 ";
86872 
86873 %feature("docstring")  casadi::FunctionInternal::generate_options(bool
86874 is_temp=false) const  "
86875 
86876 [INTERNAL]  Reconstruct options dict.
86877 
86878 ";
86879 
86880 %feature("docstring")  casadi::FunctionInternal::size1_out(casadi_int ind)
86881 const  "
86882 
86883 [INTERNAL]  Input/output dimensions.
86884 
86885 ";
86886 
86887 %feature("docstring")  casadi::FunctionInternal::mx_out(casadi_int ind)
86888 const  "
86889 
86890 [INTERNAL]  Get function input(s) and output(s)
86891 
86892 ";
86893 
86894 %feature("docstring")  casadi::FunctionInternal::mx_out() const  "
86895 
86896 [INTERNAL]  Get function input(s) and output(s)
86897 
86898 ";
86899 
86900 %feature("docstring")
86901 casadi::FunctionInternal::instruction_constant(casadi_int k) const  "
86902 
86903 [INTERNAL]  Get the floating point output argument of an atomic operation.
86904 
86905 ";
86906 
86907 %feature("docstring")  casadi::FunctionInternal::index_in(const std::string
86908 &name) const  "
86909 
86910 [INTERNAL]  Get input scheme index by name.
86911 
86912 ";
86913 
86914 %feature("docstring")  casadi::FunctionInternal::size_in(casadi_int ind)
86915 const  "
86916 
86917 [INTERNAL]  Input/output dimensions.
86918 
86919 ";
86920 
86921 %feature("docstring")  casadi::FunctionInternal::replace_fseed(const
86922 std::vector< std::vector< M >> &fseed, casadi_int npar) const  "
86923 
86924 [INTERNAL]  Replace 0-by-0 forward seeds.
86925 
86926 ";
86927 
86928 %feature("docstring")  casadi::FunctionInternal::replace_fseed(const
86929 std::vector< std::vector< M > > &fseed, casadi_int npar) const  "
86930 
86931 [INTERNAL] ";
86932 
86933 %feature("docstring")  casadi::FunctionInternal::get_reltol() const  "
86934 
86935 [INTERNAL]  Get relative tolerance.
86936 
86937 ";
86938 
86939 %feature("docstring")  casadi::Map::get_default_in(casadi_int ind) const  "
86940 
86941 [INTERNAL]  Get default input value.
86942 
86943 ";
86944 
86945 %feature("docstring")  casadi::FunctionInternal::matching_arg(const
86946 std::vector< M > &arg, casadi_int &npar) const  "
86947 
86948 [INTERNAL]  Check if input arguments that needs to be replaced.
86949 
86950 Raises errors
86951 
86952 Parameters:
86953 -----------
86954 
86955 npar[in]:  normal usage: 1, disallow pararallel calls: -1
86956 
86957 npar:  max number of horizontal repetitions across all arguments (or -1)
86958 
86959 ";
86960 
86961 %feature("docstring")  casadi::FunctionInternal::getAdaptorSolverName()
86962 const  "
86963 
86964 [INTERNAL]  Obtain solver name from Adaptor.
86965 
86966 ";
86967 
86968 %feature("docstring")  casadi::FunctionInternal::has_jac() const  "
86969 
86970 [INTERNAL]  Return Jacobian of all input elements with respect to all output
86971 elements.
86972 
86973 ";
86974 
86975 %feature("docstring")  casadi::FunctionInternal::forward(casadi_int nfwd)
86976 const  "
86977 
86978 [INTERNAL]  Return function that calculates forward derivatives
86979 forward(nfwd) returns a cached instance if available, and calls  Function
86980 get_forward(casadi_int nfwd) if no cached version is available.
86981 
86982 ";
86983 
86984 %feature("docstring")  casadi::FunctionInternal::has_derivative() const  "
86985 
86986 [INTERNAL]  Can derivatives be calculated in any way?
86987 
86988 ";
86989 
86990 %feature("docstring")  casadi::FunctionInternal::get_jac(const std::string
86991 &name, const std::vector< std::string > &inames, const std::vector<
86992 std::string > &onames, const Dict &opts) const  "
86993 
86994 [INTERNAL]  Return Jacobian of all input elements with respect to all output
86995 elements.
86996 
86997 ";
86998 
86999 %feature("docstring")  casadi::FunctionInternal::print_options(std::ostream
87000 &stream) const  "
87001 
87002 [INTERNAL]  Print list of options.
87003 
87004 ";
87005 
87006 %feature("docstring")  casadi::FunctionInternal::generate_in(const
87007 std::string &fname, const double **arg) const  "
87008 
87009 [INTERNAL]  Export an input file that can be passed to generate C code with
87010 a main.
87011 
87012 ";
87013 
87014 %feature("docstring")  casadi::ProtoFunction::free_mem(void *mem) const  "
87015 
87016 [INTERNAL]  Free memory block.
87017 
87018 ";
87019 
87020 %feature("docstring")  casadi::FunctionInternal::free_mx() const  "
87021 
87022 [INTERNAL]  Get free variables ( MX)
87023 
87024 ";
87025 
87026 %feature("docstring")  casadi::Map::get_n_out()  "
87027 
87028 [INTERNAL]  Number of function inputs and outputs.
87029 
87030 ";
87031 
87032 %feature("docstring")  casadi::ProtoFunction::sprint(char *buf, size_t
87033 buf_sz, const char *fmt,...) const  "
87034 
87035 [INTERNAL]  C-style formatted printing to string.
87036 
87037 ";
87038 
87039 %feature("docstring")  casadi::FunctionInternal::jacobian_sparsity() const
87040 "
87041 
87042 [INTERNAL]  Get Jacobian sparsity.
87043 
87044 ";
87045 
87046 %feature("docstring")
87047 casadi::FunctionInternal::codegen_alloc_mem(CodeGenerator &g) const  "
87048 
87049 [INTERNAL]  Codegen decref for alloc_mem.
87050 
87051 ";
87052 
87053 %feature("docstring")  casadi::Map::has_codegen() const  "
87054 
87055 [INTERNAL]  Is codegen supported?
87056 
87057 ";
87058 
87059 %feature("docstring")  casadi::FunctionInternal::numel_in() const  "
87060 
87061 [INTERNAL]  Number of input/output elements.
87062 
87063 ";
87064 
87065 %feature("docstring")  casadi::FunctionInternal::numel_in(casadi_int ind)
87066 const  "
87067 
87068 [INTERNAL]  Number of input/output elements.
87069 
87070 ";
87071 
87072 %feature("docstring")  casadi::FunctionInternal::n_nodes() const  "
87073 
87074 [INTERNAL]  Number of nodes in the algorithm.
87075 
87076 ";
87077 
87078 %feature("docstring")  casadi::FunctionInternal::replace_res(const
87079 std::vector< M > &res, casadi_int npar) const  "
87080 
87081 [INTERNAL]  Replace 0-by-0 outputs.
87082 
87083 ";
87084 
87085 %feature("docstring")  casadi::ProtoFunction::clear_mem() "
87086 
87087 [INTERNAL]  Clear all memory (called from destructor)
87088 
87089 ";
87090 
87091 %feature("docstring")  casadi::FunctionInternal::sz_w() const  "
87092 
87093 [INTERNAL]  Get required length of w field.
87094 
87095 ";
87096 
87097 %feature("docstring")  casadi::Map::has_function(const std::string &fname)
87098 const  "
87099 
87100 [INTERNAL] ";
87101 
87102 %feature("docstring")  casadi::FunctionInternal::adjViaJac(casadi_int nadj)
87103 const  "
87104 
87105 [INTERNAL]  Calculate derivatives by multiplying the full Jacobian and
87106 multiplying.
87107 
87108 ";
87109 
87110 %feature("docstring")  casadi::FunctionInternal::is_diff_in(casadi_int i) "
87111 
87112 [INTERNAL] ";
87113 
87114 %feature("docstring")  casadi::ProtoFunction::release(int mem) const  "
87115 
87116 [INTERNAL]  Release a memory object.
87117 
87118 ";
87119 
87120 %feature("docstring")  casadi::Map::serialize_base_function() const  "
87121 
87122 [INTERNAL]  String used to identify the immediate FunctionInternal subclass.
87123 
87124 ";
87125 
87126 %feature("docstring")  casadi::ProtoFunction::print(const char *fmt,...)
87127 const  "
87128 
87129 [INTERNAL]  C-style formatted printing during evaluation.
87130 
87131 ";
87132 
87133 %feature("docstring")  casadi::FunctionInternal::alloc_arg(size_t sz_arg,
87134 bool persistent=false) "
87135 
87136 [INTERNAL]  Ensure required length of arg field.
87137 
87138 ";
87139 
87140 %feature("docstring")  casadi::FunctionInternal::uses_output() const  "
87141 
87142 [INTERNAL]  Do the derivative functions need nondifferentiated outputs?
87143 
87144 ";
87145 
87146 %feature("docstring")  casadi::FunctionInternal::factory(const std::string
87147 &name, const std::vector< std::string > &s_in, const std::vector<
87148 std::string > &s_out, const Function::AuxOut &aux, const Dict &opts) const
87149 "
87150 
87151 [INTERNAL] ";
87152 
87153 %feature("docstring")  casadi::FunctionInternal::sz_work(size_t &sz_arg,
87154 size_t &sz_res, size_t &sz_iw, size_t &sz_w) const  "
87155 
87156 [INTERNAL]  Get number of temporary variables needed.
87157 
87158 ";
87159 
87160 %feature("docstring")  casadi::FunctionInternal::instruction_MX(casadi_int
87161 k) const  "
87162 
87163 [INTERNAL]  get MX expression associated with instruction
87164 
87165 ";
87166 
87167 %feature("docstring")  casadi::FunctionInternal::alloc_res(size_t sz_res,
87168 bool persistent=false) "
87169 
87170 [INTERNAL]  Ensure required length of res field.
87171 
87172 ";
87173 
87174 %feature("docstring")  casadi::FunctionInternal::print_option(const
87175 std::string &name, std::ostream &stream) const  "
87176 
87177 [INTERNAL]  Print all information there is to know about a certain option.
87178 
87179 ";
87180 
87181 %feature("docstring")
87182 casadi::FunctionInternal::codegen_free_mem(CodeGenerator &g) const  "
87183 
87184 [INTERNAL]  Codegen for free_mem.
87185 
87186 ";
87187 
87188 %feature("docstring")  casadi::FunctionInternal::check_mat(const Sparsity
87189 &arg, const Sparsity &inp, casadi_int &npar) "
87190 
87191 [INTERNAL]  Helper function
87192 
87193 Parameters:
87194 -----------
87195 
87196 npar[in]:  normal usage: 1, disallow pararallel calls: -1
87197 
87198 npar[out]:  required number of parallel calls (or -1)
87199 
87200 ";
87201 
87202 %feature("docstring")  casadi::FunctionInternal::oracle() const  "
87203 
87204 [INTERNAL]  Get oracle.
87205 
87206 ";
87207 
87208 %feature("docstring")  casadi::FunctionInternal::symbolic_output(const
87209 std::vector< MX > &arg) const  "
87210 
87211 [INTERNAL]  Get a vector of symbolic variables corresponding to the outputs.
87212 
87213 ";
87214 
87215 %feature("docstring")  casadi::FunctionInternal::setup(void *mem, const
87216 double **arg, double **res, casadi_int *iw, double *w) const  "
87217 
87218 [INTERNAL]  Set the (persistent and temporary) work vectors.
87219 
87220 ";
87221 
87222 %feature("docstring")  casadi::FunctionInternal::generate_dependencies(const
87223 std::string &fname, const Dict &opts) const  "
87224 
87225 [INTERNAL]  Export / Generate C code for the dependency function.
87226 
87227 ";
87228 
87229 %feature("docstring")  casadi::FunctionInternal::sp_weight() const  "
87230 
87231 [INTERNAL]  Weighting factor for chosing forward/reverse mode, sparsity
87232 propagation.
87233 
87234 ";
87235 
87236 %feature("docstring") casadi::ThreadMap "
87237 
87238 [INTERNAL]  A map Evaluate in parallel using std::thread Note: Do not use
87239 this class with much more than the intended number of threads for the
87240 parallel evaluation as it will cause excessive memory use.
87241 
87242 Joris Gillis
87243 
87244 C++ includes: map.hpp ";
87245 
87246 %feature("docstring")
87247 casadi::FunctionInternal::jacobian_sparsity_filter(const Sparsity &sp) const
87248 "
87249 
87250 [INTERNAL]  Filter out nonzeros in the full sparsity jacobian according to
87251 is_diff_in/out.
87252 
87253 ";
87254 
87255 %feature("docstring")
87256 casadi::FunctionInternal::codegen_sparsities(CodeGenerator &g) const  "
87257 
87258 [INTERNAL]  Codegen sparsities.
87259 
87260 ";
87261 
87262 %feature("docstring")  casadi::FunctionInternal::jit_dependencies(const
87263 std::string &fname) "
87264 
87265 [INTERNAL]  Jit dependencies.
87266 
87267 ";
87268 
87269 
87270 // File: classcasadi_1_1Transpose.xml
87271 
87272 
87273 // File: classcasadi_1_1UnaryMX.xml
87274 
87275 
87276 // File: classcasadi_1_1UnarySX.xml
87277 
87278 
87279 // File: classcasadi_1_1Vertcat.xml
87280 
87281 
87282 // File: classcasadi_1_1Vertsplit.xml
87283 
87284 
87285 // File: classcasadi_1_1WeakRef.xml
87286 %feature("docstring") casadi::WeakRef "
87287 
87288 Weak reference type A weak reference to a SharedObject.
87289 
87290 Joel Andersson
87291 
87292 C++ includes: shared_object.hpp ";
87293 
87294 %feature("docstring")  casadi::WeakRef::shared() "
87295 
87296 Get a shared (owning) reference.
87297 
87298 ";
87299 
87300 %feature("docstring") casadi::casadi_shared "
87301 
87302 Get a shared (owning) reference.
87303 
87304 ";
87305 
87306 %feature("docstring")  casadi::WeakRef::casadi_shared "
87307 
87308 Get a shared (owning) reference.
87309 
87310 ";
87311 
87312 %feature("docstring") casadi::WeakRef::__hash__ "
87313 
87314 Returns a number that is unique for a given Node. If the Object does not
87315 point to any node, \"0\" is returned.
87316 
87317 ";
87318 
87319 %feature("docstring")  casadi::SharedObject::is_null() const  "
87320 
87321 Is a null pointer?
87322 
87323 ";
87324 
87325 %feature("docstring")  casadi::SharedObject::print_ptr(std::ostream
87326 &stream=casadi::uout()) const  "
87327 
87328 [INTERNAL]  Print the pointer to the internal class
87329 
87330 ";
87331 
87332 %feature("docstring") casadi::WeakRef::WeakRef(int dummy=0) "
87333 
87334 Default constructor.
87335 
87336 ";
87337 
87338 %feature("docstring") casadi::WeakRef::WeakRef(SharedObject shared) "
87339 
87340 Construct from a shared object (also implicit type conversion)
87341 
87342 ";
87343 
87344 %feature("docstring")  casadi::SharedObject::disp(std::ostream &stream, bool
87345 more=false) const  "
87346 
87347 Print a description of the object.
87348 
87349 ";
87350 
87351 %feature("docstring")  casadi::SharedObject::get_str(bool more=false) const
87352 "
87353 
87354 Get string representation.
87355 
87356 ";
87357 
87358 %feature("docstring")  casadi::SharedObject::class_name() const  "
87359 
87360 Get class name.
87361 
87362 ";
87363 
87364 %feature("docstring")  casadi::WeakRef::alive() const  "
87365 
87366 Check if alive.
87367 
87368 ";
87369 
87370 
87371 // File: classcasadi_1_1XFunction.xml
87372 
87373 
87374 // File: classcasadi_1_1XmlFile.xml
87375 %feature("docstring") casadi::XmlFile "
87376 
87377 XML parser Can be used for parsing XML files into CasADi data structures.
87378 
87379 Joel Andersson
87380 
87381 C++ includes: xml_file.hpp ";
87382 
87383 %feature("docstring")  casadi::SharedObject::get_str(bool more=false) const
87384 "
87385 
87386 Get string representation.
87387 
87388 ";
87389 
87390 %feature("docstring") casadi::XmlFile::__hash__ "
87391 
87392 Returns a number that is unique for a given Node. If the Object does not
87393 point to any node, \"0\" is returned.
87394 
87395 ";
87396 
87397 %feature("docstring")  casadi::SharedObject::class_name() const  "
87398 
87399 Get class name.
87400 
87401 ";
87402 
87403 %feature("docstring")  casadi::SharedObject::is_null() const  "
87404 
87405 Is a null pointer?
87406 
87407 ";
87408 
87409 %feature("docstring")  casadi::SharedObject::disp(std::ostream &stream, bool
87410 more=false) const  "
87411 
87412 Print a description of the object.
87413 
87414 ";
87415 
87416 %feature("docstring")  casadi::SharedObject::print_ptr(std::ostream
87417 &stream=casadi::uout()) const  "
87418 
87419 [INTERNAL]  Print the pointer to the internal class
87420 
87421 ";
87422 
87423 
87424 // File: classcasadi_1_1ZeroByZero.xml
87425 
87426 
87427 // File: classcasadi_1_1ZeroSX.xml
87428 
87429 
87430 // File: namespaceBonmin.xml
87431 
87432 
87433 // File: namespacecasadi.xml
87434 %feature("docstring")  casadi::is_nondecreasing(const std::vector< T > &v) "
87435 Check if the vector is non-decreasing.
87436 
87437 ";
87438 
87439 %feature("docstring")  casadi::matrixName< double >() "
87440 
87441 Get typename.
87442 
87443 ";
87444 
87445 %feature("docstring")  casadi::complement(const std::vector< casadi_int >
87446 &v, casadi_int size) "
87447 
87448 Returns the list of all i in [0, size[ not found in supplied list.
87449 
87450 The supplied vector may contain duplicates and may be non-monotonous The
87451 supplied vector will be checked for bounds The result vector is guaranteed
87452 to be monotonously increasing
87453 
87454 ";
87455 
87456 %feature("docstring")  casadi::conic_option_type(const std::string &name,
87457 const std::string &op) "
87458 
87459 Get type info for a particular option.
87460 
87461 ";
87462 
87463 %feature("docstring")  casadi::casadi_qp_pr_index(casadi_qp_data< T1 > *d) "
87464 
87465 [INTERNAL] ";
87466 
87467 %feature("docstring")  casadi::load_expm(const std::string &name) "
87468 
87469 Explicitly load a plugin dynamically.
87470 
87471 ";
87472 
87473 %feature("docstring")  casadi::casadi_rank1(T1 *A, const casadi_int *sp_A,
87474 T1 alpha, const T1 *x) "
87475 
87476 [INTERNAL]  Adds a multiple alpha/2 of the outer product mul(x, trans(x)) to
87477 A.
87478 
87479 ";
87480 
87481 %feature("docstring")  casadi::casadi_rank1(T1 *A, const casadi_int *sp_A,
87482 T1 alpha, const T1 *x, const T1 *y) "
87483 
87484 [INTERNAL] ";
87485 
87486 %feature("docstring")  casadi::casadi_nlpsol_work(const casadi_nlpsol_prob<
87487 T1 > *p, casadi_int *sz_iw, casadi_int *sz_w) "
87488 
87489 [INTERNAL] ";
87490 
87491 %feature("docstring")  casadi::casadi_cvx_house_apply(casadi_int n,
87492 casadi_int m, casadi_int s, T1 *A, T1 *p, const T1 *v) "
87493 
87494 [INTERNAL]  Apply householder transform on dense A m-by-n matrix
87495 
87496 A is modified in-place
87497 
87498 s : stride normally equal to m when A is a submatrix of a bigger matrix, set
87499 equal to latter's number of rows v : compact housholder factorisation
87500 (length m) First element (always one) is used to store beta p : length n
87501 
87502 ";
87503 
87504 %feature("docstring")  casadi::casadi_qp_kkt_residual(casadi_qp_data< T1 >
87505 *d, T1 *r) "
87506 
87507 [INTERNAL] ";
87508 
87509 %feature("docstring")  casadi::detect_simple_bounds(const SX &xX, const SX
87510 &p, const SX &g, const SX &lbg, const SX &ubg, std::vector< casadi_int >
87511 &output_gi, SX &output_lbx, SX &output_ubx, Function &output_lam_forward,
87512 Function &output_lam_backward) "
87513 
87514 Detect simple bounds from general constraints.
87515 
87516 Given parametric constraints:
87517 
87518 ::
87519 
87520   *   subject to lbg(p) <= g(x,p) <= ubg(p)
87521   *
87522 
87523 
87524 
87525 Returns an equivalent set
87526 
87527 ::
87528 
87529   *   subject to  lbg(p)(gi) <= g(x,p)(gi) <= ubg(p)(gi)
87530   *               lbx(p) <= x                 <= ubx(p)
87531   *
87532 
87533 
87534 
87535 Parameters:
87536 -----------
87537 
87538 lam_forward:  (lam_g,p)->(lam_sg,lam_x)
87539 
87540 lam_backward:  (lam_sg,lam_x,p)->(lam_g)
87541 
87542 ";
87543 
87544 %feature("docstring")  casadi::detect_simple_bounds(const MX &xX, const MX
87545 &p, const MX &g, const MX &lbg, const MX &ubg, std::vector< casadi_int >
87546 &output_gi, MX &output_lbx, MX &output_ubx, Function &output_lam_forward,
87547 Function &output_lam_backward) "
87548 
87549 Detect simple bounds from general constraints.
87550 
87551 Given parametric constraints:
87552 
87553 ::
87554 
87555   *   subject to lbg(p) <= g(x,p) <= ubg(p)
87556   *
87557 
87558 
87559 
87560 Returns an equivalent set
87561 
87562 ::
87563 
87564   *   subject to  lbg(p)(gi) <= g(x,p)(gi) <= ubg(p)(gi)
87565   *               lbx(p) <= x                 <= ubx(p)
87566   *
87567 
87568 
87569 
87570 Parameters:
87571 -----------
87572 
87573 lam_forward:  (lam_g,p)->(lam_sg,lam_x)
87574 
87575 lam_backward:  (lam_sg,lam_x,p)->(lam_g)
87576 
87577 ";
87578 
87579 %feature("docstring")  casadi::dense_mul_tn(casadi_int n, casadi_int m,
87580 casadi_int l, const double *A, const double *B, double *C) "
87581 
87582 [INTERNAL] ";
87583 
87584 %feature("docstring")  casadi::dense_mul_nn_stride(casadi_int n, casadi_int
87585 m, casadi_int l, const double *A, const double *B, double *C, casadi_int
87586 strideA, casadi_int strideB, casadi_int strideC) "
87587 
87588 [INTERNAL] ";
87589 
87590 %feature("docstring")  casadi::dple_out() "
87591 
87592 Get output scheme of DPLE solvers.
87593 
87594 ";
87595 
87596 %feature("docstring")  casadi::dple_out(casadi_int ind) "
87597 
87598 Get DPLE output scheme name by index.
87599 
87600 ";
87601 
87602 %feature("docstring")  casadi::casadi_norm_1(casadi_int n, const T1 *x) "
87603 
87604 [INTERNAL]  NORM_1: ||x||_1 -> return.
87605 
87606 ";
87607 
87608 %feature("docstring")  casadi::expmsol(const std::string &name, const
87609 std::string &solver, const Sparsity &A, const Dict &opts=Dict()) "
87610 
87611 Performs a matrix exponentiation expm(A)
87612 
87613 General information
87614 ===================
87615 
87616 
87617 
87618 >List of available options
87619 
87620 +------------------+-----------------+------------------+------------------+
87621 |        Id        |      Type       |   Description    |     Used in      |
87622 +==================+=================+==================+==================+
87623 | ad_weight        | OT_DOUBLE       | Weighting factor | casadi::Function |
87624 |                  |                 | for derivative   | Internal         |
87625 |                  |                 | calculation.When |                  |
87626 |                  |                 | there is an      |                  |
87627 |                  |                 | option of either |                  |
87628 |                  |                 | using forward or |                  |
87629 |                  |                 | reverse mode     |                  |
87630 |                  |                 | directional      |                  |
87631 |                  |                 | derivatives, the |                  |
87632 |                  |                 | condition ad_wei |                  |
87633 |                  |                 | ght*nf<=(1-ad_we |                  |
87634 |                  |                 | ight)*na is used |                  |
87635 |                  |                 | where nf and na  |                  |
87636 |                  |                 | are estimates of |                  |
87637 |                  |                 | the number of    |                  |
87638 |                  |                 | forward/reverse  |                  |
87639 |                  |                 | mode directional |                  |
87640 |                  |                 | derivatives      |                  |
87641 |                  |                 | needed. By       |                  |
87642 |                  |                 | default,         |                  |
87643 |                  |                 | ad_weight is     |                  |
87644 |                  |                 | calculated       |                  |
87645 |                  |                 | automatically,   |                  |
87646 |                  |                 | but this can be  |                  |
87647 |                  |                 | overridden by    |                  |
87648 |                  |                 | setting this     |                  |
87649 |                  |                 | option. In       |                  |
87650 |                  |                 | particular, 0    |                  |
87651 |                  |                 | means forcing    |                  |
87652 |                  |                 | forward mode and |                  |
87653 |                  |                 | 1 forcing        |                  |
87654 |                  |                 | reverse mode.    |                  |
87655 |                  |                 | Leave unset for  |                  |
87656 |                  |                 | (class specific) |                  |
87657 |                  |                 | heuristics.      |                  |
87658 +------------------+-----------------+------------------+------------------+
87659 | ad_weight_sp     | OT_DOUBLE       | Weighting factor | casadi::Function |
87660 |                  |                 | for sparsity     | Internal         |
87661 |                  |                 | pattern          |                  |
87662 |                  |                 | calculation calc |                  |
87663 |                  |                 | ulation.Override |                  |
87664 |                  |                 | s default        |                  |
87665 |                  |                 | behavior. Set to |                  |
87666 |                  |                 | 0 and 1 to force |                  |
87667 |                  |                 | forward and      |                  |
87668 |                  |                 | reverse mode     |                  |
87669 |                  |                 | respectively.    |                  |
87670 |                  |                 | Cf. option       |                  |
87671 |                  |                 | \"ad_weight\".     |                  |
87672 |                  |                 | When set to -1,  |                  |
87673 |                  |                 | sparsity is      |                  |
87674 |                  |                 | completely       |                  |
87675 |                  |                 | ignored and      |                  |
87676 |                  |                 | dense matrices   |                  |
87677 |                  |                 | are used.        |                  |
87678 +------------------+-----------------+------------------+------------------+
87679 | always_inline    | OT_BOOL         | Force inlining.  | casadi::Function |
87680 |                  |                 |                  | Internal         |
87681 +------------------+-----------------+------------------+------------------+
87682 | compiler         | OT_STRING       | Just-in-time     | casadi::Function |
87683 |                  |                 | compiler plugin  | Internal         |
87684 |                  |                 | to be used.      |                  |
87685 +------------------+-----------------+------------------+------------------+
87686 | const_A          | OT_BOOL         | Assume A is      | casadi::Expm     |
87687 |                  |                 | constant.        |                  |
87688 |                  |                 | Default: false.  |                  |
87689 +------------------+-----------------+------------------+------------------+
87690 | custom_jacobian  | OT_FUNCTION     | Override         | casadi::Function |
87691 |                  |                 | CasADi's AD. Use | Internal         |
87692 |                  |                 | together with    |                  |
87693 |                  |                 | 'jac_penalty':   |                  |
87694 |                  |                 | 0. Note: Highly  |                  |
87695 |                  |                 | experimental.    |                  |
87696 |                  |                 | Syntax may break |                  |
87697 |                  |                 | often.           |                  |
87698 +------------------+-----------------+------------------+------------------+
87699 | derivative_of    | OT_FUNCTION     | The function is  | casadi::Function |
87700 |                  |                 | a derivative of  | Internal         |
87701 |                  |                 | another          |                  |
87702 |                  |                 | function. The    |                  |
87703 |                  |                 | type of          |                  |
87704 |                  |                 | derivative       |                  |
87705 |                  |                 | (directional     |                  |
87706 |                  |                 | derivative,      |                  |
87707 |                  |                 | Jacobian) is     |                  |
87708 |                  |                 | inferred from    |                  |
87709 |                  |                 | the function     |                  |
87710 |                  |                 | name.            |                  |
87711 +------------------+-----------------+------------------+------------------+
87712 | dump             | OT_BOOL         | Dump function to | casadi::Function |
87713 |                  |                 | file upon first  | Internal         |
87714 |                  |                 | evaluation.      |                  |
87715 |                  |                 | [false]          |                  |
87716 +------------------+-----------------+------------------+------------------+
87717 | dump_dir         | OT_STRING       | Directory to     | casadi::Function |
87718 |                  |                 | dump             | Internal         |
87719 |                  |                 | inputs/outputs   |                  |
87720 |                  |                 | to. Make sure    |                  |
87721 |                  |                 | the directory    |                  |
87722 |                  |                 | exists [.]       |                  |
87723 +------------------+-----------------+------------------+------------------+
87724 | dump_format      | OT_STRING       | Choose file      | casadi::Function |
87725 |                  |                 | format to dump   | Internal         |
87726 |                  |                 | matrices. See    |                  |
87727 |                  |                 | DM.from_file     |                  |
87728 |                  |                 | [mtx]            |                  |
87729 +------------------+-----------------+------------------+------------------+
87730 | dump_in          | OT_BOOL         | Dump numerical   | casadi::Function |
87731 |                  |                 | values of inputs | Internal         |
87732 |                  |                 | to file          |                  |
87733 |                  |                 | (readable with   |                  |
87734 |                  |                 | DM.from_file )   |                  |
87735 |                  |                 | [default: false] |                  |
87736 +------------------+-----------------+------------------+------------------+
87737 | dump_out         | OT_BOOL         | Dump numerical   | casadi::Function |
87738 |                  |                 | values of        | Internal         |
87739 |                  |                 | outputs to file  |                  |
87740 |                  |                 | (readable with   |                  |
87741 |                  |                 | DM.from_file )   |                  |
87742 |                  |                 | [default: false] |                  |
87743 +------------------+-----------------+------------------+------------------+
87744 | enable_fd        | OT_BOOL         | Enable           | casadi::Function |
87745 |                  |                 | derivative       | Internal         |
87746 |                  |                 | calculation by   |                  |
87747 |                  |                 | finite           |                  |
87748 |                  |                 | differencing.    |                  |
87749 |                  |                 | [default:        |                  |
87750 |                  |                 | false]]          |                  |
87751 +------------------+-----------------+------------------+------------------+
87752 | enable_forward   | OT_BOOL         | Enable           | casadi::Function |
87753 |                  |                 | derivative       | Internal         |
87754 |                  |                 | calculation      |                  |
87755 |                  |                 | using generated  |                  |
87756 |                  |                 | functions for    |                  |
87757 |                  |                 | Jacobian-times-  |                  |
87758 |                  |                 | vector products  |                  |
87759 |                  |                 | - typically      |                  |
87760 |                  |                 | using forward    |                  |
87761 |                  |                 | mode AD - if     |                  |
87762 |                  |                 | available.       |                  |
87763 |                  |                 | [default: true]  |                  |
87764 +------------------+-----------------+------------------+------------------+
87765 | enable_jacobian  | OT_BOOL         | Enable           | casadi::Function |
87766 |                  |                 | derivative       | Internal         |
87767 |                  |                 | calculation      |                  |
87768 |                  |                 | using generated  |                  |
87769 |                  |                 | functions for    |                  |
87770 |                  |                 | Jacobians of all |                  |
87771 |                  |                 | differentiable   |                  |
87772 |                  |                 | outputs with     |                  |
87773 |                  |                 | respect to all   |                  |
87774 |                  |                 | differentiable   |                  |
87775 |                  |                 | inputs - if      |                  |
87776 |                  |                 | available.       |                  |
87777 |                  |                 | [default: true]  |                  |
87778 +------------------+-----------------+------------------+------------------+
87779 | enable_reverse   | OT_BOOL         | Enable           | casadi::Function |
87780 |                  |                 | derivative       | Internal         |
87781 |                  |                 | calculation      |                  |
87782 |                  |                 | using generated  |                  |
87783 |                  |                 | functions for    |                  |
87784 |                  |                 | transposed       |                  |
87785 |                  |                 | Jacobian-times-  |                  |
87786 |                  |                 | vector products  |                  |
87787 |                  |                 | - typically      |                  |
87788 |                  |                 | using reverse    |                  |
87789 |                  |                 | mode AD - if     |                  |
87790 |                  |                 | available.       |                  |
87791 |                  |                 | [default: true]  |                  |
87792 +------------------+-----------------+------------------+------------------+
87793 | fd_method        | OT_STRING       | Method for       | casadi::Function |
87794 |                  |                 | finite           | Internal         |
87795 |                  |                 | differencing     |                  |
87796 |                  |                 | [default         |                  |
87797 |                  |                 | 'central']       |                  |
87798 +------------------+-----------------+------------------+------------------+
87799 | fd_options       | OT_DICT         | Options to be    | casadi::Function |
87800 |                  |                 | passed to the    | Internal         |
87801 |                  |                 | finite           |                  |
87802 |                  |                 | difference       |                  |
87803 |                  |                 | instance         |                  |
87804 +------------------+-----------------+------------------+------------------+
87805 | forward_options  | OT_DICT         | Options to be    | casadi::Function |
87806 |                  |                 | passed to a      | Internal         |
87807 |                  |                 | forward mode     |                  |
87808 |                  |                 | constructor      |                  |
87809 +------------------+-----------------+------------------+------------------+
87810 | gather_stats     | OT_BOOL         | Deprecated       | casadi::Function |
87811 |                  |                 | option           | Internal         |
87812 |                  |                 | (ignored):       |                  |
87813 |                  |                 | Statistics are   |                  |
87814 |                  |                 | now always       |                  |
87815 |                  |                 | collected.       |                  |
87816 +------------------+-----------------+------------------+------------------+
87817 | input_scheme     | OT_STRINGVECTOR | Deprecated       | casadi::Function |
87818 |                  |                 | option (ignored) | Internal         |
87819 +------------------+-----------------+------------------+------------------+
87820 | inputs_check     | OT_BOOL         | Throw exceptions | casadi::Function |
87821 |                  |                 | when the         | Internal         |
87822 |                  |                 | numerical values |                  |
87823 |                  |                 | of the inputs    |                  |
87824 |                  |                 | don't make sense |                  |
87825 +------------------+-----------------+------------------+------------------+
87826 | is_diff_in       | OT_BOOLVECTOR   | Indicate for     | casadi::Function |
87827 |                  |                 | each input if it | Internal         |
87828 |                  |                 | should be        |                  |
87829 |                  |                 | differentiable.  |                  |
87830 +------------------+-----------------+------------------+------------------+
87831 | is_diff_out      | OT_BOOLVECTOR   | Indicate for     | casadi::Function |
87832 |                  |                 | each output if   | Internal         |
87833 |                  |                 | it should be     |                  |
87834 |                  |                 | differentiable.  |                  |
87835 +------------------+-----------------+------------------+------------------+
87836 | jac_penalty      | OT_DOUBLE       | When requested   | casadi::Function |
87837 |                  |                 | for a number of  | Internal         |
87838 |                  |                 | forward/reverse  |                  |
87839 |                  |                 | directions, it   |                  |
87840 |                  |                 | may be cheaper   |                  |
87841 |                  |                 | to compute first |                  |
87842 |                  |                 | the full         |                  |
87843 |                  |                 | jacobian and     |                  |
87844 |                  |                 | then multiply    |                  |
87845 |                  |                 | with seeds,      |                  |
87846 |                  |                 | rather than      |                  |
87847 |                  |                 | obtain the       |                  |
87848 |                  |                 | requested        |                  |
87849 |                  |                 | directions in a  |                  |
87850 |                  |                 | straightforward  |                  |
87851 |                  |                 | manner. Casadi   |                  |
87852 |                  |                 | uses a heuristic |                  |
87853 |                  |                 | to decide which  |                  |
87854 |                  |                 | is cheaper. A    |                  |
87855 |                  |                 | high value of    |                  |
87856 |                  |                 | 'jac_penalty'    |                  |
87857 |                  |                 | makes it less    |                  |
87858 |                  |                 | likely for the   |                  |
87859 |                  |                 | heurstic to      |                  |
87860 |                  |                 | chose the full   |                  |
87861 |                  |                 | Jacobian         |                  |
87862 |                  |                 | strategy. The    |                  |
87863 |                  |                 | special value -1 |                  |
87864 |                  |                 | indicates never  |                  |
87865 |                  |                 | to use the full  |                  |
87866 |                  |                 | Jacobian         |                  |
87867 |                  |                 | strategy         |                  |
87868 +------------------+-----------------+------------------+------------------+
87869 | jit              | OT_BOOL         | Use just-in-time | casadi::Function |
87870 |                  |                 | compiler to      | Internal         |
87871 |                  |                 | speed up the     |                  |
87872 |                  |                 | evaluation       |                  |
87873 +------------------+-----------------+------------------+------------------+
87874 | jit_cleanup      | OT_BOOL         | Cleanup up the   | casadi::Function |
87875 |                  |                 | temporary source | Internal         |
87876 |                  |                 | file that jit    |                  |
87877 |                  |                 | creates.         |                  |
87878 |                  |                 | Default: true    |                  |
87879 +------------------+-----------------+------------------+------------------+
87880 | jit_name         | OT_STRING       | The file name    | casadi::Function |
87881 |                  |                 | used to write    | Internal         |
87882 |                  |                 | out code. The    |                  |
87883 |                  |                 | actual file      |                  |
87884 |                  |                 | names used       |                  |
87885 |                  |                 | depend on 'jit_t |                  |
87886 |                  |                 | emp_suffix' and  |                  |
87887 |                  |                 | include          |                  |
87888 |                  |                 | extensions.      |                  |
87889 |                  |                 | Default:         |                  |
87890 |                  |                 | 'jit_tmp'        |                  |
87891 +------------------+-----------------+------------------+------------------+
87892 | jit_options      | OT_DICT         | Options to be    | casadi::Function |
87893 |                  |                 | passed to the    | Internal         |
87894 |                  |                 | jit compiler.    |                  |
87895 +------------------+-----------------+------------------+------------------+
87896 | jit_serialize    | OT_STRING       | Specify          | casadi::Function |
87897 |                  |                 | behaviour when   | Internal         |
87898 |                  |                 | serializing a    |                  |
87899 |                  |                 | jitted function: |                  |
87900 |                  |                 | SOURCE|link|embe |                  |
87901 |                  |                 | d.               |                  |
87902 +------------------+-----------------+------------------+------------------+
87903 | jit_temp_suffix  | OT_BOOL         | Use a temporary  | casadi::Function |
87904 |                  |                 | (seemingly       | Internal         |
87905 |                  |                 | random) filename |                  |
87906 |                  |                 | suffix for       |                  |
87907 |                  |                 | generated code   |                  |
87908 |                  |                 | and libraries.   |                  |
87909 |                  |                 | This is desired  |                  |
87910 |                  |                 | for thread-      |                  |
87911 |                  |                 | safety. This     |                  |
87912 |                  |                 | behaviour may    |                  |
87913 |                  |                 | defeat caching   |                  |
87914 |                  |                 | compiler         |                  |
87915 |                  |                 | wrappers.        |                  |
87916 |                  |                 | Default: true    |                  |
87917 +------------------+-----------------+------------------+------------------+
87918 | max_num_dir      | OT_INT          | Specify the      | casadi::Function |
87919 |                  |                 | maximum number   | Internal         |
87920 |                  |                 | of directions    |                  |
87921 |                  |                 | for derivative   |                  |
87922 |                  |                 | functions.       |                  |
87923 |                  |                 | Overrules the    |                  |
87924 |                  |                 | builtin optimize |                  |
87925 |                  |                 | d_num_dir.       |                  |
87926 +------------------+-----------------+------------------+------------------+
87927 | never_inline     | OT_BOOL         | Forbid inlining. | casadi::Function |
87928 |                  |                 |                  | Internal         |
87929 +------------------+-----------------+------------------+------------------+
87930 | output_scheme    | OT_STRINGVECTOR | Deprecated       | casadi::Function |
87931 |                  |                 | option (ignored) | Internal         |
87932 +------------------+-----------------+------------------+------------------+
87933 | print_in         | OT_BOOL         | Print numerical  | casadi::Function |
87934 |                  |                 | values of inputs | Internal         |
87935 |                  |                 | [default: false] |                  |
87936 +------------------+-----------------+------------------+------------------+
87937 | print_out        | OT_BOOL         | Print numerical  | casadi::Function |
87938 |                  |                 | values of        | Internal         |
87939 |                  |                 | outputs          |                  |
87940 |                  |                 | [default: false] |                  |
87941 +------------------+-----------------+------------------+------------------+
87942 | print_time       | OT_BOOL         | print            | casadi::Function |
87943 |                  |                 | information      | Internal         |
87944 |                  |                 | about execution  |                  |
87945 |                  |                 | time. Implies    |                  |
87946 |                  |                 | record_time.     |                  |
87947 +------------------+-----------------+------------------+------------------+
87948 | record_time      | OT_BOOL         | record           | casadi::Function |
87949 |                  |                 | information      | Internal         |
87950 |                  |                 | about execution  |                  |
87951 |                  |                 | time, for        |                  |
87952 |                  |                 | retrieval with   |                  |
87953 |                  |                 | stats().         |                  |
87954 +------------------+-----------------+------------------+------------------+
87955 | regularity_check | OT_BOOL         | Throw exceptions | casadi::Function |
87956 |                  |                 | when NaN or Inf  | Internal         |
87957 |                  |                 | appears during   |                  |
87958 |                  |                 | evaluation       |                  |
87959 +------------------+-----------------+------------------+------------------+
87960 | reverse_options  | OT_DICT         | Options to be    | casadi::Function |
87961 |                  |                 | passed to a      | Internal         |
87962 |                  |                 | reverse mode     |                  |
87963 |                  |                 | constructor      |                  |
87964 +------------------+-----------------+------------------+------------------+
87965 | user_data        | OT_VOIDPTR      | A user-defined   | casadi::Function |
87966 |                  |                 | field that can   | Internal         |
87967 |                  |                 | be used to       |                  |
87968 |                  |                 | identify the     |                  |
87969 |                  |                 | function or pass |                  |
87970 |                  |                 | additional       |                  |
87971 |                  |                 | information      |                  |
87972 +------------------+-----------------+------------------+------------------+
87973 | verbose          | OT_BOOL         | Verbose          | casadi::Function |
87974 |                  |                 | evaluation  for  | Internal         |
87975 |                  |                 | debugging        |                  |
87976 +------------------+-----------------+------------------+------------------+
87977 
87978 List of plugins
87979 ===============
87980 
87981 
87982 
87983 - slicot
87984 
87985 Note: some of the plugins in this list might not be available on your
87986 system. Also, there might be extra plugins available to you that are not
87987 listed here. You can obtain their documentation with
87988 Expm.doc(\"myextraplugin\")
87989 
87990 
87991 
87992 --------------------------------------------------------------------------------
87993 
87994 slicot
87995 ------
87996 
87997 
87998 
87999 
88000 
88001 --------------------------------------------------------------------------------
88002 
88003 
88004 
88005 Joris Gillis
88006 
88007 ";
88008 
88009 %feature("docstring")  casadi::casadi_qp_du(casadi_qp_data< T1 > *d) "
88010 
88011 [INTERNAL] ";
88012 
88013 %feature("docstring")  casadi::casadi_mtimes(const T1 *x, const casadi_int
88014 *sp_x, const T1 *y, const casadi_int *sp_y, T1 *z, const casadi_int *sp_z,
88015 T1 *w, casadi_int tr) "
88016 
88017 [INTERNAL]  Sparse matrix-matrix multiplication: z <- z + x*y.
88018 
88019 ";
88020 
88021 %feature("docstring")  casadi::casadi_interpn_weights(casadi_int ndim, const
88022 T1 *grid, const casadi_int *offset, const T1 *x, T1 *alpha, casadi_int
88023 *index) "
88024 
88025 [INTERNAL] ";
88026 
88027 %feature("docstring")  casadi::casadi_interpn_weights(casadi_int ndim, const
88028 T1 *grid, const casadi_int *offset, const T1 *x, T1 *alpha, casadi_int
88029 *index, const casadi_int *lookup_mode) "
88030 
88031 [INTERNAL] ";
88032 
88033 %feature("docstring")  casadi::integrator_n_out() "
88034 
88035 Get the number of integrator outputs.
88036 
88037 ";
88038 
88039 %feature("docstring")  casadi::casadi_mmax(const T1 *x, casadi_int n, T1
88040 is_dense) "
88041 
88042 [INTERNAL] ";
88043 
88044 %feature("docstring")  casadi::casadi_mmax(const T1 *x, casadi_int n,
88045 casadi_int is_dense) "
88046 
88047 [INTERNAL] ";
88048 
88049 %feature("docstring")  casadi::slicot_periodic_schur(casadi_int n,
88050 casadi_int K, const double *a, double *t, double *z, double *dwork, double
88051 *eig_real, double *eig_imag, double num_zero=0) "
88052 
88053 [INTERNAL] ";
88054 
88055 %feature("docstring")  casadi::casadi_qp_prepare(casadi_qp_data< T1 > *d) "
88056 
88057 [INTERNAL] ";
88058 
88059 %feature("docstring")  casadi::casadi_cvx_scalar(T1 epsilon, casadi_int
88060 reflect, T1 eig) "
88061 
88062 [INTERNAL] ";
88063 
88064 %feature("docstring")  casadi::external(const std::string &name, const Dict
88065 &opts=Dict()) "
88066 
88067 Load an external function from a shared library.
88068 
88069 Parameters:
88070 -----------
88071 
88072 name:  Name as in the label assigned to a CasADi Function object:
88073 Function(name,...,...) Will be used to look up symbols/functions named eg.
88074 <name>_eval Use nm (linux/osx) or depends.exe (win) to check which symbols
88075 are present in your shared library
88076 
88077 File name is assumed to be ./<name>.so
88078 
88079 ";
88080 
88081 %feature("docstring")  casadi::external(const std::string &name, const
88082 std::string &bin_name, const Dict &opts=Dict()) "
88083 
88084 Load an external function from a shared library.
88085 
88086 Parameters:
88087 -----------
88088 
88089 name:  Name as in the label assigned to a CasADi Function object:
88090 Function(name,...,...) Will be used to look up symbols/functions named eg.
88091 <name>_eval Use nm (linux/osx) or depends.exe (win) to check which symbols
88092 are present in your shared library
88093 
88094 bin_name:  File name of the shared library
88095 
88096 ";
88097 
88098 %feature("docstring")  casadi::external(const std::string &name, const
88099 Importer &li, const Dict &opts=Dict()) "
88100 
88101 Load a just-in-time compiled external function File name given.
88102 
88103 ";
88104 
88105 %feature("docstring")  casadi::nlpsol_n_out() "
88106 
88107 Number of NLP solver outputs.
88108 
88109 ";
88110 
88111 %feature("docstring")  casadi::casadi_bfgs_reset(const casadi_int *sp_h, T1
88112 *h) "
88113 
88114 [INTERNAL] ";
88115 
88116 %feature("docstring")  casadi::casadi_qp_print_colcomb(casadi_qp_data< T1 >
88117 *d, char *buf, size_t buf_sz, casadi_int j) "
88118 
88119 [INTERNAL] ";
88120 
88121 %feature("docstring")  casadi::collocation_coeff(const std::vector< double >
88122 &tau, DM &output_C, DM &output_D, DM &output_B) "
88123 
88124 Obtain collocation interpolating matrices.
88125 
88126 A collocation method poses a polynomial Pi that interpolates exactly through
88127 an initial state (0,X_0) and helper states at collocation points
88128 (tau_j,Xc_j) with j=1..degree.
88129 
88130 This function computes the linear mapping between dPi/dt and coefficients
88131 Z=[X_0 Xc].
88132 
88133 Parameters:
88134 -----------
88135 
88136 tau:  location of collocation points (length: degree), as obtained from
88137 collocation_points
88138 
88139 C:  interpolating coefficients to obtain derivatives. Size: (degree+1)-by-
88140 degree
88141 
88142 You may find the slopes of Pi at the collocation points as
88143 
88144 ::
88145 
88146 dPi/dt @ Xc = (1/h) Z*C,
88147 
88148 
88149 
88150 with h the length of the integration interval.
88151 
88152 Parameters:
88153 -----------
88154 
88155 D:  interpolating coefficients to obtain end state. Size: (degree+1)-by-1
88156 
88157 You may find the end point of Pi as
88158 
88159 ::
88160 
88161 Pi @X_f = Z*D
88162 
88163 
88164 
88165 Parameters:
88166 -----------
88167 
88168 B:  quadrature coefficients Size: degree-by-1
88169 
88170 Given quadrature righ-hand-sides 'quad' evaluated at the collocation points,
88171 you may find the integrated quadratures as
88172 
88173 ::
88174 
88175 q = quad*B*h
88176 
88177 
88178 
88179 ";
88180 
88181 %feature("docstring")  casadi::to_slice2(const std::vector< casadi_int > &v)
88182 "
88183 
88184 Construct nested slices from an index vector (requires is_slice2(v) to be
88185 true)
88186 
88187 ";
88188 
88189 %feature("docstring")  casadi::in_range(const std::vector< T > &v,
88190 casadi_int upper) "
88191 
88192 Check if for each element of v holds: v_i < upper.
88193 
88194 ";
88195 
88196 %feature("docstring")  casadi::in_range(const std::vector< T > &v,
88197 casadi_int lower, casadi_int upper) "
88198 
88199 Check if for each element of v holds: lower <= v_i < upper.
88200 
88201 ";
88202 
88203 %feature("docstring")  casadi::casadi_qp_du_index(casadi_qp_data< T1 > *d) "
88204 
88205 [INTERNAL] ";
88206 
88207 %feature("docstring")  casadi::load_integrator(const std::string &name) "
88208 
88209 Explicitly load a plugin dynamically.
88210 
88211 ";
88212 
88213 %feature("docstring")  casadi::casadi_qp_dual_blocking(casadi_qp_data< T1 >
88214 *d) "
88215 
88216 [INTERNAL] ";
88217 
88218 %feature("docstring")  casadi::casadi_qp_work(const casadi_qp_prob< T1 > *p,
88219 casadi_int *sz_iw, casadi_int *sz_w) "
88220 
88221 [INTERNAL] ";
88222 
88223 %feature("docstring")  casadi::expm_n_out() "
88224 
88225 Get the number of expm solver outputs.
88226 
88227 ";
88228 
88229 %feature("docstring")  casadi::casadi_sum_viol(casadi_int n, const T1 *x,
88230 const T1 *lb, const T1 *ub) "
88231 
88232 [INTERNAL]  Sum of bound violations.
88233 
88234 ";
88235 
88236 %feature("docstring")  casadi::load_nlpsol(const std::string &name) "
88237 
88238 Explicitly load a plugin dynamically.
88239 
88240 ";
88241 
88242 %feature("docstring")  casadi::is_increasing(const std::vector< T > &v) "
88243 
88244 Check if the vector is strictly increasing.
88245 
88246 ";
88247 
88248 %feature("docstring")  casadi::casadi_scal(casadi_int n, T1 alpha, T1 *x) "
88249 
88250 [INTERNAL]  SCAL: x <- alpha*x.
88251 
88252 ";
88253 
88254 %feature("docstring")  casadi::casadi_lsqr_solve(const T1 *A, T1 *x,
88255 casadi_int nrhs, casadi_int tr, const casadi_int *sp, T1 *w) "
88256 
88257 [INTERNAL] ";
88258 
88259 %feature("docstring")  casadi::check_sos(casadi_int nx, const std::vector<
88260 std::vector< T > > &groups, std::vector< std::vector< double > > &weights,
88261 std::vector< casadi_int > &types) "
88262 
88263 Check sos structure and generate defaults.
88264 
88265 ";
88266 
88267 %feature("docstring")  casadi::casadi_fill_casadi_int(casadi_int *x,
88268 casadi_int n, casadi_int alpha) "
88269 
88270 [INTERNAL] ";
88271 
88272 %feature("docstring")  casadi::casadi_cvx(casadi_int n, T1 *A, T1 epsilon,
88273 T1 tol, casadi_int reflect, casadi_int max_iter, T1 *w, casadi_int *iw) "
88274 
88275 [INTERNAL] ";
88276 
88277 %feature("docstring")  casadi::dense_copy_stride(casadi_int n, casadi_int m,
88278 const double *A, double *B, casadi_int strideA, casadi_int strideB) "
88279 
88280 [INTERNAL] ";
88281 
88282 %feature("docstring")  casadi::casadi_qp_iterate(casadi_qp_data< T1 > *d) "
88283 
88284 [INTERNAL] ";
88285 
88286 %feature("docstring")  casadi::casadi_qr_singular(T1 *rmin, casadi_int
88287 *irmin, const T1 *nz_r, const casadi_int *sp_r, const casadi_int *pc, T1
88288 eps) "
88289 
88290 [INTERNAL] ";
88291 
88292 %feature("docstring")  casadi::conic_options(const std::string &name) "
88293 
88294 Get all options for a plugin.
88295 
88296 ";
88297 
88298 %feature("docstring")  casadi::load_linsol(const std::string &name) "
88299 
88300 Explicitly load a plugin dynamically.
88301 
88302 ";
88303 
88304 %feature("docstring")  casadi::casadi_interpn_grad(T1 *grad, casadi_int
88305 ndim, const T1 *grid, const casadi_int *offset, const T1 *values, const T1
88306 *x, casadi_int *iw, T1 *w) "
88307 
88308 [INTERNAL] ";
88309 
88310 %feature("docstring")  casadi::casadi_interpn_grad(T1 *grad, casadi_int
88311 ndim, const T1 *grid, const casadi_int *offset, const T1 *values, const T1
88312 *x, const casadi_int *lookup_mode, casadi_int m, casadi_int *iw, T1 *w) "
88313 
88314 [INTERNAL] ";
88315 
88316 %feature("docstring")  casadi::casadi_qp_calc_step(casadi_qp_data< T1 > *d)
88317 "
88318 
88319 [INTERNAL] ";
88320 
88321 %feature("docstring")  casadi::has_interpolant(const std::string &name) "
88322 
88323 Check if a particular plugin is available.
88324 
88325 ";
88326 
88327 %feature("docstring")  casadi::conic_debug(const Function &f, const
88328 std::string &filename) "
88329 
88330 Generate native code in the interfaced language for debugging
88331 
88332 ";
88333 
88334 %feature("docstring")  casadi::conic_debug(const Function &f, std::ostream
88335 &file) "
88336 
88337 Generate native code in the interfaced language for debugging
88338 
88339 ";
88340 
88341 %feature("docstring")  casadi::casadi_swap(casadi_int n, T1 *x, casadi_int
88342 inc_x, T1 *y, casadi_int inc_y) "
88343 
88344 [INTERNAL]  SWAP: x <-> y.
88345 
88346 ";
88347 
88348 %feature("docstring")  casadi::casadi_qp_flip_check(casadi_qp_data< T1 > *d)
88349 "
88350 
88351 [INTERNAL] ";
88352 
88353 %feature("docstring")  casadi::integrator(const std::string &name, const
88354 std::string &solver, const SXDict &dae, const Dict &opts=Dict()) "
88355 
88356 Create an ODE/DAE integrator Solves an initial value problem (IVP) coupled
88357 to a terminal value problem with differential equation given as an implicit
88358 ODE coupled to an algebraic equation and a set of quadratures:
88359 
88360 
88361 
88362 ::
88363 
88364   Initial conditions at t=t0
88365   x(t0)  = x0
88366   q(t0)  = 0
88367 
88368   Forward integration from t=t0 to t=tf
88369   der(x) = function(x, z, p, t)                  Forward ODE
88370   0 = fz(x, z, p, t)                  Forward algebraic equations
88371   der(q) = fq(x, z, p, t)                  Forward quadratures
88372 
88373   Terminal conditions at t=tf
88374   rx(tf)  = rx0
88375   rq(tf)  = 0
88376 
88377   Backward integration from t=tf to t=t0
88378   der(rx) = gx(rx, rz, rp, x, z, p, t)        Backward ODE
88379   0 = gz(rx, rz, rp, x, z, p, t)        Backward algebraic equations
88380   der(rq) = gq(rx, rz, rp, x, z, p, t)        Backward quadratures
88381 
88382   where we assume that both the forward and backwards integrations are index-1
88383   (i.e. dfz/dz, dgz/drz are invertible) and furthermore that
88384   gx, gz and gq have a linear dependency on rx, rz and rp.
88385 
88386 
88387 
88388 General information
88389 ===================
88390 
88391 
88392 
88393 >List of available options
88394 
88395 +------------------+-----------------+------------------+------------------+
88396 |        Id        |      Type       |   Description    |     Used in      |
88397 +==================+=================+==================+==================+
88398 | augmented_option | OT_DICT         | Options to be    | casadi::Integrat |
88399 | s                |                 | passed down to   | or               |
88400 |                  |                 | the augmented    |                  |
88401 |                  |                 | integrator, if   |                  |
88402 |                  |                 | one is           |                  |
88403 |                  |                 | constructed.     |                  |
88404 +------------------+-----------------+------------------+------------------+
88405 | common_options   | OT_DICT         | Options for      | casadi::OracleFu |
88406 |                  |                 | auto-generated   | nction           |
88407 |                  |                 | functions        |                  |
88408 +------------------+-----------------+------------------+------------------+
88409 | expand           | OT_BOOL         | Replace MX with  | casadi::Integrat |
88410 |                  |                 | SX expressions   | or               |
88411 |                  |                 | in problem       |                  |
88412 |                  |                 | formulation      |                  |
88413 |                  |                 | [false]          |                  |
88414 +------------------+-----------------+------------------+------------------+
88415 | grid             | OT_DOUBLEVECTOR | Time grid        | casadi::Integrat |
88416 |                  |                 |                  | or               |
88417 +------------------+-----------------+------------------+------------------+
88418 | monitor          | OT_STRINGVECTOR | Set of user      | casadi::OracleFu |
88419 |                  |                 | problem          | nction           |
88420 |                  |                 | functions to be  |                  |
88421 |                  |                 | monitored        |                  |
88422 +------------------+-----------------+------------------+------------------+
88423 | number_of_finite | OT_INT          | Number of finite | casadi::Integrat |
88424 | _elements        |                 | elements         | or               |
88425 +------------------+-----------------+------------------+------------------+
88426 | output_t0        | OT_BOOL         | Output the state | casadi::Integrat |
88427 |                  |                 | at the initial   | or               |
88428 |                  |                 | time             |                  |
88429 +------------------+-----------------+------------------+------------------+
88430 | print_stats      | OT_BOOL         | Print out        | casadi::Integrat |
88431 |                  |                 | statistics after | or               |
88432 |                  |                 | integration      |                  |
88433 +------------------+-----------------+------------------+------------------+
88434 | rootfinder       | OT_STRING       | An implicit      | casadi::Integrat |
88435 |                  |                 | function solver  | or               |
88436 +------------------+-----------------+------------------+------------------+
88437 | rootfinder_optio | OT_DICT         | Options to be    | casadi::Integrat |
88438 | ns               |                 | passed to the    | or               |
88439 |                  |                 | NLP Solver       |                  |
88440 +------------------+-----------------+------------------+------------------+
88441 | show_eval_warnin | OT_BOOL         | Show warnings    | casadi::OracleFu |
88442 | gs               |                 | generated from   | nction           |
88443 |                  |                 | function         |                  |
88444 |                  |                 | evaluations      |                  |
88445 |                  |                 | [true]           |                  |
88446 +------------------+-----------------+------------------+------------------+
88447 | simplify         | OT_BOOL         | Implement as MX  | casadi::Integrat |
88448 |                  |                 | Function (codege | or               |
88449 |                  |                 | neratable/serial |                  |
88450 |                  |                 | izable) default: |                  |
88451 |                  |                 | false            |                  |
88452 +------------------+-----------------+------------------+------------------+
88453 | simplify_options | OT_DICT         | Any options to   | casadi::Integrat |
88454 |                  |                 | pass to          | or               |
88455 |                  |                 | simplified form  |                  |
88456 |                  |                 | Function         |                  |
88457 |                  |                 | constructor      |                  |
88458 +------------------+-----------------+------------------+------------------+
88459 | specific_options | OT_DICT         | Options for      | casadi::OracleFu |
88460 |                  |                 | specific auto-   | nction           |
88461 |                  |                 | generated        |                  |
88462 |                  |                 | functions,       |                  |
88463 |                  |                 | overwriting the  |                  |
88464 |                  |                 | defaults from    |                  |
88465 |                  |                 | common_options.  |                  |
88466 |                  |                 | Nested           |                  |
88467 |                  |                 | dictionary.      |                  |
88468 +------------------+-----------------+------------------+------------------+
88469 | t0               | OT_DOUBLE       | Beginning of the | casadi::Integrat |
88470 |                  |                 | time horizon     | or               |
88471 +------------------+-----------------+------------------+------------------+
88472 | tf               | OT_DOUBLE       | End of the time  | casadi::Integrat |
88473 |                  |                 | horizon          | or               |
88474 +------------------+-----------------+------------------+------------------+
88475 
88476 >Input scheme: casadi::IntegratorInput (INTEGRATOR_NUM_IN = 6)
88477 
88478 +----------------+-------+-------------------------------------------------+
88479 |   Full name    | Short |                   Description                   |
88480 +================+=======+=================================================+
88481 | INTEGRATOR_X0  | x0    | Differential state at the initial time.         |
88482 +----------------+-------+-------------------------------------------------+
88483 | INTEGRATOR_P   | p     | Parameters.                                     |
88484 +----------------+-------+-------------------------------------------------+
88485 | INTEGRATOR_Z0  | z0    | Initial guess for the algebraic variable.       |
88486 +----------------+-------+-------------------------------------------------+
88487 | INTEGRATOR_RX0 | rx0   | Backward differential state at the final time.  |
88488 +----------------+-------+-------------------------------------------------+
88489 | INTEGRATOR_RP  | rp    | Backward parameter vector.                      |
88490 +----------------+-------+-------------------------------------------------+
88491 | INTEGRATOR_RZ0 | rz0   | Initial guess for the backwards algebraic       |
88492 |                |       | variable.                                       |
88493 +----------------+-------+-------------------------------------------------+
88494 
88495 >Output scheme: casadi::IntegratorOutput (INTEGRATOR_NUM_OUT = 6)
88496 
88497 +----------------+-------+-------------------------------------------------+
88498 |   Full name    | Short |                   Description                   |
88499 +================+=======+=================================================+
88500 | INTEGRATOR_XF  | xf    | Differential state at the final time.           |
88501 +----------------+-------+-------------------------------------------------+
88502 | INTEGRATOR_QF  | qf    | Quadrature state at the final time.             |
88503 +----------------+-------+-------------------------------------------------+
88504 | INTEGRATOR_ZF  | zf    | Algebraic variable at the final time.           |
88505 +----------------+-------+-------------------------------------------------+
88506 | INTEGRATOR_RXF | rxf   | Backward differential state at the initial      |
88507 |                |       | time.                                           |
88508 +----------------+-------+-------------------------------------------------+
88509 | INTEGRATOR_RQF | rqf   | Backward quadrature state at the initial time.  |
88510 +----------------+-------+-------------------------------------------------+
88511 | INTEGRATOR_RZF | rzf   | Backward algebraic variable at the initial      |
88512 |                |       | time.                                           |
88513 +----------------+-------+-------------------------------------------------+
88514 
88515 List of plugins
88516 ===============
88517 
88518 
88519 
88520 - cvodes
88521 
88522 - idas
88523 
88524 - collocation
88525 
88526 - rk
88527 
88528 Note: some of the plugins in this list might not be available on your
88529 system. Also, there might be extra plugins available to you that are not
88530 listed here. You can obtain their documentation with
88531 Integrator.doc(\"myextraplugin\")
88532 
88533 
88534 
88535 --------------------------------------------------------------------------------
88536 
88537 cvodes
88538 ------
88539 
88540 
88541 
88542 Interface to CVodes from the Sundials suite.
88543 
88544 A call to evaluate will integrate to the end.
88545 
88546 You can retrieve the entire state trajectory as follows, after the evaluate
88547 call: Call reset. Then call integrate(t_i) and getOuput for a series of
88548 times t_i.
88549 
88550 >List of available options
88551 
88552 +----------------------------+-----------+---------------------------------+
88553 |             Id             |   Type    |           Description           |
88554 +============================+===========+=================================+
88555 | abstol                     | OT_DOUBLE | Absolute tolerence for the IVP  |
88556 |                            |           | solution                        |
88557 +----------------------------+-----------+---------------------------------+
88558 | disable_internal_warnings  | OT_BOOL   | Disable SUNDIALS internal       |
88559 |                            |           | warning messages                |
88560 +----------------------------+-----------+---------------------------------+
88561 | fsens_all_at_once          | OT_BOOL   | Calculate all right hand sides  |
88562 |                            |           | of the sensitivity equations at |
88563 |                            |           | once                            |
88564 +----------------------------+-----------+---------------------------------+
88565 | fsens_err_con              | OT_BOOL   | include the forward             |
88566 |                            |           | sensitivities in all error      |
88567 |                            |           | controls                        |
88568 +----------------------------+-----------+---------------------------------+
88569 | interpolation_type         | OT_STRING | Type of interpolation for the   |
88570 |                            |           | adjoint sensitivities           |
88571 +----------------------------+-----------+---------------------------------+
88572 | linear_multistep_method    | OT_STRING | Integrator scheme: BDF|adams    |
88573 +----------------------------+-----------+---------------------------------+
88574 | linear_solver              | OT_STRING | A custom linear solver creator  |
88575 |                            |           | function [default: qr]          |
88576 +----------------------------+-----------+---------------------------------+
88577 | linear_solver_options      | OT_DICT   | Options to be passed to the     |
88578 |                            |           | linear solver                   |
88579 +----------------------------+-----------+---------------------------------+
88580 | max_krylov                 | OT_INT    | Maximum Krylov subspace size    |
88581 +----------------------------+-----------+---------------------------------+
88582 | max_multistep_order        | OT_INT    | Maximum order for the           |
88583 |                            |           | (variable-order) multistep      |
88584 |                            |           | method                          |
88585 +----------------------------+-----------+---------------------------------+
88586 | max_num_steps              | OT_INT    | Maximum number of integrator    |
88587 |                            |           | steps                           |
88588 +----------------------------+-----------+---------------------------------+
88589 | max_order                  | OT_DOUBLE | Maximum order                   |
88590 +----------------------------+-----------+---------------------------------+
88591 | max_step_size              | OT_DOUBLE | Max step size [default: 0/inf]  |
88592 +----------------------------+-----------+---------------------------------+
88593 | min_step_size              | OT_DOUBLE | Min step size [default: 0/0.0]  |
88594 +----------------------------+-----------+---------------------------------+
88595 | newton_scheme              | OT_STRING | Linear solver scheme in the     |
88596 |                            |           | Newton method:                  |
88597 |                            |           | DIRECT|gmres|bcgstab|tfqmr      |
88598 +----------------------------+-----------+---------------------------------+
88599 | nonlin_conv_coeff          | OT_DOUBLE | Coefficient in the nonlinear    |
88600 |                            |           | convergence test                |
88601 +----------------------------+-----------+---------------------------------+
88602 | nonlinear_solver_iteration | OT_STRING | Nonlinear solver type:          |
88603 |                            |           | NEWTON|functional               |
88604 +----------------------------+-----------+---------------------------------+
88605 | quad_err_con               | OT_BOOL   | Should the quadratures affect   |
88606 |                            |           | the step size control           |
88607 +----------------------------+-----------+---------------------------------+
88608 | reltol                     | OT_DOUBLE | Relative tolerence for the IVP  |
88609 |                            |           | solution                        |
88610 +----------------------------+-----------+---------------------------------+
88611 | second_order_correction    | OT_BOOL   | Second order correction in the  |
88612 |                            |           | augmented system Jacobian       |
88613 |                            |           | [true]                          |
88614 +----------------------------+-----------+---------------------------------+
88615 | sensitivity_method         | OT_STRING | Sensitivity method:             |
88616 |                            |           | SIMULTANEOUS|staggered          |
88617 +----------------------------+-----------+---------------------------------+
88618 | step0                      | OT_DOUBLE | initial step size [default:     |
88619 |                            |           | 0/estimated]                    |
88620 +----------------------------+-----------+---------------------------------+
88621 | steps_per_checkpoint       | OT_INT    | Number of steps between two     |
88622 |                            |           | consecutive checkpoints         |
88623 +----------------------------+-----------+---------------------------------+
88624 | stop_at_end                | OT_BOOL   | Stop the integrator at the end  |
88625 |                            |           | of the interval                 |
88626 +----------------------------+-----------+---------------------------------+
88627 | use_preconditioner         | OT_BOOL   | Precondition the iterative      |
88628 |                            |           | solver [default: true]          |
88629 +----------------------------+-----------+---------------------------------+
88630 
88631 --------------------------------------------------------------------------------
88632 
88633 
88634 
88635 --------------------------------------------------------------------------------
88636 
88637 idas
88638 ----
88639 
88640 
88641 
88642 Interface to IDAS from the Sundials suite.
88643 
88644 >List of available options
88645 
88646 +---------------------------+-----------------+----------------------------+
88647 |            Id             |      Type       |        Description         |
88648 +===========================+=================+============================+
88649 | abstol                    | OT_DOUBLE       | Absolute tolerence for the |
88650 |                           |                 | IVP solution               |
88651 +---------------------------+-----------------+----------------------------+
88652 | abstolv                   | OT_DOUBLEVECTOR | Absolute tolerarance for   |
88653 |                           |                 | each component             |
88654 +---------------------------+-----------------+----------------------------+
88655 | calc_ic                   | OT_BOOL         | Use IDACalcIC to get       |
88656 |                           |                 | consistent initial         |
88657 |                           |                 | conditions.                |
88658 +---------------------------+-----------------+----------------------------+
88659 | calc_icB                  | OT_BOOL         | Use IDACalcIC to get       |
88660 |                           |                 | consistent initial         |
88661 |                           |                 | conditions for backwards   |
88662 |                           |                 | system [default: equal to  |
88663 |                           |                 | calc_ic].                  |
88664 +---------------------------+-----------------+----------------------------+
88665 | cj_scaling                | OT_BOOL         | IDAS scaling on cj for the |
88666 |                           |                 | user-defined linear solver |
88667 |                           |                 | module                     |
88668 +---------------------------+-----------------+----------------------------+
88669 | constraints               | OT_INTVECTOR    | Constrain the solution     |
88670 |                           |                 | y=[x,z]. 0 (default): no   |
88671 |                           |                 | constraint on yi, 1: yi >= |
88672 |                           |                 | 0.0, -1: yi <= 0.0, 2: yi  |
88673 |                           |                 | > 0.0, -2: yi < 0.0.       |
88674 +---------------------------+-----------------+----------------------------+
88675 | disable_internal_warnings | OT_BOOL         | Disable SUNDIALS internal  |
88676 |                           |                 | warning messages           |
88677 +---------------------------+-----------------+----------------------------+
88678 | first_time                | OT_DOUBLE       | First requested time as a  |
88679 |                           |                 | fraction of the time       |
88680 |                           |                 | interval                   |
88681 +---------------------------+-----------------+----------------------------+
88682 | fsens_err_con             | OT_BOOL         | include the forward        |
88683 |                           |                 | sensitivities in all error |
88684 |                           |                 | controls                   |
88685 +---------------------------+-----------------+----------------------------+
88686 | init_xdot                 | OT_DOUBLEVECTOR | Initial values for the     |
88687 |                           |                 | state derivatives          |
88688 +---------------------------+-----------------+----------------------------+
88689 | interpolation_type        | OT_STRING       | Type of interpolation for  |
88690 |                           |                 | the adjoint sensitivities  |
88691 +---------------------------+-----------------+----------------------------+
88692 | linear_solver             | OT_STRING       | A custom linear solver     |
88693 |                           |                 | creator function [default: |
88694 |                           |                 | qr]                        |
88695 +---------------------------+-----------------+----------------------------+
88696 | linear_solver_options     | OT_DICT         | Options to be passed to    |
88697 |                           |                 | the linear solver          |
88698 +---------------------------+-----------------+----------------------------+
88699 | max_krylov                | OT_INT          | Maximum Krylov subspace    |
88700 |                           |                 | size                       |
88701 +---------------------------+-----------------+----------------------------+
88702 | max_multistep_order       | OT_INT          | Maximum order for the      |
88703 |                           |                 | (variable-order) multistep |
88704 |                           |                 | method                     |
88705 +---------------------------+-----------------+----------------------------+
88706 | max_num_steps             | OT_INT          | Maximum number of          |
88707 |                           |                 | integrator steps           |
88708 +---------------------------+-----------------+----------------------------+
88709 | max_order                 | OT_DOUBLE       | Maximum order              |
88710 +---------------------------+-----------------+----------------------------+
88711 | max_step_size             | OT_DOUBLE       | Maximim step size          |
88712 +---------------------------+-----------------+----------------------------+
88713 | newton_scheme             | OT_STRING       | Linear solver scheme in    |
88714 |                           |                 | the Newton method:         |
88715 |                           |                 | DIRECT|gmres|bcgstab|tfqmr |
88716 +---------------------------+-----------------+----------------------------+
88717 | nonlin_conv_coeff         | OT_DOUBLE       | Coefficient in the         |
88718 |                           |                 | nonlinear convergence test |
88719 +---------------------------+-----------------+----------------------------+
88720 | quad_err_con              | OT_BOOL         | Should the quadratures     |
88721 |                           |                 | affect the step size       |
88722 |                           |                 | control                    |
88723 +---------------------------+-----------------+----------------------------+
88724 | reltol                    | OT_DOUBLE       | Relative tolerence for the |
88725 |                           |                 | IVP solution               |
88726 +---------------------------+-----------------+----------------------------+
88727 | second_order_correction   | OT_BOOL         | Second order correction in |
88728 |                           |                 | the augmented system       |
88729 |                           |                 | Jacobian [true]            |
88730 +---------------------------+-----------------+----------------------------+
88731 | sensitivity_method        | OT_STRING       | Sensitivity method:        |
88732 |                           |                 | SIMULTANEOUS|staggered     |
88733 +---------------------------+-----------------+----------------------------+
88734 | step0                     | OT_DOUBLE       | initial step size          |
88735 |                           |                 | [default: 0/estimated]     |
88736 +---------------------------+-----------------+----------------------------+
88737 | steps_per_checkpoint      | OT_INT          | Number of steps between    |
88738 |                           |                 | two consecutive            |
88739 |                           |                 | checkpoints                |
88740 +---------------------------+-----------------+----------------------------+
88741 | stop_at_end               | OT_BOOL         | Stop the integrator at the |
88742 |                           |                 | end of the interval        |
88743 +---------------------------+-----------------+----------------------------+
88744 | suppress_algebraic        | OT_BOOL         | Suppress algebraic         |
88745 |                           |                 | variables in the error     |
88746 |                           |                 | testing                    |
88747 +---------------------------+-----------------+----------------------------+
88748 | use_preconditioner        | OT_BOOL         | Precondition the iterative |
88749 |                           |                 | solver [default: true]     |
88750 +---------------------------+-----------------+----------------------------+
88751 
88752 --------------------------------------------------------------------------------
88753 
88754 
88755 
88756 --------------------------------------------------------------------------------
88757 
88758 collocation
88759 -----------
88760 
88761 
88762 
88763 Fixed-step implicit Runge-Kutta integrator ODE/DAE integrator based on
88764 collocation schemes
88765 
88766 The method is still under development
88767 
88768 >List of available options
88769 
88770 +---------------------------+-----------------+----------------------------+
88771 |            Id             |      Type       |        Description         |
88772 +===========================+=================+============================+
88773 | augmented_options         | OT_DICT         | Options to be passed down  |
88774 |                           |                 | to the augmented           |
88775 |                           |                 | integrator, if one is      |
88776 |                           |                 | constructed.               |
88777 +---------------------------+-----------------+----------------------------+
88778 | collocation_scheme        | OT_STRING       | Collocation scheme:        |
88779 |                           |                 | radau|legendre             |
88780 +---------------------------+-----------------+----------------------------+
88781 | expand                    | OT_BOOL         | Replace MX with SX         |
88782 |                           |                 | expressions in problem     |
88783 |                           |                 | formulation [false]        |
88784 +---------------------------+-----------------+----------------------------+
88785 | grid                      | OT_DOUBLEVECTOR | Time grid                  |
88786 +---------------------------+-----------------+----------------------------+
88787 | interpolation_order       | OT_INT          | Order of the interpolating |
88788 |                           |                 | polynomials                |
88789 +---------------------------+-----------------+----------------------------+
88790 | number_of_finite_elements | OT_INT          | Number of finite elements  |
88791 +---------------------------+-----------------+----------------------------+
88792 | output_t0                 | OT_BOOL         | Output the state at the    |
88793 |                           |                 | initial time               |
88794 +---------------------------+-----------------+----------------------------+
88795 | print_stats               | OT_BOOL         | Print out statistics after |
88796 |                           |                 | integration                |
88797 +---------------------------+-----------------+----------------------------+
88798 | rootfinder                | OT_STRING       | An implicit function       |
88799 |                           |                 | solver                     |
88800 +---------------------------+-----------------+----------------------------+
88801 | rootfinder_options        | OT_DICT         | Options to be passed to    |
88802 |                           |                 | the NLP Solver             |
88803 +---------------------------+-----------------+----------------------------+
88804 | simplify                  | OT_BOOL         | Implement as MX  Function  |
88805 |                           |                 | (codegeneratable/serializa |
88806 |                           |                 | ble) default: false        |
88807 +---------------------------+-----------------+----------------------------+
88808 | simplify_options          | OT_DICT         | Any options to pass to     |
88809 |                           |                 | simplified form Function   |
88810 |                           |                 | constructor                |
88811 +---------------------------+-----------------+----------------------------+
88812 | t0                        | OT_DOUBLE       | Beginning of the time      |
88813 |                           |                 | horizon                    |
88814 +---------------------------+-----------------+----------------------------+
88815 | tf                        | OT_DOUBLE       | End of the time horizon    |
88816 +---------------------------+-----------------+----------------------------+
88817 
88818 --------------------------------------------------------------------------------
88819 
88820 
88821 
88822 --------------------------------------------------------------------------------
88823 
88824 rk --
88825 
88826 
88827 
88828 Fixed-step explicit Runge-Kutta integrator for ODEs Currently implements
88829 RK4.
88830 
88831 The method is still under development
88832 
88833 --------------------------------------------------------------------------------
88834 
88835 
88836 
88837 Joel Andersson
88838 
88839 ";
88840 
88841 %feature("docstring")  casadi::casadi_cvx_house_apply_symm(casadi_int n,
88842 casadi_int k, T1 *A, T1 *p, T1 *v) "
88843 
88844 [INTERNAL] ";
88845 
88846 %feature("docstring")  casadi::casadi_qp_take_step(casadi_qp_data< T1 > *d)
88847 "
88848 
88849 [INTERNAL] ";
88850 
88851 %feature("docstring")  casadi::conic_option_info(const std::string &name,
88852 const std::string &op) "
88853 
88854 Get documentation for a particular option.
88855 
88856 ";
88857 
88858 %feature("docstring")  casadi::check_exposed(T t) "
88859 
88860 [INTERNAL] ";
88861 
88862 %feature("docstring")  casadi::casadi_interpn(casadi_int ndim, const T1
88863 *grid, const casadi_int *offset, const T1 *values, const T1 *x, casadi_int
88864 *iw, T1 *w) "
88865 
88866 [INTERNAL] ";
88867 
88868 %feature("docstring")  casadi::casadi_interpn(T1 *res, casadi_int ndim,
88869 const T1 *grid, const casadi_int *offset, const T1 *values, const T1 *x,
88870 const casadi_int *lookup_mode, casadi_int m, casadi_int *iw, T1 *w) "
88871 
88872 [INTERNAL] ";
88873 
88874 %feature("docstring")  casadi::read_matlab(std::istream &stream,
88875 std::vector< T > &v) "
88876 
88877 Read vector, matlab style.
88878 
88879 ";
88880 
88881 %feature("docstring")  casadi::read_matlab(std::ifstream &file, std::vector<
88882 std::vector< T > > &v) "
88883 
88884 Read matrix, matlab style.
88885 
88886 ";
88887 
88888 %feature("docstring")  casadi::casadi_iamax(casadi_int n, const T1 *x,
88889 casadi_int inc_x) "
88890 
88891 [INTERNAL]  IAMAX: index corresponding to the entry with the largest
88892 absolute value.
88893 
88894 ";
88895 
88896 %feature("docstring")  casadi::has_expm(const std::string &name) "
88897 
88898 Check if a particular plugin is available.
88899 
88900 ";
88901 
88902 %feature("docstring")  casadi::write_matlab(std::ostream &stream, const
88903 std::vector< T > &v) "
88904 
88905 Print vector, matlab style.
88906 
88907 ";
88908 
88909 %feature("docstring")  casadi::write_matlab(std::ostream &stream, const
88910 std::vector< std::vector< T > > &v) "
88911 
88912 Print matrix, matlab style.
88913 
88914 ";
88915 
88916 %feature("docstring")  casadi::casadi_sparsify(const T1 *x, T2 *y, const
88917 casadi_int *sp_y, casadi_int tr) "
88918 
88919 [INTERNAL]  Convert dense to sparse.
88920 
88921 ";
88922 
88923 %feature("docstring")  casadi::hash_sparsity(casadi_int nrow, casadi_int
88924 ncol, const std::vector< casadi_int > &colind, const std::vector< casadi_int
88925 > &row) "
88926 
88927 Hash a sparsity pattern.
88928 
88929 ";
88930 
88931 %feature("docstring")  casadi::is_slice2(const std::vector< casadi_int > &v)
88932 "
88933 
88934 Check if an index vector can be represented more efficiently as two nested
88935 slices.
88936 
88937 ";
88938 
88939 %feature("docstring")  casadi::rootfinder(const std::string &name, const
88940 std::string &solver, const SXDict &rfp, const Dict &opts=Dict()) "
88941 
88942 Create a solver for rootfinding problems Takes a function where one of the
88943 inputs is unknown and one of the outputs is a residual function that is
88944 always zero, defines a new function where the the unknown input has been
88945 replaced by a guess for the unknown and the residual output has been
88946 replaced by the calculated value for the input.
88947 
88948 For a function [y0, y1, ...,yi, .., yn] = F(x0, x1, ..., xj, ..., xm), where
88949 xj is unknown and yi=0, defines a new function [y0, y1, ...,xj, .., yn] =
88950 G(x0, x1, ..., xj_guess, ..., xm),
88951 
88952 xj and yi must have the same dimension and d(yi)/d(xj) must be invertable.
88953 
88954 By default, the first input is unknown and the first output is the residual.
88955 
88956 General information
88957 ===================
88958 
88959 
88960 
88961 >List of available options
88962 
88963 +------------------+-----------------+------------------+------------------+
88964 |        Id        |      Type       |   Description    |     Used in      |
88965 +==================+=================+==================+==================+
88966 | common_options   | OT_DICT         | Options for      | casadi::OracleFu |
88967 |                  |                 | auto-generated   | nction           |
88968 |                  |                 | functions        |                  |
88969 +------------------+-----------------+------------------+------------------+
88970 | constraints      | OT_INTVECTOR    | Constrain the    | casadi::Rootfind |
88971 |                  |                 | unknowns. 0      | er               |
88972 |                  |                 | (default): no    |                  |
88973 |                  |                 | constraint on    |                  |
88974 |                  |                 | ui, 1: ui >=     |                  |
88975 |                  |                 | 0.0, -1: ui <=   |                  |
88976 |                  |                 | 0.0, 2: ui >     |                  |
88977 |                  |                 | 0.0, -2: ui <    |                  |
88978 |                  |                 | 0.0.             |                  |
88979 +------------------+-----------------+------------------+------------------+
88980 | error_on_fail    | OT_BOOL         | When the         | casadi::Rootfind |
88981 |                  |                 | numerical        | er               |
88982 |                  |                 | process returns  |                  |
88983 |                  |                 | unsuccessfully,  |                  |
88984 |                  |                 | raise an error   |                  |
88985 |                  |                 | (default false). |                  |
88986 +------------------+-----------------+------------------+------------------+
88987 | expand           | OT_BOOL         | Replace MX with  | casadi::OracleFu |
88988 |                  |                 | SX expressions   | nction           |
88989 |                  |                 | in problem       |                  |
88990 |                  |                 | formulation      |                  |
88991 |                  |                 | [false]          |                  |
88992 +------------------+-----------------+------------------+------------------+
88993 | implicit_input   | OT_INT          | Index of the     | casadi::Rootfind |
88994 |                  |                 | input that       | er               |
88995 |                  |                 | corresponds to   |                  |
88996 |                  |                 | the actual root- |                  |
88997 |                  |                 | finding          |                  |
88998 +------------------+-----------------+------------------+------------------+
88999 | implicit_output  | OT_INT          | Index of the     | casadi::Rootfind |
89000 |                  |                 | output that      | er               |
89001 |                  |                 | corresponds to   |                  |
89002 |                  |                 | the actual root- |                  |
89003 |                  |                 | finding          |                  |
89004 +------------------+-----------------+------------------+------------------+
89005 | jacobian_functio | OT_FUNCTION     | Function object  | casadi::Rootfind |
89006 | n                |                 | for calculating  | er               |
89007 |                  |                 | the Jacobian     |                  |
89008 |                  |                 | (autogenerated   |                  |
89009 |                  |                 | by default)      |                  |
89010 +------------------+-----------------+------------------+------------------+
89011 | linear_solver    | OT_STRING       | User-defined     | casadi::Rootfind |
89012 |                  |                 | linear solver    | er               |
89013 |                  |                 | class. Needed    |                  |
89014 |                  |                 | for              |                  |
89015 |                  |                 | sensitivities.   |                  |
89016 +------------------+-----------------+------------------+------------------+
89017 | linear_solver_op | OT_DICT         | Options to be    | casadi::Rootfind |
89018 | tions            |                 | passed to the    | er               |
89019 |                  |                 | linear solver.   |                  |
89020 +------------------+-----------------+------------------+------------------+
89021 | monitor          | OT_STRINGVECTOR | Set of user      | casadi::OracleFu |
89022 |                  |                 | problem          | nction           |
89023 |                  |                 | functions to be  |                  |
89024 |                  |                 | monitored        |                  |
89025 +------------------+-----------------+------------------+------------------+
89026 | show_eval_warnin | OT_BOOL         | Show warnings    | casadi::OracleFu |
89027 | gs               |                 | generated from   | nction           |
89028 |                  |                 | function         |                  |
89029 |                  |                 | evaluations      |                  |
89030 |                  |                 | [true]           |                  |
89031 +------------------+-----------------+------------------+------------------+
89032 | specific_options | OT_DICT         | Options for      | casadi::OracleFu |
89033 |                  |                 | specific auto-   | nction           |
89034 |                  |                 | generated        |                  |
89035 |                  |                 | functions,       |                  |
89036 |                  |                 | overwriting the  |                  |
89037 |                  |                 | defaults from    |                  |
89038 |                  |                 | common_options.  |                  |
89039 |                  |                 | Nested           |                  |
89040 |                  |                 | dictionary.      |                  |
89041 +------------------+-----------------+------------------+------------------+
89042 
89043 >Input scheme: casadi::RootfinderInput (ROOTFINDER_NUM_IN = 2)
89044 
89045 +---------------+-------+---------------------------------+
89046 |   Full name   | Short |           Description           |
89047 +===============+=======+=================================+
89048 | ROOTFINDER_X0 | x0    | Initial guess for the solution. |
89049 +---------------+-------+---------------------------------+
89050 | ROOTFINDER_P  | p     | Parameters.                     |
89051 +---------------+-------+---------------------------------+
89052 
89053 >Output scheme: casadi::RootfinderOutput (ROOTFINDER_NUM_OUT = 1)
89054 
89055 +--------------+-------+--------------------------------------+
89056 |  Full name   | Short |             Description              |
89057 +==============+=======+======================================+
89058 | ROOTFINDER_X | x     | Solution to the system of equations. |
89059 +--------------+-------+--------------------------------------+
89060 
89061 List of plugins
89062 ===============
89063 
89064 
89065 
89066 - kinsol
89067 
89068 - fast_newton
89069 
89070 - nlpsol
89071 
89072 - newton
89073 
89074 Note: some of the plugins in this list might not be available on your
89075 system. Also, there might be extra plugins available to you that are not
89076 listed here. You can obtain their documentation with
89077 Rootfinder.doc(\"myextraplugin\")
89078 
89079 
89080 
89081 --------------------------------------------------------------------------------
89082 
89083 kinsol
89084 ------
89085 
89086 
89087 
89088 KINSOL interface from the Sundials suite
89089 
89090 >List of available options
89091 
89092 +---------------------------+-----------------+----------------------------+
89093 |            Id             |      Type       |        Description         |
89094 +===========================+=================+============================+
89095 | abstol                    | OT_DOUBLE       | Stopping criterion         |
89096 |                           |                 | tolerance                  |
89097 +---------------------------+-----------------+----------------------------+
89098 | disable_internal_warnings | OT_BOOL         | Disable KINSOL internal    |
89099 |                           |                 | warning messages           |
89100 +---------------------------+-----------------+----------------------------+
89101 | exact_jacobian            | OT_BOOL         | Use exact Jacobian         |
89102 |                           |                 | information                |
89103 +---------------------------+-----------------+----------------------------+
89104 | f_scale                   | OT_DOUBLEVECTOR | Equation scaling factors   |
89105 +---------------------------+-----------------+----------------------------+
89106 | iterative_solver          | OT_STRING       | gmres|bcgstab|tfqmr        |
89107 +---------------------------+-----------------+----------------------------+
89108 | linear_solver_type        | OT_STRING       | dense|banded|iterative|use |
89109 |                           |                 | r_defined                  |
89110 +---------------------------+-----------------+----------------------------+
89111 | lower_bandwidth           | OT_INT          | Lower bandwidth for banded |
89112 |                           |                 | linear solvers             |
89113 +---------------------------+-----------------+----------------------------+
89114 | max_iter                  | OT_INT          | Maximum number of Newton   |
89115 |                           |                 | iterations. Putting 0 sets |
89116 |                           |                 | the default value of       |
89117 |                           |                 | KinSol.                    |
89118 +---------------------------+-----------------+----------------------------+
89119 | max_krylov                | OT_INT          | Maximum Krylov space       |
89120 |                           |                 | dimension                  |
89121 +---------------------------+-----------------+----------------------------+
89122 | pretype                   | OT_STRING       | Type of preconditioner     |
89123 +---------------------------+-----------------+----------------------------+
89124 | strategy                  | OT_STRING       | Globalization strategy     |
89125 +---------------------------+-----------------+----------------------------+
89126 | u_scale                   | OT_DOUBLEVECTOR | Variable scaling factors   |
89127 +---------------------------+-----------------+----------------------------+
89128 | upper_bandwidth           | OT_INT          | Upper bandwidth for banded |
89129 |                           |                 | linear solvers             |
89130 +---------------------------+-----------------+----------------------------+
89131 | use_preconditioner        | OT_BOOL         | Precondition an iterative  |
89132 |                           |                 | solver                     |
89133 +---------------------------+-----------------+----------------------------+
89134 
89135 --------------------------------------------------------------------------------
89136 
89137 
89138 
89139 --------------------------------------------------------------------------------
89140 
89141 fast_newton
89142 -----------
89143 
89144 
89145 
89146 Implements simple newton iterations to solve an implicit function.
89147 
89148 >List of available options
89149 
89150 +------------+-----------+-------------------------------------------------+
89151 |     Id     |   Type    |                   Description                   |
89152 +============+===========+=================================================+
89153 | abstol     | OT_DOUBLE | Stopping criterion tolerance on ||g||__inf)     |
89154 +------------+-----------+-------------------------------------------------+
89155 | abstolStep | OT_DOUBLE | Stopping criterion tolerance on step size       |
89156 +------------+-----------+-------------------------------------------------+
89157 | max_iter   | OT_INT    | Maximum number of Newton iterations to perform  |
89158 |            |           | before returning.                               |
89159 +------------+-----------+-------------------------------------------------+
89160 
89161 --------------------------------------------------------------------------------
89162 
89163 
89164 
89165 --------------------------------------------------------------------------------
89166 
89167 nlpsol
89168 ------
89169 
89170 
89171 
89172 
89173 
89174 --------------------------------------------------------------------------------
89175 
89176 
89177 
89178 
89179 
89180 --------------------------------------------------------------------------------
89181 
89182 newton
89183 ------
89184 
89185 
89186 
89187 Implements simple newton iterations to solve an implicit function.
89188 
89189 >List of available options
89190 
89191 +-----------------+-----------+--------------------------------------------+
89192 |       Id        |   Type    |                Description                 |
89193 +=================+===========+============================================+
89194 | abstol          | OT_DOUBLE | Stopping criterion tolerance on max(|F|)   |
89195 +-----------------+-----------+--------------------------------------------+
89196 | abstolStep      | OT_DOUBLE | Stopping criterion tolerance on step size  |
89197 +-----------------+-----------+--------------------------------------------+
89198 | line_search     | OT_BOOL   | Enable line-search (default: true)         |
89199 +-----------------+-----------+--------------------------------------------+
89200 | max_iter        | OT_INT    | Maximum number of Newton iterations to     |
89201 |                 |           | perform before returning.                  |
89202 +-----------------+-----------+--------------------------------------------+
89203 | print_iteration | OT_BOOL   | Print information about each iteration     |
89204 +-----------------+-----------+--------------------------------------------+
89205 
89206 --------------------------------------------------------------------------------
89207 
89208 
89209 
89210 Joel Andersson
89211 
89212 ";
89213 
89214 %feature("docstring")  casadi::casadi_qp_setup(casadi_qp_prob< T1 > *p) "
89215 
89216 [INTERNAL] ";
89217 
89218 %feature("docstring")  casadi::casadi_ldl(const casadi_int *sp_a, const T1
89219 *a, const casadi_int *sp_lt, T1 *lt, T1 *d, const casadi_int *p, T1 *w) "
89220 
89221 [INTERNAL] ";
89222 
89223 %feature("docstring")  casadi::dple_n_in() "
89224 
89225 Get the number of QP solver inputs.
89226 
89227 ";
89228 
89229 %feature("docstring")  casadi::has_negative(const std::vector< T > &v) "
89230 
89231 Check if the vector has negative entries.
89232 
89233 ";
89234 
89235 %feature("docstring")  casadi::casadi_tri_project(const T1 *x, const
89236 casadi_int *sp_x, T1 *y, casadi_int lower) "
89237 
89238 [INTERNAL] ";
89239 
89240 %feature("docstring")  casadi::casadi_cvx_symm_schur(casadi_int n, T1
89241 *t_diag, T1 *t_off, T1 tol, casadi_int max_iter, casadi_int *trace_meta, T1
89242 *trace) "
89243 
89244 [INTERNAL]  Golub & Van Loan Alg. 8.3.3.
89245 
89246 ";
89247 
89248 %feature("docstring")  casadi::casadi_qp_linesearch(casadi_qp_data< T1 > *d)
89249 "
89250 
89251 [INTERNAL] ";
89252 
89253 %feature("docstring")  casadi::casadi_vfmin(const T1 *x, casadi_int n, T1 r)
89254 "
89255 
89256 [INTERNAL] ";
89257 
89258 %feature("docstring")  casadi::to_slice(const IM &x, bool ind1=false) "
89259 
89260 Convert IM to Slice.
89261 
89262 ";
89263 
89264 %feature("docstring")  casadi::to_slice(const std::vector< casadi_int > &v,
89265 bool ind1=false) "
89266 
89267 Construct from an index vector (requires is_slice(v) to be true)
89268 
89269 ";
89270 
89271 %feature("docstring")  casadi::casadi_qp_dual_breakpoints(casadi_qp_data< T1
89272 > *d, T1 *tau_list, casadi_int *ind_list, T1 tau) "
89273 
89274 [INTERNAL] ";
89275 
89276 %feature("docstring")  casadi::doc_linsol(const std::string &name) "
89277 
89278 Get the documentation string for a plugin.
89279 
89280 ";
89281 
89282 %feature("docstring")  casadi::getcopy(const A &a, std::map<
89283 SharedObjectInternal *, SharedObject > &already_copied) "
89284 
89285 [INTERNAL] ";
89286 
89287 %feature("docstring")  casadi::expm_n_in() "
89288 
89289 Get the number of expm solver inputs.
89290 
89291 ";
89292 
89293 %feature("docstring")  casadi::rootfinder_out() "
89294 
89295 Get rootfinder output scheme.
89296 
89297 ";
89298 
89299 %feature("docstring")  casadi::rootfinder_out(casadi_int ind) "
89300 
89301 Get rootfinder output scheme name by index.
89302 
89303 ";
89304 
89305 %feature("docstring")  casadi::conic_in() "
89306 
89307 Get input scheme of QP solvers.
89308 
89309 ";
89310 
89311 %feature("docstring")  casadi::conic_in(casadi_int ind) "
89312 
89313 Get QP solver input scheme name by index.
89314 
89315 ";
89316 
89317 %feature("docstring")  casadi::doc_expm(const std::string &name) "
89318 
89319 Get the documentation string for a plugin.
89320 
89321 ";
89322 
89323 %feature("docstring")  casadi::lookupvector(const std::vector< casadi_int >
89324 &v, casadi_int size) "
89325 
89326 Returns a vector for quickly looking up entries of supplied list.
89327 
89328 lookupvector[i]!=-1 <=> v contains i v[lookupvector[i]] == i <=> v contains
89329 i
89330 
89331 Duplicates are treated by looking up last occurrence
89332 
89333 ";
89334 
89335 %feature("docstring")  casadi::doc_dple(const std::string &name) "
89336 
89337 Get the documentation string for a plugin.
89338 
89339 ";
89340 
89341 %feature("docstring")  casadi::casadi_nlpsol_init(casadi_nlpsol_data< T1 >
89342 *d, casadi_int **iw, T1 **w) "
89343 
89344 [INTERNAL] ";
89345 
89346 %feature("docstring")  casadi::hash_combine(std::size_t &seed, T v) "
89347 
89348 Generate a hash value incrementally (function taken from boost)
89349 
89350 ";
89351 
89352 %feature("docstring")  casadi::hash_combine(std::size_t &seed, const
89353 casadi_int *v, std::size_t sz) "
89354 
89355 Generate a hash value incrementally, array.
89356 
89357 ";
89358 
89359 %feature("docstring")  casadi::hash_combine(std::size_t &seed, const
89360 std::vector< casadi_int > &v) "
89361 
89362 Generate a hash value incrementally (function taken from boost)
89363 
89364 ";
89365 
89366 %feature("docstring")  casadi::rootfinder_n_in() "
89367 
89368 Number of rootfinder inputs.
89369 
89370 ";
89371 
89372 %feature("docstring")  casadi::casadi_sqpmethod_init(casadi_sqpmethod_data<
89373 T1 > *d, casadi_int **iw, T1 **w) "
89374 
89375 [INTERNAL] ";
89376 
89377 %feature("docstring")  casadi::casadi_qp_calc_sens(casadi_qp_data< T1 > *d,
89378 casadi_int i) "
89379 
89380 [INTERNAL] ";
89381 
89382 %feature("docstring")  casadi::has_integrator(const std::string &name) "
89383 
89384 Check if a particular plugin is available.
89385 
89386 ";
89387 
89388 %feature("docstring")  casadi::casadi_bound_consistency(casadi_int n, T1 *x,
89389 T1 *lam, const T1 *lbx, const T1 *ubx) "
89390 
89391 [INTERNAL] ";
89392 
89393 %feature("docstring")  casadi::dense_mul_nn2(casadi_int n, casadi_int m,
89394 casadi_int l, const double *A, const double *B, double *C) "
89395 
89396 [INTERNAL] ";
89397 
89398 %feature("docstring")  casadi::casadi_central_diff(T1 **yk, T1 *y0, T1 *J,
89399 T1 h, casadi_int n_y, const casadi_finite_diff_mem< T1 > *m) "
89400 
89401 [INTERNAL] ";
89402 
89403 %feature("docstring")  casadi::nlpsol_options(const std::string &name) "
89404 
89405 Get all options for a plugin.
89406 
89407 ";
89408 
89409 %feature("docstring")  casadi::integrator_out() "
89410 
89411 Get integrator output scheme of integrators.
89412 
89413 ";
89414 
89415 %feature("docstring")  casadi::integrator_out(casadi_int ind) "
89416 
89417 Get output scheme name by index.
89418 
89419 ";
89420 
89421 %feature("docstring")  casadi::has_dple(const std::string &name) "
89422 
89423 Check if a particular plugin is available.
89424 
89425 ";
89426 
89427 %feature("docstring")  casadi::rootfinder_option_info(const std::string
89428 &name, const std::string &op) "
89429 
89430 Get documentation for a particular option.
89431 
89432 ";
89433 
89434 %feature("docstring")  casadi::casadi_qp_enforceable(casadi_qp_data< T1 >
89435 *d, casadi_int i, casadi_int s) "
89436 
89437 [INTERNAL] ";
89438 
89439 %feature("docstring")  casadi::replace_mat(const M &arg, const Sparsity
89440 &inp, casadi_int npar) "
89441 
89442 [INTERNAL] ";
89443 
89444 %feature("docstring")  casadi::casadi_cvx_implicit_qr(casadi_int n, T1
89445 *t_diag, T1 *t_off, T1 *cs) "
89446 
89447 [INTERNAL] ";
89448 
89449 %feature("docstring")  casadi::casadi_qp_primal_blocking(casadi_qp_data< T1
89450 > *d) "
89451 
89452 [INTERNAL] ";
89453 
89454 %feature("docstring")  casadi::casadi_cvx_givens(T1 a, T1 b, T1 *c, T1 *s) "
89455 
89456 [INTERNAL] ";
89457 
89458 %feature("docstring")  casadi::load_interpolant(const std::string &name) "
89459 
89460 Explicitly load a plugin dynamically.
89461 
89462 ";
89463 
89464 %feature("docstring")  casadi::casadi_newton(const casadi_newton_mem< T1 >
89465 *m) "
89466 
89467 [INTERNAL] ";
89468 
89469 %feature("docstring")  casadi::flatten_nested_vector(const std::vector<
89470 std::vector< T > > &nested, std::vector< S > &flat) "
89471 
89472 Flatten a nested std::vector tot a single flattened vector.
89473 
89474 Contents of nested[i] ends up in flat[indices[i]]..flat[indices[i+1]-1]
89475 
89476 ";
89477 
89478 %feature("docstring")  casadi::flatten_nested_vector(const std::vector<
89479 std::vector< T > > &nested, std::vector< S > &flat, std::vector< I >
89480 &indices) "
89481 
89482 Flatten a nested std::vector tot a single flattened vector.
89483 
89484 Contents of nested[i] ends up in flat[indices[i]]..flat[indices[i+1]-1]
89485 
89486 ";
89487 
89488 %feature("docstring")  casadi::integrator_n_in() "
89489 
89490 Get the number of integrator inputs.
89491 
89492 ";
89493 
89494 %feature("docstring")  casadi::collocation_points(casadi_int order, const
89495 std::string &scheme="radau") "
89496 
89497 Obtain collocation points of specific order and scheme.
89498 
89499 Parameters:
89500 -----------
89501 
89502 order:  Which order (1 to 9 supported)
89503 
89504 scheme:  'radau' or 'legendre'
89505 
89506 ";
89507 
89508 %feature("docstring")  casadi::conic(const std::string &name, const
89509 std::string &solver, const SpDict &qp, const Dict &opts=Dict()) "
89510 
89511 Create a QP solver Solves the following strictly convex problem:
89512 
89513 
89514 
89515 ::
89516 
89517   min          1/2 x' H x + g' x
89518   x
89519 
89520   subject to
89521   LBA <= A x <= UBA
89522   LBX <= x   <= UBX
89523 
89524   resize(Q x, np, np) + P >= 0 (psd)
89525 
89526   with :
89527   H sparse (n x n) positive definite
89528   g dense  (n x 1)
89529   A sparse (nc x n)
89530   Q sparse symmetric (np^2 x n)
89531   P sparse symmetric (np x nq)
89532 
89533   n: number of decision variables (x)
89534   nc: number of constraints (A)
89535   nq: shape of psd constraint matrix
89536 
89537 
89538 
89539 If H is not positive-definite, the solver should throw an error.
89540 
89541 Second-order cone constraints can be added as psd constraints through a
89542 helper function 'soc':
89543 
89544 x in R^n y in R
89545 
89546 || x ||_2 <= y
89547 
89548 <=>
89549 
89550 soc(x, y) psd
89551 
89552 This can be proven with soc(x, y)=[y*I x; x' y] using the Shur complement.
89553 
89554 General information
89555 ===================
89556 
89557 
89558 
89559 >List of available options
89560 
89561 +------------------+-----------------+------------------+------------------+
89562 |        Id        |      Type       |   Description    |     Used in      |
89563 +==================+=================+==================+==================+
89564 | ad_weight        | OT_DOUBLE       | Weighting factor | casadi::Function |
89565 |                  |                 | for derivative   | Internal         |
89566 |                  |                 | calculation.When |                  |
89567 |                  |                 | there is an      |                  |
89568 |                  |                 | option of either |                  |
89569 |                  |                 | using forward or |                  |
89570 |                  |                 | reverse mode     |                  |
89571 |                  |                 | directional      |                  |
89572 |                  |                 | derivatives, the |                  |
89573 |                  |                 | condition ad_wei |                  |
89574 |                  |                 | ght*nf<=(1-ad_we |                  |
89575 |                  |                 | ight)*na is used |                  |
89576 |                  |                 | where nf and na  |                  |
89577 |                  |                 | are estimates of |                  |
89578 |                  |                 | the number of    |                  |
89579 |                  |                 | forward/reverse  |                  |
89580 |                  |                 | mode directional |                  |
89581 |                  |                 | derivatives      |                  |
89582 |                  |                 | needed. By       |                  |
89583 |                  |                 | default,         |                  |
89584 |                  |                 | ad_weight is     |                  |
89585 |                  |                 | calculated       |                  |
89586 |                  |                 | automatically,   |                  |
89587 |                  |                 | but this can be  |                  |
89588 |                  |                 | overridden by    |                  |
89589 |                  |                 | setting this     |                  |
89590 |                  |                 | option. In       |                  |
89591 |                  |                 | particular, 0    |                  |
89592 |                  |                 | means forcing    |                  |
89593 |                  |                 | forward mode and |                  |
89594 |                  |                 | 1 forcing        |                  |
89595 |                  |                 | reverse mode.    |                  |
89596 |                  |                 | Leave unset for  |                  |
89597 |                  |                 | (class specific) |                  |
89598 |                  |                 | heuristics.      |                  |
89599 +------------------+-----------------+------------------+------------------+
89600 | ad_weight_sp     | OT_DOUBLE       | Weighting factor | casadi::Function |
89601 |                  |                 | for sparsity     | Internal         |
89602 |                  |                 | pattern          |                  |
89603 |                  |                 | calculation calc |                  |
89604 |                  |                 | ulation.Override |                  |
89605 |                  |                 | s default        |                  |
89606 |                  |                 | behavior. Set to |                  |
89607 |                  |                 | 0 and 1 to force |                  |
89608 |                  |                 | forward and      |                  |
89609 |                  |                 | reverse mode     |                  |
89610 |                  |                 | respectively.    |                  |
89611 |                  |                 | Cf. option       |                  |
89612 |                  |                 | \"ad_weight\".     |                  |
89613 |                  |                 | When set to -1,  |                  |
89614 |                  |                 | sparsity is      |                  |
89615 |                  |                 | completely       |                  |
89616 |                  |                 | ignored and      |                  |
89617 |                  |                 | dense matrices   |                  |
89618 |                  |                 | are used.        |                  |
89619 +------------------+-----------------+------------------+------------------+
89620 | always_inline    | OT_BOOL         | Force inlining.  | casadi::Function |
89621 |                  |                 |                  | Internal         |
89622 +------------------+-----------------+------------------+------------------+
89623 | compiler         | OT_STRING       | Just-in-time     | casadi::Function |
89624 |                  |                 | compiler plugin  | Internal         |
89625 |                  |                 | to be used.      |                  |
89626 +------------------+-----------------+------------------+------------------+
89627 | custom_jacobian  | OT_FUNCTION     | Override         | casadi::Function |
89628 |                  |                 | CasADi's AD. Use | Internal         |
89629 |                  |                 | together with    |                  |
89630 |                  |                 | 'jac_penalty':   |                  |
89631 |                  |                 | 0. Note: Highly  |                  |
89632 |                  |                 | experimental.    |                  |
89633 |                  |                 | Syntax may break |                  |
89634 |                  |                 | often.           |                  |
89635 +------------------+-----------------+------------------+------------------+
89636 | derivative_of    | OT_FUNCTION     | The function is  | casadi::Function |
89637 |                  |                 | a derivative of  | Internal         |
89638 |                  |                 | another          |                  |
89639 |                  |                 | function. The    |                  |
89640 |                  |                 | type of          |                  |
89641 |                  |                 | derivative       |                  |
89642 |                  |                 | (directional     |                  |
89643 |                  |                 | derivative,      |                  |
89644 |                  |                 | Jacobian) is     |                  |
89645 |                  |                 | inferred from    |                  |
89646 |                  |                 | the function     |                  |
89647 |                  |                 | name.            |                  |
89648 +------------------+-----------------+------------------+------------------+
89649 | discrete         | OT_BOOLVECTOR   | Indicates which  | casadi::Conic    |
89650 |                  |                 | of the variables |                  |
89651 |                  |                 | are discrete,    |                  |
89652 |                  |                 | i.e. integer-    |                  |
89653 |                  |                 | valued           |                  |
89654 +------------------+-----------------+------------------+------------------+
89655 | dump             | OT_BOOL         | Dump function to | casadi::Function |
89656 |                  |                 | file upon first  | Internal         |
89657 |                  |                 | evaluation.      |                  |
89658 |                  |                 | [false]          |                  |
89659 +------------------+-----------------+------------------+------------------+
89660 | dump_dir         | OT_STRING       | Directory to     | casadi::Function |
89661 |                  |                 | dump             | Internal         |
89662 |                  |                 | inputs/outputs   |                  |
89663 |                  |                 | to. Make sure    |                  |
89664 |                  |                 | the directory    |                  |
89665 |                  |                 | exists [.]       |                  |
89666 +------------------+-----------------+------------------+------------------+
89667 | dump_format      | OT_STRING       | Choose file      | casadi::Function |
89668 |                  |                 | format to dump   | Internal         |
89669 |                  |                 | matrices. See    |                  |
89670 |                  |                 | DM.from_file     |                  |
89671 |                  |                 | [mtx]            |                  |
89672 +------------------+-----------------+------------------+------------------+
89673 | dump_in          | OT_BOOL         | Dump numerical   | casadi::Function |
89674 |                  |                 | values of inputs | Internal         |
89675 |                  |                 | to file          |                  |
89676 |                  |                 | (readable with   |                  |
89677 |                  |                 | DM.from_file )   |                  |
89678 |                  |                 | [default: false] |                  |
89679 +------------------+-----------------+------------------+------------------+
89680 | dump_out         | OT_BOOL         | Dump numerical   | casadi::Function |
89681 |                  |                 | values of        | Internal         |
89682 |                  |                 | outputs to file  |                  |
89683 |                  |                 | (readable with   |                  |
89684 |                  |                 | DM.from_file )   |                  |
89685 |                  |                 | [default: false] |                  |
89686 +------------------+-----------------+------------------+------------------+
89687 | enable_fd        | OT_BOOL         | Enable           | casadi::Function |
89688 |                  |                 | derivative       | Internal         |
89689 |                  |                 | calculation by   |                  |
89690 |                  |                 | finite           |                  |
89691 |                  |                 | differencing.    |                  |
89692 |                  |                 | [default:        |                  |
89693 |                  |                 | false]]          |                  |
89694 +------------------+-----------------+------------------+------------------+
89695 | enable_forward   | OT_BOOL         | Enable           | casadi::Function |
89696 |                  |                 | derivative       | Internal         |
89697 |                  |                 | calculation      |                  |
89698 |                  |                 | using generated  |                  |
89699 |                  |                 | functions for    |                  |
89700 |                  |                 | Jacobian-times-  |                  |
89701 |                  |                 | vector products  |                  |
89702 |                  |                 | - typically      |                  |
89703 |                  |                 | using forward    |                  |
89704 |                  |                 | mode AD - if     |                  |
89705 |                  |                 | available.       |                  |
89706 |                  |                 | [default: true]  |                  |
89707 +------------------+-----------------+------------------+------------------+
89708 | enable_jacobian  | OT_BOOL         | Enable           | casadi::Function |
89709 |                  |                 | derivative       | Internal         |
89710 |                  |                 | calculation      |                  |
89711 |                  |                 | using generated  |                  |
89712 |                  |                 | functions for    |                  |
89713 |                  |                 | Jacobians of all |                  |
89714 |                  |                 | differentiable   |                  |
89715 |                  |                 | outputs with     |                  |
89716 |                  |                 | respect to all   |                  |
89717 |                  |                 | differentiable   |                  |
89718 |                  |                 | inputs - if      |                  |
89719 |                  |                 | available.       |                  |
89720 |                  |                 | [default: true]  |                  |
89721 +------------------+-----------------+------------------+------------------+
89722 | enable_reverse   | OT_BOOL         | Enable           | casadi::Function |
89723 |                  |                 | derivative       | Internal         |
89724 |                  |                 | calculation      |                  |
89725 |                  |                 | using generated  |                  |
89726 |                  |                 | functions for    |                  |
89727 |                  |                 | transposed       |                  |
89728 |                  |                 | Jacobian-times-  |                  |
89729 |                  |                 | vector products  |                  |
89730 |                  |                 | - typically      |                  |
89731 |                  |                 | using reverse    |                  |
89732 |                  |                 | mode AD - if     |                  |
89733 |                  |                 | available.       |                  |
89734 |                  |                 | [default: true]  |                  |
89735 +------------------+-----------------+------------------+------------------+
89736 | error_on_fail    | OT_BOOL         | When the         | casadi::Conic    |
89737 |                  |                 | numerical        |                  |
89738 |                  |                 | process returns  |                  |
89739 |                  |                 | unsuccessfully,  |                  |
89740 |                  |                 | raise an error   |                  |
89741 |                  |                 | (default false). |                  |
89742 +------------------+-----------------+------------------+------------------+
89743 | fd_method        | OT_STRING       | Method for       | casadi::Function |
89744 |                  |                 | finite           | Internal         |
89745 |                  |                 | differencing     |                  |
89746 |                  |                 | [default         |                  |
89747 |                  |                 | 'central']       |                  |
89748 +------------------+-----------------+------------------+------------------+
89749 | fd_options       | OT_DICT         | Options to be    | casadi::Function |
89750 |                  |                 | passed to the    | Internal         |
89751 |                  |                 | finite           |                  |
89752 |                  |                 | difference       |                  |
89753 |                  |                 | instance         |                  |
89754 +------------------+-----------------+------------------+------------------+
89755 | forward_options  | OT_DICT         | Options to be    | casadi::Function |
89756 |                  |                 | passed to a      | Internal         |
89757 |                  |                 | forward mode     |                  |
89758 |                  |                 | constructor      |                  |
89759 +------------------+-----------------+------------------+------------------+
89760 | gather_stats     | OT_BOOL         | Deprecated       | casadi::Function |
89761 |                  |                 | option           | Internal         |
89762 |                  |                 | (ignored):       |                  |
89763 |                  |                 | Statistics are   |                  |
89764 |                  |                 | now always       |                  |
89765 |                  |                 | collected.       |                  |
89766 +------------------+-----------------+------------------+------------------+
89767 | input_scheme     | OT_STRINGVECTOR | Deprecated       | casadi::Function |
89768 |                  |                 | option (ignored) | Internal         |
89769 +------------------+-----------------+------------------+------------------+
89770 | inputs_check     | OT_BOOL         | Throw exceptions | casadi::Function |
89771 |                  |                 | when the         | Internal         |
89772 |                  |                 | numerical values |                  |
89773 |                  |                 | of the inputs    |                  |
89774 |                  |                 | don't make sense |                  |
89775 +------------------+-----------------+------------------+------------------+
89776 | is_diff_in       | OT_BOOLVECTOR   | Indicate for     | casadi::Function |
89777 |                  |                 | each input if it | Internal         |
89778 |                  |                 | should be        |                  |
89779 |                  |                 | differentiable.  |                  |
89780 +------------------+-----------------+------------------+------------------+
89781 | is_diff_out      | OT_BOOLVECTOR   | Indicate for     | casadi::Function |
89782 |                  |                 | each output if   | Internal         |
89783 |                  |                 | it should be     |                  |
89784 |                  |                 | differentiable.  |                  |
89785 +------------------+-----------------+------------------+------------------+
89786 | jac_penalty      | OT_DOUBLE       | When requested   | casadi::Function |
89787 |                  |                 | for a number of  | Internal         |
89788 |                  |                 | forward/reverse  |                  |
89789 |                  |                 | directions, it   |                  |
89790 |                  |                 | may be cheaper   |                  |
89791 |                  |                 | to compute first |                  |
89792 |                  |                 | the full         |                  |
89793 |                  |                 | jacobian and     |                  |
89794 |                  |                 | then multiply    |                  |
89795 |                  |                 | with seeds,      |                  |
89796 |                  |                 | rather than      |                  |
89797 |                  |                 | obtain the       |                  |
89798 |                  |                 | requested        |                  |
89799 |                  |                 | directions in a  |                  |
89800 |                  |                 | straightforward  |                  |
89801 |                  |                 | manner. Casadi   |                  |
89802 |                  |                 | uses a heuristic |                  |
89803 |                  |                 | to decide which  |                  |
89804 |                  |                 | is cheaper. A    |                  |
89805 |                  |                 | high value of    |                  |
89806 |                  |                 | 'jac_penalty'    |                  |
89807 |                  |                 | makes it less    |                  |
89808 |                  |                 | likely for the   |                  |
89809 |                  |                 | heurstic to      |                  |
89810 |                  |                 | chose the full   |                  |
89811 |                  |                 | Jacobian         |                  |
89812 |                  |                 | strategy. The    |                  |
89813 |                  |                 | special value -1 |                  |
89814 |                  |                 | indicates never  |                  |
89815 |                  |                 | to use the full  |                  |
89816 |                  |                 | Jacobian         |                  |
89817 |                  |                 | strategy         |                  |
89818 +------------------+-----------------+------------------+------------------+
89819 | jit              | OT_BOOL         | Use just-in-time | casadi::Function |
89820 |                  |                 | compiler to      | Internal         |
89821 |                  |                 | speed up the     |                  |
89822 |                  |                 | evaluation       |                  |
89823 +------------------+-----------------+------------------+------------------+
89824 | jit_cleanup      | OT_BOOL         | Cleanup up the   | casadi::Function |
89825 |                  |                 | temporary source | Internal         |
89826 |                  |                 | file that jit    |                  |
89827 |                  |                 | creates.         |                  |
89828 |                  |                 | Default: true    |                  |
89829 +------------------+-----------------+------------------+------------------+
89830 | jit_name         | OT_STRING       | The file name    | casadi::Function |
89831 |                  |                 | used to write    | Internal         |
89832 |                  |                 | out code. The    |                  |
89833 |                  |                 | actual file      |                  |
89834 |                  |                 | names used       |                  |
89835 |                  |                 | depend on 'jit_t |                  |
89836 |                  |                 | emp_suffix' and  |                  |
89837 |                  |                 | include          |                  |
89838 |                  |                 | extensions.      |                  |
89839 |                  |                 | Default:         |                  |
89840 |                  |                 | 'jit_tmp'        |                  |
89841 +------------------+-----------------+------------------+------------------+
89842 | jit_options      | OT_DICT         | Options to be    | casadi::Function |
89843 |                  |                 | passed to the    | Internal         |
89844 |                  |                 | jit compiler.    |                  |
89845 +------------------+-----------------+------------------+------------------+
89846 | jit_serialize    | OT_STRING       | Specify          | casadi::Function |
89847 |                  |                 | behaviour when   | Internal         |
89848 |                  |                 | serializing a    |                  |
89849 |                  |                 | jitted function: |                  |
89850 |                  |                 | SOURCE|link|embe |                  |
89851 |                  |                 | d.               |                  |
89852 +------------------+-----------------+------------------+------------------+
89853 | jit_temp_suffix  | OT_BOOL         | Use a temporary  | casadi::Function |
89854 |                  |                 | (seemingly       | Internal         |
89855 |                  |                 | random) filename |                  |
89856 |                  |                 | suffix for       |                  |
89857 |                  |                 | generated code   |                  |
89858 |                  |                 | and libraries.   |                  |
89859 |                  |                 | This is desired  |                  |
89860 |                  |                 | for thread-      |                  |
89861 |                  |                 | safety. This     |                  |
89862 |                  |                 | behaviour may    |                  |
89863 |                  |                 | defeat caching   |                  |
89864 |                  |                 | compiler         |                  |
89865 |                  |                 | wrappers.        |                  |
89866 |                  |                 | Default: true    |                  |
89867 +------------------+-----------------+------------------+------------------+
89868 | max_num_dir      | OT_INT          | Specify the      | casadi::Function |
89869 |                  |                 | maximum number   | Internal         |
89870 |                  |                 | of directions    |                  |
89871 |                  |                 | for derivative   |                  |
89872 |                  |                 | functions.       |                  |
89873 |                  |                 | Overrules the    |                  |
89874 |                  |                 | builtin optimize |                  |
89875 |                  |                 | d_num_dir.       |                  |
89876 +------------------+-----------------+------------------+------------------+
89877 | never_inline     | OT_BOOL         | Forbid inlining. | casadi::Function |
89878 |                  |                 |                  | Internal         |
89879 +------------------+-----------------+------------------+------------------+
89880 | output_scheme    | OT_STRINGVECTOR | Deprecated       | casadi::Function |
89881 |                  |                 | option (ignored) | Internal         |
89882 +------------------+-----------------+------------------+------------------+
89883 | print_in         | OT_BOOL         | Print numerical  | casadi::Function |
89884 |                  |                 | values of inputs | Internal         |
89885 |                  |                 | [default: false] |                  |
89886 +------------------+-----------------+------------------+------------------+
89887 | print_out        | OT_BOOL         | Print numerical  | casadi::Function |
89888 |                  |                 | values of        | Internal         |
89889 |                  |                 | outputs          |                  |
89890 |                  |                 | [default: false] |                  |
89891 +------------------+-----------------+------------------+------------------+
89892 | print_problem    | OT_BOOL         | Print a numeric  | casadi::Conic    |
89893 |                  |                 | description of   |                  |
89894 |                  |                 | the problem      |                  |
89895 +------------------+-----------------+------------------+------------------+
89896 | print_time       | OT_BOOL         | print            | casadi::Function |
89897 |                  |                 | information      | Internal         |
89898 |                  |                 | about execution  |                  |
89899 |                  |                 | time. Implies    |                  |
89900 |                  |                 | record_time.     |                  |
89901 +------------------+-----------------+------------------+------------------+
89902 | record_time      | OT_BOOL         | record           | casadi::Function |
89903 |                  |                 | information      | Internal         |
89904 |                  |                 | about execution  |                  |
89905 |                  |                 | time, for        |                  |
89906 |                  |                 | retrieval with   |                  |
89907 |                  |                 | stats().         |                  |
89908 +------------------+-----------------+------------------+------------------+
89909 | regularity_check | OT_BOOL         | Throw exceptions | casadi::Function |
89910 |                  |                 | when NaN or Inf  | Internal         |
89911 |                  |                 | appears during   |                  |
89912 |                  |                 | evaluation       |                  |
89913 +------------------+-----------------+------------------+------------------+
89914 | reverse_options  | OT_DICT         | Options to be    | casadi::Function |
89915 |                  |                 | passed to a      | Internal         |
89916 |                  |                 | reverse mode     |                  |
89917 |                  |                 | constructor      |                  |
89918 +------------------+-----------------+------------------+------------------+
89919 | user_data        | OT_VOIDPTR      | A user-defined   | casadi::Function |
89920 |                  |                 | field that can   | Internal         |
89921 |                  |                 | be used to       |                  |
89922 |                  |                 | identify the     |                  |
89923 |                  |                 | function or pass |                  |
89924 |                  |                 | additional       |                  |
89925 |                  |                 | information      |                  |
89926 +------------------+-----------------+------------------+------------------+
89927 | verbose          | OT_BOOL         | Verbose          | casadi::Function |
89928 |                  |                 | evaluation  for  | Internal         |
89929 |                  |                 | debugging        |                  |
89930 +------------------+-----------------+------------------+------------------+
89931 
89932 >Input scheme: casadi::ConicInput (CONIC_NUM_IN = 12)
89933 
89934 +--------------+--------+--------------------------------------------------+
89935 |  Full name   | Short  |                   Description                    |
89936 +==============+========+==================================================+
89937 | CONIC_H      | h      | The square matrix H: sparse, (n x n). Only the   |
89938 |              |        | lower triangular part is actually used. The      |
89939 |              |        | matrix is assumed to be symmetrical.             |
89940 +--------------+--------+--------------------------------------------------+
89941 | CONIC_G      | g      | The vector g: dense, (n x 1)                     |
89942 +--------------+--------+--------------------------------------------------+
89943 | CONIC_A      | a      | The matrix A: sparse, (nc x n) - product with x  |
89944 |              |        | must be dense.                                   |
89945 +--------------+--------+--------------------------------------------------+
89946 | CONIC_LBA    | lba    | dense, (nc x 1)                                  |
89947 +--------------+--------+--------------------------------------------------+
89948 | CONIC_UBA    | uba    | dense, (nc x 1)                                  |
89949 +--------------+--------+--------------------------------------------------+
89950 | CONIC_LBX    | lbx    | dense, (n x 1)                                   |
89951 +--------------+--------+--------------------------------------------------+
89952 | CONIC_UBX    | ubx    | dense, (n x 1)                                   |
89953 +--------------+--------+--------------------------------------------------+
89954 | CONIC_X0     | x0     | dense, (n x 1)                                   |
89955 +--------------+--------+--------------------------------------------------+
89956 | CONIC_LAM_X0 | lam_x0 | dense                                            |
89957 +--------------+--------+--------------------------------------------------+
89958 | CONIC_LAM_A0 | lam_a0 | dense                                            |
89959 +--------------+--------+--------------------------------------------------+
89960 | CONIC_Q      | q      | The matrix Q: sparse symmetric, (np^2 x n)       |
89961 +--------------+--------+--------------------------------------------------+
89962 | CONIC_P      | p      | The matrix P: sparse symmetric, (np x np)        |
89963 +--------------+--------+--------------------------------------------------+
89964 
89965 >Output scheme: casadi::ConicOutput (CONIC_NUM_OUT = 4)
89966 
89967 +-------------+-------+---------------------------------------------------+
89968 |  Full name  | Short |                    Description                    |
89969 +=============+=======+===================================================+
89970 | CONIC_X     | x     | The primal solution.                              |
89971 +-------------+-------+---------------------------------------------------+
89972 | CONIC_COST  | cost  | The optimal cost.                                 |
89973 +-------------+-------+---------------------------------------------------+
89974 | CONIC_LAM_A | lam_a | The dual solution corresponding to linear bounds. |
89975 +-------------+-------+---------------------------------------------------+
89976 | CONIC_LAM_X | lam_x | The dual solution corresponding to simple bounds. |
89977 +-------------+-------+---------------------------------------------------+
89978 
89979 List of plugins
89980 ===============
89981 
89982 
89983 
89984 - cbc
89985 
89986 - clp
89987 
89988 - cplex
89989 
89990 - gurobi
89991 
89992 - hpmpc
89993 
89994 - ooqp
89995 
89996 - osqp
89997 
89998 - qpoases
89999 
90000 - sqic
90001 
90002 - superscs
90003 
90004 - nlpsol
90005 
90006 - qrqp
90007 
90008 Note: some of the plugins in this list might not be available on your
90009 system. Also, there might be extra plugins available to you that are not
90010 listed here. You can obtain their documentation with
90011 Conic.doc(\"myextraplugin\")
90012 
90013 
90014 
90015 --------------------------------------------------------------------------------
90016 
90017 cbc
90018 ---
90019 
90020 
90021 
90022 Interface to Cbc solver for sparse Quadratic Programs
90023 
90024 >List of available options
90025 
90026 +-------------+-----------------------+------------------------------------+
90027 |     Id      |         Type          |            Description             |
90028 +=============+=======================+====================================+
90029 | cbc         | OT_DICT               | Options to be passed to CBC.Three  |
90030 |             |                       | sets of options are supported. The |
90031 |             |                       | first can be found in              |
90032 |             |                       | OsiSolverParameters.hpp. The       |
90033 |             |                       | second can be found in             |
90034 |             |                       | CbcModel.hpp. The third are        |
90035 |             |                       | options that can be passed to      |
90036 |             |                       | CbcMain1.                          |
90037 +-------------+-----------------------+------------------------------------+
90038 | hot_start   | OT_BOOL               | Hot start with x0 [Default false]. |
90039 +-------------+-----------------------+------------------------------------+
90040 | sos_groups  | OT_INTVECTORVECTOR    | Definition of SOS groups by        |
90041 |             |                       | indices.                           |
90042 +-------------+-----------------------+------------------------------------+
90043 | sos_types   | OT_INTVECTOR          | Specify 1 or 2 for each SOS group. |
90044 +-------------+-----------------------+------------------------------------+
90045 | sos_weights | OT_DOUBLEVECTORVECTOR | Weights corresponding to SOS       |
90046 |             |                       | entries.                           |
90047 +-------------+-----------------------+------------------------------------+
90048 
90049 --------------------------------------------------------------------------------
90050 
90051 
90052 
90053 --------------------------------------------------------------------------------
90054 
90055 clp
90056 ---
90057 
90058 
90059 
90060 Interface to Clp solver for sparse Quadratic Programs
90061 
90062 >List of available options
90063 
90064 +-----+---------+----------------------------------------------------------+
90065 | Id  |  Type   |                       Description                        |
90066 +=====+=========+==========================================================+
90067 | clp | OT_DICT | Options to be passed to CLP. A first set of options can  |
90068 |     |         | be found in ClpParameters.hpp. eg. 'PrimalTolerance'.    |
90069 |     |         | There are other options in additions. 'AutomaticScaling' |
90070 |     |         | (bool) is recognised. 'initial_solve' (default off)      |
90071 |     |         | activates the use of Clp's initialSolve.                 |
90072 |     |         | 'initial_solve_options' takes a dictionary with          |
90073 |     |         | following keys (see ClpSolve.hpp): SolveType (string),   |
90074 |     |         | PresolveType (string), NumberPasses, SpecialOptions      |
90075 |     |         | (intvectorvector), IndependentOptions (intvectorvector). |
90076 +-----+---------+----------------------------------------------------------+
90077 
90078 --------------------------------------------------------------------------------
90079 
90080 
90081 
90082 --------------------------------------------------------------------------------
90083 
90084 cplex
90085 -----
90086 
90087 
90088 
90089 Interface to Cplex solver for sparse Quadratic Programs
90090 
90091 >List of available options
90092 
90093 +---------------+-----------------------+----------------------------------+
90094 |      Id       |         Type          |           Description            |
90095 +===============+=======================+==================================+
90096 | cplex         | OT_DICT               | Options to be passed to CPLEX    |
90097 +---------------+-----------------------+----------------------------------+
90098 | dep_check     | OT_INT                | Detect redundant constraints.    |
90099 +---------------+-----------------------+----------------------------------+
90100 | dump_filename | OT_STRING             | The filename to dump to.         |
90101 +---------------+-----------------------+----------------------------------+
90102 | dump_to_file  | OT_BOOL               | Dumps QP to file in CPLEX        |
90103 |               |                       | format.                          |
90104 +---------------+-----------------------+----------------------------------+
90105 | mip_start     | OT_BOOL               | Hot start integers with x0       |
90106 |               |                       | [Default false].                 |
90107 +---------------+-----------------------+----------------------------------+
90108 | qp_method     | OT_INT                | Determines which CPLEX algorithm |
90109 |               |                       | to use.                          |
90110 +---------------+-----------------------+----------------------------------+
90111 | sos_groups    | OT_INTVECTORVECTOR    | Definition of SOS groups by      |
90112 |               |                       | indices.                         |
90113 +---------------+-----------------------+----------------------------------+
90114 | sos_types     | OT_INTVECTOR          | Specify 1 or 2 for each SOS      |
90115 |               |                       | group.                           |
90116 +---------------+-----------------------+----------------------------------+
90117 | sos_weights   | OT_DOUBLEVECTORVECTOR | Weights corresponding to SOS     |
90118 |               |                       | entries.                         |
90119 +---------------+-----------------------+----------------------------------+
90120 | tol           | OT_DOUBLE             | Tolerance of solver              |
90121 +---------------+-----------------------+----------------------------------+
90122 | warm_start    | OT_BOOL               | Use warm start with simplex      |
90123 |               |                       | methods (affects only the        |
90124 |               |                       | simplex methods).                |
90125 +---------------+-----------------------+----------------------------------+
90126 
90127 --------------------------------------------------------------------------------
90128 
90129 
90130 
90131 --------------------------------------------------------------------------------
90132 
90133 gurobi
90134 ------
90135 
90136 
90137 
90138 Interface to the GUROBI Solver for quadratic programming
90139 
90140 >List of available options
90141 
90142 +-------------+-----------------------+------------------------------------+
90143 |     Id      |         Type          |            Description             |
90144 +=============+=======================+====================================+
90145 | gurobi      | OT_DICT               | Options to be passed to gurobi.    |
90146 +-------------+-----------------------+------------------------------------+
90147 | sos_groups  | OT_INTVECTORVECTOR    | Definition of SOS groups by        |
90148 |             |                       | indices.                           |
90149 +-------------+-----------------------+------------------------------------+
90150 | sos_types   | OT_INTVECTOR          | Specify 1 or 2 for each SOS group. |
90151 +-------------+-----------------------+------------------------------------+
90152 | sos_weights | OT_DOUBLEVECTORVECTOR | Weights corresponding to SOS       |
90153 |             |                       | entries.                           |
90154 +-------------+-----------------------+------------------------------------+
90155 | vtype       | OT_STRINGVECTOR       | Type of variables: [CONTINUOUS|bin |
90156 |             |                       | ary|integer|semicont|semiint]      |
90157 +-------------+-----------------------+------------------------------------+
90158 
90159 --------------------------------------------------------------------------------
90160 
90161 
90162 
90163 --------------------------------------------------------------------------------
90164 
90165 hpmpc
90166 -----
90167 
90168 
90169 
90170 Interface to HMPC Solver
90171 
90172 In order to use this interface, you must:
90173 
90174 Decision variables must only by state and control, and the variable ordering
90175 must be [x0 u0 x1 u1 ...]
90176 
90177 The constraints must be in order: [ gap0 lincon0 gap1 lincon1 ]
90178 
90179 gap: Ak+1 = Ak xk + Bk uk lincon: yk= Ck xk + Dk uk
90180 
90181 
90182 
90183 ::
90184 
90185          A0 B0 -I
90186          C0 D0
90187                 A1 B1 -I
90188                 C1 D1
90189 
90190 
90191 
90192 where I must be a diagonal sparse matrix Either supply all of N, nx, ng, nu
90193 options or rely on automatic detection
90194 
90195 >List of available options
90196 
90197 +----------------+--------------+------------------------------------------+
90198 |       Id       |     Type     |               Description                |
90199 +================+==============+==========================================+
90200 | N              | OT_INT       | OCP horizon                              |
90201 +----------------+--------------+------------------------------------------+
90202 | blasfeo_target | OT_STRING    | hpmpc target                             |
90203 +----------------+--------------+------------------------------------------+
90204 | inf            | OT_DOUBLE    | HPMPC cannot handle infinities.          |
90205 |                |              | Infinities will be replaced by this      |
90206 |                |              | option's value.                          |
90207 +----------------+--------------+------------------------------------------+
90208 | max_iter       | OT_INT       | Max number of iterations                 |
90209 +----------------+--------------+------------------------------------------+
90210 | mu0            | OT_DOUBLE    | Max element in cost function as estimate |
90211 |                |              | of max multiplier                        |
90212 +----------------+--------------+------------------------------------------+
90213 | ng             | OT_INTVECTOR | Number of non-dynamic constraints,       |
90214 |                |              | length N+1                               |
90215 +----------------+--------------+------------------------------------------+
90216 | nu             | OT_INTVECTOR | Number of controls, length N             |
90217 +----------------+--------------+------------------------------------------+
90218 | nx             | OT_INTVECTOR | Number of states, length N+1             |
90219 +----------------+--------------+------------------------------------------+
90220 | print_level    | OT_INT       | Amount of diagnostic printing [Default:  |
90221 |                |              | 1].                                      |
90222 +----------------+--------------+------------------------------------------+
90223 | target         | OT_STRING    | hpmpc target                             |
90224 +----------------+--------------+------------------------------------------+
90225 | tol            | OT_DOUBLE    | Tolerance in the duality measure         |
90226 +----------------+--------------+------------------------------------------+
90227 | warm_start     | OT_BOOL      | Use warm-starting                        |
90228 +----------------+--------------+------------------------------------------+
90229 
90230 --------------------------------------------------------------------------------
90231 
90232 
90233 
90234 --------------------------------------------------------------------------------
90235 
90236 ooqp
90237 ----
90238 
90239 
90240 
90241 Interface to the OOQP Solver for quadratic programming The current
90242 implementation assumes that OOQP is configured with the MA27 sparse linear
90243 solver.
90244 
90245 NOTE: when doing multiple calls to evaluate(), check if you need to
90246 reInit();
90247 
90248 >List of available options
90249 
90250 +-------------+-----------+------------------------------------------------+
90251 |     Id      |   Type    |                  Description                   |
90252 +=============+===========+================================================+
90253 | artol       | OT_DOUBLE | tolerance as provided with setArTol to OOQP    |
90254 +-------------+-----------+------------------------------------------------+
90255 | mutol       | OT_DOUBLE | tolerance as provided with setMuTol to OOQP    |
90256 +-------------+-----------+------------------------------------------------+
90257 | print_level | OT_INT    | Print level. OOQP listens to print_level 0, 10 |
90258 |             |           | and 100                                        |
90259 +-------------+-----------+------------------------------------------------+
90260 
90261 --------------------------------------------------------------------------------
90262 
90263 
90264 
90265 --------------------------------------------------------------------------------
90266 
90267 osqp
90268 ----
90269 
90270 
90271 
90272 Interface to the OSQP Solver for quadratic programming
90273 
90274 >List of available options
90275 
90276 +-------------------+---------+--------------------------------------------+
90277 |        Id         |  Type   |                Description                 |
90278 +===================+=========+============================================+
90279 | osqp              | OT_DICT | const Options to be passed to osqp.        |
90280 +-------------------+---------+--------------------------------------------+
90281 | warm_start_dual   | OT_BOOL | Use lam_a0 and lam_x0 input to warmstart   |
90282 |                   |         | [Default: truw].                           |
90283 +-------------------+---------+--------------------------------------------+
90284 | warm_start_primal | OT_BOOL | Use x0 input to warmstart [Default: true]. |
90285 +-------------------+---------+--------------------------------------------+
90286 
90287 --------------------------------------------------------------------------------
90288 
90289 
90290 
90291 --------------------------------------------------------------------------------
90292 
90293 qpoases
90294 -------
90295 
90296 
90297 
90298 Interface to QPOases Solver for quadratic programming
90299 
90300 >List of available options
90301 
90302 +-------------------------------+-----------+------------------------------+
90303 |              Id               |   Type    |         Description          |
90304 +===============================+===========+==============================+
90305 | CPUtime                       | OT_DOUBLE | The maximum allowed CPU time |
90306 |                               |           | in seconds for the whole     |
90307 |                               |           | initialisation (and the      |
90308 |                               |           | actually required one on     |
90309 |                               |           | output). Disabled if unset.  |
90310 +-------------------------------+-----------+------------------------------+
90311 | boundRelaxation               | OT_DOUBLE | Initial relaxation of bounds |
90312 |                               |           | to start homotopy and        |
90313 |                               |           | initial value for far        |
90314 |                               |           | bounds.                      |
90315 +-------------------------------+-----------+------------------------------+
90316 | boundTolerance                | OT_DOUBLE | If upper and lower bounds    |
90317 |                               |           | differ less than this        |
90318 |                               |           | tolerance, they are regarded |
90319 |                               |           | equal, i.e. as equality      |
90320 |                               |           | constraint.                  |
90321 +-------------------------------+-----------+------------------------------+
90322 | enableCholeskyRefactorisation | OT_INT    | Specifies the frequency of a |
90323 |                               |           | full re-factorisation of     |
90324 |                               |           | projected Hessian matrix: 0: |
90325 |                               |           | turns them off, 1: uses them |
90326 |                               |           | at each iteration etc.       |
90327 +-------------------------------+-----------+------------------------------+
90328 | enableDriftCorrection         | OT_INT    | Specifies the frequency of   |
90329 |                               |           | drift corrections: 0: turns  |
90330 |                               |           | them off.                    |
90331 +-------------------------------+-----------+------------------------------+
90332 | enableEqualities              | OT_BOOL   | Specifies whether equalities |
90333 |                               |           | should be treated as always  |
90334 |                               |           | active (True) or not (False) |
90335 +-------------------------------+-----------+------------------------------+
90336 | enableFarBounds               | OT_BOOL   | Enables the use of far       |
90337 |                               |           | bounds.                      |
90338 +-------------------------------+-----------+------------------------------+
90339 | enableFlippingBounds          | OT_BOOL   | Enables the use of flipping  |
90340 |                               |           | bounds.                      |
90341 +-------------------------------+-----------+------------------------------+
90342 | enableFullLITests             | OT_BOOL   | Enables condition-hardened   |
90343 |                               |           | (but more expensive) LI      |
90344 |                               |           | test.                        |
90345 +-------------------------------+-----------+------------------------------+
90346 | enableInertiaCorrection       | OT_BOOL   | Should working set be        |
90347 |                               |           | repaired when negative       |
90348 |                               |           | curvature is discovered      |
90349 |                               |           | during hotstart.             |
90350 +-------------------------------+-----------+------------------------------+
90351 | enableNZCTests                | OT_BOOL   | Enables nonzero curvature    |
90352 |                               |           | tests.                       |
90353 +-------------------------------+-----------+------------------------------+
90354 | enableRamping                 | OT_BOOL   | Enables ramping.             |
90355 +-------------------------------+-----------+------------------------------+
90356 | enableRegularisation          | OT_BOOL   | Enables automatic Hessian    |
90357 |                               |           | regularisation.              |
90358 +-------------------------------+-----------+------------------------------+
90359 | epsDen                        | OT_DOUBLE | Denominator tolerance for    |
90360 |                               |           | ratio tests.                 |
90361 +-------------------------------+-----------+------------------------------+
90362 | epsFlipping                   | OT_DOUBLE | Tolerance of squared         |
90363 |                               |           | Cholesky diagonal factor     |
90364 |                               |           | which triggers flipping      |
90365 |                               |           | bound.                       |
90366 +-------------------------------+-----------+------------------------------+
90367 | epsIterRef                    | OT_DOUBLE | Early termination tolerance  |
90368 |                               |           | for iterative refinement.    |
90369 +-------------------------------+-----------+------------------------------+
90370 | epsLITests                    | OT_DOUBLE | Tolerance for linear         |
90371 |                               |           | independence tests.          |
90372 +-------------------------------+-----------+------------------------------+
90373 | epsNZCTests                   | OT_DOUBLE | Tolerance for nonzero        |
90374 |                               |           | curvature tests.             |
90375 +-------------------------------+-----------+------------------------------+
90376 | epsNum                        | OT_DOUBLE | Numerator tolerance for      |
90377 |                               |           | ratio tests.                 |
90378 +-------------------------------+-----------+------------------------------+
90379 | epsRegularisation             | OT_DOUBLE | Scaling factor of identity   |
90380 |                               |           | matrix used for Hessian      |
90381 |                               |           | regularisation.              |
90382 +-------------------------------+-----------+------------------------------+
90383 | finalRamping                  | OT_DOUBLE | Final value for ramping      |
90384 |                               |           | strategy.                    |
90385 +-------------------------------+-----------+------------------------------+
90386 | growFarBounds                 | OT_DOUBLE | Factor to grow far bounds.   |
90387 +-------------------------------+-----------+------------------------------+
90388 | hessian_type                  | OT_STRING | Type of Hessian - see        |
90389 |                               |           | qpOASES documentation [UNKNO |
90390 |                               |           | WN|posdef|semidef|indef|zero |
90391 |                               |           | |identity]]                  |
90392 +-------------------------------+-----------+------------------------------+
90393 | initialFarBounds              | OT_DOUBLE | Initial size for far bounds. |
90394 +-------------------------------+-----------+------------------------------+
90395 | initialRamping                | OT_DOUBLE | Start value for ramping      |
90396 |                               |           | strategy.                    |
90397 +-------------------------------+-----------+------------------------------+
90398 | initialStatusBounds           | OT_STRING | Initial status of bounds at  |
90399 |                               |           | first iteration.             |
90400 +-------------------------------+-----------+------------------------------+
90401 | linsol_plugin                 | OT_STRING | Linear solver plugin         |
90402 +-------------------------------+-----------+------------------------------+
90403 | maxDualJump                   | OT_DOUBLE | Maximum allowed jump in dual |
90404 |                               |           | variables in linear          |
90405 |                               |           | independence tests.          |
90406 +-------------------------------+-----------+------------------------------+
90407 | maxPrimalJump                 | OT_DOUBLE | Maximum allowed jump in      |
90408 |                               |           | primal variables in nonzero  |
90409 |                               |           | curvature tests.             |
90410 +-------------------------------+-----------+------------------------------+
90411 | max_schur                     | OT_INT    | Maximal number of Schur      |
90412 |                               |           | updates [75]                 |
90413 +-------------------------------+-----------+------------------------------+
90414 | nWSR                          | OT_INT    | The maximum number of        |
90415 |                               |           | working set recalculations   |
90416 |                               |           | to be performed during the   |
90417 |                               |           | initial homotopy. Default is |
90418 |                               |           | 5(nx + nc)                   |
90419 +-------------------------------+-----------+------------------------------+
90420 | numRefinementSteps            | OT_INT    | Maximum number of iterative  |
90421 |                               |           | refinement steps.            |
90422 +-------------------------------+-----------+------------------------------+
90423 | numRegularisationSteps        | OT_INT    | Maximum number of successive |
90424 |                               |           | regularisation steps.        |
90425 +-------------------------------+-----------+------------------------------+
90426 | printLevel                    | OT_STRING | Defines the amount of text   |
90427 |                               |           | output during QP solution,   |
90428 |                               |           | see Section 5.7              |
90429 +-------------------------------+-----------+------------------------------+
90430 | schur                         | OT_BOOL   | Use Schur Complement         |
90431 |                               |           | Approach [false]             |
90432 +-------------------------------+-----------+------------------------------+
90433 | sparse                        | OT_BOOL   | Formulate the QP using       |
90434 |                               |           | sparse matrices. [false]     |
90435 +-------------------------------+-----------+------------------------------+
90436 | terminationTolerance          | OT_DOUBLE | Relative termination         |
90437 |                               |           | tolerance to stop homotopy.  |
90438 +-------------------------------+-----------+------------------------------+
90439 
90440 --------------------------------------------------------------------------------
90441 
90442 
90443 
90444 --------------------------------------------------------------------------------
90445 
90446 sqic
90447 ----
90448 
90449 
90450 
90451 Interface to the SQIC solver for quadratic programming
90452 
90453 --------------------------------------------------------------------------------
90454 
90455 
90456 
90457 
90458 
90459 --------------------------------------------------------------------------------
90460 
90461 superscs
90462 --------
90463 
90464 
90465 
90466 Interface to the SuperSCS solver for conic programming
90467 
90468 Joris Gillis, 2019
90469 
90470 >List of available options
90471 
90472 +----------+---------+-----------------------------------+
90473 |    Id    |  Type   |            Description            |
90474 +==========+=========+===================================+
90475 | superscs | OT_DICT | Options to be passed to superscs. |
90476 +----------+---------+-----------------------------------+
90477 
90478 --------------------------------------------------------------------------------
90479 
90480 
90481 
90482 --------------------------------------------------------------------------------
90483 
90484 nlpsol
90485 ------
90486 
90487 
90488 
90489 Solve QPs using an Nlpsol Use the 'nlpsol' option to specify the NLP solver
90490 to use.
90491 
90492 >List of available options
90493 
90494 +----------------+-----------+---------------------------------+
90495 |       Id       |   Type    |           Description           |
90496 +================+===========+=================================+
90497 | nlpsol         | OT_STRING | Name of solver.                 |
90498 +----------------+-----------+---------------------------------+
90499 | nlpsol_options | OT_DICT   | Options to be passed to solver. |
90500 +----------------+-----------+---------------------------------+
90501 
90502 --------------------------------------------------------------------------------
90503 
90504 
90505 
90506 --------------------------------------------------------------------------------
90507 
90508 qrqp
90509 ----
90510 
90511 
90512 
90513 Solve QPs using an active-set method
90514 
90515 >List of available options
90516 
90517 +-----------------+-----------+--------------------------------------------+
90518 |       Id        |   Type    |                Description                 |
90519 +=================+===========+============================================+
90520 | constr_viol_tol | OT_DOUBLE | Constraint violation tolerance [1e-8].     |
90521 +-----------------+-----------+--------------------------------------------+
90522 | dual_inf_tol    | OT_DOUBLE | Dual feasibility violation tolerance       |
90523 |                 |           | [1e-8]                                     |
90524 +-----------------+-----------+--------------------------------------------+
90525 | max_iter        | OT_INT    | Maximum number of iterations [1000].       |
90526 +-----------------+-----------+--------------------------------------------+
90527 | min_lam         | OT_DOUBLE | Smallest multiplier treated as inactive    |
90528 |                 |           | for the initial active set [0].            |
90529 +-----------------+-----------+--------------------------------------------+
90530 | print_header    | OT_BOOL   | Print header [true].                       |
90531 +-----------------+-----------+--------------------------------------------+
90532 | print_info      | OT_BOOL   | Print info [true].                         |
90533 +-----------------+-----------+--------------------------------------------+
90534 | print_iter      | OT_BOOL   | Print iterations [true].                   |
90535 +-----------------+-----------+--------------------------------------------+
90536 | print_lincomb   | OT_BOOL   | Print dependant linear combinations of     |
90537 |                 |           | constraints [false]. Printed numbers are   |
90538 |                 |           | 0-based indices into the vector of [simple |
90539 |                 |           | bounds;linear bounds]                      |
90540 +-----------------+-----------+--------------------------------------------+
90541 
90542 --------------------------------------------------------------------------------
90543 
90544 
90545 
90546 Joel Andersson
90547 
90548 ";
90549 
90550 %feature("docstring")  casadi::casadi_qp_reset(casadi_qp_data< T1 > *d) "
90551 
90552 [INTERNAL] ";
90553 
90554 %feature("docstring")  casadi::casadi_qp_pr(casadi_qp_data< T1 > *d) "
90555 
90556 [INTERNAL] ";
90557 
90558 %feature("docstring")  casadi::doc_integrator(const std::string &name) "
90559 
90560 Get the documentation string for a plugin.
90561 
90562 ";
90563 
90564 %feature("docstring")  casadi::simpleIRK(Function f, casadi_int N=10,
90565 casadi_int order=4, const std::string &scheme="radau", const std::string
90566 &solver="newton", const Dict &solver_options=Dict()) "
90567 
90568 Construct an implicit Runge-Kutta integrator using a collocation scheme The
90569 constructed function has three inputs, corresponding to initial state (x0),
90570 parameter (p) and integration time (h) and one output, corresponding to
90571 final state (xf).
90572 
90573 Parameters:
90574 -----------
90575 
90576 f:  ODE function with two inputs (x and p) and one output (xdot)
90577 
90578 N:  Number of integrator steps
90579 
90580 order:  Order of interpolating polynomials
90581 
90582 scheme:   Collocation scheme, as excepted by collocationPoints function.
90583 
90584 solver:  Solver plugin
90585 
90586 solver_options:  Options to be passed to the solver plugin
90587 
90588 ";
90589 
90590 %feature("docstring")  casadi::cache_check(const T1 *key, T1 *cache, int
90591 *loc, casadi_int stride, casadi_int sz, casadi_int key_sz, T1 **val) "
90592 
90593 [INTERNAL] ";
90594 
90595 %feature("docstring")  casadi::nlpsol_option_type(const std::string &name,
90596 const std::string &op) "
90597 
90598 Get type info for a particular option.
90599 
90600 ";
90601 
90602 %feature("docstring")  casadi::casadi_axpy(casadi_int n, T1 alpha, const T1
90603 *x, T1 *y) "
90604 
90605 [INTERNAL]  AXPY: y <- a*x + y.
90606 
90607 ";
90608 
90609 %feature("docstring")  casadi::has_nlpsol(const std::string &name) "
90610 
90611 Check if a particular plugin is available.
90612 
90613 ";
90614 
90615 %feature("docstring")  casadi::casadi_getu(const T1 *x, const casadi_int
90616 *sp_x, T1 *v) "
90617 
90618 [INTERNAL]  Get the nonzeros for the upper triangular half.
90619 
90620 ";
90621 
90622 %feature("docstring")  casadi::doc_nlpsol(const std::string &name) "
90623 
90624 Get the documentation string for a plugin.
90625 
90626 ";
90627 
90628 %feature("docstring")  casadi::casadi_sqpmethod_work(const
90629 casadi_sqpmethod_prob< T1 > *p, casadi_int *sz_iw, casadi_int *sz_w) "
90630 
90631 [INTERNAL] ";
90632 
90633 %feature("docstring")  casadi::casadi_densify(const T1 *x, const casadi_int
90634 *sp_x, T2 *y, casadi_int tr) "
90635 
90636 [INTERNAL]  Convert sparse to dense.
90637 
90638 ";
90639 
90640 %feature("docstring")  casadi::rootfinder_options(const std::string &name) "
90641 
90642 Get all options for a plugin.
90643 
90644 ";
90645 
90646 %feature("docstring")  casadi::zip(const std::vector< std::string > &id,
90647 const std::vector< T > &mat) "
90648 
90649 [INTERNAL] ";
90650 
90651 %feature("docstring")  casadi::casadi_max_viol(casadi_int n, const T1 *x,
90652 const T1 *lb, const T1 *ub) "
90653 
90654 [INTERNAL]  Largest bound violation.
90655 
90656 ";
90657 
90658 %feature("docstring")  casadi::casadi_qp_factorize(casadi_qp_data< T1 > *d)
90659 "
90660 
90661 [INTERNAL] ";
90662 
90663 %feature("docstring")  casadi::collocation_interpolators(const std::vector<
90664 double > &tau, std::vector< std::vector< double > > &output_C, std::vector<
90665 double > &output_D) "
90666 
90667 Obtain collocation interpolating matrices.
90668 
90669 A collocation method poses a polynomial Pi that interpolates exactly through
90670 an initial state (0,X_0) and helper states at collocation points
90671 (tau_j,X(j)).
90672 
90673 This function computes the linear mapping between dPi/dt and coefficients
90674 Z=[X_0 X].
90675 
90676 Parameters:
90677 -----------
90678 
90679 tau:  location of collocation points, as obtained from collocation_points
90680 
90681 output_C:  interpolating coefficients to obtain derivatives. Length:
90682 order+1, order+1
90683 
90684 
90685 
90686 ::
90687 
90688 dPi/dt @Z_j = (1/h) Sum_i C[j][i]*Z_i,
90689 
90690 
90691 
90692 with h the length of the integration interval.
90693 
90694 Parameters:
90695 -----------
90696 
90697 output_D:  interpolating coefficients to obtain end state. Length: order+1
90698 
90699 
90700 
90701 ::
90702 
90703 Pi @X_f = Sum_i D[i]*Z_i
90704 
90705 
90706 
90707 ";
90708 
90709 %feature("docstring")  casadi::casadi_cvx_tri(T1 *A, casadi_int n, T1 *p) "
90710 
90711 [INTERNAL] ";
90712 
90713 %feature("docstring")  casadi::is_nonincreasing(const std::vector< T > &v) "
90714 
90715 Check if the vector is non-increasing.
90716 
90717 ";
90718 
90719 %feature("docstring")  casadi::nlpsol_n_in() "
90720 
90721 Number of NLP solver inputs.
90722 
90723 ";
90724 
90725 %feature("docstring")  casadi::matrixName() "
90726 
90727 Get typename.
90728 
90729 ";
90730 
90731 %feature("docstring")  casadi::load_dple(const std::string &name) "
90732 
90733 Explicitly load a plugin dynamically.
90734 
90735 ";
90736 
90737 %feature("docstring")  casadi::ConstantSX_deserialize(DeserializingStream
90738 &s) "
90739 
90740 [INTERNAL] ";
90741 
90742 %feature("docstring")  casadi::casadi_qp_expand_step(casadi_qp_data< T1 >
90743 *d) "
90744 
90745 [INTERNAL] ";
90746 
90747 %feature("docstring")  casadi::integrator_in() "
90748 
90749 Get input scheme of integrators.
90750 
90751 ";
90752 
90753 %feature("docstring")  casadi::integrator_in(casadi_int ind) "
90754 
90755 Get integrator input scheme name by index.
90756 
90757 ";
90758 
90759 %feature("docstring")  casadi::is_regular(const std::vector< T > &v) "
90760 
90761 Checks if array does not contain NaN or Inf.
90762 
90763 ";
90764 
90765 %feature("docstring")  casadi::is_regular(N_Vector v) "
90766 
90767 [INTERNAL] ";
90768 
90769 %feature("docstring")  casadi::casadi_vfmax(const T1 *x, casadi_int n, T1 r)
90770 "
90771 
90772 [INTERNAL] ";
90773 
90774 %feature("docstring")  casadi::casadi_regularize(const casadi_int *sp_h, T1
90775 *h, T1 reg) "
90776 
90777 [INTERNAL] ";
90778 
90779 %feature("docstring")  casadi::casadi_ldl_solve(T1 *x, casadi_int nrhs,
90780 const casadi_int *sp_lt, const T1 *lt, const T1 *d, const casadi_int *p, T1
90781 *w) "
90782 
90783 [INTERNAL] ";
90784 
90785 %feature("docstring")  casadi::casadi_qp_singular_step(casadi_qp_data< T1 >
90786 *d) "
90787 
90788 [INTERNAL] ";
90789 
90790 %feature("docstring")  casadi::casadi_kron(const T1 *a, const casadi_int
90791 *sp_a, const T1 *b, const casadi_int *sp_b, T1 *r) "
90792 
90793 [INTERNAL]  Calculates Calculates nonzeros of kronecker product
90794 
90795 ";
90796 
90797 %feature("docstring")  casadi::nlpsol_option_info(const std::string &name,
90798 const std::string &op) "
90799 
90800 Get documentation for a particular option.
90801 
90802 ";
90803 
90804 %feature("docstring")  casadi::casadi_qp_kkt_vector(casadi_qp_data< T1 > *d,
90805 T1 *kkt_i, casadi_int i) "
90806 
90807 [INTERNAL] ";
90808 
90809 %feature("docstring")  casadi::hash_value(T v) "
90810 
90811 Hash value of an integer.
90812 
90813 ";
90814 
90815 %feature("docstring")  casadi::casadi_polyval(const T1 *p, casadi_int n, T1
90816 x) "
90817 
90818 [INTERNAL]  Evaluate a polynomial.
90819 
90820 ";
90821 
90822 %feature("docstring")  casadi::casadi_house(T1 *v, T1 *beta, casadi_int nv)
90823 "
90824 
90825 [INTERNAL] ";
90826 
90827 %feature("docstring")  casadi::dense_mul_nt(casadi_int n, casadi_int m,
90828 casadi_int l, const double *A, const double *B, double *C) "
90829 
90830 [INTERNAL] ";
90831 
90832 %feature("docstring")  casadi::rootfinder_n_out() "
90833 
90834 Number of rootfinder outputs.
90835 
90836 ";
90837 
90838 %feature("docstring")  casadi::casadi_flip(casadi_int *corner, casadi_int
90839 ndim) "
90840 
90841 [INTERNAL] ";
90842 
90843 %feature("docstring")  casadi::simpleIntegrator(Function f, const
90844 std::string &integrator="cvodes", const Dict &integrator_options=Dict()) "
90845 
90846 Simplified wrapper for the Integrator class Constructs an integrator using
90847 the same syntax as simpleRK and simpleIRK. The constructed function has
90848 three inputs, corresponding to initial state (x0), parameter (p) and
90849 integration time (h) and one output, corresponding to final state (xf).
90850 
90851 Parameters:
90852 -----------
90853 
90854 f:  ODE function with two inputs (x and p) and one output (xdot)
90855 
90856 N:  Number of integrator steps
90857 
90858 order:  Order of interpolating polynomials
90859 
90860 scheme:   Collocation scheme, as excepted by collocationPoints function.
90861 
90862 ";
90863 
90864 %feature("docstring")  casadi::casadi_interpn_interpolate(casadi_int ndim,
90865 const casadi_int *offset, const T1 *values, const T1 *alpha, const
90866 casadi_int *index, const casadi_int *corner, T1 *coeff) "
90867 
90868 [INTERNAL] ";
90869 
90870 %feature("docstring")  casadi::casadi_interpn_interpolate(T1 *res,
90871 casadi_int ndim, const casadi_int *offset, const T1 *values, const T1
90872 *alpha, const casadi_int *index, const casadi_int *corner, T1 *coeff,
90873 casadi_int m) "
90874 
90875 [INTERNAL] ";
90876 
90877 %feature("docstring")  casadi::casadi_copy(const T1 *x, casadi_int n, T1 *y)
90878 "
90879 
90880 [INTERNAL]  COPY: y <-x.
90881 
90882 ";
90883 
90884 %feature("docstring")  casadi::nlpsol_default_in(casadi_int ind) "
90885 
90886 Default input for an NLP solver.
90887 
90888 ";
90889 
90890 %feature("docstring")  casadi::nlpsol_default_in() "
90891 
90892 Default input for an NLP solver.
90893 
90894 ";
90895 
90896 %feature("docstring")  casadi::casadi_lsqr_sym_ortho(T1 a, T1 b, T1 *cs, T1
90897 *sn, T1 *rho) "
90898 
90899 [INTERNAL] ";
90900 
90901 %feature("docstring")  casadi::casadi_norm_inf(casadi_int n, const T1 *x) "
90902 
90903 [INTERNAL]  Inf-norm of a vector * Returns the largest element in absolute
90904 value
90905 
90906 ";
90907 
90908 %feature("docstring")  casadi::casadi_ldl_trs(const casadi_int *sp_r, const
90909 T1 *nz_r, T1 *x, casadi_int tr) "
90910 
90911 [INTERNAL] ";
90912 
90913 %feature("docstring")  casadi::has_rootfinder(const std::string &name) "
90914 
90915 Check if a particular plugin is available.
90916 
90917 ";
90918 
90919 %feature("docstring")  casadi::conic_n_out() "
90920 
90921 Get the number of QP solver outputs.
90922 
90923 ";
90924 
90925 %feature("docstring")  casadi::casadi_nd_boor_dual_eval(T1 *val, casadi_int
90926 *nz, casadi_int n_dims, const T1 *all_knots, const casadi_int *offset, const
90927 casadi_int *all_degree, const casadi_int *strides, const T1 *all_x, const
90928 casadi_int *lookup_mode, casadi_int *iw, T1 *w) "
90929 
90930 [INTERNAL] ";
90931 
90932 %feature("docstring")  casadi::casadi_qr_colcomb(T1 *v, const T1 *nz_r,
90933 const casadi_int *sp_r, const casadi_int *pc, T1 eps, casadi_int ind) "
90934 
90935 [INTERNAL] ";
90936 
90937 %feature("docstring")  casadi::casadi_project(const T1 *x, const casadi_int
90938 *sp_x, T1 *y, const casadi_int *sp_y, T1 *w) "
90939 
90940 [INTERNAL]  Sparse copy: y <- x, w work vector (length >= number of rows)
90941 
90942 ";
90943 
90944 %feature("docstring")  casadi::casadi_qp_calc_dependent(casadi_qp_data< T1 >
90945 *d) "
90946 
90947 [INTERNAL] ";
90948 
90949 %feature("docstring")  casadi::casadi_qp_print_header(casadi_qp_data< T1 >
90950 *d, char *buf, size_t buf_sz) "
90951 
90952 [INTERNAL] ";
90953 
90954 %feature("docstring")  casadi::interpolant(const std::string &name, const
90955 std::string &solver, const std::vector< std::vector< double > > &grid, const
90956 std::vector< double > &values, const Dict &opts=Dict()) "
90957 
90958 An interpolant function for lookup table data
90959 
90960 Parameters:
90961 -----------
90962 
90963 name:  label for the resulting Function
90964 
90965 solver:  name of the plugin
90966 
90967 grid:  collection of 1D grids whose outer product defines the full N-D
90968 rectangular grid
90969 
90970 values:  flattened vector of all values for all gridpoints
90971 
90972 Syntax 1D
90973 
90974 ::
90975 
90976   * # Python
90977   * xgrid = np.linspace(1,6,6)
90978   * V = [-1,-1,-2,-3,0,2]
90979   * LUT = casadi.interpolant(\"LUT\",\"bspline\",[xgrid],V)
90980   * print(LUT(2.5))
90981   *
90982 
90983 
90984 
90985 ::
90986 
90987   * % Matlab
90988   * xgrid = 1:6;
90989   * V = [-1 -1 -2 -3 0 2];
90990   * LUT = casadi.interpolant('LUT','bspline',{xgrid},V);
90991   * LUT(2.5)
90992   *
90993 
90994 
90995 
90996 Syntax 2D
90997 
90998 ::
90999 
91000   * # Python
91001   * xgrid = np.linspace(-5,5,11)
91002   * ygrid = np.linspace(-4,4,9)
91003   * X,Y = np.meshgrid(xgrid,ygrid,indexing='ij')
91004   * R = np.sqrt(5*X**2 + Y**2)+ 1
91005   * data = np.sin(R)/R
91006   * data_flat = data.ravel(order='F')
91007   * LUT = casadi.interpolant('name','bspline',[xgrid,ygrid],data_flat)
91008   * print(LUT([0.5,1]))
91009   * \\\\enverbatim
91010   * \\\\verbatim
91011   * % Matlab
91012   * xgrid = -5:1:5;
91013   * ygrid = -4:1:4;
91014   * R = sqrt(5*X.^2 + Y.^2)+ 1;
91015   * V = sin(R)./(R);
91016   * LUT = interpolant('LUT','bspline',{xgrid, ygrid},V(:));
91017   * LUT([0.5 1])
91018   *
91019 
91020 
91021 
91022 General information
91023 ===================
91024 
91025 
91026 
91027 >List of available options
91028 
91029 +------------------+-----------------+------------------+------------------+
91030 |        Id        |      Type       |   Description    |     Used in      |
91031 +==================+=================+==================+==================+
91032 | ad_weight        | OT_DOUBLE       | Weighting factor | casadi::Function |
91033 |                  |                 | for derivative   | Internal         |
91034 |                  |                 | calculation.When |                  |
91035 |                  |                 | there is an      |                  |
91036 |                  |                 | option of either |                  |
91037 |                  |                 | using forward or |                  |
91038 |                  |                 | reverse mode     |                  |
91039 |                  |                 | directional      |                  |
91040 |                  |                 | derivatives, the |                  |
91041 |                  |                 | condition ad_wei |                  |
91042 |                  |                 | ght*nf<=(1-ad_we |                  |
91043 |                  |                 | ight)*na is used |                  |
91044 |                  |                 | where nf and na  |                  |
91045 |                  |                 | are estimates of |                  |
91046 |                  |                 | the number of    |                  |
91047 |                  |                 | forward/reverse  |                  |
91048 |                  |                 | mode directional |                  |
91049 |                  |                 | derivatives      |                  |
91050 |                  |                 | needed. By       |                  |
91051 |                  |                 | default,         |                  |
91052 |                  |                 | ad_weight is     |                  |
91053 |                  |                 | calculated       |                  |
91054 |                  |                 | automatically,   |                  |
91055 |                  |                 | but this can be  |                  |
91056 |                  |                 | overridden by    |                  |
91057 |                  |                 | setting this     |                  |
91058 |                  |                 | option. In       |                  |
91059 |                  |                 | particular, 0    |                  |
91060 |                  |                 | means forcing    |                  |
91061 |                  |                 | forward mode and |                  |
91062 |                  |                 | 1 forcing        |                  |
91063 |                  |                 | reverse mode.    |                  |
91064 |                  |                 | Leave unset for  |                  |
91065 |                  |                 | (class specific) |                  |
91066 |                  |                 | heuristics.      |                  |
91067 +------------------+-----------------+------------------+------------------+
91068 | ad_weight_sp     | OT_DOUBLE       | Weighting factor | casadi::Function |
91069 |                  |                 | for sparsity     | Internal         |
91070 |                  |                 | pattern          |                  |
91071 |                  |                 | calculation calc |                  |
91072 |                  |                 | ulation.Override |                  |
91073 |                  |                 | s default        |                  |
91074 |                  |                 | behavior. Set to |                  |
91075 |                  |                 | 0 and 1 to force |                  |
91076 |                  |                 | forward and      |                  |
91077 |                  |                 | reverse mode     |                  |
91078 |                  |                 | respectively.    |                  |
91079 |                  |                 | Cf. option       |                  |
91080 |                  |                 | \"ad_weight\".     |                  |
91081 |                  |                 | When set to -1,  |                  |
91082 |                  |                 | sparsity is      |                  |
91083 |                  |                 | completely       |                  |
91084 |                  |                 | ignored and      |                  |
91085 |                  |                 | dense matrices   |                  |
91086 |                  |                 | are used.        |                  |
91087 +------------------+-----------------+------------------+------------------+
91088 | always_inline    | OT_BOOL         | Force inlining.  | casadi::Function |
91089 |                  |                 |                  | Internal         |
91090 +------------------+-----------------+------------------+------------------+
91091 | batch_x          | OT_INT          | Evaluate a batch | casadi::Interpol |
91092 |                  |                 | of different     | ant              |
91093 |                  |                 | inputs at once   |                  |
91094 |                  |                 | (default 1).     |                  |
91095 +------------------+-----------------+------------------+------------------+
91096 | compiler         | OT_STRING       | Just-in-time     | casadi::Function |
91097 |                  |                 | compiler plugin  | Internal         |
91098 |                  |                 | to be used.      |                  |
91099 +------------------+-----------------+------------------+------------------+
91100 | custom_jacobian  | OT_FUNCTION     | Override         | casadi::Function |
91101 |                  |                 | CasADi's AD. Use | Internal         |
91102 |                  |                 | together with    |                  |
91103 |                  |                 | 'jac_penalty':   |                  |
91104 |                  |                 | 0. Note: Highly  |                  |
91105 |                  |                 | experimental.    |                  |
91106 |                  |                 | Syntax may break |                  |
91107 |                  |                 | often.           |                  |
91108 +------------------+-----------------+------------------+------------------+
91109 | derivative_of    | OT_FUNCTION     | The function is  | casadi::Function |
91110 |                  |                 | a derivative of  | Internal         |
91111 |                  |                 | another          |                  |
91112 |                  |                 | function. The    |                  |
91113 |                  |                 | type of          |                  |
91114 |                  |                 | derivative       |                  |
91115 |                  |                 | (directional     |                  |
91116 |                  |                 | derivative,      |                  |
91117 |                  |                 | Jacobian) is     |                  |
91118 |                  |                 | inferred from    |                  |
91119 |                  |                 | the function     |                  |
91120 |                  |                 | name.            |                  |
91121 +------------------+-----------------+------------------+------------------+
91122 | dump             | OT_BOOL         | Dump function to | casadi::Function |
91123 |                  |                 | file upon first  | Internal         |
91124 |                  |                 | evaluation.      |                  |
91125 |                  |                 | [false]          |                  |
91126 +------------------+-----------------+------------------+------------------+
91127 | dump_dir         | OT_STRING       | Directory to     | casadi::Function |
91128 |                  |                 | dump             | Internal         |
91129 |                  |                 | inputs/outputs   |                  |
91130 |                  |                 | to. Make sure    |                  |
91131 |                  |                 | the directory    |                  |
91132 |                  |                 | exists [.]       |                  |
91133 +------------------+-----------------+------------------+------------------+
91134 | dump_format      | OT_STRING       | Choose file      | casadi::Function |
91135 |                  |                 | format to dump   | Internal         |
91136 |                  |                 | matrices. See    |                  |
91137 |                  |                 | DM.from_file     |                  |
91138 |                  |                 | [mtx]            |                  |
91139 +------------------+-----------------+------------------+------------------+
91140 | dump_in          | OT_BOOL         | Dump numerical   | casadi::Function |
91141 |                  |                 | values of inputs | Internal         |
91142 |                  |                 | to file          |                  |
91143 |                  |                 | (readable with   |                  |
91144 |                  |                 | DM.from_file )   |                  |
91145 |                  |                 | [default: false] |                  |
91146 +------------------+-----------------+------------------+------------------+
91147 | dump_out         | OT_BOOL         | Dump numerical   | casadi::Function |
91148 |                  |                 | values of        | Internal         |
91149 |                  |                 | outputs to file  |                  |
91150 |                  |                 | (readable with   |                  |
91151 |                  |                 | DM.from_file )   |                  |
91152 |                  |                 | [default: false] |                  |
91153 +------------------+-----------------+------------------+------------------+
91154 | enable_fd        | OT_BOOL         | Enable           | casadi::Function |
91155 |                  |                 | derivative       | Internal         |
91156 |                  |                 | calculation by   |                  |
91157 |                  |                 | finite           |                  |
91158 |                  |                 | differencing.    |                  |
91159 |                  |                 | [default:        |                  |
91160 |                  |                 | false]]          |                  |
91161 +------------------+-----------------+------------------+------------------+
91162 | enable_forward   | OT_BOOL         | Enable           | casadi::Function |
91163 |                  |                 | derivative       | Internal         |
91164 |                  |                 | calculation      |                  |
91165 |                  |                 | using generated  |                  |
91166 |                  |                 | functions for    |                  |
91167 |                  |                 | Jacobian-times-  |                  |
91168 |                  |                 | vector products  |                  |
91169 |                  |                 | - typically      |                  |
91170 |                  |                 | using forward    |                  |
91171 |                  |                 | mode AD - if     |                  |
91172 |                  |                 | available.       |                  |
91173 |                  |                 | [default: true]  |                  |
91174 +------------------+-----------------+------------------+------------------+
91175 | enable_jacobian  | OT_BOOL         | Enable           | casadi::Function |
91176 |                  |                 | derivative       | Internal         |
91177 |                  |                 | calculation      |                  |
91178 |                  |                 | using generated  |                  |
91179 |                  |                 | functions for    |                  |
91180 |                  |                 | Jacobians of all |                  |
91181 |                  |                 | differentiable   |                  |
91182 |                  |                 | outputs with     |                  |
91183 |                  |                 | respect to all   |                  |
91184 |                  |                 | differentiable   |                  |
91185 |                  |                 | inputs - if      |                  |
91186 |                  |                 | available.       |                  |
91187 |                  |                 | [default: true]  |                  |
91188 +------------------+-----------------+------------------+------------------+
91189 | enable_reverse   | OT_BOOL         | Enable           | casadi::Function |
91190 |                  |                 | derivative       | Internal         |
91191 |                  |                 | calculation      |                  |
91192 |                  |                 | using generated  |                  |
91193 |                  |                 | functions for    |                  |
91194 |                  |                 | transposed       |                  |
91195 |                  |                 | Jacobian-times-  |                  |
91196 |                  |                 | vector products  |                  |
91197 |                  |                 | - typically      |                  |
91198 |                  |                 | using reverse    |                  |
91199 |                  |                 | mode AD - if     |                  |
91200 |                  |                 | available.       |                  |
91201 |                  |                 | [default: true]  |                  |
91202 +------------------+-----------------+------------------+------------------+
91203 | fd_method        | OT_STRING       | Method for       | casadi::Function |
91204 |                  |                 | finite           | Internal         |
91205 |                  |                 | differencing     |                  |
91206 |                  |                 | [default         |                  |
91207 |                  |                 | 'central']       |                  |
91208 +------------------+-----------------+------------------+------------------+
91209 | fd_options       | OT_DICT         | Options to be    | casadi::Function |
91210 |                  |                 | passed to the    | Internal         |
91211 |                  |                 | finite           |                  |
91212 |                  |                 | difference       |                  |
91213 |                  |                 | instance         |                  |
91214 +------------------+-----------------+------------------+------------------+
91215 | forward_options  | OT_DICT         | Options to be    | casadi::Function |
91216 |                  |                 | passed to a      | Internal         |
91217 |                  |                 | forward mode     |                  |
91218 |                  |                 | constructor      |                  |
91219 +------------------+-----------------+------------------+------------------+
91220 | gather_stats     | OT_BOOL         | Deprecated       | casadi::Function |
91221 |                  |                 | option           | Internal         |
91222 |                  |                 | (ignored):       |                  |
91223 |                  |                 | Statistics are   |                  |
91224 |                  |                 | now always       |                  |
91225 |                  |                 | collected.       |                  |
91226 +------------------+-----------------+------------------+------------------+
91227 | inline           | OT_BOOL         | Implement the    | casadi::Interpol |
91228 |                  |                 | lookup table in  | ant              |
91229 |                  |                 | MX primitives.   |                  |
91230 |                  |                 | Useful when you  |                  |
91231 |                  |                 | need derivatives |                  |
91232 |                  |                 | with respect to  |                  |
91233 |                  |                 | grid and/or      |                  |
91234 |                  |                 | coefficients.    |                  |
91235 |                  |                 | Such derivatives |                  |
91236 |                  |                 | are              |                  |
91237 |                  |                 | fundamentally    |                  |
91238 |                  |                 | dense, so use    |                  |
91239 |                  |                 | with caution.    |                  |
91240 +------------------+-----------------+------------------+------------------+
91241 | input_scheme     | OT_STRINGVECTOR | Deprecated       | casadi::Function |
91242 |                  |                 | option (ignored) | Internal         |
91243 +------------------+-----------------+------------------+------------------+
91244 | inputs_check     | OT_BOOL         | Throw exceptions | casadi::Function |
91245 |                  |                 | when the         | Internal         |
91246 |                  |                 | numerical values |                  |
91247 |                  |                 | of the inputs    |                  |
91248 |                  |                 | don't make sense |                  |
91249 +------------------+-----------------+------------------+------------------+
91250 | is_diff_in       | OT_BOOLVECTOR   | Indicate for     | casadi::Function |
91251 |                  |                 | each input if it | Internal         |
91252 |                  |                 | should be        |                  |
91253 |                  |                 | differentiable.  |                  |
91254 +------------------+-----------------+------------------+------------------+
91255 | is_diff_out      | OT_BOOLVECTOR   | Indicate for     | casadi::Function |
91256 |                  |                 | each output if   | Internal         |
91257 |                  |                 | it should be     |                  |
91258 |                  |                 | differentiable.  |                  |
91259 +------------------+-----------------+------------------+------------------+
91260 | jac_penalty      | OT_DOUBLE       | When requested   | casadi::Function |
91261 |                  |                 | for a number of  | Internal         |
91262 |                  |                 | forward/reverse  |                  |
91263 |                  |                 | directions, it   |                  |
91264 |                  |                 | may be cheaper   |                  |
91265 |                  |                 | to compute first |                  |
91266 |                  |                 | the full         |                  |
91267 |                  |                 | jacobian and     |                  |
91268 |                  |                 | then multiply    |                  |
91269 |                  |                 | with seeds,      |                  |
91270 |                  |                 | rather than      |                  |
91271 |                  |                 | obtain the       |                  |
91272 |                  |                 | requested        |                  |
91273 |                  |                 | directions in a  |                  |
91274 |                  |                 | straightforward  |                  |
91275 |                  |                 | manner. Casadi   |                  |
91276 |                  |                 | uses a heuristic |                  |
91277 |                  |                 | to decide which  |                  |
91278 |                  |                 | is cheaper. A    |                  |
91279 |                  |                 | high value of    |                  |
91280 |                  |                 | 'jac_penalty'    |                  |
91281 |                  |                 | makes it less    |                  |
91282 |                  |                 | likely for the   |                  |
91283 |                  |                 | heurstic to      |                  |
91284 |                  |                 | chose the full   |                  |
91285 |                  |                 | Jacobian         |                  |
91286 |                  |                 | strategy. The    |                  |
91287 |                  |                 | special value -1 |                  |
91288 |                  |                 | indicates never  |                  |
91289 |                  |                 | to use the full  |                  |
91290 |                  |                 | Jacobian         |                  |
91291 |                  |                 | strategy         |                  |
91292 +------------------+-----------------+------------------+------------------+
91293 | jit              | OT_BOOL         | Use just-in-time | casadi::Function |
91294 |                  |                 | compiler to      | Internal         |
91295 |                  |                 | speed up the     |                  |
91296 |                  |                 | evaluation       |                  |
91297 +------------------+-----------------+------------------+------------------+
91298 | jit_cleanup      | OT_BOOL         | Cleanup up the   | casadi::Function |
91299 |                  |                 | temporary source | Internal         |
91300 |                  |                 | file that jit    |                  |
91301 |                  |                 | creates.         |                  |
91302 |                  |                 | Default: true    |                  |
91303 +------------------+-----------------+------------------+------------------+
91304 | jit_name         | OT_STRING       | The file name    | casadi::Function |
91305 |                  |                 | used to write    | Internal         |
91306 |                  |                 | out code. The    |                  |
91307 |                  |                 | actual file      |                  |
91308 |                  |                 | names used       |                  |
91309 |                  |                 | depend on 'jit_t |                  |
91310 |                  |                 | emp_suffix' and  |                  |
91311 |                  |                 | include          |                  |
91312 |                  |                 | extensions.      |                  |
91313 |                  |                 | Default:         |                  |
91314 |                  |                 | 'jit_tmp'        |                  |
91315 +------------------+-----------------+------------------+------------------+
91316 | jit_options      | OT_DICT         | Options to be    | casadi::Function |
91317 |                  |                 | passed to the    | Internal         |
91318 |                  |                 | jit compiler.    |                  |
91319 +------------------+-----------------+------------------+------------------+
91320 | jit_serialize    | OT_STRING       | Specify          | casadi::Function |
91321 |                  |                 | behaviour when   | Internal         |
91322 |                  |                 | serializing a    |                  |
91323 |                  |                 | jitted function: |                  |
91324 |                  |                 | SOURCE|link|embe |                  |
91325 |                  |                 | d.               |                  |
91326 +------------------+-----------------+------------------+------------------+
91327 | jit_temp_suffix  | OT_BOOL         | Use a temporary  | casadi::Function |
91328 |                  |                 | (seemingly       | Internal         |
91329 |                  |                 | random) filename |                  |
91330 |                  |                 | suffix for       |                  |
91331 |                  |                 | generated code   |                  |
91332 |                  |                 | and libraries.   |                  |
91333 |                  |                 | This is desired  |                  |
91334 |                  |                 | for thread-      |                  |
91335 |                  |                 | safety. This     |                  |
91336 |                  |                 | behaviour may    |                  |
91337 |                  |                 | defeat caching   |                  |
91338 |                  |                 | compiler         |                  |
91339 |                  |                 | wrappers.        |                  |
91340 |                  |                 | Default: true    |                  |
91341 +------------------+-----------------+------------------+------------------+
91342 | lookup_mode      | OT_STRINGVECTOR | Specifies, for   | casadi::Interpol |
91343 |                  |                 | each grid        | ant              |
91344 |                  |                 | dimenion, the    |                  |
91345 |                  |                 | lookup algorithm |                  |
91346 |                  |                 | used to find the |                  |
91347 |                  |                 | correct index.   |                  |
91348 |                  |                 | 'linear' uses a  |                  |
91349 |                  |                 | for-loop +       |                  |
91350 |                  |                 | break; (default  |                  |
91351 |                  |                 | when             |                  |
91352 |                  |                 | #knots<=100),    |                  |
91353 |                  |                 | 'exact' uses     |                  |
91354 |                  |                 | floored division |                  |
91355 |                  |                 | (only for        |                  |
91356 |                  |                 | uniform grids),  |                  |
91357 |                  |                 | 'binary' uses a  |                  |
91358 |                  |                 | binary search.   |                  |
91359 |                  |                 | (default when    |                  |
91360 |                  |                 | #knots>100).     |                  |
91361 +------------------+-----------------+------------------+------------------+
91362 | max_num_dir      | OT_INT          | Specify the      | casadi::Function |
91363 |                  |                 | maximum number   | Internal         |
91364 |                  |                 | of directions    |                  |
91365 |                  |                 | for derivative   |                  |
91366 |                  |                 | functions.       |                  |
91367 |                  |                 | Overrules the    |                  |
91368 |                  |                 | builtin optimize |                  |
91369 |                  |                 | d_num_dir.       |                  |
91370 +------------------+-----------------+------------------+------------------+
91371 | never_inline     | OT_BOOL         | Forbid inlining. | casadi::Function |
91372 |                  |                 |                  | Internal         |
91373 +------------------+-----------------+------------------+------------------+
91374 | output_scheme    | OT_STRINGVECTOR | Deprecated       | casadi::Function |
91375 |                  |                 | option (ignored) | Internal         |
91376 +------------------+-----------------+------------------+------------------+
91377 | print_in         | OT_BOOL         | Print numerical  | casadi::Function |
91378 |                  |                 | values of inputs | Internal         |
91379 |                  |                 | [default: false] |                  |
91380 +------------------+-----------------+------------------+------------------+
91381 | print_out        | OT_BOOL         | Print numerical  | casadi::Function |
91382 |                  |                 | values of        | Internal         |
91383 |                  |                 | outputs          |                  |
91384 |                  |                 | [default: false] |                  |
91385 +------------------+-----------------+------------------+------------------+
91386 | print_time       | OT_BOOL         | print            | casadi::Function |
91387 |                  |                 | information      | Internal         |
91388 |                  |                 | about execution  |                  |
91389 |                  |                 | time. Implies    |                  |
91390 |                  |                 | record_time.     |                  |
91391 +------------------+-----------------+------------------+------------------+
91392 | record_time      | OT_BOOL         | record           | casadi::Function |
91393 |                  |                 | information      | Internal         |
91394 |                  |                 | about execution  |                  |
91395 |                  |                 | time, for        |                  |
91396 |                  |                 | retrieval with   |                  |
91397 |                  |                 | stats().         |                  |
91398 +------------------+-----------------+------------------+------------------+
91399 | regularity_check | OT_BOOL         | Throw exceptions | casadi::Function |
91400 |                  |                 | when NaN or Inf  | Internal         |
91401 |                  |                 | appears during   |                  |
91402 |                  |                 | evaluation       |                  |
91403 +------------------+-----------------+------------------+------------------+
91404 | reverse_options  | OT_DICT         | Options to be    | casadi::Function |
91405 |                  |                 | passed to a      | Internal         |
91406 |                  |                 | reverse mode     |                  |
91407 |                  |                 | constructor      |                  |
91408 +------------------+-----------------+------------------+------------------+
91409 | user_data        | OT_VOIDPTR      | A user-defined   | casadi::Function |
91410 |                  |                 | field that can   | Internal         |
91411 |                  |                 | be used to       |                  |
91412 |                  |                 | identify the     |                  |
91413 |                  |                 | function or pass |                  |
91414 |                  |                 | additional       |                  |
91415 |                  |                 | information      |                  |
91416 +------------------+-----------------+------------------+------------------+
91417 | verbose          | OT_BOOL         | Verbose          | casadi::Function |
91418 |                  |                 | evaluation  for  | Internal         |
91419 |                  |                 | debugging        |                  |
91420 +------------------+-----------------+------------------+------------------+
91421 
91422 List of plugins
91423 ===============
91424 
91425 
91426 
91427 - bspline
91428 
91429 - linear
91430 
91431 Note: some of the plugins in this list might not be available on your
91432 system. Also, there might be extra plugins available to you that are not
91433 listed here. You can obtain their documentation with
91434 Interpolant.doc(\"myextraplugin\")
91435 
91436 
91437 
91438 --------------------------------------------------------------------------------
91439 
91440 bspline
91441 -------
91442 
91443 
91444 
91445 >List of available options
91446 
91447 +-----------------------+--------------+-----------------------------------+
91448 |          Id           |     Type     |            Description            |
91449 +=======================+==============+===================================+
91450 | algorithm             | OT_STRING    | Algorithm used for fitting the    |
91451 |                       |              | data: 'not_a_knot' (default, same |
91452 |                       |              | as Matlab), 'smooth_linear'.      |
91453 +-----------------------+--------------+-----------------------------------+
91454 | degree                | OT_INTVECTOR | Sets, for each grid dimension,    |
91455 |                       |              | the degree of the spline.         |
91456 +-----------------------+--------------+-----------------------------------+
91457 | linear_solver         | OT_STRING    | Solver used for constructing the  |
91458 |                       |              | coefficient tensor.               |
91459 +-----------------------+--------------+-----------------------------------+
91460 | linear_solver_options | OT_DICT      | Options to be passed to the       |
91461 |                       |              | linear solver.                    |
91462 +-----------------------+--------------+-----------------------------------+
91463 | smooth_linear_frac    | OT_DOUBLE    | When 'smooth_linear' algorithm is |
91464 |                       |              | active, determines sharpness      |
91465 |                       |              | between 0 (sharp, as linear       |
91466 |                       |              | interpolation) and 0.5            |
91467 |                       |              | (smooth).Default value is 0.1.    |
91468 +-----------------------+--------------+-----------------------------------+
91469 
91470 --------------------------------------------------------------------------------
91471 
91472 
91473 
91474 --------------------------------------------------------------------------------
91475 
91476 linear
91477 ------
91478 
91479 
91480 
91481 >List of available options
91482 
91483 +-------------+-----------------+------------------------------------------+
91484 |     Id      |      Type       |               Description                |
91485 +=============+=================+==========================================+
91486 | lookup_mode | OT_STRINGVECTOR | Sets, for each grid dimenion, the lookup |
91487 |             |                 | algorithm used to find the correct       |
91488 |             |                 | index. 'linear' uses a for-loop + break; |
91489 |             |                 | 'exact' uses floored division (only for  |
91490 |             |                 | uniform grids).                          |
91491 +-------------+-----------------+------------------------------------------+
91492 
91493 --------------------------------------------------------------------------------
91494 
91495 
91496 
91497 Joel Andersson
91498 
91499 ";
91500 
91501 %feature("docstring")  casadi::interpolant(const std::string &name, const
91502 std::string &solver, const std::vector< std::vector< double > > &grid,
91503 casadi_int m=1, const Dict &opts=Dict()) "
91504 
91505 Parametric variant of interpolant.
91506 
91507 The resulting function will have an additional argument for the coefficients
91508 
91509 By default, derivatives wrt the coefficients are not supported (zero). Some
91510 interpolant plugins may support the inline=true which enables correct
91511 derivatives
91512 
91513 ";
91514 
91515 %feature("docstring")  casadi::interpolant(const std::string &name, const
91516 std::string &solver, const std::vector< casadi_int > &grid_dims, casadi_int
91517 m=1, const Dict &opts=Dict()) "
91518 
91519 Parametric variant of interpolant.
91520 
91521 The resulting function will have additional arguments for the grid and
91522 coefficients
91523 
91524 By default, derivatives wrt the coefficients are not supported (zero). Some
91525 interpolant plugins may support the inline=true which enables correct
91526 derivatives
91527 
91528 ";
91529 
91530 %feature("docstring")  casadi::interpolant(const std::string &name, const
91531 std::string &solver, const std::vector< casadi_int > &grid_dims, const
91532 std::vector< double > &values, const Dict &opts=Dict()) "
91533 
91534 Parametric variant of interpolant.
91535 
91536 The resulting function will have an additional argument for the grid
91537 
91538 By default, derivatives wrt the coefficients are not supported (zero). Some
91539 interpolant plugins may support the inline=true which enables correct
91540 derivatives
91541 
91542 ";
91543 
91544 %feature("docstring")  casadi::rootfinder_in() "
91545 
91546 Get rootfinder input scheme.
91547 
91548 ";
91549 
91550 %feature("docstring")  casadi::rootfinder_in(casadi_int ind) "
91551 
91552 Get rootfinder input scheme name by index.
91553 
91554 ";
91555 
91556 %feature("docstring")  casadi::dplesol(const std::string &name, const
91557 std::string &solver, const SpDict &st, const Dict &opts=Dict()) "
91558 
91559 Discrete periodic Lyapunov Equation solver Given matrices $A_k$ and
91560 symmetric $V_k, k = 0..K-1$
91561 
91562 ::
91563 
91564   A_k in R^(n x n)
91565   V_k in R^n
91566 
91567 
91568 provides all of $P_k$ that satisfy:
91569 
91570 ::
91571 
91572   P_0 = A_(K-1)*P_(K-1)*A_(K-1)' + V_k
91573   P_k+1 = A_k*P_k*A_k' + V_k  for k = 1..K-1
91574 
91575 
91576 
91577 
91578 General information
91579 ===================
91580 
91581 
91582 
91583 >List of available options
91584 
91585 +------------------+-----------------+------------------+------------------+
91586 |        Id        |      Type       |   Description    |     Used in      |
91587 +==================+=================+==================+==================+
91588 | ad_weight        | OT_DOUBLE       | Weighting factor | casadi::Function |
91589 |                  |                 | for derivative   | Internal         |
91590 |                  |                 | calculation.When |                  |
91591 |                  |                 | there is an      |                  |
91592 |                  |                 | option of either |                  |
91593 |                  |                 | using forward or |                  |
91594 |                  |                 | reverse mode     |                  |
91595 |                  |                 | directional      |                  |
91596 |                  |                 | derivatives, the |                  |
91597 |                  |                 | condition ad_wei |                  |
91598 |                  |                 | ght*nf<=(1-ad_we |                  |
91599 |                  |                 | ight)*na is used |                  |
91600 |                  |                 | where nf and na  |                  |
91601 |                  |                 | are estimates of |                  |
91602 |                  |                 | the number of    |                  |
91603 |                  |                 | forward/reverse  |                  |
91604 |                  |                 | mode directional |                  |
91605 |                  |                 | derivatives      |                  |
91606 |                  |                 | needed. By       |                  |
91607 |                  |                 | default,         |                  |
91608 |                  |                 | ad_weight is     |                  |
91609 |                  |                 | calculated       |                  |
91610 |                  |                 | automatically,   |                  |
91611 |                  |                 | but this can be  |                  |
91612 |                  |                 | overridden by    |                  |
91613 |                  |                 | setting this     |                  |
91614 |                  |                 | option. In       |                  |
91615 |                  |                 | particular, 0    |                  |
91616 |                  |                 | means forcing    |                  |
91617 |                  |                 | forward mode and |                  |
91618 |                  |                 | 1 forcing        |                  |
91619 |                  |                 | reverse mode.    |                  |
91620 |                  |                 | Leave unset for  |                  |
91621 |                  |                 | (class specific) |                  |
91622 |                  |                 | heuristics.      |                  |
91623 +------------------+-----------------+------------------+------------------+
91624 | ad_weight_sp     | OT_DOUBLE       | Weighting factor | casadi::Function |
91625 |                  |                 | for sparsity     | Internal         |
91626 |                  |                 | pattern          |                  |
91627 |                  |                 | calculation calc |                  |
91628 |                  |                 | ulation.Override |                  |
91629 |                  |                 | s default        |                  |
91630 |                  |                 | behavior. Set to |                  |
91631 |                  |                 | 0 and 1 to force |                  |
91632 |                  |                 | forward and      |                  |
91633 |                  |                 | reverse mode     |                  |
91634 |                  |                 | respectively.    |                  |
91635 |                  |                 | Cf. option       |                  |
91636 |                  |                 | \"ad_weight\".     |                  |
91637 |                  |                 | When set to -1,  |                  |
91638 |                  |                 | sparsity is      |                  |
91639 |                  |                 | completely       |                  |
91640 |                  |                 | ignored and      |                  |
91641 |                  |                 | dense matrices   |                  |
91642 |                  |                 | are used.        |                  |
91643 +------------------+-----------------+------------------+------------------+
91644 | always_inline    | OT_BOOL         | Force inlining.  | casadi::Function |
91645 |                  |                 |                  | Internal         |
91646 +------------------+-----------------+------------------+------------------+
91647 | compiler         | OT_STRING       | Just-in-time     | casadi::Function |
91648 |                  |                 | compiler plugin  | Internal         |
91649 |                  |                 | to be used.      |                  |
91650 +------------------+-----------------+------------------+------------------+
91651 | const_dim        | OT_BOOL         | Assume constant  | casadi::Dple     |
91652 |                  |                 | dimension of P   |                  |
91653 +------------------+-----------------+------------------+------------------+
91654 | custom_jacobian  | OT_FUNCTION     | Override         | casadi::Function |
91655 |                  |                 | CasADi's AD. Use | Internal         |
91656 |                  |                 | together with    |                  |
91657 |                  |                 | 'jac_penalty':   |                  |
91658 |                  |                 | 0. Note: Highly  |                  |
91659 |                  |                 | experimental.    |                  |
91660 |                  |                 | Syntax may break |                  |
91661 |                  |                 | often.           |                  |
91662 +------------------+-----------------+------------------+------------------+
91663 | derivative_of    | OT_FUNCTION     | The function is  | casadi::Function |
91664 |                  |                 | a derivative of  | Internal         |
91665 |                  |                 | another          |                  |
91666 |                  |                 | function. The    |                  |
91667 |                  |                 | type of          |                  |
91668 |                  |                 | derivative       |                  |
91669 |                  |                 | (directional     |                  |
91670 |                  |                 | derivative,      |                  |
91671 |                  |                 | Jacobian) is     |                  |
91672 |                  |                 | inferred from    |                  |
91673 |                  |                 | the function     |                  |
91674 |                  |                 | name.            |                  |
91675 +------------------+-----------------+------------------+------------------+
91676 | dump             | OT_BOOL         | Dump function to | casadi::Function |
91677 |                  |                 | file upon first  | Internal         |
91678 |                  |                 | evaluation.      |                  |
91679 |                  |                 | [false]          |                  |
91680 +------------------+-----------------+------------------+------------------+
91681 | dump_dir         | OT_STRING       | Directory to     | casadi::Function |
91682 |                  |                 | dump             | Internal         |
91683 |                  |                 | inputs/outputs   |                  |
91684 |                  |                 | to. Make sure    |                  |
91685 |                  |                 | the directory    |                  |
91686 |                  |                 | exists [.]       |                  |
91687 +------------------+-----------------+------------------+------------------+
91688 | dump_format      | OT_STRING       | Choose file      | casadi::Function |
91689 |                  |                 | format to dump   | Internal         |
91690 |                  |                 | matrices. See    |                  |
91691 |                  |                 | DM.from_file     |                  |
91692 |                  |                 | [mtx]            |                  |
91693 +------------------+-----------------+------------------+------------------+
91694 | dump_in          | OT_BOOL         | Dump numerical   | casadi::Function |
91695 |                  |                 | values of inputs | Internal         |
91696 |                  |                 | to file          |                  |
91697 |                  |                 | (readable with   |                  |
91698 |                  |                 | DM.from_file )   |                  |
91699 |                  |                 | [default: false] |                  |
91700 +------------------+-----------------+------------------+------------------+
91701 | dump_out         | OT_BOOL         | Dump numerical   | casadi::Function |
91702 |                  |                 | values of        | Internal         |
91703 |                  |                 | outputs to file  |                  |
91704 |                  |                 | (readable with   |                  |
91705 |                  |                 | DM.from_file )   |                  |
91706 |                  |                 | [default: false] |                  |
91707 +------------------+-----------------+------------------+------------------+
91708 | enable_fd        | OT_BOOL         | Enable           | casadi::Function |
91709 |                  |                 | derivative       | Internal         |
91710 |                  |                 | calculation by   |                  |
91711 |                  |                 | finite           |                  |
91712 |                  |                 | differencing.    |                  |
91713 |                  |                 | [default:        |                  |
91714 |                  |                 | false]]          |                  |
91715 +------------------+-----------------+------------------+------------------+
91716 | enable_forward   | OT_BOOL         | Enable           | casadi::Function |
91717 |                  |                 | derivative       | Internal         |
91718 |                  |                 | calculation      |                  |
91719 |                  |                 | using generated  |                  |
91720 |                  |                 | functions for    |                  |
91721 |                  |                 | Jacobian-times-  |                  |
91722 |                  |                 | vector products  |                  |
91723 |                  |                 | - typically      |                  |
91724 |                  |                 | using forward    |                  |
91725 |                  |                 | mode AD - if     |                  |
91726 |                  |                 | available.       |                  |
91727 |                  |                 | [default: true]  |                  |
91728 +------------------+-----------------+------------------+------------------+
91729 | enable_jacobian  | OT_BOOL         | Enable           | casadi::Function |
91730 |                  |                 | derivative       | Internal         |
91731 |                  |                 | calculation      |                  |
91732 |                  |                 | using generated  |                  |
91733 |                  |                 | functions for    |                  |
91734 |                  |                 | Jacobians of all |                  |
91735 |                  |                 | differentiable   |                  |
91736 |                  |                 | outputs with     |                  |
91737 |                  |                 | respect to all   |                  |
91738 |                  |                 | differentiable   |                  |
91739 |                  |                 | inputs - if      |                  |
91740 |                  |                 | available.       |                  |
91741 |                  |                 | [default: true]  |                  |
91742 +------------------+-----------------+------------------+------------------+
91743 | enable_reverse   | OT_BOOL         | Enable           | casadi::Function |
91744 |                  |                 | derivative       | Internal         |
91745 |                  |                 | calculation      |                  |
91746 |                  |                 | using generated  |                  |
91747 |                  |                 | functions for    |                  |
91748 |                  |                 | transposed       |                  |
91749 |                  |                 | Jacobian-times-  |                  |
91750 |                  |                 | vector products  |                  |
91751 |                  |                 | - typically      |                  |
91752 |                  |                 | using reverse    |                  |
91753 |                  |                 | mode AD - if     |                  |
91754 |                  |                 | available.       |                  |
91755 |                  |                 | [default: true]  |                  |
91756 +------------------+-----------------+------------------+------------------+
91757 | eps_unstable     | OT_DOUBLE       | A margin for     | casadi::Dple     |
91758 |                  |                 | unstability      |                  |
91759 |                  |                 | detection        |                  |
91760 +------------------+-----------------+------------------+------------------+
91761 | error_unstable   | OT_BOOL         | Throw an         | casadi::Dple     |
91762 |                  |                 | exception when   |                  |
91763 |                  |                 | it is detected   |                  |
91764 |                  |                 | that             |                  |
91765 |                  |                 | Product(A_i,     |                  |
91766 |                  |                 | i=N..1)has       |                  |
91767 |                  |                 | eigenvalues      |                  |
91768 |                  |                 | greater than     |                  |
91769 |                  |                 | 1-eps_unstable   |                  |
91770 +------------------+-----------------+------------------+------------------+
91771 | fd_method        | OT_STRING       | Method for       | casadi::Function |
91772 |                  |                 | finite           | Internal         |
91773 |                  |                 | differencing     |                  |
91774 |                  |                 | [default         |                  |
91775 |                  |                 | 'central']       |                  |
91776 +------------------+-----------------+------------------+------------------+
91777 | fd_options       | OT_DICT         | Options to be    | casadi::Function |
91778 |                  |                 | passed to the    | Internal         |
91779 |                  |                 | finite           |                  |
91780 |                  |                 | difference       |                  |
91781 |                  |                 | instance         |                  |
91782 +------------------+-----------------+------------------+------------------+
91783 | forward_options  | OT_DICT         | Options to be    | casadi::Function |
91784 |                  |                 | passed to a      | Internal         |
91785 |                  |                 | forward mode     |                  |
91786 |                  |                 | constructor      |                  |
91787 +------------------+-----------------+------------------+------------------+
91788 | gather_stats     | OT_BOOL         | Deprecated       | casadi::Function |
91789 |                  |                 | option           | Internal         |
91790 |                  |                 | (ignored):       |                  |
91791 |                  |                 | Statistics are   |                  |
91792 |                  |                 | now always       |                  |
91793 |                  |                 | collected.       |                  |
91794 +------------------+-----------------+------------------+------------------+
91795 | input_scheme     | OT_STRINGVECTOR | Deprecated       | casadi::Function |
91796 |                  |                 | option (ignored) | Internal         |
91797 +------------------+-----------------+------------------+------------------+
91798 | inputs_check     | OT_BOOL         | Throw exceptions | casadi::Function |
91799 |                  |                 | when the         | Internal         |
91800 |                  |                 | numerical values |                  |
91801 |                  |                 | of the inputs    |                  |
91802 |                  |                 | don't make sense |                  |
91803 +------------------+-----------------+------------------+------------------+
91804 | is_diff_in       | OT_BOOLVECTOR   | Indicate for     | casadi::Function |
91805 |                  |                 | each input if it | Internal         |
91806 |                  |                 | should be        |                  |
91807 |                  |                 | differentiable.  |                  |
91808 +------------------+-----------------+------------------+------------------+
91809 | is_diff_out      | OT_BOOLVECTOR   | Indicate for     | casadi::Function |
91810 |                  |                 | each output if   | Internal         |
91811 |                  |                 | it should be     |                  |
91812 |                  |                 | differentiable.  |                  |
91813 +------------------+-----------------+------------------+------------------+
91814 | jac_penalty      | OT_DOUBLE       | When requested   | casadi::Function |
91815 |                  |                 | for a number of  | Internal         |
91816 |                  |                 | forward/reverse  |                  |
91817 |                  |                 | directions, it   |                  |
91818 |                  |                 | may be cheaper   |                  |
91819 |                  |                 | to compute first |                  |
91820 |                  |                 | the full         |                  |
91821 |                  |                 | jacobian and     |                  |
91822 |                  |                 | then multiply    |                  |
91823 |                  |                 | with seeds,      |                  |
91824 |                  |                 | rather than      |                  |
91825 |                  |                 | obtain the       |                  |
91826 |                  |                 | requested        |                  |
91827 |                  |                 | directions in a  |                  |
91828 |                  |                 | straightforward  |                  |
91829 |                  |                 | manner. Casadi   |                  |
91830 |                  |                 | uses a heuristic |                  |
91831 |                  |                 | to decide which  |                  |
91832 |                  |                 | is cheaper. A    |                  |
91833 |                  |                 | high value of    |                  |
91834 |                  |                 | 'jac_penalty'    |                  |
91835 |                  |                 | makes it less    |                  |
91836 |                  |                 | likely for the   |                  |
91837 |                  |                 | heurstic to      |                  |
91838 |                  |                 | chose the full   |                  |
91839 |                  |                 | Jacobian         |                  |
91840 |                  |                 | strategy. The    |                  |
91841 |                  |                 | special value -1 |                  |
91842 |                  |                 | indicates never  |                  |
91843 |                  |                 | to use the full  |                  |
91844 |                  |                 | Jacobian         |                  |
91845 |                  |                 | strategy         |                  |
91846 +------------------+-----------------+------------------+------------------+
91847 | jit              | OT_BOOL         | Use just-in-time | casadi::Function |
91848 |                  |                 | compiler to      | Internal         |
91849 |                  |                 | speed up the     |                  |
91850 |                  |                 | evaluation       |                  |
91851 +------------------+-----------------+------------------+------------------+
91852 | jit_cleanup      | OT_BOOL         | Cleanup up the   | casadi::Function |
91853 |                  |                 | temporary source | Internal         |
91854 |                  |                 | file that jit    |                  |
91855 |                  |                 | creates.         |                  |
91856 |                  |                 | Default: true    |                  |
91857 +------------------+-----------------+------------------+------------------+
91858 | jit_name         | OT_STRING       | The file name    | casadi::Function |
91859 |                  |                 | used to write    | Internal         |
91860 |                  |                 | out code. The    |                  |
91861 |                  |                 | actual file      |                  |
91862 |                  |                 | names used       |                  |
91863 |                  |                 | depend on 'jit_t |                  |
91864 |                  |                 | emp_suffix' and  |                  |
91865 |                  |                 | include          |                  |
91866 |                  |                 | extensions.      |                  |
91867 |                  |                 | Default:         |                  |
91868 |                  |                 | 'jit_tmp'        |                  |
91869 +------------------+-----------------+------------------+------------------+
91870 | jit_options      | OT_DICT         | Options to be    | casadi::Function |
91871 |                  |                 | passed to the    | Internal         |
91872 |                  |                 | jit compiler.    |                  |
91873 +------------------+-----------------+------------------+------------------+
91874 | jit_serialize    | OT_STRING       | Specify          | casadi::Function |
91875 |                  |                 | behaviour when   | Internal         |
91876 |                  |                 | serializing a    |                  |
91877 |                  |                 | jitted function: |                  |
91878 |                  |                 | SOURCE|link|embe |                  |
91879 |                  |                 | d.               |                  |
91880 +------------------+-----------------+------------------+------------------+
91881 | jit_temp_suffix  | OT_BOOL         | Use a temporary  | casadi::Function |
91882 |                  |                 | (seemingly       | Internal         |
91883 |                  |                 | random) filename |                  |
91884 |                  |                 | suffix for       |                  |
91885 |                  |                 | generated code   |                  |
91886 |                  |                 | and libraries.   |                  |
91887 |                  |                 | This is desired  |                  |
91888 |                  |                 | for thread-      |                  |
91889 |                  |                 | safety. This     |                  |
91890 |                  |                 | behaviour may    |                  |
91891 |                  |                 | defeat caching   |                  |
91892 |                  |                 | compiler         |                  |
91893 |                  |                 | wrappers.        |                  |
91894 |                  |                 | Default: true    |                  |
91895 +------------------+-----------------+------------------+------------------+
91896 | max_num_dir      | OT_INT          | Specify the      | casadi::Function |
91897 |                  |                 | maximum number   | Internal         |
91898 |                  |                 | of directions    |                  |
91899 |                  |                 | for derivative   |                  |
91900 |                  |                 | functions.       |                  |
91901 |                  |                 | Overrules the    |                  |
91902 |                  |                 | builtin optimize |                  |
91903 |                  |                 | d_num_dir.       |                  |
91904 +------------------+-----------------+------------------+------------------+
91905 | never_inline     | OT_BOOL         | Forbid inlining. | casadi::Function |
91906 |                  |                 |                  | Internal         |
91907 +------------------+-----------------+------------------+------------------+
91908 | output_scheme    | OT_STRINGVECTOR | Deprecated       | casadi::Function |
91909 |                  |                 | option (ignored) | Internal         |
91910 +------------------+-----------------+------------------+------------------+
91911 | pos_def          | OT_BOOL         | Assume P         | casadi::Dple     |
91912 |                  |                 | positive         |                  |
91913 |                  |                 | definite         |                  |
91914 +------------------+-----------------+------------------+------------------+
91915 | print_in         | OT_BOOL         | Print numerical  | casadi::Function |
91916 |                  |                 | values of inputs | Internal         |
91917 |                  |                 | [default: false] |                  |
91918 +------------------+-----------------+------------------+------------------+
91919 | print_out        | OT_BOOL         | Print numerical  | casadi::Function |
91920 |                  |                 | values of        | Internal         |
91921 |                  |                 | outputs          |                  |
91922 |                  |                 | [default: false] |                  |
91923 +------------------+-----------------+------------------+------------------+
91924 | print_time       | OT_BOOL         | print            | casadi::Function |
91925 |                  |                 | information      | Internal         |
91926 |                  |                 | about execution  |                  |
91927 |                  |                 | time. Implies    |                  |
91928 |                  |                 | record_time.     |                  |
91929 +------------------+-----------------+------------------+------------------+
91930 | record_time      | OT_BOOL         | record           | casadi::Function |
91931 |                  |                 | information      | Internal         |
91932 |                  |                 | about execution  |                  |
91933 |                  |                 | time, for        |                  |
91934 |                  |                 | retrieval with   |                  |
91935 |                  |                 | stats().         |                  |
91936 +------------------+-----------------+------------------+------------------+
91937 | regularity_check | OT_BOOL         | Throw exceptions | casadi::Function |
91938 |                  |                 | when NaN or Inf  | Internal         |
91939 |                  |                 | appears during   |                  |
91940 |                  |                 | evaluation       |                  |
91941 +------------------+-----------------+------------------+------------------+
91942 | reverse_options  | OT_DICT         | Options to be    | casadi::Function |
91943 |                  |                 | passed to a      | Internal         |
91944 |                  |                 | reverse mode     |                  |
91945 |                  |                 | constructor      |                  |
91946 +------------------+-----------------+------------------+------------------+
91947 | user_data        | OT_VOIDPTR      | A user-defined   | casadi::Function |
91948 |                  |                 | field that can   | Internal         |
91949 |                  |                 | be used to       |                  |
91950 |                  |                 | identify the     |                  |
91951 |                  |                 | function or pass |                  |
91952 |                  |                 | additional       |                  |
91953 |                  |                 | information      |                  |
91954 +------------------+-----------------+------------------+------------------+
91955 | verbose          | OT_BOOL         | Verbose          | casadi::Function |
91956 |                  |                 | evaluation  for  | Internal         |
91957 |                  |                 | debugging        |                  |
91958 +------------------+-----------------+------------------+------------------+
91959 
91960 >Input scheme: casadi::DpleInput (DPLE_NUM_IN = 2)
91961 
91962 +-----------+-------+------------------------------------------------------+
91963 | Full name | Short |                     Description                      |
91964 +===========+=======+======================================================+
91965 | DPLE_A    | a     | A matrices (horzcat when const_dim, diagcat          |
91966 |           |       | otherwise) [a].                                      |
91967 +-----------+-------+------------------------------------------------------+
91968 | DPLE_V    | v     | V matrices (horzcat when const_dim, diagcat          |
91969 |           |       | otherwise) [v].                                      |
91970 +-----------+-------+------------------------------------------------------+
91971 
91972 >Output scheme: casadi::DpleOutput (DPLE_NUM_OUT = 1)
91973 
91974 +-----------+-------+------------------------------------------------------+
91975 | Full name | Short |                     Description                      |
91976 +===========+=======+======================================================+
91977 | DPLE_P    | p     | Lyapunov matrix (horzcat when const_dim, diagcat     |
91978 |           |       | otherwise) (Cholesky of P if pos_def) [p].           |
91979 +-----------+-------+------------------------------------------------------+
91980 
91981 List of plugins
91982 ===============
91983 
91984 
91985 
91986 - slicot
91987 
91988 Note: some of the plugins in this list might not be available on your
91989 system. Also, there might be extra plugins available to you that are not
91990 listed here. You can obtain their documentation with
91991 Dple.doc(\"myextraplugin\")
91992 
91993 
91994 
91995 --------------------------------------------------------------------------------
91996 
91997 slicot
91998 ------
91999 
92000 
92001 
92002 An efficient solver for Discrete Periodic Lyapunov Equations using SLICOT
92003 
92004 Uses Periodic Schur Decomposition ('psd') and does not assume positive
92005 definiteness. Based on Periodic Lyapunov equations: some applications and
92006 new algorithms. Int. J. Control, vol. 67, pp. 69-87, 1997.
92007 
92008 Overview of the method: J. Gillis Practical Methods for Approximate Robust
92009 Periodic Optimal Control ofNonlinear Mechanical Systems, PhD Thesis,
92010 KULeuven, 2015
92011 
92012 >List of available options
92013 
92014 +-----------------------+-----------+--------------------------------------+
92015 |          Id           |   Type    |             Description              |
92016 +=======================+===========+======================================+
92017 | linear_solver         | OT_STRING | User-defined linear solver class.    |
92018 |                       |           | Needed for sensitivities.            |
92019 +-----------------------+-----------+--------------------------------------+
92020 | linear_solver_options | OT_DICT   | Options to be passed to the linear   |
92021 |                       |           | solver.                              |
92022 +-----------------------+-----------+--------------------------------------+
92023 | psd_num_zero          | OT_DOUBLE | Numerical zero used in Periodic      |
92024 |                       |           | Schur decomposition with slicot.This |
92025 |                       |           | option is needed when your systems   |
92026 |                       |           | has Floquet multiplierszero or close |
92027 |                       |           | to zero                              |
92028 +-----------------------+-----------+--------------------------------------+
92029 
92030 --------------------------------------------------------------------------------
92031 
92032 
92033 
92034 Joris Gillis
92035 
92036 ";
92037 
92038 %feature("docstring")  casadi::is_slice(const IM &x, bool ind1=false) "
92039 
92040 Is the IM a Slice.
92041 
92042 ";
92043 
92044 %feature("docstring")  casadi::is_slice(const std::vector< casadi_int > &v,
92045 bool ind1=false) "
92046 
92047 Check if an index vector can be represented more efficiently as a slice.
92048 
92049 ";
92050 
92051 %feature("docstring")  casadi::casadi_mmin(const T1 *x, casadi_int n,
92052 casadi_int is_dense) "
92053 
92054 [INTERNAL] ";
92055 
92056 %feature("docstring")  casadi::is_decreasing(const std::vector< T > &v) "
92057 
92058 Check if the vector is strictly decreasing.
92059 
92060 ";
92061 
92062 %feature("docstring")  casadi::casadi_qr(const casadi_int *sp_a, const T1
92063 *nz_a, T1 *x, const casadi_int *sp_v, T1 *nz_v, const casadi_int *sp_r, T1
92064 *nz_r, T1 *beta, const casadi_int *prinv, const casadi_int *pc) "
92065 
92066 [INTERNAL] ";
92067 
92068 %feature("docstring")  casadi::doc_conic(const std::string &name) "
92069 
92070 Get the documentation string for a plugin.
92071 
92072 ";
92073 
92074 %feature("docstring")  casadi::casadi_dot(casadi_int n, const T1 *x, const
92075 T1 *y) "
92076 
92077 [INTERNAL]  Inner product.
92078 
92079 ";
92080 
92081 %feature("docstring")  casadi::nlpsol(const std::string &name, const
92082 std::string &solver, const SXDict &nlp, const Dict &opts=Dict()) "
92083 
92084 Create an NLP solver Creates a solver for the following parametric nonlinear
92085 program (NLP):
92086 
92087 ::
92088 
92089   min          F(x, p)
92090   x
92091 
92092   subject to
92093   LBX <=   x    <= UBX
92094   LBG <= G(x, p) <= UBG
92095   p  == P
92096 
92097   nx: number of decision variables
92098   ng: number of constraints
92099   np: number of parameters
92100 
92101 
92102 
92103 General information
92104 ===================
92105 
92106 
92107 
92108 >List of available options
92109 
92110 +------------------+-----------------+------------------+------------------+
92111 |        Id        |      Type       |   Description    |     Used in      |
92112 +==================+=================+==================+==================+
92113 | bound_consistenc | OT_BOOL         | Ensure that      | casadi::Nlpsol   |
92114 | y                |                 | primal-dual      |                  |
92115 |                  |                 | solution is      |                  |
92116 |                  |                 | consistent with  |                  |
92117 |                  |                 | the bounds       |                  |
92118 +------------------+-----------------+------------------+------------------+
92119 | calc_f           | OT_BOOL         | Calculate 'f' in | casadi::Nlpsol   |
92120 |                  |                 | the Nlpsol base  |                  |
92121 |                  |                 | class            |                  |
92122 +------------------+-----------------+------------------+------------------+
92123 | calc_g           | OT_BOOL         | Calculate 'g' in | casadi::Nlpsol   |
92124 |                  |                 | the Nlpsol base  |                  |
92125 |                  |                 | class            |                  |
92126 +------------------+-----------------+------------------+------------------+
92127 | calc_lam_p       | OT_BOOL         | Calculate        | casadi::Nlpsol   |
92128 |                  |                 | 'lam_p' in the   |                  |
92129 |                  |                 | Nlpsol base      |                  |
92130 |                  |                 | class            |                  |
92131 +------------------+-----------------+------------------+------------------+
92132 | calc_lam_x       | OT_BOOL         | Calculate        | casadi::Nlpsol   |
92133 |                  |                 | 'lam_x' in the   |                  |
92134 |                  |                 | Nlpsol base      |                  |
92135 |                  |                 | class            |                  |
92136 +------------------+-----------------+------------------+------------------+
92137 | calc_multipliers | OT_BOOL         | Calculate        | casadi::Nlpsol   |
92138 |                  |                 | Lagrange         |                  |
92139 |                  |                 | multipliers in   |                  |
92140 |                  |                 | the Nlpsol base  |                  |
92141 |                  |                 | class            |                  |
92142 +------------------+-----------------+------------------+------------------+
92143 | common_options   | OT_DICT         | Options for      | casadi::OracleFu |
92144 |                  |                 | auto-generated   | nction           |
92145 |                  |                 | functions        |                  |
92146 +------------------+-----------------+------------------+------------------+
92147 | discrete         | OT_BOOLVECTOR   | Indicates which  | casadi::Nlpsol   |
92148 |                  |                 | of the variables |                  |
92149 |                  |                 | are discrete,    |                  |
92150 |                  |                 | i.e. integer-    |                  |
92151 |                  |                 | valued           |                  |
92152 +------------------+-----------------+------------------+------------------+
92153 | error_on_fail    | OT_BOOL         | When the         | casadi::Nlpsol   |
92154 |                  |                 | numerical        |                  |
92155 |                  |                 | process returns  |                  |
92156 |                  |                 | unsuccessfully,  |                  |
92157 |                  |                 | raise an error   |                  |
92158 |                  |                 | (default false). |                  |
92159 +------------------+-----------------+------------------+------------------+
92160 | eval_errors_fata | OT_BOOL         | When errors      | casadi::Nlpsol   |
92161 | l                |                 | occur during     |                  |
92162 |                  |                 | evaluation of    |                  |
92163 |                  |                 | f,g,...,stop the |                  |
92164 |                  |                 | iterations       |                  |
92165 +------------------+-----------------+------------------+------------------+
92166 | expand           | OT_BOOL         | Replace MX with  | casadi::OracleFu |
92167 |                  |                 | SX expressions   | nction           |
92168 |                  |                 | in problem       |                  |
92169 |                  |                 | formulation      |                  |
92170 |                  |                 | [false]          |                  |
92171 +------------------+-----------------+------------------+------------------+
92172 | ignore_check_vec | OT_BOOL         | If set to true,  | casadi::Nlpsol   |
92173 |                  |                 | the input shape  |                  |
92174 |                  |                 | of F will not be |                  |
92175 |                  |                 | checked.         |                  |
92176 +------------------+-----------------+------------------+------------------+
92177 | iteration_callba | OT_FUNCTION     | A function that  | casadi::Nlpsol   |
92178 | ck               |                 | will be called   |                  |
92179 |                  |                 | at each          |                  |
92180 |                  |                 | iteration with   |                  |
92181 |                  |                 | the solver as    |                  |
92182 |                  |                 | input. Check     |                  |
92183 |                  |                 | documentation of |                  |
92184 |                  |                 | Callback .       |                  |
92185 +------------------+-----------------+------------------+------------------+
92186 | iteration_callba | OT_BOOL         | If set to true,  | casadi::Nlpsol   |
92187 | ck_ignore_errors |                 | errors thrown by |                  |
92188 |                  |                 | iteration_callba |                  |
92189 |                  |                 | ck will be       |                  |
92190 |                  |                 | ignored.         |                  |
92191 +------------------+-----------------+------------------+------------------+
92192 | iteration_callba | OT_INT          | Only call the    | casadi::Nlpsol   |
92193 | ck_step          |                 | callback         |                  |
92194 |                  |                 | function every   |                  |
92195 |                  |                 | few iterations.  |                  |
92196 +------------------+-----------------+------------------+------------------+
92197 | min_lam          | OT_DOUBLE       | Minimum allowed  | casadi::Nlpsol   |
92198 |                  |                 | multiplier value |                  |
92199 +------------------+-----------------+------------------+------------------+
92200 | monitor          | OT_STRINGVECTOR | Set of user      | casadi::OracleFu |
92201 |                  |                 | problem          | nction           |
92202 |                  |                 | functions to be  |                  |
92203 |                  |                 | monitored        |                  |
92204 +------------------+-----------------+------------------+------------------+
92205 | no_nlp_grad      | OT_BOOL         | Prevent the      | casadi::Nlpsol   |
92206 |                  |                 | creation of the  |                  |
92207 |                  |                 | 'nlp_grad'       |                  |
92208 |                  |                 | function         |                  |
92209 +------------------+-----------------+------------------+------------------+
92210 | oracle_options   | OT_DICT         | Options to be    | casadi::Nlpsol   |
92211 |                  |                 | passed to the    |                  |
92212 |                  |                 | oracle function  |                  |
92213 +------------------+-----------------+------------------+------------------+
92214 | sens_linsol      | OT_STRING       | Linear solver    | casadi::Nlpsol   |
92215 |                  |                 | used for         |                  |
92216 |                  |                 | parametric       |                  |
92217 |                  |                 | sensitivities    |                  |
92218 |                  |                 | (default 'qr').  |                  |
92219 +------------------+-----------------+------------------+------------------+
92220 | sens_linsol_opti | OT_DICT         | Linear solver    | casadi::Nlpsol   |
92221 | ons              |                 | options used for |                  |
92222 |                  |                 | parametric       |                  |
92223 |                  |                 | sensitivities.   |                  |
92224 +------------------+-----------------+------------------+------------------+
92225 | show_eval_warnin | OT_BOOL         | Show warnings    | casadi::OracleFu |
92226 | gs               |                 | generated from   | nction           |
92227 |                  |                 | function         |                  |
92228 |                  |                 | evaluations      |                  |
92229 |                  |                 | [true]           |                  |
92230 +------------------+-----------------+------------------+------------------+
92231 | specific_options | OT_DICT         | Options for      | casadi::OracleFu |
92232 |                  |                 | specific auto-   | nction           |
92233 |                  |                 | generated        |                  |
92234 |                  |                 | functions,       |                  |
92235 |                  |                 | overwriting the  |                  |
92236 |                  |                 | defaults from    |                  |
92237 |                  |                 | common_options.  |                  |
92238 |                  |                 | Nested           |                  |
92239 |                  |                 | dictionary.      |                  |
92240 +------------------+-----------------+------------------+------------------+
92241 | verbose_init     | OT_BOOL         | Print out timing | casadi::Nlpsol   |
92242 |                  |                 | information      |                  |
92243 |                  |                 | about the        |                  |
92244 |                  |                 | different stages |                  |
92245 |                  |                 | of               |                  |
92246 |                  |                 | initialization   |                  |
92247 +------------------+-----------------+------------------+------------------+
92248 | warn_initial_bou | OT_BOOL         | Warn if the      | casadi::Nlpsol   |
92249 | nds              |                 | initial guess    |                  |
92250 |                  |                 | does not satisfy |                  |
92251 |                  |                 | LBX and UBX      |                  |
92252 +------------------+-----------------+------------------+------------------+
92253 
92254 >Input scheme: casadi::NlpsolInput (NLPSOL_NUM_IN = 8)
92255 
92256 +---------------+--------+-------------------------------------------------+
92257 |   Full name   | Short  |                   Description                   |
92258 +===============+========+=================================================+
92259 | NLPSOL_X0     | x0     | Decision variables, initial guess (nx x 1)      |
92260 +---------------+--------+-------------------------------------------------+
92261 | NLPSOL_P      | p      | Value of fixed parameters (np x 1)              |
92262 +---------------+--------+-------------------------------------------------+
92263 | NLPSOL_LBX    | lbx    | Decision variables lower bound (nx x 1),        |
92264 |               |        | default -inf.                                   |
92265 +---------------+--------+-------------------------------------------------+
92266 | NLPSOL_UBX    | ubx    | Decision variables upper bound (nx x 1),        |
92267 |               |        | default +inf.                                   |
92268 +---------------+--------+-------------------------------------------------+
92269 | NLPSOL_LBG    | lbg    | Constraints lower bound (ng x 1), default -inf. |
92270 +---------------+--------+-------------------------------------------------+
92271 | NLPSOL_UBG    | ubg    | Constraints upper bound (ng x 1), default +inf. |
92272 +---------------+--------+-------------------------------------------------+
92273 | NLPSOL_LAM_X0 | lam_x0 | Lagrange multipliers for bounds on X, initial   |
92274 |               |        | guess (nx x 1)                                  |
92275 +---------------+--------+-------------------------------------------------+
92276 | NLPSOL_LAM_G0 | lam_g0 | Lagrange multipliers for bounds on G, initial   |
92277 |               |        | guess (ng x 1)                                  |
92278 +---------------+--------+-------------------------------------------------+
92279 
92280 >Output scheme: casadi::NlpsolOutput (NLPSOL_NUM_OUT = 6)
92281 
92282 +--------------+-------+---------------------------------------------------+
92283 |  Full name   | Short |                    Description                    |
92284 +==============+=======+===================================================+
92285 | NLPSOL_X     | x     | Decision variables at the optimal solution (nx x  |
92286 |              |       | 1)                                                |
92287 +--------------+-------+---------------------------------------------------+
92288 | NLPSOL_F     | f     | Cost function value at the optimal solution (1 x  |
92289 |              |       | 1)                                                |
92290 +--------------+-------+---------------------------------------------------+
92291 | NLPSOL_G     | g     | Constraints function at the optimal solution (ng  |
92292 |              |       | x 1)                                              |
92293 +--------------+-------+---------------------------------------------------+
92294 | NLPSOL_LAM_X | lam_x | Lagrange multipliers for bounds on X at the       |
92295 |              |       | solution (nx x 1)                                 |
92296 +--------------+-------+---------------------------------------------------+
92297 | NLPSOL_LAM_G | lam_g | Lagrange multipliers for bounds on G at the       |
92298 |              |       | solution (ng x 1)                                 |
92299 +--------------+-------+---------------------------------------------------+
92300 | NLPSOL_LAM_P | lam_p | Lagrange multipliers for bounds on P at the       |
92301 |              |       | solution (np x 1)                                 |
92302 +--------------+-------+---------------------------------------------------+
92303 
92304 List of plugins
92305 ===============
92306 
92307 
92308 
92309 - AmplInterface
92310 
92311 - blocksqp
92312 
92313 - bonmin
92314 
92315 - ipopt
92316 
92317 - knitro
92318 
92319 - snopt
92320 
92321 - worhp
92322 
92323 - qrsqp
92324 
92325 - scpgen
92326 
92327 - sqpmethod
92328 
92329 Note: some of the plugins in this list might not be available on your
92330 system. Also, there might be extra plugins available to you that are not
92331 listed here. You can obtain their documentation with
92332 Nlpsol.doc(\"myextraplugin\")
92333 
92334 
92335 
92336 --------------------------------------------------------------------------------
92337 
92338 AmplInterface
92339 -------------
92340 
92341 
92342 
92343 >List of available options
92344 
92345 +--------+-----------+--------------------+
92346 |   Id   |   Type    |    Description     |
92347 +========+===========+====================+
92348 | solver | OT_STRING | AMPL solver binary |
92349 +--------+-----------+--------------------+
92350 
92351 --------------------------------------------------------------------------------
92352 
92353 
92354 
92355 --------------------------------------------------------------------------------
92356 
92357 blocksqp
92358 --------
92359 
92360 
92361 
92362 This is a modified version of blockSQP by Janka et al.
92363 
92364 Dennis Janka, Joel Andersson
92365 
92366 >List of available options
92367 
92368 +----------------------------+-----------+---------------------------------+
92369 |             Id             |   Type    |           Description           |
92370 +============================+===========+=================================+
92371 | block_hess                 | OT_INT    | Blockwise Hessian               |
92372 |                            |           | approximation?                  |
92373 +----------------------------+-----------+---------------------------------+
92374 | col_eps                    | OT_DOUBLE | Epsilon for COL scaling         |
92375 |                            |           | strategy                        |
92376 +----------------------------+-----------+---------------------------------+
92377 | col_tau1                   | OT_DOUBLE | tau1 for COL scaling strategy   |
92378 +----------------------------+-----------+---------------------------------+
92379 | col_tau2                   | OT_DOUBLE | tau2 for COL scaling strategy   |
92380 +----------------------------+-----------+---------------------------------+
92381 | conv_strategy              | OT_INT    | Convexification strategy        |
92382 +----------------------------+-----------+---------------------------------+
92383 | delta                      | OT_DOUBLE | Filter line search parameter,   |
92384 |                            |           | cf. IPOPT paper                 |
92385 +----------------------------+-----------+---------------------------------+
92386 | delta_h0                   | OT_DOUBLE | Filter line search parameter,   |
92387 |                            |           | cf. IPOPT paper                 |
92388 +----------------------------+-----------+---------------------------------+
92389 | eps                        | OT_DOUBLE | Values smaller than this are    |
92390 |                            |           | regarded as numerically zero    |
92391 +----------------------------+-----------+---------------------------------+
92392 | eta                        | OT_DOUBLE | Filter line search parameter,   |
92393 |                            |           | cf. IPOPT paper                 |
92394 +----------------------------+-----------+---------------------------------+
92395 | fallback_scaling           | OT_INT    | If indefinite update is used,   |
92396 |                            |           | the type of fallback strategy   |
92397 +----------------------------+-----------+---------------------------------+
92398 | fallback_update            | OT_INT    | If indefinite update is used,   |
92399 |                            |           | the type of fallback strategy   |
92400 +----------------------------+-----------+---------------------------------+
92401 | gamma_f                    | OT_DOUBLE | Filter line search parameter,   |
92402 |                            |           | cf. IPOPT paper                 |
92403 +----------------------------+-----------+---------------------------------+
92404 | gamma_theta                | OT_DOUBLE | Filter line search parameter,   |
92405 |                            |           | cf. IPOPT paper                 |
92406 +----------------------------+-----------+---------------------------------+
92407 | globalization              | OT_BOOL   | Enable globalization            |
92408 +----------------------------+-----------+---------------------------------+
92409 | hess_damp                  | OT_INT    | Activate Powell damping for     |
92410 |                            |           | BFGS                            |
92411 +----------------------------+-----------+---------------------------------+
92412 | hess_damp_fac              | OT_DOUBLE | Damping factor for BFGS Powell  |
92413 |                            |           | modification                    |
92414 +----------------------------+-----------+---------------------------------+
92415 | hess_lim_mem               | OT_INT    | Full or limited memory          |
92416 +----------------------------+-----------+---------------------------------+
92417 | hess_memsize               | OT_INT    | Memory size for L-BFGS updates  |
92418 +----------------------------+-----------+---------------------------------+
92419 | hess_scaling               | OT_INT    | Scaling strategy for Hessian    |
92420 |                            |           | approximation                   |
92421 +----------------------------+-----------+---------------------------------+
92422 | hess_update                | OT_INT    | Type of Hessian approximation   |
92423 +----------------------------+-----------+---------------------------------+
92424 | ini_hess_diag              | OT_DOUBLE | Initial Hessian guess: diagonal |
92425 |                            |           | matrix diag(iniHessDiag)        |
92426 +----------------------------+-----------+---------------------------------+
92427 | kappa_f                    | OT_DOUBLE | Filter line search parameter,   |
92428 |                            |           | cf. IPOPT paper                 |
92429 +----------------------------+-----------+---------------------------------+
92430 | kappa_minus                | OT_DOUBLE | Filter line search parameter,   |
92431 |                            |           | cf. IPOPT paper                 |
92432 +----------------------------+-----------+---------------------------------+
92433 | kappa_plus                 | OT_DOUBLE | Filter line search parameter,   |
92434 |                            |           | cf. IPOPT paper                 |
92435 +----------------------------+-----------+---------------------------------+
92436 | kappa_plus_max             | OT_DOUBLE | Filter line search parameter,   |
92437 |                            |           | cf. IPOPT paper                 |
92438 +----------------------------+-----------+---------------------------------+
92439 | kappa_soc                  | OT_DOUBLE | Filter line search parameter,   |
92440 |                            |           | cf. IPOPT paper                 |
92441 +----------------------------+-----------+---------------------------------+
92442 | linsol                     | OT_STRING | The linear solver to be used by |
92443 |                            |           | the QP method                   |
92444 +----------------------------+-----------+---------------------------------+
92445 | max_consec_reduced_steps   | OT_INT    | Maximum number of consecutive   |
92446 |                            |           | reduced steps                   |
92447 +----------------------------+-----------+---------------------------------+
92448 | max_consec_skipped_updates | OT_INT    | Maximum number of consecutive   |
92449 |                            |           | skipped updates                 |
92450 +----------------------------+-----------+---------------------------------+
92451 | max_conv_qp                | OT_INT    | How many additional QPs may be  |
92452 |                            |           | solved for convexification per  |
92453 |                            |           | iteration?                      |
92454 +----------------------------+-----------+---------------------------------+
92455 | max_it_qp                  | OT_INT    | Maximum number of QP iterations |
92456 |                            |           | per SQP iteration               |
92457 +----------------------------+-----------+---------------------------------+
92458 | max_iter                   | OT_INT    | Maximum number of SQP           |
92459 |                            |           | iterations                      |
92460 +----------------------------+-----------+---------------------------------+
92461 | max_line_search            | OT_INT    | Maximum number of steps in line |
92462 |                            |           | search                          |
92463 +----------------------------+-----------+---------------------------------+
92464 | max_soc_iter               | OT_INT    | Maximum number of SOC line      |
92465 |                            |           | search iterations               |
92466 +----------------------------+-----------+---------------------------------+
92467 | max_time_qp                | OT_DOUBLE | Maximum number of time in       |
92468 |                            |           | seconds per QP solve per SQP    |
92469 |                            |           | iteration                       |
92470 +----------------------------+-----------+---------------------------------+
92471 | nlinfeastol                | OT_DOUBLE | Nonlinear feasibility tolerance |
92472 +----------------------------+-----------+---------------------------------+
92473 | obj_lo                     | OT_DOUBLE | Lower bound on objective        |
92474 |                            |           | function [-inf]                 |
92475 +----------------------------+-----------+---------------------------------+
92476 | obj_up                     | OT_DOUBLE | Upper bound on objective        |
92477 |                            |           | function [inf]                  |
92478 +----------------------------+-----------+---------------------------------+
92479 | opttol                     | OT_DOUBLE | Optimality tolerance            |
92480 +----------------------------+-----------+---------------------------------+
92481 | print_header               | OT_BOOL   | Print solver header at startup  |
92482 +----------------------------+-----------+---------------------------------+
92483 | print_iteration            | OT_BOOL   | Print SQP iterations            |
92484 +----------------------------+-----------+---------------------------------+
92485 | print_maxit_reached        | OT_BOOL   | Print error when maximum number |
92486 |                            |           | of SQP iterations reached       |
92487 +----------------------------+-----------+---------------------------------+
92488 | qp_init                    | OT_BOOL   | Use warmstarting                |
92489 +----------------------------+-----------+---------------------------------+
92490 | qpsol                      | OT_STRING | The QP solver to be used by the |
92491 |                            |           | SQP method                      |
92492 +----------------------------+-----------+---------------------------------+
92493 | qpsol_options              | OT_DICT   | Options to be passed to the QP  |
92494 |                            |           | solver                          |
92495 +----------------------------+-----------+---------------------------------+
92496 | restore_feas               | OT_BOOL   | Use feasibility restoration     |
92497 |                            |           | phase                           |
92498 +----------------------------+-----------+---------------------------------+
92499 | rho                        | OT_DOUBLE | Feasibility restoration phase   |
92500 |                            |           | parameter                       |
92501 +----------------------------+-----------+---------------------------------+
92502 | s_f                        | OT_DOUBLE | Filter line search parameter,   |
92503 |                            |           | cf. IPOPT paper                 |
92504 +----------------------------+-----------+---------------------------------+
92505 | s_theta                    | OT_DOUBLE | Filter line search parameter,   |
92506 |                            |           | cf. IPOPT paper                 |
92507 +----------------------------+-----------+---------------------------------+
92508 | schur                      | OT_BOOL   | Use qpOASES Schur compliment    |
92509 |                            |           | approach                        |
92510 +----------------------------+-----------+---------------------------------+
92511 | skip_first_globalization   | OT_BOOL   | No globalization strategy in    |
92512 |                            |           | first iteration                 |
92513 +----------------------------+-----------+---------------------------------+
92514 | theta_max                  | OT_DOUBLE | Filter line search parameter,   |
92515 |                            |           | cf. IPOPT paper                 |
92516 +----------------------------+-----------+---------------------------------+
92517 | theta_min                  | OT_DOUBLE | Filter line search parameter,   |
92518 |                            |           | cf. IPOPT paper                 |
92519 +----------------------------+-----------+---------------------------------+
92520 | warmstart                  | OT_BOOL   | Use warmstarting                |
92521 +----------------------------+-----------+---------------------------------+
92522 | which_second_derv          | OT_INT    | For which block should second   |
92523 |                            |           | derivatives be provided by the  |
92524 |                            |           | user                            |
92525 +----------------------------+-----------+---------------------------------+
92526 | zeta                       | OT_DOUBLE | Feasibility restoration phase   |
92527 |                            |           | parameter                       |
92528 +----------------------------+-----------+---------------------------------+
92529 
92530 --------------------------------------------------------------------------------
92531 
92532 
92533 
92534 --------------------------------------------------------------------------------
92535 
92536 bonmin
92537 ------
92538 
92539 
92540 
92541 When in warmstart mode, output NLPSOL_LAM_X may be used as input
92542 
92543 NOTE: Even when max_iter == 0, it is not guaranteed that input(NLPSOL_X0) ==
92544 output(NLPSOL_X). Indeed if bounds on X or constraints are unmet, they will
92545 differ.
92546 
92547 For a good tutorial on BONMIN,
92548 seehttp://drops.dagstuhl.de/volltexte/2009/2089/pdf/09061.WaechterAndreas.Paper.2089.pdf
92549 
92550 A good resource about the algorithms in BONMIN is: Wachter and L. T.
92551 Biegler, On the Implementation of an Interior-Point Filter Line-Search
92552 Algorithm for Large-Scale Nonlinear Programming, Mathematical Programming
92553 106(1), pp. 25-57, 2006 (As Research Report RC 23149, IBM T. J. Watson
92554 Research Center, Yorktown, USA
92555 
92556 Caveats: with default options, multipliers for the decision variables are
92557 wrong for equality constraints. Change the 'fixed_variable_treatment' to
92558 'make_constraint' or 'relax_bounds' to obtain correct results.
92559 
92560 >List of available options
92561 
92562 +-------------------------+-----------------------+------------------------+
92563 |           Id            |         Type          |      Description       |
92564 +=========================+=======================+========================+
92565 | bonmin                  | OT_DICT               | Options to be passed   |
92566 |                         |                       | to BONMIN              |
92567 +-------------------------+-----------------------+------------------------+
92568 | con_integer_md          | OT_DICT               | Integer metadata (a    |
92569 |                         |                       | dictionary with lists  |
92570 |                         |                       | of integers) about     |
92571 |                         |                       | constraints to be      |
92572 |                         |                       | passed to BONMIN       |
92573 +-------------------------+-----------------------+------------------------+
92574 | con_numeric_md          | OT_DICT               | Numeric metadata (a    |
92575 |                         |                       | dictionary with lists  |
92576 |                         |                       | of reals) about        |
92577 |                         |                       | constraints to be      |
92578 |                         |                       | passed to BONMIN       |
92579 +-------------------------+-----------------------+------------------------+
92580 | con_string_md           | OT_DICT               | String metadata (a     |
92581 |                         |                       | dictionary with lists  |
92582 |                         |                       | of strings) about      |
92583 |                         |                       | constraints to be      |
92584 |                         |                       | passed to BONMIN       |
92585 +-------------------------+-----------------------+------------------------+
92586 | grad_f                  | OT_FUNCTION           | Function for           |
92587 |                         |                       | calculating the        |
92588 |                         |                       | gradient of the        |
92589 |                         |                       | objective (column,     |
92590 |                         |                       | autogenerated by       |
92591 |                         |                       | default)               |
92592 +-------------------------+-----------------------+------------------------+
92593 | grad_f_options          | OT_DICT               | Options for the        |
92594 |                         |                       | autogenerated gradient |
92595 |                         |                       | of the objective.      |
92596 +-------------------------+-----------------------+------------------------+
92597 | hess_lag                | OT_FUNCTION           | Function for           |
92598 |                         |                       | calculating the        |
92599 |                         |                       | Hessian of the         |
92600 |                         |                       | Lagrangian             |
92601 |                         |                       | (autogenerated by      |
92602 |                         |                       | default)               |
92603 +-------------------------+-----------------------+------------------------+
92604 | hess_lag_options        | OT_DICT               | Options for the        |
92605 |                         |                       | autogenerated Hessian  |
92606 |                         |                       | of the Lagrangian.     |
92607 +-------------------------+-----------------------+------------------------+
92608 | jac_g                   | OT_FUNCTION           | Function for           |
92609 |                         |                       | calculating the        |
92610 |                         |                       | Jacobian of the        |
92611 |                         |                       | constraints            |
92612 |                         |                       | (autogenerated by      |
92613 |                         |                       | default)               |
92614 +-------------------------+-----------------------+------------------------+
92615 | jac_g_options           | OT_DICT               | Options for the        |
92616 |                         |                       | autogenerated Jacobian |
92617 |                         |                       | of the constraints.    |
92618 +-------------------------+-----------------------+------------------------+
92619 | pass_nonlinear_constrai | OT_BOOL               | Pass list of           |
92620 | nts                     |                       | constraints entering   |
92621 |                         |                       | nonlinearly to BONMIN  |
92622 +-------------------------+-----------------------+------------------------+
92623 | pass_nonlinear_variable | OT_BOOL               | Pass list of variables |
92624 | s                       |                       | entering nonlinearly   |
92625 |                         |                       | to BONMIN              |
92626 +-------------------------+-----------------------+------------------------+
92627 | sos1_groups             | OT_INTVECTORVECTOR    | Options for the        |
92628 |                         |                       | autogenerated gradient |
92629 |                         |                       | of the objective.      |
92630 +-------------------------+-----------------------+------------------------+
92631 | sos1_priorities         | OT_INTVECTOR          | Options for the        |
92632 |                         |                       | autogenerated gradient |
92633 |                         |                       | of the objective.      |
92634 +-------------------------+-----------------------+------------------------+
92635 | sos1_weights            | OT_DOUBLEVECTORVECTOR | Options for the        |
92636 |                         |                       | autogenerated gradient |
92637 |                         |                       | of the objective.      |
92638 +-------------------------+-----------------------+------------------------+
92639 | var_integer_md          | OT_DICT               | Integer metadata (a    |
92640 |                         |                       | dictionary with lists  |
92641 |                         |                       | of integers) about     |
92642 |                         |                       | variables to be passed |
92643 |                         |                       | to BONMIN              |
92644 +-------------------------+-----------------------+------------------------+
92645 | var_numeric_md          | OT_DICT               | Numeric metadata (a    |
92646 |                         |                       | dictionary with lists  |
92647 |                         |                       | of reals) about        |
92648 |                         |                       | variables to be passed |
92649 |                         |                       | to BONMIN              |
92650 +-------------------------+-----------------------+------------------------+
92651 | var_string_md           | OT_DICT               | String metadata (a     |
92652 |                         |                       | dictionary with lists  |
92653 |                         |                       | of strings) about      |
92654 |                         |                       | variables to be passed |
92655 |                         |                       | to BONMIN              |
92656 +-------------------------+-----------------------+------------------------+
92657 
92658 --------------------------------------------------------------------------------
92659 
92660 
92661 
92662 --------------------------------------------------------------------------------
92663 
92664 ipopt
92665 -----
92666 
92667 
92668 
92669 When in warmstart mode, output NLPSOL_LAM_X may be used as input
92670 
92671 NOTE: Even when max_iter == 0, it is not guaranteed that input(NLPSOL_X0) ==
92672 output(NLPSOL_X). Indeed if bounds on X or constraints are unmet, they will
92673 differ.
92674 
92675 For a good tutorial on IPOPT,
92676 seehttp://drops.dagstuhl.de/volltexte/2009/2089/pdf/09061.WaechterAndreas.Paper.2089.pdf
92677 
92678 A good resource about the algorithms in IPOPT is: Wachter and L. T. Biegler,
92679 On the Implementation of an Interior-Point Filter Line-Search Algorithm for
92680 Large-Scale Nonlinear Programming, Mathematical Programming 106(1), pp.
92681 25-57, 2006 (As Research Report RC 23149, IBM T. J. Watson Research Center,
92682 Yorktown, USA
92683 
92684 Caveats: with default options, multipliers for the decision variables are
92685 wrong for equality constraints. Change the 'fixed_variable_treatment' to
92686 'make_constraint' or 'relax_bounds' to obtain correct results.
92687 
92688 >List of available options
92689 
92690 +--------------------------+-------------+---------------------------------+
92691 |            Id            |    Type     |           Description           |
92692 +==========================+=============+=================================+
92693 | clip_inactive_lam        | OT_BOOL     | Explicitly set Lagrange         |
92694 |                          |             | multipliers to 0 when bound is  |
92695 |                          |             | deemed inactive (default:       |
92696 |                          |             | false).                         |
92697 +--------------------------+-------------+---------------------------------+
92698 | con_integer_md           | OT_DICT     | Integer metadata (a dictionary  |
92699 |                          |             | with lists of integers) about   |
92700 |                          |             | constraints to be passed to     |
92701 |                          |             | IPOPT                           |
92702 +--------------------------+-------------+---------------------------------+
92703 | con_numeric_md           | OT_DICT     | Numeric metadata (a dictionary  |
92704 |                          |             | with lists of reals) about      |
92705 |                          |             | constraints to be passed to     |
92706 |                          |             | IPOPT                           |
92707 +--------------------------+-------------+---------------------------------+
92708 | con_string_md            | OT_DICT     | String metadata (a dictionary   |
92709 |                          |             | with lists of strings) about    |
92710 |                          |             | constraints to be passed to     |
92711 |                          |             | IPOPT                           |
92712 +--------------------------+-------------+---------------------------------+
92713 | convexify_margin         | OT_DOUBLE   | When using a convexification    |
92714 |                          |             | strategy, make sure that the    |
92715 |                          |             | smallest eigenvalue is at least |
92716 |                          |             | this (default: 1e-7).           |
92717 +--------------------------+-------------+---------------------------------+
92718 | convexify_strategy       | OT_STRING   | NONE|regularize|eigen-reflect   |
92719 |                          |             | |eigen-clip. Strategy to        |
92720 |                          |             | convexify the Lagrange Hessian  |
92721 |                          |             | before passing it to the        |
92722 |                          |             | solver.                         |
92723 +--------------------------+-------------+---------------------------------+
92724 | grad_f                   | OT_FUNCTION | Function for calculating the    |
92725 |                          |             | gradient of the objective       |
92726 |                          |             | (column, autogenerated by       |
92727 |                          |             | default)                        |
92728 +--------------------------+-------------+---------------------------------+
92729 | hess_lag                 | OT_FUNCTION | Function for calculating the    |
92730 |                          |             | Hessian of the Lagrangian       |
92731 |                          |             | (autogenerated by default)      |
92732 +--------------------------+-------------+---------------------------------+
92733 | inactive_lam_strategy    | OT_STRING   | Strategy to detect if a bound   |
92734 |                          |             | is inactive. RELTOL: use        |
92735 |                          |             | solver-defined constraint       |
92736 |                          |             | tolerance *                     |
92737 |                          |             | inactive_lam_value|abstol: use  |
92738 |                          |             | inactive_lam_value              |
92739 +--------------------------+-------------+---------------------------------+
92740 | inactive_lam_value       | OT_DOUBLE   | Value used in                   |
92741 |                          |             | inactive_lam_strategy (default: |
92742 |                          |             | 10).                            |
92743 +--------------------------+-------------+---------------------------------+
92744 | ipopt                    | OT_DICT     | Options to be passed to IPOPT   |
92745 +--------------------------+-------------+---------------------------------+
92746 | jac_g                    | OT_FUNCTION | Function for calculating the    |
92747 |                          |             | Jacobian of the constraints     |
92748 |                          |             | (autogenerated by default)      |
92749 +--------------------------+-------------+---------------------------------+
92750 | max_iter_eig             | OT_DOUBLE   | Maximum number of iterations to |
92751 |                          |             | compute an eigenvalue           |
92752 |                          |             | decomposition (default: 50).    |
92753 +--------------------------+-------------+---------------------------------+
92754 | pass_nonlinear_variables | OT_BOOL     | Pass list of variables entering |
92755 |                          |             | nonlinearly to IPOPT            |
92756 +--------------------------+-------------+---------------------------------+
92757 | var_integer_md           | OT_DICT     | Integer metadata (a dictionary  |
92758 |                          |             | with lists of integers) about   |
92759 |                          |             | variables to be passed to IPOPT |
92760 +--------------------------+-------------+---------------------------------+
92761 | var_numeric_md           | OT_DICT     | Numeric metadata (a dictionary  |
92762 |                          |             | with lists of reals) about      |
92763 |                          |             | variables to be passed to IPOPT |
92764 +--------------------------+-------------+---------------------------------+
92765 | var_string_md            | OT_DICT     | String metadata (a dictionary   |
92766 |                          |             | with lists of strings) about    |
92767 |                          |             | variables to be passed to IPOPT |
92768 +--------------------------+-------------+---------------------------------+
92769 
92770 --------------------------------------------------------------------------------
92771 
92772 
92773 
92774 --------------------------------------------------------------------------------
92775 
92776 knitro
92777 ------
92778 
92779 
92780 
92781 KNITRO interface
92782 
92783 >List of available options
92784 
92785 +--------------------------+--------------------+--------------------------+
92786 |            Id            |        Type        |       Description        |
92787 +==========================+====================+==========================+
92788 | complem_variables        | OT_INTVECTORVECTOR | List of complementary    |
92789 |                          |                    | constraints on simple    |
92790 |                          |                    | bounds. Pair (i, j)      |
92791 |                          |                    | encodes complementarity  |
92792 |                          |                    | between the bounds on    |
92793 |                          |                    | variable i and variable  |
92794 |                          |                    | j.                       |
92795 +--------------------------+--------------------+--------------------------+
92796 | contype                  | OT_INTVECTOR       | Type of constraint       |
92797 +--------------------------+--------------------+--------------------------+
92798 | detect_linear_constraint | OT_BOOL            | Detect type of           |
92799 | s                        |                    | constraints              |
92800 +--------------------------+--------------------+--------------------------+
92801 | knitro                   | OT_DICT            | Options to be passed to  |
92802 |                          |                    | KNITRO                   |
92803 +--------------------------+--------------------+--------------------------+
92804 
92805 --------------------------------------------------------------------------------
92806 
92807 
92808 
92809 --------------------------------------------------------------------------------
92810 
92811 snopt
92812 -----
92813 
92814 
92815 
92816 SNOPT interface
92817 
92818 >List of available options
92819 
92820 +-------+-----------+---------------------------------------------+
92821 |  Id   |   Type    |                 Description                 |
92822 +=======+===========+=============================================+
92823 | snopt | OT_DICT   | Options to be passed to SNOPT               |
92824 +-------+-----------+---------------------------------------------+
92825 | start | OT_STRING | Warm-start options for Worhp: cold|warm|hot |
92826 +-------+-----------+---------------------------------------------+
92827 
92828 --------------------------------------------------------------------------------
92829 
92830 
92831 
92832 --------------------------------------------------------------------------------
92833 
92834 worhp
92835 -----
92836 
92837 
92838 
92839 WORHP interface
92840 
92841 Designed for Worhp 1.12
92842 
92843 >List of available options
92844 
92845 +-------+---------+-------------------------------+
92846 |  Id   |  Type   |          Description          |
92847 +=======+=========+===============================+
92848 | worhp | OT_DICT | Options to be passed to WORHP |
92849 +-------+---------+-------------------------------+
92850 
92851 --------------------------------------------------------------------------------
92852 
92853 
92854 
92855 --------------------------------------------------------------------------------
92856 
92857 qrsqp
92858 -----
92859 
92860 
92861 
92862 A textbook SQPMethod
92863 
92864 --------------------------------------------------------------------------------
92865 
92866 
92867 
92868 
92869 
92870 --------------------------------------------------------------------------------
92871 
92872 scpgen
92873 ------
92874 
92875 
92876 
92877 A structure-exploiting sequential quadratic programming (to be come
92878 sequential convex programming) method for nonlinear programming.
92879 
92880 >List of available options
92881 
92882 +-----------------------+-----------------+--------------------------------+
92883 |          Id           |      Type       |          Description           |
92884 +=======================+=================+================================+
92885 | beta                  | OT_DOUBLE       | Line-search parameter,         |
92886 |                       |                 | restoration factor of stepsize |
92887 +-----------------------+-----------------+--------------------------------+
92888 | c1                    | OT_DOUBLE       | Armijo condition, coefficient  |
92889 |                       |                 | of decrease in merit           |
92890 +-----------------------+-----------------+--------------------------------+
92891 | codegen               | OT_BOOL         | C-code generation              |
92892 +-----------------------+-----------------+--------------------------------+
92893 | hessian_approximation | OT_STRING       | gauss-newton|exact             |
92894 +-----------------------+-----------------+--------------------------------+
92895 | lbfgs_memory          | OT_INT          | Size of L-BFGS memory.         |
92896 +-----------------------+-----------------+--------------------------------+
92897 | max_iter              | OT_INT          | Maximum number of SQP          |
92898 |                       |                 | iterations                     |
92899 +-----------------------+-----------------+--------------------------------+
92900 | max_iter_ls           | OT_INT          | Maximum number of linesearch   |
92901 |                       |                 | iterations                     |
92902 +-----------------------+-----------------+--------------------------------+
92903 | merit_memsize         | OT_INT          | Size of memory to store        |
92904 |                       |                 | history of merit function      |
92905 |                       |                 | values                         |
92906 +-----------------------+-----------------+--------------------------------+
92907 | merit_start           | OT_DOUBLE       | Lower bound for the merit      |
92908 |                       |                 | function parameter             |
92909 +-----------------------+-----------------+--------------------------------+
92910 | name_x                | OT_STRINGVECTOR | Names of the variables.        |
92911 +-----------------------+-----------------+--------------------------------+
92912 | print_header          | OT_BOOL         | Print the header with problem  |
92913 |                       |                 | statistics                     |
92914 +-----------------------+-----------------+--------------------------------+
92915 | print_x               | OT_INTVECTOR    | Which variables to print.      |
92916 +-----------------------+-----------------+--------------------------------+
92917 | qpsol                 | OT_STRING       | The QP solver to be used by    |
92918 |                       |                 | the SQP method                 |
92919 +-----------------------+-----------------+--------------------------------+
92920 | qpsol_options         | OT_DICT         | Options to be passed to the QP |
92921 |                       |                 | solver                         |
92922 +-----------------------+-----------------+--------------------------------+
92923 | reg_threshold         | OT_DOUBLE       | Threshold for the              |
92924 |                       |                 | regularization.                |
92925 +-----------------------+-----------------+--------------------------------+
92926 | regularize            | OT_BOOL         | Automatic regularization of    |
92927 |                       |                 | Lagrange Hessian.              |
92928 +-----------------------+-----------------+--------------------------------+
92929 | tol_du                | OT_DOUBLE       | Stopping criterion for dual    |
92930 |                       |                 | infeasability                  |
92931 +-----------------------+-----------------+--------------------------------+
92932 | tol_pr                | OT_DOUBLE       | Stopping criterion for primal  |
92933 |                       |                 | infeasibility                  |
92934 +-----------------------+-----------------+--------------------------------+
92935 | tol_pr_step           | OT_DOUBLE       | Stopping criterion for the     |
92936 |                       |                 | step size                      |
92937 +-----------------------+-----------------+--------------------------------+
92938 | tol_reg               | OT_DOUBLE       | Stopping criterion for         |
92939 |                       |                 | regularization                 |
92940 +-----------------------+-----------------+--------------------------------+
92941 
92942 --------------------------------------------------------------------------------
92943 
92944 
92945 
92946 --------------------------------------------------------------------------------
92947 
92948 sqpmethod
92949 ---------
92950 
92951 
92952 
92953 A textbook SQPMethod
92954 
92955 >List of available options
92956 
92957 +-----------------------+-------------+------------------------------------+
92958 |          Id           |    Type     |            Description             |
92959 +=======================+=============+====================================+
92960 | beta                  | OT_DOUBLE   | Line-search parameter, restoration |
92961 |                       |             | factor of stepsize                 |
92962 +-----------------------+-------------+------------------------------------+
92963 | c1                    | OT_DOUBLE   | Armijo condition, coefficient of   |
92964 |                       |             | decrease in merit                  |
92965 +-----------------------+-------------+------------------------------------+
92966 | convexify_margin      | OT_DOUBLE   | When using a convexification       |
92967 |                       |             | strategy, make sure that the       |
92968 |                       |             | smallest eigenvalue is at least    |
92969 |                       |             | this (default: 1e-7).              |
92970 +-----------------------+-------------+------------------------------------+
92971 | convexify_strategy    | OT_STRING   | NONE|regularize|eigen-reflect      |
92972 |                       |             | |eigen-clip. Strategy to convexify |
92973 |                       |             | the Lagrange Hessian before        |
92974 |                       |             | passing it to the solver.          |
92975 +-----------------------+-------------+------------------------------------+
92976 | hess_lag              | OT_FUNCTION | Function for calculating the       |
92977 |                       |             | Hessian of the Lagrangian          |
92978 |                       |             | (autogenerated by default)         |
92979 +-----------------------+-------------+------------------------------------+
92980 | hessian_approximation | OT_STRING   | limited-memory|exact               |
92981 +-----------------------+-------------+------------------------------------+
92982 | jac_fg                | OT_FUNCTION | Function for calculating the       |
92983 |                       |             | gradient of the objective and      |
92984 |                       |             | Jacobian of the constraints        |
92985 |                       |             | (autogenerated by default)         |
92986 +-----------------------+-------------+------------------------------------+
92987 | lbfgs_memory          | OT_INT      | Size of L-BFGS memory.             |
92988 +-----------------------+-------------+------------------------------------+
92989 | max_iter              | OT_INT      | Maximum number of SQP iterations   |
92990 +-----------------------+-------------+------------------------------------+
92991 | max_iter_eig          | OT_DOUBLE   | Maximum number of iterations to    |
92992 |                       |             | compute an eigenvalue              |
92993 |                       |             | decomposition (default: 50).       |
92994 +-----------------------+-------------+------------------------------------+
92995 | max_iter_ls           | OT_INT      | Maximum number of linesearch       |
92996 |                       |             | iterations                         |
92997 +-----------------------+-------------+------------------------------------+
92998 | merit_memory          | OT_INT      | Size of memory to store history of |
92999 |                       |             | merit function values              |
93000 +-----------------------+-------------+------------------------------------+
93001 | min_iter              | OT_INT      | Minimum number of SQP iterations   |
93002 +-----------------------+-------------+------------------------------------+
93003 | min_step_size         | OT_DOUBLE   | The size (inf-norm) of the step    |
93004 |                       |             | size should not become smaller     |
93005 |                       |             | than this.                         |
93006 +-----------------------+-------------+------------------------------------+
93007 | print_header          | OT_BOOL     | Print the header with problem      |
93008 |                       |             | statistics                         |
93009 +-----------------------+-------------+------------------------------------+
93010 | print_iteration       | OT_BOOL     | Print the iterations               |
93011 +-----------------------+-------------+------------------------------------+
93012 | print_status          | OT_BOOL     | Print a status message after       |
93013 |                       |             | solving                            |
93014 +-----------------------+-------------+------------------------------------+
93015 | qpsol                 | OT_STRING   | The QP solver to be used by the    |
93016 |                       |             | SQP method [qpoases]               |
93017 +-----------------------+-------------+------------------------------------+
93018 | qpsol_options         | OT_DICT     | Options to be passed to the QP     |
93019 |                       |             | solver                             |
93020 +-----------------------+-------------+------------------------------------+
93021 | tol_du                | OT_DOUBLE   | Stopping criterion for dual        |
93022 |                       |             | infeasability                      |
93023 +-----------------------+-------------+------------------------------------+
93024 | tol_pr                | OT_DOUBLE   | Stopping criterion for primal      |
93025 |                       |             | infeasibility                      |
93026 +-----------------------+-------------+------------------------------------+
93027 
93028 --------------------------------------------------------------------------------
93029 
93030 
93031 
93032 Joel Andersson
93033 
93034 ";
93035 
93036 %feature("docstring")  casadi::casadi_qr_solve(T1 *x, casadi_int nrhs,
93037 casadi_int tr, const casadi_int *sp_v, const T1 *v, const casadi_int *sp_r,
93038 const T1 *r, const T1 *beta, const casadi_int *prinv, const casadi_int *pc,
93039 T1 *w) "
93040 
93041 [INTERNAL] ";
93042 
93043 %feature("docstring")  casadi::casadi_de_boor(T1 x, const T1 *knots,
93044 casadi_int n_knots, casadi_int degree, T1 *boor) "
93045 
93046 [INTERNAL] ";
93047 
93048 %feature("docstring")  casadi::has_conic(const std::string &name) "
93049 
93050 Check if a particular plugin is available.
93051 
93052 ";
93053 
93054 %feature("docstring")  casadi::casadi_clear_casadi_int(casadi_int *x,
93055 casadi_int n) "
93056 
93057 [INTERNAL] ";
93058 
93059 %feature("docstring")  casadi::load_conic(const std::string &name) "
93060 
93061 Explicitly load a plugin dynamically.
93062 
93063 ";
93064 
93065 %feature("docstring")  casadi::casadi_qp_du_check(casadi_qp_data< T1 > *d,
93066 casadi_int i) "
93067 
93068 [INTERNAL] ";
93069 
93070 %feature("docstring")  casadi::rootfinder_option_type(const std::string
93071 &name, const std::string &op) "
93072 
93073 Get type info for a particular option.
93074 
93075 ";
93076 
93077 %feature("docstring")  casadi::casadi_lb_eig(const casadi_int *sp_h, const
93078 T1 *h) "
93079 
93080 [INTERNAL] ";
93081 
93082 %feature("docstring")  casadi::casadi_smoothing_diff(T1 **yk, T1 *y0, T1 *J,
93083 T1 h, casadi_int n_y, const casadi_finite_diff_mem< T1 > *m) "
93084 
93085 [INTERNAL] ";
93086 
93087 %feature("docstring")  casadi::doc_interpolant(const std::string &name) "
93088 
93089 Get the documentation string for a plugin.
93090 
93091 ";
93092 
93093 %feature("docstring")  casadi::dple_n_out() "
93094 
93095 Get the number of QP solver outputs.
93096 
93097 ";
93098 
93099 %feature("docstring")  casadi::casadi_low(T1 x, const T1 *grid, casadi_int
93100 ng, casadi_int lookup_mode) "
93101 
93102 [INTERNAL] ";
93103 
93104 %feature("docstring")  casadi::load_rootfinder(const std::string &name) "
93105 
93106 Explicitly load a plugin dynamically.
93107 
93108 ";
93109 
93110 %feature("docstring")  casadi::casadi_mv(const T1 *x, const casadi_int
93111 *sp_x, const T1 *y, T1 *z, casadi_int tr) "
93112 
93113 [INTERNAL]  Sparse matrix-vector multiplication: z <- z + x*y.
93114 
93115 ";
93116 
93117 %feature("docstring")  casadi::casadi_lsqr_single_solve(const T1 *A, T1 *x,
93118 casadi_int tr, const casadi_int *sp, T1 *w) "
93119 
93120 [INTERNAL] ";
93121 
93122 %feature("docstring")  casadi::casadi_norm_2(casadi_int n, const T1 *x) "
93123 
93124 [INTERNAL]  NORM_2: ||x||_2 -> return.
93125 
93126 ";
93127 
93128 %feature("docstring")  casadi::convexify_eval(const casadi_convexify_config<
93129 T1 > *c, const T1 *Hin, T1 *Hout, casadi_int *iw, T1 *w) "
93130 
93131 [INTERNAL] ";
93132 
93133 %feature("docstring")  casadi::dense_kron_stride(casadi_int n, casadi_int m,
93134 const double *A, const double *B, double *C, casadi_int strideA, casadi_int
93135 strideB, casadi_int strideC) "
93136 
93137 [INTERNAL] ";
93138 
93139 %feature("docstring")  casadi::casadi_qp_pr_direction(casadi_qp_data< T1 >
93140 *d) "
93141 
93142 [INTERNAL] ";
93143 
93144 %feature("docstring")  casadi::casadi_forward_diff(T1 **yk, T1 *y0, T1 *J,
93145 T1 h, casadi_int n_y, const casadi_finite_diff_mem< T1 > *m) "
93146 
93147 [INTERNAL] ";
93148 
93149 %feature("docstring")  casadi::casadi_cvx_givens_apply(casadi_int n, T1 *q,
93150 T1 c, T1 s, casadi_int p) "
93151 
93152 [INTERNAL] ";
93153 
93154 %feature("docstring")  casadi::casadi_qp_kkt(casadi_qp_data< T1 > *d) "
93155 
93156 [INTERNAL] ";
93157 
93158 %feature("docstring")  casadi::casadi_qp_flip(casadi_qp_data< T1 > *d) "
93159 
93160 [INTERNAL] ";
93161 
93162 %feature("docstring")  casadi::dense_mul_nn(casadi_int n, casadi_int m,
93163 casadi_int l, const double *A, const double *B, double *C) "
93164 
93165 [INTERNAL] ";
93166 
93167 %feature("docstring")  casadi::casadi_clear(T1 *x, casadi_int n) "
93168 
93169 [INTERNAL]  CLEAR: x <- 0.
93170 
93171 ";
93172 
93173 %feature("docstring")  casadi::casadi_qr_trs(const casadi_int *sp_r, const
93174 T1 *nz_r, T1 *x, casadi_int tr) "
93175 
93176 [INTERNAL] ";
93177 
93178 %feature("docstring") casadi::_which_depends "
93179 
93180 [INTERNAL] ";
93181 
93182 %feature("docstring")  casadi::casadi_bilin(const T1 *A, const casadi_int
93183 *sp_A, const T1 *x, const T1 *y) "
93184 
93185 [INTERNAL]  Calculates dot(x, mul(A, y))
93186 
93187 ";
93188 
93189 %feature("docstring")  casadi::casadi_trans(const T1 *x, const casadi_int
93190 *sp_x, T1 *y, const casadi_int *sp_y, casadi_int *tmp) "
93191 
93192 [INTERNAL]  TRANS: y <- trans(x) , w work vector (length >= rows x)
93193 
93194 ";
93195 
93196 %feature("docstring")  casadi::casadi_nd_boor_eval(T1 *ret, casadi_int
93197 n_dims, const T1 *knots, const casadi_int *offset, const casadi_int *degree,
93198 const casadi_int *strides, const T1 *c, casadi_int m, const T1 *x, const
93199 casadi_int *lookup_mode, casadi_int *iw, T1 *w) "
93200 
93201 [INTERNAL] ";
93202 
93203 %feature("docstring")  casadi::nlpsol_out() "
93204 
93205 Get NLP solver output scheme of NLP solvers.
93206 
93207 >Output scheme: casadi::NlpsolOutput (NLPSOL_NUM_OUT = 6)
93208 
93209 +--------------+-------+---------------------------------------------------+
93210 |  Full name   | Short |                    Description                    |
93211 +==============+=======+===================================================+
93212 | NLPSOL_X     | x     | Decision variables at the optimal solution (nx x  |
93213 |              |       | 1)                                                |
93214 +--------------+-------+---------------------------------------------------+
93215 | NLPSOL_F     | f     | Cost function value at the optimal solution (1 x  |
93216 |              |       | 1)                                                |
93217 +--------------+-------+---------------------------------------------------+
93218 | NLPSOL_G     | g     | Constraints function at the optimal solution (ng  |
93219 |              |       | x 1)                                              |
93220 +--------------+-------+---------------------------------------------------+
93221 | NLPSOL_LAM_X | lam_x | Lagrange multipliers for bounds on X at the       |
93222 |              |       | solution (nx x 1)                                 |
93223 +--------------+-------+---------------------------------------------------+
93224 | NLPSOL_LAM_G | lam_g | Lagrange multipliers for bounds on G at the       |
93225 |              |       | solution (ng x 1)                                 |
93226 +--------------+-------+---------------------------------------------------+
93227 | NLPSOL_LAM_P | lam_p | Lagrange multipliers for bounds on P at the       |
93228 |              |       | solution (np x 1)                                 |
93229 +--------------+-------+---------------------------------------------------+
93230 
93231 ";
93232 
93233 %feature("docstring")  casadi::nlpsol_out(casadi_int ind) "
93234 
93235 Get output scheme name by index.
93236 
93237 >Output scheme: casadi::NlpsolOutput (NLPSOL_NUM_OUT = 6)
93238 
93239 +--------------+-------+---------------------------------------------------+
93240 |  Full name   | Short |                    Description                    |
93241 +==============+=======+===================================================+
93242 | NLPSOL_X     | x     | Decision variables at the optimal solution (nx x  |
93243 |              |       | 1)                                                |
93244 +--------------+-------+---------------------------------------------------+
93245 | NLPSOL_F     | f     | Cost function value at the optimal solution (1 x  |
93246 |              |       | 1)                                                |
93247 +--------------+-------+---------------------------------------------------+
93248 | NLPSOL_G     | g     | Constraints function at the optimal solution (ng  |
93249 |              |       | x 1)                                              |
93250 +--------------+-------+---------------------------------------------------+
93251 | NLPSOL_LAM_X | lam_x | Lagrange multipliers for bounds on X at the       |
93252 |              |       | solution (nx x 1)                                 |
93253 +--------------+-------+---------------------------------------------------+
93254 | NLPSOL_LAM_G | lam_g | Lagrange multipliers for bounds on G at the       |
93255 |              |       | solution (ng x 1)                                 |
93256 +--------------+-------+---------------------------------------------------+
93257 | NLPSOL_LAM_P | lam_p | Lagrange multipliers for bounds on P at the       |
93258 |              |       | solution (np x 1)                                 |
93259 +--------------+-------+---------------------------------------------------+
93260 
93261 ";
93262 
93263 %feature("docstring")  casadi::casadi_qp_kkt_dot(casadi_qp_data< T1 > *d,
93264 const T1 *v, casadi_int i) "
93265 
93266 [INTERNAL] ";
93267 
93268 %feature("docstring")  casadi::is_strictly_monotone(const std::vector< T >
93269 &v) "
93270 
93271 Check if the vector is strictly monotone.
93272 
93273 ";
93274 
93275 %feature("docstring")  casadi::has_linsol(const std::string &name) "
93276 
93277 Check if a particular plugin is available.
93278 
93279 ";
93280 
93281 %feature("docstring")  casadi::casadi_qp_du_direction(casadi_qp_data< T1 >
93282 *d) "
93283 
93284 [INTERNAL] ";
93285 
93286 %feature("docstring")  casadi::simpleRK(Function f, casadi_int N=10,
93287 casadi_int order=4) "
93288 
93289 Construct an explicit Runge-Kutta integrator The constructed function has
93290 three inputs, corresponding to initial state (x0), parameter (p) and
93291 integration time (h) and one output, corresponding to final state (xf).
93292 
93293 Parameters:
93294 -----------
93295 
93296 f:  ODE function with two inputs (x and p) and one output (xdot)
93297 
93298 N:  Number of integrator steps
93299 
93300 order:  Order of interpolating polynomials
93301 
93302 ";
93303 
93304 %feature("docstring")  casadi::casadi_file_slurp(const char *fname,
93305 casadi_int n, T1 *x) "
93306 
93307 [INTERNAL] ";
93308 
93309 %feature("docstring")  casadi::casadi_qp_init(casadi_qp_data< T1 > *d,
93310 casadi_int **iw, T1 **w) "
93311 
93312 [INTERNAL] ";
93313 
93314 %feature("docstring")  casadi::nlpsol_in() "
93315 
93316 Get input scheme of NLP solvers.
93317 
93318 >Input scheme: casadi::NlpsolInput (NLPSOL_NUM_IN = 8)
93319 
93320 +---------------+--------+-------------------------------------------------+
93321 |   Full name   | Short  |                   Description                   |
93322 +===============+========+=================================================+
93323 | NLPSOL_X0     | x0     | Decision variables, initial guess (nx x 1)      |
93324 +---------------+--------+-------------------------------------------------+
93325 | NLPSOL_P      | p      | Value of fixed parameters (np x 1)              |
93326 +---------------+--------+-------------------------------------------------+
93327 | NLPSOL_LBX    | lbx    | Decision variables lower bound (nx x 1),        |
93328 |               |        | default -inf.                                   |
93329 +---------------+--------+-------------------------------------------------+
93330 | NLPSOL_UBX    | ubx    | Decision variables upper bound (nx x 1),        |
93331 |               |        | default +inf.                                   |
93332 +---------------+--------+-------------------------------------------------+
93333 | NLPSOL_LBG    | lbg    | Constraints lower bound (ng x 1), default -inf. |
93334 +---------------+--------+-------------------------------------------------+
93335 | NLPSOL_UBG    | ubg    | Constraints upper bound (ng x 1), default +inf. |
93336 +---------------+--------+-------------------------------------------------+
93337 | NLPSOL_LAM_X0 | lam_x0 | Lagrange multipliers for bounds on X, initial   |
93338 |               |        | guess (nx x 1)                                  |
93339 +---------------+--------+-------------------------------------------------+
93340 | NLPSOL_LAM_G0 | lam_g0 | Lagrange multipliers for bounds on G, initial   |
93341 |               |        | guess (ng x 1)                                  |
93342 +---------------+--------+-------------------------------------------------+
93343 
93344 ";
93345 
93346 %feature("docstring")  casadi::nlpsol_in(casadi_int ind) "
93347 
93348 Get NLP solver input scheme name by index.
93349 
93350 >Input scheme: casadi::NlpsolInput (NLPSOL_NUM_IN = 8)
93351 
93352 +---------------+--------+-------------------------------------------------+
93353 |   Full name   | Short  |                   Description                   |
93354 +===============+========+=================================================+
93355 | NLPSOL_X0     | x0     | Decision variables, initial guess (nx x 1)      |
93356 +---------------+--------+-------------------------------------------------+
93357 | NLPSOL_P      | p      | Value of fixed parameters (np x 1)              |
93358 +---------------+--------+-------------------------------------------------+
93359 | NLPSOL_LBX    | lbx    | Decision variables lower bound (nx x 1),        |
93360 |               |        | default -inf.                                   |
93361 +---------------+--------+-------------------------------------------------+
93362 | NLPSOL_UBX    | ubx    | Decision variables upper bound (nx x 1),        |
93363 |               |        | default +inf.                                   |
93364 +---------------+--------+-------------------------------------------------+
93365 | NLPSOL_LBG    | lbg    | Constraints lower bound (ng x 1), default -inf. |
93366 +---------------+--------+-------------------------------------------------+
93367 | NLPSOL_UBG    | ubg    | Constraints upper bound (ng x 1), default +inf. |
93368 +---------------+--------+-------------------------------------------------+
93369 | NLPSOL_LAM_X0 | lam_x0 | Lagrange multipliers for bounds on X, initial   |
93370 |               |        | guess (nx x 1)                                  |
93371 +---------------+--------+-------------------------------------------------+
93372 | NLPSOL_LAM_G0 | lam_g0 | Lagrange multipliers for bounds on G, initial   |
93373 |               |        | guess (ng x 1)                                  |
93374 +---------------+--------+-------------------------------------------------+
93375 
93376 ";
93377 
93378 %feature("docstring")  casadi::casadi_qp_zero_blocking(casadi_qp_data< T1 >
93379 *d) "
93380 
93381 [INTERNAL] ";
93382 
93383 %feature("docstring")  casadi::conic_n_in() "
93384 
93385 Get the number of QP solver inputs.
93386 
93387 ";
93388 
93389 %feature("docstring")  casadi::doc_rootfinder(const std::string &name) "
93390 
93391 Get the documentation string for a plugin.
93392 
93393 ";
93394 
93395 %feature("docstring")  casadi::dense_mul_nt_stride(casadi_int n, casadi_int
93396 m, casadi_int l, const double *A, const double *B, double *C, casadi_int
93397 strideA, casadi_int strideB, casadi_int strideC) "
93398 
93399 [INTERNAL] ";
93400 
93401 %feature("docstring")  casadi::casadi_bfgs(const casadi_int *sp_h, T1 *h,
93402 const T1 *dx, const T1 *glag, const T1 *glag_old, T1 *w) "
93403 
93404 [INTERNAL] ";
93405 
93406 %feature("docstring")  casadi::dple_in() "
93407 
93408 Get input scheme of DPLE solvers.
93409 
93410 ";
93411 
93412 %feature("docstring")  casadi::dple_in(casadi_int ind) "
93413 
93414 Get DPLE input scheme name by index.
93415 
93416 ";
93417 
93418 %feature("docstring")  casadi::dense_copy_t_stride(casadi_int n, casadi_int
93419 m, const double *A, double *B, casadi_int strideA, casadi_int strideB) "
93420 
93421 [INTERNAL] ";
93422 
93423 %feature("docstring")  casadi::casadi_qp_print_iteration(casadi_qp_data< T1
93424 > *d, char *buf, int buf_sz) "
93425 
93426 [INTERNAL] ";
93427 
93428 %feature("docstring")  casadi::matrixName< casadi_int >() "
93429 
93430 Get typename.
93431 
93432 ";
93433 
93434 %feature("docstring")  casadi::is_monotone(const std::vector< T > &v) "
93435 
93436 Check if the vector is monotone.
93437 
93438 ";
93439 
93440 %feature("docstring")  casadi::casadi_mv_dense(const T1 *x, casadi_int
93441 nrow_x, casadi_int ncol_x, const T1 *y, T1 *z, casadi_int tr) "
93442 
93443 [INTERNAL] ";
93444 
93445 %feature("docstring")  casadi::casadi_norm_inf_mul(const T1 *x, const
93446 casadi_int *sp_x, const T1 *y, const casadi_int *sp_y, T1 *dwork, casadi_int
93447 *iwork) "
93448 
93449 [INTERNAL]  Inf-norm of a Matrix-matrix product,*
93450 
93451 Parameters:
93452 -----------
93453 
93454 dwork:  A real work vector that you must allocate Minimum size: y.size1()
93455 
93456 iwork:  A integer work vector that you must allocate Minimum size:
93457 y.size1()+x.size2()+1
93458 
93459 ";
93460 
93461 %feature("docstring")  casadi::casadi_qr_mv(const casadi_int *sp_v, const T1
93462 *v, const T1 *beta, T1 *x, casadi_int tr) "
93463 
93464 [INTERNAL] ";
93465 
93466 %feature("docstring")  casadi::casadi_fill(T1 *x, casadi_int n, T1 alpha) "
93467 
93468 [INTERNAL]  FILL: x <- alpha.
93469 
93470 ";
93471 
93472 %feature("docstring")  casadi::casadi_cvx_house(T1 *v, T1 *beta, casadi_int
93473 nv) "
93474 
93475 [INTERNAL]  Computes Householder vector beta: scalar v: vector of length nv
93476 Returns 2-norm of v
93477 
93478 Ref: Golub & Van Loan Alg 5.1.1
93479 
93480 ";
93481 
93482 %feature("docstring")  casadi::conic_out() "
93483 
93484 Get QP solver output scheme of QP solvers.
93485 
93486 ";
93487 
93488 %feature("docstring")  casadi::conic_out(casadi_int ind) "
93489 
93490 Get output scheme name by index.
93491 
93492 ";
93493 
93494 
93495 // File: namespaceIpopt.xml
93496 
93497 
93498 // File: namespacestd.xml
93499 
93500 
93501 // File: chapter1.xml
93502 
93503 
93504 // File: chapter2.xml
93505 
93506 
93507 // File: chapter3.xml
93508 
93509 
93510 // File: chapter4.xml
93511 
93512 
93513 // File: chapter5.xml
93514 
93515 
93516 // File: chapter6.xml
93517 
93518