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


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


# name: <cell-element>
# type: sq_string
# elements: 1
# length: 1594
 -- Loadable 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
     roundeded 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 seperate 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: 1541
 -- Loadable Function: [L, U] = mpfr_vector_dot_d (XL, YL, XU, YU)
 -- Loadable 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: 1249
 -- Loadable 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





