Fixed & improved pages for |,|| and &,&& 26/19026/1
Samuel GOUGEON [Thu, 1 Sep 2016 18:35:47 +0000 (20:35 +0200)]
 * & && in PDF : http://bugzilla.scilab.org/attachment.cgi?id=4468
   | || in PDF : http://bugzilla.scilab.org/attachment.cgi?id=4469
 * (ja) and (ru) pages were actually in fully english
   => removed. Retranslations shall be done later in some other commits.
 * Some of the || examples are impeded by http://bugzilla.scilab.org/14761
   But they are ready.

Change-Id: I2121940184ab70c1b172f90acdac4174d1520720

20 files changed:
scilab/CHANGES.md
scilab/modules/core/help/en_US/2_control_flow/if.xml
scilab/modules/core/help/en_US/2_control_flow/while.xml
scilab/modules/core/help/fr_FR/2_control_flow/if.xml
scilab/modules/core/help/fr_FR/2_control_flow/while.xml
scilab/modules/core/help/ja_JP/2_control_flow/if.xml
scilab/modules/core/help/ja_JP/2_control_flow/while.xml
scilab/modules/core/help/pt_BR/2_control_flow/if.xml
scilab/modules/core/help/pt_BR/2_control_flow/while.xml
scilab/modules/core/help/ru_RU/2_control_flow/if.xml
scilab/modules/core/help/ru_RU/2_control_flow/while.xml
scilab/modules/elementary_functions/help/en_US/and_op.xml
scilab/modules/elementary_functions/help/en_US/or_op.xml
scilab/modules/elementary_functions/help/fr_FR/and_op.xml [deleted file]
scilab/modules/elementary_functions/help/fr_FR/or_op.xml [deleted file]
scilab/modules/elementary_functions/help/ja_JP/and_op.xml [deleted file]
scilab/modules/elementary_functions/help/ja_JP/or_op.xml [deleted file]
scilab/modules/elementary_functions/help/ru_RU/and_op.xml [deleted file]
scilab/modules/elementary_functions/help/ru_RU/or_op.xml [deleted file]
scilab/modules/helptools/data/pages/CHANGES.html

index d64e12b..9d5342c 100644 (file)
@@ -213,7 +213,7 @@ Help pages:
 * fixed / improved:  `members`, `part`, `ode`, `ode_optional_output`, `ode_roots`, `plot2d`, `roots`,
   `printf`, `sprintf`, `iconvert`, `stdev`, `xlabel`, `and_op`, `or_op`, `permute`, `tree2code`, `%helps`,
   `scilab|scilex`, `flipdim`, `Matplot_properties`
-* rewritten: `consolebox`, `double`, `isoview`, `pixel_drawing_mode`, `householder`, `or`, `and`, `format`, `typeof`,
+* rewritten: `consolebox`, `double`, `isoview`, `pixel_drawing_mode`, `householder`, `or`, `|,||`, `and`, `format`, `typeof`,
 `brackets`, `setlanguage`, `sleep`, `isinf`, `bitor`, `bitxor`, `bitand`, `macr2tree`, `geomean`, `clf`, `getPreferencesValue`
 * reorganized:
   - `else`, `elseif`, `end`, `try`, `sciargs`, `global`, `halt`, `empty`, `power`
index 85394bd..cde7b80 100644 (file)
@@ -1,5 +1,8 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<refentry xmlns="http://docbook.org/ns/docbook" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:svg="http://www.w3.org/2000/svg" xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:db="http://docbook.org/ns/docbook" xmlns:scilab="http://www.scilab.org" xml:lang="en" xml:id="if">
+<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="en" xml:id="if">
     <refnamediv>
         <refname>if</refname>
         <refpurpose>keyword for conditional execution</refpurpose>
         <title>Syntax</title>
         <synopsis>
             if expr1 then
-            statements
+                statements
             elseif expri then
-            statements
-            ....
+                statements
+                ....
             else
-            statements
+                statements
             end
         </synopsis>
     </refsynopsisdiv>
             For example, use:
         </para>
         <programlisting role=""><![CDATA[
-      if rand(1,1) > 0.5 then
-       disp("True");
-      else
-       disp("False");
-      end
+if rand(1,1) > 0.5 then
+    disp("True");
+else
+    disp("False");
+end
 ]]></programlisting>
         <para>
             rather than
         <programlisting role=""><![CDATA[
       if rand(1,1) > 0.5 then disp("True"); else disp("False"); end
 ]]></programlisting>
-        <para>
-            Warning: the number of characters used to define the body of any
+          <warning>
+            Tthe number of characters used to define the body of any
             conditional instruction (if while for or select/case) must be limited to
             16k.
-        </para>
+          </warning>
     </refsection>
     <refsection>
         <title>Examples</title>
@@ -121,29 +124,35 @@ end
         <title>See also</title>
         <simplelist type="inline">
             <member>
-                <link linkend="try">try</link>
+                <link linkend="then">then</link>
             </member>
             <member>
-                <link linkend="while">while</link>
+                <link linkend="else">else</link>
             </member>
             <member>
-                <link linkend="select">select</link>
+                <link linkend="elseif">elseif</link>
             </member>
             <member>
-                <link linkend="boolean">boolean</link>
+                <link linkend="end">end</link>
             </member>
             <member>
-                <link linkend="end">end</link>
+                <link linkend="while">while</link>
             </member>
             <member>
-                <link linkend="then">then</link>
+                <link linkend="select">select</link>
             </member>
             <member>
-                <link linkend="else">else</link>
+                <link linkend="boolean">boolean</link>
             </member>
             <member>
                 <link linkend="comparison">comparison</link>
             </member>
+            <member>
+                <link linkend="or_op">|, ||</link>
+            </member>
+            <member>
+                <link linkend="and_op">&amp;, &amp;&amp;</link>
+            </member>
         </simplelist>
     </refsection>
 </refentry>
index 4669e75..fad736f 100644 (file)
         <programlisting role=""><![CDATA[
       i = 0; while i<5 disp("i"); i = i + 1; end
 ]]></programlisting>
-        <para>
-            <warning>
-                Warning: the number of characters used to define the body of any
-                conditional instruction (if while for or select/case) must be
-                limited to 16k.
-            </warning>
-        </para>
+        <warning>
+          The number of characters used to define the body of any conditional instruction
+          (if while for or select/case) must be limited to 16k.
+        </warning>
     </refsection>
     <refsection>
         <title>Examples</title>
@@ -97,19 +94,19 @@ e,k
         <title>See also</title>
         <simplelist type="inline">
             <member>
-                <link linkend="for">for</link>
+                <link linkend="or_op">|, ||</link>
             </member>
             <member>
-                <link linkend="select">select</link>
+                <link linkend="and_op">&amp;, &amp;&amp;</link>
             </member>
             <member>
                 <link linkend="break">break</link>
             </member>
             <member>
-                <link linkend="return">return</link>
+                <link linkend="for">for</link>
             </member>
             <member>
-                <link linkend="pause">pause</link>
+                <link linkend="select">select</link>
             </member>
         </simplelist>
     </refsection>
index efa57ef..699a295 100644 (file)
@@ -8,12 +8,12 @@
         <title>Séquence d'appel</title>
         <synopsis>
             if expr1 then
-            instructions
+                instructions
             elseif expri then
-            instructions
-            ....
+                instructions
+                ....
             else
-            instructions
+                instructions
             end
         </synopsis>
     </refsynopsisdiv>
@@ -57,9 +57,9 @@
         <para>
             Le mot-clé <literal>then</literal> peut être remplacé par un passage à la ligne ou une virgule.
         </para>
-        <para>
-            Attention : le nombre de caractères constituant le corps d'une instruction conditionnelle (if while for ou select/case) est limité à 16k.
-        </para>
+          <warning>
+             Le nombre de caractères constituant le corps d'une instruction conditionnelle (if while for ou select/case) est limité à 16k.
+          </warning>
         <para>
         </para>
     </refsection>
@@ -81,7 +81,16 @@ end
         <title>Voir aussi</title>
         <simplelist type="inline">
             <member>
-                <link linkend="try">try</link>
+                <link linkend="then">then</link>
+            </member>
+            <member>
+                <link linkend="else">else</link>
+            </member>
+            <member>
+                <link linkend="elseif">elseif</link>
+            </member>
+            <member>
+                <link linkend="end">end</link>
             </member>
             <member>
                 <link linkend="while">while</link>
@@ -93,13 +102,13 @@ end
                 <link linkend="boolean">boolean</link>
             </member>
             <member>
-                <link linkend="end">end</link>
+                <link linkend="comparison">comparison</link>
             </member>
             <member>
-                <link linkend="then">then</link>
+                <link linkend="or_op">|, ||</link>
             </member>
             <member>
-                <link linkend="else">else</link>
+                <link linkend="and_op">&amp;, &amp;&amp;</link>
             </member>
         </simplelist>
     </refsection>
index a155b51..7f2aecb 100644 (file)
         <programlisting role=""><![CDATA[
       i = 0; while i<5 disp("i"); i = i + 1; end
 ]]></programlisting>
-        <para>
-            <warning>
-                Attention : le nombre de caractères constituant le corps d'une
-                instruction conditionnelle (if while for ou select/case) est limité à
-                16k.
-            </warning>
-        </para>
+      <warning>
+        Le nombre de caractères constituant le corps d'une instruction conditionnelle (if while
+        for ou select/case) est limité à 16k.
+      </warning>
     </refsection>
     <refsection>
         <title>Exemples</title>
@@ -93,19 +90,19 @@ e,k
         <title>Voir aussi</title>
         <simplelist type="inline">
             <member>
-                <link linkend="for">for</link>
+                <link linkend="or_op">|, ||</link>
             </member>
             <member>
-                <link linkend="select">select</link>
+                <link linkend="and_op">&amp;, &amp;&amp;</link>
             </member>
             <member>
                 <link linkend="break">break</link>
             </member>
             <member>
-                <link linkend="return">return</link>
+                <link linkend="for">for</link>
             </member>
             <member>
-                <link linkend="pause">pause</link>
+                <link linkend="select">select</link>
             </member>
         </simplelist>
     </refsection>
index 6b92547..c354dcc 100644 (file)
@@ -8,12 +8,12 @@
         <title>呼び出し手順</title>
         <synopsis>
             if expr1 then
-            statements
+                statements
             elseif expri then
-            statements
-            ....
+                statements
+                ....
             else
-            statements
+                statements
             end
         </synopsis>
     </refsynopsisdiv>
@@ -90,9 +90,9 @@
         </para>
         <programlisting role=""><![CDATA[
       if rand(1,1) > 0.5 then
-       disp("True");
+    disp("True");
       else
-       disp("False");
+    disp("False");
       end
 ]]></programlisting>
         <para>
         <programlisting role=""><![CDATA[
       if rand(1,1) > 0.5 then disp("True"); else disp("False"); end
 ]]></programlisting>
-        <para>
-            警告: 条件文(if while for または select/case)の内部に記述可能な文字数は
-            16kに制限されています.
-        </para>
+      <warning>
+        条件文(if while for または select/case)の内部に記述可能な文字数は
+        16kに制限されています.
+      </warning>
     </refsection>
     <refsection>
         <title>例</title>
@@ -124,29 +124,35 @@ end
         <title>参照</title>
         <simplelist type="inline">
             <member>
-                <link linkend="try">try</link>
+                <link linkend="then">then</link>
             </member>
             <member>
-                <link linkend="while">while</link>
+                <link linkend="else">else</link>
             </member>
             <member>
-                <link linkend="select">select</link>
+                <link linkend="elseif">elseif</link>
             </member>
             <member>
-                <link linkend="boolean">boolean</link>
+                <link linkend="end">end</link>
             </member>
             <member>
-                <link linkend="end">end</link>
+                <link linkend="while">while</link>
             </member>
             <member>
-                <link linkend="then">then</link>
+                <link linkend="select">select</link>
             </member>
             <member>
-                <link linkend="else">else</link>
+                <link linkend="boolean">boolean</link>
             </member>
             <member>
                 <link linkend="comparison">comparison</link>
             </member>
+            <member>
+                <link linkend="or_op">|, ||</link>
+            </member>
+            <member>
+                <link linkend="and_op">&amp;, &amp;&amp;</link>
+            </member>
         </simplelist>
     </refsection>
 </refentry>
index 385a4cf..7e71b43 100644 (file)
         <programlisting role=""><![CDATA[
       i = 0; while i<5 disp("i"); i = i + 1; end
 ]]></programlisting>
-        <para>
-            <warning>
-                警告: 条件付き命令(if while for または select/case)の本文を定義するために使用可能な
-                文字数は 16 k以下とする必要があります.
-            </warning>
-        </para>
+      <warning>
+        条件付き命令(if while for または select/case)の本文を定義するために使用可能な
+        文字数は 16 k以下とする必要があります.
+      </warning>
     </refsection>
     <refsection>
         <title>例</title>
@@ -102,19 +100,19 @@ e,k
         <title>参照</title>
         <simplelist type="inline">
             <member>
-                <link linkend="for">for</link>
+                <link linkend="or_op">|, ||</link>
             </member>
             <member>
-                <link linkend="select">select</link>
+                <link linkend="and_op">&amp;, &amp;&amp;</link>
             </member>
             <member>
                 <link linkend="break">break</link>
             </member>
             <member>
-                <link linkend="return">return</link>
+                <link linkend="for">for</link>
             </member>
             <member>
-                <link linkend="pause">pause</link>
+                <link linkend="select">select</link>
             </member>
         </simplelist>
     </refsection>
index 471a4c6..f9dfb50 100644 (file)
@@ -1,48 +1,55 @@
 <?xml version="1.0" encoding="ISO-8859-1"?>
-<refentry xmlns="http://docbook.org/ns/docbook" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:svg="http://www.w3.org/2000/svg" xmlns:ns4="http://www.w3.org/1999/xhtml" xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:db="http://docbook.org/ns/docbook" xmlns:scilab="http://www.scilab.org" xml:id="if" 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:ns4="http://www.w3.org/1999/xhtml"
+        xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:db="http://docbook.org/ns/docbook"
+        xmlns:scilab="http://www.scilab.org" xml:id="if" xml:lang="pt">
     <refnamediv>
         <refname>if then else</refname>
-        <refpurpose>Execução condicional (significa "se então senão")</refpurpose>
+        <refpurpose>Execução condicional (significa "se então senão")</refpurpose>
     </refnamediv>
     <refsynopsisdiv>
-        <title>Seqüência de Chamamento</title>
-        <synopsis>    if expressão1 then sentenças
-            elseif expressãoi then sentenças
-            ....
-            else sentenças
+        <title>Seqüência de Chamamento</title>
+        <synopsis>
+            if expressão1 then
+                sentenças
+            elseif expressãoi then
+                sentenças
+                ....
+            else
+                sentenças
             end
         </synopsis>
     </refsynopsisdiv>
     <refsection>
-        <title>Descrição</title>
+        <title>Descrição</title>
         <para>
-            A sentença <literal>if</literal> avalia sentenças lógicas e executa
-            um grupo de sentenças se a expressão é verdadeira.
+            A sentença <literal>if</literal> avalia sentenças lógicas e executa
+            um grupo de sentenças se a expressão é verdadeira.
         </para>
         <para>
-            As <literal>expressõesi</literal> são expressões com valores
-            numéricos ou booleanos. Se as <literal>expressõesi</literal> são matrizes,
-            a condição é verdadeira somente se todas as entradas da matriz são "true"
+            As <literal>expressõesi</literal> são expressões com valores
+            numéricos ou booleanos. Se as <literal>expressõesi</literal> são matrizes,
+            a condição é verdadeira somente se todas as entradas da matriz são "true"
             (verdadeiro) ou diferentes de 0.
         </para>
         <para>
             Os opcionais <literal>elseif</literal> e <literal>else</literal>
