This is Info file liboctave.info, produced by Makeinfo version 1.67
from the input file ./liboctave.texi.

   Copyright (C) 1996 John W. Eaton.

   Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.

   Permission is granted to copy and distribute modified versions of
this manual under the conditions for verbatim copying, provided that
the entire resulting derived work is distributed under the terms of a
permission notice identical to this one.

   Permission is granted to copy and distribute translations of this
manual into another language, under the above conditions for modified
versions.


File: liboctave.info,  Node: Quadrature,  Next: Ordinary Differential Equations,  Prev: Optimization,  Up: Top

Quadrature
**********

 - :  Quad (integrand_fcn FCN)
 - :  Quad (integrand_fcn FCN, double ABS, double REL)

 - : virtual double integrate (void)
 - : virtual double integrate (int &IER)
 - : virtual double integrate (int &IER, int &NEVAL)
 - : virtual double integrate (int &IER, int &NEVAL, double &ABSERR) = 0

 - : Quad_options (void)
 - : Quad_options (const Quad_options &OPT)

 - : Quad_options& operator = (const Quad_options &OPT)

 - : void init (void)

 - : void copy (const Quad_options &OPT)

 - : void set_default_options (void)

 - : void set_absolute_tolerance (double VAL)

 - : void set_relative_tolerance (double VAL)

 - : double absolute_tolerance (void)
 - : double relative_tolerance (void)

 - :  DefQuad (integrand_fcn FCN)
 - :  DefQuad (integrand_fcn FCN, double LL, double UL)
 - :  DefQuad (integrand_fcn FCN, double LL, double UL, double ABS,
          double REL)
 - :  DefQuad (integrand_fcn FCN, double LL, double UL, const
          ColumnVector &SING)
 - :  DefQuad (integrand_fcn FCN, const ColumnVector &SING, double ABS,
          double REL)
 - :  DefQuad (integrand_fcn FCN, const ColumnVector &SING)
 - :  DefQuad (integrand_fcn FCN, double LL, double UL, const
          ColumnVector &SING, double ABS, double REL)

 - :  IndefQuad (integrand_fcn FCN)
 - :  IndefQuad (integrand_fcn FCN, double B, IntegralType T)
 - :  IndefQuad (integrand_fcn FCN, double B, IntegralType T, double
          ABS, double REL)
 - :  IndefQuad (integrand_fcn FCN, double ABS, double REL)

* Menu:

* Collocation Weights::


File: liboctave.info,  Node: Collocation Weights,  Prev: Quadrature,  Up: Quadrature

Collocation Weights
===================

 - :  CollocWt (void)
 - :  CollocWt (int N, int INC_L, int INC_R)
 - :  CollocWt (int N, int INC_L, int INC_R, double L, double R)
 - :  CollocWt (int N, double A, double B, int INC_L, int INC_R)
 - :  CollocWt (int N, int INC_L, int INC_R, double L, double R)
 - :  CollocWt (const CollocWt&)

 - : CollocWt& operator = (const CollocWt&)

 - : CollocWt& resize (int NCOL)

 - : CollocWt& add_left (void)
 - : CollocWt& add_right (void)

 - : CollocWt& delete_left (void)
 - : CollocWt& delete_right (void)

 - : CollocWt& set_left (double VAL)
 - : CollocWt& set_right (double VAL)

 - : CollocWt& set_alpha (double VAL)
 - : CollocWt& set_beta (double VAL)

 - : int ncol (void) const

 - : int left_included (void) const
 - : int right_included (void) const

 - : double left (void) const
 - : double right (void) const
 - : double width (void) const

 - : double alpha (void) const
 - : double beta (void) const

 - : ColumnVector roots (void)
 - : ColumnVector quad (void)
 - : ColumnVector quad_weights (void)

 - : Matrix first (void)
 - : Matrix second (void)

 - : ostream& operator << (ostream &OS, const CollocWt &C)


File: liboctave.info,  Node: Ordinary Differential Equations,  Next: Differential Algebraic Equations,  Prev: Quadrature,  Up: Top

