Mercurial > hg > octave-nkf

comparison src/pr-output.cc @ 5748:8510034588a7

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
[project @ 2006-04-07 07:51:59 by jwe]
author jwe
date Fri, 07 Apr 2006 07:51:59 +0000
parents 2618a0750ae6
children ce79d238f142
comparison
equal deleted inserted replaced
5747:b09d4d0f5b63 5748:8510034588a7
231 octave_idx_type nr = m.rows (); 231 octave_idx_type nr = m.rows ();
232 octave_idx_type nc = m.columns (); 232 octave_idx_type nc = m.columns ();
233 233
234 double result = -DBL_MAX; 234 double result = -DBL_MAX;
235 235
236 bool all_inf_or_nan = true;
237
236 for (octave_idx_type j = 0; j < nc; j++) 238 for (octave_idx_type j = 0; j < nc; j++)
237 for (octave_idx_type i = 0; i < nr; i++) 239 for (octave_idx_type i = 0; i < nr; i++)
238 { 240 {
239 double val = m(i,j); 241 double val = m(i,j);
240 if (xisinf (val) || xisnan (val)) 242 if (xisinf (val) || xisnan (val))
241 continue; 243 continue;
242 244
245 all_inf_or_nan = false;
246
243 if (val > result) 247 if (val > result)
244 result = val; 248 result = val;
245 } 249 }
246 250
251 if (all_inf_or_nan)
252 result = 0.0;
253
247 return result; 254 return result;
248 } 255 }
249 256
250 static double 257 static double
251 pr_min_internal (const Matrix& m) 258 pr_min_internal (const Matrix& m)
252 { 259 {
253 octave_idx_type nr = m.rows (); 260 octave_idx_type nr = m.rows ();
254 octave_idx_type nc = m.columns (); 261 octave_idx_type nc = m.columns ();
255 262
256 double result = DBL_MAX; 263 double result = DBL_MAX;
264
265 bool all_inf_or_nan = true;
257 266
258 for (octave_idx_type j = 0; j < nc; j++) 267 for (octave_idx_type j = 0; j < nc; j++)
259 for (octave_idx_type i = 0; i < nr; i++) 268 for (octave_idx_type i = 0; i < nr; i++)
260 { 269 {
261 double val = m(i,j); 270 double val = m(i,j);
262 if (xisinf (val) || xisnan (val)) 271 if (xisinf (val) || xisnan (val))
263 continue; 272 continue;
264 273
274 all_inf_or_nan = false;
275
265 if (val < result) 276 if (val < result)
266 result = val; 277 result = val;
267 } 278 }
268 279
280 if (all_inf_or_nan)
281 result = 0.0;
282
269 return result; 283 return result;
270 } 284 }
271 285
272 // XXX FIXME XXX -- it would be nice to share more code among these 286 // XXX FIXME XXX -- it would be nice to share more code among these
273 // functions,.. 287 // functions,..
283 int ld, rd; 297 int ld, rd;
284 298
285 if (bank_format) 299 if (bank_format)
286 { 300 {
287 fw = digits < 0 ? 4 : digits + 3; 301 fw = digits < 0 ? 4 : digits + 3;
288 if (inf_or_nan && fw < 3) 302 if (inf_or_nan && fw < 4)
289 fw = 3; 303 fw = 4;
290 fw += sign;
291 rd = 2; 304 rd = 2;
292 } 305 }
293 else if (hex_format) 306 else if (hex_format)
294 { 307 {
295 fw = 2 * sizeof (double); 308 fw = 2 * sizeof (double);
301 rd = 0; 314 rd = 0;
302 } 315 }
303 else if (inf_or_nan || int_only) 316 else if (inf_or_nan || int_only)
304 { 317 {
305 fw = digits; 318 fw = digits;
306 if (inf_or_nan && fw < 3) 319 if (inf_or_nan && fw < 4)
307 fw = 3; 320 fw = 4;
308 fw += sign;
309 rd = fw; 321 rd = fw;
310 } 322 }
311 else 323 else
312 { 324 {
313 if (digits > 0) 325 if (digits > 0)
322 rd = prec > digits ? prec - digits : prec; 334 rd = prec > digits ? prec - digits : prec;
323 digits = -digits + 1; 335 digits = -digits + 1;
324 } 336 }
325 337
326 fw = ld + 1 + rd; 338 fw = ld + 1 + rd;
327 if (inf_or_nan && fw < 3) 339 if (inf_or_nan && fw < 4)
328 fw = 3; 340 fw = 4;
329 fw += sign;
330 } 341 }
331 342
332 if (! (bank_format || hex_format || bit_format) 343 if (! (bank_format || hex_format || bit_format)
333 && (fw > Voutput_max_field_width || print_e || print_g)) 344 && (fw > Voutput_max_field_width || print_e || print_g))
334 { 345 {
339 int exp_field = 4; 350 int exp_field = 4;
340 if (digits > 100) 351 if (digits > 100)
341 exp_field++; 352 exp_field++;
342 353
343 fw = 2 + prec + exp_field; 354 fw = 2 + prec + exp_field;
344 if (inf_or_nan && fw < 3) 355 if (inf_or_nan && fw < 4)
345 fw = 3; 356 fw = 4;
346 fw += sign;
347 357
348 fmt = float_format (fw, prec - 1, std::ios::scientific); 358 fmt = float_format (fw, prec - 1, std::ios::scientific);
349 } 359 }
350 360
351 if (print_big_e) 361 if (print_big_e)
401 411
402 if (bank_format) 412 if (bank_format)
403 { 413 {
404 int digits = x_max > x_min ? x_max : x_min; 414 int digits = x_max > x_min ? x_max : x_min;
405 fw = digits <= 0 ? 4 : digits + 3; 415 fw = digits <= 0 ? 4 : digits + 3;
406 if (inf_or_nan && fw < 3) 416 if (inf_or_nan && fw < 4)
407 fw = 3; 417 fw = 4;
408 fw += sign;
409 rd = 2; 418 rd = 2;
410 } 419 }
411 else if (hex_format) 420 else if (hex_format)
412 { 421 {
413 fw = 2 * sizeof (double); 422 fw = 2 * sizeof (double);
420 } 429 }
421 else if (Vfixed_point_format && ! print_g) 430 else if (Vfixed_point_format && ! print_g)
422 { 431 {
423 rd = prec; 432 rd = prec;
424 fw = rd + 2; 433 fw = rd + 2;
425 if (inf_or_nan && fw < 3) 434 if (inf_or_nan && fw < 4)
426 fw = 3; 435 fw = 4;
427 fw += sign;
428 } 436 }
429 else if (int_or_inf_or_nan) 437 else if (int_or_inf_or_nan)
430 { 438 {
431 int digits = x_max > x_min ? x_max : x_min; 439 int digits = x_max > x_min ? x_max : x_min;
432 fw = digits <= 0 ? 1 : digits; 440 fw = digits <= 0 ? 1 : digits;
433 if (inf_or_nan && fw < 3) 441 if (inf_or_nan && fw < 4)
434 fw = 3; 442 fw = 4;
435 fw += sign;
436 rd = fw; 443 rd = fw;
437 } 444 }
438 else 445 else
439 { 446 {
440 int ld_max, rd_max; 447 int ld_max, rd_max;
467 474
468 ld = ld_max > ld_min ? ld_max : ld_min; 475 ld = ld_max > ld_min ? ld_max : ld_min;
469 rd = rd_max > rd_min ? rd_max : rd_min; 476 rd = rd_max > rd_min ? rd_max : rd_min;
470 477
471 fw = ld + 1 + rd; 478 fw = ld + 1 + rd;
472 if (inf_or_nan && fw < 3) 479 if (inf_or_nan && fw < 4)
473 fw = 3; 480 fw = 4;
474 fw += sign;
475 } 481 }
476 482
477 if (! (bank_format || hex_format || bit_format) 483 if (! (bank_format || hex_format || bit_format)
478 && (print_e 484 && (print_e
479 || print_g 485 || print_g
486 int exp_field = 4; 492 int exp_field = 4;
487 if (x_max > 100 || x_min > 100) 493 if (x_max > 100 || x_min > 100)
488 exp_field++; 494 exp_field++;
489 495
490 fw = 2 + prec + exp_field; 496 fw = 2 + prec + exp_field;
491 if (inf_or_nan && fw < 3) 497 if (inf_or_nan && fw < 4)
492 fw = 3; 498 fw = 4;
493 fw += sign;
494 499
495 fmt = float_format (fw, prec - 1, std::ios::scientific); 500 fmt = float_format (fw, prec - 1, std::ios::scientific);
496 } 501 }
497 502
498 if (print_big_e) 503 if (print_big_e)
559 if (bank_format) 564 if (bank_format)
560 { 565 {
561 int digits = r_x; 566 int digits = r_x;
562 i_fw = 0; 567 i_fw = 0;
563 r_fw = digits <= 0 ? 4 : digits + 3; 568 r_fw = digits <= 0 ? 4 : digits + 3;
564 if (inf_or_nan && r_fw < 3) 569 if (inf_or_nan && r_fw < 4)
565 r_fw = 3; 570 r_fw = 4;
566 r_fw += sign;
567 rd = 2; 571 rd = 2;
568 } 572 }
569 else if (hex_format) 573 else if (hex_format)
570 { 574 {
571 r_fw = 2 * sizeof (double); 575 r_fw = 2 * sizeof (double);
580 } 584 }
581 else if (inf_or_nan || int_only) 585 else if (inf_or_nan || int_only)
582 { 586 {
583 int digits = x_max > x_min ? x_max : x_min; 587 int digits = x_max > x_min ? x_max : x_min;
584 i_fw = r_fw = digits <= 0 ? 1 : digits; 588 i_fw = r_fw = digits <= 0 ? 1 : digits;
585 if (inf_or_nan && i_fw < 3) 589 if (inf_or_nan && i_fw < 4)
586 i_fw = r_fw = 3; 590 i_fw = r_fw = 4;
587 r_fw += sign;
588 rd = r_fw; 591 rd = r_fw;
589 } 592 }
590 else 593 else
591 { 594 {
592 int ld_max, rd_max; 595 int ld_max, rd_max;
619 622
620 ld = ld_max > ld_min ? ld_max : ld_min; 623 ld = ld_max > ld_min ? ld_max : ld_min;
621 rd = rd_max > rd_min ? rd_max : rd_min; 624 rd = rd_max > rd_min ? rd_max : rd_min;
622 625
623 i_fw = r_fw = ld + 1 + rd; 626 i_fw = r_fw = ld + 1 + rd;
624 if (inf_or_nan && i_fw < 3) 627 if (inf_or_nan && i_fw < 4)
625 i_fw = r_fw = 3; 628 i_fw = r_fw = 4;
626 r_fw += sign;
627 } 629 }
628 630
629 if (! (bank_format || hex_format || bit_format) 631 if (! (bank_format || hex_format || bit_format)
630 && (r_fw > Voutput_max_field_width || print_e || print_g)) 632 && (r_fw > Voutput_max_field_width || print_e || print_g))
631 { 633 {
639 int exp_field = 4; 641 int exp_field = 4;
640 if (x_max > 100 || x_min > 100) 642 if (x_max > 100 || x_min > 100)
641 exp_field++; 643 exp_field++;
642 644
643 i_fw = r_fw = 1 + prec + exp_field; 645 i_fw = r_fw = 1 + prec + exp_field;
644 if (inf_or_nan && i_fw < 3) 646 if (inf_or_nan && i_fw < 4)
645 i_fw = r_fw = 3; 647 i_fw = r_fw = 4;
646 r_fw += sign;
647 648
648 r_fmt = float_format (r_fw, prec - 1, std::ios::scientific); 649 r_fmt = float_format (r_fw, prec - 1, std::ios::scientific);
649 i_fmt = float_format (i_fw, prec - 1, std::ios::scientific); 650 i_fmt = float_format (i_fw, prec - 1, std::ios::scientific);
650 } 651 }
651 652
736 if (bank_format) 737 if (bank_format)
737 { 738 {
738 int digits = r_x_max > r_x_min ? r_x_max : r_x_min; 739 int digits = r_x_max > r_x_min ? r_x_max : r_x_min;
739 i_fw = 0; 740 i_fw = 0;
740 r_fw = digits <= 0 ? 4 : digits + 3; 741 r_fw = digits <= 0 ? 4 : digits + 3;
741 if (inf_or_nan && i_fw < 3) 742 if (inf_or_nan && i_fw < 4)
742 i_fw = r_fw = 3; 743 i_fw = r_fw = 4;
743 r_fw += sign;
744 rd = 2; 744 rd = 2;
745 } 745 }
746 else if (hex_format) 746 else if (hex_format)
747 { 747 {
748 r_fw = 2 * sizeof (double); 748 r_fw = 2 * sizeof (double);
757 } 757 }
758 else if (Vfixed_point_format && ! print_g) 758 else if (Vfixed_point_format && ! print_g)
759 { 759 {
760 rd = prec; 760 rd = prec;
761 i_fw = r_fw = rd + 2; 761 i_fw = r_fw = rd + 2;
762 if (inf_or_nan && i_fw < 3) 762 if (inf_or_nan && i_fw < 4)
763 i_fw = r_fw = 3; 763 i_fw = r_fw = 4;
764 r_fw += sign;
765 } 764 }
766 else if (int_or_inf_or_nan) 765 else if (int_or_inf_or_nan)
767 { 766 {
768 int digits = x_max > x_min ? x_max : x_min; 767 int digits = x_max > x_min ? x_max : x_min;
769 i_fw = r_fw = digits <= 0 ? 1 : digits; 768 i_fw = r_fw = digits <= 0 ? 1 : digits;
770 if (inf_or_nan && i_fw < 3) 769 if (inf_or_nan && i_fw < 4)
771 i_fw = r_fw = 3; 770 i_fw = r_fw = 4;
772 r_fw += sign;
773 rd = r_fw; 771 rd = r_fw;
774 } 772 }
775 else 773 else
776 { 774 {
777 int ld_max, rd_max; 775 int ld_max, rd_max;
804 802
805 ld = ld_max > ld_min ? ld_max : ld_min; 803 ld = ld_max > ld_min ? ld_max : ld_min;
806 rd = rd_max > rd_min ? rd_max : rd_min; 804 rd = rd_max > rd_min ? rd_max : rd_min;
807 805
808 i_fw = r_fw = ld + 1 + rd; 806 i_fw = r_fw = ld + 1 + rd;
809 if (inf_or_nan && i_fw < 3) 807 if (inf_or_nan && i_fw < 4)
810 i_fw = r_fw = 3; 808 i_fw = r_fw = 4;
811 r_fw += sign;
812 } 809 }
813 810
814 if (! (bank_format || hex_format || bit_format) 811 if (! (bank_format || hex_format || bit_format)
815 && (print_e 812 && (print_e
816 || print_g 813 || print_g
826 int exp_field = 4; 823 int exp_field = 4;
827 if (x_max > 100 || x_min > 100) 824 if (x_max > 100 || x_min > 100)
828 exp_field++; 825 exp_field++;
829 826
830 i_fw = r_fw = 1 + prec + exp_field; 827 i_fw = r_fw = 1 + prec + exp_field;
831 if (inf_or_nan && i_fw < 3) 828 if (inf_or_nan && i_fw < 4)
832 i_fw = r_fw = 3; 829 i_fw = r_fw = 4;
833 r_fw += sign;
834 830
835 r_fmt = float_format (r_fw, prec - 1, std::ios::scientific); 831 r_fmt = float_format (r_fw, prec - 1, std::ios::scientific);
836 i_fmt = float_format (i_fw, prec - 1, std::ios::scientific); 832 i_fmt = float_format (i_fw, prec - 1, std::ios::scientific);
837 } 833 }
838 834