Procedures

Left-adjust the character sequence represented by the string. The length of the character sequence remains unchanged.

Right-adjust the character sequence represented by the string. The length of the character sequence remains unchanged.

Returns a boolean scalar where two arrays are element-wise equal within a tolerance. (Specification)

Sets the bits in set1 to the bitwise and of the original bits in set1 and set2. The sets must have the same number of bits otherwise the result is undefined. (Specification)

Sets the bits in set1 to the bitwise and of the original bits in set1 with the bitwise negation of set2. The sets must have the same number of bits otherwise the result is undefined.

arange creates a one-dimensional array of the integer/real type with fixed-spaced values of given spacing, within a given interval. (Specification)

arg computes the phase angle in the interval (-π,π]. (Specification)

(Specification)

argd computes the phase angle of degree version in the interval (-180.0,180.0]. (Specification)

argpi computes the phase angle of circular version in the interval (-1.0,1.0]. (Specification)

Assign a character sequence to a string.

Used to define assignment for bitset_large. (Specification)

ASUM takes the sum of the absolute values.

AXPY constant times a vector plus a vector.

Returns an instance of type 'stringlist_index_type' representing backward index Specifications

Returns the number of bit positions in self.

Version experimental

Normal Distribution Cumulative Distribution Function (Specification)

Get uniform distribution cumulative distribution function (cdf) for integer, real and complex variables. (Specification)

Return the character sequence represented by the string.

Checks the value of a logical condition (Specification)

Computes the Cholesky factorization $A = L \cdot L^T$, or $A = U^T \cdot U$. (Specification)

Computes the Cholesky factorization $A = L \cdot L^T$, or $A = U^T \cdot U$. (Specification)

Remove trailing characters in set from string. If no character set is provided trailing whitespace is removed.

COPY copies a vector x to a vector y.

Copies the contents of the key, old_key, to the key, new_key (Specifications)

Copies the other data, other_in, to the variable, other_out (Specifications)

Pearson correlation of array elements (Specification)

Returns the number of times substring 'pattern' has appeared in the input string 'string' Specifications

Covariance of array elements (Specification)

Computes the cross product of two vectors, returning a rank-1 and size-3 array (Specification)

deg2rad converts phase angles from degrees to radians. (Specification)

Computes the determinant of a square matrix (Specification)

Creates a diagonal array or extract the diagonal elements of an array (Specification)

Computes differences between adjacent elements of an array. (Specification)

Version experimental

First derivative Legendre polynomial

DOT forms the dot product of two vectors. uses unrolled loops for increments equal to one.

DOTC forms the dot product of two complex vectors DOTC = X^H * Y

DOTU forms the dot product of two complex vectors DOTU = X^T * Y

Solves the eigendecomposition $A \cdot \bar{v} - \lambda \cdot \bar{v}$ for square matrix $A$. (Specification)

Solves the eigendecomposition $A \cdot \bar{v} - \lambda \cdot \bar{v}$ for a real symmetric $A = A^T$ or complex Hermitian $A = A^H$ square matrix. (Specification)

Returns the eigenvalues $lambda$, $A \cdot \bar{v} - \lambda \cdot \bar{v}$, for square matrix $A$. (Specification)

Returns the eigenvalues $lambda$, $A \cdot \bar{v} - \lambda \cdot \bar{v}$, for a real symmetric $A = A^T$ or complex Hermitian $A = A^H$ square matrix. (Specification)

Check whether a string ends with substring or not

Creates a new bitset, new, from a range, start_pos to stop_pos, in bitset old. If start_pos is greater than stop_pos the new bitset is empty. If start_pos is less than zero or stop_pos is greater than bits(old)-1 then if status is present it has the value index_invalid_error and new is undefined, otherwise processing stops with an informative message. (Specification)

Constructs the identity matrix (Specification)

Return the positions of the false elements in array. Specification

Maps the 32 bit integer key to an unsigned integer value with only nbits bits where nbits is less than 32 (Specification)

