Euler's identity: Difference between revisions

 

 

 

<span style="font-size:150%;font-style:bold;"><span style="font-style:italic">e^{i<math>\pi</math>}</span> + 1 = 0</span>

 

If that is the case, or there is some other limitation, show

show the amount of error in the calculation.

 

If your language is capable of symbolic calculations, show

<br><br>

 

{{trans|Python}}

 

 

{{out}}

1.22465e-16i

</pre>

 

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

<br>

We could use the identity exp(x + iy) = exp(x)( cos y + i sin y ), however the following uses a series expansion for exp(ix).

# calculate an approximation to e^(i pi) + 1 which should be 0 (Euler's identity) #

 

)

)

{{out}}

<pre>

e^(i*pi) + 1 ~ 0.00000000000000000307 -0.00000000000000002926i

</pre>

 

=={{header|C}}==

 

The following code has been tested with gcc 5.4.0 on Ubuntu 16.04.

#include <math.h>

#include <complex.h>

printf("e ^ %lci + 1 = [%.16f, %.16f] %lc 0\n", pi, creal(e), cimag(e), ae);

return 0;

 

{{output}}

</pre>

 

using System.Numerics;

 

Console.WriteLine(Complex.Pow(e, i * π) + 1);

}

{{out}}

<pre>

(0, 1.22464679914735E-16)

</pre>

 

=={{header|Common Lisp}}==

Common Lisp has complex number arithmetic built into it.

(+ 1 (exp (complex 0 pi)))

<pre>

#C(0.0L0 -5.0165576136843360246L-20)

</pre>

 

=={{header|Factor}}==

{{out}}

<pre>

C{ 0.0 1.224646799147353e-016 }

</pre>

 

=={{header|Go}}==

import (

func main() {

fmt.Println(cmplx.Exp(math.Pi * 1i) + 1.0)

 

{{output}}

=={{header|Groovy}}==

Because the Groovy language does not provide a built-in facility for complex arithmetic, this example relies on the Complex class defined in the [[Complex_numbers#Groovy|Complex numbers]] example.

 

Number.metaClass.mixin ComplexCategory

println "e ** (π * i) + 1 = " + (e ** (π * i) + 1)

 

Output: (yadda, yadda, dust, yadda)

<pre>e ** (π * i) + 1 = 1.2246467991473532E-16i

 

A double is not quite real.

 

eulerIdentityZeroIsh :: Complex Double

main :: IO ()

{{Out}}

 

 

=={{header|J}}==

NB. Euler's number is the default base for power

NB. using j's expressive numeric notation:

1 (=!.1e_15) ^ j. TAU

1

 

=={{header|jq}}==

be placed in a module to avoid name conflicts, and thus no special

prefix is used here.

if (x|type) == "number" then

if (y|type) == "number" then [ x*y, 0 ]

 

def pi: 4 * (1|atan);

 

===The Task===

 

{{out}}

Julia has a builtin <tt>Complex{T}</tt> parametrized type.

 

 

{{out}}

Using symbolic algebra, through the [https://github.com/chakravala/Reduce.jl Reduce.jl] package.

 

@force using Reduce.Algebra

 

@show ℯ^(π * :i) + 1

 

{{out}}

 

e ^ πi is calculated by summing successive terms of the power series for e ^ x until the modulus of the difference between terms is no longer significant given the precision of the Double type (about 10 ^ -16).

 

import kotlin.math.sqrt

e += Complex(1.0, 0.0)

println("e^${SMALL_PI}i + 1 = $e $APPROX_EQUALS 0")

 

{{output}}

</pre>

 

{{out}}

 

=={{header|OCaml}}==

# let pi = acos (-1.0);;

val pi : float = 3.14159265358979312

# add (exp { re = 0.0; im = pi }) { re = 1.0; im = 0.0 };;

 

=={{header|Perl}}==

{{out}}

<pre>1.22464679914735e-16i</pre>

 

=={{header|Phix}}==

{{out}}

The actual result and two rounded versions (to prove the rounding is doing what it should - the second arg is an inverted precision).

"0+1.2246e-16i"

"0+1e-16i"

</pre>

 

=={{header|Python}}==

>>> math.e ** (math.pi * 1j) + 1

 

=={{header|Racket}}==

{{out}}<pre>0.0+1.2246063538223773e-016i</pre>

 

=={{header|REXX}}==

of &nbsp; pi &nbsp; being defined within the REXX

<br>program.

say /*separate the wheat from the chaff. */

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

/*──────────────────────────────────────────────────────────────────────────────────────*/

mult: procedure; parse arg a,b; if a=0 | b=0 then return 0; return a*b

pi: pi= 3.1415926535897932384626433832795028841971693993751058209749445923; return pi

/*──────────────────────────────────────────────────────────────────────────────────────*/

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

<pre>

 

</pre>

 

<br>programmatically invoked with the requested number of decimal digits).

 

 

pi= 3.14159265358979323846264338327950288419716939937510

pi= pi || 59825349042875546873115956286388235378759375195778

pi= pi || 18577805321712268066130019278766111959092164201989

 

=={{header|Ruby}}==

 

=={{header|Rust}}==

 

extern crate num_complex;

fn main() {

println!("{:e}", Complex::new(0.0, PI).exp() + 1.0);

 

{{output}}

This example makes use of Spire's numeric data types. Complex takes a type parameter determining the type of the coefficients of a + bi, and Real is Spire's exact (i.e. arbitrary precision) numeric data type.

 

 

object Scratch extends App{

println(e.pow(pi*i) + one)

 

{{output}}

(0 + 0i)

</pre>

 

=={{header|Sidef}}==

{{out}}

<pre>

=={{header|Tcl}}==

=== Using tcllib ===

namespace eval complex_ns {

package require math::complexnumbers

set r [+ [exp [complex 0 $pi]] [complex 1 0]]

puts "e**(pi*i) = [real $r]+[imag $r]i"

{{out}}

<pre>

 

=== Using VecTcl ===

namespace import vectcl::vexpr

 

set ans [vexpr {pi=acos(-1); exp(pi*1i) + 1}]

puts "e**(pi*i) = $ans"

{{out}}

<pre>

e**(pi*i) = 0.0+1.2246063538223773e-16i

</pre>

 

=={{header|zkl}}==

Z,pi,e := GSL.Z, (0.0).pi, (0.0).e;

 

println("e^(\u03c0i) + 1 = %s \u2245 0".fmt( Z(e).pow(Z(0,1)*pi) + 1 ));

{{out}}

<pre>