# doc-cache created by Octave 8.4.0
# name: cache
# type: cell
# rows: 3
# columns: 15
# name: <cell-element>
# type: sq_string
# elements: 1
# length: 13
stk_halfpintl


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1060
 STK_HALFPINTL computes an intersection of lower half-planes

 CALL: [A, B, Z] = stk_halfpintl (A, B)

    computes the intersection of the lower half-planes defined by the vector
    of slopes A and the vector of intercepts B.  The output vectors A and B
    contain the slopes and intercept of the lines that actually contribute to
    the boundary of the intersection, sorted in such a way that the k^th
    element corresponds to the k^th piece of the piecewise affine boundary.
    The output Z contains the intersection points (shorter by one element).

 ALGORITHM

    The algorithm implemented in this function is described in [1, 2].

 REFERENCE

   [1] P. I. Frazier, W. B. Powell, and S. Dayanik.  The Knowledge-Gradient
       Policy for Correlated Normal Beliefs.  INFORMS Journal on Computing
       21(4):599-613, 2009.

   [2] W. Scott, P. I. Frazier and W. B. Powell.  The correlated knowledge
       gradient for simulation optimization of continuous parameters using
       Gaussian process regression.  SIAM J. Optim, 21(3):996-1026, 2011.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 60
 STK_HALFPINTL computes an intersection of lower half-planes



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4515
 STK_SAMPCRIT_AKG_EVAL computes the Approximate KG criterion

 CALL: AKG = stk_sampcrit_akg_eval (ZC_MEAN, ZC_STD, ZR_MEAN, ZR_STD, ZCR_COV)

    computes the value AKG of the Approximate KG criterion for a set of
    candidates points, with respect to a certain reference grid.  The
    predictive distributions of the objective function (to be minimized) at
    the candidates and reference points is assumed to be jointly Gaussian,
    with mean ZC_MEAN and standard deviation ZC_STD for the candidate points,
    mean ZR_MEAN and satandard deviation ZR_STD on the reference points, and
    covariance matrix ZCR_COV between the candidate and reference points.
    The input argument must have the following sizes:

       * ZC_MEAN    M x 1,
       * ZC_STD     M x 1,
       * ZR_MEAN    L x 1,
       * ZR_STD     L x 1,
       * ZCR_COV    M x L,

    where M is the number of candidate points and L the number of reference
    points.  The output has size M x 1.

 NOTE ABOUT THE "KNOWLEDGE GRADIENT" CRITERION

    The "Knowlegde Gradient" (KG) criterion is the one-step look-ahead (a.k.a
    myopic) sampling criterion associated to the problem of estimating the
    minimizer of the objective function under the L^1 loss (equivalently,
    under the linear loss/utility).

    This sampling strategy was proposed for the first time in the work of
    Mockus and co-authors in the 70's (see [1] and refs therein), for the case
    of noiseless evaluations, but only applied to particular Brownian-like
    processes for which the minimum of the posterior mean coincides with the
    best evaluations so far (in which case the KG criterion coincides with the
    EI criterion introduced later by Jones et al [2]).

    It was later discussed for the case of a finite space with independent
    Gaussian priors first by Gupta and Miescke [3] and then by Frazier et al
    [4] who named it "knowledge gradient".  It was extended to the case of
    correlated priors by Frazier et al [5].

 NOTE ABOUT THE REFERENCE SET

    For the case of continuous input spaces, there is no exact expression of
    the KG criterion.  The approximate KG criterion proposed in this function
    is an approximation of the KG criterion where the continuous 'min' in the
    expression of the criterion at the i^th candidate point are replaced by
    discrete mins over some reference grid *augmented* with the i^th candidate
    point.

    This type of approximation has been proposed by Scott et al [6] under the
    name "knowledge gradient for continuous parameters" (KGCP).  In [6], the
    reference grid is composed of the current set of evaluation points.  The
    implementation proposed in STK leaves this choice to the user.

    Note that, with the reference grid proposed in [6], the complexity of one
    evaluation of the AKG (KGCP) criterion increases as O(N log N), where N
    denotes the number of evaluation points.

 NOTE ABOUT THE NOISELESS CASE

    Simplified formulas are available for the noiseless case (see [7]) but not
    currenly implemented in STK.

 REFERENCES

   [1] 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, eds,
       Towards Global Optimization, 2:117-129, North Holland NY, 1978.

   [2] 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.

   [3] S. Gupta and K. Miescke,  Bayesian look ahead one-stage sampling
       allocations for selection of the best population,  J. Statist. Plann.
       Inference, 54:229-244, 1996.

   [4] P. I. Frazier, W. B. Powell, S. Dayanik,  A knowledge gradient policy
       for sequential information collection,  SIAM J. Control Optim.,
       47(5):2410-2439, 2008.

   [5] P. I. Frazier, W. B. Powell, and S. Dayanik.  The Knowledge-Gradient
       Policy for Correlated Normal Beliefs.  INFORMS Journal on Computing
       21(4):599-613, 2009.

   [6] W. Scott, P. I. Frazier and W. B. Powell.  The correlated knowledge
       gradient for simulation optimization of continuous parameters using
       Gaussian process regression.  SIAM J. Optim, 21(3):996-1026, 2011.

   [7] J. van der Herten, I. Couckuyt, D. Deschrijver, T. Dhaene,  Fast
       Calculation of the Knowledge Gradient for Optimization of Deterministic
       Engineering Simulations,  arXiv preprint arXiv:1608.04550

 See also: STK_SAMPCRIT_EI_EVAL



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 60
 STK_SAMPCRIT_AKG_EVAL computes the Approximate KG criterion



