bug 3842 fix and extension of sum, cumsum, prod cumprod to all relevant datatypes 70/1270/3
Serge Steer [Wed, 7 Jul 2010 16:51:45 +0000 (18:51 +0200)]
Change-Id: I93b5c85735955fe6396f50a717ff33f1e9b5afc3

71 files changed:
scilab/CHANGES_5.3.X
scilab/modules/compatibility_functions/macros/%b_cumprod.sci [new file with mode: 0644]
scilab/modules/compatibility_functions/macros/%b_cumsum.sci [new file with mode: 0644]
scilab/modules/compatibility_functions/macros/%b_prod.sci
scilab/modules/compatibility_functions/macros/%b_sum.sci
scilab/modules/elementary_functions/help/en_US/cumprod.xml
scilab/modules/elementary_functions/help/en_US/cumsum.xml
scilab/modules/elementary_functions/help/en_US/prod.xml
scilab/modules/elementary_functions/help/en_US/sum.xml
scilab/modules/elementary_functions/help/fr_FR/cumprod.xml
scilab/modules/elementary_functions/help/fr_FR/cumsum.xml
scilab/modules/elementary_functions/help/fr_FR/prod.xml
scilab/modules/elementary_functions/help/fr_FR/sum.xml [new file with mode: 0644]
scilab/modules/elementary_functions/sci_gateway/fortran/sci_f_cumprod.f
scilab/modules/elementary_functions/sci_gateway/fortran/sci_f_cumsum.f
scilab/modules/elementary_functions/sci_gateway/fortran/sci_f_prod.f
scilab/modules/elementary_functions/sci_gateway/fortran/sci_f_sum.f
scilab/modules/elementary_functions/src/fortran/getorient.f
scilab/modules/elementary_functions/tests/unit_tests/cumprod.dia.ref [new file with mode: 0644]
scilab/modules/elementary_functions/tests/unit_tests/cumprod.tst [new file with mode: 0644]
scilab/modules/elementary_functions/tests/unit_tests/cumsum.dia.ref [new file with mode: 0644]
scilab/modules/elementary_functions/tests/unit_tests/cumsum.tst [new file with mode: 0644]
scilab/modules/elementary_functions/tests/unit_tests/prod.dia.ref [new file with mode: 0644]
scilab/modules/elementary_functions/tests/unit_tests/prod.tst [new file with mode: 0644]
scilab/modules/elementary_functions/tests/unit_tests/sum.dia.ref [new file with mode: 0644]
scilab/modules/elementary_functions/tests/unit_tests/sum.tst [new file with mode: 0644]
scilab/modules/integer/includes/gencuprod.h
scilab/modules/integer/includes/gencusum.h
scilab/modules/integer/includes/genmcuprod.h
scilab/modules/integer/includes/genmcusum.h
scilab/modules/integer/includes/genmprod.h
scilab/modules/integer/includes/genmsum.h
scilab/modules/integer/includes/genprod.h
scilab/modules/integer/includes/gensum.h
scilab/modules/integer/src/c/gencuprod.c
scilab/modules/integer/src/c/gencusum.c
scilab/modules/integer/src/c/genmcuprod.c
scilab/modules/integer/src/c/genmcusum.c
scilab/modules/integer/src/c/genmprod.c
scilab/modules/integer/src/c/genmsum.c
scilab/modules/integer/src/c/genmsum_double.c [new file with mode: 0644]
scilab/modules/integer/src/c/genprod.c
scilab/modules/integer/src/c/gensum.c
scilab/modules/integer/src/c/gensum_double.c [new file with mode: 0644]
scilab/modules/integer/src/fortran/i_cumprod.f
scilab/modules/integer/src/fortran/i_cumsum.f
scilab/modules/integer/src/fortran/i_prod.f
scilab/modules/integer/src/fortran/i_sum.f
scilab/modules/integer/tests/nonreg_tests/bug_3842.dia.ref [new file with mode: 0644]
scilab/modules/integer/tests/nonreg_tests/bug_3842.tst [new file with mode: 0644]
scilab/modules/overloading/macros/%hm_cumprod.sci
scilab/modules/overloading/macros/%hm_cumsum.sci
scilab/modules/overloading/macros/%hm_prod.sci
scilab/modules/overloading/macros/%hm_sum.sci
scilab/modules/overloading/macros/%p_cumprod.sci [new file with mode: 0644]
scilab/modules/overloading/macros/%p_cumsum.sci [new file with mode: 0644]
scilab/modules/overloading/macros/%p_prod.sci
scilab/modules/overloading/macros/%p_sum.sci
scilab/modules/overloading/macros/%r_cumprod.sci [new file with mode: 0644]
scilab/modules/overloading/macros/%r_prod.sci [new file with mode: 0644]
scilab/modules/overloading/macros/%r_sum.sci [new file with mode: 0644]
scilab/modules/overloading/macros/%sp_cumprod.sci [new file with mode: 0644]
scilab/modules/overloading/macros/%sp_cumsum.sci [new file with mode: 0644]
scilab/modules/overloading/macros/%sp_prod.sci [new file with mode: 0644]
scilab/modules/overloading/macros/%sp_sum.sci
scilab/modules/overloading/macros/%spb_cumprod.sci [new file with mode: 0644]
scilab/modules/overloading/macros/%spb_cumsum.sci [new file with mode: 0644]
scilab/modules/overloading/macros/%spb_prod.sci [new file with mode: 0644]
scilab/modules/overloading/macros/%spb_sum.sci [new file with mode: 0644]
scilab/modules/polynomials/sci_gateway/fortran/sci_f_prod.f
scilab/modules/polynomials/sci_gateway/fortran/sci_f_sum.f

index 89f1abe..06c6ec6 100644 (file)
@@ -41,6 +41,8 @@ subwindow is not docked.
 
 Bug Fixes:
 ==========
+* bug 3842 fixed - "native" and "double" evaluation mode added to the sum, 
+                   cumsum, prod and cumprod functions
 
 * bug 4370 fixed - Help page for alufunction, figure_properties was not
                    up-to-date and the help page for pixel_drawing_mode was missing.
diff --git a/scilab/modules/compatibility_functions/macros/%b_cumprod.sci b/scilab/modules/compatibility_functions/macros/%b_cumprod.sci
new file mode 100644 (file)
index 0000000..1c17334
--- /dev/null
@@ -0,0 +1,62 @@
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2010 -  INRIA - Serge Steer 
+// 
+// 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    
+// http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
+
+function a=%b_cumprod(varargin)
+  if varargin($)=='native' then
+    if size(varargin)==2 then
+      d='*'
+    elseif size(varargin)==3 then 
+      d=varargin(2)
+    end
+    if size(d,'*')<>1 then 
+      if type(d)==10 then
+        error(msprintf(_("%s: Wrong size for input argument #%d: A string expected.\n"),"cumprod",2))
+      else
+        error(msprintf(_("%s: Wrong size for input argument #%d: A scalar expected.\n"),"cumprod",2))
+      end
+    end
+    a=varargin(1)
+    if type(d)==10 then
+      d=find(d==['m','*','r','c'])
+      if d==[] then
+        error(msprintf(_("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"),..
+                       "cumprod",2,"""*"",""r"",""c"",""m"",1:"+string(ndims(a))))
+      end
+      d=d-2
+    end
+    dims=size(a);
+    
+    if d==-1 then //'m'
+      d=find(dims>1,1)
+      if d==[] then d=0,end
+    end
+    if d<0 then
+      error(msprintf(_("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"),..
+                     "cumprod",2,"""*"",""r"",""c"",""m"",1:"+string(ndims(a))))
+    end
+    select d
+    case 0 then
+      k=find(~a,1)
+      if k<>[] then a(k:$)=%f,end
+    case 1 then
+      for k=1:dims(2)
+        a(:,k)=cumprod(a(:,k),'native')
+      end
+    case 2 then
+      for k=1:dims(1)
+        a(k,:)=cumprod(a(k,:),'native')
+      end
+    else
+      a=a
+    end    
+  else
+    varargin(1)=bool2s(varargin(1))
+    a=cumprod(varargin(:))
+  end
+endfunction
diff --git a/scilab/modules/compatibility_functions/macros/%b_cumsum.sci b/scilab/modules/compatibility_functions/macros/%b_cumsum.sci
new file mode 100644 (file)
index 0000000..3c48b17
--- /dev/null
@@ -0,0 +1,62 @@
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2010 -  INRIA - Serge Steer 
+// 
+// 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    
+// http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
+
+function a=%b_cumsum(varargin)
+  if varargin($)=='native' then
+    if size(varargin)==2 then
+      d='*'
+    elseif size(varargin)==3 then 
+      d=varargin(2)
+    end
+    if size(d,'*')<>1 then 
+      if type(d)==10 then
+        error(msprintf(_("%s: Wrong size for input argument #%d: A string expected.\n"),"cumsum",2))
+      else
+        error(msprintf(_("%s: Wrong size for input argument #%d: A scalar expected.\n"),"cumsum",2))
+      end
+    end
+    a=varargin(1)
+    if type(d)==10 then
+      d=find(d==['m','*','r','c'])
+      if d==[] then
+        error(msprintf(_("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"),..
+                       "cumsum",2,"""*"",""r"",""c"",""m"",1:"+string(ndims(a))))
+      end
+      d=d-2
+    end
+    dims=size(a);
+    
+    if d==-1 then //'m'
+      d=find(dims>1,1)
+      if d==[] then d=0,end
+    end
+    if d<0 then
+      error(msprintf(_("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"),..
+                     "cumsum",2,"""*"",""r"",""c"",""m"",1:"+string(ndims(a))))
+    end
+    select d
+    case 0 then
+      k=find(a,1)
+      if k<>[] then a(k:$)=%t,end
+    case 1 then
+      for k=1:dims(2)
+        a(:,k)=cumsum(a(:,k),'native')
+      end
+    case 2 then
+      for k=1:dims(1)
+        a(k,:)=cumsum(a(k,:),'native')
+      end
+    else
+      a=a
+    end
+  else
+    varargin(1)=bool2s(varargin(1))
+    a=cumsum(varargin(:))
+  end
+endfunction
index a0cc992..cae9816 100644 (file)
@@ -8,6 +8,14 @@
 // http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
 
 function r=%b_prod(varargin)
-varargin(1)=bool2s(varargin(1))
-r=prod(varargin(:))
+  if varargin($)=='native' then
+    if size(varargin)==3&type(varargin(2))==1&varargin(2)>2 then
+      r=varargin(1)
+    else 
+      r=and(varargin(1:$-1))
+    end
+  else
+    varargin(1)=bool2s(varargin(1))
+    r=prod(varargin(:))
+  end
 endfunction
index be2549e..2c43f3a 100644 (file)
@@ -8,6 +8,14 @@
 // http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
 
 function r=%b_sum(varargin)
-varargin(1)=bool2s(varargin(1))
-r=sum(varargin(:))
+  if varargin($)=='native' then
+    if size(varargin)==3&type(varargin(2))==1&varargin(2)>2 then
+      r=varargin(1)
+    else      
+      r=or(varargin(1:$-1))
+    end
+  else
+    varargin(1)=bool2s(varargin(1))
+    r=sum(varargin(:))
+  end
 endfunction
index bdeda2b..a56fedf 100644 (file)
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!--
  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
- * Copyright (C) 2008 - INRIA
+ * Copyright (C) 2010 - Serge Steer - INRIA
  * 
  * This file must be used under the terms of the CeCILL.
  * This source file is licensed as described in the file COPYING, which
   <refnamediv>
     <refname>cumprod</refname>
 
-    <refpurpose>cumulative product</refpurpose>
+    <refpurpose>cumulative product of array elements</refpurpose>
   </refnamediv>
 
   <refsynopsisdiv>
     <title>Calling Sequence</title>
 
     <synopsis>y=cumprod(x)
-y=cumprod(x,'r') or y=cumprod(x,1)
-y=cumprod(x,'c') or y=cumprod(x,2)
-y=cumprod(x,'m')</synopsis>
+    y=cumprod(x,orientation)
+    y=cumprod(x,outtype)
+    y=cumprod(x,orientation,outtype)
+    </synopsis>
   </refsynopsisdiv>
 
   <refsection>
@@ -44,7 +45,33 @@ y=cumprod(x,'m')</synopsis>
         <term>x</term>
 
         <listitem>
-          <para>vector or matrix (real or complex)</para>
+          <para>
+            an array of  reals, complex, booleans,  polynomials or
+            rational fractions.
+          </para>
+        </listitem>
+      </varlistentry>
+      <varlistentry>
+        <term>orientation</term>
+        <listitem>
+          <para>
+            it can be either </para>
+            <itemizedlist>
+              <listitem>
+                <para>a string with possible values <literal>"*"</literal>, <literal>"r"</literal>, 
+                <literal>"c"</literal> or  <literal>"m"</literal></para>
+              </listitem>
+              <listitem>
+                <para>a number with positive integer value</para>
+              </listitem>
+          </itemizedlist>
+        </listitem>
+      </varlistentry>
+      <varlistentry>
+        <term>outtype</term>
+        <listitem>
+          <para>
+            a string with possible values <literal>"native"</literal> or <literal>"double"</literal>. </para>
         </listitem>
       </varlistentry>
 
@@ -52,7 +79,7 @@ y=cumprod(x,'m')</synopsis>
         <term>y</term>
 
         <listitem>
-          <para>vector or matrix (real or complex)</para>
+          <para>scalar or array</para>
         </listitem>
       </varlistentry>
     </variablelist>
@@ -61,24 +88,76 @@ y=cumprod(x,'m')</synopsis>
   <refsection>
     <title>Description</title>
 
-    <para>For a vector or a matrix <literal>x</literal>,
-    <literal>y=cumprod(x)</literal> returns in <literal>y</literal> the
-    cumulative product of all the entries of <literal>x</literal> taken
-    columnwise.</para>
-
-    <para><literal>y=cumprod(x,'c')</literal> (or, equivalently,
-    <literal>y=cumprod(x,2)</literal>) returns in <literal>y</literal> the
-    cumulative elementwise product of the columns of <literal>x</literal>:
-    <literal> y(i,:)=cumprod(x(i,:))</literal></para>
-
-    <para><literal>y=cumprod(x,'r')</literal> (or, equivalently,
-    <literal>y=cumprod(x,2)</literal>) returns in <literal>y</literal> the
-    cumulative elementwise product of the rows of <literal>x</literal>:
-    <literal> y(:,i)=cumprod(x(:,i))</literal>.</para>
+    <para>For an array <literal>x</literal>,
+    <literal>y=cumprod(x)</literal> returns in the scalar <literal>y</literal> the
+    cumulative product of all the elements of <literal>x</literal>.</para>
+
+    <para><literal>y=cumprod(x,orientation)</literal> returns in
+    <literal>y</literal> the cumulative product of <literal>x</literal> along the
+    dimension given by <literal>orientation</literal>:</para>
+
+    <itemizedlist>
+ <listitem>
+        <para>if <literal>orientation</literal> is equal to 1 or "r" then</para>
+        <para><latex> <![CDATA[ y(\mathbf{l},j) = \prod_{\mathbf{i}=1}^l x(\mathbf{i},j)]]> </latex></para> 
+        <para>or </para> 
+        <para><latex> <![CDATA[ y(\mathbf{l},j,k,\ldots) = \prod_{\mathbf{i}=1}^l x(\mathbf{i},j,k,\ldots)]]> </latex> </para>
+      </listitem>
+      <listitem>
+        <para>Si <literal>orientation</literal>  est égal à  2 ou "c" alors:</para>
+        <para><latex><![CDATA[ y(i,\mathbf{l}) = \prod_{\mathbf{j}=1}^l x(i,{\mathbf{j})]]> </latex></para> 
+        <para> or </para> 
+        <para><latex><![CDATA[ y(i,\mathbf{l},k,\ldots) = \prod_{\mathbf{j}=1}^l x(i,\mathbf{j},k,\ldots)]]> </latex> </para>
+      </listitem>
+      <listitem>
+        <para>if <literal>orientation</literal> is equal to n  then</para>
+        <para><latex><![CDATA[ y(i_1,\ldots,i_{n-1},\mathbf{l},i_{n+1},\ldots) = \prod_{\mathbf{i_n}=1}^l x(i_1,\ldots,i_{n-1},\mathbf{i_n},i_{n+1},\ldots)]]> </latex> </para>
+      </listitem>
+      <listitem>
+        <para><literal>y=cumprod(x,"*")</literal> is equivalent to <literal>y=cumprod(x)</literal> </para>
+      </listitem>
+      <listitem>
+        <para><literal>y=cumprod(x,"m")</literal> is equivalent to
+        <literal>y=cumprod(x,orientation)</literal> where
+        <literal>orientation</literal> is the index of the
+        first dimension of  <literal>x</literal> that is greater than 1. This option is used for
+         Matlab compatibility.</para>
+      </listitem>
+    </itemizedlist>
+
+    <para></para>
+    <para>The <literal>outtype</literal>  argument rules the way the product is done:</para>
+    <itemizedlist>
+      <listitem>
+        <para>For arrays of floats, of polynomials, of rational
+        fractions, the evaluation is always done using floating points
+        computations. The <literal>"double"</literal> or <literal>"native"</literal> options are equivalent.</para>
+      </listitem>
+      <listitem>
+        <para>For arrays of integers,</para>
+        <para> if <literal>outtype="native"</literal> the evaluation is done using integer
+        computations (modulo 2^b, where b is the number of bits used),</para>
+         <para> if <literal>outtype="double"</literal> the evaluation is done using floating point
+        computations.</para>
+        <para>The default value is <literal>outtype="native"</literal>.</para>
+      </listitem>
+      <listitem>
+        <para>For arrays of booleans,</para>
+        <para> if <literal>outtype="native"</literal> the evaluation is done using boolean
+        computations ( + is replaced by |),</para>
+         <para> if <literal>outtype="double"</literal> the evaluation is done using floating point
+        computations (%t values are replaced by 1 and %f values by 0).</para>
+         <para>The default value is <literal>outtype="double"</literal>.</para>
+      </listitem>
+
+    </itemizedlist>
+  </refsection>
 
-    <para><literal>y=cumprod(x,'m')</literal> is the cumulative product along
-    the first non singleton dimension of <literal>x</literal> (for
-    compatibility with Matlab).</para>
+  <refsection>
+    <title>Remark</title>
+    <para>This function applies, with identical rules to <link
+    linkend="sparse">sparse matrices</link> and <link
+    linkend="hypermat">hypermatrices</link>.</para>
   </refsection>
 
   <refsection>
@@ -86,32 +165,30 @@ y=cumprod(x,'m')</synopsis>
 
     <programlisting role="example"><![CDATA[ 
 A=[1,2;3,4];
-
 cumprod(A)
-cumprod(A,'r')
-cumprod(A,'c')
-
-rand('seed',0);
-a=rand(3,4);
-[m,n]=size(a);
-w=zeros(a);
-w(1,:)=a(1,:);
-for k=2:m;
-  w(k,:)=w(k-1,:).*a(k,:);
-end;
-w-cumprod(a,'r')
+cumprod(A,1)
+
+I=uint8([2 95 103;254 9 0])
+cumprod(I) //native evaluation
+cumprod(I,"double")
+cumprod(I,2,"double")
+
+s=poly(0,"s");
+P=[s,%i+s;s^2,1];
+cumprod(P),
+cumprod(P,2)
+
+B=[%t %t %f %f];
+cumprod(B) //evaluation in float
+cumprod(B,"native") //similar to or(B)
  ]]></programlisting>
   </refsection>
 
   <refsection>
     <title>See Also</title>
-
     <simplelist type="inline">
-      <member><link linkend="cumsum">cumsum</link></member>
-
-      <member><link linkend="sum">sum</link></member>
-
       <member><link linkend="prod">prod</link></member>
+      <member><link linkend="cumsum">cumsum</link></member>
     </simplelist>
   </refsection>
 </refentry>
index eba72a8..184b318 100644 (file)
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!--
  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
- * Copyright (C) 2008 - INRIA
+ * Copyright (C) 2010 - Serge Steer - INRIA
  * 
  * This file must be used under the terms of the CeCILL.
  * This source file is licensed as described in the file COPYING, which
   <refnamediv>
     <refname>cumsum</refname>
 
-    <refpurpose>cumulative sum</refpurpose>
+    <refpurpose>cumulative sum of array elements</refpurpose>
   </refnamediv>
 
   <refsynopsisdiv>
     <title>Calling Sequence</title>
 
     <synopsis>y=cumsum(x)
-y=cumsum(x,'r') or y=cumsum(x,1)
-y=cumsum(x,'c') or y=cumsum(x,2)</synopsis>
+    y=cumsum(x,orientation)
+    y=cumsum(x,outtype)
+    y=cumsum(x,orientation,outtype)
+    </synopsis>
   </refsynopsisdiv>
 
   <refsection>
@@ -43,7 +45,33 @@ y=cumsum(x,'c') or y=cumsum(x,2)</synopsis>
         <term>x</term>
 
         <listitem>
-          <para>vector or matrix (real or complex)</para>
+          <para>
+            an array of  reals, complex, booleans,  polynomials or
+          rational fractions.
+          </para>
+        </listitem>
+      </varlistentry>
+      <varlistentry>
+        <term>orientation</term>
+        <listitem>
+          <para>
+            This argument can be</para>
+            <itemizedlist>
+              <listitem>
+                <para>either a string with possible values <literal>"*"</literal>, <literal>"r"</literal>, 
+                <literal>"c"</literal> or  <literal>"m"</literal></para>
+              </listitem>
+              <listitem>
+                <para>or a number with positive integer value</para>
+              </listitem>
+          </itemizedlist>
+        </listitem>
+      </varlistentry>
+      <varlistentry>
+        <term>outtype</term>
+        <listitem>
+          <para>
+            a string with possible values <literal>"native"</literal> or <literal>"double"</literal>. </para>
         </listitem>
       </varlistentry>
 
@@ -51,7 +79,7 @@ y=cumsum(x,'c') or y=cumsum(x,2)</synopsis>
         <term>y</term>
 
         <listitem>
-          <para>vector or matrix (real or complex)</para>
+          <para>scalar or array</para>
         </listitem>
       </varlistentry>
     </variablelist>
@@ -60,24 +88,75 @@ y=cumsum(x,'c') or y=cumsum(x,2)</synopsis>
   <refsection>
     <title>Description</title>
 
-    <para>For a vector or a matrix <literal>x</literal>,
-    <literal>y=cumsum(x)</literal> returns in <literal>y</literal> the
-    cumulative sum of all the entries of <literal>x</literal> taken
-    columnwise.</para>
-
-    <para><literal>y=cumsum(x,'c')</literal> (or, equivalently,
-    <literal>y=cumsum(x,2)</literal>) returns in <literal>y</literal> the
-    cumulative sum of the columns of <literal>x</literal>: <literal>
-    y(i,:)=cumsum(x(i,:))</literal></para>
-
-    <para><literal>y=cumsum(x,'r')</literal> (or, equivalently,
-    <literal>y=cumsum(x,1)</literal>) returns in <literal>y</literal> the
-    cumulative sum of the rows of <literal>x</literal>: <literal>
-    y(:,i)=cumsum(x(:,i))</literal></para>
-
-    <para><literal>y=cumsum(x,'m')</literal> is the cumulative sum along the
-    first non singleton dimension of <literal>x</literal> (for compatibility
-    with Matlab).</para>
+    <para>For an array <literal>x</literal>,
+    <literal>y=cumsum(x)</literal> returns in the scalar <literal>y</literal> the
+    cumulative sum of all the elements of <literal>x</literal>.</para>
+
+    <para><literal>y=cumsum(x,orientation)</literal> returns in
+    <literal>y</literal> the cumulative sum of <literal>x</literal> along the
+    dimension given by <literal>orientation</literal>:</para>
+
+    <itemizedlist>
+      <listitem>
+        <para>if <literal>orientation</literal> is equal to 1 or "r" then</para>
+        <para><latex> <![CDATA[ y(\mathbf{l},j) = \sum_{\mathbf{i}=1}^l x(\mathbf{i},j)]]> </latex></para> 
+        <para>or </para> 
+        <para><latex> <![CDATA[ y(\mathbf{l},j,k,\ldots) = \sum_{\mathbf{i}=1}^l x(\mathbf{i},j,k,\ldots)]]> </latex> </para>
+      </listitem>
+      <listitem>
+        <para>Si <literal>orientation</literal>  est égal à  2 ou "c" alors:</para>
+        <para><latex><![CDATA[ y(i,\mathbf{l}) = \sum_{\mathbf{j}=1}^l x(i,{\mathbf{j})]]> </latex></para> 
+        <para> or </para> 
+        <para><latex><![CDATA[ y(i,\mathbf{l},k,\ldots) = \sum_{\mathbf{j}=1}^l x(i,\mathbf{j},k,\ldots)]]> </latex> </para>
+      </listitem>
+      <listitem>
+        <para>if <literal>orientation</literal> is equal to n  then</para>
+        <para><latex><![CDATA[ y(i_1,\ldots,i_{n-1},\mathbf{l},i_{n+1},\ldots) = \sum_{\mathbf{i_n}=1}^l x(i_1,\ldots,i_{n-1},\mathbf{i_n},i_{n+1},\ldots)]]> </latex> </para>
+      </listitem>
+      <listitem>
+        <para><literal>y=cumsum(x,"*")</literal> is equivalent to <literal>y=cumsum(x)</literal> </para>
+      </listitem>
+      <listitem>
+        <para><literal>y=cumsum(x,"m")</literal> is equivalent to
+        <literal>y=cumsum(x,orientation)</literal> where
+        <literal>orientation</literal> is the index of the
+        first dimension of  <literal>x</literal> that is greater than 1. This option is used for
+         Matlab compatibility.</para>
+      </listitem>
+    </itemizedlist>
+
+    <para></para>
+    <para>The <literal>outtype</literal>  argument rules the way the summation is done:</para>
+    <itemizedlist>
+      <listitem>
+        <para>For arrays of floats, of polynomials, of rational
+        fractions, the evaluation is always done using floating points
+        computations. The <literal>"double"</literal> or <literal>"native"</literal> options are equivalent.</para>
+      </listitem>
+      <listitem>
+        <para>For arrays of integers,</para>
+        <para> if <literal>outtype="native"</literal> the evaluation is done using integer
+        computations (modulo 2^b, where b is the number of bits used),</para>
+         <para> if <literal>outtype="double"</literal> the evaluation is done using floating point
+        computations.</para>
+        <para>The default value is <literal>outtype="native"</literal>.</para>
+      </listitem>
+      <listitem>
+        <para>For arrays of booleans,</para>
+        <para> if <literal>outtype="native"</literal> the evaluation is done using boolean
+        computations ( + is replaced by |),</para>
+         <para> if <literal>outtype="double"</literal> the evaluation is done using floating point
+        computations (%t values are replaced by 1 and %f values by 0).</para>
+         <para>The default value is <literal>outtype="double"</literal>.</para>
+      </listitem>
+
+    </itemizedlist>
+  </refsection>
+  <refsection>
+    <title>Remark</title>
+    <para>This function applies, with identical rules to <link
+    linkend="sparse">sparse matrices</link> and <link
+    linkend="hypermat">hypermatrices</link>.</para>
   </refsection>
 
   <refsection>
@@ -85,29 +164,30 @@ y=cumsum(x,'c') or y=cumsum(x,2)</synopsis>
 
     <programlisting role="example"><![CDATA[ 
 A=[1,2;3,4];
-
 cumsum(A)
-cumsum(A,'r')
-cumsum(A,'c')
-
-a=rand(3,4)+%i;
-[m,n]=size(a);
-w=zeros(a);
-w(1,:)=a(1,:);
-for k=2:m;
-  w(k,:)=w(k-1,:)+a(k,:);
-end;
-w-cumsum(a,'r')
+cumsum(A,1)
+
+I=uint8([2 95 103;254 9 0])
+cumsum(I) //native evaluation
+cumsum(I,"double")
+cumsum(I,2,"double")
+
+s=poly(0,"s");
+P=[s,%i+s;s^2,1];
+cumsum(P),
+cumsum(P,2)
+
+B=[%t %t %f %f];
+cumsum(B) //evaluation in float
+cumsum(B,"native") //similar to or(B)
  ]]></programlisting>
   </refsection>
 
   <refsection>
     <title>See Also</title>
-
     <simplelist type="inline">
-      <member><link linkend="cumprod">cumprod</link></member>
-
       <member><link linkend="sum">sum</link></member>
+      <member><link linkend="cumprod">cumprod</link></member>
     </simplelist>
   </refsection>
 </refentry>
index f951a7c..b08f505 100644 (file)
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!--
  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
- * Copyright (C) 2008 - INRIA
+ * Copyright (C) 2010 - Serge Steer - INRIA
  * 
  * This file must be used under the terms of the CeCILL.
  * This source file is licensed as described in the file COPYING, which
   <refnamediv>
     <refname>prod</refname>
 
-    <refpurpose>product</refpurpose>
+    <refpurpose>product of array elements</refpurpose>
   </refnamediv>
 
   <refsynopsisdiv>
     <title>Calling Sequence</title>
 
     <synopsis>y=prod(x)
-y=prod(x,'r') or y=prod(x,1)
-y=prod(x,'c') or y=prod(x,2)
-y=prod(x,'m')</synopsis>
+    y=prod(x,orientation)
+    y=prod(x,outtype)
+    y=prod(x,orientation,outtype)
+    </synopsis>
   </refsynopsisdiv>
 
   <refsection>
@@ -44,7 +45,33 @@ y=prod(x,'m')</synopsis>
         <term>x</term>
 
         <listitem>
-          <para>real or complex vector or matrix</para>
+          <para>
+            an array of  reals, complex, booleans,  polynomials or
+            rational fractions.
+          </para>
+        </listitem>
+      </varlistentry>
+      <varlistentry>
+        <term>orientation</term>
+        <listitem>
+          <para>
+            it can be either </para>
+            <itemizedlist>
+              <listitem>
+                <para>a string with possible values <literal>"*"</literal>, <literal>"r"</literal>, 
+                <literal>"c"</literal> or  <literal>"m"</literal></para>
+              </listitem>
+              <listitem>
+                <para>a number with positive integer value</para>
+              </listitem>
+          </itemizedlist>
+        </listitem>
+      </varlistentry>
+      <varlistentry>
+        <term>outtype</term>
+        <listitem>
+          <para>
+            a string with possible values <literal>"native"</literal> or <literal>"double"</literal>. </para>
         </listitem>
       </varlistentry>
 
@@ -52,7 +79,7 @@ y=prod(x,'m')</synopsis>
         <term>y</term>
 
         <listitem>
-          <para>real or complex scalar or matrix</para>
+          <para>scalar or array</para>
         </listitem>
       </varlistentry>
     </variablelist>
@@ -61,47 +88,109 @@ y=prod(x,'m')</synopsis>
   <refsection>
     <title>Description</title>
 
-    <para>For a vector or a matrix <literal>x</literal>,
-    <literal>y=prod(x)</literal> returns in the scalar <literal>y</literal>
-    the prod of all the entries of <literal>x</literal>, , e.g.
-    <literal>prod(1:n)</literal> is n!</para>
-
-    <para><literal>y=prod(x,'r')</literal> (or, equivalently,
-    <literal>y=prod(x,1)</literal>)computes the rows elementwise product of
-    <literal>x</literal>. <literal>y</literal> is the row vector:
-    <literal>y(1,j)=prod(x(:,j))</literal>.</para>
-
-    <para><literal>y=prod(x,'c')</literal> (or, equivalently,
-    <literal>y=prod(x,2)</literal>) computes the columns elementwise product
-    of <literal>x</literal>. <literal>y</literal> is the column vector:
-    <literal>y(i,1)=prod(x(i,:))</literal>.</para>
-
-    <para><literal>y=prod(x,'m')</literal> is the product along the first non
-    singleton dimension of <literal>x</literal> (for compatibility with
-    Matlab).</para>
+    <para>For an array <literal>x</literal>,
+    <literal>y=prod(x)</literal> returns in the scalar <literal>y</literal> the
+    product of all the elements of <literal>x</literal>.</para>
+
+    <para><literal>y=prod(x,orientation)</literal> returns in
+    <literal>y</literal> the product of <literal>x</literal> along the
+    dimension given by <literal>orientation</literal>:</para>
+
+    <itemizedlist>
+      <listitem>
+        <para>if <literal>orientation</literal> is equal to 1 or "r" then</para>
+         <para><latex><![CDATA[ y(1,j) = \prod_i x(i,j)]]> </latex> </para>
+         <para>or </para>
+         <para><latex><![CDATA[ y(1,j,k,\ldots) = \prod_i x(i,j,k,\ldots)]]> </latex> </para>
+      </listitem>
+      <listitem>
+        <para>if <literal>orientation</literal> is equal to 2 or "c" then:</para>
+        <para><latex><![CDATA[ y(i,\mathbf{1}) = \prod_{\mathbf{j}} x(i,\mathbf{j})]]> </latex> </para>
+        <para>or </para>
+        <para><latex><![CDATA[ y(i,\mathbf{1},k,\ldots) = \prod_{j} x(i,\mathbf{j},k,\ldots)]]> </latex> </para>
+      </listitem>
+      <listitem>
+        <para>if <literal>orientation</literal> is equal to n  then</para>
+         <para><latex><![CDATA[ y(i_1,\ldots,i_{n-1},\mathbf{1},i_{n+1},\ldots) = \prod_{\mathbf{i_n}} x(i_1,\ldots,i_{n-1},\mathbf{i_n},i_{n+1},\ldots)]]> </latex> </para>
+      </listitem>
+
+      <listitem>
+        <para><literal>y=prod(x,"*")</literal> is equivalent to <literal>y=prod(x)</literal> </para>
+      </listitem>
+      <listitem>
+        <para><literal>y=prod(x,"m")</literal> is equivalent to
+        <literal>y=prod(x,orientation)</literal> where
+        <literal>orientation</literal> is the index of the
+        first dimension of  <literal>x</literal> that is greater than 1.</para>
+      </listitem>
+    </itemizedlist>
+
+    <para></para>
+    <para>The <literal>outtype</literal>  argument rules the way the summation is done:</para>
+    <itemizedlist>
+      <listitem>
+        <para>For arrays of floats, of polynomials, of rational
+        fractions, the evaluation is always done using floating points
+        computations. The <literal>"double"</literal> or <literal>"native"</literal> options are equivalent.</para>
+      </listitem>
+      <listitem>
+        <para>For arrays of integers,</para>
+        <para> if <literal>outtype="native"</literal> the evaluation is done using integer
+        computations (modulo 2^b, where b is the number of bits used),</para>
+         <para> if <literal>outtype="double"</literal> the evaluation is done using floating point
+        computations.</para>
+        <para>The default value is <literal>outtype="native"</literal>.</para>
+      </listitem>
+      <listitem>
+        <para>For arrays of booleans,</para>
+        <para> if <literal>outtype="native"</literal> the evaluation is done using boolean
+        computations ( + is replaced by |),</para>
+         <para> if <literal>outtype="double"</literal> the evaluation is done using floating point
+        computations (%t values are replaced by 1 and %f values by 0).</para>
+         <para>The default value is
+         <literal>outtype="double"</literal>. This option is used for
+         Matlab compatibility. </para>
+      </listitem>
+
+    </itemizedlist>
+  </refsection>
 
-    <para><literal>prod</literal> is not implemented for sparse
-    matrices.</para>
+  <refsection>
+    <title>Remark</title>
+    <para>This function applies, with identical rules to <link
+    linkend="sparse">sparse matrices</link> and <link
+    linkend="hypermat">hypermatrices</link>.</para>
   </refsection>
 
   <refsection>
     <title>Examples</title>
 
-    <programlisting role="example"><![CDATA[  
-A=[1,2;0,100];
+    <programlisting role="example"><![CDATA[ 
+A=[1,2;3,4];
 prod(A)
-prod(A,'c')
-prod(A,'r')
+prod(A,1)
+
+I=uint8([2 95 103;254 9 0])
+prod(I) //native evaluation
+prod(I,"double")
+prod(I,2,"double")
+
+s=poly(0,"s");
+P=[s,%i+s;s^2,1];
+prod(P),
+prod(P,2)
+
+B=[%t %t %f %f];
+prod(B) //evaluation in float
+prod(B,"native") //similar to or(B)
  ]]></programlisting>
   </refsection>
 
   <refsection>
     <title>See Also</title>
-
     <simplelist type="inline">
-      <member><link linkend="sum">sum</link></member>
-
       <member><link linkend="cumprod">cumprod</link></member>
+      <member><link linkend="sum">sum</link></member>
     </simplelist>
   </refsection>
 </refentry>
index 8ffa4c4..f21fa7c 100644 (file)
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!--
  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
- * Copyright (C) 2008 - INRIA
+ * Copyright (C) 2010 - Serge Steer - INRIA
  * 
  * This file must be used under the terms of the CeCILL.
  * This source file is licensed as described in the file COPYING, which
   <refnamediv>
     <refname>sum</refname>
 
-    <refpurpose>sum (row sum, column sum) of vector/matrix
-    entries</refpurpose>
+    <refpurpose>sum of array elements</refpurpose>
   </refnamediv>
 
   <refsynopsisdiv>
     <title>Calling Sequence</title>
 
     <synopsis>y=sum(x)
-y=sum(x,'r') or y=sum(x,1)
-
-y=sum(x,'c') or y=sum(x,2)
-
-y=sum(x,'m')</synopsis>
+    y=sum(x,orientation)
+    y=sum(x,outtype)
+    y=sum(x,orientation,outtype)
+    </synopsis>
   </refsynopsisdiv>
 
   <refsection>
@@ -47,7 +45,33 @@ y=sum(x,'m')</synopsis>
         <term>x</term>
 
         <listitem>
-          <para>vector or matrix (real, complex, sparse or polynomial)</para>
+          <para>
+            an array of  reals, complex, booleans,  polynomials or
+            rational fractions.
+          </para>
+        </listitem>
+      </varlistentry>
+      <varlistentry>
+        <term>orientation</term>
+        <listitem>
+          <para>
+            it can be either </para>
+            <itemizedlist>
+              <listitem>
+                <para>a string with possible values <literal>"*"</literal>, <literal>"r"</literal>, 
+                <literal>"c"</literal> or  <literal>"m"</literal></para>
+              </listitem>
+              <listitem>
+                <para>a number with positive integer value</para>
+              </listitem>
+          </itemizedlist>
+        </listitem>
+      </varlistentry>
+      <varlistentry>
+        <term>outtype</term>
+        <listitem>
+          <para>
+            a string with possible values <literal>"native"</literal> or <literal>"double"</literal>. </para>
         </listitem>
       </varlistentry>
 
@@ -55,7 +79,7 @@ y=sum(x,'m')</synopsis>
         <term>y</term>
 
         <listitem>
-          <para>scalar or vector</para>
+          <para>scalar or array</para>
         </listitem>
       </varlistentry>
     </variablelist>
@@ -64,22 +88,75 @@ y=sum(x,'m')</synopsis>
   <refsection>
     <title>Description</title>
 
-    <para>For a vector or a matrix <literal>x</literal>,
+    <para>For an array <literal>x</literal>,
     <literal>y=sum(x)</literal> returns in the scalar <literal>y</literal> the
-    sum of all the entries of <literal>x</literal>.</para>
-
-    <para><literal>y=sum(x,'r')</literal> (or, equivalently,
-    <literal>y=sum(x,1)</literal>) is the rowwise sum: <literal>y(j)=
-    sum(x(:,j))</literal>. <literal>y</literal> is a row vector</para>
-
-    <para><literal>y=sum(x,'c')</literal> (or, equivalently,
-    <literal>y=sum(x,2)</literal>) is the columnwise sum. It returns in each
-    entry of the column vector <literal>y</literal> the sum : <literal>y(i)=
-    sum(x(i,:))</literal>)).</para>
+    sum of all the elements of <literal>x</literal>.</para>
+
+    <para><literal>y=sum(x,orientation)</literal> returns in
+    <literal>y</literal> the sum of <literal>x</literal> along the
+    dimension given by <literal>orientation</literal>:</para>
+
+    <itemizedlist>
+      <listitem>
+        <para>if <literal>orientation</literal> is equal to 1 or "r" then</para>
+         <para><latex><![CDATA[ y(1,j) = \sum_i x(i,j)]]> </latex> </para>
+         <para>or </para>
+         <para><latex><![CDATA[ y(1,j,k,\ldots) = \sum_i x(i,j,k,\ldots)]]> </latex> </para>
+      </listitem>
+      <listitem>
+        <para>if <literal>orientation</literal> is equal to 2 or "c" then:</para>
+        <para><latex><![CDATA[ y(i,\mathbf{1}) = \sum_{\mathbf{j}} x(i,\mathbf{j})]]> </latex> </para>
+        <para>or </para>
+        <para><latex><![CDATA[ y(i,\mathbf{1},k,\ldots) = \sum_{j} x(i,\mathbf{j},k,\ldots)]]> </latex> </para>
+      </listitem>
+      <listitem>
+        <para>if <literal>orientation</literal> is equal to n  then</para>
+         <para><latex><![CDATA[ y(i_1,\ldots,i_{n-1},\mathbf{1},i_{n+1},\ldots) = \sum_{\mathbf{i_n}} x(i_1,\ldots,i_{n-1},\mathbf{i_n},i_{n+1},\ldots)]]> </latex> </para>
+      </listitem>
+      <listitem>
+        <para><literal>y=sum(x,"*")</literal> is equivalent to <literal>y=sum(x)</literal> </para>
+      </listitem>
+      <listitem>
+        <para><literal>y=sum(x,"m")</literal> is equivalent to
+        <literal>y=sum(x,orientation)</literal> where
+        <literal>orientation</literal> is the index of the
+        first dimension of  <literal>x</literal> that is greater than 1.</para>
+      </listitem>
+    </itemizedlist>
+
+    <para></para>
+    <para>The <literal>outtype</literal>  argument rules the way the summation is done:</para>
+    <itemizedlist>
+      <listitem>
+        <para>For arrays of floats, of polynomials, of rational
+        fractions, the evaluation is always done using floating points
+        computations. The <literal>"double"</literal> or <literal>"native"</literal> options are equivalent.</para>
+      </listitem>
+      <listitem>
+        <para>For arrays of integers,</para>
+        <para> if <literal>outtype="native"</literal> the evaluation is done using integer
+        computations (modulo 2^b, where b is the number of bits used),</para>
+         <para> if <literal>outtype="double"</literal> the evaluation is done using floating point
+        computations.</para>
+        <para>The default value is <literal>outtype="native"</literal>.</para>
+      </listitem>
+      <listitem>
+        <para>For arrays of booleans,</para>
+        <para> if <literal>outtype="native"</literal> the evaluation is done using boolean
+        computations ( + is replaced by |),</para>
+         <para> if <literal>outtype="double"</literal> the evaluation is done using floating point
+        computations (%t values are replaced by 1 and %f values by 0).</para>
+         <para>The default value is <literal>outtype="double"</literal>.</para>
+      </listitem>
+
+    </itemizedlist>
+  </refsection>
 
-    <para><literal>y=sum(x,'m')</literal> is the sum along the first non
-    singleton dimension of <literal>x</literal> (for compatibility with
-    Matlab).</para>
+  <refsection>
+    <title>Remark</title>
+    <para>This function applies, with identical rules to <link
+    linkend="sparse">sparse matrices</link> and <link
+    linkend="hypermat">hypermatrices</link>.</para>
   </refsection>
 
   <refsection>
@@ -87,22 +164,29 @@ y=sum(x,'m')</synopsis>
 
     <programlisting role="example"><![CDATA[ 
 A=[1,2;3,4];
-trace(A)-sum(diag(A))
-sum(A,'c')-A*ones(2,1)
-sum(A+%i)
-A=sparse(A);sum(A,'c')-A*ones(2,1)
-s=poly(0,'s');
-M=[s,%i+s;s^2,1];
-sum(M),sum(M,2)
+sum(A)
+sum(A,1)
+
+I=uint8([2 95 103;254 9 0])
+sum(I) //native evaluation
+sum(I,"double")
+sum(I,2,"double")
+
+s=poly(0,"s");
+P=[s,%i+s;s^2,1];
+sum(P),
+sum(P,2)
+
+B=[%t %t %f %f];
+sum(B) //evaluation in float
+sum(B,"native") //similar to or(B)
  ]]></programlisting>
   </refsection>
 
   <refsection>
     <title>See Also</title>
-
     <simplelist type="inline">
       <member><link linkend="cumsum">cumsum</link></member>
-
       <member><link linkend="prod">prod</link></member>
     </simplelist>
   </refsection>
index 07d2e09..de8ba62 100644 (file)
@@ -1,4 +1,15 @@
 <?xml version="1.0" encoding="UTF-8"?>
+<!--
+ * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+ * Copyright (C) 2010 - Serge Steer - 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    
+ * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
+ *
+ -->
 <refentry version="5.0-subset Scilab" xml:id="cumprod" xml:lang="fr"
           xmlns="http://docbook.org/ns/docbook"
           xmlns:xlink="http://www.w3.org/1999/xlink"
   <refnamediv>
     <refname>cumprod</refname>
 
-    <refpurpose>produit cumulatif.</refpurpose>
+    <refpurpose>produit cumulatif des éléments d'un tableau.</refpurpose>
   </refnamediv>
 
   <refsynopsisdiv>
     <title>Séquence d'appel</title>
 
     <synopsis>y=cumprod(x)
-y=cumprod(x,'r') ou y=cumprod(x,1)
-y=cumprod(x,'c') ou y=cumprod(x,2)
-y=cumprod(x,'m')</synopsis>
+    y=cumprod(x,orientation)
+    y=cumprod(x,outtype)
+    y=cumprod(x,orientation,outtype)</synopsis>
   </refsynopsisdiv>
 
   <refsection>
@@ -33,7 +44,34 @@ y=cumprod(x,'m')</synopsis>
         <term>x</term>
 
         <listitem>
-          <para>vecteur ou matrice (réelle ou complexe)</para>
+          <para>un tableau de réels, de complexes, de booléens, de
+          polynômes ou de fractions rationnelles. </para>
+        </listitem>
+      </varlistentry>
+
+      <varlistentry>
+       <term>orientation</term>
+        <listitem>
+          <para>
+            Cet argument peut être </para>
+            <itemizedlist>
+              <listitem>
+                <para>ou une chaîne de caractères pouvant avoir comme
+                valeurs: <literal>"*"</literal>,
+                <literal>"r"</literal>, <literal>"c"</literal> ou
+                <literal>"m"</literal></para>
+              </listitem>
+              <listitem>
+                <para>ou bien un nombre à valeur positive entière</para>
+              </listitem>
+          </itemizedlist>
+        </listitem>
+      </varlistentry>
+      <varlistentry>
+        <term>outtype</term>
+        <listitem>
+          <para>
+            une chaîne de caractères pouvant prendre les valeurs <literal>"native"</literal> ou <literal>"double"</literal>. </para>
         </listitem>
       </varlistentry>
 
@@ -41,7 +79,7 @@ y=cumprod(x,'m')</synopsis>
         <term>y</term>
 
         <listitem>
-          <para>vecteur ou matrice (réelle ou complexe)</para>
+          <para> un scalaire ou un tableau</para>
         </listitem>
       </varlistentry>
     </variablelist>
@@ -50,44 +88,72 @@ y=cumprod(x,'m')</synopsis>
   <refsection>
     <title>Description</title>
 
-    <para>Pour un vecteur <literal>x</literal>,
-    <literal>y=cumprod(x)</literal> renvoie dans <literal>y</literal> le
-    produit cumulatif de tous les éléments de <literal>x</literal>. Si
-    <literal>x</literal> est une matrice, elle est considérée comme un vecteur
-    (les colonnes sont mises bout à bout).</para>
-
-    <para><literal>y=cumprod(x,'c')</literal> (ou
-    <literal>y=cumprod(x,2)</literal>) renvoie dans <literal>y</literal> le
-    produit cumulatif des éléments des lignes de <literal>x</literal>:
-    <literal> y(i,:)=cumprod(x(i,:))</literal>.</para>
-
-    <para><literal>y=cumprod(x,'r')</literal> (ou
-    <literal>y=cumprod(x,2)</literal>) renvoie dans <literal>y</literal> le
-    produit cumulatif des colonnes de <literal>x</literal>: <literal>
-    y(:,i)=cumprod(x(:,i))</literal>.</para>
-
-    <para><literal>y=cumprod(x,'m')</literal> effectue le produit cumulatif
-    selon la première dimension plus grande que 1 (compatibilité avec
-    Matlab).</para>
+    <para>Pour un tableau <literal>x</literal>,
+    <literal>y=cumprod(x)</literal> renvoie dans <literal>y</literal>
+    le produit cumulatif de tous les éléments de
+    <literal>x</literal>. </para>
+
+
+   <para><literal>y=cumprod(x,orientation)</literal> retourne dans
+   <literal>y</literal> le produit cumulatif des éléments de
+   <literal>x</literal> le long de la dimension donnée par le
+   paramêtre <literal>orientation</literal>:</para>
+    <itemizedlist>
+     <listitem>
+        <para>Si <literal>orientation</literal> est égal à  1 ou "r" alors:</para>
+        <para><latex> <![CDATA[ y(\mathbf{l},j) = \prod_{\mathbf{i}=1}^l x(\mathbf{i},j)]]> </latex></para> 
+        <para>ou </para> 
+        <para><latex> <![CDATA[ y(\mathbf{l},j,k,\ldots) = \prod_{\mathbf{i}=1}^l x(\mathbf{i},j,k,\ldots)]]> </latex> </para>
+      </listitem>
+      <listitem>
+        <para>Si <literal>orientation</literal>  est égal à  2 ou "c" alors:</para>
+        <para><latex><![CDATA[ y(i,\mathbf{l}) = \prod_{\mathbf{j}=1}^l x(i,{\mathbf{j})]]> </latex></para> 
+        <para> ou </para> 
+        <para><latex><![CDATA[ y(i,\mathbf{l},k,\ldots) = \prod_{\mathbf{j}=1}^l x(i,\mathbf{j},k,\ldots)]]> </latex> </para>
+      </listitem>
+      <listitem>
+        <para>Si <literal>orientation</literal>  est égal à n  alors</para>
+        <para><latex><![CDATA[ y(i_1,\ldots,i_{n-1},\mathbf{l},i_{n+1},\ldots) = \prod_{\mathbf{i_n}=1}^l x(i_1,\ldots,i_{n-1},\mathbf{i_n},i_{n+1},\ldots)]]> </latex> </para>
+      </listitem>
+
+      <listitem>
+        <para><literal>y=cumprod(x,"*")</literal> est équivalent à <literal>y=cumprod(x)</literal> </para>
+      </listitem>
+      <listitem>
+        <para><literal>y=cumprod(x,"m")</literal> est équivalent à
+        <literal>y=cumprod(x,orientation)</literal> où
+        <literal>orientation</literal> est l'index de la première
+        dimension de <literal>x</literal> qui est plus grande que
+        1. Cette option est utilisé pour la compatibilité avec Matlab.</para>
+      </listitem>
+    </itemizedlist>
+  </refsection>
+  <refsection>
+    <title>Remarque</title>
+    <para>Cette fonction s'applique avec les mêmes règles aux matrices creuses et aux hypermatrices.</para>
   </refsection>
-
   <refsection>
     <title>Exemples</title>
 
     <programlisting role="example"><![CDATA[ 
 A=[1,2;3,4];
 cumprod(A)
-cumprod(A,'r')
-cumprod(A,'c')
-rand('seed',0);
-a=rand(3,4);
-[m,n]=size(a);
-w=zeros(a);
-w(1,:)=a(1,:);
-for k=2:m;
-  w(k,:)=w(k-1,:).*a(k,:);
-end;
-w-cumprod(a,'r')
+cumprod(A,1)
+
+I=uint8([2 95 103;254 9 0])
+cumprod(I) //native evaluation
+cumprod(I,"double")
+cumprod(I,2,"double")
+
+s=poly(0,"s");
+P=[s,%i+s;s^2,1];
+cumprod(P),
+cumprod(P,2)
+
+B=[%t %t %f %f];
+cumprod(B) //evaluation in float
+cumprod(B,"native") //similar to or(B)
+
  ]]></programlisting>
   </refsection>
 
@@ -96,9 +162,6 @@ w-cumprod(a,'r')
 
     <simplelist type="inline">
       <member><link linkend="cumsum">cumsum</link></member>
-
-      <member><link linkend="sum">sum</link></member>
-
       <member><link linkend="prod">prod</link></member>
     </simplelist>
   </refsection>
index 35da516..b8e25c3 100644 (file)
@@ -1,4 +1,15 @@
 <?xml version="1.0" encoding="UTF-8"?>
+<!--
+ * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+ * Copyright (C) 2010 - Serge Steer - 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    
+ * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
+ *
+ -->
 <refentry version="5.0-subset Scilab" xml:id="cumsum" xml:lang="fr"
           xmlns="http://docbook.org/ns/docbook"
           xmlns:xlink="http://www.w3.org/1999/xlink"
   <refnamediv>
     <refname>cumsum</refname>
 
-    <refpurpose>somme cumulative.</refpurpose>
+    <refpurpose>somme cumulative des éléments d'un tableau.</refpurpose>
   </refnamediv>
 
   <refsynopsisdiv>
     <title>Séquence d'appel</title>
 
     <synopsis>y=cumsum(x)
-y=cumsum(x,'r') ou y=cumsum(x,1)
-y=cumsum(x,'c') ou y=cumsum(x,2)
-y=cumsum(x,'m')</synopsis>
+    y=cumsum(x,orientation)
+    y=cumsum(x,outtype)
+    y=cumsum(x,orientation,outtype)</synopsis>
   </refsynopsisdiv>
 
   <refsection>
@@ -33,7 +44,34 @@ y=cumsum(x,'m')</synopsis>
         <term>x</term>
 
         <listitem>
-          <para>vecteur ou matrice (entière, réelle ou complexe)</para>
+          <para>un tableau de réels, de complexes, de booléens, de
+          polynômes ou de fractions rationnelles. </para>
+        </listitem>
+      </varlistentry>
+
+      <varlistentry>
+        <term>orientation</term>
+        <listitem>
+          <para>
+            Cet argument peut être </para>
+            <itemizedlist>
+              <listitem>
+                <para>ou une chaîne de caractères pouvant avoir comme
+                valeurs: <literal>"*"</literal>,
+                <literal>"r"</literal>, <literal>"c"</literal> ou
+                <literal>"m"</literal></para>
+              </listitem>
+              <listitem>
+                <para>ou bien un nombre à valeur positive entière</para>
+              </listitem>
+          </itemizedlist>
+        </listitem>
+      </varlistentry>
+      <varlistentry>
+        <term>outtype</term>
+        <listitem>
+          <para>
+            une chaîne de caractères pouvant prendre les valeurs <literal>"native"</literal> ou <literal>"double"</literal>. </para>
         </listitem>
       </varlistentry>
 
@@ -41,7 +79,7 @@ y=cumsum(x,'m')</synopsis>
         <term>y</term>
 
         <listitem>
-          <para>vecteur ou matrice (entière,réelle ou complexe)</para>
+          <para> un scalaire ou un tableau</para>
         </listitem>
       </varlistentry>
     </variablelist>
@@ -50,42 +88,71 @@ y=cumsum(x,'m')</synopsis>
   <refsection>
     <title>Description</title>
 
-    <para>Pour un vecteur <literal>x</literal>, <literal>y=cumsum(x)</literal>
-    renvoie dans <literal>y</literal> la somme cumulative de tous les éléments
-    de <literal>x</literal>. Si <literal>x</literal> est une matrice, elle est
-    considérée comme un vecteur (les colonnes sont mises bout à bout).</para>
-
-    <para><literal>y=cumsum(x,'c')</literal> (ou
-    <literal>y=cumsum(x,2)</literal>) renvoie dans <literal>y</literal> la
-    somme cumulative des éléments des lignes de <literal>x</literal>:
-    <literal> y(i,:)=cumsum(x(i,:))</literal>.</para>
-
-    <para><literal>y=cumsum(x,'r')</literal> (ou
-    <literal>y=cumsum(x,2)</literal>) renvoie dans <literal>y</literal> la
-    somme cumulative des colonnes de <literal>x</literal>: <literal>
-    y(:,i)=cumsum(x(:,i))</literal>.</para>
-
-    <para><literal>y=cumsum(x,'m')</literal> effectue la somme cumulative
-    selon la première dimension plus grande que 1 (compatibilité avec
-    Matlab).</para>
+    <para>Pour un tableau <literal>x</literal>,
+    <literal>y=cumsum(x)</literal> renvoie dans <literal>y</literal>
+    la somme cumulative de tous les éléments de
+    <literal>x</literal>. </para>
+
+
+   <para><literal>y=cumsum(x,orientation)</literal> retourne dans
+   <literal>y</literal> la somme cumulée des éléments de
+   <literal>x</literal> le long de la dimension donnée par le
+   paramêtre <literal>orientation</literal>:</para>
+    <itemizedlist>
+      <listitem>
+        <para>Si <literal>orientation</literal> est égal à  1 ou "r" alors:</para>
+        <para><latex> <![CDATA[ y(\mathbf{l},j) = \sum_{\mathbf{i}=1}^l x(\mathbf{i},j)]]> </latex></para> 
+        <para>ou </para> 
+        <para><latex> <![CDATA[ y(\mathbf{l},j,k,\ldots) = \sum_{\mathbf{i}=1}^l x(\mathbf{i},j,k,\ldots)]]> </latex> </para>
+      </listitem>
+      <listitem>
+        <para>Si <literal>orientation</literal>  est égal à  2 ou "c" alors:</para>
+        <para><latex><![CDATA[ y(i,\mathbf{l}) = \sum_{\mathbf{j}=1}^l x(i,{\mathbf{j})]]> </latex></para> 
+        <para> ou </para> 
+        <para><latex><![CDATA[ y(i,\mathbf{l},k,\ldots) = \sum_{\mathbf{j}=1}^l x(i,\mathbf{j},k,\ldots)]]> </latex> </para>
+      </listitem>
+      <listitem>
+        <para>Si <literal>orientation</literal>  est égal à n  alors</para>
+        <para><latex><![CDATA[ y(i_1,\ldots,i_{n-1},\mathbf{l},i_{n+1},\ldots) = \sum_{\mathbf{i_n}=1}^l x(i_1,\ldots,i_{n-1},\mathbf{i_n},i_{n+1},\ldots)]]> </latex> </para>
+      </listitem>
+      <listitem>
+        <para><literal>y=cumsum(x,"*")</literal> est équivalent à <literal>y=cumsum(x)</literal> </para>
+      </listitem>
+      <listitem>
+        <para><literal>y=cumsum(x,"m")</literal> est équivalent à
+        <literal>y=cumsum(x,orientation)</literal> où
+        <literal>orientation</literal> est l'index de la première
+        dimension de <literal>x</literal> qui est plus grande que
+        1. Cette option est utilisé pour la compatibilité avec Matlab. </para>
+      </listitem>
+    </itemizedlist>
+  </refsection>
+  <refsection>
+    <title>Remarque</title>
+    <para>Cette fonction s'applique avec les mêmes règles aux matrices creuses et aux hypermatrices.</para>
   </refsection>
-
   <refsection>
     <title>Exemples</title>
 
     <programlisting role="example"><![CDATA[ 
 A=[1,2;3,4];
 cumsum(A)
-cumsum(A,'r')
-cumsum(A,'c')
-a=rand(3,4)+%i;
-[m,n]=size(a);
-w=zeros(a);
-w(1,:)=a(1,:);
-for k=2:m;
-  w(k,:)=w(k-1,:)+a(k,:);
-end;
-w-cumsum(a,'r')
+cumsum(A,1)
+
+I=uint8([2 95 103;254 9 0])
+cumsum(I) //native evaluation
+cumsum(I,"double")
+cumsum(I,2,"double")
+
+s=poly(0,"s");
+P=[s,%i+s;s^2,1];
+cumsum(P),
+cumsum(P,2)
+
+B=[%t %t %f %f];
+cumsum(B) //evaluation in float
+cumsum(B,"native") //similar to or(B)
+
  ]]></programlisting>
   </refsection>
 
@@ -94,10 +161,7 @@ w-cumsum(a,'r')
 
     <simplelist type="inline">
       <member><link linkend="cumprod">cumprod</link></member>
-
       <member><link linkend="sum">sum</link></member>
-
-      <member><link linkend="prod">prod</link></member>
     </simplelist>
   </refsection>
 </refentry>
index d938b88..73e2afb 100644 (file)
@@ -1,4 +1,15 @@
 <?xml version="1.0" encoding="UTF-8"?>
+<!--
+ * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+ * Copyright (C) 2010 - Serge Steer - 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    
+ * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
+ *
+ -->
 <refentry version="5.0-subset Scilab" xml:id="prod" xml:lang="fr"
           xmlns="http://docbook.org/ns/docbook"
           xmlns:xlink="http://www.w3.org/1999/xlink"
   <refnamediv>
     <refname>prod</refname>
 
-    <refpurpose>produit des termes d'une matrice</refpurpose>
+    <refpurpose>produit  des éléments d'un tableau.</refpurpose>
   </refnamediv>
 
   <refsynopsisdiv>
     <title>Séquence d'appel</title>
 
     <synopsis>y=prod(x)
-y=prod(x,'r') ou y=prod(x,1)
-y=prod(x,'c') ou y=prod(x,2)
-y=prod(x,'m')</synopsis>
+    y=prod(x,orientation)
+    y=prod(x,outtype)
+    y=prod(x,orientation,outtype)</synopsis>
   </refsynopsisdiv>
 
   <refsection>
@@ -33,7 +44,34 @@ y=prod(x,'m')</synopsis>
         <term>x</term>
 
         <listitem>
-          <para>vecteur ou matrice (réelle ou complexe)</para>
+          <para>un tableau de réels, de complexes, de booléens, de
+          polynômes ou de fractions rationnelles. </para>
+        </listitem>
+      </varlistentry>
+
+      <varlistentry>
+        <term>orientation</term>
+        <listitem>
+          <para>
+            Cet argument peut être </para>
+            <itemizedlist>
+              <listitem>
+                <para>ou une chaîne de caractères pouvant avoir comme
+                valeurs: <literal>"*"</literal>,
+                <literal>"r"</literal>, <literal>"c"</literal> ou
+                <literal>"m"</literal></para>
+              </listitem>
+              <listitem>
+                <para>ou bien un nombre à valeur positive entière</para>
+              </listitem>
+          </itemizedlist>
+        </listitem>
+      </varlistentry>
+      <varlistentry>
+        <term>outtype</term>
+        <listitem>
+          <para>
+            une chaîne de caractères pouvant prendre les valeurs <literal>"native"</literal> ou <literal>"double"</literal>. </para>
         </listitem>
       </varlistentry>
 
@@ -41,7 +79,7 @@ y=prod(x,'m')</synopsis>
         <term>y</term>
 
         <listitem>
-          <para>scalaire ou vecteur</para>
+          <para> un scalaire ou un tableau</para>
         </listitem>
       </varlistentry>
     </variablelist>
@@ -50,34 +88,72 @@ y=prod(x,'m')</synopsis>
   <refsection>
     <title>Description</title>
 
-    <para>Pour un vecteur ou une matrice <literal>x</literal>,
-    <literal>y=prod(x)</literal> renvoie un scalaire <literal>y</literal> égal
-    au produit des termes de <literal>x</literal>.</para>
-
-    <para><literal>y=prod(x,'r')</literal> (ou <literal>y=prod(x,1)</literal>)
-    effectue le produit suivant l'indice de ligne. Chaque composante du
-    vecteur ligne <literal>y</literal> contient le produit de la colonne
-    correspondante <literal>x</literal>
-    (<literal>y(j)=prod(x(i,j),i=1,m)</literal>).</para>
-
-    <para><literal>y=prod(x,'c')</literal> (ou <literal>y=prod(x,2)</literal>)
-    effectue le produit suivant l'indice de colonne. Chaque composante du
-    vecteur colonne <literal>y</literal> contient le produit de la ligne
-    correspondante de <literal>x</literal> (<literal>y(i)=
-    prod(x(i,j),j=1,n)</literal>)).</para>
-
-    <para><literal>y=prod(x,'m')</literal> effectue le produit suivant la
-    première dimension plus grande que 1 (compatibilité avec Matlab).</para>
+    <para>Pour un tableau <literal>x</literal>,
+    <literal>y=prod(x)</literal> renvoie dans <literal>y</literal> la
+    produit de tous les éléments de <literal>x</literal>. </para>
+
+
+   <para><literal>y=prod(x,orientation)</literal> retourne dans
+   <literal>y</literal> la produit des éléments de <literal>x</literal>
+   le long de la dimension donnée par le paramêtre
+   <literal>orientation</literal>:</para>
+    <itemizedlist>
+ <listitem>
+        <para>Si <literal>orientation</literal> est égal à  1 ou "r" alors:</para>
+        <para><latex><![CDATA[{ y(\mathbf{1},j) = \prod_{\mathbf{i}} x(\mathbf{i},j)}]]> </latex> </para>
+        <para>ou </para>
+        <para><latex><![CDATA[ y(\mathbf{1},j,k,\ldots) = \prod_{\mathbf{i}} x(\mathbf{i},j,k,\ldots)]]> </latex> </para>
+      </listitem>
+      <listitem>
+        <para>Si <literal>orientation</literal>  est égal à  2 ou "c" alors:</para>
+        <para><latex><![CDATA[ y(i,\mathbf{1}) = \prod_{\mathbf{j}} x(i,\mathbf{j})]]> </latex> </para>
+        <para>ou</para> 
+        <para><latex><![CDATA[ y(i,\mathbf{1},k,\ldots) = \prod_{j} x(i,\mathbf{j},k,\ldots)]]> </latex> </para>
+      </listitem>
+      <listitem>
+        <para>Si <literal>orientation</literal>  est égal à n  alors</para>
+        <para><latex><![CDATA[ y(i_1,\ldots,i_{n-1},\mathbf{1},i_{n+1},\ldots) = \prod_{\mathbf{i_n}} x(i_1,\ldots,i_{n-1},\mathbf{i_n},i_{n+1},\ldots)]]> </latex> </para>
+      </listitem>
+
+      <listitem>
+        <para><literal>y=prod(x,"*")</literal> est équivalent à <literal>y=prod(x)</literal> </para>
+      </listitem>
+      <listitem>
+        <para><literal>y=prod(x,"m")</literal> est équivalent à
+        <literal>y=prod(x,orientation)</literal> où
+        <literal>orientation</literal> est l'index de la première
+        dimension de <literal>x</literal> qui est plus grande que
+        1. Cette option est utilisé pour la compatibilité avec
+        Matlab.</para>
+      </listitem>
+    </itemizedlist>
+  </refsection>
+  <refsection>
+    <title>Remarque</title>
+    <para>Cette fonction s'applique avec les mêmes règles aux matrices creuses et aux hypermatrices.</para>
   </refsection>
-
   <refsection>
     <title>Exemples</title>
 
     <programlisting role="example"><![CDATA[ 
-A=[1,2;0,100];
+A=[1,2;3,4];
 prod(A)
-prod(A,'c')
-prod(A,'r')
+prod(A,1)
+
+I=uint8([2 95 103;254 9 0])
+prod(I) //native evaluation
+prod(I,"double")
+prod(I,2,"double")
+
+s=poly(0,"s");
+P=[s,%i+s;s^2,1];
+prod(P),
+prod(P,2)
+
+B=[%t %t %f %f];
+prod(B) //evaluation in float
+prod(B,"native") //similar to or(B)
+
  ]]></programlisting>
   </refsection>
 
@@ -86,7 +162,6 @@ prod(A,'r')
 
     <simplelist type="inline">
       <member><link linkend="cumprod">cumprod</link></member>
-
       <member><link linkend="sum">sum</link></member>
     </simplelist>
   </refsection>
diff --git a/scilab/modules/elementary_functions/help/fr_FR/sum.xml b/scilab/modules/elementary_functions/help/fr_FR/sum.xml
new file mode 100644 (file)
index 0000000..28db21c
--- /dev/null
@@ -0,0 +1,166 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+ * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+ * Copyright (C) 2010 - Serge Steer - 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    
+ * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
+ *
+ -->
+<refentry version="5.0-subset Scilab" xml:id="sum" xml:lang="fr"
+          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">
+  <info>
+    <pubdate>$LastChangedDate$</pubdate>
+  </info>
+
+  <refnamediv>
+    <refname>sum</refname>
+
+    <refpurpose>somme  des éléments d'un tableau.</refpurpose>
+  </refnamediv>
+
+  <refsynopsisdiv>
+    <title>Séquence d'appel</title>
+
+    <synopsis>y=sum(x)
+    y=sum(x,orientation)
+    y=sum(x,outtype)
+    y=sum(x,orientation,outtype)</synopsis>
+  </refsynopsisdiv>
+
+  <refsection>
+    <title>Paramètres</title>
+
+    <variablelist>
+      <varlistentry>
+        <term>x</term>
+
+        <listitem>
+          <para>un tableau de réels, de complexes, de booléens, de
+          polynômes ou de fractions rationnelles. </para>
+        </listitem>
+      </varlistentry>
+
+      <varlistentry>
+        <term>orientation</term>
+        <listitem>
+          <para>
+            Cet argument peut être </para>
+            <itemizedlist>
+              <listitem>
+                <para>ou une chaîne de caractères pouvant avoir comme
+                valeurs: <literal>"*"</literal>,
+                <literal>"r"</literal>, <literal>"c"</literal> ou
+                <literal>"m"</literal></para>
+              </listitem>
+              <listitem>
+                <para>ou bien un nombre à valeur positive entière</para>
+              </listitem>
+          </itemizedlist>
+        </listitem>
+      </varlistentry>
+      <varlistentry>
+        <term>outtype</term>
+        <listitem>
+          <para>
+            une chaîne de caractères pouvant prendre les valeurs <literal>"native"</literal> ou <literal>"double"</literal>. </para>
+        </listitem>
+      </varlistentry>
+
+      <varlistentry>
+        <term>y</term>
+
+        <listitem>
+          <para> un scalaire ou un tableau</para>
+        </listitem>
+      </varlistentry>
+    </variablelist>
+  </refsection>
+
+  <refsection>
+    <title>Description</title>
+
+    <para>Pour un tableau <literal>x</literal>,
+    <literal>y=sum(x)</literal> renvoie dans <literal>y</literal> la
+    somme de tous les éléments de <literal>x</literal>. </para>
+
+
+   <para><literal>y=sum(x,orientation)</literal> retourne dans
+   <literal>y</literal> la somme des éléments de <literal>x</literal>
+   le long de la dimension donnée par le paramêtre
+   <literal>orientation</literal>:</para>
+    <itemizedlist>
+      <listitem>
+        <para>Si <literal>orientation</literal> est égal à  1 ou "r" alors:</para>
+        <para><latex><![CDATA[{ y(\mathbf{1},j) = \sum_{\mathbf{i}} x(\mathbf{i},j)}]]> </latex> </para>
+        <para>ou </para>
+        <para><latex><![CDATA[ y(\mathbf{1},j,k,\ldots) = \sum_{\mathbf{i}} x(\mathbf{i},j,k,\ldots)]]> </latex> </para>
+      </listitem>
+      <listitem>
+        <para>Si <literal>orientation</literal>  est égal à  2 ou "c" alors:</para>
+        <para><latex><![CDATA[ y(i,\mathbf{1}) = \sum_{\mathbf{j}} x(i,\mathbf{j})]]> </latex> </para>
+        <para>ou</para> 
+        <para><latex><![CDATA[ y(i,\mathbf{1},k,\ldots) = \sum_{j} x(i,\mathbf{j},k,\ldots)]]> </latex> </para>
+      </listitem>
+      <listitem>
+        <para>Si <literal>orientation</literal>  est égal à n  alors</para>
+        <para><latex><![CDATA[ y(i_1,\ldots,i_{n-1},\mathbf{1},i_{n+1},\ldots) = \sum_{\mathbf{i_n}} x(i_1,\ldots,i_{n-1},\mathbf{i_n},i_{n+1},\ldots)]]> </latex> </para>
+      </listitem>
+      <listitem>
+        <para><literal>y=sum(x,"*")</literal> est équivalent à <literal>y=sum(x)</literal> </para>
+      </listitem>
+      <listitem>
+        <para><literal>y=sum(x,"m")</literal> est équivalent à
+        <literal>y=sum(x,orientation)</literal> où
+        <literal>orientation</literal> est l'index de la première
+        dimension de <literal>x</literal> qui est plus grande que
+        1. Cette option est utilisé pour la compatibilité avec Matlab.</para>
+      </listitem>
+    </itemizedlist>
+  </refsection>
+  <refsection>
+    <title>Remarque</title>
+    <para>Cette fonction s'applique avec les mêmes règles aux matrices creuses et aux hypermatrices.</para>
+  </refsection>
+  <refsection>
+    <title>Exemples</title>
+
+    <programlisting role="example"><![CDATA[ 
+A=[1,2;3,4];
+sum(A)
+sum(A,1)
+
+I=uint8([2 95 103;254 9 0])
+sum(I) //native evaluation
+sum(I,"double")
+sum(I,2,"double")
+
+s=poly(0,"s");
+P=[s,%i+s;s^2,1];
+sum(P),
+sum(P,2)
+
+B=[%t %t %f %f];
+sum(B) //evaluation in float
+sum(B,"native") //similar to or(B)
+
+ ]]></programlisting>
+  </refsection>
+
+  <refsection>
+    <title>Voir Aussi</title>
+
+    <simplelist type="inline">
+      <member><link linkend="cumsum">cumsum</link></member>
+      <member><link linkend="prod">prod</link></member>
+    </simplelist>
+  </refsection>
+</refentry>
index da3998e..34ec838 100644 (file)
@@ -5,20 +5,21 @@ 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 http://www.cecill.info/licences/Licence_CeCILL_V2-en.txtc     -------------------------------
+c http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
+c     -------------------------------
 c
-                       subroutine intcumprod(id)
+      subroutine intcumprod(id)
 c     WARNING : argument of this interface may be passed by reference
       INCLUDE 'stack.h'
       integer id(nsiz)
       integer mtlbsel
-      integer sel,tops
+      integer sel,tops,type
       integer iadr,sadr
 c     
       iadr(l)=l+l-1
       sadr(l)=(l/2)+1
 c
-      if(rhs.gt.2) then
+      if(rhs.gt.3) then
          call error(42)
          return
       endif
@@ -42,12 +43,9 @@ c
       endif
 c     
 c     standard matrix case
-      if(rhs.eq.2) then
-         call getorient(top,sel)
-         if(err.gt.0) return
-         top=top-1
-         if(sel.eq.-1) sel=mtlbsel(istk(il0+1),2)
-      endif
+      call  orientandtype(sel,type)
+      if (err.gt.0.or.err1.gt.0) return
+      if(sel.eq.-1) sel=mtlbsel(istk(il0+1),2)
 
       m=istk(il0+1)
       n=istk(il0+2)
index ca61c50..e11462a 100644 (file)
@@ -13,13 +13,13 @@ c     WARNING : argument of this interface may be passed by reference
       integer id(nsiz)
       logical ref
       integer mtlbsel
-      integer sel,tops
+      integer sel,tops,type
       integer iadr,sadr
 c     
       iadr(l)=l+l-1
       sadr(l)=(l/2)+1
 c
-      if(rhs.gt.2) then
+      if(rhs.gt.3) then
          call error(42)
          return
       endif
@@ -44,12 +44,9 @@ c
       endif
 
 c     standard matrix case
-      if(rhs.eq.2) then
-         call getorient(top,sel)
-         if(err.gt.0) return
-         top=top-1
-         if(sel.eq.-1) sel=mtlbsel(istk(il0+1),2)
-      endif
+      call  orientandtype(sel,type)
+      if (err.gt.0.or.err1.gt.0) return
+      if(sel.eq.-1) sel=mtlbsel(istk(il0+1),2)
 
       m=istk(il0+1)
       n=istk(il0+2)
index ee1e937..f24ed5d 100644 (file)
@@ -12,7 +12,7 @@ c     WARNING : argument of this interface may be passed by reference
       INCLUDE 'stack.h'
       integer id(nsiz)
       logical ref
-      integer sel,tops
+      integer sel,tops,type
       integer iadr,sadr
       integer mtlbsel
       double precision t,tr,ti
@@ -20,7 +20,7 @@ c
       iadr(l)=l+l-1
       sadr(l)=(l/2)+1
 c
-      if(rhs.gt.2) then
+      if(rhs.gt.3) then
          call error(42)
          return
       endif
@@ -39,12 +39,10 @@ c
 c
       if(istk(il0).eq.1) then
 c     standard matrix case
-         if(rhs.eq.2) then
-            call getorient(top,sel)
-            if(err.gt.0) return
-            top=top-1
-            if(sel.eq.-1) sel=mtlbsel(istk(il0+1),2)
-         endif
+         call  orientandtype(sel,type)
+         if (err.gt.0.or.err1.gt.0) return
+         if (sel.gt.2) return
+         if(sel.eq.-1) sel=mtlbsel(istk(il0+1),2)
          m=istk(il0+1)
          n=istk(il0+2)
          it=istk(il0+3)
@@ -118,17 +116,10 @@ c     standard matrix case
          lstk(top+1)=l1+mr*nr*(it+1)
       elseif(istk(il0).eq.5) then
 c     sparse matrix case
-         if(rhs.eq.2) then
-            call getorient(top,sel)
-            if(err.gt.0) return
-            top=top-1
-         endif
-         if(sel.ne.0) then
-            top=tops
-            call funnam(ids(1,pt+1),'prod',il0)
-            fun=-1
-            return
-         endif
+         call  orientandtype(sel,type)
+         if (err.gt.0.or.err1.gt.0) return
+         if (sel.ne.0) goto 100
+         if(sel.eq.-1) sel=mtlbsel(istk(il0+1),2)
          m=istk(il0+1)
          n=istk(il0+2)
          it=istk(il0+3)
@@ -173,11 +164,16 @@ c
          fun=16
          return
       else
-         top=tops
-         call funnam(ids(1,pt+1),'prod',il0)
-         fun=-1
+         goto 100
       endif
       return
+ 100  continue
+c     overloaded cases
+      top=tops
+      call funnam(ids(1,pt+1),'prod',il0)
+      fun=-1
+      return
+
       end
 c     -------------------------------
       
index da79546..1fda190 100644 (file)
@@ -12,16 +12,16 @@ c     WARNING : argument of this interface may be passed by reference
       INCLUDE 'stack.h'
       integer id(nsiz)
       logical ref
-      integer sel,tops
+      integer sel,tops,type
       integer iadr,sadr
       double precision dsum
       integer mtlbsel
-      
+     
 c     
       iadr(l)=l+l-1
       sadr(l)=(l/2)+1
 c
-      if(rhs.gt.2) then
+      if(rhs.gt.3) then
          call error(42)
          return
       endif
@@ -30,6 +30,7 @@ c
          return
       endif
 c
+
       tops=top
       sel=0
 c     
@@ -37,20 +38,16 @@ c
       ilr=il0
       if(istk(il0).lt.0) il0=iadr(istk(il0+1))
       ref=ilr.ne.il0
-c
+
+
       if(istk(il0).eq.1) then
 c     standard matrix case
+         call  orientandtype(sel,type)
+         if (err.gt.0.or.err1.gt.0) return
+         if (sel.gt.2) return
+         if(sel.eq.-1) sel=mtlbsel(istk(il0+1),2)
          m=istk(il0+1)
          n=istk(il0+2)
-         if(rhs.eq.2) then
-            call  getorient(top,sel)
-            if(err.gt.0) return
-            top=top-1
-            if(sel.eq.-1) sel=mtlbsel(istk(il0+1),2)
-
-         endif
-         
-            
          it=istk(il0+3)
          mn=m*n
          l1=sadr(ilr+4)
@@ -128,18 +125,10 @@ c     matrix of polynomial case
 c     .  *call* polelm
          return
       elseif(istk(il0).eq.5) then
-         if(rhs.eq.2) then
-            call  getorient(top,sel)
-            if(err.gt.0) return
-            top=top-1
-         endif
-         if(sel.ne.0) then
-            top=tops
-            call funnam(ids(1,pt+1),'sum',il0)
-            fun=-1
-            return
-         endif
-c     sparse matrix case
+c     .  sparse matrix case
+         call  orientandtype(sel,type)
+         if (err.gt.0.or.err1.gt.0) return
+         if(sel.ne.0) goto 100
          it=istk(il0+3)
          m=istk(il0+1)
          mn=istk(il0+4)
@@ -158,10 +147,14 @@ c     sparse matrix case
          lstk(top+1)=l1+(it+1)
       else
 c     other cases
-         top=tops
-         call funnam(ids(1,pt+1),'sum',il0)
-         fun=-1
+         goto 100
       endif
       return
+ 100  continue
+C     overloaded cases
+      top=tops
+      call funnam(ids(1,pt+1),'sum',il0)
+      fun=-1
+      return
       end
 c     -------------------------------
index 1c06d05..3e018e4 100644 (file)
@@ -7,6 +7,47 @@ c you should have received as part of this distribution.  The terms
 c are also available at    
 c http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
 c
+      subroutine orientandtype(orient,type)
+      INCLUDE 'stack.h'
+      integer orient,type,native
+      parameter (native=0)
+      if(rhs.eq.3) then
+c     .  last argument must be "native" or "double" and previous must be
+c     .  an orientation flag
+         call getresulttype(top,type)
+         if (type.lt.0) then
+            err=3
+            if (type.eq.-2) then
+               call error(55)
+            else
+               call error(116)
+            endif
+            return
+         endif
+         top=top-1
+         call  getorient(top,orient)
+         if(err.gt.0) return
+         top=top-1
+      elseif(rhs.eq.2) then
+c     .  last argument must be an orientation flag or "native" or "double" 
+         call getresulttype(top,type)
+         if (type.lt.0) then
+c     .     orientation flag
+            type=native
+            call  getorient(top,orient)
+            if(err.gt.0) return
+         else
+            orient=0
+         endif
+         top=top-1
+      else
+         type=native
+         orient=0
+      endif
+      return
+      end
+
       subroutine getorient(k,sel)
       INCLUDE 'stack.h'
 c
@@ -28,7 +69,7 @@ c
             return
          endif
          sel=stk(sadr(il+4))
-         if(sel.ne.1.and.sel.ne.2) then
+         if(sel.lt.1) then
             err=2
             call error(44)
             return
@@ -61,3 +102,31 @@ c
       end
 
 c     -------------------------------
+      subroutine getresulttype(k,type)
+      INCLUDE 'stack.h'
+      integer type
+      character*7 temp
+      integer iadr,sadr
+c     
+      iadr(l)=l+l-1
+      sadr(l)=(l/2)+1
+
+
+      il=iadr(lstk(k))
+      if (istk(il).lt.0) il=iadr(istk(il+1))
+      if (istk(il).ne.10.or.istk(il+1).ne.1.or.istk(il+2).ne.1) then
+         type=-2
+      endif
+      n=min(7,istk(il+5)-1)
+      id=il+4
+      l=id+2
+      call codetoascii(min(n,7),istk(l),temp)
+      if (temp(1:n).eq.'native') then
+         type=0
+      elseif(temp(1:n).eq.'double') then
+         type=1
+      else
+         type=-1
+      endif
+      return
+      end
diff --git a/scilab/modules/elementary_functions/tests/unit_tests/cumprod.dia.ref b/scilab/modules/elementary_functions/tests/unit_tests/cumprod.dia.ref
new file mode 100644 (file)
index 0000000..88a434d
--- /dev/null
@@ -0,0 +1,161 @@
+// =============================================================================
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2010 - INRIA - Serge Steer
+//
+//  This file is distributed under the same license as the Scilab package.
+// =============================================================================
+// <-- JVM NOT MANDATORY -->
+//cumprod
+//Empty matrices
+T=list(list(),list('native'),list('double'));
+for typ=T
+  if cumprod([],typ(:))<>[] then bugmes();quit;end
+  if cumprod([],'*',typ(:))<>[] then bugmes();quit;end
+  if cumprod([],1,typ(:))<>[] then bugmes();quit;end
+  if cumprod([],2,typ(:))<>[] then bugmes();quit;end
+  if cumprod([],3,typ(:))<>[] then bugmes();quit;end
+end
+//=======================================================================
+//float matrices
+d=[1 10;254 9];
+T=list(list(),list('native'),list('double'));
+for typ=T
+  if or(cumprod(d,typ(:))<>[1,2540;254,22860]) then bugmes();quit;end
+  if or(cumprod(d,'*',typ(:))<>[1,2540;254,22860]) then bugmes();quit;end
+  if or(cumprod(d,1,typ(:))<>[1,10;254,90]) then bugmes();quit;end
+  if or(cumprod(d,2,typ(:))<>[1,10;254,2286]) then bugmes();quit;end
+  if or(cumprod(d,3,typ(:))<>d) then bugmes();quit;end
+end
+//hypermatrices of floats
+d=[1 10;254 9];d(1,1,2)=1;
+T=list(list(),list('native'),list('double'));
+for typ=T
+  if or(cumprod(d,typ(:))<>hypermat([2,2,2],[1;254;2540;22860;22860;0;0;0])) then bugmes();quit;end
+  if or(cumprod(d,'*',typ(:))<>hypermat([2,2,2],[1;254;2540;22860;22860;0;0;0])) then bugmes();quit;end
+  if or(cumprod(d,1,typ(:))<>hypermat([2,2,2],[1;254;10;90;1;0;0;0])) then bugmes();quit;end
+  if or(cumprod(d,2,typ(:))<>hypermat([2,2,2],[1;254;10;2286;1;0;0;0])) then bugmes();quit;end
+  if or(cumprod(d,3,typ(:))<>hypermat([2,2,2],[1;254;10;9;1;0;0;0])) then bugmes();quit;end
+  if or(cumprod(d,5,typ(:))<>d) then bugmes();quit;end
+end
+//=======================================================================
+//Integers
+i=uint8([1 10;254 9]);
+for typ=list(list(),list('native'));
+  if or(cumprod(i,typ(:))<>uint8([1,236;254,76])) then bugmes();quit;end
+  if or(cumprod(i,'*',typ(:))<>uint8([1,236;254,76])) then bugmes();quit;end
+  if or(cumprod(i,1,typ(:))<>uint8([1,10;254,90])) then bugmes();quit;end
+  if or(cumprod(i,2,typ(:))<>uint8([1,10;254,238])) then bugmes();quit;end
+  if or(cumprod(i,3,typ(:))<>i) then bugmes();quit;end
+end
+if or(cumprod(i,'double')<>[1,2540;254,22860]) then bugmes();quit;end
+if or(cumprod(i,'*','double')<>[1,2540;254,22860]) then bugmes();quit;end
+if or(cumprod(i,1,'double')<>[1,10;254,90]) then bugmes();quit;end
+if or(cumprod(i,2,'double')<>[1,10;254,2286]) then bugmes();quit;end
+if or(cumprod(i,3,'double')<>double(i)) then bugmes();quit;end
+//with hypermatrices
+i=uint8([1 10;254 9]);i(1,1,2)=uint8(1);
+for typ=list(list(),list('native'));
+  if or(cumprod(i,typ(:))<>hypermat([2,2,2],uint8([1;254;236;76;76;0;0;0]))) then bugmes();quit;end
+  if or(cumprod(i,'*',typ(:))<>hypermat([2,2,2],uint8([1;254;236;76;76;0;0;0]))) then bugmes();quit;end
+  if or(cumprod(i,1,typ(:))<>hypermat([2,2,2],uint8([1;254;10;90;1;0;0;0]))) then bugmes();quit;end
+  if or(cumprod(i,2,typ(:))<>hypermat([2,2,2],uint8([1;254;10;238;1;0;0;0]))) then bugmes();quit;end
+  if or(cumprod(i,3,typ(:))<>hypermat([2,2,2],uint8([1;254;10;9;1;0;0;0]))) then bugmes();quit;end
+  if or(cumprod(i,5,typ(:))<>i) then bugmes();quit;end
+end
+if or(cumprod(i,'double')<>hypermat([2,2,2],[1;254;2540;22860;22860;0;0;0])) then bugmes();quit;end
+if or(cumprod(i,'*','double')<>hypermat([2,2,2],[1;254;2540;22860;22860;0;0;0])) then bugmes();quit;end
+if or(cumprod(i,1,'double')<>hypermat([2,2,2],[1;254;10;90;1;0;0;0])) then bugmes();quit;end
+if or(cumprod(i,2,'double')<>hypermat([2,2,2],[1;254;10;2286;1;0;0;0])) then bugmes();quit;end
+if or(cumprod(i,3,'double')<>hypermat([2,2,2],[1;254;10;9;1;0;0;0])) then bugmes();quit;end
+if or(cumprod(i,5,'double')<>double(i)) then bugmes();quit;end
+//=======================================================================
+//Matrices of Polynomials 
+s=%s;p=[s s+1;s^2 0];
+T=list(list(),list('native'),list('double'));
+for typ=T
+  if or(cumprod(p,typ(:))<>[s,s^3+s^4;s^3,0*s]) then bugmes();quit;end
+  if or(cumprod(p,'*',typ(:))<>[s,s^3+s^4;s^3,0*s]) then bugmes();quit;end
+  if or(cumprod(p,1,typ(:))<>[s,1+s;s^3,0*s]) then bugmes();quit;end
+  if or(cumprod(p,2,typ(:))<>[s,s+s^2;s^2,0*s]) then bugmes();quit;end
+  if or(cumprod(p,3,typ(:))<>p) then bugmes();quit;end
+end
+//with hypermatrices
+s=%s;p=[s s+1;s^2 0];p(1,1,2)=-1;
+T=list(list(),list('native'),list('double'));
+for typ=T
+  if or(cumprod(p,typ(:))<>hypermat([2,2,2],[s;s^3;s^3+s^4;0*s;0*s;0*s;0*s;0*s])) then bugmes();quit;end
+  if or(cumprod(p,'*',typ(:))<>hypermat([2,2,2],[s;s^3;s^3+s^4;0*s;0*s;0*s;0*s;0*s])) then bugmes();quit;end
+  if or(cumprod(p,1,typ(:))<>hypermat([2,2,2],[s;s^3;1+s;0*s;-1;0*s;0*s;0*s])) then bugmes();quit;end
+  if or(cumprod(p,2,typ(:))<>hypermat([2,2,2],[s;s^2;s+s^2;0*s;-1;0*s;0*s;0*s])) then bugmes();quit;end
+  if or(cumprod(p,3,typ(:))<>hypermat([2,2,2],[s;s^2;1+s;0*s;-s;0*s;0*s;0*s])) then bugmes();quit;end
+  if or(cumprod(p,5,typ(:))<>p) then bugmes();quit;end
+end
+//=======================================================================
+//Matrices of rationals
+s=%s;r=1.0 ./[s s+1;s^2 1];
+T=list(list(),list('native'),list('double'));
+for typ=T
+  if or(cumprod(r,typ(:))<>[1,1;1,1]./[s,s^3+s^4;s^3,s^3+s^4]) then bugmes();quit;end
+  if or(cumprod(r,'*',typ(:))<>[1,1;1,1]./[s,s^3+s^4;s^3,s^3+s^4]) then bugmes();quit;end
+  if or(cumprod(r,1,typ(:))<>[1,1;1,1]./[s,1+s;s^3,1+s]) then bugmes();quit;end
+  if or(cumprod(r,2,typ(:))<>[1,1;1,1]./[s,s+s^2;s^2,s^2]) then bugmes();quit;end
+  if or(cumprod(r,3,typ(:))<>r) then bugmes();quit;end
+end
+//=======================================================================
+///Matrices of boolean
+b=[%t %t;%f %t];
+for typ=list(list(),list('double'));
+  if or(cumprod(b,typ(:))<>[1,0;0,0]) then bugmes();quit;end
+  if or(cumprod(b,'*',typ(:))<>[1,0;0,0]) then bugmes();quit;end
+  if or(cumprod(b,1,typ(:))<>[1,1;0,1]) then bugmes();quit;end
+  if or(cumprod(b,2,typ(:))<>[1,1;0,0]) then bugmes();quit;end
+  if or(cumprod(b,3,typ(:))<>double(b)) then bugmes();quit;end
+end
+if or(cumprod(b,'native')<>[%t,%f;%f,%f]) then bugmes();quit;end
+if or(cumprod(b,'*','native')<>[%t,%f;%f,%f]) then bugmes();quit;end
+if or(cumprod(b,1,'native')<>[%t,%t;%f,%t]) then bugmes();quit;end
+if or(cumprod(b,2,'native')<>[%t,%t;%f,%f]) then bugmes();quit;end
+if or(cumprod(b,3,'native')<>b) then bugmes();quit;end
+//with hypermatrices
+b=[%t %t;%f %t];b(1,1,2)=%f;
+for typ=list(list(),list('double'));
+  if or(cumprod(b,typ(:))<>hypermat([2,2,2],[1;0;0;0;0;0;0;0])) then bugmes();quit;end
+  if or(cumprod(b,'*',typ(:))<>hypermat([2,2,2],[1;0;0;0;0;0;0;0])) then bugmes();quit;end
+  if or(cumprod(b,1,typ(:))<>hypermat([2,2,2],[1;0;1;1;0;0;0;0])) then bugmes();quit;end
+  if or(cumprod(b,2,typ(:))<>hypermat([2,2,2],[1;0;1;0;0;0;0;0])) then bugmes();quit;end
+  if or(cumprod(b,3,typ(:))<>hypermat([2,2,2],[1;0;1;1;0;0;0;0])) then bugmes();quit;end
+  if or(cumprod(b,5,typ(:))<>double(b)) then bugmes();quit;end
+end
+if or(cumprod(b,'native')<>hypermat([2,2,2],[%t;%f;%f;%f;%f;%f;%f;%f])) then bugmes();quit;end
+if or(cumprod(b,'*','native')<>hypermat([2,2,2],[%t;%f;%f;%f;%f;%f;%f;%f])) then bugmes();quit;end
+if or(cumprod(b,1,'native')<>hypermat([2,2,2],[%t;%f;%t;%t;%f;%f;%f;%f])) then bugmes();quit;end
+if or(cumprod(b,2,'native')<>hypermat([2,2,2],[%t;%f;%t;%f;%f;%f;%f;%f])) then bugmes();quit;end
+if or(cumprod(b,3,'native')<>hypermat([2,2,2],[%t;%f;%t;%t;%f;%f;%f;%f])) then bugmes();quit;end
+if or(cumprod(b,5,'native')<>b) then bugmes();quit;end
+//=======================================================================
+//sparse matrices of floats
+s=sparse([1 10 0;-1 0 9]);
+T=list(list(),list('native'),list('double'));
+for typ=T
+  if or(cumprod(s,typ(:))<>sparse([1,1;1,2;2,1],[1;-10;-1],[2,3])) then bugmes();quit;end
+  if or(cumprod(s,'*',typ(:))<>sparse([1,1;1,2;2,1],[1;-10;-1],[2,3])) then bugmes();quit;end
+  if or(cumprod(s,1,typ(:))<>sparse([1,1;1,2;2,1],[1;10;-1],[2,3])) then bugmes();quit;end
+  if or(cumprod(s,2,typ(:))<>sparse([1,1;1,2;2,1],[1;10;-1],[2,3])) then bugmes();quit;end
+  if or(cumprod(s,3,typ(:))<>s) then bugmes();quit;end
+end
+//=======================================================================
+//sparse  matrices of boolean
+bs=sparse([%t %t %f;%t %t %t]);
+for typ=list(list(),list('double'));
+  if or(cumprod(bs,typ(:))<>sparse([1,1;1,2;2,1;2,2],[1;1;1;1],[2,3])) then bugmes();quit;end
+  if or(cumprod(bs,'*',typ(:))<>sparse([1,1;1,2;2,1;2,2],[1;1;1;1],[2,3])) then bugmes();quit;end
+  if or(cumprod(bs,1,typ(:))<>sparse([1,1;1,2;2,1;2,2],[1;1;1;1],[2,3])) then bugmes();quit;end
+  if or(cumprod(bs,2,typ(:))<>sparse([1,1;1,2;2,1;2,2;2,3],[1;1;1;1;1],[2,3])) then bugmes();quit;end
+  if or(cumprod(bs,3,typ(:))<>bool2s(bs)) then bugmes();quit;end
+end
+if or(cumprod(bs,'native')<>sparse([1,1;1,2;2,1;2,2],[%t;%t;%t;%t],[2,3])) then bugmes();quit;end
+if or(cumprod(bs,'*','native')<>sparse([1,1;1,2;2,1;2,2],[%t;%t;%t;%t],[2,3])) then bugmes();quit;end
+if or(cumprod(bs,1,'native')<>sparse([1,1;1,2;2,1;2,2],[%t;%t;%t;%t],[2,3])) then bugmes();quit;end
+if or(cumprod(bs,2,'native')<>sparse([1,1;1,2;2,1;2,2;2,3],[%t;%t;%t;%t;%t],[2,3])) then bugmes();quit;end
+if or(cumprod(bs,3,'native')<>bs) then bugmes();quit;end
+// TODO : test the "m" option
diff --git a/scilab/modules/elementary_functions/tests/unit_tests/cumprod.tst b/scilab/modules/elementary_functions/tests/unit_tests/cumprod.tst
new file mode 100644 (file)
index 0000000..2b44111
--- /dev/null
@@ -0,0 +1,181 @@
+// =============================================================================
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2010 - INRIA - Serge Steer
+//
+//  This file is distributed under the same license as the Scilab package.
+// =============================================================================
+
+// <-- JVM NOT MANDATORY -->
+
+//cumprod
+//Empty matrices
+T=list(list(),list('native'),list('double'));
+for typ=T
+  if cumprod([],typ(:))<>[] then pause,end
+  if cumprod([],'*',typ(:))<>[] then pause,end
+  if cumprod([],1,typ(:))<>[] then pause,end
+  if cumprod([],2,typ(:))<>[] then pause,end
+  if cumprod([],3,typ(:))<>[] then pause,end
+end
+
+//=======================================================================
+//float matrices
+d=[1 10;254 9];
+T=list(list(),list('native'),list('double'));
+for typ=T
+  if or(cumprod(d,typ(:))<>[1,2540;254,22860]) then pause,end
+  if or(cumprod(d,'*',typ(:))<>[1,2540;254,22860]) then pause,end
+  if or(cumprod(d,1,typ(:))<>[1,10;254,90]) then pause,end
+  if or(cumprod(d,2,typ(:))<>[1,10;254,2286]) then pause,end
+  if or(cumprod(d,3,typ(:))<>d) then pause,end
+end
+
+//hypermatrices of floats
+d=[1 10;254 9];d(1,1,2)=1;
+T=list(list(),list('native'),list('double'));
+for typ=T
+  if or(cumprod(d,typ(:))<>hypermat([2,2,2],[1;254;2540;22860;22860;0;0;0])) then pause,end
+  if or(cumprod(d,'*',typ(:))<>hypermat([2,2,2],[1;254;2540;22860;22860;0;0;0])) then pause,end
+  if or(cumprod(d,1,typ(:))<>hypermat([2,2,2],[1;254;10;90;1;0;0;0])) then pause,end
+  if or(cumprod(d,2,typ(:))<>hypermat([2,2,2],[1;254;10;2286;1;0;0;0])) then pause,end
+  if or(cumprod(d,3,typ(:))<>hypermat([2,2,2],[1;254;10;9;1;0;0;0])) then pause,end
+  if or(cumprod(d,5,typ(:))<>d) then pause,end
+end
+
+//=======================================================================
+//Integers
+i=uint8([1 10;254 9]);
+for typ=list(list(),list('native'));
+  if or(cumprod(i,typ(:))<>uint8([1,236;254,76])) then pause,end
+  if or(cumprod(i,'*',typ(:))<>uint8([1,236;254,76])) then pause,end
+  if or(cumprod(i,1,typ(:))<>uint8([1,10;254,90])) then pause,end
+  if or(cumprod(i,2,typ(:))<>uint8([1,10;254,238])) then pause,end
+  if or(cumprod(i,3,typ(:))<>i) then pause,end
+end
+
+if or(cumprod(i,'double')<>[1,2540;254,22860]) then pause,end
+if or(cumprod(i,'*','double')<>[1,2540;254,22860]) then pause,end
+if or(cumprod(i,1,'double')<>[1,10;254,90]) then pause,end
+if or(cumprod(i,2,'double')<>[1,10;254,2286]) then pause,end
+if or(cumprod(i,3,'double')<>double(i)) then pause,end
+
+//with hypermatrices
+i=uint8([1 10;254 9]);i(1,1,2)=uint8(1);
+for typ=list(list(),list('native'));
+  if or(cumprod(i,typ(:))<>hypermat([2,2,2],uint8([1;254;236;76;76;0;0;0]))) then pause,end
+  if or(cumprod(i,'*',typ(:))<>hypermat([2,2,2],uint8([1;254;236;76;76;0;0;0]))) then pause,end
+  if or(cumprod(i,1,typ(:))<>hypermat([2,2,2],uint8([1;254;10;90;1;0;0;0]))) then pause,end
+  if or(cumprod(i,2,typ(:))<>hypermat([2,2,2],uint8([1;254;10;238;1;0;0;0]))) then pause,end
+  if or(cumprod(i,3,typ(:))<>hypermat([2,2,2],uint8([1;254;10;9;1;0;0;0]))) then pause,end
+  if or(cumprod(i,5,typ(:))<>i) then pause,end
+end
+
+
+if or(cumprod(i,'double')<>hypermat([2,2,2],[1;254;2540;22860;22860;0;0;0])) then pause,end
+if or(cumprod(i,'*','double')<>hypermat([2,2,2],[1;254;2540;22860;22860;0;0;0])) then pause,end
+if or(cumprod(i,1,'double')<>hypermat([2,2,2],[1;254;10;90;1;0;0;0])) then pause,end
+if or(cumprod(i,2,'double')<>hypermat([2,2,2],[1;254;10;2286;1;0;0;0])) then pause,end
+if or(cumprod(i,3,'double')<>hypermat([2,2,2],[1;254;10;9;1;0;0;0])) then pause,end
+if or(cumprod(i,5,'double')<>double(i)) then pause,end
+
+//=======================================================================
+//Matrices of Polynomials 
+s=%s;p=[s s+1;s^2 0];
+T=list(list(),list('native'),list('double'));
+for typ=T
+  if or(cumprod(p,typ(:))<>[s,s^3+s^4;s^3,0*s]) then pause,end
+  if or(cumprod(p,'*',typ(:))<>[s,s^3+s^4;s^3,0*s]) then pause,end
+  if or(cumprod(p,1,typ(:))<>[s,1+s;s^3,0*s]) then pause,end
+  if or(cumprod(p,2,typ(:))<>[s,s+s^2;s^2,0*s]) then pause,end
+  if or(cumprod(p,3,typ(:))<>p) then pause,end
+end
+
+//with hypermatrices
+s=%s;p=[s s+1;s^2 0];p(1,1,2)=-1;
+T=list(list(),list('native'),list('double'));
+for typ=T
+  if or(cumprod(p,typ(:))<>hypermat([2,2,2],[s;s^3;s^3+s^4;0*s;0*s;0*s;0*s;0*s])) then pause,end
+  if or(cumprod(p,'*',typ(:))<>hypermat([2,2,2],[s;s^3;s^3+s^4;0*s;0*s;0*s;0*s;0*s])) then pause,end
+  if or(cumprod(p,1,typ(:))<>hypermat([2,2,2],[s;s^3;1+s;0*s;-1;0*s;0*s;0*s])) then pause,end
+  if or(cumprod(p,2,typ(:))<>hypermat([2,2,2],[s;s^2;s+s^2;0*s;-1;0*s;0*s;0*s])) then pause,end
+  if or(cumprod(p,3,typ(:))<>hypermat([2,2,2],[s;s^2;1+s;0*s;-s;0*s;0*s;0*s])) then pause,end
+  if or(cumprod(p,5,typ(:))<>p) then pause,end
+end
+//=======================================================================
+//Matrices of rationals
+s=%s;r=1.0 ./[s s+1;s^2 1];
+T=list(list(),list('native'),list('double'));
+for typ=T
+  if or(cumprod(r,typ(:))<>[1,1;1,1]./[s,s^3+s^4;s^3,s^3+s^4]) then pause,end
+  if or(cumprod(r,'*',typ(:))<>[1,1;1,1]./[s,s^3+s^4;s^3,s^3+s^4]) then pause,end
+  if or(cumprod(r,1,typ(:))<>[1,1;1,1]./[s,1+s;s^3,1+s]) then pause,end
+  if or(cumprod(r,2,typ(:))<>[1,1;1,1]./[s,s+s^2;s^2,s^2]) then pause,end
+  if or(cumprod(r,3,typ(:))<>r) then pause,end
+end
+
+//=======================================================================
+///Matrices of boolean
+
+b=[%t %t;%f %t];
+for typ=list(list(),list('double'));
+  if or(cumprod(b,typ(:))<>[1,0;0,0]) then pause,end
+  if or(cumprod(b,'*',typ(:))<>[1,0;0,0]) then pause,end
+  if or(cumprod(b,1,typ(:))<>[1,1;0,1]) then pause,end
+  if or(cumprod(b,2,typ(:))<>[1,1;0,0]) then pause,end
+  if or(cumprod(b,3,typ(:))<>double(b)) then pause,end
+end
+if or(cumprod(b,'native')<>[%t,%f;%f,%f]) then pause,end
+if or(cumprod(b,'*','native')<>[%t,%f;%f,%f]) then pause,end
+if or(cumprod(b,1,'native')<>[%t,%t;%f,%t]) then pause,end
+if or(cumprod(b,2,'native')<>[%t,%t;%f,%f]) then pause,end
+if or(cumprod(b,3,'native')<>b) then pause,end
+
+//with hypermatrices
+b=[%t %t;%f %t];b(1,1,2)=%f;
+for typ=list(list(),list('double'));
+  if or(cumprod(b,typ(:))<>hypermat([2,2,2],[1;0;0;0;0;0;0;0])) then pause,end
+  if or(cumprod(b,'*',typ(:))<>hypermat([2,2,2],[1;0;0;0;0;0;0;0])) then pause,end
+  if or(cumprod(b,1,typ(:))<>hypermat([2,2,2],[1;0;1;1;0;0;0;0])) then pause,end
+  if or(cumprod(b,2,typ(:))<>hypermat([2,2,2],[1;0;1;0;0;0;0;0])) then pause,end
+  if or(cumprod(b,3,typ(:))<>hypermat([2,2,2],[1;0;1;1;0;0;0;0])) then pause,end
+  if or(cumprod(b,5,typ(:))<>double(b)) then pause,end
+end
+
+if or(cumprod(b,'native')<>hypermat([2,2,2],[%t;%f;%f;%f;%f;%f;%f;%f])) then pause,end
+if or(cumprod(b,'*','native')<>hypermat([2,2,2],[%t;%f;%f;%f;%f;%f;%f;%f])) then pause,end
+if or(cumprod(b,1,'native')<>hypermat([2,2,2],[%t;%f;%t;%t;%f;%f;%f;%f])) then pause,end
+if or(cumprod(b,2,'native')<>hypermat([2,2,2],[%t;%f;%t;%f;%f;%f;%f;%f])) then pause,end
+if or(cumprod(b,3,'native')<>hypermat([2,2,2],[%t;%f;%t;%t;%f;%f;%f;%f])) then pause,end
+if or(cumprod(b,5,'native')<>b) then pause,end
+
+//=======================================================================
+//sparse matrices of floats
+s=sparse([1 10 0;-1 0 9]);
+T=list(list(),list('native'),list('double'));
+for typ=T
+  if or(cumprod(s,typ(:))<>sparse([1,1;1,2;2,1],[1;-10;-1],[2,3])) then pause,end
+  if or(cumprod(s,'*',typ(:))<>sparse([1,1;1,2;2,1],[1;-10;-1],[2,3])) then pause,end
+  if or(cumprod(s,1,typ(:))<>sparse([1,1;1,2;2,1],[1;10;-1],[2,3])) then pause,end
+  if or(cumprod(s,2,typ(:))<>sparse([1,1;1,2;2,1],[1;10;-1],[2,3])) then pause,end
+  if or(cumprod(s,3,typ(:))<>s) then pause,end
+end
+
+//=======================================================================
+//sparse  matrices of boolean
+bs=sparse([%t %t %f;%t %t %t]);
+for typ=list(list(),list('double'));
+  if or(cumprod(bs,typ(:))<>sparse([1,1;1,2;2,1;2,2],[1;1;1;1],[2,3])) then pause,end
+  if or(cumprod(bs,'*',typ(:))<>sparse([1,1;1,2;2,1;2,2],[1;1;1;1],[2,3])) then pause,end
+  if or(cumprod(bs,1,typ(:))<>sparse([1,1;1,2;2,1;2,2],[1;1;1;1],[2,3])) then pause,end
+  if or(cumprod(bs,2,typ(:))<>sparse([1,1;1,2;2,1;2,2;2,3],[1;1;1;1;1],[2,3])) then pause,end
+  if or(cumprod(bs,3,typ(:))<>bool2s(bs)) then pause,end
+end
+
+if or(cumprod(bs,'native')<>sparse([1,1;1,2;2,1;2,2],[%t;%t;%t;%t],[2,3])) then pause,end
+if or(cumprod(bs,'*','native')<>sparse([1,1;1,2;2,1;2,2],[%t;%t;%t;%t],[2,3])) then pause,end
+
+if or(cumprod(bs,1,'native')<>sparse([1,1;1,2;2,1;2,2],[%t;%t;%t;%t],[2,3])) then pause,end
+if or(cumprod(bs,2,'native')<>sparse([1,1;1,2;2,1;2,2;2,3],[%t;%t;%t;%t;%t],[2,3])) then pause,end
+if or(cumprod(bs,3,'native')<>bs) then pause,end
+
+// TODO : test the "m" option
diff --git a/scilab/modules/elementary_functions/tests/unit_tests/cumsum.dia.ref b/scilab/modules/elementary_functions/tests/unit_tests/cumsum.dia.ref
new file mode 100644 (file)
index 0000000..3bcd05d
--- /dev/null
@@ -0,0 +1,149 @@
+// =============================================================================
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2010 - INRIA - Serge Steer
+//
+//  This file is distributed under the same license as the Scilab package.
+// =============================================================================
+// <-- JVM NOT MANDATORY -->
+//empty matrices
+T=list(list(),list('native'),list('double'));
+for typ=T
+  if cumsum([],typ(:))<>[] then bugmes();quit;end
+  if cumsum([],'*',typ(:))<>[] then bugmes();quit;end
+  if cumsum([],1,typ(:))<>[] then bugmes();quit;end
+  if cumsum([],2,typ(:))<>[] then bugmes();quit;end
+  if cumsum([],3,typ(:))<>[] then bugmes();quit;end
+end
+//=======================================================================
+//float matrices
+d=[1 10;254 9];
+T=list(list(),list('native'),list('double'));
+for typ=T
+  if or(cumsum(d,typ(:))<>[1,265;255,274]) then bugmes();quit;end
+  if or(cumsum(d,'*',typ(:))<>[1,265;255,274]) then bugmes();quit;end
+  if or(cumsum(d,1,typ(:))<>[1,10;255,19]) then bugmes();quit;end
+  if or(cumsum(d,2,typ(:))<>[1,11;254,263]) then bugmes();quit;end
+  if or(cumsum(d,3,typ(:))<>d) then bugmes();quit;end
+end
+//hypermatrices of floats
+d=[1 10;254 9];d(1,1,2)=1;
+T=list(list(),list('native'),list('double'));
+for typ=T
+  if or(cumsum(d,typ(:))<>hypermat([2,2,2],[1;255;265;274;275;275;275;275])) then bugmes();quit;end
+  if or(cumsum(d,'*',typ(:))<>hypermat([2,2,2],[1;255;265;274;275;275;275;275])) then bugmes();quit;end
+  if or(cumsum(d,1,typ(:))<>hypermat([2,2,2],[1;255;10;19;1;1;0;0])) then bugmes();quit;end
+  if or(cumsum(d,2,typ(:))<>hypermat([2,2,2],[1;254;11;263;1;0;1;0])) then bugmes();quit;end
+  if or(cumsum(d,3,typ(:))<>hypermat([2,2,2],[1;254;10;9;2;254;10;9])) then bugmes();quit;end
+  if or(cumsum(d,5,typ(:))<>d) then bugmes();quit;end
+end
+//=======================================================================
+//Integers
+i=uint8([1 10;254 9]);
+for typ=list(list(),list('native'));
+  if or(cumsum(i,typ(:))<>uint8([1,9;255,18])) then bugmes();quit;end
+  if or(cumsum(i,'*',typ(:))<>uint8([1,9;255,18])) then bugmes();quit;end
+  if or(cumsum(i,1,typ(:))<>uint8([1,10;255,19])) then bugmes();quit;end
+  if or(cumsum(i,2,typ(:))<>uint8([1,11;254,7])) then bugmes();quit;end
+  if or(cumsum(i,3,typ(:))<>i) then bugmes();quit;end
+end
+if or(cumsum(i,'double')<>[1,265;255,274]) then bugmes();quit;end
+if or(cumsum(i,'*','double')<>[1,265;255,274]) then bugmes();quit;end
+if or(cumsum(i,1,'double')<>[1,10;255,19]) then bugmes();quit;end
+if or(cumsum(i,2,'double')<>[1,11;254,263]) then bugmes();quit;end
+if or(cumsum(i,3,'double')<>double(i)) then bugmes();quit;end
+//with hypermatrices
+i=uint8([1 10;254 9]);i(1,1,2)=uint8(1);
+for typ=list(list(),list('native'));
+  if or(cumsum(i,typ(:))<>hypermat([2,2,2],uint8([1;255;9;18;19;19;19;19]))) then bugmes();quit;end
+  if or(cumsum(i,'*',typ(:))<>hypermat([2,2,2],uint8([1;255;9;18;19;19;19;19]))) then bugmes();quit;end
+  if or(cumsum(i,1,typ(:))<>hypermat([2,2,2],uint8([1;255;10;19;1;1;0;0]))) then bugmes();quit;end
+  if or(cumsum(i,2,typ(:))<>hypermat([2,2,2],uint8([1;254;11;7;1;0;1;0]))) then bugmes();quit;end
+  if or(cumsum(i,3,typ(:))<>hypermat([2,2,2],uint8([1;254;10;9;2;254;10;9]))) then bugmes();quit;end
+  if or(cumsum(i,5,typ(:))<>i) then bugmes();quit;end
+end
+if or(cumsum(i,'double')<>hypermat([2,2,2],[1;255;265;274;275;275;275;275])) then bugmes();quit;end
+if or(cumsum(i,'*','double')<>hypermat([2,2,2],[1;255;265;274;275;275;275;275])) then bugmes();quit;end
+if or(cumsum(i,1,'double')<>hypermat([2,2,2],[1;255;10;19;1;1;0;0])) then bugmes();quit;end
+if or(cumsum(i,2,'double')<>hypermat([2,2,2],[1;254;11;263;1;0;1;0])) then bugmes();quit;end
+if or(cumsum(i,3,'double')<>hypermat([2,2,2],[1;254;10;9;2;254;10;9])) then bugmes();quit;end
+if or(cumsum(i,5,'double')<>double(i)) then bugmes();quit;end
+//=======================================================================
+//Matrices of Polynomials
+s=%s;p=[s s+1;s^2 0];
+T=list(list(),list('native'),list('double'));
+for typ=T
+  if or(cumsum(p,typ(:))<>[s,1+2*s+s^2;s+s^2,1+2*s+s^2]) then bugmes();quit;end
+  if or(cumsum(p,'*',typ(:))<>[s,1+2*s+s^2;s+s^2,1+2*s+s^2]) then bugmes();quit;end
+  if or(cumsum(p,1,typ(:))<>[s,1+s;s+s^2,1+s]) then bugmes();quit;end
+  if or(cumsum(p,2,typ(:))<>[s,1+2*s;s^2,s^2]) then bugmes();quit;end
+  if or(cumsum(p,3,typ(:))<>p) then bugmes();quit;end
+end
+//with hypermatrices
+s=%s;p=[s s+1;s^2 0];p(1,1,2)=-1;
+T=list(list(),list('native'),list('double'));
+for typ=T
+  if or(cumsum(p,typ(:))<>hypermat([2,2,2],[s;s+s^2;1+2*s+s^2;1+2*s+s^2;2*s+s^2;2*s+s^2;2*s+s^2;2*s+s^2])) then bugmes();quit;end
+  if or(cumsum(p,'*',typ(:))<>hypermat([2,2,2],[s;s+s^2;1+2*s+s^2;1+2*s+s^2;2*s+s^2;2*s+s^2;2*s+s^2;2*s+s^2])) then bugmes();quit;end
+  if or(cumsum(p,1,typ(:))<>hypermat([2,2,2],[s;s+s^2;1+s;1+s;-1;-1;0*s;0*s])) then bugmes();quit;end
+  if or(cumsum(p,2,typ(:))<>hypermat([2,2,2],[s;s^2;1+2*s;s^2;-1;0*s;-1;0*s])) then bugmes();quit;end
+  if or(cumsum(p,3,typ(:))<>hypermat([2,2,2],[s;s^2;1+s;0*s;-1+s;s^2;1+s;0*s])) then bugmes();quit;end
+  if or(cumsum(p,5,typ(:))<>p) then bugmes();quit;end
+end
+//=======================================================================
+///Matrices of boolean
+b=[%t %t;%f %t];
+for typ=list(list(),list('double'));
+  if or(cumsum(b,typ(:))<>[1,2;1,3]) then bugmes();quit;end
+  if or(cumsum(b,'*',typ(:))<>[1,2;1,3]) then bugmes();quit;end
+  if or(cumsum(b,1,typ(:))<>[1,1;1,2]) then bugmes();quit;end
+  if or(cumsum(b,2,typ(:))<>[1,2;0,1]) then bugmes();quit;end
+  if or(cumsum(b,3,typ(:))<>double(b)) then bugmes();quit;end
+end
+if or(cumsum(b,'native')<>[%t %t;%t %t]) then bugmes();quit;end
+if or(cumsum(b,'*','native')<>[%t %t;%t %t]) then bugmes();quit;end
+if or(cumsum(b,1,'native')<>[%t %t;%t %t]) then bugmes();quit;end
+if or(cumsum(b,2,'native')<>[%t %t;%f %t]) then bugmes();quit;end
+if or(cumsum(b,3,'native')<>b) then bugmes();quit;end
+//with hypermatrices
+b=[%t %t;%f %t];b(1,1,2)=%f;
+for typ=list(list(),list('double'));
+  if or(cumsum(b,typ(:))<>hypermat([2,2,2],[1;1;2;3;3;3;3;3])) then bugmes();quit;end
+  if or(cumsum(b,'*',typ(:))<>hypermat([2,2,2],[1;1;2;3;3;3;3;3])) then bugmes();quit;end
+  if or(cumsum(b,1,typ(:))<>hypermat([2,2,2],[1;1;1;2;0;0;0;0])) then bugmes();quit;end
+  if or(cumsum(b,2,typ(:))<>hypermat([2,2,2],[1;0;2;1;0;0;0;0])) then bugmes();quit;end
+  if or(cumsum(b,3,typ(:))<>hypermat([2,2,2],[1;0;1;1;1;0;1;1])) then bugmes();quit;end
+  if or(cumsum(b,5,typ(:))<>double(b)) then bugmes();quit;end
+end
+if or(cumsum(b,'native')<>hypermat([2,2,2],[%t;%t;%t;%t;%t;%t;%t;%t])) then bugmes();quit;end
+if or(cumsum(b,'*','native')<>hypermat([2,2,2],[%t;%t;%t;%t;%t;%t;%t;%t])) then bugmes();quit;end
+if or(cumsum(b,1,'native')<>hypermat([2,2,2],[%t;%t;%t;%t;%f;%f;%f;%f])) then bugmes();quit;end
+if or(cumsum(b,2,'native')<>hypermat([2,2,2],[%t;%f;%t;%t;%f;%f;%f;%f])) then bugmes();quit;end
+if or(cumsum(b,3,'native')<>hypermat([2,2,2],[%t;%f;%t;%t;%t;%f;%t;%t])) then bugmes();quit;end
+if or(cumsum(b,5,'native')<>b) then bugmes();quit;end
+//=======================================================================
+//sparse matrices of floats
+s=sparse([0 10 0;0 254 9]);
+T=list(list(),list('native'),list('double'));
+for typ=T
+  if or(cumsum(s,typ(:))<>sparse([1,2;1,3;2,2;2,3],[10;264;264;273],[2,3])) then bugmes();quit;end
+  if or(cumsum(s,'*',typ(:))<>sparse([1,2;1,3;2,2;2,3],[10;264;264;273],[2,3])) then bugmes();quit;end
+  if or(cumsum(s,1,typ(:))<>sparse([1,2;2,2;2,3],[10;264;9],[2,3])) then bugmes();quit;end
+  if or(cumsum(s,2,typ(:))<>sparse([1,2;1,3;2,2;2,3],[10;10;254;263],[2,3])) then bugmes();quit;end
+  if or(cumsum(s,3,typ(:))<>s) then bugmes();quit;end
+end
+//=======================================================================
+//sparse  matrices of boolean
+bs=sparse([0 10 0;0 254 9])<>0;
+for typ=list(list(),list('double'));
+  if or(cumsum(bs,typ(:))<>sparse([1,2;1,3;2,2;2,3],[1;2;2;3],[2,3])) then bugmes();quit;end
+  if or(cumsum(bs,'*',typ(:))<>sparse([1,2;1,3;2,2;2,3],[1;2;2;3],[2,3])) then bugmes();quit;end
+  if or(cumsum(bs,1,typ(:))<>sparse([1,2;2,2;2,3],[1;2;1],[2,3])) then bugmes();quit;end
+  if or(cumsum(bs,2,typ(:))<>sparse([1,2;1,3;2,2;2,3],[1;1;1;2],[2,3])) then bugmes();quit;end
+  if or(cumsum(bs,3,typ(:))<>bool2s(bs)) then bugmes();quit;end
+end
+if or(cumsum(bs,'native')<> sparse([1,2;1,3;2,2;2,3],[%t;%t;%t;%t],[2,3])) then bugmes();quit;end
+if or(cumsum(bs,'*','native')<> sparse([1,2;1,3;2,2;2,3],[%t;%t;%t;%t],[2,3])) then bugmes();quit;end
+if or(cumsum(bs,1,'native')<>sparse([1,2;2,2;2,3],[%t;%t;%t],[2,3])) then bugmes();quit;end
+if or(cumsum(bs,2,'native')<>sparse([1,2;1,3;2,2;2,3],[%t;%t;%t;%t],[2,3])) then bugmes();quit;end
+if or(cumsum(bs,3,'native')<>bs) then bugmes();quit;end
+// TODO : test the "m" option
diff --git a/scilab/modules/elementary_functions/tests/unit_tests/cumsum.tst b/scilab/modules/elementary_functions/tests/unit_tests/cumsum.tst
new file mode 100644 (file)
index 0000000..ce91f25
--- /dev/null
@@ -0,0 +1,168 @@
+// =============================================================================
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2010 - INRIA - Serge Steer
+//
+//  This file is distributed under the same license as the Scilab package.
+// =============================================================================
+
+// <-- JVM NOT MANDATORY -->
+
+//empty matrices
+T=list(list(),list('native'),list('double'));
+for typ=T
+  if cumsum([],typ(:))<>[] then pause,end
+  if cumsum([],'*',typ(:))<>[] then pause,end
+  if cumsum([],1,typ(:))<>[] then pause,end
+  if cumsum([],2,typ(:))<>[] then pause,end
+  if cumsum([],3,typ(:))<>[] then pause,end
+end
+
+//=======================================================================
+//float matrices
+d=[1 10;254 9];
+T=list(list(),list('native'),list('double'));
+for typ=T
+  if or(cumsum(d,typ(:))<>[1,265;255,274]) then pause,end
+  if or(cumsum(d,'*',typ(:))<>[1,265;255,274]) then pause,end
+  if or(cumsum(d,1,typ(:))<>[1,10;255,19]) then pause,end
+  if or(cumsum(d,2,typ(:))<>[1,11;254,263]) then pause,end
+  if or(cumsum(d,3,typ(:))<>d) then pause,end
+end
+
+//hypermatrices of floats
+d=[1 10;254 9];d(1,1,2)=1;
+T=list(list(),list('native'),list('double'));
+for typ=T
+  if or(cumsum(d,typ(:))<>hypermat([2,2,2],[1;255;265;274;275;275;275;275])) then pause,end
+  if or(cumsum(d,'*',typ(:))<>hypermat([2,2,2],[1;255;265;274;275;275;275;275])) then pause,end
+  if or(cumsum(d,1,typ(:))<>hypermat([2,2,2],[1;255;10;19;1;1;0;0])) then pause,end
+  if or(cumsum(d,2,typ(:))<>hypermat([2,2,2],[1;254;11;263;1;0;1;0])) then pause,end
+  if or(cumsum(d,3,typ(:))<>hypermat([2,2,2],[1;254;10;9;2;254;10;9])) then pause,end
+  if or(cumsum(d,5,typ(:))<>d) then pause,end
+end
+
+//=======================================================================
+//Integers
+i=uint8([1 10;254 9]);
+for typ=list(list(),list('native'));
+  if or(cumsum(i,typ(:))<>uint8([1,9;255,18])) then pause,end
+  if or(cumsum(i,'*',typ(:))<>uint8([1,9;255,18])) then pause,end
+  if or(cumsum(i,1,typ(:))<>uint8([1,10;255,19])) then pause,end
+  if or(cumsum(i,2,typ(:))<>uint8([1,11;254,7])) then pause,end
+  if or(cumsum(i,3,typ(:))<>i) then pause,end
+end
+
+if or(cumsum(i,'double')<>[1,265;255,274]) then pause,end
+if or(cumsum(i,'*','double')<>[1,265;255,274]) then pause,end
+if or(cumsum(i,1,'double')<>[1,10;255,19]) then pause,end
+if or(cumsum(i,2,'double')<>[1,11;254,263]) then pause,end
+if or(cumsum(i,3,'double')<>double(i)) then pause,end
+
+//with hypermatrices
+i=uint8([1 10;254 9]);i(1,1,2)=uint8(1);
+for typ=list(list(),list('native'));
+  if or(cumsum(i,typ(:))<>hypermat([2,2,2],uint8([1;255;9;18;19;19;19;19]))) then pause,end
+  if or(cumsum(i,'*',typ(:))<>hypermat([2,2,2],uint8([1;255;9;18;19;19;19;19]))) then pause,end
+  if or(cumsum(i,1,typ(:))<>hypermat([2,2,2],uint8([1;255;10;19;1;1;0;0]))) then pause,end
+  if or(cumsum(i,2,typ(:))<>hypermat([2,2,2],uint8([1;254;11;7;1;0;1;0]))) then pause,end
+  if or(cumsum(i,3,typ(:))<>hypermat([2,2,2],uint8([1;254;10;9;2;254;10;9]))) then pause,end
+  if or(cumsum(i,5,typ(:))<>i) then pause,end
+end
+
+
+if or(cumsum(i,'double')<>hypermat([2,2,2],[1;255;265;274;275;275;275;275])) then pause,end
+if or(cumsum(i,'*','double')<>hypermat([2,2,2],[1;255;265;274;275;275;275;275])) then pause,end
+if or(cumsum(i,1,'double')<>hypermat([2,2,2],[1;255;10;19;1;1;0;0])) then pause,end
+if or(cumsum(i,2,'double')<>hypermat([2,2,2],[1;254;11;263;1;0;1;0])) then pause,end
+if or(cumsum(i,3,'double')<>hypermat([2,2,2],[1;254;10;9;2;254;10;9])) then pause,end
+if or(cumsum(i,5,'double')<>double(i)) then pause,end
+
+//=======================================================================
+//Matrices of Polynomials
+s=%s;p=[s s+1;s^2 0];
+T=list(list(),list('native'),list('double'));
+for typ=T
+  if or(cumsum(p,typ(:))<>[s,1+2*s+s^2;s+s^2,1+2*s+s^2]) then pause,end
+  if or(cumsum(p,'*',typ(:))<>[s,1+2*s+s^2;s+s^2,1+2*s+s^2]) then pause,end
+  if or(cumsum(p,1,typ(:))<>[s,1+s;s+s^2,1+s]) then pause,end
+  if or(cumsum(p,2,typ(:))<>[s,1+2*s;s^2,s^2]) then pause,end
+  if or(cumsum(p,3,typ(:))<>p) then pause,end
+end
+
+//with hypermatrices
+s=%s;p=[s s+1;s^2 0];p(1,1,2)=-1;
+T=list(list(),list('native'),list('double'));
+for typ=T
+  if or(cumsum(p,typ(:))<>hypermat([2,2,2],[s;s+s^2;1+2*s+s^2;1+2*s+s^2;2*s+s^2;2*s+s^2;2*s+s^2;2*s+s^2])) then pause,end
+  if or(cumsum(p,'*',typ(:))<>hypermat([2,2,2],[s;s+s^2;1+2*s+s^2;1+2*s+s^2;2*s+s^2;2*s+s^2;2*s+s^2;2*s+s^2])) then pause,end
+  if or(cumsum(p,1,typ(:))<>hypermat([2,2,2],[s;s+s^2;1+s;1+s;-1;-1;0*s;0*s])) then pause,end
+  if or(cumsum(p,2,typ(:))<>hypermat([2,2,2],[s;s^2;1+2*s;s^2;-1;0*s;-1;0*s])) then pause,end
+  if or(cumsum(p,3,typ(:))<>hypermat([2,2,2],[s;s^2;1+s;0*s;-1+s;s^2;1+s;0*s])) then pause,end
+  if or(cumsum(p,5,typ(:))<>p) then pause,end
+end
+
+//=======================================================================
+///Matrices of boolean
+
+b=[%t %t;%f %t];
+for typ=list(list(),list('double'));
+  if or(cumsum(b,typ(:))<>[1,2;1,3]) then pause,end
+  if or(cumsum(b,'*',typ(:))<>[1,2;1,3]) then pause,end
+  if or(cumsum(b,1,typ(:))<>[1,1;1,2]) then pause,end
+  if or(cumsum(b,2,typ(:))<>[1,2;0,1]) then pause,end
+  if or(cumsum(b,3,typ(:))<>double(b)) then pause,end
+end
+if or(cumsum(b,'native')<>[%t %t;%t %t]) then pause,end
+if or(cumsum(b,'*','native')<>[%t %t;%t %t]) then pause,end
+if or(cumsum(b,1,'native')<>[%t %t;%t %t]) then pause,end
+if or(cumsum(b,2,'native')<>[%t %t;%f %t]) then pause,end
+if or(cumsum(b,3,'native')<>b) then pause,end
+
+//with hypermatrices
+b=[%t %t;%f %t];b(1,1,2)=%f;
+for typ=list(list(),list('double'));
+  if or(cumsum(b,typ(:))<>hypermat([2,2,2],[1;1;2;3;3;3;3;3])) then pause,end
+  if or(cumsum(b,'*',typ(:))<>hypermat([2,2,2],[1;1;2;3;3;3;3;3])) then pause,end
+  if or(cumsum(b,1,typ(:))<>hypermat([2,2,2],[1;1;1;2;0;0;0;0])) then pause,end
+  if or(cumsum(b,2,typ(:))<>hypermat([2,2,2],[1;0;2;1;0;0;0;0])) then pause,end
+  if or(cumsum(b,3,typ(:))<>hypermat([2,2,2],[1;0;1;1;1;0;1;1])) then pause,end
+  if or(cumsum(b,5,typ(:))<>double(b)) then pause,end
+end
+
+if or(cumsum(b,'native')<>hypermat([2,2,2],[%t;%t;%t;%t;%t;%t;%t;%t])) then pause,end
+if or(cumsum(b,'*','native')<>hypermat([2,2,2],[%t;%t;%t;%t;%t;%t;%t;%t])) then pause,end
+if or(cumsum(b,1,'native')<>hypermat([2,2,2],[%t;%t;%t;%t;%f;%f;%f;%f])) then pause,end
+if or(cumsum(b,2,'native')<>hypermat([2,2,2],[%t;%f;%t;%t;%f;%f;%f;%f])) then pause,end
+if or(cumsum(b,3,'native')<>hypermat([2,2,2],[%t;%f;%t;%t;%t;%f;%t;%t])) then pause,end
+if or(cumsum(b,5,'native')<>b) then pause,end
+
+//=======================================================================
+//sparse matrices of floats
+s=sparse([0 10 0;0 254 9]);
+T=list(list(),list('native'),list('double'));
+for typ=T
+  if or(cumsum(s,typ(:))<>sparse([1,2;1,3;2,2;2,3],[10;264;264;273],[2,3])) then pause,end
+  if or(cumsum(s,'*',typ(:))<>sparse([1,2;1,3;2,2;2,3],[10;264;264;273],[2,3])) then pause,end
+  if or(cumsum(s,1,typ(:))<>sparse([1,2;2,2;2,3],[10;264;9],[2,3])) then pause,end
+  if or(cumsum(s,2,typ(:))<>sparse([1,2;1,3;2,2;2,3],[10;10;254;263],[2,3])) then pause,end
+  if or(cumsum(s,3,typ(:))<>s) then pause,end
+end
+
+//=======================================================================
+//sparse  matrices of boolean
+bs=sparse([0 10 0;0 254 9])<>0;
+for typ=list(list(),list('double'));
+  if or(cumsum(bs,typ(:))<>sparse([1,2;1,3;2,2;2,3],[1;2;2;3],[2,3])) then pause,end
+  if or(cumsum(bs,'*',typ(:))<>sparse([1,2;1,3;2,2;2,3],[1;2;2;3],[2,3])) then pause,end
+  if or(cumsum(bs,1,typ(:))<>sparse([1,2;2,2;2,3],[1;2;1],[2,3])) then pause,end
+  if or(cumsum(bs,2,typ(:))<>sparse([1,2;1,3;2,2;2,3],[1;1;1;2],[2,3])) then pause,end
+  if or(cumsum(bs,3,typ(:))<>bool2s(bs)) then pause,end
+end
+
+if or(cumsum(bs,'native')<> sparse([1,2;1,3;2,2;2,3],[%t;%t;%t;%t],[2,3])) then pause,end
+if or(cumsum(bs,'*','native')<> sparse([1,2;1,3;2,2;2,3],[%t;%t;%t;%t],[2,3])) then pause,end
+if or(cumsum(bs,1,'native')<>sparse([1,2;2,2;2,3],[%t;%t;%t],[2,3])) then pause,end
+if or(cumsum(bs,2,'native')<>sparse([1,2;1,3;2,2;2,3],[%t;%t;%t;%t],[2,3])) then pause,end
+if or(cumsum(bs,3,'native')<>bs) then pause,end
+
+// TODO : test the "m" option
diff --git a/scilab/modules/elementary_functions/tests/unit_tests/prod.dia.ref b/scilab/modules/elementary_functions/tests/unit_tests/prod.dia.ref
new file mode 100644 (file)
index 0000000..bf13c9d
--- /dev/null
@@ -0,0 +1,161 @@
+// =============================================================================
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2010 - INRIA - Serge Steer
+//
+//  This file is distributed under the same license as the Scilab package.
+// =============================================================================
+// <-- JVM NOT MANDATORY -->
+// prod 
+//empty matrices
+T=list(list(),list('native'),list('double'));
+for typ=T
+  if prod([],typ(:))<>1 then bugmes();quit;end
+  if prod([],'*',typ(:))<>1 then bugmes();quit;end
+  if prod([],1,typ(:))<>[] then bugmes();quit;end
+  if prod([],2,typ(:))<>[] then bugmes();quit;end
+  if prod([],3,typ(:))<>[] then bugmes();quit;end
+end
+//=======================================================================
+//float matrices
+d=[1 10;254 9];
+T=list(list(),list('native'),list('double'));
+for typ=T
+  if prod(d,typ(:))<>22860 then bugmes();quit;end
+  if prod(d,'*',typ(:))<>22860 then bugmes();quit;end
+  if or(prod(d,1,typ(:))<>[254 90]) then bugmes();quit;end
+  if or(prod(d,2,typ(:))<>[10;2286]) then bugmes();quit;end
+  if or(prod(d,3,typ(:))<>d) then bugmes();quit;end
+end
+//hypermatrices of floats
+d=[1 10;254 9];d(:,:,2)=1;
+T=list(list(),list('native'),list('double'));
+for typ=T
+  if prod(d,typ(:))<>22860 then bugmes();quit;end
+  if prod(d,'*',typ(:))<>22860 then bugmes();quit;end
+  if or(prod(d,1,typ(:))<>hypermat([1,2,2],[254;90;1;1])) then bugmes();quit;end
+  if or(prod(d,2,typ(:))<>hypermat([2,1,2],[10;2286;1;1])) then bugmes();quit;end
+  if or(prod(d,3,typ(:))<>[1,10;254,9]) then bugmes();quit;end
+  if or(prod(d,5,typ(:))<>d) then bugmes();quit;end
+end
+//=======================================================================
+//matrices of short integers
+i=uint8([1 10;254 9]);
+T=list(list(),list('native'));
+for typ=T
+  if prod(i,typ(:))<>uint8(76) then bugmes();quit;end
+  if prod(i,'*',typ(:))<>uint8(76) then bugmes();quit;end
+  if or(prod(i,1,typ(:))<>uint8([254 90])) then bugmes();quit;end
+  if or(prod(i,2,typ(:))<>uint8([10;238])) then bugmes();quit;end
+  if or(prod(i,3,typ(:))<>i) then bugmes();quit;end
+end
+if prod(i,'double')<>22860 then bugmes();quit;end
+if prod(i,'*','double')<>22860 then bugmes();quit;end
+if or(prod(i,1,'double')<>[254 90]) then bugmes();quit;end
+if or(prod(i,2,'double')<>[10;2286]) then bugmes();quit;end
+if or(prod(i,3,'double')<>double(i)) then bugmes();quit;end
+//with hypermatrices
+i=uint8([1 10;254 9]);i(:,:,2)=uint8(1);
+for typ=list(list(),list('native'));
+  if prod(i,typ(:))<>uint8(76) then bugmes();quit;end
+  if prod(i,'*',typ(:))<>uint8(76) then bugmes();quit;end
+  if or(prod(i,1,typ(:))<>hypermat([1,2,2],uint8([254;90;1;1]))) then bugmes();quit;end
+  if or(prod(i,2,typ(:))<>hypermat([2,1,2],uint8([10;238;1;1]))) then bugmes();quit;end
+  if or(prod(i,3,typ(:))<>([1,10;254,9])) then bugmes();quit;end
+  if or(prod(i,5,typ(:))<>i) then bugmes();quit;end
+end
+if prod(i,'double')<>22860 then bugmes();quit;end
+if prod(i,'*','double')<>22860 then bugmes();quit;end
+if or(prod(i,1,'double')<>hypermat([1,2,2],[254;90;1;1])) then bugmes();quit;end
+if or(prod(i,2,'double')<>hypermat([2,1,2],[10;2286;1;1])) then bugmes();quit;end
+if or(prod(i,3,'double')<>[1,10;254,9]) then bugmes();quit;end
+if or(prod(i,5,'double')<>double(i)) then bugmes();quit;end
+//Polynomials
+s=%s;p=[s s+1;s^2 1];
+T=list(list(),list('native'),list('double'));
+for typ=T
+  if prod(p,typ(:))<>s^3+s^4 then bugmes();quit;end
+  if prod(p,'*',typ(:))<>s^3+s^4 then bugmes();quit;end
+  if or(prod(p,1,typ(:))<>[s^3,1+s]) then bugmes();quit;end
+  if or(prod(p,2,typ(:))<>[s+s^2;s^2]) then bugmes();quit;end
+  if or(prod(p,3,typ(:))<>p) then bugmes();quit;end
+end
+//with hypermatrices
+s=%s;p=[s s+1;s^2 1];p(:,:,2)=[1 s;s+1 2];
+T=list(list(),list('native'),list('double'));
+for typ=T
+  if prod(p,typ(:))<>2*s^4+4*s^5+2*s^6 then bugmes();quit;end
+  if prod(p,'*',typ(:))<>2*s^4+4*s^5+2*s^6 then bugmes();quit;end
+  if or(prod(p,1,typ(:))<>hypermat([1,2,2],[s^3;1+s;1+s;2*s])) then bugmes();quit;end
+  if or(prod(p,2,typ(:))<>hypermat([2,1,2],[s+s^2;s^2;s;2+2*s])) then bugmes();quit;end
+  if or(prod(p,3,typ(:))<>[s,s+s^2;s^2+s^3,2]) then bugmes();quit;end
+  if or(prod(p,5,typ(:))<>p) then bugmes();quit;end
+end
+//=======================================================================
+//Matrices of rationals
+s=%s;r=1.0 ./[s s+1;s^2 1];
+T=list(list(),list('native'),list('double'));
+for typ=T
+  if prod(r,typ(:))<>1.0/(s^3+s^4) then bugmes();quit;end
+  if prod(r,'*',typ(:))<>1.0/(s^3+s^4) then bugmes();quit;end
+  if or(prod(r,1,typ(:))<>[1,1]./[s^3,1+s]) then bugmes();quit;end
+  if or(prod(r,2,typ(:))<>[1;1]./[s+s^2;s^2]) then bugmes();quit;end
+  if or(prod(r,3,typ(:))<>r) then bugmes();quit;end
+end
+//=======================================================================
+//Matrices of booleans
+b=[%t %t; %f %t];
+for typ=list(list(),list('double'));
+  if prod(b,typ(:))<>0 then bugmes();quit;end
+  if prod(b,'*',typ(:))<>0 then bugmes();quit;end
+  if or(prod(b,1,typ(:))<>[0 1]) then bugmes();quit;end
+  if or(prod(b,2,typ(:))<>[1;0]) then bugmes();quit;end
+  if or(prod(b,3,typ(:))<>double(b)) then bugmes();quit;end
+end
+if prod(b,'native')<>%f then bugmes();quit;end
+if prod(b,'*','native')<>%f then bugmes();quit;end
+if or(prod(b,1,'native')<>[%f %t]) then bugmes();quit;end
+if or(prod(b,2,'native')<>[%t;%f]) then bugmes();quit;end
+if or(prod(b,3,'native')<>b) then bugmes();quit;end
+//with hypermatrices 
+b=[%t %t;%f %t];b(1,1,2)=%t;
+for typ=list(list(),list('double'));
+  if prod(b,typ(:))<>0 then bugmes();quit;end
+  if prod(b,'*',typ(:))<>0 then bugmes();quit;end
+  if or(prod(b,1,typ(:))<>hypermat([1,2,2],[0;1;0;0])) then bugmes();quit;end
+  if or(prod(b,2,typ(:))<>hypermat([2,1,2],[1;0;0;0])) then bugmes();quit;end
+  if or(prod(b,3,typ(:))<>[1,0;0,0]) then bugmes();quit;end
+  if or(prod(b,5,typ(:))<>double(b)) then bugmes();quit;end
+end
+if prod(b,'native')<>%f then bugmes();quit;end
+if prod(b,'*','native')<>%f then bugmes();quit;end
+if or(prod(b,1,'native')<>hypermat([1,2,2],[%f;%t;%f;%f])) then bugmes();quit;end
+if or(prod(b,2,'native')<>hypermat([2,1,2],[%t;%f;%f;%f])) then bugmes();quit;end
+if or(prod(b,3,'native')<>[%t,%f;%f,%f]) then bugmes();quit;end
+if or(prod(b,5,'native')<>b) then bugmes();quit;end
+//=======================================================================
+//sparse matrices of floats
+s=sparse([1 10 2;-1 254 9]);
+T=list(list(),list('native'),list('double'));
+for typ=T
+  if prod(s,typ(:))<>-45720 then bugmes();quit;end
+  if prod(s,'*',typ(:))<>-45720 then bugmes();quit;end
+  if or(prod(s,1,typ(:))<>sparse([-1 2540 18])) then bugmes();quit;end
+  if or(prod(s,2,typ(:))<>sparse([20;-2286])) then bugmes();quit;end
+  if or(prod(s,3,typ(:))<>s) then bugmes();quit;end
+end
+//=======================================================================
+//sparse  matrices of boolean
+bs=sparse([%t %t %f;%t %t %t]);
+for typ=list(list(),list('double'));
+  if prod(bs,typ(:))<>0 then bugmes();quit;end
+  if prod(bs,'*',typ(:))<>0 then bugmes();quit;end
+  if or(prod(bs,1,typ(:))<>sparse([1,1,0])) then bugmes();quit;end
+  if or(prod(bs,2,typ(:))<>sparse([0;1])) then bugmes();quit;end
+  if or(prod(bs,3,typ(:))<>bool2s(bs)) then bugmes();quit;end
+end
+if prod(bs,'native')<>%f then bugmes();quit;end
+if prod(bs,'*','native')<>%f then bugmes();quit;end
+if or(prod(bs,1,'native')<>sparse([%t,%t,%f])) then bugmes();quit;end
+if or(prod(bs,2,'native')<>sparse([%f;%t])) then bugmes();quit;end
+if or(prod(bs,3,'native')<>bs) then bugmes();quit;end
+// TODO : test the "m" option
diff --git a/scilab/modules/elementary_functions/tests/unit_tests/prod.tst b/scilab/modules/elementary_functions/tests/unit_tests/prod.tst
new file mode 100644 (file)
index 0000000..004493d
--- /dev/null
@@ -0,0 +1,179 @@
+// =============================================================================
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2010 - INRIA - Serge Steer
+//
+//  This file is distributed under the same license as the Scilab package.
+// =============================================================================
+
+// <-- JVM NOT MANDATORY -->
+// prod 
+//empty matrices
+T=list(list(),list('native'),list('double'));
+for typ=T
+  if prod([],typ(:))<>1 then pause,end
+  if prod([],'*',typ(:))<>1 then pause,end
+  if prod([],1,typ(:))<>[] then pause,end
+  if prod([],2,typ(:))<>[] then pause,end
+  if prod([],3,typ(:))<>[] then pause,end
+end
+
+//=======================================================================
+//float matrices
+d=[1 10;254 9];
+T=list(list(),list('native'),list('double'));
+for typ=T
+  if prod(d,typ(:))<>22860 then pause,end
+  if prod(d,'*',typ(:))<>22860 then pause,end
+  if or(prod(d,1,typ(:))<>[254 90]) then pause,end
+  if or(prod(d,2,typ(:))<>[10;2286]) then pause,end
+  if or(prod(d,3,typ(:))<>d) then pause,end
+end
+
+
+//hypermatrices of floats
+d=[1 10;254 9];d(:,:,2)=1;
+T=list(list(),list('native'),list('double'));
+for typ=T
+  if prod(d,typ(:))<>22860 then pause,end
+  if prod(d,'*',typ(:))<>22860 then pause,end
+  if or(prod(d,1,typ(:))<>hypermat([1,2,2],[254;90;1;1])) then pause,end
+  if or(prod(d,2,typ(:))<>hypermat([2,1,2],[10;2286;1;1])) then pause,end
+  if or(prod(d,3,typ(:))<>[1,10;254,9]) then pause,end
+  if or(prod(d,5,typ(:))<>d) then pause,end
+end
+
+//=======================================================================
+//matrices of short integers
+i=uint8([1 10;254 9]);
+T=list(list(),list('native'));
+for typ=T
+  if prod(i,typ(:))<>uint8(76) then pause,end
+  if prod(i,'*',typ(:))<>uint8(76) then pause,end
+  if or(prod(i,1,typ(:))<>uint8([254 90])) then pause,end
+  if or(prod(i,2,typ(:))<>uint8([10;238])) then pause,end
+  if or(prod(i,3,typ(:))<>i) then pause,end
+end
+
+if prod(i,'double')<>22860 then pause,end
+if prod(i,'*','double')<>22860 then pause,end
+if or(prod(i,1,'double')<>[254 90]) then pause,end
+if or(prod(i,2,'double')<>[10;2286]) then pause,end
+if or(prod(i,3,'double')<>double(i)) then pause,end
+
+//with hypermatrices
+i=uint8([1 10;254 9]);i(:,:,2)=uint8(1);
+for typ=list(list(),list('native'));
+  if prod(i,typ(:))<>uint8(76) then pause,end
+  if prod(i,'*',typ(:))<>uint8(76) then pause,end
+  if or(prod(i,1,typ(:))<>hypermat([1,2,2],uint8([254;90;1;1]))) then pause,end
+  if or(prod(i,2,typ(:))<>hypermat([2,1,2],uint8([10;238;1;1]))) then pause,end
+  if or(prod(i,3,typ(:))<>([1,10;254,9])) then pause,end
+  if or(prod(i,5,typ(:))<>i) then pause,end
+end
+
+if prod(i,'double')<>22860 then pause,end
+if prod(i,'*','double')<>22860 then pause,end
+if or(prod(i,1,'double')<>hypermat([1,2,2],[254;90;1;1])) then pause,end
+if or(prod(i,2,'double')<>hypermat([2,1,2],[10;2286;1;1])) then pause,end
+if or(prod(i,3,'double')<>[1,10;254,9]) then pause,end
+if or(prod(i,5,'double')<>double(i)) then pause,end
+
+
+//Polynomials
+s=%s;p=[s s+1;s^2 1];
+T=list(list(),list('native'),list('double'));
+for typ=T
+  if prod(p,typ(:))<>s^3+s^4 then pause,end
+  if prod(p,'*',typ(:))<>s^3+s^4 then pause,end
+  if or(prod(p,1,typ(:))<>[s^3,1+s]) then pause,end
+  if or(prod(p,2,typ(:))<>[s+s^2;s^2]) then pause,end
+  if or(prod(p,3,typ(:))<>p) then pause,end
+end
+//with hypermatrices
+s=%s;p=[s s+1;s^2 1];p(:,:,2)=[1 s;s+1 2];
+T=list(list(),list('native'),list('double'));
+for typ=T
+  if prod(p,typ(:))<>2*s^4+4*s^5+2*s^6 then pause,end
+  if prod(p,'*',typ(:))<>2*s^4+4*s^5+2*s^6 then pause,end
+  if or(prod(p,1,typ(:))<>hypermat([1,2,2],[s^3;1+s;1+s;2*s])) then pause,end
+  if or(prod(p,2,typ(:))<>hypermat([2,1,2],[s+s^2;s^2;s;2+2*s])) then pause,end
+  if or(prod(p,3,typ(:))<>[s,s+s^2;s^2+s^3,2]) then pause,end
+  if or(prod(p,5,typ(:))<>p) then pause,end
+end
+
+//=======================================================================
+//Matrices of rationals
+s=%s;r=1.0 ./[s s+1;s^2 1];
+T=list(list(),list('native'),list('double'));
+for typ=T
+  if prod(r,typ(:))<>1.0/(s^3+s^4) then pause,end
+  if prod(r,'*',typ(:))<>1.0/(s^3+s^4) then pause,end
+  if or(prod(r,1,typ(:))<>[1,1]./[s^3,1+s]) then pause,end
+  if or(prod(r,2,typ(:))<>[1;1]./[s+s^2;s^2]) then pause,end
+  if or(prod(r,3,typ(:))<>r) then pause,end
+end
+
+//=======================================================================
+//Matrices of booleans
+b=[%t %t; %f %t];
+for typ=list(list(),list('double'));
+  if prod(b,typ(:))<>0 then pause,end
+  if prod(b,'*',typ(:))<>0 then pause,end
+  if or(prod(b,1,typ(:))<>[0 1]) then pause,end
+  if or(prod(b,2,typ(:))<>[1;0]) then pause,end
+  if or(prod(b,3,typ(:))<>double(b)) then pause,end
+end
+
+if prod(b,'native')<>%f then pause,end
+if prod(b,'*','native')<>%f then pause,end
+if or(prod(b,1,'native')<>[%f %t]) then pause,end
+if or(prod(b,2,'native')<>[%t;%f]) then pause,end
+if or(prod(b,3,'native')<>b) then pause,end
+//with hypermatrices 
+  
+b=[%t %t;%f %t];b(1,1,2)=%t;
+for typ=list(list(),list('double'));
+  if prod(b,typ(:))<>0 then pause,end
+  if prod(b,'*',typ(:))<>0 then pause,end
+  if or(prod(b,1,typ(:))<>hypermat([1,2,2],[0;1;0;0])) then pause,end
+  if or(prod(b,2,typ(:))<>hypermat([2,1,2],[1;0;0;0])) then pause,end
+  if or(prod(b,3,typ(:))<>[1,0;0,0]) then pause,end
+  if or(prod(b,5,typ(:))<>double(b)) then pause,end
+end
+
+if prod(b,'native')<>%f then pause,end
+if prod(b,'*','native')<>%f then pause,end
+if or(prod(b,1,'native')<>hypermat([1,2,2],[%f;%t;%f;%f])) then pause,end
+if or(prod(b,2,'native')<>hypermat([2,1,2],[%t;%f;%f;%f])) then pause,end
+if or(prod(b,3,'native')<>[%t,%f;%f,%f]) then pause,end
+if or(prod(b,5,'native')<>b) then pause,end
+//=======================================================================
+//sparse matrices of floats
+s=sparse([1 10 2;-1 254 9]);
+T=list(list(),list('native'),list('double'));
+for typ=T
+  if prod(s,typ(:))<>-45720 then pause,end
+  if prod(s,'*',typ(:))<>-45720 then pause,end
+  if or(prod(s,1,typ(:))<>sparse([-1 2540 18])) then pause,end
+  if or(prod(s,2,typ(:))<>sparse([20;-2286])) then pause,end
+  if or(prod(s,3,typ(:))<>s) then pause,end
+end
+
+//=======================================================================
+//sparse  matrices of boolean
+bs=sparse([%t %t %f;%t %t %t]);
+for typ=list(list(),list('double'));
+  if prod(bs,typ(:))<>0 then pause,end
+  if prod(bs,'*',typ(:))<>0 then pause,end
+  if or(prod(bs,1,typ(:))<>sparse([1,1,0])) then pause,end
+  if or(prod(bs,2,typ(:))<>sparse([0;1])) then pause,end
+  if or(prod(bs,3,typ(:))<>bool2s(bs)) then pause,end
+end
+
+if prod(bs,'native')<>%f then pause,end
+if prod(bs,'*','native')<>%f then pause,end
+if or(prod(bs,1,'native')<>sparse([%t,%t,%f])) then pause,end
+if or(prod(bs,2,'native')<>sparse([%f;%t])) then pause,end
+if or(prod(bs,3,'native')<>bs) then pause,end
+
+// TODO : test the "m" option
diff --git a/scilab/modules/elementary_functions/tests/unit_tests/sum.dia.ref b/scilab/modules/elementary_functions/tests/unit_tests/sum.dia.ref
new file mode 100644 (file)
index 0000000..3be8ce6
--- /dev/null
@@ -0,0 +1,160 @@
+// =============================================================================
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2010 - INRIA - Serge Steer
+//
+//  This file is distributed under the same license as the Scilab package.
+// =============================================================================
+// <-- JVM NOT MANDATORY -->
+//empty matrices
+T=list(list(),list('native'),list('double'));
+for typ=T
+  if sum([],typ(:))<>0 then bugmes();quit;end
+  if sum([],'*',typ(:))<>0 then bugmes();quit;end
+  if sum([],1,typ(:))<>[] then bugmes();quit;end
+  if sum([],2,typ(:))<>[] then bugmes();quit;end
+  if sum([],3,typ(:))<>[] then bugmes();quit;end
+end
+//=======================================================================
+//float matrices
+d=[1 10;254 9];
+T=list(list(),list('native'),list('double'));
+for typ=T
+  if sum(d,typ(:))<>274 then bugmes();quit;end
+  if sum(d,'*',typ(:))<>274 then bugmes();quit;end
+  if or(sum(d,1,typ(:))<>[255 19]) then bugmes();quit;end
+  if or(sum(d,2,typ(:))<>[11;263]) then bugmes();quit;end
+  if or(sum(d,3,typ(:))<>d) then bugmes();quit;end
+end
+//hypermatrices of floats
+d(1,1,2)=1;
+for typ=T
+  if sum(d,typ(:))<>275 then bugmes();quit;end
+  if sum(d,'*',typ(:))<>275 then bugmes();quit;end
+  if or(sum(d,1,typ(:))<>hypermat([1,2,2],[255;19;1;0])) then bugmes();quit;end
+  if or(sum(d,2,typ(:))<>hypermat([2,1,2],[11;263;1;0])) then bugmes();quit;end
+  if or(sum(d,3,typ(:))<>[2,10;254,9]) then bugmes();quit;end
+  if or(sum(d,5,typ(:))<>d) then bugmes();quit;end
+end
+//=======================================================================
+//matrices of short integers
+// Caution : uint8([11;263]) is equal to uint8([11;7])
+i=uint8([1 10;254 9]);
+for typ=list(list(),list('native'));
+  if sum(i,typ(:))<>uint8(274) then bugmes();quit;end
+  if sum(i,'*',typ(:))<>uint8(274) then bugmes();quit;end
+  if or(sum(i,1,typ(:))<>uint8([255 19])) then bugmes();quit;end
+  if or(sum(i,2,typ(:))<>uint8([11;263])) then bugmes();quit;end
+  if or(sum(i,3,typ(:))<>i) then bugmes();quit;end
+end
+if sum(i,'double')<>274 then bugmes();quit;end
+if sum(i,'*','double')<>274 then bugmes();quit;end
+if or(sum(i,1,'double')<>[255 19]) then bugmes();quit;end
+if or(sum(i,2,'double')<>[11;263]) then bugmes();quit;end
+if or(sum(i,3,'double')<>double(i)) then bugmes();quit;end
+//with hypermatrices
+i(1,1,2)=uint8(1);
+for typ=list(list(),list('native'));
+  if sum(i,typ(:))<>uint8(275) then bugmes();quit;end
+  if sum(i,'*',typ(:))<>uint8(275) then bugmes();quit;end
+  if or(sum(i,1,typ(:))<>hypermat([1,2,2],uint8([255;19;1;0]))) then bugmes();quit;end
+  if or(sum(i,2,typ(:))<> hypermat([2,1,2],uint8([11;263;1;0]))) then bugmes();quit;end
+  if or(sum(i,3,typ(:))<> uint8([2,10;254,9])) then bugmes();quit;end
+  if or(sum(i,5,typ(:))<> i) then bugmes();quit;end
+end
+if sum(i,'double')<>275 then bugmes();quit;end
+if sum(i,'*','double')<>275 then bugmes();quit;end
+if or(sum(i,1,'double')<>hypermat([1,2,2],[255;19;1;0])) then bugmes();quit;end
+if or(sum(i,2,'double')<> hypermat([2,1,2],[11;263;1;0])) then bugmes();quit;end
+if or(sum(i,3,'double')<>[2,10;254,9]) then bugmes();quit;end
+//=======================================================================
+//Matrices of polynomials
+s=%s;
+p=[s s+1;s^2 0];
+T=list(list(),list('native'),list('double'));
+for typ=T
+  if sum(p,typ(:))<>1+2*s+s^2 then bugmes();quit;end
+  if sum(p,'*',typ(:))<>1+2*s+s^2 then bugmes();quit;end
+  if or(sum(p,1,typ(:))<>[s+s^2,1+s]) then bugmes();quit;end
+  if or(sum(p,2,typ(:))<>[1+2*s;s^2]) then bugmes();quit;end
+  if or(sum(p,3,typ(:))<>p) then bugmes();quit;end
+end
+//with hypermatrices
+p(1,1,2)=-1;
+for typ=T
+  if sum(p,typ(:))<>2*s+s^2 then bugmes();quit;end
+  if sum(p,'*',typ(:))<>2*s+s^2 then bugmes();quit;end
+  if or(sum(p,1,typ(:))<>hypermat([1,2,2],[s+s^2;1+s;-1;0*s])) then bugmes();quit;end
+  if or(sum(p,2,typ(:))<>hypermat([2,1,2],[1+2*s;s^2;-1;0*s])) then bugmes();quit;end
+  if or(sum(p,3,typ(:))<>[-1+s,1+s;s^2,0]) then bugmes();quit;end
+  if or(sum(p,5,typ(:))<>p) then bugmes();quit;end
+end
+//=======================================================================
+//Matrices of rationals
+s=%s;
+r=1.0 ./[s s+1;s^2 1];
+T=list(list(),list('native'),list('double'));
+for typ=T
+  if sum(r,typ(:))<>(1+2*s+3*s^2+s^3)./(s^2+s^3) then bugmes();quit;end
+  if sum(r,'*',typ(:))<>(1+2*s+3*s^2+s^3)./(s^2+s^3) then bugmes();quit;end
+  if or(sum(r,1,typ(:))<>[1+s,2+s]./[s^2,1+s]) then bugmes();quit;end
+  if or(sum(r,2,typ(:))<>[1+2*s;1+s^2]./[s+s^2;s^2]) then bugmes();quit;end
+  if or(sum(r,3,typ(:))<>r) then bugmes();quit;end
+end
+//=======================================================================
+///Matrices of boolean
+b=[%t %t %f %t];
+for typ=list(list(),list('double'));
+  if sum(b,typ(:))<>3 then bugmes();quit;end
+  if sum(b,'*',typ(:))<>3 then bugmes();quit;end
+  if or(sum(b,1,typ(:))<>[1 1 0 1]) then bugmes();quit;end
+  if or(sum(b,2,typ(:))<>3) then bugmes();quit;end
+  if or(sum(b,3,typ(:))<>double(b)) then bugmes();quit;end
+end
+if sum(b,'native')<>%t then bugmes();quit;end
+if sum(b,'*','native')<>%t then bugmes();quit;end
+if or(sum(b,1,'native')<>b) then bugmes();quit;end
+if or(sum(b,2,'native')<>%t) then bugmes();quit;end
+if or(sum(b,3,'native')<>b) then bugmes();quit;end
+//with hypermatrices 
+b=[%t %t %f %t];b(1,1,2)=%f;
+for typ=list(list(),list('double'));
+  if sum(b,typ(:))<>3 then bugmes();quit;end
+  if sum(b,'*',typ(:))<>3 then bugmes();quit;end
+  if or(sum(b,1,typ(:))<>hypermat([1,4,2],[1;1;0;1;0;0;0;0])) then bugmes();quit;end
+  if or(sum(b,2,typ(:))<>hypermat([1,1,2],[3;0])) then bugmes();quit;end
+  if or(sum(b,3,typ(:))<>[1 1 0 1]) then bugmes();quit;end
+  if or(sum(b,5,typ(:))<>double(b)) then bugmes();quit;end
+end
+if sum(b,'native')<>%t then bugmes();quit;end
+if sum(b,'*','native')<>%t then bugmes();quit;end
+if or(sum(b,1,'native')<>hypermat([1,4,2],[%t;%t;%f;%t;%f;%f;%f;%f])) then bugmes();quit;end
+if or(sum(b,2,'native')<>hypermat([1,1,2],[%t;%f])) then bugmes();quit;end
+if or(sum(b,3,'native')<>[%t %t %f %t]) then bugmes();quit;end
+if or(sum(b,5,'native')<>b) then bugmes();quit;end
+//=======================================================================
+//sparse matrices of floats
+s=sparse([1 10 0;0 254 9]);
+T=list(list(),list('native'),list('double'));
+for typ=T
+  if sum(s,typ(:))<>274 then bugmes();quit;end
+  if sum(s,'*',typ(:))<>274 then bugmes();quit;end
+  if or(sum(s,1,typ(:))<>sparse([1,264,9])) then bugmes();quit;end
+  if or(sum(s,2,typ(:))<>sparse([11;263])) then bugmes();quit;end
+  if or(sum(s,3,typ(:))<>s) then bugmes();quit;end
+end
+//=======================================================================
+//sparse  matrices of boolean
+bs=sparse([1 10 0;0 254 9])<>0;
+for typ=list(list(),list('double'));
+  if sum(bs,typ(:))<>4 then bugmes();quit;end
+  if sum(bs,'*',typ(:))<>4 then bugmes();quit;end
+  if or(sum(bs,1,typ(:))<>sparse([1,2,1])) then bugmes();quit;end
+  if or(sum(bs,2,typ(:))<>sparse([2;2])) then bugmes();quit;end
+  if or(sum(bs,3,typ(:))<>bool2s(bs)) then bugmes();quit;end
+end
+if sum(bs,'native')<>%t then bugmes();quit;end
+if sum(bs,'*','native')<>%t then bugmes();quit;end
+if or(sum(bs,1,'native')<>sparse([%t,%t,%t])) then bugmes();quit;end
+if or(sum(bs,2,'native')<>sparse([%t;%t])) then bugmes();quit;end
+if or(sum(bs,3,'native')<>bs) then bugmes();quit;end
+// TODO : test the "m" option
diff --git a/scilab/modules/elementary_functions/tests/unit_tests/sum.tst b/scilab/modules/elementary_functions/tests/unit_tests/sum.tst
new file mode 100644 (file)
index 0000000..9f3ed8c
--- /dev/null
@@ -0,0 +1,179 @@
+// =============================================================================
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2010 - INRIA - Serge Steer
+//
+//  This file is distributed under the same license as the Scilab package.
+// =============================================================================
+
+// <-- JVM NOT MANDATORY -->
+//empty matrices
+T=list(list(),list('native'),list('double'));
+for typ=T
+  if sum([],typ(:))<>0 then pause,end
+  if sum([],'*',typ(:))<>0 then pause,end
+  if sum([],1,typ(:))<>[] then pause,end
+  if sum([],2,typ(:))<>[] then pause,end
+  if sum([],3,typ(:))<>[] then pause,end
+end
+//=======================================================================
+//float matrices
+d=[1 10;254 9];
+T=list(list(),list('native'),list('double'));
+for typ=T
+  if sum(d,typ(:))<>274 then pause,end
+  if sum(d,'*',typ(:))<>274 then pause,end
+  if or(sum(d,1,typ(:))<>[255 19]) then pause,end
+  if or(sum(d,2,typ(:))<>[11;263]) then pause,end
+  if or(sum(d,3,typ(:))<>d) then pause,end
+end
+
+//hypermatrices of floats
+d(1,1,2)=1;
+for typ=T
+  if sum(d,typ(:))<>275 then pause,end
+  if sum(d,'*',typ(:))<>275 then pause,end
+  if or(sum(d,1,typ(:))<>hypermat([1,2,2],[255;19;1;0])) then pause,end
+  if or(sum(d,2,typ(:))<>hypermat([2,1,2],[11;263;1;0])) then pause,end
+  if or(sum(d,3,typ(:))<>[2,10;254,9]) then pause,end
+  if or(sum(d,5,typ(:))<>d) then pause,end
+end
+
+//=======================================================================
+//matrices of short integers
+// Caution : uint8([11;263]) is equal to uint8([11;7])
+i=uint8([1 10;254 9]);
+for typ=list(list(),list('native'));
+  if sum(i,typ(:))<>uint8(274) then pause,end
+  if sum(i,'*',typ(:))<>uint8(274) then pause,end
+  if or(sum(i,1,typ(:))<>uint8([255 19])) then pause,end
+  if or(sum(i,2,typ(:))<>uint8([11;263])) then pause,end
+  if or(sum(i,3,typ(:))<>i) then pause,end
+end
+
+if sum(i,'double')<>274 then pause,end
+if sum(i,'*','double')<>274 then pause,end
+if or(sum(i,1,'double')<>[255 19]) then pause,end
+if or(sum(i,2,'double')<>[11;263]) then pause,end
+if or(sum(i,3,'double')<>double(i)) then pause,end
+
+//with hypermatrices
+i(1,1,2)=uint8(1);
+for typ=list(list(),list('native'));
+  if sum(i,typ(:))<>uint8(275) then pause,end
+  if sum(i,'*',typ(:))<>uint8(275) then pause,end
+  if or(sum(i,1,typ(:))<>hypermat([1,2,2],uint8([255;19;1;0]))) then pause,end
+  if or(sum(i,2,typ(:))<> hypermat([2,1,2],uint8([11;263;1;0]))) then pause,end
+  if or(sum(i,3,typ(:))<> uint8([2,10;254,9])) then pause,end
+  if or(sum(i,5,typ(:))<> i) then pause,end
+end
+
+if sum(i,'double')<>275 then pause,end
+if sum(i,'*','double')<>275 then pause,end
+if or(sum(i,1,'double')<>hypermat([1,2,2],[255;19;1;0])) then pause,end
+if or(sum(i,2,'double')<> hypermat([2,1,2],[11;263;1;0])) then pause,end
+if or(sum(i,3,'double')<>[2,10;254,9]) then pause,end
+
+//=======================================================================
+//Matrices of polynomials
+s=%s;
+p=[s s+1;s^2 0];
+T=list(list(),list('native'),list('double'));
+for typ=T
+  if sum(p,typ(:))<>1+2*s+s^2 then pause,end
+  if sum(p,'*',typ(:))<>1+2*s+s^2 then pause,end
+  if or(sum(p,1,typ(:))<>[s+s^2,1+s]) then pause,end
+  if or(sum(p,2,typ(:))<>[1+2*s;s^2]) then pause,end
+  if or(sum(p,3,typ(:))<>p) then pause,end
+end
+
+//with hypermatrices
+p(1,1,2)=-1;
+for typ=T
+  if sum(p,typ(:))<>2*s+s^2 then pause,end
+  if sum(p,'*',typ(:))<>2*s+s^2 then pause,end
+  if or(sum(p,1,typ(:))<>hypermat([1,2,2],[s+s^2;1+s;-1;0*s])) then pause,end
+  if or(sum(p,2,typ(:))<>hypermat([2,1,2],[1+2*s;s^2;-1;0*s])) then pause,end
+  if or(sum(p,3,typ(:))<>[-1+s,1+s;s^2,0]) then pause,end
+  if or(sum(p,5,typ(:))<>p) then pause,end
+end
+
+//=======================================================================
+//Matrices of rationals
+s=%s;
+r=1.0 ./[s s+1;s^2 1];
+T=list(list(),list('native'),list('double'));
+for typ=T
+  if sum(r,typ(:))<>(1+2*s+3*s^2+s^3)./(s^2+s^3) then pause,end
+  if sum(r,'*',typ(:))<>(1+2*s+3*s^2+s^3)./(s^2+s^3) then pause,end
+  if or(sum(r,1,typ(:))<>[1+s,2+s]./[s^2,1+s]) then pause,end
+  if or(sum(r,2,typ(:))<>[1+2*s;1+s^2]./[s+s^2;s^2]) then pause,end
+  if or(sum(r,3,typ(:))<>r) then pause,end
+end
+
+//=======================================================================
+///Matrices of boolean
+
+b=[%t %t %f %t];
+for typ=list(list(),list('double'));
+  if sum(b,typ(:))<>3 then pause,end
+  if sum(b,'*',typ(:))<>3 then pause,end
+  if or(sum(b,1,typ(:))<>[1 1 0 1]) then pause,end
+  if or(sum(b,2,typ(:))<>3) then pause,end
+  if or(sum(b,3,typ(:))<>double(b)) then pause,end
+end
+
+if sum(b,'native')<>%t then pause,end
+if sum(b,'*','native')<>%t then pause,end
+if or(sum(b,1,'native')<>b) then pause,end
+if or(sum(b,2,'native')<>%t) then pause,end
+if or(sum(b,3,'native')<>b) then pause,end
+//with hypermatrices 
+b=[%t %t %f %t];b(1,1,2)=%f;
+for typ=list(list(),list('double'));
+  if sum(b,typ(:))<>3 then pause,end
+  if sum(b,'*',typ(:))<>3 then pause,end
+  if or(sum(b,1,typ(:))<>hypermat([1,4,2],[1;1;0;1;0;0;0;0])) then pause,end
+  if or(sum(b,2,typ(:))<>hypermat([1,1,2],[3;0])) then pause,end
+  if or(sum(b,3,typ(:))<>[1 1 0 1]) then pause,end
+  if or(sum(b,5,typ(:))<>double(b)) then pause,end
+end
+
+if sum(b,'native')<>%t then pause,end
+if sum(b,'*','native')<>%t then pause,end
+if or(sum(b,1,'native')<>hypermat([1,4,2],[%t;%t;%f;%t;%f;%f;%f;%f])) then pause,end
+if or(sum(b,2,'native')<>hypermat([1,1,2],[%t;%f])) then pause,end
+if or(sum(b,3,'native')<>[%t %t %f %t]) then pause,end
+if or(sum(b,5,'native')<>b) then pause,end
+
+//=======================================================================
+//sparse matrices of floats
+s=sparse([1 10 0;0 254 9]);
+T=list(list(),list('native'),list('double'));
+for typ=T
+  if sum(s,typ(:))<>274 then pause,end
+  if sum(s,'*',typ(:))<>274 then pause,end
+  if or(sum(s,1,typ(:))<>sparse([1,264,9])) then pause,end
+  if or(sum(s,2,typ(:))<>sparse([11;263])) then pause,end
+  if or(sum(s,3,typ(:))<>s) then pause,end
+end
+
+//=======================================================================
+//sparse  matrices of boolean
+bs=sparse([1 10 0;0 254 9])<>0;
+for typ=list(list(),list('double'));
+  if sum(bs,typ(:))<>4 then pause,end
+  if sum(bs,'*',typ(:))<>4 then pause,end
+  if or(sum(bs,1,typ(:))<>sparse([1,2,1])) then pause,end
+  if or(sum(bs,2,typ(:))<>sparse([2;2])) then pause,end
+  if or(sum(bs,3,typ(:))<>bool2s(bs)) then pause,end
+end
+
+if sum(bs,'native')<>%t then pause,end
+if sum(bs,'*','native')<>%t then pause,end
+if or(sum(bs,1,'native')<>sparse([%t,%t,%t])) then pause,end
+if or(sum(bs,2,'native')<>sparse([%t;%t])) then pause,end
+if or(sum(bs,3,'native')<>bs) then pause,end
+
+// TODO : test the "m" option
+
+
index f6c3b71..f2732ca 100644 (file)
@@ -26,6 +26,6 @@
  * @param iw
  * @return 
  */
-INTEGER_IMPEXP int C2F(gencuprod)(int *typ,int *n, void *w, int *iw);
-
+INTEGER_IMPEXP int C2F(gencuprod)(int *typ,int *n, void *in, void *out, int *iw);
+INTEGER_IMPEXP int C2F(gencuprod_double)(int *typ,int *n, void *in, double *out, int *iw);
 #endif /* __GENCUPROD_H__ */
index 494e1ca..8f908cb 100644 (file)
@@ -26,6 +26,6 @@
  * @param iw
  * @return 
  */
-INTEGER_IMPEXP int C2F(gencusum)(int *typ,int *n, int *w, int *iw);
-
+INTEGER_IMPEXP int C2F(gencusum)(int *typ,int *n, void *in, void *out, int *iw);
+INTEGER_IMPEXP int C2F(gencusum_double)(int *typ,int *n, void *in, double * out, int *iw);
 #endif /* __GENCUSUM_H__ */
index 348ad61..28b8a86 100644 (file)
  * TODO : comment 
  * @param typ
  * @param job
- * @param a
+ * @param in
+ * @param out
  * @param na
  * @param m
  * @param n
  * @return 
  */
-INTEGER_IMPEXP int C2F(genmcuprod)(int *typ,int *job,int * a,int * na,int * m,int * n);
+INTEGER_IMPEXP int C2F(genmcuprod)(int *typ,int *job,void * in, void * out, int * na,int * m,int * n);
+INTEGER_IMPEXP int C2F(genmcuprodd)(int *typ,int *job,void * in, double * out, int * na,int * m,int * n);
 #endif /* __GENMCUPROD_H__ */
 
index 6b9972b..5c6f593 100644 (file)
  * TODO : comment 
  * @param typ
  * @param job
- * @param a
+ * @param in
+ * @param out
  * @param na
  * @param m
  * @param n
  * @return 
  */
-INTEGER_IMPEXP int C2F(genmcusum)(int *typ,int *job,int * a,int * na,int * m,int * n);
+INTEGER_IMPEXP int C2F(genmcusum)(int *typ,int *job,void *in,void *out,int * na,int * m,int * n);
+INTEGER_IMPEXP int C2F(genmcusumd)(int *typ,int *job,void *in,double *out,int * na,int * m,int * n);
 
 #endif /* __GENMCUSUM_H__ */
index ed2c754..9068dfd 100644 (file)
@@ -19,5 +19,6 @@
 #include "def.h"
 
 INTEGER_IMPEXP int C2F(genmprod)(int *typ,int *job, int *a, int *na, int *m, int *n, int *v, int *nv);
+INTEGER_IMPEXP int C2F(genmprod_double)(int *typ,int *job, int *a, int *na, int *m, int *n, double *v, int *nv);
 
 #endif /* __GENMPROD_H__ */
index e68af15..c99d95e 100644 (file)
@@ -32,6 +32,7 @@
  * @return 
  */
 INTEGER_IMPEXP int C2F(genmsum)(int *typ,int *job, int *a, int *na, int *m, int *n, int *v, int *nv);
+INTEGER_IMPEXP int C2F(genmsum_double)(int *typ,int *job, int *a, int *na, int *m, int *n, double *v, int *nv);
 
 #endif /* __GENMSUM_H__ */
 
index a44f337..a3e6dbe 100644 (file)
@@ -18,5 +18,6 @@
 #include "machine.h"
 #include "def.h"
 
-INTEGER_IMPEXP int C2F(genprod)(int *typ, int *n, int *dx, int *incx);
+INTEGER_IMPEXP int C2F(genprod)(int *typ, int *n, void *dx, int *incx);
+double C2F(genprod_double)(int *typ, int *n, void *dx, int *incx);
 #endif /* __GENPROD_H__ */
index b5720d1..5f52bde 100644 (file)
@@ -26,5 +26,5 @@
  * @return 
  */
 INTEGER_IMPEXP int C2F(gensum)(int *typ, int *n, void *dx, int *incx);
-
+double C2F(gensum_double)(int *typ, int *n, void *dx, int *incx);
 #endif /* __GENSUM_H__ */
index 6676518..b06e134 100644 (file)
 
 #include "gencuprod.h"
 
-#define CUPROD(Type) {\
-Type *W;\
-    W=(Type *)w;\
-    t = 1; kk = 0;\
-    for (k = 0; k < *n; ++k) {\
-        t *= (int) W[kk];\
-       W[kk] =(Type)t;kk += (*iw);\
+#define CUPROD(Type) {         \
+Type *IN;                              \
+Type *OUT;                            \
+   IN=(Type *)in;                      \
+   OUT=(Type *)out;                   \
+   kk = 0;                               \
+    for (k = 0; k < *n; ++k) {           \
+      t *= (int)IN[kk];                  \
+       OUT[kk] =(Type)t;kk += (*iw); \
     }\
 }
 
 
-int C2F(gencuprod)(int *typ,int *n, void *w, int *iw)
+int C2F(gencuprod)(int *typ,int *n, void *in, void *out, int *iw)
 {
-  int k, kk, t;
+  int k, kk,t;
+  t=1;
 
   switch (*typ) {
   case 1:
@@ -50,3 +53,43 @@ int C2F(gencuprod)(int *typ,int *n, void *w, int *iw)
   return 0;
 }
 
+#define CUPROD_DOUBLE(Type) {         \
+Type *IN;                              \
+   IN=(Type *)in;                      \
+   kk = 0;                               \
+    for (k = 0; k < *n; ++k) {           \
+      t *= (double)IN[kk];               \
+       out[kk] =t;kk += (*iw); \
+    }\
+}
+
+
+
+int C2F(gencuprod_double)(int *typ,int *n, void *in, double *out, int *iw)
+{
+  int k, kk;
+  double t;
+  t=1.0;
+  switch (*typ) {
+  case 1:
+    CUPROD_DOUBLE(integer1);
+    break;
+  case 2:
+    CUPROD_DOUBLE(integer2);
+    break;
+  case 4:
+    CUPROD_DOUBLE(int) ;
+    break;
+  case 11:
+    CUPROD_DOUBLE(unsigned char);
+    break;
+  case 12:
+    CUPROD_DOUBLE(unsigned short);
+    break;
+  case 14:
+    CUPROD_DOUBLE(unsigned int);
+    break;
+  }
+  return 0;
+}
+
index 560f74d..0f16b3b 100644 (file)
 
 
 #include "gencusum.h"
-#define CUSUM(Type) {\
-Type *W;\
-    W=(Type *)w;\
-    t = 0; kk = 0;\
-    for (k = 0; k < *n; ++k) {\
-        t += (int) W[kk];\
-       W[kk] =(Type)t;kk += (*iw);\
-    }\
+#define CUSUM(Type) {                 \
+Type *IN;                             \
+Type *OUT;                            \
+   IN=(Type *)in;                     \
+   OUT=(Type *)out;                   \
+   kk = 0;                            \
+    for (k = 0; k < *n; ++k) {        \
+      t += (int)IN[kk];               \
+       OUT[kk] =(Type)t;kk += (*iw); \
+    }                                 \
 }
 
 
-int C2F(gencusum)(int *typ,int *n, int *w, int *iw)
+int C2F(gencusum)(int *typ,int *n, void *in, void *out, int *iw)
 {
-  int k, kk, t;
+  int k, kk;
+  int t;
+  t=0;
 
   switch (*typ) {
   case 1:
@@ -50,3 +54,42 @@ int C2F(gencusum)(int *typ,int *n, int *w, int *iw)
   return 0;
 }
 
+#define CUSUM_DOUBLE(Type) {                        \
+Type *IN;\
+   IN=(Type *)in;\
+   kk = 0;                                      \
+    for (k = 0; k < *n; ++k) {\
+      t += (double)IN[kk];                      \
+       out[kk] =t;kk += (*iw);\
+    }\
+}
+
+int C2F(gencusum_double)(int *typ,int *n, void *in, double *out, int *iw)
+{
+  int k, kk;
+  double t;
+  t=0.0;
+
+  switch (*typ) {
+  case 1:
+    CUSUM_DOUBLE(integer1);
+    break;
+  case 2:
+    CUSUM_DOUBLE(integer2);
+    break;
+  case 4:
+    CUSUM_DOUBLE(int) ;
+    break;
+  case 11:
+    CUSUM_DOUBLE(unsigned char);
+    break;
+  case 12:
+    CUSUM_DOUBLE(unsigned short);
+    break;
+  case 14:
+    CUSUM_DOUBLE(unsigned int);
+    break;
+  }
+  return 0;
+}
+
index 72cb801..a28e90e 100644 (file)
 static int c__1 = 1;
 
 #define MCUPROD(Type) {\
-Type *A;\
-    A=(Type *)a;\
+Type *IN;\
+Type *OUT;\
+    IN=(Type *)in;\
+    OUT=(Type *)out;\
     if (*job == 0) {\
-        C2F(gencuprod)(typ,&mn, A, &c__1);\
+      C2F(gencuprod)(typ,&mn, IN, OUT, &c__1);  \
     }\
     else if (*job == 1) {\
        for (j = 0; j < *n; ++j) {\
-           C2F(gencuprod)(typ,m, &A[j * (*na) ], &c__1);\
+           C2F(gencuprod)(typ,m, &IN[j * (*na) ], &OUT[j * (*na) ], &c__1);\
        }}\
     else if (*job == 2) {\
        for (i = 0; i < *m; ++i) {\
-           C2F(gencuprod)(typ,n, &A[i], na);\
+           C2F(gencuprod)(typ,n, &IN[i], &OUT[i], na);\
        }\
     }\
 }
 
-int C2F(genmcuprod)(int *typ,int *job,int * a,int * na,int * m,int * n)
+int C2F(genmcuprod)(int *typ,int *job,void * in, void* out,int * na,int * m,int * n)
 {
   static int  i, j, mn;
 
@@ -59,3 +61,50 @@ int C2F(genmcuprod)(int *typ,int *job,int * a,int * na,int * m,int * n)
   }
   return 0;
 }
+
+
+#define MCUPROD_DOUBLE(Typein) {                       \
+Typein *IN;\
+    IN=(Typein *)in;\
+    if (*job == 0) {\
+        C2F(gencuprod_double)(typ,&mn, IN, out, &c__1);\
+    }\
+    else if (*job == 1) {\
+       for (j = 0; j < *n; ++j) {\
+           C2F(gencuprod_double)(typ,m, &IN[j * (*na) ],&out[j * (*na) ], &c__1);\
+       }}\
+    else if (*job == 2) {\
+       for (i = 0; i < *m; ++i) {\
+           C2F(gencuprod_double)(typ,n, &IN[i], &out[i], na);\
+       }\
+    }\
+}
+
+int C2F(genmcuprodd)(int *typ,int *job,void * in, double *out,int * na,int * m,int * n)
+{
+  static int  i, j, mn;
+
+  mn=(*m)*(*n);
+
+  switch (*typ) {
+  case 1:
+    MCUPROD_DOUBLE(integer1);
+    break;
+  case 2:
+    MCUPROD_DOUBLE(integer2);
+    break;
+  case 4:
+    MCUPROD_DOUBLE(int) ;
+    break;
+  case 11:
+    MCUPROD_DOUBLE(unsigned char);
+    break;
+  case 12:
+    MCUPROD_DOUBLE(unsigned short);
+    break;
+  case 14:
+    MCUPROD_DOUBLE(unsigned int);
+    break;
+  }
+  return 0;
+}
index 1433109..3fd28fe 100644 (file)
 #include "genmcusum.h"
 
 static int c__1 = 1;
-#define MCUSUM(Type) {\
-Type *A;\
-    A=(Type *)a;\
+#define MCUSUM(Type) {                          \
+Type *IN;                                       \
+Type *OUT;                                      \
+    IN=(Type *)in;                              \
+    OUT=(Type *)out;                            \
+    if (*job == 0) {                            \
+        C2F(gencusum)(typ,&mn, IN, OUT, &c__1);\
+    }                                           \
+    else if (*job == 1) {                       \
+       for (j = 0; j < *n; ++j) {              \
+           C2F(gencusum)(typ,m, &IN[j * (*na) ],&OUT[j * (*na) ], &c__1);\
+       }}                                      \
+    else if (*job == 2) {                       \
+       for (i = 0; i < *m; ++i) {              \
+           C2F(gencusum)(typ,n, &IN[i], &OUT[i], na);\
+       }                                       \
+    }                                           \
+}
+
+int C2F(genmcusum)(int *typ,int *job,void * in, void *out,int * na,int * m,int * n)
+{
+  extern int  C2F(gencusum)();
+  static int  i, j, mn;
+
+  mn=(*m)*(*n);
+
+  switch (*typ) {
+  case 1:
+    MCUSUM(integer1);
+    break;
+  case 2:
+    MCUSUM(integer2);
+    break;
+  case 4:
+    MCUSUM(int) ;
+    break;
+  case 11:
+    MCUSUM(unsigned char);
+    break;
+  case 12:
+    MCUSUM(unsigned short);
+    break;
+  case 14:
+    MCUSUM(unsigned int);
+    break;
+  }
+  return 0;
+}
+
+#define MCUSUM_DOUBLE(Type) {                       \
+Type *IN;\
+    IN=(Type *)in;\
     if (*job == 0) {\
-        C2F(gencusum)(typ,&mn, A, &c__1);\
+        C2F(gencusum_double)(typ,&mn, IN, out, &c__1);\
     }\
     else if (*job == 1) {\
        for (j = 0; j < *n; ++j) {\
-           C2F(gencusum)(typ,m, &A[j * (*na) ], &c__1);\
+           C2F(gencusum_double)(typ,m, &IN[j * (*na) ],&out[j * (*na) ], &c__1);\
        }}\
     else if (*job == 2) {\
        for (i = 0; i < *m; ++i) {\
-           C2F(gencusum)(typ,n, &A[i], na);\
+           C2F(gencusum_double)(typ,n, &IN[i], &out[i], na);\
        }\
     }\
 }
 
-int C2F(genmcusum)(int *typ,int *job,int * a,int * na,int * m,int * n)
+int C2F(genmcusumd)(int *typ,int *job,void * in, double *out,int * na,int * m,int * n)
 {
-  extern int  C2F(gencusum)();
+  extern int  C2F(gencusum_double)();
   static int  i, j, mn;
 
   mn=(*m)*(*n);
 
   switch (*typ) {
   case 1:
-    MCUSUM(integer1);
+    MCUSUM_DOUBLE(integer1);
     break;
   case 2:
-    MCUSUM(integer2);
+    MCUSUM_DOUBLE(integer2);
     break;
   case 4:
-    MCUSUM(int) ;
+    MCUSUM_DOUBLE(int) ;
     break;
   case 11:
-    MCUSUM(unsigned char);
+    MCUSUM_DOUBLE(unsigned char);
     break;
   case 12:
-    MCUSUM(unsigned short);
+    MCUSUM_DOUBLE(unsigned short);
     break;
   case 14:
-    MCUSUM(unsigned int);
+    MCUSUM_DOUBLE(unsigned int);
     break;
   }
   return 0;
index cc7aefd..3cb8e4f 100644 (file)
@@ -9,7 +9,7 @@
 * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
 *
 */
-
+#include "genprod.h"
 #include "genmprod.h"
 
 static int c__1 = 1;
@@ -39,7 +39,6 @@ Type *V;\
 
 int C2F(genmprod)(int *typ,int *job, int *a, int *na, int *m, int *n, int *v, int *nv)
 {
-  extern int  C2F(genprod)();
   static int  i, j, t, iv;
 
   switch (*typ) {
@@ -64,3 +63,52 @@ int C2F(genmprod)(int *typ,int *job, int *a, int *na, int *m, int *n, int *v, in
   }
   return 0;
 }
+#define MPROD_DOUBLE(Type) {\
+Type *A;\
+    A=(Type *)a;\
+    iv = 0;\
+    if (*job == 0) {\
+       t = 1.0;\
+       for (j = 0; j < *n; ++j) \
+           t *=  C2F(genprod_double)(typ,m, &A[j * (*na)], &c__1);\
+       v[0] = t;}\
+    else if (*job == 1) {\
+       for (j = 0; j < *n; ++j) {\
+           v[iv] =  C2F(genprod_double)(typ,m, &A[j * (*na) ], &c__1);\
+           iv += *nv;\
+       }}\
+    else if (*job == 2) {\
+       for (i = 0; i < *m; ++i) {\
+           v[iv] =  C2F(genprod_double)(typ,n, &A[i], m);\
+           iv += *nv;\
+       }\
+    }\
+}
+
+int C2F(genmprod_double)(int *typ,int *job, int *a, int *na, int *m, int *n, double *v, int *nv)
+{
+  static int  i, j, iv;
+  static double t;
+
+  switch (*typ) {
+  case 1:
+    MPROD_DOUBLE(integer1);
+    break;
+  case 2:
+    MPROD_DOUBLE(integer2);
+    break;
+  case 4:
+    MPROD_DOUBLE(int) ;
+    break;
+  case 11:
+    MPROD_DOUBLE(unsigned char);
+    break;
+  case 12:
+    MPROD_DOUBLE(unsigned short);
+    break;
+  case 14:
+    MPROD_DOUBLE(unsigned int);
+    break;
+  }
+  return 0;
+}
index 1ab92f7..faadce1 100644 (file)
@@ -64,3 +64,54 @@ int C2F(genmsum)(int *typ,int *job, int *a, int *na, int *m, int *n, int *v, int
   }
   return 0;
 }
+/* sum of int returning a double */
+#define MSUM_DOUBLE(Type) {\
+Type *A;\
+double *V;\
+    A=(Type *)a;\
+    V=(Type *)v;\
+    iv = 0;\
+    if (*job == 0) {\
+       t = 0.0;\
+       for (j = 0; j < *n; ++j) \
+           t +=  C2F(gensum_double)(typ,m, &A[j * (*na)], &c__1);\
+       v[0] = t;}\
+    else if (*job == 1) {\
+       for (j = 0; j < *n; ++j) {\
+           t =  C2F(gensum_double)(typ,m, &A[j * (*na) ], &c__1);\
+           v[iv] = t;iv += *nv;\
+       }}\
+    else if (*job == 2) {\
+       for (i = 0; i < *m; ++i) {\
+           t =  C2F(gensum_double)(typ,n, &A[i], m);\
+           v[iv] = t;iv += *nv;\
+       }\
+    }\
+}
+
+int C2F(genmsum_double)(int *typ,int *job, int *a, int *na, int *m, int *n, double *v, int *nv)
+{
+  static int  i, j, iv;
+  double t;
+  switch (*typ) {
+  case 1:
+    MSUM_DOUBLE(integer1);
+    break;
+  case 2:
+    MSUM_DOUBLE(integer2);
+    break;
+  case 4:
+    MSUM_DOUBLE(int) ;
+    break;
+  case 11:
+    MSUM_DOUBLE(unsigned char);
+    break;
+  case 12:
+    MSUM_DOUBLE(unsigned short);
+    break;
+  case 14:
+    MSUM_DOUBLE(unsigned int);
+    break;
+  }
+  return 0;
+}
diff --git a/scilab/modules/integer/src/c/genmsum_double.c b/scilab/modules/integer/src/c/genmsum_double.c
new file mode 100644 (file)
index 0000000..de30bc7
--- /dev/null
@@ -0,0 +1,66 @@
+/*
+* Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+* Copyright (C) 2010 -  INRIA - Serge Steer 
+* 
+* 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    
+* http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
+*
+*/
+
+#include "gensum.h"
+#include "genmsum.h"
+
+static int c__1 = 1;
+#define MSUM_DOUBLE(Type) {\
+Type *A;\
+double *V;\
+    A=(Type *)a;\
+    V=(Type *)v;\
+    iv = 0;\
+    if (*job == 0) {\
+       t = 0;\
+       for (j = 0; j < *n; ++j) \
+           t +=  C2F(gensum_double)(typ,m, &A[j * (*na)], &c__1);\
+       v[0] = (Type)t;}\
+    else if (*job == 1) {\
+       for (j = 0; j < *n; ++j) {\
+           t =  C2F(gensum_double)(typ,m, &A[j * (*na) ], &c__1);\
+           v[iv] = (Type)t;iv += *nv;\
+       }}\
+    else if (*job == 2) {\
+       for (i = 0; i < *m; ++i) {\
+           t =  C2F(gensum_double)(typ,n, &A[i], m);\
+           v[iv] = (Type)t;iv += *nv;\
+       }\
+    }\
+}
+
+int C2F(genmsum_double)(int *typ,int *job, int *a, int *na, int *m, int *n, double *v, int *nv)
+{
+  static int  i, j, t, iv;
+
+  switch (*typ) {
+  case 1:
+    MSUM(integer1);
+    break;
+  case 2:
+    MSUM(integer2);
+    break;
+  case 4:
+    MSUM(int) ;
+    break;
+  case 11:
+    MSUM(unsigned char);
+    break;
+  case 12:
+    MSUM(unsigned short);
+    break;
+  case 14:
+    MSUM(unsigned int);
+    break;
+  }
+  return 0;
+}
index e604c76..557bd87 100644 (file)
 
 #include "genprod.h"
 
