ginac/expair.h

   1 /** @file expair.h */
   2
   3 /** A pair of expressions.
   4  *  This similar to, but slightly extended STL's pair<> but we need to account
   5  *  for methods like .compare() */
   6 class expair
   7 {
   8 public:
   9     expair() {}
  10     ~expair() {}
  11     expair(expair const & other) : rest(other.rest), coeff(other.coeff)
  12     {
  13         ASSERT(is_ex_exactly_of_type(coeff,numeric));
  14     }
  15     expair const & operator=(expair const & other)
  16     {
  17         if (this != &other) {
  18             rest=other.rest;
  19             coeff=other.coeff;
  20         }
  21         return *this;
  22     }
  23     expair(ex const & r, ex const & c) : rest(r), coeff(c)
  24     {
  25         ASSERT(is_ex_exactly_of_type(coeff,numeric));
  26     }
  27
  28     bool is_numeric_with_coeff_1(void) const
  29     {
  30         ASSERT(is_ex_exactly_of_type(coeff,numeric));
  31         return is_ex_exactly_of_type(rest,numeric) &&
  32                (ex_to_numeric(coeff).compare(numONE())==0);
  33     }
  34
  35     bool is_equal(expair const & other) const
  36     {
  37         return (rest.is_equal(other.rest) && coeff.is_equal(other.coeff));
  38     }
  39     bool is_less(expair const & other) const
  40     {
  41         return (rest.compare(other.rest)<0) ||
  42                (!(other.rest.compare(rest)<0) && (coeff.compare(other.coeff)<0));
  43     }
  44     int compare(expair const & other) const
  45     {
  46         int cmpval=rest.compare(other.rest);
  47         if (cmpval!=0) return cmpval;
  48         cmpval=coeff.compare(other.coeff);
  49         return cmpval;
  50     }
  51
  52     bool is_less_old2(expair const & other) const
  53     {
  54         /*
  55         bool this_numeric_with_coeff_1=is_numeric_with_coeff_1();
  56         bool other_numeric_with_coeff_1=other.is_numeric_with_coeff_1();
  57         if (this_numeric_with_coeff_1) {
  58             if (other_numeric_with_coeff_1) {
  59                 // both have coeff 1: compare rests
  60                 return rest.compare(other.rest)<0;
  61             }
  62             // only this has coeff 1: >
  63             return false;
  64         } else if (other_numeric_with_coeff_1) {
  65             // only other has coeff 1: <
  66             return true;
  67         }
  68         return (rest.compare(other.rest)<0) ||
  69                (!(other.rest.compare(rest)<0) &&
  70                  (coeff.compare(other.coeff)<0));
  71         */
  72         if (is_ex_exactly_of_type(rest,numeric) &&
  73             is_ex_exactly_of_type(other.rest,numeric)) {
  74             if (ex_to_numeric(coeff).compare(numONE())==0) {
  75                 if (ex_to_numeric(other.coeff).compare(numONE())==0) {
  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 (ex_to_numeric(other.coeff).compare(numONE())==0) {
  82                 // only other has coeff 1: <
  83                 return true;
  84             }
  85             // neither has coeff 1: usual compare
  86         }
  87         return (rest.compare(other.rest)<0) ||
  88                (!(other.rest.compare(rest)<0) &&
  89                  (coeff.compare(other.coeff)<0));
  90     }
  91     int compare_old2(expair const & other) const
  92     {
  93         if (is_ex_exactly_of_type(rest,numeric) &&
  94             is_ex_exactly_of_type(other.rest,numeric)) {
  95             if (ex_to_numeric(coeff).compare(numONE())==0) {
  96                 if (ex_to_numeric(other.coeff).compare(numONE())==0) {
  97                     // both have coeff 1: compare rests
  98                     return rest.compare(other.rest);
  99                 }
 100                 // only this has coeff 1: >
 101                 return 1;
 102             } else if (ex_to_numeric(other.coeff).compare(numONE())==0) {
 103                 // only other has coeff 1: <
 104                 return -1;
 105             }
 106             // neither has coeff 1: usual compare
 107         }
 108         /*
 109         bool this_numeric_with_coeff_1=is_numeric_with_coeff_1();
 110         bool other_numeric_with_coeff_1=other.is_numeric_with_coeff_1();
 111         if (this_numeric_with_coeff_1) {
 112             if (other_numeric_with_coeff_1) {
 113                 // both have coeff 1: compare rests
 114                 return rest.compare(other.rest);
 115             }
 116             // only this has coeff 1: >
 117             return 1;
 118         } else if (other_numeric_with_coeff_1) {
 119             // only other has coeff 1: <
 120             return -1;
 121             // neither has coeff 1: usual compare
 122         }
 123         */
 124         int cmpval=rest.compare(other.rest);
 125         if (cmpval!=0) return cmpval;
 126         return coeff.compare(other.coeff);
 127     }
 128     bool is_less_old(expair const & other) const
 129     {
 130         return (rest.compare(other.rest)<0) ||
 131                (!(other.rest.compare(rest)<0) && (coeff.compare(other.coeff)<0));
 132     }
 133     int compare_old(expair const & other) const
 134     {
 135         int cmpval=rest.compare(other.rest);
 136         if (cmpval!=0) return cmpval;
 137         cmpval=coeff.compare(other.coeff);
 138         return cmpval;
 139     }
 140
 141     void printraw(ostream & os) const
 142     {
 143         os << "expair(";
 144         rest.printraw(os);
 145         os << ",";
 146         coeff.printraw(os);
 147         os << ")";
 148     }
 149
 150     ex rest;
 151     ex coeff;
 152 };
 153
 154 class expair_is_less
 155 {
 156 public:
 157     bool operator()(expair const & lh, expair const & rh) const
 158     {
 159         return lh.is_less(rh);
 160     }
 161 };
 162
 163 class expair_is_less_old
 164 {
 165 public:
 166     bool operator()(expair const & lh, expair const & rh) const
 167     {
 168         return lh.is_less_old(rh);
 169     }
 170 };
 171
 172
 173