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

 

=={{header|Ada}}==

with Ada.Numerics; use Ada.Numerics;

with Ada.Numerics.Long_Complex_Types; use Ada.Numerics.Long_Complex_Types;

begin

Put (Exp (Pi * i) + 1.0);

 

{{out}}

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

 

=={{header|Bracmat}}==

 

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

 

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

#include <complex>

 

std::cout << std::exp(std::complex<double>(0.0, M_PI)) + 1.0 << std::endl;

return 0;

 

{{output}}

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

</pre>

 

 

=={{header|Fortran}}==

program euler

use iso_fortran_env, only: output_unit, REAL64

write(output_unit,*) e**(pi*i) + 1

end program euler

{{out}}

<pre>

Provides complex arithmetic and a very rapidly converging algorithm for e^z.

 

#define MAXITER 12

 

printc( curr )

print " Absolute error = ", absc(curr)

 

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

Since Java lacks a complex number class, a class is used that has sufficient operations.

public class EulerIdentity {

 

}

}

 

{{out}}

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

 

=={{header|Lambdatalk}}==

{require lib_complex}

 

'{C.exp {C.mul {C.new 0 1} {C.new {PI} 0}}} // e^πi = exp( [π,0] * [0,1] )

-> (-1 1.2246467991473532e-16) // = -1

 

=={{header|Lua}}==

new = function(s,r,i) s.__index=s return setmetatable({r=r, i=i}, s) end,

add = function(s,o) return s:new(s.r+o.r, s.i+o.i) end,

local one = c:new(1, 0)

local zero = i:mul(pi):exp():add(one)

{{out}}

<pre>e^(i*pi)+1 is approximately zero: 0+1.22460635382237726e-016i</pre>

> math.exp(0)*math.cos(math.pi)+1, math.exp(0)*math.sin(math.pi)

 

{{out}}

<pre>0</pre>

 

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

Symbolically manipulates Euler's identity until it can't be further reduced (and we get zero :)

% reduce() prints the intermediate results so that one can see Prolog "thinking."

%

 

simplify(X, X).

{{Out}}

<pre>

 

=={{header|Python}}==

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

 

=={{header|Racket}}==

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

 

e, i and π are all available as built-in constants in Raku.

 

 

say 'e**i⁢π + 1 ≅ 0 : ', e**i⁢π + 1 ≅ 0;

{{out}}

<pre>e**i⁢π + 1 ≅ 0 : True

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

<br>program.

numeric digits length( pi() ) - length(.) /*define pi; set # dec. digs precision*/

cosPI= fmt( cos(pi) ) /*calculate the value of cos(pi). */

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

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

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

 

=={{header|Wren}}==

 

 

 

{{out}}

 

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