Ramanujan's constant: Difference between revisions

=={{header|C++}}==

{{libheader|Boost}}

#include <iostream>

#include <boost/math/constants/constants.hpp>

}

return 0;

 

{{out}}

=={{header|Fōrmulæ}}==

 

 

 

 

=={{header|Go}}==

 

Also the math.Pi built in constant is not accurate enough to be used with big.Float and so I have used a more accurate string representation instead.

 

import (

fmt.Printf("%3d: %51.32f ≈ %18d (diff: %.32f)\n", h[0], qh, c, t)

}

 

{{out}}

67: 147197952743.99999866245422450682926131257863 ≈ 147197952744 (diff: 0.00000133754577549317073868742137)

163: 262537412640768743.99999999999925007259719818568888 ≈ 262537412640768744 (diff: 0.00000000000074992740280181431112)

</pre>

 

exp=: (1x"_)`((($:~<:)+^%!@x:@])~)@.(0<[) NB. recursive Taylor series x exp y recursively sums x terms of Taylor series for Exp[y], memoization candidate.

</pre>

NB. takes the constant beyond the repeat 9s.

S=: cf_sqrt&163 Digits 34

262537412640768743.9999999999992500711164316586918409066184

NB. ^

 

=={{header|Java}}==

Very interesting. Compute Pi, E, and square root to arbitrary precision.

import java.math.BigDecimal;

import java.math.MathContext;

}

 

{{out}}

 

=={{header|Julia}}==

 

julia> a = BigFloat(MathConstants.e^(BigFloat(pi)))^(BigFloat(163.0)^0.5)

7.499274028018143111206461436626630091372924626572825942241598957614307213309258e-13

 

 

=={{header|Pari/GP}}==

{{out}}

<pre>

===Direct calculation===

{{trans|Sidef}}

use warnings;

use Math::AnyNum;

my $n = Math::AnyNum::ipow($x, 3) + 744;

printf("%3s: %51s ≈ %18s (diff: %s)\n", $h, $c, $n, ($n - $c)->round(-32));

{{out}}

<pre>

===Continued fractions===

{{trans|Raku}}

use Math::AnyNum <as_dec rat>;

 

 

printf "Ramanujan's constant\n%s\n", as_dec($R,58);

{{out}}

<pre>Ramanujan's constant

{{trans|Go}}

{{libheader|Phix/mpfr}}

{{out}}

<pre>

=={{header|Python}}==

{{libheader|mpmath}}

heegner = [19,43,67,163]

mp.dps = 50

for i in heegner:

print(" for {}: {} ~ {} error: {}".format(str(i),mp.exp(mp.pi*mp.sqrt(i)),round(mp.exp(mp.pi*mp.sqrt(i))),(mp.pi*mp.sqrt(i)) - round(mp.pi*mp.sqrt(i))))

{{out}}

<pre>

[http://rosettacode.org/wiki/Calculating_the_value_of_e Euler's number], and

[http://rosettacode.org/wiki/Arithmetic-geometric_mean/Integer_roots integer roots]. Additional custom routines for exponentiation are used to ensure all computations are done with rationals, specifically <tt>FatRat</tt>s (rational numbers stored with arbitrary size numerator and denominator). The module <tt>Rat::Precise</tt> makes it simple to display these to a configurable precision.

 

# set the degree of precision for calculations

while (abs($mid - $exp) > ε) {

$sqr = sqrt($sqr);

$mid = ($low + $high) / 2;

}

 

for ^d {

$n += $n;

($a, $g) = @$_;

 

multi sqrt(FatRat $r --> FatRat) {

}

 

 

# calculation of 𝑒

sub 𝑒 (--> FatRat) { sum map { FatRat.new(1,.!) }, ^D }

 

constant 𝑒 = &𝑒();

 

say "Ramanujan's constant to 32 decimal places:\nActual: " ~

"262537412640768743.99999999999925007259719818568888\n" ~

say "Heegner numbers yielding 'almost' integers";

for 19, 96, 43, 960, 67, 5280, 163, 640320 -> $heegner, $x {

say format($exact, $almost);

{{out}}

<pre>Ramanujan's constant to 32 decimal places:

===Continued fractions===

Ramanujan's constant can also be generated to an arbitrary precision using standard [https://en.wikipedia.org/wiki/Generalized_continued_fraction continued fraction formulas] for each component of the 𝑒**(π*√163) expression. Substantially slower than the first method.

 

sub continued-fraction($n, :@a, :@b) {

#`{ e**x } my $R = 1 + ($_ / continued-fraction(170, :a( 1,|(2+$_, 3+$_ ... *)), :b(Nil, |(-1*$_, -2*$_ ... *) ))) given $r163*$pi;

 

{{out}}

<pre>Ramanujan's constant to 32 decimal places:

=={{header|REXX}}==

Instead of calculating &nbsp; <big> '''e''' </big> &nbsp; and &nbsp; <big><big><math>\pi</math></big></big> &nbsp; to some arbitrary length, &nbsp; it was easier to just include those two constants with &nbsp; '''201''' &nbsp; decimal digits &nbsp; (which is the amount of decimal digits used for the calculations). &nbsp; The results are displayed &nbsp; (right justified) &nbsp; with one-half of that number of decimal digits past the decimal point.

d= min( length(pi()), length(e()) ) - length(.) /*calculate max #decimal digs supported*/

parse arg digs sDigs . 1 . . $ /*obtain optional arguments from the CL*/

numeric form; m.=9; parse value format(x,2,1,,0) 'E0' with g 'E' _ .; g=g*.5'e'_%2

do j=0 while h>9; m.j=h; h=h % 2 + 1; end /*j*/

{{out|output|text=&nbsp; when using the default inputs:}}

<pre>

</pre>

 

=={{header|Sidef}}==

local Num!PREC = *"#{4*round((Num.pi*√x)/log(10) + decimals + 1)}"

exp(Num.pi * √x) -> round(-decimals).to_s

var n = (x**3 + 744)

printf("%3s: %51s ≈ %18s (diff: %s)\n", h, c, n, n-Num(c))

{{out}}

<pre>

 

Heegner numbers yielding 'almost' integers:

19: 885479.77768015431949753789348171962682 ≈ 885480 (diff: 0.22231984568050246210651828037318)

43: 884736743.99977746603490666193746207858538 ≈ 884736744 (diff: 0.00022253396509333806253792141462)