* Bug 16450 fixed: [double, integer] & [double ; integer] implemented 75/21475/5
Samuel GOUGEON [Sat, 30 May 2020 21:37:55 +0000 (23:37 +0200)]
  http://bugzilla.scilab.org/16450

Change-Id: I01c9fec1b718ca0802366505664e1d149160a98c

scilab/CHANGES.md
scilab/modules/ast/tests/unit_tests/concatenation.tst
scilab/modules/core/help/en_US/1_keywords/brackets.xml
scilab/modules/core/help/fr_FR/1_keywords/brackets.xml
scilab/modules/core/help/ru_RU/1_keywords/brackets.xml [new file with mode: 0644]
scilab/modules/overloading/macros/%i_c_s.sci [new file with mode: 0644]
scilab/modules/overloading/macros/%i_f_s.sci [new file with mode: 0644]
scilab/modules/overloading/macros/%s_c_i.sci [new file with mode: 0644]
scilab/modules/overloading/macros/%s_f_i.sci [new file with mode: 0644]
scilab/modules/overloading/tests/unit_tests/concatenations_mixed.tst

index c357ae2..73215b5 100644 (file)
@@ -297,10 +297,12 @@ Bug Fixes
 * [#16408](https://bugzilla.scilab.org/16408): toJSON(var, indent, filename) is the right call sequence. Documentation has been udpated.
 * [#16445](https://bugzilla.scilab.org/16445): `colorbar(..)` ignored how to guess `umin` and `umax` for a Champ object (with .colored="on").
 * [#16449](https://bugzilla.scilab.org/16449): Insertion of implicit vector in Cell was crahsing Scilab
+* [#16450](https://bugzilla.scilab.org/16450): Concatenating encoded integers with decimal or complex numbers was not possible.
 * [#16452](https://bugzilla.scilab.org/16452): `setdiff(sparse([1 3 0 2]), sparse([3 7]))` missed returning 0, and wrongly returned 3.
 * [#16454](https://bugzilla.scilab.org/16454): `gsort` yielded an error when sorting any sparse vector including some NaN.
 * [#16473](https://bugzilla.scilab.org/16473): Deleting rows in a sparse squared the matrix with padding zeros (Scilab 6 regression).
 
+
 ### Bugs fixed in 6.1.0:
 * [#2694](https://bugzilla.scilab.org/2694): `bitget` did not accept positive integers of types int8, int16 or int32.
 * [#5824](https://bugzilla.scilab.org/5824): The `datafit` algorithm was not documented.
index 55cfb43..b52834c 100644 (file)
@@ -30,8 +30,8 @@ checkCallOverload("[list(1) list(2)]");
 // Double
 assert_checkequal([ldouble ldouble], [1 2 3 1 2 3]);
 assert_checkequal([ldouble lbool], [ldouble double(lbool)]);
-checkCallOverload("[ldouble lint]");
-checkCallOverload("[ldouble lint16]");
+assert_checkequal([ldouble lint],  [ldouble double(lint)]);
+assert_checkequal([ldouble lint16],  [ldouble double(lint16)]);
 assert_checkequal([ldouble lpoly], [(ldouble + 0*%s) lpoly]);
 assert_checkequal([ldouble lsparse], [sparse(ldouble) lsparse]);
 checkCallOverload("[ldouble lspb]");
@@ -40,8 +40,8 @@ checkCallOverload("[ldouble lsta]");
 
 assert_checkequal([ldouble ; ldouble], matrix([1 1 2 2 3 3], 2, 3));
 assert_checkequal([ldouble ; lbool], [ldouble ; double(lbool)]);
-checkCallOverload("[ldouble ; lint]");
-checkCallOverload("[ldouble ; lint16]");
+assert_checkequal([ldouble ; lint],  [ldouble ; double(lint)]);
+assert_checkequal([ldouble ; lint16],[ldouble ; double(lint16)]);
 assert_checkequal([ldouble ; lpoly], [(ldouble + 0*%s) ; lpoly]);
 assert_checkequal([ldouble ; lsparse], [sparse(ldouble) ; lsparse]);
 checkCallOverload("[ldouble ; lspb]");
@@ -70,7 +70,7 @@ checkCallOverload("[lbool ; lstring]");
 checkCallOverload("[lbool ; lsta]");
 
 // int
-checkCallOverload("[lint ldouble]");
+assert_checkequal([lint ldouble], [double(lint) ldouble]);
 assert_checkequal([lint lbool], int32([1 2 3 1 0 1]));
 assert_checkequal([lint lint], int32([1 2 3 1 2 3]));
 checkCallOverload("[lint lint16]");
@@ -80,7 +80,7 @@ checkCallOverload("[lint lspb]");
 checkCallOverload("[lint lstring]");
 checkCallOverload("[lint lsta]");
 
-checkCallOverload("[lint ; ldouble]");
+assert_checkequal([lint ; ldouble], [double(lint) ; ldouble]);
 assert_checkequal([lint ; lbool], int32([1 2 3;1 0 1]));
 assert_checkequal([lint ; lint], int32(matrix([1 1 2 2 3 3], 2, 3)));
 checkCallOverload("[lint ; lint16]");
index 9a99878..4a0abfa 100644 (file)
@@ -2,7 +2,7 @@
 <!--
  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
  * Copyright (C) 2012 - 2016 - Scilab Enterprises
- * Copyright (C) 2016, 2018 - Samuel GOUGEON
+ * Copyright (C) 2016 - 2020 - 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.
                             rules are the following:
                             <orderedlist>
                                 <listitem>
-                                    boolean &lt; encoded integers.
-                                </listitem>
-                                <listitem>
-                                    boolean &lt; decimal number &lt; complex
+                                    boolean &lt; encoded integers &lt; decimal number &lt; complex
                                 </listitem>
                                 <listitem>decimal number &lt; polynomial &lt; rational
                                     <warning>booleans and polynomials are not compatible.
                                     </warning>
                                 </listitem>
                                 <listitem>
+                                    Any encoded integer can be concatenated only with booleans,
+                                    decimal numbers, or other integers of the same inttype.
+                                    Thus, the expressions
+                                    <literal>[int8(2), uint8(7)]</literal>,
+                                    <literal>[int8(2), int16(7)]</literal>,
+                                    <literal>[int8(2), 7+0*%z]</literal>,
+                                    <literal>[int8(2), sparse(7)]</literal>, or
+                                    <literal>[int8(2), sparse(%t)]</literal>
+                                    will yield an error.
+                                </listitem>
+                                <listitem>
                                     The result becomes complex-encoded as soon as a complex-encoded
                                     component -- value, polynomial, or rational -- is met in the
                                     list (even with a null imaginary part)
-                                    <para>Similarly, the result becomes sparse-encoded
+                                    <para/>
+                                    Similarly, the result becomes sparse-encoded
                                     as soon as a sparse-encoded component is met and processed.
-                                    </para>
                                 </listitem>
                                 <listitem>
                                     It is possible to concatenate polynomials or/and rationals
                                     </literal>.
                                 </listitem>
                                 <listitem>
-                                    Any encoded integer can be concatenated only with booleans or
-                                    with integers of the same inttype. Thus, the expressions
-                                    <literal>[int8(2) uint8(7)]</literal>,
-                                    <literal>[int8(2) int16(7)]</literal>,
-                                    <literal>[int8(2) 1.]</literal> will all yield an error.
-                                </listitem>
-                                <listitem>
                                     Text components can be concatenated (in the set meaning,
                                     with brackets) only with other text components or with the
                                     empty matrix <literal>[]</literal>.
                             <listitem>Recipients must be variables.
                                 Literal expressions are not accepted.
                             </listitem>
-                            <listitem>Variables shall be separated with comas.
+                            <listitem>Variables shall be separated with commas.
                             </listitem>
                             <listitem>In a distributive assignment, there must
                                 be at most as many LHS recipients
@@ -324,21 +325,36 @@ s = poly(0,'s');[1/s,2/s]
 [tf2ss(1/s),tf2ss(2/s)]
 
 [%t %f %f %T %F]
-
-// Heterogeneous concatenations with automatical types conversions
+     ]]></programlisting>
+        <para>
+            Heterogeneous concatenations with automatical type conversions:
+        </para>
+        <programlisting role="example"><![CDATA[
 [%T int8(-5)]
 [%T %pi %f 2]
 [%pi, 2+%i, %F]
+[%pi int16(-1000.84) 1.23]
 v = [%pi+0*%i, %F, %z, (1-%z)^2 ]; typeof(v), isreal(v)
 v = [10 1/%z], typeof(v)
 
-// Incompatible heterogeneous concatenations => ERRORS
+// Special case: int16 and uint8 together, due to initial
+//   conversion to real propagating from left to right
+[%pi int16(-1000.84) uint8(87)]
+     ]]></programlisting>
+        <para>
+            Incompatible heterogeneous concatenations => ERRORS:
+        </para>
+        <programlisting role="example"><![CDATA[
 [%F %z]
-[int8(%pi) uint8(%e)]
-[int8(%pi) int16(%e)]
-[int8(%pi) %e]
-
-// Concatenation of cells arrays:
+[int8(%pi), uint8(%e)]
+[int8(%pi), int16(%e)]
+[int8(-70), sparse(18)]
+[int8(-70), sparse([%T %F])]
+     ]]></programlisting>
+        <para>
+            Concatenation of cells arrays:
+        </para>
+        <programlisting role="example"><![CDATA[
 c1 = {%pi %t};
 c2 = {%z "abc"};
 c = [[{%i} c1] ; [c2, {1/%z^2}]]  // comma mandatory, to not parse c2{1/%z^2}
@@ -432,7 +448,7 @@ s.r([2 4 6])
                 </revdescription>
             </revision>
             <revision>
-                <revnumber>6.1</revnumber>
+                <revnumber>6.1.0</revnumber>
                 <revdescription>
                     <itemizedlist>
                         <listitem>
@@ -445,6 +461,13 @@ s.r([2 4 6])
                     </itemizedlist>
                 </revdescription>
             </revision>
+            <revision>
+                <revnumber>6.1.1</revnumber>
+                <revdescription>
+                    Concatenations between encoded integers and decimal numbers
+                    are now supported.
+                </revdescription>
+            </revision>
         </revhistory>
     </refsection>
 </refentry>
index fbde7f0..246ae0f 100644 (file)
@@ -2,7 +2,7 @@
 <!--
  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
  * Copyright (C) 2012 - 2016 - Scilab Enterprises
- * Copyright (C) 2016, 2018 - Samuel GOUGEON
+ * Copyright (C) 2016 - 2020 - 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.
                             les suivantes :
                             <orderedlist>
                                 <listitem>
-                                    booléen &lt; entier encodé.
-                                </listitem>
-                                <listitem>
-                                    booléen &lt; nombre décimal &lt; nombre complexe
+                                    booléen &lt; entier encodé &lt; nombre décimal &lt; nombre complexe
                                 </listitem>
                                 <listitem>décimal &lt; polynôme &lt; fraction rationelle
                                     <warning>
                                     </warning>
                                 </listitem>
                                 <listitem>
+                                    Tout entier encodé peut être concaténé uniquement avec des
+                                    booléens, des nombres réels ou complexes, ou d'autres entiers
+                                    du même type entier
+                                    (<link linkend="inttype">inttype</link>). Ainsi, les expressions
+                                    <literal>[int8(2) uint8(7)]</literal>,
+                                    <literal>[int8(2) int16(7)]</literal>,
+                                    <literal>[int8(2), 7+0*%z]</literal>,
+                                    <literal>[int8(2), sparse(7)]</literal>, ou
+                                    <literal>[int8(2), sparse(%t)]</literal>
+                                    produiront toutes une erreur.
+                                </listitem>
+                                <listitem>
                                     Le résultat est encodé en valeurs complexes (avec parties
                                     imaginaires éventuellement nulles) dés qu'un élément
                                     -- valeur, polynôme, ou fraction rationnelle -- à valeur
                                     </literal>.
                                 </listitem>
                                 <listitem>
-                                    Tout entier encodé peut être concaténé uniquement avec des
-                                    booléens ou d'autres entiers du même type entier
-                                    (<link linkend="inttype">inttype</link>). Ainsi, les expressions
-                                    <literal>[int8(2) uint8(7)]</literal>,
-                                    <literal>[int8(2) int16(7)]</literal>,
-                                    <literal>[int8(2) 1.]</literal> produiront toutes une erreur.
-                                </listitem>
-                                <listitem>
                                     Les éléments de texte (type "string") peuvent être concaténés
                                     (au sens ensembliste, avec les crochets) uniquement entre eux
                                     ou avec la matrice vide
@@ -346,21 +347,37 @@ s = poly(0,'s');[1/s,2/s]
 [tf2ss(1/s),tf2ss(2/s)]
 
 [%t %f %f %T %F]
-
-// Concaténation d'objets de types compatibles différents, avec transtypages automatiques
+     ]]></programlisting>
+        <para>
+            Concaténation d'objets de types distincts compatibles, avec
+            transtypages automatiques
+        </para>
+        <programlisting role="example"><![CDATA[
 [%T int8(-5)]
 [%T %pi %f 2]
 [%pi, 2+%i, %F]
+[%pi int16(-1000.84) 1.23]
 v = [%pi+0*%i, %F, %z, (1-%z)^2 ]; typeof(v), isreal(v)
 v = [10 1/%z], typeof(v)
 
-// Concaténations hétérogènes d'objets de types incompatibles => ERREURS
+// Cas particulier : int16 et uint8 ensemble, finalement concaténés
+//   par conversion décimale se propageant de gauche à droite :
+[%pi int16(-1000.84) uint8(87)]
+     ]]></programlisting>
+        <para>
+            Concaténations hétérogènes d'objets de types incompatibles => ERREURS
+        </para>
+        <programlisting role="example"><![CDATA[
 [%F %z]
 [int8(%pi) uint8(%e)]
 [int8(%pi) int16(%e)]
-[int8(%pi) %e]
-
-// Concaténation de tableaux de cellules :
+[int8(-70), sparse(18)]
+[int8(-70), sparse([%T %F])]
+     ]]></programlisting>
+        <para>
+            Concaténation de tableaux de cellules :
+        </para>
+        <programlisting role="example"><![CDATA[
 c1 = {%pi %t};
 c2 = {%z "abc"};
 c = [[{%i} c1] ; [c2, {1/%z^2}]]  // virgule obligatoire sinon c2{1/%z^2} => erreur
@@ -456,7 +473,7 @@ s.r([2 4 6])
                 </revdescription>
             </revision>
             <revision>
-                <revnumber>6.1</revnumber>
+                <revnumber>6.1.0</revnumber>
                 <revdescription>
                     <itemizedlist>
                         <listitem>
@@ -470,6 +487,13 @@ s.r([2 4 6])
                     </itemizedlist>
                 </revdescription>
             </revision>
+            <revision>
+                <revnumber>6.1.1</revnumber>
+                <revdescription>
+                    Concaténer des entiers encodés avec des réels ou complexes
+                    est désormais possible.
+                </revdescription>
+            </revision>
         </revhistory>
     </refsection>
 </refentry>
diff --git a/scilab/modules/core/help/ru_RU/1_keywords/brackets.xml b/scilab/modules/core/help/ru_RU/1_keywords/brackets.xml
new file mode 100644 (file)
index 0000000..57fa2dc
--- /dev/null
@@ -0,0 +1,482 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+ * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+ * Copyright (C) 2012 - 2016 - Scilab Enterprises
+ * Copyright (C) 2016 - 2020 - 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.
+ * 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="ru" xml:id="brackets">
+    <refnamediv>
+        <refname>brackets [,;]</refname>
+        <refpurpose>
+            Конкатенация. Получатели присвоения. Результаты функции.
+        </refpurpose>
+    </refnamediv>
+    <refsynopsisdiv>
+        <title>Синтаксис</title>
+        <synopsis>
+            Mh = [m11 m12 m13.. m1N] or [m11, m12, m13,.., m1N]
+            Mv = [m11 ; m21 ; m31..; mN1]
+            M  = [m11, m12,...; m21, m22,...;...]
+            [r1, r2,...] = func(...)
+            [r1, r2,.., rN] = (e1, e2, .., eN)
+            [r1, r2,.., rk] = (e1, e2, .., ek,.., eN)
+            [r1, r2,.., rN] = mylist(:)
+            [r1, r2,.., rN] = S.field([i1 i2.. iN])
+        </synopsis>
+    </refsynopsisdiv>
+    <refsection role="parameters">
+        <title>Аргументы</title>
+        <variablelist>
+            <varlistentry>
+                <term>m11, m12,...  </term>
+                <listitem>
+                    <para>
+                        Множество объектов, предназначенных для конкатенации (и слияния: прежние 
+                        отдельные контейнеры будут удалены). Следующие подмножества типов 
+                        объектов могут смешиваться в процессе, но взаимно исключающие:
+                    <itemizedlist>
+                        <listitem>
+                            Матрицы логических, вещественные, комплексные значения, полиномы, 
+                            дробно-рациональные значения: тип данных результата конкатенации это 
+                            устанавливается правилами, определёнными ниже (см. правила <link linkend="brackets_Types_conversions">
+                            <emphasis role="italic">преобразований типов</emphasis>
+                            </link>).
+                        </listitem>
+                        <listitem>
+                            Матрицы кодированных целых чисел любого типа
+                            <link linkend="inttype">inttype</link>.
+                            <warning>
+                                Кодированные целые числа различных типов не могут 
+                                конкатенироваться друг с другом.
+                            </warning>
+                        </listitem>
+                        <listitem>
+                            Cell-массивы.
+                        </listitem>
+                        <listitem>
+                            Массивы структур с одинаковыми полями. Поля могут быть в разном 
+                            порядке от одного массива к другому.
+                        </listitem>
+                        <listitem>
+                            Типизированные списки типа <link linkend="syslin">syslin</link>.
+                        </listitem>
+                    </itemizedlist>
+                    </para>
+                </listitem>
+            </varlistentry>
+            <varlistentry>
+                <term>M, Mh, Mv</term>
+                <listitem>
+                    <para>
+                        Матрицы с типом всех <varname>m##</varname>
+                        (если они все имеют одинаковый тип данных),
+                        cell-массивы (если <literal>mi</literal> являются такими),
+                        массивы структур (если <literal>mi</literal> являются такими).
+                    </para>
+                </listitem>
+            </varlistentry>
+            <varlistentry>
+                <term>e1, e2,..  </term>
+                <listitem>
+                    <para>
+                        Входные объекты (литералы, как, например,
+                        <literal>-1.23</literal> или <literal>"abcd"</literal>,
+                        переменные или выражения, как, например <literal>a+%pi</literal>
+                        и т.д.).
+                    </para>
+                </listitem>
+            </varlistentry>
+            <varlistentry>
+                <term>mylist</term>
+                <listitem>
+                    <para>Простой список.</para>
+                </listitem>
+            </varlistentry>
+            <varlistentry>
+                <term>S.field</term>
+                <listitem>
+                    <para>
+                        Массив структур с полем с именем <literal>field</literal>.
+                    </para>
+                </listitem>
+            </varlistentry>
+            <varlistentry>
+                <term>i1, i2,..  </term>
+                <listitem>
+                    <para>
+                        Индексы компонентов, выбранных из <varname>S</varname>.
+                    </para>
+                </listitem>
+            </varlistentry>
+            <varlistentry>
+                <term>r1, r2,...  </term>
+                <listitem>
+                    <para>Выходные переменные.</para>
+                </listitem>
+            </varlistentry>
+        </variablelist>
+    </refsection>
+    <refsection role="description">
+        <title>Описание</title>
+        <variablelist>
+            <varlistentry>
+                <term>[] с правой стороны: конкатенаторы</term>
+                <listitem>
+                    <para>[..] объединяют их содержимое простых и совместимых типов
+                        в единородный вектор, матрицу или гиперматрицу.
+                    </para>
+                    <note>
+                        Конкатенация по горизонтали или вертикали является двоичным итерируемым 
+                        оператором. Он исполняется пошагово слева направо и сверху вниз. Таким 
+                        образом, <literal>[1 3 5 7]</literal> исполняется как <literal>[[[1 3] 5] 7]</literal>.
+                    </note>
+                    <para>
+                        Внутри квадратных скобок,
+                        <itemizedlist>
+                            <listitem>
+                                промежутки (пробелы или табуляторы) или запятые используются в 
+                                качестве разделителей столбцов.
+                                <note>
+                                    Использование запятых вместо пробелов безопаснее. Например, 
+                                    <literal>[2 1 +%i]</literal> означает <literal>[2, 1, %i]</literal>,
+                                    в то время как <literal>[2 1 + %i]</literal> означает 
+                                    <literal>[2, 1+%i]</literal>.
+                                </note>
+                            </listitem>
+                            <listitem>
+                                точки с запятой или возврат каретки используются в качестве 
+                                разделителей строк. Множество строк не требует точек продолжения 
+                                <literal>..</literal>
+                            </listitem>
+                        </itemizedlist>
+                    </para>
+                    <refsect3 id="brackets_Types_conversions">
+                        <title>Типы преобразований</title>
+                        <para>
+                            В некоторых пределах квадратные скобки могут применяться для 
+                            множества данных, имеющих разные, но совместимых типов. В этом случае 
+                            некоторые данные конвертируются в доминирующий тип, допустимый для 
+                            этого множества. Главные правила преобразования следующие:
+                            <orderedlist>
+                                <listitem>
+                                    логическое значение &lt; кодированные целые &lt; десятичное число &lt; комплексное число
+                                </listitem>
+                                <listitem>десятичное число &lt; полином &lt; дробно-рациональное значение
+                                    <warning>
+                                        логические значения и полиномы не совместимы.
+                                        <itemizedlist>
+                                            <listitem>
+                                                <literal>[%t 2. %z]</literal> допустимо:
+                                                <literal>[%t 2.]</literal> сначала конвертируется 
+                                                в <literal>[1. 2.]</literal>, а затем принимается
+                                                <literal>[[1. 2.] %z]</literal>.
+                                            </listitem>
+                                            <listitem>
+                                                <literal>[%z %t 2.]</literal> отклоняется и даёт 
+                                                ошибку. Действительно,<literal>[%z %t]</literal>
+                                                не может конвертироваться первым.
+                                            </listitem>
+                                        </itemizedlist>
+                                    </warning>
+                                </listitem>
+                                <listitem>
+                                    Любое кодированное целое может конкатенироваться с 
+                                    логическими значениями, десятичными числами или другими 
+                                    целыми того же типа inttype. Таким образом, выражения
+                                    <literal>[int8(2), uint8(7)]</literal>,
+                                    <literal>[int8(2), int16(7)]</literal>,
+                                    <literal>[int8(2), 7+0*%z]</literal>,
+                                    <literal>[int8(2), sparse(7)]</literal>, или
+                                    <literal>[int8(2), sparse(%t)]</literal>
+                                    приведут к ошибке.
+                                </listitem>
+                                <listitem>
+                                    Результат становится комплексно-кодированным поскольку 
+                                    комплексно-кодированный компонент -- значение, полином или 
+                                    дробно-рациональное значение -- встречается в списке (даже с 
+                                    нулевой мнимой частью)
+                                    <para/>
+                                    Аналогично, результат становится разрежённо-кодированным, 
+                                    поскольку разрежённо-кодированный компонент встречается и 
+                                    обрабатывается.
+                                </listitem>
+                                <listitem>
+                                    Можно конкатенировать полиномы или/и дробно-рациональные выражения, имеющие разные имена переменных. Затем, первый полином или дробно-рациональное выражение, встреченное в списке, устанавливает имя переменной для результата конкатенации:
+                                    <literal>[%z, 1+%s, 1-%i*%s]
+                                        // => [z, 1+z, 1-iz]
+                                    </literal>.
+                                </listitem>
+                                <listitem>
+                                    Текстовые компоненты могут конкатенироваться (в массив, ограниченный квадратными скобками) только с другим текстовыми компонентами или с пустой матрицей <literal>[]</literal>.
+                                </listitem>
+                            </orderedlist>
+                        </para>
+                    </refsect3>
+                    <refsect3 id="brackets_overloading">
+                        <title>Перегрузка</title>
+                        <para>
+                            <itemizedlist>
+                                <listitem>[,]: конкатенация по горизонтали:
+                                    Этот оператор является двоичными и автоматически итерируется 
+                                    слева направо. Его код перегрузки <literal>"c"</literal>.
+                                </listitem>
+                                <listitem>[;]: конкатенация по вертикали:
+                                    Этот оператор является двоичными и автоматически итерируется 
+                                    сверху вниз. Его код перегрузки <literal>"f"</literal>.
+                                </listitem>
+                            </itemizedlist>
+                        </para>
+                    </refsect3>
+                    <para/>
+                    <refsect3>
+                        <title>Расширения</title>
+                        <para>
+                          <itemizedlist>
+                            <listitem>
+                              Для конкатенации простых списков, пожалуйста, используйте <link linkend="lstcat">lstcat</link>.
+                            </listitem>
+                            <listitem>
+                              Для составления векторов или матриц поверх некоторой размерности > 
+                                    2 для построения N-мерного массива, пожалуйста, используйте 
+                                    <link linkend="cat">cat</link>.
+                            </listitem>
+                          </itemizedlist>
+                        </para>
+                    </refsect3>
+                </listitem>
+                <para/>
+            </varlistentry>
+            <varlistentry>
+                <term>[] на левой стороне от присвоения <literal>"="</literal></term>
+                <listitem>
+                    <para>
+                        В этом случае квадратные скобки не являются конкатенаторами. Они 
+                        используются в качестве левого и правого разделителя последовательностей 
+                        переменных, используемых в качестве получателей.
+                    </para>
+                    <para>
+                        <itemizedlist>
+                            <listitem>
+                                Получатели должны быть переменными.
+                                Литеральные выражения не допускаются.
+                            </listitem>
+                            <listitem>Переменные следует разделять запятыми.
+                            </listitem>
+                            <listitem>
+                                В распределённом присвоении необходимо, чтобы получателей на 
+                                левой стороне было по крайней мере столько же, сколько выходных 
+                                источников, не более. Если получателей слева меньше, чем 
+                                источников справа, то источники несобираемых данных игнорируется. 
+                                Примеры:
+                                <simplelist>
+                                    <member><literal>[a,b]=(%pi,"Hi", %z)</literal>
+                                        приемлемо, но <literal>%z</literal> игнорируется.
+                                    </member>
+                                    <member><literal>[a,b,c]=(%pi,"Hi")</literal>
+                                        даст ошибку, поскольку <literal>c</literal>
+                                        ожидает некоторой пищи.
+                                    </member>
+                                </simplelist>
+                            </listitem>
+                            <listitem>
+                                <literal>[a,b,a] = (%pi, %z, "Allo")</literal> выполняет
+                                присвоения слева направо, таким образом, что в конце
+                                концов будет <literal>a = "Allo"</literal>.
+                            </listitem>
+                        </itemizedlist>
+                    </para>
+                </listitem>
+            </varlistentry>
+        </variablelist>
+    </refsection>
+    <refsection role="examples">
+        <title>Примеры</title>
+        <programlisting role="example"><![CDATA[
+// Конкатенация по горизонтали
+a = [ %pi 4 -1 ]
+b1 = grand(3,4,"uin",0,10)
+b2 = grand(3,2,"uin",0,10)
+b = [b1 b2]  // они должны иметь одинаковое количество строк
+
+// Конкатенация по вертикали
+a = [-2 ; 10 ; 7]
+
+b1 = grand(2,4,"uin",0,10)
+b2 = grand(3,4,"uin",0,10)
+b = [b1 ; b2] // они должны иметь одинаковое количество столбцов
+
+// Смешанная конкатенация по горизонтали и вертикали
+a = [ 3 7 ; 6, 5 ]
+b = [ 1:3 ; 7:3:13]
+c = [ a b ; a b]
+
+d = [ 3 5
+      1 4
+    ]
+e = [ d d d
+      d d d
+    ]
+// Конкатенация данных разных типов:
+['this is' ; 'a column' ; 'of texts']
+
+s = poly(0,'s');[1/s,2/s]
+[tf2ss(1/s),tf2ss(2/s)]
+
+[%t %f %f %T %F]
+     ]]></programlisting>
+        <para>
+            Разнородные конкатенации с автоматическими преобразованиями типов:
+        </para>
+        <programlisting role="example"><![CDATA[
+[%T int8(-5)]
+[%T %pi %f 2]
+[%pi, 2+%i, %F]
+[%pi int16(-1000.84) 1.23]
+v = [%pi+0*%i, %F, %z, (1-%z)^2 ]; typeof(v), isreal(v)
+v = [10 1/%z], typeof(v)
+
+// Особый случай: int16 и uint8 вместе, поскольку исходное
+//   преобразование в вещественное значение распространяется слева направо
+[%pi int16(-1000.84) uint8(87)]
+     ]]></programlisting>
+        <para>
+            Несовместимые разнородные преобразования, приводящие к ОШИБКАМ:
+        </para>
+        <programlisting role="example"><![CDATA[
+[%F %z]
+[int8(%pi), uint8(%e)]
+[int8(%pi), int16(%e)]
+[int8(-70), sparse(18)]
+[int8(-70), sparse([%T %F])]
+     ]]></programlisting>
+        <para>
+            Конкатенация cell-массивов:
+        </para>
+        <programlisting role="example"><![CDATA[
+c1 = {%pi %t};
+c2 = {%z "abc"};
+c = [[{%i} c1] ; [c2, {1/%z^2}]]  // запятая обязательна, чтобы не считать, что c2{1/%z^2}
+]]></programlisting>
+
+        <para>
+            <emphasis role="bold">Распределённые присвоения:</emphasis>
+        </para>
+        <programlisting role="example"><![CDATA[
+// Выход функции. Чаще всего, выходные результаты последовательны:
+M = rand(3,3);
+[u, s] = schur(M) // ожидаем и используем как результаты u, так и s
+u = schur(M)      // ожидаем и храним только первый результат u
+
+// Прямой список на правой стороне
+[a, b, c] = (%pi, %t, "test")
+[a, b] = (%e, %f, "Hello")
+[a, b, a] = (%pi, %t, "test"); a
+
+// Явный список на правой стороне
+L = list(%z, %i, %t, %pi, "Text");
+[a, b, c] = L(:)
+
+// Структура на правой стороне
+s(2,3).r = %pi; s(2,1).r = %i; s(2,2) = %e;
+s(2,:).r
+s.r([2 4 6])
+[a, b, c] = s.r([2 4 6])
+
+// Запрещённые / отклоняемые выражения на левой стороне (приводит к ошибке)
+[m, n, m+n] = myfun(a,b)   // Символьные выражения, такие, как "m+n" запрещены
+[p, 4.5, q] = myfun(a,b)   // Литеральные значения на левой стороне или такие выражения, как "4.5" запрещены
+[r, s+3 ] = myfun(a,b)   // Выражения, смешивающие литералы и символьные значения, такие, как "s+3" не могут быть приёмниками на левой стороне
+]]></programlisting>
+        <screen><![CDATA[--> [a, b, c] = (%pi, %t, "test")
+ a  =
+   3.1415927
+
+ b  =
+  T
+
+ c  =
+ test
+
+--> [a, b] = (%e, %f, "Hello")
+ a  =
+   2.7182818
+
+ b  =
+  F
+
+--> [a, b, a] = (%pi, %t, "test"); a
+ a  =
+ test
+]]></screen>
+    </refsection>
+    <refsection role="see also">
+        <title>Смотрите также</title>
+        <simplelist type="inline">
+            <member>
+                <link linkend="cat">cat</link>
+            </member>
+            <member>
+                <link linkend="lstcat">lstcat</link>
+            </member>
+            <member>
+                <link linkend="comma">запятая</link>
+            </member>
+            <member>
+                <link linkend="semicolon">точка с запятой</link>
+            </member>
+            <member>
+                <link linkend="parentheses">фигурные скобки</link>
+            </member>
+            <member>
+                <link linkend="empty">empty</link>
+            </member>
+            <member>
+                <link linkend="overloading">перегрузка</link>
+            </member>
+        </simplelist>
+    </refsection>
+    <refsection role="history">
+        <title>История</title>
+        <revhistory>
+            <revision>
+                <revnumber>6.0</revnumber>
+                <revdescription>
+                    Квадратные скобки <literal>[..]</literal> и фигурные скобки
+                    <literal>{..}</literal> теперь не эквивалентны.
+                </revdescription>
+            </revision>
+            <revision>
+                <revnumber>6.1.0</revnumber>
+                <revdescription>
+                    <itemizedlist>
+                        <listitem>
+                            Логические знаения и кодированные целые числа теперь могут 
+                            конкатенироваться друг с другом, как в [%t, int8(-5)].
+                        </listitem>
+                        <listitem>
+                            [a, b, ..] = (A, B,..) теперь выполняет присвоение слева направо.
+                        </listitem>
+                    </itemizedlist>
+                </revdescription>
+            </revision>
+            <revision>
+                <revnumber>6.1.1</revnumber>
+                <revdescription>
+                    Конкатенации между кодированными целыми и десятичными числами теперь 
+                    поддерживаются.
+                </revdescription>
+            </revision>
+        </revhistory>
+    </refsection>
+</refentry>
diff --git a/scilab/modules/overloading/macros/%i_c_s.sci b/scilab/modules/overloading/macros/%i_c_s.sci
new file mode 100644 (file)
index 0000000..38ef798
--- /dev/null
@@ -0,0 +1,15 @@
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+//
+// Copyright (C) 2020 - 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.
+// 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.
+
+function r = %i_c_s(a, b)
+    // Horizontal concatenation [encoded_integer, double ]
+    r = [double(a), b]
+endfunction
diff --git a/scilab/modules/overloading/macros/%i_f_s.sci b/scilab/modules/overloading/macros/%i_f_s.sci
new file mode 100644 (file)
index 0000000..da44cc3
--- /dev/null
@@ -0,0 +1,15 @@
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+//
+// Copyright (C) 2020 - 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.
+// 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.
+
+function r = %i_f_s(a, b)
+    // Vertical concatenation [encoded_integer ; double ]
+    r = [double(a) ; b]
+endfunction
diff --git a/scilab/modules/overloading/macros/%s_c_i.sci b/scilab/modules/overloading/macros/%s_c_i.sci
new file mode 100644 (file)
index 0000000..efab504
--- /dev/null
@@ -0,0 +1,15 @@
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+//
+// Copyright (C) 2020 - 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.
+// 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.
+
+function r = %s_c_i(a, b)
+    // Horizontal concatenation [double , encoded_integer ]
+    r = [a, double(b)]
+endfunction
diff --git a/scilab/modules/overloading/macros/%s_f_i.sci b/scilab/modules/overloading/macros/%s_f_i.sci
new file mode 100644 (file)
index 0000000..25bdf6e
--- /dev/null
@@ -0,0 +1,15 @@
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+//
+// Copyright (C) 2020 - 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.
+// 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.
+
+function r = %s_f_i(a, b)
+    // Vertical concatenation [ double ; encoded_integer ]
+    r = [a ; double(b)]
+endfunction
index f3e2155..5dc34dd 100644 (file)
@@ -1,6 +1,6 @@
 // =============================================================================
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
-// Copyright (C) 2018 - Samuel GOUGEON
+// Copyright (C) 2018 - 2020 - Samuel GOUGEON
 //
 //  This file is distributed under the same license as the Scilab package.
 // =============================================================================
@@ -9,7 +9,9 @@
 // <-- CLI SHELL MODE -->
 // <-- NO CHECK REF -->
 
+// -----------------------------
 // Booleans and encoded integers
+// -----------------------------
 for i = [1 2 4 8 11 12 14 18]  // loop on inttype codes
     r = [iconvert(-3,i) , %t];
     r2 = [%t , iconvert(-3,i)];
@@ -24,3 +26,16 @@ for i = [1 2 4 8 11 12 14 18]  // loop on inttype codes
     assert_checkequal(size(c) , [2 1]);
     assert_checkequal(size(c2), [2 1]);
 end
+
+// ----------------------------
+// Doubles and encoded integers
+// ----------------------------
+D = list(2, [3 7], [3 ; 7], [1 2 3 ; 4 5 6], cat(3,[1 2 3;4 5 6],[8 4 9;0 3 1]));
+for it = [1 2 4 8 11 12 14 18]  // Loop on integer types
+    for d = D
+        assert_checkequal([d, iconvert(d,it)], [d d]);
+        assert_checkequal([iconvert(d,it), d], [d d]);
+        assert_checkequal([d ; iconvert(d,it)], [d ; d]);
+        assert_checkequal([iconvert(d,it) ; d], [d ; d]);
+    end
+end