Data commit

Task/Eulers-identity/00-META.yaml

@@ -0,0 +1,2 @@
+---
+from: http://rosettacode.org/wiki/Euler's_identity

Task/Eulers-identity/00-TASK.txt

@@ -0,0 +1,31 @@
+In mathematics, ''Euler's identity'' is the equality:
+
+                <span style="font-size:150%;font-style:bold;"><span style="font-style:italic">e<sup>i<math>\pi</math></sup></span> + 1 = 0</span>
+
+where
+
+    e is Euler's number, the base of natural logarithms,
+    ''i'' is the imaginary unit, which satisfies ''i''<sup>2</sup> = −1, and
+    <math>\pi</math> is pi, the ratio of the circumference of a circle to its diameter.
+
+Euler's identity is often cited as an example of deep mathematical beauty. Three of the basic arithmetic operations occur exactly once each: addition, multiplication, and exponentiation. The identity also links five fundamental mathematical constants:
+
+    The number 0.
+    The number 1.
+    The number <math>\pi</math> (<math>\pi</math> = 3.14159<small>+</small>),
+    The number e (e = 2.71828<small>+</small>), which occurs widely in mathematical analysis.
+    The number ''i'', the imaginary unit of the complex numbers.
+
+;Task
+Show in your language that Euler's identity is true. As much as possible and practical, mimic the Euler's identity equation. 
+
+Most languages are limited to IEEE 754 floating point calculations so will have some error in the calculation. 
+
+If that is the case, or there is some other limitation, show 
+that <big>e<sup>i<math>\pi</math></sup> + 1</big> is ''approximately'' equal to zero and 
+show the amount of error in the calculation.
+
+If your language is capable of symbolic calculations, show 
+that <big>e<sup>i<math>\pi</math></sup> + 1</big> is ''exactly'' equal to zero for bonus kudos points.
+<br><br>
+

Task/Eulers-identity/11l/eulers-identity.11l

@@ -0,0 +1 @@
+print(math:e ^ (math:pi * 1i) + 1)

Task/Eulers-identity/ALGOL-68/eulers-identity.alg

@@ -0,0 +1,53 @@
+BEGIN
+    # calculate an approximation to e^(i pi) + 1 which should be 0 (Euler's identity) #
+
+    # returns e^ix for long real x, using the series:                                 #
+    #      exp(ix) = 1 - x^2/2! + x^4/4! - ... + i(x - x^3/3! + x^5/5! - x^7/7! ... ) #
+    #      the expansion stops when successive terms differ by less than 1e-15        #
+    PROC expi = ( LONG REAL x )LONG COMPL:
+         BEGIN
+            LONG REAL t              := 1;
+            LONG REAL real part      := 1;
+            LONG REAL imaginary part := 0;
+            LONG REAL divisor        := 1;
+            BOOL      even power     := FALSE;
+            BOOL      subtract       := FALSE;
+            LONG REAL diff           := 1;
+            FOR n FROM 1 WHILE ABS diff > 1e-15 DO
+                divisor *:= n;
+                t       *:= x;
+                LONG REAL term := t / divisor;
+                IF even power THEN
+                    # this term is real #
+                    subtract := NOT subtract;
+                    LONG REAL prev := real part;
+                    IF subtract THEN
+                        real part -:= term
+                    ELSE
+                        real part +:= term
+                    FI;
+                    diff := prev - real part
+                ELSE
+                    # this term is imaginary #
+                    LONG REAL prev := imaginary part;
+                    IF subtract THEN
+                        imaginary part -:= term
+                    ELSE
+                        imaginary part +:= term
+                    FI;
+                    diff := prev - imaginary part
+                FI;
+                even power := NOT even power
+            OD;
+            ( real part, imaginary part )
+         END # expi # ;
+    LONG COMPL eulers identity = expi( long pi ) + 1;
+    print( ( "e^(i*pi) + 1 ~ "
+           , fixed( re OF eulers identity, -23, 20 )
+           , " "
+           , fixed( im OF eulers identity,  23, 20 )
+           , "i"
+           , newline
+           )
+         )
+END

Task/Eulers-identity/Ada/eulers-identity.ada

@@ -0,0 +1,8 @@
+with Ada.Long_Complex_Text_IO; use Ada.Long_Complex_Text_IO;
+with Ada.Numerics; use Ada.Numerics;
+with Ada.Numerics.Long_Complex_Types; use Ada.Numerics.Long_Complex_Types;
+with Ada.Numerics.Long_Complex_Elementary_Functions; use Ada.Numerics.Long_Complex_Elementary_Functions;
+procedure Eulers_Identity is
+begin
+   Put (Exp (Pi * i) + 1.0);
+end Eulers_Identity;

