Procedures

A* search for one shortest path from source to target.

Add an int64 variable which contains the FLOPs we use int64 since we might reach very large FLOP counts

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

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.

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

Switch to the alternate screen buffer.

Switch back to the normal screen buffer.

Set the background to one of the sixteen named colours.

Set the background from the 256-colour cube.

Set the background to a 24-bit colour.

Turn on bold.

Clear the line the cursor is on.

Clear the whole screen and home the cursor.

Set the foreground to one of the sixteen named colours.

Set the foreground from the 256-colour cube.

Set the foreground to a 24-bit colour.

Hide the cursor.

Move the cursor to a one-based row and column.

Reset every attribute.

Swap foreground and background.

Show the cursor.

Whether any declared entry has this kind.

One-shot digest of a single array or string.

One-shot digest of a single array or string.

Number of encoded bytes consumed so far.

The digest of everything fed in so far.

Format a digest as 16 lowercase hexadecimal characters.

Return the accumulator to its initial state.

Number of encoded bytes consumed so far.

The digest of everything fed in so far.

Format a digest as 8 lowercase hexadecimal characters.

Return the accumulator to its initial state.

Place the decimal point in an already rounded digit string.

Assign a character sequence to a string.

Assign a character sequence to a string.

SGR number for a named colour: base + n, or base + 60 + n bright.

Multiply the big integer in place by base**power.

Multiply the big integer in place by a factor smaller than LIMB_BASE.

Initialise the big integer from a strictly positive int64.

Write the big integer out as a decimal digit string, no leading zeros.

Breadth-first search, ignoring edge weights.

Reinterpret the bit pattern of an int64 as a real(dp). See bits_to_real_sp for why this is confined to the swapped path.

Reinterpret the bit pattern of an int32 as a real(sp).

Reverse the four bytes of an int32.

Reverse the eight bytes of an int64.

Core buffering routine — appends a log entry to the buffer. If the buffer is full, increments the overflow counter. If a message or name exceeds its max length, it is truncated and the entry is flagged.

Return the character sequence represented by the string.

Return the character sequence represented by the string.

Return the character sequence represented by the string.

Return the character sequence represented by the string.

Returns the corresponding lowercase letter, if c is an uppercase ASCII character, otherwise c itself.

Returns the corresponding uppercase letter, if c is a lowercase ASCII character, otherwise c itself.

Validate the exponent part of a real, starting at pos.

Validate the structural preconditions shared by every algorithm here.

Turn a non zero iostat into an ERROR_IO carrying the raw value. Every I/O statement in this module funnels its status through here so that the failure message always names both the operation and the iostat the runtime produced.

Reject negative edge weights, on which Dijkstra and A* are invalid.

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

Remove trailing characters in set from string. Default character set variant where trailing whitespace is removed.

Remove trailing characters in set from string.

Remove trailing characters in set from string.

Remove trailing characters in set from string. Default character set variant where trailing whitespace is removed.

Remove trailing substrings from string.

Remove trailing substrings from string.

Remove trailing substrings from string.

Remove trailing substrings from string.

Inverse of days_from_civil.

Constrain a value to the inclusive range [lo, hi].

Clamp to 0 to 255, so a caller’s arithmetic slip cannot emit a sequence the terminal will misparse.

Clamp a real(dp) value to [lo, hi].

Clamp an integer(int32) value to [lo, hi].

Clamp an integer(int64) value to [lo, hi].

Clamp a real(sp) value to [lo, hi].

Reset the buffer to empty. Call after flushing if you want to reuse it.

Declare a flag, which takes no value.

Declare an option that takes a value.

Declare a positional argument, filled in registration order.

Index of the entry with this long name, or 0.

Index of the entry with this short name, or 0. Empty never matches.

Read a value into a deferred-length character.

Read a value as integer(int32), strictly.

Read a value as integer(int64), strictly.

Read a value as logical.

Read a value as real(dp), strictly.

Read a value as real(sp), strictly.

Read a value as a string_type.

Whether name was declared at all.

Whether -h or --help was given.

The help text, as a string. Nothing is printed; see the module note.

Whether name appeared on the command line.

How many times name appeared on the command line.

Parse the real command line.

Parse an explicit argument list.

Make room for one more entry, doubling the store when it is full.

Name and one-line description, used by help_text.

Fit a location into MAX_LOCATION_LEN keeping its TAIL, marking any truncation with a leading TRUNCATION_MARKER.

Fit a cause message into MAX_CAUSE_MSG_LEN keeping its HEAD, marking any truncation with a trailing TRUNCATION_MARKER.

Close the log file, needs to be called at the end of the program

Map an error code to a human-readable name

Computes longest prefix suffix for each index of the input ‘string’

Concatenate two character sequences. In this version the right-hand side character sequences is by a string.

Concatenate two character sequences. In this version the left-hand side character sequences is by a string.

Concatenate two character sequences. In this version both character sequences are by a string.

Get the current logger verbosity configuration

Configure the logger to be a certain verbosity level

Configure the logger to file to be a certain verbosity level

Label the weakly connected components of the graph.

copy a tensor of datatype dp

copy a tensor of datatype int32

copy a tensor of datatype int64

copy a tensor of datatype sp

copy a matrix of datatype dp

copy a matrix of datatype int32

