/usr/lib/ocaml/num.mli is in ocaml-nox 4.01.0-3ubuntu3.1.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 | (***********************************************************************)
(* *)
(* OCaml *)
(* *)
(* Valerie Menissier-Morain, projet Cristal, INRIA Rocquencourt *)
(* *)
(* Copyright 1996 Institut National de Recherche en Informatique et *)
(* en Automatique. All rights reserved. This file is distributed *)
(* under the terms of the GNU Library General Public License, with *)
(* the special exception on linking described in file ../../LICENSE. *)
(* *)
(***********************************************************************)
(* $Id$ *)
(** Operation on arbitrary-precision numbers.
Numbers (type [num]) are arbitrary-precision rational numbers,
plus the special elements [1/0] (infinity) and [0/0] (undefined).
*)
open Nat
open Big_int
open Ratio
(** The type of numbers. *)
type num =
Int of int
| Big_int of big_int
| Ratio of ratio
(** {6 Arithmetic operations} *)
val ( +/ ) : num -> num -> num
(** Same as {!Num.add_num}.*)
val add_num : num -> num -> num
(** Addition *)
val minus_num : num -> num
(** Unary negation. *)
val ( -/ ) : num -> num -> num
(** Same as {!Num.sub_num}.*)
val sub_num : num -> num -> num
(** Subtraction *)
val ( */ ) : num -> num -> num
(** Same as {!Num.mult_num}.*)
val mult_num : num -> num -> num
(** Multiplication *)
val square_num : num -> num
(** Squaring *)
val ( // ) : num -> num -> num
(** Same as {!Num.div_num}.*)
val div_num : num -> num -> num
(** Division *)
val quo_num : num -> num -> num
(** Euclidean division: quotient. *)
val mod_num : num -> num -> num
(** Euclidean division: remainder. *)
val ( **/ ) : num -> num -> num
(** Same as {!Num.power_num}. *)
val power_num : num -> num -> num
(** Exponentiation *)
val abs_num : num -> num
(** Absolute value. *)
val succ_num : num -> num
(** [succ n] is [n+1] *)
val pred_num : num -> num
(** [pred n] is [n-1] *)
val incr_num : num ref -> unit
(** [incr r] is [r:=!r+1], where [r] is a reference to a number. *)
val decr_num : num ref -> unit
(** [decr r] is [r:=!r-1], where [r] is a reference to a number. *)
val is_integer_num : num -> bool
(** Test if a number is an integer *)
(** The four following functions approximate a number by an integer : *)
val integer_num : num -> num
(** [integer_num n] returns the integer closest to [n]. In case of ties,
rounds towards zero. *)
val floor_num : num -> num
(** [floor_num n] returns the largest integer smaller or equal to [n]. *)
val round_num : num -> num
(** [round_num n] returns the integer closest to [n]. In case of ties,
rounds off zero. *)
val ceiling_num : num -> num
(** [ceiling_num n] returns the smallest integer bigger or equal to [n]. *)
val sign_num : num -> int
(** Return [-1], [0] or [1] according to the sign of the argument. *)
(** {7 Comparisons between numbers} *)
val ( =/ ) : num -> num -> bool
val ( </ ) : num -> num -> bool
val ( >/ ) : num -> num -> bool
val ( <=/ ) : num -> num -> bool
val ( >=/ ) : num -> num -> bool
val ( <>/ ) : num -> num -> bool
val eq_num : num -> num -> bool
val lt_num : num -> num -> bool
val le_num : num -> num -> bool
val gt_num : num -> num -> bool
val ge_num : num -> num -> bool
val compare_num : num -> num -> int
(** Return [-1], [0] or [1] if the first argument is less than,
equal to, or greater than the second argument. *)
val max_num : num -> num -> num
(** Return the greater of the two arguments. *)
val min_num : num -> num -> num
(** Return the smaller of the two arguments. *)
(** {6 Coercions with strings} *)
val string_of_num : num -> string
(** Convert a number to a string, using fractional notation. *)
val approx_num_fix : int -> num -> string
(** See {!Num.approx_num_exp}.*)
val approx_num_exp : int -> num -> string
(** Approximate a number by a decimal. The first argument is the
required precision. The second argument is the number to
approximate. {!Num.approx_num_fix} uses decimal notation; the first
argument is the number of digits after the decimal point.
[approx_num_exp] uses scientific (exponential) notation; the
first argument is the number of digits in the mantissa. *)
val num_of_string : string -> num
(** Convert a string to a number.
Raise [Failure "num_of_string"] if the given string is not
a valid representation of an integer *)
(** {6 Coercions between numerical types} *)
val int_of_num : num -> int
val num_of_int : int -> num
val nat_of_num : num -> nat
val num_of_nat : nat -> num
val num_of_big_int : big_int -> num
val big_int_of_num : num -> big_int
val ratio_of_num : num -> ratio
val num_of_ratio : ratio -> num
val float_of_num : num -> float
|