Task/Eulers-identity/Bracmat/eulers-identity.bracmat

@@ -0,0 +1 @@
+e^(i*pi)+1

Task/Eulers-identity/C++/eulers-identity.cpp

@@ -0,0 +1,7 @@
+#include <iostream>
+#include <complex>
+
+int main() {
+  std::cout << std::exp(std::complex<double>(0.0, M_PI)) + 1.0 << std::endl;
+  return 0;
+}

Task/Eulers-identity/C-sharp/eulers-identity.cs

@@ -0,0 +1,12 @@
+using System;
+using System.Numerics;
+
+public class Program
+{
+    static void Main() {
+        Complex e = Math.E;
+        Complex i = Complex.ImaginaryOne;
+        Complex π = Math.PI;
+        Console.WriteLine(Complex.Pow(e, i * π) + 1);
+    }
+}

Task/Eulers-identity/C/eulers-identity.c

@@ -0,0 +1,14 @@
+#include <stdio.h>
+#include <math.h>
+#include <complex.h>
+#include <wchar.h>
+#include <locale.h>
+
+int main() {
+    wchar_t pi = L'\u03c0'; /* Small pi symbol */
+    wchar_t ae = L'\u2245'; /* Approximately equals symbol */
+    double complex e = cexp(M_PI * I) + 1.0;
+    setlocale(LC_CTYPE, "");
+    printf("e ^ %lci + 1 = [%.16f, %.16f] %lc 0\n", pi, creal(e), cimag(e), ae);
+    return 0;
+}

Task/Eulers-identity/Common-Lisp/eulers-identity.lisp

@@ -0,0 +1 @@
+(+ 1 (exp (complex 0 pi)))

Task/Eulers-identity/Delphi/eulers-identity.delphi

@@ -0,0 +1,12 @@
+program Euler_identity;
+
+{$APPTYPE CONSOLE}
+
+uses
+  System.VarCmplx;
+
+begin
+  var result := VarComplexExp(Pi * VarComplexCreate(0, 1)) + 1;
+  writeln(result);
+  readln;
+end.

Task/Eulers-identity/F-Sharp/eulers-identity-1.fs

@@ -0,0 +1 @@
+printfn "-1 + 1 = %d" (-1+1)

Task/Eulers-identity/F-Sharp/eulers-identity-2.fs

@@ -0,0 +1 @@
+printfn "cos(pi)=%f and sin(pi)=%f" (cos 3.141592653589793) (sin 3.141592653589793)

Task/Eulers-identity/F-Sharp/eulers-identity-3.fs

@@ -0,0 +1,4 @@
+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));;

Task/Eulers-identity/Factor/eulers-identity.factor

@@ -0,0 +1,2 @@
+USING: math math.constants math.functions prettyprint ;
+1 e pi C{ 0 1 } * ^ + .

Task/Eulers-identity/Forth/eulers-identity.fth

@@ -0,0 +1,2 @@
+." e^(i*π) + 1 = " pi fcos 1e0 f+ f. '+ emit space pi fsin fs. 'i emit cr
+bye

Task/Eulers-identity/Fortran/eulers-identity.f

@@ -0,0 +1,10 @@
+program euler
+    use iso_fortran_env, only: output_unit, REAL64
+    implicit none
+
+    integer, parameter              :: d=REAL64
+    real(kind=d), parameter         :: e=exp(1._d), pi=4._d*atan(1._d)
+    complex(kind=d), parameter      :: i=(0._d,1._d)
+
+    write(output_unit,*) e**(pi*i) + 1
+end program euler

Task/Eulers-identity/FreeBASIC/eulers-identity.basic