-            propiciam execução de grupos de sentenças alternativas. A palavra-chave
+            propiciam execução de grupos de sentenças alternativas. A palavra-chave
             <literal>end</literal> keyword, que corresponde ao
-            <literal>if</literal>termina o último grupo de sentenças. A estrutura de
-            linhas dada acima não é importante, a única restrição é que cada
+            <literal>if</literal>termina o último grupo de sentenças. A estrutura de
+            linhas dada acima não é importante, a única restrição é que cada
             palavra-chave <literal>then</literal>deve estar na mesma linha de sua
             palavra-chave <literal>if</literal> ou <literal>elseif</literal>
             correspondente.
         </para>
         <para>
-            A palavra-chave <literal>then </literal>pode ser substituída por um
-            retorno de carro ou uma vírgula.
-        </para>
-        <para> Aviso: o número de caracteres utilizados para definir o corpo de
-            qualquer instrução condicional (if while for or select/case) deve ser
-            limitado a 16k.
+            A palavra-chave <literal>then </literal>pode ser substituída por um
+            retorno de carro ou uma vírgula.
         </para>
+      <warning>
+        O número de caracteres utilizados para definir o corpo de qualquer instrução condicional
+        (if while for or select/case) deve ser limitado a 16k.
+      </warning>
     </refsection>
     <refsection>
         <title>Exemplos</title>
@@ -59,10 +66,19 @@ end
  ]]></programlisting>
     </refsection>
     <refsection>
-        <title> Ver Também</title>
+        <title> Ver Também</title>
         <simplelist type="inline">
             <member>
-                <link linkend="try">try</link>
+                <link linkend="then">then</link>
+            </member>
+            <member>
+                <link linkend="else">else</link>
+            </member>
+            <member>
+                <link linkend="elseif">elseif</link>
+            </member>
+            <member>
+                <link linkend="end">end</link>
             </member>
             <member>
                 <link linkend="while">while</link>
@@ -74,13 +90,13 @@ end
                 <link linkend="boolean">boolean</link>
             </member>
             <member>
-                <link linkend="end">end</link>
+                <link linkend="comparison">comparison</link>
             </member>
             <member>
-                <link linkend="then">then</link>
+                <link linkend="or_op">|, ||</link>
             </member>
             <member>
-                <link linkend="else">else</link>
+                <link linkend="and_op">&amp;, &amp;&amp;</link>
             </member>
         </simplelist>
     </refsection>
index ae71911..a87f487 100644 (file)
@@ -7,52 +7,52 @@
         </refpurpose>
     </refnamediv>
     <refsection>
-        <title>Descrição</title>
+        <title>Descrição</title>
         <para>
             <literal>while</literal> . Deve ser terminado por
             <literal>"end"</literal>
         </para>
         <para>
-            <literal>while expressão ,instruções1,...[,else instruções],
+            <literal>while expressão ,instruções1,...[,else instruções],
                 end
             </literal>
         </para>
         <para>
-            <literal>while expressão do instruções1,...[,else instruções],
+            <literal>while expressão do instruções1,...[,else instruções],
                 end
             </literal>
         </para>
         <para>
-            <literal>while expressão then instruções1,...[,else instruções],
+            <literal>while expressão then instruções1,...[,else instruções],
                 end
             </literal>
         </para>
         <para>Notas:</para>
         <itemizedlist>
             <listitem>
-                <para>A única restrição é que cada palavra-chave "then" ou "do" deve
+                <para>A única restrição é que cada palavra-chave "then" ou "do" deve
                     estar na mesma linha que a palavra-chave "while".
                 </para>
             </listitem>
             <listitem>
-                <para>As palavras-chaves "then" ou "do" podem ser substituídas por um
-                    retorno de carro ou uma vírgula. Para compatibilidade com o Matlab,
-                    também é possível, mas não recomendado, por um espaço entre o fim da
-                    expressão e o início da primeira instrução.
+                <para>As palavras-chaves "then" ou "do" podem ser substituídas por um
+                    retorno de carro ou uma vírgula. Para compatibilidade com o Matlab,
+                    também é possível, mas não recomendado, por um espaço entre o fim da
+                    expressão e o início da primeira instrução.
                 </para>
             </listitem>
             <listitem>
                 <para>
-                    A construção opcional <literal>,else instruções</literal>
-                    permite fornecer instruções que são executadas quando a expressão
-                    expressão torna-se falsa.
+                    A construção opcional <literal>,else instruções</literal>
+                    permite fornecer instruções que são executadas quando a expressão
+                    expressão torna-se falsa.
                 </para>
             </listitem>
         </itemizedlist>
-        <para>Aviso: o número de caracateres usados para definir o corpo de
-            qualquer estrutura condicional (if while for ou select/case) deve ser
-            limitado a 16k.
-        </para>
+        <warning>
+            O número de caracateres usados para definir o corpo de  qualquer estrutura condicional
+            (if while for ou select/case) deve ser  limitado a 16k.
+        </warning>
     </refsection>
     <refsection>
         <title>Exemplos</title>
@@ -67,22 +67,22 @@ e,k
  ]]></programlisting>
     </refsection>
     <refsection>
-        <title> Ver Também </title>
+        <title> Ver Também </title>
         <simplelist type="inline">
             <member>
-                <link linkend="for">for</link>
+                <link linkend="or_op">|, ||</link>
             </member>
             <member>
-                <link linkend="select">select</link>
+                <link linkend="and_op">&amp;, &amp;&amp;</link>
             </member>
             <member>
                 <link linkend="break">break</link>
             </member>
             <member>
-                <link linkend="return">return</link>
+                <link linkend="for">for</link>
             </member>
             <member>
-                <link linkend="pause">pause</link>
+                <link linkend="select">select</link>
             </member>
         </simplelist>
     </refsection>
index f566583..adfd0e1 100644 (file)
@@ -1,5 +1,8 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<refentry xmlns="http://docbook.org/ns/docbook" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:svg="http://www.w3.org/2000/svg" xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:db="http://docbook.org/ns/docbook" xmlns:scilab="http://www.scilab.org" xml:lang="ru" xml:id="if">
+<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="if">
     <refnamediv>
         <refname>if</refname>
         <refpurpose>ключевое слово для условного выполнения</refpurpose>
         <title>Синтаксис</title>
         <synopsis>
             if expr1 then
-            statements 1
+                statements 1
             elseif expri then
-            statements i
-            ....
+                statements i
+                ....
             else
-            statements
+                statements
             end
         </synopsis>
     </refsynopsisdiv>
@@ -86,9 +89,9 @@
         </para>
         <programlisting role=""><![CDATA[
       if rand(1,1) > 0.5 then
-       disp("True");
+    disp("True");
       else
-       disp("False");
+    disp("False");
       end
 ]]></programlisting>
         <para>
         <programlisting role=""><![CDATA[
       if rand(1,1) > 0.5 then disp("True"); else disp("False"); end
 ]]></programlisting>
-        <para>
-            Предупреждение: число символов, используемых для определения тела любой инструкции условия
-            (<literal>if while for</literal> или <literal>select/case</literal>) должно быть ограничено
-            16К.
-        </para>
+      <warning>
+        число символов, используемых для определения тела любой инструкции условия
+        (<literal>if while for</literal> или <literal>select/case</literal>) должно быть ограничено
+        16К.
+      </warning>
     </refsection>
     <refsection>
         <title>Примеры</title>
@@ -121,29 +124,35 @@ end
         <title>Смотрите также</title>
         <simplelist type="inline">
             <member>
-                <link linkend="try">try</link>
+                <link linkend="then">then</link>
             </member>
             <member>
-                <link linkend="while">while</link>
+                <link linkend="else">else</link>
             </member>
             <member>
-                <link linkend="select">select</link>
+                <link linkend="elseif">elseif</link>
             </member>
             <member>
-                <link linkend="boolean">boolean</link>
+                <link linkend="end">end</link>
             </member>
             <member>
-                <link linkend="end">end</link>
+                <link linkend="while">while</link>
             </member>
             <member>
-                <link linkend="then">then</link>
+                <link linkend="select">select</link>
             </member>
             <member>
-                <link linkend="else">else</link>
+                <link linkend="boolean">boolean</link>
             </member>
             <member>
                 <link linkend="comparison">сравнение</link>
             </member>
+            <member>
+                <link linkend="or_op">|, ||</link>
+            </member>
+            <member>
+                <link linkend="and_op">&amp;, &amp;&amp;</link>
+            </member>
         </simplelist>
     </refsection>
 </refentry>
index 75d50b1..10a4440 100644 (file)
@@ -1,5 +1,8 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<refentry xmlns="http://docbook.org/ns/docbook" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:svg="http://www.w3.org/2000/svg" xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:db="http://docbook.org/ns/docbook" xmlns:scilab="http://www.scilab.org" xml:lang="ru" xml:id="while">
+<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="while">
     <refnamediv>
         <refname>while</refname>
         <refpurpose>ключевое слово while</refpurpose>
@@ -70,8 +73,8 @@
         <programlisting role=""><![CDATA[
       i = 0
       while i<5
-       disp("i");
-       i = i + 1;
+    disp("i");
+    i = i + 1;
       end
 ]]></programlisting>
         <para>
         <programlisting role=""><![CDATA[
       i = 0; while i<5 disp("i"); i = i + 1; end
 ]]></programlisting>
-        <para>
-            Предупреждение: число символов, используемых для определения тела любой инструкции условия
+        <warning>
+            число символов, используемых для определения тела любой инструкции условия
             (<literal>if while for</literal> или <literal>select/case</literal>) должно быть ограничено
             16К.
-        </para>
+        </warning>
     </refsection>
     <refsection>
         <title>Примеры</title>
         <programlisting role="example"><![CDATA[
-e=1; a=1; k=1;
+e = 1;
+a = 1;
+k = 1;
 while norm(a-(a+e),1) > %eps,
-    e=e/2;
-    k=k+1;
+    e = e/2;
+    k = k+1;
 end
 e,k
  ]]></programlisting>
@@ -101,19 +106,19 @@ e,k
         <title>Смотрите также</title>
         <simplelist type="inline">
             <member>
-                <link linkend="for">for</link>
+                <link linkend="or_op">|, ||</link>
             </member>
             <member>
-                <link linkend="select">select</link>
+                <link linkend="and_op">&amp;, &amp;&amp;</link>
             </member>
             <member>
                 <link linkend="break">break</link>
             </member>
             <member>
-                <link linkend="return">return</link>
+                <link linkend="for">for</link>
             </member>
             <member>
-                <link linkend="pause">pause</link>
+                <link linkend="select">select</link>
             </member>
         </simplelist>
     </refsection>
index 837c8df..4382a68 100644 (file)
@@ -2,6 +2,8 @@
 <!--
  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
  * Copyright (C) 2008 - INRIA
+ * Copyright (C) 2016 - Scilab Enterprises - Pierre-Aimé AGNEL
+ * Copyright (C) 2016 - 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="and_op" 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="and_op" xml:lang="en">
 
     <refnamediv>
         <refname>&amp;, &amp;&amp;</refname>
-        <refpurpose>logical AND operator</refpurpose>
+        <refpurpose>Binary AND between integers. Logical AND over/between booleans and numbers</refpurpose>
     </refnamediv>
-
     <refsynopsisdiv>
         <title>Syntax</title>
         <para>
-            Matrix operation with full evaluation:
+            Element-wise operator:
         </para>
         <synopsis>
-            full_res = A &amp; B
-            int_res = intA &amp; intB
+            intMat = intA &amp; intB
+            tfMat = A &amp; B
         </synopsis>
         <para>
-            Short-circuited evaluation:
+            and()-like short-circuited evaluation:
         </para>
         <synopsis>
-            short_circuit_res = A &amp;&amp; B
-            if (A &amp; B) then ... end
-            if (A &amp;&amp; B) then ... end
-            while (A &amp; B) then ... end
-            while (A &amp;&amp; B) then ... end
+            tf = U &amp;&amp; V
+            if (U &amp;&amp; V) then ... end
+            if (U &amp; V)  then ... end
+            while (U &amp;&amp; V) then ... end
+            while (U &amp; V) then ... end
         </synopsis>
     </refsynopsisdiv>
 
         <title>Arguments</title>
         <variablelist>
             <varlistentry>
-                <term>A</term>
+                <term>intA, intB</term>
                 <listitem>
                     <para>
-                        scalar, vector, matrix, or hypermatrix of booleans (may be sparse encoded)
-                        encoded integers (of any
-                        <link linkend="inttype">inttype</link>), real, or complex numbers.
+                        Arrays of encoded integers of any
+                        <link linkend="inttype">inttype</link>.
+                    </para>
+                    <para>
+                        <varname>intA</varname> and <varname>intB</varname> must have the same sizes
+                        to be processed element-wise. If <varname>intA</varname> or
+                        <varname>intB</varname> is a scalar, it is priorly replicated to the size of
+                        the other operand before processing.
+                    </para>
+                    <para>
+                        If <varname>intA</varname> and <varname>intB</varname> have not the same
+                        integer inttype, the operand with  the smaller encoding is converted to the
+                        wider according to the following ranks:
+                        int8 &lt; uint8 &lt; int16 &lt; uint16 &lt; int32 &lt;  uint32 &lt; int64 &lt; uint64.
                     </para>
                 </listitem>
             </varlistentry>
             <varlistentry>
-                <term>B</term>
+                <term>intMat</term>
                 <listitem>
                     <para>
-                        scalar, vector, matrix, or hypermatrix of booleans (may be sparse encoded)
-                        encoded integers (of any
-                        <link linkend="inttype">inttype</link>), real, or complex numbers.
+                        Array of encoded integers with the same sizes of <varname>intA</varname>
+                        and <varname>intB</varname>, and of the wider inttype of both (see hereabove).
+                        For any index <literal>i</literal>,
+                        <literal>intMat(i) = bitand(intA(i), intB(i))</literal>
+                        <warning>
+                            <literal>intA &amp; []</literal> and <literal>[] &amp; intA</literal>
+                            return the <emphasis role="italic">boolean</emphasis> array
+                            <literal>intA~=0</literal>.
+                        </warning>
                     </para>
                 </listitem>
             </varlistentry>
             <varlistentry>
-                <term>full_res</term>
+                <term>A, B</term>
                 <listitem>
                     <para>
-                        If <varname>A</varname> and <varname>B</varname> are not scalar,
-                        they must be of the same size and <varname>full_res</varname>
-                        is a boolean matrix of their common size.
-                        The result is the element-wise <link linkend="and">and</link> operation between <varname>A</varname> and <varname>B</varname>.
-                    </para>
-                    <para>
-                        If <varname>A</varname> or <varname>B</varname> is a scalar,
-                        <varname>full_res</varname> is a boolean matrix of the size
-                        of the other operand.
-                        The result is the element-wise <link linkend="and">and</link> operation between the matrix of the greater size and the scalar.
+                        Arrays of booleans or of numbers: encoded integers of any
+                        <link linkend="inttype">inttype</link>, real or complex numbers.
+                        <varname>A</varname> and <varname>B</varname> may have  distinct types,
+                        and may be one or both sparse-encoded. The special case where
+                        <varname>A</varname> and <varname>B</varname> are both encoded integers is
+                        excluded (see here-above).
                     </para>
                     <para>
+                        <varname>A</varname> and <varname>B</varname> must have the same sizes to
+                        be processed element-wise. If <varname>A</varname> or <varname>B</varname>
+                        is a scalar, it is priorly replicated to the size of the other operand before
+                        processing.
                     </para>
                 </listitem>
             </varlistentry>
             <varlistentry>
-                <term>intA</term>
+                <term>tfMat</term>
                 <listitem>
                     <para>
