Module `For_int64s.Num`

include Num_common

include Flambda2_algorithms.Container_types.S

type t

module T : Flambda2_algorithms.Container_types_intf.Thing with type t = t

include Flambda2_algorithms.Container_types_intf.Thing with type t := T.t

include Hashtbl.HashedType with type t := T.t

val equal : T.t -> T.t -> bool

The equality predicate used to compare keys.

val hash : T.t -> int

A hashing function on keys. It must be such that if two keys are equal according to equal, then they have identical hash values as computed by hash. Examples: suitable (equal, hash) pairs for arbitrary key types include

((=), hash) for comparing objects by structure (provided objects do not contain floats)
((fun x y -> compare x y = 0), hash) for comparing objects by structure and handling Stdlib.nan correctly
((==), hash) for comparing objects by physical equality (e.g. for mutable or cyclic objects).

include Map.OrderedType with type t := T.t

val compare : T.t -> T.t -> int

A total ordering function over the keys. This is a two-argument function f such that f e1 e2 is zero if the keys e1 and e2 are equal, f e1 e2 is strictly negative if e1 is smaller than e2, and f e1 e2 is strictly positive if e1 is greater than e2. Example: a suitable ordering function is the generic structural comparison function Stdlib.compare.

val print : Format.formatter -> T.t -> unit

module Set : Flambda2_algorithms.Container_types_intf.Set with type elt = t

module Map : 
  Flambda2_algorithms.Container_types_intf.Map
    with type key = t
     and module Set = Set

module Pair : sig ... end

val cross_product : Set.t -> Set.t -> Pair.Set.t

val zero : Target_system.Machine_width.t -> t

val one : Target_system.Machine_width.t -> t

val minus_one : Target_system.Machine_width.t -> t

val add : t -> t -> t

val sub : t -> t -> t

val mul : t -> t -> t

val div : t -> t -> t option

val mod_ : t -> t -> t option

val to_const : t -> Flambda2_identifiers.Reg_width_const.t

val to_immediate : 
  t ->
  Target_system.Machine_width.t ->
  Flambda2_numbers.Target_ocaml_int.t

val to_naked_float32 : 
  t ->
  Flambda2_numbers.Numeric_types.Float32_by_bit_pattern.t

val to_naked_float : t -> Flambda2_numbers.Numeric_types.Float_by_bit_pattern.t

val to_naked_int8 : t -> Flambda2_numbers.Numeric_types.Int8.t

val to_naked_int16 : t -> Flambda2_numbers.Numeric_types.Int16.t

val to_naked_int32 : t -> Flambda2_numbers.Numeric_types.Int32.t

val to_naked_int64 : t -> Flambda2_numbers.Numeric_types.Int64.t

val to_naked_nativeint : 
  t ->
  Target_system.Machine_width.t ->
  Flambda2_numbers.Targetint_32_64.t

val and_ : t -> t -> t

val or_ : t -> t -> t

val xor : t -> t -> t

val shift_left : t -> Flambda2_numbers.Target_ocaml_int.t -> t

val shift_right : t -> Flambda2_numbers.Target_ocaml_int.t -> t

val shift_right_logical : t -> Flambda2_numbers.Target_ocaml_int.t -> t

val swap_byte_endianness : t -> t

val neg : t -> t

val compare_unsigned : t -> t -> int

Module For_int64s.Num

Module `For_int64s.Num`