Maps the 64 bit integer key to an unsigned integer value with only nbits bits where nbits is less than 64 (Specification)

Returns an instance of type 'stringlist_index_type' representing forward index Specifications

Finds the starting index of substring 'pattern' in the input 'string' Specifications

FNV_1 interfaces (Specification)

FNV_1 interfaces (Specification)

Hashes a key with the FNV_1 algorithm Arguments: key - the key to be hashed

FNV_1A interfaces (Specification)

FNV_1A interfaces (Specification)

Hashes a key with the FNV_1a algorithm (Specifications)

Frees the memory in a key (Specifications)

Frees the memory in the other data (Specifications)

Gamma function for integer and complex numbers

Computes Gauss-Legendre quadrature nodes and weights.

Computes Gauss-Legendre-Lobatto quadrature nodes and weights.

GBMV performs one of the matrix-vector operations y := alphaAx + betay, or y := alphaATx + betay, or y := alpha*AHx + betay, where alpha and beta are scalars, x and y are vectors and A is an m by n band matrix, with kl sub-diagonals and ku super-diagonals.

Returns the greatest common divisor of two integers (Specification)

GEMM performs one of the matrix-matrix operations C := alphaop( A )op( B ) + betaC, where op( X ) is one of op( X ) = X or op( X ) = XT or op( X ) = X*H, alpha and beta are scalars, and A, B and C are matrices, with op( A ) an m by k matrix, op( B ) a k by n matrix and C an m by n matrix.

GEMV performs one of the matrix-vector operations y := alphaAx + betay, or y := alphaATx + betay, or y := alpha*AHx + betay, where alpha and beta are scalars, x and y are vectors and A is an m by n matrix.

GER performs the rank 1 operation A := alphaxy**T + A, where alpha is a scalar, x is an m element vector, y is an n element vector and A is an m by n matrix.

GERC performs the rank 1 operation A := alphaxy**H + A, where alpha is a scalar, x is an m element vector, y is an n element vector and A is an m by n matrix.

GERU performs the rank 1 operation A := alphaxy**T + A, where alpha is a scalar, x is an m element vector, y is an n element vector and A is an m by n matrix.

Vector norm: subroutine interface version: experimental

Getter function to retrieve standard library version

Read a whole line from a formatted unit into a string variable

HBMV performs the matrix-vector operation y := alphaAx + beta*y, where alpha and beta are scalars, x and y are n element vectors and A is an n by n hermitian band matrix, with k super-diagonals.

HEMM performs one of the matrix-matrix operations C := alphaAB + betaC, or C := alphaBA + betaC, where alpha and beta are scalars, A is an hermitian matrix and B and C are m by n matrices.

HEMV performs the matrix-vector operation y := alphaAx + beta*y, where alpha and beta are scalars, x and y are n element vectors and A is an n by n hermitian matrix.

HER performs the hermitian rank 1 operation A := alphaxx**H + A, where alpha is a real scalar, x is an n element vector and A is an n by n hermitian matrix.

HER2 performs the hermitian rank 2 operation A := alphaxyH + conjg( alpha )yxH + A, where alpha is a scalar, x and y are n element vectors and A is an n by n hermitian matrix.

HER2K performs one of the hermitian rank 2k operations C := alphaABH + conjg( alpha )BAH + betaC, or C := alphaAHB + conjg( alpha )BHA + betaC, where alpha and beta are scalars with beta real, C is an n by n hermitian matrix and A and B are n by k matrices in the first case and k by n matrices in the second case.

HERK performs one of the hermitian rank k operations C := alphaAAH + betaC, or C := alphaAHA + betaC, where alpha and beta are real scalars, C is an n by n hermitian matrix and A is an n by k matrix in the first case and a k by n matrix in the second case.

Computes the Hermitian version of a rank-2 matrix. For complex matrices, this returns conjg(transpose(a)). For real or integer matrices, this returns transpose(a).

