Xcos help : Proper test times and minor corrections 09/10109/8
Paul BIGNIER [Fri, 4 Jan 2013 08:34:33 +0000 (09:34 +0100)]
Now that all the solvers are merged, wrote their proper test times
Added minor corrections, notably deletion of the space before a semicolon

Change-Id: Ife33cc5cd39bdb0ebd91696a5eb6436adabff147

19 files changed:
scilab/modules/scicos/src/scicos_sundials/src/cvode/cvode.c
scilab/modules/xcos/examples/solvers/Rootfinding.sce
scilab/modules/xcos/examples/solvers/RootfindingSimple.sce
scilab/modules/xcos/examples/solvers/benchBasic.sce
scilab/modules/xcos/examples/solvers/benchKalman.sce
scilab/modules/xcos/examples/solvers/benchSinus.sce
scilab/modules/xcos/examples/solvers/integCVode.sce
scilab/modules/xcos/examples/solvers/integDoPri.sce
scilab/modules/xcos/examples/solvers/integImpRK.sce
scilab/modules/xcos/examples/solvers/integLSodar.sce
scilab/modules/xcos/examples/solvers/integRK.sce
scilab/modules/xcos/help/en_US/solvers/0-LSodar.xml
scilab/modules/xcos/help/en_US/solvers/1-CVode.xml
scilab/modules/xcos/help/en_US/solvers/2-Runge-Kutta.xml
scilab/modules/xcos/help/en_US/solvers/3-Dormand-Prince.xml
scilab/modules/xcos/help/en_US/solvers/4-ImplicitRK.xml
scilab/modules/xcos/help/en_US/solvers/7-IDA.xml
scilab/modules/xcos/help/en_US/solvers/8-Rootfinding.xml
scilab/modules/xcos/help/en_US/solvers/9-Comparisons.xml

index 7c7285f..1df1106 100644 (file)
@@ -338,7 +338,7 @@ void *CVodeCreate(int lmm, int iter)
 
   /* Test inputs */
 
-  if ((lmm != CV_ADAMS) && (lmm != CV_BDF) && (lmm != CV_DOPRI) && (lmm != CV_ExpRK) && (lmm != CV_ImpRK)) { /* Integration mode : ADAMS, BDF or RK-based */
+  if ((lmm != CV_ADAMS) && (lmm != CV_BDF) && (lmm != CV_DOPRI) && (lmm != CV_ExpRK) && (lmm != CV_ImpRK)) { /* Integration mode: ADAMS, BDF or RK-based */
     CVProcessError(NULL, 0, "CVODE", "CVodeCreate", MSGCV_BAD_LMM);
     return(NULL);
   }
@@ -2516,7 +2516,7 @@ static int CVStepDoPri(CVodeMem cv_mem)
  * CVStepExpRK
  *
  * This routine performs one internal cvode step using the Runge-Kutta 4(5) method, from tn to tn + h.
- * Proceed to :
+ * Proceed to:
  * - K1 = F(Tn, Yn),
  * - K2 = F(Tn + h/2, Yn + (h/2)*K1),
  * - K3 = F(Tn + h/2, Yn + (h/2)*K2),
@@ -2641,8 +2641,8 @@ static int CVStepImpRK(CVodeMem cv_mem)
     difference = N_VMaxNorm(ftemp);                    /* max = Max(ABS(ftemp)), */
     if (difference < reltol) {  /* Converged */
       tn += h;                               /* Increment tn, */
-      N_VScale (ONE, y, zn[0]);              /* Update Nordsziek array : - zn[0] = Yn+1, */
-      retval = f(tn, zn[0], zn[1], f_data);  /*                                                        - zn[1] = Y'(tn), */
+      N_VScale (ONE, y, zn[0]);              /* Update Nordsziek array: - zn[0] = Yn+1, */
+      retval = f(tn, zn[0], zn[1], f_data);  /*                         - zn[1] = Y'(tn), */
       N_VScale (h, zn[1], zn[1]);            /* Scale zn[1] by h */
       return (CV_SUCCESS);
     }
@@ -2651,7 +2651,7 @@ static int CVStepImpRK(CVodeMem cv_mem)
       nb_iter++;
     }
   }
-  /* End of while : maxiter attained, we consider that the algorithm has diverged */
+  /* End of while: maxiter attained, we consider that the algorithm has diverged */
   return (CONV_FAIL);
 }
 
index b08bea9..958ec63 100644 (file)
@@ -20,7 +20,7 @@ scs_m.props.tol(6) = 0;
 tic();
 try scicos_simulate(scs_m, 'nw'); catch disp(lasterror()); end
 t = toc();
-disp(t, "Time with rootfinding :");
+disp(t, "Time with rootfinding:");
 
 // Import the "without-ZC" diagram and augment the ending time
 importXcosDiagram("SCI/modules/xcos/examples/solvers/without_ZeroCrossing.xcos");
@@ -35,4 +35,4 @@ scs_m.props.tol(6) = 0;
 tic();
 try scicos_simulate(scs_m, 'nw'); catch disp(lasterror()); end
 t = toc();
-disp(t, "Time without rootfinding :");
+disp(t, "Time without rootfinding:");
index 2cf3c12..758e9ed 100644 (file)
@@ -20,7 +20,7 @@ scs_m.props.tol(6) = 0;
 tic();
 try scicos_simulate(scs_m, 'nw'); catch disp(lasterror()); end
 t = toc();
-disp(t, "Time with rootfinding :");
+disp(t, "Time with rootfinding:");
 
 // Import the "without-ZC" diagram and augment the ending time
 importXcosDiagram("SCI/modules/xcos/examples/solvers/without_ZeroCrossingSimple.xcos");
@@ -35,4 +35,4 @@ scs_m.props.tol(6) = 0;
 tic();
 try scicos_simulate(scs_m, 'nw'); catch disp(lasterror()); end
 t = toc();
