trackler 2.2.1.124 → 2.2.1.125

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8aa6a1f238562934ebf1bfff8e11fbaf66e1beb4
-  data.tar.gz: db116f9134a151f55e7f571b9d06f9b41f5ef852
+  metadata.gz: fbe6714f67121bde0d0bff60621209109e983f88
+  data.tar.gz: e94a247d8e07206e2b18a5b8adbf65ccba59d38b
 SHA512:
-  metadata.gz: 6ee3b8079ec7660d89bd5aa520fe4baebef6559ea57a91907194371aa2402de5ad1439b106dd9423028b7b7fb8b7502412ea639536af4448687a7f149d8ec4a3
-  data.tar.gz: 1532f6f88c98d3a10a827264a6029e17577e4d4852f7adb34026312cbaf3b2aa0b6bdf7a477b2fc7562bad0bb094e00226ca9906bbff8b24307f3ec948faec04
+  metadata.gz: 555d14a7c7a07b0c18b25be4ce44d4a4519940c508781fa8e8b7817614b9d4c2aa2d744f935b8c5ef08f87f16e288e403dbcb6a8f4c8711f6ad2ad870093b6f1
+  data.tar.gz: 38ecbbd2bc9a048f757c5c98a1d7a03fe0dba0b422453f5afeab05b9e9262671afd91795f144ca4f7d675565d49a6292bfff2b8cbddb9da8db1ffe11eff05fdf

data/lib/trackler/version.rb

@@ -1,3 +1,3 @@
 module Trackler
-  VERSION = "2.2.1.124"
+  VERSION = "2.2.1.125"
 end

data/tracks/delphi/exercises/book-store/uBookStoreExample.pas

@@ -37,6 +37,7 @@ type
   public
     function Total:integer;
     constructor Create(aBasket: TArray<Integer>);
+    destructor Destroy; override;
   end;
 
 function NewBasket(aBasket: TArray<Integer>): IBasket;
@@ -145,6 +146,12 @@ begin
   result := min(subResult[0], subResult[1]);
 end;
 
+destructor TBasket.Destroy;
+begin
+  fIntList.DisposeOf;
+  inherited;
+end;
+
 function TBasket.DiscountPercentage(inStr : string):extended;
 var numDiffBooks: integer;
 begin

data/tracks/swift/config.json

@@ -853,6 +853,17 @@
       "unlocked_by": null,
       "uuid": "a7074b04-3ac5-4437-817e-2dc31d9d8ae0"
     },
