Changed method names to make more idiomatic (#2317) (#2501)

Author: Wasy18

exercises/practice/complex-numbers/.meta/config.json

@@ -13,7 +13,8 @@
     "muzimuzhi",
     "SleeplessByte",
     "Smarticles101",
-    "sshine"
+    "sshine",
+    "Wasy18"
   ],
   "files": {
     "solution": [

exercises/practice/complex-numbers/.meta/src/reference/java/ComplexNumber.java

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

exercises/practice/complex-numbers/src/main/java/ComplexNumber.java

@@ -1,14 +1,14 @@
 class ComplexNumber {
 
-    ComplexNumber(double real, double imag) {
+    ComplexNumber(double real, double imaginary) {
         throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
     }
 
     double getReal() {
         throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
     }
 
-    double getImag() {
+    double getImaginary() {
         throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
     }
 
@@ -20,23 +20,23 @@ ComplexNumber add(ComplexNumber other) {
         throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
     }
 
-    ComplexNumber minus(ComplexNumber other) {
+    ComplexNumber subtract(ComplexNumber other) {
         throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
     }
 
-    ComplexNumber times(ComplexNumber other) {
+    ComplexNumber multiply(ComplexNumber other) {
         throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
     }
 
-    ComplexNumber times(double factor) {
+    ComplexNumber multiply(double factor) {
         throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
     }
 
-    ComplexNumber div(ComplexNumber other) {
+    ComplexNumber divide(ComplexNumber other) {
         throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
     }
 
-    ComplexNumber div(double divisor) {
+    ComplexNumber divide(double divisor) {
         throw new UnsupportedOperationException("Delete this statement and write your own implementation.");
     }
 

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

@@ -17,7 +17,7 @@ private void assertDoublesEqual(double d1, double d2, String numberPart) {
 
     private void assertComplexNumbersEqual(ComplexNumber c1, ComplexNumber c2) {
         assertDoublesEqual(c1.getReal(), c2.getReal(), "real");
-        assertDoublesEqual(c1.getImag(), c2.getImag(), "imaginary");
+        assertDoublesEqual(c1.getImaginary(), c2.getImaginary(), "imaginary");
     }
 
     // Tests
@@ -49,31 +49,31 @@ public void testRealPartOfNumberWithRealAndImaginaryParts() {
     @Test
     public void testImaginaryPartOfPurelyRealNumber() {
         double expected = 0.0;
-        double actual = new ComplexNumber(1.0, 0).getImag();
+        double actual = new ComplexNumber(1.0, 0).getImaginary();
         assertDoublesEqual(expected, actual, "imaginary");
     }
 
     @Ignore("Remove to run test")
     @Test
     public void testImaginaryPartOfPurelyImaginaryNumber() {
         double expected = 1.0;
-        double actual = new ComplexNumber(0, 1.0).getImag();
+        double actual = new ComplexNumber(0, 1.0).getImaginary();
         assertDoublesEqual(expected, actual, "imaginary");
     }
 
     @Ignore("Remove to run test")
     @Test
     public void testImaginaryPartOfNumberWithRealAndImaginaryParts() {
         double expected = 2.0;
-        double actual = new ComplexNumber(1.0, 2.0).getImag();
+        double actual = new ComplexNumber(1.0, 2.0).getImaginary();
         assertDoublesEqual(expected, actual, "imaginary");
     }
 
     @Ignore("Remove to run test")
     @Test
     public void testImaginaryUnitExhibitsDefiningProperty() {
         ComplexNumber expected = new ComplexNumber(-1.0, 0);
-        ComplexNumber actual = new ComplexNumber(0, 1.0).times(new ComplexNumber(0, 1.0));
+        ComplexNumber actual = new ComplexNumber(0, 1.0).multiply(new ComplexNumber(0, 1.0));
         assertComplexNumbersEqual(expected, actual);
     }
 
@@ -105,71 +105,71 @@ public void testAdditionWithRealAndImaginaryParts() {
     @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));
+        ComplexNumber actual = new ComplexNumber(1.0, 0.0).subtract(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));
+        ComplexNumber actual = new ComplexNumber(0, 1.0).subtract(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));
+        ComplexNumber actual = new ComplexNumber(1.0, 2.0).subtract(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));
+        ComplexNumber actual = new ComplexNumber(1.0, 0).multiply(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));
+        ComplexNumber actual = new ComplexNumber(0, 1.0).multiply(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));
+        ComplexNumber actual = new ComplexNumber(1.0, 2.0).multiply(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));
+        ComplexNumber actual = new ComplexNumber(1.0, 0).divide(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));
+        ComplexNumber actual = new ComplexNumber(0, 1.0).divide(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));
+        ComplexNumber actual = new ComplexNumber(1.0, 2.0).divide(new ComplexNumber(3.0, 4.0));
         assertComplexNumbersEqual(expected, actual);
     }