public ComplexNumber scalarProduct(ComplexVector2D v1) {
ComplexNumber c;
ComplexNumber d;
c = this.x.mult(v1.x);
d = this.y.mult(v1.y);
return (c.add(d));
}
public ComplexNumber pow(int n) {
ComplexNumber powResult = new ComplexNumber(a, b);
ComplexNumber staticComplexNum = new ComplexNumber(a, b);
for (int i = 1; i < n; i++) {
powResult = powResult.multiply(staticComplexNum);
}
return powResult;
}
@Test
public void shouldAddTwoComplexNumbers() {
ComplexNumber number1 = new ComplexNumber(4, 7);
ComplexNumber number2 = new ComplexNumber(5, 3);
ComplexNumber result = number1.add(number2);
assertEquals(9, result.getReal(), 0);
assertEquals(10, result.getImaginary(), 0);
}
@Test
public void multShouldWorkCorrect() {
ComplexMatrix2x2 matrix = (ComplexMatrix2x2) context.getBean("zeroMatrix");
ComplexNumber cN = ComplexMatrix2x2Util.getComplexNumber(0, 0);
when(cN.add(any(ComplexNumber.class))).thenReturn(cN);
when(cN.mult(any(ComplexNumber.class))).thenReturn(cN);
ComplexNumber[][] complexNumbers = new ComplexNumber[][] {{cN, cN}, {cN, cN}};
assertTrue(Arrays.deepEquals(matrix.mult(matrix).getMatrix(), complexNumbers));
}
@Test
public void shouldCalculateSquare() {
ComplexNumber number1 = new ComplexNumber(2, 3);
assertEquals(-5, number1.getSquare().getReal(), 0);
assertEquals(12, number1.getSquare().getImaginary(), 0);
ComplexNumber number2 = new ComplexNumber(4, 2);
assertEquals(12, number2.getSquare().getReal(), 0);
assertEquals(16, number2.getSquare().getImaginary(), 0);
}
public void calcZeros(ArrayAdapter<String> zerosArr, int nFns) {
int n;
String title;
for (int i = 0; i < nFns; i += 1) {
if (!graphCalcs[i].empty()) {
title = "Fn" + Integer.toString(i + 1) + "(x):";
n =
graphCalcs[i].calcZeros(
zeros[i],
graph.getXLeft(),
graph.getXRight(),
graph.getYBot(),
graph.getYTop(),
graph.getXMin(),
graph.getXMax(),
graph.getYMin(),
graph.getYMax(),
graph.getXUnitLen());
// Log.v ("calcZeros",Integer.toString(n));
if (n == 0) title += " None";
zerosArr.add(title);
// Convert x values of zeros to strings
for (int k = 0; k < n; k += 1) {
float num = zeros[i][k];
if ((num > -0.001 && num < 0) || (num < 0.001 && num > 0)) num = 0;
String numStr = ComplexNumber.roundStr(num, 3);
zerosArr.add(" x = " + numStr);
}
}
}
}
public static void main(String[] args) {
ComplexNumber A = new ComplexNumber(2, 3);
ComplexNumber B = new ComplexNumber(1, 4);
System.out.println("Add result: " + A.addComplex(B).toString());
System.out.println("Sub result: " + A.subComplex(B).toString());
System.out.println("Mult result: " + A.multComplex(B).toString());
System.out.println("Div result: " + A.divComplex(B).toString());
System.out.println("A Mag: " + A.magComplex());
System.out.println("B Mag: " + B.magComplex());
}
@Test
public void canConvertToString() {
ComplexNumber z = new ComplexNumber(1, 2);
assertEquals("1.0 + 2.0i", z.toString());
}
/**
* Returns the complex plane currently being used.
*
* @return complex plan currently being used.
*/
private String complexPlane() {
ComplexNumber C1 = new ComplexNumber(new RealNumber(currWXMin), new RealNumber(currWYMin));
ComplexNumber C2 = new ComplexNumber(new RealNumber(currWXMax), new RealNumber(currWYMax));
return "< " + C1.toString() + ", " + C2.toString() + " >";
}
@Test
public void shouldCalculateSquareWithNegativeRealAndImaginary() {
ComplexNumber number = new ComplexNumber(-5, -3);
assertEquals(16, number.getSquare().getReal(), 0);
assertEquals(30, number.getSquare().getImaginary(), 0);
}
@Test
public void canConvertNegativeRealPartToString() {
ComplexNumber z = new ComplexNumber(-1, 1);
assertEquals("-1.0 + 1.0i", z.toString());
}
public ComplexNumber specialDivide(ComplexNumber a, double b) {
double aNew = a.getA() / b;
double bNew = a.getB() / b;
ComplexNumber newComplexNum = new ComplexNumber(aNew, bNew);
return newComplexNum;
}
public ComplexNumber subtract(ComplexNumber other) {
ComplexNumber newComplexNum = new ComplexNumber(-other.getA(), -other.getB());
newComplexNum = add(newComplexNum);
return newComplexNum;
}
public ComplexNumber add(ComplexNumber other) {
double aNew = other.getA() + a;
double bNew = other.getB() + b;
ComplexNumber newComplexNum = new ComplexNumber(aNew, bNew);
return newComplexNum;
}
@Test
public void canConvertFloatingComplexNumberToString() {
ComplexNumber z = new ComplexNumber(3.14, 2);
assertEquals("3.14 + 2.0i", z.toString());
}
public ComplexNumber multiply(ComplexNumber other) {
double aNew = other.getA() * a - other.getB() * b;
double bNew = other.getB() * a + other.getA() * b;
ComplexNumber newComplexNum = new ComplexNumber(aNew, bNew);
return newComplexNum;
}
@Test
public void canConvertScientificFormatToString() {
ComplexNumber z = new ComplexNumber(1, 1.2456e-2);
assertEquals("1.0 + 0.01i", z.toString());
}
public ComplexNumber divide(ComplexNumber other) {
double tempNumber = other.getA() * other.getA() + other.getB() * other.getB();
ComplexNumber tempComplexNum = new ComplexNumber(other.getA(), -other.getB());
tempComplexNum = multiply(tempComplexNum);
return specialDivide(tempComplexNum, tempNumber);
}
@Test
public void canConvertNegativeImaginaryPartToString() {
ComplexNumber z = new ComplexNumber(1, -1);
assertEquals("1.0 - 1.0i", z.toString());
}
@Test
public void shouldCalculateSquareWithNegativeImaginary() {
ComplexNumber number = new ComplexNumber(3, -2);
assertEquals(5, number.getSquare().getReal(), 0);
assertEquals(-12, number.getSquare().getImaginary(), 0);
}