Browse Source

Merge branch 'featureKomplexNumberCalculator' into pullrequest

pullrequest
Lukas Reichwein 2 years ago
parent
commit
1337a0f89f
  1. 6
      pom.xml
  2. 156
      src/main/java/com/ugsbo/complexnumcalc/ComplexNumber.java
  3. 71
      src/test/java/com/ugsbo/complexnumcalc/AbsoluteValueOfComplexNumbersTest.java
  4. 31
      src/test/java/com/ugsbo/complexnumcalc/AddComplexNumbersTest.java
  5. 31
      src/test/java/com/ugsbo/complexnumcalc/DivideComplexNumbersTest.java
  6. 69
      src/test/java/com/ugsbo/complexnumcalc/EqualsComplexNumbersTest.java
  7. 31
      src/test/java/com/ugsbo/complexnumcalc/MultiplyComplexNumbersTest.java
  8. 31
      src/test/java/com/ugsbo/complexnumcalc/SubstractComplexNumbersTest.java
  9. 33
      src/test/java/com/ugsbo/complexnumcalc/conjugationOfComplexNumbersTest.java

6
pom.xml

@ -24,6 +24,12 @@
<version>4.11</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.hamcrest</groupId>
<artifactId>hamcrest-junit</artifactId>
<version>2.0.0.0</version>
<scope>test</scope>
</dependency>
<!-- https://mvnrepository.com/artifact/org.mockito/mockito-core -->
<dependency>
<groupId>org.mockito</groupId>

156
src/main/java/com/ugsbo/complexnumcalc/ComplexNumber.java

@ -0,0 +1,156 @@
package com.ugsbo.complexnumcalc;
public class ComplexNumber {
private Double realPart;
private Double imaginaryPart;
/**
* @param realPart The real part of the complex Number
* @param imaginaryPart The imaginary part of the complex Number
*/
public ComplexNumber(Double realPart, Double imaginaryPart) {
this.realPart = realPart;
this.imaginaryPart = imaginaryPart;
}
/**
* @return the realPart
*/
public Double getRealPart() {
return realPart;
}
/**
* @param realPart the realPart to set
*/
public void setRealPart(Double realPart) {
this.realPart = realPart;
}
/**
* @return the imaginaryPart
*/
public Double getImaginaryPart() {
return imaginaryPart;
}
/**
* @param imaginaryPart the imaginaryPart to set
*/
public void setImaginaryPart(Double imaginaryPart) {
this.imaginaryPart = imaginaryPart;
}
/**
* Checks if the given complex Number is equal to this object.
*
* @param complexNumber The number wich gets compared with this Instance
* @return True if the complex Numbers are Equal
*/
@Override
public boolean equals(Object complexNumber) {
if (complexNumber instanceof ComplexNumber){
ComplexNumber that = (ComplexNumber) complexNumber;
return this.realPart.equals(that.realPart) && this.imaginaryPart.equals(that.imaginaryPart);
} else {
return false;
}
}
/**
* Adds two complex Numbers together.
*
* @param addend The complex Number.
* @return The result of adding the two complex Numbers together, as a conplex
* Number.
*/
public ComplexNumber add(ComplexNumber addend) {
Double sumRealPart, sumImaginaryPart;
sumRealPart = this.realPart + addend.realPart;
sumImaginaryPart = this.imaginaryPart + addend.imaginaryPart;
ComplexNumber sum = new ComplexNumber(sumRealPart, sumImaginaryPart);
return sum;
}
/**
* Substracts the Subtrahend form this instance.
*
* @param subtrahend The Number wich will be substracted form the Minuend
* @return The Differenz of the Minuend and Subtrahend.
*/
public ComplexNumber substract(ComplexNumber subtrahend) {
Double differenzRealPart, differenzImaginaryPart;
differenzRealPart = this.realPart - subtrahend.realPart;
differenzImaginaryPart = this.imaginaryPart - subtrahend.imaginaryPart;
ComplexNumber differenz = new ComplexNumber(differenzRealPart, differenzImaginaryPart);
return differenz;
}
/**
* Multiplies the faktor with this Instance.
*
* @param faktor The ComplexNumber by wich this Instance will get multiplyed
* @return The product of this Instance and the faktor
*/
public ComplexNumber multiply(ComplexNumber faktor) {
Double productRealPart, productImaginaryPart;
productRealPart = this.realPart * faktor.realPart - this.imaginaryPart * faktor.imaginaryPart;
productImaginaryPart = this.realPart * faktor.imaginaryPart + this.imaginaryPart * faktor.realPart;
ComplexNumber product = new ComplexNumber(productRealPart, productImaginaryPart);
return product;
}
/**
* Divides the dividend by the divisor, the dividend is this Instance.
*
* @param divisor The ComplexNumber by wich this Instance will get divided
* @return The Qoutient of the Instance and the divisor
*/
public ComplexNumber divide(ComplexNumber divisor) {
Double qoutientRealPart, qoutientImaginaryPart, tempDivisor;
tempDivisor = divisor.realPart * divisor.realPart + divisor.imaginaryPart * divisor.imaginaryPart;
qoutientRealPart = this.realPart * divisor.realPart + this.imaginaryPart * divisor.imaginaryPart;
qoutientImaginaryPart = this.imaginaryPart * divisor.realPart - this.realPart * divisor.imaginaryPart;
qoutientImaginaryPart /= tempDivisor;
qoutientRealPart /= tempDivisor;
ComplexNumber qoutient = new ComplexNumber(qoutientRealPart, qoutientImaginaryPart);
return qoutient;
}
/**
* Calucates the absolute value of this complex number
* @return the absolute value
*/
public Double absolutValueOf(){
Double absoluteValue = Math.sqrt(Math.pow(this.realPart, 2) + Math.pow(this.imaginaryPart, 2)) ;
return absoluteValue;
}
/**
* Calucates the absolute value of this complex number
* @return the absolute value
*/
public ComplexNumber conjugationOf(){
if(this.imaginaryPart.equals(Double.valueOf(0))){
return this;
} else {
this.imaginaryPart *= (-1);
return this;
}
}
}

