Procedures

Checks the two modes of aprod for LSQR.

add an edge index for this vertex

add an edge to this node (path to another node with the specified distance)

returns true if all the elements of ivals are in the set iset

aprod1 computes y = y + Ax for subroutine aprod, where A is a test matrix of the form A = HYD*HZ, and the latter matrices HY, D, HZ are represented by input vectors with the same name.

aprod2 computes x = x + A(t)y for subroutine aprod, where A is a test matrix of the form A = HYD*HZ, and the latter matrices HY, D, HZ are represented by input vectors with the same name.

The internal aprod function for the lsqr_solver_ez class.

This is the matrix-vector product routine required by subroutines LSQR and CRAIG for a test matrix of the form A = HYDHZ. The quantities defining D, HY, HZ are in the work array rw, followed by a work array w. These are passed to aprod1 and aprod2 in order to make the code readable.

Backtracking line search.

return true if hand1 beats hand2 (has a higher score)

Character array to integer routine

Basic string to integer routine

Basic string to integer(ip) routine. Hacky hack just so we can overload as int()

if the char is part of a number, then get it and append to ivals

Clear all exceptions.

Print runtime in milliseconds form the start of the clock.

Start the clock

Returns the columns in a sparsity partition group.

Wrapper for computing the function, using the cache.

Computes the indices vector in the class.

Compute the Jacobian.

just a wrapper for compute_jacobian, that returns a dense (m x n) matrix.

A separate version of compute_jacobian to be used only when computing the sparsity pattern in compute_sparsity_random_2. It uses class_meths and the sparsity dperts and bounds.

Compute the Jacobian using finite differences, (using the partitioned sparsity pattern to compute multiple columns at a time).

Compute the Jacobian using finite differences. (one column at a time)

Returns the product J*v, where J is the m x n Jacobian matrix and v is an n x 1 vector.

Compute the Jacobian one element at a time using the Neville's process algorithm diff. This takes a very large number of function evaluations, but should give a very accurate answer.

Compute dx, the perturbation vector for x

Compute dx, the perturbation vector for x used when computing the gradients.

assume all elements of Jacobian are non-zero.

Computes the sparsity pattern and return it. Uses the settings currently in the class.

Compute dx, the perturbation vector for x used when computing the sparsity pattern.

Compute the sparsity pattern by computing the function at three "random" points in the [xlow_for_sparsity, xhigh_for_sparsity] interval and checking if the function values are the same.

Compute the sparsity pattern by computing a 2-point jacobian at a specified number of "random" points (num_sparsity_points) in the [xlow_for_sparsity, xhigh_for_sparsity] interval and checking if they are the same.

count the number of adjacent cells not a tree

Cross product of two real 3x1 vectors

Returns $\sqrt{ a^2 + b^2 }$ with precautions to avoid overflow.

Destroy the dag.

Generate the dependency matrix for the DAG.

Generate a Graphviz digraph structure for the DAG.

get all the vertices that depend on this vertex.

get the edges for the vertex (all the the vertices that this vertex depends on).

Generate a Graphviz digraph structure for the DAG and write it to a file.

set the edges for a vertex in a dag

set info about a vertex in a dag.

set the number of vertices in the dag

Main toposort routine

copies a vector, x, to a vector, y.

dot product of two vectors

Given the sparsity pattern of an m by n matrix a, this subroutine determines the degree sequence for the intersection graph of the columns of a.

Problem function true derivative

get destination point

Destroy a cache.

Destroy a cache.

Destructor

destroy the numdiff_type class.

destroy a sparsity_pattern type.

Destroy the sparsity pattern in the class.

the procedure diff calculates the first, second or third order derivative of a function by using neville's process to extrapolate from a sequence of simple polynomial approximations based on interpolating points distributed symmetrically about x0 (or lying only on one side of x0 should this be necessary). if the specified tolerance is non-zero then the procedure attempts to satisfy this absolute or relative accuracy requirement, while if it is unsuccessful or if the tolerance is set to zero then the result having the minimum achievable estimated error is returned instead.

Difference ip vector

Returns a set of slightly randomized equally-spaced points that divide an interval.

euclidean norm of a vector.

continue forward in time until all the bricks settle.

scales a vector by a constant.

The purpose of dsm is to determine an optimal or near- optimal consistent partition of the columns of a sparse m by n matrix a.

Wrapper for dsm to compute the sparsity pattern partition.

Returns true if the values in the array are the same (to within the specified absolute tolerance).

An exact linesearch that uses a derivative-free minimizer to find the minimum value of f(x) between x = xold + p * alpha_min and x = xold + p * alpha_max.

