Calculating the value of e: Difference between revisions

=={{header|11l}}==

{{trans|Python}}

V e = 2.0

V n = 0

print(‘Real e = ’math:e)

print(‘Error = ’(math:e - e))

{{out}}

<pre>

The 'include' file FORMAT, to format a floating point number, can be found in:

[[360_Assembly_include|Include files 360 Assembly]].

CALCE PROLOG

LE F0,=E'0'

PG DC CL80' ' buffer

REGEQU

{{out}}

<pre>

{{libheader|Action! Tool Kit}}

{{libheader|Action! Real Math}}

 

PROC Euler(REAL POINTER e)

Print("calculated e=") PrintRE(calc)

Print(" error=") PrintRE(diff)

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Calculating_the_value_of_e.png Screenshot from Atari 8-bit computer]

=={{header|Ada}}==

{{trans|Kotlin}}

with Ada.Long_Float_Text_IO; use Ada.Long_Float_Text_IO;

 

New_Line;

 

{{out}}

<pre>

=={{header|ALGOL 68}}==

{{trans|Kotlin}}

# calculate an approximation to e #

LONG REAL epsilon = 1.0e-15;

DO SKIP OD;

print( ( "e = ", fixed( e, -17, 15 ), newline ) )

{{out}}

<pre>

For the purposes of 32 bit floating point, the value seems to stabilise after summing c. 16 terms.

 

on run

foldl(add, 0, xs)

{{Out}}

<pre>2.718281828459</pre>

 

Or, as a single fold:

 

-- eApprox :: Int -> Float

end script

end if

{{Out}}

<pre>2.718281828459</pre>

 

=={{header|Applesoft BASIC}}==

{{Out}}

<pre>E = 2.71828183</pre>

=={{header|Arturo}}==

 

e: 2.0

e0: 0.0

]

 

 

{{out}}

 

=={{header|Asymptote}}==

real e1, e;

n *= n1;

}

{{out}}

<pre>The value of e = 2.71828182845905</pre>

 

=={{header|AWK}}==

# syntax: GAWK -f CALCULATING_THE_VALUE_OF_E.AWK

BEGIN {

}

function abs(x) { if (x >= 0) { return x } else { return -x } }

{{out}}

<pre>

=={{header|BASIC}}==

==={{header|BASIC256}}===

e1 = 0 : e = 1 / 1

 

 

print "The value of e = "; e

{{out}}

<pre>The value of e = 2.71828182829</pre>

{{works with|QBasic|1.1}}

{{works with|QuickBasic|4.5}}

 

e! = 1 / 1

LOOP

 

{{out}}

<pre>The value of e = 2.718282</pre>

==={{header|True BASIC}}===

{{works with|QBasic}}

LET n1 = 1

 

 

PRINT "The value of e ="; e

{{out}}

<pre>The value of e = 2.7182818</pre>

{{works with|QBasic}}

{{works with|FreeBASIC| with #lang "qb"}}

e1 = 0 : e = 1 / 1

 

wend

 

{{out}}

<pre>The value of e = 2.71828</pre>

=={{header|Befunge}}==

Befunge has no decimal capabilities, evaluates as fractions of 10^17

{{out}}

<pre>2718281828459045</pre>

 

=={{header|Burlesque}}==

blsq ) 70rz?!{10 100**\/./}ms36.+Sh'.1iash

2.7182818284590452353602874713526624977572470936999595749669676277240766303535475945713821785251664274

 

=={{header|C}}==

===solution 1===

#include <math.h>

 

 

return 0;

{{output}}

<pre>

===solution 2===

{{trans|Kotlin}}

#include <math.h>

 

printf("e = %.15f\n", e);

return 0;

 

{{output}}

 

=={{header|C sharp|C#}}==

 

namespace CalculateE {

}

}

{{out}}

<pre>e = 2.718281828459050</pre>

 

===Using Decimal type===

 

class Calc_E

Console.WriteLine(CalcE()); // Decimal precision result

}

{{out}}

<pre>2.71828182845905

{{libheader|System.Numerics}}

Automatically determines number of padding digits required for the arbitrary precision output. Can calculate a quarter million digits of '''e''' in under half a minute.

using static System.Math; using static System.Console;

 

WriteLine("partial: {0}...{1}", es.Substring(0, 46), es.Substring(es.Length - 45));

}

{{out}}

<pre>2.71828182845905

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

{{trans|C}}

#include <iomanip>

