share/descriptive/rtest_descriptive.mac

   1 (kill(all), 0);
   2 0$
   3
   4 (load(descriptive), float_approx_equal_tolerance : 1e-12, 0);
   5 0$
   6
   7 mean([a, b, c]);
   8 (c+b+a)/3$
   9
  10 /* error: negative weight */
  11 errcatch (mean ([a, b, c], [-1/2, 1/2, 1]));
  12 [];
  13
  14 /* error: weights list not same length as data */
  15 errcatch (mean ([a, b, c], [0.5, 0.5]));
  16 [];
  17
  18 /* error: sum of weights is 0 */
  19 errcatch (mean ([a, b, c], [0, 0, 0]));
  20 [];
  21
  22 /* error: weight must be 1, if not a list */
  23 errcatch (mean ([a, b, c], 2));
  24 [];
  25
  26 mean([a, b, c], 1);
  27 (c+b+a)/3$
  28
  29 mean([a, b, c], [1, 1, 1]);
  30 (c+b+a)/3$
  31
  32 mean([a, b, c], [1, 1, 1]/3);
  33 (c+b+a)/3$
  34
  35 mean([a, b, c], [3, 2, 1]);
  36 (c+2*b+3*a)/6$
  37
  38 mean([a, b, c], [3, 2, 1]/6);
  39 (c+2*b+3*a)/6$
  40
  41 mean(matrix([a, b], [c, d], [e, f]));
  42 [(e+c+a)/3,(f+d+b)/3]$
  43
  44 mean(matrix([a, b], [c, d], [e, f]), 1);
  45 [(e+c+a)/3,(f+d+b)/3]$
  46
  47 mean(matrix([a, b], [c, d], [e, f]), [1, 1, 1]);
  48 [(e+c+a)/3,(f+d+b)/3]$
  49
  50 mean(matrix([a, b], [c, d], [e, f]), [2, 3, 5]);
  51 [(5*e+3*c+2*a)/10,(5*f+3*d+2*b)/10]$
  52
  53 mean(matrix([a, b], [-11, 13], [c, d], [-29, 43], [123, -456], [e, f]), [2, 0, 3, 0, 0, 5]);
  54 [(5*e+3*c+2*a)/10,(5*f+3*d+2*b)/10]$
  55
  56 noncentral_moment ([a, b, c, d, e, f], 1, [2, 3, 5, 7, 11, 13]);
  57 (13*f + 11*e + 7*d + 5*c + 3*b + 2*a)/41;
  58
  59 noncentral_moment ([a, b, c, d, e, f], 2, [2, 3, 5, 7, 11, 13]);
  60 (13*f^2 + 11*e^2 + 7*d^2 + 5*c^2 + 3*b^2 + 2*a^2)/41;
  61
  62 mean ([a - 3, a - 2, a - 1, a, a + 1, a + 2, a + 3], [2, 3, 5, 7, 5, 3, 2]);
  63 a;
  64
  65 central_moment ([a - 3, a - 2, a - 1, a, a + 1, a + 2, a + 3], 1, [2, 3, 5, 7, 5, 3, 2]);
  66 0;
  67
  68 central_moment ([a - 3, a - 2, a - 1, a, a + 1, a + 2, a + 3], 2, [2, 3, 5, 7, 5, 3, 2]);
  69 ''((2*3^2 + 3*2^2 + 5*1^2 + 7*0^2 + 5*1^2 + 3*2^2 + 2*3^2)/(2 + 3 + 5 + 7 + 5 + 3 + 2));
  70
  71 central_moment ([a - 3, a - 2, a - 1, a, a + 1, a + 2, a + 3], 3, [2, 3, 5, 7, 5, 3, 2]);
  72 0;
  73
  74 central_moment ([a, b, c], 0, [d, e, f]);
  75 1;
  76
  77 central_moment ([a, b, c], 1, [d, e, f]);
  78 0;
  79
  80 central_moment ([a, b, c], 2, [d, e, f]);
  81 ''(block ([mm: (d*a + e*b + f*c)/(d + e + f)], ratsimp ((d*(a - mm)^2 + e*(b - mm)^2 + f*(c - mm)^2)/(d + e + f))));
  82
  83 (s1 : read_list(file_search ("pidigits.data")), mean(s1));
  84 471/100$
  85
  86 (s2 : read_matrix(file_search ("wind.data")), mean(s2));
  87 [9.9485,10.1607,10.8685,15.7166,14.8441]$
  88
  89 var(s1);
  90 84259/10000$
  91
  92 var1(s1);
  93 84259/9900$
  94
  95 var1(s2);
  96 [17.39586540404041,15.13912778787879,15.63204924242424,
  97        32.50152569696971,24.66977392929294]$
  98
  99 std(s1);
 100 sqrt(84259)/100$
 101
 102 std(s2);
 103 [4.149928523480858,3.871399812729241,3.933920277534866,
 104        5.672434260526957,4.941970881136392]$
 105
 106 std1(s1);
 107 sqrt(84259)/(30*sqrt(11))$
 108
 109 std1(s2);
 110 [4.17083509672109,3.89090320978032,3.953738641137555,5.701010936401517,
 111         4.966867617451963]$
 112
 113 noncentral_moment(s1, 1);
 114 471/100$
 115
 116 noncentral_moment(s2, 1);
 117 [9.9485,10.1607,10.8685,15.7166,14.8441]$
 118
 119 central_moment(s1, 2);
 120 84259/10000$
 121
 122 central_moment(s2, 3);
 123 [11.29584771375004,16.97988248298583,5.626661952750102,
 124         37.5986572057918,25.85981904394192]$
 125
 126 cv(s1);
 127 sqrt(84259)/471$
 128
 129 cv(s2);
 130 [0.4171411291632767,0.3810170374806106,0.3619561372346568,
 131         0.3609199356430116,0.3329249251309538]$
 132
 133 smin(s1);
 134 0$
 135
 136 smin(s2);
 137 [0.58,0.5,2.67,5.25,5.17]$
 138
 139 smax(s1);
 140 9$
 141
 142 smax(s2);
 143 [20.25,21.46,20.04,29.63,27.63]$
 144
 145 range(s1);
 146 9$
 147
 148 range(s2);
 149 [19.67,20.96,17.37,24.38,22.46]$
 150
 151 [quantile(s1, 1/4), quantile (s1, 3/4)];
 152 [2,29/4]$
 153
 154 [quantile(s2, 1/4), quantile (s2, 3/4)];
 155 [[7.2575,7.477500000000001,7.82,11.28,11.48],
 156         [12.6425,13.05,13.8425,20.01,18.13]]$
 157
 158 median(s1);
 159 9/2$
 160
 161 median(s2);
 162 [10.06,9.855,10.73,15.48,14.105]$
 163
 164 qrange(s1);
 165 21/4$
 166
 167 qrange(s2);
 168 [5.385,5.572499999999998,6.0225,8.729999999999999,6.649999999999999]$
 169
 170 mean_deviation(s1);
 171 51/20$
 172
 173 mean_deviation(s2);
 174 [3.287959999999999,3.075342,3.23907,4.715664000000001,4.028546000000002]$
 175
 176 median_deviation(s1);
 177 5/2$
 178
 179 median_deviation(s2);
 180 [2.75,2.755,3.08,4.315,3.31]$
 181
 182 harmonic_mean([5, 7, 2, 5, 9, 5, 6, 4, 9, 2, 4, 2, 5]);
 183 8190/2099$
 184
 185 harmonic_mean(s2);
 186 [6.948015590052786,7.391967752360356,9.055658197151745,
 187         13.44199028193692,13.01439145898509]$
 188
 189 geometric_mean([5, 7, 2, 5, 9, 5, 6, 4, 9, 2, 4, 2, 5]);
 190 272160000^(1/13)$
 191
 192 geometric_mean(s2);
 193 [8.82476274347979,9.22652604739361,10.0442675714889,14.61274126349021,
 194         13.96184163444275]$
 195
 196 kurtosis(s1);
 197 -9039524486/7099579081$
 198
 199 kurtosis(s2);
 200 [-0.2715445622195385,0.119998784429451,-0.4275233490482866,
 201         -0.6405361979019522,-0.4952382132352935]$
 202
 203 skewness(s1);
 204 224922/84259^(3/2)$
 205
 206 skewness(s2);
 207 [0.1580509020000979,0.2926379232061854,0.09242174416107717,
 208         0.2059984348148687,0.2142520248890832]$
 209
 210 pearson_skewness(s1);
 211 189*sqrt(11)/(10*sqrt(84259))$
 212
 213 pearson_skewness(s2);
 214 [-0.08019976629211892,0.2357036272952649,0.1050904062491204,
 215        0.1245042340592368,0.4464181795804519]$
 216
 217 quartile_skewness(s1);
 218 1/21$
 219
 220 quartile_skewness(s2);
 221 [-0.0408542246982353,0.1467025572005382,0.0336239103362392,
 222        0.03780068728522298,0.2105263157894735]$
 223
 224 foo: cov(s2);
 225 matrix([17.22190675000003,13.61811305000002,14.37216775000002,
 226         19.39623590000002,15.42162414999993],
 227        [13.61811305000002,14.98773650999988,13.30448104999995,
 228         15.15833837999995,14.97109813],
 229        [14.37216775000002,13.30448104999995,15.47572875000003,
 230         17.32543690000006,16.18170714999994],
 231        [19.39623590000002,15.15833837999995,17.32543690000006,
 232         32.17651043999993,20.44684694],
 233        [15.42162414999993,14.97109813,16.18170714999994,20.44684694,
 234         24.42307619000002])$
 235
 236 cov (s2, 1);
 237 ''foo;
 238
 239 cov (s2, makelist (1, length (s2)));
 240 ''foo;
 241
 242 cov (s2, makelist (1/length (s2), length (s2)));
 243 ''foo;
 244
 245 (baz: apply (matrix, makelist ([i, i^2, i^3], i, 1, 10)),
 246  ww: makelist (i, i, 1, 10),
 247  baz1: apply (matrix, apply (append, makelist (makelist (baz[i], ww[i]), i, 1, 10))),
 248  quux: cov (baz1));
 249 ''(transpose (baz1) . baz1 / length (baz1) - transpose (mean (baz1)) . mean (baz1));
 250
 251 cov (baz, ww);
 252 ''quux;
 253
 254 cov (baz, ww / lsum (w, w, ww));
 255 ''quux;
 256
 257 cov1(s2);
 258 matrix([17.39586540404044,13.75566974747477,14.51734116161618,
 259               19.5921574747475,15.57739813131306],
 260              [13.75566974747477,15.13912778787867,13.4388697474747,
 261               15.31145290909086,15.12232134343435],
 262              [14.51734116161618,13.4388697474747,15.63204924242427,
 263               17.50044131313137,16.34515873737368],
 264              [19.5921574747475,15.31145290909086,17.50044131313137,
 265               32.50152569696963,20.65338074747475],
 266              [15.57739813131306,15.12232134343435,16.34515873737368,
 267               20.65338074747475,24.66977392929295])$
 268
 269 global_variances(s2);
 270 [105.338342060606,21.06766841212119,12874.34690469686,113.4651792608501,
 271        6.636590811800794,2.576158149609762]$
 272
 273 cor(s2);
 274 matrix([0.9999999999999999,0.8476338537640531,0.8803514956141143,
 275                0.8239623533344873,0.7519506093997077],
 276               [0.8476338537640531,1.0,0.8735833741501071,0.6902622161735914,
 277                0.7825019890410442],
 278               [0.8803514956141142,0.8735833741501071,1.0,0.7764065117828751,
 279                0.8323358495832834],
 280               [0.8239623533344873,0.6902622161735915,0.7764065117828751,1.0,
 281                0.7293847728156051],
 282               [0.7519506093997078,0.7825019890410442,0.8323358495832834,
 283                0.7293847728156051,0.9999999999999999])$
 284
 285 list_correlations(s2);
 286  [matrix([0.3848556822758882,-0.138560101587963,-0.1562648597903809,
 287                 -0.102390587242044,0.03117928520552016],
 288                [-0.1385601015879629,0.3410745439686317,-0.1523316288476424,
 289                 0.03844715039676187,-0.05284247734522295],
 290                [-0.1562648597903812,-0.1523316288476423,0.4729580534793429,
 291                 -0.02481583049369053,-0.1005374388312373],
 292                [-0.1023905872420438,0.0384471503967619,-0.02481583049369072,
 293                 0.1093657733582761,-0.0340329624571618],
 294                [0.0311792852055202,-0.05284247734522302,-0.1005374388312372,
 295                 -0.03403296245716185,0.1483436744385358]),
 296         [0.8506325186059345,0.8063355806655949,0.8647424674282196,
 297          0.7186707921004887,0.7267464592542312],
 298         matrix([-1.0,0.3824411257726334,0.3662697588649121,0.4990802317419231,
 299                 -0.1304916392931289],
 300                [0.3824411257726332,-1.0,0.3792749151468401,
 301                 -0.1990667787299206,0.2349221680600234],
 302                [0.3662697588649129,0.3792749151468399,-0.9999999999999998,
 303                 0.109113073041974,0.3795613554674849],
 304                [0.4990802317419226,-0.1990667787299208,0.1091130730419749,
 305                 -1.0,0.267192660519117],
 306                [-0.1304916392931291,0.2349221680600237,0.3795613554674845,
 307                 0.2671926605191174,-1.0])]$
 308
 309 principal_components(s2);
 310 [[87.5689103150044,8.753405888856824,5.514842042315632,
 311          1.888527946359889,1.612655868069173],
 312         [83.13108845459334,8.30980032305862,5.235360586122282,
 313          1.792821027383679,1.530929608842086],
 314         matrix([0.4149313791478684,0.03378709673974772,-0.4756919435090896,
 315                 -0.5810494628723252,-0.5126295731507049],
 316                [0.3690402507783501,-0.3656690416147942,-0.4297594804400433,
 317                 0.7237468707135304,-0.1469445521761402],
 318                [0.3959227853488706,-0.2178353948197818,-0.2181101723256928,
 319                 -0.2749400278061583,0.820139514133606],
 320                [0.554792311834466,0.7744297760037389,0.1857057299675782,
 321                 0.231851193538861,0.06498014065837293],
 322                [0.4765415854622357,-0.4668520610438869,0.7120149566109651,
 323                 -0.09604683228877862,-0.1968933162750588])]$
 324
 325 /*               DATA MANIPULATION                 */
 326
 327 continuous_freq ([]);
 328 [[minf, inf], [0]];
 329
 330 continuous_freq (s1, 5);
 331 [[0,9/5,18/5,27/5,36/5,9],[16,24,18,17,25]]$
 332
 333 continuous_freq (s1, [-2,12,7]);
 334 [[-2,0,2,4,6,8,10,12],[8,20,22,17,20,13,0]]$
 335
 336 continuous_freq (s1, [-2,12]);
 337 [[-2,-3/5,4/5,11/5,18/5,5,32/5,39/5,46/5,53/5,12],[0,8,20,12,18,9,8,25,
 338                                                           0,0]]$
 339
 340 continuous_freq (random_permutation (makelist (i, i, 0, 100)), 1);
 341 [[0, 100], [101]];
 342
 343 continuous_freq (random_permutation (makelist (i, i, 0, 100)), 10);
 344 [[0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100], [11, 10, 10, 10, 10,  10, 10, 10, 10, 10]];
 345
 346 continuous_freq (makelist (random (100), 100), [0, 100, 1]);
 347 [[0, 100], [100]];
 348
 349 continuous_freq (random_permutation (makelist (i, i, 0, 100)), [0, 100, 10]);
 350 [[0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100], [11, 10, 10, 10, 10,  10, 10, 10, 10, 10]];
 351
 352 continuous_freq (makelist (random (100), 100), {0, 100});
 353 [[0, 100], [100]];
 354
 355 continuous_freq (random_permutation (makelist (i, i, 0, 100)), {0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100});
 356 [[0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100], [11, 10, 10, 10, 10,  10, 10, 10, 10, 10]];
 357
 358 (test_continuous_freq (xx, foo) := block ([output, bins, counts],
 359   output : continuous_freq (xx, foo),
 360   bins : makelist ([output[1][i], output[1][i + 1]], i, 1, length(output[1]) - 1),
 361   counts : count_via_sublist (if listp(xx) then xx else listarray(xx), bins),
 362   if counts = output[2]
 363     then true
 364     else ['data = xx, 'continuous_freq = output, 'count_via_sublist = counts]),
 365  count_via_sublist (xx, bins) :=
 366    append ([length (sublist (xx, lambda ([x], first(bins)[1] <= x and x <= first(bins)[2])))],
 367            map (lambda ([pq], length (sublist (xx, lambda ([x], pq[1] < x and x <= pq[2])))), rest(bins))),
 368  set_random_state (make_random_state (1)),
 369  0);
 370 0;
 371
 372 test_continuous_freq (makelist (random (100), 100) * 0.25, 17);
 373 true;
 374
 375 test_continuous_freq (makelist (random (100), 100) * 0.25, 100);
 376 true;
 377
 378 test_continuous_freq (makelist (random (100), 100) * 0.25, 1);
 379 true;
 380
 381 test_continuous_freq (makelist (random (100), 100) * 0.25, [0, 25]);
 382 true;
 383
 384 test_continuous_freq (makelist (random (100), 100) * 0.25, [0, 25, 2]);
 385 true;
 386
 387 test_continuous_freq (makelist (random (100), 100) * 0.25, [0, 25, 20]);
 388 true;
 389
 390 test_continuous_freq (makelist (random (100), 100) * 0.25, [-1000, 1000]);
 391 true;
 392
 393 test_continuous_freq (makelist (random (100), 100) * 0.25, [-990, 1010]);
 394 true;
 395
 396 test_continuous_freq (makelist (random (10), 100), 10);
 397 true;
 398
 399 test_continuous_freq (append (makelist (random (10), 50), 50 + makelist (random (10), 50)), 10);
 400 true;
 401
 402 (to_array(l) := fillarray (make_array (any, length(l)), l),
 403  prefix ("to_array"),
 404  0);
 405 0;
 406
 407 continuous_freq (to_array []);
 408 [[minf, inf], [0]];
 409
 410 continuous_freq (to_array s1, 5);
 411 [[0,9/5,18/5,27/5,36/5,9],[16,24,18,17,25]]$
 412
 413 continuous_freq (to_array s1, [-2,12,7]);
 414 [[-2,0,2,4,6,8,10,12],[8,20,22,17,20,13,0]]$
 415
 416 continuous_freq (to_array s1, [-2,12]);
 417 [[-2,-3/5,4/5,11/5,18/5,5,32/5,39/5,46/5,53/5,12],[0,8,20,12,18,9,8,25,
 418                                                           0,0]]$
 419
 420 test_continuous_freq (to_array (makelist (random (100), 100) * 0.25), 17);
 421 true;
 422
 423 test_continuous_freq (to_array (makelist (random (100), 100) * 0.25), 100);
 424 true;
 425
 426 test_continuous_freq (to_array (makelist (random (100), 100) * 0.25), 1);
 427 true;
 428
 429 test_continuous_freq (to_array (makelist (random (100), 100) * 0.25), [0, 25]);
 430 true;
 431
 432 test_continuous_freq (to_array (makelist (random (100), 100) * 0.25), [0, 25, 2]);
 433 true;
 434
 435 test_continuous_freq (to_array (makelist (random (100), 100) * 0.25), [0, 25, 20]);
 436 true;
 437
 438 test_continuous_freq (to_array (makelist (random (100), 100) * 0.25), [-1000, 1000]);
 439 true;
 440
 441 test_continuous_freq (to_array (makelist (random (100), 100) * 0.25), [-990, 1010]);
 442 true;
 443
 444 test_continuous_freq (to_array makelist (random (10), 100), 10);
 445 true;
 446
 447 test_continuous_freq (to_array append (makelist (random (10), 50), 50 + makelist (random (10), 50)), 10);
 448 true;
 449
 450 /* SF bug #3685: "continuous_freq causes Lisp error given rational numbers" */
 451
 452 continuous_freq (random_permutation ([0, 1/2, 1/2, 1/2, 2/3, 2/3, 3/4, 3/4, 3/4, 3/4, 1, 1, 4]), [0, 5, 10]);
 453 [[0, 1/2, 1, 3/2, 2, 5/2, 3, 7/2, 4, 9/2, 5], [4, 8, 0, 0, 0, 0, 0, 1, 0, 0]];
 454
 455 continuous_freq (random_permutation (bfloat ([0, 1/2, 1/2, 1/2, 2/3, 2/3, 3/4, 3/4, 3/4, 3/4, 1, 1, 4])), [0b0, 5b0, 10]);
 456 [[0b0, 0.5b0, 1b0, 1.5b0, 2b0, 2.5b0, 3b0, 3.5b0, 4b0, 4.5b0, 5b0], [4, 8, 0, 0, 0, 0, 0, 1, 0, 0]];
 457
 458 /* additional tests for #3685; verify that continuous_freq continues to work as long as elements are comparable. */
 459
 460 continuous_freq (%pi + random_permutation ([0, 1/2, 1/2, 1/2, 2/3, 2/3, 3/4, 3/4, 3/4, 3/4, 1, 1, 4]), [%pi, %pi + 5, 10]);
 461 [[%pi, %pi + 1/2, %pi + 1, %pi + 3/2, %pi + 2, %pi + 5/2, %pi + 3, %pi + 7/2, %pi + 4, %pi + 9/2, %pi + 5],
 462  [4, 8, 0, 0, 0, 0, 0, 1, 0, 0]];
 463
 464 (kill(a), continuous_freq (a + random_permutation ([0, 1/2, 1/2, 1/2, 2/3, 2/3, 3/4, 3/4, 3/4, 3/4, 1, 1, 4]), [a, a + 5, 10]));
 465 [[a, a + 1/2, a + 1, a + 3/2, a + 2, a + 5/2, a + 3, a + 7/2, a + 4, a + 9/2, a + 5], [4, 8, 0, 0, 0, 0, 0, 1, 0, 0]];
 466
 467 (assume (a > 0), continuous_freq (a * random_permutation ([0, 1/2, 1/2, 1/2, 2/3, 2/3, 3/4, 3/4, 3/4, 3/4, 1, 1, 4]), 8));
 468 [[0, a/2, a, 3*a/2, 2*a, 5*a/2, 3*a, 7*a/2, 4*a], [4, 8, 0, 0, 0, 0, 0, 1]];
 469
 470 forget (a > 0);
 471 [a > 0];
 472
 473 discrete_freq ([]);
 474 [[], []];
 475
 476 discrete_freq (s1);
 477 [[0,1,2,3,4,5,6,7,8,9],[8,8,12,12,10,8,9,8,12,13]]$
 478
 479 discrete_freq (map (lambda ([x], printf (false, "~r", x)), s1));
 480 [["eight", "five", "four", "nine", "one", "seven", "six", "three", "two", "zero"],
 481  [12, 8, 10, 13, 8, 8, 9, 12, 12, 8]];
 482
 483 discrete_freq (map (lambda ([x], concat ('x, printf (false, "~r", x))), s1));
 484 ['[xeight, xfive, xfour, xnine, xone, xseven, xsix, xthree, xtwo, xzero],
 485  [12, 8, 10, 13, 8, 8, 9, 12, 12, 8]];
 486
 487 (test_discrete_freq (xx) := block ([output, counts],
 488   output : discrete_freq (xx),
 489   counts : count_via_sublist (if listp(xx) then xx else listarray(xx)),
 490   if counts = output[2]
 491     then true
 492     else ['data = xx, 'discrete_freq = output, 'count_via_sublist = counts]),
 493  count_via_sublist (xx) :=
 494    map (lambda ([x1], length (sublist (xx, lambda ([x], x = x1)))), unique (xx)),
 495  set_random_state (make_random_state (2)),
 496  0);
 497 0;
 498
 499 test_discrete_freq (makelist (random (20), 1));
 500 true;
 501
 502 test_discrete_freq (makelist (random (20), 10));
 503 true;
 504
 505 test_discrete_freq (makelist (random (20), 100));
 506 true;
 507
 508 test_discrete_freq (makelist (random (20), 1000));
 509 true;
 510
 511 test_discrete_freq (makelist (random (100), 100) * 0.25);
 512 true;
 513
 514 test_discrete_freq (append (makelist (random (20), 50), 50 + makelist (random (20), 50)));
 515 true;
 516
 517 discrete_freq (to_array []);
 518 [[], []];
 519
 520 discrete_freq (to_array s1);
 521 [[0,1,2,3,4,5,6,7,8,9],[8,8,12,12,10,8,9,8,12,13]]$
 522
 523 discrete_freq (to_array map (lambda ([x], printf (false, "~r", x)), s1));
 524 [["eight", "five", "four", "nine", "one", "seven", "six", "three", "two", "zero"],
 525  [12, 8, 10, 13, 8, 8, 9, 12, 12, 8]];
 526
 527 discrete_freq (to_array map (lambda ([x], concat ('x, printf (false, "~r", x))), s1));
 528 ['[xeight, xfive, xfour, xnine, xone, xseven, xsix, xthree, xtwo, xzero],
 529  [12, 8, 10, 13, 8, 8, 9, 12, 12, 8]];
 530
 531 test_discrete_freq (to_array makelist (random (20), 1));
 532 true;
 533
 534 test_discrete_freq (to_array makelist (random (20), 10));
 535 true;
 536
 537 test_discrete_freq (to_array makelist (random (20), 100));
 538 true;
 539
 540 test_discrete_freq (to_array makelist (random (20), 1000));
 541 true;
 542
 543 test_discrete_freq (to_array (makelist (random (100), 100) * 0.25));
 544 true;
 545
 546 test_discrete_freq (to_array append (makelist (random (20), 50), 50 + makelist (random (20), 50)));
 547 true;
 548
 549 part(standardize(s1), [1, 10, 20]);
 550 [-171/sqrt(84259),-171/sqrt(84259),-71/sqrt(84259)]$
 551
 552 subsample (s2, lambda([v], v[1] > 18));
 553 matrix([19.38,15.37,15.12,23.09,25.25],[18.29,18.66,19.08,26.08,27.63],
 554               [20.25,21.46,19.95,27.71,23.38],[18.79,18.96,14.46,26.38,21.84])$
 555
 556 subsample (s2, g, 1, 2, 5), g(x):= first(x) >= 16 and fourth(x) < 25;
 557 matrix([19.38,15.37,25.25],[17.33,14.67,19.58],[16.92,13.21,21.21],
 558               [17.25,18.46,23.87])$
 559
 560 transform_sample(data, [a,b,c], [c, a*b, log(a)]), data: matrix([3,2,7],[3,7,2],[8,2,4],[5,2,4]);
 561 matrix([7,6,log(3)],[2,21,log(3)],[4,16,log(8)],[4,10,log(5)])$
 562
 563 (reset (float_approx_equal_tolerance), 0);
 564 0;
 565
 566 find_runs ([]);
 567 runs([], []);
 568
 569 find_runs ([1]);
 570 runs([1], [1]);
 571
 572 find_runs ([1000]);
 573 runs([1], [1000]);
 574
 575 find_runs ([1, 1]);
 576 runs ([2], [1]);
 577
 578 find_runs ([1000, 1000]);
 579 runs ([2], [1000]);
 580
 581 find_runs ([1, 1000]);
 582 runs ([1, 1], [1, 1000]);
 583
 584 find_runs ([1000, 1]);
 585 runs ([1, 1], [1000, 1]);
 586
 587 find_runs ([2, 2, 2]);
 588 runs ([3], [2]);
 589
 590 find_runs ([2, 2, 2, 2, 2, 2]);
 591 runs ([6], [2]);
 592
 593 (set_random_state (make_random_state (3)),
 594  test_find_runs (x) :=
 595    block ([r: find_runs (x), y],
 596           y: find_runs_inverse (r),
 597           if x = y then true
 598             else ['data = x, 'find_runs = r, 'find_runs_inverse = y]),
 599  0);
 600 0;
 601
 602 test_find_runs (l: makelist (random (m), n)), m = 2, n = 3;
 603 true;
 604
 605 test_find_runs (sort (l));
 606 true;
 607
 608 test_find_runs (l: makelist (random (m), n)), m = 2, n = 9;
 609 true;
 610
 611 test_find_runs (sort (l));
 612 true;
 613
 614 test_find_runs (l: makelist (random (m), n)), m = 2, n = 27;
 615 true;
 616
 617 test_find_runs (sort (l));
 618 true;
 619
 620 test_find_runs (l: makelist (random (m), n)), m = 10, n = 3;
 621 true;
 622
 623 test_find_runs (sort (l));
 624 true;
 625
 626 test_find_runs (l: makelist (random (m), n)), m = 10, n = 9;
 627 true;
 628
 629 test_find_runs (sort (l));
 630 true;
 631
 632 test_find_runs (l: makelist (random (m), n)), m = 10, n = 27;
 633 true;
 634
 635 test_find_runs (sort (l));
 636 true;
 637
 638 test_find_runs (l: makelist (random (m), n)), m = 100, n = 3;
 639 true;
 640
 641 test_find_runs (sort (l));
 642 true;
 643
 644 test_find_runs (l: makelist (random (m), n)), m = 100, n = 9;
 645 true;
 646
 647 test_find_runs (sort (l));
 648 true;
 649
 650 test_find_runs (l: makelist (random (m), n)), m = 100, n = 27;
 651 true;
 652
 653 test_find_runs (sort (l));
 654 true;
 655
 656 (kill (a, b, c, d, e, f, g, h, i, j),
 657  test_find_runs_with_symbols (l) :=
 658    block ([eqs: [0 = a, 1 = b, 2 = c, 3 = d, 4 = e, 5 = f, 6 = g, 7 = h, 8 = i, 9 = j]],
 659           test_find_runs (subst (eqs, l))),
 660  0);
 661 0;
 662
 663 find_runs ([a]);
 664 runs ([1], [a]);
 665
 666 find_runs ([b]);
 667 runs ([1], [b]);
 668
 669 find_runs ([a, a]);
 670 runs ([2], [a]);
 671
 672 find_runs ([a, b]);
 673 runs ([1, 1], [a, b]);
 674
 675 find_runs ([b, a]);
 676 runs ([1, 1], [b, a]);
 677
 678 find_runs ([b, b]);
 679 runs ([2], [b]);
 680
 681 test_find_runs_with_symbols (l: makelist (random (m), n)), m = 10, n = 3;
 682 true;
 683
 684 test_find_runs_with_symbols (sort (l));
 685 true;
 686
 687 test_find_runs_with_symbols (l: makelist (random (m), n)), m = 10, n = 9;
 688 true;
 689
 690 test_find_runs_with_symbols (sort (l));
 691 true;
 692
 693 test_find_runs_with_symbols (l: makelist (random (m), n)), m = 10, n = 27;
 694 true;
 695
 696 test_find_runs_with_symbols (sort (l));
 697 true;
 698
 699 find_runs (["foo"]);
 700 runs ([1], ["foo"]);
 701
 702 find_runs (["bar"]);
 703 runs ([1], ["bar"]);
 704
 705 find_runs (["foo", "foo"]);
 706 runs ([2], ["foo"]);
 707
 708 find_runs (["foo", "bar"]);
 709 runs ([1, 1], ["foo", "bar"]);
 710
 711 find_runs (["bar", "foo"]);
 712 runs ([1, 1], ["bar", "foo"]);
 713
 714 find_runs (["bar", "bar"]);
 715 runs ([2], ["bar"]);
 716
 717 (test_find_runs_with_strings (l) :=
 718    block ([eqs: [0 = "foo", 1 = "bar", 2 = "baz", 3 = "quux", 4 = "mumble", 5 = "blurf", 6 = "blart", 7 = "wheeze", 8 = "snort", 9 = "sigh"]],
 719           test_find_runs (subst (eqs, l))),
 720  0);
 721 0;
 722
 723 test_find_runs_with_strings (l: makelist (random (m), n)), m = 10, n = 3;
 724 true;
 725
 726 test_find_runs_with_strings (sort (l));
 727 true;
 728
 729 test_find_runs_with_strings (l: makelist (random (m), n)), m = 10, n = 9;
 730 true;
 731
 732 test_find_runs_with_strings (sort (l));
 733 true;
 734
 735 test_find_runs_with_strings (l: makelist (random (m), n)), m = 10, n = 27;
 736 true;
 737
 738 test_find_runs_with_strings (sort (l));
 739 true;
 740