Bug #11612: If A is negative sparse, the max function returned wrong value of index 22/8622/6
Adeline CARNIS [Wed, 8 Aug 2012 11:53:19 +0000 (13:53 +0200)]
Tests:
test_run("elementary_functions","max","no_check_error_output")
test_run("sparse","bug_11612")

Change-Id: Iee3ab650978b242785ab043c2e979f5c8e905aad

20 files changed:
scilab/CHANGES_5.4.X
scilab/modules/elementary_functions/macros/%sp_max.sci [new file with mode: 0644]
scilab/modules/elementary_functions/macros/%sp_min.sci [new file with mode: 0644]
scilab/modules/elementary_functions/sci_gateway/fortran/sci_f_maxi.f
scilab/modules/elementary_functions/tests/unit_tests/max.dia.ref
scilab/modules/elementary_functions/tests/unit_tests/max.tst
scilab/modules/sparse/Makefile.am
scilab/modules/sparse/Makefile.in
scilab/modules/sparse/sci_gateway/c/gw_sparse.c
scilab/modules/sparse/sci_gateway/c/sci_spmax.c [deleted file]
scilab/modules/sparse/sci_gateway/c/sci_spmin.c [deleted file]
scilab/modules/sparse/sci_gateway/fortran/sci_f_spmax.f [deleted file]
scilab/modules/sparse/src/c/core_Import.def
scilab/modules/sparse/src/c/sparse.vcxproj
scilab/modules/sparse/src/c/sparse.vcxproj.filters
scilab/modules/sparse/src/fortran/dspmax.f [deleted file]
scilab/modules/sparse/src/fortran/dspmin.f [deleted file]
scilab/modules/sparse/src/fortran/sparse_f.vfproj
scilab/modules/sparse/tests/nonreg_tests/bug_11612.dia.ref [new file with mode: 0644]
scilab/modules/sparse/tests/nonreg_tests/bug_11612.tst [new file with mode: 0644]

index 53046b2..8c81560 100644 (file)
@@ -68,6 +68,8 @@ Bug Fixes
 
 * Bug #11606 fixed - exit() was too slow in nw mode when driver("png") was set.
 
+* Bug #11612 fixed - Index of the max value of a negative sparse was wrong.
+
 * Bug #11618 fixed - A(:) returned wrong values when A was a complex sparse matrix.
 
 * Bug #11628 fixed - Clearing a shortcut did not work is Preferences.