@@ -0,0 +1,102 @@
+#define PI 3.141592653589793238462643383279502884197169399375105821
+#define MAXITER 12
+
+'---------------------------------------
+'   complex numbers and their arithmetic
+'---------------------------------------
+
+type complex
+    r as double
+    i as double
+end type
+
+function conj( a as complex ) as complex
+    dim as complex c
+    c.r =  a.r
+    c.i = -a.i
+    return c
+end function
+
+operator + ( a as complex, b as complex ) as complex
+    dim as complex c
+    c.r = a.r + b.r
+    c.i = a.i + b.i
+    return c
+end operator
+
+operator - ( a as complex, b as complex ) as complex
+    dim as complex c
+    c.r = a.r - b.r
+    c.i = a.i - b.i
+    return c
+end operator
+
+operator * ( a as complex, b as complex ) as complex
+    dim as complex c
+    c.r = a.r*b.r - a.i*b.i
+    c.i = a.i*b.r + a.r*b.i
+    return c
+end operator
+
+operator / ( a as complex, b as complex ) as complex
+    dim as double bcb = (b*conj(b)).r
+    dim as complex acb = a*conj(b), c
+    c.r = acb.r/bcb
+    c.i = acb.i/bcb
+    return c
+end operator
+
+sub printc( a as complex )
+    if a.i>=0 then
+        print using "############.############### + ############.############### i"; a.r; a.i
+    else
+        print using "############.############### - ############.############### i"; a.r; -a.i
+    end if
+end sub
+
+function intc( n as integer ) as complex
+    dim as complex c
+    c.r = n
+    c.i = 0.0
+    return c
+end function
+
+function absc( a as complex ) as double
+    return sqr( (a*conj(a)).r )
+end function
+
+'-----------------------
+' the algorithm
+' Uses a rapidly converging continued
+' fraction expansion for e^z and recursive
+' expressions for its convergents
+'-----------------------
+
+dim as complex pii, pii2, curr, A2, A1, A0, B2, B1, B0
+dim as complex ONE, TWO
+dim as integer i, k = 2
+pii.r = 0.0
+pii.i = PI
+pii2 = pii*pii
+
+B0 = intc(2)
+A0 = intc(2)
+B1 = (intc(2) - pii)
+A1 = B0*B1 + intc(2)*pii
+printc( A0/B0)
+print "     Absolute error = ", absc(A0/B0)
+printc( A1/B1)
+print "     Absolute error = ", absc(A1/B1)
+
+for i = 1 to MAXITER
+    k = k + 4
+    A2 = intc(k)*A1 + pii2*A0
+    B2 = intc(k)*B1 + pii2*B0
+    curr = A2/B2
+    A0 = A1
+    A1 = A2
+    B0 = B1
+    B1 = B2
+    printc( curr  )
+    print "     Absolute error = ", absc(curr)
+next i

Task/Eulers-identity/Go/eulers-identity.go

@@ -0,0 +1,11 @@
+package main
+
+import (
+    "fmt"
+    "math"
+    "math/cmplx"
+)
+
+func main() {
+    fmt.Println(cmplx.Exp(math.Pi * 1i) + 1.0)
+}

Task/Eulers-identity/Groovy/eulers-identity.groovy

@@ -0,0 +1,10 @@
+import static Complex.*
+
+Number.metaClass.mixin ComplexCategory
+
+def π = Math.PI
+def e = Math.E
+
+println "e ** (π * i) + 1 = " + (e ** (π * i) + 1)
+
+println "| e ** (π * i) + 1 | = " + (e ** (π * i) + 1).ρ

Task/Eulers-identity/Haskell/eulers-identity.hs

@@ -0,0 +1,8 @@
+import Data.Complex
+
+eulerIdentityZeroIsh :: Complex Double
+eulerIdentityZeroIsh =
+  exp (0 :+ pi) + 1
+
+main :: IO ()
+main = print eulerIdentityZeroIsh

Task/Eulers-identity/J/eulers-identity.j

@@ -0,0 +1,22 @@
+   NB. Euler's number is the default base for power
+   NB. using j's expressive numeric notation:
+   1 + ^ 0j1p1
+0j1.22465e_16
+
+
+   NB. Customize the comparison tolerance to 10 ^ (-15)
+   NB. to show that
+   _1 (=!.1e_15) ^ 0j1p1
+1
+
+
+
+   TAU =: 2p1
+
+   NB. tauday.com  pi is wrong
+   NB. with TAU as 2 pi,
+   NB. Euler's identity should have read
+
+
+   1 (=!.1e_15) ^ j. TAU
+1

Task/Eulers-identity/Java/eulers-identity.java

@@ -0,0 +1,30 @@
+public class EulerIdentity {
+
+    public static void main(String[] args) {
+        System.out.println("e ^ (i*Pi) + 1 = " + (new Complex(0, Math.PI).exp()).add(new Complex(1, 0)));
+    }
+
+    public static class Complex {
+
+        private double x, y;
+
+        public Complex(double re, double im) {
+            x = re;
+            y = im;
+        }
+
+        public Complex exp() {
+            double exp = Math.exp(x);
+            return new Complex(exp * Math.cos(y), exp * Math.sin(y));
+        }
+
+        public Complex add(Complex a) {
+            return new Complex(x + a.x, y + a.y);
+        }
+
+        @Override
+        public String toString() {
+            return x + " + " + y + "i";
+        }
+    }
+}

Task/Eulers-identity/Jq/eulers-identity-1.jq

