Calculating π using the Gregory Leibniz series until n terms

Question

based off my previous challenge, this wikipedia article, and a Scratch project

Your task: given i, calculate \$\pi\$ till i terms of the Gregory-Leibniz series.

The series:

$$\pi=\frac{4}{1}-\frac{4}{3}+\frac{4}{5}-\frac{4}{7}+\frac{4}{9}-...$$

Here, 4/1 is the first term, -4/3 is the second, 4/5 is the second and so on.

Note that for the nth term,

• $$\text S_n = \frac{4 \times (-1)^{n+1}}{2n-1}$$
• $$\pi_n = \text S_1 + \text S_2 + ... + \text S_n,$$ where \$\pi_n\$ is \$\pi\$ approximated to \$n\$ terms.

Test cases:

In - Out
1 - 4
2 - 2.66666667
3 - 3.46666667
4 - 2.8952381

Floating point issues are OK.

You may not calculate infinite terms of pi using this as we are calculating a number rather than terms of a series here.

This is code-golf, so shortest answer wins!

EDIT: It's strange that this question got some new... activity.

Answer 1

Python 3, 36 35 bytes

f=lambda n,k=1:n and 4/k-f(n-1,k+2)

Try it online!

-1 thanks to Mukundan314.

Answer 2

05AB1E, 14 9 bytes

L·<z··R®β

-5 bytes porting @JonathanAllan's Jelly answer

Try it online or verify all test cases.

Original 14 bytes answer:

0λè®N>m4*N·</+

Try it online or verify the infinite sequence.

Explanation:

L          # Push a list in the range [1, (implicit) input]
 ·         # Double each value: [2,4,6,...,2n]
  <        # Decrease each by 1: [1,3,5,...,2n-1]
   z       # Calculate 1/z for each: [1,1/3,1/5,...,1/(2n-1)]
    4*     # Multiply by 4: [4,4/3,4/5,...,4/(2n-1)]
      R    # Reverse the list: [4/(2n-1),...,4/5,4/3,4]
       ®β  # Convert it from a base-(-1) list to a base-10 integer:
           #  (-1)^(n-1)*4/(2n-1) + ... + 1*4/5 + -1*4/3 + 1*4/1
           # (after which the result is output implicitly)

The 14-byter is pretty similar as my 05AB1E answer of the previous challenge.

 λ         # Start a recursive environment,
  è        # to calculate a(input)
           # (which is output implicitly afterwards)
0          # Start with a(0)=0
           # Where every following a(n) is calculated by:
           #  (implicitly push the previous term a(n-1))
   ®N>m    #  Push (-1) to the power (n+1)
       4*  #  Multiply it by 4
   N·<     #  Push 2n-1
   /       #  Divide the earlier 4*(-1)**(n+1) by this (2n-1)
    +      #  Add it to the previous term a(n-1)

Answer 3

R, 31 28 bytes

Edit: -3 bytes thanks to @Dominic van Essen.

\(n,m=2*1:n-1)sum(4i/1i^m/m)

Attempt This Online!

Uses $$ (-1)^{n+1} = -1 \times (-1)^{n} = i^2\times i^{-2n} = i^{-2n+2} = i \times i^{-(2n-1)}$$ And then $$\text S_n = \frac{4 \times (-1)^{n+1}}{2n-1} = \frac{\frac{4i}{i^{2n-1}} }{2n-1} $$

Answer 4

Jelly, 8 bytes

RḤ’4÷Ṛḅ-

A monadic Link that accepts a positive integer, \$n\$, and yields a floating point number, \$\pi_n\$.

Try it online!

How?

RḤ’4÷Ṛḅ- - Link: positive integer, n
R        - range n           -> [1,2,3,...,n]
 Ḥ       - double            -> [2,4,6,...,2n]
  ’      - decrement         -> [1,3,5,...,2n-1]
   4     - 4
    ÷    - divide            -> [4/1,4/3,4/5,...,4/(2n-1)]
     Ṛ   - reverse           -> [4/(2n-1),...,4/5,4/3,4/1]
       - - -1
      ḅ  - convert from base -> (-1)^(n-1)*4/(2n-1)+...+1*4/5+-1*4/3+1*4/1 = pi_n

Answer 5

C (gcc), ⁶³ 60 bytes

float f(n){float m=4,p=1,d=1;for(;n--;d+=2,m=-m)p+=m/d;--p;}

Try it online!

Saved 3 bytes thanks to jdt!!!

Answer 6

Excel, 51 48 bytes

^{Saved 3 bytes thanks to some clever math from JvdV}

=LET(s,SEQUENCE(A1),SUM((8*ISODD(s)-4)/(2*s-1)))

Input is in the cell A1. Output is wherever the formula is.

