1   /*
2    * Licensed to the Apache Software Foundation (ASF) under one or more
3    * contributor license agreements.  See the NOTICE file distributed with
4    * this work for additional information regarding copyright ownership.
5    * The ASF licenses this file to You under the Apache License, Version 2.0
6    * (the "License"); you may not use this file except in compliance with
7    * the License.  You may obtain a copy of the License at
8    * 
9    *      http://www.apache.org/licenses/LICENSE-2.0
10   * 
11   * Unless required by applicable law or agreed to in writing, software
12   * distributed under the License is distributed on an "AS IS" BASIS,
13   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14   * See the License for the specific language governing permissions and
15   * limitations under the License.
16   */
17  
18  package org.apache.commons.math.complex;
19  
20  import org.apache.commons.math.TestUtils;
21  
22  import junit.framework.TestCase;
23  
24  /**
25   * @version $Revision: 610288 $ $Date: 2008-01-09 00:30:13 -0700 (Wed, 09 Jan 2008) $
26   */
27  public class ComplexTest extends TestCase {
28      
29      private double inf = Double.POSITIVE_INFINITY;
30      private double neginf = Double.NEGATIVE_INFINITY;
31      private double nan = Double.NaN;
32      private double pi = Math.PI;
33      private Complex oneInf = new Complex(1, inf);
34      private Complex oneNegInf = new Complex(1, neginf);
35      private Complex infOne = new Complex(inf, 1);
36      private Complex infZero = new Complex(inf, 0);
37      private Complex infNaN = new Complex(inf, nan);
38      private Complex infNegInf = new Complex(inf, neginf);
39      private Complex infInf = new Complex(inf, inf);
40      private Complex negInfInf = new Complex(neginf, inf);
41      private Complex negInfZero = new Complex(neginf, 0);
42      private Complex negInfOne = new Complex(neginf, 1);
43      private Complex negInfNaN = new Complex(neginf, nan);
44      private Complex negInfNegInf = new Complex(neginf, neginf);
45      private Complex oneNaN = new Complex(1, nan);
46      private Complex zeroInf = new Complex(0, inf);
47      private Complex zeroNaN = new Complex(0, nan);
48      private Complex nanInf = new Complex(nan, inf);
49      private Complex nanNegInf = new Complex(nan, neginf);
50      private Complex nanZero = new Complex(nan, 0);
51      
52      public void testConstructor() {
53          Complex z = new Complex(3.0, 4.0);
54          assertEquals(3.0, z.getReal(), 1.0e-5);
55          assertEquals(4.0, z.getImaginary(), 1.0e-5);
56      }
57      
58      public void testConstructorNaN() {
59          Complex z = new Complex(3.0, Double.NaN);
60          assertTrue(z.isNaN());
61  
62          z = new Complex(nan, 4.0);
63          assertTrue(z.isNaN());
64  
65          z = new Complex(3.0, 4.0);
66          assertFalse(z.isNaN());
67      }
68      
69      public void testAbs() {
70          Complex z = new Complex(3.0, 4.0);
71          assertEquals(5.0, z.abs(), 1.0e-5);
72      }
73      
74      public void testAbsNaN() {
75          assertTrue(Double.isNaN(Complex.NaN.abs()));
76          Complex z = new Complex(inf, nan);
77          assertTrue(Double.isNaN(z.abs()));
78      }
79      
80      public void testAbsInfinite() {
81          Complex z = new Complex(inf, 0);
82          assertEquals(inf, z.abs(), 0);
83          z = new Complex(0, neginf);
84          assertEquals(inf, z.abs(), 0);
85          z = new Complex(inf, neginf);
86          assertEquals(inf, z.abs(), 0);     
87      }
88      
89      public void testAdd() {
90          Complex x = new Complex(3.0, 4.0);
91          Complex y = new Complex(5.0, 6.0);
92          Complex z = x.add(y);
93          assertEquals(8.0, z.getReal(), 1.0e-5);
94          assertEquals(10.0, z.getImaginary(), 1.0e-5);
95      }
96      
97      public void testAddNaN() {
98          Complex x = new Complex(3.0, 4.0);
99          Complex z = x.add(Complex.NaN);
100         assertTrue(z.isNaN());
101         z = new Complex(1, nan);
102         Complex w = x.add(z);
103         assertEquals(w.real, 4.0, 0);
104         assertTrue(Double.isNaN(w.imaginary));
105     }
106     
107     public void testAddInfinite() {
108         Complex x = new Complex(1, 1);
109         Complex z = new Complex(inf, 0);
110         Complex w = x.add(z);
111         assertEquals(w.imaginary, 1, 0);
112         assertEquals(inf, w.real, 0);
113         
114         x = new Complex(neginf, 0);
115         assertTrue(Double.isNaN(x.add(z).real));
116     }
117     
118     public void testConjugate() {
119         Complex x = new Complex(3.0, 4.0);
120         Complex z = x.conjugate();
121         assertEquals(3.0, z.getReal(), 1.0e-5);
122         assertEquals(-4.0, z.getImaginary(), 1.0e-5);
123     }
124     
125     public void testConjugateNaN() {
126         Complex z = Complex.NaN.conjugate();
127         assertTrue(z.isNaN());
128     }
129     
130     public void testConjugateInfiinite() {
131         Complex z = new Complex(0, inf);
132         assertEquals(neginf, z.conjugate().imaginary, 0);
133         z = new Complex(0, neginf);
134         assertEquals(inf, z.conjugate().imaginary, 0);
135     }
136     
137     public void testDivide() {
138         Complex x = new Complex(3.0, 4.0);
139         Complex y = new Complex(5.0, 6.0);
140         Complex z = x.divide(y);
141         assertEquals(39.0 / 61.0, z.getReal(), 1.0e-5);
142         assertEquals(2.0 / 61.0, z.getImaginary(), 1.0e-5);
143     }
144     
145     public void testDivideInfinite() {
146         Complex x = new Complex(3, 4);
147         Complex w = new Complex(neginf, inf);
148         assertTrue(x.divide(w).equals(Complex.ZERO));
149         
150         Complex z = w.divide(x);
151         assertTrue(Double.isNaN(z.real));
152         assertEquals(inf, z.imaginary, 0);
153         
154         w = new Complex(inf, inf);
155         z = w.divide(x);
156         assertTrue(Double.isNaN(z.imaginary));
157         assertEquals(inf, z.real, 0);
158         
159         w = new Complex(1, inf);
160         z = w.divide(w);
161         assertTrue(Double.isNaN(z.real));
162         assertTrue(Double.isNaN(z.imaginary));
163     }
164     
165     public void testDivideNaN() {
166         Complex x = new Complex(3.0, 4.0);
167         Complex z = x.divide(Complex.NaN);
168         assertTrue(z.isNaN());
169     }
170     
171     public void testDivideNaNInf() {  
172        Complex z = oneInf.divide(Complex.ONE);
173        assertTrue(Double.isNaN(z.real));
174        assertEquals(inf, z.imaginary, 0);
175        
176        z = negInfNegInf.divide(oneNaN);
177        assertTrue(Double.isNaN(z.real));
178        assertTrue(Double.isNaN(z.imaginary));
179        
180        z = negInfInf.divide(Complex.ONE);
181        assertTrue(Double.isNaN(z.real));
182        assertTrue(Double.isNaN(z.imaginary));
183     }
184     
185     public void testMultiply() {
186         Complex x = new Complex(3.0, 4.0);
187         Complex y = new Complex(5.0, 6.0);
188         Complex z = x.multiply(y);
189         assertEquals(-9.0, z.getReal(), 1.0e-5);
190         assertEquals(38.0, z.getImaginary(), 1.0e-5);
191     }
192     
193     public void testMultiplyNaN() {
194         Complex x = new Complex(3.0, 4.0);
195         Complex z = x.multiply(Complex.NaN);
196         assertTrue(z.isNaN());
197     }
198     
199     public void testMultiplyNaNInf() {
200         Complex z = new Complex(1,1);
201         Complex w = z.multiply(infOne);
202         assertEquals(w.real, inf, 0);
203         assertEquals(w.imaginary, inf, 0);
204 
205         // [MATH-164]
206         assertTrue(new Complex( 1,0).multiply(infInf).equals(Complex.INF));
207         assertTrue(new Complex(-1,0).multiply(infInf).equals(Complex.INF));
208         assertTrue(new Complex( 1,0).multiply(negInfZero).equals(Complex.INF));
209         
210         w = oneInf.multiply(oneNegInf);
211         assertEquals(w.real, inf, 0);
212         assertEquals(w.imaginary, inf, 0);
213         
214         w = negInfNegInf.multiply(oneNaN);
215         assertTrue(Double.isNaN(w.real));
216         assertTrue(Double.isNaN(w.imaginary));  
217     }
218     
219     public void testNegate() {
220         Complex x = new Complex(3.0, 4.0);
221         Complex z = x.negate();
222         assertEquals(-3.0, z.getReal(), 1.0e-5);
223         assertEquals(-4.0, z.getImaginary(), 1.0e-5);
224     }
225     
226     public void testNegateNaN() {
227         Complex z = Complex.NaN.negate();
228         assertTrue(z.isNaN());
229     }
230     
231     public void testSubtract() {
232         Complex x = new Complex(3.0, 4.0);
233         Complex y = new Complex(5.0, 6.0);
234         Complex z = x.subtract(y);
235         assertEquals(-2.0, z.getReal(), 1.0e-5);
236         assertEquals(-2.0, z.getImaginary(), 1.0e-5);
237     }
238     
239     public void testSubtractNaN() {
240         Complex x = new Complex(3.0, 4.0);
241         Complex z = x.subtract(Complex.NaN);
242         assertTrue(z.isNaN());
243     }
244     
245     public void testEqualsNull() {
246         Complex x = new Complex(3.0, 4.0);
247         assertFalse(x.equals(null));
248     }
249     
250     public void testEqualsClass() {
251         Complex x = new Complex(3.0, 4.0);
252         assertFalse(x.equals(this));
253     }
254     
255     public void testEqualsSame() {
256         Complex x = new Complex(3.0, 4.0);
257         assertTrue(x.equals(x));
258     }
259     
260     public void testEqualsTrue() {
261         Complex x = new Complex(3.0, 4.0);
262         Complex y = new Complex(3.0, 4.0);
263         assertTrue(x.equals(y));
264     }
265     
266     public void testEqualsRealDifference() {
267         Complex x = new Complex(0.0, 0.0);
268         Complex y = new Complex(0.0 + Double.MIN_VALUE, 0.0);
269         assertFalse(x.equals(y));
270     }
271     
272     public void testEqualsImaginaryDifference() {
273         Complex x = new Complex(0.0, 0.0);
274         Complex y = new Complex(0.0, 0.0 + Double.MIN_VALUE);
275         assertFalse(x.equals(y));
276     }
277     
278     public void testEqualsNaN() {
279         Complex realNaN = new Complex(Double.NaN, 0.0);
280         Complex imaginaryNaN = new Complex(0.0, Double.NaN);
281         Complex complexNaN = Complex.NaN;
282         assertTrue(realNaN.equals(imaginaryNaN));
283         assertTrue(imaginaryNaN.equals(complexNaN));
284         assertTrue(realNaN.equals(complexNaN));
285     }
286     
287     public void testHashCode() {
288         Complex x = new Complex(0.0, 0.0);
289         Complex y = new Complex(0.0, 0.0 + Double.MIN_VALUE);
290         assertFalse(x.hashCode()==y.hashCode());
291         y = new Complex(0.0 + Double.MIN_VALUE, 0.0);
292         assertFalse(x.hashCode()==y.hashCode());
293         Complex realNaN = new Complex(Double.NaN, 0.0);
294         Complex imaginaryNaN = new Complex(0.0, Double.NaN);
295         assertEquals(realNaN.hashCode(), imaginaryNaN.hashCode());
296         assertEquals(imaginaryNaN.hashCode(), Complex.NaN.hashCode());
297     }
298     
299     public void testAcos() {
300         Complex z = new Complex(3, 4);
301         Complex expected = new Complex(0.936812, -2.30551);
302         TestUtils.assertEquals(expected, z.acos(), 1.0e-5);
303         TestUtils.assertEquals(new Complex(Math.acos(0), 0), 
304                 Complex.ZERO.acos(), 1.0e-12);
305     }
306     
307     public void testAcosInf() {
308         TestUtils.assertSame(Complex.NaN, oneInf.acos());
309         TestUtils.assertSame(Complex.NaN, oneNegInf.acos());
310         TestUtils.assertSame(Complex.NaN, infOne.acos());
311         TestUtils.assertSame(Complex.NaN, negInfOne.acos());
312         TestUtils.assertSame(Complex.NaN, infInf.acos());
313         TestUtils.assertSame(Complex.NaN, infNegInf.acos());
314         TestUtils.assertSame(Complex.NaN, negInfInf.acos());
315         TestUtils.assertSame(Complex.NaN, negInfNegInf.acos());
316     }
317     
318     public void testAcosNaN() {
319         assertTrue(Complex.NaN.acos().isNaN());
320     }
321     
322     public void testAsin() {
323         Complex z = new Complex(3, 4);
324         Complex expected = new Complex(0.633984, 2.30551);
325         TestUtils.assertEquals(expected, z.asin(), 1.0e-5);
326     }
327     
328     public void testAsinNaN() {
329         assertTrue(Complex.NaN.asin().isNaN());
330     }
331     
332     public void testAsinInf() {
333         TestUtils.assertSame(Complex.NaN, oneInf.asin());
334         TestUtils.assertSame(Complex.NaN, oneNegInf.asin());
335         TestUtils.assertSame(Complex.NaN, infOne.asin());
336         TestUtils.assertSame(Complex.NaN, negInfOne.asin());
337         TestUtils.assertSame(Complex.NaN, infInf.asin());
338         TestUtils.assertSame(Complex.NaN, infNegInf.asin());
339         TestUtils.assertSame(Complex.NaN, negInfInf.asin());
340         TestUtils.assertSame(Complex.NaN, negInfNegInf.asin());
341     }
342     
343    
344     public void testAtan() {
345         Complex z = new Complex(3, 4);
346         Complex expected = new Complex(1.44831, 0.158997);
347         TestUtils.assertEquals(expected, z.atan(), 1.0e-5);
348     }
349     
350     public void testAtanInf() {
351         TestUtils.assertSame(Complex.NaN, oneInf.atan());
352         TestUtils.assertSame(Complex.NaN, oneNegInf.atan());
353         TestUtils.assertSame(Complex.NaN, infOne.atan());
354         TestUtils.assertSame(Complex.NaN, negInfOne.atan());
355         TestUtils.assertSame(Complex.NaN, infInf.atan());
356         TestUtils.assertSame(Complex.NaN, infNegInf.atan());
357         TestUtils.assertSame(Complex.NaN, negInfInf.atan());
358         TestUtils.assertSame(Complex.NaN, negInfNegInf.atan());
359     } 
360     
361     public void testAtanNaN() {
362         assertTrue(Complex.NaN.atan().isNaN());
363         assertTrue(Complex.I.atan().isNaN());
364     }
365     
366     public void testCos() {
367         Complex z = new Complex(3, 4);
368         Complex expected = new Complex(-27.03495, -3.851153);
369         TestUtils.assertEquals(expected, z.cos(), 1.0e-5);
370     }
371     
372     public void testCosNaN() {
373         assertTrue(Complex.NaN.cos().isNaN());
374     }
375     
376     public void testCosInf() {
377         TestUtils.assertSame(infNegInf, oneInf.cos());
378         TestUtils.assertSame(infInf, oneNegInf.cos());
379         TestUtils.assertSame(Complex.NaN, infOne.cos());
380         TestUtils.assertSame(Complex.NaN, negInfOne.cos());
381         TestUtils.assertSame(Complex.NaN, infInf.cos());
382         TestUtils.assertSame(Complex.NaN, infNegInf.cos());
383         TestUtils.assertSame(Complex.NaN, negInfInf.cos());
384         TestUtils.assertSame(Complex.NaN, negInfNegInf.cos());
385     } 
386     
387     public void testCosh() {
388         Complex z = new Complex(3, 4);
389         Complex expected = new Complex(-6.58066, -7.58155);
390         TestUtils.assertEquals(expected, z.cosh(), 1.0e-5);
391     }
392     
393     public void testCoshNaN() {
394         assertTrue(Complex.NaN.cosh().isNaN());
395     }
396     
397     public void testCoshInf() {  
398         TestUtils.assertSame(Complex.NaN, oneInf.cosh());
399         TestUtils.assertSame(Complex.NaN, oneNegInf.cosh());
400         TestUtils.assertSame(infInf, infOne.cosh());
401         TestUtils.assertSame(infNegInf, negInfOne.cosh());
402         TestUtils.assertSame(Complex.NaN, infInf.cosh());
403         TestUtils.assertSame(Complex.NaN, infNegInf.cosh());
404         TestUtils.assertSame(Complex.NaN, negInfInf.cosh());
405         TestUtils.assertSame(Complex.NaN, negInfNegInf.cosh());
406     } 
407     
408     public void testExp() {
409         Complex z = new Complex(3, 4);
410         Complex expected = new Complex(-13.12878, -15.20078);
411         TestUtils.assertEquals(expected, z.exp(), 1.0e-5);
412         TestUtils.assertEquals(Complex.ONE, 
413                 Complex.ZERO.exp(), 10e-12);
414         Complex iPi = Complex.I.multiply(new Complex(pi,0));
415         TestUtils.assertEquals(Complex.ONE.negate(), 
416                 iPi.exp(), 10e-12);
417     }
418     
419     public void testExpNaN() {
420         assertTrue(Complex.NaN.exp().isNaN());
421     }
422     
423     public void testExpInf() {
424         TestUtils.assertSame(Complex.NaN, oneInf.exp());
425         TestUtils.assertSame(Complex.NaN, oneNegInf.exp());
426         TestUtils.assertSame(infInf, infOne.exp());
427         TestUtils.assertSame(Complex.ZERO, negInfOne.exp());
428         TestUtils.assertSame(Complex.NaN, infInf.exp());
429         TestUtils.assertSame(Complex.NaN, infNegInf.exp());
430         TestUtils.assertSame(Complex.NaN, negInfInf.exp());
431         TestUtils.assertSame(Complex.NaN, negInfNegInf.exp());
432     }
433     
434     public void testLog() {
435         Complex z = new Complex(3, 4);
436         Complex expected = new Complex(1.60944, 0.927295);
437         TestUtils.assertEquals(expected, z.log(), 1.0e-5);
438     }
439     
440     public void testLogNaN() {
441         assertTrue(Complex.NaN.log().isNaN());
442     }
443     
444     public void testLogInf() {
445         TestUtils.assertEquals(new Complex(inf, pi / 2),
446                 oneInf.log(), 10e-12);
447         TestUtils.assertEquals(new Complex(inf, -pi / 2),
448                 oneNegInf.log(), 10e-12);
449         TestUtils.assertEquals(infZero, infOne.log(), 10e-12);
450         TestUtils.assertEquals(new Complex(inf, pi),
451                 negInfOne.log(), 10e-12);
452         TestUtils.assertEquals(new Complex(inf, pi / 4),
453                 infInf.log(), 10e-12);
454         TestUtils.assertEquals(new Complex(inf, -pi / 4),
455                 infNegInf.log(), 10e-12);
456         TestUtils.assertEquals(new Complex(inf, 3d * pi / 4),
457                 negInfInf.log(), 10e-12);
458         TestUtils.assertEquals(new Complex(inf, - 3d * pi / 4),
459                 negInfNegInf.log(), 10e-12);
460     }
461     
462     public void testLogZero() {
463         TestUtils.assertSame(negInfZero, Complex.ZERO.log());
464     }
465     
466     public void testPow() {
467         Complex x = new Complex(3, 4);
468         Complex y = new Complex(5, 6);
469         Complex expected = new Complex(-1.860893, 11.83677);
470         TestUtils.assertEquals(expected, x.pow(y), 1.0e-5);
471     }
472     
473     public void testPowNaNBase() {
474         Complex x = new Complex(3, 4);
475         assertTrue(Complex.NaN.pow(x).isNaN());
476     }
477     
478     public void testPowNaNExponent() {
479         Complex x = new Complex(3, 4);
480         assertTrue(x.pow(Complex.NaN).isNaN());
481     }
482     
483    public void testPowInf() {
484        TestUtils.assertSame(Complex.NaN,Complex.ONE.pow(oneInf));
485        TestUtils.assertSame(Complex.NaN,Complex.ONE.pow(oneNegInf));
486        TestUtils.assertSame(Complex.NaN,Complex.ONE.pow(infOne));
487        TestUtils.assertSame(Complex.NaN,Complex.ONE.pow(infInf));
488        TestUtils.assertSame(Complex.NaN,Complex.ONE.pow(infNegInf));
489        TestUtils.assertSame(Complex.NaN,Complex.ONE.pow(negInfInf));
490        TestUtils.assertSame(Complex.NaN,Complex.ONE.pow(negInfNegInf));
491        TestUtils.assertSame(Complex.NaN,infOne.pow(Complex.ONE));
492        TestUtils.assertSame(Complex.NaN,negInfOne.pow(Complex.ONE));
493        TestUtils.assertSame(Complex.NaN,infInf.pow(Complex.ONE));
494        TestUtils.assertSame(Complex.NaN,infNegInf.pow(Complex.ONE));
495        TestUtils.assertSame(Complex.NaN,negInfInf.pow(Complex.ONE));
496        TestUtils.assertSame(Complex.NaN,negInfNegInf.pow(Complex.ONE));
497        TestUtils.assertSame(Complex.NaN,negInfNegInf.pow(infNegInf));
498        TestUtils.assertSame(Complex.NaN,negInfNegInf.pow(negInfNegInf));
499        TestUtils.assertSame(Complex.NaN,negInfNegInf.pow(infInf));
500        TestUtils.assertSame(Complex.NaN,infInf.pow(infNegInf));
501        TestUtils.assertSame(Complex.NaN,infInf.pow(negInfNegInf));
502        TestUtils.assertSame(Complex.NaN,infInf.pow(infInf));
503        TestUtils.assertSame(Complex.NaN,infNegInf.pow(infNegInf));
504        TestUtils.assertSame(Complex.NaN,infNegInf.pow(negInfNegInf));
505        TestUtils.assertSame(Complex.NaN,infNegInf.pow(infInf));   
506    }
507    
508    public void testPowZero() {
509        TestUtils.assertSame(Complex.NaN, 
510                Complex.ZERO.pow(Complex.ONE));
511        TestUtils.assertSame(Complex.NaN, 
512                Complex.ZERO.pow(Complex.ZERO));
513        TestUtils.assertSame(Complex.NaN, 
514                Complex.ZERO.pow(Complex.I));
515        TestUtils.assertEquals(Complex.ONE,
516                Complex.ONE.pow(Complex.ZERO), 10e-12);
517        TestUtils.assertEquals(Complex.ONE,
518                Complex.I.pow(Complex.ZERO), 10e-12);
519        TestUtils.assertEquals(Complex.ONE,
520                new Complex(-1, 3).pow(Complex.ZERO), 10e-12);
521    }
522     
523     public void testpowNull() {
524         try {
525             Complex.ONE.pow(null); 
526             fail("Expecting NullPointerException");
527         } catch (NullPointerException ex) {
528             // expected
529         }
530     }
531     
532     public void testSin() {
533         Complex z = new Complex(3, 4);
534         Complex expected = new Complex(3.853738, -27.01681);
535         TestUtils.assertEquals(expected, z.sin(), 1.0e-5);
536     }
537     
538     public void testSinInf() {
539         TestUtils.assertSame(infInf, oneInf.sin());
540         TestUtils.assertSame(infNegInf, oneNegInf.sin());
541         TestUtils.assertSame(Complex.NaN, infOne.sin());
542         TestUtils.assertSame(Complex.NaN, negInfOne.sin());
543         TestUtils.assertSame(Complex.NaN, infInf.sin());
544         TestUtils.assertSame(Complex.NaN, infNegInf.sin());
545         TestUtils.assertSame(Complex.NaN, negInfInf.sin());
546         TestUtils.assertSame(Complex.NaN, negInfNegInf.sin());
547     }
548     
549     public void testSinNaN() {
550         assertTrue(Complex.NaN.sin().isNaN());
551     }
552     
553     public void testSinh() {
554         Complex z = new Complex(3, 4);
555         Complex expected = new Complex(-6.54812, -7.61923);
556         TestUtils.assertEquals(expected, z.sinh(), 1.0e-5);
557     }
558     
559     public void testSinhNaN() {
560         assertTrue(Complex.NaN.sinh().isNaN());
561     }
562     
563     public void testSinhInf() {
564         TestUtils.assertSame(Complex.NaN, oneInf.sinh());
565         TestUtils.assertSame(Complex.NaN, oneNegInf.sinh());
566         TestUtils.assertSame(infInf, infOne.sinh());
567         TestUtils.assertSame(negInfInf, negInfOne.sinh());
568         TestUtils.assertSame(Complex.NaN, infInf.sinh());
569         TestUtils.assertSame(Complex.NaN, infNegInf.sinh());
570         TestUtils.assertSame(Complex.NaN, negInfInf.sinh());
571         TestUtils.assertSame(Complex.NaN, negInfNegInf.sinh());
572     }
573     
574     public void testSqrtRealPositive() {
575         Complex z = new Complex(3, 4);
576         Complex expected = new Complex(2, 1);
577         TestUtils.assertEquals(expected, z.sqrt(), 1.0e-5);
578     }
579     
580     public void testSqrtRealZero() {
581         Complex z = new Complex(0.0, 4);
582         Complex expected = new Complex(1.41421, 1.41421);
583         TestUtils.assertEquals(expected, z.sqrt(), 1.0e-5);
584     }
585     
586     public void testSqrtRealNegative() {
587         Complex z = new Complex(-3.0, 4);
588         Complex expected = new Complex(1, 2);
589         TestUtils.assertEquals(expected, z.sqrt(), 1.0e-5);
590     }
591     
592     public void testSqrtImaginaryZero() {
593         Complex z = new Complex(-3.0, 0.0);
594         Complex expected = new Complex(0.0, 1.73205);
595         TestUtils.assertEquals(expected, z.sqrt(), 1.0e-5);
596     }
597     
598     public void testSqrtImaginaryNegative() {
599         Complex z = new Complex(-3.0, -4.0);
600         Complex expected = new Complex(1.0, -2.0);
601         TestUtils.assertEquals(expected, z.sqrt(), 1.0e-5);
602     }
603     
604     public void testSqrtPolar() {
605         double r = 1;
606         for (int i = 0; i < 5; i++) {
607             r += i;
608             double theta = 0;
609             for (int j =0; j < 11; j++) {
610                 theta += pi /12;
611                 Complex z = ComplexUtils.polar2Complex(r, theta);
612                 Complex sqrtz = ComplexUtils.polar2Complex(Math.sqrt(r), theta / 2);
613                 TestUtils.assertEquals(sqrtz, z.sqrt(), 10e-12);
614             }
615         }       
616     }
617     
618     public void testSqrtNaN() {
619         assertTrue(Complex.NaN.sqrt().isNaN());
620     }
621       
622     public void testSqrtInf() {
623         TestUtils.assertSame(infNaN, oneInf.sqrt());
624         TestUtils.assertSame(infNaN, oneNegInf.sqrt());
625         TestUtils.assertSame(infZero, infOne.sqrt());
626         TestUtils.assertSame(zeroInf, negInfOne.sqrt());
627         TestUtils.assertSame(infNaN, infInf.sqrt());
628         TestUtils.assertSame(infNaN, infNegInf.sqrt());
629         TestUtils.assertSame(nanInf, negInfInf.sqrt());
630         TestUtils.assertSame(nanNegInf, negInfNegInf.sqrt());
631     }
632     
633     public void testSqrt1z() {
634         Complex z = new Complex(3, 4);
635         Complex expected = new Complex(4.08033, -2.94094);
636         TestUtils.assertEquals(expected, z.sqrt1z(), 1.0e-5);
637     }
638     
639     public void testSqrt1zNaN() {
640         assertTrue(Complex.NaN.sqrt1z().isNaN());
641     }
642     
643     public void testTan() {
644         Complex z = new Complex(3, 4);
645         Complex expected = new Complex(-0.000187346, 0.999356);
646         TestUtils.assertEquals(expected, z.tan(), 1.0e-5);
647     }
648     
649     public void testTanNaN() {
650         assertTrue(Complex.NaN.tan().isNaN());
651     }
652     
653     public void testTanInf() {
654         TestUtils.assertSame(zeroNaN, oneInf.tan());
655         TestUtils.assertSame(zeroNaN, oneNegInf.tan());
656         TestUtils.assertSame(Complex.NaN, infOne.tan());
657         TestUtils.assertSame(Complex.NaN, negInfOne.tan());
658         TestUtils.assertSame(Complex.NaN, infInf.tan());
659         TestUtils.assertSame(Complex.NaN, infNegInf.tan());
660         TestUtils.assertSame(Complex.NaN, negInfInf.tan());
661         TestUtils.assertSame(Complex.NaN, negInfNegInf.tan());
662     }
663     
664    public void testTanCritical() {
665         TestUtils.assertSame(infNaN, new Complex(pi/2, 0).tan());
666         TestUtils.assertSame(negInfNaN, new Complex(-pi/2, 0).tan());
667     }
668     
669     public void testTanh() {
670         Complex z = new Complex(3, 4);
671         Complex expected = new Complex(1.00071, 0.00490826);
672         TestUtils.assertEquals(expected, z.tanh(), 1.0e-5);
673     }
674     
675     public void testTanhNaN() {
676         assertTrue(Complex.NaN.tanh().isNaN());
677     }
678     
679     public void testTanhInf() {
680         TestUtils.assertSame(Complex.NaN, oneInf.tanh());
681         TestUtils.assertSame(Complex.NaN, oneNegInf.tanh());
682         TestUtils.assertSame(nanZero, infOne.tanh());
683         TestUtils.assertSame(nanZero, negInfOne.tanh());
684         TestUtils.assertSame(Complex.NaN, infInf.tanh());
685         TestUtils.assertSame(Complex.NaN, infNegInf.tanh());
686         TestUtils.assertSame(Complex.NaN, negInfInf.tanh());
687         TestUtils.assertSame(Complex.NaN, negInfNegInf.tanh());
688     }
689     
690     public void testTanhCritical() {
691         TestUtils.assertSame(nanInf, new Complex(0, pi/2).tanh());
692     }
693 }