* Bug #12679 refixed - Polynomials: argument check for gcd and lcm 36/14836/2
Paul Bignier [Wed, 9 Jul 2014 13:56:01 +0000 (15:56 +0200)]
Change-Id: I0f6d90da7489b8ec8ee66d946df13d3a69babcb6

scilab/modules/elementary_functions/help/en_US/discrete/gcd.xml
scilab/modules/elementary_functions/help/en_US/discrete/lcm.xml
scilab/modules/elementary_functions/help/fr_FR/discrete/gcd.xml
scilab/modules/elementary_functions/help/fr_FR/discrete/lcm.xml
scilab/modules/polynomials/macros/gcd.sci
scilab/modules/polynomials/macros/lcm.sci
scilab/modules/polynomials/tests/nonreg_tests/bug_12679.dia.ref
scilab/modules/polynomials/tests/nonreg_tests/bug_12679.tst

index b28efe2..b87d940 100644 (file)
                 <listitem>
                     <para>
                         a polynomial row vector <literal>p = [p1, ..., pn]</literal> (type equal to 2) or
-                        an integer row vector (type equal to 8).
+                        an integer row vector (type equal to 1 or 8).
+                    </para>
+                </listitem>
+            </varlistentry>
+            <varlistentry>
+                <term>pgcd</term>
+                <listitem>
+                    <para>
+                        vector of the same type as <literal>p</literal>
+                    </para>
+                </listitem>
+            </varlistentry>
+            <varlistentry>
+                <term>U</term>
+                <listitem>
+                    <para>
+                        matrix of the same type as <literal>p</literal>
                     </para>
                 </listitem>
             </varlistentry>
             The greatest common divisor of an array <literal>p</literal> of real numbersof real numbers can be obtained by
             converting it to a polynomial before calling <literal>gcd</literal>, through <code>p = inv_coeff(p, 0)</code>.
         </para>
+        <para>
+            If <literal>p</literal> is given as an integer double (type 1), then it is treated as an <literal>int32</literal>.
+        </para>
     </refsection>
     <refsection>
         <title>Examples</title>
         <programlisting role="example"><![CDATA[
-//polynomial case
-s=poly(0,'s');
-p=[s,s*(s+1)^2,2*s^2+s^3];
-[pgcd,u]=gcd(p);
+// Polynomial case
+s = %s;
+p = [s  s*(s+1)^2 2*s^2+s^3];
+[pgcd,u] = gcd(p);
 p*u
 
-//integer case
-V=int32([2^2*3^5, 2^3*3^2,2^2*3^4*5]);
-[thegcd,U]=gcd(V)
+// Integer case
+V = int32([2^2*3^5 2^3*3^2 2^2*3^4*5]);
+[thegcd,U] = gcd(V)
 V*U
 
-gcd(uint8([15 20]))
+// Double case
+V = [2^2*3^5 2^3*3^2 2^2*3^4*5];
+[thegcd,U] = gcd(V)
+V*U
 
-gcd([iconvert(15,4) iconvert(20,4)])
+gcd(uint8([15 20]))
 
-gcd(iconvert([15 20],4))
+gcd([iconvert(15, 4) iconvert(20, 4)])
 
+gcd(iconvert([15 20], 4))
  ]]></programlisting>
     </refsection>
     <refsection role="see also">
index ccad027..4021a39 100644 (file)
@@ -27,7 +27,7 @@
                 <listitem>
                     <para>
                         a polynomial row vector <literal>p = [p1, ..., pn]</literal> (type equal to 2) or
-                        an integer row vector (type equal to 8).
+                        an integer row vector (type equal to 1 or 8).
                     </para>
                 </listitem>
             </varlistentry>
             The least common multiple of an array <literal>p</literal> of real numbers can be obtained by
             converting it to a polynomial before calling <literal>lcm</literal>, through <code>p = inv_coeff(p, 0)</code>.
         </para>
