[WIP] Add complex numbers exercise - Part I

config.json

@@ -995,6 +995,17 @@
         "Algorithms"
       ]
     },
+    {
+      "uuid": "0ed2de0f-70da-4f04-834e-01bfb0aa48d3",
+      "slug": "complex-numbers",
+      "core": false,
+      "unlocked_by": "leap",
+      "difficulty": 6,
+      "topics": [
+        "Tuples",
+        "Mathematics"
+      ]
+    },
     {
       "uuid": "d03a9508-336a-4425-8f47-f04317d1ba15",
       "slug": "poker",

exercises/Exercises.All.sln

@@ -1,6 +1,6 @@
 Microsoft Visual Studio Solution File, Format Version 12.00
 # Visual Studio 15
-VisualStudioVersion = 15.0.26228.4
+VisualStudioVersion = 15.0.26403.7
 MinimumVisualStudioVersion = 15.0.26124.0
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Accumulate", "accumulate\Accumulate.csproj", "{F16C0EE1-6923-4328-B015-363CF24FF867}"
 EndProject
@@ -218,6 +218,8 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "SpiralMatrix", "spiral-matr
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "CollatzConjecture", "collatz-conjecture\CollatzConjecture.csproj", "{18BC2EE7-E798-40DE-A346-0B803137E67D}"
 EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "ComplexNumbers", "complex-numbers\ComplexNumbers.csproj", "{D0399EAC-5563-4234-9828-0C607BAF7623}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -1524,6 +1526,18 @@ Global
 		{18BC2EE7-E798-40DE-A346-0B803137E67D}.Release|x64.Build.0 = Release|Any CPU
 		{18BC2EE7-E798-40DE-A346-0B803137E67D}.Release|x86.ActiveCfg = Release|Any CPU
 		{18BC2EE7-E798-40DE-A346-0B803137E67D}.Release|x86.Build.0 = Release|Any CPU
+		{D0399EAC-5563-4234-9828-0C607BAF7623}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{D0399EAC-5563-4234-9828-0C607BAF7623}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{D0399EAC-5563-4234-9828-0C607BAF7623}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{D0399EAC-5563-4234-9828-0C607BAF7623}.Debug|x64.Build.0 = Debug|Any CPU
+		{D0399EAC-5563-4234-9828-0C607BAF7623}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{D0399EAC-5563-4234-9828-0C607BAF7623}.Debug|x86.Build.0 = Debug|Any CPU
+		{D0399EAC-5563-4234-9828-0C607BAF7623}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{D0399EAC-5563-4234-9828-0C607BAF7623}.Release|Any CPU.Build.0 = Release|Any CPU
+		{D0399EAC-5563-4234-9828-0C607BAF7623}.Release|x64.ActiveCfg = Release|Any CPU
+		{D0399EAC-5563-4234-9828-0C607BAF7623}.Release|x64.Build.0 = Release|Any CPU
+		{D0399EAC-5563-4234-9828-0C607BAF7623}.Release|x86.ActiveCfg = Release|Any CPU
+		{D0399EAC-5563-4234-9828-0C607BAF7623}.Release|x86.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE

exercises/complex-numbers/ComplexNumbers.cs

@@ -0,0 +1,53 @@
+using System;
+
+public struct ComplexNumber
+{
+    public ComplexNumber(double real, double imaginary)
+    {
+    }
+
+    public double Real()
+    {
+        throw new NotImplementedException("You need to implement this function.");
+    }
+
+    public double Imaginary()
+    {
+        throw new NotImplementedException("You need to implement this function.");
+    }
+
+    public ComplexNumber Mul(ComplexNumber other)
+    {
+        throw new NotImplementedException("You need to implement this function.");
+    }
+
+    public ComplexNumber Add(ComplexNumber other)
+    {
+        throw new NotImplementedException("You need to implement this function.");
+    }
+
+    public ComplexNumber Sub(ComplexNumber other)
+    {
+        throw new NotImplementedException("You need to implement this function.");
+    }
+
+    public ComplexNumber Div(ComplexNumber other)
+    {
+        throw new NotImplementedException("You need to implement this function.");
+    }
+
+    public double Abs()
+    {
+        throw new NotImplementedException("You need to implement this function.");
+    }
+
+    public ComplexNumber Conjugate()
+    {
+        throw new NotImplementedException("You need to implement this function.");
+    }
+
+    public ComplexNumber Exp()
+    {
+        throw new NotImplementedException("You need to implement this function.");
+    }
+}

exercises/complex-numbers/ComplexNumbers.csproj

@@ -0,0 +1,18 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>netcoreapp1.0</TargetFramework>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <Compile Remove="Example.cs" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.0.0" />
+    <PackageReference Include="xunit" Version="2.2.0" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.2.0" />
+  </ItemGroup>
+
+</Project>

exercises/complex-numbers/ComplexNumbersTest.cs

@@ -0,0 +1,255 @@
+// This file was auto-generated based on version 1.0.0 of the canonical data.
+
+using Xunit;
+using System;
+
+public class ComplexNumbersTest
+{
+    [Fact]
+    public void Real_part_of_a_purely_real_number()
+    {
+        var sut = new ComplexNumber(1, 0);
+        Assert.Equal(1, sut.Real());
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Real_part_of_a_purely_imaginary_number()
+    {
+        var sut = new ComplexNumber(0, 1);
+        Assert.Equal(0, sut.Real());
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Real_part_of_a_number_with_real_and_imaginary_part()
+    {
+        var sut = new ComplexNumber(1, 2);
+        Assert.Equal(1, sut.Real());
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Imaginary_part_of_a_purely_real_number()
+    {
+        var sut = new ComplexNumber(1, 0);
+        Assert.Equal(0, sut.Imaginary());
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Imaginary_part_of_a_purely_imaginary_number()
+    {
+        var sut = new ComplexNumber(0, 1);
+        Assert.Equal(1, sut.Imaginary());
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Imaginary_part_of_a_number_with_real_and_imaginary_part()
+    {
+        var sut = new ComplexNumber(1, 2);
+        Assert.Equal(2, sut.Imaginary());
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Imaginary_unit()
+    {
+        var sut = new ComplexNumber(0, 1);
+        var expected = new ComplexNumber(-1, 0);
+        Assert.Equal(expected.Real(), sut.Mul(new ComplexNumber(0, 1)).Real(), 15);
+        Assert.Equal(expected.Imaginary(), sut.Mul(new ComplexNumber(0, 1)).Imaginary(), 15);
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Add_purely_real_numbers()
+    {
+        var sut = new ComplexNumber(1, 0);
+        var expected = new ComplexNumber(3, 0);
+        Assert.Equal(expected.Real(), sut.Add(new ComplexNumber(2, 0)).Real(), 15);
+        Assert.Equal(expected.Imaginary(), sut.Add(new ComplexNumber(2, 0)).Imaginary(), 15);
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Add_purely_imaginary_numbers()
+    {
+        var sut = new ComplexNumber(0, 1);
+        var expected = new ComplexNumber(0, 3);
+        Assert.Equal(expected.Real(), sut.Add(new ComplexNumber(0, 2)).Real(), 15);
+        Assert.Equal(expected.Imaginary(), sut.Add(new ComplexNumber(0, 2)).Imaginary(), 15);
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Add_numbers_with_real_and_imaginary_part()
+    {
+        var sut = new ComplexNumber(1, 2);
+        var expected = new ComplexNumber(4, 6);
+        Assert.Equal(expected.Real(), sut.Add(new ComplexNumber(3, 4)).Real(), 15);
+        Assert.Equal(expected.Imaginary(), sut.Add(new ComplexNumber(3, 4)).Imaginary(), 15);
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Subtract_purely_real_numbers()
+    {
+        var sut = new ComplexNumber(1, 0);
+        var expected = new ComplexNumber(-1, 0);
+        Assert.Equal(expected.Real(), sut.Sub(new ComplexNumber(2, 0)).Real(), 15);
+        Assert.Equal(expected.Imaginary(), sut.Sub(new ComplexNumber(2, 0)).Imaginary(), 15);
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Subtract_purely_imaginary_numbers()
+    {
+        var sut = new ComplexNumber(0, 1);
+        var expected = new ComplexNumber(0, -1);
+        Assert.Equal(expected.Real(), sut.Sub(new ComplexNumber(0, 2)).Real(), 15);
+        Assert.Equal(expected.Imaginary(), sut.Sub(new ComplexNumber(0, 2)).Imaginary(), 15);
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Subtract_numbers_with_real_and_imaginary_part()
+    {
+        var sut = new ComplexNumber(1, 2);
+        var expected = new ComplexNumber(-2, -2);
+        Assert.Equal(expected.Real(), sut.Sub(new ComplexNumber(3, 4)).Real(), 15);
+        Assert.Equal(expected.Imaginary(), sut.Sub(new ComplexNumber(3, 4)).Imaginary(), 15);
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Multiply_purely_real_numbers()
+    {
+        var sut = new ComplexNumber(1, 0);
+        var expected = new ComplexNumber(2, 0);
+        Assert.Equal(expected.Real(), sut.Mul(new ComplexNumber(2, 0)).Real(), 15);
+        Assert.Equal(expected.Imaginary(), sut.Mul(new ComplexNumber(2, 0)).Imaginary(), 15);
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Multiply_purely_imaginary_numbers()
+    {
+        var sut = new ComplexNumber(0, 1);
+        var expected = new ComplexNumber(-2, 0);
+        Assert.Equal(expected.Real(), sut.Mul(new ComplexNumber(0, 2)).Real(), 15);
+        Assert.Equal(expected.Imaginary(), sut.Mul(new ComplexNumber(0, 2)).Imaginary(), 15);
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Multiply_numbers_with_real_and_imaginary_part()
+    {
+        var sut = new ComplexNumber(1, 2);
+        var expected = new ComplexNumber(-5, 10);
+        Assert.Equal(expected.Real(), sut.Mul(new ComplexNumber(3, 4)).Real(), 15);
+        Assert.Equal(expected.Imaginary(), sut.Mul(new ComplexNumber(3, 4)).Imaginary(), 15);
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Divide_purely_real_numbers()
+    {
+        var sut = new ComplexNumber(1, 0);
+        var expected = new ComplexNumber(0.5, 0);
+        Assert.Equal(expected.Real(), sut.Div(new ComplexNumber(2, 0)).Real(), 15);
+        Assert.Equal(expected.Imaginary(), sut.Div(new ComplexNumber(2, 0)).Imaginary(), 15);
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Divide_purely_imaginary_numbers()
+    {
+        var sut = new ComplexNumber(0, 1);
+        var expected = new ComplexNumber(0.5, 0);
+        Assert.Equal(expected.Real(), sut.Div(new ComplexNumber(0, 2)).Real(), 15);
+        Assert.Equal(expected.Imaginary(), sut.Div(new ComplexNumber(0, 2)).Imaginary(), 15);
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Divide_numbers_with_real_and_imaginary_part()
+    {
+        var sut = new ComplexNumber(1, 2);
+        var expected = new ComplexNumber(0.44, 0.08);
+        Assert.Equal(expected.Real(), sut.Div(new ComplexNumber(3, 4)).Real(), 15);
+        Assert.Equal(expected.Imaginary(), sut.Div(new ComplexNumber(3, 4)).Imaginary(), 15);
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Absolute_value_of_a_positive_purely_real_number()
+    {
+        var sut = new ComplexNumber(5, 0);
+        Assert.Equal(5, sut.Abs());
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Absolute_value_of_a_negative_purely_real_number()
+    {
+        var sut = new ComplexNumber(-5, 0);
+        Assert.Equal(5, sut.Abs());
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Absolute_value_of_a_purely_imaginary_number_with_positive_imaginary_part()
+    {
+        var sut = new ComplexNumber(0, 5);
+        Assert.Equal(5, sut.Abs());
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Absolute_value_of_a_purely_imaginary_number_with_negative_imaginary_part()
+    {
+        var sut = new ComplexNumber(0, -5);
+        Assert.Equal(5, sut.Abs());
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Absolute_value_of_a_number_with_real_and_imaginary_part()
+    {
+        var sut = new ComplexNumber(3, 4);
+        Assert.Equal(5, sut.Abs());
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Conjugate_a_purely_real_number()
+    {
+        var sut = new ComplexNumber(5, 0);
+        var expected = new ComplexNumber(5, 0);
+        Assert.Equal(expected.Real(), sut.Conjugate().Real(), 15);
+        Assert.Equal(expected.Imaginary(), sut.Conjugate().Imaginary(), 15);
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Conjugate_a_purely_imaginary_number()
+    {
+        var sut = new ComplexNumber(0, 5);
+        var expected = new ComplexNumber(0, -5);
+        Assert.Equal(expected.Real(), sut.Conjugate().Real(), 15);
+        Assert.Equal(expected.Imaginary(), sut.Conjugate().Imaginary(), 15);
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Conjugate_a_number_with_real_and_imaginary_part()
+    {
+        var sut = new ComplexNumber(1, 1);
+        var expected = new ComplexNumber(1, -1);
+        Assert.Equal(expected.Real(), sut.Conjugate().Real(), 15);
+        Assert.Equal(expected.Imaginary(), sut.Conjugate().Imaginary(), 15);
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Eulers_identity_formula()
+    {
+        var sut = new ComplexNumber(0, Math.PI);
+        var expected = new ComplexNumber(-1, 0);
+        Assert.Equal(expected.Real(), sut.Exp().Real(), 15);
+        Assert.Equal(expected.Imaginary(), sut.Exp().Imaginary(), 15);
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Exponential_of_0()
+    {
+        var sut = new ComplexNumber(0, 0);
+        var expected = new ComplexNumber(1, 0);
+        Assert.Equal(expected.Real(), sut.Exp().Real(), 15);
+        Assert.Equal(expected.Imaginary(), sut.Exp().Imaginary(), 15);
+    }
+
+    [Fact(Skip = "Remove to run test")]
+    public void Exponential_of_a_purely_real_number()
+    {
+        var sut = new ComplexNumber(1, 0);
+        var expected = new ComplexNumber(Math.E, 0);
+        Assert.Equal(expected.Real(), sut.Exp().Real(), 15);
+        Assert.Equal(expected.Imaginary(), sut.Exp().Imaginary(), 15);
+    }
+}