WDL/denormal.h

   1 #ifndef _WDL_DENORMAL_H_
   2 #define _WDL_DENORMAL_H_
   3
   4 typedef struct
   5 {
   6   #ifdef __ppc__ // todo: other big endian platforms...
   7     unsigned int hw;
   8     unsigned int lw;
   9   #else
  10     unsigned int lw;
  11     unsigned int hw;
  12   #endif
  13 } WDL_DenormalTwoInts;
  14
  15 typedef union { double fl; WDL_DenormalTwoInts w; } WDL_DenormalDoubleAccess;
  16 typedef union { float fl; unsigned int w; } WDL_DenormalFloatAccess;
  17
  18
  19 // note: the _aggressive versions filter out anything less than around 1.0e-16 or so (approximately) to 0.0, including -0.0 (becomes 0.0)
  20 // note: new! the _aggressive versions also filter inf and NaN to 0.0
  21
  22 #ifdef __cplusplus
  23 #define WDL_DENORMAL_INLINE inline
  24 #elif defined(_MSC_VER)
  25 #define WDL_DENORMAL_INLINE __inline
  26 #else
  27 #define WDL_DENORMAL_INLINE
  28 #endif
  29
  30 #define WDL_DENORMAL_DOUBLE_HW(a) (((const WDL_DenormalDoubleAccess*)(a))->w.hw)
  31 #define WDL_DENORMAL_DOUBLE_LW(a) (((const WDL_DenormalDoubleAccess*)(a))->w.lw)
  32 #define WDL_DENORMAL_FLOAT_W(a) (((const WDL_DenormalFloatAccess*)(a))->w)
  33
  34 #define WDL_DENORMAL_DOUBLE_HW_NC(a) (((WDL_DenormalDoubleAccess*)(a))->w.hw)
  35 #define WDL_DENORMAL_DOUBLE_LW_NC(a) (((WDL_DenormalDoubleAccess*)(a))->w.lw)
  36 #define WDL_DENORMAL_FLOAT_W_NC(a) (((WDL_DenormalFloatAccess*)(a))->w)
  37
  38 #define WDL_DENORMAL_DOUBLE_AGGRESSIVE_CUTOFF 0x3cA00000 // 0x3B8000000 maybe instead? that's 10^-5 smaller or so
  39 #define WDL_DENORMAL_FLOAT_AGGRESSIVE_CUTOFF 0x25000000
  40
  41 #define WDL_NOT_DENORMAL_DOUBLE(a) (WDL_DENORMAL_DOUBLE_HW(a)&0x7ff00000)
  42 #define WDL_NOT_DENORMAL_FLOAT(a) (WDL_DENORMAL_FLOAT_W(a)&0x7f800000)
  43
  44 #define WDL_DENORMAL_OR_ZERO_DOUBLE(a) (!WDL_NOT_DENORMAL_DOUBLE(a))
  45 #define WDL_DENORMAL_OR_ZERO_FLOAT(a) (!WDL_NOT_DENORMAL_FLOAT(a))
  46 #define WDL_DENORMAL_OR_ZERO_DOUBLE_AGGRESSIVE(a) (((WDL_DENORMAL_DOUBLE_HW(a)+0x100000)&0x7ff00000) < WDL_DENORMAL_DOUBLE_AGGRESSIVE_CUTOFF)
  47 #define WDL_DENORMAL_OR_ZERO_FLOAT_AGGRESSIVE(a) (((WDL_DENORMAL_FLOAT_W(a)+0x800000)&0x7f800000) < WDL_DENORMAL_FLOAT_AGGRESSIVE_CUTOFF)
  48
  49 static double WDL_DENORMAL_INLINE denormal_filter_double(double a)
  50 {
  51   return (WDL_DENORMAL_DOUBLE_HW(&a)&0x7ff00000) ? a : 0.0;
  52 }
  53
  54 static double WDL_DENORMAL_INLINE denormal_filter_double2(double a)
  55 {
  56   return ((WDL_DENORMAL_DOUBLE_HW(&a)+0x100000)&0x7ff00000) > 0x100000 ? a : 0.0;
  57 }
  58
  59 static double WDL_DENORMAL_INLINE denormal_filter_double_aggressive(double a)
  60 {
  61   return ((WDL_DENORMAL_DOUBLE_HW(&a)+0x100000)&0x7ff00000) >= WDL_DENORMAL_DOUBLE_AGGRESSIVE_CUTOFF ? a : 0.0;
  62 }
  63
  64 static float WDL_DENORMAL_INLINE denormal_filter_float(float a)
  65 {
  66   return (WDL_DENORMAL_FLOAT_W(&a)&0x7f800000) ? a : 0.0f;
  67 }
  68
  69 static float WDL_DENORMAL_INLINE denormal_filter_float2(float a)
  70 {
  71   return ((WDL_DENORMAL_FLOAT_W(&a)+0x800000)&0x7f800000) > 0x800000 ? a : 0.0f;
  72 }
  73
  74
  75 static float WDL_DENORMAL_INLINE denormal_filter_float_aggressive(float a)
  76 {
  77   return ((WDL_DENORMAL_FLOAT_W(&a)+0x800000)&0x7f800000) >= WDL_DENORMAL_FLOAT_AGGRESSIVE_CUTOFF ? a : 0.0f;
  78 }
  79 static void WDL_DENORMAL_INLINE denormal_fix_double(double *a)
  80 {
  81   if (!(WDL_DENORMAL_DOUBLE_HW(a)&0x7ff00000)) *a=0.0;
  82 }
  83
  84 static void WDL_DENORMAL_INLINE denormal_fix_double_aggressive(double *a)
  85 {
  86   if (((WDL_DENORMAL_DOUBLE_HW(a)+0x100000)&0x7ff00000) < WDL_DENORMAL_DOUBLE_AGGRESSIVE_CUTOFF) *a=0.0;
  87 }
  88
  89 static void WDL_DENORMAL_INLINE denormal_fix_float(float *a)
  90 {
  91   if (!(WDL_DENORMAL_FLOAT_W(a)&0x7f800000)) *a=0.0f;
  92 }
  93 static void WDL_DENORMAL_INLINE denormal_fix_float_aggressive(float *a)
  94 {
  95   if (((WDL_DENORMAL_FLOAT_W(a)+0x800000)&0x7f800000) < WDL_DENORMAL_FLOAT_AGGRESSIVE_CUTOFF) *a=0.0f;
  96 }
  97
  98
  99
 100 #ifdef __cplusplus // automatic typed versions (though one should probably use the explicit versions...
 101
 102
 103 static double WDL_DENORMAL_INLINE denormal_filter(double a)
 104 {
 105   return (WDL_DENORMAL_DOUBLE_HW(&a)&0x7ff00000) ? a : 0.0;
 106 }
 107 static double WDL_DENORMAL_INLINE denormal_filter_aggressive(double a)
 108 {
 109   return ((WDL_DENORMAL_DOUBLE_HW(&a)+0x100000)&0x7ff00000) >= WDL_DENORMAL_DOUBLE_AGGRESSIVE_CUTOFF ? a : 0.0;
 110 }
 111
 112 static float WDL_DENORMAL_INLINE denormal_filter(float a)
 113 {
 114   return (WDL_DENORMAL_FLOAT_W(&a)&0x7f800000) ? a : 0.0f;
 115 }
 116
 117 static float WDL_DENORMAL_INLINE denormal_filter_aggressive(float a)
 118 {
 119   return ((WDL_DENORMAL_FLOAT_W(&a)+0x800000)&0x7f800000) >= WDL_DENORMAL_FLOAT_AGGRESSIVE_CUTOFF ? a : 0.0f;
 120 }
 121
 122 static void WDL_DENORMAL_INLINE denormal_fix(double *a)
 123 {
 124   if (!(WDL_DENORMAL_DOUBLE_HW(a)&0x7ff00000)) *a=0.0;
 125 }
 126 static void WDL_DENORMAL_INLINE denormal_fix_aggressive(double *a)
 127 {
 128   if (((WDL_DENORMAL_DOUBLE_HW(a)+0x100000)&0x7ff00000) < WDL_DENORMAL_DOUBLE_AGGRESSIVE_CUTOFF) *a=0.0;
 129 }
 130 static void WDL_DENORMAL_INLINE denormal_fix(float *a)
 131 {
 132   if (!(WDL_DENORMAL_FLOAT_W(a)&0x7f800000)) *a=0.0f;
 133 }
 134 static void WDL_DENORMAL_INLINE denormal_fix_aggressive(float *a)
 135 {
 136   if (((WDL_DENORMAL_FLOAT_W(a)+0x800000)&0x7f800000) < WDL_DENORMAL_FLOAT_AGGRESSIVE_CUTOFF) *a=0.0f;
 137 }
 138
 139 static bool WDL_DENORMAL_INLINE WDL_DENORMAL_OR_ZERO(double *a)
 140 {
 141   return WDL_DENORMAL_OR_ZERO_DOUBLE(a);
 142 }
 143
 144 static bool WDL_DENORMAL_INLINE WDL_DENORMAL_OR_ZERO(float *a)
 145 {
 146   return WDL_DENORMAL_OR_ZERO_FLOAT(a);
 147 }
 148
 149 static bool WDL_DENORMAL_INLINE WDL_DENORMAL_OR_ZERO_AGGRESSIVE(double *a)
 150 {
 151   return WDL_DENORMAL_OR_ZERO_DOUBLE_AGGRESSIVE(a);
 152 }
 153
 154 static bool WDL_DENORMAL_INLINE WDL_DENORMAL_OR_ZERO_AGGRESSIVE(float *a)
 155 {
 156   return WDL_DENORMAL_OR_ZERO_FLOAT_AGGRESSIVE(a);
 157 }
 158
 159
 160
 161 #endif // cplusplus versions
 162
 163
 164
 165
 166 ////////////////////
 167 // this isnt a denormal function but it is similar, so we'll put it here as a bonus
 168
 169 static void WDL_DENORMAL_INLINE GetDoubleMaxAbsValue(double *out, const double *in) // note: the value pointed to by "out" must be >=0.0, __NOT__ <= -0.0
 170 {
 171   unsigned int hw = WDL_DENORMAL_DOUBLE_HW(in)&0x7fffffff;
 172   if (hw >= WDL_DENORMAL_DOUBLE_HW(out) && (hw>WDL_DENORMAL_DOUBLE_HW(out) || WDL_DENORMAL_DOUBLE_LW(in) > WDL_DENORMAL_DOUBLE_LW(out)))
 173   {
 174     WDL_DENORMAL_DOUBLE_LW_NC(out) = WDL_DENORMAL_DOUBLE_LW(in);
 175     WDL_DENORMAL_DOUBLE_HW_NC(out) = hw;
 176   }
 177 }
 178
 179 static void WDL_DENORMAL_INLINE GetFloatMaxAbsValue(float *out, const float *in) // note: the value pointed to by "out" must be >=0.0, __NOT__ <= -0.0
 180 {
 181   unsigned int hw = WDL_DENORMAL_FLOAT_W(in)&0x7fffffff;
 182   if (hw > WDL_DENORMAL_FLOAT_W(out)) WDL_DENORMAL_FLOAT_W_NC(out)=hw;
 183 }
 184
 185
 186 #ifdef __cplusplus
 187 static void WDL_DENORMAL_INLINE GetFloatMaxAbsValue(double *out, const double *in) // note: the value pointed to by "out" must be >=0.0, __NOT__ <= -0.0
 188 {
 189   GetDoubleMaxAbsValue(out,in);
 190 }
 191 #endif
 192
 193 #endif