Arbitrary precision real balls

precision(::Type{Balls})

Return the precision for ball arithmetic.

Examples

julia> set_precision!(Balls, 200); precision(Balls)
200

set_precision!(::Type{Balls}, n::Int)

Set the precision for all ball arithmetic to be n.

Examples

julia> const_pi(real_field())
[3.141592653589793239 +/- 5.96e-19]

julia> set_precision!(Balls, 200); const_pi(real_field())
[3.14159265358979323846264338327950288419716939937510582097494 +/- 5.73e-60]

set_precision!(f, ::Type{Balls}, n::Int)

Change ball arithmetic precision to n for the duration of f..

Examples

julia> set_precision!(Balls, 4) do
         const_pi(real_field())
       end
[3e+0 +/- 0.376]

julia> set_precision!(Balls, 200) do
         const_pi(real_field())
       end
[3.1415926535897932385 +/- 3.74e-20]

real_field()

Return the field of real numbers modelled via real balls.

See precision and set_precision! on how to control the precision.

is_nonzero(x::RealFieldElem)

Return true if $x$ is certainly not equal to zero, otherwise return false.

isfinite(x::RealFieldElem)

Return true if $x$ is finite, i.e. having finite midpoint and radius, otherwise return false.

is_exact(x::RealFieldElem)

Return true if $x$ is exact, i.e. has zero radius, otherwise return false.

isinteger(x::RealFieldElem)

Return true if $x$ is an exact integer, otherwise return false.

is_positive(x::RealFieldElem)

Return true if $x$ is certainly positive, otherwise return false.

is_nonnegative(x::RealFieldElem)

Return true if $x$ is certainly non-negative, otherwise return false.

is_negative(x::RealFieldElem)

Return true if $x$ is certainly negative, otherwise return false.

is_nonpositive(x::RealFieldElem)

Return true if $x$ is certainly nonpositive, otherwise return false.

midpoint(x::RealFieldElem)

Return the midpoint of the ball $x$ as an Arb ball.

radius(x::RealFieldElem)

Return the radius of the ball $x$ as an Arb ball.

accuracy_bits(x::RealFieldElem)

Return the relative accuracy of $x$ measured in bits, capped between typemax(Int) and -typemax(Int).

overlaps(x::RealFieldElem, y::RealFieldElem)

Returns true if any part of the ball $x$ overlaps any part of the ball $y$, otherwise return false.

contains(x::RealFieldElem, y::RealFieldElem)

Returns true if the ball $x$ contains the ball $y$, otherwise return false.

contains(x::RealFieldElem, y::Integer)

Returns true if the ball $x$ contains the given integer value, otherwise return false.

contains(x::RealFieldElem, y::ZZRingElem)

Returns true if the ball $x$ contains the given integer value, otherwise return false.

contains(x::RealFieldElem, y::QQFieldElem)

Returns true if the ball $x$ contains the given rational value, otherwise return false.

contains(x::RealFieldElem, y::Rational{T}) where {T <: Integer}

Returns true if the ball $x$ contains the given rational value, otherwise return false.

contains(x::RealFieldElem, y::BigFloat)

Returns true if the ball $x$ contains the given floating point value, otherwise return false.

contains_zero(x::RealFieldElem)

Returns true if the ball $x$ contains zero, otherwise return false.

contains_negative(x::RealFieldElem)

Returns true if the ball $x$ contains any negative value, otherwise return false.

contains_positive(x::RealFieldElem)

Returns true if the ball $x$ contains any positive value, otherwise return false.

contains_nonnegative(x::RealFieldElem)

Returns true if the ball $x$ contains any non-negative value, otherwise return false.

contains_nonpositive(x::RealFieldElem)

Returns true if the ball $x$ contains any nonpositive value, otherwise return false.

isequal(x::RealFieldElem, y::RealFieldElem)

Return true if the balls $x$ and $y$ are precisely equal, i.e. have the same midpoints and radii.

add_error!(x::RealFieldElem, y::RealFieldElem)

Adds the absolute values of the midpoint and radius of $y$ to the radius of $x$.

trim(x::RealFieldElem)

Return an RealFieldElem interval containing $x$ but which may be more economical, by rounding off insignificant bits from the midpoint.

unique_integer(x::RealFieldElem)

Return a pair where the first value is a boolean and the second is an ZZRingElem integer. The boolean indicates whether the interval $x$ contains a unique integer. If this is the case, the second return value is set to this unique integer.

setunion(x::RealFieldElem, y::RealFieldElem)

Return an RealFieldElem containing the union of the intervals represented by $x$ and $y$.

