Ejemplo n.º 1
1
  /**
   * <u>Berechnen des Tangens der komplexen Zahl</u><br>
   *
   * @param comp Komplexe Zahl
   * @return R&uuml;ckgabe eines Objektes vom Typ Complex mit L&ouml;sung aus tan(<u>z</u>)
   */
  public static Complex tan(Complex comp) {
    double real, imag;
    double nn =
        1d
            + Math.pow(
                Math.tan(comp.getReal()) * Math.tanh(comp.getImag()), 2); // Nenner der Brueche

    real = (Math.tan(comp.getReal()) * (1 - Math.pow(Math.tanh(comp.getImag()), 2))) / nn;
    imag = (Math.tanh(comp.getImag()) * (1 + Math.pow(Math.tan(comp.getReal()), 2))) / nn;

    return new Complex(real, imag);
  }
Ejemplo n.º 2
0
  public void testScalarMultiplyInf() {
    Complex z = new Complex(1, 1);
    Complex w = z.multiply(Double.POSITIVE_INFINITY);
    assertEquals(w.getReal(), inf, 0);
    assertEquals(w.getImaginary(), inf, 0);

    w = z.multiply(Double.NEGATIVE_INFINITY);
    assertEquals(w.getReal(), inf, 0);
    assertEquals(w.getImaginary(), inf, 0);
  }
Ejemplo n.º 3
0
  public void testDivideNaNInf() {
    Complex z = oneInf.divide(Complex.ONE);
    assertTrue(Double.isNaN(z.getReal()));
    assertEquals(inf, z.getImaginary(), 0);

    z = negInfNegInf.divide(oneNaN);
    assertTrue(Double.isNaN(z.getReal()));
    assertTrue(Double.isNaN(z.getImaginary()));

    z = negInfInf.divide(Complex.ONE);
    assertTrue(Double.isNaN(z.getReal()));
    assertTrue(Double.isNaN(z.getImaginary()));
  }
Ejemplo n.º 4
0
 public void testDivide() {
   Complex x = new Complex(3.0, 4.0);
   Complex y = new Complex(5.0, 6.0);
   Complex z = x.divide(y);
   assertEquals(39.0 / 61.0, z.getReal(), 1.0e-5);
   assertEquals(2.0 / 61.0, z.getImaginary(), 1.0e-5);
 }
Ejemplo n.º 5
0
 public void testMultiply() {
   Complex x = new Complex(3.0, 4.0);
   Complex y = new Complex(5.0, 6.0);
   Complex z = x.multiply(y);
   assertEquals(-9.0, z.getReal(), 1.0e-5);
   assertEquals(38.0, z.getImaginary(), 1.0e-5);
 }
Ejemplo n.º 6
0
 public void testAdd() {
   Complex x = new Complex(3.0, 4.0);
   Complex y = new Complex(5.0, 6.0);
   Complex z = x.add(y);
   assertEquals(8.0, z.getReal(), 1.0e-5);
   assertEquals(10.0, z.getImaginary(), 1.0e-5);
 }
Ejemplo n.º 7
0
 public void testSubtract() {
   Complex x = new Complex(3.0, 4.0);
   Complex y = new Complex(5.0, 6.0);
   Complex z = x.subtract(y);
   assertEquals(-2.0, z.getReal(), 1.0e-5);
   assertEquals(-2.0, z.getImaginary(), 1.0e-5);
 }
Ejemplo n.º 8
0
 public void testScalarMultiply() {
   Complex x = new Complex(3.0, 4.0);
   double y = 2.0;
   Complex z = x.multiply(y);
   assertEquals(6.0, z.getReal(), 1.0e-5);
   assertEquals(8.0, z.getImaginary(), 1.0e-5);
 }
