1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
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
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
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
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 }