diff --git a/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/Q/index.html b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/Q/index.html index 6a8ac36b..0e01653d 100644 --- a/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/Q/index.html +++ b/dev/sidekick-base/Sidekick_base_solver/Th_lra/A/Q/index.html @@ -1,2 +1,2 @@ -Q (sidekick-base.Sidekick_base_solver.Th_lra.A.Q)

Module A.Q

type t = Q.t
val zero : t
val one : t
val minus_one : t
val sign : t -> int
val of_int : int -> t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t CCFormat.printer
val (+) : t -> t -> t
val (-) : t -> t -> t
val (*) : t -> t -> t
val (~-) : t -> t
val neg : t -> t
val min : t -> t -> t
val max : t -> t -> t
val (=) : t -> t -> bool
val (<>) : t -> t -> bool
val (>) : t -> t -> bool
val (>=) : t -> t -> bool
val (<) : t -> t -> bool
val (<=) : t -> t -> bool
type bigint = Z.t
val (/) : t -> t -> t
val num : t -> bigint
val denum : t -> bigint
val pp_approx : int -> Stdlib.Format.formatter -> t -> unit
\ No newline at end of file +Q (sidekick-base.Sidekick_base_solver.Th_lra.A.Q)

Module A.Q

type t = Q.t
val zero : t
val one : t
val minus_one : t
val sign : t -> int
val of_int : int -> t
val equal : t -> t -> bool
val compare : t -> t -> int
val hash : t -> int
val pp : t CCFormat.printer
val (+) : t -> t -> t
val (-) : t -> t -> t
val (*) : t -> t -> t
val (~-) : t -> t
val neg : t -> t
val min : t -> t -> t
val max : t -> t -> t
val (=) : t -> t -> bool
val (<>) : t -> t -> bool
val (>) : t -> t -> bool
val (>=) : t -> t -> bool
val (<) : t -> t -> bool
val (<=) : t -> t -> bool
type bigint = Z.t
val (/) : t -> t -> t
val num : t -> bigint
val denum : t -> bigint
val infinity : t
val minus_infinity : t
val is_real : t -> bool
val pp_approx : int -> Stdlib.Format.formatter -> t -> unit
\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith/module-type-RATIONAL/index.html b/dev/sidekick/Sidekick_arith/module-type-RATIONAL/index.html index 4c4e3946..13a40332 100644 --- a/dev/sidekick/Sidekick_arith/module-type-RATIONAL/index.html +++ b/dev/sidekick/Sidekick_arith/module-type-RATIONAL/index.html @@ -1,2 +1,2 @@ -RATIONAL (sidekick.Sidekick_arith.RATIONAL)

Module type Sidekick_arith.RATIONAL

include NUM
type t
val zero : t
val one : t
val minus_one : t
val sign : t -> int
val of_int : int -> t
include Sidekick_sigs.EQ with type t := t
val equal : t -> t -> bool
include Sidekick_sigs.ORD with type t := t
val compare : t -> t -> int
include Sidekick_sigs.HASH with type t := t
val hash : t -> int
include Sidekick_sigs.PRINT with type t := t
val pp : t CCFormat.printer
val (+) : t -> t -> t
val (-) : t -> t -> t
val (*) : t -> t -> t
val (~-) : t -> t
val neg : t -> t
val min : t -> t -> t
val max : t -> t -> t
val (=) : t -> t -> bool
val (<>) : t -> t -> bool
val (>) : t -> t -> bool
val (>=) : t -> t -> bool
val (<) : t -> t -> bool
val (<=) : t -> t -> bool
type bigint
val (/) : t -> t -> t
val num : t -> bigint
val denum : t -> bigint
val pp_approx : int -> Stdlib.Format.formatter -> t -> unit

Pretty print rational with given amount of precision (for example as a floating point number)

\ No newline at end of file +RATIONAL (sidekick.Sidekick_arith.RATIONAL)

Module type Sidekick_arith.RATIONAL