71
src/test/java/com/ugsbo/complexnumcalc/AbsoluteValueOfComplexNumbersTest.java

@ -0,0 +1,71 @@
package com.ugsbo.complexnumcalc;
import static org.junit.Assert.assertEquals;
import org.junit.Test;
public class AbsoluteValueOfComplexNumbersTest {
@Test
public void TheAbsoluteValueOfAComplexNumberWithOnlyARealPart_IsNotTheAbsoluteValueOfTheRealPart() {
ComplexNumber complexNumber = new ComplexNumber(Double.valueOf(4), Double.valueOf(0));
Double expected = Double.valueOf(4);
Double actual = complexNumber.absolutValueOf();
assertEquals("The absolute value of an complex number with only an real part should be the absolute value of that real part", expected, actual);
}
@Test
public void TheAbsoluteValueOfAComplexNumberWithOnlyANegativeRealPart_IsNotTheAbsoluteValueOfTheRealPart() {
ComplexNumber complexNumber = new ComplexNumber(Double.valueOf(-4), Double.valueOf(0));
Double expected = Double.valueOf(4);
Double actual = complexNumber.absolutValueOf();
assertEquals("The absolute value of an complex number with only an negative real part should be the absolute value of that real part", expected, actual);
}
@Test
public void TheAbsoluteValueOfAComplexNumber_IsNotTheAbsoluteValueOfIt() {
ComplexNumber complexNumber = new ComplexNumber(Double.valueOf(4), Double.valueOf(3));
Double expected = Double.valueOf(5);
Double actual = complexNumber.absolutValueOf();
assertEquals("The absolute value of an complex number should be the square root of the sum of real " +
"part times real part and imaginary part times imaginary part ", expected, actual);
}
@Test
public void TheAbsoluteValueOfAComplexNumberWithNegativRealPart_IsNotTheAbsoluteValueOfIt() {
ComplexNumber complexNumber = new ComplexNumber(Double.valueOf(-4), Double.valueOf(3));
Double expected = Double.valueOf(5);
Double actual = complexNumber.absolutValueOf();
assertEquals("The absolute value of an complex number with negative real part should be the square root of the sum of real " +
"part times real part and imaginary part times imaginary part ", expected, actual);
}
@Test
public void TheAbsoluteValueOfAComplexNumberWithNegativImaginaryPart_IsNotTheAbsoluteValueOfIt() {
ComplexNumber complexNumber = new ComplexNumber(Double.valueOf(4), Double.valueOf(-3));
Double expected = Double.valueOf(5);
Double actual = complexNumber.absolutValueOf();
assertEquals("The absolute value of an complex number with negative imaginary part should be the square root of the sum of real " +
"part times real part and imaginary part times imaginary part ", expected, actual);
}
@Test
public void TheAbsoluteValueOfAComplexNumberWithNegativParts_IsNotTheAbsoluteValueOfIt() {
ComplexNumber complexNumber = new ComplexNumber(Double.valueOf(-4), Double.valueOf(-3));
Double expected = Double.valueOf(5);
Double actual = complexNumber.absolutValueOf();
assertEquals("The absolute value of an complex number with negative parts should be the square root of the sum of real " +
"part times real part and imaginary part times imaginary part ", expected, actual);
}
}

31
src/test/java/com/ugsbo/complexnumcalc/AddComplexNumbersTest.java

