X-Git-Url: https://www.ginac.de/ginac.git//ginac.git?p=ginac.git;a=blobdiff_plain;f=ginac%2Frelational.cpp;h=c4e34ddfd34ca44958e37632d6e041969f08680b;hp=82b4bb93f0b057b8ae826ad319ca18e47dee7f67;hb=ff7eeaa487dca86b36ddbb19b1dcefb2134327be;hpb=591b85b0697370f2f5f25a29a1e94ff831a02c12

diff --git a/ginac/relational.cpp b/ginac/relational.cpp
index 82b4bb93..c4e34ddf 100644
--- 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
@@ -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);
@@ -204,21 +193,24 @@ 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;
+	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_of_type(other, relational));
+	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"));
 	}