+    {
+      "core": false,
+      "difficulty": 6,
+      "slug": "complex-numbers",
+      "topics": [
+        "mathematics",
+        "tuples"
+      ],
+      "unlocked_by": "leap",
+      "uuid": "5a918ed8-e840-46b8-b824-291d872d2224"
+    },
     {
       "core": false,
       "difficulty": 7,

data/tracks/swift/exercises/complex-numbers/.gitignore

@@ -0,0 +1,4 @@
+.DS_Store
+/.build
+/Packages
+/*.xcodeproj

data/tracks/swift/exercises/complex-numbers/Package.swift

@@ -0,0 +1,5 @@
+import PackageDescription
+
+let package = Package(
+    name: "ComplexNumbers"
+)

data/tracks/swift/exercises/complex-numbers/README.md

@@ -0,0 +1,29 @@
+# Complex Numbers
+
+A complex number is a number in the form a + b * i where a and b are real and i satisfies i^2 = -1.
+
+a is called the real part and b is called the imaginary part of z. The conjugate of the number a + b * i is the number a - b * i. The absolute value of a complex number z = a + b * i is a real number |z| = sqrt(a^2 + b^2). The square of the absolute value |z|^2 is the result of multiplication of z by its complex conjugate.
+
+The sum/difference of two complex numbers involves adding/subtracting their real and imaginary parts separately: (a + i * b) + (c + i * d) = (a + c) + (b + d) * i, (a + i * b) - (c + i * d) = (a - c) + (b - d) * i.
+
+Multiplication result is by definition (a + i * b) * (c + i * d) = (a * c - b * d) + (b * c + a * d) * i.
+
+The reciprocal of a non-zero complex number is 1 / (a + i * b) = a/(a^2 + b^2) - b/(a^2 + b^2) * i.
+
+Dividing a complex number a + i * b by another c + i * d gives: (a + i * b) / (c + i * d) = (a * c + b * d)/(c^2 + d^2) + (b * c - a * d)/(c^2 + d^2) * i.
+
+Exponent of a complex number can be expressed as exp(a + i * b) = exp(a) * exp(i * b), and the last term is given by Euler's formula exp(i * b) = cos(b) + i * sin(b).
+
+Implement the following operations:
+
+addition, subtraction, multiplication and division of two complex numbers,
+conjugate, absolute value, exponent of a given complex number.
+Assume the programming language you are using does not have an implementation of complex numbers.
+
+## Source
+
+Wikipedia https://en.wikipedia.org/wiki/Complex_number
+
+## Submitting Incomplete Solutions
+
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

data/tracks/swift/exercises/complex-numbers/Sources/ComplexNumbers.swift

@@ -0,0 +1 @@
+//Solution goes in Sources

data/tracks/swift/exercises/complex-numbers/Sources/ComplexNumbersExample.swift

@@ -0,0 +1,66 @@
+import Foundation
+
+struct ComplexNumber {
+
+    var realComponent: Double
+
+    var imaginaryComponent: Double
+
+    func getRealComponent() -> Double {
+
+        return self.realComponent
+    }
+
+    func getImaginaryComponent() -> Double {
+
+        return self.imaginaryComponent
+    }
+
+    func add(complexNumber: ComplexNumber) -> ComplexNumber {
+
+        return ComplexNumber(realComponent: self.realComponent + complexNumber.realComponent, imaginaryComponent: self.imaginaryComponent + complexNumber.imaginaryComponent)
+
+    }
+
+    func subtract(complexNumber: ComplexNumber) -> ComplexNumber {
+
+        return ComplexNumber(realComponent: self.realComponent - complexNumber.realComponent, imaginaryComponent: self.imaginaryComponent - complexNumber.imaginaryComponent)
+    }
+
+    func multiply(complexNumber: ComplexNumber) -> ComplexNumber {
+
+        return ComplexNumber(realComponent: self.realComponent * complexNumber.realComponent - self.imaginaryComponent * complexNumber.imaginaryComponent, imaginaryComponent: self.imaginaryComponent * complexNumber.realComponent + self.realComponent * complexNumber.imaginaryComponent)
+    }
+
+    func divide(complexNumber: ComplexNumber) -> ComplexNumber {
+
+        let amplitudeOfComplexNumber = (complexNumber.realComponent *  complexNumber.realComponent) + (complexNumber.imaginaryComponent * complexNumber.imaginaryComponent)
+
+        let realPartOfQuotient = (self.realComponent * complexNumber.realComponent + self.imaginaryComponent * complexNumber.imaginaryComponent) / amplitudeOfComplexNumber
+
+        let imaginaryPartOfQuotient = (self.imaginaryComponent * complexNumber.realComponent - self.realComponent * self.realComponent * complexNumber.imaginaryComponent) / amplitudeOfComplexNumber
+
+        return ComplexNumber(realComponent: realPartOfQuotient, imaginaryComponent: imaginaryPartOfQuotient)
+    }
+
+    func conjugate() -> ComplexNumber {
+
+        return ComplexNumber(realComponent: self.realComponent, imaginaryComponent: (-1 * self.imaginaryComponent))
+    }
+
+    func absolute() -> Double {
+
+        return sqrt(pow(self.realComponent, 2.0) + pow(self.imaginaryComponent, 2.0))
+    }
+
+    func exponent() -> ComplexNumber {
+
+        let realPartOfResult = cos(self.imaginaryComponent)
+        let imaginaryPartOfResult = sin(self.imaginaryComponent)
+        let factor = exp(self.realComponent)
+
+        return ComplexNumber(realComponent: realPartOfResult * factor, imaginaryComponent: imaginaryPartOfResult * factor)
+
+    }
+
+}

data/tracks/swift/exercises/complex-numbers/Tests/ComplexNumbersTests/ComplexNumbersTests.swift

@@ -0,0 +1,321 @@
+import XCTest
+@testable import ComplexNumbers
+
+class ComplexNumbersTests: XCTestCase {
+
+    override func setUp() {
+        super.setUp()
+        // Put setup code here. This method is called before the invocation of each test method in the class.
+    }
+
+    override func tearDown() {
+        // Put teardown code here. This method is called after the invocation of each test method in the class.
+        super.tearDown()
+    }
+
+    func testRealPartOfPurelyRealNumber() {
+
+        let input = ComplexNumber(realComponent: 1, imaginaryComponent: 0)
+        let expectedOutput = Double(1)
+        XCTAssertEqual(expectedOutput, input.getRealComponent())
+    }
+
+    func testRealPartOfPurelyImaginaryNumber() {
+
+        let input = ComplexNumber(realComponent: 0, imaginaryComponent: 1)
+        let expectedOutput = Double(1)
+        XCTAssertEqual(expectedOutput, input.getImaginaryComponent())
+    }
+
+    func testRealPartOfNumberWithRealAndImaginary() {
+
+        let input = ComplexNumber(realComponent: 1, imaginaryComponent: 2)
+        let expectedOutput = Double(1)
+        XCTAssertEqual(expectedOutput, input.getRealComponent())
+    }
+
+    func testImaginaryPartOfPurelyRealNumber() {
+
+        let input = ComplexNumber(realComponent: 1, imaginaryComponent: 0)
+        let expectedOutput = Double(0)
+        XCTAssertEqual(expectedOutput, input.getImaginaryComponent())
+    }
+
+    func testImaginaryPartOfPurelyImaginaryNumber() {
+
+        let input = ComplexNumber(realComponent: 0, imaginaryComponent: 1)
+        let expectedOutput = Double(1)
+        XCTAssertEqual(expectedOutput, input.getImaginaryComponent())
+    }
+
+    func testImaginaryPartOfNumberWithRealAndImaginary() {
+
+        let input = ComplexNumber(realComponent: 1, imaginaryComponent: 2)
+        let expectedOutput = Double(2)
+        XCTAssertEqual(expectedOutput, input.getImaginaryComponent())
+    }
+
+    func testImaginaryUnit() {
+
+        let multiplicand = ComplexNumber(realComponent: 0, imaginaryComponent: 1)
+        let multiplier = ComplexNumber(realComponent: 0, imaginaryComponent: 1)
+        let expectedProduct = ComplexNumber(realComponent: -1, imaginaryComponent: 0)
+        let actualProduct = multiplicand.multiply(complexNumber: multiplier)
+        XCTAssertEqual([expectedProduct.realComponent, expectedProduct.imaginaryComponent], [actualProduct.realComponent, actualProduct.imaginaryComponent])
+    }
+
+    func testAddPurelyRealNumbers() {
+
+        let addend = ComplexNumber(realComponent: 1, imaginaryComponent: 0)
+        let augend = ComplexNumber(realComponent: 2, imaginaryComponent: 0)
+        let expectedSum = ComplexNumber(realComponent: 3, imaginaryComponent: 0)
+        let actualSum = ComplexNumber(realComponent: addend.add(complexNumber: augend).realComponent, imaginaryComponent: addend.add(complexNumber: augend).imaginaryComponent)
+        XCTAssertEqual([expectedSum.realComponent, expectedSum.imaginaryComponent], [actualSum.realComponent, actualSum.imaginaryComponent])
+    }
+
+    func testAddPurelyImaginaryNumbers() {
+
+        let addend = ComplexNumber(realComponent: 0, imaginaryComponent: 1)
+        let augend = ComplexNumber(realComponent: 0, imaginaryComponent: 2)
+        let expectedSum = ComplexNumber(realComponent: 0, imaginaryComponent: 3)
+        let actualSum = addend.add(complexNumber: augend)
+
+        XCTAssertEqual([expectedSum.realComponent, expectedSum.imaginaryComponent], [actualSum.realComponent, actualSum.imaginaryComponent])
+    }
+
+    func testAddNumbersWithRealAndImaginaryParts() {
+
+        let addend = ComplexNumber(realComponent: 1, imaginaryComponent: 2)
+        let augend = ComplexNumber(realComponent: 3, imaginaryComponent: 4)
+        let expectedSum = ComplexNumber(realComponent: 4, imaginaryComponent: 6)
+        let actualSum = addend.add(complexNumber: augend)
+
+        XCTAssertEqual([expectedSum.realComponent, expectedSum.imaginaryComponent], [actualSum.realComponent, actualSum.imaginaryComponent])
+    }
+
+    func testSubtractPurelyRealNumbers() {
+
+        let subtrahend = ComplexNumber(realComponent: 1, imaginaryComponent: 0)
+        let minuend = ComplexNumber(realComponent: 2, imaginaryComponent: 0)
+        let expectedDifference = ComplexNumber(realComponent: -1, imaginaryComponent: 0)
+        let actualDifference = subtrahend.subtract(complexNumber: minuend)
+
+        XCTAssertEqual([expectedDifference.realComponent, expectedDifference.imaginaryComponent], [actualDifference.realComponent, actualDifference.imaginaryComponent])
+    }
+
+    func testSubtractPurelyImaginaryNumbers() {
+
+        let subtrahend = ComplexNumber(realComponent: 0, imaginaryComponent: 1)
+        let minuend = ComplexNumber(realComponent: 0, imaginaryComponent: 2)
+        let expectedDifference = ComplexNumber(realComponent: 0, imaginaryComponent: -1)
+        let actualDifference = subtrahend.subtract(complexNumber: minuend)
+
+        XCTAssertEqual([expectedDifference.realComponent, expectedDifference.imaginaryComponent], [actualDifference.realComponent, actualDifference.imaginaryComponent])
+    }
+
+    func testSubtractNumbersWithRealAndImaginaryParts() {
+
+        let subtrahend = ComplexNumber(realComponent: 1, imaginaryComponent: 2)
+        let minuend = ComplexNumber(realComponent: 3, imaginaryComponent: 4)
+        let expectedDifference = ComplexNumber(realComponent: -2, imaginaryComponent: -2)
+        let actualDifference = subtrahend.subtract(complexNumber: minuend)
+
+        XCTAssertEqual([expectedDifference.realComponent, expectedDifference.imaginaryComponent], [actualDifference.realComponent, actualDifference.imaginaryComponent])
+
+    }
+
+    func testMultiplicationOfPurelyRealNumbers() {
+
+        let multiplicand = ComplexNumber(realComponent: 1, imaginaryComponent: 0)
+        let multiplier = ComplexNumber(realComponent: 2, imaginaryComponent: 0)
+        let expectedProduct = ComplexNumber(realComponent: 2, imaginaryComponent: 0)
+        let actualProduct = multiplicand.multiply(complexNumber: multiplier)
+
+        XCTAssertEqual([expectedProduct.realComponent, expectedProduct.imaginaryComponent], [actualProduct.realComponent, actualProduct.imaginaryComponent])
+
+    }
+
+    func testMultiplicationOfPurelyImaginaryNumbers() {
+
+        let multiplicand = ComplexNumber(realComponent: 0, imaginaryComponent: 1)
+        let multiplier = ComplexNumber(realComponent: 0, imaginaryComponent: 2)
+        let expectedProduct = ComplexNumber(realComponent: -2, imaginaryComponent: 0)
+        let actualProduct = multiplicand.multiply(complexNumber: multiplier)
+
+        XCTAssertEqual([expectedProduct.realComponent, expectedProduct.imaginaryComponent], [actualProduct.realComponent, actualProduct.imaginaryComponent])
+    }
+
+    func testMultiplyNumbersWithRealAndImaginaryParts() {
+
+        let multiplicand = ComplexNumber(realComponent: 1, imaginaryComponent: 2)
+        let multiplier = ComplexNumber(realComponent: 3, imaginaryComponent: 4)
+        let expectedProduct = ComplexNumber(realComponent: -5, imaginaryComponent: 10)
+        let actualProduct = multiplicand.multiply(complexNumber: multiplier)
+
+        XCTAssertEqual([expectedProduct.realComponent, expectedProduct.imaginaryComponent], [actualProduct.realComponent, actualProduct.imaginaryComponent])
+    }
+
+    func testDividePurelyRealNumbers() {
+
+        let dividend = ComplexNumber(realComponent: 1, imaginaryComponent: 0)
+        let divisor = ComplexNumber(realComponent: 2, imaginaryComponent: 0)
+        let expectedQuotient = ComplexNumber(realComponent: 0.5, imaginaryComponent: 0)
+        let actualQuotient = dividend.divide(complexNumber: divisor)
+
+        XCTAssertEqual([expectedQuotient.realComponent, expectedQuotient.imaginaryComponent], [actualQuotient.realComponent, actualQuotient.imaginaryComponent])
+    }
+
+    func testDividePurelyImaginaryNumbers() {
+
+        let dividend = ComplexNumber(realComponent: 0, imaginaryComponent: 1)
+        let divisor = ComplexNumber(realComponent: 0, imaginaryComponent: 2)
+        let expectedQuotient = ComplexNumber(realComponent: 0.5, imaginaryComponent: 0)
+        let actualQuotient = dividend.divide(complexNumber: divisor)
+
+        XCTAssertEqual([expectedQuotient.realComponent, expectedQuotient.imaginaryComponent], [actualQuotient.realComponent, actualQuotient.imaginaryComponent])
+    }
+
+    func testDividingNumbersWithRealAndImaginaryParts() {
+
+        let dividend = ComplexNumber(realComponent: 1, imaginaryComponent: 2)
+        let divisor = ComplexNumber(realComponent: 3, imaginaryComponent: 4)
+        let expectedQuotient = ComplexNumber(realComponent: 0.44, imaginaryComponent: 0.08)
+        let actualQuotient = dividend.divide(complexNumber: divisor)
+
+        XCTAssertEqual([expectedQuotient.realComponent, expectedQuotient.imaginaryComponent], [actualQuotient.realComponent, actualQuotient.imaginaryComponent])
+    }
+
+    func testAbsoluteValueOfPositivePurelyRealNumber() {
+
+        let input = ComplexNumber(realComponent: 5, imaginaryComponent: 0)
+        let expectedResult = Double(5)
+        XCTAssertEqual(expectedResult, input.absolute())
+    }
+
+    func testAbsoluteValueOfNegativePurelyRealNumber() {
+
+        let input = ComplexNumber(realComponent: -5, imaginaryComponent: 0)
+        let expectedResult = Double(5)
+        XCTAssertEqual(expectedResult, input.absolute())
+    }
+
+    func testAbsoluteValueOfPositivePurelyImaginaryNumber() {
+
+        let input = ComplexNumber(realComponent: 0, imaginaryComponent: 5)
+        let expectedResult = Double(5)
+        XCTAssertEqual(expectedResult, input.absolute())
+    }
+
+    func testAbsoluteValueOfNegativePurelyImaginaryNumber() {
+
+        let input = ComplexNumber(realComponent: 0, imaginaryComponent: -5)
+        let expectedResult = Double(5)
+        XCTAssertEqual(expectedResult, input.absolute())
+    }
+
+    func testAbsoluteValueOfNumberWithRealAndImaginaryParts() {
+
+        let input = ComplexNumber(realComponent: 3, imaginaryComponent: 4)
+        let expectedResult = Double(5)
+        XCTAssertEqual(expectedResult, input.absolute())
+    }
+
+    func testConjugateOfAPurelyRealNumber() {
+
+        let input = ComplexNumber(realComponent: 5, imaginaryComponent: 0)
+        let expectedResult = ComplexNumber(realComponent: 5, imaginaryComponent: 0)
+        let actualResult = input.conjugate()
+    XCTAssertEqual([expectedResult.realComponent, expectedResult.imaginaryComponent], [actualResult.realComponent, actualResult.imaginaryComponent])
+    }
+
+    func testConjugateOfAPurelyImaginaryNumber() {
+
+        let input = ComplexNumber(realComponent: 0, imaginaryComponent: 5)
+        let expectedResult = ComplexNumber(realComponent: 0, imaginaryComponent: -5)
+        let actualResult = input.conjugate()
+        XCTAssertEqual([expectedResult.realComponent, expectedResult.imaginaryComponent], [actualResult.realComponent, actualResult.imaginaryComponent])
+    }
+
+    func testConjugateOfANumberWithRealAndImaginaryParts() {
+
+        let input = ComplexNumber(realComponent: 1, imaginaryComponent: 1)
+        let expectedResult = ComplexNumber(realComponent: 1, imaginaryComponent: -1)
+        let actualResult = input.conjugate()
+        XCTAssertEqual([expectedResult.realComponent, expectedResult.imaginaryComponent], [actualResult.realComponent, actualResult.imaginaryComponent])
+    }
+
+    func testEulersIdentityForComplexNumbers() {
+
+        let input = ComplexNumber(realComponent: 0, imaginaryComponent: Double(String(format: "%.3f", Double.pi))!)
+        let expectedResult = ComplexNumber(realComponent: -1, imaginaryComponent: 0)
+        let actualResult = input.exponent()
+    XCTAssertEqual([expectedResult.realComponent, expectedResult.imaginaryComponent], [Double(String(format: "%.3f", actualResult.realComponent))!, Double(String(format: "%.3f", actualResult.imaginaryComponent))!])
+
+    }
+
+    func testExponentOfZero() {
+
+        let input = ComplexNumber(realComponent: 0, imaginaryComponent: 0)
+        let expectedResult = ComplexNumber(realComponent: 1, imaginaryComponent: 0)
+        let actualResult = input.exponent()
+    XCTAssertEqual([expectedResult.realComponent, expectedResult.imaginaryComponent], [actualResult.realComponent, actualResult.imaginaryComponent])
+    }
+
+    func testExponentOfPurelyRealNumber() {
+
+        let input = ComplexNumber(realComponent: 1, imaginaryComponent: 0)
+        let expectedResult = ComplexNumber(realComponent: exp(1), imaginaryComponent: 0)
+        let actualResult = input.exponent()
+    XCTAssertEqual([expectedResult.realComponent, expectedResult.imaginaryComponent], [actualResult.realComponent, actualResult.imaginaryComponent])
+    }
+
+    func testExponentOfNumberWithRealAndImaginaryPart() {
+
+        let input = ComplexNumber(realComponent: log(2), imaginaryComponent: Double(String(format: "%.3f", Double.pi))!)
+        let expectedResult = ComplexNumber(realComponent: -2, imaginaryComponent: 0)
+        let actualResult = input.exponent()
+
+        XCTAssertEqual([expectedResult.realComponent, expectedResult.imaginaryComponent], [round(actualResult.realComponent), Double(String(format: "%.1f", actualResult.imaginaryComponent))!])
+    }
+
+    static var allTests: [(String, (ComplexNumbersTests) -> () throws -> Void)] {
+        return [
+            ("testRealPartOfPurelyRealNumber", testRealPartOfPurelyRealNumber),
+            ("testRealPartOfPurelyImaginaryNumber", testRealPartOfPurelyImaginaryNumber),
+            ("testRealPartOfNumberWithRealAndImaginary", testRealPartOfNumberWithRealAndImaginary),
+            ("testImaginaryPartOfPurelyRealNumber", testImaginaryPartOfPurelyRealNumber),
+            ("testImaginaryPartOfPurelyImaginaryNumber", testImaginaryPartOfPurelyImaginaryNumber),
+            ("testImaginaryPartOfNumberWithRealAndImaginary", testImaginaryPartOfNumberWithRealAndImaginary),
+            ("testImaginaryUnit", testImaginaryUnit),
+            ("testAddPurelyRealNumbers", testAddPurelyRealNumbers),
+            ("testAddPurelyImaginaryNumbers", testAddPurelyImaginaryNumbers),
+            ("testAddNumbersWithRealAndImaginaryParts", testAddNumbersWithRealAndImaginaryParts),
+            ("testSubtractPurelyRealNumbers", testSubtractPurelyRealNumbers),
+            ("testSubtractPurelyImaginaryNumbers", testSubtractPurelyImaginaryNumbers),
+            ("testSubtractNumbersWithRealAndImaginaryParts", testSubtractNumbersWithRealAndImaginaryParts),
+            ("testMultiplicationOfPurelyRealNumbers", testMultiplicationOfPurelyRealNumbers),
+            ("testMultiplicationOfPurelyImaginaryNumbers", testMultiplicationOfPurelyImaginaryNumbers),
+            ("testMultiplyNumbersWithRealAndImaginaryParts", testMultiplyNumbersWithRealAndImaginaryParts),
+            ("testDividePurelyRealNumbers", testDividePurelyRealNumbers),
+            ("testDividePurelyImaginaryNumbers", testDividePurelyImaginaryNumbers),
+            ("testDividingNumbersWithRealAndImaginaryParts", testDividingNumbersWithRealAndImaginaryParts),
+            ("testAbsoluteValueOfPositivePurelyRealNumber", testAbsoluteValueOfPositivePurelyRealNumber),
+            ("testAbsoluteValueOfNegativePurelyRealNumber", testAbsoluteValueOfNegativePurelyRealNumber),
+            ("testAbsoluteValueOfPositivePurelyImaginaryNumber", testAbsoluteValueOfPositivePurelyImaginaryNumber),
+            ("testAbsoluteValueOfNegativePurelyImaginaryNumber", testAbsoluteValueOfNegativePurelyImaginaryNumber),
+            ("testAbsoluteValueOfNumberWithRealAndImaginaryParts", testAbsoluteValueOfNumberWithRealAndImaginaryParts),
+            ("testConjugateOfAPurelyRealNumber", testConjugateOfAPurelyRealNumber),
+            ("testConjugateOfAPurelyImaginaryNumber", testConjugateOfAPurelyImaginaryNumber),
+
+            ("testConjugateOfANumberWithRealAndImaginaryParts", testConjugateOfANumberWithRealAndImaginaryParts),
+
+            ("testEulersIdentityForComplexNumbers", testEulersIdentityForComplexNumbers),
+
+                ("testExponentOfZero", testExponentOfZero),
+            ("testExponentOfPurelyRealNumber", testExponentOfPurelyRealNumber),
+
+            ("testExponentOfNumberWithRealAndImaginaryPart", testExponentOfNumberWithRealAndImaginaryPart)
+        ]
+    }
+
+}