copy a matrix of datatype int64

copy a matrix of datatype sp

copy a vector of datatype dp

copy a vector of datatype int32

copy a vector of datatype int64

copy a vector of datatype sp

Returns the number of times substring ‘pattern’ has appeared in the input string ‘string’

Returns the number of times substring ‘pattern’ has appeared in the input string ‘string’ Returns an integer

Returns the number of times substring ‘pattern’ has appeared in the input string ‘string’ Returns an integer

Returns the number of times substring ‘pattern’ has appeared in the input string ‘string’ Returns an integer

Returns the number of times substring ‘pattern’ has appeared in the input string ‘string’ Returns an integer

Build the matrix from coordinate (COO) triplets.

Release all storage and reset the matrix to an empty 0 by 0 one.

Check that the stored triple is structurally consistent.

Sparse matrix-vector product y = A*x.

Number of columns of the matrix.

Number of rows of the matrix.

Number of stored entries, including any explicitly stored zeros.

Copy out the column indices and values stored in row i.

Build the transpose of this matrix into at.

Inverse of unix_time_ms, producing a UTC datetime_t.

Days from 1970-01-01 to the given proleptic Gregorian date.

Log a message that will only be printed at the debug level of verbosity

Decode raw terminal bytes into key events.

Decode one byte that is not part of an escape sequence.

Single-source shortest paths with non-negative edge weights.

Route a buffered entry to the appropriate logger method

Number of columns text occupies.

Map a non-negative real(dp) onto an integer(int64) heap key, preserving order exactly.

this subroutine runs a random dgemm to create work so that timers and other testing utils work nicely

Bytes occupied by one element of the record type tag, or -1 for an unknown tag.

Append an event, silently dropping any beyond the caller’s array.

Check whether a string ends with substring or not

Check whether a string ends with substring or not

Check whether a string ends with substring or not

Check whether a string ends with substring or not

Check whether a string ends with substring or not

Label and enqueue every still-unlabelled neighbour of u.

Rebuild the key of an entry from the packed character pool.

The left-hand column of one help line.

Compare two character sequences for equality. In this version the right-hand side character sequences is by a string.

Compare two character sequences for equality. In this version the left-hand side character sequences is by a string.

Compare two character sequences for equality. In this version both character sequences are by a string.

Log a message that will only be printed at the error of verbosity

Add a call location to the stack trace Typically called when propagating errors upward

Clear the error state, stack trace, and cause chain

Print the error trace and stop the program Use for unrecoverable errors

Get the error code

Get complete error message with cause chain and stack trace Returns a dynamically-sized multi-line string

Get the error message (without stack trace)

Check if an error is set

Check if the error matches a specific error code

Print error with cause chain and stack trace to specified unit If unit not specified, prints to stdout

Set an optional error argument, if the caller supplied one.

Set an error with code and message Resets the stack trace and cause chain

Wrap the current error with a higher-level context Pushes the current error into the cause chain and sets a new top-level code and message (Rust-style “caused by”)

Length of the escape sequence beginning at start, or 0.

Exact decimal expansion of a finite, strictly positive value.

Canonical exponent field: sign, then at least two zero padded digits.

Set err to ERROR_VALIDATION with message, when err is present.

Set err if it is present, and do nothing if it is not.

Set err to ERROR_VALIDATION with message, when err is present.

Feed the nbytes low-order bytes of value, least significant first.

Feed the nbytes low-order bytes of value, least significant first.

Feed one byte: 1 for true, 0 for false.

Feed one byte: 1 for true, 0 for false.

Canonicalise and feed one real(dp) value. See feed_real_sp for the ordering of the classification tests.

Canonicalise and feed one real(dp) value. See feed_real_sp64 for the ordering of the classification tests.

Feed the fixed 14-byte canonical record of one real value.

Feed the fixed 14-byte canonical record of one real value.

Canonicalise and feed one real(sp) value.

Canonicalise and feed one real(sp) value.

fill a tensor of datatype dp with a value

fill a tensor of datatype int32 with a value

fill a tensor of datatype int64 with a value

fill a tensor of datatype sp with a value

fill a matrix of datatype dp with a value

fill a matrix of datatype int32 with a value

fill a matrix of datatype int64 with a value

fill a matrix of datatype sp with a value

fill a vector of datatype dp with a value

fill a vector of datatype int32 with a value

fill a vector of datatype int64 with a value

fill a vector of datatype sp with a value

Finds the starting index of substring ‘pattern’ in the input ‘string’ Specifications

Returns the starting index of the ‘occurrence’th occurrence of substring ‘pattern’ in input ‘string’ Returns an integer

Returns the starting index of the ‘occurrence’th occurrence of substring ‘pattern’ in input ‘string’ Returns an integer

Index of key in the insertion-order table, or 0 when absent.

Find an existing region by name or create a new one Returns -1 if MAX_REGIONS is exceeded

Returns the starting index of the ‘occurrence’th occurrence of substring ‘pattern’ in input ‘string’ Returns an integer

Returns the starting index of the ‘occurrence’th occurrence of substring ‘pattern’ in input ‘string’ Returns an integer

Copy of the live elements as a plain array of extent size(), not capacity(). Returns a zero-length array when empty. This is how the contents are handed to ordinary Fortran routines; note that it is the one operation here that does allocate, so keep it out of the hot path.

