* Bug 15017 fixed: lcm() for int64 uint64 + improved 83/20183/7
Samuel GOUGEON [Sun, 24 Jun 2018 23:46:43 +0000 (01:46 +0200)]
  http://bugzilla.scilab.org/15017

  PDF page: http://bugzilla.scilab.org/attachment.cgi?id=4744

Change-Id: I6470e48488a9e3ce513b2245d18264477e085240

scilab/CHANGES.md
scilab/modules/elementary_functions/help/en_US/discrete/lcm.xml
scilab/modules/elementary_functions/help/fr_FR/discrete/lcm.xml
scilab/modules/elementary_functions/help/ja_JP/discrete/lcm.xml [deleted file]
scilab/modules/elementary_functions/help/pt_BR/discrete/lcm.xml
scilab/modules/elementary_functions/help/ru_RU/discrete/lcm.xm [new file with mode: 0644]
scilab/modules/polynomials/macros/lcm.sci
scilab/modules/polynomials/tests/unit_tests/lcm.tst

index 47fd5ae..4c9ec77 100644 (file)
@@ -222,8 +222,11 @@ input and output arguments.
 * The console `File => Open a file` menu allows now to open xcos, zcos, scg or lib files with the proper Scilab component, and other files with the proper OS application. All files were opened in Scinotes and could freeze it.
 * `size` is now overloadable for `tlist` lists, as it already could for `mlist` lists.
 * For arrays of cells or structures, `length` now returns their number of elements.
-* `gcd` now accepts `int64` and `uint64` integers. The input can now be an array instead of a row vector.
-* `gcd` and `lcm` of integers now always return a positive result.
+* `gcd` and `lcm`
+   - now accept `int64` and `uint64` integers.
+   - For input integers, the result is now always positive.
+   - The input can now be an array instead of a row vector.
+* `lcm` of some integers now returns decimal integers instead of int32.
 * `cat` has been rewritten. It is now fast and can process heavy arrays at high dimensions.
 * Warnings from `fplot3d1` called without an option were removed.
 * `whereis` has been upgraded:
@@ -252,7 +255,7 @@ Help pages:
   `colordef`, `matrix`, `coffg`, `diag`, `speye`, `sparse`, `recursionlimit`, `for`, `fileinfo`, `end`, `iconvert`, `Globalproperty`, `unique`, `intdec`, `plus`, `minus`
 * rewritten: `consolebox`, `double`, `isoview`, `pixel_drawing_mode`, `householder`, `or`, `|,||`,
  `and`, `&,&&`, `format`, `type`, `typeof`, `brackets`, `setlanguage`, `sleep`, `isinf`, `unique`,
- `bitor`, `bitxor`, `bitand`, `macr2tree`, `geomean`, `clf`, `getPreferencesValue`, `gcd`, `isglobal`,
+ `bitor`, `bitxor`, `bitand`, `macr2tree`, `geomean`, `clf`, `getPreferencesValue`, `gcd`, `lcm`, `isglobal`,
  `whereis`, `mode`, `%onprompt`, `toeplitz`, `param3d`, `param3d1`, `argn`,
  `mtlb_int8`, `mtlb_int16`, `mtlb_int32`, `mtlb_int64`, `mtlb_uint8`, `mtlb_uint16`, `mtlb_uint32`, `mtlb_uint64`, `intersect`,
  `load`
