* create dirs ${prefix}/share/doc/GiNaC/{tutorial,reference} only if

[ginac.git] / ginac / relational.cpp

diff --git a/ginac/relational.cpp b/ginac/relational.cpp
index 0bc6c70f21c08c810243caaa8f6a96edb6558b49..d0beb95205e138dbcefae8766077fca089fa67e4 100644 (file)
--- a/ginac/relational.cpp
+++ b/ginac/relational.cpp
@@ -20,6 +20,7 @@
  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 
+#include <iostream>
 #include <stdexcept>
 
 #include "relational.h"
@@ -27,20 +28,16 @@
 #include "print.h"
 #include "archive.h"
 #include "utils.h"
-#include "debugmsg.h"
 
 namespace GiNaC {
 
 GINAC_IMPLEMENT_REGISTERED_CLASS(relational, basic)
 
 //////////
-// default ctor, dtor, copy ctor assignment operator and helpers
+// default ctor, dtor, copy ctor, assignment operator and helpers
 //////////
 
-relational::relational() : basic(TINFO_relational)
-{
-       debugmsg("relational default ctor",LOGLEVEL_CONSTRUCT);
-}
+relational::relational() : basic(TINFO_relational) {}
 
 void relational::copy(const relational & other)
 {
@@ -58,13 +55,7 @@ DEFAULT_DESTROY(relational)
 
 // public
 
-relational::relational(const ex & lhs, const ex & rhs, operators oper) : basic(TINFO_relational)
-{
-       debugmsg("relational ctor ex,ex,operator",LOGLEVEL_CONSTRUCT);
-       lh=lhs;
-       rh=rhs;
-       o=oper;
-}
+relational::relational(const ex & lhs, const ex & rhs, operators oper) : basic(TINFO_relational), lh(lhs), rh(rhs), o(oper) {}
 
 //////////
 // archiving
@@ -72,7 +63,6 @@ relational::relational(const ex & lhs, const ex & rhs, operators oper) : basic(T
 
 relational::relational(const archive_node &n, const lst &sym_lst) : inherited(n, sym_lst)
 {
-       debugmsg("relational ctor from archive_node", LOGLEVEL_CONSTRUCT);
        unsigned int opi;
        if (!(n.find_unsigned("op", opi)))
                throw (std::runtime_error("unknown relational operator in archive"));
@@ -92,16 +82,14 @@ 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
 
 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);
 
@@ -192,22 +180,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
@@ -242,30 +233,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"));
        }