``` Download this article as a single PDF document
```

A list of some quick Ada specific options

Integers

Integer attributes:

```   First           -- the first (lowest) value of the type
Last            -- the last (highest) value of the type
Image(X)        -- convert the integer X to a string
Value(X)        -- convert the string X to an integer
Min(X,Y)        -- the smaller of the integers X and Y
Max(X,Y)        -- the larger of the integers X and Y
```

Arithmetic operations

```    +    Addition           -    Subtraction
*    Multiplication     /    Division
rem  Remainder          mod  Modulus
**   Exponentiation     abs  Absolute value
```

```Highest priority (evaluated first):  **    abs   not
*     /     mod   rem
+     -     (unary versions)
+     -     &
=     /=    <     >     <=    >=
Lowest priority (evaluated last):    and   or    xor
```

Difference between rem and mod is the way they deal with negative numbers: rem gives a negative result if the dividend (the left hand operand) is negative, whereas mod gives a negative result if the divisor (the right hand operand) is negative.

```7/5     =  1     7 rem 5     =  2      7 mod 5     =  2
(-7)/5  = -1      (-7) rem 5  = -2     (-7) mod 5  =  3
7/-5    = -1     7 rem -5    =  2      7 mod -5    = -3
(-7)/-5 =  1      (-7) rem -5 = -2     (-7) mod -5 = -2
```

Real types

```type My_Float is digits 10;                                -- a floating point type
type My_Fixed is delta 0.01 range 0.0 .. 10.0;     -- a fixed point type
type Decimal  is delta 0.01 digits 12;                 -- a decimal type (delta
-- must be a power of 10)
```

My_Float is a floating point type which is accurate to at least ten significant figures, and My_Fixed is a fixed point type which is accurate to within 0.01 (i.e. to at least two decimal places) across the specified range. Decimal is a decimal type with 12 digits which is accurate to two decimal places (i.e. capable of representing decimal values up to 9999999999.99).

Numeric literals

It’s possible to write numbers in binary or hexadecimal or any other base between 2 and 16. Here are three different ways of writing the decimal value 31:

```2#11111#   -- the binary (base 2) value 11111
16#1F#       -- the hexadecimal (base 16) value 1F
6#51#         -- the base 6 value 51
```

The letters A to F (or a to f) are used for the digits 10 to 15 when using bases above 10. If you mix an exponent (e) part with a based number, the exponent is raised to the power of the base; thus 16#1F#e1 means hexadecimal 1F (= 31) × 161, or 496 in decimal.

Enumerations

```Pos(X)    -- an integer representing the position of X in the
list of possible values starting at 0
Val(X)    -- the X'th value in the list of possible values
Succ(X)   -- the next (successor) value after X
Pred(X)   -- the previous (predecessor) value to X
```

Cheers,