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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 3232
 -- Function: mpfr_function_d ('acos', R, X)
 -- Function: mpfr_function_d ('acosh', R, X)
 -- Function: mpfr_function_d ('asin', R, X)
 -- Function: mpfr_function_d ('asinh', R, X)
 -- Function: mpfr_function_d ('atan', R, X)
 -- Function: mpfr_function_d ('atan2', R, Y, X)
 -- Function: mpfr_function_d ('atanh', R, X)
 -- Function: mpfr_function_d ('cbrt', R, X)
 -- Function: mpfr_function_d ('cos', R, X)
 -- Function: mpfr_function_d ('cosh', R, X)
 -- Function: mpfr_function_d ('cot', R, X)
 -- Function: mpfr_function_d ('coth', R, X)
 -- Function: mpfr_function_d ('csc', R, X)
 -- Function: mpfr_function_d ('csch', R, X)
 -- Function: mpfr_function_d ('dilog', R, X)
 -- Function: mpfr_function_d ('ei', R, X)
 -- Function: mpfr_function_d ('erf', R, X)
 -- Function: mpfr_function_d ('erfc', R, X)
 -- Function: mpfr_function_d ('exp', R, X)
 -- Function: mpfr_function_d ('expm1', R, X)
 -- Function: mpfr_function_d ('factorial', R, N)
 -- Function: mpfr_function_d ('fma', R, X, Y, Z)
 -- Function: mpfr_function_d ('gamma', R, X)
 -- Function: mpfr_function_d ('gammaln', R, X)
 -- Function: mpfr_function_d ('hypot', R, X, Y)
 -- Function: mpfr_function_d ('log', R, X)
 -- Function: mpfr_function_d ('log2', R, X)
 -- Function: mpfr_function_d ('log10', R, X)
 -- Function: mpfr_function_d ('log1p', R, X)
 -- Function: mpfr_function_d ('minus', R, X, Y)
 -- Function: mpfr_function_d ('nthroot', R, X, N)
 -- Function: mpfr_function_d ('plus', R, X, Y)
 -- Function: mpfr_function_d ('pow', R, X, Y)
 -- Function: mpfr_function_d ('pow2', R, X)
 -- Function: mpfr_function_d ('pow10', R, X)
 -- Function: mpfr_function_d ('psi', R, X)
 -- Function: mpfr_function_d ('rdivide', R, X, Y)
 -- Function: mpfr_function_d ('realsqrt', R, X)
 -- Function: mpfr_function_d ('rsqrt', R, X)
 -- Function: mpfr_function_d ('sec', R, X)
 -- Function: mpfr_function_d ('sech', R, X)
 -- Function: mpfr_function_d ('sin', R, X)
 -- Function: mpfr_function_d ('sinh', R, X)
 -- Function: mpfr_function_d ('sinh', R, X)
 -- Function: mpfr_function_d ('sinh', R, X)
 -- Function: mpfr_function_d ('sqr', R, X)
 -- Function: mpfr_function_d ('tan', R, X)
 -- Function: mpfr_function_d ('tanh', R, X)
 -- Function: mpfr_function_d ('times', R, X, Y)

     Evaluate a function in binary64 with correctly rounded result.

     Parameter 1 is the function’s name in GNU Octave, Parameter 2 is
     the rounding direction (‘0’: towards zero, ‘0.5’: towards nearest
     and ties to even, ‘+inf’: towards positive infinity, ‘-inf’:
     towards negative infinity).  Parameters 3 and (possibly) 4 and 5
     are operands to the function.

     Evaluated on matrices, the function will be applied element-wise.
     Scalar operands do broadcast for functions with more than one
     operand.

     The result is guaranteed to be correctly rounded.  That is, the
     function is evaluated with (virtually) infinite precision and the
     exact result is approximated with a binary64 number using the
     desired rounding direction.

          mpfr_function_d ('plus', -inf, 1, eps / 2) == 1
            ⇒ 1
          mpfr_function_d ('plus', +inf, 1, eps / 2) == 1 + eps
            ⇒ 1

     See also: fesetround.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 62
Evaluate a function in binary64 with correctly rounded result.



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 515
 -- Function: mpfr_linspace_d (R, BASE, LIMIT, N)

     Return a row vector with N linearly spaced elements between BASE
     and LIMIT.

     The result is rounded in the direction R (‘+inf’: towards positive
     infinity, ‘-inf’: towards negative infinity).

     The result is not guaranteed to be correctly rounded, but should be
     within 1 ULP of the correctly rounded result.

          mpfr_linspace_d (-inf, 0, 10, 3)
            ⇒ ans =
                  0    5   10

     See also: linspace.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 75
Return a row vector with N linearly spaced elements between BASE and
LIMIT.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 17
mpfr_matrix_mul_d


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 823
 -- Function: [L, U] = mpfr_matrix_mul_d (XL, YL, XU, YU)

     Compute the matrix product with binary64 numbers and correctly
     rounded result.

     Compute the lower and upper boundary of the matrix multiplication
     of interval matrices [XL, XU] and [YL, YU].

     The result is guaranteed to be tight.  That is, the matrix product
     is evaluated with (virtually) infinite precision and the exact
     result is approximated with binary64 numbers using directed
     rounding.

          m = magic (3);
          [l, u] = mpfr_matrix_mul_d (m, m', m + 1, m' + 1)
            ⇒ l =
               101    71    53
                71    83    71
                53    71   101
              u =
               134   104    86
               104   116   104
                86   104   134

     See also: mtimes.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 78
Compute the matrix product with binary64 numbers and correctly rounded
result.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 17
mpfr_matrix_sqr_d


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1160
 -- Function: [L, U] = mpfr_matrix_sqr_d (XL, XU)

     Compute the lower and upper boundary of the matrix square of
     interval matrix [XL, XU].

     The result is guaranteed to be tight.  That is, the matrix square
     is evaluated with (virtually) infinite precision and the exact
     result is approximated with binary64 numbers using directed
     rounding.

     Unlike ‘X * X’ this function avoids the dependency problem during
     computation and produces a better enclosure.  The algorithm has
     been implemented after “Feasible algorithm for computing the square
     of an interval matrix” in O. Kosheleva, V. Kreinovich, G. Mayer,
     and H. T. Nguyen (2005): Computing the cube of an interval matrix
     is NP-hard.  In SAC ’05: Proc.  of the 2005 ACM Symposium on
     Applied Computing, pages 1449–1453, 2005.

          m = magic (3);
          [l, u] = mpfr_matrix_sqr_d (m, m + 1)
            ⇒ l =
               91   67   67
               67   91   67
               67   67   91
              u =
               124   100   100
               100   124   100
               100   100   124

     See also: mpower.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Compute the lower and upper boundary of the matrix square of interval
matrix [XL



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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1583
 -- Function: mpfr_to_string_d (R, FORMAT, X)

     Convert binary64 numbers X to string representation, either exact
     or correctly rounded.

     The result is a cell array of strings and, if not exact, is rounded
     in the direction R (‘0’: towards zero, ‘0.5’: towards nearest and
     ties to even, ‘+inf’: towards positive infinity, ‘-inf’: towards
     negative infinity).

     The FORMAT may be one of the following:
     ‘auto’
          Varying mantissa length with 5 or 15 places, depending on the
          currently active ‘format’.  It is also possible to define
          other values with the ‘output_precision’ function.
     ‘decimal’
          Varying mantissa length with up to 16 or 17 places.  This
          format will correctly separate subsequent numbers of binary64
          precision with the least possible number of digits.
     ‘exact decimal’
          Varying mantissa length with up to 751 places.
     ‘exact hexadecimal’
          Mantissa with exactly 13 hexadecimal places.

          mpfr_to_string_d (-inf, "exact hexadecimal", magic (3) / 10)
            ⇒
              {
                [1,1] = 0XC.CCCCCCCCCCCD0P-4
                [2,1] = 0X4.CCCCCCCCCCCCCP-4
                [3,1] = 0X6.6666666666668P-4
                [1,2] = 0X1.999999999999AP-4
                [2,2] = 0X8.0000000000000P-4
                [3,2] = 0XE.6666666666668P-4
                [1,3] = 0X9.9999999999998P-4
                [2,3] = 0XB.3333333333330P-4
                [3,3] = 0X3.3333333333334P-4
              }


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Convert binary64 numbers X to string representation, either exact or
correctly r



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 17
mpfr_vector_dot_d


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1523
 -- Function: [L, U] = mpfr_vector_dot_d (XL, YL, XU, YU)
 -- Function: [D, E] = mpfr_vector_dot_d (R, X, Y)

     Compute the dot product of binary64 numbers with correctly rounded
     result.

     Syntax 1: Compute the lower and upper boundary of the dot product
     of interval vectors [XL, XU] and [YL, YU] with tightest accuracy.

     Syntax 2: Compute the dot product D of two binary64 vectors with
     correctly rounded result and rounding direction R (‘0’: towards
     zero, ‘0.5’: towards nearest and ties to even, ‘+inf’: towards
     positive infinity, ‘-inf’: towards negative infinity).  Output
     parameter E yields an approximation of the error, that is the
     difference between the exact dot product and D as a second binary64
     number, rounded towards zero.

     The result is guaranteed to be tight / correctly rounded.  That is,
     the dot product is evaluated with (virtually) infinite precision
     and the exact result is approximated with a binary64 number using
     the desired rounding direction.

     For syntax 2 only: If one element of any vector is NaN, infinities
     of both signs or a product of zero and (positive or negative)
     infinity are encountered, the result will be NaN. An _exact_ zero
     is returned as +0 in all rounding directions, except for rounding
     towards negative infinity, where -0 is returned.

          [l, u] = mpfr_vector_dot_d (-1, -1, 2, 3)
            ⇒
              l = -3
              u = 6

     See also: dot.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 74
Compute the dot product of binary64 numbers with correctly rounded
result.



# name: <cell-element>
# type: sq_string
# elements: 1
# length: 17
mpfr_vector_sum_d


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1240
 -- Function: [S, E] = mpfr_vector_sum_d (R, X)

     Compute the sum S of all numbers in a binary64 vector X with
     correctly rounded result.

     R is the rounding direction (‘0’: towards zero, ‘0.5’: towards
     nearest and ties to even, ‘+inf’: towards positive infinity,
     ‘-inf’: towards negative infinity).

     The result is guaranteed to be correctly rounded.  That is, the sum
     is evaluated with (virtually) infinite precision and the exact
     result is approximated with a binary64 number using the desired
     rounding direction.

     If one element of the vector is NaN or infinities of both signs are
     encountered, the result will be NaN. An _exact_ zero is returned as
     +0 in all rounding directions, except for rounding towards negative
     infinity, where -0 is returned.

     A second output parameter yields an approximation of the error.
     The difference between the exact sum over X and S is approximated
     by a second binary64 number E with rounding towards zero.

          mpfr_vector_sum_d (-inf, [1, eps/2, realmax, -realmax]) == 1
            ⇒ 1
          mpfr_vector_sum_d (+inf, [1, eps/2, realmax, -realmax]) == 1 + eps
            ⇒ 1

     See also: sum.


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 80
Compute the sum S of all numbers in a binary64 vector X with correctly
rounded r





