complex-numbers: add to track

config.json

       ]
     },
     {
+      "slug": "complex-numbers",
+      "difficulty": 8,
+      "topics": [
+
+      ]
+    },
+    {
       "slug": "change",
       "difficulty": 8,
       "topics": [

exercises/complex-numbers/build.gradle

+apply plugin: "java"
+apply plugin: "eclipse"
+apply plugin: "idea"
+
+repositories {
+  mavenCentral()
+}
+
+dependencies {
+  testCompile "junit:junit:4.12"
+}
+
+test {
+  testLogging {
+    exceptionFormat = 'full'
+    events = ["passed", "failed", "skipped"]
+  }
+}

exercises/complex-numbers/src/example/java/ComplexNumber.java

+final class ComplexNumber {
+
+    private final double real;
+
+    private final double imag;
+
+    ComplexNumber(double real, double imag) {
+        this.real = real;
+        this.imag = imag;
+    }
+
+    double getReal() {
+        return real;
+    }
+
+    double getImag() {
+        return imag;
+    }
+
+    ComplexNumber times(ComplexNumber other) {
+        return new ComplexNumber(
+                real * other.real - imag * other.imag,
+                real * other.imag + imag * other.real);
+    }
+
+    ComplexNumber add(ComplexNumber other) {
+        return new ComplexNumber(real + other.real, imag + other.imag);
+    }
+
+    ComplexNumber minus(ComplexNumber other) {
+        return new ComplexNumber(real - other.real, imag - other.imag);
+    }
+
+    ComplexNumber div(ComplexNumber other) {
+        return this.times(other.conjugate()).div(Math.pow(other.abs(), 2));
+    }
+
+    double abs() {
+        return Math.hypot(real, imag);
+    }
+
+    ComplexNumber conjugate() {
+        return new ComplexNumber(real, -imag);
+    }
+
+    ComplexNumber exponentialOf() {
+        return new ComplexNumber(Math.cos(imag), Math.sin(imag)).times(Math.exp(real));
+    }
+
+    private ComplexNumber div(double factor) {
+        return new ComplexNumber(real / factor, imag / factor);
+    }
+
+    private ComplexNumber times(double factor) {
+        return new ComplexNumber(factor * real, factor * imag);
+    }
+}

exercises/complex-numbers/src/test/java/ComplexNumberTest.java

+import org.junit.Ignore;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+public class ComplexNumberTest {
+
+    // Test helpers
+
+    private static final double DOUBLE_EQUALITY_TOLERANCE = 1e-15;
+
+    private void assertDoublesEqual(double d1, double d2) {
+        assertEquals(d1, d2, DOUBLE_EQUALITY_TOLERANCE);
+    }
+
+    private void assertComplexNumbersEqual(ComplexNumber c1, ComplexNumber c2) {
+        assertDoublesEqual(c1.getReal(), c2.getReal());
+        assertDoublesEqual(c1.getImag(), c2.getImag());
+    }
+
+    // Tests
+
+    @Test
+    public void testImaginaryUnitExhibitsDefiningProperty() {
+        ComplexNumber expected = new ComplexNumber(-1.0, 0);
+        ComplexNumber actual = new ComplexNumber(0, 1.0).times(new ComplexNumber(0, 1.0));
+        assertComplexNumbersEqual(expected, actual);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testAdditionWithPurelyRealNumbers() {
+        ComplexNumber expected = new ComplexNumber(3.0, 0);
+        ComplexNumber actual = new ComplexNumber(1.0, 0).add(new ComplexNumber(2.0, 0));
+        assertComplexNumbersEqual(expected, actual);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testAdditionWithPurelyImaginaryNumbers() {
+        ComplexNumber expected = new ComplexNumber(0, 3.0);
+        ComplexNumber actual = new ComplexNumber(0, 1.0).add(new ComplexNumber(0, 2.0));
+        assertComplexNumbersEqual(expected, actual);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testAdditionWithRealAndImaginaryParts() {
+        ComplexNumber expected = new ComplexNumber(4.0, 6.0);
+        ComplexNumber actual = new ComplexNumber(1.0, 2.0).add(new ComplexNumber(3.0, 4.0));
+        assertComplexNumbersEqual(expected, actual);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testSubtractionWithPurelyRealNumbers() {
+        ComplexNumber expected = new ComplexNumber(-1.0, 0.0);
+        ComplexNumber actual = new ComplexNumber(1.0, 0.0).minus(new ComplexNumber(2.0, 0.0));
+        assertComplexNumbersEqual(expected, actual);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testSubtractionWithPurelyImaginaryNumbers() {
+        ComplexNumber expected = new ComplexNumber(0, -1.0);
+        ComplexNumber actual = new ComplexNumber(0, 1.0).minus(new ComplexNumber(0, 2.0));
+        assertComplexNumbersEqual(expected, actual);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testSubtractionWithRealAndImaginaryParts() {
+        ComplexNumber expected = new ComplexNumber(-2.0, -2.0);
+        ComplexNumber actual = new ComplexNumber(1.0, 2.0).minus(new ComplexNumber(3.0, 4.0));
+        assertComplexNumbersEqual(expected, actual);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testMultiplicationWithPurelyRealNumbers() {
+        ComplexNumber expected = new ComplexNumber(2.0, 0);
+        ComplexNumber actual = new ComplexNumber(1.0, 0).times(new ComplexNumber(2.0, 0));
+        assertComplexNumbersEqual(expected, actual);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testMultiplicationWithPurelyImaginaryNumbers() {
+        ComplexNumber expected = new ComplexNumber(-2.0, 0);
+        ComplexNumber actual = new ComplexNumber(0, 1.0).times(new ComplexNumber(0, 2.0));
+        assertComplexNumbersEqual(expected, actual);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testMultiplicationWithRealAndImaginaryParts() {
+        ComplexNumber expected = new ComplexNumber(-5.0, 10.0);
+        ComplexNumber actual = new ComplexNumber(1.0, 2.0).times(new ComplexNumber(3.0, 4.0));
+        assertComplexNumbersEqual(expected, actual);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testDivisionWithPurelyRealNumbers() {
+        ComplexNumber expected = new ComplexNumber(0.5, 0);
+        ComplexNumber actual = new ComplexNumber(1.0, 0).div(new ComplexNumber(2.0, 0));
+        assertComplexNumbersEqual(expected, actual);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testDivisionWithPurelyImaginaryNumbers() {
+        ComplexNumber expected = new ComplexNumber(0.5, 0);
+        ComplexNumber actual = new ComplexNumber(0, 1.0).div(new ComplexNumber(0, 2.0));
+        assertComplexNumbersEqual(expected, actual);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testDivisionWithRealAndImaginaryParts() {
+        ComplexNumber expected = new ComplexNumber(0.44, 0.08);
+        ComplexNumber actual = new ComplexNumber(1.0, 2.0).div(new ComplexNumber(3.0, 4.0));
+        assertComplexNumbersEqual(expected, actual);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testAbsoluteValueOfPositivePurelyRealNumber() {
+        double expected = 5.0;
+        double actual = new ComplexNumber(5.0, 0).abs();
+        assertDoublesEqual(expected, actual);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testAbsoluteValueOfNegativePurelyRealNumber() {
+        double expected = 5.0;
+        double actual = new ComplexNumber(-5.0, 0).abs();
+        assertDoublesEqual(expected, actual);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testAbsoluteValueOfPurelyImaginaryNumberWithPositiveImaginaryPart() {
+        double expected = 5.0;
+        double actual = new ComplexNumber(0, 5.0).abs();
+        assertDoublesEqual(expected, actual);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testAbsoluteValueOfPurelyImaginaryNumberWithNegativeImaginaryPart() {
+        double expected = 5.0;
+        double actual = new ComplexNumber(0, -5.0).abs();
+        assertDoublesEqual(expected, actual);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testAbsoluteValueOfNumberWithRealAndImaginaryParts() {
+        double expected = 5.0;
+        double actual = new ComplexNumber(3.0, 4.0).abs();
+        assertDoublesEqual(expected, actual);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testConjugationOfPurelyRealNumber() {
+        ComplexNumber expected = new ComplexNumber(5.0, 0);
+        ComplexNumber actual = new ComplexNumber(5.0, 0).conjugate();
+        assertComplexNumbersEqual(expected, actual);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testConjugationOfPurelyImaginaryNumber() {
+        ComplexNumber expected = new ComplexNumber(0, -5.0);
+        ComplexNumber actual = new ComplexNumber(0, 5.0).conjugate();
+        assertComplexNumbersEqual(expected, actual);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testConjugationOfNumberWithRealAndImaginaryParts() {
+        ComplexNumber expected = new ComplexNumber(1.0, -1.0);
+        ComplexNumber actual = new ComplexNumber(1.0, 1.0).conjugate();
+        assertComplexNumbersEqual(expected, actual);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testRealPartOfPurelyRealNumber() {
+        double expected = 1.0;
+        double actual = new ComplexNumber(1.0, 0).getReal();
+        assertDoublesEqual(expected, actual);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testRealPartOfPurelyImaginaryNumber() {
+        double expected = 0.0;
+        double actual = new ComplexNumber(0, 1.0).getReal();
+        assertDoublesEqual(expected, actual);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testRealPartOfNumberWithRealAndImaginaryParts() {
+        double expected = 1.0;
+        double actual = new ComplexNumber(1.0, 2.0).getReal();
+        assertDoublesEqual(expected, actual);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testImaginaryPartOfPurelyRealNumber() {
+        double expected = 0.0;
+        double actual = new ComplexNumber(1.0, 0).getImag();
+        assertDoublesEqual(expected, actual);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testImaginaryPartOfPurelyImaginaryNumber() {
+        double expected = 1.0;
+        double actual = new ComplexNumber(0, 1.0).getImag();
+        assertDoublesEqual(expected, actual);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testImaginaryPartOfNumberWithRealAndImaginaryParts() {
+        double expected = 2.0;
+        double actual = new ComplexNumber(1.0, 2.0).getImag();
+        assertDoublesEqual(expected, actual);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testExponentialOfPurelyImaginaryNumber() {
+        ComplexNumber expected = new ComplexNumber(-1.0, 0);
+        ComplexNumber actual = new ComplexNumber(0, Math.PI).exponentialOf();
+        assertComplexNumbersEqual(expected, actual);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testExponentialOfZero() {
+        ComplexNumber expected = new ComplexNumber(1.0, 0);
+        ComplexNumber actual = new ComplexNumber(0, 0).exponentialOf();
+        assertComplexNumbersEqual(expected, actual);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void testExponentialOfPurelyRealNumber() {
+        ComplexNumber expected = new ComplexNumber(Math.E, 0);
+        ComplexNumber actual = new ComplexNumber(1.0, 0).exponentialOf();
+        assertComplexNumbersEqual(expected, actual);
+    }
+
+}

exercises/settings.gradle

 include 'change'
 include 'clock'
 include 'collatz-conjecture'
+include 'complex-numbers'
 include 'crypto-square'
 include 'custom-set'
 include 'diamond'