• LET(s,SEQUENCE(A1) defines s to be an array of numbers from 1 to the value in A1. This is what lets us calculate the first n terms.
• (8*ISODD(s)-4) creates an array of the same sized filled with 4, -4, 4, -4, .... The only trick is that ISODD() returns a boolean and Excel turns TRUE into 1 and FALSE into 0 when you force it to do math. That means it becomes an array of 8-4, 0-4, 8-4, 0-4, ... which then simplifies as shown above.
• (2*s-1) creates an array of the same size filled with 1, 3, 5, 7, ...
• SUM((~)/(~)) divides the first array by the second (giving us each term in the sequence) and then adds them up.

Answer 7

Python 3, ⁴¹ 39 bytes

f=lambda x:x and(x%2*4-2)/(x-.5)+f(x-1)

Try it online!

Answer 8

Desmos, 30 bytes

f(n)=∑_{k=1}^n4(-1)^k/(1-2k)

Pretty self-explanatory.

Try It On Desmos!

Try It On Desmos! - Prettified

Answer 9

Vyxal ḋ, 10 bytes

4ÞNÞ∞d‹/¦i

Try it Online!

4          # 4
 ÞN        # [4, -4, 4, -4, 4, -4...
   Þ∞      # [1, 2, 3, 4, 5, 6...
     d     # [2, 4, 6, 8, 10, 12...
      ‹    # [1, 3, 5, 7, 9, 11...
       /   # [4/1, -4/3, 4/5, -4/7...
        ¦  # Take the cumulative sums of that
         i # Index the input into that

Answer 10

Haskell, 28 bytes

f n=foldr((-).(2/))0[1/2..n]

Try it online!

Answer 11

Japt -mx, 11 bytes

4*JpU /(UÑÄ

Try it

Without Flags, 11 bytes

DZZ4/°ZÃÔìJ

Try it

4*JpU /(UÑÄ     :Implicit map of each U in the range [0,input)
4*              :Multiply 4 by
  J             :-1
   pU           :Raised to the power of U
      /(        :Divide by
        UÑ      :U times 2
          Ä     :Plus 1
                :Implicit output of sum of resulting array

DZZ4/°ZÃÔìJ     :Implicit input of integer U
Ç               :Map each Z in the range [0,U)
 ±Z             :  Increment Z by itself
   4/           :  Divide 4 by
     °Z         :  Z, prefix incremented
       Ã        :End map
        Ô       :Reverse
         ì      :Convert from digit array in base
          J     :  -1

Answer 12

Vyxal ḋ, 13 bytes

Flag ḋ prints out rationals in their decimal form

ƛ4nd‹/un›e*;∑

Try it Online!

Explanation:

ƛ4nd‹/un›e*;∑
ƛ          ;    Map trough range of input
 4nd‹/          Divide four by 2n-1
      un›e*     Raise -1 to the n+1 and multiply
            ∑   Sum the fractions

Another 13 byter: ƛ4nd‹/k-ni*;∑

Answer 13

Factor + koszul math.unicode, 51 bytes

[ [1,b] [ dup 1 + -1^ 4 * swap 2 * 1 - / ] map Σ ]

Try it online!

• [1,b] [ ... ] map Σ Map each integer in 1..input using [ ... ] and add them together.
• dup 1 + -1^ 4 * swap 2 * 1 - / Just a straight translation of $$\text S_n = \frac{4 \times (-1)^{n+1}}{2n-1}$$ Here's how the data stack looks arriving at the second term to add together:

       ! 2
dup    ! 2 2
1      ! 2 2 1
+      ! 2 3
-1^    ! 2 -1
4      ! 2 -1 4
*      ! 2 -4
swap   ! -4 2
2      ! -4 2 2
*      ! -4 4
1      ! -4 4 1
-      ! -4 3
/      ! -1-1/3

Answer 14

Fortran (GFortran), 60 bytes

function a(j)
do i=1,j
a=a+4.0*(-1)**(i+1)/(2*i-1)
enddo
end

Try it online!

Mostly just exploiting implicit typing so no need to declare variable types. Also saves 1 byte by removing the space between end and do.

Answer 15

Husk, 10 9 bytes

-1 thanks to a clever rearrangement by Dominic van Essen

Ḟ`-↑M/İ14

Try it online!

Explanation

Husk's reversed operand order for subtraction really hurts here, but at least Dominic found a nice workaround for the reversed division.

Ḟ`-↑M/İ14
      İ1   Infinite list of positive odd numbers
        4  Integer 4
    M      For each element in the first argument,
     /     divide the second argument by it
   ↑       Take the first N elements, where N is the program's argument
Ḟ          Right-fold the resulting list
 `-        on subtraction

Answer 16

C (gcc), 47 bytes

float f(n){return--n?(4.-n%2*8)/(n-~n)+f(n):4;}

Try it online!

Answer 17

APL (Dyalog Unicode), 18 bytes ^SBCS

(4ׯ1*⍳)+.÷(1+2×⍳)

Try it on APLgolf!

A tacit function.

Answer 18

Charcoal, 14 bytes

ＩΣＥＮ×Ｘ±¹ι∕⁴⊕⊗ι

Try it online! Link is to verbose version of code. Explanation:

   Ｎ            Input `n` as a number
  Ｅ             Map over implicit range
       ¹        Literal integer `1`
      ±         Negated
     Ｘ          Raised to power
        ι       Current value
    ×           Multiplied by
          ⁴     Literal integer `4`
         ∕      Divided by
             ι  Current value
            ⊗   Doubled
           ⊕    Incremented
 Σ              Take the sum
Ｉ               Cast to string
                Implicitly print

Answer 19

Haskell, 36 bytes

f i=g[1,3..i*2]
g(h:t)=4/h-g t
g[]=0

Try it online!

I think it's quite self descriptive due to Haskell feature of describing something.

I try to visualize what g does, pretty simple : taking a list of i denominators but all positive...

[1,      3,      5,      7]
                       4/7
               4/5 -  (4/7)
 4 - ( 4/3 - ( 4/5 -  (4/7)))

hence the signs result alternating
 4 -   4/3 +   4/5 -   4/7

Answer 20

Wolfram Language (Mathematica), 26 bytes

Tr[4I^#/I/#&[2Range@#-1]]&

Try it online!

Unnamed function that takes a positive integer argument and returns an exact fraction (the TIO footer shows both the output fraction and its decimal equivalent). Managed to beat the super straightforward Sum[-4(-1)^j/(2j-1),{j,#}]& by one byte by using powers of the complex unit I instead of powers of -1.

Answer 21

x86 32-bit machine code, 23 bytes

D9 EE D9 E8 D9 E8 D8 C0 DC E9 D8 F1 DE E2 E2 F4 DD D8 D8 C0 D9 E1 C3

Try it online!

Following the fastcall calling convention, this takes a number n in ECX and returns the sum of the first n terms on the FPU register stack.

This code creates −2/1, −2/3, −2/5, ..., and combines them using the reverse-subtract instruction. This is equivalent to negating the running total before adding each term; this handles the alternating signs, but leaves the result with the wrong sign for odd n, which is corrected for by taking the absolute value at the end (because all the correct results are positive). The value is also doubled at the end.

In assembly:

                        # Example execution for i=2
                        # FPU register stack (left is bottom):
f:  fldz                # 0
    fld1                # 0   1
r:  fld1                # 0   1   1
    fadd st(0), st(0)   # 0   1   2
    fsub st(1), st(0)   # 0  -1   2
    fdiv st(0), st(1)   # 0  -1  -2/1
    fsubrp st(2), st(0) # -2/1  -1
    loop r              #[The loop executes again:
                        # -2/1  -1   1
                        # -2/1  -1   2
                        # -2/1  -3   2
                        # -2/1  -3  -2/3
                        # -2/3+2/1  -3            ]
    fstp st(0)          # -2/3+2/1
    fadd st(0), st(0)   # -4/3+4/1
    fabs                # -4/3+4/1   (but for odd n, this fixes the sign)
    ret

Answer 22

BQN, 9 bytes

-´4÷1+2×↕

Try it at BQN online!

Explanation

-´4÷1+2×↕
        ↕  Range [0, n)
      2×   Double each number
    1+     Add 1 to each number
  4÷       Divide 4 by each number
-´         Right fold on subtraction

Answer 23

MATLAB, 34 bytes

f=@(n)sum(4./[1:4:2*n,-(3:4:2*n)])

An anonymous function that makes an array of [ 1 5 9 ... -3 -7 -11 ...], member-wise divides 4 by the array and then sums the result.

Test:

arrayfun(f, 1:4)
  ans = 4.0000    2.6667    3.4667    2.8952

Answer 24

Rust, 62 bytes

fn f(n:f32,k:f32)->f32{if n==0.{return 4./k}4./k-f(n-1.,k+2.)}

Try it online!

Answer 25

Math++, 49 bytes

?>x
1>a
1>b
k+b*4/a>k
a+2>a
-b>b
x-1>x
4+5*!x>$
k

Answer 26

Raku, 26 bytes

[\+] (4,-*...*)Z/(1,3...*)

Try it online!

This is an expression for the infinite sequence of partial sums.

• (4, -* ... *) is the sequence 4, -4, 4, -4, ....
• (1, 3 ... *) is the sequence 1, 3, 5, ....
• Z/ zips those two sequences together using division.
• [\+] produces the sequence of partial sums.

Answer 27

><>, 33 bytes

0$\~n;
(?\:2%2*1-4*$:}2*1-,+$1-:1

Try it online

Answer 28

TI-Basic, 22 bytes

sum(4/seq((1-2I)(-1)^I,I,1,Ans

Takes input in Ans. The first - is the subtraction sign, and the second is the negative sign. Only works for inputs less than or equal to 999, or 99 on a TI-83. For larger inputs, use this:

29 bytes

Input N
For(I,1,N
Ans+4(-1)^I/(1-2I
End
Ans

The first - is the negative sign, and the second is the subtraction sign. Assumes being run on fresh/RAM cleared calculator.

Answer 29

APL (Dyalog Unicode), 10 bytes

4×-/÷1+2×⍳

Try it on TryAPL.org!

The environmental variable ⎕IO←0.

A tacit function.

Answer 30

Pyth, 11 bytes

*4smc^_1dhy

Test suite

Explanation:

*4smc^_1dhy   | Full code
*4smc^_1dhydQ | with implicit variables
--------------+
   m        Q | For each d from 0 to input:
    c^_1dhyd  |  (-1)^d/(2d+1)
  s           | Sum the results
*4            | Print sum * 4