ale_real.h

   1 // Copyright 2002, 2004 David Hilvert <dhilvert@auricle.dyndns.org>,
   2 //                                    <dhilvert@ugcs.caltech.edu>
   3
   4 /*  This file is part of the Anti-Lamenessing Engine.
   5
   6     The Anti-Lamenessing Engine is free software; you can redistribute it and/or modify
   7     it under the terms of the GNU General Public License as published by
   8     the Free Software Foundation; either version 3 of the License, or
   9     (at your option) any later version.
  10
  11     The Anti-Lamenessing Engine is distributed in the hope that it will be useful,
  12     but WITHOUT ANY WARRANTY; without even the implied warranty of
  13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14     GNU General Public License for more details.
  15
  16     You should have received a copy of the GNU General Public License
  17     along with the Anti-Lamenessing Engine; if not, write to the Free Software
  18     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19 */
  20
  21 #ifndef __ale_real_h__
  22 #define __ale_real_h__
  23
  24 #include "ale_fixed.h"
  25
  26 #define SINGLE 1
  27 #define DOUBLE 2
  28 #define HALF 3
  29 #define FIXED32 4
  30 #define FIXED16 5
  31
  32 #define ale_real_enable_casting()
  33 #define ale_real_disable_casting()
  34
  35 #define ale_real_unexceptional_negation(VALUE) -(VALUE)
  36
  37 #define ale_real_from_int(INT_VALUE, MAXVAL) (((float) (INT_VALUE)) / ((float) (MAXVAL)))
  38 #define ale_real_to_int(REAL_VALUE, MAXVAL) round((float) (REAL_VALUE) * (MAXVAL))
  39 #define ale_real_weight_floor 0.0001
  40
  41 /*
  42  * Real-valued type used to represent the range of an image (colors, weights,
  43  * etc.).
  44  *
  45  * ale_real is used in computation.
  46  * ale_sreal is used for storage.
  47  */
  48
  49 #if ALE_COLORS == SINGLE
  50
  51 typedef float ale_real;
  52 typedef float ale_sreal;
  53
  54 #define ale_real_ip_weight_floor 1e-10
  55 #define ale_real_confidence_floor 0.001
  56
  57 #define ALE_REAL_PRECISION_STRING "SINGLE"
  58
  59 #elif ALE_COLORS == DOUBLE
  60
  61 typedef double ale_real;
  62 typedef double ale_sreal;
  63
  64 #define ale_real_ip_weight_floor 1e-10
  65 #define ale_real_confidence_floor 0.000001
  66
  67 #define ALE_REAL_PRECISION_STRING "DOUBLE"
  68
  69 #elif ALE_COLORS == HALF
  70
  71 /*
  72  * What follows is one approach to packing a floating point
  73  * number into 16 bits.  This implementation is very slow.
  74  */
  75
  76 #define MANTISSA_BITS (9)
  77 #define EXP_BITS (15 - MANTISSA_BITS)
  78 #define EXP_SPECIAL (1 << (EXP_BITS - 1))
  79 #define EXP_MAX (EXP_SPECIAL - 1)
  80 #define EXP_MIN (-EXP_MAX)
  81
  82 typedef float ale_real;
  83
  84 class ale_sreal {
  85
  86         union {
  87                 uint16_t bits;
  88                 struct {
  89                         uint16_t sign:1;
  90                         uint16_t mant:MANTISSA_BITS;
  91                         int16_t  exp :EXP_BITS;
  92                 } fpr;
  93         } u;
  94 public:
  95         ale_sreal() {
  96                 u.bits = 0;
  97         }
  98         ale_sreal operator=(float v) {
  99                 if (v == 0) {
 100                         u.bits = 0;
 101                 } else if (isnan(v)) {
 102                         u.fpr.exp = EXP_SPECIAL;
 103                         u.fpr.mant = 1;
 104                 } else {
 105
 106                         if (v > 0)
 107                                 u.fpr.sign = 0;
 108                         else if (v < 0) {
 109                                 u.fpr.sign = 1;
 110                                 v = -v;
 111                         } else
 112                                 assert(0);
 113
 114                         /*
 115                          * Get the exponent.
 116                          */
 117
 118                         int log2 = (int) floor (log(v) / log(2));
 119
 120                         /*
 121                          * Test the exponent against the largest expressible
 122                          * exponent for ale_sreal.
 123                          */
 124
 125                         if (log2 > EXP_MAX) {
 126                                 /*
 127                                  * Infinity
 128                                  */
 129
 130                                 u.fpr.exp = EXP_SPECIAL;
 131                                 u.fpr.mant = 0;
 132
 133                                 return *this;
 134                         }
 135
 136                         /*
 137                          * Test the exponent against the smallest expressible
 138                          * exponent for ale_sreal.
 139                          */
 140
 141                         if (log2 < EXP_MIN) {
 142                                 /*
 143                                  * Zero
 144                                  */
 145
 146                                 u.fpr.exp = 0x0;
 147                                 u.fpr.mant = 0;
 148
 149                                 return *this;
 150                         }
 151
 152                         /*
 153                          * The exponent is in range, so use it.
 154                          */
 155
 156                         u.fpr.exp = log2;
 157
 158                         u.fpr.mant = (uint16_t) floor(v / pow(2, log2) * (1 << (MANTISSA_BITS - 1)));
 159                 }
 160
 161                 return *this;
 162         }
 163
 164         operator float() const {
 165                 float result = 3.14159;
 166
 167                 if (((uint16_t) u.fpr.exp == EXP_SPECIAL) && (u.fpr.mant == 1)) {
 168
 169                         /*
 170                          * NaN
 171                          */
 172
 173                         float a = 0;
 174                         float b = 0;
 175
 176                         result = a / b;
 177
 178                 } else if (((uint16_t) u.fpr.exp == EXP_SPECIAL) && (u.fpr.mant == 0)) {
 179
 180                         /*
 181                          * Infinity
 182                          */
 183
 184                         float a = 1;
 185                         float b = 0;
 186
 187                         result = (a / b);
 188
 189                 } else if ((uint16_t) u.fpr.exp != EXP_SPECIAL) {
 190
 191                         /*
 192                          * Value is finite.
 193                          */
 194
 195                         result = u.fpr.mant / ((double) (1 << (MANTISSA_BITS - 1)))
 196                                * pow(2, u.fpr.exp);
 197
 198                 } else
 199                         assert(0);
 200
 201                 if (u.fpr.sign)
 202                         result = -result;
 203
 204                 return result;
 205         }
 206
 207         ale_sreal operator-=(float r) {
 208                 *this = (float) *this - (float) r;
 209                 return *this;
 210         }
 211         ale_sreal operator/=(float r) {
 212                 *this = (float) *this / (float) r;
 213                 return *this;
 214         }
 215         ale_sreal operator*=(float r) {
 216                 *this = (float) *this * (float) r;
 217                 return *this;
 218         }
 219         ale_sreal operator+=(float r) {
 220                 *this = (float) *this + (float) r;
 221                 return *this;
 222         }
 223 };
 224
 225 #undef MANTISSA_BITS
 226 #undef EXP_BITS
 227 #undef EXP_SPECIAL
 228 #undef EXP_MAX
 229 #undef EXP_MIN
 230
 231 #define ALE_REAL_PRECISION_STRING "HALF"
 232
 233 #elif ALE_COLORS == FIXED32
 234
 235 typedef ale_fixed<ale_fixed_32,16> ale_real;
 236 typedef ale_fixed<ale_fixed_32,16> ale_sreal;
 237
 238 #undef ale_real_enable_casting
 239 #undef ale_real_disable_casting
 240 #define ale_real_enable_casting() ale_real::enable_casting()
 241 #define ale_real_disable_casting() ale_real::disable_casting()
 242
 243 #undef ale_real_unexceptional_negation
 244 #define ale_real_unexceptional_negation(VALUE) (VALUE).unexceptional_negation();
 245
 246 #undef ale_real_to_int
 247 #undef ale_real_from_int
 248 #define ale_real_to_int(REAL_VALUE, MAXVAL) (  (MAXVAL == 255) \
 249                                              ? (int) ale_fixed<ale_fixed_16_calc,8>::fixed_to_bits(REAL_VALUE) \
 250                                              : ( (MAXVAL == 65535) \
 251                                                ? (int) ale_fixed<ale_fixed_16_calc,16>::fixed_to_bits(REAL_VALUE)  \
 252                                                : (int) round((float) (REAL_VALUE) * (MAXVAL)) ) )
 253
 254 #define ale_real_from_int(INT_VALUE, MAXVAL) (  (MAXVAL == 255) \
 255                                                ? (ale_real) ale_fixed<ale_fixed_16_calc,8>::bits_to_fixed(INT_VALUE) \
 256                                                : ( (MAXVAL == 65535) \
 257                                                  ? (ale_real) ale_fixed<ale_fixed_16_calc,16>::bits_to_fixed(INT_VALUE) \
 258                                                  : (ale_real) (((float) (INT_VALUE)) / ((float) (MAXVAL))) ) )
 259
 260 #define ale_real_ip_weight_floor (1 / (ale_real) 100)
 261 #define ale_real_confidence_floor (1 / (ale_real) 10)
 262
 263 #define ALE_REAL_PRECISION_STRING "FIXED32"
 264
 265 #elif ALE_COLORS == FIXED16
 266
 267 typedef ale_fixed<ale_fixed_16_calc,14> ale_real;
 268 typedef ale_fixed<ale_fixed_16,12> ale_sreal;
 269
 270 #undef ale_real_enable_casting
 271 #undef ale_real_disable_casting
 272 #define ale_real_enable_casting() ale_real::enable_casting()
 273 #define ale_real_disable_casting() ale_real::disable_casting()
 274
 275 #undef ale_real_unexceptional_negation
 276 #define ale_real_unexceptional_negation(VALUE) (VALUE).unexceptional_negation();
 277
 278 #undef ale_real_to_int
 279 #undef ale_real_from_int
 280 #define ale_real_to_int(REAL_VALUE, MAXVAL) (  (MAXVAL == 255) \
 281                                              ? (int) ale_fixed<ale_fixed_16_calc,8>::fixed_to_bits(REAL_VALUE) \
 282                                              : ( (MAXVAL == 65535) \
 283                                                ? (int) ale_fixed<ale_fixed_16_calc,16>::fixed_to_bits(REAL_VALUE)  \
 284                                                : (int) round((float) (REAL_VALUE) * (MAXVAL)) ) )
 285
 286 #define ale_real_from_int(INT_VALUE, MAXVAL) (  (MAXVAL == 255) \
 287                                                ? (ale_real) ale_fixed<ale_fixed_16_calc,8>::bits_to_fixed(INT_VALUE) \
 288                                                : ( (MAXVAL == 65535) \
 289                                                  ? (ale_real) ale_fixed<ale_fixed_16_calc,16>::bits_to_fixed(INT_VALUE) \
 290                                                  : (ale_real) (((float) (INT_VALUE)) / ((float) (MAXVAL))) ) )
 291
 292 #define ale_real_ip_weight_floor (1 / (ale_real) 100)
 293 #define ale_real_confidence_floor (1 / (ale_real) 10)
 294
 295 #define ALE_REAL_PRECISION_STRING "FIXED16"
 296
 297 #else
 298
 299 #warning Unknown precision in ale_real.h: Choosing PRECISION=SINGLE.
 300
 301 typedef float ale_real;
 302 typedef float ale_sreal;
 303
 304 #define ale_real_ip_weight_floor 1e-10
 305 #define ale_real_confidence_floor 0.001
 306
 307 #define ALE_REAL_PRECISION_STRING "SINGLE"
 308
 309 #endif
 310
 311 const ale_real ale_real_0 = (ale_real) 0;
 312
 313 #undef SINGLE
 314 #undef DOUBLE
 315 #undef HALF
 316 #undef FIXED16
 317 #undef FIXED32
 318
 319 #endif