Module Apronext.Apol

include sig ... end
module A = Apron.Abstract1
module G = Generatorext
module T = Tconsext
module L = Linconsext
module E = Environmentext
module I = Intervalext
type t = Polka.strict Polka.t A.t
type box1 = A.box1 = {
  1. mutable interval_array : I.t array;
  2. mutable box1_env : E.t;
}
type policy =
  1. | Fail
  2. | Meet
val bottom : Environmentext.t -> t
val top : Environmentext.t -> t
val join : ?merge:policy -> Polka.strict Polka.t A.t -> Polka.strict Polka.t A.t -> Polka.strict Polka.t A.t
val meet : ?merge:policy -> Polka.strict Polka.t A.t -> Polka.strict Polka.t A.t -> Polka.strict Polka.t A.t
val widening : t -> t -> t
val is_bottom : t -> bool
val is_top : t -> bool
val is_leq : t -> t -> bool
val is_eq : t -> t -> bool
val sat_lincons : t -> Linconsext.t -> bool
val sat_tcons : t -> Tconsext.t -> bool
val filter_lincons : t -> Linconsext.t -> t
val filter_tcons : t -> Tconsext.t -> t
val to_lincons_array : t -> Linconsext.earray
val to_tcons_array : t -> Tconsext.earray
val to_generator_array : t -> Generatorext.earray
val to_lincons_list : t -> L.t list
val to_tcons_list : t -> T.t list
val to_generator_list : t -> G.t list
val of_generator_list : Generatorext.t list -> t
val of_generator_array : G.earray -> t
val of_lincons_array : Environmentext.t -> Apron.Lincons1.earray -> t
val of_tcons_array : Environmentext.t -> Apron.Tcons1.earray -> t
val of_lincons_list : Environmentext.t -> L.t list -> t
val of_tcons_list : Environmentext.t -> T.t list -> t
val of_box : Environmentext.t -> Apron.Var.t array -> Intervalext.t array -> t
val get_environment : t -> Environmentext.t
val change_environment : t -> Apron.Environment.t -> t
val assign_texpr : t -> Apron.Var.t -> Apron.Texpr1.t -> t
val assign_linexpr : t -> Apron.Var.t -> Apron.Linexpr1.t -> t
val assign_interval : t -> Apron.Var.t -> Apron.Interval.t -> t
val assign_f : t -> Apron.Var.t -> float -> t
val assign_fs : t -> string -> float -> t
val add_var : t -> Apron.Environment.typvar -> Apron.Var.t -> t
val add_var_s : t -> Apron.Environment.typvar -> string -> t
val bound_variable : t -> Apron.Var.t -> Apron.Interval.t
val bound_variable_f : t -> Apron.Var.t -> float * float
val bound_variable_s : t -> string -> Apron.Interval.t
val bound_variable_fs : t -> string -> float * float
val is_bounded_variable : t -> Apron.Var.t -> bool
val is_bounded_s : t -> string -> bool
val is_bounded : t -> bool
val to_box1 : Polka.strict Polka.t A.t -> A.box1
val to_box : t -> Box.t A.t
val to_oct : t -> Oct.t A.t
val to_poly : t -> Polka.strict Polka.t A.t
val print : Stdlib.Format.formatter -> 'a A.t -> unit
val pp_print : Stdlib.Format.formatter -> t -> unit
val proj2D : t -> Apron.Var.t -> Apron.Var.t -> t
val proj3D : t -> Apron.Var.t -> Apron.Var.t -> Apron.Var.t -> t
val proj2D_s : t -> string -> string -> t
val proj3D_s : t -> string -> string -> string -> t
val to_vertices2D : t -> Apron.Var.t -> Apron.Var.t -> (float * float) list
val to_vertices2D_s : t -> string -> string -> (float * float) list
val diff : t -> t -> t list

set difference

val join_irredundant : t -> t -> t list

symbolic join with irredundant result (no overlapp)

val weak_join : t -> t -> t

weaker join operator in linear time

val to_simplices : t -> t list

decomposes a polyhedron p into a list of simplices p1;p2 ... pn s.t (join p1 (join p2 (... (join pn-1 pn)))) = p and all pi are simplices ie, their number of generator is less or equal to the number of dimensions + 1