-                        scalar, vector, matrix, or hypermatrix of encoded integers (of any
-                        <link linkend="inttype">inttype</link>), real, or complex numbers.
+                        Boolean array with the same sizes of  <varname>A</varname> and
+                        <varname>B</varname>.  If <varname>A</varname> or <varname>B</varname> is
+                        sparse-encoded, so is <varname>tfMat</varname>.
+                    </para>
+                    <para>
+                        For any index <literal>i</literal>, <literal>tfMat(i)</literal> is
+                        <constant>%T</constant> if neither <literal>A(i)</literal> nor
+                        <literal>B(i)</literal> are <literal>%F</literal> or zero. Otherwise,
+                        <literal>tfMat(i)</literal> is set to  <constant>%F</constant>.
+                        <warning>
+                            <literal>A &amp; []</literal> and <literal>[] &amp; A</literal> return
+                            <literal>[]</literal>.
+                        </warning>
                     </para>
                 </listitem>
             </varlistentry>
             <varlistentry>
-                <term>intB</term>
+                <term>U, V</term>
                 <listitem>
                     <para>
-                        scalar, vector, matrix, or hypermatrix of encoded integers (of any
-                        <link linkend="inttype">inttype</link>), real, or complex numbers.
+                        Arrays of full or sparse-encoded booleans or of numbers of any types and
+                        encoding: any <link linkend="inttype">inttype</link> of encoded  integers,
+                        full or sparse-encoded real or complex numbers.
+                    </para>
+                    <para>
+                        <varname>U</varname> and <varname>V</varname> may have distinct data types,
+                        <emphasis role="italic">number of dimensions, and sizes</emphasis>.
                     </para>
                 </listitem>
             </varlistentry>
             <varlistentry>
-                <term>int_res</term>
+                <term>tf</term>
                 <listitem>
                     <para>
-                        If <varname>A</varname> and <varname>B</varname> are not scalar,
-                        they must be of the same size and <varname>int_res</varname>
-                        is a matrix of integer of their common size.
-                        The result is the element-wise <link linkend="bitand">bitand</link> operation between <varname>A</varname> and <varname>B</varname>.
+                        single boolean: Set to <literal>and(U) &amp; and(V)</literal>,  without
+                        evaluating <literal>and(V)</literal> if <literal>and(U)</literal> is false
+                        (this is why the <literal>&amp;&amp;</literal> operator is so-called
+                        short-circuited).
                     </para>
                     <para>
-                        If <varname>A</varname> or <varname>B</varname> is a scalar,
-                        <varname>int_res</varname> is a boolean matrix of the size
-                        of the other operand.
-                        The result is the element-wise <link linkend="bitand">bitand</link> operation between the matrix of the greater size and the scalar.
+                        See <link linkend="and">and</link>() for the definition of the evaluation
+                        to false depending on type and encoding.
                     </para>
+                </listitem>
+            </varlistentry>
+        </variablelist>
+    </refsection>
+
+    <refsection>
+        <title>Description</title>
+        <variablelist>
+            <varlistentry>
+                <term>&amp;&amp;</term>
+                <listitem>
                     <para>
-                        If <varname>A</varname> and <varname>B</varname> are of different integer encoding,
-                        integer promotion is performed according to the following rules:
+                        For any boolean or numerical operands <varname>U</varname> and
+                        <varname>V</varname>, <code>G = U &amp;&amp; V</code> is equivalent to
+                        <code>if ~and(U), G = %F, else G = and(V), end</code>.
                         <itemizedlist>
                             <listitem>
-                                if any operand is unsigned, <varname>int_res</varname> is unsigned;
+                              <varname>U</varname> and <varname>V</varname> may have distinct sizes
+                              or numbers of dimensions.
                             </listitem>
                             <listitem>
-                                <varname>int_res</varname> has the encoding of the higher number of bits between the encoding of <varname>A</varname> and <varname>B</varname>;
+                                The result is always a single boolean.
                             </listitem>
                             <listitem>
-                                <varname>A</varname> and <varname>B</varname> are promoted to the same encoding before computation is performed
+                                <code>and(V)</code>  is evaluated only if <code>and(U)</code> is true.
+                                This mainly avoids yielding errors when further operations with
+                                <varname>V</varname> are meaningless or prone to error when
+                                <varname>U</varname> is false. See examples.
                             </listitem>
                         </itemizedlist>
                     </para>
                 </listitem>
             </varlistentry>
             <varlistentry>
-                <term>short_circuit_res</term>
+                <term>&amp;</term>
                 <listitem>
                     <para>
-                        boolean scalar when the operation is short-circuited.
+                        When the <literal>&amp;</literal> operator is used inside a logical
+                        condition tested by a <function>while</function> or by an
+                        <function>if</function> control structure, it is equivalent to the
+                        <literal>&amp;&amp;</literal> operator (see above).
                     </para>
-                    <para>
-                        The short-circuit operation evaluates to false if any entry of <varname>A</varname> is false. In this case <varname>B</varname> is not evaluated.
-                    </para>
-                    <para>
-                        See <link linkend="and">and</link> for the definition of the evaluation to false depending on type and encoding.
+                    <para>Otherwise, <literal>&amp;</literal> has two different actions:
+                        <orderedlist>
+                            <listitem>
+                                When both operands are encoded integers,
+                                <literal>intA &amp; intB</literal> is processed element-wise and
+                                yields an array of integers resulting from the bitwise
+                                <literal>AND</literal> between corresponding components.
+                            </listitem>
+                            <listitem>
+                                Otherwise, when operands are arrays of numbers or/and booleans,
+                                they are still processed element-wise. Provided that null numbers
+                                are equivalent to false booleans, the result is an array of booleans.
+                            </listitem>
+                        </orderedlist>
                     </para>
                 </listitem>
             </varlistentry>
         </variablelist>
-    </refsection>
-
-    <refsection>
-        <title>Description</title>
-        <para>
-            When the right and left operands are <emphasis>not</emphasis> both of integer type, <literal>A &amp; B</literal> yields the element-wise logical
-            <literal>AND</literal> of matrices <varname>A</varname> and
-            <literal>B</literal> evaluated as matrices of boolean. <varname>A</varname> and <varname>B</varname> must
-            be matrices with the same dimensions or one from them must be a single
-            boolean.
-            If any operand is sparse the result of <literal>A &amp; B</literal> is sparse encoded.
-        </para>
         <para>
-            When both operands are of integer type, <literal>A &amp; B</literal> yields the bitwise comparison between each element of <varname>A</varname> and <varname>B</varname>.
+            <emphasis role="bold">Comparing <literal>&amp;</literal> and
+            <literal>&amp;&amp;</literal> with <literal>bitand()</literal> and
+            <literal>and()</literal>
+            </emphasis> :
         </para>
         <para>
-            For <link linkend="if">if</link> and <link linkend="while">while</link> control structures or when computing <literal>A &amp;&amp; B</literal>, the left operand is evaluated prior to the right operand. If any entry in the left operand is false, the result is set to <literal>%f</literal> short-circuiting the evaluation of the right operand.
-            Otherwise, <literal>A &amp; B</literal> is computed.
+            <itemizedlist>
+                <listitem>
+                    <literal>and(A)</literal> is equivalent to <literal>A &amp;&amp; %T</literal>,
+                    whereas  <literal>and(A, side)</literal> has no equivalence with
+                    <literal>&amp;&amp;</literal>.
+                </listitem>
+                <listitem>
+                    <literal>intA &amp; intB</literal> accepts negative integers, while
+                    <code>bitand(intA, intB)</code> does not. <code>bitand(A,B)</code> works bitwise
+                    with decimal-encoded integers.
+                </listitem>
+            </itemizedlist>
         </para>
+        <note>
+            The <link linkend="overloading">overloading</link> code for  <literal>&amp;</literal>
+            and <literal>&amp;&amp;</literal> operators is <emphasis role="bold">h</emphasis>.
+        </note>
+        <warning>
+            <itemizedlist>
+                <listitem>
+                    <constant>%nan</constant> is <literal>true</literal>.
+                </listitem>
+                <listitem>
+                    A constant polynomial or rational is not considered as a number and is not an
+                    acceptable operand for <literal>&amp;</literal> or <literal>&amp;&amp;</literal>.
+                </listitem>
+            </itemizedlist>
+        </warning>
     </refsection>
 
     <refsection>
         <title>Examples</title>
         <programlisting role="example"><![CDATA[
-A = [0 1; 1 0];
-B = [1 1; 0 0];
+A = [0 1; 1 0];   // equivalent to [%f %t ; %t %f]
+B = [1 1; 0 0];   // equivalent to [%t %t ; %f %f]
 spA = sparse(A);
 spB = sparse(B);
 spbA = sparse(A<>0);
@@ -183,73 +262,150 @@ iB = int8(B);
 cA = A + 0*%i;
 cB = B + 0*%i;
 
-// A is evaluated as
-// [%f, %t;
-//  %t, %f]
-// B is evaluated as
-// [%t, %t;
-//  %f, %f]
-
 // & as logical operation
 A & B
-A & spB  // Result is sparse encoded
-iA & spB // Result is sparse encoded
+A & spB    // Result is sparse encoded
+iA & spB   // Result is sparse encoded
 cA & iB
+A & %nan   // %nan is %t
 
 // & as bitwise operation
 iA & iB
 
-i8_A = int8([ -1, 1; 127, -128]);
-// Integer representation of i8_A:
+Ai8 = int8([ -1, 1; 127, -128]);
+// Integer representation of Ai8:
 // [ 1111 1111, 0000 0001 ;
 //   0111 1111, 1000 0000 ]
 
-i8_B = int8([-2, 0; 126, -127]);
-// Integer representation of i8_A:
+Bi8 = int8([-2, 0; 126, -127]);
+// Integer representation of Bi8:
 // [ 1111 1110, 0000 0000 ;
 //   0111 1110, 1000 0001 ]
 
-i8_1 & i8_B
+Ai8 & Bi8
 
 // Integer promotion
-i16_A = int16(i8_A);
-ui32_B = uint32(i8_B);
+Ai16 = int16(Ai8);
+Bui32 = uint32(Bi8);
 
-i16_A & ui32_B
+r = Ai16 & Bui32, typeof(r)
 
-// && as a shortcut operation
+// Shorted & or &&:
+// ----------------
 function res = foo()
-    disp("this is executed");
-    res = %t;
+    error("foo() shall not be called")
 endfunction
 
-if ( %f & foo() ) then
-    // This is not executed
+// & (simple) is always shorted in any if's condition:
+if  %F & foo() then
+    // foo() is not called and this is not executed
 end
 
-A && foo()  // A has at least one element equals to 0
-iA && foo() // therefore, foo() is not executed
+A && foo()    // A, iA and cA have at least one element equals to 0.
+iA && foo()   // Therefore, foo() is not called
 cA && foo()
 
-iA && iB // iA is evalueated as false resulting in the short-circuited operation
+iA && iB // iA is evaluated as false resulting in the short-circuited operation
+ ]]></programlisting>
+
+    <para>
+    Avoiding conditional errors in or out of "if" and "while" conditions:
+    <programlisting role="example"><![CDATA[
+A = [ 1 3 -2 ; 4 -1  2]
+c = issquare(A) & det(A)~=0
+// det(A) is evaluated despite issquare(A) is false (so c is false anyway)
+// But A should be square to be able to compute its det(). This leads to the error
+
+// Now, we use the short-circuited && :
+// det(A) is NO LONGER computed, since issquare(A) is false => anyway c is false
+c = issquare(A) && det(A)~=0      // ==> no error
+
+// In an "if" (or "while") tested condition, & is equivalent to &&
+if issquare(A) & det(A)~=0      // => no error: here & is meant as &&
+   B = inv(A)
+else
+   disp("A is not square")
+end
  ]]></programlisting>
+    <screen><![CDATA[
+--> A = [ 1 3 -2 ; 4 -1  2]
+ A  =
+   1.   3.  -2.
+   4.  -1.   2.
+
+--> c = issquare(A) & det(A)~=0
+det: Wrong type for input argument #1: Square matrix expected.
+
+--> c = issquare(A) && det(A)~=0
+ c  =
+  F
+
+--> if issquare(A) & det(A)~=0        // => no error: here & is meant as &&
+  >    B = inv(A)
+  > else
+  >    disp("A is not square")
+  > end
+
+  A is not square
+]]></screen>
+    </para>
+    <para>
+    Constant polynomials or rationals can't be processed with &amp; or &amp;&amp;:
+    <programlisting role="example"><![CDATA[
+p = 1 + 0*%z
+typeof(p)
+p &amp; 1
+ ]]></programlisting>
+    <screen><![CDATA[
+--> p = 1 + 0*%z
+ p  =
+   1
+
+--> typeof(p)
+ ans  =
+ polynomial
+
+--> p &amp; 1
+Undefined operation for the given operands.
+check or define function %p_h_s for overloading.
+]]></screen>
+    </para>
     </refsection>
 
     <refsection role="see also">
         <title>See also</title>
         <simplelist type="inline">
             <member>
-                <link linkend="not">not</link>
+                <link linkend="and">and</link>
             </member>
             <member>
-                <link linkend="and">and</link>
+                <link linkend="bitand">bitand</link>
             </member>
             <member>
                 <link linkend="or_op">or operator (|)</link>
             </member>
             <member>
-                <link linkend="bitand">bitand</link>
+                <link linkend="not">not ~</link>
+            </member>
+            <member>
+                <link linkend="if">if</link>
+            </member>
+            <member>
+                <link linkend="while">while</link>
+            </member>
+            <member>
+                <link linkend="overloading">overloading</link>
             </member>
         </simplelist>
     </refsection>
-</refentry>
+    <refsection role="history">
+        <title>History</title>
+        <revhistory>
+            <revision>
+                <revnumber>6.0</revnumber>
+                <revdescription>&amp;&amp; operator added
+                </revdescription>
+            </revision>
+        </revhistory>
+    </refsection>
+    </refentry>
index c449185..21b058a 100644 (file)
@@ -2,6 +2,8 @@
 <!--
  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
  * Copyright (C) 2008 - INRIA
+ * Copyright (C) 2016 - Scilab Enterprises - Pierre-Aimé AGNEL
+ * Copyright (C) 2017 - 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="or_op" 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="or_op" xml:lang="en">
+
     <refnamediv>
         <refname>|, ||</refname>
-        <refpurpose>logical OR operator</refpurpose>
+        <refpurpose>Binary OR between integers. Logical OR over/between booleans and numbers</refpurpose>
     </refnamediv>
-
     <refsynopsisdiv>
         <title>Syntax</title>
         <para>
-            Matrix operation with full evaluation:
+            Element-wise operator:
         </para>
         <synopsis>
-            full_res = A | B
-            int_res = intA | intB
+            intMat = intA | intB
+            tfMat = A | B
         </synopsis>
         <para>
-            Short-circuited evaluation:
+            Scalared short-circuited evaluation:
         </para>
         <synopsis>
-            short_circuit_res = A || B
-            if (A | B) then ... end
-            if (A || B) then ... end
-            while (A | B) then ... end
-            while (A || B) then ... end
+            tf = U || V
+            if (U || V) then ... end
+            if (U | V)  then ... end
+            while (U || V) then ... end
+            while (U | V) then ... end
         </synopsis>
     </refsynopsisdiv>
 
         <title>Arguments</title>
         <variablelist>
             <varlistentry>
-                <term>A</term>
+                <term>intA, intB</term>
                 <listitem>
                     <para>
-                        scalar, vector, matrix, or hypermatrix of booleans (may be sparse encoded)
-                        encoded integers (of any
-                        <link linkend="inttype">inttype</link>), real, or complex numbers.
+                        Arrays of encoded integers of any <link linkend="inttype">inttype</link>.
+                    </para>
+                    <para>
+                        <varname>intA</varname> and <varname>intB</varname> must have the same sizes
+                        to be processed element-wise. If <varname>intA</varname> or
+                        <varname>intB</varname> is a scalar, it is priorly replicated to the size of
+                        the other operand before processing.
+                    </para>
+                    <para>
+                        If <varname>intA</varname> and <varname>intB</varname> have not the same
+                        integer inttype, the operand with the smaller encoding is converted to the
+                        wider according to the following ranks:
+                        int8 &lt; uint8 &lt; int16 &lt; uint16 &lt; int32 &lt; uint32 &lt; int64 &lt; uint64.
                     </para>
                 </listitem>
             </varlistentry>
             <varlistentry>
