* Bug 15590 fixed: pdiv pmodulo modulo code and pages improved 64/20064/9
Samuel GOUGEON [Sat, 26 May 2018 23:02:19 +0000 (01:02 +0200)]
  http://bugzilla.scilab.org/15590

  * pdiv() modulo() pmodulo() extended to hypermatrices of polynomials
  * pdiv() code simplified
  * modulo() and pmodulo() code simplified (hypermats are no longer mlist)
  * The modulo() pages
     - had mistakes (about the sign of the result): fixed
     - did not describe the polynomial case
    pt and ru versions were not up-to-date after 2013 improvements.
  * pdiv page:
    - example improved
    - missing header (fr) added

Change-Id: I8c23a68d8ad3a7740960fc6ca9a9921ff5982185

16 files changed:
scilab/CHANGES.md
scilab/modules/elementary_functions/help/en_US/modulo.xml
scilab/modules/elementary_functions/help/fr_FR/modulo.xml
scilab/modules/elementary_functions/help/ja_JP/modulo.xml
scilab/modules/elementary_functions/help/pt_BR/modulo.xml
scilab/modules/elementary_functions/help/ru_RU/modulo.xml
scilab/modules/elementary_functions/macros/modulo.sci
scilab/modules/elementary_functions/macros/pmodulo.sci
scilab/modules/elementary_functions/tests/unit_tests/modulo.dia.ref [deleted file]
scilab/modules/elementary_functions/tests/unit_tests/modulo.tst
scilab/modules/polynomials/help/en_US/pdiv.xml
scilab/modules/polynomials/help/fr_FR/pdiv.xml
scilab/modules/polynomials/help/ja_JP/pdiv.xml
scilab/modules/polynomials/help/pt_BR/pdiv.xml
scilab/modules/polynomials/macros/pdiv.sci
scilab/modules/polynomials/tests/nonreg_tests/bug_15590.tst [new file with mode: 0644]

index 514bbd1..b364e6a 100644 (file)
@@ -252,7 +252,7 @@ Help pages:
   `printf`, `sprintf`, `iconvert`, `stdev`, `xlabel`, `and_op`, `or_op`, `permute`, `tree2code`, `%helps`,
   `scilab`, `flipdim`, `Matplot_properties`, `text_properties`, `meshgrid`, `ismatrix`, `xget`, `xset`, `ieee`, `evstr`,
   `uigetfont`, `uigetdir`, `uigetfile`, `uiputfile`, `cat`, `makecell`, `xstring`, `norm`, `barhomogenize`,