@@ -0,0 +1,26 @@
+def multiply(x; y):
+    if (x|type) == "number" then
+       if  (y|type) == "number" then [ x*y, 0 ]
+       else [x * y[0], x * y[1]]
+       end
+    elif (y|type) == "number" then multiply(y;x)
+    else [ x[0] * y[0] - x[1] * y[1],  x[0] * y[1] + x[1] * y[0]]
+    end;
+
+def plus(x; y):
+    if (x|type) == "number" then
+       if  (y|type) == "number" then [ x+y, 0 ]
+       else [ x + y[0], y[1]]
+       end
+    elif (y|type) == "number" then plus(y;x)
+    else [ x[0] + y[0], x[1] + y[1] ]
+    end;
+
+def exp(z):
+  def expi(x): [ (x|cos), (x|sin) ];
+  if (z|type) == "number" then z|exp
+  elif z[0] == 0 then expi(z[1])  # for efficiency
+  else multiply( (z[0]|exp); expi(z[1]) )
+  end ;
+
+def pi: 4 * (1|atan);

Task/Eulers-identity/Jq/eulers-identity-2.jq

@@ -0,0 +1,2 @@
+"e^iπ:     \( exp( [0, pi ] ) )",
+"e^iπ + 1: \( plus(1; exp( [0, pi ] ) ))"

Task/Eulers-identity/Julia/eulers-identity-1.julia

@@ -0,0 +1,2 @@
+@show ℯ^(π * im) + 1
+@assert ℯ^(π * im) ≈ -1

Task/Eulers-identity/Julia/eulers-identity-2.julia

@@ -0,0 +1,5 @@
+using Reduce
+@force using Reduce.Algebra
+
+@show ℯ^(π * :i) + 1
+@assert ℯ^(π * :i) + 1 == 0

Task/Eulers-identity/Kotlin/eulers-identity.kotlin

@@ -0,0 +1,52 @@
+// Version 1.2.40
+
+import kotlin.math.sqrt
+import kotlin.math.PI
+
+const val EPSILON = 1.0e-16
+const val SMALL_PI = '\u03c0'
+const val APPROX_EQUALS = '\u2245'
+
+class Complex(val real: Double, val imag: Double) {
+    operator fun plus(other: Complex) =
+        Complex(real + other.real, imag + other.imag)
+
+    operator fun times(other: Complex) = Complex(
+        real * other.real - imag * other.imag,
+        real * other.imag + imag * other.real
+    )
+
+    fun inv(): Complex {
+        val denom = real * real + imag * imag
+        return Complex(real / denom, -imag / denom)
+    }
+
+    operator fun unaryMinus() = Complex(-real, -imag)
+
+    operator fun minus(other: Complex) = this + (-other)
+
+    operator fun div(other: Complex) = this * other.inv()
+
+    val modulus: Double get() = sqrt(real * real + imag * imag)
+
+    override fun toString() =
+        if (imag >= 0.0) "$real + ${imag}i"
+        else "$real - ${-imag}i"
+}
+
+fun main(args: Array<String>) {
+    var fact = 1.0
+    val x = Complex(0.0, PI)
+    var e = Complex(1.0, PI)
+    var n = 2
+    var pow = x
+    do {
+        val e0 = e
+        fact *= n++
+        pow *= x
+        e += pow / Complex(fact, 0.0)
+    }
+    while ((e - e0).modulus >= EPSILON)
+    e += Complex(1.0, 0.0)
+    println("e^${SMALL_PI}i + 1 = $e $APPROX_EQUALS 0")
+}

Task/Eulers-identity/Lambdatalk/eulers-identity.lambdatalk

