* Bug #12705 fixed - Elementary_functions & m2sci: members() function 95/11795/16
Paul BIGNIER [Mon, 24 Jun 2013 08:30:54 +0000 (10:30 +0200)]
Implementing Matlab's ismember() function under the name members().

The two functions are not equivalent but provide the same feature for the second output argument.

Change-Id: I561578381aa670e23d5629f69f16bde6013628b6

14 files changed:
SEP/INDEX
SEP/SEP_102_members.odt [new file with mode: 0644]
scilab/CHANGES_5.5.X
scilab/modules/elementary_functions/help/en_US/setoperations/intersect.xml
scilab/modules/elementary_functions/help/en_US/setoperations/members.xml [new file with mode: 0644]
scilab/modules/elementary_functions/help/en_US/setoperations/unique.xml
scilab/modules/elementary_functions/help/fr_FR/setoperations/intersect.xml
scilab/modules/elementary_functions/help/fr_FR/setoperations/members.xml [new file with mode: 0644]
scilab/modules/elementary_functions/help/fr_FR/setoperations/unique.xml
scilab/modules/elementary_functions/macros/members.sci [new file with mode: 0644]
scilab/modules/elementary_functions/tests/unit_tests/members.dia.ref [new file with mode: 0644]
scilab/modules/elementary_functions/tests/unit_tests/members.tst [new file with mode: 0644]
scilab/modules/m2sci/help/en_US/m2sci_equivalents/i/ismember.xml [new file with mode: 0644]
scilab/modules/m2sci/macros/kernel/not_yet_converted.sci

index b717ef1..337538a 100644 (file)
--- a/SEP/INDEX
+++ b/SEP/INDEX
@@ -97,3 +97,4 @@ SEP #098: New output argument for qp_solve function
 SEP #099: Matrices of strings as input argument for clear
 SEP #100: Extends history size
 SEP #101: File browser
+SEP #102: members function.
diff --git a/SEP/SEP_102_members.odt b/SEP/SEP_102_members.odt
new file mode 100644 (file)
index 0000000..c4db1fb
Binary files /dev/null and b/SEP/SEP_102_members.odt differ
index 850553f..9ce3b57 100644 (file)
@@ -502,6 +502,9 @@ Bug fixes
 
 * Bug #12703 fixed - In SciNotes, common shortcuts 'SHIFT DELETE', 'SHIFT INSERT' (and others) added.
 
+* Bug #12705 fixed - Function members() added. It allows to find number of occurrences and linear indexes
+                     for common values between two matrices of the same type.
+
 * Bug #12706 fixed - A wrong size matrix as input argument of cross function was not detected.
 
 * Bug #12708 fixed - Incorrect display in SciNotes preferences fixed (onmouseover styles).
index d263467..20b87af 100644 (file)
@@ -143,6 +143,9 @@ A(:,ka)
         <title>See Also</title>
         <simplelist type="inline">
             <member>
+                <link linkend="members">members</link>
+            </member>
+            <member>
                 <link linkend="unique">unique</link>
             </member>
             <member>
diff --git a/scilab/modules/elementary_functions/help/en_US/setoperations/members.xml b/scilab/modules/elementary_functions/help/en_US/setoperations/members.xml
new file mode 100644 (file)
index 0000000..de7cef9
--- /dev/null
@@ -0,0 +1,146 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+ * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+ * Copyright (C) 2009 - Université du Maine - Samuel Gougeon
+ *
+ * This file must be used under the terms of the CeCILL.
+ * This source file is licensed as described in the file COPYING, which
+ * you should have received as part of this distribution.  The terms
+ * are also available at
+ * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
+ *
+ -->
+<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="members" xml:lang="fr">
+    <refnamediv>
+        <refname>members</refname>
+        <refpurpose>returns vectors of indexes corresponding to the common values of two matrices
+        </refpurpose>
+    </refnamediv>
+    <refsynopsisdiv>
+        <title>Calling Sequence</title>
+        <synopsis>[nb [,loc]] = members(A, S [,last])</synopsis>
+    </refsynopsisdiv>
+    <refsection>
+        <title>Arguments</title>
+        <variablelist>
+            <varlistentry>
+                <term>A</term>
+                <listitem>
+                    <para>matrix or hypermatrix of booleans, integers, reals, complexes, polynomials or strings</para>
+                </listitem>
+            </varlistentry>
+            <varlistentry>
+                <term>S</term>
+                <listitem>
+                    <para>
+                        matrix or hypermatrix of same datatype as <literal>A</literal>
+                    </para>
+                </listitem>
+            </varlistentry>
+            <varlistentry>
+                <term>last</term>
+                <listitem>
+                    <para>scalar boolean</para>
+                </listitem>
+            </varlistentry>
+            <varlistentry>
+                <term>nb</term>
+                <listitem>
+                    <para>
+                        matrix of reals, same size as <literal>A</literal>
+                    </para>
+                </listitem>
+            </varlistentry>
+            <varlistentry>
+                <term>loc</term>
+                <listitem>
+                    <para>
+                        matrix of reals, same size as <literal>A</literal>
+                    </para>
+                </listitem>
+            </varlistentry>
+        </variablelist>
+    </refsection>
+    <refsection>
+        <title>Description</title>
+        <para>
+            <literal>nb = members(A, S)</literal> returns the number of occurrences of <literal>A</literal> in <literal>S</literal>.
+            After <literal>[nb, loc] = members(A, S, last)</literal>,
+            <literal>loc(i, j)</literal>contains the linear index in <literal>S</literal> of the first occurrence of <literal>A(i, j)</literal>.
+            If <literal>last==%t</literal>, the index of the last occurrence is returned instead.
+            <literal>loc(i, j)</literal> returns zero if <literal>A(i, j)</literal> is not found.
+            <literal>%inf</literal> and <literal>-%inf</literal> values are supported either in <literal>A</literal> as well as in <literal>S</literal>.
+            <literal>%nan</literal> are only supported in <literal>A</literal>.
+        </para>
+        <para>
+            When <literal>A</literal> is a vector of doubles or integers and <literal>S</literal> is a vector of doubles or integers in strictly increasing order,
+            <literal>dsearch(A, S, "d")</literal> is preferred over <literal>members(A, S)</literal>.
+        </para>
+    </refsection>
+    <refsection>
+        <title>Examples</title>
+        <programlisting role="example"><![CDATA[
+A = [1 8 4 5 2 1];
+S = [9 7 4 2 1 4];
+
+[nb, loc] = members(A, S, %t)
+// Returns nb  = [1 0 2 0 1 1] because, for instance, the third element of A (which is 4) appears twice in S.
+// And     loc = [5 0 6 0 4 5] because the last occurrence in S of the third element of A (which is 4) is in sixth position
+
+[nb, loc] = members(A, S, %f)
+// Returns loc = [5 0 3 0 4 5] because the first occurrence in S of the third element of A (which is 4) is in third position
+
+// With hypermatrices. From previous A and S:
+A = matrix(A, [3 1 2]);
+S = matrix(S, [3 1 2]);
+[nb, loc] = members(A, S, %T)
+
+// With integers:
+A = int8(grand(3, 2, "uin", -5, 5));
+S = int8(grand(4, 4, "uin", -5, 5));
+[nb, loc] = members(A, S)
+
+// With polynomials (complex coefficients are accepted):
+z = %z;
+A = [z (1-z)^2 ; -4 %i*z ];
+S = [2  %i*z -z  3-z  z  z^3 z];
+[nb, loc] = members(A, S)
+
+// With text:
+A = [ "Hi" "Hu" "Allo"];
+S = [ "Hello" "Bonjour" "Allo"
+      "Holà"  "Allo"  "Hallo"
+      "Hi"    "Hé"    "Salud" ];
+[nb, loc] = members(A, S, %t)
+]]></programlisting>
+    </refsection>
+    <refsection role="see also">
+        <title>See Also</title>
+        <simplelist type="inline">
+            <member>
+                <link linkend="dsearch">dsearch</link>
+            </member>
+            <member>
+                <link linkend="intersect">intersect</link>
+            </member>
+            <member>
+                <link linkend="unique">unique</link>
+            </member>
+            <member>
+                <link linkend="gsort">gsort</link>
+            </member>
+            <member>
+                <link linkend="union">union</link>
+            </member>
+        </simplelist>
+    </refsection>
+    <refsection>
+        <title>History</title>
+        <revhistory>
+            <revision>
+                <revnumber>5.5.0</revnumber>
+                <revremark>Function members introduced.</revremark>
+            </revision>
+        </revhistory>
+    </refsection>
+</refentry>
index 36450ec..6c9c1f3 100644 (file)
@@ -105,6 +105,9 @@ unique(A,'c')
         <title>See Also</title>
         <simplelist type="inline">
             <member>
