packages feed

altfloat 0.3 → 0.3.1

raw patch · 6 files changed

+163/−22 lines, 6 filesPVP: major bump suggested

API removals or changes: PVP suggests a major version bump

API changes (from Hackage documentation)

- Data.Floating.Environment: instance (Eq a) => Eq (FEnv a)
- Data.Floating.Environment: instance (Floating a) => Floating (FEnv a)
- Data.Floating.Environment: instance (Fractional a) => Fractional (FEnv a)
- Data.Floating.Environment: instance (Num a) => Num (FEnv a)
- Data.Floating.Environment: instance (RealFloat a) => RealFloat (FEnv a)
- Data.Floating.Environment: instance (Show a) => Show (FEnv a)
- Data.Floating.Types: instance [overlap ok] (Real a) => FloatConvert a Double
- Data.Floating.Types: instance [overlap ok] (Real a) => FloatConvert a Float
- Data.Poset: instance (Poset a) => Poset (Maybe a)
- Data.Poset: instance (Poset a) => Poset [a]
+ Data.Floating.Environment: instance Eq a => Eq (FEnv a)
+ Data.Floating.Environment: instance Floating a => Floating (FEnv a)
+ Data.Floating.Environment: instance Fractional a => Fractional (FEnv a)
+ Data.Floating.Environment: instance Num a => Num (FEnv a)
+ Data.Floating.Environment: instance RealFloat a => RealFloat (FEnv a)
+ Data.Floating.Environment: instance Show a => Show (FEnv a)
+ Data.Floating.Types: instance [overlap ok] Real a => FloatConvert a Double
+ Data.Floating.Types: instance [overlap ok] Real a => FloatConvert a Float
+ Data.Poset: instance Poset a => Poset (Maybe a)
+ Data.Poset: instance Poset a => Poset [a]
- Data.Floating: fquotRem :: (RealFloat a) => a -> a -> (a, a)
+ Data.Floating: fquotRem :: RealFloat a => a -> a -> (a, a)
- Data.Floating: isFinite :: (PrimFloat a) => a -> Bool
+ Data.Floating: isFinite :: PrimFloat a => a -> Bool
- Data.Floating: isInfinite :: (PrimFloat a) => a -> Bool
+ Data.Floating: isInfinite :: PrimFloat a => a -> Bool
- Data.Floating: isNaN :: (PrimFloat a) => a -> Bool
+ Data.Floating: isNaN :: PrimFloat a => a -> Bool
- Data.Floating: isNegativeZero :: (PrimFloat a) => a -> Bool
+ Data.Floating: isNegativeZero :: PrimFloat a => a -> Bool
- Data.Floating: isNormal :: (PrimFloat a) => a -> Bool
+ Data.Floating: isNormal :: PrimFloat a => a -> Bool
- Data.Floating: isSubNormal :: (PrimFloat a) => a -> Bool
+ Data.Floating: isSubNormal :: PrimFloat a => a -> Bool
- Data.Floating: toFloating :: (FloatConvert a b) => a -> b
+ Data.Floating: toFloating :: FloatConvert a b => a -> b
- Data.Floating.Classes: (**) :: (Floating a) => a -> a -> a
+ Data.Floating.Classes: (**) :: Floating a => a -> a -> a
- Data.Floating.Classes: acos :: (Floating a) => a -> a
+ Data.Floating.Classes: acos :: Floating a => a -> a
- Data.Floating.Classes: acosh :: (Floating a) => a -> a
+ Data.Floating.Classes: acosh :: Floating a => a -> a
- Data.Floating.Classes: asin :: (Floating a) => a -> a
+ Data.Floating.Classes: asin :: Floating a => a -> a
- Data.Floating.Classes: asinh :: (Floating a) => a -> a
+ Data.Floating.Classes: asinh :: Floating a => a -> a
- Data.Floating.Classes: atan :: (Floating a) => a -> a
+ Data.Floating.Classes: atan :: Floating a => a -> a
- Data.Floating.Classes: atan2 :: (RealFloat a) => a -> a -> a
+ Data.Floating.Classes: atan2 :: RealFloat a => a -> a -> a
- Data.Floating.Classes: atanh :: (Floating a) => a -> a
+ Data.Floating.Classes: atanh :: Floating a => a -> a
- Data.Floating.Classes: cbrt :: (RealFloat a) => a -> a
+ Data.Floating.Classes: cbrt :: RealFloat a => a -> a
- Data.Floating.Classes: ceiling :: (Roundable a) => a -> a
+ Data.Floating.Classes: ceiling :: Roundable a => a -> a
- Data.Floating.Classes: class (Fractional a) => Floating a
+ Data.Floating.Classes: class Fractional a => Floating a
- Data.Floating.Classes: class (Floating a) => RealFloat a
+ Data.Floating.Classes: class Floating a => RealFloat a
- Data.Floating.Classes: classify :: (PrimFloat a) => a -> FPClassification
+ Data.Floating.Classes: classify :: PrimFloat a => a -> FPClassification
- Data.Floating.Classes: copysign :: (RealFloat a) => a -> a -> a
+ Data.Floating.Classes: copysign :: RealFloat a => a -> a -> a
- Data.Floating.Classes: cos :: (Floating a) => a -> a
+ Data.Floating.Classes: cos :: Floating a => a -> a
- Data.Floating.Classes: cosh :: (Floating a) => a -> a
+ Data.Floating.Classes: cosh :: Floating a => a -> a
- Data.Floating.Classes: erf :: (RealFloat a) => a -> a
+ Data.Floating.Classes: erf :: RealFloat a => a -> a
- Data.Floating.Classes: erfc :: (RealFloat a) => a -> a
+ Data.Floating.Classes: erfc :: RealFloat a => a -> a
- Data.Floating.Classes: exp :: (Floating a) => a -> a
+ Data.Floating.Classes: exp :: Floating a => a -> a
- Data.Floating.Classes: exp2 :: (RealFloat a) => a -> a
+ Data.Floating.Classes: exp2 :: RealFloat a => a -> a
- Data.Floating.Classes: expm1 :: (RealFloat a) => a -> a
+ Data.Floating.Classes: expm1 :: RealFloat a => a -> a
- Data.Floating.Classes: floor :: (Roundable a) => a -> a
+ Data.Floating.Classes: floor :: Roundable a => a -> a
- Data.Floating.Classes: fma :: (RealFloat a) => a -> a -> a -> a
+ Data.Floating.Classes: fma :: RealFloat a => a -> a -> a -> a
- Data.Floating.Classes: fmod :: (RealFloat a) => a -> a -> a
+ Data.Floating.Classes: fmod :: RealFloat a => a -> a -> a
- Data.Floating.Classes: frem :: (RealFloat a) => a -> a -> a
+ Data.Floating.Classes: frem :: RealFloat a => a -> a -> a
- Data.Floating.Classes: gamma :: (RealFloat a) => a -> a
+ Data.Floating.Classes: gamma :: RealFloat a => a -> a
- Data.Floating.Classes: hypot :: (RealFloat a) => a -> a -> a
+ Data.Floating.Classes: hypot :: RealFloat a => a -> a -> a
- Data.Floating.Classes: infinity :: (RealFloat a) => a
+ Data.Floating.Classes: infinity :: RealFloat a => a
- Data.Floating.Classes: lgamma :: (RealFloat a) => a -> a
+ Data.Floating.Classes: lgamma :: RealFloat a => a -> a
- Data.Floating.Classes: log :: (Floating a) => a -> a
+ Data.Floating.Classes: log :: Floating a => a -> a
- Data.Floating.Classes: log10 :: (RealFloat a) => a -> a
+ Data.Floating.Classes: log10 :: RealFloat a => a -> a
- Data.Floating.Classes: log1p :: (RealFloat a) => a -> a
+ Data.Floating.Classes: log1p :: RealFloat a => a -> a
- Data.Floating.Classes: log2 :: (RealFloat a) => a -> a
+ Data.Floating.Classes: log2 :: RealFloat a => a -> a
- Data.Floating.Classes: logb :: (RealFloat a) => a -> a
+ Data.Floating.Classes: logb :: RealFloat a => a -> a
- Data.Floating.Classes: nan :: (RealFloat a) => a
+ Data.Floating.Classes: nan :: RealFloat a => a
- Data.Floating.Classes: nearbyint :: (RealFloat a) => a -> a
+ Data.Floating.Classes: nearbyint :: RealFloat a => a -> a
- Data.Floating.Classes: nextafter :: (RealFloat a) => a -> a -> a
+ Data.Floating.Classes: nextafter :: RealFloat a => a -> a -> a
- Data.Floating.Classes: pi :: (RealFloat a) => a
+ Data.Floating.Classes: pi :: RealFloat a => a
- Data.Floating.Classes: rint :: (RealFloat a) => a -> a
+ Data.Floating.Classes: rint :: RealFloat a => a -> a
- Data.Floating.Classes: round :: (Roundable a) => a -> a
+ Data.Floating.Classes: round :: Roundable a => a -> a
- Data.Floating.Classes: sin :: (Floating a) => a -> a
+ Data.Floating.Classes: sin :: Floating a => a -> a
- Data.Floating.Classes: sinh :: (Floating a) => a -> a
+ Data.Floating.Classes: sinh :: Floating a => a -> a
- Data.Floating.Classes: sqrt :: (Floating a) => a -> a
+ Data.Floating.Classes: sqrt :: Floating a => a -> a
- Data.Floating.Classes: tan :: (Floating a) => a -> a
+ Data.Floating.Classes: tan :: Floating a => a -> a
- Data.Floating.Classes: tanh :: (Floating a) => a -> a
+ Data.Floating.Classes: tanh :: Floating a => a -> a
- Data.Floating.Classes: truncate :: (Roundable a) => a -> a
+ Data.Floating.Classes: truncate :: Roundable a => a -> a
- Data.Floating.Types: toFloating :: (FloatConvert a b) => a -> b
+ Data.Floating.Types: toFloating :: FloatConvert a b => a -> b
- Data.Poset: (<) :: (Poset a) => a -> a -> Bool
+ Data.Poset: (<) :: Poset a => a -> a -> Bool
- Data.Poset: (</=>) :: (Poset a) => a -> a -> Bool
+ Data.Poset: (</=>) :: Poset a => a -> a -> Bool
- Data.Poset: (<=) :: (Poset a) => a -> a -> Bool
+ Data.Poset: (<=) :: Poset a => a -> a -> Bool
- Data.Poset: (<==>) :: (Poset a) => a -> a -> Bool
+ Data.Poset: (<==>) :: Poset a => a -> a -> Bool
- Data.Poset: (>) :: (Poset a) => a -> a -> Bool
+ Data.Poset: (>) :: Poset a => a -> a -> Bool
- Data.Poset: (>=) :: (Poset a) => a -> a -> Bool
+ Data.Poset: (>=) :: Poset a => a -> a -> Bool
- Data.Poset: class (Sortable a) => Ord a
+ Data.Poset: class Sortable a => Ord a
- Data.Poset: class (Eq a) => Poset a
+ Data.Poset: class Eq a => Poset a
- Data.Poset: class (Poset a) => Sortable a
+ Data.Poset: class Poset a => Sortable a
- Data.Poset: compare :: (Poset a) => a -> a -> Ordering
+ Data.Poset: compare :: Poset a => a -> a -> Ordering
- Data.Poset: comparing :: (Poset b) => (a -> b) -> a -> a -> Ordering
+ Data.Poset: comparing :: Poset b => (a -> b) -> a -> a -> Ordering
- Data.Poset: isOrdered :: (Sortable a) => a -> Bool
+ Data.Poset: isOrdered :: Sortable a => a -> Bool
- Data.Poset: max :: (Sortable a) => a -> a -> a
+ Data.Poset: max :: Sortable a => a -> a -> a
- Data.Poset: min :: (Sortable a) => a -> a -> a
+ Data.Poset: min :: Sortable a => a -> a -> a
- Data.Poset: sort :: (Sortable a) => [a] -> [a]
+ Data.Poset: sort :: Sortable a => [a] -> [a]
- Data.Poset: sortBy :: (Sortable a) => (a -> a -> Ordering) -> [a] -> [a]
+ Data.Poset: sortBy :: Sortable a => (a -> a -> Ordering) -> [a] -> [a]

