+
Point of view
All features
expanded class NATURAL_8
Summary
Direct parents
Insert list: NATURAL_GENERAL
Overview
Features
Explicit conversions:
{ANY}
{ANY}
{ANY}
• infix "+" (other: NATURAL_8): NATURAL_8
Sum with other (commutative).
• infix "-" (other: NATURAL_8): NATURAL_8
Result of subtracting other.
• infix "*" (other: NATURAL_8): NATURAL_8
Product by other.
• infix "/" (other: NATURAL_8): REAL_64
Division by other.
• infix "<" (other: NATURAL_8): BOOLEAN
Is Current strictly less than other?
• infix "<=" (other: NATURAL_8): BOOLEAN
Is Current less than or equal other?
• infix ">" (other: NATURAL_8): BOOLEAN
Is Current strictly greater than other?
• infix ">=" (other: NATURAL_8): BOOLEAN
Is Current greater than or equal than other?
• is_equal (other: NATURAL_8): BOOLEAN
Is other attached to an object considered equal to current object?
Conversions:
{ANY}
Modular arithmetic (these wrap around on overflow)
{ANY}
Object printing
{ANY}
Bitwise Logical Operators:
{ANY}
• infix "#>>" (s: INTEGER_8): NATURAL_8
Rotate by s positions right.
• bit_rotate_right (s: INTEGER_8): NATURAL_8
Rotate by s positions right.
• infix "#<<" (s: INTEGER_8): NATURAL_8
Rotate by s positions left.
• bit_rotate_left (s: INTEGER_8): NATURAL_8
Rotate by s positions left.
• bit_rotate (s: INTEGER_8): NATURAL_8
Rotate by s positions (positive s shifts right, negative left
• prefix "~": NATURAL_8
One's complement of Current.
• bit_not: NATURAL_8
One's complement of Current.
• infix "&" (other: NATURAL_8): NATURAL_8
Bitwise logical and of Current with other.
• bit_and (other: NATURAL_8): NATURAL_8
Bitwise logical and of Current with other.
• infix "|" (other: NATURAL_8): NATURAL_8
Bitwise logical inclusive or of Current with other.
• bit_or (other: NATURAL_8): NATURAL_8
Bitwise logical inclusive or of Current with other.
• bit_xor (other: NATURAL_8): NATURAL_8
Bitwise logical exclusive or of Current with other.
• infix "|>>" (s: INTEGER_8): NATURAL_8
Shift by s positions right (sign bit copied) bits falling off the end are lost.
• bit_shift_right (s: INTEGER_8): NATURAL_8
Shift by s positions right (sign bit copied) bits falling off the end are lost.
• infix "|<<" (s: INTEGER_8): NATURAL_8
Shift by s positions left bits falling off the end are lost.
• bit_shift_left (s: INTEGER_8): NATURAL_8
Shift by s positions left bits falling off the end are lost.
{}
{ANY}
• in_range (lower: NATURAL_8, upper: NATURAL_8): BOOLEAN
Return True if Current is in range [lower..upper]
• compare (other: NATURAL_8): INTEGER_32
If current object equal to other, 0 if smaller, -1; if greater, 1.
• three_way_comparison (other: NATURAL_8): INTEGER_32
If current object equal to other, 0 if smaller, -1; if greater, 1.
• min (other: NATURAL_8): NATURAL_8
Minimum of Current and other.
• max (other: NATURAL_8): NATURAL_8
Maximum of Current and other.
• bounded_by (a_min: NATURAL_8, a_max: NATURAL_8): NATURAL_8
A value that is equal to Current if it is between the limits set by a_min and a_max.
Maximum:
{}
Minimum:
{}
Bits:
{}
to_natural_16: NATURAL_16
{ANY}
Explicit conversion to NATURAL_16.
ensure
• Result.to_natural_8 = Current
to_natural_32: NATURAL_32
{ANY}
Explicit conversion to NATURAL_32.
ensure
• Result.to_natural_8 = Current
to_natural_64: NATURAL_64
{ANY}
Explicit conversion to NATURAL_64.
ensure
• Result.to_natural_8 = Current
fit_integer_8: BOOLEAN
effective function
{ANY}
Does Current fit in INTEGER_8?
ensure
• Result = Current <= 127.to_natural_8
to_integer_8: INTEGER_8
{ANY}
Explicit conversion to INTEGER_8.
require ensure
• Result.to_natural_8 = Current
to_integer_16: INTEGER_16
{ANY}
Explicit conversion to INTEGER_16.
ensure
• Result.to_natural_8 = Current
to_integer_32: INTEGER_32
{ANY}
Explicit conversion to INTEGER_32.
ensure
• Result.to_natural_8 = Current
to_integer_64: INTEGER_64
{ANY}
Explicit conversion to INTEGER_64.
ensure
• Result.to_natural_8 = Current
to_real_32: REAL_32
effective function
{ANY}
Explicit conversion to REAL_32.
to_real_64: REAL_64
effective function
{ANY}
Explicit conversion to REAL_64.
infix "//" (other: NATURAL_8): NATURAL_8
{ANY}
Quotient of the Euclidian division of Current by other.
The corresponding remainder is given by infix "\\".
require
• other /= 0.to_natural_8
infix "\\" (other: NATURAL_8): NATURAL_8
{ANY}
Remainder of the Euclidian division of Current by other.
By definition, 0 <= Result < other.abs.
require
• other /= 0.to_natural_8
is_odd: BOOLEAN
effective function
{ANY}
Is odd?
is_even: BOOLEAN
effective function
{ANY}
Is even?
hash_code: INTEGER_32
effective function
{ANY}
The hash-code value of Current.
ensure
• good_hash_value: Result >= 0
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!).
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!).
require
• buffer /= Void
decimal_digit: CHARACTER
effective function
{ANY}
Gives the corresponding CHARACTER for range 0..9.
require
• in_range(0.to_natural_8, 9.to_natural_8)
ensure
• "0123456789".has(Result)
effective function
{ANY}
Gives the corresponding CHARACTER for range 0..15.
require
• in_range(0.to_natural_8, 15.to_natural_8)
ensure
• "0123456789ABCDEF".has(Result)
to_character: CHARACTER
effective function
{ANY}
Return the corresponding ASCII character.
require
to_number: NUMBER
effective function
{ANY}
Convert Current into a new allocated NUMBER.
ensure
• Result.to_string.is_equal(to_string)
bit_count: INTEGER_8
is 8
constant attribute
{ANY}
The number of bits used to store the value of Current (it is 8 for NATURAL_8, 16 for NATURAL_16 and so on) This is actually used only for assertion here, in NATURAL_GENERAL.
ensure
• Result = object_size * 8
infix "+" (other: NATURAL_8): NATURAL_8
{ANY}
Sum with other (commutative).
infix "-" (other: NATURAL_8): NATURAL_8
{ANY}
Result of subtracting other.
infix "*" (other: NATURAL_8): NATURAL_8
{ANY}
Product by other.
infix "/" (other: NATURAL_8): REAL_64
{ANY}
Division by other.
infix "<" (other: NATURAL_8): BOOLEAN
{ANY}
Is Current strictly less than other?
require
• other_exists: other /= Void
ensure
• asymmetric: Result implies not other < Current
infix "<=" (other: NATURAL_8): BOOLEAN
{ANY}
Is Current less than or equal other?
require
• other_exists: other /= Void
ensure
• definition: Result = Current < other or is_equal(other)
infix ">" (other: NATURAL_8): BOOLEAN
{ANY}
Is Current strictly greater than other?
require
• other_exists: other /= Void
ensure
• definition: Result = other < Current
infix ">=" (other: NATURAL_8): BOOLEAN
{ANY}
Is Current greater than or equal than other?
require
• other_exists: other /= Void
ensure
• definition: Result = other <= Current
is_equal (other: NATURAL_8): 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)
• trichotomy: Result = not Current < other and not other < Current
• Result implies hash_code = other.hash_code
to_string: STRING
effective function
{ANY}
The decimal view of Current into a new allocated STRING.
For example, if Current is 3 the Result is "3".
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".
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!).
require
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!).
require
ensure
• buffer.count >= old buffer.count + s
infix "#+" (other: NATURAL_8): NATURAL_8
{ANY}
infix "#-" (other: NATURAL_8): NATURAL_8
{ANY}
infix "#\\" (other: NATURAL_8): NATURAL_8
{ANY}
infix "#//" (other: NATURAL_8): NATURAL_8
{ANY}
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
effective function
{ANY}
effective procedure
{ANY}
infix "#>>" (s: INTEGER_8): NATURAL_8
{ANY}
Rotate by s positions right.
require
bit_rotate_right (s: INTEGER_8): NATURAL_8
{ANY}
Rotate by s positions right.
require
infix "#<<" (s: INTEGER_8): NATURAL_8
{ANY}
Rotate by s positions left.
require
bit_rotate_left (s: INTEGER_8): NATURAL_8
{ANY}
Rotate by s positions left.
require
bit_rotate (s: INTEGER_8): NATURAL_8
{ANY}
Rotate by s positions (positive s shifts right, negative left
require
prefix "~": NATURAL_8
{ANY}
One's complement of Current.
bit_not: NATURAL_8
{ANY}
One's complement of Current.
infix "&" (other: NATURAL_8): NATURAL_8
{ANY}
Bitwise logical and of Current with other.
bit_and (other: NATURAL_8): NATURAL_8
{ANY}
Bitwise logical and of Current with other.
infix "|" (other: NATURAL_8): NATURAL_8
{ANY}
Bitwise logical inclusive or of Current with other.
bit_or (other: NATURAL_8): NATURAL_8
{ANY}
Bitwise logical inclusive or of Current with other.
bit_xor (other: NATURAL_8): NATURAL_8
{ANY}
Bitwise logical exclusive or of Current with other.
infix "|>>" (s: INTEGER_8): NATURAL_8
{ANY}
Shift by s positions right (sign bit copied) bits falling off the end are lost.
bit_shift_right (s: INTEGER_8): NATURAL_8
{ANY}
Shift by s positions right (sign bit copied) bits falling off the end are lost.
infix "|<<" (s: INTEGER_8): NATURAL_8
{ANY}
Shift by s positions left bits falling off the end are lost.
bit_shift_left (s: INTEGER_8): NATURAL_8
{ANY}
Shift by s positions left bits falling off the end are lost.
string_buffer: STRING
once function
{}
unicode_string_buffer: UNICODE_STRING
once function
{}
in_range (lower: NATURAL_8, upper: NATURAL_8): BOOLEAN
effective function
{ANY}
Return True if Current is in range [lower..upper]
ensure
• Result = Current >= lower and Current <= upper
compare (other: NATURAL_8): INTEGER_32
effective function
{ANY}
If current object equal to other, 0 if smaller, -1; if greater, 1.
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: NATURAL_8): INTEGER_32
effective function
{ANY}
If current object equal to other, 0 if smaller, -1; if greater, 1.
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: NATURAL_8): NATURAL_8
effective function
{ANY}
Minimum of Current and other.
require
• other /= Void
ensure
• Result <= Current and then Result <= other
• compare(Result) = 0 or else other.compare(Result) = 0
max (other: NATURAL_8): NATURAL_8
effective function
{ANY}
Maximum of Current and other.
require
• other /= Void
ensure
• Result >= Current and then Result >= other
• compare(Result) = 0 or else other.compare(Result) = 0
bounded_by (a_min: NATURAL_8, a_max: NATURAL_8): NATURAL_8
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.