-  `colordef`, `matrix`, `coffg`, `diag`, `speye`, `sparse`, `recursionlimit`, `for`, `fileinfo`, `end`, `iconvert`, `Globalproperty`, `unique`, `intdec`, `plus`, `minus`, `varn`, `savematfile`, `empty`
+  `colordef`, `matrix`, `coffg`, `diag`, `speye`, `sparse`, `recursionlimit`, `for`, `fileinfo`, `end`, `iconvert`, `Globalproperty`, `unique`, `intdec`, `plus`, `minus`, `varn`, `savematfile`, `empty`, `modulo`, `pdiv`
 * 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`, `lcm`, `isglobal`,
@@ -491,6 +491,7 @@ Known issues
 * [#15583](http://bugzilla.scilab.org/show_bug.cgi?id=15583): `color(["red" "blue"])` yielded a puzzling error message asking for String type instead of a scalar.
 * [#15586](http://bugzilla.scilab.org/show_bug.cgi?id=15586): `tree2code()` added some leading `,` in the argins and argout lists.
 * [#15589](http://bugzilla.scilab.org/show_bug.cgi?id=15589): `inv()` could fail on some matrices of polynomials with complex coefficients.
+* [#15590](http://bugzilla.scilab.org/show_bug.cgi?id=15590): `pdiv`, `modulo` and `pmodulo` did not work with hypermatrices of polynomials. There were some mistakes in `modulo` help page. The code of `modulo()` and `pmodulo` could be simplified since hypermatrices are no longer mlist() in Scilab 6.
 * [#15593](http://bugzilla.scilab.org/show_bug.cgi?id=15593): The `grand` page was alone in a main chapter instead of being in the `rand` section.
 * [#15594](http://bugzilla.scilab.org/show_bug.cgi?id=15594): The `bool2s` page was alone in a main chapter instead of being with the `boolean` page.
 * [#15598](http://bugzilla.scilab.org/show_bug.cgi?id=15598): `string(handle)` returned "" instead of calling `%h_string()`
index e61b01f..9680a97 100644 (file)
@@ -2,7 +2,7 @@
 <!--
  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
  * Copyright (C) 2008 - INRIA
- * Copyright (C) 2013 - Samuel GOUGEON
+ * Copyright (C) 2013, 2018 - Samuel GOUGEON
  *
  * Copyright (C) 2012 - 2016 - Scilab Enterprises
  *
  * 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:ns5="http://www.w3.org/1999/xhtml" xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:db="http://docbook.org/ns/docbook" xmlns:scilab="http://www.scilab.org" xml:id="modulo" xml:lang="en">
+<refentry xmlns="http://docbook.org/ns/docbook" xmlns:xlink="http://www.w3.org/1999/xlink"
+        xmlns:svg="http://www.w3.org/2000/svg" xmlns:ns5="http://www.w3.org/1999/xhtml"
+        xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:db="http://docbook.org/ns/docbook"
+        xmlns:scilab="http://www.scilab.org" xml:id="modulo" xml:lang="en">
     <refnamediv>
         <refname>modulo</refname>
-        <refpurpose>remainder modulo m with the left operand sign</refpurpose>
+        <refpurpose>
+            remainder modulo m with the sign of the left operand, or of a polynomial division
+        </refpurpose>
     </refnamediv>
     <refnamediv xml:id="pmodulo">
         <refname>pmodulo</refname>
             <varlistentry>
                 <term>m, n</term>
                 <listitem>
-                    <para>Scalar, vector, matrix or hypermatrix of encoded integers, reals or polynomials (Hypermatrix is not supported for polynomials).
-                        <varname>m</varname> and <varname>n</varname> must have the same type. If they are of integer type, they may be of distinct
-                        encoding length (for instance int8 and int16). If none of them is scalar, they must have the same sizes.
+                    <para>
+                        Scalar, vector, matrix or hypermatrix of encoded integers, reals, or
+                        polynomials with real coefficients.
+                        <varname>m</varname> and <varname>n</varname> must have the same type.
+                        If they are of integer type, they may be of distinct encoding length
+                        (for instance int8 and int16).
+                        If none of them is scalar, they must have the same sizes.
                     </para>
                 </listitem>
             </varlistentry>
                 <term>i</term>
                 <listitem>
                     <para>
-                        Scalar, vector, matrix or hypermatrix of same type (and inttype) as <varname>n</varname>.
-                        <varname>i</varname> takes the sizes of the bigger <varname>m</varname> or<varname>n</varname>.
+                        Scalar, vector, matrix or hypermatrix of <varname>n</varname>'s type
+                        (and inttype).
+                        <varname>i</varname> takes the sizes of the bigger <varname>m</varname>
+                        or <varname>n</varname>.
+                    </para>
+                    <para>
+                        <warning>
+                            For polynomials, when all remainders in the array <varname>i</varname>
+                            are constant (degree==0), <varname>i</varname> is of type 1
+                            (numbers) instead of 2 (constant polynomials).
+                        </warning>
                     </para>
                 </listitem>
             </varlistentry>
     <refsection>
         <title>Description</title>
         <para>
-            <function>modulo</function> computes <code>i = n (modulo m)</code>
+            <literal>modulo()</literal> computes <literal>i = n (modulo m)</literal>
             i.e. remainder of <varname>n</varname> divided by <varname>m</varname>.
         </para>
+        <para>For polynomials, <literal>pdiv()</literal> is called.</para>
         <para>
-            <code>i = n - m .* int (n ./ m)</code>. Here the answer may be negative
-            if <varname>n</varname> or <varname>m</varname> are negative.
+            For numbers,
+            <itemizedlist>
+                <listitem>
+                    <para>
+                        <literal>modulo()</literal> computes <literal>i = n - m .* int (n ./ m)</literal>.
+                        The result is negative (or null) when <varname>n</varname> is negative, and
+                        is positive otherwise.
+                    </para>
+                </listitem>
+                <listitem>
+                    <para>
+                        <literal>pmodulo()</literal> computes <literal>i = n - |m| .* floor (n ./ |m|)</literal>.
+                        The result is always positive or null.
+                    </para>
+                </listitem>
+            </itemizedlist>
         </para>
         <para>
-            <function>pmodulo</function> computes <code>i = n - |m| .* floor (n ./ |m|)</code>,
-            the answer is positive or zero.
+            <warning>
+                If <varname>m</varname> contains at least one 0 value, <literal>modulo(x,m)</literal>
+                and <literal>pmodulo(x,m)</literal> will perform a division by zero.
+                If <varname>m</varname> is of real type, this exception will be processed according
+                to the <literal>ieee()</literal> mode.
+                For encoded integers, it will always yield an error.
+            </warning>
         </para>
-        <warning>
-            If <varname>m</varname> contains at least one 0 value, <code>modulo(x,m)</code> and <code>pmodulo(x,m)</code> will perform a division by zero. If <varname>m</varname> is of real type, this exception will be processed according to the <literal>ieee()</literal> mode. For encoded integers, it will always yield an error.
-        </warning>
     </refsection>
     <refsection>
         <title>Examples</title>
@@ -108,8 +143,6 @@ pmodulo(m,n)
 // Polynomials
 modulo( %z^2+1, %z)
 pmodulo(%z^2+1, %z)
-
-
  ]]></programlisting>
     </refsection>
     <refsection role= "see also">
@@ -130,7 +163,10 @@ pmodulo(%z^2+1, %z)
                 <revnumber>5.5.0</revnumber>
                 <revremark>Extension to encoded integers and to hypermatrices of encoded integers or reals.</revremark>
             </revision>
+            <revision>
+                <revnumber>6.0.2</revnumber>
+                <revremark>Extension to hypermatrices of polynomials.</revremark>
+            </revision>
         </revhistory>
     </refsection>
-
 </refentry>
index 7dd1b2c..b04fbb3 100644 (file)
@@ -2,7 +2,7 @@
 <!--
  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
  * Copyright (C) 2008 - INRIA
- * Copyright (C) 2013 - Samuel GOUGEON
+ * Copyright (C) 2013, 2018 - Samuel GOUGEON
  *
  * Copyright (C) 2012 - 2016 - Scilab Enterprises
  *
  * 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:ns5="http://www.w3.org/1999/xhtml" xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:db="http://docbook.org/ns/docbook" xmlns:scilab="http://www.scilab.org" xml:id="modulo" xml:lang="fr">
+<refentry xmlns="http://docbook.org/ns/docbook" xmlns:xlink="http://www.w3.org/1999/xlink"
+        xmlns:svg="http://www.w3.org/2000/svg" xmlns:ns5="http://www.w3.org/1999/xhtml"
+        xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:db="http://docbook.org/ns/docbook"
+        xmlns:scilab="http://www.scilab.org" xml:id="modulo" xml:lang="fr">
     <refnamediv>
         <refname>modulo</refname>
-        <refpurpose>reste symétrique modulo m ayant le signe du dividende</refpurpose>
+        <refpurpose>reste modulo m ayant le signe du dividende, ou de division polynomiale</refpurpose>
     </refnamediv>
     <refnamediv xml:id="pmodulo">
         <refname>pmodulo</refname>
             <varlistentry>
                 <term>m, n</term>
                 <listitem>
-                    <para>Scalaire, vecteur, matrice ou hypermatrice d'entiers encodés, de décimaux réels ou de polynômes (les hypermatrices de polynômes ne sont pas admises).
-                        <varname>m</varname> et <varname>n</varname> doivent être de même type. S'ils sont de types entiers, il peuvent être d'encodages distincts (par exemple int8 et int16) Si aucune des deux n'est scalaire, elles doivent avoir les mêmes dimensions.
+                    <para>
+                        Scalaire, vecteur, matrice ou hypermatrice d'entiers encodés, de décimaux
+                        réels ou de polynômes à coefficients réels.
+                        <varname>m</varname> et <varname>n</varname> doivent être du même type.
+                        Si elles sont de types entiers, elles peuvent être d'encodages distincts
+                        (par exemple int8 et int16). Si aucune des deux n'est scalaire, elles
+                        doivent avoir les mêmes tailles.
                     </para>
                 </listitem>
             </varlistentry>
                 <term>i</term>
                 <listitem>
                     <para>
-                        Scalaire, vecteur, matrice ou hypermatrice du type de <varname>n</varname> (voire de même inttype).
-                        <varname>i</varname> a les dimensions de la plus large de <varname>m</varname> ou<varname>n</varname>.
+                        Scalaire, vecteur, matrice ou hypermatrice du type de <varname>n</varname>
+                        (voire de même inttype).
+                        <varname>i</varname> a les tailles de la plus large de
+                        <varname>m</varname> ou <varname>n</varname>.
+                    </para>
+                    <para>
+                        <warning>
+                            Pour des polynômes en entrée, lorsque tous les restes dans <varname>i</varname>
+                            sont des polynômes constants (degré==0), <varname>i</varname> est de
+                            de type 1 (nombres) au lieu de 2 (polynômes constants).
+                        </warning>
                     </para>
                 </listitem>
             </varlistentry>
     <refsection>
         <title>Description</title>
         <para>
-            <literal>modulo</literal> calcule <literal>i= n (modulo m)</literal>
+            <literal>modulo</literal> calcule <literal>i = n (modulo m)</literal>
             c'est à dire le reste de <literal>n</literal> divisé par
             <literal>m</literal>.
         </para>
-        <para>i = n - m .* int (n ./ m). Ici la réponse peut être négative si
-            <literal>n</literal> et/ou <literal>m</literal> sont négatifs.
+        <para>
+            Pour <varname>m</varname> et <varname>n</varname> numériques,
+            <itemizedlist>
+                <listitem>
+                    <para>
+                        <literal>modulo()</literal> calcule <literal>i = n - m .* int (n ./ m)</literal>.
+                        Le résultat est négatif (ou nul) lorsque <varname>n</varname> est négatif.
+                        Il est positif sinon.
+                    </para>
+                </listitem>
+                <listitem>
+                    <para>
+                        <literal>pmodulo()</literal> calcule <literal>i = n - |m| .* floor (n ./ |m|)</literal>.
+                        Le résultat est toujours positif ou nul.
+                    </para>
+                </listitem>
+            </itemizedlist>
         </para>
         <para>
-            <literal>pmodulo</literal> calcule <literal>i = n - |m| .* floor (n ./|m|)</literal>,la réponse est positive ou nulle.
+            <warning>
+                Si <literal>m</literal> contient au moins une valeur nulle,
+                <literal>modulo(x,m)</literal> et <literal>pmodulo(x,m)</literal> effectueront une
+                division par zéro. Si <varname>m</varname> est de type réel, l'exception sera
+                traitée selon le mode <literal>ieee()</literal> actif. Si <literal>m</literal>
+                est de type entier, une erreur sera toujours émise.
+            </warning>
         </para>
-        <warning>
-            Si <literal>m</literal> contient au moins une valeur nulle, <code>modulo(x,m)</code> et <code>pmodulo(x,m)</code> effectueront une division par zéro. Si <varname>m</varname> est de type réel, l'exception sera traitée selon le mode <literal>ieee()</literal> actif. Si <literal>m</literal> est de type entier, une erreur sera toujours émise.
-        </warning>
     </refsection>
     <refsection>
         <title>Exemples</title>
@@ -106,7 +141,6 @@ pmodulo(m,n)
 // Polynômes
 modulo( %z^2+1, %z)
 pmodulo(%z^2+1, %z)
-
  ]]></programlisting>
     </refsection>
     <refsection role= "see also">
@@ -125,7 +159,13 @@ pmodulo(%z^2+1, %z)
         <revhistory>
             <revision>
                 <revnumber>5.5.0</revnumber>
-                <revremark>Extension aux entiers encodés et aux hypermatrices d'entiers ou de réels.</revremark>
+                <revremark>
+                    Extension aux entiers encodés et aux hypermatrices d'entiers ou de réels.
+                </revremark>
+            </revision>
+            <revision>
+                <revnumber>6.0.2</revnumber>
+                <revremark>Extension aux hypermatrices de polynômes.</revremark>
             </revision>
         </revhistory>
     </refsection>
index e9be42e..37eea8f 100644 (file)
@@ -2,7 +2,7 @@
 <!--
  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
  * Copyright (C) 2008 - INRIA
- * Copyright (C) 2013 - Samuel GOUGEON
+ * Copyright (C) 2013, 2018 - Samuel GOUGEON
  *
  * Copyright (C) 2012 - 2016 - Scilab Enterprises
  *
  * 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:ns5="http://www.w3.org/1999/xhtml" xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:db="http://docbook.org/ns/docbook" xmlns:scilab="http://www.scilab.org" xml:id="modulo" xml:lang="ja">
+<refentry xmlns="http://docbook.org/ns/docbook" xmlns:xlink="http://www.w3.org/1999/xlink"
+        xmlns:svg="http://www.w3.org/2000/svg" xmlns:ns5="http://www.w3.org/1999/xhtml"
+        xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:db="http://docbook.org/ns/docbook"
+        xmlns:scilab="http://www.scilab.org" xml:id="modulo" xml:lang="ja">
     <refnamediv>
         <refname>modulo</refname>
         <refpurpose>左オペランド符号を有するモジュロm剰余演算</refpurpose>
                 <term>m, n</term>
                 <listitem>
                     <para>
-                        エンコードされた整数, 実数または多項式の
-                        スカラー, ベクトル, またはハイパー行列
-                        (ハイパー行列は多項式ではサポートされません).
+                        エンコードされた整数, 実数または多項式の,  スカラー, ベクトル, またはハイパー行列
                         <varname>m</varname> および <varname>n</varname>は,
                         同じ型である必要があります.
                         yが整数型の場合,(int8およびint16のように)
                         異なるエンコード長とすることが可能です.
-                        どちらもスカラーでない場合、yは同じ大きさとする
-                        必要があります.
+                        どちらもスカラーでない場合、yは同じ大きさとする 必要があります.
                     </para>
                 </listitem>
             </varlistentry>
                         <varname>m</varname>または<varname>n</varname>の
                         大きい方の大きさとなります.
                     </para>
+                    <para>
+                        <warning>
+                            For polynomials, when all remainders in the array <varname>i</varname>
+                            are constant (degree==0), <varname>i</varname> is of type 1
+                            (numbers) instead of 2 (constant polynomials).
+                        </warning>
+                    </para>
                 </listitem>
             </varlistentry>
         </variablelist>
     <refsection>
         <title>説明</title>
         <para>
-            <literal>modulo</literal> は,
-            <literal>i= n (modulo m)</literal>,
-            すなわち, <literal>n</literal>を<literal>m</literal>で
-            割った剰余を計算します.
-        </para>
-        <para>
-            <code>i = n - m .* int (n ./ m)</code>.
-            この式で,
-            <literal>n</literal> または <literal>m</literal>が負の場合,
-            答えが負となる可能性があります.
+            <literal>modulo</literal> は, <literal>i= n (modulo m)</literal>,
+            すなわち, <literal>n</literal>を<literal>m</literal>で 割った剰余を計算します.
         </para>
+        <para>多項式の場合は、<literal>pdiv()</literal>が使用されます.</para>
         <para>
-            <literal>pmodulo</literal> は,
-            <code>i = n - |m| .* floor (n ./ |m|)</code>
-            を計算します.答えは正またはゼロとなります.
+            数字の場合、
+            <itemizedlist>
+                <listitem>
+                    <para>
+                        <literal>modulo()</literal>は<literal>i = n  -  m.* int(n./ m)</literal>を計算します.
+                        <varname>n</varname>が負の場合、結果は負(またはヌル)になります. それ以外は肯定的です.
+                    </para>
+                </listitem>
+                <listitem>
+                    <para>
+                        <literal>pmodulo()</literal> は,
+                        <literal>i = n - |m| .* floor (n ./ |m|)</literal>
+                        を計算します.答えは正またはゼロとなります.
+                    </para>
+                </listitem>
+            </itemizedlist>
         </para>
         <warning>
             <varname>m</varname>が1つ以上の値0を含む場合,
-            <code>modulo(x,m)</code> および <code>pmodulo(x,m)</code>
+            <literal>modulo(x,m)</literal> および <literal>pmodulo(x,m)</literal>
             はゼロ割を発生します.
             <varname>m</varname>hが実数型の場合,
             この例外は<literal>ieee()</literal> モードに基づき処理されます.
         <programlisting role="example"><![CDATA[
 n = [1,2,10,15];
 m = [2,2,3,5];
+
 modulo(n,m)
 modulo(-3, 9)
 modulo(10, -4)
 pmodulo(-3, 9)
 pmodulo(10, -6)
 pmodulo(-10, -6)
+
 // エンコードされた整数
 modulo( int8(-13), int16(-7))
 pmodulo(int8(-13), int16(-7))
@@ -110,6 +125,7 @@ modulo( int8([-13 8]), int16(-7))
 pmodulo(int8([-13 8]), int16(-7))
 modulo( int8([-13 8]), int16([-7 5]))
 pmodulo(int8([-13 8]), int16([-7 5]))
+
 // ハイパー行列
 m = grand(2,2,2,"uin",-100,100)
 n = grand(2,2,2,"uin",-10 ,10);
@@ -120,6 +136,7 @@ modulo(51, n)
 pmodulo(51,n)
 modulo(m, n)
 pmodulo(m,n)
+
 // 多項式
 modulo( %z^2+1, %z)
 pmodulo(%z^2+1, %z)
@@ -146,6 +163,10 @@ pmodulo(%z^2+1, %z)
                     ハイパー行列に拡張されました.
                 </revremark>
             </revision>
+            <revision>
+                <revnumber>6.0.2</revnumber>
+                <revremark>Extension to hypermatrices of polynomials.</revremark>
+            </revision>
         </revhistory>
     </refsection>
 </refentry>
index 3c91578..20be949 100644 (file)
@@ -1,8 +1,8 @@
-<?xml version="1.0" encoding="ISO-8859-1"?>
+<?xml version="1.0" encoding="UTF-8"?>
 <!--
  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
  * Copyright (C) 2008 - INRIA
- * Copyright (C) 2013 - Samuel GOUGEON
+ * Copyright (C) 2013, 2018 - Samuel GOUGEON
  *
  * Copyright (C) 2012 - 2016 - Scilab Enterprises
  *
  * 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:ns5="http://www.w3.org/1999/xhtml" xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:db="http://docbook.org/ns/docbook" xmlns:scilab="http://www.scilab.org" xml:id="modulo" xml:lang="pt">
+<refentry xmlns="http://docbook.org/ns/docbook" xmlns:xlink="http://www.w3.org/1999/xlink"
+        xmlns:svg="http://www.w3.org/2000/svg" xmlns:ns5="http://www.w3.org/1999/xhtml"
+        xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:db="http://docbook.org/ns/docbook"
+        xmlns:scilab="http://www.scilab.org" xml:id="modulo" xml:lang="pt">
     <refnamediv>
         <refname>modulo</refname>
-        <refpurpose>Resto aritmético simétrico da divisão de n por m</refpurpose>
+        <refpurpose>
+            Resto módulo m com o sinal do operando esquerdo, ou de uma divisão polinomial
+        </refpurpose>
     </refnamediv>
     <refnamediv xml:id="pmodulo">
         <refname>pmodulo</refname>
-        <refpurpose>Resto aritmético positivo da divisão de n por m</refpurpose>
+        <refpurpose>Resto positivo da divisão de n por m</refpurpose>
     </refnamediv>
     <refsynopsisdiv>
         <title>Seqüência de Chamamento</title>
             <varlistentry>
                 <term>n,m</term>
                 <listitem>
-                    <para>inteiros ou vetores ou matrizes de inteiros de ordens
-                        iguais
+                    <para>
+                        Escalar, vetor, matriz ou hipermatriz de inteiros codificados, reais ou
+                        polinômios com coeficientes reais.
+                        <varname>m</varname> e <varname>n</varname> devem ter o mesmo tipo.
+                        Se eles são do tipo inteiro, eles podem ser de comprimento de codificação
+                        distinto (por exemplo, int8 e int16).
+                        Se nenhum deles for escalar, eles devem ter os mesmos tamanhos.
+                    </para>
+                </listitem>
+            </varlistentry>
+            <varlistentry>
+                <term>i</term>
+                <listitem>
+                    <para>
+                        Escalar, vetor, matriz ou hipermatriz do tipo (e inttype) <varname>n</varname>.
+                        <varname>i</varname> aceita os tamanhos do maior <varname>m</varname>
+                        ou <varname>n</varname>.
+                    </para>
+                    <para>
+                        <warning>
+                            For polynomials, when all remainders in the array <varname>i</varname>
+                            are constant (degree==0), <varname>i</varname> is of type 1
+                            (numbers) instead of 2 (constant polynomials).
+                        </warning>
                     </para>
                 </listitem>
             </varlistentry>
         <title>Descrição</title>
         <para>
             <literal>modulo</literal> computa <literal>i= n (modulo m)</literal>
-            i.e. resto da divisão de <literal>m</literal> (<literal>n</literal> e
-            <literal>m</literal> inteiros).
-        </para>
-        <para>i = n - m .* int (n ./ m). Aqui, a resposta pode ser negativa se
-            <literal>n</literal> ou <literal>m</literal> são negativos.
-        </para>
-        <para>
-            <literal>pmodulo</literal> computa <literal>i = n - |m| .* floor (n ./
-                |m|)
-            </literal>
-            ,a resposta é positiva ou zero.
+            i.e. resto da divisão de <literal>m</literal>.
         </para>
+        <para>Para polinômios, <literal>pdiv()</literal> é chamado.</para>
+        <para>
+            Para números,
+            <itemizedlist>
+                <listitem>
+                    <para>
+                    <literal>modulo()</literal> calcula <literal>i = n - m .* int (n ./m)</literal>.
+                    O resultado é negativo (ou nulo) quando <varname>n</varname> é negativo e
+                    é positivo caso contrário.
+                    </para>
+                </listitem>
+                <listitem>
+                    <para>
+                    <literal>pmodulo()</literal> calcula <literal>i = n - | m | .* floor (n ./ | m |)</literal>.
+                    O resultado é sempre positivo ou nulo.
+                    </para>
+                </listitem>
+            </itemizedlist>
+        </para>
+        <para>
+            <warning>
+                Se <varname>m</varname> contiver pelo menos um valor 0, <literal>modulo(x,m)</literal>
+                e <literal>pmodulo(x,m)</literal> executará uma divisão por zero.
+                Se <varname>m</varname> for do tipo real, esta exceção será processada de acordo
+                para o modo <literal>ieee()</literal>.
+                Para inteiros codificados, sempre gerará um erro.
+            </warning>
+        </para>
     </refsection>
     <refsection>
         <title>Exemplos</title>
@@ -72,6 +117,58 @@ modulo(10, -4)
 pmodulo(-3, 9)
 pmodulo(10, -6)
 pmodulo(-10, -6)
+
+// Inteiros codificados
+modulo( int8(-13), int16(-7))
+pmodulo(int8(-13), int16(-7))
+modulo( int8(-13), int16([-7 5]))
+pmodulo(int8(-13), int16([-7 5]))
+modulo( int8([-13 8]), int16(-7))
+pmodulo(int8([-13 8]), int16(-7))
+modulo( int8([-13 8]), int16([-7 5]))
+pmodulo(int8([-13 8]), int16([-7 5]))
+
+// Hypermatrices
+m = grand(2,2,2,"uin",-100,100)
+n = grand(2,2,2,"uin",-10 ,10);
+n(n==0) = 1
+modulo(m, 5)
+pmodulo(m,5)
+modulo(51, n)
+pmodulo(51,n)
+modulo(m, n)
+pmodulo(m,n)
+
+// Polinômios
+modulo( %z^2+1, %z)
+pmodulo(%z^2+1, %z)
  ]]></programlisting>
     </refsection>
+    <refsection role= "see also">
+        <title>Ver Também</title>
+        <simplelist type="inline">
+            <member>
+                <link linkend="unwrap">unwrap</link>
+            </member>
+            <member>
+                <link linkend="ieee">ieee</link>
+            </member>
+        </simplelist>
+    </refsection>
+    <refsection>
+        <title>Histórico</title>
+        <revhistory>
+            <revision>
+                <revnumber>5.5.0</revnumber>
+                <revremark>
+                    Extensão para inteiros codificados e para hypermatrices de inteiros codificados
+                    ou de reais.
+                </revremark>
+            </revision>
+            <revision>
+                <revnumber>6.0.2</revnumber>
+                <revremark>Extensão para hipermatrizes de polinômios..</revremark>
+            </revision>
+        </revhistory>
+    </refsection>
 </refentry>
index e6283ca..3fad33a 100644 (file)
  * 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:ns5="http://www.w3.org/1999/xhtml" xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:db="http://docbook.org/ns/docbook" xmlns:scilab="http://www.scilab.org" xml:id="modulo" xml:lang="ru">
+<refentry xmlns="http://docbook.org/ns/docbook" xmlns:xlink="http://www.w3.org/1999/xlink"
+        xmlns:svg="http://www.w3.org/2000/svg" xmlns:ns5="http://www.w3.org/1999/xhtml"
+        xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:db="http://docbook.org/ns/docbook"
+        xmlns:scilab="http://www.scilab.org" xml:id="modulo" xml:lang="ru">
     <refnamediv>
         <refname>modulo</refname>
         <refpurpose>симметричный арифметический остаток от деления по модулю m</refpurpose>
         <title>Аргументы</title>
         <variablelist>
             <varlistentry>
-                <term>n</term>
+                <term>m, n</term>
                 <listitem>
                     <para>
-                        вещественный или полиномиальный вектор или матрица
+                        Скаляр, вектор, матрица или гиперматрица закодированных целых чисел,
+                        реалов или многочлены с вещественными коэффициентами.
+                        <varname>m</varname> и <varname>n</varname> должны иметь один и тот же тип.
+                        Если они имеют целочисленный тип, они могут иметь разную длину кодирования
+                        (например, int8 и int16).
+                        Если ни один из них не является скалярным, они должны иметь одинаковые размеры.
                     </para>
                 </listitem>
             </varlistentry>
             <varlistentry>
-                <term>m</term>
+                <term>i</term>
                 <listitem>
-                    <para>вещественный вектор или матрица</para>
+                    <para>
+                        Скалярная, векторная, матричная или гиперматрица типа <varname>n</varname>
+                        (и inttype).
+                        <varname>i</varname> принимает размеры более крупного <varname>m</varname>
+                        или <varname>n</varname>.
+                    </para>
+                    <para>
+                        <warning>
+                            Для полиномов, если все остатки от деления в массиве <varname>i</varname>
+                            являются константами (порядок равен 0), то <varname>i</varname> имеет тип 1
+                            (числа) вместо 2 (постоянные полиномы).
+                        </warning>
+                    </para>
                 </listitem>
             </varlistentry>
         </variablelist>
     <refsection>
         <title>Описание</title>
         <para>
-            <function>modulo</function> вычисляет <code>i= n (modulo m)</code>,
+            <function>modulo</function> вычисляет <literal>i = n (modulo m)</literal>,
             т. е. остаток от деления <varname>n</varname> на <varname>m</varname>
             (<varname>n</varname> и <varname>m</varname> - целые числа).
         </para>
+        <para>Для полиномов используется <literal>pdiv()</literal>.</para>
         <para>
-            <code>i= n - m .* int (n ./ m)</code>. Здесь ответ может быть
-            отрицательным, если <varname>n</varname> или <varname>m</varname>
-            являются отрицательными.
-        </para>
-        <para>
-            <function>pmodulo</function> вычисляет <code>i = n - |m| .* floor (n
-                ./ |m|)
-            </code>
-            , ответ является положительным либо равным нулю.
-        </para>
-        <para>
-            <code>modulo(x,0)</code> возвращает сообщение об ошибке: "Деление на нуль...". При <code>ieee(2)</code>, <code>modulo(x,0)</code> возвращает <constant>%nan</constant>.
-        </para>
-        <para>
-            <code>pmodulo(x,0)</code> возвращает сообщение об ошибке: "Деление на нуль...". При <code>ieee(2)</code>, <code>pmodulo(x,0)</code> возвращает <constant>%nan</constant>.
-        </para>
+            Для чисел,
+            <itemizedlist>
+                <listitem>
+                    <para>
+                        <literal>modulo()</literal> вычисляет <literal>i = n - m. * int (n ./ m)</literal>.
+                        Результат отрицательный (или нулевой), когда <varname>n</varname>
+                        отрицательный, и в противном случае.
+                    </para>
+                </listitem>
+                <listitem>
+                    <para>
+                        <literal>pmodulo()</literal> вычисляет
+                        <literal>i = n - | m | . * floor (n ./ | m |)</literal>,
+                        ответ является положительным либо равным причинам.
+                    </para>
+                </listitem>
+            </itemizedlist>
+        </para>
+        <para>
+            <warning>
+                Если <varname>m</varname> содержит хотя бы одно значение 0, <literal>modulo(x, m)</literal>
+                и <literal>pmodulo(x, m)</literal> выполнит деление на ноль.
+                Если <varname>m</varname> имеет реальный тип, это исключение будет обрабатываться
+                в соответствии с к режиму <literal>ieee()</literal>.
+                Для закодированных целых чисел он всегда будет давать ошибку.
+            </warning>
+        </para>
     </refsection>
     <refsection>
         <title>Примеры</title>
@@ -86,6 +118,55 @@ modulo(10, -4)
 pmodulo(-3, 9)
 pmodulo(10, -6)
 pmodulo(-10, -6)
+
+// Кодированные целые числа
+modulo( int8(-13), int16(-7))
+pmodulo(int8(-13), int16(-7))
+modulo( int8(-13), int16([-7 5]))
+pmodulo(int8(-13), int16([-7 5]))
+modulo( int8([-13 8]), int16(-7))
+pmodulo(int8([-13 8]), int16(-7))
+modulo( int8([-13 8]), int16([-7 5]))
+pmodulo(int8([-13 8]), int16([-7 5]))
+
+// гиперматрицам
+m = grand(2,2,2,"uin",-100,100)
+n = grand(2,2,2,"uin",-10 ,10);
+n(n==0) = 1
+modulo(m, 5)
+pmodulo(m,5)
+modulo(51, n)
+pmodulo(51,n)
+modulo(m, n)
+pmodulo(m,n)
+
+// Полиномы
+modulo( %z^2+1, %z)
+pmodulo(%z^2+1, %z)
  ]]></programlisting>
     </refsection>
+    <refsection role= "see also">
+        <title>Смотрите также</title>
+        <simplelist type="inline">
+            <member>
+                <link linkend="unwrap">unwrap</link>
+            </member>
+            <member>
+                <link linkend="ieee">ieee</link>
+            </member>
+        </simplelist>
+    </refsection>
+    <refsection>
+        <title>История</title>
+        <revhistory>
+            <revision>
+                <revnumber>5.5.0</revnumber>
+                <revremark>Расширение до кодированных целых чесел и гиперматриц кодированных целых чисел или вещественных чисел.</revremark>
+            </revision>
+            <revision>
+                <revnumber>6.0.2</revnumber>
+                <revremark>Расширение до гиперматриц полиномов.</revremark>
+            </revision>
+        </revhistory>
+    </refsection>
 </refentry>
index 337ab55..4c38529 100644 (file)
@@ -2,7 +2,7 @@
 // Copyright (C) INRIA
 // Copyright (C) DIGITEO - 2011 - Allan CORNET
 // Copyright (C) 2012 - Scilab Enterprises - Adeline CARNIS
-// Copyright (C) 2013 - Samuel GOUGEON : Bug 13002 : extension to hypermatrices & integers
+// Copyright (C) 2013, 2018 - Samuel GOUGEON
 //
 // Copyright (C) 2012 - 2016 - Scilab Enterprises
 //
@@ -21,16 +21,16 @@ function i = modulo(n, m)
         error(msprintf(msg, "modulo", 2))
     end
 
-    mt = type(m($))
-    nt = type(n($))
+    mt = type(m)
+    nt = type(n)
     // -----------------------  Checking arguments --------------------------
 
-    if or(type(n)==[15 16]) | and(nt <> [1 2 8]) | (nt==1 & ~isreal(n))
+    if ~or(nt==[1 2 8]) | (nt==1 & ~isreal(n))
         msg = _("%s: Wrong type for input argument #%d: Real, integer or polynomial matrix expected.\n")
         error(msprintf(msg, "modulo", 1))
     end
 
-    if or(type(m)==[15 16]) |  and(mt <> [1 2 8]) | (mt==1 & ~isreal(m))
+    if ~or(mt==[1 2 8]) | (mt==1 & ~isreal(m))
         msg = _("%s: Wrong type for input argument #%d: Real, integer or polynomial matrix expected.\n")
         error(msprintf(msg, "modulo", 2))
     end
@@ -42,29 +42,19 @@ function i = modulo(n, m)
 
     // --------------------------  Processing ----------------------------
 
-    if isempty(m)
+    if m==[]
         i = n;
         return
     end
     if or(mt==[1 8]) & mt==nt then
-        ms = size(m)
-        ns = size(n)
-        m = m(:)
-        n = n(:)
-        if length(n)>1 & length(m)>1 & or(ns <> ms) then
+        if length(n)>1 & length(m)>1 & or(size(n) <> size(m)) then
             msg = _("%s: Wrong size for input arguments: Same size expected.\n")
             error(msprintf(msg, "modulo"))
         end
         i = n - int(n ./ m) .* m
         i = iconvert(i, inttype(n))
-        if length(m)>1 then
-            s = ms
-        else
-            s = ns
-        end
-        i = matrix(i, s)
     else
-        [i,q] = pdiv(n, m)
+        [i,?] = pdiv(n, m)
     end
 
 endfunction
index e92f73f..1f3174b 100644 (file)
@@ -2,7 +2,7 @@
 // Copyright (C) INRIA
 // Copyright (C) DIGITEO - 2011 - Allan CORNET
 // Copyright (C) 2012 - Scilab Enterprises - Adeline CARNIS
-// Copyright (C) 2013 - Samuel GOUGEON :  : bugs 12373 & 13002
+// Copyright (C) 2013, 2018 - Samuel GOUGEON
 //
 // Copyright (C) 2012 - 2016 - Scilab Enterprises
 //
@@ -14,8 +14,6 @@
 // along with this program.
 
 function i = pmodulo(n, m)
-    //i=pmodulo(n,m) the "positive modulo" of m et n.
-    //i=n-floor(n./m).*m
 
     [lhs, rhs] = argn(0);
     if rhs <> 2 then
@@ -23,17 +21,17 @@ function i = pmodulo(n, m)
         error(msprintf(msg, "pmodulo", 2))
     end
 
-    mt = type(m($))
-    nt = type(n($))
+    mt = type(m)
+    nt = type(n)
 
     // -----------------------  Checking arguments --------------------------
 
-    if or(type(n)==[15 16]) | and(nt <> [1 2 8]) | (nt==1 & ~isreal(n)) then
+    if and(nt <> [1 2 8]) | (nt==1 & ~isreal(n)) then
         msg = _("%s: Wrong type for input argument #%d: Real, integer or polynomial matrix expected.\n")
         error(msprintf(msg, "pmodulo", 1))
     end
 
-    if or(type(m)==[15 16]) | and(mt <> [1 2 8]) | (mt==1 & ~isreal(m)) then
+    if and(mt <> [1 2 8]) | (mt==1 & ~isreal(m)) then
         msg = _("%s: Wrong type for input argument #%d: Real, integer or polynomial matrix expected.\n")
         error(msprintf(msg, "pmodulo", 2))
     end
@@ -43,39 +41,30 @@ function i = pmodulo(n, m)
         error(msprintf(msg, "pmodulo"))
     end
 
-    // --------------------------  Processing ----------------------------
+    // --------------------------  Processing ------------------------
 
-    if isempty(m)
+    if m==[]
         i = n;
         return;
     end
     if  nt==2 then
-        [i,q] = pdiv(n, m)
+        [i,?] = pdiv(n, m)
     else
-        ms = size(m)
-        ns = size(n)
-        m = m(:)
-        n = n(:)
         m = abs(m)  // else returns i<0 for m<0 : http://bugzilla.scilab.org/12373
-        if length(n)>1 & length(m)>1 & or(ns<>ms) then
+        if length(n)>1 & length(m)>1 & or(size(n)<>size(m)) then
             msg = _("%s: Wrong size for input arguments: Same size expected.\n")
             error(msprintf(msg, "pmodulo"))
         end
         i = n - floor(n ./ m) .* m
         k = find(i<0)           // this may occur for encoded integers
-        if length(m)>1 then
-            if ~isempty(k)
+        if k~=[]
+            if length(m)>1 then
                 i(k) = i(k) + m(k)
-            end
-            i = iconvert(i, inttype(n))
-            i = matrix(i, ms)
-        else
-            if ~isempty(k)
+            else
                 i(k) = i(k) + m
             end
-            i = iconvert(i, inttype(n))
-            i = matrix(i, ns)
         end
+        i = iconvert(i, inttype(n))
     end
 
 endfunction
diff --git a/scilab/modules/elementary_functions/tests/unit_tests/modulo.dia.ref b/scilab/modules/elementary_functions/tests/unit_tests/modulo.dia.ref
deleted file mode 100644 (file)
index ec0019e..0000000
+++ /dev/null
@@ -1,63 +0,0 @@
-// =============================================================================
-// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
-// Copyright (C) 2013 - Scilab Enterprises - Bruno JOFRET
-//
-//  This file is distributed under the same license as the Scilab package.
-// =============================================================================
-// <-- CLI SHELL MODE -->
-// unit tests for modulo() function
-// =============================================================================
-assert_checkerror("modulo()", msprintf(_("%s: Wrong number of input argument(s): %d expected.\n"),"modulo", 2));
-assert_checkerror("modulo(''a'',1)", msprintf(_("%s: Wrong type for input argument #%d: Real, integer or polynomial matrix expected.\n"), "modulo", 1));
-assert_checkerror("modulo(1,''a'')", msprintf(_("%s: Wrong type for input argument #%d: Real, integer or polynomial matrix expected.\n"), "modulo", 2));
-assert_checkerror("modulo(%pi+%i,1)", msprintf(_("%s: Wrong type for input argument #%d: Real, integer or polynomial matrix expected.\n"), "modulo", 1));
-assert_checkerror("modulo(1,1+%i)", msprintf(_("%s: Wrong type for input argument #%d: Real, integer or polynomial matrix expected.\n"), "modulo", 2));
-n=[1,2,10,15];
-m=[2,2,3,5];
-r = modulo(n,m);
-assert_checkequal(r, [1,0,1,0]);
-n = 100 * rand(1,100);
-m = 100 * rand(1,100);
-r = modulo(n,m);
-computed_r = n - m .* int (n ./ m);
-assert_checkequal(r, computed_r);
-assert_checkequal(modulo(%z^2,%z),0);
-// Encoded integers
-assert_checkequal(modulo( int8(-123), int16(-7)), int8(-4));
-assert_checkequal(pmodulo(int8(-123), int16(-7)), int8(3));
-assert_checkequal(modulo( int8(-123), int16([-7 5])),int8([-4,-3]));
-assert_checkequal(pmodulo(int8(-123), int16([-7 5])),int8([3,2]));
-assert_checkequal(modulo( int8([-123 51]), int16(-7)),  int8([-4,2]));
-assert_checkequal(pmodulo(int8([-123 51]), int16(-7)),int8([3,2]));
-assert_checkequal(modulo( int8([-123 51]), int16([-7 5])),int8([-4,1]) );
-assert_checkequal(pmodulo(int8([-123 51]), int16([-7 5])),  int8([3,1]));
-// Hypermatrices
-m = matrix(1:8, [2 2 2]);
-n = matrix(-9:-2, [2 2 2])
- n  = 
-(:,:,1)
-  -9.  -7.
-  -8.  -6.
-(:,:,2)
-  -5.  -3.
-  -4.  -2.
-a=[1 3;2 4];a(:,:,2)=[0 2; 1 3];
-assert_checkequal(modulo(m, 5), a );
-assert_checkequal(pmodulo(m,5), a);
-a=[6 2;3 3];a(:,:,2)=[1 0; 3 1];
-assert_checkequal(modulo(51, n), a);
-assert_checkequal(pmodulo(51,n), a);
-a=[1 3;2 4];a(:,:,2)=[0 1; 2 0];
-assert_checkequal(modulo(m, n), a);
-assert_checkequal(pmodulo(m,n), a);
-// Polynomials
-assert_checkequal(modulo( %z^2+1, %z), 1);
-assert_checkequal(pmodulo(%z^2+1, %z), 1);
-assert_checkequal(modulo(     -9 ,     [-7 5]) ,[-2 -4]);
-assert_checkequal(modulo(int8(-9),int8([-7 5])),int8([-2 -4]));
-assert_checkequal(modulo(      9 ,     [-7 5]) ,[2 4]);
-assert_checkequal(modulo( int8(9),int8([-7 5])),int8([2 4]));
-assert_checkequal(pmodulo(     -9,      [-7 5]) ,[5 1]);
-assert_checkequal(pmodulo(int8(-9),int8([-7 5])),int8([5 1]));
-assert_checkequal(pmodulo(      9,      [-7 5]) ,[2 4]);
-assert_checkequal(pmodulo( int8(9),int8([-7 5])),int8([2 4]));
index 2af7f25..e73fc86 100644 (file)
@@ -1,13 +1,16 @@
 // =============================================================================
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
 // Copyright (C) 2013 - Scilab Enterprises - Bruno JOFRET
+// Copyright (C) 2013 - Scilab Enterprises - Sylvestre LEDRU
+// Copyright (C) 2018 - Samuel GOUGEON
 //
 //  This file is distributed under the same license as the Scilab package.
 // =============================================================================
 
 // <-- CLI SHELL MODE -->
+// <-- NO CHECK REF -->
 
-// unit tests for modulo() function
+// unitary tests for modulo() and pmodulo() functions
 // =============================================================================
 
 assert_checkerror("modulo()", msprintf(_("%s: Wrong number of input argument(s): %d expected.\n"),"modulo", 2));
@@ -26,21 +29,9 @@ m = 100 * rand(1,100);
 r = modulo(n,m);
 computed_r = n - m .* int (n ./ m);
 assert_checkequal(r, computed_r);
-
-assert_checkequal(modulo(%z^2,%z),0);
-// Encoded integers
-assert_checkequal(modulo( int8(-123), int16(-7)), int8(-4));
-assert_checkequal(pmodulo(int8(-123), int16(-7)), int8(3));
-assert_checkequal(modulo( int8(-123), int16([-7 5])),int8([-4,-3]));
-assert_checkequal(pmodulo(int8(-123), int16([-7 5])),int8([3,2]));
-assert_checkequal(modulo( int8([-123 51]), int16(-7)),  int8([-4,2]));
-assert_checkequal(pmodulo(int8([-123 51]), int16(-7)),int8([3,2]));
-assert_checkequal(modulo( int8([-123 51]), int16([-7 5])),int8([-4,1]) );
-assert_checkequal(pmodulo(int8([-123 51]), int16([-7 5])),  int8([3,1]));
-
 // Hypermatrices
 m = matrix(1:8, [2 2 2]);
-n = matrix(-9:-2, [2 2 2])
+n = matrix(-9:-2, [2 2 2]);
 a=[1 3;2 4];a(:,:,2)=[0 2; 1 3];
 assert_checkequal(modulo(m, 5), a );
 assert_checkequal(pmodulo(m,5), a);
@@ -51,11 +42,9 @@ a=[1 3;2 4];a(:,:,2)=[0 1; 2 0];
 assert_checkequal(modulo(m, n), a);
 assert_checkequal(pmodulo(m,n), a);
 
-// Polynomials
-assert_checkequal(modulo( %z^2+1, %z), 1);
-assert_checkequal(pmodulo(%z^2+1, %z), 1);
-
 
+// ENCODED INTEGERS
+// Same inttypes
 assert_checkequal(modulo(     -9 ,     [-7 5]) ,[-2 -4]);
 assert_checkequal(modulo(int8(-9),int8([-7 5])),int8([-2 -4]));
 assert_checkequal(modulo(      9 ,     [-7 5]) ,[2 4]);
@@ -65,4 +54,29 @@ assert_checkequal(pmodulo(     -9,      [-7 5]) ,[5 1]);
 assert_checkequal(pmodulo(int8(-9),int8([-7 5])),int8([5 1]));
 assert_checkequal(pmodulo(      9,      [-7 5]) ,[2 4]);
 assert_checkequal(pmodulo( int8(9),int8([-7 5])),int8([2 4]));
+// Distinct inttypes
+assert_checkequal(modulo( int8(-123), int16(-7)), int8(-4));
+assert_checkequal(pmodulo(int8(-123), int16(-7)), int8(3));
+assert_checkequal(modulo( int8(-123), int16([-7 5])),int8([-4,-3]));
+assert_checkequal(pmodulo(int8(-123), int16([-7 5])),int8([3,2]));
+assert_checkequal(modulo( int8([-123 51]), int16(-7)),  int8([-4,2]));
+assert_checkequal(pmodulo(int8([-123 51]), int16(-7)),int8([3,2]));
+assert_checkequal(modulo( int8([-123 51]), int16([-7 5])),int8([-4,1]) );
+assert_checkequal(pmodulo(int8([-123 51]), int16([-7 5])),  int8([3,1]));
+// Hypermatrices
+m = grand(2,4,2, "uin", -120, 120);
+n = grand(2,4,2, "uin", -100, 100);
+assert_checkequal(modulo(int8(m), int8(n)), int8(modulo(m,n)));
+assert_checkequal(modulo(int16(m), int8(n)), int16(modulo(m,n)));
+assert_checkequal(pmodulo(int8(m), int8(n)), int8(pmodulo(m,n)));
+assert_checkequal(pmodulo(int16(m), int8(n)), int16(pmodulo(m,n)));
 
+
+// POLYNOMIALS
+assert_checkequal(modulo(%z^2,%z),0);
+assert_checkequal(modulo( %z^2+1, %z), 1);
+assert_checkequal(pmodulo(%z^2+1, %z), 1);
+// Hypermatrices
+h = grand(2,2,2, "uin", 1,9)*%s;
+assert_checkequal(modulo(h,h),zeros(h));
+assert_checkequal(pmodulo(h,h),zeros(h));
index 456664f..c69a2e0 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
  *
     </refnamediv>
     <refsynopsisdiv>
         <title>Syntax</title>
-        <synopsis>[R,Q]=pdiv(P1,P2)
-            [Q]=pdiv(P1,P2)
+        <synopsis>
+            [R, Q] = pdiv(P1,P2)
+            Q = pdiv(P1,P2)
         </synopsis>
     </refsynopsisdiv>
     <refsection>
         <title>Arguments</title>
         <variablelist>
             <varlistentry>
-                <term>P1</term>
+                <term>P1, R, Q</term>
                 <listitem>
-                    <para>polynomial matrix</para>
+                    <para>
+                        arrays of polynomials with real or complex coefficients, of same sizes.
+                         <varname>Q</varname> are Quotients and <varname>R</varname> are Remainders.
+                    </para>
+                    <para>
+                      When all remainders <varname>R</varname> are constant (degree==0),
+                      <varname>R</varname> is of type 1 (numbers) instead of 2 (polynomials).
+                    </para>
                 </listitem>
             </varlistentry>
             <varlistentry>
                 <term>P2</term>
                 <listitem>
-                    <para>polynomial or polynomial matrix</para>
-                </listitem>
-            </varlistentry>
-            <varlistentry>
-                <term>R,Q</term>
-                <listitem>
-                    <para>two polynomial matrices</para>
+                    <para>
+                        single polynomial, or array of polynomials of size(P1).
+                    </para>
                 </listitem>
             </varlistentry>
         </variablelist>
     <refsection>
         <title>Description</title>
         <para>
-            Element-wise euclidan division of the polynomial matrix <literal>P1</literal>
-            by the polynomial <literal>P2</literal> or by the polynomial matrix <literal>P2</literal>.
-            <literal>Rij</literal> is the matrix of remainders, <literal>Qij</literal> is the matrix
-            of quotients and <literal>P1ij = Qij*P2 + Rij</literal> or <literal>P1ij = Qij*P2ij + Rij</literal>.
+            Element-wise euclidan division of the polynomial array <literal>P1</literal>
+            (scalar, vector, matrix or hypermatrix) by the polynomial <literal>P2</literal>
+            or by the polynomial array <literal>P2</literal>.
+            <literal>R</literal> is the array of remainders, <literal>Q</literal> is the array
+            of quotients, such that <literal>P1 = Q*P2 + R</literal> or
+            <literal>P1 = Q.*P2 + R</literal>.
         </para>
     </refsection>
     <refsection>
         <title>Examples</title>
         <programlisting role="example"><![CDATA[
-x=poly(0,'x');
-p1=(1+x^2)*(1-x);p2=1-x;
-[r,q]=pdiv(p1,p2)
+x = poly(0,'x');
+//
+p1 = (1+x^2)*(1-x);
+p2 = 1-x;
+[r,q] = pdiv(p1, p2)
 p2*q-p1
-p2=1+x;
-[r,q]=pdiv(p1,p2)
-p2*q+r-p1
+
+// With polynomials with complex coefficients
+p1 = (x-%i)*(x+2*%i);    printf("%s\n",string(p1))
+p2 = 1-x;
+[r, q] = pdiv(p1, p2);   printf("%s\n", string([r;q]))
+p = q*p2 + r;            printf("%s\n", string(p)); // p1 expected
+
+// Elementwise processing:
+p1 = [1+x-x^2 , x^3-x+1];
+p2 = [2-x , x^2-3];
+[r,q] = pdiv(p1, p2)
  ]]></programlisting>
     </refsection>
     <refsection role="see also">
@@ -88,7 +105,11 @@ p2*q+r-p1
     <revhistory>
         <revision>
             <revnumber>6.0.0</revnumber>
-            <revremark>pdiv return a matrix of type 'constant' when all ranks are 0.</revremark>
+            <revremark>pdiv now returns a matrix of type 'constant' when all degrees are 0.</revremark>
+        </revision>
+        <revision>
+            <revnumber>6.0.2</revnumber>
+            <revremark>Extension to hypermatrices.</revremark>
         </revision>
     </revhistory>
 </refentry>
index ea07f49..5b6e757 100644 (file)
@@ -1,39 +1,56 @@
 <?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.
+ *
+ -->
 <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="pdiv">
     <refnamediv>
         <refname>pdiv</refname>
-        <refpurpose>division de polynômes  </refpurpose>
+        <refpurpose>division de polynômes</refpurpose>
     </refnamediv>
     <refsynopsisdiv>
         <title>Séquence d'appel</title>
-        <synopsis>[R,Q]=pdiv(P1,P2)
-            [Q]=pdiv(P1,P2)
+        <synopsis>
+            [R, Q] = pdiv(P1, P2)
+            Q = pdiv(P1, P2)
         </synopsis>
     </refsynopsisdiv>
     <refsection>
-        <title>Paramètres</title>
+        <title>Arguments</title>
         <variablelist>
             <varlistentry>
-                <term>P1  </term>
+                <term>P1, Q, R</term>
                 <listitem>
-                    <para>matrice de polynômes
+                    <para>
+                        Tableaux de polynômes à coefficients réels ou complexes, de mêmes tailles.
+                        <varname>Q</varname> donne les Quotients. <varname>R</varname> donne les
+                        restes de la division membre à membre.
                     </para>
-                </listitem>
-            </varlistentry>
-            <varlistentry>
-                <term>P2  </term>
-                <listitem>
-                    <para>polynôme ou matrice de polynômes
+                    <para>
+                      Lorsque tous les restes <varname>R</varname> sont des polynômes constants
+                      (degrés==0), <varname>R</varname> est de type (nombres) au lieu de 2 (polynômes).
                     </para>
                 </listitem>
             </varlistentry>
             <varlistentry>
-                <term>R,Q  </term>
+                <term>P2</term>
                 <listitem>
-                    <para>deux matrices de polynômes
+                    <para>
+                        Polynôme unique, ou tableau de polynômes de taille size(P1).
                     </para>
                 </listitem>
             </varlistentry>
     <refsection>
         <title>Description</title>
         <para>
-            Division euclidienne élément par élément de la matrice de polynômes <literal>P1</literal>
-            par le polynôme <literal>P2</literal> ou par la matrice de polynômes <literal>P2</literal>.
-            <literal>Rij</literal> est la matrice des restes, <literal>Qij</literal> est la matrice
-            des quotients et <literal>P1ij = Qij*P2 + Rij</literal> ou <literal>P1ij = Qij*P2ij + Rij</literal>.
+            Division euclidienne élément par élément de la matrice de polynômes <varname>P1</varname>
+            par le polynôme <varname>P2</varname> ou par la matrice de polynômes <varname>P2</varname>,
+            telle que <literal>P1 = Q * P2 + R</literal> ou <literal>P1 = Q .* P2 + R</literal>.
         </para>
     </refsection>
     <refsection>
         <title>Exemples</title>
         <programlisting role="example"><![CDATA[
-x=poly(0,'x');
-p1=(1+x^2)*(1-x);p2=1-x;
-[r,q]=pdiv(p1,p2)
+x = poly(0,'x');
+//
+p1 = (1+x^2)*(1-x);
+p2 = 1-x;
+[r,q] = pdiv(p1, p2)
 p2*q-p1
-p2=1+x;
-[r,q]=pdiv(p1,p2)
-p2*q+r-p1
+
+// Avec des polynômes à coefficients complexes
+p1 = (x-%i)*(x+2*%i);    printf("%s\n",string(p1))
+p2 = 1-x;
+[r, q] = pdiv(p1, p2);   printf("%s\n", string([r;q]))
+p = q*p2 + r;            printf("%s\n", string(p)); // p1 attendu
+
+// Traitement élément par élément
+p1 = [1+x-x^2 , x^3-x+1];
+p2 = [2-x , x^2-3];
+[r,q] = pdiv(p1, p2)
  ]]></programlisting>
     </refsection>
     <refsection role="see also">
@@ -77,7 +103,14 @@ p2*q+r-p1
     <revhistory>
         <revision>
             <revnumber>6.0.0</revnumber>
-            <revremark>pdiv retourne une matrice de 'constant' quand tous les rangs sont nuls.</revremark>
+            <revremark>
+              pdiv() retourne désormais une matrice de type 1 (nombres) au lieu de 2
+              (polynômes (constants)) quand tous les restes sont de degré nul.
+            </revremark>
+        </revision>
+        <revision>
+            <revnumber>6.0.2</revnumber>
+            <revremark>Extension aux hypermatrices.</revremark>
         </revision>
     </revhistory>
 </refentry>
index e0c2630..e784bb6 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
  *
     </refnamediv>
     <refsynopsisdiv>
         <title>呼び出し手順</title>
-        <synopsis>[R,Q]=pdiv(P1,P2)
-            [Q]=pdiv(P1,P2)
+        <synopsis>
+            [R,Q] = pdiv(P1, P2)
+            Q = pdiv(P1, P2)
         </synopsis>
     </refsynopsisdiv>
     <refsection>
         <title>パラメータ</title>
         <variablelist>
             <varlistentry>
-                <term>P1</term>
+                <term>P1, R, Q</term>
                 <listitem>
-                    <para>多項式の行列</para>
+                    <para>
+                        同一サイズの実係数または複素係数を持つ多項式の配列。
+                        <varname>Q</varname>は商であり、<varname>R</varname>は剰余である。
+                    </para>
+                    <para>
+                      When all remainders <varname>R</varname> are constant (degree==0),
+                      <varname>R</varname> is of type 1 (numbers) instead of 2 (polynomials).
+                    </para>
                 </listitem>
             </varlistentry>
             <varlistentry>
                 <term>P2</term>
                 <listitem>
-                    <para>多項式または多項式行列 </para>
-                </listitem>
-            </varlistentry>
-            <varlistentry>
-                <term>R,Q</term>
-                <listitem>
-                    <para>多項式行列</para>
+                    <para>単一多項式、またはsize(P1)の多項式の配列です。</para>
                 </listitem>
             </varlistentry>
         </variablelist>
             多項式行列<literal>P1</literal>の多項式<literal>P2</literal>または
             多項式行列<literal>P2</literal>による
             要素毎のユークリッド除算.
-            <literal>Rij</literal>は余りの行列,
-            <literal>Qij</literal>は商の行列,そして,
-            <literal>P1ij = Qij*P2 + Rij</literal> または <literal>P1ij = Qij*P2ij + Rij</literal>
+            <varname>R</varname>は余りの行列,
+            <varname>Q</varname>は商の行列,そして,
+            <literal>P1 = Q*P2 + Rij</literal> または <literal>P1 = Q .* P2 + R</literal>
             です.
         </para>
     </refsection>
     <refsection>
         <title>例</title>
         <programlisting role="example"><![CDATA[
-x=poly(0,'x');
-p1=(1+x^2)*(1-x);p2=1-x;
-[r,q]=pdiv(p1,p2)
+x = poly(0,'x');
+//
+p1 = (1+x^2)*(1-x);
+p2 = 1-x;
+[r,q] = pdiv(p1, p2)
 p2*q-p1
-p2=1+x;
-[r,q]=pdiv(p1,p2)
-p2*q+r-p1
+
+// 複素係数を持つ多項式
+p1 = (x-%i)*(x+2*%i);    printf("%s\n",string(p1))
+p2 = 1-x;
+[r, q] = pdiv(p1, p2);   printf("%s\n", string([r;q]))
+p = q*p2 + r;            printf("%s\n", string(p)); // p1は期待される
+
+// 要素単位処理
+p1 = [1+x-x^2 , x^3-x+1];
+p2 = [2-x , x^2-3];
+[r,q] = pdiv(p1, p2)
  ]]></programlisting>
     </refsection>
     <refsection role="see also">
@@ -88,4 +101,14 @@ p2*q+r-p1
             </member>
         </simplelist>
     </refsection>
+    <revhistory>
+        <revision>
+            <revnumber>6.0.0</revnumber>
+            <revremark>pdivはすべてのランクが0のときに 'constant'型の行列を返すようになりました。</revremark>
+        </revision>
+        <revision>
+            <revnumber>6.0.2</revnumber>
+            <revremark>ハイパーマトリックスへの拡張。</revremark>
+        </revision>
+    </revhistory>
 </refentry>
index 25a5f83..d1d97aa 100644 (file)
@@ -1,7 +1,8 @@
-<?xml version="1.0" encoding="ISO-8859-1"?>
+<?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
  *
     </refnamediv>
     <refsynopsisdiv>
         <title> Seqüência de Chamamento </title>
-        <synopsis>[R,Q]=pdiv(P1,P2)
-            [Q]=pdiv(P1,P2)
+        <synopsis>
+            [R,Q] = pdiv(P1, P2)
+            Q = pdiv(P1, P2)
         </synopsis>
     </refsynopsisdiv>
     <refsection>
         <title>Parâmetros</title>
         <variablelist>
             <varlistentry>
-                <term>P1</term>
+                <term>P1, R, Q</term>
                 <listitem>
-                    <para>matriz de polinômios </para>
+                    <para>
+                        arrays de polinômios com coeficientes reais ou complexos, do mesmo tamanho.
+                        <varname>Q</varname> são Quocientes e <varname>R</varname> são Restos.
+                    </para>
+                    <para>
+                      When all remainders <varname>R</varname> are constant (degree==0),
+                      <varname>R</varname> is of type 1 (numbers) instead of 2 (polynomials).
+                    </para>
                 </listitem>
             </varlistentry>
             <varlistentry>
                 <term>P2</term>
                 <listitem>
-                    <para>polinômio ou matriz de polinômios</para>
-                </listitem>
-            </varlistentry>
-            <varlistentry>
-                <term>R,Q</term>
-                <listitem>
-                    <para>duas matrizes de polinômios</para>
+                    <para>single polinomial, ou array de polinômios de size(P1).</para>
                 </listitem>
             </varlistentry>
         </variablelist>
     </refsection>
     <refsection>
         <title>Descrição</title>
-        <para>Divisão euclidiana elemento a elemento da matriz de polinômios
-            <literal>P1</literal> pelo polinômio <literal>P2</literal> ou pela matriz
-            de polinômios <literal>P2</literal>. <literal>Rij</literal> é a matriz de
-            restos, <literal>Qij</literal> é a matriz de quocientes e <literal>P1ij =
-                Qij*P2 + Rij
-            </literal>
-            ou <literal>P1ij = Qij*P2ij + Rij</literal>.
+        <para>
+            Divisão euclidiana elemento a elemento da array de polinômios <varname>P1</varname>
+            (escalar, vetor, matriz ou hipermatriz) pelo polinômio <varname>P2</varname> ou pela
+            array de polinômios <varname>P2</varname>. <varname>R</varname> é a array de
+            restos, <varname>Q</varname> é a array de quocientes tal que
+            <literal>P1 = Q*P2 + Rij</literal> ou <literal>P1 = Q.*P2 + R</literal>.
         </para>
     </refsection>
     <refsection>
         <title>Exemplos</title>
         <programlisting role="example"><![CDATA[
-x=poly(0,'x');
-p1=(1+x^2)*(1-x);p2=1-x;
-[r,q]=pdiv(p1,p2)
+x = poly(0,'x');
+//
+p1 = (1+x^2)*(1-x);
+p2 = 1-x;
+[r,q] = pdiv(p1, p2)
 p2*q-p1
-p2=1+x;
-[r,q]=pdiv(p1,p2)
-p2*q+r-p1
+
+// Com polinômios com coeficientes complexos
+p1 = (x-%i)*(x+2*%i);    printf("%s\n",string(p1))
+p2 = 1-x;
+[r, q] = pdiv(p1, p2);   printf("%s\n", string([r;q]))
+p = q*p2 + r;            printf("%s\n", string(p)); // p1 esperado
+
+// Processamento elemento por elemento
+p1 = [1+x-x^2 , x^3-x+1];
+p2 = [2-x , x^2-3];
+[r,q] = pdiv(p1, p2)
  ]]></programlisting>
     </refsection>
     <refsection>
-        <title> Ver Também </title>
+        <title>Ver Também</title>
         <simplelist type="inline">
             <member>
                 <link linkend="ldiv">ldiv</link>
@@ -87,4 +99,16 @@ p2*q+r-p1
             </member>
         </simplelist>
     </refsection>
+    <revhistory>
+        <revision>
+            <revnumber>6.0.0</revnumber>
+            <revremark>pdiv() now returns an array R of numbers (type 1) instead of constant
+              polynomials (type 2) when all remainders have a degree 0.
+            </revremark>
+        </revision>
+        <revision>
+            <revnumber>6.0.2</revnumber>
+            <revremark>Extensão para hypermatrices.</revremark>
+        </revision>
+    </revhistory>
 </refentry>
index ca94d4e..44517de 100644 (file)
@@ -1,7 +1,7 @@
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
 // Copyright (C) ????-2008 - INRIA
-//
 // Copyright (C) 2012 - 2016 - Scilab Enterprises
+// Copyright (C) 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 [R,Q]=pdiv(P1,P2)
+function [R, Q] = pdiv(P1, P2)
     // Element wise euclidan division of a polynomial matrix
     // by a polynomial
     // This is just a loop for the primitive pppdiv
     //!
-    [lhs,rhs]=argn(0);
-    [n,m]=size(P1);
-    [n1,m1]=size(P2);
+
     // Special case for constant matrices
-    if type(P1)==1&type(P2)==1 then
-        Q=P1./P2;R=0*P1;
-        if lhs==1 then R=Q; end
-        return;
-    end
-    R=[],Q=[]
-    if n1==1 & m1==1 then
-        for l=1:n,
-            for k=1:m,
-                [rlk,qlk]=pppdiv(P1(l,k),P2),R(l,k)=rlk;Q(l,k)=qlk;
-            end;
-        end
-        if lhs==1 then R=Q;end
+    if type(P1)==1 & type(P2)==1 then
+        Q = P1 ./ P2
+        R = zeros(P1)
 
-        return;
+    else
+        scalarP2 = length(P2)==1
+        s = size(P1)
+        if size(s,2)>2
+            P1 = P1(:)
+            P2 = P2(:)
+        end
+        [n, m] = size(P1)
+        R = zeros(P1)
+        Q = zeros(P1)
+        for l = 1:n
+            for k = 1:m
+                if scalarP2
+                    [rlk, qlk] = pppdiv(P1(l,k), P2)
+                else
+                    [rlk, qlk] = pppdiv(P1(l,k), P2(l,k))
+                end
+                R(l,k) = rlk
+                Q(l,k) = qlk
+            end
+        end
+        if size(s,2)>2
+            Q = matrix(Q, s)
+            R = matrix(R, s)
+        end
     end
-    for l=1:n,
-        for k=1:m,
-            [rlk,qlk]=pppdiv(P1(l,k),P2(l,k)),R(l,k)=rlk;Q(l,k)=qlk;
-        end;
+    if argn(1)==1 then
+        R = Q
     end
-    if lhs==1 then R=Q; end
 endfunction
diff --git a/scilab/modules/polynomials/tests/nonreg_tests/bug_15590.tst b/scilab/modules/polynomials/tests/nonreg_tests/bug_15590.tst
new file mode 100644 (file)
index 0000000..368aea2
--- /dev/null
@@ -0,0 +1,24 @@
+// =============================================================================
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2018 - Samuel GOUGEON
+//
+//  This file is distributed under the same license as the Scilab package.
+// =============================================================================
+//
+// <-- CLI SHELL MODE -->
+// <-- NO CHECK REF -->
+//
+// <-- Non-regression test for bug 15590 -->
+//
+// <-- Bugzilla URL -->
+// http://bugzilla.scilab.org/15590
+//
+// <-- Short Description -->
+// pdiv(), and then modulo() and pmodulo() failed with hypermatrices
+// of polynomials
+
+ph = ones(2,2,2)*%s;
+assert_checkequal(pdiv(ph, ph), ones(2,2,2));
+r = rand(2,2,2)-0.5;
+assert_checkequal(modulo(ph+r, ph), r);
+assert_checkequal(pmodulo(ph+r, ph), r);