-                <term>B</term>
+                <term>intMat</term>
                 <listitem>
                     <para>
-                        scalar, vector, matrix, or hypermatrix of booleans (may be sparse encoded)
-                        encoded integers (of any
-                        <link linkend="inttype">inttype</link>), real, or complex numbers.
+                        Array of encoded integers with the same sizes of <varname>intA</varname>
+                        and <varname>intB</varname>, and of the wider inttype of both (see hereabove).
+                        For any index <literal>i</literal>,
+                        <literal>intMat(i) = bitor(intA(i), intB(i))</literal>
+                        <warning>
+                            <literal>intA | []</literal> and <literal>[] | intA</literal> return the
+                            <emphasis role="italic">boolean</emphasis> array
+                            <literal>intA~=%nan</literal>.
+                        </warning>
                     </para>
                 </listitem>
             </varlistentry>
             <varlistentry>
-                <term>full_res</term>
+                <term>A, B</term>
                 <listitem>
                     <para>
-                        If <varname>A</varname> and <varname>B</varname> are not scalar,
-                        they must be of the same size and <varname>full_res</varname>
-                        is a boolean matrix of their common size.
-                        The result is the element-wise <link linkend="or">or</link> operation between <varname>A</varname> and <varname>B</varname>.
+                        Arrays of booleans or of numbers: encoded integers of any
+                        <link linkend="inttype">inttype</link>, real or complex numbers.
+                        <varname>A</varname> and <varname>B</varname> may have distinct types,
+                        and may be one or both sparse-encoded. The special case where
+                        <varname>A</varname> and <varname>B</varname> are both encoded integers is
+                        excluded (see here-above).
                     </para>
                     <para>
-                        If <varname>A</varname> or <varname>B</varname> is a scalar,
-                        <varname>full_res</varname> is a boolean matrix of the size
-                        of the other operand.
-                        The result is the element-wise <link linkend="or">or</link> operation between the matrix of the greater size and the scalar.
+                        <varname>A</varname> and <varname>B</varname> must have the same sizes to
+                        be processed element-wise. If <varname>A</varname> or <varname>B</varname>
+                        is a scalar, it is priorly replicated to the size of the other operand before
+                        processing.
                     </para>
                 </listitem>
             </varlistentry>
             <varlistentry>
-                <term>intA</term>
+                <term>tfMat</term>
                 <listitem>
                     <para>
-                        scalar, vector, matrix, or hypermatrix of encoded integers (of any
-                        <link linkend="inttype">inttype</link>).
+                        Boolean array with the same sizes of <varname>A</varname> and
+                        <varname>B</varname>. If <varname>A</varname> or <varname>B</varname> is
+                        sparse-encoded, so is <varname>tfMat</varname>.
+                    </para>
+                    <para>
+                        For any index <literal>i</literal>, <literal>tfMat(i)</literal> is
+                        <constant>%T</constant> if either <literal>A(i)</literal> or
+                        <literal>B(i)</literal> is <constant>%T</constant> or not zero. Otherwise,
+                        <literal>tfMat(i)</literal> is set to <constant>%F</constant>.
+                        <warning>
+                            <literal>A | []</literal> and <literal>[] | A</literal> return
+                            <literal>[]</literal>.
+                        </warning>
                     </para>
                 </listitem>
             </varlistentry>
             <varlistentry>
-                <term>intB</term>
+                <term>U, V</term>
                 <listitem>
                     <para>
-                        scalar, vector, matrix, or hypermatrix of encoded integers (of any
-                        <link linkend="inttype">inttype</link>).
+                        Arrays of full or sparse-encoded booleans or of numbers of any types and
+                        encoding: any <link linkend="inttype">inttype</link> of encoded integers,
+                        full or sparse-encoded real or complex numbers.
+                    </para>
+                    <para>
+                        <varname>U</varname> and <varname>V</varname> may have distinct data types,
+                        <emphasis role="italic">number of dimensions, and sizes</emphasis>.
                     </para>
                 </listitem>
             </varlistentry>
             <varlistentry>
-                <term>int_res</term>
+                <term>tf</term>
                 <listitem>
                     <para>
-                        If <varname>A</varname> and <varname>B</varname> are not scalar,
-                        they must be of the same size and <varname>int_res</varname>
-                        is a matrix of integer of their common size.
-                        The result is the element-wise <link linkend="bitor">bitor</link> operation between <varname>A</varname> and <varname>B</varname>.
+                        single boolean: <literal>U || V</literal> is equal to
+                        <literal>or(U) | or(V)</literal>, without evaluating <literal>or(V)</literal>
+                        if <literal>or(U)</literal> is true (this is why the <literal>||</literal>
+                        operator is so-called short-circuited).
                     </para>
                     <para>
-                        If <varname>A</varname> or <varname>B</varname> is a scalar,
-                        <varname>int_res</varname> is a boolean matrix of the size
-                        of the other operand.
-                        The result is the element-wise <link linkend="bitor">bitor</link> operation between the matrix of the greater size and the scalar.
+                        See <link linkend="or">or</link>() for the definition of the evaluation to
+                        true depending on type and encoding.
                     </para>
+                </listitem>
+            </varlistentry>
+        </variablelist>
+    </refsection>
+
+    <refsection>
+        <title>Description</title>
+        <variablelist>
+            <varlistentry>
+                <term>||</term>
+                <listitem>
                     <para>
-                        If <varname>A</varname> and <varname>B</varname> are of different integer encoding,
-                        integer promotion is performed according to the following rules:
+                        For any boolean or numerical operands <varname>U</varname> and
+                        <varname>V</varname>,
+                        <literal>G = U || V</literal> is equivalent to
+                        <literal>if or(U), G = %T, else G = or(V), end</literal>.
                         <itemizedlist>
                             <listitem>
-                                if any operand is unsigned, <varname>int_res</varname> is unsigned;
+                                <varname>U</varname> and <varname>V</varname> may have distinct sizes
+                                or numbers of dimensions.
                             </listitem>
                             <listitem>
-                                <varname>int_res</varname> has the encoding of the higher number of bits between the encoding of <varname>A</varname> and <varname>B</varname>;
+                                The result is always a single boolean.
                             </listitem>
                             <listitem>
-                                <varname>A</varname> and <varname>B</varname> are promoted to the same encoding before computation is performed
+                                <literal>or(V)</literal>  is evaluated only if <literal>or(U)</literal>
+                                is false. This mainly avoids yielding errors when further operations
+                                with <varname>V</varname> are meaningless or prone to error when
+                                <varname>U</varname> is true. See examples.
                             </listitem>
                         </itemizedlist>
                     </para>
                 </listitem>
             </varlistentry>
             <varlistentry>
-                <term>short_circuit_res</term>
+                <term>|</term>
                 <listitem>
                     <para>
-                        boolean scalar when the operation is short-circuited.
-                    </para>
-                    <para>
-                        The short-circuit operation evaluates to true if all entries of <varname>A</varname> is true. In this case <varname>B</varname> is not evaluated.
+                        When the <literal>|</literal> operator is used inside a logical condition
+                        tested by a <function>while</function> or by an <function>if</function>
+                        control structure, it is equivalent to the <literal>||</literal> operator
+                        (see above).
                     </para>
-                    <para>
-                        See <link linkend="or">or</link> for the definition of the evaluation to true depending on type and encoding.
+                    <para>Otherwise, <literal>|</literal> has two different actions:
+                        <orderedlist>
+                            <listitem>
+                                When both operands are encoded integers,
+                                <literal>intA | intB</literal> is processed element-wise and yields
+                                an array of integers resulting from the bitwise
+                                <literal>AND</literal> between corresponding components.
+                            </listitem>
+                            <listitem>
+                                Otherwise, when operands are arrays of numbers or/and booleans,
+                                they are still processed element-wise. Provided that null numbers
+                                are equivalent to false booleans, the result is an array of booleans.
+                            </listitem>
+                        </orderedlist>
                     </para>
                 </listitem>
             </varlistentry>
         </variablelist>
-    </refsection>
-
-    <refsection>
-        <title>Description</title>
         <para>
-            When the right and left operands are <emphasis>not both</emphasis> of integer type, <literal>A | B</literal> yields the element-wise logical
-            <literal>OR</literal> of matrices <varname>A</varname> and
-            <literal>B</literal> evaluated as matrices of boolean. <varname>A</varname> and <varname>B</varname> must
-            be matrices with the same dimensions or one from them must be a single
-            boolean.
-            If any operand is sparse the result of <literal>A | B</literal> is sparse encoded.
+            <emphasis role="bold">Comparing <literal>|</literal> and <literal>||</literal> with
+            <literal>bitor()</literal> and <literal>or()</literal></emphasis> :
         </para>
         <para>
-            When both operands are of integer type, <literal>A | B</literal> yields the bitwise comparison between each element of <varname>A</varname> and <varname>B</varname>.
-        </para>
-        <para>
-            For <link linkend="if">if</link> and <link linkend="while">while</link> control structures or when computing <literal>A || B</literal>, the left operand is evaluated prior to the right operand. If all entries in the left operand are true, the result is set to <literal>%t</literal> short-circuiting the evaluation of the right operand.
-            Otherwise, <literal>A | B</literal> is computed.
+            <itemizedlist>
+                <listitem>
+                    <literal>or(A)</literal> is equivalent to <literal>A || %F</literal>, whereas
+                    <literal>or(A, side)</literal> has no equivalence with <literal>||</literal>.
+                </listitem>
+                <listitem>
+                    <literal>intA | intB</literal> accepts negative integers, while
+                    <literal>bitor(intA, intB)</literal> does not. <literal>bitor(A,B)</literal>
+                    works bitwise with decimal-encoded integers.
+                </listitem>
+            </itemizedlist>
         </para>
+        <note>
+            The <link linkend="overloading">overloading</link> code for <literal>|</literal> and
+            <literal>||</literal> operators is <emphasis role="bold">g</emphasis>.
+        </note>
+        <warning>
+            <itemizedlist>
+                <listitem>
+                    <literal>%nan</literal> is <literal>true</literal>.
+                </listitem>
+                <listitem>
+                    A polynomial or rational is not considered as a number and is not an acceptable
+                    operand for <literal>|</literal> or <literal>||</literal>.
+                </listitem>
+            </itemizedlist>
+        </warning>
     </refsection>
 
     <refsection>
         <title>Examples</title>
         <programlisting role="example"><![CDATA[
-A = [0 1; 1 0];
-B = [1 1; 0 0];
+A = [0 1; 1 0];   // equivalent to [%f %t ; %t %f]
+B = [1 1; 0 0];   // equivalent to [%t %t ; %f %f]
 spA = sparse(A);
 spB = sparse(B);
 spbA = sparse(A<>0);
@@ -180,56 +259,110 @@ iB = int8(B);
 cA = A + 0*%i;
 cB = B + 0*%i;
 
-// A is evaluated as
-// [%f, %t;
-//  %t, %f]
-// B is evaluated as
-// [%t, %t;
-//  %f, %f]
-
 // | as logical operation
 A | B
-A | spB  // Result is sparse encoded
-iA | spB // Result is sparse encoded
+A | spB    // Result is sparse encoded
+iA | spB   // Result is sparse encoded
 cA | iB
+A | %nan   // %nan is %t
 
 // | as bitwise operation
 iA | iB
 
-i8_A = int8([ -1, 1; 127, -128]);
-// Integer representation of i8_A:
+Ai8 = int8([ -1, 1; 127, -128]);
+// Integer representation of Ai8:
 // [ 1111 1111, 0000 0001 ;
 //   0111 1111, 1000 0000 ]
 
-i8_B = int8([-2, 0; 126, -127]);
-// Integer representation of i8_A:
+Bi8 = int8([-2, 0; 126, -127]);
+// Integer representation of Bi8:
 // [ 1111 1110, 0000 0000 ;
 //   0111 1110, 1000 0001 ]
 
-i8_1 | i8_B
+Ai8 | Bi8
 
 // Integer promotion
-i16_A = int16(i8_A);
-ui32_B = uint32(i8_B);
+Ai16  = int16(Ai8);
+Bui32 = uint32(Bi8);
 
-i16_A | ui32_B
+r = Ai16 | Bui32, typeof(r)
 
-// || as a shortcut operation
+// Shorted | or ||:
+// ----------------
 function res = foo()
-    disp("this is executed");
-    res = %t;
+    error("foo() shall not be called")
 endfunction
 
-if ( %t | foo() ) then
-    // foo is not executed
+// | (simple) is always shorted in any if's condition:
+if  %T | foo() then
+    // foo() is not called and this is not executed
 end
 
-C = [1 %i; 2, 10]; // All C entries are different than 0
-if ( C || foo() ) then
-    // foo() is not executed
+A  || foo()   // A, iA and cA have at least one non-zero element.
+iA || foo()   // Therefore, foo() is not called
+cA || foo()
+ ]]></programlisting>
+
+    <para>
+    Avoiding conditional errors in <literal>or</literal> out of <literal>if</literal> and
+    <literal>while</literal> conditions:
+    <programlisting role="example"><![CDATA[
+A = [ 1 3 -2 ; 4 -1  2]
+c = ~issquare(A) | det(A)~=0
+// det(A) is evaluated despite ~issquare(A) is true (so c is true anyway)
+// But A should be square to be able to compute its det(). ==> ERROR
+
+// Now, we use the short-circuited || :
+// det(A) is NO LONGER computed, since ~issquare(A) is true => anyway c is true
+c = ~issquare(A) || det(A)~=0     // => NO ERROR
+
+// In an "if" (or "while") tested condition, | is equivalent to ||
+if ~issquare(A) | det(A)~=0       // => NO ERROR
+   B = A * A.'
 end
+ ]]></programlisting>
+    <screen><![CDATA[
+--> A = [ 1 3 -2 ; 4 -1  2]
+ A  =
+   1.   3.  -2.
+   4.  -1.   2.
+
+--> c = ~issquare(A) | det(A)~=0
+det: Wrong type for input argument #1: Square matrix expected.
+
+--> c = ~issquare(A) || det(A)~=0    // => NO ERROR
+ c  =
+  T
 
+--> if ~issquare(A) | det(A)~=0      // => NO ERROR
+  >    B = A * A.'
+  > end
+ B  =
+   14.  -3.
+  -3.    21.
+]]></screen>
+    </para>
+    <para>
+    Constant polynomials or rationals can't be processed with | or ||:
+    <programlisting role="example"><![CDATA[
+p = 1 + 0*%z
+typeof(p)
+p | 1
  ]]></programlisting>
+    <screen><![CDATA[
+--> p = 1 + 0*%z
+ p  =
+   1
+
+--> typeof(p)
+ ans  =
+ polynomial
+
+--> p | 1
+Undefined operation for the given operands.
+check or define function %p_g_s for overloading.
+]]></screen>
+    </para>
     </refsection>
 
     <refsection role="see also">
@@ -239,20 +372,33 @@ end
                 <link linkend="or">or</link>
             </member>
             <member>
-                <link linkend="and">and</link>
+                <link linkend="bitor">bitor</link>
             </member>
             <member>
                 <link linkend="and_op">and operator (&amp;)</link>
             </member>
             <member>
-                <link linkend="not">not</link>
+                <link linkend="not">not ~</link>
             </member>
             <member>
-                <link linkend="find">find</link>
+                <link linkend="if">if</link>
             </member>
             <member>
-                <link linkend="bitor">bitor</link>
+                <link linkend="while">while</link>
+            </member>
+            <member>
+                <link linkend="overloading">overloading</link>
             </member>
         </simplelist>
     </refsection>
+    <refsection role="history">
+        <title>History</title>
+        <revhistory>
+            <revision>
+                <revnumber>6.0</revnumber>
+                <revdescription>|| operator added
+                </revdescription>
+            </revision>
+        </revhistory>
+    </refsection>
 </refentry>
