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

 

 

Table[

c = N[Exp[Pi Sqrt[h]], 40];

,

{h, {19, 43, 67, 163}}

{{out}}

<pre>{2,6,2,5,3,7,4,1,2,6,4,0,7,6,8,7,4,3,9,9,9,9,9,9,9,9,9,9,9,9,2,5,0,0,7,2,5,9,7,1,9,8,1,8,5,6,8,8,8,7,9,3,5,3,8,5,6,3,3,7,3,3,6,9,9,0,8,6,2,7,0,7,5,3,7,4,1,0,3,7,8,2,1,0,6,4,7,9,1,0,1,1,8,6,0,7,3,1,2,9,5,1,1,8,1,3,4,6,1,8,6,0,6,4,5,0,4,1,9,3,0,8,3,8,8,7,9,4,9,7,5,3,8,6,4,0,4,4,9,0,5,7,2,8,7,1,4,4,7,7,1,9,6,8,1,4,8,5,2,3,2,2,4,3,2,0,3,9,1,1,6,4,7,8,2,9,1,4,8,8,6,4,2,2,8,2,7,2,0,1,3,1,1,7,8,3,1,7,0,6}

=={{header|Nim}}==

{{libheader|nim-decimal}}

import decimal

 

let d = x - k

let s = if d > 0: "+ " & $d else: "- " & $(-d)

 

{{out}}

 

=={{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 {

my $exact = $x³ + 744;

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>

 

=={{header|Ruby}}==

include BigMath

 

puts "#{x}: #{(e ** (pi * BigMath.sqrt(BigDecimal(x), 200))).round(100).to_s("F")}"

end

{{out}}

<pre>19: 885479.7776801543194975378934817196268207142865018553571526577110128809842286637202423189990118182067775711

</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>

 

I've therefore hard-coded a value for pi with 70 decimal places (more than enough for this task) and written a 'big' exponential function using the Taylor series for e(x). The latter requires a lot of iterations and is therefore quite slow (takes about 5 seconds to calculate the Ramanujan constant). However, this is acceptable for a scripting language such as Wren.

 

var pi = "3.1415926535897932384626433832795028841971693993751058209749445923078164"

rc = rc.toDecimal(32)

Fmt.print("$3d: $51s ≈ $18s (diff: $s)", h, r, rc, diff)

 

{{out}}