+
Point of view
All features
expanded class INTEGER_64
Summary
top
Direct parents
Insert list: INTEGER_GENERAL
Overview
top
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}
top
Does Current fit in INTEGER_8?
ensure
to_integer_8: INTEGER_8
{ANY}
top
Explicit conversion to INTEGER_8.
require ensure
fit_integer_16: BOOLEAN
effective function
{ANY}
top
Does Current fit in INTEGER_16?
ensure
  • Result = Current.in_range(-32768, 32767)
to_integer_16: INTEGER_16
{ANY}
top
Explicit conversion to INTEGER_16.
require ensure
fit_integer_32: BOOLEAN
effective function
{ANY}
top
Does Current fit in INTEGER_32?
ensure
  • Result = Current.in_range(-2147483648, 2147483647)
to_integer_32: INTEGER_32
{ANY}
top
Explicit conversion to INTEGER_32.
require ensure
  • Current = Result
fit_natural_8: BOOLEAN
effective function
{ANY}
top
Does Current fit in NATURAL_8?
ensure
to_natural_8: NATURAL_8
{ANY}
top
Explicit conversion to NATURAL_8.
require ensure
  • Result.to_integer_16 = Current
fit_natural_16: BOOLEAN
effective function
{ANY}
top
Does Current fit in NATURAL_16?
ensure
to_natural_16: NATURAL_16
{ANY}
top
Explicit conversion to NATURAL_16.
require ensure
  • Result.to_integer_32 = Current
fit_natural_32: BOOLEAN
effective function
{ANY}
top
Does Current fit in NATURAL_32?
ensure
  • Result = Current.in_range(0, 4294967295)
to_natural_32: NATURAL_32
{ANY}
top
Explicit conversion to NATURAL_32.
require ensure
  • Result.to_integer_64 = Current
to_natural_64: NATURAL_64
{ANY}
top
Explicit conversion to NATURAL_64.
require
  • Current >= 0
ensure
  • Result.to_integer_64 = Current
force_to_real_32: REAL_32
{ANY}
top
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}
top
Does Current fit in REAL_32?
to_real_32: REAL_32
effective function
{ANY}
top
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}
top
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}
top
Does Current fit in REAL_64?
to_real_64: REAL_64
effective function
{ANY}
top
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}
top
Convert Current into a new allocated NUMBER.
See also to_boolean, to_string, to_character, to_hexadecimal.
ensure
  • Result @= Current
  • Result.to_string.is_equal(to_string)
decimal_digit: CHARACTER
effective function
{ANY}
top
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}
top
Gives the corresponding CHARACTER for range 0..15.
require
  • is_hexadecimal_digit
ensure
  • "0123456789ABCDEF".has(Result)
low_32: INTEGER_32
{ANY}
top
The 32 low bits of Current (i.e. the right-most part).
high_32: INTEGER_32
effective function
{ANY}
top
The 32 high bits of Current (i.e. the left-most part).
one: INTEGER_8
is 1
constant attribute
{ANY}
top
Neutral element for "*" and "/".
zero: INTEGER_8
is 0
constant attribute
{ANY}
top
Neutral element for "+" and "-".
hash_code: INTEGER_32
effective function
{ANY}
top
The hash-code value of Current.
ensure
  • good_hash_value: Result >= 0
sqrt: REAL_64
effective function
{ANY}
top
Square root of Current.
require
  • Current >= zero
log: REAL_64
effective function
{ANY}
top
Natural Logarithm of Current.
require
  • Current > zero
log10: REAL_64
effective function
{ANY}
top
Base-10 Logarithm of Current.
require
  • Current > zero
bit_count: INTEGER_8
is 64
constant attribute
{ANY}
top
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
{}
top
infix "+" (other: INTEGER_64): INTEGER_64
{ANY}
top
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}
top
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}
top
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}
top
Division by other.
require
  • other /= Void
  • other /= zero
  • divisible(other)
infix "//" (other: INTEGER_64): INTEGER_64
effective function
{ANY}
top
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}
top
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}
top
Integer power of Current by other
require
  • exp >= zero
abs: INTEGER_64
effective function
{ANY}
top
Absolute value of Current.
require
  • not_minimum_value: Current < zero implies zero < #- Current