@ -0,0 +1,31 @@
package com.ugsbo.complexnumcalc;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.*;
import org.junit.Test;
public class AddComplexNumbersTest {
@Test
public void addingTwoComplexNumbersWithoutImaginaryPart() {
ComplexNumber firstAddend = new ComplexNumber(Double.valueOf(5), Double.valueOf(0));
ComplexNumber secoundAddend = new ComplexNumber(Double.valueOf(6), Double.valueOf(0));
ComplexNumber expected = new ComplexNumber(Double.valueOf(11), Double.valueOf(0));
ComplexNumber sum = firstAddend.add(secoundAddend);
assertThat("Dont sum to the sum", sum, equalTo(expected));
}
@Test
public void addingTwoComplexNumbersWithImaginaryPart() {
ComplexNumber firstAddend = new ComplexNumber(Double.valueOf(5), Double.valueOf(3));
ComplexNumber secoundAddend = new ComplexNumber(Double.valueOf(6), Double.valueOf(4));
ComplexNumber expected = new ComplexNumber(Double.valueOf(11), Double.valueOf(7));
ComplexNumber sum = firstAddend.add(secoundAddend);
assertThat("Dont sum to the sum", sum, equalTo(expected));
}
}

31
src/test/java/com/ugsbo/complexnumcalc/DivideComplexNumbersTest.java

@ -0,0 +1,31 @@
package com.ugsbo.complexnumcalc;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.*;
import org.junit.Test;
public class DivideComplexNumbersTest {
@Test
public void divideTwoComplexNumbersWithoutImaginaryPart() {
ComplexNumber dividend = new ComplexNumber(Double.valueOf(30), Double.valueOf(0));
ComplexNumber divisor = new ComplexNumber(Double.valueOf(6), Double.valueOf(0));
ComplexNumber expected = new ComplexNumber(Double.valueOf(5), Double.valueOf(0));
ComplexNumber quotient = dividend.divide(divisor);
assertThat("The quotient is not as expected", quotient, equalTo(expected));
}
@Test
public void divideTwoComplexNumbersWithImaginaryPart() {
ComplexNumber dividend = new ComplexNumber(Double.valueOf(30), Double.valueOf(28));
ComplexNumber divisor = new ComplexNumber(Double.valueOf(6), Double.valueOf(2));
ComplexNumber expected = new ComplexNumber(Double.valueOf(5.9), Double.valueOf(2.7));
ComplexNumber quotient = dividend.divide(divisor);
assertThat("The quotient is not as expected", quotient, equalTo(expected));
}
}

69
src/test/java/com/ugsbo/complexnumcalc/EqualsComplexNumbersTest.java

@ -0,0 +1,69 @@
package com.ugsbo.complexnumcalc;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import org.junit.Test;
public class EqualsComplexNumbersTest {
@Test
public void TwoEqualNumbersWithOnlyRealPart_AreNotDetectedAsEqual() {
ComplexNumber firstNumber = new ComplexNumber(Double.valueOf(5), Double.valueOf(0));
ComplexNumber secoundNumber = new ComplexNumber(Double.valueOf(5), Double.valueOf(0));
boolean actual = firstNumber.equals(secoundNumber);
assertTrue("TwoEqualNumbersShouldBeEqual", actual);
}
@Test
public void TwoNotEqualNumbersWithOnlyRealPart_AreDetectedAsEqual() {
ComplexNumber firstNumber = new ComplexNumber(Double.valueOf(5), Double.valueOf(0));
ComplexNumber secoundNumber = new ComplexNumber(Double.valueOf(6), Double.valueOf(0));
boolean actual = firstNumber.equals(secoundNumber);
assertFalse("TwoNotEqualNumbersShouldNotBeEqual", actual);
}
@Test
public void TwoEqualNumbersWithOnlyImaginaryPart_AreNotDetectedAsEqual() {
ComplexNumber firstNumber = new ComplexNumber(Double.valueOf(0), Double.valueOf(5));
ComplexNumber secoundNumber = new ComplexNumber(Double.valueOf(0), Double.valueOf(5));
boolean actual = firstNumber.equals(secoundNumber);
assertTrue("TwoEqualComplexNumbersShouldBeEqual", actual);
}
@Test
public void TwoNotEqualNumbersWithOnlyImaginaryPart_AreDetectedAsEqual() {
ComplexNumber firstNumber = new ComplexNumber(Double.valueOf(0), Double.valueOf(5));
ComplexNumber secoundNumber = new ComplexNumber(Double.valueOf(0), Double.valueOf(6));
boolean actual = firstNumber.equals(secoundNumber);
assertFalse("TwoNotEqualComplexNumbersShouldNotBeEqual", actual);
}
@Test
public void TwoEqualComplexNumbers_AreNotDetectedAsEqual() {
ComplexNumber firstNumber = new ComplexNumber(Double.valueOf(5), Double.valueOf(5));
ComplexNumber secoundNumber = new ComplexNumber(Double.valueOf(5), Double.valueOf(5));
boolean actual = firstNumber.equals(secoundNumber);
assertTrue("TwoEqualComplexNumbersShouldBeEqual", actual);
}
@Test
public void TwoNotEqualComplexNumbers_AreDetectedAsEqual() {
ComplexNumber firstNumber = new ComplexNumber(Double.valueOf(5), Double.valueOf(5));
ComplexNumber secoundNumber = new ComplexNumber(Double.valueOf(6), Double.valueOf(6));
boolean actual = firstNumber.equals(secoundNumber);
assertFalse("TwoNotEqualComplexNumbersShouldNotBeEqual", actual);
}
}

