Re: LSODE speed up question

[Tatsuro MATSUOKA]

Hello

--- Ayesha Kalra <address@hidden> wrote:

> Hi Tatsuro
> I can not furnish the whole code but, here is the heart of the code which
> solves the system of equations f
> 
> //*****************************************************************
> 
>  // initialize the solver by transfering the function f
> 
>          ODEFunc odef (f);
> 
>          // initialize the solver with XS and the initial time
> 
>          // as well as the ODEFunc object ode
> 
> 
> 
>          // LSODE options to be specified ***************************
> 
>          LSODE_options ();                // should specify a stiff solver
> 
> 
>          // *********************************************************
> 
> 
> 
>          LSODE ls(XS, 0.0, odef);
> 
>          // integrate
> 
>          y = ls.do_integrate(t);
> 
> 
> 
>          // append data
> 
>          X_and_S.insert(t,0,0);
> 
>          X_and_S.insert(y,0,1);
> 
> 
> 
> //*****************************************************************


The above is general code for LSODE in C++. (I have used a similar routine by 
myself.)
So the information is not so helpful for the discussion.


> The function f is a ColumnVector of length ~300. t is a ColumnVector of
> length 500. I got the idea to solve equations using LSODE in C++ from the
> following link


The step of t is not related to LSODE speed.  
LSODE automatically detemine the integration step 
if you do not specify it at lsode options.  
The vector t is used only for store integated data.
Only t(size-1) valuse is used to determine integration range.

Please read help lsode_options.
Those are to be set for the critical problem.

Perhaps the function f is a key point.  Is your problem whether the your 
problem stiff or not?
If it is not stiff, you can set lsode option to non-stiff.  
At that case no Jacobian is used.  

In addition, f is a ColumnVector of length ~300.  The function should be 
complex.



octave:2> help lsode_options
 -- Loadable Function:  lsode_options (OPT, VAL)
     When called with two arguments, this function allows you set
     options parameters for the function `lsode'.  Given one argument,
     `lsode_options' returns the value of the corresponding option.  If
     no arguments are supplied, the names of all the available options
     and their current values are displayed.

     Options include

    `"absolute tolerance"'
          Absolute tolerance.  May be either vector or scalar.  If a
          vector, it must match the dimension of the state vector.

    `"relative tolerance"'
          Relative tolerance parameter.  Unlike the absolute tolerance,
          this parameter may only be a scalar.

          The local error test applied at each integration step is

                 abs (local error in x(i)) <= ...
                     rtol * abs (y(i)) + atol(i)

    `"integration method"'
          A string specifying the method of integration to use to solve
          the ODE system.  Valid values are

         "adams"
         "non-stiff"
               No Jacobian used (even if it is available).

         "bdf"

         "stiff"
               Use stiff backward differentiation formula (BDF) method.
               If a function to compute the Jacobian is not supplied,
               `lsode' will compute a finite difference approximation
               of the Jacobian matrix.

    `"initial step size"'
          The step size to be attempted on the first step (default is
          determined automatically).

    `"maximum order"'
          Restrict the maximum order of the solution method.  If using
          the Adams method, this option must be between 1 and 12.
          Otherwise, it must be between 1 and 5, inclusive.

    `"maximum step size"'
          Setting the maximum stepsize will avoid passing over very
          large regions  (default is not specified).

    `"minimum step size"'
          The minimum absolute step size allowed (default is 0).

    `"step limit"'
          Maximum number of steps allowed (default is 100000). 


> http://info.ee.surrey.ac.uk/Personal/M.Michel/index.php?page=4&site=4
> 
> Your inputs are welcome.
> 
> Ayesha
> 
> On Fri, Apr 25, 2008 at 5:19 PM, Tatsuro MATSUOKA <address@hidden>
> wrote:
> 
> > If you would like to use Automatic Differentiation by Analytically,
> > please use symbolic package in octave-forge.
> > http://octave.sourceforge.net/packages.html
> > and see
> > http://wiki.octave.org/wiki.pl?CategorySymbolic
> >
> > If possible, please show the your C++ code.
> > That will make more fruitful discussion possible
> >
> >
> > Regards
> >
> > Tatsuro
> > --- Ayesha Kalra <address@hidden> wrote:
> >
> > > Hi all,
> > > I am using LSODE in a C++ program to solve a system of ~300 ODEs (500
> > time
> > > steps). I used LSODE in C++ so that I could get some performance
> > enhancement
> > > over using LSODE in Octave itself, however, there was no improvement in
> > > performance (measured in time (in sec) taken to solve the system of
> > > equations. It may be noted that in both cases, I am NOT supplying the
> > > Jacobian to LSODE. Can anyone tell me what is the bottleneck step for
> > LSODE,
> > > if it is calculation of Jacobian of the system,  I will try to calculate
> > it
> > > explicitly using some kind of Automatic Differentiation library and then
> > > supply it to LSODE (I am not sure, how to do this right now, any
> > > ideas/suggestions are welcome).
> > >
> > > Or, is there anything else I need to look/change to speed up solution by
> > > LSODE in C++.
> > >
> > > Thanks
> > > Ayesha
> > > > _______________________________________________
> > > Help-octave mailing list
> > > address@hidden
> > > https://www.cae.wisc.edu/mailman/listinfo/help-octave
> > >
> >
> >
> > --------------------------------------
> > GANBARE! NIPPON! Win your ticket to Olympic Games 2008.
> > http://pr.mail.yahoo.co.jp/ganbare-nippon/
> >
> 


--------------------------------------
GANBARE! NIPPON! Win your ticket to Olympic Games 2008.
http://pr.mail.yahoo.co.jp/ganbare-nippon/