qrupdate-ng 1.2.0
Loading...
Searching...
No Matches
Auxilliary Subroutines

Collection of helper routines for basic linear algebra and specialized vector operations. More...

Collaboration diagram for Auxilliary Subroutines:

Topics

 Givens Rotations
 Routines for the generation and application of Givens rotations.
 Error Handling
 Routines for error handling.

Functions

subroutine caxcpy (n, a, x, incx, y, incy)
 Performs scaled conjugate vector addition.
subroutine qrupdate_cdotc (ret, n, cx, incx, cy, incy)
 CDOTC Complex dot product (x**H y version).
subroutine qrupdate_cdotu (ret, n, cx, incx, cy, incy)
 CDOTU Complex dot product (x**T y version).
subroutine zaxcpy (n, a, x, incx, y, incy)
 Performs scaled conjugate vector addition.
subroutine qrupdate_zdotc (ret, n, cx, incx, cy, incy)
 ZDOTC Complex dot product (x**H y version).
subroutine qrupdate_zdotu (ret, n, cx, incx, cy, incy)
 Complex dot product (x**T y version).

Detailed Description

Collection of helper routines for basic linear algebra and specialized vector operations.

This group provides utilities that fill gaps in standard BLAS implementations or provide specialized operations required by the library, such as scaled conjugate vector addition (axcpy), which are used across the various decomposition update routines.

Function Documentation

◆ caxcpy()

subroutine caxcpy ( integer, intent(in) n,
complex(real32), intent(in) a,
complex(real32), dimension(*), intent(in) x,
integer, intent(in) incx,
complex(real32), dimension(*), intent(inout) y,
integer, intent(in) incy )

Performs scaled conjugate vector addition.

Definition:
!>       subroutine caxcpy(n,a,x,incx,y,incy)
!>
!>       .. Scalar Arguments ..
!>       integer            n, incx, incy
!>       ..
!>       .. Array Arguments ..
!>       complex            a, x(*), y(*)
!>       ..
!>
Purpose:
!>
!> CAXCPY performs the operation y := y + a * conjg(x), where a is a
!> complex scalar, x is a vector of length n, conjg(x) denotes the
!> element-wise complex conjugate of x, and y is a vector of the same
!> length.  On entry, y contains the existing values; on exit, y is
!> overwritten with the result.  This is the complex analogue of the
!> BLAS caxpy, with the x argument conjugated before scaling.
!>
Parameters
[in]n
!>          n is INTEGER
!>          The number of elements in vectors x and y.  If n <= 0,
!>          the subroutine returns immediately without modification.
!>
[in]a
!>          a is COMPLEX
!>          The complex scalar used to scale the conjugated vector
!>          conjg(x) before accumulation into y.
!>
[in]x
!>          x is COMPLEX array, dimension (*)
!>          The vector whose complex conjugate is scaled by a and
!>          added to y.  x is not modified.
!>
[in]incx
!>          incx is INTEGER
!>          The stride (increment) for elements of x.  If incx > 0,
!>          elements are accessed starting from x(1); if incx < 0,
!>          elements are accessed starting from
!>          x(1 + (-n+1)*incx).  A value of 1 accesses
!>          contiguous elements.
!>
[in,out]y
!>          y is COMPLEX array, dimension (*)
!>          On entry, the vector y of length n.  On exit, y is
!>          overwritten with y + a * conjg(x).
!>
[in]incy
!>          incy is INTEGER
!>          The stride (increment) for elements of y.  If incy > 0,
!>          elements are accessed starting from y(1); if incy < 0,
!>          elements are accessed starting from
!>          y(1 + (-n+1)*incy).  A value of 1 accesses
!>          contiguous elements.
!>

Definition at line 95 of file caxcpy.f90.

◆ qrupdate_cdotc()

subroutine qrupdate_cdotc ( complex(real32), intent(out) ret,
integer, intent(in) n,
complex(real32), dimension(*), intent(in) cx,
integer, intent(in) incx,
complex(real32), dimension(*), intent(in) cy,
integer, intent(in) incy )

CDOTC Complex dot product (x**H y version).