Bounds-checked element access, 1-based. Any index outside 1:size() (including indices that are within the capacity but beyond the live elements) sets value to zero and err to ERROR_VALIDATION. On success err is left untouched.

Maximum number of elements, i.e. PIC_FIXED_ARRAY_CAPACITY.

Drop every element. The storage itself is untouched, so this is a single integer assignment; the array can be reused immediately.

UNCHECKED element access for inner loops: no bounds check at all. The caller is responsible for guaranteeing 1 <= index <= size(), typically by looping over 1, array%size(). Reading an index outside that range returns undefined data. Use at unless the bounds check is measurably in the way.

True when no elements are live.

True when a further push_back would fail.

Remove and return the last element (LIFO). On an empty array value is set to zero and err is set to ERROR_VALIDATION. On success err is left untouched.

Append an element. If the array is already at capacity the element is not stored, the size is left unchanged and err is set to ERROR_VALIDATION. On success err is left untouched.

Number of live elements.

Copy of the live elements as a plain array of extent size(), not capacity(). Returns a zero-length array when empty. This is how the contents are handed to ordinary Fortran routines; note that it is the one operation here that does allocate, so keep it out of the hot path.

Bounds-checked element access, 1-based. Any index outside 1:size() (including indices that are within the capacity but beyond the live elements) sets value to zero and err to ERROR_VALIDATION. On success err is left untouched.

Maximum number of elements, i.e. PIC_FIXED_ARRAY_CAPACITY.

Drop every element. The storage itself is untouched, so this is a single integer assignment; the array can be reused immediately.

UNCHECKED element access for inner loops: no bounds check at all. The caller is responsible for guaranteeing 1 <= index <= size(), typically by looping over 1, array%size(). Reading an index outside that range returns undefined data. Use at unless the bounds check is measurably in the way.

True when no elements are live.

True when a further push_back would fail.

Remove and return the last element (LIFO). On an empty array value is set to zero and err is set to ERROR_VALIDATION. On success err is left untouched.

Append an element. If the array is already at capacity the element is not stored, the size is left unchanged and err is set to ERROR_VALIDATION. On success err is left untouched.

Number of live elements.

add flops to the flop rate type, this will add the flops to the flop recorder Usage: call my_flop_rate%add_flops(1000)

get the flop rate in GFLOP/s, this will calculate the flop rate based on the number of flops and the elapsed time

get the number of flops recorded in the flop rate type

get the elapsed time in seconds from the timer contained in the flop rate type

report the flop rate, this will print the flop rate in GFLOP/s

reset the flop rate type, this will reset the timer and the flop recorder

Calls the start method for the timer contained in the flop rate type

Calls the stop method for the timer contained in the flop rate type

Flush all buffered entries through the real logger, then clear the buffer. This is impure — call it once you are back outside the pure call chain.

One FNV-1a round: exclusive-or in a byte, then multiply by the prime.

One FNV-1a round: exclusive-or in a byte, then multiply by the prime.

FNV_1 interfaces

FNV_1A interfaces

Multiply a 32-bit FNV state by the FNV prime, modulo 2**32.

ISO 8601, for example 2026-09-14T09:46:00.123Z.

Width the frame truncates to.

Force the next render to emit every row.

The escape sequence that brings the screen up to date.

Set the frame’s dimensions, discarding the diff.

Number of lines the frame holds.

Set one line, truncated to the frame width in code points.

Compare two character sequences for being greater or equal In this version the right-hand side character sequences is by a string.

Compare two character sequences for being greater or equal. In this version the left-hand side character sequences is by a string.

Compare two character sequences for being greater or equal. In this version both character sequences are by a string.

Get the first command line argument, expected to be a filename.

Get the int64 number of FLOPs we currently have in the counter

I print random knowledge

Get the current precision for real numbers

Obtain the current precision being used to print variables to strings

get_threading_mode returns the current threading mode for the array routines Usage: mode = get_threading_mode()

get the current threading mode for the array routines Usage: mode = get_threading_mode()

Double the bucket table and rehash. Entry storage is never moved.

integer(int32) counterpart of grow_int64.

Reallocate arr to new_cap slots, keeping its first n_keep values.

Compare two character sequences for being greater. In this version the right-hand side character sequences is by a string.

Compare two character sequences for being greater. In this version the left-hand side character sequences is by a string.

Compare two character sequences for being greater. In this version both character sequences are by a string.

Fetch the entry at position in the iteration order, counting from 1. This is the exact-fidelity iteration accessor: key comes back with the key’s true length, trailing blanks included.

Current number of buckets, 0 while the map is unallocated. Exposed so that callers and tests can observe growth; it never affects iteration order.

Remove every entry but keep the allocated capacity, so that refilling the map does not have to reallocate. A cleared map iterates as empty and the next insert starts a fresh insertion order at position 1.

Release every buffer and return the map to the unallocated state.

Look up key. A missing key is an ordinary outcome, not an error: found comes back .false. and value is set to 0.

.true. when key is stored in the map.

Allocate the map, discarding any entries it already held.

Insert key with value, or overwrite the value of an existing key.

.true. when the map holds no entries.

All keys, in insertion order.

Remove key from the map.

