GNU Octave  6.2.0
A high-level interpreted language, primarily intended for numerical computations, mostly compatible with Matlab
DASPK-opts.cc
Go to the documentation of this file.
1 // DO NOT EDIT!
2 // Generated automatically from ../liboctave/numeric/DASPK-opts.in.
3 
4 // This file should not include config.h. It is only included in other
5 // C++ source files that should have included config.h before including
6 // this file.
7 
8 #include <iomanip>
9 #include <ostream>
10 #include <sstream>
11 
12 #include "DASPK-opts.h"
13 
14 #include "defun.h"
15 #include "pr-output.h"
16 
17 #include "ovl.h"
18 #include "utils.h"
19 #include "pager.h"
20 
22 
23 #define MAX_TOKENS 6
24 
26 {
27  const char *keyword;
28  const char *kw_tok[MAX_TOKENS + 1];
29  int min_len[MAX_TOKENS + 1];
31 };
32 
33 #define NUM_OPTIONS 13
34 
36 {
37  { "absolute tolerance",
38  { "absolute", "tolerance", nullptr, nullptr, nullptr, nullptr, nullptr, },
39  { 2, 0, 0, 0, 0, 0, 0, }, 1, },
40 
41  { "relative tolerance",
42  { "relative", "tolerance", nullptr, nullptr, nullptr, nullptr, nullptr, },
43  { 1, 0, 0, 0, 0, 0, 0, }, 1, },
44 
45  { "compute consistent initial condition",
46  { "compute", "consistent", "initial", "condition", nullptr, nullptr, nullptr, },
47  { 1, 0, 0, 0, 0, 0, 0, }, 1, },
48 
49  { "use initial condition heuristics",
50  { "use", "initial", "condition", "heuristics", nullptr, nullptr, nullptr, },
51  { 1, 0, 0, 0, 0, 0, 0, }, 1, },
52 
53  { "initial condition heuristics",
54  { "initial", "condition", "heuristics", nullptr, nullptr, nullptr, nullptr, },
55  { 3, 1, 0, 0, 0, 0, 0, }, 2, },
56 
57  { "print initial condition info",
58  { "print", "initial", "condition", "info", nullptr, nullptr, nullptr, },
59  { 1, 0, 0, 0, 0, 0, 0, }, 1, },
60 
61  { "exclude algebraic variables from error test",
62  { "exclude", "algebraic", "variables", "from", "error", "test", nullptr, },
63  { 2, 0, 0, 0, 0, 0, 0, }, 1, },
64 
65  { "algebraic variables",
66  { "algebraic", "variables", nullptr, nullptr, nullptr, nullptr, nullptr, },
67  { 2, 0, 0, 0, 0, 0, 0, }, 1, },
68 
69  { "enforce inequality constraints",
70  { "enforce", "inequality", "constraints", nullptr, nullptr, nullptr, nullptr, },
71  { 2, 0, 0, 0, 0, 0, 0, }, 1, },
72 
73  { "inequality constraint types",
74  { "inequality", "constraint", "types", nullptr, nullptr, nullptr, nullptr, },
75  { 3, 0, 0, 0, 0, 0, 0, }, 1, },
76 
77  { "initial step size",
78  { "initial", "step", "size", nullptr, nullptr, nullptr, nullptr, },
79  { 3, 1, 0, 0, 0, 0, 0, }, 2, },
80 
81  { "maximum order",
82  { "maximum", "order", nullptr, nullptr, nullptr, nullptr, nullptr, },
83  { 1, 1, 0, 0, 0, 0, 0, }, 2, },
84 
85  { "maximum step size",
86  { "maximum", "step", "size", nullptr, nullptr, nullptr, nullptr, },
87  { 1, 1, 0, 0, 0, 0, 0, }, 2, },
88 };
89 
90 static void
91 print_DASPK_options (std::ostream& os)
92 {
93  std::ostringstream buf;
94 
95  os << "\n"
96  << "Options for DASPK include:\n\n"
97  << " keyword value\n"
98  << " ------- -----\n";
99 
101 
102  {
103  os << " "
104  << std::setiosflags (std::ios::left) << std::setw (50)
105  << list[0].keyword
106  << std::resetiosflags (std::ios::left)
107  << " ";
108 
109  Array<double> val = daspk_opts.absolute_tolerance ();
110 
111  if (val.numel () == 1)
112  {
113  os << val(0) << "\n";
114  }
115  else
116  {
117  os << "\n\n";
118  Matrix tmp = Matrix (ColumnVector (val));
119  octave_print_internal (os, tmp, false, 2);
120  os << "\n\n";
121  }
122  }
123 
124  {
125  os << " "
126  << std::setiosflags (std::ios::left) << std::setw (50)
127  << list[1].keyword
128  << std::resetiosflags (std::ios::left)
129  << " ";
130 
131  Array<double> val = daspk_opts.relative_tolerance ();
132 
133  if (val.numel () == 1)
134  {
135  os << val(0) << "\n";
136  }
137  else
138  {
139  os << "\n\n";
140  Matrix tmp = Matrix (ColumnVector (val));
141  octave_print_internal (os, tmp, false, 2);
142  os << "\n\n";
143  }
144  }
145 
146  {
147  os << " "
148  << std::setiosflags (std::ios::left) << std::setw (50)
149  << list[2].keyword
150  << std::resetiosflags (std::ios::left)
151  << " ";
152 
153  int val = daspk_opts.compute_consistent_initial_condition ();
154 
155  os << val << "\n";
156  }
157 
158  {
159  os << " "
160  << std::setiosflags (std::ios::left) << std::setw (50)
161  << list[3].keyword
162  << std::resetiosflags (std::ios::left)
163  << " ";
164 
165  int val = daspk_opts.use_initial_condition_heuristics ();
166 
167  os << val << "\n";
168  }
169 
170  {
171  os << " "
172  << std::setiosflags (std::ios::left) << std::setw (50)
173  << list[4].keyword
174  << std::resetiosflags (std::ios::left)
175  << " ";
176 
177  Array<double> val = daspk_opts.initial_condition_heuristics ();
178 
179  if (val.numel () == 1)
180  {
181  os << val(0) << "\n";
182  }
183  else
184  {
185  os << "\n\n";
186  Matrix tmp = Matrix (ColumnVector (val));
187  octave_print_internal (os, tmp, false, 2);
188  os << "\n\n";
189  }
190  }
191 
192  {
193  os << " "
194  << std::setiosflags (std::ios::left) << std::setw (50)
195  << list[5].keyword
196  << std::resetiosflags (std::ios::left)
197  << " ";
198 
199  int val = daspk_opts.print_initial_condition_info ();
200 
201  os << val << "\n";
202  }
203 
204  {
205  os << " "
206  << std::setiosflags (std::ios::left) << std::setw (50)
207  << list[6].keyword
208  << std::resetiosflags (std::ios::left)
209  << " ";
210 
211  int val = daspk_opts.exclude_algebraic_variables_from_error_test ();
212 
213  os << val << "\n";
214  }
215 
216  {
217  os << " "
218  << std::setiosflags (std::ios::left) << std::setw (50)
219  << list[7].keyword
220  << std::resetiosflags (std::ios::left)
221  << " ";
222 
223  Array<octave_idx_type> val = daspk_opts.algebraic_variables ();
224 
225  if (val.numel () == 1)
226  {
227  os << val(0) << "\n";
228  }
229  else
230  {
231  os << "\n\n";
232  octave_idx_type len = val.numel ();
233  Matrix tmp (len, 1);
234  for (octave_idx_type i = 0; i < len; i++)
235  tmp(i,0) = val(i);
236  octave_print_internal (os, tmp, false, 2);
237  os << "\n\n";
238  }
239  }
240 
241  {
242  os << " "
243  << std::setiosflags (std::ios::left) << std::setw (50)
244  << list[8].keyword
245  << std::resetiosflags (std::ios::left)
246  << " ";
247 
248  int val = daspk_opts.enforce_inequality_constraints ();
249 
250  os << val << "\n";
251  }
252 
253  {
254  os << " "
255  << std::setiosflags (std::ios::left) << std::setw (50)
256  << list[9].keyword
257  << std::resetiosflags (std::ios::left)
258  << " ";
259 
260  Array<octave_idx_type> val = daspk_opts.inequality_constraint_types ();
261 
262  if (val.numel () == 1)
263  {
264  os << val(0) << "\n";
265  }
266  else
267  {
268  os << "\n\n";
269  octave_idx_type len = val.numel ();
270  Matrix tmp (len, 1);
271  for (octave_idx_type i = 0; i < len; i++)
272  tmp(i,0) = val(i);
273  octave_print_internal (os, tmp, false, 2);
274  os << "\n\n";
275  }
276  }
277 
278  {
279  os << " "
280  << std::setiosflags (std::ios::left) << std::setw (50)
281  << list[10].keyword
282  << std::resetiosflags (std::ios::left)
283  << " ";
284 
285  double val = daspk_opts.initial_step_size ();
286 
287  os << val << "\n";
288  }
289 
290  {
291  os << " "
292  << std::setiosflags (std::ios::left) << std::setw (50)
293  << list[11].keyword
294  << std::resetiosflags (std::ios::left)
295  << " ";
296 
297  int val = daspk_opts.maximum_order ();
298 
299  os << val << "\n";
300  }
301 
302  {
303  os << " "
304  << std::setiosflags (std::ios::left) << std::setw (50)
305  << list[12].keyword
306  << std::resetiosflags (std::ios::left)
307  << " ";
308 
309  double val = daspk_opts.maximum_step_size ();
310 
311  os << val << "\n";
312  }
313 
314  os << "\n";
315 }
316 
317 static void
318 set_DASPK_options (const std::string& keyword, const octave_value& val)
319 {
321 
322  if (octave::keyword_almost_match (list[0].kw_tok, list[0].min_len,
323  keyword, list[0].min_toks_to_match, MAX_TOKENS))
324  {
325  Array<double> tmp = val.vector_value ();
326 
327  daspk_opts.set_absolute_tolerance (tmp);
328  }
329  else if (octave::keyword_almost_match (list[1].kw_tok, list[1].min_len,
330  keyword, list[1].min_toks_to_match, MAX_TOKENS))
331  {
332  Array<double> tmp = val.vector_value ();
333 
334  daspk_opts.set_relative_tolerance (tmp);
335  }
336  else if (octave::keyword_almost_match (list[2].kw_tok, list[2].min_len,
337  keyword, list[2].min_toks_to_match, MAX_TOKENS))
338  {
339  int tmp = val.int_value ();
340 
341  daspk_opts.set_compute_consistent_initial_condition (tmp);
342  }
343  else if (octave::keyword_almost_match (list[3].kw_tok, list[3].min_len,
344  keyword, list[3].min_toks_to_match, MAX_TOKENS))
345  {
346  int tmp = val.int_value ();
347 
348  daspk_opts.set_use_initial_condition_heuristics (tmp);
349  }
350  else if (octave::keyword_almost_match (list[4].kw_tok, list[4].min_len,
351  keyword, list[4].min_toks_to_match, MAX_TOKENS))
352  {
353  Array<double> tmp = val.vector_value ();
354 
355  daspk_opts.set_initial_condition_heuristics (tmp);
356  }
357  else if (octave::keyword_almost_match (list[5].kw_tok, list[5].min_len,
358  keyword, list[5].min_toks_to_match, MAX_TOKENS))
359  {
360  int tmp = val.int_value ();
361 
362  daspk_opts.set_print_initial_condition_info (tmp);
363  }
364  else if (octave::keyword_almost_match (list[6].kw_tok, list[6].min_len,
365  keyword, list[6].min_toks_to_match, MAX_TOKENS))
366  {
367  int tmp = val.int_value ();
368 
369  daspk_opts.set_exclude_algebraic_variables_from_error_test (tmp);
370  }
371  else if (octave::keyword_almost_match (list[7].kw_tok, list[7].min_len,
372  keyword, list[7].min_toks_to_match, MAX_TOKENS))
373  {
374  Array<int> tmp = val.int_vector_value ();
375 
376  daspk_opts.set_algebraic_variables (tmp);
377  }
378  else if (octave::keyword_almost_match (list[8].kw_tok, list[8].min_len,
379  keyword, list[8].min_toks_to_match, MAX_TOKENS))
380  {
381  int tmp = val.int_value ();
382 
383  daspk_opts.set_enforce_inequality_constraints (tmp);
384  }
385  else if (octave::keyword_almost_match (list[9].kw_tok, list[9].min_len,
386  keyword, list[9].min_toks_to_match, MAX_TOKENS))
387  {
388  Array<int> tmp = val.int_vector_value ();
389 
390  daspk_opts.set_inequality_constraint_types (tmp);
391  }
392  else if (octave::keyword_almost_match (list[10].kw_tok, list[10].min_len,
393  keyword, list[10].min_toks_to_match, MAX_TOKENS))
394  {
395  double tmp = val.double_value ();
396 
397  daspk_opts.set_initial_step_size (tmp);
398  }
399  else if (octave::keyword_almost_match (list[11].kw_tok, list[11].min_len,
400  keyword, list[11].min_toks_to_match, MAX_TOKENS))
401  {
402  int tmp = val.int_value ();
403 
404  daspk_opts.set_maximum_order (tmp);
405  }
406  else if (octave::keyword_almost_match (list[12].kw_tok, list[12].min_len,
407  keyword, list[12].min_toks_to_match, MAX_TOKENS))
408  {
409  double tmp = val.double_value ();
410 
411  daspk_opts.set_maximum_step_size (tmp);
412  }
413  else
414  {
415  warning ("daspk_options: no match for `%s'", keyword.c_str ());
416  }
417 }
418 
419 static octave_value_list
420 show_DASPK_options (const std::string& keyword)
421 {
423 
425 
426  if (octave::keyword_almost_match (list[0].kw_tok, list[0].min_len,
427  keyword, list[0].min_toks_to_match, MAX_TOKENS))
428  {
429  Array<double> val = daspk_opts.absolute_tolerance ();
430 
431  if (val.numel () == 1)
432  {
433  retval = val(0);
434  }
435  else
436  {
437  retval = ColumnVector (val);
438  }
439  }
440  else if (octave::keyword_almost_match (list[1].kw_tok, list[1].min_len,
441  keyword, list[1].min_toks_to_match, MAX_TOKENS))
442  {
443  Array<double> val = daspk_opts.relative_tolerance ();
444 
445  if (val.numel () == 1)
446  {
447  retval = val(0);
448  }
449  else
450  {
451  retval = ColumnVector (val);
452  }
453  }
454  else if (octave::keyword_almost_match (list[2].kw_tok, list[2].min_len,
455  keyword, list[2].min_toks_to_match, MAX_TOKENS))
456  {
457  int val = daspk_opts.compute_consistent_initial_condition ();
458 
459  retval = static_cast<double> (val);
460  }
461  else if (octave::keyword_almost_match (list[3].kw_tok, list[3].min_len,
462  keyword, list[3].min_toks_to_match, MAX_TOKENS))
463  {
464  int val = daspk_opts.use_initial_condition_heuristics ();
465 
466  retval = static_cast<double> (val);
467  }
468  else if (octave::keyword_almost_match (list[4].kw_tok, list[4].min_len,
469  keyword, list[4].min_toks_to_match, MAX_TOKENS))
470  {
471  Array<double> val = daspk_opts.initial_condition_heuristics ();
472 
473  if (val.numel () == 1)
474  {
475  retval = val(0);
476  }
477  else
478  {
479  retval = ColumnVector (val);
480  }
481  }
482  else if (octave::keyword_almost_match (list[5].kw_tok, list[5].min_len,
483  keyword, list[5].min_toks_to_match, MAX_TOKENS))
484  {
485  int val = daspk_opts.print_initial_condition_info ();
486 
487  retval = static_cast<double> (val);
488  }
489  else if (octave::keyword_almost_match (list[6].kw_tok, list[6].min_len,
490  keyword, list[6].min_toks_to_match, MAX_TOKENS))
491  {
492  int val = daspk_opts.exclude_algebraic_variables_from_error_test ();
493 
494  retval = static_cast<double> (val);
495  }
496  else if (octave::keyword_almost_match (list[7].kw_tok, list[7].min_len,
497  keyword, list[7].min_toks_to_match, MAX_TOKENS))
498  {
499  Array<octave_idx_type> val = daspk_opts.algebraic_variables ();
500 
501  if (val.numel () == 1)
502  {
503  retval = static_cast<double> (val(0));
504  }
505  else
506  {
507  octave_idx_type len = val.numel ();
508  ColumnVector tmp (len);
509  for (octave_idx_type i = 0; i < len; i++)
510  tmp(i) = val(i);
511  retval = tmp;
512  }
513  }
514  else if (octave::keyword_almost_match (list[8].kw_tok, list[8].min_len,
515  keyword, list[8].min_toks_to_match, MAX_TOKENS))
516  {
517  int val = daspk_opts.enforce_inequality_constraints ();
518 
519  retval = static_cast<double> (val);
520  }
521  else if (octave::keyword_almost_match (list[9].kw_tok, list[9].min_len,
522  keyword, list[9].min_toks_to_match, MAX_TOKENS))
523  {
524  Array<octave_idx_type> val = daspk_opts.inequality_constraint_types ();
525 
526  if (val.numel () == 1)
527  {
528  retval = static_cast<double> (val(0));
529  }
530  else
531  {
532  octave_idx_type len = val.numel ();
533  ColumnVector tmp (len);
534  for (octave_idx_type i = 0; i < len; i++)
535  tmp(i) = val(i);
536  retval = tmp;
537  }
538  }
539  else if (octave::keyword_almost_match (list[10].kw_tok, list[10].min_len,
540  keyword, list[10].min_toks_to_match, MAX_TOKENS))
541  {
542  double val = daspk_opts.initial_step_size ();
543 
544  retval = val;
545  }
546  else if (octave::keyword_almost_match (list[11].kw_tok, list[11].min_len,
547  keyword, list[11].min_toks_to_match, MAX_TOKENS))
548  {
549  int val = daspk_opts.maximum_order ();
550 
551  retval = static_cast<double> (val);
552  }
553  else if (octave::keyword_almost_match (list[12].kw_tok, list[12].min_len,
554  keyword, list[12].min_toks_to_match, MAX_TOKENS))
555  {
556  double val = daspk_opts.maximum_step_size ();
557 
558  retval = val;
559  }
560  else
561  {
562  warning ("daspk_options: no match for `%s'", keyword.c_str ());
563  }
564 
565  return retval;
566 }
567 
568 DEFUN (daspk_options, args, ,
569  doc: /* -*- texinfo -*-
570 @deftypefn {} {} daspk_options ()
571 @deftypefnx {} {val =} daspk_options (@var{opt})
572 @deftypefnx {} {} daspk_options (@var{opt}, @var{val})
573 Query or set options for the function @code{daspk}.
574 
575 When called with no arguments, the names of all available options and
576 their current values are displayed.
577 
578 Given one argument, return the value of the option @var{opt}.
579 
580 When called with two arguments, @code{daspk_options} sets the option
581 @var{opt} to value @var{val}.
582 
583 Options include
584 
585 @table @asis
586 @item @qcode{"absolute tolerance"}
587 Absolute tolerance. May be either vector or scalar. If a vector, it
588 must match the dimension of the state vector, and the relative
589 tolerance must also be a vector of the same length.
590 
591 @item @qcode{"relative tolerance"}
592 Relative tolerance. May be either vector or scalar. If a vector, it
593 must match the dimension of the state vector, and the absolute
594 tolerance must also be a vector of the same length.
595 
596 The local error test applied at each integration step is
597 
598 @example
599 @group
600  abs (local error in x(i))
601  <= rtol(i) * abs (Y(i)) + atol(i)
602 @end group
603 @end example
604 
605 @item @qcode{"compute consistent initial condition"}
606 Denoting the differential variables in the state vector by @samp{Y_d}
607 and the algebraic variables by @samp{Y_a}, @code{ddaspk} can solve
608 one of two initialization problems:
609 
610 @enumerate
611 @item Given Y_d, calculate Y_a and Y'_d
612 
613 @item Given Y', calculate Y.
614 @end enumerate
615 
616 In either case, initial values for the given components are input, and
617 initial guesses for the unknown components must also be provided as
618 input. Set this option to 1 to solve the first problem, or 2 to solve
619 the second (the default is 0, so you must provide a set of
620 initial conditions that are consistent).
621 
622 If this option is set to a nonzero value, you must also set the
623 @qcode{"algebraic variables"} option to declare which variables in the
624 problem are algebraic.
625 
626 @item @qcode{"use initial condition heuristics"}
627 Set to a nonzero value to use the initial condition heuristics options
628 described below.
629 
630 @item @qcode{"initial condition heuristics"}
631 A vector of the following parameters that can be used to control the
632 initial condition calculation.
633 
634 @table @code
635 @item MXNIT
636 Maximum number of Newton iterations (default is 5).
637 
638 @item MXNJ
639 Maximum number of Jacobian evaluations (default is 6).
640 
641 @item MXNH
642 Maximum number of values of the artificial stepsize parameter to be
643 tried if the @qcode{"compute consistent initial condition"} option has
644 been set to 1 (default is 5).
645 
646 Note that the maximum total number of Newton iterations allowed is
647 @code{MXNIT*MXNJ*MXNH} if the @qcode{"compute consistent initial
648 condition"} option has been set to 1 and @code{MXNIT*MXNJ} if it is
649 set to 2.
650 
651 @item LSOFF
652 Set to a nonzero value to disable the linesearch algorithm (default is
653 0).
654 
655 @item STPTOL
656 Minimum scaled step in linesearch algorithm (default is eps^(2/3)).
657 
658 @item EPINIT
659 Swing factor in the Newton iteration convergence test. The test is
660 applied to the residual vector, premultiplied by the approximate
661 Jacobian. For convergence, the weighted RMS norm of this vector
662 (scaled by the error weights) must be less than @code{EPINIT*EPCON},
663 where @code{EPCON} = 0.33 is the analogous test constant used in the
664 time steps. The default is @code{EPINIT} = 0.01.
665 @end table
666 
667 @item @qcode{"print initial condition info"}
668 Set this option to a nonzero value to display detailed information
669 about the initial condition calculation (default is 0).
670 
671 @item @qcode{"exclude algebraic variables from error test"}
672 Set to a nonzero value to exclude algebraic variables from the error
673 test. You must also set the @qcode{"algebraic variables"} option to
674 declare which variables in the problem are algebraic (default is 0).
675 
676 @item @qcode{"algebraic variables"}
677 A vector of the same length as the state vector. A nonzero element
678 indicates that the corresponding element of the state vector is an
679 algebraic variable (i.e., its derivative does not appear explicitly
680 in the equation set).
681 
682 This option is required by the
683 @qcode{"compute consistent initial condition"} and
684 @qcode{"exclude algebraic variables from error test"} options.
685 
686 @item @qcode{"enforce inequality constraints"}
687 Set to one of the following values to enforce the inequality
688 constraints specified by the @qcode{"inequality constraint types"}
689 option (default is 0).
690 
691 @enumerate
692 @item To have constraint checking only in the initial condition calculation.
693 
694 @item To enforce constraint checking during the integration.
695 
696 @item To enforce both options 1 and 2.
697 @end enumerate
698 
699 @item @qcode{"inequality constraint types"}
700 A vector of the same length as the state specifying the type of
701 inequality constraint. Each element of the vector corresponds to an
702 element of the state and should be assigned one of the following
703 codes
704 
705 @table @asis
706 @item -2
707 Less than zero.
708 
709 @item -1
710 Less than or equal to zero.
711 
712 @item 0
713 Not constrained.
714 
715 @item 1
716 Greater than or equal to zero.
717 
718 @item 2
719 Greater than zero.
720 @end table
721 
722 This option only has an effect if the
723 @qcode{"enforce inequality constraints"} option is nonzero.
724 
725 @item @qcode{"initial step size"}
726 Differential-algebraic problems may occasionally suffer from severe
727 scaling difficulties on the first step. If you know a great deal
728 about the scaling of your problem, you can help to alleviate this
729 problem by specifying an initial stepsize (default is computed
730 automatically).
731 
732 @item @qcode{"maximum order"}
733 Restrict the maximum order of the solution method. This option must
734 be between 1 and 5, inclusive (default is 5).
735 
736 @item @qcode{"maximum step size"}
737 Setting the maximum stepsize will avoid passing over very large
738 regions (default is not specified).
739 @end table
740 @end deftypefn */)
741 {
743 
744  int nargin = args.length ();
745 
746  if (nargin > 2)
747  print_usage ();
748 
749  if (nargin == 0)
750  {
752  }
753  else
754  {
755  std::string keyword = args(0).xstring_value ("daspk_options: expecting keyword as first argument");
756 
757  if (nargin == 1)
758  retval = show_DASPK_options (keyword);
759  else
760  set_DASPK_options (keyword, args(1));
761  }
762 
763  return retval;
764 }
#define MAX_TOKENS
Definition: DASPK-opts.cc:23
static DASPK_options_struct DASPK_options_table[]
Definition: DASPK-opts.cc:35
static void set_DASPK_options(const std::string &keyword, const octave_value &val)
Definition: DASPK-opts.cc:318
static void print_DASPK_options(std::ostream &os)
Definition: DASPK-opts.cc:91
static octave_value_list show_DASPK_options(const std::string &keyword)
Definition: DASPK-opts.cc:420
static DASPK_options daspk_opts
Definition: DASPK-opts.cc:21
octave_idx_type numel(void) const
Number of elements in the array.
Definition: Array.h:377
Definition: dMatrix.h:42
int int_value(bool req_int=false, bool frc_str_conv=false) const
Definition: ov.h:765
Array< double > vector_value(bool frc_str_conv=false, bool frc_vec_conv=false) const
Array< int > int_vector_value(bool req_int=false, bool frc_str_conv=false, bool frc_vec_conv=false) const
double double_value(bool frc_str_conv=false) const
Definition: ov.h:794
OCTINTERP_API void print_usage(void)
Definition: defun.cc:53
#define DEFUN(name, args_name, nargout_name, doc)
Macro to define a builtin function.
Definition: defun.h:56
void warning(const char *fmt,...)
Definition: error.cc:1050
static int left
Definition: randmtzig.cc:191
int keyword_almost_match(const char *const *std, int *min_len, const std::string &s, int min_toks_to_match, int max_toks)
Definition: utils.cc:272
octave_value::octave_value(const Array< char > &chm, char type) return retval
Definition: ov.cc:811
#define octave_stdout
Definition: pager.h:313
void octave_print_internal(std::ostream &os, const float_display_format &fmt, bool d, bool pr_as_read_syntax)
Definition: pr-output.cc:1762
const char * kw_tok[6+1]
Definition: DASPK-opts.cc:28
const char * keyword
Definition: DASPK-opts.cc:27
F77_RET_T len
Definition: xerbla.cc:61