Typo fixes
[scilab.git] / scilab / modules / optimization / help / en_US / nonlinearleastsquares / leastsq.xml
index 7fc8a92..776f224 100644 (file)
@@ -3,11 +3,11 @@
  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
  * Copyright (C) 2008 - INRIA
  * Copyright (C) 2011 - DIGITEO - Michael Baudin
- * 
+ *
  * This file must be used under the terms of the CeCILL.
  * This source file is licensed as described in the file COPYING, which
  * you should have received as part of this distribution.  The terms
- * are also available at    
+ * are also available at
  * http://www.cecill.info/licences/Licence_CeCILL_V2.1-en.txt
  *
  -->
                 <term>mem</term>
                 <listitem>
                     <para>
-                        integer, number of variables used to approximate the Hessean
+                        integer, number of variables used to approximate the Hessian
                         (second derivatives) of <literal>f</literal> when
                         <literal>algo</literal><literal>='qn'</literal>. Default value is
                         10.
         <title>How to provide fun and dfun</title>
         <para>
             <literal>fun</literal> can be a scilab function (case
-            1) or a fortran or a C routine linked to scilab (case 2). 
+            1) or a fortran or a C routine linked to scilab (case 2).
         </para>
         <variablelist>
             <varlistentry>
                 <listitem>
                     <para>
                         When <literal>fun</literal> is a Scilab function, its calling
