* Bug #6305 fixed - dsearch function did not work with integers, strings and hypermat... 72/12472/3
Charlotte HECQUET [Mon, 9 Sep 2013 15:12:16 +0000 (17:12 +0200)]
Change-Id: I6a273d4ba5a73921cebdb9271d5888fb3cca6ce5

15 files changed:
scilab/CHANGES_5.5.X
scilab/modules/elementary_functions/help/en_US/searchandsort/dsearch.xml
scilab/modules/elementary_functions/help/fr_FR/searchandsort/dsearch.xml [new file with mode: 0644]
scilab/modules/elementary_functions/sci_gateway/fortran/sci_f_dsearch.f
scilab/modules/elementary_functions/tests/nonreg_tests/bug_12783.dia.ref
scilab/modules/elementary_functions/tests/nonreg_tests/bug_12783.tst
scilab/modules/helptools/etc/images_md5.txt
scilab/modules/helptools/images/dsearch_1.png
scilab/modules/helptools/images/dsearch_2.png
scilab/modules/helptools/images/dsearch_3.png
scilab/modules/overloading/macros/%c_dsearch.sci [new file with mode: 0644]
scilab/modules/overloading/macros/%hm_dsearch.sci [new file with mode: 0644]
scilab/modules/overloading/macros/%i_dsearch.sci [new file with mode: 0644]
scilab/modules/overloading/tests/nonreg_tests/bug_6305.dia.ref [new file with mode: 0644]
scilab/modules/overloading/tests/nonreg_tests/bug_6305.tst [new file with mode: 0644]

index e6a1937..cb8e885 100644 (file)
@@ -50,6 +50,8 @@ Scilab Bug Fixes
 
 * Bug #5886 fixed - There was no property labels_font_style on axis.
 
+* Bug #6305 fixed - dsearch function did not work with integers, strings and hypermatrices.
+
 * Bug #6306 fixed - It is now possible to compute an histogram instead of plotting it
                     with new function histc(). Besides, histplot can now return the computed data.
 
index 59918cc..c1f2117 100644 (file)
@@ -3,6 +3,7 @@
  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
  * Copyright (C) Bruno Pincon
  * Copyright (C) 2011 - DIGITEO - Michael Baudin
+ * Copyright (C) 2013 - 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
     <refnamediv>
         <refname>dsearch</refname>
         <refpurpose>
-            search in ordered sets
+            distribute, locate and count elements of a matrix or hypermatrix in given categories
         </refpurpose>
     </refnamediv>
     <refsynopsisdiv>
         <title>Calling Sequence</title>
         <synopsis>
-            [ind [,occ [,info]]] = dsearch(X, s )
-            [ind [,occ [,info]]] = dsearch(X, s , ch )
+            [i_bin [,counts [,outside]]] = dsearch(X, bins )
+            [i_bin [,counts [,outside]]] = dsearch(X, bins , pm )
         </synopsis>
     </refsynopsisdiv>
     <refsection>
                 <term>X</term>
                 <listitem>
                     <para>
-                        a mx-by-nx matrix of doubles, the entries to locate.
+                        matrix or hypermatrix of reals, encoded integers, or texts: The entries to categorize. 
+                                               Complex numbers and polynomials are not supported.
                     </para>
                 </listitem>
             </varlistentry>
             <varlistentry>
-                <term>s</term>
+                <term>bins</term>
                 <listitem>
                     <para>
-                        a n-by-1 or 1-by-n matrix of doubles, the 
-                        intervals (if ch="c") or the set (if ch="d"). 
-                        The values in s must be in strictly increasing order:
-                        s(1) &lt; s(2) &lt; ... &lt; s(n)
-                    </para>
+                        row or column vector defining categories, of same type as <varname>X</varname> (for encoded integers in <varname>X</varname>, <varname>bins</varname> may be decimals).
+                                               <itemizedlist>
+                                                       <listitem>
+                                                               Discrete case (pm="d"): <varname>bins</varname> are distinct values to which <varname>X</varname> entries must be identified. If <varname>X</varname> is numeric (reals or encoded integers), <varname>bins</varname> must be sorted in strictly increasing order.
+                                                       </listitem>
+                                                       <listitem>
+                                                               Continuous case (default, pm="c"): <varname>bins</varname> are bounds of contiguous intervals: <literal>I1 = [bins(1), bins(2)]</literal>, <literal>I2 = (bins(2), bins(3)]</literal>,..., <literal>In = (bins(n), bins(n+1)]</literal>. Note that entries from <varname>X</varname> just equal to bins(1) are included in <literal>I1</literal>.
+                                                               The values in <varname>bins</varname> must be in strictly increasing order: bins(1) &lt; bins(2) &lt; ... &lt; bins(n). 
+                                                               For text processing, the case-sensitive lexicographic order is considered.
+                                                       </listitem>
+                                               </itemizedlist>
+                                       </para>
                 </listitem>
             </varlistentry>
             <varlistentry>
-                <term>ch</term>
+                <term>pm</term>
                 <listitem>
                     <para>
-                        a 1-by-1 matrix of strings, the type of search (default ch="c").
-                        Available values are ch="c" or ch="d".
+                        "c" (continuous, default) or "d" (discrete): processing mode. In continuous mode, <varname>bins</varname> defines the bounds of contiguous intervals considered as categories. In discrete mode, <varname>bins</varname> provides the values to which entries from <varname>X</varname> must be identified.
                     </para>
                 </listitem>
             </varlistentry>
             <varlistentry>
-                <term>ind</term>
+                <term>i_bin</term>
                 <listitem>
                     <para>
-                        a mx-by-nx matrix of doubles. 
-                        The location of the X values in the intervals or the set defined by <literal>s</literal>.
+                        matrix or hypermatrix with same sizes than <varname>X</varname>: <literal>i_bin(k)</literal> is the index of the category to which <varname>X(k)</varname> belongs. If <varname>X(k)</varname> belongs to none of the categories, <literal>i_bin(k) = 0</literal>
                     </para>
                 </listitem>
             </varlistentry>
             <varlistentry>
-                <term>occ</term>
-                <listitem>
-                    <para>
-                        If ch="c", a (n-1)-by-1 or 1-by-(n-1) of doubles. 
-                        If ch="d", a n-by-1 or 1-by-n of doubles. The number of entries 
-                        from X in the intervals s.
+                <term>counts</term>
+                <listitem>number of X entries in respective bins.
+                    <para>Continuous case (pm="c"): counts(i) elements of <varname>X</varname> belong to the interval <literal>Ik</literal> as defined above (see the <varname>bins</varname> parameter). Elements of <varname>X</varname> just equal to bins(1) are included in counts(1). <varname>counts</varname> has the size of <varname>bins</varname> - 1
+                                       </para>
+                                       <para>Discrete case (pm="d"): <literal>counts(i)</literal> elements of <varname>X</varname> are equal to <literal>bins(i)</literal>
                     </para>
                 </listitem>
             </varlistentry>
             <varlistentry>
-                <term>info</term>
+                <term>outside</term>
                 <listitem>
                     <para>
-                        a 1-by-1 matrix of doubles. The number of X entries which are not in <literal>s</literal>.
+                        Total number of X entries belonging to none of the <literal>bins</literal>.
                     </para>
                 </listitem>
             </varlistentry>
     <refsection>
         <title>Description</title>
         <para>
