base/mod_num.hh

   1 /*
   2  * Copyright (c) 2003 The Regents of The University of Michigan
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions are
   7  * met: redistributions of source code must retain the above copyright
   8  * notice, this list of conditions and the following disclaimer;
   9  * redistributions in binary form must reproduce the above copyright
  10  * notice, this list of conditions and the following disclaimer in the
  11  * documentation and/or other materials provided with the distribution;
  12  * neither the name of the copyright holders nor the names of its
  13  * contributors may be used to endorse or promote products derived from
  14  * this software without specific prior written permission.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  17  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  18  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  19  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  20  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  21  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  22  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  23  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  24  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  26  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27  */
  28
  29 template<class T, T MV>
  30 class ModNum {
  31   private:
  32     T value;
  33
  34     //  Compiler should optimize this
  35     void setValue(T n) { value = n % MV; }
  36
  37   public:
  38     ModNum() {}
  39     ModNum(T n) { setValue(n); }
  40     ModNum(const ModNum<T, MV> &n) : value(n.value) {}
  41
  42     ModNum operator=(T n) {
  43         setValue(n);
  44         return *this;
  45     }
  46
  47     const ModNum operator=(ModNum n) {
  48         value = n.value;
  49         return *this;
  50     }
  51
  52     //  Return the value if object used as RHS
  53     operator T() const { return value; }
  54
  55     //
  56     //  Operator "+="
  57     //
  58     const ModNum<T, MV> operator+=(ModNum<T, MV> r) {
  59         setValue(value + r.value);
  60         return *this;
  61     }
  62
  63     const ModNum<T, MV> operator+=(T r) {
  64         setValue(value + r);
  65         return *this;
  66     }
  67
  68     //
  69     //  Operator "-="
  70     //
  71     const ModNum<T, MV> operator-=(ModNum<T, MV> r) {
  72         setValue(value - r.value);
  73         return *this;
  74     }
  75
  76     const ModNum<T, MV> operator-=(T r) {
  77         setValue(value - r);
  78         return *this;
  79     }
  80
  81     //
  82     //  Operator "++"
  83     //
  84     //  PREFIX (like ++a)
  85     const ModNum<T, MV> operator++() {
  86         *this += 1;
  87         return *this;
  88     }
  89
  90     //  POSTFIX (like a++)
  91     const ModNum<T, MV> operator++(int) {
  92         ModNum<T, MV> rv = *this;
  93
  94         *this += 1;
  95
  96         return rv;
  97     }
  98
  99     //
 100     //  Operator "--"
 101     //
 102     //  PREFIX (like --a)
 103     const ModNum<T, MV> operator--() {
 104         *this -= 1;
 105         return *this;
 106     }
 107
 108     //  POSTFIX (like a--)
 109     const ModNum<T, MV> operator--(int) {
 110         ModNum<T, MV> rv = *this;
 111         *this -= 1;
 112         return rv;
 113     }
 114 };
 115
 116
 117 //
 118 //  Define operator "+" like this to avoid creating a temporary
 119 //
 120 template<class T, T MV>
 121 inline ModNum<T, MV>
 122 operator+(ModNum<T, MV> l, ModNum<T, MV> r) {
 123     l += r;
 124     return l;
 125 }
 126
 127 template<class T, T MV>
 128 inline ModNum<T, MV>
 129 operator+(ModNum<T, MV> l, T r) {
 130     l += r;
 131     return l;
 132 }
 133
 134 template<class T, T MV>
 135 inline ModNum<T, MV>
 136 operator+(T l, ModNum<T, MV> r) {
 137     r += l;
 138     return r;
 139 }
 140
 141
 142 //
 143 //  Define operator "-" like this to avoid creating a temporary
 144 //
 145 template<class T, T MV>
 146 inline ModNum<T, MV>
 147 operator-(ModNum<T, MV> l, ModNum<T, MV> r) {
 148     l -= r;
 149     return l;
 150 }
 151
 152 template<class T, T MV>
 153 inline ModNum<T, MV>
 154 operator-(ModNum<T, MV> l, T r) {
 155     l -= r;
 156     return l;
 157 }
 158
 159 template<class T, T MV>
 160 inline ModNum<T, MV>
 161 operator-(T l, ModNum<T, MV> r) {
 162     r -= l;
 163     return r;
 164 }
 165
 166
 167 //
 168 //  Comparison operators
 169 //  (all other cases are handled with conversons)
 170 //
 171 template<class T, T MV>
 172 inline bool
 173 operator<(ModNum<T, MV> l, ModNum<T, MV> r) {
 174     return l.value < r.value;
 175 }
 176
 177 template<class T, T MV>
 178 inline bool
 179 operator>(ModNum<T, MV> l, ModNum<T, MV> r) {
 180     return l.value > r.value;
 181 }
 182
 183 template<class T, T MV>
 184 inline bool
 185 operator==(ModNum<T, MV> l, ModNum<T, MV> r) {
 186     return l.value == r.value;
 187 }
 188
 189 template<class T, T MV>
 190 inline bool
 191 operator<=(ModNum<T, MV> l, ModNum<T, MV> r) {
 192     return l.value <= r.value;
 193 }
 194
 195 template<class T, T MV>
 196 inline bool
 197 operator>=(ModNum<T, MV> l, ModNum<T, MV> r) {
 198     return l.value >= r.value;
 199 }
 200
 201