[
https://issues.apache.org/jira/browse/MATH-236?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel
]
Bernhard Grünewaldt updated MATH-236:
-------------------------------------
Attachment: ComplexTest.java.diff
Div for org.apache.commons.math.complex.ComplexTest
> nth-root of complex numbers
> ---------------------------
>
> Key: MATH-236
> URL: https://issues.apache.org/jira/browse/MATH-236
> Project: Commons Math
> Issue Type: Improvement
> Affects Versions: 2.0
> Reporter: Bernhard Grünewaldt
> Fix For: 2.0
>
> Attachments: Complex.java.diff, ComplexTest.java.diff
>
>
> Hello,
> I would like to have a simple methods that gives back all nth roots of a
> complex number.
> Below is the JavaCode for it. I have tested it and it works.
> What has to be done is the Exception Handling for NaN and Infinite etc.
> You can send me instructions what to do, or you can do it yourself.
> I really would like to contribute.
> {code:title=org.apache.commons.math.complex.Complex.java|borderStyle=solid}
> /**
> * Compute the angle phi of this complex number.
> * Where y=imaginary and x=real.
> *
> * Here is a short table for it:
> * <pre>
> * <code>
> * +----------+-------------+------------------+------------------+
> * | quadrant | I | II, III | IV |
> * +----------+-------------+------------------+------------------+
> * | phi | arctan(y/x) | arctan(y/x)+&pi | arctan(y/x)+2&pi |
> * +----------+-------------+------------------+------------------+
> * </code>
> * </pre>
> *
> * @return the angle phi of this complex number
> */
> public double getPhi() {
> // the angle phi from arctan(y/x)
> return Math.atan2(getImaginary(), getReal());
> }
>
> /**
> * Compute the n-th root of this complex number.
> * <p>
> * For a given n it implements the formula: <pre>
> * <code> z_k = pow( abs , 1.0/n ) * (cos(phi + k * 2&pi) + i * (sin(phi
> + k * 2&pi)</code></pre></p>
> * with <i><code>k=0,1,...,n-1</code></i> and
> <i><code>pow(abs,1.0/n)</code></i> is the nth root of the absolute-value.
> * <p>
> *
> * @param n degree of root
> * @return Collection<Complex> all nth roots of this complex number as a
> Collection
> * @throws IllegalArgumentException if parameter n is negative!
> */
> public Collection<Complex> nthRoot(int n) throws IllegalArgumentException
> {
> if (n <= 0) {
> throw new IllegalArgumentException("The value for the nth root
> has to be positive!");
> }
> Collection<Complex> result = new ArrayList<Complex>();
> // nth root of abs
> double nthRootOfAbs = Math.pow( abs() , 1.0/n );
> // Compute nth roots of complex number with k=0,1,...n-1
> for (int k=0; k<n;k++) {
> // inner part
> double innerPart = (getPhi() + k * 2 * Math.PI) / n;
> double realPart = nthRootOfAbs * Math.cos ( innerPart );
> double imaginaryPart = nthRootOfAbs * Math.sin ( innerPart );
> result.add(createComplex(realPart, imaginaryPart));
> }
> return result;
> }
>
>
> /**
> * To String now returns human readable Form of this complex number
> *
> * @return returns a String of the form "real + i * imaginary"
> */
> public String toString() {
> return getReal() + " + i * " + getImaginary();
> }
>
> {code}
> Unit Test:
> {code:title=org.apache.commons.math.complex.ComplexTest.java|borderStyle=solid}
> /**
> * Test: computing <b>third roots</b> of z.
> * <pre>
> * <code>
> * <b>z = -2 + 2 * i</b>
> * => z_0 = 1 + i
> * => z_1 = -1.3660 + 0.3660 * i
> * => z_2 = 0.3660 - 1.3660 * i
> * </code>
> * </pre>
> */
> public void testNthRoot_normal_thirdRoot() {
> // The complex number we want to compute all third-roots for.
> Complex z = new Complex(-2,2);
> // The List holding all third roots
> Complex[] thirdRootsOfZ = z.nthRoot(3).toArray(new Complex[0]);
> // Returned Collection must not be empty!
> assertEquals(3, thirdRootsOfZ.length);
> // test z_0
> assertEquals(1.0, thirdRootsOfZ[0].getReal(),
> 1.0e-5);
> assertEquals(1.0, thirdRootsOfZ[0].getImaginary(),
> 1.0e-5);
> // test z_1
> assertEquals(-1.3660254037844386, thirdRootsOfZ[1].getReal(),
> 1.0e-5);
> assertEquals(0.36602540378443843, thirdRootsOfZ[1].getImaginary(),
> 1.0e-5);
> // test z_2
> assertEquals(0.366025403784439, thirdRootsOfZ[2].getReal(),
> 1.0e-5);
> assertEquals(-1.3660254037844384, thirdRootsOfZ[2].getImaginary(),
> 1.0e-5);
> }
>
>
> /**
> * Test: computing <b>fourth roots</b> of z.
> * <pre>
> * <code>
> * <b>z = 5 - 2 * i</b>
> * => z_0 = 1.5164 - 0.1446 * i
> * => z_1 = 0.1446 + 1.5164 * i
> * => z_2 = -1.5164 + 0.1446 * i
> * => z_3 = -1.5164 - 0.1446 * i
> * </code>
> * </pre>
> */
> public void testNthRoot_normal_fourthRoot() {
> // The complex number we want to compute all third-roots for.
> Complex z = new Complex(5,-2);
> // The List holding all fourth roots
> Complex[] fourthRootsOfZ = z.nthRoot(4).toArray(new Complex[0]);
> // Returned Collection must not be empty!
> assertEquals(4, fourthRootsOfZ.length);
> // test z_0
> assertEquals(1.5164629308487783, fourthRootsOfZ[0].getReal(),
> 1.0e-5);
> assertEquals(-0.14469266210702247, fourthRootsOfZ[0].getImaginary(),
> 1.0e-5);
> // test z_1
> assertEquals(0.14469266210702256, fourthRootsOfZ[1].getReal(),
> 1.0e-5);
> assertEquals(1.5164629308487783, fourthRootsOfZ[1].getImaginary(),
> 1.0e-5);
> // test z_2
> assertEquals(-1.5164629308487783, fourthRootsOfZ[2].getReal(),
> 1.0e-5);
> assertEquals(0.14469266210702267, fourthRootsOfZ[2].getImaginary(),
> 1.0e-5);
> // test z_3
> assertEquals(-0.14469266210702275, fourthRootsOfZ[3].getReal(),
> 1.0e-5);
> assertEquals(-1.5164629308487783, fourthRootsOfZ[3].getImaginary(),
> 1.0e-5);
> }
>
> /**
> * Test: computing <b>third roots</b> of z.
> * <pre>
> * <code>
> * <b>z = 8</b>
> * => z_0 = 2
> * => z_1 = -1 + 1.73205 * i
> * => z_2 = -1 - 1.73205 * i
> * </code>
> * </pre>
> */
> public void testNthRoot_cornercase_thirdRoot_imaginaryPartEmpty() {
> // The number 8 has three third roots. One we all already know is the
> number 2.
> // But there are two more complex roots.
> Complex z = new Complex(8,0);
> // The List holding all third roots
> Complex[] thirdRootsOfZ = z.nthRoot(3).toArray(new Complex[0]);
> // Returned Collection must not be empty!
> assertEquals(3, thirdRootsOfZ.length);
> // test z_0
> assertEquals(2.0, thirdRootsOfZ[0].getReal(),
> 1.0e-5);
> assertEquals(0.0, thirdRootsOfZ[0].getImaginary(),
> 1.0e-5);
> // test z_1
> assertEquals(-1.0, thirdRootsOfZ[1].getReal(),
> 1.0e-5);
> assertEquals(1.7320508075688774, thirdRootsOfZ[1].getImaginary(),
> 1.0e-5);
> // test z_2
> assertEquals(-1.0, thirdRootsOfZ[2].getReal(),
> 1.0e-5);
> assertEquals(-1.732050807568877, thirdRootsOfZ[2].getImaginary(),
> 1.0e-5);
> }
>
>
> /**
> * Test: computing <b>third roots</b> of z with real part 0.
> * <pre>
> * <code>
> * <b>z = 2 * i</b>
> * => z_0 = 1.0911 + 0.6299 * i
> * => z_1 = -1.0911 + 0.6299 * i
> * => z_2 = -2.3144 - 1.2599 * i
> * </code>
> * </pre>
> */
> public void testNthRoot_cornercase_thirdRoot_realPartEmpty() {
> // complex number with only imaginary part
> Complex z = new Complex(0,2);
> // The List holding all third roots
> Complex[] thirdRootsOfZ = z.nthRoot(3).toArray(new Complex[0]);
> // Returned Collection must not be empty!
> assertEquals(3, thirdRootsOfZ.length);
> // test z_0
> assertEquals(1.0911236359717216, thirdRootsOfZ[0].getReal(),
> 1.0e-5);
> assertEquals(0.6299605249474365, thirdRootsOfZ[0].getImaginary(),
> 1.0e-5);
> // test z_1
> assertEquals(-1.0911236359717216, thirdRootsOfZ[1].getReal(),
> 1.0e-5);
> assertEquals(0.6299605249474365, thirdRootsOfZ[1].getImaginary(),
> 1.0e-5);
> // test z_2
> assertEquals(-2.3144374213981936E-16, thirdRootsOfZ[2].getReal(),
> 1.0e-5);
> assertEquals(-1.2599210498948732, thirdRootsOfZ[2].getImaginary(),
> 1.0e-5);
> }
>
> /**
> * Test cornercases with NaN and Infinity.
> */
> public void testNthRoot_cornercase_NAN_Inf() {
> // third root of z = 1 + NaN * i
> for (Complex c : oneNaN.nthRoot(3)) {
> // both parts should be nan
> assertEquals(nan, c.getReal());
> assertEquals(nan, c.getImaginary());
> }
> // third root of z = inf + NaN * i
> for (Complex c : infNaN.nthRoot(3)) {
> // both parts should be nan
> assertEquals(nan, c.getReal());
> assertEquals(nan, c.getImaginary());
> }
> // third root of z = neginf + 1 * i
> Complex[] zInfOne = negInfOne.nthRoot(2).toArray(new Complex[0]);
> // first root
> assertEquals(inf, zInfOne[0].getReal());
> assertEquals(inf, zInfOne[0].getImaginary());
> // second root
> assertEquals(neginf, zInfOne[1].getReal());
> assertEquals(neginf, zInfOne[1].getImaginary());
> }
> {code}
--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.
