Journal of Applied Sciences & Environmental Management,
Vol. 9, No. 3, 2005, pp. 87-89
Algorithm
for Output of Floating-Point Numbers in Fixed-Point Form
NDEEKOR,
C B
Maths /statistics/Computer Science Department, Faculty
of Science, University of Port Harcourt Nigeria. E-mail:
clemtoes@yahoo.com
Code Number: ja05064
ABSTRACT:
Input/output of data items and information are very
common operations performed on computer systems. Various data types require
special ways to perform these operations on them. Floating-point numbers are
no exceptions. Presented in this paper is an algorithm with which floating-point
numbers can be converted to their American Standard Code for Information
Interchange (ASCII) equivalents in fixed-point form ready for output. The
algorithm is so written that it can be implemented easily and requires just
the
address of the buffer to contain the ASCII equivalent and the number of
fractional digits desired in the result. @JASEM
Input/output of data and results into/from the
computer system are very important operations that are performed in most
programs. The program written in high level programming language indirectly
calls up input/output routines through appropriate input/output statements to
perform these operations. The programmer in assembly language has to directly
call up routines to perform input/output or writes his own routines (Brey,
1998; Detmer, 1990 and Sanchez, 1990).
The algorithm presented enables the conversion of a
floating-point number (in its internal form) to a string of American Standard
Code for Information Interchange (ASCII) in fixed-point form ready for output.
The output may be done with an appropriate service function (Norton, 1995). The
user decides the number of fractional digits to appear in the result and
provides a buffer that will hold the ASCII string. This contrasts with what is
obtained in existing output routines where the user must specify the width as
well as number of fractional digits desired, if the output is formatted.
Invariably, the user is forced to provide the number of positions for the
whole-number part of the output; but this is unnecessary since the number of
digits that make up the whole number part of a floating-point number in
fixed-point form is always fixed.
The output from
this algorithm is in the form described by the Extended Backus Naur Form
(EBNF):
FP = [-]{Digit}.{Digit}.
Digit = 0/1/2/3/4/5/6/7/8/9.
where the minus sign is optional (appears for a
negative number). The first recurring Digit represents the whole number part
of the floating-point number while the second represents the fractional part. The
number of digits that can appear in the whole number as well as the fractional
parts are limited by restrictions in the floating-point number data format
adopted.
MATERIALS AND
METHODS
Below is an algorithm that achieves the aims stated in
the introduction above.
Step1: Initialize appropriate variables
NDORM = 0
ROUNDER = 0.5
STRING_POINTER = First byte of Output Buffer
N = Supplied number of fractional digits desired
VALUE = Number to be converted to ASCII characters
Step 2: Divide ROUNDER by 10.0 (N) times.
Step 3: Compare VALUE with 0.0
If (VALUE < 0.0) then
Output minus - sign to buffer
Increment STRING-POINTER
Negate VALUE
Elseif (VALUE = 0.0) then
Go to step 6
End if
Step 4: Add ROUNDER to VALUE
Step 5: Compare VALUE with 10.0
If (VALUE > = 10.0) then
While (VALUE > = 10.0) do
Divide VALUE by 10.0
Increment NDORM
Endwhile
Elseif (VALUE < 1.0) then
While (VALUE < 1.0) do
Multiply VALUE by 10.0
Decrement NDORM
Endwhile
Endif.
Step 6: Compare NDORM and 0
If (NDORM < 0) then
Output 0 to output buffer
Increment STRING-POINTER
Output . to output buffer
Increment STRING-POINTER
If (NDORM ≠ -1)then
Negate NDORM
Decrement NDORM
Repeat until NDORM is 0
Output 0 to output buffer
Increment STRING-POINTER
Decrement NDORM
End repeat
Else
Nagate NDORM
Endif
Repeat until N is 0
Obtain integer part (INT_PART) of
VALUE
Convert INT_PART to ASCII equivalent
Store ASCII equivalent in output
buffer
Increment STRING-POINTER
Subtract INT-PART from VALUE
Multiply VALUE by 10.0
Decrement N
End repeat
Else
COUNTER1 = 1
COUNTER2 = (N + NDORM + 1)
Repeat until COUNTER2 =
0
If (COUNTER1 = NDORM + 2) then
Store . in output buffer
Increment STRING-POINTER
Endif
Obtain INT_PART of VALUE
Convert INT_PART to ASCII equivalent
Store ASCII equivalent in output buffer
Increment STRING_POINTER
Subtract INT-PART from VALUE
Multiply VALUE by 10.0
Increment COUNTER1
Decrement COUNTER2
Endif
Step 7: Store terminating character ($) in buffer
Step 8: Stop.
RESULTS AND
DISCUSSION
In the above algorithm, a ROUNDER is used to take care
of rounding error. The final value of ROUNDER (originally set to 0.5) is
determined by the number of fractional digits desired by the user.
In step 3, the floating-point number to be
converted is checked against 0.0 to know if it is a negative or positive
number. If negative, minus sign is output to the output buffer, STRING_POINTER
incremented and the original VALUE negated. However, if the floating-point
number is zero, control goes to step 6.
Step 4 adds ROUNDER to the floating-point number.
Step 5 compares VALUE (floating-point number to be converted) against 10.0.
If it is greater than or equal to 10.0, it is repeatedly divided by 10.0 until
VALUE is less than 10.0. At each division, NDORM is incremented by 1. However,
if VALUE is not greater than or equal to 10.0 and it is less than 0.1, it is
repeatedly multiplied by 10.0 until it is greater than or equal to 1.0. At
each multiplication, NDORM is decremented by 1 (Detmer, 1990).
In step 6, the digits of the floating-point
number are outputted to the output buffer. The value of NDORM is tested
against 0 to know if it is greater than or equal to it. If it is not, the
implication is that the original floating-point number had leading zero digits
before and after decimal point (recall the continuous multiplication by 10.0 in
step 5). So the leading 0 is output to the output buffer followed by a point
(.). The next test and the actions that follow (NDORM tested against -1)
determine the number of 0s to be output before the first non-zero digit.
When NDORM is equal to -1, there will be no leading non-zero digit after
decimal point but if NDORM is less than -1, then there will be as many as
(-NDORM -1) leading 0s before the first non-zero digit. After storing the
leading zeros, other digits are stored according to the desired number of
fractional digits.
If NDORM is not less than 0, then the floating-point
number is output containing (NDORM + N + 1) ASCII characters. The position of
decimal point is at (NDORM + 2).
Step
7 stores the terminating character
($) while step 8 ends the algorithm.
Conclusion: In this work, an algorithm with which an internal
floating-point number can be converted to fixed-point form requiring just the
desired number of fractional digits and the output buffer is developed. The
algorithm can be used to converted floating-point numbers declared with the Institute of Electrical and Electronic Engineers (IEEE)
floating-point data formats or any possible data format adopted. The algorithm
can also be implemented for customized applications. The dollar sign is used to
terminate the obtained ASCII string.
Acknowledgement: I am indepted to Dr O Owolabi and Dr I. U. Mbeledogu
for their contributions to the research work that lead to this paper.
REFERENCES