Mercurial > jwe > octave

comparison liboctave/numeric/lo-specfun.cc @ 21136:7cac4e7458f2

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
maint: clean up code around calls to current_liboctave_error_handler. Remove statements after call to handler that are no longer reachable. Place input validation first and immediately call handler if necessary. Change if/error_handler/else to if/error_handler and re-indent code. * Array-util.cc, Array.cc, CColVector.cc, CDiagMatrix.cc, CMatrix.cc, CNDArray.cc, CRowVector.cc, CSparse.cc, DiagArray2.cc, MArray.cc, PermMatrix.cc, Sparse.cc, Sparse.h, chMatrix.cc, chNDArray.cc, dColVector.cc, dDiagMatrix.cc, dMatrix.cc, dNDArray.cc, dRowVector.cc, dSparse.cc, fCColVector.cc, fCDiagMatrix.cc, fCMatrix.cc, fCNDArray.cc, fCRowVector.cc, fColVector.cc, fDiagMatrix.cc, fMatrix.cc, fNDArray.cc, fRowVector.cc, idx-vector.cc, CmplxAEPBAL.cc, CmplxCHOL.cc, CmplxGEPBAL.cc, CmplxHESS.cc, CmplxLU.cc, CmplxQR.cc, CmplxSCHUR.cc, CmplxSVD.cc, DASPK.cc, EIG.cc, LSODE.cc, Quad.cc, SparseCmplxCHOL.cc, SparseCmplxLU.cc, SparseCmplxQR.cc, SparseQR.cc, SparsedbleCHOL.cc, SparsedbleLU.cc, base-lu.cc, bsxfun-defs.cc, dbleAEPBAL.cc, dbleCHOL.cc, dbleGEPBAL.cc, dbleHESS.cc, dbleLU.cc, dbleQR.cc, dbleSCHUR.cc, dbleSVD.cc, eigs-base.cc, fCmplxAEPBAL.cc, fCmplxCHOL.cc, fCmplxLU.cc, fCmplxQR.cc, fCmplxSCHUR.cc, fEIG.cc, floatAEPBAL.cc, floatCHOL.cc, floatGEPBAL.cc, floatHESS.cc, floatLU.cc, floatQR.cc, floatSCHUR.cc, floatSVD.cc, lo-specfun.cc, oct-fftw.cc, oct-rand.cc, oct-spparms.cc, sparse-base-chol.cc, sparse-dmsolve.cc, file-ops.cc, lo-sysdep.cc, mach-info.cc, oct-env.cc, oct-syscalls.cc, cmd-edit.cc, cmd-hist.cc, data-conv.cc, lo-ieee.cc, lo-regexp.cc, oct-base64.cc, oct-shlib.cc, pathsearch.cc, singleton-cleanup.cc, sparse-util.cc, unwind-prot.cc: Remove statements after call to handler that are no longer reachable. Place input validation first and immediately call handler if necessary. Change if/error_handler/else to if/error_handler and re-indent code.
author Rik <rik@octave.org>
date Sat, 23 Jan 2016 13:52:03 -0800
parents 3ac9f47fb04b
children 538b57866b90
comparison
equal deleted inserted replaced
21135:95da3bc8a281 21136:7cac4e7458f2
1194 octave_idx_type x_nc = x.cols (); 1194 octave_idx_type x_nc = x.cols ();
1195 1195
1196 octave_idx_type alpha_nr = alpha.rows (); 1196 octave_idx_type alpha_nr = alpha.rows ();
1197 octave_idx_type alpha_nc = alpha.cols (); 1197 octave_idx_type alpha_nc = alpha.cols ();
1198 1198
1199 if (x_nr == alpha_nr && x_nc == alpha_nc) 1199 if (x_nr != alpha_nr || x_nc != alpha_nc)
1200 {
1201 octave_idx_type nr = x_nr;
1202 octave_idx_type nc = x_nc;
1203
1204 retval.resize (nr, nc);
1205
1206 ierr.resize (dim_vector (nr, nc));
1207
1208 for (octave_idx_type j = 0; j < nc; j++)
1209 for (octave_idx_type i = 0; i < nr; i++)
1210 retval(i,j) = f (x(i,j), alpha(i,j), (scaled ? 2 : 1), ierr(i,j));
1211 }
1212 else
1213 (*current_liboctave_error_handler) 1200 (*current_liboctave_error_handler)
1214 ("%s: the sizes of alpha and x must conform", fn); 1201 ("%s: the sizes of alpha and x must conform", fn);
1202
1203 octave_idx_type nr = x_nr;
1204 octave_idx_type nc = x_nc;
1205
1206 retval.resize (nr, nc);
1207
1208 ierr.resize (dim_vector (nr, nc));
1209
1210 for (octave_idx_type j = 0; j < nc; j++)
1211 for (octave_idx_type i = 0; i < nr; i++)
1212 retval(i,j) = f (x(i,j), alpha(i,j), (scaled ? 2 : 1), ierr(i,j));
1215 1213
1216 return retval; 1214 return retval;
1217 } 1215 }
1218 1216
1219 static inline ComplexNDArray 1217 static inline ComplexNDArray
1253 const ComplexNDArray& x, bool scaled, Array<octave_idx_type>& ierr) 1251 const ComplexNDArray& x, bool scaled, Array<octave_idx_type>& ierr)
1254 { 1252 {
1255 dim_vector dv = x.dims (); 1253 dim_vector dv = x.dims ();
1256 ComplexNDArray retval; 1254 ComplexNDArray retval;
1257 1255
1258 if (dv == alpha.dims ()) 1256 if (dv != alpha.dims ())
1259 {
1260 octave_idx_type nel = dv.numel ();
1261
1262 retval.resize (dv);
1263 ierr.resize (dv);
1264
1265 for (octave_idx_type i = 0; i < nel; i++)
1266 retval(i) = f (x(i), alpha(i), (scaled ? 2 : 1), ierr(i));
1267 }
1268 else
1269 (*current_liboctave_error_handler) 1257 (*current_liboctave_error_handler)
1270 ("%s: the sizes of alpha and x must conform", fn); 1258 ("%s: the sizes of alpha and x must conform", fn);
1259
1260 octave_idx_type nel = dv.numel ();
1261
1262 retval.resize (dv);
1263 ierr.resize (dv);
1264
1265 for (octave_idx_type i = 0; i < nel; i++)
1266 retval(i) = f (x(i), alpha(i), (scaled ? 2 : 1), ierr(i));
1271 1267
1272 return retval; 1268 return retval;
1273 } 1269 }
1274 1270
1275 static inline ComplexMatrix 1271 static inline ComplexMatrix
1804 octave_idx_type x_nc = x.cols (); 1800 octave_idx_type x_nc = x.cols ();
1805 1801
1806 octave_idx_type alpha_nr = alpha.rows (); 1802 octave_idx_type alpha_nr = alpha.rows ();
1807 octave_idx_type alpha_nc = alpha.cols (); 1803 octave_idx_type alpha_nc = alpha.cols ();
1808 1804
1809 if (x_nr == alpha_nr && x_nc == alpha_nc) 1805 if (x_nr != alpha_nr || x_nc != alpha_nc)
1810 {
1811 octave_idx_type nr = x_nr;
1812 octave_idx_type nc = x_nc;
1813
1814 retval.resize (nr, nc);
1815
1816 ierr.resize (dim_vector (nr, nc));
1817
1818 for (octave_idx_type j = 0; j < nc; j++)
1819 for (octave_idx_type i = 0; i < nr; i++)
1820 retval(i,j) = f (x(i,j), alpha(i,j), (scaled ? 2 : 1), ierr(i,j));
1821 }
1822 else
1823 (*current_liboctave_error_handler) 1806 (*current_liboctave_error_handler)
1824 ("%s: the sizes of alpha and x must conform", fn); 1807 ("%s: the sizes of alpha and x must conform", fn);
1808
1809 octave_idx_type nr = x_nr;
1810 octave_idx_type nc = x_nc;
1811
1812 retval.resize (nr, nc);
1813
1814 ierr.resize (dim_vector (nr, nc));
1815
1816 for (octave_idx_type j = 0; j < nc; j++)
1817 for (octave_idx_type i = 0; i < nr; i++)
1818 retval(i,j) = f (x(i,j), alpha(i,j), (scaled ? 2 : 1), ierr(i,j));
1825 1819
1826 return retval; 1820 return retval;
1827 } 1821 }
1828 1822
1829 static inline FloatComplexNDArray 1823 static inline FloatComplexNDArray
1864 Array<octave_idx_type>& ierr) 1858 Array<octave_idx_type>& ierr)
1865 { 1859 {
1866 dim_vector dv = x.dims (); 1860 dim_vector dv = x.dims ();
1867 FloatComplexNDArray retval; 1861 FloatComplexNDArray retval;
1868 1862
1869 if (dv == alpha.dims ()) 1863 if (dv != alpha.dims ())
1870 {
1871 octave_idx_type nel = dv.numel ();
1872
1873 retval.resize (dv);
1874 ierr.resize (dv);
1875
1876 for (octave_idx_type i = 0; i < nel; i++)
1877 retval(i) = f (x(i), alpha(i), (scaled ? 2 : 1), ierr(i));
1878 }
1879 else
1880 (*current_liboctave_error_handler) 1864 (*current_liboctave_error_handler)
1881 ("%s: the sizes of alpha and x must conform", fn); 1865 ("%s: the sizes of alpha and x must conform", fn);
1866
1867 octave_idx_type nel = dv.numel ();
1868
1869 retval.resize (dv);
1870 ierr.resize (dv);
1871
1872 for (octave_idx_type i = 0; i < nel; i++)
1873 retval(i) = f (x(i), alpha(i), (scaled ? 2 : 1), ierr(i));
1882 1874
1883 return retval; 1875 return retval;
1884 } 1876 }
1885 1877
1886 static inline FloatComplexMatrix 1878 static inline FloatComplexMatrix
2576 err = false; 2568 err = false;
2577 2569
2578 if (a < 0.0 || x < 0.0) 2570 if (a < 0.0 || x < 0.0)
2579 (*current_liboctave_error_handler) 2571 (*current_liboctave_error_handler)
2580 ("gammainc: A and X must be non-negative"); 2572 ("gammainc: A and X must be non-negative");
2581 else 2573
2582 F77_XFCN (xgammainc, XGAMMAINC, (a, x, retval)); 2574 F77_XFCN (xgammainc, XGAMMAINC, (a, x, retval));
2583 2575
2584 return retval; 2576 return retval;
2585 } 2577 }
2586 2578
2587 Matrix 2579 Matrix
2599 for (octave_idx_type i = 0; i < nr; i++) 2591 for (octave_idx_type i = 0; i < nr; i++)
2600 { 2592 {
2601 result(i,j) = gammainc (x, a(i,j), err); 2593 result(i,j) = gammainc (x, a(i,j), err);
2602 2594
2603 if (err) 2595 if (err)
2604 goto done; 2596 goto done; // FIXME: why not just use return to exit?
2605 } 2597 }
2606 2598
2607 retval = result; 2599 retval = result;
2608 2600
2609 done: 2601 done:
2626 for (octave_idx_type i = 0; i < nr; i++) 2618 for (octave_idx_type i = 0; i < nr; i++)
2627 { 2619 {
2628 result(i,j) = gammainc (x(i,j), a, err); 2620 result(i,j) = gammainc (x(i,j), a, err);
2629 2621
2630 if (err) 2622 if (err)
2631 goto done; 2623 goto done; // FIXME: why not just use return to exit?
2632 } 2624 }
2633 2625
2634 retval = result; 2626 retval = result;
2635 2627
2636 done: 2628 done:
2648 octave_idx_type nc = x.cols (); 2640 octave_idx_type nc = x.cols ();
2649 2641
2650 octave_idx_type a_nr = a.rows (); 2642 octave_idx_type a_nr = a.rows ();
2651 octave_idx_type a_nc = a.cols (); 2643 octave_idx_type a_nc = a.cols ();
2652 2644
2653 if (nr == a_nr && nc == a_nc) 2645 if (nr != a_nr || nc != a_nc)
2654 {
2655 result.resize (nr, nc);
2656
2657 bool err;
2658
2659 for (octave_idx_type j = 0; j < nc; j++)
2660 for (octave_idx_type i = 0; i < nr; i++)
2661 {
2662 result(i,j) = gammainc (x(i,j), a(i,j), err);
2663
2664 if (err)
2665 goto done;
2666 }
2667
2668 retval = result;
2669 }
2670 else
2671 (*current_liboctave_error_handler) 2646 (*current_liboctave_error_handler)
2672 ("gammainc: nonconformant arguments (arg 1 is %dx%d, arg 2 is %dx%d)", 2647 ("gammainc: nonconformant arguments (arg 1 is %dx%d, arg 2 is %dx%d)",
2673 nr, nc, a_nr, a_nc); 2648 nr, nc, a_nr, a_nc);
2674 2649
2650 result.resize (nr, nc);
2651
2652 bool err;
2653
2654 for (octave_idx_type j = 0; j < nc; j++)
2655 for (octave_idx_type i = 0; i < nr; i++)
2656 {
2657 result(i,j) = gammainc (x(i,j), a(i,j), err);
2658
2659 if (err)
2660 goto done; // FIXME: why not just use return to exit?
2661 }
2662
2663 retval = result;
2664
2675 done: 2665 done:
2676 2666
2677 return retval; 2667 return retval;
2678 } 2668 }
2679 2669
2691 for (octave_idx_type i = 0; i < nel; i++) 2681 for (octave_idx_type i = 0; i < nel; i++)
2692 { 2682 {
2693 result(i) = gammainc (x, a(i), err); 2683 result(i) = gammainc (x, a(i), err);
2694 2684
2695 if (err) 2685 if (err)
2696 goto done; 2686 goto done; // FIXME: why not just use return to exit?
2697 } 2687 }
2698 2688
2699 retval = result; 2689 retval = result;
2700 2690
2701 done: 2691 done:
2717 for (octave_idx_type i = 0; i < nel; i++) 2707 for (octave_idx_type i = 0; i < nel; i++)
2718 { 2708 {
2719 result(i) = gammainc (x(i), a, err); 2709 result(i) = gammainc (x(i), a, err);
2720 2710
2721 if (err) 2711 if (err)
2722 goto done; 2712 goto done; // FIXME: why not just use return to exit?
2723 } 2713 }
2724 2714
2725 retval = result; 2715 retval = result;
2726 2716
2727 done: 2717 done:
2733 gammainc (const NDArray& x, const NDArray& a) 2723 gammainc (const NDArray& x, const NDArray& a)
2734 { 2724 {
2735 dim_vector dv = x.dims (); 2725 dim_vector dv = x.dims ();
2736 octave_idx_type nel = dv.numel (); 2726 octave_idx_type nel = dv.numel ();
2737 2727
2738 NDArray retval; 2728 if (dv != a.dims ())
2739 NDArray result;
2740
2741 if (dv == a.dims ())
2742 {
2743 result.resize (dv);
2744
2745 bool err;
2746
2747 for (octave_idx_type i = 0; i < nel; i++)
2748 {
2749 result(i) = gammainc (x(i), a(i), err);
2750
2751 if (err)
2752 goto done;
2753 }
2754
2755 retval = result;
2756 }
2757 else
2758 { 2729 {
2759 std::string x_str = dv.str (); 2730 std::string x_str = dv.str ();
2760 std::string a_str = a.dims ().str (); 2731 std::string a_str = a.dims ().str ();
2761 2732
2762 (*current_liboctave_error_handler) 2733 (*current_liboctave_error_handler)
2763 ("gammainc: nonconformant arguments (arg 1 is %s, arg 2 is %s)", 2734 ("gammainc: nonconformant arguments (arg 1 is %s, arg 2 is %s)",
2764 x_str.c_str (), a_str. c_str ()); 2735 x_str.c_str (), a_str. c_str ());
2765 } 2736 }
2766 2737
2738 NDArray retval;
2739 NDArray result (dv);
2740
2741 bool err;
2742
2743 for (octave_idx_type i = 0; i < nel; i++)
2744 {
2745 result(i) = gammainc (x(i), a(i), err);
2746
2747 if (err)
2748 goto done; // FIXME: why not just use return to exit?
2749 }
2750
2751 retval = result;
2752
2767 done: 2753 done:
2768 2754
2769 return retval; 2755 return retval;
2770 } 2756 }
2771 2757
2777 err = false; 2763 err = false;
2778 2764
2779 if (a < 0.0 || x < 0.0) 2765 if (a < 0.0 || x < 0.0)
2780 (*current_liboctave_error_handler) 2766 (*current_liboctave_error_handler)
2781 ("gammainc: A and X must be non-negative"); 2767 ("gammainc: A and X must be non-negative");
2782 else 2768
2783 F77_XFCN (xsgammainc, XSGAMMAINC, (a, x, retval)); 2769 F77_XFCN (xsgammainc, XSGAMMAINC, (a, x, retval));
2784 2770
2785 return retval; 2771 return retval;
2786 } 2772 }
2787 2773
2788 FloatMatrix 2774 FloatMatrix
2800 for (octave_idx_type i = 0; i < nr; i++) 2786 for (octave_idx_type i = 0; i < nr; i++)
2801 { 2787 {
2802 result(i,j) = gammainc (x, a(i,j), err); 2788 result(i,j) = gammainc (x, a(i,j), err);
2803 2789
2804 if (err) 2790 if (err)
2805 goto done; 2791 goto done; // FIXME: why not just use return to exit?
2806 } 2792 }
2807 2793
2808 retval = result; 2794 retval = result;
2809 2795
2810 done: 2796 done:
2827 for (octave_idx_type i = 0; i < nr; i++) 2813 for (octave_idx_type i = 0; i < nr; i++)
2828 { 2814 {
2829 result(i,j) = gammainc (x(i,j), a, err); 2815 result(i,j) = gammainc (x(i,j), a, err);
2830 2816
2831 if (err) 2817 if (err)
2832 goto done; 2818 goto done; // FIXME: why not just use return to exit?
2833 } 2819 }
2834 2820
2835 retval = result; 2821 retval = result;
2836 2822
2837 done: 2823 done:
2849 octave_idx_type nc = x.cols (); 2835 octave_idx_type nc = x.cols ();
2850 2836
2851 octave_idx_type a_nr = a.rows (); 2837 octave_idx_type a_nr = a.rows ();
2852 octave_idx_type a_nc = a.cols (); 2838 octave_idx_type a_nc = a.cols ();
2853 2839
2854 if (nr == a_nr && nc == a_nc) 2840 if (nr != a_nr || nc != a_nc)
2855 {
2856 result.resize (nr, nc);
2857
2858 bool err;
2859
2860 for (octave_idx_type j = 0; j < nc; j++)
2861 for (octave_idx_type i = 0; i < nr; i++)
2862 {
2863 result(i,j) = gammainc (x(i,j), a(i,j), err);
2864
2865 if (err)
2866 goto done;
2867 }
2868
2869 retval = result;
2870 }
2871 else
2872 (*current_liboctave_error_handler) 2841 (*current_liboctave_error_handler)
2873 ("gammainc: nonconformant arguments (arg 1 is %dx%d, arg 2 is %dx%d)", 2842 ("gammainc: nonconformant arguments (arg 1 is %dx%d, arg 2 is %dx%d)",
2874 nr, nc, a_nr, a_nc); 2843 nr, nc, a_nr, a_nc);
2875 2844
2845 result.resize (nr, nc);
2846
2847 bool err;
2848
2849 for (octave_idx_type j = 0; j < nc; j++)
2850 for (octave_idx_type i = 0; i < nr; i++)
2851 {
2852 result(i,j) = gammainc (x(i,j), a(i,j), err);
2853
2854 if (err)
2855 goto done; // FIXME: why not just use return to exit?
2856 }
2857
2858 retval = result;
2859
2876 done: 2860 done:
2877 2861
2878 return retval; 2862 return retval;
2879 } 2863 }
2880 2864
2892 for (octave_idx_type i = 0; i < nel; i++) 2876 for (octave_idx_type i = 0; i < nel; i++)
2893 { 2877 {
2894 result(i) = gammainc (x, a(i), err); 2878 result(i) = gammainc (x, a(i), err);
2895 2879
2896 if (err) 2880 if (err)
2897 goto done; 2881 goto done; // FIXME: why not just use return to exit?
2898 } 2882 }
2899 2883
2900 retval = result; 2884 retval = result;
2901 2885
2902 done: 2886 done:
2918 for (octave_idx_type i = 0; i < nel; i++) 2902 for (octave_idx_type i = 0; i < nel; i++)
2919 { 2903 {
2920 result(i) = gammainc (x(i), a, err); 2904 result(i) = gammainc (x(i), a, err);
2921 2905
2922 if (err) 2906 if (err)
2923 goto done; 2907 goto done; // FIXME: why not just use return to exit?
2924 } 2908 }
2925 2909
2926 retval = result; 2910 retval = result;
2927 2911
2928 done: 2912 done:
2937 octave_idx_type nel = dv.numel (); 2921 octave_idx_type nel = dv.numel ();
2938 2922
2939 FloatNDArray retval; 2923 FloatNDArray retval;
2940 FloatNDArray result; 2924 FloatNDArray result;
2941 2925
2942 if (dv == a.dims ()) 2926 if (dv != a.dims ())
2943 {
2944 result.resize (dv);
2945
2946 bool err;
2947
2948 for (octave_idx_type i = 0; i < nel; i++)
2949 {
2950 result(i) = gammainc (x(i), a(i), err);
2951
2952 if (err)
2953 goto done;
2954 }
2955
2956 retval = result;
2957 }
2958 else
2959 { 2927 {
2960 std::string x_str = dv.str (); 2928 std::string x_str = dv.str ();
2961 std::string a_str = a.dims ().str (); 2929 std::string a_str = a.dims ().str ();
2962 2930
2963 (*current_liboctave_error_handler) 2931 (*current_liboctave_error_handler)
2964 ("gammainc: nonconformant arguments (arg 1 is %s, arg 2 is %s)", 2932 ("gammainc: nonconformant arguments (arg 1 is %s, arg 2 is %s)",
2965 x_str.c_str (), a_str.c_str ()); 2933 x_str.c_str (), a_str.c_str ());
2966 } 2934 }
2935
2936 result.resize (dv);
2937
2938 bool err;
2939
2940 for (octave_idx_type i = 0; i < nel; i++)
2941 {
2942 result(i) = gammainc (x(i), a(i), err);
2943
2944 if (err)
2945 goto done; // FIXME: why not just use return to exit?
2946 }
2947
2948 retval = result;
2967 2949
2968 done: 2950 done:
2969 2951
2970 return retval; 2952 return retval;
2971 } 2953 }
3305 value = y; 3287 value = y;
3306 3288
3307 // Test for admissibility of parameters. 3289 // Test for admissibility of parameters.
3308 3290
3309 if (p <= 0.0 || q <= 0.0) 3291 if (p <= 0.0 || q <= 0.0)
3310 { 3292 (*current_liboctave_error_handler) ("betaincinv: wrong parameters");
3311 (*current_liboctave_error_handler)
3312 ("betaincinv: wrong parameters");
3313 }
3314
3315 if (y < 0.0 || 1.0 < y) 3293 if (y < 0.0 || 1.0 < y)
3316 { 3294 (*current_liboctave_error_handler) ("betaincinv: wrong parameter Y");
3317 (*current_liboctave_error_handler)
3318 ("betaincinv: wrong parameter Y");
3319 }
3320 3295
3321 if (y == 0.0 || y == 1.0) 3296 if (y == 0.0 || y == 1.0)
3322 { 3297 return value;
3323 return value;
3324 }
3325 3298
3326 // Change tail if necessary. 3299 // Change tail if necessary.
3327 3300
3328 if (0.5 < y) 3301 if (0.5 < y)
3329 { 3302 {