-disp(t, "Time without rootfinding :");
+disp(t, "Time without rootfinding:");
index 7832156..ab69553 100644 (file)
@@ -21,7 +21,7 @@ solverName = ["LSodar", "CVode BDF/Newton", "CVode BDF/Functional", "CVode Adams
 disp("--------------------------------");
 for solver = 0:7
 
- disp("Time for " + solverName(solver + 1) + " :");
+ disp("Time for " + solverName(solver + 1) + ":");
  tolerances(6) = solver;
 
  // Modify 'Max step size' if RK-based solver
index ccc151c..391c92f 100644 (file)
@@ -21,7 +21,7 @@ solverName = ["LSodar", "CVode BDF/Newton", "CVode BDF/Functional", "CVode Adams
 disp("--------------------------------");
 for solver = 0:7
 
- disp("Time for " + solverName(solver + 1) + " :");
+ disp("Time for " + solverName(solver + 1) + ":");
  tolerances(6) = solver;
 
  // Modify 'Max step size' if RK-based solver
index 7008b0a..0d672db 100644 (file)
@@ -19,7 +19,7 @@ solverName = ["LSodar", "CVode BDF/Newton", "CVode BDF/Functional", "CVode Adams
 disp("--------------------------------");
 for solver = 0:7
 
- disp("Time for " + solverName(solver + 1) + " :");
+ disp("Time for " + solverName(solver + 1) + ":");
  tolerances(6) = solver;
 
  // Modify 'Max step size' if RK-based solver
index 7846ac8..eb3db91 100644 (file)
@@ -22,6 +22,6 @@ for solver=1:4
  tic();
  try scicos_simulate(scs_m, 'nw'); catch disp(lasterror()); end;
  t = toc();
- disp(t, "Time for " + solverName(solver) + " :");
+ disp(t, "Time for " + solverName(solver) + ":");
 
 end
index 9000bea..1227c04 100644 (file)
@@ -25,6 +25,6 @@ for solver=1:5
  tic();
  try scicos_simulate(scs_m, 'nw'); catch disp(lasterror()); end;
  t = toc();
- disp(t, "Time for " + solverName(solver) + " :");
+ disp(t, "Time for " + solverName(solver) + ":");
 
 end
index b7e69b3..c8e7865 100644 (file)
@@ -26,6 +26,6 @@ for solver=1:5
  tic();
  try scicos_simulate(scs_m, 'nw'); catch disp(lasterror()); end
  t = toc();
- disp(t, "Time for " + solverName(solver) + " :");
+ disp(t, "Time for " + solverName(solver) + ":");
 
 end
index 7540722..6334656 100644 (file)
@@ -22,6 +22,6 @@ for solver = 0:4
  tic();
  try scicos_simulate(scs_m, 'nw'); catch disp(lasterror()); end;
  t = toc();
- disp(t, "Time for " + solverName(solver+1) + " :");
+ disp(t, "Time for " + solverName(solver+1) + ":");
 
 end
index 3c2c768..679ae72 100644 (file)
@@ -26,6 +26,6 @@ for solver=1:5
  tic();
  try scicos_simulate(scs_m, 'nw'); catch disp(lasterror()); end
  t = toc();
- disp(t, "Time for " + solverName(solver) + " :");
+ disp(t, "Time for " + solverName(solver) + ":");
 
 end
index bd210c7..0bf29fe 100644 (file)
@@ -19,7 +19,7 @@
     <refsection>
         <title>Description</title>
         <para>
-            Called by <link linkend="xcos">xcos</link>, <emphasis>LSodar</emphasis> (short for Livermore Solver for Ordinary Differential equations, with Automatic method switching for stiff and nonstiff problems, and with Root-finding) is a numerical solver providing an efficient and stable variable-size step method to solve Initial Value Problems of the form :
+            Called by <link linkend="xcos">xcos</link>, <emphasis>LSodar</emphasis> (short for Livermore Solver for Ordinary Differential equations, with Automatic method switching for stiff and nonstiff problems, and with Root-finding) is a numerical solver providing an efficient and stable variable-size step method to solve Initial Value Problems of the form:
         </para>
         <para>
             <latex>
@@ -29,7 +29,7 @@
             </latex>
         </para>
         <para>
-            LSodar is similar to <emphasis>CVode</emphasis> in many ways :
+            LSodar is similar to <emphasis>CVode</emphasis> in many ways:
             <itemizedlist>
                 <listitem>
                     It uses variable-size steps,
@@ -93,7 +93,7 @@ try xcos_simulate(scs_m, 4); catch disp(lasterror()); end
 ]]></scilab:image>
         </para>
         <para>
-            The integral block returns its continuous state, we can evaluate it with LSodar by running the example :
+            The integral block returns its continuous state, we can evaluate it with <emphasis>LSodar</emphasis> by running the example:
         </para>
         <para>
             <programlisting language="example"><![CDATA[
@@ -110,42 +110,42 @@ try xcos_simulate(scs_m, 4); catch disp(lasterror()); end
       tic();
       try xcos_simulate(scs_m, 4); catch disp(lasterror()); end
       t = toc();
-      disp(t, "Time for LSodar :");
+      disp(t, "Time for LSodar:");
       ]]></programlisting>
         </para>
         <para>
-            The Scilab console displays :
+            The Scilab console displays:
             <screen><![CDATA[
-Time for LSodar :
- 16.836
+Time for LSodar:
+ 9.546
             ]]></screen>
         </para>
         <para>
-            Now, in the following script, we compare the time difference between the methods by running the example with the five solvers in turn :
+            Now, in the following script, we compare the time difference between <emphasis>LSodar</emphasis> and <emphasis>CVode</emphasis> by running the example with the five solvers in turn:
             <link type="scilab" linkend ="scilab.scinotes/xcos/examples/solvers/integLSodar.sce">
                 Open the script
             </link>
         </para>
         <para>
             <screen><![CDATA[
-Time for LSodar :
+Time for LSodar:
  6.115
 
-Time for BDF / Newton :
- 19.894
+Time for BDF / Newton:
+ 18.894
 
-Time for BDF / Functional :
- 19.382
+Time for BDF / Functional:
+ 18.382
 
-Time for Adams / Newton :
- 11.255
+Time for Adams / Newton:
+ 10.368
 
-Time for Adams / Functional :
- 10.233
+Time for Adams / Functional:
+ 9.815
             ]]></screen>
         </para>
         <para>
-            These results show that on a nonstiff problem, for the same precision required, LSodar is significantly faster. Other tests prove the proximity of the results. Indeed, we find that the solution difference order between LSodar and CVode is close to the order of the highest tolerance ( 
+            These results show that on a nonstiff problem, for the same precision required, <emphasis>LSodar</emphasis> is significantly faster. Other tests prove the proximity of the results. Indeed, we find that the solution difference order between <emphasis>LSodar</emphasis> and <emphasis>CVode</emphasis> is close to the order of the highest tolerance ( 
             <emphasis>
                 y<subscript>lsodar</subscript> - y<subscript>cvode</subscript>
             </emphasis>
index 98fe8be..b60428b 100644 (file)
@@ -19,7 +19,7 @@
     <refsection>
         <title>Description</title>
         <para>
-            Called by <link linkend="xcos">xcos</link>, <emphasis>CVode</emphasis> (short for C-language Variable-coefficients ODE solver) is a numerical solver providing an efficient and stable method to solve Initial Value Problems of the form :
+            Called by <link linkend="xcos">xcos</link>, <emphasis>CVode</emphasis> (short for C-language Variable-coefficients ODE solver) is a numerical solver providing an efficient and stable method to solve Initial Value Problems of the form:
         </para>
         <para>
             <latex>
@@ -37,7 +37,7 @@
             <emphasis>
                 y<subscript>n+1</subscript>
             </emphasis>
-            with the formula :
+            with the formula:
         </para>
         <para>
             <latex>
             .
         </para>
         <para>
-            This is where the difference between <emphasis>BDF</emphasis> and <emphasis>Adams</emphasis> intervenes (<emphasis>Backward Differenciation Formula</emphasis> and <emphasis>Adams-Moulton formula</emphasis>) :
+            This is where the difference between <emphasis>BDF</emphasis> and <emphasis>Adams</emphasis> intervenes (<emphasis>Backward Differentiation Formula</emphasis> and <emphasis>Adams-Moulton formula</emphasis>):
         </para>
         <para>
             <caution>
-                If the problem is stiff, the user should select <emphasis>BDF</emphasis> :
+                If the problem is stiff, the user should select <emphasis>BDF</emphasis>:
             </caution>
         </para>
         <itemizedlist>
@@ -89,7 +89,7 @@
             </listitem>
         </itemizedlist>
         <para>
-            In the case of nonstiffness, <emphasis>Adams</emphasis> is preferred :
+            In the case of nonstiffness, <emphasis>Adams</emphasis> is preferred:
         </para>
         <itemizedlist>
             <listitem>
             .
         </para>
         <para>
-            For either choice and at each step, injecting this integration in <emphasis>(1)</emphasis> yields the nonlinear system :
+            For either choice and at each step, injecting this integration in <emphasis>(1)</emphasis> yields the nonlinear system:
         </para>
         <para>
             <latex>
         <itemizedlist>
             <para>  </para>
             <listitem>
-                <emphasis role="bold">Functional :</emphasis> this method only involves evaluations of <emphasis>f</emphasis>, it simply computes 
+                <emphasis role="bold">Functional:</emphasis> this method only involves evaluations of <emphasis>f</emphasis>, it simply computes 
                 <emphasis>
                     y<subscript>n(0)</subscript>
                 </emphasis>
-                by iterating the formula :
+                by iterating the formula:
                 <para>
                     <latex>
                         y_{n(m+1)} = h_n &#x3B2;_{n,0} f(t_n,y_{n(m+1)}) + a_n
             </listitem>
             <para>  </para>
             <listitem>
-                <emphasis role="bold">Newton :</emphasis> here, we use an implemented direct dense solver on the linear system :
+                <emphasis role="bold">Newton:</emphasis> here, we use an implemented direct dense solver on the linear system:
                 <para>
                     <latex>
                         M[y_{n(m+1)}-y_{n(m)}]=-G(y_{n(m)}), \hspace{4 mm} M \approx I-\gamma J, \hspace{2 mm} J=\frac{\partial f}{\partial y}, \hspace{2 mm} and \hspace{2 mm} \gamma = h_n\beta_{n,0}
@@ -196,7 +196,7 @@ try xcos_simulate(scs_m, 4); catch disp(lasterror()); end
 ]]></scilab:image>
         </para>
         <para>
-            The integral block returns its continuous state, we can evaluate it with BDF / Newton by running the example :
+            The integral block returns its continuous state, we can evaluate it with <emphasis>BDF / Newton</emphasis> by running the example:
         </para>
         <para>
             <programlisting language="example"><![CDATA[
@@ -213,40 +213,40 @@ try xcos_simulate(scs_m, 4); catch disp(lasterror()); end
       tic();
       try xcos_simulate(scs_m, 4); catch disp(lasterror()); end
       t = toc();
-      disp(t, "Time for BDF / Newton :");
+      disp(t, "Time for BDF / Newton:");
       ]]></programlisting>
         </para>
         <para>
-            The Scilab console displays :
+            The Scilab console displays:
             <screen><![CDATA[
-Time for BDF / Newton :
- 19.454
+Time for BDF / Newton:
+ 13.438
             ]]></screen>
         </para>
         <para>
-            Now, in the following script, we compare the time difference between the methods by running the example with the four solvers in turn :
+            Now, in the following script, we compare the time difference between the methods by running the example with the four solvers in turn:
             <link type="scilab" linkend ="scilab.scinotes/xcos/examples/solvers/integCVode.sce">
                 Open the script
             </link>
         </para>
         <para>
-            Results :
+            Results:
             <screen language="example"><![CDATA[
-Time for BDF / Newton :
- 19.894
+Time for BDF / Newton:
+ 18.894
 
-Time for BDF / Functional :
- 19.382
+Time for BDF / Functional:
+ 18.382
 
-Time for Adams / Newton :
- 11.255
+Time for Adams / Newton:
+ 10.368
 
-Time for Adams / Functional :
- 10.233
+Time for Adams / Functional:
+ 9.815
             ]]></screen>
         </para>
         <para>
-            The results show that for a simple nonstiff continuous problem, Adams / Functional is fastest.
+            The results show that for a simple nonstiff continuous problem, <emphasis>Adams / Functional</emphasis> is fastest.
         </para>
     </refsection>
     <refsection>
index 4b1a9db..6418bca 100644 (file)
@@ -19,7 +19,7 @@
     <refsection>
         <title>Description</title>
         <para>
-            Called by <link linkend="xcos">xcos</link>, <emphasis>Runge-Kutta</emphasis> is a numerical solver providing an efficient fixed-size step method to solve Initial Value Problems of the form :
+            Called by <link linkend="xcos">xcos</link>, <emphasis>Runge-Kutta</emphasis> is a numerical solver providing an efficient fixed-size step method to solve Initial Value Problems of the form:
         </para>
         <para>
             <latex>
@@ -32,7 +32,7 @@
             <emphasis>CVode</emphasis> and <emphasis>IDA</emphasis> use variable-size steps for the integration.
         </para>
         <para>
-            A drawback of that is the unpredictable computation time. With Runge-Kutta, we do not adapt to the complexity of the problem, but we guarantee a stable computation time.
+            A drawback of that is the unpredictable computation time. With <emphasis>Runge-Kutta</emphasis>, we do not adapt to the complexity of the problem, but we guarantee a stable computation time.
         </para>
         <para>
             As of now, this method is explicit, so it is not concerned with Newton or Functional iterations, and not advised for stiff problems.
             By convention, to use fixed-size steps, the program first computes a fitting <emphasis>h</emphasis> that approaches the simulation parameter <link linkend="Simulatemenu_Menu_entries">max step size</link>.
         </para>
         <para>
-            An important difference of Runge-Kutta with the previous methods is that it computes up to the fourth derivative of <emphasis>y</emphasis>, while the others only use linear combinations of <emphasis>y</emphasis> and <emphasis>y'</emphasis>.
+            An important difference of <emphasis>Runge-Kutta</emphasis> with the previous methods is that it computes up to the fourth derivative of <emphasis>y</emphasis>, while the others only use linear combinations of <emphasis>y</emphasis> and <emphasis>y'</emphasis>.
         </para>
         <para>
             Here, the next value is determined by the present value 
             <emphasis>
                 y<subscript>n</subscript>
             </emphasis>
-            plus the weighted average of four increments, where each increment is the product of the size of the interval, <emphasis>h</emphasis>, and an estimated slope specified by the function <emphasis>f(t,y)</emphasis> :
+            plus the weighted average of four increments, where each increment is the product of the size of the interval, <emphasis>h</emphasis>, and an estimated slope specified by the function <emphasis>f(t,y)</emphasis>:
             <itemizedlist>
                 <listitem>
                     <emphasis>k1</emphasis> is the increment based on the slope at the beginning of the interval, using 
@@ -153,7 +153,7 @@ try xcos_simulate(scs_m, 4); catch disp(lasterror()); end
 ]]></scilab:image>
         </para>
         <para>
