* Bug 15534 fixed: [%t int8(-5)] was refused 52/19952/7
Samuel GOUGEON [Sat, 14 Apr 2018 18:53:05 +0000 (20:53 +0200)]
  http://bugzilla.scilab.org/15534
  SEP/Open discussion: http://mailinglists.scilab.org/Scilab-users-SEP-boolean-integer-class-concatenations-tp4037923.html

Change-Id: Id853be8c5c1c87bedb5897ce815cc6c5373932a6

scilab/CHANGES.md
scilab/modules/core/help/en_US/1_keywords/brackets.xml
scilab/modules/core/help/fr_FR/1_keywords/brackets.xml
scilab/modules/helptools/data/configuration/scilab_macros.txt
scilab/modules/overloading/macros/%b_c_i.sci [new file with mode: 0644]
scilab/modules/overloading/macros/%b_f_i.sci [new file with mode: 0644]
scilab/modules/overloading/macros/%i_c_b.sci [new file with mode: 0644]
scilab/modules/overloading/macros/%i_f_b.sci [new file with mode: 0644]
scilab/modules/overloading/tests/unit_tests/concatenations_mixed.tst [new file with mode: 0644]

index 163bbd3..125e9b0 100644 (file)
@@ -139,6 +139,7 @@ Feature changes and additions
   - Improved placement of labels.
 * `nicholschart` is improved: more neutral default frame color; improved labels positionning; colors can now be specified by their predefined name or "#RRGGBB" hexa code; a structure of handles is now returned to easily postprocess both subframes and the set of labels.
 * `sciargs()` returns a column instead of formerly a row.
+* Booleans and encoded integers can now be concatenated together, as in `[%f int8(-5)]`.
 
 Help pages:
 -----------
