tablepress / libraries / vendor / Complex / Functions.php

Functions.php in TablePress – Tables in WordPress made easy 2.0.4, at libraries/vendor/Complex/Functions.php

806 lines 27.5 KB

Raw Download Zip

1	<?php
2
3	namespace TablePress\Complex;
4
5	use InvalidArgumentException;
6
7	class Functions
8	{
9	/**
10	* Returns the absolute value (modulus) of a complex number.
11	* Also known as the rho of the complex number, i.e. the distance/radius
12	* from the centrepoint to the representation of the number in polar coordinates.
13	*
14	* This function is a synonym for rho()
15	*
16	* @param TablePress\Complex\|mixed $complex TablePress\Complex number or a numeric value.
17	* @return float The absolute (or rho) value of the complex argument.
18	* @throws Exception If argument isn't a valid real or complex number.
19	*
20	* @see rho
21	*
22	*/
23	public static function abs($complex): float
24	{
25	return self::rho($complex);
26	}
27
28	/**
29	* Returns the inverse cosine of a complex number.
30	*
31	* @param TablePress\Complex\|mixed $complex TablePress\Complex number or a numeric value.
32	* @return TablePress\Complex The inverse cosine of the complex argument.
33	* @throws Exception If argument isn't a valid real or complex number.
34	*/
35	public static function acos($complex): TablePress\Complex
36	{
37	$complex = Complex::validateComplexArgument($complex);
38
39	$square = clone $complex;
40	$square = Operations::multiply($square, $complex);
41	$invsqrt = new Complex(1.0);
42	$invsqrt = Operations::subtract($invsqrt, $square);
43	$invsqrt = self::sqrt($invsqrt);
44	$adjust = new Complex(
45	$complex->getReal() - $invsqrt->getImaginary(),
46	$complex->getImaginary() + $invsqrt->getReal()
47	);
48	$log = self::ln($adjust);
49
50	return new Complex(
51	$log->getImaginary(),
52	-1 * $log->getReal()
53	);
54	}
55
56	/**
57	* Returns the inverse hyperbolic cosine of a complex number.
58	*
59	* @param TablePress\Complex\|mixed $complex TablePress\Complex number or a numeric value.
60	* @return TablePress\Complex The inverse hyperbolic cosine of the complex argument.
61	* @throws Exception If argument isn't a valid real or complex number.
62	*/
63	public static function acosh($complex): TablePress\Complex
64	{
65	$complex = Complex::validateComplexArgument($complex);
66
67	if ($complex->isReal() && ($complex->getReal() > 1)) {
68	return new Complex(\acosh($complex->getReal()));
69	}
70
71	$acosh = self::acos($complex)
72	->reverse();
73	if ($acosh->getReal() < 0.0) {
74	$acosh = $acosh->invertReal();
75	}
76
77	return $acosh;
78	}
79
80	/**
81	* Returns the inverse cotangent of a complex number.
82	*
83	* @param TablePress\Complex\|mixed $complex TablePress\Complex number or a numeric value.
84	* @return TablePress\Complex The inverse cotangent of the complex argument.
85	* @throws Exception If argument isn't a valid real or complex number.
86	* @throws \InvalidArgumentException If function would result in a division by zero
87	*/
88	public static function acot($complex): TablePress\Complex
89	{
90	$complex = Complex::validateComplexArgument($complex);
91
92	return self::atan(self::inverse($complex));
93	}
94
95	/**
96	* Returns the inverse hyperbolic cotangent of a complex number.
97	*
98	* @param TablePress\Complex\|mixed $complex TablePress\Complex number or a numeric value.
99	* @return TablePress\Complex The inverse hyperbolic cotangent of the complex argument.
100	* @throws Exception If argument isn't a valid real or complex number.
101	* @throws \InvalidArgumentException If function would result in a division by zero
102	*/
103	public static function acoth($complex): TablePress\Complex
104	{
105	$complex = Complex::validateComplexArgument($complex);
106
107	return self::atanh(self::inverse($complex));
108	}
109
110	/**
111	* Returns the inverse cosecant of a complex number.
112	*
113	* @param TablePress\Complex\|mixed $complex TablePress\Complex number or a numeric value.
114	* @return TablePress\Complex The inverse cosecant of the complex argument.
115	* @throws Exception If argument isn't a valid real or complex number.
116	* @throws \InvalidArgumentException If function would result in a division by zero
117	*/
118	public static function acsc($complex): TablePress\Complex
119	{
120	$complex = Complex::validateComplexArgument($complex);
121
122	if ($complex->getReal() == 0.0 && $complex->getImaginary() == 0.0) {
123	return new Complex(INF);
124	}
125
126	return self::asin(self::inverse($complex));
127	}
128
129	/**
130	* Returns the inverse hyperbolic cosecant of a complex number.
131	*
132	* @param TablePress\Complex\|mixed $complex TablePress\Complex number or a numeric value.
133	* @return TablePress\Complex The inverse hyperbolic cosecant of the complex argument.
134	* @throws Exception If argument isn't a valid real or complex number.
135	* @throws \InvalidArgumentException If function would result in a division by zero
136	*/
137	public static function acsch($complex): TablePress\Complex
138	{
139	$complex = Complex::validateComplexArgument($complex);
140
141	if ($complex->getReal() == 0.0 && $complex->getImaginary() == 0.0) {
142	return new Complex(INF);
143	}
144
145	return self::asinh(self::inverse($complex));
146	}
147
148	/**
149	* Returns the argument of a complex number.
150	* Also known as the theta of the complex number, i.e. the angle in radians
151	* from the real axis to the representation of the number in polar coordinates.
152	*
153	* This function is a synonym for theta()
154	*
155	* @param TablePress\Complex\|mixed $complex TablePress\Complex number or a numeric value.
156	* @return float The argument (or theta) value of the complex argument.
157	* @throws Exception If argument isn't a valid real or complex number.
158	*
159	* @see theta
160	*/
161	public static function argument($complex): float
162	{
163	return self::theta($complex);
164	}
165
166	/**
167	* Returns the inverse secant of a complex number.
168	*
169	* @param TablePress\Complex\|mixed $complex TablePress\Complex number or a numeric value.
170	* @return TablePress\Complex The inverse secant of the complex argument.
171	* @throws Exception If argument isn't a valid real or complex number.
172	* @throws \InvalidArgumentException If function would result in a division by zero
173	*/
174	public static function asec($complex): TablePress\Complex
175	{
176	$complex = Complex::validateComplexArgument($complex);
177
178	if ($complex->getReal() == 0.0 && $complex->getImaginary() == 0.0) {
179	return new Complex(INF);
180	}
181
182	return self::acos(self::inverse($complex));
183	}
184
185	/**
186	* Returns the inverse hyperbolic secant of a complex number.
187	*
188	* @param TablePress\Complex\|mixed $complex TablePress\Complex number or a numeric value.
189	* @return TablePress\Complex The inverse hyperbolic secant of the complex argument.
190	* @throws Exception If argument isn't a valid real or complex number.
191	* @throws \InvalidArgumentException If function would result in a division by zero
192	*/
193	public static function asech($complex): TablePress\Complex
194	{
195	$complex = Complex::validateComplexArgument($complex);
196
197	if ($complex->getReal() == 0.0 && $complex->getImaginary() == 0.0) {
198	return new Complex(INF);
199	}
200
201	return self::acosh(self::inverse($complex));
202	}
203
204	/**
205	* Returns the inverse sine of a complex number.
206	*
207	* @param TablePress\Complex\|mixed $complex TablePress\Complex number or a numeric value.
208	* @return TablePress\Complex The inverse sine of the complex argument.
209	* @throws Exception If argument isn't a valid real or complex number.
210	*/
211	public static function asin($complex): TablePress\Complex
212	{
213	$complex = Complex::validateComplexArgument($complex);
214
215	$square = Operations::multiply($complex, $complex);
216	$invsqrt = new Complex(1.0);
217	$invsqrt = Operations::subtract($invsqrt, $square);
218	$invsqrt = self::sqrt($invsqrt);
219	$adjust = new Complex(
220	$invsqrt->getReal() - $complex->getImaginary(),
221	$invsqrt->getImaginary() + $complex->getReal()
222	);
223	$log = self::ln($adjust);
224
225	return new Complex(
226	$log->getImaginary(),
227	-1 * $log->getReal()
228	);
229	}
230
231	/**
232	* Returns the inverse hyperbolic sine of a complex number.
233	*
234	* @param TablePress\Complex\|mixed $complex TablePress\Complex number or a numeric value.
235	* @return TablePress\Complex The inverse hyperbolic sine of the complex argument.
236	* @throws Exception If argument isn't a valid real or complex number.
237	*/
238	public static function asinh($complex): TablePress\Complex
239	{
240	$complex = Complex::validateComplexArgument($complex);
241
242	if ($complex->isReal() && ($complex->getReal() > 1)) {
243	return new Complex(\asinh($complex->getReal()));
244	}
245
246	$asinh = clone $complex;
247	$asinh = $asinh->reverse()
248	->invertReal();
249	$asinh = self::asin($asinh);
250
251	return $asinh->reverse()
252	->invertImaginary();
253	}
254
255	/**
256	* Returns the inverse tangent of a complex number.
257	*
258	* @param TablePress\Complex\|mixed $complex TablePress\Complex number or a numeric value.
259	* @return TablePress\Complex The inverse tangent of the complex argument.
260	* @throws Exception If argument isn't a valid real or complex number.
261	* @throws \InvalidArgumentException If function would result in a division by zero
262	*/
263	public static function atan($complex): TablePress\Complex
264	{
265	$complex = Complex::validateComplexArgument($complex);
266
267	if ($complex->isReal()) {
268	return new Complex(\atan($complex->getReal()));
269	}
270
271	$t1Value = new Complex(-1 * $complex->getImaginary(), $complex->getReal());
272	$uValue = new Complex(1, 0);
273
274	$d1Value = clone $uValue;
275	$d1Value = Operations::subtract($d1Value, $t1Value);
276	$d2Value = Operations::add($t1Value, $uValue);
277	$uResult = $d1Value->divideBy($d2Value);
278	$uResult = self::ln($uResult);
279
280	return new Complex(
281	(($uResult->getImaginary() == M_PI) ? -M_PI : $uResult->getImaginary()) * -0.5,
282	$uResult->getReal() * 0.5,
283	$complex->getSuffix()
284	);
285	}
286
287	/**
288	* Returns the inverse hyperbolic tangent of a complex number.
289	*
290	* @param TablePress\Complex\|mixed $complex TablePress\Complex number or a numeric value.
291	* @return TablePress\Complex The inverse hyperbolic tangent of the complex argument.
292	* @throws Exception If argument isn't a valid real or complex number.
293	*/
294	public static function atanh($complex): TablePress\Complex
295	{
296	$complex = Complex::validateComplexArgument($complex);
297
298	if ($complex->isReal()) {
299	$real = $complex->getReal();
300	if ($real >= -1.0 && $real <= 1.0) {
301	return new Complex(\atanh($real));
302	} else {
303	return new Complex(\atanh(1 / $real), (($real < 0.0) ? M_PI_2 : -1 * M_PI_2));
304	}
305	}
306
307	$iComplex = clone $complex;
308	$iComplex = $iComplex->invertImaginary()
309	->reverse();
310	return self::atan($iComplex)
311	->invertReal()
312	->reverse();
313	}
314
315	/**
316	* Returns the complex conjugate of a complex number
317	*
318	* @param TablePress\Complex\|mixed $complex TablePress\Complex number or a numeric value.
319	* @return TablePress\Complex The conjugate of the complex argument.
320	* @throws Exception If argument isn't a valid real or complex number.
321	*/
322	public static function conjugate($complex): TablePress\Complex
323	{
324	$complex = Complex::validateComplexArgument($complex);
325
326	return new Complex(
327	$complex->getReal(),
328	-1 * $complex->getImaginary(),
329	$complex->getSuffix()
330	);
331	}
332
333	/**
334	* Returns the cosine of a complex number.
335	*
336	* @param TablePress\Complex\|mixed $complex TablePress\Complex number or a numeric value.
337	* @return TablePress\Complex The cosine of the complex argument.
338	* @throws Exception If argument isn't a valid real or complex number.
339	*/
340	public static function cos($complex): TablePress\Complex
341	{
342	$complex = Complex::validateComplexArgument($complex);
343
344	if ($complex->isReal()) {
345	return new Complex(\cos($complex->getReal()));
346	}
347
348	return self::conjugate(
349	new Complex(
350	\cos($complex->getReal()) * \cosh($complex->getImaginary()),
351	\sin($complex->getReal()) * \sinh($complex->getImaginary()),
352	$complex->getSuffix()
353	)
354	);
355	}
356
357	/**
358	* Returns the hyperbolic cosine of a complex number.
359	*
360	* @param TablePress\Complex\|mixed $complex TablePress\Complex number or a numeric value.
361	* @return TablePress\Complex The hyperbolic cosine of the complex argument.
362	* @throws Exception If argument isn't a valid real or complex number.
363	*/
364	public static function cosh($complex): TablePress\Complex
365	{
366	$complex = Complex::validateComplexArgument($complex);
367
368	if ($complex->isReal()) {
369	return new Complex(\cosh($complex->getReal()));
370	}
371
372	return new Complex(
373	\cosh($complex->getReal()) * \cos($complex->getImaginary()),
374	\sinh($complex->getReal()) * \sin($complex->getImaginary()),
375	$complex->getSuffix()
376	);
377	}
378
379	/**
380	* Returns the cotangent of a complex number.
381	*
382	* @param TablePress\Complex\|mixed $complex TablePress\Complex number or a numeric value.
383	* @return TablePress\Complex The cotangent of the complex argument.
384	* @throws Exception If argument isn't a valid real or complex number.
385	* @throws \InvalidArgumentException If function would result in a division by zero
386	*/
387	public static function cot($complex): TablePress\Complex
388	{
389	$complex = Complex::validateComplexArgument($complex);
390
391	if ($complex->getReal() == 0.0 && $complex->getImaginary() == 0.0) {
392	return new Complex(INF);
393	}
394
395	return self::inverse(self::tan($complex));
396	}
397
398	/**
399	* Returns the hyperbolic cotangent of a complex number.
400	*
401	* @param TablePress\Complex\|mixed $complex TablePress\Complex number or a numeric value.
402	* @return TablePress\Complex The hyperbolic cotangent of the complex argument.
403	* @throws Exception If argument isn't a valid real or complex number.
404	* @throws \InvalidArgumentException If function would result in a division by zero
405	*/
406	public static function coth($complex): TablePress\Complex
407	{
408	$complex = Complex::validateComplexArgument($complex);
409
410	return self::inverse(self::tanh($complex));
411	}
412
413	/**
414	* Returns the cosecant of a complex number.
415	*
416	* @param TablePress\Complex\|mixed $complex TablePress\Complex number or a numeric value.
417	* @return TablePress\Complex The cosecant of the complex argument.
418	* @throws Exception If argument isn't a valid real or complex number.
419	* @throws \InvalidArgumentException If function would result in a division by zero
420	*/
421	public static function csc($complex): TablePress\Complex
422	{
423	$complex = Complex::validateComplexArgument($complex);
424
425	if ($complex->getReal() == 0.0 && $complex->getImaginary() == 0.0) {
426	return new Complex(INF);
427	}
428
429	return self::inverse(self::sin($complex));
430	}
431
432	/**
433	* Returns the hyperbolic cosecant of a complex number.
434	*
435	* @param TablePress\Complex\|mixed $complex TablePress\Complex number or a numeric value.
436	* @return TablePress\Complex The hyperbolic cosecant of the complex argument.
437	* @throws Exception If argument isn't a valid real or complex number.
438	* @throws \InvalidArgumentException If function would result in a division by zero
439	*/
440	public static function csch($complex): TablePress\Complex
441	{
442	$complex = Complex::validateComplexArgument($complex);
443
444	if ($complex->getReal() == 0.0 && $complex->getImaginary() == 0.0) {
445	return new Complex(INF);
446	}
447
448	return self::inverse(self::sinh($complex));
449	}
450
451	/**
452	* Returns the exponential of a complex number.
453	*
454	* @param TablePress\Complex\|mixed $complex TablePress\Complex number or a numeric value.
455	* @return TablePress\Complex The exponential of the complex argument.
456	* @throws Exception If argument isn't a valid real or complex number.
457	*/
458	public static function exp($complex): TablePress\Complex
459	{
460	$complex = Complex::validateComplexArgument($complex);
461
462	if (($complex->getReal() == 0.0) && (\abs($complex->getImaginary()) == M_PI)) {
463	return new Complex(-1.0, 0.0);
464	}
465
466	$rho = \exp($complex->getReal());
467
468	return new Complex(
469	$rho * \cos($complex->getImaginary()),
470	$rho * \sin($complex->getImaginary()),
471	$complex->getSuffix()
472	);
473	}
474
475	/**
476	* Returns the inverse of a complex number.
477	*
478	* @param TablePress\Complex\|mixed $complex TablePress\Complex number or a numeric value.
479	* @return TablePress\Complex The inverse of the complex argument.
480	* @throws Exception If argument isn't a valid real or complex number.
481	* @throws InvalidArgumentException If function would result in a division by zero
482	*/
483	public static function inverse($complex): TablePress\Complex
484	{
485	$complex = clone Complex::validateComplexArgument($complex);
486
487	if ($complex->getReal() == 0.0 && $complex->getImaginary() == 0.0) {
488	throw new InvalidArgumentException('Division by zero');
489	}
490
491	return $complex->divideInto(1.0);
492	}
493
494	/**
495	* Returns the natural logarithm of a complex number.
496	*
497	* @param TablePress\Complex\|mixed $complex TablePress\Complex number or a numeric value.
498	* @return TablePress\Complex The natural logarithm of the complex argument.
499	* @throws Exception If argument isn't a valid real or complex number.
500	* @throws InvalidArgumentException If the real and the imaginary parts are both zero
501	*/
502	public static function ln($complex): TablePress\Complex
503	{
504	$complex = Complex::validateComplexArgument($complex);
505
506	if (($complex->getReal() == 0.0) && ($complex->getImaginary() == 0.0)) {
507	throw new InvalidArgumentException();
508	}
509
510	return new Complex(
511	\log(self::rho($complex)),
512	self::theta($complex),
513	$complex->getSuffix()
514	);
515	}
516
517	/**
518	* Returns the base-2 logarithm of a complex number.
519	*
520	* @param TablePress\Complex\|mixed $complex TablePress\Complex number or a numeric value.
521	* @return TablePress\Complex The base-2 logarithm of the complex argument.
522	* @throws Exception If argument isn't a valid real or complex number.
523	* @throws InvalidArgumentException If the real and the imaginary parts are both zero
524	*/
525	public static function log2($complex): TablePress\Complex
526	{
527	$complex = Complex::validateComplexArgument($complex);
528
529	if (($complex->getReal() == 0.0) && ($complex->getImaginary() == 0.0)) {
530	throw new InvalidArgumentException();
531	} elseif (($complex->getReal() > 0.0) && ($complex->getImaginary() == 0.0)) {
532	return new Complex(\log($complex->getReal(), 2), 0.0, $complex->getSuffix());
533	}
534
535	return self::ln($complex)
536	->multiply(\log(Complex::EULER, 2));
537	}
538
539	/**
540	* Returns the common logarithm (base 10) of a complex number.
541	*
542	* @param TablePress\Complex\|mixed $complex TablePress\Complex number or a numeric value.
543	* @return TablePress\Complex The common logarithm (base 10) of the complex argument.
544	* @throws Exception If argument isn't a valid real or complex number.
545	* @throws InvalidArgumentException If the real and the imaginary parts are both zero
546	*/
547	public static function log10($complex): TablePress\Complex
548	{
549	$complex = Complex::validateComplexArgument($complex);
550
551	if (($complex->getReal() == 0.0) && ($complex->getImaginary() == 0.0)) {
552	throw new InvalidArgumentException();
553	} elseif (($complex->getReal() > 0.0) && ($complex->getImaginary() == 0.0)) {
554	return new Complex(\log10($complex->getReal()), 0.0, $complex->getSuffix());
555	}
556
557	return self::ln($complex)
558	->multiply(\log10(Complex::EULER));
559	}
560
561	/**
562	* Returns the negative of a complex number.
563	*
564	* @param TablePress\Complex\|mixed $complex TablePress\Complex number or a numeric value.
565	* @return TablePress\Complex The negative value of the complex argument.
566	* @throws Exception If argument isn't a valid real or complex number.
567	*
568	* @see rho
569	*
570	*/
571	public static function negative($complex): TablePress\Complex
572	{
573	$complex = Complex::validateComplexArgument($complex);
574
575	return new Complex(
576	-1 * $complex->getReal(),
577	-1 * $complex->getImaginary(),
578	$complex->getSuffix()
579	);
580	}
581
582	/**
583	* Returns a complex number raised to a power.
584	*
585	* @param TablePress\Complex\|mixed $complex TablePress\Complex number or a numeric value.
586	* @param float\|integer $power The power to raise this value to
587	* @return TablePress\Complex The complex argument raised to the real power.
588	* @throws Exception If the power argument isn't a valid real
589	*/
590	public static function pow($complex, $power): TablePress\Complex
591	{
592	$complex = Complex::validateComplexArgument($complex);
593
594	if (!is_numeric($power)) {
595	throw new Exception('Power argument must be a real number');
596	}
597
598	if ($complex->getImaginary() == 0.0 && $complex->getReal() >= 0.0) {
599	return new Complex(\pow($complex->getReal(), $power));
600	}
601
602	$rValue = \sqrt(($complex->getReal() * $complex->getReal()) + ($complex->getImaginary() * $complex->getImaginary()));
603	$rPower = \pow($rValue, $power);
604	$theta = $complex->argument() * $power;
605	if ($theta == 0) {
606	return new Complex(1);
607	}
608
609	return new Complex($rPower * \cos($theta), $rPower * \sin($theta), $complex->getSuffix());
610	}
611
612	/**
613	* Returns the rho of a complex number.
614	* This is the distance/radius from the centrepoint to the representation of the number in polar coordinates.
615	*
616	* @param TablePress\Complex\|mixed $complex TablePress\Complex number or a numeric value.
617	* @return float The rho value of the complex argument.
618	* @throws Exception If argument isn't a valid real or complex number.
619	*/
620	public static function rho($complex): float
621	{
622	$complex = Complex::validateComplexArgument($complex);
623
624	return \sqrt(
625	($complex->getReal() * $complex->getReal()) +
626	($complex->getImaginary() * $complex->getImaginary())
627	);
628	}
629
630	/**
631	* Returns the secant of a complex number.
632	*
633	* @param TablePress\Complex\|mixed $complex TablePress\Complex number or a numeric value.
634	* @return TablePress\Complex The secant of the complex argument.
635	* @throws Exception If argument isn't a valid real or complex number.
636	* @throws \InvalidArgumentException If function would result in a division by zero
637	*/
638	public static function sec($complex): TablePress\Complex
639	{
640	$complex = Complex::validateComplexArgument($complex);
641
642	return self::inverse(self::cos($complex));
643	}
644
645	/**
646	* Returns the hyperbolic secant of a complex number.
647	*
648	* @param TablePress\Complex\|mixed $complex TablePress\Complex number or a numeric value.
649	* @return TablePress\Complex The hyperbolic secant of the complex argument.
650	* @throws Exception If argument isn't a valid real or complex number.
651	* @throws \InvalidArgumentException If function would result in a division by zero
652	*/
653	public static function sech($complex): TablePress\Complex
654	{
655	$complex = Complex::validateComplexArgument($complex);
656
657	return self::inverse(self::cosh($complex));
658	}
659
660	/**
661	* Returns the sine of a complex number.
662	*
663	* @param TablePress\Complex\|mixed $complex TablePress\Complex number or a numeric value.
664	* @return TablePress\Complex The sine of the complex argument.
665	* @throws Exception If argument isn't a valid real or complex number.
666	*/
667	public static function sin($complex): TablePress\Complex
668	{
669	$complex = Complex::validateComplexArgument($complex);
670
671	if ($complex->isReal()) {
672	return new Complex(\sin($complex->getReal()));
673	}
674
675	return new Complex(
676	\sin($complex->getReal()) * \cosh($complex->getImaginary()),
677	\cos($complex->getReal()) * \sinh($complex->getImaginary()),
678	$complex->getSuffix()
679	);
680	}
681
682	/**
683	* Returns the hyperbolic sine of a complex number.
684	*
685	* @param TablePress\Complex\|mixed $complex TablePress\Complex number or a numeric value.
686	* @return TablePress\Complex The hyperbolic sine of the complex argument.
687	* @throws Exception If argument isn't a valid real or complex number.
688	*/
689	public static function sinh($complex): TablePress\Complex
690	{
691	$complex = Complex::validateComplexArgument($complex);
692
693	if ($complex->isReal()) {
694	return new Complex(\sinh($complex->getReal()));
695	}
696
697	return new Complex(
698	\sinh($complex->getReal()) * \cos($complex->getImaginary()),
699	\cosh($complex->getReal()) * \sin($complex->getImaginary()),
700	$complex->getSuffix()
701	);
702	}
703
704	/**
705	* Returns the square root of a complex number.
706	*
707	* @param TablePress\Complex\|mixed $complex TablePress\Complex number or a numeric value.
708	* @return TablePress\Complex The Square root of the complex argument.
709	* @throws Exception If argument isn't a valid real or complex number.
710	*/
711	public static function sqrt($complex): TablePress\Complex
712	{
713	$complex = Complex::validateComplexArgument($complex);
714
715	$theta = self::theta($complex);
716	$delta1 = \cos($theta / 2);
717	$delta2 = \sin($theta / 2);
718	$rho = \sqrt(self::rho($complex));
719
720	return new Complex($delta1 * $rho, $delta2 * $rho, $complex->getSuffix());
721	}
722
723	/**
724	* Returns the tangent of a complex number.
725	*
726	* @param TablePress\Complex\|mixed $complex TablePress\Complex number or a numeric value.
727	* @return TablePress\Complex The tangent of the complex argument.
728	* @throws Exception If argument isn't a valid real or complex number.
729	* @throws InvalidArgumentException If function would result in a division by zero
730	*/
731	public static function tan($complex): TablePress\Complex
732	{
733	$complex = Complex::validateComplexArgument($complex);
734
735	if ($complex->isReal()) {
736	return new Complex(\tan($complex->getReal()));
737	}
738
739	$real = $complex->getReal();
740	$imaginary = $complex->getImaginary();
741	$divisor = 1 + \pow(\tan($real), 2) * \pow(\tanh($imaginary), 2);
742	if ($divisor == 0.0) {
743	throw new InvalidArgumentException('Division by zero');
744	}
745
746	return new Complex(
747	\pow(self::sech($imaginary)->getReal(), 2) * \tan($real) / $divisor,
748	\pow(self::sec($real)->getReal(), 2) * \tanh($imaginary) / $divisor,
749	$complex->getSuffix()
750	);
751	}
752
753	/**
754	* Returns the hyperbolic tangent of a complex number.
755	*
756	* @param TablePress\Complex\|mixed $complex TablePress\Complex number or a numeric value.
757	* @return TablePress\Complex The hyperbolic tangent of the complex argument.
758	* @throws Exception If argument isn't a valid real or complex number.
759	* @throws \InvalidArgumentException If function would result in a division by zero
760	*/
761	public static function tanh($complex): TablePress\Complex
762	{
763	$complex = Complex::validateComplexArgument($complex);
764	$real = $complex->getReal();
765	$imaginary = $complex->getImaginary();
766	$divisor = \cos($imaginary) * \cos($imaginary) + \sinh($real) * \sinh($real);
767	if ($divisor == 0.0) {
768	throw new InvalidArgumentException('Division by zero');
769	}
770
771	return new Complex(
772	\sinh($real) * \cosh($real) / $divisor,
773	0.5 * \sin(2 * $imaginary) / $divisor,
774	$complex->getSuffix()
775	);
776	}
777
778	/**
779	* Returns the theta of a complex number.
780	* This is the angle in radians from the real axis to the representation of the number in polar coordinates.
781	*
782	* @param TablePress\Complex\|mixed $complex TablePress\Complex number or a numeric value.
783	* @return float The theta value of the complex argument.
784	* @throws Exception If argument isn't a valid real or complex number.
785	*/
786	public static function theta($complex): float
787	{
788	$complex = Complex::validateComplexArgument($complex);
789
790	if ($complex->getReal() == 0.0) {
791	if ($complex->isReal()) {
792	return 0.0;
793	} elseif ($complex->getImaginary() < 0.0) {
794	return M_PI / -2;
795	}
796	return M_PI / 2;
797	} elseif ($complex->getReal() > 0.0) {
798	return \atan($complex->getImaginary() / $complex->getReal());
799	} elseif ($complex->getImaginary() < 0.0) {
800	return -(M_PI - \atan(\abs($complex->getImaginary()) / \abs($complex->getReal())));
801	}
802
803	return M_PI - \atan($complex->getImaginary() / \abs($complex->getReal()));
804	}
805	}
806