31
src/test/java/com/ugsbo/complexnumcalc/MultiplyComplexNumbersTest.java

@ -0,0 +1,31 @@
package com.ugsbo.complexnumcalc;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.*;
import org.junit.Test;
public class MultiplyComplexNumbersTest {
@Test
public void multiplyTwoComplexNumbersWithoutImaginaryPart() {
ComplexNumber firstFaktor = new ComplexNumber(Double.valueOf(5), Double.valueOf(0));
ComplexNumber secoundFaktor = new ComplexNumber(Double.valueOf(6), Double.valueOf(0));
ComplexNumber expected = new ComplexNumber(Double.valueOf(30), Double.valueOf(0));
ComplexNumber product = firstFaktor.multiply(secoundFaktor);
assertThat("The product is not as expected", product, equalTo(expected));
}
@Test
public void multiplyTwoComplexNumbersWithImaginaryPart() {
ComplexNumber firstFaktor = new ComplexNumber(Double.valueOf(5), Double.valueOf(3));
ComplexNumber secoundFaktor = new ComplexNumber(Double.valueOf(6), Double.valueOf(2));
ComplexNumber expected = new ComplexNumber(Double.valueOf(24.0), Double.valueOf(28.0));
ComplexNumber product = firstFaktor.multiply(secoundFaktor);
assertThat("The product is not as expected", product, equalTo(expected));
}
}

31
src/test/java/com/ugsbo/complexnumcalc/SubstractComplexNumbersTest.java

@ -0,0 +1,31 @@
package com.ugsbo.complexnumcalc;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.*;
import org.junit.Test;
public class SubstractComplexNumbersTest {
@Test
public void substractTwoComplexNumbersWithoutImaginaryPart() {
ComplexNumber minuend = new ComplexNumber(Double.valueOf(5), Double.valueOf(0));
ComplexNumber subtrahend = new ComplexNumber(Double.valueOf(6), Double.valueOf(0));
ComplexNumber expected = new ComplexNumber(Double.valueOf(-1), Double.valueOf(0));
ComplexNumber difference = minuend.substract(subtrahend);
assertThat("The difference is not as expected", difference, equalTo(expected));
}
@Test
public void substractTwoComplexNumbersWithImaginaryPart() {
ComplexNumber minuend = new ComplexNumber(Double.valueOf(5), Double.valueOf(5));
ComplexNumber subtrahend = new ComplexNumber(Double.valueOf(6), Double.valueOf(4));
ComplexNumber expected = new ComplexNumber(Double.valueOf(-1), Double.valueOf(1));
ComplexNumber difference = minuend.substract(subtrahend);
assertThat("The difference is not as expected", difference, equalTo(expected));
}
}

33
src/test/java/com/ugsbo/complexnumcalc/conjugationOfComplexNumbersTest.java

@ -0,0 +1,33 @@
package com.ugsbo.complexnumcalc;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.*;
import org.junit.Test;
public class conjugationOfComplexNumbersTest {
@Test
public void TheConjugatedComplexNumberOfAComplexNumberWithOnlyARealPartShouldBeTheRealPart_ButItIsNot() {
Double realPart = Double.valueOf(4);
Double imaginaryPart = Double.valueOf(0);
ComplexNumber complexNumber = new ComplexNumber(realPart, imaginaryPart);
ComplexNumber expected = new ComplexNumber(realPart, imaginaryPart);
ComplexNumber actual = complexNumber.conjugationOf();
assertThat("The conjugated complex Number of a complex number with only a real part is the real part", expected, equalTo(actual));
}
@Test
public void TheConjugatedComplexNumberOfAComplexNumberShouldBeTheComplexNumberWithSwapedSignImaginaryPart_ButItIsNot() {
Double realPart = Double.valueOf(4);
Double imaginaryPart = Double.valueOf(5);
ComplexNumber complexNumber = new ComplexNumber(realPart, imaginaryPart);
ComplexNumber expected = new ComplexNumber(realPart, -imaginaryPart);
ComplexNumber actual = complexNumber.conjugationOf();
assertThat("The conjugated complex number of a complex number is the complex number with swaped sign in the imaginary part", expected, equalTo(actual));
}
}
Loading…
Cancel
Save