+                <link linkend="members">members</link>
+            </member>
+            <member>
                 <link linkend="union">union</link>
             </member>
             <member>
index f379d9d..04eadac 100644 (file)
@@ -124,6 +124,9 @@ A(:,ka)
         <title>Voir aussi</title>
         <simplelist type="inline">
             <member>
+                <link linkend="members">members</link>
+            </member>
+            <member>
                 <link linkend="unique">unique</link>
             </member>
             <member>
diff --git a/scilab/modules/elementary_functions/help/fr_FR/setoperations/members.xml b/scilab/modules/elementary_functions/help/fr_FR/setoperations/members.xml
new file mode 100644 (file)
index 0000000..9632088
--- /dev/null
@@ -0,0 +1,147 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+ * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+ * Copyright (C) 2009 - Université du Maine - Samuel Gougeon
+ *
+ * This file must be used under the terms of the CeCILL.
+ * This source file is licensed as described in the file COPYING, which
+ * you should have received as part of this distribution.  The terms
+ * are also available at
+ * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
+ *
+ -->
+<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="members" xml:lang="en">
+    <refnamediv>
+        <refname>members</refname>
+        <refpurpose>retourne des vecteurs d'indices correspondants aux valeurs communes entre deux matrices
+        </refpurpose>
+    </refnamediv>
+    <refsynopsisdiv>
+        <title>Séquence d'appel</title>
+        <synopsis>[nb [,loc]] = members(A, S [,last])</synopsis>
+    </refsynopsisdiv>
+    <refsection>
+        <title>Paramètres</title>
+        <variablelist>
+            <varlistentry>
+                <term>A</term>
+                <listitem>
+                    <para>matrice ou hypermatrice de booléens, entiers, réels, complexes, polynômes ou chaînes de caractères</para>
+                </listitem>
+            </varlistentry>
+            <varlistentry>
+                <term>S</term>
+                <listitem>
+                    <para>
+                        matrice ou hypermatrice du même type que <literal>A</literal>
+                    </para>
+                </listitem>
+            </varlistentry>
+            <varlistentry>
+                <term>last</term>
+                <listitem>
+                    <para>booléen</para>
+                </listitem>
+            </varlistentry>
+            <varlistentry>
+                <term>nb</term>
+                <listitem>
+                    <para>
+                        matrice de réels de même taille que <literal>A</literal>
+                    </para>
+                </listitem>
+            </varlistentry>
+            <varlistentry>
+                <term>loc</term>
+                <listitem>
+                    <para>
+                        matrice de réels de même taille que <literal>A</literal>
+                    </para>
+                </listitem>
+            </varlistentry>
+        </variablelist>
+    </refsection>
+    <refsection>
+        <title>Description</title>
+        <para>
+            <literal>nb = members(A, S)</literal> retourne le nombre d'occurrences de <literal>A</literal> dans <literal>S</literal>.
+            Après <literal>[nb, loc] = members(A, S, last)</literal>,
+            <literal>loc(i, j)</literal> contient l'indice linéraire dans <literal>S</literal> de la première occurrence de <literal>A(i, j)</literal>.
+            Si <literal>last==%t</literal>, l'index de la dernière occurrence est retourné.
+            <literal>loc(i, j)</literal> retourne zéro si <literal>A(i, j)</literal> n'est pas trouvé.
+            <literal>%inf</literal> et <literal>-%inf</literal> sont supportés dans <literal>A</literal> et <literal>S</literal>.
+            <literal>%nan</literal> ne sont supportés que dans <literal>A</literal>.
+        </para>
+        <para>
+            Quand <literal>A</literal> est un vecteur de réels ou entiers et <literal>S</literal> est un vecteur de réels ou entiers strictement croissant,
+            <literal>dsearch(A, S, "d")</literal> est préféré à <literal>members(A, S)</literal>.
+        </para>
+    </refsection>
+    <refsection>
+        <title>Exemples</title>
+        <programlisting role="example"><![CDATA[
+A = [1 8 4 5 2 1];
+S = [9 7 4 2 1 4];
+
+[nb, loc] = members(A, S, %t)
+// Retourne loc = [5 0 6 0 4 5] parce-que la dernière occurrence dans S du troisième élément de A (qui est 4) est en sixième position
+
+[nb, loc] = members(A, S, %f)
+// Retourne loc = [5 0 3 0 4 5] parce-que la première occurrence dans S du troisième élément de A (qui est 4) est en troisième position
+
+// Dans les deux cas, nb = [1 0 2 0 1 1] parce-que, par exemple, le nombre d'occurrences du troisième élément de A dans S est 2.
+
+// Avec des hypermatrices. En réutilisant A et S :
+A = matrix(A, [3 1 2]);
+S = matrix(S, [3 1 2]);
+[nb, loc] = members(A, S, %T)
+
+// Avec des entiers :
+A = int8(grand(3, 2, "uin", -5, 5));
+S = int8(grand(4, 4, "uin", -5, 5));
+[nb, loc] = members(A, S)
+
+// Avec des polynômes (les coefficients complexes sont acceptés) :
+z = %z;
+A = [z (1-z)^2 ; -4 %i*z ];
+S = [2  %i*z -z  3-z  z  z^3 z];
+[nb, loc] = members(A, S)
+
+// Avec du texte :
+A = [ "Hi" "Hu" "Allo"];
+S = [ "Hello" "Bonjour" "Allo"
+      "Holà"  "Allo"  "Hallo"
+      "Hi"    "Hé"    "Salud" ];
+[nb, loc] = members(A, S, %t)
+]]></programlisting>
+    </refsection>
+    <refsection role="see also">
+        <title>Voir aussi</title>
+        <simplelist type="inline">
+            <member>
+                <link linkend="dsearch">dsearch</link>
+            </member>
+            <member>
+                <link linkend="intersect">intersect</link>
+            </member>
+            <member>
+                <link linkend="unique">unique</link>
+            </member>
+            <member>
+                <link linkend="gsort">gsort</link>
+            </member>
+            <member>
+                <link linkend="union">union</link>
+            </member>
+        </simplelist>
+    </refsection>
+    <refsection>
+        <title>Historique</title>
+        <revhistory>
+            <revision>
+                <revnumber>5.5.0</revnumber>
+                <revremark>Fonction members introduite.</revremark>
+            </revision>
+        </revhistory>
+    </refsection>
+</refentry>
index ccb6d48..15214e5 100644 (file)
@@ -102,6 +102,9 @@ unique(A,'c')
         <title>Voir aussi</title>
         <simplelist type="inline">
             <member>
