<WRAP centeralign round box>
<WRAP><color red><fs 200%>Corning Community College</fs></color></WRAP>
<WRAP><fs 150%>CSCS2330 Discrete Structures</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, in a specified range of numbers.

=====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 command-line, computes the number of factor pairs of a given number or range of numbers, displaying to STDOUT all the numbers in that range that qualify as a nary number of the specification.

=====Program run-time usage=====
Your program should accept command-line arguments as follows:

<cli>
$ ./cnv0 NARY START END
</cli>

All are mandatory. If any are lacking or incorrect, display an error and exit with a non-zero value.

=====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**
  * process the arguments, check to make sure the numbers provided are positive numbers greater than or equal to 1 or 2 (depending); if in violation, display an error (to STDERR) and exit with a non-zero value.
    * the nary value must be a value greater than or equal to 1
    * the starting and ending values must be greater than or equal to 2
  * proceed to evaluate the appropriate number range, determining whether or not it is an nary number as specified.
    * if it is, display the value to STDOUT in space-separated form (see execution section below for message)
    * if it is not, do not display anything related to that value (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/discrete/cnv0$ ./cnv0 2 3 12
4 6 8 9 10
lab46:~/src/discrete/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/discrete/cnv0$ gcc -Wall --std=gnu99 -o cnv0 cnv0.c
lab46:~/src/discrete/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 discrete cnv0 cnv0.c
Submitting discrete 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