NAME
PDL::LinearAlgebra::Complex - PDL interface to the lapack linear algebra programming library (complex number)
SYNOPSIS
use PDL;
use PDL::LinearAlgebra::Complex;
$a = random(cdouble, 100, 100);
$s = zeroes(cdouble, 100);
$u = zeroes(cdouble, 100, 100);
$v = zeroes(cdouble, 100, 100);
$info = 0;
$job = 0;
cgesdd($a, $job, $info, $s , $u, $v);DESCRIPTION
This module provides an interface to parts of the lapack library (complex numbers). These routines accept either float or double ndarrays.
FUNCTIONS
cgtsv
Signature: (complex [io]DL(n);complex [io]D(n);complex [io]DU(n);complex [io]B(n,nrhs); int [o]info())
Types: (float double)$info = cgtsv($DL, $D, $DU, $B);
cgtsv($DL, $D, $DU, $B, $info); # all arguments given
$info = $DL->cgtsv($D, $DU, $B); # method call
$DL->cgtsv($D, $DU, $B, $info);Solves the equation
A * X = Bwhere A is an n by n tridiagonal matrix, by Gaussian elimination with partial pivoting, and B is an n by nrhs matrix.
Note that the equation A**T*X = B may be solved by interchanging the order of the arguments DU and DL.
NB This differs from the LINPACK function cgtsl in that DL starts from its first element, while the LINPACK equivalent starts from its second element.
Arguments
=========
DL: On entry, DL must contain the (n-1) sub-diagonal elements of A.
On exit, DL is overwritten by the (n-2) elements of the
second super-diagonal of the upper triangular matrix U from
the LU factorization of A, in DL(1), ..., DL(n-2).
D: On entry, D must contain the diagonal elements of A.
On exit, D is overwritten by the n diagonal elements of U.
DU: On entry, DU must contain the (n-1) super-diagonal elements of A.
On exit, DU is overwritten by the (n-1) elements of the
first super-diagonal of the U.
B: On entry, the n by nrhs matrix of right hand side matrix B.
On exit, if info = 0, the n by nrhs solution matrix X.
info: = 0: successful exit
< 0: if info = -i, the i-th argument had an illegal value
> 0: if info = i, U(i,i) is exactly zero, and the solution
has not been computed. The factorization has not been
completed unless i = n.$dl = random(float, 9) + random(float, 9) * i;
$d = random(float, 10) + random(float, 10) * i;
$du = random(float, 9) + random(float, 9) * i;
$b = random(10,5) + random(10,5) * i;
cgtsv($dl, $d, $du, $b, ($info=null));
print "X is:\n$b" unless $info;Broadcasts over its inputs.
cgtsv ignores the bad-value flag of the input ndarrays. It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays.
cgesvd
Signature: (complex [io]A(m,n); int jobu(); int jobvt(); [o]s(minmn=CALC(PDLMIN($SIZE(m),$SIZE(n))));complex [o]U(p,p);complex [o]VT(s,s); int [o]info(); [t]rwork(rworkn=CALC(5*$SIZE(minmn))))
Types: (float double)($s, $U, $VT, $info) = cgesvd($A, $jobu, $jobvt);
cgesvd($A, $jobu, $jobvt, $s, $U, $VT, $info); # all arguments given
($s, $U, $VT, $info) = $A->cgesvd($jobu, $jobvt); # method call
$A->cgesvd($jobu, $jobvt, $s, $U, $VT, $info);Complex version of "gesvd" in PDL::LinearAlgebra::Real.
The SVD is written
A = U * SIGMA * ConjugateTranspose(V)Broadcasts over its inputs.
cgesvd ignores the bad-value flag of the input ndarrays. It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays.
cgesdd
Signature: (complex [io]A(m,n); int jobz(); [o]s(minmn=CALC(PDLMIN($SIZE(m),$SIZE(n))));complex [o]U(p,p);complex [o]VT(s,s); int [o]info(); int [t]iwork(iworkn))
Types: (float double)($s, $U, $VT, $info) = cgesdd($A, $jobz);
cgesdd($A, $jobz, $s, $U, $VT, $info); # all arguments given
($s, $U, $VT, $info) = $A->cgesdd($jobz); # method call
$A->cgesdd($jobz, $s, $U, $VT, $info);Complex version of "gesdd" in PDL::LinearAlgebra::Real.
The SVD is written
A = U * SIGMA * ConjugateTranspose(V)Broadcasts over its inputs.
cgesdd ignores the bad-value flag of the input ndarrays. It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays.
cggsvd
Signature: (complex [io]A(m,n); int jobu(); int jobv(); int jobq();complex [io]B(p,n); int [o]k(); int [o]l();[o]alpha(n);[o]beta(n);complex [o]U(q,q);complex [o]V(r,r);complex [o]Q(s,s); int [o]iwork(n); int [o]info(); [t]rwork(rworkn=CALC(2*$SIZE(n))))
Types: (float double)($k, $l, $alpha, $beta, $U, $V, $Q, $iwork, $info) = cggsvd($A, $jobu, $jobv, $jobq, $B);
cggsvd($A, $jobu, $jobv, $jobq, $B, $k, $l, $alpha, $beta, $U, $V, $Q, $iwork, $info); # all arguments given
($k, $l, $alpha, $beta, $U, $V, $Q, $iwork, $info) = $A->cggsvd($jobu, $jobv, $jobq, $B); # method call
$A->cggsvd($jobu, $jobv, $jobq, $B, $k, $l, $alpha, $beta, $U, $V, $Q, $iwork, $info);Complex version of "ggsvd" in PDL::LinearAlgebra::Real
Broadcasts over its inputs.
cggsvd ignores the bad-value flag of the input ndarrays. It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays.
cgeev
Signature: (complex [io]A(n,n); int jobvl(); int jobvr();complex [o]w(n);complex [o]vl(m,m);complex [o]vr(p,p); int [o]info(); [t]rwork(rworkn=CALC(2*$SIZE(n))))
Types: (float double)($w, $vl, $vr, $info) = cgeev($A, $jobvl, $jobvr);
cgeev($A, $jobvl, $jobvr, $w, $vl, $vr, $info); # all arguments given
($w, $vl, $vr, $info) = $A->cgeev($jobvl, $jobvr); # method call
$A->cgeev($jobvl, $jobvr, $w, $vl, $vr, $info);Complex version of "geev" in PDL::LinearAlgebra::Real
Broadcasts over its inputs.
cgeev ignores the bad-value flag of the input ndarrays. It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays.
cgeevx
Signature: (complex [io]A(n,n); int jobvl(); int jobvr(); int balance(); int sense();complex [o]w(n);complex [o]vl(m,m);complex [o]vr(p,p); int [o]ilo(); int [o]ihi(); [o]scale(n); [o]abnrm(); [o]rconde(q); [o]rcondv(r); int [o]info(); [t]rwork(rworkn=CALC(2*$SIZE(n))))
Types: (float double)($w, $vl, $vr, $ilo, $ihi, $scale, $abnrm, $rconde, $rcondv, $info) = cgeevx($A, $jobvl, $jobvr, $balance, $sense);
cgeevx($A, $jobvl, $jobvr, $balance, $sense, $w, $vl, $vr, $ilo, $ihi, $scale, $abnrm, $rconde, $rcondv, $info); # all arguments given
($w, $vl, $vr, $ilo, $ihi, $scale, $abnrm, $rconde, $rcondv, $info) = $A->cgeevx($jobvl, $jobvr, $balance, $sense); # method call
$A->cgeevx($jobvl, $jobvr, $balance, $sense, $w, $vl, $vr, $ilo, $ihi, $scale, $abnrm, $rconde, $rcondv, $info);Complex version of "geevx" in PDL::LinearAlgebra::Real
Broadcasts over its inputs.
cgeevx ignores the bad-value flag of the input ndarrays. It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays.
cggev
Signature: (complex [io]A(n,n); int jobvl();int jobvr();complex [io]B(n,n);complex [o]alpha(n);complex [o]beta(n);complex [o]VL(m,m);complex [o]VR(p,p);int [o]info(); [t]rwork(rworkn=CALC(8*$SIZE(n))))
Types: (float double)($alpha, $beta, $VL, $VR, $info) = cggev($A, $jobvl, $jobvr, $B);
cggev($A, $jobvl, $jobvr, $B, $alpha, $beta, $VL, $VR, $info); # all arguments given
($alpha, $beta, $VL, $VR, $info) = $A->cggev($jobvl, $jobvr, $B); # method call
$A->cggev($jobvl, $jobvr, $B, $alpha, $beta, $VL, $VR, $info);Complex version of "ggev" in PDL::LinearAlgebra::Real
Broadcasts over its inputs.
cggev ignores the bad-value flag of the input ndarrays. It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays.
cggevx
Signature: (complex [io]A(n,n);int balanc();int jobvl();int jobvr();int sense();complex [io]B(n,n);complex [o]alpha(n);complex [o]beta(n);complex [o]VL(m,m);complex [o]VR(p,p);int [o]ilo();int [o]ihi();[o]lscale(n);[o]rscale(n);[o]abnrm();[o]bbnrm();[o]rconde(r);[o]rcondv(s);int [o]info(); [t]rwork(rworkn=CALC(6*$SIZE(n))); int [t]bwork(bworkn); int [t]iwork(iworkn))
Types: (float double)($alpha, $beta, $VL, $VR, $ilo, $ihi, $lscale, $rscale, $abnrm, $bbnrm, $rconde, $rcondv, $info) = cggevx($A, $balanc, $jobvl, $jobvr, $sense, $B);
cggevx($A, $balanc, $jobvl, $jobvr, $sense, $B, $alpha, $beta, $VL, $VR, $ilo, $ihi, $lscale, $rscale, $abnrm, $bbnrm, $rconde, $rcondv, $info); # all arguments given
($alpha, $beta, $VL, $VR, $ilo, $ihi, $lscale, $rscale, $abnrm, $bbnrm, $rconde, $rcondv, $info) = $A->cggevx($balanc, $jobvl, $jobvr, $sense, $B); # method call
$A->cggevx($balanc, $jobvl, $jobvr, $sense, $B, $alpha, $beta, $VL, $VR, $ilo, $ihi, $lscale, $rscale, $abnrm, $bbnrm, $rconde, $rcondv, $info);Complex version of "ggevx" in PDL::LinearAlgebra::Real
Broadcasts over its inputs.
cggevx ignores the bad-value flag of the input ndarrays. It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays.
cgees
Signature: (complex [io]A(n,n); int jobvs(); int sort();complex [o]w(n);complex [o]vs(p,p); int [o]sdim(); int [o]info(); [t]rwork(n); int [t]bwork(bworkn); SV* select_func)
Types: (float double)($w, $vs, $sdim, $info) = cgees($A, $jobvs, $sort, $select_func);
cgees($A, $jobvs, $sort, $w, $vs, $sdim, $info, $select_func); # all arguments given
($w, $vs, $sdim, $info) = $A->cgees($jobvs, $sort, $select_func); # method call
$A->cgees($jobvs, $sort, $w, $vs, $sdim, $info, $select_func);Complex version of "gees" in PDL::LinearAlgebra::Real
select_func:
If sort = 1, select_func is used to select eigenvalues to sort
to the top left of the Schur form.
If sort = 0, select_func is not referenced.
An complex eigenvalue w is selected if
select_func(complex(w)) is true;
Note that a selected complex eigenvalue may no longer
satisfy select_func(complex(w)) = 1 after ordering, since
ordering may change the value of complex eigenvalues
(especially if the eigenvalue is ill-conditioned); in this
case info is set to N+2.Broadcasts over its inputs.
cgees ignores the bad-value flag of the input ndarrays. It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays.
cgeesx
Signature: (complex [io]A(n,n); int jobvs(); int sort(); int sense();complex [o]w(n);complex [o]vs(p,p); int [o]sdim(); [o]rconde();[o]rcondv(); int [o]info(); [t]rwork(n); int [t]bwork(bworkn); SV* select_func)
Types: (float double)($w, $vs, $sdim, $rconde, $rcondv, $info) = cgeesx($A, $jobvs, $sort, $sense, $select_func);
cgeesx($A, $jobvs, $sort, $sense, $w, $vs, $sdim, $rconde, $rcondv, $info, $select_func); # all arguments given
($w, $vs, $sdim, $rconde, $rcondv, $info) = $A->cgeesx($jobvs, $sort, $sense, $select_func); # method call
$A->cgeesx($jobvs, $sort, $sense, $w, $vs, $sdim, $rconde, $rcondv, $info, $select_func);Complex version of "geesx" in PDL::LinearAlgebra::Real
select_func:
If sort = 1, select_func is used to select eigenvalues to sort
to the top left of the Schur form.
If sort = 0, select_func is not referenced.
An complex eigenvalue w is selected if
select_func(complex(w)) is true;
Note that a selected complex eigenvalue may no longer
satisfy select_func(complex(w)) = 1 after ordering, since
ordering may change the value of complex eigenvalues
(especially if the eigenvalue is ill-conditioned); in this
case info is set to N+2.Broadcasts over its inputs.
cgeesx ignores the bad-value flag of the input ndarrays. It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays.
cgges
Signature: (complex [io]A(n,n); int jobvsl();int jobvsr();int sort();complex [io]B(n,n);complex [o]alpha(n);complex [o]beta(n);complex [o]VSL(m,m);complex [o]VSR(p,p);int [o]sdim();int [o]info(); [t]rwork(rworkn=CALC(8*$SIZE(n))); int [t]bwork(bworkn); SV* select_func)
Types: (float double)($alpha, $beta, $VSL, $VSR, $sdim, $info) = cgges($A, $jobvsl, $jobvsr, $sort, $B, $select_func);
cgges($A, $jobvsl, $jobvsr, $sort, $B, $alpha, $beta, $VSL, $VSR, $sdim, $info, $select_func); # all arguments given
($alpha, $beta, $VSL, $VSR, $sdim, $info) = $A->cgges($jobvsl, $jobvsr, $sort, $B, $select_func); # method call
$A->cgges($jobvsl, $jobvsr, $sort, $B, $alpha, $beta, $VSL, $VSR, $sdim, $info, $select_func);Complex version of "ggees" in PDL::LinearAlgebra::Real
select_func:
If sort = 1, select_func is used to select eigenvalues to sort
to the top left of the Schur form.
If sort = 0, select_func is not referenced.
An eigenvalue w = w/beta is selected if
select_func(complex(w), complex(beta)) is true;
Note that a selected complex eigenvalue may no longer
satisfy select_func(complex(w),complex(beta)) = 1 after ordering, since
ordering may change the value of complex eigenvalues
(especially if the eigenvalue is ill-conditioned); in this
case info is set to N+2.Broadcasts over its inputs.
cgges ignores the bad-value flag of the input ndarrays. It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays.
cggesx
Signature: (complex [io]A(n,n); int jobvsl();int jobvsr();int sort();int sense();complex [io]B(n,n);complex [o]alpha(n);complex [o]beta(n);complex [o]VSL(m,m);complex [o]VSR(p,p);int [o]sdim();[o]rconde(q=2);[o]rcondv(q=2);int [o]info(); [t]rwork(rworkn=CALC(8*$SIZE(n))); int [t]bwork(bworkn); int [t]iwork(iworkn=CALC($SIZE(n)+2)); SV* select_func)
Types: (float double)($alpha, $beta, $VSL, $VSR, $sdim, $rconde, $rcondv, $info) = cggesx($A, $jobvsl, $jobvsr, $sort, $sense, $B, $select_func);
cggesx($A, $jobvsl, $jobvsr, $sort, $sense, $B, $alpha, $beta, $VSL, $VSR, $sdim, $rconde, $rcondv, $info, $select_func); # all arguments given
($alpha, $beta, $VSL, $VSR, $sdim, $rconde, $rcondv, $info) = $A->cggesx($jobvsl, $jobvsr, $sort, $sense, $B, $select_func); # method call
$A->cggesx($jobvsl, $jobvsr, $sort, $sense, $B, $alpha, $beta, $VSL, $VSR, $sdim, $rconde, $rcondv, $info, $select_func);Complex version of "ggeesx" in PDL::LinearAlgebra::Real
select_func:
If sort = 1, select_func is used to select eigenvalues to sort
to the top left of the Schur form.
If sort = 0, select_func is not referenced.
An eigenvalue w = w/beta is selected if
select_func(complex(w), complex(beta)) is true;
Note that a selected complex eigenvalue may no longer
satisfy select_func(complex(w),complex(beta)) = 1 after ordering, since
ordering may change the value of complex eigenvalues
(especially if the eigenvalue is ill-conditioned); in this
case info is set to N+3.Broadcasts over its inputs.
cggesx ignores the bad-value flag of the input ndarrays. It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays.
cheev
Signature: (complex [io]A(n,n); int jobz(); int uplo(); [o]w(n); int [o]info(); [t]rwork(rworkn=CALC(3*($SIZE(n)-2))))
Types: (float double)($w, $info) = cheev($A, $jobz, $uplo);
cheev($A, $jobz, $uplo, $w, $info); # all arguments given
($w, $info) = $A->cheev($jobz, $uplo); # method call
$A->cheev($jobz, $uplo, $w, $info);Complex version of "syev" in PDL::LinearAlgebra::Real for Hermitian matrix
Broadcasts over its inputs.
cheev ignores the bad-value flag of the input ndarrays. It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays.
cheevd
Signature: (complex [io]A(n,n); int jobz(); int uplo(); [o]w(n); int [o]info())
Types: (float double)($w, $info) = cheevd($A, $jobz, $uplo);
cheevd($A, $jobz, $uplo, $w, $info); # all arguments given
($w, $info) = $A->cheevd($jobz, $uplo); # method call
$A->cheevd($jobz, $uplo, $w, $info);Complex version of "syevd" in PDL::LinearAlgebra::Real for Hermitian matrix
Broadcasts over its inputs.
cheevd ignores the bad-value flag of the input ndarrays. It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays.
cheevx
Signature: (complex [io]A(n,n); int jobz(); int range(); int uplo(); vl(); vu(); int il(); int iu(); abstol(); int [o]m(); [o]w(n);complex [o]z(p,p);int [o]ifail(n); int [o]info(); [t]rwork(rworkn=CALC(7*$SIZE(n))); int [t]iwork(iworkn=CALC(5*$SIZE(n))))
Types: (float double)($m, $w, $z, $ifail, $info) = cheevx($A, $jobz, $range, $uplo, $vl, $vu, $il, $iu, $abstol);
cheevx($A, $jobz, $range, $uplo, $vl, $vu, $il, $iu, $abstol, $m, $w, $z, $ifail, $info); # all arguments given
($m, $w, $z, $ifail, $info) = $A->cheevx($jobz, $range, $uplo, $vl, $vu, $il, $iu, $abstol); # method call
$A->cheevx($jobz, $range, $uplo, $vl, $vu, $il, $iu, $abstol, $m, $w, $z, $ifail, $info);Complex version of "syevx" in PDL::LinearAlgebra::Real for Hermitian matrix
Broadcasts over its inputs.
cheevx ignores the bad-value flag of the input ndarrays. It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays.
cheevr
Signature: (complex [io]A(n,n); int jobz(); int range(); int uplo(); vl(); vu(); int il(); int iu(); abstol(); int [o]m(); [o]w(n);complex [o]z(p,q);int [o]isuppz(r); int [o]info())
Types: (float double)($m, $w, $z, $isuppz, $info) = cheevr($A, $jobz, $range, $uplo, $vl, $vu, $il, $iu, $abstol);
cheevr($A, $jobz, $range, $uplo, $vl, $vu, $il, $iu, $abstol, $m, $w, $z, $isuppz, $info); # all arguments given
($m, $w, $z, $isuppz, $info) = $A->cheevr($jobz, $range, $uplo, $vl, $vu, $il, $iu, $abstol); # method call
$A->cheevr($jobz, $range, $uplo, $vl, $vu, $il, $iu, $abstol, $m, $w, $z, $isuppz, $info);Complex version of "syevr" in PDL::LinearAlgebra::Real for Hermitian matrix
Broadcasts over its inputs.
cheevr ignores the bad-value flag of the input ndarrays. It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays.
chegv
Signature: (complex [io]A(n,n);int itype();int jobz(); int uplo();complex [io]B(n,n);[o]w(n); int [o]info(); [t]rwork(rworkn=CALC(3*($SIZE(n)-2))))
Types: (float double)($w, $info) = chegv($A, $itype, $jobz, $uplo, $B);
chegv($A, $itype, $jobz, $uplo, $B, $w, $info); # all arguments given
($w, $info) = $A->chegv($itype, $jobz, $uplo, $B); # method call
$A->chegv($itype, $jobz, $uplo, $B, $w, $info);Complex version of "sygv" in PDL::LinearAlgebra::Real for Hermitian matrix
Broadcasts over its inputs.
chegv ignores the bad-value flag of the input ndarrays. It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays.
chegvd
Signature: (complex [io]A(n,n);int itype();int jobz(); int uplo();complex [io]B(n,n);[o]w(n); int [o]info())
Types: (float double)($w, $info) = chegvd($A, $itype, $jobz, $uplo, $B);
chegvd($A, $itype, $jobz, $uplo, $B, $w, $info); # all arguments given
($w, $info) = $A->chegvd($itype, $jobz, $uplo, $B); # method call
$A->chegvd($itype, $jobz, $uplo, $B, $w, $info);Complex version of "sygvd" in PDL::LinearAlgebra::Real for Hermitian matrix
Broadcasts over its inputs.
chegvd ignores the bad-value flag of the input ndarrays. It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays.
chegvx
Signature: (complex [io]A(n,n);int itype();int jobz();int range();
int uplo();complex [io]B(n,n);vl();vu();int il();
int iu();abstol();int [o]m();[o]w(n);complex
[o]Z(p,p);int [o]ifail(n);int [o]info(); [t]rwork(rworkn=CALC(7*$SIZE(n))); int [t]iwork(iworkn=CALC(5*$SIZE(n)));
)
Types: (float double)($m, $w, $Z, $ifail, $info) = chegvx($A, $itype, $jobz, $range, $uplo, $B, $vl, $vu, $il, $iu, $abstol);
chegvx($A, $itype, $jobz, $range, $uplo, $B, $vl, $vu, $il, $iu, $abstol, $m, $w, $Z, $ifail, $info); # all arguments given
($m, $w, $Z, $ifail, $info) = $A->chegvx($itype, $jobz, $range, $uplo, $B, $vl, $vu, $il, $iu, $abstol); # method call
$A->chegvx($itype, $jobz, $range, $uplo, $B, $vl, $vu, $il, $iu, $abstol, $m, $w, $Z, $ifail, $info);Complex version of "sygvx" in PDL::LinearAlgebra::Real for Hermitian matrix
Broadcasts over its inputs.
chegvx ignores the bad-value flag of the input ndarrays. It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays.
cgesv
Signature: (complex [io]A(n,n);complex [io]B(n,m); int [o]ipiv(n); int [o]info())
Types: (float double)($ipiv, $info) = cgesv($A, $B);
cgesv($A, $B, $ipiv, $info); # all arguments given
($ipiv, $info) = $A->cgesv($B); # method call
$A->cgesv($B, $ipiv, $info);Complex version of "gesv" in PDL::LinearAlgebra::Real
Broadcasts over its inputs.
cgesv ignores the bad-value flag of the input ndarrays. It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays.
cgesvx
Signature: (complex [io]A(n,n); int trans(); int fact();complex [io]B(n,m);complex [io]af(n,n); int [io]ipiv(n); int [io]equed(); [o]r(p); [o]c(q);complex [o]X(n,m); [o]rcond(); [o]ferr(m); [o]berr(m); [o]rpvgrw(); int [o]info(); [t]rwork(rworkn=CALC(4*$SIZE(n))); [t]work(rworkn))
Types: (float double)($r, $c, $X, $rcond, $ferr, $berr, $rpvgrw, $info) = cgesvx($A, $trans, $fact, $B, $af, $ipiv, $equed);
cgesvx($A, $trans, $fact, $B, $af, $ipiv, $equed, $r, $c, $X, $rcond, $ferr, $berr, $rpvgrw, $info); # all arguments given
($r, $c, $X, $rcond, $ferr, $berr, $rpvgrw, $info) = $A->cgesvx($trans, $fact, $B, $af, $ipiv, $equed); # method call
$A->cgesvx($trans, $fact, $B, $af, $ipiv, $equed, $r, $c, $X, $rcond, $ferr, $berr, $rpvgrw, $info);Complex version of "gesvx" in PDL::LinearAlgebra::Real.
trans: Specifies the form of the system of equations:
= 0: A * X = B (No transpose)
= 1: A' * X = B (Transpose)
= 2: A**H * X = B (Conjugate transpose)Broadcasts over its inputs.
cgesvx ignores the bad-value flag of the input ndarrays. It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays.
csysv
Signature: (complex [io]A(n,n); int uplo();complex [io]B(n,m); int [o]ipiv(n); int [o]info())
Types: (float double)($ipiv, $info) = csysv($A, $uplo, $B);
csysv($A, $uplo, $B, $ipiv, $info); # all arguments given
($ipiv, $info) = $A->csysv($uplo, $B); # method call
$A->csysv($uplo, $B, $ipiv, $info);Complex version of "sysv" in PDL::LinearAlgebra::Real
Broadcasts over its inputs.
csysv ignores the bad-value flag of the input ndarrays. It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays.
csysvx
Signature: (complex A(n,n); int uplo(); int fact();complex B(n,m);complex [io]af(n,n); int [io]ipiv(n);complex [o]X(n,m); [o]rcond(); [o]ferr(m); [o]berr(m); int [o]info(); [t]rwork(n))
Types: (float double)($X, $rcond, $ferr, $berr, $info) = csysvx($A, $uplo, $fact, $B, $af, $ipiv);
csysvx($A, $uplo, $fact, $B, $af, $ipiv, $X, $rcond, $ferr, $berr, $info); # all arguments given
($X, $rcond, $ferr, $berr, $info) = $A->csysvx($uplo, $fact, $B, $af, $ipiv); # method call
$A->csysvx($uplo, $fact, $B, $af, $ipiv, $X, $rcond, $ferr, $berr, $info);Complex version of "sysvx" in PDL::LinearAlgebra::Real
Broadcasts over its inputs.
csysvx ignores the bad-value flag of the input ndarrays. It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays.
chesv
Signature: (complex [io]A(n,n); int uplo();complex [io]B(n,m); int [o]ipiv(n); int [o]info())
Types: (float double)($ipiv, $info) = chesv($A, $uplo, $B);
chesv($A, $uplo, $B, $ipiv, $info); # all arguments given
($ipiv, $info) = $A->chesv($uplo, $B); # method call
$A->chesv($uplo, $B, $ipiv, $info);Complex version of "sysv" in PDL::LinearAlgebra::Real for Hermitian matrix
Broadcasts over its inputs.
chesv ignores the bad-value flag of the input ndarrays. It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays.
chesvx
Signature: (complex A(n,n); int uplo(); int fact();complex B(n,m);complex [io]af(n,n); int [io]ipiv(n);complex [o]X(n,m); [o]rcond(); [o]ferr(m); [o]berr(m); int [o]info(); [t]rwork(n))
Types: (float double)($X, $rcond, $ferr, $berr, $info) = chesvx($A, $uplo, $fact, $B, $af, $ipiv);
chesvx($A, $uplo, $fact, $B, $af, $ipiv, $X, $rcond, $ferr, $berr, $info); # all arguments given
($X, $rcond, $ferr, $berr, $info) = $A->chesvx($uplo, $fact, $B, $af, $ipiv); # method call
$A->chesvx($uplo, $fact, $B, $af, $ipiv, $X, $rcond, $ferr, $berr, $info);Complex version of "sysvx" in PDL::LinearAlgebra::Real for Hermitian matrix
Broadcasts over its inputs.
chesvx ignores the bad-value flag of the input ndarrays. It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays.
cposv
Signature: (complex [io]A(n,n); int uplo();complex [io]B(n,m); int [o]info())
Types: (float double)$info = cposv($A, $uplo, $B);
cposv($A, $uplo, $B, $info); # all arguments given
$info = $A->cposv($uplo, $B); # method call
$A->cposv($uplo, $B, $info);Complex version of "posv" in PDL::LinearAlgebra::Real for Hermitian positive definite matrix
Broadcasts over its inputs.
cposv ignores the bad-value flag of the input ndarrays. It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays.
cposvx
Signature: (complex [io]A(n,n); int uplo(); int fact();complex [io]B(n,m);complex [io]af(n,n); int [io]equed(); [o]s(p);complex [o]X(n,m); [o]rcond(); [o]ferr(m); [o]berr(m); int [o]info(); [t]rwork(rworkn=CALC(2*$SIZE(n))); [t]work(workn=CALC(4*$SIZE(n))))
Types: (float double)($s, $X, $rcond, $ferr, $berr, $info) = cposvx($A, $uplo, $fact, $B, $af, $equed);
cposvx($A, $uplo, $fact, $B, $af, $equed, $s, $X, $rcond, $ferr, $berr, $info); # all arguments given
($s, $X, $rcond, $ferr, $berr, $info) = $A->cposvx($uplo, $fact, $B, $af, $equed); # method call
$A->cposvx($uplo, $fact, $B, $af, $equed, $s, $X, $rcond, $ferr, $berr, $info);Complex version of "posvx" in PDL::LinearAlgebra::Real for Hermitian positive definite matrix
Broadcasts over its inputs.
cposvx ignores the bad-value flag of the input ndarrays. It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays.
cgels
Signature: (complex [io]A(m,n); int trans();complex [io]B(p,q);int [o]info())
Types: (float double)$info = cgels($A, $trans, $B);
cgels($A, $trans, $B, $info); # all arguments given
$info = $A->cgels($trans, $B); # method call
$A->cgels($trans, $B, $info);Solves overdetermined or underdetermined complex linear systems involving an M-by-N matrix A, or its conjugate-transpose. Complex version of "gels" in PDL::LinearAlgebra::Real.
trans: = 0: the linear system involves A;
= 1: the linear system involves A**H.Broadcasts over its inputs.
cgels ignores the bad-value flag of the input ndarrays. It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays.
cgelsy
Signature: (complex [io]A(m,n);complex [io]B(p,q); rcond(); int [io]jpvt(n); int [o]rank();int [o]info(); [t]rwork(rworkn=CALC(2*$SIZE(n))))
Types: (float double)($rank, $info) = cgelsy($A, $B, $rcond, $jpvt);
cgelsy($A, $B, $rcond, $jpvt, $rank, $info); # all arguments given
($rank, $info) = $A->cgelsy($B, $rcond, $jpvt); # method call
$A->cgelsy($B, $rcond, $jpvt, $rank, $info);Complex version of "gelsy" in PDL::LinearAlgebra::Real
Broadcasts over its inputs.
cgelsy ignores the bad-value flag of the input ndarrays. It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays.
cgelss
Signature: (complex [io]A(m,n);complex [io]B(p,q); rcond(); [o]s(r); int [o]rank();int [o]info(); [t]rwork(rworkn=CALC(5*PDLMIN($SIZE(m),$SIZE(n)))))
Types: (float double)($s, $rank, $info) = cgelss($A, $B, $rcond);
cgelss($A, $B, $rcond, $s, $rank, $info); # all arguments given
($s, $rank, $info) = $A->cgelss($B, $rcond); # method call
$A->cgelss($B, $rcond, $s, $rank, $info);Complex version of "gelss" in PDL::LinearAlgebra::Real
Broadcasts over its inputs.
cgelss ignores the bad-value flag of the input ndarrays. It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays.
cgelsd
Signature: (complex [io]A(m,n);complex [io]B(p,q); rcond(); [o]s(minmn=CALC(PDLMAX(1,PDLMIN($SIZE(m),$SIZE(n))))); int [o]rank();int [o]info(); int [t]iwork(iworkn); [t]rwork(rworkn))
Types: (float double)($s, $rank, $info) = cgelsd($A, $B, $rcond);
cgelsd($A, $B, $rcond, $s, $rank, $info); # all arguments given
($s, $rank, $info) = $A->cgelsd($B, $rcond); # method call
$A->cgelsd($B, $rcond, $s, $rank, $info);Complex version of "gelsd" in PDL::LinearAlgebra::Real
Broadcasts over its inputs.
cgelsd ignores the bad-value flag of the input ndarrays. It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays.
cgglse
Signature: (complex [io]A(m,n);complex [io]B(p,n);complex [io]c(m);complex [io]d(p);complex [o]x(n);int [o]info())
Types: (float double)($x, $info) = cgglse($A, $B, $c, $d);
cgglse($A, $B, $c, $d, $x, $info); # all arguments given
($x, $info) = $A->cgglse($B, $c, $d); # method call
$A->cgglse($B, $c, $d, $x, $info);Complex version of "gglse" in PDL::LinearAlgebra::Real
Broadcasts over its inputs.
cgglse ignores the bad-value flag of the input ndarrays. It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays.
cggglm
Signature: (complex [io]A(n,m);complex [io]B(n,p);complex [io]d(n);complex [o]x(m);complex [o]y(p);int [o]info())
Types: (float double)($x, $y, $info) = cggglm($A, $B, $d);
cggglm($A, $B, $d, $x, $y, $info); # all arguments given
($x, $y, $info) = $A->cggglm($B, $d); # method call
$A->cggglm($B, $d, $x, $y, $info);Complex version of "ggglm" in PDL::LinearAlgebra::Real
Broadcasts over its inputs.
cggglm ignores the bad-value flag of the input ndarrays. It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays.
cgetrf
Signature: (complex [io]A(m,n); int [o]ipiv(p=CALC(PDLMIN($SIZE(m),$SIZE(n)))); int [o]info())
Types: (float double)($ipiv, $info) = cgetrf($A);
cgetrf($A, $ipiv, $info); # all arguments given
($ipiv, $info) = $A->cgetrf; # method call
$A->cgetrf($ipiv, $info);Complex version of "getrf" in PDL::LinearAlgebra::Real
Broadcasts over its inputs.
cgetrf ignores the bad-value flag of the input ndarrays. It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays.
cgetf2
Signature: (complex [io]A(m,n); int [o]ipiv(p=CALC(PDLMIN($SIZE(m),$SIZE(n)))); int [o]info())
Types: (float double)($ipiv, $info) = cgetf2($A);
cgetf2($A, $ipiv, $info); # all arguments given
($ipiv, $info) = $A->cgetf2; # method call
$A->cgetf2($ipiv, $info);Complex version of "getf2" in PDL::LinearAlgebra::Real
Broadcasts over its inputs.
cgetf2 ignores the bad-value flag of the input ndarrays. It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays.
csytrf
Signature: (complex [io]A(n,n); int uplo(); int [o]ipiv(n); int [o]info())
Types: (float double)($ipiv, $info) = csytrf($A, $uplo);
csytrf($A, $uplo, $ipiv, $info); # all arguments given
($ipiv, $info) = $A->csytrf($uplo); # method call
$A->csytrf($uplo, $ipiv, $info);Complex version of "sytrf" in PDL::LinearAlgebra::Real
Broadcasts over its inputs.
csytrf ignores the bad-value flag of the input ndarrays. It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays.
csytf2
Signature: (complex [io]A(n,n); int uplo(); int [o]ipiv(n); int [o]info())
Types: (float double)($ipiv, $info) = csytf2($A, $uplo);
csytf2($A, $uplo, $ipiv, $info); # all arguments given
($ipiv, $info) = $A->csytf2($uplo); # method call
$A->csytf2($uplo, $ipiv, $info);Complex version of "sytf2" in PDL::LinearAlgebra::Real
Broadcasts over its inputs.
csytf2 ignores the bad-value flag of the input ndarrays. It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays.
cchetrf
Signature: (complex [io]A(n,n); int uplo(); int [o]ipiv(n); int [o]info(); [t]work(workn))
Types: (float double)($ipiv, $info) = cchetrf($A, $uplo);
cchetrf($A, $uplo, $ipiv, $info); # all arguments given
($ipiv, $info) = $A->cchetrf($uplo); # method call
$A->cchetrf($uplo, $ipiv, $info);Complex version of "sytrf" in PDL::LinearAlgebra::Real for Hermitian matrix
Broadcasts over its inputs.
cchetrf ignores the bad-value flag of the input ndarrays. It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays.
chetf2
Signature: (complex [io]A(n,n); int uplo(); int [o]ipiv(n); int [o]info())
Types: (float double)($ipiv, $info) = chetf2($A, $uplo);
chetf2($A, $uplo, $ipiv, $info); # all arguments given
($ipiv, $info) = $A->chetf2($uplo); # method call
$A->chetf2($uplo, $ipiv, $info);Complex version of "sytf2" in PDL::LinearAlgebra::Real for Hermitian matrix
Broadcasts over its inputs.
chetf2 ignores the bad-value flag of the input ndarrays. It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays.
cpotrf
Signature: (complex [io]A(n,n); int uplo(); int [o]info())
Types: (float double)$info = cpotrf($A, $uplo);
cpotrf($A, $uplo, $info); # all arguments given
$info = $A->cpotrf($uplo); # method call
$A->cpotrf($uplo, $info);Complex version of "potrf" in PDL::LinearAlgebra::Real for Hermitian positive definite matrix
Broadcasts over its inputs.
cpotrf ignores the bad-value flag of the input ndarrays. It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays.
cpotf2
Signature: (complex [io]A(n,n); int uplo(); int [o]info())
Types: (float double)$info = cpotf2($A, $uplo);
cpotf2($A, $uplo, $info); # all arguments given
$info = $A->cpotf2($uplo); # method call
$A->cpotf2($uplo, $info);Complex version of "potf2" in PDL::LinearAlgebra::Real for Hermitian positive definite matrix
Broadcasts over its inputs.
cpotf2 ignores the bad-value flag of the input ndarrays. It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays.
cgetri
Signature: (complex [io]A(n,n); int ipiv(n); int [o]info())
Types: (float double)$info = cgetri($A, $ipiv);
cgetri($A, $ipiv, $info); # all arguments given
$info = $A->cgetri($ipiv); # method call
$A->cgetri($ipiv, $info);Complex version of "getri" in PDL::LinearAlgebra::Real
Broadcasts over its inputs.
cgetri ignores the bad-value flag of the input ndarrays. It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays.
csytri
Signature: (complex [io]A(n,n); int uplo(); int ipiv(n); int [o]info(); [t]work(workn=CALC(2*$SIZE(n))))
Types: (float double)$info = csytri($A, $uplo, $ipiv);
csytri($A, $uplo, $ipiv, $info); # all arguments given
$info = $A->csytri($uplo, $ipiv); # method call
$A->csytri($uplo, $ipiv, $info);Complex version of "sytri" in PDL::LinearAlgebra::Real
Broadcasts over its inputs.
csytri ignores the bad-value flag of the input ndarrays. It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays.
chetri
Signature: (complex [io]A(n,n); int uplo(); int ipiv(n); int [o]info(); [t]work(workn=CALC(2*$SIZE(n))))
Types: (float double)$info = chetri($A, $uplo, $ipiv);
chetri($A, $uplo, $ipiv, $info); # all arguments given
$info = $A->chetri($uplo, $ipiv); # method call
$A->chetri($uplo, $ipiv, $info);Complex version of "sytri" in PDL::LinearAlgebra::Real for Hermitian matrix
Broadcasts over its inputs.
chetri ignores the bad-value flag of the input ndarrays. It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays.
cpotri
Signature: (complex [io]A(n,n); int uplo(); int [o]info())
Types: (float double)$info = cpotri($A, $uplo);
cpotri($A, $uplo, $info); # all arguments given
$info = $A->cpotri($uplo); # method call
$A->cpotri($uplo, $info);Complex version of "potri" in PDL::LinearAlgebra::Real
Broadcasts over its inputs.
cpotri ignores the bad-value flag of the input ndarrays. It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays.
ctrtri
Signature: (complex [io]A(n,n); int uplo(); int diag(); int [o]info())
Types: (float double)$info = ctrtri($A, $uplo, $diag);
ctrtri($A, $uplo, $diag, $info); # all arguments given
$info = $A->ctrtri($uplo, $diag); # method call
$A->ctrtri($uplo, $diag, $info);Complex version of "trtri" in PDL::LinearAlgebra::Real
Broadcasts over its inputs.
ctrtri ignores the bad-value flag of the input ndarrays. It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays.
ctrti2
Signature: (complex [io]A(n,n); int uplo(); int diag(); int [o]info())
Types: (float double)$info = ctrti2($A, $uplo, $diag);
ctrti2($A, $uplo, $diag, $info); # all arguments given
$info = $A->ctrti2($uplo, $diag); # method call
$A->ctrti2($uplo, $diag, $info);Complex version of "trti2" in PDL::LinearAlgebra::Real
Broadcasts over its inputs.
ctrti2 ignores the bad-value flag of the input ndarrays. It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays.
cgetrs
Signature: (complex A(n,n); int trans();complex [io]B(n,m); int ipiv(n); int [o]info())
Types: (float double)$info = cgetrs($A, $trans, $B, $ipiv);
cgetrs($A, $trans, $B, $ipiv, $info); # all arguments given
$info = $A->cgetrs($trans, $B, $ipiv); # method call
$A->cgetrs($trans, $B, $ipiv, $info);Complex version of "getrs" in PDL::LinearAlgebra::Real
Arguments
=========
trans: = 0: No transpose;
= 1: Transpose;
= 2: Conjugate transpose;Broadcasts over its inputs.
cgetrs ignores the bad-value flag of the input ndarrays. It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays.
csytrs
Signature: (complex A(n,n); int uplo();complex [io]B(n,m); int ipiv(n); int [o]info())
Types: (float double)$info = csytrs($A, $uplo, $B, $ipiv);
csytrs($A, $uplo, $B, $ipiv, $info); # all arguments given
$info = $A->csytrs($uplo, $B, $ipiv); # method call
$A->csytrs($uplo, $B, $ipiv, $info);Complex version of "sytrs" in PDL::LinearAlgebra::Real
Broadcasts over its inputs.
csytrs ignores the bad-value flag of the input ndarrays. It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays.
chetrs
Signature: (complex A(n,n); int uplo();complex [io]B(n,m); int ipiv(n); int [o]info())
Types: (float double)$info = chetrs($A, $uplo, $B, $ipiv);
chetrs($A, $uplo, $B, $ipiv, $info); # all arguments given
$info = $A->chetrs($uplo, $B, $ipiv); # method call
$A->chetrs($uplo, $B, $ipiv, $info);Complex version of "sytrs" in PDL::LinearAlgebra::Real for Hermitian matrix
Broadcasts over its inputs.
chetrs ignores the bad-value flag of the input ndarrays. It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays.
cpotrs
Signature: (complex A(n,n); int uplo();complex [io]B(n,m); int [o]info())
Types: (float double)$info = cpotrs($A, $uplo, $B);
cpotrs($A, $uplo, $B, $info); # all arguments given
$info = $A->cpotrs($uplo, $B); # method call
$A->cpotrs($uplo, $B, $info);Complex version of "potrs" in PDL::LinearAlgebra::Real for Hermitian positive definite matrix
Broadcasts over its inputs.
cpotrs ignores the bad-value flag of the input ndarrays. It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays.
ctrtrs
Signature: (complex A(n,n); int uplo(); int trans(); int diag();complex [io]B(n,m); int [o]info())
Types: (float double)$info = ctrtrs($A, $uplo, $trans, $diag, $B);
ctrtrs($A, $uplo, $trans, $diag, $B, $info); # all arguments given
$info = $A->ctrtrs($uplo, $trans, $diag, $B); # method call
$A->ctrtrs($uplo, $trans, $diag, $B, $info);Complex version of "trtrs" in PDL::LinearAlgebra::Real
Arguments
=========
trans: = 0: No transpose;
= 1: Transpose;
= 2: Conjugate transpose;Broadcasts over its inputs.
ctrtrs ignores the bad-value flag of the input ndarrays. It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays.
clatrs
Signature: (complex A(n,n); int uplo(); int trans(); int diag(); int normin();complex [io]x(n); [o]scale();[io]cnorm(n);int [o]info())
Types: (float double)($scale, $info) = clatrs($A, $uplo, $trans, $diag, $normin, $x, $cnorm);
clatrs($A, $uplo, $trans, $diag, $normin, $x, $scale, $cnorm, $info); # all arguments given
($scale, $info) = $A->clatrs($uplo, $trans, $diag, $normin, $x, $cnorm); # method call
$A->clatrs($uplo, $trans, $diag, $normin, $x, $scale, $cnorm, $info);Complex version of "latrs" in PDL::LinearAlgebra::Real
Arguments
=========
trans: = 0: No transpose;
= 1: Transpose;
= 2: Conjugate transpose;Broadcasts over its inputs.
clatrs ignores the bad-value flag of the input ndarrays. It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays.
cgecon
Signature: (complex A(n,n); int norm(); anorm(); [o]rcond();int [o]info(); [t]rwork(rworkn=CALC(2*$SIZE(n))); [t]work(workn=CALC(4*$SIZE(n))))
Types: (float double)($rcond, $info) = cgecon($A, $norm, $anorm);
cgecon($A, $norm, $anorm, $rcond, $info); # all arguments given
($rcond, $info) = $A->cgecon($norm, $anorm); # method call
$A->cgecon($norm, $anorm, $rcond, $info);Complex version of "gecon" in PDL::LinearAlgebra::Real
Broadcasts over its inputs.
cgecon ignores the bad-value flag of the input ndarrays. It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays.
csycon
Signature: (complex A(n,n); int uplo(); int ipiv(n); anorm(); [o]rcond();int [o]info(); [t]work(workn=CALC(4*$SIZE(n))))
Types: (float double)($rcond, $info) = csycon($A, $uplo, $ipiv, $anorm);
csycon($A, $uplo, $ipiv, $anorm, $rcond, $info); # all arguments given
($rcond, $info) = $A->csycon($uplo, $ipiv, $anorm); # method call
$A->csycon($uplo, $ipiv, $anorm, $rcond, $info);Complex version of "sycon" in PDL::LinearAlgebra::Real
Broadcasts over its inputs.
csycon ignores the bad-value flag of the input ndarrays. It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays.
checon
Signature: (complex A(n,n); int uplo(); int ipiv(n); anorm(); [o]rcond();int [o]info(); [t]work(workn=CALC(4*$SIZE(n))))
Types: (float double)($rcond, $info) = checon($A, $uplo, $ipiv, $anorm);
checon($A, $uplo, $ipiv, $anorm, $rcond, $info); # all arguments given
($rcond, $info) = $A->checon($uplo, $ipiv, $anorm); # method call
$A->checon($uplo, $ipiv, $anorm, $rcond, $info);Complex version of "sycon" in PDL::LinearAlgebra::Real for Hermitian matrix
Broadcasts over its inputs.
checon ignores the bad-value flag of the input ndarrays. It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays.
cpocon
Signature: (complex A(n,n); int uplo(); anorm(); [o]rcond();int [o]info(); [t]work(workn=CALC(4*$SIZE(n))); [t]rwork(n))
Types: (float double)($rcond, $info) = cpocon($A, $uplo, $anorm);
cpocon($A, $uplo, $anorm, $rcond, $info); # all arguments given
($rcond, $info) = $A->cpocon($uplo, $anorm); # method call
$A->cpocon($uplo, $anorm, $rcond, $info);Complex version of "pocon" in PDL::LinearAlgebra::Real for Hermitian positive definite matrix
Broadcasts over its inputs.
cpocon ignores the bad-value flag of the input ndarrays. It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays.
ctrcon
Signature: (complex A(n,n); int norm();int uplo();int diag(); [o]rcond();int [o]info(); [t]work(workn=CALC(4*$SIZE(n))); [t]rwork(n))
Types: (float double)($rcond, $info) = ctrcon($A, $norm, $uplo, $diag);
ctrcon($A, $norm, $uplo, $diag, $rcond, $info); # all arguments given
($rcond, $info) = $A->ctrcon($norm, $uplo, $diag); # method call
$A->ctrcon($norm, $uplo, $diag, $rcond, $info);Complex version of "trcon" in PDL::LinearAlgebra::Real
Broadcasts over its inputs.
ctrcon ignores the bad-value flag of the input ndarrays. It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays.
cgeqp3
Signature: (complex [io]A(m,n); int [io]jpvt(n);complex [o]tau(k); int [o]info(); [t]rwork(rworkn=CALC(2*$SIZE(n))))
Types: (float double)($tau, $info) = cgeqp3($A, $jpvt);
cgeqp3($A, $jpvt, $tau, $info); # all arguments given
($tau, $info) = $A->cgeqp3($jpvt); # method call
$A->cgeqp3($jpvt, $tau, $info);Complex version of "geqp3" in PDL::LinearAlgebra::Real
Broadcasts over its inputs.
cgeqp3 ignores the bad-value flag of the input ndarrays. It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays.
cgeqrf
Signature: (complex [io]A(m,n);complex [o]tau(k); int [o]info())
Types: (float double)($tau, $info) = cgeqrf($A);
cgeqrf($A, $tau, $info); # all arguments given
($tau, $info) = $A->cgeqrf; # method call
$A->cgeqrf($tau, $info);Complex version of "geqrf" in PDL::LinearAlgebra::Real
Broadcasts over its inputs.
cgeqrf ignores the bad-value flag of the input ndarrays. It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays.
cungqr
Signature: (complex [io]A(m,n);complex tau(k); int [o]info())
Types: (float double)$info = cungqr($A, $tau);
cungqr($A, $tau, $info); # all arguments given
$info = $A->cungqr($tau); # method call
$A->cungqr($tau, $info);Complex version of "orgqr" in PDL::LinearAlgebra::Real
Broadcasts over its inputs.
cungqr ignores the bad-value flag of the input ndarrays. It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays.
cunmqr
Signature: (complex A(p,k); int side(); int trans();complex tau(k);complex [io]C(m,n);int [o]info())
Types: (float double)$info = cunmqr($A, $side, $trans, $tau, $C);
cunmqr($A, $side, $trans, $tau, $C, $info); # all arguments given
$info = $A->cunmqr($side, $trans, $tau, $C); # method call
$A->cunmqr($side, $trans, $tau, $C, $info);Complex version of "ormqr" in PDL::LinearAlgebra::Real. Here trans = 1 means conjugate transpose.
Broadcasts over its inputs.
cunmqr ignores the bad-value flag of the input ndarrays. It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays.
cgelqf
Signature: (complex [io]A(m,n);complex [o]tau(k); int [o]info())
Types: (float double)($tau, $info) = cgelqf($A);
cgelqf($A, $tau, $info); # all arguments given
($tau, $info) = $A->cgelqf; # method call
$A->cgelqf($tau, $info);Complex version of "gelqf" in PDL::LinearAlgebra::Real
Broadcasts over its inputs.
cgelqf ignores the bad-value flag of the input ndarrays. It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays.
cunglq
Signature: (complex [io]A(m,n);complex tau(k); int [o]info())
Types: (float double)$info = cunglq($A, $tau);
cunglq($A, $tau, $info); # all arguments given
$info = $A->cunglq($tau); # method call
$A->cunglq($tau, $info);Complex version of "orglq" in PDL::LinearAlgebra::Real
Broadcasts over its inputs.
cunglq ignores the bad-value flag of the input ndarrays. It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays.
cunmlq
Signature: (complex A(k,p); int side(); int trans();complex tau(k);complex [io]C(m,n);int [o]info())
Types: (float double)$info = cunmlq($A, $side, $trans, $tau, $C);
cunmlq($A, $side, $trans, $tau, $C, $info); # all arguments given
$info = $A->cunmlq($side, $trans, $tau, $C); # method call
$A->cunmlq($side, $trans, $tau, $C, $info);Complex version of "ormlq" in PDL::LinearAlgebra::Real. Here trans = 1 means conjugate transpose.
Broadcasts over its inputs.
cunmlq ignores the bad-value flag of the input ndarrays. It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays.
cgeqlf
Signature: (complex [io]A(m,n);complex [o]tau(k); int [o]info())
Types: (float double)($tau, $info) = cgeqlf($A);
cgeqlf($A, $tau, $info); # all arguments given
($tau, $info) = $A->cgeqlf; # method call
$A->cgeqlf($tau, $info);Complex version of "geqlf" in PDL::LinearAlgebra::Real
Broadcasts over its inputs.
cgeqlf ignores the bad-value flag of the input ndarrays. It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays.
cungql
Signature: (complex [io]A(m,n);complex tau(k); int [o]info())
Types: (float double)$info = cungql($A, $tau);
cungql($A, $tau, $info); # all arguments given
$info = $A->cungql($tau); # method call
$A->cungql($tau, $info);Broadcasts over its inputs.
cungql ignores the bad-value flag of the input ndarrays. It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays.
cunmql
Signature: (complex A(p,k); int side(); int trans();complex tau(k);complex [io]C(m,n);int [o]info())
Types: (float double)$info = cunmql($A, $side, $trans, $tau, $C);
cunmql($A, $side, $trans, $tau, $C, $info); # all arguments given
$info = $A->cunmql($side, $trans, $tau, $C); # method call
$A->cunmql($side, $trans, $tau, $C, $info);Complex version of "ormql" in PDL::LinearAlgebra::Real. Here trans = 1 means conjugate transpose.
Broadcasts over its inputs.
cunmql ignores the bad-value flag of the input ndarrays. It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays.
cgerqf
Signature: (complex [io]A(m,n);complex [o]tau(k); int [o]info())
Types: (float double)($tau, $info) = cgerqf($A);
cgerqf($A, $tau, $info); # all arguments given
($tau, $info) = $A->cgerqf; # method call
$A->cgerqf($tau, $info);Complex version of "gerqf" in PDL::LinearAlgebra::Real
Broadcasts over its inputs.
cgerqf ignores the bad-value flag of the input ndarrays. It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays.
cungrq
Signature: (complex [io]A(m,n);complex tau(k); int [o]info())
Types: (float double)$info = cungrq($A, $tau);
cungrq($A, $tau, $info); # all arguments given
$info = $A->cungrq($tau); # method call
$A->cungrq($tau, $info);Complex version of "orgrq" in PDL::LinearAlgebra::Real.
Broadcasts over its inputs.
cungrq ignores the bad-value flag of the input ndarrays. It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays.
cunmrq
Signature: (complex A(k,p); int side(); int trans();complex tau(k);complex [io]C(m,n);int [o]info())
Types: (float double)$info = cunmrq($A, $side, $trans, $tau, $C);
cunmrq($A, $side, $trans, $tau, $C, $info); # all arguments given
$info = $A->cunmrq($side, $trans, $tau, $C); # method call
$A->cunmrq($side, $trans, $tau, $C, $info);Complex version of "ormrq" in PDL::LinearAlgebra::Real. Here trans = 1 means conjugate transpose.
Broadcasts over its inputs.
cunmrq ignores the bad-value flag of the input ndarrays. It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays.
ctzrzf
Signature: (complex [io]A(m,n);complex [o]tau(k); int [o]info())
Types: (float double)($tau, $info) = ctzrzf($A);
ctzrzf($A, $tau, $info); # all arguments given
($tau, $info) = $A->ctzrzf; # method call
$A->ctzrzf($tau, $info);Complex version of "tzrzf" in PDL::LinearAlgebra::Real
Broadcasts over its inputs.
ctzrzf ignores the bad-value flag of the input ndarrays. It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays.
cunmrz
Signature: (complex A(k,p); int side(); int trans();complex tau(k);complex [io]C(m,n);int [o]info())
Types: (float double)$info = cunmrz($A, $side, $trans, $tau, $C);
cunmrz($A, $side, $trans, $tau, $C, $info); # all arguments given
$info = $A->cunmrz($side, $trans, $tau, $C); # method call
$A->cunmrz($side, $trans, $tau, $C, $info);Complex version of "ormrz" in PDL::LinearAlgebra::Real. Here trans = 1 means conjugate transpose.
Broadcasts over its inputs.
cunmrz ignores the bad-value flag of the input ndarrays. It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays.
cgehrd
Signature: (complex [io]A(n,n); int ilo();int ihi();complex [o]tau(k); int [o]info())
Types: (float double)($tau, $info) = cgehrd($A, $ilo, $ihi);
cgehrd($A, $ilo, $ihi, $tau, $info); # all arguments given
($tau, $info) = $A->cgehrd($ilo, $ihi); # method call
$A->cgehrd($ilo, $ihi, $tau, $info);Complex version of "gehrd" in PDL::LinearAlgebra::Real
Broadcasts over its inputs.
cgehrd ignores the bad-value flag of the input ndarrays. It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays.
cunghr
Signature: (complex [io]A(n,n); int ilo();int ihi();complex tau(k); int [o]info())
Types: (float double)$info = cunghr($A, $ilo, $ihi, $tau);
cunghr($A, $ilo, $ihi, $tau, $info); # all arguments given
$info = $A->cunghr($ilo, $ihi, $tau); # method call
$A->cunghr($ilo, $ihi, $tau, $info);Complex version of "orghr" in PDL::LinearAlgebra::Real
Broadcasts over its inputs.
cunghr ignores the bad-value flag of the input ndarrays. It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays.
chseqr
Signature: (complex [io]H(n,n); int job();int compz();int ilo();int ihi();complex [o]w(n);complex [o]Z(m,m); int [o]info())
Types: (float double)($w, $Z, $info) = chseqr($H, $job, $compz, $ilo, $ihi);
chseqr($H, $job, $compz, $ilo, $ihi, $w, $Z, $info); # all arguments given
($w, $Z, $info) = $H->chseqr($job, $compz, $ilo, $ihi); # method call
$H->chseqr($job, $compz, $ilo, $ihi, $w, $Z, $info);Complex version of "hseqr" in PDL::LinearAlgebra::Real
Broadcasts over its inputs.
chseqr ignores the bad-value flag of the input ndarrays. It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays.
ctrevc
Signature: (complex T(n,n); int side();int howmny();int select(q);complex [o]VL(m,m);complex [o]VR(p,p);int [o]m(); int [o]info(); [t]work(workn=CALC(5*$SIZE(n))))
Types: (float double)($VL, $VR, $m, $info) = ctrevc($T, $side, $howmny, $select);
ctrevc($T, $side, $howmny, $select, $VL, $VR, $m, $info); # all arguments given
($VL, $VR, $m, $info) = $T->ctrevc($side, $howmny, $select); # method call
$T->ctrevc($side, $howmny, $select, $VL, $VR, $m, $info);Complex version of "trevc" in PDL::LinearAlgebra::Real
Broadcasts over its inputs.
ctrevc ignores the bad-value flag of the input ndarrays. It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays.
ctgevc
Signature: (complex A(n,n); int side();int howmny();complex B(n,n);int select(q);complex [o]VL(m,m);complex [o]VR(p,p);int [o]m(); int [o]info(); [t]work(workn=CALC(6*$SIZE(n))))
Types: (float double)($VL, $VR, $m, $info) = ctgevc($A, $side, $howmny, $B, $select);
ctgevc($A, $side, $howmny, $B, $select, $VL, $VR, $m, $info); # all arguments given
($VL, $VR, $m, $info) = $A->ctgevc($side, $howmny, $B, $select); # method call
$A->ctgevc($side, $howmny, $B, $select, $VL, $VR, $m, $info);Complex version of "tgevc" in PDL::LinearAlgebra::Real
Broadcasts over its inputs.
ctgevc ignores the bad-value flag of the input ndarrays. It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays.
cgebal
Signature: (complex [io]A(n,n); int job(); int [o]ilo();int [o]ihi();[o]scale(n); int [o]info())
Types: (float double)($ilo, $ihi, $scale, $info) = cgebal($A, $job);
cgebal($A, $job, $ilo, $ihi, $scale, $info); # all arguments given
($ilo, $ihi, $scale, $info) = $A->cgebal($job); # method call
$A->cgebal($job, $ilo, $ihi, $scale, $info);Complex version of "gebal" in PDL::LinearAlgebra::Real
Broadcasts over its inputs.
cgebal ignores the bad-value flag of the input ndarrays. It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays.
clange
Signature: (complex A(n,m); int norm(); [o]b(); [t]work(workn))
Types: (float double)$b = clange($A, $norm);
clange($A, $norm, $b); # all arguments given
$b = $A->clange($norm); # method call
$A->clange($norm, $b);Complex version of "lange" in PDL::LinearAlgebra::Real
Broadcasts over its inputs.
clange ignores the bad-value flag of the input ndarrays. It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays.
clansy
Signature: (complex A(n,n); int uplo(); int norm(); [o]b(); [t]work(workn))
Types: (float double)$b = clansy($A, $uplo, $norm);
clansy($A, $uplo, $norm, $b); # all arguments given
$b = $A->clansy($uplo, $norm); # method call
$A->clansy($uplo, $norm, $b);Complex version of "lansy" in PDL::LinearAlgebra::Real
Broadcasts over its inputs.
clansy ignores the bad-value flag of the input ndarrays. It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays.
clantr
Signature: (complex A(m,n); int uplo(); int norm();int diag(); [o]b(); [t]work(workn))
Types: (float double)$b = clantr($A, $uplo, $norm, $diag);
clantr($A, $uplo, $norm, $diag, $b); # all arguments given
$b = $A->clantr($uplo, $norm, $diag); # method call
$A->clantr($uplo, $norm, $diag, $b);Complex version of "lantr" in PDL::LinearAlgebra::Real
Broadcasts over its inputs.
clantr ignores the bad-value flag of the input ndarrays. It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays.
cgemm
Signature: (complex A(m,n); int transa(); int transb();complex B(p,q);complex alpha();complex beta();complex [io]C(r,s))
Types: (float double)cgemm($A, $transa, $transb, $B, $alpha, $beta, $C); # all arguments given
$A->cgemm($transa, $transb, $B, $alpha, $beta, $C); # method callComplex version of "gemm" in PDL::LinearAlgebra::Real.
Arguments
=========
transa: = 0: No transpose;
= 1: Transpose;
= 2: Conjugate transpose;
transb: = 0: No transpose;
= 1: Transpose;
= 2: Conjugate transpose;Broadcasts over its inputs.
cgemm ignores the bad-value flag of the input ndarrays. It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays.
cmmult
Signature: (complex A(m,n);complex B(p,m);complex [o]C(p,n))
Types: (float double)$C = cmmult($A, $B);
cmmult($A, $B, $C); # all arguments given
$C = $A->cmmult($B); # method call
$A->cmmult($B, $C);Complex version of "mmult" in PDL::LinearAlgebra::Real
Broadcasts over its inputs.
cmmult ignores the bad-value flag of the input ndarrays. It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays.
ccrossprod
Signature: (complex A(n,m);complex B(p,m);complex [o]C(p,n))
Types: (float double)$C = ccrossprod($A, $B);
ccrossprod($A, $B, $C); # all arguments given
$C = $A->ccrossprod($B); # method call
$A->ccrossprod($B, $C);Complex version of "crossprod" in PDL::LinearAlgebra::Real
Broadcasts over its inputs.
ccrossprod ignores the bad-value flag of the input ndarrays. It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays.
csyrk
Signature: (complex A(m,n); int uplo(); int trans();complex alpha();complex beta();complex [io]C(p,p))
Types: (float double)csyrk($A, $uplo, $trans, $alpha, $beta, $C); # all arguments given
$A->csyrk($uplo, $trans, $alpha, $beta, $C); # method callComplex version of "syrk" in PDL::LinearAlgebra::Real
Broadcasts over its inputs.
csyrk ignores the bad-value flag of the input ndarrays. It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays.
cdot
Signature: (complex a(n);complex b(n);complex [o]c())
Types: (float double)$c = cdot($a, $b);
cdot($a, $b, $c); # all arguments given
$c = $a->cdot($b); # method call
$a->cdot($b, $c);Complex version of "dot" in PDL::LinearAlgebra::Real
Broadcasts over its inputs.
cdot ignores the bad-value flag of the input ndarrays. It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays.
cdotc
Signature: (complex a(n);complex b(n);complex [o]c())
Types: (float double)$c = cdotc($a, $b);
cdotc($a, $b, $c); # all arguments given
$c = $a->cdotc($b); # method call
$a->cdotc($b, $c);Forms the dot product of two vectors, conjugating the first vector.
Broadcasts over its inputs.
cdotc ignores the bad-value flag of the input ndarrays. It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays.
caxpy
Signature: (complex a(n);complex alpha();complex [io]b(n))
Types: (float double)caxpy($a, $alpha, $b); # all arguments given
$a->caxpy($alpha, $b); # method callComplex version of "axpy" in PDL::LinearAlgebra::Real
Broadcasts over its inputs.
caxpy ignores the bad-value flag of the input ndarrays. It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays.
cnrm2
Signature: (complex a(n);[o]b())
Types: (float double)$b = cnrm2($a);
cnrm2($a, $b); # all arguments given
$b = $a->cnrm2; # method call
$a->cnrm2($b);Complex version of "nrm2" in PDL::LinearAlgebra::Real
Broadcasts over its inputs.
cnrm2 ignores the bad-value flag of the input ndarrays. It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays.
casum
Signature: (complex a(n);[o]b())
Types: (float double)$b = casum($a);
casum($a, $b); # all arguments given
$b = $a->casum; # method call
$a->casum($b);Complex version of "asum" in PDL::LinearAlgebra::Real
Broadcasts over its inputs.
casum ignores the bad-value flag of the input ndarrays. It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays.
cscal
Signature: (complex [io]a(n);complex scale())
Types: (float double)cscal($a, $scale); # all arguments given
$a->cscal($scale); # method callComplex version of "scal" in PDL::LinearAlgebra::Real
Broadcasts over its inputs.
cscal ignores the bad-value flag of the input ndarrays. It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays.
csscal
Signature: (complex [io]a(n);scale())
Types: (float double)csscal($a, $scale); # all arguments given
$a->csscal($scale); # method callScales a complex vector by a real constant.
Broadcasts over its inputs.
csscal ignores the bad-value flag of the input ndarrays. It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays.
crotg
Signature: (complex [io]a();complex b();[o]c();complex [o]s())
Types: (float double)($c, $s) = crotg($a, $b);
crotg($a, $b, $c, $s); # all arguments given
($c, $s) = $a->crotg($b); # method call
$a->crotg($b, $c, $s);Complex version of "rotg" in PDL::LinearAlgebra::Real
Broadcasts over its inputs.
crotg ignores the bad-value flag of the input ndarrays. It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays.
clacpy
Signature: (complex A(m,n); int uplo();complex [o]B(p,n))
Types: (float double)$B = clacpy($A, $uplo);
clacpy($A, $uplo, $B); # all arguments given
$B = $A->clacpy($uplo); # method call
$A->clacpy($uplo, $B);Complex version of "lacpy" in PDL::LinearAlgebra::Real
Broadcasts over its inputs.
clacpy ignores the bad-value flag of the input ndarrays. It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays.
claswp
Signature: (complex [io]A(m,n); int k1(); int k2(); int ipiv(p))
Types: (float double)claswp($A, $k1, $k2, $ipiv); # all arguments given
$A->claswp($k1, $k2, $ipiv); # method callComplex version of "laswp" in PDL::LinearAlgebra::Real
Broadcasts over its inputs.
claswp ignores the bad-value flag of the input ndarrays. It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays.
ccharpol
Signature: (A(c=2,n,n);[o]Y(c=2,n,n);[o]out(c=2,p=CALC($SIZE(n)+1)); [t]rwork(rworkn=CALC(2*$SIZE(n)*$SIZE(n))))
Types: (float double)($Y, $out) = ccharpol($A);
ccharpol($A, $Y, $out); # all arguments given
($Y, $out) = $A->ccharpol; # method call
$A->ccharpol($Y, $out);Complex version of "charpol" in PDL::LinearAlgebra::Real
Broadcasts over its inputs.
ccharpol does not process bad values. It will set the bad-value flag of all output ndarrays if the flag is set for any of the input ndarrays.
AUTHOR
Copyright (C) Grégory Vanuxem 2005-2018.
This library is free software; you can redistribute it and/or modify it under the terms of the Perl Artistic License as in the file Artistic_2 in this distribution.