Cálculo de pi mediante los métodos de Gregory-Leibniz y de Beeler

PorJosé A. Alonso 7-abril-202026-marzo-2022

La fórmula de Gregory-Leibniz para calcular pi es

y la de Beeler es

Definir las funciones

   aproximaPiGL     :: Int -> Double
   aproximaPiBeeler :: Int -> Double
   graficas         :: [Int] -> IO ()

1

2

3

aproximaPiGL :: Int -> Double

aproximaPiBeeler :: Int -> Double

graficas :: [Int] -> IO ()

tales que

(aproximaPiGL n) es la aproximación de pi con los primeros n términos de la fórmula de Gregory-Leibniz. Por ejemplo,

     aproximaPiGL 1       ==  4.0
     aproximaPiGL 2       ==  2.666666666666667
     aproximaPiGL 3       ==  3.466666666666667
     aproximaPiGL 10      ==  3.0418396189294032
     aproximaPiGL 100     ==  3.1315929035585537
     aproximaPiGL 1000    ==  3.140592653839794
     aproximaPiGL 10000   ==  3.1414926535900345
     aproximaPiGL 100000  ==  3.1415826535897198

1

2

3

4

5

6

7

8

aproximaPiGL 1 == 4.0

aproximaPiGL 2 == 2.666666666666667

aproximaPiGL 3 == 3.466666666666667

aproximaPiGL 10 == 3.0418396189294032

aproximaPiGL 100 == 3.1315929035585537

aproximaPiGL 1000 == 3.140592653839794

aproximaPiGL 10000 == 3.1414926535900345

aproximaPiGL 100000 == 3.1415826535897198

(aproximaPiBeeler n) es la aproximación de pi con los primeros n términos de la fórmula de Beeler. Por ejemplo,

     aproximaPiBeeler 1   ==  2.0
     aproximaPiBeeler 2   ==  2.6666666666666665
     aproximaPiBeeler 3   ==  2.933333333333333
     aproximaPiBeeler 10  ==  3.140578169680337
     aproximaPiBeeler 60  ==  3.141592653589793
     pi                   ==  3.141592653589793

1

2

3

4

5

6

aproximaPiBeeler 1 == 2.0

aproximaPiBeeler 2 == 2.6666666666666665

aproximaPiBeeler 3 == 2.933333333333333

aproximaPiBeeler 10 == 3.140578169680337

aproximaPiBeeler 60 == 3.141592653589793

pi == 3.141592653589793

(graficas xs) dibuja la gráfica de las k-ésimas aproximaciones de pi, donde k toma los valores de la lista xs, con las fórmulas de Gregory-Leibniz y de Beeler. Por ejemplo, (graficas [1..25]) dibuja

donde la línea morada corresponde a la aproximación de Gregory-Leibniz y la verde a la de Beeler.

Soluciones

import Graphics.Gnuplot.Simple

-- Definiciones de aproximaPiGL
-- ============================

-- 1ª definición de aproximaPiGL
aproximaPiGL :: Int -> Double
aproximaPiGL n = 4 * (sum . take n . sumaA . zipWith (/) [1,1..]) [1,3..]
  where sumaA (x:y:xs) = x:(-y):sumaA xs

-- 2ª definición de aproximaPiGL
aproximaPiGL2 :: Int -> Double
aproximaPiGL2 n =
  4 * (sum (take n (zipWith (/) (cycle [1,-1]) [1,3..])))

-- 3ª definición de aproximaPiGL
aproximaPiGL3 :: Int -> Double
aproximaPiGL3 n =
  4 * (sum . take n . zipWith (/) (cycle [1,-1])) [1,3..]

-- 4ª definición de aproximaPiGL
aproximaPiGL4 :: Int -> Double
aproximaPiGL4 n = serieGL !! (n-1)

serieGL :: [Double]
serieGL = scanl1 (+) (zipWith (/) numeradores denominadores)
  where numeradores   = cycle [4,-4]
        denominadores = [1,3..]

-- Definición de aproximaPiBeeler
aproximaPiBeeler :: Int -> Double
aproximaPiBeeler n = 2 * aux (fromIntegral n) 1
  where
    aux :: Double -> Double -> Double 
    aux n k | n == k    = 1
            | otherwise = 1 + (k/(2*k+1)) * aux n (1+k)

-- Definición de graficas
graficas :: [Int] -> IO ()
graficas xs = 
    plotLists [Key Nothing]
             [[(k,aproximaPiGL k)     | k <- xs],
              [(k,aproximaPiBeeler k) | k <- xs]]

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

import Graphics.Gnuplot.Simple

-- Definiciones de aproximaPiGL

-- ============================

-- 1ª definición de aproximaPiGL

aproximaPiGL :: Int -> Double

aproximaPiGL n = 4 * (sum . take n . sumaA . zipWith (/) [1,1..]) [1,3..]

where sumaA (x:y:xs) = x:(-y):sumaA xs

-- 2ª definición de aproximaPiGL

aproximaPiGL2 :: Int -> Double

aproximaPiGL2 n =

4 * (sum (take n (zipWith (/) (cycle [1,-1]) [1,3..])))

-- 3ª definición de aproximaPiGL

aproximaPiGL3 :: Int -> Double

aproximaPiGL3 n =

4 * (sum . take n . zipWith (/) (cycle [1,-1])) [1,3..]

-- 4ª definición de aproximaPiGL

aproximaPiGL4 :: Int -> Double

aproximaPiGL4 n = serieGL !! (n-1)

serieGL :: [Double]

serieGL = scanl1 (+) (zipWith (/) numeradores denominadores)

where numeradores = cycle [4,-4]

denominadores = [1,3..]

-- Definición de aproximaPiBeeler

aproximaPiBeeler :: Int -> Double

