1Int64(3)                         OCaml library                        Int64(3)
2
3
4

NAME

6       Int64 - 64-bit integers.
7

Module

9       Module   Int64
10

Documentation

12       Module Int64
13        : sig end
14
15
16       64-bit integers.
17
18       This  module  provides  operations  on  the type int64 of signed 64-bit
19       integers.  Unlike the built-in int type, the type int64  is  guaranteed
20       to  be exactly 64-bit wide on all platforms.  All arithmetic operations
21       over int64 are taken modulo 2^64
22
23       Performance notice: values of type int64 occupy more memory space  than
24       values  of  type int , and arithmetic operations on int64 are generally
25       slower than those on  int  .   Use  int64  only  when  the  application
26       requires exact 64-bit arithmetic.
27
28       Literals  for  64-bit  integers are suffixed by L: let zero: int64 = 0L
29       let one: int64 = 1L let m_one: int64 = -1L
30
31
32
33
34
35
36
37       val zero : int64
38
39       The 64-bit integer 0.
40
41
42
43       val one : int64
44
45       The 64-bit integer 1.
46
47
48
49       val minus_one : int64
50
51       The 64-bit integer -1.
52
53
54
55       val neg : int64 -> int64
56
57       Unary negation.
58
59
60
61       val add : int64 -> int64 -> int64
62
63       Addition.
64
65
66
67       val sub : int64 -> int64 -> int64
68
69       Subtraction.
70
71
72
73       val mul : int64 -> int64 -> int64
74
75       Multiplication.
76
77
78
79       val div : int64 -> int64 -> int64
80
81       Integer division.  Raise Division_by_zero if  the  second  argument  is
82       zero.   This division rounds the real quotient of its arguments towards
83       zero, as specified for (/) .
84
85
86
87       val unsigned_div : int64 -> int64 -> int64
88
89       Same as Int64.div , except that arguments and result are interpreted as
90       unsigned 64-bit integers.
91
92
93       Since 4.08.0
94
95
96
97       val rem : int64 -> int64 -> int64
98
99       Integer  remainder.  If y is not zero, the result of Int64.rem x y sat‐
100       isfies the following property: x = Int64.add (Int64.mul (Int64.div x y)
101       y)  (Int64.rem x y) .  If y = 0 , Int64.rem x y raises Division_by_zero
102       .
103
104
105
106       val unsigned_rem : int64 -> int64 -> int64
107
108       Same as Int64.rem , except that arguments and result are interpreted as
109       unsigned 64-bit integers.
110
111
112       Since 4.08.0
113
114
115
116       val succ : int64 -> int64
117
118       Successor.  Int64.succ x is Int64.add x Int64.one .
119
120
121
122       val pred : int64 -> int64
123
124       Predecessor.  Int64.pred x is Int64.sub x Int64.one .
125
126
127
128       val abs : int64 -> int64
129
130       Return the absolute value of its argument.
131
132
133
134       val max_int : int64
135
136       The greatest representable 64-bit integer, 2^63 - 1.
137
138
139
140       val min_int : int64
141
142       The smallest representable 64-bit integer, -2^63.
143
144
145
146       val logand : int64 -> int64 -> int64
147
148       Bitwise logical and.
149
150
151
152       val logor : int64 -> int64 -> int64
153
154       Bitwise logical or.
155
156
157
158       val logxor : int64 -> int64 -> int64
159
160       Bitwise logical exclusive or.
161
162
163
164       val lognot : int64 -> int64
165
166       Bitwise logical negation.
167
168
169
170       val shift_left : int64 -> int -> int64
171
172
173       Int64.shift_left  x  y  shifts  x to the left by y bits.  The result is
174       unspecified if y < 0 or y >= 64 .
175
176
177
178       val shift_right : int64 -> int -> int64
179
180
181       Int64.shift_right x y shifts x to the right by  y  bits.   This  is  an
182       arithmetic  shift:  the sign bit of x is replicated and inserted in the
183       vacated bits.  The result is unspecified if y < 0 or y >= 64 .
184
185
186
187       val shift_right_logical : int64 -> int -> int64
188
189
190       Int64.shift_right_logical x y shifts x to the right by y bits.  This is
191       a  logical shift: zeroes are inserted in the vacated bits regardless of
192       the sign of x .  The result is unspecified if y < 0 or y >= 64 .
193
194
195
196       val of_int : int -> int64
197
198       Convert the given integer (type int ) to a 64-bit integer  (type  int64
199       ).
200
201
202
203       val to_int : int64 -> int
204
205       Convert  the given 64-bit integer (type int64 ) to an integer (type int
206       ).  On 64-bit platforms, the 64-bit integer is taken modulo 2^63,  i.e.
207       the high-order bit is lost during the conversion.  On 32-bit platforms,
208       the 64-bit integer is taken modulo 2^31, i.e. the top 33 bits are  lost
209       during the conversion.
210
211
212
213       val unsigned_to_int : int64 -> int option
214
215       Same as Int64.to_int , but interprets the argument as an unsigned inte‐
216       ger.  Returns None if the unsigned value of  the  argument  cannot  fit
217       into an int .
218
219
220       Since 4.08.0
221
222
223
224       val of_float : float -> int64
225
226       Convert the given floating-point number to a 64-bit integer, discarding
227       the fractional part (truncate towards 0).  The result of the conversion
228       is  undefined  if,  after truncation, the number is outside the range [
229       Int64.min_int , Int64.max_int ].
230
231
232
233       val to_float : int64 -> float
234
235       Convert the given 64-bit integer to a floating-point number.
236
237
238
239       val of_int32 : int32 -> int64
240
241       Convert the given 32-bit integer (type int32  )  to  a  64-bit  integer
242       (type int64 ).
243
244
245
246       val to_int32 : int64 -> int32
247
248       Convert  the  given  64-bit  integer  (type int64 ) to a 32-bit integer
249       (type int32 ). The 64-bit integer is taken modulo 2^32, i.e. the top 32
250       bits are lost during the conversion.
251
252
253
254       val of_nativeint : nativeint -> int64
255
256       Convert  the given native integer (type nativeint ) to a 64-bit integer
257       (type int64 ).
258
259
260
261       val to_nativeint : int64 -> nativeint
262
263       Convert the given 64-bit integer (type int64 ) to a native integer.  On
264       32-bit  platforms,  the 64-bit integer is taken modulo 2^32.  On 64-bit
265       platforms, the conversion is exact.
266
267
268
269       val of_string : string -> int64
270
271       Convert the given string to a 64-bit integer.  The string  is  read  in
272       decimal  (by default, or if the string begins with 0u ) or in hexadeci‐
273       mal, octal or binary if the string begins with 0x , 0o  or  0b  respec‐
274       tively.
275
276       The  0u  prefix reads the input as an unsigned integer in the range [0,
277       2*Int64.max_int+1] .  If the input exceeds  Int64.max_int  it  is  con‐
278       verted  to the signed integer Int64.min_int + input - Int64.max_int - 1
279       .
280
281       The _ (underscore) character can appear anywhere in the string  and  is
282       ignored.   Raise  Failure  Int64.of_string if the given string is not a
283       valid representation of an  integer,  or  if  the  integer  represented
284       exceeds the range of integers representable in type int64 .
285
286
287
288       val of_string_opt : string -> int64 option
289
290       Same as of_string , but return None instead of raising.
291
292
293       Since 4.05
294
295
296
297       val to_string : int64 -> string
298
299       Return the string representation of its argument, in decimal.
300
301
302
303       val bits_of_float : float -> int64
304
305       Return  the internal representation of the given float according to the
306       IEEE 754 floating-point 'double format' bit  layout.   Bit  63  of  the
307       result  represents  the  sign of the float; bits 62 to 52 represent the
308       (biased) exponent; bits 51 to 0 represent the mantissa.
309
310
311
312       val float_of_bits : int64 -> float
313
314       Return the floating-point number whose internal representation, accord‐
315       ing  to  the IEEE 754 floating-point 'double format' bit layout, is the
316       given int64 .
317
318
319       type t = int64
320
321
322       An alias for the type of 64-bit integers.
323
324
325
326       val compare : t -> t -> int
327
328       The comparison function for 64-bit integers, with the  same  specifica‐
329       tion as compare .  Along with the type t , this function compare allows
330       the module Int64 to be passed as argument to the functors Set.Make  and
331       Map.Make .
332
333
334
335       val unsigned_compare : t -> t -> int
336
337       Same  as  Int64.compare  ,  except  that  arguments  are interpreted as
338       unsigned 64-bit integers.
339
340
341       Since 4.08.0
342
343
344
345       val equal : t -> t -> bool
346
347       The equal function for int64s.
348
349
350       Since 4.03.0
351
352
353
354
355
356OCamldoc                          2019-07-30                          Int64(3)