diff --git a/scilab/modules/elementary_functions/help/fr_FR/and_op.xml b/scilab/modules/elementary_functions/help/fr_FR/and_op.xml
deleted file mode 100644 (file)
index 2540399..0000000
+++ /dev/null
@@ -1,235 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<refentry xmlns="http://docbook.org/ns/docbook" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:svg="http://www.w3.org/2000/svg" xmlns: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="and_op" xml:lang="fr">
-    <refnamediv>
-        <refname>&amp;, &amp;&amp;</refname>
-        <refpurpose>opérateur ET logique</refpurpose>
-    </refnamediv>
-    <refsynopsisdiv>
-        <title>Séquence d'appel</title>
-        <para>
-            Opérateur matriciel avec évaluation complète:
-        </para>
-        <synopsis>
-            full_res = A &amp; B
-            int_res = intA &amp; intB
-        </synopsis>
-        <para>
-            Évaluation court-circuitée :
-        </para>
-        <synopsis>
-            short_circuit_res = A &amp;&amp; B
-            if (A &amp; B) then ... end
-            if (A &amp;&amp; B) then ... end
-            while (A &amp; B) then ... end
-            while (A &amp;&amp; B) then ... end
-        </synopsis>
-    </refsynopsisdiv>
-
-    <refsection role="parameters">
-        <title>Arguments</title>
-        <variablelist>
-            <varlistentry>
-                <term>A</term>
-                <listitem>
-                    <para>
-                        scalaire, vecteur, matrice ou hypermatrice de booléens (possiblement creux),
-                        d'entiers codés (de tout <link linkend="inttype">inttype</link>), de nombres réels ou complexes.
-                    </para>
-                </listitem>
-            </varlistentry>
-            <varlistentry>
-                <term>B</term>
-                <listitem>
-                    <para>
-                        scalaire, vecteur, matrice ou hypermatrice de booléens (possiblement creux),
-                        d'entiers codés (de tout <link linkend="inttype">inttype</link>), de nombres réels ou complexes.
-                    </para>
-                </listitem>
-            </varlistentry>
-            <varlistentry>
-                <term>full_res</term>
-                <listitem>
-                    <para>
-                        Si <varname>A</varname> et <varname>B</varname> ne sont pas des scalaires,
-                        ils doivent être de la même taille et <varname>full_res</varname> est alors une matrice
-                        de booléens de leur taille commune.
-                        Le résultat est l'opérateur <link linkend="and">and</link> logique appliqué élément
-                        par élément entre <varname>A</varname> et <varname>B</varname>.
-                    </para>
-                    <para>
-                        Si <varname>A</varname> ou <varname>B</varname> est un scalaire,
-                        <varname>full_res</varname> est une matrice de booléens
-                        de la taille de l'autre opérande.
-                        Le résultat est l'opérateur <link linkend="and">and</link> logique appliqué élément par élément
-                        entre la matrice de la plus grande taille et le scalaire.
-                    </para>
-                </listitem>
-            </varlistentry>
-            <varlistentry>
-                <term>intA</term>
-                <listitem>
-                    <para>
-                        scalaire, vecteur, matrice ou hypermatrice
-                        d'entiers codés (de tout <link linkend="inttype">inttype</link>).
-                    </para>
-                </listitem>
-            </varlistentry>
-            <varlistentry>
-                <term>intB</term>
-                <listitem>
-                    <para>
-                        scalaire, vecteur, matrice ou hypermatrice
-                        d'entiers codés (de tout <link linkend="inttype">inttype</link>).
-                    </para>
-                </listitem>
-            </varlistentry>
-            <varlistentry>
-                <term>int_res</term>
-                <listitem>
-                    <para>
-                        Si <varname>A</varname> et <varname>B</varname> ne sont pas des scalaires,
-                        ils doivent être de la même taille et <varname>int_res</varname> est alors une matrice
-                        de booléens de leur taille commune.
-                        Le résultat est l'opérateur <link linkend="bitand">bitand</link> appliqué élément
-                        par élément entre <varname>A</varname> et <varname>B</varname>.
-                    </para>
-                    <para>
-                        Si <varname>A</varname> ou <varname>B</varname> est un scalaire,
-                        <varname>int_res</varname> est une matrice de booléens
-                        de la taille de l'autre opérande.
-                        Le résultat est l'opérateur <link linkend="bitand">bitand</link> appliqué élément par élément
-                        entre la matrice de la plus grande taille et le scalaire.
-                    </para>
-                    <para>
-                        Si les codages en entier de <varname>A</varname> et <varname>B</varname> sont différents,
-                        une promotion d'entier est opérée selon les règles suivantes :
-                        <itemizedlist>
-                            <listitem>
-                                si une des opérandes est non signée,  <varname>int_res</varname> est non signé;
-                            </listitem>
-                            <listitem>
-                                <varname>int_res</varname> a le codage entier du nombre de bits le plus grand entre le codage de <varname>A</varname> et celui de <varname>B</varname>;
-                            </listitem>
-                            <listitem>
-                                <varname>A</varname> et <varname>B</varname> sont promus pour être du même codage avant que l'opération ne soit effectuée.
-                            </listitem>
-                        </itemizedlist>
-                    </para>
-                </listitem>
-            </varlistentry>
-            <varlistentry>
-                <term>short_circuit_res</term>
-                <listitem>
-                    <para>
-                        booléen scalaire si l'opération est court-circuitée.
-                    </para>
-                    <para>
-                        L'opération court-circuitée renvoie vrai si toutes les entrées de <varname>A</varname> sont vraies. Dans ce cas <varname>B</varname> n'est pas évaluée.
-                    </para>
-                    <para>
-                        Voir <link linkend="and">and</link> pour la définition de l'évaluation à vrai selon le type et le codage utilisé.
-                    </para>
-                </listitem>
-            </varlistentry>
-        </variablelist>
-    </refsection>
-
-    <refsection>
-        <title>Description</title>
-        <para>
-            Quand les opérandes de gauche et de droite ne sont <emphasis>pas toutes deux</emphasis> de type entier, <literal>A &amp; B</literal> renvoie le <literal>ET</literal> logique effectué élément par élément entre les matrices <varname>A</varname> et <varname>B</varname> évaluées comme matrice de booléens.
-            <varname>A</varname> et <varname>B</varname> doivent être des matrices de même taille ou l'une d'entre elle doit être un scalaire.
-            Si une opérande est creuse, le résultat de <literal>A &amp; B</literal> est creux.
-        </para>
-        <para>
-            Quand les deux opérandes sont de type entier, <literal>A &amp; B</literal> renvoie la comparaison bit à bit de chaque élément de <varname>A</varname> et de <varname>B</varname>.
-        </para>
-        <para>
-            Pour les structures de contrôle <link linkend="if">if</link> et <link linkend="while">while</link> ou quand l'on calcule <literal>A &amp;&amp; B</literal>, l'opérande de gauche est évaluée avant l'opérande de droite. Si une entrée de l'opérande de gauche est fausse, le résultat est <literal>%f</literal>, ce qui court-circuite l'évaluation de l'opérande de droite.
-            Dans les autres cas, l'on calcule <literal>A &amp; B.</literal>
-        </para>
-    </refsection>
-    <refsection>
-        <title>Exemples</title>
-        <programlisting role="example"><![CDATA[
-A = [0 1; 1 0];
-B = [1 1; 0 0];
-spA = sparse(A);
-spB = sparse(B);
-spbA = sparse(A<>0);
-spbB = sparse(B<>0);
-iA = int8(A);
-iB = int8(B);
-cA = A + 0*%i;
-cB = B + 0*%i;
-
-// A est évalué comme
-// [%f, %t;
-//  %t, %f]
-// B est évalué comme
-// [%t, %t;
-//  %f, %f]
-
-// & comme ET logique
-A & B
-A & spB  // Le résultat est creux
-iA & spB // Le résultat est creux
-cA & iB
-
-// & comme opération bit à bit
-iA & iB
-
-i8_A = int8([ -1, 1; 127, -128]);
-// codage entier de i8_A:
-// [ 1111 1111, 0000 0001 ;
-//   0111 1111, 1000 0000 ]
-
-i8_B = int8([-2, 0; 126, -127]);
-// codage entier i8_B:
-// [ 1111 1110, 0000 0000 ;
-//   0111 1110, 1000 0001 ]
-
-i8_1 & i8_B
-
-// Promotion d'entier
-i16_A = int16(i8_A);
-ui32_B = uint32(i8_B);
-
-i16_A & ui32_B
-
-// && comme opération court-circuitée
-function res = foo()
-    disp("ceci est exécuté");
-    res = %t;
-endfunction
-
-if ( %f & foo() ) then
-    // foo n'est pas exécuté
-end
-
-A && foo()  // Au moins une entrée de A vaut 0
-iA && foo() // alors, foo() n'est pas executée
-cA && foo()
-
-iA && iB // iA est évaluée à faux et l'opération est court-circuitée
- ]]></programlisting>
-    </refsection>
-
-    <refsection role="see also">
-        <title>Voir aussi</title>
-        <simplelist type="inline">
-            <member>
-                <link linkend="not">not</link>
-            </member>
-            <member>
-                <link linkend="and">and</link>
-            </member>
-            <member>
-                <link linkend="or_op">opérateur ou (|)</link>
-            </member>
-            <member>
-                <link linkend="bitand">bitand</link>
-            </member>
-        </simplelist>
-    </refsection>
-</refentry>
diff --git a/scilab/modules/elementary_functions/help/fr_FR/or_op.xml b/scilab/modules/elementary_functions/help/fr_FR/or_op.xml
deleted file mode 100644 (file)
index 590173e..0000000
+++ /dev/null
@@ -1,243 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<refentry xmlns="http://docbook.org/ns/docbook" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:svg="http://www.w3.org/2000/svg" xmlns: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="or_op" xml:lang="fr">
-    <refnamediv>
-        <refname>|, ||</refname>
-        <refpurpose>opérateur de disjonction logique</refpurpose>
-    </refnamediv>
-
-    <refsynopsisdiv>
-        <title>Séquence d'appel</title>
-        <synopsis>A|B</synopsis>
-        <para>
-            Opérateur matriciel avec évaluation complète:
-        </para>
-        <synopsis>
-            full_res = A | B
-            int_res = intA | intB
-        </synopsis>
-        <para>
-            Évaluation court-circuitée :
-        </para>
-        <synopsis>
-            short_circuit_res = A || B
-            if (A | B) then ... end
-            if (A || B) then ... end
-            while (A | B) then ... end
-            while (A || B) then ... end
-        </synopsis>
-    </refsynopsisdiv>
-
-    <refsection role="parameters">
-        <title>Arguments</title>
-        <variablelist>
-            <varlistentry>
-                <term>A</term>
-                <listitem>
-                    <para>
-                        scalaire, vecteur, matrice ou hypermatrice de booléens (possiblement creux),
-                        d'entiers codés (de tout <link linkend="inttype">inttype</link>), de nombres réels ou complexes.
-                    </para>
-                </listitem>
-            </varlistentry>
-            <varlistentry>
-                <term>B</term>
-                <listitem>
-                    <para>
-                        scalaire, vecteur, matrice ou hypermatrice de booléens (possiblement creux),
-                        d'entiers codés (de tout <link linkend="inttype">inttype</link>), de nombres réels ou complexes.
-                    </para>
-                </listitem>
-            </varlistentry>
-            <varlistentry>
-                <term>full_res</term>
-                <listitem>
-                    <para>
-                        Si <varname>A</varname> et <varname>B</varname> ne sont pas des scalaires,
-                        ils doivent être de la même taille et <varname>full_res</varname> est alors une matrice
-                        de booléens de leur taille commune.
-                        Le résultat est l'opérateur <link linkend="or">or</link> logique appliqué élément
-                        par élément entre <varname>A</varname> et <varname>B</varname>.
-                    </para>
-                    <para>
-                        Si <varname>A</varname> ou <varname>B</varname> est un scalaire,
-                        <varname>full_res</varname> est une matrice de booléens
-                        de la taille de l'autre opérande.
-                        Le résultat est l'opérateur <link linkend="or">or</link> logique appliqué élément par élément
-                        entre la matrice de la plus grande taille et le scalaire.
-                    </para>
-                </listitem>
-            </varlistentry>
-            <varlistentry>
-                <term>intA</term>
-                <listitem>
-                    <para>
-                        scalaire, vecteur, matrice ou hypermatrice
-                        d'entiers codés (de tout <link linkend="inttype">inttype</link>).
-                    </para>
-                </listitem>
-            </varlistentry>
-            <varlistentry>
-                <term>intB</term>
-                <listitem>
-                    <para>
-                        scalaire, vecteur, matrice ou hypermatrice
-                        d'entiers codés (de tout <link linkend="inttype">inttype</link>).
-                    </para>
-                </listitem>
-            </varlistentry>
-            <varlistentry>
-                <term>int_res</term>
-                <listitem>
-                    <para>
-                        Si <varname>A</varname> et <varname>B</varname> ne sont pas des scalaires,
-                        ils doivent être de la même taille et <varname>int_res</varname> est alors une matrice
-                        de booléens de leur taille commune.
-                        Le résultat est l'opérateur <link linkend="bitor">bitor</link> appliqué élément
-                        par élément entre <varname>A</varname> et <varname>B</varname>.
-                    </para>
-                    <para>
-                        Si <varname>A</varname> ou <varname>B</varname> est un scalaire,
-                        <varname>int_res</varname> est une matrice de booléens
-                        de la taille de l'autre opérande.
-                        Le résultat est l'opérateur <link linkend="bitor">bitor</link> appliqué élément par élément
-                        entre la matrice de la plus grande taille et le scalaire.
-                    </para>
-                    <para>
-                        Si les codages en entier de <varname>A</varname> et <varname>B</varname> sont différents,
-                        une promotion d'entier est opérée selon les règles suivantes :
-                        <itemizedlist>
-                            <listitem>
-                                si une des opérandes est non signée,  <varname>int_res</varname> est non signé;
-                            </listitem>
-                            <listitem>
-                                <varname>int_res</varname> a le codage entier du nombre de bits le plus grand entre le codage de <varname>A</varname> et celui de <varname>B</varname>;
-                            </listitem>
-                            <listitem>
-                                <varname>A</varname> et <varname>B</varname> sont promus pour être du même codage avant que l'opération ne soit effectuée.
-                            </listitem>
-                        </itemizedlist>
-                    </para>
-                </listitem>
-            </varlistentry>
-            <varlistentry>
-                <term>short_circuit_res</term>
-                <listitem>
-                    <para>
-                        booléen scalaire si l'opération est court-circuitée.
-                    </para>
-                    <para>
-                        L'opération court-circuitée renvoie vrai si toutes les entrées de <varname>A</varname> sont vraies. Dans ce cas <varname>B</varname> n'est pas évaluée.
-                    </para>
-                    <para>
-                        Voir <link linkend="or">or</link> pour la définition de l'évaluation à vrai selon le type et le codage utilisé.
-                    </para>
-                </listitem>
-            </varlistentry>
-        </variablelist>
-    </refsection>
-
-    <refsection>
-        <title>Description</title>
-        <para>
-            Quand les opérandes de gauche et de droite ne sont <emphasis>pas toutes deux</emphasis> de type entier, <literal>A | B</literal> renvoie le <literal>OU</literal> logique effectué élément par élément entre les matrices <varname>A</varname> et <varname>B</varname> évaluées comme matrice de booléens.
-            <varname>A</varname> et <varname>B</varname> doivent être des matrices de même taille ou l'une d'entre elle doit être un scalaire.
-            Si une opérande est creuse, le résultat de <literal>A | B</literal> est creux.
-        </para>
-        <para>
-            Quand les deux opérandes sont de type entier, <literal>A | B</literal> renvoie la comparaison bit à bit de chaque élément de <varname>A</varname> et de <varname>B</varname>.
-        </para>
-        <para>
-            Pour les structures de contrôle <link linkend="if">if</link> et <link linkend="while">while</link> ou quand l'on calcule <literal>A || B</literal>, l'opérande de gauche est évaluée avant l'opérande de droite. Si toutes les entrées de l'opérande de gauche sont vraies, le résultat est <literal>%t</literal>, ce qui court-circuite l'évaluation de l'opérande de droite.
-            Dans les autres cas, l'on calcule <literal>A | B.</literal>
-        </para>
-    </refsection>
-    <refsection>
-        <title>Exemples</title>
-        <programlisting role="example"><![CDATA[
-A = [0 1; 1 0];
-B = [1 1; 0 0];
-spA = sparse(A);
-spB = sparse(B);
-spbA = sparse(A<>0);
-spbB = sparse(B<>0);
-iA = int8(A);
-iB = int8(B);
-cA = A + 0*%i;
-cB = B + 0*%i;
-
-// A est évalué comme
-// [%f, %t;
-//  %t, %f]
-// B est évalué comme
-// [%t, %t;
-//  %f, %f]
-
-// | comme OU logique
-A | B
-A | spB  // Le résultat est creux
-iA | spB // Le résultat est creux
-cA | iB
-
-// | comme opération bit à bit
-iA | iB
-
-i8_A = int8([ -1, 1; 127, -128]);
-// codage entier de i8_A:
-// [ 1111 1111, 0000 0001 ;
-//   0111 1111, 1000 0000 ]
-
-i8_B = int8([-2, 0; 126, -127]);
-// codage entier i8_B:
-// [ 1111 1110, 0000 0000 ;
-//   0111 1110, 1000 0001 ]
-
-i8_1 | i8_B
-
-// Promotion d'entier
-i16_A = int16(i8_A);
-ui32_B = uint32(i8_B);
-
-i16_A | ui32_B
-
-// || comme opération court-circuitée
-function res = foo()
-    disp("ceci est exécuté");
-    res = %t;
-endfunction
-
-if ( %t | foo() ) then
-    // foo n'est pas exécuté
-end
-
-C = [1 %i; 2, 10]; // Toutes les entrées de C sont différentes de 0
-if ( C || foo() ) then
-    // foo() foo n'est pas exécuté
-end
-
- ]]></programlisting>
-    </refsection>
-
-    <refsection role="see also">
-        <title>Voir aussi</title>
-        <simplelist type="inline">
-            <member>
-                <link linkend="or">or</link>
-            </member>
-            <member>
-                <link linkend="and">and</link>
-            </member>
-            <member>
-                <link linkend="and_op">opérateur logique et (&amp;)</link>
-            </member>
-            <member>
-                <link linkend="not">not</link>
-            </member>
-            <member>
-                <link linkend="find">find</link>
-            </member>
-            <member>
-                <link linkend="bitor">bitor</link>
-            </member>
-        </simplelist>
-    </refsection>
-</refentry>
diff --git a/scilab/modules/elementary_functions/help/ja_JP/and_op.xml b/scilab/modules/elementary_functions/help/ja_JP/and_op.xml
deleted file mode 100644 (file)
index f224020..0000000
+++ /dev/null
@@ -1,243 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-
-<!--
- * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
- * Copyright (C) 2008 - INRIA
- *
- * Copyright (C) 2012 - 2016 - Scilab Enterprises
- *
- * This file is hereby licensed under the terms of the GNU GPL v2.0,
- * pursuant to article 5.3.4 of the CeCILL v.2.1.
- * This file was originally licensed under the terms of the CeCILL v2.1,
- * and continues to be available under such terms.
- * For more information, see the COPYING file which you should have received
- * along with this program.
- *
- -->
-
-<refentry xmlns="http://docbook.org/ns/docbook" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:svg="http://www.w3.org/2000/svg" xmlns: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="and_op" xml:lang="ja">
-
-    <refnamediv>
-        <refname>&amp;, &amp;&amp;</refname>
-        <refpurpose>論理積演算子</refpurpose>
-    </refnamediv>
-
-    <refsynopsisdiv>
-        <title>呼び出し手順</title>
-        <synopsis>A&amp;B</synopsis>
-    </refsynopsisdiv>
-    <refsection>
-        <title>説明</title>
-        <para>
-            Matrix operation with full evaluation:
-        </para>
-        <synopsis>
-            full_res = A &amp; B
-            int_res = intA &amp; intB
-        </synopsis>
-        <para>
-            Short-circuited evaluation:
-        </para>
-        <synopsis>
-            short_circuit_res = A &amp;&amp; B
-            if (A &amp; B) then ... end
-            if (A &amp;&amp; B) then ... end
-            while (A &amp; B) then ... end
-            while (A &amp;&amp; B) then ... end
-        </synopsis>
-    </refsection>
-
-    <refsection role="parameters">
-        <title>Arguments</title>
-        <variablelist>
-            <varlistentry>
-                <term>A</term>
-                <listitem>
-                    <para>
-                        scalar, vector, matrix, or hypermatrix of booleans (may be sparse encoded)
-                        encoded integers (of any
-                        <link linkend="inttype">inttype</link>), real, or complex numbers.
-                    </para>
-                </listitem>
-            </varlistentry>
-            <varlistentry>
-                <term>B</term>
-                <listitem>
-                    <para>
-                        scalar, vector, matrix, or hypermatrix of booleans (may be sparse encoded)
-                        encoded integers (of any
-                        <link linkend="inttype">inttype</link>), real, or complex numbers.
-                    </para>
-                </listitem>
-            </varlistentry>
-            <varlistentry>
-                <term>full_res</term>
-                <listitem>
-                    <para>
-                        If <varname>A</varname> and <varname>B</varname> are not scalar,
-                        they must be of the same size and <varname>full_res</varname>
-                        is a boolean matrix of their common size.
-                        The result is the element-wise <link linkend="and">and</link> operation between <varname>A</varname> and <varname>B</varname>.
-                    </para>
-                    <para>
-                        If <varname>A</varname> or <varname>B</varname> is a scalar,
-                        <varname>full_res</varname> is a boolean matrix of the size
-                        of the other operand.
-                        The result is the element-wise <link linkend="and">and</link> operation between the matrix of the greater size and the scalar.
-                    </para>
-                    <para>
-                    </para>
-                </listitem>
-            </varlistentry>
-            <varlistentry>
-                <term>intA</term>
-                <listitem>
-                    <para>
-                        scalar, vector, matrix, or hypermatrix of encoded integers (of any
-                        <link linkend="inttype">inttype</link>), real, or complex numbers.
-                    </para>
-                </listitem>
-            </varlistentry>
-            <varlistentry>
-                <term>intB</term>
-                <listitem>
-                    <para>
-                        scalar, vector, matrix, or hypermatrix of encoded integers (of any
-                        <link linkend="inttype">inttype</link>), real, or complex numbers.
-                    </para>
-                </listitem>
-            </varlistentry>
-            <varlistentry>
-                <term>int_res</term>
-                <listitem>
-                    <para>
-                        If <varname>A</varname> and <varname>B</varname> are not scalar,
-                        they must be of the same size and <varname>int_res</varname>
-                        is a matrix of integer of their common size.
-                        The result is the element-wise <link linkend="bitand">bitand</link> operation between <varname>A</varname> and <varname>B</varname>.
-                    </para>
-                    <para>
-                        If <varname>A</varname> or <varname>B</varname> is a scalar,
-                        <varname>int_res</varname> is a boolean matrix of the size
-                        of the other operand.
-                        The result is the element-wise <link linkend="bitand">bitand</link> operation between the matrix of the greater size and the scalar.
-                    </para>
-                    <para>
-                        If <varname>A</varname> and <varname>B</varname> are of different integer encoding,
-                        integer promotion is performed according to the following rules:
-                        <itemizedlist>
-                            <listitem>
-                                if any operand is unsigned, <varname>int_res</varname> is unsigned;
-                            </listitem>
-                            <listitem>
-                                <varname>int_res</varname> has the encoding of the higher number of bits between the encoding of <varname>A</varname> and <varname>B</varname>;
-                            </listitem>
-                            <listitem>
-                                <varname>A</varname> and <varname>B</varname> are promoted to the same encoding before computation is performed
-                            </listitem>
-                        </itemizedlist>
-                    </para>
-                </listitem>
-            </varlistentry>
-            <varlistentry>
-                <term>short_circuit_res</term>
-                <listitem>
-                    <para>
-                        boolean scalar when the operation is short-circuited.
-                    </para>
-                    <para>
-                        The short-circuit operation evaluates to false if any entry of <varname>A</varname> is false. In this case <varname>B</varname> is not evaluated.
-                    </para>
-                    <para>
-                        See <link linkend="and">and</link> for the definition of the evaluation to false depending on type and encoding.
-                    </para>
-                </listitem>
-            </varlistentry>
-        </variablelist>
-    </refsection>
-
-    <refsection>
-        <title>例</title>
-        <programlisting role="example"><![CDATA[
-A = [0 1; 1 0];
-B = [1 1; 0 0];
-spA = sparse(A);
-spB = sparse(B);
-spbA = sparse(A<>0);
-spbB = sparse(B<>0);
-iA = int8(A);
-iB = int8(B);
-cA = A + 0*%i;
-cB = B + 0*%i;
-
-// A is evaluated as
-// [%f, %t;
-//  %t, %f]
-// B is evaluated as
-// [%t, %t;
-//  %f, %f]
-
-// & as logical operation
-A & B
-A & spB  // Result is sparse encoded
-iA & spB // Result is sparse encoded
-cA & iB
-
-// & as bitwise operation
-iA & iB
-
-i8_A = int8([ -1, 1; 127, -128]);
-// Integer representation of i8_A:
-// [ 1111 1111, 0000 0001 ;
-//   0111 1111, 1000 0000 ]
-
-i8_B = int8([-2, 0; 126, -127]);
-// Integer representation of i8_A:
-// [ 1111 1110, 0000 0000 ;
-//   0111 1110, 1000 0001 ]
-
-i8_1 & i8_B
-
-// Integer promotion
-i16_A = int16(i8_A);
-ui32_B = uint32(i8_B);
-
-i16_A & ui32_B
-
-// && as a shortcut operation
-function res = foo()
-    disp("this is executed");
-    res = %t;
-endfunction
-
-if ( %f & foo() ) then
-    // This is not executed
-end
-
-A && foo()  // A has at least one element equals to 0
-iA && foo() // therefore, foo() is not executed
-cA && foo()
-
-iA && iB // iA is evalueated as false resulting in the short-circuited operation
- ]]></programlisting>
-    </refsection>
-
-    <refsection role="see also">
-        <title>参照</title>
-        <simplelist type="inline">
-            <member>
-                <link linkend="not">not</link>
-            </member>
-            <member>
-                <link linkend="and">and</link>
-            </member>
-            <member>
-                <link linkend="or_op">or operator (|)</link>
-            </member>
-            <member>
-                <link linkend="bitand">bitand</link>
-            </member>
-        </simplelist>
-    </refsection>
-</refentry>
-
diff --git a/scilab/modules/elementary_functions/help/ja_JP/or_op.xml b/scilab/modules/elementary_functions/help/ja_JP/or_op.xml
deleted file mode 100644 (file)
index ca88894..0000000
+++ /dev/null
@@ -1,257 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
- * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
- * Copyright (C) 2008 - INRIA
- *
- * Copyright (C) 2012 - 2016 - Scilab Enterprises
- *
- * This file is hereby licensed under the terms of the GNU GPL v2.0,
- * pursuant to article 5.3.4 of the CeCILL v.2.1.
- * This file was originally licensed under the terms of the CeCILL v2.1,
- * and continues to be available under such terms.
- * For more information, see the COPYING file which you should have received
- * along with this program.
- *
- -->
-<refentry xmlns="http://docbook.org/ns/docbook" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:svg="http://www.w3.org/2000/svg" xmlns: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="or_op" xml:lang="ja">
-    <refnamediv>
-        <refname>|, ||</refname>
-        <refpurpose>論理和演算子</refpurpose>
-    </refnamediv>
-
-    <refsynopsisdiv>
-        <title>呼び出し手順</title>
-        <para>
-            Matrix operation with full evaluation:
-        </para>
-        <synopsis>
-            full_res = A | B
-            int_res = intA | intB
-        </synopsis>
-        <para>
-            Short-circuited evaluation:
-        </para>
-        <synopsis>
-            short_circuit_res = A || B
-            if (A | B) then ... end
-            if (A || B) then ... end
-            while (A | B) then ... end
-            while (A || B) then ... end
-        </synopsis>
-    </refsynopsisdiv>
-
-    <refsection role="parameters">
-        <title>Arguments</title>
-        <variablelist>
-            <varlistentry>
-                <term>A</term>
-                <listitem>
-                    <para>
-                        scalar, vector, matrix, or hypermatrix of booleans (may be sparse encoded)
-                        encoded integers (of any
-                        <link linkend="inttype">inttype</link>), real, or complex numbers.
-                    </para>
-                </listitem>
-            </varlistentry>
-            <varlistentry>
-                <term>B</term>
-                <listitem>
-                    <para>
-                        scalar, vector, matrix, or hypermatrix of booleans (may be sparse encoded)
-                        encoded integers (of any
-                        <link linkend="inttype">inttype</link>), real, or complex numbers.
-                    </para>
-                </listitem>
-            </varlistentry>
-            <varlistentry>
-                <term>full_res</term>
-                <listitem>
-                    <para>
-                        If <varname>A</varname> and <varname>B</varname> are not scalar,
-                        they must be of the same size and <varname>full_res</varname>
-                        is a boolean matrix of their common size.
-                        The result is the element-wise <link linkend="or">or</link> operation between <varname>A</varname> and <varname>B</varname>.
-                    </para>
-                    <para>
-                        If <varname>A</varname> or <varname>B</varname> is a scalar,
-                        <varname>full_res</varname> is a boolean matrix of the size
-                        of the other operand.
-                        The result is the element-wise <link linkend="or">or</link> operation between the matrix of the greater size and the scalar.
-                    </para>
-                </listitem>
-            </varlistentry>
-            <varlistentry>
-                <term>intA</term>
-                <listitem>
-                    <para>
-                        scalar, vector, matrix, or hypermatrix of encoded integers (of any
-                        <link linkend="inttype">inttype</link>).
-                    </para>
-                </listitem>
-            </varlistentry>
-            <varlistentry>
-                <term>intB</term>
-                <listitem>
-                    <para>
-                        scalar, vector, matrix, or hypermatrix of encoded integers (of any
-                        <link linkend="inttype">inttype</link>).
-                    </para>
-                </listitem>
-            </varlistentry>
-            <varlistentry>
-                <term>int_res</term>
-                <listitem>
-                    <para>
-                        If <varname>A</varname> and <varname>B</varname> are not scalar,
-                        they must be of the same size and <varname>int_res</varname>
-                        is a matrix of integer of their common size.
-                        The result is the element-wise <link linkend="bitor">bitor</link> operation between <varname>A</varname> and <varname>B</varname>.
-                    </para>
-                    <para>
-                        If <varname>A</varname> or <varname>B</varname> is a scalar,
-                        <varname>int_res</varname> is a boolean matrix of the size
-                        of the other operand.
-                        The result is the element-wise <link linkend="bitor">bitor</link> operation between the matrix of the greater size and the scalar.
-                    </para>
-                    <para>
-                        If <varname>A</varname> and <varname>B</varname> are of different integer encoding,
-                        integer promotion is performed according to the following rules:
-                        <itemizedlist>
-                            <listitem>
-                                if any operand is unsigned, <varname>int_res</varname> is unsigned;
-                            </listitem>
-                            <listitem>
-                                <varname>int_res</varname> has the encoding of the higher number of bits between the encoding of <varname>A</varname> and <varname>B</varname>;
-                            </listitem>
-                            <listitem>
-                                <varname>A</varname> and <varname>B</varname> are promoted to the same encoding before computation is performed
-                            </listitem>
-                        </itemizedlist>
-                    </para>
-                </listitem>
-            </varlistentry>
-            <varlistentry>
-                <term>short_circuit_res</term>
-                <listitem>
-                    <para>
-                        boolean scalar when the operation is short-circuited.
-                    </para>
-                    <para>
-                        The short-circuit operation evaluates to true if all entries of <varname>A</varname> is true. In this case <varname>B</varname> is not evaluated.
-                    </para>
-                    <para>
-                        See <link linkend="or">or</link> for the definition of the evaluation to true depending on type and encoding.
-                    </para>
-                </listitem>
-            </varlistentry>
-        </variablelist>
-    </refsection>
-
-    <refsection>
-        <title>説明</title>
-        <para>
-            When the right and left operands are <emphasis>not both</emphasis> of integer type, <literal>A | B</literal> yields the element-wise logical
-            <literal>OR</literal> of matrices <varname>A</varname> and
-            <literal>B</literal> evaluated as matrices of boolean. <varname>A</varname> and <varname>B</varname> must
-            be matrices with the same dimensions or one from them must be a single
-            boolean.
-            If any operand is sparse the result of <literal>A | B</literal> is sparse encoded.
-        </para>
-        <para>
-            When both operands are of integer type, <literal>A | B</literal> yields the bitwise comparison between each element of <varname>A</varname> and <varname>B</varname>.
-        </para>
-        <para>
-            For <link linkend="if">if</link> and <link linkend="while">while</link> control structures or when computing <literal>A || B</literal>, the left operand is evaluated prior to the right operand. If all entries in the left operand are true, the result is set to <literal>%t</literal> short-circuiting the evaluation of the right operand.
-            Otherwise, <literal>A | B</literal> is computed.
-        </para>
-    </refsection>
-
-    <refsection>
-        <title>例</title>
-        <programlisting role="example"><![CDATA[
-A = [0 1; 1 0];
-B = [1 1; 0 0];
-spA = sparse(A);
-spB = sparse(B);
-spbA = sparse(A<>0);
-spbB = sparse(B<>0);
-iA = int8(A);
-iB = int8(B);
-cA = A + 0*%i;
-cB = B + 0*%i;
-
-// A is evaluated as
-// [%f, %t;
-//  %t, %f]
-// B is evaluated as
-// [%t, %t;
-//  %f, %f]
-
-// | as logical operation
-A | B
-A | spB  // Result is sparse encoded
-iA | spB // Result is sparse encoded
-cA | iB
-
-// | as bitwise operation
-iA | iB
-
-i8_A = int8([ -1, 1; 127, -128]);
-// Integer representation of i8_A:
-// [ 1111 1111, 0000 0001 ;
-//   0111 1111, 1000 0000 ]
-
-i8_B = int8([-2, 0; 126, -127]);
-// Integer representation of i8_A:
-// [ 1111 1110, 0000 0000 ;
-//   0111 1110, 1000 0001 ]
-
-i8_1 | i8_B
-
-// Integer promotion
-i16_A = int16(i8_A);
-ui32_B = uint32(i8_B);
-
-i16_A | ui32_B
-
-// || as a shortcut operation
-function res = foo()
-    disp("this is executed");
-    res = %t;
-endfunction
-
-if ( %t | foo() ) then
-    // foo is not executed
-end
-
-C = [1 %i; 2, 10]; // All C entries are different than 0
-if ( C || foo() ) then
-    // foo() is not executed
-end
- ]]></programlisting>
-    </refsection>
-
-    <refsection role="see also">
-        <title>参照</title>
-        <simplelist type="inline">
-            <member>
-                <link linkend="or">or</link>
-            </member>
-            <member>
-                <link linkend="and">and</link>
-            </member>
-            <member>
-                <link linkend="and_op">and 演算子 (&amp;)</link>
-            </member>
-            <member>
-                <link linkend="not">not</link>
-            </member>
-            <member>
-                <link linkend="find">find</link>
-            </member>
-            <member>
-                <link linkend="bitor">bitor</link>
-            </member>
-        </simplelist>
-    </refsection>
-</refentry>
diff --git a/scilab/modules/elementary_functions/help/ru_RU/and_op.xml b/scilab/modules/elementary_functions/help/ru_RU/and_op.xml
deleted file mode 100644 (file)
index 85cdc36..0000000
+++ /dev/null
@@ -1,254 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
- * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
- * Copyright (C) 2008 - INRIA
- *
- * Copyright (C) 2012 - 2016 - Scilab Enterprises
- *
- * This file is hereby licensed under the terms of the GNU GPL v2.0,
- * pursuant to article 5.3.4 of the CeCILL v.2.1.
- * This file was originally licensed under the terms of the CeCILL v2.1,
- * and continues to be available under such terms.
- * For more information, see the COPYING file which you should have received
- * along with this program.
- *
- -->
-<refentry xmlns="http://docbook.org/ns/docbook" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:svg="http://www.w3.org/2000/svg" xmlns: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="and_op" xml:lang="ru">
-    <refnamediv>
-        <refname>&amp;, &amp;&amp;</refname>
-        <refpurpose>оператор логического И</refpurpose>
-    </refnamediv>
-
-    <refsynopsisdiv>
-        <title>Синтаксис</title>
-        <para>
-            Matrix operation with full evaluation:
-        </para>
-        <synopsis>
-            full_res = A &amp; B
-            int_res = intA &amp; intB
-        </synopsis>
-        <para>
-            Short-circuited evaluation:
-        </para>
-        <synopsis>
-            short_circuit_res = A &amp;&amp; B
-            if (A &amp; B) then ... end
-            if (A &amp;&amp; B) then ... end
-            while (A &amp; B) then ... end
-            while (A &amp;&amp; B) then ... end
-        </synopsis>
-    </refsynopsisdiv>
-
-    <refsection role="parameters">
-        <title>Arguments</title>
-        <variablelist>
-            <varlistentry>
-                <term>A</term>
-                <listitem>
-                    <para>
-                        scalar, vector, matrix, or hypermatrix of booleans (may be sparse encoded)
-                        encoded integers (of any
-                        <link linkend="inttype">inttype</link>), real, or complex numbers.
-                    </para>
-                </listitem>
-            </varlistentry>
-            <varlistentry>
-                <term>B</term>
-                <listitem>
-                    <para>
-                        scalar, vector, matrix, or hypermatrix of booleans (may be sparse encoded)
-                        encoded integers (of any
-                        <link linkend="inttype">inttype</link>), real, or complex numbers.
-                    </para>
-                </listitem>
-            </varlistentry>
-            <varlistentry>
-                <term>full_res</term>
-                <listitem>
-                    <para>
-                        If <varname>A</varname> and <varname>B</varname> are not scalar,
-                        they must be of the same size and <varname>full_res</varname>
-                        is a boolean matrix of their common size.
-                        The result is the element-wise <link linkend="and">and</link> operation between <varname>A</varname> and <varname>B</varname>.
-                    </para>
-                    <para>
-                        If <varname>A</varname> or <varname>B</varname> is a scalar,
-                        <varname>full_res</varname> is a boolean matrix of the size
-                        of the other operand.
-                        The result is the element-wise <link linkend="and">and</link> operation between the matrix of the greater size and the scalar.
-                    </para>
-                    <para>
-                    </para>
-                </listitem>
-            </varlistentry>
-            <varlistentry>
-                <term>intA</term>
-                <listitem>
-                    <para>
-                        scalar, vector, matrix, or hypermatrix of encoded integers (of any
-                        <link linkend="inttype">inttype</link>), real, or complex numbers.
-                    </para>
-                </listitem>
-            </varlistentry>
-            <varlistentry>
-                <term>intB</term>
-                <listitem>
-                    <para>
-                        scalar, vector, matrix, or hypermatrix of encoded integers (of any
-                        <link linkend="inttype">inttype</link>), real, or complex numbers.
-                    </para>
-                </listitem>
-            </varlistentry>
-            <varlistentry>
-                <term>int_res</term>
-                <listitem>
-                    <para>
-                        If <varname>A</varname> and <varname>B</varname> are not scalar,
-                        they must be of the same size and <varname>int_res</varname>
-                        is a matrix of integer of their common size.
-                        The result is the element-wise <link linkend="bitand">bitand</link> operation between <varname>A</varname> and <varname>B</varname>.
-                    </para>
-                    <para>
-                        If <varname>A</varname> or <varname>B</varname> is a scalar,
-                        <varname>int_res</varname> is a boolean matrix of the size
-                        of the other operand.
-                        The result is the element-wise <link linkend="bitand">bitand</link> operation between the matrix of the greater size and the scalar.
-                    </para>
-                    <para>
-                        If <varname>A</varname> and <varname>B</varname> are of different integer encoding,
-                        integer promotion is performed according to the following rules:
-                        <itemizedlist>
-                            <listitem>
-                                if any operand is unsigned, <varname>int_res</varname> is unsigned;
-                            </listitem>
-                            <listitem>
-                                <varname>int_res</varname> has the encoding of the higher number of bits between the encoding of <varname>A</varname> and <varname>B</varname>;
-                            </listitem>
-                            <listitem>
-                                <varname>A</varname> and <varname>B</varname> are promoted to the same encoding before computation is performed
-                            </listitem>
-                        </itemizedlist>
-                    </para>
-                </listitem>
-            </varlistentry>
-            <varlistentry>
-                <term>short_circuit_res</term>
-                <listitem>
-                    <para>
-                        boolean scalar when the operation is short-circuited.
-                    </para>
-                    <para>
-                        The short-circuit operation evaluates to false if any entry of <varname>A</varname> is false. In this case <varname>B</varname> is not evaluated.
-                    </para>
-                    <para>
-                        See <link linkend="and">and</link> for the definition of the evaluation to false depending on type and encoding.
-                    </para>
-                </listitem>
-            </varlistentry>
-        </variablelist>
-    </refsection>
-
-    <refsection>
-        <title>Описание</title>
-        <para>
-            When the right and left operands are <emphasis>not</emphasis> both of integer type, <literal>A &amp; B</literal> yields the element-wise logical
-            <literal>AND</literal> of matrices <varname>A</varname> and
-            <literal>B</literal> evaluated as matrices of boolean. <varname>A</varname> and <varname>B</varname> must
-            be matrices with the same dimensions or one from them must be a single
-            boolean.
-            If any operand is sparse the result of <literal>A &amp; B</literal> is sparse encoded.
-        </para>
-        <para>
-            When both operands are of integer type, <literal>A &amp; B</literal> yields the bitwise comparison between each element of <varname>A</varname> and <varname>B</varname>.
-        </para>
-        <para>
-            For <link linkend="if">if</link> and <link linkend="while">while</link> control structures or when computing <literal>A &amp;&amp; B</literal>, the left operand is evaluated prior to the right operand. If any entry in the left operand is false, the result is set to <literal>%f</literal> short-circuiting the evaluation of the right operand.
-            Otherwise, <literal>A &amp; B</literal> is computed.
-        </para>
-    </refsection>
-
-    <refsection>
-        <title>Examples</title>
-        <programlisting role="example"><![CDATA[
-A = [0 1; 1 0];
-B = [1 1; 0 0];
-spA = sparse(A);
-spB = sparse(B);
-spbA = sparse(A<>0);
-spbB = sparse(B<>0);
-iA = int8(A);
-iB = int8(B);
-cA = A + 0*%i;
-cB = B + 0*%i;
-
-// A is evaluated as
-// [%f, %t;
-//  %t, %f]
-// B is evaluated as
-// [%t, %t;
-//  %f, %f]
-
-// & as logical operation
-A & B
-A & spB  // Result is sparse encoded
-iA & spB // Result is sparse encoded
-cA & iB
-
-// & as bitwise operation
-iA & iB
-
-i8_A = int8([ -1, 1; 127, -128]);
-// Integer representation of i8_A:
-// [ 1111 1111, 0000 0001 ;
-//   0111 1111, 1000 0000 ]
-
-i8_B = int8([-2, 0; 126, -127]);
-// Integer representation of i8_A:
-// [ 1111 1110, 0000 0000 ;
-//   0111 1110, 1000 0001 ]
-
-i8_1 & i8_B
-
-// Integer promotion
-i16_A = int16(i8_A);
-ui32_B = uint32(i8_B);
-
-i16_A & ui32_B
-
-// && as a shortcut operation
-function res = foo()
-    disp("this is executed");
-    res = %t;
-endfunction
-
-if ( %f & foo() ) then
-    // This is not executed
-end
-
-A && foo()  // A has at least one element equals to 0
-iA && foo() // therefore, foo() is not executed
-cA && foo()
-
-iA && iB // iA is evalueated as false resulting in the short-circuited operation
- ]]></programlisting>
-    </refsection>
-
-    <refsection role="see also">
-        <title>Смотрите также</title>
-        <simplelist type="inline">
-            <member>
-                <link linkend="not">not</link>
-            </member>
-            <member>
-                <link linkend="and">and</link>
-            </member>
-            <member>
-                <link linkend="or_op">or operator (|)</link>
-            </member>
-            <member>
-                <link linkend="bitand">bitand</link>
-            </member>
-        </simplelist>
-    </refsection>
-</refentry>
diff --git a/scilab/modules/elementary_functions/help/ru_RU/or_op.xml b/scilab/modules/elementary_functions/help/ru_RU/or_op.xml
deleted file mode 100644 (file)
index 82521a0..0000000
+++ /dev/null
@@ -1,258 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<!--
- * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
- * Copyright (C) 2008 - INRIA
- *
- * Copyright (C) 2012 - 2016 - Scilab Enterprises
- *
- * This file is hereby licensed under the terms of the GNU GPL v2.0,
- * pursuant to article 5.3.4 of the CeCILL v.2.1.
- * This file was originally licensed under the terms of the CeCILL v2.1,
- * and continues to be available under such terms.
- * For more information, see the COPYING file which you should have received
- * along with this program.
- *
- -->
-<refentry xmlns="http://docbook.org/ns/docbook" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:svg="http://www.w3.org/2000/svg" xmlns: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="or_op" xml:lang="ru">
-    <refnamediv>
-        <refname>|, ||</refname>
-        <refpurpose>оператор логического ИЛИ</refpurpose>
-    </refnamediv>
-
-    <refsynopsisdiv>
-        <title>Синтаксис</title>
-        <para>
-            Matrix operation with full evaluation:
-        </para>
-        <synopsis>
-            full_res = A | B
-            int_res = intA | intB
-        </synopsis>
-        <para>
-            Short-circuited evaluation:
-        </para>
-        <synopsis>
-            short_circuit_res = A || B
-            if (A | B) then ... end
-            if (A || B) then ... end
-            while (A | B) then ... end
-            while (A || B) then ... end
-        </synopsis>
-    </refsynopsisdiv>
-
-    <refsection role="parameters">
-        <title>Arguments</title>
-        <variablelist>
-            <varlistentry>
-                <term>A</term>
-                <listitem>
-                    <para>
-                        scalar, vector, matrix, or hypermatrix of booleans (may be sparse encoded)
-                        encoded integers (of any
-                        <link linkend="inttype">inttype</link>), real, or complex numbers.
-                    </para>
-                </listitem>
-            </varlistentry>
-            <varlistentry>
-                <term>B</term>
-                <listitem>
-                    <para>
-                        scalar, vector, matrix, or hypermatrix of booleans (may be sparse encoded)
-                        encoded integers (of any
-                        <link linkend="inttype">inttype</link>), real, or complex numbers.
-                    </para>
-                </listitem>
-            </varlistentry>
-            <varlistentry>
-                <term>full_res</term>
-                <listitem>
-                    <para>
-                        If <varname>A</varname> and <varname>B</varname> are not scalar,
-                        they must be of the same size and <varname>full_res</varname>
-                        is a boolean matrix of their common size.
-                        The result is the element-wise <link linkend="or">or</link> operation between <varname>A</varname> and <varname>B</varname>.
-                    </para>
-                    <para>
-                        If <varname>A</varname> or <varname>B</varname> is a scalar,
-                        <varname>full_res</varname> is a boolean matrix of the size
-                        of the other operand.
-                        The result is the element-wise <link linkend="or">or</link> operation between the matrix of the greater size and the scalar.
-                    </para>
-                </listitem>
-            </varlistentry>
-            <varlistentry>
-                <term>intA</term>
-                <listitem>
-                    <para>
-                        scalar, vector, matrix, or hypermatrix of encoded integers (of any
-                        <link linkend="inttype">inttype</link>).
-                    </para>
-                </listitem>
-            </varlistentry>
-            <varlistentry>
-                <term>intB</term>
-                <listitem>
-                    <para>
-                        scalar, vector, matrix, or hypermatrix of encoded integers (of any
-                        <link linkend="inttype">inttype</link>).
-                    </para>
-                </listitem>
-            </varlistentry>
-            <varlistentry>
-                <term>int_res</term>
-                <listitem>
-                    <para>
-                        If <varname>A</varname> and <varname>B</varname> are not scalar,
-                        they must be of the same size and <varname>int_res</varname>
-                        is a matrix of integer of their common size.
-                        The result is the element-wise <link linkend="bitor">bitor</link> operation between <varname>A</varname> and <varname>B</varname>.
-                    </para>
-                    <para>
-                        If <varname>A</varname> or <varname>B</varname> is a scalar,
-                        <varname>int_res</varname> is a boolean matrix of the size
-                        of the other operand.
-                        The result is the element-wise <link linkend="bitor">bitor</link> operation between the matrix of the greater size and the scalar.
-                    </para>
-                    <para>
-                        If <varname>A</varname> and <varname>B</varname> are of different integer encoding,
-                        integer promotion is performed according to the following rules:
-                        <itemizedlist>
-                            <listitem>
-                                if any operand is unsigned, <varname>int_res</varname> is unsigned;
-                            </listitem>
-                            <listitem>
-                                <varname>int_res</varname> has the encoding of the higher number of bits between the encoding of <varname>A</varname> and <varname>B</varname>;
-                            </listitem>
-                            <listitem>
-                                <varname>A</varname> and <varname>B</varname> are promoted to the same encoding before computation is performed
-                            </listitem>
-                        </itemizedlist>
-                    </para>
-                </listitem>
-            </varlistentry>
-            <varlistentry>
-                <term>short_circuit_res</term>
-                <listitem>
-                    <para>
-                        boolean scalar when the operation is short-circuited.
-                    </para>
-                    <para>
-                        The short-circuit operation evaluates to true if all entries of <varname>A</varname> is true. In this case <varname>B</varname> is not evaluated.
-                    </para>
-                    <para>
-                        See <link linkend="or">or</link> for the definition of the evaluation to true depending on type and encoding.
-                    </para>
-                </listitem>
-            </varlistentry>
-        </variablelist>
-    </refsection>
-
-    <refsection>
-        <title>Описание</title>
-        <para>
-            When the right and left operands are <emphasis>not both</emphasis> of integer type, <literal>A | B</literal> yields the element-wise logical
-            <literal>OR</literal> of matrices <varname>A</varname> and
-            <literal>B</literal> evaluated as matrices of boolean. <varname>A</varname> and <varname>B</varname> must
-            be matrices with the same dimensions or one from them must be a single
-            boolean.
-            If any operand is sparse the result of <literal>A | B</literal> is sparse encoded.
-        </para>
-        <para>
-            When both operands are of integer type, <literal>A | B</literal> yields the bitwise comparison between each element of <varname>A</varname> and <varname>B</varname>.
-        </para>
-        <para>
-            For <link linkend="if">if</link> and <link linkend="while">while</link> control structures or when computing <literal>A || B</literal>, the left operand is evaluated prior to the right operand. If all entries in the left operand are true, the result is set to <literal>%t</literal> short-circuiting the evaluation of the right operand.
-            Otherwise, <literal>A | B</literal> is computed.
-        </para>
-    </refsection>
-
-    <refsection>
-        <title>Примеры</title>
-        <programlisting role="example"><![CDATA[
-A = [0 1; 1 0];
-B = [1 1; 0 0];
-spA = sparse(A);
-spB = sparse(B);
-spbA = sparse(A<>0);
-spbB = sparse(B<>0);
-iA = int8(A);
-iB = int8(B);
-cA = A + 0*%i;
-cB = B + 0*%i;
-
-// A is evaluated as
-// [%f, %t;
-//  %t, %f]
-// B is evaluated as
-// [%t, %t;
-//  %f, %f]
-
-// | as logical operation
-A | B
-A | spB  // Result is sparse encoded
-iA | spB // Result is sparse encoded
-cA | iB
-
-// | as bitwise operation
-iA | iB
-
-i8_A = int8([ -1, 1; 127, -128]);
-// Integer representation of i8_A:
-// [ 1111 1111, 0000 0001 ;
-//   0111 1111, 1000 0000 ]
-
-i8_B = int8([-2, 0; 126, -127]);
-// Integer representation of i8_A:
-// [ 1111 1110, 0000 0000 ;
-//   0111 1110, 1000 0001 ]
-
-i8_1 | i8_B
-
-// Integer promotion
-i16_A = int16(i8_A);
-ui32_B = uint32(i8_B);
-
-i16_A | ui32_B
-
-// || as a shortcut operation
-function res = foo()
-    disp("this is executed");
-    res = %t;
-endfunction
-
-if ( %t | foo() ) then
-    // foo is not executed
-end
-
-C = [1 %i; 2, 10]; // All C entries are different than 0
-if ( C || foo() ) then
-    // foo() is not executed
-end
-
- ]]></programlisting>
-    </refsection>
-
-    <refsection role="see also">
-        <title>Смотрите также</title>
-        <simplelist type="inline">
-            <member>
-                <link linkend="or">or</link>
-            </member>
-            <member>
-                <link linkend="and">and</link>
-            </member>
-            <member>
-                <link linkend="and_op">and operator (&amp;)</link>
-            </member>
-            <member>
-                <link linkend="not">not</link>
-            </member>
-            <member>
-                <link linkend="find">find</link>
-            </member>
-            <member>
-                <link linkend="bitor">bitor</link>
-            </member>
-        </simplelist>
-    </refsection>
-</refentry>
index e8afa01..1df8ae9 100644 (file)
@@ -244,14 +244,15 @@ or a 3-components vector to set the position in axes coordinates to draw the dat
 <li>When the view property of Axes object is set at <code>2d</code>, the rotation becomes impossible.</li>
 <li>The zero-pole-gain (zpk) representation added for linear dynamical systems.</li>
 <li>It is now possible to add a title to the axes via the &quot;Label -&gt; Title&quot; context menu entry</li>
