 |
bcd |
Type (Structure) |
} bcd __attribute__((__may_alias__)); |
|
Represents the internal organization of floating point numbers
in the format recognized by the TIOS.
The bcd
type represents the internal organization of floating point numbers
in the format recognized by the TIOS (the so-called SMAP II BCD format).
Note that long long is not a typing error: it is a
GNU C extension for representing very long integers (8-byte integers in this implementation).
Here will be given the exact internal organization of floating point numbers. Magnitude of every
real number (except zero) can be represented as m*10^e, where e
(so-called exponent) is an integer, and m (so-called mantissa) is a real number
which satisfies condition 1 <= m < 10
(this is somewhat different convention than used in frexp10 function
which is derived from ANSI standard). e is
stored in the exponent field, and m in mantissa field of the
bcd
structure. Details of storing format are given below. You don't
need to know these details, but they are given here for anybody who needs to
know more about floats on TI.
Field exponent of the bcd
structure contains e+0x4000
if the number is positive, or e+0xC000 if the number is negative. So, the most
significant bit of exponent is the sign of the number, but the format is not
2-complement code (more precise, it is sign_and_magnitude_0x4000_biased code). The exponent
is NOT bcd-coded (unlike the mantissa). Legal range for the e is from -16383 to +16382
(values -16384 and +16383 are reserved for some special values), although many math functions
are not very happy with extremely small or extremely big exponents. Keep your exponents in
the range from -999 to +999.
The mantissa is stored in BCD code. As the mantissa satisfies the condition
1 <= m < 10, it can be represented as
m1.m2m3m4... where m1, m2 etc. are digits (0-9).
TIOS first truncates the mantissa up to 16 digits, or adds trailing zeros on the
end of the mantissa up to 16 digits if it is shorter than 16 digits. Then,
it stores the integer number m1m2m3...m16 in mantissa field
of the bcd
structure using packed BCD code (each digit in
4 bits).
Everything will be more clear on a concrete example. Look the number 379.25
. It can
be written as 3.7925*10^2
. So, e is 2
, and m is 3.7925
. As the
number is positive, exponent will contain 0x4000+2 = 0x4002
.
As the mantissa has less than 16 digits, it must be padded to 3.792500000000000
.
So, mantissa will contain the integer 3792500000000000
, i.e. it will contain
0x3792500000000000
(note the strong correspodence between hex numbers and bcd coded
numbers: they have the same digits). So, to assign the value 379.25
to the
variable a of type bcd
, you can use
a.exponent = 0x4002
and
a.mantissa = 0x3792500000000000
. Standard ANSI types
float
, double
and long double
(all of
them are the same in TIGCC) are internally organized exactly at the same way
in TIGCC, except that from the aspect of the compiler, they are scalars, and
bcd
is a structure, so you can not simply cast float
to bcd
and vice versa. For this purpose, use functions
(more precise macros) float_to_bcd,
bcd_to_float and bcd_var.
Note that due to the condition 1 <= m < 10,
the mantissa must be normalized (which means that the
first digit of the mantissa must not be zero). The consequence is that mantissa
field must always be greater or equal to 0x1000000000000000. You can construct
(artifically) structures in which this condition is not satisfied. Some functions
will work well with such (unnormalized) numbers, but many of them will not work correctly.
So, avoid creating of such illegal values: any unnormalized number may be represented
in normalized format. Anyway, don't worry about it: all numbers written using
"normal" methods are always normalized: you can create unnormalized numbers
only intentionally by direct accessing to mantissa part of a bcd
structure.