Tail(S, 5, 8) *************************************************************************/

Tail(S, 5, 9) *************************************************************************/

Tail(S, 6, 10) *************************************************************************/

Tail(S, 6, 100) *************************************************************************/

Tail(S, 6, 11) *************************************************************************/

Tail(S, 6, 12) *************************************************************************/

Tail(S, 6, 13) *************************************************************************/

Tail(S, 6, 14) *************************************************************************/

Tail(S, 6, 30) *************************************************************************/

Tail(S, 6, 6) *************************************************************************/

Tail(S, 6, 7) *************************************************************************/

Tail(S, 6, 8) *************************************************************************/

Tail(S, 6, 9) *************************************************************************/

Tail(S, 7, 10) *************************************************************************/

Tail(S, 7, 100) *************************************************************************/

Tail(S, 7, 11) *************************************************************************/

Tail(S, 7, 12) *************************************************************************/

Tail(S, 7, 13) *************************************************************************/

Tail(S, 7, 14) *************************************************************************/

Tail(S, 7, 30) *************************************************************************/

Tail(S, 7, 7) *************************************************************************/

Tail(S, 7, 8) *************************************************************************/

Tail(S, 7, 9) *************************************************************************/

Tail(S, 8, 10) *************************************************************************/

Tail(S, 8, 100) *************************************************************************/

Tail(S, 8, 11) *************************************************************************/

Tail(S, 8, 12) *************************************************************************/

Tail(S, 8, 13) *************************************************************************/

Tail(S, 8, 14) *************************************************************************/

Tail(S, 8, 30) *************************************************************************/

Tail(S, 8, 8) *************************************************************************/

Tail(S, 8, 9) *************************************************************************/

Tail(S, 9, 10) *************************************************************************/

Tail(S, 9, 100) *************************************************************************/

Tail(S, 9, 11) *************************************************************************/

Tail(S, 9, 12) *************************************************************************/

Tail(S, 9, 13) *************************************************************************/

Tail(S, 9, 14) *************************************************************************/

Tail(S, 9, 30) *************************************************************************/

Tail(S, 9, 9) *************************************************************************/

Returns A-tile size for a matrix. A-tiles are smallest tiles (32x32), suitable for processing by ALGLIB own implementation of Level 3 linear algebra

Returns B-tile size for a matrix. B-tiles are larger tiles (64x64), suitable for parallel execution or for processing by vendor's implementation of

Returns the text streamed into this AssertionResult. Test assertions use it when they fail (i.e., the predicate's outcome doesn't match the assertion'

This function allocates all dataset-dependent array fields of KDTree, i.e. such array fields that their dimensions depend on dataset size. This funct

This function allocates all dataset-independend array fields of KDTree, i.e. such array fields that their dimensions do not depend on dataset

Recursive kd-tree generation subroutine. PARAMETERS KDT tree NodesOffs unused part of Nodes[] which must be filled by tree Spli

Recursive subroutine for box queries. -- ALGLIB -- Copyright 28.02.2010 by Bochkanov Sergey **************************************************

Rearranges nodes [I1,I2) using partition in D-th dimension with S as threshold. Returns split position I3: [I1,I3) and [I3,I2) are created as result.

Decreases lambda, but leaves it unchanged when there is danger of underflow. *************************************************************************

Increases lambda, returns False when there is a danger of overflow *************************************************************************/

This function provides reverse communication interface Reverse communication interface is not documented or recommended to use. See below for function

This subroutine restarts CG algorithm from new point. All optimization parameters are left unchanged. This function allows to solve multiple

NLEQ solver results Buffered implementation of NLEQResults(), which uses pre-allocated buffer to store X[]. If buffer size is too small, it resi

This function sets stopping conditions for the nonlinear solver INPUT PARAMETERS: State - structure which stores algorithm state EpsF

This function sets maximum step length INPUT PARAMETERS: State - structure which stores algorithm state StpMax - maximum step length,

This function turns on/off reporting. INPUT PARAMETERS: State - structure which stores algorithm state NeedXRep- whether iteration repo

Internal initialization subroutine *************************************************************************/

This function provides reverse communication interface Reverse communication interface is not documented or recommended to use. See below for function

* Find all the neighbors to \a query_point[0:dim-1] within a maximum radius. * The output is given as a vector of pairs, of which the first elemen

Returns random normal number using low-quality system-provided generator -- ALGLIB -- Copyright 20.03.2009 by Bochkanov Sergey ***************

Remove a point from the set (Lazy Deletion) */

Fast kernel -- ALGLIB routine -- 19.01.2010 Bochkanov Sergey *************************************************************************/

RMatrixGEMM kernel, basecase code for RMatrixGEMM, specialized for sitation with OpTypeA=0 and OpTypeB=0. Additional info: * this function requires t

RMatrixGEMM kernel, basecase code for RMatrixGEMM, specialized for sitation with OpTypeA=0 and OpTypeB=1. Additional info: * this function requires t

RMatrixGEMM kernel, basecase code for RMatrixGEMM, specialized for sitation with OpTypeA=1 and OpTypeB=0. Additional info: * this function requires t

RMatrixGEMM kernel, basecase code for RMatrixGEMM, specialized for sitation with OpTypeA=1 and OpTypeB=1. Additional info: * this function requires t

Dense solver. Similar to RMatrixLUSolve() but solves task with multiple right parts (where b and x are NxM matrices). This is "robust-but-slow

Dense solver. Similar to RMatrixMixedSolve() but solves task with multiple right parts (where b and x are NxM matrices). Algorithm features: * aut

If Cols(X)<N or Rows(X)<M, resizes X -- ALGLIB -- Copyright 20.03.2009 by Bochkanov Sergey ***************************************************

Dense solver. Similar to RMatrixSolve() but solves task with multiple right parts (where b and x are NxM matrices). This is "slow-but-robust" versi

Resizes X and: * preserves old contents of X * fills new elements by zeros -- ALGLIB -- Copyright 20.03.2009 by Bochkanov Sergey *************

Safe sqrt(x^2+y^2) -- ALGLIB -- Copyright by Bochkanov Sergey *************************************************************************/

Obsolete 1-based subroutine. See RMatrixTRSafeSolve for 0-based replacement. *************************************************************************

Stores the index in a binary file. * IMPORTANT NOTE: The set of data points is NOT stored in the file, so when * loading the index object it m

Serialization: complex value *************************************************************************/

This function returns minimum cost of task which is feasible for multithreaded processing. It returns real number in order to avoid overflow problems.

This function returns minimum cost of task which is feasible for spawn (given that multithreading is active). It returns real number in order to avoi

Dense solver for A*X=B with N*N symmetric positive definite matrix A given by its Cholesky decomposition, and N*M vectors X and B. It is "slow-but-

Dense solver for A*X=B with N*N symmetric positive definite matrix A, and N*M vectors X and B. It is "slow-but-feature-rich" version of the solver.

Spearman's rank correlation coefficient Input parameters: X - sample 1 (array indexes: [0..N-1]) Y - sample 2 (array indexes:

Gets the number of successful tests.

Heap operations: adds element to the heap PARAMETERS: A - heap itself, must be at least array[0..N] B - array of integer tags

This function sorts array of real keys by ascending. Its results are: * sorted array A * permutation tables P1, P2 Algorithm outputs permutation tab