-            The integral block returns its continuous state, we can evaluate it with Runge-Kutta by running the example :
+            The integral block returns its continuous state, we can evaluate it with <emphasis>Runge-Kutta</emphasis> by running the example:
         </para>
         <para>
             <programlisting language="example"><![CDATA[
@@ -171,42 +171,42 @@ try xcos_simulate(scs_m, 4); catch disp(lasterror()); end
       tic();
       try xcos_simulate(scs_m, 4); catch disp(lasterror()); end
       t = toc();
-      disp(t, "Time for Runge-Kutta :");
+      disp(t, "Time for Runge-Kutta:");
       ]]></programlisting>
         </para>
         <para>
-            The Scilab console displays :
+            The Scilab console displays:
             <screen><![CDATA[
-Time for Runge-Kutta :
- 15.624
+Time for Runge-Kutta:
+ 8.906
             ]]></screen>
         </para>
         <para>
-            Now, in the following script, we compare the time difference between Runge-Kutta and Sundials by running the example with the five solvers in turn :
+            Now, in the following script, we compare the time difference between <emphasis>Runge-Kutta</emphasis> and <emphasis>CVode</emphasis> by running the example with the five solvers in turn:
             <link type="scilab" linkend ="scilab.scinotes/xcos/examples/solvers/integRK.sce">
                 Open the script
             </link>
         </para>
         <para>
             <screen><![CDATA[
-Time for BDF / Newton :
- 19.894
+Time for BDF / Newton:
+ 18.894
 
-Time for BDF / Functional :
- 19.382
+Time for BDF / Functional:
+ 18.382
 
-Time for Adams / Newton :
- 11.255
+Time for Adams / Newton:
+ 10.368
 
-Time for Adams / Functional :
- 10.233
+Time for Adams / Functional:
+ 9.815
 
-Time for Runge-Kutta :
- 5.502
+Time for Runge-Kutta:
+ 4.743
             ]]></screen>
         </para>
         <para>