HPMV performs the matrix-vector operation y := alphaAx + beta*y, where alpha and beta are scalars, x and y are n element vectors and A is an n by n hermitian matrix, supplied in packed form.

HPR performs the hermitian rank 1 operation A := alphaxx**H + A, where alpha is a real scalar, x is an n element vector and A is an n by n hermitian matrix, supplied in packed form.

HPR2 performs the hermitian rank 2 operation A := alphaxyH + conjg( alpha )yxH + A, where alpha is a scalar, x and y are n element vectors and A is an n by n hermitian matrix, supplied in packed form.

Code in ASCII collating sequence.

Character-to-integer conversion function.

Position of a substring within a string.

Inverse of a square matrix (Specification)

Inversion of a square matrix (Specification)

Checks whether c is an ASCII letter (A .. Z, a .. z).

Checks whether c is a letter or a number (0 .. 9, a .. z, A .. Z).

Checks whether or not c is in the ASCII character set - i.e. in the range 0 .. 0x7F.

Checks whether or not c is a blank character. That includes the only the space and tab characters

Returns a boolean scalar/array where two scalar/arrays are element-wise equal within a tolerance. (Specification)

Checks whether c is a control character.

Checks if a matrix (rank-2 array) is diagonal (Specification)

Checks whether c is a digit (0 .. 9).

Checks whether or not c is a printable character other than the space character.

Checks if a matrix (rank-2 array) is Hermitian (Specification)

Checks if a matrix (rank-2 array) is Hessenberg (Specification)

Checks whether c is a digit in base 16 (0 .. 9, A .. F, a .. f).

Checks whether c is a lowercase ASCII letter (a .. z).

Checks whether c is a digit in base 8 (0 .. 7).

Checks whether or not c is a printable character - including the space character.

Checks whether or not c is a punctuation character. That includes all ASCII characters which are not control characters, letters, digits, or whitespace.

Checks if a matrix (rank-2 array) is skew-symmetric (Specification)

Checks if a matrix (rank-2 array) is square (Specification)

Checks if a matrix (rank-2 array) is symmetric (Specification)

Checks if a matrix (rank-2 array) is triangular (Specification)

Checks whether c is an uppercase ASCII letter (A .. Z).

Checks whether or not c is a whitespace character. That includes the space, tab, vertical tab, form feed, carriage return, and linefeed characters.

Joins an array of strings into a single string. The chunks are separated with a space, or an optional user-defined separator. Specifications

Computes the Kronecker product of two arrays of size M1xN1, and of M2xN2, returning an (M1M2)x(N1N2) array (Specification)

Legendre polynomial

Returns the length of the character sequence represented by the string.

Returns the length of the character sequence without trailing spaces represented by the string.

Lexically compare the order of two character sequences being greater equal, The left-hand side, the right-hand side or both character sequences can be represented by a string.

Lexically compare the order of two character sequences being greater, The left-hand side, the right-hand side or both character sequences can be represented by a string.

Flow control: on output flag present, return it; otherwise, halt on error

Create rank 1 array of linearly spaced elements If the number of elements is not specified, create an array with size 100. If n is a negative value, return an array with size 0. If n = 1, return an array whose only element is end (Specification)

Lexically compare the order of two character sequences being less equal, The left-hand side, the right-hand side or both character sequences can be represented by a string.

Lexically compare the order of two character sequences being less, The left-hand side, the right-hand side or both character sequences can be represented by a string.

Load multidimensional array in npy format (Specification)

Loads a 2D array from a text file (Specification)

Logarithm of factorial n!, integer variable

Logarithm of gamma function

Logarithm of lower incomplete gamma function

Logarithm of upper incomplete gamma function

Create rank 1 array of logarithmically spaced elements from basestart to baseend. If the number of elements is not specified, create an array with size 50. If n is a negative value, return an array with size 0. If n = 1, return an array whose only element is base**end. If no base is specified, logspace will default to using a base of 10

