To create a program that can perform the task of a binary counter, in incrementing or decrementing fashion.

In “The C Book”, please read through Chapter 5.

It is your task to write a program that, upon accepting various pieces of input from the user, acts as a binary counter, displaying the resultant values in binary as from a starting to an ending progression.

Your program should:

• have valid, descriptive variable names of length no shorter than 4 symbols
• have consistent, well-defined indentation (no less than 4 spaces per level of indentation)
  • all code within the same scope aligned to its indentation level
• have proximal comments explaining your rationale and what is going on, throughout your code
• to STDERR, prompt for the starting value (0-1023)
  • properly store this in a variable of type signed short int
• to STDERR, prompt for the ending value (0-1023)
  • properly store this in a variable of type signed short int
• immediately after each input, check to make sure starting and ending values fall appropriately in the range stated; if in violation, display an error (to STDERR) and exit with a non-zero value.
• check the starting and ending values to determine if we are to perform an incrementation or a decrementation.
• in binary, display the starting number and all the others as well to STDOUT
• proceed to the next value in sequence, doing the same
• keep going until you have arrived at the ending value, displaying it as well
• using a single return statement at the conclusion of the code, return a 0 indicating successful operation

Some additional points of consideration:

• Note that the driving variables in your loops need to be at least of type short int, otherwise you may get a warning when you compile it.

lab46:~/src/c4eng/bcf0$ ./bcf0
Enter starting value (0-1023): 12
Enter ending value (0-1023): 28
0000001100
0000001101
0000001110
0000001111
0000010000
0000010001
0000010010
0000010011
0000010100
0000010101
0000010110
0000010111
0000011000
0000011001
0000011010
0000011011
0000011100
lab46:~/src/c4eng/bcf0$ 

The execution of the program is short and simple- obtain the input, do the processing, produce the output, and then terminate.

lab46:~/src/c4eng/bcf0$ ./bcf0
Enter starting value (0-1023): 17
Enter ending value (0-1023): 0
0000010001
0000010000
0000001111
0000001110
0000001101
0000001100
0000001011
0000001010
0000001001
0000001000
0000000111
0000000110
0000000101
0000000100
0000000011
0000000010
0000000001
0000000000
lab46:~/src/c4eng/bcf0$ 

lab46:~/src/c4eng/bcf0$ ./bcf0
Enter starting value (0-1023): 5543
ERROR: input value must be between 0-1023!
lab46:~/src/c4eng/bcf0$ 

lab46:~/src/c4eng/bcf0$ ./bcf0
Enter starting value (0-1023): 255
Enter ending value (0-1023): 7168
ERROR: input value must be between 0-1023!
lab46:~/src/c4eng/bcf0$ 

In the C4ENG public directory, inside the bcf0 subdirectory, will be a copy of my implementation (in executable form), which abides by the project specifications. Please compare its output against that of your implementation.

You might wonder how, when you are limited to non-binary input, how you can obtain the binary value so that you can work with it.

There are a couple ways to go about this:

Using the division method, you can convert a decimal value to binary, continually dividing the value (or its quotient) by the base, until the quotient is 0, then we use the remainders to give us the binary value:

• value / base
• value = 15
• value / 2
  • ie: 15 / 2
    • quotient: 7
    • remainder: 1
• value = quotient
• value / 2
  • ie: 7 / 2
    • quotient: 3
    • remainder: 1
• value = quotient
• value / 2
  • ie: 3 / 2
    • quotient: 1
    • remainder: 1
• value = quotient
• value / 2
  • ie: 1 / 2
    • quotient: 0
    • remainder: 1

The binary for 15 (decimal) is 1111 (binary)

Or:

• value = 11
• value / 2
  • quotient: 5
  • remainder: 1
• value = 5
• value / 2
  • quotient: 2
  • remainder: 1
• value = 2
• value / 2
  • quotient: 1
  • remainder: 0
• value = 1
• value / 2
  • quotient: 0
  • remainder: 1

The binary for 11 (decimal) is 1011 (binary).

NOTE that the order in which we get the remainders produces the number from right to left.

If one understands the weight values corresponding with the places of each bit in a binary number, we can simply do a bitwise AND and see if the result is greater than 0 or not:

So, if we wanted to see if the 2 to the 7th bit is active, we can simply:

    value  = number & 128;

We can then check of value is greater than 0; if it is, we've got a 1 in that position, if it isn't, we have a 0.

We can then repeat the operation for 64, 32, 16, etc. down to 1, to get each bit of our number.

NOTE that I have only taken us out to 8-bits. You may need to extend this to incorporate all the allowed values for this project.

Depending on the approach taken, you might have a need to store each of the bits for later display (for example, if you produce the bits in reverse order to the manner you wish to display them).

An array is like a regular variable, although instead of being able to store exactly one value, it acts as a container for MANY variables (all of the same type). We can then address each value through an offset (0 being the first slot, 1 being the second, etc.)

First, we need to identify a need; just as we needed to do with loops.

Let's say we had the following standalone variables:

    int num1  = 13;
    int num2  = 73;
    int num3  = 26;
    int num4  = 57;

We likely understand how to work with each of the four independent variables, but we can't exactly automate accessing them, such as through a loop.

This is where an array can come in handy. Witness, the equivalent storage of numbers using an array:

    int num[4]; // declare a 4 element integer array
    num[0]  = 13;
    num[1]  = 73;
    num[2]  = 26;
    num[3]  = 57;

What value does this offer us? Well, for one, we can automate the access of the array. Let's say we wanted to display the array contents (we have to do so one element at a time):

    int index  = 0;
    int max    = 4;
    for (index = 0; index < max; index = index + 1)
    {
        fprintf (stdout, "%d\n", num[index]);
    }

Perhaps an array can be of some use in this project?

To successfully complete this project, the following criteria must be met:

• Code must compile cleanly (no warnings or errors)
• Output must be correct, and match the form given in the sample output above.
• Code must be nicely and consistently indented
• Code must be well commented
• Do NOT double space your code. Group like statements together.
• Output Formatting (including spacing) of program must conform to the provided output (see above).
• Track/version the source code in a repository
• Submit a copy of your source code to me using the submit tool.

To submit this program to me using the submit tool, run the following command at your lab46 prompt:

$ submit c4eng bcf0 bcf0.c
Submitting c4eng project "bcf0":
    -> bcf0.c(OK)

SUCCESSFULLY SUBMITTED

You should get some sort of confirmation indicating successful submission if all went according to plan. If not, check for typos and or locational mismatches.

What I'll be looking for:

78:bcf0:final tally of results (78/78)
*:bcf0:proper error checking and status reporting performed [13/13]
*:bcf0:correct variable types and name lengths used [13/13]
*:bcf0:proper output formatting per specifications [13/13]
*:bcf0:runtime tests of submitted program succeed [13/13]
*:bcf0:no negative compiler messages for program [13/13]
*:bcf0:code is pushed to lab46 repository [13/13]

Additionally:

• Solutions not abiding by spirit of project will be subject to a 25% overall deduction
• Solutions not utilizing descriptive why and how comments will be subject to a 25% overall deduction
• Solutions not utilizing indentation to promote scope and clarity will be subject to a 25% overall deduction
• Solutions not organized and easy to read are subject to a 25% overall deduction