-#define PROD(Type) {\
-Type *DX;\
- DX=(Type *)dx;\
+#define PROD(Typein,Typeout) {\
+Typein *DX;\
+ DX=(Typein *)dx;\
  --DX;\
  if (*incx == 1) {\
-   for (i = 1; i <= *n; ++i) dtemp *= (int) DX[i];\
+   for (i = 1; i <= *n; ++i) dtemp *= (Typeout) DX[i];\
  }\
  else {\
    i1 = *n * *incx;i2 = *incx;\
-   for (i = 1; i2 < 0 ? i >= i1 : i <= i1; i += i2) dtemp *= (int) DX[i];\
+   for (i = 1; i2 < 0 ? i >= i1 : i <= i1; i += i2) dtemp *= (Typeout) DX[i];\
  }\
 }
 
-int C2F(genprod)(int *typ, int *n, int *dx, int *incx)
+int C2F(genprod)(int *typ, int *n, void *dx, int *incx)
 {
     int  i1, i2;
     static int i, dtemp;
@@ -36,22 +36,55 @@ int C2F(genprod)(int *typ, int *n, int *dx, int *incx)
 
     switch (*typ) {
     case 1:
-      PROD(integer1);
+      PROD(integer1,int);
       break;
     case 2:
-      PROD(integer2);
+      PROD(integer2,int);
       break;
     case 4:
-      PROD(int) ;
+      PROD(int,int) ;
       break;
     case 11:
-      PROD(unsigned char);
+      PROD(unsigned char,int);
       break;
     case 12:
-      PROD(unsigned short);
+      PROD(unsigned short,int);
       break;
     case 14:
-      PROD(unsigned int);
+      PROD(unsigned int,int);
+      break;
+    }
+    return dtemp;
+}
+
+double C2F(genprod_double)(int *typ, int *n, void *dx, int *incx)
+{
+    int  i1, i2;
+    static int i;
+    static double dtemp;
+
+
+    dtemp = 1.0;
+    if (*n <= 0) return dtemp;
+
+    switch (*typ) {
+    case 1:
+      PROD(integer1,double);
+      break;
+    case 2:
+      PROD(integer2,double);
+      break;
+    case 4:
+      PROD(int,double);
+      break;
+    case 11:
+      PROD(unsigned char,double);
+      break;
+    case 12:
+      PROD(unsigned short,double);
+      break;
+    case 14:
+      PROD(unsigned int,double);
       break;
     }
     return dtemp;
index 8eff603..235693f 100644 (file)
 
 #include "gensum.h"
 
-#define SUM(Type) {\
-Type *DX;\
- DX=(Type *)dx;\
+#define SUM(Typein,Typeout) {                          \
+Typein *DX;\
+ DX=(Typein *)dx;\
  --DX;\
  if (*incx == 1) {\
-   for (i = 1; i <= *n; ++i) dtemp += (int) DX[i];\
+   for (i = 1; i <= *n; ++i) dtemp += (Typeout) DX[i];\
  }\
  else {\
    i1 = *n * *incx;i2 = *incx;\
-   for (i = 1; i2 < 0 ? i >= i1 : i <= i1; i += i2) dtemp += (int) DX[i];\
+   for (i = 1; i2 < 0 ? i >= i1 : i <= i1; i += i2) dtemp += (Typeout) DX[i];\
  }\
 }
 