include NUM
type t
val zero : t
val one : t
val minus_one : t
val sign : t -> int
val of_int : int -> t
include Sidekick_sigs.EQ with type t := t
val equal : t -> t -> bool
include Sidekick_sigs.ORD with type t := t
val compare : t -> t -> int
include Sidekick_sigs.HASH with type t := t
val hash : t -> int
include Sidekick_sigs.PRINT with type t := t
val pp : t CCFormat.printer
val (+) : t -> t -> t
val (-) : t -> t -> t
val (*) : t -> t -> t
val (~-) : t -> t
val neg : t -> t
val min : t -> t -> t
val max : t -> t -> t
val (=) : t -> t -> bool
val (<>) : t -> t -> bool
val (>) : t -> t -> bool
val (>=) : t -> t -> bool
val (<) : t -> t -> bool
val (<=) : t -> t -> bool
type bigint
val (/) : t -> t -> t
val num : t -> bigint
val denum : t -> bigint
val infinity : t

+infinity

val minus_infinity : t
val is_real : t -> bool

A proper real, not nan/infinity

val pp_approx : int -> Stdlib.Format.formatter -> t -> unit

Pretty print rational with given amount of precision (for example as a floating point number)

\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lra/Make/argument-1-A/Q/index.html b/dev/sidekick/Sidekick_arith_lra/Make/argument-1-A/Q/index.html index d28f554a..dcf3f304 100644 --- a/dev/sidekick/Sidekick_arith_lra/Make/argument-1-A/Q/index.html +++ b/dev/sidekick/Sidekick_arith_lra/Make/argument-1-A/Q/index.html @@ -1,2 +1,2 @@ -Q (sidekick.Sidekick_arith_lra.Make.1-A.Q)

Module 1-A.Q

include Sidekick_arith.NUM
type t
val zero : t
val one : t
val minus_one : t
val sign : t -> int
val of_int : int -> t
include Sidekick_sigs.EQ with type t := t
val equal : t -> t -> bool
include Sidekick_sigs.ORD with type t := t
val compare : t -> t -> int
include Sidekick_sigs.HASH with type t := t
val hash : t -> int
include Sidekick_sigs.PRINT with type t := t
val pp : t CCFormat.printer
val (+) : t -> t -> t
val (-) : t -> t -> t
val (*) : t -> t -> t
val (~-) : t -> t
val neg : t -> t
val min : t -> t -> t
val max : t -> t -> t
val (=) : t -> t -> bool
val (<>) : t -> t -> bool
val (>) : t -> t -> bool
val (>=) : t -> t -> bool
val (<) : t -> t -> bool
val (<=) : t -> t -> bool
type bigint
val (/) : t -> t -> t
val num : t -> bigint
val denum : t -> bigint
val pp_approx : int -> Stdlib.Format.formatter -> t -> unit

Pretty print rational with given amount of precision (for example as a floating point number)

\ No newline at end of file +Q (sidekick.Sidekick_arith_lra.Make.1-A.Q)

Module 1-A.Q

include Sidekick_arith.NUM
type t
val zero : t
val one : t
val minus_one : t
val sign : t -> int
val of_int : int -> t
include Sidekick_sigs.EQ with type t := t
val equal : t -> t -> bool
include Sidekick_sigs.ORD with type t := t
val compare : t -> t -> int
include Sidekick_sigs.HASH with type t := t
val hash : t -> int
include Sidekick_sigs.PRINT with type t := t
val pp : t CCFormat.printer
val (+) : t -> t -> t
val (-) : t -> t -> t
val (*) : t -> t -> t
val (~-) : t -> t
val neg : t -> t
val min : t -> t -> t
val max : t -> t -> t
val (=) : t -> t -> bool
val (<>) : t -> t -> bool
val (>) : t -> t -> bool
val (>=) : t -> t -> bool
val (<) : t -> t -> bool
val (<=) : t -> t -> bool
type bigint
val (/) : t -> t -> t
val num : t -> bigint
val denum : t -> bigint
val infinity : t

