Data commit

Task/Arithmetic-Complex/C-sharp/arithmetic-complex-1.cs

@@ -0,0 +1,17 @@
+namespace RosettaCode.Arithmetic.Complex
+{
+    using System;
+    using System.Numerics;
+
+    internal static class Program
+    {
+        private static void Main()
+        {
+            var number = Complex.ImaginaryOne;
+            foreach (var result in new[] { number + number, number * number, -number, 1 / number, Complex.Conjugate(number) })
+            {
+                Console.WriteLine(result);
+            }
+        }
+    }
+}

Task/Arithmetic-Complex/C-sharp/arithmetic-complex-2.cs

@@ -0,0 +1,205 @@
+using System;
+
+public struct ComplexNumber
+{
+    public static readonly ComplexNumber i = new ComplexNumber(0.0, 1.0);
+    public static readonly ComplexNumber Zero = new ComplexNumber(0.0, 0.0);
+
+    public double Re;
+    public double Im;
+
+    public ComplexNumber(double re)
+    {
+        this.Re = re;
+        this.Im = 0;
+    }
+
+    public ComplexNumber(double re, double im)
+    {
+        this.Re = re;
+        this.Im = im;
+    }
+
+    public static ComplexNumber operator *(ComplexNumber n1, ComplexNumber n2)
+    {
+        return new ComplexNumber(n1.Re * n2.Re - n1.Im * n2.Im,
+            n1.Im * n2.Re + n1.Re * n2.Im);
+    }
+
+    public static ComplexNumber operator *(double n1, ComplexNumber n2)
+    {
+        return new ComplexNumber(n1 * n2.Re, n1 * n2.Im);
+    }
+
+    public static ComplexNumber operator /(ComplexNumber n1, ComplexNumber n2)
+    {
+        double n2Norm = n2.Re * n2.Re + n2.Im * n2.Im;
+        return new ComplexNumber((n1.Re * n2.Re + n1.Im * n2.Im) / n2Norm,
+            (n1.Im * n2.Re - n1.Re * n2.Im) / n2Norm);
+    }
+
+    public static ComplexNumber operator /(ComplexNumber n1, double n2)
+    {
+        return new ComplexNumber(n1.Re / n2, n1.Im / n2);
+    }
+
+    public static ComplexNumber operator +(ComplexNumber n1, ComplexNumber n2)
+    {
+        return new ComplexNumber(n1.Re + n2.Re, n1.Im + n2.Im);
+    }
+
+    public static ComplexNumber operator -(ComplexNumber n1, ComplexNumber n2)
+    {
+        return new ComplexNumber(n1.Re - n2.Re, n1.Im - n2.Im);
+    }
+
+    public static ComplexNumber operator -(ComplexNumber n)
+    {
+        return new ComplexNumber(-n.Re, -n.Im);
+    }
+
+    public static implicit operator ComplexNumber(double n)
+    {
+        return new ComplexNumber(n, 0.0);
+    }
+
+    public static explicit operator double(ComplexNumber n)
+    {
+        return n.Re;
+    }
+
+    public static bool operator ==(ComplexNumber n1, ComplexNumber n2)
+    {
+        return n1.Re == n2.Re && n1.Im == n2.Im;
+    }
+
+    public static bool operator !=(ComplexNumber n1, ComplexNumber n2)
+    {
+        return n1.Re != n2.Re || n1.Im != n2.Im;
+    }
+
+    public override bool Equals(object obj)
+    {
+        return this == (ComplexNumber)obj;
+    }
+
+    public override int GetHashCode()
+    {
+        return Re.GetHashCode() ^ Im.GetHashCode();
+    }
+
+    public override string ToString()
+    {
+        return String.Format("{0}+{1}*i", Re, Im);
+    }
+}
+
+public static class ComplexMath
+{
+    public static double Abs(ComplexNumber a)
+    {
+        return Math.Sqrt(Norm(a));
+    }
+
+    public static double Norm(ComplexNumber a)
+    {
+        return a.Re * a.Re + a.Im * a.Im;
+    }
+
+    public static double Arg(ComplexNumber a)
+    {
+        return Math.Atan2(a.Im, a.Re);
+    }
+
+    public static ComplexNumber Inverse(ComplexNumber a)
+    {
+        double norm = Norm(a);
+        return new ComplexNumber(a.Re / norm, -a.Im / norm);
+    }
+
+    public static ComplexNumber Conjugate(ComplexNumber a)
+    {
+        return new ComplexNumber(a.Re, -a.Im);
+
+    }
+
+    public static ComplexNumber Exp(ComplexNumber a)
+    {
+        double e = Math.Exp(a.Re);
+        return new ComplexNumber(e * Math.Cos(a.Im), e * Math.Sin(a.Im));
+    }
+
+    public static ComplexNumber Log(ComplexNumber a)
+    {
+
+        return new ComplexNumber(0.5 * Math.Log(Norm(a)), Arg(a));
+    }
+
+    public static ComplexNumber Power(ComplexNumber a, ComplexNumber power)
+    {
+        return Exp(power * Log(a));
+    }
+
+    public static ComplexNumber Power(ComplexNumber a, int power)
+    {
+        bool inverse = false;
+        if (power < 0)
+        {
+            inverse = true; power = -power;
+        }
+
+        ComplexNumber result = 1.0;
+        ComplexNumber multiplier = a;
+        while (power > 0)
+        {
+            if ((power & 1) != 0) result *= multiplier;
+            multiplier *= multiplier;
+            power >>= 1;
+        }
+
+        if (inverse)
+            return Inverse(result);
+        else
+            return result;
+    }
+
+    public static ComplexNumber Sqrt(ComplexNumber a)
+    {
+        return Exp(0.5 * Log(a));
+    }
+
+    public static ComplexNumber Sin(ComplexNumber a)
+    {
+        return Sinh(ComplexNumber.i * a) / ComplexNumber.i;
+    }
+
+    public static ComplexNumber Cos(ComplexNumber a)
+    {
+        return Cosh(ComplexNumber.i * a);
+    }
+
+    public static ComplexNumber Sinh(ComplexNumber a)
+    {
+        return 0.5 * (Exp(a) - Exp(-a));
+    }
+
+    public static ComplexNumber Cosh(ComplexNumber a)
+    {
+        return 0.5 * (Exp(a) + Exp(-a));
+    }
+
+}
+
+class Program
+{
+    static void Main(string[] args)
+    {
+        // usage
+        ComplexNumber i = 2;
+        ComplexNumber j = new ComplexNumber(1, -2);
+        Console.WriteLine(i * j);
+        Console.WriteLine(ComplexMath.Power(j, 2));
+        Console.WriteLine((double)ComplexMath.Sin(i) + " vs " + Math.Sin(2));
+        Console.WriteLine(ComplexMath.Power(j, 0) == 1.0);
+    }
+}