Integers

In integer.cecil:

abstract object integer isa num; 
method =(l@:integer,r@:integer):bool; 
method <(l@:integer,r@:integer):bool;
implementation +(l@:integer,r@:integer):integer; 
implementation -(l@:integer,r@:integer):integer;
implementation *(l@:integer,r@:integer):integer; 
implementation /(l@:integer,r@:integer):integer; 
method mod(l@:integer,r@integer:`T <= integer):T;
- modulus 
signature %(integer, `T <= integer):T;
- same as

mod 
implementation %(l@:integer,r@:integer):integer; 
signature rem(integer, `T <= integer):T;
- remainder 
implementation rem(l@:integer,r@:integer):integer; 
method -_ov(l@:integer):integer;
method +_ov(l@:integer,r@:integer):integer; 
method -_ov(l@:integer,r@:integer):integer;
method *_ov(l@:integer,r@:integer):integer; 
method /_ov(l@:integer,r@:integer):integer; 
method %_ov(l@:integer,r@:integer):integer; 
method <<(l@:integer,r@:integer):integer;
- left shift
method >>(l@:integer,r@:integer):integer;
- right arithmetic shift (extends sign)
method <<_ov(l@:integer,r@:integer):integer;
method >>_ov(l@:integer,r@:integer):integer;
method bit_and (l@:integer, r@:integer):integer; 
method bit_or (l@:integer, r@:integer):integer; 
method bit_xor (l@:integer, r@:integer):integer; 
method bit_xnor (l@:integer, r@:integer):integer; 
method bit_not(l@:integer):integer; 
method get_bit(i@:integer, bit@:integer):integer;
- extract

ith bit (0 or 1) 
method set_bit(i@:integer, bit@:integer):integer;
- set

ith bit to 1 
method clear_bit(i@:integer, bit@:integer):integer;
- set

ith bit to 0 
method as_int(l@integer:`T <= integer):T; 
method as_small_int(l@:integer):int; 
signature as_small_int(integer, if_overflow:&():`T):int|T; 
method as_small_int_if_possible(l@:integer):integer; 
method is_int8(val@:integer):bool; 
method as_int8(val@:integer, if_overflow:&():integer):integer; 
method log_base(x@:integer, base@:integer):int;
- compute logarithm to nearest integer; rounds up 
method exact_log_base(x@:integer, base@:integer, 
if_not_exact:&():int):int;
- compute logarithm, but invoke closure if integer result not exact
method is_even(i@:integer):bool;
- test parity 
method is_odd(i@:integer):bool; 
method hash(i@:integer, range:`T <= integer):S 
where signature %(integer, T):`Q, signature abs(Q):`S;
signature average(integer,integer):integer; 

         Integers are numbers, supporting all the operations of numbers. The normal +, -, *, and / operations do not trap overflow; the +_ov, etc. functions transparently coerce to arbitrary-precision integers if overflow happens. The bitwise operations assume two's complement representation.

method round_up(i:integer, nearest:integer):integer; 
signature round_up(int, int):int; 
method round_down(i:integer, nearest:integer):integer; 
signature round_down(int, int):int; 
method factorial(n:integer):integer; 
method fibonacci(n:integer):integer; 
method fibonacci_recursive(n:integer):integer; 

round_up rounds toward positive infinity, while round_down rounds toward negative infinity. Both ignore the sign of their second argument.

method do_digits_increasing(i@:integer, c:&(digit:int,position:int):void):void; 
method do_digits_increasing_base(i@:integer, base:int, 
c:&(digit:int,position:int):void):void;
method print_string(i@:integer):string; 
method print_string_base(i@:integer, base:int):string; 
method print_string_base(i@:int, base:int):string; 
method print_string(i@:integer, len:int):string; 

do_digits_increasing calls its closure on each digit from least to most significant; the position argument indicates the digit's significance and starts at zero.

In small-int.cecil:

