bug 4810
Allan CORNET [Tue, 22 Sep 2009 11:38:13 +0000 (13:38 +0200)]
scilab/CHANGES_5.2.X
scilab/modules/elementary_functions/help/en_US/gsort.xml
scilab/modules/elementary_functions/help/fr_FR/gsort.xml
scilab/modules/elementary_functions/help/pt_BR/gsort.xml
scilab/modules/elementary_functions/macros/%sp_gsort.sci [new file with mode: 0644]
scilab/modules/elementary_functions/sci_gateway/c/sci_gsort.c
scilab/modules/elementary_functions/tests/nonreg_tests/bug_4810.dia.ref [new file with mode: 0644]
scilab/modules/elementary_functions/tests/nonreg_tests/bug_4810.tst [new file with mode: 0644]

index cf7620c..526d098 100644 (file)
@@ -448,3 +448,4 @@ Bug fixes:
 
 * bug 4807 fixed - strsubst does not check if second argument is a valid patter where fourth argument is 'r'.
 
+* bug 4810 fixed - gsort does not manage sparse vectors as sort.
index 1df3432..5118b79 100644 (file)
@@ -25,7 +25,7 @@
   <refnamediv>
     <refname>gsort</refname>
 
-    <refpurpose> sorting by quick sort agorithm</refpurpose>
+    <refpurpose>sorting by quick sort agorithm</refpurpose>
   </refnamediv>
 
   <refsynopsisdiv>
 [B [,k]]=gsort(A,option)
 [B [,k]]=gsort(A,option,direction)</synopsis>
   </refsynopsisdiv>
+
   <refsection>
     <title>Parameters</title>
+
     <variablelist>
       <varlistentry>
         <term>A</term>
+
         <listitem>
-          <para>a real,an integer or a character string vector/matrix.</para>
+          <para>a real,an integer or a character string vector/matrix or a
+          sparse vector.</para>
         </listitem>
       </varlistentry>
 
         <term>option</term>
 
         <listitem>
-          <para>a character string. It gives the type of sort to perform:</para>
-         <itemizedlist>
+          <para>a character string. It gives the type of sort to
+          perform:</para>
+
+          <itemizedlist>
             <listitem>
               <para>'r' : each column of <literal>A</literal> is sorted</para>
             </listitem>
             </listitem>
 
             <listitem>
-              <para>'g': all elements of <literal>A</literal> are sorted. It is the default value.</para>
+              <para>'g': all elements of <literal>A</literal> are sorted. It
+              is the default value.</para>
             </listitem>
 
             <listitem>
-              <para>'lr':  lexicographic sort of the rows of <literal>A</literal></para>
+              <para>'lr': lexicographic sort of the rows of
+              <literal>A</literal></para>
             </listitem>
 
             <listitem>
-              <para>'lc': lexicographic sort of the columns of <literal>A</literal></para>
+              <para>'lc': lexicographic sort of the columns of
+              <literal>A</literal></para>
             </listitem>
           </itemizedlist>
         </listitem>
@@ -76,6 +85,7 @@
 
       <varlistentry>
         <term>direction</term>
+
         <listitem>
           <para>a character string. It gives the ordering direction:
           <literal>'i'</literal> stand for increasing and
         </listitem>
       </varlistentry>
 
-     <varlistentry>
+      <varlistentry>
         <term>B</term>
+
         <listitem>
-          <para>an array with same type and dimensions as <literal>A</literal>.</para>
+          <para>an array with same type and dimensions as
+          <literal>A</literal>.</para>
         </listitem>
       </varlistentry>
+
       <varlistentry>
         <term>k</term>
+
         <listitem>
-          <para>a real array with integer values and same dimensions
-          as <literal>A</literal>. Contains the origin indices.</para>
+          <para>a real array with integer values and same dimensions as
+          <literal>A</literal>. Contains the origin indices.</para>
         </listitem>
       </varlistentry>
     </variablelist>
     <title>Description</title>
 
     <para><literal>gsort</literal> implements a "quick sort" algorithm for
-    various data types. </para>
+    various data types.</para>
+
     <itemizedlist>
       <listitem>
         <para><literal>B=gsort(A,'g')</literal>,
         <literal>B=gsort(A,'g','d')</literal> and
         <literal>B=gsort(A)</literal> sort the elements of the array
