Week 02 Laboratory Exercises

Objectives

to practice using C's bitwise operations
to understand how integer values are represented
to practice manipulating dynamic memory
to explore working with binary-coded decimal values
to explore arbitrary precision integer arithmetic

Preparation

Before the lab you should re-read the relevant lecture slides and their accompanying examples.

Getting Started

Set up for the lab by creating a new directory called lab02 and changing to this directory.

mkdir lab02
cd lab02

There are some provided files for this lab which you can fetch with this command:

1092 fetch lab02

If you're not working at CSE, you can download the provided files as a zip file or a tar file.

Exercise — individual:
Convert 16 Binary Digits to A Signed Number

Download sixteen_in.c, or copy it to your CSE account using the following command:

cp -n /import/reed/A/dp1092/public_html/24T3/activities/sixteen_in/files.cp/sixteen_in.c sixteen_in.c

Your task is to add code to this function in sixteen_in.c:

//
// given a string of binary digits ('1' and '0')
// return the corresponding signed 16 bit integer
//
int16_t sixteen_in(char *bits) {

    // PUT YOUR CODE HERE

    return 0;
}

Add code to the function sixteen_in so that, given a sixteen-character string containing an ASCII positional representation of a binary number, it returns the corresponding signed integer. For example:

./sixteen_in 0000000000000000
0
./sixteen_in 1111111111111111
-1
./sixteen_in 0011001100110011
13107
./sixteen_in 1111000011110000
-3856

When you think your program is working, you can use autotest to run some simple automated tests:

1092 autotest sixteen_in

When you are finished working on this exercise, you must submit your work by running give:

give dp1092 lab02_sixteen_in sixteen_in.c

You must run give before Tuesday 10 September 09:00 (2024-09-10 09:00:00) to obtain the marks for this lab exercise. Note that this is an individual exercise, the work you submit with give must be entirely your own.

Exercise — individual:
Convert a 16-bit Signed Number to Binary Digits

Download sixteen_out.c, or copy it to your CSE account using the following command:

cp -n /import/reed/A/dp1092/public_html/24T3/activities/sixteen_out/files.cp/sixteen_out.c sixteen_out.c

Your task is to add code to this function in sixteen_out.c:

// given a signed 16 bit integer
// return a null-terminated string of 16 binary digits ('1' and '0')
// storage for string is allocated using malloc
char *sixteen_out(int16_t value) {

    // PUT YOUR CODE HERE

}

Add code to the function sixteen_out so that, given a 16-bit signed integer it returns a string containing sixteen binary digits ('0' or '1'). For example:

./sixteen_out 0
0000000000000000
./sixteen_out -1
1111111111111111
./sixteen_out 13107
0011001100110011
./sixteen_out -3856
1111000011110000

When you think your program is working, you can use autotest to run some simple automated tests:

1092 autotest sixteen_out

When you are finished working on this exercise, you must submit your work by running give:

give dp1092 lab02_sixteen_out sixteen_out.c

Exercise — individual:
Convert a 2 digit BCD Value to an Integer

Download bcd.c, or copy it to your CSE account using the following command:

cp -n /import/reed/A/dp1092/public_html/24T3/activities/bcd/files.cp/bcd.c bcd.c

Your task is to add code to this function in bcd.c:

// given a  BCD encoded value between 0 .. 99
// return corresponding integer
int bcd(int bcd_value) {

    // PUT YOUR CODE HERE

    return 0;
}

Add code to the function bcd so that, given a 2 digit Binary-Coded Decimal (BCD) value, it returns the corresponding integer.

In binary-coded decimal format, each byte holds 1 decimal value (0 to 9), so each byte contains 1 decimal digit. For example:

./bcd 0x07
7
./bcd 0x0102             # note: 0x0102 == 258 decimal
12
./bcd 0x0402             # note: 0x0402 == 1026 decimal
42

When you think your program is working, you can use autotest to run some simple automated tests:

1092 autotest bcd

When you are finished working on this exercise, you must submit your work by running give:

give dp1092 lab02_bcd bcd.c

Exercise — individual:
Convert an 8 digit Packed BCD Value to an Integer

Download packed_bcd.c, or copy it to your CSE account using the following command:

cp -n /import/reed/A/dp1092/public_html/24T3/activities/packed_bcd/files.cp/packed_bcd.c packed_bcd.c

Your task is to add code to this function in packed_bcd.c:

// given a packed BCD encoded value between 0 .. 99999999
// return the corresponding integer
uint32_t packed_bcd(uint32_t packed_bcd_value) {

    // PUT YOUR CODE HERE

    return 0;
}

Add code to the function packed_bcd so that, given an eight-digit packed binary-coded decimal value, it returns the corresponding integer.