const_pi(r::RealField)

Return $\pi = 3.14159\ldots$ as an element of $r$.

const_e(r::RealField)

Return $e = 2.71828\ldots$ as an element of $r$.

const_log2(r::RealField)

Return $\log(2) = 0.69314\ldots$ as an element of $r$.

const_log10(r::RealField)

Return $\log(10) = 2.302585\ldots$ as an element of $r$.

const_euler(r::RealField)

Return Euler's constant $\gamma = 0.577215\ldots$ as an element of $r$.

const_catalan(r::RealField)

Return Catalan's constant $C = 0.915965\ldots$ as an element of $r$.

const_khinchin(r::RealField)

Return Khinchin's constant $K = 2.685452\ldots$ as an element of $r$.

const_glaisher(r::RealField)

Return Glaisher's constant $A = 1.282427\ldots$ as an element of $r$.

rsqrt(x::RealFieldElem)

Return the reciprocal of the square root of $x$, i.e. $1/\sqrt{x}$.

sqrt1pm1(x::RealFieldElem)

Return $\sqrt{1+x}-1$, evaluated accurately for small $x$.

sqrtpos(x::RealFieldElem)

Return the sqrt root of $x$, assuming that $x$ represents a non-negative number. Thus any negative number in the input interval is discarded.

gamma(x::RealFieldElem)

Return the Gamma function evaluated at $x$.

lgamma(x::RealFieldElem)

Return the logarithm of the Gamma function evaluated at $x$.

rgamma(x::RealFieldElem)

Return the reciprocal of the Gamma function evaluated at $x$.

digamma(x::RealFieldElem)

Return the logarithmic derivative of the gamma function evaluated at $x$, i.e. $\psi(x)$.

gamma(s::RealFieldElem, x::RealFieldElem)

Return the upper incomplete gamma function $\Gamma(s,x)$.

gamma_regularized(s::RealFieldElem, x::RealFieldElem)

Return the regularized upper incomplete gamma function $\Gamma(s,x) / \Gamma(s)$.

gamma_lower(s::RealFieldElem, x::RealFieldElem)

Return the lower incomplete gamma function $\gamma(s,x) / \Gamma(s)$.

gamma_lower_regularized(s::RealFieldElem, x::RealFieldElem)

Return the regularized lower incomplete gamma function $\gamma(s,x) / \Gamma(s)$.

zeta(x::RealFieldElem)

Return the Riemann zeta function evaluated at $x$.

atan2(y::RealFieldElem, x::RealFieldElem)

Return $\operatorname{atan2}(y,x) = \arg(x+yi)$. Same as atan(y, x).

agm(x::RealFieldElem, y::RealFieldElem)

Return the arithmetic-geometric mean of $x$ and $y$

zeta(s::RealFieldElem, a::RealFieldElem)

Return the Hurwitz zeta function $\zeta(s,a)$.

root(x::RealFieldElem, n::Int)

Return the $n$-th root of $x$. We require $x \geq 0$.

factorial(x::RealFieldElem)

Return the factorial of $x$.

factorial(n::Int, r::RealField)

Return the factorial of $n$ in the given field.

binomial(x::RealFieldElem, n::UInt)

Return the binomial coefficient ${x \choose n}$.

binomial(n::UInt, k::UInt, r::RealField)

Return the binomial coefficient ${n \choose k}$ in the given field.

fibonacci(n::ZZRingElem, r::RealField)

Return the $n$-th Fibonacci number in the given field.

fibonacci(n::Int, r::RealField)

Return the $n$-th Fibonacci number in the given field.

gamma(x::ZZRingElem, r::RealField)

Return the Gamma function evaluated at $x$ in the given field.

gamma(x::QQFieldElem, r::RealField)

Return the Gamma function evaluated at $x$ in the given field.

zeta(n::Int, r::RealField)

Return the Riemann zeta function $\zeta(n)$ as an element of the given field.

bernoulli(n::Int, r::RealField)

Return the $n$-th Bernoulli number as an element of the given field.

rising_factorial(x::RealFieldElem, n::Int)

Return the rising factorial $x(x + 1)\ldots (x + n - 1)$.

rising_factorial(x::RingElement, n::Integer)

Return the rising factorial of $x$, i.e. $x(x + 1)(x + 2)\cdots (x + n - 1)$. If $n < 0$ we throw a DomainError().

Examples

julia> R, x = ZZ[:x];

julia> rising_factorial(x, 1)
x

julia> rising_factorial(x, 2)
x^2 + x

julia> rising_factorial(4, 2)
20

