You are viewing a plain text version of this content. The canonical link for it is here.
Posted to issues@commons.apache.org by "Bernhard Grünewaldt (JIRA)" <ji...@apache.org> on 2008/12/26 12:28:44 UTC
[jira] Created: (MATH-236) nth-root of complex numbers
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: 1.3
Reporter: Bernhard Grünewaldt
Fix For: 1.3
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.
* Depending on in which quadrant this complex number lies
* &pi or 2&pi is added. Where x=real and y=imaginary.
*
* 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)
double phi = Math.atan(getImaginary()/getReal());
if (getReal() < 0) {
// II and III-quadrant => phi + pi
phi+=Math.PI;
} else if (getImaginary() <0){
// IV-quadrant => phi + 2 * pi
phi+=2*Math.PI;
}
return phi;
}
/**
* 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 <code>k=0,1,...,n-1</code> and <code>pow( abs , 1.0/n )</code> is the nth root of the absolute-value.
* <p>
*
* @return all nth roots of this complex number as a Collection
*/
public Collection<Complex> nthRoot(int n) {
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
for (int k=0; k<n;k++) {
// inner part
double innerPart = (getPhi() +k*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}
--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.
[jira] Commented: (MATH-236) nth-root of complex numbers
Posted by "Bernhard Grünewaldt (JIRA)" <ji...@apache.org>.
[ 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.
[jira] Commented: (MATH-236) nth-root of complex numbers
Posted by "Luc Maisonobe (JIRA)" <ji...@apache.org>.
[ https://issues.apache.org/jira/browse/MATH-236?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=12659234#action_12659234 ]
Luc Maisonobe commented on MATH-236:
------------------------------------
This is an interesting feature, thanks.
Here are a few comments:
* there won't be any 1.3 version, next version will be 2.0
* could you provide unit tests with your patch ?
* couldn't the getPhi method be implemented simpler using Math.atan2(imaginary, real) ?
> 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: 1.3
> Reporter: Bernhard Grünewaldt
> Fix For: 1.3
>
>
> 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.
> * Depending on in which quadrant this complex number lies
> * &pi or 2&pi is added. Where x=real and y=imaginary.
> *
> * 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)
> double phi = Math.atan(getImaginary()/getReal());
> if (getReal() < 0) {
> // II and III-quadrant => phi + pi
> phi+=Math.PI;
> } else if (getImaginary() <0){
> // IV-quadrant => phi + 2 * pi
> phi+=2*Math.PI;
> }
> return phi;
> }
>
> /**
> * 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 <code>k=0,1,...,n-1</code> and <code>pow( abs , 1.0/n )</code> is the nth root of the absolute-value.
> * <p>
> *
> * @return all nth roots of this complex number as a Collection
> */
> public Collection<Complex> nthRoot(int n) {
> 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
> for (int k=0; k<n;k++) {
> // inner part
> double innerPart = (getPhi() +k*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}
--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.
[jira] Updated: (MATH-236) nth-root of complex numbers
Posted by "Bernhard Grünewaldt (JIRA)" <ji...@apache.org>.
[ https://issues.apache.org/jira/browse/MATH-236?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel ]
Bernhard Grünewaldt updated MATH-236:
-------------------------------------
Fix Version/s: (was: 1.3)
2.0
Affects Version/s: (was: 1.3)
2.0
Ok, I will add a unit Test and use atan2.
I will try to generate a patch.
> 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
>
>
> 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.
> * Depending on in which quadrant this complex number lies
> * &pi or 2&pi is added. Where x=real and y=imaginary.
> *
> * 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)
> double phi = Math.atan(getImaginary()/getReal());
> if (getReal() < 0) {
> // II and III-quadrant => phi + pi
> phi+=Math.PI;
> } else if (getImaginary() <0){
> // IV-quadrant => phi + 2 * pi
> phi+=2*Math.PI;
> }
> return phi;
> }
>
> /**
> * 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 <code>k=0,1,...,n-1</code> and <code>pow( abs , 1.0/n )</code> is the nth root of the absolute-value.
> * <p>
> *
> * @return all nth roots of this complex number as a Collection
> */
> public Collection<Complex> nthRoot(int n) {
> 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
> for (int k=0; k<n;k++) {
> // inner part
> double innerPart = (getPhi() +k*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}
--
This message is automatically generated by JIRA.
-
You can reply to this email to add a comment to the issue online.
[jira] Updated: (MATH-236) nth-root of complex numbers
Posted by "Bernhard Grünewaldt (JIRA)" <ji...@apache.org>.
[ https://issues.apache.org/jira/browse/MATH-236?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel ]
Bernhard Grünewaldt updated MATH-236:
-------------------------------------
Attachment: Complex.java.diff
Diff for org.apache.commons.math.complex.Complex.java
> 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.
[jira] Updated: (MATH-236) nth-root of complex numbers
Posted by "Bernhard Grünewaldt (JIRA)" <ji...@apache.org>.
[ https://issues.apache.org/jira/browse/MATH-236?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel ]
Bernhard Grünewaldt updated MATH-236:
-------------------------------------
Description:
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}
was:
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.
* Depending on in which quadrant this complex number lies
* &pi or 2&pi is added. Where x=real and y=imaginary.
*
* 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)
double phi = Math.atan(getImaginary()/getReal());
if (getReal() < 0) {
// II and III-quadrant => phi + pi
phi+=Math.PI;
} else if (getImaginary() <0){
// IV-quadrant => phi + 2 * pi
phi+=2*Math.PI;
}
return phi;
}
/**
* 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 <code>k=0,1,...,n-1</code> and <code>pow( abs , 1.0/n )</code> is the nth root of the absolute-value.
* <p>
*
* @return all nth roots of this complex number as a Collection
*/
public Collection<Complex> nthRoot(int n) {
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
for (int k=0; k<n;k++) {
// inner part
double innerPart = (getPhi() +k*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}
Now with unit Test and some minor changes.
I will now try to generate a diff and attach it.
> 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
>
>
> 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.
[jira] Updated: (MATH-236) nth-root of complex numbers
Posted by "Bernhard Grünewaldt (JIRA)" <ji...@apache.org>.
[ 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.
[jira] Resolved: (MATH-236) nth-root of complex numbers
Posted by "Luc Maisonobe (JIRA)" <ji...@apache.org>.
[ 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.