Euler's identity: Difference between revisions

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

 

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

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)

=={{header|Delphi}}==

{{libheader| System.VarCmplx}}

program Euler_identity;

 

writeln(result);

readln;

{{out}}

<pre>0 + 0i</pre>

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

As per the discussion page this task as described is to show that -1+1=0

printfn "-1 + 1 = %d" (-1+1)

{{out}}

<pre>

</pre>

I shall also show that cos π = -1 and sin π = 0

printfn "cos(pi)=%f and sin(pi)=%f" (cos 3.141592653589793) (sin 3.141592653589793)

{{out}}

<pre>

</pre>

I shall try the formula e^iπ. I'll use the MathNet.Numerics package. I'll leave you the reader to determine what it 'proves'.

let i =MathNet.Numerics.complex(0.0,1.0);;

let pi=MathNet.Numerics.complex(MathNet.Numerics.Constants.Pi,0.0);;

let e =MathNet.Numerics.complex(MathNet.Numerics.Constants.E ,0.0);;

printfn "e**(i*pi) = %A" (e**(i*pi));;

{{out}}

<pre>

</pre>

=={{header|Factor}}==

{{out}}

<pre>

=={{header|Forth}}==

Uses fs. (scientific) to print the imaginary term, since that's the one that's inexact.

." e^(i*π) + 1 = " pi fcos 1e0 f+ f. '+ emit space pi fsin fs. 'i emit cr

bye

{{Out}}

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

 

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

{{out}}

<pre>0</pre>

 

=={{header|Nim}}==

 

 

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

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

<span style="color: #008080;">include</span> <span style="color: #000000;">builtins</span><span style="color: #0000FF;">\</span><span style="color: #004080;">complex</span><span style="color: #0000FF;">.</span><span style="color: #000000;">e</span>

<span style="color: #0000FF;">?</span><span style="color: #7060A8;">complex_sprint</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">complex_round</span><span style="color: #0000FF;">(</span><span style="color: #000000;">res</span><span style="color: #0000FF;">,</span><span style="color: #000000;">1e16</span><span style="color: #0000FF;">),</span><span style="color: #004600;">true</span><span style="color: #0000FF;">)</span>

<span style="color: #0000FF;">?</span><span style="color: #7060A8;">complex_sprint</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">complex_round</span><span style="color: #0000FF;">(</span><span style="color: #000000;">res</span><span style="color: #0000FF;">,</span><span style="color: #000000;">1e15</span><span style="color: #0000FF;">),</span><span style="color: #004600;">true</span><span style="color: #0000FF;">)</span>

{{out}}

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

{{trans|Prolog}}

Of course "symbolically" you can just do this (ha ha):

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

<span style="color: #008080;">procedure</span> <span style="color: #000000;">reduce</span><span style="color: #0000FF;">(</span><span style="color: #004080;">string</span> <span style="color: #000000;">s</span><span style="color: #0000FF;">)</span>

<span style="color: #000000;">reduce</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"exp(i*pi)+1"</span><span style="color: #0000FF;">)</span>

{{out}}

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

{{out}}<pre>0+1.224606e-16i</pre>

 

Symbolically with the Ryacas package (on CRAN):

{{out}}<pre>0</pre>

 

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

include Math

 

E ** (PI * 1i) + 1

 

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

=={{header|Scheme}}==

{{works with|Chez Scheme}}

(define pi (acos -1))

 

; Print the value of e^(i*pi) + 1 -- should be 0.

{{out}}

<pre>e^(i*pi) + 1 = 0.0+1.2246467991473532e-16i

The series are computed using exact rational numbers.

This code converts the rational results into decimal representation.

 

(define fact

(e-pi-i (exp-series (* pi +i) 222))

(euler-id (+ e-pi-i 1)))

{{out}}

<pre>e^(i*pi) + 1 =

 

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

{{libheader|Wren-complex}}

 

 

 

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