octave-interval 3.1.0-5 / usr / share / octave / packages / interval-3.1.0 / doc-cache

# doc-cache created by Octave 4.2.1
# 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: 892
 -- 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: 869
 -- 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: 927
 -- 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: 1162
 -- 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: 1154
 -- 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: 727
 -- 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: 1695
 -- 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: 47
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: 852
 -- 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: 1249
 -- 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: 1267
 -- 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: 1692
 -- 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.

     See also: .


# 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: 1105
 -- 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: 1966
 -- 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.