Lab46 Wiki

This page is read only. You can view the source, but not change it. Ask your administrator if you think this is wrong.
<WRAP centeralign round box>
<WRAP><color red><fs 200%>Corning Community College</fs></color></WRAP>
<WRAP><fs 150%>ENGR1050 C for Engineers</fs></WRAP>
</WRAP>

======Project: COMPUTATION - CALCULATING N-ARY VALUES (cnv0)======

=====Objective=====
To create a program that can calculate and determine the number of factor pairs of a given number, starting with values composed of exactly 2 sets of factor pairs.

=====Reading=====
In "The C Book", please read through Chapter 6.

=====Background=====
In mathematics, you have likely encountered the notion of "prime" numbers, those values which are divisible only by 1 and the number itself.

Expanding our view on the situation, when considering factors of a number, we have the presence of a "factor pair"; ie a pair of two values that are evenly divisible into that number.

For 17, a prime number, we have just ONE factor pair: 1 and 17:

  * 17 % 1 == 0
  * 17 % 17 == 0

All other values (2-16) when we divide them into 17 results in a non-zero value for the remainder.

In this way, prime, or primary, numbers, have exactly ONE factor pair. To further simplify matters, we can call it an N-ary(1) or nary(1) value. Where the number indicates the number of factor pairs.

A secondary, or nary(2) number, on the other hand, has exactly TWO sets of factor pairs.

Take the number 6, for instance:

  * factor pair of 1 and 6
  * factor pair of 2 and 3

Where 17 was a primary number, 6 is a secondary number.

====Determining factor pairs====
We are going to be exploring a basic, brute force, method of determining factors for a number, and that is the "trial by division" method.

Here, we successively divide a number by potential factors, to see if the factor evenly divides into the number. For convenience, we will assume the 1 and number factor pair, because EVERY number is evenly divisible by 1 and itself.

So, the number 5:

  * 5 % 2 == 1
  * 5 % 3 == 2
  * 5 % 4 == 1

No other evenly divisible factors were found in the range 2-(N-1), therefore we are only left with the factor pair of 1 and N, making 5 an nary(1) value.

The number 14:

  * 14 % 2 == 0   another factor!
  * 14 % 3 == 2
  * 14 % 4 == 2
  * 14 % 5 == 4
  * 14 % 6 == 2
  * 14 % 7 == 0   another factor!
  * 14 % 8 == 6
  * 14 % 9 == 5
  * 14 % 10 == 4
  * 14 % 11 == 3
  * 14 % 12 == 2
  * 14 % 13 == 1

Because factor pairs ALWAYS come in a set of 2, we have the factor pairs of 1 and 14, along with 2 and 7.

How about 12:

  * 12 % 2 == 0
  * 12 % 3 == 0
  * 12 % 4 == 0
  * 12 % 5 == 2
  * 12 % 6 == 0
  * 12 % 7 == 5
  * 12 % 8 == 4
  * 12 % 9 == 3
  * 12 % 10 == 2
  * 12 % 11 == 1

There are 4 additional factors discovered here, giving us a total of 6 factors, or three factor pairs:

  * 1, 12
  * 2, 6
  * 3, 4

Notice also how the factors are nested: 1 and 12 are the outermost, 2 and 6 are encapsulated within that, and inside there, 3 and 4.

Because there are 3 factor pairs, 12 would be considered an nary(3) value (or a tertiary number).
=====Program=====
It is your task to write a program that, upon accepting various pieces of input from the user, computes the number of factor pairs of a given number, displaying its eligibility as a secondary number.

=====Specifications=====
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 number (range appropriate of an unsigned long int)
    * properly store this in a variable of type **unsigned long int**
  * immediately after the input, check to make sure the input number is a positive number greater than or equal to 2; if in violation, display an error (to STDERR) and exit with a non-zero value.
  * proceed to evaluate the input number, determining whether or not it is a secondary (nary(2)) number.
    * if it is, display to STDOUT that it is a secondary number (see execution section below for message)
    * if it is not, display to STDOUT that it is not a secondary number (again, see execution section below)
  * 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.

=====Execution=====

====Secondary number output====
<cli>
lab46:~/src/c4eng/cnv0$ ./cnv0
Enter a number: 6
6 is a secondary number
lab46:~/src/c4eng/cnv0$ 
</cli>

====Non-secondary number output====
<cli>
lab46:~/src/c4eng/cnv0$ ./cnv0
Enter a number: 7
7 is NOT a secondary number
</cli>

====Additional outputs====
<cli>
lab46:~/src/c4eng/cnv0$ ./cnv0
Enter a number: 8
8 is a secondary number
lab46:~/src/c4eng/cnv0$ ./cnv0
Enter a number: 16
16 is NOT a secondary number
lab46:~/src/c4eng/cnv0$ ./cnv0
Enter a number: 21
21 is a secondary number
lab46:~/src/c4eng/cnv0$ 
</cli>

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

=====Compiling=====
As we have been doing all along, use the following options to gcc when compiling:

<cli>
lab46:~/src/c4eng/cnv0$ gcc -Wall --std=gnu99 -o cnv0 cnv0.c
lab46:~/src/c4eng/cnv0$ 
</cli>

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

<cli>
lab46:~/src/c4eng/cnv0$ /var/public/fall2019/c4eng/cnv0/ref_cnv0
Enter a number: 6
6 is a secondary number
lab46:~/src/c4eng/cnv0$ 
</cli>
=====Verification=====
In addition, I have also placed a **cnv0verify** script in that same subdirectory, which will test your program against a range of values, to determine overall correctness.

<cli>
lab46:~/src/c4eng/cnv0$ /var/public/fall2019/c4eng/cnv0/cnv0verify
[  1] you have: err, should be: err    [  2] you have:  no, should be:  no
[  3] you have:  no, should be:  no    [  4] you have: yes, should be: yes
[  5] you have:  no, should be:  no    [  6] you have: yes, should be: yes
[  7] you have:  no, should be:  no    [  8] you have: yes, should be: yes
[  9] you have: yes, should be: yes    [ 10] you have: yes, should be: yes
[ 11] you have:  no, should be:  no    [ 12] you have:  no, should be:  no
[ 13] you have:  no, should be:  no    [ 14] you have: yes, should be: yes
[ 15] you have: yes, should be: yes    [ 16] you have:  no, should be:  no
[ 17] you have:  no, should be:  no    [ 18] you have:  no, should be:  no
[ 19] you have:  no, should be:  no    [ 20] you have:  no, should be:  no
[ 21] you have: yes, should be: yes    [ 22] you have: yes, should be: yes
[ 23] you have:  no, should be:  no    [ 24] you have:  no, should be:  no
[ 25] you have: yes, should be: yes    [ 26] you have: yes, should be: yes
[ 27] you have: yes, should be: yes    [ 28] you have:  no, should be:  no
[ 29] you have:  no, should be:  no    [ 30] you have:  no, should be:  no
[ 31] you have:  no, should be:  no    [ 32] you have:  no, should be:  no
[ 33] you have: yes, should be: yes    [ 34] you have: yes, should be: yes
[ 35] you have: yes, should be: yes    [ 36] you have:  no, should be:  no
lab46:~/src/c4eng/cnv0$ 
</cli>
=====Submission=====
To successfully complete this project, the following criteria must be met:

  * Code must compile cleanly (no notes, warnings, nor 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:

<cli>
$ submit c4eng cnv0 cnv0.c
Submitting c4eng project "cnv0":
    -> cnv0.c(OK)

SUCCESSFULLY SUBMITTED
</cli>

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:

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

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