Files

Data/Floating/CMath.hs view
@@ -17,13 +17,13 @@     c_acosh, c_acoshf, c_asinh, c_asinhf, c_atanh, c_atanhf, c_cosh, c_coshf,     c_sinh, c_sinhf, c_tanh, c_tanhf, -    -- * Exponential functions+    -- * Exponential and logarithmic functions     c_exp, c_expf, c_exp2, c_exp2f, c_expm1, c_expm1f, c_frexp, c_frexpf,     c_ilogb, c_ilogbf, c_ldexp, c_ldexpf, c_log, c_logf, c_log10, c_log10f,     c_log1p, c_log1pf, c_log2, c_log2f, c_logb, c_logbf, c_modf, c_modff,     c_scalbn, c_scalbnf, c_scalbln, c_scalblnf, -    -- * Power and absolute value functions+    -- * Power and absolute-value functions     c_cbrt, c_cbrtf, c_fabs, c_fabsf, c_hypot, c_hypotf, c_pow, c_powf, c_sqrt,     c_sqrtf, @@ -92,9 +92,9 @@     c_atan :: CDouble -> CDouble foreign import ccall unsafe "atanf"     c_atanf :: CFloat -> CFloat-foreign import ccall unsafe "atan"+foreign import ccall unsafe "atan2"     c_atan2 :: CDouble -> CDouble -> CDouble-foreign import ccall unsafe "atanf"+foreign import ccall unsafe "atan2f"     c_atan2f :: CFloat -> CFloat -> CFloat foreign import ccall unsafe "cos"     c_cos :: CDouble -> CDouble@@ -135,7 +135,7 @@ foreign import ccall unsafe "tanhf"     c_tanhf :: CFloat -> CFloat --- 7.12.6 Exponential functions+-- 7.12.6 Exponential and logarithmic functions foreign import ccall unsafe "exp"     c_exp :: CDouble -> CDouble foreign import ccall unsafe "expf"@@ -193,7 +193,7 @@ foreign import ccall unsafe "scalblnf"     c_scalblnf :: CFloat -> CLong -> CFloat --- 7.12.7 Power and absolute value functions+-- 7.12.7 Power and absolute-value functions foreign import ccall unsafe "cbrt"     c_cbrt :: CDouble -> CDouble foreign import ccall unsafe "cbrtf"
Data/Floating/Types.hs view
@@ -32,16 +32,6 @@ -- | The Float type.  data Float  = F# Float# --- | This type is identical to CDouble.  For some reason unknown to me, it is--- impossible to marshal data from Double to CDouble without losing--- information.  The issue is further complicated by Foreign.C.Types not--- exporting CDouble's constructor.  Thus, to marshal data from Double to--- CDouble, we construct an instance of this type and then use unsafeCoerce.-newtype FuckFFIDouble = FuckD Double---- | The analogue of FuckFFIDouble for CFloat.-newtype FuckFFIFloat  = FuckF Float- -- | Coercion to floating point types. class FloatConvert a b where     -- | Convert to a floating point type.  Conversions from integers and real@@ -51,16 +41,16 @@     toFloating :: a -> b  instance FloatConvert Double CDouble where-    toFloating = unsafeCoerce . FuckD+    toFloating = unsafeCoerce  instance FloatConvert CDouble Double where-    toFloating f = let FuckD x = unsafeCoerce f in x+    toFloating = unsafeCoerce  instance FloatConvert Float CFloat where-    toFloating = unsafeCoerce . FuckF+    toFloating = unsafeCoerce  instance FloatConvert CFloat Float where-    toFloating f = let FuckF x = unsafeCoerce f in x+    toFloating = unsafeCoerce  instance FloatConvert Double Float where     toFloating (D# x) = F# (double2Float# x)
altfloat.cabal view
@@ -1,5 +1,5 @@ Name:               altfloat-Version:            0.3+Version:            0.3.1 License:            OtherLicense License-File:       LICENSE Cabal-Version:      >= 1.6
config.h.in view
@@ -3,6 +3,27 @@ /* The normal alignment of `fenv_t', in bytes. */ #undef ALIGNOF_FENV_T +/* Define to the value of DBL_MANT_DIG */+#undef DBL_MANT_DIG_VAL++/* Define to the value of DBL_MAX_EXP */+#undef DBL_MAX_EXP_VAL++/* Define to the value of DBL_MIN_EXP */+#undef DBL_MIN_EXP_VAL++/* Define to the value of FLT_MANT_DIG */+#undef FLT_MANT_DIG_VAL++/* Define to the value of FLT_MAX_EXP */+#undef FLT_MAX_EXP_VAL++/* Define to the value of FLT_MIN_EXP */+#undef FLT_MIN_EXP_VAL++/* Define to the value of FLT_RADIX */+#undef FLT_RADIX_VAL+ /* Define to 1 if you do not have a working acosf function. */ #undef NEED_LIBM_ACOSF
configure view
@@ -3036,6 +3036,136 @@   +	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking floating point radix" >&5+$as_echo_n "checking floating point radix... " >&6; }+	if test "${altfloat_cv_FLT_RADIX+set}" = set; then :+  $as_echo_n "(cached) " >&6+else+  if ac_fn_c_compute_int "$LINENO" "FLT_RADIX" "altfloat_cv_FLT_RADIX"        "#include <float.h>"; then :++fi++fi++	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $altfloat_cv_FLT_RADIX" >&5+$as_echo "$altfloat_cv_FLT_RADIX" >&6; }++cat >>confdefs.h <<_ACEOF+#define FLT_RADIX_VAL $altfloat_cv_FLT_RADIX+_ACEOF++	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking precision of double" >&5+$as_echo_n "checking precision of double... " >&6; }+	if test "${altfloat_cv_DBL_MANT_DIG+set}" = set; then :+  $as_echo_n "(cached) " >&6+else+  if ac_fn_c_compute_int "$LINENO" "DBL_MANT_DIG" "altfloat_cv_DBL_MANT_DIG"        "#include <float.h>"; then :++fi++fi++	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $altfloat_cv_DBL_MANT_DIG digits" >&5+$as_echo "$altfloat_cv_DBL_MANT_DIG digits" >&6; }++cat >>confdefs.h <<_ACEOF+#define DBL_MANT_DIG_VAL $altfloat_cv_DBL_MANT_DIG+_ACEOF++	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking precision of float" >&5+$as_echo_n "checking precision of float... " >&6; }+	if test "${altfloat_cv_FLT_MANT_DIG+set}" = set; then :+  $as_echo_n "(cached) " >&6+else+  if ac_fn_c_compute_int "$LINENO" "FLT_MANT_DIG" "altfloat_cv_FLT_MANT_DIG"        "#include <float.h>"; then :++fi++fi++	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $altfloat_cv_FLT_MANT_DIG digits" >&5+$as_echo "$altfloat_cv_FLT_MANT_DIG digits" >&6; }++cat >>confdefs.h <<_ACEOF+#define FLT_MANT_DIG_VAL $altfloat_cv_FLT_MANT_DIG+_ACEOF+++	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking minimum normal exponent for double" >&5+$as_echo_n "checking minimum normal exponent for double... " >&6; }+	if test "${altfloat_cv_DBL_MIN_EXP+set}" = set; then :+  $as_echo_n "(cached) " >&6+else+  if ac_fn_c_compute_int "$LINENO" "DBL_MIN_EXP" "altfloat_cv_DBL_MIN_EXP"        "#include <float.h>"; then :++fi++fi++	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $altfloat_cv_DBL_MIN_EXP" >&5+$as_echo "$altfloat_cv_DBL_MIN_EXP" >&6; }++cat >>confdefs.h <<_ACEOF+#define DBL_MIN_EXP_VAL $altfloat_cv_DBL_MIN_EXP+_ACEOF++	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking maximum finite exponent for double" >&5+$as_echo_n "checking maximum finite exponent for double... " >&6; }+	if test "${altfloat_cv_DBL_MAX_EXP+set}" = set; then :+  $as_echo_n "(cached) " >&6+else+  if ac_fn_c_compute_int "$LINENO" "DBL_MAX_EXP" "altfloat_cv_DBL_MAX_EXP"        "#include <float.h>"; then :++fi++fi++	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $altfloat_cv_DBL_MAX_EXP" >&5+$as_echo "$altfloat_cv_DBL_MAX_EXP" >&6; }++cat >>confdefs.h <<_ACEOF+#define DBL_MAX_EXP_VAL $altfloat_cv_DBL_MAX_EXP+_ACEOF++	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking minimum normal exponent for float" >&5+$as_echo_n "checking minimum normal exponent for float... " >&6; }+	if test "${altfloat_cv_FLT_MIN_EXP+set}" = set; then :+  $as_echo_n "(cached) " >&6+else+  if ac_fn_c_compute_int "$LINENO" "FLT_MIN_EXP" "altfloat_cv_FLT_MIN_EXP"        "#include <float.h>"; then :++fi++fi++	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $altfloat_cv_FLT_MIN_EXP" >&5+$as_echo "$altfloat_cv_FLT_MIN_EXP" >&6; }++cat >>confdefs.h <<_ACEOF+#define FLT_MIN_EXP_VAL $altfloat_cv_FLT_MIN_EXP+_ACEOF++	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking maximum finite exponent for float" >&5+$as_echo_n "checking maximum finite exponent for float... " >&6; }+	if test "${altfloat_cv_FLT_MAX_EXP+set}" = set; then :+  $as_echo_n "(cached) " >&6+else+  if ac_fn_c_compute_int "$LINENO" "FLT_MAX_EXP" "altfloat_cv_FLT_MAX_EXP"        "#include <float.h>"; then :++fi++fi++	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $altfloat_cv_FLT_MAX_EXP" >&5+$as_echo "$altfloat_cv_FLT_MAX_EXP" >&6; }++cat >>confdefs.h <<_ACEOF+#define FLT_MAX_EXP_VAL $altfloat_cv_FLT_MAX_EXP+_ACEOF++++ replaced_libm=no  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for library containing nan" >&5
configure.ac view
@@ -5,7 +5,7 @@ dnl without any warranty.  AC_PREREQ(2.62)-AC_INIT([altfloat],[0.3],[nbowler@draconx.ca])+AC_INIT([altfloat],[0.3.1],[nbowler@draconx.ca]) AC_CONFIG_SRCDIR([altfloat.cabal]) AC_CONFIG_HEADER([config.h])