表示 0 到 1 范围内的浮点数的最佳方式是什么？

Question

我正在寻找能够表示值 0.213123 或 0.0 或 1.0 的数值类型，但拒绝超出范围的值，例如 -0.2123 和 1.2312。是否存在适合该目的的特定类型，将数字限制在特定范围内的最佳通用方法是什么？

当然，想到的第一个答案是：只使用Double，但是被 Haskell 的类型系统宠坏了，我已经习惯了在类型级别上最大限度地保护程序。

Answer 1

严肃的建议

您可以在适当位大小的单词周围使用新类型包装器（和智能构造器）：

newtype SmallFrac = SF Word64

-- Example conversion (You'd actually want to make
-- instances of common classes, I assume)
sfToDouble :: SmallFrac -> Double
sfToDouble (SF x) = fromIntegral x / fromIntegral (maxBound `asTypeOf` x)

instance Show SmallFrac where
    show = show . sfToDouble

实现乘法和除法的成本可能比您想的要高，但至少加法很容易（防止上溢/下溢的模数），而且您声称不需要任何运算甚至更好。

一个不太有用的建议

如果您只需要一个表示值介于 1 和 0 之间的符号，那么请采纳 dave4420 的建议，只需要一个单位类型：

newtype SmallFrac = SF ()

没有针对这种类型的操作，甚至没有转换到/从其他类型的兴趣，例如Double，但这符合所述的要求。

Answer 2

不标准。你必须做一个——我建议smart constructor。请记住，尽管这种类型支持的数字操作很少——您不能添加它们并将它们保留在集合中，也不能否定它们，所以我建议不要使用 Num 实例。在乘法上使用Monoid 是合理的。

Answer 3

基于Double的表示

newtype Rep1 = Rep1 Double

checkRange :: Double -> Maybe Double
checkRange x
  | 0 < x && x < 1 = Just x
  | otherwise = Nothing

toRep1 :: Double -> Maybe Rep1
toRep1 x = Rep1 . (\x -> tan $ (x-0.5) * pi) <$> checkRange x

fromRep1 :: Rep1 -> Double
fromRep1 (Rep1 x) = atan x / pi + 0.5

基于整数的表示

data Rep2 = Rep2 Integer Integer

fromRep2 :: Rep2 -> Double
fromRep2 (Rep2 a b) = fromIntegral (abs a) / fromIntegral (abs a + abs b + 1)

toRep2 :: Double -> Maybe Rep2
toRep2 = error "left to the reader"

Answer 4

智能构造器模式的一种变体。

这可能有点过头了。

{-# LANGUAGE TemplateHaskell #-}
module Foo (Foo(), doubleFromFoo,
            maybeFooFromDouble, unsafeFooFromDouble, thFooFromDouble)
where
import Language.Haskell.TH

不管怎样，标准的newtype...

newtype Foo = Foo Double

获取Double 很容易...

doubleFromFoo :: Foo -> Double
doubleFromFoo (Foo x) = x

在运行时放入 Double 会导致运行时检查，无法绕过...

maybeFooFromDouble :: Double -> Maybe Foo
maybeFooFromDouble x
        | 0 <= x && x <= 1 = Just (Foo x)
        | otherwise        = Nothing

...除非您对不安全感到高兴（并且有一些社交手段来强制所有unsafeFooFromDouble 的使用实际上都是安全的）...

unsafeFooFromDouble :: Double -> Foo
unsafeFooFromDouble = Foo

但如果它是编译时常量，您可以在编译时进行检查，而无需运行时开销：

thFooFromDouble :: (Real a, Show a) => a -> Q Exp
thFooFromDouble x
        | 0 <= x && x <= 1 = return $ AppE (VarE 'unsafeFooFromDouble)
                                           (LitE (RationalL (toRational x)))
        | otherwise        = fail $ show x ++ " is not between 0 and 1"

这就是你使用最后一个函数的方式：

$(thFooFromDouble 0.3)

切记不要在$ 和(! 之间放置任何空格。