- Banned exZERO(), exONE(), exMINUSHALF() and all this from the interface.

[ginac.git] / ginac / expair.h

diff --git a/ginac/expair.h b/ginac/expair.h
index ffe953224a1a5120317097e8d2c8053176a1c940..8580598d85a98e74c46347c45716703325bd90a3 100644 (file)
--- a/ginac/expair.h
+++ b/ginac/expair.h
@@ -1,4 +1,34 @@
-/** @file expair.h */
+/** @file expair.h
+ *
+ *  Definition of expression pairs (building blocks of expairseq). */
+
+/*
+ *  GiNaC Copyright (C) 1999 Johannes Gutenberg University Mainz, Germany
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#ifndef __GINAC_EXPAIR_H__
+#define __GINAC_EXPAIR_H__
+
+#include <ginac/ex.h>
+#include <ginac/numeric.h>
+
+#ifndef NO_GINAC_NAMESPACE
+namespace GiNaC {
+#endif // ndef NO_GINAC_NAMESPACE

 
 /** A pair of expressions.
  *  This similar to, but slightly extended STL's pair<> but we need to account
 
 /** A pair of expressions.
  *  This similar to, but slightly extended STL's pair<> but we need to account


@@ -10,7 +40,7 @@ public:
     ~expair() {}
     expair(expair const & other) : rest(other.rest), coeff(other.coeff)
     {
     ~expair() {}
     expair(expair const & other) : rest(other.rest), coeff(other.coeff)
     {

-        ASSERT(is_ex_exactly_of_type(coeff,numeric));
+        GINAC_ASSERT(is_ex_exactly_of_type(coeff,numeric));

     }
     expair const & operator=(expair const & other)
     {
     }
     expair const & operator=(expair const & other)
     {


@@ -22,14 +52,14 @@ public:
     }
     expair(ex const & r, ex const & c) : rest(r), coeff(c)
     {
     }
     expair(ex const & r, ex const & c) : rest(r), coeff(c)
     {

-        ASSERT(is_ex_exactly_of_type(coeff,numeric));
+        GINAC_ASSERT(is_ex_exactly_of_type(coeff,numeric));

     }
     
     bool is_numeric_with_coeff_1(void) const
     {
     }
     
     bool is_numeric_with_coeff_1(void) const
     {

-        ASSERT(is_ex_exactly_of_type(coeff,numeric));
+        GINAC_ASSERT(is_ex_exactly_of_type(coeff,numeric));

         return is_ex_exactly_of_type(rest,numeric) &&
         return is_ex_exactly_of_type(rest,numeric) &&

-               (ex_to_numeric(coeff).compare(numONE())==0);
+               (coeff.is_equal(ex(1)));

     }
 
     bool is_equal(expair const & other) const
     }
 
     bool is_equal(expair const & other) const


@@ -71,14 +101,14 @@ public:
         */
         if (is_ex_exactly_of_type(rest,numeric) &&
             is_ex_exactly_of_type(other.rest,numeric)) {
         */
         if (is_ex_exactly_of_type(rest,numeric) &&
             is_ex_exactly_of_type(other.rest,numeric)) {

-            if (ex_to_numeric(coeff).compare(numONE())==0) {
-                if (ex_to_numeric(other.coeff).compare(numONE())==0) {
+            if (coeff.is_equal(ex(1))) {
+                if ((other.coeff).is_equal(ex(1))) {

                     // both have coeff 1: compare rests
                     return rest.compare(other.rest)<0;
                 }
                 // only this has coeff 1: >
                 return false;
                     // both have coeff 1: compare rests
                     return rest.compare(other.rest)<0;
                 }
                 // only this has coeff 1: >
                 return false;

-            } else if (ex_to_numeric(other.coeff).compare(numONE())==0) {
+            } else if ((other.coeff).is_equal(ex(1))) {

                 // only other has coeff 1: <
                 return true;
             }
                 // only other has coeff 1: <
                 return true;
             }


@@ -92,14 +122,14 @@ public:
     {
         if (is_ex_exactly_of_type(rest,numeric) &&
             is_ex_exactly_of_type(other.rest,numeric)) {
     {
         if (is_ex_exactly_of_type(rest,numeric) &&
             is_ex_exactly_of_type(other.rest,numeric)) {

-            if (ex_to_numeric(coeff).compare(numONE())==0) {
-                if (ex_to_numeric(other.coeff).compare(numONE())==0) {
+            if ((coeff).is_equal(ex(1))) {
+                if ((other.coeff).is_equal(ex(1))) {

                     // both have coeff 1: compare rests
                     return rest.compare(other.rest);
                 }
                 // only this has coeff 1: >
                 return 1;
                     // both have coeff 1: compare rests
                     return rest.compare(other.rest);
                 }
                 // only this has coeff 1: >
                 return 1;

-            } else if (ex_to_numeric(other.coeff).compare(numONE())==0) {
+            } else if ((other.coeff).is_equal(ex(1))) {

                 // only other has coeff 1: <
                 return -1;
             }
                 // only other has coeff 1: <
                 return -1;
             }


@@ -169,5 +199,8 @@ public:
     }
 };
 
     }
 };
 

+#ifndef NO_GINAC_NAMESPACE
+} // namespace GiNaC
+#endif // ndef NO_GINAC_NAMESPACE

 
 

-           
+#endif // ndef __GINAC_EXPAIR_H__