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 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 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 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 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 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 rot3_map : Gg.v3 -> Gg.v3 -> Gg.quat       val rot3_axis : Gg.v3 -> float -> Gg.quat       val rot3_zyx : Gg.v3 -> Gg.quat       val to_rot3_axis : Gg.quat -> Gg.v3 * float       val to_rot3_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 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 rot2 : float -> Gg.m2       val scale2 : 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 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 move2 : Gg.v2 -> Gg.m3       val rot2 : ?pt:Gg.p2 -> float -> Gg.m3       val scale2 : Gg.v2 -> Gg.m3       val rigid2 : move:Gg.v2 -> rot:float -> Gg.m3       val srigid2 : move:Gg.v2 -> rot:float -> scale:Gg.v2 -> Gg.m3       val rot3_map : Gg.v3 -> Gg.v3 -> Gg.m3       val rot3_axis : Gg.v3 -> float -> Gg.m3       val rot3_zyx : Gg.v3 -> Gg.m3       val scale3 : 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 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 move2 : Gg.v2 -> Gg.m4       val rot2 : ?pt:Gg.p2 -> float -> Gg.m4       val scale2 : Gg.v2 -> Gg.m4       val rigid2 : move:Gg.v2 -> rot:float -> Gg.m4       val srigid2 : move:Gg.v2 -> rot:float -> scale:Gg.v2 -> Gg.m4       val move3 : Gg.v3 -> Gg.m4       val rot3_map : Gg.v3 -> Gg.v3 -> Gg.m4       val rot3_axis : Gg.v3 -> float -> Gg.m4       val rot3_zyx : Gg.v3 -> Gg.m4       val scale3 : Gg.v3 -> Gg.m4       val rigid3 : move:Gg.v3 -> rot:Gg.v3 * float -> Gg.m4       val rigid3q : move:Gg.v3 -> rot:Gg.quat -> Gg.m4       val srigid3 : move:Gg.v3 -> rot:Gg.v3 * float -> scale:Gg.v3 -> Gg.m4       val srigid3q : move:Gg.v3 -> rot:Gg.quat -> scale:Gg.v3 -> Gg.m4       val ortho :         left:float ->         right:float ->         bot:float -> top:float -> near:float -> far:float -> Gg.m4       val persp :         left:float ->         right:float ->         bot:float -> top:float -> near:float -> far:float -> Gg.m4       val scale4 : 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 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 size1 = float   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 Size1 :     sig       type t = float       val dim : int       val v : float -> Gg.size1       val w : Gg.size1 -> float       val zero : Gg.size1       val unit : Gg.size1     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       val aspect : Gg.size2 -> float       val of_w : float -> aspect:float -> Gg.size2       val of_h : float -> aspect:float -> 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 box1   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 pp : Format.formatter -> Gg.Box.t -> unit       val pp_f :         (Format.formatter -> float -> unit) ->         Format.formatter -> Gg.Box.t -> unit     end   module Box1 :     sig       type t       val dim : int       type v = float       type p = float       type size = Gg.size1       type m = float       val v : float -> Gg.size1 -> Gg.box1       val v_mid : float -> Gg.size1 -> Gg.box1       val empty : Gg.box1       val o : Gg.box1 -> float       val ox : Gg.box1 -> float       val size : Gg.box1 -> Gg.size1       val w : Gg.box1 -> float       val zero : Gg.box1       val unit : Gg.box1       val of_pts : float -> float -> Gg.box1       val min : Gg.box1 -> float       val minx : Gg.box1 -> float       val max : Gg.box1 -> float       val maxx : Gg.box1 -> float       val mid : Gg.box1 -> float       val midx : Gg.box1 -> float       val left : Gg.box1 -> float       val right : Gg.box1 -> float       val area : Gg.box1 -> float       val inter : Gg.box1 -> Gg.box1 -> Gg.box1       val union : Gg.box1 -> Gg.box1 -> Gg.box1       val inset : float -> Gg.box1 -> Gg.box1       val round : Gg.box1 -> Gg.box1       val move : float -> Gg.box1 -> Gg.box1       val ltr : float -> Gg.box1 -> Gg.box1       val tr : Gg.m2 -> Gg.box1 -> Gg.box1       val map_f : (float -> float) -> Gg.box1 -> Gg.box1       val is_empty : Gg.box1 -> bool       val is_pt : Gg.box1 -> bool       val isects : Gg.box1 -> Gg.box1 -> bool       val subset : Gg.box1 -> Gg.box1 -> bool       val mem : float -> Gg.box1 -> bool       val equal : Gg.box1 -> Gg.box1 -> bool       val equal_f : (float -> float -> bool) -> Gg.box1 -> Gg.box1 -> bool       val compare : Gg.box1 -> Gg.box1 -> int       val compare_f : (float -> float -> int) -> Gg.box1 -> Gg.box1 -> int       val pp : Format.formatter -> Gg.box1 -> unit       val pp_f :         (Format.formatter -> float -> unit) ->         Format.formatter -> Gg.box1 -> 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 bl_pt : Gg.box2 -> Gg.p2       val bm_pt : Gg.box2 -> Gg.p2       val br_pt : Gg.box2 -> Gg.p2       val ml_pt : Gg.box2 -> Gg.p2       val mm_pt : Gg.box2 -> Gg.p2       val mr_pt : Gg.box2 -> Gg.p2       val tl_pt : Gg.box2 -> Gg.p2       val tm_pt : Gg.box2 -> Gg.p2       val tr_pt : 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 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 fbl_pt : Gg.box3 -> Gg.p3       val fbr_pt : Gg.box3 -> Gg.p3       val ftl_pt : Gg.box3 -> Gg.p3       val ftr_pt : Gg.box3 -> Gg.p3       val nbl_pt : Gg.box3 -> Gg.p3       val nbr_pt : Gg.box3 -> Gg.p3       val ntl_pt : Gg.box3 -> Gg.p3       val ntr_pt : Gg.box3 -> Gg.p3       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 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 ('a, 'b) bigarray = ('a, 'b, Bigarray.c_layout) Bigarray.Array1.t   type buffer =       [ `Float16 of (int, Bigarray.int16_unsigned_elt) Gg.bigarray       | `Float32 of (float, Bigarray.float32_elt) Gg.bigarray       | `Float64 of (float, Bigarray.float64_elt) Gg.bigarray       | `Int16 of (int, Bigarray.int16_signed_elt) Gg.bigarray       | `Int32 of (int32, Bigarray.int32_elt) Gg.bigarray       | `Int64 of (int64, Bigarray.int64_elt) Gg.bigarray       | `Int8 of (int, Bigarray.int8_signed_elt) Gg.bigarray       | `UInt16 of (int, Bigarray.int16_unsigned_elt) Gg.bigarray       | `UInt32 of (int32, Bigarray.int32_elt) Gg.bigarray       | `UInt64 of (int64, Bigarray.int64_elt) Gg.bigarray       | `UInt8 of (int, Bigarray.int8_unsigned_elt) Gg.bigarray ]   module Ba :     sig       type ('a, 'b) ba_scalar_type =           Int8 : (int, Bigarray.int8_signed_elt) Gg.Ba.ba_scalar_type         | Int16 : (int, Bigarray.int16_signed_elt) Gg.Ba.ba_scalar_type         | Int32 : (int32, Bigarray.int32_elt) Gg.Ba.ba_scalar_type         | Int64 : (int64, Bigarray.int64_elt) Gg.Ba.ba_scalar_type         | UInt8 : (int, Bigarray.int8_unsigned_elt) Gg.Ba.ba_scalar_type         | UInt16 : (int, Bigarray.int16_unsigned_elt) Gg.Ba.ba_scalar_type         | UInt32 : (int32, Bigarray.int32_elt) Gg.Ba.ba_scalar_type         | UInt64 : (int64, Bigarray.int64_elt) Gg.Ba.ba_scalar_type         | Float16 : (int, Bigarray.int16_unsigned_elt) Gg.Ba.ba_scalar_type         | Float32 : (float, Bigarray.float32_elt) Gg.Ba.ba_scalar_type         | Float64 : (float, Bigarray.float64_elt) Gg.Ba.ba_scalar_type       val ba_kind_of_ba_scalar_type :         ('a, 'b) Gg.Ba.ba_scalar_type -> ('a, 'b) Bigarray.kind       type scalar_type =           [ `Float16           | `Float32           | `Float64           | `Int16           | `Int32           | `Int64           | `Int8           | `UInt16           | `UInt32           | `UInt64           | `UInt8 ]       val scalar_type_of_ba_scalar_type :         ('a, 'b) Gg.Ba.ba_scalar_type -> Gg.Ba.scalar_type       val scalar_type_byte_count : Gg.Ba.scalar_type -> int       val pp_scalar_type : Format.formatter -> Gg.Ba.scalar_type -> unit       module Buffer :         sig           type t = Gg.buffer           val create : Gg.Ba.scalar_type -> int -> Gg.buffer           val scalar_type : Gg.buffer -> Gg.Ba.scalar_type           val length : Gg.buffer -> int           val byte_length : Gg.buffer -> int           val of_bigarray :             ?data:[ `Float | `Unsigned ] -> ('a, 'b) Gg.bigarray -> Gg.buffer           val pp : Format.formatter -> Gg.buffer -> unit         end       val create :         ('a, 'b) Gg.Ba.ba_scalar_type -> int -> ('a, 'b) Gg.bigarray       val length : ('a, 'b) Gg.bigarray -> int       val sub : ('a, 'b) Gg.bigarray -> int -> int -> ('a, 'b) Gg.bigarray       val blit :         ('a, 'b) Gg.bigarray ->         int -> ('a, 'b) Gg.bigarray -> int -> int -> unit       val fill : ('a, 'b) Gg.bigarray -> '-> unit       val of_array :         ('a, 'b) Gg.Ba.ba_scalar_type -> 'a array -> ('a, 'b) Gg.bigarray       val of_list :         ('a, 'b) Gg.Ba.ba_scalar_type -> 'a list -> ('a, 'b) Gg.bigarray       val of_bytes :         ?be:bool ->         ('a, 'b) Gg.Ba.ba_scalar_type -> string -> ('a, 'b) Gg.bigarray       val pp :         ?count:int ->         ?stride:int ->         ?first:int ->         ?dim:int ->         pp_scalar:(Format.formatter -> '-> unit) ->         Format.formatter -> ('a, 'b) Gg.bigarray -> unit       val unsafe_get : ('a, 'b) Gg.bigarray -> int -> 'a       val get_v2 : (float, 'b) Gg.bigarray -> int -> Gg.v2       val get_v3 : (float, 'b) Gg.bigarray -> int -> Gg.v3       val get_v4 : (float, 'b) Gg.bigarray -> int -> Gg.v4       val get_2d : ('a, 'b) Gg.bigarray -> int -> 'a * 'a       val get_3d : ('a, 'b) Gg.bigarray -> int -> 'a * 'a * 'a       val get_4d : ('a, 'b) Gg.bigarray -> int -> 'a * 'a * 'a * 'a       val geti_2d : (int32, 'b) Gg.bigarray -> int -> int * int       val geti_3d : (int32, 'b) Gg.bigarray -> int -> int * int * int       val unsafe_set : ('a, 'b) Gg.bigarray -> int -> '-> unit       val set_v2 : (float, 'b) Gg.bigarray -> int -> Gg.v2 -> unit       val set_v3 : (float, 'b) Gg.bigarray -> int -> Gg.v3 -> unit       val set_v4 : (float, 'b) Gg.bigarray -> int -> Gg.v4 -> unit       val set_2d : ('a, 'b) Gg.bigarray -> int -> '-> '-> unit       val set_3d : ('a, 'b) Gg.bigarray -> int -> '-> '-> '-> unit       val set_4d :         ('a, 'b) Gg.bigarray -> int -> '-> '-> '-> '-> unit       val seti_2d : (int32, 'b) Gg.bigarray -> int -> int -> int -> unit       val seti_3d :         (int32, 'b) Gg.bigarray -> int -> int -> int -> int -> unit     end   type raster   module Raster :     sig       module Sample :         sig           type 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_semantics :             Format.formatter -> Gg.Raster.Sample.semantics -> unit           type pack =               [ `FourCC of string * Gg.Ba.scalar_type option               | `Other of string * Gg.Ba.scalar_type option               | `PU8888 ]           val pp_pack : Format.formatter -> Gg.Raster.Sample.pack -> unit           type format           val format :             ?pack:Gg.Raster.Sample.pack ->             Gg.Raster.Sample.semantics ->             Gg.Ba.scalar_type -> Gg.Raster.Sample.format           val semantics :             Gg.Raster.Sample.format -> Gg.Raster.Sample.semantics           val scalar_type : Gg.Raster.Sample.format -> Gg.Ba.scalar_type           val pack : Gg.Raster.Sample.format -> Gg.Raster.Sample.pack option           val dim : Gg.Raster.Sample.format -> int           val scalar_count :             ?first:int ->             ?w_stride:int ->             ?h_stride:int ->             [ `D1 of Gg.size1 | `D2 of Gg.size2 | `D3 of Gg.size3 ] ->             Gg.Raster.Sample.format -> int           val pp_format : Format.formatter -> Gg.Raster.Sample.format -> unit         end       type t = Gg.raster       val v :         ?res:Gg.v3 ->         ?first:int ->         ?w_stride:int ->         ?h_stride:int ->         [ `D1 of float | `D2 of Gg.size2 | `D3 of Gg.size3 ] ->         Gg.Raster.Sample.format -> Gg.buffer -> Gg.Raster.t       val res : Gg.Raster.t -> Gg.v3 option       val get_res : Gg.Raster.t -> Gg.v3       val first : Gg.Raster.t -> int       val w_stride : Gg.Raster.t -> int       val h_stride : Gg.Raster.t -> int       val sample_format : Gg.Raster.t -> Gg.Raster.Sample.format       val buffer : Gg.Raster.t -> Gg.buffer       val wi : Gg.Raster.t -> int       val hi : Gg.Raster.t -> int       val di : Gg.Raster.t -> int       val w : ?meters:bool -> Gg.Raster.t -> float       val h : ?meters:bool -> Gg.Raster.t -> float       val d : ?meters:bool -> Gg.Raster.t -> float       val size1 : ?meters:bool -> Gg.Raster.t -> Gg.size1       val size2 : ?meters:bool -> Gg.Raster.t -> Gg.size2       val size3 : ?meters:bool -> Gg.Raster.t -> Gg.size3       val box1 :         ?meters:bool -> ?mid:bool -> ?o:float -> Gg.Raster.t -> Gg.box1       val box2 :         ?meters:bool -> ?mid:bool -> ?o:Gg.p2 -> Gg.Raster.t -> Gg.box2       val box3 :         ?meters:bool -> ?mid:bool -> ?o:Gg.p3 -> Gg.Raster.t -> Gg.box3       val dim : Gg.Raster.t -> int       val kind : Gg.Raster.t -> [ `D1 | `D2 | `D3 ]       val sub :         [ `D1 of Gg.box1 | `D2 of Gg.box2 | `D3 of Gg.box3 ] ->         Gg.Raster.t -> Gg.Raster.t       val scalar_strides : 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 pp : Format.formatter -> Gg.Raster.t -> unit       val res_default : float       val spm_of_spi : float -> float       val spm_to_spi : float -> float     end end