@@ -432,6 +435,7 @@ Known issues
 * [#14990](http://bugzilla.scilab.org/show_bug.cgi?id=14990): The example of Xcos diagram on the NEGTOPOS_f help page was distorted.
 * [#15091](http://bugzilla.scilab.org/show_bug.cgi?id=15091): `translatepaths()` was KO.
 * [#15092](http://bugzilla.scilab.org/show_bug.cgi?id=15092): Scalar variable was resized as a column vector instead of row.
+* [#15017](http://bugzilla.scilab.org/show_bug.cgi?id=15017): `lcm` did not support int64 and uint64 input integers. Input integers had to be in a row instead of any matrix. For input decimal integers, results were int32 encoded.
 * [#15115](http://bugzilla.scilab.org/show_bug.cgi?id=15115): Tabs order in SciNotes was incorrect when opening file and restoring session.
 * [#15182](http://bugzilla.scilab.org/show_bug.cgi?id=15182): The result of `a.*.b` with mixed integer/decimal operands introduced in Scilab 6 returned some doubles instead of integers, inconsistently wrt the `*` and `.*` products.
 * [#15263](http://bugzilla.scilab.org/show_bug.cgi?id=15263): Assignments in an array of structures often overwrote some untargeted elements.
index 398e737..01140e8 100644 (file)
@@ -2,6 +2,7 @@
 <!--
  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
  * Copyright (C) 2006-2008 - INRIA
+ * Copyright (C) 2018 - Samuel GOUGEON
  *
  * Copyright (C) 2012 - 2016 - Scilab Enterprises
  *
@@ -13,6 +14,7 @@
  * along with this program.
  *
  -->
+<!--  module: polynomials  -->
 <refentry xmlns="http://docbook.org/ns/docbook" xmlns:xlink="http://www.w3.org/1999/xlink"
           xmlns:svg="http://www.w3.org/2000/svg" xmlns:mml="http://www.w3.org/1998/Math/MathML"
           xmlns:db="http://docbook.org/ns/docbook" xmlns:scilab="http://www.scilab.org"
                 <term>p</term>
                 <listitem>
                     <para>
-                        a polynomial row vector <literal>p = [p1, ..., pn]</literal> (type equal to 2) or
-                        an integer row vector (type equal to 1 or 8).
+                        matrix of polynomials (type 2), or of decimal or encoded integers (types 1 or 8).
                     </para>
                 </listitem>
             </varlistentry>
             <varlistentry>
-                <term>fact</term>
+                <term>pp</term>
                 <listitem>
-                    <para>a polynomial vector or an integer vector.</para>
+                    <para>
+                        a polynomial or a decimal integer: Positive Least Common Multiple of
+                        <varname>p</varname> components.
+                    </para>
                 </listitem>
             </varlistentry>
             <varlistentry>
-                <term>pp</term>
+                <term>fact</term>
                 <listitem>
-                    <para>a polynomial or an integer.</para>
+                    <para>
+                        matrix of polynomials, or of decimal integers (type 1), with the size of
+                        <varname>p</varname>, such that <literal>fact(i)= pp./p(i)</literal>.
+                    </para>
                 </listitem>
             </varlistentry>
         </variablelist>
     <refsection>
         <title>Description</title>
         <para>
-            <code>pp = lcm(p)</code> computes the lcm <varname>pp</varname> of polynomial vector <varname>p</varname>.
+            <literal>pp=lcm(p)</literal> computes the LCM <varname>pp</varname> of <varname>p</varname>
+            components.
         </para>
         <para>
-            <code>[pp, fact] = lcm(p)</code> computes in addition the vector <varname>fact</varname>
-            such that <literal>p.*fact = pp*ones(p)</literal>.
+          If <literal>p</literal> are polynomials, <literal>pp</literal> is a polynomial and
+          <varname>fact</varname> is also a matrix of polynomials.
         </para>
         <para>
-          If <literal>p</literal> is a set of integers with some negative ones, the returned value
-          <literal>pp</literal> of their LCM is always positive.
-        </para>
-        <para>
-            If <literal>p</literal> is an array of decimal integers, they are priorly converted
-            into <literal>int32</literal> before processing.
+          If <literal>p</literal> is a set of integers,
+            <itemizedlist>
+                <listitem>
+                    if they are encoded integers, they are then converted into decimal integers
+                    before processing.
+                </listitem>
+                <listitem>
+                    Any int64 or uint64 input |integers| > 2^53 will be truncated and lcm()
+                    will return a wrong result.
+                </listitem>
+                <listitem>
+                    If some of them are negative, the returned value <literal>pp</literal>
+                    of their LCM is always positive.
+                </listitem>
+            </itemizedlist>
         </para>
         <para>
             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>.
+            through <literal>p = inv_coeff(p, 0)</literal>.
         </para>
     </refsection>
     <refsection>
         <title>Examples</title>
+        <para>With polynomials:</para>
         <programlisting role="example"><![CDATA[
-// Polynomial case
 s = %s;
-p = [s s*(s+1)^2 s^2*(s+2)];
-[pp,fact] = lcm(p);
-p.*fact, pp
+p = [s , s*(s+1) , s^2-1]
+[pp, fact] = lcm(p)
+p .* fact == pp
+ ]]></programlisting>
+    <screen><![CDATA[
+--> p = [s , s*(s+1) , s^2-1]
+ p  =
+           2       2
+   s   s +s   -1 +s
 
-// Integer case
-V = int32([2^2*3^5, 2^3*3^2,2^2*3^4*5]);
-lcm(V)
+--> [pp, fact] = lcm(p)
+ fact  =
+       2
+  -1 +s   -1 +s   s
 
-// Double case
-V = [2^2*3^5, 2^3*3^2,2^2*3^4*5];
-lcm(V)
+ pp  =
+       3
+  -s +s
+
+--> p .* fact == pp
+ ans  =
+  T T T
+]]></screen>
+    <para>With encoded integers:</para>
+    <programlisting role="example"><![CDATA[
+// Prime numbers: 2  3  5  7  11  13  17  19  23  29  31  37  41  43  47
+V = int16([2*3 3*7 ; 7*5  3*5])
+[pp, fact] = lcm(V)
+ ]]></programlisting>
+    <screen><![CDATA[
+--> V = int16([2*3 3*7 ; 7*5  3*5])
+ V  =
+   6  21
+  35  15
+
+--> [pp, fact] = lcm(V)
+ pp  =
+   210.
+
+ fact  =
+   35.   10.
+   6.    14.
+]]></screen>
+    <para>With decimal integers:</para>
+    <programlisting role="example"><![CDATA[
+V = [2*3 3*7 ; 7*5  3*5]
+[pp, fact] = lcm(V)
+ ]]></programlisting>
+    <para>With big integers:</para>
+    <programlisting role="example"><![CDATA[
+V = [3*2^51 , 3*5]
+[pp, fact] = lcm(V)    // OK
+ ]]></programlisting>
+    <screen><![CDATA[
+--> V = [3*2^51 , 3*5]
+ V  =
+   6.755D+15   15.
+
+--> [pp, fact] = lcm(V)
+ fact  =
+   5.   2.252D+15
+
+ pp  =
+   3.378D+16
+]]></screen>
+    <para>
+        When the numerical encoding is overflown, truncature occurs and results turn wrong:
+    </para>
+    <programlisting role="example"><![CDATA[
+V = [3*2^52 , 3*5]
+[pp, fact] = lcm(V)
  ]]></programlisting>
+    <screen><![CDATA[
+--> V = [3*2^52 , 3*5]
+ V  =
+   1.351D+16   15.
+
+--> [pp, fact] = lcm(V)
+ fact  =
+   15.   1.351D+16
+
+ pp  =
+   2.027D+17
+]]></screen>
     </refsection>
     <refsection role="see also">
         <title>See also</title>
@@ -104,6 +193,9 @@ lcm(V)
             <member>
                 <link linkend="bezout">bezout</link>
             </member>
+            <member>
+                <link linkend="factor">factor</link>
+            </member>
         </simplelist>
     </refsection>
     <refsection role="history">
@@ -115,6 +207,26 @@ lcm(V)
                    For input integers possibly negative, the returned LCM is now always positive.
                 </revdescription>
             </revision>
+            <revision>
+                <revnumber>6.0.2</revnumber>
+                <revdescription>
+                    <itemizedlist>
+                        <listitem>
+                            int64 and uint64 input encoded integers are now supported.
+                        </listitem>
+                        <listitem>
+                            <varname>p</varname> can now be a matrix of any shape, not necessarily
+                            a row.
+                        </listitem>
+                        <listitem>
+                            When <varname>p</varname> is a matrix of encoded or decimal integers,
+                            computations are now performed in floating point instead of int32 format.
+                            <varname>pp</varname> and <varname>fact</varname> are now decimal
+                            integers (instead of int32 integers).
+                        </listitem>
+                    </itemizedlist>
+                </revdescription>
+            </revision>
         </revhistory>
     </refsection>
 </refentry>
index 67340e9..f521678 100644 (file)
@@ -1,5 +1,24 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<refentry xmlns="http://docbook.org/ns/docbook" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:svg="http://www.w3.org/2000/svg" xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:db="http://docbook.org/ns/docbook" xmlns:scilab="http://www.scilab.org" xml:lang="fr" xml:id="lcm">
+<!--
+ * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+ * Copyright (C) 2006-2008 - INRIA
+ * Copyright (C) 2018 - Samuel GOUGEON
+ *
+ * Copyright (C) 2012 - 2016 - Scilab Enterprises
+ *
+ * This file is hereby licensed under the terms of the GNU GPL v2.0,
+ * pursuant to article 5.3.4 of the CeCILL v.2.1.
+ * This file was originally licensed under the terms of the CeCILL v2.1,
+ * and continues to be available under such terms.
+ * For more information, see the COPYING file which you should have received
+ * along with this program.
+ *
+ -->
+<!--  module: polynomials  -->
+<refentry xmlns="http://docbook.org/ns/docbook" xmlns:xlink="http://www.w3.org/1999/xlink"
+        xmlns:svg="http://www.w3.org/2000/svg" xmlns:mml="http://www.w3.org/1998/Math/MathML"
+        xmlns:db="http://docbook.org/ns/docbook" xmlns:scilab="http://www.scilab.org"
+        xml:lang="fr" xml:id="lcm">
     <refnamediv>
         <refname>lcm</refname>
         <refpurpose>Plus petit multiple commun (PPCM) de polynômes ou d'entiers
             <varlistentry>
                 <term>p</term>
                 <listitem>
-                    <para>vecteur de polynômes (type égal à 2) ou d'entiers décimaux ou encodés
-                      (type 1 ou 8).
+                    <para>
+                        matrice de polynômes (type égal à 2) ou d'entiers décimaux ou encodés
+                        (types 1 ou 8).
                     </para>
                 </listitem>
             </varlistentry>
             <varlistentry>
-                <term>fact</term>
+                <term>pp</term>
                 <listitem>
-                    <para>vecteur de polynômes ou d'entiers
+                    <para>
+                        polynôme ou entier décimal: PPCM positif des éléments de p.
                     </para>
                 </listitem>
             </varlistentry>
             <varlistentry>
-                <term>pp</term>
+                <term>fact</term>
                 <listitem>
-                    <para>polynôme ou entier
+                    <para>
+                        matrice de polynômes ou d'entiers décimaux, de tailles identiques à celle
+                        de <varname>p</varname>, telle que <literal>fact(i)= pp./p(i)</literal>.
                     </para>
                 </listitem>
             </varlistentry>
     <refsection>
         <title>Description</title>
         <para>
-            <literal>pp = lcm(p)</literal> calcule le PPCM <literal>pp</literal>  du vecteur
-            <literal>p</literal> au sens des polynômes ou des entiers.
+            <literal>pp = lcm(p)</literal> calcule le PPCM <literal>pp</literal>  des éléments de
+            <literal>p</literal>, au sens des polynômes ou des entiers.
         </para>
         <para>
-            <literal>[pp, fact] = lcm(p)</literal> calcule de plus le vecteur <literal>fact</literal>
-            tel que <literal>p .* fact = pp * ones(p)</literal>
+            <literal>[pp, fact] = lcm(p)</literal> calcule et produit en outre la matrice
+            <literal>fact</literal> des facteurs tels que <literal>p(i) * fact(i) = pp</literal>
         </para>
         <para>
-          Si <literal>p</literal> est une matrice d'entiers dont certains sont négatifs,
-          le PPCM <literal>pp</literal> retourné est toujours positif.
-        </para>
-        <para>
-            Si <literal>p</literal> est une matrice d'entiers décimaux, elle est préalablement
-            convertie en entiers <literal>int32</literal> avant les calculs.
+          Si <literal>p</literal> sont des entiers,
+            <itemizedlist>
+                <listitem>
+                    s'il s'agit d'entiers encodés, ils sont préalablement convertis en entiers
+                    décimaux avant les calculs.
+                </listitem>
+                <listitem>
+                    S'il s'agit d'entiers encodés en int64 ou uint64, les |valeurs| d'entrée > 2^53
+                    seront tronquées par la conversion en décimaux et le résultat
+                    <literal>p</literal> sera erroné.
+                </listitem>
+                <listitem>
+                    si un ou plusieurs éléments de <literal>p</literal> sont négatifs, le
+                    résultat <literal>pp</literal> sera toujours positif.
+                </listitem>
+            </itemizedlist>
         </para>
         <para>
             Le plus petit commun multiple d'une matrice <literal>p</literal> de réels peut
     </refsection>
     <refsection>
         <title>Exemples</title>
+        <para>Avec des polynômes :</para>
         <programlisting role="example"><![CDATA[
-// Cas des polynômes
 s = %s;
-p = [s s*(s+1)^2 s^2*(s+2)];
-[pp,fact] = lcm(p);
-p.*fact, pp
+p = [s , s*(s+1) , s^2-1]
+[pp, fact] = lcm(p)
+p .* fact == pp
+ ]]></programlisting>
+    <screen><![CDATA[
+--> p = [s , s*(s+1) , s^2-1]
+ p  =
+           2       2
+   s   s +s   -1 +s
+
+--> [pp, fact] = lcm(p)
+ fact  =
+       2
+  -1 +s   -1 +s   s
 
-// Cas des entiers
-V = int32([2^2*3^5, 2^3*3^2,2^2*3^4*5]);
-lcm(V)
+ pp  =
+       3
+  -s +s
 
-// Cas des doubles
-V = [2^2*3^5, 2^3*3^2,2^2*3^4*5];
-lcm(V)
+--> p .* fact == pp
+ ans  =
+  T T T
+]]></screen>
+    <para>Avec des entiers encodés :</para>
+    <programlisting role="example"><![CDATA[
+// Nombres premiers : 2  3  5  7  11  13  17  19  23  29  31  37  41  43  47
+V = int16([2*3 3*7 ; 7*5  3*5])
+[pp, fact] = lcm(V)
  ]]></programlisting>
+    <screen><![CDATA[
+--> V = int16([2*3 3*7 ; 7*5  3*5])
+ V  =
+   6  21
+  35  15
+
+--> [pp, fact] = lcm(V)
+ pp  =
+   210.
+
+ fact  =
+   35.   10.
+   6.    14.
+]]></screen>
+    <para>Avec des entiers décimaux :</para>
+    <programlisting role="example"><![CDATA[
+V = [2*3 3*7 ; 7*5  3*5]
+[pp, fact] = lcm(V)
+ ]]></programlisting>
+    <para>Avec des grands entiers </para>
+    <programlisting role="example"><![CDATA[
+V = [3*2^51 , 3*5]
+[pp, fact] = lcm(V)    // OK
+ ]]></programlisting>
+    <screen><![CDATA[
+--> V = [3*2^51 , 3*5]
+ V  =
+   6.755D+15   15.
+
+--> [pp, fact] = lcm(V)
+ fact  =
+   5.   2.252D+15
+
+ pp  =
+   3.378D+16
+]]></screen>
+    <para>
+        Lorsque les valeurs d'éntrée débordent leur encodage numérique, elles sont tronquées et
+        les résultats deviennent erronés :
+    </para>
+    <programlisting role="example"><![CDATA[
+V = [3*2^52 , 3*5]
+[pp, fact] = lcm(V)
+ ]]></programlisting>
+    <screen><![CDATA[
+--> V = [3*2^52 , 3*5]
+ V  =
+   1.351D+16   15.
+
+--> [pp, fact] = lcm(V)
+ fact  =
+   15.   1.351D+16
+
+ pp  =
+   2.027D+17
+]]></screen>
     </refsection>
     <refsection role="see also">
         <title>Voir aussi</title>
@@ -90,6 +196,9 @@ lcm(V)
             <member>
                 <link linkend="bezout">bezout</link>
             </member>
+            <member>
+                <link linkend="factor">factor</link>
+            </member>
         </simplelist>
     </refsection>
     <refsection role="history">
@@ -102,6 +211,26 @@ lcm(V)
                    toujours la valeur absolue du PPCM.
                 </revdescription>
             </revision>
+            <revision>
+                <revnumber>6.0.2</revnumber>
+                <revdescription>
+                    <itemizedlist>
+                        <listitem>
+                            <varname>p</varname> peut désormais être des entiers int64 ou uint64
+                            encodés sur 64 bits.
+                        </listitem>
+                        <listitem>
+                            <varname>p</varname> peut désormais être une matrice de format
+                            quelconque, non nécessairement un vecteur ligne.
+                        </listitem>
+                        <listitem>
+                            Lorsque <varname>p</varname> est une matrice d'entiers encodés ou
+                            décimaux, <varname>pp</varname> et <varname>fact</varname> sont
+                            désormais des entiers décimaux (au lieu d'entiers encodés int32).
+                        </listitem>
+                    </itemizedlist>
+                </revdescription>
+            </revision>
         </revhistory>
     </refsection>
 </refentry>
diff --git a/scilab/modules/elementary_functions/help/ja_JP/discrete/lcm.xml b/scilab/modules/elementary_functions/help/ja_JP/discrete/lcm.xml
deleted file mode 100644 (file)
index 3637437..0000000
+++ /dev/null
@@ -1,179 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-
-<!--
- * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
- * Copyright (C) 2006-2008 - INRIA
- *
- * Copyright (C) 2012 - 2016 - Scilab Enterprises
- *
- * This file is hereby licensed under the terms of the GNU GPL v2.0,
- * pursuant to article 5.3.4 of the CeCILL v.2.1.
- * This file was originally licensed under the terms of the CeCILL v2.1,
- * and continues to be available under such terms.
- * For more information, see the COPYING file which you should have received
- * along with this program.
- *
- -->
-
-<refentry xmlns="http://docbook.org/ns/docbook" xmlns:xlink="http://www.w3.org/1999/xlink"
-          xmlns:svg="http://www.w3.org/2000/svg" xmlns:mml="http://www.w3.org/1998/Math/MathML"
-          xmlns:db="http://docbook.org/ns/docbook" xmlns:scilab="http://www.scilab.org"
-          xml:lang="ja" xml:id="lcm">
-
-    <refnamediv>
-
-        <refname>lcm</refname>
-
-        <refpurpose>最小公倍数</refpurpose>
-
-    </refnamediv>
-
-    <refsynopsisdiv>
-
-        <title>呼び出し手順</title>
-
-        <synopsis>
-           pp = lcm(p)
-          [pp, fact] = lcm(p)
-        </synopsis>
-
-    </refsynopsisdiv>
-
-    <refsection>
-
-        <title>引数</title>
-
-        <variablelist>
-
-            <varlistentry>
-
-                <term>p</term>
-
-                <listitem>
-
-                    <para>
-
-                        多項式行ベクトル <literal>p = [p1, ..., pn]</literal> (2型) または
-
-                        整数行ベクトル (8型).
-
-                    </para>
-
-                </listitem>
-
-            </varlistentry>
-
-            <varlistentry>
-
-                <term>fact</term>
-
-                <listitem>
-
-                    <para>多項式ベクトルまたは整数ベクトル</para>
-
-                </listitem>
-
-            </varlistentry>
-
-            <varlistentry>
-
-                <term>pp</term>
-
-                <listitem>
-
-                    <para>多項式または整数</para>
-
-                </listitem>
-
-            </varlistentry>
-
-        </variablelist>
-
-    </refsection>
-
-    <refsection>
-
-        <title>説明</title>
-
-        <para>
-
-            <code>pp = lcm(p)</code> は,多項式ベクトル<varname>p</varname>
-
-            の最小公倍数<varname>pp</varname>を計算します.
-
-        </para>
-
-        <para>
-
-            <code>[pp, fact] = lcm(p)</code> は,これに加えて以下のような
-
-            ベクトル<varname>fact</varname>を計算します <literal>p .* fact = pp * ones(p)</literal>
-        </para>
-        <para>
-          If <literal>p</literal> is a set of integers with some negative ones, the returned value
-          <literal>pp</literal> of their LCM is always positive.
-        </para>
-        <para>
-            If <literal>p</literal> is an array of decimal integers, they are priorly converted
-            into <literal>int32</literal> before processing.
-        </para>
-        <para>
-            実数の配列<literal>p</literal>の最小公倍数は,
-            <literal>lcm</literal>をコールする前に<code>p = inv_coeff(p, 0)</code>により
-            多項式に変換することにより得られます.
-        </para>
-
-    </refsection>
-
-    <refsection>
-
-        <title>例</title>
-
-        <programlisting role="example"><![CDATA[
-//多項式の場合
-s=poly(0,'s');
-p=[s,s*(s+1)^2,s^2*(s+2)];
-[pp,fact]=lcm(p);
-p.*fact, pp
-//整数の場合
-V=int32([2^2*3^5, 2^3*3^2,2^2*3^4*5]);
-lcm(V)
- ]]></programlisting>
-
-    </refsection>
-
-    <refsection role="see also">
-
-        <title>参照</title>
-
-        <simplelist type="inline">
-
-            <member>
-
-                <link linkend="gcd">gcd</link>
-
-            </member>
-
-            <member>
-
-                <link linkend="bezout">bezout</link>
-
-            </member>
-
-        </simplelist>
-
-    </refsection>
-    <refsection role="history">
-        <title>履歴</title>
-        <revhistory>
-            <revision>
-                <revnumber>6.0.1</revnumber>
-                <revdescription>
-                   For input integers possibly negative, the returned LCM is now always positive.
-                </revdescription>
-            </revision>
-        </revhistory>
-    </refsection>
-
-</refentry>
-
index afb59e2..f596b49 100644 (file)
  * along with this program.
  *
  -->
+<!--  module: polynomials  -->
 <refentry xmlns="http://docbook.org/ns/docbook" xmlns:xlink="http://www.w3.org/1999/xlink"
         xmlns:svg="http://www.w3.org/2000/svg" xmlns:ns4="http://www.w3.org/1999/xhtml"
         xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:db="http://docbook.org/ns/docbook"
         xmlns:scilab="http://www.scilab.org" xml:id="lcm" xml:lang="pt">
     <refnamediv>
         <refname>lcm</refname>
-        <refpurpose>mínimo múltiplo comum</refpurpose>
+        <refpurpose>mínimo múltiplo comum (positivo) de inteiros ou de polinômios</refpurpose>
     </refnamediv>
     <refsynopsisdiv>
         <title> Seqüência de Chamamento </title>
             <varlistentry>
                 <term>p</term>
                 <listitem>
-                    <para>vetor de polinômios </para>
+                    <para>
+                        matriz de polinômios (tipo 2), ou de inteiros decimais ou codificados
+                        (tipos 1 ou 8).
+                    </para>
                 </listitem>
             </varlistentry>
             <varlistentry>
-                <term>fact</term>
+                <term>pp</term>
                 <listitem>
-                    <para>vetor de polinômios ou inteiros (tipo igual a 8)</para>
+                    <para>
+                        um polinomial ou um inteiro decimal : Mínimo positivo múltiplo comum de
+                         Componentes <varname>p</varname>.
+                    </para>
                 </listitem>
             </varlistentry>
             <varlistentry>
-                <term>pp</term>
+                <term>fact</term>
                 <listitem>
-                    <para>polinômio ou inteiro</para>
+                    <para>
+                        matriz de polinômios ou de inteiros decimais (tipo 1), com os tamanhos de
+                         <varname>p</varname>, tal que <literal>fact(i)=pp./p(i)</literal>.
+                    </para>
                 </listitem>
             </varlistentry>
         </variablelist>
     <refsection>
         <title>Descrição</title>
         <para>
-            <literal>pp=lcm(p)</literal> computa o MMC <literal>pp</literal> do
-            vetor de polinômios <literal>p</literal>.
+            <literal>pp=lcm(p)</literal> computa o MMC <literal>pp</literal> do matriz de
+            polinômios <literal>p</literal>.
         </para>
         <para>
-            <literal>[pp,fact]=lcm(p)</literal> computa, ainda, o vetor
-            <literal>fact</literal> tal que <literal>p.*fact=pp*ones(p)</literal>
+          Se <literal>p</literal> são polinômios, <literal>pp</literal> é um polinômio e
+           <varname>fact</varname> também é uma matriz de polinômios.
         </para>
         <para>
-          If <literal>p</literal> is a set of integers with some negative ones, the returned value
-          <literal>pp</literal> of their LCM is always positive.
+          Se <literal>p</literal> são inteiros,
+            <itemizedlist>
+                <listitem>
+                    inteiros codificados são convertidos em inteiros decimais antes do processamento.
+                </listitem>
+                <listitem>
+                    Qualquer entrada int64 ou uint64 input |inteiros| > 2^53 será truncado e lcm()
+                    retornará um resultado errado.
+                </listitem>
+                <listitem>
+                    se algum deles for negativo, o valor de retorno <literal>pp</literal> é sempre
+                    positivo.
+                </listitem>
+            </itemizedlist>
         </para>
         <para>
-            If <literal>p</literal> is an array of decimal integers, they are priorly converted
-            into <literal>int32</literal> before processing.
+            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 <literal>p = inv_coeff(p, 0)</literal>.
         </para>
     </refsection>
     <refsection>
         <title>Exemplos</title>
+        <para>Com polinômios :</para>
         <programlisting role="example"><![CDATA[
-//caso polinomial
-s=poly(0,'s');
-p=[s,s*(s+1)^2,s^2*(s+2)];
-[pp,fact]=lcm(p);
-p.*fact, pp
+s = %s;
+p = [s , s*(s+1) , s^2-1]
+[pp, fact] = lcm(p)
+p .* fact == pp
+ ]]></programlisting>
+    <screen><![CDATA[
+--> p = [s , s*(s+1) , s^2-1]
+ p  =
+           2       2
+   s   s +s   -1 +s
+
+--> [pp, fact] = lcm(p)
+ fact  =
+       2
+  -1 +s   -1 +s   s
 
-//caso inteiro
-V=int32([2^2*3^5, 2^3*3^2,2^2*3^4*5]);
-lcm(V)
+ pp  =
+       3
+  -s +s
+
+--> p .* fact == pp
+ ans  =
+  T T T
+]]></screen>
+    <para>Com inteiros codificados :</para>
+    <programlisting role="example"><![CDATA[
+// Prime numbers: 2  3  5  7  11  13  17  19  23  29  31  37  41  43  47
+V = int16([2*3 3*7 ; 7*5  3*5])
+[pp, fact] = lcm(V)
  ]]></programlisting>
+    <screen><![CDATA[
+--> V = int16([2*3 3*7 ; 7*5  3*5])
+ V  =
+   6  21
+  35  15
+
+--> [pp, fact] = lcm(V)
+ pp  =
+   210.
+
+ fact  =
+   35.   10.
+   6.    14.
+]]></screen>
+    <para>Com números inteiros decimais :</para>
+    <programlisting role="example"><![CDATA[
+V = [2*3 3*7 ; 7*5  3*5]
+[pp, fact] = lcm(V)
+ ]]></programlisting>
+    <para>Com grandes inteiros:</para>
+    <programlisting role="example"><![CDATA[
+V = [3*2^51 , 3*5]
+[pp, fact] = lcm(V)    // OK
+ ]]></programlisting>
+    <screen><![CDATA[
+--> V = [3*2^51 , 3*5]
+ V  =
+   6.755D+15   15.
+
+--> [pp, fact] = lcm(V)
+ fact  =
+   5.   2.252D+15
+
+ pp  =
+   3.378D+16
+]]></screen>
+    <para>
+        Quando a codificação numérica é excedida, truncatura ocorre e os resultados ficam errados :
+    </para>
+    <programlisting role="example"><![CDATA[
+V = [3*2^52 , 3*5]
+[pp, fact] = lcm(V)
+ ]]></programlisting>
+    <screen><![CDATA[
+--> V = [3*2^52 , 3*5]
+ V  =
+   1.351D+16   15.
+
+--> [pp, fact] = lcm(V)
+ fact  =
+   15.   1.351D+16
+
+ pp  =
+   2.027D+17
+]]></screen>
     </refsection>
-    <refsection>
-        <title> Ver Também </title>
+    <refsection role="see also">
+        <title>Ver Também</title>
         <simplelist type="inline">
             <member>
                 <link linkend="gcd">gcd</link>
@@ -93,6 +192,9 @@ lcm(V)
             <member>
                 <link linkend="bezout">bezout</link>
             </member>
+            <member>
+                <link linkend="factor">factor</link>
+            </member>
         </simplelist>
     </refsection>
     <refsection role="history">
@@ -101,7 +203,27 @@ lcm(V)
             <revision>
                 <revnumber>6.0.1</revnumber>
                 <revdescription>
-                    For input integers possibly negative, the returned LCM is now always positive.
+                   For input integers possibly negative, the returned LCM is now always positive.
+                </revdescription>
+            </revision>
+            <revision>
+                <revnumber>6.0.2</revnumber>
+                <revdescription>
+                    <itemizedlist>
+                        <listitem>
+                            int64 and uint64 input encoded integers are now supported.
+                        </listitem>
+                        <listitem>
+                            <varname>p</varname> can now be a matrix of any shape, not necessarily
+                            a row.
+                        </listitem>
+                        <listitem>
+                            When <varname>p</varname> is a matrix of encoded or decimal integers,
+                            computations are now performed in floating point instead of int32 format.
+                            <varname>pp</varname> and <varname>fact</varname> are now decimal
+                            integers (instead of int32 integers).
+                        </listitem>
+                    </itemizedlist>
                 </revdescription>
             </revision>
         </revhistory>
diff --git a/scilab/modules/elementary_functions/help/ru_RU/discrete/lcm.xm b/scilab/modules/elementary_functions/help/ru_RU/discrete/lcm.xm
new file mode 100644 (file)
index 0000000..6908926
--- /dev/null
@@ -0,0 +1,234 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+ * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+ * Copyright (C) 2006-2008 - INRIA
+ * Copyright (C) 2018 - Samuel GOUGEON
+ *
+ * Copyright (C) 2012 - 2016 - Scilab Enterprises
+ *
+ * This file is hereby licensed under the terms of the GNU GPL v2.0,
+ * pursuant to article 5.3.4 of the CeCILL v.2.1.
+ * This file was originally licensed under the terms of the CeCILL v2.1,
+ * and continues to be available under such terms.
+ * For more information, see the COPYING file which you should have received
+ * along with this program.
+ *
+ -->
+<!--  module: polynomials  -->
+<refentry xmlns="http://docbook.org/ns/docbook" xmlns:xlink="http://www.w3.org/1999/xlink"
+         xmlns:svg="http://www.w3.org/2000/svg" xmlns:mml="http://www.w3.org/1998/Math/MathML"
+         xmlns:db="http://docbook.org/ns/docbook" xmlns:scilab="http://www.scilab.org"
+         xml:lang="ru" xml:id="lcm">
+   <refnamediv>
+       <refname>lcm</refname>
+       <refpurpose>наименьшее общее кратное (положительное) целых чисел или полиномов</refpurpose>
+   </refnamediv>
+   <refsynopsisdiv>
+       <title>Синтаксис</title>
+       <synopsis>
+          pp = lcm(p)
+         [pp, fact] = lcm(p)
+       </synopsis>
+   </refsynopsisdiv>
+   <refsection>
+       <title>Аргументы</title>
+       <variablelist>
+           <varlistentry>
+               <term>p</term>
+               <listitem>
+                   <para>
+                       матрица полиномов (тип 2), или десятичных чисел или кодированных целых
+                       чисел (тип 1 или 8).
+                   </para>
+               </listitem>
+           </varlistentry>
+           <varlistentry>
+               <term>pp</term>
+               <listitem>
+                   <para>
+                       полином или десятичное целое число: положительное нименьшее общее кратное у
+                       составляющих <varname>p</varname>.
+                   </para>
+               </listitem>
+           </varlistentry>
+           <varlistentry>
+               <term>fact</term>
+               <listitem>
+                   <para>
+                       матрица полиномов или десятичных целых чисел (тип 1) с размером, как у
+                       <varname>p</varname>, такая, что <literal>fact(i)= pp./p(i)</literal>.
+                   </para>
+               </listitem>
+           </varlistentry>
+       </variablelist>
+   </refsection>
+   <refsection>
+       <title>Описание</title>
+       <para>
+           <literal>pp=lcm(p)</literal>  вычисляет НОК <varname>pp</varname> составляющих <varname>p</varname>.
+       </para>
+       <para>
+         Если <literal>p</literal> являются полиномами, то <literal>pp</literal> является полиномом и
+         <varname>fact</varname> также является матрицей полиномов.
+       </para>
+       <para>
+         Если <literal>p</literal> является массивом целых числел, то
+           <itemizedlist>
+               <listitem>
+                   если они являются кодированными целыми числами, то тогда они преобразуются
+                   в десятичные целые числи перед обработкой.
+               </listitem>
+               <listitem>
+                   Любые входные целые числа типа int64 или uint64 по модулю больше 2^53
+                   будут усечены и <literal>lcm()</literal> вернёт неверный результат.
+               </listitem>
+               <listitem>
+                   Если некоторые из них отрицательные, то возвращаемое значение <literal>pp</literal>
+                   (их НОК) будет всегда положительным.
+               </listitem>
+           </itemizedlist>
+       </para>
+       <para>
+           Намиеньшее общее кратное массива <literal>p</literal> вещественных чисел может быть
+           получено конвертированием его в полином перед вызовом <literal>lcm</literal>,
+           через <literal>p = inv_coeff(p, 0)</literal>.
+       </para>
+   </refsection>
+   <refsection>
+       <title>Примеры</title>
+       <para>С полиномами:</para>
+       <programlisting role="example"><![CDATA[
+s = %s;
+p = [s , s*(s+1) , s^2-1]
+[pp, fact] = lcm(p)
+p .* fact == pp
+]]></programlisting>
+   <screen><![CDATA[
+--> p = [s , s*(s+1) , s^2-1]
+ p  =
+           2       2
+   s   s +s   -1 +s
+
+--> [pp, fact] = lcm(p)
+ fact  =
+       2
+  -1 +s   -1 +s   s
+
+ pp  =
+       3
+  -s +s
+
+--> p .* fact == pp
+ ans  =
+  T T T
+]]></screen>
+   <para>С кодированными целыми числами:</para>
+   <programlisting role="example"><![CDATA[
+// Простые числа: 2  3  5  7  11  13  17  19  23  29  31  37  41  43  47
+V = int16([2*3 3*7 ; 7*5  3*5])
+[pp, fact] = lcm(V)
+ ]]></programlisting>
+    <screen><![CDATA[
+--> V = int16([2*3 3*7 ; 7*5  3*5])
+ V  =
+   6  21
+  35  15
+
+--> [pp, fact] = lcm(V)
+ pp  =
+   210.
+
+ fact  =
+   35.   10.
+   6.    14.
+]]></screen>
+    <para>С десятичнми целыми числами:</para>
+    <programlisting role="example"><![CDATA[
+V = [2*3 3*7 ; 7*5  3*5]
+[pp, fact] = lcm(V)
+ ]]></programlisting>
+    <para>С большими целыми числами:</para>
+    <programlisting role="example"><![CDATA[
+V = [3*2^51 , 3*5]
+[pp, fact] = lcm(V)    // OK
+ ]]></programlisting>
+    <screen><![CDATA[
+--> V = [3*2^51 , 3*5]
+ V  =
+   6.755D+15   15.
+
+--> [pp, fact] = lcm(V)
+ fact  =
+   5.   2.252D+15
+
+ pp  =
+   3.378D+16
+]]></screen>
+    <para>
+        Когда числовое кодирование переполняет разрядную сетку, происходит усечение
+        и результаты возвращаются ошибочные:
+    </para>
+    <programlisting role="example"><![CDATA[
+V = [3*2^52 , 3*5]
+[pp, fact] = lcm(V)
+ ]]></programlisting>
+    <screen><![CDATA[
+--> V = [3*2^52 , 3*5]
+ V  =
+   1.351D+16   15.
+
+--> [pp, fact] = lcm(V)
+ fact  =
+   15.   1.351D+16
+
+ pp  =
+   2.027D+17
+]]></screen>
+   </refsection>
+   <refsection role="see also">
+       <title>Смотрите также</title>
+       <simplelist type="inline">
+           <member>
+               <link linkend="gcd">gcd</link>
+           </member>
+           <member>
+               <link linkend="bezout">bezout</link>
+           </member>
+           <member>
+               <link linkend="factor">factor</link>
+           </member>
+       </simplelist>
+   </refsection>
+   <refsection role="history">
+       <title>История</title>
+       <revhistory>
+           <revision>
+               <revnumber>6.0.1</revnumber>
+               <revdescription>
+                  Для входных целых чисел, возможно отрицательных, возвращаемое МОК теперь
+                  всегда положительно.
+               </revdescription>
+           </revision>
+           <revision>
+               <revnumber>6.0.2</revnumber>
+               <revdescription>
+                   <itemizedlist>
+                       <listitem>
+                           Теперь поддерживаются входные кодированные целые числа типа int64 и uint64.
+                       </listitem>
+                       <listitem>
+                           Теперь <varname>p</varname> может быть матрицей любой формы, необязательно строка.
+                       </listitem>
+                       <listitem>
+                           Когда <varname>p</varname> является матрицей кодированных или десятичных целых
+                           чисел, то вычисления теперь выполняются в числах с плавающей запятой вместо
+                           формата int32.
+                           <varname>pp</varname> и <varname>fact</varname> теперь десятичные целые числа
+                           (вместо целых чисел типа int32).
+                       </listitem>
+                   </itemizedlist>
+               </revdescription>
+           </revision>
+       </revhistory>
+   </refsection>
+</refentry>
index f885a55..faf0a9a 100644 (file)
@@ -1,9 +1,8 @@
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
 // Copyright (C) ????-2008 - INRIA
 // Copyright (C) INRIA - Serge Steer
-// Copyright (C) 2017 - Samuel GOUGEON : http://bugzilla.scilab.org/15058
-//
 // Copyright (C) 2012 - 2016 - Scilab Enterprises
+// Copyright (C) 2017 - 2018 - Samuel GOUGEON
 //
 // This file is hereby licensed under the terms of the GNU GPL v2.0,
 // pursuant to article 5.3.4 of the CeCILL v.2.1.
 // For more information, see the COPYING file which you should have received
 // along with this program.
 
-function [p, fact] = lcm(p)
-    //p=lcm(p) computes the lcm of polynomial vector p
-    //[pp,fact]=lcm(p) computes besides the vector fact of factors
-    //such that  p.*fact=pp*ones(p)
-    //!
+function [q, fact] = lcm(p)
+    //q = lcm(p) computes the Least Common Multiple of vector p of polynomials
+    // or integers
+    //[q, fact] = lcm(p) computes the vector fact of factors such that
+    // p .* fact = q*ones(p)
 
-    if type(p)<>1 & type(p)<>2 & type(p)<>8 then
-        msg = _("%s: Wrong type for argument #%d: Integer array or Polynomial expected.\n");
-        error(msprintf(msg, "lcm", 1));
+    if ~or(type(p)==[1 2 8]) then
+        msg = _("%s: Wrong type for argument #%d: Array of integers or polynomials expected.\n")
+        error(msprintf(msg, "lcm", 1))
     end
 
-    if type(p)==1 then
-        if floor(p) <> p then
-            msg = _("%s: Wrong type for argument #%d: Integer array or Polynomial expected.\n");
-            error(msprintf(msg, "lcm", 1));
+    if  type(p)~=2
+        intype = inttype(p)
+        if type(p)==1 then
+            if floor(p)<>p
+                msg = _("%s: Wrong values for argument #%d: Integer values expected.\n")
+                error(msprintf(msg, "lcm", 1));
+            end
         else
-            p = iconvert(p, 4);
+            p = iconvert(p,0);
         end
     end
 
-    fact = 1;
-
-    // Integers:
-    if type(p)==8 then
-        if argn(1)==2 then
-            [p, fact] = %i_lcm(p);
+    // Integers
+    // --------
+    if type(p)==1 then
+        k = find(p==0)
+        if k<>[] then
+            q = 0
+            fact = zeros(p)
+            fact(k) = 1
         else
-            p = %i_lcm(p);
+            q = p(1)
+            for k = 2:size(p,"*")
+                q = round(q / gcd([q,p(k)]))*p(k)
+            end
+            fact = round(q ./ p)
         end
-        if p~=[] & p<0 then
-            p = -p
+        if q~=[] & q<0 then
+            q = -q
             fact = -fact;
         end
         return
     end
 
-    // Polynomials:
+    // Polynomials
+    // -----------
     [m, n] = size(p),
     p = matrix(p, m*n, 1),
     p0 = p(1);
+    fact = 1;
     for l = 2:m*n,
-        [u, v] = simp(p0, p(l)),
+        [u, v] = simp(p0, p(l))
         p0 = p0*v,
         fact = [v*fact, u],
     end,
-    fact = matrix(fact, m, n),
-    p = p0;
-endfunction
+    fact = matrix(fact, m, n)
+    q = p0;
 
-// ----------------------------------------------------------------------------
-
-function [q, fact] = %i_lcm(p)
-    // p = lcm(p) computes the lcm of polynomial vector p
-    // [pp,fact]=lcm(p) computes besides the vector fact of factors
-    // such that  p.*fact=pp*ones(p)
-
-    k = find(p==0);
-    if k <> [] then
-        q = p(k(1));
-        fact = 0*ones(p);
-        fact(k) = 1;
-        return
-    end
-
-    q = p(1);
-    for k = 2:size(p,"*")
-        q = q / gcd([q,p(k)]) * p(k);
-    end
-    fact = q ./ p;
 endfunction
index 8c4537d..9426891 100644 (file)
@@ -1,7 +1,7 @@
 // =============================================================================
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
 // Copyright (C) 2013 - Scilab Enterprises - Bruno JOFRET
-// Copyright (C) 2017 - Samuel GOUGEON
+// Copyright (C) 2017, 2018 - Samuel GOUGEON
 //
 //  This file is distributed under the same license as the Scilab package.
 // =============================================================================
@@ -9,32 +9,59 @@
 // <-- CLI SHELL MODE -->
 // <-- NO CHECK REF -->
 
-s = poly(0,'s');
-p = [s,s*(s+1)^2,s^2*(s+2)];
+// With polynomials
+// ----------------
+s = %s;
+p = [s, s*(s-1)^2, s^2*(s+2)];
 [pp, fact] = lcm(p);
 
-assert_checkequal(pp, s^5+4*s^4+5*s^3+2*s^2);
-assert_checkequal(fact, [2*s+5*s^2+4*s^3+s^4, 2*s+s^2, 1+2*s+s^2]);
-
-V=int32([2^2*3^5, 2^3*3^2,2^2*3^4*5]);
-assert_checkequal(lcm(V), int32(9720));
-
-// Integer Overflow
-V = int32([59356 44517]);
-assert_checkequal(lcm(V), int32(178068));
-
-V = int32([50000 50000]);
-assert_checkequal(lcm(V), int32(50000));
+expected = s^2*(s-1)^2*(s+2);
+assert_checkequal(pp, expected);
+r =  expected./p;
+r.num = r.num ./ coeff(r.den);
+R = r.num;
+assert_checkequal(clean(fact-R), [0 0 0]*%s);
 
 // With negative integers
 // ----------------------
 // http://bugzilla.scilab.org/15058
-v = [-2*3*5*7  7*11  -13*17];
-LCMref = int32(2*3*5*7*11*13*17);
-factRef = int32([-11*13*17, 2*3*5*13*17, -2*3*5*7*11]);
+v = int16([-2*3*5*7  7*11  -13*17]);
+LCMref = 2*3*5*7*11*13*17;
+factRef = [-11*13*17, 2*3*5*13*17, -2*3*5*7*11];
 [LCM, fact] = lcm(v);
 assert_checkequal(LCM, LCMref);
 assert_checkequal(fact, factRef);
 [LCM, fact] = lcm(-v);
 assert_checkequal(LCM, LCMref);
 assert_checkequal(fact, -factRef);
+
+// With decimal or encoded integers
+// --------------------------------
+//--> pr = primes(50)
+// pr  =
+//   2.  3.  5.  7.  11.  13.  17.  19.  23.  29.  31.  37.  41.  43.  47.
+
+V = int32([2^2*3^5, 2^3*3^2, 2^2*3^4*5]);
+assert_checkequal(lcm(V), 2^3*3^5*5);
+
+v = [2*3*7, 5*7];
+Lcm = 2*3*5*7;                  // 210  int8: 2^7 = 128
+v = [v; [2*2*3*7*13, 5*7*11*13]];
+Lcm = [Lcm 2*2*3*5*7*11*13];    // 60060. int16 : 2^15 = 32768
+d =  3*7*13*29*37;
+v = [v; [d*2*19*27, d*5*11*23]];
+Lcm = [Lcm d*2*5*11*19*23*27];  // 3.802D+11 int32: 2^31 ~ 2.147D+09
+// int64    2^51 ~2.252D+15  2^63 ~ 9.223D+18
+d = 9*49*13*23*29*37*47;        // 6.650D+09
+v = [v; [d*2*25*31, d*7*29]];   // 1.031D+13 ; 1.350D+12
+Lcm = [Lcm  d*2*7*25*29*31];    // ~ 2.092D+15
+
+// inttype: [1 11 2 12 4 14 8 18]
+for i = 1:4
+    it = 2^(i-1);
+    L = lcm(iconvert([-v(i,1) v(i,2)],it));     // inttype [1 2 4 8]
+    assert_checkequal(L, Lcm(i));
+    L = lcm(iconvert([v(i,1) v(i,2)],it+10));   // inttype [11 12 14 18]
+    assert_checkequal(L, Lcm(i));
+end
+assert_checkequal(lcm(v(4,:)), Lcm(4));         // inttype 0 (decimal)