# doc-cache created by Octave 6.4.0
# name: cache
# type: cell
# rows: 3
# columns: 7
# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
stk_is_lhs


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 666
 STK_IS_LHS tests if a given set of points forms a LHS

 CALL: OK = stk_is_lhs (X, N, DIM, BOX)

    tests if X is a Latin Hypercube Sample (LHS) of size N, over the hyper-
    rectangle BOX of dimension DIM. The result OK is true if X is a LHS and
    false otherwise.

 CALL: OK = stk_is_lhs (X, N, DIM)

    tests if X is a Latin Hypercube Sample (LHS) of size N, over the hyper-
    rectangle [0; 1]^DIM.

 CALL: OK = stk_is_lhs (X)

    tests if X is a Latin Hypercube Sample (LHS). Both the size N and the
    number DIM of factors are inferred from X.

 All three calling syntaxes accept both matrix-type inputs or data structures
 (with an 'a' field) for X.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 54
 STK_IS_LHS tests if a given set of points forms a LHS



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 18
stk_isequal_tolabs


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 775
 STK_ISEQUAL_TOLABS tests approximate equality of two matrices or structures.

 CALL: BOOL = stk_isequal_tolabs(A, B, TOLABS)

   returns true if A and B are numeric arrays of the same size, such that for
   any pair (a, b) of corresponding entries,

      abs(b - a) <= TOLABS.                                                (1)

   For numeric array, the function returns false is either

    * the array don't have identical sizes, or
    * the array have identical sizes but (1) doesn't hold.

   If A and B are structures with the same list of fieldnames, the function
   works recursively on the fields, and returns true iff all the fields are
   approximately equal.

 CALL: b = stk_isequal_tolabs(a, b)

   uses the default value 1e-8 for TOLABS.

 See also isequal.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 77
 STK_ISEQUAL_TOLABS tests approximate equality of two matrices or structures.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 18
stk_isequal_tolrel


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 837
 STK_ISEQUAL_TOLREL tests approximate equality of two matrices or structures.

 CALL: BOOL = stk_isequal_tolrel(A, B, TOLREL)

   returns true if A and B are numeric arrays of the same size, such that for
   any pair (a, b) of corresponding entries,

      abs(b - a) <= TOLABS,                                                (1)

   where

      TOLABS = max(abs(A(:)), abs(B(:))) * TOLREL.

   For numeric array, the function returns false is either

    * the array don't have identical sizes, or
    * the array have identical sizes but (1) doesn't hold.

   If A and B are structures with the same list of fieldnames, the function
   works recursively on the fields, and returns true iff all the fields are
   approximately equal.

 CALL: b = stk_isequal_tolrel(a, b)

   uses the default value 1e-8 for TOLREL.

 See also isequal.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 77
 STK_ISEQUAL_TOLREL tests approximate equality of two matrices or structures.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 12
stk_runtests


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 76
 STK_RUNTESTS runs all tests in a given directory (or in STK's searchpath).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 76
 STK_RUNTESTS runs all tests in a given directory (or in STK's searchpath).




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 8
stk_test


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2137
 STK_TEST performs tests for a given M-file.

 FIXME (ticket #86): Convert help text below to plain text

 -*- texinfo -*-
 @deftypefn  {Command} {} test @var{name}
 @deftypefnx {Command} {} test @var{name} quiet|normal|verbose
 @deftypefnx {Function File} {} test ('@var{name}', 'quiet|normal|verbose', @var{fid})
 @deftypefnx {Function File} {} test ([], 'explain', @var{fid})
 @deftypefnx {Function File} {@var{success} =} test (@dots{})
 @deftypefnx {Function File} {[@var{n}, @var{max}] =} test (@dots{})
 @deftypefnx {Function File} {[@var{code}, @var{idx}] =} test ('@var{name}', 'grabdemo')

 Perform tests from the first file in the loadpath matching @var{name}.
 @code{test} can be called as a command or as a function.  Called with
 a single argument @var{name}, the tests are run interactively and stop
 after the first error is encountered.

 With a second argument the tests which are performed and the amount of
 output is selected.

 @table @asis
 @item 'quiet'
  Don't report all the tests as they happen, just the errors.

 @item 'normal'
 Report all tests as they happen, but don't do tests which require
 user interaction.

 @item 'verbose'
 Do tests which require user interaction.
 @end table

 The argument @var{fid} can be used to allow batch processing.  Errors
 can be written to the already open file defined by @var{fid}, and
 hopefully when Octave crashes this file will tell you what was happening
 when it did.  You can use @code{stdout} if you want to see the results as
 they happen.  You can also give a file name rather than an @var{fid}, in
 which case the contents of the file will be replaced with the log from
 the current test.

 Called with a single output argument @var{success}, @code{test} returns
 true if all of the tests were successful.  Called with two output arguments
 @var{n} and @var{max}, the number of successful tests and the total number
 of tests in the file @var{name} are returned.

 If the second argument is 'explain', then @var{name} is ignored and an
 explanation of the line markers used is written to the file @var{fid}.
 @seealso{assert, error, example}
 @end deftypefn



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 44
 STK_TEST performs tests for a given M-file.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 14
stk_test_class


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 62
 STK_TEST_CLASS is a unit test that any STK class should pass



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 62
 STK_TEST_CLASS is a unit test that any STK class should pass




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 19
stk_test_dfbinaryop


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 25
 STK_TEST_DFBINARYOP ...



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 25
 STK_TEST_DFBINARYOP ...