diff --git a/scilab/modules/elementary_functions/macros/%sp_max.sci b/scilab/modules/elementary_functions/macros/%sp_max.sci
new file mode 100644 (file)
index 0000000..967857e
--- /dev/null
@@ -0,0 +1,270 @@
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2010 - Scilab Enterprises - Adeline CARNIS
+// 
+// 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 [m, k] = %sp_max(varargin)
+    [lhs, rhs] = argn(0);
+
+    elements = varargin;
+    error_list = %f;
+
+    // If the first argument is a list, it retrieves the number of sparse 
+    // matrices in list
+    if type(varargin(1)) == 15 then
+        if rhs <> 1 then
+            error(msprintf(_("%s: Wrong size of input argument: %d expected.\n"), "%sp_max", 1))
+        end
+
+        rhs = length(varargin(1));
+        elements = varargin(1);
+        error_list = %t; 
+
+        // If the second argument of list is not a sparse -> ERROR
+        if rhs == 2 & type(elements(2)) <> 5 then
+            error(msprintf(_("%s: Wrong type for input argument #%d: A sparse matrix expected.\n"), "%sp_max", 1))
+        end
+    end
+
+    select rhs
+        // If rhs = 1, the first input argument must be a sparse
+    case 1
+        A1 = elements(1);
+
+        // Check if A is a sparse
+        if type(A1)<> 5 then
+            error(msprintf(_("%s: Wrong type for input argument #%d: A sparse matrix expected.\n"), "%sp_max", 1))
+        end
+
+        // Retrieves entries of sparse matrix
+        [ij, v, mn]= spget(A1);
+        if lhs == 1 then
+            m = max(v);
+        else
+            [m, i] = max(v);
+            if mn(1) == 1 then
+                k = ij(i,2);
+            else
+                if mn(2) == 1 then
+                    k = ij(i,1);
+                else
+                    k = [ij(i,1) ij(i,2)];
+                end
+            end
+        end
+
+        // If A1 contains negative values and the length of v is less then mn(1)
+        // * mn(2), A1 contains one or several zeros
+        // So, max = 0
+        if m < 0 & length(v)<> mn(1)*mn(2) then
+            m = 0;
+            if lhs == 2 then
+                k = 0;
+                if mn(1) == 1 then
+                    for i = 1:length(v)
+                        if and(ij(:,2) <> i) then
+                            k = i;
+                            break;
+                        end
+                    end
+                else
+                    if mn(2) == 1 then
+                        for i = 1:length(v)
+                            if and(ij(:,1) <> i) then
+                                k = i;
+                                break;
+                            end
+                        end
+                    else
+                        // thanks to ij, find the position of zero value
+                        // But ij contains only the indices of non zero values
+                        // So check on first column the values 1:mn(1)
+                        // if posi is less than mn(2) then there is zero value
+                        cpt = 0;
+                        for i = 1:mn(1)
+                            posi = length(find(ij(:,1)==i));
+                            if posi <> mn(2) then
+                                for j = 1:mn(2)
+                                    // it is the last index of line where m = 0
+                                    if mn(2)*(i-1)+j ==  mn(2)*i then
+                                        k = [i, j];
+                                        break;
+                                    else
+                                        pos = find(ij(mn(2)*(i-1)+j,2) == j);
+                                        if pos == [] & k == 0 then
+                                            k = [i,j];
+                                            break;
+                                        end
+                                    end
+                                end
+                                if k <> 0 then
+                                    break;
+                                end
+                            end
+                        end
+                    end
+                end
+            end
+        end
+
+        // If rhs = 2, the second input argument can be a character or a sparse
+        // matrix
+    case 2
+        if lhs == 2 then
+            error(msprintf(_("%s: Wrong number of output argument: %d expected.\n"), "%sp_max", 1));
+        end
+
+        A1 = elements(1);
+
+        // Check if A is a sparse
+        if type(A1) <> 5  then
+            error(msprintf(_("%s: Wrong type for input argument #%d: A sparse matrix expected.\n"), "%sp_max", 1));
+        end
+
+        select type(elements(2))
+            // If the second argument is a string
+        case 10
+            opts = elements(2);
+            // Opts can be : 'c' 'r' or 'm'
+            ind = find(opts == ['c','r','m']);
+            if (ind == []) then
+                error(msprintf(_("%s: Wrong value for input argument #%d: [''r'' ''c'' ''m''] expected.\n"),"%sp_max",2));
+            end
+
+            [ij, v, mn] = spget(A1);
+
+            // If mn(1) = 1, A1 is a row vector
+            if mn(1) == 1 then
+                // max(A1, 'r') = A1(1,:) because A1 is a row vector
+                if opts == 'r' then
+                    m = A1;
+                    // max(A1, 'c') or max(A1, 'm') = max(A1)
+                else
+                    m = max(v', opts);
+                    if m < 0 & length(v)<> mn(1)*mn(2) then
+                        m = 0;
+                    end
+                end
+            end
+
+            // If mn(2) = 1, A1 is a column vector
+            if mn(2) == 1 then
+                if opts == 'c' then
+                    m = A1;
+                else
+                    m = max(v, opts);
+                end
+                if m < 0 & length(v)<> mn(1)*mn(2) then
+                    m = 0;
+                end
+            end
+
+            // Return a sparse vector containing the max in terms of 'c', 'r' or 'm'
+            if mn(1) <> 1 & mn(2) <> 1 then
+
+                // If opts = 'c', the result is returned in column vector
+                if opts == 'c' then
+                    m = spzeros(mn(1),1);
+                    for i = 1:mn(1)
+                        pos = length(find(ij(:,1)==i));
+                        if pos <> mn(2) then
+                            m(i) = 0;
+                        else
+                            m(i) = max(A1(i,:));
+                        end
+                    end
+                    // If opts = 'r' or 'm', the result is returned in row vector
+                else
+                    m = spzeros(1,mn(2));
+                    for i = 1:mn(2)
+                        pos = length(find(ij(:,2)==i));
+                        if pos <> mn(1) then
+                            m(i) = 0;
+                        else
+                            m(i) = max(A1(:,i));
+                        end
+                    end
+                end
+            end
+
+        case 5
+            // If the second argument is a sparse
+            A2 = elements(2);
+
+            [m1, n1] = size(A1);
+            [m2, n2] = size(A2);
+
+            // Check the size of A2
+            if (m1 <> m2 | n1 <> n2) then
+                error(msprintf(_("%s: Wrong size of input argument #%d: Same size as input argument #%d expected.\n"), "%sp_max", 2, 1));
+            end
+
+            // Retrieve the indices of non-zeros
+            ij1 = spget(A1);
+            ij2 = spget(A2);
+
+            // A1 and A2 contain non zeros -> full
+            if size(ij1,'r') == m1*n1 & size(ij2,'r') == m2*n2 then
+                [m,k] = max(full(A1), full(A2));
+                m = sparse(m);
+                k = sparse(k);
+            else
+                m = A1;
+                pos = find(m < A2);
+                m(pos) = A2(pos);
+            end
+
+        else
+            error(msprintf(_("%s: Wrong type for input argument #%d: A sparse matrix or a character expected.\n"), "%sp_max", 2));
+        end
+
+        // Case : max(A1,A2,A3,..,An) or max(list(A1,A2,A3,..,An))
+    else
+        if lhs == 2 then
+            error(msprintf(_("%s: Wrong number of output argument: %d expected.\n"), "%sp_max", 1));
+        end
+        // m is the first matrix
+        m = elements(1);
+        // Loop on the number of input arguments
+        for i = 2:rhs
+            An = elements(i);
+
+            // Check if An is a sparse
+            if type(An) <> 5 then
+                if error_list then
+                    error(msprintf(_("%s: Wrong type for input argument #%d of list: A sparse matrix expected.\n"), "%sp_max", i))
+                else
+                    error(msprintf(_("%s: Wrong type for input argument #%d: A sparse matrix expected.\n"), "%sp_max", i))
+                end
+            end
+
+            [m1, n1] = size(m);
+            [m2, n2] = size(An);
+
+            // Check size
+            if (m1 <> m2 | n1 <> n2) then
+                if error_list then
+                    error(msprintf(_("%s: Wrong size of input argument #%d of list: Same size as input argument #%d expected.\n"), "%sp_max", i, 1))
+                else
+                    error(msprintf(_("%s: Wrong size of input argument #%d: Same size as input argument #%d expected.\n"), "%sp_max", i, 1))
+                end
+            end
+
+            ij1 = spget(m);
+            ij2 = spget(An);
+
+            if size(ij1,'r') == m1*n1 & size(ij2,'r') == m2*n2 then
+                [m,k] = max(full(m), full(An));
+                m = sparse(m);
+                k = sparse(k);
+            else
+                pos = find(m < An);
+                m(pos) = An(pos);
+            end
+        end
+    end
+endfunction
diff --git a/scilab/modules/elementary_functions/macros/%sp_min.sci b/scilab/modules/elementary_functions/macros/%sp_min.sci
new file mode 100644 (file)
index 0000000..dd19c54
--- /dev/null
@@ -0,0 +1,270 @@
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2010 - Scilab Enterprises - Adeline CARNIS
+// 
+// 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 [m, k] = %sp_min(varargin)
+    [lhs, rhs] = argn(0);
+
+    elements = varargin;
+    error_list = %f;
+
+    // If the first argument is a list, it retrieves the number of sparse 
+    // matrices in list
+    if type(varargin(1)) == 15 then
+        if rhs <> 1 then
+            error(msprintf(_("%s: Wrong size of input argument: %d expected.\n"), "%sp_min", 1))
+        end
+
+        rhs = length(varargin(1));
+        elements = varargin(1);
+        error_list = %t; 
+
+        // If the second argument of list is not a sparse -> ERROR
+        if rhs == 2 & type(elements(2)) <> 5 then
+            error(msprintf(_("%s: Wrong type for input argument #%d: A sparse matrix expected.\n"), "%sp_min", 1))
+        end
+    end
+
+    select rhs
+        // If rhs = 1, the first input argument must be a sparse
+    case 1
+        A1 = elements(1);
+
+        // Check if A is a sparse
+        if type(A1)<> 5 then
+            error(msprintf(_("%s: Wrong type for input argument #%d: A sparse matrix expected.\n"), "%sp_min", 1))
+        end
+
+        // Retrieves entries of sparse matrix
+        [ij, v, mn]= spget(A1);
+        if lhs == 1 then
+            m = min(v);
+        else
+            [m, i] = min(v);
+            if mn(1) == 1 then
+                k = ij(i,2);
+            else
+                if mn(2) == 1 then
+                    k = ij(i,1);
+                else
+                    k = [ij(i,1) ij(i,2)];
+                end
+            end
+        end
+
+        // If A1 contains positive values and the length of v is less then mn(1)
+        // * mn(2), A1 contains one or several zeros
+        // So, min = 0
+        if m > 0 & length(v)<> mn(1)*mn(2) then
+            m = 0;
+            if lhs == 2 then
+                k = 0;
+                if mn(1) == 1 then
+                    for i = 1:length(v)
+                        if and(ij(:,2) <> i) then
+                            k = i;
+                            break;
+                        end
+                    end
+                else
+                    if mn(2) == 1 then
+                        for i = 1:length(v)
+                            if and(ij(:,1) <> i) then
+                                k = i;
+                                break;
+                            end
+                        end
+                    else
+                        // thanks to ij, find the position of zero value
+                        // But ij contains only the indices of non zero values
+                        // So check on first column the values 1:mn(1)
+                        // if posi is less than mn(2) then there is zero value
+                        for i = 1:mn(1)
+                            posi = length(find(ij(:,1)==i));
+                            if posi <> mn(2) then
+                                for j = 1:mn(2)
+                                    // it is the last index of line where m = 0
+                                    if mn(2)*(i-1)+j ==  mn(2)*i then
+                                        k = [i, j];
+                                        break;
+                                    else
+                                        pos = find(ij(mn(2)*(i-1)+j,2) == j);
+                                        if pos == [] & k == 0 then
+                                            k = [i,j];
+                                            break;
+                                        end
+                                    end
+                                end
+                                if k <> 0 then
+                                    break;
+                                end
+                            end
+                        end
+                    end
+                end
+            end
+        end
+
+        // If rhs = 2, the second input argument can be a character or a sparse
+        // matrix
+    case 2
+        if lhs == 2 then
+            error(msprintf(_("%s: Wrong number of output argument: %d expected"), "%sp_min", 1));
+        end
+
+        A1 = elements(1);
+
+        // Check if A is a sparse
+        if type(A1) <> 5  then
+            error(msprintf(_("%s: Wrong type for input argument #%d: A sparse matrix expected.\n"), "%sp_min", 1));
+        end
+
+        select type(elements(2))
+            // If the second argument is a string
+        case 10
+            opts = elements(2);
+            // Opts can be : 'c' 'r' or 'm'
+            ind = find(opts == ['c','r','m']);
+            if (ind == []) then
+                error(msprintf(_("%s: Wrong value for input argument #%d: [''r'' ''c'' ''m''] expected.\n"),"%sp_min",2));
+            end
+
+            [ij, v, mn] = spget(A1);
+
+            // If mn(1) = 1, A1 is a row vector
+            if mn(1) == 1 then
+                // min(A1, 'r') = A1(1,:) because A1 is a row vector
+                if opts == 'r' then
+                    m = A1;
+                    // min(A1, 'c') or min(A1, 'm') = min(A1)
+                else
+                    m = min(v', opts);
+                    if m > 0 & length(v)<> mn(1)*mn(2) then
+                        m = 0;
+                    end
+                end
+            end
+
+            // If mn(2) = 1, A1 is a column vector
+            if mn(2) == 1 then
+                if opts == 'c' then
+                    m = A1;
+                else
+                    m = min(v, opts);
+                end
+                if m > 0 & length(v)<> mn(1)*mn(2) then
+                    m = 0;
+                end
+            end
+
+            // Return a sparse vector containing the max in terms of 'c', 'r' or 'm'
+            if mn(1) <> 1 & mn(2) <> 1 then
+                m = spzeros(mn(1),1);
+                // If opts = 'c', the result is returned in column vector
+                if opts == 'c' then
+                    m = spzeros(mn(1),1);
+                    for i = 1:mn(1)
+                        pos = length(find(ij(:,1)==i));
+                        if pos <> mn(2) then
+                            m(i) = 0;
+                        else
+                            m(i) = min(A1(i,:));
+                        end
+                    end
+                    // If opts = 'r' or 'm', the result is returned in row vector
+                else
+                    m = spzeros(1,mn(2));
+                    for i = 1:mn(2)
+                        pos = length(find(ij(:,2)==i));
+                        if pos <> mn(1) then
+                            m(i) = 0;
+                        else
+                            m(i) = min(A1(:,i));
+                        end
+                    end
+                end
+            end
+
+        case 5
+            // If the second argument is a sparse
+            A2 = elements(2);
+
+            // Check if A2 is a sparse
+            if type(A2) <> 5 then
+                error(msprintf(_("%s: Wrong type for input argument #%d: A sparse matrix expected.\n"), "%sp_min", 2));
+            end
+
+            [m1, n1] = size(A1);
+            [m2, n2] = size(A2);
+
+            // Check the size of A2
+            if (m1 <> m2 | n1 <> n2) then
+                error(msprintf(_("%s: Wrong size of input argument #%d: Same size as input argument #%d expected.\n"), "%sp_min", 2, 1));
+            end
+
+            // Retrieve the indices of non-zeros
+            ij1 = spget(A1);
+            ij2 = spget(A2);
+
+            // A1 and A2 contain non zeros -> full
+            if size(ij1,'r') == m1*n1 & size(ij2,'r') == m2*n2 then
+                [m,k] = min(full(A1), full(A2));
+                m = sparse(m);
+                k = sparse(k);
+            else
+                m = A1;
+                pos = find(m > A2);
+                m(pos) = A2(pos);
+            end
+
+        else
+            error(msprintf(_("%s: Wrong type for input argument #%d: A sparse matrix or a character expected.\n"), "%sp_min", 2));
+        end
+
+        // Case : max(A1,A2,A3,..,An) or max(list(A1,A2,A3,..,An))
+    else
+        if lhs == 2 then
+            error(msprintf(_("%s: Wrong number of output argument: %d expected"), "%sp_min", 1));
+        end
+        // m is the first matrix
+        m = elements(1);
+        // Loop on the number of input arguments
+        for i = 2:rhs
+            An = elements(i);
+
+            // Check if An is a sparse
+            if type(An) <> 5 then
+                if error_list then
+                    error(msprintf(_("%s: Wrong type for input argument #%d of list: A sparse matrix expected.\n"), "%sp_min", i))
+                else
+                    error(msprintf(_("%s: Wrong type for input argument #%d: A sparse matrix expected.\n"), "%sp_min", i))
+                end
+            end
+
+            [m1, n1] = size(m);
+            [m2, n2] = size(An);
+
+            // Check size
+            if (m1 <> m2 | n1 <> n2) then
+                error(msprintf(_("%s: Wrong size of input argument #%d: Same size as input argument #%d expected.\n"), "%sp_min", i, 1))
+            end
+
+            ij1 = spget(m);
+            ij2 = spget(An);
+
+            if size(ij1,'r') == m1*n1 & size(ij2,'r') == m2*n2 then
+                [m,k] = min(full(m), full(An));
+                m = sparse(m);
+                k = sparse(k);
+            else
+                pos = find(m > An);
+                m(pos) = An(pos);
+            end
+        end
+    end
+endfunction
index 6dddb41..cb2880f 100644 (file)
@@ -35,8 +35,14 @@ c     ------list case
 c     ------sparse case
       if(itype.eq.5) then
          call ref2val
-         fin=fin-6
-         fun=27
+         top=topk
+         il=iadr(lstk(top))
+         if(fin.eq.17) then
+               call funnam(ids(1,pt+1),'min',il)
+            else
+               call funnam(ids(1,pt+1),'max',il)
+            endif
+            fun=-1
 c        *call* spelm
          return
       endif
@@ -69,9 +75,9 @@ c     ------simple case one argument which is a matrix or vector
       if(gettype(top).ne.1) then
          top=topk
          if((fin.eq.17) .or. (fin.eq.54)) then
-            call funnam(ids(1,pt+1),'mini',iadr(lstk(top-rhs+1)))
+            call funnam(ids(1,pt+1),'min',iadr(lstk(top-rhs+1)))
          else
-            call funnam(ids(1,pt+1),'maxi',iadr(lstk(top-rhs+1)))
+            call funnam(ids(1,pt+1),'max',iadr(lstk(top-rhs+1)))
          endif
          fun=-1
          return
@@ -182,9 +188,9 @@ c     check argument and compute dimension of the result.
             il=iadr(lstk(top-rhs+i))
             if(istk(il).lt.0) il=iadr(istk(il+1))
             if(fin.eq.17) then
-               call funnam(ids(1,pt+1),'mini',il)
+               call funnam(ids(1,pt+1),'min',il)
             else
-               call funnam(ids(1,pt+1),'maxi',il)
+               call funnam(ids(1,pt+1),'max',il)
             endif
             fun=-1
             return
@@ -273,6 +279,21 @@ c=====maxi mini of list arguments
          call error(999)
          return
       endif
+
+c     first item is a sparse, call overload %sp_max/min  
+      il11 = iadr(il1)
+      if(istk(il11).eq.5) then
+        if ((fin.eq.17).or.(fin.eq.54)) then
+            call funnam(ids(1,pt+1),'min',il11)
+        else
+            call funnam(ids(1,pt+1),'max',il11)
+        endif
+     
+        fun=-1
+        return
+      endif
+
+
       if(.not.getlistmat(fname,topk,topk,1,it1,m,n,lr1,lc1)
      $     ) return
       if ( it1.ne.0) then
index 4554b3d..b1f8e62 100644 (file)
 // =============================================================================
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
 // Copyright (C) ????-2008 - INRIA
+// Copyright (C) 2012 - Scilab Enterprises - Adeline CARNIS
 //
 //  This file is distributed under the same license as the Scilab package.
 // =============================================================================
 // <-- CLI SHELL MODE -->
-Ntest=1
- Ntest  =
-    1.  
+Ntest = 1;
 // test max(A) : A matrix
-// maxi is compared with gsort
-for i=1:Ntest,
-       m=100;n=200;a=rand(m,n);
-       [am,ak]=max(a); [a1,ak1]=gsort(a);
-       if norm([am-a1(1,1),(ak(1)+(m)*(ak(2)-1))-ak1(1,1)])> %eps then bugmes();quit;end
+// maxi is compared with sort
+for i = 1:Ntest,
+    m = 100;n = 200;a = rand(m,n);
+    [am,ak] = max(a); [a1,ak1] = gsort(a);
+    assert_checkequal(am, a1(1,1));
+    assert_checkequal(ak(1) + m * (ak(2) - 1), ak1(1,1));
 end
 // test max(A) : A vector
-for i=1:Ntest,
-       m=100;a=rand(1,m);
-       [am,ak]=max(a); [a1,ak1]=gsort(a);
-       if norm([am-a1(1,1),(ak-ak1(1,1))])> %eps then bugmes();quit;end
+for i = 1:Ntest,
+    m = 100;a = rand(1,m);
+    [am,ak] = max(a); [a1,ak1] = gsort(a);
+    assert_checkequal(am, a1(1,1));
+    assert_checkequal(ak, ak1(1,1));
 end
-// test mini
+// test mini 
 for i=1:Ntest,
-       m=100;n=200;a=rand(m,n);
-       [am,ak]=max(-a); [ami,aki]=min(a);
-       if norm([am+ami,ak-aki])> %eps then bugmes();quit;end
+    m = 100;n = 200;a = rand(m,n);
+    [am,ak] = max(-a); [ami,aki] = min(a);
+    assert_checkequal(am, -ami);
+    assert_checkequal(ak, aki);
 end
-for i=1:Ntest,
-       m=100;a=rand(1,m);
-       [am,ak]=max(-a); [ami,aki]=min(a);
-       if norm([am+ami,ak-aki])> %eps then bugmes();quit;end
+for i = 1:Ntest,
+    m = 100;a = rand(1,m);
+    [am,ak] = max(-a); [ami,aki] = min(a);
+    assert_checkequal(am, -ami);
+    assert_checkequal(ak, aki);
 end
 // test max(A1,A....) compared with usual maxi + feval
-m=10,n=20;
- m  =
-    10.  
-A1=rand(m,n);
-A2=rand(m,n);
-A3=rand(m,n);
-A4=rand(m,n);
+m = 10;
+n = 20;
+A1 = rand(m,n);
+A2 = rand(m,n);
+A3 = rand(m,n);
+A4 = rand(m,n);
 deff('[y]=f(i,j)','[y,k]=max([A1(i,j),A2(i,j),A3(i,j),A4(i,j)]);y=y+%i*k');
-A=feval(1:m,1:n,f);
-Am=real(A);Ak=imag(A);
-[Am1,Ak1]=max(A1,A2,A3,A4);
-if norm(Am1-Am)> %eps then bugmes();quit;end
-if norm(Ak1-Ak)> %eps then bugmes();quit;end
+A = feval(1:m,1:n,f);
+Am = real(A);Ak = imag(A);
+[Am1, Ak1] = max(A1, A2, A3, A4);
+assert_checkequal(Am1, Am);
+assert_checkequal(Ak1, Ak);
 // test max(list(A1,A2,..)) compared to max(A1,..)
-[Al,Akl]=max(list(A1,A2,A3,A4));
-if norm(Al-Am)> %eps then bugmes();quit;end
-if norm(Akl-Ak)> %eps then bugmes();quit;end
-// test max(A,'c') and max(A,'r')
+[Al, Akl] = max(list(A1, A2, A3, A4));
+assert_checkequal(Al, Am);
+assert_checkequal(Akl, Ak);
+// test max(A,'c') and max(A,'r') 
 // max(A,'r') returns a row vector which contains max for each column
-[Am,Akm]=max(A1,'r');
-nc=size(A1,'c')
- nc  =
-    20.  
-Am1=[];Ak1=[]
- Ak1  =
-     []
-for i=1:nc,[am,ak]=max(A1(:,i)); Am1=[Am1,am];Ak1=[Ak1,ak];end
-if norm(Am-Am1)> %eps then bugmes();quit;end
-if norm(Akm-Ak1)> %eps then bugmes();quit;end
+[Am, Akm] = max(A1, 'r');
+nc = size(A1, 'c');
+Am1 = [];
+Ak1 = [];
+for i = 1:nc
+    [am, ak] = max(A1(:,i));
+    Am1 = [Am1, am];
+    Ak1 = [Ak1, ak];
+end
+assert_checkequal(Am, Am1);
+assert_checkequal(Akm, Ak1);
 // max(A,'c');
-[Am,Akm]=max(A1,'c');
-nc=size(A1,'r')
- nc  =
-    10.  
-Am1=[];Ak1=[]
- Ak1  =
-     []
-for i=1:nc,[am,ak]=max(A1(i,:)); Am1=[Am1;am];Ak1=[Ak1;ak];end
-if norm(Am-Am1)> %eps then bugmes();quit;end
-if norm(Akm-Ak1)> %eps then bugmes();quit;end
+[Am, Akm] = max(A1, 'c');
+nc = size(A1, 'r');
+Am1 = [];
+Ak1 = [];
+for i = 1:nc
+    [am, ak] = max(A1(i,:));
+    Am1 = [Am1; am];
+    Ak1 = [Ak1; ak];
+end
+assert_checkequal(Am, Am1);
+assert_checkequal(Akm, Ak1);
+// ******************** WITH SPARSES ********************
+// check error messages
+A = [1 2;3 4];
+A = sparse(A);
+assert_checkfalse(execstr("[m,i] = max(A,''c'')", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong number of output argument: %d expected.\n"), "%sp_max", 1);
+assert_checkerror("[m,i] = max(A,''c'')", refMsg);
+A = [1 2;3 4];
+A = sparse(A);
+assert_checkfalse(execstr("m = max(A,full(A))", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: A sparse matrix or a character expected.\n"), "%sp_max", 2);
+assert_checkerror("m = max(A,full(A))", refMsg);
+B = sparse([1 2]);
+assert_checkfalse(execstr("m = max(A,B)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong size of input argument #%d: Same size as input argument #%d expected.\n"), "%sp_max", 2, 1);
+assert_checkerror("m = max(A,B)", refMsg);
+B = B';
+assert_checkfalse(execstr("m = max(A,B)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong size of input argument #%d: Same size as input argument #%d expected.\n"), "%sp_max", 2, 1);
+assert_checkerror("m = max(A,B)", refMsg);
+B = [6 7;8 9];
+C = [2 4; 6 8];
+assert_checkfalse(execstr("[m,i] = max(A,B,C)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong number of output argument: %d expected.\n"), "%sp_max", 1);
+assert_checkerror("[m,i] = max(A,B,C)", refMsg);
+assert_checkfalse(execstr("m = max(A,sparse(B),C)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: A sparse matrix expected.\n"), "%sp_max", 3);
+assert_checkerror("m = max(A,sparse(B),C)", refMsg);
+L = list(A,sparse(B),C);
+assert_checkfalse(execstr("m = max(L", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d of list: A sparse matrix expected.\n"), "%sp_max", 3);
+assert_checkerror("m = max(L)", refMsg);
+C = sparse([1 2]);
+L = list(A,sparse(B),C);
+assert_checkfalse(execstr("m = max(L", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong size of input argument #%d of list: Same size as input argument #%d expected.\n"), "%sp_max", 3, 1);
+assert_checkerror("m = max(L)", refMsg);
+assert_checkfalse(execstr("m = max(A,sparse(B),C)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong size of input argument #%d: Same size as input argument #%d expected.\n"), "%sp_max", 3, 1);
+assert_checkerror("m = max(A,sparse(B),C)", refMsg);
+a = -1 * rand(3,2);
+a(2) = 0;
+A = sparse(a);
+[m, i] = max(a);
+[m1, i1] = max(A);
+assert_checkequal(m1,m);
+assert_checkequal(i1,i);
+[m, i] = max(a');
+[m1, i1] = max(A');
+assert_checkequal(m1,m);
+assert_checkequal(i1,i);
+[m, i] = max(a(:));
+[m1, i1] = max(A(:));
+assert_checkequal(m1,m);
+assert_checkequal(i1,i);
+[m, i] = max(a(:)');
+[m1, i1] = max(A(:)');
+assert_checkequal(m1,m);
+assert_checkequal(i1,i);
+a = [-3 -4;0 -1;-5 -6];
+A = sparse(a);
+[m, i] = max(a);
+[m1, i1] = max(A);
+assert_checkequal(m1,m);
+assert_checkequal(i1,i);
+[m, i] = max(a');
+[m1, i1] = max(A');
+assert_checkequal(m1,m);
+assert_checkequal(i1,i);
+[m, i] = max(a(:));
+[m1, i1] = max(A(:));
+assert_checkequal(m1,m);
+assert_checkequal(i1,i);
+[m, i] = max(a(:)');
+[m1, i1] = max(A(:)');
+assert_checkequal(m1,m);
+assert_checkequal(i1,i);
+b = [-5 0;-1 -6];
+B = sparse(b);
+[m, i] = max(b);
+[m1, i1] = max(B);
+assert_checkequal(m1,m);
+assert_checkequal(i1,i);
+[m, i] = max(b');
+[m1, i1] = max(B');
+assert_checkequal(m1,m);
+assert_checkequal(i1,i);
+[m, i] = max(b(:));
+[m1, i1] = max(B(:));
+assert_checkequal(m1,m);
+assert_checkequal(i1,i);
+[m, i] = max(b(:)');
+[m1, i1] = max(B(:)');
+assert_checkequal(m1,m);
+assert_checkequal(i1,i);
+s = rand(3,2);
+s(2) = 0;
+S = sparse(s);
+[m, i] = min(s);
+[m1, i1] = min(S);
+assert_checkequal(m1,m);
+assert_checkequal(i1,i);
+[m, i] = min(s');
+[m1, i1] = min(S');
+assert_checkequal(m1,m);
+assert_checkequal(i1,i);
+[m, i] = min(s(:));
+[m1, i1] = min(S(:));
+assert_checkequal(m1,m);
+assert_checkequal(i1,i);
+[m, i] = min(s(:)');
+[m1, i1] = min(S(:)');
+assert_checkequal(m1,m);
+assert_checkequal(i1,i);
+v = [1 4;7 6];
+V = sparse(v);
+[m, i] = max(v);
+[m1, i1] = max(V);
+assert_checkequal(m1,m);
+assert_checkequal(i1,i);
+[m, i] = max(v');
+[m1, i1] = max(V');
+assert_checkequal(m1,m);
+assert_checkequal(i1,i);
+[m, i] = max(v(:));
+[m1, i1] = max(V(:));
+assert_checkequal(m1,m);
+assert_checkequal(i1,i);
+[m, i] = max(v(:)');
+[m1, i1] = max(V(:)');
+assert_checkequal(m1,m);
+assert_checkequal(i1,i);
+// max(A1, A2,..., An)
+A1 = sprand(3,3,3);
+A2 = sprand(3,3,3);
+A3 = sprand(3,3,3);
+m = max(full(A1), full(A2), full(A3));
+m1 = max(A1, A2, A3);
+assert_checkequal(full(m1), m);
+// with list
+m = max(list(full(A1), full(A2), full(A3)));
+m1 = max(list(A1, A2, A3));
+assert_checkequal(full(m1), m);
+// min(A1, A2,..., An)
+A1 = sprand(3,3,3);
+A2 = sprand(3,3,3);
+A3 = sprand(3,3,3);
+m = min(full(A1), full(A2), full(A3));
+m1 = min(A1, A2, A3);
+assert_checkequal(full(m1), m);
+// with list
+m = min(list(full(A1), full(A2), full(A3)));
+m1 = min(list(A1, A2, A3));
+assert_checkequal(full(m1), m);
+for i = 1:Ntest,
+    m = 100;a = rand(1,m);
+    [am,ak] = max(-a); [ami,aki] = min(a);
+    assert_checkequal(am, -ami);
+    assert_checkequal(ak, aki);
+end
+// test max(A1,A....) compared with usual maxi + feval
+m = 10;
+n = 20;
+A1 = sprand(m,n,10);
+A2 = sprand(m,n,10);
+A3 = sprand(m,n,10);
+A4 = sprand(m,n,10);
+deff('[y]=f(i,j)','[y,k]=max([A1(i,j),A2(i,j),A3(i,j),A4(i,j)]);y=y+%i*k');
+A = feval(1:m,1:n,f);
+Am = real(A);Ak = imag(A);
+Am1 = max(A1, A2, A3, A4);
+assert_checkequal(Am1, sparse(Am));
+// test max(list(A1,A2,..)) compared to max(A1,..)
+Al = max(list(A1, A2, A3, A4));
+assert_checkequal(Al, sparse(Am));
+// test max(A,'c') and max(A,'r') 
+// max(A,'r') returns a row vector which contains max for each column
+[Am] = max(A1, 'r');
+nc = size(A1, 'c');
+Am1 = [];
+for i = 1:nc
+    [am] = max(A1(:,i));
+    Am1 = [Am1, am];
+end
+assert_checkequal(Am, sparse(Am1));
+// max(A,'c');
+[Am] = max(A1, 'c');
+nc = size(A1, 'r');
+Am1 = [];
+for i = 1:nc
+    [am] = max(A1(i,:));
+    Am1 = [Am1; am];
+end
+assert_checkequal(Am, sparse(Am1));
+// test min(A1,A....) compared with usual maxi + feval
+m = 10;
+n = 20;
+A1 = sprand(m,n,10);
+A2 = sprand(m,n,10);
+A3 = sprand(m,n,10);
+A4 = sprand(m,n,10);
+deff('[y]=g(i,j)','[y,k]=min([A1(i,j),A2(i,j),A3(i,j),A4(i,j)]);y=y+%i*k');
+A = feval(1:m,1:n,g);
+Am = real(A);Ak = imag(A);
+Am1 = min(A1, A2, A3, A4);
+assert_checkequal(Am1, sparse(Am));
+// test min(list(A1,A2,..)) compared to min(A1,..)
+Al = min(list(A1, A2, A3, A4));
+assert_checkequal(Al, sparse(Am));
+// test min(A,'c') and min(A,'r') 
+// min(A,'r') returns a row vector which contains min for each column
+[Am] = min(A1, 'r');
+nc = size(A1, 'c');
+Am1 = [];
+for i = 1:nc
+    [am] = min(A1(:,i));
+    Am1 = [Am1, am];
+end
+assert_checkequal(Am, sparse(Am1));
+// min(A,'c');
+[Am] = min(A1, 'c');
+nc = size(A1, 'r');
+Am1 = [];
+for i = 1:nc
+    [am] = min(A1(i,:));
+    Am1 = [Am1; am];
+end
+assert_checkequal(Am, sparse(Am1));
index abed7e2..97d9e92 100644 (file)
 // =============================================================================
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
 // Copyright (C) ????-2008 - INRIA
+// Copyright (C) 2012 - Scilab Enterprises - Adeline CARNIS
 //
 //  This file is distributed under the same license as the Scilab package.
 // =============================================================================
 
 // <-- CLI SHELL MODE -->
 
-Ntest=1
+Ntest = 1;
 // test max(A) : A matrix
 // maxi is compared with sort
 
-for i=1:Ntest,
-       m=100;n=200;a=rand(m,n);
-       [am,ak]=max(a); [a1,ak1]=gsort(a); 
-       if norm([am-a1(1,1),(ak(1)+(m)*(ak(2)-1))-ak1(1,1)])> %eps then pause,end
+for i = 1:Ntest,
+    m = 100;n = 200;a = rand(m,n);
+    [am,ak] = max(a); [a1,ak1] = gsort(a);
+    assert_checkequal(am, a1(1,1));
+    assert_checkequal(ak(1) + m * (ak(2) - 1), ak1(1,1));
 end
 
 // test max(A) : A vector
 
-for i=1:Ntest,
-       m=100;a=rand(1,m);
-       [am,ak]=max(a); [a1,ak1]=gsort(a); 
-       if norm([am-a1(1,1),(ak-ak1(1,1))])> %eps then pause,end
+for i = 1:Ntest,
+    m = 100;a = rand(1,m);
+    [am,ak] = max(a); [a1,ak1] = gsort(a);
+    assert_checkequal(am, a1(1,1));
+    assert_checkequal(ak, ak1(1,1));
 end
 
 // test mini 
 
 for i=1:Ntest,
-       m=100;n=200;a=rand(m,n);
-       [am,ak]=max(-a); [ami,aki]=min(a);
-       if norm([am+ami,ak-aki])> %eps then pause,end
+    m = 100;n = 200;a = rand(m,n);
+    [am,ak] = max(-a); [ami,aki] = min(a);
+    assert_checkequal(am, -ami);
+    assert_checkequal(ak, aki);
 end
 
-for i=1:Ntest,
-       m=100;a=rand(1,m);
-       [am,ak]=max(-a); [ami,aki]=min(a);
-       if norm([am+ami,ak-aki])> %eps then pause,end
+for i = 1:Ntest,
+    m = 100;a = rand(1,m);
+    [am,ak] = max(-a); [ami,aki] = min(a);
+    assert_checkequal(am, -ami);
+    assert_checkequal(ak, aki);
 end
 
-
 // test max(A1,A....) compared with usual maxi + feval
 
-m=10,n=20;
-A1=rand(m,n);
-A2=rand(m,n);
-A3=rand(m,n);
-A4=rand(m,n);
+m = 10;
+n = 20;
+A1 = rand(m,n);
+A2 = rand(m,n);
+A3 = rand(m,n);
+A4 = rand(m,n);
 deff('[y]=f(i,j)','[y,k]=max([A1(i,j),A2(i,j),A3(i,j),A4(i,j)]);y=y+%i*k');
-A=feval(1:m,1:n,f);
-Am=real(A);Ak=imag(A);
-[Am1,Ak1]=max(A1,A2,A3,A4);
+A = feval(1:m,1:n,f);
+Am = real(A);Ak = imag(A);
+[Am1, Ak1] = max(A1, A2, A3, A4);
 
-if norm(Am1-Am)> %eps then pause,end
-if norm(Ak1-Ak)> %eps then pause,end
+assert_checkequal(Am1, Am);
+assert_checkequal(Ak1, Ak);
 
 // test max(list(A1,A2,..)) compared to max(A1,..)
 
-[Al,Akl]=max(list(A1,A2,A3,A4));
-if norm(Al-Am)> %eps then pause,end
-if norm(Akl-Ak)> %eps then pause,end
+[Al, Akl] = max(list(A1, A2, A3, A4));
+
+assert_checkequal(Al, Am);
+assert_checkequal(Akl, Ak);
 
 // test max(A,'c') and max(A,'r') 
 // max(A,'r') returns a row vector which contains max for each column
 
-[Am,Akm]=max(A1,'r');
-nc=size(A1,'c')
-Am1=[];Ak1=[]
-for i=1:nc,[am,ak]=max(A1(:,i)); Am1=[Am1,am];Ak1=[Ak1,ak];end
-if norm(Am-Am1)> %eps then pause,end
-if norm(Akm-Ak1)> %eps then pause,end
+[Am, Akm] = max(A1, 'r');
+nc = size(A1, 'c');
+Am1 = [];
+Ak1 = [];
+for i = 1:nc
+    [am, ak] = max(A1(:,i));
+    Am1 = [Am1, am];
+    Ak1 = [Ak1, ak];
+end
+assert_checkequal(Am, Am1);
+assert_checkequal(Akm, Ak1);
+
+// max(A,'c');
+
+[Am, Akm] = max(A1, 'c');
+nc = size(A1, 'r');
+Am1 = [];
+Ak1 = [];
+for i = 1:nc
+    [am, ak] = max(A1(i,:));
+    Am1 = [Am1; am];
+    Ak1 = [Ak1; ak];
+end
+
+assert_checkequal(Am, Am1);
+assert_checkequal(Akm, Ak1);
+
+// ******************** WITH SPARSES ********************
+// check error messages
+A = [1 2;3 4];
+A = sparse(A);
+assert_checkfalse(execstr("[m,i] = max(A,''c'')", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong number of output argument: %d expected.\n"), "%sp_max", 1);
+assert_checkerror("[m,i] = max(A,''c'')", refMsg);
+
+A = [1 2;3 4];
+A = sparse(A);
+assert_checkfalse(execstr("m = max(A,full(A))", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: A sparse matrix or a character expected.\n"), "%sp_max", 2);
+assert_checkerror("m = max(A,full(A))", refMsg);
+
+B = sparse([1 2]);
+assert_checkfalse(execstr("m = max(A,B)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong size of input argument #%d: Same size as input argument #%d expected.\n"), "%sp_max", 2, 1);
+assert_checkerror("m = max(A,B)", refMsg);
+
+B = B';
+assert_checkfalse(execstr("m = max(A,B)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong size of input argument #%d: Same size as input argument #%d expected.\n"), "%sp_max", 2, 1);
+assert_checkerror("m = max(A,B)", refMsg);
+
+B = [6 7;8 9];
+C = [2 4; 6 8];
+assert_checkfalse(execstr("[m,i] = max(A,B,C)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong number of output argument: %d expected.\n"), "%sp_max", 1);
+assert_checkerror("[m,i] = max(A,B,C)", refMsg);
+
+
+assert_checkfalse(execstr("m = max(A,sparse(B),C)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d: A sparse matrix expected.\n"), "%sp_max", 3);
+assert_checkerror("m = max(A,sparse(B),C)", refMsg);
+
+L = list(A,sparse(B),C);
+assert_checkfalse(execstr("m = max(L", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong type for input argument #%d of list: A sparse matrix expected.\n"), "%sp_max", 3);
+assert_checkerror("m = max(L)", refMsg);
+
+C = sparse([1 2]);
+L = list(A,sparse(B),C);
+assert_checkfalse(execstr("m = max(L", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong size of input argument #%d of list: Same size as input argument #%d expected.\n"), "%sp_max", 3, 1);
+assert_checkerror("m = max(L)", refMsg);
+
+assert_checkfalse(execstr("m = max(A,sparse(B),C)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong size of input argument #%d: Same size as input argument #%d expected.\n"), "%sp_max", 3, 1);
+assert_checkerror("m = max(A,sparse(B),C)", refMsg);
+
+
+a = -1 * rand(3,2);
+a(2) = 0;
+A = sparse(a);
+[m, i] = max(a);
+[m1, i1] = max(A);
+assert_checkequal(m1,m);
+assert_checkequal(i1,i);
+
+[m, i] = max(a');
+[m1, i1] = max(A');
+assert_checkequal(m1,m);
+assert_checkequal(i1,i);
+
+[m, i] = max(a(:));
+[m1, i1] = max(A(:));
+assert_checkequal(m1,m);
+assert_checkequal(i1,i);
+
+[m, i] = max(a(:)');
+[m1, i1] = max(A(:)');
+assert_checkequal(m1,m);
+assert_checkequal(i1,i);
+
+a = [-3 -4;0 -1;-5 -6];
+A = sparse(a);
+[m, i] = max(a);
+[m1, i1] = max(A);
+assert_checkequal(m1,m);
+assert_checkequal(i1,i);
+
+[m, i] = max(a');
+[m1, i1] = max(A');
+assert_checkequal(m1,m);
+assert_checkequal(i1,i);
+
+[m, i] = max(a(:));
+[m1, i1] = max(A(:));
+assert_checkequal(m1,m);
+assert_checkequal(i1,i);
+
+[m, i] = max(a(:)');
+[m1, i1] = max(A(:)');
+assert_checkequal(m1,m);
+assert_checkequal(i1,i);
+
+b = [-5 0;-1 -6];
+B = sparse(b);
+[m, i] = max(b);
+[m1, i1] = max(B);
+assert_checkequal(m1,m);
+assert_checkequal(i1,i);
+
+[m, i] = max(b');
+[m1, i1] = max(B');
+assert_checkequal(m1,m);
+assert_checkequal(i1,i);
+
+[m, i] = max(b(:));
+[m1, i1] = max(B(:));
+assert_checkequal(m1,m);
+assert_checkequal(i1,i);
+
+[m, i] = max(b(:)');
+[m1, i1] = max(B(:)');
+assert_checkequal(m1,m);
+assert_checkequal(i1,i);
+
+s = rand(3,2);
+s(2) = 0;
+S = sparse(s);
+[m, i] = min(s);
+[m1, i1] = min(S);
+assert_checkequal(m1,m);
+assert_checkequal(i1,i);
+
+[m, i] = min(s');
+[m1, i1] = min(S');
+assert_checkequal(m1,m);
+assert_checkequal(i1,i);
 
+[m, i] = min(s(:));
+[m1, i1] = min(S(:));
+assert_checkequal(m1,m);
+assert_checkequal(i1,i);
+
+[m, i] = min(s(:)');
+[m1, i1] = min(S(:)');
+assert_checkequal(m1,m);
+assert_checkequal(i1,i);
+
+v = [1 4;7 6];
+V = sparse(v);
+[m, i] = max(v);
+[m1, i1] = max(V);
+assert_checkequal(m1,m);
+assert_checkequal(i1,i);
+
+[m, i] = max(v');
+[m1, i1] = max(V');
+assert_checkequal(m1,m);
+assert_checkequal(i1,i);
+
+[m, i] = max(v(:));
+[m1, i1] = max(V(:));
+assert_checkequal(m1,m);
+assert_checkequal(i1,i);
+
+[m, i] = max(v(:)');
+[m1, i1] = max(V(:)');
+assert_checkequal(m1,m);
+assert_checkequal(i1,i);
+
+// max(A1, A2,..., An)
+A1 = sprand(3,3,3);
+A2 = sprand(3,3,3);
+A3 = sprand(3,3,3);
+m = max(full(A1), full(A2), full(A3));
+m1 = max(A1, A2, A3);
+assert_checkequal(full(m1), m);
+
+// with list
+m = max(list(full(A1), full(A2), full(A3)));
+m1 = max(list(A1, A2, A3));
+assert_checkequal(full(m1), m);
+
+// min(A1, A2,..., An)
+A1 = sprand(3,3,3);
+A2 = sprand(3,3,3);
+A3 = sprand(3,3,3);
+m = min(full(A1), full(A2), full(A3));
+m1 = min(A1, A2, A3);
+assert_checkequal(full(m1), m);
+
+// with list
+m = min(list(full(A1), full(A2), full(A3)));
+m1 = min(list(A1, A2, A3));
+assert_checkequal(full(m1), m);
+
+for i = 1:Ntest,
+    m = 100;a = rand(1,m);
+    [am,ak] = max(-a); [ami,aki] = min(a);
+    assert_checkequal(am, -ami);
+    assert_checkequal(ak, aki);
+end
+
+// test max(A1,A....) compared with usual maxi + feval
+
+m = 10;
+n = 20;
+A1 = sprand(m,n,10);
+A2 = sprand(m,n,10);
+A3 = sprand(m,n,10);
+A4 = sprand(m,n,10);
+deff('[y]=f(i,j)','[y,k]=max([A1(i,j),A2(i,j),A3(i,j),A4(i,j)]);y=y+%i*k');
+A = feval(1:m,1:n,f);
+Am = real(A);Ak = imag(A);
+Am1 = max(A1, A2, A3, A4);
+
+assert_checkequal(Am1, sparse(Am));
+
+// test max(list(A1,A2,..)) compared to max(A1,..)
+
+Al = max(list(A1, A2, A3, A4));
+assert_checkequal(Al, sparse(Am));
+
+// test max(A,'c') and max(A,'r') 
+// max(A,'r') returns a row vector which contains max for each column
+
+[Am] = max(A1, 'r');
+nc = size(A1, 'c');
+Am1 = [];
+for i = 1:nc
+    [am] = max(A1(:,i));
+    Am1 = [Am1, am];
+end
+assert_checkequal(Am, sparse(Am1));
 
 // max(A,'c');
 
-[Am,Akm]=max(A1,'c');
-nc=size(A1,'r')
-Am1=[];Ak1=[]
-for i=1:nc,[am,ak]=max(A1(i,:)); Am1=[Am1;am];Ak1=[Ak1;ak];end
-if norm(Am-Am1)> %eps then pause,end
-if norm(Akm-Ak1)> %eps then pause,end
+[Am] = max(A1, 'c');
+nc = size(A1, 'r');
+Am1 = [];
+for i = 1:nc
+    [am] = max(A1(i,:));
+    Am1 = [Am1; am];
+end
+assert_checkequal(Am, sparse(Am1));
+
+// test min(A1,A....) compared with usual maxi + feval
+
+m = 10;
+n = 20;
+A1 = sprand(m,n,10);
+A2 = sprand(m,n,10);
+A3 = sprand(m,n,10);
+A4 = sprand(m,n,10);
+deff('[y]=g(i,j)','[y,k]=min([A1(i,j),A2(i,j),A3(i,j),A4(i,j)]);y=y+%i*k');
+A = feval(1:m,1:n,g);
+Am = real(A);Ak = imag(A);
+Am1 = min(A1, A2, A3, A4);
+
+assert_checkequal(Am1, sparse(Am));
+
+// test min(list(A1,A2,..)) compared to min(A1,..)
+
+Al = min(list(A1, A2, A3, A4));
+assert_checkequal(Al, sparse(Am));
+
+// test min(A,'c') and min(A,'r') 
+// min(A,'r') returns a row vector which contains min for each column
+
+[Am] = min(A1, 'r');
+nc = size(A1, 'c');
+Am1 = [];
+for i = 1:nc
+    [am] = min(A1(:,i));
+    Am1 = [Am1, am];
+end
+assert_checkequal(Am, sparse(Am1));
+
+// min(A,'c');
+
+[Am] = min(A1, 'c');
+nc = size(A1, 'r');
+Am1 = [];
+for i = 1:nc
+    [am] = min(A1(i,:));
+    Am1 = [Am1; am];
+end
+assert_checkequal(Am, sparse(Am1));
index 5f2e15d..aa0dc19 100644 (file)
@@ -16,7 +16,6 @@ src/c/spSolve.c
 
 SPARSE_FORTRAN_SOURCES = src/fortran/spcompack.f \
 src/fortran/wsposp.f \
-src/fortran/dspmax.f \
 src/fortran/findl.f \
 src/fortran/spcho1.f \
 src/fortran/dspful.f \
@@ -101,7 +100,6 @@ src/fortran/dsosp.f \
 src/fortran/dspmat.f \
 src/fortran/wspmsp.f \
 src/fortran/lspis.f \
-src/fortran/dspmin.f \
 src/fortran/writebuf.f \
 src/fortran/ta2lpd.f
 
@@ -122,9 +120,7 @@ sci_gateway/c/sci_luget.c \
 sci_gateway/c/sci_ordmmd.c \
 sci_gateway/c/sci_spget.c \
 sci_gateway/c/sci_spclean.c \
-sci_gateway/c/sci_spmin.c \
 sci_gateway/c/sci_spchol.c \
-sci_gateway/c/sci_spmax.c \
 sci_gateway/c/sci_lusolve.c \
 sci_gateway/c/sci_fadj2sp.c \
 sci_gateway/c/gw_sparse.c \
@@ -150,7 +146,6 @@ sci_gateway/fortran/sci_f_ordmmd.f \
 sci_gateway/fortran/sci_f_spget.f \
 sci_gateway/fortran/sci_f_spclean.f \
 sci_gateway/fortran/sci_f_spchol.f \
-sci_gateway/fortran/sci_f_spmax.f \
 sci_gateway/fortran/sci_f_lusolve.f \
 sci_gateway/fortran/sci_f_fadj2sp.f \
 sci_gateway/fortran/sci_f_sfinit.f \
@@ -190,7 +185,7 @@ modulename=sparse
 
 #### sparse : Conf files ####
 libscisparse_la_rootdir = $(mydatadir)
-libscisparse_la_root_DATA =  license.txt 
+libscisparse_la_root_DATA =  license.txt
 
 
 ####┬ásparse : init scripts ####
index b2f25f8..3e6d87f 100644 (file)
@@ -140,22 +140,21 @@ am__objects_1 = libscisparse_algo_la-spUtils.lo \
        libscisparse_algo_la-spOutput.lo \
        libscisparse_algo_la-spAllocate.lo \
        libscisparse_algo_la-spSolve.lo
-am__objects_2 = spcompack.lo wsposp.lo dspmax.lo findl.lo spcho1.lo \
-       dspful.lo blkslv.lo wspcle.lo wspt.lo wspssp.lo lspmat.lo \
-       lsosp.lo blkfc1.lo wspxsp.lo lspful.lo blkfct.lo symfct.lo \
-       dspt.lo wspos.lo dful2sp.lo sputil.lo lspt.lo dspxs.lo \
-       sp2col.lo dcompa.lo sz2ptr.lo spt.lo lcompa.lo wspmat.lo \
-       iperm.lo wspful.lo spif1b.lo spextr.lo lful2sp.lo dspos.lo \
-       dspasp.lo inpnv.lo spreshape.lo spsort.lo wperm.lo dij2sp.lo \
-       dspcsp.lo spcho2.lo lspos.lo wspe2.lo spif.lo lspasp.lo \
-       dspisp.lo wful2sp.lo lij2sp.lo lspcsp.lo wspis.lo dspmsp.lo \
-       dsposp.lo wsmsp.lo wspms.lo lspisp.lo dspcle.lo wsosp.lo \
-       dspssp.lo lsposp.lo dspxsp.lo ordmmd.lo spextr1.lo wcompa.lo \
-       lspxsp.lo spisp.lo dperm.lo spind.lo dspe2.lo wspasp.lo \
-       wij2sp.lo wspcsp.lo lspops.lo spifp.lo isort1.lo dspis.lo \
-       wspxs.lo lspe2.lo wspisp.lo dsmsp.lo dspms.lo spord.lo \
-       dsosp.lo dspmat.lo wspmsp.lo lspis.lo dspmin.lo writebuf.lo \
-       ta2lpd.lo
+am__objects_2 = spcompack.lo wsposp.lo findl.lo spcho1.lo dspful.lo \
+       blkslv.lo wspcle.lo wspt.lo wspssp.lo lspmat.lo lsosp.lo \
+       blkfc1.lo wspxsp.lo lspful.lo blkfct.lo symfct.lo dspt.lo \
+       wspos.lo dful2sp.lo sputil.lo lspt.lo dspxs.lo sp2col.lo \
+       dcompa.lo sz2ptr.lo spt.lo lcompa.lo wspmat.lo iperm.lo \
+       wspful.lo spif1b.lo spextr.lo lful2sp.lo dspos.lo dspasp.lo \
+       inpnv.lo spreshape.lo spsort.lo wperm.lo dij2sp.lo dspcsp.lo \
+       spcho2.lo lspos.lo wspe2.lo spif.lo lspasp.lo dspisp.lo \
+       wful2sp.lo lij2sp.lo lspcsp.lo wspis.lo dspmsp.lo dsposp.lo \
+       wsmsp.lo wspms.lo lspisp.lo dspcle.lo wsosp.lo dspssp.lo \
+       lsposp.lo dspxsp.lo ordmmd.lo spextr1.lo wcompa.lo lspxsp.lo \
+       spisp.lo dperm.lo spind.lo dspe2.lo wspasp.lo wij2sp.lo \
+       wspcsp.lo lspops.lo spifp.lo isort1.lo dspis.lo wspxs.lo \
+       lspe2.lo wspisp.lo dsmsp.lo dspms.lo spord.lo dsosp.lo \
+       dspmat.lo wspmsp.lo lspis.lo writebuf.lo ta2lpd.lo
 am_libscisparse_algo_la_OBJECTS = $(am__objects_1) $(am__objects_2)
 libscisparse_algo_la_OBJECTS = $(am_libscisparse_algo_la_OBJECTS)
 @MAINTAINER_MODE_FALSE@am_libscisparse_algo_la_rpath =
@@ -170,8 +169,7 @@ am__objects_3 = libscisparse_la-sci_spcompa.lo \
        libscisparse_la-sci_symfcti.lo libscisparse_la-sci_mfull.lo \
        libscisparse_la-sci_luget.lo libscisparse_la-sci_ordmmd.lo \
        libscisparse_la-sci_spget.lo libscisparse_la-sci_spclean.lo \
-       libscisparse_la-sci_spmin.lo libscisparse_la-sci_spchol.lo \
-       libscisparse_la-sci_spmax.lo libscisparse_la-sci_lusolve.lo \
+       libscisparse_la-sci_spchol.lo libscisparse_la-sci_lusolve.lo \
        libscisparse_la-sci_fadj2sp.lo libscisparse_la-gw_sparse.lo \
        libscisparse_la-sci_sfinit.lo libscisparse_la-sci_sparse.lo \
        libscisparse_la-sci_mspget.lo
@@ -180,8 +178,8 @@ am__objects_4 = sci_f_spcompa.lo sci_f_sparse.lo sci_f_full.lo \
        sci_f_bfinit.lo spops.lo sci_f_spmatrix.lo sci_f_blkfc1i.lo \
        sci_f_lufact.lo sci_f_symfcti.lo sci_f_luget.lo \
        sci_f_ordmmd.lo sci_f_spget.lo sci_f_spclean.lo \
-       sci_f_spchol.lo sci_f_spmax.lo sci_f_lusolve.lo \
-       sci_f_fadj2sp.lo sci_f_sfinit.lo sci_f_ta2lpd.lo
+       sci_f_spchol.lo sci_f_lusolve.lo sci_f_fadj2sp.lo \
+       sci_f_sfinit.lo sci_f_ta2lpd.lo
 am_libscisparse_la_OBJECTS = $(am__objects_3) $(am__objects_4)
 libscisparse_la_OBJECTS = $(am_libscisparse_la_OBJECTS)
 @MAINTAINER_MODE_FALSE@am_libscisparse_la_rpath =
@@ -484,7 +482,6 @@ src/c/spSolve.c
 # src/c/spFortran.c
 SPARSE_FORTRAN_SOURCES = src/fortran/spcompack.f \
 src/fortran/wsposp.f \
-src/fortran/dspmax.f \
 src/fortran/findl.f \
 src/fortran/spcho1.f \
 src/fortran/dspful.f \
@@ -569,7 +566,6 @@ src/fortran/dsosp.f \
 src/fortran/dspmat.f \
 src/fortran/wspmsp.f \
 src/fortran/lspis.f \
-src/fortran/dspmin.f \
 src/fortran/writebuf.f \
 src/fortran/ta2lpd.f
 
@@ -590,9 +586,7 @@ sci_gateway/c/sci_luget.c \
 sci_gateway/c/sci_ordmmd.c \
 sci_gateway/c/sci_spget.c \
 sci_gateway/c/sci_spclean.c \
-sci_gateway/c/sci_spmin.c \
 sci_gateway/c/sci_spchol.c \
-sci_gateway/c/sci_spmax.c \
 sci_gateway/c/sci_lusolve.c \
 sci_gateway/c/sci_fadj2sp.c \
 sci_gateway/c/gw_sparse.c \
@@ -618,7 +612,6 @@ sci_gateway/fortran/sci_f_ordmmd.f \
 sci_gateway/fortran/sci_f_spget.f \
 sci_gateway/fortran/sci_f_spclean.f \
 sci_gateway/fortran/sci_f_spchol.f \
-sci_gateway/fortran/sci_f_spmax.f \
 sci_gateway/fortran/sci_f_lusolve.f \
 sci_gateway/fortran/sci_f_fadj2sp.f \
 sci_gateway/fortran/sci_f_sfinit.f \
@@ -651,7 +644,7 @@ modulename = sparse
 
 #### sparse : Conf files ####
 libscisparse_la_rootdir = $(mydatadir)
-libscisparse_la_root_DATA = license.txt 
+libscisparse_la_root_DATA = license.txt
 
 ####┬ásparse : init scripts ####
 libscisparse_la_etcdir = $(mydatadir)/etc
@@ -851,8 +844,6 @@ distclean-compile:
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libscisparse_la-sci_spcompa.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libscisparse_la-sci_spget.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libscisparse_la-sci_spmatrix.Plo@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libscisparse_la-sci_spmax.Plo@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libscisparse_la-sci_spmin.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libscisparse_la-sci_symfcti.Plo@am__quote@
 
 .c.o:
@@ -1051,13 +1042,6 @@ libscisparse_la-sci_spclean.lo: sci_gateway/c/sci_spclean.c
 @AMDEP_TRUE@@am__fastdepCC_FALSE@      DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
 @am__fastdepCC_FALSE@  $(LIBTOOL)  --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libscisparse_la_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o libscisparse_la-sci_spclean.lo `test -f 'sci_gateway/c/sci_spclean.c' || echo '$(srcdir)/'`sci_gateway/c/sci_spclean.c
 
-libscisparse_la-sci_spmin.lo: sci_gateway/c/sci_spmin.c
-@am__fastdepCC_TRUE@   $(LIBTOOL)  --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libscisparse_la_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT libscisparse_la-sci_spmin.lo -MD -MP -MF $(DEPDIR)/libscisparse_la-sci_spmin.Tpo -c -o libscisparse_la-sci_spmin.lo `test -f 'sci_gateway/c/sci_spmin.c' || echo '$(srcdir)/'`sci_gateway/c/sci_spmin.c
-@am__fastdepCC_TRUE@   $(am__mv) $(DEPDIR)/libscisparse_la-sci_spmin.Tpo $(DEPDIR)/libscisparse_la-sci_spmin.Plo
-@AMDEP_TRUE@@am__fastdepCC_FALSE@      source='sci_gateway/c/sci_spmin.c' object='libscisparse_la-sci_spmin.lo' libtool=yes @AMDEPBACKSLASH@
-@AMDEP_TRUE@@am__fastdepCC_FALSE@      DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
-@am__fastdepCC_FALSE@  $(LIBTOOL)  --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libscisparse_la_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o libscisparse_la-sci_spmin.lo `test -f 'sci_gateway/c/sci_spmin.c' || echo '$(srcdir)/'`sci_gateway/c/sci_spmin.c
-
 libscisparse_la-sci_spchol.lo: sci_gateway/c/sci_spchol.c
 @am__fastdepCC_TRUE@   $(LIBTOOL)  --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libscisparse_la_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT libscisparse_la-sci_spchol.lo -MD -MP -MF $(DEPDIR)/libscisparse_la-sci_spchol.Tpo -c -o libscisparse_la-sci_spchol.lo `test -f 'sci_gateway/c/sci_spchol.c' || echo '$(srcdir)/'`sci_gateway/c/sci_spchol.c
 @am__fastdepCC_TRUE@   $(am__mv) $(DEPDIR)/libscisparse_la-sci_spchol.Tpo $(DEPDIR)/libscisparse_la-sci_spchol.Plo
@@ -1065,13 +1049,6 @@ libscisparse_la-sci_spchol.lo: sci_gateway/c/sci_spchol.c
 @AMDEP_TRUE@@am__fastdepCC_FALSE@      DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
 @am__fastdepCC_FALSE@  $(LIBTOOL)  --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libscisparse_la_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o libscisparse_la-sci_spchol.lo `test -f 'sci_gateway/c/sci_spchol.c' || echo '$(srcdir)/'`sci_gateway/c/sci_spchol.c
 
-libscisparse_la-sci_spmax.lo: sci_gateway/c/sci_spmax.c
-@am__fastdepCC_TRUE@   $(LIBTOOL)  --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libscisparse_la_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT libscisparse_la-sci_spmax.lo -MD -MP -MF $(DEPDIR)/libscisparse_la-sci_spmax.Tpo -c -o libscisparse_la-sci_spmax.lo `test -f 'sci_gateway/c/sci_spmax.c' || echo '$(srcdir)/'`sci_gateway/c/sci_spmax.c
-@am__fastdepCC_TRUE@   $(am__mv) $(DEPDIR)/libscisparse_la-sci_spmax.Tpo $(DEPDIR)/libscisparse_la-sci_spmax.Plo
-@AMDEP_TRUE@@am__fastdepCC_FALSE@      source='sci_gateway/c/sci_spmax.c' object='libscisparse_la-sci_spmax.lo' libtool=yes @AMDEPBACKSLASH@
-@AMDEP_TRUE@@am__fastdepCC_FALSE@      DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
-@am__fastdepCC_FALSE@  $(LIBTOOL)  --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libscisparse_la_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o libscisparse_la-sci_spmax.lo `test -f 'sci_gateway/c/sci_spmax.c' || echo '$(srcdir)/'`sci_gateway/c/sci_spmax.c
-
 libscisparse_la-sci_lusolve.lo: sci_gateway/c/sci_lusolve.c
 @am__fastdepCC_TRUE@   $(LIBTOOL)  --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(libscisparse_la_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -MT libscisparse_la-sci_lusolve.lo -MD -MP -MF $(DEPDIR)/libscisparse_la-sci_lusolve.Tpo -c -o libscisparse_la-sci_lusolve.lo `test -f 'sci_gateway/c/sci_lusolve.c' || echo '$(srcdir)/'`sci_gateway/c/sci_lusolve.c
 @am__fastdepCC_TRUE@   $(am__mv) $(DEPDIR)/libscisparse_la-sci_lusolve.Tpo $(DEPDIR)/libscisparse_la-sci_lusolve.Plo
@@ -1129,9 +1106,6 @@ spcompack.lo: src/fortran/spcompack.f
 wsposp.lo: src/fortran/wsposp.f
        $(LIBTOOL)  --tag=F77 $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(F77) $(AM_FFLAGS) $(FFLAGS) -c -o wsposp.lo `test -f 'src/fortran/wsposp.f' || echo '$(srcdir)/'`src/fortran/wsposp.f
 
-dspmax.lo: src/fortran/dspmax.f
-       $(LIBTOOL)  --tag=F77 $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(F77) $(AM_FFLAGS) $(FFLAGS) -c -o dspmax.lo `test -f 'src/fortran/dspmax.f' || echo '$(srcdir)/'`src/fortran/dspmax.f
-
 findl.lo: src/fortran/findl.f
        $(LIBTOOL)  --tag=F77 $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(F77) $(AM_FFLAGS) $(FFLAGS) -c -o findl.lo `test -f 'src/fortran/findl.f' || echo '$(srcdir)/'`src/fortran/findl.f
 
@@ -1384,9 +1358,6 @@ wspmsp.lo: src/fortran/wspmsp.f
 lspis.lo: src/fortran/lspis.f
        $(LIBTOOL)  --tag=F77 $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(F77) $(AM_FFLAGS) $(FFLAGS) -c -o lspis.lo `test -f 'src/fortran/lspis.f' || echo '$(srcdir)/'`src/fortran/lspis.f
 
-dspmin.lo: src/fortran/dspmin.f
-       $(LIBTOOL)  --tag=F77 $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(F77) $(AM_FFLAGS) $(FFLAGS) -c -o dspmin.lo `test -f 'src/fortran/dspmin.f' || echo '$(srcdir)/'`src/fortran/dspmin.f
-
 writebuf.lo: src/fortran/writebuf.f
        $(LIBTOOL)  --tag=F77 $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(F77) $(AM_FFLAGS) $(FFLAGS) -c -o writebuf.lo `test -f 'src/fortran/writebuf.f' || echo '$(srcdir)/'`src/fortran/writebuf.f
 
@@ -1447,9 +1418,6 @@ sci_f_spclean.lo: sci_gateway/fortran/sci_f_spclean.f
 sci_f_spchol.lo: sci_gateway/fortran/sci_f_spchol.f
        $(LIBTOOL)  --tag=F77 $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(F77) $(AM_FFLAGS) $(FFLAGS) -c -o sci_f_spchol.lo `test -f 'sci_gateway/fortran/sci_f_spchol.f' || echo '$(srcdir)/'`sci_gateway/fortran/sci_f_spchol.f
 
-sci_f_spmax.lo: sci_gateway/fortran/sci_f_spmax.f
-       $(LIBTOOL)  --tag=F77 $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(F77) $(AM_FFLAGS) $(FFLAGS) -c -o sci_f_spmax.lo `test -f 'sci_gateway/fortran/sci_f_spmax.f' || echo '$(srcdir)/'`sci_gateway/fortran/sci_f_spmax.f
-
 sci_f_lusolve.lo: sci_gateway/fortran/sci_f_lusolve.f
        $(LIBTOOL)  --tag=F77 $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=compile $(F77) $(AM_FFLAGS) $(FFLAGS) -c -o sci_f_lusolve.lo `test -f 'sci_gateway/fortran/sci_f_lusolve.f' || echo '$(srcdir)/'`sci_gateway/fortran/sci_f_lusolve.f
 
index 5083598..971fd7d 100644 (file)
@@ -28,8 +28,8 @@ static gw_generic_table Tab[]=
     {sci_luget, "luget"},
     {sci_spclean, "spclean"},
     {sci_nnz, "nnz"},
-    {sci_spmax, "spmax"},
-    {sci_spmin, "spmin"},
+    {NULL, ""}, //spmax
+    {NULL, ""}, //spmin
     {sci_spmatrix, "spmatrix"},
     {sci_spchol, "spchol"},
     {sci_fadj2sp, "fadj2sp"},
diff --git a/scilab/modules/sparse/sci_gateway/c/sci_spmax.c b/scilab/modules/sparse/sci_gateway/c/sci_spmax.c
deleted file mode 100644 (file)
index 0e7f0d0..0000000
+++ /dev/null
@@ -1,24 +0,0 @@
-/*
- * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
- * Copyright (C) 2006 - INRIA - 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
- *
- */
-
-#include "gw_sparse.h"
-/*--------------------------------------------------------------------------*/
-extern int C2F(intspmax)(char *minmax,int *id);
-/*--------------------------------------------------------------------------*/
-int sci_spmax(char *fname,unsigned long fname_len)
-{
-       static int id[6];
-       char job[]="max";
-       C2F(intspmax)(job,id);
-       return 0;
-}
-/*--------------------------------------------------------------------------*/
diff --git a/scilab/modules/sparse/sci_gateway/c/sci_spmin.c b/scilab/modules/sparse/sci_gateway/c/sci_spmin.c
deleted file mode 100644 (file)
index a0b50e1..0000000
+++ /dev/null
@@ -1,24 +0,0 @@
-/*
- * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
- * Copyright (C) 2006 - INRIA - 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
- *
- */
-
-#include "gw_sparse.h"
-/*--------------------------------------------------------------------------*/
-extern int C2F(intspmax)(char *minmax,int *id);
-/*--------------------------------------------------------------------------*/
-int sci_spmin(char *fname,unsigned long fname_len)
-{
-       static int id[6];
-       char job[]="min";
-       C2F(intspmax)(job,id);
-       return 0;
-}
-/*--------------------------------------------------------------------------*/
diff --git a/scilab/modules/sparse/sci_gateway/fortran/sci_f_spmax.f b/scilab/modules/sparse/sci_gateway/fortran/sci_f_spmax.f
deleted file mode 100644 (file)
index c054112..0000000
+++ /dev/null
@@ -1,200 +0,0 @@
-c Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
-c Copyright (C) INRIA
-c 
-c This file must be used under the terms of the CeCILL.
-c This source file is licensed as described in the file COPYING, which
-c you should have received as part of this distribution.  The terms
-c are also available at    
-c http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
-      subroutine intspmax(fname,id)
-      include 'stack.h'
-      integer id(nsiz),top0
-      character*(*) fname
-      double precision tv
-      integer iadr, sadr
-
-      iadr(l)=l+l-1
-      sadr(l)=(l/2)+1
-
-      rhs = max(0,rhs)
-      top0=top+1-rhs
-
-      if (rhs .lt. 1) then
-         call error(39)
-         return
-      endif
-
-      lw = lstk(top+1)
-      l0 = lstk(top+1-rhs)
-      if (rhs.eq.1) then
-         if (lhs .gt.2) then
-            call error(41)
-            return
-         endif
-         il1 = iadr(lstk(top))
-         if (istk(il1) .ne. 5) then
-            err=1
-            call error(217)
-            return
-         endif
-         m1=istk(il1+1)
-         n1=istk(il1+2)
-         it1=istk(il1+3)
-         nel1=istk(il1+4)
-         irc1=il1+5
-         l1=sadr(irc1+m1+nel1)
-         if(it1.ne.0) then
-            err=1
-            call error(52)
-            return
-         endif
-         tv=0.0d0
-         if(nel1.gt.0) then
-            tv=stk(l1)
-            im=0
-            if(fin.eq.10) then
-               do 60 i=0,nel1-1
-                  if (stk(l1+i).gt.tv) then
-                     tv=stk(l1+i)
-                     im=i
-                  endif
- 60            continue
-               if(tv.lt.0.0d0.and.nel1.lt.m1*n1) tv=0.0d0
-            else
-               do 61 i=0,nel1-1
-                  if (stk(l1+i).lt.tv) then
-                     tv=stk(l1+i)
-                     im=i
-                  endif
- 61            continue
-               if(tv.gt.0.0d0.and.nel1.lt.m1*n1) tv=0.0d0
-            endif
-         endif
-c
-         if(lhs.eq.2) then
-            if (nel1.ne.0) then
-               jm=istk(irc1+m1+im)
-               im=im+1
-               ii=0
-               do 62 i=0,m1-1
-                  ii=ii+istk(irc1+i)
-                  if(ii.ge.im) goto 63
- 62            continue
- 63            im=i+1
-            endif
-         endif
-c
-         istk(il1)=1
-         istk(il1+1)=1
-         istk(il1+2)=1
-         istk(il1+3)=0
-         l=sadr(il1+4)
-         stk(l)=tv
-         lstk(top+1)=l+1
-         if(lhs.eq.2) then
-            top=top+1
-            il2=iadr(lstk(top))
-            err=lstk(top)+4-lstk(bot)
-            if(err.gt.0) then
-               call error(17)
-               return
-            endif
-            istk(il2)=1
-            l=sadr(il2+4)
-            istk(il2+3)=0
-            if (nel1.ne.0) then
-               istk(il2+1)=1
-               istk(il2+2)=1
-               stk(l)=im+(jm-1)*m1
-               lstk(top+1)=l+1
-            else
-               istk(il2+1)=0
-               istk(il2+2)=0
-               lstk(top+1)=l+1
-            endif
-         endif
-         return
-      endif
-c     
-c     checking variable sp2 (number 2)
-c
-      if (lhs .ne. 1) then
-         call error(41)
-         return
-      endif
-      do 65 i=1,rhs-1
-         il2 = iadr(lstk(top))
-         if (istk(il2) .ne. 5) then
-            err=2
-            call error(217)
-            return
-         endif
-
-         m2=istk(il2+1)
-         n2=istk(il2+2)
-         it2=istk(il2+3)
-         nel2=istk(il2+4)
-         irc2=il2+5
-         if(it2.ne.0) then
-            err=2
-            call error(52)
-            return
-         endif
-         l2=sadr(irc2+m2+nel2)
-c     
-c     checking variable sp1 (number 1)
-c     
-         top=top-1
-         il1 = iadr(lstk(top))
-         if (istk(il1) .ne. 5) then
-            err=1
-            call error(217)
-            return
-         endif
-         m1=istk(il1+1)
-         n1=istk(il1+2)
-         it1=istk(il1+3)
-         nel1=istk(il1+4)
-         irc1=il1+5
-         l1=sadr(irc1+m1+nel1)
-
-         if(it1.ne.0) then
-            err=1
-            call error(52)
-            return
-         endif
-         if(m1.ne.m2.or.n1.ne.n2) then
-            call error(60)
-            return
-         endif
-         irc=iadr(lw)
-         nelmx=(iadr(lstk(bot))-irc-m1-10)/3
-         lc=sadr(irc+m1+nelmx)
-         lw=lc+nelmx
-         err=lw-lstk(bot)
-         if(err.gt.0) then
-            call error(17)
-            return
-         endif  
-         nel=nelmx
-         if(fname.eq.'max') then
-            call dspmax(m1,n1,stk(l1),nel1,istk(irc1),stk(l2),nel2,
-     $           istk(irc2),stk(lc),nel,istk(irc),ierr)
-         else
-            call dspmin(m1,n1,stk(l1),nel1,istk(irc1),stk(l2),nel2,
-     $           istk(irc2),stk(lc),nel,istk(irc),ierr)
-         endif
-         if(ierr.ne.0) then
-            call error(17)
-            return
-         endif
-         istk(il1+3)=0
-         istk(il1+4)=nel
-         call icopy(m1+nel,istk(irc),1,istk(irc1),1)
-         l1=sadr(irc1+m1+nel)
-         call unsfdcopy(nel,stk(lc),1,stk(l1),1)
-         lstk(top+1)=l1+nel
- 65   continue
-      return
-      end
-c                      ======================================
index b54808f..e0644b1 100644 (file)
@@ -216,8 +216,6 @@ lib /DEF:"$(ProjectDir)elementary_functions_f_Import.def" /SUBSYSTEM:WINDOWS /MA
     <ClCompile Include="..\..\sci_gateway\c\sci_spcompa.c" />
     <ClCompile Include="..\..\sci_gateway\c\sci_spget.c" />
     <ClCompile Include="..\..\sci_gateway\c\sci_spmatrix.c" />
-    <ClCompile Include="..\..\sci_gateway\c\sci_spmax.c" />
-    <ClCompile Include="..\..\sci_gateway\c\sci_spmin.c" />
     <ClCompile Include="..\..\sci_gateway\c\sci_symfcti.c" />
     <ClCompile Include="spAllocate.c" />
     <ClCompile Include="spBuild.c" />
index db18988..f8711ee 100644 (file)
     <ClCompile Include="..\..\sci_gateway\c\sci_spmatrix.c">
       <Filter>Source Files</Filter>
     </ClCompile>
-    <ClCompile Include="..\..\sci_gateway\c\sci_spmax.c">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-    <ClCompile Include="..\..\sci_gateway\c\sci_spmin.c">
-      <Filter>Source Files</Filter>
-    </ClCompile>
     <ClCompile Include="..\..\sci_gateway\c\sci_symfcti.c">
       <Filter>Source Files</Filter>
     </ClCompile>
diff --git a/scilab/modules/sparse/src/fortran/dspmax.f b/scilab/modules/sparse/src/fortran/dspmax.f
deleted file mode 100644 (file)
index f4adea2..0000000
+++ /dev/null
@@ -1,133 +0,0 @@
-c Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
-c Copyright (C) INRIA
-c 
-c This file must be used under the terms of the CeCILL.
-c This source file is licensed as described in the file COPYING, which
-c you should have received as part of this distribution.  The terms
-c are also available at    
-c http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
-      subroutine dspmax(nr,nc,a,nela,inda,b,nelb,indb,c,nelc,indc,ierr)
-c!pupose
-c     computes the sparse matrix formed with maximum elementwise of two 
-c     sparse matrices.
-c!parameters     
-c     a,b,c : arrays. 
-c             Contain non zero elements of first,second and sum matrices.
-c     nr : integer: row dimension of a b c matrices
-c     nc : integer: column dimension of a b c matrices
-c     nela :integer: number of non zero elements of a
-c     nelb :integer: number of non zero elements of b
-c     nelc :integer: 
-c            on entry maximum number  of non zero elements of c
-c            on return number of non zero elements of c
-c     inda : a matrix control data:
-c            inda(i) 1<=i<=nr contains the number of ith row non zero elements
-c            of a
-c            inda(m+i) 1<=i<=nela column index of each non zero element
-c     indb : b matrix control data:
-c            indb(i) 1<=i<=nr contains the number of ith row non zero elements
-c            of b
-c            indb(m+i) 1<=i<=nelb column index of each non zero element
-c
-c     indc : on return contains c matrix control data:
-c            indc(i) 1<=i<=nr contains the number of ith row non zero elements
-c            of c
-c            indc(m+i) 1<=i<=nelb column index of each non zero element
-c     ierr : if non zero initial value of nelc is to small
-c!
-
-      double precision a(*),b(*),c(*)
-      integer nr,nc,nela,inda(*),nelb,indb(*),nelc,indc(*),ierr
-c
-      integer jc,ka,kb,jb,kf,i,ka1,ja,j1,j2,nold
-c     
-      nelmx=nelc
-      ierr=0
-c     clear indc.
-      do 1 i = 1,nr
-         indc(i) = 0
- 1    continue
-c     jc counts elements of c.
-      jc     = 1
-c     ka,kb are numbers in first i rows of a,b.
-      ka     = 0
-      kb     = 0
-c     kf is number of control data in a,b or c.
-      kf     = nr
-c     jb counts elements of b.
-      jb     = 1
-c     i counts rows of a,b,c.
-      do 15 i=1,nr
-         kb      = kb+indb(i)
-c     nira is number in row i of a.
-         nira    = inda(i)
-         if (nira.eq.0) go to 12
-         ka1     = ka+1
-         ka      = ka+nira
-c     ja counts elements of a.
-         do 11 ja= ka1,ka
- 6          j1     = inda(ja+kf)
-c     at end of b-row transfer rest of a-row.
-            if (jb.gt.kb) then
-               if(a(ja).gt.0.0d0) then
-                  if (jc.gt.nelmx) go to 16
-                  c(jc)  = a(ja)
-                  indc(jc+kf)=j1
-                  jc     = jc+1
-               endif
-               goto 11
-            endif
-            j2     = indb(jb+kf)
-            if(j1.lt.j2) then
-c     if a-index less than b-index transfer a-element to c.
-               if(a(ja).gt.0.0d0) then
-                  if (jc.gt.nelmx) go to 16
-                  c(jc)  = a(ja)
-                  indc(jc+kf)=j1
-                  jc     = jc+1
-               endif
-            elseif(j1.eq.j2) then
-               if (jc.gt.nelmx) go to 16
-               c(jc)  = max(a(ja),b(jb))
-               jb     = jb+1
-               indc(jc+kf)=j1
-               jc     = jc+1
-            else
-c     if a-index greater than b-index transfer b-element to c.
-               if(b(jb).gt.0.0d0) then
-                  if (jc.gt.nelmx) go to 16
-                  c(jc)  = b(jb)
-                  indc(jc+kf)=j2
-                  jc     = jc+1
-               endif
-               jb     = jb+1
-               go to 6
-            endif
- 11      continue
-c     end of row of a.  transfer rest of row of b.
- 12      if (jb.gt.kb) go to 13
-         if(b(jb).gt.0.0d0) then
-            if (jc.gt.nelmx) go to 16
-            c(jc) = b(jb)
-            j2    = indb(jb+kf)
-            indc(jc+kf)=j2
-            jc    = jc+1
-         endif
-         jb      = jb+1
-         go to 12
- 13      if (i.gt.1) go to 14
-         nold  = jc-1
-c     nirc is number in row i of c.
-         nirc  = jc-1
-         go to 15
- 14      nirc   = jc-1-nold
-         nold  = jc-1
- 15      indc(i)=nirc
-         nelc  = jc-1
-         return
-c     error messages.
- 16      ierr=1
-c     no more place for c
-
-         return 
-         end
diff --git a/scilab/modules/sparse/src/fortran/dspmin.f b/scilab/modules/sparse/src/fortran/dspmin.f
deleted file mode 100644 (file)
index 1971cda..0000000
+++ /dev/null
@@ -1,132 +0,0 @@
-c Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
-c Copyright (C) INRIA
-c 
-c This file must be used under the terms of the CeCILL.
-c This source file is licensed as described in the file COPYING, which
-c you should have received as part of this distribution.  The terms
-c are also available at    
-c http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
-      subroutine dspmin(nr,nc,a,nela,inda,b,nelb,indb,c,nelc,indc,ierr)
-c!pupose
-c     computes the sparse matrix formed with mimimum elementwise of two 
-c     sparse matrices.
-c!parameters     
-c     a,b,c : arrays. 
-c             Contain non zero elements of first,second and sum matrices.
-c     nr : integer: row dimension of a b c matrices
-c     nc : integer: column dimension of a b c matrices
-c     nela :integer: number of non zero elements of a
-c     nelb :integer: number of non zero elements of b
-c     nelc :integer: 
-c            on entry maximum number  of non zero elements of c
-c            on return number of non zero elements of c
-c     inda : a matrix control data:
-c            inda(i) 1<=i<=nr contains the number of ith row non zero elements
-c            of a
-c            inda(m+i) 1<=i<=nela column index of each non zero element
-c     indb : b matrix control data:
-c            indb(i) 1<=i<=nr contains the number of ith row non zero elements
-c            of b
-c            indb(m+i) 1<=i<=nelb column index of each non zero element
-c
-c     indc : on return contains c matrix control data:
-c            indc(i) 1<=i<=nr contains the number of ith row non zero elements
-c            of c
-c            indc(m+i) 1<=i<=nelb column index of each non zero element
-c     ierr : if non zero initial value of nelc is to small
-c!
-      double precision a(*),b(*),c(*)
-      integer nr,nc,nela,inda(*),nelb,indb(*),nelc,indc(*),ierr
-c
-      integer jc,ka,kb,jb,kf,i,ka1,ja,j1,j2,nold
-c     
-      nelmx=nelc
-      ierr=0
-c     clear indc.
-      do 1 i = 1,nr
-         indc(i) = 0
- 1    continue
-c     jc counts elements of c.
-      jc     = 1
-c     ka,kb are numbers in first i rows of a,b.
-      ka     = 0
-      kb     = 0
-c     kf is number of control data in a,b or c.
-      kf     = nr
-c     jb counts elements of b.
-      jb     = 1
-c     i counts rows of a,b,c.
-      do 15 i=1,nr
-         kb      = kb+indb(i)
-c     nira is number in row i of a.
-         nira    = inda(i)
-         if (nira.eq.0) go to 12
-         ka1     = ka+1
-         ka      = ka+nira
-c     ja counts elements of a.
-         do 11 ja= ka1,ka
- 6          j1     = inda(ja+kf)
-c     at end of b-row transfer rest of a-row.
-            if (jb.gt.kb) then
-               if(a(ja).lt.0.0d0) then
-                  if (jc.gt.nelmx) go to 16
-                  c(jc)  = a(ja)
-                  indc(jc+kf)=j1
-                  jc     = jc+1
-               endif
-               goto 11
-            endif
-            j2     = indb(jb+kf)
-            if(j1.lt.j2) then
-c     if a-index less than b-index transfer a-element to c.
-               if(a(ja).lt.0.0d0) then
-                  if (jc.gt.nelmx) go to 16
-                  c(jc)  = a(ja)
-                  indc(jc+kf)=j1
-                  jc     = jc+1
-               endif
-            elseif(j1.eq.j2) then
-               if (jc.gt.nelmx) go to 16
-               c(jc)  = min(a(ja),b(jb))
-               jb     = jb+1
-               indc(jc+kf)=j1
-               jc     = jc+1
-            else
-c     if a-index greater than b-index transfer b-element to c.
-               if(b(jb).lt.0.0d0) then
-                  if (jc.gt.nelmx) go to 16
-                  c(jc)  = b(jb)
-                  indc(jc+kf)=j2
-                  jc     = jc+1
-               endif
-               jb     = jb+1
-               go to 6
-            endif
- 11      continue
-c     end of row of a.  transfer rest of row of b.
- 12      if (jb.gt.kb) go to 13
-         if(b(jb).lt.0.0d0) then
-            if (jc.gt.nelmx) go to 16
-            c(jc) = b(jb)
-            j2    = indb(jb+kf)
-            indc(jc+kf)=j2
-            jc    = jc+1
-         endif
-         jb      = jb+1
-         go to 12
- 13      if (i.gt.1) go to 14
-         nold  = jc-1
-c     nirc is number in row i of c.
-         nirc  = jc-1
-         go to 15
- 14      nirc   = jc-1-nold
-         nold  = jc-1
- 15      indc(i)=nirc
-         nelc  = jc-1
-         return
-c     error messages.
- 16      ierr=1
-c     no more place for c
-
-         return 
-         end
index 4d80061..c9b745f 100644 (file)
@@ -176,7 +176,6 @@ lib /DEF:&quot;$(InputDir)core_f_Import.def&quot; /SUBSYSTEM:WINDOWS /MACHINE:X6
                <File RelativePath="..\..\sci_gateway\fortran\sci_f_spcompa.f"/>
                <File RelativePath="..\..\sci_gateway\fortran\sci_f_spget.f"/>
                <File RelativePath="..\..\sci_gateway\fortran\sci_f_spmatrix.f"/>
-               <File RelativePath="..\..\sci_gateway\fortran\sci_f_spmax.f"/>
                <File RelativePath="..\..\sci_gateway\fortran\sci_f_symfcti.f"/>
                <File RelativePath="..\..\sci_gateway\fortran\sci_f_ta2lpd.f"/>
                <File RelativePath="sp2col.f"/>
diff --git a/scilab/modules/sparse/tests/nonreg_tests/bug_11612.dia.ref b/scilab/modules/sparse/tests/nonreg_tests/bug_11612.dia.ref
new file mode 100644 (file)
index 0000000..78dc6ba
--- /dev/null
@@ -0,0 +1,106 @@
+// =============================================================================
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2012 - Scilab Enterprises - Adeline CARNIS
+//
+//  This file is distributed under the same license as the Scilab package.
+// =============================================================================
+// <-- CLI SHELL MODE -->
+// <-- Non-regression test for bug 11612 -->
+//
+// <-- Bugzilla URL -->
+// http://bugzilla.scilab.org/show_bug.cgi?id=11612
+//
+// <-- Short Description -->
+// index of the max value of a negative sparse was wrong
+a = -1 * rand(3,2);
+a(2) = 0;
+A = sparse(a);
+[m, i] = max(a);
+[m1, i1] = max(A);
+assert_checkequal(m1,m);
+assert_checkequal(i1,i);
+[m, i] = max(a');
+[m1, i1] = max(A');
+assert_checkequal(m1,m);
+assert_checkequal(i1,i);
+[m, i] = max(a(:));
+[m1, i1] = max(A(:));
+assert_checkequal(m1,m);
+assert_checkequal(i1,i);
+[m, i] = max(a(:)');
+[m1, i1] = max(A(:)');
+assert_checkequal(m1,m);
+assert_checkequal(i1,i);
+a = [-3 -4;0 -1;-5 -6];
+A = sparse(a);
+[m, i] = max(a);
+[m1, i1] = max(A);
+assert_checkequal(m1,m);
+assert_checkequal(i1,i);
+[m, i] = max(a');
+[m1, i1] = max(A');
+assert_checkequal(m1,m);
+assert_checkequal(i1,i);
+[m, i] = max(a(:));
+[m1, i1] = max(A(:));
+assert_checkequal(m1,m);
+assert_checkequal(i1,i);
+[m, i] = max(a(:)');
+[m1, i1] = max(A(:)');
+assert_checkequal(m1,m);
+assert_checkequal(i1,i);
+b = [-5 0;-1 -6];
+B = sparse(b);
+[m, i] = max(b);
+[m1, i1] = max(B);
+assert_checkequal(m1,m);
+assert_checkequal(i1,i);
+[m, i] = max(b');
+[m1, i1] = max(B');
+assert_checkequal(m1,m);
+assert_checkequal(i1,i);
+[m, i] = max(b(:));
+[m1, i1] = max(B(:));
+assert_checkequal(m1,m);
+assert_checkequal(i1,i);
+[m, i] = max(b(:)');
+[m1, i1] = max(B(:)');
+assert_checkequal(m1,m);
+assert_checkequal(i1,i);
+s = rand(3,2);
+s(2) = 0;
+S = sparse(s);
+[m, i] = min(s);
+[m1, i1] = min(S);
+assert_checkequal(m1,m);
+assert_checkequal(i1,i);
+[m, i] = min(s');
+[m1, i1] = min(S');
+assert_checkequal(m1,m);
+assert_checkequal(i1,i);
+[m, i] = min(s(:));
+[m1, i1] = min(S(:));
+assert_checkequal(m1,m);
+assert_checkequal(i1,i);
+[m, i] = min(s(:)');
+[m1, i1] = min(S(:)');
+assert_checkequal(m1,m);
+assert_checkequal(i1,i);
+v = [1 4;7 6];
+V = sparse(v);
+[m, i] = max(v);
+[m1, i1] = max(V);
+assert_checkequal(m1,m);
+assert_checkequal(i1,i);
+[m, i] = max(v');
+[m1, i1] = max(V');
+assert_checkequal(m1,m);
+assert_checkequal(i1,i);
+[m, i] = max(v(:));
+[m1, i1] = max(V(:));
+assert_checkequal(m1,m);
+assert_checkequal(i1,i);
+[m, i] = max(v(:)');
+[m1, i1] = max(V(:)');
+assert_checkequal(m1,m);
+assert_checkequal(i1,i);
diff --git a/scilab/modules/sparse/tests/nonreg_tests/bug_11612.tst b/scilab/modules/sparse/tests/nonreg_tests/bug_11612.tst
new file mode 100644 (file)
index 0000000..6cc03a7
--- /dev/null
@@ -0,0 +1,128 @@
+// =============================================================================
+// Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+// Copyright (C) 2012 - Scilab Enterprises - Adeline CARNIS
+//
+//  This file is distributed under the same license as the Scilab package.
+// =============================================================================
+
+// <-- CLI SHELL MODE -->
+
+// <-- Non-regression test for bug 11612 -->
+//
+// <-- Bugzilla URL -->
+// http://bugzilla.scilab.org/show_bug.cgi?id=11612
+//
+// <-- Short Description -->
+// index of the max value of a negative sparse was wrong
+
+a = -1 * rand(3,2);
+a(2) = 0;
+A = sparse(a);
+[m, i] = max(a);
+[m1, i1] = max(A);
+assert_checkequal(m1,m);
+assert_checkequal(i1,i);
+
+[m, i] = max(a');
+[m1, i1] = max(A');
+assert_checkequal(m1,m);
+assert_checkequal(i1,i);
+
+[m, i] = max(a(:));
+[m1, i1] = max(A(:));
+assert_checkequal(m1,m);
+assert_checkequal(i1,i);
+
+[m, i] = max(a(:)');
+[m1, i1] = max(A(:)');
+assert_checkequal(m1,m);
+assert_checkequal(i1,i);
+
+a = [-3 -4;0 -1;-5 -6];
+A = sparse(a);
+[m, i] = max(a);
+[m1, i1] = max(A);
+assert_checkequal(m1,m);
+assert_checkequal(i1,i);
+
+[m, i] = max(a');
+[m1, i1] = max(A');
+assert_checkequal(m1,m);
+assert_checkequal(i1,i);
+
+[m, i] = max(a(:));
+[m1, i1] = max(A(:));
+assert_checkequal(m1,m);
+assert_checkequal(i1,i);
+
+[m, i] = max(a(:)');
+[m1, i1] = max(A(:)');
+assert_checkequal(m1,m);
+assert_checkequal(i1,i);
+
+b = [-5 0;-1 -6];
+B = sparse(b);
+[m, i] = max(b);
+[m1, i1] = max(B);
+assert_checkequal(m1,m);
+assert_checkequal(i1,i);
+
+[m, i] = max(b');
+[m1, i1] = max(B');
+assert_checkequal(m1,m);
+assert_checkequal(i1,i);
+
+[m, i] = max(b(:));
+[m1, i1] = max(B(:));
+assert_checkequal(m1,m);
+assert_checkequal(i1,i);
+
+[m, i] = max(b(:)');
+[m1, i1] = max(B(:)');
+assert_checkequal(m1,m);
+assert_checkequal(i1,i);
+
+s = rand(3,2);
+s(2) = 0;
+S = sparse(s);
+[m, i] = min(s);
+[m1, i1] = min(S);
+assert_checkequal(m1,m);
+assert_checkequal(i1,i);
+
+[m, i] = min(s');
+[m1, i1] = min(S');
+assert_checkequal(m1,m);
+assert_checkequal(i1,i);
+
+[m, i] = min(s(:));
+[m1, i1] = min(S(:));
+assert_checkequal(m1,m);
+assert_checkequal(i1,i);
+
+[m, i] = min(s(:)');
+[m1, i1] = min(S(:)');
+assert_checkequal(m1,m);
+assert_checkequal(i1,i);
+
+v = [1 4;7 6];
+V = sparse(v);
+[m, i] = max(v);
+[m1, i1] = max(V);
+assert_checkequal(m1,m);
+assert_checkequal(i1,i);
+
+[m, i] = max(v');
+[m1, i1] = max(V');
+assert_checkequal(m1,m);
+assert_checkequal(i1,i);
+
+[m, i] = max(v(:));
+[m1, i1] = max(V(:));
+assert_checkequal(m1,m);
+assert_checkequal(i1,i);
+
+[m, i] = max(v(:)');
+[m1, i1] = max(V(:)');
+assert_checkequal(m1,m);
+assert_checkequal(i1,i);