Re: Upgrading a codebase from 2.065 to 2.066

[Dominikus Dittes Scherkl via Digitalmars-d]

On Tuesday, 8 July 2014 at 06:08:58 UTC, Brian Schott wrote:
On Tuesday, 8 July 2014 at 06:02:51 UTC, Iain Buclaw via 
Digitalmars-d wrote:
I would ask why are you passing integers to isNaN.

We passed T to isNaN, and sometimes T was uint.

I would like to have a NaN in any type and be able to call isNaN 
for any (numeric) type. In fact I work with the following:

/// add a property to numeric types that can be used as return 
value if a result is out of bounds
template @property T invalid(T) @primitive if(isNumeric!T)
{
   static if(isFloat!T)
      return T.init;
   else static if(isSigned!T)
      return T.min;
   else // unsigned
      return T.max;
}

/// returns the save (not invalid) minimum value for the given 
type
template @property T smin(T) @primitive if(isNumeric!T)
{
   static if(isIntegral!T && isSigned!T)
      return T.min+1;
   else
      return T.min;
}

/// returns the save (not invalid) maximum value for the given 
type
template @property T smax(T) @primitive if(isNumeric!T)
{
   static if(isUnsigned!T)
      return T.max-1u;
   else
      return T.max;
}

/// take any NaN as invalid floatingpoint value,
/// T.max as invalid value of unsigned types and
/// T.min as invalid value of signed types
bool isInvalid(T)(const(T) x) @primitive if(isNumeric!T)
{
   static if(isFloat!T)
      return isNaN(x);
   else static if(isSigned!T)
      return x == T.min;
   else // unsigned
      return x == T.max;
}

(btw: @primitive is my internal shorthand for "pure @safe @nogc 
@nothrow")

because it allows to define save functions like e.g. a save 
downcast:

/// returns T.invalid if x is outside the target type range
T limit(T, U)(const(U) x) @primitive if(isNumeric!T && 
isNumeric!U)
{
   static if(Unqual!T == Unqual!U) // nop
      return x;
   else static if(isFloat!T)
      return cast(T)x; // let D handle this internally
   else static if(isFloat!U)
      return (isNaN(x) || x <= cast(U)T.min-1.0f || x >= 
cast(U)T.max+1.0f) ? T.invalid : cast(T)x;
   else static if(isSigned!T)
   {
      static if(T.sizeof > U.sizeof) // nothing to limit
         return cast(T)x;
      else static if(isUnsigned!U) // limit one direction
         return (x > T.max) ? T.invalid : cast(T)x;
      else // limit both directions
         return (x < T.min || x > T.max) ? T.invalid : cast(T)x;
   }
   else // unsigned result
   {
      static if(isSigned!U) // prohibit negative values
         if(x < 0) return T.invalid;

      static if(T.sizeof >= U.sizeof) // no further limit
         return cast(T)x;
      else // prohibit also big positive values
         return (x > T.max) ? T.invalid : cast(T)x;
   }
}