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 ((int64_t) 1 << (SREAL_PART_BITS - 2))
  29 #define SREAL_MAX_SIG (((int64_t) 1 << (SREAL_PART_BITS - 1)) - 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) {}
  40
  41   /* Construct a sreal.  */
  42   sreal (int64_t sig, int exp = 0) : m_sig (sig), m_exp (exp)
  43   {
  44     normalize ();
  45   }
  46
  47   void dump (FILE *) const;
  48   int64_t to_int () const;
  49   sreal operator+ (const sreal &other) const;
  50   sreal operator- (const sreal &other) const;
  51   sreal operator* (const sreal &other) const;
  52   sreal operator/ (const sreal &other) const;
  53
  54   bool operator< (const sreal &other) const
  55   {
  56     if (m_exp == other.m_exp)
  57       return m_sig < other.m_sig;
  58     else
  59     {
  60       bool negative = m_sig < 0;
  61       bool other_negative = other.m_sig < 0;
  62
  63       if (negative != other_negative)
  64         return negative > other_negative;
  65
  66       bool r = m_exp < other.m_exp;
  67       return negative ? !r : r;
  68     }
  69   }
  70
  71   bool operator== (const sreal &other) const
  72   {
  73     return m_exp == other.m_exp && m_sig == other.m_sig;
  74   }
  75
  76   sreal operator- () const
  77   {
  78     sreal tmp = *this;
  79     tmp.m_sig *= -1;
  80
  81     return tmp;
  82   }
  83
  84   sreal shift (int s) const
  85   {
  86     gcc_checking_assert (s <= SREAL_BITS);
  87     gcc_checking_assert (s >= -SREAL_BITS);
  88
  89     /* Exponent should never be so large because shift_right is used only by
  90      sreal_add and sreal_sub ant thus the number cannot be shifted out from
  91      exponent range.  */
  92     gcc_checking_assert (m_exp + s <= SREAL_MAX_EXP);
  93     gcc_checking_assert (m_exp + s >= -SREAL_MAX_EXP);
  94
  95     sreal tmp = *this;
  96     tmp.m_exp += s;
  97
  98     return tmp;
  99   }
 100
 101   /* Global minimum sreal can hold.  */
 102   inline static sreal min ()
 103   {
 104     static sreal min = sreal (-SREAL_MAX_SIG, SREAL_MAX_EXP);
 105     return min;
 106   }
 107
 108   /* Global minimum sreal can hold.  */
 109   inline static sreal max ()
 110   {
 111     static sreal max = sreal (SREAL_MAX_SIG, SREAL_MAX_EXP);
 112     return max;
 113   }
 114
 115 private:
 116   void normalize ();
 117   void shift_right (int amount);
 118   static sreal signedless_plus (const sreal &a, const sreal &b, bool negative);
 119   static sreal signedless_minus (const sreal &a, const sreal &b, bool negative);
 120
 121   int64_t m_sig;                        /* Significant.  */
 122   signed int m_exp;                     /* Exponent.  */
 123 };
 124
 125 extern void debug (const sreal &ref);
 126 extern void debug (const sreal *ptr);
 127
 128 inline sreal &operator+= (sreal &a, const sreal &b)
 129 {
 130   return a = a + b;
 131 }
 132
 133 inline sreal &operator-= (sreal &a, const sreal &b)
 134 {
 135   return a = a - b;
 136 }
 137
 138 inline sreal &operator/= (sreal &a, const sreal &b)
 139 {
 140   return a = a / b;
 141 }
 142
 143 inline sreal &operator*= (sreal &a, const sreal &b)
 144 {
 145   return a = a  * b;
 146 }
 147
 148 inline bool operator!= (const sreal &a, const sreal &b)
 149 {
 150   return !(a == b);
 151 }
 152
 153 inline bool operator> (const sreal &a, const sreal &b)
 154 {
 155   return !(a == b || a < b);
 156 }
 157
 158 inline bool operator<= (const sreal &a, const sreal &b)
 159 {
 160   return a < b || a == b;
 161 }
 162
 163 inline bool operator>= (const sreal &a, const sreal &b)
 164 {
 165   return a == b || a > b;
 166 }
 167
 168 inline sreal operator<< (const sreal &a, int exp)
 169 {
 170   return a.shift (exp);
 171 }
 172
 173 inline sreal operator>> (const sreal &a, int exp)
 174 {
 175   return a.shift (-exp);
 176 }
 177
 178 #endif