-            This function locates the indices of the entries in X in the intervals or the set defined by s.
-        </para>
-        <para>
-            If <literal>ch="c"</literal> (default), we consider the
-            intervals <literal>I1 = [s(1), s(2)]</literal> 
-            and <literal>Ik = (s(k), s(k+1)]</literal> for <literal>k=2,...,n-1</literal>. 
-            Notice that the bounds of <literal>I1</literal> are closed, 
-            while the left bounds of <literal>I2</literal>, ..., <literal>In</literal> are 
-            opened.
-            For each entry <literal>X(i)</literal>, 
-            we search the interval <literal>Ik</literal> which contains X(i), i.e. we search k such 
-            that <literal>s(k)&lt;X(i)&lt;=s(k+1)</literal>.
-        </para>
-        <para>
-            More precisely,
-        </para>
-        <variablelist>
-            <varlistentry>
-                <term>ind(i)</term>
-                <listitem>
-                    <para>
-                        is k such that <literal>Ik</literal> contains X(i) or 
-                        0 if X(i) is not in any interval <literal>Ik</literal>.
-                    </para>
-                </listitem>
-            </varlistentry>
-            <varlistentry>
-                <term>occ(k)</term>
-                <listitem>
-                    <para>
-                        is the number of components of <literal>X</literal> which are in <literal>Ik</literal>
-                    </para>
-                </listitem>
-            </varlistentry>
-            <varlistentry>
-                <term>info</term>
-                <listitem>
-                    <para>
-                        is the number of components of <literal>X</literal> which are not in
-                        any interval <literal>Ik</literal>.
-                    </para>
-                </listitem>
-            </varlistentry>
-        </variablelist>
-        <para>
-            If <literal>ch="d"</literal>, we consider the set {s(1),s(2),...,s(n)}.
-            For each X(i), search k such that X(i)=s(k).
-        </para>
-        <para>
-            More precisely, 
-        </para>
-        <variablelist>
-            <varlistentry>
-                <term>ind(i)</term>
-                <listitem>
-                    <para>
-                        is k if X(i)=s(k) or 0 if X(i) is not in s.
-                    </para>
-                </listitem>
-            </varlistentry>
-            <varlistentry>
-                <term>occ(k)</term>
-                <listitem>
-                    <para>
-                        is the number of entries in X equal to s(k)
-                    </para>
-                </listitem>
-            </varlistentry>
-            <varlistentry>
-                <term>info</term>
-                <listitem>
-                    <para>
-                        is the number of entries in X which are not in the set
-                        {s(1),...,s(n)}.
-                    </para>
-                </listitem>
-            </varlistentry>
-        </variablelist>
+            For each <varname>X(i)</varname> entry, <varname>dsearch</varname> locates the value <literal>bins(j)</literal> or the interval <literal>(bins(j), bins(j+1)]</literal> defined  by <varname>bins</varname> and containing or equal to <varname>X(i)</varname>. Then it returns <literal>i_bin(i) = j</literal> or 0 whether no bin equals or contains it. (the first interval includes <literal>bins(1)</literal>). The population of each bin is returned through <varname>counts</varname>. The total number of unbinned entries is returned in <varname>outside</varname> (therefore <literal>outside = sum(bool2s(i_bin==0))</literal>).
+               </para>
         <para>
-            The ch="c" option can be used to compute the empirical histogram of a function given a dataset.
-            The ch="d" option can be used to compute the entries in X which are present in the set s.
+                       <literal>dsearch(..)</literal> can be overloaded.                       
+            The default pm="c" option can be used to compute the empirical histogram of a function given a dataset.
         </para>
     </refsection>
+       
     <refsection>
         <title>Examples</title>
