---
name: "PDL::LinearAlgebra::Complex"
section: "3pm"
platform: "linux"
package: "libpdl-linearalgebra-perl"
version: "0.35-1+b2"
release: "Debian 12 (Bookworm)"
platforms: ["linux"]
url: "https://new.carta.tech/PDL::LinearAlgebra::Complex"
---

# PDL::LinearAlgebra::Complex(3pm)

PDL interface to the lapack linear algebra programming library (complex number)

## 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. #line 68 "Complex.pm"

## FUNCTIONS

### cgtsv

```
  Signature: (complex [phys]DL(n);complex  [phys]D(n);complex  [phys]DU(n);complex  [io,phys]B(n,nrhs); int [o,phys]info())
```

Solves the equation

```
        A * X = B
```

where 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;
```

### cgesvd

```
  Signature: (complex [io]A(m,n); int jobu(); int jobvt(); [o]s(minmn);complex  [o]U(p,p);complex  [o]VT(s,s); int [o]info(); [t]rwork(rworkn))
```

Complex version of "gesvd" in PDL::LinearAlgebra::Real.

The SVD is written

```
 A = U * SIGMA * ConjugateTranspose(V)
```

### cgesdd

```
  Signature: (complex [io]A(m,n); int jobz(); [o]s(minmn);complex  [o]U(p,p);complex  [o]VT(s,s); int [o]info(); int [t]iwork(iworkn))
```

Complex version of "gesdd" in PDL::LinearAlgebra::Real.

The SVD is written

```
 A = U * SIGMA * ConjugateTranspose(V)
```

### 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))
```

Complex version of "ggsvd" in PDL::LinearAlgebra::Real

### cgeev

```
  Signature: (complex 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))
```

Complex version of "geev" in PDL::LinearAlgebra::Real

### 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))
```

Complex version of "geevx" in PDL::LinearAlgebra::Real

### cggev

```
  Signature: (complex A(n,n); int [phys]jobvl();int [phys]jobvr();complex 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))
```

Complex version of "ggev" in PDL::LinearAlgebra::Real

### cggevx

```
  Signature: (complex [io,phys]A(n,n);int balanc();int jobvl();int jobvr();int sense();complex [io,phys]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); int [t]bwork(bworkn); int [t]iwork(iworkn))
```

Complex version of "ggevx" in PDL::LinearAlgebra::Real

### 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)
```

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(PDL::Complex(w)) is true;
            Note that a selected complex eigenvalue may no longer
            satisfy select_func(PDL::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.
```

### 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)
```

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(PDL::Complex(w)) is true;
            Note that a selected complex eigenvalue may no longer
            satisfy select_func(PDL::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.
```

### 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); int [t]bwork(bworkn);SV* 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(PDL::Complex(w), PDL::Complex(beta)) is true;
            Note that a selected complex eigenvalue may no longer
            satisfy select_func(PDL::Complex(w),PDL::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.
```

### 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); int [t]bwork(bworkn); int [t]iwork(iworkn);SV* 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(PDL::Complex(w), PDL::Complex(beta)) is true;
            Note that a selected complex eigenvalue may no longer
            satisfy select_func(PDL::Complex(w),PDL::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.
```

### cheev

```
  Signature: (complex [io]A(n,n); int jobz(); int uplo(); [o]w(n); int [o]info(); [t]rwork(rworkn))
```

Complex version of "syev" in PDL::LinearAlgebra::Real for Hermitian matrix

### cheevd

```
  Signature: (complex [io,phys]A(n,n);  int jobz(); int uplo(); [o,phys]w(n); int [o,phys]info())
```

Complex version of "syevd" in PDL::LinearAlgebra::Real for Hermitian matrix

### cheevx

```
  Signature: (complex 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); int [t]iwork(iworkn))
```

Complex version of "syevx" in PDL::LinearAlgebra::Real for Hermitian matrix

### cheevr

```
  Signature: (complex [phys]A(n,n);  int jobz(); int range(); int uplo(); [phys]vl(); [phys]vu(); int [phys]il(); int [phys]iu(); [phys]abstol(); int [o,phys]m(); [o,phys]w(n);complex  [o,phys]z(p,q);int [o,phys]isuppz(r); int [o,phys]info())
```

Complex version of "syevr" in PDL::LinearAlgebra::Real for Hermitian matrix

### 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))
```

Complex version of "sygv" in PDL::LinearAlgebra::Real for Hermitian matrix

### chegvd

```
  Signature: (complex [io,phys]A(n,n);int [phys]itype();int jobz(); int uplo();complex [io,phys]B(n,n);[o,phys]w(n); int [o,phys]info())
```

Complex version of "sygvd" in PDL::LinearAlgebra::Real for Hermitian matrix

### 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); int [t]iwork(iworkn);
        )
```

Complex version of "sygvx" in PDL::LinearAlgebra::Real for Hermitian matrix

### cgesv

```
  Signature: (complex [io,phys]A(n,n);complex   [io,phys]B(n,m); int [o,phys]ipiv(n); int [o,phys]info())
```

Complex version of "gesv" in PDL::LinearAlgebra::Real

### 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); [t]work(rworkn))
```

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)
```

### csysv

```
  Signature: (complex [io,phys]A(n,n);  int uplo();complex  [io,phys]B(n,m); int [o]ipiv(n); int [o]info())