+infinity

val minus_infinity : t
val is_real : t -> bool

A proper real, not nan/infinity

val pp_approx : int -> Stdlib.Format.formatter -> t -> unit

Pretty print rational with given amount of precision (for example as a floating point number)

\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lra/Simplex2/Make/argument-1-Q/index.html b/dev/sidekick/Sidekick_arith_lra/Simplex2/Make/argument-1-Q/index.html index 47c15b74..a461fc77 100644 --- a/dev/sidekick/Sidekick_arith_lra/Simplex2/Make/argument-1-Q/index.html +++ b/dev/sidekick/Sidekick_arith_lra/Simplex2/Make/argument-1-Q/index.html @@ -1,2 +1,2 @@ -Q (sidekick.Sidekick_arith_lra.Simplex2.Make.1-Q)

Parameter Make.1-Q

include Sidekick_arith.NUM
type t
val zero : t
val one : t
val minus_one : t
val sign : t -> int
val of_int : int -> t
include Sidekick_sigs.EQ with type t := t
val equal : t -> t -> bool
include Sidekick_sigs.ORD with type t := t
val compare : t -> t -> int
include Sidekick_sigs.HASH with type t := t
val hash : t -> int
include Sidekick_sigs.PRINT with type t := t
val pp : t CCFormat.printer
val (+) : t -> t -> t
val (-) : t -> t -> t
val (*) : t -> t -> t
val (~-) : t -> t
val neg : t -> t
val min : t -> t -> t
val max : t -> t -> t
val (=) : t -> t -> bool
val (<>) : t -> t -> bool
val (>) : t -> t -> bool
val (>=) : t -> t -> bool
val (<) : t -> t -> bool
val (<=) : t -> t -> bool
type bigint
val (/) : t -> t -> t
val num : t -> bigint
val denum : t -> bigint
val pp_approx : int -> Stdlib.Format.formatter -> t -> unit

Pretty print rational with given amount of precision (for example as a floating point number)

\ No newline at end of file +Q (sidekick.Sidekick_arith_lra.Simplex2.Make.1-Q)

Parameter Make.1-Q

include Sidekick_arith.NUM
type t
val zero : t
val one : t
val minus_one : t
val sign : t -> int
val of_int : int -> t
include Sidekick_sigs.EQ with type t := t
val equal : t -> t -> bool
include Sidekick_sigs.ORD with type t := t
val compare : t -> t -> int
include Sidekick_sigs.HASH with type t := t
val hash : t -> int
include Sidekick_sigs.PRINT with type t := t
val pp : t CCFormat.printer
val (+) : t -> t -> t
val (-) : t -> t -> t
val (*) : t -> t -> t
val (~-) : t -> t
val neg : t -> t
val min : t -> t -> t
val max : t -> t -> t
val (=) : t -> t -> bool
val (<>) : t -> t -> bool
val (>) : t -> t -> bool
val (>=) : t -> t -> bool
val (<) : t -> t -> bool
val (<=) : t -> t -> bool
type bigint
val (/) : t -> t -> t
val num : t -> bigint
val denum : t -> bigint
val infinity : t

+infinity

val minus_infinity : t
val is_real : t -> bool

A proper real, not nan/infinity

val pp_approx : int -> Stdlib.Format.formatter -> t -> unit

Pretty print rational with given amount of precision (for example as a floating point number)

\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lra/Simplex2/module-type-S/Q/index.html b/dev/sidekick/Sidekick_arith_lra/Simplex2/module-type-S/Q/index.html index 575f2568..2ab16776 100644 --- a/dev/sidekick/Sidekick_arith_lra/Simplex2/module-type-S/Q/index.html +++ b/dev/sidekick/Sidekick_arith_lra/Simplex2/module-type-S/Q/index.html @@ -1,2 +1,2 @@ -Q (sidekick.Sidekick_arith_lra.Simplex2.S.Q)

