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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 238
 STK_BOUNDINGBOX constructs the bounding box for a set of points

 CALL: B = stk_boundingbox (X)

    returns the bounding box of X, defined as:

       B = [min(X); max(X)].

    The result is an stk_hrect object.

  See also: stk_hrect



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 64
 STK_BOUNDINGBOX constructs the bounding box for a set of points



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 85
 STK_COMMONSIZE ...

 TODO: describe differences with Octave's common_size function.



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



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 9
stk_feval


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 2538
 STK_FEVAL evaluates a function at given evaluation points

 CALL: Z = stk_feval (F, X)

    evaluates the function F on the evaluation points X, where

     * F can be either a function handle or a function name (string),
       or a cell-array of function handles or names, and
     * X can be either a numerical array or an stk_dataframe object.

    The output Z contains the evaluation results. The number of rows of Z is
    the same as the number of rows of X.

     * If F is a single function (name of handle) that returns row vectors with
       J elements, then Z has J columns and Z(i, :) is equal to F(X(i, :)).
     * If F is a cell-array of functions (names or handles), where F{k} returns
       row vectors J_k elements, then Z has J = J_1 + ... + J_K elements, and
       Z(i, :) is equal to [F{1}(X(i, :)) ... F{K}(X(i, :))].

    This two-argument form assumes that F supports vectorized evaluations.

 EXAMPLE:

    f = {@sin @cos};
    x = stk_sampling_regulargrid (100, 1, [0; 2*pi]);
    x.colnames = {'x'};
    y = stk_feval (f, x);
    plot (x, y);

 CALL: Z = stk_feval (F, X, DISPLAY_PROGRESS)

    displays progress messages if DISPLAY_PROGRESS is true, and does the same
    as the previous form otherwise. Displaying a progress message is useful if
    each evaluation of F requires a significant computation time.

    This three-argument form assumes that F supports vectorized evaluations if
    DISPLAY_PROGRESS is false, and performs evaluations one by one otherwise.

 NOTE: output type

   The output of stk_feval is an stk_dataframe object if X is, with the same
   row names and with column names determined automatically. Otherwise, the
   type of the output of stk_feval is determined by the type of the output of
   each function that is evaluated (together with the usual rules for concate-
   nating arrays of different types, if necessary).

 CALL: Z = stk_feval (F, X, DISPLAY_PROGRESS, DF_OUT)

   returns an stk_dataframe output if DF_OUT is true (even if X is not an
   stk_dataframe object itself), and let the usual concatenation rules
   determine the output type otherwise (even if X is an stk_dataframe).

 CALL: Z = stk_feval (F, X, DISPLAY_PROGRESS, DF_OUT, VECTORIZED)

   controls whether function evaluations are performed in a "vectorized" manner
   (i.e., all rows at once) or one row after the other. This form can be used
   to override the default rules explained above. Vectorized evaluations are
   usually faster but some functions do not support them.

 See also feval



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 58
 STK_FEVAL evaluates a function at given evaluation points



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 15
stk_isdominated


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 895
 STK_ISDOMINATED returns true for dominated rows

 CALL: ISDOM = stk_isdominated (A, B)

    returns a vector ISDOM of logicals, where ISDOM(i) is true if A(i, :)
    is dominated by one of the rows of B. A row B(j, :) is said to
    dominate A(i, :) if

       B(j, k) <= A(i, k)    for all k in {1, 2, ..., d}

    and

       B(j, k) < A(i, k)     for at least one such k,

    where d is the number of columns.  In other words: smaller is better.

 CALL: ISDOM = stk_isdominated (A, B, DO_SORTROWS)

    does the same but, if DO_SORTROWS == false, assumes that the rows of
    B are already sorted in ascending lexical order.

 CALL: [ISDOM, DPOS] = stk_isdominated (A, B, DO_SORTROWS)

    also returns a vector DPOS such that DPOS(i) = 0 if A(i, :) is non-
    dominated, and DPOS(i) gives the index of a row in B that dominates
    A(i, :) otherwise.

 See also: sortrows, stk_paretofind



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 48
 STK_ISDOMINATED returns true for dominated rows



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 339
 STK_LENGTH return the "length" of an array

 CALL:  L = stk_length (X)

    returns the "length" of the data array X.

 NOTE:

    Currently, the length of a data array (numeric array or stk_dataframe
    object) is defined as SIZE (X, 1) but this might change in future
    versions of STK. Note that this is not the same as length (X).



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 43
 STK_LENGTH return the "length" of an array



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 52
 STK_NORMALIZE normalizes a dataset to [0; 1] ^ DIM



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 52
 STK_NORMALIZE normalizes a dataset to [0; 1] ^ DIM




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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 705
 STK_PARETOFIND finds non-dominated rows in an array

 CALL: [NDPOS, DRANK] = stk_paretofind (X)

    returns the indices NDPOS such that X(NDPOS, :) contains all non-
    dominated rows of X, sorted in (ascending) lexical order. A row
    X(i, :) is said to dominate another row X(j, :) if

       X(i, k) <= X(j, k)    for all k in {1, 2, ..., d}

    and

       X(i, k) < X(j, k)     for at least one such k,

    where d is the number of columns.  In other words: smaller is better.
    For each row X(i, :),  DRANK(i) is equal to zero if the row is non-
    dominated, and equal to the smallest j such that X(i, :) is dominated
    by X(NDPOS(j), :) otherwise.

 See also: sortrows, stk_isdominated



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 52
 STK_PARETOFIND finds non-dominated rows in an array



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 11
stk_rescale


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 56
 STK_RESCALE rescales a dataset from one box to another



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 56
 STK_RESCALE rescales a dataset from one box to another




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 11
stk_sprintf


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 63
 STK_SPRINTF_DATA prints the content of an array into a string



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 63
 STK_SPRINTF_DATA prints the content of an array into a string




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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 59
 STK_SPRINTF_COLNAMES returns the column names of an array



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 59
 STK_SPRINTF_COLNAMES returns the column names of an array




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 16
stk_sprintf_info


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 67
 STK_SPRINTF_INFO returns the 'info' string associated to an array



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 67
 STK_SPRINTF_INFO returns the 'info' string associated to an array




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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 56
 STK_SPRINTF_ROWNAMES returns the row names of an array



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 56
 STK_SPRINTF_ROWNAMES returns the row names of an array




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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 61
 STK_SPRINTF_SIZETYPE prints the size and type into a string



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 61
 STK_SPRINTF_SIZETYPE prints the size and type into a string