+        <programlisting role="example"><![CDATA[               
+// DISCRETE values of TEXT
+// -----------------------
+i = grand(4,6,"uin",0,7)+97;
+T = matrix(strsplit(ascii(i),1:length(i)-1), size(i));
+T(T=="f") = "#";
+T(T=="a") = "AA";
+T
+bins = [ strsplit(ascii(97+(7:-1:0)),1:7)' "AA"]
+[i_bin, counts, outside] = dsearch(T, bins, "d")
+
+// BINNING TEXTS in LEXICOGRAPHIC INTERVALS
+// ----------------------------------------
+// generating a random matrix of text
+nL = 3; nC = 5; L  = 3;
+s = ascii(grand(1,nL*nC*L,"uin",0,25)+97);
+T = matrix(strsplit(s, L:L:nL*nC*L-1), nL, nC);
+// generating random bins bounds
+L  = 2; nC = 6;
+s = ascii(grand(1,nC*L,"uin",0,25)+97);
+bins = unique(matrix(strsplit(s, L:L:nC*L-1), 1, nC))
+T
+[i_bin, counts, outside] = dsearch(T, bins)
+    ]]></programlisting>
+       
         <para>
-            In the following example, we consider 3 intervals <literal>I1=[5,11]</literal>, 
-            <literal>I2=(11,15]</literal> and <literal>I3=(15,20]</literal>.
-            We are looking for the location of the entries of <literal>X=[11 13 1 7 5 2 9]</literal> 
+            In the following example, we consider 3 intervals <literal>I1 = [5,11]</literal>, 
+            <literal>I2 = (11,15]</literal> and <literal>I3 = (15,20]</literal>.
+            We are looking for the location of the entries of <literal>X = [11 13 1 7 5 2 9]</literal> 
             in these intervals.
         </para>
         <programlisting role="example"><![CDATA[ 
-[ind, occ, info] = dsearch([11 13 1 7 5 2 9], [5 11 15 20])
+[i_bin, counts, outside] = dsearch([11 13 1 7 5 2 9], [5 11 15 20])
     ]]></programlisting>
         <para>
-            The previous example produces the following output.
+            Displayed output:
         </para>
         <screen><![CDATA[ 
--->[ind, occ, info] = dsearch([11 13 1 7 5 2 9], [5 11 15 20])
- info  =
+-->[i_bin, counts, outside] = dsearch([11 13 1 7 5 2 9], [5 11 15 20])
+ outside  =
     2.
- occ  =
+ counts  =
     4.    1.    0.
- ind  =
+ i_bin  =
     1.    2.    0.    1.    1.    0.    1.
     ]]></screen>
         <para>
-            We now explain these results.
+            Indeed,
         </para>
         <itemizedlist>
             <listitem>
-                <para>X(1)=11 is in the interval I1, hence ind(1)=1.</para>
+                <para>X(1)=11 is in the interval I1, hence i_bin(1)=1.</para>
             </listitem>
             <listitem>
-                <para> X(2)=13 is in the interval I2, hence ind(2)=2.</para>
+                <para> X(2)=13 is in the interval I2, hence i_bin(2)=2.</para>
             </listitem>
             <listitem>
-                <para> X(3)=1 is not in any interval, hence ind(3)=0.</para>
+                <para> X(3)=1 belongs to none of defined intervals, hence i_bin(3)=0.</para>
             </listitem>
             <listitem>
-                <para> X(4)=7 is in the interval I1, hence ind(4)=1.</para>
+                <para> X(4)=7 is in the interval I1, hence i_bin(4)=1.</para>
             </listitem>
             <listitem>
-                <para> X(5)=5 is in the interval I1, hence ind(5)=1.</para>
+                <para>...</para>
             </listitem>
             <listitem>
-                <para> X(6)=2 is not in any interval, hence ind(6)=0.</para>
+                <para> There are four X entries (5, 7, 9 and 11) in I1, hence counts(1)=4.</para>
             </listitem>
             <listitem>
-                <para> X(7)=9 is in the interval I1, hence ind(7)=1.</para>
+                <para> There is only one X entry (13) in I2, hence counts(2)=1.</para>
             </listitem>
             <listitem>
-                <para> There are four X entries (5, 7, 9 and 11) in I1, hence occ(1)=4.</para>
+                <para> There is no X entry in I3, hence counts(3)=0.</para>
             </listitem>
             <listitem>
-                <para> There is one X entry (i.e. 13) in I2, hence occ(2)=1.</para>
-            </listitem>
-            <listitem>
-                <para> There is no X entry in I3, hence occ(3)=0.</para>
-            </listitem>
-            <listitem>
-                <para> There are two X entries (i.e. 1, 2) which are not in any interval, hence info=2.</para>
+                <para> There are two X entries (i.e. 1, 2) which belong to none of defined intervals, hence outside=2.</para>
             </listitem>
         </itemizedlist>
-        <para>
-            In the following example, we consider the set [5 11 15 20] and 
-            are searching the location of the X entries in this set.
-        </para>
         <programlisting role="example"><![CDATA[ 
-[ind, occ, info] = dsearch([11 13 1 7 5 2 9], [5 11 15 20],"d" )
+// Numbers in DISCRETE categories (having specific values)
+// ------------------------------
+[i_bin, counts, outside] = dsearch([11 13 1 7 5 2 9], [5 11 15 20],"d" )
     ]]></programlisting>
         <para>
-            The previous example produces the following output.
+            displays
         </para>
         <screen><![CDATA[ 
--->[ind, occ, info] = dsearch([11 13 1 7 5 2 9], [5 11 15 20],"d" )
- info  =
+-->[i_bin, counts, outside] = dsearch([11 13 1 7 5 2 9], [5 11 15 20], "d" )
+ outside  =
     5.
- occ  =
+ counts  =
     1.    1.    0.    0.
- ind  =
+ i_bin  =
     2.    0.    0.    0.    1.    0.    0.
     ]]></screen>
         <para>
-            The following is a detailed explanation for the previous results.
+            Indeed,
         </para>
         <itemizedlist>
             <listitem>
                 <para>
-                    X(1)=11 is in the set <literal>s</literal> at position #2, hence ind(1)=2.
+                    X(1)=11 is in the set <literal>bins</literal> at position #2, hence i_bin(1)=2.
                 </para>
             </listitem>
             <listitem>
                 <para>
-                    X(2)=13 is not in the set <literal>s</literal>, hence ind(2)=0.
+                    X(2)=13 is not in the set <literal>bins</literal>, hence i_bin(2)=0.
                 </para>
             </listitem>
             <listitem>
-                <para>
-                    X(3)=1 is not in the set <literal>s</literal>, hence ind(3)=0.
-                </para>
+                <para>...</para>
             </listitem>
             <listitem>
                 <para>
-                    X(4)=7 is not in the set <literal>s</literal>, hence ind(4)=0.
+                    X(7)=9 is not in the set <literal>bins</literal>, hence i_bin(7)=0.
                 </para>
             </listitem>
             <listitem>
                 <para>
-                    X(5)=5 is in the set <literal>s</literal> at position #1, hence ind(5)=1.
+                    There is only one entry X (i.e. 5) equal to 5, hence counts(1)=1.
                 </para>
             </listitem>
             <listitem>
                 <para>
-                    X(6)=2 is not in the set <literal>s</literal>, hence ind(6)=0.
+                    There are no entries matching <literal>bins(4)</literal>, hence counts(4)=0.
                 </para>
             </listitem>
             <listitem>
                 <para>
-                    X(7)=9 is not in the set <literal>s</literal>, hence ind(7)=0.
-                </para>
-            </listitem>
-            <listitem>
-                <para>
-                    There is one entry X (i.e. 5) equal to 5, hence occ(1)=1.
-                </para>
-            </listitem>
-            <listitem>
-                <para>
-                    There is one entry X (i.e. 11) equal to 1, hence occ(2)=1.
-                </para>
-            </listitem>
-            <listitem>
-                <para>
-                    There are no entries matching <literal>s(3)</literal>, hence occ(3)=0.
-                </para>
-            </listitem>
-            <listitem>
-                <para>
-                    There are no entries matching <literal>s(4)</literal>, hence occ(4)=0.
-                </para>
-            </listitem>
-            <listitem>
-                <para>
-                    There are five X entries (i.e. 13, 1, 7, 2, 9) which are not in the set <literal>s</literal>, hence info=5.
+                    There are five X entries (i.e. 13, 1, 7, 2, 9) which are not in the set <literal>bins</literal>, hence outside=5.
                 </para>
             </listitem>
         </itemizedlist>
         <para>
-            The values in <literal>s</literal> must be in increasing order, whatever the 
-            value of the <literal>ch</literal> option. 
-            If this is not true, an error is generated, as in the following session.
+            Numbers in <literal>bins</literal> must be in increasing order, whatever is the processing mode (continuous or discrete).
+            If this is not the case, an error is generated:
         </para>
         <screen><![CDATA[ 
 -->dsearch([11 13 1 7 5 2 9], [2 1])
@@ -335,26 +255,24 @@ dsearch   : the array s (arg 2) is not well ordered
         <para>
             In the following example, we compare the empirical histogram of uniform
             random numbers in [0,1) with the uniform distribution function.
-            To perform this comparison, we use the default search algorithm based on 
-            intervals (ch="c").
-            We generate X as a collection of m=50 000 uniform random numbers in
-            the range [0,1).
+            To perform this comparison, we use the default search algorithm based on intervals (pm="c").
+            We generate X as a collection of m=50 000 uniform random numbers in the range [0,1).
             We consider the n=10 values equally equally spaced values in the [0,1] range and
             consider the associated intervals.
             Then we count the number of entries in X which fall in the intervals:
             this is the empirical histogram of the uniform distribution function.
-            The expectation for occ/m is equal to 1/(n-1).
+            The expectation for counts/m is equal to 1/(n-1).
         </para>
         <programlisting role="example"><![CDATA[
 m = 50000 ;
 n = 10;
 X = grand(m,1,"def");
-s = linspace(0,1,n)';
-[ind, occ] = dsearch(X, s);
+bins = linspace(0,1,n)';
+[i_bin, counts] = dsearch(X, bins);
 e = 1/(n-1)*ones(1,n-1);
 scf() ; 
-plot(s(1:n-1), occ/m,"bo");
-plot(s(1:n-1), e,"r-");
+plot(bins(1:n-1), counts/m,"bo");
+plot(bins(1:n-1), e,"r-");
 legend(["Experiment","Expectation"]);
 xtitle("Uniform random numbers","X","P(X)");
  ]]></programlisting>
@@ -362,12 +280,12 @@ xtitle("Uniform random numbers","X","P(X)");
             m = 50000 ;
             n = 10;
             X = grand(m,1,"def");
-            s = linspace(0,1,n)';
-            [ind, occ] = dsearch(X, s);
+            bins = linspace(0,1,n)';
+            [i_bin, counts] = dsearch(X, bins);
             e = 1/(n-1)*ones(1,n-1);
             scf() ; 
-            plot(s(1:n-1), occ/m,"bo");
-            plot(s(1:n-1), e,"r-");
+            plot(bins(1:n-1), counts/m,"bo");
+            plot(bins(1:n-1), e,"r-");
             legend(["Experiment","Expectation"]);
             xtitle("Uniform random numbers","X","P(X)");
         </scilab:image>
@@ -376,20 +294,20 @@ xtitle("Uniform random numbers","X","P(X)");
             random numbers with the binomial probability distribution function B(N,p),
             with N=8 and p=0.5.
             To perform this comparison, we use the discrete search algorithm based on
-            a set (ch="d").
+            a set (pm="d").
         </para>
         <programlisting role="example"><![CDATA[ 
 N = 8 ; 
 p = 0.5; 
 m = 50000;
 X = grand(m,1,"bin",N,p); 
-s = (0:N)';
-[ind, occ] = dsearch(X, s, "d");
-Pexp = occ/m; 
+bins = (0:N)';
+[i_bin, counts] = dsearch(X, bins, "d");
+Pexp = counts/m; 
 Pexa = binomial(p,N);
 scf() ; 
-plot(s,Pexp,"bo");
-plot(s,Pexa',"r-");
+plot(bins, Pexp, "bo");
+plot(bins, Pexa', "r-");
 xtitle("Binomial distribution B(8,0.5)","X","P(X)");
 legend(["Experiment","Expectation"]);
 ]]></programlisting>
@@ -398,13 +316,13 @@ legend(["Experiment","Expectation"]);
             p = 0.5; 
             m = 50000;
             X = grand(m,1,"bin",N,p); 
-            s = (0:N)';
-            [ind, occ] = dsearch(X, s, "d");
-            Pexp = occ/m; 
+            bins = (0:N)';
+            [i_bin, counts] = dsearch(X, bins, "d");
+            Pexp = counts/m; 
             Pexa = binomial(p,N);
             scf() ; 
-            plot(s,Pexp,"bo");
-            plot(s,Pexa',"r-");
+            plot(bins, Pexp, "bo");
+            plot(bins, Pexa',"r-");
             xtitle("Binomial distribution B(8,0.5)","X","P(X)");
             legend(["Experiment","Expectation"]);
         </scilab:image>
@@ -440,10 +358,10 @@ legend(["Experiment","Expectation"]);
       y = [0 ; 0.1 ;-0.1  ; 0   ; 0.4  ;-0.1 ;  0];
       d = [1 ; 0   ; 0    ; 1   ; 0    ; 0   ; -1];
       X = linspace(0, 1, 200)';
-      ind = dsearch(X, x);
+      i_bin = dsearch(X, x);
 
       // plot the curve
-      Y = y(ind).*Hl(X,ind) + y(ind+1).*Hr(X,ind) + d(ind).*Kl(X,ind) + d(ind+1).*Kr(X,ind);
+      Y = y(i_bin).*Hl(X,i_bin) + y(i_bin+1).*Hr(X,i_bin) + d(i_bin).*Kl(X,i_bin) + d(i_bin+1).*Kr(X,i_bin);
       scf();
       plot(X,Y,"k-");
       plot(x,y,"bo")
@@ -477,9 +395,9 @@ legend(["Experiment","Expectation"]);
             y = [0 ; 0.1 ;-0.1  ; 0   ; 0.4  ;-0.1 ;  0];
             d = [1 ; 0   ; 0    ; 1   ; 0    ; 0   ; -1];
             X = linspace(0, 1, 200)';
-            ind = dsearch(X, x);
+            i_bin = dsearch(X, x);
             
-            Y = y(ind).*Hl(X,ind) + y(ind+1).*Hr(X,ind) + d(ind).*Kl(X,ind) + d(ind+1).*Kr(X,ind);
+            Y = y(i_bin).*Hl(X,i_bin) + y(i_bin+1).*Hr(X,i_bin) + d(i_bin).*Kl(X,i_bin) + d(i_bin+1).*Kr(X,i_bin);
             scf();
             plot(X,Y,"k-");
             plot(x,y,"bo")
@@ -487,6 +405,7 @@ legend(["Experiment","Expectation"]);
             legend(["Polynomial","Data"]);
         </scilab:image>
     </refsection>
+       
     <refsection role="see also">
         <title>See Also</title>
         <simplelist type="inline">
@@ -494,8 +413,21 @@ legend(["Experiment","Expectation"]);
                 <link linkend="find">find</link>
             </member>
             <member>
+                <link linkend="members">members</link>
+            </member>
+            <member>
                 <link linkend="tabul">tabul</link>
             </member>
         </simplelist>
     </refsection>
+       
+    <refsection>
+        <title>History</title>
+        <revhistory>
+            <revision>
+                <revnumber>5.5.0</revnumber>
+                <revremark>Extension to hypermatrices, encoded integers, and text.</revremark>
+            </revision>
+        </revhistory>
+    </refsection>
 </refentry>
diff --git a/scilab/modules/elementary_functions/help/fr_FR/searchandsort/dsearch.xml b/scilab/modules/elementary_functions/help/fr_FR/searchandsort/dsearch.xml
new file mode 100644 (file)
index 0000000..0d2a1f1
--- /dev/null
@@ -0,0 +1,428 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+ * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+ * Copyright (C) Bruno Pincon
+ * Copyright (C) 2011 - DIGITEO - Michael Baudin
+ * Copyright (C) 2013 - 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.1-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="dsearch" xml:lang="fr">
+    <refnamediv>
+        <refname>dsearch</refname>
+        <refpurpose>
+            répartit, localise et compte les éléments d'une matrice en catégories données
+        </refpurpose>
+    </refnamediv>
+    <refsynopsisdiv>
+        <title>Séquence d'appel</title>
+        <synopsis>
+            [i_bin [,counts [,outside]]] = dsearch(X, bins )
+            [i_bin [,counts [,outside]]] = dsearch(X, bins , pm )
+        </synopsis>
+    </refsynopsisdiv>
+    <refsection>
+        <title>Paramètres</title>
+        <variablelist>
+            <varlistentry>
+                <term>X</term>
+                <listitem>
+                    <para>
+                        matrice ou hypermatrice de nombres réels, d'entiers encodés, ou de textes : éléments à catégoriser. 
+                                               Les nombres complexes et les polynômes ne sont pas admis.
+                    </para>
+                </listitem>
+            </varlistentry>
+            <varlistentry>
+                <term>bins</term>
+                <listitem>
+                    <para>
+                        vecteur ligne ou colonne définissant les catégories, de même type que <varname>X</varname> (Si <varname>X</varname> contient des entiers encodés, <varname>bins</varname> peut être de type décimal).
+                                               <itemizedlist>
+                                                       <listitem>
+                                                               Cas discret (pm="d"): <varname>bins</varname> contient les valeurs auxquelles les éléments de <varname>X</varname> doivent être identifiés. Si <varname>X</varname> est numérique (nombres réels ou entiers encodés), <varname>bins</varname> doit être préalablement trié par ordre croissant, et sans doublons.
+                                                       </listitem>
+                                                       <listitem>
+                                                               Cas continu (par défaut, pm="c"): <varname>bins</varname> contient les bornes d'intervalles <literal>Ik</literal> contigus : <literal>I1 = [bins(1), bins(2)]</literal>, <literal>I2 = (bins(2), bins(3)]</literal>,..., <literal>In = (bins(n), bins(n+1)]</literal>. Noter que <literal>I1</literal> est fermé à gauche, alors que les <literal>I(k>1)</literal> sont semi-ouverts à gauche.
+                                                               Les bornes <varname>bins</varname> doivent être préalablement triées en ordre strictement croissant : bins(1) &lt; bins(2) &lt; ... &lt; bins(n). 
+                                                               Pour le traitement du texte, l'ordre lexicographique sensible à la casse est considéré.
+                                                       </listitem>
+                                               </itemizedlist>
+                                       </para>
+                </listitem>
+            </varlistentry>
+            <varlistentry>
+                <term>pm</term>
+                <listitem>
+                    <para>
+                        "c" (continu, par défaut) ou "d" (discrêt): mode de traitement. En mode continu, <varname>bins</varname> spécifie les bornes d'intervalles contigus définissant les catégories à considérer. En mode discrêt, <varname>bins</varname> fournit les valeurs auxquelles les éléments de <varname>X</varname> doivent être individuellement identifiés.
+                    </para>
+                </listitem>
+            </varlistentry>
+            <varlistentry>
+                <term>i_bin</term>
+                <listitem>
+                    <para>
+                        Matrice ou hypermatrice de mêmes tailles que <varname>X</varname>: <literal>i_bin(k)</literal> donne le n° de la catégorie à laquelle <varname>X(k)</varname> appartient. Si <varname>X(k)</varname> n'appartient à aucune catégorie, <literal>i_bin(k) = 0</literal>.
+                    </para>
+                </listitem>
+            </varlistentry>
+            <varlistentry>
+                <term>counts</term>
+                <listitem>Nombre d'éléments de X dans les catégories respectives.
+                    <para>Cas continu(pm="c"): counts(i) éléments de <varname>X</varname> appartiennent à l'intervalle <literal>Ik</literal> tel que défini ci-dessus (voir le paramètre <varname>bins</varname>). Les éléments de <varname>X</varname> juste égaux à bins(1) sont comptés dans counts(1). <varname>counts</varname> est un vecteur de même taille que <varname>bins</varname>, - 1.
+                                       </para>
+                                       <para>Cas discrêt(pm="d"): <literal>counts(i)</literal> indique le nombre d'éléments de <varname>X</varname> égaux à <literal>bins(i)</literal>
+                    </para>
+                </listitem>
+            </varlistentry>
+            <varlistentry>
+                <term>outside</term>
+                <listitem>
+                    <para>
+                        Nombre total d'éléments de X n'appartenant à aucune catégorie <literal>bins</literal>.
+                    </para>
+                </listitem>
+            </varlistentry>
+        </variablelist>
+    </refsection>
+    <refsection>
+        <title>Description</title>
+        <para>
+            Pour chaque élément <varname>X(i)</varname>, la fonction <varname>dsearch</varname> détermine la valeur <literal>bins(j)</literal> ou l'intervalle <literal>(bins(j), bins(j+1)]</literal> égale à ou contenant <varname>X(i)</varname>. Elle retourne <literal>i_bin(i) = j</literal>, ou 0 si aucune valeur ou intervalle ne convient (le premier intervalle inclut <literal>bins(1)</literal> à gauche). L'effectif de chaque de chaque catégorie est retourné dans le vecteur <varname>counts</varname>. Le nombre d'éléments de <varname>X</varname> n'allant dans aucune catégorie est retourné dans <varname>outside</varname> (donc <literal>outside = sum(bool2s(i_bin==0))</literal>).
+               </para>
+        <para>
+                       <literal>dsearch(..)</literal> peut être surchargée.
+            Le mode pm="c" par défaut peut être utilisé pour calculer l'histogramme empirique d'une fonction appliquée à un ensemble de points donnés.
+        </para>
+    </refsection>
+       
+    <refsection>
+        <title>Exemples</title>
+        <programlisting role="example"><![CDATA[               
+// TEXTES en valeurs PARTICULIERES
+// -------------------------------
+i = grand(4,6,"uin",0,7)+97;
+T = matrix(strsplit(ascii(i),1:length(i)-1), size(i));
+T(T=="f") = "#";
+T(T=="a") = "AA";
+T
+bins = [ strsplit(ascii(97+(7:-1:0)),1:7)' "AA"]
+[i_bin, counts, outside] = dsearch(T, bins, "d")
+
+// TEXTES categorisés par INTERVALLES LEXICOGRAPHIQUES
+// ---------------------------------------------------
+// Génération d'une matrice texte aléatoire
+nL = 3; nC = 5; L  = 3;
+s = ascii(grand(1,nL*nC*L,"uin",0,25)+97);
+T = matrix(strsplit(s, L:L:nL*nC*L-1), nL, nC);
+// Génération d'intervalles lexicographiques aléatoires ordonnés
+L  = 2; nC = 6;
+s = ascii(grand(1,nC*L,"uin",0,25)+97);
+bins = unique(matrix(strsplit(s, L:L:nC*L-1), 1, nC))
+T
+[i_bin, counts, outside] = dsearch(T, bins)
+    ]]>
+       </programlisting>
+       
+        <para>
+            Dans l'exemple suivant, considérons 3 intervalles <literal>I1 = [5,11]</literal>, 
+            <literal>I2 = (11,15]</literal> and <literal>I3 = (15,20]</literal>.
+            Nous recherchons les n° des intervalles respectifs auxquels les éléments de <literal>X = [11 13 1 7 5 2 9]</literal> appartiennent.
+        </para>
+        <programlisting role="example"><![CDATA[ 
+[i_bin, counts, outside] = dsearch([11 13 1 7 5 2 9], [5 11 15 20])
+    ]]></programlisting>
+        <para>
+            Résultat affiché :
+        </para>
+        <screen><![CDATA[ 
+-->[i_bin, counts, outside] = dsearch([11 13 1 7 5 2 9], [5 11 15 20])
+ outside  =
+    2.
+ counts  =
+    4.    1.    0.
+ i_bin  =
+    1.    2.    0.    1.    1.    0.    1.
+    ]]></screen>
+        <para>
+            En effet,
+        </para>
+        <itemizedlist>
+            <listitem>
+                <para>X(1)=11 est dans l'intervalle I1, donc i_bin(1)=1.</para>
+            </listitem>
+            <listitem>
+                <para>X(2)=13 est dans l'intervalle I2, donc i_bin(2)=2.</para>
+            </listitem>
+            <listitem>
+                <para>X(3)=1 n'appartient à aucun des intervalles définis, donc i_bin(3)=0.</para>
+            </listitem>
+            <listitem>
+                <para>X(4)=7 est dans l'intervalle I1, donc i_bin(4)=1.</para>
+            </listitem>
+            <listitem>
+                <para>...</para>
+            </listitem>
+            <listitem>
+                <para>4 éléments de X (5, 7, 9 et 11) appartiennent à I1, donc counts(1)=4.</para>
+            </listitem>
+            <listitem>
+                <para>Seul un élément de X (13) est dans I2, donc counts(2)=1.</para>
+            </listitem>
+            <listitem>
+                <para>Aucun élément de X est dans I3, donc counts(3)=0.</para>
+            </listitem>
+            <listitem>
+                <para>Deux éléments de X (i.e. 1, 2) n'appartiennent à aucun intervalle défini, donc outside=2.</para>
+            </listitem>
+        </itemizedlist>
+        <programlisting role="example"><![CDATA[ 
+// Nombres à identifier à des valeurs discrêtes
+// --------------------------------------------
+[i_bin, counts, outside] = dsearch([11 13 1 7 5 2 9], [5 11 15 20],"d" )
+    ]]></programlisting>
+        <para>
+            affiche
+        </para>
+        <screen><![CDATA[ 
+-->[i_bin, counts, outside] = dsearch([11 13 1 7 5 2 9], [5 11 15 20], "d" )
+ outside  =
+    5.
+ counts  =
+    1.    1.    0.    0.
+ i_bin  =
+    2.    0.    0.    0.    1.    0.    0.
+    ]]></screen>
+        <para>
+            En effet,
+        </para>
+        <itemizedlist>
+            <listitem>
+                <para>
+                    <literal>X(1)=11</literal> égale <literal>bins(2)</literal>, donc <literal>i_bin(1)=2</literal>.
+                </para>
+            </listitem>
+            <listitem>
+                <para>
+                    <literal>X(2)=13</literal> ne correspond à aucune des valeurs de <literal>bins</literal>, donc <literal>i_bin(2)=0</literal>.
+                </para>
+            </listitem>
+            <listitem>
+                <para>...</para>
+            </listitem>
+            <listitem>
+                <para>
+                    <literal>X(7)=9</literal> ne correspond à aucune des valeurs de <literal>bins</literal>, donc <literal>i_bin(7)=0</literal>.
+                </para>
+            </listitem>
+            <listitem>
+                <para>
+                    Un seul élément de X vaut <literal>bin(1)=5</literal>, donc <literal>counts(1)=1</literal>.
+                </para>
+            </listitem>
+            <listitem>
+                <para>
+                    Aucun élément de X ne vaut <literal>bins(4)=20</literal>, donc <literal>counts(4)=0</literal>.
+                </para>
+            </listitem>
+            <listitem>
+                <para>
+                    5 éléments de X (i.e. 13, 1, 7, 2, 9) ne sont identiables à aucun des éléments de <literal>bins</literal>, donc <literal>outside=5</literal>.
+                </para>
+            </listitem>
+        </itemizedlist>
+        <para>
+            Les nombres dans <literal>bins</literal> doivent être rangés par ordre strictement croissant, que le mode de traitement soit continu ou discrêt. Dans le cas contraire, une erreur se produit.
+        </para>
+        <screen><![CDATA[ 
+-->dsearch([11 13 1 7 5 2 9], [2 1])
+!--error 999
+dsearch   : the array s (arg 2) is not well ordered
+-->dsearch([11 13 1 7 5 2 9], [2 1],"d")
+!--error 999
+dsearch   : the array s (arg 2) is not well ordered
+    ]]></screen>
+    </refsection>
+    <refsection>
+        <title>Exemples avancés</title>
+        <para>
+            Dans l'exemple suivant, l'histogramme empirique d'un tirage aléatoire à distribution uniforme sur [0, 1]
+                       est comparé avec la fonction de distribution théorique uniforme.
+            A cette fin, une catégorisation par intervalles contigus est utilisée (pm="c").
+            Une matrice X  de m=50000 nombres aléatoires à ditribution uniforme sur [0,1[ sont générés.
+                       n=10 bornes régulièrement espacées sur [0,1] sont générées et partionnent ce domaine 
+                       en n-1=9 intervalles de largeurs identiques.
+                       dsearch() classe et dénombre les effectifs de X dans chaque intervalle.
+                       La valeur de counts(i)/m attendue (pour m -> inf) vaut 1/(n-1).
+        </para>
+        <programlisting role="example"><![CDATA[
+m = 50000 ;
+n = 10;
+X = grand(m,1,"def");
+bins = linspace(0,1,n)';
+[i_bin, counts] = dsearch(X, bins);
+e = 1/(n-1)*ones(1,n-1);
+scf() ; 
+plot(bins(1:n-1), counts/m,"bo");
+plot(bins(1:n-1), e,"r-");
+legend(["Experiment","Expectation"]);
+xtitle("Uniform random numbers","X","P(X)");
+ ]]></programlisting>
+        <scilab:image>
+            m = 50000 ;
+            n = 10;
+            X = grand(m,1,"def");
+            bins = linspace(0,1,n)';
+            [i_bin, counts] = dsearch(X, bins);
+            e = 1/(n-1)*ones(1,n-1);
+            scf() ; 
+            plot(bins(1:n-1), counts/m,"bo");
+            plot(bins(1:n-1), e,"r-");
+            legend(["Experiment","Expectation"]);
+            xtitle("Uniform random numbers","X","P(X)");
+        </scilab:image>
+        <para>
+            Dans l'exemple suivant, l'histogramme d'un tirage aléatoire à distribution binomiale
+            est comparé avec la fonction de distribution de probabilité binomiale théorique B(N,p),
+            avec N=8 et p=0.5.
+            A cette fin, dsearch() est utilisée en mode discret ("pm="d").
+        </para>
+        <programlisting role="example"><![CDATA[ 
+N = 8 ; 
+p = 0.5; 
+m = 50000;
+X = grand(m,1,"bin",N,p); 
+bins = (0:N)';
+[i_bin, counts] = dsearch(X, bins, "d");
+Pexp = counts/m; 
+Pexa = binomial(p,N);
+scf() ; 
+plot(bins, Pexp, "bo");
+plot(bins, Pexa', "r-");
+xtitle("Distribution binomiale B(8,0.5)","X","P(X)");
+legend(["Tirage","Théorie"]);
+]]></programlisting>
+        <scilab:image>
+            N = 8 ; 
+            p = 0.5; 
+            m = 50000;
+            X = grand(m,1,"bin",N,p); 
+            bins = (0:N)';
+            [i_bin, counts] = dsearch(X, bins, "d");
+            Pexp = counts/m; 
+            Pexa = binomial(p,N);
+            scf() ; 
+            plot(bins, Pexp, "bo");
+            plot(bins, Pexa',"r-");
+            xtitle("Distribution binomiale B(8,0.5)","X","P(X)");
+            legend(["Tirage","Théorie"]);
+        </scilab:image>
+        <para>
+            Autre exemple : utilisons maintenant une série de polynômes de Hermite définis par morceaux pour interpoler un ensemble depoints.
+        </para>
+        <programlisting role="example"><![CDATA[ 
+
+      // Définition de la base des fonctions de Hermite :
+      function y=Ll(t,k,x)
+        // Lagrange left on Ik
+        y=(t-x(k+1))./(x(k)-x(k+1))
+      endfunction
+      function y=Lr(t,k,x)
+        // Lagrange right on Ik
+        y=(t-x(k))./(x(k+1)-x(k))
+      endfunction
+      function y=Hl(t,k,x)
+        y=(1-2*(t-x(k))./(x(k)-x(k+1))).*Ll(t,k,x).^2
+      endfunction
+      function y=Hr(t,k,x)
+        y=(1-2*(t-x(k+1))./(x(k+1)-x(k))).*Lr(t,k,x).^2
+      endfunction
+      function y=Kl(t,k,x)
+        y=(t-x(k)).*Ll(t,k,x).^2
+      endfunction
+      function y=Kr(t,k,x)
+        y=(t-x(k+1)).*Lr(t,k,x).^2
+      endfunction
+
+      x = [0 ; 0.2 ; 0.35 ; 0.5 ; 0.65 ; 0.8 ;  1];
+      y = [0 ; 0.1 ;-0.1  ; 0   ; 0.4  ;-0.1 ;  0];
+      d = [1 ; 0   ; 0    ; 1   ; 0    ; 0   ; -1];
+      X = linspace(0, 1, 200)';
+      i_bin = dsearch(X, x);
+
+      // Affichage de la courbe :
+      Y = y(i_bin).*Hl(X,i_bin) + y(i_bin+1).*Hr(X,i_bin) + d(i_bin).*Kl(X,i_bin) + d(i_bin+1).*Kr(X,i_bin);
+      scf();
+      plot(X,Y,"k-");
+      plot(x,y,"bo")
+      xtitle("Polynôme de Hermite par morceaux");
+      legend(["Polynôme d''interpolation","Données à interpoler"]);
+      // NOTE : pour vérifier, décommenter et exécuter la ligne suivante
+      // YY = interp(X,x,y,d); plot2d(X,YY,3,"000")
+      ]]></programlisting>
+        <scilab:image>
+            
+            function y=Ll(t,k,x)
+            y=(t-x(k+1))./(x(k)-x(k+1))
+            endfunction
+            function y=Lr(t,k,x)
+            y=(t-x(k))./(x(k+1)-x(k))
+            endfunction
+            function y=Hl(t,k,x)
+            y=(1-2*(t-x(k))./(x(k)-x(k+1))).*Ll(t,k,x).^2
+            endfunction
+            function y=Hr(t,k,x)
+            y=(1-2*(t-x(k+1))./(x(k+1)-x(k))).*Lr(t,k,x).^2
+            endfunction
+            function y=Kl(t,k,x)
+            y=(t-x(k)).*Ll(t,k,x).^2
+            endfunction
+            function y=Kr(t,k,x)
+            y=(t-x(k+1)).*Lr(t,k,x).^2
+            endfunction
+            
+            x = [0 ; 0.2 ; 0.35 ; 0.5 ; 0.65 ; 0.8 ;  1];
+            y = [0 ; 0.1 ;-0.1  ; 0   ; 0.4  ;-0.1 ;  0];
+            d = [1 ; 0   ; 0    ; 1   ; 0    ; 0   ; -1];
+            X = linspace(0, 1, 200)';
+            i_bin = dsearch(X, x);
+            
+            Y = y(i_bin).*Hl(X,i_bin) + y(i_bin+1).*Hr(X,i_bin) + d(i_bin).*Kl(X,i_bin) + d(i_bin+1).*Kr(X,i_bin);
+            scf();
+            plot(X,Y,"k-");
+            plot(x,y,"bo")
+            xtitle("Polynôme de Hermite par morceaux");
+            legend(["Polynôme d''interpolation","Données à interpoler"]);
+        </scilab:image>
+    </refsection>
+       
+    <refsection role="see also">
+        <title>Voir aussi</title>
+        <simplelist type="inline">
+            <member>
+                <link linkend="find">find</link>
+            </member>
+            <member>
+                <link linkend="members">members</link>
+            </member>
+            <member>
+                <link linkend="tabul">tabul</link>
+            </member>
+        </simplelist>
+    </refsection>
+    <refsection>
+        <title>Historique</title>
+        <revhistory>
+            <revision>
+                <revnumber>5.5.0</revnumber>
+                <revremark>Extension aux hypermatrices, aux entiers encodés, et au traitement du texte.</revremark>
+            </revision>
+        </revhistory>
+    </refsection>
+</refentry>
index 15e9d27..7cfc97e 100644 (file)
@@ -75,9 +75,10 @@ c     get val
         il = iadr(istk(il + 1))
       endif
       if (istk(il) .ne. 1) then
-        err = 2
-        call error(202)
-        return
+         top = topk
+         call funnam(ids(1,pt+1),'dsearch',il)
+         fun=-1
+         return
       endif
       if( .not. getrvect(fname, topk, top, mval, nval, lval) ) return
       if (ch.eq.'d') then
@@ -106,7 +107,7 @@ c     get val
 *     verif that val is in strict increasing order
       do j = 1, mval*nval-1
          if (.not. stk(lval+j-1) .lt. stk(lval+j)) then  ! cette forme permet de detecter les nans
-            buf=fname//' : the array s (arg 2) is not well ordered'
+            buf=fname//' : the array bins (arg 2) is not well ordered'
             call error(999)
             return
          endif
@@ -119,9 +120,10 @@ c     get X
         il = iadr(istk(il + 1))
       endif
       if (istk(il) .ne. 1) then
-        err = 1
-        call error(202)
-        return
+         top = topk
+         call funnam(ids(1,pt+1),'dsearch',il)
+         fun=-1
+         return
       endif
       if( .not. getrmat(fname, topk, top, mX, nX, lX) ) return
 
index 62264db..1550631 100644 (file)
 //
 // <-- Short Description -->
 // There are some inconsistent error messages in dsearch
-errmsg1 = msprintf(_("%s: Wrong type for argument #%d: Real matrix expected.\n"), "dsearch", 1);
-assert_checkerror("dsearch(int8([ 1 5 7]), [3 4 7 10], ""d"")", errmsg1);
-errmsg2 = msprintf(_("%s: Wrong type for argument #%d: Real matrix expected.\n"), "dsearch", 2);
-assert_checkerror("dsearch([1 5 7], int8([3 4 7 10]), ""d"")", errmsg2);
+assert_checktrue(execstr("dsearch(int8([ 1 5 7]), [3 4 7 10], ""d"")", "errcatch")==0);
+assert_checktrue(execstr("dsearch([1 5 7], int8([3 4 7 10]), ""d"")", "errcatch")==0);
 m=50000;
 n=10;
 X=grand(m,1,"def");
index 6a16849..786e177 100644 (file)
 // <-- Short Description -->
 // There are some inconsistent error messages in dsearch
 
-errmsg1 = msprintf(_("%s: Wrong type for argument #%d: Real matrix expected.\n"), "dsearch", 1);
-assert_checkerror("dsearch(int8([ 1 5 7]), [3 4 7 10], ""d"")", errmsg1);
+assert_checktrue(execstr("dsearch(int8([ 1 5 7]), [3 4 7 10], ""d"")", "errcatch")==0);
 
-errmsg2 = msprintf(_("%s: Wrong type for argument #%d: Real matrix expected.\n"), "dsearch", 2);
-assert_checkerror("dsearch([1 5 7], int8([3 4 7 10]), ""d"")", errmsg2);
+assert_checktrue(execstr("dsearch([1 5 7], int8([3 4 7 10]), ""d"")", "errcatch")==0);
 
 m=50000;
 n=10;
index bad4f42..07df888 100644 (file)
@@ -814,9 +814,9 @@ datatips_2.png=4052a4546ac5ee65fa61ed0dbe165513
 detrend_1.png=2eccb4bd13c0ab0b23b0b8a36477116b
 detrend_2.png=87e3a6b831bea33f9497349bafa3ff14
 drawaxis_1.png=8e796fb40ab072abf4067a37542a620
-dsearch_1.png=d664d494a4874dff2fc6872de753fac2
-dsearch_2.png=e372a35dd4d9181479cf0b1b2c81adf7
-dsearch_3.png=eca72d17fcd1b5db973bc3f0bd5efb7b
+dsearch_1.png=2e8c9cf2b136c7d25d870c271d599dd
+dsearch_2.png=fafbfb1fd80337e9567602ea7c1f01d0
+dsearch_3.png=baf82271411b092b792e67c4ebd25e1
 ell1mag_1.png=f7ce02603b04993e49aedf144db15915
 eqfir_1.png=ccaf8d9b3be54b01b15910cd2935ed94
 erfinv_1.png=a9c079e2216ea843f529d8fa1af6a38d
index 3357e33..64626bf 100644 (file)
Binary files a/scilab/modules/helptools/images/dsearch_1.png and b/scilab/modules/helptools/images/dsearch_1.png differ
index a74ed19..37c724c 100644 (file)
Binary files a/scilab/modules/helptools/images/dsearch_2.png and b/scilab/modules/helptools/images/dsearch_2.png differ
index 8e1b4af..a7c2014 100644 (file)
Binary files a/scilab/modules/helptools/images/dsearch_3.png and b/scilab/modules/helptools/images/dsearch_3.png differ
diff --git a/scilab/modules/overloading/macros/%c_dsearch.sci b/scilab/modules/overloading/macros/%c_dsearch.sci
new file mode 100644 (file)
index 0000000..d31c594
--- /dev/null
@@ -0,0 +1,73 @@
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) - 2013 - 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 [i_bin, counts, outside] = %c_dsearch(T, bins, discrete)
+
+    // CHECKING PARAMETERS
+    // -------------------
+    bins2 = unique(bins)
+    if size(bins2,"*")~=size(bins,"*")
+        msg = _("%c: input argument #%d has duplicates\n")
+        error(msprintf(msg, "dsearch", 2))
+    end
+
+    // DISCRETE CASE
+    // -------------
+    if argn(2)>2 & discrete=="d" then
+        [nb, i_bin] = members(T, bins)
+        outside = sum(bool2s(nb==0))
+        counts = zeros(bins)
+        inds = [ 0 ; gsort(i_bin(:),"g","i") ; size(bins,"*")+1]
+        tmp = find(inds(2:$)~=inds(1:$-1))+1
+        counts(inds(tmp(1:$-1))) = tmp(2:$)-tmp(1:$-1)
+        counts($) = sum(T==bins($))
+        
+    // SORTED CASE
+    // -----------
+    else
+        if or(bins2~=bins)
+            msg = _("%c: input argument #%d must be sorted in lexicographic order\n")
+            error(msprintf(msg, "dsearch", 2))
+        end
+        T0 = T
+        [T, k] = gsort(T0,"g","i")
+        
+        // index of the first T(i) >= bins(1)
+        i0 = min(find(strcmp(T(:), bins(1))>=0))
+        if i0==[] then
+            i0 = 1
+        end
+        // Initializations
+        i_bin = zeros(T)
+        counts = zeros(bins(2:$))
+        
+        // Loop over the bins
+        nT = size(T,"*")
+        for i = 1:size(bins,"*")-1
+            j = find(strcmp(T(i0:$), bins(i+1))<=0)
+            if j==[] then
+                counts(i) = 0
+            else
+                counts(i) = max(j)
+                i_bin(i0+j-1) = i
+                i0 = i0 + max(j)
+            end
+            if i0>nT then
+                break
+            end
+        end
+        
+        // Taking into account the original T order
+        i_bin = i_bin(:)
+        i_bin(k(:)) = i_bin
+        i_bin = matrix(i_bin, size(k))
+        //
+        outside = sum(bool2s(i_bin==0))
+    end
+endfunction
diff --git a/scilab/modules/overloading/macros/%hm_dsearch.sci b/scilab/modules/overloading/macros/%hm_dsearch.sci
new file mode 100644 (file)
index 0000000..621cbe0
--- /dev/null
@@ -0,0 +1,17 @@
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2013 - 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.1-en.txt
+
+
+function [ind, occ, info] = %hm_dsearch(H, r, flag)
+    if argn(2)<3 then
+        flag = "c";
+    end
+    [ind, occ, info] = dsearch(H(:), r, flag)
+    ind = matrix(ind, size(H))
+endfunction
diff --git a/scilab/modules/overloading/macros/%i_dsearch.sci b/scilab/modules/overloading/macros/%i_dsearch.sci
new file mode 100644 (file)
index 0000000..f971ef0
--- /dev/null
@@ -0,0 +1,18 @@
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2013 - Scilab Enterprises - Charlotte HECQUET
+//
+// 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.1-en.txt
+
+
+function [ind, occ, info] = %i_dsearch(H, r, flag)
+    if argn(2)<3 then
+        flag = "c";
+    end
+    H = iconvert(H, 0);
+    r = iconvert(r, 0);
+    [ind, occ, info] = dsearch(H, r, flag);
+endfunction
diff --git a/scilab/modules/overloading/tests/nonreg_tests/bug_6305.dia.ref b/scilab/modules/overloading/tests/nonreg_tests/bug_6305.dia.ref
new file mode 100644 (file)
index 0000000..e3e1a68
--- /dev/null
@@ -0,0 +1,64 @@
+// =============================================================================
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2013 - Scilab Enterprises - Charlotte HECQUET
+//
+//  This file is distributed under the same license as the Scilab package.
+// =============================================================================
+// <-- Non-regression test for bug 6305 -->
+//
+// <-- Bugzilla URL -->
+// http://bugzilla.scilab.org/show_bug.cgi?id=6305
+//
+// <-- Short Description -->
+// dsearch does not work with integers, hypermatrices and strings
+indref_d = [1,0, 0, 2; 2, 0, 0, 0; 0, 0, 2, 0; 4, 3, 0, 0];
+occref_d = [1, 3, 1, 1];
+inforef_d = 10;
+indref_c = [1, 2, 2, 1; 1, 0, 0, 0; 0, 0, 1, 0; 3, 2, 3, 3];
+occref_c = [4, 3, 3];
+inforef_c = 6;
+I = [3, 5, 6, 4; 4, 1, 2, 11; 1, 11, 4, 0; 10, 7, 9 9];
+// Integers
+I_int8 = int8(I);
+[ind, occ, info] = dsearch(I_int8, int8([3 4 7 10]),"d");
+assert_checkequal(ind, indref_d);
+assert_checkequal(occ, occref_d);
+assert_checkequal(info, inforef_d);
+[ind, occ, info] = dsearch(I_int8, int8([3 4 7 10]), "c");
+assert_checkequal(ind, indref_c);
+assert_checkequal(occ, occref_c);
+assert_checkequal(info, inforef_c);
+[ind, occ, info] = dsearch(I_int8, int8([3 4 7 10]));
+assert_checkequal(ind, indref_c);
+assert_checkequal(occ, occref_c);
+assert_checkequal(info, inforef_c);
+// Strings
+[ind, occ, info] = dsearch(["K", "M", "a", "g", "E", "b", "I"], ["E", "K", "O", "T"], "c");
+assert_checkequal(ind, [1 2 0 0 1 0 1]);
+assert_checkequal(occ, [3 1 0]);
+assert_checkequal(info, 3);
+[ind, occ, info] = dsearch(["K", "M", "a", "g", "E", "b", "I"], ["E", "K", "O", "T"], "d");
+assert_checkequal(ind, [2 0 0 0 1 0 0]);
+assert_checkequal(occ, [1 1 0 0]);
+assert_checkequal(info, 5);
+[ind, occ, info] = dsearch(["K", "M", "a", "g", "E", "b", "I"], ["E", "K", "O", "T"]);
+assert_checkequal(ind, [1 2 0 0 1 0 1]);
+assert_checkequal(occ, [3 1 0]);
+assert_checkequal(info, 3);
+// Hypermatrices
+I_hm(:,:,1) = I;
+I_hm(:,:,2) = I;
+indref_d(:,:,2) = indref_d;
+indref_c(:,:,2) = indref_c;
+[ind, occ, info] = dsearch(I_hm, [3 4 7 10], "d");
+assert_checkequal(ind, indref_d);
+assert_checkequal(occ, 2*occref_d);
+assert_checkequal(info, 2*inforef_d);
+[ind, occ, info] = dsearch(I_hm, [3 4 7 10], "c");
+assert_checkequal(ind, indref_c);
+assert_checkequal(occ, 2*occref_c);
+assert_checkequal(info, 2*inforef_c);
+[ind, occ, info] = dsearch(I_hm, [3 4 7 10]);
+assert_checkequal(ind, indref_c);
+assert_checkequal(occ, 2*occref_c);
+assert_checkequal(info, 2*inforef_c);
diff --git a/scilab/modules/overloading/tests/nonreg_tests/bug_6305.tst b/scilab/modules/overloading/tests/nonreg_tests/bug_6305.tst
new file mode 100644 (file)
index 0000000..7c18551
--- /dev/null
@@ -0,0 +1,72 @@
+// =============================================================================
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2013 - Scilab Enterprises - Charlotte HECQUET
+//
+//  This file is distributed under the same license as the Scilab package.
+// =============================================================================
+
+
+// <-- Non-regression test for bug 6305 -->
+//
+// <-- Bugzilla URL -->
+// http://bugzilla.scilab.org/show_bug.cgi?id=6305
+//
+// <-- Short Description -->
+// dsearch does not work with integers, hypermatrices and strings
+
+indref_d = [1,0, 0, 2; 2, 0, 0, 0; 0, 0, 2, 0; 4, 3, 0, 0];
+occref_d = [1, 3, 1, 1];
+inforef_d = 10;
+indref_c = [1, 2, 2, 1; 1, 0, 0, 0; 0, 0, 1, 0; 3, 2, 3, 3];
+occref_c = [4, 3, 3];
+inforef_c = 6;
+I = [3, 5, 6, 4; 4, 1, 2, 11; 1, 11, 4, 0; 10, 7, 9 9];
+
+// Integers
+I_int8 = int8(I);
+[ind, occ, info] = dsearch(I_int8, int8([3 4 7 10]),"d");
+assert_checkequal(ind, indref_d);
+assert_checkequal(occ, occref_d);
+assert_checkequal(info, inforef_d);
+[ind, occ, info] = dsearch(I_int8, int8([3 4 7 10]), "c");
+assert_checkequal(ind, indref_c);
+assert_checkequal(occ, occref_c);
+assert_checkequal(info, inforef_c);
+[ind, occ, info] = dsearch(I_int8, int8([3 4 7 10]));
+assert_checkequal(ind, indref_c);
+assert_checkequal(occ, occref_c);
+assert_checkequal(info, inforef_c);
+
+// Strings
+[ind, occ, info] = dsearch(["K", "M", "a", "g", "E", "b", "I"], ["E", "K", "O", "T"], "c");
+assert_checkequal(ind, [1 2 0 0 1 0 1]);
+assert_checkequal(occ, [3 1 0]);
+assert_checkequal(info, 3);
+
+[ind, occ, info] = dsearch(["K", "M", "a", "g", "E", "b", "I"], ["E", "K", "O", "T"], "d");
+assert_checkequal(ind, [2 0 0 0 1 0 0]);
+assert_checkequal(occ, [1 1 0 0]);
+assert_checkequal(info, 5);
+
+[ind, occ, info] = dsearch(["K", "M", "a", "g", "E", "b", "I"], ["E", "K", "O", "T"]);
+assert_checkequal(ind, [1 2 0 0 1 0 1]);
+assert_checkequal(occ, [3 1 0]);
+assert_checkequal(info, 3);
+
+// Hypermatrices
+I_hm(:,:,1) = I;
+I_hm(:,:,2) = I;
+indref_d(:,:,2) = indref_d;
+indref_c(:,:,2) = indref_c;
+[ind, occ, info] = dsearch(I_hm, [3 4 7 10], "d");
+assert_checkequal(ind, indref_d);
+assert_checkequal(occ, 2*occref_d);
+assert_checkequal(info, 2*inforef_d);
+[ind, occ, info] = dsearch(I_hm, [3 4 7 10], "c");
+assert_checkequal(ind, indref_c);
+assert_checkequal(occ, 2*occref_c);
+assert_checkequal(info, 2*inforef_c);
+[ind, occ, info] = dsearch(I_hm, [3 4 7 10]);
+assert_checkequal(ind, indref_c);
+assert_checkequal(occ, 2*occref_c);
+assert_checkequal(info, 2*inforef_c);