+                <link linkend="members">members</link>
+            </member>
+            <member>
                 <link linkend="union">union</link>
             </member>
             <member>
diff --git a/scilab/modules/elementary_functions/macros/members.sci b/scilab/modules/elementary_functions/macros/members.sci
new file mode 100644 (file)
index 0000000..15ecca8
--- /dev/null
@@ -0,0 +1,250 @@
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2009,2013 - Université du Maine - Samuel Gougeon
+//
+// This file must be used under the terms of the CeCILL.
+// This source file is licensed as described in the file COPYING, which
+// you should have received as part of this distribution.  The terms
+// are also available at
+// http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
+
+function [nb, loc] = members(A, S, last)
+    //
+    // Input / Output arguments:
+    // -------------------------
+    // A   : Matrix or hypermatrix of booleans, integers, reals, complexes, polynomials or strings:
+    //       entities (needles) to search in S (haystack).
+    // S   : Matrix or hypermatrix of same datatype as A
+    // last: Scalar boolean
+    // nb  : Matrix of reals: same sizes as A
+    //       nb(i, j, ...): number of occurrences of A(i, j, ...) in S.
+    // loc : Matrix of reals: same sizes as A
+    //       loc(i, j, ...): linear index in S of the first occurrence of A(i, j, ...).
+    //       If last==%t, the index of the last occurrence is returned instead.
+    //       loc(i, j, ...) returns zero if A(i, j, ...) is not found.
+    //
+    // %inf, -%inf values are supported in A as well as in S.
+    // %nan are supported only in A.
+    //
+    // Examples:
+    // ---------
+    // a) with reals:
+    // N = [ 7  3
+    //     %inf 0
+    //     %nan 1 ];
+    // H = [ 5   8    0   4
+    //       3   4    7   7
+    //       3 %inf %inf  2
+    //       7   5    5   8 ];
+    // [nb, loc] = members(N, H)
+    // [nb, loc] = members(N, H, %T)
+    //
+    // b) with hypermatrices, from previous N and H:
+    // N = matrix(N, [3 1 2]);
+    // H = matrix(H, [4 2 2]);
+    // [nb, loc] = members(N, H, %T)
+    //
+    // c) with integers:
+    // N = int8(grand(3, 2, "uin", -5, 5));
+    // H = int8(grand(4, 4, "uin", -5, 5));
+    // [nb, loc] = members(N, H)
+    //
+    // d) with polynomials (complex coefficients are accepted):
+    // z = %z;
+    // N = [z (1-z)^2 ; -4 %i*z ];
+    // H = [2  %i*z -z  3-z  z  z^3 z];
+    // [nb, loc] = members(N, H)
+    //
+    // e) with text:
+    // N = [ "Hi" "Hu" "Allo"];
+    // H = [ "Hello" "Bonjour" "Allo"
+    //       "Holà"  "Allo"  "Hallo"
+    //       "Hi"    "Hé"    "Salud" ];
+    // [nb, loc] = members(N, H, %t)
+
+    [lhs, rhs] = argn();
+    if rhs < 2 then
+        error(msprintf(gettext("%s: Wrong number of input argument(s): at least %d expected.\n"), "members", 2));
+    end
+    if rhs == 2 then
+        last = %f;
+    end
+    if A == [] then
+        nb = [];
+        if lhs > 1 then
+            loc = [];
+        end
+        return
+    end
+    if  S == []  then
+        nb = zeros(A);
+        if lhs > 1 then
+            loc = zeros(A);
+        end
+        return
+    end
+
+    type_A = type(A(:));
+    type_S = type(S(:));
+    if type_A <> type_S then
+        error(msprintf(gettext("%s: Wrong type for input argument #%d: expected same type as first argument.\n"), "members", 2));
+    end
+    if and(type_A <> [1 2 4 8 10]) then
+        error(msprintf(gettext("%s: Wrong type for input argument #%d: Matrix of Integers, Reals, Complexes, Booleans, Polynomials or Strings expected.\n"), "members", 1));
+    end
+    if and(type_S <> [1 2 4 8 10]) then
+        error(msprintf(gettext("%s: Wrong type for input argument #%d: Matrix of Integers, Reals, Complexes, Booleans, Polynomials or Strings expected.\n"), "members", 2));
+    end
+    if or(isnan(S)) then
+        error(msprintf(gettext("%s: Wrong value for argument #%d: Must not contain NaN.\n"), "members", 2));
+    end
+    if type(last) <> 4 then
+        error(msprintf(gettext("%s: Wrong type for input argument #%d: Boolean matrix expected.\n"), "members", 3));
+    end
+    if ~isscalar(last) then
+        error(msprintf(gettext("%s: Wrong size for input argument #%d: Scalar expected.\n"), "members", 3));
+    end
+
+    // ------------------------------------------------------------------------
+
+    // Reals: special faster processing with dsearch().
+    //  %inf, -%inf are supported in A and S. %nan are only supported in A.
+    //  Processing integers and strings requires bugs 6305 & 12778 to be fixed.
+
+    if type_A == 8 then   // Convert integers into reals in order to use dsearch
+        A = double(A);
+        S = double(S);
+    end
+    if type_A == 1 & isreal(A) & isreal(S) then
+        S = S(:);
+        if last then
+            S = S($:-1:1);
+        end
+        [Su, kS] = unique(S);
+        [i, nbS] = dsearch(S, Su, "d");
+
+        I = dsearch(A(:), Su, "d");
+        k = find(I~=0);
+        nb = I;
+        nb(k) = nbS(I(k));
+        nb = matrix(nb, size(A));
+        if lhs > 1 then
+            loc = I;
+            loc(k) = kS(I(k));
+            if last then
+                loc(k) = length(S)-loc(k)+1;
+            end
+            loc = matrix(loc, size(A));
+        end
+        // ------------------------------------------------------------------------
+    else
+        // Other cases : polynomials, text, complexes
+        // ==========================================
+        sA = size(A);
+        LA = size(A, "*");
+        LS = size(S, "*");
+        A = A(:);
+        if ~last then
+            S = S($:-1:1);
+        end
+
+        // Slices may be needed in case of memory overflow
+        //
+        // Function returning the memory space in [bytes] occupied by each
+        //  querried variable. If a variable exists in several contexts,
+        //  only the last created one is considered
+        function varargout = varspace(varargin)
+            [Ln, Ls] = who("local");
+            vs = list();
+            for vn = varargin
+                i = find(Ln==vn);
+                if i ~= [] then
+                    vs($+1) = Ls(i(1))*8;
+                else
+                    vs($+1) = 0;
+                end
+            end
+            varargout = vs;
+        endfunction
+        // -----------------------------------
+        // Memory space needed to process a i:j slice of A:
+        // nb  : j doubles (occupied at the end)
+        // loc : j doubles (occupied at the end)
+        // tmp : LS * (j-i+1) doubles needed
+        // A2  : LS * mem(A(i:j)) needed
+        // S2  : mem(S)*(j-i+1) needed
+
+        // Function setting the thickness of the slice, according to the
+        //    available and needed memory
+        function j = set_j(i, LS, memS, rA)
+            // rA : remaining unprocessed part of A
+            [memA2, memS2, memtmp] = varspace("A2", "S2", "tmp");
+            // Available memory [bytes]:
+            m = stacksize();
+            avail = (m(1)-m(2))*8 + memA2 + memS2 + memtmp -16*(i-1); // [bytes]
+            avail = 0.15*avail;  // A lot of memory is used as Intermediate memory
+            // Diadic loop on e = j-i+1 (slice's thickness):
+            // Init
+            e = size(rA, "*");
+            Vtest = rA(1:e);
+            memrA = varspace("Vtest");   // [bytes]
+            // Loop fitting the slice's thickness e for the available memory
+            while (e*(memS+8*LS+16)+LS*memrA > avail & e > 1)
+                e = ceil(e/2);   // Remaining thickness => divided by 2
+                Vtest = rA(1:e);
+                memrA = varspace("Vtest");
+            end
+            if (e*(memS+8*LS+16)+LS*memrA > avail) then
+                msg = _("%s: not enough memory to proceed");
+                error(sprintf(msg, "members"));
+            end
+            j = i+e-1;
+        endfunction
+
+        memS = varspace("S");  // [bytes]
+
+        // Starting and ending indices in A for the current slice
+        i = 1;   // Starting index: initialization
+        j = 0;   // Ending index: initialization
+        while j < LA      // Slicing loop
+            // Setting next j (=> thickness of the slice = j-i+1)
+            j = set_j(i, LS, memS, A(i:$));
+
+            // Progression bar
+            if j < LA then
+                if isdef("waitH") then
+                    waitbar(j/LA, waitH);
+                elseif j/LA < 0.4   // Else: too few steps => not worthwhile
+                    waitH = waitbar(j/LA);
+                end
+            end
+
+            A2 = repmat(A(i:j), 1, LS);
+            S2 = repmat(S(:).', j-i+1, 1);
+
+            tmp = bool2s(A2==S2);
+            nb(i:j) = sum(tmp, "c");
+            if lhs > 1 then
+                tmp = tmp.* ( (1:LS) .*. ones(j-i+1, 1) );
+                loc(i:j) = max(tmp, "c");
+            end
+            i = j+1;
+            // End of slice processing
+        end
+        // Deleting the waitbar (if any) and clearing transient variables
+        clear A2 S2 tmp
+        if isdef("waitH") then
+            delete(waitH);
+        end
+
+        // Final operations on the overall result(s)
+        nb = matrix(nb, sA);
+        if lhs > 1
+            if ~last
+                k = loc~=0;
+                loc(k) = LS - loc(k) + 1;
+            end
+            loc = matrix(loc, sA);
+        end
+    end
+
+endfunction
diff --git a/scilab/modules/elementary_functions/tests/unit_tests/members.dia.ref b/scilab/modules/elementary_functions/tests/unit_tests/members.dia.ref
new file mode 100644 (file)
index 0000000..bf92370
--- /dev/null
@@ -0,0 +1,307 @@
+// =============================================================================
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2013 - Scilab Enterprises - Paul Bignier
+//
+//  This file is distributed under the same license as the Scilab package.
+// =============================================================================
+// <-- CLI SHELL MODE -->
+// <-- ENGLISH IMPOSED -->
+// Vectors
+[nb, loc] = members([], [], %t);
+assert_checkequal(nb , []);
+assert_checkequal(loc, []);
+[nb, loc] = members([], [], %f);
+assert_checkequal(nb , []);
+assert_checkequal(loc, []);
+[nb, loc] = members([1 2], [3 4], %t);
+assert_checkequal(nb , [0 0]);
+assert_checkequal(loc, [0 0]);
+[nb, loc] = members([1 2], [3 4], %f);
+assert_checkequal(nb , [0 0]);
+assert_checkequal(loc, [0 0]);
+[nb, loc] = members([1 2; 3 4], [5 6; 7 8], %t);
+assert_checkequal(nb , [0 0; 0 0]);
+assert_checkequal(loc, [0 0; 0 0]);
+[nb, loc] = members([1 2; 3 4], [5 6; 7 8], %f);
+assert_checkequal(nb , [0 0; 0 0]);
+assert_checkequal(loc, [0 0; 0 0]);
+[nb, loc] = members(string([1 2; 3 4]), string([5 6; 7 8]), %t);
+assert_checkequal(nb , [0 0; 0 0]);
+assert_checkequal(loc, [0 0; 0 0]);
+[nb, loc] = members(string([1 2; 3 4]), string([5 6; 7 8]), %f);
+assert_checkequal(nb , [0 0; 0 0]);
+assert_checkequal(loc, [0 0; 0 0]);
+A = [1 8 4 5 2 1];
+S = [9 7 4 2 1 4];
+[nb, loc] = members(A, S, %t);
+assert_checkequal(nb , [1 0 2 0 1 1]);
+assert_checkequal(loc, [5 0 6 0 4 5]);
+[nb, loc] = members(A, S, %f);
+assert_checkequal(nb , [1 0 2 0 1 1]);
+assert_checkequal(loc, [5 0 3 0 4 5]);
+// Strings
+A = 'a'+string(A);
+S = 's'+string(S);
+[nb, loc] = members(A, S, %t);
+assert_checkequal(nb , [0 0 0 0 0 0]);
+assert_checkequal(loc, [0 0 0 0 0 0]);
+[nb, loc] = members(A, S, %f);
+assert_checkequal(nb , [0 0 0 0 0 0]);
+assert_checkequal(loc, [0 0 0 0 0 0]);
+A = ["elt1" "elt3" "elt4"];
+S = ["elt5" "elt1" "elt3"];
+[nb, loc] = members(A, S, %t);
+assert_checkequal(nb , [1 1 0]);
+assert_checkequal(loc, [2 3 0]);
+[nb, loc] = members(A, S, %f);
+assert_checkequal(nb , [1 1 0]);
+assert_checkequal(loc, [2 3 0]);
+A = ["elt1" "elt3" "elt4"];
+S = ["elt5" "elt6" "elt2" "elt1" "elt3"];
+[nb, loc] = members(A, S, %t);
+assert_checkequal(nb , [1 1 0]);
+assert_checkequal(loc, [4 5 0]);
+[nb, loc] = members(A, S, %f);
+assert_checkequal(nb , [1 1 0]);
+assert_checkequal(loc, [4 5 0]);
+// Integers
+A = int16([1 8 4 5 2 1]);
+S = int16([9 7 4 2 1 4]);
+[nb, loc] = members(A, S, %t);
+assert_checkequal(nb , [1 0 2 0 1 1]);
+assert_checkequal(loc, [5 0 6 0 4 5]);
+[nb, loc] = members(A, S, %f);
+assert_checkequal(nb , [1 0 2 0 1 1]);
+assert_checkequal(loc, [5 0 3 0 4 5]);
+A = uint8([1 8 4 5 2 1]);
+S = uint8([9 7 4 2 1 4]);
+[nb, loc] = members(A, S, %t);
+assert_checkequal(nb , [1 0 2 0 1 1]);
+assert_checkequal(loc, [5 0 6 0 4 5]);
+[nb, loc] = members(A, S, %f);
+assert_checkequal(nb , [1 0 2 0 1 1]);
+assert_checkequal(loc, [5 0 3 0 4 5]);
+// Complexes
+A = [1 8 4 5 2 1]*%i;
+S = [9 7 4 2 1 4]*%i;
+[nb, loc] = members(A, S, %t);
+assert_checkequal(nb , [1 0 2 0 1 1]);
+assert_checkequal(loc, [5 0 6 0 4 5]);
+[nb, loc] = members(A, S, %f);
+assert_checkequal(nb , [1 0 2 0 1 1]);
+assert_checkequal(loc, [5 0 3 0 4 5]);
+// Matrices
+A = [ 5 0 1 4 1 ;
+      0 5 3 1 9 ;
+      2 0 1 6 1 ;
+      0 2 2 2 2 ;
+      2 0 8 1 7 ;
+      6 7 1 9 3 ];
+S = [4 8 1 ;
+     1 0 2 ;
+     6 2 3 ;
+     2 9 4 ;
+     1 2 5 ;
+     3 0 6 ];
+loc_ref  = [ 17 12 13 16 13 ;
+             12 17 15 13 10 ;
+             14 12 13 18 13 ;
+             12 14 14 14 14 ;
+             14 12  7 13  0 ;
+             18  0 13 10 15 ];
+loc2_ref = [ 17  8  2  1  2 ;
+              8 17  6  2 10 ;
+              4  8  2  3  2 ;
+              8  4  4  4  4 ;
+              4  8  7  2  0 ;
+              3  0  2  10 6 ];
+nb_ref   = [ 1 2 3 2 3 ;
+             2 1 2 3 1 ;
+             4 2 3 2 3 ;
+             2 4 4 4 4 ;
+             4 2 1 3 0 ;
+             2 0 3 1 2 ];
+[nb, loc] = members(A, S, %t);
+assert_checkequal(nb , nb_ref);
+assert_checkequal(loc, loc_ref);
+[nb, loc2] = members(A, S, %f);
+assert_checkequal(nb  , nb_ref);
+assert_checkequal(loc2, loc2_ref);
+assert_checktrue(loc >= loc2);
+A_for_later = A;
+S_for_later = S;
+loc_ref_for_later = loc_ref;
+loc2_ref_for_later = loc2_ref;
+nb_ref_for_later = nb_ref;
+A = A';
+S = S';
+loc_ref  = [ 15 17 14 17 14 18 ;
+             17 15 17 14 17  0 ;
+             13 16 13 14  2 13 ;
+             12 13 18 14 13 11 ;
+             13 11 13 14  0 16 ];
+loc2_ref = [ 15  5  6  5  6  7 ;
+              5 15  5  6  5  0 ;
+              3  9  3  6  2  3 ;
+              1  3  7  6  3 11 ;
+              3 11  3  6  0  9 ];
+nb_ref   = [1 2 4 2 4 2 ;
+            2 1 2 4 2 0 ;
+            3 2 3 4 1 3 ;
+            2 3 2 4 3 1 ;
+            3 1 3 4 0 2 ];
+[nb, loc] = members(A, S, %t);
+assert_checkequal(nb , nb_ref);
+assert_checkequal(loc, loc_ref);
+[nb, loc2] = members(A, S, %f);
+assert_checkequal(nb  , nb_ref);
+assert_checkequal(loc2, loc2_ref);
+assert_checktrue(loc >= loc2);
+// Matrices of Integers
+A = uint32(A);
+S = uint32(S);
+[nb, loc] = members(A, S, %t);
+assert_checkequal(nb , nb_ref);
+assert_checkequal(loc, loc_ref);
+[nb, loc2] = members(A, S, %f);
+assert_checkequal(nb  , nb_ref);
+assert_checkequal(loc2, loc2_ref);
+assert_checktrue(loc >= loc2);
+// Matrices of Strings
+A = string(A_for_later);
+S = string(S_for_later);
+loc_ref  = loc_ref_for_later;
+loc2_ref = loc2_ref_for_later;
+nb_ref   = nb_ref_for_later;
+[nb, loc] = members(A, S, %t);
+assert_checkequal(nb , nb_ref);
+assert_checkequal(loc, loc_ref);
+[nb, loc2] = members(A, S, %f);
+assert_checkequal(nb  , nb_ref);
+assert_checkequal(loc2, loc2_ref);
+assert_checktrue(loc >= loc2);
+// Matrices of Complexes
+A = A_for_later*%i;
+S = S_for_later*%i;
+[nb, loc] = members(A, S, %t);
+assert_checkequal(nb , nb_ref);
+assert_checkequal(loc, loc_ref);
+[nb, loc2] = members(A, S, %f);
+assert_checkequal(nb  , nb_ref);
+assert_checkequal(loc2, loc2_ref);
+assert_checktrue(loc >= loc2);
+// Hypermatrices
+A = A_for_later;
+A(:, :, 2) = A;
+S = S_for_later;
+loc_ref(:, :, 2)  = loc_ref;
+loc2_ref(:, :, 2) = loc2_ref;
+nb_ref(:, :, 2)   = nb_ref;
+[nb, loc] = members(A, S, %t);
+assert_checkequal(nb , nb_ref);
+assert_checkequal(loc, loc_ref);
+[nb, loc2] = members(A, S, %f);
+assert_checkequal(nb  , nb_ref);
+assert_checkequal(loc2, loc2_ref);
+assert_checktrue(loc(:, :, 1) >= loc2(:, :, 1));
+assert_checktrue(loc(:, :, 2) >= loc2(:, :, 2));
+// Hypermatrices of Integers
+A_int = uint32(A);
+S_int = uint32(S);
+[nb, loc] = members(A_int, S_int, %t);
+assert_checkequal(nb , nb_ref);
+assert_checkequal(loc, loc_ref);
+[nb, loc2] = members(A_int, S_int, %f);
+assert_checkequal(nb  , nb_ref);
+assert_checkequal(loc2, loc2_ref);
+assert_checktrue(loc(:, :, 1) >= loc2(:, :, 1));
+assert_checktrue(loc(:, :, 2) >= loc2(:, :, 2));
+// Hypermatrices of Strings
+A_str = string(A);
+S_str = string(S);
+[nb, loc] = members(A_str, S_str, %t);
+assert_checkequal(nb , nb_ref);
+assert_checkequal(loc, loc_ref);
+[nb, loc2] = members(A_str, S_str, %f);
+assert_checkequal(nb  , nb_ref);
+assert_checkequal(loc2, loc2_ref);
+assert_checktrue(loc(:, :, 1) >= loc2(:, :, 1));
+assert_checktrue(loc(:, :, 2) >= loc2(:, :, 2));
+// Hypermatrices of Complexes
+A_img = A.*%i;
+S_img = S*%i;
+[nb, loc] = members(A_img, S_img, %t);
+assert_checkequal(nb , nb_ref);
+assert_checkequal(loc, loc_ref);
+[nb, loc2] = members(A_img, S_img, %f);
+assert_checkequal(nb  , nb_ref);
+assert_checkequal(loc2, loc2_ref);
+assert_checktrue(loc(:, :, 1) >= loc2(:, :, 1));
+assert_checktrue(loc(:, :, 2) >= loc2(:, :, 2));
+// Polynomials
+z = %z;
+A = [z (1-z)^2 ; -4 %i*z ];
+S = [2  %i*z -z  3-z  z  z^3 z];
+loc_ref  = [7 0 ; 0 2];
+loc2_ref = [5 0 ; 0 2];
+nb_ref   = [2 0 ; 0 1];
+[nb, loc] = members(A, S, %t);
+assert_checkequal(nb, nb_ref);
+assert_checkequal(loc, loc_ref);
+[nb, loc2] = members(A, S, %f);
+assert_checkequal(nb, nb_ref);
+assert_checkequal(loc2, loc2_ref);
+assert_checktrue(loc >= loc2);
+// IEEE
+A = [ 0 0 1 1 1 ;
+      0 2 2 2 %nan ;
+      2 0 1 1 1 ;
+      0 0 1 %inf -%inf];
+S = [1 0 1 ;
+     2 0 4 ;
+     1 2 5 ;
+  %inf -%inf 6];
+loc_ref  = [6 6 9 9 9 ;
+            6 7 7 7 0 ;
+            7 6 9 9 9 ;
+            6 6 9 4 8 ];
+loc2_ref = [5 5 1 1 1 ;
+            5 2 2 2 0 ;
+            2 5 1 1 1 ;
+            5 5 1 4 8 ];
+nb_ref   = [2 2 3 3 3 ;
+            2 2 2 2 0 ;
+            2 2 3 3 3 ;
+            2 2 3 1 1 ];
+[nb, loc] = members(A, S, %t);
+assert_checkequal(nb , nb_ref);
+assert_checkequal(loc, loc_ref);
+[nb, loc2] = members(A, S, %f);
+assert_checkequal(nb  , nb_ref);
+assert_checkequal(loc2, loc2_ref);
+assert_checktrue(loc >= loc2);
+// =============================================================================
+// Error checks
+A = [1 2 3; 4 5 6];
+refMsg = msprintf(_("%s: Wrong number of input argument(s): at least %d expected.\n"), "members", 2);
+assert_checkerror("[nb, loc] = members(A);", refMsg);
+S = string(A);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: expected same type as first argument.\n"), "members", 2);
+assert_checkerror("[nb, loc] = members(A, S, %t);", refMsg);
+S = int16(A);
+assert_checkerror("[nb, loc] = members(A, S, %t);", refMsg);
+S = uint8(A);
+assert_checkerror("[nb, loc] = members(A, S, %f);", refMsg);
+S = [7 8 9; 10 %nan 12];
+refMsg = msprintf(_("%s: Wrong value for argument #%d: Must not contain NaN.\n"), "members", 2);
+assert_checkerror("[nb, loc] = members(A, S);", refMsg);
+S = [7 8 9; 10 11 12];
+last = 1;
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: Boolean matrix expected.\n"), "members", 3);
+assert_checkerror("[nb, loc] = members(A, S, last);", refMsg);
+last = "yes";
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: Boolean matrix expected.\n"), "members", 3);
+assert_checkerror("[nb, loc] = members(A, S, last);", refMsg);
+last = [%t %f];
+refMsg = msprintf(_("%s: Wrong size for input argument #%d: Scalar expected.\n"), "members", 3);
+assert_checkerror("[nb, loc] = members(A, S, last);", refMsg);
diff --git a/scilab/modules/elementary_functions/tests/unit_tests/members.tst b/scilab/modules/elementary_functions/tests/unit_tests/members.tst
new file mode 100644 (file)
index 0000000..f36d4e1
--- /dev/null
@@ -0,0 +1,366 @@
+// =============================================================================
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2013 - Scilab Enterprises - Paul Bignier
+//
+//  This file is distributed under the same license as the Scilab package.
+// =============================================================================
+
+// <-- CLI SHELL MODE -->
+// <-- ENGLISH IMPOSED -->
+
+
+// Vectors
+[nb, loc] = members([], [], %t);
+assert_checkequal(nb , []);
+assert_checkequal(loc, []);
+[nb, loc] = members([], [], %f);
+assert_checkequal(nb , []);
+assert_checkequal(loc, []);
+
+[nb, loc] = members([1 2], [3 4], %t);
+assert_checkequal(nb , [0 0]);
+assert_checkequal(loc, [0 0]);
+[nb, loc] = members([1 2], [3 4], %f);
+assert_checkequal(nb , [0 0]);
+assert_checkequal(loc, [0 0]);
+
+[nb, loc] = members([1 2; 3 4], [5 6; 7 8], %t);
+assert_checkequal(nb , [0 0; 0 0]);
+assert_checkequal(loc, [0 0; 0 0]);
+[nb, loc] = members([1 2; 3 4], [5 6; 7 8], %f);
+assert_checkequal(nb , [0 0; 0 0]);
+assert_checkequal(loc, [0 0; 0 0]);
+
+[nb, loc] = members(string([1 2; 3 4]), string([5 6; 7 8]), %t);
+assert_checkequal(nb , [0 0; 0 0]);
+assert_checkequal(loc, [0 0; 0 0]);
+[nb, loc] = members(string([1 2; 3 4]), string([5 6; 7 8]), %f);
+assert_checkequal(nb , [0 0; 0 0]);
+assert_checkequal(loc, [0 0; 0 0]);
+
+A = [1 8 4 5 2 1];
+S = [9 7 4 2 1 4];
+
+[nb, loc] = members(A, S, %t);
+assert_checkequal(nb , [1 0 2 0 1 1]);
+assert_checkequal(loc, [5 0 6 0 4 5]);
+[nb, loc] = members(A, S, %f);
+assert_checkequal(nb , [1 0 2 0 1 1]);
+assert_checkequal(loc, [5 0 3 0 4 5]);
+
+
+// Strings
+A = 'a'+string(A);
+S = 's'+string(S);
+
+[nb, loc] = members(A, S, %t);
+assert_checkequal(nb , [0 0 0 0 0 0]);
+assert_checkequal(loc, [0 0 0 0 0 0]);
+[nb, loc] = members(A, S, %f);
+assert_checkequal(nb , [0 0 0 0 0 0]);
+assert_checkequal(loc, [0 0 0 0 0 0]);
+
+A = ["elt1" "elt3" "elt4"];
+S = ["elt5" "elt1" "elt3"];
+
+[nb, loc] = members(A, S, %t);
+assert_checkequal(nb , [1 1 0]);
+assert_checkequal(loc, [2 3 0]);
+[nb, loc] = members(A, S, %f);
+assert_checkequal(nb , [1 1 0]);
+assert_checkequal(loc, [2 3 0]);
+
+A = ["elt1" "elt3" "elt4"];
+S = ["elt5" "elt6" "elt2" "elt1" "elt3"];
+
+[nb, loc] = members(A, S, %t);
+assert_checkequal(nb , [1 1 0]);
+assert_checkequal(loc, [4 5 0]);
+[nb, loc] = members(A, S, %f);
+assert_checkequal(nb , [1 1 0]);
+assert_checkequal(loc, [4 5 0]);
+
+
+// Integers
+A = int16([1 8 4 5 2 1]);
+S = int16([9 7 4 2 1 4]);
+
+[nb, loc] = members(A, S, %t);
+assert_checkequal(nb , [1 0 2 0 1 1]);
+assert_checkequal(loc, [5 0 6 0 4 5]);
+[nb, loc] = members(A, S, %f);
+assert_checkequal(nb , [1 0 2 0 1 1]);
+assert_checkequal(loc, [5 0 3 0 4 5]);
+
+A = uint8([1 8 4 5 2 1]);
+S = uint8([9 7 4 2 1 4]);
+
+[nb, loc] = members(A, S, %t);
+assert_checkequal(nb , [1 0 2 0 1 1]);
+assert_checkequal(loc, [5 0 6 0 4 5]);
+[nb, loc] = members(A, S, %f);
+assert_checkequal(nb , [1 0 2 0 1 1]);
+assert_checkequal(loc, [5 0 3 0 4 5]);
+
+
+// Complexes
+A = [1 8 4 5 2 1]*%i;
+S = [9 7 4 2 1 4]*%i;
+
+[nb, loc] = members(A, S, %t);
+assert_checkequal(nb , [1 0 2 0 1 1]);
+assert_checkequal(loc, [5 0 6 0 4 5]);
+[nb, loc] = members(A, S, %f);
+assert_checkequal(nb , [1 0 2 0 1 1]);
+assert_checkequal(loc, [5 0 3 0 4 5]);
+
+
+// Matrices
+A = [ 5 0 1 4 1 ;
+      0 5 3 1 9 ;
+      2 0 1 6 1 ;
+      0 2 2 2 2 ;
+      2 0 8 1 7 ;
+      6 7 1 9 3 ];
+S = [4 8 1 ;
+     1 0 2 ;
+     6 2 3 ;
+     2 9 4 ;
+     1 2 5 ;
+     3 0 6 ];
+loc_ref  = [ 17 12 13 16 13 ;
+             12 17 15 13 10 ;
+             14 12 13 18 13 ;
+             12 14 14 14 14 ;
+             14 12  7 13  0 ;
+             18  0 13 10 15 ];
+loc2_ref = [ 17  8  2  1  2 ;
+              8 17  6  2 10 ;
+              4  8  2  3  2 ;
+              8  4  4  4  4 ;
+              4  8  7  2  0 ;
+              3  0  2  10 6 ];
+nb_ref   = [ 1 2 3 2 3 ;
+             2 1 2 3 1 ;
+             4 2 3 2 3 ;
+             2 4 4 4 4 ;
+             4 2 1 3 0 ;
+             2 0 3 1 2 ];
+
+[nb, loc] = members(A, S, %t);
+assert_checkequal(nb , nb_ref);
+assert_checkequal(loc, loc_ref);
+[nb, loc2] = members(A, S, %f);
+assert_checkequal(nb  , nb_ref);
+assert_checkequal(loc2, loc2_ref);
+assert_checktrue(loc >= loc2);
+A_for_later = A;
+S_for_later = S;
+loc_ref_for_later = loc_ref;
+loc2_ref_for_later = loc2_ref;
+nb_ref_for_later = nb_ref;
+
+A = A';
+S = S';
+loc_ref  = [ 15 17 14 17 14 18 ;
+             17 15 17 14 17  0 ;
+             13 16 13 14  2 13 ;
+             12 13 18 14 13 11 ;
+             13 11 13 14  0 16 ];
+loc2_ref = [ 15  5  6  5  6  7 ;
+              5 15  5  6  5  0 ;
+              3  9  3  6  2  3 ;
+              1  3  7  6  3 11 ;
+              3 11  3  6  0  9 ];
+nb_ref   = [1 2 4 2 4 2 ;
+            2 1 2 4 2 0 ;
+            3 2 3 4 1 3 ;
+            2 3 2 4 3 1 ;
+            3 1 3 4 0 2 ];
+
+[nb, loc] = members(A, S, %t);
+assert_checkequal(nb , nb_ref);
+assert_checkequal(loc, loc_ref);
+[nb, loc2] = members(A, S, %f);
+assert_checkequal(nb  , nb_ref);
+assert_checkequal(loc2, loc2_ref);
+assert_checktrue(loc >= loc2);
+
+
+// Matrices of Integers
+A = uint32(A);
+S = uint32(S);
+
+[nb, loc] = members(A, S, %t);
+assert_checkequal(nb , nb_ref);
+assert_checkequal(loc, loc_ref);
+[nb, loc2] = members(A, S, %f);
+assert_checkequal(nb  , nb_ref);
+assert_checkequal(loc2, loc2_ref);
+assert_checktrue(loc >= loc2);
+
+
+// Matrices of Strings
+A = string(A_for_later);
+S = string(S_for_later);
+loc_ref  = loc_ref_for_later;
+loc2_ref = loc2_ref_for_later;
+nb_ref   = nb_ref_for_later;
+
+[nb, loc] = members(A, S, %t);
+assert_checkequal(nb , nb_ref);
+assert_checkequal(loc, loc_ref);
+[nb, loc2] = members(A, S, %f);
+assert_checkequal(nb  , nb_ref);
+assert_checkequal(loc2, loc2_ref);
+assert_checktrue(loc >= loc2);
+
+
+// Matrices of Complexes
+A = A_for_later*%i;
+S = S_for_later*%i;
+
+[nb, loc] = members(A, S, %t);
+assert_checkequal(nb , nb_ref);
+assert_checkequal(loc, loc_ref);
+[nb, loc2] = members(A, S, %f);
+assert_checkequal(nb  , nb_ref);
+assert_checkequal(loc2, loc2_ref);
+assert_checktrue(loc >= loc2);
+
+
+// Hypermatrices
+A = A_for_later;
+A(:, :, 2) = A;
+S = S_for_later;
+loc_ref(:, :, 2)  = loc_ref;
+loc2_ref(:, :, 2) = loc2_ref;
+nb_ref(:, :, 2)   = nb_ref;
+
+[nb, loc] = members(A, S, %t);
+assert_checkequal(nb , nb_ref);
+assert_checkequal(loc, loc_ref);
+[nb, loc2] = members(A, S, %f);
+assert_checkequal(nb  , nb_ref);
+assert_checkequal(loc2, loc2_ref);
+assert_checktrue(loc(:, :, 1) >= loc2(:, :, 1));
+assert_checktrue(loc(:, :, 2) >= loc2(:, :, 2));
+
+
+// Hypermatrices of Integers
+A_int = uint32(A);
+S_int = uint32(S);
+
+[nb, loc] = members(A_int, S_int, %t);
+assert_checkequal(nb , nb_ref);
+assert_checkequal(loc, loc_ref);
+[nb, loc2] = members(A_int, S_int, %f);
+assert_checkequal(nb  , nb_ref);
+assert_checkequal(loc2, loc2_ref);
+assert_checktrue(loc(:, :, 1) >= loc2(:, :, 1));
+assert_checktrue(loc(:, :, 2) >= loc2(:, :, 2));
+
+
+// Hypermatrices of Strings
+A_str = string(A);
+S_str = string(S);
+
+[nb, loc] = members(A_str, S_str, %t);
+assert_checkequal(nb , nb_ref);
+assert_checkequal(loc, loc_ref);
+[nb, loc2] = members(A_str, S_str, %f);
+assert_checkequal(nb  , nb_ref);
+assert_checkequal(loc2, loc2_ref);
+assert_checktrue(loc(:, :, 1) >= loc2(:, :, 1));
+assert_checktrue(loc(:, :, 2) >= loc2(:, :, 2));
+
+
+// Hypermatrices of Complexes
+A_img = A.*%i;
+S_img = S*%i;
+
+[nb, loc] = members(A_img, S_img, %t);
+assert_checkequal(nb , nb_ref);
+assert_checkequal(loc, loc_ref);
+[nb, loc2] = members(A_img, S_img, %f);
+assert_checkequal(nb  , nb_ref);
+assert_checkequal(loc2, loc2_ref);
+assert_checktrue(loc(:, :, 1) >= loc2(:, :, 1));
+assert_checktrue(loc(:, :, 2) >= loc2(:, :, 2));
+
+
+// Polynomials
+z = %z;
+A = [z (1-z)^2 ; -4 %i*z ];
+S = [2  %i*z -z  3-z  z  z^3 z];
+loc_ref  = [7 0 ; 0 2];
+loc2_ref = [5 0 ; 0 2];
+nb_ref   = [2 0 ; 0 1];
+
+[nb, loc] = members(A, S, %t);
+assert_checkequal(nb, nb_ref);
+assert_checkequal(loc, loc_ref);
+[nb, loc2] = members(A, S, %f);
+assert_checkequal(nb, nb_ref);
+assert_checkequal(loc2, loc2_ref);
+assert_checktrue(loc >= loc2);
+
+
+// IEEE
+A = [ 0 0 1 1 1 ;
+      0 2 2 2 %nan ;
+      2 0 1 1 1 ;
+      0 0 1 %inf -%inf];
+S = [1 0 1 ;
+     2 0 4 ;
+     1 2 5 ;
+  %inf -%inf 6];
+loc_ref  = [6 6 9 9 9 ;
+            6 7 7 7 0 ;
+            7 6 9 9 9 ;
+            6 6 9 4 8 ];
+loc2_ref = [5 5 1 1 1 ;
+            5 2 2 2 0 ;
+            2 5 1 1 1 ;
+            5 5 1 4 8 ];
+nb_ref   = [2 2 3 3 3 ;
+            2 2 2 2 0 ;
+            2 2 3 3 3 ;
+            2 2 3 1 1 ];
+
+[nb, loc] = members(A, S, %t);
+assert_checkequal(nb , nb_ref);
+assert_checkequal(loc, loc_ref);
+[nb, loc2] = members(A, S, %f);
+assert_checkequal(nb  , nb_ref);
+assert_checkequal(loc2, loc2_ref);
+assert_checktrue(loc >= loc2);
+
+
+// =============================================================================
+
+
+// Error checks
+A = [1 2 3; 4 5 6];
+refMsg = msprintf(_("%s: Wrong number of input argument(s): at least %d expected.\n"), "members", 2);
+assert_checkerror("[nb, loc] = members(A);", refMsg);
+S = string(A);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: expected same type as first argument.\n"), "members", 2);
+assert_checkerror("[nb, loc] = members(A, S, %t);", refMsg);
+S = int16(A);
+assert_checkerror("[nb, loc] = members(A, S, %t);", refMsg);
+S = uint8(A);
+assert_checkerror("[nb, loc] = members(A, S, %f);", refMsg);
+S = [7 8 9; 10 %nan 12];
+refMsg = msprintf(_("%s: Wrong value for argument #%d: Must not contain NaN.\n"), "members", 2);
+assert_checkerror("[nb, loc] = members(A, S);", refMsg);
+S = [7 8 9; 10 11 12];
+last = 1;
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: Boolean matrix expected.\n"), "members", 3);
+assert_checkerror("[nb, loc] = members(A, S, last);", refMsg);
+last = "yes";
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: Boolean matrix expected.\n"), "members", 3);
+assert_checkerror("[nb, loc] = members(A, S, last);", refMsg);
+last = [%t %f];
+refMsg = msprintf(_("%s: Wrong size for input argument #%d: Scalar expected.\n"), "members", 3);
+assert_checkerror("[nb, loc] = members(A, S, last);", refMsg);
diff --git a/scilab/modules/m2sci/help/en_US/m2sci_equivalents/i/ismember.xml b/scilab/modules/m2sci/help/en_US/m2sci_equivalents/i/ismember.xml
new file mode 100644 (file)
index 0000000..a9eac8d
--- /dev/null
@@ -0,0 +1,49 @@
+<?xml version="1.0" encoding="ISO-8859-1"?>
+<!--
+ * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+ * Copyright (C) 2009 - Université du Maine - Samuel Gougeon
+ *
+ * This file must be used under the terms of the CeCILL.
+ * This source file is licensed as described in the file COPYING, which
+ * you should have received as part of this distribution.  The terms
+ * are also available at
+ * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
+ *
+ -->
+<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:id="m2sci_ismember">
+    <refnamediv>
+        <refname>ismember (Matlab function)</refname>
+        <refpurpose>Data sets membership comparison</refpurpose>
+    </refnamediv>
+    <refsection>
+        <title>Matlab/Scilab equivalent</title>
+        <informaltable border="1" width="100%">
+            <tr>
+                <td align="center">
+                    <emphasis role="bold">Matlab</emphasis>
+                </td>
+                <td align="center">
+                    <emphasis role="bold">Scilab</emphasis>
+                </td>
+            </tr>
+            <tr>
+                <td>
+                    <programlisting role="example"><![CDATA[
+[., loc] = ismember(A, B)
+]]></programlisting>
+                </td>
+                <td>
+                    <programlisting role="example"><![CDATA[
+[., loc] = members(A, B, %f)
+]]></programlisting>
+                </td>
+            </tr>
+        </informaltable>
+    </refsection>
+    <refsection>
+        <title>Description</title>
+        <para>
+            The second output argument returned by <emphasis role="bold">members(A, B, %f)</emphasis> in Scilab is equivalent to the second output argument of <emphasis role="bold">ismember(A, B)</emphasis> in Matlab.
+        </para>
+    </refsection>
+</refentry>
index 2190a6a..9946853 100644 (file)
@@ -594,7 +594,6 @@ function allnames=not_yet_converted()
     "ishghandle";
     "isjava";
     "iskeyword";
-    "ismember";
     "ismethod";
     "isobject";
     "isocaps";