+<li><code>getPreferencesValue</code> can now read a tag having multiple occurrences, and accepts the path to a preferences file instead of its XML handle.</li>
 </ul>
 <h2>Help pages:</h2>
 <ul>
 <li>fixed / improved:  <code>members</code>, <code>part</code>, <code>ode</code>, <code>ode_optional_output</code>, <code>ode_roots</code>, <code>plot2d</code>, <code>roots</code>,
 <code>printf</code>, <code>sprintf</code>, <code>iconvert</code>, <code>stdev</code>, <code>xlabel</code>, <code>and_op</code>, <code>or_op</code>, <code>permute</code>, <code>tree2code</code>, <code>%helps</code>,
-<code>scilab|scilex</code>, <code>flipdim</code></li>
-<li>rewritten: <code>consolebox</code>, <code>double</code>, <code>isoview</code>, <code>pixel_drawing_mode</code>, <code>householder</code>, <code>or</code>, <code>and</code>, <code>format</code>, <code>typeof</code>,
-<code>brackets</code>, <code>setlanguage</code>, <code>sleep</code>, <code>isinf</code>, <code>bitor</code>, <code>bitxor</code>, <code>bitand</code>, <code>macr2tree</code>, <code>geomean</code>, <code>clf</code></li>
+<code>scilab|scilex</code>, <code>flipdim</code>, <code>Matplot_properties</code></li>
+<li>rewritten: <code>consolebox</code>, <code>double</code>, <code>isoview</code>, <code>pixel_drawing_mode</code>, <code>householder</code>, <code>or</code>, <code>|,||</code>, <code>and</code>, <code>format</code>, <code>typeof</code>,
+<code>brackets</code>, <code>setlanguage</code>, <code>sleep</code>, <code>isinf</code>, <code>bitor</code>, <code>bitxor</code>, <code>bitand</code>, <code>macr2tree</code>, <code>geomean</code>, <code>clf</code>, <code>getPreferencesValue</code></li>
 <li>reorganized:
 <ul>
 <li><code>else</code>, <code>elseif</code>, <code>end</code>, <code>try</code>, <code>sciargs</code>, <code>global</code>, <code>halt</code>, <code>empty</code>, <code>power</code></li>
