| _decompose [Disjunction] | Decompose an abstract value |
| _equal [Mpfr] | |
| _equal [Mpf] | |
| _export [Mpz] | |
| _gcdext [Mpz] | |
| _get_str [Mpfr] | |
| _get_str [Mpf] | |
| _get_str [Mpq] | |
| _get_str [Mpz] | |
| _import [Mpz] | |
| _init_set_str [Mpfr] | |
| _init_set_str [Mpf] | |
| _init_set_str [Mpz] | |
| _mpfr [Mpfrf] | |
| _mpfrf [Mpfrf] | Unsafe conversion from and to Mpfr.t. |
| _mpq [Mpqf] | |
| _mpqf [Mpqf] | Unsafe conversion from and to Mpq.t. |
| _mpz [Mpzf] | |
| _mpzf [Mpzf] | |
| _powm [Mpz] | |
| _powm_ui [Mpz] | |
| _set_str [Mpfr] | |
| _set_str [Mpf] | |
| _set_str [Mpq] | |
| _set_str [Mpz] | |
| _sprintf [Mpfr] | |
| _sqrtrem [Mpz] | |
| _strtofr [Mpfr] | |
A | |
| abs [Mpfrf] | |
| abs [Mpqf] | |
| abs [Mpzf] | |
| abs [Mpfr] | |
| abs [Mpf] | |
| abs [Mpq] | |
| abs [Mpz] | |
| abstract0 [Abstract1] | Return resp. |
| abstract0_collapse [Pplite] | Modify abstract element to have n disjunct at most. |
| abstract0_disj_to_lincons_array [Pplite] | Get the linear constraints of the n-th disjunct. |
| abstract0_disj_to_tcons_array [Pplite] | Get the tree constraints of the n-th disjunct. |
| abstract0_geom_subseteq [Pplite] | Returns true if abs1 is geometrically contained in abs2 |
| abstract0_is_disjunctive [Pplite] | Returns true if abs is a powerset of polyhedra |
| abstract0_num_disjuncts [Pplite] | Get the number of disjuncts of a polyhedra powerset. |
| abstract0_split [Pplite] | Splits abstract element on linear constraint |
| acos [Mpfr] | |
| acosh [Mpfr] | |
| add [Mpfrf] | |
| add [Mpqf] | |
| add [Mpzf] | |
| add [Mpfr] | |
| add [Mpf] | |
| add [Mpq] | |
| add [Mpz] | |
| add [Environment] | Adding to an environment a set of integer and real variables. |
| add_dimensions [Abstract0] | |
| add_dimensions_with [Abstract0] | |
| add_epsilon [Oct] | Perturbation. |
| add_epsilon_bin [Oct] | Perturbation. |
| add_int [Mpfrf] | |
| add_int [Mpzf] | |
| add_q [Mpfr] | |
| add_ray_array [Abstract1] | Add the array of generators to the abstract value (time elapse operator). |
| add_ray_array [Abstract0] | Add the array of generators to the abstract value (time elapse operator). |
| add_ray_array_with [Abstract1] | |
| add_ray_array_with [Abstract0] | |
| add_ui [Mpfr] | |
| add_ui [Mpf] | |
| add_ui [Mpz] | |
| add_z [Mpfr] | |
| addmul [Mpz] | |
| addmul_ui [Mpz] | |
| agm [Mpfr] | |
| apply_dimchange2 [Abstract0] | |
| apply_dimchange2_with [Abstract0] | |
| approximate [Abstract1] |
|
| approximate [Abstract0] |
|
| array_extend_environment [Tcons1] | Change the environment of the array of constraints for a super-environment. |
| array_extend_environment [Generator1] | Change the environment of the array of generators for a super-environment. |
| array_extend_environment [Lincons1] | Change the environment of the array of constraints for a super-environment. |
| array_extend_environment_with [Tcons1] | Side-effect version of the previous function |
| array_extend_environment_with [Generator1] | Side-effect version of the previous function |
| array_extend_environment_with [Lincons1] | Side-effect version of the previous function |
| array_get [Tcons1] | Get the element of the given index (which is not a copy) |
| array_get [Generator1] | Get the element of the given index (which is not a copy) |
| array_get [Lincons1] | Get the element of the given index (which is not a copy) |
| array_get_env [Tcons1] | Get the environment of the array |
| array_get_env [Lincons1] | Get the environment of the array |
| array_length [Tcons1] | Get the size of the array |
| array_length [Generator1] | Get the size of the array |
| array_length [Lincons1] | Get the size of the array |
| array_make [Tcons1] | Make an array of tree expression constraints with the given size and defined on the given environment. |
| array_make [Generator1] | Make an array of generators with the given size and defined on the given environment. |
| array_make [Lincons1] | Make an array of linear constraints with the given size and defined on the given environment. |
| array_print [Tcons1] | Print an array of constraints |
| array_print [Generator1] | Print an array of generators |
| array_print [Lincons1] | Print an array of constraints |
| array_set [Tcons1] | Set the element of the given index (without any copy). |
| array_set [Generator1] | Set the element of the given index (without any copy). |
| array_set [Lincons1] | Set the element of the given index (without any copy). |
| asin [Mpfr] | |
| asinh [Mpfr] | |
| assign_linexpr [Abstract1] | |
| assign_linexpr [Abstract0] | |
| assign_linexpr_array [Abstract1] | Parallel assignement of an array of dimensions by an array of same size of linear expressions |
| assign_linexpr_array [Abstract0] | Parallel assignement of an array of dimensions by an array of same size of linear expressions |
| assign_linexpr_array_with [Abstract1] | |
| assign_linexpr_array_with [Abstract0] | |
| assign_linexpr_with [Abstract1] | |
| assign_linexpr_with [Abstract0] | |
| assign_texpr [Abstract1] | |
| assign_texpr [Abstract0] | |
| assign_texpr_array [Abstract1] | Parallel assignement of an array of dimensions by an array of same size of tree expressions |
| assign_texpr_array [Abstract0] | Parallel assignement of an array of dimensions by an array of same size of tree expressions |
| assign_texpr_array_with [Abstract1] | |
| assign_texpr_array_with [Abstract0] | |
| assign_texpr_with [Abstract1] | |
| assign_texpr_with [Abstract0] | |
| atan [Mpfr] | |
| atan2 [Mpfr] | |
| atanh [Mpfr] | |
B | |
| bin_ui [Mpz] | |
| bin_uiui [Mpz] | |
| binop [Texpr1] | |
| binop [Texpr0] | |
| bottom [Abstract1] | Create a bottom (empty) value defined on the given environment |
| bottom [Abstract0] | Create a bottom (empty) value with the given number of integer and real variables |
| bottom [Interval] | Top and bottom intervals (using |
| bound_dimension [Abstract0] | Return the interval of variation of the dimension in the abstract value. |
| bound_linexpr [Abstract1] | Return the interval of variation of the linear expression in the abstract value. |
| bound_linexpr [Abstract0] | Return the interval of variation of the linear expression in the abstract value. |
| bound_texpr [Abstract1] | Return the interval of variation of the tree expression in the abstract value. |
| bound_texpr [Abstract0] | Return the interval of variation of the tree expression in the abstract value. |
| bound_variable [Abstract1] | Return the interval of variation of the variable in the abstract value. |
C | |
| canonicalize [Mpq] | |
| canonicalize [Abstract1] | Put the abstract value in canonical form. |
| canonicalize [Abstract0] | Put the abstract value in canonical form. |
| cbrt [Mpfr] | |
| cdiv_q [Mpzf] | |
| cdiv_q [Mpz] | The first parameter holds the quotient. |
| cdiv_q_2exp [Mpz] | The first parameter holds the quotient. |
| cdiv_q_ui [Mpz] | The first parameter holds the quotient. |
| cdiv_qr [Mpzf] | |
| cdiv_qr [Mpz] | The two first parameters hold resp. |
| cdiv_qr_ui [Mpz] | The two first parameters hold resp. |
| cdiv_r [Mpzf] | |
| cdiv_r [Mpz] | The first parameter holds the remainder. |
| cdiv_r_2exp [Mpz] | The first parameter holds the remainder. |
| cdiv_r_ui [Mpz] | The first parameter holds the remainder. |
| cdiv_ui [Mpz] | |
| ceil [Mpfr] | |
| ceil [Mpf] | |
| change_add_invert [Dim] | Assuming a transformation for add_dimensions, invert it in-place to obtain the inverse transformation using remove_dimensions |
| change_environment [Abstract1] | Change the environment of the abstract values. |
| change_environment_with [Abstract1] | |
| check_range [Mpfr] | |
| clear_flags [Mpfr] | |
| clear_inexflag [Mpfr] | |
| clear_nanflag [Mpfr] | |
| clear_overflow [Mpfr] | |
| clear_underflow [Mpfr] | |
| closure [Abstract1] | Closure: transform strict constraints into non-strict ones. |
| closure [Abstract0] | Closure: transform strict constraints into non-strict ones. |
| closure_with [Abstract1] | Side-effect version |
| closure_with [Abstract0] | Side-effect version |
| clrbit [Mpz] | |
| cmp [Mpfrf] | |
| cmp [Mpqf] | |
| cmp [Mpzf] | |
| cmp [Mpfr] | |
| cmp [Mpf] | |
| cmp [Mpq] | |
| cmp [Mpz] | |
| cmp [Environment] | Compare two environment. |
| cmp [Linexpr0] | Comparison with lexicographic ordering using |
| cmp [Coeff] | Non Total Comparison: If the 2 coefficients are both scalars, corresp. to Scalar.cmp, If the 2 coefficients are both intervals, corresp. to Interval.cmp, otherwise, -3 if the first is a scalar, 3 otherwise |
| cmp [Interval] | Non Total Comparison: 0: equality -1: i1 included in i2 +1: i2 included in i1 -2: i1.inf less than or equal to i2.inf +2: i1.inf greater than i2.inf |
| cmp [Scalar] | Compare two coefficients, possibly converting to |
| cmp_d [Mpf] | |
| cmp_d [Mpz] | |
| cmp_frac [Mpqf] | |
| cmp_int [Mpfrf] | |
| cmp_int [Mpqf] | |
| cmp_int [Mpzf] | |
| cmp_int [Scalar] | Compare a coefficient with an integer |
| cmp_si [Mpfr] | |
| cmp_si [Mpf] | |
| cmp_si [Mpq] | |
| cmp_si [Mpz] | |
| cmp_si_2exp [Mpfr] | |
| cmpabs [Mpz] | |
| cmpabs_d [Mpz] | |
| cmpabs_ui [Mpz] | |
| com [Mpz] | |
| compare [Var] | Comparison function. |
| compose [PolkaGrid] | Compose an abstract value |
| compose [Disjunction] | |
| congruent_2exp_p [Mpz] | |
| congruent_p [Mpz] | |
| congruent_ui_p [Mpz] | |
| const_catalan [Mpfr] | |
| const_euler [Mpfr] | |
| const_log2 [Mpfr] | |
| const_pi [Mpfr] | |
| copy [Policy] | |
| copy [Abstract1] | Copy a value |
| copy [Tcons1] | Copy (deep copy) |
| copy [Texpr1] | Copy |
| copy [Generator1] | Copy (deep copy) |
| copy [Lincons1] | Copy (deep copy) |
| copy [Linexpr1] | Copy |
| copy [Abstract0] | Copy a value |
| copy [Tcons0] | Copy a tree expression constraint (deep copy) |
| copy [Texpr0] | Copy |
| copy [Generator0] | Copy a generator (deep copy) |
| copy [Lincons0] | Copy a linear constraint (deep copy) |
| copy [Linexpr0] | Copy |
| cos [Mpfr] | |
| cosh [Mpfr] | |
| cot [Mpfr] | |
| coth [Mpfr] | |
| csc [Mpfr] | |
| csch [Mpfr] | |
| cst [Texpr1] | |
| cst [Texpr0] | |
D | |
| decompose [PolkaGrid] | Decompose an abstract value |
| decompose [Disjunction] | |
| dim [Texpr0] | |
| dim_of_var [Environment] | Return the dimension associated to the given variable in the environment. |
| dimchange [Environment] |
|
| dimchange2 [Environment] |
|
| dimension [Policy] | |
| dimension [Environment] | Return the dimension of the environment |
| dimension [Abstract0] | |
| div [Mpfrf] | |
| div [Mpqf] | |
| div [Mpfr] | |
| div [Mpf] | |
| div [Mpq] | |
| div_2exp [Mpfr] | |
| div_2exp [Mpf] | |
| div_2exp [Mpq] | |
| div_2si [Mpfr] | |
| div_2ui [Mpfr] | |
| div_q [Mpfr] | |
| div_ui [Mpfrf] | |
| div_ui [Mpfr] | |
| div_ui [Mpf] | |
| div_z [Mpfr] | |
| divexact [Mpzf] | |
| divexact [Mpz] | |
| divexact_ui [Mpz] | |
| divisible_2exp_p [Mpz] | |
| divisible_p [Mpz] | |
| divisible_ui_p [Mpz] | |
E | |
| eint [Mpfr] | |
| env [Abstract1] | |
| equal [Mpfrf] | |
| equal [Mpqf] | |
| equal [Mpfr] | |
| equal [Mpf] | |
| equal [Mpq] | |
| equal [Policy] | |
| equal [Environment] | Test the equality of two environments |
| equal [Texpr0] | Equality test |
| equal [Linexpr0] | Equality comparison |
| equal [Coeff] | Equality test |
| equal [Interval] | Equality test |
| equal [Scalar] | Equality test, possibly using a conversion to |
| equal_int [Coeff] | Is the coefficient equal to scalar b or interval |
| equal_int [Interval] | Is the interval equal to |
| equal_int [Scalar] | Equality test with an integer |
| erf [Mpfr] | |
| erfc [Mpfr] | |
| even_p [Mpz] | |
| exp [Mpfr] | |
| exp10 [Mpfr] | |
| exp2 [Mpfr] | |
| expand [Abstract1] | Expansion: |
| expand [Abstract0] | Expansion: |
| expand_with [Abstract1] | |
| expand_with [Abstract0] | |
| expm1 [Mpfr] | |
| export [Mpz] | |
| extend_environment [Tcons1] | Change the environment of the constraint for a super-environment. |
| extend_environment [Texpr1] | Change the environment of the expression for a super-environment. |
| extend_environment [Generator1] | Change the environment of the generator for a super-environment. |
| extend_environment [Lincons1] | Change the environment of the constraint for a super-environment. |
| extend_environment [Linexpr1] | Change the environment of the expression for a super-environment. |
| extend_environment_with [Tcons1] | Side-effect version of the previous function |
| extend_environment_with [Texpr1] | Side-effet version of the previous function |
| extend_environment_with [Generator1] | Side-effect version of the previous function |
| extend_environment_with [Lincons1] | Side-effect version of the previous function |
| extend_environment_with [Linexpr1] | Side-effet version of the previous function |
F | |
| fac_ui [Mpfr] | |
| fac_ui [Mpz] | |
| fdiv_q [Mpzf] | |
| fdiv_q [Mpz] | |
| fdiv_q_2exp [Mpz] | |
| fdiv_q_ui [Mpz] | |
| fdiv_qr [Mpzf] | |
| fdiv_qr [Mpz] | |
| fdiv_qr_ui [Mpz] | |
| fdiv_r [Mpzf] | |
| fdiv_r [Mpz] | |
| fdiv_r_2exp [Mpz] | |
| fdiv_r_ui [Mpz] | |
| fdiv_ui [Mpz] | |
| fdump [Policy] | |
| fdump [Abstract1] | Dump on the |
| fdump [Abstract0] | Dump on the |
| fib2_ui [Mpz] | |
| fib_ui [Mpz] | |
| fits_int_p [Mpf] | |
| fits_int_p [Mpz] | |
| fits_sint_p [Mpf] | |
| fits_sint_p [Mpz] | |
| fits_slong_p [Mpf] | |
| fits_slong_p [Mpz] | |
| fits_sshort_p [Mpf] | |
| fits_sshort_p [Mpz] | |
| fits_uint_p [Mpf] | |
| fits_uint_p [Mpz] | |
| fits_ulong_p [Mpf] | |
| fits_ulong_p [Mpz] | |
| fits_ushort_p [Mpf] | |
| fits_ushort_p [Mpz] | |
| floor [Mpfr] | |
| floor [Mpf] | |
| fma [Mpfr] | |
| fmod [Mpfr] | |
| fms [Mpfr] | |
| fold [Abstract1] | Folding: |
| fold [Abstract0] | Folding: |
| fold_with [Abstract1] | |
| fold_with [Abstract0] | |
| forget_array [Abstract1] | |
| forget_array [Abstract0] | |
| forget_array_with [Abstract1] | |
| forget_array_with [Abstract0] | |
| frac [Mpfr] | |
| funopt_make [Manager] | Return the default options for any function ( |
G | |
| gamma [Mpfr] | |
| gand [Mpz] | |
| gcd [Mpzf] | |
| gcd [Mpz] | |
| gcd_ui [Mpz] | |
| gcdext [Mpz] | |
| generator1_of_lexbuf [Parser] | Conversion from lexing buffers to resp. |
| generator1_of_lstring [Parser] | Conversion from lists of strings to array of resp. |
| generator1_of_string [Parser] | Conversion from strings to resp. |
| get_approximate_max_coeff_size [Polka] | |
| get_coeff [Generator1] | Get the coefficient of the variable in the underlying linear expression |
| get_coeff [Lincons1] | Get the coefficient of the variable in the underlying linear expression |
| get_coeff [Linexpr1] | Get the coefficient of the variable |
| get_coeff [Linexpr0] | Get the coefficient corresponding to the dimension |
| get_cst [Lincons1] | Get the constant of the underlying linear expression |
| get_cst [Linexpr1] | Get the constant |
| get_cst [Linexpr0] | Get the constant |
| get_d [Mpfr] | |
| get_d [Mpf] | |
| get_d [Mpq] | |
| get_d [Mpz] | |
| get_d1 [Mpfr] | |
| get_d_2exp [Mpf] | |
| get_d_2exp [Mpz] | |
| get_default_prec [Mpfr] | |
| get_default_prec [Mpf] | |
| get_default_rounding_mode [Mpfr] | |
| get_den [Mpqf] | |
| get_den [Mpq] | |
| get_deserialize [Manager] | |
| get_emax [Mpfr] | |
| get_emin [Mpfr] | |
| get_env [Tcons1] | Get the environment of the tree expression constraint |
| get_env [Texpr1] | Get the environment of the expression |
| get_env [Generator1] | Get the environment of the generator |
| get_env [Lincons1] | Get the environment of the linear constraint |
| get_env [Linexpr1] | Get the environment of the expression |
| get_exp [Mpfr] | |
| get_flag_best [Manager] | Get the corresponding result flag |
| get_flag_exact [Manager] | Get the corresponding result flag |
| get_funopt [Manager] | Get the options sets for the function. |
| get_generator0 [Generator1] | Get the underlying generator of level 0. |
| get_int [Mpf] | |
| get_int [Mpz] | |
| get_library [Manager] | Get the name of the effective library which allocated the manager |
| get_lincons0 [Lincons1] | Get the underlying linear constraint of level 0. |
| get_linexpr0 [Linexpr1] | Get the underlying expression of level 0 (which is not a copy). |
| get_linexpr1 [Generator1] | Get the underlying linear expression. |
| get_linexpr1 [Lincons1] | Get the underlying linear expression. |
| get_max_coeff_size [Polka] | |
| get_num [Mpqf] | |
| get_num [Mpq] | |
| get_prec [Mpfr] | |
| get_prec [Mpf] | |
| get_q [Mpf] | |
| get_si [Mpf] | |
| get_si [Mpz] | |
| get_size [Linexpr0] | Get the size of the linear expression (which may be sparse or dense) |
| get_str [Mpfr] | |
| get_str [Mpf] | |
| get_str [Mpq] | |
| get_str [Mpz] | |
| get_tcons0 [Tcons1] | Get the underlying tree expression constraint of level 0. |
| get_texpr0 [Texpr1] | Get the underlying expression of level 0 (which is not a copy). |
| get_texpr1 [Tcons1] | Get the underlying linear expression. |
| get_typ [Tcons1] | Get the constraint type |
| get_typ [Generator1] | Get the generator type |
| get_typ [Lincons1] | Get the constraint type |
| get_version [Manager] | Get the version of the effective library which allocated the manager |
| get_z [Mpfr] | |
| get_z [Mpf] | |
| get_z [Mpq] | |
| get_z_exp [Mpfr] | |
| gmod [Mpzf] | |
| gmod [Mpz] | |
| gmod_ui [Mpz] | |
H | |
| hamdist [Mpz] | |
| hash [Abstract1] | |
| hash [Environment] | Hashing function for environments |
| hash [Var] | Hash function |
| hash [Abstract0] | |
| hash [Texpr0] | Hashing function |
| hash [Linexpr0] | Hashing function |
| hypot [Mpfr] | |
I | |
| i_of_float [Coeff] | |
| i_of_frac [Coeff] | |
| i_of_int [Coeff] | |
| i_of_mpfr [Coeff] | Create an interval coefficient from resp. |
| i_of_mpq [Coeff] | |
| i_of_mpqf [Coeff] | |
| i_of_scalar [Coeff] | Build an interval from a lower and an upper bound |
| import [Mpz] | |
| inexflag_p [Mpfr] | |
| inf_p [Mpfrf] | |
| inf_p [Mpfr] | |
| init [Mpfr] | |
| init [Mpf] | |
| init [Mpq] | |
| init [Mpz] | |
| init2 [Mpfr] | |
| init2 [Mpf] | |
| init2 [Mpz] | |
| init_default [Gmp_random] | |
| init_lc_2exp [Gmp_random] | |
| init_lc_2exp_size [Gmp_random] | |
| init_set [Mpfr] | |
| init_set [Mpf] | |
| init_set [Mpq] | |
| init_set [Mpz] | |
| init_set_d [Mpfr] | |
| init_set_d [Mpf] | |
| init_set_d [Mpq] | |
| init_set_d [Mpz] | |
| init_set_f [Mpfr] | |
| init_set_q [Mpfr] | |
| init_set_si [Mpfr] | |
| init_set_si [Mpf] | |
| init_set_si [Mpq] | |
| init_set_si [Mpz] | |
| init_set_str [Mpfr] | |
| init_set_str [Mpf] | |
| init_set_str [Mpq] | |
| init_set_str [Mpz] | |
| init_set_z [Mpfr] | |
| init_set_z [Mpq] | |
| integer_p [Mpfr] | |
| integer_p [Mpf] | |
| inv [Mpqf] | |
| inv [Mpq] | |
| invert [Mpz] | |
| ior [Mpz] | |
| is_bottom [Abstract1] | Emptiness test |
| is_bottom [Abstract0] | Emptiness test |
| is_bottom [Interval] | Does the interval contain no value ( |
| is_box [Box.Policy] | Return |
| is_box [Box.Abstract1] | Return |
| is_box [Box.Abstract0] | Return |
| is_dimension_unconstrained [Abstract0] | Is the dimension unconstrained in the abstract value ? If yes, this means that the existential quantification of the dimension does not change the value. |
| is_disjunction [Disjunction.Abstract1] | Return |
| is_disjunction [Disjunction.Abstract0] | Return |
| is_eq [Abstract1] | Equality test. |
| is_eq [Abstract0] | Equality test. |
| is_infty [Scalar] | Infinity test. |
| is_integer [Mpf] | |
| is_integer [Linexpr1] | Does the linear expression depend only on integer variables ? |
| is_interval [Coeff] | |
| is_interval_cst [Texpr1] | |
| is_interval_cst [Texpr0] | |
| is_interval_linear [Texpr1] | |
| is_interval_linear [Texpr0] | |
| is_interval_polyfrac [Texpr1] | |
| is_interval_polyfrac [Texpr0] | |
| is_interval_polynomial [Texpr1] | |
| is_interval_polynomial [Texpr0] | |
| is_leq [Abstract1] | Inclusion test. |
| is_leq [Abstract0] | Inclusion test. |
| is_leq [Interval] | Inclusion test. |
| is_oct [Oct.Abstract1] | Return |
| is_oct [Oct.Abstract0] | Return |
| is_polka [Polka.Abstract1] | |
| is_polka [Polka.Abstract0] | |
| is_polka_equalities [Polka.Abstract1] | Return |
| is_polka_equalities [Polka.Abstract0] | Return |
| is_polka_loose [Polka.Abstract1] | |
| is_polka_loose [Polka.Abstract0] | |
| is_polka_strict [Polka.Abstract1] | |
| is_polka_strict [Polka.Abstract0] | |
| is_polkagrid [PolkaGrid.Abstract1] | Return |
| is_polkagrid [PolkaGrid.Abstract0] | Return |
| is_ppl [Ppl.Abstract1] | |
| is_ppl [Ppl.Abstract0] | |
| is_ppl_grid [Ppl.Abstract1] | Return |
| is_ppl_grid [Ppl.Abstract0] | Return |
| is_ppl_loose [Ppl.Abstract1] | |
| is_ppl_loose [Ppl.Abstract0] | |
| is_ppl_strict [Ppl.Abstract1] | |
| is_ppl_strict [Ppl.Abstract0] | |
| is_pplite [Pplite.Abstract1] | |
| is_pplite [Pplite.Abstract0] | |
| is_pplite_loose [Pplite.Abstract1] | |
| is_pplite_loose [Pplite.Abstract0] | |
| is_pplite_strict [Pplite.Abstract1] | Return |
| is_pplite_strict [Pplite.Abstract0] | Return |
| is_real [Linexpr1] | Does the linear expression depend only on real variables ? |
| is_scalar [Texpr1] | |
| is_scalar [Texpr0] | |
| is_scalar [Coeff] | |
| is_top [Abstract1] | Universality test |
| is_top [Abstract0] | Universality test |
| is_top [Interval] | Does the interval represent the universe ( |
| is_unsat [Lincons1] | Is the constraint not satisfiable ? |
| is_variable_unconstrained [Abstract1] | Is the variable unconstrained in the abstract value ? If yes, this means that the existential quantification of the dimension does not change the value. |
| is_zero [Coeff] | Is the coefficient equal to scalar 0 or interval |
| is_zero [Interval] | Is the interval equal to |
| iter [Generator1] | Iter the function on the pair coefficient/variable of the underlying linear expression |
| iter [Lincons1] | Iter the function on the pair coefficient/variable of the underlying linear expression |
| iter [Linexpr1] | Iter the function on the pair coefficient/variable of the linear expression |
| iter [Linexpr0] | |
J | |
| j0 [Mpfr] | |
| j1 [Mpfr] | |
| jacobi [Mpz] | |
| jn [Mpfr] | |
| join [Abstract1] | Join of 2 abstract values. |
| join [Abstract0] | Join of 2 abstract values. |
| join_array [Abstract1] | Join of a non empty array of abstract values. |
| join_array [Abstract0] | Join of a non empty array of abstract values. |
| join_with [Abstract1] | |
| join_with [Abstract0] | |
K | |
| kronecker [Mpz] | |
| kronecker_si [Mpz] | |
L | |
| lce [Environment] | Compute the least common environment of 2 environment, that is, the environment composed of all the variables of the 2 environments. |
| lce_change [Environment] | Similar to the previous function, but returns also the transformations
required to convert from |
| lcm [Mpzf] | |
| lcm [Mpz] | |
| lcm_ui [Mpz] | |
| legendre [Mpz] | |
| lgamma [Mpfr] | |
| lincons1_of_lexbuf [Parser] | |
| lincons1_of_lstring [Parser] | |
| lincons1_of_string [Parser] | |
| linexpr1_of_lexbuf [Parser] | |
| linexpr1_of_string [Parser] | |
| lngamma [Mpfr] | |
| log [Mpfr] | |
| log10 [Mpfr] | |
| log1p [Mpfr] | |
| log2 [Mpfr] | |
| lucnum2_ui [Mpz] | |
| lucnum_ui [Mpz] | |
M | |
| make [Tcons1] | Make a tree expression constraint. |
| make [Generator1] | Make a generator. |
| make [Lincons1] | Make a linear constraint. |
| make [Linexpr1] | Build a linear expression defined on the given argument, which is sparse by default. |
| make [Environment] | Making an environment from a set of integer and real variables. |
| make [Tcons0] | Make a tree expression constraint. |
| make [Generator0] | Making a generator. |
| make [Lincons0] | Make a linear constraint. |
| make [Linexpr0] | Create a linear expression. |
| make_unsat [Lincons1] | Build the unsatisfiable constraint -1>=0 |
| manager [Policy] | Policy, general |
| manager [Abstract1] | |
| manager [Abstract0] | |
| manager_alloc [PolkaGrid] | Create a PolkaGrid manager from a (loose or strict) polka manager, and a PPL grid manager |
| manager_alloc [T1p] | Create a Taylor1+ manager. |
| manager_alloc [Oct] | Allocate a new manager to manipulate octagons. |
| manager_alloc [Box] | Create a Box manager. |
| manager_alloc [Disjunction] | |
| manager_alloc_equalities [Polka] | Create a NewPolka manager for conjunctions of linear equalities. |
| manager_alloc_grid [Ppl] | Allocate a new manager for linear congruences (grids) |
| manager_alloc_loose [Pplite] | Allocate a PPLite manager for loose convex polyhedra. |
| manager_alloc_loose [Ppl] | Allocate a PPL manager for loose convex polyhedra. |
| manager_alloc_loose [Polka] | Create a NewPolka manager for loose convex polyhedra. |
| manager_alloc_strict [Pplite] | Allocate a PPLite manager for strict convex polyhedra. |
| manager_alloc_strict [Ppl] | Allocate a PPL manager for strict convex polyhedra. |
| manager_alloc_strict [Polka] | Create a NewPolka manager for strict convex polyhedra. |
| manager_decompose [PolkaGrid] | Decompose the manager |
| manager_decompose [Disjunction] | |
| manager_get_internal [Polka] | Get the internal submanager of a NewPolka manager. |
| manager_get_internal [Oct] | No internal parameters for now... |
| manager_get_kind [Pplite] | Get the polyhedra kind from PPLite manager. |
| manager_get_manager [Policy] | Policy manager |
| manager_get_widen_spec [Pplite] | Get the widening specification from PPLite manager. |
| manager_is_box [Box] | Return |
| manager_is_disjunction [Disjunction] | Return |
| manager_is_oct [Oct] | Return |
| manager_is_polka [Polka] | |
| manager_is_polka_equalities [Polka] | Return |
| manager_is_polka_loose [Polka] | |
| manager_is_polka_strict [Polka] | |
| manager_is_polkagrid [PolkaGrid] | Return |
| manager_is_ppl [Ppl] | Type conversions |
| manager_is_ppl_grid [Ppl] | Return |
| manager_is_ppl_loose [Ppl] | |
| manager_is_ppl_strict [Ppl] | |
| manager_is_pplite [Pplite] | |
| manager_is_pplite_loose [Pplite] | |
| manager_is_pplite_strict [Pplite] | Return |
| manager_of_box [Box] | Make a box manager generic |
| manager_of_disjunction [Disjunction] | Make a disjunction manager generic |
| manager_of_oct [Oct] | Make an octagon manager generic |
| manager_of_polka [Polka] | |
| manager_of_polka_equalities [Polka] | Makes a polka manager generic |
| manager_of_polka_loose [Polka] | |
| manager_of_polka_strict [Polka] | |
| manager_of_polkagrid [PolkaGrid] | Makes a polkagrid manager generic |
| manager_of_ppl [Ppl] | |
| manager_of_ppl_grid [Ppl] | Make a ppl manager generic |
| manager_of_ppl_loose [Ppl] | |
| manager_of_ppl_strict [Ppl] | |
| manager_of_pplite [Pplite] | |
| manager_of_pplite_loose [Pplite] | |
| manager_of_pplite_strict [Pplite] | Make a PPLite manager generic |
| manager_set_kind [Pplite] | Set the polyhedra kind for PPLite manager. |
| manager_set_widen_spec [Pplite] | Set the widening specification for PPLite manager. |
| manager_to_box [Box] | Instanciate the type of a box manager. |
| manager_to_disjunction [Disjunction] | Instanciate the type of a disjunction manager. |
| manager_to_oct [Oct] | Instanciate the type of an octagon manager. |
| manager_to_polka [Polka] | |
| manager_to_polka_equalities [Polka] | Instanciate the type of a polka manager. |
| manager_to_polka_loose [Polka] | |
| manager_to_polka_strict [Polka] | |
| manager_to_polkagrid [PolkaGrid] | Instanciate the type of a polkagrid manager. |
| manager_to_ppl [Ppl] | |
| manager_to_ppl_grid [Ppl] | Instanciate the type of a ppl manager. |
| manager_to_ppl_loose [Ppl] | |
| manager_to_ppl_strict [Ppl] | |
| manager_to_pplite [Pplite] | |
| manager_to_pplite_loose [Pplite] | |
| manager_to_pplite_strict [Pplite] | Instantiate the type of a PPLite manager. |
| max [Mpfr] | |
| meet [Abstract1] | Meet of 2 abstract values. |
| meet [Abstract0] | Meet of 2 abstract values. |
| meet_apply [Policy.Abstract1] | |
| meet_apply [Policy.Abstract0] | |
| meet_array [Abstract1] | Meet of a non empty array of abstract values. |
| meet_array [Abstract0] | Meet of a non empty array of abstract values. |
| meet_array_apply [Policy.Abstract1] | |
| meet_array_apply [Policy.Abstract0] | |
| meet_array_improve [Policy.Abstract1] | |
| meet_array_improve [Policy.Abstract0] | |
| meet_improve [Policy.Abstract1] | |
| meet_improve [Policy.Abstract0] | |
| meet_lincons_array [Abstract1] | Meet of an abstract value with an array of linear constraints. |
| meet_lincons_array [Abstract0] | Meet of an abstract value with an array of linear constraints. |
| meet_lincons_array_apply [Policy.Abstract1] | |
| meet_lincons_array_apply [Policy.Abstract0] | |
| meet_lincons_array_improve [Policy.Abstract1] | |
| meet_lincons_array_improve [Policy.Abstract0] | |
| meet_lincons_array_with [Abstract1] | |
| meet_lincons_array_with [Abstract0] | |
| meet_lincons_array_with_apply [Policy.Abstract1] | |
| meet_lincons_array_with_apply [Policy.Abstract0] | |
| meet_tcons_array [Abstract1] | Meet of an abstract value with an array of tree expressions constraints. |
| meet_tcons_array [Abstract0] | Meet of an abstract value with an array of tree expression constraints. |
| meet_tcons_array_apply [Policy.Abstract1] | |
| meet_tcons_array_apply [Policy.Abstract0] | |
| meet_tcons_array_improve [Policy.Abstract1] | |
| meet_tcons_array_improve [Policy.Abstract0] | |
| meet_tcons_array_with [Abstract1] | |
| meet_tcons_array_with [Abstract0] | |
| meet_tcons_array_with_apply [Policy.Abstract1] | |
| meet_tcons_array_with_apply [Policy.Abstract0] | |
| meet_with [Abstract1] | |
| meet_with [Abstract0] | |
| meet_with_apply [Policy.Abstract1] | |
| meet_with_apply [Policy.Abstract0] | |
| mem_var [Environment] | Return true if the variable is present in the environment. |
| min [Mpfr] | |
| minimize [Abstract1] | Minimize the size of the representation of the value. |
| minimize [Linexpr1] | In case of sparse representation, remove zero coefficients |
| minimize [Abstract0] | Minimize the size of the representation of the value. |
| minimize [Linexpr0] | In case of sparse representation, remove zero coefficients |
| minimize_environment [Abstract1] | Remove from the environment of the abstract value and from the abstract value itself variables that are unconstrained in it. |
| minimize_environment_with [Abstract1] | |
| modf [Mpfr] | |
| mul [Mpfrf] | |
| mul [Mpqf] | |
| mul [Mpzf] | |
| mul [Mpfr] | |
| mul [Mpf] | |
| mul [Mpq] | |
| mul [Mpz] | |
| mul_2exp [Mpfr] | |
| mul_2exp [Mpf] | |
| mul_2exp [Mpq] | |
| mul_2exp [Mpz] | |
| mul_2si [Mpfr] | |
| mul_2ui [Mpfr] | |
| mul_d [Mpfr] | |
| mul_int [Mpzf] | |
| mul_q [Mpfr] | |
| mul_si [Mpfr] | |
| mul_si [Mpz] | |
| mul_ui [Mpfrf] | |
| mul_ui [Mpfr] | |
| mul_ui [Mpf] | |
| mul_z [Mpfr] | |
N | |
| nan_p [Mpfrf] | |
| nan_p [Mpfr] | |
| nanflag_p [Mpfr] | |
| narrowing [Oct] | Standard narrowing. |
| neg [Mpfrf] | |
| neg [Mpqf] | |
| neg [Mpzf] | |
| neg [Mpfr] | |
| neg [Mpf] | |
| neg [Mpq] | |
| neg [Mpz] | |
| neg [Coeff] | Negation |
| neg [Interval] | Negation |
| neg [Scalar] | Negation |
| nextabove [Mpfr] | |
| nextbelow [Mpfr] | |
| nextprime [Mpz] | |
| nexttoward [Mpfr] | |
| number_p [Mpfrf] | |
| number_p [Mpfr] | |
O | |
| odd_p [Mpz] | |
| of_array [Linexpr0] | Combines |
| of_box [Box.Policy] | Make a box value generic |
| of_box [Box.Abstract1] | Make a box value generic |
| of_box [Box.Abstract0] | Make a box value generic |
| of_box [Abstract1] | Abstract an hypercube. |
| of_box [Abstract0] | Abstract an hypercube. |
| of_disjunction [Disjunction.Abstract1] | Make a disjunction value generic |
| of_disjunction [Disjunction.Abstract0] | Make a disjunction value generic |
| of_expr [Texpr1] | General constructor (actually the most efficient) |
| of_expr [Texpr0] | General constructor (actually the most efficient |
| of_float [Mpfrf] | |
| of_float [Mpqf] | |
| of_float [Mpzf] | |
| of_float [Mpfr] | |
| of_float [Mpf] | |
| of_float [Mpq] | |
| of_float [Mpz] | |
| of_float [Interval] | |
| of_float [Scalar] | Create a scalar of type |
| of_frac [Mpfrf] | |
| of_frac [Mpqf] | |
| of_frac [Mpfr] | |
| of_frac [Mpq] | |
| of_frac [Interval] | |
| of_frac [Scalar] | Create a scalar of type |
| of_generator_array [Oct] | Approximate a set of generators to an abstract value, with best precision. |
| of_infsup [Interval] | depreciated |
| of_infty [Scalar] | Create a scalar of type |
| of_int [Mpfrf] | |
| of_int [Mpqf] | |
| of_int [Mpzf] | |
| of_int [Mpfr] | |
| of_int [Mpf] | |
| of_int [Mpq] | |
| of_int [Mpz] | |
| of_int [Interval] | |
| of_int [Scalar] | |
| of_lincons_array [Abstract1] | |
| of_lincons_array [Abstract0] | |
| of_linexpr [Texpr1] | Conversion |
| of_linexpr [Texpr0] | Conversion |
| of_list [Linexpr0] | Combines |
| of_lstring [Parser] | Abstraction of lists of strings representing constraints to abstract values, on the abstract domain defined by the given manager. |
| of_mpfr [Mpfrf] | Safe conversion from and to Mpfr.t. |
| of_mpfr [Interval] | Create an interval from resp. |
| of_mpfr [Scalar] | |
| of_mpfrf [Scalar] | Create a scalar of type |
| of_mpq [Mpfrf] | |
| of_mpq [Mpqf] | Safe conversion from and to Mpq.t. |
| of_mpq [Mpfr] | |
| of_mpq [Mpf] | |
| of_mpq [Interval] | |
| of_mpq [Scalar] | |
| of_mpqf [Interval] | |
| of_mpqf [Scalar] | |
| of_mpz [Mpfrf] | |
| of_mpz [Mpqf] | |
| of_mpz [Mpzf] | Safe conversion from and to Mpz.t. |
| of_mpz [Mpfr] | |
| of_mpz [Mpf] | |
| of_mpz [Mpq] | |
| of_mpz2 [Mpfrf] | |
| of_mpz2 [Mpqf] | |
| of_mpz2 [Mpfr] | |
| of_mpz2 [Mpq] | |
| of_oct [Oct.Abstract1] | Make an oct value generic |
| of_oct [Oct.Abstract0] | Make an oct value generic |
| of_polka [Polka.Abstract1] | |
| of_polka [Polka.Abstract0] | |
| of_polka_equalities [Polka.Abstract1] | Makes a polka value generic |
| of_polka_equalities [Polka.Abstract0] | Makes a polka value generic |
| of_polka_loose [Polka.Abstract1] | |
| of_polka_loose [Polka.Abstract0] | |
| of_polka_strict [Polka.Abstract1] | |
| of_polka_strict [Polka.Abstract0] | |
| of_polkagrid [PolkaGrid.Abstract1] | Makes a polkagrid value generic |
| of_polkagrid [PolkaGrid.Abstract0] | Makes a polkagrid value generic |
| of_ppl [Ppl.Abstract1] | |
| of_ppl [Ppl.Abstract0] | |
| of_ppl_grid [Ppl.Abstract1] | Make a ppl value generic |
| of_ppl_grid [Ppl.Abstract0] | Make a ppl value generic |
| of_ppl_loose [Ppl.Abstract1] | |
| of_ppl_loose [Ppl.Abstract0] | |
| of_ppl_strict [Ppl.Abstract1] | |
| of_ppl_strict [Ppl.Abstract0] | |
| of_pplite [Pplite.Abstract1] | |
| of_pplite [Pplite.Abstract0] | |
| of_pplite_loose [Pplite.Abstract1] | |
| of_pplite_loose [Pplite.Abstract0] | |
| of_pplite_strict [Pplite.Abstract1] | Make a PPLite value generic |
| of_pplite_strict [Pplite.Abstract0] | Make a PPLite value generic |
| of_scalar [Interval] | Build an interval from a lower and an upper bound |
| of_string [Mpfrf] | |
| of_string [Mpqf] | |
| of_string [Mpzf] | |
| of_string [Mpfr] | |
| of_string [Mpf] | |
| of_string [Mpq] | |
| of_string [Mpz] | |
| of_string [Var] | Constructor |
| of_tcons_array [Abstract1] | Abstract a conjunction of constraints |
| of_tcons_array [Abstract0] | Abstract a conjunction of constraints |
| overflow_p [Mpfr] | |
P | |
| perfect_power_p [Mpz] | |
| perfect_square_p [Mpz] | |
| perm_compose [Dim] |
|
| perm_invert [Dim] | Invert a permutation |
| permute_dimensions [Abstract0] | |
| permute_dimensions_with [Abstract0] | |
| policy_manager_alloc [Box] | |
| popcount [Mpz] | |
| pow [Mpfrf] | |
| pow [Mpfr] | |
| pow_int [Mpfrf] | |
| pow_si [Mpfr] | |
| pow_ui [Mpfr] | |
| pow_ui [Mpf] | |
| pow_ui [Mpz] | |
| powm [Mpz] | |
| powm_ui [Mpz] | |
| pre_widening [Oct] | Algorithms. |
| print [Mpfrf] | |
| print [Mpqf] | |
| print [Mpzf] | |
| print [Mpfr] | |
| print [Mpf] | |
| print [Mpq] | |
| print [Mpz] | |
| print [Box.Policy] | |
| print [Abstract1] | Print as a set of constraints |
| print [Tcons1] | Print the tree expression constraint |
| print [Texpr1] | Print an abstract tree expression |
| print [Generator1] | Print the generator |
| print [Lincons1] | Print the linear constraint |
| print [Linexpr1] | Print the linear expression |
| print [Environment] | Printing |
| print [Var] | Printing function |
| print [Abstract0] | Print as a set of constraints |
| print [Tcons0] | Print a constraint |
| print [Texpr0] | Print an abstract tree expression, using a function converting from dimensions to names |
| print [Generator0] | Print a generator |
| print [Lincons0] | Print a constraint |
| print [Linexpr0] | Print a linear expression, using a function converting from dimensions to names |
| print [Coeff] | Printing |
| print [Interval] | Print an interval, under the format |
| print [Scalar] | Print a coefficient |
| print0 [Box.Policy] | |
| print1 [Box.Policy] | |
| print_array [Abstract0] | General use |
| print_binop [Texpr1] | |
| print_binop [Texpr0] | |
| print_exc [Manager] | |
| print_exclog [Manager] | Printing functions |
| print_expr [Texpr1] | Print a tree expression |
| print_expr [Texpr0] | Print a tree expression, using a function converting from dimensions to names |
| print_funid [Manager] | |
| print_funopt [Manager] | |
| print_precedence_of_binop [Texpr0] | |
| print_precedence_of_unop [Texpr0] | |
| print_round [Mpfr] | |
| print_round [Texpr1] | |
| print_round [Texpr0] | |
| print_sprint_binop [Texpr0] | |
| print_sprint_unop [Texpr0] | |
| print_typ [Texpr1] | |
| print_typ [Texpr0] | |
| print_unop [Texpr1] | |
| print_unop [Texpr0] | |
| probab_prime_p [Mpz] | |
R | |
| realloc2 [Mpz] | |
| rec_sqrt [Mpfr] | |
| reduce [Coeff] | Convert interval to scalar if possible |
| reldiff [Mpfr] | |
| reldiff [Mpf] | |
| remainder [Mpfr] | |
| remove [Mpz] | |
| remove [Environment] | Remove from an environment a set of variables. |
| remove_dimensions [Abstract0] | |
| remove_dimensions_with [Abstract0] | |
| rename [Environment] | Renaming in an environment a set of variables. |
| rename_array [Abstract1] | Parallel renaming of the environment of the abstract value. |
| rename_array_with [Abstract1] | |
| rename_perm [Environment] | Similar to previous function, but returns also the permutation on dimensions induced by the renaming. |
| rint [Mpfr] | |
| root [Mpfr] | |
| root [Mpz] | |
| rootn_ui [Mpfr] | |
| round [Mpfr] | |
| round_prec [Mpfr] | |
| rrandomb [Gmp_random.Mpz] | |
S | |
| s_of_float [Coeff] | Create an interval coefficient of type |
| s_of_frac [Coeff] | Create a scalar coefficient of type |
| s_of_int [Coeff] | |
| s_of_mpfr [Coeff] | Create an interval coefficient of type |
| s_of_mpq [Coeff] | |
| s_of_mpqf [Coeff] | |
| sat_interval [Abstract1] | Does the abstract value satisfy the constraint |
| sat_interval [Abstract0] | Does the abstract value satisfy the constraint |
| sat_lincons [Abstract1] | Does the abstract value satisfy the linear constraint ? |
| sat_lincons [Abstract0] | Does the abstract value satisfy the linear constraint ? |
| sat_tcons [Abstract1] | Does the abstract value satisfy the tree expression constraint ? |
| sat_tcons [Abstract0] | Does the abstract value satisfy the tree expression constraint ? |
| scan0 [Mpz] | |
| scan1 [Mpz] | |
| sec [Mpfr] | |
| sech [Mpfr] | |
| seed [Gmp_random] | |
| seed_ui [Gmp_random] | |
| set [Mpfr] | |
| set [Mpf] | |
| set [Mpq] | |
| set [Mpz] | |
| set_approximate_max_coeff_size [Polka] | |
| set_array [Generator1] | Set simultaneously a number of coefficients, as |
| set_array [Lincons1] | Set simultaneously a number of coefficients, as |
| set_array [Linexpr1] | Set simultaneously a number of coefficients, as |
| set_array [Linexpr0] | Set simultaneously a number of coefficients, as |
| set_bottom [Interval] | Fill the interval with top (resp. |
| set_coeff [Generator1] | Set the coefficient of the variable in the underlying linear expression |
| set_coeff [Lincons1] | Set the coefficient of the variable in the underlying linear expression |
| set_coeff [Linexpr1] | Set the coefficient of the variable |
| set_coeff [Linexpr0] | Set the coefficient corresponding to the dimension |
| set_cst [Lincons1] | Set the constant of the underlying linear expression |
| set_cst [Linexpr1] | Set the constant |
| set_cst [Linexpr0] | Set the constant |
| set_d [Mpfr] | |
| set_d [Mpf] | |
| set_d [Mpq] | |
| set_d [Mpz] | |
| set_default_prec [Mpfr] | |
| set_default_prec [Mpf] | |
| set_default_rounding_mode [Mpfr] | |
| set_den [Mpq] | |
| set_deserialize [Manager] | Set / get the global manager used for deserialization |
| set_emax [Mpfr] | |
| set_emin [Mpfr] | |
| set_exp [Mpfr] | |
| set_f [Mpfr] | |
| set_funopt [Manager] | Set the options for the function. |
| set_gc [Abstract0] | |
| set_inf [Mpfr] | |
| set_infsup [Interval] | Fill the interval with the given lower and upper bouunds |
| set_list [Generator1] | Set simultaneously a number of coefficients. |
| set_list [Lincons1] | Set simultaneously a number of coefficients. |
| set_list [Linexpr1] | Set simultaneously a number of coefficients. |
| set_list [Linexpr0] | Set simultaneously a number of coefficients. |
| set_max_coeff_size [Polka] | |
| set_nan [Mpfr] | |
| set_num [Mpq] | |
| set_prec [Mpfr] | |
| set_prec [Mpf] | |
| set_prec_raw [Mpfr] | |
| set_prec_raw [Mpf] | |
| set_q [Mpfr] | |
| set_q [Mpf] | |
| set_si [Mpfr] | |
| set_si [Mpf] | |
| set_si [Mpq] | |
| set_si [Mpz] | |
| set_si_2exp [Mpfr] | |
| set_str [Mpfr] | |
| set_str [Mpf] | |
| set_str [Mpq] | |
| set_str [Mpz] | |
| set_top [Interval] | |
| set_typ [Tcons1] | Set the constraint type |
| set_typ [Generator1] | Set the generator type |
| set_typ [Lincons1] | Set the constraint type |
| set_var_operations [Var] | Initialisation of abstract type operations in C library |
| set_z [Mpfr] | |
| set_z [Mpf] | |
| set_z [Mpq] | |
| setbit [Mpz] | |
| sgn [Mpfrf] | |
| sgn [Mpqf] | |
| sgn [Mpzf] | |
| sgn [Mpfr] | |
| sgn [Mpf] | |
| sgn [Mpq] | |
| sgn [Mpz] | |
| sgn [Scalar] | Return the sign of the coefficient, which may be a negative value, zero or a positive value. |
| si_kronecker [Mpz] | |
| signbit [Mpfr] | |
| sin [Mpfr] | |
| sin_cos [Mpfr] | |
| sinh [Mpfr] | |
| size [Mpz] | |
| size [Abstract1] | Return the abstract size of a value |
| size [Environment] | Return the size of the environment |
| size [Abstract0] | Return the abstract size of a value |
| sizeinbase [Mpz] | |
| sprintf [Mpfr] | Call sprintf with the given format string and arguments. |
| sqr [Mpfr] | |
| sqrt [Mpfrf] | |
| sqrt [Mpfr] | |
| sqrt [Mpf] | |
| sqrt [Mpz] | |
| sqrt_ui [Mpfr] | |
| sqrtrem [Mpz] | |
| string_of_binop [Texpr1] | |
| string_of_binop [Texpr0] | |
| string_of_exc [Manager] | |
| string_of_funid [Manager] | |
| string_of_round [Mpfr] | |
| string_of_round [Texpr1] | |
| string_of_round [Texpr0] | |
| string_of_typ [Tcons1] | Convert a constraint type to a string ( |
| string_of_typ [Texpr1] | |
| string_of_typ [Lincons1] | Convert a constraint type to a string ( |
| string_of_typ [Tcons0] | Convert a constraint type to a string ( |
| string_of_typ [Texpr0] | |
| string_of_typ [Generator0] | Convert a generator type to a string ( |
| string_of_typ [Lincons0] | Convert a constraint type to a string ( |
| string_of_unop [Texpr1] | |
| string_of_unop [Texpr0] | |
| strtofr [Mpfr] | As MPFR's strtofr, but returns a pair |
| sub [Mpfrf] | |
| sub [Mpqf] | |
| sub [Mpzf] | |
| sub [Mpfr] | |
| sub [Mpf] | |
| sub [Mpq] | |
| sub [Mpz] | |
| sub_int [Mpfrf] | |
| sub_int [Mpzf] | |
| sub_q [Mpfr] | |
| sub_ui [Mpfr] | |
| sub_ui [Mpf] | |
| sub_ui [Mpz] | |
| sub_z [Mpfr] | |
| submul [Mpz] | |
| submul_ui [Mpz] | |
| subnormalize [Mpfr] | |
| substitute_linexpr [Abstract1] | |
| substitute_linexpr [Abstract0] | |
| substitute_linexpr_array [Abstract1] | Parallel substitution of an array of dimensions by an array of same size of linear expressions |
| substitute_linexpr_array [Abstract0] | Parallel substitution of an array of dimensions by an array of same size of linear expressions |
| substitute_linexpr_array_with [Abstract1] | |
| substitute_linexpr_array_with [Abstract0] | |
| substitute_linexpr_with [Abstract1] | |
| substitute_linexpr_with [Abstract0] | |
| substitute_texpr [Abstract1] | Assignement/Substitution of a single dimension by a single expression |
| substitute_texpr [Abstract0] | Assignement/Substitution of a single dimension by a single expression |
| substitute_texpr_array [Abstract1] | Parallel substitution of an array of dimensions by an array of same size of tree expressions |
| substitute_texpr_array [Abstract0] | Parallel substitution of an array of dimensions by an array of same size of tree expressions |
| substitute_texpr_array_with [Abstract1] | |
| substitute_texpr_array_with [Abstract0] | |
| substitute_texpr_with [Abstract1] | Side-effect version of the previous functions |
| substitute_texpr_with [Abstract0] | Side-effect version of the previous functions |
| swap [Mpfr] | |
| swap [Mpf] | |
| swap [Mpq] | |
| swap [Mpz] | |
T | |
| tan [Mpfr] | |
| tanh [Mpfr] | |
| tcons1_of_lexbuf [Parser] | Conversion from lexing buffers to resp. |
| tcons1_of_lstring [Parser] | Conversion from lists of strings to array of tree constraints. |
| tcons1_of_string [Parser] | Conversion from lexing buffers to resp. |
| tdiv_q [Mpzf] | |
| tdiv_q [Mpz] | |
| tdiv_q_2exp [Mpz] | |
| tdiv_q_ui [Mpz] | |
| tdiv_qr [Mpzf] | |
| tdiv_qr [Mpz] | |
| tdiv_qr_ui [Mpz] | |
| tdiv_r [Mpzf] | |
| tdiv_r [Mpz] | |
| tdiv_r_2exp [Mpz] | |
| tdiv_r_ui [Mpz] | |
| tdiv_ui [Mpz] | |
| texpr1_of_lexbuf [Parser] | |
| texpr1_of_string [Parser] | |
| texpr1expr_of_lexbuf [Parser] | |
| texpr1expr_of_string [Parser] | |
| to_box [Box.Policy] | Instanciate the type of a box value. |
| to_box [Box.Abstract1] | Instanciate the type of a box value. |
| to_box [Box.Abstract0] | Instanciate the type of a box value. |
| to_box [Abstract1] | Convert the abstract value to an hypercube . |
| to_box [Abstract0] | Convert the abstract value to an hypercube. |
| to_disjunction [Disjunction.Abstract1] | Instanciate the type of a disjunction value. |
| to_disjunction [Disjunction.Abstract0] | Instanciate the type of a disjunction value. |
| to_expr [Texpr1] | General destructor |
| to_expr [Texpr0] | General destructor |
| to_float [Mpfrf] | |
| to_float [Mpqf] | |
| to_float [Mpzf] | |
| to_float [Mpfr] | |
| to_float [Mpf] | |
| to_float [Mpq] | |
| to_float [Mpz] | |
| to_generator_array [Abstract1] | Convert the abstract value to a set of generators that defines it. |
| to_generator_array [Abstract0] | Convert the abstract value to a set of generators that defines it. |
| to_lincons0_set [Disjunction] | |
| to_lincons1_set [Disjunction] | |
| to_lincons_array [Abstract1] | Convert the abstract value to a conjunction of linear constraints. |
| to_lincons_array [Abstract0] | Convert the abstract value to a conjunction of linear constraints. |
| to_mpfr [Mpfrf] | |
| to_mpq [Mpqf] | |
| to_mpq [Mpfr] | |
| to_mpqf [Mpfrf] | |
| to_mpz [Mpzf] | |
| to_mpzf2 [Mpqf] | |
| to_oct [Oct.Abstract1] | Instanciate the type of an oct value. |
| to_oct [Oct.Abstract0] | Instanciate the type of an oct value. |
| to_polka [Polka.Abstract1] | |
| to_polka [Polka.Abstract0] | |
| to_polka_equalities [Polka.Abstract1] | Instanciate the type of a polka value. |
| to_polka_equalities [Polka.Abstract0] | Instanciate the type of a polka value. |
| to_polka_loose [Polka.Abstract1] | |
| to_polka_loose [Polka.Abstract0] | |
| to_polka_strict [Polka.Abstract1] | |
| to_polka_strict [Polka.Abstract0] | |
| to_polkagrid [PolkaGrid.Abstract1] | Instanciate the type of a polkagrid value. |
| to_polkagrid [PolkaGrid.Abstract0] | Instanciate the type of a polkagrid value. |
| to_ppl [Ppl.Abstract1] | |
| to_ppl [Ppl.Abstract0] | |
| to_ppl_grid [Ppl.Abstract1] | Instanciate the type of a ppl value. |
| to_ppl_grid [Ppl.Abstract0] | Instanciate the type of a ppl value. |
| to_ppl_loose [Ppl.Abstract1] | |
| to_ppl_loose [Ppl.Abstract0] | |
| to_ppl_strict [Ppl.Abstract1] | |
| to_ppl_strict [Ppl.Abstract0] | |
| to_pplite [Pplite.Abstract1] | |
| to_pplite [Pplite.Abstract0] | |
| to_pplite_loose [Pplite.Abstract1] | |
| to_pplite_loose [Pplite.Abstract0] | |
| to_pplite_strict [Pplite.Abstract1] | Instantiate the type of a PPLite value. |
| to_pplite_strict [Pplite.Abstract0] | Instantiate the type of a PPLite value. |
| to_string [Mpfrf] | |
| to_string [Mpqf] | |
| to_string [Mpzf] | |
| to_string [Mpfr] | |
| to_string [Mpf] | |
| to_string [Mpq] | |
| to_string [Mpz] | |
| to_string [Policy] | |
| to_string [Var] | Conversion to string |
| to_string [Scalar] | Conversion to string, using |
| to_tcons_array [Abstract1] | |
| to_tcons_array [Abstract0] | Convert the abstract value to a conjunction of tree expression constraints. |
| top [Abstract1] | Create a top (universe) value defined on the given environment |
| top [Abstract0] | Create a top (universe) value with the given number of integer and real variables |
| top [Interval] | |
| trunc [Mpfr] | |
| trunc [Mpf] | |
| tstbit [Mpz] | |
| typ_of_var [Environment] | Return the type of variables in the environment. |
U | |
| ui_div [Mpfrf] | |
| ui_div [Mpfr] | |
| ui_div [Mpf] | |
| ui_pow [Mpfrf] | |
| ui_pow [Mpfr] | |
| ui_pow_ui [Mpfr] | |
| ui_pow_ui [Mpz] | |
| ui_sub [Mpfr] | |
| ui_sub [Mpf] | |
| ui_sub [Mpz] | |
| underflow_p [Mpfr] | |
| unify [Abstract1] | Unification of 2 abstract values on their least common environment |
| unify_with [Abstract1] | Side-effect version |
| unop [Texpr1] | |
| unop [Texpr0] | |
| urandom [Gmp_random.Mpfr] | |
| urandomb [Gmp_random.Mpfr] | |
| urandomb [Gmp_random.Mpf] | |
| urandomb [Gmp_random.Mpz] | |
| urandomm [Gmp_random.Mpz] | |
V | |
| var [Texpr1] | |
| var_of_dim [Environment] | Return the variable corresponding to the given dimension in the environment. |
| vars [Environment] | Return the (lexicographically ordered) sets of integer and real variables in the environment |
| version [Version] | |
| version_major [Version] | |
| version_micro [Version] | |
| version_minor [Version] | |
W | |
| widening [Abstract1] | Widening. |
| widening [Abstract0] | Widening. |
| widening_threshold [Abstract1] | |
| widening_threshold [Abstract0] | |
| widening_thresholds [Oct] | Widening with scalar thresholds. |
X | |
| xor [Mpz] | |
Y | |
| y0 [Mpfr] | |
| y1 [Mpfr] | |
| yn [Mpfr] | |
Z | |
| zero_p [Mpfr] | |
| zeta [Mpfr] |