commons-issues mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From Bernhard Grünewaldt (JIRA) <j...@apache.org>
Subject [jira] Commented: (MATH-236) nth-root of complex numbers
Date Fri, 26 Dec 2008 15:31:44 GMT

    [ https://issues.apache.org/jira/browse/MATH-236?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=12659248#action_12659248
] 

Bernhard Grünewaldt commented on MATH-236:
------------------------------------------

Ok, I provided diffs for Complex.java and ComplexTest.java for the Revision 729499 of the
trunk. (see above)

> 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.


Mime
View raw message