Definition:
!>       SUBROUTINE QRUPDATE_CDOTC(RET, N,CX,INCX,CY,INCY)
!>
!>       .. Scalar Arguments ..
!>       INTEGER INCX,INCY,N
!>       COMPLEX(real32) ret
!>       ..
!>       .. Array Arguments ..
!>       COMPLEX(real32) CX(*),CY(*)
!>       ..
!>
Purpose:
!>
!> CDOTC forms the dot product of two complex vectors
!>      CDOTC = X^H * Y
!>
!>
Parameters
[out]RET
!>         RET is COMPLEX(real32)
!>         RET contains the dot product.
!>
[in]N
!>         N is INTEGER
!>         number of elements in input vector(s)
!>
[in]CX
!>          CX is COMPLEX(real32) array, dimension ( 1 + ( N - 1 )*abs( INCX ) )
!>
[in]INCX
!>         INCX is INTEGER
!>         storage spacing between elements of CX
!>
[in]CY
!>          CY is COMPLEX(real32) array, dimension ( 1 + ( N - 1 )*abs( INCY ) )
!>
[in]INCY
!>         INCY is INTEGER
!>         storage spacing between elements of CY
!>
Remarks
This routine is equivalent to cdotc from BLAS but invariant with the compiler's Fortran ABI

Definition at line 86 of file cdotc.f90.

◆ qrupdate_cdotu()

subroutine qrupdate_cdotu ( complex(real32), intent(out) ret,
integer, intent(in) n,
complex(real32), dimension(*), intent(in) cx,
integer, intent(in) incx,
complex(real32), dimension(*), intent(in) cy,
integer, intent(in) incy )

CDOTU Complex dot product (x**T y version).

Definition:
!>       SUBROUTINE QRUPDATE_CDOTU(RET, N,CX,INCX,CY,INCY)
!>
!>       .. Scalar Arguments ..
!>       INTEGER INCX,INCY,N
!>       COMPLEX(real32) ret
!>       ..
!>       .. Array Arguments ..
!>       COMPLEX(real32) CX(*),CY(*)
!>       ..
!>
Purpose:
!>
!> CDOTU forms the dot product of two complex vectors
!>      CDOTU = X^T * Y
!>
!>
Parameters
[out]RET
!>         RET is COMPLEX(real32)
!>         RET contains the dot product.
!>
[in]N
!>         N is INTEGER
!>         number of elements in input vector(s)
!>
[in]CX
!>          CX is COMPLEX(real32) array, dimension ( 1 + ( N - 1 )*abs( INCX ) )
!>
[in]INCX
!>         INCX is INTEGER
!>         storage spacing between elements of CX
!>
[in]CY
!>          CY is COMPLEX(real32) array, dimension ( 1 + ( N - 1 )*abs( INCY ) )
!>
[in]INCY
!>         INCY is INTEGER
!>         storage spacing between elements of CY
!>
Remarks
This routine is equivalent to cdotu from BLAS but invariant with the compiler's Fortran ABI

Definition at line 87 of file cdotu.f90.

◆ qrupdate_zdotc()

subroutine qrupdate_zdotc ( complex(real64), intent(out) ret,
integer, intent(in) n,
complex(real64), dimension(*), intent(in) cx,
integer, intent(in) incx,
complex(real64), dimension(*), intent(in) cy,
integer, intent(in) incy )

ZDOTC Complex dot product (x**H y version).

Definition:
!>       SUBROUTINE QRUPDATE_ZDOTC(RET, N,CX,INCX,CY,INCY)
!>
!>       .. Scalar Arguments ..
!>       INTEGER INCX,INCY,N
!>       COMPLEX(real64) ret
!>       ..
!>       .. Array Arguments ..
!>       COMPLEX(real64) CX(*),CY(*)
!>       ..
!>
Purpose:
!>
!> ZDOTC forms the dot product of two complex vectors
!>      ZDOTC = X^H * Y
!>
!>
Parameters
[out]RET
!>         RET is COMPLEX(real64)
!>         RET contains the dot product.
!>
[in]N
!>         N is INTEGER
!>         number of elements in input vector(s)
!>
[in]CX
!>          CX is COMPLEX(real64) array, dimension ( 1 + ( N - 1 )*abs( INCX ) )
!>
[in]INCX
!>         INCX is INTEGER
!>         storage spacing between elements of CX
!>
[in]CY
!>          CY is COMPLEX(real64) array, dimension ( 1 + ( N - 1 )*abs( INCY ) )
!>
[in]INCY
!>         INCY is INTEGER
!>         storage spacing between elements of CY
!>
Remarks
This routine is equivalent to zdotc from BLAS but invariant with the compiler's Fortran ABI