ensure
  • Result >= zero
infix "<" (other: INTEGER_64): BOOLEAN
{ANY}
top
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}
top
require
  • other_exists: other /= Void
ensure
  • definition: Result = Current < other or is_equal(other)
infix ">" (other: INTEGER_64): BOOLEAN
{ANY}
top
require
  • other_exists: other /= Void
ensure
  • definition: Result = other < Current
infix ">=" (other: INTEGER_64): BOOLEAN
{ANY}
top
require
  • other_exists: other /= Void
ensure
  • definition: Result = other <= Current
prefix "+": INTEGER_64
effective function
{ANY}
top
Unary plus of Current.
prefix "-": INTEGER_64
{ANY}
top
Unary minus of Current.
require
  • not_minimum_value: Current < zero implies zero < #- Current
is_odd: BOOLEAN
effective function
{ANY}
top
Is odd?
is_even: BOOLEAN
effective function
{ANY}
top
Is even?
is_prime: BOOLEAN
effective function
{ANY}
top
Is prime?
is_fibonacci: BOOLEAN
effective function
{ANY}
top
Is Fibonacci number?
gcd (other: INTEGER_64): INTEGER_64
effective function
{ANY}
top
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
{}
top
to_string: STRING
effective function
{ANY}
top
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}
top
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}
top
Return False for 0, otherwise True.
See also to_string, to_character, to_hexadecimal, to_number.
ensure
  • Result = Current /= zero
append_in (buffer: STRING)
effective procedure
{ANY}
top
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}
top
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}
top
Same as to_string but the result is on s character and the number is right aligned.
See also append_in_format, to_character, to_number, to_hexadecimal.
require
  • to_string.count <= s
ensure
  • Result.count = s
to_unicode_string_format (s: INTEGER_32): UNICODE_STRING
effective function
{ANY}
top
Same as to_unicode_string but the result is on s character and the number is right aligned.
See also append_in_unicode_format, to_string, to_hexadecimal, to_octal.
require
  • to_string.count <= s
ensure
  • Result.count = s
append_in_format (buffer: STRING, s: INTEGER_32)
effective procedure
{ANY}
top
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}
top
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}
top
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}
top
is_hexadecimal_digit: BOOLEAN
effective function
{ANY}
top
to_character: CHARACTER
{ANY}
top
Return the corresponding ASCII character.
See also to_boolean, to_number, to_string, to_hexadecimal.
require
  • Current >= zero
    Current <= Maximum_character_code

to_octal_in (buffer: STRING)
effective procedure
{ANY}
top
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}
top
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}
top
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}
top
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}
top
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}
top
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}
top
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}
top
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}
top
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}
top
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}
top
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}
top
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}
top
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}
top
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}
top
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}
top
Rotate by s positions left.
See also bit_rotate_right and bit_rotate.
require
  • s.in_range(1, bit_count - 1)
bit_rotate_left (s: INTEGER_8): INTEGER_64
{ANY}
top
Rotate by s positions left.
See also bit_rotate_right and bit_rotate.
require
  • s.in_range(1, bit_count - 1)
bit_rotate (s: INTEGER_8): INTEGER_64
{ANY}
top
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}
top
One's complement of Current.
bit_not: INTEGER_64
{ANY}
top
One's complement of Current.
infix "&" (other: INTEGER_64): INTEGER_64
{ANY}
top
Bitwise logical and of Current with other.
bit_and (other: INTEGER_64): INTEGER_64
{ANY}
top
Bitwise logical and of Current with other.
infix "|" (other: INTEGER_64): INTEGER_64
{ANY}
top
Bitwise logical inclusive or of Current with other.
bit_or (other: INTEGER_64): INTEGER_64
{ANY}
top
Bitwise logical inclusive or of Current with other.
bit_xor (other: INTEGER_64): INTEGER_64
{ANY}
top
Bitwise logical exclusive or of Current with other.
bit_shift (s: INTEGER_8): INTEGER_64
effective function
{ANY}
top
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}
top
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}
top
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}
top
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}
top
Sign of Current (0 or -1 or 1).
ensure
  • Result.in_range(-1, 1)
