fsolve: check if evalf() return value is actually a number.

[ginac.git] / ginac / inifcns.cpp

diff --git a/ginac/inifcns.cpp b/ginac/inifcns.cpp
index 63c2d74f556d74c2c9cce124729107695a3bdf43..f366e779e70fbdb18a64e0447b8b21263f3704ee 100644 (file)
--- a/ginac/inifcns.cpp
+++ b/ginac/inifcns.cpp
@@ -319,8 +319,8 @@ REGISTER_FUNCTION(step, eval_func(step_eval).
                         evalf_func(step_evalf).
                         series_func(step_series).
                         conjugate_func(step_conjugate).
-                                                               real_part_func(step_real_part).
-                                                               imag_part_func(step_imag_part));
+                        real_part_func(step_real_part).
+                        imag_part_func(step_imag_part));
 
 //////////
 // Complex sign
@@ -643,10 +643,25 @@ static ex Li2_series(const ex &x, const relational &rel, int order, unsigned opt
        throw do_taylor();  // caught by function::series()
 }
 
+static ex Li2_conjugate(const ex & x)
+{
+       // conjugate(Li2(x))==Li2(conjugate(x)) unless on the branch cuts which
+       // run along the positive real axis beginning at 1.
+       if (x.info(info_flags::negative)) {
+               return Li2(x);
+       }
+       if (is_exactly_a<numeric>(x) &&
+           (!x.imag_part().is_zero() || x < *_num1_p)) {
+               return Li2(x.conjugate());
+       }
+       return conjugate_function(Li2(x)).hold();
+}
+
 REGISTER_FUNCTION(Li2, eval_func(Li2_eval).
                        evalf_func(Li2_evalf).
                        derivative_func(Li2_deriv).
                        series_func(Li2_series).
+                       conjugate_func(Li2_conjugate).
                        latex_name("\\mathrm{Li}_2"));
 
 //////////
@@ -992,8 +1007,16 @@ fsolve(const ex& f_in, const symbol& x, const numeric& x1, const numeric& x2)
        do {
                xxprev = xx[side];
                fxprev = fx[side];
-               xx[side] += ex_to<numeric>(ff.subs(x==xx[side]).evalf());
-               fx[side] = ex_to<numeric>(f.subs(x==xx[side]).evalf());
+               ex dx_ = ff.subs(x == xx[side]).evalf();
+               if (!is_a<numeric>(dx_))
+                       throw std::runtime_error("fsolve(): function derivative does not evaluate numerically");
+               xx[side] += ex_to<numeric>(dx_);
+
+               ex f_x = f.subs(x == xx[side]).evalf();
+               if (!is_a<numeric>(f_x))
+                       throw std::runtime_error("fsolve(): function does not evaluate numerically");
+               fx[side] = ex_to<numeric>(f_x);
+
                if ((side==0 && xx[0]<xxprev) || (side==1 && xx[1]>xxprev) || xx[0]>xx[1]) {
                        // Oops, Newton-Raphson method shot out of the interval.
                        // Restore, and try again with the other side instead!
@@ -1002,8 +1025,16 @@ fsolve(const ex& f_in, const symbol& x, const numeric& x1, const numeric& x2)
                        side = !side;
                        xxprev = xx[side];
                        fxprev = fx[side];
-                       xx[side] += ex_to<numeric>(ff.subs(x==xx[side]).evalf());
-                       fx[side] = ex_to<numeric>(f.subs(x==xx[side]).evalf());
+
+                       ex dx_ = ff.subs(x == xx[side]).evalf();
+                       if (!is_a<numeric>(dx_))
+                               throw std::runtime_error("fsolve(): function derivative does not evaluate numerically [2]");
+                       xx[side] += ex_to<numeric>(dx_);
+
+                       ex f_x = f.subs(x==xx[side]).evalf();
+                       if (!is_a<numeric>(f_x))
+                               throw std::runtime_error("fsolve(): function does not evaluate numerically [2]");
+                       fx[side] = ex_to<numeric>(f_x);
                }
                if ((fx[side]<0 && fx[!side]<0) || (fx[side]>0 && fx[!side]>0)) {
                        // Oops, the root isn't bracketed any more.
@@ -1027,7 +1058,10 @@ fsolve(const ex& f_in, const symbol& x, const numeric& x1, const numeric& x2)
                        static const double secant_weight = 0.984375;  // == 63/64 < 1
                        numeric xxmid = (1-secant_weight)*0.5*(xx[0]+xx[1])
                            + secant_weight*(xx[0]+fx[0]*(xx[0]-xx[1])/(fx[1]-fx[0]));
-                       numeric fxmid = ex_to<numeric>(f.subs(x==xxmid).evalf());
+                       ex fxmid_ = f.subs(x == xxmid).evalf();
+                       if (!is_a<numeric>(fxmid_))
+                               throw std::runtime_error("fsolve(): function does not evaluate numerically [3]");
+                       numeric fxmid = ex_to<numeric>(fxmid_);
                        if (fxmid.is_zero()) {
                                // Luck strikes...
                                return xxmid;