-                        sequence must be: 
-                        <screen><![CDATA[ 
+                        sequence must be:
+                        <screen><![CDATA[
 y=fun(x)
  ]]></screen>
-                        In the case where the cost function needs extra parameters, 
+                        In the case where the cost function needs extra parameters,
                         its header must be:
-                        <screen><![CDATA[ 
+                        <screen><![CDATA[
 y=f(x,a1,a2,...)
  ]]></screen>
-                        In this case, we provide <literal>fun</literal> as a list, 
+                        In this case, we provide <literal>fun</literal> as a list,
                         which contains <literal>list(f,a1,a2,...)</literal>.
                     </para>
                 </listitem>
@@ -259,17 +259,17 @@ y=f(x,a1,a2,...)
                     <para>
                         When <literal>fun</literal> is a Fortran or C
                         routine, it must be <literal>list(fun_name,m[,a1,a2,...])</literal> in the calling sequence of
-                        <literal>leastsq</literal>, where <literal>fun_name</literal> is 
+                        <literal>leastsq</literal>, where <literal>fun_name</literal> is
                         a 1-by-1 matrix of strings, the name of the routine which must be linked to Scilab (see
                         <link linkend="link">link</link>). The header must be, in Fortran:
                         
-                        <screen><![CDATA[ 
+                        <screen><![CDATA[
 subroutine fun(m, n, x, params, y)
 integer m,n
 double precision x(n), params(*), y(m)
  ]]></screen>
                         and in C:
-                        <screen><![CDATA[ 
+                        <screen><![CDATA[
 void fun(int *m, int *n, double *x, double *params, double *y)
  ]]></screen>
                         
@@ -282,7 +282,7 @@ void fun(int *m, int *n, double *x, double *params, double *y)
                         <literal>a1</literal> has 3 components, the description of
                         <literal>a2</literal> begin from
                         <literal>params(4)</literal> (in fortran), and from
-                        <literal>params[3]</literal> (in C). 
+                        <literal>params[3]</literal> (in C).
                         Note that even if <literal>fun</literal> does not need supplementary parameters you
                         must anyway write the fortran code with a <literal>params</literal>
                         argument (which is then unused in the subroutine core).
@@ -291,9 +291,9 @@ void fun(int *m, int *n, double *x, double *params, double *y)
             </varlistentry>
         </variablelist>
         <para>
-            By default, the algorithm uses a finite difference approximation 
-            of the Jacobian matrix. 
-            The Jacobian matrix can be provided by defining the function 
+            By default, the algorithm uses a finite difference approximation
+            of the Jacobian matrix.
+            The Jacobian matrix can be provided by defining the function
             <literal>dfun</literal>, where  to the
             optimizer it may be given as a usual scilab function or
             as a fortran or a C routine linked to scilab.
@@ -304,15 +304,15 @@ void fun(int *m, int *n, double *x, double *params, double *y)
                 <listitem>
                     <para>
                         when <literal>dfun</literal> is a scilab function, its calling
-                        sequence must be: 
-                        <screen><![CDATA[ 
+                        sequence must be:
+                        <screen><![CDATA[
               y=dfun(x)
  ]]></screen>
                         where <literal>y(i,j)=dfi/dxj</literal>.
-                        If extra parameters are required by <literal>fun</literal>, i.e. if arguments 
-                        <literal>a1,a2,...</literal> are required, they are passed also to 
+                        If extra parameters are required by <literal>fun</literal>, i.e. if arguments
+                        <literal>a1,a2,...</literal> are required, they are passed also to
                         <literal>dfun</literal>, which must have header
-                        <screen><![CDATA[ 
+                        <screen><![CDATA[
               y=dfun(x,a1,a2,...)
  ]]></screen>
                         Note that, even if <literal>dfun</literal>
@@ -327,16 +327,16 @@ void fun(int *m, int *n, double *x, double *params, double *y)
                 <listitem>
                     <para>
                         When <literal>dfun</literal> is defined by a Fortran or C
-                        routine it must be a string, the name of the function linked to 
-                        Scilab. 
+                        routine it must be a string, the name of the function linked to
+                        Scilab.
                         The calling sequences must be, in Fortran:
-                        <screen><![CDATA[ 
+                        <screen><![CDATA[
 subroutine dfun(m, n, x, params, y)
 integer m,n
 double precision x(n), params(*), y(m,n)
  ]]></screen>
                         in C:
-                        <screen><![CDATA[ 
+                        <screen><![CDATA[
           void fun(int *m, int *n, double *x, double *params, double *y)
  ]]></screen>
                         
@@ -366,33 +366,33 @@ double precision x(n), params(*), y(m,n)
         <para>
             We will show different calling possibilities of leastsq on one (trivial) example
             which is non linear but does not really need to be solved with leastsq (applying
-            log linearizes the model and the problem may be solved with linear algebra). 
+            log linearizes the model and the problem may be solved with linear algebra).
             In this example we look for the 2 parameters x(1) and x(2) of a simple
             exponential decay model (x(1) being the unknow initial value and x(2) the
-            decay constant): 
+            decay constant):
         </para>
-        <programlisting role="example"><![CDATA[ 
+        <programlisting role="example"><![CDATA[
 
 function y = yth(t, x)
-   y  = x(1)*exp(-x(2)*t) 
-endfunction  
+   y  = x(1)*exp(-x(2)*t)
+endfunction
 
 // we have the m measures (ti, yi):
 m = 10;
 tm = [0.25, 0.5, 0.75, 1.0, 1.25, 1.5, 1.75, 2.0, 2.25, 2.5]';
 ym = [0.79, 0.59, 0.47, 0.36, 0.29, 0.23, 0.17, 0.15, 0.12, 0.08]';
 // measure weights (here all equal to 1...)
-wm = ones(m,1); 
+wm = ones(m,1);
 
-// and we want to find the parameters x such that the model fits the given 
+// and we want to find the parameters x such that the model fits the given
 // data in the least square sense:
-// 
-//  minimize  f(x) = sum_i  wm(i)^2 ( yth(tm(i),x) - ym(i) )^2   
+//
+//  minimize  f(x) = sum_i  wm(i)^2 ( yth(tm(i),x) - ym(i) )^2
 
 // initial parameters guess
 x0 = [1.5 ; 0.8];
 
-// in the first examples, we define the function fun and dfun 
+// in the first examples, we define the function fun and dfun
 // in scilab language
 function e = myfun(x, tm, ym, wm)
    e = wm.*( yth(tm, x) - ym )
@@ -427,12 +427,12 @@ xtitle("a simple fit with leastsq")
 [f,xopt, gopt] = leastsq(1,list(myfun,tm,ym,wm),mydfun,x0,"gc")
 
 // 5- how to provide bound constraints (not useful here !)
-xinf = [-%inf,-%inf]; 
+xinf = [-%inf,-%inf];
 xsup = [%inf, %inf];
 // without Jacobian:
-[f,xopt, gopt] = leastsq(list(myfun,tm,ym,wm),"b",xinf,xsup,x0) 
+[f,xopt, gopt] = leastsq(list(myfun,tm,ym,wm),"b",xinf,xsup,x0)
 // with Jacobian :
-[f,xopt, gopt] = leastsq(list(myfun,tm,ym,wm),mydfun,"b",xinf,xsup,x0) 
+[f,xopt, gopt] = leastsq(list(myfun,tm,ym,wm),mydfun,"b",xinf,xsup,x0)
 
 // 6- playing with some stopping parameters of the algorithm
 //    (allows only 40 function calls, 8 iterations and set epsg=0.01, epsf=0.1)
@@ -441,13 +441,13 @@ xsup = [%inf, %inf];
         <scilab:image>
             
             function y = yth(t, x)
-            y  = x(1)*exp(-x(2)*t) 
-            endfunction  
+            y  = x(1)*exp(-x(2)*t)
+            endfunction
             
             m = 10;
             tm = [0.25, 0.5, 0.75, 1.0, 1.25, 1.5, 1.75, 2.0, 2.25, 2.5]';
             ym = [0.79, 0.59, 0.47, 0.36, 0.29, 0.23, 0.17, 0.15, 0.12, 0.08]';
-            wm = ones(m,1); 
+            wm = ones(m,1);
             
             x0 = [1.5 ; 0.8];
             
@@ -486,7 +486,7 @@ xsup = [%inf, %inf];
         <para>
             Let us begin by an example with fun and dfun in fortran
         </para>
-        <programlisting role="example"><![CDATA[ 
+        <programlisting role="example"><![CDATA[
 // 7-1/ Let 's Scilab write the fortran code (in the TMPDIR directory):
 f_code = ["      subroutine myfun(m,n,x,param,f)"
           "*     param(i) = tm(i), param(m+i) = ym(i), param(2m+i) = wm(i)"
@@ -518,7 +518,7 @@ names = ["myfun" "mydfun"]
 flibname = ilib_for_link(names,"myfun.f",[],"f");
 
 // 7-3/ link it to scilab (see link help page)
-link(flibname,names,"f") 
+link(flibname,names,"f")
 
 // 7-4/ ready for the leastsq call: be carreful do not forget to
 //      give the dimension m after the routine name !
@@ -528,7 +528,7 @@ link(flibname,names,"f")
         <para>
             Last example: fun and dfun in C.
         </para>
-        <programlisting role="example"><![CDATA[ 
+        <programlisting role="example"><![CDATA[
 // 8-1/ Let 's Scilab write the C code (in the TMPDIR directory):
 c_code = ["#include <math.h>"
           "void myfunc(int *m,int *n, double *x, double *param, double *f)"
@@ -559,7 +559,7 @@ names = ["myfunc" "mydfunc"]
 clibname = ilib_for_link(names,"myfunc.c",[],"c");
 
 // 8-3/ link it to scilab (see link help page)
-link(clibname,names,"c") 
+link(clibname,names,"c")
 
 // 8-4/ ready for the leastsq call
 [f,xopt, gopt] = leastsq(list("myfunc",m,tm,ym,wm),"mydfunc",x0)