API Reference

rs_isolate(uni; verbose, output_precision, hybrid_limit, constraints, ensure_derivative_nonzero)

Isolate the roots of the univariate polynomial given by its coefficients as rational numbers.
Each root is contained in an interval where the polynomial and all constraints maintain constant sign.

Parameters:
    - uni : Vector of rational coefficients of the univariate polynomial (in ascending order)
    - constraints : Vector of polynomials (as vectors of rational coefficients) that should maintain 
                   constant sign in the output isolating intervals. Default is empty.
    - ensure_derivative_nonzero : If true, ensures that the derivative of the polynomial doesn't vanish 
                                 in the output isolating intervals. Default is false.

Optional parameters:
    - verbose : A non-negative integer fixing the level of verbosity during execution. Default is 0
    - output_precision : The number of bits encoding the mantissa of the output intervals. Default is 2
    - hybrid_limit : Number of bits above which the algorithm switches to exact arithmetic 
                    (instead of adaptive floating point arithmetic). Default is 2^30

function rs_rur(sys::Vector{AbstractAlgebra.Generic.MPoly{Rational{BigInt}}},
                vars::Vector{Symbol};
		        verbose::Int32=Int32(0))

Computes the RUR if the system sys wrt the variables vars.

It returns the RUR : extention, denominator, coordinates, separating element.

The optional parameter :
    - verbose : a non negative integer fixing the level of verbosity during the execution.

function rs_isolate(sys::Vector{AbstractAlgebra.Generic.MPoly{Rational{BigInt}}},
                    vars::Vector{Symbol};
	                verbose::Int32=Int32(0),output_precision::Int32=Int32(2),
                    hybrid_limit::Int32=Int32(2^30))

Isolate the roots of the multivariate polynomial system f w.r.t. the variables vars.

It returns a list of intervals with rational bounds.

The optional parameters are :
    - verbose : a non negative integer fixing the level of verbosity during the execution. 
    - output precision : the positive integer is the number of bits encoding the mantissa. 
    - hybrid_limit : number of bits above which the algorithm switches to exact arithmetic 
      (instead of adaptative floating point arithmetic).

function rs_isolate(rext::Vector{BigInt},rden::Vector{BigInt},
                    rur_num::Vector{Vector{BigInt}},sepvector::Vector{BigInt};
	                verbose::Int32=Int32(0),output_precision::Int32=Int32(2),
                    hybrid_limit::Int32=Int32(2^30))

Isolate the roots of the multivariate polynomial system given by a RUR rext,rden,rur_num 
and its associated separating vector sepvect.

It returns a list of boxes of precision (difference of mantissa in bits) at least output_precision.

The optional parameters are :

    - verbose : a non negative integer fixing the level of verbosity during the execution. 
    - output precision : the positive integer is the number of bits encoding the mantissa. 
    - hybrid_limit : number of bits above which the algorithm switches to exact arithmetic 
      (instead of adaptative floating point arithmetic).

function rs_isolate(rur::Vector{Vector{Rational{BigInt}}},sepvector;
	                verbose::Int32=Int32(0),output_precision::Int32=Int32(2),
                    hybrid_limit::Int32=Int32(2^30))

Isolate the roots of the multivariate polynomial system given by a RUR rur and its 
associated separating vector sepvect.

it returns a list of n-Dimensional boxes of precision at least output_precision and 
also certifies the sign of the coordinates.

The optional parameters are :
    - verbose : a non negative integer fixing the level of verbosity during the execution. 
    - output precision : the positive integer is the number of bits encoding the mantissa. 
    - hybrid_limit : number of bits above which the algorithm switches to exact arithmetic 
      (instead of adaptative floating point arithmetic).

function rs_newton(sys::Vector{AbstractAlgebra.Generic.MPoly{Rational{BigInt}}},
                   vars::Vector{Symbol},initial_point::Vector{BigFloat};
	               verbose::Int32=Int32(0),point_precision::Int32=Int32(23),
	               system_precision::Int32=Int32(23),work_precision::Int32=Int32(63),
	               output_precision::Int32=Int32(2),max_nb_loops::Int32=Int32(10))

Applies interval-Newton algorithm in order to find a box of output_precision bits that contains a unique root 
of the square polynomial system sys whose coefficients are knwon with a precision system_precision bits using 
work_precision bits during the computations and running a maximum of max_nb_loops iterations.

It returns a lst of boxes and a flag.

The optional parameters are :
    - verbose : a non negative integer fixing the level of verbosity during the execution. 
    - point_precision : the positive integer is the number of bits encoding the mantissa. 
    - system_precision : the positive integer is the number of bits encoding the mantissa. 
    - work_precision : the positive integer is the number of bits encoding the mantissa. 
    - output precision : the positive integer is the number of bits encoding the mantissa. 
    - max_nb_loops : a positive integer. The default is 10.

function rs_tci_points(icurve::AbstractAlgebra.Generic.MPoly{BigInt},
                       rs_vars::Vector{Symbol},
                       ym::Float64,yM::Float64,
                       xm::Float64,xM::Float64,
                       nb::Int32,prec::Int32;
                       verbose::Int32=Int32(0))


Given a bivariate polynomial with integral coefficients pol, the function computes 
the bitmap of resolution nb points defined by the plan curve pol=0 in the box 
[xm,xM]x[ym,YM] using prec bits for the floating point arithmetic.

The optional parameter :
    - verbose : a non negative integer fixing the level of verbosity during the execution. Default is 0