# doc-cache created by Octave 4.0.0
# name: cache
# type: cell
# rows: 3
# columns: 7
# name: <cell-element>
# type: sq_string
# elements: 1
# length: 23
stk_sampling_halton_rr2


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 468
 STK_SAMPLING_HALTON_RR2 generates points from the Halton/RR2 sequence

 CALL: X = stk_sampling_halton_rr2 (N, D)

    computes the first N terms of the D-dimensional RR2-scrambled Halton
    sequence.

 REFERENCE

    Ladislav Kocis and William J. Whiten, "Computational investigations of low
    discrepancy sequences", ACM Transactions on Mathematical Software,
    23(2):266-294, 1997.  http://dx.doi.org/10.1145/264029.264064

 SEE ALSO: __stk_sampling_vdc_rr2__



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 70
 STK_SAMPLING_HALTON_RR2 generates points from the Halton/RR2 sequence



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 23
stk_sampling_maximinlhs


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 799
 STK_SAMPLING_MAXIMINLHS generates a "maximin" LHS design

 CALL: X = stk_sampling_maximinlhs (N, DIM)

   generates a "maximin" Latin Hypercube Sample of size N in the
   DIM-dimensional hypercube [0; 1]^DIM. More precisely, NITER = 1000
   independent random LHS are generated, and the one with the biggest
   separation distance is returned.

 CALL: X = stk_sampling_maximinlhs (N, DIM, BOX)

   does the same thing in the DIM-dimensional hyperrectangle specified by the
   argument BOX, which is a 2 x DIM matrix where BOX(1, j) and BOX(2, j) are
   the lower- and upper-bound of the interval on the j^th coordinate.

 CALL: X = stk_sampling_maximinlhs (N, DIM, BOX, NITER)

   allows to change the number of independent random LHS that are used.

 See also: stk_mindist, stk_sampling_randomlhs



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 57
 STK_SAMPLING_MAXIMINLHS generates a "maximin" LHS design



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 17
stk_sampling_olhs


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1665
 STK_SAMPLING_OLHS generates a random Orthogonal Latin Hypercube (OLH) sample

 CALL: X = stk_sampling_olhs (N)

    generates a random Orthogonal Latin Hypercube (OLH) sample X, using the
    construction of Ye (1998). The algorithm only works for sample sizes N
    of the form 2^(R+1)+1, with R >= 1. Trying to generate an OLHS with a
    value of N that is not of this form generates an error. The number of
    factors is D = 2*R, and the OLHS is defined on [-1; 1]^D.

 CALL: X = stk_sampling_olhs (N, D)

    does exactly the same thing, provided that there exists an integer R
    such that N = 2^(R+1)+1 and D = 2*R (or D is empty).

 CALL: X = stk_sampling_olhs (N, D, BOX)

    generates an OLHS on BOX. Again, D can be empty since the number of
    factors can be deduced from N.

 CALL: X = stk_sampling_olhs (N, D, BOX, PERMUT)

    uses a given permutation PERMUT, instead of a random permutation, to
    initialize the construction of Ye (1998). As a result, the generated
    OLHS is not random anymore. PERMUT must be a permutation of 1:2^R. If
    BOX is empty, then the default domain [-1, 1]^D is used.

 NOTE: orthogonality

    The samples generated by this functions are only orthogonal, stricty-
    speaking, if BOX is a symmetric domain (e.g., [-1, 1] ^ D). Otherwise,
    the generated samples should be called "uncorrelated".

 REFERENCE

    Kenny Q. Ye, "Orthogonal Column Latin Hypercubes and Their
    Application in Computer Experiments", Journal of the American
    Statistical Association, 93(444), 1430-1439, 1998.
    http://dx.doi.org/10.1080/01621459.1998.10473803

 See also: stk_sampling_randomlhs, stk_sampling_maximinlhs



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 77
 STK_SAMPLING_OLHS generates a random Orthogonal Latin Hypercube (OLH) sample



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 22
stk_sampling_randomlhs


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 571
 STK_SAMPLING_RANDOMLHS generates a random LHS design

 CALL: X = stk_sampling_randomlhs (N, DIM)

   generates a random Latin Hypercube Sample of size N in the DIM-dimensional
   hypercube [0; 1]^DIM.

 CALL: X = stk_sampling_randomlhs (N, DIM, BOX)

   generates a random Latin Hypercube Sample of size N in the DIM-dimensional
   hyperrectangle specified by the argument BOX, which is a 2 x DIM matrix
   where BOX(1, j) and BOX(2, j) are the lower- and upper-bound of the interval
   on the j^th coordinate.

 See also: stk_sampling_maximinlhs, stk_sampling_randunif



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 53
 STK_SAMPLING_RANDOMLHS generates a random LHS design



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 21
stk_sampling_randunif


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 489
 STK_SAMPLING_RANDUNIF generates uniformly distributed points

 CALL: X = stk_sampling_randunif (N, DIM)

   generates N points, independent and uniformly distributed in the
   DIM-dimensional hypercube [0; 1]^DIM.

 CALL: X = stk_sampling_randunif (N, DIM, BOX)

   does the same thing in the DIM-dimensional hyperrectangle specified by the
   argument BOX, which is a 2 x DIM matrix where BOX(1, j) and BOX(2, j) are
   the lower- and upper-bound of the interval on the j^th coordinate.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 61
 STK_SAMPLING_RANDUNIF generates uniformly distributed points



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 24
stk_sampling_regulargrid


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 686
 STK_SAMPLING_REGULARGRID builds a regular grid

 CALL: X = stk_sampling_regulargrid (N, DIM)

   builds a regular grid in the DIM-dimensional hypercube [0; 1]^DIM. If N is
   an integer, a grid of size N is built; in this case, acceptable sizes are
   such that N^(1/DIM) is an integer. If N is a vector of length N, a grid of
   size prod(N) is built, with N(j) points on coordinate j.

 CALL: X = stk_sampling_regulargrid (N, DIM, BOX)

   does the same thing in the DIM-dimensional hyperrectangle specified by the
   argument BOX, which is a 2 x DIM matrix where BOX(1, j) and BOX(2, j) are
   the lower- and upper-bound of the interval on the j^th coordinate.

 See also: linspace



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 47
 STK_SAMPLING_REGULARGRID builds a regular grid



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 20
stk_sampling_vdc_rr2


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 478
 STK_SAMPLING_VDC_RR2 generates points from the "RR2" van der Corput sequence

 CALL: X = __stk_sampling_vdc_rr2__(N, J)

    computes the first N terms of the j^th RR2-scrambled van der Corput
    sequence.

 REFERENCE 

    Ladislav Kocis and William J. Whiten, "Computational investigations of low
    discrepancy sequences", ACM Transactions on Mathematical Software, 
    23(2):266-294, 1997.
    http://dx.doi.org/10.1145/264029.264064

 SEE ALSO: stk_sampling_halton_rr2



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 77
 STK_SAMPLING_VDC_RR2 generates points from the "RR2" van der Corput sequence





