Mercurial > jwe > octave

comparison liboctave/array/CSparse.cc @ 21112:358aa7fcbd33

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Rename errwarn_singular_matrix to warn_singular_matrix. * inv.cc, sparse-xdiv.cc, xdiv.cc, CMatrix.cc, CSparse.cc, dMatrix.cc, dSparse.cc, fCMatrix.cc, fMatrix.cc, lo-array-errwarn.cc, lo-array-errwarn.h: Rename errwarn_singular_matrix to warn_singular_matrix.
author Rik <rik@octave.org>
date Tue, 19 Jan 2016 15:43:18 -0800
parents bd1752782e56
children 7cac4e7458f2
comparison
equal deleted inserted replaced
21111:7bb96a8df912 21112:358aa7fcbd33
1797 { 1797 {
1798 sing_handler (rcond); 1798 sing_handler (rcond);
1799 mattype.mark_as_rectangular (); 1799 mattype.mark_as_rectangular ();
1800 } 1800 }
1801 else 1801 else
1802 errwarn_singular_matrix (rcond); 1802 warn_singular_matrix (rcond);
1803 } 1803 }
1804 1804
1805 volatile double rcond_plus_one = rcond + 1.0; 1805 volatile double rcond_plus_one = rcond + 1.0;
1806 1806
1807 if (rcond_plus_one == 1.0 || xisnan (rcond)) 1807 if (rcond_plus_one == 1.0 || xisnan (rcond))
1812 { 1812 {
1813 sing_handler (rcond); 1813 sing_handler (rcond);
1814 mattype.mark_as_rectangular (); 1814 mattype.mark_as_rectangular ();
1815 } 1815 }
1816 else 1816 else
1817 errwarn_singular_matrix (rcond); 1817 warn_singular_matrix (rcond);
1818 } 1818 }
1819 } 1819 }
1820 else 1820 else
1821 (*current_liboctave_error_handler) ("incorrect matrix type"); 1821 (*current_liboctave_error_handler) ("incorrect matrix type");
1822 } 1822 }
2080 { 2080 {
2081 sing_handler (rcond); 2081 sing_handler (rcond);
2082 mattype.mark_as_rectangular (); 2082 mattype.mark_as_rectangular ();
2083 } 2083 }
2084 else 2084 else
2085 errwarn_singular_matrix (rcond); 2085 warn_singular_matrix (rcond);
2086 } 2086 }
2087 2087
2088 volatile double rcond_plus_one = rcond + 1.0; 2088 volatile double rcond_plus_one = rcond + 1.0;
2089 2089
2090 if (rcond_plus_one == 1.0 || xisnan (rcond)) 2090 if (rcond_plus_one == 1.0 || xisnan (rcond))
2095 { 2095 {
2096 sing_handler (rcond); 2096 sing_handler (rcond);
2097 mattype.mark_as_rectangular (); 2097 mattype.mark_as_rectangular ();
2098 } 2098 }
2099 else 2099 else
2100 errwarn_singular_matrix (rcond); 2100 warn_singular_matrix (rcond);
2101 } 2101 }
2102 } 2102 }
2103 else 2103 else
2104 (*current_liboctave_error_handler) ("incorrect matrix type"); 2104 (*current_liboctave_error_handler) ("incorrect matrix type");
2105 } 2105 }
2310 { 2310 {
2311 sing_handler (rcond); 2311 sing_handler (rcond);
2312 mattype.mark_as_rectangular (); 2312 mattype.mark_as_rectangular ();
2313 } 2313 }
2314 else 2314 else
2315 errwarn_singular_matrix (rcond); 2315 warn_singular_matrix (rcond);
2316 } 2316 }
2317 2317
2318 volatile double rcond_plus_one = rcond + 1.0; 2318 volatile double rcond_plus_one = rcond + 1.0;
2319 2319
2320 if (rcond_plus_one == 1.0 || xisnan (rcond)) 2320 if (rcond_plus_one == 1.0 || xisnan (rcond))
2325 { 2325 {
2326 sing_handler (rcond); 2326 sing_handler (rcond);
2327 mattype.mark_as_rectangular (); 2327 mattype.mark_as_rectangular ();
2328 } 2328 }
2329 else 2329 else
2330 errwarn_singular_matrix (rcond); 2330 warn_singular_matrix (rcond);
2331 } 2331 }
2332 } 2332 }
2333 else 2333 else
2334 (*current_liboctave_error_handler) ("incorrect matrix type"); 2334 (*current_liboctave_error_handler) ("incorrect matrix type");
2335 } 2335 }
2593 { 2593 {
2594 sing_handler (rcond); 2594 sing_handler (rcond);
2595 mattype.mark_as_rectangular (); 2595 mattype.mark_as_rectangular ();
2596 } 2596 }
2597 else 2597 else
2598 errwarn_singular_matrix (rcond); 2598 warn_singular_matrix (rcond);
2599 } 2599 }
2600 2600
2601 volatile double rcond_plus_one = rcond + 1.0; 2601 volatile double rcond_plus_one = rcond + 1.0;
2602 2602
2603 if (rcond_plus_one == 1.0 || xisnan (rcond)) 2603 if (rcond_plus_one == 1.0 || xisnan (rcond))
2608 { 2608 {
2609 sing_handler (rcond); 2609 sing_handler (rcond);
2610 mattype.mark_as_rectangular (); 2610 mattype.mark_as_rectangular ();
2611 } 2611 }
2612 else 2612 else
2613 errwarn_singular_matrix (rcond); 2613 warn_singular_matrix (rcond);
2614 } 2614 }
2615 } 2615 }
2616 else 2616 else
2617 (*current_liboctave_error_handler) ("incorrect matrix type"); 2617 (*current_liboctave_error_handler) ("incorrect matrix type");
2618 } 2618 }
2843 { 2843 {
2844 sing_handler (rcond); 2844 sing_handler (rcond);
2845 mattype.mark_as_rectangular (); 2845 mattype.mark_as_rectangular ();
2846 } 2846 }
2847 else 2847 else
2848 errwarn_singular_matrix (rcond); 2848 warn_singular_matrix (rcond);
2849 } 2849 }
2850 2850
2851 volatile double rcond_plus_one = rcond + 1.0; 2851 volatile double rcond_plus_one = rcond + 1.0;
2852 2852
2853 if (rcond_plus_one == 1.0 || xisnan (rcond)) 2853 if (rcond_plus_one == 1.0 || xisnan (rcond))
2858 { 2858 {
2859 sing_handler (rcond); 2859 sing_handler (rcond);
2860 mattype.mark_as_rectangular (); 2860 mattype.mark_as_rectangular ();
2861 } 2861 }
2862 else 2862 else
2863 errwarn_singular_matrix (rcond); 2863 warn_singular_matrix (rcond);
2864 } 2864 }
2865 } 2865 }
2866 else 2866 else
2867 (*current_liboctave_error_handler) ("incorrect matrix type"); 2867 (*current_liboctave_error_handler) ("incorrect matrix type");
2868 } 2868 }
3145 { 3145 {
3146 sing_handler (rcond); 3146 sing_handler (rcond);
3147 mattype.mark_as_rectangular (); 3147 mattype.mark_as_rectangular ();
3148 } 3148 }
3149 else 3149 else
3150 errwarn_singular_matrix (rcond); 3150 warn_singular_matrix (rcond);
3151 } 3151 }
3152 3152
3153 volatile double rcond_plus_one = rcond + 1.0; 3153 volatile double rcond_plus_one = rcond + 1.0;
3154 3154
3155 if (rcond_plus_one == 1.0 || xisnan (rcond)) 3155 if (rcond_plus_one == 1.0 || xisnan (rcond))
3160 { 3160 {
3161 sing_handler (rcond); 3161 sing_handler (rcond);
3162 mattype.mark_as_rectangular (); 3162 mattype.mark_as_rectangular ();
3163 } 3163 }
3164 else 3164 else
3165 errwarn_singular_matrix (rcond); 3165 warn_singular_matrix (rcond);
3166 } 3166 }
3167 } 3167 }
3168 else 3168 else
3169 (*current_liboctave_error_handler) ("incorrect matrix type"); 3169 (*current_liboctave_error_handler) ("incorrect matrix type");
3170 } 3170 }
3399 { 3399 {
3400 sing_handler (rcond); 3400 sing_handler (rcond);
3401 mattype.mark_as_rectangular (); 3401 mattype.mark_as_rectangular ();
3402 } 3402 }
3403 else 3403 else
3404 errwarn_singular_matrix (rcond); 3404 warn_singular_matrix (rcond);
3405 } 3405 }
3406 3406
3407 volatile double rcond_plus_one = rcond + 1.0; 3407 volatile double rcond_plus_one = rcond + 1.0;
3408 3408
3409 if (rcond_plus_one == 1.0 || xisnan (rcond)) 3409 if (rcond_plus_one == 1.0 || xisnan (rcond))
3414 { 3414 {
3415 sing_handler (rcond); 3415 sing_handler (rcond);
3416 mattype.mark_as_rectangular (); 3416 mattype.mark_as_rectangular ();
3417 } 3417 }
3418 else 3418 else
3419 errwarn_singular_matrix (rcond); 3419 warn_singular_matrix (rcond);
3420 } 3420 }
3421 } 3421 }
3422 else 3422 else
3423 (*current_liboctave_error_handler) ("incorrect matrix type"); 3423 (*current_liboctave_error_handler) ("incorrect matrix type");
3424 } 3424 }
3700 { 3700 {
3701 sing_handler (rcond); 3701 sing_handler (rcond);
3702 mattype.mark_as_rectangular (); 3702 mattype.mark_as_rectangular ();
3703 } 3703 }
3704 else 3704 else
3705 errwarn_singular_matrix (rcond); 3705 warn_singular_matrix (rcond);
3706 } 3706 }
3707 3707
3708 volatile double rcond_plus_one = rcond + 1.0; 3708 volatile double rcond_plus_one = rcond + 1.0;
3709 3709
3710 if (rcond_plus_one == 1.0 || xisnan (rcond)) 3710 if (rcond_plus_one == 1.0 || xisnan (rcond))
3715 { 3715 {
3716 sing_handler (rcond); 3716 sing_handler (rcond);
3717 mattype.mark_as_rectangular (); 3717 mattype.mark_as_rectangular ();
3718 } 3718 }
3719 else 3719 else
3720 errwarn_singular_matrix (rcond); 3720 warn_singular_matrix (rcond);
3721 } 3721 }
3722 } 3722 }
3723 else 3723 else
3724 (*current_liboctave_error_handler) ("incorrect matrix type"); 3724 (*current_liboctave_error_handler) ("incorrect matrix type");
3725 } 3725 }
3862 { 3862 {
3863 sing_handler (rcond); 3863 sing_handler (rcond);
3864 mattype.mark_as_rectangular (); 3864 mattype.mark_as_rectangular ();
3865 } 3865 }
3866 else 3866 else
3867 errwarn_singular_matrix (); 3867 warn_singular_matrix ();
3868 3868
3869 } 3869 }
3870 else 3870 else
3871 rcond = 1.; 3871 rcond = 1.;
3872 } 3872 }
3959 { 3959 {
3960 sing_handler (rcond); 3960 sing_handler (rcond);
3961 mattype.mark_as_rectangular (); 3961 mattype.mark_as_rectangular ();
3962 } 3962 }
3963 else 3963 else
3964 errwarn_singular_matrix (); 3964 warn_singular_matrix ();
3965 } 3965 }
3966 else 3966 else
3967 { 3967 {
3968 char job = 'N'; 3968 char job = 'N';
3969 volatile octave_idx_type x_nz = b.nnz (); 3969 volatile octave_idx_type x_nz = b.nnz ();
4161 { 4161 {
4162 sing_handler (rcond); 4162 sing_handler (rcond);
4163 mattype.mark_as_rectangular (); 4163 mattype.mark_as_rectangular ();
4164 } 4164 }
4165 else 4165 else
4166 errwarn_singular_matrix (); 4166 warn_singular_matrix ();
4167 } 4167 }
4168 } 4168 }
4169 else if (typ != MatrixType::Tridiagonal_Hermitian) 4169 else if (typ != MatrixType::Tridiagonal_Hermitian)
4170 (*current_liboctave_error_handler) ("incorrect matrix type"); 4170 (*current_liboctave_error_handler) ("incorrect matrix type");
4171 } 4171 }
4256 { 4256 {
4257 sing_handler (rcond); 4257 sing_handler (rcond);
4258 mattype.mark_as_rectangular (); 4258 mattype.mark_as_rectangular ();
4259 } 4259 }
4260 else 4260 else
4261 errwarn_singular_matrix (); 4261 warn_singular_matrix ();
4262 } 4262 }
4263 else 4263 else
4264 { 4264 {
4265 rcond = 1.; 4265 rcond = 1.;
4266 char job = 'N'; 4266 char job = 'N';
4425 { 4425 {
4426 sing_handler (rcond); 4426 sing_handler (rcond);
4427 mattype.mark_as_rectangular (); 4427 mattype.mark_as_rectangular ();
4428 } 4428 }
4429 else 4429 else
4430 errwarn_singular_matrix (rcond); 4430 warn_singular_matrix (rcond);
4431 } 4431 }
4432 } 4432 }
4433 else 4433 else
4434 rcond = 1.0; 4434 rcond = 1.0;
4435 4435
4510 { 4510 {
4511 sing_handler (rcond); 4511 sing_handler (rcond);
4512 mattype.mark_as_rectangular (); 4512 mattype.mark_as_rectangular ();
4513 } 4513 }
4514 else 4514 else
4515 errwarn_singular_matrix (); 4515 warn_singular_matrix ();
4516 } 4516 }
4517 else 4517 else
4518 { 4518 {
4519 if (calc_cond) 4519 if (calc_cond)
4520 { 4520 {
4543 { 4543 {
4544 sing_handler (rcond); 4544 sing_handler (rcond);
4545 mattype.mark_as_rectangular (); 4545 mattype.mark_as_rectangular ();
4546 } 4546 }
4547 else 4547 else
4548 errwarn_singular_matrix (rcond); 4548 warn_singular_matrix (rcond);
4549 } 4549 }
4550 } 4550 }
4551 else 4551 else
4552 rcond = 1.; 4552 rcond = 1.;
4553 4553
4667 { 4667 {
4668 sing_handler (rcond); 4668 sing_handler (rcond);
4669 mattype.mark_as_rectangular (); 4669 mattype.mark_as_rectangular ();
4670 } 4670 }
4671 else 4671 else
4672 errwarn_singular_matrix (rcond); 4672 warn_singular_matrix (rcond);
4673 } 4673 }
4674 } 4674 }
4675 else 4675 else
4676 rcond = 1.0; 4676 rcond = 1.0;
4677 4677
4785 { 4785 {
4786 sing_handler (rcond); 4786 sing_handler (rcond);
4787 mattype.mark_as_rectangular (); 4787 mattype.mark_as_rectangular ();
4788 } 4788 }
4789 else 4789 else
4790 errwarn_singular_matrix (); 4790 warn_singular_matrix ();
4791 } 4791 }
4792 else 4792 else
4793 { 4793 {
4794 if (calc_cond) 4794 if (calc_cond)
4795 { 4795 {
4818 { 4818 {
4819 sing_handler (rcond); 4819 sing_handler (rcond);
4820 mattype.mark_as_rectangular (); 4820 mattype.mark_as_rectangular ();
4821 } 4821 }
4822 else 4822 else
4823 errwarn_singular_matrix (rcond); 4823 warn_singular_matrix (rcond);
4824 } 4824 }
4825 } 4825 }
4826 else 4826 else
4827 rcond = 1.; 4827 rcond = 1.;
4828 4828
4981 { 4981 {
4982 sing_handler (rcond); 4982 sing_handler (rcond);
4983 mattype.mark_as_rectangular (); 4983 mattype.mark_as_rectangular ();
4984 } 4984 }
4985 else 4985 else
4986 errwarn_singular_matrix (rcond); 4986 warn_singular_matrix (rcond);
4987 } 4987 }
4988 } 4988 }
4989 else 4989 else
4990 rcond = 1.0; 4990 rcond = 1.0;
4991 4991
5064 { 5064 {
5065 sing_handler (rcond); 5065 sing_handler (rcond);
5066 mattype.mark_as_rectangular (); 5066 mattype.mark_as_rectangular ();
5067 } 5067 }
5068 else 5068 else
5069 errwarn_singular_matrix (); 5069 warn_singular_matrix ();
5070 } 5070 }
5071 else 5071 else
5072 { 5072 {
5073 if (calc_cond) 5073 if (calc_cond)
5074 { 5074 {
5097 { 5097 {
5098 sing_handler (rcond); 5098 sing_handler (rcond);
5099 mattype.mark_as_rectangular (); 5099 mattype.mark_as_rectangular ();
5100 } 5100 }
5101 else 5101 else
5102 errwarn_singular_matrix (rcond); 5102 warn_singular_matrix (rcond);
5103 } 5103 }
5104 } 5104 }
5105 else 5105 else
5106 rcond = 1.; 5106 rcond = 1.;
5107 5107
5223 { 5223 {
5224 sing_handler (rcond); 5224 sing_handler (rcond);
5225 mattype.mark_as_rectangular (); 5225 mattype.mark_as_rectangular ();
5226 } 5226 }
5227 else 5227 else
5228 errwarn_singular_matrix (rcond); 5228 warn_singular_matrix (rcond);
5229 } 5229 }
5230 } 5230 }
5231 else 5231 else
5232 rcond = 1.0; 5232 rcond = 1.0;
5233 5233
5346 { 5346 {
5347 sing_handler (rcond); 5347 sing_handler (rcond);
5348 mattype.mark_as_rectangular (); 5348 mattype.mark_as_rectangular ();
5349 } 5349 }
5350 else 5350 else
5351 errwarn_singular_matrix (); 5351 warn_singular_matrix ();
5352 } 5352 }
5353 else 5353 else
5354 { 5354 {
5355 if (calc_cond) 5355 if (calc_cond)
5356 { 5356 {
5379 { 5379 {
5380 sing_handler (rcond); 5380 sing_handler (rcond);
5381 mattype.mark_as_rectangular (); 5381 mattype.mark_as_rectangular ();
5382 } 5382 }
5383 else 5383 else
5384 errwarn_singular_matrix (rcond); 5384 warn_singular_matrix (rcond);
5385 } 5385 }
5386 } 5386 }
5387 else 5387 else
5388 rcond = 1.; 5388 rcond = 1.;
5389 5389
5532 err = -2; 5532 err = -2;
5533 5533
5534 if (sing_handler) 5534 if (sing_handler)
5535 sing_handler (rcond); 5535 sing_handler (rcond);
5536 else 5536 else
5537 errwarn_singular_matrix (rcond); 5537 warn_singular_matrix (rcond);
5538 } 5538 }
5539 else if (status < 0) 5539 else if (status < 0)
5540 { 5540 {
5541 (*current_liboctave_error_handler) 5541 (*current_liboctave_error_handler)
5542 ("SparseComplexMatrix::solve numeric factorization failed"); 5542 ("SparseComplexMatrix::solve numeric factorization failed");
5682 { 5682 {
5683 sing_handler (rcond); 5683 sing_handler (rcond);
5684 mattype.mark_as_rectangular (); 5684 mattype.mark_as_rectangular ();
5685 } 5685 }
5686 else 5686 else
5687 errwarn_singular_matrix (rcond); 5687 warn_singular_matrix (rcond);
5688 5688
5689 return retval; 5689 return retval;
5690 } 5690 }
5691 5691
5692 cholmod_dense *X; 5692 cholmod_dense *X;
5937 { 5937 {
5938 sing_handler (rcond); 5938 sing_handler (rcond);
5939 mattype.mark_as_rectangular (); 5939 mattype.mark_as_rectangular ();
5940 } 5940 }
5941 else 5941 else
5942 errwarn_singular_matrix (rcond); 5942 warn_singular_matrix (rcond);
5943 5943
5944 return retval; 5944 return retval;
5945 } 5945 }
5946 5946
5947 cholmod_sparse *X; 5947 cholmod_sparse *X;
6220 { 6220 {
6221 sing_handler (rcond); 6221 sing_handler (rcond);
6222 mattype.mark_as_rectangular (); 6222 mattype.mark_as_rectangular ();
6223 } 6223 }
6224 else 6224 else
6225 errwarn_singular_matrix (rcond); 6225 warn_singular_matrix (rcond);
6226 6226
6227 return retval; 6227 return retval;
6228 } 6228 }
6229 6229
6230 cholmod_dense *X; 6230 cholmod_dense *X;
6454 { 6454 {
6455 sing_handler (rcond); 6455 sing_handler (rcond);
6456 mattype.mark_as_rectangular (); 6456 mattype.mark_as_rectangular ();
6457 } 6457 }
6458 else 6458 else
6459 errwarn_singular_matrix (rcond); 6459 warn_singular_matrix (rcond);
6460 6460
6461 return retval; 6461 return retval;
6462 } 6462 }
6463 6463
6464 cholmod_sparse *X; 6464 cholmod_sparse *X;
6585 err = -2; 6585 err = -2;
6586 6586
6587 if (sing_handler) 6587 if (sing_handler)
6588 sing_handler (rcond); 6588 sing_handler (rcond);
6589 else 6589 else
6590 errwarn_singular_matrix (rcond); 6590 warn_singular_matrix (rcond);
6591 } 6591 }
6592 6592
6593 UMFPACK_ZNAME (report_info) (control, info); 6593 UMFPACK_ZNAME (report_info) (control, info);
6594 6594
6595 UMFPACK_ZNAME (free_numeric) (&Numeric); 6595 UMFPACK_ZNAME (free_numeric) (&Numeric);