Int64 man page on Cygwin

Man page or keyword search:  
man Server   22533 pages
apropos Keyword Search (all sections)
Output format
Cygwin logo
[printable version]

Int64(3)			 OCaml library			      Int64(3)

NAME
       Int64 - 64-bit integers.

Module
       Module	Int64

Documentation
       Module Int64
	: sig end

       64-bit integers.

       This  module  provides  operations  on  the type int64 of signed 64-bit
       integers.  Unlike the built-in int type, the type int64	is  guaranteed
       to  be exactly 64-bit wide on all platforms.  All arithmetic operations
       over int64 are taken modulo 2^{64

       Performance notice: values of type int64 occupy more memory space  than
       values  of  type int , and arithmetic operations on int64 are generally
       slower than those on  int  .   Use  int64  only	when  the  application
       requires exact 64-bit arithmetic.

       val zero : int64

       The 64-bit integer 0.

       val one : int64

       The 64-bit integer 1.

       val minus_one : int64

       The 64-bit integer -1.

       val neg : int64 -> int64

       Unary negation.

       val add : int64 -> int64 -> int64

       Addition.

       val sub : int64 -> int64 -> int64

       Subtraction.

       val mul : int64 -> int64 -> int64

       Multiplication.

       val div : int64 -> int64 -> int64

       Integer	division.   Raise  Division_by_zero  if the second argument is
       zero.  This division rounds the real quotient of its arguments  towards
       zero, as specified for Pervasives.(/) .

       val rem : int64 -> int64 -> int64

       Integer	remainder.  If y is not zero, the result of Int64.rem x y sat‐
       isfies the following property: x = Int64.add (Int64.mul (Int64.div x y)
       y)  (Int64.rem x y) .  If y = 0 , Int64.rem x y raises Division_by_zero
       .

       val succ : int64 -> int64

       Successor.  Int64.succ x is Int64.add x Int64.one .

       val pred : int64 -> int64

       Predecessor.  Int64.pred x is Int64.sub x Int64.one .

       val abs : int64 -> int64

       Return the absolute value of its argument.

       val max_int : int64

       The greatest representable 64-bit integer, 2^{63 - 1.

       val min_int : int64

       The smallest representable 64-bit integer, -2^{63.

       val logand : int64 -> int64 -> int64

       Bitwise logical and.

       val logor : int64 -> int64 -> int64

       Bitwise logical or.

       val logxor : int64 -> int64 -> int64

       Bitwise logical exclusive or.

       val lognot : int64 -> int64

       Bitwise logical negation

       val shift_left : int64 -> int -> int64

       Int64.shift_left x y shifts x to the left by y  bits.   The  result  is
       unspecified if y < 0 or y >= 64 .

       val shift_right : int64 -> int -> int64

       Int64.shift_right  x  y	shifts	x  to the right by y bits.  This is an
       arithmetic shift: the sign bit of x is replicated and inserted  in  the
       vacated bits.  The result is unspecified if y < 0 or y >= 64 .

       val shift_right_logical : int64 -> int -> int64

       Int64.shift_right_logical x y shifts x to the right by y bits.  This is
       a logical shift: zeroes are inserted in the vacated bits regardless  of
       the sign of x .	The result is unspecified if y < 0 or y >= 64 .

       val of_int : int -> int64

       Convert	the  given integer (type int ) to a 64-bit integer (type int64
       ).

       val to_int : int64 -> int

       Convert the given 64-bit integer (type int64 ) to an integer (type  int
       ).  On 64-bit platforms, the 64-bit integer is taken modulo 2^{63, i.e.
       the high-order bit is lost during the conversion.  On 32-bit platforms,
       the 64-bit integer is taken modulo 2^{31, i.e. the top 33 bits are lost
       during the conversion.

       val of_float : float -> int64

       Convert the given floating-point number to a 64-bit integer, discarding
       the fractional part (truncate towards 0).  The result of the conversion
       is undefined if, after truncation, the number is outside	 the  range  [
       Int64.min_int , Int64.max_int ].

       val to_float : int64 -> float

       Convert the given 64-bit integer to a floating-point number.

       val of_int32 : int32 -> int64

       Convert	the  given  32-bit  integer  (type int32 ) to a 64-bit integer
       (type int64 ).

       val to_int32 : int64 -> int32

       Convert the given 64-bit integer (type int64  )	to  a  32-bit  integer
       (type  int32  ). The 64-bit integer is taken modulo 2^{32, i.e. the top
       32 bits are lost during the conversion.

       val of_nativeint : nativeint -> int64

       Convert the given native integer (type nativeint ) to a 64-bit  integer
       (type int64 ).

       val to_nativeint : int64 -> nativeint

       Convert the given 64-bit integer (type int64 ) to a native integer.  On
       32-bit platforms, the 64-bit integer is taken modulo 2^{32.  On	64-bit
       platforms, the conversion is exact.

       val of_string : string -> int64

       Convert	the  given  string to a 64-bit integer.	 The string is read in
       decimal (by default) or in hexadecimal, octal or binary if  the	string
       begins with 0x , 0o or 0b respectively.	Raise Failure int_of_string if
       the given string is not a valid representation of an integer, or if the
       integer represented exceeds the range of integers representable in type
       int64 .

       val to_string : int64 -> string

       Return the string representation of its argument, in decimal.

       val bits_of_float : float -> int64

       Return the internal representation of the given float according to  the
       IEEE  754  floating-point  'double  format'  bit layout.	 Bit 63 of the
       result represents the sign of the float; bits 62 to  52	represent  the
       (biased) exponent; bits 51 to 0 represent the mantissa.

       val float_of_bits : int64 -> float

       Return the floating-point number whose internal representation, accord‐
       ing to the IEEE 754 floating-point 'double format' bit layout,  is  the
       given int64 .

       type t = int64

       An alias for the type of 64-bit integers.

       val compare : t -> t -> int

       The  comparison	function for 64-bit integers, with the same specifica‐
       tion as Pervasives.compare .  Along with the type  t  ,	this  function
       compare	allows	the module Int64 to be passed as argument to the func‐
       tors Set.Make and Map.Make .

OCamldoc			  2013-10-24			      Int64(3)
[top]

List of man pages available for Cygwin

Copyright (c) for man pages and the logo by the respective OS vendor.

For those who want to learn more, the polarhome community provides shell access and support.

[legal] [privacy] [GNU] [policy] [cookies] [netiquette] [sponsors] [FAQ]
Tweet
Polarhome, production since 1999.
Member of Polarhome portal.
Based on Fawad Halim's script.
....................................................................
Vote for polarhome
Free Shell Accounts :: the biggest list on the net