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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 893
 -- Function: ctc_intersect (C1, Y1, C2, Y2)
 -- Function: ctc_intersect (C1, C2)

     Return a contractor function for the intersection of two sets.

     Functions C1 and C2 define two sets ‘S1 = {X | C1 (X) ∈ Y1}’ and ‘S2 = {X |
     C2 (X) ∈ Y2}’.  The return value is a contractor function for the set
     ‘S1 ∩ S2 = {X | C1 (X) ∈ Y1 and C2 (X) ∈ Y2}’.

     Parameters C1 and C2 must be function handles and must accept the same
     number of parameters.  See ‘@infsup/fsolve’ for how to define contractor
     functions.  The user manual also contains an example on how to use this
     function.

     Instead of solving ‘C1 (X) ∈ Y1’ and ‘C2 (X) ∈ Y2’ separately and then
     compute an intersection of the result, you can solve ‘ctc_intersect (C1,
     Y1, C2, Y2) = 0’.

     See also: @@infsup/fsolve, ctc_union.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 62
Return a contractor function for the intersection of two sets.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 870
 -- Function: ctc_union (C1, Y1, C2, Y2)
 -- Function: ctc_union (C1, C2)

     Return a contractor function for the union of two sets.

     Functions C1 and C2 define two sets ‘S1 = {X | C1 (X) ∈ Y1}’ and ‘S2 = {X |
     C2 (X) ∈ Y2}’.  The return value is a contractor function for the set
     ‘S1 ∪ S2 = {X | C1 (X) ∈ Y1 or C2 (X) ∈ Y2}’.

     Parameters C1 and C2 must be function handles and must accept the same
     number of parameters.  See ‘@infsup/fsolve’ for how to define contractor
     functions.  The user manual also contains an example on how to use this
     function.

     Instead of solving ‘C1 (X) ∈ Y1’ and ‘C2 (X) ∈ Y2’ separately and then
     compute an union of the result, you can solve ‘ctc_union (C1, Y1, C2, Y2) =
     0’.

     See also: @@infsup/fsolve, ctc_intersect.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 55
Return a contractor function for the union of two sets.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 5
empty


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 926
 -- Function: empty ()
 -- Function: empty (N)
 -- Function: empty (N, M)
 -- Function: empty (N, M, K, ...)
 -- Function: empty ([N M ...])

     Return the empty interval.

     With additional parameters, create an interval vector/matrix/array, which
     comprises empty interval entries.

     The empty interval [Empty] contains no real numbers.  All interval
     functions return an empty result if the input is either empty or outside of
     the function's domain.

     The empty interval carries the trivial ‘trv’ decoration, which denotes that
     the empty interval cannot be the result of a function evaluation for a
     nonempty subset of its domain.

     Accuracy: The representation of the empty interval is exact.

          x = empty ()
            ⇒ x = [Empty]_trv
          inf (x)
            ⇒ ans = Inf
          sup (x)
            ⇒ ans = -Inf

     See also: @@infsup/isempty, entire.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 26
Return the empty interval.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
entire


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1148
 -- Function: entire ()
 -- Function: entire (N)
 -- Function: entire (N, M)

     Return the entire set of real numbers.

     With additional parameters, create an interval vector/matrix/array, which
     comprises entire interval entries.

     The entire set of real numbers [Entire] is a closed interval.  If used as
     an enclosure for a certain value, it represents a state of minimum
     constraints.  An interval function which evaluates to [Entire] yields no
     information at all if no interval decoration is present.

     The special floating-point values -Inf and Inf represent boundaries of the
     entire set of real numbers.  However, they are not members of the interval.

     The result of this function carries the defined and continuous ‘dac’
     decoration, which denotes that the interval is not bounded and therefore is
     no common interval.

     Accuracy: The representation of the entire set of real numbers is exact.

          x = entire ()
            ⇒ x = [Entire]_dac
          inf (x)
            ⇒ ans = -Inf
          sup (x)
            ⇒ ans = Inf

     See also: @@infsup/isentire, empty.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 38
