scilab/modules/elementary_functions/tests/unit_tests/gsort_sparse.tst

   1 // ===================================================================
   2 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
   3 // Copyright (C) ????-2008 - INRIA
   4 // Copyright (C) ????-2008 - ENPC
   5 // Copyright (C) 2008 - DIGITEO - Allan CORNET
   6 // Copyright (C) 2012 - Scilab Enterprises - Adeline CARNIS
   7 // Copyright (C) 2018 - 2020 - Samuel GOUGEON
   8 //
   9 //  This file is distributed under the same license as the Scilab package.
  10 // ===================================================================
  11 //
  12 // Included gsort() tests:
  13 //  * sparse reals (all sizes)
  14 //  * sparse complex (all sizes), including multi-level sorting
  15 //  * sparse boolean
  16 //
  17 // <-- CLI SHELL MODE -->
  18 // <-- NO CHECK REF -->
  19
  20 // ========================= sparse reals ============================
  21
  22 b = [5 1 3 2 4 ; 6 1 2 4 1];
  23 c = full(sprand(10,8,0.1));
  24 objects = list(b(:)', b(:), b, c(:)', c(:), c);
  25 for method = ["g" "lr" "lc" "r" "c" ] //
  26     mprintf("\n%s : ", method);
  27     for o = objects
  28         O = sparse(o);
  29         for order = ["i" "d"]
  30             mprintf("%s ",order)
  31             [s,k] = gsort(o, method, order);
  32             [S,K] = gsort(O, method, order);
  33             assert_checktrue(issparse(S));
  34             assert_checkequal(full(S), s);
  35             assert_checkequal(K, k);
  36         end
  37     end
  38 end
  39
  40 // Uniform row, column or matrix of zeros or of ones
  41 objects = list(spzeros(1,10), spzeros(10,1), spzeros(6,8))
  42 for a = [0 1]
  43     for o = objects
  44         sz = size(o);
  45         z = o + a;
  46         [s, k]= gsort(z, "g");
  47         assert_checkequal(s, z);
  48         assert_checkequal(k, matrix(1:prod(sz),sz(1),-1));
  49         [s, k]= gsort(z, "r");
  50         assert_checkequal(k, (1:sz(1))'*ones(1,sz(2)));
  51         [s, k]= gsort(z, "c");
  52         assert_checkequal(k, ones(sz(1),1)*(1:sz(2)));
  53         [s, k]= gsort(z, "lr");
  54         assert_checkequal(k, (1:sz(1))');
  55         [s, k]= gsort(z, "lc");
  56         assert_checkequal(k, 1:sz(2));
  57     end
  58 end
  59
  60 // ========================== sparse complex =========================
  61
  62 // Sparse column of complex numbers (< 2018)
  63 // -----------------------------------------
  64 A = [1 -%i;%i 0];
  65 A1 = sparse(A);
  66 B = [1 1+%i 4; -2*%i 3 3-%i];
  67 B1 = sparse(B);
  68 C = [-%i 3*%i;4 9;-2*%i 7];
  69 C1 = sparse(C);
  70 mprintf("\nSparse real:\n");
  71 for order = ["i" "d"]
  72     for method = ["g" "r" "c" "lr" "lc"]
  73         c = gsort(A(:), method, order);
  74         d = full(gsort(A1(:), method, order));
  75         assert_checkequal(c, d);
  76
  77         c = gsort(B(:), method, order);
  78         d = full(gsort(B1(:), method, order));
  79         assert_checkequal(c, d);
  80
  81         [s,k] = gsort(C(:), method, order);
  82         [s1,k1] = gsort(C1(:), method, order);
  83         assert_checkequal(full(s1), s);
  84         assert_checkequal(k1, k);
  85     end
  86 end
  87
  88 // Sparse matrix of complex numbers
  89 // --------------------------------
  90 c0 = sprand(50,10,0.2) + imult(sprand(50,10,0.2));
  91 objects = list(c0(:).', c0(:), c0);
  92 Crit = list(list(abs, atan), list(real, imag));
  93 Orders = ["i" "i" ; "i" "d"];
  94 mprintf("\nSparse complex:\n");
  95 for method = ["g" "r" "c" "lr" "lc"]
  96     mprintf("\n%s : ", method);
  97     for O = objects
  98         for j = 1:2
  99             order = Orders(j,:);
 100             crit = Crit(j);
 101             mprintf("%s ", strcat(order));
 102             S = gsort(O, method, order, crit);
 103             s = gsort(full(O), method, order, crit);
 104             assert_checktrue(issparse(S));
 105             assert_checkequal(s, full(S));
 106
 107             [S, K] = gsort(O, method, order, crit);
 108             [s, k] = gsort(full(O), method, order, crit);
 109             assert_checktrue(issparse(S));
 110             assert_checkequal(K, k);
 111             assert_checkequal(s, full(S));
 112         end
 113     end
 114 end
 115
 116 // ========================= sparse boolean =========================
 117
 118 b = sprand(10,500,0.1) > 0;
 119 objects = list(b(:)', b(:), b);
 120 mprintf("\nSparse booleans:\n");
 121 for method = ["g" "r" "c" "lr" "lc"]
 122     mprintf("\n%s : ", method);
 123     for O = objects
 124         for order = ["i" "d"]
 125             mprintf("%s ", order);
 126             [S, K] = gsort(O, method, order);
 127             [s, k] = gsort(full(O), method, order);
 128             assert_checktrue(issparse(S));
 129             assert_checkequal(K, k);
 130             assert_checkequal(full(S), s);
 131
 132             S = gsort(O, method, order);
 133             assert_checktrue(issparse(S));
 134             assert_checkequal(full(S), s);
 135         end
 136     end
 137 end
 138