gcc/sreal.h

   1 /* Definitions for simple data type for real numbers.
   2    Copyright (C) 2002-2014 Free Software Foundation, Inc.
   3
   4 This file is part of GCC.
   5
   6 GCC is free software; you can redistribute it and/or modify it under
   7 the terms of the GNU General Public License as published by the Free
   8 Software Foundation; either version 3, or (at your option) any later
   9 version.
  10
  11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14 for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GCC; see the file COPYING3.  If not see
  18 <http://www.gnu.org/licenses/>.  */
  19
  20 #ifndef GCC_SREAL_H
  21 #define GCC_SREAL_H
  22
  23 /* SREAL_PART_BITS has to be an even number.  */
  24 #define SREAL_PART_BITS 32
  25
  26 #define UINT64_BITS     64
  27
  28 #define SREAL_MIN_SIG ((uint64_t) 1 << (SREAL_PART_BITS - 1))
  29 #define SREAL_MAX_SIG (((uint64_t) 1 << SREAL_PART_BITS) - 1)
  30 #define SREAL_MAX_EXP (INT_MAX / 4)
  31
  32 #define SREAL_BITS SREAL_PART_BITS
  33
  34 /* Structure for holding a simple real number.  */
  35 class sreal
  36 {
  37 public:
  38   /* Construct an uninitialized sreal.  */
  39   sreal () : m_sig (-1), m_exp (-1), m_negative (0) {}
  40
  41   /* Construct a sreal.  */
  42   sreal (int64_t sig, int exp = 0) : m_exp (exp)
  43   {
  44     m_negative = sig < 0;
  45
  46     if (sig < 0)
  47       sig = -sig;
  48
  49     m_sig = (uint64_t) sig;
  50
  51     normalize ();
  52   }
  53
  54   void dump (FILE *) const;
  55   int64_t to_int () const;
  56   sreal operator+ (const sreal &other) const;
  57   sreal operator- (const sreal &other) const;
  58   sreal operator* (const sreal &other) const;
  59   sreal operator/ (const sreal &other) const;
  60
  61   bool operator< (const sreal &other) const
  62   {
  63     /* We negate result in case of negative numbers and
  64        it would return true for equal negative numbers.  */
  65     if (*this == other)
  66       return false;
  67
  68     if (m_negative != other.m_negative)
  69       return m_negative > other.m_negative;
  70
  71     bool r = m_exp < other.m_exp
  72       || (m_exp == other.m_exp && m_sig < other.m_sig);
  73
  74     return m_negative ? !r : r;
  75   }
  76
  77   bool operator== (const sreal &other) const
  78   {
  79     return m_exp == other.m_exp && m_sig == other.m_sig
  80                     && m_negative == other.m_negative;
  81   }
  82
  83   sreal operator- () const
  84   {
  85     if (m_sig == 0)
  86       return *this;
  87
  88     sreal tmp = *this;
  89     tmp.m_negative = !tmp.m_negative;
  90
  91     return tmp;
  92   }
  93
  94   sreal shift (int s) const
  95   {
  96     gcc_checking_assert (s <= SREAL_BITS);
  97     gcc_checking_assert (s >= -SREAL_BITS);
  98
  99     /* Exponent should never be so large because shift_right is used only by
 100      sreal_add and sreal_sub ant thus the number cannot be shifted out from
 101      exponent range.  */
 102     gcc_checking_assert (m_exp + s <= SREAL_MAX_EXP);
 103     gcc_checking_assert (m_exp + s >= -SREAL_MAX_EXP);
 104
 105     sreal tmp = *this;
 106     tmp.m_exp += s;
 107
 108     return tmp;
 109   }
 110
 111   /* Global minimum sreal can hold.  */
 112   inline static sreal min ()
 113   {
 114     static sreal min = sreal (-SREAL_MAX_SIG, SREAL_MAX_EXP);
 115     return min;
 116   }
 117
 118   /* Global minimum sreal can hold.  */
 119   inline static sreal max ()
 120   {
 121     static sreal max = sreal (SREAL_MAX_SIG, SREAL_MAX_EXP);
 122     return max;
 123   }
 124
 125 private:
 126   void normalize ();
 127   void shift_right (int amount);
 128
 129   static sreal signedless_plus (const sreal &a, const sreal &b, bool negative);
 130   static sreal signedless_minus (const sreal &a, const sreal &b, bool negative);
 131
 132   uint64_t m_sig;                       /* Significant.  */
 133   signed int m_exp;                     /* Exponent.  */
 134   bool m_negative;                      /* Negative sign.  */
 135 };
 136
 137 extern void debug (sreal &ref);
 138 extern void debug (sreal *ptr);
 139
 140 inline sreal &operator+= (sreal &a, const sreal &b)
 141 {
 142   return a = a + b;
 143 }
 144
 145 inline sreal &operator-= (sreal &a, const sreal &b)
 146 {
 147   return a = a - b;
 148 }
 149
 150 inline sreal &operator/= (sreal &a, const sreal &b)
 151 {
 152   return a = a / b;
 153 }
 154
 155 inline sreal &operator*= (sreal &a, const sreal &b)
 156 {
 157   return a = a  * b;
 158 }
 159
 160 inline bool operator!= (const sreal &a, const sreal &b)
 161 {
 162   return !(a == b);
 163 }
 164
 165 inline bool operator> (const sreal &a, const sreal &b)
 166 {
 167   return !(a == b || a < b);
 168 }
 169
 170 inline bool operator<= (const sreal &a, const sreal &b)
 171 {
 172   return a < b || a == b;
 173 }
 174
 175 inline bool operator>= (const sreal &a, const sreal &b)
 176 {
 177   return a == b || a > b;
 178 }
 179
 180 inline sreal operator<< (const sreal &a, int exp)
 181 {
 182   return a.shift (exp);
 183 }
 184
 185 inline sreal operator>> (const sreal &a, int exp)
 186 {
 187   return a.shift (-exp);
 188 }
 189
 190 #endif