```

Complex version of "sysv" in PDL::LinearAlgebra::Real

### csysvx

```
  Signature: (complex [phys]A(n,n); int uplo(); int fact();complex  [phys]B(n,m);complex  [io,phys]af(n,n); int [io,phys]ipiv(n);complex  [o]X(n,m); [o]rcond(); [o]ferr(m); [o]berr(m); int [o]info(); [t]rwork(n))
```

Complex version of "sysvx" in PDL::LinearAlgebra::Real

### chesv

```
  Signature: (complex [io,phys]A(n,n);  int uplo();complex  [io,phys]B(n,m); int [o,phys]ipiv(n); int [o,phys]info())
```

Complex version of "sysv" in PDL::LinearAlgebra::Real for Hermitian matrix

### 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))
```

Complex version of "sysvx" in PDL::LinearAlgebra::Real for Hermitian matrix

### cposv

```
  Signature: (complex [io,phys]A(n,n);  int uplo();complex  [io,phys]B(n,m); int [o,phys]info())
```

Complex version of "posv" in PDL::LinearAlgebra::Real for Hermitian positive definite matrix

### 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); [t]work(workn))
```

Complex version of "posvx" in PDL::LinearAlgebra::Real for Hermitian positive definite matrix

### cgels

```
  Signature: (complex [io,phys]A(m,n); int trans();complex  [io,phys]B(p,q);int [o,phys]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.
```

### 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))
```

Complex version of "gelsy" in PDL::LinearAlgebra::Real

### 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))
```

Complex version of "gelss" in PDL::LinearAlgebra::Real

### cgelsd

```
  Signature: (complex [io]A(m,n);complex  [io]B(p,q); rcond(); [o]s(minmn); int [o]rank();int [o]info(); int [t]iwork(iworkn); [t]rwork(rworkn))
```

Complex version of "gelsd" in PDL::LinearAlgebra::Real

### cgglse

```
  Signature: (complex [phys]A(m,n);complex  [phys]B(p,n);complex [io,phys]c(m);complex [phys]d(p);complex [o,phys]x(n);int [o,phys]info())
```

Complex version of "gglse" in PDL::LinearAlgebra::Real

### cggglm

```
  Signature: (complex [phys]A(n,m);complex  [phys]B(n,p);complex [phys]d(n);complex [o,phys]x(m);complex [o,phys]y(p);int [o,phys]info())
```

Complex version of "ggglm" in PDL::LinearAlgebra::Real

### cgetrf

```
  Signature: (complex [io]A(m,n); int [o]ipiv(p); int [o]info())
```

Complex version of "getrf" in PDL::LinearAlgebra::Real

### cgetf2

```
  Signature: (complex [io]A(m,n); int [o]ipiv(p); int [o]info())
```

Complex version of "getf2" in PDL::LinearAlgebra::Real

### csytrf

```
  Signature: (complex [io,phys]A(n,n); int uplo(); int [o,phys]ipiv(n); int [o,phys]info())
```

Complex version of "sytrf" in PDL::LinearAlgebra::Real

### csytf2

```
  Signature: (complex [io,phys]A(n,n); int uplo(); int [o,phys]ipiv(n); int [o,phys]info())
```

Complex version of "sytf2" in PDL::LinearAlgebra::Real

### cchetrf

```
  Signature: (complex [io]A(n,n); int uplo(); int [o]ipiv(n); int [o]info(); [t]work(workn))
```

Complex version of "sytrf" in PDL::LinearAlgebra::Real for Hermitian matrix

### chetf2

```
  Signature: (complex [io]A(n,n); int uplo(); int [o]ipiv(n); int [o]info())
```

Complex version of "sytf2" in PDL::LinearAlgebra::Real for Hermitian matrix

### cpotrf

```
  Signature: (complex [io,phys]A(n,n); int uplo(); int [o,phys]info())
```

Complex version of "potrf" in PDL::LinearAlgebra::Real for Hermitian positive definite matrix

### cpotf2

```
  Signature: (complex [io,phys]A(n,n); int uplo(); int [o,phys]info())
```

Complex version of "potf2" in PDL::LinearAlgebra::Real for Hermitian positive definite matrix

### cgetri

```
  Signature: (complex [io,phys]A(n,n); int [phys]ipiv(n); int [o,phys]info())
```

Complex version of "getri" in PDL::LinearAlgebra::Real

### csytri

```
  Signature: (complex [io]A(n,n); int uplo(); int ipiv(n); int [o]info(); [t]work(workn))
```

Complex version of "sytri" in PDL::LinearAlgebra::Real

### chetri

```
  Signature: (complex [io]A(n,n); int uplo(); int ipiv(n); int [o]info(); [t]work(workn))
```

Complex version of "sytri" in PDL::LinearAlgebra::Real for Hermitian matrix

### cpotri

```
  Signature: (complex [io,phys]A(n,n); int uplo(); int [o,phys]info())
```

Complex version of "potri" in PDL::LinearAlgebra::Real

### ctrtri

```
  Signature: (complex [io,phys]A(n,n); int uplo(); int diag(); int [o,phys]info())
```

Complex version of "trtri" in PDL::LinearAlgebra::Real

### ctrti2

```
  Signature: (complex [io,phys]A(n,n); int uplo(); int diag(); int [o,phys]info())
```

Complex version of "trti2" in PDL::LinearAlgebra::Real

### cgetrs

```
  Signature: (complex [phys]A(n,n); int trans();complex  [io,phys]B(n,m); int [phys]ipiv(n); int [o,phys]info())
```

Complex version of "getrs" in PDL::LinearAlgebra::Real

```
    Arguments
    =========
        trans:   = 0:  No transpose;
                 = 1:  Transpose;
                 = 2:  Conjugate transpose;
```

### csytrs

```
  Signature: (complex [phys]A(n,n); int uplo();complex [io,phys]B(n,m); int [phys]ipiv(n); int [o,phys]info())
```

Complex version of "sytrs" in PDL::LinearAlgebra::Real

### chetrs

```
  Signature: (complex [phys]A(n,n); int uplo();complex [io,phys]B(n,m); int [phys]ipiv(n); int [o,phys]info())
```

Complex version of "sytrs" in PDL::LinearAlgebra::Real for Hermitian matrix

### cpotrs

```
  Signature: (complex [phys]A(n,n); int uplo();complex  [io,phys]B(n,m); int [o,phys]info())
```

Complex version of "potrs" in PDL::LinearAlgebra::Real for Hermitian positive definite matrix

### ctrtrs

```
  Signature: (complex [phys]A(n,n); int uplo(); int trans(); int diag();complex [io,phys]B(n,m); int [o,phys]info())
```

Complex version of "trtrs" in PDL::LinearAlgebra::Real

```
    Arguments
    =========
        trans:   = 0:  No transpose;
                 = 1:  Transpose;
                 = 2:  Conjugate transpose;
```

### clatrs

```
  Signature: (complex [phys]A(n,n); int uplo(); int trans(); int diag(); int normin();complex [io,phys]x(n); [o,phys]scale();[io,phys]cnorm(n);int [o,phys]info())
```

Complex version of "latrs" in PDL::LinearAlgebra::Real

```
    Arguments
    =========
        trans:   = 0:  No transpose;
                 = 1:  Transpose;
                 = 2:  Conjugate transpose;
```

### cgecon

```
  Signature: (complex A(n,n); int norm(); anorm(); [o]rcond();int [o]info(); [t]rwork(rworkn); [t]work(workn))
```

Complex version of "gecon" in PDL::LinearAlgebra::Real

### csycon

```
  Signature: (complex A(n,n); int uplo(); int ipiv(n); anorm(); [o]rcond();int [o]info(); [t]work(workn))
```

Complex version of "sycon" in PDL::LinearAlgebra::Real

### checon

```
  Signature: (complex A(n,n); int uplo(); int ipiv(n); anorm(); [o]rcond();int [o]info(); [t]work(workn))
```

Complex version of "sycon" in PDL::LinearAlgebra::Real for Hermitian matrix

### cpocon

```
  Signature: (complex A(n,n); int uplo(); anorm(); [o]rcond();int [o]info(); [t]work(workn); [t]rwork(n))
```

Complex version of "pocon" in PDL::LinearAlgebra::Real for Hermitian positive definite matrix

### ctrcon

```
  Signature: (complex A(n,n); int norm();int uplo();int diag(); [o]rcond();int [o]info(); [t]work(workn); [t]rwork(n))
```

Complex version of "trcon" in PDL::LinearAlgebra::Real

### cgeqp3

```
  Signature: (complex [io]A(m,n); int [io]jpvt(n);complex  [o]tau(k); int [o]info(); [t]rwork(rworkn))
```

Complex version of "geqp3" in PDL::LinearAlgebra::Real

### cgeqrf

```
  Signature: (complex [io,phys]A(m,n);complex  [o,phys]tau(k); int [o,phys]info())
```

Complex version of "geqrf" in PDL::LinearAlgebra::Real

### cungqr

```
  Signature: (complex [io,phys]A(m,n);complex  [phys]tau(k); int [o,phys]info())
```

Complex version of "orgqr" in PDL::LinearAlgebra::Real

### cunmqr

```
  Signature: (complex [phys]A(p,k); int side(); int trans();complex  [phys]tau(k);complex  [io,phys]C(m,n);int [o,phys]info())
```

Complex version of "ormqr" in PDL::LinearAlgebra::Real. Here trans = 1 means conjugate transpose.

### cgelqf

```
  Signature: (complex [io,phys]A(m,n);complex  [o,phys]tau(k); int [o,phys]info())
```

Complex version of "gelqf" in PDL::LinearAlgebra::Real

### cunglq

```
  Signature: (complex [io,phys]A(m,n);complex  [phys]tau(k); int [o,phys]info())
```

Complex version of "orglq" in PDL::LinearAlgebra::Real

### cunmlq

```
  Signature: (complex [phys]A(k,p); int side(); int trans();complex  [phys]tau(k);complex  [io,phys]C(m,n);int [o,phys]info())
```

Complex version of "ormlq" in PDL::LinearAlgebra::Real. Here trans = 1 means conjugate transpose.

### cgeqlf

```
  Signature: (complex [io,phys]A(m,n);complex  [o,phys]tau(k); int [o,phys]info())
```

Complex version of "geqlf" in PDL::LinearAlgebra::Real

### cungql

```
  Signature: (complex [io,phys]A(m,n);complex  [phys]tau(k); int [o,phys]info())
```

### cunmql

```
  Signature: (complex [phys]A(p,k); int side(); int trans();complex  [phys]tau(k);complex  [io,phys]C(m,n);int [o,phys]info())
```

Complex version of "ormql" in PDL::LinearAlgebra::Real. Here trans = 1 means conjugate transpose.

### cgerqf

```
  Signature: (complex [io,phys]A(m,n);complex  [o,phys]tau(k); int [o,phys]info())
```

Complex version of "gerqf" in PDL::LinearAlgebra::Real

### cungrq

```
  Signature: (complex [io,phys]A(m,n);complex  [phys]tau(k); int [o,phys]info())
```

Complex version of "orgrq" in PDL::LinearAlgebra::Real.

### cunmrq

```
  Signature: (complex [phys]A(k,p); int side(); int trans();complex  [phys]tau(k);complex  [io,phys]C(m,n);int [o,phys]info())
```

Complex version of "ormrq" in PDL::LinearAlgebra::Real. Here trans = 1 means conjugate transpose.

### ctzrzf

```
  Signature: (complex [io,phys]A(m,n);complex  [o,phys]tau(k); int [o,phys]info())
```

Complex version of "tzrzf" in PDL::LinearAlgebra::Real

### cunmrz

```
  Signature: (complex [phys]A(k,p); int side(); int trans();complex  [phys]tau(k);complex  [io,phys]C(m,n);int [o,phys]info())
```

Complex version of "ormrz" in PDL::LinearAlgebra::Real. Here trans = 1 means conjugate transpose.

### cgehrd

```
  Signature: (complex [io,phys]A(n,n); int [phys]ilo();int [phys]ihi();complex [o,phys]tau(k); int [o,phys]info())
```

Complex version of "gehrd" in PDL::LinearAlgebra::Real

### cunghr

```
  Signature: (complex [io,phys]A(n,n); int [phys]ilo();int [phys]ihi();complex [phys]tau(k); int [o,phys]info())
```

Complex version of "orghr" in PDL::LinearAlgebra::Real

### chseqr

```
  Signature: (complex [io,phys]H(n,n); int job();int compz();int [phys]ilo();int [phys]ihi();complex [o,phys]w(n);complex  [o,phys]Z(m,m); int [o,phys]info())
```

Complex version of "hseqr" in PDL::LinearAlgebra::Real

### ctrevc

```
  Signature: (complex [io]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))