+        <para>
+            If <literal>p</literal> is given as an integer double (type 1), then it is treated as an <literal>int32</literal>.
+        </para>
     </refsection>
     <refsection>
         <title>Examples</title>
         <programlisting role="example"><![CDATA[
-//polynomial case
-s=poly(0,'s');
-p=[s,s*(s+1)^2,s^2*(s+2)];
-[pp,fact]=lcm(p);
+// Polynomial case
+s = %s;
+p = [s s*(s+1)^2 s^2*(s+2)];
+[pp,fact] = lcm(p);
 p.*fact, pp
 
-//integer case
-V=int32([2^2*3^5, 2^3*3^2,2^2*3^4*5]);
+// Integer case
+V = int32([2^2*3^5, 2^3*3^2,2^2*3^4*5]);
+lcm(V)
+
+// Double case
+V = [2^2*3^5, 2^3*3^2,2^2*3^4*5];
 lcm(V)
  ]]></programlisting>
     </refsection>
index 971d3ce..16d5123 100644 (file)
         <title>Paramètres</title>
         <variablelist>
             <varlistentry>
-                <term>p  </term>
+                <term>p</term>
                 <listitem>
                     <para>
-                        vecteur ligne de polynômes <literal>p = [p1,..,pn] (type égal à 2) ou d'entiers (type égal à 8)</literal>
+                        vecteur ligne de polynômes <literal>p = [p1,..,pn] (type égal à 2) ou d'entiers (type égal à 1 ou 8)</literal>
+                    </para>
+                </listitem>
+            </varlistentry>
+            <varlistentry>
+                <term>pgcd</term>
+                <listitem>
+                    <para>
+                        vecteur de même type que <literal>p</literal>
+                    </para>
+                </listitem>
+            </varlistentry>
+            <varlistentry>
+                <term>u</term>
+                <listitem>
+                    <para>
+                        matrice de même type que <literal>p</literal>
                     </para>
                 </listitem>
             </varlistentry>
             Le PGCD d'une matrice <literal>p</literal> de réels peut s'obtenir en la convertissant en polynôme
             avant d'appeler <literal>gcd</literal>, grâce à la commande <literal>p = inv_coeff(p, 0)</literal>.
         </para>
+        <para>
+            Si <literal>p</literal> est donné comme un flottant entier (type 1), alors il est traité comme un <literal>int32</literal>.
+        </para>
     </refsection>
     <refsection>
         <title>Exemples</title>
         <programlisting role="example"><![CDATA[
-//cas des polynômes
-s=poly(0,'s');
-p=[s,s*(s+1)^2,2*s^2+s^3];
-[pgcd,u]=gcd(p);
+// Cas des polynômes
+s = %s;
+p = [s  s*(s+1)^2 2*s^2+s^3];
+[pgcd,u] = gcd(p);
 p*u
 
-//cas des entiers
-V=int32([2^2*3^5, 2^3*3^2,2^2*3^4*5]);
-[thegcd,U]=gcd(V)
+// Cas des entiers
+V = int32([2^2*3^5 2^3*3^2 2^2*3^4*5]);
+[thegcd,U] = gcd(V)
+V*U
+
+// Cas des doubles
+V = [2^2*3^5 2^3*3^2 2^2*3^4*5];
+[thegcd,U] = gcd(V)
 V*U
 
 gcd(uint8([15 20]))
 
-gcd([iconvert(15,4) iconvert(20,4)])
+gcd([iconvert(15, 4) iconvert(20, 4)])
 
-gcd(iconvert([15 20],4))
+gcd(iconvert([15 20], 4))
  ]]></programlisting>
     </refsection>
     <refsection role="see also">
index 012023b..6c3e019 100644 (file)
         <title>Paramètres</title>
         <variablelist>
             <varlistentry>
-                <term>p  </term>
+                <term>p</term>
                 <listitem>
-                    <para>vecteur de polynômes (type égal à 2) ou d'entiers (type égal à 8)
+                    <para>vecteur de polynômes (type égal à 2) ou d'entiers (type égal à 1 ou 8)
                     </para>
                 </listitem>
             </varlistentry>
             <varlistentry>
-                <term>fact  </term>
+                <term>fact</term>
                 <listitem>
                     <para>vecteur de polynômes ou d'entiers
                     </para>
                 </listitem>
             </varlistentry>
             <varlistentry>
-                <term>pp  </term>
+                <term>pp</term>
                 <listitem>
-                    <para>polynôme ou un entier
+                    <para>polynôme ou entier
                     </para>
                 </listitem>
             </varlistentry>
             Le plus petit commun multiple d'une matrice <literal>p</literal> de réels peut s'obtenir en la convertissant
             en polynôme avant d'appeler <literal>lcm</literal>, grâce à la commande <literal>p = inv_coeff(p, 0)</literal>.
         </para>
