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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1673
 STK_DOMINATEHV computes the hypervolume dominated by a set of points

 CALL: HV = stk_dominatedhv (Y, Y_REF)
 CALL: HV = stk_dominatedhv (Y, Y_REF, 0)

    computes the hypervolume dominated by the rows of Y, with respect to the
    reference point Y_REF (a row vector with the same number of columns as Y).
    It is expected that all the rows of Y are smaller than Y_REF
    (multi-objective minimization framework).

 CALL: HV = stk_dominatedhv (Y)
 CALL: HV = stk_dominatedhv (Y, [], 0)

    uses [0 0 ... 0] as a reference point.

 CALL: DECOMP = stk_dominatedhv (Y, Y_REF, 1)

    computes a signed decomposition of the dominated hyper-region delimited by
    the reference point Y_REF into overlapping rectangles. Assuming that Y is
    of size N x D, the result DECOMP is a structure with field .sign (N x 1),
    .xmin (N x D) and .xmax (N x D). The hypervolume can be recovered from this
    decomposition using

      HV = sum (DECOMP.sign .* prod (DECOMP.xmax - DECOMP.xmin, 2))

    provided that the resulting decomposition is not empty.

 CALL: HV = stk_dominatedhv (Y, [], 1)

    computed a signed decomposition using [0 0 ... 0] as a reference point.

 NOTE:

    This function relies internally on the WFG algorithm [1, 2].

 REFERENCES:

   [1] Lyndon While, Lucas Bradstreet and Luigi Barone, "A Fast Way of
       Calculating Exact Hypervolumes", IEEE Transactions on Evolutionary
       Computation, 16(1):86-95, 2012
       http://dx.doi.org/10.1109/TEVC.2010.2077298

   [2] WFG 1.10, released under the GPLv2 licence, available online from:
       http://www.wfg.csse.uwa.edu.au/hypervolume/

 See also: sortrows, stk_isdominated, stk_paretofind



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 69
 STK_DOMINATEHV computes the hypervolume dominated by a set of points



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 912
 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, stk_dominatedhv



# 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: 14
stk_paretofind


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 722
 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, stk_dominatedhv



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