@@ -0,0 +1,4 @@
+{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

Task/Eulers-identity/Lua/eulers-identity-1.lua

@@ -0,0 +1,11 @@
+local c = {
+  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,
+  exp = function(s) local e=math.exp(s.r) return s:new(e*math.cos(s.i), e*math.sin(s.i)) end,
+  mul = function(s,o) return s:new(s.r*o.r+s.i*o.i, s.r*o.i+s.i*o.r) end
+}
+local i = c:new(0, 1)
+local pi = c:new(math.pi, 0)
+local one = c:new(1, 0)
+local zero = i:mul(pi):exp():add(one)
+print(string.format("e^(i*pi)+1 is approximately zero:  %.18g%+.18gi", zero.r, zero.i))

Task/Eulers-identity/Lua/eulers-identity-2.lua

@@ -0,0 +1,3 @@
+> -- alternatively, equivalent one-liner from prompt:
+> math.exp(0)*math.cos(math.pi)+1, math.exp(0)*math.sin(math.pi)
+0.0     1.2246063538224e-016

Task/Eulers-identity/Mathematica/eulers-identity.math

@@ -0,0 +1 @@
+E^(I Pi) + 1

Task/Eulers-identity/Nim/eulers-identity.nim

@@ -0,0 +1,3 @@
+import math, complex
+
+echo "exp(iπ) + 1 = ", exp(complex(0.0, PI)) + 1, " ~= 0"

Task/Eulers-identity/OCaml/eulers-identity.ocaml

@@ -0,0 +1,5 @@
+# open Complex;;
+# let pi = acos (-1.0);;
+val pi : float = 3.14159265358979312
+# add (exp { re = 0.0; im = pi }) { re = 1.0; im = 0.0 };;
+- : Complex.t = {re = 0.; im = 1.22464679914735321e-16}

Task/Eulers-identity/Perl/eulers-identity.pl

@@ -0,0 +1,2 @@
+use Math::Complex;
+print exp(pi * i) + 1, "\n";

Task/Eulers-identity/Phix/eulers-identity-1.phix

@@ -0,0 +1,9 @@
+(phixonline)-->
+ <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: #004080;">complex</span> <span style="color: #000000;">i</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">complex_new</span><span style="color: #0000FF;">(</span><span style="color: #000000;">0</span><span style="color: #0000FF;">,</span><span style="color: #000000;">1</span><span style="color: #0000FF;">),</span>
+         <span style="color: #000000;">res</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">complex_add</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">complex_exp</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">complex_mul</span><span style="color: #0000FF;">(</span><span style="color: #004600;">PI</span><span style="color: #0000FF;">,</span><span style="color: #000000;">i</span><span style="color: #0000FF;">)),</span><span style="color: #000000;">1</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: #000000;">res</span><span style="color: #0000FF;">,</span><span style="color: #000000;">both</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;">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>
+<!--

Task/Eulers-identity/Phix/eulers-identity-2.phix

@@ -0,0 +1,30 @@
+(phixonline)-->
+ <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: #008080;">constant</span> <span style="color: #000000;">rules</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{{</span><span style="color: #008000;">"-1+1"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"0"</span><span style="color: #0000FF;">},</span>
+                       <span style="color: #0000FF;">{</span><span style="color: #008000;">"-1+0"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"-1"</span><span style="color: #0000FF;">},</span>
+                       <span style="color: #0000FF;">{</span><span style="color: #008000;">"i*0"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"0"</span><span style="color: #0000FF;">},</span>
+                       <span style="color: #0000FF;">{</span><span style="color: #008000;">"sin(pi)"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"0"</span><span style="color: #0000FF;">},</span>
+                       <span style="color: #0000FF;">{</span><span style="color: #008000;">"cos(pi)"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"-1"</span><span style="color: #0000FF;">},</span>
+                       <span style="color: #0000FF;">{</span><span style="color: #008000;">"exp(i*pi)"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"cos(pi)+i*sin(pi)"</span><span style="color: #0000FF;">}}</span>
+     <span style="color: #004080;">string</span> <span style="color: #000000;">t</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">s</span>
+     <span style="color: #004080;">sequence</span> <span style="color: #000000;">seen</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{}</span>          <span style="color: #000080;font-style:italic;">-- (be safe and avoid infinite loops)</span>
+     <span style="color: #008080;">while</span> <span style="color: #008080;">not</span> <span style="color: #7060A8;">find</span><span style="color: #0000FF;">(</span><span style="color: #000000;">t</span><span style="color: #0000FF;">,</span><span style="color: #000000;">seen</span><span style="color: #0000FF;">)</span>      <span style="color: #000080;font-style:italic;">--      "" re-treading</span>
+       <span style="color: #008080;">and</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">t</span><span style="color: #0000FF;">)<</span><span style="color: #000000;">10000</span> <span style="color: #008080;">do</span>    <span style="color: #000080;font-style:italic;">--      "" ever-growing</span>
+         <span style="color: #000000;">seen</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">append</span><span style="color: #0000FF;">(</span><span style="color: #000000;">seen</span><span style="color: #0000FF;">,</span><span style="color: #000000;">t</span><span style="color: #0000FF;">)</span>
+         <span style="color: #004080;">bool</span> <span style="color: #000000;">found</span> <span style="color: #0000FF;">=</span> <span style="color: #004600;">false</span>
+         <span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">rules</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">do</span>
+             <span style="color: #004080;">string</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">r</span><span style="color: #0000FF;">,</span><span style="color: #000000;">e</span><span style="color: #0000FF;">}</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">rules</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">]</span>
+             <span style="color: #008080;">if</span> <span style="color: #7060A8;">match</span><span style="color: #0000FF;">(</span><span style="color: #000000;">r</span><span style="color: #0000FF;">,</span><span style="color: #000000;">t</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">then</span>
+                 <span style="color: #000000;">found</span> <span style="color: #0000FF;">=</span> <span style="color: #004600;">true</span>
+                 <span style="color: #000000;">t</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">substitute</span><span style="color: #0000FF;">(</span><span style="color: #000000;">t</span><span style="color: #0000FF;">,</span><span style="color: #000000;">r</span><span style="color: #0000FF;">,</span><span style="color: #000000;">e</span><span style="color: #0000FF;">)</span>
+             <span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
+         <span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
+         <span style="color: #008080;">if</span> <span style="color: #008080;">not</span> <span style="color: #000000;">found</span> <span style="color: #008080;">then</span> <span style="color: #008080;">exit</span> <span style="color: #008080;">end</span> <span style="color: #008080;">if</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;">"%s = %s\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">s</span><span style="color: #0000FF;">,</span><span style="color: #000000;">t</span><span style="color: #0000FF;">})</span>
+         <span style="color: #000000;">s</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">repeat</span><span style="color: #0000FF;">(</span><span style="color: #008000;">' '</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">))</span>
+     <span style="color: #008080;">end</span> <span style="color: #008080;">while</span>
+ <span style="color: #008080;">end</span> <span style="color: #008080;">procedure</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>
+<!--

Task/Eulers-identity/Prolog/eulers-identity.pro

@@ -0,0 +1,36 @@
+% reduce() prints the intermediate results so that one can see Prolog "thinking."
+%
+reduce(A, C) :-
+    simplify(A, B),
+    (B = A -> C = A; io:format("= ~w~n", [B]), reduce(B, C)).
+
+simplify(exp(i*X), cos(X) + i*sin(X)) :- !.
+
+simplify(0 + A, A) :- !.
+simplify(A + 0, A) :- !.
+simplify(A + B, C) :-
+    integer(A),
+    integer(B), !,
+    C is A + B.
+simplify(A + B, C + D) :- !,
+    simplify(A, C),
+    simplify(B, D).
+
+simplify(0 * _, 0) :- !.
+simplify(_ * 0, 0) :- !.
+simplify(1 * A, A) :- !.
+simplify(A * 1, A) :- !.
+simplify(A * B, C) :-
+    integer(A),
+    integer(B), !,
+    C is A * B.
+simplify(A * B, C * D) :- !,
+    simplify(A, C),
+    simplify(B, D).
+
+simplify(cos(0),  1)  :- !.
+simplify(sin(0),  0)  :- !.
+simplify(cos(pi), -1) :- !.
+simplify(sin(pi), 0)  :- !.
+
+simplify(X, X).

Task/Eulers-identity/Python/eulers-identity.py

@@ -0,0 +1,3 @@
+>>> import math
+>>> math.e ** (math.pi * 1j) + 1
+1.2246467991473532e-16j

Task/Eulers-identity/R/eulers-identity-1.r

@@ -0,0 +1,2 @@
+# lang R
+exp(1i * pi) + 1

Task/Eulers-identity/R/eulers-identity-2.r

@@ -0,0 +1,2 @@
+library(Ryacas)
+as_r(yac_str("Exp(I * Pi) + 1"))

Task/Eulers-identity/REXX/eulers-identity-1.rexx

@@ -0,0 +1,23 @@
+/*REXX program proves  Euler's  identity by showing that:      e^(i pi) + 1  ≡     0    */
+numeric digits length( pi() )  -  length(.)      /*define pi;  set # dec. digs precision*/
+        cosPI= fmt( cos(pi) )                    /*calculate the value of   cos(pi).    */
+        sinPI= fmt( sin(pi) )                    /*    "      "    "    "   sin(pi).    */
+say  '         cos(pi) = '  cosPI                /*display    "    "    "   cos(Pi).    */
+say  '         sin(pi) = '  sinPI                /*   "       "    "    "   sin(Pi).    */
+say                                              /*separate the wheat from the chaff.   */
+     $= cosPI  +  mult( sqrt(-1), sinPI )  +  1  /*calc. product of sin(x) and sqrt(-1).*/
+say  '    e^(i pi) + 1 = '  fmt($)    '    ' word("unproven proven",  ($=0)  +  1)
+exit                                             /*stick a fork in it,  we're all done. */
+/*──────────────────────────────────────────────────────────────────────────────────────*/
+fmt:   procedure; parse arg x; x= format(x, , digits() %2, 0);   return left('', x>=0)x /1
+mult:  procedure; parse arg a,b;       if a=0  | b=0  then return 0;            return a*b
+pi:    pi= 3.1415926535897932384626433832795028841971693993751058209749445923;  return pi
+cos:   procedure; parse arg x;  z= 1;  _= 1;   q= x*x;  i= -1;            return .sinCos()
+sin:   procedure; parse arg x 1 z 1 _;         q= x*x;  i=  1;            return .sinCos()
+.sinCos:   do k=2  by 2  until p=z;  p=z;  _= -_ * q/(k*(k+i));  z= z+_;  end;    return z
+/*──────────────────────────────────────────────────────────────────────────────────────*/
+sqrt:  procedure; parse arg x;  if x=0  then return 0;  d=digits(); i=;             h= d+6
+       numeric digits;  numeric form;   if x<0  then  do;  x= -x;   i= 'i';  end;   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
+         do k=j+5  to 0  by -1;  numeric digits m.k;  g= (g+x/g) *.5;  end;  return g || i

Task/Eulers-identity/REXX/eulers-identity-2.rexx

@@ -0,0 +1,23 @@
+/*────────────────── 1,051  decimal digs of  pi. ──────────────────*/
+
+pi=     3.14159265358979323846264338327950288419716939937510
+pi= pi || 58209749445923078164062862089986280348253421170679
+pi= pi || 82148086513282306647093844609550582231725359408128
+pi= pi || 48111745028410270193852110555964462294895493038196
+pi= pi || 44288109756659334461284756482337867831652712019091
+pi= pi || 45648566923460348610454326648213393607260249141273
+pi= pi || 72458700660631558817488152092096282925409171536436
+pi= pi || 78925903600113305305488204665213841469519415116094
+pi= pi || 33057270365759591953092186117381932611793105118548
+pi= pi || 07446237996274956735188575272489122793818301194912
+pi= pi || 98336733624406566430860213949463952247371907021798
+pi= pi || 60943702770539217176293176752384674818467669405132
+pi= pi || 00056812714526356082778577134275778960917363717872
+pi= pi || 14684409012249534301465495853710507922796892589235
+pi= pi || 42019956112129021960864034418159813629774771309960
+pi= pi || 51870721134999999837297804995105973173281609631859
+pi= pi || 50244594553469083026425223082533446850352619311881
+pi= pi || 71010003137838752886587533208381420617177669147303
+pi= pi || 59825349042875546873115956286388235378759375195778
+pi= pi || 18577805321712268066130019278766111959092164201989
+pi= pi || 38095257201065485863278865936153381827968230301952

Task/Eulers-identity/Racket/eulers-identity.rkt

@@ -0,0 +1,2 @@
+#lang racket
+(+ (exp (* 0+i pi)) 1)

Task/Eulers-identity/Raku/eulers-identity.raku

@@ -0,0 +1,4 @@
+sub infix:<⁢> is tighter(&infix:<**>) { $^a * $^b };
+
+say 'e**i⁢π + 1 ≅ 0 : ', e**i⁢π + 1 ≅ 0;
+say 'Error: ', e**i⁢π + 1;

Task/Eulers-identity/Ruby/eulers-identity.rb

@@ -0,0 +1,4 @@
+include Math
+
+E ** (PI * 1i) + 1
+# => (0.0+0.0i)

Task/Eulers-identity/Rust/eulers-identity.rust

@@ -0,0 +1,8 @@
+use std::f64::consts::PI;
+
+extern crate num_complex;
+use num_complex::Complex;
+
+fn main() {
+    println!("{:e}", Complex::new(0.0, PI).exp() + 1.0);
+}

Task/Eulers-identity/Scala/eulers-identity.scala

@@ -0,0 +1,11 @@
+import spire.math.{Complex, Real}
+
+object Scratch extends App{
+  //Declare values with friendly names to clean up the final expression
+  val e = Complex[Real](Real.e, 0)
+  val pi = Complex[Real](Real.pi, 0)
+  val i = Complex[Real](0, 1)
+  val one = Complex.one[Real]
+
+  println(e.pow(pi*i) + one)
+}

Task/Eulers-identity/Scheme/eulers-identity-1.ss

@@ -0,0 +1,5 @@
+; A way to get pi.
+(define pi (acos -1))
+
+; Print the value of e^(i*pi) + 1 -- should be 0.
+(printf "e^(i*pi) + 1 = ~a~%" (+ (exp (* +i pi)) 1))

Task/Eulers-identity/Scheme/eulers-identity-2.ss

@@ -0,0 +1,88 @@
+; Procedure to compute factorial.
+
+(define fact
+  (lambda (n)
+    (if (<= n 0)
+      1
+      (* n (fact (1- n))))))
+
+; Use series to compute approximation to Pi (using N terms of series).
+; (Uses the Newton / Euler Convergence Transformation.)
+
+(define pi-series
+  (lambda (n)
+    (do ((k 0 (1+ k))
+         (sum 0 (+ sum (/ (* (expt 2 k) (expt (fact k) 2)) (fact (1+ (* 2 k)))))))
+        ((>= k n) (* 2 sum)))))
+
+; Use series to compute approximation to exp(z) (using N terms of series).
+
+(define exp-series
+  (lambda (z n)
+    (do ((k 0 (1+ k))
+         (sum 0 (+ sum (/ (expt z k) (fact k)))))
+        ((>= k n) sum))))
+
+; Convert the given Rational number to a Decimal string.
+; 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 opt contains 'plus, prefix positive numbers with plus ('+') sign.
+; N.B.:  When number of decimals specified, this truncates instead of rounds.
+
+(define rat->dec-str
+  (lambda (rat . opt)
+    (let* ((num (abs (numerator rat)))
+           (den (abs (denominator rat)))
+           (no-par (find (lambda (a) (eq? a 'nopar)) opt))
+           (plus (find (lambda (a) (eq? a 'plus)) opt))
+           (dec-lim (find integer? opt))
+           (rep-inx #f)
+           (rems-seen '())
+           (int-part (format (cond ((< rat 0) "-~d") (plus "+~d") (else "~d")) (quotient num den)))
+           (frc-list
+             (cond
+               ((zero? num)
+                 '())
+               (else
+                 (let loop ((rem (modulo num den)) (decs 0))
+                   (cond
+                     ((or (<= rem 0) (and dec-lim (>= decs dec-lim)))
+                       '())
+                     ((and (not dec-lim) (assq rem rems-seen))
+                       (set! rep-inx (cdr (assq rem rems-seen)))
+                       '())
+                     (else
+                       (set! rems-seen (cons (cons rem decs) rems-seen))
+                       (cons
+                         (integer->char (+ (quotient (* 10 rem) den) (char->integer #\0)))
+                         (loop (modulo (* 10 rem) den) (1+ decs))))))))))
+      (when (and rep-inx (not no-par))
+        (set! frc-list (append
+                         (list-head frc-list rep-inx)
+                         (list #\()
+                         (list-tail frc-list rep-inx)
+                         (list #\)))))
+      (if (null? frc-list)
+        int-part
+        (format "~a.~a" int-part (list->string frc-list))))))
+
+; Convert the given Rational Complex number to a Decimal string.
+; 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 opt contains 'plus, prefix positive numbers with plus ('+') sign.
+; N.B.:  When number of decimals specified, this truncates instead of rounds.
+
+(define rat-cplx->dec-str
+  (lambda (rat-cplx . opt)
+    (let* ((real-dec-str (apply rat->dec-str (cons (real-part rat-cplx) opt)))
+           (imag-dec-str (apply rat->dec-str (cons (imag-part rat-cplx) (cons 'plus opt)))))
+      (format "~a~ai" real-dec-str imag-dec-str))))
+
+; Print the value of e^(i*pi) + 1 -- should be 0.
+; (Computed using the series defined above.)
+
+(let*
+    ((pi (pi-series 222))
+     (e-pi-i (exp-series (* pi +i) 222))
+     (euler-id (+ e-pi-i 1)))
+  (printf "e^(i*pi) + 1 = ~a~%" (rat-cplx->dec-str euler-id 70)))

Task/Eulers-identity/Sidef/eulers-identity.sidef

@@ -0,0 +1,2 @@
+say ('e**i⁢π + 1 ≅ 0 : ', Num.e**Num.pi.i + 1 ≅ 0)
+say ('Error: ', Num.e**Num.pi.i + 1)

Task/Eulers-identity/Tcl/eulers-identity-1.tcl

@@ -0,0 +1,10 @@
+# Set up complex sandbox (since we're doing a star import)
+namespace eval complex_ns {
+    package require math::complexnumbers
+    namespace import ::math::complexnumbers::*
+
+    set pi [expr {acos(-1)}]
+
+    set r [+ [exp [complex 0 $pi]] [complex 1 0]]
+    puts "e**(pi*i) = [real $r]+[imag $r]i"
+}

Task/Eulers-identity/Tcl/eulers-identity-2.tcl

@@ -0,0 +1,5 @@
+package require vectcl
+namespace import vectcl::vexpr
+
+set ans [vexpr {pi=acos(-1); exp(pi*1i) + 1}]
+puts "e**(pi*i) = $ans"

Task/Eulers-identity/Wren/eulers-identity.wren

@@ -0,0 +1,3 @@
+import "/complex" for Complex
+
+System.print((Complex.new(0, Num.pi).exp + Complex.one).toString)

Task/Eulers-identity/Zkl/eulers-identity.zkl

@@ -0,0 +1,5 @@
+var [const] GSL=Import("zklGSL");	// libGSL (GNU Scientific Library)
+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 ));
+println("TMI: ",(Z(e).pow(Z(0,1)*pi) + 1 ).format(0,25,"g"));