-            These results show that on a nonstiff problem, for relatively same precision required and forcing the same step size, Runge-Kutta is faster.
+            These results show that on a nonstiff problem, for relatively same precision required and forcing the same step size, <emphasis>Runge-Kutta</emphasis> is faster.
         </para>
         <para>
             Variable-size step ODE solvers are not appropriate for deterministic real-time applications because the computational overhead of taking a time step varies over the course of an application.
index 93ff5b5..3c3a418 100644 (file)
@@ -19,7 +19,7 @@
     <refsection>
         <title>Description</title>
         <para>
-            Called by <link linkend="xcos">xcos</link>, <emphasis>Dormand-Prince</emphasis> is a numerical solver providing an efficient fixed-size step method to solve Initial Value Problems of the form :
+            Called by <link linkend="xcos">xcos</link>, <emphasis>Dormand-Prince</emphasis> is a numerical solver providing an efficient fixed-size step method to solve Initial Value Problems of the form:
         </para>
         <para>
             <latex>
@@ -32,7 +32,7 @@
             <emphasis>CVode</emphasis> and <emphasis>IDA</emphasis> use variable-size steps for the integration.
         </para>
         <para>
-            A drawback of that is the unpredictable computation time. With Dormand-Prince, we do not adapt to the complexity of the problem, but we guarantee a stable computation time.
+            A drawback of that is the unpredictable computation time. With <emphasis>Dormand-Prince</emphasis>, we do not adapt to the complexity of the problem, but we guarantee a stable computation time.
         </para>
         <para>
             As of now, this method is explicit, so it is not concerned with Newton or Functional iterations, and not advised for stiff problems.
             By convention, to use fixed-size steps, the program first computes a fitting <emphasis>h</emphasis> that approaches the simulation parameter <link linkend="Simulatemenu_Menu_entries">max step size</link>.
         </para>
         <para>
