ginac/expair.h

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