share/numericalio/rtest_numericalio.mac

   1 /* Test read_list parsing -- verify expected handling of separator with missing value */
   2
   3 (read_from_string (f, S, sep) :=
   4      block ([S1, L],
   5             S1: make_string_input_stream (S),
   6             L: apply (f, [S1, sep]),
   7             close (S1),
   8             L),
   9  kill (a, b, c, d, e, f, g, h, i));
  10 done;
  11
  12 (bb:"a,b,c
  13 d,e,f
  14 g,h,i",
  15  read_from_string (read_list, bb, 'comma));
  16 [a, b, c,
  17  d, e, f,
  18  g, h, i];
  19
  20 read_from_string (read_nested_list, bb, 'comma);
  21 [[a, b, c],
  22  [d, e, f],
  23  [g, h, i]];
  24
  25 (cc:",a,b,c,
  26 ,d,e,f,
  27 ,g,h,i,",
  28  read_from_string (read_list, cc, 'comma));
  29 [false, a, b, c, false,
  30  false, d, e, f, false,
  31  false, g, h, i, false];
  32
  33 read_from_string (read_nested_list, cc, 'comma);
  34 [[false, a, b, c, false],
  35  [false, d, e, f, false],
  36  [false, g, h, i, false]];
  37
  38 (dd:",a,b,c
  39 ,d,e,f
  40 ,g,h,i",
  41  read_from_string (read_list, dd, 'comma));
  42 [false, a, b, c,
  43  false, d, e, f,
  44  false, g, h, i];
  45
  46 read_from_string (read_nested_list, dd, 'comma);
  47 [[false, a, b, c],
  48  [false, d, e, f],
  49  [false, g, h, i]];
  50
  51 (ee:"a,b,c,
  52 d,e,f,
  53 g,h,i,",
  54  read_from_string (read_list, ee, 'comma));
  55 [a, b, c, false,
  56  d, e, f, false,
  57  g, h, i, false];
  58
  59 read_from_string (read_nested_list, ee, 'comma);
  60 [[a, b, c, false],
  61  [d, e, f, false],
  62  [g, h, i, false]];
  63
  64 (ff:"a,,,b,,,c
  65 d,,,e,,,f
  66 g,,,h,,,i",
  67  read_from_string (read_list, ff, 'comma));
  68 [a, false, false, b, false, false, c,
  69  d, false, false, e, false, false, f,
  70  g, false, false, h, false, false, i];
  71
  72 read_from_string (read_nested_list, ff, 'comma);
  73 [[a, false, false, b, false, false, c],
  74  [d, false, false, e, false, false, f],
  75  [g, false, false, h, false, false, i]];
  76
  77 /* Test read/write array */
  78
  79 (kill (all),
  80  l :
  81    [7, 12, FOO, 45, 91,
  82     2, -8, 123, -9, -1,
  83     8, 18, Bar, -5, 17,
  84     6, 13, -57, 28, 53,
  85
  86     2.5, 19.7, 1.2, 9.1, 1.7,
  87     3.5, -8.2, 3.1, 7.2, 7.1,
  88     5.4, -5.3, 9.8, 1.8, 6.2,
  89     0.8, 52.9, 7.1, 0.2, 1.8,
  90
  91     baz, 79, 112, 173, 311,
  92     18, 97, 211, 317, 113,
  93     29, 32, 925, 512, 713,
  94     87, 53, 133, 127, 158],
  95  a : make_array ('any, 3, 4, 5),
  96  fillarray (a, l),
  97
  98  /* Note that this makes b the same size as a,
  99   * despite the different arguments ... <sigh>
 100   */
 101  array (b, 2, 3, 4),
 102
 103  fillarray (b, l),
 104
 105  a2 : make_array ('any, 3, 4, 5),
 106  array (b2, 2, 3, 4),
 107  0);
 108 0;
 109
 110 (read_array (file_search ("array.data"), a2),
 111  is (equal (a, a2)));
 112 true;
 113
 114 (read_array (file_search ("array.data"), b2),
 115  is (equal (b, b2)));
 116 true;
 117
 118 (write_data (a2, sconcat (maxima_tempdir, "/tmp-lisp-array.data")),
 119  a3: make_array('any, 3, 4, 5),
 120  read_array (sconcat (maxima_tempdir, "/tmp-lisp-array.data"), a3),
 121  is (equal (a2, a3)));
 122 true;
 123
 124 (write_data (b2, sconcat (maxima_tempdir, "/tmp-maxima-array.data")),
 125  array (b3, 2, 3, 4),
 126  read_array (sconcat (maxima_tempdir, "/tmp-maxima-array.data"), b3),
 127  is (equal (b2, b3)));
 128 true;
 129
 130 /* Test read/write comma-separated data */
 131
 132 (kill (all),
 133  l_nested :
 134   [[KEY, XX, YY, ZZ, FOO, Bar, baz],
 135    [aa46, 7, 7, 16, FOO3, 2.71, 2.88],
 136    [aA31, 31, 61, 25, 916, 6.10, 741],
 137    [AA22, 61, 40, 13, 32.75, Bar2, 9.12],
 138    [AA16, 19, 25, 31, FOO7, 4.80, 697],
 139    [AA16, 13, 49, 7, 5.67, 2.54, 4.54],
 140    [AA58, 19, 28, 43, 4.04, 0.90, baz8],
 141    [AA34, 16, 22, 19, 4.87, 4.90, 2.85],
 142    [AA52, 28, 34, 7, FOO9, Bar4, 293],
 143    [AA52, 10, 43, 13, 12.125, 5.69, 0.00],
 144    [AA40, 7, 25, 40, 3.15, 7.54, 6.11]],
 145  m : apply(matrix, l_nested),
 146  0);
 147 0;
 148
 149 (m2 : read_matrix (file_search ("rectangular.csv")),
 150  is (m = m2));
 151 true;
 152
 153 (m3 : read_matrix (file_search ("really-csv.data"), 'comma),
 154  is (m = m3));
 155 true;
 156
 157 (m3a : read_matrix (file_search ("really-csv.data"), ","),
 158  is (m = m3a));
 159 true;
 160
 161 (m4 : read_matrix (file_search ("really-space-separated.csv"), 'space),
 162  is (m = m4));
 163 true;
 164
 165 (m4a : read_matrix (file_search ("really-space-separated.csv"), " "),
 166  is (m = m4a));
 167 true;
 168
 169 (write_data (m2, sconcat (maxima_tempdir, "/tmp-matrix.csv")),
 170  m5 : read_matrix(sconcat (maxima_tempdir, "/tmp-matrix.csv")),
 171  is (m2 = m5));
 172 true;
 173
 174 (write_data (m2, sconcat (maxima_tempdir, "/tmp-matrix.data", 'comma)),
 175  m6 : read_matrix(sconcat (maxima_tempdir, "/tmp-matrix.data", 'comma)),
 176  is (m2 = m6));
 177 true;
 178
 179 (write_data (m2, sconcat (maxima_tempdir, "/tmp-matrix.data", ",")),
 180  m6a : read_matrix(sconcat (maxima_tempdir, "/tmp-matrix.data", ",")),
 181  is (m2 = m6a));
 182 true;
 183
 184 (write_data (m2, sconcat (maxima_tempdir, "/tmp-matrix-2.csv", 'space)),
 185  m7 : read_matrix(sconcat (maxima_tempdir, "/tmp-matrix-2.csv", 'space)),
 186  is (m2 = m7));
 187 true;
 188
 189 (write_data (m2, sconcat (maxima_tempdir, "/tmp-matrix-2.csv", " ")),
 190  m7a : read_matrix(sconcat (maxima_tempdir, "/tmp-matrix-2.csv", " ")),
 191  is (m2 = m7a));
 192 true;
 193
 194 (array (a, 10, 6),
 195  read_array (file_search ("rectangular.data"), a),
 196  write_data (a, sconcat (maxima_tempdir, "/tmp-array.csv")),
 197  array (a2, 10, 6),
 198  read_array (sconcat (maxima_tempdir, "/tmp-array.csv"), a2),
 199  is (equal (a, a2)));
 200 true;
 201
 202 /* Test read/write variable-length lines */
 203
 204 (kill (all),
 205  l_nested :
 206   [[aa46,7,7,16,FOO3],
 207    [aA31,31,61,25,9.16,513],
 208    [AA16,13,49,7,5.67,2.54,4.54],
 209    [AA52,7,FOO9,Bar4,2.93],
 210    [AA40,7,25,40,3.15,7.54,0.00],
 211    [aa46,1325,7,16,FOO3,2.71,2.88],
 212    [aA31,31,61,25,9.16],
 213    [AA58,19,28,43,4.04,0.90,baz8],
 214    [AA34,16,175.25,2.85],
 215    [AA40,7,25],
 216    [AA22,617,40,Bar2,9.12],
 217    [zz7b,12375e-003,12375s-003,12375d-003,123b-001],
 218    [w23q,123.375e-001,123.375s-001,123.375d-001,123.456b-001],
 219    [q32w,12375E-003,12375S-003,12375D-003,123B-001],
 220    [t5u7,123.375E-001,123.375S-001,123.375D-001,123.456B-001],
 221    [q129,"Foo","BAR","Foo \\ BAR \"baz quux\""]],
 222  l : flatten (l_nested),
 223  h[aa46] : [7,7,16,FOO3],
 224  h[aA31] : [31,61,25,9.16,513],
 225  h[AA16] : [13,49,7,5.67,2.54,4.54],
 226  h[AA52] : [7,FOO9,Bar4,2.93],
 227  h[AA40] : [7,25,40,3.15,7.54,0.00],
 228  h[aa46] : [1325,7,16,FOO3,2.71,2.88],
 229  h[aA31] : [31,61,25,9.16],
 230  h[AA58] : [19,28,43,4.04,0.90,baz8],
 231  h[AA34] : [16,175.25,2.85],
 232  h[AA40] : [7,25],
 233  h[AA22] : [617,40,Bar2,9.12],
 234  h[zz7b] : [12375e-003,12375s-003,12375d-003,123b-001],
 235  h[w23q] : [123.375e-001,123.375s-001,123.375d-001,123.456b-001],
 236  h[q32w] : [12375E-003,12375S-003,12375D-003,123B-001],
 237  h[t5u7] : [123.375E-001,123.375S-001,123.375D-001,123.456B-001],
 238  h[q129] : ["Foo","BAR","Foo \\ BAR \"baz quux\""],
 239  0);
 240 0;
 241
 242 (l2 : read_list (file_search ("ragged.data")),
 243  is (l = l2));
 244 true;
 245
 246 (l2_nested: read_nested_list (file_search ("ragged.data")),
 247  is (l_nested = l2_nested));
 248 true;
 249
 250 (read_hashed_array (file_search ("ragged.data"), h2),
 251  is (equal (h, h2)));
 252 true;
 253
 254 (AA16: 16,
 255  AA22: 22,
 256  aA31: 31,
 257  AA34: 34,
 258  AA40: 40,
 259  aa46: 46,
 260  AA52: 52,
 261  AA58: 58,
 262  FOO3: 13,
 263
 264  FOO9: 27.25,
 265  Bar4: %pi,
 266  baz8: -5.75,
 267  Bar2: -1217,
 268  is (ev (l) = ev (l2)));
 269 true;
 270
 271 /* Test read/write rectangular (same number of items on each line) data */
 272
 273 (kill (all),
 274  l_nested :
 275   [[KEY, XX, YY, ZZ, FOO, Bar, baz],
 276    [aa46, 7, 7, 16, FOO3, 2.71, 2.88],
 277    [aA31, 31, 61, 25, 916, 6.10, 741],
 278    [AA22, 61, 40, 13, 32.75, Bar2, 9.12],
 279    [AA16, 19, 25, 31, FOO7, 4.80, 697],
 280    [AA16, 13, 49, 7, 5.67, 2.54, 4.54],
 281    [AA58, 19, 28, 43, 4.04, 0.90, baz8],
 282    [AA34, 16, 22, 19, 4.87, 4.90, 2.85],
 283    [AA52, 28, 34, 7, FOO9, Bar4, 293],
 284    [AA52, 10, 43, 13, 12.125, 5.69, 0.00],
 285    [AA40, 7, 25, 40, 3.15, 7.54, 6.11]],
 286  m : apply (matrix, l_nested),
 287  for i:1 thru length (l_nested)
 288   do h [l_nested [i] [1]] : rest (l_nested [i]),
 289  l: flatten (l_nested),
 290  0);
 291 0;
 292
 293 (m2: read_matrix (file_search ("rectangular.data")),
 294  is (m = m2));
 295 true;
 296
 297 (read_hashed_array (file_search ("rectangular.data"), h2),
 298  is (equal (h, h2)));
 299 true;
 300
 301 (l2_nested : read_nested_list (file_search ("rectangular.data")),
 302  is (l_nested = l2_nested));
 303 true;
 304
 305 (l2 : read_list (file_search ("rectangular.data")),
 306  is (l = l2));
 307 true;
 308
 309 (write_data (m2, sconcat (maxima_tempdir, "/tmp-matrix.data")),
 310  l3_nested : read_nested_list (sconcat (maxima_tempdir, "/tmp-matrix.data")),
 311  is (l2_nested = l3_nested));
 312 true;
 313
 314 (write_data (h2, sconcat (maxima_tempdir, "/tmp-hashed-array.data")),
 315  read_hashed_array (sconcat (maxima_tempdir, "/tmp-hashed-array.data"), h3),
 316  is (equal (h2, h3)));
 317 true;
 318
 319 (write_data (l2_nested, sconcat (maxima_tempdir, "/tmp-nested-list.data")),
 320  m3 : read_matrix (sconcat (maxima_tempdir, "/tmp-nested-list.data")),
 321  is (m2 = m3));
 322 true;
 323
 324 (write_data (l2, sconcat (maxima_tempdir, "/tmp-list.data")),
 325  l3 : read_list (sconcat (maxima_tempdir, "/tmp-list.data")),
 326  is (l2 = l3));
 327 true;
 328
 329 (KEY: -2.5,
 330  XX: 3.25,
 331  YY: 1.75,
 332  ZZ: 5.5,
 333  FOO: %pi,
 334  Bar: 175,
 335  baz: 2119,
 336
 337  aa46: 46,
 338  aA31: 31,
 339  AA22: 22,
 340  AA16: 16,
 341  AA58: 58,
 342  AA34: 34,
 343  AA52: 52,
 344  AA40: 40,
 345
 346  FOO3: 611,
 347  Bar2: 1917,
 348  FOO7: 6,
 349  baz8: -5,
 350  FOO9: -1.5,
 351  Bar4: -3.75,
 352
 353  is (ev (m) = ev (m2)));
 354 true;
 355
 356 /* Test read/write with different separator characters */
 357
 358 (kill (all),
 359  l_nested :
 360   [[],
 361    [false, false],
 362    [false, false, false],
 363    [false, false, false, false],
 364    [Foo],
 365    [],
 366    [],
 367    [Foo, false],
 368    [false, Foo],
 369    [Foo, false, false],
 370    [false, Foo, false],
 371    [false, false, Foo],
 372    [Foo, BAR, false],
 373    [Foo, false, BAR],
 374    [false, Foo, BAR],
 375    [Foo, BAR, baz, embedded\ space\ and\ \$p\*cia\!\ c\#\@rs],
 376    [12.34, Foo, 12375e-3, BAR, 1234b-2, baz, 1234],
 377    ["tab        space comma, semicolon; pipe| dollar$", "quux \"blart\"", ?a\-lisp\-symbol],
 378    [],
 379    [],
 380    []],
 381  0);
 382 0;
 383
 384 (l_nested_2 : read_nested_list (file_search ("semicolon.data"), 'semicolon),
 385  is (l_nested = l_nested_2));
 386 true;
 387
 388 (write_data (l_nested_2, sconcat (maxima_tempdir, "/tmp-semicolon.data"), ";"),
 389  l_nested_2a : read_nested_list (sconcat (maxima_tempdir, "/tmp-semicolon.data"), ";"),
 390  is (l_nested = l_nested_2a));
 391 true;
 392
 393 (l_nested_3 : read_nested_list (file_search ("pipe.data"), 'pipe),
 394  is (l_nested = l_nested_3));
 395 true;
 396
 397 (write_data (l_nested_3, sconcat (maxima_tempdir, "/tmp-pipe.data"), "|"),
 398  l_nested_3a : read_nested_list (sconcat (maxima_tempdir, "/tmp-pipe.data"), "|"),
 399  is (l_nested = l_nested_3a));
 400 true;
 401
 402 (write_data (l_nested, sconcat (maxima_tempdir, "/tmp-tab.data"), 'tab),
 403  /* tab not recognized by read_nested_list, since Maxima parser
 404   * (barring hackery to recognize tab characters as tokens)
 405   * just burns through multiple tabs.
 406   */
 407  l_nested_4: read_nested_list (sconcat (maxima_tempdir, "/tmp-tab.data"), 'space),
 408  is (l_nested = l_nested_4));
 409 true;
 410
 411 /* ASCII character 9 is the tab character. ascii(9) returns a 1-element string. */
 412 (write_data (l_nested, sconcat (maxima_tempdir, "/tmp-tab.data"), ascii(9)),
 413  l_nested_4a: read_nested_list (sconcat (maxima_tempdir, "/tmp-tab.data"), " "),
 414  is (l_nested = l_nested_4a));
 415 true;
 416
 417 /* Test read/write on streams (instead of files) */
 418
 419 (kill (all),
 420  0);
 421 0;
 422
 423 (a1 : make_array ('any, 3, 4, 5),
 424  read_array (file_search ("array.data"), a1),
 425  a2 : make_array ('any, 3, 4, 5),
 426  s : openr (file_search ("array.data")),
 427  read_array (s, a2),
 428  close (s),
 429  is (equal (a1, a2)));
 430 true;
 431
 432 (s : openw (sconcat (maxima_tempdir, "/tmp-lisp-array.data")),
 433  write_data (a2, s),
 434  close (s),
 435  a3 : make_array ('any, 3, 4, 5),
 436  s : openr (sconcat (maxima_tempdir, "/tmp-lisp-array.data")),
 437  read_array (s, a3),
 438  close (s),
 439  is (equal (a1, a3)));
 440 true;
 441
 442 (b1 : array (b, 2, 3, 4),
 443  read_array (file_search ("array.data"), b1),
 444  b2 : array (b, 2, 3, 4),
 445  s : openr (file_search ("array.data")),
 446  read_array (s, b2),
 447  close (s),
 448  is (equal (b1, b2)));
 449 true;
 450
 451 (s : openw (sconcat (maxima_tempdir, "/tmp-maxima-array.data")),
 452  write_data (b2, s),
 453  close (s),
 454  b3 : array (b, 2, 3, 4),
 455  s : openr (sconcat (maxima_tempdir, "/tmp-maxima-array.data")),
 456  read_array (s, b3),
 457  close (s),
 458  is (equal (b1, b3)));
 459 true;
 460
 461 (m1 : read_matrix (file_search ("rectangular.data")),
 462  s : openr (file_search ("rectangular.data")),
 463  m2 : read_matrix (s),
 464  close (s),
 465  is (m1 = m2));
 466 true;
 467
 468 (s : openw (sconcat (maxima_tempdir, "/tmp-matrix.data")),
 469  write_data (m2, s),
 470  close (s),
 471  s : openr (sconcat (maxima_tempdir, "/tmp-matrix.data")),
 472  m3 : read_matrix (s),
 473  close (s),
 474  is (m1 = m3));
 475 true;
 476
 477 (l1 : read_list (file_search ("ragged.data")),
 478  s : openr (file_search ("ragged.data")),
 479  l2 : read_list (s),
 480  close (s),
 481  is (l1 = l2));
 482 true;
 483
 484 (s : openw (sconcat (maxima_tempdir, "/tmp-list.data")),
 485  write_data (l2, s),
 486  close (s),
 487  s : openr (sconcat (maxima_tempdir, "/tmp-list.data")),
 488  l3 : read_list (s),
 489  close (s),
 490  is (l1 = l3));
 491 true;
 492
 493 (l1 : read_nested_list (file_search ("ragged.data")),
 494  s : openr (file_search ("ragged.data")),
 495  l2 : read_nested_list (s),
 496  close (s),
 497  is (l1 = l2));
 498 true;
 499
 500 (s : openw (sconcat (maxima_tempdir, "/tmp-nested-list.data")),
 501  write_data (l2, s),
 502  close (s),
 503  s : openr (sconcat (maxima_tempdir, "/tmp-nested-list.data")),
 504  l3 : read_nested_list (s),
 505  close (s),
 506  is (l1 = l3));
 507 true;
 508
 509 (read_hashed_array (file_search ("ragged.data"), h1),
 510  s : openr (file_search ("ragged.data")),
 511  read_hashed_array (s, h2),
 512  close (s),
 513  is (equal (h1, h2)));
 514 true;
 515
 516 (s : openw (sconcat (maxima_tempdir, "/tmp-hashed-array.data")),
 517  write_data (h2, s),
 518  close (s),
 519  s : openr (sconcat (maxima_tempdir, "/tmp-hashed-array.data")),
 520  read_hashed_array (s, h3),
 521  close (s),
 522  is (equal (h1, h3)));
 523 true;
 524
 525 /* Write and read binary data */
 526
 527 (assume_external_byte_order (lsb),
 528  read_binary_list (file_search ("test-binary.f8-lsb")));
 529 [-1.125, 0.375, 3.750, -7.875, 2.625];
 530
 531 (assume_external_byte_order (lsb),
 532  L : makelist (0, 5),
 533  read_binary_list (file_search ("test-binary.f8-lsb"), L),
 534  L);
 535 [-1.125, 0.375, 3.750, -7.875, 2.625];
 536
 537 (assume_external_byte_order (msb),
 538  read_binary_list (file_search ("test-binary.f8-msb")));
 539 [-1.125, 0.375, 3.750, -7.875, 2.625];
 540
 541 (assume_external_byte_order (msb),
 542  L : makelist (0, 5),
 543  read_binary_list (file_search ("test-binary.f8-msb"), L),
 544  L);
 545 [-1.125, 0.375, 3.750, -7.875, 2.625];
 546
 547 (tmp_msb : sconcat (maxima_tempdir, "/tmp-binary.f8-msb"),
 548  tmp_lsb : sconcat (maxima_tempdir, "/tmp-binary.f8-lsb"),
 549  L : makelist (11.0^(3*i), i, 1, 98),
 550  L4 : append ([?most\-negative\-double\-float], - reverse (L), [- 1.0], -1 / L, [?least\-negative\-normalized\-double\-float, 0.0, ?least\-positive\-normalized\-double\-float], reverse (1 / L), [1.0], L, [?most\-positive\-double\-float]),
 551  0);
 552 0;
 553
 554 (assume_external_byte_order (lsb),
 555  write_binary_data (L4, tmp_lsb));
 556 done;
 557
 558 (L4b : read_binary_list (tmp_lsb),
 559  is (L4b = L4));
 560 true;
 561
 562 (assume_external_byte_order (msb),
 563  write_binary_data (L4, tmp_msb));
 564 done;
 565
 566 (L4c : read_binary_list (tmp_msb),
 567  is (L4c = L4));
 568 true;
 569
 570 (A4 : make_array (any, 3, 7, 19),
 571  fillarray (A4, L4),
 572  0);
 573 0;
 574
 575 (tmp2_msb : sconcat (maxima_tempdir, "/tmp2-binary.f8-msb"),
 576  tmp2_lsb : sconcat (maxima_tempdir, "/tmp2-binary.f8-lsb"),
 577  assume_external_byte_order (msb),
 578  write_binary_data (A4, tmp2_msb));
 579 done;
 580
 581 (A4b : make_array (any, 3, 7, 19),
 582  read_binary_array (tmp2_msb, A4b),
 583  is (A4b = A4b));
 584 true;
 585
 586 is (listarray (read_binary_array (tmp2_msb)) = L4);
 587 true;
 588
 589 (assume_external_byte_order (lsb),
 590  write_binary_data (A4, tmp2_lsb));
 591 done;
 592
 593 (A4c : make_array (any, 3, 7, 19),
 594  read_binary_array (tmp2_lsb, A4c),
 595  is (A4c = A4));
 596 true;
 597
 598 is (listarray (read_binary_array (tmp2_lsb)) = L4);
 599 true;
 600
 601 /* Read specific number of data via optional argument */
 602
 603 (l1 : read_list (file_search ("ragged.data")),
 604  l2 : read_list (file_search ("ragged.data"), false, 20));
 605 ''(makelist (l1 [i], i, 1, 20));
 606
 607 (s : openr (file_search ("ragged.data")),
 608  l2 : read_list (s, false, 20),
 609  l3 : read_list (s, false, 12),
 610  l4 : read_list (s),
 611  close (s),
 612  [length (l2), length (l3), length (l4), append (l2, l3, l4)]);
 613 ''([20, 12, length (l1) - (20 + 12), l1]);
 614
 615 (assume_external_byte_order (lsb),
 616  l1 : read_binary_list (tmp2_lsb),
 617  l2 : read_binary_list (tmp2_lsb, 50));
 618 ''(makelist (l1 [i], i, 1, 50));
 619
 620 (s : openr_binary (tmp2_lsb),
 621  l2 : read_binary_list (s, 50),
 622  l3 : read_binary_list (s, 30),
 623  l4 : read_binary_list (s),
 624  close (s),
 625  [length (l2), length (l3), length (l4), append (l2, l3, l4)]);
 626 ''([50, 30, length (l1) - (50 + 30), l1]);
 627
 628 /* NEED ADDITIONAL TESTS HERE FOR PARTIAL READS TO PRODUCE ARRAYS */
 629
 630 /* read from a file and return a new array */
 631
 632 block ([a, l],
 633   kill (a), /* ensure no declared array */
 634   l : read_list (file_search ("rectangular.data")),
 635   a : read_array (file_search ("rectangular.data")),
 636   [is (length (l) = ?length (a)), every (makelist (l[i] = a[i - 1], i, length (l)))]);
 637 [true, true];
 638
 639 block ([a, l],
 640   l : read_list (file_search ("rectangular.csv")),
 641   a : read_array (file_search ("rectangular.csv")),
 642   [is (length (l) = ?length (a)), every (makelist (l[i] = a[i - 1], i, length (l)))]);
 643 [true, true];
 644
 645 block ([a, l],
 646   l : read_list (file_search ("really-csv.data"), 'comma),
 647   a : read_array (file_search ("really-csv.data"), 'comma),
 648   [is (length (l) = ?length (a)), every (makelist (l[i] = a[i - 1], i, length (l)))]);
 649 [true, true];
 650
 651 block ([a, l],
 652   l : read_list (file_search ("really-space-separated.csv"), 'space),
 653   a : read_array (file_search ("really-space-separated.csv"), 'space),
 654   [is (length (l) = ?length (a)), every (makelist (l[i] = a[i - 1], i, length (l)))]);
 655 [true, true];
 656
 657 /* verify that empty lines are ignored by
 658  * read_matrix, read_list, read_array, and read_hashed_array,
 659  * but not read_nested_list.
 660  */
 661
 662 (zz: "
 663
 664 11,22,33,44
 665 55,66,77,88
 666
 667 99,111,222,333
 668 444,555,666,777
 669 888,999,1111,2222
 670
 671
 672 ",
 673  aa: [11,22,33,44,
 674       55,66,77,88,
 675       99,111,222,333,
 676       444,555,666,777,
 677       888,999,1111,2222],
 678  read_from_string (f, S, [a]) :=
 679      block ([S1, L],
 680             S1: make_string_input_stream (S),
 681             L: apply (f, cons (S1, a)),
 682             close (S1),
 683             L),
 684 0);
 685 0;
 686
 687 read_from_string (read_matrix, zz, 'comma);
 688 matrix ([11,22,33,44],
 689         [55,66,77,88],
 690         [99,111,222,333],
 691         [444,555,666,777],
 692         [888,999,1111,2222]);
 693
 694 read_from_string (read_list, zz, 'comma);
 695 [11,22,33,44,
 696  55,66,77,88,
 697  99,111,222,333,
 698  444,555,666,777,
 699  888,999,1111,2222];
 700
 701 (yy: make_array (fixnum, 5*4),
 702  read_from_string (read_array, zz, yy, 'comma),
 703  yy);
 704 ''(make_array (fixnum, 5*4), fillarray (%%, aa), %%);
 705
 706 (kill(hh, hh1),
 707  read_from_string (read_hashed_array, zz, hh, 'comma),
 708  hh1[11]: [22, 33, 44],
 709  hh1[55]: [66, 77, 88],
 710  hh1[99]: [111, 222, 333],
 711  hh1[444]: [555, 666, 777],
 712  hh1[888]: [999, 1111, 2222],
 713  is (equal (hh, hh1)));
 714 true;
 715
 716 read_from_string (read_nested_list, zz, 'comma);
 717 [[],
 718  [],
 719  [11,22,33,44],
 720  [55,66,77,88],
 721  [],
 722  [99,111,222,333],
 723  [444,555,666,777],
 724  [888,999,1111,2222],
 725  [],
 726  []];