#include <cmath>

cout << "e = " << setprecision(16) << e << endl;

return 0;

 

{{output}}

 

=={{header|Clojure}}==

;; Calculating the number e, euler-napier number.

;; We will use two methods

(time (with-precision 110 (method-e 200M)))

 

 

<pre>

=={{header|COBOL}}==

{{trans|C}}

IDENTIFICATION DIVISION.

PROGRAM-ID. EULER.

DISPLAY RESULT-MESSAGE.

STOP RUN.

{{out}}

<pre>

=={{header|Commodore BASIC}}==

Commodore BASIC floats have a 40-bit mantissa, so we get max precision after just 11 iterations:

100 REM COMPUTE E VIA INVERSE FACTORIAL SUM

110 N = 11:REM NUMBER OF ITERATIONS

160 : E = E + 1/F

170 NEXT I

 

{{Out}}

Common Lisp performs exact rational arithmetic, but printing those results out in decimal form is challenging; the built-in options require conversion to floating point values of relatively low precision. The QuickLisp module <tt>computable-reals</tt> makes printing out precise decimal representations easy, though:

 

(use-package :computable-reals)

 

(setq e (+ e (/ 1 f))))

(format t "After ~a iterations, e = " *iterations*)

 

{{Out}}

 

=={{header|D}}==

import std.stdio;

 

} while (abs(e - e0) >= EPSILON);

writefln("e = %.15f", e);

{{out}}

<pre>e = 2.718281828459046</pre>

Here's the 1000-iteration code, which keeps 2574 digits of precision to ensure that it gets the answer right to 2570 (and then only prints it out to 2570):

 

2574k [ precision to use during computation ]sx

1 d se sf [ set e and f to 1 ]sx

2570k [ now reset precision to match correct digits ]sx

le 1 / [ get result truncated to that precision ]sx

 

{{Out}}

 

{{Trans|C}}

program Calculating_the_value_of_e;

 

end.

 

 

{{out}}

{{trans|Swift}}

 