```

Complex version of "trevc" in PDL::LinearAlgebra::Real

### ctgevc

```
  Signature: (complex [io]A(n,n); int side();int howmny();complex  [io]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))
```

Complex version of "tgevc" in PDL::LinearAlgebra::Real

### cgebal

```
  Signature: (complex [io,phys]A(n,n); int job(); int [o,phys]ilo();int [o,phys]ihi();[o,phys]scale(n); int [o,phys]info())
```

Complex version of "gebal" in PDL::LinearAlgebra::Real

### clange

```
  Signature: (complex A(n,m); int norm(); [o]b(); [t]work(workn))
```

Complex version of "lange" in PDL::LinearAlgebra::Real

### clansy

```
  Signature: (complex A(n,n); int uplo(); int norm(); [o]b(); [t]work(workn))
```

Complex version of "lansy" in PDL::LinearAlgebra::Real

### clantr

```
  Signature: (complex A(m,n); int uplo(); int norm();int diag(); [o]b(); [t]work(workn))
```

Complex version of "lantr" in PDL::LinearAlgebra::Real

### cgemm

```
  Signature: (complex [phys]A(m,n); int transa(); int transb();complex  [phys]B(p,q);complex [phys]alpha();complex  [phys]beta();complex  [io,phys]C(r,s))
