# doc-cache created by Octave 4.2.1
# name: cache
# type: cell
# rows: 3
# columns: 11
# name: <cell-element>
# type: sq_string
# elements: 1
# length: 22
stk_sampcrit_ehvi_eval


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1356
 STK_SAMPCRIT_EHVI_EVAL computes the EHVI criterion

 CALL: EHVI = stk_sampcrit_ehvi_eval (ZP_MEAN, ZP_STD, ZI, ZR)

    computes the value EHVI of the Expected HyperVolume Improvement (EHVI) for
    a multi-objective minimization problem, with respect to the observed values
    ZI and the reference point ZR, assuming Gaussian predictive distributions
    with means ZP_MEAN and standard deviations ZP_STD.  The input arguments
    must have the following sizes:

       * ZP_MEAN    M x P,
       * ZP_STD     M x P,
       * ZI         N x P,
       * ZR         1 x P,

    where M is the number of points where the EHVI must be computed, P the
    number of objective functions to be minimized, and N the current number of
    Pareto optimal solutions.  The output has size M x 1.

 NOTE

 1) The result depends only on the non-dominated rows of ZI.

 2) Multi-objective maximization problems, or mixed minimization/maximization
    problems, can be handled by changing the sign of the corresponding
    components of ZP_MEAN and ZI.

 REFERENCES

  [1] Emmerich, M. T., Giannakoglou, K. C., & Naujoks, B.  Single- and
      multiobjective evolutionary optimization assisted by gaussian random
      field metamodels. IEEE Transactions on Evolutionary Computation,
      10(4), 421-439, 2006.

 See also: stk_sampcrit_emmi_eval, stk_sampcrit_ei_eval



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 51
 STK_SAMPCRIT_EHVI_EVAL computes the EHVI criterion



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1595
 STK_SAMPCRIT_EI_EVAL computes the EI criterion

 CALL: EI = stk_sampcrit_ei_eval (ZP_MEAN, ZP_STD, ZI)

    computes the value EI of the Expected Improvement (EI) criterion for a
    minimization problem, with respect to the observed values ZI, assuming
    Gaussian predictive distributions with means ZP_MEAN and standard
    deviations ZP_STD.  The input argument must have the following sizes:

       * ZP_MEAN    M x 1,
       * ZP_STD     M x 1,
       * ZI         N x 1,

    where M is the number of points where the EI must be computed, and N the
    number of observations.  The output has size M x 1.

 REMARK

    Since the EI is computed for a minimization problem, the result depends
    on the minimum of the obervations only, not on the entire set of observed
    values.  The above call is thus equivalent to

       EI = stk_sampcrit_ei_eval (ZP_MEAN, ZP_STD, min (ZI))

 NOTE

    This function was added in STK 2.4.1, and will in the future completely
    replace stk_distrib_normal_ei.  Note that, unlike the present function,
    stk_distrib_normal_ei returns as a default the EI for a *maximization*
    problem.

 REFERENCES

   [1] D. R. Jones, M. Schonlau and William J. Welch. Efficient global
       optimization of expensive black-box functions.  Journal of Global
       Optimization, 13(4):455-492, 1998.

   [2] J. Mockus, V. Tiesis and A. Zilinskas. The application of Bayesian
       methods for seeking the extremum. In L.C.W. Dixon and G.P. Szego,
       editors, Towards Global Optimization, volume 2, pages 117-129, North
       Holland, New York, 1978.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 47
 STK_SAMPCRIT_EI_EVAL computes the EI criterion



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1583
 STK_SAMPCRIT_EMMI_EVAL computes the EMMI criterion

 CALL: EMMI = stk_sampcrit_emmi_eval (ZP_MEAN, ZP_STD, ZI)

    computes the value EMMI of the Expected MaxiMin Improvement (EMMI) for a
    multi-objective minimization problem, with respect to the observed values
    ZI, assuming Gaussian predictive distributions with means ZP_MEAN and
    standard deviations ZP_STD.  The value of the criterion is computed
    approximately, using Monte Carlo simulations.  The input arguments must
    have the following sizes:

       * ZP_MEAN    M x P,
       * ZP_STD     M x P,
       * ZI         N x P,

    where M is the number of points where the EMMI must be computed, P the
    number of objective functions to be minimized, and N the current number of
    Pareto optimal solutions.  The output has size M x 1.

 CALL: EMMI = stk_sampcrit_emmi_eval (ZP_MEAN, ZP_STD, ZI, NSIMU)

    allows to change the number of simulations NSIMU used in the calculation of
    the criterion.

 NOTE

 1) The result depends only on the non-dominated rows of ZI.

 2) Multi-objective maximization problems, or mixed minimization/maximization
    problems, can be handled by changing the sign of the corresponding
    components of ZP_MEAN and ZI.

 3) Objective functions should be normalized for better performances.

 REFERENCES

   [1] Svenson J.D. and Santner T.J. Multiobjective optimization of
       expensive black-box functions via expected maximin improvement.
       Technical report, Tech. rep., 43210, Ohio University, Columbus,
       Ohio, 2010

 See also: stk_sampcrit_ehvi_eval



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 51
 STK_SAMPCRIT_EMMI_EVAL computes the EMMI criterion



# 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: 18
stk_sampling_sobol


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1572
 STK_SAMPLING_SOBOL generates points from a Sobol sequence

 CALL: X = stk_sampling_sobol (N, D)
 CALL: X = stk_sampling_sobol (N, D, FALSE)

    computes the first N terms of a D-dimensional Sobol sequence (with
    N < 2^32 and D <= 1111).  The sequence is generated using the algorithm
    of Bratley and Fox [1], as modified by Joe and Kuo [3].

 CALL: X = stk_sampling_sobol (N, D, TRUE)

    skips an initial segment of the sequence.  More precisely, according to
    the recommendation of [2] and [3], a number of points equal to the largest
    power of 2 smaller than n is skipped.

 NOTE: Implementation

    The C implementation under the hood is due to Steven G. Johnson, and
    was borrowed from the NLopt toolbox [4] (version 2.4.2).

 REFERENCE

    [1] Paul Bratley and Bennett L. Fox, "Algorithm 659: Implementing Sobol's
        quasirandom sequence generator",  ACM Transactions on Mathematical
        Software, 14(1):88-100, 1988.

    [2] Peter Acworth, Mark Broadie and Paul Glasserman, "A Comparison of Some
        Monte Carlo and Quasi Monte Carlo Techniques for Option Pricing", in
        Monte Carlo and Quasi-Monte Carlo Methods 1996, Lecture Notes in
        Statistics 27:1-18, Springer, 1998.

    [3] Stephen Joe and Frances Y. Kuo, "Remark on Algorithm 659: Implementing
        Sobol's Quasirandom Sequence Generator', ACM Transactions on
        Mathematical Software, 29(1):49-57, 2003.

    [4] Steven G. Johnson, The NLopt nonlinear-optimization package,
        http://ab-initio.mit.edu/nlopt.

 SEE ALSO: stk_sampling_halton_rr2



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 58
 STK_SAMPLING_SOBOL generates points from a Sobol sequence



# 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