Lower incomplete gamma function

Computes the squares solution to system $A \cdot x = b$. (Specification)

Computes the integer, real [, complex] working space required by the least-squares solver (Specification)

Mean of array elements (Specification)

Median of array elements (Specification)

Computes a list of coordinate matrices from coordinate vectors. (Specification)

Matrix norms: function interface version: experimental

Central moment of array elements (Specification)

Moves the allocated character scalar from 'from' to 'to' Specifications

(Specification

(Specification)

(Specification)

NMHASH32 interfaces (Specification)

NMHASH32X interfaces (Specification)

Computes the vector norm of a generic-rank array $A$. (Specification)

NRM2 returns the euclidean norm of a vector via the function name, so that NRM2 := sqrt( x'*x )

Returns a 32 bit pseudo random integer, harvest, distributed uniformly over the odd integers of the int32 kind. (Specification)

Returns a 64 bit pseudo random integer, harvest, distributed uniformly over the odd integers of the 64 bit kind. (Specification)

Opens a file (Specification)

Determinant operator of a square matrix (Specification)

Inverse operator of a square matrix (Specification)

Pseudo-inverse operator of a matrix (Specification)

Concatenate two character sequences, the left-hand side, the right-hand side or both character sequences can be represented by a string.

Concatenates stringlist with the input entity Returns a new stringlist Specifications

Compare two character sequences for inequality, the left-hand side, the right-hand side or both character sequences can be represented by a string.

Returns .true. if not all bits in set1 and set2 have the same value, .false. otherwise. The sets must have the same number of bits otherwise the result is undefined. (Specification)

Compares stringlist for inequality with the input entity Returns a logical Specifications

Compare two character sequences for being less, the left-hand side, the right-hand side or both character sequences can be represented by a string.

Returns .true. if the bits in set1 and set2 differ and the highest order different bit is set to 0 in set1 and to 1 in set2, .false. otherwise. The sets must have the same number of bits otherwise the result is undefined. (Specification)

Compare two character sequences for being less than, the left-hand side, the right-hand side or both character sequences can be represented by a string.

Returns .true. if the bits in set1 and set2 are the same or the highest order different bit is set to 0 in set1 and to 1 in set2, .false. otherwise. The sets must have the same number of bits otherwise the result is undefined. (Specification)

Comparison operators

Compare two character sequences for equality, the left-hand side, the right-hand side or both character sequences can be represented by a string.

Returns .true. if all bits in set1 and set2 have the same value, .false. otherwise. The sets must have the same number of bits otherwise the result is undefined. (Specification)

Compares stringlist for equality with the input entity Returns a logical Specifications

Compare two character sequences for being greater, the left-hand side, the right-hand side or both character sequences can be represented by a string.

Returns .true. if the bits in set1 and set2 differ and the highest order different bit is set to 1 in set1 and to 0 in set2, .false. otherwise. The sets must have the same number of bits otherwise the result is undefined. (Specification)

Compare two character sequences for being greater than, the left-hand side, the right-hand side or both character sequences can be represented by a string.

Returns .true. if the bits in set1 and set2 are the same or the highest order different bit is set to 1 in set1 and to 0 in set2, .false. otherwise. The sets must have the same number of bits otherwise the result is undefined. (Specification)

Fallback value for optional arguments (Specification)

Sets the bits in set1 to the bitwise or of the original bits in set1 and set2. The sets must have the same number of bits otherwise the result is undefined. (Specification)

The generic subroutine interface implementing the ORD_SORT algorithm, a translation to Fortran 2008, of the "Rust" sort algorithm found in slice.rs https://github.com/rust-lang/rust/blob/90eb44a5897c39e3dff9c7e48e3973671dcd9496/src/liballoc/slice.rs#L2159 ORD_SORT is a hybrid stable comparison algorithm combining merge sort, and insertion sort. (Specification)

Computes the outer product of two vectors, returning a rank-2 array (Specification)

Left pad the input string Specifications

Right pad the input string Specifications

Version experimental

Normal Distribution Probability Density Function (Specification)

Get uniform distribution probability density (pdf) for integer, real and complex variables. (Specification)

PENGY_HASH interfaces (Specification)

Pseudo-inverse of a matrix (Specification)

Computation of the Moore-Penrose pseudo-inverse (Specification)

Computes the QR factorization of matrix $A = Q R$. (Specification)

Computes the working array space required by the QR factorization solver (Specification)

rad2deg converts phase angles from radians to degrees. (Specification)

The generic subroutine interface implementing the LSD radix sort algorithm, see https://en.wikipedia.org/wiki/Radix_sort for more details. It is always O(N) in sorting random data, but need a O(N) buffer. (Specification)

Version experimental

Read a character sequence from a connected unformatted unit into the string.

Read a character sequence from a connected unformatted unit into the string.

Regularized (normalized) lower incomplete gamma function, P

Regularized (normalized) upper incomplete gamma function, Q

Repeats the character sequence hold by the string by the number of specified copies.

Replaces all the occurrences of substring 'pattern' in the input 'string' with the replacement 'replacement' Version: experimental

Reverse the character order in the input character variable (Specification)

Reverses the character sequence hold by the input string

ROT applies a plane rotation.

The computation uses the formulas |x| = sqrt( Re(x)2 + Im(x)2 ) sgn(x) = x / |x| if x /= 0 = 1 if x = 0 c = |a| / sqrt(|a|2 + |b|2) s = sgn(a) * conjg(b) / sqrt(|a|2 + |b|2) When a and b are real and r /= 0, the formulas simplify to r = sgn(a)sqrt(|a|2 + |b|*2) c = a / r s = b / r the same as in SROTG when |a| > |b|. When |b| >= |a|, the sign of c and s will be different from those computed by SROTG if the signs of a and b are not the same.

ROTM applies the modified Givens transformation, $H$, to the 2-by-N matrix $$\left[ \begin{array}{c}DX^T\\DY^T\\ \end{array} \right],$$ where $^T$ indicates transpose. The elements of $DX$ are in DX(LX+IINCX), I = 0:N-1, where LX = 1 if INCX >= 0, else LX = (-INCX)N, and similarly for DY using LY and INCY. With DPARAM(1)=DFLAG, $H$ has one of the following forms: $$H=\underbrace{\begin{bmatrix}DH_{11} & DH_{12}\\DH_{21} & DH_{22}\end{bmatrix}}_{DFLAG=-1}, \underbrace{\begin{bmatrix}1 & DH_{12}\\DH_{21} & 1\end{bmatrix}}_{DFLAG=0}, \underbrace{\begin{bmatrix}DH_{11} & 1\\-1 & DH_{22}\end{bmatrix}}_{DFLAG=1}, \underbrace{\begin{bmatrix}1 & 0\\0 & 1\end{bmatrix}}_{DFLAG=-2}.$$ See ROTMG for a description of data storage in DPARAM.

ROTMG Constructs the modified Givens transformation matrix $H$ which zeros the second component of the 2-vector $$\left[ {\sqrt{DD_1}\cdot DX_1,\sqrt{DD_2}\cdot DY_2} \right]^T.$$ With DPARAM(1)=DFLAG, $H$ has one of the following forms: $$H=\underbrace{\begin{bmatrix}DH_{11} & DH_{12}\\DH_{21} & DH_{22}\end{bmatrix}}_{DFLAG=-1}, \underbrace{\begin{bmatrix}1 & DH_{12}\\DH_{21} & 1\end{bmatrix}}_{DFLAG=0}, \underbrace{\begin{bmatrix}DH_{11} & 1\\-1 & DH_{22}\end{bmatrix}}_{DFLAG=1}, \underbrace{\begin{bmatrix}1 & 0\\0 & 1\end{bmatrix}}_{DFLAG=-2}.$$ Locations 2-4 of DPARAM contain DH11, DH21, DH12 and DH22 respectively. (Values of 1.0, -1.0, or 0.0 implied by the value of DPARAM(1) are not stored in DPARAM.) The values of parameters GAMSQ and RGAMSQ may be inexact. This is OK as they are only used for testing the size of DD1 and DD2. All actual scaling of data is done using GAM.

Version experimental

Normal Distribution Random Variates (Specification)

Get uniformly distributed random variate for integer, real and complex variables. (Specification)

Save multidimensional array in npy format (Specification)

Saves a 2D array into a text file (Specification)

SBMV performs the matrix-vector operation y := alphaAx + beta*y, where alpha and beta are scalars, x and y are n element vectors and A is an n by n symmetric band matrix, with k super-diagonals.

SCAL scales a vector by a constant.

Scan a string for the presence of a set of characters. Scans a string for any of the characters in a set of characters.

Computes the Schur decomposition of matrix $A = Z T Z^H$. (Specification)

Computes the working array space required by the Schur decomposition solver (Specification)

Compute the inner product of two vectors with extended precision accumulation and result. Returns D.P. dot product accumulated in D.P., for S.P. SX and SY SDOT = sum for I = 0 to N-1 of SX(LX+IINCX) * SY(LY+IINCY), where LX = 1 if INCX >= 0, else LX = 1+(1-N)*INCX, and LY is defined in a similar way using INCY.

Hashes a key with the NMHASH32 hash algorithm (Specifications)

Hashes a key with the NMHASH32X hash algorithm (Specifications) Arguments: key - the key to be hashed seed - the seed (unused) for the hashing algorithm

Hashes a key with the waterhash algorithm (Specifications)

(Specification)

Fisher-Yates shuffle algorithm for a rank one array of integer, real and complex variables. (Specification)

Integrates sampled values using Simpson's rule (Specification)

Integrates sampled values using trapezoidal rule weights for given abscissas (Specification)

Extracts characters from the input string to return a new string

Solves the linear system $A \cdot x = b$ for the unknown vector $x$ from a square matrix $A$. (Specification)

Computes the squares solution to system $A \cdot x = b$. (Specification)

Solves the linear system $A \cdot x = b$ for the unknown vector $x$ from a square matrix $A$. (Specification)

The generic subroutine interface implementing the SORT algorithm, based on the introsort of David Musser. (Specification)

The generic subroutine interface implementing the SORT_INDEX algorithm, based on the "Rust" sort algorithm found in slice.rs https://github.com/rust-lang/rust/blob/90eb44a5897c39e3dff9c7e48e3973671dcd9496/src/liballoc/slice.rs#L2159 but modified to return an array of indices that would provide a stable sort of the rank one ARRAY input. (Specification)

SPMV performs the matrix-vector operation y := alphaAx + beta*y, where alpha and beta are scalars, x and y are n element vectors and A is an n by n symmetric matrix, supplied in packed form.

SPOOKY_HASH interfaces (Specification)

SPR performs the symmetric rank 1 operation A := alphaxx**T + A, where alpha is a real scalar, x is an n element vector and A is an n by n symmetric matrix, supplied in packed form.

SPR2 performs the symmetric rank 2 operation A := alphaxyT + alphayxT + A, where alpha is a scalar, x and y are n element vectors and A is an n by n symmetric matrix, supplied in packed form.

SROT applies a plane rotation, where the cos and sin (c and s) are real and the vectors cx and cy are complex. jack dongarra, linpack, 3/11/78.

SSCAL scales a complex vector by a real constant.

Check whether a string starts with substring or not

This subroutine translates from a BLAST-specified integer constant to the character string specifying a transposition operation. CHLA_TRANSTYPE returns an CHARACTER*1. If CHLA_TRANSTYPE: is 'X', then input is not an integer indicating a transposition operator. Otherwise CHLA_TRANSTYPE returns the constant value corresponding to TRANS.