+        <para>
+            Si <literal>p</literal> est donné comme un flottant entier (type 1), alors il est traité comme un <literal>int32</literal>.
+        </para>
     </refsection>
     <refsection>
         <title>Exemples</title>
         <programlisting role="example"><![CDATA[
-//cas des polynomes
-s=poly(0,'s');
-p=[s,s*(s+1)^2,s^2*(s+2)];
-[pp,fact]=lcm(p);
+// Cas des polynômes
+s = %s;
+p = [s s*(s+1)^2 s^2*(s+2)];
+[pp,fact] = lcm(p);
 p.*fact, pp
 
-//cas des entiers
-V=int32([2^2*3^5, 2^3*3^2,2^2*3^4*5]);
+// Cas des entiers
+V = int32([2^2*3^5, 2^3*3^2,2^2*3^4*5]);
+lcm(V)
+
+// Cas des doubles
+V = [2^2*3^5, 2^3*3^2,2^2*3^4*5];
 lcm(V)
  ]]></programlisting>
     </refsection>
index 5061669..ee9f47a 100644 (file)
@@ -14,10 +14,18 @@ function [x, uu] = gcd(p)
     //with minimal degree such that [p1 p2]*u=[0 ... 0 pgcd]
     //!
 
-    if (type(p)<>2 & type(p)<>8) then
+    if type(p)<>1 & type(p)<>2 & type(p)<>8 then
         error(msprintf(_("%s: Wrong type for argument #%d: Integer array or Polynomial expected.\n"), "gcd", 1));
     end
 
+    if type(p)==1 then
+        if floor(p)<>p then
+            error(msprintf(_("%s: Wrong type for argument #%d: Integer array or Polynomial expected.\n"), "gcd", 1));
+        else
+            p = iconvert(p,4);
+        end
+    end
+
     [lhs,rhs]=argn(0)
     if type(p)==8 then
         if lhs==2 then [x,uu]=%i_gcd(p), else x=%i_gcd(p), end
index fc13a4b..f079000 100644 (file)
@@ -14,10 +14,18 @@ function [p, fact] = lcm(p)
     //such that  p.*fact=pp*ones(p)
     //!
 
-    if (type(p)<>2 & type(p)<>8) then
+    if type(p)<>1 & type(p)<>2 & type(p)<>8 then
         error(msprintf(_("%s: Wrong type for argument #%d: Integer array or Polynomial expected.\n"), "lcm", 1));
     end
 
+    if type(p)==1 then
+        if floor(p)<>p then
+            error(msprintf(_("%s: Wrong type for argument #%d: Integer array or Polynomial expected.\n"), "lcm", 1));
+        else
+            p = iconvert(p,4);
+        end
+    end
+
     if type(p)==8 then
         if argn(1)==2 then [p, fact] = %i_lcm(p), else p = %i_lcm(p), end
         return
index 61c2ce2..1a295ae 100644 (file)
 // Run with test_run('polynomials', 'bug_12679', ['no_check_error_output'])
 ////////////////// gcd
 // Normal behavior, with polynomials
-s = poly(0, 's');
+s = poly(0, "s");
 p = [s, s*(s+1)^2, 2*s^2+s^3];
 [pgcd, u] = gcd(p);
 assert_checkequal(p*u, [0 0 s]);
 // Complex polynomials should yield an error
 // Normal behavior, with integers
-V = int32([2^2*3^5, 2^3*3^2, 2^2*3^4*5]);
+V = [2^2*3^5 2^3*3^2 2^2*3^4*5];
+V_int = int32(V);
 [thegcd, U] = gcd(V);
+[thegcd, U_int] = gcd(V);
 assert_checkequal(V*U, int32([0 0 36]));
+assert_checkequal(V_int*U_int, int32([0 0 36]));
 assert_checkequal(gcd(uint8([15 20])), uint8(5));
 assert_checkequal(gcd([iconvert(15, 4) iconvert(20, 4)]), int32(5));
 assert_checkequal(gcd(iconvert([15 20], 4)), int32(5));
-// Trying to use doubles should yield an error
+// Trying to use booleans, strings or decimals should yield an error
 refMsg2 = msprintf(_("%s: Wrong type for argument #%d: Integer array or Polynomial expected.\n"), "gcd", 1);
