Math::GComplex - Generic complex number library.
Version 0.08
Math::GComplex provides a generic interface to complex number operations, accepting any type of number as a component of a complex number, including native Perl numbers and numerical objects provided by other mathematical libraries, such as Math::AnyNum.
use 5.014; use Math::GComplex; use Math::AnyNum qw(:overload); my $x = Math::GComplex->new(3, 4); my $y = Math::GComplex->new(7, 5); say $x + $y; #=> (10 9) say $x - $y; #=> (-4 -1) say $x * $y; #=> (1 43) say $x / $y; #=> (41/74 13/74)
Math::GComplex is a lightweight library, which focuses primarily on providing a friendly interface to complex number operations and good performance.
In most cases, it can be used as drop-in replacement for Math::Complex.
Due to its simple and elegant design, this library is between 2x up to 8x faster than Math::Complex.
The following functions are exportable:
:trig sin sinh asin asinh cos cosh acos acosh tan tanh atan atanh cot coth acot acoth sec sech asec asech csc csch acsc acsch atan2 deg2rad rad2deg :special log logn exp sqrt cbrt root :misc cplx abs acmp sgn conj norm inv real imag reals
Each function can be exported individually, as:
use Math::GComplex qw(acosh);
There is also the possibility of exporting an entire group of functions, as:
use Math::GComplex qw(:trig);
The imaginary unit, i = sqrt(-1), is also exportable, as:
i = sqrt(-1)
use Math::GComplex qw(i);
Additionally, by specifying the :all keyword, all the exportable functions, including the i constant, will be exported:
:all
i
use Math::GComplex qw(:all);
The :overload keyword enables constant overloading, which makes each number a Math::GComplex object and also exports the i constant:
:overload
use Math::GComplex qw(:overload); CORE::say 3 + 4*i; #=> (3 4) CORE::say log(-1); #=> (0 3.14159265358979)
NOTE: :overload is lexical to the current scope only.
The syntax for disabling the :overload behavior in the current scope, is:
no Math::GComplex; # :overload will be disabled in the current scope
Nothing is exported by default.
my $z = Math::GComplex->new($real, $imag);
Creates and returns a new Math::GComplex object.
my $z = cplx($real, $imag);
my $i = Math::GComplex::i();
Returns the imaginary unit as a Math::GComplex object, equivalent with cplx(0, 1).
cplx(0, 1)
This section describes all the basic operations provided by this module.
$x + $y $x->add($y)
Addition of $x and $y, defined as:
$x
$y
(a + b*i) + (x + y*i) = (a + x) + (b + y)*i
$x - $y $x->sub($y)
Subtraction of $y from $x, defined as:
(a + b*i) - (x + y*i) = (a - x) + (b - y)*i
$x * $y $x->mul($y)
Multiplication of $x and $y, defined as:
(a + b*i) * (x + y*i) = i*(a*y + b*x) + a*x - b*y
$x / $y $x->div($y)
Division of $x by $y, defined as:
(a + b*i) / (x + y*i) = (a*x + b*y)/(x^2 + y^2) + (b*x - a*y)/(x^2 + y^2)*i
$x % $y $x->mod($y)
Remainder of $x when divided by $y, defined as:
mod(a, b) = a - b * floor(a/b)
-$x $x->neg
Additive inverse of $x, defined as:
neg(a + b*i) = -a - b*i
~$x $x->conj
Complex conjugate of $x, defined as:
conj(a + b*i) = a - b*i
$x->inv
Multiplicative inverse of $x, defined as:
inv(x) = 1/x
$x->norm
Normalized value of $x, defined as:
norm(a + b*i) = a^2 + b^2
$x->abs
Absolute value of $x, defined as:
abs(a + b*i) = sqrt(a^2 + b^2)
$x->sgn
The sign of $x, defined as:
sgn(x) = x / abs(x)
This section describes the special mathematical functions provided by this module.
log($x) $x->log
Natural logarithm of $x, defined as:
log(a + b*i) = log(a^2 + b^2)/2 + atan2(b, a) * i
$x->logn($y)
Logarithm of $x to base $y, defined as:
logn(a, b) = log(a) / log(b)
exp($x) $x->exp
Natural exponentiation of $x, defined as:
exp(a + b*i) = exp(a) * cos(b) + exp(a) * sin(b) * i
$x**$y $x->pow($y)
Raises $x to power $y and returns the result, defined as:
a^b = exp(log(a) * b)
$x->root($y)
Nth root of $x, defined as:
root(a, b) = exp(log(a) / b)
sqrt($x) $x->sqrt
Square root of $x, defined as:
sqrt(x) = exp(log(x) / 2)
$x->cbrt
Cube root of $x, defined as:
cbrt(x) = exp(log(x) / 3)
This section includes all the trigonometric functions provied by Math::GComplex.
$x->sin $x->sinh $x->asin $x->asinh
Sine, hyperbolic sine, inverse sine and inverse hyperbolic sine.
Defined as:
sin(x) = (exp(x * i) - exp(-i * x))/(2 * i) sinh(x) = (exp(2 * x) - 1) / (2 * exp(x)) asin(x) = -i * log(i * x + sqrt(1 - x^2)) asinh(x) = log(sqrt(x^2 + 1) + x)
$x->cos $x->cosh $x->acos $x->acosh
Cosine, hyperbolic cosine, inverse cosine and inverse hyperbolic cosine.
cos(x) = (exp(-i * x) + exp(i * x)) / 2 cosh(x) = (exp(2 * x) + 1) / (2 * exp(x)) acos(x) = -2 * i * log(i * sqrt((1 - x)/2) + sqrt((1 + x)/2)) acosh(x) = log(x + sqrt(x - 1) * sqrt(x + 1))
$x->tan $x->tanh $x->atan $x->atanh
Tangent, hyperbolic tangent, inverse tangent and inverse hyperbolic tangent.
tan(x) = (2 * i)/(exp(2 * i * x) + 1) - i tanh(x) = (exp(2 * x) - 1) / (exp(2 * x) + 1) atan(x) = i * (log(1 - i * x) - log(1 + i * x)) / 2 atanh(x) = (log(1 + x) - log(1 - x)) / 2
$x->cot $x->coth $x->acot $x->acoth
Cotangent, hyperbolic cotangent, inverse cotangent and inverse hyperbolic cotangent.
cot(x) = (2 * i)/(exp(2 * i * x) - 1) + i coth(x) = (exp(2 * x) + 1) / (exp(2 * x) - 1) acot(x) = atan(1/x) acoth(x) = atanh(1/x)
$x->sec $x->sech $x->asec $x->asech
Secant, hyperbolic secant, inverse secant and inverse hyperbolic secant.
sec(x) = 2/(exp(-i * x) + exp(i * x)) sech(x) = (2 * exp(x)) / (exp(2 * x) + 1) asec(x) = acos(1/x) asech(x) = acosh(1/x)
$x->csc $x->csch $x->acsc $x->acsch
Cosecant, hyperbolic cosecant, inverse cosecant and inverse hyperbolic cosecant.
csc(x) = -(2 * i)/(exp(-i * x) - exp(i * x)) csch(x) = (2 * exp(x)) / (exp(2 * x) - 1) acsc(x) = asin(1/x) acsch(x) = asinh(1/x)
atan2($x, $y) $x->atan2($y)
The arc tangent of $x and $y, defined as:
atan2(a, b) = -i * log((b + a*i) / sqrt(a^2 + b^2))
Returns the value of x converted from degrees to radians.
x
deg2rad(x) = x / 180 * atan2(0, -abs(x))
my $deg = $x->rad2deg;
Returns the value of x converted from radians to degrees.
rad2deg(x) = x * 180 / atan2(0, -abs(x))
This section describes the various useful methods provided by this module.
$x->floor
The floor function, defined as:
floor(a + b*i) = floor(a) + floor(b)*i
$x->ceil
The ceil function, defined as:
ceil(a + b*i) = ceil(a) + ceil(b)*i
int($x) $x->int
The integer-truncation function, defined as:
int(a + b*i) = int(a) + int(b)*i
$x->real
Return the real part of $x.
$x->imag
Returns the imaginary part of $x.
($real, $imag) = $x->reals
Returns the real and the imaginary part of $x, as real numbers.
$x == $y $x->eq($y)
Equality check: returns a true value when $x and $y are equal.
$x != $y $x->ne($y)
Inequality check: returns a true value when $x and $y are not equal.
$x > $y $x->gt($y)
Returns a true value when $x is greater than $y.
$x >= $y $x->ge($y)
Returns a true value when $x is equal or greater than $y.
$x < $y $x->lt($y)
Returns a true value when $x is less than $y.
$x <= $y $x->le($y)
Returns a true value when $x is equal or less than $y.
$x <=> $y $x->cmp($y)
Compares $x to $y and returns a negative value when $x is less than $y, 0 when $x and $y are equal, and a positive value when $x is greater than $y.
Complex numbers are compared as:
(real($x) <=> real($y)) || (imag($x) <=> imag($y))
$x->acmp($y)
Absolute comparison of $x and $y, defined as:
acmp(a, b) = abs(a) <=> abs(b)
$x->boolify
Returns a true value when either the real part or the imaginary part of $x is non-zero.
$x->numify
Returns the real part of $x.
$x->stringify
Returns a stringification version of $x.
Example:
Math::GComplex->new( 3, -4)->stringify; # "(3 -4)" Math::GComplex->new(-5, 6)->stringify; # "(-5 6)"
Being a generic interface, it assumes that all the special cases (such as division by zero) are handled by the library of which type the components of a complex number are.
When the components of a complex number are native Perl numbers, the "division by zero" and the "logarithm of zero" cases are implicitly handled by this library. However the user may still encounter incorrect results due to overflow or underflow in some special cases (such as coth(1e6) = (NaN NaN) and cosh(1e6) = (NaN NaN)).
coth(1e6) = (NaN NaN)
cosh(1e6) = (NaN NaN)
Daniel "Trizen" Șuteu, <trizen at protonmail.com>
<trizen at protonmail.com>
Please report any bugs or feature requests at https://github.com/trizen/Math-GComplex/issues. I will be notified, and then you'll automatically be notified of progress on your bug as I make changes.
You can find documentation for this module with the perldoc command.
perldoc Math::GComplex
You can also look for information at:
Github
https://github.com/trizen/Math-GComplex
AnnoCPAN: Annotated CPAN documentation
http://annocpan.org/dist/Math-GComplex
CPAN Ratings
http://cpanratings.perl.org/d/Math-GComplex
Search CPAN
http://search.cpan.org/dist/Math-GComplex/
Other math libraries
Math::AnyNum - Arbitrary size precision for integers, rationals, floating-points and complex numbers.
Math::GMP - High speed arbitrary size integer math.
Math::GMPz - perl interface to the GMP library's integer (mpz) functions.
Math::GMPq - perl interface to the GMP library's rational (mpq) functions.
Math::MPFR - perl interface to the MPFR (floating point) library.
Math::MPC - perl interface to the MPC (multi precision complex) library.
Math::Complex - complex numbers and associated mathematical functions.
Copyright 2018 Daniel "Trizen" Șuteu.
This program is free software; you can redistribute it and/or modify it under the terms of the the Artistic License (2.0). You may obtain a copy of the full license at:
http://www.perlfoundation.org/artistic_license_2_0
Any use, modification, and distribution of the Standard or Modified Versions is governed by this Artistic License. By using, modifying or distributing the Package, you accept this license. Do not use, modify, or distribute the Package, if you do not accept this license.
If your Modified Version has been derived from a Modified Version made by someone other than you, you are nevertheless required to ensure that your Modified Version complies with the requirements of this license.
This license does not grant you the right to use any trademark, service mark, tradename, or logo of the Copyright Holder.
This license includes the non-exclusive, worldwide, free-of-charge patent license to make, have made, use, offer to sell, sell, import and otherwise transfer the Package with respect to any patent claims licensable by the Copyright Holder that are necessarily infringed by the Package. If you institute patent litigation (including a cross-claim or counterclaim) against any party alleging that the Package constitutes direct or contributory patent infringement, then this Artistic License to you shall terminate on the date that such litigation is filed.
Disclaimer of Warranty: THE PACKAGE IS PROVIDED BY THE COPYRIGHT HOLDER AND CONTRIBUTORS "AS IS' AND WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES. THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT ARE DISCLAIMED TO THE EXTENT PERMITTED BY YOUR LOCAL LAW. UNLESS REQUIRED BY LAW, NO COPYRIGHT HOLDER OR CONTRIBUTOR WILL BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING IN ANY WAY OUT OF THE USE OF THE PACKAGE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
To install Math::GComplex, copy and paste the appropriate command in to your terminal.
cpanm
cpanm Math::GComplex
CPAN shell
perl -MCPAN -e shell install Math::GComplex
For more information on module installation, please visit the detailed CPAN module installation guide.