Ordinary Differential Equations
*******************************

 - :  ODE_options (void)
 - :  ODE_options (const ODE_options &OPT)

 - : ODE_options& operator = (const ODE_options &OPT)

 - : void init (void)

 - : void copy (const ODE_options &OPT)

 - : void set_default_options (void)

 - : void set_absolute_tolerance (double VAL)

 - : void set_initial_step_size (double VAL)

 - : void set_maximum_step_size (double VAL)

 - : void set_minimum_step_size (double VAL)

 - : void set_relative_tolerance (double VAL)

 - : double absolute_tolerance (void)
 - : double initial_step_size (void)
 - : double maximum_step_size (void)
 - : double minimum_step_size (void)
 - : double relative_tolerance (void)

 - :  ODE (void)
 - :  ODE (int N)
 - :  ODE (const ColumnVector &STATE, double TIME, const ODEFunc &F)

 - : virtual int size (void) const

 - : virtual ColumnVector state (void) const

 - : virtual double time (void) const

 - : virtual void force_restart (void)

 - : virtual void initialize (const ColumnVector &X, double T)

 - : virtual void set_stop_time (double T)

 - : virtual void clear_stop_time (void)

 - : virtual ColumnVector integrate (double T)

 - : void integrate (int NSTEPS, double TSTEP, ostream &S)

 - : Matrix integrate (const ColumnVector &TOUT)
 - : Matrix integrate (const ColumnVector &TOUT, const ColumnVector
          &TCRIT)


File: liboctave.info,  Node: Differential Algebraic Equations,  Next: Error Handling,  Prev: Ordinary Differential Equations,  Up: Top

Differential Algebraic Equations
********************************

 - :  DAE (void)
 - :  DAE (int N)
 - :  DAE (const ColumnVector &X, double TIME, DAEFunc &F)
 - :  DAE (const ColumnVector &X, ColumnVector &XDOT, double TIME,
          DAEFunc &F)

 - : ColumnVector deriv (void)

 - : virtual void initialize (const ColumnVector &X, double T)
 - : virtual void initialize (const ColumnVector &X, ColumnVector
          &XDOT, double T)

 - : ColumnVector integrate (double T)

 - : Matrix integrate (const ColumnVector &TOUT, Matrix &XDOT_OUT)
 - : Matrix integrate (const ColumnVector &TOUT, Matrix &XDOT_OUT,
          const ColumnVector &TCRIT)


File: liboctave.info,  Node: Error Handling,  Next: Installation,  Prev: Differential Algebraic Equations,  Up: Top

Error Handling
**************


File: liboctave.info,  Node: Installation,  Next: Bugs,  Prev: Error Handling,  Up: Top

Installation
************


File: liboctave.info,  Node: Bugs,  Next: Concept Index,  Prev: Installation,  Up: Top

Bugs
****


File: liboctave.info,  Node: Concept Index,  Next: Function Index,  Prev: Bugs,  Up: Top

Concept Index
*************

* Menu:

* acknowledgements:                      Acknowledgements.
* arrays:                                Arrays.
* bounds:                                Bounds.
* bugs, known:                           Bugs.
* collocation weights:                   Collocation Weights.
* contributors:                          Contributors.
* copyright:                             Contributors.
* DAE:                                   Differential Algebraic Equations.
* factorizations:                        Matrix Factorizations.
* installation:                          Installation.
* installation trouble:                  Bugs.
* integration:                           Quadrature.
* introduction:                          Introduction.
* known causes of trouble:               Bugs.
* linear Constraints:                    Linear Constraints.
* matrix factorizations:                 Matrix Factorizations.
* matrix manipulations:                  Matrix and Vector @var{Operations}.
* NLP:                                   Nonlinear Programming.
* nonlinear Constraints:                 Nonlinear Constraints.
* nonlinear equations:                   Nonlinear Equations.
* nonlinear functions:                   Nonlinear Functions.
* nonlinear programming:                 Nonlinear Programming.
* numerical integration:                 Quadrature.
* objective functions:                   Objective Functions.
* ODE:                                   Ordinary Differential Equations.
* optimization:                          Optimization.
* orthogonal collocation:                Collocation Weights.
* QP:                                    Quadratic Programming.
* quadratic programming:                 Quadratic Programming.
* quadrature:                            Quadrature.
* ranges:                                Ranges.
* troubleshooting:                       Bugs.
* vector manipulations:                  Matrix and Vector @var{Operations}.
* warranty:                              Contributors.


File: liboctave.info,  Node: Function Index,  Prev: Concept Index,  Up: Top

Function Index
**************

* Menu:

* ( <1>:                                 Quadrature.
* ( <2>:                                 Matrix Factorizations.
* (:                                     Constructors and Assignment.
* absolute_tolerance <1>:                Ordinary Differential Equations.
* absolute_tolerance:                    Quadrature.
* add_left:                              Collocation Weights.
* add_right:                             Collocation Weights.
* AEPBALANCE:                            Matrix Factorizations.
* all:                                   Matrix and Vector @var{Operations}.
* alpha:                                 Collocation Weights.
* any:                                   Matrix and Vector @var{Operations}.
* append:                                Matrix and Vector @var{Operations}.
* Array2:                                Constructors and Assignment.
* Array<T>::Array:                       Constructors and Assignment.
* Array<T>::capacity:                    Constructors and Assignment.
* Array<T>::checkelem:                   Constructors and Assignment.
* Array<T>::data:                        Constructors and Assignment.
* Array<T>::elem:                        Constructors and Assignment.
* Array<T>::length:                      Constructors and Assignment.
* Array<T>::operator:                    Constructors and Assignment.
* Array<T>::operator ():                 Constructors and Assignment.
* Array<T>::operator =:                  Constructors and Assignment.
* Array<T>::resize:                      Constructors and Assignment.
* Array<T>::xelem:                       Constructors and Assignment.
* balanced_a_matrix:                     Matrix Factorizations.
* balanced_b_matrix:                     Matrix Factorizations.
* balanced_matrix:                       Matrix Factorizations.
* balancing_matrix:                      Matrix Factorizations.
* base:                                  Ranges.
* beta:                                  Collocation Weights.
* Bounds:                                Bounds.
* central_difference_interval:           Nonlinear Programming.
* checkelem:                             Constructors and Assignment.
* CHOL:                                  Matrix Factorizations.
* chol_matrix:                           Matrix Factorizations.
* clear_stop_time:                       Ordinary Differential Equations.
* coefficient:                           Matrix Factorizations.
* CollocWt:                              Collocation Weights.
* cols:                                  Constructors and Assignment.
* column:                                Matrix and Vector @var{Operations}.
* column_max:                            Matrix and Vector @var{Operations}.
* column_max_loc:                        Matrix and Vector @var{Operations}.
* column_min:                            Matrix and Vector @var{Operations}.
* column_min_loc:                        Matrix and Vector @var{Operations}.
* columns:                               Constructors and Assignment.
* ColumnVector:                          Matrix and Vector @var{Operations}.
* ComplexCHOL:                           Matrix Factorizations.
* ComplexColumnVector:                   Matrix and Vector @var{Operations}.
* ComplexDET:                            Matrix Factorizations.
* ComplexDiagMatrix:                     Matrix and Vector @var{Operations}.
* ComplexHESS:                           Matrix Factorizations.
* ComplexLU:                             Matrix Factorizations.
* ComplexMatrix:                         Matrix and Vector @var{Operations}.
* ComplexQR:                             Matrix Factorizations.
* ComplexRowVector:                      Matrix and Vector @var{Operations}.
* ComplexSCHUR:                          Matrix Factorizations.
* ComplexSVD:                            Matrix Factorizations.
* conj:                                  Matrix and Vector @var{Operations}.
* constraint_matrix:                     Linear Constraints.
* copy <1>:                              Ordinary Differential Equations.
* copy <2>:                              Quadrature.
* copy <3>:                              Nonlinear Programming.
* copy <4>:                              Quadratic Programming.
* copy:                                  Nonlinear Equations.
* crash_tolerance:                       Nonlinear Programming.
* cumprod:                               Matrix and Vector @var{Operations}.
* cumsum:                                Matrix and Vector @var{Operations}.
* DAE:                                   Differential Algebraic Equations.
* DefQuad:                               Quadrature.
* delete_left:                           Collocation Weights.
* delete_right:                          Collocation Weights.
* deriv:                                 Differential Algebraic Equations.
* derivative_level:                      Nonlinear Programming.
* DET:                                   Matrix Factorizations.
* determinant:                           Matrix and Vector @var{Operations}.
* diag:                                  Matrix and Vector @var{Operations}.
* DiagArray:                             Constructors and Assignment.
* DiagMatrix:                            Matrix and Vector @var{Operations}.
* difference_interval:                   Nonlinear Programming.
* dim1:                                  Constructors and Assignment.
* dim2:                                  Constructors and Assignment.
* dim3:                                  Constructors and Assignment.
* EIG:                                   Matrix Factorizations.
* eigenvalues:                           Matrix Factorizations.
* eigenvectors:                          Matrix Factorizations.
* elem:                                  Constructors and Assignment.
* eq_constraint_matrix:                  Linear Constraints.
* eq_constraint_vector:                  Linear Constraints.
* exponent:                              Matrix Factorizations.
* extract:                               Matrix and Vector @var{Operations}.
* feasibility_tolerance:                 Quadratic Programming.
* fill:                                  Matrix and Vector @var{Operations}.
* first:                                 Collocation Weights.
* force_restart:                         Ordinary Differential Equations.
* fourier:                               Matrix and Vector @var{Operations}.
* function:                              Nonlinear Functions.
* function_precision:                    Nonlinear Programming.
* GEPBALANCE:                            Matrix Factorizations.
* gradient_function:                     Objective Functions.
* HESS:                                  Matrix Factorizations.
* hess_matrix:                           Matrix Factorizations.
* ifourier:                              Matrix and Vector @var{Operations}.
* imag:                                  Matrix and Vector @var{Operations}.
* inc:                                   Ranges.
* IndefQuad:                             Quadrature.
* ineq_constraint_matrix:                Linear Constraints.
* ineq_constraint_vector:                Linear Constraints.
* infinite_bound <1>:                    Nonlinear Programming.
* infinite_bound:                        Quadratic Programming.
* infinite_step:                         Nonlinear Programming.
* init <1>:                              Ordinary Differential Equations.
* init <2>:                              Quadrature.
* init <3>:                              Nonlinear Programming.
* init <4>:                              Quadratic Programming.
* init:                                  Nonlinear Equations.
* initial_step_size:                     Ordinary Differential Equations.
* initialize <1>:                        Differential Algebraic Equations.
* initialize:                            Ordinary Differential Equations.
* insert:                                Matrix and Vector @var{Operations}.
* integrate <1>:                         Differential Algebraic Equations.
* integrate <2>:                         Ordinary Differential Equations.
* integrate:                             Quadrature.
* inverse:                               Matrix and Vector @var{Operations}.
* iteration_limit:                       Quadratic Programming.
* jacobian_function:                     Nonlinear Functions.
* L:                                     Matrix Factorizations.
* left:                                  Collocation Weights.
* left_balancing_matrix:                 Matrix Factorizations.
* left_included:                         Collocation Weights.
* left_singular_matrix:                  Matrix Factorizations.
* limit:                                 Ranges.
* LinConst:                              Linear Constraints.
* linear_feasibility_tolerance:          Nonlinear Programming.
* linesearch_tolerance:                  Nonlinear Programming.
* lower_bound:                           Bounds.
* lower_bounds:                          Bounds.
* lssolve:                               Matrix and Vector @var{Operations}.
* LU:                                    Matrix Factorizations.
* major_iteration_limit:                 Nonlinear Programming.
* major_print_level:                     Nonlinear Programming.
* map:                                   Matrix and Vector @var{Operations}.
* Matrix:                                Matrix and Vector @var{Operations}.
* max <1>:                               Ranges.
* max:                                   Matrix and Vector @var{Operations}.
* maximum_step_size:                     Ordinary Differential Equations.
* min <1>:                               Ranges.
* min:                                   Matrix and Vector @var{Operations}.
* minimize <1>:                          Nonlinear Programming.
* minimize:                              Quadratic Programming.
* minimum_step_size:                     Ordinary Differential Equations.
* minor_iteration_limit:                 Nonlinear Programming.
* minor_print_level:                     Nonlinear Programming.
* ncol:                                  Collocation Weights.
* nelem:                                 Ranges.
* NLConst:                               Nonlinear Constraints.
* NLEqn:                                 Nonlinear Equations.
* NLEqn_options:                         Nonlinear Equations.
* NLFunc:                                Nonlinear Functions.
* NLP:                                   Nonlinear Programming.
* nonlinear_feasibility_tolerance:       Nonlinear Programming.
* NPSOL:                                 Nonlinear Programming.
* NPSOL_options:                         Nonlinear Programming.
* Objective:                             Objective Functions.
* objective_function:                    Objective Functions.
* ODE:                                   Ordinary Differential Equations.
* ODE_options:                           Ordinary Differential Equations.
* operator !:                            Matrix and Vector @var{Operations}.
* operator !=:                           Matrix and Vector @var{Operations}.
* operator ():                           Constructors and Assignment.
* operator * <1>:                        Matrix and Vector @var{Operations}.
* operator *:                            Constructors and Assignment.
* operator + <1>:                        Matrix and Vector @var{Operations}.
* operator +:                            Constructors and Assignment.
* operator +=:                           Matrix and Vector @var{Operations}.
* operator - <1>:                        Matrix and Vector @var{Operations}.
* operator -:                            Constructors and Assignment.
* operator -=:                           Matrix and Vector @var{Operations}.
* operator / <1>:                        Matrix and Vector @var{Operations}.
* operator /:                            Constructors and Assignment.
* operator << <1>:                       Collocation Weights.
* operator << <2>:                       Linear Constraints.
* operator << <3>:                       Bounds.
* operator << <4>:                       Ranges.
* operator << <5>:                       Matrix Factorizations.
* operator <<:                           Matrix and Vector @var{Operations}.
* operator = <1>:                        Ordinary Differential Equations.
* operator = <2>:                        Collocation Weights.
* operator = <3>:                        Quadrature.
* operator = <4>:                        Nonlinear Programming.
* operator = <5>:                        Quadratic Programming.
* operator = <6>:                        Nonlinear Constraints.
* operator = <7>:                        Linear Constraints.
* operator = <8>:                        Bounds.
* operator = <9>:                        Objective Functions.
* operator = <10>:                       Nonlinear Equations.
* operator = <11>:                       Nonlinear Functions.
* operator = <12>:                       Matrix Factorizations.
* operator = <13>:                       Matrix and Vector @var{Operations}.
* operator =:                            Constructors and Assignment.
* operator ==:                           Matrix and Vector @var{Operations}.
* operator >> <1>:                       Ranges.
* operator >>:                           Matrix and Vector @var{Operations}.
* optimality_tolerance:                  Nonlinear Programming.
* P:                                     Matrix Factorizations.
* print_level:                           Quadratic Programming.
* print_range:                           Ranges.
* prod:                                  Matrix and Vector @var{Operations}.
* product <1>:                           Matrix and Vector @var{Operations}.
* product:                               Constructors and Assignment.
* Q:                                     Matrix Factorizations.
* QP:                                    Quadratic Programming.
* QPSOL:                                 Quadratic Programming.
* QPSOL_options:                         Quadratic Programming.
* QR:                                    Matrix Factorizations.
* quad:                                  Collocation Weights.
* Quad:                                  Quadrature.
* quad_weights:                          Collocation Weights.
* quotient <1>:                          Matrix and Vector @var{Operations}.
* quotient:                              Constructors and Assignment.
* R:                                     Matrix Factorizations.
* Range:                                 Ranges.
* real:                                  Matrix and Vector @var{Operations}.
* relative_tolerance <1>:                Ordinary Differential Equations.
* relative_tolerance:                    Quadrature.
* resize <1>:                            Collocation Weights.
* resize <2>:                            Linear Constraints.
* resize <3>:                            Bounds.
* resize <4>:                            Nonlinear Equations.
* resize:                                Constructors and Assignment.
* right:                                 Collocation Weights.
* right_balancing_matrix:                Matrix Factorizations.
* right_included:                        Collocation Weights.
* right_singular_matrix:                 Matrix Factorizations.
* roots:                                 Collocation Weights.
* row:                                   Matrix and Vector @var{Operations}.
* row_max:                               Matrix and Vector @var{Operations}.
* row_max_loc:                           Matrix and Vector @var{Operations}.
* row_min:                               Matrix and Vector @var{Operations}.
* row_min_loc:                           Matrix and Vector @var{Operations}.
* rows:                                  Constructors and Assignment.
* RowVector:                             Matrix and Vector @var{Operations}.
* SCHUR:                                 Matrix Factorizations.
* schur_matrix:                          Matrix Factorizations.
* second:                                Collocation Weights.
* set_absolute_tolerance <1>:            Ordinary Differential Equations.
* set_absolute_tolerance:                Quadrature.
* set_alpha:                             Collocation Weights.
* set_base:                              Ranges.
* set_beta:                              Collocation Weights.
* set_bound:                             Bounds.
* set_bounds:                            Bounds.
* set_central_difference_interval:       Nonlinear Programming.
* set_constraint_matrix:                 Linear Constraints.
* set_crash_tolerance:                   Nonlinear Programming.
* set_default_options <1>:               Ordinary Differential Equations.
* set_default_options <2>:               Quadrature.
* set_default_options <3>:               Nonlinear Programming.
* set_default_options <4>:               Quadratic Programming.
* set_default_options:                   Nonlinear Equations.
* set_derivative_level:                  Nonlinear Programming.
* set_difference_interval:               Nonlinear Programming.
* set_feasibility_tolerance:             Quadratic Programming.
* set_function:                          Nonlinear Functions.
* set_function_precision:                Nonlinear Programming.
* set_gradient_function:                 Objective Functions.
* set_inc:                               Ranges.
* set_infinite_bound <1>:                Nonlinear Programming.
* set_infinite_bound:                    Quadratic Programming.
* set_infinite_step:                     Nonlinear Programming.
* set_initial_step_size:                 Ordinary Differential Equations.
* set_iteration_limit:                   Quadratic Programming.
* set_jacobian_function:                 Nonlinear Functions.
* set_left:                              Collocation Weights.
* set_limit:                             Ranges.
* set_linear_feasibility_tolerance:      Nonlinear Programming.
* set_linesearch_tolerance:              Nonlinear Programming.
* set_lower_bound:                       Bounds.
* set_lower_bounds:                      Bounds.
* set_major_iteration_limit:             Nonlinear Programming.
* set_major_print_level:                 Nonlinear Programming.
* set_maximum_step_size:                 Ordinary Differential Equations.
* set_minimum_step_size:                 Ordinary Differential Equations.
* set_minor_iteration_limit:             Nonlinear Programming.
* set_minor_print_level:                 Nonlinear Programming.
* set_nonlinear_feasibility_tolerance:   Nonlinear Programming.
* set_objective_function:                Objective Functions.
* set_optimality_tolerance:              Nonlinear Programming.
* set_print_level:                       Quadratic Programming.
* set_relative_tolerance <1>:            Ordinary Differential Equations.
* set_relative_tolerance:                Quadrature.
* set_right:                             Collocation Weights.
* set_start_constraint_check:            Nonlinear Programming.
* set_start_objective_check:             Nonlinear Programming.
* set_states:                            Nonlinear Equations.
* set_stop_constraint_check:             Nonlinear Programming.
* set_stop_objective_check:              Nonlinear Programming.
* set_stop_time:                         Ordinary Differential Equations.
* set_tolerance:                         Nonlinear Equations.
* set_upper_bound:                       Bounds.
* set_upper_bounds:                      Bounds.
* set_verify_level:                      Nonlinear Programming.
* singular_values:                       Matrix Factorizations.
* size <1>:                              Ordinary Differential Equations.
* size <2>:                              Nonlinear Programming.
* size <3>:                              Bounds.
* size:                                  Nonlinear Equations.
* solve <1>:                             Nonlinear Equations.
* solve:                                 Matrix and Vector @var{Operations}.
* sort:                                  Ranges.
* stack:                                 Matrix and Vector @var{Operations}.
* start_constraint_check:                Nonlinear Programming.
* start_objective_check:                 Nonlinear Programming.
* state:                                 Ordinary Differential Equations.
* states:                                Nonlinear Equations.
* stop_constraint_check:                 Nonlinear Programming.
* stop_objective_check:                  Nonlinear Programming.
* sum:                                   Matrix and Vector @var{Operations}.
* sumsq:                                 Matrix and Vector @var{Operations}.
* SVD:                                   Matrix Factorizations.
* time:                                  Ordinary Differential Equations.
* tolerance:                             Nonlinear Equations.
* transpose:                             Matrix and Vector @var{Operations}.
* U:                                     Matrix Factorizations.
* unitary_hess_matrix:                   Matrix Factorizations.
* unitary_matrix:                        Matrix Factorizations.
* upper_bound:                           Bounds.
* upper_bounds:                          Bounds.
* value:                                 Matrix Factorizations.
* value_will_overflow:                   Matrix Factorizations.
* value_will_underflow:                  Matrix Factorizations.
* verify_level:                          Nonlinear Programming.
* width:                                 Collocation Weights.