@@ -264,7 +265,7 @@ or a 3-components vector to set the position in axes coordinates to draw the dat
 </li>
 <li>translations added:
 <ul>
-<li>(fr): <code>format</code>, <code>typeof</code>, <code>isoview</code>, <code>ndgrid</code>, <code>bench_run</code>, <code>consolebox</code>, <code>harmean</code>, <code>sleep</code>, <code>strtod</code>, <code>permute</code></li>
+<li>(fr): <code>format</code>, <code>typeof</code>, <code>isoview</code>, <code>ndgrid</code>, <code>bench_run</code>, <code>consolebox</code>, <code>harmean</code>, <code>sleep</code>, <code>strtod</code>, <code>permute</code>, <code>geomean</code></li>
 <li>(ru): homepage</li>
 </ul>
 </li>
@@ -500,6 +501,7 @@ the <a href="dev@lists.scilab.org">development mailing list</a> for a particular
 <li><a href="http://bugzilla.scilab.org/show_bug.cgi?id=14591">#14591</a>: <code>&lt;=</code> and <code>&gt;=</code> elementwise operators comparing 2 hypermatrices of decimal numbers or encoded integers were inverted.</li>
 <li><a href="http://bugzilla.scilab.org/show_bug.cgi?id=14593">#14593</a>: Signs are no more drawn in BIGSOM and PRODUCT components.</li>
 <li><a href="http://bugzilla.scilab.org/show_bug.cgi?id=14602">#14602</a>: WRITEC_f block didn't work for x86 machines.</li>
