sig
  module Float :
    sig
      type t = float
      val e : float
      val pi : float
      val two_pi : float
      val pi_div_2 : float
      val pi_div_4 : float
      val inv_pi : float
      val max_sub_float : float
      val min_sub_float : float
      val max_frac_float : float
      val max_int_arith : float
      val deg_of_rad : float -> float
      val rad_of_deg : float -> float
      val wrap_angle : float -> float
      val random : ?min:float -> len:float -> unit -> float
      val srandom :
        Random.State.t -> ?min:float -> len:float -> unit -> float
      val mix : float -> float -> float -> float
      val step : float -> float -> float
      val smooth_step : float -> float -> float -> float
      val fmax : float -> float -> float
      val fmin : float -> float -> float
      val clamp : min:float -> max:float -> float -> float
      val remap :
        x0:float -> x1:float -> y0:float -> y1:float -> float -> float
      val round : float -> float
      val int_of_round : float -> int
      val round_dfrac : int -> float -> float
      val round_dsig : int -> float -> float
      val round_zero : eps:float -> float -> float
      val chop : eps:float -> float -> float
      val sign : float -> float
      val sign_bit : float -> bool
      val succ : float -> float
      val pred : float -> float
      val nan : int -> float
      val nan_payload : float -> int
      val is_zero : eps:float -> float -> bool
      val is_nan : float -> bool
      val is_inf : float -> bool
      val is_int : float -> bool
      val equal : float -> float -> bool
      val equal_tol : eps:float -> float -> float -> bool
      val compare : float -> float -> int
      val compare_tol : eps:float -> float -> float -> int
      val to_string : float -> string
      val pp : Format.formatter -> float -> unit
    end
  type m2
  type m3
  type m4
  type v2
  type v3
  type v4
  module type V =
    sig
      type t
      val dim : int
      type m
      val comp : int -> Gg.V.t -> float
      val zero : Gg.V.t
      val infinity : Gg.V.t
      val neg_infinity : Gg.V.t
      val basis : int -> Gg.V.t
      val neg : Gg.V.t -> Gg.V.t
      val add : Gg.V.t -> Gg.V.t -> Gg.V.t
      val sub : Gg.V.t -> Gg.V.t -> Gg.V.t
      val mul : Gg.V.t -> Gg.V.t -> Gg.V.t
      val div : Gg.V.t -> Gg.V.t -> Gg.V.t
      val smul : float -> Gg.V.t -> Gg.V.t
      val half : Gg.V.t -> Gg.V.t
      val dot : Gg.V.t -> Gg.V.t -> float
      val norm : Gg.V.t -> float
      val norm2 : Gg.V.t -> float
      val unit : Gg.V.t -> Gg.V.t
      val homogene : Gg.V.t -> Gg.V.t
      val mix : Gg.V.t -> Gg.V.t -> float -> Gg.V.t
      val ltr : Gg.V.m -> Gg.V.t -> Gg.V.t
      val ( + ) : Gg.V.t -> Gg.V.t -> Gg.V.t
      val ( - ) : Gg.V.t -> Gg.V.t -> Gg.V.t
      val ( * ) : float -> Gg.V.t -> Gg.V.t
      val ( / ) : Gg.V.t -> float -> Gg.V.t
      val map : (float -> float) -> Gg.V.t -> Gg.V.t
      val mapi : (int -> float -> float) -> Gg.V.t -> Gg.V.t
      val fold : ('-> float -> 'a) -> '-> Gg.V.t -> 'a
      val foldi : ('-> int -> float -> 'a) -> '-> Gg.V.t -> 'a
      val iter : (float -> unit) -> Gg.V.t -> unit
      val iteri : (int -> float -> unit) -> Gg.V.t -> unit
      val for_all : (float -> bool) -> Gg.V.t -> bool
      val exists : (float -> bool) -> Gg.V.t -> bool
      val equal : Gg.V.t -> Gg.V.t -> bool
      val equal_f : (float -> float -> bool) -> Gg.V.t -> Gg.V.t -> bool
      val compare : Gg.V.t -> Gg.V.t -> int
      val compare_f : (float -> float -> int) -> Gg.V.t -> Gg.V.t -> int
      val to_string : Gg.V.t -> string
      val pp : Format.formatter -> Gg.V.t -> unit
      val pp_f :
        (Format.formatter -> float -> unit) ->
        Format.formatter -> Gg.V.t -> unit
    end
  module V2 :
    sig
      type t = Gg.v2
      val dim : int
      type m = Gg.m2
      val v : float -> float -> Gg.v2
      val comp : int -> Gg.v2 -> float
      val x : Gg.v2 -> float
      val y : Gg.v2 -> float
      val ox : Gg.v2
      val oy : Gg.v2
      val zero : Gg.v2
      val infinity : Gg.v2
      val neg_infinity : Gg.v2
      val basis : int -> Gg.v2
      val of_tuple : float * float -> Gg.v2
      val to_tuple : Gg.v2 -> float * float
      val of_polar : Gg.v2 -> Gg.v2
      val to_polar : Gg.v2 -> Gg.v2
      val of_v3 : Gg.v3 -> Gg.v2
      val of_v4 : Gg.v4 -> Gg.v2
      val neg : Gg.v2 -> Gg.v2
      val add : Gg.v2 -> Gg.v2 -> Gg.v2
      val sub : Gg.v2 -> Gg.v2 -> Gg.v2
      val mul : Gg.v2 -> Gg.v2 -> Gg.v2
      val div : Gg.v2 -> Gg.v2 -> Gg.v2
      val smul : float -> Gg.v2 -> Gg.v2
      val half : Gg.v2 -> Gg.v2
      val dot : Gg.v2 -> Gg.v2 -> float
      val norm : Gg.v2 -> float
      val norm2 : Gg.v2 -> float
      val unit : Gg.v2 -> Gg.v2
      val polar : float -> float -> Gg.v2
      val angle : Gg.v2 -> float
      val ortho : Gg.v2 -> Gg.v2
      val homogene : Gg.v2 -> Gg.v2
      val mix : Gg.v2 -> Gg.v2 -> float -> Gg.v2
      val ltr : Gg.m2 -> Gg.v2 -> Gg.v2
      val tr : Gg.m3 -> Gg.v2 -> Gg.v2
      val ( + ) : Gg.v2 -> Gg.v2 -> Gg.v2
      val ( - ) : Gg.v2 -> Gg.v2 -> Gg.v2
      val ( * ) : float -> Gg.v2 -> Gg.v2
      val ( / ) : Gg.v2 -> float -> Gg.v2
      val map : (float -> float) -> Gg.v2 -> Gg.v2
      val mapi : (int -> float -> float) -> Gg.v2 -> Gg.v2
      val fold : ('-> float -> 'a) -> '-> Gg.v2 -> 'a
      val foldi : ('-> int -> float -> 'a) -> '-> Gg.v2 -> 'a
      val iter : (float -> unit) -> Gg.v2 -> unit
      val iteri : (int -> float -> unit) -> Gg.v2 -> unit
      val for_all : (float -> bool) -> Gg.v2 -> bool
      val exists : (float -> bool) -> Gg.v2 -> bool
      val equal : Gg.v2 -> Gg.v2 -> bool
      val equal_f : (float -> float -> bool) -> Gg.v2 -> Gg.v2 -> bool
      val compare : Gg.v2 -> Gg.v2 -> int
      val compare_f : (float -> float -> int) -> Gg.v2 -> Gg.v2 -> int
      val to_string : Gg.v2 -> string
      val pp : Format.formatter -> Gg.v2 -> unit
      val pp_f :
        (Format.formatter -> float -> unit) ->
        Format.formatter -> Gg.v2 -> unit
    end
  module V3 :
    sig
      type t = Gg.v3
      val dim : int
      type m = Gg.m3
      val v : float -> float -> float -> Gg.v3
      val comp : int -> Gg.v3 -> float
      val x : Gg.v3 -> float
      val y : Gg.v3 -> float
      val z : Gg.v3 -> float
      val ox : Gg.v3
      val oy : Gg.v3
      val oz : Gg.v3
      val zero : Gg.v3
      val infinity : Gg.v3
      val neg_infinity : Gg.v3
      val basis : int -> Gg.v3
      val of_tuple : float * float * float -> Gg.v3
      val to_tuple : Gg.v3 -> float * float * float
      val of_spherical : Gg.v3 -> Gg.v3
      val to_spherical : Gg.v3 -> Gg.v3
      val of_v2 : Gg.v2 -> z:float -> Gg.v3
      val of_v4 : Gg.v4 -> Gg.v3
      val neg : Gg.v3 -> Gg.v3
      val add : Gg.v3 -> Gg.v3 -> Gg.v3
      val sub : Gg.v3 -> Gg.v3 -> Gg.v3
      val mul : Gg.v3 -> Gg.v3 -> Gg.v3
      val div : Gg.v3 -> Gg.v3 -> Gg.v3
      val smul : float -> Gg.v3 -> Gg.v3
      val half : Gg.v3 -> Gg.v3
      val cross : Gg.v3 -> Gg.v3 -> Gg.v3
      val dot : Gg.v3 -> Gg.v3 -> float
      val norm : Gg.v3 -> float
      val norm2 : Gg.v3 -> float
      val unit : Gg.v3 -> Gg.v3
      val spherical : float -> float -> float -> Gg.v3
      val azimuth : Gg.v3 -> float
      val zenith : Gg.v3 -> float
      val homogene : Gg.v3 -> Gg.v3
      val mix : Gg.v3 -> Gg.v3 -> float -> Gg.v3
      val ltr : Gg.m3 -> Gg.v3 -> Gg.v3
      val tr : Gg.m4 -> Gg.v3 -> Gg.v3
      val ( + ) : Gg.v3 -> Gg.v3 -> Gg.v3
      val ( - ) : Gg.v3 -> Gg.v3 -> Gg.v3
      val ( * ) : float -> Gg.v3 -> Gg.v3
      val ( / ) : Gg.v3 -> float -> Gg.v3
      val map : (float -> float) -> Gg.v3 -> Gg.v3
      val mapi : (int -> float -> float) -> Gg.v3 -> Gg.v3
      val fold : ('-> float -> 'a) -> '-> Gg.v3 -> 'a
      val foldi : ('-> int -> float -> 'a) -> '-> Gg.v3 -> 'a
      val iter : (float -> unit) -> Gg.v3 -> unit
      val iteri : (int -> float -> unit) -> Gg.v3 -> unit
      val for_all : (float -> bool) -> Gg.v3 -> bool
      val exists : (float -> bool) -> Gg.v3 -> bool
      val equal : Gg.v3 -> Gg.v3 -> bool
      val equal_f : (float -> float -> bool) -> Gg.v3 -> Gg.v3 -> bool
      val compare : Gg.v3 -> Gg.v3 -> int
      val compare_f : (float -> float -> int) -> Gg.v3 -> Gg.v3 -> int
      val to_string : Gg.v3 -> string
      val pp : Format.formatter -> Gg.v3 -> unit
      val pp_f :
        (Format.formatter -> float -> unit) ->
        Format.formatter -> Gg.v3 -> unit
    end
  module V4 :
    sig
      type t = Gg.v4
      val dim : int
      type m = Gg.m4
      val v : float -> float -> float -> float -> Gg.v4
      val comp : int -> Gg.v4 -> float
      val x : Gg.v4 -> float
      val y : Gg.v4 -> float
      val z : Gg.v4 -> float
      val w : Gg.v4 -> float
      val ox : Gg.v4
      val oy : Gg.v4
      val oz : Gg.v4
      val ow : Gg.v4
      val zero : Gg.v4
      val infinity : Gg.v4
      val neg_infinity : Gg.v4
      val basis : int -> Gg.v4
      val of_tuple : float * float * float * float -> Gg.v4
      val to_tuple : Gg.v4 -> float * float * float * float
      val of_v2 : Gg.v2 -> z:float -> w:float -> Gg.v4
      val of_v3 : Gg.v3 -> w:float -> Gg.v4
      val neg : Gg.v4 -> Gg.v4
      val add : Gg.v4 -> Gg.v4 -> Gg.v4
      val sub : Gg.v4 -> Gg.v4 -> Gg.v4
      val mul : Gg.v4 -> Gg.v4 -> Gg.v4
      val div : Gg.v4 -> Gg.v4 -> Gg.v4
      val smul : float -> Gg.v4 -> Gg.v4
      val half : Gg.v4 -> Gg.v4
      val dot : Gg.v4 -> Gg.v4 -> float
      val norm : Gg.v4 -> float
      val norm2 : Gg.v4 -> float
      val unit : Gg.v4 -> Gg.v4
      val homogene : Gg.v4 -> Gg.v4
      val mix : Gg.v4 -> Gg.v4 -> float -> Gg.v4
      val ltr : Gg.m4 -> Gg.v4 -> Gg.v4
      val ( + ) : Gg.v4 -> Gg.v4 -> Gg.v4
      val ( - ) : Gg.v4 -> Gg.v4 -> Gg.v4
      val ( * ) : float -> Gg.v4 -> Gg.v4
      val ( / ) : Gg.v4 -> float -> Gg.v4
      val map : (float -> float) -> Gg.v4 -> Gg.v4
      val mapi : (int -> float -> float) -> Gg.v4 -> Gg.v4
      val fold : ('-> float -> 'a) -> '-> Gg.v4 -> 'a
      val foldi : ('-> int -> float -> 'a) -> '-> Gg.v4 -> 'a
      val iter : (float -> unit) -> Gg.v4 -> unit
      val iteri : (int -> float -> unit) -> Gg.v4 -> unit
      val for_all : (float -> bool) -> Gg.v4 -> bool
      val exists : (float -> bool) -> Gg.v4 -> bool
      val equal : Gg.v4 -> Gg.v4 -> bool
      val equal_f : (float -> float -> bool) -> Gg.v4 -> Gg.v4 -> bool
      val compare : Gg.v4 -> Gg.v4 -> int
      val compare_f : (float -> float -> int) -> Gg.v4 -> Gg.v4 -> int
      val to_string : Gg.v4 -> string
      val pp : Format.formatter -> Gg.v4 -> unit
      val pp_f :
        (Format.formatter -> float -> unit) ->
        Format.formatter -> Gg.v4 -> unit
    end
  type p2 = Gg.v2
  type p3 = Gg.v3
  module type P =
    sig
      type t
      val dim : int
      type mh
      val o : Gg.P.t
      val mid : Gg.P.t -> Gg.P.t -> Gg.P.t
      val tr : Gg.P.mh -> Gg.P.t -> Gg.P.t
    end
  module P2 :
    sig
      type t = Gg.p2
      val dim : int
      type mh = Gg.m3
      val v : float -> float -> Gg.p2
      val x : Gg.p2 -> float
      val y : Gg.p2 -> float
      val o : Gg.p2
      val mid : Gg.p2 -> Gg.p2 -> Gg.p2
      val tr : Gg.m3 -> Gg.p2 -> Gg.p2
    end
  module P3 :
    sig
      type t = Gg.p3
      val dim : int
      type mh = Gg.m4
      val v : float -> float -> float -> Gg.p3
      val x : Gg.p3 -> float
      val y : Gg.p3 -> float
      val z : Gg.p3 -> float
      val o : Gg.p3
      val mid : Gg.p3 -> Gg.p3 -> Gg.p3
      val tr : Gg.m4 -> Gg.p3 -> Gg.p3
    end
  type quat = Gg.v4
  module Quat :
    sig
      type t = Gg.quat
      val v : float -> float -> float -> float -> Gg.quat
      val zero : Gg.quat
      val id : Gg.quat
      val mul : Gg.quat -> Gg.quat -> Gg.quat
      val conj : Gg.quat -> Gg.quat
      val unit : Gg.quat -> Gg.quat
      val inv : Gg.quat -> Gg.quat
      val slerp : Gg.quat -> Gg.quat -> float -> Gg.quat
      val squad :
        Gg.quat -> Gg.quat -> Gg.quat -> Gg.quat -> float -> Gg.quat
      val nlerp : Gg.quat -> Gg.quat -> float -> Gg.quat
      val of_m3 : Gg.m3 -> Gg.quat
      val of_m4 : Gg.m4 -> Gg.quat
      val rot_map : Gg.v3 -> Gg.v3 -> Gg.quat
      val rot_axis : Gg.v3 -> float -> Gg.quat
      val rot_zyx : Gg.v3 -> Gg.quat
      val to_rot_axis : Gg.quat -> Gg.v3 * float
      val to_rot_zyx : Gg.quat -> Gg.v3
      val apply3 : Gg.quat -> Gg.v3 -> Gg.v3
      val apply4 : Gg.quat -> Gg.v4 -> Gg.v4
    end
  module type M =
    sig
      type t
      val dim : int
      type v
      val el : int -> int -> Gg.M.t -> float
      val row : int -> Gg.M.t -> Gg.M.v
      val col : int -> Gg.M.t -> Gg.M.v
      val zero : Gg.M.t
      val id : Gg.M.t
      val neg : Gg.M.t -> Gg.M.t
      val add : Gg.M.t -> Gg.M.t -> Gg.M.t
      val sub : Gg.M.t -> Gg.M.t -> Gg.M.t
      val mul : Gg.M.t -> Gg.M.t -> Gg.M.t
      val emul : Gg.M.t -> Gg.M.t -> Gg.M.t
      val ediv : Gg.M.t -> Gg.M.t -> Gg.M.t
      val smul : float -> Gg.M.t -> Gg.M.t
      val transpose : Gg.M.t -> Gg.M.t
      val trace : Gg.M.t -> float
      val det : Gg.M.t -> float
      val inv : Gg.M.t -> Gg.M.t
      val map : (float -> float) -> Gg.M.t -> Gg.M.t
      val mapi : (int -> int -> float -> float) -> Gg.M.t -> Gg.M.t
      val fold : ('-> float -> 'a) -> '-> Gg.M.t -> 'a
      val foldi : ('-> int -> int -> float -> 'a) -> '-> Gg.M.t -> 'a
      val iter : (float -> unit) -> Gg.M.t -> unit
      val iteri : (int -> int -> float -> unit) -> Gg.M.t -> unit
      val for_all : (float -> bool) -> Gg.M.t -> bool
      val exists : (float -> bool) -> Gg.M.t -> bool
      val equal : Gg.M.t -> Gg.M.t -> bool
      val equal_f : (float -> float -> bool) -> Gg.M.t -> Gg.M.t -> bool
      val compare : Gg.M.t -> Gg.M.t -> int
      val compare_f : (float -> float -> int) -> Gg.M.t -> Gg.M.t -> int
      val to_string : Gg.M.t -> string
      val pp : Format.formatter -> Gg.M.t -> unit
      val pp_f :
        (Format.formatter -> float -> unit) ->
        Format.formatter -> Gg.M.t -> unit
    end
  module M2 :
    sig
      type t = Gg.m2
      val dim : int
      type v = Gg.v2
      val v : float -> float -> float -> float -> Gg.m2
      val of_rows : Gg.v2 -> Gg.v2 -> Gg.m2
      val of_cols : Gg.v2 -> Gg.v2 -> Gg.m2
      val el : int -> int -> Gg.m2 -> float
      val row : int -> Gg.m2 -> Gg.v2
      val col : int -> Gg.m2 -> Gg.v2
      val zero : Gg.m2
      val id : Gg.m2
      val of_m3 : Gg.m3 -> Gg.m2
      val of_m4 : Gg.m4 -> Gg.m2
      val neg : Gg.m2 -> Gg.m2
      val add : Gg.m2 -> Gg.m2 -> Gg.m2
      val sub : Gg.m2 -> Gg.m2 -> Gg.m2
      val mul : Gg.m2 -> Gg.m2 -> Gg.m2
      val emul : Gg.m2 -> Gg.m2 -> Gg.m2
      val ediv : Gg.m2 -> Gg.m2 -> Gg.m2
      val smul : float -> Gg.m2 -> Gg.m2
      val transpose : Gg.m2 -> Gg.m2
      val trace : Gg.m2 -> float
      val det : Gg.m2 -> float
      val inv : Gg.m2 -> Gg.m2
      val rot : float -> Gg.m2
      val scale : Gg.v2 -> Gg.m2
      val map : (float -> float) -> Gg.m2 -> Gg.m2
      val mapi : (int -> int -> float -> float) -> Gg.m2 -> Gg.m2
      val fold : ('-> float -> 'a) -> '-> Gg.m2 -> 'a
      val foldi : ('-> int -> int -> float -> 'a) -> '-> Gg.m2 -> 'a
      val iter : (float -> unit) -> Gg.m2 -> unit
      val iteri : (int -> int -> float -> unit) -> Gg.m2 -> unit
      val for_all : (float -> bool) -> Gg.m2 -> bool
      val exists : (float -> bool) -> Gg.m2 -> bool
      val equal : Gg.m2 -> Gg.m2 -> bool
      val equal_f : (float -> float -> bool) -> Gg.m2 -> Gg.m2 -> bool
      val compare : Gg.m2 -> Gg.m2 -> int
      val compare_f : (float -> float -> int) -> Gg.m2 -> Gg.m2 -> int
      val to_string : Gg.m2 -> string
      val pp : Format.formatter -> Gg.m2 -> unit
      val pp_f :
        (Format.formatter -> float -> unit) ->
        Format.formatter -> Gg.m2 -> unit
      val e00 : Gg.m2 -> float
      val e01 : Gg.m2 -> float
      val e10 : Gg.m2 -> float
      val e11 : Gg.m2 -> float
    end
  module M3 :
    sig
      type t = Gg.m3
      val dim : int
      type v = Gg.v3
      val v :
        float ->
        float ->
        float -> float -> float -> float -> float -> float -> float -> Gg.m3
      val of_rows : Gg.v3 -> Gg.v3 -> Gg.v3 -> Gg.m3
      val of_cols : Gg.v3 -> Gg.v3 -> Gg.v3 -> Gg.m3
      val el : int -> int -> Gg.m3 -> float
      val row : int -> Gg.m3 -> Gg.v3
      val col : int -> Gg.m3 -> Gg.v3
      val zero : Gg.m3
      val id : Gg.m3
      val of_m2_v2 : Gg.m2 -> Gg.v2 -> Gg.m3
      val of_m4 : Gg.m4 -> Gg.m3
      val of_quat : Gg.quat -> Gg.m3
      val neg : Gg.m3 -> Gg.m3
      val add : Gg.m3 -> Gg.m3 -> Gg.m3
      val sub : Gg.m3 -> Gg.m3 -> Gg.m3
      val mul : Gg.m3 -> Gg.m3 -> Gg.m3
      val emul : Gg.m3 -> Gg.m3 -> Gg.m3
      val ediv : Gg.m3 -> Gg.m3 -> Gg.m3
      val smul : float -> Gg.m3 -> Gg.m3
      val transpose : Gg.m3 -> Gg.m3
      val trace : Gg.m3 -> float
      val det : Gg.m3 -> float
      val inv : Gg.m3 -> Gg.m3
      val move : Gg.v2 -> Gg.m3
      val rot : float -> Gg.m3
      val scale2 : Gg.v2 -> Gg.m3
      val rigid : move:Gg.v2 -> rot:float -> Gg.m3
      val srigid : move:Gg.v2 -> rot:float -> scale:Gg.v2 -> Gg.m3
      val rot_map : Gg.v3 -> Gg.v3 -> Gg.m3
      val rot_axis : Gg.v3 -> float -> Gg.m3
      val rot_zyx : Gg.v3 -> Gg.m3
      val scale : Gg.v3 -> Gg.m3
      val map : (float -> float) -> Gg.m3 -> Gg.m3
      val mapi : (int -> int -> float -> float) -> Gg.m3 -> Gg.m3
      val fold : ('-> float -> 'a) -> '-> Gg.m3 -> 'a
      val foldi : ('-> int -> int -> float -> 'a) -> '-> Gg.m3 -> 'a
      val iter : (float -> unit) -> Gg.m3 -> unit
      val iteri : (int -> int -> float -> unit) -> Gg.m3 -> unit
      val for_all : (float -> bool) -> Gg.m3 -> bool
      val exists : (float -> bool) -> Gg.m3 -> bool
      val equal : Gg.m3 -> Gg.m3 -> bool
      val equal_f : (float -> float -> bool) -> Gg.m3 -> Gg.m3 -> bool
      val compare : Gg.m3 -> Gg.m3 -> int
      val compare_f : (float -> float -> int) -> Gg.m3 -> Gg.m3 -> int
      val to_string : Gg.m3 -> string
      val pp : Format.formatter -> Gg.m3 -> unit
      val pp_f :
        (Format.formatter -> float -> unit) ->
        Format.formatter -> Gg.m3 -> unit
      val e00 : Gg.m3 -> float
      val e01 : Gg.m3 -> float
      val e02 : Gg.m3 -> float
      val e10 : Gg.m3 -> float
      val e11 : Gg.m3 -> float
      val e12 : Gg.m3 -> float
      val e20 : Gg.m3 -> float
      val e21 : Gg.m3 -> float
      val e22 : Gg.m3 -> float
    end
  module M4 :
    sig
      type t = Gg.m4
      val dim : int
      type v = Gg.v4
      val v :
        float ->
        float ->
        float ->
        float ->
        float ->
        float ->
        float ->
        float ->
        float ->
        float -> float -> float -> float -> float -> float -> float -> Gg.m4
      val of_rows : Gg.v4 -> Gg.v4 -> Gg.v4 -> Gg.v4 -> Gg.m4
      val of_cols : Gg.v4 -> Gg.v4 -> Gg.v4 -> Gg.v4 -> Gg.m4
      val el : int -> int -> Gg.m4 -> float
      val row : int -> Gg.m4 -> Gg.M4.v
      val col : int -> Gg.m4 -> Gg.M4.v
      val zero : Gg.m4
      val id : Gg.m4
      val of_m3_v3 : Gg.m3 -> Gg.v3 -> Gg.m4
      val of_quat : Gg.quat -> Gg.m4
      val neg : Gg.m4 -> Gg.m4
      val add : Gg.m4 -> Gg.m4 -> Gg.m4
      val sub : Gg.m4 -> Gg.m4 -> Gg.m4
      val mul : Gg.m4 -> Gg.m4 -> Gg.m4
      val emul : Gg.m4 -> Gg.m4 -> Gg.m4
      val ediv : Gg.m4 -> Gg.m4 -> Gg.m4
      val smul : float -> Gg.m4 -> Gg.m4
      val transpose : Gg.m4 -> Gg.m4
      val trace : Gg.m4 -> float
      val det : Gg.m4 -> float
      val inv : Gg.m4 -> Gg.m4
      val move : Gg.v3 -> Gg.m4
      val rot_map : Gg.v3 -> Gg.v3 -> Gg.m4
      val rot_axis : Gg.v3 -> float -> Gg.m4
      val rot_zyx : Gg.v3 -> Gg.m4
      val scale3 : Gg.v3 -> Gg.m4
      val rigid : move:Gg.v3 -> rot:Gg.v3 * float -> Gg.m4
      val rigidq : move:Gg.v3 -> rot:Gg.quat -> Gg.m4
      val srigid : move:Gg.v3 -> rot:Gg.v3 * float -> scale:Gg.v3 -> Gg.m4
      val srigidq : move:Gg.v3 -> rot:Gg.quat -> scale:Gg.v3 -> Gg.m4
      val ortho :
        left:float ->
        right:float ->
        bottom:float -> top:float -> near:float -> far:float -> Gg.m4
      val persp :
        left:float ->
        right:float ->
        bottom:float -> top:float -> near:float -> far:float -> Gg.m4
      val scale : Gg.v4 -> Gg.m4
      val map : (float -> float) -> Gg.m4 -> Gg.m4
      val mapi : (int -> int -> float -> float) -> Gg.m4 -> Gg.m4
      val fold : ('-> float -> 'a) -> '-> Gg.m4 -> 'a
      val foldi : ('-> int -> int -> float -> 'a) -> '-> Gg.m4 -> 'a
      val iter : (float -> unit) -> Gg.m4 -> unit
      val iteri : (int -> int -> float -> unit) -> Gg.m4 -> unit
      val for_all : (float -> bool) -> Gg.m4 -> bool
      val exists : (float -> bool) -> Gg.m4 -> bool
      val equal : Gg.m4 -> Gg.m4 -> bool
      val equal_f : (float -> float -> bool) -> Gg.m4 -> Gg.m4 -> bool
      val compare : Gg.m4 -> Gg.m4 -> int
      val compare_f : (float -> float -> int) -> Gg.m4 -> Gg.m4 -> int
      val to_string : Gg.m4 -> string
      val pp : Format.formatter -> Gg.m4 -> unit
      val pp_f :
        (Format.formatter -> float -> unit) ->
        Format.formatter -> Gg.m4 -> unit
      val e00 : Gg.m4 -> float
      val e01 : Gg.m4 -> float
      val e02 : Gg.m4 -> float
      val e03 : Gg.m4 -> float
      val e10 : Gg.m4 -> float
      val e11 : Gg.m4 -> float
      val e12 : Gg.m4 -> float
      val e13 : Gg.m4 -> float
      val e20 : Gg.m4 -> float
      val e21 : Gg.m4 -> float
      val e22 : Gg.m4 -> float
      val e23 : Gg.m4 -> float
      val e30 : Gg.m4 -> float
      val e31 : Gg.m4 -> float
      val e32 : Gg.m4 -> float
      val e33 : Gg.m4 -> float
    end
  type size2 = Gg.v2
  type size3 = Gg.v3
  module type Size =
    sig type t val dim : int val zero : Gg.Size.t val unit : Gg.Size.t end
  module Size2 :
    sig
      type t = Gg.size2
      val dim : int
      val v : float -> float -> Gg.size2
      val w : Gg.size2 -> float
      val h : Gg.size2 -> float
      val zero : Gg.size2
      val unit : Gg.size2
    end
  module Size3 :
    sig
      type t = Gg.size3
      val dim : int
      val v : float -> float -> float -> Gg.size3
      val w : Gg.size3 -> float
      val h : Gg.size3 -> float
      val d : Gg.size3 -> float
      val zero : Gg.size3
      val unit : Gg.size3
    end
  type box2
  type box3
  module type Box =
    sig
      type t
      val dim : int
      type v
      type p
      type size
      type m
      val v : Gg.Box.p -> Gg.Box.size -> Gg.Box.t
      val v_mid : Gg.Box.p -> Gg.Box.size -> Gg.Box.t
      val empty : Gg.Box.t
      val o : Gg.Box.t -> Gg.Box.p
      val size : Gg.Box.t -> Gg.Box.size
      val zero : Gg.Box.t
      val unit : Gg.Box.t
      val of_pts : Gg.Box.p -> Gg.Box.p -> Gg.Box.t
      val min : Gg.Box.t -> Gg.Box.p
      val max : Gg.Box.t -> Gg.Box.p
      val mid : Gg.Box.t -> Gg.Box.p
      val area : Gg.Box.t -> float
      val inter : Gg.Box.t -> Gg.Box.t -> Gg.Box.t
      val union : Gg.Box.t -> Gg.Box.t -> Gg.Box.t
      val inset : Gg.Box.v -> Gg.Box.t -> Gg.Box.t
      val round : Gg.Box.t -> Gg.Box.t
      val move : Gg.Box.v -> Gg.Box.t -> Gg.Box.t
      val ltr : Gg.Box.m -> Gg.Box.t -> Gg.Box.t
      val map_f : (float -> float) -> Gg.Box.t -> Gg.Box.t
      val is_empty : Gg.Box.t -> bool
      val is_pt : Gg.Box.t -> bool
      val isects : Gg.Box.t -> Gg.Box.t -> bool
      val subset : Gg.Box.t -> Gg.Box.t -> bool
      val mem : Gg.Box.p -> Gg.Box.t -> bool
      val equal : Gg.Box.t -> Gg.Box.t -> bool
      val equal_f : (float -> float -> bool) -> Gg.Box.t -> Gg.Box.t -> bool
      val compare : Gg.Box.t -> Gg.Box.t -> int
      val compare_f : (float -> float -> int) -> Gg.Box.t -> Gg.Box.t -> int
      val to_string : Gg.Box.t -> string
      val pp : Format.formatter -> Gg.Box.t -> unit
      val pp_f :
        (Format.formatter -> float -> unit) ->
        Format.formatter -> Gg.Box.t -> unit
    end
  module Box2 :
    sig
      type t = Gg.box2
      val dim : int
      type v = Gg.v2
      type p = Gg.p2
      type size = Gg.size2
      type m = Gg.m2
      val v : Gg.p2 -> Gg.size2 -> Gg.box2
      val v_mid : Gg.p2 -> Gg.size2 -> Gg.Box2.t
      val empty : Gg.box2
      val o : Gg.box2 -> Gg.p2
      val ox : Gg.box2 -> float
      val oy : Gg.box2 -> float
      val size : Gg.box2 -> Gg.Box2.size
      val w : Gg.box2 -> float
      val h : Gg.box2 -> float
      val zero : Gg.box2
      val unit : Gg.box2
      val of_pts : Gg.p2 -> Gg.p2 -> Gg.box2
      val min : Gg.box2 -> Gg.p2
      val minx : Gg.box2 -> float
      val miny : Gg.box2 -> float
      val max : Gg.box2 -> Gg.p2
      val maxx : Gg.box2 -> float
      val maxy : Gg.box2 -> float
      val mid : Gg.box2 -> Gg.p2
      val midx : Gg.box2 -> float
      val midy : Gg.box2 -> float
      val bottom_left : Gg.box2 -> Gg.p2
      val bottom_right : Gg.box2 -> Gg.p2
      val top_left : Gg.box2 -> Gg.p2
      val top_right : Gg.box2 -> Gg.p2
      val area : Gg.box2 -> float
      val inter : Gg.box2 -> Gg.box2 -> Gg.box2
      val union : Gg.box2 -> Gg.box2 -> Gg.box2
      val inset : Gg.v2 -> Gg.box2 -> Gg.box2
      val round : Gg.box2 -> Gg.box2
      val move : Gg.v2 -> Gg.box2 -> Gg.box2
      val ltr : Gg.m2 -> Gg.box2 -> Gg.box2
      val tr : Gg.m3 -> Gg.box2 -> Gg.box2
      val map_f : (float -> float) -> Gg.box2 -> Gg.box2
      val is_empty : Gg.box2 -> bool
      val is_pt : Gg.box2 -> bool
      val is_seg : Gg.box2 -> bool
      val isects : Gg.box2 -> Gg.box2 -> bool
      val subset : Gg.box2 -> Gg.box2 -> bool
      val mem : Gg.p2 -> Gg.box2 -> bool
      val equal : Gg.box2 -> Gg.box2 -> bool
      val equal_f : (float -> float -> bool) -> Gg.box2 -> Gg.box2 -> bool
      val compare : Gg.box2 -> Gg.box2 -> int
      val compare_f : (float -> float -> int) -> Gg.box2 -> Gg.box2 -> int
      val to_string : Gg.box2 -> string
      val pp : Format.formatter -> Gg.box2 -> unit
      val pp_f :
        (Format.formatter -> float -> unit) ->
        Format.formatter -> Gg.box2 -> unit
    end
  module Box3 :
    sig
      type t = Gg.box3
      val dim : int
      type v = Gg.v3
      type p = Gg.p3
      type size = Gg.size3
      type m = Gg.m3
      val v : Gg.p3 -> Gg.size3 -> Gg.box3
      val v_mid : Gg.p3 -> Gg.size3 -> Gg.Box3.t
      val empty : Gg.box3
      val o : Gg.box3 -> Gg.p3
      val ox : Gg.box3 -> float
      val oy : Gg.box3 -> float
      val oz : Gg.box3 -> float
      val size : Gg.box3 -> Gg.size3
      val w : Gg.box3 -> float
      val h : Gg.box3 -> float
      val d : Gg.box3 -> float
      val zero : Gg.box3
      val unit : Gg.box3
      val of_pts : Gg.p3 -> Gg.p3 -> Gg.box3
      val min : Gg.box3 -> Gg.p3
      val minx : Gg.box3 -> float
      val miny : Gg.box3 -> float
      val minz : Gg.box3 -> float
      val max : Gg.box3 -> Gg.p3
      val maxx : Gg.box3 -> float
      val maxy : Gg.box3 -> float
      val maxz : Gg.box3 -> float
      val mid : Gg.box3 -> Gg.p3
      val midx : Gg.box3 -> float
      val midy : Gg.box3 -> float
      val midz : Gg.box3 -> float
      val area : Gg.box3 -> float
      val volume : Gg.box3 -> float
      val inter : Gg.box3 -> Gg.box3 -> Gg.box3
      val union : Gg.box3 -> Gg.box3 -> Gg.box3
      val inset : Gg.v3 -> Gg.box3 -> Gg.box3
      val round : Gg.box3 -> Gg.box3
      val move : Gg.v3 -> Gg.box3 -> Gg.box3
      val ltr : Gg.m3 -> Gg.box3 -> Gg.box3
      val tr : Gg.m4 -> Gg.box3 -> Gg.box3
      val map_f : (float -> float) -> Gg.box3 -> Gg.box3
      val is_empty : Gg.box3 -> bool
      val is_pt : Gg.box3 -> bool
      val is_plane : Gg.box3 -> bool
      val is_seg : Gg.box3 -> bool
      val isects : Gg.box3 -> Gg.box3 -> bool
      val subset : Gg.box3 -> Gg.box3 -> bool
      val mem : Gg.p3 -> Gg.box3 -> bool
      val equal : Gg.box3 -> Gg.box3 -> bool
      val equal_f : (float -> float -> bool) -> Gg.box3 -> Gg.box3 -> bool
      val compare : Gg.box3 -> Gg.box3 -> int
      val compare_f : (float -> float -> int) -> Gg.box3 -> Gg.box3 -> int
      val to_string : Gg.box3 -> string
      val pp : Format.formatter -> Gg.box3 -> unit
      val pp_f :
        (Format.formatter -> float -> unit) ->
        Format.formatter -> Gg.box3 -> unit
    end
  type color = Gg.v4
  module Color :
    sig
      type t = Gg.color
      type stops = (float * Gg.color) list
      val v : float -> float -> float -> float -> Gg.color
      val v_srgb : ?a:float -> float -> float -> float -> Gg.color
      val v_srgbi : ?a:float -> int -> int -> int -> Gg.color
      val r : Gg.color -> float
      val g : Gg.color -> float
      val b : Gg.color -> float
      val a : Gg.color -> float
      val void : Gg.color
      val black : Gg.color
      val gray : ?a:float -> float -> Gg.color
      val white : Gg.color
      val red : Gg.color
      val green : Gg.color
      val blue : Gg.color
      val blend : Gg.color -> Gg.color -> Gg.color
      val clamp : Gg.color -> Gg.color
      val with_a : Gg.color -> float -> Gg.color
      type srgb = Gg.v4
      val of_srgb : Gg.Color.srgb -> Gg.color
      val to_srgb : Gg.color -> Gg.Color.srgb
      type luv = Gg.v4
      val of_luv : Gg.Color.luv -> Gg.color
      val to_luv : Gg.color -> Gg.Color.luv
      type lch_uv = Gg.v4
      val of_lch_uv : Gg.Color.lch_uv -> Gg.color
      val to_lch_uv : Gg.color -> Gg.Color.lch_uv
      type lab = Gg.v4
      val of_lab : Gg.v4 -> Gg.color
      val to_lab : Gg.color -> Gg.v4
      type lch_ab = Gg.v4
      val of_lch_ab : Gg.Color.lch_ab -> Gg.color
      val to_lch_ab : Gg.color -> Gg.Color.lch_ab
      type space =
          [ `CLR2
          | `CLR3
          | `CLR4
          | `CLR5
          | `CLR6
          | `CLR7
          | `CLR8
          | `CLR9
          | `CLRA
          | `CLRB
          | `CLRC
          | `CLRD
          | `CLRE
          | `CLRF
          | `CMY
          | `CMYK
          | `Gray
          | `HLS
          | `HSV
          | `Lab
          | `Luv
          | `RGB
          | `XYZ
          | `YCbr
          | `Yxy ]
      val space_dim : Gg.Color.space -> int
      val pp_space : Format.formatter -> Gg.Color.space -> unit
      type profile
      val profile_of_icc : string -> Gg.Color.profile option
      val profile_to_icc : Gg.Color.profile -> string
      val profile_space : Gg.Color.profile -> Gg.Color.space
      val profile_dim : Gg.Color.profile -> int
      val p_gray_l : Gg.Color.profile
      val p_rgb_l : Gg.Color.profile
    end
  type raster
  module Raster :
    sig
      type scalar_type =
          [ `Float16
          | `Float32
          | `Float64
          | `Int16
          | `Int32
          | `Int64
          | `Int8
          | `UInt16
          | `UInt32
          | `UInt64
          | `UInt8 ]
      val scalar_type_byte_count : Gg.Raster.scalar_type -> int
      val pp_scalar_type : Format.formatter -> Gg.Raster.scalar_type -> unit
      type ('a, 'b) b_array = ('a, 'b, Bigarray.c_layout) Bigarray.Array1.t
      type buffer =
          [ `A_Float64 of float array
          | `B_Float16 of
              (int, Bigarray.int16_unsigned_elt) Gg.Raster.b_array
          | `B_Float32 of (float, Bigarray.float32_elt) Gg.Raster.b_array
          | `B_Float64 of (float, Bigarray.float64_elt) Gg.Raster.b_array
          | `B_Int16 of (int, Bigarray.int16_signed_elt) Gg.Raster.b_array
          | `B_Int32 of (int32, Bigarray.int32_elt) Gg.Raster.b_array
          | `B_Int64 of (int64, Bigarray.int64_elt) Gg.Raster.b_array
          | `B_Int8 of (int, Bigarray.int8_signed_elt) Gg.Raster.b_array
          | `B_UInt16 of (int, Bigarray.int16_unsigned_elt) Gg.Raster.b_array
          | `B_UInt32 of (int32, Bigarray.int32_elt) Gg.Raster.b_array
          | `B_UInt64 of (int64, Bigarray.int64_elt) Gg.Raster.b_array
          | `B_UInt8 of (int, Bigarray.int8_unsigned_elt) Gg.Raster.b_array
          | `S_UInt8 of string ]
      val buffer_scalar_type : Gg.Raster.buffer -> Gg.Raster.scalar_type
      val pp_buffer : Format.formatter -> Gg.Raster.buffer -> unit
      type sample_semantics =
          [ `Color of Gg.Color.profile * bool | `Other of string * int ]
      val rgb_l : Gg.Raster.sample_semantics
      val rgba_l : Gg.Raster.sample_semantics
      val gray_l : Gg.Raster.sample_semantics
      val graya_l : Gg.Raster.sample_semantics
      val pp_sample_semantics :
        Format.formatter -> Gg.Raster.sample_semantics -> unit
      type sample_pack =
          [ `FourCC of string * Gg.Raster.scalar_type option
          | `Other of string * Gg.Raster.scalar_type option
          | `PU8888 ]
      val pp_sample_pack : Format.formatter -> Gg.Raster.sample_pack -> unit
      type sample_format
      val sample_format_v :
        ?pack:Gg.Raster.sample_pack ->
        Gg.Raster.sample_semantics ->
        Gg.Raster.scalar_type -> Gg.Raster.sample_format
      val sf_semantics :
        Gg.Raster.sample_format -> Gg.Raster.sample_semantics
      val sf_scalar_type : Gg.Raster.sample_format -> Gg.Raster.scalar_type
      val sf_pack : Gg.Raster.sample_format -> Gg.Raster.sample_pack option
      val sf_dim : Gg.Raster.sample_format -> int
      val sf_scalar_count :
        ?first:int ->
        ?w_skip:int ->
        ?h_skip:int ->
        w:int -> ?h:int -> ?d:int -> Gg.Raster.sample_format -> int
      val pp_sample_format :
        Format.formatter -> Gg.Raster.sample_format -> unit
      type t = Gg.raster
      val v :
        ?res:Gg.v3 ->
        ?first:int ->
        ?w_skip:int ->
        ?h_skip:int ->
        w:int ->
        ?h:int ->
        ?d:int -> Gg.Raster.sample_format -> Gg.Raster.buffer -> Gg.Raster.t
      val res : Gg.Raster.t -> Gg.v3 option
      val first : Gg.Raster.t -> int
      val w_skip : Gg.Raster.t -> int
      val h_skip : Gg.Raster.t -> int
      val w : Gg.Raster.t -> int
      val h : Gg.Raster.t -> int
      val d : Gg.Raster.t -> int
      val sample_format : Gg.Raster.t -> Gg.Raster.sample_format
      val buffer : Gg.Raster.t -> Gg.Raster.buffer
      val dim : Gg.Raster.t -> int
      val size2 : Gg.Raster.t -> Gg.size2
      val size3 : Gg.Raster.t -> Gg.size3
      val sub :
        ?x:int ->
        ?y:int ->
        ?z:int -> ?w:int -> ?h:int -> ?d:int -> Gg.Raster.t -> Gg.Raster.t
      val pitches : Gg.Raster.t -> int * int * int
      val equal : Gg.Raster.t -> Gg.Raster.t -> bool
      val compare : Gg.Raster.t -> Gg.Raster.t -> int
      val to_string : Gg.Raster.t -> string
      val pp : Format.formatter -> Gg.Raster.t -> unit
    end
end