Question

我只是在学习haskell（我自己，为了好玩）而且我遇到了墙。

我的问题：

如何定义功能

flrt = (floor . sqrt)

当我在文件中编写并编译时，GCHi会抱怨以下内容：

AKS.hs:11:9:
    No instance for (RealFrac Integer)
      arising from a use of `floor'
    Possible fix: add an instance declaration for (RealFrac Integer)
    In the first argument of `(.)', namely `floor'
    In the expression: (floor . sqrt)
    In an equation for `flrt': flrt = (floor . sqrt)

AKS.hs:11:17:
    No instance for (Floating Integer)
      arising from a use of `sqrt'
    Possible fix: add an instance declaration for (Floating Integer)
    In the second argument of `(.)', namely `sqrt'
    In the expression: (floor . sqrt)
    In an equation for `flrt': flrt = (floor . sqrt)

我不明白为什么结果函数不只是Int - ＆gt;中间体

我刚刚完成了CS的第二年并完成了基础PL课程。我听说过，但还没有得到类型。我尝试阅读一些haskell教程，但这一切都超越了我的想法。

P.S。 - 我也不明白monad是什么。（我的搜索出现的很多其他问题都谈到了这些问题）

P.P.S。 - 我的完整资料来源

bar = \a b -> if (2^a) > b
                then (a-1)
                else bar (a+1) b
foo = bar 1

flrt :: Integer -> Integer
flrt = (floor . sqrt)

aks target = if (target < 2)
                then putStr "Not a Prime.\n\n"
                else if elem (mod target 10) [0,2,4,5,6,8]
                        then putStr "Composite\n\n"
                        else if (elem target) [a^b | a <- [3,5..(flrt target)], b <- [1.. (foo target)]]

                                then putStr "Composite\n\n"--}
                            else 
                            putStr "filler"

Answer 1

问题在于您尝试使用Integer作为输入。 Haskell是强类型的，这意味着没有任何类型的隐式强制或转换。看看你想要撰写的函数的签名：

sqrt  :: Floating a => a -> a
floor :: (RealFrac a, Integral b) => a -> b

由GHC推断出你的功能的签名：

> :t floor . sqrt
floor . sqrt :: (RealFrac b, Integral c, Floating b) => b -> c

因此，要拥有从Integer（没有Floating实例）到Integer的函数，您必须先将参数转换为Floating }，可以使用fromIntegral：

来完成

> :t floor . sqrt . fromIntegral
floor . sqrt . fromIntegral :: (Integral a, Integral c) => a -> c

Answer 2

正如copumpkin所说的那样，在这里转换为浮点可能实际上是一个坏主意，因为这会导致精度损失，因此即使使用舍入，也可能会产生足够大的整数输入的错误结果。

我假设你所处理的所有数字至少都足够小，以至于为它们提供了一些浮点表示，例如：一切都是＆lt; 10 ³⁰⁰。但是，例如

Prelude> round(sqrt.fromInteger$10^60 :: Double) ^ 2
1000000000000000039769249677312000395398304974095154031886336
Prelude>  {-   and not   -}     10^60    {-  == (10^30)^2 == (sqrt$10^60) ^ 2  -}
1000000000000000000000000000000000000000000000000000000000000

在绝对差异方面，方式关闭。它仍然是数字本身的一个相当好的近似相对，因此您可以将其用作算法的快速确定的起点，以找到确切的结果。您可以使用Integer s实现Newton / Raphson（在本例中为AKA Heron）：

flrt :: Integer -> Integer  -- flrt x ≈ √x,  with  flrt x^2 ≤ x < flrt(x+1)^2
flrt x = approx (round . (sqrt::Double->Double) . fromInteger $ x)
   where approx r
            | ctrl <= x, (r+1)^2 > x  = r
            | otherwise               = approx $ r - diff
          where ctrl = r^2
                diff = (ctrl - x) // (2*r)    -- ∂/∂x x² = 2x

         a//b = a`div`b + if (a>0)==(b>0) then 1 else 0   -- always away from 0

现在可以按照需要运行：

*IntegerSqrt> (flrt $ 10^60) ^ 2
1000000000000000000000000000000000000000000000000000000000000

Newton-Raphson校正中的除法总是偏离0，这是防止陷入无限递归所必需的。

在哈斯克尔组成楼层和sqrt

2 个答案: