sig
exception Can_not_subdiv
module F :
sig
type t
val of_float : float -> Ival.F.t
val to_float : Ival.F.t -> float
exception Nan_or_infinite
end
module Float_abstract :
sig
type t
type integer = Abstract_interp.Int.t
exception Nan_or_infinite
exception Bottom
type rounding_mode = Any | Nearest_Even
val inject : Ival.F.t -> Ival.F.t -> Ival.Float_abstract.t
val inject_r : Ival.F.t -> Ival.F.t -> bool * Ival.Float_abstract.t
val min_and_max_float : Ival.Float_abstract.t -> Ival.F.t * Ival.F.t
val top : Ival.Float_abstract.t
val add_float :
Ival.Float_abstract.rounding_mode ->
Ival.Float_abstract.t ->
Ival.Float_abstract.t -> bool * Ival.Float_abstract.t
val sub_float :
Ival.Float_abstract.rounding_mode ->
Ival.Float_abstract.t ->
Ival.Float_abstract.t -> bool * Ival.Float_abstract.t
val mult_float :
Ival.Float_abstract.rounding_mode ->
Ival.Float_abstract.t ->
Ival.Float_abstract.t -> bool * Ival.Float_abstract.t
val div_float :
Ival.Float_abstract.rounding_mode ->
Ival.Float_abstract.t ->
Ival.Float_abstract.t -> bool * Ival.Float_abstract.t
val contains_zero : Ival.Float_abstract.t -> bool
val compare : Ival.Float_abstract.t -> Ival.Float_abstract.t -> int
val pretty : Format.formatter -> Ival.Float_abstract.t -> unit
val hash : Ival.Float_abstract.t -> int
val zero : Ival.Float_abstract.t
val is_included :
Ival.Float_abstract.t -> Ival.Float_abstract.t -> bool
val join :
Ival.Float_abstract.t ->
Ival.Float_abstract.t -> Ival.Float_abstract.t
val meet :
Ival.Float_abstract.t ->
Ival.Float_abstract.t -> Ival.Float_abstract.t
val contains_a_zero : Ival.Float_abstract.t -> bool
val is_zero : Ival.Float_abstract.t -> bool
val is_singleton : Ival.Float_abstract.t -> bool
val neg_float : Ival.Float_abstract.t -> Ival.Float_abstract.t
val sqrt_float :
Ival.Float_abstract.rounding_mode ->
Ival.Float_abstract.t -> bool * Ival.Float_abstract.t
val minus_one_one : Ival.Float_abstract.t
val cos_float : Ival.Float_abstract.t -> Ival.Float_abstract.t
val widen :
Ival.Float_abstract.t ->
Ival.Float_abstract.t -> Ival.Float_abstract.t
val equal_float_ieee :
Ival.Float_abstract.t -> Ival.Float_abstract.t -> bool * bool
val maybe_le_ieee_float :
Ival.Float_abstract.t -> Ival.Float_abstract.t -> bool
val maybe_lt_ieee_float :
Ival.Float_abstract.t -> Ival.Float_abstract.t -> bool
val diff :
Ival.Float_abstract.t ->
Ival.Float_abstract.t -> Ival.Float_abstract.t
val filter_le :
Ival.Float_abstract.t ->
Ival.Float_abstract.t -> Ival.Float_abstract.t
val filter_ge :
Ival.Float_abstract.t ->
Ival.Float_abstract.t -> Ival.Float_abstract.t
val filter_lt :
Ival.Float_abstract.t ->
Ival.Float_abstract.t -> Ival.Float_abstract.t
val filter_gt :
Ival.Float_abstract.t ->
Ival.Float_abstract.t -> Ival.Float_abstract.t
end
module O :
sig
type elt = Abstract_interp.Int.t
type t
val empty : Ival.O.t
val is_empty : Ival.O.t -> bool
val mem : Ival.O.elt -> Ival.O.t -> bool
val add : Ival.O.elt -> Ival.O.t -> Ival.O.t
val singleton : Ival.O.elt -> Ival.O.t
val remove : Ival.O.elt -> Ival.O.t -> Ival.O.t
val union : Ival.O.t -> Ival.O.t -> Ival.O.t
val inter : Ival.O.t -> Ival.O.t -> Ival.O.t
val diff : Ival.O.t -> Ival.O.t -> Ival.O.t
val compare : Ival.O.t -> Ival.O.t -> int
val equal : Ival.O.t -> Ival.O.t -> bool
val subset : Ival.O.t -> Ival.O.t -> bool
val iter : (Ival.O.elt -> unit) -> Ival.O.t -> unit
val fold : (Ival.O.elt -> 'a -> 'a) -> Ival.O.t -> 'a -> 'a
val for_all : (Ival.O.elt -> bool) -> Ival.O.t -> bool
val exists : (Ival.O.elt -> bool) -> Ival.O.t -> bool
val filter : (Ival.O.elt -> bool) -> Ival.O.t -> Ival.O.t
val partition : (Ival.O.elt -> bool) -> Ival.O.t -> Ival.O.t * Ival.O.t
val cardinal : Ival.O.t -> int
val elements : Ival.O.t -> Ival.O.elt list
val min_elt : Ival.O.t -> Ival.O.elt
val max_elt : Ival.O.t -> Ival.O.elt
val choose : Ival.O.t -> Ival.O.elt
val split : Ival.O.elt -> Ival.O.t -> Ival.O.t * bool * Ival.O.t
end
type tt =
Set of Ival.O.t
| Float of Ival.Float_abstract.t
| Top of Abstract_interp.Int.t option * Abstract_interp.Int.t option *
Abstract_interp.Int.t * Abstract_interp.Int.t
module Widen_Hints :
sig
module V :
sig
type t = Abstract_interp.Int.t
val ty : t Type.t
val name : string
val descr : t Descr.t
val packed_descr : Structural_descr.pack
val reprs : t list
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pretty_code : Format.formatter -> t -> unit
val internal_pretty_code :
Type.precedence -> Format.formatter -> t -> unit
val pretty : Format.formatter -> t -> unit
val varname : t -> string
val mem_project : (Project_skeleton.t -> bool) -> t -> bool
val copy : t -> t
val gt : t -> t -> bool
val le : t -> t -> bool
val ge : t -> t -> bool
val lt : t -> t -> bool
val add : t -> t -> t
val sub : t -> t -> t
val mul : t -> t -> t
val native_div : t -> t -> t
val rem : t -> t -> t
val pos_div : t -> t -> t
val c_div : t -> t -> t
val c_rem : t -> t -> t
val cast : size:t -> signed:bool -> value:t -> t
val abs : t -> t
val zero : t
val one : t
val two : t
val four : t
val minus_one : t
val is_zero : t -> bool
val is_one : t -> bool
val pgcd : t -> t -> t
val ppcm : t -> t -> t
val min : t -> t -> t
val max : t -> t -> t
val length : t -> t -> t
val of_int : int -> t
val of_float : float -> t
val of_int64 : Int64.t -> t
val to_int : t -> int
val to_float : t -> float
val neg : t -> t
val succ : t -> t
val pred : t -> t
val round_up_to_r : min:t -> r:t -> modu:t -> t
val round_down_to_r : max:t -> r:t -> modu:t -> t
val pos_rem : t -> t -> t
val shift_left : t -> t -> t
val shift_right : t -> t -> t
val fold : (t -> 'a -> 'a) -> inf:t -> sup:t -> step:t -> 'a -> 'a
val logand : t -> t -> t
val logor : t -> t -> t
val logxor : t -> t -> t
val lognot : t -> t
val power_two : int -> t
val two_power : t -> t
val extract_bits : start:t -> stop:t -> t -> t
end
type elt = Ival.Widen_Hints.V.t
type t
val ty : t Type.t
val name : string
val descr : t Descr.t
val packed_descr : Structural_descr.pack
val reprs : t list
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pretty_code : Format.formatter -> t -> unit
val internal_pretty_code :
Type.precedence -> Format.formatter -> t -> unit
val pretty : Format.formatter -> t -> unit
val varname : t -> string
val mem_project : (Project_skeleton.t -> bool) -> t -> bool
val copy : t -> t
val empty : t
val is_empty : t -> bool
val mem : Ival.Widen_Hints.elt -> t -> bool
val add : Ival.Widen_Hints.elt -> t -> t
val singleton : Ival.Widen_Hints.elt -> t
val remove : Ival.Widen_Hints.elt -> t -> t
val union : t -> t -> t
val inter : t -> t -> t
val diff : t -> t -> t
val subset : t -> t -> bool
val iter : (Ival.Widen_Hints.elt -> unit) -> t -> unit
val fold : (Ival.Widen_Hints.elt -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (Ival.Widen_Hints.elt -> bool) -> t -> bool
val exists : (Ival.Widen_Hints.elt -> bool) -> t -> bool
val filter : (Ival.Widen_Hints.elt -> bool) -> t -> t
val partition : (Ival.Widen_Hints.elt -> bool) -> t -> t * t
val cardinal : t -> int
val elements : t -> Ival.Widen_Hints.elt list
val min_elt : t -> Ival.Widen_Hints.elt
val max_elt : t -> Ival.Widen_Hints.elt
val choose : t -> Ival.Widen_Hints.elt
val split : Ival.Widen_Hints.elt -> t -> t * bool * t
val nearest_elt_le : Ival.Widen_Hints.elt -> t -> Ival.Widen_Hints.elt
val nearest_elt_ge : Ival.Widen_Hints.elt -> t -> Ival.Widen_Hints.elt
val default_widen_hints : t
end
exception Error_Top
exception Error_Bottom
type t = tt
val ty : t Type.t
val name : string
val descr : t Descr.t
val packed_descr : Structural_descr.pack
val reprs : t list
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pretty_code : Format.formatter -> t -> unit
val internal_pretty_code : Type.precedence -> Format.formatter -> t -> unit
val pretty : Format.formatter -> t -> unit
val varname : t -> string
val mem_project : (Project_skeleton.t -> bool) -> t -> bool
val copy : t -> t
type widen_hint = Ival.Widen_Hints.t
val join : t -> t -> t
val link : t -> t -> t
val meet : t -> t -> t
val narrow : t -> t -> t
val bottom : t
val top : t
val is_included : t -> t -> bool
val is_included_exn : t -> t -> unit
val intersects : t -> t -> bool
val widen : Ival.widen_hint -> t -> t -> t
val fold_enum :
split_non_enumerable:int -> (t -> 'a -> 'a) -> t -> 'a -> 'a
val diff : t -> t -> t
val diff_if_one : t -> t -> t
val add : t -> t -> t
val neg : t -> t
val sub : t -> t -> t
val min_int : t -> Abstract_interp.Int.t option
val max_int : t -> Abstract_interp.Int.t option
val min_max_r_mod :
t ->
Abstract_interp.Int.t option * Abstract_interp.Int.t option *
Abstract_interp.Int.t * Abstract_interp.Int.t
val min_and_max :
t -> Abstract_interp.Int.t option * Abstract_interp.Int.t option
val bitwise_and : size:int -> signed:bool -> t -> t -> t
val bitwise_or : size:int -> t -> t -> t
val inject_range :
Abstract_interp.Int.t option -> Abstract_interp.Int.t option -> t
val all_positives : Abstract_interp.Int.t option -> bool
val all_negatives : Abstract_interp.Int.t option -> bool
val cardinal_zero_or_one : t -> bool
val is_singleton_int : t -> bool
val inject_singleton : Abstract_interp.Int.t -> t
val zero : t
val one : t
val compare_min_float : t -> t -> int
val compare_max_float : t -> t -> int
val compare_min_int : t -> t -> int
val compare_max_int : t -> t -> int
val is_zero : t -> bool
val is_one : t -> bool
val inject_float : Ival.Float_abstract.t -> t
val top_float : t
val top_single_precision_float : t
val project_float : t -> Ival.Float_abstract.t
val in_interval :
Abstract_interp.Int.t ->
Abstract_interp.Int.t option ->
Abstract_interp.Int.t option ->
Abstract_interp.Int.t -> Abstract_interp.Int.t -> bool
val contains_zero : t -> bool
exception Not_Singleton_Int
val project_int : t -> Abstract_interp.Int.t
val cardinal_less_than : t -> int -> int
val splitting_cardinal_less_than :
split_non_enumerable:int -> t -> int -> int
val inject_top :
Abstract_interp.Int.t option ->
Abstract_interp.Int.t option ->
Abstract_interp.Int.t -> Abstract_interp.Int.t -> t
val fold : (Abstract_interp.Int.t -> 'a -> 'a) -> t -> 'a -> 'a
exception Apply_Set_Exn of exn
val apply_set :
string ->
(Abstract_interp.Int.t -> Abstract_interp.Int.t -> Abstract_interp.Int.t) ->
t -> t -> t
val apply_set_unary :
'a -> (Abstract_interp.Int.t -> Abstract_interp.Int.t) -> t -> t
val singleton_zero : t
val singleton_one : t
val zero_or_one : t
val contains_non_zero : t -> bool
val subdiv_float_interval : t -> t * t
val scale : Abstract_interp.Int.t -> t -> t
val scale_div : pos:bool -> Abstract_interp.Int.t -> t -> t
val negative : t
val div : t -> t -> t
val scale_rem : pos:bool -> Abstract_interp.Int.t -> t -> t
val c_rem : t -> t -> t
val mul : t -> t -> t
val shift_left : size:Abstract_interp.Int.t -> t -> t -> t
val shift_right : size:Abstract_interp.Int.t -> t -> t -> t
val interp_boolean : contains_zero:bool -> contains_non_zero:bool -> t
val filter_set : (int -> bool) -> Abstract_interp.Int.t -> Ival.O.t -> t
val extract_bits :
start:Abstract_interp.Int.t -> stop:Abstract_interp.Int.t -> t -> t
val create_all_values :
modu:Abstract_interp.Int.t -> signed:bool -> size:int -> t
val all_values : size:Abstract_interp.Int.t -> t -> bool
val filter_le_int : Abstract_interp.Int.t option -> t -> t
val filter_ge_int : Abstract_interp.Int.t option -> t -> t
val filter_lt_int : Abstract_interp.Int.t option -> t -> t
val filter_gt_int : Abstract_interp.Int.t option -> t -> t
val filter_le : t -> t -> t
val filter_ge : t -> t -> t
val filter_lt : t -> t -> t
val filter_gt : t -> t -> t
val filter_le_float : t -> t -> t
val filter_ge_float : t -> t -> t
val filter_lt_float : t -> t -> t
val filter_gt_float : t -> t -> t
val compare_C :
(Abstract_interp.Int.t option ->
Abstract_interp.Int.t option ->
Abstract_interp.Int.t option -> Abstract_interp.Int.t option -> 'a) ->
t -> t -> 'a
val max_max :
Abstract_interp.Int.t option ->
Abstract_interp.Int.t option -> Abstract_interp.Int.t option
val scale_int64base : Int_Base.tt -> t -> t
val cast_float_to_int : Ival.Float_abstract.t -> t
val of_int : int -> t
val of_int64 : int64 -> t
val cast_int_to_float : Ival.Float_abstract.rounding_mode -> t -> bool * t
val cast : size:Abstract_interp.Int.t -> signed:bool -> value:t -> t
val cast_float : t -> bool * t
val tag : t -> int
val pretty_debug : Format.formatter -> t -> unit
end