The gsort function did not manage the complex sparse matrices 67/8567/8
Adeline CARNIS [Mon, 6 Aug 2012 14:32:52 +0000 (16:32 +0200)]
Change-Id: I30fe943ad25202bf0e23970b42634a7afe527c55

scilab/modules/elementary_functions/macros/%sp_gsort.sci
scilab/modules/elementary_functions/tests/unit_tests/gsort.dia.ref
scilab/modules/elementary_functions/tests/unit_tests/gsort.tst

index 9b96fcc..29c7f50 100644 (file)
@@ -8,55 +8,73 @@
 // are also available at    \r
 // http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt\r
 \r
-function A = %sp_gsort(A, optsort, directionsort)\r
+function [A, k] = %sp_gsort(A, optsort, directionsort)\r
     rhs = argn(2);\r
+    lhs = argn(1);\r
+    // arguments by default in gsort\r
     select rhs\r
     case 1\r
         optsort = 'g';\r
         directionsort = 'd';\r
     case 2\r
+        // optsort can be: 'r', 'c', 'g', 'lr', 'lc'\r
+        pos_opts = find(optsort == ['r', 'c', 'g', 'lr', 'lc']);\r
+        if pos_opts == [] then\r
+            error(msprintf(_("%s: Wrong value for input argument #%d: ''%s'', ''%s'', ''%s'', ''%s'' or ''%s'' expected.\n"), "gsort", 2, "r", "c", "g", "lr", "lc"));\r
+        end\r
         directionsort = 'd';\r
+    else\r
+        // optsort can be: 'r', 'c', 'g', 'lr', 'lc'\r
+        pos_opts = find(optsort == ['r', 'c', 'g', 'lr', 'lc']);\r
+        // directionsort can be: 'd' or 'i'\r
+        pos_direction = find(directionsort == ['d', 'i']);\r
+        if pos_opts == [] then\r
+            error(msprintf(_("%s: Wrong value for input argument #%d: ''%s'', ''%s'', ''%s'', ''%s'' or ''%s'' expected.\n"), "gsort", 2, "r", "c", "g", "lr", "lc"));\r
+        end\r
+        if pos_direction == [] then\r
+            error(msprintf(_("%s: Wrong value for input argument #%d: ''%s'' or ''%s'' expected.\n"), "gsort", 3, "d", "i"));\r
+        end\r
     end\r
 \r
     [ij, v, mn] = spget(A);\r
-\r
     if mn(1) <> 1 & mn(2) <> 1 then\r
-        error(999,msprintf(_("%s: Wrong size for input argument #%d: sparse vectors expected.\n"),'gsort',1));\r
+        error(999,msprintf(_("%s: Wrong size for input argument #%d: sparse vectors expected.\n"), 'gsort', 1));\r
     end\r
 \r
-    if (strcmp(optsort, 'c')) == 0 | v == [] then\r
-        A = A;\r
-    else\r
-        if mn(2) == 1 then\r
-            dif = mn(1) - length(v);\r
-            v = gsort(v, optsort, directionsort);\r
-            \r
-            last = find(v<0);\r
-            first = find(v>0);\r
-            \r
-            if last == [] & first <> [] then\r
-                if strcmp(directionsort, 'i')== 0 then\r
-                    ij(:,1) = first(:) + dif;\r
+    if mn(1) == 1 then\r
+        // if A is a row vector and optsort = 'r', the result is the \r
+        // first input argument\r
+        if strcmp(optsort, 'r') == 0 |strcmp(optsort, 'lr') == 0 then\r
+            A = A;\r
+            if lhs == 2 then\r
+                if strcmp(optsort, 'lr') == 0 then\r
+                    k = 1;\r
                 else\r
-                    ij(:,1) = first(:);\r
-                end\r
-            elseif first == [] & last <> [] then\r
-                ij(:,1) = last(:) + dif;\r
-            else\r
-                if strcmp(directionsort, 'i')== 0 then\r
-                    ij(:,1) = [last(:); first(:) + dif];\r
-                else\r
-                    ij(:,1) = [first(:); last(:) + dif];\r
+                    k = ij(:,1);\r
+                    k = k';\r
                 end\r
             end\r
-            \r
-        elseif mn(1) == 1 then\r
+        else\r
             dif = mn(2) - length(v);\r