aproximaPiBeeler n = 2 * aux (fromIntegral n) 1

where

aux :: Double -> Double -> Double

aux n k | n == k = 1

| otherwise = 1 + (k/(2*k+1)) * aux n (1+k)

-- Definición de graficas

graficas :: [Int] -> IO ()

graficas xs =

plotLists [Key Nothing]

[[(k,aproximaPiGL k) | k <- xs],

[(k,aproximaPiBeeler k) | k <- xs]]

Otras soluciones

Se pueden escribir otras soluciones en los comentarios.
El código se debe escribir entre una línea con <pre lang="haskell"> y otra con </pre>

4 Comentarios

import Graphics.Gnuplot.Simple

aproximaPiGL :: Int -> Double
aproximaPiGL n =
  4 * sum [(-1)**(k+1)/(2*k-1) | k <- [1,2..fromIntegral (n)]]

aproximaPiBeeler :: Int -> Double
aproximaPiBeeler n =
  2 * aux [k/(2*k+1) | k <- [1.. fromIntegral (n-1)]]
  where aux []     = 1
        aux (x:xs) = 1 + x * aux xs

graficas :: [Int] -> IO ()
graficas xs =
  plotLists [ Key Nothing
            , Title "Aproximaciones de Pi: Gregory-Leibniz y de Beeler"]
            [map aproximaPiGL xs, map aproximaPiBeeler xs]

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

import Graphics.Gnuplot.Simple

aproximaPiGL :: Int -> Double

aproximaPiGL n =

4 * sum [(-1)**(k+1)/(2*k-1) | k <- [1,2..fromIntegral (n)]]

aproximaPiBeeler :: Int -> Double

aproximaPiBeeler n =

2 * aux [k/(2*k+1) | k <- [1.. fromIntegral (n-1)]]

where aux [] = 1

aux (x:xs) = 1 + x * aux xs

graficas :: [Int] -> IO ()

graficas xs =

plotLists [ Key Nothing

, Title "Aproximaciones de Pi: Gregory-Leibniz y de Beeler"]

[map aproximaPiGL xs, map aproximaPiBeeler xs]

import Graphics.Gnuplot.Simple

aproximaPiGL :: Int -> Double
aproximaPiGL 1 = 4
aproximaPiGL n
  | even n    = a - m
  | otherwise = a + m  
  where a =  aproximaPiGL (n-1)
        m = 4 / [3,5..] !! (n-2)

aproximaPiBeeler :: Int -> Double
aproximaPiBeeler n = 2 * foldr f 1 xs
  where f (a,b) xs = 1 + a/b * xs 
        xs         = [(x,2*x+1) | x <- [1..fromIntegral (n-1)]]

graficas :: [Int] -> IO ()
graficas xs =
  plotLists [Key Nothing, PNG "graficasGLyB.png"]
            [map aproximaPiGL xs, map aproximaPiBeeler xs]

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

import Graphics.Gnuplot.Simple

aproximaPiGL :: Int -> Double

aproximaPiGL 1 = 4

aproximaPiGL n

| even n = a - m

| otherwise = a + m

where a = aproximaPiGL (n-1)

m = 4 / [3,5..] !! (n-2)

aproximaPiBeeler :: Int -> Double

aproximaPiBeeler n = 2 * foldr f 1 xs

where f (a,b) xs = 1 + a/b * xs

xs = [(x,2*x+1) | x <- [1..fromIntegral (n-1)]]

graficas :: [Int] -> IO ()

graficas xs =

plotLists [Key Nothing, PNG "graficasGLyB.png"]

[map aproximaPiGL xs, map aproximaPiBeeler xs]

import Graphics.Gnuplot.Simple

aproximaPiGL :: Int -> Double
aproximaPiGL n = 4 * (sum $ take n [(-1)**n/(2*n+1) | n <- [0..]])

aproximaPiBeeler :: Int -> Double
aproximaPiBeeler n = 2 * (aux n 1)
  where aux n m
          | n == 1    = 1
          | m == n-1  = 1 + m'/(2*m'+1)
          | otherwise = 1 + m'/(2*m'+1)*(aux n (m+1))
          where m' = fromIntegral m

graficas :: [Int] -> IO ()
graficas ns = 
  plotLists [Key Nothing, PNG "calculoPiLeibnizBeeler.png"]
            [map aproximaPiGL ns, map aproximaPiBeeler ns]

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

import Graphics.Gnuplot.Simple

aproximaPiGL :: Int -> Double

aproximaPiGL n = 4 * (sum $ take n [(-1)**n/(2*n+1) | n <- [0..]])

aproximaPiBeeler :: Int -> Double

aproximaPiBeeler n = 2 * (aux n 1)

where aux n m

| n == 1 = 1

| m == n-1 = 1 + m'/(2*m'+1)

| otherwise = 1 + m'/(2*m'+1)*(aux n (m+1))

where m' = fromIntegral m

graficas :: [Int] -> IO ()

graficas ns =

plotLists [Key Nothing, PNG "calculoPiLeibnizBeeler.png"]

[map aproximaPiGL ns, map aproximaPiBeeler ns]

Otra forma de calcular la aproximación de Gregory-Leibniz:

terminosPiGL :: [Double]
terminosPiGL = [((-1)**n) * (1/m) | (n,m) <- zip [0..] [1,3..]]

aproximaPiGL :: Int -> Double
aproximaPiGL n = 4 * (sum $ take n terminosPiGL)

1

2

3

4

5

terminosPiGL :: [Double]

terminosPiGL = [((-1)**n) * (1/m) | (n,m) <- zip [0..] [1,3..]]

aproximaPiGL :: Int -> Double

aproximaPiGL n = 4 * (sum $ take n terminosPiGL)

Escribe tu soluciónCancel reply