Typo fixes 21/14221/2
Paul Bignier [Fri, 28 Mar 2014 16:12:47 +0000 (17:12 +0100)]
Change-Id: Ic3f71c37b1a45725b7538ecfb1e9d4a71fc7c499

38 files changed:
scilab/modules/atoms/macros/atoms_gui/atomsResize.sci
scilab/modules/atoms/macros/atoms_internals/atomsSetInstalledList.sci
scilab/modules/cacsd/demos/pid.dem
scilab/modules/differential_equations/demos/ode/ode_vanderpol/ode_vanderpol.dem.sce
scilab/modules/elementary_functions/src/fortran/watan.f
scilab/modules/external_objects_java/help/en_US/jinvoke.xml
scilab/modules/graphics/help/ja_JP/axes_operations/plotframe.xml
scilab/modules/graphics/help/pt_BR/annotation/label_properties.xml
scilab/modules/graphics/macros/legends.sci
scilab/modules/graphics/tests/nonreg_tests/bug_120.dia.ref
scilab/modules/graphics/tests/nonreg_tests/bug_120.tst
scilab/modules/graphics/tests/nonreg_tests/bug_1726.dia.ref
scilab/modules/graphics/tests/nonreg_tests/bug_1726.tst
scilab/modules/graphics/tests/nonreg_tests/bug_3009.dia.ref
scilab/modules/graphics/tests/nonreg_tests/bug_3009.tst
scilab/modules/gui/includes/CallClipboard.h
scilab/modules/gui/sci_gateway/c/sci_ClipBoard.c
scilab/modules/interpolation/demos/interp_demo.sci
scilab/modules/interpolation/help/ja_JP/cshep2d.xml
scilab/modules/mpi/macros/MPIPi_seq.sci
scilab/modules/optimization/help/en_US/derivative.xml
scilab/modules/optimization/help/en_US/numderivative.xml
scilab/modules/optimization/help/fr_FR/numderivative.xml
scilab/modules/optimization/macros/numderivative.sci
scilab/modules/scicos_blocks/macros/Misc/MBLOCK.sci
scilab/modules/scicos_blocks/macros/Misc/MPBLOCK.sci
scilab/modules/scinotes/etc/keysConfiguration.xml
scilab/modules/signal_processing/demos/conv2.dem.sce
scilab/modules/sparse/src/c/spFactor.c
scilab/modules/sparse/src/c/spFortran.c
scilab/modules/xml/help/en_US/htmlDump.xml
scilab/modules/xml/help/en_US/htmlRead.xml
scilab/modules/xml/help/en_US/htmlReadStr.xml
scilab/modules/xml/help/en_US/htmlWrite.xml
scilab/modules/xml/sci_gateway/cpp/sci_htmlDump.cpp
scilab/modules/xml/sci_gateway/cpp/sci_htmlRead.cpp
scilab/modules/xml/sci_gateway/cpp/sci_htmlReadStr.cpp
scilab/modules/xml/sci_gateway/cpp/sci_htmlWrite.cpp

index 1b7df7b..d2b8e71 100644 (file)
@@ -5,7 +5,7 @@
 // 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
-// http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
+// http://www.cecill.info/licences/Licence_CeCILL_V2.1-en.txt
 
 function atomsResize()
     // Load Atoms Internals lib if it's not already loaded
@@ -16,4 +16,4 @@ function atomsResize()
     HomeElements = atomsGetHomeListboxElts();
     set("HomeListbox", "String", HomeElements("items_str"));
     set("HomeListbox", "UserData", HomeElements("items_mat"));
-endfunction
\ No newline at end of file
+endfunction
index ab4c51f..8751c49 100644 (file)
@@ -5,7 +5,7 @@
 // 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
-// http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
+// http://www.cecill.info/licences/Licence_CeCILL_V2.1-en.txt
 
 // =============================================================================
 //
index 972ee5c..7e99943 100644 (file)
@@ -79,7 +79,7 @@ function demo_pid()
 
     disp(spec(Winv(2)),'closed loop eigenvalues');//Check internal stability
     if max(real(spec(Winv(2)))) > 0 then
-      messagebox('You loose: closed-loop is UNSTABLE!!!',"modal");
+      messagebox('You lose: closed-loop is UNSTABLE!!!',"modal");
     else
       messagebox('Congratulations: closed-loop is STABLE !!!',"modal");
       break;
index b07201b..fbe8970 100644 (file)
@@ -49,7 +49,7 @@ function demo_ode_vanderpol()
     a=gca();a.margins(3)=0.2
     title([_("Van der Pol vector field")
     "dy1/dt=y2"
-    "dy2/dt=5*(1-y1^2*y2-y1"],"fontsize",3)
+    "dy2/dt=5*(1-y1^2)*y2-y1"],"fontsize",3)
 
     t0=0; dt=0.05; tmax=15;
     t=t0:dt:tmax;
index 809f005..2ffe210 100644 (file)
@@ -1,10 +1,10 @@
 c Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
 c Copyright (C) Bruno Pincon
-c 
+c
 c This file must be used under the terms of the CeCILL.
 c This source file is licensed as described in the file COPYING, which
 c you should have received as part of this distribution.  The terms
-c are also available at    
+c are also available at
 c http://www.cecill.info/licences/Licence_CeCILL_V2.1-en.txt
 c
       subroutine watan(xr,xi,yr,yi)
@@ -25,10 +25,10 @@ c     COPYRIGHT (C) 2001 Bruno Pincon and Lydia van Dijk
 c        Written by Bruno Pincon <Bruno.Pincon@iecn.u-nancy.fr> so
 c        as to get more precision.  Also to fix the
 c        behavior at the singular points and at the branch cuts.
-c        Polished by Lydia van Dijk 
+c        Polished by Lydia van Dijk
 c        <lvandijk@hammersmith-consulting.com>
-c     
-c     CHANGES : - (Bruno on 2001 May 22) for ysptrk use a 
+c
+c     CHANGES : - (Bruno on 2001 May 22) for ysptrk use a
 c                 minimax polynome to enlarge the special
 c                 evaluation zone |s| < SLIM. Also rename
 c                 this function as lnp1m1.
@@ -43,11 +43,11 @@ c        lnp1m1  (at the end of this file)
 c
 c     ALGORITHM : noting z = a + i*b, we have:
 c        Z = yr + yi*b = arctan(z) = (i/2) * log( (i+z)/(i-z) )
-c              
+c
 c     This function has two branch points at +i and -i and the
 c     chosen  branch cuts are the two half-straight lines
 c     D1 = [i, i*oo) and D2 = (-i*oo, i].  The function is then
-c     analytic in C \ (D1 U D2)). 
+c     analytic in C \ (D1 U D2)).
 c
 c     From the definition it follows that:
 c
@@ -64,17 +64,17 @@ c         if imag(z) > 1 then
 c             Arg(arctan(z)) =  pi/2 (=lim real(z) -> 0+)
 c         if imag(z) < 1 then
 c             Arg(arctan(z)) = -pi/2 (=lim real(z) -> 0-)
-c                 
+c
 c
 c     Basic evaluation: if we write (i+z)/(i-z) using
 c     z = a + i*b, we get:
 c
 c     i+z    1-(a**2+b**2) + i*(2a)
-c     --- =  ---------------------- 
+c     --- =  ----------------------
 c     i-z       a**2 + (1-b)**2
 c
 c     then, with r2 = |z|^2 = a**2 + b**2 :
-c  
+c
 c     yr = 0.5 * Arg(1-r2 + (2*a)*i)
 c        = 0.5 * atan2(2a, (1-r2))                      (3)
 c
@@ -83,29 +83,29 @@ c     and also when |1-r2| and |a| are near 0 (see comments
 c     in the code).
 c
 c     After some math:
-c             
+c
 c     yi = 0.25 * log( (a**2 + (b + 1)**2) /
-c                      (a**2 + (b - 1)**2) )            (4)     
-c               
+c                      (a**2 + (b - 1)**2) )            (4)
+c
 c     Evaluation for "big" |z|
 c     ------------------------
 c
 c     If |z| is "big", the direct evaluation of yi by (4) may
-c     suffer of innaccuracies and of spurious overflow.  Noting 
+c     suffer of innaccuracies and of spurious overflow.  Noting
 c     that  s = 2 b / (1 + |z|**2), we have:
 c
 c     yi = 0.25 log ( (1 + s)/(1 - s) )                 (5)
 c
-c                                3        5    
+c                                3        5
 c     yi = 0.25*( 2 * ( s + 1/3 s  + 1/5 s  + ... ))
 c
 c     yi = 0.25 * lnp1m1(s)    if  |s| < SLIM
 c
 c     So if |s| is less than SLIM we switch to a special
-c     evaluation done by the function lnp1m1. The 
-c     threshold value SLIM is choosen by experiment 
-c     (with the Pari-gp software). For |s| 
-c     "very small" we used a truncated taylor dvp, 
+c     evaluation done by the function lnp1m1. The
+c     threshold value SLIM is chosen by experiment
+c     (with the Pari-gp software). For |s|
+c     "very small" we used a truncated taylor dvp,
 c     else a minimax polynome (see lnp1m1).
 c
 c     To avoid spurious overflows (which result in spurious
@@ -113,7 +113,7 @@ c     underflows for s) in computing s with s= 2 b / (1 + |z|**2)
 c     when |z|^2 > RMAX (max positive float) we use :
 c
 c            s = 2d0 / ( (a/b)*a + b )
-c     
+c
 c     but if |b| = Inf  this formula leads to NaN when
 c     |a| is also Inf. As we have :
 c
@@ -130,12 +130,12 @@ c     So we switch to the following formulas:
 c
 c     If b = +-1 and |a| < sqrt(tiny) approximately 1d-150 (say)
 c     then (by using that a**2 + 4 = 4 in machine for such a):
-c         
+c
 c         yi = 0.5 * log( 2/|a| )   for b=1
-c 
+c
 c         yi = 0.5 * log( |a|/2 )   for b=-1
 c
-c     finally: yi = 0.5 * sign(b) * log( 2/|a| )     
+c     finally: yi = 0.5 * sign(b) * log( 2/|a| )
 c              yi = 0.5 * sign(b) * (log(2) - log(|a|)) (6)
 c
 c     The last trick is to avoid overflow for |a|=tiny!  In fact
@@ -161,7 +161,7 @@ c
 c     STATIC VAR
       logical first
       double precision RMAX, HALFPI
-      
+
       save    first
       data    first /.true./
        save             RMAX, HALFPI
@@ -229,11 +229,11 @@ c              got a Nan with 0/0
                yr = 0d0
             endif
          elseif (r2 .gt. RMAX) then
-c           yr is necessarily very near sign(a)* pi/2 
+c           yr is necessarily very near sign(a)* pi/2
             yr = sign(1.d0, a) * HALFPI
          elseif ( abs(1.d0 - r2) + abs(a) .le.TOL ) then
 c           |b| is very near 1 (and a is near 0)  some
-c           cancellation occur in the (next) generic formula 
+c           cancellation occur in the (next) generic formula
             yr = 0.5d0 * atan2(2d0*a, (1.d0-b)*(1.d0+b) - a*a)
          else
 c           generic formula
@@ -250,20 +250,20 @@ c
 c     PURPOSE :  Compute   v = log ( (1 + s)/(1 - s) )
 c        for small s, this is for |s| < SLIM = 0.20
 c
-c     ALGORITHM : 
+c     ALGORITHM :
 c     1/ if |s| is "very small" we use a truncated
-c        taylor dvp (by keeping 3 terms) from : 
+c        taylor dvp (by keeping 3 terms) from :
 c                               2        4          6
 c        t = 2 * s * ( 1 + 1/3 s  + 1/5 s  + [ 1/7 s  + ....] )
-c                               2        4      
+c                               2        4
 c        t = 2 * s * ( 1 + 1/3 s  + 1/5 s  + er)
-c          
+c
 c        The limit E until we use this formula may be simply
 c        gotten so that the negliged part er is such that :
 c                                    2        4
 c        (#) er <= epsm * ( 1 + 1/3 s  + 1/5 s )   for all |s|<= E
 c
-c        As  er  = 1/7 s^6 + 1/9 s^8 + ... 
+c        As  er  = 1/7 s^6 + 1/9 s^8 + ...
 c            er <= 1/7 * s^6 ( 1 + s^2 + s^4 + ...) = 1/7  s^6/(1-s^2)
 c
 c        the inequality (#) is forced if :
@@ -278,9 +278,9 @@ c     2/ For larger |s| we used a minimax polynome :
 c
 c        yi = s * (2  + d3 s^3 + d5 s^5 .... + d13 s^13 + d15 s^15)
 c
-c        This polynome was computed (by some remes algorithm) following 
+c        This polynome was computed (by some remes algorithm) following
 c        (*) the sin(x) example (p 39) of the book :
-c       
+c
 c         "ELEMENTARY FUNCTIONS"
 c         "Algorithms and implementation"
 c         J.M. Muller (Birkhauser)
@@ -310,8 +310,8 @@ c     minimax poly coefs
       end
 
 c
-c   a log(1+x) function for scilab .... 
-c                                      
+c   a log(1+x) function for scilab ....
+c
 c
       double precision function logp1(x)
       implicit none
@@ -319,12 +319,12 @@ c
 
       double precision g
       double precision a, b
-      parameter      ( a = -1d0/3d0, 
+      parameter      ( a = -1d0/3d0,
      $                 b =  0.5d0 )
 
       double precision lnp1m1
       external         lnp1m1
-      
+
       if ( x .lt. -1.d0 ) then
 c        got NaN
          logp1 = (x - x)/(x - x)
index e805318..cdbcac8 100644 (file)
@@ -52,7 +52,7 @@
             Invoke the Java method (static or not) called methodName of the given object. The result is returned as a mlist typed _JObj.
         </para>
         <para>
-            The polymorphism is handled in using Java Reflection and the autoboxing is handled too so ArrayList.add(1.234) or ArrayList.add("Hello") are allowed. If it exists a method Foo.bar(int), it is possible to write Foo.bar(123) even if 123 is a Scilab double but Foo.bar(double), if it exists, will be choosen.
+            The polymorphism is handled in using Java Reflection and the autoboxing is handled too so ArrayList.add(1.234) or ArrayList.add("Hello") are allowed. If it exists a method Foo.bar(int), it is possible to write Foo.bar(123) even if 123 is a Scilab double but Foo.bar(double), if it exists, will be chosen.
         </para>
     </refsection>
     <refsection>
index 084af81..f73dab7 100644 (file)
@@ -2,11 +2,11 @@
 <!--
  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
  * Copyright (C) INRIA
- * 
+ *
  * 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
  *
  -->
@@ -49,7 +49,7 @@
             <varlistentry>
                 <term>arg_optX</term>
                 <listitem>
-                    <para>optional arguments up to three and choosen among.</para>
+                    <para>optional arguments up to three and chosen among.</para>
                     <variablelist>
                         <varlistentry>
                             <term>flags</term>
     </refsection>
     <refsection>
         <title>Examples</title>
-        <programlisting role="example"><![CDATA[ 
+        <programlisting role="example"><![CDATA[
 x=[-0.3:0.8:27.3]';
 y=rand(x);
 rect=[min(x),min(y),max(x),max(y)];
index 8843e08..dab10df 100644 (file)
@@ -2,11 +2,11 @@
 <!--
  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
  * Copyright (C) INRIA - Djalel Abdemouche
- * 
+ *
  * 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
  *
  -->
@@ -77,7 +77,7 @@
                 <listitem>
                     <para>este campo contém a cor utilizada para exibir o rótulo e a
                         linha ao redor da caixa, se houver. Deve ser um índice de cor
-                        (relativo ao mapa de cores corrente). 
+                        (relativo ao mapa de cores corrente).
                     </para>
                 </listitem>
             </varlistentry>
@@ -86,7 +86,7 @@
                 <listitem>
                     <para>este campo contém a cor a ser usada para preencher a caixa, se
                         houver. Deve ser um índice de cor (relativo ao mapa de cores
-                        corrente). 
+                        corrente).
                     </para>
                 </listitem>
             </varlistentry>
@@ -97,7 +97,7 @@
                         este campo toma valores <literal>"on"</literal> ou
                         <literal>"off"</literal>. Se <literal>"on"</literal> uma caixa é
                         desenhada ao redor do texto com uma linha em sua borda e um plano de
-                        fundo. 
+                        fundo.
                     </para>
                 </listitem>
             </varlistentry>
                 <term>auto_position:</term>
                 <listitem>
                     <para>
-                        se <literal>"on"</literal>, o Scilab computa automticamente a
+                        se <literal>"on"</literal>, o Scilab computa automaticamente a
                         melhor posição para a exibição do rótulo na janela de gráficos. Se
                         <literal>"off"</literal>, o rótulo pode ser posicionado manualmente
                         através da propriedade <literal>position</literal>.
     </refsection>
     <refsection>
         <title>Exemplos</title>
-        <programlisting role="example"><![CDATA[ 
+        <programlisting role="example"><![CDATA[
 a=get("current_axes");
 a.title
 type(a.title)
@@ -189,14 +189,14 @@ plot3d()
 a.x_label
 a.y_label
 a.z_label
-xtitle("Meu título","meu rótulo de eixo x", "Volume","Mês") 
+xtitle("Meu título","meu rótulo de eixo x", "Volume","Mês")
 
 t=a.title;
 t.foreground=9;
 t.font_size=5;
 t.font_style=5;
 t.text="SCILAB";
-   
+
 x_label=a.x_label;
 x_label.text=" Peso"
 x_label.font_style= 5;
index de80ff1..15afad5 100644 (file)
@@ -58,7 +58,7 @@ function legends(leg, style, opt, with_box, font_size )
     arect=old_ax.margins;
     r1=old_ax.axes_bounds;
 
-    //create small axes on the top left corner (the axes is choosen very
+    //create small axes on the top left corner (the axes is chosen very
     //small to avoid it can be selected for rotation in new graphic mode
     //case (a little tricky)
     xsetech(wrect=[r1(1),r1(2),r1(3)/1000,r1(4)/1000],frect=[0 0 1,1]/1000,arect=[0,0,0,0])
index e8f2173..a317776 100644 (file)
@@ -39,7 +39,7 @@ dataBounds1 = curFig.children(1).data_bounds
  
     0.01  - 29.4651    
     100.    30.537043  
-// chack that the X bounds are [fmin, fmax]
+// check that the X bounds are [fmin, fmax]
 if (dataBounds1(1,1) <> fmin) then bugmes();quit;end;
 if (dataBounds1(2,1) <> fmax) then bugmes();quit;end;
 // same for magnitude plot
@@ -48,6 +48,6 @@ dataBounds2 = curFig.children(2).data_bounds
  
     0.01  - 0.1723667  
     100.    9.4565594  
-// chack that the X bounds are [fmin, fmax]
+// check that the X bounds are [fmin, fmax]
 if (dataBounds2(1,1) <> fmin) then bugmes();quit;end;
 if (dataBounds2(2,1) <> fmax) then bugmes();quit;end;
index cd2f534..de800c9 100644 (file)
@@ -17,9 +17,9 @@
 //  It shift x (horizontal) axis for one decade in right. So the bode plot is incorect.
 
 // create a linerar system
-s=poly(0,'s')
-h=syslin('c',(s^2+2*0.9*10*s+100)/(s^2+2*0.3*10.1*s+102.01))
-my_title='(s^2+2*0.9*10*s+100)/(s^2+2*0.3*10.1*s+102.01)';
+s=poly(0,"s")
+h=syslin("c",(s^2+2*0.9*10*s+100)/(s^2+2*0.3*10.1*s+102.01))
+my_title="(s^2+2*0.9*10*s+100)/(s^2+2*0.3*10.1*s+102.01)";
 
 // draw the bode plot between fmin and fmax
 fmin = 0.01;
@@ -31,13 +31,13 @@ curFig = gcf();
 
 // get data bounds of phase plot
 dataBounds1 = curFig.children(1).data_bounds
-// chack that the X bounds are [fmin, fmax]
+// check that the X bounds are [fmin, fmax]
 if (dataBounds1(1,1) <> fmin) then pause; end;
 if (dataBounds1(2,1) <> fmax) then pause; end;
 
 // same for magnitude plot
 dataBounds2 = curFig.children(2).data_bounds
-// chack that the X bounds are [fmin, fmax]
+// check that the X bounds are [fmin, fmax]
 if (dataBounds2(1,1) <> fmin) then pause; end;
 if (dataBounds2(2,1) <> fmax) then pause; end;
 
index 338bbb6..7ae8e7d 100644 (file)
@@ -82,4 +82,4 @@ for alpha = -250:0.1:0
     ha.rotation_angles(2) = alpha;
     drawnow();
 end
-// chack that 5 facets of the cube are correctly drawn.
+// check that 5 facets of the cube are correctly drawn.
index 80692f9..3ac95de 100644 (file)
@@ -95,5 +95,5 @@ for alpha = -250:0.1:0
     drawnow();
 end
 
-// chack that 5 facets of the cube are correctly drawn.
+// check that 5 facets of the cube are correctly drawn.
 
index 6978d7e..883a92b 100644 (file)
@@ -17,7 +17,7 @@ df = gdf();
 df.user_data = list(1,2,3);
 da = gda();
 da.user_data = rand(50,50);
-// create a figure and axes and chack their user_data fields
+// create a figure and axes and check their user_data fields
 fig = gcf();
 axes = gca();
 if (fig.user_data <> df.user_data) then bugmes();quit;end
index 80e7a98..29c1519 100644 (file)
 //
 // <-- Short Description -->
 // Default figure and axes handles "user_data" field is not taken into account when creating a new figure.
-// 
+//
 
 df = gdf();
 df.user_data = list(1,2,3);
 da = gda();
 da.user_data = rand(50,50);
 
-// create a figure and axes and chack their user_data fields
+// create a figure and axes and check their user_data fields
 fig = gcf();
 axes = gca();
 if (fig.user_data <> df.user_data) then pause; end
index fe23b75..07f57ed 100644 (file)
@@ -22,7 +22,7 @@ extern "C" {
      * Get the clipboard contents
      *
      * @param void
-     * @return the contents of the clipbaord or NULL if the clipbaord data are not chars
+     * @return the contents of the clipboard or NULL if the clipboard data are not chars
      */
     char *getClipboardContents(void);
 
index f400850..8510aff 100644 (file)
@@ -73,7 +73,7 @@ int sci_ClipBoard(char *fname, unsigned long l)
 
                 if ( ( strcmp(param1, "paste") == 0 ) || ( strcmp(param1, "pastespecial") == 0 ) )
                 {
-                    /* Use the Java clipboard (CallScilabBridge.java returns "" if clipbaord could not be read) */
+                    /* Use the Java clipboard (CallScilabBridge.java returns "" if clipboard could not be read) */
                     char *output = getClipboardContents();
 
 
index cd46eec..f342a38 100644 (file)
@@ -43,7 +43,7 @@ function [Xm,Xp,Ym,Yp,Zm,Zp] = slice_parallelepiped(dir_, val, ebox, nx, ny, nz)
     select dir_
     case "x=" then
         if val < ebox(1)  |  ebox(2) < val then
-            error("Bad slice choosen")
+            error("Bad slice chosen")
         end
         dx = coef*(ebox(2)-ebox(1))
         y = linspace(ebox(3),ebox(4),ny)
@@ -54,7 +54,7 @@ function [Xm,Xp,Ym,Yp,Zm,Zp] = slice_parallelepiped(dir_, val, ebox, nx, ny, nz)
         Xp = (val+dx)*ones(Yp);
     case "y=" then
         if val < ebox(3)  |  ebox(4) < val then
-            error("bad slice choosen")
+            error("bad slice chosen")
         end
         dy = coef*(ebox(4)-ebox(3))
         x = linspace(ebox(1),ebox(2),nx)
@@ -65,7 +65,7 @@ function [Xm,Xp,Ym,Yp,Zm,Zp] = slice_parallelepiped(dir_, val, ebox, nx, ny, nz)
         Yp = (val+dy)*ones(Xp);
     case "z=" then
         if val < ebox(5)  |  ebox(6) < val then
-            error("bad slice choosen")
+            error("bad slice chosen")
         end
         dz = coef*(ebox(6)-ebox(5))
         x = linspace(ebox(1),ebox(2),nx)
index a7095a1..e5d2a4f 100644 (file)
@@ -63,7 +63,7 @@
     </refsection>
     <refsection>
         <title>例</title>
-        <programlisting role="example"><![CDATA[ 
+        <programlisting role="example"><![CDATA[
 // ランダムに選択された補間点について cos(x)cos(y)を補間します
 n = 150; // nb 個の補間点
 xy = grand(n,2,"unf",0,2*%pi);
@@ -79,7 +79,7 @@ Z = eval_cshep2d(X,Y, tl_coef);
 clf()
 plot3d(xx,xx,Z,flag=[2 6 4])
 param3d1(xy(:,1),xy(:,2),list(z,-9), flag=[0 0])
-xtitle("Cubic Shepard Interpolation of cos(x)cos(y) with randomly choosen interpolation points")
+xtitle("Cubic Shepard Interpolation of cos(x)cos(y) with randomly chosen interpolation points")
 legends("interpolation points",-9,1)
 show_window()
  ]]></programlisting>
index 4dbd38c..fc72160 100644 (file)
@@ -1,68 +1,68 @@
 function MPIPi_seq(N)
-// Pi_seq: Compute PI (sequential) by num.integr. of arctan(x) in [0..1]
-//
-//     Pi_seq [ (N) ]
-//
-//  N  [1E7]   #subdivisions of the [0, 1] interval
-//
-//  printed results struct contains
-//     pi      estimated pi value
-//     err     error
-//     time    from argument xmit to pi computed
-//
-// Examples:
-//
-//  octave:1> Pi_seq
-//  results =
-//  {
-//    pi =  3.1416
-//    err = -6.4837e-14
-//    time =  2.7761
-//  }
-//
+    // Pi_seq: Compute PI (sequential) by num.integr. of arctan(x) in [0..1]
+    //
+    // Pi_seq [ (N) ]
+    //
+    //  N      [1E7]   #subdivisions of the [0, 1] interval
+    //
+    //  printed results struct contains
+    // pi      estimated pi value
+    // err     error
+    // time    from argument xmit to pi computed
+    //
+    // Examples:
+    //
+    //  octave:1> Pi_seq
+    //  results =
+    //  {
+    //    pi =  3.1416
+    //    err = -6.4837e-14
+    //    time =  2.7761
+    //  }
+    //
 
-////////////////////
-// ArgChk //
-////////////////////
-if argn(2)<1,  N=1E7;  end
-if argn(2)>1,  error("usage Pi_seq(N)"); end
-flag=0;
-[%H,%ierr] = evstr(string(N));
-flag=flag | size(N,"*")<>1 | %ierr<>0;
-flag=flag  |   fix(N)~=N   |           N<1;
-if flag,       error("usage Pi_seq( <int> N>0, <char> mod==''s|r'' )"), end
+    ////////////////////
+    // ArgChk //
+    ////////////////////
+    if argn(2)<1,      N=1E7;  end
+    if argn(2)>1,      error("usage Pi_seq(N)"); end
+    flag=0;
+    [%H,%ierr] = evstr(string(N));
+    flag=flag | size(N,"*")<>1 | %ierr<>0;
+    flag=flag  |   fix(N)~=N   |           N<1;
+    if flag,   error("usage Pi_seq( <int> N>0, <char> mod==''s|r'' )"), end
 
-////////////////////////////////////
-// Results struct //
-////////////////////////////////////
-results.pi  =0;
-results.err =0;
-results.time=0;
+    ////////////////////////////////////
+    // Results struct //
+    ////////////////////////////////////
+    results.pi  =0;
+    results.err =0;
+    results.time=0;
 
-////////////////////////////
-// SEQUENTIAL // code, vectorized
-////////////////////////////
-//    T=clock; //
-////////////////////////////                   // vectorized code, equivalent to
+    ////////////////////////////
+    // SEQUENTIAL // code, vectorized
+    ////////////////////////////
+    //    T=clock; //
+    ////////////////////////////                       // vectorized code, equivalent to
     width=1/N; Sum=0;          // for i=0:N-1
     i=0:N-1;                   //   x=(i+0.5)*width;
     x=(i+0.5)*width;           //   Sum=Sum+4/(1+x^2);
     Sum=sum(4 ./ (1+x.^2));    // end
-    Sum      = Sum/N ;         // 1/N better at end: don't loose resolution
-//////////////////////////////////////////////////////////////////
-//results.time = etime(clock,T);       //
-//////////////////////////////////////////////////////////////////
-results.err  = Sum-%pi;
-results.pi   = Sum // ;
+    Sum      = Sum/N ;         // 1/N better at end: don't lose resolution
+    //////////////////////////////////////////////////////////////////
+    //results.time = etime(clock,T);   //
+    //////////////////////////////////////////////////////////////////
+    results.err  = Sum-%pi;
+    results.pi   = Sum // ;
 
 
-//////////////////////////////
-// FINAL CHECK //
-//////////////////////////////
-  if abs(results.err)>5E-10
-    warning("pretty nice pi value! go fix it")
-  end
-disp(results)
+    //////////////////////////////
+    // FINAL CHECK //
+    //////////////////////////////
+    if abs(results.err)>5E-10
+        warning("pretty nice pi value! go fix it")
+    end
+    disp(results)
 endfunction
 
 
index 111678e..5a1fd76 100644 (file)
 <?xml version="1.0" encoding="UTF-8"?>
 <refentry xmlns="http://docbook.org/ns/docbook" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:svg="http://www.w3.org/2000/svg" xmlns:ns4="http://www.w3.org/1999/xhtml" xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:db="http://docbook.org/ns/docbook" xmlns:scilab="http://www.scilab.org" xml:id="derivative" xml:lang="en">
-   <refnamediv>
-      <refname>derivative</refname>
-      <refpurpose>approximate derivatives of a function. <emphasis role="bold"> This function is obsolete. Please use the <link linkend="numderivative">numderivative</link> function instead.</emphasis></refpurpose>
-   </refnamediv>
-   <refsynopsisdiv>
-      <title>Calling Sequence</title>
-      <synopsis>
-         derivative(F,x)
-         [J [,H]] = derivative(F,x [,h ,order ,H_form ,Q])
-      </synopsis>
-   </refsynopsisdiv>
-   <refsection>
-      <title>Arguments</title>
-      <variablelist>
-         <varlistentry>
-            <term>F</term>
+    <refnamediv>
+        <refname>derivative</refname>
+        <refpurpose>
+            approximate derivatives of a function. 
+            <emphasis role="bold">
+                 This function is obsolete. Please use the <link linkend="numderivative">numderivative</link> function instead.
+            </emphasis>
+        </refpurpose>
+    </refnamediv>
+    <refsynopsisdiv>
+        <title>Calling Sequence</title>
+        <synopsis>
+            derivative(F,x)
+            [J [,H]] = derivative(F,x [,h ,order ,H_form ,Q])
+        </synopsis>
+    </refsynopsisdiv>
+    <refsection>
+        <title>Arguments</title>
+        <variablelist>
+            <varlistentry>
+                <term>F</term>
+                <listitem>
+                    <para>
+                        a Scilab function F: <literal>R^n --&gt; R^m</literal> or a
+                        <literal>list(F,p1,...,pk)</literal>, where F is a scilab function
+                        in the form <literal>y=F(x,p1,...,pk)</literal>, p1, ..., pk being
+                        any scilab objects (matrices, lists,...).
+                    </para>
+                </listitem>
+            </varlistentry>
+            <varlistentry>
+                <term>x</term>
+                <listitem>
+                    <para>real column vector of dimension n.</para>
+                </listitem>
+            </varlistentry>
+            <varlistentry>
+                <term>h</term>
+                <listitem>
+                    <para>
+                        (optional) real, the stepsize used in the finite difference
+                        approximations.
+                    </para>
+                </listitem>
+            </varlistentry>
+            <varlistentry>
+                <term>order</term>
+                <listitem>
+                    <para>
+                        (optional) integer, the order of the finite difference formula
+                        used to approximate the derivatives (order = 1,2 or 4, default is
+                        order=2 ).
+                    </para>
+                </listitem>
+            </varlistentry>
+            <varlistentry>
+                <term>H_form</term>
+                <listitem>
+                    <para>
+                        (optional) string, the form in which the Hessean will be
+                        returned. Possible forms are:
+                    </para>
+                    <variablelist>
+                        <varlistentry>
+                            <term>H_form='default'</term>
+                            <listitem>
+                                <para>
+                                    H is a m x (<literal>n^2</literal>) matrix ; in this
+                                    form, the k-th row of H corresponds to the Hessean of the k-th
+                                    component of F, given as the following row vector :
+                                </para>
+                                <informalequation>
+                                    <mediaobject>
+                                        <imageobject>
+                                            <imagedata align="center" fileref="../mml/derivative_equation_1.mml"/>
+                                        </imageobject>
+                                    </mediaobject>
+                                </informalequation>
+                                <para>((grad(F_k) being a row vector).</para>
+                            </listitem>
+                        </varlistentry>
+                        <varlistentry>
+                            <term>H_form='blockmat' :</term>
+                            <listitem>
+                                <para>
+                                    H is a (mxn) x n block matrix : the classic Hessean
+                                    matrices (of each component of F) are stacked by row (H = [H1
+                                    ; H2 ; ... ; Hm] in scilab syntax).
+                                </para>
+                            </listitem>
+                        </varlistentry>
+                        <varlistentry>
+                            <term>H_form='hypermat' :</term>
+                            <listitem>
+                                <para>
+                                    H is a n x n matrix for m=1, and a n x n x m hypermatrix
+                                    otherwise. H(:,:,k) is the classic Hessean matrix of the k-th
+                                    component of F.
+                                </para>
+                            </listitem>
+                        </varlistentry>
+                    </variablelist>
+                </listitem>
+            </varlistentry>
+            <varlistentry>
+                <term>Q</term>
+                <listitem>
+                    <para>
+                        (optional) real matrix, orthogonal (default is eye(n,n)). Q is added to have the possibility to remove
+                        the arbitrariness of using the canonical basis to approximate the derivatives of a function and it should be an
+                        orthogonal matrix. It is not mandatory but better to recover the derivative as you need the inverse matrix (and
+                        so simply Q' instead of inv(Q)).
+                    </para>
+                </listitem>
+            </varlistentry>
+            <varlistentry>
+                <term>J</term>
+                <listitem>
+                    <para>approximated Jacobian</para>
+                </listitem>
+            </varlistentry>
+            <varlistentry>
+                <term>H</term>
+                <listitem>
+                    <para>approximated Hessian</para>
+                </listitem>
+            </varlistentry>
+        </variablelist>
+    </refsection>
+    <refsection>
+        <title>Description</title>
+        <para>
+            Numerical approximation of the first and second derivatives of a
+            function F: <literal> R^n --&gt; R^m</literal> at the point x. The
+            Jacobian is computed by approximating the directional derivatives of the
+            components of F in the direction of the columns of Q. (For m=1, v=Q(:,k) :
+            grad(F(x))*v = Dv(F(x)).) The second derivatives are computed by
+            composition of first order derivatives. If H is given in its default form
+            the Taylor series of F(x) up to terms of second order is given by :
+        </para>
+        <informalequation>
+            <mediaobject>
+                <imageobject>
+                    <imagedata align="center" fileref="../mml/derivative_equation_2.mml"/>
+                </imageobject>
+            </mediaobject>
+        </informalequation>
+        <para>(([J,H]=derivative(F,x,H_form='default'), J=J(x), H=H(x).)</para>
+    </refsection>
+    <refsection>
+        <title>Performances</title>
+        <para>
+            If the problem is correctly scaled, increasing the accuracy reduces
+            the total error but requires more function evaluations.
+            The following list presents the number of function evaluations required to
+            compute the Jacobian depending on the order of the formula and the dimension of <literal>x</literal>,
+            denoted by <literal>n</literal>:
+        </para>
+        <itemizedlist>
             <listitem>
-               <para>
-                  a Scilab function F: <literal>R^n --&gt; R^m</literal> or a
-                  <literal>list(F,p1,...,pk)</literal>, where F is a scilab function
-                  in the form <literal>y=F(x,p1,...,pk)</literal>, p1, ..., pk being
-                  any scilab objects (matrices, lists,...).
-               </para>
+                <para>
+                    <literal>order=1</literal>, the number of function evaluations is <literal>n+1</literal>,
+                </para>
             </listitem>
-         </varlistentry>
-         <varlistentry>
-            <term>x</term>
             <listitem>
-               <para>real column vector of dimension n.</para>
+                <para>
+                    <literal>order=2</literal>, the number of function evaluations is <literal>2n</literal>,
+                </para>
             </listitem>
-         </varlistentry>
-         <varlistentry>
-            <term>h</term>
             <listitem>
-               <para>
-                  (optional) real, the stepsize used in the finite difference
-                  approximations.
-               </para>
+                <para>
+                    <literal>order=4</literal>, the number of function evaluations is <literal>4n</literal>.
+                </para>
             </listitem>
-         </varlistentry>
-         <varlistentry>
-            <term>order</term>
+        </itemizedlist>
+        <para>
+            Computing the Hessian matrix requires square the number of function evaluations,
+            as detailed in the following list.
+        </para>
+        <itemizedlist>
             <listitem>
-               <para>
-                  (optional) integer, the order of the finite difference formula
-                  used to approximate the derivatives (order = 1,2 or 4, default is
-                  order=2 ).
-               </para>
+                <para>
+                    <literal>order=1</literal>, the number of function evaluations is <literal>(n+1)^2</literal>,
+                </para>
             </listitem>
-         </varlistentry>
-         <varlistentry>
-            <term>H_form</term>
             <listitem>
-               <para>
-                  (optional) string, the form in which the Hessean will be
-                  returned. Possible forms are:
-               </para>
-               <variablelist>
-                  <varlistentry>
-                     <term>H_form='default'</term>
-                     <listitem>
-                        <para>
-                           H is a m x (<literal>n^2</literal>) matrix ; in this
-                           form, the k-th row of H corresponds to the Hessean of the k-th
-                           component of F, given as the following row vector :
-                        </para>
-                        <informalequation>
-                           <mediaobject>
-                              <imageobject>
-                                 <imagedata align="center" fileref="../mml/derivative_equation_1.mml"/>
-                              </imageobject>
-                           </mediaobject>
-                        </informalequation>
-                        <para>((grad(F_k) being a row vector).</para>
-                     </listitem>
-                  </varlistentry>
-                  <varlistentry>
-                     <term>H_form='blockmat' :</term>
-                     <listitem>
-                        <para>
-                           H is a (mxn) x n block matrix : the classic Hessean
-                           matrices (of each component of F) are stacked by row (H = [H1
-                           ; H2 ; ... ; Hm] in scilab syntax).
-                        </para>
-                     </listitem>
-                  </varlistentry>
-                  <varlistentry>
-                     <term>H_form='hypermat' :</term>
-                     <listitem>
-                        <para>
-                           H is a n x n matrix for m=1, and a n x n x m hypermatrix
-                           otherwise. H(:,:,k) is the classic Hessean matrix of the k-th
-                           component of F.
-                        </para>
-                     </listitem>
-                  </varlistentry>
-               </variablelist>
+                <para>
+                    <literal>order=2</literal>, the number of function evaluations is <literal>4n^2</literal>,
+                </para>
             </listitem>
-         </varlistentry>
-         <varlistentry>
-            <term>Q</term>
             <listitem>
-               <para>
-                  (optional) real matrix, orthogonal (default is eye(n,n)). Q is added to have the possibility to remove
-                  the arbitrariness of using the canonical basis to approximate the derivatives of a function and it should be an
-                  orthogonal matrix. It is not mandatory but better to recover the derivative as you need the inverse matrix (and
-                  so simply Q' instead of inv(Q)).
-               </para>
+                <para>
+                    <literal>order=4</literal>, the number of function evaluations is <literal>16n^2</literal>.
+                </para>
             </listitem>
-         </varlistentry>
-         <varlistentry>
-            <term>J</term>
-            <listitem>
-               <para>approximated Jacobian</para>
-            </listitem>
-         </varlistentry>
-         <varlistentry>
-            <term>H</term>
-            <listitem>
-               <para>approximated Hessian</para>
-            </listitem>
-         </varlistentry>
-      </variablelist>
-   </refsection>
-   <refsection>
-      <title>Description</title>
-      <para>
-         Numerical approximation of the first and second derivatives of a
-         function F: <literal> R^n --&gt; R^m</literal> at the point x. The
-         Jacobian is computed by approximating the directional derivatives of the
-         components of F in the direction of the columns of Q. (For m=1, v=Q(:,k) :
-         grad(F(x))*v = Dv(F(x)).) The second derivatives are computed by
-         composition of first order derivatives. If H is given in its default form
-         the Taylor series of F(x) up to terms of second order is given by :
-      </para>
-      <informalequation>
-         <mediaobject>
-            <imageobject>
-               <imagedata align="center" fileref="../mml/derivative_equation_2.mml"/>
-            </imageobject>
-         </mediaobject>
-      </informalequation>
-      <para>(([J,H]=derivative(F,x,H_form='default'), J=J(x), H=H(x).)</para>
-   </refsection>
-   <refsection>
-      <title>Performances</title>
-      <para>
-         If the problem is correctly scaled, increasing the accuracy reduces
-         the total error but requires more function evaluations.
-         The following list presents the number of function evaluations required to
-         compute the Jacobian depending on the order of the formula and the dimension of <literal>x</literal>,
-         denoted by <literal>n</literal>:
-      </para>
-      <itemizedlist>
-         <listitem>
-            <para>
-               <literal>order=1</literal>, the number of function evaluations is <literal>n+1</literal>,
-            </para>
-         </listitem>
-         <listitem>
-            <para>
-               <literal>order=2</literal>, the number of function evaluations is <literal>2n</literal>,
-            </para>
-         </listitem>
-         <listitem>
-            <para>
-               <literal>order=4</literal>, the number of function evaluations is <literal>4n</literal>.
-            </para>
-         </listitem>
-      </itemizedlist>
-      <para>
-         Computing the Hessian matrix requires square the number of function evaluations,
-         as detailed in the following list.
-      </para>
-      <itemizedlist>
-         <listitem>
-            <para>
-               <literal>order=1</literal>, the number of function evaluations is <literal>(n+1)^2</literal>,
-            </para>
-         </listitem>
-         <listitem>
-            <para>
-               <literal>order=2</literal>, the number of function evaluations is <literal>4n^2</literal>,
-            </para>
-         </listitem>
-         <listitem>
-            <para>
-               <literal>order=4</literal>, the number of function evaluations is <literal>16n^2</literal>.
-            </para>
-         </listitem>
-      </itemizedlist>
-   </refsection>
-   <refsection>
-      <title>Remarks</title>
-      <para>
-         The step size h must be small to get a low error but if it is too
-         small floating point errors will dominate by cancellation. As a rule of
-         thumb, do not change the default step size. To work around numerical
-         difficulties one may also change the order and/or choose different
-         orthogonal matrices Q (the default is eye(n,n)), especially if the
-         approximate derivatives are used in optimization routines. All the
-         optional arguments may also be passed as named arguments, so that one can
-         use calls in the form :
-      </para>
-      <programlisting>
-         <![CDATA[
+        </itemizedlist>
+    </refsection>
+    <refsection>
+        <title>Remarks</title>
+        <para>
+            The step size h must be small to get a low error but if it is too
+            small floating point errors will dominate by cancellation. As a rule of
+            thumb, do not change the default step size. To work around numerical
+            difficulties one may also change the order and/or choose different
+            orthogonal matrices Q (the default is eye(n,n)), especially if the
+            approximate derivatives are used in optimization routines. All the
+            optional arguments may also be passed as named arguments, so that one can
+            use calls in the form :
+        </para>
+        <programlisting>
+            <![CDATA[
          derivative(F, x, H_form = "hypermat")
          derivative(F, x, order = 4) etc.
          ]]>
-      </programlisting>
-   </refsection>
-   <refsection>
-      <title>Examples</title>
-      <programlisting role="example">
-         <![CDATA[
+        </programlisting>
+    </refsection>
+    <refsection>
+        <title>Examples</title>
+        <programlisting role="example">
+            <![CDATA[
          function y=F(x)
          y=[sin(x(1)*x(2))+exp(x(2)*x(3)+x(1)) ; sum(x.^3)];
          endfunction
 
-         function y=G(x,p) 
+         function y=G(x,p)
          y=[sin(x(1)*x(2)*p)+exp(x(2)*x(3)+x(1)) ; sum(x.^3)];
          endfunction
 
          [J,H]=derivative(F,x,H_form='blockmat')
 
          n=3;
-         // form an orthogonal matrix :   
+         // form an orthogonal matrix :
          Q = qr(rand(n,n))
          // Test order 1, 2 and 4 formulas.
          for i=[1,2,4]
 
          // A trivial example
          function y=f(x,A,p,w)
-         y=x'*A*x+p'*x+w; 
+         y=x'*A*x+p'*x+w;
          endfunction
          // with Jacobian and Hessean given by J(x)=x'*(A+A')+p', and H(x)=A+A'.
-         A = rand(3,3); 
-         p = rand(3,1); 
+         A = rand(3,3);
+         p = rand(3,1);
          w = 1;
          x = rand(3,1);
          [J,H]=derivative(list(f,A,p,w),x,h=1,H_form='blockmat')
 
          // Since f(x) is quadratic in x, approximate derivatives of order=2 or 4 by finite
          // differences should be exact for all h~=0. The apparent errors are caused by
-         // cancellation in the floating point operations, so a "big" h is choosen.
+         // cancellation in the floating point operations, so a "big" h is chosen.
          // Comparison with the exact matrices:
          Je = x'*(A+A')+p'
          He = A+A'
          clean(Je - J)
          clean(He - H)
          ]]>
-      </programlisting>
-   </refsection>
-   <refsection>
-      <title>Accuracy issues</title>
-      <para>
-         The <literal>derivative</literal> function uses the same step <literal>h</literal>
-         whatever the direction and whatever the norm of <literal>x</literal>.
-         This may lead to a poor scaling with respect to <literal>x</literal>.
-         An accurate scaling of the step is not possible without many evaluations
-         of the function. Still, the user has the possibility to compare the results
-         produced by the <literal>derivative</literal> and the <literal>numdiff</literal>
-         functions. Indeed, the <literal>numdiff</literal> function scales the
-         step depending on the absolute value of <literal>x</literal>.
-         This scaling may produce more accurate results, especially if
-         the magnitude of <literal>x</literal> is large.
-      </para>
-      <para>
-         In the following Scilab script, we compute the derivative of an
-         univariate quadratic function. The exact derivative can be
-         computed analytically and the relative error is computed.
-         In this rather extreme case, the <literal>derivative</literal> function
-         produces no significant digits, while the <literal>numdiff</literal>
-         function produces 6 significant digits.
-      </para>
-      <programlisting role="example">
-         <![CDATA[
+        </programlisting>
+    </refsection>
+    <refsection>
+        <title>Accuracy issues</title>
+        <para>
+            The <literal>derivative</literal> function uses the same step <literal>h</literal>
+            whatever the direction and whatever the norm of <literal>x</literal>.
+            This may lead to a poor scaling with respect to <literal>x</literal>.
+            An accurate scaling of the step is not possible without many evaluations
+            of the function. Still, the user has the possibility to compare the results
+            produced by the <literal>derivative</literal> and the <literal>numdiff</literal>
+            functions. Indeed, the <literal>numdiff</literal> function scales the
+            step depending on the absolute value of <literal>x</literal>.
+            This scaling may produce more accurate results, especially if
+            the magnitude of <literal>x</literal> is large.
+        </para>
+        <para>
+            In the following Scilab script, we compute the derivative of an
+            univariate quadratic function. The exact derivative can be
+            computed analytically and the relative error is computed.
+            In this rather extreme case, the <literal>derivative</literal> function
+            produces no significant digits, while the <literal>numdiff</literal>
+            function produces 6 significant digits.
+        </para>
+        <programlisting role="example">
+            <![CDATA[
          // Difference between derivative and numdiff when x is large
          function y = myfunction (x)
          y = x*x;
          e = abs(fp-fe)/fe;
          mprintf("Relative error with numdiff: %e\n",e)
          ]]>
-      </programlisting>
-      <para>
-         The previous script produces the following output.
-      </para>
-      <programlisting role="example">
-         <![CDATA[
+        </programlisting>
+        <para>
+            The previous script produces the following output.
+        </para>
+        <programlisting role="example">
+            <![CDATA[
          Relative error with derivative: 1.000000e+000
          Relative error with numdiff: 7.140672e-006
          ]]>
-      </programlisting>
-      <para>
-         In a practical situation, we may not know what is the correct numerical
-         derivative. Still, we are warned that the numerical derivatives
-         should be used with caution in this specific case.
-      </para>
-   </refsection>
-   <refsection role="see also">
-      <title>See Also</title>
-      <simplelist type="inline">
-         <member>
-            <link linkend="interp">interp</link>
-         </member>
-         <member>
-            <link linkend="interp2d">interp2d</link>
-         </member>
-         <member>
-            <link linkend="splin">splin</link>
-         </member>
-         <member>
-            <link linkend="eval_cshep2d">eval_cshep2d</link>
-         </member>
-         <member>
-            <link linkend="diff">diff</link>
-         </member>
-         <member>
-            <link linkend="numdiff">numdiff</link>
-         </member>
-         <member>
-            <link linkend="derivat">derivat</link>
-         </member>
-         <member>
-            <link linkend="numderivative">numderivative</link>
-         </member>
-      </simplelist>
-      </refsection>  <refsection>
-      <title>History</title>
-      <revhistory>
-         <revision>
-            <revnumber>5.5.0</revnumber>
-            <revremark>Tagged as obsolete. Will be removed in Scilab 6.0.0.</revremark>
-         </revision>
-      </revhistory>
-   </refsection>
-   <refsection>
-      <title>Appendix</title>
-      <para>
-         We now discuss how a script using the <literal>derivative</literal> function can be
-         updated to use the <literal>numderivative</literal> function.
-      </para>
-      <para>
-         Consider the function:
-      </para>
-      <programlisting role="example">
-         <![CDATA[
+        </programlisting>
+        <para>
+            In a practical situation, we may not know what is the correct numerical
+            derivative. Still, we are warned that the numerical derivatives
+            should be used with caution in this specific case.
+        </para>
+    </refsection>
+    <refsection role="see also">
+        <title>See Also</title>
+        <simplelist type="inline">
+            <member>
+                <link linkend="interp">interp</link>
+            </member>
+            <member>
+                <link linkend="interp2d">interp2d</link>
+            </member>
+            <member>
+                <link linkend="splin">splin</link>
+            </member>
+            <member>
+                <link linkend="eval_cshep2d">eval_cshep2d</link>
+            </member>
+            <member>
+                <link linkend="diff">diff</link>
+            </member>
+            <member>
+                <link linkend="numdiff">numdiff</link>
+            </member>
+            <member>
+                <link linkend="derivat">derivat</link>
+            </member>
+            <member>
+                <link linkend="numderivative">numderivative</link>
+            </member>
+        </simplelist>
+    </refsection>
+     <refsection>
+        <title>History</title>
+        <revhistory>
+            <revision>
+                <revnumber>5.5.0</revnumber>
+                <revremark>Tagged as obsolete. Will be removed in Scilab 6.0.0.</revremark>
+            </revision>
+        </revhistory>
+    </refsection>
+    <refsection>
+        <title>Appendix</title>
+        <para>
+            We now discuss how a script using the <literal>derivative</literal> function can be
+            updated to use the <literal>numderivative</literal> function.
+        </para>
+        <para>
+            Consider the function:
+        </para>
+        <programlisting role="example">
+            <![CDATA[
          function y = F(x)
          f1 = sin(x(1)*x(2)) + exp(x(2)*x(3)+x(1))
          f2 = sum(x.^3)
          y = [f1 ; f2];
          endfunction
          ]]>
-      </programlisting>
-      <para>
-         and the point:
-      </para>
-      <programlisting role="example">
-         <![CDATA[
+        </programlisting>
+        <para>
+            and the point:
+        </para>
+        <programlisting role="example">
+            <![CDATA[
          x = [1 ; 2 ; 3];
          ]]>
-      </programlisting>
-      <para>
-         Therefore, the statement:
-      </para>
-      <programlisting role="example">
-         <![CDATA[
+        </programlisting>
+        <para>
+            Therefore, the statement:
+        </para>
+        <programlisting role="example">
+            <![CDATA[
          [J, H] = derivative(F, x)
          ]]>
-      </programlisting>
-      <para>
-         can be replaced with
-      </para>
-      <programlisting role="example">
-         <![CDATA[
+        </programlisting>
+        <para>
+            can be replaced with
+        </para>
+        <programlisting role="example">
+            <![CDATA[
          [J, H] = numderivative(F, x)
          ]]>
-      </programlisting>
-      <para>
-         The statement:
-      </para>
-      <programlisting role="example">
-         <![CDATA[
+        </programlisting>
+        <para>
+            The statement:
+        </para>
+        <programlisting role="example">
+            <![CDATA[
          [J, H] = derivative(F, x, order=4)
          ]]>
-      </programlisting>
-      <para>
-         can be replaced by:
-      </para>
-      <programlisting role="example">
-         <![CDATA[
+        </programlisting>
+        <para>
+            can be replaced by:
+        </para>
+        <programlisting role="example">
+            <![CDATA[
          [J, H] = numderivative(F, x, [], 4)
          ]]>
-      </programlisting>
-      <para>
-         The statement:
-      </para>
-      <programlisting role="example">
-         <![CDATA[
+        </programlisting>
+        <para>
+            The statement:
+        </para>
+        <programlisting role="example">
+            <![CDATA[
          [J, H] = derivative(F, x, H_form="blockmat")
          ]]>
-      </programlisting>
-      <para>
-         can be replaced by:
-      </para>
-      <programlisting role="example">
-         <![CDATA[
+        </programlisting>
+        <para>
+            can be replaced by:
+        </para>
+        <programlisting role="example">
+            <![CDATA[
          [J, H] = numderivative(F, x, [], [], "blockmat")
          ]]>
-      </programlisting>
-      <para>
-         We emphasize that <literal>numderivative</literal> and <literal>derivative</literal> do not
-         use the same strategy for the choice of the default step <literal>h</literal>.
-         Hence, in general, the functions <literal>numderivative</literal> and <literal>derivative</literal>
-         will not produce exactly the same outputs.
-         Still, in general, we expect that <literal>numderivative</literal> is more accurate.
-         It is not easy to get the same step in <literal>numderivative</literal> as in <literal>derivative</literal>,
-         because the choice of the step depends on the degree of
-         differenciation (Jacobian or Hessian) and the order of the formula.
-      </para>
-   </refsection>
+        </programlisting>
+        <para>
+            We emphasize that <literal>numderivative</literal> and <literal>derivative</literal> do not
+            use the same strategy for the choice of the default step <literal>h</literal>.
+            Hence, in general, the functions <literal>numderivative</literal> and <literal>derivative</literal>
+            will not produce exactly the same outputs.
+            Still, in general, we expect that <literal>numderivative</literal> is more accurate.
+            It is not easy to get the same step in <literal>numderivative</literal> as in <literal>derivative</literal>,
+            because the choice of the step depends on the degree of
+            differenciation (Jacobian or Hessian) and the order of the formula.
+        </para>
+    </refsection>
 </refentry>
index fc987e0..18d80a5 100644 (file)
@@ -10,7 +10,7 @@
  * 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
- * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
+ * http://www.cecill.info/licences/Licence_CeCILL_V2.1-en.txt
  *
  -->
 <refentry version="5.0-subset Scilab"
index 92329b4..488c102 100644 (file)
@@ -11,7 +11,7 @@
  * 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
- * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
+ * http://www.cecill.info/licences/Licence_CeCILL_V2.1-en.txt
  *
  -->
 <refentry version="5.0-subset Scilab"
index 6ca721a..14485a8 100644 (file)
@@ -8,7 +8,7 @@
 // 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
-// http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
+// http://www.cecill.info/licences/Licence_CeCILL_V2.1-en.txt
 
 function [J, H] = numderivative(varargin)
     //
index a5e6969..71ae263 100644 (file)
@@ -117,7 +117,7 @@ function [x,y,typ]=MBLOCK(job,arg1,arg2)
             funam=stripblanks(Tfunam)","errcatch")
 
             if ierr<>0 then
-                //You loose ! Try again ! Insert coin !
+                //You lose! Try again! Insert coin!
                 //messagebox("Error, try again please!","modal","error");
                 messagebox("Error in evaluation of variables.","modal","error");
                 ok=%f
index d16f36b..a249e9b 100644 (file)
@@ -118,7 +118,7 @@ function [x,y,typ]=MPBLOCK(job,arg1,arg2)
             funam=stripblanks(Tfunam)","errcatch")
 
             if ierr<>0 then
-                //You loose ! Try again ! Insert coin !
+                //You lose! Try again! Insert coin!
                 //x_message("Error, try again please!")
                 x_message("Error in evaluation of variables.")
                 ok=%f
index b896681..ef190f8 100644 (file)
@@ -3,7 +3,7 @@
 <properties>
     <comment>
         Map between action and keys
-        If no path is given, org.scilab.modules.scinotes.actions will be choosen
+        If no path is given, org.scilab.modules.scinotes.actions will be chosen
     </comment>
     
     <entry key="ActivateHelpOnTypingForOpenersAction">OSSCKEY H</entry>
index ee1fdfe..d55b8ae 100644 (file)
@@ -36,7 +36,7 @@ function demo_conv2()
     a=gca();a.margins=[0 0 0.125 0]
     a.tight_limits="on";
     a.axes_visible="off";
-    title("Blured  image")
+    title("Blurred  image")
     drawnow()
 endfunction
 demo_conv2()
index 7eacdac..f0026da 100644 (file)
@@ -135,7 +135,7 @@ int spcColExchange( MatrixPtr Matrix, int Col1, int Col2 );
  *      performance on matrices where growth is low, as is often the
  *      case with ill-conditioned matrices.  Once a valid threshold is
  *      given, it becomes the new default.  The default value of
- *      RelThreshold was choosen for use with nearly diagonally
+ *      RelThreshold was chosen for use with nearly diagonally
  *      dominant matrices such as node- and modified-node admittance
  *      matrices.  For these matrices it is usually best to use
  *      diagonal pivoting.  For matrices without a strong diagonal, it
index 80cace7..8b64280 100644 (file)
@@ -597,7 +597,7 @@ sfAdd4Complex( long Template[4], RealNumber *Real, RealNumber *Imag )
  *      performance on matrices where growth is low, as is often the
  *      case with ill-conditioned matrices.  Once a valid threshold is
  *      given, it becomes the new default.  The default value of
- *      RelThreshold was choosen for use with nearly diagonally
+ *      RelThreshold was chosen for use with nearly diagonally
  *      dominant matrices such as node- and modified-node admittance
  *      matrices.  For these matrices it is usually best to use
  *      diagonal pivoting.  For matrices without a strong diagonal, it
index ce289e6..d36cf6d 100644 (file)
@@ -7,7 +7,7 @@
 * 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
-* http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
+* http://www.cecill.info/licences/Licence_CeCILL_V2.1-en.txt
 *
 -->
 <refentry xmlns="http://docbook.org/ns/docbook" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:svg="http://www.w3.org/2000/svg" xmlns:ns5="http://www.w3.org/1999/xhtml" xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:db="http://docbook.org/ns/docbook" xmlns:scilab="http://www.scilab.org" xml:id="htmlDump" xml:lang="en">
index edfa50e..790caa2 100644 (file)
@@ -7,7 +7,7 @@
 * 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
-* http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
+* http://www.cecill.info/licences/Licence_CeCILL_V2.1-en.txt
 *
 -->
 <refentry xmlns="http://docbook.org/ns/docbook" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:svg="http://www.w3.org/2000/svg" xmlns:ns5="http://www.w3.org/1999/xhtml" xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:db="http://docbook.org/ns/docbook" xmlns:scilab="http://www.scilab.org" xml:id="htmlRead" xml:lang="en">
index 0e99556..df54bf7 100644 (file)
@@ -7,7 +7,7 @@
 * 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
-* http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
+* http://www.cecill.info/licences/Licence_CeCILL_V2.1-en.txt
 *
 -->
 <refentry xmlns="http://docbook.org/ns/docbook" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:svg="http://www.w3.org/2000/svg" xmlns:ns5="http://www.w3.org/1999/xhtml" xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:db="http://docbook.org/ns/docbook" xmlns:scilab="http://www.scilab.org" xml:id="htmlReadStr" xml:lang="en">
index d5a7af9..677686d 100644 (file)
@@ -7,7 +7,7 @@
 * 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
-* http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
+* http://www.cecill.info/licences/Licence_CeCILL_V2.1-en.txt
 *
 -->
 <refentry xmlns="http://docbook.org/ns/docbook" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:svg="http://www.w3.org/2000/svg" xmlns:ns5="http://www.w3.org/1999/xhtml" xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:db="http://docbook.org/ns/docbook" xmlns:scilab="http://www.scilab.org" xml:id="htmlWrite" xml:lang="en">
index b0dddf0..53f3c90 100644 (file)
@@ -6,7 +6,7 @@
  * 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
- * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
+ * http://www.cecill.info/licences/Licence_CeCILL_V2.1-en.txt
  *
  */
 
@@ -105,7 +105,7 @@ int sci_htmlDump(char *fname, unsigned long fname_len)
 
     if (clines.size())
     {
-        err = createMatrixOfString(pvApiCtx, Rhs + 1, (int)lines.size(), 1, const_cast < const char *const *>(&(clines[0])));
+        err = createMatrixOfString(pvApiCtx, Rhs + 1, (int)lines.size(), 1, const_cast < const char * const *>(&(clines[0])));
     }
     else
     {
index 00e064d..51293a1 100644 (file)
@@ -6,7 +6,7 @@
  * 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
- * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
+ * http://www.cecill.info/licences/Licence_CeCILL_V2.1-en.txt
  *
  */
 
index a11be80..3cf2249 100644 (file)
@@ -6,7 +6,7 @@
  * 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
- * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
+ * http://www.cecill.info/licences/Licence_CeCILL_V2.1-en.txt
  *
  */
 
index 16d7445..f20760a 100644 (file)
@@ -6,7 +6,7 @@
  * 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
- * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
+ * http://www.cecill.info/licences/Licence_CeCILL_V2.1-en.txt
  *
  */