-            v = gsort(v, optsort, directionsort);\r
-            \r
-            last = find(v<0);\r
-            first = find(v>0);\r
-            \r
+            if lhs == 1 then\r
+                v = gsort(v', optsort, directionsort);\r
+            else\r
+                [v, k] = gsort(v', optsort, directionsort);\r
+            end\r
+\r
+            //Obtain the indices corresponding to positive values of v\r
+            // and negative value of v\r
+            // If A is complex, the elements are sorted by magnitude\r
+            if isreal(A) then\r
+                last = find(v<0);\r
+                first = find(v>0);\r
+            else\r
+                s = abs(v);\r
+                last = find(s<0);\r
+                first = find(s>0);\r
+            end\r
+\r
+            // Sort the indices\r
             if last == [] & first <> [] then\r
                 if strcmp(directionsort, 'i')== 0 then\r
                     ij(:,2) = first(:) + dif;\r
@@ -64,7 +82,11 @@ function A = %sp_gsort(A, optsort, directionsort)
                     ij(:,2) = first(:);\r
                 end\r
             elseif first == [] & last <> [] then\r
-                ij(:,1) = last(:) + dif;\r
+                if strcmp(directionsort, 'i')== 0 then\r
+                    ij(:,1) = last(:);\r
+                else\r
+                    ij(:,1) = last(:) + dif;\r
+                end\r
             else\r
                 if strcmp(directionsort, 'i')== 0 then\r
                     ij(:,2) = [last(:); first(:) + dif];\r
@@ -72,12 +94,74 @@ function A = %sp_gsort(A, optsort, directionsort)
                     ij(:,2) = [first(:); last(:) + dif];\r
                 end\r
             end\r
-            \r
+            A = sparse(ij,v,mn);\r
         end\r
-        A = sparse(ij, v, mn)\r
     end\r
 \r
-endfunction\r
+    if mn(2) == 1 then\r
+        // if A is a column vector and optsort = 'c', the result is the \r
+        // first input argument\r
+        if strcmp(optsort, 'c') == 0 | strcmp(optsort, 'lc') == 0 then\r
+            A = A;\r
+            if lhs == 2 then\r
+                if strcmp(optsort, 'lc') == 0 then\r
+                    k = 1;\r
+                else\r
+                    k = ij(:,2);\r
+                    k = k;\r
+                end\r
+            end\r
+        else\r
+\r
+            dif = mn(1) - length(v);\r
+            if lhs == 1 then\r
+                v = gsort(v, optsort, directionsort);\r
+            else\r
+                [v, k] = gsort(v, optsort, directionsort);\r
+            end\r
 \r
+            //Obtain the indices corresponding to positive values of v\r
+            // and negative value of v\r
+            // If A is complex, the elements are sorted by magnitude\r
+            if isreal(A) then\r
+                last = find(v<0);\r
+                first = find(v>0);\r
+            else\r
+                s = abs(v);\r
+                last = find(s<0);\r
+                first = find(s>0);\r
+            end\r
 \r
-\r\r
+            // sort the indices in terms of directionsort = 'i' or 'd'\r
+            // if directionsort='i' and v>0, the elements are sorted in the \r
+            // increasing order, ie [0,..,v] and, conversely, in the decreasing\r
+            // order the elements are sorted : [v,..,0]\r
+            // if v<0, the elements are sorted in the increasing order, \r
+            // ie [v,..,0] and, conversely, in the decreasing order the \r
+            // elements are sorted : [0,..,v]\r
+            // And else, if v contains positive and neqative values, the \r
+            // elements are sorted in the increasing order,ie [v_neg,0,v_pos],\r
+            // and conversely for the decreasing order.\r
+            if last == [] & first <> [] then\r
+                if strcmp(directionsort, 'i') == 0 then\r
+                    ij(:,1) = first(:) + dif;\r
+                else\r
+                    ij(:,1) = first(:);\r
+                end\r
+            elseif first == [] & last <> [] then\r
+                if strcmp(directionsort, 'i') == 0 then\r
+                    ij(:,1) = last(:);\r
+                else\r
+                    ij(:,1) = last(:) + dif;\r
+                end\r
+            else\r
+                if strcmp(directionsort, 'i') == 0 then\r
+                    ij(:,1) = [last(:); first(:) + dif];\r
+                else\r
+                    ij(:,1) = [first(:); last(:) + dif];\r
+                end\r
+            end\r
+            A = sparse(ij, v, mn);\r
+        end\r
+    end\r
+endfunction\r
index 7f5c1ca..114120a 100644 (file)
@@ -3,6 +3,7 @@
 // Copyright (C) ????-2008 - INRIA
 // Copyright (C) ????-2008 - ENPC
 // Copyright (C) 2008 - DIGITEO - Allan CORNET
+// Copyright (C) 2012 - Scilab Enterprises - Adeline CARNIS
 //
 //  This file is distributed under the same license as the Scilab package.
 // =============================================================================
 //================================ complex matrix ================================================
 x = [3  1  5 ; 2 9 8];
 y = [2  4  1 ; 4 1 3];
-c = x+y*%i;
+c = x + y * %i;
 ref_ind = [    4.    5.    3.  ;    6.    2.    1.  ];
 ref_values = [     9. + %i      5. + %i      1. + 4.*%i  ;    8. + 3.*%i    2. + 4.*%i    3. + 2.*%i ];
 [v,ind] = gsort(c);
-if or(ref_ind <> ind) then bugmes();quit;end
-if or(ref_values <> v) then bugmes();quit;end
+assert_checkequal(ref_ind, ind);
+assert_checkequal(ref_values, v);
 [v1,ind1] = gsort(abs(c));
 [v2,ind2] = gsort(c);
-if or(ind1<>ind2) then bugmes();quit;end
+assert_checkequal(ind1, ind2);
 A = [18 21 10 7 5];
 B = [1  3  22 8 4];
 y = complex(A,B);
 [a,b] = gsort(y);
-if or( b <> [3 2 1 4 5] ) then bugmes();quit;end
-if ( y(b) <> a  ) then bugmes();quit;end
-ierr = execstr("[a,b] = gsort(y,''l'');","errcatch");
-if ierr<> 999 then bugmes();quit;end
+assert_checkequal(b, [3 2 1 4 5]);
+assert_checkequal(y(b), a);
+assert_checkfalse(execstr("[a,b] = gsort(y,''l'')", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong value for input argument #%d: [''g'' ''r'' ''c'' ''lc'' ''lr''] expected.\n"), "gsort", 2); 
+assert_checkerror("[a,b] = gsort(y,''l'')", refMsg);
 ierr = execstr("[a,b] = gsort(y,''g'');","errcatch");
-if ierr<> 0 then bugmes();quit;end
+assert_checkequal(ierr, 0);
 ierr = execstr("[a,b] = gsort(y,''r'');","errcatch");
-if ierr<> 0 then bugmes();quit;end
+assert_checkequal(ierr, 0);
 ierr = execstr("[a,b] = gsort(y,''c'');","errcatch");
-if ierr<> 0 then bugmes();quit;end
+assert_checkequal(ierr, 0);
 ierr = execstr("[a,b] = gsort(y,''lc'');","errcatch");
-if ierr<> 0 then bugmes();quit;end
+assert_checkequal(ierr, 0);
 ierr = execstr("[a,b] = gsort(y,''lr'');","errcatch");
-if ierr<> 0 then bugmes();quit;end
+assert_checkequal(ierr, 0);
 //================================ sparse vectors ================================================
 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
+assert_checkequal(ref, A);
 sp = sparse([1,2;4,5;3,10]);
-ierr = execstr('A = gsort(sp);','errcatch');
-if ierr <> 999 then bugmes();quit;end
+assert_checkfalse(execstr("A = gsort(sp)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong size for input argument #%d: sparse vectors expected.\n"), "gsort", 1); 
+assert_checkerror("A = gsort(sp)", refMsg);
 //================================ Matrix of string case ===========================================
 N = 4;
 P = 20;
 a = int(10*rand(N,P,'u'));
 //-----Global sort 
-[a1,ind]=gsort(string(a),'g');
-[a2,ind2]=gsort(a,'g');
-if norm(evstr(a1)- matrix(a(ind),N,P)) > %eps then bugmes();quit;end;
-// a and string(a) are in the same order in the previous example 
-if norm(evstr(a1)- a2 ) > %eps then bugmes();quit;end;
+[a1,ind] = gsort(string(a),'g');
+[a2,ind2] = gsort(a,'g');
+assert_checkalmostequal(norm(evstr(a1)- matrix(a(ind),N,P)), %eps, [], %eps);
+// a or string(a) are in the same order in the previous example 
+assert_checkalmostequal(norm(evstr(a1)- a2), %eps, [], %eps);
 //-- rows 
-[a1,ind1]=gsort(string(a),'r');   
+[a1,ind1]=gsort(string(a),'r');
 [a2,ind2]=gsort(a,'r');
-if norm(ind1-ind2) > %eps then bugmes();quit;end;
-// a and string(a) are in the same order in the previous example 
-if norm(evstr(a1)- a2 ) > %eps then bugmes();quit;end;
+assert_checkalmostequal(norm(ind1-ind2), %eps, [], %eps);
+// a or string(a) are in the same order in the previous example 
+assert_checkalmostequal(norm(evstr(a1)- a2), %eps, [], %eps);
 //--columns 
-[a1,ind1]=gsort(string(a),'c')   ;                      
-[a2,ind2]=gsort(a,'c');
-if norm(ind1-ind2) > %eps then bugmes();quit;end;
-// a and string(a) are in the same order in the previous example 
-if norm(evstr(a1)- a2 ) > %eps then bugmes();quit;end;
+[a1,ind1] = gsort(string(a),'c');
+[a2,ind2] = gsort(a,'c');
+assert_checkalmostequal(norm(ind1-ind2), %eps, [], %eps);
+// a or string(a) are in the same order in the previous example 
+assert_checkalmostequal(norm(evstr(a1)- a2), %eps, [], %eps);
 //----sort the rows of a in lexicographic order 
-N1=4;P1=3;
-alr=[1,2,2;
-     1,2,1;
-     1,1,2;
-     1,1,1];
+N1 = 4;P1 = 3;
+alr = [1,2,2;
+1,2,1;
+1,1,2;
+1,1,1];
 // a random permutation 
-[ax,perm]=gsort(rand(1,N1,'u'));
-a=alr(perm,:);
-[a1,ind]=gsort(string(a),'lr') ;        
-[a2,ind]=gsort(a,'lr') ;
-//
-if norm(evstr(a1)- matrix(a(ind,:),N1,P1)) > %eps then bugmes();quit;end;
-// a and string(a) are in the same order in the previous example 
-if norm(evstr(a1)- a2 ) > %eps then bugmes();quit;end;
+[ax,perm] = gsort(rand(1,N1,'u'));
+a = alr(perm,:);
+[a1,ind] = gsort(string(a),'lr');
+[a2,ind] = gsort(a,'lr') ;
+assert_checkalmostequal(norm(evstr(a1)- matrix(a(ind,:),N1,P1)), %eps, [], %eps);
+// a or string(a) are in the same order in the previous example 
+assert_checkalmostequal(norm(evstr(a1)- a2), %eps, [], %eps);
 //----sort the columns of a in lexicographic order 
-N1=3;P1=4;
-alr=alr';
+N1 = 3;P1 = 4;
+alr = alr';
 // a random permutation 
-[ax,perm]=gsort(rand(1,P1,'u'));
-a=alr(:,perm);
-[a1,ind]=gsort(string(a),'lc');                   
-[a2,ind]=gsort(a,'lc') ;
-//
-if norm(evstr(a1)- matrix(a(:,ind),N1,P1)) > %eps then bugmes();quit;end;
-// a and string(a) are in the same order in the previous example 
-if norm(evstr(a1)- a2 ) > %eps then bugmes();quit;end;
+[ax,perm] = gsort(rand(1,P1,'u'));
+a = alr(:,perm);
+[a1,ind] = gsort(string(a),'lc');
+[a2,ind] = gsort(a,'lc') ;
+assert_checkalmostequal(norm(evstr(a1)- matrix(a(:,ind),N1,P1)), %eps, [], %eps);
+// a or string(a) are in the same order in the previous example 
+assert_checkalmostequal(norm(evstr(a1)- a2), %eps, [], %eps);
 //================================ Matrix of double case ===========================================
-N=4;P=20;Nrand=100; 
+N = 4;P = 20;Nrand = 100; 
 a = matrix(grand(1,'prm',(1:N*P)'),N,P);
 //-----Global sort --------------------------------
 [a1,ind]=gsort(a,'g');
-if norm(a1- matrix(N*P:-1:1,N,P)) > %eps then bugmes();quit;end;
-if norm(a1- matrix(a(ind),N,P)) > %eps then bugmes();quit;end;
+assert_checkalmostequal(norm(a1- matrix(N*P:-1:1,N,P)), %eps, [], %eps);
+assert_checkalmostequal(norm(a1- matrix(a(ind),N,P)), %eps, [], %eps);
 for i=1:Nrand 
-  b = int(10*rand(N,P,'u')); 
-  [b1,ind]=gsort(b,'g');
-  if norm(b1- matrix(b(ind),N,P)) > %eps then bugmes();quit;end;
-  if or(b1(1:$-1)-b1(2:$) <0) then bugmes();quit;end
-end 
+    b = int(10*rand(N,P,'u')); 
+    [b1,ind] = gsort(b,'g');
+    assert_checkalmostequal(norm(b1- matrix(b(ind),N,P)), %eps, [], %eps);
+    assert_checktrue(or(b1(1:$-1)-b1(2:$) >= 0));
+end
 //increasing values 
-[a1,ind]=gsort(a,'g','i');
-if norm(a1- matrix(1:N*P,N,P)) > %eps then bugmes();quit;end;
-if norm(a1- matrix(a(ind),N,P)) > %eps then bugmes();quit;end;
+[a1,ind] = gsort(a,'g','i');
+assert_checkalmostequal(norm(a1- matrix(1:N*P,N,P)), %eps, [], %eps);
+assert_checkalmostequal(norm(a1- matrix(a(ind),N,P)), %eps, [], %eps);
 for i=1:100
-  b = int(10*rand(N,P,'u')); 
-  [b1,ind]=gsort(b,'g','i');
-  if norm(b1- matrix(b(ind),N,P)) > %eps then bugmes();quit;end;
-  if or(b1(1:$-1)-b1(2:$) > 0) then bugmes();quit;end
-end 
+    b = int(10*rand(N,P,'u')); 
+    [b1,ind] = gsort(b,'g','i');
+    assert_checkalmostequal(norm(b1- matrix(b(ind),N,P)), %eps, [], %eps);
+    assert_checktrue(or(b1(1:$-1)-b1(2:$) <= 0));
+end
 //----sort each column of a ('r' means that the row indice is used for sorting)
-[a1,ind]=gsort(a,'r');
-nc=size(a,'c');
-test=[];
-for i=1:nc ; 
-   test= [test, matrix(a(ind(:,i),i),N,1)];
-end 
-if norm(a1- test) > %eps then bugmes();quit;end;
-test=[];
-for i=1:nc ; 
-   test= [test, gsort(a(:,i),'g')];
-end 
-if norm(a1- test) > %eps then bugmes();quit;end;
-for i=1:Nrand
-  b = int(10*rand(N,P,'u')); 
-  [b1,ind]=gsort(b,'r');
-  if or( b1(2:$,:)-b1(1:$-1,:) > 0 ) then bugmes();quit;end 
-  test=[];
-  for j=1:nc ; 
-    test= [test, matrix(b(ind(:,j),j),N,1)];
-  end 
-  if norm(b1- test) > %eps then bugmes();quit;end;
-end 
+[a1,ind] = gsort(a,'r');
+nc = size(a,'c');
+test = [];
+for i = 1:nc;
+    test = [test, matrix(a(ind(:,i),i),N,1)];
+end 
+assert_checkalmostequal(norm(a1- test), %eps, [], %eps);
+test = [];
+for i = 1:nc;
+    test = [test, gsort(a(:,i),'g')];
+end
+assert_checkalmostequal(norm(a1- test), %eps, [], %eps);
+for i = 1:Nrand
+    b = int(10*rand(N,P,'u')); 
+    [b1,ind] = gsort(b,'r');
+    assert_checkequal(or(b1(2:$,:) - b1(1:$-1,:) > 0), %f);
+    test = [];
+    for j = 1:nc
+        test = [test, matrix(b(ind(:,j),j),N,1)];
+    end
+    assert_checkalmostequal(norm(b1- test), %eps, [], %eps);
+end
 //increasing values 
-[a1,ind]=gsort(a,'r','i');
-nc=size(a,'c');
-test=[];
-for i=1:nc ; 
-  test= [test, matrix(a(ind(:,i),i),N,1)];
-end 
-if norm(a1- test) > %eps then bugmes();quit;end;
-test=[];
-for i=1:nc ; 
-   test= [test, gsort(a(:,i),'g','i')];
-end 
-if norm(a1- test) > %eps then bugmes();quit;end;
+[a1,ind] = gsort(a,'r','i');
+nc = size(a,'c');
+test = [];
+for i = 1:nc 
+    test = [test, matrix(a(ind(:,i),i),N,1)];
+end
+assert_checkalmostequal(norm(a1- test), %eps, [], %eps);
+test = [];
+for i = 1:nc 
+    test = [test, gsort(a(:,i),'g','i')];
+end
+assert_checkalmostequal(norm(a1- test), %eps, [], %eps);
 //----sort each row of a ('c' means that the column indice is used for sorting)
-[a1,ind]=gsort(a,'c')   ;
-nr=size(a,'r');
-test=[];
-for i=1:nr ; 
-   test= [test; matrix(a(i,ind(i,:)),1,P)];
-end 
-if norm(a1- test) > %eps then bugmes();quit;end;
-test=[];
-for i=1:nr ; 
-   test= [test; gsort(a(i,:),'g')];
-end 
-if norm(a1- test) > %eps then bugmes();quit;end;
-for i=1:Nrand
-  b = int(10*rand(N,P,'u')); 
-  [b1,ind]=gsort(b,'c');
-  if or( b1(:,2:$)-b1(:,1:$-1) > 0 ) then bugmes();quit;end 
-  test=[];
-  for j=1:nr ; 
-    test= [test; b(j,ind(j,:))];
-  end 
-  if norm(b1- test) > %eps then bugmes();quit;end;
-end 
+[a1,ind] = gsort(a,'c');
+nr = size(a,'r');
+test = [];
+for i = 1:nr 
+    test = [test; matrix(a(i,ind(i,:)),1,P)];
+end
+assert_checkalmostequal(norm(a1- test), %eps, [], %eps);
+test = [];
+for i = 1:nr 
+    test = [test; gsort(a(i,:),'g')];
+end
+assert_checkalmostequal(norm(a1- test), %eps, [], %eps);
+for i = 1:Nrand
+    b = int(10*rand(N,P,'u')); 
+    [b1,ind] = gsort(b,'c');
+    assert_checkequal(or(b1(:,2:$) - b1(:,1:$-1) > 0), %f);
+    test = [];
+    for j = 1:nr
+        test = [test; b(j,ind(j,:))];
+    end
+    assert_checkalmostequal(norm(b1- test), %eps, [], %eps);
+end
 //increasing 
-[a1,ind]=gsort(a,'c','i')   ;
-nr=size(a,'r');
-test=[];
-for i=1:nr ; 
-   test= [test; matrix(a(i,ind(i,:)),1,P)];
-end 
-if norm(a1- test) > %eps then bugmes();quit;end;
-test=[];
-for i=1:nr ; 
-   test= [test; gsort(a(i,:),'g','i')];
-end 
-if norm(a1- test) > %eps then bugmes();quit;end;
+[a1,ind] = gsort(a,'c','i');
+nr = size(a,'r');
+test = [];
+for i = 1:nr
+    test = [test; matrix(a(i,ind(i,:)),1,P)];
+end 
+assert_checkalmostequal(norm(a1- test), %eps, [], %eps);
+test = [];
+for i = 1:nr
+    test = [test; gsort(a(i,:),'g','i')];
+end
+assert_checkalmostequal(norm(a1- test), %eps, [], %eps);
 //----sort the rows of a in lexicographic order 
 //    i.e a(k,:) < a(l,:) if there's a number j 
-//    such that a(k,j) < a(l,j) and a(k,p)=a(l,p) for p in [1,j-1];
+//    such that a(k,j) < a(l,j) or a(k,p)=a(l,p) for p in [1,j-1];
 //
-N1=4;P1=3;
-alr=[1,2,2;
-     1,2,1;
-     1,1,2;
-     1,1,1];
+vmax = 4;
+N1 = 4;P1 = 3;
+alr = [1,2,2;
+1,2,1;
+1,1,2;
+1,1,1];
 // a random permutation 
-[ax,perm]=gsort(rand(1,N1,'u'));
-a=alr(perm,:);
-[a1,ind]=gsort(a,'lr');                   
-if norm(a1- alr) > %eps then bugmes();quit;end;
-if norm(a1- matrix(a(ind,:),N1,P1)) > %eps then bugmes();quit;end;
-[a2,ind2]=gsort(a*[100;10;1],'g');
-if norm(ind2-ind) > %eps then bugmes();quit;end;
-for i=1:Nrand
-  vmax=4;
-  b = int(vmax*rand(N,P,'u')); 
-  [b1,ind]=gsort(b,'lr');
-  if norm(b1- b(ind,:)) > %eps then bugmes();quit;end;
-  v= b1*((vmax+1)^[P-1:-1:0])';
-  if or( v(2:$)-v(1:$-1) > 0 ) then bugmes();quit;end 
-end 
+[ax,perm] = gsort(rand(1, N1, 'u'));
+a = alr(perm,:);
+[a1,ind] = gsort(a,'lr');
+assert_checkalmostequal(norm(a1 - alr), %eps, [], %eps);
+assert_checkalmostequal(norm(a1 - matrix(a(ind,:),N1,P1)), %eps, [], %eps);
+[a2,ind2] = gsort(a*[100;10;1],'g');
+assert_checkalmostequal(norm(ind2 - ind), %eps, [], %eps);
+for i = 1:Nrand
+    b = int(vmax * rand(N,P,'u')); 
+    [b1,ind] = gsort(b,'lr');
+    assert_checkalmostequal(norm(b1 - b(ind,:)), %eps, [], %eps);
+    v = b1 * ((vmax + 1) ^ [P - 1 : -1 : 0])';
+    assert_checktrue(or(v(2:$) - v(1:$-1) <= 0));
+end
 // increasing 
-[a1,ind]=gsort(a,'lr','i');                   
-if norm(a1- alr(N1:-1:1,:)) > %eps then bugmes();quit;end;
-if norm(a1- matrix(a(ind,:),N1,P1)) > %eps then bugmes();quit;end;
-[a2,ind2]=gsort(a*[100;10;1],'g','i');
-if norm(ind2-ind) > %eps then bugmes();quit;end;
-for i=1:Nrand
-  vmax=4;
-  b = int(vmax*rand(N,P,'u')); 
-  [b1,ind]=gsort(b,'lr','i');
-  if norm(b1- b(ind,:)) > %eps then bugmes();quit;end;
-  v= b1*((vmax+1)^[P-1:-1:0])';
-  if or( v(2:$)-v(1:$-1) < 0 ) then bugmes();quit;end 
-end 
+[a1,ind] = gsort(a,'lr','i');
+assert_checkalmostequal(norm(a1 - alr(N1:-1:1,:)), %eps, [], %eps);
+assert_checkalmostequal(norm(a1 - matrix(a(ind,:),N1,P1)), %eps, [], %eps);
+[a2,ind2] = gsort(a * [100;10;1],'g','i');
+assert_checkalmostequal(norm(ind2 - ind), %eps, [], %eps);
+for i = 1:Nrand    
+    b = int(vmax * rand(N,P,'u')); 
+    [b1,ind] = gsort(b,'lr','i');
+    assert_checkalmostequal(norm(b1 - b(ind,:)), %eps, [], %eps);
+    v= b1*((vmax+1)^[P-1:-1:0])';
+    assert_checktrue(or(v(2:$) - v(1:$-1) >= 0));
+end
 //----sort the columns of a in lexicographic order 
-N1=3;P1=4;
-alr=alr';
+N1 = 3;P1 = 4;
+alr = alr';
 // a random permutation 
-[ax,perm]=gsort(rand(1,P1,'u'));
-a=alr(:,perm);
-[a1,ind]=gsort(a,'lc');                   
-if norm(a1- alr) > %eps then bugmes();quit;end;
-if norm(a1- matrix(a(:,ind),N1,P1)) > %eps then bugmes();quit;end;
-[a2,ind2]=gsort([100,10,1]*a,'g');
-if norm(ind2-ind) > %eps then bugmes();quit;end;
-for i=1:Nrand
-  vmax=4;
-  b = int(vmax*rand(N1,P1,'u')); 
-  [b1,ind]=gsort(b,'lc');
-  if norm(b1- b(:,ind)) > %eps then bugmes();quit;end;
-  v= ((vmax+1)^[N1-1:-1:0])*b1;
-  if or( v(2:$)-v(1:$-1) > 0 ) then bugmes();quit;end 
+[ax,perm] = gsort(rand(1,P1,'u'));
+a = alr(:,perm);
+[a1,ind] = gsort(a,'lc');
+assert_checkalmostequal(norm(a1 - alr), %eps, [], %eps);
+assert_checkalmostequal(norm(a1- matrix(a(:,ind),N1,P1)), %eps, [], %eps);
+[a2,ind2] = gsort([100,10,1]*a,'g');
+assert_checkalmostequal(norm(ind2 - ind), %eps, [], %eps);
+for i = 1:Nrand
+    b = int(vmax * rand(N1,P1,'u')); 
+    [b1,ind] = gsort(b,'lc');
+    assert_checkalmostequal(norm(b1 - b(:,ind)), %eps, [], %eps);
+    v = ((vmax+1)^[N1-1:-1:0])*b1;
+    assert_checktrue(or(v(2:$) - v(1:$-1) <= 0));
 end 
 //increasing 
-[a1,ind]=gsort(a,'lc','i');                   
-if norm(a1- alr(:,P1:-1:1)) > %eps then bugmes();quit;end;
-if norm(a1- matrix(a(:,ind),N1,P1)) > %eps then bugmes();quit;end;
-[a2,ind2]=gsort([100,10,1]*a,'g','i');
-if norm(ind2-ind) > %eps then bugmes();quit;end;
-for i=1:Nrand
-  vmax=4;
-  b = int(vmax*rand(N,P,'u')); 
-  [b1,ind]=gsort(b,'lc','i');
-  if norm(b1- b(:,ind)) > %eps then bugmes();quit;end;
-  v= ((vmax+1)^[N-1:-1:0])*b1;
-  if or( v(2:$)-v(1:$-1) < 0 ) then bugmes();quit;end 
+[a1,ind] = gsort(a,'lc','i');
+assert_checkalmostequal(norm(a1 - alr(:,P1:-1:1)), %eps, [], %eps);
+assert_checkalmostequal(norm(a1 - matrix(a(:,ind),N1,P1)), %eps, [], %eps);
+[a2,ind2] = gsort([100,10,1]*a,'g','i');
+assert_checkalmostequal(norm(ind2 - ind), %eps, [], %eps);
+for i = 1:Nrand
+    b = int(vmax * rand(N,P,'u')); 
+    [b1,ind] = gsort(b,'lc','i');
+    assert_checkalmostequal(norm(b1 - b(:,ind)), %eps, [], %eps);
+    v = ((vmax+1)^[N-1:-1:0])*b1;
+    assert_checktrue(or(v(2:$) - v(1:$-1) >= 0));
 end 
 a = [1,1,1,1,2,2,3,3,2,2,3,3,4,4,4,4,4,4,4,4,5,5,5,6,6,6,7,7,7,7,8,8,8,8,9,9,9,9,9,9,9,7,9,10,..
- 10,10,10,11,11,11,12,13,13,13,13,14,14,12,12,14,14,14,14,14,14,15,15,15,15,16,17,18;
+10,10,10,11,11,11,12,13,13,13,13,14,14,12,12,14,14,14,14,14,14,15,15,15,15,16,17,18;
 3,4,4,5,3,8,4,4,7,8,8,8,5,5,8,9,10,10,9,8,6,10,10,10,10,11,8,8,13,13,9,9,13,13,10,10,13,..
- 13,14,15,15,12,14,11,11,15,15,15,15,16,17,14,14,17,17,15,15,13,13,17,17,18,18,19,19,16,..
- 16,19,19,19,18,19]';
-[b,ind]=gsort(a,'lr','i');
-t=b(2:$,:)-b(1:$-1,:);
-if or(t(:,1)<0) then bugmes();quit;end
-if or(t(find(t(:,1)==0),2)<0) then bugmes();quit;end
-if or(a(ind,:)<>b) then bugmes();quit;end
-for k=1:30
-  p=grand(1,'prm',(1:size(a,1))');
-  [b,ind]=gsort(a(p,:),'lr','i');      
-  t=b(2:$,:)-b(1:$-1,:);
-  if or(t(:,1)<0) then bugmes();quit;end
-  if or(t(find(t(:,1)==0),2)<0) then bugmes();quit;end
-  if or(a(p(ind),:)<>b) then bugmes();quit;end
+13,14,15,15,12,14,11,11,15,15,15,15,16,17,14,14,17,17,15,15,13,13,17,17,18,18,19,19,16,..
+16,19,19,19,18,19]';
+[b,ind] = gsort(a,'lr','i');
+t = b(2:$,:) - b(1:$-1,:);
+assert_checktrue(or(t(:,1) >= 0));
+assert_checktrue(or(t(find(t(:,1)==0),2)>=0));
+assert_checkequal(a(ind,:), b);
+for k = 1:30
+    p = grand(1,'prm',(1:size(a,1))');
+    [b,ind] = gsort(a(p,:),'lr','i');  
+    t = b(2:$,:) - b(1:$-1,:);
+    assert_checktrue(or(t(:,1) >= 0));
+    assert_checktrue(or(t(find(t(:,1)==0),2)>=0));
+    assert_checkequal(a(p(ind),:), b);
 end
-[b,ind]=gsort(a,'lr','d');
-t=b(1:$-1,:)-b(2:$,:);
-if or(t(:,1)<0) then bugmes();quit;end
-if or(t(find(t(:,1)==0),2)<0) then bugmes();quit;end
-if or(a(ind,:)<>b) then bugmes();quit;end
-for k=1:30
-  p=grand(1,'prm',(1:size(a,1))');
-  [b,ind]=gsort(a(p,:),'lr','d');      
-  t=b(1:$-1,:)-b(2:$,:);
-  if or(t(:,1)<0) then bugmes();quit;end
-  if or(t(find(t(:,1)==0),2)<0) then bugmes();quit;end
-  if or(a(p(ind),:)<>b) then bugmes();quit;end
+[b,ind] = gsort(a,'lr','d');
+t = b(1:$-1,:) - b(2:$,:);
+assert_checktrue(or(t(:,1) >= 0));
+assert_checktrue(or(t(find(t(:,1)==0),2)>=0));
+assert_checkequal(a(ind,:), b);
+for k = 1:30
+    p = grand(1,'prm',(1:size(a,1))');
+    [b,ind] = gsort(a(p,:),'lr','d');  
+    t = b(1:$-1,:) - b(2:$,:);
+    assert_checktrue(or(t(:,1) >= 0));
+    assert_checktrue(or(t(find(t(:,1)==0),2)>=0));
+    assert_checkequal(a(p(ind),:), b);
 end
-a=b;
-a([10 60],:)=a([60 10],:);
-[b,ind]=gsort(a,'lr','i');
-t=b(2:$,:)-b(1:$-1,:);
-if or(t(:,1)<0) then bugmes();quit;end
-if or(t(find(t(:,1)==0),2)<0) then bugmes();quit;end
-if or(a(ind,:)<>b) then bugmes();quit;end
-[b,ind]=gsort(a,'lr','d');
-t=b(1:$-1,:)-b(2:$,:);
-if or(t(:,1)<0) then bugmes();quit;end
-if or(t(find(t(:,1)==0),2)<0) then bugmes();quit;end
-if or(a(ind,:)<>b) then bugmes();quit;end
-//================================ Matrix of int32 and uint32 case =======================================
-N=4;P=20;Nrand=100; 
+a = b;
+a([10 60],:) = a([60 10],:);
+[b,ind] = gsort(a,'lr','i');
+t = b(2:$,:) - b(1:$-1,:);
+assert_checktrue(or(t(:,1) >= 0));
+assert_checktrue(or(t(find(t(:,1)==0),2)>=0));
+assert_checkequal(a(ind,:), b);
+[b,ind] = gsort(a,'lr','d');
+t = b(1:$-1,:) - b(2:$,:);
+assert_checktrue(or(t(:,1) >= 0));
+assert_checktrue(or(t(find(t(:,1)==0),2)>=0));
+assert_checkequal(a(ind,:), b);
+//================================ Matrix of int32 or uint32 case =======================================
+N = 4;P = 20;Nrand = 100; vmax = 4;
 a = int32(matrix(grand(1,'prm',(1:N*P)'),N,P));
 //-----Global sort --------------------------------
-[a1,ind]=gsort(a,'g');
-if or(a1- matrix(N*P:-1:1,N,P) <>0) then bugmes();quit;end;
-if or(a1- matrix(a(ind),N,P)  <>0) then bugmes();quit;end;
-for i=1:Nrand 
-  b = int32(10*rand(N,P,'u')); 
-  [b1,ind]=gsort(b,'g');
-  if or(b1- matrix(b(ind),N,P)<>0)  then bugmes();quit;end;
-  if or(b1(1:$-1)-b1(2:$) <0) then bugmes();quit;end
-end 
-//increasing values 
-[a1,ind]=gsort(a,'g','i');
-if or(a1- matrix(1:N*P,N,P) <>0) then bugmes();quit;end;
-if or(a1- matrix(a(ind),N,P)  <>0) then bugmes();quit;end;
-for i=1:100
-  b = int32(10*rand(N,P,'u')); 
-  [b1,ind]=gsort(b,'g','i');
-  if or(b1- matrix(b(ind),N,P)<>0)  then bugmes();quit;end;
-  if or(b1(1:$-1)-b1(2:$) > 0) then bugmes();quit;end
-end 
+[a1,ind] = gsort(a,'g');
+assert_checkequal(a1, int32(matrix(N * P:-1:1,N,P)));
+assert_checkequal(a1, matrix(a(ind),N,P));
+for i = 1:Nrand 
+    b = int32(10 * rand(N,P,'u')); 
+    [b1,ind] = gsort(b,'g');
+    assert_checkequal(b1, matrix(b(ind),N,P));
+    assert_checktrue(or(b1(1:$-1) - b1(2:$) >= 0));
+end
+//increasing values
+[a1,ind] = gsort(a,'g','i');
+assert_checkequal(a1, int32(matrix(1:N*P,N,P)));
+assert_checkequal(a1, matrix(a(ind),N,P));
+for i = 1:100
+    b = int32(10*rand(N,P,'u')); 
+    [b1,ind]=gsort(b,'g','i');
+    assert_checkequal(b1, matrix(b(ind),N,P));
+    assert_checktrue(or(b1(1:$-1) - b1(2:$) <= 0));
+end
 //----sort each column of a ('r' means that the row indice is used for sorting)
-[a1,ind]=gsort(a,'r');
-nc=size(a,'c');
-test=[];
-for i=1:nc ; 
-   test= [test, matrix(a(ind(:,i),i),N,1)];
-end 
-if or((a1- test)<>0)  then bugmes();quit;end;
-test=[];
-for i=1:nc ; 
-   test= [test, gsort(a(:,i),'g')];
-end 
-if or((a1- test)<>0)  then bugmes();quit;end;
-for i=1:Nrand
-  b = int32(10*rand(N,P,'u')); 
-  [b1,ind]=gsort(b,'r');
-  if or( b1(2:$,:)-b1(1:$-1,:) > 0 ) then bugmes();quit;end 
-  test=[];
-  for j=1:nc ; 
-    test= [test, matrix(b(ind(:,j),j),N,1)];
-  end 
-  if or((b1- test)<>0) then bugmes();quit;end;
-end 
+[a1,ind] = gsort(a,'r');
+nc = size(a,'c');
+test = [];
+for i = 1:nc
+    test = [test, matrix(a(ind(:,i),i),N,1)];
+end
+assert_checkequal(a1, test);
+test = [];
+for i =1:nc
+    test = [test, gsort(a(:,i),'g')];
+end
+assert_checkequal(a1, test);
+for i = 1:Nrand
+    b = int32(10*rand(N,P,'u')); 
+    [b1,ind] = gsort(b,'r');
+    assert_checkequal(or(b1(2:$,:) - b1(1:$-1,:) > 0), %f);
+    test = [];
+    for j = 1:nc 
+        test = [test, matrix(b(ind(:,j),j),N,1)];
+    end 
+    assert_checkequal(b1, test);
+end
 //increasing values 
-[a1,ind]=gsort(a,'r','i');
-nc=size(a,'c');
-test=[];
-for i=1:nc ; 
-  test= [test, matrix(a(ind(:,i),i),N,1)];
-end 
-if or((a1- test)<>0)  then bugmes();quit;end;
-test=[];
-for i=1:nc ; 
-   test= [test, gsort(a(:,i),'g','i')];
-end 
-if or((a1- test)<>0)  then bugmes();quit;end;
+[a1,ind] = gsort(a,'r','i');
+nc = size(a,'c');
+test = [];
+for i = 1:nc
+    test = [test, matrix(a(ind(:,i),i),N,1)];
+end 
+assert_checkequal(a1, test);
+test = [];
+for i = 1:nc 
+    test = [test, gsort(a(:,i),'g','i')];
+end 
+assert_checkequal(a1, test);
 //----sort each row of a ('c' means that the column indice is used for sorting)
-[a1,ind]=gsort(a,'c')   ;
-nr=size(a,'r');
-test=[];
-for i=1:nr ; 
-   test= [test; matrix(a(i,ind(i,:)),1,P)];
-end 
-if or((a1- test)<>0)  then bugmes();quit;end;
-test=[];
-for i=1:nr ; 
-   test= [test; gsort(a(i,:),'g')];
-end 
-if or((a1- test)<>0)  then bugmes();quit;end;
-for i=1:Nrand
-  b = int32(10*rand(N,P,'u')); 
-  [b1,ind]=gsort(b,'c');
-  if or( b1(:,2:$)-b1(:,1:$-1) > 0 ) then bugmes();quit;end 
-  test=[];
-  for j=1:nr ; 
-    test= [test; b(j,ind(j,:))];
-  end 
-  if or((b1- test)<>0) then bugmes();quit;end;
-end 
-//increasing 
-[a1,ind]=gsort(a,'c','i')   ;
-nr=size(a,'r');
-test=[];
-for i=1:nr ; 
-   test= [test; matrix(a(i,ind(i,:)),1,P)];
-end 
-if or((a1- test)<>0)  then bugmes();quit;end;
-test=[];
-for i=1:nr ; 
-   test= [test; gsort(a(i,:),'g','i')];
-end 
-if or((a1- test)<>0)  then bugmes();quit;end;
+[a1,ind] = gsort(a,'c');
+nr = size(a,'r');
+test = [];
+for i = 1:nr
+    test = [test; matrix(a(i,ind(i,:)),1,P)];
+end
+assert_checkequal(a1, test);
+test = [];
+for i = 1:nr ; 
+    test = [test; gsort(a(i,:),'g')];
+end
+assert_checkequal(a1, test);
+for i = 1:Nrand
+    b = int32(10 * rand(N,P,'u')); 
+    [b1,ind] = gsort(b,'c');
+    assert_checkequal(or(b1(:,2:$) - b1(:,1:$-1) > 0), %f);
+    test = [];
+    for j = 1:nr
+        test = [test; b(j,ind(j,:))];
+    end
+    assert_checkequal(b1, test);
+end 
+//increasing
+[a1,ind] = gsort(a,'c','i');
+nr = size(a,'r');
+test = [];
+for i = 1:nr
+    test = [test; matrix(a(i,ind(i,:)),1,P)];
+end 
+assert_checkequal(a1, test);
+test = [];
+for i = 1:nr
+    test = [test; gsort(a(i,:),'g','i')];
+end 
+assert_checkequal(a1, test);
 //----sort the rows of a in lexicographic order 
 //    i.e a(k,:) < a(l,:) if there's a number j 
-//    such that a(k,j) < a(l,j) and a(k,p)=a(l,p) for p in [1,j-1];
+//    such that a(k,j) < a(l,j) or a(k,p)=a(l,p) for p in [1,j-1];
 //
 N1=4;P1=3;
 alr=[1,2,2;
-     1,2,1;
-     1,1,2;
-     1,1,1];
+1,2,1;
+1,1,2;
+1,1,1];
 // a random permutation 
-[ax,perm]=gsort(rand(1,N1,'u'));
-a=alr(perm,:);
-[a1,ind]=gsort(a,'lr');                   
-if or((a1- alr) <>0) then bugmes();quit;end;
-if or((a1- matrix(a(ind,:),N1,P1)) <>0) then bugmes();quit;end;
-[a2,ind2]=gsort(a*[100;10;1],'g');
-if or((ind2-ind)<>0) then bugmes();quit;end;
+[ax,perm] = gsort(rand(1,N1,'u'));
+a = int32(alr(perm,:));
+[a1,ind] = gsort(a,'lr');
+assert_checkequal(a1, int32(alr));
+assert_checkequal(a1, matrix(a(ind,:),N1,P1));
+[a2,ind2] = gsort(a*[100;10;1],'g');
+assert_checkequal(ind2, ind);
 ///////////////////////
-for i=1:Nrand
-  vmax=4;
-  b = int32(vmax*rand(N,P,'u')); 
-  [b1,ind]=gsort(b,'lr');
-  if or((b1- b(ind,:)) <>0) then bugmes();quit;end;
-  v= double(b1)*((vmax+1)^[P-1:-1:0])';
-  if or( v(2:$)-v(1:$-1) > 0 ) then bugmes();quit;end 
+for i = 1:Nrand
+    b = int32(vmax*rand(N,P,'u')); 
+    [b1,ind] = gsort(b,'lr');
+    assert_checkequal(b1, b(ind,:));
+    v = double(b1)*((vmax+1)^[P-1:-1:0])';
+    assert_checktrue(or(v(2:$) - v(1:$-1) <= 0));
 end 
 // increasing 
-[a1,ind]=gsort(a,'lr','i');                   
-if or((a1- alr(N1:-1:1,:)) <>0) then bugmes();quit;end;
-if or((a1- matrix(a(ind,:),N1,P1)) <>0) then bugmes();quit;end;
-[a2,ind2]=gsort(a*[100;10;1],'g','i');
-if or((ind2-ind) <>0) then bugmes();quit;end;
-for i=1:Nrand
-  vmax=4;
-  b = int(vmax*rand(N,P,'u')); 
-  [b1,ind]=gsort(b,'lr','i');
-  if or((b1- b(ind,:)) <>0) then bugmes();quit;end;
-  v= double(b1)*((vmax+1)^[P-1:-1:0])';
-  if or( v(2:$)-v(1:$-1) < 0 ) then bugmes();quit;end 
-end 
-//----sort the columns of a in lexicographic order 
-N1=3;P1=4;
-alr=alr';
+[a1,ind] = gsort(a,'lr','i');
+assert_checkequal(a1, int32(alr(N1:-1:1,:)));
+assert_checkequal(a1, matrix(a(ind,:),N1,P1));
+[a2,ind2] = gsort(a*[100;10;1],'g','i');
+assert_checkequal(ind2, ind);
+for i = 1:Nrand
+    b = int(vmax * rand(N,P,'u')); 
+    [b1,ind] = gsort(b,'lr','i');
+    assert_checkequal(b1, b(ind,:));
+    v = double(b1)*((vmax+1)^[P-1:-1:0])';
+    assert_checktrue(or(v(2:$) - v(1:$-1) >= 0));
+end
+//----sort the columns of a in lexicographic order
+N1 = 3;P1 = 4;
+alr = alr';
 // a random permutation 
-[ax,perm]=gsort(rand(1,P1,'u'));
-a=alr(:,perm);
-[a1,ind]=gsort(a,'lc');                   
-if or((a1- alr) <>0) then bugmes();quit;end;
-if or((a1- matrix(a(:,ind),N1,P1)) <>0) then bugmes();quit;end;
-[a2,ind2]=gsort([100,10,1]*a,'g');
-if or((ind2-ind) <>0) then bugmes();quit;end;
-for i=1:Nrand
-  vmax=4;
-  b = int(vmax*rand(N1,P1,'u')); 
-  [b1,ind]=gsort(b,'lc');
-  if or((b1- b(:,ind)) <>0) then bugmes();quit;end;
-  v= ((vmax+1)^[N1-1:-1:0])*double(b1);
-  if or( v(2:$)-v(1:$-1) > 0 ) then bugmes();quit;end 
-end 
-//increasing 
-[a1,ind]=gsort(a,'lc','i');                   
-if or((a1- alr(:,P1:-1:1)) <>0) then bugmes();quit;end;
-if or((a1- matrix(a(:,ind),N1,P1)) <>0) then bugmes();quit;end;
-[a2,ind2]=gsort([100,10,1]*a,'g','i');
-if or((ind2-ind) <>0) then bugmes();quit;end;
-for i=1:Nrand
-  vmax=4;
-  b = int(vmax*rand(N,P,'u')); 
-  [b1,ind]=gsort(b,'lc','i');
-  if or((b1- b(:,ind)) <>0) then bugmes();quit;end;
-  v= ((vmax+1)^[N-1:-1:0])*b1;
-  if or( v(2:$)-v(1:$-1) < 0 ) then bugmes();quit;end 
-end 
+[ax,perm] = gsort(rand(1,P1,'u'));
+a = int32(alr(:,perm));
+[a1,ind] = gsort(a,'lc');
+assert_checkequal(a1, int32(alr));
+assert_checkequal(a1, matrix(a(:,ind),N1,P1));
+[a2,ind2] = gsort([100,10,1]*a,'g');
+assert_checkequal(ind2, ind);
+for i = 1:Nrand
+    b = int(vmax*rand(N1,P1,'u')); 
+    [b1,ind] = gsort(b,'lc');
+    assert_checkequal(b1, b(:,ind));
+    v= ((vmax+1)^[N1-1:-1:0])*double(b1);
+    assert_checktrue(or(v(2:$) - v(1:$-1) <= 0));
+end 
+//increasing
+[a1,ind] = gsort(a,'lc','i');
+assert_checkequal(a1, int32(alr(:,P1:-1:1)));
+assert_checkequal(a1, matrix(a(:,ind),N1,P1));
+[a2,ind2] = gsort([100,10,1] * a,'g','i');
+assert_checkequal(ind2, ind);
+for i = 1:Nrand
+    b = int(vmax*rand(N,P,'u')); 
+    [b1,ind] = gsort(b,'lc','i');
+    assert_checkequal(b1, b(:,ind));
+    v = ((vmax+1)^[N-1:-1:0])*b1;
+    assert_checktrue(or(v(2:$) - v(1:$-1) >= 0));
+end
 a = int32([1,1,1,1,2,2,3,3,2,2,3,3,4,4,4,4,4,4,4,4,5,5,5,6,6,6,7,7,7,7,8,8,8,8,9,9,9,9,9,9,9,7,9,10,..
- 10,10,10,11,11,11,12,13,13,13,13,14,14,12,12,14,14,14,14,14,14,15,15,15,15,16,17,18;
+10,10,10,11,11,11,12,13,13,13,13,14,14,12,12,14,14,14,14,14,14,15,15,15,15,16,17,18;
 3,4,4,5,3,8,4,4,7,8,8,8,5,5,8,9,10,10,9,8,6,10,10,10,10,11,8,8,13,13,9,9,13,13,10,10,13,..
- 13,14,15,15,12,14,11,11,15,15,15,15,16,17,14,14,17,17,15,15,13,13,17,17,18,18,19,19,16,..
- 16,19,19,19,18,19])';
-[b,ind]=gsort(a,'lr','i');
-t=b(2:$,:)-b(1:$-1,:);
-if or(t(:,1)<0) then bugmes();quit;end
-if or(t(find(t(:,1)==0),2)<0) then bugmes();quit;end
-if or(a(ind,:)<>b) then bugmes();quit;end
-for k=1:30
-  p=grand(1,'prm',(1:size(a,1))');
-  [b,ind]=gsort(a(p,:),'lr','i');      
-  t=b(2:$,:)-b(1:$-1,:);
-  if or(t(:,1)<0) then bugmes();quit;end
-  if or(t(find(t(:,1)==0),2)<0) then bugmes();quit;end
-  if or(a(p(ind),:)<>b) then bugmes();quit;end
+13,14,15,15,12,14,11,11,15,15,15,15,16,17,14,14,17,17,15,15,13,13,17,17,18,18,19,19,16,..
+16,19,19,19,18,19])';
+[b,ind] = gsort(a,'lr','i');
+t = b(2:$,:) - b(1:$-1,:);
+assert_checktrue(or(t(:,1) >= 0));
+assert_checktrue(or(t(find(t(:,1)==0),2) >= 0));
+assert_checkequal(a(ind,:), b);
+for k = 1:30
+    p = grand(1,'prm',(1:size(a,1))');
+    [b,ind] = gsort(a(p,:),'lr','i');  
+    t = b(2:$,:) - b(1:$-1,:);
+    assert_checktrue(or(t(:,1) >= 0));
+    assert_checktrue(or(t(find(t(:,1)==0),2) >= 0));
+    assert_checkequal(a(p(ind),:), b);
 end
-[b,ind]=gsort(a,'lr','d');
-t=b(1:$-1,:)-b(2:$,:);
-if or(t(:,1)<0) then bugmes();quit;end
-if or(t(find(t(:,1)==0),2)<0) then bugmes();quit;end
-if or(a(ind,:)<>b) then bugmes();quit;end
-for k=1:30
-  p=grand(1,'prm',(1:size(a,1))');
-  [b,ind]=gsort(a(p,:),'lr','d');      
-  t=b(1:$-1,:)-b(2:$,:);
-  if or(t(:,1)<0) then bugmes();quit;end
-  if or(t(find(t(:,1)==0),2)<0) then bugmes();quit;end
-  if or(a(p(ind),:)<>b) then bugmes();quit;end
+[b,ind] = gsort(a,'lr','d');
+t = b(1:$-1,:) - b(2:$,:);
+assert_checktrue(or(t(:,1) >= 0));
+assert_checktrue(or(t(find(t(:,1)==0),2) >= 0));
+assert_checkequal(a(ind,:), b);
+for k = 1:30
+    p = grand(1,'prm',(1:size(a,1))');
+    [b,ind] = gsort(a(p,:),'lr','d');  
+    t = b(1:$-1,:) - b(2:$,:);
+    assert_checktrue(or(t(:,1) >= 0));
+    assert_checktrue(or(t(find(t(:,1)==0),2) >= 0));
+    assert_checkequal(a(p(ind),:), b);
 end
-a=b;
-a([10 60],:)=a([60 10],:);
-[b,ind]=gsort(a,'lr','i');
-t=b(2:$,:)-b(1:$-1,:);
-if or(t(:,1)<0) then bugmes();quit;end
-if or(t(find(t(:,1)==0),2)<0) then bugmes();quit;end
-if or(a(ind,:)<>b) then bugmes();quit;end
-[b,ind]=gsort(a,'lr','d');
-t=b(1:$-1,:)-b(2:$,:);
-if or(t(:,1)<0) then bugmes();quit;end
-if or(t(find(t(:,1)==0),2)<0) then bugmes();quit;end
-if or(a(ind,:)<>b) then bugmes();quit;end
-//================================ Matrix of int16 and uint16 case =======================================
+a = b;
+a([10 60],:) = a([60 10],:);
+[b,ind] = gsort(a,'lr','i');
+t = b(2:$,:) - b(1:$-1,:);
+assert_checktrue(or(t(:,1) >= 0));
+assert_checktrue(or(t(find(t(:,1)==0),2) >= 0));
+assert_checkequal(a(ind,:), b);
+[b,ind] = gsort(a,'lr','d');
+t = b(1:$-1,:) - b(2:$,:);
+assert_checktrue(or(t(:,1) >= 0));
+assert_checktrue(or(t(find(t(:,1)==0),2) >= 0));
+assert_checkequal(a(ind,:), b);
+//================================ Matrix of int16 or uint16 case =======================================
 // Copyright Inria
 // test of gsort for int16 matrices:
-N=4;P=20;Nrand=100; 
+N = 4;P = 20;Nrand = 100; vmax = 4;
 a = int16(matrix(grand(1,'prm',(1:N*P)'),N,P));
 //-----Global sort --------------------------------
-[a1,ind]=gsort(a,'g');
-if or(a1- matrix(N*P:-1:1,N,P) <>0) then bugmes();quit;end;
-if or(a1- matrix(a(ind),N,P)  <>0) then bugmes();quit;end;
-for i=1:Nrand 
-  b = int16(10*rand(N,P,'u')); 
-  [b1,ind]=gsort(b,'g');
-  if or(b1- matrix(b(ind),N,P)<>0)  then bugmes();quit;end;
-  if or(b1(1:$-1)-b1(2:$) <0) then bugmes();quit;end
-end 
+[a1,ind] = gsort(a,'g');
+assert_checkequal(a1, int16(matrix(N*P:-1:1,N,P)));
+assert_checkequal(a1, matrix(a(ind),N,P));
+for i = 1:Nrand 
+    b = int16(10*rand(N,P,'u')); 
+    [b1,ind]=gsort(b,'g');
+    assert_checkequal(b1, matrix(b(ind),N,P));
+    assert_checktrue(or(b1(1:$-1) - b1(2:$) >= 0));
+end
 //increasing values 
-[a1,ind]=gsort(a,'g','i');
-if or(a1- matrix(1:N*P,N,P) <>0) then bugmes();quit;end;
-if or(a1- matrix(a(ind),N,P)  <>0) then bugmes();quit;end;
-for i=1:100
-  b = int16(10*rand(N,P,'u')); 
-  [b1,ind]=gsort(b,'g','i');
-  if or(b1- matrix(b(ind),N,P)<>0)  then bugmes();quit;end;
-  if or(b1(1:$-1)-b1(2:$) > 0) then bugmes();quit;end
-end 
+[a1,ind] = gsort(a,'g','i');
+assert_checkequal(a1, int16(matrix(1:N*P,N,P)));
+assert_checkequal(a1, matrix(a(ind),N,P));
+for i = 1:100
+    b = int16(10*rand(N,P,'u')); 
+    [b1,ind] = gsort(b,'g','i');
+    assert_checkequal(b1, int16(matrix(b(ind),N,P)));
+    assert_checktrue(or(b1(1:$-1) - b1(2:$) <= 0));
+end
 //----sort each column of a ('r' means that the row indice is used for sorting)
-[a1,ind]=gsort(a,'r');
-nc=size(a,'c');
-test=[];
-for i=1:nc ; 
-   test= [test, matrix(a(ind(:,i),i),N,1)];
-end 
-if or((a1- test)<>0)  then bugmes();quit;end;
-test=[];
-for i=1:nc ; 
-   test= [test, gsort(a(:,i),'g')];
-end 
-if or((a1- test)<>0)  then bugmes();quit;end;
-for i=1:Nrand
-  b = int16(10*rand(N,P,'u')); 
-  [b1,ind]=gsort(b,'r');
-  if or( b1(2:$,:)-b1(1:$-1,:) > 0 ) then bugmes();quit;end 
-  test=[];
-  for j=1:nc ; 
-    test= [test, matrix(b(ind(:,j),j),N,1)];
-  end 
-  if or((b1- test)<>0) then bugmes();quit;end;
+[a1,ind] = gsort(a,'r');
+nc = size(a,'c');
+test = [];
+for i = 1:nc 
+    test = [test, matrix(a(ind(:,i),i),N,1)];
+end
+assert_checkequal(a1, test);
+test = [];
+for i = 1:nc 
+    test = [test, gsort(a(:,i),'g')];
+end 
+assert_checkequal(a1, test);
+for i = 1:Nrand
+    b = int16(10*rand(N,P,'u')); 
+    [b1,ind] = gsort(b,'r');
+    assert_checktrue(or( b1(2:$,:) - b1(1:$-1,:) <= 0));
+    test = [];
+    for j = 1:nc 
+        test = [test, matrix(b(ind(:,j),j),N,1)];
+    end 
+    assert_checkequal(b1, test);
 end 
 //increasing values 
-[a1,ind]=gsort(a,'r','i');
-nc=size(a,'c');
-test=[];
-for i=1:nc ; 
-  test= [test, matrix(a(ind(:,i),i),N,1)];
-end 
-if or((a1- test)<>0)  then bugmes();quit;end;
-test=[];
-for i=1:nc ; 
-   test= [test, gsort(a(:,i),'g','i')];
-end 
-if or((a1- test)<>0)  then bugmes();quit;end;
+[a1,ind] = gsort(a,'r','i');
+nc = size(a,'c');
+test = [];
+for i = 1:nc 
+    test = [test, matrix(a(ind(:,i),i),N,1)];
+end 
+assert_checkequal(a1, test);
+test =[];
+for i = 1:nc ; 
+    test = [test, gsort(a(:,i),'g','i')];
+end 
+assert_checkequal(a1, test);
 //----sort each row of a ('c' means that the column indice is used for sorting)
-[a1,ind]=gsort(a,'c')   ;
-nr=size(a,'r');
-test=[];
-for i=1:nr ; 
-   test= [test; matrix(a(i,ind(i,:)),1,P)];
-end 
-if or((a1- test)<>0)  then bugmes();quit;end;
-test=[];
-for i=1:nr ; 
-   test= [test; gsort(a(i,:),'g')];
-end 
-if or((a1- test)<>0)  then bugmes();quit;end;
-for i=1:Nrand
-  b = int16(10*rand(N,P,'u')); 
-  [b1,ind]=gsort(b,'c');
-  if or( b1(:,2:$)-b1(:,1:$-1) > 0 ) then bugmes();quit;end 
-  test=[];
-  for j=1:nr ; 
-    test= [test; b(j,ind(j,:))];
-  end 
-  if or((b1- test)<>0) then bugmes();quit;end;
+[a1,ind] = gsort(a,'c')   ;
+nr = size(a,'r');
+test = [];
+for i = 1:nr
+    test = [test; matrix(a(i,ind(i,:)),1,P)];
+end 
+assert_checkequal(a1, test);
+test = [];
+for i = 1:nr
+    test = [test; gsort(a(i,:),'g')];
+end 
+assert_checkequal(a1, test);
+for i = 1:Nrand
+    b = int16(10*rand(N,P,'u')); 
+    [b1,ind] = gsort(b,'c');
+    assert_checktrue(or(b1(:,2:$) - b1(:,1:$-1) <= 0));
+    test = [];
+    for j = 1:nr 
+        test = [test; b(j,ind(j,:))];
+    end 
+    assert_checkequal(b1, test);
 end 
 //increasing 
-[a1,ind]=gsort(a,'c','i')   ;
-nr=size(a,'r');
-test=[];
-for i=1:nr ; 
-   test= [test; matrix(a(i,ind(i,:)),1,P)];
-end 
-if or((a1- test)<>0)  then bugmes();quit;end;
-test=[];
-for i=1:nr ; 
-   test= [test; gsort(a(i,:),'g','i')];
-end 
-if or((a1- test)<>0)  then bugmes();quit;end;
+[a1,ind] = gsort(a,'c','i');
+nr = size(a,'r');
+test = [];
+for i = 1:nr 
+    test = [test; matrix(a(i,ind(i,:)),1,P)];
+end 
+assert_checkequal(a1, test);
+test = [];
+for i = 1:nr ; 
+    test = [test; gsort(a(i,:),'g','i')];
+end 
+assert_checkequal(a1, test);
 //----sort the rows of a in lexicographic order 
 //    i.e a(k,:) < a(l,:) if there's a number j 
-//    such that a(k,j) < a(l,j) and a(k,p)=a(l,p) for p in [1,j-1];
+//    such that a(k,j) < a(l,j) or a(k,p)=a(l,p) for p in [1,j-1];
 //
-N1=4;P1=3;
-alr=[1,2,2;
-     1,2,1;
-     1,1,2;
-     1,1,1];
+N1 = 4;P1 = 3;
+alr = [1,2,2;
+1,2,1;
+1,1,2;
+1,1,1];
 // a random permutation 
-[ax,perm]=gsort(rand(1,N1,'u'));
-a=alr(perm,:);
-[a1,ind]=gsort(a,'lr');                   
-if or((a1- alr) <>0) then bugmes();quit;end;
-if or((a1- matrix(a(ind,:),N1,P1)) <>0) then bugmes();quit;end;
+[ax,perm] = gsort(rand(1,N1,'u'));
+a = int16(alr(perm,:));
+[a1,ind] = gsort(a,'lr');
+assert_checkequal(a1, int16(alr));
+assert_checkequal(a1, matrix(a(ind,:),N1,P1));
 [a2,ind2]=gsort(a*[100;10;1],'g');
-if or((ind2-ind)<>0) then bugmes();quit;end;
+assert_checkequal(ind2, ind);
 ///////////////////////
-for i=1:Nrand
-  vmax=4;
-  b = int16(vmax*rand(N,P,'u')); 
-  [b1,ind]=gsort(b,'lr');
-  if or((b1- b(ind,:)) <>0) then bugmes();quit;end;
-  v= double(b1)*((vmax+1)^[P-1:-1:0])';
-  if or( v(2:$)-v(1:$-1) > 0 ) then bugmes();quit;end 
-end 
+for i = 1:Nrand
+    b = int16(vmax * rand(N,P,'u')); 
+    [b1,ind] = gsort(b,'lr');
+    assert_checkequal(b1, b(ind,:));
+    v= double(b1)*((vmax+1)^[P-1:-1:0])';
+    assert_checktrue(or(v(2:$) - v(1:$-1) <= 0));
+end
 // increasing 
-[a1,ind]=gsort(a,'lr','i');                   
-if or((a1- alr(N1:-1:1,:)) <>0) then bugmes();quit;end;
-if or((a1- matrix(a(ind,:),N1,P1)) <>0) then bugmes();quit;end;
-[a2,ind2]=gsort(a*[100;10;1],'g','i');
-if or((ind2-ind) <>0) then bugmes();quit;end;
-for i=1:Nrand
-  vmax=4;
-  b = int(vmax*rand(N,P,'u')); 
-  [b1,ind]=gsort(b,'lr','i');
-  if or((b1- b(ind,:)) <>0) then bugmes();quit;end;
-  v= double(b1)*((vmax+1)^[P-1:-1:0])';
-  if or( v(2:$)-v(1:$-1) < 0 ) then bugmes();quit;end 
+[a1,ind] = gsort(a,'lr','i');
+assert_checkequal(a1, int16(alr(N1:-1:1,:)));
+assert_checkequal(a1, matrix(a(ind,:),N1,P1));
+[a2,ind2] = gsort(a*[100;10;1],'g','i');
+assert_checkequal(ind2, ind);
+for i = 1:Nrand
+    b = int(vmax*rand(N,P,'u')); 
+    [b1,ind] = gsort(b,'lr','i');
+    assert_checkequal(b1, b(ind,:));
+    v = double(b1)*((vmax+1)^[P-1:-1:0])';
+    assert_checktrue(or(v(2:$) - v(1:$-1) >= 0));
 end
 //----sort the columns of a in lexicographic order 
-N1=3;P1=4;
-alr=alr';
+N1 = 3;P1 = 4;
+alr = alr';
 // a random permutation 
-[ax,perm]=gsort(rand(1,P1,'u'));
-a=alr(:,perm);
-[a1,ind]=gsort(a,'lc');                   
-if or((a1- alr) <>0) then bugmes();quit;end;
-if or((a1- matrix(a(:,ind),N1,P1)) <>0) then bugmes();quit;end;
-[a2,ind2]=gsort([100,10,1]*a,'g');
-if or((ind2-ind) <>0) then bugmes();quit;end;
-for i=1:Nrand
-  vmax=4;
-  b = int(vmax*rand(N1,P1,'u')); 
-  [b1,ind]=gsort(b,'lc');
-  if or((b1- b(:,ind)) <>0) then bugmes();quit;end;
-  v= ((vmax+1)^[N1-1:-1:0])*double(b1);
-  if or( v(2:$)-v(1:$-1) > 0 ) then bugmes();quit;end 
+[ax,perm] = gsort(rand(1,P1,'u'));
+a = int16(alr(:,perm));
+[a1,ind] = gsort(a,'lc');
+assert_checkequal(a1, int16(alr));
+assert_checkequal(a1, matrix(a(:,ind),N1,P1));
+[a2,ind2] = gsort([100,10,1]*a,'g');
+assert_checkequal(ind2, ind);
+for i = 1:Nrand
+    b = int(vmax*rand(N1,P1,'u')); 
+    [b1,ind] = gsort(b,'lc');
+    assert_checkequal(b1, b(:,ind));
+    v= ((vmax+1)^[N1-1:-1:0])*double(b1);
+    assert_checktrue(or(v(2:$) - v(1:$-1) <= 0));
 end 
 //increasing 
-[a1,ind]=gsort(a,'lc','i');                   
-if or((a1- alr(:,P1:-1:1)) <>0) then bugmes();quit;end;
-if or((a1- matrix(a(:,ind),N1,P1)) <>0) then bugmes();quit;end;
-[a2,ind2]=gsort([100,10,1]*a,'g','i');
-if or((ind2-ind) <>0) then bugmes();quit;end;
-for i=1:Nrand
-  vmax=4;
-  b = int(vmax*rand(N,P,'u')); 
-  [b1,ind]=gsort(b,'lc','i');
-  if or((b1- b(:,ind)) <>0) then bugmes();quit;end;
-  v= ((vmax+1)^[N-1:-1:0])*b1;
-  if or( v(2:$)-v(1:$-1) < 0 ) then bugmes();quit;end 
-end 
+[a1,ind] = gsort(a,'lc','i');
+assert_checkequal(a1, int16(alr(:,P1:-1:1)));
+assert_checkequal(a1, matrix(a(:,ind),N1,P1));
+[a2,ind2] = gsort([100,10,1]*a,'g','i');
+assert_checkequal(ind2, ind);
+for i = 1:Nrand
+    b = int(vmax*rand(N,P,'u')); 
+    [b1,ind] = gsort(b,'lc','i');
+    assert_checkequal(b1, b(:,ind));
+    v = ((vmax+1)^[N-1:-1:0])*b1;
+    assert_checktrue(or(v(2:$) - v(1:$-1) >= 0));
+end
 a = int16([1,1,1,1,2,2,3,3,2,2,3,3,4,4,4,4,4,4,4,4,5,5,5,6,6,6,7,7,7,7,8,8,8,8,9,9,9,9,9,9,9,7,9,10,..
- 10,10,10,11,11,11,12,13,13,13,13,14,14,12,12,14,14,14,14,14,14,15,15,15,15,16,17,18;
+10,10,10,11,11,11,12,13,13,13,13,14,14,12,12,14,14,14,14,14,14,15,15,15,15,16,17,18;
 3,4,4,5,3,8,4,4,7,8,8,8,5,5,8,9,10,10,9,8,6,10,10,10,10,11,8,8,13,13,9,9,13,13,10,10,13,..
- 13,14,15,15,12,14,11,11,15,15,15,15,16,17,14,14,17,17,15,15,13,13,17,17,18,18,19,19,16,..
- 16,19,19,19,18,19])';
-[b,ind]=gsort(a,'lr','i');
-t=b(2:$,:)-b(1:$-1,:);
-if or(t(:,1)<0) then bugmes();quit;end
-if or(t(find(t(:,1)==0),2)<0) then bugmes();quit;end
-if or(a(ind,:)<>b) then bugmes();quit;end
-for k=1:30
-  p=grand(1,'prm',(1:size(a,1))');
-  [b,ind]=gsort(a(p,:),'lr','i');      
-  t=b(2:$,:)-b(1:$-1,:);
-  if or(t(:,1)<0) then bugmes();quit;end
-  if or(t(find(t(:,1)==0),2)<0) then bugmes();quit;end
-  if or(a(p(ind),:)<>b) then bugmes();quit;end
+13,14,15,15,12,14,11,11,15,15,15,15,16,17,14,14,17,17,15,15,13,13,17,17,18,18,19,19,16,..
+16,19,19,19,18,19])';
+[b,ind] = gsort(a,'lr','i');
+t = b(2:$,:) - b(1:$-1,:);
+assert_checktrue(or(t(:,1) >= 0));
+assert_checktrue(or(t(find(t(:,1)==0),2) >= 0));
+assert_checkequal(a(ind,:), b);
+for k = 1:30
+    p = grand(1,'prm',(1:size(a,1))');
+    [b,ind] = gsort(a(p,:),'lr','i');  
+    t = b(2:$,:) - b(1:$-1,:);
+    assert_checktrue(or(t(:,1) >= 0));
+    assert_checktrue(or(t(find(t(:,1)==0),2) >= 0));
+    assert_checkequal(a(p(ind),:), b);
 end
-[b,ind]=gsort(a,'lr','d');
-t=b(1:$-1,:)-b(2:$,:);
-if or(t(:,1)<0) then bugmes();quit;end
-if or(t(find(t(:,1)==0),2)<0) then bugmes();quit;end
-if or(a(ind,:)<>b) then bugmes();quit;end
-for k=1:30
-  p=grand(1,'prm',(1:size(a,1))');
-  [b,ind]=gsort(a(p,:),'lr','d');      
-  t=b(1:$-1,:)-b(2:$,:);
-  if or(t(:,1)<0) then bugmes();quit;end
-  if or(t(find(t(:,1)==0),2)<0) then bugmes();quit;end
-  if or(a(p(ind),:)<>b) then bugmes();quit;end
+[b,ind] = gsort(a,'lr','d');
+t = b(1:$-1,:) - b(2:$,:);
+assert_checktrue(or(t(:,1) >= 0));
+assert_checktrue(or(t(find(t(:,1)==0),2) >= 0));
+assert_checkequal(a(ind,:), b);
+for k = 1:30
+    p = grand(1,'prm',(1:size(a,1))');
+    [b,ind] = gsort(a(p,:),'lr','d');  
+    t = b(1:$-1,:) - b(2:$,:);
+    assert_checktrue(or(t(:,1) >= 0));
+    assert_checktrue(or(t(find(t(:,1)==0),2) >= 0));
+    assert_checkequal(a(p(ind),:), b);
 end
-a=b;
-a([10 60],:)=a([60 10],:);
-[b,ind]=gsort(a,'lr','i');
-t=b(2:$,:)-b(1:$-1,:);
-if or(t(:,1)<0) then bugmes();quit;end
-if or(t(find(t(:,1)==0),2)<0) then bugmes();quit;end
-if or(a(ind,:)<>b) then bugmes();quit;end
-[b,ind]=gsort(a,'lr','d');
-t=b(1:$-1,:)-b(2:$,:);
-if or(t(:,1)<0) then bugmes();quit;end
-if or(t(find(t(:,1)==0),2)<0) then bugmes();quit;end
-if or(a(ind,:)<>b) then bugmes();quit;end
+a = b;
+a([10 60],:) = a([60 10],:);
+[b,ind] = gsort(a,'lr','i');
+t = b(2:$,:) - b(1:$-1,:);
+assert_checktrue(or(t(:,1) >= 0));
+assert_checktrue(or(t(find(t(:,1)==0),2) >= 0));
+assert_checkequal(a(ind,:), b);
+[b,ind] = gsort(a,'lr','d');
+t = b(1:$-1,:) - b(2:$,:);
+assert_checktrue(or(t(:,1) >= 0));
+assert_checktrue(or(t(find(t(:,1)==0),2) >= 0));
+assert_checkequal(a(ind,:), b);
 a = uint16([1,1,1,1,2,2,3,3,2,2,3,3,4,4,4,4,4,4,4,4,5,5,5,6,6,6,7,7,7,7,8,8,8,8,9,9,9,9,9,9,9,7,9,10,..
- 10,10,10,11,11,11,12,13,13,13,13,14,14,12,12,14,14,14,14,14,14,15,15,15,15,16,17,18;
+10,10,10,11,11,11,12,13,13,13,13,14,14,12,12,14,14,14,14,14,14,15,15,15,15,16,17,18;
 3,4,4,5,3,8,4,4,7,8,8,8,5,5,8,9,10,10,9,8,6,10,10,10,10,11,8,8,13,13,9,9,13,13,10,10,13,..
- 13,14,15,15,12,14,11,11,15,15,15,15,16,17,14,14,17,17,15,15,13,13,17,17,18,18,19,19,16,..
- 16,19,19,19,18,19]-5)';
-[b,ind]=gsort(a,'lr','i');
-t=b(2:$,:)<b(1:$-1,:);
-if or(t(:,1)) then bugmes();quit;end
-if or(t(b(2:$,1)==b(1:$-1,1),2)) then bugmes();quit;end
-if or(a(ind,:)<>b) then bugmes();quit;end
-for k=1:30
-  p=grand(1,'prm',(1:size(a,1))');
-  [b,ind]=gsort(a(p,:),'lr','i');
-  t=b(2:$,:)<b(1:$-1,:);
-  if or(t(:,1)) then bugmes();quit;end
-  if or(t(b(2:$,1)==b(1:$-1,1),2)) then bugmes();quit;end
-  if or(a(p(ind),:)<>b) then bugmes();quit;end
+13,14,15,15,12,14,11,11,15,15,15,15,16,17,14,14,17,17,15,15,13,13,17,17,18,18,19,19,16,..
+16,19,19,19,18,19]-5)';
+[b,ind] = gsort(a,'lr','i');
+t = b(2:$,:) < b(1:$-1,:);
+assert_checkfalse(or(t(:,1)));
+assert_checkfalse(or(t(b(2:$,1)==b(1:$-1,1),2)));
+assert_checkequal(a(ind,:), b);
+for k = 1:30
+    p = grand(1,'prm',(1:size(a,1))');
+    [b,ind] = gsort(a(p,:),'lr','i');
+    t = b(2:$,:) < b(1:$-1,:);
+    assert_checkfalse(or(t(:,1)));
+    assert_checkfalse(or(t(b(2:$,1)==b(1:$-1,1),2)));
+    assert_checkequal(a(p(ind),:), b);
 end
-[b,ind]=gsort(a,'lr','d');
-t=b(2:$,:)>b(1:$-1,:);
-if or(t(:,1)) then bugmes();quit;end
-if or(t(b(2:$,1)==b(1:$-1,1),2)) then bugmes();quit;end
-if or(a(ind,:)<>b) then bugmes();quit;end
-for k=1:30
-  p=grand(1,'prm',(1:size(a,1))');
-  [b,ind]=gsort(a(p,:),'lr','d');
-  t=b(2:$,:)>b(1:$-1,:);
-  if or(t(:,1)) then bugmes();quit;end
-  if or(t(b(2:$,1)==b(1:$-1,1),2)) then bugmes();quit;end
-  if or(a(p(ind),:)<>b) then bugmes();quit;end
+[b,ind] = gsort(a,'lr','d');
+t = b(2:$,:) > b(1:$-1,:);
+assert_checkfalse(or(t(:,1)));
+assert_checkfalse(or(t(b(2:$,1)==b(1:$-1,1),2)));
+assert_checkequal(a(ind,:), b);
+for k = 1:30
+    p = grand(1,'prm',(1:size(a,1))');
+    [b,ind] = gsort(a(p,:),'lr','d');
+    t = b(2:$,:) > b(1:$-1,:);
+    assert_checkfalse(or(t(:,1)));
+    assert_checkfalse(or(t(b(2:$,1)==b(1:$-1,1),2)));
+    assert_checkequal(a(p(ind),:), b);
 end
-a=b;
-a([10 60],:)=a([60 10],:);
-[b,ind]=gsort(a,'lr','i');
-t=b(2:$,:)<b(1:$-1,:);
-if or(t(:,1)) then bugmes();quit;end
-if or(t(b(2:$,1)==b(1:$-1,1),2)) then bugmes();quit;end
-if or(a(ind,:)<>b) then bugmes();quit;end
-[b,ind]=gsort(a,'lr','d');
-t=b(2:$,:)>b(1:$-1,:);
-if or(t(:,1)) then bugmes();quit;end
-if or(t(b(2:$,1)==b(1:$-1,1),2)) then bugmes();quit;end
-if or(a(ind,:)<>b) then bugmes();quit;end
-//================================ Matrix of int8 and uint8 case =======================================
+a = b;
+a([10 60],:) = a([60 10],:);
+[b,ind] = gsort(a,'lr','i');
+t = b(2:$,:) < b(1:$-1,:);
+assert_checkfalse(or(t(:,1)));
+assert_checkfalse(or(t(b(2:$,1)==b(1:$-1,1),2)));
+assert_checkequal(a(ind,:), b);
+[b,ind] = gsort(a,'lr','d');
+t = b(2:$,:) > b(1:$-1,:);
+assert_checkfalse(or(t(:,1)));
+assert_checkfalse(or(t(b(2:$,1)==b(1:$-1,1),2)));
+assert_checkequal(a(ind,:), b);
+//================================ Matrix of int8 or uint8 case =======================================
 // test of gsort for int8 matrices:
-N=4;P=20;Nrand=100; 
+N = 4;P = 20;Nrand = 100; vmax = 4;
 a = int8(matrix(grand(1,'prm',(1:N*P)'),N,P));
 //-----Global sort --------------------------------
-[a1,ind]=gsort(a,'g');
-if or(a1- matrix(N*P:-1:1,N,P) <>0) then bugmes();quit;end;
-if or(a1- matrix(a(ind),N,P)  <>0) then bugmes();quit;end;
-for i=1:Nrand 
-  b = int8(10*rand(N,P,'u')); 
-  [b1,ind]=gsort(b,'g');
-  if or(b1- matrix(b(ind),N,P)<>0)  then bugmes();quit;end;
-  if or(b1(1:$-1)-b1(2:$) <0) then bugmes();quit;end
-end 
+[a1,ind] = gsort(a,'g');
+assert_checkequal(a1, int8(matrix(N*P:-1:1,N,P)));
+assert_checkequal(a1, matrix(a(ind),N,P));
+for i = 1:Nrand 
+    b = int8(10*rand(N,P,'u')); 
+    [b1,ind] = gsort(b,'g');
+    assert_checkequal(b1, matrix(b(ind),N,P));
+    assert_checktrue(or(b1(1:$-1) - b1(2:$) >= 0));
+end
 //increasing values 
-[a1,ind]=gsort(a,'g','i');
-if or(a1- matrix(1:N*P,N,P) <>0) then bugmes();quit;end;
-if or(a1- matrix(a(ind),N,P)  <>0) then bugmes();quit;end;
-for i=1:100
-  b = int8(10*rand(N,P,'u')); 
-  [b1,ind]=gsort(b,'g','i');
-  if or(b1- matrix(b(ind),N,P)<>0)  then bugmes();quit;end;
-  if or(b1(1:$-1)-b1(2:$) > 0) then bugmes();quit;end
-end 
+[a1,ind] = gsort(a,'g','i');
+assert_checkequal(a1, int8(matrix(1:N*P,N,P)));
+assert_checkequal(a1, matrix(a(ind),N,P));
+for i = 1:Nrand
+    b = int8(10*rand(N,P,'u')); 
+    [b1,ind] = gsort(b,'g','i');
+    assert_checkequal(b1, matrix(b(ind),N,P));
+    assert_checktrue(or(b1(1:$-1) - b1(2:$) <= 0));
+end
 //----sort each column of a ('r' means that the row indice is used for sorting)
-[a1,ind]=gsort(a,'r');
-nc=size(a,'c');
-test=[];
-for i=1:nc ; 
-   test= [test, matrix(a(ind(:,i),i),N,1)];
-end 
-if or((a1- test)<>0)  then bugmes();quit;end;
-test=[];
-for i=1:nc ; 
-   test= [test, gsort(a(:,i),'g')];
-end 
-if or((a1- test)<>0)  then bugmes();quit;end;
-for i=1:Nrand
-  b = int8(10*rand(N,P,'u')); 
-  [b1,ind]=gsort(b,'r');
-  if or( b1(2:$,:)-b1(1:$-1,:) > 0 ) then bugmes();quit;end 
-  test=[];
-  for j=1:nc ; 
-    test= [test, matrix(b(ind(:,j),j),N,1)];
-  end 
-  if or((b1- test)<>0) then bugmes();quit;end;
+[a1,ind] = gsort(a,'r');
+nc = size(a,'c');
+test = [];
+for i = 1:nc 
+    test = [test, matrix(a(ind(:,i),i),N,1)];
+end
+assert_checkequal(a1, test);
+test = [];
+for i = 1:nc 
+    test = [test, gsort(a(:,i),'g')];
+end 
+assert_checkequal(a1, test);
+for i = 1:Nrand
+    b = int8(10*rand(N,P,'u')); 
+    [b1,ind] = gsort(b,'r');
+    assert_checkequal(or(b1(2:$,:) - b1(1:$-1,:) > 0), %f);
+    test = [];
+    for j = 1:nc 
+        test = [test, matrix(b(ind(:,j),j),N,1)];
+    end 
+    assert_checkequal(b1, test);
 end 
 //increasing values 
-[a1,ind]=gsort(a,'r','i');
-nc=size(a,'c');
-test=[];
-for i=1:nc ; 
-  test= [test, matrix(a(ind(:,i),i),N,1)];
-end 
-if or((a1- test)<>0)  then bugmes();quit;end;
-test=[];
-for i=1:nc ; 
-   test= [test, gsort(a(:,i),'g','i')];
-end 
-if or((a1- test)<>0)  then bugmes();quit;end;
+[a1,ind] = gsort(a,'r','i');
+nc = size(a,'c');
+test = [];
+for i = 1:nc 
+    test = [test, matrix(a(ind(:,i),i),N,1)];
+end 
+assert_checkequal(a1, test);
+test =[];
+for i = 1:nc ; 
+    test = [test, gsort(a(:,i),'g','i')];
+end 
+assert_checkequal(a1, int8(test));
 //----sort each row of a ('c' means that the column indice is used for sorting)
-[a1,ind]=gsort(a,'c')   ;
-nr=size(a,'r');
-test=[];
-for i=1:nr ; 
-   test= [test; matrix(a(i,ind(i,:)),1,P)];
-end 
-if or((a1- test)<>0)  then bugmes();quit;end;
-test=[];
-for i=1:nr ; 
-   test= [test; gsort(a(i,:),'g')];
-end 
-if or((a1- test)<>0)  then bugmes();quit;end;
-for i=1:Nrand
-  b = int8(10*rand(N,P,'u')); 
-  [b1,ind]=gsort(b,'c');
-  if or( b1(:,2:$)-b1(:,1:$-1) > 0 ) then bugmes();quit;end 
-  test=[];
-  for j=1:nr ; 
-    test= [test; b(j,ind(j,:))];
-  end 
-  if or((b1- test)<>0) then bugmes();quit;end;
-end 
+[a1,ind] = gsort(a,'c');
+nr = size(a,'r');
+test = [];
+for i = 1:nr 
+    test = [test; matrix(a(i,ind(i,:)),1,P)];
+end
+assert_checkequal(a1, test);
+test = [];
+for i = 1:nr
+    test = [test; gsort(a(i,:),'g')];
+end 
+assert_checkequal(a1, test);
+for i = 1:Nrand
+    b = int8(10*rand(N,P,'u')); 
+    [b1,ind] = gsort(b,'c');
+    assert_checktrue(or(b1(:,2:$) - b1(:,1:$-1) <= 0));
+    test = [];
+    for j = 1:nr
+        test = [test; b(j,ind(j,:))];
+    end
+    assert_checkequal(b1, test);
+end
 //increasing 
-[a1,ind]=gsort(a,'c','i')   ;
-nr=size(a,'r');
-test=[];
-for i=1:nr ; 
-   test= [test; matrix(a(i,ind(i,:)),1,P)];
-end 
-if or((a1- test)<>0)  then bugmes();quit;end;
-test=[];
-for i=1:nr ; 
-   test= [test; gsort(a(i,:),'g','i')];
-end 
-if or((a1- test)<>0)  then bugmes();quit;end;
+[a1,ind] = gsort(a,'c','i');
+nr = size(a,'r');
+test = [];
+for i = 1:nr
+    test = [test; matrix(a(i,ind(i,:)),1,P)];
+end 
+assert_checkequal(a1, test);
+test = [];
+for i = 1:nr ; 
+    test = [test; gsort(a(i,:),'g','i')];
+end 
+assert_checkequal(a1, test);
 //----sort the rows of a in lexicographic order 
 //    i.e a(k,:) < a(l,:) if there's a number j 
-//    such that a(k,j) < a(l,j) and a(k,p)=a(l,p) for p in [1,j-1];
+//    such that a(k,j) < a(l,j) or a(k,p)=a(l,p) for p in [1,j-1];
 //
-N1=4;P1=3;
-alr=[1,2,2;
-     1,2,1;
-     1,1,2;
-     1,1,1];
+N1 = 4;P1 = 3;
+alr = [1,2,2;
+1,2,1;
+1,1,2;
+1,1,1];
 // a random permutation 
-[ax,perm]=gsort(rand(1,N1,'u'));
-a=alr(perm,:);
-[a1,ind]=gsort(a,'lr');                   
-if or((a1- alr) <>0) then bugmes();quit;end;
-if or((a1- matrix(a(ind,:),N1,P1)) <>0) then bugmes();quit;end;
-[a2,ind2]=gsort(a*[100;10;1],'g');
-if or((ind2-ind)<>0) then bugmes();quit;end;
+[ax,perm] = gsort(rand(1,N1,'u'));
+a = int8(alr(perm,:));
+[a1,ind] = gsort(a,'lr');
+assert_checkequal(a1, int8(alr));
+assert_checkequal(a1, matrix(a(ind,:),N1,P1));
+[a2,ind2] = gsort(a*[100;10;1],'g');
+assert_checkequal(ind2, ind);
 ///////////////////////
-for i=1:Nrand
-  vmax=4;
-  b = int8(vmax*rand(N,P,'u')); 
-  [b1,ind]=gsort(b,'lr');
-  if or((b1- b(ind,:)) <>0) then bugmes();quit;end;
-  v= double(b1)*((vmax+1)^[P-1:-1:0])';
-  if or( v(2:$)-v(1:$-1) > 0 ) then bugmes();quit;end 
-end 
+for i = 1:Nrand
+    b = int8(vmax*rand(N,P,'u')); 
+    [b1,ind] = gsort(b,'lr');
+    assert_checkequal(b1, b(ind,:));
+    v= double(b1)*((vmax+1)^[P-1:-1:0])';
+    assert_checktrue(or(v(2:$) - v(1:$-1) <= 0));
+end
 // increasing 
-[a1,ind]=gsort(a,'lr','i');                   
-if or((a1- alr(N1:-1:1,:)) <>0) then bugmes();quit;end;
-if or((a1- matrix(a(ind,:),N1,P1)) <>0) then bugmes();quit;end;
+[a1,ind] = gsort(a,'lr','i');
+assert_checkequal(a1, int8(alr(N1:-1:1,:)));
+assert_checkequal(a1, matrix(a(ind,:),N1,P1));
 [a2,ind2]=gsort(a*[100;10;1],'g','i');
-if or((ind2-ind) <>0) then bugmes();quit;end;
-for i=1:Nrand
-  vmax=4;
-  b = int(vmax*rand(N,P,'u')); 
-  [b1,ind]=gsort(b,'lr','i');
-  if or((b1- b(ind,:)) <>0) then bugmes();quit;end;
-  v= double(b1)*((vmax+1)^[P-1:-1:0])';
-  if or( v(2:$)-v(1:$-1) < 0 ) then bugmes();quit;end 
+assert_checkequal(ind2, ind);
+for i = 1:Nrand
+    b = int(vmax*rand(N,P,'u')); 
+    [b1,ind] = gsort(b,'lr','i');
+    assert_checkequal(b1, b(ind,:));
+    v = double(b1)*((vmax+1)^[P-1:-1:0])';
+    assert_checktrue(or(v(2:$) - v(1:$-1) >= 0));
 end 
 //----sort the columns of a in lexicographic order 
-N1=3;P1=4;
-alr=alr';
+N1 = 3;P1 = 4;
+alr = alr';
 // a random permutation 
-[ax,perm]=gsort(rand(1,P1,'u'));
-a=alr(:,perm);
-[a1,ind]=gsort(a,'lc');                   
-if or((a1- alr) <>0) then bugmes();quit;end;
-if or((a1- matrix(a(:,ind),N1,P1)) <>0) then bugmes();quit;end;
+[ax,perm] = gsort(rand(1,P1,'u'));
+a = int8(alr(:,perm));
+[a1,ind] = gsort(a,'lc');
+assert_checkequal(a1, int8(alr));
+assert_checkequal(a1, matrix(a(:,ind),N1,P1));
 [a2,ind2]=gsort([100,10,1]*a,'g');
-if or((ind2-ind) <>0) then bugmes();quit;end;
-for i=1:Nrand
-  vmax=4;
-  b = int(vmax*rand(N1,P1,'u')); 
-  [b1,ind]=gsort(b,'lc');
-  if or((b1- b(:,ind)) <>0) then bugmes();quit;end;
-  v= ((vmax+1)^[N1-1:-1:0])*double(b1);
-  if or( v(2:$)-v(1:$-1) > 0 ) then bugmes();quit;end 
+assert_checkequal(ind2, ind);
+for i = 1:Nrand
+    b = int(vmax*rand(N1,P1,'u')); 
+    [b1,ind] = gsort(b,'lc');
+    assert_checkequal(b1, b(:,ind));
+    v= ((vmax+1)^[N1-1:-1:0])*double(b1);
+    assert_checktrue(or(v(2:$) - v(1:$-1) <= 0));
 end 
 //increasing 
-[a1,ind]=gsort(a,'lc','i');                   
-if or((a1- alr(:,P1:-1:1)) <>0) then bugmes();quit;end;
-if or((a1- matrix(a(:,ind),N1,P1)) <>0) then bugmes();quit;end;
+[a1,ind] = gsort(a,'lc','i');
+assert_checkequal(a1, int8(alr(:,P1:-1:1)));
+assert_checkequal(a1, matrix(a(:,ind),N1,P1));
 [a2,ind2]=gsort([100,10,1]*a,'g','i');
-if or((ind2-ind) <>0) then bugmes();quit;end;
-for i=1:Nrand
-  vmax=4;
-  b = int(vmax*rand(N,P,'u')); 
-  [b1,ind]=gsort(b,'lc','i');
-  if or((b1- b(:,ind)) <>0) then bugmes();quit;end;
-  v= ((vmax+1)^[N-1:-1:0])*b1;
-  if or( v(2:$)-v(1:$-1) < 0 ) then bugmes();quit;end 
-end 
+assert_checkequal(ind2, ind);
+for i = 1:Nrand
+    b = int(vmax*rand(N,P,'u')); 
+    [b1,ind] = gsort(b,'lc','i');
+    assert_checkequal(b1, b(:,ind));
+    v= ((vmax+1)^[N-1:-1:0])*b1;
+    assert_checktrue(or(v(2:$) - v(1:$-1) >= 0));
+end
 a = int8([1,1,1,1,2,2,3,3,2,2,3,3,4,4,4,4,4,4,4,4,5,5,5,6,6,6,7,7,7,7,8,8,8,8,9,9,9,9,9,9,9,7,9,10,..
- 10,10,10,11,11,11,12,13,13,13,13,14,14,12,12,14,14,14,14,14,14,15,15,15,15,16,17,18;
+10,10,10,11,11,11,12,13,13,13,13,14,14,12,12,14,14,14,14,14,14,15,15,15,15,16,17,18;
 3,4,4,5,3,8,4,4,7,8,8,8,5,5,8,9,10,10,9,8,6,10,10,10,10,11,8,8,13,13,9,9,13,13,10,10,13,..
- 13,14,15,15,12,14,11,11,15,15,15,15,16,17,14,14,17,17,15,15,13,13,17,17,18,18,19,19,16,..
- 16,19,19,19,18,19])';
-[b,ind]=gsort(a,'lr','i');
-t=b(2:$,:)-b(1:$-1,:);
-if or(t(:,1)<0) then bugmes();quit;end
-if or(t(find(t(:,1)==0),2)<0) then bugmes();quit;end
-if or(a(ind,:)<>b) then bugmes();quit;end
-for k=1:30
-  p=grand(1,'prm',(1:size(a,1))');
-  [b,ind]=gsort(a(p,:),'lr','i');      
-  t=b(2:$,:)-b(1:$-1,:);
-  if or(t(:,1)<0) then bugmes();quit;end
-  if or(t(find(t(:,1)==0),2)<0) then bugmes();quit;end
-  if or(a(p(ind),:)<>b) then bugmes();quit;end
+13,14,15,15,12,14,11,11,15,15,15,15,16,17,14,14,17,17,15,15,13,13,17,17,18,18,19,19,16,..
+16,19,19,19,18,19])';
+[b,ind] = gsort(a,'lr','i');
+t = b(2:$,:) - b(1:$-1,:);
+assert_checktrue(or(t(:,1) <= 0));
+assert_checktrue(or(t(find(t(:,1)==0),2)>=0));
+assert_checkequal(a(ind,:), b);
+for k = 1:30
+    p = grand(1,'prm',(1:size(a,1))');
+    [b,ind] = gsort(a(p,:),'lr','i');  
+    t = b(2:$,:) - b(1:$-1,:);
+    assert_checktrue(or(t(:,1) <= 0));
+    assert_checktrue(or(t(find(t(:,1)==0),2)>=0));
+    assert_checkequal(a(p(ind),:), b);
 end
 [b,ind]=gsort(a,'lr','d');
 t=b(1:$-1,:)-b(2:$,:);
-if or(t(:,1)<0) then bugmes();quit;end
-if or(t(find(t(:,1)==0),2)<0) then bugmes();quit;end
-if or(a(ind,:)<>b) then bugmes();quit;end
-for k=1:30
-  p=grand(1,'prm',(1:size(a,1))');
-  [b,ind]=gsort(a(p,:),'lr','d');      
-  t=b(1:$-1,:)-b(2:$,:);
-  if or(t(:,1)<0) then bugmes();quit;end
-  if or(t(find(t(:,1)==0),2)<0) then bugmes();quit;end
-  if or(a(p(ind),:)<>b) then bugmes();quit;end
+assert_checktrue(or(t(:,1) <= 0));
+assert_checktrue(or(t(find(t(:,1)==0),2)>=0));
+assert_checkequal(a(ind,:), b);
+for k = 1:30
+    p = grand(1,'prm',(1:size(a,1))');
+    [b,ind] = gsort(a(p,:),'lr','d');  
+    t = b(1:$-1,:) - b(2:$,:);
+    assert_checktrue(or(t(:,1) <= 0));
+    assert_checktrue(or(t(find(t(:,1)==0),2)>=0));
+    assert_checkequal(a(p(ind),:), b);
 end
-a=b;
-a([10 60],:)=a([60 10],:);
-[b,ind]=gsort(a,'lr','i');
-t=b(2:$,:)-b(1:$-1,:);
-if or(t(:,1)<0) then bugmes();quit;end
-if or(t(find(t(:,1)==0),2)<0) then bugmes();quit;end
-if or(a(ind,:)<>b) then bugmes();quit;end
-[b,ind]=gsort(a,'lr','d');
-t=b(1:$-1,:)-b(2:$,:);
-if or(t(:,1)<0) then bugmes();quit;end
-if or(t(find(t(:,1)==0),2)<0) then bugmes();quit;end
-if or(a(ind,:)<>b) then bugmes();quit;end
-N=4;P=20;Nrand=100; 
+a = b;
+a([10 60],:) = a([60 10],:);
+[b,ind] = gsort(a,'lr','i');
+t = b(2:$,:) - b(1:$-1,:);
+assert_checktrue(or(t(:,1) <= 0));
+assert_checktrue(or(t(find(t(:,1)==0),2)>=0));
+assert_checkequal(a(ind,:), b);
+[b,ind] = gsort(a,'lr','d');
+t = b(1:$-1,:) - b(2:$,:);
+assert_checktrue(or(t(:,1) <= 0));
+assert_checktrue(or(t(find(t(:,1)==0),2)>=0));
+assert_checkequal(a(ind,:), b);
+N = 4;P = 20;Nrand = 100; vmax = 4;
 a = uint32(matrix(grand(1,'prm',(1:N*P)'),N,P));
 //-----Global sort --------------------------------
-[a1,ind]=gsort(a,'g');
-if or(a1- matrix(N*P:-1:1,N,P) <>0) then bugmes();quit;end;
-if or(a1- matrix(a(ind),N,P)  <>0) then bugmes();quit;end;
-for i=1:Nrand 
-  b = uint32(10*rand(N,P,'u')); 
-  [b1,ind]=gsort(b,'g');
-  if or(b1- matrix(b(ind),N,P)<>0)  then bugmes();quit;end;
-  if or(b1(1:$-1)-b1(2:$) <0) then bugmes();quit;end
+[a1,ind] = gsort(a,'g');
+assert_checkequal(a1, uint32(matrix(N*P:-1:1,N,P)));
+assert_checkequal(a1, matrix(a(ind),N,P));
+for i = 1:Nrand 
+    b = uint32(10*rand(N,P,'u')); 
+    [b1,ind] = gsort(b,'g');
+    assert_checkequal(b1, matrix(b(ind),N,P));
+    assert_checktrue(or(b1(1:$-1) - b1(2:$) >= 0));
 end 
 //increasing values 
-[a1,ind]=gsort(a,'g','i');
-if or(a1- matrix(1:N*P,N,P) <>0) then bugmes();quit;end;
-if or(a1- matrix(a(ind),N,P)  <>0) then bugmes();quit;end;
+[a1,ind] = gsort(a,'g','i');
+assert_checkequal(a1, uint32(matrix(1:N*P,N,P)));
+assert_checkequal(a1, matrix(a(ind),N,P));
 //----sort each column of a ('r' means that the row indice is used for sorting)
-[a1,ind]=gsort(a,'r');
-nc=size(a,'c');
-test=[];
-for i=1:nc ; 
-   test= [test, matrix(a(ind(:,i),i),N,1)];
-end 
-if or((a1- test)<>0)  then bugmes();quit;end;
-test=[];
-for i=1:nc ; 
-   test= [test, gsort(a(:,i),'g')];
-end 
-if or((a1- test)<>0)  then bugmes();quit;end;
+[a1,ind] = gsort(a,'r');
+nc = size(a,'c');
+test = [];
+for i = 1:nc ; 
+    test = [test, matrix(a(ind(:,i),i),N,1)];
+end 
+assert_checkequal(a1, test);
+test = [];
+for i = 1:nc ; 
+    test = [test, gsort(a(:,i),'g')];
+end 
+assert_checkequal(a1, test);
 //increasing values 
-[a1,ind]=gsort(a,'r','i');
-nc=size(a,'c');
-test=[];
-for i=1:nc ; 
-  test= [test, matrix(a(ind(:,i),i),N,1)];
-end 
-if or((a1- test)<>0)  then bugmes();quit;end;
-test=[];
-for i=1:nc ; 
-   test= [test, gsort(a(:,i),'g','i')];
+[a1,ind] = gsort(a,'r','i');
+nc = size(a,'c');
+test = [];
+for i = 1:nc ; 
+    test = [test, matrix(a(ind(:,i),i),N,1)];
+end
+assert_checkequal(a1, test);
+test = [];
+for i = 1:nc ; 
+    test = [test, gsort(a(:,i),'g','i')];
 end 
-if or((a1- test)<>0)  then bugmes();quit;end;
+assert_checkequal(a1, test);
 //----sort each row of a ('c' means that the column indice is used for sorting)
-[a1,ind]=gsort(a,'c')   ;
-nr=size(a,'r');
-test=[];
-for i=1:nr ; 
-   test= [test; matrix(a(i,ind(i,:)),1,P)];
-end 
-if or((a1- test)<>0)  then bugmes();quit;end;
-test=[];
-for i=1:nr ; 
-   test= [test; gsort(a(i,:),'g')];
+[a1,ind] = gsort(a,'c');
+nr = size(a,'r');
+test = [];
+for i = 1:nr 
+    test = [test; matrix(a(i,ind(i,:)),1,P)];
+end
+assert_checkequal(a1, test);
+test = [];
+for i = 1:nr
+    test = [test; gsort(a(i,:),'g')];
 end 
-if or((a1- test)<>0)  then bugmes();quit;end;
+assert_checkequal(a1, test);
 //increasing 
-[a1,ind]=gsort(a,'c','i')   ;
-nr=size(a,'r');
-test=[];
-for i=1:nr ; 
-   test= [test; matrix(a(i,ind(i,:)),1,P)];
-end 
-if or((a1- test)<>0)  then bugmes();quit;end;
-test=[];
-for i=1:nr ; 
-   test= [test; gsort(a(i,:),'g','i')];
-end 
-if or((a1- test)<>0)  then bugmes();quit;end;
+[a1,ind] = gsort(a,'c','i');
+nr = size(a,'r');
+test = [];
+for i = 1:nr 
+    test = [test; matrix(a(i,ind(i,:)),1,P)];
+end
+assert_checkequal(a1, test);
+test = [];
+for i = 1:nr 
+    test = [test; gsort(a(i,:),'g','i')];
+end
+assert_checkequal(a1, test);
 //----sort the rows of a in lexicographic order 
 //    i.e a(k,:) < a(l,:) if there's a number j 
-//    such that a(k,j) < a(l,j) and a(k,p)=a(l,p) for p in [1,j-1];
+//    such that a(k,j) < a(l,j) or a(k,p)=a(l,p) for p in [1,j-1];
 //
-N1=4;P1=3;
-alr=[1,2,2;
-     1,2,1;
-     1,1,2;
-     1,1,1];
+N1 = 4;P1 = 3;
+alr = [1,2,2;
+1,2,1;
+1,1,2;
+1,1,1];
 // a random permutation 
-[ax,perm]=gsort(rand(1,N1,'u'));
-a=alr(perm,:);
-[a1,ind]=gsort(a,'lr');                   
-if or((a1- alr) <>0) then bugmes();quit;end;
-if or((a1- matrix(a(ind,:),N1,P1)) <>0) then bugmes();quit;end;
+[ax,perm] = gsort(rand(1,N1,'u'));
+a = uint32(alr(perm,:));
+[a1,ind] = gsort(a,'lr');
+assert_checkequal(a1, uint32(alr));
+assert_checkequal(a1, matrix(a(ind,:),N1,P1));
 [a2,ind2]=gsort(a*[100;10;1],'g');
-if or((ind2-ind)<>0) then bugmes();quit;end;
+assert_checkequal(ind2, ind);
 ///////////////////////
-for i=1:Nrand
-  vmax=4;
-  b = uint32(vmax*rand(N,P,'u')); 
-  [b1,ind]=gsort(b,'lr');
-  if or((b1- b(ind,:)) <>0) then bugmes();quit;end;
-  v= double(b1)*((vmax+1)^[P-1:-1:0])';
-  if or( v(2:$)-v(1:$-1) > 0 ) then bugmes();quit;end 
+for i = 1:Nrand
+    b = uint32(vmax*rand(N,P,'u')); 
+    [b1,ind] = gsort(b,'lr');
+    assert_checkequal(b1, b(ind,:));
+    v = double(b1)*((vmax+1)^[P-1:-1:0])';
+    assert_checktrue(or(v(2:$)-v(1:$-1) <= 0));
 end 
 // increasing 
-[a1,ind]=gsort(a,'lr','i');                   
-if or((a1- alr(N1:-1:1,:)) <>0) then bugmes();quit;end;
-if or((a1- matrix(a(ind,:),N1,P1)) <>0) then bugmes();quit;end;
+[a1,ind] = gsort(a,'lr','i');
+assert_checkequal(a1, uint32(alr(N1:-1:1,:)));
+assert_checkequal(a1, matrix(a(ind,:),N1,P1));
 [a2,ind2]=gsort(a*[100;10;1],'g','i');
-if or((ind2-ind) <>0) then bugmes();quit;end;
-for i=1:Nrand
-  vmax=4;
-  b = int(vmax*rand(N,P,'u')); 
-  [b1,ind]=gsort(b,'lr','i');
-  if or((b1- b(ind,:)) <>0) then bugmes();quit;end;
-  v= double(b1)*((vmax+1)^[P-1:-1:0])';
-  if or( v(2:$)-v(1:$-1) < 0 ) then bugmes();quit;end 
-end 
-//----sort the columns of a in lexicographic order 
-N1=3;P1=4;
-alr=alr';
+assert_checkequal(ind2, ind);
+for i = 1:Nrand
+    b = int(vmax*rand(N,P,'u')); 
+    [b1,ind] = gsort(b,'lr','i');
+    assert_checkequal(b1, b(ind,:));
+    v= double(b1)*((vmax+1)^[P-1:-1:0])';
+    assert_checktrue(or(v(2:$)-v(1:$-1) >= 0));
+end 
+//----sort the columns of a in lexicographic order
+N1 = 3;P1 = 4;
+alr = alr';
 // a random permutation 
-[ax,perm]=gsort(rand(1,P1,'u'));
-a=alr(:,perm);
-[a1,ind]=gsort(a,'lc');                   
-if or((a1- alr) <>0) then bugmes();quit;end;
-if or((a1- matrix(a(:,ind),N1,P1)) <>0) then bugmes();quit;end;
-[a2,ind2]=gsort([100,10,1]*a,'g');
-if or((ind2-ind) <>0) then bugmes();quit;end;
-for i=1:Nrand
-  vmax=4;
-  b = int(vmax*rand(N1,P1,'u')); 
-  [b1,ind]=gsort(b,'lc');
-  if or((b1- b(:,ind)) <>0) then bugmes();quit;end;
-  v= ((vmax+1)^[N1-1:-1:0])*double(b1);
-  if or( v(2:$)-v(1:$-1) > 0 ) then bugmes();quit;end 
-end 
-//increasing 
-[a1,ind]=gsort(a,'lc','i');                   
-if or((a1- alr(:,P1:-1:1)) <>0) then bugmes();quit;end;
-if or((a1- matrix(a(:,ind),N1,P1)) <>0) then bugmes();quit;end;
-[a2,ind2]=gsort([100,10,1]*a,'g','i');
-if or((ind2-ind) <>0) then bugmes();quit;end;
-for i=1:Nrand
-  vmax=4;
-  b = int(vmax*rand(N,P,'u')); 
-  [b1,ind]=gsort(b,'lc','i');
-  if or((b1- b(:,ind)) <>0) then bugmes();quit;end;
-  v= ((vmax+1)^[N-1:-1:0])*b1;
-  if or( v(2:$)-v(1:$-1) < 0 ) then bugmes();quit;end 
+[ax,perm] = gsort(rand(1,P1,'u'));
+a = uint32(alr(:,perm));
+[a1,ind] = gsort(a,'lc');
+assert_checkequal(a1, uint32(alr));
+assert_checkequal(a1, matrix(a(:,ind),N1,P1));
+[a2,ind2] = gsort([100,10,1]*a,'g');
+assert_checkequal(ind2, ind);
+for i = 1:Nrand
+    b = int(vmax * rand(N1,P1,'u')); 
+    [b1,ind] = gsort(b,'lc');
+    assert_checkequal(b1, b(:,ind));
+    v= ((vmax+1)^[N1-1:-1:0])*double(b1);
+    assert_checktrue(or(v(2:$)-v(1:$-1) <= 0));
+end 
+//increasing
+[a1,ind] = gsort(a,'lc','i');
+assert_checkequal(a1, uint32(alr(:,P1:-1:1)));
+assert_checkequal(a1, matrix(a(:,ind),N1,P1));
+[a2,ind2] = gsort([100,10,1] * a,'g','i');
+assert_checkequal(ind2, ind);
+for i = 1:Nrand
+    b = int(vmax * rand(N,P,'u')); 
+    [b1,ind] = gsort(b,'lc','i');
+    assert_checkequal(b1, b(:,ind));
+    v= ((vmax+1)^[N-1:-1:0])*b1;
+    assert_checktrue(or(v(2:$)-v(1:$-1) >= 0));
 end 
 a = uint32([1,1,1,1,2,2,3,3,2,2,3,3,4,4,4,4,4,4,4,4,5,5,5,6,6,6,7,7,7,7,8,8,8,8,9,9,9,9,9,9,9,7,9,10,..
- 10,10,10,11,11,11,12,13,13,13,13,14,14,12,12,14,14,14,14,14,14,15,15,15,15,16,17,18;
+10,10,10,11,11,11,12,13,13,13,13,14,14,12,12,14,14,14,14,14,14,15,15,15,15,16,17,18;
 3,4,4,5,3,8,4,4,7,8,8,8,5,5,8,9,10,10,9,8,6,10,10,10,10,11,8,8,13,13,9,9,13,13,10,10,13,..
- 13,14,15,15,12,14,11,11,15,15,15,15,16,17,14,14,17,17,15,15,13,13,17,17,18,18,19,19,16,..
- 16,19,19,19,18,19]-5)';
-[b,ind]=gsort(a,'lr','i');
-t=b(2:$,:)<b(1:$-1,:);
-if or(t(:,1)) then bugmes();quit;end
-if or(t(b(2:$,1)==b(1:$-1,1),2)) then bugmes();quit;end
-if or(a(ind,:)<>b) then bugmes();quit;end
-for k=1:30
-  p=grand(1,'prm',(1:size(a,1))');
-  [b,ind]=gsort(a(p,:),'lr','i');
-  t=b(2:$,:)<b(1:$-1,:);
-  if or(t(:,1)) then bugmes();quit;end
-  if or(t(b(2:$,1)==b(1:$-1,1),2)) then bugmes();quit;end
-  if or(a(p(ind),:)<>b) then bugmes();quit;end
+13,14,15,15,12,14,11,11,15,15,15,15,16,17,14,14,17,17,15,15,13,13,17,17,18,18,19,19,16,..
+16,19,19,19,18,19]-5)';
+[b,ind] = gsort(a,'lr','i');
+t = b(2:$,:) < b(1:$-1,:);
+assert_checkfalse(or(t(:,1)));
+assert_checkfalse(or(t(b(2:$,1)==b(1:$-1,1),2)));
+assert_checkequal(a(ind,:),b);
+for k = 1:30
+    p = grand(1,'prm',(1:size(a,1))');
+    [b,ind] = gsort(a(p,:),'lr','i');
+    t = b(2:$,:) < b(1:$-1,:);
+    assert_checkfalse(or(t(:,1)));
+    assert_checkfalse(or(t(b(2:$,1)==b(1:$-1,1),2)));
+    assert_checkequal(a(p(ind),:),b);
 end
-[b,ind]=gsort(a,'lr','d');
-t=b(2:$,:)>b(1:$-1,:);
-if or(t(:,1)) then bugmes();quit;end
-if or(t(b(2:$,1)==b(1:$-1,1),2)) then bugmes();quit;end
-if or(a(ind,:)<>b) then bugmes();quit;end
-for k=1:30
-  p=grand(1,'prm',(1:size(a,1))');
-  [b,ind]=gsort(a(p,:),'lr','d');
-  t=b(2:$,:)>b(1:$-1,:);
-  if or(t(:,1)) then bugmes();quit;end
-  if or(t(b(2:$,1)==b(1:$-1,1),2)) then bugmes();quit;end
-  if or(a(p(ind),:)<>b) then bugmes();quit;end
+[b,ind] = gsort(a,'lr','d');
+t = b(2:$,:) > b(1:$-1,:);
+assert_checkfalse(or(t(:,1)));
+assert_checkfalse(or(t(b(2:$,1)==b(1:$-1,1),2)));
+assert_checkequal(a(ind,:),b);
+for k = 1:30
+    p = grand(1,'prm',(1:size(a,1))');
+    [b,ind] = gsort(a(p,:),'lr','d');
+    t = b(2:$,:) > b(1:$-1,:);
+    assert_checkfalse(or(t(:,1)));
+    assert_checkfalse(or(t(b(2:$,1)==b(1:$-1,1),2)));
+    assert_checkequal(a(p(ind),:),b);
 end
-a=b;
-a([10 60],:)=a([60 10],:);
-[b,ind]=gsort(a,'lr','i');
-t=b(2:$,:)<b(1:$-1,:);
-if or(t(:,1)) then bugmes();quit;end
-if or(t(b(2:$,1)==b(1:$-1,1),2)) then bugmes();quit;end
-if or(a(ind,:)<>b) then bugmes();quit;end
-[b,ind]=gsort(a,'lr','d');
-t=b(2:$,:)>b(1:$-1,:);
-if or(t(:,1)) then bugmes();quit;end
-if or(t(b(2:$,1)==b(1:$-1,1),2)) then bugmes();quit;end
-if or(a(ind,:)<>b) then bugmes();quit;end
+a = b;
+a([10 60],:) = a([60 10],:);
+[b,ind] = gsort(a,'lr','i');
+t = b(2:$,:) < b(1:$-1,:);
+assert_checkfalse(or(t(:,1)));
+assert_checkfalse(or(t(b(2:$,1)==b(1:$-1,1),2)));
+assert_checkequal(a(ind,:),b);
+[b,ind] = gsort(a,'lr','d');
+t = b(2:$,:) > b(1:$-1,:);
+assert_checkfalse(or(t(:,1)));
+assert_checkfalse(or(t(b(2:$,1)==b(1:$-1,1),2)));
+assert_checkequal(a(ind,:),b);
 // test of gsort for uuint16 matrices:
-N=4;P=20;Nrand=100; 
+N = 4;P = 20;Nrand = 100; vmax = 4;
 a = uint16(matrix(grand(1,'prm',(1:N*P)'),N,P));
 //-----Global sort --------------------------------
-[a1,ind]=gsort(a,'g');
-if or(a1- matrix(N*P:-1:1,N,P) <>0) then bugmes();quit;end;
-if or(a1- matrix(a(ind),N,P)  <>0) then bugmes();quit;end;
-for i=1:Nrand 
-  b = uint16(10*rand(N,P,'u')); 
-  [b1,ind]=gsort(b,'g');
-  if or(b1- matrix(b(ind),N,P)<>0)  then bugmes();quit;end;
-  if or(b1(1:$-1)-b1(2:$) <0) then bugmes();quit;end
-end 
-//increasing values 
-[a1,ind]=gsort(a,'g','i');
-if or(a1- matrix(1:N*P,N,P) <>0) then bugmes();quit;end;
-if or(a1- matrix(a(ind),N,P)  <>0) then bugmes();quit;end;
+[a1,ind] = gsort(a,'g');
+assert_checkequal(a1, uint16(matrix(N*P:-1:1,N,P)));
+assert_checkequal(a1, matrix(a(ind),N,P));
+for i = 1:Nrand 
+    b = uint16(10 * rand(N,P,'u')); 
+    [b1,ind] = gsort(b,'g');
+    assert_checkequal(b1, matrix(b(ind),N,P));
+    assert_checktrue(or(b1(1:$-1) - b1(2:$) >= 0));
+end 
+//increasing values
+[a1,ind] = gsort(a,'g','i');
+assert_checkequal(a1, uint16(matrix(1:N*P,N,P)));
+assert_checkequal(a1, matrix(a(ind),N,P));
 //----sort each column of a ('r' means that the row indice is used for sorting)
-[a1,ind]=gsort(a,'r');
-nc=size(a,'c');
-test=[];
-for i=1:nc ; 
-   test= [test, matrix(a(ind(:,i),i),N,1)];
-end 
-if or((a1- test)<>0)  then bugmes();quit;end;
-test=[];
-for i=1:nc ; 
-   test= [test, gsort(a(:,i),'g')];
-end 
-if or((a1- test)<>0)  then bugmes();quit;end;
-//increasing values 
-[a1,ind]=gsort(a,'r','i');
-nc=size(a,'c');
-test=[];
-for i=1:nc ; 
-  test= [test, matrix(a(ind(:,i),i),N,1)];
-end 
-if or((a1- test)<>0)  then bugmes();quit;end;
-test=[];
-for i=1:nc ; 
-   test= [test, gsort(a(:,i),'g','i')];
-end 
-if or((a1- test)<>0)  then bugmes();quit;end;
+[a1,ind] = gsort(a,'r');
+nc = size(a,'c');
+test = [];
+for i = 1:nc
+    test = [test, matrix(a(ind(:,i),i),N,1)];
+end
+assert_checkequal(a1, test);
+test = [];
+for i = 1:nc
+    test = [test, gsort(a(:,i),'g')];
+end 
+assert_checkequal(a1, test);
+//increasing values
+[a1,ind] = gsort(a,'r','i');
+nc = size(a,'c');
+test = [];
+for i = 1:nc 
+    test = [test, matrix(a(ind(:,i),i),N,1)];
+end 
+assert_checkequal(a1, test);
+test = [];
+for i = 1:nc 
+    test = [test, gsort(a(:,i),'g','i')];
+end 
+assert_checkequal(a1, test);
 //----sort each row of a ('c' means that the column indice is used for sorting)
-[a1,ind]=gsort(a,'c')   ;
-nr=size(a,'r');
-test=[];
-for i=1:nr ; 
-   test= [test; matrix(a(i,ind(i,:)),1,P)];
-end 
-if or((a1- test)<>0)  then bugmes();quit;end;
-test=[];
-for i=1:nr ; 
-   test= [test; gsort(a(i,:),'g')];
-end 
-if or((a1- test)<>0)  then bugmes();quit;end;
-//increasing 
-[a1,ind]=gsort(a,'c','i')   ;
-nr=size(a,'r');
-test=[];
-for i=1:nr ; 
-   test= [test; matrix(a(i,ind(i,:)),1,P)];
-end 
-if or((a1- test)<>0)  then bugmes();quit;end;
-test=[];
-for i=1:nr ; 
-   test= [test; gsort(a(i,:),'g','i')];
+[a1,ind] = gsort(a,'c');
+nr = size(a,'r');
+test = [];
+for i = 1:nr
+    test = [test; matrix(a(i,ind(i,:)),1,P)];
+end 
+assert_checkequal(a1, test);
+test = [];
+for i = 1:nr 
+    test = [test; gsort(a(i,:),'g')];
+end 
+assert_checkequal(a1, test);
+//increasing
+[a1,ind] = gsort(a,'c','i');
+nr = size(a,'r');
+test = [];
+for i = 1:nr
+    test = [test; matrix(a(i,ind(i,:)),1,P)];
+end
+assert_checkequal(a1, test);
+test = [];
+for i = 1:nr
+    test = [test; gsort(a(i,:),'g','i')];
 end 
-if or((a1- test)<>0)  then bugmes();quit;end;
+assert_checkequal(a1, test);
 //----sort the rows of a in lexicographic order 
 //    i.e a(k,:) < a(l,:) if there's a number j 
-//    such that a(k,j) < a(l,j) and a(k,p)=a(l,p) for p in [1,j-1];
+//    such that a(k,j) < a(l,j) or a(k,p)=a(l,p) for p in [1,j-1];
 //
-N1=4;P1=3;
-alr=[1,2,2;
-     1,2,1;
-     1,1,2;
-     1,1,1];
+N1 = 4;P1 = 3;
+alr = [1,2,2;
+1,2,1;
+1,1,2;
+1,1,1];
 // a random permutation 
-[ax,perm]=gsort(rand(1,N1,'u'));
-a=alr(perm,:);
-[a1,ind]=gsort(a,'lr');                   
-if or((a1- alr) <>0) then bugmes();quit;end;
-if or((a1- matrix(a(ind,:),N1,P1)) <>0) then bugmes();quit;end;
-[a2,ind2]=gsort(a*[100;10;1],'g');
-if or((ind2-ind)<>0) then bugmes();quit;end;
+[ax,perm] = gsort(rand(1,N1,'u'));
+a = uint16(alr(perm,:));
+[a1,ind] = gsort(a,'lr');
+assert_checkequal(a1, uint16(alr));
+assert_checkequal(a1, matrix(a(ind,:),N1,P1));
+[a2,ind2] = gsort(a * [100;10;1],'g');
+assert_checkequal(ind2, ind);
 ///////////////////////
-for i=1:Nrand
-  vmax=4;
-  b = uint16(vmax*rand(N,P,'u')); 
-  [b1,ind]=gsort(b,'lr');
-  if or((b1- b(ind,:)) <>0) then bugmes();quit;end;
-  v= double(b1)*((vmax+1)^[P-1:-1:0])';
-  if or( v(2:$)-v(1:$-1) > 0 ) then bugmes();quit;end 
-end 
-// increasing 
-[a1,ind]=gsort(a,'lr','i');                   
-if or((a1- alr(N1:-1:1,:)) <>0) then bugmes();quit;end;
-if or((a1- matrix(a(ind,:),N1,P1)) <>0) then bugmes();quit;end;
-[a2,ind2]=gsort(a*[100;10;1],'g','i');
-if or((ind2-ind) <>0) then bugmes();quit;end;
-for i=1:Nrand
-  vmax=4;
-  b = int(vmax*rand(N,P,'u')); 
-  [b1,ind]=gsort(b,'lr','i');
-  if or((b1- b(ind,:)) <>0) then bugmes();quit;end;
-  v= double(b1)*((vmax+1)^[P-1:-1:0])';
-  if or( v(2:$)-v(1:$-1) < 0 ) then bugmes();quit;end 
+for i = 1:Nrand
+    b = uint16(vmax*rand(N,P,'u')); 
+    [b1,ind] = gsort(b,'lr');
+    assert_checkequal(b1, b(ind,:));
+    v= double(b1)*((vmax+1)^[P-1:-1:0])';
+    assert_checktrue(or(v(2:$)-v(1:$-1) <= 0));
+end 
+// increasing
+[a1,ind] = gsort(a,'lr','i');
+assert_checkequal(a1, uint16(alr(N1:-1:1,:)));
+assert_checkequal(a1, matrix(a(ind,:),N1,P1));
+[a2,ind2] = gsort(a * [100;10;1],'g','i');
+assert_checkequal(ind2, ind);
+for i = 1:Nrand
+    b = int(vmax * rand(N,P,'u')); 
+    [b1,ind] = gsort(b,'lr','i');
+    assert_checkequal(b1, b(ind,:));
+    v = double(b1) * ((vmax+1)^[P-1:-1:0])';
+    assert_checktrue(or(v(2:$)-v(1:$-1) >= 0));
 end 
 //----sort the columns of a in lexicographic order 
-N1=3;P1=4;
-alr=alr';
+N1 = 3;P1 = 4;
+alr = alr';
 // a random permutation 
-[ax,perm]=gsort(rand(1,P1,'u'));
-a=alr(:,perm);
-[a1,ind]=gsort(a,'lc');                   
-if or((a1- alr) <>0) then bugmes();quit;end;
-if or((a1- matrix(a(:,ind),N1,P1)) <>0) then bugmes();quit;end;
-[a2,ind2]=gsort([100,10,1]*a,'g');
-if or((ind2-ind) <>0) then bugmes();quit;end;
-for i=1:Nrand
-  vmax=4;
-  b = int(vmax*rand(N1,P1,'u')); 
-  [b1,ind]=gsort(b,'lc');
-  if or((b1- b(:,ind)) <>0) then bugmes();quit;end;
-  v= ((vmax+1)^[N1-1:-1:0])*double(b1);
-  if or( v(2:$)-v(1:$-1) > 0 ) then bugmes();quit;end 
-end 
-//increasing 
-[a1,ind]=gsort(a,'lc','i');                   
-if or((a1- alr(:,P1:-1:1)) <>0) then bugmes();quit;end;
-if or((a1- matrix(a(:,ind),N1,P1)) <>0) then bugmes();quit;end;
-[a2,ind2]=gsort([100,10,1]*a,'g','i');
-if or((ind2-ind) <>0) then bugmes();quit;end;
-for i=1:Nrand
-  vmax=4;
-  b = int(vmax*rand(N,P,'u')); 
-  [b1,ind]=gsort(b,'lc','i');
-  if or((b1- b(:,ind)) <>0) then bugmes();quit;end;
-  v= ((vmax+1)^[N-1:-1:0])*b1;
-  if or( v(2:$)-v(1:$-1) < 0 ) then bugmes();quit;end 
-end 
+[ax,perm] = gsort(rand(1,P1,'u'));
+a = uint16(alr(:,perm));
+[a1,ind] = gsort(a,'lc');
+assert_checkequal(a1, uint16(alr));
+assert_checkequal(a1, matrix(a(:,ind),N1,P1));
+[a2,ind2] = gsort([100,10,1] * a,'g');
+assert_checkequal(ind2, ind);
+for i = 1:Nrand  
+    b = int(vmax * rand(N1,P1,'u')); 
+    [b1,ind] = gsort(b,'lc');
+    assert_checkequal(b1, b(:,ind));
+    v = ((vmax+1)^[N1-1:-1:0]) * double(b1);
+    assert_checktrue(or(v(2:$)-v(1:$-1) <= 0));
+end 
+//increasing
+[a1,ind] = gsort(a,'lc','i');
+assert_checkequal(a1, uint16(alr(:,P1:-1:1)));
+assert_checkequal(a1, matrix(a(:,ind),N1,P1));
+[a2,ind2] = gsort([100,10,1] * a,'g','i');
+assert_checkequal(ind2, ind);
+vmax = 4;
+for i = 1:Nrand
+    b = int(vmax * rand(N,P,'u')); 
+    [b1,ind] = gsort(b,'lc','i');
+    assert_checkequal(b1, b(:,ind));
+    v = ((vmax+1)^[N-1:-1:0])*b1;
+    assert_checktrue(or(v(2:$)-v(1:$-1) >= 0));
+end
 ////////////////////////////////////////////////////////////////////////
-// test of gsort for uuint8 matrices:
-N=4;P=20;Nrand=100; 
+// test of gsort for uint8 matrices:
+N = 4;P = 20;Nrand = 100; vmax = 4;
 a = uint8(matrix(grand(1,'prm',(1:N*P)'),N,P));
 //-----Global sort --------------------------------
-[a1,ind]=gsort(a,'g');
-if or(a1- matrix(N*P:-1:1,N,P) <>0) then bugmes();quit;end;
-if or(a1- matrix(a(ind),N,P)  <>0) then bugmes();quit;end;
-for i=1:Nrand 
-  b = uint8(10*rand(N,P,'u')); 
-  [b1,ind]=gsort(b,'g');
-  if or(b1- matrix(b(ind),N,P)<>0)  then bugmes();quit;end;
-  if or(b1(1:$-1)-b1(2:$) <0) then bugmes();quit;end
-end 
-//increasing values 
-[a1,ind]=gsort(a,'g','i');
-if or(a1- matrix(1:N*P,N,P) <>0) then bugmes();quit;end;
-if or(a1- matrix(a(ind),N,P)  <>0) then bugmes();quit;end;
+[a1,ind] = gsort(a,'g');
+assert_checkequal(a1, uint8(matrix(N*P:-1:1,N,P)));
+assert_checkequal(a1, matrix(a(ind),N,P));
+for i = 1:Nrand 
+    b = uint8(10*rand(N,P,'u')); 
+    [b1,ind] = gsort(b,'g');
+    assert_checkequal(b1, matrix(b(ind),N,P));
+    assert_checktrue(or(b1(1:$-1)-b1(2:$) >= 0));
+end
+//increasing values
+[a1,ind] = gsort(a,'g','i');
+assert_checkequal(a1, uint8(matrix(1:N*P,N,P)));
+assert_checkequal(a1, matrix(a(ind),N,P));
 //----sort each column of a ('r' means that the row indice is used for sorting)
-[a1,ind]=gsort(a,'r');
-nc=size(a,'c');
-test=[];
-for i=1:nc ; 
-   test= [test, matrix(a(ind(:,i),i),N,1)];
-end 
-if or((a1- test)<>0)  then bugmes();quit;end;
-test=[];
-for i=1:nc ; 
-   test= [test, gsort(a(:,i),'g')];
-end 
-if or((a1- test)<>0)  then bugmes();quit;end;
-//increasing values 
-[a1,ind]=gsort(a,'r','i');
-nc=size(a,'c');
-test=[];
-for i=1:nc ; 
-  test= [test, matrix(a(ind(:,i),i),N,1)];
-end 
-if or((a1- test)<>0)  then bugmes();quit;end;
-test=[];
-for i=1:nc ; 
-   test= [test, gsort(a(:,i),'g','i')];
-end 
-if or((a1- test)<>0)  then bugmes();quit;end;
+[a1,ind] = gsort(a,'r');
+nc = size(a,'c');
+test = [];
+for i = 1:nc
+    test = [test, matrix(a(ind(:,i),i),N,1)];
+end
+assert_checkequal(a1, test);
+test = [];
+for i = 1:nc 
+    test = [test, gsort(a(:,i),'g')];
+end
+assert_checkequal(a1, test);
+//increasing values
+[a1,ind] = gsort(a,'r','i');
+nc = size(a,'c');
+test = [];
+for i = 1:nc 
+    test = [test, matrix(a(ind(:,i),i),N,1)];
+end 
+assert_checkequal(a1, test);
+test = [];
+for i = 1:nc ; 
+    test = [test, gsort(a(:,i),'g','i')];
+end
+assert_checkequal(a1, test);
 //----sort each row of a ('c' means that the column indice is used for sorting)
-[a1,ind]=gsort(a,'c')   ;
-nr=size(a,'r');
-test=[];
-for i=1:nr ; 
-   test= [test; matrix(a(i,ind(i,:)),1,P)];
-end 
-if or((a1- test)<>0)  then bugmes();quit;end;
-test=[];
-for i=1:nr ; 
-   test= [test; gsort(a(i,:),'g')];
-end 
-if or((a1- test)<>0)  then bugmes();quit;end;
-//increasing 
-[a1,ind]=gsort(a,'c','i')   ;
-nr=size(a,'r');
-test=[];
-for i=1:nr ; 
-   test= [test; matrix(a(i,ind(i,:)),1,P)];
-end 
-if or((a1- test)<>0)  then bugmes();quit;end;
-test=[];
-for i=1:nr ; 
-   test= [test; gsort(a(i,:),'g','i')];
-end 
-if or((a1- test)<>0)  then bugmes();quit;end;
+[a1,ind] = gsort(a,'c');
+nr = size(a,'r');
+test = [];
+for i = 1:nr; 
+    test = [test; matrix(a(i,ind(i,:)),1,P)];
+end
+assert_checkequal(a1, test);
+test = [];
+for i = 1:nr
+    test = [test; gsort(a(i,:),'g')];
+end 
+assert_checkequal(a1, test);
+//increasing
+[a1,ind] = gsort(a,'c','i');
+nr = size(a,'r');
+test = [];
+for i = 1:nr 
+    test = [test; matrix(a(i,ind(i,:)),1,P)];
+end 
+assert_checkequal(a1, test);
+test = [];
+for i = 1:nr
+    test = [test; gsort(a(i,:),'g','i')];
+end 
+assert_checkequal(a1, test);
 //----sort the rows of a in lexicographic order 
 //    i.e a(k,:) < a(l,:) if there's a number j 
-//    such that a(k,j) < a(l,j) and a(k,p)=a(l,p) for p in [1,j-1];
+//    such that a(k,j) < a(l,j) or a(k,p)=a(l,p) for p in [1,j-1];
 //
-N1=4;P1=3;
-alr=[1,2,2;
-     1,2,1;
-     1,1,2;
-     1,1,1];
+N1 = 4;P1 = 3;
+alr = [1,2,2;
+1,2,1;
+1,1,2;
+1,1,1];
 // a random permutation 
-[ax,perm]=gsort(rand(1,N1,'u'));
-a=alr(perm,:);
-[a1,ind]=gsort(a,'lr');                   
-if or((a1- alr) <>0) then bugmes();quit;end;
-if or((a1- matrix(a(ind,:),N1,P1)) <>0) then bugmes();quit;end;
-[a2,ind2]=gsort(a*[100;10;1],'g');
-if or((ind2-ind)<>0) then bugmes();quit;end;
+[ax,perm] = gsort(rand(1,N1,'u'));
+a = uint8(alr(perm,:));
+[a1,ind] = gsort(a,'lr');
+assert_checkequal(a1, uint8(alr));
+assert_checkequal(a1, matrix(a(ind,:),N1,P1));
+[a2,ind2] = gsort(a*[100;10;1],'g');
+assert_checkequal(ind2, ind);
 ///////////////////////
-for i=1:Nrand
-  vmax=4;
-  b = uint8(vmax*rand(N,P,'u')); 
-  [b1,ind]=gsort(b,'lr');
-  if or((b1- b(ind,:)) <>0) then bugmes();quit;end;
-  v= double(b1)*((vmax+1)^[P-1:-1:0])';
-  if or( v(2:$)-v(1:$-1) > 0 ) then bugmes();quit;end 
-end 
-// increasing 
-[a1,ind]=gsort(a,'lr','i');                   
-if or((a1- alr(N1:-1:1,:)) <>0) then bugmes();quit;end;
-if or((a1- matrix(a(ind,:),N1,P1)) <>0) then bugmes();quit;end;
-[a2,ind2]=gsort(a*[100;10;1],'g','i');
-if or((ind2-ind) <>0) then bugmes();quit;end;
-for i=1:Nrand
-  vmax=4;
-  b = int(vmax*rand(N,P,'u')); 
-  [b1,ind]=gsort(b,'lr','i');
-  if or((b1- b(ind,:)) <>0) then bugmes();quit;end;
-  v= double(b1)*((vmax+1)^[P-1:-1:0])';
-  if or( v(2:$)-v(1:$-1) < 0 ) then bugmes();quit;end 
-end 
-//----sort the columns of a in lexicographic order 
-N1=3;P1=4;
-alr=alr';
+for i = 1:Nrand
+    b = uint8(vmax*rand(N,P,'u')); 
+    [b1,ind] = gsort(b,'lr');
+    assert_checkequal(b1, b(ind,:));
+    v = double(b1)*((vmax+1)^[P-1:-1:0])';
+    assert_checktrue(or(v(2:$)-v(1:$-1) <= 0));
+end 
+// increasing
+[a1,ind] = gsort(a,'lr','i');
+assert_checkequal(a1, uint8(alr(N1:-1:1,:)));
+assert_checkequal(a1, matrix(a(ind,:),N1,P1));
+[a2,ind2] = gsort(a*[100;10;1],'g','i');
+assert_checkequal(ind2, ind);
+for i = 1:Nrand
+    b = int(vmax*rand(N,P,'u')); 
+    [b1,ind] = gsort(b,'lr','i');
+    assert_checkequal(b1, b(ind,:));
+    v= double(b1)*((vmax+1)^[P-1:-1:0])';
+    assert_checktrue(or(v(2:$)-v(1:$-1) >= 0));
+end 
+//----sort the columns of a in lexicographic order
+N1 = 3;P1 = 4;
+alr = alr';
 // a random permutation 
-[ax,perm]=gsort(rand(1,P1,'u'));
-a=alr(:,perm);
-[a1,ind]=gsort(a,'lc');                   
-if or((a1- alr) <>0) then bugmes();quit;end;
-if or((a1- matrix(a(:,ind),N1,P1)) <>0) then bugmes();quit;end;
-[a2,ind2]=gsort([100,10,1]*a,'g');
-if or((ind2-ind) <>0) then bugmes();quit;end;
-for i=1:Nrand
-  vmax=4;
-  b = int(vmax*rand(N1,P1,'u')); 
-  [b1,ind]=gsort(b,'lc');
-  if or((b1- b(:,ind)) <>0) then bugmes();quit;end;
-  v= ((vmax+1)^[N1-1:-1:0])*double(b1);
-  if or( v(2:$)-v(1:$-1) > 0 ) then bugmes();quit;end 
-end 
-//increasing 
-[a1,ind]=gsort(a,'lc','i');                   
-if or((a1- alr(:,P1:-1:1)) <>0) then bugmes();quit;end;
-if or((a1- matrix(a(:,ind),N1,P1)) <>0) then bugmes();quit;end;
-[a2,ind2]=gsort([100,10,1]*a,'g','i');
-if or((ind2-ind) <>0) then bugmes();quit;end;
-for i=1:Nrand
-  vmax=4;
-  b = int(vmax*rand(N,P,'u')); 
-  [b1,ind]=gsort(b,'lc','i');
-  if or((b1- b(:,ind)) <>0) then bugmes();quit;end;
-  v= ((vmax+1)^[N-1:-1:0])*b1;
-  if or( v(2:$)-v(1:$-1) < 0 ) then bugmes();quit;end 
-end 
+[ax,perm] = gsort(rand(1,P1,'u'));
+a = uint8(alr(:,perm));
+[a1,ind] = gsort(a,'lc');
+assert_checkequal(a1, uint8(alr));
+assert_checkequal(a1, matrix(a(:,ind),N1,P1));
+[a2,ind2] = gsort([100,10,1]*a,'g');
+assert_checkequal(ind2, ind);
+for i = 1:Nrand
+    b = int(vmax * rand(N1,P1,'u')); 
+    [b1,ind] = gsort(b,'lc');
+    assert_checkequal(b1, b(:,ind));
+    v = ((vmax+1)^[N1-1:-1:0])*double(b1);
+    assert_checktrue(or(v(2:$)-v(1:$-1) <= 0));
+end 
+//increasing
+[a1,ind] = gsort(a,'lc','i');
+assert_checkequal(a1, uint8(alr(:,P1:-1:1)));
+assert_checkequal(a1, matrix(a(:,ind),N1,P1));
+[a2,ind2] = gsort([100,10,1]*a,'g','i');
+assert_checkequal(ind2, ind);
+for i = 1:Nrand
+    b = int(vmax*rand(N,P,'u')); 
+    [b1,ind] = gsort(b,'lc','i');
+    assert_checkequal(b1, b(:,ind));
+    v= ((vmax+1)^[N-1:-1:0])*b1;
+    assert_checktrue(or(v(2:$)-v(1:$-1) >= 0));
+end
 a = uint8([1,1,1,1,2,2,3,3,2,2,3,3,4,4,4,4,4,4,4,4,5,5,5,6,6,6,7,7,7,7,8,8,8,8,9,9,9,9,9,9,9,7,9,10,..
- 10,10,10,11,11,11,12,13,13,13,13,14,14,12,12,14,14,14,14,14,14,15,15,15,15,16,17,18;
+10,10,10,11,11,11,12,13,13,13,13,14,14,12,12,14,14,14,14,14,14,15,15,15,15,16,17,18;
 3,4,4,5,3,8,4,4,7,8,8,8,5,5,8,9,10,10,9,8,6,10,10,10,10,11,8,8,13,13,9,9,13,13,10,10,13,..
- 13,14,15,15,12,14,11,11,15,15,15,15,16,17,14,14,17,17,15,15,13,13,17,17,18,18,19,19,16,..
- 16,19,19,19,18,19]-5)';
-[b,ind]=gsort(a,'lr','i');
-t=b(2:$,:)<b(1:$-1,:);
-if or(t(:,1)) then bugmes();quit;end
-if or(t(b(2:$,1)==b(1:$-1,1),2)) then bugmes();quit;end
-if or(a(ind,:)<>b) then bugmes();quit;end
-for k=1:30
-  p=grand(1,'prm',(1:size(a,1))');
-  [b,ind]=gsort(a(p,:),'lr','i');
-  t=b(2:$,:)<b(1:$-1,:);
-  if or(t(:,1)) then bugmes();quit;end
-  if or(t(b(2:$,1)==b(1:$-1,1),2)) then bugmes();quit;end
-  if or(a(p(ind),:)<>b) then bugmes();quit;end
+13,14,15,15,12,14,11,11,15,15,15,15,16,17,14,14,17,17,15,15,13,13,17,17,18,18,19,19,16,..
+16,19,19,19,18,19]-5)';
+[b,ind] = gsort(a,'lr','i');
+t = b(2:$,:) < b(1:$-1,:);
+assert_checkfalse(or(t(:,1)));
+assert_checkfalse(or(t(b(2:$,1)==b(1:$-1,1),2)));
+assert_checkequal(a(ind,:),b);
+for k = 1:30
+    p = grand(1,'prm',(1:size(a,1))');
+    [b,ind] = gsort(a(p,:),'lr','i');
+    t = b(2:$,:) < b(1:$-1,:);
+    assert_checkfalse(or(t(:,1)));
+    assert_checkfalse(or(t(b(2:$,1)==b(1:$-1,1),2)));
+    assert_checkequal(a(p(ind),:),b);
 end
 [b,ind]=gsort(a,'lr','d');
-t=b(2:$,:)>b(1:$-1,:);
-if or(t(:,1)) then bugmes();quit;end
-if or(t(b(2:$,1)==b(1:$-1,1),2)) then bugmes();quit;end
-if or(a(ind,:)<>b) then bugmes();quit;end
-for k=1:30
-  p=grand(1,'prm',(1:size(a,1))');
-  [b,ind]=gsort(a(p,:),'lr','d');
-  t=b(2:$,:)>b(1:$-1,:);
-  if or(t(:,1)) then bugmes();quit;end
-  if or(t(b(2:$,1)==b(1:$-1,1),2)) then bugmes();quit;end
-  if or(a(p(ind),:)<>b) then bugmes();quit;end
+t=b(2:$,:) > b(1:$-1,:);
+assert_checkfalse(or(t(:,1)));
+assert_checkfalse(or(t(b(2:$,1)==b(1:$-1,1),2)));
+assert_checkequal(a(ind,:),b);
+for k = 1:30
+    p = grand(1,'prm',(1:size(a,1))');
+    [b,ind] = gsort(a(p,:),'lr','d');
+    t = b(2:$,:) > b(1:$-1,:);
+    assert_checkfalse(or(t(:,1)));
+    assert_checkfalse(or(t(b(2:$,1)==b(1:$-1,1),2)));
+    assert_checkequal(a(p(ind),:),b);
 end
-a=b;
-a([10 60],:)=a([60 10],:);
-[b,ind]=gsort(a,'lr','i');
-t=b(2:$,:)<b(1:$-1,:);
-if or(t(:,1)) then bugmes();quit;end
-if or(t(b(2:$,1)==b(1:$-1,1),2)) then bugmes();quit;end
-if or(a(ind,:)<>b) then bugmes();quit;end
-[b,ind]=gsort(a,'lr','d');
-t=b(2:$,:)>b(1:$-1,:);
-if or(t(:,1)) then bugmes();quit;end
-if or(t(b(2:$,1)==b(1:$-1,1),2)) then bugmes();quit;end
-if or(a(ind,:)<>b) then bugmes();quit;end
+a = b;
+a([10 60],:) = a([60 10],:);
+[b,ind] = gsort(a,'lr','i');
+t = b(2:$,:) < b(1:$-1,:);
+assert_checkfalse(or(t(:,1)));
+assert_checkfalse(or(t(b(2:$,1)==b(1:$-1,1),2)));
+assert_checkequal(a(ind,:),b);
+[b,ind] = gsort(a,'lr','d');
+t = b(2:$,:) > b(1:$-1,:);
+assert_checkfalse(or(t(:,1)));
+assert_checkfalse(or(t(b(2:$,1)==b(1:$-1,1),2)));
+assert_checkequal(a(ind,:),b);
 //testing gsort with Nan's
-b=gsort([1 2 %nan 3 4],'g','i');
-if or(b(1:4)<>(1:4)) then bugmes();quit;end
-if find(isnan(b))<>5 then bugmes();quit;end
-b=gsort([1 2 %nan 1 3 ],'g','i');
-if or(b(1:4)<>[1 1 2 3]) then bugmes();quit;end
-if find(isnan(b))<>5 then bugmes();quit;end
-b=gsort([1 2 %nan 1 3 ],'g','d');
-if or(b(2:$)<>[3 2 1 1]) then bugmes();quit;end
-if find(isnan(b))<>1 then bugmes();quit;end
-b=gsort([1 2 %nan 1 3 %nan 2 3],'g','d');
-if or(b(3:$)<>[3,3,2,2,1,1]) then bugmes();quit;end
-if or(find(isnan(b))<>[1 2]) then bugmes();quit;end
-b=gsort([1 2 %nan 1 3 %nan 2 3],'g','i');
-if or(b(1:$-2)<>[1,1,2,2,3,3]) then bugmes();quit;end
-if or(find(isnan(b))<>[7 8]) then bugmes();quit;end
-m=[1 2 %nan;1 3 %nan;1 2 3];
-b=gsort(m,'lr','i');
-if sci2exp(b,0)<>'[1,2,%nan;1,2,3;1,3,%nan]' then bugmes();quit;end
-b=gsort(m,'lr','d');
-if sci2exp(b,0)<>'[1,3,%nan;1,2,%nan;1,2,3]' then bugmes();quit;end
-m=m(:,[3 1 2]);
-b=gsort(m,'lc','i');
-if sci2exp(b,0)<>'[1,2,%nan;1,3,%nan;1,2,3]' then bugmes();quit;end
-b=gsort(m,'lc','d');
-if sci2exp(b,0)<>'[%nan,2,1;%nan,3,1;3,2,1]' then bugmes();quit;end
+b = gsort([1 2 %nan 3 4],'g','i');
+assert_checkequal(b(1:4), (1:4));
+assert_checkequal(find(isnan(b)), 5);
+b = gsort([1 2 %nan 1 3 ],'g','i');
+assert_checkequal(b(1:4), [1 1 2 3]);
+assert_checkequal(find(isnan(b)), 5);
+b = gsort([1 2 %nan 1 3 ],'g','d');
+assert_checkequal(b(2:$), [3 2 1 1]);
+assert_checkequal(find(isnan(b)), 1);
+b = gsort([1 2 %nan 1 3 %nan 2 3],'g','d');
+assert_checkequal(b(3:$), [3,3,2,2,1,1]);
+assert_checkequal(find(isnan(b)), [1 2]);
+b = gsort([1 2 %nan 1 3 %nan 2 3],'g','i');
+assert_checkequal(b(1:$-2), [1,1,2,2,3,3]);
+assert_checkequal(find(isnan(b)), [7 8]);
+m = [1 2 %nan;1 3 %nan;1 2 3];
+b = gsort(m,'lr','i');
+assert_checkequal(sci2exp(b,0), '[1,2,%nan;1,2,3;1,3,%nan]');
+b = gsort(m,'lr','d');
+assert_checkequal(sci2exp(b,0), '[1,3,%nan;1,2,%nan;1,2,3]');
+m = m(:,[3 1 2]);
+b = gsort(m,'lc','i');
+assert_checkequal(sci2exp(b,0), '[1,2,%nan;1,3,%nan;1,2,3]');
+b = gsort(m,'lc','d');
+assert_checkequal(sci2exp(b,0), '[%nan,2,1;%nan,3,1;3,2,1]');
 //testing gsort with Inf's
-b=gsort([1 2 %inf 3 4],'g','i');
-if or(b(1:4)<>(1:4)) then bugmes();quit;end
-if find(isinf(b))<>5 then bugmes();quit;end
+b = gsort([1 2 %inf 3 4],'g','i');
+assert_checkequal(b(1:4), (1:4));
+assert_checkequal(find(isinf(b)), 5);
 b=gsort([1 2 %inf 1 3 ],'g','i');
-if or(b(1:4)<>[1 1 2 3]) then bugmes();quit;end
-if find(isinf(b))<>5 then bugmes();quit;end
+assert_checkequal(b(1:4), [1 1 2 3]);
+assert_checkequal(find(isinf(b)), 5);
 b=gsort([1 2 %inf 1 3 ],'g','d');
-if or(b(2:$)<>[3 2 1 1]) then bugmes();quit;end
-if find(isinf(b))<>1 then bugmes();quit;end
+assert_checkequal(b(2:$), [3 2 1 1]);
+assert_checkequal(find(isinf(b)), 1);
 b=gsort([1 2 %inf 1 3 %inf 2 3],'g','d');
-if or(b(3:$)<>[3,3,2,2,1,1]) then bugmes();quit;end
-if or(find(isinf(b))<>[1 2]) then bugmes();quit;end
+assert_checkequal(b(3:$), [3,3,2,2,1,1]);
+assert_checkequal(find(isinf(b)), [1 2]);
 b=gsort([1 2 %inf 1 3 %inf 2 3],'g','i');
-if or(b(1:$-2)<>[1,1,2,2,3,3]) then bugmes();quit;end
-if or(find(isinf(b))<>[7 8]) then bugmes();quit;end
-m=[1 2 %inf;1 3 %inf;1 2 3];
-b=gsort(m,'lr','i');
-if sci2exp(b,0)<>'[1,2,3;1,2,%inf;1,3,%inf]' then bugmes();quit;end
-b=gsort(m,'lr','d');
-if sci2exp(b,0)<>'[1,3,%inf;1,2,%inf;1,2,3]' then bugmes();quit;end
-m=m(:,[3 1 2]);
-b=gsort(m,'lc','i');
-if sci2exp(b,0)<>'[1,2,%inf;1,3,%inf;1,2,3]' then bugmes();quit;end
-b=gsort(m,'lc','d');
-if sci2exp(b,0)<>'[%inf,2,1;%inf,3,1;3,2,1]' then bugmes();quit;end
+assert_checkequal(b(1:$-2), [1,1,2,2,3,3]);
+assert_checkequal(find(isinf(b)), [7 8]);
+m = [1 2 %inf;1 3 %inf;1 2 3];
+b = gsort(m,'lr','i');
+assert_checkequal(sci2exp(b,0), '[1,2,3;1,2,%inf;1,3,%inf]');
+b = gsort(m,'lr','d');
+assert_checkequal(sci2exp(b,0), '[1,3,%inf;1,2,%inf;1,2,3]');
+m = m(:,[3 1 2]);
+b = gsort(m,'lc','i');
+assert_checkequal(sci2exp(b,0), '[1,2,%inf;1,3,%inf;1,2,3]');
+b = gsort(m,'lc','d');
+assert_checkequal(sci2exp(b,0), '[%inf,2,1;%inf,3,1;3,2,1]');
 //gsort
-a=[5 1 3 2 4]
- a  =
-    5.    1.    3.    2.    4.  
-if or(gsort(a)<>[5 4 3 2 1]) then bugmes();quit;end
-if or(gsort(a+0)<>[5 4 3 2 1]) then bugmes();quit;end
-[s,k]=gsort(a);
-if or(k<>[1 5 3 4 2]) then bugmes();quit;end
-if or(s<>[5 4 3 2 1]) then bugmes();quit;end
+a = [5 1 3 2 4];
+assert_checkequal(gsort(a), [5 4 3 2 1]);
+assert_checkequal(gsort(a + 0), [5 4 3 2 1]);
+[s,k] = gsort(a);
+assert_checkequal(k, [1 5 3 4 2]);
+assert_checkequal(s, [5 4 3 2 1]);
 [s,k]=gsort(a+0);
-if or(k<>[1 5 3 4 2]) then bugmes();quit;end
-if or(s<>[5 4 3 2 1]) then bugmes();quit;end
-a=string([5 1 3 2 4])
- a  =
-!5  1  3  2  4  !
-if or(gsort(string([5 1 3 2 4]),'g','i')<>string(1:5)) then bugmes();quit;end
-//[s,k]=gsort(a);
-[s,k]=gsort(string([5 1 3 2 4]),'g','i');
-if or(k<>[2 4 3 5 1]) then bugmes();quit;end
-if or(s<>string(1:5)) then bugmes();quit;end
-a=[]
- a  =
-     []
-if gsort(a)<>[] then bugmes();quit;end
-[s,k]=gsort(a);if s<>[]|k<>[] then bugmes();quit;end
-if gsort([])<>[] then bugmes();quit;end
-[s,k]=gsort([]);if s<>[]|k<>[] then bugmes();quit;end
+assert_checkequal(k, [1 5 3 4 2]);
+assert_checkequal(s, [5 4 3 2 1]);
+a = string([5 1 3 2 4]);
+assert_checkequal(gsort(a,'g','i'), string(1:5));
+[s,k]=gsort(a,'g','i');
+assert_checkequal(k, [2 4 3 5 1]);
+assert_checkequal(s, string(1:5));
+a = [];
+assert_checkequal(gsort(a), []);
+[s,k]=gsort(a);
+assert_checkequal(s, []);
+assert_checkequal(k, []);
+// gsort with sparses (macro: %sp_gsort):
+b = [5 1 3 2 4;6 1 2 4 1];
+B = sparse(b);
+// opts = 'r' and direction = 'd' or 'i'
+[s,k] = gsort(b(:),'r','d');
+[s1,k1] = gsort(B(:),'r','d');
+assert_checkequal(full(s1),s);
+assert_checkequal(k1,k);
+[s,k] = gsort(b(:),'r','i');
+[s1,k1] = gsort(B(:),'r','i');
+assert_checkequal(full(s1),s);
+assert_checkequal(k1,k);
+[s,k] = gsort(b(:)','r','d');
+[s1,k1] = gsort(B(:)','r','d');
+assert_checkequal(full(s1),s);
+assert_checkequal(k1,k);
+[s,k] = gsort(b(:)','r','i');
+[s1,k1] = gsort(B(:)','r','i');
+assert_checkequal(full(s1),s);
+assert_checkequal(k1,k);
+// opts = 'c' and direction = 'd' or 'i'
+[s,k] = gsort(b(:),'c','d');
+[s1,k1] = gsort(B(:),'c','d');
+assert_checkequal(full(s1),s);
+assert_checkequal(k1,k);
+[s,k] = gsort(b(:),'c','i');
+[s1,k1] = gsort(B(:),'c','i');
+assert_checkequal(full(s1),s);
+assert_checkequal(k1,k);
+[s,k] = gsort(b(:)','c','d');
+[s1,k1] = gsort(B(:)','c','d');
+assert_checkequal(full(s1),s);
+assert_checkequal(k1,k);
+[s,k] = gsort(b(:)','c','i');
+[s1,k1] = gsort(B(:)','c','i');
+assert_checkequal(full(s1),s);
+assert_checkequal(k1,k);
+// opts = 'g' and direction = 'd' or 'i'
+[s,k] = gsort(b(:),'g','d');
+[s1,k1] = gsort(B(:),'g','d');
+assert_checkequal(full(s1),s);
+assert_checkequal(k1,k);
+[s,k] = gsort(b(:),'g','i');
+[s1,k1] = gsort(B(:),'g','i');
+assert_checkequal(full(s1),s);
+assert_checkequal(k1,k);
+[s,k] = gsort(b(:)','g','d');
+[s1,k1] = gsort(B(:)','g','d');
+assert_checkequal(full(s1),s);
+assert_checkequal(k1,k);
+[s,k] = gsort(b(:)','g','i');
+[s1,k1] = gsort(B(:)','g','i');
+assert_checkequal(full(s1),s);
+assert_checkequal(k1,k);
+// opts = 'lr' and direction = 'd' or 'i'
+[s,k] = gsort(b(:),'lr','d');
+[s1,k1] = gsort(B(:),'lr','d');
+assert_checkequal(full(s1),s);
+assert_checkequal(k1,k);
+[s,k] = gsort(b(:),'lr','i');
+[s1,k1] = gsort(B(:),'lr','i');
+assert_checkequal(full(s1),s);
+assert_checkequal(k1,k);
+[s,k] = gsort(b(:)','lr','d');
+[s1,k1] = gsort(B(:)','lr','d');
+assert_checkequal(full(s1),s);
+assert_checkequal(k1,k);
+[s,k] = gsort(b(:)','lr','i');
+[s1,k1] = gsort(B(:)','lr','i');
+assert_checkequal(full(s1),s);
+assert_checkequal(k1,k);
+// opts = 'lc' and direction = 'd' or 'i'
+[s,k] = gsort(b(:),'lc','d');
+[s1,k1] = gsort(B(:),'lc','d');
+assert_checkequal(full(s1),s);
+assert_checkequal(k1,k);
+[s,k] = gsort(b(:),'lc','i');
+[s1,k1] = gsort(B(:),'lc','i');
+assert_checkequal(full(s1),s);
+assert_checkequal(k1,k);
+[s,k] = gsort(b(:)','lc','d');
+[s1,k1] = gsort(B(:)','lc','d');
+assert_checkequal(full(s1),s);
+assert_checkequal(k1,k);
+[s,k] = gsort(b(:)','lc','i');
+[s1,k1] = gsort(B(:)','lc','i');
+assert_checkequal(full(s1),s);
+assert_checkequal(k1,k);
+// gsort with complex sparses :
+A = [1 -%i;%i 0];
+A1 = sparse(A);
+c = gsort(A(:),'g','d');
+d = full(gsort(A1(:),'g','d'));
+assert_checkequal(c,d);
+c = gsort(A(:),'g','i');
+d = full(gsort(A1(:),'g','i'));
+assert_checkequal(c,d);
+c = gsort(A(:),'r','d');
+d = full(gsort(A1(:),'r','d'));
+assert_checkequal(c,d);
+c = gsort(A(:),'r','i');
+d = full(gsort(A1(:),'r','i'));
+assert_checkequal(c,d);
+c = gsort(A(:),'c','d');
+d = full(gsort(A1(:),'c','d'));
+assert_checkequal(c,d);
+c = gsort(A(:),'c','i');
+d = full(gsort(A1(:),'c','i'));
+assert_checkequal(c,d);
+B = [1 1+%i 4; -2*%i 3 3-%i];
+B1 = sparse(B);
+c = gsort(B(:),'g','d');
+d = full(gsort(B1(:),'g','d'));
+assert_checkequal(c,d);
+c = gsort(B(:),'g','i');
+d = full(gsort(B1(:),'g','i'));
+assert_checkequal(c,d);
+c = gsort(B(:),'r','d');
+d = full(gsort(B1(:),'r','d'));
+assert_checkequal(c,d);
+c = gsort(B(:),'r','i');
+d = full(gsort(B1(:),'r','i'));
+assert_checkequal(c,d);
+c = gsort(B(:),'c','d');
+d = full(gsort(B1(:),'c','d'));
+assert_checkequal(c,d);
+c = gsort(B(:),'c','i');
+d = full(gsort(B1(:),'c','i'));
+assert_checkequal(c,d);
+C = [-%i 3*%i;4 9;-2*%i 7];
+C1 = sparse(C);
+[s,k] = gsort(C(:),'g','d');
+[s1,k1] = gsort(C1(:),'g','d');
+assert_checkequal(full(s1),s);
+assert_checkequal(k1,k);
+[s,k] = gsort(C(:),'g','i');
+[s1,k1] = gsort(C1(:),'g','i');
+assert_checkequal(full(s1),s);
+assert_checkequal(k1,k);
+[s,k] = gsort(C(:),'r','d');
+[s1,k1] = gsort(C1(:),'r','d');
+assert_checkequal(full(s1),s);
+assert_checkequal(k1,k);
+[s,k] = gsort(C(:),'r','i');
+[s1,k1] = gsort(C1(:),'r','i');
+assert_checkequal(full(s1),s);
+assert_checkequal(k1,k);
+[s,k] = gsort(C(:),'c','d');
+[s1,k1] = gsort(C1(:),'c','d');
+assert_checkequal(full(s1),s);
+assert_checkequal(k1,k);
+[s,k] = gsort(C(:),'c','i');
+[s1,k1] = gsort(C1(:),'c','i');
+assert_checkequal(full(s1),s);
+assert_checkequal(k1,k);
index b6433d2..8b99143 100644 (file)
@@ -3,6 +3,7 @@
 // Copyright (C) ????-2008 - INRIA
 // Copyright (C) ????-2008 - ENPC
 // Copyright (C) 2008 - DIGITEO - Allan CORNET
+// Copyright (C) 2012 - Scilab Enterprises - Adeline CARNIS
 //
 //  This file is distributed under the same license as the Scilab package.
 // =============================================================================
 //================================ complex matrix ================================================
 x = [3  1  5 ; 2 9 8];
 y = [2  4  1 ; 4 1 3];
-c = x+y*%i;
+c = x + y * %i;
 
 ref_ind = [    4.    5.    3.  ;    6.    2.    1.  ];
 ref_values = [     9. + %i      5. + %i      1. + 4.*%i  ;    8. + 3.*%i    2. + 4.*%i    3. + 2.*%i ];
 [v,ind] = gsort(c);
-if or(ref_ind <> ind) then pause,end
-if or(ref_values <> v) then pause,end
+assert_checkequal(ref_ind, ind);
+assert_checkequal(ref_values, v);
 
 [v1,ind1] = gsort(abs(c));
 [v2,ind2] = gsort(c);
-
-if or(ind1<>ind2) then pause,end
+assert_checkequal(ind1, ind2);
 
 A = [18 21 10 7 5];
 B = [1  3  22 8 4];
 y = complex(A,B);
 [a,b] = gsort(y);
-if or( b <> [3 2 1 4 5] ) then pause,end
-if ( y(b) <> a  ) then pause,end
+assert_checkequal(b, [3 2 1 4 5]);
+assert_checkequal(y(b), a);
 
-ierr = execstr("[a,b] = gsort(y,''l'');","errcatch");
-if ierr<> 999 then pause,end
+assert_checkfalse(execstr("[a,b] = gsort(y,''l'')", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong value for input argument #%d: [''g'' ''r'' ''c'' ''lc'' ''lr''] expected.\n"), "gsort", 2); 
+assert_checkerror("[a,b] = gsort(y,''l'')", refMsg);
 
 ierr = execstr("[a,b] = gsort(y,''g'');","errcatch");
-if ierr<> 0 then pause,end
+assert_checkequal(ierr, 0);
 
 ierr = execstr("[a,b] = gsort(y,''r'');","errcatch");
-if ierr<> 0 then pause,end
+assert_checkequal(ierr, 0);
 
 ierr = execstr("[a,b] = gsort(y,''c'');","errcatch");
-if ierr<> 0 then pause,end
+assert_checkequal(ierr, 0);
 
 ierr = execstr("[a,b] = gsort(y,''lc'');","errcatch");
-if ierr<> 0 then pause,end
+assert_checkequal(ierr, 0);
 
 ierr = execstr("[a,b] = gsort(y,''lr'');","errcatch");
-if ierr<> 0 then pause,end
+assert_checkequal(ierr, 0);
 //================================ sparse vectors ================================================
 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
+assert_checkequal(ref, A);
 
 sp = sparse([1,2;4,5;3,10]);
-ierr = execstr('A = gsort(sp);','errcatch');
-if ierr <> 999 then pause,end
+assert_checkfalse(execstr("A = gsort(sp)", "errcatch") == 0);
+refMsg = msprintf(_("%s: Wrong size for input argument #%d: sparse vectors expected.\n"), "gsort", 1); 
+assert_checkerror("A = gsort(sp)", refMsg);
 //================================ Matrix of string case ===========================================
 N = 4;
 P = 20;
@@ -65,1906 +67,1976 @@ a = int(10*rand(N,P,'u'));
 
 //-----Global sort 
 
-[a1,ind]=gsort(string(a),'g');
-[a2,ind2]=gsort(a,'g');
-if norm(evstr(a1)- matrix(a(ind),N,P)) > %eps then pause,end;
-// a and string(a) are in the same order in the previous example 
-if norm(evstr(a1)- a2 ) > %eps then pause,end;
+[a1,ind] = gsort(string(a),'g');
+[a2,ind2] = gsort(a,'g');
+assert_checkalmostequal(norm(evstr(a1)- matrix(a(ind),N,P)), %eps, [], %eps);
+
+// a or string(a) are in the same order in the previous example 
+assert_checkalmostequal(norm(evstr(a1)- a2), %eps, [], %eps);
 
 //-- rows 
-[a1,ind1]=gsort(string(a),'r');   
+[a1,ind1]=gsort(string(a),'r');
 [a2,ind2]=gsort(a,'r');
-if norm(ind1-ind2) > %eps then pause,end;
-// a and string(a) are in the same order in the previous example 
-if norm(evstr(a1)- a2 ) > %eps then pause,end;
+assert_checkalmostequal(norm(ind1-ind2), %eps, [], %eps);
+
+// a or string(a) are in the same order in the previous example 
+assert_checkalmostequal(norm(evstr(a1)- a2), %eps, [], %eps);
+
 
 //--columns 
-[a1,ind1]=gsort(string(a),'c')   ;                      
-[a2,ind2]=gsort(a,'c');
-if norm(ind1-ind2) > %eps then pause,end;
-// a and string(a) are in the same order in the previous example 
-if norm(evstr(a1)- a2 ) > %eps then pause,end;
+[a1,ind1] = gsort(string(a),'c');
+[a2,ind2] = gsort(a,'c');
+assert_checkalmostequal(norm(ind1-ind2), %eps, [], %eps);
+
+// a or string(a) are in the same order in the previous example 
+assert_checkalmostequal(norm(evstr(a1)- a2), %eps, [], %eps);
 
 //----sort the rows of a in lexicographic order 
 
-N1=4;P1=3;
-alr=[1,2,2;
-     1,2,1;
-     1,1,2;
-     1,1,1];
+N1 = 4;P1 = 3;
+alr = [1,2,2;
+1,2,1;
+1,1,2;
+1,1,1];
 // a random permutation 
-[ax,perm]=gsort(rand(1,N1,'u'));
-a=alr(perm,:);
-[a1,ind]=gsort(string(a),'lr') ;        
-[a2,ind]=gsort(a,'lr') ;
-//
-if norm(evstr(a1)- matrix(a(ind,:),N1,P1)) > %eps then pause,end;
-// a and string(a) are in the same order in the previous example 
-if norm(evstr(a1)- a2 ) > %eps then pause,end;
+[ax,perm] = gsort(rand(1,N1,'u'));
+a = alr(perm,:);
+[a1,ind] = gsort(string(a),'lr');
+[a2,ind] = gsort(a,'lr') ;
+
+assert_checkalmostequal(norm(evstr(a1)- matrix(a(ind,:),N1,P1)), %eps, [], %eps);
+
+// a or string(a) are in the same order in the previous example 
+assert_checkalmostequal(norm(evstr(a1)- a2), %eps, [], %eps);
+
 
 //----sort the columns of a in lexicographic order 
-N1=3;P1=4;
-alr=alr';
+N1 = 3;P1 = 4;
+alr = alr';
 // a random permutation 
-[ax,perm]=gsort(rand(1,P1,'u'));
-a=alr(:,perm);
+[ax,perm] = gsort(rand(1,P1,'u'));
+a = alr(:,perm);
+
+[a1,ind] = gsort(string(a),'lc');
+[a2,ind] = gsort(a,'lc') ;
+
+assert_checkalmostequal(norm(evstr(a1)- matrix(a(:,ind),N1,P1)), %eps, [], %eps);
+
+// a or string(a) are in the same order in the previous example 
+assert_checkalmostequal(norm(evstr(a1)- a2), %eps, [], %eps);
 
-[a1,ind]=gsort(string(a),'lc');                   
-[a2,ind]=gsort(a,'lc') ;
-//
-if norm(evstr(a1)- matrix(a(:,ind),N1,P1)) > %eps then pause,end;
-// a and string(a) are in the same order in the previous example 
-if norm(evstr(a1)- a2 ) > %eps then pause,end;
 //================================ Matrix of double case ===========================================
-N=4;P=20;Nrand=100; 
+N = 4;P = 20;Nrand = 100; 
 
 a = matrix(grand(1,'prm',(1:N*P)'),N,P);
 
 //-----Global sort --------------------------------
 
 [a1,ind]=gsort(a,'g');
-
-if norm(a1- matrix(N*P:-1:1,N,P)) > %eps then pause,end;
-if norm(a1- matrix(a(ind),N,P)) > %eps then pause,end;
+assert_checkalmostequal(norm(a1- matrix(N*P:-1:1,N,P)), %eps, [], %eps);
+assert_checkalmostequal(norm(a1- matrix(a(ind),N,P)), %eps, [], %eps);
 
 for i=1:Nrand 
-  b = int(10*rand(N,P,'u')); 
-  [b1,ind]=gsort(b,'g');
-  if norm(b1- matrix(b(ind),N,P)) > %eps then pause,end;
-  if or(b1(1:$-1)-b1(2:$) <0) then pause,end
-end 
+    b = int(10*rand(N,P,'u')); 
+    [b1,ind] = gsort(b,'g');
+    assert_checkalmostequal(norm(b1- matrix(b(ind),N,P)), %eps, [], %eps);
+    assert_checktrue(or(b1(1:$-1)-b1(2:$) >= 0));
+end
 
 //increasing values 
 
-[a1,ind]=gsort(a,'g','i');
-
-if norm(a1- matrix(1:N*P,N,P)) > %eps then pause,end;
-if norm(a1- matrix(a(ind),N,P)) > %eps then pause,end;
+[a1,ind] = gsort(a,'g','i');
+assert_checkalmostequal(norm(a1- matrix(1:N*P,N,P)), %eps, [], %eps);
+assert_checkalmostequal(norm(a1- matrix(a(ind),N,P)), %eps, [], %eps);
 
 for i=1:100
-  b = int(10*rand(N,P,'u')); 
-  [b1,ind]=gsort(b,'g','i');
-  if norm(b1- matrix(b(ind),N,P)) > %eps then pause,end;
-  if or(b1(1:$-1)-b1(2:$) > 0) then pause,end
-end 
+    b = int(10*rand(N,P,'u')); 
+    [b1,ind] = gsort(b,'g','i');
+    assert_checkalmostequal(norm(b1- matrix(b(ind),N,P)), %eps, [], %eps);
+    assert_checktrue(or(b1(1:$-1)-b1(2:$) <= 0));
+end
 
 //----sort each column of a ('r' means that the row indice is used for sorting)
 
-[a1,ind]=gsort(a,'r');
-nc=size(a,'c');
-test=[];
-for i=1:nc ; 
-   test= [test, matrix(a(ind(:,i),i),N,1)];
-end 
-if norm(a1- test) > %eps then pause,end;
-test=[];
-for i=1:nc ; 
-   test= [test, gsort(a(:,i),'g')];
-end 
-if norm(a1- test) > %eps then pause,end;
-
-for i=1:Nrand
-  b = int(10*rand(N,P,'u')); 
-  [b1,ind]=gsort(b,'r');
-  if or( b1(2:$,:)-b1(1:$-1,:) > 0 ) then pause,end 
-  test=[];
-  for j=1:nc ; 
-    test= [test, matrix(b(ind(:,j),j),N,1)];
-  end 
-  if norm(b1- test) > %eps then pause,end;
+[a1,ind] = gsort(a,'r');
+nc = size(a,'c');
+test = [];
+for i = 1:nc;
+    test = [test, matrix(a(ind(:,i),i),N,1)];
 end 
+assert_checkalmostequal(norm(a1- test), %eps, [], %eps);
+
+test = [];
+for i = 1:nc;
+    test = [test, gsort(a(:,i),'g')];
+end
+assert_checkalmostequal(norm(a1- test), %eps, [], %eps);
+
+for i = 1:Nrand
+    b = int(10*rand(N,P,'u')); 
+    [b1,ind] = gsort(b,'r');
+    assert_checkequal(or(b1(2:$,:) - b1(1:$-1,:) > 0), %f);
+    test = [];
+    for j = 1:nc
+        test = [test, matrix(b(ind(:,j),j),N,1)];
+    end
+    assert_checkalmostequal(norm(b1- test), %eps, [], %eps);
+end
 
 //increasing values 
 
-[a1,ind]=gsort(a,'r','i');
-nc=size(a,'c');
-test=[];
-for i=1:nc ; 
-  test= [test, matrix(a(ind(:,i),i),N,1)];
-end 
-if norm(a1- test) > %eps then pause,end;
-test=[];
-for i=1:nc ; 
-   test= [test, gsort(a(:,i),'g','i')];
-end 
-if norm(a1- test) > %eps then pause,end;
+[a1,ind] = gsort(a,'r','i');
+nc = size(a,'c');
+test = [];
+for i = 1:nc 
+    test = [test, matrix(a(ind(:,i),i),N,1)];
+end
+assert_checkalmostequal(norm(a1- test), %eps, [], %eps);
+
+test = [];
+for i = 1:nc 
+    test = [test, gsort(a(:,i),'g','i')];
+end
+assert_checkalmostequal(norm(a1- test), %eps, [], %eps);
 
 //----sort each row of a ('c' means that the column indice is used for sorting)
+[a1,ind] = gsort(a,'c');
+nr = size(a,'r');
+test = [];
+for i = 1:nr 
+    test = [test; matrix(a(i,ind(i,:)),1,P)];
+end
+assert_checkalmostequal(norm(a1- test), %eps, [], %eps);
 
-[a1,ind]=gsort(a,'c')   ;
-nr=size(a,'r');
-test=[];
-for i=1:nr ; 
-   test= [test; matrix(a(i,ind(i,:)),1,P)];
-end 
-if norm(a1- test) > %eps then pause,end;
-test=[];
-for i=1:nr ; 
-   test= [test; gsort(a(i,:),'g')];
-end 
-if norm(a1- test) > %eps then pause,end;
-
-for i=1:Nrand
-  b = int(10*rand(N,P,'u')); 
-  [b1,ind]=gsort(b,'c');
-  if or( b1(:,2:$)-b1(:,1:$-1) > 0 ) then pause,end 
-  test=[];
-  for j=1:nr ; 
-    test= [test; b(j,ind(j,:))];
-  end 
-  if norm(b1- test) > %eps then pause,end;
-end 
+test = [];
+for i = 1:nr 
+    test = [test; gsort(a(i,:),'g')];
+end
+assert_checkalmostequal(norm(a1- test), %eps, [], %eps);
+
+for i = 1:Nrand
+    b = int(10*rand(N,P,'u')); 
+    [b1,ind] = gsort(b,'c');
+    assert_checkequal(or(b1(:,2:$) - b1(:,1:$-1) > 0), %f);
+    test = [];
+    for j = 1:nr
+        test = [test; b(j,ind(j,:))];
+    end
+    assert_checkalmostequal(norm(b1- test), %eps, [], %eps);
+end
 
 //increasing 
-
-[a1,ind]=gsort(a,'c','i')   ;
-nr=size(a,'r');
-test=[];
-for i=1:nr ; 
-   test= [test; matrix(a(i,ind(i,:)),1,P)];
+[a1,ind] = gsort(a,'c','i');
+nr = size(a,'r');
+test = [];
+for i = 1:nr
+    test = [test; matrix(a(i,ind(i,:)),1,P)];
 end 
-if norm(a1- test) > %eps then pause,end;
-test=[];
-for i=1:nr ; 
-   test= [test; gsort(a(i,:),'g','i')];
-end 
-if norm(a1- test) > %eps then pause,end;
+assert_checkalmostequal(norm(a1- test), %eps, [], %eps);
+
+test = [];
+for i = 1:nr
+    test = [test; gsort(a(i,:),'g','i')];
+end
+assert_checkalmostequal(norm(a1- test), %eps, [], %eps);
+
 
 //----sort the rows of a in lexicographic order 
 //    i.e a(k,:) < a(l,:) if there's a number j 
-//    such that a(k,j) < a(l,j) and a(k,p)=a(l,p) for p in [1,j-1];
+//    such that a(k,j) < a(l,j) or a(k,p)=a(l,p) for p in [1,j-1];
 //
-N1=4;P1=3;
-alr=[1,2,2;
-     1,2,1;
-     1,1,2;
-     1,1,1];
+vmax = 4;
+N1 = 4;P1 = 3;
+alr = [1,2,2;
+1,2,1;
+1,1,2;
+1,1,1];
 // a random permutation 
-[ax,perm]=gsort(rand(1,N1,'u'));
-a=alr(perm,:);
-
-[a1,ind]=gsort(a,'lr');                   
-
-if norm(a1- alr) > %eps then pause,end;
-if norm(a1- matrix(a(ind,:),N1,P1)) > %eps then pause,end;
-
-[a2,ind2]=gsort(a*[100;10;1],'g');
-if norm(ind2-ind) > %eps then pause,end;
-
-for i=1:Nrand
-  vmax=4;
-  b = int(vmax*rand(N,P,'u')); 
-  [b1,ind]=gsort(b,'lr');
-  if norm(b1- b(ind,:)) > %eps then pause,end;
-  v= b1*((vmax+1)^[P-1:-1:0])';
-  if or( v(2:$)-v(1:$-1) > 0 ) then pause,end 
-end 
+[ax,perm] = gsort(rand(1, N1, 'u'));
+a = alr(perm,:);
+
+[a1,ind] = gsort(a,'lr');
+assert_checkalmostequal(norm(a1 - alr), %eps, [], %eps);
+assert_checkalmostequal(norm(a1 - matrix(a(ind,:),N1,P1)), %eps, [], %eps);
+
+[a2,ind2] = gsort(a*[100;10;1],'g');
+assert_checkalmostequal(norm(ind2 - ind), %eps, [], %eps);
+
+for i = 1:Nrand
+    b = int(vmax * rand(N,P,'u')); 
+    [b1,ind] = gsort(b,'lr');
+    assert_checkalmostequal(norm(b1 - b(ind,:)), %eps, [], %eps);
+    v = b1 * ((vmax + 1) ^ [P - 1 : -1 : 0])';
+    assert_checktrue(or(v(2:$) - v(1:$-1) <= 0));
+end
 
 // increasing 
-
-[a1,ind]=gsort(a,'lr','i');                   
-if norm(a1- alr(N1:-1:1,:)) > %eps then pause,end;
-if norm(a1- matrix(a(ind,:),N1,P1)) > %eps then pause,end;
-[a2,ind2]=gsort(a*[100;10;1],'g','i');
-if norm(ind2-ind) > %eps then pause,end;
-
-for i=1:Nrand
-  vmax=4;
-  b = int(vmax*rand(N,P,'u')); 
-  [b1,ind]=gsort(b,'lr','i');
-  if norm(b1- b(ind,:)) > %eps then pause,end;
-  v= b1*((vmax+1)^[P-1:-1:0])';
-  if or( v(2:$)-v(1:$-1) < 0 ) then pause,end 
-end 
+[a1,ind] = gsort(a,'lr','i');
+assert_checkalmostequal(norm(a1 - alr(N1:-1:1,:)), %eps, [], %eps);
+assert_checkalmostequal(norm(a1 - matrix(a(ind,:),N1,P1)), %eps, [], %eps);
+
+[a2,ind2] = gsort(a * [100;10;1],'g','i');
+assert_checkalmostequal(norm(ind2 - ind), %eps, [], %eps);
+
+for i = 1:Nrand    
+    b = int(vmax * rand(N,P,'u')); 
+    [b1,ind] = gsort(b,'lr','i');
+    assert_checkalmostequal(norm(b1 - b(ind,:)), %eps, [], %eps);
+    v= b1*((vmax+1)^[P-1:-1:0])';
+    assert_checktrue(or(v(2:$) - v(1:$-1) >= 0));
+end
 
 //----sort the columns of a in lexicographic order 
-
-N1=3;P1=4;
-alr=alr';
+N1 = 3;P1 = 4;
+alr = alr';
 // a random permutation 
-[ax,perm]=gsort(rand(1,P1,'u'));
-a=alr(:,perm);
+[ax,perm] = gsort(rand(1,P1,'u'));
+a = alr(:,perm);
 
-[a1,ind]=gsort(a,'lc');                   
+[a1,ind] = gsort(a,'lc');
+assert_checkalmostequal(norm(a1 - alr), %eps, [], %eps);
+assert_checkalmostequal(norm(a1- matrix(a(:,ind),N1,P1)), %eps, [], %eps);
 
-if norm(a1- alr) > %eps then pause,end;
-if norm(a1- matrix(a(:,ind),N1,P1)) > %eps then pause,end;
+[a2,ind2] = gsort([100,10,1]*a,'g');
+assert_checkalmostequal(norm(ind2 - ind), %eps, [], %eps);
 
-[a2,ind2]=gsort([100,10,1]*a,'g');
-if norm(ind2-ind) > %eps then pause,end;
-
-for i=1:Nrand
-  vmax=4;
-  b = int(vmax*rand(N1,P1,'u')); 
-  [b1,ind]=gsort(b,'lc');
-  if norm(b1- b(:,ind)) > %eps then pause,end;
-  v= ((vmax+1)^[N1-1:-1:0])*b1;
-  if or( v(2:$)-v(1:$-1) > 0 ) then pause,end 
+for i = 1:Nrand
+    b = int(vmax * rand(N1,P1,'u')); 
+    [b1,ind] = gsort(b,'lc');
+    assert_checkalmostequal(norm(b1 - b(:,ind)), %eps, [], %eps);
+    v = ((vmax+1)^[N1-1:-1:0])*b1;
+    assert_checktrue(or(v(2:$) - v(1:$-1) <= 0));
 end 
 
 //increasing 
+[a1,ind] = gsort(a,'lc','i');
 
-[a1,ind]=gsort(a,'lc','i');                   
+assert_checkalmostequal(norm(a1 - alr(:,P1:-1:1)), %eps, [], %eps);
+assert_checkalmostequal(norm(a1 - matrix(a(:,ind),N1,P1)), %eps, [], %eps);
 
-if norm(a1- alr(:,P1:-1:1)) > %eps then pause,end;
-if norm(a1- matrix(a(:,ind),N1,P1)) > %eps then pause,end;
+[a2,ind2] = gsort([100,10,1]*a,'g','i');
+assert_checkalmostequal(norm(ind2 - ind), %eps, [], %eps);
 
-[a2,ind2]=gsort([100,10,1]*a,'g','i');
-if norm(ind2-ind) > %eps then pause,end;
-
-for i=1:Nrand
-  vmax=4;
-  b = int(vmax*rand(N,P,'u')); 
-  [b1,ind]=gsort(b,'lc','i');
-  if norm(b1- b(:,ind)) > %eps then pause,end;
-  v= ((vmax+1)^[N-1:-1:0])*b1;
-  if or( v(2:$)-v(1:$-1) < 0 ) then pause,end 
+for i = 1:Nrand
+    b = int(vmax * rand(N,P,'u')); 
+    [b1,ind] = gsort(b,'lc','i');
+    assert_checkalmostequal(norm(b1 - b(:,ind)), %eps, [], %eps);
+    v = ((vmax+1)^[N-1:-1:0])*b1;
+    assert_checktrue(or(v(2:$) - v(1:$-1) >= 0));
 end 
 
 a = [1,1,1,1,2,2,3,3,2,2,3,3,4,4,4,4,4,4,4,4,5,5,5,6,6,6,7,7,7,7,8,8,8,8,9,9,9,9,9,9,9,7,9,10,..
- 10,10,10,11,11,11,12,13,13,13,13,14,14,12,12,14,14,14,14,14,14,15,15,15,15,16,17,18;
+10,10,10,11,11,11,12,13,13,13,13,14,14,12,12,14,14,14,14,14,14,15,15,15,15,16,17,18;
 3,4,4,5,3,8,4,4,7,8,8,8,5,5,8,9,10,10,9,8,6,10,10,10,10,11,8,8,13,13,9,9,13,13,10,10,13,..
- 13,14,15,15,12,14,11,11,15,15,15,15,16,17,14,14,17,17,15,15,13,13,17,17,18,18,19,19,16,..
- 16,19,19,19,18,19]';
-[b,ind]=gsort(a,'lr','i');
-t=b(2:$,:)-b(1:$-1,:);
-if or(t(:,1)<0) then pause,end
-if or(t(find(t(:,1)==0),2)<0) then pause,end
-if or(a(ind,:)<>b) then pause,end
-
-for k=1:30
-  p=grand(1,'prm',(1:size(a,1))');
-  [b,ind]=gsort(a(p,:),'lr','i');      
-  t=b(2:$,:)-b(1:$-1,:);
-  if or(t(:,1)<0) then pause,end
-  if or(t(find(t(:,1)==0),2)<0) then pause,end
-  if or(a(p(ind),:)<>b) then pause,end
+13,14,15,15,12,14,11,11,15,15,15,15,16,17,14,14,17,17,15,15,13,13,17,17,18,18,19,19,16,..
+16,19,19,19,18,19]';
+[b,ind] = gsort(a,'lr','i');
+t = b(2:$,:) - b(1:$-1,:);
+assert_checktrue(or(t(:,1) >= 0));
+assert_checktrue(or(t(find(t(:,1)==0),2)>=0));
+assert_checkequal(a(ind,:), b);
+
+for k = 1:30
+    p = grand(1,'prm',(1:size(a,1))');
+    [b,ind] = gsort(a(p,:),'lr','i');  
+    t = b(2:$,:) - b(1:$-1,:);
+    assert_checktrue(or(t(:,1) >= 0));
+    assert_checktrue(or(t(find(t(:,1)==0),2)>=0));
+    assert_checkequal(a(p(ind),:), b);
 end
 
-[b,ind]=gsort(a,'lr','d');
-t=b(1:$-1,:)-b(2:$,:);
-if or(t(:,1)<0) then pause,end
-if or(t(find(t(:,1)==0),2)<0) then pause,end
-if or(a(ind,:)<>b) then pause,end
-
-for k=1:30
-  p=grand(1,'prm',(1:size(a,1))');
-  [b,ind]=gsort(a(p,:),'lr','d');      
-  t=b(1:$-1,:)-b(2:$,:);
-  if or(t(:,1)<0) then pause,end
-  if or(t(find(t(:,1)==0),2)<0) then pause,end
-  if or(a(p(ind),:)<>b) then pause,end
+[b,ind] = gsort(a,'lr','d');
+t = b(1:$-1,:) - b(2:$,:);
+assert_checktrue(or(t(:,1) >= 0));
+assert_checktrue(or(t(find(t(:,1)==0),2)>=0));
+assert_checkequal(a(ind,:), b);
+
+for k = 1:30
+    p = grand(1,'prm',(1:size(a,1))');
+    [b,ind] = gsort(a(p,:),'lr','d');  
+    t = b(1:$-1,:) - b(2:$,:);
+    assert_checktrue(or(t(:,1) >= 0));
+    assert_checktrue(or(t(find(t(:,1)==0),2)>=0));
+    assert_checkequal(a(p(ind),:), b);
 end
 
-
-a=b;
-a([10 60],:)=a([60 10],:);
-[b,ind]=gsort(a,'lr','i');
-t=b(2:$,:)-b(1:$-1,:);
-if or(t(:,1)<0) then pause,end
-if or(t(find(t(:,1)==0),2)<0) then pause,end
-if or(a(ind,:)<>b) then pause,end
-
-[b,ind]=gsort(a,'lr','d');
-t=b(1:$-1,:)-b(2:$,:);
-if or(t(:,1)<0) then pause,end
-if or(t(find(t(:,1)==0),2)<0) then pause,end
-if or(a(ind,:)<>b) then pause,end
-
-//================================ Matrix of int32 and uint32 case =======================================
-N=4;P=20;Nrand=100; 
+a = b;
+a([10 60],:) = a([60 10],:);
+[b,ind] = gsort(a,'lr','i');
+t = b(2:$,:) - b(1:$-1,:);
+assert_checktrue(or(t(:,1) >= 0));
+assert_checktrue(or(t(find(t(:,1)==0),2)>=0));
+assert_checkequal(a(ind,:), b);
+
+[b,ind] = gsort(a,'lr','d');
+t = b(1:$-1,:) - b(2:$,:);
+assert_checktrue(or(t(:,1) >= 0));
+assert_checktrue(or(t(find(t(:,1)==0),2)>=0));
+assert_checkequal(a(ind,:), b);
+//================================ Matrix of int32 or uint32 case =======================================
+N = 4;P = 20;Nrand = 100; vmax = 4;
 
 a = int32(matrix(grand(1,'prm',(1:N*P)'),N,P));
 
 //-----Global sort --------------------------------
+[a1,ind] = gsort(a,'g');
+assert_checkequal(a1, int32(matrix(N * P:-1:1,N,P)));
+assert_checkequal(a1, matrix(a(ind),N,P));
+
+for i = 1:Nrand 
+    b = int32(10 * rand(N,P,'u')); 
+    [b1,ind] = gsort(b,'g');
+    assert_checkequal(b1, matrix(b(ind),N,P));
+    assert_checktrue(or(b1(1:$-1) - b1(2:$) >= 0));
+end
 
-[a1,ind]=gsort(a,'g');
-
-if or(a1- matrix(N*P:-1:1,N,P) <>0) then pause,end;
-if or(a1- matrix(a(ind),N,P)  <>0) then pause,end;
-
-for i=1:Nrand 
-  b = int32(10*rand(N,P,'u')); 
-  [b1,ind]=gsort(b,'g');
-  if or(b1- matrix(b(ind),N,P)<>0)  then pause,end;
-  if or(b1(1:$-1)-b1(2:$) <0) then pause,end
-end 
-
-//increasing values 
-
-[a1,ind]=gsort(a,'g','i');
-
-if or(a1- matrix(1:N*P,N,P) <>0) then pause,end;
-if or(a1- matrix(a(ind),N,P)  <>0) then pause,end;
-
-
-for i=1:100
-  b = int32(10*rand(N,P,'u')); 
-  [b1,ind]=gsort(b,'g','i');
-  if or(b1- matrix(b(ind),N,P)<>0)  then pause,end;
-  if or(b1(1:$-1)-b1(2:$) > 0) then pause,end
-end 
+//increasing values
+[a1,ind] = gsort(a,'g','i');
+assert_checkequal(a1, int32(matrix(1:N*P,N,P)));
+assert_checkequal(a1, matrix(a(ind),N,P));
 
+for i = 1:100
+    b = int32(10*rand(N,P,'u')); 
+    [b1,ind]=gsort(b,'g','i');
+    assert_checkequal(b1, matrix(b(ind),N,P));
+    assert_checktrue(or(b1(1:$-1) - b1(2:$) <= 0));
+end
 
 //----sort each column of a ('r' means that the row indice is used for sorting)
+[a1,ind] = gsort(a,'r');
+nc = size(a,'c');
+test = [];
+for i = 1:nc
+    test = [test, matrix(a(ind(:,i),i),N,1)];
+end
+assert_checkequal(a1, test);
 
-[a1,ind]=gsort(a,'r');
-nc=size(a,'c');
-test=[];
-for i=1:nc ; 
-   test= [test, matrix(a(ind(:,i),i),N,1)];
-end 
-if or((a1- test)<>0)  then pause,end;
-test=[];
-for i=1:nc ; 
-   test= [test, gsort(a(:,i),'g')];
-end 
-if or((a1- test)<>0)  then pause,end;
-
-
-for i=1:Nrand
-  b = int32(10*rand(N,P,'u')); 
-  [b1,ind]=gsort(b,'r');
-  if or( b1(2:$,:)-b1(1:$-1,:) > 0 ) then pause,end 
-  test=[];
-  for j=1:nc ; 
-    test= [test, matrix(b(ind(:,j),j),N,1)];
-  end 
-  if or((b1- test)<>0) then pause,end;
-end 
+test = [];
+for i =1:nc
+    test = [test, gsort(a(:,i),'g')];
+end
+assert_checkequal(a1, test);
+
+for i = 1:Nrand
+    b = int32(10*rand(N,P,'u')); 
+    [b1,ind] = gsort(b,'r');
+    assert_checkequal(or(b1(2:$,:) - b1(1:$-1,:) > 0), %f);
+    test = [];
+    for j = 1:nc 
+        test = [test, matrix(b(ind(:,j),j),N,1)];
+    end 
+    assert_checkequal(b1, test);
+end
 
 //increasing values 
-
-[a1,ind]=gsort(a,'r','i');
-nc=size(a,'c');
-test=[];
-for i=1:nc ; 
-  test= [test, matrix(a(ind(:,i),i),N,1)];
+[a1,ind] = gsort(a,'r','i');
+nc = size(a,'c');
+test = [];
+for i = 1:nc
+    test = [test, matrix(a(ind(:,i),i),N,1)];
 end 
-if or((a1- test)<>0)  then pause,end;
+assert_checkequal(a1, test);
 
-test=[];
-for i=1:nc ; 
-   test= [test, gsort(a(:,i),'g','i')];
+test = [];
+for i = 1:nc 
+    test = [test, gsort(a(:,i),'g','i')];
 end 
-if or((a1- test)<>0)  then pause,end;
+assert_checkequal(a1, test);
 
 //----sort each row of a ('c' means that the column indice is used for sorting)
+[a1,ind] = gsort(a,'c');
+nr = size(a,'r');
+test = [];
+for i = 1:nr
+    test = [test; matrix(a(i,ind(i,:)),1,P)];
+end
+assert_checkequal(a1, test);
 
-[a1,ind]=gsort(a,'c')   ;
-nr=size(a,'r');
-test=[];
-for i=1:nr ; 
-   test= [test; matrix(a(i,ind(i,:)),1,P)];
-end 
-if or((a1- test)<>0)  then pause,end;
+test = [];
+for i = 1:nr ; 
+    test = [test; gsort(a(i,:),'g')];
+end
+assert_checkequal(a1, test);
 
-test=[];
-for i=1:nr ; 
-   test= [test; gsort(a(i,:),'g')];
-end 
-if or((a1- test)<>0)  then pause,end;
-
-
-for i=1:Nrand
-  b = int32(10*rand(N,P,'u')); 
-  [b1,ind]=gsort(b,'c');
-  if or( b1(:,2:$)-b1(:,1:$-1) > 0 ) then pause,end 
-  test=[];
-  for j=1:nr ; 
-    test= [test; b(j,ind(j,:))];
-  end 
-  if or((b1- test)<>0) then pause,end;
+for i = 1:Nrand
+    b = int32(10 * rand(N,P,'u')); 
+    [b1,ind] = gsort(b,'c');
+    assert_checkequal(or(b1(:,2:$) - b1(:,1:$-1) > 0), %f);
+    test = [];
+    for j = 1:nr
+        test = [test; b(j,ind(j,:))];
+    end
+    assert_checkequal(b1, test);
 end 
 
-//increasing 
-
-[a1,ind]=gsort(a,'c','i')   ;
-nr=size(a,'r');
-test=[];
-for i=1:nr ; 
-   test= [test; matrix(a(i,ind(i,:)),1,P)];
+//increasing
+[a1,ind] = gsort(a,'c','i');
+nr = size(a,'r');
+test = [];
+for i = 1:nr
+    test = [test; matrix(a(i,ind(i,:)),1,P)];
 end 
-if or((a1- test)<>0)  then pause,end;
-test=[];
-for i=1:nr ; 
-   test= [test; gsort(a(i,:),'g','i')];
+assert_checkequal(a1, test);
+test = [];
+for i = 1:nr
+    test = [test; gsort(a(i,:),'g','i')];
 end 
-if or((a1- test)<>0)  then pause,end;
+assert_checkequal(a1, test);
 
 //----sort the rows of a in lexicographic order 
 //    i.e a(k,:) < a(l,:) if there's a number j 
-//    such that a(k,j) < a(l,j) and a(k,p)=a(l,p) for p in [1,j-1];
+//    such that a(k,j) < a(l,j) or a(k,p)=a(l,p) for p in [1,j-1];
 //
 N1=4;P1=3;
 alr=[1,2,2;
-     1,2,1;
-     1,1,2;
-     1,1,1];
+1,2,1;
+1,1,2;
+1,1,1];
 // a random permutation 
-[ax,perm]=gsort(rand(1,N1,'u'));
-a=alr(perm,:);
+[ax,perm] = gsort(rand(1,N1,'u'));
+a = int32(alr(perm,:));
 
-[a1,ind]=gsort(a,'lr');                   
+[a1,ind] = gsort(a,'lr');
 
-if or((a1- alr) <>0) then pause,end;
-if or((a1- matrix(a(ind,:),N1,P1)) <>0) then pause,end;
+assert_checkequal(a1, int32(alr));
+assert_checkequal(a1, matrix(a(ind,:),N1,P1));
 
-[a2,ind2]=gsort(a*[100;10;1],'g');
-if or((ind2-ind)<>0) then pause,end;
+[a2,ind2] = gsort(a*[100;10;1],'g');
+assert_checkequal(ind2, ind);
 ///////////////////////
-for i=1:Nrand
-  vmax=4;
-  b = int32(vmax*rand(N,P,'u')); 
-  [b1,ind]=gsort(b,'lr');
-  if or((b1- b(ind,:)) <>0) then pause,end;
-  v= double(b1)*((vmax+1)^[P-1:-1:0])';
-  if or( v(2:$)-v(1:$-1) > 0 ) then pause,end 
+for i = 1:Nrand
+    b = int32(vmax*rand(N,P,'u')); 
+    [b1,ind] = gsort(b,'lr');
+    assert_checkequal(b1, b(ind,:));
+    v = double(b1)*((vmax+1)^[P-1:-1:0])';
+    assert_checktrue(or(v(2:$) - v(1:$-1) <= 0));
 end 
 
 // increasing 
+[a1,ind] = gsort(a,'lr','i');
+assert_checkequal(a1, int32(alr(N1:-1:1,:)));
+assert_checkequal(a1, matrix(a(ind,:),N1,P1));
+
+[a2,ind2] = gsort(a*[100;10;1],'g','i');
+assert_checkequal(ind2, ind);
+
+for i = 1:Nrand
+    b = int(vmax * rand(N,P,'u')); 
+    [b1,ind] = gsort(b,'lr','i');
+    assert_checkequal(b1, b(ind,:));
+    v = double(b1)*((vmax+1)^[P-1:-1:0])';
+    assert_checktrue(or(v(2:$) - v(1:$-1) >= 0));
+end
 
-[a1,ind]=gsort(a,'lr','i');                   
-if or((a1- alr(N1:-1:1,:)) <>0) then pause,end;
-
-if or((a1- matrix(a(ind,:),N1,P1)) <>0) then pause,end;
-[a2,ind2]=gsort(a*[100;10;1],'g','i');
-if or((ind2-ind) <>0) then pause,end;
-
-for i=1:Nrand
-  vmax=4;
-  b = int(vmax*rand(N,P,'u')); 
-  [b1,ind]=gsort(b,'lr','i');
-  if or((b1- b(ind,:)) <>0) then pause,end;
-  v= double(b1)*((vmax+1)^[P-1:-1:0])';
-  if or( v(2:$)-v(1:$-1) < 0 ) then pause,end 
-end 
-
-
-//----sort the columns of a in lexicographic order 
-
-N1=3;P1=4;
-alr=alr';
+//----sort the columns of a in lexicographic order
+N1 = 3;P1 = 4;
+alr = alr';
 // a random permutation 
-[ax,perm]=gsort(rand(1,P1,'u'));
-a=alr(:,perm);
-
-[a1,ind]=gsort(a,'lc');                   
-
-if or((a1- alr) <>0) then pause,end;
-if or((a1- matrix(a(:,ind),N1,P1)) <>0) then pause,end;
-
-[a2,ind2]=gsort([100,10,1]*a,'g');
-if or((ind2-ind) <>0) then pause,end;
-
-for i=1:Nrand
-  vmax=4;
-  b = int(vmax*rand(N1,P1,'u')); 
-  [b1,ind]=gsort(b,'lc');
-  if or((b1- b(:,ind)) <>0) then pause,end;
-  v= ((vmax+1)^[N1-1:-1:0])*double(b1);
-  if or( v(2:$)-v(1:$-1) > 0 ) then pause,end 
-end 
-
-//increasing 
-
-[a1,ind]=gsort(a,'lc','i');                   
-
-if or((a1- alr(:,P1:-1:1)) <>0) then pause,end;
-if or((a1- matrix(a(:,ind),N1,P1)) <>0) then pause,end;
-
-[a2,ind2]=gsort([100,10,1]*a,'g','i');
-if or((ind2-ind) <>0) then pause,end;
-
-for i=1:Nrand
-  vmax=4;
-  b = int(vmax*rand(N,P,'u')); 
-  [b1,ind]=gsort(b,'lc','i');
-  if or((b1- b(:,ind)) <>0) then pause,end;
-  v= ((vmax+1)^[N-1:-1:0])*b1;
-  if or( v(2:$)-v(1:$-1) < 0 ) then pause,end 
-end 
-
-
+[ax,perm] = gsort(rand(1,P1,'u'));
+a = int32(alr(:,perm));
+
+[a1,ind] = gsort(a,'lc');
+assert_checkequal(a1, int32(alr));
+assert_checkequal(a1, matrix(a(:,ind),N1,P1));
+
+[a2,ind2] = gsort([100,10,1]*a,'g');
+assert_checkequal(ind2, ind);
+
+for i = 1:Nrand
+    b = int(vmax*rand(N1,P1,'u')); 
+    [b1,ind] = gsort(b,'lc');
+    assert_checkequal(b1, b(:,ind));
+    v= ((vmax+1)^[N1-1:-1:0])*double(b1);
+    assert_checktrue(or(v(2:$) - v(1:$-1) <= 0));
+end 
+
+//increasing
+[a1,ind] = gsort(a,'lc','i');
+assert_checkequal(a1, int32(alr(:,P1:-1:1)));
+assert_checkequal(a1, matrix(a(:,ind),N1,P1));
+
+[a2,ind2] = gsort([100,10,1] * a,'g','i');
+assert_checkequal(ind2, ind);
+
+for i = 1:Nrand
+    b = int(vmax*rand(N,P,'u')); 
+    [b1,ind] = gsort(b,'lc','i');
+    assert_checkequal(b1, b(:,ind));
+    v = ((vmax+1)^[N-1:-1:0])*b1;
+    assert_checktrue(or(v(2:$) - v(1:$-1) >= 0));
+end
 
 a = int32([1,1,1,1,2,2,3,3,2,2,3,3,4,4,4,4,4,4,4,4,5,5,5,6,6,6,7,7,7,7,8,8,8,8,9,9,9,9,9,9,9,7,9,10,..
- 10,10,10,11,11,11,12,13,13,13,13,14,14,12,12,14,14,14,14,14,14,15,15,15,15,16,17,18;
+10,10,10,11,11,11,12,13,13,13,13,14,14,12,12,14,14,14,14,14,14,15,15,15,15,16,17,18;
 3,4,4,5,3,8,4,4,7,8,8,8,5,5,8,9,10,10,9,8,6,10,10,10,10,11,8,8,13,13,9,9,13,13,10,10,13,..
- 13,14,15,15,12,14,11,11,15,15,15,15,16,17,14,14,17,17,15,15,13,13,17,17,18,18,19,19,16,..
- 16,19,19,19,18,19])';
-[b,ind]=gsort(a,'lr','i');
-t=b(2:$,:)-b(1:$-1,:);
-if or(t(:,1)<0) then pause,end
-if or(t(find(t(:,1)==0),2)<0) then pause,end
-if or(a(ind,:)<>b) then pause,end
-
-for k=1:30
-  p=grand(1,'prm',(1:size(a,1))');
-  [b,ind]=gsort(a(p,:),'lr','i');      
-  t=b(2:$,:)-b(1:$-1,:);
-  if or(t(:,1)<0) then pause,end
-  if or(t(find(t(:,1)==0),2)<0) then pause,end
-  if or(a(p(ind),:)<>b) then pause,end
+13,14,15,15,12,14,11,11,15,15,15,15,16,17,14,14,17,17,15,15,13,13,17,17,18,18,19,19,16,..
+16,19,19,19,18,19])';
+[b,ind] = gsort(a,'lr','i');
+t = b(2:$,:) - b(1:$-1,:);
+assert_checktrue(or(t(:,1) >= 0));
+assert_checktrue(or(t(find(t(:,1)==0),2) >= 0));
+assert_checkequal(a(ind,:), b);
+
+for k = 1:30
+    p = grand(1,'prm',(1:size(a,1))');
+    [b,ind] = gsort(a(p,:),'lr','i');  
+    t = b(2:$,:) - b(1:$-1,:);
+    assert_checktrue(or(t(:,1) >= 0));
+    assert_checktrue(or(t(find(t(:,1)==0),2) >= 0));
+    assert_checkequal(a(p(ind),:), b);
 end
 
-[b,ind]=gsort(a,'lr','d');
-t=b(1:$-1,:)-b(2:$,:);
-if or(t(:,1)<0) then pause,end
-if or(t(find(t(:,1)==0),2)<0) then pause,end
-if or(a(ind,:)<>b) then pause,end
-
-for k=1:30
-  p=grand(1,'prm',(1:size(a,1))');
-  [b,ind]=gsort(a(p,:),'lr','d');      
-  t=b(1:$-1,:)-b(2:$,:);
-  if or(t(:,1)<0) then pause,end
-  if or(t(find(t(:,1)==0),2)<0) then pause,end
-  if or(a(p(ind),:)<>b) then pause,end
+[b,ind] = gsort(a,'lr','d');
+t = b(1:$-1,:) - b(2:$,:);
+assert_checktrue(or(t(:,1) >= 0));
+assert_checktrue(or(t(find(t(:,1)==0),2) >= 0));
+assert_checkequal(a(ind,:), b);
+
+for k = 1:30
+    p = grand(1,'prm',(1:size(a,1))');
+    [b,ind] = gsort(a(p,:),'lr','d');  
+    t = b(1:$-1,:) - b(2:$,:);
+    assert_checktrue(or(t(:,1) >= 0));
+    assert_checktrue(or(t(find(t(:,1)==0),2) >= 0));
+    assert_checkequal(a(p(ind),:), b);
 end
 
-
-a=b;
-a([10 60],:)=a([60 10],:);
-[b,ind]=gsort(a,'lr','i');
-t=b(2:$,:)-b(1:$-1,:);
-if or(t(:,1)<0) then pause,end
-if or(t(find(t(:,1)==0),2)<0) then pause,end
-if or(a(ind,:)<>b) then pause,end
-
-[b,ind]=gsort(a,'lr','d');
-t=b(1:$-1,:)-b(2:$,:);
-if or(t(:,1)<0) then pause,end
-if or(t(find(t(:,1)==0),2)<0) then pause,end
-if or(a(ind,:)<>b) then pause,end
-
-//================================ Matrix of int16 and uint16 case =======================================
+a = b;
+a([10 60],:) = a([60 10],:);
+[b,ind] = gsort(a,'lr','i');
+t = b(2:$,:) - b(1:$-1,:);
+assert_checktrue(or(t(:,1) >= 0));
+assert_checktrue(or(t(find(t(:,1)==0),2) >= 0));
+assert_checkequal(a(ind,:), b);
+
+[b,ind] = gsort(a,'lr','d');
+t = b(1:$-1,:) - b(2:$,:);
+assert_checktrue(or(t(:,1) >= 0));
+assert_checktrue(or(t(find(t(:,1)==0),2) >= 0));
+assert_checkequal(a(ind,:), b);
+
+//================================ Matrix of int16 or uint16 case =======================================
 // Copyright Inria
 // test of gsort for int16 matrices:
-N=4;P=20;Nrand=100; 
+N = 4;P = 20;Nrand = 100; vmax = 4;
 
 a = int16(matrix(grand(1,'prm',(1:N*P)'),N,P));
 
 //-----Global sort --------------------------------
-
-[a1,ind]=gsort(a,'g');
-
-if or(a1- matrix(N*P:-1:1,N,P) <>0) then pause,end;
-if or(a1- matrix(a(ind),N,P)  <>0) then pause,end;
-
-for i=1:Nrand 
-  b = int16(10*rand(N,P,'u')); 
-  [b1,ind]=gsort(b,'g');
-  if or(b1- matrix(b(ind),N,P)<>0)  then pause,end;
-  if or(b1(1:$-1)-b1(2:$) <0) then pause,end
-end 
+[a1,ind] = gsort(a,'g');
+assert_checkequal(a1, int16(matrix(N*P:-1:1,N,P)));
+assert_checkequal(a1, matrix(a(ind),N,P));
+
+for i = 1:Nrand 
+    b = int16(10*rand(N,P,'u')); 
+    [b1,ind]=gsort(b,'g');
+    assert_checkequal(b1, matrix(b(ind),N,P));
+    assert_checktrue(or(b1(1:$-1) - b1(2:$) >= 0));
+end
 
 //increasing values 
-
-[a1,ind]=gsort(a,'g','i');
-
-if or(a1- matrix(1:N*P,N,P) <>0) then pause,end;
-if or(a1- matrix(a(ind),N,P)  <>0) then pause,end;
-
-
-for i=1:100
-  b = int16(10*rand(N,P,'u')); 
-  [b1,ind]=gsort(b,'g','i');
-  if or(b1- matrix(b(ind),N,P)<>0)  then pause,end;
-  if or(b1(1:$-1)-b1(2:$) > 0) then pause,end
-end 
+[a1,ind] = gsort(a,'g','i');
+assert_checkequal(a1, int16(matrix(1:N*P,N,P)));
+assert_checkequal(a1, matrix(a(ind),N,P));
+
+for i = 1:100
+    b = int16(10*rand(N,P,'u')); 
+    [b1,ind] = gsort(b,'g','i');
+    assert_checkequal(b1, int16(matrix(b(ind),N,P)));
+    assert_checktrue(or(b1(1:$-1) - b1(2:$) <= 0));
+end
 
 //----sort each column of a ('r' means that the row indice is used for sorting)
+[a1,ind] = gsort(a,'r');
+nc = size(a,'c');
+test = [];
+for i = 1:nc 
+    test = [test, matrix(a(ind(:,i),i),N,1)];
+end
+assert_checkequal(a1, test);
 
-[a1,ind]=gsort(a,'r');
-nc=size(a,'c');
-test=[];
-for i=1:nc ; 
-   test= [test, matrix(a(ind(:,i),i),N,1)];
+test = [];
+for i = 1:nc 
+    test = [test, gsort(a(:,i),'g')];
 end 
-if or((a1- test)<>0)  then pause,end;
-test=[];
-for i=1:nc ; 
-   test= [test, gsort(a(:,i),'g')];
-end 
-if or((a1- test)<>0)  then pause,end;
-
-
-for i=1:Nrand
-  b = int16(10*rand(N,P,'u')); 
-  [b1,ind]=gsort(b,'r');
-  if or( b1(2:$,:)-b1(1:$-1,:) > 0 ) then pause,end 
-  test=[];
-  for j=1:nc ; 
-    test= [test, matrix(b(ind(:,j),j),N,1)];
-  end 
-  if or((b1- test)<>0) then pause,end;
+assert_checkequal(a1, test);
+
+for i = 1:Nrand
+    b = int16(10*rand(N,P,'u')); 
+    [b1,ind] = gsort(b,'r');
+    assert_checktrue(or( b1(2:$,:) - b1(1:$-1,:) <= 0));
+    test = [];
+    for j = 1:nc 
+        test = [test, matrix(b(ind(:,j),j),N,1)];
+    end 
+    assert_checkequal(b1, test);
 end 
 
 //increasing values 
-
-[a1,ind]=gsort(a,'r','i');
-nc=size(a,'c');
-test=[];
-for i=1:nc ; 
-  test= [test, matrix(a(ind(:,i),i),N,1)];
+[a1,ind] = gsort(a,'r','i');
+nc = size(a,'c');
+test = [];
+for i = 1:nc 
+    test = [test, matrix(a(ind(:,i),i),N,1)];
 end 
-if or((a1- test)<>0)  then pause,end;
+assert_checkequal(a1, test);
 
-test=[];
-for i=1:nc ; 
-   test= [test, gsort(a(:,i),'g','i')];
+test =[];
+for i = 1:nc ; 
+    test = [test, gsort(a(:,i),'g','i')];
 end 
-if or((a1- test)<>0)  then pause,end;
-
-
+assert_checkequal(a1, test);
 
 //----sort each row of a ('c' means that the column indice is used for sorting)
-
-[a1,ind]=gsort(a,'c')   ;
-nr=size(a,'r');
-test=[];
-for i=1:nr ; 
-   test= [test; matrix(a(i,ind(i,:)),1,P)];
+[a1,ind] = gsort(a,'c')   ;
+nr = size(a,'r');
+test = [];
+for i = 1:nr
+    test = [test; matrix(a(i,ind(i,:)),1,P)];
 end 
-if or((a1- test)<>0)  then pause,end;
+assert_checkequal(a1, test);
 
-test=[];
-for i=1:nr ; 
-   test= [test; gsort(a(i,:),'g')];
+test = [];
+for i = 1:nr
+    test = [test; gsort(a(i,:),'g')];
 end 
-if or((a1- test)<>0)  then pause,end;
-
-
-for i=1:Nrand
-  b = int16(10*rand(N,P,'u')); 
-  [b1,ind]=gsort(b,'c');
-  if or( b1(:,2:$)-b1(:,1:$-1) > 0 ) then pause,end 
-  test=[];
-  for j=1:nr ; 
-    test= [test; b(j,ind(j,:))];
-  end 
-  if or((b1- test)<>0) then pause,end;
+assert_checkequal(a1, test);
+
+for i = 1:Nrand
+    b = int16(10*rand(N,P,'u')); 
+    [b1,ind] = gsort(b,'c');
+    assert_checktrue(or(b1(:,2:$) - b1(:,1:$-1) <= 0));
+    test = [];
+    for j = 1:nr 
+        test = [test; b(j,ind(j,:))];
+    end 
+    assert_checkequal(b1, test);
 end 
 
 //increasing 
-
-[a1,ind]=gsort(a,'c','i')   ;
-nr=size(a,'r');
-test=[];
-for i=1:nr ; 
-   test= [test; matrix(a(i,ind(i,:)),1,P)];
+[a1,ind] = gsort(a,'c','i');
+nr = size(a,'r');
+test = [];
+for i = 1:nr 
+    test = [test; matrix(a(i,ind(i,:)),1,P)];
 end 
-if or((a1- test)<>0)  then pause,end;
-test=[];
-for i=1:nr ; 
-   test= [test; gsort(a(i,:),'g','i')];
+assert_checkequal(a1, test);
+
+test = [];
+for i = 1:nr ; 
+    test = [test; gsort(a(i,:),'g','i')];
 end 
-if or((a1- test)<>0)  then pause,end;
+assert_checkequal(a1, test);
 
 //----sort the rows of a in lexicographic order 
 //    i.e a(k,:) < a(l,:) if there's a number j 
-//    such that a(k,j) < a(l,j) and a(k,p)=a(l,p) for p in [1,j-1];
+//    such that a(k,j) < a(l,j) or a(k,p)=a(l,p) for p in [1,j-1];
 //
-N1=4;P1=3;
-alr=[1,2,2;
-     1,2,1;
-     1,1,2;
-     1,1,1];
+N1 = 4;P1 = 3;
+alr = [1,2,2;
+1,2,1;
+1,1,2;
+1,1,1];
 // a random permutation 
-[ax,perm]=gsort(rand(1,N1,'u'));
-a=alr(perm,:);
+[ax,perm] = gsort(rand(1,N1,'u'));
+a = int16(alr(perm,:));
 
-[a1,ind]=gsort(a,'lr');                   
+[a1,ind] = gsort(a,'lr');
 
-if or((a1- alr) <>0) then pause,end;
-if or((a1- matrix(a(ind,:),N1,P1)) <>0) then pause,end;
+assert_checkequal(a1, int16(alr));
+assert_checkequal(a1, matrix(a(ind,:),N1,P1));
 
 [a2,ind2]=gsort(a*[100;10;1],'g');
-if or((ind2-ind)<>0) then pause,end;
+assert_checkequal(ind2, ind);
 ///////////////////////
-for i=1:Nrand
-  vmax=4;
-  b = int16(vmax*rand(N,P,'u')); 
-  [b1,ind]=gsort(b,'lr');
-  if or((b1- b(ind,:)) <>0) then pause,end;
-  v= double(b1)*((vmax+1)^[P-1:-1:0])';
-  if or( v(2:$)-v(1:$-1) > 0 ) then pause,end 
-end 
+for i = 1:Nrand
+    b = int16(vmax * rand(N,P,'u')); 
+    [b1,ind] = gsort(b,'lr');
+    assert_checkequal(b1, b(ind,:));
+    v= double(b1)*((vmax+1)^[P-1:-1:0])';
+    assert_checktrue(or(v(2:$) - v(1:$-1) <= 0));
+end
 
 // increasing 
-
-[a1,ind]=gsort(a,'lr','i');                   
-if or((a1- alr(N1:-1:1,:)) <>0) then pause,end;
-
-if or((a1- matrix(a(ind,:),N1,P1)) <>0) then pause,end;
-[a2,ind2]=gsort(a*[100;10;1],'g','i');
-if or((ind2-ind) <>0) then pause,end;
-
-for i=1:Nrand
-  vmax=4;
-  b = int(vmax*rand(N,P,'u')); 
-  [b1,ind]=gsort(b,'lr','i');
-  if or((b1- b(ind,:)) <>0) then pause,end;
-  v= double(b1)*((vmax+1)^[P-1:-1:0])';
-  if or( v(2:$)-v(1:$-1) < 0 ) then pause,end 
+[a1,ind] = gsort(a,'lr','i');
+assert_checkequal(a1, int16(alr(N1:-1:1,:)));
+assert_checkequal(a1, matrix(a(ind,:),N1,P1));
+
+[a2,ind2] = gsort(a*[100;10;1],'g','i');
+assert_checkequal(ind2, ind);
+
+for i = 1:Nrand
+    b = int(vmax*rand(N,P,'u')); 
+    [b1,ind] = gsort(b,'lr','i');
+    assert_checkequal(b1, b(ind,:));
+    v = double(b1)*((vmax+1)^[P-1:-1:0])';
+    assert_checktrue(or(v(2:$) - v(1:$-1) >= 0));
 end
 
 //----sort the columns of a in lexicographic order 
-
-N1=3;P1=4;
-alr=alr';
+N1 = 3;P1 = 4;
+alr = alr';
 // a random permutation 
-[ax,perm]=gsort(rand(1,P1,'u'));
-a=alr(:,perm);
+[ax,perm] = gsort(rand(1,P1,'u'));
+a = int16(alr(:,perm));
 
-[a1,ind]=gsort(a,'lc');                   
+[a1,ind] = gsort(a,'lc');
+assert_checkequal(a1, int16(alr));
+assert_checkequal(a1, matrix(a(:,ind),N1,P1));
 
-if or((a1- alr) <>0) then pause,end;
-if or((a1- matrix(a(:,ind),N1,P1)) <>0) then pause,end;
+[a2,ind2] = gsort([100,10,1]*a,'g');
+assert_checkequal(ind2, ind);
 
-[a2,ind2]=gsort([100,10,1]*a,'g');
-if or((ind2-ind) <>0) then pause,end;
-
-for i=1:Nrand
-  vmax=4;
-  b = int(vmax*rand(N1,P1,'u')); 
-  [b1,ind]=gsort(b,'lc');
-  if or((b1- b(:,ind)) <>0) then pause,end;
-  v= ((vmax+1)^[N1-1:-1:0])*double(b1);
-  if or( v(2:$)-v(1:$-1) > 0 ) then pause,end 
+for i = 1:Nrand
+    b = int(vmax*rand(N1,P1,'u')); 
+    [b1,ind] = gsort(b,'lc');
+    assert_checkequal(b1, b(:,ind));
+    v= ((vmax+1)^[N1-1:-1:0])*double(b1);
+    assert_checktrue(or(v(2:$) - v(1:$-1) <= 0));
 end 
 
 //increasing 
+[a1,ind] = gsort(a,'lc','i');
 
-[a1,ind]=gsort(a,'lc','i');                   
+assert_checkequal(a1, int16(alr(:,P1:-1:1)));
+assert_checkequal(a1, matrix(a(:,ind),N1,P1));
 
-if or((a1- alr(:,P1:-1:1)) <>0) then pause,end;
-if or((a1- matrix(a(:,ind),N1,P1)) <>0) then pause,end;
+[a2,ind2] = gsort([100,10,1]*a,'g','i');
+assert_checkequal(ind2, ind);
+
+for i = 1:Nrand
+    b = int(vmax*rand(N,P,'u')); 
+    [b1,ind] = gsort(b,'lc','i');
+    assert_checkequal(b1, b(:,ind));
+    v = ((vmax+1)^[N-1:-1:0])*b1;
+    assert_checktrue(or(v(2:$) - v(1:$-1) >= 0));
+end
 
-[a2,ind2]=gsort([100,10,1]*a,'g','i');
-if or((ind2-ind) <>0) then pause,end;
-
-for i=1:Nrand
-  vmax=4;
-  b = int(vmax*rand(N,P,'u')); 
-  [b1,ind]=gsort(b,'lc','i');
-  if or((b1- b(:,ind)) <>0) then pause,end;
-  v= ((vmax+1)^[N-1:-1:0])*b1;
-  if or( v(2:$)-v(1:$-1) < 0 ) then pause,end 
-end 
 a = int16([1,1,1,1,2,2,3,3,2,2,3,3,4,4,4,4,4,4,4,4,5,5,5,6,6,6,7,7,7,7,8,8,8,8,9,9,9,9,9,9,9,7,9,10,..
- 10,10,10,11,11,11,12,13,13,13,13,14,14,12,12,14,14,14,14,14,14,15,15,15,15,16,17,18;
+10,10,10,11,11,11,12,13,13,13,13,14,14,12,12,14,14,14,14,14,14,15,15,15,15,16,17,18;
 3,4,4,5,3,8,4,4,7,8,8,8,5,5,8,9,10,10,9,8,6,10,10,10,10,11,8,8,13,13,9,9,13,13,10,10,13,..
- 13,14,15,15,12,14,11,11,15,15,15,15,16,17,14,14,17,17,15,15,13,13,17,17,18,18,19,19,16,..
- 16,19,19,19,18,19])';
-[b,ind]=gsort(a,'lr','i');
-t=b(2:$,:)-b(1:$-1,:);
-if or(t(:,1)<0) then pause,end
-if or(t(find(t(:,1)==0),2)<0) then pause,end
-if or(a(ind,:)<>b) then pause,end
-
-for k=1:30
-  p=grand(1,'prm',(1:size(a,1))');
-  [b,ind]=gsort(a(p,:),'lr','i');      
-  t=b(2:$,:)-b(1:$-1,:);
-  if or(t(:,1)<0) then pause,end
-  if or(t(find(t(:,1)==0),2)<0) then pause,end
-  if or(a(p(ind),:)<>b) then pause,end
+13,14,15,15,12,14,11,11,15,15,15,15,16,17,14,14,17,17,15,15,13,13,17,17,18,18,19,19,16,..
+16,19,19,19,18,19])';
+[b,ind] = gsort(a,'lr','i');
+t = b(2:$,:) - b(1:$-1,:);
+assert_checktrue(or(t(:,1) >= 0));
+assert_checktrue(or(t(find(t(:,1)==0),2) >= 0));
+assert_checkequal(a(ind,:), b);
+
+for k = 1:30
+    p = grand(1,'prm',(1:size(a,1))');
+    [b,ind] = gsort(a(p,:),'lr','i');  
+    t = b(2:$,:) - b(1:$-1,:);
+    assert_checktrue(or(t(:,1) >= 0));
+    assert_checktrue(or(t(find(t(:,1)==0),2) >= 0));
+    assert_checkequal(a(p(ind),:), b);
 end
 
-[b,ind]=gsort(a,'lr','d');
-t=b(1:$-1,:)-b(2:$,:);
-if or(t(:,1)<0) then pause,end
-if or(t(find(t(:,1)==0),2)<0) then pause,end
-if or(a(ind,:)<>b) then pause,end
-
-for k=1:30
-  p=grand(1,'prm',(1:size(a,1))');
-  [b,ind]=gsort(a(p,:),'lr','d');      
-  t=b(1:$-1,:)-b(2:$,:);
-  if or(t(:,1)<0) then pause,end
-  if or(t(find(t(:,1)==0),2)<0) then pause,end
-  if or(a(p(ind),:)<>b) then pause,end
+[b,ind] = gsort(a,'lr','d');
+t = b(1:$-1,:) - b(2:$,:);
+assert_checktrue(or(t(:,1) >= 0));
+assert_checktrue(or(t(find(t(:,1)==0),2) >= 0));
+assert_checkequal(a(ind,:), b);
+
+for k = 1:30
+    p = grand(1,'prm',(1:size(a,1))');
+    [b,ind] = gsort(a(p,:),'lr','d');  
+    t = b(1:$-1,:) - b(2:$,:);
+    assert_checktrue(or(t(:,1) >= 0));
+    assert_checktrue(or(t(find(t(:,1)==0),2) >= 0));
+    assert_checkequal(a(p(ind),:), b);
 end
 
+a = b;
+a([10 60],:) = a([60 10],:);
+[b,ind] = gsort(a,'lr','i');
+t = b(2:$,:) - b(1:$-1,:);
+assert_checktrue(or(t(:,1) >= 0));
+assert_checktrue(or(t(find(t(:,1)==0),2) >= 0));
+assert_checkequal(a(ind,:), b);
 
-a=b;
-a([10 60],:)=a([60 10],:);
-[b,ind]=gsort(a,'lr','i');
-t=b(2:$,:)-b(1:$-1,:);
-if or(t(:,1)<0) then pause,end
-if or(t(find(t(:,1)==0),2)<0) then pause,end
-if or(a(ind,:)<>b) then pause,end
-
-[b,ind]=gsort(a,'lr','d');
-t=b(1:$-1,:)-b(2:$,:);
-if or(t(:,1)<0) then pause,end
-if or(t(find(t(:,1)==0),2)<0) then pause,end
-if or(a(ind,:)<>b) then pause,end
-
+[b,ind] = gsort(a,'lr','d');
+t = b(1:$-1,:) - b(2:$,:);
+assert_checktrue(or(t(:,1) >= 0));
+assert_checktrue(or(t(find(t(:,1)==0),2) >= 0));
+assert_checkequal(a(ind,:), b);
 
 a = uint16([1,1,1,1,2,2,3,3,2,2,3,3,4,4,4,4,4,4,4,4,5,5,5,6,6,6,7,7,7,7,8,8,8,8,9,9,9,9,9,9,9,7,9,10,..
- 10,10,10,11,11,11,12,13,13,13,13,14,14,12,12,14,14,14,14,14,14,15,15,15,15,16,17,18;
+10,10,10,11,11,11,12,13,13,13,13,14,14,12,12,14,14,14,14,14,14,15,15,15,15,16,17,18;
 3,4,4,5,3,8,4,4,7,8,8,8,5,5,8,9,10,10,9,8,6,10,10,10,10,11,8,8,13,13,9,9,13,13,10,10,13,..
- 13,14,15,15,12,14,11,11,15,15,15,15,16,17,14,14,17,17,15,15,13,13,17,17,18,18,19,19,16,..
- 16,19,19,19,18,19]-5)';
-[b,ind]=gsort(a,'lr','i');
-t=b(2:$,:)<b(1:$-1,:);
-if or(t(:,1)) then pause,end
-if or(t(b(2:$,1)==b(1:$-1,1),2)) then pause,end
-if or(a(ind,:)<>b) then pause,end
-
-for k=1:30
-  p=grand(1,'prm',(1:size(a,1))');
-  [b,ind]=gsort(a(p,:),'lr','i');
-  t=b(2:$,:)<b(1:$-1,:);
-  if or(t(:,1)) then pause,end
-  if or(t(b(2:$,1)==b(1:$-1,1),2)) then pause,end
-  if or(a(p(ind),:)<>b) then pause,end
+13,14,15,15,12,14,11,11,15,15,15,15,16,17,14,14,17,17,15,15,13,13,17,17,18,18,19,19,16,..
+16,19,19,19,18,19]-5)';
+[b,ind] = gsort(a,'lr','i');
+t = b(2:$,:) < b(1:$-1,:);
+assert_checkfalse(or(t(:,1)));
+assert_checkfalse(or(t(b(2:$,1)==b(1:$-1,1),2)));
+assert_checkequal(a(ind,:), b);
+
+for k = 1:30
+    p = grand(1,'prm',(1:size(a,1))');
+    [b,ind] = gsort(a(p,:),'lr','i');
+    t = b(2:$,:) < b(1:$-1,:);
+    assert_checkfalse(or(t(:,1)));
+    assert_checkfalse(or(t(b(2:$,1)==b(1:$-1,1),2)));
+    assert_checkequal(a(p(ind),:), b);
 end
 
-[b,ind]=gsort(a,'lr','d');
-t=b(2:$,:)>b(1:$-1,:);
-if or(t(:,1)) then pause,end
-if or(t(b(2:$,1)==b(1:$-1,1),2)) then pause,end
-if or(a(ind,:)<>b) then pause,end
-
-
-for k=1:30
-  p=grand(1,'prm',(1:size(a,1))');
-  [b,ind]=gsort(a(p,:),'lr','d');
-  t=b(2:$,:)>b(1:$-1,:);
-  if or(t(:,1)) then pause,end
-  if or(t(b(2:$,1)==b(1:$-1,1),2)) then pause,end
-  if or(a(p(ind),:)<>b) then pause,end
+[b,ind] = gsort(a,'lr','d');
+t = b(2:$,:) > b(1:$-1,:);
+assert_checkfalse(or(t(:,1)));
+assert_checkfalse(or(t(b(2:$,1)==b(1:$-1,1),2)));
+assert_checkequal(a(ind,:), b);
+
+for k = 1:30
+    p = grand(1,'prm',(1:size(a,1))');
+    [b,ind] = gsort(a(p,:),'lr','d');
+    t = b(2:$,:) > b(1:$-1,:);
+    assert_checkfalse(or(t(:,1)));
+    assert_checkfalse(or(t(b(2:$,1)==b(1:$-1,1),2)));
+    assert_checkequal(a(p(ind),:), b);
 end
 
-
-a=b;
-a([10 60],:)=a([60 10],:);
-[b,ind]=gsort(a,'lr','i');
-t=b(2:$,:)<b(1:$-1,:);
-if or(t(:,1)) then pause,end
-if or(t(b(2:$,1)==b(1:$-1,1),2)) then pause,end
-if or(a(ind,:)<>b) then pause,end
-
-
-
-[b,ind]=gsort(a,'lr','d');
-t=b(2:$,:)>b(1:$-1,:);
-if or(t(:,1)) then pause,end
-if or(t(b(2:$,1)==b(1:$-1,1),2)) then pause,end
-if or(a(ind,:)<>b) then pause,end
-
-//================================ Matrix of int8 and uint8 case =======================================
+a = b;
+a([10 60],:) = a([60 10],:);
+[b,ind] = gsort(a,'lr','i');
+t = b(2:$,:) < b(1:$-1,:);
+assert_checkfalse(or(t(:,1)));
+assert_checkfalse(or(t(b(2:$,1)==b(1:$-1,1),2)));
+assert_checkequal(a(ind,:), b);
+
+[b,ind] = gsort(a,'lr','d');
+t = b(2:$,:) > b(1:$-1,:);
+assert_checkfalse(or(t(:,1)));
+assert_checkfalse(or(t(b(2:$,1)==b(1:$-1,1),2)));
+assert_checkequal(a(ind,:), b);
+
+//================================ Matrix of int8 or uint8 case =======================================
 // test of gsort for int8 matrices:
-N=4;P=20;Nrand=100; 
+N = 4;P = 20;Nrand = 100; vmax = 4;
 
 a = int8(matrix(grand(1,'prm',(1:N*P)'),N,P));
 
 //-----Global sort --------------------------------
-
-[a1,ind]=gsort(a,'g');
-
-if or(a1- matrix(N*P:-1:1,N,P) <>0) then pause,end;
-if or(a1- matrix(a(ind),N,P)  <>0) then pause,end;
-
-for i=1:Nrand 
-  b = int8(10*rand(N,P,'u')); 
-  [b1,ind]=gsort(b,'g');
-  if or(b1- matrix(b(ind),N,P)<>0)  then pause,end;
-  if or(b1(1:$-1)-b1(2:$) <0) then pause,end
-end 
+[a1,ind] = gsort(a,'g');
+assert_checkequal(a1, int8(matrix(N*P:-1:1,N,P)));
+assert_checkequal(a1, matrix(a(ind),N,P));
+
+for i = 1:Nrand 
+    b = int8(10*rand(N,P,'u')); 
+    [b1,ind] = gsort(b,'g');
+    assert_checkequal(b1, matrix(b(ind),N,P));
+    assert_checktrue(or(b1(1:$-1) - b1(2:$) >= 0));
+end
 
 //increasing values 
+[a1,ind] = gsort(a,'g','i');
 
-[a1,ind]=gsort(a,'g','i');
-
-if or(a1- matrix(1:N*P,N,P) <>0) then pause,end;
-if or(a1- matrix(a(ind),N,P)  <>0) then pause,end;
-
-
-for i=1:100
-  b = int8(10*rand(N,P,'u')); 
-  [b1,ind]=gsort(b,'g','i');
-  if or(b1- matrix(b(ind),N,P)<>0)  then pause,end;
-  if or(b1(1:$-1)-b1(2:$) > 0) then pause,end
-end 
+assert_checkequal(a1, int8(matrix(1:N*P,N,P)));
+assert_checkequal(a1, matrix(a(ind),N,P));
 
+for i = 1:Nrand
+    b = int8(10*rand(N,P,'u')); 
+    [b1,ind] = gsort(b,'g','i');
+    assert_checkequal(b1, matrix(b(ind),N,P));
+    assert_checktrue(or(b1(1:$-1) - b1(2:$) <= 0));
+end
 
 //----sort each column of a ('r' means that the row indice is used for sorting)
-
-[a1,ind]=gsort(a,'r');
-nc=size(a,'c');
-test=[];
-for i=1:nc ; 
-   test= [test, matrix(a(ind(:,i),i),N,1)];
-end 
-if or((a1- test)<>0)  then pause,end;
-test=[];
-for i=1:nc ; 
-   test= [test, gsort(a(:,i),'g')];
+[a1,ind] = gsort(a,'r');
+nc = size(a,'c');
+test = [];
+for i = 1:nc 
+    test = [test, matrix(a(ind(:,i),i),N,1)];
+end
+assert_checkequal(a1, test);
+test = [];
+for i = 1:nc 
+    test = [test, gsort(a(:,i),'g')];
 end 
-if or((a1- test)<>0)  then pause,end;
-
-
-for i=1:Nrand
-  b = int8(10*rand(N,P,'u')); 
-  [b1,ind]=gsort(b,'r');
-  if or( b1(2:$,:)-b1(1:$-1,:) > 0 ) then pause,end 
-  test=[];
-  for j=1:nc ; 
-    test= [test, matrix(b(ind(:,j),j),N,1)];
-  end 
-  if or((b1- test)<>0) then pause,end;
+assert_checkequal(a1, test);
+
+for i = 1:Nrand
+    b = int8(10*rand(N,P,'u')); 
+    [b1,ind] = gsort(b,'r');
+    assert_checkequal(or(b1(2:$,:) - b1(1:$-1,:) > 0), %f);
+    test = [];
+    for j = 1:nc 
+        test = [test, matrix(b(ind(:,j),j),N,1)];
+    end 
+    assert_checkequal(b1, test);
 end 
 
 //increasing values 
-
-[a1,ind]=gsort(a,'r','i');
-nc=size(a,'c');
-test=[];
-for i=1:nc ; 
-  test= [test, matrix(a(ind(:,i),i),N,1)];
+[a1,ind] = gsort(a,'r','i');
+nc = size(a,'c');
+test = [];
+for i = 1:nc 
+    test = [test, matrix(a(ind(:,i),i),N,1)];
 end 
-if or((a1- test)<>0)  then pause,end;
+assert_checkequal(a1, test);
 
-test=[];
-for i=1:nc ; 
-   test= [test, gsort(a(:,i),'g','i')];
+test =[];
+for i = 1:nc ; 
+    test = [test, gsort(a(:,i),'g','i')];
 end 
-if or((a1- test)<>0)  then pause,end;
-
+assert_checkequal(a1, int8(test));
 
 //----sort each row of a ('c' means that the column indice is used for sorting)
-
-[a1,ind]=gsort(a,'c')   ;
-nr=size(a,'r');
-test=[];
-for i=1:nr ; 
-   test= [test; matrix(a(i,ind(i,:)),1,P)];
-end 
-if or((a1- test)<>0)  then pause,end;
-
-test=[];
-for i=1:nr ; 
-   test= [test; gsort(a(i,:),'g')];
-end 
-if or((a1- test)<>0)  then pause,end;
-
-
-for i=1:Nrand
-  b = int8(10*rand(N,P,'u')); 
-  [b1,ind]=gsort(b,'c');
-  if or( b1(:,2:$)-b1(:,1:$-1) > 0 ) then pause,end 
-  test=[];
-  for j=1:nr ; 
-    test= [test; b(j,ind(j,:))];
-  end 
-  if or((b1- test)<>0) then pause,end;
-end 
+[a1,ind] = gsort(a,'c');
+nr = size(a,'r');
+test = [];
+for i = 1:nr 
+    test = [test; matrix(a(i,ind(i,:)),1,P)];
+end
+assert_checkequal(a1, test);
+
+test = [];
+for i = 1:nr
+    test = [test; gsort(a(i,:),'g')];
+end 
+assert_checkequal(a1, test);
+
+for i = 1:Nrand
+    b = int8(10*rand(N,P,'u')); 
+    [b1,ind] = gsort(b,'c');
+    assert_checktrue(or(b1(:,2:$) - b1(:,1:$-1) <= 0));
+    test = [];
+    for j = 1:nr
+        test = [test; b(j,ind(j,:))];
+    end
+    assert_checkequal(b1, test);
+end
 
 //increasing 
-
-[a1,ind]=gsort(a,'c','i')   ;
-nr=size(a,'r');
-test=[];
-for i=1:nr ; 
-   test= [test; matrix(a(i,ind(i,:)),1,P)];
+[a1,ind] = gsort(a,'c','i');
+nr = size(a,'r');
+test = [];
+for i = 1:nr
+    test = [test; matrix(a(i,ind(i,:)),1,P)];
 end 
-if or((a1- test)<>0)  then pause,end;
-test=[];
-for i=1:nr ; 
-   test= [test; gsort(a(i,:),'g','i')];
+assert_checkequal(a1, test);
+test = [];
+for i = 1:nr ; 
+    test = [test; gsort(a(i,:),'g','i')];
 end 
-if or((a1- test)<>0)  then pause,end;
+assert_checkequal(a1, test);
 
 //----sort the rows of a in lexicographic order 
 //    i.e a(k,:) < a(l,:) if there's a number j 
-//    such that a(k,j) < a(l,j) and a(k,p)=a(l,p) for p in [1,j-1];
+//    such that a(k,j) < a(l,j) or a(k,p)=a(l,p) for p in [1,j-1];
 //
-N1=4;P1=3;
-alr=[1,2,2;
-     1,2,1;
-     1,1,2;
-     1,1,1];
+N1 = 4;P1 = 3;
+alr = [1,2,2;
+1,2,1;
+1,1,2;
+1,1,1];
 // a random permutation 
-[ax,perm]=gsort(rand(1,N1,'u'));
-a=alr(perm,:);
+[ax,perm] = gsort(rand(1,N1,'u'));
+a = int8(alr(perm,:));
 
-[a1,ind]=gsort(a,'lr');                   
+[a1,ind] = gsort(a,'lr');
+assert_checkequal(a1, int8(alr));
+assert_checkequal(a1, matrix(a(ind,:),N1,P1));
 
-if or((a1- alr) <>0) then pause,end;
-if or((a1- matrix(a(ind,:),N1,P1)) <>0) then pause,end;
-
-[a2,ind2]=gsort(a*[100;10;1],'g');
-if or((ind2-ind)<>0) then pause,end;
+[a2,ind2] = gsort(a*[100;10;1],'g');
+assert_checkequal(ind2, ind);
 ///////////////////////
-for i=1:Nrand
-  vmax=4;
-  b = int8(vmax*rand(N,P,'u')); 
-  [b1,ind]=gsort(b,'lr');
-  if or((b1- b(ind,:)) <>0) then pause,end;
-  v= double(b1)*((vmax+1)^[P-1:-1:0])';
-  if or( v(2:$)-v(1:$-1) > 0 ) then pause,end 
-end 
+for i = 1:Nrand
+    b = int8(vmax*rand(N,P,'u')); 
+    [b1,ind] = gsort(b,'lr');
+    assert_checkequal(b1, b(ind,:));
+    v= double(b1)*((vmax+1)^[P-1:-1:0])';
+    assert_checktrue(or(v(2:$) - v(1:$-1) <= 0));
+end
 
 // increasing 
+[a1,ind] = gsort(a,'lr','i');
+assert_checkequal(a1, int8(alr(N1:-1:1,:)));
+assert_checkequal(a1, matrix(a(ind,:),N1,P1));
 
-[a1,ind]=gsort(a,'lr','i');                   
-if or((a1- alr(N1:-1:1,:)) <>0) then pause,end;
-
-if or((a1- matrix(a(ind,:),N1,P1)) <>0) then pause,end;
 [a2,ind2]=gsort(a*[100;10;1],'g','i');
-if or((ind2-ind) <>0) then pause,end;
-
-for i=1:Nrand
-  vmax=4;
-  b = int(vmax*rand(N,P,'u')); 
-  [b1,ind]=gsort(b,'lr','i');
-  if or((b1- b(ind,:)) <>0) then pause,end;
-  v= double(b1)*((vmax+1)^[P-1:-1:0])';
-  if or( v(2:$)-v(1:$-1) < 0 ) then pause,end 
+assert_checkequal(ind2, ind);
+
+for i = 1:Nrand
+    b = int(vmax*rand(N,P,'u')); 
+    [b1,ind] = gsort(b,'lr','i');
+    assert_checkequal(b1, b(ind,:));
+    v = double(b1)*((vmax+1)^[P-1:-1:0])';
+    assert_checktrue(or(v(2:$) - v(1:$-1) >= 0));
 end 
 
 //----sort the columns of a in lexicographic order 
-
-N1=3;P1=4;
-alr=alr';
+N1 = 3;P1 = 4;
+alr = alr';
 // a random permutation 
-[ax,perm]=gsort(rand(1,P1,'u'));
-a=alr(:,perm);
-
-[a1,ind]=gsort(a,'lc');                   
+[ax,perm] = gsort(rand(1,P1,'u'));
+a = int8(alr(:,perm));
 
-if or((a1- alr) <>0) then pause,end;
-if or((a1- matrix(a(:,ind),N1,P1)) <>0) then pause,end;
+[a1,ind] = gsort(a,'lc');
+assert_checkequal(a1, int8(alr));
+assert_checkequal(a1, matrix(a(:,ind),N1,P1));
 
 [a2,ind2]=gsort([100,10,1]*a,'g');
-if or((ind2-ind) <>0) then pause,end;
-
-for i=1:Nrand
-  vmax=4;
-  b = int(vmax*rand(N1,P1,'u')); 
-  [b1,ind]=gsort(b,'lc');
-  if or((b1- b(:,ind)) <>0) then pause,end;
-  v= ((vmax+1)^[N1-1:-1:0])*double(b1);
-  if or( v(2:$)-v(1:$-1) > 0 ) then pause,end 
+assert_checkequal(ind2, ind);
+
+for i = 1:Nrand
+    b = int(vmax*rand(N1,P1,'u')); 
+    [b1,ind] = gsort(b,'lc');
+    assert_checkequal(b1, b(:,ind));
+    v= ((vmax+1)^[N1-1:-1:0])*double(b1);
+    assert_checktrue(or(v(2:$) - v(1:$-1) <= 0));
 end 
 
 //increasing 
+[a1,ind] = gsort(a,'lc','i');
 
-[a1,ind]=gsort(a,'lc','i');                   
-
-if or((a1- alr(:,P1:-1:1)) <>0) then pause,end;
-if or((a1- matrix(a(:,ind),N1,P1)) <>0) then pause,end;
+assert_checkequal(a1, int8(alr(:,P1:-1:1)));
+assert_checkequal(a1, matrix(a(:,ind),N1,P1));
 
 [a2,ind2]=gsort([100,10,1]*a,'g','i');
-if or((ind2-ind) <>0) then pause,end;
-
-for i=1:Nrand
-  vmax=4;
-  b = int(vmax*rand(N,P,'u')); 
-  [b1,ind]=gsort(b,'lc','i');
-  if or((b1- b(:,ind)) <>0) then pause,end;
-  v= ((vmax+1)^[N-1:-1:0])*b1;
-  if or( v(2:$)-v(1:$-1) < 0 ) then pause,end 
-end 
-
+assert_checkequal(ind2, ind);
+
+for i = 1:Nrand
+    b = int(vmax*rand(N,P,'u')); 
+    [b1,ind] = gsort(b,'lc','i');
+    assert_checkequal(b1, b(:,ind));
+    v= ((vmax+1)^[N-1:-1:0])*b1;
+    assert_checktrue(or(v(2:$) - v(1:$-1) >= 0));
+end
 
 a = int8([1,1,1,1,2,2,3,3,2,2,3,3,4,4,4,4,4,4,4,4,5,5,5,6,6,6,7,7,7,7,8,8,8,8,9,9,9,9,9,9,9,7,9,10,..
- 10,10,10,11,11,11,12,13,13,13,13,14,14,12,12,14,14,14,14,14,14,15,15,15,15,16,17,18;
+10,10,10,11,11,11,12,13,13,13,13,14,14,12,12,14,14,14,14,14,14,15,15,15,15,16,17,18;
 3,4,4,5,3,8,4,4,7,8,8,8,5,5,8,9,10,10,9,8,6,10,10,10,10,11,8,8,13,13,9,9,13,13,10,10,13,..
- 13,14,15,15,12,14,11,11,15,15,15,15,16,17,14,14,17,17,15,15,13,13,17,17,18,18,19,19,16,..
- 16,19,19,19,18,19])';
-[b,ind]=gsort(a,'lr','i');
-t=b(2:$,:)-b(1:$-1,:);
-if or(t(:,1)<0) then pause,end
-if or(t(find(t(:,1)==0),2)<0) then pause,end
-if or(a(ind,:)<>b) then pause,end
-
-for k=1:30
-  p=grand(1,'prm',(1:size(a,1))');
-  [b,ind]=gsort(a(p,:),'lr','i');      
-  t=b(2:$,:)-b(1:$-1,:);
-  if or(t(:,1)<0) then pause,end
-  if or(t(find(t(:,1)==0),2)<0) then pause,end
-  if or(a(p(ind),:)<>b) then pause,end
+13,14,15,15,12,14,11,11,15,15,15,15,16,17,14,14,17,17,15,15,13,13,17,17,18,18,19,19,16,..
+16,19,19,19,18,19])';
+[b,ind] = gsort(a,'lr','i');
+t = b(2:$,:) - b(1:$-1,:);
+assert_checktrue(or(t(:,1) <= 0));
+assert_checktrue(or(t(find(t(:,1)==0),2)>=0));
+assert_checkequal(a(ind,:), b);
+
+for k = 1:30
+    p = grand(1,'prm',(1:size(a,1))');
+    [b,ind] = gsort(a(p,:),'lr','i');  
+    t = b(2:$,:) - b(1:$-1,:);
+    assert_checktrue(or(t(:,1) <= 0));
+    assert_checktrue(or(t(find(t(:,1)==0),2)>=0));
+    assert_checkequal(a(p(ind),:), b);
 end
 
 [b,ind]=gsort(a,'lr','d');
 t=b(1:$-1,:)-b(2:$,:);
-if or(t(:,1)<0) then pause,end
-if or(t(find(t(:,1)==0),2)<0) then pause,end
-if or(a(ind,:)<>b) then pause,end
-
-for k=1:30
-  p=grand(1,'prm',(1:size(a,1))');
-  [b,ind]=gsort(a(p,:),'lr','d');      
-  t=b(1:$-1,:)-b(2:$,:);
-  if or(t(:,1)<0) then pause,end
-  if or(t(find(t(:,1)==0),2)<0) then pause,end
-  if or(a(p(ind),:)<>b) then pause,end
+assert_checktrue(or(t(:,1) <= 0));
+assert_checktrue(or(t(find(t(:,1)==0),2)>=0));
+assert_checkequal(a(ind,:), b);
+
+for k = 1:30
+    p = grand(1,'prm',(1:size(a,1))');
+    [b,ind] = gsort(a(p,:),'lr','d');  
+    t = b(1:$-1,:) - b(2:$,:);
+    assert_checktrue(or(t(:,1) <= 0));
+    assert_checktrue(or(t(find(t(:,1)==0),2)>=0));
+    assert_checkequal(a(p(ind),:), b);
 end
 
-a=b;
-a([10 60],:)=a([60 10],:);
-[b,ind]=gsort(a,'lr','i');
-t=b(2:$,:)-b(1:$-1,:);
-if or(t(:,1)<0) then pause,end
-if or(t(find(t(:,1)==0),2)<0) then pause,end
-if or(a(ind,:)<>b) then pause,end
+a = b;
+a([10 60],:) = a([60 10],:);
+[b,ind] = gsort(a,'lr','i');
+t = b(2:$,:) - b(1:$-1,:);
+assert_checktrue(or(t(:,1) <= 0));
+assert_checktrue(or(t(find(t(:,1)==0),2)>=0));
+assert_checkequal(a(ind,:), b);
 
-[b,ind]=gsort(a,'lr','d');
-t=b(1:$-1,:)-b(2:$,:);
-if or(t(:,1)<0) then pause,end
-if or(t(find(t(:,1)==0),2)<0) then pause,end
-if or(a(ind,:)<>b) then pause,end
+[b,ind] = gsort(a,'lr','d');
+t = b(1:$-1,:) - b(2:$,:);
+assert_checktrue(or(t(:,1) <= 0));
+assert_checktrue(or(t(find(t(:,1)==0),2)>=0));
+assert_checkequal(a(ind,:), b);
 
-N=4;P=20;Nrand=100; 
+N = 4;P = 20;Nrand = 100; vmax = 4;
 
 a = uint32(matrix(grand(1,'prm',(1:N*P)'),N,P));
 
 //-----Global sort --------------------------------
 
-[a1,ind]=gsort(a,'g');
+[a1,ind] = gsort(a,'g');
+assert_checkequal(a1, uint32(matrix(N*P:-1:1,N,P)));
+assert_checkequal(a1, matrix(a(ind),N,P));
 
-if or(a1- matrix(N*P:-1:1,N,P) <>0) then pause,end;
-if or(a1- matrix(a(ind),N,P)  <>0) then pause,end;
-
-for i=1:Nrand 
-  b = uint32(10*rand(N,P,'u')); 
-  [b1,ind]=gsort(b,'g');
-  if or(b1- matrix(b(ind),N,P)<>0)  then pause,end;
-  if or(b1(1:$-1)-b1(2:$) <0) then pause,end
+for i = 1:Nrand 
+    b = uint32(10*rand(N,P,'u')); 
+    [b1,ind] = gsort(b,'g');
+    assert_checkequal(b1, matrix(b(ind),N,P));
+    assert_checktrue(or(b1(1:$-1) - b1(2:$) >= 0));
 end 
 
 //increasing values 
-
-[a1,ind]=gsort(a,'g','i');
-
-if or(a1- matrix(1:N*P,N,P) <>0) then pause,end;
-if or(a1- matrix(a(ind),N,P)  <>0) then pause,end;
+[a1,ind] = gsort(a,'g','i');
+assert_checkequal(a1, uint32(matrix(1:N*P,N,P)));
+assert_checkequal(a1, matrix(a(ind),N,P));
 
 //----sort each column of a ('r' means that the row indice is used for sorting)
-
-[a1,ind]=gsort(a,'r');
-nc=size(a,'c');
-test=[];
-for i=1:nc ; 
-   test= [test, matrix(a(ind(:,i),i),N,1)];
+[a1,ind] = gsort(a,'r');
+nc = size(a,'c');
+test = [];
+for i = 1:nc ; 
+    test = [test, matrix(a(ind(:,i),i),N,1)];
 end 
-if or((a1- test)<>0)  then pause,end;
-test=[];
-for i=1:nc ; 
-   test= [test, gsort(a(:,i),'g')];
+assert_checkequal(a1, test);
+test = [];
+for i = 1:nc ; 
+    test = [test, gsort(a(:,i),'g')];
 end 
-if or((a1- test)<>0)  then pause,end;
+assert_checkequal(a1, test);
 
 //increasing values 
+[a1,ind] = gsort(a,'r','i');
+nc = size(a,'c');
+test = [];
+for i = 1:nc ; 
+    test = [test, matrix(a(ind(:,i),i),N,1)];
+end
+assert_checkequal(a1, test);
 
-[a1,ind]=gsort(a,'r','i');
-nc=size(a,'c');
-test=[];
-for i=1:nc ; 
-  test= [test, matrix(a(ind(:,i),i),N,1)];
-end 
-if or((a1- test)<>0)  then pause,end;
-
-test=[];
-for i=1:nc ; 
-   test= [test, gsort(a(:,i),'g','i')];
+test = [];
+for i = 1:nc ; 
+    test = [test, gsort(a(:,i),'g','i')];
 end 
-if or((a1- test)<>0)  then pause,end;
+assert_checkequal(a1, test);
 
 //----sort each row of a ('c' means that the column indice is used for sorting)
+[a1,ind] = gsort(a,'c');
+nr = size(a,'r');
+test = [];
+for i = 1:nr 
+    test = [test; matrix(a(i,ind(i,:)),1,P)];
+end
+assert_checkequal(a1, test);
 
-[a1,ind]=gsort(a,'c')   ;
-nr=size(a,'r');
-test=[];
-for i=1:nr ; 
-   test= [test; matrix(a(i,ind(i,:)),1,P)];
-end 
-if or((a1- test)<>0)  then pause,end;
-
-test=[];
-for i=1:nr ; 
-   test= [test; gsort(a(i,:),'g')];
+test = [];
+for i = 1:nr
+    test = [test; gsort(a(i,:),'g')];
 end 
-if or((a1- test)<>0)  then pause,end;
+assert_checkequal(a1, test);
 
 //increasing 
-
-[a1,ind]=gsort(a,'c','i')   ;
-nr=size(a,'r');
-test=[];
-for i=1:nr ; 
-   test= [test; matrix(a(i,ind(i,:)),1,P)];
-end 
-if or((a1- test)<>0)  then pause,end;
-test=[];
-for i=1:nr ; 
-   test= [test; gsort(a(i,:),'g','i')];
-end 
-if or((a1- test)<>0)  then pause,end;
+[a1,ind] = gsort(a,'c','i');
+nr = size(a,'r');
+test = [];
+for i = 1:nr 
+    test = [test; matrix(a(i,ind(i,:)),1,P)];
+end
+assert_checkequal(a1, test);
+test = [];
+for i = 1:nr 
+    test = [test; gsort(a(i,:),'g','i')];
+end
+assert_checkequal(a1, test);
 
 //----sort the rows of a in lexicographic order 
 //    i.e a(k,:) < a(l,:) if there's a number j 
-//    such that a(k,j) < a(l,j) and a(k,p)=a(l,p) for p in [1,j-1];
+//    such that a(k,j) < a(l,j) or a(k,p)=a(l,p) for p in [1,j-1];
 //
-N1=4;P1=3;
-alr=[1,2,2;
-     1,2,1;
-     1,1,2;
-     1,1,1];
+N1 = 4;P1 = 3;
+alr = [1,2,2;
+1,2,1;
+1,1,2;
+1,1,1];
 // a random permutation 
-[ax,perm]=gsort(rand(1,N1,'u'));
-a=alr(perm,:);
+[ax,perm] = gsort(rand(1,N1,'u'));
+a = uint32(alr(perm,:));
 
-[a1,ind]=gsort(a,'lr');                   
-
-if or((a1- alr) <>0) then pause,end;
-if or((a1- matrix(a(ind,:),N1,P1)) <>0) then pause,end;
+[a1,ind] = gsort(a,'lr');
+assert_checkequal(a1, uint32(alr));
+assert_checkequal(a1, matrix(a(ind,:),N1,P1));
 
 [a2,ind2]=gsort(a*[100;10;1],'g');
-if or((ind2-ind)<>0) then pause,end;
+assert_checkequal(ind2, ind);
 ///////////////////////
-for i=1:Nrand
-  vmax=4;
-  b = uint32(vmax*rand(N,P,'u')); 
-  [b1,ind]=gsort(b,'lr');
-  if or((b1- b(ind,:)) <>0) then pause,end;
-  v= double(b1)*((vmax+1)^[P-1:-1:0])';
-  if or( v(2:$)-v(1:$-1) > 0 ) then pause,end 
+for i = 1:Nrand
+    b = uint32(vmax*rand(N,P,'u')); 
+    [b1,ind] = gsort(b,'lr');
+    assert_checkequal(b1, b(ind,:));
+    v = double(b1)*((vmax+1)^[P-1:-1:0])';
+    assert_checktrue(or(v(2:$)-v(1:$-1) <= 0));
 end 
 
 // increasing 
+[a1,ind] = gsort(a,'lr','i');
+assert_checkequal(a1, uint32(alr(N1:-1:1,:)));
+assert_checkequal(a1, matrix(a(ind,:),N1,P1));
 
-[a1,ind]=gsort(a,'lr','i');                   
-if or((a1- alr(N1:-1:1,:)) <>0) then pause,end;
-
-if or((a1- matrix(a(ind,:),N1,P1)) <>0) then pause,end;
 [a2,ind2]=gsort(a*[100;10;1],'g','i');
-if or((ind2-ind) <>0) then pause,end;
-
-for i=1:Nrand
-  vmax=4;
-  b = int(vmax*rand(N,P,'u')); 
-  [b1,ind]=gsort(b,'lr','i');
-  if or((b1- b(ind,:)) <>0) then pause,end;
-  v= double(b1)*((vmax+1)^[P-1:-1:0])';
-  if or( v(2:$)-v(1:$-1) < 0 ) then pause,end 
-end 
+assert_checkequal(ind2, ind);
 
-//----sort the columns of a in lexicographic order 
+for i = 1:Nrand
+    b = int(vmax*rand(N,P,'u')); 
+    [b1,ind] = gsort(b,'lr','i');
+    assert_checkequal(b1, b(ind,:));
+    v= double(b1)*((vmax+1)^[P-1:-1:0])';
+    assert_checktrue(or(v(2:$)-v(1:$-1) >= 0));
+end 
 
-N1=3;P1=4;
-alr=alr';
+//----sort the columns of a in lexicographic order
+N1 = 3;P1 = 4;
+alr = alr';
 // a random permutation 
-[ax,perm]=gsort(rand(1,P1,'u'));
-a=alr(:,perm);
+[ax,perm] = gsort(rand(1,P1,'u'));
+a = uint32(alr(:,perm));
 
-[a1,ind]=gsort(a,'lc');                   
+[a1,ind] = gsort(a,'lc');
+assert_checkequal(a1, uint32(alr));
+assert_checkequal(a1, matrix(a(:,ind),N1,P1));
 
-if or((a1- alr) <>0) then pause,end;
-if or((a1- matrix(a(:,ind),N1,P1)) <>0) then pause,end;
+[a2,ind2] = gsort([100,10,1]*a,'g');
+assert_checkequal(ind2, ind);
 
-[a2,ind2]=gsort([100,10,1]*a,'g');
-if or((ind2-ind) <>0) then pause,end;
-
-for i=1:Nrand
-  vmax=4;
-  b = int(vmax*rand(N1,P1,'u')); 
-  [b1,ind]=gsort(b,'lc');
-  if or((b1- b(:,ind)) <>0) then pause,end;
-  v= ((vmax+1)^[N1-1:-1:0])*double(b1);
-  if or( v(2:$)-v(1:$-1) > 0 ) then pause,end 
+for i = 1:Nrand
+    b = int(vmax * rand(N1,P1,'u')); 
+    [b1,ind] = gsort(b,'lc');
+    assert_checkequal(b1, b(:,ind));
+    v= ((vmax+1)^[N1-1:-1:0])*double(b1);
+    assert_checktrue(or(v(2:$)-v(1:$-1) <= 0));
 end 
 
-//increasing 
-
-[a1,ind]=gsort(a,'lc','i');                   
+//increasing
+[a1,ind] = gsort(a,'lc','i');
+assert_checkequal(a1, uint32(alr(:,P1:-1:1)));
+assert_checkequal(a1, matrix(a(:,ind),N1,P1));
 
-if or((a1- alr(:,P1:-1:1)) <>0) then pause,end;
-if or((a1- matrix(a(:,ind),N1,P1)) <>0) then pause,end;
+[a2,ind2] = gsort([100,10,1] * a,'g','i');
+assert_checkequal(ind2, ind);
 
-[a2,ind2]=gsort([100,10,1]*a,'g','i');
-if or((ind2-ind) <>0) then pause,end;
-
-for i=1:Nrand
-  vmax=4;
-  b = int(vmax*rand(N,P,'u')); 
-  [b1,ind]=gsort(b,'lc','i');
-  if or((b1- b(:,ind)) <>0) then pause,end;
-  v= ((vmax+1)^[N-1:-1:0])*b1;
-  if or( v(2:$)-v(1:$-1) < 0 ) then pause,end 
+for i = 1:Nrand
+    b = int(vmax * rand(N,P,'u')); 
+    [b1,ind] = gsort(b,'lc','i');
+    assert_checkequal(b1, b(:,ind));
+    v= ((vmax+1)^[N-1:-1:0])*b1;
+    assert_checktrue(or(v(2:$)-v(1:$-1) >= 0));
 end 
 
 a = uint32([1,1,1,1,2,2,3,3,2,2,3,3,4,4,4,4,4,4,4,4,5,5,5,6,6,6,7,7,7,7,8,8,8,8,9,9,9,9,9,9,9,7,9,10,..
- 10,10,10,11,11,11,12,13,13,13,13,14,14,12,12,14,14,14,14,14,14,15,15,15,15,16,17,18;
+10,10,10,11,11,11,12,13,13,13,13,14,14,12,12,14,14,14,14,14,14,15,15,15,15,16,17,18;
 3,4,4,5,3,8,4,4,7,8,8,8,5,5,8,9,10,10,9,8,6,10,10,10,10,11,8,8,13,13,9,9,13,13,10,10,13,..
- 13,14,15,15,12,14,11,11,15,15,15,15,16,17,14,14,17,17,15,15,13,13,17,17,18,18,19,19,16,..
- 16,19,19,19,18,19]-5)';
-[b,ind]=gsort(a,'lr','i');
-t=b(2:$,:)<b(1:$-1,:);
-if or(t(:,1)) then pause,end
-if or(t(b(2:$,1)==b(1:$-1,1),2)) then pause,end
-if or(a(ind,:)<>b) then pause,end
-
-for k=1:30
-  p=grand(1,'prm',(1:size(a,1))');
-  [b,ind]=gsort(a(p,:),'lr','i');
-  t=b(2:$,:)<b(1:$-1,:);
-  if or(t(:,1)) then pause,end
-  if or(t(b(2:$,1)==b(1:$-1,1),2)) then pause,end
-  if or(a(p(ind),:)<>b) then pause,end
+13,14,15,15,12,14,11,11,15,15,15,15,16,17,14,14,17,17,15,15,13,13,17,17,18,18,19,19,16,..
+16,19,19,19,18,19]-5)';
+[b,ind] = gsort(a,'lr','i');
+t = b(2:$,:) < b(1:$-1,:);
+assert_checkfalse(or(t(:,1)));
+assert_checkfalse(or(t(b(2:$,1)==b(1:$-1,1),2)));
+assert_checkequal(a(ind,:),b);
+
+for k = 1:30
+    p = grand(1,'prm',(1:size(a,1))');
+    [b,ind] = gsort(a(p,:),'lr','i');
+    t = b(2:$,:) < b(1:$-1,:);
+    assert_checkfalse(or(t(:,1)));
+    assert_checkfalse(or(t(b(2:$,1)==b(1:$-1,1),2)));
+    assert_checkequal(a(p(ind),:),b);
 end
 
-[b,ind]=gsort(a,'lr','d');
-t=b(2:$,:)>b(1:$-1,:);
-if or(t(:,1)) then pause,end
-if or(t(b(2:$,1)==b(1:$-1,1),2)) then pause,end
-if or(a(ind,:)<>b) then pause,end
-
-
-for k=1:30
-  p=grand(1,'prm',(1:size(a,1))');
-  [b,ind]=gsort(a(p,:),'lr','d');
-  t=b(2:$,:)>b(1:$-1,:);
-  if or(t(:,1)) then pause,end
-  if or(t(b(2:$,1)==b(1:$-1,1),2)) then pause,end
-  if or(a(p(ind),:)<>b) then pause,end
+[b,ind] = gsort(a,'lr','d');
+t = b(2:$,:) > b(1:$-1,:);
+assert_checkfalse(or(t(:,1)));
+assert_checkfalse(or(t(b(2:$,1)==b(1:$-1,1),2)));
+assert_checkequal(a(ind,:),b);
+
+for k = 1:30
+    p = grand(1,'prm',(1:size(a,1))');
+    [b,ind] = gsort(a(p,:),'lr','d');
+    t = b(2:$,:) > b(1:$-1,:);
+    assert_checkfalse(or(t(:,1)));
+    assert_checkfalse(or(t(b(2:$,1)==b(1:$-1,1),2)));
+    assert_checkequal(a(p(ind),:),b);
 end
 
+a = b;
+a([10 60],:) = a([60 10],:);
+[b,ind] = gsort(a,'lr','i');
+t = b(2:$,:) < b(1:$-1,:);
+assert_checkfalse(or(t(:,1)));
+assert_checkfalse(or(t(b(2:$,1)==b(1:$-1,1),2)));
+assert_checkequal(a(ind,:),b);
 
-a=b;
-a([10 60],:)=a([60 10],:);
-[b,ind]=gsort(a,'lr','i');
-t=b(2:$,:)<b(1:$-1,:);
-if or(t(:,1)) then pause,end
-if or(t(b(2:$,1)==b(1:$-1,1),2)) then pause,end
-if or(a(ind,:)<>b) then pause,end
-
-[b,ind]=gsort(a,'lr','d');
-t=b(2:$,:)>b(1:$-1,:);
-if or(t(:,1)) then pause,end
-if or(t(b(2:$,1)==b(1:$-1,1),2)) then pause,end
-if or(a(ind,:)<>b) then pause,end
+[b,ind] = gsort(a,'lr','d');
+t = b(2:$,:) > b(1:$-1,:);
+assert_checkfalse(or(t(:,1)));
+assert_checkfalse(or(t(b(2:$,1)==b(1:$-1,1),2)));
+assert_checkequal(a(ind,:),b);
 
 // test of gsort for uuint16 matrices:
-N=4;P=20;Nrand=100; 
+N = 4;P = 20;Nrand = 100; vmax = 4;
 
 a = uint16(matrix(grand(1,'prm',(1:N*P)'),N,P));
 
 //-----Global sort --------------------------------
 
-[a1,ind]=gsort(a,'g');
-
-if or(a1- matrix(N*P:-1:1,N,P) <>0) then pause,end;
-if or(a1- matrix(a(ind),N,P)  <>0) then pause,end;
+[a1,ind] = gsort(a,'g');
+assert_checkequal(a1, uint16(matrix(N*P:-1:1,N,P)));
+assert_checkequal(a1, matrix(a(ind),N,P));
 
-for i=1:Nrand 
-  b = uint16(10*rand(N,P,'u')); 
-  [b1,ind]=gsort(b,'g');
-  if or(b1- matrix(b(ind),N,P)<>0)  then pause,end;
-  if or(b1(1:$-1)-b1(2:$) <0) then pause,end
+for i = 1:Nrand 
+    b = uint16(10 * rand(N,P,'u')); 
+    [b1,ind] = gsort(b,'g');
+    assert_checkequal(b1, matrix(b(ind),N,P));
+    assert_checktrue(or(b1(1:$-1) - b1(2:$) >= 0));
 end 
 
-//increasing values 
-
-[a1,ind]=gsort(a,'g','i');
-
-if or(a1- matrix(1:N*P,N,P) <>0) then pause,end;
-if or(a1- matrix(a(ind),N,P)  <>0) then pause,end;
+//increasing values
+[a1,ind] = gsort(a,'g','i');
+assert_checkequal(a1, uint16(matrix(1:N*P,N,P)));
+assert_checkequal(a1, matrix(a(ind),N,P));
 
 //----sort each column of a ('r' means that the row indice is used for sorting)
-
-[a1,ind]=gsort(a,'r');
-nc=size(a,'c');
-test=[];
-for i=1:nc ; 
-   test= [test, matrix(a(ind(:,i),i),N,1)];
-end 
-if or((a1- test)<>0)  then pause,end;
-test=[];
-for i=1:nc ; 
-   test= [test, gsort(a(:,i),'g')];
+[a1,ind] = gsort(a,'r');
+nc = size(a,'c');
+test = [];
+for i = 1:nc
+    test = [test, matrix(a(ind(:,i),i),N,1)];
+end
+assert_checkequal(a1, test);
+test = [];
+for i = 1:nc
+    test = [test, gsort(a(:,i),'g')];
 end 
-if or((a1- test)<>0)  then pause,end;
+assert_checkequal(a1, test);
 
-//increasing values 
-
-[a1,ind]=gsort(a,'r','i');
-nc=size(a,'c');
-test=[];
-for i=1:nc ; 
-  test= [test, matrix(a(ind(:,i),i),N,1)];
+//increasing values
+[a1,ind] = gsort(a,'r','i');
+nc = size(a,'c');
+test = [];
+for i = 1:nc 
+    test = [test, matrix(a(ind(:,i),i),N,1)];
 end 
-if or((a1- test)<>0)  then pause,end;
+assert_checkequal(a1, test);
 
-test=[];
-for i=1:nc ; 
-   test= [test, gsort(a(:,i),'g','i')];
+test = [];
+for i = 1:nc 
+    test = [test, gsort(a(:,i),'g','i')];
 end 
-if or((a1- test)<>0)  then pause,end;
+assert_checkequal(a1, test);
 
 //----sort each row of a ('c' means that the column indice is used for sorting)
+[a1,ind] = gsort(a,'c');
+nr = size(a,'r');
+test = [];
+for i = 1:nr
+    test = [test; matrix(a(i,ind(i,:)),1,P)];
+end 
+assert_checkequal(a1, test);
+
+test = [];
+for i = 1:nr 
+    test = [test; gsort(a(i,:),'g')];
+end 
+assert_checkequal(a1, test);
+
+//increasing
+[a1,ind] = gsort(a,'c','i');
+nr = size(a,'r');
+test = [];
+for i = 1:nr
+    test = [test; matrix(a(i,ind(i,:)),1,P)];
+end
+assert_checkequal(a1, test);
 
-[a1,ind]=gsort(a,'c')   ;
-nr=size(a,'r');
-test=[];
-for i=1:nr ; 
-   test= [test; matrix(a(i,ind(i,:)),1,P)];
-end 
-if or((a1- test)<>0)  then pause,end;
-
-test=[];
-for i=1:nr ; 
-   test= [test; gsort(a(i,:),'g')];
-end 
-if or((a1- test)<>0)  then pause,end;
-
-
-//increasing 
-
-[a1,ind]=gsort(a,'c','i')   ;
-nr=size(a,'r');
-test=[];
-for i=1:nr ; 
-   test= [test; matrix(a(i,ind(i,:)),1,P)];
-end 
-if or((a1- test)<>0)  then pause,end;
-test=[];
-for i=1:nr ; 
-   test= [test; gsort(a(i,:),'g','i')];
+test = [];
+for i = 1:nr
+    test = [test; gsort(a(i,:),'g','i')];
 end 
-if or((a1- test)<>0)  then pause,end;
+assert_checkequal(a1, test);
 
 //----sort the rows of a in lexicographic order 
 //    i.e a(k,:) < a(l,:) if there's a number j 
-//    such that a(k,j) < a(l,j) and a(k,p)=a(l,p) for p in [1,j-1];
+//    such that a(k,j) < a(l,j) or a(k,p)=a(l,p) for p in [1,j-1];
 //
-N1=4;P1=3;
-alr=[1,2,2;
-     1,2,1;
-     1,1,2;
-     1,1,1];
+N1 = 4;P1 = 3;
+alr = [1,2,2;
+1,2,1;
+1,1,2;
+1,1,1];
 // a random permutation 
-[ax,perm]=gsort(rand(1,N1,'u'));
-a=alr(perm,:);
+[ax,perm] = gsort(rand(1,N1,'u'));
+a = uint16(alr(perm,:));
 
-[a1,ind]=gsort(a,'lr');                   
+[a1,ind] = gsort(a,'lr');
+assert_checkequal(a1, uint16(alr));
+assert_checkequal(a1, matrix(a(ind,:),N1,P1));
 
-if or((a1- alr) <>0) then pause,end;
-if or((a1- matrix(a(ind,:),N1,P1)) <>0) then pause,end;
-
-[a2,ind2]=gsort(a*[100;10;1],'g');
-if or((ind2-ind)<>0) then pause,end;
+[a2,ind2] = gsort(a * [100;10;1],'g');
+assert_checkequal(ind2, ind);
 ///////////////////////
-for i=1:Nrand
-  vmax=4;
-  b = uint16(vmax*rand(N,P,'u')); 
-  [b1,ind]=gsort(b,'lr');
-  if or((b1- b(ind,:)) <>0) then pause,end;
-  v= double(b1)*((vmax+1)^[P-1:-1:0])';
-  if or( v(2:$)-v(1:$-1) > 0 ) then pause,end 
+for i = 1:Nrand
+    b = uint16(vmax*rand(N,P,'u')); 
+    [b1,ind] = gsort(b,'lr');
+    assert_checkequal(b1, b(ind,:));
+    v= double(b1)*((vmax+1)^[P-1:-1:0])';
+    assert_checktrue(or(v(2:$)-v(1:$-1) <= 0));
 end 
 
-// increasing 
+// increasing
+[a1,ind] = gsort(a,'lr','i');
+assert_checkequal(a1, uint16(alr(N1:-1:1,:)));
+assert_checkequal(a1, matrix(a(ind,:),N1,P1));
 
-[a1,ind]=gsort(a,'lr','i');                   
-if or((a1- alr(N1:-1:1,:)) <>0) then pause,end;
+[a2,ind2] = gsort(a * [100;10;1],'g','i');
+assert_checkequal(ind2, ind);
 
-if or((a1- matrix(a(ind,:),N1,P1)) <>0) then pause,end;
-[a2,ind2]=gsort(a*[100;10;1],'g','i');
-if or((ind2-ind) <>0) then pause,end;
-
-for i=1:Nrand
-  vmax=4;
-  b = int(vmax*rand(N,P,'u')); 
-  [b1,ind]=gsort(b,'lr','i');
-  if or((b1- b(ind,:)) <>0) then pause,end;
-  v= double(b1)*((vmax+1)^[P-1:-1:0])';
-  if or( v(2:$)-v(1:$-1) < 0 ) then pause,end 
+for i = 1:Nrand
+    b = int(vmax * rand(N,P,'u')); 
+    [b1,ind] = gsort(b,'lr','i');
+    assert_checkequal(b1, b(ind,:));
+    v = double(b1) * ((vmax+1)^[P-1:-1:0])';
+    assert_checktrue(or(v(2:$)-v(1:$-1) >= 0));
 end 
 
 //----sort the columns of a in lexicographic order 
-
-N1=3;P1=4;
-alr=alr';
+N1 = 3;P1 = 4;
+alr = alr';
 // a random permutation 
-[ax,perm]=gsort(rand(1,P1,'u'));
-a=alr(:,perm);
+[ax,perm] = gsort(rand(1,P1,'u'));
+a = uint16(alr(:,perm));
 
-[a1,ind]=gsort(a,'lc');                   
+[a1,ind] = gsort(a,'lc');
+assert_checkequal(a1, uint16(alr));
+assert_checkequal(a1, matrix(a(:,ind),N1,P1));
 
-if or((a1- alr) <>0) then pause,end;
-if or((a1- matrix(a(:,ind),N1,P1)) <>0) then pause,end;
+[a2,ind2] = gsort([100,10,1] * a,'g');
+assert_checkequal(ind2, ind);
 
-[a2,ind2]=gsort([100,10,1]*a,'g');
-if or((ind2-ind) <>0) then pause,end;
-
-for i=1:Nrand
-  vmax=4;
-  b = int(vmax*rand(N1,P1,'u')); 
-  [b1,ind]=gsort(b,'lc');
-  if or((b1- b(:,ind)) <>0) then pause,end;
-  v= ((vmax+1)^[N1-1:-1:0])*double(b1);
-  if or( v(2:$)-v(1:$-1) > 0 ) then pause,end 
+for i = 1:Nrand  
+    b = int(vmax * rand(N1,P1,'u')); 
+    [b1,ind] = gsort(b,'lc');
+    assert_checkequal(b1, b(:,ind));
+    v = ((vmax+1)^[N1-1:-1:0]) * double(b1);
+    assert_checktrue(or(v(2:$)-v(1:$-1) <= 0));
 end 
 
-//increasing 
+//increasing
+[a1,ind] = gsort(a,'lc','i');
 
-[a1,ind]=gsort(a,'lc','i');                   
+assert_checkequal(a1, uint16(alr(:,P1:-1:1)));
+assert_checkequal(a1, matrix(a(:,ind),N1,P1));
 
-if or((a1- alr(:,P1:-1:1)) <>0) then pause,end;
-if or((a1- matrix(a(:,ind),N1,P1)) <>0) then pause,end;
+[a2,ind2] = gsort([100,10,1] * a,'g','i');
+assert_checkequal(ind2, ind);
 
-[a2,ind2]=gsort([100,10,1]*a,'g','i');
-if or((ind2-ind) <>0) then pause,end;
-
-for i=1:Nrand
-  vmax=4;
-  b = int(vmax*rand(N,P,'u')); 
-  [b1,ind]=gsort(b,'lc','i');
-  if or((b1- b(:,ind)) <>0) then pause,end;
-  v= ((vmax+1)^[N-1:-1:0])*b1;
-  if or( v(2:$)-v(1:$-1) < 0 ) then pause,end 
-end 
+vmax = 4;
+for i = 1:Nrand
+    b = int(vmax * rand(N,P,'u')); 
+    [b1,ind] = gsort(b,'lc','i');
+    assert_checkequal(b1, b(:,ind));
+    v = ((vmax+1)^[N-1:-1:0])*b1;
+    assert_checktrue(or(v(2:$)-v(1:$-1) >= 0));
+end
 
 ////////////////////////////////////////////////////////////////////////
-// test of gsort for uuint8 matrices:
-N=4;P=20;Nrand=100; 
+// test of gsort for uint8 matrices:
+N = 4;P = 20;Nrand = 100; vmax = 4;
 
 a = uint8(matrix(grand(1,'prm',(1:N*P)'),N,P));
 
 //-----Global sort --------------------------------
 
-[a1,ind]=gsort(a,'g');
+[a1,ind] = gsort(a,'g');
+assert_checkequal(a1, uint8(matrix(N*P:-1:1,N,P)));
+assert_checkequal(a1, matrix(a(ind),N,P));
 
-if or(a1- matrix(N*P:-1:1,N,P) <>0) then pause,end;
-if or(a1- matrix(a(ind),N,P)  <>0) then pause,end;
-
-for i=1:Nrand 
-  b = uint8(10*rand(N,P,'u')); 
-  [b1,ind]=gsort(b,'g');
-  if or(b1- matrix(b(ind),N,P)<>0)  then pause,end;
-  if or(b1(1:$-1)-b1(2:$) <0) then pause,end
-end 
-
-//increasing values 
-
-[a1,ind]=gsort(a,'g','i');
-
-if or(a1- matrix(1:N*P,N,P) <>0) then pause,end;
-if or(a1- matrix(a(ind),N,P)  <>0) then pause,end;
+for i = 1:Nrand 
+    b = uint8(10*rand(N,P,'u')); 
+    [b1,ind] = gsort(b,'g');
+    assert_checkequal(b1, matrix(b(ind),N,P));
+    assert_checktrue(or(b1(1:$-1)-b1(2:$) >= 0));
+end
 
+//increasing values
+[a1,ind] = gsort(a,'g','i');
+assert_checkequal(a1, uint8(matrix(1:N*P,N,P)));
+assert_checkequal(a1, matrix(a(ind),N,P));
 
 //----sort each column of a ('r' means that the row indice is used for sorting)
+[a1,ind] = gsort(a,'r');
+nc = size(a,'c');
+test = [];
+for i = 1:nc
+    test = [test, matrix(a(ind(:,i),i),N,1)];
+end
+assert_checkequal(a1, test);
 
-[a1,ind]=gsort(a,'r');
-nc=size(a,'c');
-test=[];
-for i=1:nc ; 
-   test= [test, matrix(a(ind(:,i),i),N,1)];
-end 
-if or((a1- test)<>0)  then pause,end;
-test=[];
-for i=1:nc ; 
-   test= [test, gsort(a(:,i),'g')];
-end 
-if or((a1- test)<>0)  then pause,end;
-
-
-//increasing values 
+test = [];
+for i = 1:nc 
+    test = [test, gsort(a(:,i),'g')];
+end
+assert_checkequal(a1, test);
 
-[a1,ind]=gsort(a,'r','i');
-nc=size(a,'c');
-test=[];
-for i=1:nc ; 
-  test= [test, matrix(a(ind(:,i),i),N,1)];
+//increasing values
+[a1,ind] = gsort(a,'r','i');
+nc = size(a,'c');
+test = [];
+for i = 1:nc 
+    test = [test, matrix(a(ind(:,i),i),N,1)];
 end 
-if or((a1- test)<>0)  then pause,end;
+assert_checkequal(a1, test);
 
-test=[];
-for i=1:nc ; 
-   test= [test, gsort(a(:,i),'g','i')];
-end 
-if or((a1- test)<>0)  then pause,end;
+test = [];
+for i = 1:nc ; 
+    test = [test, gsort(a(:,i),'g','i')];
+end
+assert_checkequal(a1, test);
 
 //----sort each row of a ('c' means that the column indice is used for sorting)
+[a1,ind] = gsort(a,'c');
+nr = size(a,'r');
+test = [];
+for i = 1:nr; 
+    test = [test; matrix(a(i,ind(i,:)),1,P)];
+end
+assert_checkequal(a1, test);
 
-[a1,ind]=gsort(a,'c')   ;
-nr=size(a,'r');
-test=[];
-for i=1:nr ; 
-   test= [test; matrix(a(i,ind(i,:)),1,P)];
+test = [];
+for i = 1:nr
+    test = [test; gsort(a(i,:),'g')];
 end 
-if or((a1- test)<>0)  then pause,end;
+assert_checkequal(a1, test);
 
-test=[];
-for i=1:nr ; 
-   test= [test; gsort(a(i,:),'g')];
+//increasing
+[a1,ind] = gsort(a,'c','i');
+nr = size(a,'r');
+test = [];
+for i = 1:nr 
+    test = [test; matrix(a(i,ind(i,:)),1,P)];
 end 
-if or((a1- test)<>0)  then pause,end;
+assert_checkequal(a1, test);
 
-//increasing 
-
-[a1,ind]=gsort(a,'c','i')   ;
-nr=size(a,'r');
-test=[];
-for i=1:nr ; 
-   test= [test; matrix(a(i,ind(i,:)),1,P)];
-end 
-if or((a1- test)<>0)  then pause,end;
-test=[];
-for i=1:nr ; 
-   test= [test; gsort(a(i,:),'g','i')];
+test = [];
+for i = 1:nr
+    test = [test; gsort(a(i,:),'g','i')];
 end 
-if or((a1- test)<>0)  then pause,end;
+assert_checkequal(a1, test);
 
 //----sort the rows of a in lexicographic order 
 //    i.e a(k,:) < a(l,:) if there's a number j 
-//    such that a(k,j) < a(l,j) and a(k,p)=a(l,p) for p in [1,j-1];
+//    such that a(k,j) < a(l,j) or a(k,p)=a(l,p) for p in [1,j-1];
 //
-N1=4;P1=3;
-alr=[1,2,2;
-     1,2,1;
-     1,1,2;
-     1,1,1];
+N1 = 4;P1 = 3;
+alr = [1,2,2;
+1,2,1;
+1,1,2;
+1,1,1];
 // a random permutation 
-[ax,perm]=gsort(rand(1,N1,'u'));
-a=alr(perm,:);
-
-[a1,ind]=gsort(a,'lr');                   
+[ax,perm] = gsort(rand(1,N1,'u'));
+a = uint8(alr(perm,:));
 
-if or((a1- alr) <>0) then pause,end;
-if or((a1- matrix(a(ind,:),N1,P1)) <>0) then pause,end;
+[a1,ind] = gsort(a,'lr');
+assert_checkequal(a1, uint8(alr));
+assert_checkequal(a1, matrix(a(ind,:),N1,P1));
 
-[a2,ind2]=gsort(a*[100;10;1],'g');
-if or((ind2-ind)<>0) then pause,end;
+[a2,ind2] = gsort(a*[100;10;1],'g');
+assert_checkequal(ind2, ind);
 ///////////////////////
-for i=1:Nrand
-  vmax=4;
-  b = uint8(vmax*rand(N,P,'u')); 
-  [b1,ind]=gsort(b,'lr');
-  if or((b1- b(ind,:)) <>0) then pause,end;
-  v= double(b1)*((vmax+1)^[P-1:-1:0])';
-  if or( v(2:$)-v(1:$-1) > 0 ) then pause,end 
+for i = 1:Nrand
+    b = uint8(vmax*rand(N,P,'u')); 
+    [b1,ind] = gsort(b,'lr');
+    assert_checkequal(b1, b(ind,:));
+    v = double(b1)*((vmax+1)^[P-1:-1:0])';
+    assert_checktrue(or(v(2:$)-v(1:$-1) <= 0));
 end 
 
-// increasing 
+// increasing
+[a1,ind] = gsort(a,'lr','i');
+assert_checkequal(a1, uint8(alr(N1:-1:1,:)));
+assert_checkequal(a1, matrix(a(ind,:),N1,P1));
 
-[a1,ind]=gsort(a,'lr','i');                   
-if or((a1- alr(N1:-1:1,:)) <>0) then pause,end;
+[a2,ind2] = gsort(a*[100;10;1],'g','i');
+assert_checkequal(ind2, ind);
 
-if or((a1- matrix(a(ind,:),N1,P1)) <>0) then pause,end;
-[a2,ind2]=gsort(a*[100;10;1],'g','i');
-if or((ind2-ind) <>0) then pause,end;
-
-for i=1:Nrand
-  vmax=4;
-  b = int(vmax*rand(N,P,'u')); 
-  [b1,ind]=gsort(b,'lr','i');
-  if or((b1- b(ind,:)) <>0) then pause,end;
-  v= double(b1)*((vmax+1)^[P-1:-1:0])';
-  if or( v(2:$)-v(1:$-1) < 0 ) then pause,end 
+for i = 1:Nrand
+    b = int(vmax*rand(N,P,'u')); 
+    [b1,ind] = gsort(b,'lr','i');
+    assert_checkequal(b1, b(ind,:));
+    v= double(b1)*((vmax+1)^[P-1:-1:0])';
+    assert_checktrue(or(v(2:$)-v(1:$-1) >= 0));
 end 
 
-//----sort the columns of a in lexicographic order 
-
-N1=3;P1=4;
-alr=alr';
+//----sort the columns of a in lexicographic order
+N1 = 3;P1 = 4;
+alr = alr';
 // a random permutation 
-[ax,perm]=gsort(rand(1,P1,'u'));
-a=alr(:,perm);
-
-[a1,ind]=gsort(a,'lc');                   
-
-if or((a1- alr) <>0) then pause,end;
-if or((a1- matrix(a(:,ind),N1,P1)) <>0) then pause,end;
-
-[a2,ind2]=gsort([100,10,1]*a,'g');
-if or((ind2-ind) <>0) then pause,end;
-
-for i=1:Nrand
-  vmax=4;
-  b = int(vmax*rand(N1,P1,'u')); 
-  [b1,ind]=gsort(b,'lc');
-  if or((b1- b(:,ind)) <>0) then pause,end;
-  v= ((vmax+1)^[N1-1:-1:0])*double(b1);
-  if or( v(2:$)-v(1:$-1) > 0 ) then pause,end 
-end 
-
-//increasing 
-
-[a1,ind]=gsort(a,'lc','i');                   
-
-if or((a1- alr(:,P1:-1:1)) <>0) then pause,end;
-if or((a1- matrix(a(:,ind),N1,P1)) <>0) then pause,end;
-
-[a2,ind2]=gsort([100,10,1]*a,'g','i');
-if or((ind2-ind) <>0) then pause,end;
-
-for i=1:Nrand
-  vmax=4;
-  b = int(vmax*rand(N,P,'u')); 
-  [b1,ind]=gsort(b,'lc','i');
-  if or((b1- b(:,ind)) <>0) then pause,end;
-  v= ((vmax+1)^[N-1:-1:0])*b1;
-  if or( v(2:$)-v(1:$-1) < 0 ) then pause,end 
-end 
-
+[ax,perm] = gsort(rand(1,P1,'u'));
+a = uint8(alr(:,perm));
+
+[a1,ind] = gsort(a,'lc');
+assert_checkequal(a1, uint8(alr));
+assert_checkequal(a1, matrix(a(:,ind),N1,P1));
+
+[a2,ind2] = gsort([100,10,1]*a,'g');
+assert_checkequal(ind2, ind);
+
+for i = 1:Nrand
+    b = int(vmax * rand(N1,P1,'u')); 
+    [b1,ind] = gsort(b,'lc');
+    assert_checkequal(b1, b(:,ind));
+    v = ((vmax+1)^[N1-1:-1:0])*double(b1);
+    assert_checktrue(or(v(2:$)-v(1:$-1) <= 0));
+end 
+
+//increasing
+[a1,ind] = gsort(a,'lc','i');
+assert_checkequal(a1, uint8(alr(:,P1:-1:1)));
+assert_checkequal(a1, matrix(a(:,ind),N1,P1));
+
+[a2,ind2] = gsort([100,10,1]*a,'g','i');
+assert_checkequal(ind2, ind);
+
+for i = 1:Nrand
+    b = int(vmax*rand(N,P,'u')); 
+    [b1,ind] = gsort(b,'lc','i');
+    assert_checkequal(b1, b(:,ind));
+    v= ((vmax+1)^[N-1:-1:0])*b1;
+    assert_checktrue(or(v(2:$)-v(1:$-1) >= 0));
+end
 
 a = uint8([1,1,1,1,2,2,3,3,2,2,3,3,4,4,4,4,4,4,4,4,5,5,5,6,6,6,7,7,7,7,8,8,8,8,9,9,9,9,9,9,9,7,9,10,..
- 10,10,10,11,11,11,12,13,13,13,13,14,14,12,12,14,14,14,14,14,14,15,15,15,15,16,17,18;
+10,10,10,11,11,11,12,13,13,13,13,14,14,12,12,14,14,14,14,14,14,15,15,15,15,16,17,18;
 3,4,4,5,3,8,4,4,7,8,8,8,5,5,8,9,10,10,9,8,6,10,10,10,10,11,8,8,13,13,9,9,13,13,10,10,13,..
- 13,14,15,15,12,14,11,11,15,15,15,15,16,17,14,14,17,17,15,15,13,13,17,17,18,18,19,19,16,..
- 16,19,19,19,18,19]-5)';
-[b,ind]=gsort(a,'lr','i');
-t=b(2:$,:)<b(1:$-1,:);
-if or(t(:,1)) then pause,end
-if or(t(b(2:$,1)==b(1:$-1,1),2)) then pause,end
-if or(a(ind,:)<>b) then pause,end
-
-for k=1:30
-  p=grand(1,'prm',(1:size(a,1))');
-  [b,ind]=gsort(a(p,:),'lr','i');
-  t=b(2:$,:)<b(1:$-1,:);
-  if or(t(:,1)) then pause,end
-  if or(t(b(2:$,1)==b(1:$-1,1),2)) then pause,end
-  if or(a(p(ind),:)<>b) then pause,end
+13,14,15,15,12,14,11,11,15,15,15,15,16,17,14,14,17,17,15,15,13,13,17,17,18,18,19,19,16,..
+16,19,19,19,18,19]-5)';
+[b,ind] = gsort(a,'lr','i');
+t = b(2:$,:) < b(1:$-1,:);
+assert_checkfalse(or(t(:,1)));
+assert_checkfalse(or(t(b(2:$,1)==b(1:$-1,1),2)));
+assert_checkequal(a(ind,:),b);
+
+for k = 1:30
+    p = grand(1,'prm',(1:size(a,1))');
+    [b,ind] = gsort(a(p,:),'lr','i');
+    t = b(2:$,:) < b(1:$-1,:);
+    assert_checkfalse(or(t(:,1)));
+    assert_checkfalse(or(t(b(2:$,1)==b(1:$-1,1),2)));
+    assert_checkequal(a(p(ind),:),b);
 end
 
 [b,ind]=gsort(a,'lr','d');
-t=b(2:$,:)>b(1:$-1,:);
-if or(t(:,1)) then pause,end
-if or(t(b(2:$,1)==b(1:$-1,1),2)) then pause,end
-if or(a(ind,:)<>b) then pause,end
-
-
-for k=1:30
-  p=grand(1,'prm',(1:size(a,1))');
-  [b,ind]=gsort(a(p,:),'lr','d');
-  t=b(2:$,:)>b(1:$-1,:);
-  if or(t(:,1)) then pause,end
-  if or(t(b(2:$,1)==b(1:$-1,1),2)) then pause,end
-  if or(a(p(ind),:)<>b) then pause,end
+t=b(2:$,:) > b(1:$-1,:);
+assert_checkfalse(or(t(:,1)));
+assert_checkfalse(or(t(b(2:$,1)==b(1:$-1,1),2)));
+assert_checkequal(a(ind,:),b);
+
+for k = 1:30
+    p = grand(1,'prm',(1:size(a,1))');
+    [b,ind] = gsort(a(p,:),'lr','d');
+    t = b(2:$,:) > b(1:$-1,:);
+    assert_checkfalse(or(t(:,1)));
+    assert_checkfalse(or(t(b(2:$,1)==b(1:$-1,1),2)));
+    assert_checkequal(a(p(ind),:),b);
 end
 
-a=b;
-a([10 60],:)=a([60 10],:);
-[b,ind]=gsort(a,'lr','i');
-t=b(2:$,:)<b(1:$-1,:);
-if or(t(:,1)) then pause,end
-if or(t(b(2:$,1)==b(1:$-1,1),2)) then pause,end
-if or(a(ind,:)<>b) then pause,end
+a = b;
+a([10 60],:) = a([60 10],:);
+[b,ind] = gsort(a,'lr','i');
+t = b(2:$,:) < b(1:$-1,:);
+assert_checkfalse(or(t(:,1)));
+assert_checkfalse(or(t(b(2:$,1)==b(1:$-1,1),2)));
+assert_checkequal(a(ind,:),b);
 
-[b,ind]=gsort(a,'lr','d');
-t=b(2:$,:)>b(1:$-1,:);
-if or(t(:,1)) then pause,end
-if or(t(b(2:$,1)==b(1:$-1,1),2)) then pause,end
-if or(a(ind,:)<>b) then pause,end
+[b,ind] = gsort(a,'lr','d');
+t = b(2:$,:) > b(1:$-1,:);
+assert_checkfalse(or(t(:,1)));
+assert_checkfalse(or(t(b(2:$,1)==b(1:$-1,1),2)));
+assert_checkequal(a(ind,:),b);
 
 //testing gsort with Nan's
+b = gsort([1 2 %nan 3 4],'g','i');
+assert_checkequal(b(1:4), (1:4));
+assert_checkequal(find(isnan(b)), 5);
 
-b=gsort([1 2 %nan 3 4],'g','i');
-if or(b(1:4)<>(1:4)) then pause,end
-if find(isnan(b))<>5 then pause,end
-
-b=gsort([1 2 %nan 1 3 ],'g','i');
-if or(b(1:4)<>[1 1 2 3]) then pause,end
-if find(isnan(b))<>5 then pause,end
-
-b=gsort([1 2 %nan 1 3 ],'g','d');
-if or(b(2:$)<>[3 2 1 1]) then pause,end
-if find(isnan(b))<>1 then pause,end
-
-b=gsort([1 2 %nan 1 3 %nan 2 3],'g','d');
-if or(b(3:$)<>[3,3,2,2,1,1]) then pause,end
-if or(find(isnan(b))<>[1 2]) then pause,end
+b = gsort([1 2 %nan 1 3 ],'g','i');
+assert_checkequal(b(1:4), [1 1 2 3]);
+assert_checkequal(find(isnan(b)), 5);
 
-b=gsort([1 2 %nan 1 3 %nan 2 3],'g','i');
-if or(b(1:$-2)<>[1,1,2,2,3,3]) then pause,end
-if or(find(isnan(b))<>[7 8]) then pause,end
+b = gsort([1 2 %nan 1 3 ],'g','d');
+assert_checkequal(b(2:$), [3 2 1 1]);
+assert_checkequal(find(isnan(b)), 1);
 
-m=[1 2 %nan;1 3 %nan;1 2 3];
-b=gsort(m,'lr','i');
-if sci2exp(b,0)<>'[1,2,%nan;1,2,3;1,3,%nan]' then pause,end
+b = gsort([1 2 %nan 1 3 %nan 2 3],'g','d');
+assert_checkequal(b(3:$), [3,3,2,2,1,1]);
+assert_checkequal(find(isnan(b)), [1 2]);
 
-b=gsort(m,'lr','d');
-if sci2exp(b,0)<>'[1,3,%nan;1,2,%nan;1,2,3]' then pause,end
+b = gsort([1 2 %nan 1 3 %nan 2 3],'g','i');
+assert_checkequal(b(1:$-2), [1,1,2,2,3,3]);
+assert_checkequal(find(isnan(b)), [7 8]);
 
-m=m(:,[3 1 2]);
+m = [1 2 %nan;1 3 %nan;1 2 3];
+b = gsort(m,'lr','i');
+assert_checkequal(sci2exp(b,0), '[1,2,%nan;1,2,3;1,3,%nan]');
 
-b=gsort(m,'lc','i');
-if sci2exp(b,0)<>'[1,2,%nan;1,3,%nan;1,2,3]' then pause,end
+b = gsort(m,'lr','d');
+assert_checkequal(sci2exp(b,0), '[1,3,%nan;1,2,%nan;1,2,3]');
 
-b=gsort(m,'lc','d');
-if sci2exp(b,0)<>'[%nan,2,1;%nan,3,1;3,2,1]' then pause,end
+m = m(:,[3 1 2]);
+b = gsort(m,'lc','i');
+assert_checkequal(sci2exp(b,0), '[1,2,%nan;1,3,%nan;1,2,3]');
 
+b = gsort(m,'lc','d');
+assert_checkequal(sci2exp(b,0), '[%nan,2,1;%nan,3,1;3,2,1]');
 
 //testing gsort with Inf's
-
-b=gsort([1 2 %inf 3 4],'g','i');
-if or(b(1:4)<>(1:4)) then pause,end
-if find(isinf(b))<>5 then pause,end
+b = gsort([1 2 %inf 3 4],'g','i');
+assert_checkequal(b(1:4), (1:4));
+assert_checkequal(find(isinf(b)), 5);
 
 b=gsort([1 2 %inf 1 3 ],'g','i');
-if or(b(1:4)<>[1 1 2 3]) then pause,end
-if find(isinf(b))<>5 then pause,end
+assert_checkequal(b(1:4), [1 1 2 3]);
+assert_checkequal(find(isinf(b)), 5);
 
 b=gsort([1 2 %inf 1 3 ],'g','d');
-if or(b(2:$)<>[3 2 1 1]) then pause,end
-if find(isinf(b))<>1 then pause,end
+assert_checkequal(b(2:$), [3 2 1 1]);
+assert_checkequal(find(isinf(b)), 1);
 
 b=gsort([1 2 %inf 1 3 %inf 2 3],'g','d');
-if or(b(3:$)<>[3,3,2,2,1,1]) then pause,end
-if or(find(isinf(b))<>[1 2]) then pause,end
+assert_checkequal(b(3:$), [3,3,2,2,1,1]);
+assert_checkequal(find(isinf(b)), [1 2]);
 
 b=gsort([1 2 %inf 1 3 %inf 2 3],'g','i');
-if or(b(1:$-2)<>[1,1,2,2,3,3]) then pause,end
-if or(find(isinf(b))<>[7 8]) then pause,end
+assert_checkequal(b(1:$-2), [1,1,2,2,3,3]);
+assert_checkequal(find(isinf(b)), [7 8]);
 
+m = [1 2 %inf;1 3 %inf;1 2 3];
+b = gsort(m,'lr','i');
+assert_checkequal(sci2exp(b,0), '[1,2,3;1,2,%inf;1,3,%inf]');
 
-m=[1 2 %inf;1 3 %inf;1 2 3];
-b=gsort(m,'lr','i');
-if sci2exp(b,0)<>'[1,2,3;1,2,%inf;1,3,%inf]' then pause,end
+b = gsort(m,'lr','d');
+assert_checkequal(sci2exp(b,0), '[1,3,%inf;1,2,%inf;1,2,3]');
 
-b=gsort(m,'lr','d');
-if sci2exp(b,0)<>'[1,3,%inf;1,2,%inf;1,2,3]' then pause,end
+m = m(:,[3 1 2]);
+b = gsort(m,'lc','i');
+assert_checkequal(sci2exp(b,0), '[1,2,%inf;1,3,%inf;1,2,3]');
 
-m=m(:,[3 1 2]);
+b = gsort(m,'lc','d');
+assert_checkequal(sci2exp(b,0), '[%inf,2,1;%inf,3,1;3,2,1]');
 
-b=gsort(m,'lc','i');
-if sci2exp(b,0)<>'[1,2,%inf;1,3,%inf;1,2,3]' then pause,end
+//gsort
+a = [5 1 3 2 4];
+assert_checkequal(gsort(a), [5 4 3 2 1]);
+assert_checkequal(gsort(a + 0), [5 4 3 2 1]);
 
+[s,k] = gsort(a);
+assert_checkequal(k, [1 5 3 4 2]);
+assert_checkequal(s, [5 4 3 2 1]);
 
-b=gsort(m,'lc','d');
-if sci2exp(b,0)<>'[%inf,2,1;%inf,3,1;3,2,1]' then pause,end
+[s,k]=gsort(a+0);
+assert_checkequal(k, [1 5 3 4 2]);
+assert_checkequal(s, [5 4 3 2 1]);
 
-//gsort
-a=[5 1 3 2 4]
-if or(gsort(a)<>[5 4 3 2 1]) then pause,end
-if or(gsort(a+0)<>[5 4 3 2 1]) then pause,end
+a = string([5 1 3 2 4]);
+assert_checkequal(gsort(a,'g','i'), string(1:5));
+
+[s,k]=gsort(a,'g','i');
+assert_checkequal(k, [2 4 3 5 1]);
+assert_checkequal(s, string(1:5));
+
+a = [];
+assert_checkequal(gsort(a), []);
 [s,k]=gsort(a);
-if or(k<>[1 5 3 4 2]) then pause,end
-if or(s<>[5 4 3 2 1]) then pause,end
-[s,k]=gsort(a+0);
-if or(k<>[1 5 3 4 2]) then pause,end
-if or(s<>[5 4 3 2 1]) then pause,end
+assert_checkequal(s, []);
+assert_checkequal(k, []);
+
+// gsort with sparses (macro: %sp_gsort):
+b = [5 1 3 2 4;6 1 2 4 1];
+B = sparse(b);
+
+// opts = 'r' and direction = 'd' or 'i'
+[s,k] = gsort(b(:),'r','d');
+[s1,k1] = gsort(B(:),'r','d');
+assert_checkequal(full(s1),s);
+assert_checkequal(k1,k);
+
+[s,k] = gsort(b(:),'r','i');
+[s1,k1] = gsort(B(:),'r','i');
+assert_checkequal(full(s1),s);
+assert_checkequal(k1,k);
+
+[s,k] = gsort(b(:)','r','d');
+[s1,k1] = gsort(B(:)','r','d');
+assert_checkequal(full(s1),s);
+assert_checkequal(k1,k);
+
+[s,k] = gsort(b(:)','r','i');
+[s1,k1] = gsort(B(:)','r','i');
+assert_checkequal(full(s1),s);
+assert_checkequal(k1,k);
+
+// opts = 'c' and direction = 'd' or 'i'
+[s,k] = gsort(b(:),'c','d');
+[s1,k1] = gsort(B(:),'c','d');
+assert_checkequal(full(s1),s);
+assert_checkequal(k1,k);
+
+[s,k] = gsort(b(:),'c','i');
+[s1,k1] = gsort(B(:),'c','i');
+assert_checkequal(full(s1),s);
+assert_checkequal(k1,k);
+
+[s,k] = gsort(b(:)','c','d');
+[s1,k1] = gsort(B(:)','c','d');
+assert_checkequal(full(s1),s);
+assert_checkequal(k1,k);
+
+[s,k] = gsort(b(:)','c','i');
+[s1,k1] = gsort(B(:)','c','i');
+assert_checkequal(full(s1),s);
+assert_checkequal(k1,k);
+
+// opts = 'g' and direction = 'd' or 'i'
+[s,k] = gsort(b(:),'g','d');
+[s1,k1] = gsort(B(:),'g','d');
+assert_checkequal(full(s1),s);
+assert_checkequal(k1,k);
+
+[s,k] = gsort(b(:),'g','i');
+[s1,k1] = gsort(B(:),'g','i');
+assert_checkequal(full(s1),s);
+assert_checkequal(k1,k);
+
+[s,k] = gsort(b(:)','g','d');
+[s1,k1] = gsort(B(:)','g','d');
+assert_checkequal(full(s1),s);
+assert_checkequal(k1,k);
+
+[s,k] = gsort(b(:)','g','i');
+[s1,k1] = gsort(B(:)','g','i');
+assert_checkequal(full(s1),s);
+assert_checkequal(k1,k);
+
+// opts = 'lr' and direction = 'd' or 'i'
+[s,k] = gsort(b(:),'lr','d');
+[s1,k1] = gsort(B(:),'lr','d');
+assert_checkequal(full(s1),s);
+assert_checkequal(k1,k);
+
+[s,k] = gsort(b(:),'lr','i');
+[s1,k1] = gsort(B(:),'lr','i');
+assert_checkequal(full(s1),s);
+assert_checkequal(k1,k);
+
+[s,k] = gsort(b(:)','lr','d');
+[s1,k1] = gsort(B(:)','lr','d');
+assert_checkequal(full(s1),s);
+assert_checkequal(k1,k);
+
+[s,k] = gsort(b(:)','lr','i');
+[s1,k1] = gsort(B(:)','lr','i');
+assert_checkequal(full(s1),s);
+assert_checkequal(k1,k);
+
+// opts = 'lc' and direction = 'd' or 'i'
+[s,k] = gsort(b(:),'lc','d');
+[s1,k1] = gsort(B(:),'lc','d');
+assert_checkequal(full(s1),s);
+assert_checkequal(k1,k);
+
+[s,k] = gsort(b(:),'lc','i');
+[s1,k1] = gsort(B(:),'lc','i');
+assert_checkequal(full(s1),s);
+assert_checkequal(k1,k);
+
+[s,k] = gsort(b(:)','lc','d');
+[s1,k1] = gsort(B(:)','lc','d');
+assert_checkequal(full(s1),s);
+assert_checkequal(k1,k);
+
+[s,k] = gsort(b(:)','lc','i');
+[s1,k1] = gsort(B(:)','lc','i');
+assert_checkequal(full(s1),s);
+assert_checkequal(k1,k);
+
+
+// gsort with complex sparses :
+A = [1 -%i;%i 0];
+A1 = sparse(A);
+
+c = gsort(A(:),'g','d');
+d = full(gsort(A1(:),'g','d'));
+assert_checkequal(c,d);
+
+c = gsort(A(:),'g','i');
+d = full(gsort(A1(:),'g','i'));
+assert_checkequal(c,d);
+
+c = gsort(A(:),'r','d');
+d = full(gsort(A1(:),'r','d'));
+assert_checkequal(c,d);
+
+c = gsort(A(:),'r','i');
+d = full(gsort(A1(:),'r','i'));
+assert_checkequal(c,d);
+
+c = gsort(A(:),'c','d');
+d = full(gsort(A1(:),'c','d'));
+assert_checkequal(c,d);
+
+c = gsort(A(:),'c','i');
+d = full(gsort(A1(:),'c','i'));
+assert_checkequal(c,d);
+
+B = [1 1+%i 4; -2*%i 3 3-%i];
+B1 = sparse(B);
+
+c = gsort(B(:),'g','d');
+d = full(gsort(B1(:),'g','d'));
+assert_checkequal(c,d);
+
+c = gsort(B(:),'g','i');
+d = full(gsort(B1(:),'g','i'));
+assert_checkequal(c,d);
+
+c = gsort(B(:),'r','d');
+d = full(gsort(B1(:),'r','d'));
+assert_checkequal(c,d);
+
+c = gsort(B(:),'r','i');
+d = full(gsort(B1(:),'r','i'));
+assert_checkequal(c,d);
+
+c = gsort(B(:),'c','d');
+d = full(gsort(B1(:),'c','d'));
+assert_checkequal(c,d);
+
+c = gsort(B(:),'c','i');
+d = full(gsort(B1(:),'c','i'));
+assert_checkequal(c,d);
+
+C = [-%i 3*%i;4 9;-2*%i 7];
+C1 = sparse(C);
+
+[s,k] = gsort(C(:),'g','d');
+[s1,k1] = gsort(C1(:),'g','d');
+assert_checkequal(full(s1),s);
+assert_checkequal(k1,k);
+
+[s,k] = gsort(C(:),'g','i');
+[s1,k1] = gsort(C1(:),'g','i');
+assert_checkequal(full(s1),s);
+assert_checkequal(k1,k);
+
+[s,k] = gsort(C(:),'r','d');
+[s1,k1] = gsort(C1(:),'r','d');
+assert_checkequal(full(s1),s);
+assert_checkequal(k1,k);
+
+[s,k] = gsort(C(:),'r','i');
+[s1,k1] = gsort(C1(:),'r','i');
+assert_checkequal(full(s1),s);
+assert_checkequal(k1,k);
 
-a=string([5 1 3 2 4])
+[s,k] = gsort(C(:),'c','d');
+[s1,k1] = gsort(C1(:),'c','d');
+assert_checkequal(full(s1),s);
+assert_checkequal(k1,k);
 
-if or(gsort(string([5 1 3 2 4]),'g','i')<>string(1:5)) then pause,end
-//[s,k]=gsort(a);
-[s,k]=gsort(string([5 1 3 2 4]),'g','i');
-if or(k<>[2 4 3 5 1]) then pause,end
-if or(s<>string(1:5)) then pause,end
+[s,k] = gsort(C(:),'c','i');
+[s1,k1] = gsort(C1(:),'c','i');
+assert_checkequal(full(s1),s);
+assert_checkequal(k1,k);
 
-a=[]
-if gsort(a)<>[] then pause,end
-[s,k]=gsort(a);if s<>[]|k<>[] then pause,end
 
-if gsort([])<>[] then pause,end
-[s,k]=gsort([]);if s<>[]|k<>[] then pause,end