Return the entire set of real numbers.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1151
 -- Function: exacttointerval (S)
 -- Function: exacttointerval (L, U)
 -- Function: exacttointerval (M)

     Create a bare interval.  Fail, if the interval cannot exactly represent the
     input.

     Typically, this function operates on interval literals S.  It is also
     possible to pass lower and upper boundaries L and U, or create a
     point-interval with a midpoint M.

     All valid input formats of the ‘infsup’ class constructor are allowed.  By
     giving a cell as input it is possible to create N-dimensional interval
     arrays.  If this function creates an interval array, all interval
     boundaries must be representable with binary64 numbers.

     Accuracy: The equation ‘X == exacttointerval (intervaltoexact (X))’ holds
     for all intervals.

          w = exacttointerval ("[ ]")
            ⇒ w = [Empty]
          x = exacttointerval ("[2, 3]")
            ⇒ x = [2, 3]
          y = exacttointerval ("[,]")
            ⇒ y = [Entire]
          z = exacttointerval ("[21e-1]")
            ⊣ ??? exacttointerval: interval wouldn't be exact

     See also: @@infsup/intervaltoexact, @@infsup/infsup.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 23
Create a bare interval.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 4
hull


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1380
 -- Function: hull (X1, X2, …)

     Create an interval enclosure for a list of parameters.

     Parameters can be simple numbers, intervals or interval literals as
     strings.  If needed, broadcasting is performed.

     NaNs represent missing values and are treated like empty intervals.  Inf
     and -Inf can be used to create unbound intervals, but note that these
     values will not be members of the interval.  In particular, it is not
     possible to create an interval with ‘hull (inf)’.

     The result is equivalent to ‘union (infsupdec (X1), union (infsupdec (X2),
     …))’, but computed in a more efficient way.  In contrast to the union
     function, this function is not considered a set operation and the result
     carries the best possible decoration, which is allowed by the input
     parameters.

     Warning: This function is not defined by IEEE Std 1788-2015 and shall not
     be confused with the standard's convexHull function, which is implemented
     by ‘union’.

     Accuracy: The result is a tight enclosure.

          hull (1, 4, 3, 2)
            ⇒ ans = [1, 4]_com
          hull (empty, entire)
            ⇒ ans = [Entire]_trv
          hull ("0.1", "pi", "e")
            ⇒ ans ⊂ [0.099999, 3.1416]_com
          hull ("[0, 3]", "[4, 7]")
            ⇒ ans = [0, 7]_com

     See also: @@infsupdec/union.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 54
Create an interval enclosure for a list of parameters.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 723
 -- Function: interval_bitpack (X)

     Decode an interval from its interchange format.

     The input must either be a matrix of n × 128 bits for n bare intervals, or
     a matrix of n × 136 bits for n decorated intervals.  Bits are in increasing
     order.  Byte order depends on the system's endianness.  First 8 bytes are
     used for the lower interval boundary, next 8 bytes are used for the upper
     interval boundary, (optionally) last byte is used for the decoration.

     The result is a row vector of intervals.

     Accuracy: For all valid interchange encodings the following equation holds:
     ‘X == bitunpack (interval_bitpack (X))’.

     See also: @@infsup/bitunpack, @@infsupdec/bitunpack.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 47
Decode an interval from its interchange format.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 6
midrad


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1681
 -- Function: I = midrad (M, R)
 -- Function: I = midrad (M)
 -- Function: I = midrad ()
 -- Function: [M, R] = midrad (I)

     Create an interval enclosure I for [M-R, M+R].

     With two output arguments, compute a rigorous midpoint M and radius R for
     interval I.

     Without input parameters, return the empty interval.  With only one input
     parameter, the radius R defaults to zero.

     Parameters can be simple numbers, intervals or interval literals as
     strings.  If needed, broadcasting is performed.

     The result is not guaranteed to be tightest if parameters are given as
     strings.  This is due to intermediate results.  The infsupdec constructor
     with interval literals in uncertain form ‘m?ruE’ can instead be used to
     create tight enclosures of decimal numbers with a radius.

     Accuracy (with one output argument): The result is an accurate enclosure.
     The result is tightest if M and R are floating-point numbers or intervals.

     Accuracy (with two output arguments): M is the interval's midpoint in
     binary64 precision, rounded to nearest and ties to even.  The returned
     radius R will make a tight enclosure of the interval together with M.  That
     is, R is the smallest binary64 number, which will make [M-R, M+R] enclose
     the interval I.

          midrad (42, 3)
            ⇒ ans = [39, 45]_com
          midrad (0, inf)
            ⇒ ans = [Entire]_dac
          midrad ("1.1", "0.1")
            ⇒ ans ⊂ [0.99999, 1.2001]_com
          midrad ("25", "3/7")
            ⇒ ans ⊂ [24.571, 25.429]_com

     See also: @@infsupdec/infsupdec, hull, @@infsupdec/mid, @@infsupdec/rad.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 48