Number of entries currently stored.

All values, in insertion order. values() and keys() are index aligned: values(i) belongs to keys(i). Zero-sized for an empty map.

Replace the heap contents with keys/payloads, heapified in O(n).

Number of entries the heap can hold before it has to grow.

Remove every entry but keep the allocated storage for reuse.

Release the heap storage and reset it to empty.

Initialise the heap, discarding any previous contents.

.true. when the heap holds no entries.

Return the root entry without removing it.

Remove and return the root entry (minimum, or maximum for a max-heap).

Insert one (key, payload) entry in O(log n).

Ensure room for at least n entries without further reallocation.

Number of entries currently in the heap.

Bucket a key hashes to before probing.

Report whether the running machine stores the least significant byte of an integer first.

Code in ASCII collating sequence.

Code in ASCII collating sequence.

Character-to-integer conversion function.

Character-to-integer conversion function.

Add one to a decimal digit string, growing it on carry out.

Position of a substring within a string.

Position of a sequence of character within a character sequence. In this version the sub character sequence is represented by a string.

Position of a sequence of character within a character sequence. In this version the main character sequence is represented by a string.

Position of a sequence of character within a character sequence. In this version both character sequences are represented by a string.

Log a message that will only be printed at the info level of verbosity

The original FNV-1 8-bit key algorithm.

The original FNV-1a 8-bit key algorithm.

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

Test two floating-point values for approximate equality.

Approximate equality for real(dp) values.

Approximate equality for real(sp) values.

Checks whether c is a control character.

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

The is equal interface is used to circumvent the fact that Fortran, rightfully, complains about comparing two reals without involving a tolerance, i.e. if(a == b) since there is no guarantee that the two reals are exactly equal due to floating point precision issues. The functions are defined as elemental

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

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

Test whether a value lies within the inclusive range [lo, hi].

Inclusive range test for real(dp).

Inclusive range test for integer(int32).

Inclusive range test for integer(int64).

Inclusive range test for real(sp).

Whether arg is a --name form. A bare -- is not.

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

True for negative values. The result for negative zero is processor dependent, so callers must not rely on it: every caller here tests value == 0 first and drops the sign for zero. Not valid for NaN, which the callers have already filtered out.

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

True when code falls inside the range PIC reserves for its own error codes (0 .. PIC_ERROR_CODE_MAX). Downstream libraries can assert their own codes are outside it: if (is_pic_error_code(MYLIB_ERROR_SOCKET)) error stop “code clash”

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.

Whether arg is a -s form. A bare - is not, and neither is a negative number, which must be able to reach a positional.

is_sorted provides a simple way to checking if a 1d array is sorted it is implemented for int32, int64, sp, and dp datatypes. The default is to check if an array is sorted in ascending fashion.

check if a 1d array of type char is sorted

check if a 1d array of type dp is sorted

check if a 1d array of type int32 is sorted

check if a 1d array of type int64 is sorted

check if a 1d array of type sp is sorted

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.

Joins a list of strings with a separator (default: space). Returns a new string

Joins a list of strings with a separator (default: space). Returns a new string

Exact key comparison: same length and same characters. Deliberately not the Fortran == operator, which blank-pads the shorter operand.

Log a message that will only be printed at the error of verbosity

Log a message that will only be printed at the large_info level of verbosity

Compare two character sequences for being less or equal In this version the right-hand side character sequences is by a string.

Compare two character sequences for being less or equal. In this version the left-hand side character sequences is by a string.

Compare two character sequences for being less or equal. In this version both character sequences are by a string.

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.

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 two character sequences for being greater or equal In this version the right-hand side character sequences is by a string.

Lexically compare two character sequences for being greater or equal. In this version the left-hand side character sequences is by a string.

Lexically compare two character sequences for being greater or equal. In this version both character sequences are 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.

Lexically compare two character sequences for being greater. In this version the right-hand side character sequences is by a string.

Lexically compare two character sequences for being greater. In this version the left-hand side character sequences is by a string.

Lexically compare two character sequences for being greater. In this version both character sequences are by a string.

Expand one limb into exactly LIMB_DIGITS zero padded characters, table driven the same way pic_strings converts integers.

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 two character sequences for being less or equal In this version the right-hand side character sequences is by a string.

Lexically compare two character sequences for being less or equal. In this version the left-hand side character sequences is by a string.

Lexically compare two character sequences for being less or equal. In this version both character sequences are 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.

Lexically compare two character sequences for being less. In this version the right-hand side character sequences is by a string.

Lexically compare two character sequences for being less. In this version the left-hand side character sequences is by a string.

Lexically compare two character sequences for being less. In this version both character sequences are by a string.

internal subroutines that processes the message and filters it according to the verbosity level set by the user or the default this is a private subroutine so it is not exposed to the user

Whether arg is a negative number rather than an option.

Compare two character sequences for being less. In this version the right-hand side character sequences is by a string.

Compare two character sequences for being less. In this version the left-hand side character sequences is by a string.

Compare two character sequences for being less. In this version both character sequences are by a string.

Test whether seq is a finished escape sequence.

Safely return the character sequences represented by the string

Arithmetic mean of a 1-D array, returned as real(dp).

Mean of a real(dp) array.

Mean of an integer(int32) array.

Mean of an integer(int64) array.

