home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / octa21fb.zip / octave / doc / liboct.i03 (.txt) < prev    next >
GNU Info File  |  2000-01-15  |  27KB  |  439 lines
  1. This is Info file liboct, produced by Makeinfo-1.64 from the input file
  2. liboct.tex.
  3.    Copyright (C) 1996, 1997 John W. Eaton.
  4.    Permission is granted to make and distribute verbatim copies of this
  5. manual provided the copyright notice and this permission notice are
  6. preserved on all copies.
  7.    Permission is granted to copy and distribute modified versions of
  8. this manual under the conditions for verbatim copying, provided that
  9. the entire resulting derived work is distributed under the terms of a
  10. permission notice identical to this one.
  11.    Permission is granted to copy and distribute translations of this
  12. manual into another language, under the above conditions for modified
  13. versions.
  14. File: liboct,  Node: Differential Algebraic Equations,  Next: Error Handling,  Prev: Ordinary Differential Equations,  Up: Top
  15. Differential Algebraic Equations
  16. ********************************
  17.  - :  DAE (void)
  18.  - :  DAE (int N)
  19.  - :  DAE (const ColumnVector &X, double TIME, DAEFunc &F)
  20.  - :  DAE (const ColumnVector &X, ColumnVector &XDOT, double TIME,
  21.           DAEFunc &F)
  22.  - : ColumnVector deriv (void)
  23.  - : virtual void initialize (const ColumnVector &X, double T)
  24.  - : virtual void initialize (const ColumnVector &X, ColumnVector
  25.           &XDOT, double T)
  26.  - : ColumnVector integrate (double T)
  27.  - : Matrix integrate (const ColumnVector &TOUT, Matrix &XDOT_OUT)
  28.  - : Matrix integrate (const ColumnVector &TOUT, Matrix &XDOT_OUT,
  29.           const ColumnVector &TCRIT)
  30. File: liboct,  Node: Error Handling,  Next: Installation,  Prev: Differential Algebraic Equations,  Up: Top
  31. Error Handling
  32. **************
  33. File: liboct,  Node: Installation,  Next: Bugs,  Prev: Error Handling,  Up: Top
  34. Installation
  35. ************
  36. File: liboct,  Node: Bugs,  Next: Concept Index,  Prev: Installation,  Up: Top
  37. File: liboct,  Node: Concept Index,  Next: Function Index,  Prev: Bugs,  Up: Top
  38. Concept Index
  39. *************
  40. * Menu:
  41. * acknowledgements:                     Acknowledgements.
  42. * arrays:                               Arrays.
  43. * bounds:                               Bounds.
  44. * bugs, known:                          Bugs.
  45. * collocation weights:                  Collocation Weights.
  46. * contributors:                         Contributors.
  47. * copyright:                            Contributors.
  48. * DAE:                                  Differential Algebraic Equations.
  49. * factorizations:                       Matrix Factorizations.
  50. * installation:                         Installation.
  51. * installation trouble:                 Bugs.
  52. * integration:                          Quadrature.
  53. * introduction:                         Introduction.
  54. * known causes of trouble:              Bugs.
  55. * linear Constraints:                   Linear Constraints.
  56. * matrix factorizations:                Matrix Factorizations.
  57. * matrix manipulations:                 Matrix and Vector Operations.
  58. * NLP:                                  Nonlinear Programming.
  59. * nonlinear Constraints:                Nonlinear Constraints.
  60. * nonlinear equations:                  Nonlinear Equations.
  61. * nonlinear functions:                  Nonlinear Functions.
  62. * nonlinear programming:                Nonlinear Programming.
  63. * numerical integration:                Quadrature.
  64. * objective functions:                  Objective Functions.
  65. * ODE:                                  Ordinary Differential Equations.
  66. * optimization:                         Optimization.
  67. * orthogonal collocation:               Collocation Weights.
  68. * QP:                                   Quadratic Programming.
  69. * quadratic programming:                Quadratic Programming.
  70. * quadrature:                           Quadrature.
  71. * ranges:                               Ranges.
  72. * troubleshooting:                      Bugs.
  73. * vector manipulations:                 Matrix and Vector Operations.
  74. * warranty:                             Contributors.
  75. File: liboct,  Node: Function Index,  Prev: Concept Index,  Up: Top
  76. Function Index
  77. **************
  78. * Menu:
  79. * ( <1>:                                Quadrature.
  80. * ( <2>:                                Matrix Factorizations.
  81. * ( <3>:                                Constructors and Assignment.
  82. * (:                                    Matrix Factorizations.
  83. * absolute_tolerance <1>:               Quadrature.
  84. * absolute_tolerance:                   Ordinary Differential Equations.
  85. * add_left:                             Collocation Weights.
  86. * add_right:                            Collocation Weights.
  87. * AEPBALANCE:                           Matrix Factorizations.
  88. * all:                                  Matrix and Vector Operations.
  89. * alpha:                                Collocation Weights.
  90. * any:                                  Matrix and Vector Operations.
  91. * append:                               Matrix and Vector Operations.
  92. * Array2:                               Constructors and Assignment.
  93. * Array<T>::Array:                      Constructors and Assignment.
  94. * Array<T>::capacity:                   Constructors and Assignment.
  95. * Array<T>::checkelem:                  Constructors and Assignment.
  96. * Array<T>::data:                       Constructors and Assignment.
  97. * Array<T>::elem:                       Constructors and Assignment.
  98. * Array<T>::length:                     Constructors and Assignment.
  99. * Array<T>::operator:                   Constructors and Assignment.
  100. * Array<T>::operator ():                Constructors and Assignment.
  101. * Array<T>::operator =:                 Constructors and Assignment.
  102. * Array<T>::resize:                     Constructors and Assignment.
  103. * Array<T>::xelem:                      Constructors and Assignment.
  104. * balanced_a_matrix:                    Matrix Factorizations.
  105. * balanced_b_matrix:                    Matrix Factorizations.
  106. * balanced_matrix:                      Matrix Factorizations.
  107. * balancing_matrix:                     Matrix Factorizations.
  108. * base:                                 Ranges.
  109. * beta:                                 Collocation Weights.
  110. * Bounds:                               Bounds.
  111. * checkelem:                            Constructors and Assignment.
  112. * CHOL:                                 Matrix Factorizations.
  113. * chol_matrix:                          Matrix Factorizations.
  114. * clear_stop_time:                      Ordinary Differential Equations.
  115. * coefficient:                          Matrix Factorizations.
  116. * CollocWt:                             Collocation Weights.
  117. * cols:                                 Constructors and Assignment.
  118. * column:                               Matrix and Vector Operations.
  119. * columns:                              Constructors and Assignment.
  120. * ColumnVector:                         Matrix and Vector Operations.
  121. * column_max:                           Matrix and Vector Operations.
  122. * column_max_loc:                       Matrix and Vector Operations.
  123. * column_min:                           Matrix and Vector Operations.
  124. * column_min_loc:                       Matrix and Vector Operations.
  125. * ComplexCHOL:                          Matrix Factorizations.
  126. * ComplexColumnVector:                  Matrix and Vector Operations.
  127. * ComplexDET:                           Matrix Factorizations.
  128. * ComplexDiagMatrix:                    Matrix and Vector Operations.
  129. * ComplexHESS:                          Matrix Factorizations.
  130. * ComplexLU:                            Matrix Factorizations.
  131. * ComplexMatrix:                        Matrix and Vector Operations.
  132. * ComplexQR:                            Matrix Factorizations.
  133. * ComplexRowVector:                     Matrix and Vector Operations.
  134. * ComplexSCHUR:                         Matrix Factorizations.
  135. * ComplexSVD:                           Matrix Factorizations.
  136. * conj:                                 Matrix and Vector Operations.
  137. * constraint_matrix:                    Linear Constraints.
  138. * copy <1>:                             Ordinary Differential Equations.
  139. * copy <2>:                             Quadrature.
  140. * copy:                                 Nonlinear Equations.
  141. * cumprod:                              Matrix and Vector Operations.
  142. * cumsum:                               Matrix and Vector Operations.
  143. * DAE:                                  Differential Algebraic Equations.
  144. * DefQuad:                              Quadrature.
  145. * delete_left:                          Collocation Weights.
  146. * delete_right:                         Collocation Weights.
  147. * deriv:                                Differential Algebraic Equations.
  148. * DET:                                  Matrix Factorizations.
  149. * determinant:                          Matrix and Vector Operations.
  150. * diag:                                 Matrix and Vector Operations.
  151. * DiagArray:                            Constructors and Assignment.
  152. * DiagMatrix:                           Matrix and Vector Operations.
  153. * dim1:                                 Constructors and Assignment.
  154. * dim2:                                 Constructors and Assignment.
  155. * dim3:                                 Constructors and Assignment.
  156. * EIG:                                  Matrix Factorizations.
  157. * eigenvalues:                          Matrix Factorizations.
  158. * eigenvectors:                         Matrix Factorizations.
  159. * elem:                                 Constructors and Assignment.
  160. * eq_constraint_matrix:                 Linear Constraints.
  161. * eq_constraint_vector:                 Linear Constraints.
  162. * exponent:                             Matrix Factorizations.
  163. * extract:                              Matrix and Vector Operations.
  164. * fill:                                 Matrix and Vector Operations.
  165. * first:                                Collocation Weights.
  166. * force_restart:                        Ordinary Differential Equations.
  167. * fourier:                              Matrix and Vector Operations.
  168. * function:                             Nonlinear Functions.
  169. * GEPBALANCE:                           Matrix Factorizations.
  170. * gradient_function:                    Objective Functions.
  171. * HESS:                                 Matrix Factorizations.
  172. * hess_matrix:                          Matrix Factorizations.
  173. * ifourier:                             Matrix and Vector Operations.
  174. * imag:                                 Matrix and Vector Operations.
  175. * inc:                                  Ranges.
  176. * IndefQuad:                            Quadrature.
  177. * ineq_constraint_matrix:               Linear Constraints.
  178. * ineq_constraint_vector:               Linear Constraints.
  179. * init <1>:                             Nonlinear Equations.
  180. * init <2>:                             Ordinary Differential Equations.
  181. * init:                                 Quadrature.
  182. * initialize <1>:                       Differential Algebraic Equations.
  183. * initialize:                           Ordinary Differential Equations.
  184. * initial_step_size:                    Ordinary Differential Equations.
  185. * insert:                               Matrix and Vector Operations.
  186. * integrate <1>:                        Ordinary Differential Equations.
  187. * integrate <2>:                        Differential Algebraic Equations.
  188. * integrate <3>:                        Ordinary Differential Equations.
  189. * integrate <4>:                        Quadrature.
  190. * integrate <5>:                        Differential Algebraic Equations.
  191. * integrate:                            Quadrature.
  192. * inverse:                              Matrix and Vector Operations.
  193. * jacobian_function:                    Nonlinear Functions.
  194. * L:                                    Matrix Factorizations.
  195. * left:                                 Collocation Weights.
  196. * left_balancing_matrix:                Matrix Factorizations.
  197. * left_included:                        Collocation Weights.
  198. * left_singular_matrix:                 Matrix Factorizations.
  199. * limit:                                Ranges.
  200. * LinConst:                             Linear Constraints.
  201. * lower_bound:                          Bounds.
  202. * lower_bounds:                         Bounds.
  203. * lssolve:                              Matrix and Vector Operations.
  204. * LU:                                   Matrix Factorizations.
  205. * map:                                  Matrix and Vector Operations.
  206. * Matrix:                               Matrix and Vector Operations.
  207. * max <1>:                              Matrix and Vector Operations.
  208. * max <2>:                              Ranges.
  209. * max:                                  Matrix and Vector Operations.
  210. * maximum_step_size:                    Ordinary Differential Equations.
  211. * min <1>:                              Matrix and Vector Operations.
  212. * min:                                  Ranges.
  213. * minimize <1>:                         Quadratic Programming.
  214. * minimize <2>:                         Nonlinear Programming.
  215. * minimize <3>:                         Quadratic Programming.
  216. * minimize <4>:                         Nonlinear Programming.
  217. * minimize <5>:                         Quadratic Programming.
  218. * minimize:                             Nonlinear Programming.
  219. * minimum_step_size:                    Ordinary Differential Equations.
  220. * ncol:                                 Collocation Weights.
  221. * nelem:                                Ranges.
  222. * NLConst:                              Nonlinear Constraints.
  223. * NLEqn:                                Nonlinear Equations.
  224. * NLEqn_options:                        Nonlinear Equations.
  225. * NLFunc:                               Nonlinear Functions.
  226. * NLP:                                  Nonlinear Programming.
  227. * Objective:                            Objective Functions.
  228. * objective_function:                   Objective Functions.
  229. * ODE:                                  Ordinary Differential Equations.
  230. * ODE_options:                          Ordinary Differential Equations.
  231. * operator !:                           Matrix and Vector Operations.
  232. * operator !=:                          Matrix and Vector Operations.
  233. * operator ():                          Constructors and Assignment.
  234. * operator * <1>:                       Matrix and Vector Operations.
  235. * operator * <2>:                       Constructors and Assignment.
  236. * operator * <3>:                       Matrix and Vector Operations.
  237. * operator * <4>:                       Constructors and Assignment.
  238. * operator * <5>:                       Matrix and Vector Operations.
  239. * operator * <6>:                       Constructors and Assignment.
  240. * operator * <7>:                       Matrix and Vector Operations.
  241. * operator * <8>:                       Constructors and Assignment.
  242. * operator *:                           Matrix and Vector Operations.
  243. * operator + <1>:                       Matrix and Vector Operations.
  244. * operator + <2>:                       Constructors and Assignment.
  245. * operator + <3>:                       Matrix and Vector Operations.
  246. * operator + <4>:                       Constructors and Assignment.
  247. * operator + <5>:                       Matrix and Vector Operations.
  248. * operator + <6>:                       Constructors and Assignment.
  249. * operator + <7>:                       Matrix and Vector Operations.
  250. * operator + <8>:                       Constructors and Assignment.
  251. * operator + <9>:                       Matrix and Vector Operations.
  252. * operator + <10>:                      Constructors and Assignment.
  253. * operator + <11>:                      Matrix and Vector Operations.
  254. * operator + <12>:                      Constructors and Assignment.
  255. * operator +:                           Matrix and Vector Operations.
  256. * operator +=:                          Matrix and Vector Operations.
  257. * operator - <1>:                       Matrix and Vector Operations.
  258. * operator - <2>:                       Constructors and Assignment.
  259. * operator - <3>:                       Matrix and Vector Operations.
  260. * operator - <4>:                       Constructors and Assignment.
  261. * operator - <5>:                       Matrix and Vector Operations.
  262. * operator - <6>:                       Constructors and Assignment.
  263. * operator - <7>:                       Matrix and Vector Operations.
  264. * operator - <8>:                       Constructors and Assignment.
  265. * operator - <9>:                       Matrix and Vector Operations.
  266. * operator - <10>:                      Constructors and Assignment.
  267. * operator - <11>:                      Matrix and Vector Operations.
  268. * operator - <12>:                      Constructors and Assignment.
  269. * operator - <13>:                      Matrix and Vector Operations.
  270. * operator - <14>:                      Constructors and Assignment.
  271. * operator -:                           Matrix and Vector Operations.
  272. * operator -=:                          Matrix and Vector Operations.
  273. * operator / <1>:                       Matrix and Vector Operations.
  274. * operator / <2>:                       Constructors and Assignment.
  275. * operator / <3>:                       Matrix and Vector Operations.
  276. * operator / <4>:                       Constructors and Assignment.
  277. * operator / <5>:                       Matrix and Vector Operations.
  278. * operator / <6>:                       Constructors and Assignment.
  279. * operator / <7>:                       Matrix and Vector Operations.
  280. * operator / <8>:                       Constructors and Assignment.
  281. * operator / <9>:                       Matrix and Vector Operations.
  282. * operator / <10>:                      Constructors and Assignment.
  283. * operator /:                           Matrix and Vector Operations.
  284. * operator << <1>:                      Matrix Factorizations.
  285. * operator << <2>:                      Matrix and Vector Operations.
  286. * operator << <3>:                      Matrix Factorizations.
  287. * operator << <4>:                      Matrix and Vector Operations.
  288. * operator << <5>:                      Matrix Factorizations.
  289. * operator << <6>:                      Matrix and Vector Operations.
  290. * operator << <7>:                      Ranges.
  291. * operator << <8>:                      Matrix and Vector Operations.
  292. * operator << <9>:                      Bounds.
  293. * operator << <10>:                     Matrix Factorizations.
  294. * operator << <11>:                     Matrix and Vector Operations.
  295. * operator << <12>:                     Matrix Factorizations.
  296. * operator << <13>:                     Linear Constraints.
  297. * operator << <14>:                     Collocation Weights.
  298. * operator << <15>:                     Matrix Factorizations.
  299. * operator <<:                          Matrix and Vector Operations.
  300. * operator = <1>:                       Matrix Factorizations.
  301. * operator = <2>:                       Matrix and Vector Operations.
  302. * operator = <3>:                       Matrix Factorizations.
  303. * operator = <4>:                       Nonlinear Programming.
  304. * operator = <5>:                       Matrix Factorizations.
  305. * operator = <6>:                       Matrix and Vector Operations.
  306. * operator = <7>:                       Matrix Factorizations.
  307. * operator = <8>:                       Matrix and Vector Operations.
  308. * operator = <9>:                       Matrix Factorizations.
  309. * operator = <10>:                      Bounds.
  310. * operator = <11>:                      Matrix Factorizations.
  311. * operator = <12>:                      Nonlinear Constraints.
  312. * operator = <13>:                      Linear Constraints.
  313. * operator = <14>:                      Matrix Factorizations.
  314. * operator = <15>:                      Matrix and Vector Operations.
  315. * operator = <16>:                      Collocation Weights.
  316. * operator = <17>:                      Nonlinear Equations.
  317. * operator = <18>:                      Matrix and Vector Operations.
  318. * operator = <19>:                      Quadrature.
  319. * operator = <20>:                      Matrix Factorizations.
  320. * operator = <21>:                      Ordinary Differential Equations.
  321. * operator = <22>:                      Matrix Factorizations.
  322. * operator = <23>:                      Constructors and Assignment.
  323. * operator = <24>:                      Nonlinear Equations.
  324. * operator = <25>:                      Nonlinear Functions.
  325. * operator = <26>:                      Constructors and Assignment.
  326. * operator = <27>:                      Objective Functions.
  327. * operator = <28>:                      Matrix and Vector Operations.
  328. * operator =:                           Matrix Factorizations.
  329. * operator ==:                          Matrix and Vector Operations.
  330. * operator >> <1>:                      Ranges.
  331. * operator >>:                          Matrix and Vector Operations.
  332. * P:                                    Matrix Factorizations.
  333. * print_range:                          Ranges.
  334. * prod:                                 Matrix and Vector Operations.
  335. * product <1>:                          Matrix and Vector Operations.
  336. * product <2>:                          Constructors and Assignment.
  337. * product <3>:                          Matrix and Vector Operations.
  338. * product <4>:                          Constructors and Assignment.
  339. * product:                              Matrix and Vector Operations.
  340. * Q:                                    Matrix Factorizations.
  341. * QP:                                   Quadratic Programming.
  342. * QR:                                   Matrix Factorizations.
  343. * Quad:                                 Quadrature.
  344. * quad:                                 Collocation Weights.
  345. * quad_weights:                         Collocation Weights.
  346. * quotient <1>:                         Matrix and Vector Operations.
  347. * quotient <2>:                         Constructors and Assignment.
  348. * quotient <3>:                         Matrix and Vector Operations.
  349. * quotient <4>:                         Constructors and Assignment.
  350. * quotient:                             Matrix and Vector Operations.
  351. * R:                                    Matrix Factorizations.
  352. * Range:                                Ranges.
  353. * real:                                 Matrix and Vector Operations.
  354. * relative_tolerance <1>:               Quadrature.
  355. * relative_tolerance:                   Ordinary Differential Equations.
  356. * resize <1>:                           Collocation Weights.
  357. * resize <2>:                           Constructors and Assignment.
  358. * resize <3>:                           Bounds.
  359. * resize <4>:                           Constructors and Assignment.
  360. * resize <5>:                           Linear Constraints.
  361. * resize <6>:                           Constructors and Assignment.
  362. * resize <7>:                           Nonlinear Equations.
  363. * resize:                               Constructors and Assignment.
  364. * right:                                Collocation Weights.
  365. * right_balancing_matrix:               Matrix Factorizations.
  366. * right_included:                       Collocation Weights.
  367. * right_singular_matrix:                Matrix Factorizations.
  368. * roots:                                Collocation Weights.
  369. * row:                                  Matrix and Vector Operations.
  370. * rows:                                 Constructors and Assignment.
  371. * RowVector:                            Matrix and Vector Operations.
  372. * row_max:                              Matrix and Vector Operations.
  373. * row_max_loc:                          Matrix and Vector Operations.
  374. * row_min:                              Matrix and Vector Operations.
  375. * row_min_loc:                          Matrix and Vector Operations.
  376. * SCHUR:                                Matrix Factorizations.
  377. * schur_matrix:                         Matrix Factorizations.
  378. * second:                               Collocation Weights.
  379. * set_absolute_tolerance <1>:           Ordinary Differential Equations.
  380. * set_absolute_tolerance:               Quadrature.
  381. * set_alpha:                            Collocation Weights.
  382. * set_base:                             Ranges.
  383. * set_beta:                             Collocation Weights.
  384. * set_bound:                            Bounds.
  385. * set_bounds:                           Bounds.
  386. * set_constraint_matrix:                Linear Constraints.
  387. * set_default_options <1>:              Nonlinear Equations.
  388. * set_default_options <2>:              Quadrature.
  389. * set_default_options:                  Ordinary Differential Equations.
  390. * set_function:                         Nonlinear Functions.
  391. * set_gradient_function:                Objective Functions.
  392. * set_inc:                              Ranges.
  393. * set_initial_step_size:                Ordinary Differential Equations.
  394. * set_jacobian_function:                Nonlinear Functions.
  395. * set_left:                             Collocation Weights.
  396. * set_limit:                            Ranges.
  397. * set_lower_bound:                      Bounds.
  398. * set_lower_bounds:                     Bounds.
  399. * set_maximum_step_size:                Ordinary Differential Equations.
  400. * set_minimum_step_size:                Ordinary Differential Equations.
  401. * set_objective_function:               Objective Functions.
  402. * set_relative_tolerance <1>:           Quadrature.
  403. * set_relative_tolerance:               Ordinary Differential Equations.
  404. * set_right:                            Collocation Weights.
  405. * set_states:                           Nonlinear Equations.
  406. * set_stop_time:                        Ordinary Differential Equations.
  407. * set_tolerance:                        Nonlinear Equations.
  408. * set_upper_bound:                      Bounds.
  409. * set_upper_bounds:                     Bounds.
  410. * singular_values:                      Matrix Factorizations.
  411. * size <1>:                             Bounds.
  412. * size <2>:                             Nonlinear Equations.
  413. * size <3>:                             Ordinary Differential Equations.
  414. * size:                                 Nonlinear Programming.
  415. * solve <1>:                            Matrix and Vector Operations.
  416. * solve <2>:                            Nonlinear Equations.
  417. * solve <3>:                            Matrix and Vector Operations.
  418. * solve <4>:                            Nonlinear Equations.
  419. * solve:                                Matrix and Vector Operations.
  420. * sort:                                 Ranges.
  421. * stack:                                Matrix and Vector Operations.
  422. * state:                                Ordinary Differential Equations.
  423. * states:                               Nonlinear Equations.
  424. * sum:                                  Matrix and Vector Operations.
  425. * sumsq:                                Matrix and Vector Operations.
  426. * SVD:                                  Matrix Factorizations.
  427. * time:                                 Ordinary Differential Equations.
  428. * tolerance:                            Nonlinear Equations.
  429. * transpose:                            Matrix and Vector Operations.
  430. * U:                                    Matrix Factorizations.
  431. * unitary_hess_matrix:                  Matrix Factorizations.
  432. * unitary_matrix:                       Matrix Factorizations.
  433. * upper_bound:                          Bounds.
  434. * upper_bounds:                         Bounds.
  435. * value:                                Matrix Factorizations.
  436. * value_will_overflow:                  Matrix Factorizations.
  437. * value_will_underflow:                 Matrix Factorizations.
  438. * width:                                Collocation Weights.
  439.