PDL::LinearAlgebra::Complex(3) PDL interface to the lapack linear algebra programming library (complex number)

## SYNOPSIS

use PDL::Complex
use PDL::LinearAlgebra::Complex;
\$a = r2C random (100,100);
\$s = r2C zeroes(100);
\$u = r2C zeroes(100,100);
\$v = r2C zeroes(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 piddles.

## cgesvd

```  Signature: ([io,phys]A(2,m,n); int jobu(); int jobvt(); [o,phys]s(r); [o,phys]U(2,p,q); [o,phys]VT(2,s,t); int [o,phys]info())
```

Complex version of gesvd.

The SVD is written

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

cgesvd ignores the bad-value flag of the input piddles. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.

## cgesdd

```  Signature: ([io,phys]A(2,m,n); int job(); [o,phys]s(r); [o,phys]U(2,p,q); [o,phys]VT(2,s,t); int [o,phys]info())
```

Complex version of gesdd.

The SVD is written

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

cgesdd ignores the bad-value flag of the input piddles. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.

## cggsvd

```  Signature: ([io,phys]A(2,m,n); int jobu(); int jobv(); int jobq(); [io,phys]B(2,p,n); int [o,phys]k(); int [o,phys]l();[o,phys]alpha(n);[o,phys]beta(n); [o,phys]U(2,q,r); [o,phys]V(2,s,t); [o,phys]Q(2,u,v); int [o,phys]iwork(n); int [o,phys]info())
```

Complex version of ggsvd

cggsvd ignores the bad-value flag of the input piddles. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.

## cgeev

```  Signature: ([phys]A(2,n,n); int jobvl(); int jobvr(); [o,phys]w(2,n); [o,phys]vl(2,m,m); [o,phys]vr(2,p,p); int [o,phys]info())
```

Complex version of geev

cgeev ignores the bad-value flag of the input piddles. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.

## cgeevx

```  Signature: ([io,phys]A(2,n,n);  int jobvl(); int jobvr(); int balance(); int sense(); [o,phys]w(2,n); [o,phys]vl(2,m,m); [o,phys]vr(2,p,p); int [o,phys]ilo(); int [o,phys]ihi(); [o,phys]scale(n); [o,phys]abnrm(); [o,phys]rconde(q); [o,phys]rcondv(r); int [o,phys]info())
```

Complex version of geevx

cgeevx ignores the bad-value flag of the input piddles. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.

## cggev

```  Signature: ([phys]A(2,n,n); int jobvl();int jobvr();[phys]B(2,n,n);[o,phys]alpha(2,n);[o,phys]beta(2,n);[o,phys]VL(2,m,m);[o,phys]VR(2,p,p);int [o,phys]info())
```

Complex version of ggev

cggev ignores the bad-value flag of the input piddles. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.

## cggevx

```  Signature: ([io,phys]A(2,n,n);int balanc();int jobvl();int jobvr();int sense();[io,phys]B(2,n,n);[o,phys]alpha(2,n);[o,phys]beta(2,n);[o,phys]VL(2,m,m);[o,phys]VR(2,p,p);int [o,phys]ilo();int [o,phys]ihi();[o,phys]lscale(n);[o,phys]rscale(n);[o,phys]abnrm();[o,phys]bbnrm();[o,phys]rconde(r);[o,phys]rcondv(s);int [o,phys]info())
```

Complex version of ggevx

cggevx ignores the bad-value flag of the input piddles. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.

## cgees

```  Signature: ([io,phys]A(2,n,n);  int jobvs(); int sort(); [o,phys]w(2,n); [o,phys]vs(2,p,p); int [o,phys]sdim(); int [o,phys]info(); SV* select_func)
```

Complex version of gees

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

cgees ignores the bad-value flag of the input piddles. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.

## cgeesx

```  Signature: ([io,phys]A(2,n,n);  int jobvs(); int sort(); int sense(); [o,phys]w(2,n);[o,phys]vs(2,p,p); int [o,phys]sdim(); [o,phys]rconde();[o,phys]rcondv(); int [o,phys]info(); SV* select_func)
```

Complex version of geesx

```    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 ignores the bad-value flag of the input piddles. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.

## cgges

```  Signature: ([io,phys]A(2,n,n); int jobvsl();int jobvsr();int sort();[io,phys]B(2,n,n);[o,phys]alpha(2,n);[o,phys]beta(2,n);[o,phys]VSL(2,m,m);[o,phys]VSR(2,p,p);int [o,phys]sdim();int [o,phys]info(); SV* select_func)
```

Complex version of ggees

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

cgges ignores the bad-value flag of the input piddles. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.

## cggesx

```  Signature: ([io,phys]A(2,n,n); int jobvsl();int jobvsr();int sort();int sense();[io,phys]B(2,n,n);[o,phys]alpha(2,n);[o,phys]beta(2,n);[o,phys]VSL(2,m,m);[o,phys]VSR(2,p,p);int [o,phys]sdim();[o,phys]rconde(q);[o,phys]rcondv(r);int [o,phys]info(); SV* select_func)
```

Complex version of ggeesx

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

cggesx ignores the bad-value flag of the input piddles. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.

## cheev

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

Complex version of syev for Hermitian matrix

cheev ignores the bad-value flag of the input piddles. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.

## cheevd

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

Complex version of syevd for Hermitian matrix

cheevd ignores the bad-value flag of the input piddles. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.

## cheevx

```  Signature: ([phys]A(2,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); [o,phys]z(2,p,q);int [o,phys]ifail(r); int [o,phys]info())
```

Complex version of syevx for Hermitian matrix

cheevx ignores the bad-value flag of the input piddles. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.

## cheevr

```  Signature: ([phys]A(2,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); [o,phys]z(2,p,q);int [o,phys]isuppz(r); int [o,phys]info())
```

Complex version of syevr for Hermitian matrix

cheevr ignores the bad-value flag of the input piddles. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.

## chegv

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

Complex version of sygv for Hermitian matrix

chegv ignores the bad-value flag of the input piddles. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.

## chegvd

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

Complex version of sygvd for Hermitian matrix

chegvd ignores the bad-value flag of the input piddles. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.

## chegvx

```  Signature: ([io,phys]A(2,n,n);int [phys]itype();int jobz();int range(); int uplo();[io,phys]B(2,n,n);[phys]vl();[phys]vu();int [phys]il();int [phys]iu();[phys]abstol();int [o,phys]m();[o,phys]w(n); [o,phys]Z(2,p,q);int [o,phys]ifail(r);int [o,phys]info())
```

Complex version of sygvx for Hermitian matrix

chegvx ignores the bad-value flag of the input piddles. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.

## cgesv

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

Complex version of gesv

cgesv ignores the bad-value flag of the input piddles. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.

## cgesvx

```  Signature: ([io,phys]A(2,n,n); int trans(); int fact(); [io,phys]B(2,n,m); [io,phys]af(2,n,n); int [io,phys]ipiv(n); int [io]equed(); [io,phys]r(n); [io,phys]c(n); [o,phys]X(2,n,m); [o,phys]rcond(); [o,phys]ferr(m); [o,phys]berr(m); [o,phys]rpvgrw(); int [o,phys]info())
```

Complex version of gesvx.

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

cgesvx ignores the bad-value flag of the input piddles. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.

## csysv

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

Complex version of sysv

csysv ignores the bad-value flag of the input piddles. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.

## csysvx

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

Complex version of sysvx

csysvx ignores the bad-value flag of the input piddles. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.

## chesv

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

Complex version of sysv for Hermitian matrix

chesv ignores the bad-value flag of the input piddles. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.

## chesvx

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

Complex version of sysvx for Hermitian matrix

chesvx ignores the bad-value flag of the input piddles. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.

## cposv

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

Complex version of posv for Hermitian positive definite matrix

cposv ignores the bad-value flag of the input piddles. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.

## cposvx

```  Signature: ([io,phys]A(2,n,n); int uplo(); int fact(); [io,phys]B(2,n,m); [io,phys]af(2,n,n); int [io]equed(); [io,phys]s(n); [o,phys]X(2,n,m); [o,phys]rcond(); [o,phys]ferr(m); [o,phys]berr(m); int [o,phys]info())
```

Complex version of posvx for Hermitian positive definite matrix

cposvx ignores the bad-value flag of the input piddles. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.

## cgels

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

```    trans:  = 0: the linear system involves A;
= 1: the linear system involves A**H.
```

cgels ignores the bad-value flag of the input piddles. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.

## cgelsy

```  Signature: ([io,phys]A(2,m,n); [io,phys]B(2,p,q); [phys]rcond(); int [io,phys]jpvt(n); int [o,phys]rank();int [o,phys]info())
```

Complex version of gelsy

cgelsy ignores the bad-value flag of the input piddles. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.

## cgelss

```  Signature: ([io,phys]A(2,m,n); [io,phys]B(2,p,q); [phys]rcond(); [o,phys]s(r); int [o,phys]rank();int [o,phys]info())
```

Complex version of gelss

cgelss ignores the bad-value flag of the input piddles. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.

## cgelsd

```  Signature: ([io,phys]A(2,m,n); [io,phys]B(2,p,q); [phys]rcond(); [o,phys]s(r); int [o,phys]rank();int [o,phys]info())
```

Complex version of gelsd

cgelsd ignores the bad-value flag of the input piddles. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.

## cgglse

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

Complex version of gglse

cgglse ignores the bad-value flag of the input piddles. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.

## cggglm

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

Complex version of ggglm

cggglm ignores the bad-value flag of the input piddles. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.

## cgetrf

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

Complex version of getrf

cgetrf ignores the bad-value flag of the input piddles. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.

## cgetf2

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

Complex version of getf2

cgetf2 ignores the bad-value flag of the input piddles. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.

## csytrf

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

Complex version of sytrf

csytrf ignores the bad-value flag of the input piddles. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.

## csytf2

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

Complex version of sytf2

csytf2 ignores the bad-value flag of the input piddles. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.

## cchetrf

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

Complex version of sytrf for Hermitian matrix

cchetrf ignores the bad-value flag of the input piddles. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.

## chetf2

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

Complex version of sytf2 for Hermitian matrix

chetf2 ignores the bad-value flag of the input piddles. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.

## cpotrf

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

Complex version of potrf for Hermitian positive definite matrix

cpotrf ignores the bad-value flag of the input piddles. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.

## cpotf2

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

Complex version of potf2 for Hermitian positive definite matrix

cpotf2 ignores the bad-value flag of the input piddles. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.

## cgetri

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

Complex version of getri

cgetri ignores the bad-value flag of the input piddles. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.

## csytri

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

Complex version of sytri

csytri ignores the bad-value flag of the input piddles. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.

## chetri

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

Complex version of sytri for Hermitian matrix

chetri ignores the bad-value flag of the input piddles. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.

## cpotri

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

Complex version of potri

cpotri ignores the bad-value flag of the input piddles. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.

## ctrtri

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

Complex version of trtri

ctrtri ignores the bad-value flag of the input piddles. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.

## ctrti2

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

Complex version of trti2

ctrti2 ignores the bad-value flag of the input piddles. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.

## cgetrs

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

Complex version of getrs

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

cgetrs ignores the bad-value flag of the input piddles. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.

## csytrs

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

Complex version of sytrs

csytrs ignores the bad-value flag of the input piddles. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.

## chetrs

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

Complex version of sytrs for Hermitian matrix

chetrs ignores the bad-value flag of the input piddles. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.

## cpotrs

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

Complex version of potrs for Hermitian positive definite matrix

cpotrs ignores the bad-value flag of the input piddles. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.

## ctrtrs

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

Complex version of trtrs

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

ctrtrs ignores the bad-value flag of the input piddles. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.

## clatrs

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

Complex version of latrs

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

clatrs ignores the bad-value flag of the input piddles. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.

## cgecon

```  Signature: ([phys]A(2,n,n); int norm(); [phys]anorm(); [o,phys]rcond();int [o,phys]info())
```

Complex version of gecon

cgecon ignores the bad-value flag of the input piddles. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.

## csycon

```  Signature: ([phys]A(2,n,n); int uplo(); int ipiv(n); [phys]anorm(); [o,phys]rcond();int [o,phys]info())
```

Complex version of sycon

csycon ignores the bad-value flag of the input piddles. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.

## checon

```  Signature: ([phys]A(2,n,n); int uplo(); int ipiv(n); [phys]anorm(); [o,phys]rcond();int [o,phys]info())
```

Complex version of sycon for Hermitian matrix

checon ignores the bad-value flag of the input piddles. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.

## cpocon

```  Signature: ([phys]A(2,n,n); int uplo(); [phys]anorm(); [o,phys]rcond();int [o,phys]info())
```

Complex version of pocon for Hermitian positive definite matrix

cpocon ignores the bad-value flag of the input piddles. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.

## ctrcon

```  Signature: ([phys]A(2,n,n); int norm();int uplo();int diag(); [o,phys]rcond();int [o,phys]info())
```

Complex version of trcon

ctrcon ignores the bad-value flag of the input piddles. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.

## cgeqp3

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

Complex version of geqp3

cgeqp3 ignores the bad-value flag of the input piddles. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.

## cgeqrf

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

Complex version of geqrf

cgeqrf ignores the bad-value flag of the input piddles. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.

## cungqr

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

Complex version of orgqr

cungqr ignores the bad-value flag of the input piddles. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.

## cunmqr

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

Complex version of ormqr. Here trans = 1 means conjugate transpose.

cunmqr ignores the bad-value flag of the input piddles. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.

## cgelqf

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

Complex version of gelqf

cgelqf ignores the bad-value flag of the input piddles. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.

## cunglq

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

Complex version of orglq

cunglq ignores the bad-value flag of the input piddles. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.

## cunmlq

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

Complex version of ormlq. Here trans = 1 means conjugate transpose.

cunmlq ignores the bad-value flag of the input piddles. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.

## cgeqlf

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

Complex version of geqlf

cgeqlf ignores the bad-value flag of the input piddles. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.

## cungql

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

Complex version of orgql.

cungql ignores the bad-value flag of the input piddles. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.

## cunmql

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

Complex version of ormql. Here trans = 1 means conjugate transpose.

cunmql ignores the bad-value flag of the input piddles. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.

## cgerqf

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

Complex version of gerqf

cgerqf ignores the bad-value flag of the input piddles. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.

## cungrq

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

Complex version of orgrq.

cungrq ignores the bad-value flag of the input piddles. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.

## cunmrq

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

Complex version of ormrq. Here trans = 1 means conjugate transpose.

cunmrq ignores the bad-value flag of the input piddles. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.

## ctzrzf

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

Complex version of tzrzf

ctzrzf ignores the bad-value flag of the input piddles. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.

## cunmrz

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

Complex version of ormrz. Here trans = 1 means conjugate transpose.

cunmrz ignores the bad-value flag of the input piddles. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.

## cgehrd

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

Complex version of gehrd

cgehrd ignores the bad-value flag of the input piddles. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.

## cunghr

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

Complex version of orghr

cunghr ignores the bad-value flag of the input piddles. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.

## chseqr

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

Complex version of hseqr

chseqr ignores the bad-value flag of the input piddles. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.

## ctrevc

```  Signature: ([io,phys]T(2,n,n); int side();int howmny();int [phys]select(q);[io,phys]VL(2,m,r); [io,phys]VR(2,p,s);int [o,phys]m(); int [o,phys]info())
```

Complex version of trevc

ctrevc ignores the bad-value flag of the input piddles. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.

## ctgevc

```  Signature: ([io,phys]A(2,n,n); int side();int howmny(); [io,phys]B(2,n,n);int [phys]select(q);[io,phys]VL(2,m,r); [io,phys]VR(2,p,s);int [o,phys]m(); int [o,phys]info())
```

Complex version of tgevc

ctgevc ignores the bad-value flag of the input piddles. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.

## cgebal

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

Complex version of gebal

cgebal ignores the bad-value flag of the input piddles. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.

## clange

```  Signature: ([phys]A(2,n,m); int norm(); [o]b())
```

Complex version of lange

clange ignores the bad-value flag of the input piddles. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.

## clansy

```  Signature: ([phys]A(2, n,n); int uplo(); int norm(); [o]b())
```

Complex version of lansy

clansy ignores the bad-value flag of the input piddles. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.

## clantr

```  Signature: ([phys]A(2,m,n);int uplo();int norm();int diag();[o]b())
```

Complex version of lantr

clantr ignores the bad-value flag of the input piddles. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.

## cgemm

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

Complex version of gemm.

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

cgemm ignores the bad-value flag of the input piddles. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.

## cmmult

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

Complex version of mmult

cmmult ignores the bad-value flag of the input piddles. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.

## ccrossprod

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

Complex version of crossprod

ccrossprod ignores the bad-value flag of the input piddles. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.

## csyrk

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

Complex version of syrk

csyrk ignores the bad-value flag of the input piddles. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.

## cdot

```  Signature: ([phys]a(2,n);int [phys]inca();[phys]b(2,n);int [phys]incb();[o,phys]c(2))
```

Complex version of dot

cdot ignores the bad-value flag of the input piddles. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.

## cdotc

```  Signature: ([phys]a(2,n);int [phys]inca();[phys]b(2,n);int [phys]incb();[o,phys]c(2))
```

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

cdotc ignores the bad-value flag of the input piddles. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.

## caxpy

```  Signature: ([phys]a(2,n);int [phys]inca();[phys] alpha(2);[io,phys]b(2,n);int [phys]incb())
```

Complex version of axpy

caxpy ignores the bad-value flag of the input piddles. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.

## cnrm2

```  Signature: ([phys]a(2,n);int [phys]inca();[o,phys]b())
```

Complex version of nrm2

cnrm2 ignores the bad-value flag of the input piddles. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.

## casum

```  Signature: ([phys]a(2,n);int [phys]inca();[o,phys]b())
```

Complex version of asum

casum ignores the bad-value flag of the input piddles. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.

## cscal

```  Signature: ([io,phys]a(2,n);int [phys]inca();[phys]scale(2))
```

Complex version of scal

cscal ignores the bad-value flag of the input piddles. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.

## sscal

```  Signature: ([io,phys]a(2,n);int [phys]inca();[phys]scale())
```

Scales a complex vector by a real constant.

sscal ignores the bad-value flag of the input piddles. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.

## crotg

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

Complex version of rotg

crotg ignores the bad-value flag of the input piddles. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.

## clacpy

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

Complex version of lacpy

clacpy ignores the bad-value flag of the input piddles. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.

## claswp

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

Complex version of laswp

claswp ignores the bad-value flag of the input piddles. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.

## 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 piddles if the flag is set for any of the input piddles.

## cmstack

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

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

cmstack does not process bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.

## ccharpol

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

Complex version of charpol

ccharpol does not process bad values. It will set the bad-value flag of all output piddles if the flag is set for any of the input piddles.