Mean of a real(sp) array.

Minimum and maximum of a 1-D array in a single length-2 result.

Minimum and maximum of a real(dp) array.

Minimum and maximum of an integer(int32) array.

Minimum and maximum of an integer(int64) array.

Minimum and maximum of a real(sp) array.

The SplitMix64 finalising mix (the “MurmurHash3-style” avalanche used by splitmix64.c). Used both as the generator output stage and as the seed derivation function for stream_for.

Milliseconds from an unspecified origin, or PIC_CLOCK_NO_CLOCK.

Shared body of monotonic_ms and monotonic_us.

Microseconds from an unspecified origin, or PIC_CLOCK_NO_CLOCK.

Moves the allocated character scalar from ‘from’ to ‘to’

Moves the allocated character scalar from ‘from’ to ‘to’ No output

Moves the allocated character scalar from ‘from’ to ‘to’ No output

Moves the allocated character scalar from ‘from’ to ‘to’ No output

Moves the allocated character scalar from ‘from’ to ‘to’ No output

Compare two character sequences for inequality. In this version the right-hand side character sequences is by a string.

Compare two character sequences for inequality. In this version the left-hand side character sequences is by a string.

Compare two character sequences for inequality. In this version both character sequences are by a string.

Draw a uniform integer in [0, n) by rejection sampling.

Return true with probability ppm in a million.

Draw an exponential deviate with the given mean.

Draw an exponentially distributed integer with the given mean, in whatever unit mean is expressed in.

Draw a normal deviate with mean mu and standard deviation sigma.

Draw a Poisson-distributed count with mean mean_milli/1000.

Index of the next unfilled positional, advancing used.

Draw a uniform integer in the inclusive range [lo, hi].

Draw a uniform real(dp) in [0, 1).

The current local date and time.

The current date and time in UTC, with utc_offset_min zero.

Pop an NVTX range (no-op if PIC_USE_NVTX not defined)

Push an NVTX range (no-op if PIC_USE_NVTX not defined)

The trailing zone designator of an ISO 8601 timestamp.

One-line notice that count intermediate causes were dropped

Operator for checking error state: if (.haserror. err) then

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

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

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.

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.

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

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.

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.

Handle optional character(len=*) value

Handle optional real(dp) value

Handle optional integer(int32) value

Handle optional integer(int64) value

Handle optional logical value

Handle optional real(sp) value

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.

function to pad a string with a certain number of characters for nice printing

adds a number X of spaces to the left of a “string” whcih is just a collection of characters. Mostly used for nice printing

value in decimal, zero filled on the left to width characters. A value too wide to fit is not truncated; the field simply grows.

Blank pad on the left, widening rather than truncating.

Left pad the input string

Left pad the input string with ” ” (1 whitespace)

Left pad the input string with the ‘pad_with’ character

Left pad the input string with ” ” (1 whitespace)

Left pad the input string with the ‘pad_with’ character

Right pad the input string

Right pad the input string with ” ” (1 whitespace)

Right pad the input string with the ‘pad_with’ character

Right pad the input string with ” ” (1 whitespace)

Right pad the input string with the ‘pad_with’ character

Parse a string into an integer, reporting failures through error_t.

Parse a character string into a 32 bit integer.

Parse a string_type into a 32 bit integer.

Parse a character string into a 64 bit integer.

Parse a string_type into a 64 bit integer.

Core integer parser, accumulating in int64.

Parse a string into a real, reporting failures through error_t.

Parse a character string into a double precision real.

Parse a string_type into a double precision real.

Parse a character string into a single precision real.

Parse a string_type into a single precision real.

Core real parser.

Give the container n live elements, discarding any it already had.

Allocated length of every field array. Always at least size().

Drop every live element but keep the allocated capacity.

Release every field array and reset both counters to zero.

Read a container back from an open stream unit.

Change the number of live elements, preserving the elements that survive.

Write the container to an open stream unit.

Exact size in bytes of the stream serialize would write now.

Number of live elements.

32-bit FNV-1a digest of the container’s live state.

64-bit FNV-1a digest of the container’s live state.

Total weight of walking path through graph.

Next 32-bit output, returned as the int32 with the same bit pattern as the reference implementation’s uint32_t result. Roughly half of the returned values are therefore negative; use next_real_dp or next_below if a magnitude is wanted.

Uniform integer in [0, n) from a PCG32 generator. Each attempt consumes two 32-bit outputs, so the stream stays word aligned no matter how many rejections occur.

True with probability ppm in a million, from a pcg32_t generator.

Exponential deviate from a PCG32 generator.

Exponential integer with the given mean, from a pcg32_t generator.

Normal deviate from a PCG32 generator.

Poisson count with mean mean_milli/1000, from a pcg32_t generator.

Uniform integer in [lo, hi] from a pcg32_t generator.

Uniform real(dp) in [0, 1) from a PCG32 generator. Consumes two 32-bit outputs.

Full 64-bit random word built from two consecutive 32-bit outputs; the first output supplies the high half. Fixing the order here is what makes next_real_dp and next_below reproducible for this engine.

Seed the generator, following the reference pcg32_srandom_r: the stream selector is shifted left and forced odd to become the LCG increment, then the state is warmed up, offset by the requested state and warmed up again.