Create an interval enclosure I for [M-R, M+R].




# name: <cell-element>
# type: sq_string
# elements: 1
# length: 3
nai


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 841
 -- Function: nai ()
 -- Function: nai (N)
 -- Function: nai (N, M)
 -- Function: nai (N, M, K, ...)
 -- Function: nai ([N, M, ...])

     Return the ill-formed decorated interval, called NaI (Not an Interval).

     Ill-formed intervals are the result of an illegal interval creation, e.g.
     ‘[3, 2]’.  They occur if the ‘infsupdec’ constructor is called with an
     invalid input and survive through interval arithmetic computations.
     Boolean comparisons on NaIs return ‘false’, i.e.  ‘[NaI] == [NaI]’ is
     false.

     The interval part of NaI is undefined.  The decoration part of NaI is
     ‘ill’.

     The infsup constructor will not produce NaIs, but a warning instead.

          x = nai ()
            ⇒ x = [NaI]
          x + 42
            ⇒ ans = [NaI]

     See also: @@infsupdec/infsupdec.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 71
Return the ill-formed decorated interval, called NaI (Not an Interval).



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1239
 -- Function: [LAMBDA, X, EP] = vereigback (A)
     Verified backward error analysis of eigenpairs.

     For a square complex (or real) matrix A, this function computes a vector of
     eigenvalues LAMBDA and a matrix of eigenvectors X in the usual Octave way
          ‘[X, L] = eig (A); lambda = diag (L);’
     and additionally a vector EP with the following property: for each I there
     exists a matrix, say A[I], verified to satisfy ‘max (max (abs (A - A[i])))
     <= ep(i)’ such that ‘(lambda(i), X(:, i))’ is verified to be an _exact_
     eigenpair of A[I].  If A, ‘lambda(i)’, and ‘X(:, i)’ are real then A[I] can
     be taken real, otherwise it is complex in general.  The maximal value of
     ‘ep(i)’ is usually very small (of order 1e-013 to 1e-016), which shows that
     Octave computes eigenvalues and eigenvectors with great accuracy.

     Based on the inequality (3.13) in J. Rohn, A Handbook of Results on
     Interval Linear Problems, posted at <http://www.cs.cas.cz/~rohn>, which
     also holds for complex eigenpairs (unpublished).

     This work was supported by the Czech Republic National Research Program
     “Information Society”, project 1ET400300415.

     See also: eig.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 47
Verified backward error analysis of eigenpairs.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1262
 -- Function: [EVC, LAMBDA, AS] = vereigvec (A, X)
     Verified real eigenvector of an interval matrix.

     For a square interval matrix A and a _real_ vector X, this function
     verifies X to be an eigenvector of some matrix in A, or not to be an
     eigenvector of any matrix in A, or yields no verified result
     (unfortunately, complex eigenvectors cannot be handled yet):

     EVC = 1
          X is verified to be an eigenvector of some matrix in A, LAMBDA is an
          interval number such that for each LAMBDA0 ∈ LAMBDA, A is verified to
          contain a matrix having (LAMDA0, X) as an eigenpair, AS is a very
          tight interval matrix verified to contain a matrix having (mid
          (LAMBDA), X) as an eigenpair,

     EVC = 0
          X is verified not to be an eigenvector of any matrix in A, LAMBDA and
          AS consist of empty intervals,

     EVC = -1
          no verified result (data may be wrong).

     Based on the section “Real eigenvectors” in J. Rohn, A handbook of results
     on interval linear problems, posted at <http://www.cs.cas.cz/~rohn>.

     This work was supported by the Czech Republic National Research Program
     “Information Society”, project 1ET400300415.

     See also: eig.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 48
Verified real eigenvector of an interval matrix.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1669
 -- Function: [X, AS] = verintlinineqs (A, B)
     Verified strong solution of interval linear inequalities.

     For a rectangular interval matrix A and a matching interval vector B, this
     function either computes a strong solution X to
          A * X ≤ b
     (i. e., a real vector X verified to satisfy AO * X ≤ BO for each AO in A
     and BO in B), or verifies nonexistence of such a solution, or yields no
     verified result:

     ~isnan (X)
          X is a verified strong solution of A * X ≤ B, and AS is an interval
          matrix of empty intervals,

     ~isempty (AS)
          AS is a very right (“almost thin”) interval matrix verified to contain
          a real matrix AO such that the system AO * X ≤ B.inf has no solution
          (which proves that no strong solution exists), and X is a vector of
          NaNs,

     otherwise
          no verified output.

     A theoretical result [1] asserts that if each system AO * X ≤ BO, where AO
     in A and BO in B, has a solution (depending generally on AO and BO), then
     there exists a vector X satisfying AO * X ≤ BO for _each_ AO in A and BO in
     B.  Such a vector X is called a strong solution of the system A * X ≤ B.

     [1] J. Rohn and J. Kreslova, Linear Interval Inequalities, LAMA 38 (1994),
     79–82.

     Based on Section 2.13 in M. Fiedler, J. Nedoma, J. Ramik, J. Rohn and
     K. Zimmermann, Linear Optimization Problems with Inexact Data,
     Springer-Verlag, New York 2006.

     This work was supported by the Czech Republic National Research Program
     “Information Society”, project 1ET400300415.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 57
