orgeat 0.0.1 · OCaml Package

Parameters

module K : Smol.Algebra.Ring_S

Signature

type t = K.t p

val zero : 'a p

val is_zero : t -> bool

val one : t

val of_scalar : K.t -> t

val to_scalar : t -> K.t

val to_scalar_opt : t -> K.t option

val of_literal : Literal.Variable.t -> t

val of_monomial : Smol.Monomial.Make(Literal.Variable).t -> t

val singleton : Smol.Monomial.Make(Literal.Variable).t -> K.t -> t

val flatten : t p -> t

val get_support : t -> Literal.Variable.t list

val equal : t -> t -> bool

val deg : Literal.Variable.t -> t -> int

val add : t -> t -> t

val mul_scalar : K.t -> t -> t

val mul : t -> t -> t

val leading_coef : Literal.Variable.t -> t -> t * int

val apply_raw : 
  (module Smol.Algebra.Mul_Monoid_S with type t = 'a) ->
  (module Smol.Algebra.Semiring_S with type t = 'b) ->
  (K.t -> 'a -> 'b) ->
  'a Map.Make(Literal.Variable).t ->
  t ->
  'b p

val apply : 
  (module Smol.Algebra.Semiring_S with type t = 'a) ->
  (K.t -> 'a -> 'a) ->
  'a Map.Make(Literal.Variable).t ->
  t ->
  'a p

val eval : K.t Map.Make(Literal.Variable).t -> t -> t

val substitution : t Map.Make(Literal.Variable).t -> t -> t

val apply_at_0 : t -> K.t

val deriv : Literal.Variable.t -> t -> (int * K.t) p

val to_string : t -> string

val map : ('a -> K.t) -> 'a p -> t

val mapi : (Smol.Monomial.Make(Literal.Variable).t -> 'a -> K.t) -> 'a p -> t

val merge : 
  (Smol.Monomial.Make(Literal.Variable).t -> 'a option -> 'b option -> K.t) ->
  'a p ->
  'b p ->
  t

val mem : Smol.Monomial.Make(Literal.Variable).t -> 'a p -> bool

val set_coef : Smol.Monomial.Make(Literal.Variable).t -> K.t -> t -> t

val update : Smol.Monomial.Make(Literal.Variable).t -> (K.t -> K.t) -> t -> t

val remove : Smol.Monomial.Make(Literal.Variable).t -> 'a p -> 'a p

val union : 
  (Smol.Monomial.Make(Literal.Variable).t -> K.t -> K.t -> K.t) ->
  t ->
  t ->
  t

val compare : ('a -> 'a -> int) -> 'a p -> 'a p -> int

val iter : 
  (Smol.Monomial.Make(Literal.Variable).t -> 'a -> unit) ->
  'a p ->
  unit

val fold : 
  (Smol.Monomial.Make(Literal.Variable).t -> 'a -> 'b -> 'b) ->
  'a p ->
  'b ->
  'b

val for_all : 
  (Smol.Monomial.Make(Literal.Variable).t -> 'a -> bool) ->
  'a p ->
  bool

val exists : 
  (Smol.Monomial.Make(Literal.Variable).t -> 'a -> bool) ->
  'a p ->
  bool

val filter : 
  (Smol.Monomial.Make(Literal.Variable).t -> 'a -> bool) ->
  'a p ->
  'a p

val partition : 
  (Smol.Monomial.Make(Literal.Variable).t -> 'a -> bool) ->
  'a p ->
  'a p * 'a p

val cardinal : 'a p -> int

val bindings : 'a p -> (Smol.Monomial.Make(Literal.Variable).t * 'a) list

val get_coef : Smol.Monomial.Make(Literal.Variable).t -> t -> K.t

val to_seq : 'a p -> (Smol.Monomial.Make(Literal.Variable).t * 'a) Seq.t

val add_seq : (Smol.Monomial.Make(Literal.Variable).t * K.t) Seq.t -> t -> t

val of_seq : (Smol.Monomial.Make(Literal.Variable).t * K.t) Seq.t -> t

val neg : t -> t

val sub : t -> t -> t

val partial_div_euclid : Literal.Variable.t -> t -> t -> t * t * t * int

val partial_gcd : Literal.Variable.t -> t -> t -> t

module Infix : sig ... end

package orgeat

Parameters

Signature