extend int isa integer; 
method = (l@:int, r@:int):bool; 
method < (l@:int, r@:int):bool;
method <_unsigned (l@:int, r@:int):bool;
method <= (l@:int, r@:int):bool;
method <=_unsigned (l@:int, r@:int):bool;
method > (l@:int, r@:int):bool;
method >_unsigned (l@:int, r@:int):bool;
method >= (l@:int, r@:int):bool;
method >=_unsigned (l@:int, r@:int):bool;
method != (l@:int, r@:int):bool;
implementation + (l@:int, r@:int):int; 
implementation - (l@:int, r@:int):int;
implementation * (l@:int, r@:int):int; 
implementation / (l@:int, r@:int):int; 
implementation % (l@:int, r@:int):int; 
method negate_ov (l@:int, if_overflow:&():`T):int|T; 
method add_ov (l@:int, r@:int, if_overflow:&():`T):int|T; 
method sub_ov (l@:int, r@:int, if_overflow:&():`T):int|T; 
method mul_ov (l@:int, r@:int, if_overflow:&():`T):int|T; 
method div_ov (l@:int, r@:int, if_overflow:&():`T):int|T; 
method mod_ov (l@:int, r@:int, if_overflow:&():`T):int|T; 
method -_ov(l@:int):integer;
method +_ov (l@:int, r@:int):integer; 
method -_ov (l@:int, r@:int):integer;
method *_ov (l@:int, r@:int):integer; 
method /_ov (l@:int, r@:int):integer; 
method %_ov (l@:int, r@:int):integer; 
method as_single_float(l@:int):single_float; 
method as_double_float(l@:int):double_float; 
method bit_and (l@:int, r@:int):int; 
method bit_or (l@:int, r@:int):int; 
method bit_xor (l@:int, r@:int):int; 
method bit_not(l@:int):int; 
method << (l@:int, r@:int):int;
method >> (l@:int, r@:int):int;
method >>_logical (l@:int, r@:int):int;
- right logical shift (no sign-extension)
method get_bit(i@:int, bit@:int):int; 
method set_bit(i@:int, bit@:int):int; 
method clear_bit(i@:int, bit@:int):int; 
method is_even(i@:int):bool; 
method sqrt(x@:int):int; 
signature average(int,int):int; 
signature pred(int):int; 
signature succ(int):int; 
method as_small_int(l@:int, if_overflow:&():`T):int; 

                Small integers ( int) are the main representation of integers.

method do(count@:int, c:&(int):void):void; 
method print_string(i@:int):string; 
let num_int_bits:int;
- number of bits in small int representation 
let max_int:int;
- maximum small int 
let min_int:int;
- minimum small int 

do on integers is a simple kind of for-loop. Expression n.do(&(i:int){...}) invokes the argument closure n times, binding i to each of the numbers from 0 to n-1 in turn; it does not return a value.

In big-int.cecil:

template object big_int isa integer; 
method =(l@:big_int, r@:big_int):bool; 
method < (l@:big_int, r@:big_int):bool;
method <=(l@:big_int, r@:big_int):bool;
method >=(l@:big_int, r@:big_int):bool;
method > (l@:big_int, r@:big_int):bool;
method compare(l@:big_int, r@:big_int,  
if_less:&():`T, if_equal:&():`T, if_greater:&():`T
):T;
method -(l@:big_int):big_int;
method +(l@:big_int, r@:big_int):big_int; 
method -(l@:big_int, r@:big_int):big_int;
method *(l@:big_int, r@:big_int):big_int; 
method /(l@:big_int, r@:big_int):big_int; 
method %(l@:big_int, r@:big_int):big_int; 
method %(l@:big_int, r@:int):int; 
method <<(l@:big_int, r@:integer):integer;
method >>(l@:big_int, r@:integer):integer;
method as_small_int(l@:big_int, if_overflow:&():`T):int|T; 
signature as_big_int(integer):big_int; 
implementation as_big_int(l@:big_int):big_int; 
implementation as_big_int(l@:int):big_int; 
method as_single_float(l@:big_int):single_float; 
method as_double_float(l@:big_int):double_float; 
method print_string_base(x@:big_int, base:int):string; 

         Big integers are an arbitrary-precision representation of integers.