divisible (other: INTEGER_64): BOOLEAN
effective function
{ANY}
top
May Current be divided by other ?
require
  • other /= Void
ensure
  • definition: Result = other /= zero
is_equal (other: INTEGER_64): BOOLEAN
effective function
{ANY}
top
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}
top
Is Current a power of 2?
require
  • Current > zero
times (repeat: PROCEDURE[TUPLE[TUPLE 1[INTEGER_64]]])
effective procedure
{ANY}
top
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}
top
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}
top
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}
top
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}
top
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}
top
prefix "#-": INTEGER_64
{ANY}
top
infix "#-" (other: INTEGER_64): INTEGER_64
{ANY}
top
infix "#*" (other: INTEGER_64): INTEGER_64
{ANY}
top
infix "#//" (other: INTEGER_64): INTEGER_64
{ANY}
top
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}
top
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
{}
top
unicode_string_buffer: UNICODE_STRING
once function
{}
top
lcm (other: INTEGER_64): INTEGER_64
effective function
{ANY}
top
Least Common Multiple of Current and other.
ensure
in_range (lower: INTEGER_64, upper: INTEGER_64): BOOLEAN
effective function
{ANY}
top
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}
top
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}
top
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}
top
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}
top
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}
top
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
{}
top
Largest supported code for CHARACTER values.
ensure
  • meaningful: Result >= 127
Maximum_integer_8: INTEGER_8
is 127
constant attribute
{}
top
Largest supported value of type INTEGER_8.
Maximum_integer_16: INTEGER_16
is 32767
constant attribute
{}
top
Largest supported value of type INTEGER_16.
Maximum_integer: INTEGER_32
is 2147483647
constant attribute
{}
top
Largest supported value of type INTEGER/INTEGER_32.
Maximum_integer_32: INTEGER_32
is 2147483647
constant attribute
{}
top
Largest supported value of type INTEGER/INTEGER_32.
Maximum_integer_64: INTEGER_64
is 9223372036854775807
constant attribute
{}
top
Largest supported value of type INTEGER_64.
Maximum_real_32: REAL_32
is {REAL_32 3.4028234663852885981170418348451692544e+38}
constant attribute
{}
top
Largest non-special (no NaNs nor infinity) supported value of type REAL_32.
Maximum_real: REAL_64
{}
top
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
{}
top
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
{}
top
Largest supported value of type REAL_80.
ensure
Minimum_character_code: INTEGER_16
{}
top
Smallest supported code for CHARACTER values.
ensure
  • meaningful: Result <= 0
Minimum_integer_8: INTEGER_8
is -128
constant attribute
{}
top
Smallest supported value of type INTEGER_8.
Minimum_integer_16: INTEGER_16
is -32768
constant attribute
{}
top
Smallest supported value of type INTEGER_16.
Minimum_integer: INTEGER_32
is -2147483648
constant attribute
{}
top
Smallest supported value of type INTEGER/INTEGER_32.
Minimum_integer_32: INTEGER_32
is -2147483648
constant attribute
{}
top
Smallest supported value of type INTEGER/INTEGER_32.
Minimum_integer_64: INTEGER_64
is -9223372036854775808
constant attribute
{}
top
Smallest supported value of type INTEGER_64.
Minimum_real_32: REAL_32
is {REAL_32 -3.40282346638528859811704183484516925440e+38}
constant attribute
{}
top
Smallest non-special (no NaNs nor infinity) supported value of type REAL_32.
Minimum_real: REAL_64
{}
top
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
{}
top
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
{}
top
Smallest supported value of type REAL_80.
ensure
  • meaningful: Result <= 0.0
Boolean_bits: INTEGER_32
{}
top
Number of bits in a value of type BOOLEAN.
ensure
  • meaningful: Result >= 1
Character_bits: INTEGER_32
{}
top
Number of bits in a value of type CHARACTER.
ensure
Integer_bits: INTEGER_32
{}
top
Number of bits in a value of type INTEGER.
ensure
  • integer_definition: Result = 32
Real_bits: INTEGER_32
is 64
constant attribute
{}
top
Number of bits in a value of type REAL.
Pointer_bits: INTEGER_32
{}
top
Number of bits in a value of type POINTER.