* Fix a bitch of a bug where 1<I (and all other relationals) returned true.

  This did not happen for the binary relational operators between numerics.
  Now the behaviour is more consistent (throwing exceptions when the difference
  becomes complex).
* Some regression tests were actually wrong in the light of this bug.  :-(

diff --git a/check/check_inifcns.cpp b/check/check_inifcns.cpp
index b5945d2e15cca0124fded728120d6cebee96965a..3069c4d51d1ae9b000021eee7dd124cd96deffbf 100644 (file)
--- a/check/check_inifcns.cpp
+++ b/check/check_inifcns.cpp
@@ -178,7 +178,7 @@ static unsigned inifcns_check_Li2(void)
                argument = numeric(20.0*rand()/(RAND_MAX+1.0)-10.0)
                         + numeric(20.0*rand()/(RAND_MAX+1.0)-10.0)*I;
                if (abs(Li2(pow(argument,2))-2*Li2(argument)-2*Li2(-argument)) > epsilon) {
-                       cout << "Li2(z) at z==" << argument
+                       clog << "Li2(z) at z==" << argument
                             << " failed to satisfy Li2(z^2)==2*(Li2(z)+Li2(-z))" << endl;
                        errorflag = true;
                }

diff --git a/check/check_numeric.cpp b/check/check_numeric.cpp
index 3c569357f8c456210d52eee75ca6a8229ef56fad..ae15454566d77c9c855b92b87e01f273501b0275 100644 (file)
--- a/check/check_numeric.cpp
+++ b/check/check_numeric.cpp
@@ -60,7 +60,7 @@ static unsigned check_numeric2(void)
        int i_num, i_den;
        
        // Check non-nested radicals (n/d)^(m/n) in ex wrapper class:
-       for (int i=0; i<200; ++i) {  // FIXME: run to ~200
+       for (int i=0; i<200; ++i) {
                for (int j=2; j<13; ++j) {
                        // construct an exponent 1/j...
                        numeric nm(1,j);
@@ -81,7 +81,7 @@ static unsigned check_numeric2(void)
                                     << radical << endl;
                                errorflag = true;
                        }
-                       numeric ratio = ex_to<numeric>(evalf(radical))/floating;
+                       numeric ratio = ex_to<numeric>(abs(evalf(radical)))/floating;
                        if (ratio>1.0001 && ratio<0.9999) {
                                clog << "(" << num << "/" << den << ")^(" << nm
                                     << ") erroneously evaluated to " << radical;

diff --git a/ginac/power.cpp b/ginac/power.cpp
index 97b0f6f0c051a56975618f9a073836ff6a580ecb..47efc2fd3806583b0e61197354111f090b11755e 100644 (file)
--- a/ginac/power.cpp
+++ b/ginac/power.cpp
@@ -49,7 +49,7 @@ typedef std::vector<int> intvector;
 // default ctor, dtor, copy ctor assignment operator and helpers
 //////////
 
-power::power() : basic(TINFO_power)
+power::power() : inherited(TINFO_power)
 {
        debugmsg("power default ctor",LOGLEVEL_CONSTRUCT);
 }
@@ -67,14 +67,14 @@ DEFAULT_DESTROY(power)
 // other ctors
 //////////
 
-power::power(const ex & lh, const ex & rh) : basic(TINFO_power), basis(lh), exponent(rh)
+power::power(const ex & lh, const ex & rh) : inherited(TINFO_power), basis(lh), exponent(rh)
 {
        debugmsg("power ctor from ex,ex",LOGLEVEL_CONSTRUCT);
 }
 
 /** Ctor from an ex and a bare numeric.  This is somewhat more efficient than
  *  the normal ctor from two ex whenever it can be used. */
-power::power(const ex & lh, const numeric & rh) : basic(TINFO_power), basis(lh), exponent(rh)
+power::power(const ex & lh, const numeric & rh) : inherited(TINFO_power), basis(lh), exponent(rh)
 {
        debugmsg("power ctor from ex,numeric",LOGLEVEL_CONSTRUCT);
 }

diff --git a/ginac/relational.cpp b/ginac/relational.cpp
index 0bc6c70f21c08c810243caaa8f6a96edb6558b49..f657f8100d96ef67a5d1200bc3c4cdb04baf85db 100644 (file)
--- a/ginac/relational.cpp
+++ b/ginac/relational.cpp
@@ -242,30 +242,31 @@ ex relational::rhs(void) const
 // non-virtual functions in this class
 //////////
 
+/** Cast the relational into a boolean, mainly for evaluation within an 
+ *  if-statement.  Note that (a<b) == false does not imply (a>=b) == true in
+ *  the general symbolic case.  A false result means the comparison is either
+ *  false or undecidable (except of course for !=, where true means either
+ *  unequal or undecidable). */
 relational::operator bool() const
 {
-       // please note that (a<b) == false does not imply (a>=b) == true
-       // a false result means the comparison is either false or undecidable
-       // (except for !=, where true means unequal or undecidable)
-       ex df = lh-rh;
+       const ex df = lh-rh;
        if (!is_ex_exactly_of_type(df,numeric))
                // cannot decide on non-numerical results
                return o==not_equal ? true : false;
        
-       int cmpval = ex_to<numeric>(df).compare(_num0());
        switch (o) {
        case equal:
-               return cmpval==0;
+               return ex_to<numeric>(df).is_zero();
        case not_equal:
-               return cmpval!=0;
+               return !ex_to<numeric>(df).is_zero();
        case less:
-               return cmpval<0;
+               return ex_to<numeric>(df)<_num0();
        case less_or_equal:
-               return cmpval<=0;
+               return ex_to<numeric>(df)<=_num0();
        case greater:
-               return cmpval>0;
+               return ex_to<numeric>(df)>_num0();
        case greater_or_equal:
-               return cmpval>=0;
+               return ex_to<numeric>(df)>=_num0();
        default:
                throw(std::logic_error("invalid relational operator"));
        }