package colibri2

You can search for identifiers within the package.

in-package search v0.2.0

Package contains no libraries

Represents product of sign of nodes

type t

include Colibri2_popop_lib.Popop_stdlib.Datatype with type t := t

include Colibri2_popop_lib.Popop_stdlib.OrderedHashedType with type t := t

val equal : t -> t -> bool

val pp : t Colibri2_popop_lib.Pp.pp

val hash_fold_t : t Base.Hash.folder

module M : Colibri2_popop_lib.Map_intf.PMap with type key = t

module S : 
  Colibri2_popop_lib.Map_intf.Set
    with type 'a M.t = 'a M.t
     and type M.key = M.key

module H : Colibri2_popop_lib.Exthtbl.Hashtbl.S with type key = t

include Base.Hashtbl.Key.S with type t := t

val compare : t Base__Ppx_compare_lib.compare

val sexp_of_t : t -> Sexplib0.Sexp.t

val hash : t -> int

type cst =

| Pos
| Neg

val cst : Colibri2_stdlib.Std.A.t -> t

val of_one_node : Colibri2_core.Node.t -> t

Build a value that represent one node

val of_one_node_non_zero : Colibri2_core.Node.t -> t

Build a value that represent one node when it is known to be non-zero

val is_one_node : t -> Colibri2_core.Node.t option

Test if a value represents one node

val subst : t -> Colibri2_core.Node.t -> t -> t option

subst p n q substitute n by q in p, if n is not in p None is returned, otherwise the result of the substitution is returned

val normalize : t -> f:(Colibri2_core.Node.t -> t) -> t

norm p ~f normalize p using f

type data

An abstract type to avoid translating the map to sets in nodes

val nodes : t -> data Colibri2_core.Node.M.t

nodes t returns the node which are present in t

val mul : t -> t -> t

type extracted =

| Plus_one
| Minus_one
| Zero
| Var of Colibri2_core.Node.t * t
| NoNonZero

val extract : t -> extracted

type extract_cst =

| Pos
| Neg
| Zero

val extract_cst : t -> extract_cst * t

val remove : Colibri2_core.Node.t -> t -> t

val common : t -> t -> t

Return the common part

val one : t

val minus_one : t

val zero : t

val mul_cst : cst -> Colibri2_stdlib.Std.A.t -> Colibri2_stdlib.Std.A.t

type kind =

| PLUS_ONE
| MINUS_ONE
| ZERO
| NODE of cst * Colibri2_core.Node.t
| PRODUCT

val classify : t -> kind

type presolve =

| Zero
| NonZero
| OneNonZero of Colibri2_core.Node.t
| Other

val presolve : t -> presolve