Common (p.mopsa.1.2.doc.mopsa.mopsa_analyzer.Mopsa_analyzer.Languages.Universal.Numeric.Common)

module I = Mopsa_analyzer.MopsaLib.ItvUtils.IntItv

module C = Mopsa_analyzer.MopsaLib.CongUtils.IntCong

Integer intervals

*********************

type int_itv = I.t_with_bot

Integer intervals

type MopsaLib.avalue_kind +=

| V_int_interval : int_itv MopsaLib.avalue_kind
(*
Query to evaluate the integer interval of an expression
*)

type MopsaLib.avalue_kind +=

| V_int_interval_fast : int_itv MopsaLib.avalue_kind
(*
Same as V_int_interval but should be handled by optimized domains, such Boxes
*)

val mk_int_interval_query : 
  ?fast:bool ->
  Framework.Core.Ast.Expr.expr ->
  ('a, int_itv) Framework.Core.Query.query

val pp_int_interval : 
  Format.formatter ->
  I.t Mopsa_utils.Core.Bot.with_bot ->
  unit

val compare_int_interval : 
  I.t Mopsa_utils.Core.Bot.with_bot ->
  I.t Mopsa_utils.Core.Bot.with_bot ->
  int

val constraints_of_itv : 
  MopsaLib.expr ->
  int_itv ->
  Mopsa_utils.Core.Location.range ->
  MopsaLib.expr

Creates var \in itv constraint

Integer intervals with congruence

*************************************

type int_congr_itv = int_itv * C.t_with_bot

Integer step intervals

type MopsaLib.avalue_kind +=

| V_int_congr_interval : int_congr_itv MopsaLib.avalue_kind

Query to evaluate the integer interval of an expression

val mk_int_congr_interval_query : 
  Framework.Core.Ast.Expr.expr ->
  ('a, int_congr_itv) Framework.Core.Query.query

Rounding mode of floats

***************************

val opt_float_rounding : Apron.Texpr1.round ref

val rounding_option_name : string

Float intervals

*******************

module F = Mopsa_analyzer.MopsaLib.ItvUtils.FloatItvNan

type float_itv = F.t

Float intervals

type MopsaLib.avalue_kind +=

| V_float_interval : Universal.Lang.Ast.float_prec -> float_itv MopsaLib.avalue_kind
(*
Query to evaluate the float interval of an expression, with infinities and NaN
*)
| V_float_maybenan : Universal.Lang.Ast.float_prec -> bool MopsaLib.avalue_kind

val mk_float_interval_query : 
  ?prec:Universal.Lang.Ast.float_prec ->
  Framework.Core.Ast.Expr.expr ->
  ('a, float_itv) Framework.Core.Query.query

val mk_float_maybenan_query : 
  ?prec:Universal.Lang.Ast.float_prec ->
  Framework.Core.Ast.Expr.expr ->
  ('a, bool) Framework.Core.Query.query

val pp_float_interval : Format.formatter -> F.t -> unit

val compare_float_interval : F.t -> F.t -> int

val prec : 
  Universal.Lang.Ast.float_prec ->
  Mopsa_analyzer.MopsaLib.ItvUtils.FloatItvNan.prec

val round : unit -> Mopsa_analyzer.MopsaLib.ItvUtils.FloatItvNan.round

Fast assume on numeric conditions

*************************************

val interval_of_num_expr : 
  MopsaLib.expr ->
  ('a, 'b) MopsaLib.man ->
  'a Core.Flow.flow ->
  int_itv

Get the intervals of a numeric expression

val eval_num_cond : 
  Framework.Core.Ast.Expr.expr ->
  ('a, 'b) MopsaLib.man ->
  'a Core.Flow.flow ->
  bool option

Evaluate a numeric condition using intervals

val assume_num : 
  Framework.Core.Ast.Expr.expr ->
  fthen:('a Core.Flow.flow -> ('a, 'b) Core.Cases.cases) ->
  felse:('a Core.Flow.flow -> ('a, 'b) Core.Cases.cases) ->
  ?route:MopsaLib.route ->
  ('a, 'c) MopsaLib.man ->
  'a Core.Flow.flow ->
  ('a, 'b) Mopsa_analyzer.MopsaLib.Cases.cases

Optimized assume function that uses intervals to check a condition or falls back to classic assume

Widening thresholds

***********************

module K : sig ... end

val widening_thresholds_ctx_key : 
  ('a, Mopsa_utils.Containers.SetExt.ZSet.t)
    Mopsa_analyzer__Framework__Core__Context.ctx_key

Key for accessing widening thresholds

val add_widening_threshold : 
  Framework.Core.All.var ->
  Mopsa_utils.Containers.SetExt.ZSet.elt ->
  'a Framework.Core.All.ctx ->
  'a Framework.Core.All.ctx

Add a constant to the widening thresholds of a variable

val remove_widening_thresholds : 
  Framework.Core.All.var ->
  'a Framework.Core.All.ctx ->
  'a Framework.Core.All.ctx

Remove all widening thresholds of a variable