Mercurial > octave-nkf

comparison scripts/io/importdata.m @ 17325:8cfc28809a07

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
importdata.m: Add %!tests for colheaders and rowheaders. * scripts/io/importdata.m: Add %!tests for colheaders and rowheaders. Simplify code in %!tests.
author Rik <rik@octave.org>
date Fri, 23 Aug 2013 20:05:04 -0700
parents 7babcdb9bc13
children 44624eb20076
comparison
equal deleted inserted replaced
17324:c8809de193a3 17325:8cfc28809a07
309 309
310 310
311 ######################################## 311 ########################################
312 312
313 %!test 313 %!test
314 %! # Comma separated values 314 %! ## Comma separated values
315 %! A = [3.1 -7.2 0; 0.012 6.5 128]; 315 %! A = [3.1 -7.2 0; 0.012 6.5 128];
316 %! fn = tmpnam (); 316 %! fn = tmpnam ();
317 %! fid = fopen (fn, "w"); 317 %! fid = fopen (fn, "w");
318 %! fputs (fid, "3.1,-7.2,0\n0.012,6.5,128"); 318 %! fputs (fid, "3.1,-7.2,0\n0.012,6.5,128");
319 %! fclose (fid); 319 %! fclose (fid);
322 %! assert (a, A); 322 %! assert (a, A);
323 %! assert (d, ","); 323 %! assert (d, ",");
324 %! assert (h, 0); 324 %! assert (h, 0);
325 325
326 %!test 326 %!test
327 %! # Tab separated values 327 %! ## Tab separated values
328 %! A = [3.1 -7.2 0; 0.012 6.5 128]; 328 %! A = [3.1 -7.2 0; 0.012 6.5 128];
329 %! fn = tmpnam (); 329 %! fn = tmpnam ();
330 %! fid = fopen (fn, "w"); 330 %! fid = fopen (fn, "w");
331 %! fputs (fid, "3.1\t-7.2\t0\n0.012\t6.5\t128"); 331 %! fputs (fid, "3.1\t-7.2\t0\n0.012\t6.5\t128");
332 %! fclose (fid); 332 %! fclose (fid);
333 %! [a,d,h] = importdata (fn, "\\t"); 333 %! [a,d,h] = importdata (fn, "\t");
334 %! unlink (fn); 334 %! unlink (fn);
335 %! assert (a, A); 335 %! assert (a, A);
336 %! assert (d, "\t"); 336 %! assert (d, "\t");
337 %! assert (h, 0); 337 %! assert (h, 0);
338 338
339 %!test 339 %!test
340 %! # Space separated values, using multiple spaces to align in columns. 340 %! ## Space separated values, using multiple spaces to align in columns.
341 %! A = [3.1 -7.2 0; 0.012 6.5 128]; 341 %! A = [3.1 -7.2 0; 0.012 6.5 128];
342 %! fn = tmpnam (); 342 %! fn = tmpnam ();
343 %! fid = fopen (fn, "w"); 343 %! fid = fopen (fn, "w");
344 %! fprintf (fid, "%10.3f %10.3f %10.3f\n", A(1,:)); 344 %! fprintf (fid, "%10.3f %10.3f %10.3f\n", A');
345 %! fprintf (fid, "%10.3f %10.3f %10.3f\n", A(2,:));
346 %! fclose (fid); 345 %! fclose (fid);
347 %! [a,d,h] = importdata (fn, " "); 346 %! [a,d,h] = importdata (fn, " ");
348 %! unlink (fn); 347 %! unlink (fn);
349 %! assert (a, A); 348 %! assert (a, A);
350 %! assert (d, " "); 349 %! assert (d, " ");
351 %! assert (h, 0); 350 %! assert (h, 0);
352 351
353 %!test 352 %!test
354 %! # Header 353 %! ## Header text
355 %! A.data = [3.1 -7.2 0; 0.012 6.5 128]; 354 %! A.data = [3.1 -7.2 0; 0.012 6.5 128];
356 %! A.textdata = {"This is a header row."; ... 355 %! A.textdata = {"This is a header row."; ...
357 %! "this row does not contain any data, but the next one does."}; 356 %! "this row does not contain any data, but the next one does."};
358 %! fn = tmpnam (); 357 %! fn = tmpnam ();
359 %! fid = fopen (fn, "w"); 358 %! fid = fopen (fn, "w");
360 %! fputs (fid, [A.textdata{1} "\n"]); 359 %! fprintf (fid, "%s\n", A.textdata{:});
361 %! fputs (fid, [A.textdata{2} "\n"]);
362 %! fputs (fid, "3.1\t-7.2\t0\n0.012\t6.5\t128"); 360 %! fputs (fid, "3.1\t-7.2\t0\n0.012\t6.5\t128");
363 %! fclose (fid); 361 %! fclose (fid);
364 %! [a,d,h] = importdata (fn, "\\t"); 362 %! [a,d,h] = importdata (fn, '\t');
365 %! unlink (fn); 363 %! unlink (fn);
366 %! assert (a, A); 364 %! assert (a, A);
367 %! assert (d, "\t"); 365 %! assert (d, "\t");
368 %! assert (h, 2); 366 %! assert (h, 2);
369 367
370 %!test 368 %!test
371 %! # Ignore empty rows containing only spaces 369 %! ## Column headers, only last row is returned in colheaders
370 %! A.data = [3.1 -7.2 0; 0.012 6.5 128];
371 %! A.textdata = {"Label1 Label2 Label3";
372 %! "col1 col2 col3"};
373 %! A.colheaders = {"col1", "col2", "col3"};
374 %! fn = tmpnam ();
375 %! fid = fopen (fn, "w");
376 %! fprintf (fid, "%s\n", A.textdata{:});
377 %! fputs (fid, "3.1\t-7.2\t0\n0.012\t6.5\t128");
378 %! fclose (fid);
379 %! [a,d,h] = importdata (fn, '\t');
380 %! unlink (fn);
381 %! assert (a, A);
382 %! assert (d, "\t");
383 %! assert (h, 2);
384
385 %!test
386 %! ## Row headers
387 %! A.data = [3.1 -7.2 0; 0.012 6.5 128];
388 %! ## FIXME: Does Matlab even create field "textdata" if it is null?
389 %! A.textdata = {""};
390 %! A.rowheaders = {"row1", "row2"};
391 %! fn = tmpnam ();
392 %! fid = fopen (fn, "w");
393 %! fputs (fid, "row1\t3.1\t-7.2\t0\nrow2\t0.012\t6.5\t128");
394 %! fclose (fid);
395 %! [a,d,h] = importdata (fn, '\t');
396 %! unlink (fn);
397 %! assert (a, A);
398 %! assert (d, "\t");
399 %! assert (h, 2);
400
401 %!test
402 %! ## Row/Column headers and Header Text
403 %! A.data = [3.1 -7.2 0; 0.012 6.5 128];
404 %! A.textdata = {"This is introductory header text"
405 %! " col1 col2 col3"
406 %! "row1"
407 %! "row2"};
408 %! fn = tmpnam ();
409 %! fid = fopen (fn, "w");
410 %! fprintf (fid, "%s\n", A.textdata{1:2});
411 %! fputs (fid, "row1\t3.1\t-7.2\t0\nrow2\t0.012\t6.5\t128");
412 %! fclose (fid);
413 %! [a,d,h] = importdata (fn, '\t');
414 %! unlink (fn);
415 %! assert (a, A);
416 %! assert (d, "\t");
417 %! assert (h, 2);
418
419 %!test
420 %! ## Ignore empty rows containing only spaces
372 %! A = [3.1 -7.2 0; 0.012 6.5 128]; 421 %! A = [3.1 -7.2 0; 0.012 6.5 128];
373 %! fn = tmpnam (); 422 %! fn = tmpnam ();
374 %! fid = fopen (fn, "w"); 423 %! fid = fopen (fn, "w");
375 %! fprintf (fid, "%10.3f %10.3f %10.3f\n", A(1,:)); 424 %! fprintf (fid, "%10.3f %10.3f %10.3f\n", A(1,:));
376 %! fputs (fid, " "); 425 %! fputs (fid, " ");
381 %! assert (a, A); 430 %! assert (a, A);
382 %! assert (d, " "); 431 %! assert (d, " ");
383 %! assert (h, 0); 432 %! assert (h, 0);
384 433
385 %!test 434 %!test
386 %! # Exponentials 435 %! ## Exponentials
387 %! A = [3.1 -7.2 0; 0.012 6.5 128]; 436 %! A = [3.1 -7.2 0; 0.012 6.5 128];
388 %! fn = tmpnam (); 437 %! fn = tmpnam ();
389 %! fid = fopen (fn, "w"); 438 %! fid = fopen (fn, "w");
390 %! fputs (fid, "+3.1e0\t-72E-1\t0\n12e-3\t6.5\t128"); 439 %! fputs (fid, "+3.1e0\t-72E-1\t0\n12e-3\t6.5\t128");
391 %! fclose (fid); 440 %! fclose (fid);
392 %! [a,d,h] = importdata (fn, "\\t"); 441 %! [a,d,h] = importdata (fn, '\t');
393 %! unlink (fn); 442 %! unlink (fn);
394 %! assert (a, A); 443 %! assert (a, A);
395 %! assert (d, "\t"); 444 %! assert (d, "\t");
396 %! assert (h, 0); 445 %! assert (h, 0);
397 446
398 %!test 447 %!test
399 %! # Complex numbers 448 %! ## Complex numbers
400 %! A = [3.1 -7.2 0-3.4i; 0.012 -6.5+7.2i 128]; 449 %! A = [3.1 -7.2 0-3.4i; 0.012 -6.5+7.2i 128];
401 %! fn = tmpnam (); 450 %! fn = tmpnam ();
402 %! fid = fopen (fn, "w"); 451 %! fid = fopen (fn, "w");
403 %! fputs (fid, "3.1\t-7.2\t0-3.4i\n0.012\t-6.5+7.2i\t128"); 452 %! fputs (fid, "3.1\t-7.2\t0-3.4i\n0.012\t-6.5+7.2i\t128");
404 %! fclose (fid); 453 %! fclose (fid);
405 %! [a,d,h] = importdata (fn, "\\t"); 454 %! [a,d,h] = importdata (fn, '\t');
406 %! unlink (fn); 455 %! unlink (fn);
407 %! assert (a, A); 456 %! assert (a, A);
408 %! assert (d, "\t"); 457 %! assert (d, "\t");
409 %! assert (h, 0); 458 %! assert (h, 0);
410 459
411 %!test 460 ## FIXME: Currently commented out (8/23/13) because I can't determine whether
412 %! # Missing values 461 ## Matlab processes exceptional values.
462 %!#test
463 %! ## Exceptional values (Inf, NaN, NA)
464 %! A = [3.1 Inf NA; -Inf NaN 128];
465 %! fn = tmpnam ();
466 %! fid = fopen (fn, "w");
467 %! fputs (fid, "3.1\tInf\tNA\n-Inf\tNaN\t128");
468 %! fclose (fid);
469 %! [a,d,h] = importdata (fn, '\t');
470 %! unlink (fn);
471 %! assert (a, A);
472 %! assert (d, "\t");
473 %! assert (h, 0);
474
475 %!test
476 %! ## Missing values
413 %! A = [3.1 NaN 0; 0.012 6.5 128]; 477 %! A = [3.1 NaN 0; 0.012 6.5 128];
414 %! fn = tmpnam (); 478 %! fn = tmpnam ();
415 %! fid = fopen (fn, "w"); 479 %! fid = fopen (fn, "w");
416 %! fputs (fid, "3.1\t\t0\n0.012\t6.5\t128"); 480 %! fputs (fid, "3.1\t\t0\n0.012\t6.5\t128");
417 %! fclose (fid); 481 %! fclose (fid);
418 %! [a,d,h] = importdata (fn, "\\t"); 482 %! [a,d,h] = importdata (fn, '\t');
419 %! unlink (fn); 483 %! unlink (fn);
420 %! assert (a, A); 484 %! assert (a, A);
421 %! assert (d, "\t"); 485 %! assert (d, "\t");
422 %! assert (h, 0); 486 %! assert (h, 0);
423 487
424 %!test 488 %!test
425 %! # CRLF for line breaks 489 %! ## CRLF for line breaks
426 %! A = [3.1 -7.2 0; 0.012 6.5 128]; 490 %! A = [3.1 -7.2 0; 0.012 6.5 128];
427 %! fn = tmpnam (); 491 %! fn = tmpnam ();
428 %! fid = fopen (fn, "w"); 492 %! fid = fopen (fn, "w");
429 %! fputs (fid, "3.1\t-7.2\t0\r\n0.012\t6.5\t128"); 493 %! fputs (fid, "3.1\t-7.2\t0\r\n0.012\t6.5\t128");
430 %! fclose (fid); 494 %! fclose (fid);
431 %! [a,d,h] = importdata (fn, "\\t"); 495 %! [a,d,h] = importdata (fn, '\t');
432 %! unlink (fn); 496 %! unlink (fn);
433 %! assert (a, A); 497 %! assert (a, A);
434 %! assert (d, "\t"); 498 %! assert (d, "\t");
435 %! assert (h, 0); 499 %! assert (h, 0);
436 500
437 %!test 501 %!test
438 %! # CR for line breaks 502 %! ## CR for line breaks
439 %! A = [3.1 -7.2 0; 0.012 6.5 128]; 503 %! A = [3.1 -7.2 0; 0.012 6.5 128];
440 %! fn = tmpnam (); 504 %! fn = tmpnam ();
441 %! fid = fopen (fn, "w"); 505 %! fid = fopen (fn, "w");
442 %! fputs (fid, "3.1\t-7.2\t0\r0.012\t6.5\t128"); 506 %! fputs (fid, "3.1\t-7.2\t0\r0.012\t6.5\t128");
443 %! fclose (fid); 507 %! fclose (fid);
444 %! [a,d,h] = importdata (fn, "\\t"); 508 %! [a,d,h] = importdata (fn, '\t');
445 %! unlink (fn); 509 %! unlink (fn);
446 %! assert (a, A); 510 %! assert (a, A);
447 %! assert (d, "\t"); 511 %! assert (d, "\t");
448 %! assert (h, 0); 512 %! assert (h, 0);
449 513