sig
  type complex = Complex.t
  val acos : float -> float
  val acosh : float -> float
  val asin : float -> float
  val asinh : float -> float
  val atan : float -> float
  val atan2 : float -> float -> float
  val atanh : float -> float
  val cabs : Posix_math.complex -> float
  val cacos : Posix_math.complex -> Posix_math.complex
  val cacosh : Posix_math.complex -> Posix_math.complex
  val carg : Posix_math.complex -> float
  val casin : Posix_math.complex -> Posix_math.complex
  val casinh : Posix_math.complex -> Posix_math.complex
  val catan : Posix_math.complex -> Posix_math.complex
  val catanh : Posix_math.complex -> Posix_math.complex
  val cbrt : float -> float
  val ccos : Posix_math.complex -> Posix_math.complex
  val ccosh : Posix_math.complex -> Posix_math.complex
  val ceil : float -> float
  val cexp : Posix_math.complex -> Posix_math.complex
  val cimag : Posix_math.complex -> float
  val clog : Posix_math.complex -> Posix_math.complex
  val conj : Posix_math.complex -> Posix_math.complex
  val copysign : float -> float -> float
  val cos : float -> float
  val cosh : float -> float
  val cpow : Posix_math.complex -> Posix_math.complex -> Posix_math.complex
  val cproj : Posix_math.complex -> Posix_math.complex
  val creal : Posix_math.complex -> float
  val csin : Posix_math.complex -> Posix_math.complex
  val csinh : Posix_math.complex -> Posix_math.complex
  val csqrt : Posix_math.complex -> Posix_math.complex
  val ctan : Posix_math.complex -> Posix_math.complex
  val ctanh : Posix_math.complex -> Posix_math.complex
  val exp : float -> float
  val ldexp : float -> int -> float
  val lgamma : float -> float
  val llrint : float -> int64
  val llround : float -> int64
  val log : float -> float
  val log10 : float -> float
  val log1p : float -> float
  val log2 : float -> float
  val logb : float -> float
  val lrint : float -> int32
  val lround : float -> int32
  val modf : float -> float * float
  val nearbyint : float -> float
  val nextafter : float -> float -> float
  val nexttoward : float -> float -> float
  val pow : float -> float -> float
  val remainder : float -> float -> float
  val remquo : float -> float -> float * int
  val rint : float -> float
  val round : float -> float
  val scalbln : float -> int64 -> float
  val scalbn : float -> int -> float
  val signbit : float -> int
  val sin : float -> float
  val sinh : float -> float
  val sqrt : float -> float
  val tan : float -> float
  val tanh : float -> float
  val tgamma : float -> float
  val trunc : float -> float
  module Fexcepts :
    sig
      type t
      val fe_all_except : Posix_math.Fexcepts.t
      val fe_divbyzero : Posix_math.Fexcepts.t
      val fe_inexact : Posix_math.Fexcepts.t
      val fe_invalid : Posix_math.Fexcepts.t
      val fe_overflow : Posix_math.Fexcepts.t
      val fe_underflow : Posix_math.Fexcepts.t
      val union :
        Posix_math.Fexcepts.t ->
        Posix_math.Fexcepts.t -> Posix_math.Fexcepts.t
    end
  val feclearexcept :
    Posix_math.Fexcepts.t -> (unit, [> `Error ]) Result.result
  val feraiseexcept :
    Posix_math.Fexcepts.t -> (unit, [> `Error ]) Result.result
  val fetestexcept :
    Posix_math.Fexcepts.t ->
    (Posix_math.Fexcepts.t, [> `Error ]) Result.result
  module Fexcept : sig type t end
  val fesetexceptflag :
    Posix_math.Fexcept.t ->
    Posix_math.Fexcepts.t -> (unit, [> `Error ]) Result.result
  val fegetexceptflag :
    Posix_math.Fexcepts.t ->
    (Posix_math.Fexcept.t, [> `Error ]) Result.result
  module Fenv : sig type t end
  val fegetenv : unit -> (Posix_math.Fenv.t, [> `Error ]) Result.result
  val fesetenv : Posix_math.Fenv.t -> (unit, [> `Error ]) Result.result
  val feupdateenv : Posix_math.Fenv.t -> (unit, [> `Error ]) Result.result
  val feholdexcept : unit -> (Posix_math.Fenv.t, [> `Error ]) Result.result
  module Fround :
    sig
      type t
      val fe_tonearest : Posix_math.Fround.t
      val fe_upward : Posix_math.Fround.t
      val fe_downward : Posix_math.Fround.t
      val fe_towardzero : Posix_math.Fround.t
    end
  val fesetround : Posix_math.Fround.t -> (unit, [> `Error ]) Result.result
  val fegetround : unit -> (Posix_math.Fround.t, [> `Error ]) Result.result
end