@@ -36,25 +36,57 @@ int C2F(gensum)(int *typ, int *n, void *dx, int *incx)
 
     switch (*typ) {
     case 1:
-      SUM(integer1);
+      SUM(integer1,int);
       break;
     case 2:
-      SUM(integer2);
+      SUM(integer2,int);
       break;
     case 4:
-      SUM(int) ;
+      SUM(int,int) ;
       break;
     case 11:
-      SUM(unsigned char);
+      SUM(unsigned char,int);
       break;
     case 12:
-      SUM(unsigned short);
+      SUM(unsigned short,int);
       break;
     case 14:
-      SUM(unsigned int);
+      SUM(unsigned int,int);
       break;
     }
     return dtemp;
 }
 
+double C2F(gensum_double)(int *typ, int *n, void *dx, int *incx)
+{
+    int  i1, i2;
+    static int i;
+    static double dtemp;
+
 
+    dtemp = 0.0;
+    if (*n <= 0) return dtemp;
+
+    switch (*typ) {
+    case 1:
+      SUM(integer1,double);
+      break;
+    case 2:
+      SUM(integer2,double);
+      break;
+    case 4:
+      SUM(int,double) ;
+      break;
+    case 11:
+      SUM(unsigned char,double);
+      break;
+    case 12:
+      SUM(unsigned short,double);
+      break;
+    case 14:
+      SUM(unsigned int,double);
+      break;
+    }
+    return dtemp;
+    sciprint("gensum,%f\n",dtemp);
+}
diff --git a/scilab/modules/integer/src/c/gensum_double.c b/scilab/modules/integer/src/c/gensum_double.c
new file mode 100644 (file)
index 0000000..f07492c
--- /dev/null
@@ -0,0 +1,61 @@
+/*
+* Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+* Copyright (C) 2010 -  INRIA - Serge Steer 
+* 
+* 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    
+* http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
+*
+*/
+
+#include "gensum.h"
+
+#define SUM_DOUBLE(Type) {\
+Type *DX;\
+ DX=(Type *)dx;\
+ --DX;\
+ if (*incx == 1) {\
+   for (i = 1; i <= *n; ++i) dtemp += (double) DX[i];\
+ }\
+ else {\
+   i1 = *n * *incx;i2 = *incx;\
+   for (i = 1; i2 < 0 ? i >= i1 : i <= i1; i += i2) dtemp += (double) DX[i];\
+ }\
+}
+
+double C2F(gensum_double)(int *typ, int *n, void *dx, int *incx)
+{
+    int  i1, i2;
+    static int i;
+    static double dtemp;
+
+
+    dtemp = 0.0;
+    if (*n <= 0) return dtemp;
+
+    switch (*typ) {
+    case 1:
+      SUM(integer1);
+      break;
+    case 2:
+      SUM(integer2);
+      break;
+    case 4:
+      SUM(int) ;
+      break;
+    case 11:
+      SUM(unsigned char);
+      break;
+    case 12:
+      SUM(unsigned short);
+      break;
+    case 14:
+      SUM(unsigned int);
+      break;
+    }
+    return dtemp;
+}
+
+
index 562ff77..82499aa 100644 (file)
@@ -15,12 +15,16 @@ c     WARNING : argument of this interface may be passed by reference
       integer sel,tops
       external memused,mtlbsel
       integer memused,mtlbsel