-        <literal>A</literal>, seen as <literal>A(:)</literal> in a decreasing order.</para>
+        <literal>A</literal>, seen as <literal>A(:)</literal> in a decreasing
+        order.</para>
 
-        <para><literal>B=gsort(A,'g','i')</literal> sort the elements of the array
-        <literal>A</literal> in the increasing order.</para>
+        <para><literal>B=gsort(A,'g','i')</literal> sort the elements of the
+        array <literal>A</literal> in the increasing order.</para>
       </listitem>
 
-    <listitem>
+      <listitem>
         <para><literal>B=gsort(A,'lr')</literal> sorts the rows of
-        <literal>A</literal> in lexical decreasing order.
-        <literal>B</literal> is obtained by a permutation of the rows
-        of matrix <literal>A</literal> in such a way that the rows of
-        <literal>B</literal> verify
-        <literal>B(i,:)&gt;=B(j,:)</literal> if
+        <literal>A</literal> in lexical decreasing order. <literal>B</literal>
+        is obtained by a permutation of the rows of matrix
+        <literal>A</literal> in such a way that the rows of
+        <literal>B</literal> verify <literal>B(i,:)&gt;=B(j,:)</literal> if
         <literal>i&lt;j</literal>.</para>
 
-        <para><literal>B=gsort(A,'lr','i')</literal> works similarily
-        for increasing lexical order.</para>
+        <para><literal>B=gsort(A,'lr','i')</literal> works similarily for
+        increasing lexical order.</para>
       </listitem>
-     <listitem>
+
+      <listitem>
         <para><literal>B=gsort(A,'lc')</literal> sorts the columns of
-        <literal>A</literal> in lexical decreasing order.
-        <literal>B</literal> is obtained by a permutation of the columns
-        of matrix <literal>A</literal> in such a way that the columns of
-        <literal>B</literal> verify
-        <literal>B(:,i)&gt;=B(:,j)</literal> if
+        <literal>A</literal> in lexical decreasing order. <literal>B</literal>
+        is obtained by a permutation of the columns of matrix
+        <literal>A</literal> in such a way that the columns of
+        <literal>B</literal> verify <literal>B(:,i)&gt;=B(:,j)</literal> if
         <literal>i&lt;j</literal>.</para>
 
-        <para><literal>B=gsort(A,'lc','i')</literal> works similarily
-        for increasing lexical order.</para>
+        <para><literal>B=gsort(A,'lc','i')</literal> works similarily for
+        increasing lexical order.</para>
       </listitem>
     </itemizedlist>
-    <para>If required the second return argument <literal>k</literal>
-   contains the indices of the sorted values in
-   <literal>A</literal>. If <literal>[B,k]=gsort(A,'g')</literal> one
-   has <literal>B==A(k)</literal>. <emphasis role="bold">The
-   algorithme preserve the relative order of records with equal
-   values. </emphasis></para>
+
+    <para>If required the second return argument <literal>k</literal> contains
+    the indices of the sorted values in <literal>A</literal>. If
+    <literal>[B,k]=gsort(A,'g')</literal> one has <literal>B==A(k)</literal>.
+    <emphasis role="bold">The algorithme preserve the relative order of
+    records with equal values. </emphasis></para>
 
     <para>When <literal>v</literal> is complex, the elements are sorted by
-    magnitude, i.e., abs(<literal>v</literal>) . Only <literal>'g'</literal> as second argument
-    is managed with complex.</para>
+    magnitude, i.e., abs(<literal>v</literal>) . Only <literal>'g'</literal>
+    as second argument is managed with complex.</para>
 
     <para>if <literal>v</literal> have <literal>%nan</literal> or
     <literal>%inf</literal> as elements. gsort places these at the beginning
     with <literal>'i'</literal> or at the end with <literal>'d'</literal>
     argument.</para>
-
   </refsection>
 
   <refsection>
     <title>Examples</title>
 