-            An important difference of Dormand-Prince with the previous methods is that it computes up to the seventh derivative of <emphasis>y</emphasis>, while the others only use linear combinations of <emphasis>y</emphasis> and <emphasis>y'</emphasis>.
+            An important difference of <emphasis>Dormand-Prince</emphasis> with the previous methods is that it computes up to the seventh derivative of <emphasis>y</emphasis>, while the others only use linear combinations of <emphasis>y</emphasis> and <emphasis>y'</emphasis>.
         </para>
         <para>
             Here, the next value is determined by the present value 
             <emphasis>
                 y<subscript>n</subscript>
             </emphasis>
-            plus the weighted average of six increments, where each increment is the product of the size of the interval, <emphasis>h</emphasis>, and an estimated slope specified by the function <emphasis>f(t,y)</emphasis> :
+            plus the weighted average of six increments, where each increment is the product of the size of the interval, <emphasis>h</emphasis>, and an estimated slope specified by the function <emphasis>f(t,y)</emphasis>:
             <itemizedlist>
                 <listitem>
                     <emphasis>k1</emphasis> is the increment based on the slope at the beginning of the interval, using 
@@ -95,7 +95,7 @@
             .
         </para>
         <para>
-            That error analysis baptized the method <emphasis>Dormand-Prince 4(5)</emphasis> : 
+            That error analysis baptized the method <emphasis>Dormand-Prince 4(5)</emphasis>: 
             <emphasis>
                 O(h<superscript>5</superscript>)
             </emphasis>
@@ -137,7 +137,7 @@ try xcos_simulate(scs_m, 4); catch disp(lasterror()); end
 ]]></scilab:image>
         </para>
         <para>
-            The integral block returns its continuous state, we can evaluate it with Dormand-Prince by running the example :
+            The integral block returns its continuous state, we can evaluate it with <emphasis>Dormand-Prince</emphasis> by running the example:
         </para>
         <para>
             <programlisting language="example"><![CDATA[
@@ -155,42 +155,42 @@ try xcos_simulate(scs_m, 4); catch disp(lasterror()); end
       tic();
       try xcos_simulate(scs_m, 4); catch disp(lasterror()); end
       t = toc();
-      disp(t, "Time for Dormand-Prince :");
+      disp(t, "Time for Dormand-Prince:");
       ]]></programlisting>
         </para>
         <para>
-            The Scilab console displays :
+            The Scilab console displays:
             <screen><![CDATA[
-Time for Dormand-Prince :
- 17.226
+Time for Dormand-Prince:
+ 9.197
             ]]></screen>
         </para>
         <para>
-            Now, in the following script, we compare the time difference between Dormand-Prince and Sundials by running the example with the five solvers in turn :
+            Now, in the following script, we compare the time difference between <emphasis>Dormand-Prince</emphasis> and <emphasis>CVode</emphasis> by running the example with the five solvers in turn:
             <link type="scilab" linkend ="scilab.scinotes/xcos/examples/solvers/integDoPri.sce">
                 Open the script
             </link>
         </para>
         <para>
             <screen><![CDATA[
-Time for BDF / Newton :
- 19.894
+Time for BDF / Newton:
+ 18.894
 
-Time for BDF / Functional :
- 19.382
+Time for BDF / Functional:
+ 18.382
 
-Time for Adams / Newton :
- 11.255
+Time for Adams / Newton:
+ 10.368
 
-Time for Adams / Functional :
- 10.233
+Time for Adams / Functional:
+ 9.815
 
-Time for DoPri :
- 8.654
+Time for Dormand-Prince:
+ 7.842
             ]]></screen>
         </para>
         <para>
-            These results show that on a nonstiff problem, for relatively same precision required and forcing the same step size, Dormand-Prince's computational overhead (compared to Runge-Kutta) is significant and is close to <emphasis>Adams/Functional</emphasis>. Its error to the solution is althought much smaller than the regular Runge-Kutta 4(5), for a small overhead in time.
+            These results show that on a nonstiff problem, for relatively same precision required and forcing the same step size, <emphasis>Dormand-Prince</emphasis>'s computational overhead (compared to <emphasis>Runge-Kutta</emphasis>) is significant and is close to <emphasis>Adams/Functional</emphasis>. Its error to the solution is althought much smaller than the regular <emphasis>Runge-Kutta 4(5)</emphasis>, for a small overhead in time.
         </para>
         <para>
             Variable-size step ODE solvers are not appropriate for deterministic real-time applications because the computational overhead of taking a time step varies over the course of an application.
index 1be9c79..c66188c 100644 (file)
     <refnamediv>
         <refname>Implicit Runge-Kutta 4(5)</refname>
         <refpurpose>
-            Runge-Kutta is a numerical solver providing an efficient and stable implicit method to solve Ordinary Differential Equations (ODEs) Initial Value Problems. Called by <link linkend="xcos">xcos</link>.
+            <emphasis>Implicit Runge-Kutta</emphasis> is a numerical solver providing an efficient and stable implicit method to solve Ordinary Differential Equations (ODEs) Initial Value Problems. Called by <link linkend="xcos">xcos</link>.
         </refpurpose>
     </refnamediv>
     <refsection>
         <title>Description</title>
         <para>
-            Runge-Kutta is a numerical solver providing an efficient and stable fixed-size step method to solve Initial Value Problems of the form :
+            <emphasis>Runge-Kutta</emphasis> is a numerical solver providing an efficient and stable fixed-size step method to solve Initial Value Problems of the form:
         </para>
         <para>
             <latex>
@@ -32,7 +32,7 @@
             <emphasis>CVode</emphasis> and <emphasis>IDA</emphasis> use variable-size steps for the integration.
         </para>
         <para>
-            A drawback of that is the unpredictable computation time. With Runge-Kutta, we do not adapt to the complexity of the problem, but we guarantee a stable computation time.
+            A drawback of that is the unpredictable computation time. With <emphasis>Runge-Kutta</emphasis>, we do not adapt to the complexity of the problem, but we guarantee a stable computation time.
         </para>
         <para>
             This method being explicit, it can be used on stiff problems.
@@ -55,7 +55,7 @@
             By convention, to use fixed-size steps, the program first computes a fitting <emphasis>h</emphasis> that approaches the simulation parameter <link linkend="Simulatemenu_Menu_entries">max step size</link>.
         </para>
         <para>
