* Some internal reorganization WRT flyweight handling and initialization,

[ginac.git] / ginac / relational.cpp

diff --git a/ginac/relational.cpp b/ginac/relational.cpp
index 82b4bb93f0b057b8ae826ad319ca18e47dee7f67..9d50fee22ff787ecac5314b22aaae3bb9b9f6c1d 100644 (file)
--- a/ginac/relational.cpp
+++ b/ginac/relational.cpp
@@ -92,7 +92,7 @@ void relational::archive(archive_node &n) const
 DEFAULT_UNARCHIVE(relational)
 
 //////////
-// functions overriding virtual functions from bases classes
+// functions overriding virtual functions from base classes
 //////////
 
 // public
@@ -101,7 +101,7 @@ void relational::print(const print_context & c, unsigned level) const
 {
        debugmsg("relational print",LOGLEVEL_PRINT);
 
-       if (is_of_type(c, print_tree)) {
+       if (is_a<print_tree>(c)) {
 
                inherited::print(c, level);
 
@@ -183,17 +183,6 @@ ex relational::eval(int level) const
        return (new relational(lh.eval(level-1),rh.eval(level-1),o))->setflag(status_flags::dynallocated | status_flags::evaluated);
 }
 
-ex relational::evalf(int level) const
-{
-       if (level==1)
-               return *this;
-       
-       if (level==-max_recursion_level)
-               throw(std::runtime_error("max recursion level reached"));
-       
-       return (new relational(lh.eval(level-1),rh.eval(level-1),o))->setflag(status_flags::dynallocated);
-}
-
 ex relational::simplify_ncmul(const exvector & v) const
 {
        return lh.simplify_ncmul(v);
@@ -203,22 +192,25 @@ ex relational::simplify_ncmul(const exvector & v) const
 
 int relational::compare_same_type(const basic & other) const
 {
-       GINAC_ASSERT(is_exactly_of_type(other, relational));
-       const relational & oth=static_cast<const relational &>(const_cast<basic &>(other));
-       
-       int cmpval;
+       GINAC_ASSERT(is_exactly_a<relational>(other));
+       const relational &oth = static_cast<const relational &>(other);
        
        if (o == oth.o) {
-               cmpval = lh.compare(oth.lh);
-               if (cmpval==0)
-                       return rh.compare(oth.rh);
-               else
+               int cmpval = lh.compare(oth.lh);
+               if (cmpval)
                        return cmpval;
+               else
+                       return rh.compare(oth.rh);
        }
-       if (o<oth.o)
-               return -1;
-       else
-               return 1;
+       return (o < oth.o) ? -1 : 1;
+}
+
+bool relational::match_same_type(const basic & other) const
+{
+       GINAC_ASSERT(is_exactly_a<relational>(other));
+       const relational &oth = static_cast<const relational &>(other);
+
+       return o == oth.o;
 }
 
 unsigned relational::return_type(void) const
@@ -253,30 +245,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"));
        }