Add elements to the integer vector in chunks.

Add elements to the integer vector in chunks.

Add elements to the integer vector in chunks.

Add elements to the real vector in chunks.

export an iteration:

export an iteration:

extrapolate the next value in the sequence using a difference table. Straightfoward implemention: create the full table, and then evaluate it.

This procedure attempts to estimate the level of rounding errors in the calculated function values near the point x0+h0 by fitting a least-squares straight-line approximation to the function at the six points x0+h0-j*h1, (j = 0,1,3,5,7,9), and then setting facc to twice the largest deviation of the function values from this line. hi is adjusted if necessary so that it is approximately 8 times the smallest spacing at which the function values are unequal near x0+h0.

Returns True if an exception has been raised.

Function subroutine for testing fdjs.

Given a consistent partition of the columns of an m by n jacobian matrix into groups, this subroutine computes approximations to those columns in a given group. the approximations are stored into either a column-oriented or a row-oriented pattern.

constructor

A simple search that just evaluates the function at a specified number of points and picks the one with the minimum function value.

An approximation x to the point where f attains a minimum on the interval (ax,bx) is determined.

Problem function

Test function to minimize.

compute the function

compute the function

Generate a "dense" sparsity partition.

count of all the parts in the set

Returns all the methods with the given class (i.e., number of points in the formula).

reursively get a list of all pieces above piece i

reursively get a list of all pieces below piece i

Returns the current error code and message.

Return a string with the finite difference formula. Input is the method id code.

Return a finite_diff_method given the id code. (the id codes begin at 1, are sequential, and uniquely define the method).

Return a string with the finite difference formula.

Check if the x vector is in the cache, if so return f. Note that only some of the elements may be present, so it will return the ones there are there, and indicate which ones were found.

Check if the x vector is in the cache, if so return f. Note that only some of the elements may be present, so it will return the ones there are there, and indicate which ones were found.

get the full number contining the character at i,j

get set of pieces directly above piece i

get set of pieces directly below piece i

Returns the sparsity pattern from the class. If it hasn't been computed, the output arrays will not be allocated.

Return the status code and message from the nlesolver_type class.

compute the number of cols to left of mirror (0 if none) call with transpose(puzzle) to get number of rows above.

solve the case

compute the gradient of the function (Jacobian):

compute the gradient of the function (Jacobian):

compute the gradient of the function (Jacobian):

returns the type of hand

Determine the ASCII code for the current character of the string.

hprod applies a Householder transformation stored in hz to get y = ( I - 2hzhz(transpose) ) * x.

given the sparsity pattern of an m by n matrix a, this subroutine determines an incidence-degree ordering of the columns of a.

read the data

Initialize the cache. Must be called first before use.

Initialize the cache. Must be called first before use.

Constructor for lsqr_solver_ez.

Constructor for a finite_diff_method.

Constructor for the class.

Initialize a numdiff_type class. This must be called first.

Alternate version of initialize_numdiff routine when using diff to compute the Jacobian.

integer array to Character array

Convert an integer to a string.

Integer to allocatable string.

inverse of a 2x2 matrix.

returns true if a node is at these coordinates

returns true if the character is not a number.

returns true if the character is a number from 0 to 9.

LCM. based on code from NCAR Command Language

Solve the linear system: $Ax = b$, using a dense, direct method.

given a polygonal line connecting the vertices (x(i),y(i)) (i = 1,...,n) taken in this order. it is assumed that the polygonal path is a loop, where (x(n),y(n)) = (x(1),y(1)) or there is an arc from (x(n),y(n)) to (x(1),y(1)).

LSQR finds a solution $x$ to the following problems:

Unit test.

lstp generate a sparse least-squares test problem of the form ( A )x = ( b ) ( dampI ) ( 0 ) for solution by LSQR, or a sparse underdetermined system Ax + damps = b for solution by CRAIG. The matrix A is m by n and is constructed in the form A = HYD*HZ, where D is an m by n diagonal matrix, and HY and HZ are Householder transformations.

! nelem = numnz !!! Don't change nelem. ! nelem is now numnz below (it might be less than the input value).

! a(ldiagU + nrowu) = abest ! This was in pivot order. !!! DEBUG

! TPP ! Absolute test for Complete Pivoting

Manhattan distance between two ip points.

returns true if the pattern is valid for the int list.

move a piece down (fall one square) if it can be moved

Problem function

Problem function interface for numdiff

Main solver.

find the node number for this name

returns the index of these coordinates in the list of nodes (0 if it is not a node)

returns true if the cell isn't a tree