# 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: 1601
 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., & Santner, T. (2016).  Multiobjective optimization of
       expensive-to-evaluate deterministic computer simulator models.
       Computational Statistics & Data Analysis, 94, 250-264,
       DOI: 10.1016/j.csda.2015.08.011.

 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: 25
stk_sampling_nesteddesign


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1622
 STK_SAMPLING_NESTEDDESIGN generates a nested design

 CALL: X = stk_sampling_nesteddesign (N, DIM)

   generates a nested design with length(N) levels, with N(k) points at
   the k-th level. X has sum(N) rows and (DIM + 1) columns, the last
   column begin the levels.
   A design is nested when all points at the (k+1)-th level are also at
   the k-th level.

 CALL: X = stk_sampling_nesteddesign (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.
   Default value for BOX: [0; 1]^DIM.
   If BOX is provided, DIM = size(BOX, 2).
   Warning: size(X, 2) == (DIM + 1)

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

   allows to change the number of independent random LHS that are used,
   when generating a maximin LHS.
   Default value for NITER: 1000. 

 CALL: X = stk_sampling_nesteddesign (N, DIM, BOX, NITER, LEVELS)

   does the same thing, but the levels are indexed by the vector LEVELS.
   The length of LEVELS must be greater or equal than the length of N.
   Default value for levels: 1:length(N).

 EXAMPLE

   n = [30, 14, 5, 2]; dim = 2;
   bnd = stk_hrect([-5, 1; 7, 2]);
   levels = [100; 50; 33; 25; 20;];
   x = stk_sampling_nesteddesign(n, dim, bnd, [], levels);

 REFERENCE

   [1] Loic Le Gratiet, "Multi-fidelity Gaussian process regression for
       computer experiments", PhD thesis, Universite Paris-Diderot -
       Paris VII, 2013.

 See also: stk_sampling_nestedlhs, stk_sampling_maximinlhs



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 52
 STK_SAMPLING_NESTEDDESIGN generates a nested design



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1794
 STK_SAMPLING_NESTEDLHS builds a Nested Latin Hypercube Sampling (NLHS)

 CALL: X = stk_sampling_nestedlhs (N, DIM)

   builds a NLHS, with length(N) levels, N(k) points at the k-th level,
   and a dimension DIM. X has sum(N) rows and (DIM + 1) columns, the last
   column begin the levels.
   A design is nested when all points observed at the (k+1)-th level are
   also observed at the k-th level.
   A nested design is a Latin Hypercube Sampling (LHS), if every
   sub-design corresponding to a specified level is a LHS.
   Remark: N(k+1) must divide N(k).

 CALL: X = stk_sampling_nestedlhs (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.
   Default value for BOX: [0; 1]^DIM.
   If BOX is provided, DIM = size(BOX, 2).
   Warning: size(X, 2) == (DIM + 1)

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

   allows to change the number of independent random LHS that are used at
   each level to complete the design.
   Default value for NITER: 1000.
   Put NITER to 1 to generate a random NLHS.

 CALL: X = stk_sampling_nestedlhs (N, DIM, BOX, NITER, LEVELS)

   does the same thing, but the levels are indexed by the vector LEVELS.
   The length of LEVELS must be greater or equal than the length of N.
   Default value for LEVELS: 1:length(N).

 EXAMPLE

   n = [48, 12, 6, 2]; dim = 2;
   bnd = stk_hrect([-5, 1; 7, 2]);
   levels = [100; 50; 33; 25; 20];
   x = stk_sampling_nestedlhs(n, dim, bnd, [], levels);

 REFERENCE

   [1] Peter Z. G. Qian, "Nested latin hypercube designs", Biometrika,
       96(4):957-970, 2009.

 See also: stk_sampling_nesteddesign, stk_sampling_randomlhs



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 71
 STK_SAMPLING_NESTEDLHS builds a Nested Latin Hypercube Sampling (NLHS)



# 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: 1990
 STK_SAMPLING_SOBOL generates points from a Sobol sequence

 CALL: X = stk_sampling_sobol (N, D)

    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, 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_sobol (N, D, BOX, DO_SKIP)

    skips an initial segment of the Sobol sequence  if DO_SKIP is true.  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.  If
    DO_SKIP is false, the beginning of the sequence is returns, as in the
    previous cases (in other words, DO_SKIP = false is the default).

 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