+<li><a href="http://bugzilla.scilab.org/show_bug.cgi?id=14609">#14609</a>: &quot;msscanf&quot; crashes Scilab when 'niter' parameter is out of range.</li>
 <li><a href="http://bugzilla.scilab.org/show_bug.cgi?id=14632">#14632</a>: Zooming moves drawn axis offscreen</li>
 <li><a href="http://bugzilla.scilab.org/show_bug.cgi?id=14640">#14640</a>: <code>median(int8([10 60 80 100]))</code> returned -58 instead of 70 due to overflow when interpolating (60+80)&gt;128</li>
 <li><a href="http://bugzilla.scilab.org/show_bug.cgi?id=14648">#14648</a>: <code>isinf</code> returned <code>%F</code> for complex numbers with both real and imag infinite parts.</li>
@@ -509,7 +511,7 @@ the <a href="dev@lists.scilab.org">development mailing list</a> for a particular
 <li><a href="http://bugzilla.scilab.org/show_bug.cgi?id=14667">#14667</a>: Multi line string without final quote generated a non terminal parser state.</li>
 <li><a href="http://bugzilla.scilab.org/show_bug.cgi?id=14681">#14681</a>: Short-circuited AND operation was not possible with double matrices in if and while clauses</li>
 <li><a href="http://bugzilla.scilab.org/show_bug.cgi?id=14689">#14689</a>: fixed - <code>resize_matrix(rand(2,3),[0 2])</code> did not return []. Usage of new sizes &lt;0 to keep them unchanged was not documented.</li>
-<li><a href="http://bugzilla.scilab.org/show_bug.cgi?id=14690">#14690</a>: The user's startup files set in the working directory were not executed. When <code>SCIHOME</code> is not the working directory, <code>SCIHOME\scilab.ini</code> was executed twice.</li>
+<li><a href="http://bugzilla.scilab.org/show_bug.cgi?id=14690">#14690</a>: The user startup files set in the working directory were not executed. When <code>SCIHOME</code> is not the working directory, <code>SCIHOME\scilab.ini</code> was executed twice.</li>
 <li><a href="http://bugzilla.scilab.org/show_bug.cgi?id=14692">#14692</a>: isequal() was always returning true for builtin functions</li>
 <li><a href="http://bugzilla.scilab.org/show_bug.cgi?id=14694">#14694</a>: The list of named colors was misaligned and poorly rendered in <code>help color_list</code></li>
 <li><a href="http://bugzilla.scilab.org/show_bug.cgi?id=14710">#14710</a>: fullpath(TMPDIR+...) was bugged on MacOS</li>
@@ -525,12 +527,16 @@ the <a href="dev@lists.scilab.org">development mailing list</a> for a particular
 <li><a href="http://bugzilla.scilab.org/show_bug.cgi?id=14824">#14824</a>: Incorrect error message with <code>mfprintf(fd, &quot;%d&quot;, [])</code>.</li>
 <li><a href="http://bugzilla.scilab.org/show_bug.cgi?id=14835">#14835</a>: <code>AFFICH_m</code> block was not rendered correctly.</li>
 <li><a href="http://bugzilla.scilab.org/show_bug.cgi?id=14839">#14839</a>: <code>plot2d2</code> crashed Scilab.</li>
+<li><a href="http://bugzilla.scilab.org/show_bug.cgi?id=14885">#14885</a>: The tag property was not documented in Matplot_properties help page.</li>
 <li><a href="http://bugzilla.scilab.org/show_bug.cgi?id=14887">#14887</a>: For many graphic handle types, the display of the <code>.tag</code> value missed <code>&quot;..&quot;</code> delimiters</li>
 <li><a href="http://bugzilla.scilab.org/show_bug.cgi?id=14909">#14909</a>: getlongpathname and getshortpathname return values with &quot;&quot; instead of &quot;/&quot;</li>
 <li><a href="http://bugzilla.scilab.org/show_bug.cgi?id=14911">#14911</a>: Added the entry &quot;Label =&gt; Title&quot; in the graphic context menu in a figure</li>
 <li><a href="http://bugzilla.scilab.org/show_bug.cgi?id=14941">#14941</a>: <code>find</code> did not accept encoded integers</li>
 <li><a href="http://bugzilla.scilab.org/show_bug.cgi?id=14942">#14942</a>: Keep the Tkscale block label if block already has label.</li>
 <li><a href="http://bugzilla.scilab.org/show_bug.cgi?id=14956">#14956</a>: <code>clf(&quot;reset&quot;)</code> forgot resetting the <code>immediate_drawing</code>, <code>resize</code>, <code>resizefcn</code>, <code>closerequestfcn</code>, <code>toolbar_visible</code>, <code>menubar_visible</code>, <code>infobar_visible</code>, <code>default_axes</code>, and <code>icon</code> figure properties.</li>
+<li><a href="http://bugzilla.scilab.org/show_bug.cgi?id=14965">#14965</a>: <code>getPreferencesValue</code> could not read a tag having multiple occurrences and did not accept the path to the preferences file.</li>
+<li><a href="http://bugzilla.scilab.org/show_bug.cgi?id=14976">#14976</a>: <code>asciimat(colNum)</code> concatenated rows when colNum has a single column of ascii codes. With UTF-8 chars, <code>asciimat(asciimat(&quot;àéïôù&quot;))</code> yielded an error.</li>
+<li><a href="http://bugzilla.scilab.org/show_bug.cgi?id=14978">#14978</a>: <code>input(message)</code> interpreted an entered <code>x</code> as a literal string, and exited with the new prompt on the same line.</li>
 </ul>
 <h3>Bugs fixed in 6.0.0 beta-2 and earlier 6.0.0 pre-releases:</h3>
 <ul>