* Bug 12999 fixed: now zeros() and ones() can return integers 64/19964/17
Stéphane Mottelet [Thu, 19 Apr 2018 10:07:17 +0000 (12:07 +0200)]
http://bugzilla.scilab.org/12999

new syntax zeros(n1,..,nd,"type") and zeros(A,"type") are supported
for type in the set {double, boolean, (u)int(8|16|32|64)}
Legacy syntax works as before, i.e. zeros(A) is always a double and
empty matrix is always a double.

Change-Id: I4c3f9bbd42cadd058e6130e8dd4fc9bbfb1eeafa

scilab/modules/elementary_functions/help/en_US/elementarymatrices/ones.xml
scilab/modules/elementary_functions/help/en_US/elementarymatrices/zeros.xml
scilab/modules/elementary_functions/help/fr_FR/elementarymatrices/ones.xml
scilab/modules/elementary_functions/help/fr_FR/elementarymatrices/zeros.xml
scilab/modules/elementary_functions/includes/elem_func_gw.hxx
scilab/modules/elementary_functions/sci_gateway/cpp/elem_func_gw.cpp
scilab/modules/elementary_functions/sci_gateway/cpp/sci_ones.cpp
scilab/modules/elementary_functions/sci_gateway/cpp/sci_zeros.cpp
scilab/modules/elementary_functions/tests/unit_tests/zeros.dia.ref [deleted file]
scilab/modules/elementary_functions/tests/unit_tests/zeros.tst

index 69d6d67..5e48205 100644 (file)
                     <para>integers</para>
                 </listitem>
             </varlistentry>
+            <varlistentry>
+                <term>type</term>
+                <listitem>
+                    <para>optional character string: 'double', 'boolean', 'int8', 'uint8', 'int16', 'uint16', 'int32', 'uint32', 'int64', or 'uint64'.</para>
+                </listitem>
+            </varlistentry>
         </variablelist>
     </refsection>
     <refsection>
         <title>Description</title>
-        <para>Returns a matrix made of ones.</para>
+        <para>Returns a matrix made of ones.  By default the returned matrix is of double precision floating point type but a given type can be precised in the <term>type</term>argument.</para>
         <variablelist>
             <varlistentry>
-                <term>ones(m1,m2)</term>
+                <term>ones(m1,m2,..,mn)</term>
                 <listitem>
                     <para>
-                        returns a <literal>(m1,m2)</literal> matrix full of
+                        creates a <literal>(m1,m2,..,mn)</literal> matrix full of
                         ones.
                     </para>
                 </listitem>
             </varlistentry>
             <varlistentry>
-                <term>ones(m1,m2,..,mn)</term>
+                <term>ones(m1,m2,..,mn,type)</term>
                 <listitem>
                     <para>
-                        creates a <literal>(m1,m2,..,mn)</literal> matrix full of
-                        ones.
+                        returns a <literal>(m1,m2,..,mn)</literal> matrix made of ones with type given by <literal>type</literal>. In the case of boolean type the matrix is filled with <literal>%T</literal> value. 
                     </para>
                 </listitem>
             </varlistentry>
             <varlistentry>
                 <term>ones(x)</term>
                 <listitem>
-                    <para>returns a matrix full of ones with the same size that
+                    <para>returns a matrix full of ones with the same size as
                         <literal>x</literal>.
                     </para>
                 </listitem>
             </varlistentry>
             <varlistentry>