@@ -247,11 +248,16 @@ Bug Fixes
 * [#15392](http://bugzilla.scilab.org/show_bug.cgi?id=15392): `comet` and `comet3d` did not allow specifying colors with colors names.
 * [#15393](http://bugzilla.scilab.org/show_bug.cgi?id=15393): In a new figure, `nicholschart` plotted nothing. The default frame color was a flashy cyan. The position of gain labels could be puzzling. It was not possible to specify colors by their names. Postprocessing the frames and the set of labels was not easy.
 * [#15425](http://bugzilla.scilab.org/show_bug.cgi?id=15425): The Kronecker product `a.*.b` failed when `a` or `b` or both are hypermatrices, with one or both being polynomials or rationals.
+<<<<<<< HEAD
 * [#15431](http://bugzilla.scilab.org/show_bug.cgi?id=15431): The empty matrix `[]` and its non-convertibility were poorly documented.
 * [#15451](http://bugzilla.scilab.org/show_bug.cgi?id=15451): The code was not adapted to use `lucene 4.10` in Debian.
 * [#15514](http://bugzilla.scilab.org/show_bug.cgi?id=15514): The `set()` documentation page needed to be overhauled.
 * [#15522](http://bugzilla.scilab.org/show_bug.cgi?id=15522): `unique()` was not able to consider all Nan values as the same value. A `uniqueNan` option now allows it.
 * [#15523](http://bugzilla.scilab.org/show_bug.cgi?id=15523): `%ODEOPTIONS(1)=2` didn't work with solvers 'rk' and 'rkf'
+=======
+* [#15523](http://bugzilla.scilab.org/show_bug.cgi?id=15523): `%ODEOPTIONS(1)=2` didn't work with solvers 'rk' and 'rkf' 
+* [#15534](http://bugzilla.scilab.org/show_bug.cgi?id=15534): Booleans and encoded integers could not be concatenated together.
+>>>>>>> 7115870ad73... * Bug 15534 fixed: [%t int8(-5)] was refused
 * [#15577](http://bugzilla.scilab.org/show_bug.cgi?id=15577): `edit` did not accept a line number as text, as with `edit linspace 21`.
 * [#15580](http://bugzilla.scilab.org/show_bug.cgi?id=15580): `det(sparse([],[]))` yielded an error.
 * [#15981](http://bugzilla.scilab.org/show_bug.cgi?id=15981): `wavread()` kept the wav file open and locked when returning on errors. It weakly managed the input file name. It claimed for invalid data formats instead of unsupported ones, with poor information about the current format vs the supported ones. Several error messages refered to a wrong function.
index 78afd11..e9973da 100644 (file)
@@ -1,9 +1,8 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!--
  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
- * Copyright (C) 2016 - Samuel GOUGEON
- *
  * Copyright (C) 2012 - 2016 - Scilab Enterprises
+ * Copyright (C) 2016, 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.
                             into the dominating type available in the set. The main conversion
                             rules are the following:
                             <orderedlist>
-                                <listitem>boolean &lt; decimal number &lt; complex
+                                <listitem>
+                                    boolean &lt; encoded integers.
+                                </listitem>
+                                <listitem>
+                                    boolean &lt; decimal number &lt; complex
                                 </listitem>
                                 <listitem>decimal number &lt; polynomial &lt; rational
                                     <warning>booleans and polynomials are not compatible.
                                         <itemizedlist>
                                             <listitem>
                                                 <literal>[%t 2. %z]</literal> is accepted:
-                                                <literal>[%t 2.]</literal> is first
-                                                converted into
+                                                <literal>[%t 2.]</literal> is first converted into
                                                 <literal>[1. 2.]</literal>, and then
                                                 <literal>[[1. 2.] %z]</literal> is accepted.
                                             </listitem>
                                             <listitem>
-                                                <literal>[%z %t 2.]</literal> is
-                                                rejected and yields an error.
-                                                Indeed, <literal>[%z %t]</literal>
+                                                <literal>[%z %t 2.]</literal> is rejected and yields
+                                                an error. Indeed, <literal>[%z %t]</literal>
                                                 can't be converted first.
                                             </listitem>
                                         </itemizedlist>
                                     </warning>
                                 </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)
+                                    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
-                                    as soon as a sparse-encoded component is met
-                                    and processed.
+                                    as soon as a sparse-encoded component is met and processed.
                                     </para>
                                 </listitem>
                                 <listitem>
-                                    It is possible to concatenate polynomials or/and
-                                    rationals having different variable names. Then,
-                                    the first polynomial or rational met in the list
-                                    sets the variable name to the concatenation result:
+                                    It is possible to concatenate polynomials or/and rationals
+                                    having different variable names. Then, the first polynomial
+                                    or rational met in the list sets the variable name to the
+                                    concatenation result:
                                     <literal>[%z, 1+%s, 1-%i*%s]
                                         // => [z, 1+z, 1-iz]
                                     </literal>.
                                 </listitem>
                                 <listitem>
-                                    Any encoded integer can be concatenated
-                                    only with integers of the same inttype.
-                                    Thus, the expressions
-                                    <literal>[%t int8(2)]</literal>,
+                                    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.
+                                    <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>
+                                    Text components can be concatenated (in the set meaning,
+                                    with brackets) only with other text components or with the
+                                    empty matrix <literal>[]</literal>.
                                 </listitem>
                             </orderedlist>
                         </para>
@@ -334,6 +330,7 @@ s = poly(0,'s');[1/s,2/s]
 [%t %f %f %T %F]
 
 // Heterogeneous concatenations with automatical types conversions
+[%T int8(-5)]
 [%T %pi %f 2]
 [%pi, 2+%i, %F]
 v = [%pi+0*%i, %F, %z, (1-%z)^2 ]; typeof(v), isreal(v)
@@ -341,9 +338,9 @@ v = [10 1/%z], typeof(v)
 
 // Incompatible heterogeneous concatenations => ERRORS
 [%F %z]
-[%F int8(5)]
 [int8(%pi) uint8(%e)]
 [int8(%pi) int16(%e)]
+[int8(%pi) %e]
 
 // Concatenation of cells arrays:
 c1 = {%pi %t};
@@ -406,12 +403,6 @@ s.r([2 4 6])
         <title>See also</title>
         <simplelist type="inline">
             <member>
-                <link linkend="empty">empty</link>
-            </member>
-            <member>
-                <link linkend="parentheses">parentheses</link>
-            </member>
-            <member>
                 <link linkend="cat">cat</link>
             </member>
             <member>
@@ -424,6 +415,12 @@ s.r([2 4 6])
                 <link linkend="semicolon">semicolon</link>
             </member>
             <member>
+                <link linkend="parentheses">parentheses</link>
+            </member>
+            <member>
+                <link linkend="empty">empty</link>
+            </member>
+            <member>
                 <link linkend="overloading">overloading</link>
             </member>
         </simplelist>
@@ -438,6 +435,12 @@ s.r([2 4 6])
                     <literal>{..}</literal> are no longer equivalent
                 </revdescription>
             </revision>
+            <revision>
+                <revnumber>6.1</revnumber>
+                <revdescription>
+                    Booleans and encoded integers can now be concatenated together, as in [%t, int8(-5)].
+                </revdescription>
+            </revision>
         </revhistory>
     </refsection>
 </refentry>
index b911aba..557702c 100644 (file)
@@ -1,8 +1,8 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!--
  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
- * Copyright (C) 2016 - Samuel GOUGEON
  * Copyright (C) 2012 - 2016 - Scilab Enterprises
+ * Copyright (C) 2016, 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.
                     </note>
                     <para>Dans les crochets,
                         <itemizedlist>
-                            <listitem>les espaces (blancs ou tabulations) ou
-                                les virgules servent de séparateurs.
-                                <note>Il est préférable d'utiliser des virgules,
-                                en particulier lorsque des nombres complexes
-                                ou des polynômes sont fournis en expressions
-                                litérales. Par exemple, <literal>[2 1 +%i]</literal>
-                                sera interprété comme <literal>[2, 1, %i]</literal>,
-                                alors que <literal>[2 1 + %i]</literal> sera
-                                compris comme <literal>[2, 1+%i]</literal>.
+                            <listitem>
+                                les espaces (blancs ou tabulations) ou les virgules servent de
+                                séparateurs.
+                                <note>
+                                Il est préférable d'utiliser des virgules, en particulier lorsque
+                                des nombres complexes ou des polynômes sont fournis en expressions
+                                litérales. Par exemple, <literal>[2 1 +%i]</literal> sera interprété
+                                comme <literal>[2, 1, %i]</literal>, alors que
+                                <literal>[2 1 + %i]</literal> sera compris comme
+                                <literal>[2, 1+%i]</literal>.
                                 </note>
                             </listitem>
-                            <listitem>les points-virgules ou les changements de
-                            lignes sont utilisés comme séparateurs de lignes.
-                            Pour peu que la ligne courante soit complète, le
-                            passage à la ligne ne pré-requiert pas les points de
-                            poursuite-à-la-ligne <literal>..</literal>.
+                            <listitem>
+                                les points-virgules ou les changements de lignes sont utilisés comme
+                                séparateurs de lignes. Pour peu que la ligne courante soit complète,
+                                le passage à la ligne ne pré-requiert pas les points de
+                                poursuite-à-la-ligne <literal>..</literal>.
                             </listitem>
                         </itemizedlist>
                     </para>
                     <refsect3 id="brackets_Types_conversions">
                         <title>Transtypages</title>
                         <para>
-                            Avec quelques restrictions, les crochets peuvent être
-                            utilisés sur une série de valeurs ayant des types distincts
-                            mais compatibles. Des valeurs sont alors converties
-                            de proche en proche dans le type de données dominant.
-                            Les principales règles de conversion implicite sont
+                            Avec quelques restrictions, les crochets peuvent être utilisés sur une
+                            série de valeurs ayant des types distincts mais compatibles.
+                            Des valeurs sont alors converties de proche en proche dans le type de
+                            données dominant. Les principales règles de conversion implicite sont
                             les suivantes :
                             <orderedlist>
-                                <listitem>booléen &lt; nombre décimal &lt; nombre complexe
+                                <listitem>
+                                    booléen &lt; entier encodé.
+                                </listitem>
+                                <listitem>
+                                    booléen &lt; nombre décimal &lt; nombre complexe
                                 </listitem>
                                 <listitem>décimal &lt; polynôme &lt; fraction rationelle
-                                    <warning>Les booléens et les polynômes ne sont pas
-                                        compatibles entre eux :
+                                    <warning>
+                                        Les booléens et les polynômes ne sont pas compatibles entre
+                                        eux :
                                         <itemizedlist>
                                             <listitem>
                                                 <literal>[%t 2. %z]</literal> est accepté, car :
-                                                <literal>[%t 2.]</literal> est d'abord
-                                                converti en
+                                                <literal>[%t 2.]</literal> est d'abord converti en
                                                 <literal>[1. 2.]</literal>, puis
-                                                <literal>[[1. 2.] %z]</literal> est
-                                                accepté.
+                                                <literal>[[1. 2.] %z]</literal> est accepté.
                                             </listitem>
                                             <listitem>
-                                                <literal>[%z %t 2.]</literal> est
-                                                refusé et produit une erreur.
-                                                En effet, <literal>[%z %t]</literal>
+                                                <literal>[%z %t 2.]</literal> est refusé et produit
+                                                une erreur. En effet, <literal>[%z %t]</literal>
                                                 n'est pas permis et bloque la suite.
                                             </listitem>
                                         </itemizedlist>
                                     </warning>
                                 </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 complexe est rencontré.
-                                    <para>De même, le résultat est encodé sous forme
-                                    creuse
-                                    dés qu'un élément encodé creux est rencontré.
+                                    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
+                                    complexe est rencontré.
+                                    <para>
+                                        De même, le résultat est encodé sous forme creuse dés qu'un
+                                        élément encodé creux est rencontré.
                                     </para>
                                 </listitem>
                                 <listitem>
-                                    Des polynômes ou des fractions rationnelles
-                                    de différentes variables peuvent
-                                    être concaténés entre eux. Le premier polynôme
-                                    ou fraction rationnelle listé donne alors le
-                                    nom de sa variable au résultat de la concaténation :
+                                    Des polynômes ou des fractions rationnelles de différentes
+                                    variables peuvent être concaténés entre eux. Le premier polynôme
+                                    ou fraction rationnelle listé donne alors le nom de sa variable
+                                    au résultat de la concaténation :
                                     <literal>[%z, 1+%s, 1-%i*%s]
                                         // => [z, 1+z, 1-iz]
                                     </literal>.
                                 </listitem>
                                 <listitem>
-                                    Tout entier encodé peut être concaténé uniquement
-                                    avec d'autres entiers du même type entier
-                                    (<link linkend="inttype">inttype</link>). Ainsi,
-                                    les expressions
-                                    <literal>[%t int8(2)]</literal>,
+                                    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.
+                                    <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
+                                <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
                                 <literal>[]</literal>.
                                 </listitem>
                             </orderedlist>
                         <title>Surcharge</title>
                         <para>
                             <itemizedlist>
-                                <listitem>[,]: concaténation horizontale :
-                                    cet opérateur n-aire (pouvant être appliqué à un
-                                    nombre arbitraire n de données) est en fait un
-                                    opérateur binaire automatiquement itéré de la
+                                <listitem>[,]: concaténation horizontale : cet opérateur n-aire
+                                    (pouvant être appliqué à un nombre arbitraire n de données)
+                                    est en fait un opérateur binaire automatiquement itéré de la
                                     gauche vers la droite. Son code de surcharge est
                                     <literal>"c"</literal>.
                                 </listitem>
-                                <listitem>[;]: la concaténation verticale est
-                                    également un opérateur binaire, itéré du haut
-                                    vers le bas. Son code de surcharge est
+                                <listitem>
+                                    [;]: la concaténation verticale est également un opérateur
+                                    binaire, itéré du haut vers le bas. Son code de surcharge est
                                     <literal>"f"</literal>.
                                 </listitem>
                             </itemizedlist>
                 <term>[] figurant à gauche d'une affectation <literal>"="</literal></term>
                 <listitem>
                     <para>
-                    Dans ce cas, les crochets ne désignent en rien une concaténation.
-                    Ils délimitent une série de variables servant de récipients.
+                        Dans ce cas, les crochets ne désignent en rien une concaténation. Ils
+                        délimitent une série de variables servant de récipients.
                     </para>
                     <para>
                         <itemizedlist>
-                            <listitem>Les termes entre crochets doivent alors
-                                impérativement être des variables. Les expressions
-                                litérales ou symboliques sont rejetées.
+                            <listitem>
+                                Les termes entre crochets doivent alors impérativement être des
+                                variables. Les expressions litérales ou symboliques sont rejetées.
                             </listitem>
-                            <listitem>Les variables sont séparées par des virgules
-                              ou des espaces. Lorsqu'il s'agit de la liste des
-                              arguments de sortie d'une function, les virgules
-                              sont obligatoires.
+                            <listitem>
+                                Les variables sont séparées par des virgules ou des espaces.
+                                Lorsqu'il s'agit de la liste des arguments de sortie d'une function,
+                                les virgules sont obligatoires.
                             </listitem>
                             <listitem>Dans une affectation distributive, il doit
                                 y avoir <emphasis role="italic">au plus</emphasis>
-                                autant de récipients que de sources de données
-                                provenant du terme de droite, pas plus. S'il y
-                                moins de récipients à gauche que de sources à droite,
-                                les sources non collectées sont ignorées. Exemples :
+                                autant de récipients que de sources de données provenant du terme de
+                                droite, pas plus. S'il y moins de récipients à gauche que de sources
+                                à droite, les sources non collectées sont ignorées. Exemples :
                                 <simplelist>
                                     <member><literal>[a,b] = (%pi,"Hi", %z)</literal>
                                         est correct, mais <literal>%z</literal>
                                         produit une erreur, car <literal>c</literal>
                                         attend du contenu.
                                     </member>
-                                </simplelist>                            </listitem>
-                            <listitem>La même variable peut être utilisée plusieurs
-                                fois dans la liste de gauche entre crochets.
-                                Le cas échéant, les affectations successives sont réalisées
-                              <emphasis role="italic">de droite à gauche (!)</emphasis> dans la liste,
-                               et écrasent les contenus pré-existants. Exemple :
+                                </simplelist>
+                            </listitem>
+                            <listitem>
+                                La même variable peut être utilisée plusieurs fois dans la liste
+                                de gauche entre crochets. Le cas échéant, les affectations
+                                successives sont réalisées
+                              <emphasis role="italic">de droite à gauche (!)</emphasis> dans la
+                              liste, et écrasent les contenus pré-existants. Exemple :
                                 <literal>[a,b,a] = (%pi, %z, "Allo")</literal>
                                 est équivalent à <literal>a = %pi, b = %z</literal>.
                             </listitem>
@@ -354,6 +353,7 @@ s = poly(0,'s');[1/s,2/s]
 [%t %f %f %T %F]
 
 // Concaténation d'objets de types compatibles différents, avec transtypages automatiques
+[%T int8(-5)]
 [%T %pi %f 2]
 [%pi, 2+%i, %F]
 v = [%pi+0*%i, %F, %z, (1-%z)^2 ]; typeof(v), isreal(v)
@@ -361,9 +361,9 @@ v = [10 1/%z], typeof(v)
 
 // Concaténations hétérogènes d'objets de types incompatibles => ERREURS
 [%F %z]
-[%F int8(5)]
 [int8(%pi) uint8(%e)]
 [int8(%pi) int16(%e)]
+[int8(%pi) %e]
 
 // Concaténation de tableaux de cellules :
 c1 = {%pi %t};
@@ -428,12 +428,6 @@ s.r([2 4 6])
         <title>Voir aussi</title>
         <simplelist type="inline">
             <member>
-                <link linkend="empty">empty</link>
-            </member>
-            <member>
-                <link linkend="parentheses">parentheses</link>
-            </member>
-            <member>
                 <link linkend="cat">cat</link>
             </member>
             <member>
@@ -446,6 +440,12 @@ s.r([2 4 6])
                 <link linkend="semicolon">semicolon</link>
             </member>
             <member>
+                <link linkend="parentheses">parentheses</link>
+            </member>
+            <member>
+                <link linkend="empty">empty</link>
+            </member>
+            <member>
                 <link linkend="overloading">overloading</link>
             </member>
         </simplelist>
@@ -456,8 +456,15 @@ s.r([2 4 6])
             <revision>
                 <revnumber>6.0</revnumber>
                 <revdescription>
-                    Crochets <literal>[..]</literal> et accolades
-                    <literal>{..}</literal> ont désormais des fonctions distinctes.
+                    Crochets <literal>[..]</literal> et accolades <literal>{..}</literal> ont
+                    désormais des fonctions distinctes.
+                </revdescription>
+            </revision>
+            <revision>
+                <revnumber>6.1</revnumber>
+                <revdescription>
+                    Booléens et entiers encodés peuvent désormais être concaténés ensemble,
+                    comme dans [%t, int8(-5)].
                 </revdescription>
             </revision>
         </revhistory>
index 5c47c7c..004ca37 100644 (file)
@@ -224,8 +224,10 @@ mfile2sci
 translatepaths
 %b_a_b
 %b_a_s
+%b_c_i
 %b_c_s
 %b_d_s
+%b_f_i
 %b_f_s
 %b_l_b
 %b_l_s
@@ -681,9 +683,11 @@ systmat
 %hm_x_s
 %i_and
 %i_ascii
+%i_b_c
 %i_b_s
 %i_bezout
 %i_dsearch
+%i_f_b
 %i_i_ce
 %i_i_h
 %i_i_hm
diff --git a/scilab/modules/overloading/macros/%b_c_i.sci b/scilab/modules/overloading/macros/%b_c_i.sci
new file mode 100644 (file)
index 0000000..692741e
--- /dev/null
@@ -0,0 +1,14 @@
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// 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.
+// 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 = %b_c_i(a, b)
+    // Horizontal concatenation [ boolean , encoded_integer ]
+    r = [iconvert(a, inttype(b)), b]
+endfunction
diff --git a/scilab/modules/overloading/macros/%b_f_i.sci b/scilab/modules/overloading/macros/%b_f_i.sci
new file mode 100644 (file)
index 0000000..484e7a3
--- /dev/null
@@ -0,0 +1,14 @@
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// 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.
+// 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 = %b_f_i(a, b)
+    // Vertical concatenation [ boolean ; encoded_integer ]
+    r = [iconvert(a, inttype(b)) ; b]
+endfunction
diff --git a/scilab/modules/overloading/macros/%i_c_b.sci b/scilab/modules/overloading/macros/%i_c_b.sci
new file mode 100644 (file)
index 0000000..b011d71
--- /dev/null
@@ -0,0 +1,14 @@
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// 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.
+// 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_b(a, b)
+    // Horizontal concatenation [ encoded_integer , boolean ]
+    r = [a , iconvert(b, inttype(a))]
+endfunction
diff --git a/scilab/modules/overloading/macros/%i_f_b.sci b/scilab/modules/overloading/macros/%i_f_b.sci
new file mode 100644 (file)
index 0000000..35d5ddf
--- /dev/null
@@ -0,0 +1,14 @@
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// 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.
+// 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_b(a, b)
+    // Vertical concatenation [ encoded_integer ; boolean ]
+    r = [ a ; iconvert(b, inttype(a))]
+endfunction
diff --git a/scilab/modules/overloading/tests/unit_tests/concatenations_mixed.tst b/scilab/modules/overloading/tests/unit_tests/concatenations_mixed.tst
new file mode 100644 (file)
index 0000000..f3e2155
--- /dev/null
@@ -0,0 +1,26 @@
+// =============================================================================
+// 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.
+// =============================================================================
+// Unit tests for mixed types concatenations
+//
+// <-- 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)];
+    c2 = [%t ; iconvert(-3,i)];
+    c = [iconvert(-3,i) ; %t];
+    assert_checkequal(inttype(r), i);
+    assert_checkequal(inttype(r2), i);
+    assert_checkequal(inttype(c), i);
+    assert_checkequal(inttype(c2), i);
+    assert_checkequal(size(r) , [1 2]);
+    assert_checkequal(size(r2), [1 2]);
+    assert_checkequal(size(c) , [2 1]);
+    assert_checkequal(size(c2), [2 1]);
+end