larf#

Functions

void slarf(
    const char*          side,
    const INT            m,
    const INT            n,
    const f32*  restrict v,
    const INT            incv,
    const f32            tau,
          f32*  restrict C,
    const INT            ldc,
          f32*  restrict work
);
void slarf(const char *side, const INT m, const INT n, const f32 *restrict v, const INT incv, const f32 tau, f32 *restrict C, const INT ldc, f32 *restrict work)#

SLARF applies a real elementary reflector H to a real m by n matrix C, from either the left or the right.

H is represented in the form 

  H = I - tau * v * v**T
where tau is a real scalar and v is a real vector.

If tau = 0, then H is taken to be the unit matrix.

Parameters

in
side

‘L’: form H * C; ‘R’: form C * H

in
m

The number of rows of C.

in
n

The number of columns of C.

in
v

The vector v in the representation of H. Dimension (1+(m-1)*|incv|) if side=’L’, or (1+(n-1)*|incv|) if side=’R’.

in
incv

The increment between elements of v. incv != 0.

in
tau

The value tau in the representation of H.

inout
C

Double precision array, dimension (ldc, n). On exit, overwritten by H*C or C*H.

in
ldc

The leading dimension of C. ldc >= max(1, m).

out
work

Workspace, dimension (n) if side=’L’, (m) if side=’R’.

Functions

void slarf1f(
    const char*          side,
    const INT            m,
    const INT            n,
    const f32*  restrict v,
    const INT            incv,
    const f32            tau,
          f32*  restrict C,
    const INT            ldc,
          f32*  restrict work
);
void slarf1f(const char *side, const INT m, const INT n, const f32 *restrict v, const INT incv, const f32 tau, f32 *restrict C, const INT ldc, f32 *restrict work)#

SLARF1F applies a real elementary reflector H to a real m by n matrix C, from either the left or the right.

H is represented in the form 

  H = I - tau * v * v**T
where tau is a real scalar and v is a real vector, with v(1) = 1 (not stored).

If tau = 0, then H is taken to be the unit matrix.

Parameters

in
side

‘L’: form H * C; ‘R’: form C * H

in
m

The number of rows of C.

in
n

The number of columns of C.

in
v

The vector v in the representation of H. v(0) is not referenced (implicitly 1). Dimension (1+(m-1)*|incv|) if side=’L’, or (1+(n-1)*|incv|) if side=’R’.

in
incv

The increment between elements of v. incv != 0.

in
tau

The value tau in the representation of H.

inout
C

Double precision array, dimension (ldc, n). On exit, overwritten by H*C or C*H.

in
ldc

The leading dimension of C. ldc >= max(1, m).

out
work

Workspace, dimension (n) if side=’L’, (m) if side=’R’.

Functions

void slarf1l(
    const char*          side,
    const INT            m,
    const INT            n,
    const f32*  restrict v,
    const INT            incv,
    const f32            tau,
          f32*  restrict C,
    const INT            ldc,
          f32*  restrict work
);
void slarf1l(const char *side, const INT m, const INT n, const f32 *restrict v, const INT incv, const f32 tau, f32 *restrict C, const INT ldc, f32 *restrict work)#

SLARF1L applies a real elementary reflector H to a real m by n matrix C, from either the left or the right.

H is represented in the form 

  H = I - tau * v * v**T
where tau is a real scalar and v is a real vector, with v(lastv) = 1 (where lastv is the last non-zero element).

If tau = 0, then H is taken to be the unit matrix.

Parameters

in
side

‘L’: form H * C; ‘R’: form C * H

in
m

The number of rows of C.

in
n

The number of columns of C.

in
v

The vector v in the representation of H. Dimension (1+(m-1)*|incv|) if side=’L’, or (1+(n-1)*|incv|) if side=’R’.

in
incv

The increment between elements of v. incv != 0.

in
tau

The value tau in the representation of H.

inout
C

Double precision array, dimension (ldc, n). On exit, overwritten by H*C or C*H.

in
ldc

The leading dimension of C. ldc >= max(1, m).

out
work

Workspace, dimension (n) if side=’L’, (m) if side=’R’.

Functions

void dlarf(
    const char*          side,
    const INT            m,
    const INT            n,
    const f64*  restrict v,
    const INT            incv,
    const f64            tau,
          f64*  restrict C,
    const INT            ldc,
          f64*  restrict work
);
void dlarf(const char *side, const INT m, const INT n, const f64 *restrict v, const INT incv, const f64 tau, f64 *restrict C, const INT ldc, f64 *restrict work)#

DLARF applies a real elementary reflector H to a real m by n matrix C, from either the left or the right.

H is represented in the form 

  H = I - tau * v * v**T
where tau is a real scalar and v is a real vector.

If tau = 0, then H is taken to be the unit matrix.

Parameters

in
side

‘L’: form H * C; ‘R’: form C * H

in
m

The number of rows of C.

in
n

The number of columns of C.

in
v

The vector v in the representation of H. Dimension (1+(m-1)*|incv|) if side=’L’, or (1+(n-1)*|incv|) if side=’R’.

in
incv

The increment between elements of v. incv != 0.

in
tau

The value tau in the representation of H.

inout
C

Double precision array, dimension (ldc, n). On exit, overwritten by H*C or C*H.

in
ldc

The leading dimension of C. ldc >= max(1, m).

out
work

Workspace, dimension (n) if side=’L’, (m) if side=’R’.

Functions

void dlarf1f(
    const char*          side,
    const INT            m,
    const INT            n,
    const f64*  restrict v,
    const INT            incv,
    const f64            tau,
          f64*  restrict C,
    const INT            ldc,
          f64*  restrict work
);
void dlarf1f(const char *side, const INT m, const INT n, const f64 *restrict v, const INT incv, const f64 tau, f64 *restrict C, const INT ldc, f64 *restrict work)#

DLARF1F applies a real elementary reflector H to a real m by n matrix C, from either the left or the right.

H is represented in the form 

  H = I - tau * v * v**T
where tau is a real scalar and v is a real vector, with v(1) = 1 (not stored).

If tau = 0, then H is taken to be the unit matrix.

Parameters

in
side

‘L’: form H * C; ‘R’: form C * H

in
m

The number of rows of C.

in
n

The number of columns of C.

in
v

The vector v in the representation of H. v(0) is not referenced (implicitly 1). Dimension (1+(m-1)*|incv|) if side=’L’, or (1+(n-1)*|incv|) if side=’R’.

in
incv

The increment between elements of v. incv != 0.

in
tau

The value tau in the representation of H.

inout
C

Double precision array, dimension (ldc, n). On exit, overwritten by H*C or C*H.

in
ldc

The leading dimension of C. ldc >= max(1, m).

out
work

Workspace, dimension (n) if side=’L’, (m) if side=’R’.

Functions

void dlarf1l(
    const char*          side,
    const INT            m,
    const INT            n,
    const f64*  restrict v,
    const INT            incv,
    const f64            tau,
          f64*  restrict C,
    const INT            ldc,
          f64*  restrict work
);
void dlarf1l(const char *side, const INT m, const INT n, const f64 *restrict v, const INT incv, const f64 tau, f64 *restrict C, const INT ldc, f64 *restrict work)#

DLARF1L applies a real elementary reflector H to a real m by n matrix C, from either the left or the right.

H is represented in the form 

  H = I - tau * v * v**T
where tau is a real scalar and v is a real vector, with v(lastv) = 1 (where lastv is the last non-zero element).

If tau = 0, then H is taken to be the unit matrix.

Parameters

in
side

‘L’: form H * C; ‘R’: form C * H

in
m

The number of rows of C.

in
n

The number of columns of C.

in
v

The vector v in the representation of H. Dimension (1+(m-1)*|incv|) if side=’L’, or (1+(n-1)*|incv|) if side=’R’.

in
incv

The increment between elements of v. incv != 0.

in
tau

The value tau in the representation of H.

inout
C

Double precision array, dimension (ldc, n). On exit, overwritten by H*C or C*H.

in
ldc

The leading dimension of C. ldc >= max(1, m).

out
work

Workspace, dimension (n) if side=’L’, (m) if side=’R’.

Functions

void clarf(
    const char*          side,
    const INT            m,
    const INT            n,
    const c64*  restrict v,
    const INT            incv,
    const c64            tau,
          c64*  restrict C,
    const INT            ldc,
          c64*  restrict work
);
void clarf(const char *side, const INT m, const INT n, const c64 *restrict v, const INT incv, const c64 tau, c64 *restrict C, const INT ldc, c64 *restrict work)#

CLARF applies a complex elementary reflector H to a complex m by n matrix C, from either the left or the right.

H is represented in the form 

  H = I - tau * v * v**H
where tau is a complex scalar and v is a complex vector.

If tau = 0, then H is taken to be the unit matrix.

Parameters

in
side

‘L’: form H * C; ‘R’: form C * H

in
m

The number of rows of C.

in
n

The number of columns of C.

in
v

The vector v in the representation of H. Dimension (1+(m-1)*|incv|) if side=’L’, or (1+(n-1)*|incv|) if side=’R’.

in
incv

The increment between elements of v. incv != 0.

in
tau

The value tau in the representation of H.

inout
C

Single complex array, dimension (ldc, n). On exit, overwritten by H*C or C*H.

in
ldc

The leading dimension of C. ldc >= max(1, m).

out
work

Workspace, dimension (n) if side=’L’, (m) if side=’R’.

Functions

void clarf1f(
    const char*          side,
    const INT            m,
    const INT            n,
    const c64*  restrict v,
    const INT            incv,
    const c64            tau,
          c64*  restrict C,
    const INT            ldc,
          c64*  restrict work
);
void clarf1f(const char *side, const INT m, const INT n, const c64 *restrict v, const INT incv, const c64 tau, c64 *restrict C, const INT ldc, c64 *restrict work)#

CLARF1F applies a complex elementary reflector H to a complex m by n matrix C, from either the left or the right.

H is represented in the form 

  H = I - tau * v * v**H
where tau is a complex scalar and v is a complex vector, with v(1) = 1 (not stored).

If tau = 0, then H is taken to be the unit matrix.

To apply H**H, supply conjg(tau) instead tau.

Parameters

in
side

‘L’: form H * C; ‘R’: form C * H

in
m

The number of rows of C.

in
n

The number of columns of C.

in
v

The vector v in the representation of H. v(0) is not referenced (implicitly 1). Dimension (1+(m-1)*|incv|) if side=’L’, or (1+(n-1)*|incv|) if side=’R’.

in
incv

The increment between elements of v. incv != 0.

in
tau

The value tau in the representation of H.

inout
C

Complex array, dimension (ldc, n). On exit, overwritten by H*C or C*H.

in
ldc

The leading dimension of C. ldc >= max(1, m).

out
work

Workspace, dimension (n) if side=’L’, (m) if side=’R’.

Functions

void clarf1l(
    const char*          side,
    const INT            m,
    const INT            n,
    const c64*  restrict v,
    const INT            incv,
    const c64            tau,
          c64*  restrict C,
    const INT            ldc,
          c64*  restrict work
);
void clarf1l(const char *side, const INT m, const INT n, const c64 *restrict v, const INT incv, const c64 tau, c64 *restrict C, const INT ldc, c64 *restrict work)#

CLARF1L applies a complex elementary reflector H to a complex m by n matrix C, from either the left or the right.

H is represented in the form 

  H = I - tau * v * v**H
where tau is a complex scalar and v is a complex vector, with v(lastv) = 1 (where lastv is the last non-zero element).

If tau = 0, then H is taken to be the unit matrix.

To apply H**H (the conjugate transpose of H), supply conjg(tau) instead tau.

Parameters

in
side

‘L’: form H * C; ‘R’: form C * H

in
m

The number of rows of C.

in
n

The number of columns of C.

in
v

The vector v in the representation of H. Dimension (1+(m-1)*|incv|) if side=’L’, or (1+(n-1)*|incv|) if side=’R’.

in
incv

The increment between elements of v. incv > 0.

in
tau

The value tau in the representation of H.

inout
C

Complex array, dimension (ldc, n). On exit, overwritten by H*C or C*H.

in
ldc

The leading dimension of C. ldc >= max(1, m).

out
work

Workspace, dimension (n) if side=’L’, (m) if side=’R’.

Functions

void zlarf(
    const char*          side,
    const INT            m,
    const INT            n,
    const c128* restrict v,
    const INT            incv,
    const c128           tau,
          c128* restrict C,
    const INT            ldc,
          c128* restrict work
);
void zlarf(const char *side, const INT m, const INT n, const c128 *restrict v, const INT incv, const c128 tau, c128 *restrict C, const INT ldc, c128 *restrict work)#

ZLARF applies a complex elementary reflector H to a complex m by n matrix C, from either the left or the right.

H is represented in the form 

  H = I - tau * v * v**H
where tau is a complex scalar and v is a complex vector.

If tau = 0, then H is taken to be the unit matrix.

Parameters

in
side

‘L’: form H * C; ‘R’: form C * H

in
m

The number of rows of C.

in
n

The number of columns of C.

in
v

The vector v in the representation of H. Dimension (1+(m-1)*|incv|) if side=’L’, or (1+(n-1)*|incv|) if side=’R’.

in
incv

The increment between elements of v. incv != 0.

in
tau

The value tau in the representation of H.

inout
C

Double complex array, dimension (ldc, n). On exit, overwritten by H*C or C*H.

in
ldc

The leading dimension of C. ldc >= max(1, m).

out
work

Workspace, dimension (n) if side=’L’, (m) if side=’R’.

Functions

void zlarf1f(
    const char*          side,
    const INT            m,
    const INT            n,
    const c128* restrict v,
    const INT            incv,
    const c128           tau,
          c128* restrict C,
    const INT            ldc,
          c128* restrict work
);
void zlarf1f(const char *side, const INT m, const INT n, const c128 *restrict v, const INT incv, const c128 tau, c128 *restrict C, const INT ldc, c128 *restrict work)#

ZLARF1F applies a complex elementary reflector H to a complex m by n matrix C, from either the left or the right.

H is represented in the form 

  H = I - tau * v * v**H
where tau is a complex scalar and v is a complex vector, with v(1) = 1 (not stored).

If tau = 0, then H is taken to be the unit matrix.

To apply H**H, supply conjg(tau) instead tau.

Parameters

in
side

‘L’: form H * C; ‘R’: form C * H

in
m

The number of rows of C.

in
n

The number of columns of C.

in
v

The vector v in the representation of H. v(0) is not referenced (implicitly 1). Dimension (1+(m-1)*|incv|) if side=’L’, or (1+(n-1)*|incv|) if side=’R’.

in
incv

The increment between elements of v. incv != 0.

in
tau

The value tau in the representation of H.

inout
C

Complex array, dimension (ldc, n). On exit, overwritten by H*C or C*H.

in
ldc

The leading dimension of C. ldc >= max(1, m).

out
work

Workspace, dimension (n) if side=’L’, (m) if side=’R’.

Functions

void zlarf1l(
    const char*          side,
    const INT            m,
    const INT            n,
    const c128* restrict v,
    const INT            incv,
    const c128           tau,
          c128* restrict C,
    const INT            ldc,
          c128* restrict work
);
void zlarf1l(const char *side, const INT m, const INT n, const c128 *restrict v, const INT incv, const c128 tau, c128 *restrict C, const INT ldc, c128 *restrict work)#

ZLARF1L applies a complex elementary reflector H to a complex m by n matrix C, from either the left or the right.

H is represented in the form 

  H = I - tau * v * v**H
where tau is a complex scalar and v is a complex vector, with v(lastv) = 1 (where lastv is the last non-zero element).

If tau = 0, then H is taken to be the unit matrix.

To apply H**H (the conjugate transpose of H), supply conjg(tau) instead tau.

Parameters

in
side

‘L’: form H * C; ‘R’: form C * H

in
m

The number of rows of C.

in
n

The number of columns of C.

in
v

The vector v in the representation of H. Dimension (1+(m-1)*|incv|) if side=’L’, or (1+(n-1)*|incv|) if side=’R’.

in
incv

The increment between elements of v. incv > 0.

in
tau

The value tau in the representation of H.

inout
C

Complex array, dimension (ldc, n). On exit, overwritten by H*C or C*H.

in
ldc

The leading dimension of C. ldc >= max(1, m).

out
work

Workspace, dimension (n) if side=’L’, (m) if side=’R’.