Vibescript Showcase

Chudnovsky π

Calculate 100 digits of π with the Chudnovsky formula and big integers.

Edit the source, then Run. Checks start after your first Run. Ctrl/⌘ + Enter runs; Tab indents. Preview services use sample data and never contact a real service.

Sourceshowcase/math/chudnovsky_pi.vibe
# Binary splitting: each leaf holds one series term's P, Q, T; merges combine
# ranges with T(a,b) = Q(m,b)T(a,m) + P(a,m)T(m,b), exactly as the Go
# implementation does across CPU cores. 10939058860032000 is 640320^3 // 24.
type RunResult = {
  digits_per_term: float,
  matching_reference_digits: int,
  pi_100_digits: string,
  terms_used: int
}

def split_series(a: int, b: int) -> [int, int, int]
  if b - a == 1
    if a == 0
      p = 1
      q = 1
    else
      p = (6 * a - 5) * (2 * a - 1) * (6 * a - 1)
      q = a * a * a * 10939058860032000
    end
    t = p * (13591409 + 545140134 * a)
    if a % 2 == 1
      t = -t
    end
    [p, q, t]
  else
    m = (a + b) // 2
    left = split_series(a, m)
    right = split_series(m, b)
    [
      left.fetch(0) * right.fetch(0),
      left.fetch(1) * right.fetch(1),
      right.fetch(1) * left.fetch(2) + left.fetch(0) * right.fetch(2)
    ]
  end
end

# Integer Newton square root. Starting above the true root, the sequence
# descends monotonically and stops exactly at floor(sqrt(n)).
def integer_sqrt(n: int, seed: int) -> int
  x = (seed + n // seed) // 2
  y = (x + n // x) // 2
  while y < x
    x = y
    y = (x + n // x) // 2
  end
  x
end

def matching_digits(computed: string, reference: string) -> int
  pairs = computed.chars.zip(reference.chars)
  first_mismatch = pairs.index { |pair| pair[0] != pair[1] }
  if first_mismatch == nil
    computed.length
  else
    first_mismatch
  end
end

def run -> RunResult
  digits = 100
  scale = digits + 5
  terms = scale // 14 + 2

  p, q, t = split_series(0, terms)

  # sqrt(10005) is about 100.025, so 101 * 10^scale starts above the root. An
  # integer seed keeps every step exact at any number of digits.
  seed = 101 * (10 ** scale)
  sqrt_c = integer_sqrt(10005 * (10 ** (2 * scale)), seed)

  # pi * 10^scale = 426880 * sqrt(10005 * 10^(2*scale)) * Q // T
  pi = (q * 426880 * sqrt_c) // t
  computed = "3.#{pi.to_s.slice(1, digits)}"
  reference = "3.1415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253421170679"

  {
    pi_100_digits: computed,
    matching_reference_digits: matching_digits(computed, reference),
    terms_used: terms,
    digits_per_term: 14.18
  }
end

Output

Click Run example to see the result.

Code checks

Run once to load the checker. Your code stays in this browser.