# Module Span

    module Span: sig .. end

###### Basic operations on spans

    type t = private float

    module Parts: sig .. end

    include Comparable_binable

    include Comparable.With_zero

    include Floatable

    include Hashable_binable

    include Pretty_printer.S

    include Robustly_comparable

    val to_string : t -> string

    val of_string : string -> t

    val nanosecond : t

    val microsecond : t

    val millisecond : t

    val second : t

    val minute : t

    val hour : t

    val day : t

    val robust_comparison_tolerance : t

    val zero : t

    val create : ?sign:Core_kernel.Std.Float.Sign.t ->
           ?day:int ->
           ?hr:int -> ?min:int -> ?sec:int -> ?ms:int -> ?us:int -> unit -> t

    val to_parts : t -> Parts.t

    val of_ns : float -> t

    val of_us : float -> t

    val of_ms : float -> t

    val of_sec : float -> t

    val of_int_sec : int -> t

    val of_min : float -> t

    val of_hr : float -> t

    val of_day : float -> t

    val to_ns : t -> float

    val to_us : t -> float

    val to_ms : t -> float

    val to_sec : t -> float

    val to_min : t -> float

    val to_hr : t -> float

    val to_day : t -> float

    val (+) : t -> t -> t

###### Basic operations on spans

    val (-) : t -> t -> t

    val abs : t -> t

absolute value

    val neg : t -> t

negation

    val scale : t -> float -> t

    val (/) : t -> float -> t

    val (//) : t -> t -> float

    val to_short_string : t -> string

`to_short_string t` pretty-prints approximate time span using no more than five characters if the span is positive, and six if the span is negative. Examples

- `"4h"` = 4 hours
- `"5m"` = 5 minutes
- `"4s"` = 4 seconds
- `"10ms"` = 10 milliseconds

only the most significant denomination is shown.

    module Unit_of_time: sig .. end

    val to_unit_of_time : t -> Unit_of_time.t

`to_unit_of_time t` = `Day` if `abs t >= day`, `Hour` if `abs t >= hour`, and so on down to `Microsecond` if `abs t >= microsecond`, and `Nanosecond` otherwise.

    val of_unit_of_time : Unit_of_time.t -> t

`of_unit_of_time unit_of_time` produces a `t` representing the corresponding span.

    val to_string_hum : ?delimiter:char ->
           ?decimals:int ->
           ?align_decimal:bool -> ?unit_of_time:Unit_of_time.t -> t -> string

`to_string_hum t ~delimiter ~decimals ~align_decimal ~unit_of_time` formats `t` using the given unit of time, or the largest appropriate units if none is specified, among "d"=day, "h"=hour, "m"=minute, "s"=second, "ms"=millisecond, "us"=microsecond, or "ns"=nanosecond. The magnitude of the time span in the chosen unit is formatted by:

`Float.to_string_hum ~delimiter ~decimals ~strip_zero:(not align_decimal)`

If `align_decimal` is true, the single-character suffixes are padded with an extra space character. In combination with not stripping zeroes, this means that the decimal point will occur a fixed number of characters from the end of the string.

    val randomize : t -> percent:float -> t

`randomize t ~percent` returns a span +/- percent * original span. Percent must be between 0 and 1, and must be positive.

    module Stable: sig .. end

    val t_of_sexp : Sexplib.Sexp.t -> t

    val sexp_of_t : t -> Sexplib.Sexp.t

    val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t

    val bin_read_t : t Core_kernel.Std.Bin_prot.Read.reader

    val __bin_read_t__ : (int -> t) Core_kernel.Std.Bin_prot.Read.reader

    val bin_reader_t : t Core_kernel.Std.Bin_prot.Type_class.reader

    val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer

    val bin_write_t : t Core_kernel.Std.Bin_prot.Write.writer

    val bin_writer_t : t Core_kernel.Std.Bin_prot.Type_class.writer

###### Basic operations on spans

absolute value
negation
`to_short_string t` pretty-prints approximate time span using no more than five characters if the span is positive, and six if the span is negative. Examples

- `"4h"` = 4 hours
- `"5m"` = 5 minutes
- `"4s"` = 4 seconds
- `"10ms"` = 10 milliseconds

only the most significant denomination is shown.
Represents a unit of time for purposes of human-readable display. Comparison respects Nanosecond < Microsecond < Millisecond < Second < Minute < Hour < Day.
`to_unit_of_time t` = `Day` if `abs t >= day`, `Hour` if `abs t >= hour`, and so on down to `Microsecond` if `abs t >= microsecond`, and `Nanosecond` otherwise.
`of_unit_of_time unit_of_time` produces a `t` representing the corresponding span.
`to_string_hum t ~delimiter ~decimals ~align_decimal ~unit_of_time` formats `t` using the given unit of time, or the largest appropriate units if none is specified, among "d"=day, "h"=hour, "m"=minute, "s"=second, "ms"=millisecond, "us"=microsecond, or "ns"=nanosecond. The magnitude of the time span in the chosen unit is formatted by:

`Float.to_string_hum ~delimiter ~decimals ~strip_zero:(not align_decimal)`

If `align_decimal` is true, the single-character suffixes are padded with an extra space character. In combination with not stripping zeroes, this means that the decimal point will occur a fixed number of characters from the end of the string.
defaults to `'_'`
defaults to 3
defaults to `false`
defaults to `to_unit_of_time t`
`randomize t ~percent` returns a span +/- percent * original span. Percent must be between 0 and 1, and must be positive.