Module S.Q

include Sidekick_arith.NUM
type t
val zero : t
val one : t
val minus_one : t
val sign : t -> int
val of_int : int -> t
include Sidekick_sigs.EQ with type t := t
val equal : t -> t -> bool
include Sidekick_sigs.ORD with type t := t
val compare : t -> t -> int
include Sidekick_sigs.HASH with type t := t
val hash : t -> int
include Sidekick_sigs.PRINT with type t := t
val pp : t CCFormat.printer
val (+) : t -> t -> t
val (-) : t -> t -> t
val (*) : t -> t -> t
val (~-) : t -> t
val neg : t -> t
val min : t -> t -> t
val max : t -> t -> t
val (=) : t -> t -> bool
val (<>) : t -> t -> bool
val (>) : t -> t -> bool
val (>=) : t -> t -> bool
val (<) : t -> t -> bool
val (<=) : t -> t -> bool
type bigint
val (/) : t -> t -> t
val num : t -> bigint
val denum : t -> bigint
val pp_approx : int -> Stdlib.Format.formatter -> t -> unit

Pretty print rational with given amount of precision (for example as a floating point number)

\ No newline at end of file +Q (sidekick.Sidekick_arith_lra.Simplex2.S.Q)

Module S.Q

include Sidekick_arith.NUM
type t
val zero : t
val one : t
val minus_one : t
val sign : t -> int
val of_int : int -> t
include Sidekick_sigs.EQ with type t := t
val equal : t -> t -> bool
include Sidekick_sigs.ORD with type t := t
val compare : t -> t -> int
include Sidekick_sigs.HASH with type t := t
val hash : t -> int
include Sidekick_sigs.PRINT with type t := t
val pp : t CCFormat.printer
val (+) : t -> t -> t
val (-) : t -> t -> t
val (*) : t -> t -> t
val (~-) : t -> t
val neg : t -> t
val min : t -> t -> t
val max : t -> t -> t
val (=) : t -> t -> bool
val (<>) : t -> t -> bool
val (>) : t -> t -> bool
val (>=) : t -> t -> bool
val (<) : t -> t -> bool
val (<=) : t -> t -> bool
type bigint
val (/) : t -> t -> t
val num : t -> bigint
val denum : t -> bigint
val infinity : t

+infinity

val minus_infinity : t
val is_real : t -> bool

A proper real, not nan/infinity

val pp_approx : int -> Stdlib.Format.formatter -> t -> unit

Pretty print rational with given amount of precision (for example as a floating point number)

\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lra/module-type-ARG/Q/index.html b/dev/sidekick/Sidekick_arith_lra/module-type-ARG/Q/index.html index 2396c929..d4b83c5e 100644 --- a/dev/sidekick/Sidekick_arith_lra/module-type-ARG/Q/index.html +++ b/dev/sidekick/Sidekick_arith_lra/module-type-ARG/Q/index.html @@ -1,2 +1,2 @@ -Q (sidekick.Sidekick_arith_lra.ARG.Q)

Module ARG.Q

include Sidekick_arith.NUM
type t
val zero : t
val one : t
val minus_one : t
val sign : t -> int
val of_int : int -> t
include Sidekick_sigs.EQ with type t := t
val equal : t -> t -> bool
include Sidekick_sigs.ORD with type t := t
val compare : t -> t -> int
include Sidekick_sigs.HASH with type t := t
val hash : t -> int
include Sidekick_sigs.PRINT with type t := t
val pp : t CCFormat.printer
val (+) : t -> t -> t
val (-) : t -> t -> t
val (*) : t -> t -> t
val (~-) : t -> t
val neg : t -> t
val min : t -> t -> t
val max : t -> t -> t
val (=) : t -> t -> bool
val (<>) : t -> t -> bool
val (>) : t -> t -> bool
val (>=) : t -> t -> bool
val (<) : t -> t -> bool
val (<=) : t -> t -> bool
type bigint
val (/) : t -> t -> t
val num : t -> bigint
val denum : t -> bigint
val pp_approx : int -> Stdlib.Format.formatter -> t -> unit

