import java.util.*;
/** Complex numbers. Basic operations. */
public class Complex {
// TODO!!! Your fields here
/** Constructor from the pair of double values.
* @param r real part
* @param i imaginary part
*/
public Complex (double r, double i) {
// TODO!!!
}
/** Real part of the complex number.
* @return real part
*/
public double getRe() {
return 0.; // TODO!!!
}
/** Imaginary part of the complex number.
* @return imaginary part
*/
public double getIm() {
return 0.; // TODO!!!
}
/** Conversion of the complex number to the string.
* @return a string of form "a+bi", "-a+bi", "a-bi" or "-a-bi"
* (without any brackets)
*/
@Override
public String toString() {
return null; // TODO!!!
}
/** Conversion from the string to the complex number.
* Reverse to toString
method.
* @throws IllegalArgumentException if string s does not represent
* a complex number (defined by the toString
method)
* @param s string of form produced by the toString
method
* @return a complex number represented by string s
*/
public static Complex valueOf (String s) {
return null; // TODO!!!
}
/** Clone of the complex number.
* @return independent clone of this
*/
@Override
public Object clone() throws CloneNotSupportedException {
return null; // TODO!!!
}
/** Test whether the complex number is zero.
* @return true if the real part and the imaginary part
* are both (close to) zero
*/
public boolean isZero() {
return true; // TODO!!!
}
/** Conjugate of the complex number. Expressed by the formula
* conjugate(a+bi) = a-bi
* @return conjugate of this
*/
public Complex conjugate() {
return null; // TODO!!!
}
/** Opposite of the complex number. Expressed by the formula
* opposite(a+bi) = -a-bi
* @return complex number -this
*/
public Complex opposite() {
return null; // TODO!!!
}
/** Sum of complex numbers. Expressed by the formula
* (a+bi) + (c+di) = (a+c) + (b+d)i
* @param k addend (c+di)
* @return complex number this+k
*/
public Complex plus (Complex k) {
return null; // TODO!!!
}
/** Product of complex numbers. Expressed by the formula
* (a+bi) * (c+di) = (ac-bd) + (ad+bc)i
* @param k factor (c+di)
* @return complex number this*k
*/
public Complex times (Complex k) {
return null; // TODO!!!
}
/** Inverse of the complex number. Expressed by the formula
* 1/(a+bi) = a/(a*a+b*b) + ((-b)/(a*a+b*b))i
* @return complex number 1/this
*/
public Complex inverse() {
return null; // TODO!!!
}
/** Difference of complex numbers. Expressed as addition to the opposite.
* @param k subtrahend
* @return complex number this-k
*/
public Complex minus (Complex k) {
return null; // TODO!!!
}
/** Quotient of complex numbers. Expressed as multiplication to the inverse.
* @param k divisor
* @return complex number this/k
*/
public Complex divideBy (Complex k) {
return null; // TODO!!!
}
/** Equality test of complex numbers. Difference of equal numbers
* is (close to) zero.
* @param ko second complex number
* @return logical value of the expression this.equals(ko)
*/
@Override
public boolean equals (Object ko) {
return false; // TODO!!!
}
/** Module of the complex number. Expressed by the formula
* module(a+bi) = Math.sqrt(a*a+b*b)
* @return module of this
(module is a real number)
*/
public double module() {
return 0.; // TODO!!!
}
/** Polar angle of the complex number (principal value) in radians.
* Defined by the connection a+bi = m*cos(p) + (m*sin(p))i ,
* where m is the module and p is the polar angle of complex number a+bi.
* In Java p=Math.atan2(b,a)
* @return polar angle p of this
(in radians)
*/
public double angle() {
return 0.; // TODO!!!
}
/** Main method for testing purposes.
* @param arg command line parameters
*/
public static void main (String[] arg) {
// TODO!!! Your tests here!
Complex arv1 = new Complex (-1., 1.);
if (arg.length > 0)
arv1 = valueOf (arg[0]);
System.out.println ("first: " + arv1.toString());
System.out.println ("real: " + arv1.getRe());
System.out.println ("imag: " + arv1.getIm());
System.out.println ("isZero: " + arv1.isZero());
System.out.println ("conjugate: " + arv1.conjugate());
System.out.println ("opposite: " + arv1.opposite());
Complex res = null;
try {
res = (Complex)arv1.clone();
} catch (CloneNotSupportedException e) {};
System.out.println ("clone equals to original: " + res.equals (arv1));
System.out.println ("clone is not the same object: " + (res!=arv1));
res = valueOf (arv1.toString());
System.out.println ("string conversion equals to original: "
+ res.equals (arv1));
Complex arv2 = new Complex (1., -2.);
if (arg.length > 1)
arv2 = valueOf (arg[1]);
System.out.println ("second: " + arv2.toString());
System.out.println ("equals: " + arv1.equals (arv2));
res = arv1.plus (arv2);
System.out.println ("plus: " + res);
System.out.println ("times: " + arv1.times (arv2));
System.out.println ("minus: " + arv1.minus (arv2));
double mm = arv1.module();
System.out.println ("module: " + mm);
double nn = arv1.angle();
System.out.println ("angle: " + nn);
System.out.println ("back from polar: " + new Complex (mm*Math.cos (nn),
mm*Math.sin (nn)));
System.out.println ("inverse: " + arv1.inverse());
System.out.println ("divideBy: " + arv1.divideBy (arv2));
}
}