+                <term>ones(x,type)</term>
+                <listitem>
+                    <para>returns a matrix full of ones with the same size as
+                        <literal>x</literal> and type given by <literal>type</literal>. In the case of boolean type the matrix is filled with <literal>%T</literal> value. 
+                    </para>
+                </listitem>
+            </varlistentry>
+            <varlistentry>
                 <term>ones(x)</term>
                 <listitem>
                     <para>
         <programlisting role="example"><![CDATA[
 ones(3)
 ones(3,3)
+ones(3,3,"uint8")
+ones(3,3,"boolean")
 ones(2,3,2)
 
 repmat(1, [2 4 2])
@@ -128,6 +143,9 @@ repmat(1, [2 4 2])
             <member>
                 <link linkend="zeros">zeros</link>
             </member>
+            <member>
+                <link linkend="repmat">repmat</link>
+            </member>
         </simplelist>
     </refsection>
 </refentry>
index 2ea49c6..0b812fc 100644 (file)
           xmlns:scilab="http://www.scilab.org" xml:id="zeros" xml:lang="en">
     <refnamediv>
         <refname>zeros</refname>
-        <refpurpose>matrix made of zeros</refpurpose>
+        <refpurpose>null matrix</refpurpose>
     </refnamediv>
     <refsynopsisdiv>
         <title>Syntax</title>
-        <synopsis>y=zeros()
+        <synopsis>y=zeros(m1,m2,...)
             y=zeros(x)
-            y=zeros(m1,m2,..)
+            y=zeros()
         </synopsis>
     </refsynopsisdiv>
     <refsection>
                     <para>integers</para>
                 </listitem>
             </varlistentry>
+            <varlistentry>
+                <term>type</term>
+                <listitem>
+                    <para>optional character string: 'double', 'boolean','int8', 'uint8', 'int16', 'uint16', 'int32', 'uint32', 'int64', or 'uint64'.</para>
+                </listitem>
+            </varlistentry>
         </variablelist>
     </refsection>
     <refsection>
         <title>Description</title>
-        <para>
-            Creates matrix of zeros (same as <literal>0*ones</literal>).
-        </para>
+        <para>Returns a null matrix.  By default the returned matrix is of double precision floating point type but a given type can be precised in the <term>type</term> argument.</para>
         <variablelist>
             <varlistentry>
-                <term>zeros(m1,m2)</term>
+                <term>zeros(m1,m2,..,mn)</term>
                 <listitem>
                     <para>
-                        for an <literal>(m1,m2)</literal> matrix.
+                        creates a <literal>(m1,m2,..,mn)</literal> null matrix.
                     </para>
                 </listitem>
             </varlistentry>
             <varlistentry>
-                <term>zeros(m1,m2,..,mn)</term>
+                <term>zeros(m1,m2,..,mn,type)</term>
                 <listitem>
                     <para>
-                        creates a <literal>(m1,m2,..,mn)</literal> matrix filled with
-                        zeros
+                        returns a <literal>(m1,m2,..,mn)</literal> null matrix with type given by <literal>type</literal>. In the case of boolean type the matrix is filled with <literal>%F</literal> value. 
                     </para>
                 </listitem>
             </varlistentry>
             <varlistentry>
-                <term>zeros(A)</term>
+                <term>zeros(x)</term>
                 <listitem>
-                    <para>
-                        for a matrix of same size of <literal>A</literal>.
+                    <para>returns a null matrix with the same size as
+                        <literal>x</literal>.
                     </para>
                 </listitem>
             </varlistentry>
             <varlistentry>
-                <term>zeros(3)</term>
+                <term>zeros(m1,m2,..,mn,type)</term>
                 <listitem>
                     <para>
-                        is <literal>zeros(a)</literal> with <literal>a=3</literal> i.e
-                        it is NOT a 3x3 matrix!
+                        returns a null matrix with the same size as <literal>x</literal>
+                        and type given by <literal>type</literal>. In the case of boolean type the matrix is filled with <literal>%F</literal> value. 
                     </para>
                 </listitem>
             </varlistentry>
             <varlistentry>
-                <term>zeros()</term>
+                <term>zeros(x)</term>
                 <listitem>
-                    <para>returns a single zero</para>
+                    <para>
+                        is also valid for <literal>x</literal> a
+                        <literal>syslin</literal> list.
+                    </para>
                 </listitem>
             </varlistentry>
         </variablelist>
+    </refsection>
+    <refsection>
+        <title>Remarks</title>
+        <itemizedlist>
+            <listitem>
+                <para>
+                    Note that <literal>zeros(3)</literal> is <literal>zeros(a)</literal>
+                    with <literal>a=3</literal> i.e it is NOT a 3x3 matrix!
+                </para>
+            </listitem>
+            <listitem>
+                <para>zeros() is equivalent to zeros(1,1).</para>
+            </listitem>
+            <listitem>
+                <para>
+                    <literal>zeros(3,-3)</literal> and <literal>zeros(-3,-3)</literal> both return an empty matrix.
+                </para>
+            </listitem>
+        </itemizedlist>
         <note>
-           <literal>repmat(0, sizes)</literal> can be used to generate an array of zeros with
+           <literal>repmat(1, sizes)</literal> can be used to generate an array of zeros with
            <literal>sizes=[m1 m2 ..]</literal> given as a vector.
         </note>
-        <para>
-            If <literal>x</literal> is a <literal>syslin</literal> list (linear
-            system in state-space or transfer form), <literal>zeros(x)</literal> is
-            also valid and returns a zero matrix.
-        </para>
     </refsection>
     <refsection>
         <title>Examples</title>
         <programlisting role="example"><![CDATA[
 zeros(3)
 zeros(3,3)
+zeros(3,3,"uint8")
+zeros(3,3,"boolean")
 zeros(2,3,2)
 
-repmat(0, [2 4 2])
+repmat(1, [2 4 2])
  ]]></programlisting>
     </refsection>
     <refsection role="see also">
@@ -122,7 +144,7 @@ repmat(0, [2 4 2])
                 <link linkend="ones">ones</link>
             </member>
             <member>
-                <link linkend="spzeros">spzeros</link>
+                <link linkend="repmat">repmat</link>
             </member>
         </simplelist>
     </refsection>
index 42eefc4..93c31d7 100644 (file)
@@ -9,8 +9,8 @@
     </refnamediv>
     <refsynopsisdiv>
         <title>Séquence d'appel</title>
-        <synopsis>y=ones(m1,m2,...)
-            y=ones(x)
+        <synopsis>y=ones(m1,m2,...,[,type])
+            y=ones(x,[,type])
             y=ones()
         </synopsis>
     </refsynopsisdiv>
                     <para>entiers</para>
                 </listitem>
             </varlistentry>
+            <varlistentry>
+                <term>type</term>
+                <listitem>
+                    <para>chaine de caractères optionnelle : 'double', 'boolean', 'int8', 'uint8', 'int16', 'uint16', 'int32', 'uint32', 'int64', ou 'uint64'.</para>
+                </listitem>
+            </varlistentry>
         </variablelist>
     </refsection>
     <refsection>
         <title>Description</title>
-        <para>Renvoie une matrice dont tous les termes valent 1.</para>
+        <para>Renvoie une matrice dont tous les termes valent 1. Par défaut la matrice renvoyée est de type flottant à double précision mais un type donné peut être précisé dans l'argument <term>type</term>.
+        </para>
         <variablelist>
             <varlistentry>
-                <term>ones(m1,m2)</term>
+                <term>ones(m1,m2,..,mn)</term>
                 <listitem>
                     <para>
-                        Renvoie une matrice de taille <literal>(m1,m2)</literal>
-                        remplie de 1.
+                        renvoie une matrice <literal>(m1,m2,..,mn)</literal> remplie
+                        de 1.
                     </para>
                 </listitem>
             </varlistentry>
             <varlistentry>
-                <term>ones(m1,m2,..,mn)</term>
+                <term>ones(m1,m2,..,mn,type)</term>
                 <listitem>
                     <para>
-                        renvoie une matrice <literal>(m1,m2,..,mn)</literal> remplie
-                        de 1.
+                        renvoie une matrice <literal>(m1,m2,..,mn)</literal> remplie de 1 et de type précisé dans <literal>type</literal>. Dans le cas où le type est booléen la matrice est remplie avec la valeur <literal>%T</literal>. 
                     </para>
                 </listitem>
             </varlistentry>
             <varlistentry>
                 <term>ones(x)</term>
                 <listitem>
-                    <para>renvoie une matrice remplie de 1 de même taille que
+                    <para>renvoie une matrice remplie de 1. de même taille que
                         <literal>x</literal>.
                     </para>
                 </listitem>
             </varlistentry>
             <varlistentry>
+                <term>ones(x,type)</term>
+                <listitem>
+                    <para>
+                        renvoie une matrice remplie de 1. de même taille que <literal>x</literal>.
+                         et de type précisé dans <literal>type</literal>. Dans le cas où le type est booléen la matrice est remplie avec la valeur <literal>%T</literal>. 
+                    </para>
+                </listitem>
+            </varlistentry>
+            <varlistentry>
                 <term>ones(x)</term>
                 <listitem>
                     <para>
         <programlisting role="example"><![CDATA[
 ones(3)
 ones(3,3)
+ones(3,3,'uint8')
+ones(3,3,'boolean')
 ones(2,3,2)
 
 repmat(1, [2 4 2])
@@ -117,6 +134,9 @@ repmat(1, [2 4 2])
             <member>
                 <link linkend="zeros">zeros</link>
             </member>
+            <member>
+                <link linkend="repmat">repmat</link>
+            </member>
         </simplelist>
     </refsection>
 </refentry>
index f43dc55..b5f4069 100644 (file)
@@ -9,8 +9,8 @@
     </refnamediv>
     <refsynopsisdiv>
         <title>Séquence d'appel</title>
-        <synopsis>y=zeros(m1,m2,...)
-            y=zeros(x)
+        <synopsis>y=zeros(m1,m2,...,[,type])
+            y=zeros(x,[,type])
             y=zeros()
         </synopsis>
     </refsynopsisdiv>
                     <para>entiers</para>
                 </listitem>
             </varlistentry>
+            <varlistentry>
+                <term>type</term>
+                <listitem>
+                    <para>chaine de caractères optionnelle : 'double', 'boolean', 'int8', 'uint8', 'int16', 'uint16', 'int32', 'uint32', 'int64', ou 'uint64'.</para>
+                </listitem>
+            </varlistentry>
         </variablelist>
     </refsection>
     <refsection>
         <title>Description</title>
-        <para>Renvoie une matrice dont tous les termes sont nuls.</para>
+        <para>Renvoie une matrice nulle Par défaut la matrice renvoyée est de type flottant à double précision mais un type donné peut être précisé dans l'argument <term>type</term>.
+        </para>
         <variablelist>
             <varlistentry>
-                <term>zeros(m1,m2)</term>
+                <term>zeros(m1,m2,..,mn)</term>
                 <listitem>
-                    <para>Renvoie une matrice nulle de taille
-                        <literal>(m1,m2)</literal>.
+                    <para>
+                        renvoie une matrice nulle de dimensions<literal>(m1,m2,..,mn)</literal> 
                     </para>
                 </listitem>
             </varlistentry>
             <varlistentry>
-                <term>zeros(m1,m2,..,mn)</term>
+                <term>zeros(m1,m2,..,mn,type)</term>
                 <listitem>
-                    <para>renvoie une matrice nulle de taille
-                        <literal>(m1,m2,..,mn)</literal>.
+                    <para>
+                        renvoie une matrice nulle de dimensions <literal>(m1,m2,..,mn)</literal> et de type précisé dans <literal>type</literal>. Dans le cas où le type est booléen la matrice est remplie avec la valeur <literal>%F</literal>. 
                     </para>
                 </listitem>
             </varlistentry>
                 </listitem>
             </varlistentry>
             <varlistentry>
+                <term>zeros(x,type)</term>
+                <listitem>
+                    <para>
+                        renvoie une matrice nulle de même taille que <literal>x</literal>.
+                         et de type précisé dans <literal>type</literal>. Dans le cas où le type est booléen la matrice est remplie avec la valeur <literal>%F</literal>. 
+                    </para>
+                </listitem>
+            </varlistentry>
+            <varlistentry>
                 <term>zeros(x)</term>
                 <listitem>
                     <para>
                 </listitem>
             </varlistentry>
         </variablelist>
-        <warning>
-            <literal>zeros(3)</literal> est équivalent à
-            <literal>zeros(a)</literal> avec <literal>a=3</literal> et donc n'est PAS
-            une matrice 3x3 !
-        </warning>
-        <para>zeros() est équivalent à zeros(1,1).</para>
+    </refsection>
+    <refsection>
+        <title>Remarques</title>
+        <itemizedlist>
+            <listitem>
+                <para>
+                    Notez que <literal>zeros(3)</literal> est équivalent à
+                    <literal>zeros(a)</literal> avec <literal>a=3</literal> et donc n'est PAS
+                    une matrice 3x3 !
+                </para>
+            </listitem>
+            <listitem>
+                <para>zeros() est équivalent à zeros(1,1).</para>
+            </listitem>
+            <listitem>
+                <para>
+                    Les commandes <literal>zeros(3,-3)</literal> et <literal>zeros(-3,-3)</literal> renvoient
+                    une matrice vide.
+                </para>
+            </listitem>
+        </itemizedlist>
         <note>
-           <literal>repmat(0, sizes)</literal> peut être utilisé pour générer un tableau de zéros
-           dont les dimensions sont données dans un vecteur <literal>sizes=[m1 m2 ..]</literal>.
+           <literal>repmat(0, sizes)</literal> peut être utilisé pour créer une matrice nulle dont
+           les dimensions sont données dans un vecteur <literal>sizes=[m1 m2 ..]</literal>.
         </note>
     </refsection>
     <refsection>
         <programlisting role="example"><![CDATA[
 zeros(3)
 zeros(3,3)
+zeros(3,3,'uint8')
+zeros(3,3,'boolean')
 zeros(2,3,2)
 
-repmat(0, [2 4 2])
+repmat(1, [2 4 2])
  ]]></programlisting>
     </refsection>
     <refsection role="see also">
@@ -101,7 +134,7 @@ repmat(0, [2 4 2])
                 <link linkend="ones">ones</link>
             </member>
             <member>
-                <link linkend="spzeros">spzeros</link>
+                <link linkend="repmat">repmat</link>
             </member>
         </simplelist>
     </refsection>
index 97880a8..753b4b7 100644 (file)
@@ -2,7 +2,8 @@
 *  Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
 *  Copyright (C) 2008-2008 - DIGITEO - Antoine ELIAS
 *  Copyright (C) 2010-2011 - DIGITEO - Bruno JOFRET
-*
+*  Copyright (C) 2018 - Stéphane Mottelet
+ *
  * Copyright (C) 2012 - 2016 - Scilab Enterprises
  *
  * This file is hereby licensed under the terms of the GNU GPL v2.0,
@@ -20,6 +21,7 @@
 #include "cpp_gateway_prototype.hxx"
 #include "double.hxx"
 #include "complex"
+#include "function.hxx"
 
 extern "C"
 {
@@ -131,5 +133,6 @@ typedef double(*func_real)(double);
 typedef std::complex<double>(*func_complex)(const std::complex<double>&);
 
 types::Double* trigo(types::Double* in, func_real func_r, func_complex func_c, bool forceComplex = false);
+types::Function::ReturnValue zerosOrOnesFromValue(types::typed_list& in, int _iRetCount, types::typed_list& out, bool value);
 
 #endif /* __ELEM_FUNC_GW_HXX__ */
index 878ef95..f6243ab 100644 (file)
@@ -2,7 +2,7 @@
 *  Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
 *  Copyright (C) 2008-2008 - DIGITEO - Antoine ELIAS
 *  Copyright (C) 2011-2011 - DIGITEO - Bruno JOFRET
-*
+*  Copyright (C) 2018 - Stéphane MOTTELET
  * Copyright (C) 2012 - 2016 - Scilab Enterprises
  *
  * This file is hereby licensed under the terms of the GNU GPL v2.0,
@@ -20,6 +20,7 @@
 #endif
 
 #include "elem_func_gw.hxx"
+#include "function.hxx"
 #include "context.hxx"
 #include "overload.hxx"
 #include "Scierror.h"
@@ -27,6 +28,9 @@
 #include "charEncoding.h"
 #include "sparse.hxx"
 #include "int.hxx"
+#include "double.hxx"
+#include "bool.hxx"
+#include "string.hxx"
 
 #define MODULE_NAME L"elementary_functions"
 extern "C"
@@ -277,3 +281,150 @@ types::Double* trigo(types::Double* in, func_real func_r, func_complex func_c, b
 
     return out;
 }
+
+types::Function::ReturnValue zerosOrOnesFromValue(types::typed_list& in, int _iRetCount, types::typed_list& out, bool value)
+{
+    int iDims = 0;
+    int* piDims = NULL;
+
+    static std::map<std::wstring, types::InternalType::ScilabType> mapOfTypes = {
+        {L"double", types::InternalType::ScilabDouble},
+        {L"constant", types::InternalType::ScilabDouble},
+        {L"boolean", types::InternalType::ScilabBool},
+        {L"uint8", types::InternalType::ScilabUInt8},
+        {L"int8", types::InternalType::ScilabInt8},
+        {L"uint16", types::InternalType::ScilabUInt16},
+        {L"int16", types::InternalType::ScilabInt16},
+        {L"uint32", types::InternalType::ScilabUInt32},
+        {L"int32", types::InternalType::ScilabInt32},
+        {L"uint64", types::InternalType::ScilabUInt64},
+        {L"int64", types::InternalType::ScilabInt64}
+    };
+
+    types::InternalType::ScilabType reftype = types::InternalType::ScilabDouble;
+    bool alloc = false;
+
+    int size = (int)in.size();
+    types::InternalType* it = in[size - 1];
+    if (size > 1 && it->isString())
+    {
+        // get optional type string
+        wchar_t* pType = it->getAs<types::String>()->get()[0];
+        auto f = mapOfTypes.find(pType);
+        if (f == mapOfTypes.end())
+        {
+            Scierror(999, _("%s: Wrong value for input argument #%d: Must be in the set {%s}"),
+                value ? "ones" : "zeros", in.size(), "double, boolean, (u)int(8|16|32|64) ");
+            return types::Function::Error;
+        }
+
+        reftype = f->second;
+        in.pop_back();
+    }
+
+    bool ret = getDimsFromArguments(in, value ? "ones" : "zeros", &iDims, &piDims, &alloc);
+    if (ret == false)
+    {
+        switch (iDims)
+        {
+            case -1:
+                Scierror(21, _("Invalid index.\n"));
+                break;
+            case 1:
+            {
+                //call overload
+                return Overload::generateNameAndCall(value ? L"ones" : L"zeros", in, _iRetCount, out);
+            }
+        }
+
+        return types::Function::Error;
+    }
+
+    if (std::find(piDims, piDims+iDims, 0) != piDims+iDims)
+    {
+      // in Scilab, empty matrix is always a Double
+      reftype = types::InternalType::ScilabDouble;
+    }
+
+    switch (reftype)
+    {
+        case types::InternalType::ScilabInt8:
+        {
+            types::Int8* pOut = new types::Int8(iDims, piDims);
+            std::fill(pOut->get(), pOut->get() + pOut->getSize(), value);
+            out.push_back(pOut);
+            break;
+        }
+        case types::InternalType::ScilabInt16:
+        {
+            types::Int16* pOut = new types::Int16(iDims, piDims);
+            std::fill(pOut->get(), pOut->get() + pOut->getSize(), value);
+            out.push_back(pOut);
+            break;
+        }
+        case types::InternalType::ScilabInt32:
+        {
+            types::Int32* pOut = new types::Int32(iDims, piDims);
+            std::fill(pOut->get(), pOut->get() + pOut->getSize(), value);
+            out.push_back(pOut);
+            break;
+        }
+        case types::InternalType::ScilabInt64:
+        {
+            types::Int64* pOut = new types::Int64(iDims, piDims);
+            std::fill(pOut->get(), pOut->get() + pOut->getSize(), value);
+            out.push_back(pOut);
+            break;
+        }
+        case types::InternalType::ScilabUInt8:
+        {
+            types::UInt8* pOut = new types::UInt8(iDims, piDims);
+            std::fill(pOut->get(), pOut->get() + pOut->getSize(), value);
+            out.push_back(pOut);
+            break;
+        }
+        case types::InternalType::ScilabUInt16:
+        {
+            types::UInt16* pOut = new types::UInt16(iDims, piDims);
+            std::fill(pOut->get(), pOut->get() + pOut->getSize(), value);
+            out.push_back(pOut);
+            break;
+        }
+        case types::InternalType::ScilabUInt32:
+        {
+            types::UInt32* pOut = new types::UInt32(iDims, piDims);
+            std::fill(pOut->get(), pOut->get() + pOut->getSize(), value);
+            out.push_back(pOut);
+            break;
+        }
+        case types::InternalType::ScilabUInt64:
+        {
+            types::UInt64* pOut = new types::UInt64(iDims, piDims);
+            std::fill(pOut->get(), pOut->get() + pOut->getSize(), value);
+            out.push_back(pOut);
+            break;
+        }
+        case types::InternalType::ScilabBool:
+        {
+            types::Bool* pOut = new types::Bool(iDims, piDims);
+            std::fill(pOut->get(), pOut->get() + pOut->getSize(), value);
+            out.push_back(pOut);
+            break;
+        }
+        default: // other cases: create double with inherited dimensions only (not type)
+        case types::InternalType::ScilabDouble:
+        {
+            types::Double* pOut = new types::Double(iDims, piDims);
+            std::fill(pOut->get(), pOut->get() + pOut->getSize(), value);
+            out.push_back(pOut);
+            break;
+        }
+    }
+
+    if (alloc)
+    {
+        delete[] piDims;
+    }
+
+    return types::Function::OK;
+}
index 0b6f9eb..20a701f 100644 (file)
@@ -4,6 +4,7 @@
  * Copyright (C) 2011 - DIGITEO - Antoine ELIAS
  * Copyright (C) 2013 - Scilab Enterprises - Cedric Delamarre
  * Copyright (C) 2014 - Scilab Enterprises - Anais Aubert
+ * Copyright (C) 2018 - Stéphane Mottelet
  *
  * Copyright (C) 2012 - 2016 - Scilab Enterprises
  *
 /*--------------------------------------------------------------------------*/
 #include "elem_func_gw.hxx"
 #include "function.hxx"
-#include "overload.hxx"
-#include "double.hxx"
-
-extern "C"
-{
-#include "Scierror.h"
-#include "localization.h"
-#include "charEncoding.h"
-}
 
 /*--------------------------------------------------------------------------*/
+
 types::Function::ReturnValue sci_ones(types::typed_list &in, int _iRetCount, types::typed_list &out)
 {
-    types::Double* pOut = NULL;
-
-    int iDims = 0;
-    int* piDims = NULL;
-    bool alloc = false;
-
-    bool ret = getDimsFromArguments(in, "ones", &iDims, &piDims, &alloc);
-    if (ret == false)
-    {
-        switch (iDims)
-        {
-            case -1 :
-                Scierror(21, _("Invalid index.\n"));
-                break;
-            case 1:
-            {
-                //call overload
-                return Overload::generateNameAndCall(L"ones", in, _iRetCount, out);
-            }
-        }
-
-        return types::Function::Error;
-    }
-
-    pOut = new types::Double(iDims, piDims);
-    if (alloc)
-    {
-        delete[] piDims;
-    }
-
-    pOut->setOnes();
-
-    out.push_back(pOut);
-    return types::Function::OK;
+    return zerosOrOnesFromValue(in, _iRetCount, out, true);
 }
 /*--------------------------------------------------------------------------*/
index e8f1fa9..b910324 100644 (file)
@@ -4,6 +4,7 @@
  * Copyright (C) 2011 - DIGITEO - Antoine ELIAS
  * Copyright (C) 2014 - Scilab Enterprises - Sylvain GENIN
  * Copyright (C) 2014 - Scilab Enterprises - Anais Aubert
+ * Copyright (C) 2018 - Stéphane Mottelet
  *
  * Copyright (C) 2012 - 2016 - Scilab Enterprises
  *
 /*--------------------------------------------------------------------------*/
 #include "elem_func_gw.hxx"
 #include "function.hxx"
-#include "overload.hxx"
-#include "double.hxx"
-
-extern "C"
-{
-#include "Scierror.h"
-#include "localization.h"
-#include "charEncoding.h"
-}
 
 /*--------------------------------------------------------------------------*/
+
 types::Function::ReturnValue sci_zeros(types::typed_list &in, int _iRetCount, types::typed_list &out)
 {
-    types::Double* pOut = NULL;
-
-    int iDims = 0;
-    int* piDims = NULL;
-    bool alloc = false;
-
-    bool ret = getDimsFromArguments(in, "zeros", &iDims, &piDims, &alloc);
-    if (ret == false)
-    {
-        switch (iDims)
-        {
-            case -1:
-                Scierror(21, _("Invalid index.\n"));
-                break;
-            case 1:
-            {
-                //call overload
-                return Overload::generateNameAndCall(L"zeros", in, _iRetCount, out);
-            }
-        }
-
-        return types::Function::Error;
-    }
-
-    pOut = new types::Double(iDims, piDims);
-    if (alloc)
-    {
-        delete[] piDims;
-    }
-
-    pOut->setZeros();
-    out.push_back(pOut);
-    return types::Function::OK;
+    return zerosOrOnesFromValue(in, _iRetCount, out, false);
 }
 /*--------------------------------------------------------------------------*/
diff --git a/scilab/modules/elementary_functions/tests/unit_tests/zeros.dia.ref b/scilab/modules/elementary_functions/tests/unit_tests/zeros.dia.ref
deleted file mode 100644 (file)
index 73a4ecf..0000000
+++ /dev/null
@@ -1,13 +0,0 @@
-// =============================================================================
-// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
-// Copyright (C) 2014 - SCilab Enterprises - Antoine ELIAS
-//
-//  This file is distributed under the same license as the Scilab package.
-// =============================================================================
-// <-- CLI SHELL MODE -->
-res(2,3,4) = 0;
-computed = list([], 1, 10, list(2,3), list(2,3,4));
-expected = list([], 0, 0, [0 0 0;0 0 0], res);
-for i = 1:size(computed)
-    assert_checkequal(zeros(computed(i)(:)), expected(i));
-end
index 5ff3ac8..58aa06b 100644 (file)
@@ -1,11 +1,13 @@
 // =============================================================================
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
-// Copyright (C) 2014 - SCilab Enterprises - Antoine ELIAS
+// Copyright (C) 2018 - ESI - Antoine ELIAS
+// Copyright (C) 2018 - Stéphane MOTTELET
 //
 //  This file is distributed under the same license as the Scilab package.
 // =============================================================================
 
 // <-- CLI SHELL MODE -->
+// <-- NO CHECK REF -->
 
 res(2,3,4) = 0;
 computed = list([], 1, 10, list(2,3), list(2,3,4));
@@ -14,3 +16,79 @@ expected = list([], 0, 0, [0 0 0;0 0 0], res);
 for i = 1:size(computed)
     assert_checkequal(zeros(computed(i)(:)), expected(i));
 end
+
+data = rand(4, 3, 2) * 1000;
+dataz = zeros(data);
+
+// boolean
+ref = isinf(dataz);
+assert_checkequal(zeros(1,0, "boolean"), []);
+assert_checkequal(zeros([], "boolean"), []);
+assert_checkequal(zeros(data, "boolean"), ref);
+assert_checkequal(zeros(4,3,2, "boolean"), ref);
+assert_checkequal(zeros(isinf(data)), dataz);
+
+// int8
+ref = int8(dataz);
+assert_checkequal(zeros(1,0, "int8"), []);
+assert_checkequal(zeros([], "int8"), []);
+assert_checkequal(zeros(data, "int8"), ref);
+assert_checkequal(zeros(4,3,2, "int8"), ref);
+assert_checkequal(zeros(int8(data)), dataz);
+
+// uint8
+ref = uint8(dataz);
+assert_checkequal(zeros(1,0, "uint8"), []);
+assert_checkequal(zeros([], "uint8"), []);
+assert_checkequal(zeros(data, "uint8"), ref);
+assert_checkequal(zeros(4,3,2, "uint8"), ref);
+assert_checkequal(zeros(uint8(data)), dataz);
+
+// int16
+ref = int16(dataz);
+assert_checkequal(zeros(1,0, "int16"), []);
+assert_checkequal(zeros([], "int16"), []);
+assert_checkequal(zeros(data, "int16"), ref);
+assert_checkequal(zeros(4,3,2, "int16"), ref);
+assert_checkequal(zeros(int16(data)), dataz);
+
+// uint16
+ref = uint16(dataz);
+assert_checkequal(zeros(1,0, "uint16"), []);
+assert_checkequal(zeros([], "uint16"), []);
+assert_checkequal(zeros(data, "uint16"), ref);
+assert_checkequal(zeros(4,3,2, "uint16"), ref);
+assert_checkequal(zeros(uint16(data)), dataz);
+
+// int32
+ref = int32(dataz);
+assert_checkequal(zeros(1,0, "int32"), []);
+assert_checkequal(zeros([], "int32"), []);
+assert_checkequal(zeros(data, "int32"), ref);
+assert_checkequal(zeros(4,3,2, "int32"), ref);
+assert_checkequal(zeros(int32(data)), dataz);
+
+// uint32
+ref = uint32(dataz);
+assert_checkequal(zeros(1,0, "uint32"), []);
+assert_checkequal(zeros([], "uint32"), []);
+assert_checkequal(zeros(data, "uint32"), ref);
+assert_checkequal(zeros(4,3,2, "uint32"), ref);
+assert_checkequal(zeros(uint32(data)), dataz);
+
+// int64
+ref = int64(dataz);
+assert_checkequal(zeros(1,0, "int64"), []);
+assert_checkequal(zeros([], "int64"), []);
+assert_checkequal(zeros(data, "int64"), ref);
+assert_checkequal(zeros(4,3,2, "int64"), ref);
+assert_checkequal(zeros(int64(data)), dataz);
+
+// uint64
+ref = uint64(dataz);
+assert_checkequal(zeros(1,0, "uint64"), []);
+assert_checkequal(zeros([], "uint64"), []);
+assert_checkequal(zeros(data, "uint64"), ref);
+assert_checkequal(zeros(4,3,2, "uint64"), ref);
+assert_checkequal(zeros(uint64(data)), dataz);
+