```

Complex 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;
```

### cmmult

```
  Signature: (complex [phys]A(m,n);complex  [phys]B(p,m);complex  [o,phys]C(p,n))
```

Complex version of "mmult" in PDL::LinearAlgebra::Real

### ccrossprod

```
  Signature: (complex [phys]A(n,m);complex  [phys]B(p,m);complex  [o,phys]C(p,n))
```

Complex version of "crossprod" in PDL::LinearAlgebra::Real

### csyrk

```
  Signature: (complex [phys]A(m,n); int uplo(); int trans();complex  [phys]alpha();complex  [phys]beta();complex  [io,phys]C(p,p))
```

Complex version of "syrk" in PDL::LinearAlgebra::Real

### cdot

```
  Signature: (complex [phys]a(n);complex [phys]b(n);complex [o]c())
```

Complex version of "dot" in PDL::LinearAlgebra::Real

### cdotc

```
  Signature: (complex [phys]a(n);complex [phys]b(n);complex [o,phys]c())
```

Forms the dot product of two vectors, conjugating the first    vector.

### caxpy

```
  Signature: (complex [phys]a(n);complex [phys] alpha();complex [io,phys]b(n))
```

Complex version of "axpy" in PDL::LinearAlgebra::Real

### cnrm2

```
  Signature: (complex [phys]a(n);[o]b())
```

