octave-interval 1.4.1-1 / usr / share / octave / packages / interval-1.4.1 / doc-cache

# doc-cache created by Octave 4.0.0
# name: cache
# type: cell
# rows: 3
# columns: 9
# 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: 854
 -- Function: empty ()
 -- Function: empty (N)
 -- Function: empty (N, M)

     Return the empty interval.

     With additional parameters, create an interval vector/matrix, 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: 1156
 -- Function: entire ()
 -- Function: entire (N)
 -- Function: entire (N, M)

     Return the entire set of real numbers.

     With additional parameters, create an interval vector/matrix, 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: 1062
 -- 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.  If this function creates an interval matrix, 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: 1442
 -- Function: hull (X1, X2, …)

     Create an interval enclosure for a list of parameters.

     Parameters can be simple numbers, intervals or interval literals as
     strings.  Scalar values or scalar intervals do broadcast if
     combined with matrices or interval matrices.

     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: 1239
 -- Function: midrad (M, R)
 -- Function: midrad (M)
 -- Function: midrad ()

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

     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.  Scalar values or scalar intervals do broadcast if
     combined with matrices or interval matrices.

     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: The result is an accurate enclosure.  The result is
     tightest if M and R are floating-point numbers or intervals.

          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: 44
Create an interval enclosure 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: 777
 -- Function: nai ()

     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 size of NaI is one in each dimension.

     The infsup constructor will not produce NaIs, but an error 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).