-            An important difference of implicit Runge-Kutta with the previous methods is that it computes up to the fourth derivative of <emphasis>y</emphasis>, while the others mainly use linear combinations of <emphasis>y</emphasis> and <emphasis>y'</emphasis>.
+            An important difference of <emphasis>implicit Runge-Kutta</emphasis> with the previous methods is that it computes up to the fourth derivative of <emphasis>y</emphasis>, while the others mainly use linear combinations of <emphasis>y</emphasis> and <emphasis>y'</emphasis>.
         </para>
         <para>
             Here, the next value is determined by the present value 
             .
         </para>
         <para>
-            That error analysis baptized the method <emphasis>implicit Runge-Kutta 4(5)</emphasis> : 
+            That error analysis baptized the method <emphasis>implicit Runge-Kutta 4(5)</emphasis>: 
             <emphasis>
                 O(h<superscript>5</superscript>)
             </emphasis>
@@ -195,7 +195,7 @@ try xcos_simulate(scs_m, 4); catch disp(lasterror()); end
 ]]></scilab:image>
         </para>
         <para>
-            The integral block returns its continuous state, we can evaluate it with Runge-Kutta by running the example :
+            The integral block returns its continuous state, we can evaluate it with <emphasis>implicit RK</emphasis> by running the example:
         </para>
         <para>
             <programlisting language="example"><![CDATA[
@@ -214,42 +214,42 @@ try xcos_simulate(scs_m, 4); catch disp(lasterror()); end
       tic();
       try xcos_simulate(scs_m, 4); catch disp(lasterror()); end
       t = toc();
-      disp(t, "Time for implicit Runge-Kutta :");
+      disp(t, "Time for implicit Runge-Kutta:");
       ]]></programlisting>
         </para>
         <para>
-            The Scilab console displays :
+            The Scilab console displays:
             <screen><![CDATA[
-Time for implicit Runge-Kutta :
- 17.003
+Time for implicit Runge-Kutta:
+ 8.911
             ]]></screen>
         </para>
         <para>
-            Now, in the following script, we compare the time difference between implicit RK and CVode by running the example with the five solvers in turn :
+            Now, in the following script, we compare the time difference between <emphasis>implicit RK</emphasis> and <emphasis>CVode</emphasis> by running the example with the five solvers in turn:
             <link type="scilab" linkend ="scilab.scinotes/xcos/examples/solvers/integImpRK.sce">
                 Open the script
             </link>
         </para>
         <para>
             <screen><![CDATA[
-Time for BDF / Newton :
- 19.894
+Time for BDF / Newton:
+ 18.894
 
-Time for BDF / Functional :
- 19.382
+Time for BDF / Functional:
+ 18.382
 
-Time for Adams / Newton :
- 11.255
+Time for Adams / Newton:
+ 10.368
 
-Time for Adams / Functional :
- 10.233
+Time for Adams / Functional:
+ 9.815
 
-Time for implicit Runge-Kutta :
- 8.112
+Time for implicit Runge-Kutta:
+ 6.652
             ]]></screen>
         </para>
         <para>
-            These results show that on a nonstiff problem, for relatively same precision required and forcing the same step size, implicit Runge-Kutta competes with Adams / Functional.
+            These results show that on a nonstiff problem, for relatively same precision required and forcing the same step size, <emphasis>implicit Runge-Kutta</emphasis> competes with <emphasis>Adams / Functional</emphasis>.
         </para>
         <para>
             Variable-size step ODE solvers are not appropriate for deterministic real-time applications because the computational overhead of taking a time step varies over the course of an application.
index 4f96b2d..11ccb4a 100644 (file)
@@ -19,7 +19,7 @@
     <refsection>
         <title>Description</title>
         <para>
-            Called by <link linkend="xcos">xcos</link>, <emphasis>IDA</emphasis> (short for Implicit Differential Algebraic solver) is a numerical solver providing an efficient and stable method to solve Initial Value Problems of the form :
+            Called by <link linkend="xcos">xcos</link>, <emphasis>IDA</emphasis> (short for Implicit Differential Algebraic solver) is a numerical solver providing an efficient and stable method to solve Initial Value Problems of the form:
         </para>
         <para>
             <latex>
@@ -52,7 +52,7 @@
             <emphasis>
                 y<subscript>n+1</subscript>
             </emphasis>
-            with the <emphasis>BDF</emphasis> formula :
+            with the <emphasis>BDF</emphasis> formula:
         </para>
         <para>
             <latex>
@@ -81,7 +81,7 @@
             </para>
         </para>
         <para>
-            Injecting this formula in <emphasis>(1)</emphasis> yields the system :
+            Injecting this formula in <emphasis>(1)</emphasis> yields the system:
         </para>
         <para>
             <latex>
@@ -89,7 +89,7 @@
             </latex>
         </para>
         <para>
-            To apply <emphasis>Newton</emphasis> iterations to it, we rewrite it into :
+            To apply <emphasis>Newton</emphasis> iterations to it, we rewrite it into:
         </para>
         <para>
             <latex>
@@ -97,7 +97,7 @@
             </latex>
         </para>
         <para>
-            &#160; with <emphasis>J</emphasis> an approximation of the Jacobian :
+            &#160; with <emphasis>J</emphasis> an approximation of the Jacobian:
         </para>
         <para>
             &#160; <latex>
     <refsection id="Example_IDA">
         <title>Example</title>
         <para>
-            The 'Modelica Generic' block returns its continuous states, we can evaluate them with IDA by running the example :
+            The 'Modelica Generic' block returns its continuous states, we can evaluate them with <emphasis>IDA</emphasis> by running the example:
         </para>
         <para>
             <link type="scilab" linkend="scilab.xcos/xcos/examples/solvers/IDA_Example.xcos">
index 0ccb8aa..ff9ab51 100644 (file)
@@ -37,7 +37,7 @@
             <emphasis>
                 [t<subscript>lo</subscript>, t<subscript>hi</subscript>]
             </emphasis>
-            .A loop is entered to locate the
+            . A loop is entered to locate the
             root to within a rather tight tolerance, given by the <emphasis>unit roudoff</emphasis>, the <emphasis>current time</emphasis> and the <emphasis>step size</emphasis>.
         </para>
         <para>
@@ -77,7 +77,7 @@ try xcos_simulate(scs_m, 4); catch disp(lasterror()); end
 ]]></scilab:image>
         </para>
         <para>