Complex version of "nrm2" in PDL::LinearAlgebra::Real

### casum

```
  Signature: (complex [phys]a(n);[o]b())
```

Complex version of "asum" in PDL::LinearAlgebra::Real

### cscal

```
  Signature: (complex [io,phys]a(n);complex scale())
```

Complex version of "scal" in PDL::LinearAlgebra::Real

### csscal

```
  Signature: (complex [io,phys]a(n);scale())
```

Scales a complex vector by a real constant.

### crotg

```
  Signature: (complex [io,phys]a();complex [phys]b();[o,phys]c();complex  [o,phys]s())
```

Complex version of "rotg" in PDL::LinearAlgebra::Real

### clacpy

```
  Signature: (complex [phys]A(m,n); int uplo();complex  [o,phys]B(p,n))
```

Complex version of "lacpy" in PDL::LinearAlgebra::Real

### claswp

```
  Signature: (complex [io,phys]A(m,n); int [phys]k1(); int [phys]k2(); int [phys]ipiv(p))
```

Complex version of "laswp" in PDL::LinearAlgebra::Real

### ctricpy

```
  Signature: (A(c=2,m,n);int uplo();[o] C(c=2,m,n))
```

Copy triangular part to another matrix. If uplo == 0 copy upper triangular part.

ctricpy 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.

### cmstack

```
  Signature: (x(c,n,m);y(c,n,p);[o]out(c,n,q))
```

Combine two 3D ndarrays into a single ndarray. This routine does backward and forward dataflow automatically.

cmstack 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.

### ccharpol

```
  Signature: (A(c=2,n,n);[o]Y(c=2,n,n);[o]out(c=2,p); [t]rwork(rworkn))
```

Complex version of "charpol" in PDL::LinearAlgebra::Real

## 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.