Ejemplo n.º 9
0
 public void testAddNaN() {
   Complex x = new Complex(3.0, 4.0);
   Complex z = x.add(Complex.NaN);
   assertTrue(z.isNaN());
   z = new Complex(1, nan);
   Complex w = x.add(z);
   assertEquals(w.getReal(), 4.0, 0);
   assertTrue(Double.isNaN(w.getImaginary()));
 }
Ejemplo n.º 10
0
  public void testDivideInfinite() {
    Complex x = new Complex(3, 4);
    Complex w = new Complex(neginf, inf);
    assertTrue(x.divide(w).equals(Complex.ZERO));

    Complex z = w.divide(x);
    assertTrue(Double.isNaN(z.getReal()));
    assertEquals(inf, z.getImaginary(), 0);

    w = new Complex(inf, inf);
    z = w.divide(x);
    assertTrue(Double.isNaN(z.getImaginary()));
    assertEquals(inf, z.getReal(), 0);

    w = new Complex(1, inf);
    z = w.divide(w);
    assertTrue(Double.isNaN(z.getReal()));
    assertTrue(Double.isNaN(z.getImaginary()));
  }
Ejemplo n.º 11
0
  public void testAddInfinite() {
    Complex x = new Complex(1, 1);
    Complex z = new Complex(inf, 0);
    Complex w = x.add(z);
    assertEquals(w.getImaginary(), 1, 0);
    assertEquals(inf, w.getReal(), 0);

    x = new Complex(neginf, 0);
    assertTrue(Double.isNaN(x.add(z).getReal()));
  }
Ejemplo n.º 12
0
  public void testMultiplyNaNInf() {
    Complex z = new Complex(1, 1);
    Complex w = z.multiply(infOne);
    assertEquals(w.getReal(), inf, 0);
    assertEquals(w.getImaginary(), inf, 0);

    // [MATH-164]
    assertTrue(new Complex(1, 0).multiply(infInf).equals(Complex.INF));
    assertTrue(new Complex(-1, 0).multiply(infInf).equals(Complex.INF));
    assertTrue(new Complex(1, 0).multiply(negInfZero).equals(Complex.INF));

    w = oneInf.multiply(oneNegInf);
    assertEquals(w.getReal(), inf, 0);
    assertEquals(w.getImaginary(), inf, 0);

    w = negInfNegInf.multiply(oneNaN);
    assertTrue(Double.isNaN(w.getReal()));
    assertTrue(Double.isNaN(w.getImaginary()));
  }
Ejemplo n.º 13
0
 private void ift(Complex[] F, byte[] img, int width, int height) {
   for (int x = 0; x < height; x++) {
     for (int y = 0; y < width; y++) {
       Complex c = new Complex();
       for (int u = 0; u < height; u++) {
         for (int v = 0; v < width; v++) {
           Complex tmp =
               Complex.fromPolar(
                   1, 2.0 * Math.PI * (u * x / (double) height + v * y / (double) width));
           c = c.plus(tmp.mul(F[u * width + v]));
         }
       }
       c = c.div(height * width);
       c = c.mul(Math.pow(-1, (x + y)));
       if (c.getReal() < 0) c.setReal(0.0);
       System.out.println(c.getReal());
       img[x * width + y] = (byte) (c.getReal());
     }
   }
 }
Ejemplo n.º 14
0
  public static void main(String args[]) {
    Complex c1 = new Complex(3, 4);
    Complex c2 = new Complex(1, 5);
    Complex add = Complex.add(c1, c2);
    System.out.println(add.toString());

    Complex sub = Complex.sub(c1, c2);
    System.out.println(sub.getReal() + " + " + sub.getImag() + "i");

    Complex mult = Complex.mult(c1, c2);
    System.out.println(mult.toString());

    Complex clone = add.clone();
    System.out.println(clone.toString());
  }
Ejemplo n.º 15
0
 public TestComplex(Complex other) {
   this(other.getReal(), other.getImaginary());
 }