-            Simple example of a Sinus crossing zero several times :
+            Simple example of a Sinus crossing zero several times:
         </para>
         <para>
             <programlisting language="example"><![CDATA[
@@ -90,42 +90,42 @@ try xcos_simulate(scs_m, 4); catch disp(lasterror()); end
       tic();
       try xcos_simulate(scs_m, 4); catch disp(lasterror()); end
       t = toc();
-      disp(t, "Time for LSodar :");
+      disp(t, "Time for LSodar:");
       ]]></programlisting>
         </para>
         <para>
             The blue bars represent the "positive to negative" zero crossings, while the red ones are for "negative to positive".
         </para>
         <para>
-            Now, in the two following scripts, we test the computational overhead of the rootfinding with <emphasis>LSodar</emphasis> :
+            Now, in the two following scripts, we test the computational overhead of the rootfinding with <emphasis>LSodar</emphasis>:
         </para>
         <para>
-            First, a Sinus that crosses zero every &#928; period :
+            First, a Sinus that crosses zero every &#960; period:
             <link type="scilab" linkend ="scilab.scinotes/xcos/examples/solvers/Rootfinding.sce">
                 Open the script
             </link>
         </para>
         <para>
             <screen><![CDATA[
-Time with rootfinding :
+Time with rootfinding:
  15.021
 
-Time without rootfinding :
+Time without rootfinding:
  10.573
             ]]></screen>
         </para>
         <para>
-            Then, a simple straight line that crosses zero only once, in the middle of the interval :
+            Then, a simple straight line that crosses zero only once, in the middle of the interval:
             <link type="scilab" linkend ="scilab.scinotes/xcos/examples/solvers/RootfindingSimple.sce">
                 Open the script
             </link>
         </para>
         <para>
             <screen><![CDATA[
-Time with rootfinding :
+Time with rootfinding:
  0.114
 
-Time without rootfinding :
+Time without rootfinding:
  0.09
             ]]></screen>
         </para>
index c065a81..862459d 100644 (file)
         </para>
         <title>Variable-size and Fixed-size</title>
         <para>
-            The solvers can be divided into two distinct main families : the <emphasis>Variable</emphasis>-size and the <emphasis>Fixed</emphasis>-size step methods.
+            The solvers can be divided into two distinct main families: the <emphasis>Variable</emphasis>-size and the <emphasis>Fixed</emphasis>-size step methods.
         </para>
         <para>
             They both compute the next simulation time as the sum of the current simulation time and a quantity known as the step size, which is constant in the Fixed-size solvers and can change in the Variable-size ones, depending on the model dynamics and the input <link linkend="Simulatemenu_Menu_entries">tolerances</link>.
         </para>
         <para>
-            If looking for stable computation time, the user should select a Fixed-size step solver, because the computation overhead for a Variable-size step method cannot be properly foreseen.
+            If looking for stable computation time, the user should select a Fixed-size step solver, because the computation overhead for a Variable-size step method cannot be properly predicted.
         </para>
         <para>
             Although for a simple problem (or loose tolerances) a Variable-size solver can significantly improve the simulation time by computing bigger step sizes, a Fixed-size method is preferable if the ideal step size is known and roughly constant (the user should then mention it in <link linkend="Simulatemenu_Menu_entries">max step size</link>).
                     <td> Implicit Runge-Kutta </td>
                 </tr>
             </informaltable>-->
-            <emphasis role="bold">Variable</emphasis>-size step solvers :
+            <emphasis role="bold">Variable</emphasis>-size step solvers:
             <simplelist>
                 <member>LSodar</member>
                 <member>CVode</member>
                 <member>IDA</member>
             </simplelist>
-            <emphasis role="bold">Fixed</emphasis>-size step solvers :
+            <emphasis role="bold">Fixed</emphasis>-size step solvers:
             <simplelist>
                 <member>Runge-Kutta 4(5)</member>
                 <member>Dormand-Prince 4(5)</member>
             The family choice is usually determined by the <emphasis>stiffness</emphasis> of the problem, which is, when there is a big gap between the biggest and the smallest eigen values modules of the jacobian matrix (when it is ill-conditionned). It is generally a system that is sensitive to discontinuitues, meaning that the required precision is not constant.
         </para>
         <para>
-            <emphasis role="bold">Implicit</emphasis> solvers :
+            <emphasis role="bold">Implicit</emphasis> solvers:
             <simplelist>
                 <member>LSodar</member>
                 <member>CVode</member>
                 <member>IDA</member>
                 <member>Implicit Runge-Kutta 4(5)</member>
             </simplelist>
-            <emphasis role="bold">Explicit</emphasis> solvers :
+            <emphasis role="bold">Explicit</emphasis> solvers:
             <simplelist>
                 <member>Runge-Kutta 4(5)</member>
                 <member>Dormand-Prince 4(5)</member>
         </para>
         <title>So how to choose ?</title>
         <para>
-            Because it is not possible to know for sure wether a solver will be efficient for a given system or not, the best way is to run the most probable on it and to compare their results.
+            Because it is not possible to know for sure wether a solver will be efficient for a given system or not, the best way is to run the most probable one on it and to compare their results.
         </para>
         <para>
             The user should first establish the complexity of his problem (stability / stiffness) and if he desires high precision, rapid simulation, predictable time or an automated program.
             <para>
-                <emphasis role="bold">Precision :</emphasis> <emphasis>CVode</emphasis>,
+                <emphasis role="bold">Precision:</emphasis> <emphasis>CVode</emphasis>,
             </para>
             <para>
-                <emphasis role="bold">Predictable time :</emphasis> Fixed-size step.
+                <emphasis role="bold">Predictable time:</emphasis> Fixed-size step.
             </para>
             <para>
-                <emphasis role="bold">Simulation time :</emphasis> <emphasis>LSodar</emphasis>,
+                <emphasis role="bold">Simulation time:</emphasis> <emphasis>LSodar</emphasis>,
             </para>
             <para>
-                <emphasis role="bold">Automated :</emphasis> <emphasis>LSodar</emphasis>,
+                <emphasis role="bold">Automated:</emphasis> <emphasis>LSodar</emphasis>,
             </para>
         </para>
     </refsection>
     <refsection>
         <title>Examples</title>
         <para>
