You are viewing a plain text version of this content. The canonical link for it is here.
Posted to issues@commons.apache.org by "Luc Maisonobe (JIRA)" <ji...@apache.org> on 2008/12/27 17:28:46 UTC
[jira] Resolved: (MATH-236) nth-root of complex numbers
[ https://issues.apache.org/jira/browse/MATH-236?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel ]
Luc Maisonobe resolved MATH-236.
--------------------------------
Resolution: Fixed
fixed in trunk as of r729639
The patch has been applied with small changes (no tabs, moved computation of phi out of the loop.
The toString method has been removed as their is a dedicated class for displaying complex numbers (ComplexFormat)
> 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.