/usr/i686-w64-mingw32/lib/ocaml/big_int.mli is in ocaml-mingw-w64-i686 4.01.0~20140328-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 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 | (***********************************************************************)
(* *)
(* 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$ *)
(** Operations on arbitrary-precision integers.
Big integers (type [big_int]) are signed integers of arbitrary size.
*)
open Nat
type big_int
(** The type of big integers. *)
val zero_big_int : big_int
(** The big integer [0]. *)
val unit_big_int : big_int
(** The big integer [1]. *)
(** {6 Arithmetic operations} *)
val minus_big_int : big_int -> big_int
(** Unary negation. *)
val abs_big_int : big_int -> big_int
(** Absolute value. *)
val add_big_int : big_int -> big_int -> big_int
(** Addition. *)
val succ_big_int : big_int -> big_int
(** Successor (add 1). *)
val add_int_big_int : int -> big_int -> big_int
(** Addition of a small integer to a big integer. *)
val sub_big_int : big_int -> big_int -> big_int
(** Subtraction. *)
val pred_big_int : big_int -> big_int
(** Predecessor (subtract 1). *)
val mult_big_int : big_int -> big_int -> big_int
(** Multiplication of two big integers. *)
val mult_int_big_int : int -> big_int -> big_int
(** Multiplication of a big integer by a small integer *)
val square_big_int: big_int -> big_int
(** Return the square of the given big integer *)
val sqrt_big_int: big_int -> big_int
(** [sqrt_big_int a] returns the integer square root of [a],
that is, the largest big integer [r] such that [r * r <= a].
Raise [Invalid_argument] if [a] is negative. *)
val quomod_big_int : big_int -> big_int -> big_int * big_int
(** Euclidean division of two big integers.
The first part of the result is the quotient,
the second part is the remainder.
Writing [(q,r) = quomod_big_int a b], we have
[a = q * b + r] and [0 <= r < |b|].
Raise [Division_by_zero] if the divisor is zero. *)
val div_big_int : big_int -> big_int -> big_int
(** Euclidean quotient of two big integers.
This is the first result [q] of [quomod_big_int] (see above). *)
val mod_big_int : big_int -> big_int -> big_int
(** Euclidean modulus of two big integers.
This is the second result [r] of [quomod_big_int] (see above). *)
val gcd_big_int : big_int -> big_int -> big_int
(** Greatest common divisor of two big integers. *)
val power_int_positive_int: int -> int -> big_int
val power_big_int_positive_int: big_int -> int -> big_int
val power_int_positive_big_int: int -> big_int -> big_int
val power_big_int_positive_big_int: big_int -> big_int -> big_int
(** Exponentiation functions. Return the big integer
representing the first argument [a] raised to the power [b]
(the second argument). Depending
on the function, [a] and [b] can be either small integers
or big integers. Raise [Invalid_argument] if [b] is negative. *)
(** {6 Comparisons and tests} *)
val sign_big_int : big_int -> int
(** Return [0] if the given big integer is zero,
[1] if it is positive, and [-1] if it is negative. *)
val compare_big_int : big_int -> big_int -> int
(** [compare_big_int a b] returns [0] if [a] and [b] are equal,
[1] if [a] is greater than [b], and [-1] if [a] is smaller
than [b]. *)
val eq_big_int : big_int -> big_int -> bool
val le_big_int : big_int -> big_int -> bool
val ge_big_int : big_int -> big_int -> bool
val lt_big_int : big_int -> big_int -> bool
val gt_big_int : big_int -> big_int -> bool
(** Usual boolean comparisons between two big integers. *)
val max_big_int : big_int -> big_int -> big_int
(** Return the greater of its two arguments. *)
val min_big_int : big_int -> big_int -> big_int
(** Return the smaller of its two arguments. *)
val num_digits_big_int : big_int -> int
(** Return the number of machine words used to store the
given big integer. *)
(** {6 Conversions to and from strings} *)
val string_of_big_int : big_int -> string
(** Return the string representation of the given big integer,
in decimal (base 10). *)
val big_int_of_string : string -> big_int
(** Convert a string to a big integer, in decimal.
The string consists of an optional [-] or [+] sign,
followed by one or several decimal digits. *)
(** {6 Conversions to and from other numerical types} *)
val big_int_of_int : int -> big_int
(** Convert a small integer to a big integer. *)
val is_int_big_int : big_int -> bool
(** Test whether the given big integer is small enough to
be representable as a small integer (type [int])
without loss of precision. On a 32-bit platform,
[is_int_big_int a] returns [true] if and only if
[a] is between 2{^30} and 2{^30}-1. On a 64-bit platform,
[is_int_big_int a] returns [true] if and only if
[a] is between -2{^62} and 2{^62}-1. *)
val int_of_big_int : big_int -> int
(** Convert a big integer to a small integer (type [int]).
Raises [Failure "int_of_big_int"] if the big integer
is not representable as a small integer. *)
val big_int_of_int32 : int32 -> big_int
(** Convert a 32-bit integer to a big integer. *)
val big_int_of_nativeint : nativeint -> big_int
(** Convert a native integer to a big integer. *)
val big_int_of_int64 : int64 -> big_int
(** Convert a 64-bit integer to a big integer. *)
val int32_of_big_int : big_int -> int32
(** Convert a big integer to a 32-bit integer.
Raises [Failure] if the big integer is outside the
range [[-2{^31}, 2{^31}-1]]. *)
val nativeint_of_big_int : big_int -> nativeint
(** Convert a big integer to a native integer.
Raises [Failure] if the big integer is outside the
range [[Nativeint.min_int, Nativeint.max_int]]. *)
val int64_of_big_int : big_int -> int64
(** Convert a big integer to a 64-bit integer.
Raises [Failure] if the big integer is outside the
range [[-2{^63}, 2{^63}-1]]. *)
val float_of_big_int : big_int -> float
(** Returns a floating-point number approximating the
given big integer. *)
(** {6 Bit-oriented operations} *)
val and_big_int : big_int -> big_int -> big_int
(** Bitwise logical 'and'.
The arguments must be positive or zero. *)
val or_big_int : big_int -> big_int -> big_int
(** Bitwise logical 'or'.
The arguments must be positive or zero. *)
val xor_big_int : big_int -> big_int -> big_int
(** Bitwise logical 'exclusive or'.
The arguments must be positive or zero. *)
val shift_left_big_int : big_int -> int -> big_int
(** [shift_left_big_int b n] returns [b] shifted left by [n] bits.
Equivalent to multiplication by [2^n]. *)
val shift_right_big_int : big_int -> int -> big_int
(** [shift_right_big_int b n] returns [b] shifted right by [n] bits.
Equivalent to division by [2^n] with the result being
rounded towards minus infinity. *)
val shift_right_towards_zero_big_int : big_int -> int -> big_int
(** [shift_right_towards_zero_big_int b n] returns [b] shifted
right by [n] bits. The shift is performed on the absolute
value of [b], and the result has the same sign as [b].
Equivalent to division by [2^n] with the result being
rounded towards zero. *)
val extract_big_int : big_int -> int -> int -> big_int
(** [extract_big_int bi ofs n] returns a nonnegative number
corresponding to bits [ofs] to [ofs + n - 1] of the
binary representation of [bi]. If [bi] is negative,
a two's complement representation is used. *)
(**/**)
(** {6 For internal use} *)
val nat_of_big_int : big_int -> nat
val big_int_of_nat : nat -> big_int
val base_power_big_int: int -> int -> big_int -> big_int
val sys_big_int_of_string: string -> int -> int -> big_int
val round_futur_last_digit : string -> int -> int -> bool
val approx_big_int: int -> big_int -> string
|