ginac/expair.h

   1 /** @file expair.h
   2  *
   3  *  Definition of expression pairs (building blocks of expairseq). */
   4
   5 /*
   6  *  GiNaC Copyright (C) 1999-2000 Johannes Gutenberg University Mainz, Germany
   7  *
   8  *  This program is free software; you can redistribute it and/or modify
   9  *  it under the terms of the GNU General Public License as published by
  10  *  the Free Software Foundation; either version 2 of the License, or
  11  *  (at your option) any later version.
  12  *
  13  *  This program is distributed in the hope that it will be useful,
  14  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  *  GNU General Public License for more details.
  17  *
  18  *  You should have received a copy of the GNU General Public License
  19  *  along with this program; if not, write to the Free Software
  20  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  21  */
  22
  23 #ifndef __GINAC_EXPAIR_H__
  24 #define __GINAC_EXPAIR_H__
  25
  26 #include <ginac/ex.h>
  27 #include <ginac/numeric.h>
  28
  29 #ifndef NO_GINAC_NAMESPACE
  30 namespace GiNaC {
  31 #endif // ndef NO_GINAC_NAMESPACE
  32
  33 /** A pair of expressions.
  34  *  This similar to, but slightly extended STL's pair<> but we need to account
  35  *  for methods like .compare() */
  36 class expair
  37 {
  38 public:
  39     expair() {}
  40     ~expair() {}
  41     expair(const expair & other) : rest(other.rest), coeff(other.coeff)
  42     {
  43         GINAC_ASSERT(is_ex_exactly_of_type(coeff,numeric));
  44     }
  45     const expair & operator=(const expair & other)
  46     {
  47         if (this != &other) {
  48             rest=other.rest;
  49             coeff=other.coeff;
  50         }
  51         return *this;
  52     }
  53     expair(const ex & r, const ex & c) : rest(r), coeff(c)
  54     {
  55         GINAC_ASSERT(is_ex_exactly_of_type(coeff,numeric));
  56     }
  57
  58     bool is_numeric_with_coeff_1(void) const
  59     {
  60         GINAC_ASSERT(is_ex_exactly_of_type(coeff,numeric));
  61         return is_ex_exactly_of_type(rest,numeric) &&
  62                (coeff.is_equal(ex(1)));
  63     }
  64
  65     bool is_equal(const expair & other) const
  66     {
  67         return (rest.is_equal(other.rest) && coeff.is_equal(other.coeff));
  68     }
  69     bool is_less(const expair & other) const
  70     {
  71         return (rest.compare(other.rest)<0) ||
  72                (!(other.rest.compare(rest)<0) && (coeff.compare(other.coeff)<0));
  73     }
  74     int compare(const expair & other) const
  75     {
  76         int cmpval=rest.compare(other.rest);
  77         if (cmpval!=0) return cmpval;
  78         cmpval=coeff.compare(other.coeff);
  79         return cmpval;
  80     }
  81
  82     bool is_less_old2(const expair & other) const
  83     {
  84         /*
  85         bool this_numeric_with_coeff_1=is_numeric_with_coeff_1();
  86         bool other_numeric_with_coeff_1=other.is_numeric_with_coeff_1();
  87         if (this_numeric_with_coeff_1) {
  88             if (other_numeric_with_coeff_1) {
  89                 // both have coeff 1: compare rests
  90                 return rest.compare(other.rest)<0;
  91             }
  92             // only this has coeff 1: >
  93             return false;
  94         } else if (other_numeric_with_coeff_1) {
  95             // only other has coeff 1: <
  96             return true;
  97         }
  98         return (rest.compare(other.rest)<0) ||
  99                (!(other.rest.compare(rest)<0) &&
 100                  (coeff.compare(other.coeff)<0));
 101         */
 102         if (is_ex_exactly_of_type(rest,numeric) &&
 103             is_ex_exactly_of_type(other.rest,numeric)) {
 104             if (coeff.is_equal(ex(1))) {
 105                 if ((other.coeff).is_equal(ex(1))) {
 106                     // both have coeff 1: compare rests
 107                     return rest.compare(other.rest)<0;
 108                 }
 109                 // only this has coeff 1: >
 110                 return false;
 111             } else if ((other.coeff).is_equal(ex(1))) {
 112                 // only other has coeff 1: <
 113                 return true;
 114             }
 115             // neither has coeff 1: usual compare
 116         }
 117         return (rest.compare(other.rest)<0) ||
 118                (!(other.rest.compare(rest)<0) &&
 119                  (coeff.compare(other.coeff)<0));
 120     }
 121     int compare_old2(const expair & other) const
 122     {
 123         if (is_ex_exactly_of_type(rest,numeric) &&
 124             is_ex_exactly_of_type(other.rest,numeric)) {
 125             if ((coeff).is_equal(ex(1))) {
 126                 if ((other.coeff).is_equal(ex(1))) {
 127                     // both have coeff 1: compare rests
 128                     return rest.compare(other.rest);
 129                 }
 130                 // only this has coeff 1: >
 131                 return 1;
 132             } else if ((other.coeff).is_equal(ex(1))) {
 133                 // only other has coeff 1: <
 134                 return -1;
 135             }
 136             // neither has coeff 1: usual compare
 137         }
 138         /*
 139         bool this_numeric_with_coeff_1=is_numeric_with_coeff_1();
 140         bool other_numeric_with_coeff_1=other.is_numeric_with_coeff_1();
 141         if (this_numeric_with_coeff_1) {
 142             if (other_numeric_with_coeff_1) {
 143                 // both have coeff 1: compare rests
 144                 return rest.compare(other.rest);
 145             }
 146             // only this has coeff 1: >
 147             return 1;
 148         } else if (other_numeric_with_coeff_1) {
 149             // only other has coeff 1: <
 150             return -1;
 151             // neither has coeff 1: usual compare
 152         }
 153         */
 154         int cmpval=rest.compare(other.rest);
 155         if (cmpval!=0) return cmpval;
 156         return coeff.compare(other.coeff);
 157     }
 158     bool is_less_old(const expair & other) const
 159     {
 160         return (rest.compare(other.rest)<0) ||
 161                (!(other.rest.compare(rest)<0) && (coeff.compare(other.coeff)<0));
 162     }
 163     int compare_old(const expair & other) const
 164     {
 165         int cmpval=rest.compare(other.rest);
 166         if (cmpval!=0) return cmpval;
 167         cmpval=coeff.compare(other.coeff);
 168         return cmpval;
 169     }
 170
 171     void printraw(ostream & os) const
 172     {
 173         os << "expair(";
 174         rest.printraw(os);
 175         os << ",";
 176         coeff.printraw(os);
 177         os << ")";
 178     }
 179
 180     ex rest;
 181     ex coeff;
 182 };
 183
 184 class expair_is_less
 185 {
 186 public:
 187     bool operator()(const expair & lh, const expair & rh) const
 188     {
 189         return lh.is_less(rh);
 190     }
 191 };
 192
 193 class expair_is_less_old
 194 {
 195 public:
 196     bool operator()(const expair & lh, const expair & rh) const
 197     {
 198         return lh.is_less_old(rh);
 199     }
 200 };
 201
 202 #ifndef NO_GINAC_NAMESPACE
 203 } // namespace GiNaC
 204 #endif // ndef NO_GINAC_NAMESPACE
 205
 206 #endif // ndef __GINAC_EXPAIR_H__