Advance the LCG one step and return the XSH-RR permutation of the previous state as an unsigned value in [0, 2**32).

Uniform unsigned integer in [0, span_minus_1], by rejection.

Forget any partial escape sequence.

Whether a partial sequence is being carried.

Log a message that will only be printed at the performance of verbosity

copy provides a blas-less implementation of xcopy where x is (i,s,d) icopy, scopy, dcopy if you built pic with BLAS use the copy interface provided there, I will not beat BLAS copy is implemented for (int32, int64, sp, dp) for 1 and 2d arrays of the same types

fill provides a generic interface to assing a value alpha of types (int32, int64, sp, dp) as defined in pic_types.F90 The inteface supports filling 1d and 2d arrays of the specified variables

Overloaded interface for optional value retrieval, supported types are: - integer(int32), integer(int64), real(sp), real(dp), character(len=*), logical

Generic interface for printing arrays of different types

my cool banner, work in progress

pic_sum provides a threaded alternative to the sum(array) Fortran intrinsic which will be too slow for large sizes of vectors and matrices. Note that this provides the total sum. As opposed to the blas alternative XASUM which does the absolute sum

pic_transpose provides a blas-less, threaded alternative to the Fortran transpose intrinsic which will be slow for large matrix sizes. pic_transpose does not assume symmetric matrices

.true. when entry left must pop before entry right.

Print a 3D tensor of values

Print a 3D tensor of values

Print a 3D tensor of values

Print a 3D tensor of values

prints a convenient row of asterisks of length n

print a matrix of values

print a matrix of values

print a matrix of values

print a matrix of values

Print a packed lower triangular matrix of values

Print a packed lower triangular matrix of values

Print a packed lower triangular matrix of values

Print a packed lower triangular matrix of values

print a vector of values

print a vector of values

print a vector of values

print a vector of values

First empty bucket in the probe sequence of key. The load factor keeps at least one bucket empty at all times, so this always finds one.

Disable profiling temporarily

Enable profiling (if it was disabled)

Finalize the profiler and release resources

Get accumulated time for a named region

Initialize the profiler

Print profiling report sorted by time

Reset all timing data while keeping region names

Start a named profiling region

Stop a profiling region

Buffer a debug-level message

Buffer an error-level message

Buffer an info-level message

Buffer a knowledge-level message

Buffer a large_info-level message

Buffer a performance-level message

Buffer a verbose-level message

Buffer a warning-level message

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)

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

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

Read one record back, validating its type tag and its length.

Read a character scalar record into a deferred length string.

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

Read and validate the stream header.

Read an integer(int32) array record.

Read an integer(int64) array record.

Read a real(dp) array record. See read_real_sp_array for the way the foreign endian path is kept away from the native one.

Read a real(sp) array record.

Read a record header, check the type tag, and bounds check the announced payload against the real length of the file.

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

Turn a 64-bit random word into a real(dp) in [0, 1) using its top 53 bits. See the next_real_dp interface documentation for the exactness argument.

Re-index every entry into the bucket table. Touches buckets only, so the insertion order is untouched by construction.

Total on disk size of a record, including its 12 byte record header.

Smallest 2**k - 1 that is at least n - 1, for n >= 1.

Smallest 2**k - 1 that covers span_minus_1 read as unsigned.

Remove a region index from the stack (helper for explicit stop)

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

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

Replaces all the occurrences of substring ‘pattern’ in the input ‘string’ with the replacement ‘replacement’ Returns a new string

Replaces all occurrences of substring ‘pattern’ in the input ‘string’ with the replacement ‘replacement’ Returns a new string

Replaces all occurrences of substring ‘pattern’ in the input ‘string’ with the replacement ‘replacement’ Returns a new string

Replaces all occurrences of substring ‘pattern’ in the input ‘string’ with the replacement ‘replacement’ Returns a new string

Replaces all occurrences of substring ‘pattern’ in the input ‘string’ with the replacement ‘replacement’ Returns a new string

Replaces all occurrences of substring ‘pattern’ in the input ‘string’ with the replacement ‘replacement’ Returns a new string

Replaces all occurrences of substring ‘pattern’ in the input ‘string’ with the replacement ‘replacement’ Returns a new string

Replaces all occurrences of substring ‘pattern’ in the input ‘string’ with the replacement ‘replacement’ Returns a new string

Ensure the insertion-order arrays hold at least needed entries. Explicit allocate/copy/move_alloc rather than reallocation-on-assignment, which is shaky on some supported compilers.

Ensure the packed key pool holds at least needed characters.

Resets the flop counter to 0_int64

Reverses the character sequence hold by the input string

Reverse the character order in the input character variable

Returns a new character sequence which is reverse of the input charater sequence This method is elemental and returns a character sequence

Reverse the character sequence hold by the input string

Fetch the root entry, reporting an error when the heap is empty.

Rotate the low 32 bits of x right by rot bits, 0 <= rot <= 31. Branch free: when rot is zero the left-shifted term is shifted clean out of the low 32 bits and the mask removes it.

Round an exact digit string to n_keep leading digits, half to even.

Multiply a Q32.32 value by an integer mean and drop the fraction.

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

Scan a character sequence for any of the characters in a set of characters. In this version the set of characters is represented by a string.