In packed binary-coded decimal format, each 4 bits holds 1 decimal value (0 to 9), so each byte contains 2 decimal digits. For example:

./packed_bcd 0x42         # note: 0x42 == 66 decimal
42
./packed_bcd 0x9999       # note: 0x9999 == 39321 decimal
9999
./packed_bcd 0x42424242   # note: 0x42424242 == 1111638594 decimal
42424242

When you think your program is working, you can use autotest to run some simple automated tests:

1092 autotest packed_bcd

When you are finished working on this exercise, you must submit your work by running give:

give dp1092 lab02_packed_bcd packed_bcd.c

Challenge Exercise — individual:
Add 2 Arbitrary Length BCD Values

Download bcd_add.c, or copy it to your CSE account using the following command:

cp -n /import/reed/A/dp1092/public_html/24T3/activities/bcd_add/files.cp/bcd_add.c bcd_add.c

Your task is to add code to this function in bcd_add.c:

big_bcd_t *bcd_add(big_bcd_t *x, big_bcd_t *y) {

    // PUT YOUR CODE HERE

}

Add code to the function bcd_add so that, given 2 arbitrary length binary-coded decimal numbers, it returns their sum. For example:

./bcd_add 123456789123456789 123456789123456789
246913578246913578
./bcd_add 999999999999999999 1
1000000000000000000
./bcd_add 777777777777777777777777777777777777 888888888888888888888888888888888888
1666666666666666666666666666666666665
./bcd_add 987654321987654321987654321 98765987659876598765
987654420753641981864253086

Use realloc(3) if you need to grow an array.

You will be working with pointers to structs with a field that is a pointer to an array. It would be wise to revise pointers, structs, typedefs, arrays, and dynamic memory allocation. The relevant videos in this playlist may help.

You can use Python (for example) to check what the sum of any two integers is:

python3 -i
Python 3.7.3 (default, Apr  3 2019, 05:39:12)
[GCC 8.3.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
123456789123456789 + 123456789123456789
246913578246913578

When you think your program is working, you can use autotest to run some simple automated tests:

1092 autotest bcd_add

When you are finished working on this exercise, you must submit your work by running give:

give dp1092 lab02_bcd_add bcd_add.c

Challenge Exercise — individual:
Subtract, Multiply and Divide 2 Arbitrary Length BCD Values

Download bcd_arithmetic.c, or copy it to your CSE account using the following command:

cp -n /import/reed/A/dp1092/public_html/24T3/activities/bcd_arithmetic/files.cp/bcd_arithmetic.c bcd_arithmetic.c

Add code to the functions bcd_add, bcd_subtract, bcd_multiply, and bcd_divide so that, given two arbitrary-length binary-coded decimal (BCD) numbers, they return the result of the corresponding arithmetic operation. For example:

./bcd_arithmetic 1123456789123456789 - 1123456789123456788
1
./bcd_arithmetic 123456789123456789 '*' 123456789123456789
15241578780673678515622620750190521
./bcd_arithmetic 15241578780673678515622620750190521 / 123456789123456789
123456789123456789
./bcd_arithmetic 123456789 '*' 987654321 +  987654321 / 1234
121932631113435637
./bcd_arithmetic 14 / 5
2

The code you are given already handles '+', '-', '*', and '/', and calls bcd_add, bcd_subtract, bcd_multiply, and bcd_divide respectively. You don't need to understand this code to do the exercises, though you will find it interesting to read. You only need to implement the four arithmetic functions.

Use realloc(3) to grow an array.

You could use Python (for example) to check what the value of an expression is, (though you don't need to quote the *, and you need to use // to get integer division):

python3 -i
Python 3.7.3 (default, Apr  3 2019, 05:39:12)
[GCC 8.3.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
123456789 * 987654321 + 987654321 // 1234
121932631113435637

When you think your program is working, you can use autotest to run some simple automated tests:

1092 autotest bcd_arithmetic

When you are finished working on this exercise, you must submit your work by running give:

give dp1092 lab02_bcd_arithmetic bcd_arithmetic.c

Submission

When you are finished each exercises make sure you submit your work by running give.

You can run give multiple times. Only your last submission will be marked.

Don't submit any exercises you haven't attempted.

If you are working at home, you may find it more convenient to upload your work via give's web interface.

Remember you have until Week 3 Tuesday 09:00:00 to submit your work.

You cannot obtain marks by e-mailing your code to tutors or lecturers.

You check the files you have submitted here.

Automarking will be run by the lecturer several days after the submission deadline, using test cases different to those autotest runs for you. (Hint: do your own testing as well as running autotest.)

After automarking is run by the lecturer you can view your results here. The resulting mark will also be available via give's web interface.

Lab Marks

When all components of a lab are automarked you should be able to view the the marks via give's web interface or by running this command on a CSE machine:

1092 classrun -sturec