-            We will begin with a simple nonstiff example : a Sinus integration.
+            We will begin with a simple nonstiff example: a Sinus integration.
         </para>
         <para>
             <link type="scilab" linkend="scilab.xcos/xcos/examples/solvers/ODE_Example.xcos">
@@ -142,36 +142,36 @@ try xcos_simulate(scs_m, 4); catch disp(lasterror()); end
 ]]></scilab:image>
         </para>
         <para>
-            In the following script, we compare the time difference between the solvers by running the example with the eight solvers in turn (<emphasis>IDA</emphasis> doesn't handle this kind of problem) :
+            In the following script, we compare the time difference between the solvers by running the example with the eight solvers in turn (<emphasis>IDA</emphasis> doesn't handle this kind of problem):
             <link type="scilab" linkend ="scilab.scinotes/xcos/examples/solvers/benchSinus.sce">
                 Open the script
             </link>
         </para>
         <para>
-            The Scilab console displays :
+            The Scilab console displays:
             <screen><![CDATA[
-Time for LSodar :
+Time for LSodar:
  10.1
 
-Time for CVode BDF/Newton :
+Time for CVode BDF/Newton:
  31
 
-Time for CVode BDF/Functional :
+Time for CVode BDF/Functional:
  30
 
-Time for CVode Adams/Newton :
+Time for CVode Adams/Newton:
  17.211
 
-Time for CVode Adams/Functional :
+Time for CVode Adams/Functional:
  16.305
 
-Time for Dormand-Prince :
+Time for Dormand-Prince:
  12.92
 
-Time for Runge-Kutta :
+Time for Runge-Kutta:
  7.663
 
-Time for implicit Runge-Kutta :
+Time for implicit Runge-Kutta:
  10.881
             ]]></screen>
         </para>
@@ -179,10 +179,10 @@ Time for implicit Runge-Kutta :
             These results show that on a nonstiff problem and for same precision required, <emphasis>Runge-Kutta</emphasis> is fastest.
         </para>
         <para>
-            In spite of the computational overhead of the step size, <emphasis>LSodar</emphasis> not too distant from the Fixed-size solvers because it is able to take long steps.
+            In spite of the computational overhead of the step size, <emphasis>LSodar</emphasis> is not too distant from the Fixed-size solvers because it is able to take long steps.
         </para>
         <para>
-            From the results, we can extract speed factors and set the following table :
+            From the results, we can extract speed factors and set the following table:
         </para>
         <para>
             <informaltable border="1">
@@ -314,44 +314,44 @@ try xcos_simulate(scs_m, 4); catch disp(lasterror()); end
 ]]></scilab:image>
         </para>
         <para>
-            In the following script, we compare the time difference between the solvers by running the example with the eight solvers in turn (<emphasis>IDA</emphasis> doesn't handle this kind of problem) :
+            In the following script, we compare the time difference between the solvers by running the example with the eight solvers in turn (<emphasis>IDA</emphasis> doesn't handle this kind of problem):
             <link type="scilab" linkend ="scilab.scinotes/xcos/examples/solvers/benchBasic.sce">
                 Open the script
             </link>
         </para>
         <para>
-            The Scilab console displays :
+            The Scilab console displays:
             <screen><![CDATA[
-Time for LSodar :
+Time for LSodar:
  10
 
-Time for CVode BDF/Newton :
+Time for CVode BDF/Newton:
  28.254
 
-Time for CVode BDF/Functional :
+Time for CVode BDF/Functional:
  25.545
 
-Time for CVode Adams/Newton :
+Time for CVode Adams/Newton:
  15
 
-Time for CVode Adams/Functional :
+Time for CVode Adams/Functional:
  12.1
 
-Time for Dormand-Prince :
+Time for Dormand-Prince:
  2.359
 
-Time for Runge-Kutta :
+Time for Runge-Kutta:
  1.671
 
-Time for implicit Runge-Kutta :
+Time for implicit Runge-Kutta:
  5.612
             ]]></screen>
         </para>
         <para>
-            These results show that as stiffness appears, <emphasis>BDF/Newton</emphasis> starts picking up speed. But the problem is not yet complicated enough for that method to be interesting.
+            These results show that as stiffness appears, <emphasis>BDF / Newton</emphasis> starts picking up speed. But the problem is not yet complicated enough for that method to be interesting.
         </para>
         <para>
-            The updated speed factors table is as follows :
+            The updated speed factors table is as follows:
         </para>
         <para>
             <informaltable border="1">
@@ -483,36 +483,36 @@ try xcos_simulate(scs_m, 4); catch disp(lasterror()); end
 ]]></scilab:image>
         </para>
         <para>
-            In the following script, we compare the time difference between the solvers by running the example with the eight solvers in turn (<emphasis>IDA</emphasis> doesn't handle this kind of problem) :
+            In the following script, we compare the time difference between the solvers by running the example with the eight solvers in turn (<emphasis>IDA</emphasis> doesn't handle this kind of problem):
             <link type="scilab" linkend ="scilab.scinotes/xcos/examples/solvers/benchKalman.sce">
                 Open the script
             </link>
         </para>
         <para>
-            The Scilab console displays :
+            The Scilab console displays:
             <screen><![CDATA[
-Time for LSodar :
+Time for LSodar:
  10
 
-Time for CVode BDF/Newton :
+Time for CVode BDF/Newton:
  21.3
 
-Time for CVode BDF/Functional :
+Time for CVode BDF/Functional:
  15.8
 
-Time for CVode Adams/Newton :
+Time for CVode Adams/Newton:
  12.5
 
-Time for CVode Adams/Functional :
+Time for CVode Adams/Functional:
  8.67
 
-Time for Dormand-Prince :
+Time for Dormand-Prince:
  1.244
 
-Time for Runge-Kutta :
+Time for Runge-Kutta:
  0.87
 
-Time for implicit Runge-Kutta :
+Time for implicit Runge-Kutta:
  4
             ]]></screen>
         </para>
@@ -520,7 +520,7 @@ Time for implicit Runge-Kutta :
             These results show that for a bigger problem (more continuous states implies more equations), the <emphasis>Newton iteration</emphasis> starts showing interest, for it comes closer to the other solvers.
         </para>
         <para>
-            The updated speed factors table is as follows :
+            The updated speed factors table is as follows:
         </para>
         <para>
             <informaltable border="1">