Scan a character sequence for any of the characters in a set of characters. In this version the character sequences is represented by a string.

Scan a character sequence for any of the characters in a set of characters. In this version both the character sequence and the character set are represented by a string.

should not be used, intended for testing purposes. randomizes an array of type char

should not be used, intended for testing purposes. randomizes an array of type dp

should not be used, intended for testing purposes. randomizes an array of type int32

should not be used, intended for testing purposes. randomizes an array of type int64

should not be used, intended for testing purposes. randomizes an array of type sp

Close a unit previously opened by one of the open helpers.

Open an existing serialized stream for reading.

Open filename for writing a serialized stream, replacing any existing file.

Set brackets based on output format type

Configure whether logs should include explicit level prefixes.

This routine overrides the default dp precision used for printing strings in the to_char function, the default is : integer(default_int), parameter :: default_dp_precision = 12

Set the precision for real numbers

set_threading sets the threading mode for the array routines this will set the use_threaded variable to true or false depending on the input Usage: call set_threading_mode(.true.) or call set_threading_mode(.false.)

set the threading mode for the array routines, this will set the use_threaded variable to true or false depending on the input

Implementation to transfer a set of characters to a string representing the set.

Move entry start towards the leaves until the heap property holds.

Move entry start towards the root until the heap property holds.

Advance pos past a leading + or - if one is present.

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

Extracts characters from the input string to return a new string

Extract the characters from the region between ‘first’ and ‘last’ index (both inclusive) of the input ‘string’ by taking strides of length ‘stride’ Returns a new string

Extract the characters from the region between ‘first’ and ‘last’ index (both inclusive) of the input ‘string’ by taking strides of length ‘stride’ Returns a new string

Turn a non-zero stat= from an allocate into ERROR_ALLOC.

Verify that a field record read back holds the expected element count.

Verify that n live elements really exist in a field array.

Validate the arguments of a field resize.

Short schema spelling of a field kind code, or "?" if unknown.

pic_serialize record tag a field kind is stored as, or -1 if the kind is unknown. A logical field maps onto the int32 tag.

Capacity that covers required elements under the geometric policy.

Fold the first n elements of an integer(int32) field into a 64-bit hash.

Fold the first n elements of an integer(int64) field into a 64-bit hash.

Fold the first n elements of a logical field into a 64-bit hash.

Fold the first n elements of a real(dp) field into a 64-bit hash.

Fold the first n elements of a real(sp) field into a 64-bit hash.

Reset a hash accumulator and fold in a container’s identity.

Reset a 32-bit hash accumulator and fold in a container’s identity.

Reset a 64-bit hash accumulator and fold in a container’s identity.

Fold the first n elements of one field into a hash accumulator.

Fold the first n elements of an integer(int32) field into a hash.

Fold the first n elements of an integer(int64) field into a hash.

Fold the first n elements of a default logical field into a hash.

Fold the first n elements of a real(dp) field into a hash.

Fold the first n elements of a real(sp) field into a hash.

Work out what a resize to new_size elements has to do.

Read one field record back and check its length.

Read an integer(int32) field record.

Read an integer(int64) field record.

Read a default logical field from an int32 record of 0/1 codes.

Read and validate the prologue, returning the element count.

Read a real(dp) field record.

Read a real(sp) field record.

Give one field array a new allocated length, preserving a prefix.

Resize an integer(int32) field.

Resize an integer(int64) field.

Resize a default logical field.

Resize a real(dp) field.

Resize a real(sp) field.

Exact size in bytes of the stream a container of n elements writes.

Write the first n elements of one field as a stream record.

Write the first n elements of an integer(int32) field.

Write the first n elements of an integer(int64) field.

Write the first n elements of a default logical field as an int32 record of 0/1 codes.

Write the stream header, the schema record and the element count.

Write the first n elements of a real(dp) field.

Write the first n elements of a real(sp) field.

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.

Insertion-sort one row segment lo:hi by column index.

Detect NaN and the infinities and return their canonical spelling.

Split a string on every occurrence of a delimiter, keeping empty fields.

Split a character string on a character delimiter.

Split a character string on a string_type delimiter.

Split a string_type on a character delimiter.

Split a string_type on a string_type delimiter.

Advance the state by the golden-ratio increment and return the mixed 64-bit output.

Uniform integer in [0, n) from a SplitMix64 generator.

True with probability ppm in a million, from a splitmix64_t generator.

Exponential deviate from a SplitMix64 generator.

Exponential integer with the given mean, from a splitmix64_t generator.

Normal deviate from a SplitMix64 generator.

Poisson count with mean mean_milli/1000, from a splitmix64_t generator.

Uniform integer in [lo, hi] from a splitmix64_t generator.

Uniform real(dp) in [0, 1) from a SplitMix64 generator.

Full 64-bit random word. For SplitMix64 this is simply next; it exists so that both engines present the same interface to the shared real and bounded-integer conversions.

Set the generator state. Any 64-bit value is a valid seed, including zero: SplitMix64 has no degenerate state.

Uniform unsigned integer in [0, span_minus_1], by rejection.

Check whether a string starts with substring or not

Check whether a string starts with substring or not

Check whether a string starts with substring or not

Check whether a string starts with substring or not

Check whether a string starts with substring or not

Standard deviation of a 1-D array, returned as real(dp).