rising_factorial(x::QQFieldElem, n::Int, r::RealField)

Return the rising factorial $x(x + 1)\ldots (x + n - 1)$ as an element of the given field.

rising_factorial2(x::RealFieldElem, n::Int)

Return a tuple containing the rising factorial $x(x + 1)\ldots (x + n - 1)$ and its derivative.

rising_factorial2(x::RingElement, n::Integer)

Return a tuple containing the rising factorial $x(x + 1)\cdots (x + n - 1)$ and its derivative. If $n < 0$ we throw a DomainError().

Examples

julia> R, x = ZZ[:x];

julia> rising_factorial2(x, 1)
(x, 1)

julia> rising_factorial2(x, 2)
(x^2 + x, 2*x + 1)

julia> rising_factorial2(4, 2)
(20, 9)

polylog(s::Union{RealFieldElem,Int}, a::RealFieldElem)

Return the polylogarithm Li$_s(a)$.

chebyshev_t(n::Int, x::RealFieldElem)

Return the value of the Chebyshev polynomial $T_n(x)$.

chebyshev_u(n::Int, x::RealFieldElem)

Return the value of the Chebyshev polynomial $U_n(x)$.

chebyshev_t2(n::Int, x::RealFieldElem)

Return the tuple $(T_{n}(x), T_{n-1}(x))$.

chebyshev_u2(n::Int, x::RealFieldElem)

Return the tuple $(U_{n}(x), U_{n-1}(x))$

bell(n::ZZRingElem, r::RealField)

Return the Bell number $B_n$ as an element of $r$.

bell(n::Int, r::RealField)

Return the Bell number $B_n$ as an element of $r$.

numpart(n::ZZRingElem, r::RealField)

Return the number of partitions $p(n)$ as an element of $r$.

numpart(n::Int, r::RealField)

Return the number of partitions $p(n)$ as an element of $r$.

airy_ai(x::RealFieldElem)

Return the Airy function $\operatorname{Ai}(x)$.

airy_ai_prime(x::RealFieldElem)

Return the derivative of the Airy function $\operatorname{Ai}^\prime(x)$.

airy_bi(x::RealFieldElem)

Return the Airy function $\operatorname{Bi}(x)$.

airy_bi_prime(x::RealFieldElem)

Return the derivative of the Airy function $\operatorname{Bi}^\prime(x)$.

lindep(A::Vector{RealFieldElem}, bits::Int)

Find a small linear combination of the entries of the array $A$ that is small (using LLL). The entries are first scaled by the given number of bits before truncating to integers for use in LLL. This function can be used to find linear dependence between a list of real numbers. The algorithm is heuristic only and returns an array of Nemo integers representing the linear combination.

Examples

julia> RR = real_field()
Real field

julia> a = RR(-0.33198902958450931620250069492231652319)
[-0.33198902958450932088 +/- 4.15e-22]

julia> V = [RR(1), a, a^2, a^3, a^4, a^5]
6-element Vector{RealFieldElem}:
 1.0000000000000000000
 [-0.33198902958450932088 +/- 4.15e-22]
 [0.11021671576446420510 +/- 7.87e-21]
 [-0.03659074051063616184 +/- 4.17e-21]
 [0.012147724433904692427 +/- 4.99e-22]
 [-0.004032911246472051677 +/- 6.25e-22]

julia> W = lindep(V, 20)
6-element Vector{ZZRingElem}:
 1
 3
 0
 0
 0
 1

  simplest_rational_inside(x::RealFieldElem)

Return the simplest fraction inside the ball $x$. A canonical fraction $a_1/b_1$ is defined to be simpler than $a_2/b_2$ iff $b_1 < b_2$ or $b_1 = b_2$ and $a_1 < a_2$.

Examples

julia> RR = real_field()
Real field

julia> simplest_rational_inside(const_pi(RR))
8717442233//2774848045

rand(r::RealField; randtype::Symbol=:urandom)

Return a random element in given field.

The randtype default is :urandom which return an RealFieldElem contained in $[0,1]$.

The rest of the methods return non-uniformly distributed values in order to exercise corner cases. The option :randtest will return a finite number, and :randtest_exact the same but with a zero radius. The option :randtest_precise return an RealFieldElem with a radius around $2^{-\mathrm{prec}}$ the magnitude of the midpoint, while :randtest_wide return a radius that might be big relative to its midpoint. The :randtest_special-option might return a midpoint and radius whose values are NaN or inf.

rand([rng=Random.default_rng(),] G::SymmetricGroup)

Return a random permutation from G.