Verified strong solution of interval linear inequalities.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 12
verinvnonneg


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 929
 -- Function: [nonneg, As] = verinvnonneg (A)
     Verified nonnegative invertibility of an interval matrix.

     For a square interval (or real) matrix A, this function verifies inverse
     nonnegativity of A, or not-inverse-nonnegativity of A, or yields no
     verified result:

     NONNEG = 1
          A verified inverse nonnegative,

     NONNEG = 0
          A verified not to be inverse nonnegative; AS is a matrix in A (always
          one of the two bounds) which is verified not to be inverse
          nonnegative,

     NONNEG = -1
          no verified result.

     Based on the result by Kuttler, Math.  of Computation 1971; see also J.
     Rohn, A Handbook of Results on Interval Linear Problems, posted at
     <http://www.cs.cas.cz/~rohn>, Section 3.9.

     This work was supported by the Czech Republic National Research Program
     “Information Society”, project 1ET400300415.

     See also: inv.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 57
Verified nonnegative invertibility of an interval matrix.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 12
verlinineqnn


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1083
 -- Function: [X, Y] = verlinineqnn (A, B)
     Verified nonnegative solution of a system of linear inequalities.

     For a rectangular real matrix A and a matching real vector B, this function
     either computes a verified solution of the system of linear inequalities
          A * X ≤ b,

                    X ≥ 0,
     or verifies nonexistence of a solution, or yields no verified result.

     Possible outputs:
        • Either X is a real vector verified to satisfy both inequalities and Y
          is a vector of NaN's,

        • or Y is a real vector verified to satisfy
               A' * Y ≥ 0,

                          Y ≥ 0,

               B' * Y ≤ -1
          (which by Farka's lemma implies nonexistence of a solution to the
          original inequalities), and X is a vector of NaN's,

        • or both X and Y are NaN's.  In this case no verified result could be
          found.

     This work was supported by the Czech Republic National Research Program
     “Information Society”, project 1ET400300415.

     See also: linprog.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 65
Verified nonnegative solution of a system of linear inequalities.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1930
 -- Function: [FLAG, X, Y, H] = verlinprog (A, B, C)
     Verified linear programming.

     For a real matrix A (full or sparse) and matching real vectors B, C, this
     function either computes verified optimal solution X, verified dual optimal
     solution Y and verified optimal value H of the linear programming problem
          min C' * X subject to A * X = B, x ≥ 0,
     or verifies (in)feasibility, or verifies unboundedness, or yields no
     verified result.  The respective outcome is always described verbally in
     the variable FLAG.

     Possible values of FLAG:
     ‘verified optimum’
          X is verified to enclose a primal optimal solution, Y is verified to
          enclose a dual optimal solution, H is verified to enclose the optimal
          value,

     ‘verified unbounded’
          X is verified to enclose a primal feasible solution XO, and Y is
          verified to enclose a vector YO such that the objective tends to -Inf
          along the feasible half-line {XO + T * YO | T ≥ 0}, H is empty,

     ‘verified feasible’
          X is verified to enclose a primal feasible solution (neither
          optimality nor unboundedness could be verified), Y, H are empty,

     ‘verified infeasible’
          Y is verified to enclose a Farkas vector YO satisfying A' * YO ≥ 0, B'
          * YO < 0 (whose existence proves primal infeasibility), X, H are
          empty,

     ‘no verified result’
          X, Y, and H are empty (no verified result could be found).

     Complexity: The algorithm solves at most four linear programming problems
     (independently of the size of the original problem) and uses a verification
     procedure which runs approximately in O(M³) time, where M = rows (A).

     This work was supported by the Czech Republic National Research Program
     “Information Society”, project 1ET400300415.

     See also: linprog.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 28
Verified linear programming.





