Sale!

Assignment 1 – Floating Point solution

$30.00

COMPSCI 210
Computer Systems 1
Assignment 1 – Floating Point
Worth 5%

Introduction
This assignment gets you to implement a simple floating point format using Python. The
assignment leads you to develop the floating point format in a series of steps.
CodeRunner
All of the programming is to be tested on CodeRunner https://coderunner2.auckland.ac.nz,
however don’t develop your code in CodeRunner as it is a testing environment, not a development
environment. IDLE or some other IDE or text editor is much better.

Category:

Description

5/5 - (2 votes)

COMPSCI 210
Computer Systems 1
Assignment 1 – Floating Point
Worth 5%

Introduction
This assignment gets you to implement a simple floating point format using Python. The
assignment leads you to develop the floating point format in a series of steps.
CodeRunner
All of the programming is to be tested on CodeRunner https://coderunner2.auckland.ac.nz,
however don’t develop your code in CodeRunner as it is a testing environment, not a development
environment. IDLE or some other IDE or text editor is much better.
The programs submitted through CodeRunner will be checked for similarities to all other
submissions, so please ensure that the work is your own. The checker is not fooled by changing
attribute names and comments or reordering the code, and other alterations.
Python provides a number of easy ways to do some of these exercises. Unfortunately using these
solutions does not demonstrate the algorithms which produce the output. The markers will check
your submitted programs and you will lose any marks allocated by the CodeRunner system if you
haven’t used the indicated algorithms. This is mostly for Program 1 and Program 2.
Program 1 (2 marks)
The function has this signature:
def integer_to_binary(integer_string)
Convert a string of decimal digits up to 32 digits long representing a positive decimal integer value
into its equivalent binary digit string.
You must use the decimal to binary conversion algorithm described in class: repeated division by
two. Print each binary digit as it is produced and print the final result.
The following method produces the expected output but does not use the correct algorithm, hence
it would pass in CodeRunner but you would lose all marks when the markers review the code.
def integer_to_binary(integer_string):
result = bin(int(integer_string))[2:]
for bit in reversed(result):
print(bit, end=’ ‘)
print()
print(result)
Program 2 (4 marks)
The function has this signature:
def fraction_to_binary(fraction_string, significant_binary_digits)
Convert a string of decimal digits up to 32 digits long representing a positive decimal fractional
value into its equivalent binary digit string. For this function to terminate the algorithm accepts the
number of significant binary digits to produce. Binary digits in the result are significant if they are
the first “1” in the result or any digits following the first “1”. The last significant binary digit must
be rounded in the final result. So the algorithm will print more digits than the specified number
page 1
COMPSCI 210 Assignment 1
because leading “0”s don’t count and the algorithm must go one more digit than the specified
number of digits and the final result must show exactly the number of specified significant binary
digits using the extra digit to round up if necessary.
You may assume that the decimal fraction will NOT be zero.
e.g.
0.5 to two significant binary digits would be 0.10
0.125 to two significant binary digits would be 0.0010
0.875 to one significant binary digit would be 1., because that is 0.111 rounded to two significant
binary digits.
You must use the decimal to binary conversion algorithm described in class: repeated
multiplication by two. Print each binary digit as it is produced and print the final result.
All decimal fractions will start with “0.” and the binary final result must also start with “0.” except
when the value rounds to “1.”.
The 32 digits in the decimal fraction do not include the “0.”.
You may find it useful to use the Decimal class. See https://docs.python.org/3/library/
decimal.html
Program 3 (2 marks)
The function has this signature:
def valid_float(number_string)
Check whether a string consists only of decimal digits (of any length) and the “-” and “.” characters
and matches the following requirements. The function returns True if the string is valid, and False
otherwise.
The string must start with a decimal digit or “-“. The “-” can only occur as the first character if it
appears at all.
If the first decimal digit is a “0” the next character must be “.”.
The string does not have to include a “.” There can be only one “.” in the string.
If the string includes a “.” there must be a string of 1 or more decimal digits before the “.” and there
must be 1 or more decimal digits after the “.”
These strings are valid:
1234
-1234
12.4
0.6
-0.6
-1234567890.123456789
These strings are invalid:
+123
123.
.6
00.6
12-.6335
You may use regular expressions. See https://docs.python.org/3/library/re.html
page 2
COMPSCI 210 Assignment 1
An alternative could be to use a finite state machine.
Program 4 (2 marks)
The function has this signature:
def break_into_parts(decimal_string)
Break the decimal string into the sign, the integer part and the fractional part. The decimal string is
guaranteed to be valid as in Program 3. The function must print the sign, integer and fraction part
as below. If the sign is not negative it is printed as “+”, if the fractional part does not exist it is
printed as “0”.
If the decimal string is -12.40 the output would be:
sign: – integer: 12 fraction: 40
If the string is 1234 the output would be:
sign: + integer: 1234 fraction: 0
Program 5 (2 marks)
The function has this signature:
def print_binary(number_string, fraction_length)
Print the binary version of the decimal number string. The decimal string is guaranteed to be valid
as in Program 3. The printed binary number must have at least one digit before and after the “.”.
The fraction length parameter is the number of binary digits to print after the “.”.
Unlike Program 2 you do NOT round the binary fraction at the last digit.
Positive numbers should be printed with a sign.
If the number is 0 and the fraction length is 4 the output would be :
+0.0000
If the decimal number is -12.4 and the fraction length is 10 the output would be:
-1100.0110011001
Program 6 (8 marks)
The function has this signature:
def float_string_to_binary(float_string)
It takes a decimal number string representing a floating point value and prints out the binary
equivalent using the floating point format described below. You may assume that all values of the
decimal string will fit within this format.
The format
The floating point format to use is similar to the IEEE 32-bit floating point format as covered in
class. It is a 16-bit format (not quite the same as the IEEE 16-bit format).
Sign: the first bit (most significant bit: bit 15). 1 means negative, 0 means positive
Exponent: four bits for the exponent (bits 14–11). The exponent has a bias of 7.
page 3
COMPSCI 210 Assignment 1
Mantissa (fractional part): 11 bits (bits 10–0). The mantissa is normalised and the most significant 1
is not represented. When converting a decimal number into this format you must round the 12th
significant binary digit of the number before removing the most significant 1.
Zero is represented by all 16 bits being 0.
e.g. The largest number which can be represented by this approach is 511.875
0 1111 11111111111
The sign is positive.
The exponent is 11112 minus the bias or 15 – 7 = 8.
The mantissa is 1.111111111112 remember the non-showing 1 before the binary point.
1.111111111112 * 28 = 111111111.1112 = 511.875
I leave you with the exercise to find the smallest non-zero value which can be represented by this
format.
And
Include a comment with your login name (UPI) at the top of each program you enter into
CodeRunner. Markers will remove a mark if you have not done this on every program.