-    <programlisting role="example"><![CDATA[ 
+    <programlisting role="example"> 
 alr=[1,2,2;
      1,2,1;
      1,1,2;
@@ -186,7 +199,7 @@ v=['Scilab' '2.6'
 
 gsort(v,'lr','i')
 gsort(v,'lc','i')
- ]]></programlisting>
+ </programlisting>
   </refsection>
 
   <refsection>
@@ -194,8 +207,6 @@ gsort(v,'lc','i')
 
     <simplelist type="inline">
       <member><link linkend="find">find</link></member>
-
-      <member><link linkend="sort">sort</link></member>
     </simplelist>
   </refsection>
 
@@ -205,6 +216,5 @@ gsort(v,'lc','i')
     <para>Quick sort algorithm from Bentley &amp; McIlroy's "Engineering a
     Sort Function". Software---Practice and Experience,
     23(11):1249-1265</para>
-
   </refsection>
 </refentry>
index d836ca4..eac547d 100644 (file)
@@ -34,7 +34,7 @@
 
         <listitem>
           <para>vecteur ou matrice de nombres réels, entiers ou de chaînes de
-          caractères.</para>
+          caractères ou vecteur creux.</para>
         </listitem>
       </varlistentry>
 
 
     <para>Si le second argument de retour k est demandé, il contient les
     indices des valeurs triées dans le tableau d'origine. Si
-    <literal>[B,k]=gsort(A,'g')</literal> on a
-    <literal>B==A(k)</literal>. <emphasis role="bold">L'algorithme préserve l'ordre
-    relatif des éléments ayant des valeurs
-    égales.</emphasis></para>
+    <literal>[B,k]=gsort(A,'g')</literal> on a <literal>B==A(k)</literal>.
+    <emphasis role="bold">L'algorithme préserve l'ordre relatif des éléments
+    ayant des valeurs égales.</emphasis></para>
 
     <para>Les matrices ou vecteurs complexes sont triés par rapport au module
     complexe. Seule l'option <literal>'g'</literal> est accessible avec des
   <refsection>
     <title>Exemples</title>
 
-    <programlisting role="example"><![CDATA[ 
+    <programlisting role="example"> 
 alr=[1,2,2;
      1,2,1;
      1,1,2;
@@ -193,7 +192,7 @@ A=['Scilab' '2.6'
 
 gsort(A,'lr','i')
 gsort(A,'lc','i')
- ]]></programlisting>
+ </programlisting>
   </refsection>
 
   <refsection>
@@ -201,8 +200,6 @@ gsort(A,'lc','i')
 
     <simplelist type="inline">
       <member><link linkend="find">find</link></member>
-
-      <member><link linkend="sort">sort</link></member>
     </simplelist>
   </refsection>
 
@@ -212,6 +209,5 @@ gsort(A,'lc','i')
     <para>Quick sort algorithm from Bentley &amp; McIlroy's "Engineering a
     Sort Function". Software---Practice and Experience,
     23(11):1249-1265</para>
-
   </refsection>
 </refentry>
index 1c5db90..c163a10 100644 (file)
@@ -44,7 +44,8 @@
         <term>v,s</term>
 
         <listitem>
-          <para>vetor ou matriz de reais, inteiros ou strings</para>
+          <para>vetor ou matriz de reais, inteiros ou strings ou sparse
+          vector</para>
         </listitem>
       </varlistentry>
 
   <refsection>
     <title>Exemplos</title>
 
-    <programlisting role="example"><![CDATA[ 
+    <programlisting role="example"> 
 alr=[1,2,2;
      1,2,1;
      1,1,2;
@@ -140,7 +141,7 @@ v=['Scilab' '2.6'
 
 gsort(v,'lr','i')
 gsort(v,'lc','i')
- ]]></programlisting>
+ </programlisting>
   </refsection>
 
   <refsection>
@@ -148,8 +149,6 @@ gsort(v,'lc','i')
 
     <simplelist type="inline">
       <member><link linkend="find">find</link></member>
-
-      <member><link linkend="sort">sort</link></member>
     </simplelist>
   </refsection>
 
diff --git a/scilab/modules/elementary_functions/macros/%sp_gsort.sci b/scilab/modules/elementary_functions/macros/%sp_gsort.sci
new file mode 100644 (file)
index 0000000..a97509f
--- /dev/null
@@ -0,0 +1,27 @@
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) DIGITEO - 2009 - Allan CORNET
+// 
+// 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 A = %sp_gsort(A, optsort, directionsort)
+  [ij, v, mn] = spget(A);
+  if mn(2) == 1 then
+    last = find( v<0 );
+    first = find( v>0 );
+    nn = size(v, '*');
+    v([1:size(first, '*'), nn-size(last, '*')+1:nn]) = [gsort(v(first));gsort(v(last))];
+    A = sparse(ij, v, mn);
+  elseif mn(1) == 1 then
+    last = find( v<0 );
+    first = find( v>0 );
+    nn = size(v, '*');
+    v([1:size(first, '*'),nn-size(last, '*')+1:nn]) = [gsort(v(first));gsort(v(last))];
+    A = sparse(ij, v, mn);  
+  else
+    error(999,msprintf(_("%s: Wrong size for input argument #%d: sparse vectors expected.\n"),'gsort',1));
+  end
+endfunction
index bf08fd9..7f72046 100644 (file)
@@ -59,9 +59,6 @@ int C2F(sci_gsort)(char *fname, unsigned long fname_len)
        CheckRhs(1,3);
        CheckLhs(1,2);
 
-
-
-
        if (Rhs >= 1)
     {
                Type=VarType(1);
@@ -104,6 +101,10 @@ int C2F(sci_gsort)(char *fname, unsigned long fname_len)
                        case sci_ints:
                                GetRhsVar(1,MATRIX_OF_VARIABLE_SIZE_INTEGER_DATATYPE,&m1,&n1,&Im);
                        break;
+                       case sci_sparse:
+                               OverLoad(1);
+                               return 0;
+                               break;
                        default :
                                Scierror(999,_("%s: Wrong type for input argument #%d: Real, complex, int matrix or matrix of strings expected.\n"),fname,2);
                                return 0;
diff --git a/scilab/modules/elementary_functions/tests/nonreg_tests/bug_4810.dia.ref b/scilab/modules/elementary_functions/tests/nonreg_tests/bug_4810.dia.ref
new file mode 100644 (file)
index 0000000..1c204e0
--- /dev/null
@@ -0,0 +1,21 @@
+// =============================================================================
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2009 - DIGITEO - Allan CORNET
+//
+//  This file is distributed under the same license as the Scilab package.
+// =============================================================================
+// <-- JVM NOT MANDATORY -->
+// <-- Non-regression test for bug 4810 -->
+//
+// <-- Bugzilla URL -->
+// http://bugzilla.scilab.org/show_bug.cgi?id=4810
+//
+// <-- Short Description -->
+// gsort does not manage sparse vector as sort
+sp = sparse([1,2,4,5,3,10]);
+ref = sparse([10,5,4,3,2,1]);
+A = gsort(sp);
+if and(ref == A) <> %t then bugmes();quit;end
+sp = sparse([1,2;4,5;3,10]);
+ierr = execstr('A = gsort(sp);','errcatch');
+if ierr <> 999 then bugmes();quit;end
diff --git a/scilab/modules/elementary_functions/tests/nonreg_tests/bug_4810.tst b/scilab/modules/elementary_functions/tests/nonreg_tests/bug_4810.tst
new file mode 100644 (file)
index 0000000..745fad4
--- /dev/null
@@ -0,0 +1,24 @@
+// =============================================================================
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2009 - DIGITEO - Allan CORNET
+//
+//  This file is distributed under the same license as the Scilab package.
+// =============================================================================
+// <-- JVM NOT MANDATORY -->
+// <-- Non-regression test for bug 4810 -->
+//
+// <-- Bugzilla URL -->
+// http://bugzilla.scilab.org/show_bug.cgi?id=4810
+//
+// <-- Short Description -->
+// gsort does not manage sparse vector as sort
+
+sp = sparse([1,2,4,5,3,10]);
+ref = sparse([10,5,4,3,2,1]);
+A = gsort(sp);
+if and(ref == A) <> %t then pause,end
+
+sp = sparse([1,2;4,5;3,10]);
+ierr = execstr('A = gsort(sp);','errcatch');
+if ierr <> 999 then pause,end
+