+      integer type
+      integer native
+      parameter (native=0)
+c
       integer iadr,sadr
 c     
       iadr(l)=l+l-1
       sadr(l)=(l/2)+1
 c
-      if(rhs.gt.2) then
+      if(rhs.gt.3) then
          call error(42)
          return
       endif
@@ -37,33 +41,72 @@ c
       if(istk(il0).lt.0) il0=iadr(istk(il0+1))
       ref=ilr.ne.il0
 c
-      if(rhs.eq.2) then
-         call getorient(top,sel)
-         if(err.gt.0) return
-         top=top-1
-         if(sel.eq.-1) sel=mtlbsel(istk(il0+1),2)
-      endif
-
+      call  orientandtype(sel,type)
+      if (err.gt.0.or.err1.gt.0) return
+      if(sel.eq.-1) sel=mtlbsel(istk(il0+1),2)
+c
       m=istk(il0+1)
       n=istk(il0+2)
       it=istk(il0+3)
       l=il0+4
       l1=ilr+4
       mn=m*n
-
 c
-      if(ref) then
-         err=sadr(l1+memused(it,mn))-lstk(bot)
+      if (sel.gt.2) then
+c     cumprod(a,sel)-->a
+         lr=sadr(il0+4)
+         err=lr+mn-lstk(bot)
          if(err.gt.0) then
             call error(17)
             return
          endif