func abs(n) {

if n < 0 {

}

 

{{out}}

 

=={{header|EasyLang}}==

fact = 1

n = 2

e += 1 / fact

.

 

=={{header|EDSAC order code}}==

by calculating e - 2 and printing the result with '2' in front.

It will be seen that the answer is 3 out in the 10th decimal place.

[Calculate e]

[EDSAC program, Initial Orders 2]

E14Z [relative address of entry]

PF [enter with accumulator = 0]

{{out}}

<pre>

 

The program executes about 38 million orders (16 hours on the original EDSAC) and prints e to 1324 decimal places. Because of rounding errors, the last two places are wrong (should be 61, not 44).

[Calculate e by multilength variables.

EDSAC program, Initial Orders 2.

E 184 Z [define entry point]

P F [acc = 0 on entry]

{{out}}

<pre>

===Spigot algorithm===

The EDSAC program to calculate pi by means of a spigot algorithm is easily modified to calculate e. It will then output 2070 correct digits of e (though it outputs only 252 correct digits of pi). Details will be found under the task "Pi".

[Code not given, as it is almost the same as the EDSAC spigot algorithm for pi.

See the task "Pi" for the EDSAC program and the changes needed to calculate e.]

{{out}}

<pre>

 

=={{header|Emacs Lisp}}==

"Compute factorial of i."

(apply #'* (number-sequence 1 i)))

(mapcar #'factorial (number-sequence 1 iter)))))

 

{{output}}

<pre>

 

=={{header|Epoxy}}==

var E:1,F:1

loop I:1;I<=P;I+:1 do

 

log(CalculateE(100))

{{out}}

<pre>2.7182818284590455

 

{{Works with|Office 365 betas 2021}}

=LAMBDA(n,

INDEX(

1

)

 

and also assuming the following generic bindings in the Name Manager for the WorkBook:

 

=LAMBDA(op,

LAMBDA(a,

)

)

 

{{Out}}

 

=={{header|F_Sharp|F#}}==

// A function to generate the sequence 1/n!). Nigel Galloway: May 9th., 2018

let e = Seq.unfold(fun (n,g)->Some(n,(n/g,g+1N))) (1N,1N)

Which may be used:

printfn "%.14f" (float (e |> Seq.take 20 |> Seq.sum))

{{out}}

<pre>

=={{header|Factor}}==

{{works with|Factor|0.98}}

IN: rosetta-code.calculate-e

 

CONSTANT: terms 20

 

{{out}}

<pre>

=={{header|FOCAL}}==

{{trans|ZX Spectrum Basic}}

1.2 F X=1,10; D 2

1.3 Q

2.1 S E=E+1/K

2.2 S K=K*X

{{output}}

<pre>*G

* Output the next digit: The final quotient is the next digit of e.

 

: int-array create cells allot does> swap cells + ;

 

0 .r

LOOP ;

{{out}}

<pre>

 

=={{header|Fortran}}==

Program eee

implicit none

write(*,*) ' polynomial ', ee

{{out}}

<pre>

=={{header|FreeBASIC}}==

===Normal basic===

' compile with: fbc -s console

 

Print : Print "hit any key to end program"

Sleep

{{out}}

<pre>The value of e = 2.718281828459046</pre>

===GMP version===

{{libheader|GMP}}

' compile with: fbc -s console

 

Print : Print "hit any key to end program"

Sleep

{{out}}

<pre>The value of e = 2.71828182845904523536028747135266249775724709369996</pre>

 

=={{header|Furor}}==

###sysinclude math.uh

1.0e-15 sto EPSILON

{ „e0” }

{ „n” }

 

{{out}}

=={{header|Go}}==

{{trans|Kotlin}}

 

import (

}

fmt.Printf("e = %.15f\n", e)

 

{{out}}

 

Since the difference between partial sums is always the "last" term, it suffices to ensure that the "last" term is less than the tolerance.

def φ = 1/ε

 

}

 

'''Test: '''

'''Output: '''

<pre>2.718281828459045

For the purposes of 64 bit floating point precision, the value seems to stabilise after summing c. 17-20 terms.

 

 

eApprox :: Int -> Double

--------------------------- TEST -------------------------

main :: IO ()

{{Out}}

<pre>2.7182818284590455</pre>

Or equivalently, in a single fold:

 

 

eApprox n =

--------------------------- TEST -------------------------

main :: IO ()

{{Out}}

<pre>2.7182818284590455</pre>

Or in terms of iterate:

 

 

------------------- APPROXIMATIONS TO E ------------------

--------------------------- TEST -------------------------

main :: IO ()

{{Out}}

<pre>2.7182818284590455</pre>

For Icon, the EPSILON preprocessor constant would need to be an inline constant where tested, or set in a variable.

 

 

procedure main()

write("computed e ", e)

write("keyword &e ", &e)

 

{{out}}

 

=={{header|IS-BASIC}}==

110 LET E1=0:LET E,N,N1=1

120 DO WHILE E<>E1

140 LET N1=N1+1:LET N=N*N1

150 LOOP

{{Out}}

<pre>The value of e = 2.71828183</pre>

=={{header|Java}}==

{{trans|Kotlin}}

public static final double EPSILON = 1.0e-15;

 

System.out.printf("e = %.15f\n", e);

}

{{out}}

<pre>e = 2.718281828459046</pre>

=={{header|Javascript}}==

Summing over a scan

"use strict";

 

// MAIN ---

return main();

<pre>2.7182818284590455</pre>

 

Or as a single fold/reduce:

"use strict";

 

// MAIN ---

return main();

{{Out}}

<pre>2.7182818284590455</pre>

 

=={{header|jq}}==

[null,0,1,1]

| until(.[0] == .[1]; .[0]=.[1] | .[1]+=1/.[2] | .[2] *= .[3] | .[3]+=1)

| .[0];

 

=={{header|Julia}}==

 

'''Module''':

 

export NeperConst

end

 

 

'''Main''':

println(NeperConst{F}())

 

{{out}}

 

=={{header|K}}==

/ Computing value of e

/ ecomp.k

evalue:{1 +/(1.0%)'fact' 1+!20}

evalue[]

 

{{out}}

 

=={{header|Klingphix}}==

 

0 !e0 2 !e 0 !n 1 !fact

"Number of iterations = " $n printOp

 

 

=={{header|Kotlin}}==

 

import kotlin.math.abs

while (abs(e - e0) >= EPSILON)

println("e = %.15f".format(e))

 

{{output}}

 

=={{header|Lambdatalk}}==

1) straightforward

 

{euler 1 17}

-> 2.7182818284590455

 

=={{header|langur}}==

{{trans|Go}}

 

val .epsilon = 1.0e-104

 

# compare to built-in constant e

 

{{out}}

 

=={{header|Lua}}==

 

fact = 1

until (math.abs(e - e0) < EPSILON)

 

{{out}}

<pre>e = 2.718281828459046</pre>

Using @ for Decimal, and ~ for Float, # for Currency (Double is the default type for M2000)

 

Module FindE {

Function comp_e (n){

}

FindE

 

{{out}}

 

As a lambda function (also we use a faster For, using block {})

comp_e=lambda (n)->{n/=28:For i=27to 1 {n=1+n/i}:=n}

 

=={{header|Maple}}==

 

# 2.7182818284590452353602874713526624977572470937000

 

evalf[50](exp(1));

 

With [https://en.wikipedia.org/wiki/Continued_fraction continued fractions]:

 

e:=ContinuedFraction(exp(1)):

Convergent(e,100);

 

# 13823891428306770374331665289458907890372191037173036666131/5085525453460186301777867529962655859538011626631066055111

 

=={{header|Mathematica}}/{{header|Wolfram Language}}==

{{output}}

<pre>

</pre>

 

or even just

{{output}}

<pre>𝕖</pre>

=={{header|min}}==

{{works with|min|0.19.3}}

(iota 'succ '* map-reduce) :factorial

 

{{out}}

<pre>

 

=={{header|МК-61/52}}==

ИП3 ИП2 ИП1 ИП0 - 1 + * П2 1/x + П3

 

At n = 10, the value is 2.7182819.

 

=={{header|Modula-2}}==

FROM RealStr IMPORT RealToStr;

FROM Terminal IMPORT WriteString,WriteLn,ReadChar;

 

ReadChar

 

=={{header|Myrddin}}==

 

const main = {

;;

std.put("e: {}\n", e)

 

=={{header|Nanoquery}}==

{{trans|Python}}

e = 2

n = 0

 

println "Computed e = " + e

{{out}}

<pre>

 

=={{header|Nim}}==

var fact : int64 = 1

var e : float64 = 2.0

e = e + 1.0 / fact.float64

 

 

=={{header|Pascal}}==

Like delphi and many other.Slightly modified to calculate (1/n!) not n! and then divide to (1/n!)

{$IFDEF FPC}

{$MODE DELPHI}

{$IFDEF WINDOWS}readln;{$ENDIF}

end.

{{out}}

<pre>calc e = 2.718281828459045 intern e= 2.718281828459045</pre>

=={{header|Perl}}==

With the <code>bignum</code> core module in force, Brother's algorithm requires only 18 iterations to match the precision of the built-in value, <code>e</code>.

 

$e = 2;

 

print "Computed " . substr($e, 0, 41), "\n";

{{out}}

<pre>Computed 2.718281828459045235360287471352662497757

Here, 71 terms of the Taylor series yield 𝑒 to 101 digits.

 

use Math::Decimal qw(dec_canonise dec_mul dec_rndiv_and_rem);

 

}

 

{{out}}

<pre>numerator: 32561133701373476427912330475884581607687531065877567210421813247164172713574202714721554378508046501

=={{header|Phix}}==

{{trans|Python}}

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #7060A8;">requires</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"1.0.2"</span><span style="color: #0000FF;">)</span> <span style="color: #000080;font-style:italic;">-- (builtin constant E renamed as EULER)</span>

<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">" Error = %g\n"</span><span style="color: #0000FF;">,</span><span style="color: #004600;">EULER</span><span style="color: #0000FF;">-</span><span style="color: #000000;">e</span><span style="color: #0000FF;">)</span>

<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"Number of iterations = %d\n"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">n</span><span style="color: #0000FF;">)</span>

{{out}}

<pre>

=={{header|Phixmonti}}==

{{trans|Python}}

1e-15 var v

 

"Real e = " rE tostr printOp

"Error = " rE e - printOp

{{out}}

<pre>

 

=={{header|PicoLisp}}==

(let (F 1 E 2.0 E0 0 N 2)

(while (> E E0)

(inc 'E (*/ 1.0 F))

(inc 'N) )

{{out}}

<pre>e = 2.718281828459046</pre>

=={{header|PowerShell}}==

{{trans|Python}}

$e = 2

$n = 0

Write-Host " Real e = $([Math]::Exp(1))"

Write-Host " Error = $([Math]::Exp(1) - $e)"

{{out}}

<pre>Computed e = 2.71828182845904

=={{header|Processing}}==

Updated to show that computed value matches library value after 21 iterations.

void setup() {

double e = 0;

}

 

{{out}}

<pre>

===Floating-point solution===

Uses Newton's method to solve ln x = 1

% Calculate the value e = exp 1

% Use Newton's method: x0 = 2; y = x(2 - ln x)

 

?- main.

{{Out}}

<pre>

 

===Arbitrary-precision solution===

% John Devou: 26-Nov-2021

% Simple program to calculate e up to n decimal digits.

 

?- main.

{{Out}}

<pre>

 

=={{header|PureBasic}}==

LOOP:

f*n : e+1.0/f

If e-e0>=1.0e-15 : e0=e : n+1 : Goto LOOP : EndIf

{{out}}

<pre>e=2.718281828459046</pre>

=={{header|Python}}==

===Imperative===

#Implementation of Brother's formula

e0 = 0

print "Real e = "+str(math.e)

print "Error = "+str(math.e-e)

{{out}}

<pre>

 

{{Works with|Python|3.7}}

 

from itertools import (accumulate, chain)

# MAIN ---

if __name__ == '__main__':

{{Out}}

<pre>2.7182818284590455</pre>

 

Or in terms of a single fold/reduce:

 

from functools import reduce

# MAIN ---

if __name__ == '__main__':

{{Out}}

<pre>2.7182818284590455</pre>

 

=={{header|R}}==

options(digits=22)

cat("e =",sum(rep(1,20)/factorial(0:19)))

{{Out}}

<pre>

Using the Quackery bignum rational arithmetic library.

 

 

[ swap number$

3 times drop temp release ] is approximate-e ( n n --> )

 

 

{{Out}}

 

=={{header|Racket}}==

(require math/number-theory)

 

(displayln e)

(displayln (real->decimal-string e 20))

{{out}}

<pre>82666416490601/30411275102208

(formerly Perl 6)

{{works with|Rakudo|2018.03}}

# Adjust the terms parameter to suit. Theoretically the

# terms could be ∞. Practically, calculating an infinite

 

# Or, if you don't need high precision, it's a built-in.

{{out}}

<pre>2.718281828459045235360287471352662497757247093699959574966967627724076630353547

If the argument (digs) is negative, a running number of decimal digits of &nbsp; <big>''e''</big> &nbsp; is

shown.

parse arg digs . /*get optional number of decimal digits*/

if digs=='' | digs=="," then digs= 101 /*Not specified? Then use the default.*/

end /*#*/ /* -1 is for the decimal point────┘ */

say /*stick a fork in it, we're all done. */

Programming note: &nbsp; the factorial of the &nbsp; '''do''' &nbsp; loop index is calculated by &nbsp; ''division'', &nbsp; not by the usual &nbsp; ''multiplication'' &nbsp; (for optimization).

 

===version 2===

Using the series shown in version 1 compute e to the specified precision.

Parse Arg dig /* the desired precision */

Numeric Digits (dig+3) /* increase precision */

Numeric Digits dig /* the desired precision */

e=e/1 /* the desired approximation */

{{out}}

<pre>J:\>rexx eval compey(66)

compey(66)=2.71828182845904523536028747135266249775724709369995957496696762772 (52 iterations required)</pre>

Check the function's correctness

e_='2.7182818284590452353602874713526624977572470936999595749669676277240'||,

'766303535475945713821785251664274274663919320030599218174135966290435'||,

Else ok=ok+1

End

{{out}}

<pre>J:\>rexx compez

 

=={{header|Ring}}==

# Project : Calculating the value of e

 

return n * factorial(n-1)

ok

Output:

<pre>

=={{header|Ruby}}==

{{trans|C}}

fact = 1

e = 2

 

puts e

Built in:

 

puts BigMath.E(50).to_s # 50 decimals

{{out}}

<pre>

 

=={{header|Rust}}==

 

fn main() {

}

println!("e = {:.15}", e);

{{out}}

<pre>e = 2.718281828459046</pre>

=={{header|Scala}}==

{{Out}}Best seen running in your browser either by [https://scalafiddle.io/sf/gLmNcH2/0 ScalaFiddle (ES aka JavaScript, non JVM)] or [https://scastie.scala-lang.org/WSvNG9xMT5GcugVTvqogVg Scastie (remote JVM)].

 

object CalculateE extends App {

 

println(f"ℯ = ${iter(1L, 2.0, 2, 0)}%.15f")

=={{header|Scheme}}==

{{trans|JavaScript}}

(import (rnrs))

 

 

(display (e))

===High Precision===

{{works with|Chez Scheme}}

exactness of the calculation. So, calling exp with the integer 1 will return an exact rational

value, allowing for higher precision than floating point would.

; n-1

; exp(z) ~ SUM ( z^k / k! )

(if (<= n 0)

1

'''Convert for Display'''

; If opt contains an integer, show to that many places past the decimal regardless of repeating.

; If opt contains 'nopar, do not insert the parentheses indicating the repeating places.

(if (null? frc-list)

int-part

'''The Task'''

 

(let*

(printf "the computed exact rational:~%~a~%" e)

(printf "converted to decimal (~a places):~%~a~%" p (rat->dec-str e p))

{{out}}

<pre>Computing exp(1) using 75 terms...

The program below computes e:

 

include "float.s7i";

 

until abs(e - e0) < EPSILON;

writeln("e = " <& e digits 15);

 

{{out}}

=={{header|Sidef}}==

 

sum(0..n, {|k| 1/k! })

}

 

say calculate_e()

{{out}}

<pre>

For finding the number of required terms for calculating ''e'' to a given number of decimal places, using the formula '''Sum_{k=0..n} 1/k!''', we have:

 

var t = n*log(10)

(n + 10).bsearch_le { |k|

var n = f(10**k)

say "Sum_{k=0..#{n}} 1/k! = e correct to #{10**k->commify} decimal places"

{{out}}

<pre>

 

=={{header|Standard ML}}==

let

val eps = 1.0e~15

in

calcToEps'(2.0, 1.0, 1.0, 2.0)

 

{{out}}

{{trans|C}}

 

 

 

}

 

 

{{out}}

=={{header|Tcl}}==

=== By the power series of exp(x) ===

set ε 1.0e-15

set fact 1

set e [expr $e + 1.0/$fact]

}

{{Out}}

<pre>

=== By the continued fraction for e ===

This has the advantage, that arbitrary large precision can be achieved, should that become a demand. Also, full precision for the floating point value can be guaranteed.

## We use (regular) continued fractions, step by step.

## The partial CF is coded (a n b m) for (a+nr) / (b+mr) for rest r.

 

calcE 17

{{out}}

<pre>

=={{header|TI-83 BASIC}}==

Guided by the Awk version.

2->N

2->E

End

Disp E

{{Out}}

<pre>2.718281828</pre>

=={{header|VBScript}}==

{{Trans|Python}}

While (e - e0) > 1E-15

e0 = e

WScript.Echo "Real e = " & Exp(1)

WScript.Echo "Error = " & (Exp(1) - e)

{{Out}}

<pre>Computed e = 2.71828182845904

 

=={{header|Verilog}}==

real n, n1;

real e1, e;

$finish ;

end

{{out}}

<pre>The value of e = 2.71828</pre>

{{trans|C#}}

{{libheader|System.Numerics}}Automatically determines number of padding digits required for the arbitrary precision output. Can calculate a quarter million digits of '''''e''''' in under a half a minute.

 

Module Program

WriteLine("partial: {0}...{1}", es.Substring(0, 46), es.Substring(es.Length - 45))

End Sub

{{out}}

<pre>2.71828182845905

=={{header|Vlang}}==

{{trans|Go}}

const epsilon = 1.0e-15

}

println("e = ${e:.15f}")

 

{{out}}

=={{header|Wren}}==

{{trans|Go}}

var fact = 1

var e = 2

if ((e - e0).abs < epsilon) break

}

 

{{out}}

 

=={{header|XPL0}}==

[Format(1, 16); \show 16 places after decimal point

N:= 1.0; E:= 1.0; F:= 1.0;

RlOut(0, E); CrLf(0);

IntOut(0, fix(N)); Text(0, " iterations");

 

{{out}}

=={{header|Zig}}==

This uses the continued fraction method to generate the maximum ratio that can be computed using 64 bit math. The final ratio is correct to 35 decimal places.

const std = @import("std");

const math = std.math;

}

}

{{Out}}

<pre>

=={{header|zkl}}==

{{trans|C}}

fact,e,n := 1, 2.0, 2;

do{

e+=1.0/fact;

}while((e - e0).abs() >= EPSILON);

{{out}}

<pre>

=={{header|ZX Spectrum Basic}}==

 

20 LET k=1: REM ...the Spectrum's maximum expressible precision is reached at p=13, while...

30 LET e=0: REM ...the factorial can't go any higher than 33

70 NEXT x

80 PRINT e

 

{{Out}}