Up
# module Q

: sig
# Types

# Construction

# Inspection

# Testing

# Conversions

# Arithmetic operations

# Printing

# Prefix and infix operators

Rationals.

This modules builds arbitrary precision rationals on top of arbitrary integers from module Z.

This file is part of the Zarith library http://forge.ocamlcore.org/projects/zarith . It is distributed under LGPL 2 licensing, with static linking exception. See the LICENSE file included in the distribution.

Copyright (c) 2010-2011 Antoine Miné, Abstraction project. Abstraction is part of the LIENS (Laboratoire d'Informatique de l'ENS), a joint laboratory by: CNRS (Centre national de la recherche scientifique, France), ENS (École normale supérieure, Paris, France), INRIA Rocquencourt (Institut national de recherche en informatique, France).

#

type t = {

}

#
num
| : Z.t | ; | (* | Numerator. | *) |

#
den
| : Z.t | ; | (* | Denominator, >= 0 | *) |

A rational is represented as a pair numerator/denominator, reduced to
have a non-negative denominator and no common factor.
This form is canonical (enabling polymorphic equality and hashing).
The representation allows three special numbers: `inf`

(1/0), `-inf`

(-1/0)
and `undef`

(0/0).

#

val of_string : string -> t

Converts a string to a rational.
Plain decimals, and `/`

separated decimal ratios (with optional sign) are
understood.
Additionally, the special `inf`

, `-inf`

, and `undef`

are recognized
(they can also be typeset respectively as `1/0`

, `-1/0`

, `0/0`

).

#

type kind =

#
| ZERO
| (* | 0 | *) |

#
| INF
| (* | infinity, i.e. 1/0 | *) |

#
| MINF
| (* | minus infinity, i.e. -1/0 | *) |

#
| UNDEF
| (* | undefined, i.e., 0/0 | *) |

#
| NZERO
| (* | well-defined, non-infinity, non-zero number | *) |

Rationals can be categorized into different kinds, depending mainly on whether the numerator and/or denominator is null.

#

val sign : t -> int

Returns 1 if the argument is positive (including inf), -1 if it is negative (including -inf), and 0 if it is null or undefined.

#

val compare : t -> t -> int

`compare x y`

compares `x`

to `y`

and returns 1 if `x`

is strictly
greater that `y`

, -1 if it is strictly smaller, and 0 if they are
equal.
This is a total ordering.
Infinities are ordered in the natural way, while undefined is considered
the smallest of all: undef = undef < -inf <= -inf < x < inf <= inf.
This is consistent with OCaml's handling of floating-point infinities
and NaN.

OCaml's polymorphic comparison will NOT return a result consistent with the ordering of rationals.

#

val to_nativeint : t -> nativeint

Convert to integer by truncation.
Raises a `Divide_by_zero`

if the argument is an infinity or undefined.
Raises a `Z.Overflow`

if the result does not fit in the destination
type.

In all operations, the result is `undef`

if one argument is `undef`

.
Other operations can return `undef`

: such as `inf`

-`inf`

, `inf`

*0, 0/0.

#

val output : Pervasives.out_channel -> t -> unit

Prints the argument on the specified channel.
Also intended to be used as `%a`

format printer in `Printf.printf`

.

Classic prefix and infix `int`

operators are redefined on `t`

.

end