-         call icopy(4,istk(il0),1,istk(ilr),1)
-         call gencopy(it,mn,istk(l),1,istk(l1),1)
+         call tpconv(it,0, mn,istk(l1),-1,stk(lr),-1)
+         istk(ilr)=1
+         istk(ilr+1)=m
+         istk(ilr+2)=n
+         istk(ilr+3)=0
+         lstk(top+1)=lr+mn
+         return
+      endif
+c
+      if (type.eq.native) then
+c     .  result in integers
+         if(ref) then
+            err=sadr(l1+memused(it,mn))-lstk(bot)
+            if(err.gt.0) then
+               call error(17)
+               return
+            endif
+            call icopy(4,istk(il0),1,istk(ilr),1)
+            call gencopy(it,mn,istk(l),1,istk(l1),1)
+         endif
+         lstk(top+1)=sadr(l1+memused(it,mn))
+         if(mn.eq.0) return
+         call genmcuprod(it,sel,istk(l1),istk(l1),m,m,n)
+      else
+C     . result in floats
+         if(ref) then
+            lr=sadr(ilr+4)
+         else
+            lr=lstk(top+1)
+         endif
+         err=lr+mn-lstk(bot)
+         if(err.gt.0) then
+            call error(17)
+            return
+         endif
+         call genmcuprodd(it,sel,istk(l1),stk(lr),m,m,n)
+         if(ref) then
+            lstk(top+1)=lr+mn
+         else
+            l1=sadr(ilr+4)
+            call dcopy(mn,stk(lr),1,stk(l1),1)
+            lstk(top+1)=l1+mn
+         endif
+         istk(ilr)=1
+         istk(ilr+1)=m
+         istk(ilr+2)=n
+         istk(ilr+3)=0
       endif
-      lstk(top+1)=sadr(l1+memused(it,mn))
-      if(mn.eq.0) return
-
-      call genmcuprod(it,sel,istk(l1),m,m,n)
-
       end
index 215eb55..98fec39 100644 (file)
@@ -15,12 +15,16 @@ c     WARNING : argument of this interface may be passed by reference
       integer sel,tops
       external memused,mtlbsel
       integer memused,mtlbsel
+      integer type
+      integer native
+      parameter (native=0)
+c
       integer iadr,sadr
 c     
       iadr(l)=l+l-1
       sadr(l)=(l/2)+1
 c
-      if(rhs.gt.2) then
+      if(rhs.gt.3) then
          call error(42)
          return
       endif
@@ -37,33 +41,70 @@ c
       if(istk(il0).lt.0) il0=iadr(istk(il0+1))
       ref=ilr.ne.il0
 c
-      if(rhs.eq.2) then
-         call getorient(top,sel)
-         if(err.gt.0) return
-         top=top-1
-         if(sel.eq.-1) sel=mtlbsel(istk(il0+1),2)
-      endif
-
+      call  orientandtype(sel,type)
+      if (err.gt.0.or.err1.gt.0) return
+      if(sel.eq.-1) sel=mtlbsel(istk(il0+1),2)
+c
       m=istk(il0+1)
       n=istk(il0+2)
       it=istk(il0+3)
       l=il0+4
       l1=ilr+4
       mn=m*n
-
 c
-      if(ref) then
-         err=sadr(l1+memused(it,mn))-lstk(bot)
+      if (sel.gt.2) then
+c     cumsum(a,sel)-->a
+         lr=sadr(il0+4)
+         err=lr+mn-lstk(bot)
          if(err.gt.0) then
             call error(17)
             return
          endif
-         call icopy(4,istk(il0),1,istk(ilr),1)
-         call gencopy(it,mn,istk(l),1,istk(l1),1)
+         call tpconv(it,0, mn,istk(l1),-1,stk(lr),-1)
+         istk(ilr)=1
+         istk(ilr+1)=m
+         istk(ilr+2)=n
+         istk(ilr+3)=0
+         lstk(top+1)=lr+mn
+         return
       endif
-      lstk(top+1)=sadr(l1+memused(it,mn))
-      if(mn.eq.0) return
 
-      call genmcusum(it,sel,istk(l1),m,m,n)
+      if (type.eq.native) then
+c     .  result in integers
+         if(ref) then
+            err=sadr(l1+memused(it,mn))-lstk(bot)
+            if(err.gt.0) then
+               call error(17)
+               return
+            endif
+            call icopy(4,istk(il0),1,istk(ilr),1)
+            call gencopy(it,mn,istk(l),1,istk(l1),1)
+         endif
+         lstk(top+1)=sadr(l1+memused(it,mn))
+         if(mn.eq.0) return
 
+         call genmcusum(it,sel,istk(l1),istk(l1),m,m,n)
+      else
+C     . result in floats
+         if(ref) then
+            lr=sadr(ilr+4)
+         else
+            lr=lstk(top+1)
+         endif
+         err=lr+mn-lstk(bot)
+         if(err.gt.0) then
+            call error(17)
+            return
+         endif
+         call genmcusumd(it,sel,istk(l1),stk(lr),m,m,n)
+         if(ref) then
+            lstk(top+1)=lr+mn
+         else
+            l1=sadr(ilr+4)
+            call dcopy(mn,stk(lr),1,stk(l1),1)
+            lstk(top+1)=l1+mn
+         endif
+         istk(ilr)=1
+         istk(ilr+3)=0
+      endif
       end
index c0b0f83..4445cc6 100644 (file)
@@ -13,6 +13,10 @@ c     WARNING : argument of this interface may be passed by reference
       integer id(nsiz)
       logical ref
       integer sel,tops
+      integer type
+      integer native
+      parameter (native=0)
+
       integer iadr,sadr
 
       external memused,mtlbsel
@@ -21,7 +25,7 @@ c
       iadr(l)=l+l-1
       sadr(l)=(l/2)+1
 c
-      if(rhs.gt.2) then
+      if(rhs.gt.3) then
          call error(42)
          return
       endif
@@ -38,12 +42,10 @@ c
       if(istk(il0).lt.0) il0=iadr(istk(il0+1))
       ref=ilr.ne.il0
 c     
-      if(rhs.eq.2) then
-         call  getorient(top,sel)
-         if(err.gt.0) return
-         if(sel.eq.-1) sel=mtlbsel(istk(il0+1),2)
-         top=top-1
-      endif
+      call  orientandtype(sel,type)
+      if (err.gt.0.or.err1.gt.0) return
+      if(sel.eq.-1) sel=mtlbsel(istk(il0+1),2)
+
       m=istk(il0+1)
       n=istk(il0+2)
       it=istk(il0+3)
@@ -51,6 +53,9 @@ c
       l1=ilr+4
       l=il0+4
       if(mn.eq.0) then
+c     .  as the only empty matrices have a double type this part of code
+c     .  should never be used.
+
          if(ref) then
             err=sadr(l1+1)-lstk(bot)
             if(err.gt.0) then
@@ -75,7 +80,22 @@ c
          endif
          return
       endif
-
+      if (sel.gt.2) then
+c     prod(a,sel)-->a
+         lr=sadr(il0+4)
+         err=lr+mn-lstk(bot)
+         if(err.gt.0) then
+            call error(17)
+            return
+         endif
+         call tpconv(it,0, mn,istk(l1),-1,stk(lr),-1)
+         istk(ilr)=1
+         istk(ilr+1)=m
+         istk(ilr+2)=n
+         istk(ilr+3)=0
+         lstk(top+1)=lr+mn
+         return
+      endif
       if(sel.eq.0) then
          mr=1
          nr=1
@@ -86,22 +106,48 @@ c
          mr=m
          nr=1
       endif
-      if(ref) then
-         err=sadr(l1+memused(it,mr*nr))-lstk(bot)
+      if(type.eq.native) then
+c     .  return an array of integers
+
+         if(ref) then
+            err=sadr(l1+memused(it,mr*nr))-lstk(bot)
+            if(err.gt.0) then
+               call error(17)
+               return
+            endif
+         endif
+         istk(ilr)=8
+         istk(ilr+1)=mr
+         istk(ilr+2)=nr
+         istk(ilr+3)=it
+         l1=ilr+4
+
+         call genmprod(it,sel,istk(l),m,m,n,istk(l1),1)
+
+         lstk(top+1)=sadr(l1+memused(it,mr*nr))
+      else
+c     .  return an array of doubles
+         if(ref) then
+            lr=sadr(ilr+4)
+         else
+            lr=lstk(top+1)
+         endif
+         err=lr+mr*nr-lstk(bot)
          if(err.gt.0) then
             call error(17)
             return
          endif
+         call genmprod_double(it,sel,istk(l),m,m,n,stk(lr),1)
+         if (.not.ref) then
+            call dcopy(mr*nr,stk(lr),1,stk(sadr(ilr+4)),1)
+            lr=sadr(ilr+4)
+         endif
+         istk(ilr)=1
+         istk(ilr+1)=mr
+         istk(ilr+2)=nr
+         istk(ilr+3)=0
+         lstk(top+1)=lr+mr*nr
       endif
-      istk(ilr)=8
-      istk(ilr+1)=mr
-      istk(ilr+2)=nr
-      istk(ilr+3)=it
-      l1=ilr+4
-
-      call genmprod(it,sel,istk(l),m,m,n,istk(l1),1)
-
-      lstk(top+1)=sadr(l1+memused(it,mr*nr))
       return
       end
 
index 2512dd8..dcfdb65 100644 (file)
@@ -17,11 +17,14 @@ c     WARNING : argument of this interface may be passed by reference
 
       external memused,mtlbsel
       integer memused,mtlbsel
+      integer type
+      integer native
+      parameter (native=0)
 c     
       iadr(l)=l+l-1
       sadr(l)=(l/2)+1
 c
-      if(rhs.gt.2) then
+      if(rhs.gt.3) then
          call error(42)
          return
       endif
@@ -31,19 +34,17 @@ c
       endif
 c
       tops=top
-      sel=0
 c     
       il0=iadr(lstk(tops-rhs+1))
       ilr=il0
       if(istk(il0).lt.0) il0=iadr(istk(il0+1))
       ref=ilr.ne.il0
 c     
-      if(rhs.eq.2) then
-         call  getorient(top,sel)
-         if(err.gt.0) return
-         if(sel.eq.-1) sel=mtlbsel(istk(il0+1),2)
-         top=top-1
-      endif
+      call  orientandtype(sel,type)
+      if (err.gt.0.or.err1.gt.0) return
+      if(sel.eq.-1) sel=mtlbsel(istk(il0+1),2)
+      
+
       m=istk(il0+1)
       n=istk(il0+2)
       it=istk(il0+3)
@@ -51,6 +52,8 @@ c
       l1=ilr+4
       l=il0+4
       if(mn.eq.0) then
+c     .  as the only empty matrices have a double type this part of code
+c     .  should never be used.
          if(ref) then
             err=sadr(l1+1)-lstk(bot)
             if(err.gt.0) then
@@ -75,6 +78,22 @@ c
          endif
          return
       endif
+      if (sel.gt.2) then
+c     sum(a,sel)-->a
+         lr=sadr(il0+4)
+         err=lr+mn-lstk(bot)
+         if(err.gt.0) then
+            call error(17)
+            return
+         endif
+         call tpconv(it,0, mn,istk(l1),-1,stk(lr),-1)
+         istk(ilr)=1
+         istk(ilr+1)=m
+         istk(ilr+2)=n
+         istk(ilr+3)=0
+         lstk(top+1)=lr+mn
+         return
+      endif
 
       if(sel.eq.0) then
          mr=1
@@ -86,22 +105,46 @@ c
          mr=m
          nr=1
       endif
-      if(ref) then
-         err=sadr(l1+memused(it,mr*nr))-lstk(bot)
+      if(type.eq.native) then
+c     .  return an array of integers
+         if(ref) then
+            err=sadr(l1+memused(it,mr*nr))-lstk(bot)
+            if(err.gt.0) then
+               call error(17)
+               return
+            endif
+         endif
+     
+         istk(ilr)=8
+         istk(ilr+1)=mr
+         istk(ilr+2)=nr
+         istk(ilr+3)=it
+         l1=ilr+4
+         call genmsum(it,sel,istk(l),m,m,n,istk(l1),1)
+         lstk(top+1)=sadr(l1+memused(it,mr*nr))
+      else
+c     .  return an array of doubles
+         if(ref) then
+            lr=sadr(ilr+4)
+         else
+            lr=lstk(top+1)
+         endif
+         err=lr+mr*nr-lstk(bot)
          if(err.gt.0) then
             call error(17)
             return
          endif
+         call genmsum_double(it,sel,istk(l),m,m,n,stk(lr),1)
+         if (.not.ref) then
+            call dcopy(mr*nr,stk(lr),1,stk(sadr(ilr+4)),1)
+            lr=sadr(ilr+4)
+         endif
+         istk(ilr)=1
+         istk(ilr+1)=mr
+         istk(ilr+2)=nr
+         istk(ilr+3)=0
+         lstk(top+1)=lr+mr*nr
       endif
-      istk(ilr)=8
-      istk(ilr+1)=mr
-      istk(ilr+2)=nr
-      istk(ilr+3)=it
-      l1=ilr+4
-
-      call genmsum(it,sel,istk(l),m,m,n,istk(l1),1)
-
-      lstk(top+1)=sadr(l1+memused(it,mr*nr))
       return
       end
 