Pretty print rational with given amount of precision (for example as a floating point number)

\ No newline at end of file +Q (sidekick.Sidekick_arith_lra.ARG.Q)

Module ARG.Q

include Sidekick_arith.NUM
type t
val zero : t
val one : t
val minus_one : t
val sign : t -> int
val of_int : int -> t
include Sidekick_sigs.EQ with type t := t
val equal : t -> t -> bool
include Sidekick_sigs.ORD with type t := t
val compare : t -> t -> int
include Sidekick_sigs.HASH with type t := t
val hash : t -> int
include Sidekick_sigs.PRINT with type t := t
val pp : t CCFormat.printer
val (+) : t -> t -> t
val (-) : t -> t -> t
val (*) : t -> t -> t
val (~-) : t -> t
val neg : t -> t
val min : t -> t -> t
val max : t -> t -> t
val (=) : t -> t -> bool
val (<>) : t -> t -> bool
val (>) : t -> t -> bool
val (>=) : t -> t -> bool
val (<) : t -> t -> bool
val (<=) : t -> t -> bool
type bigint
val (/) : t -> t -> t
val num : t -> bigint
val denum : t -> bigint
val infinity : t

+infinity

val minus_infinity : t
val is_real : t -> bool

A proper real, not nan/infinity

val pp_approx : int -> Stdlib.Format.formatter -> t -> unit

Pretty print rational with given amount of precision (for example as a floating point number)

\ No newline at end of file diff --git a/dev/sidekick/Sidekick_arith_lra/module-type-S/A/Q/index.html b/dev/sidekick/Sidekick_arith_lra/module-type-S/A/Q/index.html index 752c0425..c31c6495 100644 --- a/dev/sidekick/Sidekick_arith_lra/module-type-S/A/Q/index.html +++ b/dev/sidekick/Sidekick_arith_lra/module-type-S/A/Q/index.html @@ -1,2 +1,2 @@ -Q (sidekick.Sidekick_arith_lra.S.A.Q)

Module A.Q

include Sidekick_arith.NUM
type t
val zero : t
val one : t
val minus_one : t
val sign : t -> int
val of_int : int -> t
include Sidekick_sigs.EQ with type t := t
val equal : t -> t -> bool
include Sidekick_sigs.ORD with type t := t
val compare : t -> t -> int
include Sidekick_sigs.HASH with type t := t
val hash : t -> int
include Sidekick_sigs.PRINT with type t := t
val pp : t CCFormat.printer
val (+) : t -> t -> t
val (-) : t -> t -> t
val (*) : t -> t -> t
val (~-) : t -> t
val neg : t -> t
val min : t -> t -> t
val max : t -> t -> t
val (=) : t -> t -> bool
val (<>) : t -> t -> bool
val (>) : t -> t -> bool
val (>=) : t -> t -> bool
val (<) : t -> t -> bool
val (<=) : t -> t -> bool
type bigint
val (/) : t -> t -> t
val num : t -> bigint
val denum : t -> bigint
val pp_approx : int -> Stdlib.Format.formatter -> t -> unit

Pretty print rational with given amount of precision (for example as a floating point number)

\ No newline at end of file +Q (sidekick.Sidekick_arith_lra.S.A.Q)

Module A.Q

