NAME
Math::Complex_C - perl interface to C's complex.h functions.
DEPENDENCIES
In order to compile this module, a C compiler that provides
complex.h is needed.DESCRIPTION This module wraps the 'double _Complex' type (as a Math::Complex_C object) and the 'long double _Complex' type (as a Math::Complex_C::Long object).
use warnings;
use strict;
use Math::Complex_C qw(:all);
my $c = Math::Complex_C->new(12.5, 1125); # 'double _Complex' type
my $root = Math::Complex_C->new();
my $cl = Math::Complex_C::Long->new(5.9,1.1); # 'long double _Complex'
my $rootl = Math::Complex_C::Long->new();
sqrt_c($root, $c);
sqrt_cl($rootl, $cl);
print "Square root of $c is $root\n";
print "Square root of $c1 is $rootl\n";
On many perls, the values printed out by the above code will be
identical - see the README for some elaboration.
Note that Math::Complex_C and Math::Complex_C::Long objects use
different functions (sqrt_c vs sqrt_cl, in the above example).
See also the Math::Complex_C test suite for some (simplistic) examples
of usage.FUNCTIONS
$rop = Math::Complex_C->new([$re, [$im]]);
$rop = Math::Complex_C::new([$re, [$im]]);
$rop = new Math::Complex_C([$re, [$im]]);
$ropl = Math::Complex_C::Long->new([$re, [$im]]);
$ropl = Math::Complex_C::Long::new([$re, [$im]]);
$ropl = new Math::Complex_C::Long([$re, [$im]]);
$rop/$ropl is a Math::Complex_C/Math::Complex_C::Long object;
$re and $im are the real and imaginary values (respectively) that $rop
holds. They can be an integer (signed or unsigned) or a floating point
value.Integer values (IV/UV) will be converted to floating point (NV)
before being assigned.
Note that the two arguments ($re $im) are optional - ie can be omitted.
If no arguments are supplied to new, then $rop will be assigned NaN for
both the real and imaginary parts.
If only one argument is supplied, then $rop will be assigned that value
for the real part, and 0 for the imaginary part.
$rop = create_c();
$ropl = create_cl();
$rop/$ropl is a Math::Complex_C/Math::Complex_C::Long object (created
with both real and imaginary values set to NaN).
assign_c($rop, $re, $im);
assign_cl($ropl, $re, $im);
The real part of $rop/$ropl is set to the value of $re, the imaginary
part is set to the value of $im.
$re and $im can be an integer (signed or unsigned) or a floating point
value. Integer values (IV/UV) will be converted to floating point (NV)
before being assigned.
mul_c($rop, $op1, $op2);
mul_c_iv($rop, $op1, $si);
mul_c_uv($rop, $op1, $ui);
mul_c_nv($rop, $op1, $nv);
mul_cl($ropl, $op1, $op2);
mul_c_ivl($ropl, $op1, $si);
mul_c_uvl($ropl, $op1, $ui);
mul_c_nvl($ropl, $op1, $nv);
Multiply $op1 by the 3rd arg, and store the result in $rop/$ropl.
The "3rd arg" is (respectively, from the top) a Math::Complex_C object,
a signed integer value (IV), an unsigned integer value (UV), and a
floating point value (NV).
add_c($rop, $op1, $op2);
add_c_iv($rop, $op1, $si);
add_c_uv($rop, $op1, $ui);
add_c_nv($rop, $op1, $nv);
add_cl($ropl, $op1, $op2);
add_c_ivl($ropl, $op1, $si);
add_c_uvl($ropl, $op1, $ui);
add_c_nvl($ropl, $op1, $nv);
As for mul_c(), etc., but performs addition.
div_c($rop, $op1, $op2);
div_c_iv($rop, $op1, $si);
div_c_uv($rop, $op1, $ui);
div_c_nv($rop, $op1, $nv);
div_cl($ropl, $op1, $op2);
div_c_ivl($ropl, $op1, $si);
div_c_uvl($ropl, $op1, $ui);
div_c_nvl($ropl, $op1, $nv);
As for mul_c(), etc., but performs division.
sub_c($rop, $op1, $op2);
sub_c_iv($rop, $op1, $si);
sub_c_uv($rop, $op1, $ui);
sub_c_nv($rop, $op1, $nv);
sub_cl($ropl, $op1, $op2);
sub_c_ivl($ropl, $op1, $si);
sub_c_uvl($ropl, $op1, $ui);
sub_c_nvl($ropl, $op1, $nv);
As for mul_c(), etc., but performs subtraction.
$nv = real_c($op);
$nv = real_cl($op);
Returns the (floating point) value of the real component of $op.
Wraps C's 'creal/creall' function.
$nv = imag_c($op);
$nv = imag_cl($op);
Returns the (floating point) value of the imaginary component of $op.
Wraps C's 'cimag/cimagl' function.
$nv = arg_c($op);
$nv = arg_cl($op);
Returns the (floating point) value of the argument of $op.
Wraps C's 'carg/cargl' function.
$nv = abs_c($op);
$nv = abs_cl($op);
Returns the (floating point) absolute value of $op.
Wraps C's 'cabs/cabsl' function.
conj_c($rop, $op);
conj_cl($ropl, $op);
Sets $rop/$ropl to the conjugate of $op.
Wraps C's 'conj/conjl' function.
acos_c($rop, $op);
acos_cl($ropl, $op);
Sets $rop/$ropl to acos($op).
Wraps C's 'cacos/cacosl' function.
asin_c($rop, $op);
asin_cl($ropl, $op);
Sets $rop/$ropl to asin($op).
Wraps C's 'casin/casinl' function.
atan_c($rop, $op);
atan_cl($ropl, $op);
Sets $rop/$ropl to atan($op).
Wraps C's 'catan/catanl' function.
cos_c($rop, $op);
cos_cl($ropl, $op);
Sets $rop/$ropl to cos($op).
Wraps C's 'ccos/ccosl' function.
sin_c($rop, $op);
sin_cl($ropl, $op);
Sets $rop/$ropl to sin($op).
Wraps C's 'csin/csinl' function.
tan_c($rop, $op);
tan_cl($ropl, $op);
Sets $rop/$ropl to tan($op).
Wraps C's 'ctan/ctanl' function.
acosh_c($rop, $op);
acosh_cl($ropl, $op);
Sets $rop/$ropl to acosh($op).
Wraps C's 'cacosh/cacoshl' function.
asinh_c($rop, $op);
asinh_cl($ropl, $op);
Sets $rop/$ropl to asinh($op).
Wraps C's 'casinh/casinhl' function.
atanh_c($rop, $op);
atanh_cl($ropl, $op);
Sets $rop/$ropl to atanh($op).
Wraps C's 'catanh/catanhl' function.
cosh_c($rop, $op);
cosh_cl($ropl, $op);
Sets $rop/$ropl to cosh($op).
Wraps C's 'ccosh/ccoshl' function.
sinh_c($rop, $op);
sinh_cl($rop, $op);
Sets $rop/$ropl to sinh($op).
Wraps C's 'csinh/csinhl' function.
tanh_c($rop, $op);
tanh_cl($ropl, $op);
Sets $rop/$ropl to tanh($op).
Wraps C's 'ctanh/ctanhl' function.
exp_c($rop, $op);
exp_cl($rop1, $op);
Sets $rop/$ropl to e ** $op.
Wraps C's 'cexp/cexpl' function.
log_c($rop, $op);
log_cl($ropl, $op);
Sets $rop/$ropl to log($op).
Wraps C's 'clog/clogl' function.
pow_c($rop, $op1, $op2);
pow_cl($ropl, $op1, $op2);
Sets $rop/$ropl to $op1 ** $op2.
Wraps C's 'cpow/cpowl' function.
sqrt_c($rop, $op);
sqrt_cl($ropl, $op);
Sets $rop/$ropl to sqrt($op).
Wraps C's 'csqrt/csqrtl' function.
proj_c($rop, $op);
proj_cl($ropl, $op);
Sets $rop/$ropl to a projection of $op onto the Riemann sphere.
Wraps C's 'cproj/cprojl' function.
$rop = get_nan();
$ropl = get_nanl();
Sets $rop/$ropl to NaN.
$rop = get_inf();
$ropl = get_infl();
Sets $rop/$ropl to Inf.
$bool = is_nan($op);
$bool = is_nanl($op);
Returns true if $op is a NaN - else returns false
$bool = is_inf($op);
$bool = is_infl($op);
Returns true if $op is -Inf or +Inf - else returns false
$bool = is_neg_zero($nv);
Returns true if $nv is -0. Else returns false - hence the function
returns false (and warns) if $nv is not an NV (since only an NV
can be -0).
Perl can't be relied upon to print the '-' sign if the NV is -0.
For example, 5.12.0 *will* print it, but 5.14.0 won't.
Therefore, if we care about the sign, we need to check using this
XSub.OPERATOR OVERLOADING
Both Math::Complex_C and Math::Complex_C::Long overload the
following operators:
*, +, /, -, **,
*=, +=, /=, -=, **=,
!, bool,
==, !=,
=, "",
abs, exp, log, cos, sin, atan2, sqrt
Cross-class overloading is not impllemented - that is, you
cannot use both a Math::Complex_C::Long object and a
Math::Complex_C object in the same overloaded operation.
Note: For the purposes of the overloaded 'not', '!' and 'bool'
operators, a "false" Math::Complex_C object is one with real
and imaginary parts that are both "false" - where "false"
currently means either 0 (including -0) or NaN.
(A "true" Math::Complex_C object is, of course, simply one
that is not "false".)
If the value passed to the overloaded '**', '**=' or
'equivalence' operators is an IV/UV (integer), it will be
converted to an NV (floating point value) before the calculation
is performed.LICENSE
This program is free software; you may redistribute it and/or
modify it under the same terms as Perl itself.
Copyright 2011 Sisyphus.AUTHOR
Sisyphus <sisyphus at(@) cpan dot (.) org>