From 80206aeb73b1a43adaec4302a222a845916c5f33 Mon Sep 17 00:00:00 2001 From: resu-xuniL Date: Sat, 19 Sep 2026 23:24:09 +0200 Subject: [PATCH 1/6] Generate exercice with `configlet create` --- config.json | 8 ++ .../complex-numbers/.docs/instructions.md | 100 ++++++++++++++ .../complex-numbers/.meta/config.json | 17 +++ .../complex-numbers/.meta/example.php | 0 .../practice/complex-numbers/.meta/tests.toml | 130 ++++++++++++++++++ .../complex-numbers/ComplexNumbers.php | 0 .../complex-numbers/ComplexNumbersTest.php | 0 7 files changed, 255 insertions(+) create mode 100644 exercises/practice/complex-numbers/.docs/instructions.md create mode 100644 exercises/practice/complex-numbers/.meta/config.json create mode 100644 exercises/practice/complex-numbers/.meta/example.php create mode 100644 exercises/practice/complex-numbers/.meta/tests.toml create mode 100644 exercises/practice/complex-numbers/ComplexNumbers.php create mode 100644 exercises/practice/complex-numbers/ComplexNumbersTest.php diff --git a/config.json b/config.json index 1ef332ef2..744202c8d 100644 --- a/config.json +++ b/config.json @@ -1402,6 +1402,14 @@ "practices": [], "prerequisites": [], "difficulty": 7 + }, + { + "slug": "complex-numbers", + "name": "Complex Numbers", + "uuid": "6ae0a351-0dba-4889-b0ec-ad23483cbc48", + "practices": [], + "prerequisites": [], + "difficulty": 1 } ], "foregone": [ diff --git a/exercises/practice/complex-numbers/.docs/instructions.md b/exercises/practice/complex-numbers/.docs/instructions.md new file mode 100644 index 000000000..2b8a7a49d --- /dev/null +++ b/exercises/practice/complex-numbers/.docs/instructions.md @@ -0,0 +1,100 @@ +# Instructions + +A **complex number** is expressed in the form `z = a + b * i`, where: + +- `a` is the **real part** (a real number), + +- `b` is the **imaginary part** (also a real number), and + +- `i` is the **imaginary unit** satisfying `i^2 = -1`. + +## Operations on Complex Numbers + +### Conjugate + +The conjugate of the complex number `z = a + b * i` is given by: + +```text +zc = a - b * i +``` + +### Absolute Value + +The absolute value (or modulus) of `z` is defined as: + +```text +|z| = sqrt(a^2 + b^2) +``` + +The square of the absolute value is computed as the product of `z` and its conjugate `zc`: + +```text +|z|^2 = z * zc = a^2 + b^2 +``` + +### Addition + +The sum of two complex numbers `z1 = a + b * i` and `z2 = c + d * i` is computed by adding their real and imaginary parts separately: + +```text +z1 + z2 = (a + b * i) + (c + d * i) + = (a + c) + (b + d) * i +``` + +### Subtraction + +The difference of two complex numbers is obtained by subtracting their respective parts: + +```text +z1 - z2 = (a + b * i) - (c + d * i) + = (a - c) + (b - d) * i +``` + +### Multiplication + +The product of two complex numbers is defined as: + +```text +z1 * z2 = (a + b * i) * (c + d * i) + = (a * c - b * d) + (b * c + a * d) * i +``` + +### Reciprocal + +The reciprocal of a non-zero complex number is given by: + +```text +1 / z = 1 / (a + b * i) + = a / (a^2 + b^2) - b / (a^2 + b^2) * i +``` + +### Division + +The division of one complex number by another is given by: + +```text +z1 / z2 = z1 * (1 / z2) + = (a + b * i) / (c + d * i) + = (a * c + b * d) / (c^2 + d^2) + (b * c - a * d) / (c^2 + d^2) * i +``` + +### Exponentiation + +Raising _e_ (the base of the natural logarithm) to a complex exponent can be expressed using Euler's formula: + +```text +e^(a + b * i) = e^a * e^(b * i) + = e^a * (cos(b) + i * sin(b)) +``` + +## Implementation Requirements + +Given that you should not use built-in support for complex numbers, implement the following operations: + +- **addition** of two complex numbers +- **subtraction** of two complex numbers +- **multiplication** of two complex numbers +- **division** of two complex numbers +- **conjugate** of a complex number +- **absolute value** of a complex number +- **exponentiation** of _e_ (the base of the natural logarithm) to a complex number diff --git a/exercises/practice/complex-numbers/.meta/config.json b/exercises/practice/complex-numbers/.meta/config.json new file mode 100644 index 000000000..65f177c70 --- /dev/null +++ b/exercises/practice/complex-numbers/.meta/config.json @@ -0,0 +1,17 @@ +{ + "authors": [], + "files": { + "solution": [ + "ComplexNumbers.php" + ], + "test": [ + "ComplexNumbersTest.php" + ], + "example": [ + ".meta/example.php" + ] + }, + "blurb": "Implement complex numbers.", + "source": "Wikipedia", + "source_url": "https://en.wikipedia.org/wiki/Complex_number" +} diff --git a/exercises/practice/complex-numbers/.meta/example.php b/exercises/practice/complex-numbers/.meta/example.php new file mode 100644 index 000000000..e69de29bb diff --git a/exercises/practice/complex-numbers/.meta/tests.toml b/exercises/practice/complex-numbers/.meta/tests.toml new file mode 100644 index 000000000..dffb1f2a3 --- /dev/null +++ b/exercises/practice/complex-numbers/.meta/tests.toml @@ -0,0 +1,130 @@ +# This is an auto-generated file. +# +# Regenerating this file via `configlet sync` will: +# - Recreate every `description` key/value pair +# - Recreate every `reimplements` key/value pair, where they exist in problem-specifications +# - Remove any `include = true` key/value pair (an omitted `include` key implies inclusion) +# - Preserve any other key/value pair +# +# As user-added comments (using the # character) will be removed when this file +# is regenerated, comments can be added via a `comment` key. + +[9f98e133-eb7f-45b0-9676-cce001cd6f7a] +description = "Real part -> Real part of a purely real number" + +[07988e20-f287-4bb7-90cf-b32c4bffe0f3] +description = "Real part -> Real part of a purely imaginary number" + +[4a370e86-939e-43de-a895-a00ca32da60a] +description = "Real part -> Real part of a number with real and imaginary part" + +[9b3fddef-4c12-4a99-b8f8-e3a42c7ccef6] +description = "Imaginary part -> Imaginary part of a purely real number" + +[a8dafedd-535a-4ed3-8a39-fda103a2b01e] +description = "Imaginary part -> Imaginary part of a purely imaginary number" + +[0f998f19-69ee-4c64-80ef-01b086feab80] +description = "Imaginary part -> Imaginary part of a number with real and imaginary part" + +[a39b7fd6-6527-492f-8c34-609d2c913879] +description = "Imaginary unit" + +[9a2c8de9-f068-4f6f-b41c-82232cc6c33e] +description = "Arithmetic -> Addition -> Add purely real numbers" + +[657c55e1-b14b-4ba7-bd5c-19db22b7d659] +description = "Arithmetic -> Addition -> Add purely imaginary numbers" + +[4e1395f5-572b-4ce8-bfa9-9a63056888da] +description = "Arithmetic -> Addition -> Add numbers with real and imaginary part" + +[1155dc45-e4f7-44b8-af34-a91aa431475d] +description = "Arithmetic -> Subtraction -> Subtract purely real numbers" + +[f95e9da8-acd5-4da4-ac7c-c861b02f774b] +description = "Arithmetic -> Subtraction -> Subtract purely imaginary numbers" + +[f876feb1-f9d1-4d34-b067-b599a8746400] +description = "Arithmetic -> Subtraction -> Subtract numbers with real and imaginary part" + +[8a0366c0-9e16-431f-9fd7-40ac46ff4ec4] +description = "Arithmetic -> Multiplication -> Multiply purely real numbers" + +[e560ed2b-0b80-4b4f-90f2-63cefc911aaf] +description = "Arithmetic -> Multiplication -> Multiply purely imaginary numbers" + +[4d1d10f0-f8d4-48a0-b1d0-f284ada567e6] +description = "Arithmetic -> Multiplication -> Multiply numbers with real and imaginary part" + +[b0571ddb-9045-412b-9c15-cd1d816d36c1] +description = "Arithmetic -> Division -> Divide purely real numbers" + +[5bb4c7e4-9934-4237-93cc-5780764fdbdd] +description = "Arithmetic -> Division -> Divide purely imaginary numbers" + +[c4e7fef5-64ac-4537-91c2-c6529707701f] +description = "Arithmetic -> Division -> Divide numbers with real and imaginary part" + +[c56a7332-aad2-4437-83a0-b3580ecee843] +description = "Absolute value -> Absolute value of a positive purely real number" + +[cf88d7d3-ee74-4f4e-8a88-a1b0090ecb0c] +description = "Absolute value -> Absolute value of a negative purely real number" + +[bbe26568-86c1-4bb4-ba7a-da5697e2b994] +description = "Absolute value -> Absolute value of a purely imaginary number with positive imaginary part" + +[3b48233d-468e-4276-9f59-70f4ca1f26f3] +description = "Absolute value -> Absolute value of a purely imaginary number with negative imaginary part" + +[fe400a9f-aa22-4b49-af92-51e0f5a2a6d3] +description = "Absolute value -> Absolute value of a number with real and imaginary part" + +[fb2d0792-e55a-4484-9443-df1eddfc84a2] +description = "Complex conjugate -> Conjugate a purely real number" + +[e37fe7ac-a968-4694-a460-66cb605f8691] +description = "Complex conjugate -> Conjugate a purely imaginary number" + +[f7704498-d0be-4192-aaf5-a1f3a7f43e68] +description = "Complex conjugate -> Conjugate a number with real and imaginary part" + +[6d96d4c6-2edb-445b-94a2-7de6d4caaf60] +description = "Complex exponential function -> Euler's identity/formula" + +[2d2c05a0-4038-4427-a24d-72f6624aa45f] +description = "Complex exponential function -> Exponential of 0" + +[ed87f1bd-b187-45d6-8ece-7e331232c809] +description = "Complex exponential function -> Exponential of a purely real number" + +[08eedacc-5a95-44fc-8789-1547b27a8702] +description = "Complex exponential function -> Exponential of a number with real and imaginary part" + +[d2de4375-7537-479a-aa0e-d474f4f09859] +description = "Complex exponential function -> Exponential resulting in a number with real and imaginary part" + +[06d793bf-73bd-4b02-b015-3030b2c952ec] +description = "Operations between real numbers and complex numbers -> Add real number to complex number" + +[d77dbbdf-b8df-43f6-a58d-3acb96765328] +description = "Operations between real numbers and complex numbers -> Add complex number to real number" + +[20432c8e-8960-4c40-ba83-c9d910ff0a0f] +description = "Operations between real numbers and complex numbers -> Subtract real number from complex number" + +[b4b38c85-e1bf-437d-b04d-49bba6e55000] +description = "Operations between real numbers and complex numbers -> Subtract complex number from real number" + +[dabe1c8c-b8f4-44dd-879d-37d77c4d06bd] +description = "Operations between real numbers and complex numbers -> Multiply complex number by real number" + +[6c81b8c8-9851-46f0-9de5-d96d314c3a28] +description = "Operations between real numbers and complex numbers -> Multiply real number by complex number" + +[8a400f75-710e-4d0c-bcb4-5e5a00c78aa0] +description = "Operations between real numbers and complex numbers -> Divide complex number by real number" + +[9a867d1b-d736-4c41-a41e-90bd148e9d5e] +description = "Operations between real numbers and complex numbers -> Divide real number by complex number" diff --git a/exercises/practice/complex-numbers/ComplexNumbers.php b/exercises/practice/complex-numbers/ComplexNumbers.php new file mode 100644 index 000000000..e69de29bb diff --git a/exercises/practice/complex-numbers/ComplexNumbersTest.php b/exercises/practice/complex-numbers/ComplexNumbersTest.php new file mode 100644 index 000000000..e69de29bb From 9fff11602bc27df58a20d2ef09add890c3460737 Mon Sep 17 00:00:00 2001 From: resu-xuniL Date: Sun, 20 Sep 2026 23:13:08 +0200 Subject: [PATCH 2/6] Create `test` and `example` files --- .../complex-numbers/.meta/example.php | 104 ++++ .../complex-numbers/ComplexNumbers.php | 33 ++ .../complex-numbers/ComplexNumbersTest.php | 516 ++++++++++++++++++ 3 files changed, 653 insertions(+) diff --git a/exercises/practice/complex-numbers/.meta/example.php b/exercises/practice/complex-numbers/.meta/example.php index e69de29bb..757b901d0 100644 --- a/exercises/practice/complex-numbers/.meta/example.php +++ b/exercises/practice/complex-numbers/.meta/example.php @@ -0,0 +1,104 @@ +real + $num2->real, + $this->imaginary + $num2->imaginary + ); + } + + public function addR(int|ComplexNumbers $num1, int|ComplexNumbers $num2): ComplexNumbers + { + is_int($num1) ? $num1 = new ComplexNumbers($num1) : $num2 = new ComplexNumbers($num2); + + return new ComplexNumbers( + $num1->real + $num2->real, + $num1->imaginary + $num2->imaginary + ); + } + + public function sub(ComplexNumbers $num2): ComplexNumbers + { + return new ComplexNumbers( + $this->real - $num2->real, + $this->imaginary - $num2->imaginary + ); + } + + public function subR(int|ComplexNumbers $num1, int|ComplexNumbers $num2): ComplexNumbers + { + is_int($num1) ? $num1 = new ComplexNumbers($num1) : $num2 = new ComplexNumbers($num2); + + return new ComplexNumbers( + $num1->real - $num2->real, + $num1->imaginary - $num2->imaginary + ); + } + + public function mul(ComplexNumbers $num2): ComplexNumbers + { + return new ComplexNumbers( + $this->real * $num2->real - $this->imaginary * $num2->imaginary, + $this->imaginary * $num2->real + $this->real * $num2->imaginary + ); + } + + public function mulR(int|ComplexNumbers $num1, int|ComplexNumbers $num2): ComplexNumbers + { + is_int($num1) ? $num1 = new ComplexNumbers($num1) : $num2 = new ComplexNumbers($num2); + + return new ComplexNumbers( + $num1->real * $num2->real - $num1->imaginary * $num2->imaginary, + $num1->imaginary * $num2->real + $num1->real * $num2->imaginary + ); + } + + public function div(ComplexNumbers $num2): ComplexNumbers + { + return new ComplexNumbers( + ($this->real * $num2->real + $this->imaginary * $num2->imaginary) / + (pow($num2->real, 2) + pow($num2->imaginary, 2)), + ($this->imaginary * $num2->real - $this->real * $num2->imaginary) / + (pow($num2->real, 2) + pow($num2->imaginary, 2)) + ); + } + + public function divR(int|ComplexNumbers $num1, int|ComplexNumbers $num2): ComplexNumbers + { + is_int($num1) ? $num1 = new ComplexNumbers($num1) : $num2 = new ComplexNumbers($num2); + + return new ComplexNumbers( + ($num1->real * $num2->real + $num1->imaginary * $num2->imaginary) / + (pow($num2->real, 2) + pow($num2->imaginary, 2)), + ($num1->imaginary * $num2->real - $num1->real * $num2->imaginary) / + (pow($num2->real, 2) + pow($num2->imaginary, 2)) + ); + } + + public function abs(): float + { + return hypot($this->real, $this->imaginary); + } + + public function conjugate(): ComplexNumbers + { + return new ComplexNumbers($this->real, $this->imaginary * -1); + } + + public function exp(): ComplexNumbers + { + return new ComplexNumbers( + exp($this->real) * cos($this->imaginary), + exp($this->real) * sin($this->imaginary) + ); + } +} diff --git a/exercises/practice/complex-numbers/ComplexNumbers.php b/exercises/practice/complex-numbers/ComplexNumbers.php index e69de29bb..fff8f45fd 100644 --- a/exercises/practice/complex-numbers/ComplexNumbers.php +++ b/exercises/practice/complex-numbers/ComplexNumbers.php @@ -0,0 +1,33 @@ +. + * + * To disable strict typing, comment out the directive below. + */ + +declare(strict_types=1); + +class ComplexNumbers +{ + public function __construct() + { + throw new \BadMethodCallException(sprintf('Implement the %s method', __FUNCTION__)); + } +} diff --git a/exercises/practice/complex-numbers/ComplexNumbersTest.php b/exercises/practice/complex-numbers/ComplexNumbersTest.php index e69de29bb..90db76465 100644 --- a/exercises/practice/complex-numbers/ComplexNumbersTest.php +++ b/exercises/practice/complex-numbers/ComplexNumbersTest.php @@ -0,0 +1,516 @@ + Real part of a purely real number')] + public function testRealPartRealPartOfAPurelyRealNumber(): void + { + $ComplexNumber = new ComplexNumbers(1, 0); + $expected = 1; + + $this->assertEquals($expected, $ComplexNumber->real); + } + + /** + * uuid 07988e20-f287-4bb7-90cf-b32c4bffe0f3 + */ + #[TestDox('Real part -> Real part of a purely imaginary number')] + public function testRealPartRealPartOfAPurelyImaginaryNumber(): void + { + $ComplexNumber = new ComplexNumbers(0, 1); + $expected = 0; + + $this->assertEquals($expected, $ComplexNumber->real); + } + + /** + * uuid 4a370e86-939e-43de-a895-a00ca32da60a + */ + #[TestDox('Real part -> Real part of a number with real and imaginary part')] + public function testRealPartRealPartOfANumberWithRealAndImaginaryPart(): void + { + $ComplexNumber = new ComplexNumbers(1, 2); + $expected = 1; + + $this->assertEquals($expected, $ComplexNumber->real); + } + + /** + * uuid 9b3fddef-4c12-4a99-b8f8-e3a42c7ccef6 + */ + #[TestDox('Imaginary part -> Imaginary part of a purely real number')] + public function testImaginaryPartImaginaryPartOfAPurelyRealNumber(): void + { + $ComplexNumber = new ComplexNumbers(1, 0); + $expected = 0; + + $this->assertEquals($expected, $ComplexNumber->imaginary); + } + + /** + * uuid a8dafedd-535a-4ed3-8a39-fda103a2b01e + */ + #[TestDox('Imaginary part -> Imaginary part of a purely imaginary number')] + public function testImaginaryPartImaginaryPartOfAPurelyImaginaryNumber(): void + { + $ComplexNumber = new ComplexNumbers(0, 1); + $expected = 1; + + $this->assertEquals($expected, $ComplexNumber->imaginary); + } + + /** + * uuid 0f998f19-69ee-4c64-80ef-01b086feab80 + */ + #[TestDox('Imaginary part -> Imaginary part of a number with real and imaginary part')] + public function testImaginaryPartImaginaryPartOfANumberWithRealAndImaginaryPart(): void + { + $ComplexNumber = new ComplexNumbers(1, 2); + $expected = 2; + + $this->assertEquals($expected, $ComplexNumber->imaginary); + } + + /** + * uuid a39b7fd6-6527-492f-8c34-609d2c913879 + */ + #[TestDox('Imaginary unit')] + public function testImaginaryUnit(): void + { + $ComplexNumber1 = new ComplexNumbers(0, 1); + $ComplexNumber2 = new ComplexNumbers(0, 1); + $expected = new ComplexNumbers(-1, 0); + + $this->assertEquals($expected, $ComplexNumber1->mul($ComplexNumber2)); + } + + /** + * uuid 9a2c8de9-f068-4f6f-b41c-82232cc6c33e + */ + #[TestDox('Arithmetic -> Addition -> Add purely real numbers')] + public function testArithmeticAdditionAddPurelyRealNumbers(): void + { + $ComplexNumber1 = new ComplexNumbers(1, 0); + $ComplexNumber2 = new ComplexNumbers(2, 0); + $expected = new ComplexNumbers(3, 0); + + $this->assertEquals($expected, $ComplexNumber1->add($ComplexNumber2)); + } + + /** + * uuid 657c55e1-b14b-4ba7-bd5c-19db22b7d659 + */ + #[TestDox('Arithmetic -> Addition -> Add purely imaginary numbers')] + public function testArithmeticAdditionAddPurelyImaginaryNumbers(): void + { + $ComplexNumber1 = new ComplexNumbers(0, 1); + $ComplexNumber2 = new ComplexNumbers(0, 2); + $expected = new ComplexNumbers(0, 3); + + $this->assertEquals($expected, $ComplexNumber1->add($ComplexNumber2)); + } + + /** + * uuid 4e1395f5-572b-4ce8-bfa9-9a63056888da + */ + #[TestDox('Arithmetic -> Addition -> Add numbers with real and imaginary part')] + public function testArithmeticAdditionAddNumbersWithRealAndImaginaryPart(): void + { + $ComplexNumber1 = new ComplexNumbers(1, 2); + $ComplexNumber2 = new ComplexNumbers(3, 4); + $expected = new ComplexNumbers(4, 6); + + $this->assertEquals($expected, $ComplexNumber1->add($ComplexNumber2)); + } + + /** + * uuid 1155dc45-e4f7-44b8-af34-a91aa431475d + */ + #[TestDox('Arithmetic -> Subtraction -> Subtract purely real numbers')] + public function testArithmeticSubtractionSubtractPurelyRealNumbers(): void + { + $ComplexNumber1 = new ComplexNumbers(1, 0); + $ComplexNumber2 = new ComplexNumbers(2, 0); + $expected = new ComplexNumbers(-1, 0); + + $this->assertEquals($expected, $ComplexNumber1->sub($ComplexNumber2)); + } + + /** + * uuid f95e9da8-acd5-4da4-ac7c-c861b02f774b + */ + #[TestDox('Arithmetic -> Subtraction -> Subtract purely imaginary numbers')] + public function testArithmeticSubtractionSubtractPurelyImaginaryNumbers(): void + { + $ComplexNumber1 = new ComplexNumbers(0, 1); + $ComplexNumber2 = new ComplexNumbers(0, 2); + $expected = new ComplexNumbers(0, -1); + + $this->assertEquals($expected, $ComplexNumber1->sub($ComplexNumber2)); + } + + /** + * uuid f876feb1-f9d1-4d34-b067-b599a8746400 + */ + #[TestDox('Arithmetic -> Subtraction -> Subtract numbers with real and imaginary part')] + public function testArithmeticSubtractionSubtractNumbersWithRealAndImaginaryPart(): void + { + $ComplexNumber1 = new ComplexNumbers(1, 2); + $ComplexNumber2 = new ComplexNumbers(3, 4); + $expected = new ComplexNumbers(-2, -2); + + $this->assertEquals($expected, $ComplexNumber1->sub($ComplexNumber2)); + } + + /** + * uuid 8a0366c0-9e16-431f-9fd7-40ac46ff4ec4 + */ + #[TestDox('Arithmetic -> Multiplication -> Multiply purely real numbers')] + public function testArithmeticMultiplicationMultiplyPurelyRealNumbers(): void + { + $ComplexNumber1 = new ComplexNumbers(1, 0); + $ComplexNumber2 = new ComplexNumbers(2, 0); + $expected = new ComplexNumbers(2, 0); + + $this->assertEquals($expected, $ComplexNumber1->mul($ComplexNumber2)); + } + + /** + * uuid e560ed2b-0b80-4b4f-90f2-63cefc911aaf + */ + #[TestDox('Arithmetic -> Multiplication -> Multiply purely imaginary numbers')] + public function testArithmeticMultiplicationMultiplyPurelyImaginaryNumbers(): void + { + $ComplexNumber1 = new ComplexNumbers(0, 1); + $ComplexNumber2 = new ComplexNumbers(0, 2); + $expected = new ComplexNumbers(-2, 0); + + $this->assertEquals($expected, $ComplexNumber1->mul($ComplexNumber2)); + } + + /** + * uuid 4d1d10f0-f8d4-48a0-b1d0-f284ada567e6 + */ + #[TestDox('Arithmetic -> Multiplication -> Multiply numbers with real and imaginary part')] + public function testArithmeticMultiplicationMultiplyNumbersWithRealAndImaginaryPart(): void + { + $ComplexNumber1 = new ComplexNumbers(1, 2); + $ComplexNumber2 = new ComplexNumbers(3, 4); + $expected = new ComplexNumbers(-5, 10); + + $this->assertEquals($expected, $ComplexNumber1->mul($ComplexNumber2)); + } + + /** + * uuid b0571ddb-9045-412b-9c15-cd1d816d36c1 + */ + #[TestDox('Arithmetic -> Division -> Divide purely real numbers')] + public function testArithmeticDivisionDividePurelyRealNumbers(): void + { + $ComplexNumber1 = new ComplexNumbers(1, 0); + $ComplexNumber2 = new ComplexNumbers(2, 0); + $expected = new ComplexNumbers(0.5, 0); + + $this->assertEquals($expected, $ComplexNumber1->div($ComplexNumber2)); + } + + /** + * uuid 5bb4c7e4-9934-4237-93cc-5780764fdbdd + */ + #[TestDox('Arithmetic -> Arithmetic -> Division -> Divide purely imaginary numbers')] + public function testArithmeticDivisionDividePurelyImaginaryNumbers(): void + { + $ComplexNumber1 = new ComplexNumbers(0, 1); + $ComplexNumber2 = new ComplexNumbers(0, 2); + $expected = new ComplexNumbers(0.5, 0); + + $this->assertEquals($expected, $ComplexNumber1->div($ComplexNumber2)); + } + + /** + * uuid c4e7fef5-64ac-4537-91c2-c6529707701f + */ + #[TestDox('Arithmetic -> Division -> Divide numbers with real and imaginary part')] + public function testArithmeticDivisionDivideNumbersWithRealAndImaginaryPart(): void + { + $ComplexNumber1 = new ComplexNumbers(1, 2); + $ComplexNumber2 = new ComplexNumbers(3, 4); + $expected = new ComplexNumbers(0.44, 0.08); + + $this->assertEquals($expected, $ComplexNumber1->div($ComplexNumber2)); + } + + + /** + * uuid c56a7332-aad2-4437-83a0-b3580ecee843 + */ + #[TestDox('Absolute value -> Absolute value of a positive purely real number')] + public function testAbsoluteValueAbsoluteValueOfAPositivePurelyRealNumber(): void + { + $ComplexNumber = new ComplexNumbers(5, 0); + $expected = 5; + + $this->assertEquals($expected, $ComplexNumber->abs()); + } + + /** + * uuid cf88d7d3-ee74-4f4e-8a88-a1b0090ecb0c + */ + #[TestDox('Absolute value -> Absolute value of a negative purely real number')] + public function testAbsoluteValueAbsoluteValueOfANegativePurelyRealNumber(): void + { + $ComplexNumber = new ComplexNumbers(-5, 0); + $expected = 5; + + $this->assertEquals($expected, $ComplexNumber->abs()); + } + + /** + * uuid bbe26568-86c1-4bb4-ba7a-da5697e2b994 + */ + #[TestDox('Absolute value -> Absolute value of a purely imaginary number with positive imaginary part')] + public function testAbsoluteValueAbsoluteValueOfAPurelyImaginaryNumberWithPositiveImaginaryPart(): void + { + $ComplexNumber = new ComplexNumbers(0, 5); + $expected = 5; + + $this->assertEquals($expected, $ComplexNumber->abs()); + } + + /** + * uuid 3b48233d-468e-4276-9f59-70f4ca1f26f3 + */ + #[TestDox('Absolute value -> Absolute value of a purely imaginary number with negative imaginary part')] + public function testAbsoluteValueAbsoluteValueOfAPurelyImaginaryNumberWithNegativeImaginaryPart(): void + { + $ComplexNumber = new ComplexNumbers(0, -5); + $expected = 5; + + $this->assertEquals($expected, $ComplexNumber->abs()); + } + + /** + * uuid fe400a9f-aa22-4b49-af92-51e0f5a2a6d3 + */ + #[TestDox('Absolute value -> Absolute value of a number with real and imaginary part')] + public function testAbsoluteValueAbsoluteValueOfANumberWithRealAndImaginaryPart(): void + { + $ComplexNumber = new ComplexNumbers(3, 4); + $expected = 5; + + $this->assertEquals($expected, $ComplexNumber->abs()); + } + + /** + * uuid fb2d0792-e55a-4484-9443-df1eddfc84a2 + */ + #[TestDox('Complex conjugate -> Conjugate a purely real number')] + public function testComplexConjugateConjugateAPurelyRealNumber(): void + { + $ComplexNumber = new ComplexNumbers(5, 0); + $expected = new ComplexNumbers(5, 0); + + $this->assertEquals($expected, $ComplexNumber->conjugate()); + } + + /** + * uuid e37fe7ac-a968-4694-a460-66cb605f8691 + */ + #[TestDox('Complex conjugate -> Conjugate a purely imaginary number')] + public function testComplexConjugateConjugateAPurelyImaginaryNumber(): void + { + $ComplexNumber = new ComplexNumbers(0, 5); + $expected = new ComplexNumbers(0, -5); + + $this->assertEquals($expected, $ComplexNumber->conjugate()); + } + + /** + * uuid f7704498-d0be-4192-aaf5-a1f3a7f43e68 + */ + #[TestDox('Complex conjugate -> Conjugate a number with real and imaginary part')] + public function testComplexConjugateConjugateANumberWithRealAndImaginaryPart(): void + { + $ComplexNumber = new ComplexNumbers(1, 1); + $expected = new ComplexNumbers(1, -1); + + $this->assertEquals($expected, $ComplexNumber->conjugate()); + } + + /** + * uuid 6d96d4c6-2edb-445b-94a2-7de6d4caaf60 + */ + #[TestDox("Complex exponential function -> Euler's identity/formula")] + public function testComplexExponentialFunctionEulersIdentityFormula(): void + { + $ComplexNumber = new ComplexNumbers(0, M_PI); + $expected = new ComplexNumbers(-1, 0); + + $this->assertEqualsWithDelta($expected, $ComplexNumber->exp(), 1e-10); + } + + /** + * uuid 2d2c05a0-4038-4427-a24d-72f6624aa45f + */ + #[TestDox("Complex exponential function -> Exponential of 0")] + public function testComplexExponentialFunctionExponentialOf0(): void + { + $ComplexNumber = new ComplexNumbers(0, 0); + $expected = new ComplexNumbers(1, 0); + + $this->assertEquals($expected, $ComplexNumber->exp()); + } + + /** + * uuid ed87f1bd-b187-45d6-8ece-7e331232c809 + */ + #[TestDox("Complex exponential function -> Exponential of a purely real number")] + public function testComplexExponentialFunctionExponentialOfAPurelyRealNumber(): void + { + $ComplexNumber = new ComplexNumbers(1, 0); + $expected = new ComplexNumbers(M_E, 0); + + $this->assertEquals($expected, $ComplexNumber->exp()); + } + + /** + * uuid 08eedacc-5a95-44fc-8789-1547b27a8702 + */ + #[TestDox("Complex exponential function -> Exponential of a number with real and imaginary part")] + public function testComplexExponentialFunctionExponentialOfANumberWithRealAndImaginaryPart(): void + { + $ComplexNumber = new ComplexNumbers(M_LN2, M_PI); + $expected = new ComplexNumbers(-2, 0); + + $this->assertEqualsWithDelta($expected, $ComplexNumber->exp(), 1e-10); + } + + /** + * uuid d2de4375-7537-479a-aa0e-d474f4f09859 + */ + #[TestDox("Complex exponential function -> Exponential resulting in a number with real and imaginary part")] + public function testComplexExponentialFunctionExponentialResultingInANumberWithRealAndImaginaryPart(): void + { + $ComplexNumber = new ComplexNumbers(M_LN2 / 2, M_PI_4); + $expected = new ComplexNumbers(1, 1); + + $this->assertEqualsWithDelta($expected, $ComplexNumber->exp(), 1e-10); + } + + /** + * uuid 06d793bf-73bd-4b02-b015-3030b2c952ec + */ + #[TestDox("Operations between real numbers and complex numbers -> Add real number to complex number")] + public function testOperationsBetweenRealNumbersAndComplexNumbersAddRealNumberToComplexNumber(): void + { + $realNumber = 5; + $ComplexNumber = new ComplexNumbers(1, 2); + $expected = new ComplexNumbers(6, 2); + + $this->assertEquals($expected, $ComplexNumber->addR($ComplexNumber, $realNumber)); + } + + /** + * uuid d77dbbdf-b8df-43f6-a58d-3acb96765328 + */ + #[TestDox("Operations between real numbers and complex numbers -> Add complex number to real number")] + public function testOperationsBetweenRealNumbersAndComplexNumbersAddComplexNumberToRealNumber(): void + { + $realNumber = 5; + $ComplexNumber = new ComplexNumbers(1, 2); + $expected = new ComplexNumbers(6, 2); + + $this->assertEquals($expected, $ComplexNumber->addR($realNumber, $ComplexNumber)); + } + + /** + * uuid 20432c8e-8960-4c40-ba83-c9d910ff0a0f + */ + #[TestDox("Operations between real numbers and complex numbers -> Subtract real number from complex number")] + public function testOperationsBetweenRealNumbersAndComplexNumbersSubtractRealNumberFromComplexNumber(): void + { + $realNumber = 4; + $ComplexNumber = new ComplexNumbers(5, 7); + $expected = new ComplexNumbers(1, 7); + + $this->assertEquals($expected, $ComplexNumber->subR($ComplexNumber, $realNumber)); + } + + /** + * uuid b4b38c85-e1bf-437d-b04d-49bba6e55000 + */ + #[TestDox("Operations between real numbers and complex numbers -> Subtract complex number from real number")] + public function testOperationsBetweenRealNumbersAndComplexNumbersSubtractComplexNumberFromRealNumber(): void + { + $realNumber = 4; + $ComplexNumber = new ComplexNumbers(5, 7); + $expected = new ComplexNumbers(-1, -7); + + $this->assertEquals($expected, $ComplexNumber->subR($realNumber, $ComplexNumber)); + } + + /** + * uuid dabe1c8c-b8f4-44dd-879d-37d77c4d06bd + */ + #[TestDox("Operations between real numbers and complex numbers -> Multiply complex number by real number")] + public function testOperationsBetweenRealNumbersAndComplexNumbersMultiplyComplexNumberByRealNumber(): void + { + $realNumber = 5; + $ComplexNumber = new ComplexNumbers(2, 5); + $expected = new ComplexNumbers(10, 25); + + $this->assertEquals($expected, $ComplexNumber->mulR($ComplexNumber, $realNumber)); + } + + /** + * uuid 6c81b8c8-9851-46f0-9de5-d96d314c3a28 + */ + #[TestDox("Operations between real numbers and complex numbers -> Multiply real number by complex number")] + public function testOperationsBetweenRealNumbersAndComplexNumbersMultiplyRealNumberByComplexNumber(): void + { + $realNumber = 5; + $ComplexNumber = new ComplexNumbers(2, 5); + $expected = new ComplexNumbers(10, 25); + + $this->assertEquals($expected, $ComplexNumber->mulR($realNumber, $ComplexNumber)); + } + + /** + * uuid 8a400f75-710e-4d0c-bcb4-5e5a00c78aa0 + */ + #[TestDox("Operations between real numbers and complex numbers -> Divide complex number by real number")] + public function testOperationsBetweenRealNumbersAndComplexNumbersDivideComplexNumberByRealNumber(): void + { + $realNumber = 10; + $ComplexNumber = new ComplexNumbers(10, 100); + $expected = new ComplexNumbers(1, 10); + + $this->assertEquals($expected, $ComplexNumber->divR($ComplexNumber, $realNumber)); + } + + /** + * uuid 9a867d1b-d736-4c41-a41e-90bd148e9d5e + */ + #[TestDox("Operations between real numbers and complex numbers -> Divide real number by complex number")] + public function testOperationsBetweenRealNumbersAndComplexNumbersDivideRealNumberByComplexNumber(): void + { + $realNumber = 5; + $ComplexNumber = new ComplexNumbers(1, 1); + $expected = new ComplexNumbers(2.5, -2.5); + + $this->assertEquals($expected, $ComplexNumber->divR($realNumber, $ComplexNumber)); + } +} From 8089ec513101e186877408b57b665f5c69b3f865 Mon Sep 17 00:00:00 2001 From: resu-xuniL Date: Mon, 21 Sep 2026 13:30:34 +0200 Subject: [PATCH 3/6] Set the difficulty rank to `6` --- config.json | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/config.json b/config.json index 744202c8d..83f7f2865 100644 --- a/config.json +++ b/config.json @@ -1326,6 +1326,14 @@ "prerequisites": [], "difficulty": 6 }, + { + "slug": "complex-numbers", + "name": "Complex Numbers", + "uuid": "6ae0a351-0dba-4889-b0ec-ad23483cbc48", + "practices": [], + "prerequisites": [], + "difficulty": 6 + }, { "slug": "flower-field", "name": "Flower Field", @@ -1402,14 +1410,6 @@ "practices": [], "prerequisites": [], "difficulty": 7 - }, - { - "slug": "complex-numbers", - "name": "Complex Numbers", - "uuid": "6ae0a351-0dba-4889-b0ec-ad23483cbc48", - "practices": [], - "prerequisites": [], - "difficulty": 1 } ], "foregone": [ From 9511a085fe1d882ed82d9a18380f8f7991e9af8f Mon Sep 17 00:00:00 2001 From: resu-xuniL Date: Mon, 21 Sep 2026 13:31:42 +0200 Subject: [PATCH 4/6] Add GitHub handle to `config.json` --- exercises/practice/complex-numbers/.meta/config.json | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/exercises/practice/complex-numbers/.meta/config.json b/exercises/practice/complex-numbers/.meta/config.json index 65f177c70..c65324b4b 100644 --- a/exercises/practice/complex-numbers/.meta/config.json +++ b/exercises/practice/complex-numbers/.meta/config.json @@ -1,5 +1,7 @@ { - "authors": [], + "authors": [ + "resu-xuniL" + ], "files": { "solution": [ "ComplexNumbers.php" From c6f1290eac26c355d03a2fded71f683a48efd213 Mon Sep 17 00:00:00 2001 From: resu-xuniL Date: Fri, 25 Sep 2026 11:49:21 +0200 Subject: [PATCH 5/6] remove *R functions --- .../complex-numbers/.meta/example.php | 42 ------------------- .../complex-numbers/ComplexNumbersTest.php | 32 +++++++------- 2 files changed, 16 insertions(+), 58 deletions(-) diff --git a/exercises/practice/complex-numbers/.meta/example.php b/exercises/practice/complex-numbers/.meta/example.php index 757b901d0..19a34f3da 100644 --- a/exercises/practice/complex-numbers/.meta/example.php +++ b/exercises/practice/complex-numbers/.meta/example.php @@ -16,16 +16,6 @@ public function add(ComplexNumbers $num2): ComplexNumbers ); } - public function addR(int|ComplexNumbers $num1, int|ComplexNumbers $num2): ComplexNumbers - { - is_int($num1) ? $num1 = new ComplexNumbers($num1) : $num2 = new ComplexNumbers($num2); - - return new ComplexNumbers( - $num1->real + $num2->real, - $num1->imaginary + $num2->imaginary - ); - } - public function sub(ComplexNumbers $num2): ComplexNumbers { return new ComplexNumbers( @@ -34,16 +24,6 @@ public function sub(ComplexNumbers $num2): ComplexNumbers ); } - public function subR(int|ComplexNumbers $num1, int|ComplexNumbers $num2): ComplexNumbers - { - is_int($num1) ? $num1 = new ComplexNumbers($num1) : $num2 = new ComplexNumbers($num2); - - return new ComplexNumbers( - $num1->real - $num2->real, - $num1->imaginary - $num2->imaginary - ); - } - public function mul(ComplexNumbers $num2): ComplexNumbers { return new ComplexNumbers( @@ -52,16 +32,6 @@ public function mul(ComplexNumbers $num2): ComplexNumbers ); } - public function mulR(int|ComplexNumbers $num1, int|ComplexNumbers $num2): ComplexNumbers - { - is_int($num1) ? $num1 = new ComplexNumbers($num1) : $num2 = new ComplexNumbers($num2); - - return new ComplexNumbers( - $num1->real * $num2->real - $num1->imaginary * $num2->imaginary, - $num1->imaginary * $num2->real + $num1->real * $num2->imaginary - ); - } - public function div(ComplexNumbers $num2): ComplexNumbers { return new ComplexNumbers( @@ -72,18 +42,6 @@ public function div(ComplexNumbers $num2): ComplexNumbers ); } - public function divR(int|ComplexNumbers $num1, int|ComplexNumbers $num2): ComplexNumbers - { - is_int($num1) ? $num1 = new ComplexNumbers($num1) : $num2 = new ComplexNumbers($num2); - - return new ComplexNumbers( - ($num1->real * $num2->real + $num1->imaginary * $num2->imaginary) / - (pow($num2->real, 2) + pow($num2->imaginary, 2)), - ($num1->imaginary * $num2->real - $num1->real * $num2->imaginary) / - (pow($num2->real, 2) + pow($num2->imaginary, 2)) - ); - } - public function abs(): float { return hypot($this->real, $this->imaginary); diff --git a/exercises/practice/complex-numbers/ComplexNumbersTest.php b/exercises/practice/complex-numbers/ComplexNumbersTest.php index 90db76465..46126dc54 100644 --- a/exercises/practice/complex-numbers/ComplexNumbersTest.php +++ b/exercises/practice/complex-numbers/ComplexNumbersTest.php @@ -416,11 +416,11 @@ public function testComplexExponentialFunctionExponentialResultingInANumberWithR #[TestDox("Operations between real numbers and complex numbers -> Add real number to complex number")] public function testOperationsBetweenRealNumbersAndComplexNumbersAddRealNumberToComplexNumber(): void { - $realNumber = 5; + $realNumber = new ComplexNumbers(5); $ComplexNumber = new ComplexNumbers(1, 2); $expected = new ComplexNumbers(6, 2); - $this->assertEquals($expected, $ComplexNumber->addR($ComplexNumber, $realNumber)); + $this->assertEquals($expected, $ComplexNumber->add($realNumber)); } /** @@ -429,11 +429,11 @@ public function testOperationsBetweenRealNumbersAndComplexNumbersAddRealNumberTo #[TestDox("Operations between real numbers and complex numbers -> Add complex number to real number")] public function testOperationsBetweenRealNumbersAndComplexNumbersAddComplexNumberToRealNumber(): void { - $realNumber = 5; + $realNumber = new ComplexNumbers(5); $ComplexNumber = new ComplexNumbers(1, 2); $expected = new ComplexNumbers(6, 2); - $this->assertEquals($expected, $ComplexNumber->addR($realNumber, $ComplexNumber)); + $this->assertEquals($expected, $realNumber->add($ComplexNumber)); } /** @@ -442,11 +442,11 @@ public function testOperationsBetweenRealNumbersAndComplexNumbersAddComplexNumbe #[TestDox("Operations between real numbers and complex numbers -> Subtract real number from complex number")] public function testOperationsBetweenRealNumbersAndComplexNumbersSubtractRealNumberFromComplexNumber(): void { - $realNumber = 4; + $realNumber = new ComplexNumbers(4); $ComplexNumber = new ComplexNumbers(5, 7); $expected = new ComplexNumbers(1, 7); - $this->assertEquals($expected, $ComplexNumber->subR($ComplexNumber, $realNumber)); + $this->assertEquals($expected, $ComplexNumber->sub($realNumber)); } /** @@ -455,11 +455,11 @@ public function testOperationsBetweenRealNumbersAndComplexNumbersSubtractRealNum #[TestDox("Operations between real numbers and complex numbers -> Subtract complex number from real number")] public function testOperationsBetweenRealNumbersAndComplexNumbersSubtractComplexNumberFromRealNumber(): void { - $realNumber = 4; + $realNumber = new ComplexNumbers(4); $ComplexNumber = new ComplexNumbers(5, 7); $expected = new ComplexNumbers(-1, -7); - $this->assertEquals($expected, $ComplexNumber->subR($realNumber, $ComplexNumber)); + $this->assertEquals($expected, $realNumber->sub($ComplexNumber)); } /** @@ -468,11 +468,11 @@ public function testOperationsBetweenRealNumbersAndComplexNumbersSubtractComplex #[TestDox("Operations between real numbers and complex numbers -> Multiply complex number by real number")] public function testOperationsBetweenRealNumbersAndComplexNumbersMultiplyComplexNumberByRealNumber(): void { - $realNumber = 5; + $realNumber = new ComplexNumbers(5); $ComplexNumber = new ComplexNumbers(2, 5); $expected = new ComplexNumbers(10, 25); - $this->assertEquals($expected, $ComplexNumber->mulR($ComplexNumber, $realNumber)); + $this->assertEquals($expected, $ComplexNumber->mul($realNumber)); } /** @@ -481,11 +481,11 @@ public function testOperationsBetweenRealNumbersAndComplexNumbersMultiplyComplex #[TestDox("Operations between real numbers and complex numbers -> Multiply real number by complex number")] public function testOperationsBetweenRealNumbersAndComplexNumbersMultiplyRealNumberByComplexNumber(): void { - $realNumber = 5; + $realNumber = new ComplexNumbers(5); $ComplexNumber = new ComplexNumbers(2, 5); $expected = new ComplexNumbers(10, 25); - $this->assertEquals($expected, $ComplexNumber->mulR($realNumber, $ComplexNumber)); + $this->assertEquals($expected, $realNumber->mul($ComplexNumber)); } /** @@ -494,11 +494,11 @@ public function testOperationsBetweenRealNumbersAndComplexNumbersMultiplyRealNum #[TestDox("Operations between real numbers and complex numbers -> Divide complex number by real number")] public function testOperationsBetweenRealNumbersAndComplexNumbersDivideComplexNumberByRealNumber(): void { - $realNumber = 10; + $realNumber = new ComplexNumbers(10); $ComplexNumber = new ComplexNumbers(10, 100); $expected = new ComplexNumbers(1, 10); - $this->assertEquals($expected, $ComplexNumber->divR($ComplexNumber, $realNumber)); + $this->assertEquals($expected, $ComplexNumber->div($realNumber)); } /** @@ -507,10 +507,10 @@ public function testOperationsBetweenRealNumbersAndComplexNumbersDivideComplexNu #[TestDox("Operations between real numbers and complex numbers -> Divide real number by complex number")] public function testOperationsBetweenRealNumbersAndComplexNumbersDivideRealNumberByComplexNumber(): void { - $realNumber = 5; + $realNumber = new ComplexNumbers(5); $ComplexNumber = new ComplexNumbers(1, 1); $expected = new ComplexNumbers(2.5, -2.5); - $this->assertEquals($expected, $ComplexNumber->divR($realNumber, $ComplexNumber)); + $this->assertEquals($expected, $realNumber->div($ComplexNumber)); } } From 25d627207e538d71123fc8919b1f52b4fe59f5ef Mon Sep 17 00:00:00 2001 From: resu-xuniL Date: Fri, 25 Sep 2026 11:51:13 +0200 Subject: [PATCH 6/6] cosmetic code changes --- .../complex-numbers/ComplexNumbersTest.php | 260 +++++++++--------- 1 file changed, 130 insertions(+), 130 deletions(-) diff --git a/exercises/practice/complex-numbers/ComplexNumbersTest.php b/exercises/practice/complex-numbers/ComplexNumbersTest.php index 46126dc54..d62c24d10 100644 --- a/exercises/practice/complex-numbers/ComplexNumbersTest.php +++ b/exercises/practice/complex-numbers/ComplexNumbersTest.php @@ -18,10 +18,10 @@ public static function setUpBeforeClass(): void #[TestDox('Real part -> Real part of a purely real number')] public function testRealPartRealPartOfAPurelyRealNumber(): void { - $ComplexNumber = new ComplexNumbers(1, 0); + $complexNumber = new ComplexNumbers(1, 0); $expected = 1; - $this->assertEquals($expected, $ComplexNumber->real); + $this->assertEquals($expected, $complexNumber->real); } /** @@ -30,10 +30,10 @@ public function testRealPartRealPartOfAPurelyRealNumber(): void #[TestDox('Real part -> Real part of a purely imaginary number')] public function testRealPartRealPartOfAPurelyImaginaryNumber(): void { - $ComplexNumber = new ComplexNumbers(0, 1); + $complexNumber = new ComplexNumbers(0, 1); $expected = 0; - $this->assertEquals($expected, $ComplexNumber->real); + $this->assertEquals($expected, $complexNumber->real); } /** @@ -42,10 +42,10 @@ public function testRealPartRealPartOfAPurelyImaginaryNumber(): void #[TestDox('Real part -> Real part of a number with real and imaginary part')] public function testRealPartRealPartOfANumberWithRealAndImaginaryPart(): void { - $ComplexNumber = new ComplexNumbers(1, 2); + $complexNumber = new ComplexNumbers(1, 2); $expected = 1; - $this->assertEquals($expected, $ComplexNumber->real); + $this->assertEquals($expected, $complexNumber->real); } /** @@ -54,10 +54,10 @@ public function testRealPartRealPartOfANumberWithRealAndImaginaryPart(): void #[TestDox('Imaginary part -> Imaginary part of a purely real number')] public function testImaginaryPartImaginaryPartOfAPurelyRealNumber(): void { - $ComplexNumber = new ComplexNumbers(1, 0); + $complexNumber = new ComplexNumbers(1, 0); $expected = 0; - $this->assertEquals($expected, $ComplexNumber->imaginary); + $this->assertEquals($expected, $complexNumber->imaginary); } /** @@ -66,10 +66,10 @@ public function testImaginaryPartImaginaryPartOfAPurelyRealNumber(): void #[TestDox('Imaginary part -> Imaginary part of a purely imaginary number')] public function testImaginaryPartImaginaryPartOfAPurelyImaginaryNumber(): void { - $ComplexNumber = new ComplexNumbers(0, 1); + $complexNumber = new ComplexNumbers(0, 1); $expected = 1; - $this->assertEquals($expected, $ComplexNumber->imaginary); + $this->assertEquals($expected, $complexNumber->imaginary); } /** @@ -78,10 +78,10 @@ public function testImaginaryPartImaginaryPartOfAPurelyImaginaryNumber(): void #[TestDox('Imaginary part -> Imaginary part of a number with real and imaginary part')] public function testImaginaryPartImaginaryPartOfANumberWithRealAndImaginaryPart(): void { - $ComplexNumber = new ComplexNumbers(1, 2); + $complexNumber = new ComplexNumbers(1, 2); $expected = 2; - $this->assertEquals($expected, $ComplexNumber->imaginary); + $this->assertEquals($expected, $complexNumber->imaginary); } /** @@ -90,11 +90,11 @@ public function testImaginaryPartImaginaryPartOfANumberWithRealAndImaginaryPart( #[TestDox('Imaginary unit')] public function testImaginaryUnit(): void { - $ComplexNumber1 = new ComplexNumbers(0, 1); - $ComplexNumber2 = new ComplexNumbers(0, 1); - $expected = new ComplexNumbers(-1, 0); + $complexNumber1 = new ComplexNumbers(0, 1); + $complexNumber2 = new ComplexNumbers(0, 1); + $expected = new ComplexNumbers(-1, 0); - $this->assertEquals($expected, $ComplexNumber1->mul($ComplexNumber2)); + $this->assertEquals($expected, $complexNumber1->mul($complexNumber2)); } /** @@ -103,11 +103,11 @@ public function testImaginaryUnit(): void #[TestDox('Arithmetic -> Addition -> Add purely real numbers')] public function testArithmeticAdditionAddPurelyRealNumbers(): void { - $ComplexNumber1 = new ComplexNumbers(1, 0); - $ComplexNumber2 = new ComplexNumbers(2, 0); - $expected = new ComplexNumbers(3, 0); + $complexNumber1 = new ComplexNumbers(1, 0); + $complexNumber2 = new ComplexNumbers(2, 0); + $expected = new ComplexNumbers(3, 0); - $this->assertEquals($expected, $ComplexNumber1->add($ComplexNumber2)); + $this->assertEquals($expected, $complexNumber1->add($complexNumber2)); } /** @@ -116,11 +116,11 @@ public function testArithmeticAdditionAddPurelyRealNumbers(): void #[TestDox('Arithmetic -> Addition -> Add purely imaginary numbers')] public function testArithmeticAdditionAddPurelyImaginaryNumbers(): void { - $ComplexNumber1 = new ComplexNumbers(0, 1); - $ComplexNumber2 = new ComplexNumbers(0, 2); - $expected = new ComplexNumbers(0, 3); + $complexNumber1 = new ComplexNumbers(0, 1); + $complexNumber2 = new ComplexNumbers(0, 2); + $expected = new ComplexNumbers(0, 3); - $this->assertEquals($expected, $ComplexNumber1->add($ComplexNumber2)); + $this->assertEquals($expected, $complexNumber1->add($complexNumber2)); } /** @@ -129,11 +129,11 @@ public function testArithmeticAdditionAddPurelyImaginaryNumbers(): void #[TestDox('Arithmetic -> Addition -> Add numbers with real and imaginary part')] public function testArithmeticAdditionAddNumbersWithRealAndImaginaryPart(): void { - $ComplexNumber1 = new ComplexNumbers(1, 2); - $ComplexNumber2 = new ComplexNumbers(3, 4); - $expected = new ComplexNumbers(4, 6); + $complexNumber1 = new ComplexNumbers(1, 2); + $complexNumber2 = new ComplexNumbers(3, 4); + $expected = new ComplexNumbers(4, 6); - $this->assertEquals($expected, $ComplexNumber1->add($ComplexNumber2)); + $this->assertEquals($expected, $complexNumber1->add($complexNumber2)); } /** @@ -142,11 +142,11 @@ public function testArithmeticAdditionAddNumbersWithRealAndImaginaryPart(): void #[TestDox('Arithmetic -> Subtraction -> Subtract purely real numbers')] public function testArithmeticSubtractionSubtractPurelyRealNumbers(): void { - $ComplexNumber1 = new ComplexNumbers(1, 0); - $ComplexNumber2 = new ComplexNumbers(2, 0); - $expected = new ComplexNumbers(-1, 0); + $complexNumber1 = new ComplexNumbers(1, 0); + $complexNumber2 = new ComplexNumbers(2, 0); + $expected = new ComplexNumbers(-1, 0); - $this->assertEquals($expected, $ComplexNumber1->sub($ComplexNumber2)); + $this->assertEquals($expected, $complexNumber1->sub($complexNumber2)); } /** @@ -155,11 +155,11 @@ public function testArithmeticSubtractionSubtractPurelyRealNumbers(): void #[TestDox('Arithmetic -> Subtraction -> Subtract purely imaginary numbers')] public function testArithmeticSubtractionSubtractPurelyImaginaryNumbers(): void { - $ComplexNumber1 = new ComplexNumbers(0, 1); - $ComplexNumber2 = new ComplexNumbers(0, 2); - $expected = new ComplexNumbers(0, -1); + $complexNumber1 = new ComplexNumbers(0, 1); + $complexNumber2 = new ComplexNumbers(0, 2); + $expected = new ComplexNumbers(0, -1); - $this->assertEquals($expected, $ComplexNumber1->sub($ComplexNumber2)); + $this->assertEquals($expected, $complexNumber1->sub($complexNumber2)); } /** @@ -168,11 +168,11 @@ public function testArithmeticSubtractionSubtractPurelyImaginaryNumbers(): void #[TestDox('Arithmetic -> Subtraction -> Subtract numbers with real and imaginary part')] public function testArithmeticSubtractionSubtractNumbersWithRealAndImaginaryPart(): void { - $ComplexNumber1 = new ComplexNumbers(1, 2); - $ComplexNumber2 = new ComplexNumbers(3, 4); - $expected = new ComplexNumbers(-2, -2); + $complexNumber1 = new ComplexNumbers(1, 2); + $complexNumber2 = new ComplexNumbers(3, 4); + $expected = new ComplexNumbers(-2, -2); - $this->assertEquals($expected, $ComplexNumber1->sub($ComplexNumber2)); + $this->assertEquals($expected, $complexNumber1->sub($complexNumber2)); } /** @@ -181,11 +181,11 @@ public function testArithmeticSubtractionSubtractNumbersWithRealAndImaginaryPart #[TestDox('Arithmetic -> Multiplication -> Multiply purely real numbers')] public function testArithmeticMultiplicationMultiplyPurelyRealNumbers(): void { - $ComplexNumber1 = new ComplexNumbers(1, 0); - $ComplexNumber2 = new ComplexNumbers(2, 0); - $expected = new ComplexNumbers(2, 0); + $complexNumber1 = new ComplexNumbers(1, 0); + $complexNumber2 = new ComplexNumbers(2, 0); + $expected = new ComplexNumbers(2, 0); - $this->assertEquals($expected, $ComplexNumber1->mul($ComplexNumber2)); + $this->assertEquals($expected, $complexNumber1->mul($complexNumber2)); } /** @@ -194,11 +194,11 @@ public function testArithmeticMultiplicationMultiplyPurelyRealNumbers(): void #[TestDox('Arithmetic -> Multiplication -> Multiply purely imaginary numbers')] public function testArithmeticMultiplicationMultiplyPurelyImaginaryNumbers(): void { - $ComplexNumber1 = new ComplexNumbers(0, 1); - $ComplexNumber2 = new ComplexNumbers(0, 2); - $expected = new ComplexNumbers(-2, 0); + $complexNumber1 = new ComplexNumbers(0, 1); + $complexNumber2 = new ComplexNumbers(0, 2); + $expected = new ComplexNumbers(-2, 0); - $this->assertEquals($expected, $ComplexNumber1->mul($ComplexNumber2)); + $this->assertEquals($expected, $complexNumber1->mul($complexNumber2)); } /** @@ -207,11 +207,11 @@ public function testArithmeticMultiplicationMultiplyPurelyImaginaryNumbers(): vo #[TestDox('Arithmetic -> Multiplication -> Multiply numbers with real and imaginary part')] public function testArithmeticMultiplicationMultiplyNumbersWithRealAndImaginaryPart(): void { - $ComplexNumber1 = new ComplexNumbers(1, 2); - $ComplexNumber2 = new ComplexNumbers(3, 4); - $expected = new ComplexNumbers(-5, 10); + $complexNumber1 = new ComplexNumbers(1, 2); + $complexNumber2 = new ComplexNumbers(3, 4); + $expected = new ComplexNumbers(-5, 10); - $this->assertEquals($expected, $ComplexNumber1->mul($ComplexNumber2)); + $this->assertEquals($expected, $complexNumber1->mul($complexNumber2)); } /** @@ -220,11 +220,11 @@ public function testArithmeticMultiplicationMultiplyNumbersWithRealAndImaginaryP #[TestDox('Arithmetic -> Division -> Divide purely real numbers')] public function testArithmeticDivisionDividePurelyRealNumbers(): void { - $ComplexNumber1 = new ComplexNumbers(1, 0); - $ComplexNumber2 = new ComplexNumbers(2, 0); - $expected = new ComplexNumbers(0.5, 0); + $complexNumber1 = new ComplexNumbers(1, 0); + $complexNumber2 = new ComplexNumbers(2, 0); + $expected = new ComplexNumbers(0.5, 0); - $this->assertEquals($expected, $ComplexNumber1->div($ComplexNumber2)); + $this->assertEquals($expected, $complexNumber1->div($complexNumber2)); } /** @@ -233,11 +233,11 @@ public function testArithmeticDivisionDividePurelyRealNumbers(): void #[TestDox('Arithmetic -> Arithmetic -> Division -> Divide purely imaginary numbers')] public function testArithmeticDivisionDividePurelyImaginaryNumbers(): void { - $ComplexNumber1 = new ComplexNumbers(0, 1); - $ComplexNumber2 = new ComplexNumbers(0, 2); - $expected = new ComplexNumbers(0.5, 0); + $complexNumber1 = new ComplexNumbers(0, 1); + $complexNumber2 = new ComplexNumbers(0, 2); + $expected = new ComplexNumbers(0.5, 0); - $this->assertEquals($expected, $ComplexNumber1->div($ComplexNumber2)); + $this->assertEquals($expected, $complexNumber1->div($complexNumber2)); } /** @@ -246,11 +246,11 @@ public function testArithmeticDivisionDividePurelyImaginaryNumbers(): void #[TestDox('Arithmetic -> Division -> Divide numbers with real and imaginary part')] public function testArithmeticDivisionDivideNumbersWithRealAndImaginaryPart(): void { - $ComplexNumber1 = new ComplexNumbers(1, 2); - $ComplexNumber2 = new ComplexNumbers(3, 4); - $expected = new ComplexNumbers(0.44, 0.08); + $complexNumber1 = new ComplexNumbers(1, 2); + $complexNumber2 = new ComplexNumbers(3, 4); + $expected = new ComplexNumbers(0.44, 0.08); - $this->assertEquals($expected, $ComplexNumber1->div($ComplexNumber2)); + $this->assertEquals($expected, $complexNumber1->div($complexNumber2)); } @@ -260,10 +260,10 @@ public function testArithmeticDivisionDivideNumbersWithRealAndImaginaryPart(): v #[TestDox('Absolute value -> Absolute value of a positive purely real number')] public function testAbsoluteValueAbsoluteValueOfAPositivePurelyRealNumber(): void { - $ComplexNumber = new ComplexNumbers(5, 0); + $complexNumber = new ComplexNumbers(5, 0); $expected = 5; - $this->assertEquals($expected, $ComplexNumber->abs()); + $this->assertEquals($expected, $complexNumber->abs()); } /** @@ -272,10 +272,10 @@ public function testAbsoluteValueAbsoluteValueOfAPositivePurelyRealNumber(): voi #[TestDox('Absolute value -> Absolute value of a negative purely real number')] public function testAbsoluteValueAbsoluteValueOfANegativePurelyRealNumber(): void { - $ComplexNumber = new ComplexNumbers(-5, 0); + $complexNumber = new ComplexNumbers(-5, 0); $expected = 5; - $this->assertEquals($expected, $ComplexNumber->abs()); + $this->assertEquals($expected, $complexNumber->abs()); } /** @@ -284,10 +284,10 @@ public function testAbsoluteValueAbsoluteValueOfANegativePurelyRealNumber(): voi #[TestDox('Absolute value -> Absolute value of a purely imaginary number with positive imaginary part')] public function testAbsoluteValueAbsoluteValueOfAPurelyImaginaryNumberWithPositiveImaginaryPart(): void { - $ComplexNumber = new ComplexNumbers(0, 5); + $complexNumber = new ComplexNumbers(0, 5); $expected = 5; - $this->assertEquals($expected, $ComplexNumber->abs()); + $this->assertEquals($expected, $complexNumber->abs()); } /** @@ -296,10 +296,10 @@ public function testAbsoluteValueAbsoluteValueOfAPurelyImaginaryNumberWithPositi #[TestDox('Absolute value -> Absolute value of a purely imaginary number with negative imaginary part')] public function testAbsoluteValueAbsoluteValueOfAPurelyImaginaryNumberWithNegativeImaginaryPart(): void { - $ComplexNumber = new ComplexNumbers(0, -5); + $complexNumber = new ComplexNumbers(0, -5); $expected = 5; - $this->assertEquals($expected, $ComplexNumber->abs()); + $this->assertEquals($expected, $complexNumber->abs()); } /** @@ -308,10 +308,10 @@ public function testAbsoluteValueAbsoluteValueOfAPurelyImaginaryNumberWithNegati #[TestDox('Absolute value -> Absolute value of a number with real and imaginary part')] public function testAbsoluteValueAbsoluteValueOfANumberWithRealAndImaginaryPart(): void { - $ComplexNumber = new ComplexNumbers(3, 4); + $complexNumber = new ComplexNumbers(3, 4); $expected = 5; - $this->assertEquals($expected, $ComplexNumber->abs()); + $this->assertEquals($expected, $complexNumber->abs()); } /** @@ -320,10 +320,10 @@ public function testAbsoluteValueAbsoluteValueOfANumberWithRealAndImaginaryPart( #[TestDox('Complex conjugate -> Conjugate a purely real number')] public function testComplexConjugateConjugateAPurelyRealNumber(): void { - $ComplexNumber = new ComplexNumbers(5, 0); - $expected = new ComplexNumbers(5, 0); + $complexNumber = new ComplexNumbers(5, 0); + $expected = new ComplexNumbers(5, 0); - $this->assertEquals($expected, $ComplexNumber->conjugate()); + $this->assertEquals($expected, $complexNumber->conjugate()); } /** @@ -332,10 +332,10 @@ public function testComplexConjugateConjugateAPurelyRealNumber(): void #[TestDox('Complex conjugate -> Conjugate a purely imaginary number')] public function testComplexConjugateConjugateAPurelyImaginaryNumber(): void { - $ComplexNumber = new ComplexNumbers(0, 5); - $expected = new ComplexNumbers(0, -5); + $complexNumber = new ComplexNumbers(0, 5); + $expected = new ComplexNumbers(0, -5); - $this->assertEquals($expected, $ComplexNumber->conjugate()); + $this->assertEquals($expected, $complexNumber->conjugate()); } /** @@ -344,10 +344,10 @@ public function testComplexConjugateConjugateAPurelyImaginaryNumber(): void #[TestDox('Complex conjugate -> Conjugate a number with real and imaginary part')] public function testComplexConjugateConjugateANumberWithRealAndImaginaryPart(): void { - $ComplexNumber = new ComplexNumbers(1, 1); - $expected = new ComplexNumbers(1, -1); + $complexNumber = new ComplexNumbers(1, 1); + $expected = new ComplexNumbers(1, -1); - $this->assertEquals($expected, $ComplexNumber->conjugate()); + $this->assertEquals($expected, $complexNumber->conjugate()); } /** @@ -356,10 +356,10 @@ public function testComplexConjugateConjugateANumberWithRealAndImaginaryPart(): #[TestDox("Complex exponential function -> Euler's identity/formula")] public function testComplexExponentialFunctionEulersIdentityFormula(): void { - $ComplexNumber = new ComplexNumbers(0, M_PI); - $expected = new ComplexNumbers(-1, 0); + $complexNumber = new ComplexNumbers(0, M_PI); + $expected = new ComplexNumbers(-1, 0); - $this->assertEqualsWithDelta($expected, $ComplexNumber->exp(), 1e-10); + $this->assertEqualsWithDelta($expected, $complexNumber->exp(), 1e-10); } /** @@ -368,10 +368,10 @@ public function testComplexExponentialFunctionEulersIdentityFormula(): void #[TestDox("Complex exponential function -> Exponential of 0")] public function testComplexExponentialFunctionExponentialOf0(): void { - $ComplexNumber = new ComplexNumbers(0, 0); - $expected = new ComplexNumbers(1, 0); + $complexNumber = new ComplexNumbers(0, 0); + $expected = new ComplexNumbers(1, 0); - $this->assertEquals($expected, $ComplexNumber->exp()); + $this->assertEquals($expected, $complexNumber->exp()); } /** @@ -380,10 +380,10 @@ public function testComplexExponentialFunctionExponentialOf0(): void #[TestDox("Complex exponential function -> Exponential of a purely real number")] public function testComplexExponentialFunctionExponentialOfAPurelyRealNumber(): void { - $ComplexNumber = new ComplexNumbers(1, 0); - $expected = new ComplexNumbers(M_E, 0); + $complexNumber = new ComplexNumbers(1, 0); + $expected = new ComplexNumbers(M_E, 0); - $this->assertEquals($expected, $ComplexNumber->exp()); + $this->assertEquals($expected, $complexNumber->exp()); } /** @@ -392,10 +392,10 @@ public function testComplexExponentialFunctionExponentialOfAPurelyRealNumber(): #[TestDox("Complex exponential function -> Exponential of a number with real and imaginary part")] public function testComplexExponentialFunctionExponentialOfANumberWithRealAndImaginaryPart(): void { - $ComplexNumber = new ComplexNumbers(M_LN2, M_PI); - $expected = new ComplexNumbers(-2, 0); + $complexNumber = new ComplexNumbers(M_LN2, M_PI); + $expected = new ComplexNumbers(-2, 0); - $this->assertEqualsWithDelta($expected, $ComplexNumber->exp(), 1e-10); + $this->assertEqualsWithDelta($expected, $complexNumber->exp(), 1e-10); } /** @@ -404,10 +404,10 @@ public function testComplexExponentialFunctionExponentialOfANumberWithRealAndIma #[TestDox("Complex exponential function -> Exponential resulting in a number with real and imaginary part")] public function testComplexExponentialFunctionExponentialResultingInANumberWithRealAndImaginaryPart(): void { - $ComplexNumber = new ComplexNumbers(M_LN2 / 2, M_PI_4); - $expected = new ComplexNumbers(1, 1); + $complexNumber = new ComplexNumbers(M_LN2 / 2, M_PI_4); + $expected = new ComplexNumbers(1, 1); - $this->assertEqualsWithDelta($expected, $ComplexNumber->exp(), 1e-10); + $this->assertEqualsWithDelta($expected, $complexNumber->exp(), 1e-10); } /** @@ -416,11 +416,11 @@ public function testComplexExponentialFunctionExponentialResultingInANumberWithR #[TestDox("Operations between real numbers and complex numbers -> Add real number to complex number")] public function testOperationsBetweenRealNumbersAndComplexNumbersAddRealNumberToComplexNumber(): void { - $realNumber = new ComplexNumbers(5); - $ComplexNumber = new ComplexNumbers(1, 2); - $expected = new ComplexNumbers(6, 2); + $realNumber = new ComplexNumbers(5); + $complexNumber = new ComplexNumbers(1, 2); + $expected = new ComplexNumbers(6, 2); - $this->assertEquals($expected, $ComplexNumber->add($realNumber)); + $this->assertEquals($expected, $complexNumber->add($realNumber)); } /** @@ -429,11 +429,11 @@ public function testOperationsBetweenRealNumbersAndComplexNumbersAddRealNumberTo #[TestDox("Operations between real numbers and complex numbers -> Add complex number to real number")] public function testOperationsBetweenRealNumbersAndComplexNumbersAddComplexNumberToRealNumber(): void { - $realNumber = new ComplexNumbers(5); - $ComplexNumber = new ComplexNumbers(1, 2); - $expected = new ComplexNumbers(6, 2); + $realNumber = new ComplexNumbers(5); + $complexNumber = new ComplexNumbers(1, 2); + $expected = new ComplexNumbers(6, 2); - $this->assertEquals($expected, $realNumber->add($ComplexNumber)); + $this->assertEquals($expected, $realNumber->add($complexNumber)); } /** @@ -442,11 +442,11 @@ public function testOperationsBetweenRealNumbersAndComplexNumbersAddComplexNumbe #[TestDox("Operations between real numbers and complex numbers -> Subtract real number from complex number")] public function testOperationsBetweenRealNumbersAndComplexNumbersSubtractRealNumberFromComplexNumber(): void { - $realNumber = new ComplexNumbers(4); - $ComplexNumber = new ComplexNumbers(5, 7); - $expected = new ComplexNumbers(1, 7); + $realNumber = new ComplexNumbers(4); + $complexNumber = new ComplexNumbers(5, 7); + $expected = new ComplexNumbers(1, 7); - $this->assertEquals($expected, $ComplexNumber->sub($realNumber)); + $this->assertEquals($expected, $complexNumber->sub($realNumber)); } /** @@ -455,11 +455,11 @@ public function testOperationsBetweenRealNumbersAndComplexNumbersSubtractRealNum #[TestDox("Operations between real numbers and complex numbers -> Subtract complex number from real number")] public function testOperationsBetweenRealNumbersAndComplexNumbersSubtractComplexNumberFromRealNumber(): void { - $realNumber = new ComplexNumbers(4); - $ComplexNumber = new ComplexNumbers(5, 7); - $expected = new ComplexNumbers(-1, -7); + $realNumber = new ComplexNumbers(4); + $complexNumber = new ComplexNumbers(5, 7); + $expected = new ComplexNumbers(-1, -7); - $this->assertEquals($expected, $realNumber->sub($ComplexNumber)); + $this->assertEquals($expected, $realNumber->sub($complexNumber)); } /** @@ -468,11 +468,11 @@ public function testOperationsBetweenRealNumbersAndComplexNumbersSubtractComplex #[TestDox("Operations between real numbers and complex numbers -> Multiply complex number by real number")] public function testOperationsBetweenRealNumbersAndComplexNumbersMultiplyComplexNumberByRealNumber(): void { - $realNumber = new ComplexNumbers(5); - $ComplexNumber = new ComplexNumbers(2, 5); - $expected = new ComplexNumbers(10, 25); + $realNumber = new ComplexNumbers(5); + $complexNumber = new ComplexNumbers(2, 5); + $expected = new ComplexNumbers(10, 25); - $this->assertEquals($expected, $ComplexNumber->mul($realNumber)); + $this->assertEquals($expected, $complexNumber->mul($realNumber)); } /** @@ -481,11 +481,11 @@ public function testOperationsBetweenRealNumbersAndComplexNumbersMultiplyComplex #[TestDox("Operations between real numbers and complex numbers -> Multiply real number by complex number")] public function testOperationsBetweenRealNumbersAndComplexNumbersMultiplyRealNumberByComplexNumber(): void { - $realNumber = new ComplexNumbers(5); - $ComplexNumber = new ComplexNumbers(2, 5); - $expected = new ComplexNumbers(10, 25); + $realNumber = new ComplexNumbers(5); + $complexNumber = new ComplexNumbers(2, 5); + $expected = new ComplexNumbers(10, 25); - $this->assertEquals($expected, $realNumber->mul($ComplexNumber)); + $this->assertEquals($expected, $realNumber->mul($complexNumber)); } /** @@ -494,11 +494,11 @@ public function testOperationsBetweenRealNumbersAndComplexNumbersMultiplyRealNum #[TestDox("Operations between real numbers and complex numbers -> Divide complex number by real number")] public function testOperationsBetweenRealNumbersAndComplexNumbersDivideComplexNumberByRealNumber(): void { - $realNumber = new ComplexNumbers(10); - $ComplexNumber = new ComplexNumbers(10, 100); - $expected = new ComplexNumbers(1, 10); + $realNumber = new ComplexNumbers(10); + $complexNumber = new ComplexNumbers(10, 100); + $expected = new ComplexNumbers(1, 10); - $this->assertEquals($expected, $ComplexNumber->div($realNumber)); + $this->assertEquals($expected, $complexNumber->div($realNumber)); } /** @@ -507,10 +507,10 @@ public function testOperationsBetweenRealNumbersAndComplexNumbersDivideComplexNu #[TestDox("Operations between real numbers and complex numbers -> Divide real number by complex number")] public function testOperationsBetweenRealNumbersAndComplexNumbersDivideRealNumberByComplexNumber(): void { - $realNumber = new ComplexNumbers(5); - $ComplexNumber = new ComplexNumbers(1, 1); - $expected = new ComplexNumbers(2.5, -2.5); + $realNumber = new ComplexNumbers(5); + $complexNumber = new ComplexNumbers(1, 1); + $expected = new ComplexNumbers(2.5, -2.5); - $this->assertEquals($expected, $realNumber->div($ComplexNumber)); + $this->assertEquals($expected, $realNumber->div($complexNumber)); } }