+
Point of view
All features
expanded class INTEGER_64
Summary
Direct parents
Insert list: INTEGER_GENERAL
Overview
Features
Conversions:
{ANY}
{ANY}
{}
{ANY}
{}
Conversions:
{ANY}
Bitwise Logical Operators:
{ANY}
  • bit_test (idx: INTEGER_8): BOOLEAN
    The value of the idx-ith bit (the right-most bit is at index 0).
  • bit_set (idx: INTEGER_8): INTEGER_64
    The value of the idx-ith bit (the right-most bit is at index 0).
  • bit_reset (idx: INTEGER_8): INTEGER_64
    The value of the idx-ith bit (the right-most bit is at index 0).
  • infix "|>>" (s: INTEGER_8): INTEGER_64
    Shift by s positions right (sign bit copied) bits falling off the end are lost.
  • bit_shift_right (s: INTEGER_8): INTEGER_64
    Shift by s positions right (sign bit copied) bits falling off the end are lost.
  • infix "|>>>" (s: INTEGER_8): INTEGER_64
    Shift by s positions right (sign bit not copied) bits falling off the end are lost.
  • bit_shift_right_unsigned (s: INTEGER_8): INTEGER_64
    Shift by s positions right (sign bit not copied) bits falling off the end are lost.
  • infix "|<<" (s: INTEGER_8): INTEGER_64
    Shift by s positions left bits falling off the end are lost.
  • bit_shift_left (s: INTEGER_8): INTEGER_64
    Shift by s positions left bits falling off the end are lost.
  • infix "#>>" (s: INTEGER_8): INTEGER_64
    Rotate by s positions right.
  • bit_rotate_right (s: INTEGER_8): INTEGER_64
    Rotate by s positions right.
  • infix "#<<" (s: INTEGER_8): INTEGER_64
    Rotate by s positions left.
  • bit_rotate_left (s: INTEGER_8): INTEGER_64
    Rotate by s positions left.
  • bit_rotate (s: INTEGER_8): INTEGER_64
    Rotate by s positions (positive s shifts right, negative left
  • prefix "~": INTEGER_64
    One's complement of Current.
  • bit_not: INTEGER_64
    One's complement of Current.
  • infix "&" (other: INTEGER_64): INTEGER_64
    Bitwise logical and of Current with other.
  • bit_and (other: INTEGER_64): INTEGER_64
    Bitwise logical and of Current with other.
  • infix "|" (other: INTEGER_64): INTEGER_64
    Bitwise logical inclusive or of Current with other.
  • bit_or (other: INTEGER_64): INTEGER_64
    Bitwise logical inclusive or of Current with other.
  • bit_xor (other: INTEGER_64): INTEGER_64
    Bitwise logical exclusive or of Current with other.
  • bit_shift (s: INTEGER_8): INTEGER_64
    Shift by s positions (positive s shifts right (sign bit copied), negative shifts left bits falling off the end are lost).
  • bit_shift_unsigned (s: INTEGER_8): INTEGER_64
    Shift by s positions (positive s shifts right (sign bit not copied), negative left bits falling off the end are lost).
Object Printing:
{ANY}
Miscellaneous:
{ANY}
Looping:
{ANY}
  • times (repeat: PROCEDURE[TUPLE[TUPLE 1[INTEGER_64]]])
    Repeats the procedure from 1 to Current.
  • loop_to (bound: INTEGER_64, repeat: PROCEDURE[TUPLE[TUPLE 1[INTEGER_64]]])
    Repeats the procedure from Current to bound.
  • loop_from (bound: INTEGER_64, repeat: PROCEDURE[TUPLE[TUPLE 1[INTEGER_64]]])
    Repeats the procedure from bound to Current.
  • loop_up_to (bound: INTEGER_64, repeat: PROCEDURE[TUPLE[TUPLE 1[INTEGER_64]]])
    Repeats the procedure from Current to a greater bound.
  • loop_down_to (bound: INTEGER_64, repeat: PROCEDURE[TUPLE[TUPLE 1[INTEGER_64]]])
    Repeats the procedure from Current to a lower bound.
Modular arithmetic (these wrap around on overflow)
{ANY}
  • infix "#+" (other: INTEGER_64): INTEGER_64
  • prefix "#-": INTEGER_64
  • infix "#-" (other: INTEGER_64): INTEGER_64
  • infix "#*" (other: INTEGER_64): INTEGER_64
  • infix "#//" (other: INTEGER_64): INTEGER_64
    Integer division of Current by other.
  • infix "#\\" (other: INTEGER_64): INTEGER_64
    Remainder of the integer division of Current by other.
{}
{ANY}
  • lcm (other: INTEGER_64): INTEGER_64
    Least Common Multiple of Current and other.
{ANY}
  • in_range (lower: INTEGER_64, upper: INTEGER_64): BOOLEAN
    Return True if Current is in range [lower..upper]
    See also min, max, compare.
  • compare (other: INTEGER_64): INTEGER_32
    If current object equal to other, 0 if smaller, -1; if greater, 1.
  • three_way_comparison (other: INTEGER_64): INTEGER_32
    If current object equal to other, 0 if smaller, -1; if greater, 1.
  • min (other: INTEGER_64): INTEGER_64
    Minimum of Current and other.
  • max (other: INTEGER_64): INTEGER_64
    Maximum of Current and other.
  • bounded_by (a_min: INTEGER_64, a_max: INTEGER_64): INTEGER_64
    A value that is equal to Current if it is between the limits set by a_min and a_max.
Maximum:
{}
Minimum:
{}
Bits:
{}
fit_integer_8: BOOLEAN
effective function
{ANY}
Does Current fit in INTEGER_8?
ensure
to_integer_8: INTEGER_8
{ANY}
Explicit conversion to INTEGER_8.
require ensure
fit_integer_16: BOOLEAN
effective function
{ANY}
Does Current fit in INTEGER_16?
ensure
  • Result = Current.in_range(-32768, 32767)
to_integer_16: INTEGER_16
{ANY}
Explicit conversion to INTEGER_16.
require ensure
fit_integer_32: BOOLEAN
effective function
{ANY}
Does Current fit in INTEGER_32?
ensure
  • Result = Current.in_range(-2147483648, 2147483647)
to_integer_32: INTEGER_32
{ANY}
Explicit conversion to INTEGER_32.
require ensure
  • Current = Result
fit_natural_8: BOOLEAN
effective function
{ANY}
Does Current fit in NATURAL_8?
ensure
to_natural_8: NATURAL_8
{ANY}
Explicit conversion to NATURAL_8.
require ensure
  • Result.to_integer_16 = Current
fit_natural_16: BOOLEAN
effective function
{ANY}
Does Current fit in NATURAL_16?
ensure
to_natural_16: NATURAL_16
{ANY}
Explicit conversion to NATURAL_16.
require ensure
  • Result.to_integer_32 = Current
fit_natural_32: BOOLEAN
effective function
{ANY}
Does Current fit in NATURAL_32?
ensure
  • Result = Current.in_range(0, 4294967295)
to_natural_32: NATURAL_32
{ANY}
Explicit conversion to NATURAL_32.
require ensure
  • Result.to_integer_64 = Current
to_natural_64: NATURAL_64
{ANY}
Explicit conversion to NATURAL_64.
require
  • Current >= 0
ensure
  • Result.to_integer_64 = Current
force_to_real_32: REAL_32
{ANY}
Forced conversion to REAL_32 (possible loss of precision).
(See also fit_real_32 and to_real_32.)
fit_real_32: BOOLEAN
effective function
{ANY}
Does Current fit in REAL_32?
to_real_32: REAL_32
effective function
{ANY}
Explicit conversion to REAL_32.
(See also force_to_real_32.)
require ensure
  • Result.force_to_integer_64 = Current
force_to_real_64: REAL_64
{ANY}
Forced conversion to REAL_64 (possible loss of precision).
(See also fit_real_64 and to_real_64.)
fit_real_64: BOOLEAN
effective function
{ANY}
Does Current fit in REAL_64?
to_real_64: REAL_64
effective function
{ANY}
Explicit conversion to REAL_64.
(See also force_to_real_64.)
require ensure
  • Result.force_to_integer_64 = Current
to_number: NUMBER
effective function
{ANY}
Convert Current into a new allocated NUMBER.
ensure
  • Result @= Current
  • Result.to_string.is_equal(to_string)
decimal_digit: CHARACTER
effective function
{ANY}
Gives the corresponding CHARACTER for range 0..9.
require
  • is_decimal_digit
ensure
  • "0123456789".has(Result)
    Current.is_equal(Result.value)

hexadecimal_digit: CHARACTER
effective function
{ANY}
Gives the corresponding CHARACTER for range 0..15.
require
  • is_hexadecimal_digit
ensure
  • "0123456789ABCDEF".has(Result)
low_32: INTEGER_32
{ANY}
The 32 low bits of Current (i.e. the right-most part).
high_32: INTEGER_32
effective function
{ANY}
The 32 high bits of Current (i.e. the left-most part).
one: INTEGER_8
is 1
constant attribute
{ANY}
Neutral element for "*" and "/".
zero: INTEGER_8
is 0
constant attribute
{ANY}
Neutral element for "+" and "-".
hash_code: INTEGER_32
effective function
{ANY}
The hash-code value of Current.
ensure
  • good_hash_value: Result >= 0
sqrt: REAL_64
effective function
{ANY}
Square root of Current.
require
  • Current >= zero
log: REAL_64
effective function
{ANY}
Natural Logarithm of Current.
require
  • Current > zero
log10: REAL_64
effective function
{ANY}
Base-10 Logarithm of Current.
require
  • Current > zero
bit_count: INTEGER_8
is 64
constant attribute
{ANY}
The number of bits used to store the value of Current
ensure
  • Result = object_size * 8
integer_64_fit_real_64 (integer_64: INTEGER_64): BOOLEAN
{}
infix "+" (other: INTEGER_64): INTEGER_64
{ANY}
Sum with other (commutative).
require
  • no_overflow: Current > zero = other > zero implies Current #+ other > zero = Current > zero
    this means: if operand are of same sign, it will be sign of the Result.

ensure
  • Result #- other = Current
infix "-" (other: INTEGER_64): INTEGER_64
{ANY}
Result of subtracting other.
require
  • no_overflow: Current > zero /= other > zero implies Current #- other > zero = Current > zero
    this means: if operand are of different sign, sign of the Result will be the same sign as Current.

ensure
  • Result #+ other = Current
infix "*" (other: INTEGER_64): INTEGER_64
{ANY}
Product by other.
require
  • no_overflow: other /= zero implies Current #* other #// other = Current
ensure
  • Current /= zero and other /= zero implies Result /= zero
  • Result /= zero implies Result #// other = Current
  • Result /= zero implies Result #\\ other = zero
infix "/" (other: INTEGER_64): REAL_64
{ANY}
Division by other.
require
  • other /= Void
  • other /= zero
  • divisible(other)
infix "//" (other: INTEGER_64): INTEGER_64
effective function
{ANY}
Quotient of the Euclidian division of Current by other.
The corresponding remainder is given by infix "\\".
See also infix "#//".
require
  • other /= zero
  • no_overflow: other = - one implies Current = zero or Current |<< 1 /= zero
ensure
  • euclidian_divide_case1: Current >= zero implies Result * other + Current \\ other = Current
  • euclidian_divide_case2: Current < zero implies Result #* other #+ Current \\ other = Current
infix "\\" (other: INTEGER_64): INTEGER_64
effective function
{ANY}
Remainder of the Euclidian division of Current by other.
By definition, zero <= Result < other.abs.
See also infix "#\\", infix "//".
require
  • other /= zero
ensure
  • Result >= zero
  • other |<< 1 /= zero implies Result < other.abs
  • good_remainder: Result #- Current #\\ other #\\ other = zero
infix "^" (exp: INTEGER_64): INTEGER_64
effective function
{ANY}
Integer power of Current by other
require
  • exp >= zero
abs: INTEGER_64
effective function
{ANY}
Absolute value of Current.
require
  • not_minimum_value: Current < zero implies zero < #- Current
ensure
  • Result >= zero
infix "<" (other: INTEGER_64): BOOLEAN
{ANY}
Is Current strictly less than other?
See also >, <=, >=, min, max.
require
  • other_exists: other /= Void
ensure
  • asymmetric: Result implies not other < Current
infix "<=" (other: INTEGER_64): BOOLEAN
{ANY}
require
  • other_exists: other /= Void
ensure
  • definition: Result = Current < other or is_equal(other)
infix ">" (other: INTEGER_64): BOOLEAN
{ANY}
require
  • other_exists: other /= Void
ensure
  • definition: Result = other < Current
infix ">=" (other: INTEGER_64): BOOLEAN
{ANY}
require
  • other_exists: other /= Void
ensure
  • definition: Result = other <= Current
prefix "+": INTEGER_64
effective function
{ANY}
Unary plus of Current.
prefix "-": INTEGER_64
{ANY}
Unary minus of Current.
require
  • not_minimum_value: Current < zero implies zero < #- Current
is_odd: BOOLEAN
effective function
{ANY}
Is odd?
is_even: BOOLEAN
effective function
{ANY}
Is even?
is_prime: BOOLEAN
effective function
{ANY}
Is prime?
is_fibonacci: BOOLEAN
effective function
{ANY}
Is Fibonacci number?
gcd (other: INTEGER_64): INTEGER_64
effective function
{ANY}
Greatest Common Divisor of Current and other.
ensure
  • Result >= zero
  • Result = zero implies Current = zero and other = zero
  • Result >= one + one implies Current \\ Result = zero and other \\ Result = zero and Current // Result.gcd(other // Result) = one
is_perfect_square (other: INTEGER_64): BOOLEAN
effective function
{}
to_string: STRING
effective function
{ANY}
The decimal view of Current into a new allocated STRING.
For example, if Current is -1 the Result is "-1".
See also append_in, to_string_format, to_unicode_string, to_hexadecimal, to_octal.
to_unicode_string: UNICODE_STRING
effective function
{ANY}
The decimal view of Current into a new allocated UNICODE_STRING.
For example, if Current is -1 the Result is U"-1".
See also append_in_unicode, to_unicode_string_format, to_string, to_hexadecimal, to_octal.
to_boolean: BOOLEAN
effective function
{ANY}
Return False for 0, otherwise True.
ensure
  • Result = Current /= zero
append_in (buffer: STRING)
effective procedure
{ANY}
Append in the buffer the equivalent of to_string.
If you look for performances, you should always prefer append_in which allow you to recycle a unique common buffer (each call of to_string allocate a new object!).
See also append_in_format, append_in_unicode, append_in_unicode_format, to_hexadecimal_in.
require
  • buffer /= Void
append_in_unicode (buffer: UNICODE_STRING)
effective procedure
{ANY}
Append in the buffer the equivalent of to_unicode_string.
If you look for performances, you should always prefer append_in_unicode which allow you to recycle a unique common buffer (each call of to_unicode_string allocate a new object!).
See also append_in_unicode_format, append_in, append_in_format, to_hexadecimal_in.
require
  • buffer /= Void
to_string_format (s: INTEGER_32): STRING
effective function
{ANY}
Same as to_string but the result is on s character and the number is right aligned.
require
  • to_string.count <= s
ensure
  • Result.count = s
to_unicode_string_format (s: INTEGER_32): UNICODE_STRING
effective function
{ANY}
Same as to_unicode_string but the result is on s character and the number is right aligned.
require
  • to_string.count <= s
ensure
  • Result.count = s
append_in_format (buffer: STRING, s: INTEGER_32)
effective procedure
{ANY}
Append in the buffer the equivalent of to_string_format.
If you look for performances, you should always prefer append_in_format which allow you to recycle a unique common buffer (each call of to_string_format allocate a new object!).
See also append_in, append_in_unicode, append_in_unicode_format, to_hexadecimal_in.
require
  • to_string.count <= s
ensure
  • buffer.count >= old buffer.count + s
append_in_unicode_format (buffer: UNICODE_STRING, s: INTEGER_32)
effective procedure
{ANY}
Append in the buffer the equivalent of to_unicode_string_format.
If you look for performances, you should always prefer append_in_unicode_format which allow you to recycle a unique common buffer (each call of to_unicode_string_format allocate a new object!).
See also append_in_format, append_in, append_in_format, to_hexadecimal_in.
require
  • to_string.count <= s
ensure
  • buffer.count >= old buffer.count + s
digit: CHARACTER
effective function
{ANY}
Legacy synonym for decimal_digit.
Note: already prefer decimal_digit because digit may become obsolete (feb 4th 2006).
ensure
  • Result = decimal_digit
is_decimal_digit: BOOLEAN
effective function
{ANY}
is_hexadecimal_digit: BOOLEAN
effective function
{ANY}
to_character: CHARACTER
{ANY}
Return the corresponding ASCII character.
require
  • Current >= zero
    Current <= Maximum_character_code

to_octal_in (buffer: STRING)
effective procedure
{ANY}
Append in the buffer the equivalent of to_octal.
If you look for performances, you should always prefer to_octal_in which allow you to recycle a unique common buffer (each call of to_octal allocate a new object!).
See also to_hexadecimal_in, append_in, append_in_format, append_in_unicode.
ensure
  • buffer.count = old buffer.count + bit_count #// 3 + 1
to_octal: STRING
effective function
{ANY}
The octal view of Current into a new allocated STRING.
For example, if Current is -1 and if Current is a 16 bits integer the Result is "177777".
See also to_octal_in, to_hexadecimal, to_number, to_string.
ensure
  • Result.count = bit_count #// 3 + 1
to_hexadecimal: STRING
effective function
{ANY}
The hexadecimal view of Current into a new allocated STRING.
For example, if Current is -1 and if Current is a 32 bits integer the Result is "FFFFFFFF".
See also to_hexadecimal_in, to_octal, to_number, to_string.
ensure
  • Result.count = object_size * 2
to_hexadecimal_in (buffer: STRING)
effective procedure
{ANY}
Append in the buffer the equivalent of to_hexadecimal.
If you look for performances, you should always prefer to_hexadecimal_in which allow you to recycle a unique common buffer (each call of to_hexadecimal allocate a new object!).
See also to_octal_in, append_in, append_in_format, append_in_unicode.
ensure
  • buffer.count = old buffer.count + object_size * 2
bit_test (idx: INTEGER_8): BOOLEAN
effective function
{ANY}
The value of the idx-ith bit (the right-most bit is at index 0).
require
  • idx.in_range(0, bit_count - 1)
bit_set (idx: INTEGER_8): INTEGER_64
effective function
{ANY}
The value of the idx-ith bit (the right-most bit is at index 0).
require
  • idx.in_range(0, bit_count - 1)
ensure
  • Result.bit_test(idx)
  • Result = Current or Result.bit_reset(idx) = Current
bit_reset (idx: INTEGER_8): INTEGER_64
effective function
{ANY}
The value of the idx-ith bit (the right-most bit is at index 0).
require
  • idx.in_range(0, bit_count - 1)
ensure
  • not Result.bit_test(idx)
  • Result = Current or Result.bit_set(idx) = Current
infix "|>>" (s: INTEGER_8): INTEGER_64
{ANY}
Shift by s positions right (sign bit copied) bits falling off the end are lost.
require
  • s.in_range(0, bit_count - 1)
bit_shift_right (s: INTEGER_8): INTEGER_64
{ANY}
Shift by s positions right (sign bit copied) bits falling off the end are lost.
require
  • s.in_range(0, bit_count - 1)
infix "|>>>" (s: INTEGER_8): INTEGER_64
{ANY}
Shift by s positions right (sign bit not copied) bits falling off the end are lost.
require
  • s.in_range(0, bit_count - 1)
bit_shift_right_unsigned (s: INTEGER_8): INTEGER_64
{ANY}
Shift by s positions right (sign bit not copied) bits falling off the end are lost.
require
  • s.in_range(0, bit_count - 1)
infix "|<<" (s: INTEGER_8): INTEGER_64
{ANY}
Shift by s positions left bits falling off the end are lost.
require
  • s.in_range(0, bit_count - 1)
bit_shift_left (s: INTEGER_8): INTEGER_64
{ANY}
Shift by s positions left bits falling off the end are lost.
require
  • s.in_range(0, bit_count - 1)
infix "#>>" (s: INTEGER_8): INTEGER_64
{ANY}
Rotate by s positions right.
See also bit_rotate_left and bit_rotate.
require
  • s.in_range(1, bit_count - 1)
bit_rotate_right (s: INTEGER_8): INTEGER_64
{ANY}
Rotate by s positions right.
See also bit_rotate_left and bit_rotate.
require
  • s.in_range(1, bit_count - 1)
infix "#<<" (s: INTEGER_8): INTEGER_64
{ANY}
Rotate by s positions left.
require
  • s.in_range(1, bit_count - 1)
bit_rotate_left (s: INTEGER_8): INTEGER_64
{ANY}
Rotate by s positions left.
require
  • s.in_range(1, bit_count - 1)
bit_rotate (s: INTEGER_8): INTEGER_64
{ANY}
Rotate by s positions (positive s shifts right, negative left
See also bit_rotate_right and bit_rotate_left.
require
  • s.in_range(- bit_count - 1, bit_count - 1)
prefix "~": INTEGER_64
{ANY}
One's complement of Current.
bit_not: INTEGER_64
{ANY}
One's complement of Current.
infix "&" (other: INTEGER_64): INTEGER_64
{ANY}
Bitwise logical and of Current with other.
bit_and (other: INTEGER_64): INTEGER_64
{ANY}
Bitwise logical and of Current with other.
infix "|" (other: INTEGER_64): INTEGER_64
{ANY}
Bitwise logical inclusive or of Current with other.
bit_or (other: INTEGER_64): INTEGER_64
{ANY}
Bitwise logical inclusive or of Current with other.
bit_xor (other: INTEGER_64): INTEGER_64
{ANY}
Bitwise logical exclusive or of Current with other.
bit_shift (s: INTEGER_8): INTEGER_64
effective function
{ANY}
Shift by s positions (positive s shifts right (sign bit copied), negative shifts left bits falling off the end are lost).
See also infix "|>>" and infix "|<<".
require
  • s /= 0
bit_shift_unsigned (s: INTEGER_8): INTEGER_64
effective function
{ANY}
Shift by s positions (positive s shifts right (sign bit not copied), negative left bits falling off the end are lost).
See also infix "|>>>" and infix "|<<".
require
  • s /= 0
out_in_tagged_out_memory
effective procedure
{ANY}
Append terse printable representation of current object in tagged_out_memory.
require
    • locked: tagged_out_locked
    • locked: tagged_out_locked
ensure
  • still_locked: tagged_out_locked
  • not_cleared: tagged_out_memory.count >= old tagged_out_memory.count
  • append_only: old tagged_out_memory.twin.is_equal(tagged_out_memory.substring(1, old tagged_out_memory.count))
fill_tagged_out_memory
effective procedure
{ANY}
Append a viewable information in tagged_out_memory in order to affect the behavior of out, tagged_out, etc.
require
    • locked: tagged_out_locked
    • locked: tagged_out_locked
ensure
  • still_locked: tagged_out_locked
sign: INTEGER_8
effective function
{ANY}
Sign of Current (0 or -1 or 1).
ensure
  • Result.in_range(-1, 1)
divisible (other: INTEGER_64): BOOLEAN
effective function
{ANY}
May Current be divided by other ?
require
  • other /= Void
ensure
  • definition: Result = other /= zero
is_equal (other: INTEGER_64): BOOLEAN
effective function
{ANY}
Is other attached to an object considered equal to current object?
require
    • other /= Void
    • other /= Void
ensure
  • commutative: generating_type = other.generating_type implies Result = other.is_equal(Current)
  • Result implies hash_code = other.hash_code
  • trichotomy: Result = not Current < other and not other < Current
is_a_power_of_2: BOOLEAN
effective function
{ANY}
Is Current a power of 2?
require
  • Current > zero
times (repeat: PROCEDURE[TUPLE[TUPLE 1[INTEGER_64]]])
effective procedure
{ANY}
Repeats the procedure from 1 to Current.
As for any Liberty Eiffel agent the open argument may be safely ignored. You may also build your agent with closed arguments.
See also loop_to, loop_from
require
loop_to (bound: INTEGER_64, repeat: PROCEDURE[TUPLE[TUPLE 1[INTEGER_64]]])
effective procedure
{ANY}
Repeats the procedure from Current to bound.
As for any Liberty Eiffel agent the open argument may be safely ignored. You may also build your agent with closed arguments.
See also times, loop_from
See also the simpler loop_up_to, loop_down_to
loop_from (bound: INTEGER_64, repeat: PROCEDURE[TUPLE[TUPLE 1[INTEGER_64]]])
effective procedure
{ANY}
Repeats the procedure from bound to Current.
As for any Liberty Eiffel agent the open argument may be safely ignored. You may also build your agent with closed arguments.
See also times, loop_to
require
  • useful: bound /= Current
loop_up_to (bound: INTEGER_64, repeat: PROCEDURE[TUPLE[TUPLE 1[INTEGER_64]]])
effective procedure
{ANY}
Repeats the procedure from Current to a greater bound.
As for any Liberty Eiffel agent the open argument may be safely ignored. You may also build your agent with closed arguments.
See also loop_to, loop_down_to
loop_down_to (bound: INTEGER_64, repeat: PROCEDURE[TUPLE[TUPLE 1[INTEGER_64]]])
effective procedure
{ANY}
Repeats the procedure from Current to a lower bound.
As for any Liberty Eiffel agent the open argument may be safely ignored. You may also build your agent with closed arguments.
See also loop_to, loop_down_to
infix "#+" (other: INTEGER_64): INTEGER_64
{ANY}
prefix "#-": INTEGER_64
{ANY}
infix "#-" (other: INTEGER_64): INTEGER_64
{ANY}
infix "#*" (other: INTEGER_64): INTEGER_64
{ANY}
infix "#//" (other: INTEGER_64): INTEGER_64
{ANY}
Integer division of Current by other.
According to the ANSI C99: if Current and other are both non-negative, the Result is the quotient of the Euclidian division; but this is not the general case, the Result value is the algebraic quotient Current/other with any fractional part discarded. (This is often called "truncated toward zero"). So, the corresponding remainder value only verifies the expression remainder.abs < other.abs.
See also infix "//", infix "#\\".
require
  • other /= zero
ensure
  • Result * other + Current #\\ other = Current
  • ansi_c_remainder: other |<< 1 /= zero implies Current - Result * other.abs < other.abs
  • ansi_c_good_case: Current >= zero and other > zero implies Current - Result * other >= zero
infix "#\\" (other: INTEGER_64): INTEGER_64
{ANY}
Remainder of the integer division of Current by other.
According to the ANSI C99:
  * if Current and other are both non-negative,
    the Result is the remainder of the Euclidian division.
  * but this is not the general case,
    Result as the same sign as Current and only verify
    the expression Result.abs < other.abs.
See also infix "\\", infix "#//".
require
  • other /= zero
ensure
  • Current - Result #\\ other = zero
  • ansi_c_remainder: other |<< 1 /= zero implies Result.abs < other.abs
  • ansi_c_good_case: Current >= zero and other > zero implies Result >= zero
string_buffer: STRING
once function
{}
unicode_string_buffer: UNICODE_STRING
once function
{}
lcm (other: INTEGER_64): INTEGER_64
effective function
{ANY}
Least Common Multiple of Current and other.
ensure
in_range (lower: INTEGER_64, upper: INTEGER_64): BOOLEAN
effective function
{ANY}
Return True if Current is in range [lower..upper]
See also min, max, compare.
ensure
  • Result = Current >= lower and Current <= upper
compare (other: INTEGER_64): INTEGER_32
effective function
{ANY}
If current object equal to other, 0 if smaller, -1; if greater, 1.
See also min, max, in_range.
require
  • other_exists: other /= Void
ensure
  • equal_zero: Result = 0 = is_equal(other)
  • smaller_negative: Result = -1 = Current < other
  • greater_positive: Result = 1 = Current > other
three_way_comparison (other: INTEGER_64): INTEGER_32
effective function
{ANY}
If current object equal to other, 0 if smaller, -1; if greater, 1.
See also min, max, in_range.
require
  • other_exists: other /= Void
ensure
  • equal_zero: Result = 0 = is_equal(other)
  • smaller_negative: Result = -1 = Current < other
  • greater_positive: Result = 1 = Current > other
min (other: INTEGER_64): INTEGER_64
effective function
{ANY}
Minimum of Current and other.
See also max, in_range.
require
  • other /= Void
ensure
  • Result <= Current and then Result <= other
  • compare(Result) = 0 or else other.compare(Result) = 0
max (other: INTEGER_64): INTEGER_64
effective function
{ANY}
Maximum of Current and other.
See also min, in_range.
require
  • other /= Void
ensure
  • Result >= Current and then Result >= other
  • compare(Result) = 0 or else other.compare(Result) = 0
bounded_by (a_min: INTEGER_64, a_max: INTEGER_64): INTEGER_64
effective function
{ANY}
A value that is equal to Current if it is between the limits set by a_min and a_max.
Otherwise it's a_min if Current is smaller or a_max if Current is greater It's a shortcut for Current.min(a_max).max(a_min) also known as "clamp" in the widespread C library Glib
ensure
  • correctness: Result.in_range(a_min, a_max)
Maximum_character_code: INTEGER_16
{}
Largest supported code for CHARACTER values.
ensure
  • meaningful: Result >= 127
Maximum_integer_8: INTEGER_8
is 127
constant attribute
{}
Largest supported value of type INTEGER_8.
Maximum_integer_16: INTEGER_16
is 32767
constant attribute
{}
Largest supported value of type INTEGER_16.
Maximum_integer: INTEGER_32
is 2147483647
constant attribute
{}
Largest supported value of type INTEGER/INTEGER_32.
Maximum_integer_32: INTEGER_32
is 2147483647
constant attribute
{}
Largest supported value of type INTEGER/INTEGER_32.
Maximum_integer_64: INTEGER_64
is 9223372036854775807
constant attribute
{}
Largest supported value of type INTEGER_64.
Maximum_real_32: REAL_32
is {REAL_32 3.4028234663852885981170418348451692544e+38}
constant attribute
{}
Largest non-special (no NaNs nor infinity) supported value of type REAL_32.
Maximum_real: REAL_64
{}
Largest non-special (no NaNs nor infinity) supported value of type REAL.
Just to give an idea of this value: 1.79769313486231570....e+308
Maximum_real_64: REAL_64
{}
Largest non-special (no NaNs nor infinity) supported value of type REAL.
Just to give an idea of this value: 1.79769313486231570....e+308
Maximum_real_80: REAL_EXTENDED
{}
Largest supported value of type REAL_80.
ensure
Minimum_character_code: INTEGER_16
{}
Smallest supported code for CHARACTER values.
ensure
  • meaningful: Result <= 0
Minimum_integer_8: INTEGER_8
is -128
constant attribute
{}
Smallest supported value of type INTEGER_8.
Minimum_integer_16: INTEGER_16
is -32768
constant attribute
{}
Smallest supported value of type INTEGER_16.
Minimum_integer: INTEGER_32
is -2147483648
constant attribute
{}
Smallest supported value of type INTEGER/INTEGER_32.
Minimum_integer_32: INTEGER_32
is -2147483648
constant attribute
{}
Smallest supported value of type INTEGER/INTEGER_32.
Minimum_integer_64: INTEGER_64
is -9223372036854775808
constant attribute
{}
Smallest supported value of type INTEGER_64.
Minimum_real_32: REAL_32
is {REAL_32 -3.40282346638528859811704183484516925440e+38}
constant attribute
{}
Smallest non-special (no NaNs nor infinity) supported value of type REAL_32.
Minimum_real: REAL_64
{}
Smallest non-special (no NaNs nor infinity) supported value of type REAL.
Just to give an idea of this value: -1.79769313486231570....e+308
Minimum_real_64: REAL_64
{}
Smallest non-special (no NaNs nor infinity) supported value of type REAL.
Just to give an idea of this value: -1.79769313486231570....e+308
Minimum_real_80: REAL_64
{}
Smallest supported value of type REAL_80.
ensure
  • meaningful: Result <= 0.0
Boolean_bits: INTEGER_32
{}
Number of bits in a value of type BOOLEAN.
ensure
  • meaningful: Result >= 1
Character_bits: INTEGER_32
{}
Number of bits in a value of type CHARACTER.
ensure
Integer_bits: INTEGER_32
{}
Number of bits in a value of type INTEGER.
ensure
  • integer_definition: Result = 32
Real_bits: INTEGER_32
is 64
constant attribute
{}
Number of bits in a value of type REAL.
Pointer_bits: INTEGER_32
{}
Number of bits in a value of type POINTER.