Returns the number of lines in a file (assumed to be open)

Given a sequence of integers, this subroutine groups together those indices with the same sequence value and, optionally, sorts the sequence into either ascending or descending order.

given a sequence of nb points (x(i),y(i)). parea computes the area bounded by the closed polygonal curve which passes through the points in the order that they are indexed. the final point of the curve is assumed to be the first point given. therefore, it need not be listed at the end of x and y. the curve is not required to be simple.

parse positive ints from a string that also includes text

Parse positive ints from a string that also includes text

parse space-deliminated ip sequence (positive or negative)

Perturb the specified optimization variable, and compute the function. This routine is designed so that df is accumulated as each function evaluation is done, to avoid having to allocate more temporary storage.

Perturb the specified optimization variable, and compute the function. This routine is designed so that df is accumulated as each function evaluation is done, to avoid having to allocate more temporary storage.

Print the contents of the cache. Used for debugging.

Print the contents of a finite_diff_method. Used for debugging.

Print the sparsity pattern.

Print the sparsity pattern in matrix form.

Print the sparsity pattern in vector form (irow, icol).

process this part through all the workflows.

process this part range starting with irule

Put a value into the cache.

Put a value into the cache.

Raise an exception.

Read a file into a 2d character array.

Read a file into a 2d character array.

Read a file into an ip integer array (one element per line)

Read a file into an integer array (one element per line)

Reads the next line from a file.

remove the lens with the label (if present)

Resize the sparsity arrays after accumulating them.

Reverse an ip vector

Select a finite diff method of a given class so that the perturbations of x will not violate the variable bounds.

Select a finite diff method of a given class so that the perturbations of x will not violate the variable bounds for any variable in the group.

given the sparsity pattern of an m by n matrix a, this subroutine determines a consistent partition of the columns of a by a sequential algorithm.

specify the edge indices for this vertex

Set the function in a diff_func. Must be called before diff.

Change the variable bounds in a numdiff_type.

Sets the variable bounds for sparsity in a numdiff_type. These are only used for sparsity_mode=2.

Set sparsity mode.

To specify the sparsity pattern directly if it is already known.

Set status flag and message.

given a column-oriented definition of the sparsity pattern of an m by n matrix a, this subroutine determines a row-oriented definition of the sparsity pattern of a.

Take a simple step in the search direction of p * alpha.

given the sparsity pattern of an m by n matrix a, this subroutine determines the smallest-last ordering of the columns of a.

Wrapper for lu1fac + lu6sol to solve a linear system A*x = b.

Wrapper for LSQR for the easy version of the class.

Sorts an integer array ivec in increasing order. Uses a basic recursive quicksort (with insertion sort for partitions with $\le$ 20 elements).

Sorts an integer array ivec in increasing order. Uses a basic recursive quicksort (with insertion sort for partitions with $\le$ 20 elements).

Sorts a real array ivec in increasing order. Uses a basic recursive quicksort (with insertion sort for partitions with $\le$ 20 elements).

Split a character string using a token. This routine is inspired by the Python split function.

Split a string, given a token.

given the non-zero elements of an m by n matrix a in arbitrary order as specified by their row and column indices, this subroutine permutes these elements so that their column indices are in non-decreasing order.

test if a string starts with a specified substring

starts with function for strings

take all valid steps from any # elements in array

convert the character string to an array of characters

Convert a string to a numeric array by mapping characters to integers (user-specified)

Convert a string to a numeric array by mapping characters to integers (user-specified)

Basic string to integer routine

Basic string to integer routine

Swap two integer values.

Swap two integer values.

swap function for hand type

Swap two integer values.

Swap two integer values.

Swap two character string values

A user-callable routine. When called, it will terminate all computations and return. The istat return code will be set to -1. This can be called in the function or the info function.

Can be called by the user in the function to terminate the computation. This will set ifail=-1.

This is an example driver routine for running LSQR. It generates a test problem, solves it, and examines the results. Note that subroutine aprod must be declared external if it is used only in the call to LSQR (and acheck).

each ? can be either a . or a # check pattern to match the int list

traverse the graph until we get to the end and check the max distance

travere the graph and visit all the connected nodes

Return only the unique values from vec.

Return only the unique values from vec.

Returns only the unique elements of the vector (sorted in ascending order).

Returns only the unique elements of the vector (sorted in ascending order).

populate the array using the start/end indices

DJB hash algorithm for a real(wp) vector.

DJB hash algorithm for a integer(ip) vector.

get the index of this workflow in the array

get the index of this workflow in the array

Tests if x solves a certain least-squares problem.