1 (** 63 bit signed integer type *)
2 (* (C) Copyright 2008 Richard W.M. Jones, Red Hat Inc.
4 This program is free software; you can redistribute it and/or modify
5 it under the terms of the GNU General Public License as published by
6 the Free Software Foundation; either version 2 of the License, or
7 (at your option) any later version.
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 GNU General Public License for more details.
14 You should have received a copy of the GNU General Public License
15 along with this program; if not, write to the Free Software
16 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19 (** This module deals with creating an efficient 63 bit signed integer
22 In OCaml, the basic [int] type is fast because it is unboxed, but
23 it has a different size on 32 and 64 bit platforms (31 and 63 bits
24 respectively). If we want a large integer type we can use the
25 OCaml [int64] type, but that is boxed and hence operations are
26 slow, even on 64 bit platforms.
28 This type gives us a large integer (up to 63 bits, therefore fine
29 for things involving eg. large disk file sizes), but retains
30 efficiency. On 64 bit platforms it degenerates into just a normal
31 [int], hence unboxed and fast. On 32 bit platforms it degenerates
32 to a kind of [int64], which is boxed and slow but hey 32 bit
33 platforms are going the way of all things anyway.
35 The implementation of this type is in the files [int63_on_32.ml]
36 or [int63_on_64.ml] for 32 bit and 64 bit platforms respectively.
37 The appropriate implementation is copied by the Makefile to
43 OCaml cross-module inlining means that the compiler gets to
44 inline [int] operations directly and efficiently on 64 bit
45 platforms. However we still need to hide the actual type
46 to prevent people from writing code that accidentally depends
47 on 32/64-bit platform differences.
54 It is recommended to do:
60 in your code so that you get the operators [+^], [-^] .. and the
61 type [int63] directly, and can still use the less frequent
62 functions as {!Int63.logand} etc.
65 module Operators : sig
68 (* For the gory details of the rules of operators, see:
69 * http://caml.inria.fr/pub/docs/manual-ocaml/lex.html
72 val ( +^ ) : t -> t -> t
73 val ( -^ ) : t -> t -> t
74 val ( *^ ) : t -> t -> t
75 val ( /^ ) : t -> t -> t
76 val ( %^ ) : t -> t -> t
77 (** Infix arithmetic operators. eg. [a +^ b -^ c] *)
79 val ( <^< ) : t -> int -> t
80 val ( >^> ) : t -> int -> t
81 (** Infix shift left and logical shift right.
84 NB: We cannot use two less-than signs or two greater-than signs
85 in a row because that clashes with the symbols used for
88 val ( &&^ ) : t -> t -> t
89 val ( ||^ ) : t -> t -> t
90 val ( ^^^ ) : t -> t -> t
91 (** Infix logical and, or and xor operators.
92 eg. [bits &&^ mask] *)
95 (** Small integer constants,
96 eg. [~^0] is the constant zero and [~^1] is the constant one. *)
97 val ( ~^~ ) : int -> t
98 (** Small negative integer constants,
99 eg. [~^~1] is the constant minus one. *)
104 These functions are analogous to the similarly named
105 functions available in the standard library [Int32] and
111 (** Some constants. *)
116 val add : t -> t -> t
117 val sub : t -> t -> t
118 val mul : t -> t -> t
119 val div : t -> t -> t
120 val rem : t -> t -> t
129 (** Absolute value. *)
132 (** The constant 2{^62}-1. *)
134 (** The constant -2{^62}. *)
136 val logand : t -> t -> t
137 val logor : t -> t -> t
138 val logxor : t -> t -> t
140 (** Bitwise logical and, or, xor and not. *)
142 val shift_left : t -> int -> t
143 (** Shift the number left by the integer number of bits. *)
144 val shift_right : t -> int -> t
145 (** Arithmetic shift the number right by the integer number of bits.
146 The sign bit is replicated into the vacated bits. *)
147 val shift_right_logical : t -> int -> t
148 (** Logical shift the number right by the integer number of bits.
149 The vacated bits are filled with bit [0] regardless of sign. *)
151 val of_int : int -> t
152 val to_int : t -> int
153 val of_float : float -> t
154 val to_float : t -> float
155 val of_int32 : int32 -> t
156 val to_int32 : t -> int32
157 val of_int64 : int64 -> t
158 val to_int64 : t -> int64
159 val of_nativeint : nativeint -> t
160 val to_nativeint : t -> nativeint
161 (** Convert between t and various standard types. *)
163 val of_string : string -> t
164 val to_string : t -> string
165 (** Convert between string. *)
167 val compare : t -> t -> int
168 (** Compare two numbers. *)