include Sidekick_arith.NUM
type t
val zero : t
val one : t
val minus_one : t
val sign : t -> int
val of_int : int -> t
include Sidekick_sigs.EQ with type t := t
val equal : t -> t -> bool
include Sidekick_sigs.ORD with type t := t
val compare : t -> t -> int
include Sidekick_sigs.HASH with type t := t
val hash : t -> int
include Sidekick_sigs.PRINT with type t := t
val pp : t CCFormat.printer
val (+) : t -> t -> t
val (-) : t -> t -> t
val (*) : t -> t -> t
val (~-) : t -> t
val neg : t -> t
val min : t -> t -> t
val max : t -> t -> t
val (=) : t -> t -> bool
val (<>) : t -> t -> bool
val (>) : t -> t -> bool
val (>=) : t -> t -> bool
val (<) : t -> t -> bool
val (<=) : t -> t -> bool
type bigint
val (/) : t -> t -> t
val num : t -> bigint
val denum : t -> bigint
val infinity : t

+infinity

val minus_infinity : t
val is_real : t -> bool

A proper real, not nan/infinity

val pp_approx : int -> Stdlib.Format.formatter -> t -> unit

Pretty print rational with given amount of precision (for example as a floating point number)

\ No newline at end of file diff --git a/dev/sidekick/Sidekick_zarith/Rational/index.html b/dev/sidekick/Sidekick_zarith/Rational/index.html index 68635893..d7e1f4b9 100644 --- a/dev/sidekick/Sidekick_zarith/Rational/index.html +++ b/dev/sidekick/Sidekick_zarith/Rational/index.html @@ -1,2 +1,2 @@ -Rational (sidekick.Sidekick_zarith.Rational)

Module Sidekick_zarith.Rational

include Sidekick_arith.NUM with type t = Q.t
type t = Q.t
val zero : t
val one : t
val minus_one : t
val sign : t -> int
val of_int : int -> t
include Sidekick_sigs.EQ with type t := t
val equal : t -> t -> bool
include Sidekick_sigs.ORD with type t := t
val compare : t -> t -> int
include Sidekick_sigs.HASH with type t := t
val hash : t -> int
include Sidekick_sigs.PRINT with type t := t
val pp : t CCFormat.printer
val (+) : t -> t -> t
val (-) : t -> t -> t
val (*) : t -> t -> t
val (~-) : t -> t
val neg : t -> t
val min : t -> t -> t
val max : t -> t -> t
val (=) : t -> t -> bool
val (<>) : t -> t -> bool
val (>) : t -> t -> bool
val (>=) : t -> t -> bool
val (<) : t -> t -> bool
val (<=) : t -> t -> bool
type bigint = Z.t
val (/) : t -> t -> t
val num : t -> bigint
val denum : t -> bigint
val pp_approx : int -> Stdlib.Format.formatter -> t -> unit

Pretty print rational with given amount of precision (for example as a floating point number)

\ No newline at end of file +Rational (sidekick.Sidekick_zarith.Rational)

Module Sidekick_zarith.Rational

include Sidekick_arith.NUM with type t = Q.t
type t = Q.t
val zero : t
val one : t
val minus_one : t
val sign : t -> int
val of_int : int -> t
include Sidekick_sigs.EQ with type t := t
val equal : t -> t -> bool
include Sidekick_sigs.ORD with type t := t
val compare : t -> t -> int
include Sidekick_sigs.HASH with type t := t
val hash : t -> int
include Sidekick_sigs.PRINT with type t := t
val pp : t CCFormat.printer
val (+) : t -> t -> t
val (-) : t -> t -> t
val (*) : t -> t -> t
val (~-) : t -> t
val neg : t -> t
val min : t -> t -> t
val max : t -> t -> t
val (=) : t -> t -> bool
val (<>) : t -> t -> bool
val (>) : t -> t -> bool
val (>=) : t -> t -> bool
val (<) : t -> t -> bool
val (<=) : t -> t -> bool
type bigint = Z.t
val (/) : t -> t -> t
val num : t -> bigint
val denum : t -> bigint
val infinity : t

+infinity

val minus_infinity : t
val is_real : t -> bool

A proper real, not nan/infinity

val pp_approx : int -> Stdlib.Format.formatter -> t -> unit

Pretty print rational with given amount of precision (for example as a floating point number)

\ No newline at end of file