# doc-cache created by Octave 8.4.0
# name: cache
# type: cell
# rows: 3
# columns: 8
# name: <cell-element>
# type: sq_string
# elements: 1
# length: 16
stk_conditioning


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1909
 STK_CONDITIONING produces conditioned sample paths

 CALL: ZSIMC = stk_conditioning (LAMBDA, ZI, ZSIM, XI_IND)

    produces conditioned sample paths ZSMIC from the unconditioned sample paths
    ZSIM, using the matrix of kriging weights LAMBDA. Conditioning is done with
    respect to a finite number NI of observations, located at the indices given
    in XI_IND (vector of length NI), with corresponding noiseless observed
    values ZI.

    The matrix LAMBDA must be of size NI x N, where N is the number of
    evaluation points for the sample paths; such a matrix is typically provided
    by stk_predict().

    Both ZSIM and ZSIMC have size N x NB_PATHS, where NB_PATH is the number
    sample paths to be dealt with. ZI is a column of length NI.

 CALL: ZSIMC = stk_conditioning (LAMBDA, ZI, ZSIM)

    assumes that the oberved values ZI correspond to the first NI evaluation
    points.

 CALL: ZSIMC = stk_conditioning (LAMBDA, ZI, ZSIM, XI_IND, NOISE_SIM)

    produces conditioned sample paths ZSMIC from the unconditioned sample paths
    ZSIM, using the matrix of kriging weights LAMBDA. Conditioning is done with
    respect to a finite number NI of observations, located at the indices given
    in XI_IND (vector of length NI), with corresponding noisy observed values
    ZI, using a NI x N matrix NOISE_SIM of simulated noise values.

 NOTE: Conditioning by kriging

    stk_conditioning uses the technique called "conditioning by kriging"
    (see, e.g., Chiles and Delfiner, Geostatistics: Modeling Spatial
    Uncertainty, Wiley, 1999)

 NOTE: Output type

    The output argument ZSIMC will be an stk_dataframe if either LAMBDA or ZSIM
    are stk_dataframe. In case of conflicting row names (coming from
    ZSIM.rownames on the one hand and LAMBDA.colnames on the other hand),
    ZSIMC.rownames is {}.

 EXAMPLE: stk_example_kb05

 See also stk_generate_samplepaths, stk_predict



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 51
 STK_CONDITIONING produces conditioned sample paths



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1859
 STK_GENERATE_SAMPLEPATHS generates sample paths of a Gaussian process

 CALL: ZSIM = stk_generate_samplepaths (MODEL, XT)

    generates one sample path ZSIM of the Gaussian process MODEL discretized on
    the evaluation points XT.  The input argument XT can be either a numerical
    matrix or a dataframe.  The output argument ZSIM has the same number of
    rows as XT.  More precisely, on a factor space of dimension DIM,

     * XT must have size NS x DIM,
     * ZSIM will have size NS x 1,

    where NS is the number of simulation points.

    Note that, in the case where MODEL is a model for noisy observations, this
    function simulates sample paths of the underlying (latent) Gaussian
    process, i.e., noiseless observations.

 CALL: ZSIM = stk_generate_samplepaths (MODEL, XT, NB_PATHS)

    generates NB_PATHS sample paths at once.  In this case, the output argument
    ZSIM has size NS x NB_PATHS.

 CALL: ZSIM = stk_generate_samplepaths (MODEL, XI, ZI, XT)

    generates one sample path ZSIM, using the kriging model MODEL and the
    evaluation points XT, conditional on the evaluations (XI, ZI).

 CALL: ZSIM = stk_generate_samplepaths (MODEL, XI, ZI, XT, NB_PATHS)

    generates NB_PATHS conditional sample paths at once.

 NOTE: Sample size limitation

    This function generates (discretized) sample paths using a Cholesky
    factorization of the covariance matrix, and is therefore restricted to
    moderate values of the number of evaluation points.

 NOTE: Output type

    The output argument ZSIM is a plain (double precision) numerical array,
    even if XT is a data frame.  Row names can be added afterwards as follows:

       ZSIM = stk_generate_samplepaths (MODEL, XT);
       ZSIM = stk_dataframe (ZSIM, {}, XT.rownames);

 EXAMPLES: see stk_example_kb05, stk_example_kb07

 See also stk_conditioning, stk_cholcov



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 70
 STK_GENERATE_SAMPLEPATHS generates sample paths of a Gaussian process



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 10
stk_plot1d


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 792
 STK_PLOT1D is a convenient plot function for 1D kriging predictions

 CALL: stk_plot1d (XI, ZI, XT, ZT, ZP)

    plots the evaluation points (XI, ZI), the "true function" with values
    ZT on the grid XT, and a representation of the prediction ZP on the
    same grid XT: the kriging prediction (posterior mean) surrounded by a
    shaded area corresponding to 95% pointwise confidence intervals.

    It is possible to omit plotting either the observations (XI, ZI) or
    the true function ZT by providing empty matrices.

 CALL: stk_plot1d (XI, ZI, XT, ZT, ZP, ZSIM)

    also plots a set ZSIM of samplepaths.

 CALL: stk_plot1d (H_AXES, ...)

    plots into existing axes with axis handle H_AXES.

 CALL: H_PLOT = stk_plot1d (...)

   returns the handles of the drawing in a structure.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 68
 STK_PLOT1D is a convenient plot function for 1D kriging predictions



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 225
 STK_PLOT_HISTNORMRES plots an histogram for normalized residuals

 CALL: H = stk_plot_histnormres (NORM_RES, ...)

 CALL: H = stk_plot_histnormres (H_AXES, NORM_RES, ...)

 See also stk_predict_leaveoneout, stk_example_kb10



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 65
 STK_PLOT_HISTNORMRES plots an histogram for normalized residuals



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 224
 STK_PLOT_PREDVSOBS plots predictions against observations

 CALL: H = stk_plot_predvsobs (Z_OBS, Z_PRED, ...)

 CALL: H = stk_plot_predvsobs (H_AXES, Z_OBS, Z_PRED, ...)

 See also stk_predict_leaveoneout, stk_example_kb10



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 58
 STK_PLOT_PREDVSOBS plots predictions against observations



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1335
 STK_PLOT_PROBDOM2D represents the uncertainty about a 2D Pareto

 CALL: stk_plot_probdom2d (MODEL1, MODEL2, BOX)

    represents the uncertainty about the 2D Pareto front associated with the
    minimization of models MODEL1 and MODEL2 over the domain BOX.

    Use prior model structures (see stk_model) to represent prior uncertainty.

    Use @stk_model_gpposterior objects to represent posterior uncertainty.

 EXPERIMENTAL FUNCTION WARNING

    This function is currently considered experimental.  Because of the very
    basic method used to choose the simulation points (uniform IID sampling),
    the plots produced by this function are very unreliable representations
    on the residual uncertainty on the Pareto front (except perhaps on low-
    dimensional problems of moderate difficulty).

    STK users that wish to experiment with it are welcome to do so, but should
    be aware of this limitation.  We invite them to direct any questions,
    remarks or comments about this experimental class to the STK mailing list.

 REFERENCE

  [1] Michael Binois, David Ginsbourger and Olivier Roustant,  Quantifying
      uncertainty on Pareto fronts with Gaussian Process conditional simu-
      lations,  European J. of Operational Research, 2043(2):386-394, 2015.

 See also: stk_example_misc04, stk_model, stk_gpposterior



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 64
 STK_PLOT_PROBDOM2D represents the uncertainty about a 2D Pareto



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 13
stk_pmisclass


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 924
 STK_PMISCLASS computes the (expected) probability of misclassification

 CALL: P = stk_pmisclass (U, Z_PRED)

    computes the probability of misclassification P with respect to the
    threshold U using the posterior means and variances contained in Z_PRED,
    where Z_PRED is a dataframe with column names 'mean' and 'var' (as
    returned by stk_predict).

 CALL: P = stk_pmisclass (U, Z1_PRED, K12, K22)

    computes the expected probability of misclassification P with respect to
    the threshold U at a set of locations X1, assuming that observations are
    made at another set of location X2, where:

     * Z1_PRED contains, as above, the posterior means and variances at X1;

     * K12 is the posterior covariance matrix between the values of the process
       at X1 and the observations (at X2);

     * K22 is the posterior covariance matrix of the observations.

 See also: stk_predict, stk_example_doe04



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 71
 STK_PMISCLASS computes the (expected) probability of misclassification



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 686
 STK_SIMULATE_NOISE simulates random draws of the observation noise

 CALL: Z = stk_simulate_noise (MODEL, X)

    simulates one random draw of the observation noise in the MODEL at
    observation points X.  The input argument X can be either a numerical
    matrix or a dataframe.  The output Z has the same number of of rows as X.
    More precisely, on a factor space of dimension DIM,

     * X must have size NS x DIM,
     * Z will have size NS x 1,

    where NS is the number of simulation points.

 CALL: Z = stk_simulate_noise (MODEL, X, M)

    generates M random draws at once.  In this case, the output argument Z has
    size NS x M.

 See also: stk_generate_samplepaths



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 67
 STK_SIMULATE_NOISE simulates random draws of the observation noise