-assert_checkerror("gcd([15 20]);", refMsg2);
+assert_checkerror("gcd(%t);", refMsg2);
+assert_checkerror("gcd(1.5);", refMsg2);
+assert_checkerror("gcd(""string"");", refMsg2);
 ////////////////// lcm
 // Normal behavior, with polynomials
-s = poly(0, 's');
+s = poly(0, "s");
 p = [s, s*(s+1)^2, s^2*(s+2)];
 [pp, fact] = lcm(p);
 assert_checkequal(pp, [2*s^2 + 5*s^3 + 4*s^4 + s^5]);
 // Normal behavior, with integers
-V = int32([2^2*3^5, 2^3*3^2, 2^2*3^4*5]);
+V = [2^2*3^5 2^3*3^2 2^2*3^4*5];
+V_int = int32(V);
 assert_checkequal(lcm(V), int32(9720));
-// Trying to use doubles should yield an error
+assert_checkequal(lcm(V_int), int32(9720));
+// Trying to use booleans, strings or decimals should yield an error
 refMsg4 = msprintf(_("%s: Wrong type for argument #%d: Integer array or Polynomial expected.\n"), "lcm", 1);
-assert_checkerror("lcm([15 20]);", refMsg4);
+assert_checkerror("lcm(%t);", refMsg4);
+assert_checkerror("lcm(1.5);", refMsg4);
+assert_checkerror("lcm(""string"");", refMsg4);
index f30eeaf..88f98dd 100644 (file)
 
 ////////////////// gcd
 // Normal behavior, with polynomials
-s = poly(0, 's');
+s = poly(0, "s");
 p = [s, s*(s+1)^2, 2*s^2+s^3];
 [pgcd, u] = gcd(p);
 assert_checkequal(p*u, [0 0 s]);
 // Complex polynomials should yield an error
 
 // Normal behavior, with integers
-V = int32([2^2*3^5, 2^3*3^2, 2^2*3^4*5]);
+V = [2^2*3^5 2^3*3^2 2^2*3^4*5];
+V_int = int32(V);
 [thegcd, U] = gcd(V);
+[thegcd, U_int] = gcd(V);
 assert_checkequal(V*U, int32([0 0 36]));
+assert_checkequal(V_int*U_int, int32([0 0 36]));
 assert_checkequal(gcd(uint8([15 20])), uint8(5));
 assert_checkequal(gcd([iconvert(15, 4) iconvert(20, 4)]), int32(5));
 assert_checkequal(gcd(iconvert([15 20], 4)), int32(5));
-// Trying to use doubles should yield an error
+// Trying to use booleans, strings or decimals should yield an error
 refMsg2 = msprintf(_("%s: Wrong type for argument #%d: Integer array or Polynomial expected.\n"), "gcd", 1);
-assert_checkerror("gcd([15 20]);", refMsg2);
+assert_checkerror("gcd(%t);", refMsg2);
+assert_checkerror("gcd(1.5);", refMsg2);
+assert_checkerror("gcd(""string"");", refMsg2);
 
 
 ////////////////// lcm
 // Normal behavior, with polynomials
-s = poly(0, 's');
+s = poly(0, "s");
 p = [s, s*(s+1)^2, s^2*(s+2)];
 [pp, fact] = lcm(p);
 assert_checkequal(pp, [2*s^2 + 5*s^3 + 4*s^4 + s^5]);
 
 // Normal behavior, with integers
-V = int32([2^2*3^5, 2^3*3^2, 2^2*3^4*5]);
+V = [2^2*3^5 2^3*3^2 2^2*3^4*5];
+V_int = int32(V);
 assert_checkequal(lcm(V), int32(9720));
-// Trying to use doubles should yield an error
+assert_checkequal(lcm(V_int), int32(9720));
+// Trying to use booleans, strings or decimals should yield an error
 refMsg4 = msprintf(_("%s: Wrong type for argument #%d: Integer array or Polynomial expected.\n"), "lcm", 1);
-assert_checkerror("lcm([15 20]);", refMsg4);
+assert_checkerror("lcm(%t);", refMsg4);
+assert_checkerror("lcm(1.5);", refMsg4);
+assert_checkerror("lcm(""string"");", refMsg4);