Haskell: lambda

Question

'daki sınırlayıcı değişkenleri referanslayan tümcenin, trapez kuralını kullanarak Haskell'deki bir işlevi sayısal olarak entegre etmeye çalışıyorum, entegre edilecek aralığın bitiş noktaları için argümanları a, b alan bir anti-türevi döndürüyorum. Yukarıda

integrate :: (Float -> Float) -> (Float -> Float -> Float) 

integrate f 
    = \ a b -> d * sum [ f (a + d*k) | k <- [0..n] ] - d/2.0 * (f a + f b) 
    where 
     d = (b - a)/n 
     n = 1000 

, I Bu neredeyse lambda b, bir bağlı argümanlar haricinde, işler

n - for the number of subintervals 
d - for the width of each subinterval 

kullanın. Ben hata mesajı alıyorum:

Not in scope: `b' 
Not in scope: `a' 

Ben kapsamı b sadece bu lambda ifadesi sınırlı olduğunu anlayabiliyorum ama I (yazmak zorunda kalmamak için Haskell bir çözüm vardır Yukarıdaki her bir d için ba)/n?

Answer 1

deneyin:

integrate f a b = d * sum [ f (a + d*k) | k <- [0..n] ] - d/2.0 * (f a + f b) 
    where 
     d = (b - a)/n 
     n = 1000 

Answer 2

Sen iki Float s alır ve Float döndüren bir işlev dönmek gerekiyor düşünüyorsunuz ama aslında sizin integrate işlevinde iki ekstra Float argümansız ve kullanmanın farklı değil Körpe (yani sadece sağlanmayan ve dönüş tipi Float -> Float -> Float olacaktır).

Yani bunun

integrate :: (Float -> Float) -> Float -> Float -> Float 

integrate f a b 
    = d * sum [ f (a + d*k) | k <- [0..n] ] - d/2.0 * (f a + f b) 
    where 
     d = (b - a)/n 
     n = 1000 

gibi işlev yazabiliriz Yoksa where yerine let ... in kullanabilirsiniz:

integrate f 
    = \a b -> 
     let d = (b - a/n) 
      n = 1000 
     in d * sum [ f (a + d * k) | k <- [0..n] ] - d/2.0 * (f a + f b) 

Answer 3

Tabi. nereye ısrar ederse

integrate f a b = d * sum [ f (a + d*k) | k <- [0..n] ] - d/2.0 * (f a + f b) 
    where 
     d = (b - a)/n 
     n = 1000 

Answer 4

:

integrate f = \a b -> case() of 
    () -> d * sum [ f (a + d*k) | k <- [0..n] ] - d/2.0 * (f a + f b) 
      where 
       d = (b - a)/n 
       n = 1000 

oldukça güzel görünüyor, değil mi? durum biraz daha motive görünmesi için:

integrate f = \a b -> case (f a + f b) of 
    fs -> d * sum [ f (a + d*k) | k <- [0..n] ] - d/2.0 * fs 
      where 
       d = (b - a)/n 
       n = 1000 

Answer 5

Sen çözüm yolları yer çok şey var.

Eğer lambda ifadeleri dışında herhangi bağlayıcı sözdizimi bilmiyorsanız size (çünkü onun teorik güzelliği en çok sevdiğim hangi ama asla nedeniyle sözdizimsel çirkinlik kullanın) yapabilirsiniz:

integrate f 
    = \a b -> (\d -> d * sum [ f (a + d*k) | k <- [0..n] ] - d/2.0 * (f a + f b)) 
      ((b - a)/n) 
    where 
     n = 1000 

ise Eğer tanımları görmek ve sadece bunu yapabilirsiniz -syntax where biliyorum: Ayrıca let -Sözdizimi biliyorsanız

integrate f = go 
    where 
    n = 1000 
    go a b = d * sum [ f (a + d*k) | k <- [0..n] ] - d/2.0 * (f a + f b) 
     where 
     d = (b - a)/n 

, bunu yapabilirsiniz:

Eğer a -> (b -> c -> d) a -> b -> c -> d aynı olduğunu hatırlarsanız

integrate f = 
    \a b -> let d = (b - a)/n 
      in d * sum [ f (a + d*k) | k <- [0..n] ] - d/2.0 * (f a + f b) 
    where 
    n = 1000 

Son olarak, bariz yapabilirsiniz:

integrate f a b = d * sum [ f (a + d*k) | k <- [0..n] ] - d/2.0 * (f a + f b) 
    where 
    n = 1000 
    d = (b - a)/n