diff --git a/scilab/modules/integer/tests/nonreg_tests/bug_3842.dia.ref b/scilab/modules/integer/tests/nonreg_tests/bug_3842.dia.ref
new file mode 100644 (file)
index 0000000..f5544e9
--- /dev/null
@@ -0,0 +1,1071 @@
+// =============================================================================
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2010 - INRIA - Serge Steer
+//
+//  This file is distributed under the same license as the Scilab package.
+// =============================================================================
+// <-- Non-regression test for bug 3842 -->
+//
+// <-- Bugzilla URL -->
+// http://bugzilla.scilab.org/show_bug.cgi?id=3842
+//
+// <-- Short Description -->
+// sum applyed to integer arrys can only procuce results computed using native operations.
+exec SCI/modules/elementary_functions/tests/unit_tests/prod.tst
+// =============================================================================
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2010 - INRIA - Serge Steer
+//
+//  This file is distributed under the same license as the Scilab package.
+// =============================================================================
+// <-- JVM NOT MANDATORY 
+// prod 
+//empty matrices
+T=list(list(),list('native'),list('double'));
+for typ=T
+  if prod([],typ(:))<>1 then pause,end
+  if prod([],'*',typ(:))<>1 then pause,end
+  if prod([],1,typ(:))<>[] then pause,end
+  if prod([],2,typ(:))<>[] then pause,end
+  if prod([],3,typ(:))<>[] then pause,end
+end
+//=======================================================================
+//float matrices
+d=[1 10;254 9];
+T=list(list(),list('native'),list('double'));
+for typ=T
+  if prod(d,typ(:))<>22860 then pause,end
+  if prod(d,'*',typ(:))<>22860 then pause,end
+  if or(prod(d,1,typ(:))<>[254 90]) then pause,end
+  if or(prod(d,2,typ(:))<>[10;2286]) then pause,end
+  if or(prod(d,3,typ(:))<>d) then pause,end
+end
+//hypermatrices of floats
+d=[1 10;254 9];d(:,:,2)=1;
+T=list(list(),list('native'),list('double'));
+for typ=T
+  if prod(d,typ(:))<>22860 then pause,end
+  if prod(d,'*',typ(:))<>22860 then pause,end
+  if or(prod(d,1,typ(:))<>hypermat([1,2,2],[254;90;1;1])) then pause,end
+  if or(prod(d,2,typ(:))<>hypermat([2,1,2],[10;2286;1;1])) then pause,end
+  if or(prod(d,3,typ(:))<>[1,10;254,9]) then pause,end
+  if or(prod(d,5,typ(:))<>d) then pause,end
+end
+//=======================================================================
+//matrices of short integers
+i=uint8([1 10;254 9]);
+T=list(list(),list('native'));
+for typ=T
+  if prod(i,typ(:))<>uint8(76) then pause,end
+  if prod(i,'*',typ(:))<>uint8(76) then pause,end
+  if or(prod(i,1,typ(:))<>uint8([254 90])) then pause,end
+  if or(prod(i,2,typ(:))<>uint8([10;238])) then pause,end
+  if or(prod(i,3,typ(:))<>i) then pause,end
+end
+if prod(i,'double')<>22860 then pause,end
+if prod(i,'*','double')<>22860 then pause,end
+if or(prod(i,1,'double')<>[254 90]) then pause,end
+if or(prod(i,2,'double')<>[10;2286]) then pause,end
+if or(prod(i,3,'double')<>double(i)) then pause,end
+//with hypermatrices
+i=uint8([1 10;254 9]);i(:,:,2)=uint8(1);
+for typ=list(list(),list('native'));
+  if prod(i,typ(:))<>uint8(76) then pause,end
+  if prod(i,'*',typ(:))<>uint8(76) then pause,end
+  if or(prod(i,1,typ(:))<>hypermat([1,2,2],uint8([254;90;1;1]))) then pause,end
+  if or(prod(i,2,typ(:))<>hypermat([2,1,2],uint8([10;238;1;1]))) then pause,end
+  if or(prod(i,3,typ(:))<>([1,10;254,9])) then pause,end
+  if or(prod(i,5,typ(:))<>i) then pause,end
+end
+if prod(i,'double')<>22860 then pause,end
+if prod(i,'*','double')<>22860 then pause,end
+if or(prod(i,1,'double')<>hypermat([1,2,2],[254;90;1;1])) then pause,end
+if or(prod(i,2,'double')<>hypermat([2,1,2],[10;2286;1;1])) then pause,end
+if or(prod(i,3,'double')<>[1,10;254,9]) then pause,end
+if or(prod(i,5,'double')<>double(i)) then pause,end
+//Polynomials
+s=%s;p=[s s+1;s^2 1];
+T=list(list(),list('native'),list('double'));
+for typ=T
+  if prod(p,typ(:))<>s^3+s^4 then pause,end
+  if prod(p,'*',typ(:))<>s^3+s^4 then pause,end
+  if or(prod(p,1,typ(:))<>[s^3,1+s]) then pause,end
+  if or(prod(p,2,typ(:))<>[s+s^2;s^2]) then pause,end
+  if or(prod(p,3,typ(:))<>p) then pause,end
+end
+//with hypermatrices
+s=%s;p=[s s+1;s^2 1];p(:,:,2)=[1 s;s+1 2];
+T=list(list(),list('native'),list('double'));
+for typ=T
+  if prod(p,typ(:))<>2*s^4+4*s^5+2*s^6 then pause,end
+  if prod(p,'*',typ(:))<>2*s^4+4*s^5+2*s^6 then pause,end
+  if or(prod(p,1,typ(:))<>hypermat([1,2,2],[s^3;1+s;1+s;2*s])) then pause,end
+  if or(prod(p,2,typ(:))<>hypermat([2,1,2],[s+s^2;s^2;s;2+2*s])) then pause,end
+  if or(prod(p,3,typ(:))<>[s,s+s^2;s^2+s^3,2]) then pause,end
+  if or(prod(p,5,typ(:))<>p) then pause,end
+end
+//=======================================================================
+//Matrices of rationals
+s=%s;r=1.0 ./[s s+1;s^2 1];
+T=list(list(),list('native'),list('double'));
+for typ=T
+  if prod(r,typ(:))<>1.0/(s^3+s^4) then pause,end
+  if prod(r,'*',typ(:))<>1.0/(s^3+s^4) then pause,end
+  if or(prod(r,1,typ(:))<>[1,1]./[s^3,1+s]) then pause,end
+  if or(prod(r,2,typ(:))<>[1;1]./[s+s^2;s^2]) then pause,end
+  if or(prod(r,3,typ(:))<>r) then pause,end
+end
+//=======================================================================
+//Matrices of booleans
+b=[%t %t; %f %t];
+for typ=list(list(),list('double'));
+  if prod(b,typ(:))<>0 then pause,end
+  if prod(b,'*',typ(:))<>0 then pause,end
+  if or(prod(b,1,typ(:))<>[0 1]) then pause,end
+  if or(prod(b,2,typ(:))<>[1;0]) then pause,end
+  if or(prod(b,3,typ(:))<>double(b)) then pause,end
+end
+if prod(b,'native')<>%f then pause,end
+if prod(b,'*','native')<>%f then pause,end
+if or(prod(b,1,'native')<>[%f %t]) then pause,end
+if or(prod(b,2,'native')<>[%t;%f]) then pause,end
+if or(prod(b,3,'native')<>b) then pause,end
+//with hypermatrices 
+b=[%t %t;%f %t];b(1,1,2)=%t;
+for typ=list(list(),list('double'));
+  if prod(b,typ(:))<>0 then pause,end
+  if prod(b,'*',typ(:))<>0 then pause,end
+  if or(prod(b,1,typ(:))<>hypermat([1,2,2],[0;1;0;0])) then pause,end
+  if or(prod(b,2,typ(:))<>hypermat([2,1,2],[1;0;0;0])) then pause,end
+  if or(prod(b,3,typ(:))<>[1,0;0,0]) then pause,end
+  if or(prod(b,5,typ(:))<>double(b)) then pause,end
+end
+if prod(b,'native')<>%f then pause,end
+if prod(b,'*','native')<>%f then pause,end
+if or(prod(b,1,'native')<>hypermat([1,2,2],[%f;%t;%f;%f])) then pause,end
+if or(prod(b,2,'native')<>hypermat([2,1,2],[%t;%f;%f;%f])) then pause,end
+if or(prod(b,3,'native')<>[%t,%f;%f,%f]) then pause,end
+if or(prod(b,5,'native')<>b) then pause,end
+//=======================================================================
+//sparse matrices of floats
+s=sparse([1 10 2;-1 254 9]);
+T=list(list(),list('native'),list('double'));
+for typ=T
+  if prod(s,typ(:))<>-45720 then pause,end
+  if prod(s,'*',typ(:))<>-45720 then pause,end
+  if or(prod(s,1,typ(:))<>sparse([-1 2540 18])) then pause,end
+  if or(prod(s,2,typ(:))<>sparse([20;-2286])) then pause,end
+  if or(prod(s,3,typ(:))<>s) then pause,end
+end
+//=======================================================================
+//sparse  matrices of boolean
+bs=sparse([%t %t %f;%t %t %t]);
+for typ=list(list(),list('double'));
+  if prod(bs,typ(:))<>0 then pause,end
+  if prod(bs,'*',typ(:))<>0 then pause,end
+  if or(prod(bs,1,typ(:))<>sparse([1,1,0])) then pause,end
+  if or(prod(bs,2,typ(:))<>sparse([0;1])) then pause,end
+  if or(prod(bs,3,typ(:))<>bool2s(bs)) then pause,end
+end
+if prod(bs,'native')<>%f then pause,end
+if prod(bs,'*','native')<>%f then pause,end
+if or(prod(bs,1,'native')<>sparse([%t,%t,%f])) then pause,end
+if or(prod(bs,2,'native')<>sparse([%f;%t])) then pause,end
+if or(prod(bs,3,'native')<>bs) then pause,end
+exec SCI/modules/elementary_functions/tests/unit_tests/cumprod.tst
+// =============================================================================
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2010 - INRIA - Serge Steer
+//
+//  This file is distributed under the same license as the Scilab package.
+// =============================================================================
+// <-- JVM NOT MANDATORY 
+//cumprod
+//Empty matrices
+T=list(list(),list('native'),list('double'));
+for typ=T
+  if cumprod([],typ(:))<>[] then pause,end
+  if cumprod([],'*',typ(:))<>[] then pause,end
+  if cumprod([],1,typ(:))<>[] then pause,end
+  if cumprod([],2,typ(:))<>[] then pause,end
+  if cumprod([],3,typ(:))<>[] then pause,end
+end
+//=======================================================================
+//float matrices
+d=[1 10;254 9];
+T=list(list(),list('native'),list('double'));
+for typ=T
+  if or(cumprod(d,typ(:))<>[1,2540;254,22860]) then pause,end
+  if or(cumprod(d,'*',typ(:))<>[1,2540;254,22860]) then pause,end
+  if or(cumprod(d,1,typ(:))<>[1,10;254,90]) then pause,end
+  if or(cumprod(d,2,typ(:))<>[1,10;254,2286]) then pause,end
+  if or(cumprod(d,3,typ(:))<>d) then pause,end
+end
+//hypermatrices of floats
+d=[1 10;254 9];d(1,1,2)=1;
+T=list(list(),list('native'),list('double'));
+for typ=T
+  if or(cumprod(d,typ(:))<>hypermat([2,2,2],[1;254;2540;22860;22860;0;0;0])) then pause,end
+  if or(cumprod(d,'*',typ(:))<>hypermat([2,2,2],[1;254;2540;22860;22860;0;0;0])) then pause,end
+  if or(cumprod(d,1,typ(:))<>hypermat([2,2,2],[1;254;10;90;1;0;0;0])) then pause,end
+  if or(cumprod(d,2,typ(:))<>hypermat([2,2,2],[1;254;10;2286;1;0;0;0])) then pause,end
+  if or(cumprod(d,3,typ(:))<>hypermat([2,2,2],[1;254;10;9;1;0;0;0])) then pause,end
+  if or(cumprod(d,5,typ(:))<>d) then pause,end
+end
+//=======================================================================
+//Integers
+i=uint8([1 10;254 9]);
+for typ=list(list(),list('native'));
+  if or(cumprod(i,typ(:))<>uint8([1,236;254,76])) then pause,end
+  if or(cumprod(i,'*',typ(:))<>uint8([1,236;254,76])) then pause,end
+  if or(cumprod(i,1,typ(:))<>uint8([1,10;254,90])) then pause,end
+  if or(cumprod(i,2,typ(:))<>uint8([1,10;254,238])) then pause,end
+  if or(cumprod(i,3,typ(:))<>i) then pause,end
+end
+if or(cumprod(i,'double')<>[1,2540;254,22860]) then pause,end
+if or(cumprod(i,'*','double')<>[1,2540;254,22860]) then pause,end
+if or(cumprod(i,1,'double')<>[1,10;254,90]) then pause,end
+if or(cumprod(i,2,'double')<>[1,10;254,2286]) then pause,end
+if or(cumprod(i,3,'double')<>double(i)) then pause,end
+//with hypermatrices
+i=uint8([1 10;254 9]);i(1,1,2)=uint8(1);
+for typ=list(list(),list('native'));
+  if or(cumprod(i,typ(:))<>hypermat([2,2,2],uint8([1;254;236;76;76;0;0;0]))) then pause,end
+  if or(cumprod(i,'*',typ(:))<>hypermat([2,2,2],uint8([1;254;236;76;76;0;0;0]))) then pause,end
+  if or(cumprod(i,1,typ(:))<>hypermat([2,2,2],uint8([1;254;10;90;1;0;0;0]))) then pause,end
+  if or(cumprod(i,2,typ(:))<>hypermat([2,2,2],uint8([1;254;10;238;1;0;0;0]))) then pause,end
+  if or(cumprod(i,3,typ(:))<>hypermat([2,2,2],uint8([1;254;10;9;1;0;0;0]))) then pause,end
+  if or(cumprod(i,5,typ(:))<>i) then pause,end
+end
+if or(cumprod(i,'double')<>hypermat([2,2,2],[1;254;2540;22860;22860;0;0;0])) then pause,end
+if or(cumprod(i,'*','double')<>hypermat([2,2,2],[1;254;2540;22860;22860;0;0;0])) then pause,end
+if or(cumprod(i,1,'double')<>hypermat([2,2,2],[1;254;10;90;1;0;0;0])) then pause,end
+if or(cumprod(i,2,'double')<>hypermat([2,2,2],[1;254;10;2286;1;0;0;0])) then pause,end
+if or(cumprod(i,3,'double')<>hypermat([2,2,2],[1;254;10;9;1;0;0;0])) then pause,end
+if or(cumprod(i,5,'double')<>double(i)) then pause,end
+//=======================================================================
+//Matrices of Polynomials 
+s=%s;p=[s s+1;s^2 0];
+T=list(list(),list('native'),list('double'));
+for typ=T
+  if or(cumprod(p,typ(:))<>[s,s^3+s^4;s^3,0*s]) then pause,end
+  if or(cumprod(p,'*',typ(:))<>[s,s^3+s^4;s^3,0*s]) then pause,end
+  if or(cumprod(p,1,typ(:))<>[s,1+s;s^3,0*s]) then pause,end
+  if or(cumprod(p,2,typ(:))<>[s,s+s^2;s^2,0*s]) then pause,end
+  if or(cumprod(p,3,typ(:))<>p) then pause,end
+end
+//with hypermatrices
+s=%s;p=[s s+1;s^2 0];p(1,1,2)=-1;
+T=list(list(),list('native'),list('double'));
+for typ=T
+  if or(cumprod(p,typ(:))<>hypermat([2,2,2],[s;s^3;s^3+s^4;0*s;0*s;0*s;0*s;0*s])) then pause,end
+  if or(cumprod(p,'*',typ(:))<>hypermat([2,2,2],[s;s^3;s^3+s^4;0*s;0*s;0*s;0*s;0*s])) then pause,end
+  if or(cumprod(p,1,typ(:))<>hypermat([2,2,2],[s;s^3;1+s;0*s;-1;0*s;0*s;0*s])) then pause,end
+  if or(cumprod(p,2,typ(:))<>hypermat([2,2,2],[s;s^2;s+s^2;0*s;-1;0*s;0*s;0*s])) then pause,end
+  if or(cumprod(p,3,typ(:))<>hypermat([2,2,2],[s;s^2;1+s;0*s;-s;0*s;0*s;0*s])) then pause,end
+  if or(cumprod(p,5,typ(:))<>p) then pause,end
+end
+//=======================================================================
+//Matrices of rationals
+s=%s;r=1.0 ./[s s+1;s^2 1];
+T=list(list(),list('native'),list('double'));
+for typ=T
+  if or(cumprod(r,typ(:))<>[1,1;1,1]./[s,s^3+s^4;s^3,s^3+s^4]) then pause,end
+  if or(cumprod(r,'*',typ(:))<>[1,1;1,1]./[s,s^3+s^4;s^3,s^3+s^4]) then pause,end
+  if or(cumprod(r,1,typ(:))<>[1,1;1,1]./[s,1+s;s^3,1+s]) then pause,end
+  if or(cumprod(r,2,typ(:))<>[1,1;1,1]./[s,s+s^2;s^2,s^2]) then pause,end
+  if or(cumprod(r,3,typ(:))<>r) then pause,end
+end
+//=======================================================================
+///Matrices of boolean
+b=[%t %t;%f %t];
+for typ=list(list(),list('double'));
+  if or(cumprod(b,typ(:))<>[1,0;0,0]) then pause,end
+  if or(cumprod(b,'*',typ(:))<>[1,0;0,0]) then pause,end
+  if or(cumprod(b,1,typ(:))<>[1,1;0,1]) then pause,end
+  if or(cumprod(b,2,typ(:))<>[1,1;0,0]) then pause,end
+  if or(cumprod(b,3,typ(:))<>double(b)) then pause,end
+end
+if or(cumprod(b,'native')<>[%t,%f;%f,%f]) then pause,end
+if or(cumprod(b,'*','native')<>[%t,%f;%f,%f]) then pause,end
+if or(cumprod(b,1,'native')<>[%t,%t;%f,%t]) then pause,end
+if or(cumprod(b,2,'native')<>[%t,%t;%f,%f]) then pause,end
+if or(cumprod(b,3,'native')<>b) then pause,end
+//with hypermatrices
+b=[%t %t;%f %t];b(1,1,2)=%f;
+for typ=list(list(),list('double'));
+  if or(cumprod(b,typ(:))<>hypermat([2,2,2],[1;0;0;0;0;0;0;0])) then pause,end
+  if or(cumprod(b,'*',typ(:))<>hypermat([2,2,2],[1;0;0;0;0;0;0;0])) then pause,end
+  if or(cumprod(b,1,typ(:))<>hypermat([2,2,2],[1;0;1;1;0;0;0;0])) then pause,end
+  if or(cumprod(b,2,typ(:))<>hypermat([2,2,2],[1;0;1;0;0;0;0;0])) then pause,end
+  if or(cumprod(b,3,typ(:))<>hypermat([2,2,2],[1;0;1;1;0;0;0;0])) then pause,end
+  if or(cumprod(b,5,typ(:))<>double(b)) then pause,end
+end
+if or(cumprod(b,'native')<>hypermat([2,2,2],[%t;%f;%f;%f;%f;%f;%f;%f])) then pause,end
+if or(cumprod(b,'*','native')<>hypermat([2,2,2],[%t;%f;%f;%f;%f;%f;%f;%f])) then pause,end
+if or(cumprod(b,1,'native')<>hypermat([2,2,2],[%t;%f;%t;%t;%f;%f;%f;%f])) then pause,end
+if or(cumprod(b,2,'native')<>hypermat([2,2,2],[%t;%f;%t;%f;%f;%f;%f;%f])) then pause,end
+if or(cumprod(b,3,'native')<>hypermat([2,2,2],[%t;%f;%t;%t;%f;%f;%f;%f])) then pause,end
+if or(cumprod(b,5,'native')<>b) then pause,end
+//=======================================================================
+//sparse matrices of floats
+s=sparse([1 10 0;-1 0 9]);
+T=list(list(),list('native'),list('double'));
+for typ=T
+  if or(cumprod(s,typ(:))<>sparse([1,1;1,2;2,1],[1;-10;-1],[2,3])) then pause,end
+  if or(cumprod(s,'*',typ(:))<>sparse([1,1;1,2;2,1],[1;-10;-1],[2,3])) then pause,end
+  if or(cumprod(s,1,typ(:))<>sparse([1,1;1,2;2,1],[1;10;-1],[2,3])) then pause,end
+  if or(cumprod(s,2,typ(:))<>sparse([1,1;1,2;2,1],[1;10;-1],[2,3])) then pause,end
+  if or(cumprod(s,3,typ(:))<>s) then pause,end
+end
+//=======================================================================
+//sparse  matrices of boolean
+bs=sparse([%t %t %f;%t %t %t]);
+for typ=list(list(),list('double'));
+  if or(cumprod(bs,typ(:))<>sparse([1,1;1,2;2,1;2,2],[1;1;1;1],[2,3])) then pause,end
+  if or(cumprod(bs,'*',typ(:))<>sparse([1,1;1,2;2,1;2,2],[1;1;1;1],[2,3])) then pause,end
+  if or(cumprod(bs,1,typ(:))<>sparse([1,1;1,2;2,1;2,2],[1;1;1;1],[2,3])) then pause,end
+  if or(cumprod(bs,2,typ(:))<>sparse([1,1;1,2;2,1;2,2;2,3],[1;1;1;1;1],[2,3])) then pause,end
+  if or(cumprod(bs,3,typ(:))<>bool2s(bs)) then pause,end
+end
+if or(cumprod(bs,'native')<>sparse([1,1;1,2;2,1;2,2],[%t;%t;%t;%t],[2,3])) then pause,end
+if or(cumprod(bs,'*','native')<>sparse([1,1;1,2;2,1;2,2],[%t;%t;%t;%t],[2,3])) then pause,end
+if or(cumprod(bs,1,'native')<>sparse([1,1;1,2;2,1;2,2],[%t;%t;%t;%t],[2,3])) then pause,end
+if or(cumprod(bs,2,'native')<>sparse([1,1;1,2;2,1;2,2;2,3],[%t;%t;%t;%t;%t],[2,3])) then pause,end
+if or(cumprod(bs,3,'native')<>bs) then pause,end
+exec SCI/modules/elementary_functions/tests/unit_tests/prod.tst
+// =============================================================================
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2010 - INRIA - Serge Steer
+//
+//  This file is distributed under the same license as the Scilab package.
+// =============================================================================
+// <-- JVM NOT MANDATORY 
+// prod 
+//empty matrices
+T=list(list(),list('native'),list('double'));
+for typ=T
+  if prod([],typ(:))<>1 then pause,end
+  if prod([],'*',typ(:))<>1 then pause,end
+  if prod([],1,typ(:))<>[] then pause,end
+  if prod([],2,typ(:))<>[] then pause,end
+  if prod([],3,typ(:))<>[] then pause,end
+end
+//=======================================================================
+//float matrices
+d=[1 10;254 9];
+T=list(list(),list('native'),list('double'));
+for typ=T
+  if prod(d,typ(:))<>22860 then pause,end
+  if prod(d,'*',typ(:))<>22860 then pause,end
+  if or(prod(d,1,typ(:))<>[254 90]) then pause,end
+  if or(prod(d,2,typ(:))<>[10;2286]) then pause,end
+  if or(prod(d,3,typ(:))<>d) then pause,end
+end
+//hypermatrices of floats
+d=[1 10;254 9];d(:,:,2)=1;
+T=list(list(),list('native'),list('double'));
+for typ=T
+  if prod(d,typ(:))<>22860 then pause,end
+  if prod(d,'*',typ(:))<>22860 then pause,end
+  if or(prod(d,1,typ(:))<>hypermat([1,2,2],[254;90;1;1])) then pause,end
+  if or(prod(d,2,typ(:))<>hypermat([2,1,2],[10;2286;1;1])) then pause,end
+  if or(prod(d,3,typ(:))<>[1,10;254,9]) then pause,end
+  if or(prod(d,5,typ(:))<>d) then pause,end
+end
+//=======================================================================
+//matrices of short integers
+i=uint8([1 10;254 9]);
+T=list(list(),list('native'));
+for typ=T
+  if prod(i,typ(:))<>uint8(76) then pause,end
+  if prod(i,'*',typ(:))<>uint8(76) then pause,end
+  if or(prod(i,1,typ(:))<>uint8([254 90])) then pause,end
+  if or(prod(i,2,typ(:))<>uint8([10;238])) then pause,end
+  if or(prod(i,3,typ(:))<>i) then pause,end
+end
+if prod(i,'double')<>22860 then pause,end
+if prod(i,'*','double')<>22860 then pause,end
+if or(prod(i,1,'double')<>[254 90]) then pause,end
+if or(prod(i,2,'double')<>[10;2286]) then pause,end
+if or(prod(i,3,'double')<>double(i)) then pause,end
+//with hypermatrices
+i=uint8([1 10;254 9]);i(:,:,2)=uint8(1);
+for typ=list(list(),list('native'));
+  if prod(i,typ(:))<>uint8(76) then pause,end
+  if prod(i,'*',typ(:))<>uint8(76) then pause,end
+  if or(prod(i,1,typ(:))<>hypermat([1,2,2],uint8([254;90;1;1]))) then pause,end
+  if or(prod(i,2,typ(:))<>hypermat([2,1,2],uint8([10;238;1;1]))) then pause,end
+  if or(prod(i,3,typ(:))<>([1,10;254,9])) then pause,end
+  if or(prod(i,5,typ(:))<>i) then pause,end
+end
+if prod(i,'double')<>22860 then pause,end
+if prod(i,'*','double')<>22860 then pause,end
+if or(prod(i,1,'double')<>hypermat([1,2,2],[254;90;1;1])) then pause,end
+if or(prod(i,2,'double')<>hypermat([2,1,2],[10;2286;1;1])) then pause,end
+if or(prod(i,3,'double')<>[1,10;254,9]) then pause,end
+if or(prod(i,5,'double')<>double(i)) then pause,end
+//Polynomials
+s=%s;p=[s s+1;s^2 1];
+T=list(list(),list('native'),list('double'));
+for typ=T
+  if prod(p,typ(:))<>s^3+s^4 then pause,end
+  if prod(p,'*',typ(:))<>s^3+s^4 then pause,end
+  if or(prod(p,1,typ(:))<>[s^3,1+s]) then pause,end
+  if or(prod(p,2,typ(:))<>[s+s^2;s^2]) then pause,end
+  if or(prod(p,3,typ(:))<>p) then pause,end
+end
+//with hypermatrices
+s=%s;p=[s s+1;s^2 1];p(:,:,2)=[1 s;s+1 2];
+T=list(list(),list('native'),list('double'));
+for typ=T
+  if prod(p,typ(:))<>2*s^4+4*s^5+2*s^6 then pause,end
+  if prod(p,'*',typ(:))<>2*s^4+4*s^5+2*s^6 then pause,end
+  if or(prod(p,1,typ(:))<>hypermat([1,2,2],[s^3;1+s;1+s;2*s])) then pause,end
+  if or(prod(p,2,typ(:))<>hypermat([2,1,2],[s+s^2;s^2;s;2+2*s])) then pause,end
+  if or(prod(p,3,typ(:))<>[s,s+s^2;s^2+s^3,2]) then pause,end
+  if or(prod(p,5,typ(:))<>p) then pause,end
+end
+//=======================================================================
+//Matrices of rationals
+s=%s;r=1.0 ./[s s+1;s^2 1];
+T=list(list(),list('native'),list('double'));
+for typ=T
+  if prod(r,typ(:))<>1.0/(s^3+s^4) then pause,end
+  if prod(r,'*',typ(:))<>1.0/(s^3+s^4) then pause,end
+  if or(prod(r,1,typ(:))<>[1,1]./[s^3,1+s]) then pause,end
+  if or(prod(r,2,typ(:))<>[1;1]./[s+s^2;s^2]) then pause,end
+  if or(prod(r,3,typ(:))<>r) then pause,end
+end
+//=======================================================================
+//Matrices of booleans
+b=[%t %t; %f %t];
+for typ=list(list(),list('double'));
+  if prod(b,typ(:))<>0 then pause,end
+  if prod(b,'*',typ(:))<>0 then pause,end
+  if or(prod(b,1,typ(:))<>[0 1]) then pause,end
+  if or(prod(b,2,typ(:))<>[1;0]) then pause,end
+  if or(prod(b,3,typ(:))<>double(b)) then pause,end
+end
+if prod(b,'native')<>%f then pause,end
+if prod(b,'*','native')<>%f then pause,end
+if or(prod(b,1,'native')<>[%f %t]) then pause,end
+if or(prod(b,2,'native')<>[%t;%f]) then pause,end
+if or(prod(b,3,'native')<>b) then pause,end
+//with hypermatrices 
+b=[%t %t;%f %t];b(1,1,2)=%t;
+for typ=list(list(),list('double'));
+  if prod(b,typ(:))<>0 then pause,end
+  if prod(b,'*',typ(:))<>0 then pause,end
+  if or(prod(b,1,typ(:))<>hypermat([1,2,2],[0;1;0;0])) then pause,end
+  if or(prod(b,2,typ(:))<>hypermat([2,1,2],[1;0;0;0])) then pause,end
+  if or(prod(b,3,typ(:))<>[1,0;0,0]) then pause,end
+  if or(prod(b,5,typ(:))<>double(b)) then pause,end
+end
+if prod(b,'native')<>%f then pause,end
+if prod(b,'*','native')<>%f then pause,end
+if or(prod(b,1,'native')<>hypermat([1,2,2],[%f;%t;%f;%f])) then pause,end
+if or(prod(b,2,'native')<>hypermat([2,1,2],[%t;%f;%f;%f])) then pause,end
+if or(prod(b,3,'native')<>[%t,%f;%f,%f]) then pause,end
+if or(prod(b,5,'native')<>b) then pause,end
+//=======================================================================
+//sparse matrices of floats
+s=sparse([1 10 2;-1 254 9]);
+T=list(list(),list('native'),list('double'));
+for typ=T
+  if prod(s,typ(:))<>-45720 then pause,end
+  if prod(s,'*',typ(:))<>-45720 then pause,end
+  if or(prod(s,1,typ(:))<>sparse([-1 2540 18])) then pause,end
+  if or(prod(s,2,typ(:))<>sparse([20;-2286])) then pause,end
+  if or(prod(s,3,typ(:))<>s) then pause,end
+end
+//=======================================================================
+//sparse  matrices of boolean
+bs=sparse([%t %t %f;%t %t %t]);
+for typ=list(list(),list('double'));
+  if prod(bs,typ(:))<>0 then pause,end
+  if prod(bs,'*',typ(:))<>0 then pause,end
+  if or(prod(bs,1,typ(:))<>sparse([1,1,0])) then pause,end
+  if or(prod(bs,2,typ(:))<>sparse([0;1])) then pause,end
+  if or(prod(bs,3,typ(:))<>bool2s(bs)) then pause,end
+end
+if prod(bs,'native')<>%f then pause,end
+if prod(bs,'*','native')<>%f then pause,end
+if or(prod(bs,1,'native')<>sparse([%t,%t,%f])) then pause,end
+if or(prod(bs,2,'native')<>sparse([%f;%t])) then pause,end
+if or(prod(bs,3,'native')<>bs) then pause,end
+exec SCI/modules/elementary_functions/tests/unit_tests/cumprod.tst
+// =============================================================================
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2010 - INRIA - Serge Steer
+//
+//  This file is distributed under the same license as the Scilab package.
+// =============================================================================
+// <-- JVM NOT MANDATORY 
+//cumprod
+//Empty matrices
+T=list(list(),list('native'),list('double'));
+for typ=T
+  if cumprod([],typ(:))<>[] then pause,end
+  if cumprod([],'*',typ(:))<>[] then pause,end
+  if cumprod([],1,typ(:))<>[] then pause,end
+  if cumprod([],2,typ(:))<>[] then pause,end
+  if cumprod([],3,typ(:))<>[] then pause,end
+end
+//=======================================================================
+//float matrices
+d=[1 10;254 9];
+T=list(list(),list('native'),list('double'));
+for typ=T
+  if or(cumprod(d,typ(:))<>[1,2540;254,22860]) then pause,end
+  if or(cumprod(d,'*',typ(:))<>[1,2540;254,22860]) then pause,end
+  if or(cumprod(d,1,typ(:))<>[1,10;254,90]) then pause,end
+  if or(cumprod(d,2,typ(:))<>[1,10;254,2286]) then pause,end
+  if or(cumprod(d,3,typ(:))<>d) then pause,end
+end
+//hypermatrices of floats
+d=[1 10;254 9];d(1,1,2)=1;
+T=list(list(),list('native'),list('double'));
+for typ=T
+  if or(cumprod(d,typ(:))<>hypermat([2,2,2],[1;254;2540;22860;22860;0;0;0])) then pause,end
+  if or(cumprod(d,'*',typ(:))<>hypermat([2,2,2],[1;254;2540;22860;22860;0;0;0])) then pause,end
+  if or(cumprod(d,1,typ(:))<>hypermat([2,2,2],[1;254;10;90;1;0;0;0])) then pause,end
+  if or(cumprod(d,2,typ(:))<>hypermat([2,2,2],[1;254;10;2286;1;0;0;0])) then pause,end
+  if or(cumprod(d,3,typ(:))<>hypermat([2,2,2],[1;254;10;9;1;0;0;0])) then pause,end
+  if or(cumprod(d,5,typ(:))<>d) then pause,end
+end
+//=======================================================================
+//Integers
+i=uint8([1 10;254 9]);
+for typ=list(list(),list('native'));
+  if or(cumprod(i,typ(:))<>uint8([1,236;254,76])) then pause,end
+  if or(cumprod(i,'*',typ(:))<>uint8([1,236;254,76])) then pause,end
+  if or(cumprod(i,1,typ(:))<>uint8([1,10;254,90])) then pause,end
+  if or(cumprod(i,2,typ(:))<>uint8([1,10;254,238])) then pause,end
+  if or(cumprod(i,3,typ(:))<>i) then pause,end
+end
+if or(cumprod(i,'double')<>[1,2540;254,22860]) then pause,end
+if or(cumprod(i,'*','double')<>[1,2540;254,22860]) then pause,end
+if or(cumprod(i,1,'double')<>[1,10;254,90]) then pause,end
+if or(cumprod(i,2,'double')<>[1,10;254,2286]) then pause,end
+if or(cumprod(i,3,'double')<>double(i)) then pause,end
+//with hypermatrices
+i=uint8([1 10;254 9]);i(1,1,2)=uint8(1);
+for typ=list(list(),list('native'));
+  if or(cumprod(i,typ(:))<>hypermat([2,2,2],uint8([1;254;236;76;76;0;0;0]))) then pause,end
+  if or(cumprod(i,'*',typ(:))<>hypermat([2,2,2],uint8([1;254;236;76;76;0;0;0]))) then pause,end
+  if or(cumprod(i,1,typ(:))<>hypermat([2,2,2],uint8([1;254;10;90;1;0;0;0]))) then pause,end
+  if or(cumprod(i,2,typ(:))<>hypermat([2,2,2],uint8([1;254;10;238;1;0;0;0]))) then pause,end
+  if or(cumprod(i,3,typ(:))<>hypermat([2,2,2],uint8([1;254;10;9;1;0;0;0]))) then pause,end
+  if or(cumprod(i,5,typ(:))<>i) then pause,end
+end
+if or(cumprod(i,'double')<>hypermat([2,2,2],[1;254;2540;22860;22860;0;0;0])) then pause,end
+if or(cumprod(i,'*','double')<>hypermat([2,2,2],[1;254;2540;22860;22860;0;0;0])) then pause,end
+if or(cumprod(i,1,'double')<>hypermat([2,2,2],[1;254;10;90;1;0;0;0])) then pause,end
+if or(cumprod(i,2,'double')<>hypermat([2,2,2],[1;254;10;2286;1;0;0;0])) then pause,end
+if or(cumprod(i,3,'double')<>hypermat([2,2,2],[1;254;10;9;1;0;0;0])) then pause,end
+if or(cumprod(i,5,'double')<>double(i)) then pause,end
+//=======================================================================
+//Matrices of Polynomials 
+s=%s;p=[s s+1;s^2 0];
+T=list(list(),list('native'),list('double'));
+for typ=T
+  if or(cumprod(p,typ(:))<>[s,s^3+s^4;s^3,0*s]) then pause,end
+  if or(cumprod(p,'*',typ(:))<>[s,s^3+s^4;s^3,0*s]) then pause,end
+  if or(cumprod(p,1,typ(:))<>[s,1+s;s^3,0*s]) then pause,end
+  if or(cumprod(p,2,typ(:))<>[s,s+s^2;s^2,0*s]) then pause,end
+  if or(cumprod(p,3,typ(:))<>p) then pause,end
+end
+//with hypermatrices
+s=%s;p=[s s+1;s^2 0];p(1,1,2)=-1;
+T=list(list(),list('native'),list('double'));
+for typ=T
+  if or(cumprod(p,typ(:))<>hypermat([2,2,2],[s;s^3;s^3+s^4;0*s;0*s;0*s;0*s;0*s])) then pause,end
+  if or(cumprod(p,'*',typ(:))<>hypermat([2,2,2],[s;s^3;s^3+s^4;0*s;0*s;0*s;0*s;0*s])) then pause,end
+  if or(cumprod(p,1,typ(:))<>hypermat([2,2,2],[s;s^3;1+s;0*s;-1;0*s;0*s;0*s])) then pause,end
+  if or(cumprod(p,2,typ(:))<>hypermat([2,2,2],[s;s^2;s+s^2;0*s;-1;0*s;0*s;0*s])) then pause,end
+  if or(cumprod(p,3,typ(:))<>hypermat([2,2,2],[s;s^2;1+s;0*s;-s;0*s;0*s;0*s])) then pause,end
+  if or(cumprod(p,5,typ(:))<>p) then pause,end
+end
+//=======================================================================
+//Matrices of rationals
+s=%s;r=1.0 ./[s s+1;s^2 1];
+T=list(list(),list('native'),list('double'));
+for typ=T
+  if or(cumprod(r,typ(:))<>[1,1;1,1]./[s,s^3+s^4;s^3,s^3+s^4]) then pause,end
+  if or(cumprod(r,'*',typ(:))<>[1,1;1,1]./[s,s^3+s^4;s^3,s^3+s^4]) then pause,end
+  if or(cumprod(r,1,typ(:))<>[1,1;1,1]./[s,1+s;s^3,1+s]) then pause,end
+  if or(cumprod(r,2,typ(:))<>[1,1;1,1]./[s,s+s^2;s^2,s^2]) then pause,end
+  if or(cumprod(r,3,typ(:))<>r) then pause,end
+end
+//=======================================================================
+///Matrices of boolean
+b=[%t %t;%f %t];
+for typ=list(list(),list('double'));
+  if or(cumprod(b,typ(:))<>[1,0;0,0]) then pause,end
+  if or(cumprod(b,'*',typ(:))<>[1,0;0,0]) then pause,end
+  if or(cumprod(b,1,typ(:))<>[1,1;0,1]) then pause,end
+  if or(cumprod(b,2,typ(:))<>[1,1;0,0]) then pause,end
+  if or(cumprod(b,3,typ(:))<>double(b)) then pause,end
+end
+if or(cumprod(b,'native')<>[%t,%f;%f,%f]) then pause,end
+if or(cumprod(b,'*','native')<>[%t,%f;%f,%f]) then pause,end
+if or(cumprod(b,1,'native')<>[%t,%t;%f,%t]) then pause,end
+if or(cumprod(b,2,'native')<>[%t,%t;%f,%f]) then pause,end
+if or(cumprod(b,3,'native')<>b) then pause,end
+//with hypermatrices
+b=[%t %t;%f %t];b(1,1,2)=%f;
+for typ=list(list(),list('double'));
+  if or(cumprod(b,typ(:))<>hypermat([2,2,2],[1;0;0;0;0;0;0;0])) then pause,end
+  if or(cumprod(b,'*',typ(:))<>hypermat([2,2,2],[1;0;0;0;0;0;0;0])) then pause,end
+  if or(cumprod(b,1,typ(:))<>hypermat([2,2,2],[1;0;1;1;0;0;0;0])) then pause,end
+  if or(cumprod(b,2,typ(:))<>hypermat([2,2,2],[1;0;1;0;0;0;0;0])) then pause,end
+  if or(cumprod(b,3,typ(:))<>hypermat([2,2,2],[1;0;1;1;0;0;0;0])) then pause,end
+  if or(cumprod(b,5,typ(:))<>double(b)) then pause,end
+end
+if or(cumprod(b,'native')<>hypermat([2,2,2],[%t;%f;%f;%f;%f;%f;%f;%f])) then pause,end
+if or(cumprod(b,'*','native')<>hypermat([2,2,2],[%t;%f;%f;%f;%f;%f;%f;%f])) then pause,end
+if or(cumprod(b,1,'native')<>hypermat([2,2,2],[%t;%f;%t;%t;%f;%f;%f;%f])) then pause,end
+if or(cumprod(b,2,'native')<>hypermat([2,2,2],[%t;%f;%t;%f;%f;%f;%f;%f])) then pause,end
+if or(cumprod(b,3,'native')<>hypermat([2,2,2],[%t;%f;%t;%t;%f;%f;%f;%f])) then pause,end
+if or(cumprod(b,5,'native')<>b) then pause,end
+//=======================================================================
+//sparse matrices of floats
+s=sparse([1 10 0;-1 0 9]);
+T=list(list(),list('native'),list('double'));
+for typ=T
+  if or(cumprod(s,typ(:))<>sparse([1,1;1,2;2,1],[1;-10;-1],[2,3])) then pause,end
+  if or(cumprod(s,'*',typ(:))<>sparse([1,1;1,2;2,1],[1;-10;-1],[2,3])) then pause,end
+  if or(cumprod(s,1,typ(:))<>sparse([1,1;1,2;2,1],[1;10;-1],[2,3])) then pause,end
+  if or(cumprod(s,2,typ(:))<>sparse([1,1;1,2;2,1],[1;10;-1],[2,3])) then pause,end
+  if or(cumprod(s,3,typ(:))<>s) then pause,end
+end
+//=======================================================================
+//sparse  matrices of boolean
+bs=sparse([%t %t %f;%t %t %t]);
+for typ=list(list(),list('double'));
+  if or(cumprod(bs,typ(:))<>sparse([1,1;1,2;2,1;2,2],[1;1;1;1],[2,3])) then pause,end
+  if or(cumprod(bs,'*',typ(:))<>sparse([1,1;1,2;2,1;2,2],[1;1;1;1],[2,3])) then pause,end
+  if or(cumprod(bs,1,typ(:))<>sparse([1,1;1,2;2,1;2,2],[1;1;1;1],[2,3])) then pause,end
+  if or(cumprod(bs,2,typ(:))<>sparse([1,1;1,2;2,1;2,2;2,3],[1;1;1;1;1],[2,3])) then pause,end
+  if or(cumprod(bs,3,typ(:))<>bool2s(bs)) then pause,end
+end
+if or(cumprod(bs,'native')<>sparse([1,1;1,2;2,1;2,2],[%t;%t;%t;%t],[2,3])) then pause,end
+if or(cumprod(bs,'*','native')<>sparse([1,1;1,2;2,1;2,2],[%t;%t;%t;%t],[2,3])) then pause,end
+if or(cumprod(bs,1,'native')<>sparse([1,1;1,2;2,1;2,2],[%t;%t;%t;%t],[2,3])) then pause,end
+if or(cumprod(bs,2,'native')<>sparse([1,1;1,2;2,1;2,2;2,3],[%t;%t;%t;%t;%t],[2,3])) then pause,end
+if or(cumprod(bs,3,'native')<>bs) then pause,end
diff --git a/scilab/modules/integer/tests/nonreg_tests/bug_3842.tst b/scilab/modules/integer/tests/nonreg_tests/bug_3842.tst
new file mode 100644 (file)
index 0000000..7151d87
--- /dev/null
@@ -0,0 +1,18 @@
+// =============================================================================
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2010 - INRIA - Serge Steer
+//
+//  This file is distributed under the same license as the Scilab package.
+// =============================================================================
+
+// <-- Non-regression test for bug 3842 -->
+//
+// <-- Bugzilla URL -->
+// http://bugzilla.scilab.org/show_bug.cgi?id=3842
+//
+// <-- Short Description -->
+// sum applyed to integer arrys can only procuce results computed using native operations.
+exec SCI/modules/elementary_functions/tests/unit_tests/prod.tst
+exec SCI/modules/elementary_functions/tests/unit_tests/cumprod.tst
+exec SCI/modules/elementary_functions/tests/unit_tests/prod.tst
+exec SCI/modules/elementary_functions/tests/unit_tests/cumprod.tst
index bd238cc..1e3832b 100644 (file)
@@ -7,15 +7,59 @@
 // are also available at    
 // http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
 
-function x=%hm_cumprod(m,d)
+function x=%hm_cumprod(m,d,typ)
   if argn(2)==1 then