Standard deviation of a real(dp) array.

Standard deviation of an integer(int32) array.

Standard deviation of an integer(int64) array.

Standard deviation of a real(sp) array.

Derive an independent, reproducible generator for a stream id.

Build the PCG32 generator belonging to stream_id. The derived seed drives a local SplitMix64 which supplies both the LCG state and the stream selector.

Build the SplitMix64 generator belonging to stream_id.

Deterministic seed for stream_id under master_seed.

Constructor for new string instances

Remove leading and trailing whitespace characters.

Remove leading and trailing whitespace characters.

Remove leading and trailing whitespace characters.

Wrap text in the requested attributes and a reset.

perform the total sum of all components of type dp in a 3d tensor

perform the total sum of all components of type int32 in a 3d tensor

perform the total sum of all components of type int64 in a 3d tensor

perform the total sum of all components of type sp in a 3d tensor

perform the total sum of all components of type dp in a matrix

perform the total sum of all components of type int32 in a matrix

perform the total sum of all components of type int64 in a matrix

perform the total sum of all components of type sp in a matrix

perform the total sum of all components of type dp in a vector

perform the total sum of all components of type int32 in a vector

perform the total sum of all components of type int64 in a vector

perform the total sum of all components of type sp in a vector

Exchange two heap slots, key, payload and insertion index together.

Returns the elapsed time as a real(dp) variable

Prints the elapsed time at the time of calling

starts the timer. If OMP is enabled, it will use omp_get_wtime() if not, it will use Fortran’s system_clock

stop the timer. If OMP is enabled, it will use omp_get_wtime() if not, it will use Fortran’s system_clock

Format or transfer other types as a string.

Convert a Fortran character string to a C character array

Convert a Fortran string type to a C character array

converts a variable of type (int32, int64, sp, dp, char, logical) to a series of chars which is just a collecting of chars.

transform a character to a string

format a non-negative cell/element count with an SI suffix 500 -> “500 cells”, 40000 -> “40.0 K cells”, 4_000_000 -> “4.0 M cells”, 4_000_000_000 -> “4.0 B cells”

transform a real(dp) to a string

transform an int32 to a string

transform an int64 to a string

tranform a logical to a string either true or false

transform a real(sp) to a string

Returns the lowercase version of the character sequence hold by the input string

Convert character variable to lower case

Returns a new character sequence which is the lower case version of the input character sequence This method is elemental and returns a character sequence

Convert the character sequence hold by the input string to lower case

Returns the sentencecase version of the character sequence hold by the input string

Converts character sequence to sentence case

Returns a new character sequence which is the sentence case version of the input character sequence This method is elemental and returns a character sequence

Convert the character sequence hold by the input string to sentence case

Format or transfer other types as a string.

Render a real in fixed point notation with an exact number of decimals. Fixed point rendering, never an exponent.

Fixed point rendering of a real(dp) value.

Fixed point rendering of a real(sp) value.

Render a real in scientific notation with a canonical exponent field. Scientific rendering, canonical form [-]D[.DDD]e[+-]NN.

Scientific rendering of a real(dp) value.

Scientific rendering of a real(sp) value. See to_string_fixed_sp for why the widening to real(dp) is lossless.

Render an integer right aligned in a field of the requested width. Right aligned integer rendering, blank padded on the left.

Right aligned rendering of an integer(int32) value.

Right aligned rendering of an integer(int64) value.

Returns the titlecase version of the character sequence hold by the input string

Converts character sequence to title case

Returns a new character sequence which is the title case version of the input character sequence This method is elemental and returns a character sequence

Convert the character sequence hold by the input string to title case

Returns the uppercase version of the character sequence hold by the input string

Convert character variable to upper case

Returns a new character sequence which is the upper case version of the input character sequence This method is elemental and returns a character sequence

Convert the character sequence hold by the input string to upper case

Split a string into whitespace separated words.

Split a character string into whitespace separated words.

Split a string_type into whitespace separated words.

Walk prev from target back to source and return it forwards.

transpose a matrix of datatype dp

transpose a matrix of datatype int32

transpose a matrix of datatype int64

transpose a matrix of datatype sp

Returns the character sequence hold by the string without trailing spaces.

Returns the character sequence hold by the string without trailing spaces.

Cut text to at most width columns, never mid-character and never inside an escape sequence.

Reinterpret an unsigned 32-bit value held in [0, 2**32) as the signed int32 with the same bit pattern. Done arithmetically rather than with transfer, and without ever passing an out-of-range value to int.

(a + b) reduced modulo 264, without ever overflowing a signed 64-bit integer. Operands are split into 32-bit halves with ibits, so each half sum stays below 233.

.true. when a < b with both operands read as unsigned 64-bit values.

(a * b) reduced modulo 2**64, without ever overflowing a signed 64-bit integer.

Logical (zero-filling) right shift of a 64-bit word by n bits, 0 <= n <= 63. Written with ibits rather than ishft(x, -n) or the Fortran 2008 shiftr for the portability reasons given in the module documentation.

Milliseconds since 1970-01-01T00:00:00Z.

Do nothing but mark an unused dummy argument as such to acknowledge compile time warning like:

Feed a character string, one iachar byte per character.

Feed a character string, one iachar byte per character.