octave: liboctave/oct-inttypes.h comparison

comparison liboctave/oct-inttypes.h @ 11586:12df7854fa7c

strip trailing whitespace from source files

author	John W. Eaton <jwe@octave.org>
date	Thu, 20 Jan 2011 17:24:59 -0500
parents	fd0a3ac60b0e
children	15eefbd9d4e8

comparison

equal deleted inserted replaced

-:1473d0cf86d2
+:12df7854fa7c
 template<int qsize, bool qsigned>
 struct query_integer_type
 {
 public:
 static const bool registered = false;
 typedef void type; // Void shall result in a compile-time error if we
 // attempt to use it in computations.
 };
 #define REGISTER_INT_TYPE(TYPE) \
 template <> \
 REGISTER_INT_TYPE (int64_t);
 REGISTER_INT_TYPE (uint64_t);
 // Rationale: Comparators have a single static method, rel(), that returns the
 // result of the binary relation. They also have two static boolean fields:
 // ltval, gtval determine the value of x OP y if x < y, x > y, respectively.
 #define REGISTER_OCTAVE_CMP_OP(NM,OP) \
 class NM \
 { \
 public: \
 static const bool ltval = (0 OP 1), gtval = (1 OP 0); \
 // size.
 template <class T1, class T2>
 class prom
 {
 // Promote to int?
 static const bool pint = (sizeof (T1) < sizeof (int)
 && sizeof (T2) < sizeof (int));
 static const bool t1sig = std::numeric_limits<T1>::is_signed;
 static const bool t2sig = std::numeric_limits<T2>::is_signed;
 static const bool psig =
 (pint || (sizeof (T2) > sizeof (T1) && t2sig) || t1sig);
 static const int psize =
 (pint ? sizeof (int) : (sizeof (T2) > sizeof (T1)
 ? sizeof (T2) : sizeof (T1)));
 public:
 typedef typename query_integer_type<psize, psig>::type type;
 };
 class uiop
 {
 typedef typename query_integer_type<size, false>::type utype;
 typedef typename query_integer_type<size, true>::type stype;
 public:
 static bool op (utype x, utype y)
 { return xop::op (x, y); }
 static bool op (stype x, stype y)
 { return xop::op (x, y); }
 static bool op (stype x, utype y)
 { return (x < 0) ? xop::ltval : xop::op (static_cast<utype> (x), y); }
 static bool op (utype x, stype y)
 { return (y < 0) ? xop::gtval : xop::op (x, static_cast<utype> (y)); }
 };
 public:
 REGISTER_OCTAVE_CMP_OP (lt, <);
 static bool
 op (T1 x, T2 y)
 {
 typedef typename prom<T1, T2>::type PT1;
 typedef typename prom<T2, T1>::type PT2;
 return uiop<xop, sizeof (PT1)>::op (static_cast<PT1> (x),
 static_cast<PT2> (y));
 }
 public:
 // Mixed comparisons
 template <class xop, class T>
 static bool
 mop (T1 x, T2 y) \
 { \
 return xop::op (static_cast<long double> (x), \
 static_cast<long double> (y)); \
 }
 #else
 // ... otherwise, use external handlers
 // FIXME: We could declare directly the mop methods as external,
 // but we can't do this because bugs in gcc (<= 4.3) prevent
 // explicit instantiations later in that case.
 #undef DEFINE_LONG_DOUBLE_CMP_OP
 };
 // Base integer class. No data, just conversion methods and exception flags.
 template <class T>
 class octave_int_base
 {
 protected:
 static T min_val () { return std::numeric_limits<T>:: min (); }
 public:
 // Convert integer value.
 template <class S>
 static T
 truncate_int (const S& value)
 {
 // An exhaustive test whether the max and/or min check can be omitted.
 static const bool t_is_signed = std::numeric_limits<T>::is_signed;
 static const bool s_is_signed = std::numeric_limits<S>::is_signed;
 static const int t_size = sizeof (T), s_size = sizeof (S);
 static const bool omit_chk_min =
 (! s_is_signed || (t_is_signed && t_size >= s_size));
 static const bool omit_chk_max =
 (t_size > s_size || (t_size == s_size
 && (! t_is_signed || s_is_signed)));
 // If the check can be omitted, substitute constant false relation.
 typedef octave_int_cmp_op::cf cf;
 typedef octave_int_cmp_op::lt lt;
 typedef octave_int_cmp_op::gt gt;
 return static_cast<T> (value);
 }
 private:
 // Computes a real-valued threshold for a max/min check.
 template <class S>
 static S
 compute_threshold (S val, T orig_val)
 {
 val = xround (val); // Fool optimizations (maybe redundant)
 // If val is even, but orig_val is odd, we're one unit off.
 if (orig_val % 2 && val / 2 == xround (val / 2))
 // FIXME -- is this always correct?
 val *= (static_cast<S>(1) - (std::numeric_limits<S>::epsilon () / 2));
 return val;
 }
 public:
 // Convert a real number (check NaN and non-int).
 template <class S>
 static T
 convert_real (const S& value)
 {
 // Compute proper thresholds.
 static const S thmin = compute_threshold (static_cast<S> (min_val ()), min_val ());
 static const S thmax = compute_threshold (static_cast<S> (max_val ()), max_val ());
 return static_cast<T> (0);
 }
 // the overflow behaviour for unsigned integers is guaranteed by C/C++,
 // so the following should always work.
 static T
 add (T x, T y)
 {
 T u = x + y;
 if (u < x)
 {
 u = octave_int_base<T>::max_val ();
 }
 return u;
 }
 static T
 sub (T x, T y)
 {
 T u = x - y;
 if (u > x)
 {
 }
 return u;
 }
 // Multiplication is done using promotion to wider integer type. If there is
 // no suitable promotion type, this operation *MUST* be specialized.
 static T
 mul (T x, T y)
 {
 // Promotion type for multiplication (if exists).
 typedef typename query_integer_type<2*sizeof (T), false>::type mptype;
 return truncate_int (static_cast<mptype> (x)
 * static_cast<mptype> (y));
 }
 // Division with rounding to nearest. Note that / and % are probably
 // computed by a single instruction.
 static T
 div (T x, T y)
 {
 if (y != 0)
 {
 T z = x / y, w = x % y;
 return static_cast<uint64_t> (p);
 }
 #else
 // Special handler for 64-bit integer multiply.
 template <>
 OCTAVE_API uint64_t
 octave_int_arith_base<uint64_t, false>::mul (uint64_t, uint64_t);
 #endif
 // Signed integer arithmetics.
 // Rationale: If HAVE_FAST_INT_OPS is defined, the following conditions
 //
 // The above conditions are satisfied by most modern platforms. If
 // HAVE_FAST_INT_OPS is defined, bit tricks and wraparound arithmetics are used
 // to avoid conditional jumps as much as possible, thus being friendly to modern
 // pipeline processor architectures.
 // Otherwise, we fall back to a bullet-proof code that only uses assumptions
 // guaranteed by the standard.
 template <class T>
 class octave_int_arith_base<T, true> : octave_int_base<T>
 {
 typedef typename query_integer_type<sizeof (T), false>::type UT;
 public:
 // Returns 1 for negative number, 0 otherwise.
 static T
 signbit (T x)
 {
 #ifdef HAVE_FAST_INT_OPS
 return static_cast<UT> (x) >> std::numeric_limits<T>::digits;
 #else
 return (x < 0) ? 1 : 0;
 #endif
 }
 static T
 abs (T x)
 // This is close to how GCC does std::abs, but we can't just use std::abs,
 // because its behaviour for INT_MIN is undefined and the compiler could
 // discard the following test.
 T m = x >> std::numeric_limits<T>::digits;
 T y = (x ^ m) - m;
 if (y < 0)
 {
 y = octave_int_base<T>::max_val ();
 }
 return y;
 #else
 return y;
 #endif
 }
 static T
 signum (T x)
 {
 // With modest optimizations, this will compile without a jump.
 return ((x > 0) ? 1 : 0) - signbit (x);
 }
 // FIXME -- we do not have an authority what signed shifts should
 // exactly do, so we define them the easy way. Note that Matlab does
 // not define signed shifts.
 y = -x;
 return y;
 #endif
 }
 static T
 add (T x, T y)
 {
 #ifdef HAVE_FAST_INT_OPS
 // The typecasts do nothing, but they are here to prevent an optimizing
 // compiler from interfering. Also, the signed operations on small types
 // actually return int.
 T u = static_cast<UT> (x) + static_cast<UT> (y);
 T ux = u ^ x, uy = u ^ y;
 if ((ux & uy) < 0)
 {
 u = octave_int_base<T>::max_val () + signbit (~u);
 }
 return u;
 #else
 return u;
 #endif
 }
 // This is very similar to addition.
 static T
 sub (T x, T y)
 {
 #ifdef HAVE_FAST_INT_OPS
 // The typecasts do nothing, but they are here to prevent an optimizing
 // compiler from interfering. Also, the signed operations on small types
 // actually return int.
 T u = static_cast<UT> (x) - static_cast<UT> (y);
 T ux = u ^ x, uy = u ^ ~y;
 if ((ux & uy) < 0)
 {
 u = octave_int_base<T>::max_val () + signbit (~u);
 }
 return u;
 #else
 return u;
 #endif
 }
 // Multiplication is done using promotion to wider integer type. If there is
 // no suitable promotion type, this operation *MUST* be specialized.
 static T
 mul (T x, T y)
 {
 // Promotion type for multiplication (if exists).
 typedef typename query_integer_type<2*sizeof (T), true>::type mptype;
 return truncate_int (static_cast<mptype> (x)
 * static_cast<mptype> (y));
 }
 // Division.
 static T
 div (T x, T y)
 {
 T z;
 if (y == 0)
 {
 }
 else
 {
 z = x / y;
 T w = -octave_int_abs (x % y); // Can't overflow, but std::abs (x) can!
 if (w <= y - w)
 z -= 1 - (signbit (x) << 1);
 }
 }
 else
 {
 // FIXME -- this is a workaround due to MSVC's absence of
 // std::abs (int64_t).  The call to octave_int_abs can't
 // overflow, but std::abs (x) can!
 T w = octave_int_abs (x % y);
 if (w >= y - w)
 z += 1 - (signbit (x) << 1);
 }
 return z;
 }
 return static_cast<int64_t> (p);
 }
 #else
 // Special handler for 64-bit integer multiply.
 template <>
 OCTAVE_API int64_t
 octave_int_arith_base<int64_t, true>::mul (int64_t, int64_t);
 #endif
 // This class simply selects the proper arithmetics.
 template<class T>
 class octave_int_arith
 : public octave_int_arith_base<T, std::numeric_limits<T>::is_signed>
 {};
 template <class T>
 class
 octave_int (void) : ival () { }
 octave_int (T i) : ival (i) { }
 octave_int (double d) : ival (octave_int_base<T>::convert_real (d)) { }
 octave_int (float d) : ival (octave_int_base<T>::convert_real (d)) { }
 #ifdef OCTAVE_INT_USE_LONG_DOUBLE
 octave_int (long double d) : ival (octave_int_base<T>::convert_real (d)) { }
 #endif
 octave_int (bool b) : ival (b) { }
 template <class U>
 static const char *type_name ();
 // The following are provided for convenience.
 static const octave_int zero, one;
 // Unsafe.  This function exists to support the MEX interface.
 // You should not use it anywhere else.
 void *mex_get_data (void) const { return const_cast<T *> (&ival); }
 private:
 template <class T>
 octave_int<T>
 xmax (const octave_int<T>& x, const octave_int<T>& y)
 {
 const T xv = x.value (), yv = y.value ();
 return octave_int<T> (xv >= yv ? xv : yv);
 }
 template <class T>
 octave_int<T>
 xmin (const octave_int<T>& x, const octave_int<T>& y)
 {
 const T xv = x.value (), yv = y.value ();
 return octave_int<T> (xv <= yv ? xv : yv);
 }
 #endif

Mercurial > octave

comparison liboctave/oct-inttypes.h @ 11586:12df7854fa7c