Ejemplo n.º 16
0
 /**
  * <u>Subtraktion zweier komplexer Zahlen</u><br>
  *
  * @param comp1 1. Komplexe Zahl
  * @param comp2 2. Komplexe Zahl
  * @return R&uuml;ckgabe von neuem Objekt mit Ergebnis aus Subtraktion
  */
 public static Complex sub(Complex comp1, Complex comp2) {
   return new Complex(comp1.getReal() - comp2.getReal(), comp1.getImag() - comp2.getImag());
 }
Ejemplo n.º 17
0
 /**
  * <u>Subtraktion zweier komplexer Zahlen</u><br>
  *
  * @param comp Komplexe Zahl
  * @return R&uuml;ckgabe von neuem Objekt mit Ergebnis aus Subtraktion
  */
 public Complex sub(Complex comp) {
   return new Complex(this.real - comp.getReal(), this.imag - comp.getImag());
 }
Ejemplo n.º 18
0
 /**
  * <u>Addition zweier komplexer Zahlen</u><br>
  *
  * @param comp Komplexe Zahl
  * @return R&uuml;ckgabe von neuem Objekt mit Ergebnis aus Addition
  */
 public Complex add(Complex comp) {
   return new Complex(this.real + comp.getReal(), this.imag + comp.getImag());
 }
Ejemplo n.º 19
0
 private static boolean closeFourDigit(Complex a, Complex b) {
   return closeFourDigit(a.getReal(), b.getReal())
       && closeFourDigit(a.getImaginary(), b.getImaginary());
 }
Ejemplo n.º 20
0
 public Complex multiplyNum(Complex a) {
   return new Complex(this.real * a.getReal(), this.imag * a.getImag());
 }
Ejemplo n.º 21
0
 public Complex addNum(Complex a) {
   return (Complex) new Complex(this.real + a.getReal(), this.imag + a.getImag());
 }
Ejemplo n.º 22
0
 public void evaluateAt(Complex var, Complex res) {
   res.setValue(var.getImaginary(), var.getReal());
 }
Ejemplo n.º 23
0
 public void testNegate() {
   Complex x = new Complex(3.0, 4.0);
   Complex z = x.negate();
   assertEquals(-3.0, z.getReal(), 1.0e-5);
   assertEquals(-4.0, z.getImaginary(), 1.0e-5);
 }
Ejemplo n.º 24
0
 public void testConstructor() {
   Complex z = new Complex(3.0, 4.0);
   assertEquals(3.0, z.getReal(), 1.0e-5);
   assertEquals(4.0, z.getImaginary(), 1.0e-5);
 }
Ejemplo n.º 25
0
 /**
  * <u>Berechnen der e-Funktion der komplexen Zahl</u><br>
  *
  * @param comp Komplexe Zahl
  * @return R&uuml;ckgabe eines Objektes vom Typ Complex mit L&ouml;sung aus exp(<u>z</u>)
  */
 public static Complex exp(Complex comp) {
   return new Complex(
       Math.cos(comp.getImag()) * (Math.sinh(comp.getReal()) + Math.cosh(comp.getReal())),
       Math.sin(comp.getImag()) * (Math.cosh(comp.getReal()) + Math.sinh(comp.getReal())));
 }
Ejemplo n.º 26
0
 /**
  * <u>Berechnen der konjugierten komplexen Zahl</u><br>
  * * @param comp Komplexe Zahl
  *
  * @return R&uuml;ckgabe eines Objektes vom Typ Complex mit L&ouml;sung aus conj(<u>z</u>)
  */
 public Complex conj(Complex comp) {
   return new Complex(comp.getReal(), -comp.getImag());
 }
Ejemplo n.º 27
0
 public static void testValues() {
   Complex c = new Complex(2, 3);
   System.out.println("(" + c + ")" + " = " + c.getReal());
   System.out.println("(" + c + ")" + " = " + c.getComplex() + "i");
   System.out.println();
 }