Definition at line 86 of file zdotc.f90.

◆ qrupdate_zdotu()

subroutine qrupdate_zdotu ( complex(real32), intent(out) ret,
integer, intent(in) n,
complex(real32), dimension(*), intent(in) cx,
integer, intent(in) incx,
complex(real32), dimension(*), intent(in) cy,
integer, intent(in) incy )

Complex dot product (x**T y version).

Definition:
!>       SUBROUTINE QRUPDATE_ZDOTU(RET, N,CX,INCX,CY,INCY)
!>
!>       .. Scalar Arguments ..
!>       INTEGER INCX,INCY,N
!>       COMPLEX(real32) ret
!>       ..
!>       .. Array Arguments ..
!>       COMPLEX(real32) CX(*),CY(*)
!>       ..
!>
Purpose:
!>
!> ZDOTU forms the dot product of two complex vectors
!>      ZDOTU = X^T * Y
!>
!>
Parameters
[out]RET
!>         RET is COMPLEX(real32)
!>         RET contains the dot product.
!>
[in]N
!>         N is INTEGER
!>         number of elements in input vector(s)
!>
[in]CX
!>          CX is COMPLEX(real32) array, dimension ( 1 + ( N - 1 )*abs( INCX ) )
!>
[in]INCX
!>         INCX is INTEGER
!>         storage spacing between elements of CX
!>
[in]CY
!>          CY is COMPLEX(real32) array, dimension ( 1 + ( N - 1 )*abs( INCY ) )
!>
[in]INCY
!>         INCY is INTEGER
!>         storage spacing between elements of CY
!>
Remarks
This routine is equivalent to zdotu from BLAS but invariant with the compiler's Fortran ABI

Definition at line 86 of file zdotu.f90.

◆ zaxcpy()

subroutine zaxcpy ( integer, intent(in) n,
complex(real64), intent(in) a,
complex(real64), dimension(*), intent(in) x,
integer, intent(in) incx,
complex(real64), dimension(*), intent(inout) y,
integer, intent(in) incy )

Performs scaled conjugate vector addition.

Definition:
!>       subroutine zaxcpy(n,a,x,incx,y,incy)
!>
!>       .. Scalar Arguments ..
!>       integer            n, incx, incy
!>       ..
!>       .. Array Arguments ..
!>       double complex     a, x(*), y(*)
!>       ..
!>
Purpose:
!>
!> ZAXCPY performs the operation y := y + a * conjg(x), where a is a
!> double complex scalar, x is a vector of length n, conjg(x) denotes
!> the element-wise complex conjugate of x, and y is a vector of the
!> same length.  On entry, y contains the existing values; on exit, y
!> is overwritten with the result.  This is the double precision
!> complex analogue of the BLAS zaxpy, with the x argument conjugated
!> before scaling.
!>
Parameters
[in]n
!>          n is INTEGER
!>          The number of elements in vectors x and y.  If n <= 0,
!>          the subroutine returns immediately without modification.
!>
[in]a
!>          a is COMPLEX*16
!>          The double complex scalar used to scale the conjugated
!>          vector conjg(x) before accumulation into y.
!>
[in]x
!>          x is COMPLEX*16 array, dimension (*)
!>          The vector of length n whose complex conjugate is scaled
!>          by a and added to y.  x is not modified.
!>
[in]incx
!>          incx is INTEGER
!>          The stride (increment) for elements of x.  If incx > 0,
!>          elements are accessed starting from x(1); if incx < 0,
!>          elements are accessed starting from
!>          x(1 + (-n+1)*incx).  A value of 1 accesses
!>          contiguous elements.
!>
[in,out]y
!>          y is COMPLEX*16 array, dimension (*)
!>          On entry, the vector y of length n.  On exit, y is
!>          overwritten with y + a * conjg(x).
!>
[in]incy
!>          incy is INTEGER
!>          The stride (increment) for elements of y.  If incy > 0,
!>          elements are accessed starting from y(1); if incy < 0,
!>          elements are accessed starting from
!>          y(1 + (-n+1)*incy).  A value of 1 accesses
!>          contiguous elements.
!>

Definition at line 96 of file zaxcpy.f90.