-    x=hypermat(m.dims,cumprod(m.entries))
-    return
+    typ=list()
+    d='*'
+  elseif argn(2)==2 then 
+    if argn(2)==2& or(d==['native','double']) then
+      typ=list(d)
+      d='*'
+    else
+      typ=list()
+    end
+  else
+    typ=list(typ)
+  end
+  if size(d,'*')<>1 then 
+    if type(d)==10 then
+      error(msprintf(_("%s: Wrong size for input argument #%d: A string expected.\n"),"cumprod",2))
+    else
+      error(msprintf(_("%s: Wrong size for input argument #%d: A scalar expected.\n"),"cumprod",2))
+    end
+  end
+  
+  if type(d)==10 then
+    d=find(d==['m','*','r','c'])
+    if d==[] then
+      error(msprintf(_("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"),..
+                     "cumprod",2,"""*"",""r"",""c"",""m"",1:"+string(ndims(a))))
+    end
+    d=d-2
   end
   dims=m.dims;
-  if d=='m' then
+  
+  if d==-1 then //'m'
     d=find(dims>1,1)
-    if d==[] then x=cumprod(m.entries),return,end
+    if d==[] then d=0,end
+  end
+  if d<0 then
+    error(msprintf(_("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"),..
+                     "cumprod",2,"""*"",""r"",""c"",""m"",1:"+string(ndims(a))))
+  end
+  if d==0 then// '*'
+     x=hypermat(m.dims,cumprod(m.entries,typ(:)))
+     return
+  end
+  if d>size(dims,'*') then
+    //requested summation direction exceeds array dims, return the array, converted
+    //to double if necessary.
+    tm=type(m.entries)
+    if (tm==8&typ==list('double'))|(tm==4&typ<>list('native')) then 
+        m.entries=double(m.entries),
+    end    
+    x=m
+    return
   end
 
   if type(dims==8) then flag=1; dims=double(dims); else flag=0;end
@@ -29,7 +73,7 @@ function x=%hm_cumprod(m,d)
 
   ind=(0:p2:prod(dims)-1)';
   I=ones(ind).*.I+ind.*.ones(I)
-  x=cumprod(matrix(m.entries(I),-1,dims(d)),2)
+  x=cumprod(matrix(m.entries(I),-1,dims(d)),2,typ(:))
   x(I)=matrix(x,-1,1)
   if flag==1 then dims=int32(dims);end
   x=hypermat(dims,x)
index 00b5343..6d32c5b 100644 (file)
@@ -7,16 +7,64 @@
 // are also available at    
 // http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
 
-function x=%hm_cumsum(m,d)
+function x=%hm_cumsum(m,d,typ)
   if argn(2)==1 then
-    x=hypermat(m.dims,cumsum(m.entries))
-    return
+    typ=list()
+    d='*'
+  elseif argn(2)==2 then 
+    if argn(2)==2& or(d==['native','double']) then
+      typ=list(d)
+      d='*'
+    else
+      typ=list()
+    end
+  else
+    typ=list(typ)
+  end
+  if size(d,'*')<>1 then 
+    if type(d)==10 then
+      error(msprintf(_("%s: Wrong size for input argument #%d: A string expected.\n"),"cumsum",2))
+    else
+      error(msprintf(_("%s: Wrong size for input argument #%d: A scalar expected.\n"),"cumsum",2))
+    end
+  end
+  
+  if type(d)==10 then
+    d=find(d==['m','*','r','c'])
+    if d==[] then
+      error(msprintf(_("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"),..
+                     "cumsum",2,"""*"",""r"",""c"",""m"",1:"+string(ndims(a))))
+    end
+    d=d-2
   end
   dims=m.dims;
-  if d=='m' then
+    
+  if d==-1 then //'m'
     d=find(dims>1,1)
-    if d==[] then x=cumsum(m.entries),return,end
+    if d==[] then d=0,end
+  end
+  
+  if d<0 then
+    error(msprintf(_("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"),..
+                     "cumsum",2,"""*"",""r"",""c"",""m"",1:"+string(ndims(a))))
   end
+  
+  if d==0 then// '*'
+     x=hypermat(m.dims,cumsum(m.entries,typ(:)))
+     return
+  end
+  
+  if d>size(dims,'*') then
+    //requested summation direction exceeds array dims, return the array, converted
+    //to double if necessary.
+    tm=type(m.entries)
+    if (tm==8&typ==list('double'))|(tm==4&typ<>list('native')) then 
+        m.entries=double(m.entries),
+    end    
+    x=m
+    return
+  end
+
 
   if type(dims==8) then flag=1; dims=double(dims); else flag=0;end
   N=size(dims,'*');
@@ -29,7 +77,7 @@ function x=%hm_cumsum(m,d)
 
   ind=(0:p2:prod(dims)-1)';
   I=ones(ind).*.I+ind.*.ones(I)
-  x=cumsum(matrix(m.entries(I),-1,dims(d)),2)
+  x=cumsum(matrix(m.entries(I),-1,dims(d)),2,typ(:))
   x(I)=matrix(x,-1,1)
   if flag==1 then dims=int32(dims);end
   x=hypermat(dims,x)
index 2575992..1ecefed 100644 (file)
@@ -7,16 +7,63 @@
 // are also available at    
 // http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
 
-function x=%hm_prod(m,d)
+function x=%hm_prod(m,d,typ)
   if argn(2)==1 then
-    x=prod(m.entries)
-    return
+    typ=list()
+    d='*'
+  elseif argn(2)==2 then 
+    if argn(2)==2& or(d==['native','double']) then
+      typ=list(d)
+      d='*'
+    else
+      typ=list()
+    end
+  else
+    typ=list(typ)
+  end
+  if size(d,'*')<>1 then 
+    if type(d)==10 then
+      error(msprintf(_("%s: Wrong size for input argument #%d: A string expected.\n"),"prod",2))
+    else
+      error(msprintf(_("%s: Wrong size for input argument #%d: A scalar expected.\n"),"prod",2))
+    end
+  end
+  if type(d)==10 then
+    d=find(d==['m','*','r','c'])
+    if d==[] then
+      error(msprintf(_("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"),..
+                     "prod",2,"""*"",""r"",""c"",""m"",1:"+string(ndims(a))))
+    end
+    d=d-2
   end
   dims=m.dims;
-  if d=='m' then
+    
+  if d==-1 then 
+    //sum(x,'m'), determine the product direction
     d=find(dims>1,1)
-    if d==[] then x=prod(m.entries),return,end
+    if d==[] then d=0,end
+  end
+  if d<0 then
+    error(msprintf(_("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"),..
+                     "prod",2,"""*"",""r"",""c"",""m"",1:"+string(ndims(a))))
   end
+  if d==0 then 
+    //prod of all elements
+     x=prod(m.entries,typ(:))
+     return
+  end
+  
+  if d>size(dims,'*') then
+    //requested  product direction exceeds array dims, return the array, converted
+    //to double if necessary.
+    tm=type(m.entries)
+    if (tm==8&typ==list('double'))|(tm==4&typ<>list('native')) then 
+        m.entries=double(m.entries),
+    end    
+    x=m
+    return
+  end
+
 
   if type(dims==8) then flag=1; dims=double(dims); else flag=0;end
   N=size(dims,'*');
@@ -29,7 +76,7 @@ function x=%hm_prod(m,d)
   ind=(0:p2:prod(dims)-1);
   I=ones(ind).*.I+ind.*.ones(I)
 
-  x=prod(matrix(m.entries(I),dims(d),-1),1)
+  x=prod(matrix(m.entries(I),dims(d),-1),1,typ(:))
   dims(d)=1
   while  dims($)==1 then dims($)=[],end
   if d==N then
index ee4b378..7b73dd6 100644 (file)
@@ -7,16 +7,65 @@
 // are also available at    
 // http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
 
-function x=%hm_sum(m,d)
+function x=%hm_sum(m,d,typ)
   if argn(2)==1 then
-    x=sum(m.entries)
-    return
+    typ=list()
+    d='*'
+  elseif argn(2)==2 then 
+    if argn(2)==2& or(d==['native','double']) then
+      typ=list(d)
+      d='*'
+    else
+      typ=list()
+    end
+  else
+    typ=list(typ)
+  end
+  if size(d,'*')<>1 then 
+    if type(d)==10 then
+      error(msprintf(_("%s: Wrong size for input argument #%d: A string expected.\n"),"sum",2))
+    else
+      error(msprintf(_("%s: Wrong size for input argument #%d: A scalar expected.\n"),"sum",2))
+    end
+  end
+  if type(d)==10 then
+    d=find(d==['m','*','r','c'])
+    if d==[] then
+      error(msprintf(_("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"),..
+                     "sum",2,"""*"",""r"",""c"",""m"",1:"+string(ndims(a))))
+    end
+    d=d-2
   end
   dims=m.dims;
-  if d=='m' then
+    
+  if d==-1 then 
+    //sum(x,'m'), determine the summation direction
     d=find(dims>1,1)
-    if d==[] then x=sum(m.entries),return,end
+    if d==[] then d=0,end
+  end
+  if d<0 then
+    error(msprintf(_("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"),..
+                     "sum",2,"""*"",""r"",""c"",""m"",1:"+string(ndims(a))))
+  end
+  
+  if d==0 then 
+    //sum of all elements
+     x=sum(m.entries,typ(:))
+     return
   end
+  if d>size(dims,'*') then
+    //requested summation direction exceeds array dims, return the array, converted
+    //to double if necessary.
+    tm=type(m.entries)
+    if (tm==8&typ==list('double'))|(tm==4&typ<>list('native')) then 
+        m.entries=double(m.entries),
+    end    
+    x=m
+    return
+  end
+
+
   if type(dims==8) then flag=1; dims=double(dims); else flag=0;end
   N=size(dims,'*');
   p1=prod(dims(1:d-1));// step to build one vector on which sum is applied
@@ -27,8 +76,7 @@ function x=%hm_sum(m,d)
 
   ind=(0:p2:prod(dims)-1);
   I=ones(ind).*.I+ind.*.ones(I)
-
-  x=sum(matrix(m.entries(I),dims(d),-1),1)
+  x=sum(matrix(m.entries(I),dims(d),-1),1,typ(:))
 
   dims(d)=1
   while  dims($)==1 then dims($)=[],end
diff --git a/scilab/modules/overloading/macros/%p_cumprod.sci b/scilab/modules/overloading/macros/%p_cumprod.sci
new file mode 100644 (file)
index 0000000..a2e91f8
--- /dev/null
@@ -0,0 +1,68 @@
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2010 -  INRIA - Serge Steer 
+// 
+// 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    
+// http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
+
+function a=%p_cumprod(a,d,typ)
+  if argn(2)==1 then
+    typ=list()
+    d='*'
+  elseif argn(2)==2 then 
+    if argn(2)==2& or(d==['native','double']) then
+      typ=list(d)
+      d='*'
+    else
+      typ=list()
+    end
+  else
+    typ=list(typ)
+  end
+  if size(d,'*')<>1 then 
+    if type(d)==10 then
+      error(msprintf(_("%s: Wrong size for input argument #%d: A string expected.\n"),"cumprod",2))
+    else
+      error(msprintf(_("%s: Wrong size for input argument #%d: A scalar expected.\n"),"cumprod",2))
+    end
+  end
+  if type(d)==10 then
+    d=find(d==['m','*','r','c'])
+    if d==[] then
+      error(msprintf(_("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"),..
+                     "cumprod",2,"""*"",""r"",""c"",""m"",1:"+string(ndims(a))))
+    end
+    d=d-2
+  end
+  dims=size(a);
+    
+  if d==-1 then //'m'
+    d=find(dims>1,1)
+    if d==[] then d=0,end
+  end
+  if d<0 then
+    error(msprintf(_("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"),..
+                     "cumprod",2,"""*"",""r"",""c"",""m"",1:"+string(ndims(a))))
+  end
+
+  
+  select d
+  case 0 then
+    for k=2:prod(dims)
+      a(k)=a(k-1)*a(k)
+    end
+  case 1 then
+    for k=1:dims(2)
+      a(:,k)=cumprod(a(:,k),typ(:))
+    end
+  case 2 then
+    for k=1:dims(1)
+      a(k,:)=cumprod(a(k,:),typ(:))
+    end
+  else
+    a=a
+  end
+endfunction
diff --git a/scilab/modules/overloading/macros/%p_cumsum.sci b/scilab/modules/overloading/macros/%p_cumsum.sci
new file mode 100644 (file)
index 0000000..e2c0c97
--- /dev/null
@@ -0,0 +1,67 @@
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2010 -  INRIA - Serge Steer 
+// 
+// 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    
+// http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
+
+function a=%p_cumsum(a,d,typ)
+  if argn(2)==1 then
+    typ=list()
+    d='*'
+  elseif argn(2)==2 then 
+    if argn(2)==2& or(d==['native','double']) then
+      typ=list(d)
+      d='*'
+    else
+      typ=list()
+    end
+  else
+    typ=list(typ)
+  end
+  if size(d,'*')<>1 then 
+    if type(d)==10 then
+      error(msprintf(_("%s: Wrong size for input argument #%d: A string expected.\n"),"cumsum",2))
+    else
+      error(msprintf(_("%s: Wrong size for input argument #%d: A scalar expected.\n"),"cumsum",2))
+    end
+  end
+  if type(d)==10 then
+    d=find(d==['m','*','r','c'])
+    if d==[] then
+      error(msprintf(_("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"),..
+                     "cumsum",2,"""*"",""r"",""c"",""m"",1:"+string(ndims(a))))
+    end
+    d=d-2
+  end
+  dims=size(a);
+    
+  if d==-1 then //'m'
+    d=find(dims>1,1)
+    if d==[] then d=0,end
+  end
+  if d<0 then
+    error(msprintf(_("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"),..
+                     "cumsum",2,"""*"",""r"",""c"",""m"",1:"+string(ndims(a))))
+  end
+
+  select d
+  case 0 then
+    for k=2:prod(dims)
+      a(k)=a(k-1)+a(k)
+    end
+  case 1 then
+    for k=1:dims(2)
+      a(:,k)=cumsum(a(:,k),typ(:))
+    end
+  case 2 then
+    for k=1:dims(1)
+      a(k,:)=cumsum(a(k,:),typ(:))
+    end
+  else
+    a=a
+  end
+endfunction
index 1c1bdaa..ec882a1 100644 (file)
@@ -1,5 +1,5 @@
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
-// Copyright (C) INRIA
+// Copyright (C) 2010 -  INRIA - Serge Steer
 // 
 // This file must be used under the terms of the CeCILL.
 // This source file is licensed as described in the file COPYING, which
@@ -7,20 +7,60 @@
 // are also available at    
 // http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
 
-function r=%p_prod(a,flag)
+function r=%p_prod(a,d,typ)
+  if argn(2)==1 then
+    typ=list()
+    d='*'
+  elseif argn(2)==2 then 
+    if argn(2)==2& or(d==['native','double']) then
+      typ=list(d)
+      d='*'
+    else
+      typ=list()
+    end
+  else
+    typ=list(typ)
+  end
+  if size(d,'*')<>1 then 
+    if type(d)==10 then
+      error(msprintf(_("%s: Wrong size for input argument #%d: A string expected.\n"),"prod",2))
+    else
+      error(msprintf(_("%s: Wrong size for input argument #%d: A scalar expected.\n"),"prod",2))
+    end
+  end
+  if type(d)==10 then
+    d=find(d==['m','*','r','c'])
+    if d==[] then
+      error(msprintf(_("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"),..
+                     "prod",2,"""*"",""r"",""c"",""m"",1:"+string(ndims(a))))
+    end
+    d=d-2
+  end
+  dims=size(a);
+    
+  if d==-1 then //'m'
+    d=find(dims>1,1)
+    if d==[] then d=0,end
+  end
+  if d<0 then
+    error(msprintf(_("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"),..
+                     "prod",2,"""*"",""r"",""c"",""m"",1:"+string(ndims(a))))
+  end
 
-r=[]
-[m,n]=size(a);
-[m,n]=size(a);
-if flag=='m'|flag==-1 then
-  flag=find([m,n]>1,1)
-  if flag==[] then a=prod(a),return,end
-end
+  select d
+  case 0 then
+     r=prod(a)
+  case 1 then
+    for k=1:dims(2)
+      r(1,k)=prod(a(:,k),typ(:))
+    end
+   case 2 then
+    for k=1:dims(1)
+      r(k,1)=prod(a(k,:),typ(:))
+    end
+  else
+    r=a
+  end
 
-if flag==1|flag=='r' then
-  for k=1:n,r(1,k)=prod(a(:,k)),end
-end
-if flag==2|flag=='c' then
-  for k=1:m,r(k,1)=prod(a(k,:)),end
-end
 endfunction
index e31c454..b744c1b 100644 (file)
@@ -1,5 +1,5 @@
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
-// Copyright (C) INRIA
+// Copyright (C) 2010 -  INRIA - Serge Steer
 // 
 // This file must be used under the terms of the CeCILL.
 // This source file is licensed as described in the file COPYING, which
@@ -7,16 +7,53 @@
 // are also available at    
 // http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
 
-function a=%p_sum(a,flag)
+function a=%p_sum(a,d,typ)
+//sum of a polynomial matrix. Sum of Polynomial hypermatrices are
+//handled by %hm_sum
+  if argn(2)==1 then
+    typ=list()
+    d='*'
+  elseif argn(2)==2 then 
+    if argn(2)==2& or(d==['native','double']) then
+      typ=list(d)
+      d='*'
+    else
+      typ=list()
+    end
+  else
+    typ=list(typ)
+  end
+  if size(d,'*')<>1 then 
+    if type(d)==10 then
+      error(msprintf(_("%s: Wrong size for input argument #%d: A string expected.\n"),"sum",2))
+    else
+      error(msprintf(_("%s: Wrong size for input argument #%d: A scalar expected.\n"),"sum",2))
+    end
+  end
+  if type(d)==10 then
+    d=find(d==['m','*','r','c'])
+    if d==[] then
+      error(msprintf(_("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"),..
+                     "sum",2,"""*"",""r"",""c"",""m"",1:"+string(ndims(a))))
+    end
+    d=d-2
+  end
+  dims=size(a);
+    
+  if d==-1 then //'m'
+    d=find(dims>1,1)
+    if d==[] then d=0,end
+  end
+  select d
+  case 0 then
+    a=sum(a)
+  case 1 then
+    a=ones(1,dims(1))*a;
+  case 2 then
+    a=a*ones(dims(2),1);  
+  else
+    a=a
+  end
 
-[m,n]=size(a);
-if flag=='m'|flag==-1 then
-  flag=find([m,n]>1,1)
-  if flag==[] then a=sum(a),return,end
-end
-if flag==1|flag=='r' then
-  a=ones(1,m)*a;
-elseif flag==2|flag=='c' then
-  a=a*ones(n,1);
-end
 endfunction
diff --git a/scilab/modules/overloading/macros/%r_cumprod.sci b/scilab/modules/overloading/macros/%r_cumprod.sci
new file mode 100644 (file)
index 0000000..cdec484
--- /dev/null
@@ -0,0 +1,55 @@
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2010 -  INRIA - Serge Steer
+// 
+// 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    
+// http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
+
+function a=%r_cumprod(a,d,typ)
+//prod of a rational matrix
+  if argn(2)==1 then
+    d='*'
+  elseif argn(2)==2 then 
+    if argn(2)==2& or(d==['native','double']) then
+      d='*'
+    end
+  end
+  if size(d,'*')<>1 then 
+    if type(d)==10 then
+      error(msprintf(_("%s: Wrong size for input argument #%d: A string expected.\n"),"cumprod",2))
+    else
+      error(msprintf(_("%s: Wrong size for input argument #%d: A scalar expected.\n"),"cumprod",2))
+    end
+  end
+  dims=size(a);
+  
+  if type(d)==10 then
+    d=find(d==['m','*','r','c'])
+    if d==[] then
+      error(msprintf(_("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"),..
+                     "cumprod",2,"""*"",""r"",""c"",""m"",1:"+string(size(dims,'*'))))
+    end
+    d=d-2
+  end
+     
+  if d==-1 then //'m'
+    d=find(dims>1,1)
+    if d==[] then d=0,end
+  end
+  if d<0 then
+    error(msprintf(_("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"),..
+                     "cumprod",2,"""*"",""r"",""c"",""m"",1:"+string(ndims(a))))
+  end
+  if d==0 then //'*'
+    a=rlist(cumprod(a.num),cumprod(a.den),a.dt)
+    if simp_mode() then a=simp(a),end
+  elseif or(d==[1 2]) then
+    a=rlist(cumprod(a.num,d),cumprod(a.den,d),a.dt)
+    if simp_mode() then a=simp(a),end
+  else
+    a=a
+  end
+
+endfunction
diff --git a/scilab/modules/overloading/macros/%r_prod.sci b/scilab/modules/overloading/macros/%r_prod.sci
new file mode 100644 (file)
index 0000000..d63a13f
--- /dev/null
@@ -0,0 +1,55 @@
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2010 -  INRIA - Serge Steer
+// 
+// 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    
+// http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
+
+function a=%r_prod(a,d,typ)
+//prod of a rational matrix
+  if argn(2)==1 then
+    d='*'
+  elseif argn(2)==2 then 
+    if argn(2)==2& or(d==['native','double']) then
+      d='*'
+    end
+  end
+  if size(d,'*')<>1 then 
+    if type(d)==10 then
+      error(msprintf(_("%s: Wrong size for input argument #%d: A string expected.\n"),"prod",2))
+    else
+      error(msprintf(_("%s: Wrong size for input argument #%d: A scalar expected.\n"),"prod",2))
+    end
+  end
+  dims=size(a);
+  
+  if type(d)==10 then
+    d=find(d==['m','*','r','c'])
+    if d==[] then
+      error(msprintf(_("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"),..
+                     "prod",2,"""*"",""r"",""c"",""m"",1:"+string(size(dims,'*'))))
+    end
+    d=d-2
+  end
+     
+  if d==-1 then //'m'
+    d=find(dims>1,1)
+    if d==[] then d=0,end
+  end
+  if d<0 then
+    error(msprintf(_("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"),..
+                     "prod",2,"""*"",""r"",""c"",""m"",1:"+string(ndims(a))))
+  end
+
+  if d==0 then //'*'
+    a=rlist(prod(a.num),prod(a.den),a.dt)
+    if simp_mode() then a=simp(a),end
+  elseif or(d==[1 2]) then
+    a=rlist(prod(a.num,d),prod(a.den,d),a.dt)
+    if simp_mode() then a=simp(a),end
+  else
+    a=a
+  end
+endfunction
diff --git a/scilab/modules/overloading/macros/%r_sum.sci b/scilab/modules/overloading/macros/%r_sum.sci
new file mode 100644 (file)
index 0000000..fecfd6e
--- /dev/null
@@ -0,0 +1,52 @@
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2010 -  INRIA - Serge Steer
+// 
+// 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    
+// http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
+
+function a=%r_sum(a,d,typ)
+//sum of a rational matrix. Sum of rational hypermatrices are
+//handled by %hm_sum
+  
+  if argn(2)==1 then
+    d='*'
+  elseif argn(2)==2 then 
+    if argn(2)==2& or(d==['native','double']) then
+      d='*'
+    end
+  end
+  if size(d,'*')<>1 then 
+    if type(d)==10 then
+      error(msprintf(_("%s: Wrong size for input argument #%d: A string expected.\n"),"sum",2))
+    else
+      error(msprintf(_("%s: Wrong size for input argument #%d: A scalar expected.\n"),"sum",2))
+    end
+  end
+  dims=size(a);
+  if type(d)==10 then
+    d=find(d==['m','*','r','c'])
+    if d==[] then
+      error(msprintf(_("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"),..
+                     "sum",2,"""*"",""r"",""c"",""m"",1:"+string(size(dims,'*'))))
+    end
+    d=d-2
+  end
+    
+  if d==-1 then //'m'
+    d=find(dims>1,1)
+    if d==[] then d=0,end
+  end
+  select d
+  case 0 then//'*'
+     a=ones(1,size(a,'*'))*matrix(a,-1,1)
+  case 1 then
+     a=ones(1,dims(1))*a;
+  case 2 then
+     a=a*ones(dims(2),1);
+  else
+    a=a
+  end
+endfunction
diff --git a/scilab/modules/overloading/macros/%sp_cumprod.sci b/scilab/modules/overloading/macros/%sp_cumprod.sci
new file mode 100644 (file)
index 0000000..34ac669
--- /dev/null
@@ -0,0 +1,110 @@
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2010 -  INRIA - Serge Steer
+// 
+// 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    
+// http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
+
+function r=%sp_cumprod(a,d,typ)
+  if argn(2)==1 then
+    typ=list()
+    d='*'
+  elseif argn(2)==2 then 
+    if argn(2)==2& or(d==['native','double']) then
+      typ=list(d)
+      d='*'
+    else
+      typ=list()
+    end
+  else
+    typ=list(typ)
+  end
+  if size(d,'*')<>1 then 
+    if type(d)==10 then
+      error(msprintf(_("%s: Wrong size for input argument #%d: A string expected.\n"),"cumprod",2))
+    else
+      error(msprintf(_("%s: Wrong size for input argument #%d: A scalar expected.\n"),"cumprod",2))
+    end
+  end
+  if type(d)==10 then
+    d=find(d==['m','*','r','c'])
+    if d==[] then
+      error(msprintf(_("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"),..
+                     "cumprod",2,"""*"",""r"",""c"",""m"",1:"+string(ndims(a))))
+    end
+    d=d-2
+  end
+  dims=size(a);
+    
+  if d==-1 then //'m'
+    d=find(dims>1,1)
+    if d==[] then d=0,end
+  end
+  if d<0 then
+    error(msprintf(_("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"),..
+                     "cumprod",2,"""*"",""r"",""c"",""m"",1:"+string(ndims(a))))
+  end
+
+  
+  r=sparse(dims,0,dims)
+  select d
+  case 0 then
+    [ij,v]=spget(a)
+    if or(ij(1,:)<>[1 1]) then return,end
+    if dims(1)==1 then
+      l=find(diff(ij(:,2))>1,1)
+      if l==[] then 
+        r=sparse(ij,cumprod(v),dims)
+      else
+        r=sparse(ij(1:l,:),cumprod(v(1:l)),dims)
+      end
+    elseif dims(2)==1 then
+      l=find(diff(ij(:,1))>1,1)
+      if l==[] then 
+        r=sparse(ij,cumprod(v),dims)
+      else
+        r=sparse(ij(1:l,:),cumprod(v(1:l)),dims)
+      end
+     else
+      r=matrix(cumprod(matrix(a,1,-1)),dims)
+    end
+  case 1 then
+    ij=[];v=[];
+    for k=1:dims(2)
+      [ijk,vk]=spget(a(:,k));
+      if and(ijk(1,:)==[1 1]) then
+        l=find(diff(ijk(:,1))>1,1);
+        if l==[] then 
+          ij=[ij;[ijk(:,1) k*ones(vk)]];
+          v=[v;cumprod(vk)];
+        else
+          ij=[ij;[ijk(1:l,1) k*ones(l,1)]];
+          v=[v;cumprod(vk(1:l,:))];
+        end
+      end
+    end
+    r=sparse(ij,v,dims)
+   case 2 then
+     ij=[];v=[]
+     for k=1:dims(1)
+     [ijk,vk]=spget(a(k,:))
+     if and(ijk(1,:)==[1 1]) then
+       l=find(diff(ijk(:,2))>1,1)
+       if l==[] then 
+         ij=[ij;[k*ones(vk) ijk(:,2)]];
+         v=[v;cumprod(vk)]
+       else
+         ij=[ij;[k*ones(l,1),ijk(1:l,2)]];
+         v=[v;cumprod(vk(1:l,:))]
+       end
+     end
+    end
+    r=sparse(ij,v,dims)
+  else
+    r=a
+  end
+
+endfunction
diff --git a/scilab/modules/overloading/macros/%sp_cumsum.sci b/scilab/modules/overloading/macros/%sp_cumsum.sci
new file mode 100644 (file)
index 0000000..f1bcf7b
--- /dev/null
@@ -0,0 +1,68 @@
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2010 -  INRIA - Serge Steer
+// 
+// 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    
+// http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
+
+function r=%sp_cumsum(a,d,typ)
+  rhs=argn(2)
+  if rhs==1 then
+    d='*'
+  elseif rhs==2 then 
+    if argn(2)==2& or(d==['native','double']) then
+      d='*'
+    end
+  end
+  if size(d,'*')<>1 then 
+    if type(d)==10 then
+      error(msprintf(_("%s: Wrong size for input argument #%d: A string expected.\n"),"cumsum",2))
+    else
+      error(msprintf(_("%s: Wrong size for input argument #%d: A scalar expected.\n"),"cumsum",2))
+    end
+  end
+  if type(d)==10 then
+    d=find(d==['m','*','r','c'])
+    if d==[] then
+      error(msprintf(_("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"),..
+                     "cumsum",2,"""*"",""r"",""c"",""m"",1:"+string(ndims(a))))
+    end
+    d=d-2
+  end
+  
+  dims=size(a)
+
+  if d==-1 then 
+    //sum(x,'m'), determine the summation direction
+    d=find(dims>1,1)
+    if d==[] then d=0,end
+  end
+  if d<0 then
+    error(msprintf(_("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"),..
+                     "cumsum",2,"""*"",""r"",""c"",""m"",1:"+string(ndims(a))))
+  end
+  
+  select d
+  case 0 then
+    ij=spget(a)
+    if size(ij,1)==0 then r=a,return,end
+    mnj=min(ij(:,2));
+    r=sparse([],[],dims);
+    r(1:dims(1),mnj:dims(2))=sparse(cumsum(full(a(:,mnj:$))))
+  case 1 then
+    r=sparse([],[],dims);
+    for k=1:dims(2)
+      r(:,k)=cumsum(a(:,k))
+    end
+  case 2 then
+    r=sparse([],[],dims);
+    for k=1:dims(1)
+      r(k,:)=cumsum(a(k,:))
+    end
+  else
+    r=a
+  end
+endfunction
diff --git a/scilab/modules/overloading/macros/%sp_prod.sci b/scilab/modules/overloading/macros/%sp_prod.sci
new file mode 100644 (file)
index 0000000..ed3c0b8
--- /dev/null
@@ -0,0 +1,63 @@
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2010 -  INRIA - Serge Steer
+// 
+// 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    
+// http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
+
+function r=%sp_prod(a,d,typ)
+  if argn(2)==1 then
+    d='*'
+  elseif argn(2)==2 then 
+    if argn(2)==2& or(d==['native','double']) then
+      d='*'
+
+    end
+  end
+  if size(d,'*')<>1 then 
+    if type(d)==10 then
+      error(msprintf(_("%s: Wrong size for input argument #%d: A string expected.\n"),"prod",2))
+    else
+      error(msprintf(_("%s: Wrong size for input argument #%d: A scalar expected.\n"),"prod",2))
+    end
+  end
+  if type(d)==10 then
+    d=find(d==['m','*','r','c'])
+    if d==[] then
+      error(msprintf(_("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"),..
+                     "prod",2,"""*"",""r"",""c"",""m"",1:"+string(ndims(a))))
+    end
+    d=d-2
+  end
+  dims=size(a);
+    
+  if d==-1 then //'m'
+    d=find(dims>1,1)
+    if d==[] then d=0,end
+  end
+  if d<0 then
+    error(msprintf(_("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"),..
+                     "prod",2,"""*"",""r"",""c"",""m"",1:"+string(ndims(a))))
+  end
+
+  select d
+  case 0 then
+     r=prod(a)
+  case 1 then
+    for k=1:dims(2)
+      r(1,k)=prod(a(:,k))
+    end
+    r=sparse(r)
+  case 2 then
+    for k=1:dims(1)
+      r(k,1)=prod(a(k,:))
+    end
+    r=sparse(r)
+  else
+    r=a
+  end
+
+endfunction
index b45da60..3642df2 100644 (file)
@@ -1,5 +1,5 @@
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
-// Copyright (C) INRIA
+// Copyright (C) 2010 -  INRIA - Serge Steer
 // 
 // This file must be used under the terms of the CeCILL.
 // This source file is licensed as described in the file COPYING, which
@@ -7,18 +7,50 @@
 // are also available at    
 // http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
 
-function a=%sp_sum(a,flag)
-
-[m,n]=size(a);
-if flag=='m'|flag==-1 then
-  flag=find([m,n]>1,1)
-  if flag==[] then a=sum(a),return,end
-end
-
-if flag==2|flag=='c' then
-  a=sparse(a*ones(n,1))
-end
-if flag==1|flag=='r' then
-  a=sparse(ones(1,m)*a);
-end
+function a=%sp_sum(a,d,typ)
+  rhs=argn(2)
+  if rhs==1 then
+    d='*'
+  elseif rhs==2 then 
+    if argn(2)==2& or(d==['native','double']) then
+      d='*'
+    end
+  end
+  if size(d,'*')<>1 then 
+    if type(d)==10 then
+      error(msprintf(_("%s: Wrong size for input argument #%d: A string expected.\n"),"sum",2))
+    else
+      error(msprintf(_("%s: Wrong size for input argument #%d: A scalar expected.\n"),"sum",2))
+    end
+  end
+  dims=size(a)
+  if type(d)==10 then
+    d=find(d==['m','*','r','c'])
+    if d==[] then
+      error(msprintf(_("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"),..
+                     "sum",2,"""*"",""r"",""c"",""m"",1:"+string(ndims(a))))
+    end
+    d=d-2
+  end
+  
+  if d==-1 then 
+    //sum(x,'m'), determine the summation direction
+    d=find(dims>1,1)
+    if d==[] then d=0,end
+  end
+  if d<0 then
+    error(msprintf(_("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"),..
+                     "sum",2,"""*"",""r"",""c"",""m"",1:"+string(ndims(a))))
+  end
+  select d
+    case 0 then
+    //sum of all elements
+    a=sum(a)
+  case 1 then
+     a=sparse(ones(1,dims(1))*a);
+  case 2 then
+    a=sparse(a*ones(dims(2),1))
+  else
+    a=a
+  end
 endfunction
diff --git a/scilab/modules/overloading/macros/%spb_cumprod.sci b/scilab/modules/overloading/macros/%spb_cumprod.sci
new file mode 100644 (file)
index 0000000..7d6d43b
--- /dev/null
@@ -0,0 +1,113 @@
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2010 -  INRIA - Serge Steer
+// 
+// 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    
+// http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
+
+function r=%spb_cumprod(a,d,typ)
+  if argn(2)==1 then
+    typ=list()
+    d='*'
+  elseif argn(2)==2 then 
+    if argn(2)==2& or(d==['native','double']) then
+      typ=list(d)
+      d='*'
+    else
+      typ=list()
+    end
+  else
+    typ=list(typ)
+  end
+  if size(d,'*')<>1 then 
+    if type(d)==10 then
+      error(msprintf(_("%s: Wrong size for input argument #%d: A string expected.\n"),"cumprod",2))
+    else
+      error(msprintf(_("%s: Wrong size for input argument #%d: A scalar expected.\n"),"cumprod",2))
+    end
+  end
+  if type(d)==10 then
+    d=find(d==['m','*','r','c'])
+    if d==[] then
+      error(msprintf(_("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"),..
+                     "cumprod",2,"""*"",""r"",""c"",""m"",1:"+string(ndims(a))))
+    end
+    d=d-2
+  end
+  dims=size(a);
+    
+  if d==-1 then //'m'
+    d=find(dims>1,1)
+    if d==[] then d=0,end
+  end
+  if d<0 then
+    error(msprintf(_("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"),..
+                     "cumprod",2,"""*"",""r"",""c"",""m"",1:"+string(ndims(a))))
+  end
+
+  
+  r=sparse(dims,0,dims)
+  select d
+  case 0 then
+    [ij,v]=spget(a)
+    if dims(1)==1 then
+      l=find(diff(ij(:,2))>1,1)
+      if l==[] then 
+        r=sparse(ij,cumprod(v,typ(:)),dims)
+      else
+        r=sparse(ij(1:l,:),cumprod(v(1:l),typ(:)),dims)
+      end
+    elseif dims(2)==1 then
+      l=find(diff(ij(:,1))>1,1)
+      if l==[] then 
+        r=sparse(ij,cumprod(v,typ(:)),dims)
+      else
+        r=sparse(ij(1:l,:),cumprod(v(1:l),typ(:)),dims)
+      end
+    else
+      r=matrix(cumprod(matrix(a,1,-1),typ(:)),dims)
+    end
+  case 1 then
+    ij=[];v=[];
+    for k=1:dims(2)
+      [ijk,vk]=spget(a(:,k));
+      if and(ijk(1,:)==[1 1]) then
+        l=find(diff(ijk(:,1))>1,1);
+        if l==[] then 
+          ij=[ij;[ijk(:,1) k*ones(vk)]];
+          v=[v;cumprod(vk,typ(:))];
+        else
+          ij=[ij;[ijk(1:l,1) k*ones(l,1)]];
+          v=[v;cumprod(vk(1:l,:),typ(:))];
+        end
+      end
+    end
+    r=sparse(ij,v,dims)
+   case 2 then
+     ij=[];v=[]
+     for k=1:dims(1)
+     [ijk,vk]=spget(a(k,:))
+     if and(ijk(1,:)==[1 1]) then
+       l=find(diff(ijk(:,2))>1,1)
+       if l==[] then 
+         ij=[ij;[k*ones(vk) ijk(:,2)]];
+         v=[v;cumprod(vk,typ(:))]
+       else
+         ij=[ij;[k*ones(l,1),ijk(1:l,2)]];
+         v=[v;cumprod(vk(1:l,:),typ(:))]
+       end
+     end
+    end
+    r=sparse(ij,v,dims)
+  else
+    if typ==list('native')
+      r=a
+    else
+      r=bool2s(a)
+    end
+  end
+
+endfunction
diff --git a/scilab/modules/overloading/macros/%spb_cumsum.sci b/scilab/modules/overloading/macros/%spb_cumsum.sci
new file mode 100644 (file)
index 0000000..6f56e40
--- /dev/null
@@ -0,0 +1,97 @@
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2010 -  INRIA - Serge Steer
+// 
+// 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    
+// http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
+
+function r=%spb_cumsum(a,d,typ)
+  if argn(2)==1 then
+    typ=list()
+    d='*'
+  elseif argn(2)==2 then 
+    if argn(2)==2& or(d==['native','double']) then
+      typ=list(d)
+      d='*'
+    else
+      typ=list()
+    end
+  else
+    typ=list(typ)
+  end
+  if size(d,'*')<>1 then 
+    if type(d)==10 then
+      error(msprintf(_("%s: Wrong size for input argument #%d: A string expected.\n"),"cumsum",2))
+    else
+      error(msprintf(_("%s: Wrong size for input argument #%d: A scalar expected.\n"),"cumsum",2))
+    end
+  end
+
+  if type(d)==10 then
+    d=find(d==['m','*','r','c'])
+    if d==[] then
+      error(msprintf(_("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"),..
+                     "cumsum",2,"""*"",""r"",""c"",""m"",1:"+string(ndims(a))))
+    end
+    d=d-2
+  end
+  
+  dims=size(a)
+
+  if d==-1 then 
+    //sum(x,'m'), determine the summation direction
+    d=find(dims>1,1)
+    if d==[] then d=0,end
+  end
+  if d<0 then
+    error(msprintf(_("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"),..
+                     "cumsum",2,"""*"",""r"",""c"",""m"",1:"+string(ndims(a))))
+  end
+  
+  if typ<>list('native') then
+    r=sparse(dims,0,dims);
+  else
+    r=sparse(dims,%f,dims);
+  end
+  
+  select d
+  case 0 then
+    ij=spget(a)
+    if size(ij,1)==0 then return,end
+    if dims(1)==1 then
+        mnj=min(ij(:,2))
+        r(1,mnj:$)=sparse(cumsum(full(a(1,mnj:$)),typ(:)))
+    elseif dims(2)==1 then
+      mni=min(ij(:,1))
+      r(mni:$,1)=sparse(cumsum(full(a(mni:$,1)),typ(:)))
+    else
+      mnj=min(ij(:,2))
+      r(:,mnj:dims(2))=sparse(cumsum(full(a(:,mnj:$)),typ(:)))
+    end
+  case 1 then
+    for k=1:dims(2)
+      ij=spget(a(:,k))
+      if size(ij,1)<>0 then
+        mni=min(ij(:,1))
+        r(mni:$,k)=sparse(cumsum(full(a(mni:$,k)),typ(:)))
+      end
+    end
+  case 2 then
+    for k=1:dims(1)
+      ij=spget(a(k,:))
+      if size(ij,1)<>0 then
+        mnj=min(ij(:,2))
+        r(k,mnj:$)=sparse(cumsum(full(a(k,mnj:$)),typ(:)))
+      end
+    end
+  else
+    if typ==list('native') then
+      r=a
+    else
+      r=bool2s(a)
+    end
+  end
+endfunction
diff --git a/scilab/modules/overloading/macros/%spb_prod.sci b/scilab/modules/overloading/macros/%spb_prod.sci
new file mode 100644 (file)
index 0000000..e1e600d
--- /dev/null
@@ -0,0 +1,71 @@
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2010 -  INRIA - Serge Steer
+// 
+// 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    
+// http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
+
+function r=%spb_prod(a,d,typ)
+  if argn(2)==1 then
+    typ=list()
+    d='*'
+  elseif argn(2)==2 then 
+    if argn(2)==2& or(d==['native','double']) then
+      typ=list(d)
+      d='*'
+    else
+      typ=list()
+    end
+  else
+    typ=list(typ)
+  end
+  if size(d,'*')<>1 then 
+    if type(d)==10 then
+      error(msprintf(_("%s: Wrong size for input argument #%d: A string expected.\n"),"prod",2))
+    else
+      error(msprintf(_("%s: Wrong size for input argument #%d: A scalar expected.\n"),"prod",2))
+    end
+  end
+  if type(d)==10 then
+    d=find(d==['m','*','r','c'])
+    if d==[] then
+      error(msprintf(_("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"),..
+                     "prod",2,"""*"",""r"",""c"",""m"",1:"+string(ndims(a))))
+    end
+    d=d-2
+  end
+  dims=size(a);
+    
+  if d==-1 then //'m'
+    d=find(dims>1,1)
+    if d==[] then d=0,end
+  end
+  if d<0 then
+    error(msprintf(_("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"),..
+                     "prod",2,"""*"",""r"",""c"",""m"",1:"+string(ndims(a))))
+  end
+
+  select d
+  case 0 then
+     ij=spget(a)
+     r=size(ij,1)==prod(dims)
+     if typ<>list('native') then r=bool2s(r),end
+  case 1 then
+    for k=1:dims(2)
+      r(1,k)=prod(a(:,k),typ(:))
+    end
+    r=sparse(r)
+  case 2 then
+    for k=1:dims(1)
+      r(k,1)=prod(a(k,:),typ(:))
+    end
+    r=sparse(r)
+  else
+    r=a
+    if typ<>list('native') then r=bool2s(r),end
+  end
+
+endfunction
diff --git a/scilab/modules/overloading/macros/%spb_sum.sci b/scilab/modules/overloading/macros/%spb_sum.sci
new file mode 100644 (file)
index 0000000..86b6e83
--- /dev/null
@@ -0,0 +1,94 @@
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2010 -  INRIA - Serge Steer
+// 
+// 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    
+// http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
+
+function r=%spb_sum(a,d,typ)
+  rhs=argn(2)
+  if rhs==1 then
+    d='*'
+    typ="double"
+  elseif rhs==2 then 
+    if or(d==['native','double']) then
+      typ=d
+      d='*'
+    else
+      typ="double"
+    end
+  end
+  
+  if size(d,'*')<>1 then 
+    if type(d)==10 then
+      error(msprintf(_("%s: Wrong size for input argument #%d: A string expected.\n"),"sum",2))
+    else
+      error(msprintf(_("%s: Wrong size for input argument #%d: A scalar expected.\n"),"sum",2))
+    end
+  end
+  dims=size(a)
+  if type(d)==10 then
+    d=find(d==['m','*','r','c'])
+    if d==[] then
+      error(msprintf(_("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"),..
+                     "sum",2,"""*"",""r"",""c"",""m"",1:"+string(ndims(a))))
+    end
+    d=d-2
+  end
+  
+  if d==-1 then 
+    //sum(x,'m'), determine the summation direction
+    d=find(dims>1,1)
+    if d==[] then d=0,end
+  end
+  if d<0 then
+    error(msprintf(_("%s: Wrong value for input argument #%d: Must be in the set {%s}.\n"),..
+                     "sum",2,"""*"",""r"",""c"",""m"",1:"+string(ndims(a))))
+  end
+  
+  ij=spget(a);
+  select d
+  case 0 then
+    //sum of all elements
+    if typ=='native' then
+      r=size(ij,1)<>0
+    else
+      r=size(ij,1)
+    end
+  case 1 then
+    if typ=='native' then
+      r(1,dims(2))=%f
+      for k=1:dims(2)
+        r(k)=or(ij(:,2)==k)
+      end
+    else
+      r=zeros(1,dims(2));
+      for k=1:dims(2)
+        r(k)=size(find(ij(:,2)==k),'*')
+      end
+    end
+    r=sparse(r)
+  case 2 then
+    if typ=='native' then
+      r(dims(1),1)=%f
+      for k=1:dims(1)
+        r(k)=or(ij(:,1)==k)
+      end
+    else
+      r=zeros(ndims(1),1);
+      for k=1:dims(1)
+        r(k)=size(find(ij(:,1)==k),'*')
+      end
+    end
+    r=sparse(r)
+  else
+    if typ=='native' then
+      r=a
+    else
+      r=sparse(ij,ones(size(ij,1),1),dims)
+    end
+  end
+endfunction
index 243d458..a1d3728 100644 (file)
@@ -22,7 +22,7 @@ c
          return
       endif
       if(rhs.ne.1) then
-         if(rhs.eq.2) then
+         if(rhs.ge.2) then
             call funnam(ids(1,pt+1),'prod',iadr(lstk(top-rhs+1)))
             fun=-1
             return
index 9962d2b..59ccc26 100644 (file)
@@ -22,7 +22,7 @@ c
          return
       endif
       if(rhs.ne.1) then
-         if(rhs.eq.2) then
+         if(rhs.ge.2) then
             call funnam(ids(1,pt+1),'sum',iadr(lstk(top-rhs+1)))
             fun=-1
             return