Procedures

Clear all exceptions.

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.

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.

Destroy a cache.

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.

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

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).

Add elements to the integer vector in chunks.

Add elements to the real vector in chunks.

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.

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

Generate a "dense" sparsity partition.

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

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.

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

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

Initialize the cache. Must be called first before use.

Constructor for a finite_diff_method.

Initialize a numdiff_type class. This must be called first.

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

Convert an integer to a string.

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.

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).

Put a value into the cache.

Raise an exception.

Resize the sparsity arrays after accumulating them.

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.

Change the dpert vector. Can be used after the class has been initialized to change the perturbation step sizes (e.g., after an iteration).

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.

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.

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

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).

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.

Swap two integer values.

Swap two integer values.

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

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.

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

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

DJB hash algorithm for a real(wp) vector.