octave_packages/odepkg-0.8.2/doc-cache

   1 # Created by Octave 3.6.2, Sun Aug 05 21:39:02 2012 UTC <root@t61>
   2 # name: cache
   3 # type: cell
   4 # rows: 3
   5 # columns: 35
   6 # name: <cell-element>
   7 # type: sq_string
   8 # elements: 1
   9 # length: 5
  10 bvp4c
  11
  12
  13 # name: <cell-element>
  14 # type: sq_string
  15 # elements: 1
  16 # length: 694
  17  -- Function File: A = bvp4c (ODEFUN, BCFUN, SOLINIT)
  18      Solves the first order system of non-linear differential equations
  19      defined by ODEFUN with the boundary conditions defined in BCFUN.
  20
  21      The structure SOLINIT defines the grid on which to compute the
  22      solution (SOLINIT.X), and an initial guess for the solution
  23      (SOLINIT.Y).  The output SOL is also a structure with the
  24      following fields:
  25         * SOL.X list of points where the solution is evaluated
  26
  27         * SOL.Y solution evaluated at the points SOL.X
  28
  29         * SOL.YP derivative of the solution evaluated at the points
  30           SOL.X
  31
  32         * SOL.SOLVER = "bvp4c" for compatibility
  33
  34      See also: odpkg
  35
  36
  37
  38
  39
  40 # name: <cell-element>
  41 # type: sq_string
  42 # elements: 1
  43 # length: 80
  44 Solves the first order system of non-linear differential equations
  45 defined by OD
  46
  47
  48
  49 # name: <cell-element>
  50 # type: sq_string
  51 # elements: 1
  52 # length: 5
  53 ode23
  54
  55
  56 # name: <cell-element>
  57 # type: sq_string
  58 # elements: 1
  59 # length: 2466
  60  -- Function File: [] = ode23 (@FUN, SLOT, INIT, [OPT], [PAR1, PAR2,
  61           ...])
  62  -- Command: [SOL] = ode23 (@FUN, SLOT, INIT, [OPT], [PAR1, PAR2, ...])
  63  -- Command: [T, Y, [XE, YE, IE]] = ode23 (@FUN, SLOT, INIT, [OPT],
  64           [PAR1, PAR2, ...])
  65      This function file can be used to solve a set of non-stiff
  66      ordinary differential equations (non-stiff ODEs) or non-stiff
  67      differential algebraic equations (non-stiff DAEs) with the well
  68      known explicit Runge-Kutta method of order (2,3).
  69
  70      If this function is called with no return argument then plot the
  71      solution over time in a figure window while solving the set of
  72      ODEs that are defined in a function and specified by the function
  73      handle @FUN. The second input argument SLOT is a double vector
  74      that defines the time slot, INIT is a double vector that defines
  75      the initial values of the states, OPT can optionally be a
  76      structure array that keeps the options created with the command
  77      `odeset' and PAR1, PAR2, ... can optionally be other input
  78      arguments of any type that have to be passed to the function
  79      defined by @FUN.
  80
  81      If this function is called with one return argument then return
  82      the solution SOL of type structure array after solving the set of
  83      ODEs. The solution SOL has the fields X of type double column
  84      vector for the steps chosen by the solver, Y of type double column
  85      vector for the solutions at each time step of X, SOLVER of type
  86      string for the solver name and optionally the extended time stamp
  87      information XE, the extended solution information YE and the
  88      extended index information IE all of type double column vector
  89      that keep the informations of the event function if an event
  90      function handle is set in the option argument OPT.
  91
  92      If this function is called with more than one return argument then
  93      return the time stamps T, the solution values Y and optionally the
  94      extended time stamp information XE, the extended solution
  95      information YE and the extended index information IE all of type
  96      double column vector.
  97
  98      For example, solve an anonymous implementation of the Van der Pol
  99      equation
 100
 101           fvdb = @(vt,vy) [vy(2); (1 - vy(1)^2) * vy(2) - vy(1)];
 102
 103           vopt = odeset ("RelTol", 1e-3, "AbsTol", 1e-3, \
 104                    "NormControl", "on", "OutputFcn", @odeplot);
 105           ode23 (fvdb, [0 20], [2 0], vopt);
 106
 107    See also: odepkg
 108
 109
 110
 111
 112 # name: <cell-element>
 113 # type: sq_string
 114 # elements: 1
 115 # length: 80
 116 This function file can be used to solve a set of non-stiff ordinary
 117 differential
 118
 119
 120
 121 # name: <cell-element>
 122 # type: sq_string
 123 # elements: 1
 124 # length: 6
 125 ode23d
 126
 127
 128 # name: <cell-element>
 129 # type: sq_string
 130 # elements: 1
 131 # length: 3606
 132  -- Function File: [] = ode23d (@FUN, SLOT, INIT, LAGS, HIST, [OPT],
 133           [PAR1, PAR2, ...])
 134  -- Command: [SOL] = ode23d (@FUN, SLOT, INIT, LAGS, HIST, [OPT],
 135           [PAR1, PAR2, ...])
 136  -- Command: [T, Y, [XE, YE, IE]] = ode23d (@FUN, SLOT, INIT, LAGS,
 137           HIST, [OPT], [PAR1, PAR2, ...])
 138      This function file can be used to solve a set of non-stiff delay
 139      differential equations (non-stiff DDEs) with a modified version of
 140      the well known explicit Runge-Kutta method of order (2,3).
 141
 142      If this function is called with no return argument then plot the
 143      solution over time in a figure window while solving the set of
 144      DDEs that are defined in a function and specified by the function
 145      handle @FUN. The second input argument SLOT is a double vector
 146      that defines the time slot, INIT is a double vector that defines
 147      the initial values of the states, LAGS is a double vector that
 148      describes the lags of time, HIST is a double matrix and describes
 149      the history of the DDEs, OPT can optionally be a structure array
 150      that keeps the options created with the command `odeset' and PAR1,
 151      PAR2, ... can optionally be other input arguments of any type that
 152      have to be passed to the function defined by @FUN.
 153
 154      In other words, this function will solve a problem of the form
 155           dy/dt = fun (t, y(t), y(t-lags(1), y(t-lags(2), ...)))
 156           y(slot(1)) = init
 157           y(slot(1)-lags(1)) = hist(1), y(slot(1)-lags(2)) = hist(2), ...
 158
 159      If this function is called with one return argument then return
 160      the solution SOL of type structure array after solving the set of
 161      DDEs. The solution SOL has the fields X of type double column
 162      vector for the steps chosen by the solver, Y of type double column
 163      vector for the solutions at each time step of X, SOLVER of type
 164      string for the solver name and optionally the extended time stamp
 165      information XE, the extended solution information YE and the
 166      extended index information IE all of type double column vector
 167      that keep the informations of the event function if an event
 168      function handle is set in the option argument OPT.
 169
 170      If this function is called with more than one return argument then
 171      return the time stamps T, the solution values Y and optionally the
 172      extended time stamp information XE, the extended solution
 173      information YE and the extended index information IE all of type
 174      double column vector.
 175
 176      For example:
 177         - the following code solves an anonymous implementation of a
 178           chaotic behavior
 179
 180                fcao = @(vt, vy, vz) [2 * vz / (1 + vz^9.65) - vy];
 181
 182                vopt = odeset ("NormControl", "on", "RelTol", 1e-3);
 183                vsol = ode23d (fcao, [0, 100], 0.5, 2, 0.5, vopt);
 184
 185                vlag = interp1 (vsol.x, vsol.y, vsol.x - 2);
 186                plot (vsol.y, vlag); legend ("fcao (t,y,z)");
 187
 188         - to solve the following problem with two delayed state
 189           variables
 190
 191                d y1(t)/dt = -y1(t)
 192                d y2(t)/dt = -y2(t) + y1(t-5)
 193                d y3(t)/dt = -y3(t) + y2(t-10)*y1(t-10)
 194
 195           one might do the following
 196
 197                function f = fun (t, y, yd)
 198                f(1) = -y(1);                   %% y1' = -y1(t)
 199                f(2) = -y(2) + yd(1,1);         %% y2' = -y2(t) + y1(t-lags(1))
 200                f(3) = -y(3) + yd(2,2)*yd(1,2); %% y3' = -y3(t) + y2(t-lags(2))*y1(t-lags(2))
 201                endfunction
 202                T = [0,20]
 203                res = ode23d (@fun, T, [1;1;1], [5, 10], ones (3,2));
 204
 205
 206    See also: odepkg
 207
 208
 209
 210
 211 # name: <cell-element>
 212 # type: sq_string
 213 # elements: 1
 214 # length: 80
 215 This function file can be used to solve a set of non-stiff delay
 216 differential eq
 217
 218
 219
 220 # name: <cell-element>
 221 # type: sq_string
 222 # elements: 1
 223 # length: 5
 224 ode45
 225
 226
 227 # name: <cell-element>
 228 # type: sq_string
 229 # elements: 1
 230 # length: 2466
 231  -- Function File: [] = ode45 (@FUN, SLOT, INIT, [OPT], [PAR1, PAR2,
 232           ...])
 233  -- Command: [SOL] = ode45 (@FUN, SLOT, INIT, [OPT], [PAR1, PAR2, ...])
 234  -- Command: [T, Y, [XE, YE, IE]] = ode45 (@FUN, SLOT, INIT, [OPT],
 235           [PAR1, PAR2, ...])
 236      This function file can be used to solve a set of non-stiff
 237      ordinary differential equations (non-stiff ODEs) or non-stiff
 238      differential algebraic equations (non-stiff DAEs) with the well
 239      known explicit Runge-Kutta method of order (4,5).
 240
 241      If this function is called with no return argument then plot the
 242      solution over time in a figure window while solving the set of
 243      ODEs that are defined in a function and specified by the function
 244      handle @FUN. The second input argument SLOT is a double vector
 245      that defines the time slot, INIT is a double vector that defines
 246      the initial values of the states, OPT can optionally be a
 247      structure array that keeps the options created with the command
 248      `odeset' and PAR1, PAR2, ... can optionally be other input
 249      arguments of any type that have to be passed to the function
 250      defined by @FUN.
 251
 252      If this function is called with one return argument then return
 253      the solution SOL of type structure array after solving the set of
 254      ODEs. The solution SOL has the fields X of type double column
 255      vector for the steps chosen by the solver, Y of type double column
 256      vector for the solutions at each time step of X, SOLVER of type
 257      string for the solver name and optionally the extended time stamp
 258      information XE, the extended solution information YE and the
 259      extended index information IE all of type double column vector
 260      that keep the informations of the event function if an event
 261      function handle is set in the option argument OPT.
 262
 263      If this function is called with more than one return argument then
 264      return the time stamps T, the solution values Y and optionally the
 265      extended time stamp information XE, the extended solution
 266      information YE and the extended index information IE all of type
 267      double column vector.
 268
 269      For example, solve an anonymous implementation of the Van der Pol
 270      equation
 271
 272           fvdb = @(vt,vy) [vy(2); (1 - vy(1)^2) * vy(2) - vy(1)];
 273
 274           vopt = odeset ("RelTol", 1e-3, "AbsTol", 1e-3, \
 275                    "NormControl", "on", "OutputFcn", @odeplot);
 276           ode45 (fvdb, [0 20], [2 0], vopt);
 277
 278    See also: odepkg
 279
 280
 281
 282
 283 # name: <cell-element>
 284 # type: sq_string
 285 # elements: 1
 286 # length: 80
 287 This function file can be used to solve a set of non-stiff ordinary
 288 differential
 289
 290
 291
 292 # name: <cell-element>
 293 # type: sq_string
 294 # elements: 1
 295 # length: 6
 296 ode45d
 297
 298
 299 # name: <cell-element>
 300 # type: sq_string
 301 # elements: 1
 302 # length: 3606
 303  -- Function File: [] = ode45d (@FUN, SLOT, INIT, LAGS, HIST, [OPT],
 304           [PAR1, PAR2, ...])
 305  -- Command: [SOL] = ode45d (@FUN, SLOT, INIT, LAGS, HIST, [OPT],
 306           [PAR1, PAR2, ...])
 307  -- Command: [T, Y, [XE, YE, IE]] = ode45d (@FUN, SLOT, INIT, LAGS,
 308           HIST, [OPT], [PAR1, PAR2, ...])
 309      This function file can be used to solve a set of non-stiff delay
 310      differential equations (non-stiff DDEs) with a modified version of
 311      the well known explicit Runge-Kutta method of order (4,5).
 312
 313      If this function is called with no return argument then plot the
 314      solution over time in a figure window while solving the set of
 315      DDEs that are defined in a function and specified by the function
 316      handle @FUN. The second input argument SLOT is a double vector
 317      that defines the time slot, INIT is a double vector that defines
 318      the initial values of the states, LAGS is a double vector that
 319      describes the lags of time, HIST is a double matrix and describes
 320      the history of the DDEs, OPT can optionally be a structure array
 321      that keeps the options created with the command `odeset' and PAR1,
 322      PAR2, ... can optionally be other input arguments of any type that
 323      have to be passed to the function defined by @FUN.
 324
 325      In other words, this function will solve a problem of the form
 326           dy/dt = fun (t, y(t), y(t-lags(1), y(t-lags(2), ...)))
 327           y(slot(1)) = init
 328           y(slot(1)-lags(1)) = hist(1), y(slot(1)-lags(2)) = hist(2), ...
 329
 330      If this function is called with one return argument then return
 331      the solution SOL of type structure array after solving the set of
 332      DDEs. The solution SOL has the fields X of type double column
 333      vector for the steps chosen by the solver, Y of type double column
 334      vector for the solutions at each time step of X, SOLVER of type
 335      string for the solver name and optionally the extended time stamp
 336      information XE, the extended solution information YE and the
 337      extended index information IE all of type double column vector
 338      that keep the informations of the event function if an event
 339      function handle is set in the option argument OPT.
 340
 341      If this function is called with more than one return argument then
 342      return the time stamps T, the solution values Y and optionally the
 343      extended time stamp information XE, the extended solution
 344      information YE and the extended index information IE all of type
 345      double column vector.
 346
 347      For example:
 348         - the following code solves an anonymous implementation of a
 349           chaotic behavior
 350
 351                fcao = @(vt, vy, vz) [2 * vz / (1 + vz^9.65) - vy];
 352
 353                vopt = odeset ("NormControl", "on", "RelTol", 1e-3);
 354                vsol = ode45d (fcao, [0, 100], 0.5, 2, 0.5, vopt);
 355
 356                vlag = interp1 (vsol.x, vsol.y, vsol.x - 2);
 357                plot (vsol.y, vlag); legend ("fcao (t,y,z)");
 358
 359         - to solve the following problem with two delayed state
 360           variables
 361
 362                d y1(t)/dt = -y1(t)
 363                d y2(t)/dt = -y2(t) + y1(t-5)
 364                d y3(t)/dt = -y3(t) + y2(t-10)*y1(t-10)
 365
 366           one might do the following
 367
 368                function f = fun (t, y, yd)
 369                f(1) = -y(1);                   %% y1' = -y1(t)
 370                f(2) = -y(2) + yd(1,1);         %% y2' = -y2(t) + y1(t-lags(1))
 371                f(3) = -y(3) + yd(2,2)*yd(1,2); %% y3' = -y3(t) + y2(t-lags(2))*y1(t-lags(2))
 372                endfunction
 373                T = [0,20]
 374                res = ode45d (@fun, T, [1;1;1], [5, 10], ones (3,2));
 375
 376
 377    See also: odepkg
 378
 379
 380
 381
 382 # name: <cell-element>
 383 # type: sq_string
 384 # elements: 1
 385 # length: 80
 386 This function file can be used to solve a set of non-stiff delay
 387 differential eq
 388
 389
 390
 391 # name: <cell-element>
 392 # type: sq_string
 393 # elements: 1
 394 # length: 5
 395 ode54
 396
 397
 398 # name: <cell-element>
 399 # type: sq_string
 400 # elements: 1
 401 # length: 2466
 402  -- Function File: [] = ode54 (@FUN, SLOT, INIT, [OPT], [PAR1, PAR2,
 403           ...])
 404  -- Command: [SOL] = ode54 (@FUN, SLOT, INIT, [OPT], [PAR1, PAR2, ...])
 405  -- Command: [T, Y, [XE, YE, IE]] = ode54 (@FUN, SLOT, INIT, [OPT],
 406           [PAR1, PAR2, ...])
 407      This function file can be used to solve a set of non-stiff
 408      ordinary differential equations (non-stiff ODEs) or non-stiff
 409      differential algebraic equations (non-stiff DAEs) with the well
 410      known explicit Runge-Kutta method of order (5,4).
 411
 412      If this function is called with no return argument then plot the
 413      solution over time in a figure window while solving the set of
 414      ODEs that are defined in a function and specified by the function
 415      handle @FUN. The second input argument SLOT is a double vector
 416      that defines the time slot, INIT is a double vector that defines
 417      the initial values of the states, OPT can optionally be a
 418      structure array that keeps the options created with the command
 419      `odeset' and PAR1, PAR2, ... can optionally be other input
 420      arguments of any type that have to be passed to the function
 421      defined by @FUN.
 422
 423      If this function is called with one return argument then return
 424      the solution SOL of type structure array after solving the set of
 425      ODEs. The solution SOL has the fields X of type double column
 426      vector for the steps chosen by the solver, Y of type double column
 427      vector for the solutions at each time step of X, SOLVER of type
 428      string for the solver name and optionally the extended time stamp
 429      information XE, the extended solution information YE and the
 430      extended index information IE all of type double column vector
 431      that keep the informations of the event function if an event
 432      function handle is set in the option argument OPT.
 433
 434      If this function is called with more than one return argument then
 435      return the time stamps T, the solution values Y and optionally the
 436      extended time stamp information XE, the extended solution
 437      information YE and the extended index information IE all of type
 438      double column vector.
 439
 440      For example, solve an anonymous implementation of the Van der Pol
 441      equation
 442
 443           fvdb = @(vt,vy) [vy(2); (1 - vy(1)^2) * vy(2) - vy(1)];
 444
 445           vopt = odeset ("RelTol", 1e-3, "AbsTol", 1e-3, \
 446                    "NormControl", "on", "OutputFcn", @odeplot);
 447           ode54 (fvdb, [0 20], [2 0], vopt);
 448
 449    See also: odepkg
 450
 451
 452
 453
 454 # name: <cell-element>
 455 # type: sq_string
 456 # elements: 1
 457 # length: 80
 458 This function file can be used to solve a set of non-stiff ordinary
 459 differential
 460
 461
 462
 463 # name: <cell-element>
 464 # type: sq_string
 465 # elements: 1
 466 # length: 6
 467 ode54d
 468
 469
 470 # name: <cell-element>
 471 # type: sq_string
 472 # elements: 1
 473 # length: 3606
 474  -- Function File: [] = ode54d (@FUN, SLOT, INIT, LAGS, HIST, [OPT],
 475           [PAR1, PAR2, ...])
 476  -- Command: [SOL] = ode54d (@FUN, SLOT, INIT, LAGS, HIST, [OPT],
 477           [PAR1, PAR2, ...])
 478  -- Command: [T, Y, [XE, YE, IE]] = ode54d (@FUN, SLOT, INIT, LAGS,
 479           HIST, [OPT], [PAR1, PAR2, ...])
 480      This function file can be used to solve a set of non-stiff delay
 481      differential equations (non-stiff DDEs) with a modified version of
 482      the well known explicit Runge-Kutta method of order (2,3).
 483
 484      If this function is called with no return argument then plot the
 485      solution over time in a figure window while solving the set of
 486      DDEs that are defined in a function and specified by the function
 487      handle @FUN. The second input argument SLOT is a double vector
 488      that defines the time slot, INIT is a double vector that defines
 489      the initial values of the states, LAGS is a double vector that
 490      describes the lags of time, HIST is a double matrix and describes
 491      the history of the DDEs, OPT can optionally be a structure array
 492      that keeps the options created with the command `odeset' and PAR1,
 493      PAR2, ... can optionally be other input arguments of any type that
 494      have to be passed to the function defined by @FUN.
 495
 496      In other words, this function will solve a problem of the form
 497           dy/dt = fun (t, y(t), y(t-lags(1), y(t-lags(2), ...)))
 498           y(slot(1)) = init
 499           y(slot(1)-lags(1)) = hist(1), y(slot(1)-lags(2)) = hist(2), ...
 500
 501      If this function is called with one return argument then return
 502      the solution SOL of type structure array after solving the set of
 503      DDEs. The solution SOL has the fields X of type double column
 504      vector for the steps chosen by the solver, Y of type double column
 505      vector for the solutions at each time step of X, SOLVER of type
 506      string for the solver name and optionally the extended time stamp
 507      information XE, the extended solution information YE and the
 508      extended index information IE all of type double column vector
 509      that keep the informations of the event function if an event
 510      function handle is set in the option argument OPT.
 511
 512      If this function is called with more than one return argument then
 513      return the time stamps T, the solution values Y and optionally the
 514      extended time stamp information XE, the extended solution
 515      information YE and the extended index information IE all of type
 516      double column vector.
 517
 518      For example:
 519         - the following code solves an anonymous implementation of a
 520           chaotic behavior
 521
 522                fcao = @(vt, vy, vz) [2 * vz / (1 + vz^9.65) - vy];
 523
 524                vopt = odeset ("NormControl", "on", "RelTol", 1e-3);
 525                vsol = ode54d (fcao, [0, 100], 0.5, 2, 0.5, vopt);
 526
 527                vlag = interp1 (vsol.x, vsol.y, vsol.x - 2);
 528                plot (vsol.y, vlag); legend ("fcao (t,y,z)");
 529
 530         - to solve the following problem with two delayed state
 531           variables
 532
 533                d y1(t)/dt = -y1(t)
 534                d y2(t)/dt = -y2(t) + y1(t-5)
 535                d y3(t)/dt = -y3(t) + y2(t-10)*y1(t-10)
 536
 537           one might do the following
 538
 539                function f = fun (t, y, yd)
 540                f(1) = -y(1);                   %% y1' = -y1(t)
 541                f(2) = -y(2) + yd(1,1);         %% y2' = -y2(t) + y1(t-lags(1))
 542                f(3) = -y(3) + yd(2,2)*yd(1,2); %% y3' = -y3(t) + y2(t-lags(2))*y1(t-lags(2))
 543                endfunction
 544                T = [0,20]
 545                res = ode54d (@fun, T, [1;1;1], [5, 10], ones (3,2));
 546
 547
 548    See also: odepkg
 549
 550
 551
 552
 553 # name: <cell-element>
 554 # type: sq_string
 555 # elements: 1
 556 # length: 80
 557 This function file can be used to solve a set of non-stiff delay
 558 differential eq
 559
 560
 561
 562 # name: <cell-element>
 563 # type: sq_string
 564 # elements: 1
 565 # length: 5
 566 ode78
 567
 568
 569 # name: <cell-element>
 570 # type: sq_string
 571 # elements: 1
 572 # length: 2466
 573  -- Function File: [] = ode78 (@FUN, SLOT, INIT, [OPT], [PAR1, PAR2,
 574           ...])
 575  -- Command: [SOL] = ode78 (@FUN, SLOT, INIT, [OPT], [PAR1, PAR2, ...])
 576  -- Command: [T, Y, [XE, YE, IE]] = ode78 (@FUN, SLOT, INIT, [OPT],
 577           [PAR1, PAR2, ...])
 578      This function file can be used to solve a set of non-stiff
 579      ordinary differential equations (non-stiff ODEs) or non-stiff
 580      differential algebraic equations (non-stiff DAEs) with the well
 581      known explicit Runge-Kutta method of order (7,8).
 582
 583      If this function is called with no return argument then plot the
 584      solution over time in a figure window while solving the set of
 585      ODEs that are defined in a function and specified by the function
 586      handle @FUN. The second input argument SLOT is a double vector
 587      that defines the time slot, INIT is a double vector that defines
 588      the initial values of the states, OPT can optionally be a
 589      structure array that keeps the options created with the command
 590      `odeset' and PAR1, PAR2, ... can optionally be other input
 591      arguments of any type that have to be passed to the function
 592      defined by @FUN.
 593
 594      If this function is called with one return argument then return
 595      the solution SOL of type structure array after solving the set of
 596      ODEs. The solution SOL has the fields X of type double column
 597      vector for the steps chosen by the solver, Y of type double column
 598      vector for the solutions at each time step of X, SOLVER of type
 599      string for the solver name and optionally the extended time stamp
 600      information XE, the extended solution information YE and the
 601      extended index information IE all of type double column vector
 602      that keep the informations of the event function if an event
 603      function handle is set in the option argument OPT.
 604
 605      If this function is called with more than one return argument then
 606      return the time stamps T, the solution values Y and optionally the
 607      extended time stamp information XE, the extended solution
 608      information YE and the extended index information IE all of type
 609      double column vector.
 610
 611      For example, solve an anonymous implementation of the Van der Pol
 612      equation
 613
 614           fvdb = @(vt,vy) [vy(2); (1 - vy(1)^2) * vy(2) - vy(1)];
 615
 616           vopt = odeset ("RelTol", 1e-3, "AbsTol", 1e-3, \
 617                    "NormControl", "on", "OutputFcn", @odeplot);
 618           ode78 (fvdb, [0 20], [2 0], vopt);
 619
 620    See also: odepkg
 621
 622
 623
 624
 625 # name: <cell-element>
 626 # type: sq_string
 627 # elements: 1
 628 # length: 80
 629 This function file can be used to solve a set of non-stiff ordinary
 630 differential
 631
 632
 633
 634 # name: <cell-element>
 635 # type: sq_string
 636 # elements: 1
 637 # length: 6
 638 ode78d
 639
 640
 641 # name: <cell-element>
 642 # type: sq_string
 643 # elements: 1
 644 # length: 3606
 645  -- Function File: [] = ode78d (@FUN, SLOT, INIT, LAGS, HIST, [OPT],
 646           [PAR1, PAR2, ...])
 647  -- Command: [SOL] = ode78d (@FUN, SLOT, INIT, LAGS, HIST, [OPT],
 648           [PAR1, PAR2, ...])
 649  -- Command: [T, Y, [XE, YE, IE]] = ode78d (@FUN, SLOT, INIT, LAGS,
 650           HIST, [OPT], [PAR1, PAR2, ...])
 651      This function file can be used to solve a set of non-stiff delay
 652      differential equations (non-stiff DDEs) with a modified version of
 653      the well known explicit Runge-Kutta method of order (7,8).
 654
 655      If this function is called with no return argument then plot the
 656      solution over time in a figure window while solving the set of
 657      DDEs that are defined in a function and specified by the function
 658      handle @FUN. The second input argument SLOT is a double vector
 659      that defines the time slot, INIT is a double vector that defines
 660      the initial values of the states, LAGS is a double vector that
 661      describes the lags of time, HIST is a double matrix and describes
 662      the history of the DDEs, OPT can optionally be a structure array
 663      that keeps the options created with the command `odeset' and PAR1,
 664      PAR2, ... can optionally be other input arguments of any type that
 665      have to be passed to the function defined by @FUN.
 666
 667      In other words, this function will solve a problem of the form
 668           dy/dt = fun (t, y(t), y(t-lags(1), y(t-lags(2), ...)))
 669           y(slot(1)) = init
 670           y(slot(1)-lags(1)) = hist(1), y(slot(1)-lags(2)) = hist(2), ...
 671
 672      If this function is called with one return argument then return
 673      the solution SOL of type structure array after solving the set of
 674      DDEs. The solution SOL has the fields X of type double column
 675      vector for the steps chosen by the solver, Y of type double column
 676      vector for the solutions at each time step of X, SOLVER of type
 677      string for the solver name and optionally the extended time stamp
 678      information XE, the extended solution information YE and the
 679      extended index information IE all of type double column vector
 680      that keep the informations of the event function if an event
 681      function handle is set in the option argument OPT.
 682
 683      If this function is called with more than one return argument then
 684      return the time stamps T, the solution values Y and optionally the
 685      extended time stamp information XE, the extended solution
 686      information YE and the extended index information IE all of type
 687      double column vector.
 688
 689      For example:
 690         - the following code solves an anonymous implementation of a
 691           chaotic behavior
 692
 693                fcao = @(vt, vy, vz) [2 * vz / (1 + vz^9.65) - vy];
 694
 695                vopt = odeset ("NormControl", "on", "RelTol", 1e-3);
 696                vsol = ode78d (fcao, [0, 100], 0.5, 2, 0.5, vopt);
 697
 698                vlag = interp1 (vsol.x, vsol.y, vsol.x - 2);
 699                plot (vsol.y, vlag); legend ("fcao (t,y,z)");
 700
 701         - to solve the following problem with two delayed state
 702           variables
 703
 704                d y1(t)/dt = -y1(t)
 705                d y2(t)/dt = -y2(t) + y1(t-5)
 706                d y3(t)/dt = -y3(t) + y2(t-10)*y1(t-10)
 707
 708           one might do the following
 709
 710                function f = fun (t, y, yd)
 711                f(1) = -y(1);                   %% y1' = -y1(t)
 712                f(2) = -y(2) + yd(1,1);         %% y2' = -y2(t) + y1(t-lags(1))
 713                f(3) = -y(3) + yd(2,2)*yd(1,2); %% y3' = -y3(t) + y2(t-lags(2))*y1(t-lags(2))
 714                endfunction
 715                T = [0,20]
 716                res = ode78d (@fun, T, [1;1;1], [5, 10], ones (3,2));
 717
 718
 719    See also: odepkg
 720
 721
 722
 723
 724 # name: <cell-element>
 725 # type: sq_string
 726 # elements: 1
 727 # length: 80
 728 This function file can be used to solve a set of non-stiff delay
 729 differential eq
 730
 731
 732
 733 # name: <cell-element>
 734 # type: sq_string
 735 # elements: 1
 736 # length: 6
 737 odebwe
 738
 739
 740 # name: <cell-element>
 741 # type: sq_string
 742 # elements: 1
 743 # length: 2525
 744  -- Function File: [] = odebwe (@FUN, SLOT, INIT, [OPT], [PAR1, PAR2,
 745           ...])
 746  -- Command: [SOL] = odebwe (@FUN, SLOT, INIT, [OPT], [PAR1, PAR2, ...])
 747  -- Command: [T, Y, [XE, YE, IE]] = odebwe (@FUN, SLOT, INIT, [OPT],
 748           [PAR1, PAR2, ...])
 749      This function file can be used to solve a set of stiff ordinary
 750      differential equations (stiff ODEs) or stiff differential
 751      algebraic equations (stiff DAEs) with the Backward Euler method.
 752
 753      If this function is called with no return argument then plot the
 754      solution over time in a figure window while solving the set of
 755      ODEs that are defined in a function and specified by the function
 756      handle @FUN. The second input argument SLOT is a double vector
 757      that defines the time slot, INIT is a double vector that defines
 758      the initial values of the states, OPT can optionally be a
 759      structure array that keeps the options created with the command
 760      `odeset' and PAR1, PAR2, ... can optionally be other input
 761      arguments of any type that have to be passed to the function
 762      defined by @FUN.
 763
 764      If this function is called with one return argument then return
 765      the solution SOL of type structure array after solving the set of
 766      ODEs. The solution SOL has the fields X of type double column
 767      vector for the steps chosen by the solver, Y of type double column
 768      vector for the solutions at each time step of X, SOLVER of type
 769      string for the solver name and optionally the extended time stamp
 770      information XE, the extended solution information YE and the
 771      extended index information IE all of type double column vector
 772      that keep the informations of the event function if an event
 773      function handle is set in the option argument OPT.
 774
 775      If this function is called with more than one return argument then
 776      return the time stamps T, the solution values Y and optionally the
 777      extended time stamp information XE, the extended solution
 778      information YE and the extended index information IE all of type
 779      double column vector.
 780
 781      For example, solve an anonymous implementation of the Van der Pol
 782      equation
 783
 784           fvdb = @(vt,vy) [vy(2); (1 - vy(1)^2) * vy(2) - vy(1)];
 785           vjac = @(vt,vy) [0, 1; -1 - 2 * vy(1) * vy(2), 1 - vy(1)^2];
 786           vopt = odeset ("RelTol", 1e-3, "AbsTol", 1e-3, \
 787                    "NormControl", "on", "OutputFcn", @odeplot, \
 788                    "Jacobian",vjac);
 789           odebwe (fvdb, [0 20], [2 0], vopt);
 790
 791    See also: odepkg
 792
 793
 794
 795
 796 # name: <cell-element>
 797 # type: sq_string
 798 # elements: 1
 799 # length: 80
 800 This function file can be used to solve a set of stiff ordinary
 801 differential equ
 802
 803
 804
 805 # name: <cell-element>
 806 # type: sq_string
 807 # elements: 1
 808 # length: 11
 809 odeexamples
 810
 811
 812 # name: <cell-element>
 813 # type: sq_string
 814 # elements: 1
 815 # length: 169
 816  -- Function File: [] = odeexamples ()
 817      Open the differential equations examples menu and allow the user
 818      to select a submenu of ODE, DAE, IDE or DDE examples.
 819
 820
 821
 822
 823 # name: <cell-element>
 824 # type: sq_string
 825 # elements: 1
 826 # length: 80
 827 Open the differential equations examples menu and allow the user to
 828 select a sub
 829
 830
 831
 832 # name: <cell-element>
 833 # type: sq_string
 834 # elements: 1
 835 # length: 6
 836 odeget
 837
 838
 839 # name: <cell-element>
 840 # type: sq_string
 841 # elements: 1
 842 # length: 1313
 843  -- Function File: [VALUE] = odeget (ODESTRUCT, OPTION, [DEFAULT])
 844  -- Command: [VALUES] = odeget (ODESTRUCT, {OPT1, OPT2, ...}, [{DEF1,
 845           DEF2, ...}])
 846      If this function is called with two input arguments and the first
 847      input argument ODESTRUCT is of type structure array and the second
 848      input argument OPTION is of type string then return the option
 849      value VALUE that is specified by the option name OPTION in the
 850      OdePkg option structure ODESTRUCT. Optionally if this function is
 851      called with a third input argument then return the default value
 852      DEFAULT if OPTION is not set in the structure ODESTRUCT.
 853
 854      If this function is called with two input arguments and the first
 855      input argument ODESTRUCT is of type structure array and the second
 856      input argument OPTION is of type cell array of strings then return
 857      the option values VALUES that are specified by the option names
 858      OPT1, OPT2, ... in the OdePkg option structure ODESTRUCT.
 859      Optionally if this function is called with a third input argument
 860      of type cell array then return the default value DEF1 if OPT1 is
 861      not set in the structure ODESTRUCT, DEF2 if OPT2 is not set in the
 862      structure ODESTRUCT, ...
 863
 864      Run examples with the command
 865           demo odeget
 866
 867    See also: odepkg
 868
 869
 870
 871
 872 # name: <cell-element>
 873 # type: sq_string
 874 # elements: 1
 875 # length: 80
 876 If this function is called with two input arguments and the first input
 877 argument
 878
 879
 880
 881 # name: <cell-element>
 882 # type: sq_string
 883 # elements: 1
 884 # length: 8
 885 odephas2
 886
 887
 888 # name: <cell-element>
 889 # type: sq_string
 890 # elements: 1
 891 # length: 1625
 892  -- Function File: [RET] = odephas2 (T, Y, FLAG)
 893      Open a new figure window and plot the first result from the
 894      variable Y that is of type double column vector over the second
 895      result from the variable Y while solving. The types and the values
 896      of the input parameter T and the output parameter RET depend on
 897      the input value FLAG that is of type string. If FLAG is
 898     ``"init"''
 899           then T must be a double column vector of length 2 with the
 900           first and the last time step and nothing is returned from
 901           this function,
 902
 903     ``""''
 904           then T must be a double scalar specifying the actual time
 905           step and the return value is false (resp. value 0) for 'not
 906           stop solving',
 907
 908     ``"done"''
 909           then T must be a double scalar specifying the last time step
 910           and nothing is returned from this function.
 911
 912      This function is called by a OdePkg solver function if it was
 913      specified in an OdePkg options structure with the `odeset'. This
 914      function is an OdePkg internal helper function therefore it should
 915      never be necessary that this function is called directly by a
 916      user. There is only little error detection implemented in this
 917      function file to achieve the highest performance.
 918
 919      For example, solve an anonymous implementation of the "Van der
 920      Pol" equation and display the results while solving in a 2D plane
 921           fvdb = @(vt,vy) [vy(2); (1 - vy(1)^2) * vy(2) - vy(1)];
 922
 923           vopt = odeset ('OutputFcn', @odephas2, 'RelTol', 1e-6);
 924           vsol = ode45 (fvdb, [0 20], [2 0], vopt);
 925
 926    See also: odepkg
 927
 928
 929
 930
 931 # name: <cell-element>
 932 # type: sq_string
 933 # elements: 1
 934 # length: 80
 935 Open a new figure window and plot the first result from the variable Y
 936 that is o
 937
 938
 939
 940 # name: <cell-element>
 941 # type: sq_string
 942 # elements: 1
 943 # length: 8
 944 odephas3
 945
 946
 947 # name: <cell-element>
 948 # type: sq_string
 949 # elements: 1
 950 # length: 1735
 951  -- Function File: [RET] = odephas3 (T, Y, FLAG)
 952      Open a new figure window and plot the first result from the
 953      variable Y that is of type double column vector over the second
 954      and the third result from the variable Y while solving. The types
 955      and the values of the input parameter T and the output parameter
 956      RET depend on the input value FLAG that is of type string. If FLAG
 957      is
 958     ``"init"''
 959           then T must be a double column vector of length 2 with the
 960           first and the last time step and nothing is returned from
 961           this function,
 962
 963     ``""''
 964           then T must be a double scalar specifying the actual time
 965           step and the return value is false (resp. value 0) for 'not
 966           stop solving',
 967
 968     ``"done"''
 969           then T must be a double scalar specifying the last time step
 970           and nothing is returned from this function.
 971
 972      This function is called by a OdePkg solver function if it was
 973      specified in an OdePkg options structure with the `odeset'. This
 974      function is an OdePkg internal helper function therefore it should
 975      never be necessary that this function is called directly by a
 976      user. There is only little error detection implemented in this
 977      function file to achieve the highest performance.
 978
 979      For example, solve the "Lorenz attractor" and display the results
 980      while solving in a 3D plane
 981           function vyd = florenz (vt, vx)
 982             vyd = [10 * (vx(2) - vx(1));
 983                    vx(1) * (28 - vx(3));
 984                    vx(1) * vx(2) - 8/3 * vx(3)];
 985           endfunction
 986
 987           vopt = odeset ('OutputFcn', @odephas3);
 988           vsol = ode23 (@florenz, [0:0.01:7.5], [3 15 1], vopt);
 989
 990    See also: odepkg
 991
 992
 993
 994
 995 # name: <cell-element>
 996 # type: sq_string
 997 # elements: 1
 998 # length: 80
 999 Open a new figure window and plot the first result from the variable Y
1000 that is o
1001
1002
1003
1004 # name: <cell-element>
1005 # type: sq_string
1006 # elements: 1
1007 # length: 6
1008 odepkg
1009
1010
1011 # name: <cell-element>
1012 # type: sq_string
1013 # elements: 1
1014 # length: 664
1015  -- Function File: [] = odepkg ()
1016      OdePkg is part of the GNU Octave Repository (the Octave-Forge
1017      project). The package includes commands for setting up various
1018      options, output functions etc. before solving a set of
1019      differential equations with the solver functions that are also
1020      included. At this time OdePkg is under development with the main
1021      target to make a package that is mostly compatible to proprietary
1022      solver products.
1023
1024      If this function is called without any input argument then open
1025      the OdePkg tutorial in the Octave window. The tutorial can also be
1026      opened with the following command
1027
1028           doc odepkg
1029
1030
1031
1032
1033 # name: <cell-element>
1034 # type: sq_string
1035 # elements: 1
1036 # length: 71
1037 OdePkg is part of the GNU Octave Repository (the Octave-Forge project).
1038
1039
1040
1041 # name: <cell-element>
1042 # type: sq_string
1043 # elements: 1
1044 # length: 19
1045 odepkg_event_handle
1046
1047
1048 # name: <cell-element>
1049 # type: sq_string
1050 # elements: 1
1051 # length: 1577
1052  -- Function File: [SOL] = odepkg_event_handle (@FUN, TIME, Y, FLAG,
1053           [PAR1, PAR2, ...])
1054      Return the solution of the event function that is specified as the
1055      first input argument @FUN in form of a function handle. The second
1056      input argument TIME is of type double scalar and specifies the
1057      time of the event evaluation, the third input argument Y either is
1058      of type double column vector (for ODEs and DAEs) and specifies the
1059      solutions or is of type cell array (for IDEs and DDEs) and
1060      specifies the derivatives or the history values, the third input
1061      argument FLAG is of type string and can be of the form
1062     ``"init"''
1063           then initialize internal persistent variables of the function
1064           `odepkg_event_handle' and return an empty cell array of size
1065           4,
1066
1067     ``"calc"''
1068           then do the evaluation of the event function and return the
1069           solution SOL as type cell array of size 4,
1070
1071     ``"done"''
1072           then cleanup internal variables of the function
1073           `odepkg_event_handle' and return an empty cell array of size
1074           4.
1075      Optionally if further input arguments PAR1, PAR2, ... of any type
1076      are given then pass these parameters through `odepkg_event_handle'
1077      to the event function.
1078
1079      This function is an OdePkg internal helper function therefore it
1080      should never be necessary that this function is called directly by
1081      a user. There is only little error detection implemented in this
1082      function file to achieve the highest performance.
1083
1084    See also: odepkg
1085
1086
1087
1088
1089 # name: <cell-element>
1090 # type: sq_string
1091 # elements: 1
1092 # length: 80
1093 Return the solution of the event function that is specified as the
1094 first input a
1095
1096
1097
1098 # name: <cell-element>
1099 # type: sq_string
1100 # elements: 1
1101 # length: 19
1102 odepkg_examples_dae
1103
1104
1105 # name: <cell-element>
1106 # type: sq_string
1107 # elements: 1
1108 # length: 145
1109  -- Function File: [] = odepkg_examples_dae ()
1110      Open the DAE examples menu and allow the user to select a demo
1111      that will be evaluated.
1112
1113
1114
1115
1116 # name: <cell-element>
1117 # type: sq_string
1118 # elements: 1
1119 # length: 80
1120 Open the DAE examples menu and allow the user to select a demo that
1121 will be eval
1122
1123
1124
1125 # name: <cell-element>
1126 # type: sq_string
1127 # elements: 1
1128 # length: 19
1129 odepkg_examples_dde
1130
1131
1132 # name: <cell-element>
1133 # type: sq_string
1134 # elements: 1
1135 # length: 145
1136  -- Function File: [] = odepkg_examples_dde ()
1137      Open the DDE examples menu and allow the user to select a demo
1138      that will be evaluated.
1139
1140
1141
1142
1143 # name: <cell-element>
1144 # type: sq_string
1145 # elements: 1
1146 # length: 80
1147 Open the DDE examples menu and allow the user to select a demo that
1148 will be eval
1149
1150
1151
1152 # name: <cell-element>
1153 # type: sq_string
1154 # elements: 1
1155 # length: 19
1156 odepkg_examples_ide
1157
1158
1159 # name: <cell-element>
1160 # type: sq_string
1161 # elements: 1
1162 # length: 145
1163  -- Function File: [] = odepkg_examples_ide ()
1164      Open the IDE examples menu and allow the user to select a demo
1165      that will be evaluated.
1166
1167
1168
1169
1170 # name: <cell-element>
1171 # type: sq_string
1172 # elements: 1
1173 # length: 80
1174 Open the IDE examples menu and allow the user to select a demo that
1175 will be eval
1176
1177
1178
1179 # name: <cell-element>
1180 # type: sq_string
1181 # elements: 1
1182 # length: 19
1183 odepkg_examples_ode
1184
1185
1186 # name: <cell-element>
1187 # type: sq_string
1188 # elements: 1
1189 # length: 145
1190  -- Function File: [] = odepkg_examples_ode ()
1191      Open the ODE examples menu and allow the user to select a demo
1192      that will be evaluated.
1193
1194
1195
1196
1197 # name: <cell-element>
1198 # type: sq_string
1199 # elements: 1
1200 # length: 80
1201 Open the ODE examples menu and allow the user to select a demo that
1202 will be eval
1203
1204
1205
1206 # name: <cell-element>
1207 # type: sq_string
1208 # elements: 1
1209 # length: 22
1210 odepkg_structure_check
1211
1212
1213 # name: <cell-element>
1214 # type: sq_string
1215 # elements: 1
1216 # length: 1043
1217  -- Function File: [NEWSTRUCT] = odepkg_structure_check (OLDSTRUCT,
1218           ["SOLVER"])
1219      If this function is called with one input argument of type
1220      structure array then check the field names and the field values of
1221      the OdePkg structure OLDSTRUCT and return the structure as
1222      NEWSTRUCT if no error is found. Optionally if this function is
1223      called with a second input argument "SOLVER" of type string taht
1224      specifies the name of a valid OdePkg solver then a higher level
1225      error detection is performed. The function does not modify any of
1226      the field names or field values but terminates with an error if an
1227      invalid option or value is found.
1228
1229      This function is an OdePkg internal helper function therefore it
1230      should never be necessary that this function is called directly by
1231      a user. There is only little error detection implemented in this
1232      function file to achieve the highest performance.
1233
1234      Run examples with the command
1235           demo odepkg_structure_check
1236
1237    See also: odepkg
1238
1239
1240
1241
1242 # name: <cell-element>
1243 # type: sq_string
1244 # elements: 1
1245 # length: 80
1246 If this function is called with one input argument of type structure
1247 array then
1248
1249
1250
1251 # name: <cell-element>
1252 # type: sq_string
1253 # elements: 1
1254 # length: 26
1255 odepkg_testsuite_calcmescd
1256
1257
1258 # name: <cell-element>
1259 # type: sq_string
1260 # elements: 1
1261 # length: 890
1262  -- Function File: [MESCD] = odepkg_testsuite_calcmescd (SOLUTION,
1263           REFERENCE, ABSTOL, RELTOL)
1264      If this function is called with four input arguments of type
1265      double scalar or column vector then return a normalized value for
1266      the minimum number of correct digits MESCD that is calculated from
1267      the solution at the end of an integration interval SOLUTION and a
1268      set of reference values REFERENCE. The input arguments ABSTOL and
1269      RELTOL are used to calculate a reference solution that depends on
1270      the relative and absolute error tolerances.
1271
1272      Run examples with the command
1273           demo odepkg_testsuite_calcmescd
1274
1275      This function has been ported from the "Test Set for IVP solvers"
1276      which is developed by the INdAM Bari unit project group "Codes and
1277      Test Problems for Differential Equations", coordinator F. Mazzia.
1278
1279    See also: odepkg
1280
1281
1282
1283
1284 # name: <cell-element>
1285 # type: sq_string
1286 # elements: 1
1287 # length: 80
1288 If this function is called with four input arguments of type double
1289 scalar or co
1290
1291
1292
1293 # name: <cell-element>
1294 # type: sq_string
1295 # elements: 1
1296 # length: 24
1297 odepkg_testsuite_calcscd
1298
1299
1300 # name: <cell-element>
1301 # type: sq_string
1302 # elements: 1
1303 # length: 873
1304  -- Function File: [SCD] = odepkg_testsuite_calcscd (SOLUTION,
1305           REFERENCE, ABSTOL, RELTOL)
1306      If this function is called with four input arguments of type
1307      double scalar or column vector then return a normalized value for
1308      the minimum number of correct digits SCD that is calculated from
1309      the solution at the end of an integration interval SOLUTION and a
1310      set of reference values REFERENCE. The input arguments ABSTOL and
1311      RELTOL are unused but present because of compatibility to the
1312      function `odepkg_testsuite_calcmescd'.
1313
1314      Run examples with the command
1315           demo odepkg_testsuite_calcscd
1316
1317      This function has been ported from the "Test Set for IVP solvers"
1318      which is developed by the INdAM Bari unit project group "Codes and
1319      Test Problems for Differential Equations", coordinator F. Mazzia.
1320
1321    See also: odepkg
1322
1323
1324
1325
1326 # name: <cell-element>
1327 # type: sq_string
1328 # elements: 1
1329 # length: 80
1330 If this function is called with four input arguments of type double
1331 scalar or co
1332
1333
1334
1335 # name: <cell-element>
1336 # type: sq_string
1337 # elements: 1
1338 # length: 25
1339 odepkg_testsuite_chemakzo
1340
1341
1342 # name: <cell-element>
1343 # type: sq_string
1344 # elements: 1
1345 # length: 835
1346  -- Function File: [SOLUTION] = odepkg_testsuite_chemakzo (@SOLVER,
1347           RELTOL)
1348      If this function is called with two input arguments and the first
1349      input argument @SOLVER is a function handle describing an OdePkg
1350      solver and the second input argument RELTOL is a double scalar
1351      describing the relative error tolerance then return a cell array
1352      SOLUTION with performance informations about the chemical AKZO
1353      Nobel testsuite of differential algebraic equations after solving
1354      (DAE-test).
1355
1356      Run examples with the command
1357           demo odepkg_testsuite_chemakzo
1358
1359      This function has been ported from the "Test Set for IVP solvers"
1360      which is developed by the INdAM Bari unit project group "Codes and
1361      Test Problems for Differential Equations", coordinator F. Mazzia.
1362
1363    See also: odepkg
1364
1365
1366
1367
1368 # name: <cell-element>
1369 # type: sq_string
1370 # elements: 1
1371 # length: 80
1372 If this function is called with two input arguments and the first input
1373 argument
1374
1375
1376
1377 # name: <cell-element>
1378 # type: sq_string
1379 # elements: 1
1380 # length: 22
1381 odepkg_testsuite_hires
1382
1383
1384 # name: <cell-element>
1385 # type: sq_string
1386 # elements: 1
1387 # length: 799
1388  -- Function File: [SOLUTION] = odepkg_testsuite_hires (@SOLVER, RELTOL)
1389      If this function is called with two input arguments and the first
1390      input argument @SOLVER is a function handle describing an OdePkg
1391      solver and the second input argument RELTOL is a double scalar
1392      describing the relative error tolerance then return a cell array
1393      SOLUTION with performance informations about the HIRES testsuite
1394      of ordinary differential equations after solving (ODE-test).
1395
1396      Run examples with the command
1397           demo odepkg_testsuite_hires
1398
1399      This function has been ported from the "Test Set for IVP solvers"
1400      which is developed by the INdAM Bari unit project group "Codes and
1401      Test Problems for Differential Equations", coordinator F. Mazzia.
1402
1403    See also: odepkg
1404
1405
1406
1407
1408 # name: <cell-element>
1409 # type: sq_string
1410 # elements: 1
1411 # length: 80
1412 If this function is called with two input arguments and the first input
1413 argument
1414
1415
1416
1417 # name: <cell-element>
1418 # type: sq_string
1419 # elements: 1
1420 # length: 25
1421 odepkg_testsuite_implakzo
1422
1423
1424 # name: <cell-element>
1425 # type: sq_string
1426 # elements: 1
1427 # length: 844
1428  -- Function File: [SOLUTION] = odepkg_testsuite_implakzo (@SOLVER,
1429           RELTOL)
1430      If this function is called with two input arguments and the first
1431      input argument @SOLVER is a function handle describing an OdePkg
1432      solver and the second input argument RELTOL is a double scalar
1433      describing the relative error tolerance then return a cell array
1434      SOLUTION with performance informations about the chemical AKZO
1435      Nobel testsuite of implicit differential algebraic equations after
1436      solving (IDE-test).
1437
1438      Run examples with the command
1439           demo odepkg_testsuite_implakzo
1440
1441      This function has been ported from the "Test Set for IVP solvers"
1442      which is developed by the INdAM Bari unit project group "Codes and
1443      Test Problems for Differential Equations", coordinator F. Mazzia.
1444
1445    See also: odepkg
1446
1447
1448
1449
1450 # name: <cell-element>
1451 # type: sq_string
1452 # elements: 1
1453 # length: 80
1454 If this function is called with two input arguments and the first input
1455 argument
1456
1457
1458
1459 # name: <cell-element>
1460 # type: sq_string
1461 # elements: 1
1462 # length: 26
1463 odepkg_testsuite_implrober
1464
1465
1466 # name: <cell-element>
1467 # type: sq_string
1468 # elements: 1
1469 # length: 866
1470  -- Function File: [SOLUTION] = odepkg_testsuite_implrober (@SOLVER,
1471           RELTOL)
1472      If this function is called with two input arguments and the first
1473      input argument @SOLVER is a function handle describing an OdePkg
1474      solver and the second input argument RELTOL is a double scalar
1475      describing the relative error tolerance then return a cell array
1476      SOLUTION with performance informations about the implicit form of
1477      the modified ROBERTSON testsuite of implicit differential
1478      algebraic equations after solving (IDE-test).
1479
1480      Run examples with the command
1481           demo odepkg_testsuite_implrober
1482
1483      This function has been ported from the "Test Set for IVP solvers"
1484      which is developed by the INdAM Bari unit project group "Codes and
1485      Test Problems for Differential Equations", coordinator F. Mazzia.
1486
1487    See also: odepkg
1488
1489
1490
1491
1492 # name: <cell-element>
1493 # type: sq_string
1494 # elements: 1
1495 # length: 80
1496 If this function is called with two input arguments and the first input
1497 argument
1498
1499
1500
1501 # name: <cell-element>
1502 # type: sq_string
1503 # elements: 1
1504 # length: 26
1505 odepkg_testsuite_impltrans
1506
1507
1508 # name: <cell-element>
1509 # type: sq_string
1510 # elements: 1
1511 # length: 839
1512  -- Function File: [SOLUTION] = odepkg_testsuite_impltrans (@SOLVER,
1513           RELTOL)
1514      If this function is called with two input arguments and the first
1515      input argument @SOLVER is a function handle describing an OdePkg
1516      solver and the second input argument RELTOL is a double scalar
1517      describing the relative error tolerance then return the cell array
1518      SOLUTION with performance informations about the TRANSISTOR
1519      testsuite of implicit differential algebraic equations after
1520      solving (IDE-test).
1521
1522      Run examples with the command
1523           demo odepkg_testsuite_impltrans
1524
1525      This function has been ported from the "Test Set for IVP solvers"
1526      which is developed by the INdAM Bari unit project group "Codes and
1527      Test Problems for Differential Equations", coordinator F. Mazzia.
1528
1529    See also: odepkg
1530
1531
1532
1533
1534 # name: <cell-element>
1535 # type: sq_string
1536 # elements: 1
1537 # length: 80
1538 If this function is called with two input arguments and the first input
1539 argument
1540
1541
1542
1543 # name: <cell-element>
1544 # type: sq_string
1545 # elements: 1
1546 # length: 27
1547 odepkg_testsuite_oregonator
1548
1549
1550 # name: <cell-element>
1551 # type: sq_string
1552 # elements: 1
1553 # length: 829
1554  -- Function File: [SOLUTION] = odepkg_testsuite_oregonator (@SOLVER,
1555           RELTOL)
1556      If this function is called with two input arguments and the first
1557      input argument @SOLVER is a function handle describing an OdePkg
1558      solver and the second input argument RELTOL is a double scalar
1559      describing the relative error tolerance then return a cell array
1560      SOLUTION with performance informations about the OREGONATOR
1561      testsuite of ordinary differential equations after solving
1562      (ODE-test).
1563
1564      Run examples with the command
1565           demo odepkg_testsuite_oregonator
1566
1567      This function has been ported from the "Test Set for IVP solvers"
1568      which is developed by the INdAM Bari unit project group "Codes and
1569      Test Problems for Differential Equations", coordinator F. Mazzia.
1570
1571    See also: odepkg
1572
1573
1574
1575
1576 # name: <cell-element>
1577 # type: sq_string
1578 # elements: 1
1579 # length: 80
1580 If this function is called with two input arguments and the first input
1581 argument
1582
1583
1584
1585 # name: <cell-element>
1586 # type: sq_string
1587 # elements: 1
1588 # length: 26
1589 odepkg_testsuite_pollution
1590
1591
1592 # name: <cell-element>
1593 # type: sq_string
1594 # elements: 1
1595 # length: 828
1596  -- Function File: [SOLUTION] = odepkg_testsuite_pollution (@SOLVER,
1597           RELTOL)
1598      If this function is called with two input arguments and the first
1599      input argument @SOLVER is a function handle describing an OdePkg
1600      solver and the second input argument RELTOL is a double scalar
1601      describing the relative error tolerance then return the cell array
1602      SOLUTION with performance informations about the POLLUTION
1603      testsuite of ordinary differential equations after solving
1604      (ODE-test).
1605
1606      Run examples with the command
1607           demo odepkg_testsuite_pollution
1608
1609      This function has been ported from the "Test Set for IVP solvers"
1610      which is developed by the INdAM Bari unit project group "Codes and
1611      Test Problems for Differential Equations", coordinator F. Mazzia.
1612
1613    See also: odepkg
1614
1615
1616
1617
1618 # name: <cell-element>
1619 # type: sq_string
1620 # elements: 1
1621 # length: 80
1622 If this function is called with two input arguments and the first input
1623 argument
1624
1625
1626
1627 # name: <cell-element>
1628 # type: sq_string
1629 # elements: 1
1630 # length: 26
1631 odepkg_testsuite_robertson
1632
1633
1634 # name: <cell-element>
1635 # type: sq_string
1636 # elements: 1
1637 # length: 836
1638  -- Function File: [SOLUTION] = odepkg_testsuite_robertson (@SOLVER,
1639           RELTOL)
1640      If this function is called with two input arguments and the first
1641      input argument @SOLVER is a function handle describing an OdePkg
1642      solver and the second input argument RELTOL is a double scalar
1643      describing the relative error tolerance then return a cell array
1644      SOLUTION with performance informations about the modified
1645      ROBERTSON testsuite of differential algebraic equations after
1646      solving (DAE-test).
1647
1648      Run examples with the command
1649           demo odepkg_testsuite_robertson
1650
1651      This function has been ported from the "Test Set for IVP solvers"
1652      which is developed by the INdAM Bari unit project group "Codes and
1653      Test Problems for Differential Equations", coordinator F. Mazzia.
1654
1655    See also: odepkg
1656
1657
1658
1659
1660 # name: <cell-element>
1661 # type: sq_string
1662 # elements: 1
1663 # length: 80
1664 If this function is called with two input arguments and the first input
1665 argument
1666
1667
1668
1669 # name: <cell-element>
1670 # type: sq_string
1671 # elements: 1
1672 # length: 27
1673 odepkg_testsuite_transistor
1674
1675
1676 # name: <cell-element>
1677 # type: sq_string
1678 # elements: 1
1679 # length: 832
1680  -- Function File: [SOLUTION] = odepkg_testsuite_transistor (@SOLVER,
1681           RELTOL)
1682      If this function is called with two input arguments and the first
1683      input argument @SOLVER is a function handle describing an OdePkg
1684      solver and the second input argument RELTOL is a double scalar
1685      describing the relative error tolerance then return the cell array
1686      SOLUTION with performance informations about the TRANSISTOR
1687      testsuite of differential algebraic equations after solving
1688      (DAE-test).
1689
1690      Run examples with the command
1691           demo odepkg_testsuite_transistor
1692
1693      This function has been ported from the "Test Set for IVP solvers"
1694      which is developed by the INdAM Bari unit project group "Codes and
1695      Test Problems for Differential Equations", coordinator F. Mazzia.
1696
1697    See also: odepkg
1698
1699
1700
1701
1702 # name: <cell-element>
1703 # type: sq_string
1704 # elements: 1
1705 # length: 80
1706 If this function is called with two input arguments and the first input
1707 argument
1708
1709
1710
1711 # name: <cell-element>
1712 # type: sq_string
1713 # elements: 1
1714 # length: 7
1715 odeplot
1716
1717
1718 # name: <cell-element>
1719 # type: sq_string
1720 # elements: 1
1721 # length: 1551
1722  -- Function File: [RET] = odeplot (T, Y, FLAG)
1723      Open a new figure window and plot the results from the variable Y
1724      of type column vector over time while solving. The types and the
1725      values of the input parameter T and the output parameter RET
1726      depend on the input value FLAG that is of type string. If FLAG is
1727     ``"init"''
1728           then T must be a double column vector of length 2 with the
1729           first and the last time step and nothing is returned from
1730           this function,
1731
1732     ``""''
1733           then T must be a double scalar specifying the actual time
1734           step and the return value is false (resp. value 0) for 'not
1735           stop solving',
1736
1737     ``"done"''
1738           then T must be a double scalar specifying the last time step
1739           and nothing is returned from this function.
1740
1741      This function is called by a OdePkg solver function if it was
1742      specified in an OdePkg options structure with the `odeset'. This
1743      function is an OdePkg internal helper function therefore it should
1744      never be necessary that this function is called directly by a
1745      user. There is only little error detection implemented in this
1746      function file to achieve the highest performance.
1747
1748      For example, solve an anonymous implementation of the "Van der
1749      Pol" equation and display the results while solving
1750           fvdb = @(vt,vy) [vy(2); (1 - vy(1)^2) * vy(2) - vy(1)];
1751
1752           vopt = odeset ('OutputFcn', @odeplot, 'RelTol', 1e-6);
1753           vsol = ode45 (fvdb, [0 20], [2 0], vopt);
1754
1755    See also: odepkg
1756
1757
1758
1759
1760 # name: <cell-element>
1761 # type: sq_string
1762 # elements: 1
1763 # length: 80
1764 Open a new figure window and plot the results from the variable Y of
1765 type column
1766
1767
1768
1769 # name: <cell-element>
1770 # type: sq_string
1771 # elements: 1
1772 # length: 8
1773 odeprint
1774
1775
1776 # name: <cell-element>
1777 # type: sq_string
1778 # elements: 1
1779 # length: 1760
1780  -- Function File: [RET] = odeprint (T, Y, FLAG)
1781      Display the results of the set of differential equations in the
1782      Octave window while solving. The first column of the screen output
1783      shows the actual time stamp that is given with the input arguemtn
1784      T, the following columns show the results from the function
1785      evaluation that are given by the column vector Y. The types and
1786      the values of the input parameter T and the output parameter RET
1787      depend on the input value FLAG that is of type string. If FLAG is
1788     ``"init"''
1789           then T must be a double column vector of length 2 with the
1790           first and the last time step and nothing is returned from
1791           this function,
1792
1793     ``""''
1794           then T must be a double scalar specifying the actual time
1795           step and the return value is false (resp. value 0) for 'not
1796           stop solving',
1797
1798     ``"done"''
1799           then T must be a double scalar specifying the last time step
1800           and nothing is returned from this function.
1801
1802      This function is called by a OdePkg solver function if it was
1803      specified in an OdePkg options structure with the `odeset'. This
1804      function is an OdePkg internal helper function therefore it should
1805      never be necessary that this function is called directly by a
1806      user. There is only little error detection implemented in this
1807      function file to achieve the highest performance.
1808
1809      For example, solve an anonymous implementation of the "Van der
1810      Pol" equation and print the results while solving
1811           fvdb = @(vt,vy) [vy(2); (1 - vy(1)^2) * vy(2) - vy(1)];
1812
1813           vopt = odeset ('OutputFcn', @odeprint, 'RelTol', 1e-6);
1814           vsol = ode45 (fvdb, [0 20], [2 0], vopt);
1815
1816    See also: odepkg
1817
1818
1819
1820
1821 # name: <cell-element>
1822 # type: sq_string
1823 # elements: 1
1824 # length: 80
1825 Display the results of the set of differential equations in the Octave
1826 window wh
1827
1828
1829
1830 # name: <cell-element>
1831 # type: sq_string
1832 # elements: 1
1833 # length: 6
1834 odeset
1835
1836
1837 # name: <cell-element>
1838 # type: sq_string
1839 # elements: 1
1840 # length: 1704
1841  -- Function File: [ODESTRUCT] = odeset ()
1842  -- Command: [ODESTRUCT] = odeset ("FIELD1", VALUE1, "FIELD2", VALUE2,
1843           ...)
1844  -- Command: [ODESTRUCT] = odeset (OLDSTRUCT, "FIELD1", VALUE1,
1845           "FIELD2", VALUE2, ...)
1846  -- Command: [ODESTRUCT] = odeset (OLDSTRUCT, NEWSTRUCT)
1847      If this function is called without an input argument then return a
1848      new OdePkg options structure array that contains all the necessary
1849      fields and sets the values of all fields to default values.
1850
1851      If this function is called with string input arguments "FIELD1",
1852      "FIELD2", ... identifying valid OdePkg options then return a new
1853      OdePkg options structure with all necessary fields and set the
1854      values of the fields "FIELD1", "FIELD2", ... to the values VALUE1,
1855      VALUE2, ...
1856
1857      If this function is called with a first input argument OLDSTRUCT
1858      of type structure array then overwrite all values of the options
1859      "FIELD1", "FIELD2", ... of the structure OLDSTRUCT with new values
1860      VALUE1, VALUE2, ... and return the modified structure array.
1861
1862      If this function is called with two input argumnets OLDSTRUCT and
1863      NEWSTRUCT of type structure array then overwrite all values in the
1864      fields from the structure OLDSTRUCT with new values of the fields
1865      from the structure NEWSTRUCT. Empty values of NEWSTRUCT will not
1866      overwrite values in OLDSTRUCT.
1867
1868      For a detailed explanation about valid fields and field values in
1869      an OdePkg structure aaray have a look at the `odepkg.pdf', Section
1870      'ODE/DAE/IDE/DDE options' or run the command `doc odepkg' to open
1871      the tutorial.
1872
1873      Run examples with the command
1874           demo odeset
1875
1876    See also: odepkg
1877
1878
1879
1880
1881 # name: <cell-element>
1882 # type: sq_string
1883 # elements: 1
1884 # length: 80
1885 If this function is called without an input argument then return a new
1886 OdePkg op
1887
1888
1889
1890
1891