Differences

This shows you the differences between two versions of the page.

--- haas:fall2017:cprog:projects:pnc1 [2017/03/01 18:43] – external edit 127.0.0.1
+++ haas:fall2017:cprog:projects:pnc1 [2017/10/15 21:27] (current) – [Full Verification Compliance] wedge
@@ Line 4: / Line 4: @@
 </WRAP>
-~~TOC~~
+======Project: ALGORITHMS - PRIME NUMBER CALCULATION (pnc1)======
-======Project: OPTIMIZING ALGORITHMS - PRIME NUMBER CALCULATION (pnc1)======
+=====Errata=====
+With any increasingly complex piece of code or environment, we must find effective means of organizing various processes or communications. This "Errata" section and related updates are one such instance of that; intended as a means of disseminating information on changes to the project, you can be informed what modifications have taken place, along with any unique actions you need to take to compensate.
-=====Objective=====
+Any typos, bugs, or other updates/changes to the project will be documented here.
-To apply your skills in algorithmic optimization through the implementation of improved prime number calculating programs.
-=====Algorithmic Complexity=====
+====Revision List====
-A concept in Computer Science curriculum is the notion of computational/algorithmic complexity.
-Basically, a solution to a problem exists on a spectrum of efficiency (typically constrained by time vs. space): if optimizing for time, the code size tends to grow.
+  * revision #: <description> (DATESTRING)
-Additionally, if optimizing for time (specifically to reduce the amount of time taken), strategic approaches are taken to reduce unnecessary or redundant operations (yet still achieving the desired end results).
+Some changes may involve updates being made available to the project, in which case you'll be prompted with such notification and can run the available updating commands to synchronize your copy of the project with the changes.
-This project will endeavor to introduce you to the notion that the algorithms and constructs you use in coding your solution can and do make a difference to the overall runtime of your code.
+=====Objective=====
+To apply your skills in the implementation of prime number calculating algorithms.
-=====Optimizing the prime number calculation=====
+=====Background=====
-We should be fairly familiar with the process of computing primes by now, which is an essential beginning step to accomplish before pursuing optimization. Following will be some optimizations I'd like you to implement (as separate programs) so we can analyze the differences in approaches, and how they influence runtimes.
+In mathematics, a **prime** number is a value that is only evenly divisible by 1 and itself; it has just that one pair of factors, no others. Numbers that have divisibility/factors are classified as **composite** numbers.
-====odds (primeodds)====
+The number **6** is a **composite** number, as in addition to 1 and 6, it also has the factors of 2 and 3.
-Some optimizations can be the result of sheer common sense observations. For instance, with the exception of 2, all primes are odd numbers.
-So does it make sense to check an even number for primality? No, it doesn't.
+The number **17**, however, is a **prime** number, as no numbers other than 1 and 17 can be evenly divided into it.
-And can we predict even numbers? Yes, we can: they occur every other number.
+=====Calculating the primality of a number=====
+As of yet, there is no quick and direct way of determining the primality of a given number. Instead, we must perform a series of tests to determine if it fails primality (typically by proving it is composite).
-Therefore, we can start our number checking at 3, and skip 2 values each time (3, 5, 7, 9, 11, etc.).
+This process incurs a considerable amount of processing overhead on the task, so much so that increasingly large values take ever-expanding amounts of time. Often, approaches to prime number calculation involve various algorithms, which offer various benefits (less time) and drawback (more complex code).
-To make our output correct, we would simply display the "2" outright. We know it is prime, and will make that assumption with this program.
+Your task for this project is to implement a prime number program using the straightforward, unoptimized brute-force algorithm, which determines the primality of a number in a "trial by division" approach.
-This program should be an optimization based on your **primebruteopt** program from pnc0.
+=====Main algorithm: brute force (primereg)=====
+The brute force approach is the simplest to implement (although at some cost).
-====square root (primesqrt)====
+As we will be looking to do some time/performance analysis and comparisons, it is often good to have a baseline. This program will be it.
-An optimization to the computation of prime numbers is the square root trick. Basically, if we've processed numbers up to the square root of the number we're testing, and none have proven to be evenly divisible, we can also assume primality and bail out.
-The C library has a **sqrt()** function available through including the **math.h** header file, and linking against the math library at compile time (add **-lm** to your gcc line).
+To perform the process of computing the primality of a number, we simply attempt to evenly divide all the values between 2 and one less than the number in question. If any one of them divides evenly, the number is **NOT** prime, but instead composite.
-To use **sqrt()**, we pass in the value we wish to obtain the square root of, and assign the result to an **int**:
+Checking the **remainder** of a division indicates whether or not a division was clean (having 0 remainder indicates such a state).
-<code c>
+For example, the number 11:
-int x = 25;
-int y = 0;
-y = sqrt(x);
+<code>
+% 2 = 1 (2 is not a factor of 11)
-// y should be 5 as a result
+% 3 = 2 (3 is not a factor of 11)
+% 4 = 3 (4 is not a factor of 11)
+% 5 = 1 (5 is not a factor of 11)
+% 6 = 5 (6 is not a factor of 11)
+% 7 = 4 (7 is not a factor of 11)
+% 8 = 3 (8 is not a factor of 11)
+% 9 = 2 (9 is not a factor of 11)
+% 10 = 1 (10 is not a factor of 11)
 </code>
-For instance, the number 37 (using the square root optimization), we find the square root (whole number) of 37 is 6, so we only need to check 2-6:
+Because none of the values 2-10 evenly divided into 11, we can say it passed the test: **11 is a prime number**
+On the other hand, take 119:
 <code>
- % 2 = 1 (2 is not a factor of 37)
+ % 2 = 1 (2 is not a factor of 119)
- % 3 = 1 (3 is not a factor of 37)
+ % 3 = 2 (3 is not a factor of 119)
- % 4 = 1 (4 is not a factor of 37)
+ % 4 = 3 (4 is not a factor of 119)
- % 5 = 2 (5 is not a factor of 37)
+ % 5 = 4 (5 is not a factor of 119)
- % 6 = 1 (6 is not a factor of 37)
+ % 6 = 5 (6 is not a factor of 119)
+% 7 = 0 (7 is a factor of 119)
+% 8 = 7
+% 9 = 2
+% 10 = 9
+% 11 = 9
+% 12 = 11
+% 13 = 2
+...
 </code>
-Because none of these values evenly divides, we can give 37 a pass: **it is a prime**
+Because, during our range of testing every value from 2-118, we find that 7 evenly divides into 119, it failed the test: 119 is **not** prime, but is instead a composite number.
-This will dramatically improve the runtime, and offers a nice comparison against our brute force baseline.
+Please NOTE: Even once a number is identified as composite, your **primereg** MUST **CONTINUE** evaluating the remainder of the values (up to 119-1, or 118). It might seem pointless (and it is for a production program), but I want you to see the performance implications this creates.
-NOTE: You will be reverting to checking all numbers (both even and odd) with this program.
+====algorithm====
+Some things to keep in mind on your implementation:
-This program should be an optimization based on your **primebruteopt** program from pnc0.
+  * you will want to use loops (no less than 2, no more than 2) for this program.
+    * a nested loop makes the most sense:
+      * an outer loop that drives the progression of each sequential number to be tested
+      * an inner loop that tests that current number to see if it has any factors
+  * you know the starting value and the terminating condition, so you have a clear starting and ending point to work with.
+  * I do **NOT** want to see ambiguous, one-letter variables used in your implementation(s). Please use //meaningful// variable names.
+    * Some good examples of variable names would be:
+      * **number**: the number being tested
+      * **factor**: the value being divided into number to test for primality
+      * **step**: the rate by which some variable is changing
+      * **qty**: the count of the current tally of primes
+      * **max**: the maximum count we seek
+      * **start**: a value we are starting at
+      * **lower**: a lower bound
+      * **upper**: an upper bound
+      * see how much more readable and meaningful these are, especially as compared to **a**, **i**, **n**, **x**? You may even find it helps with debugging and understanding your code better.
+  * let the loops drive the overall process. Identify prime/composite status separate from loop terminating conditions.
+    * and remember, the baseline brute force algorithm (**primereg**) may well identify a value as composite, but won't terminate the loop.
+  * your timing should start before the loop (just AFTER argument processing), and terminate immediately following the terminating output newline outside the loops.
-====sqrt() odds (primesqrtodds)====
+=====prime algorithm implementation=====
-In the previous program we used **sqrt()** against all the values, even or odd.
+For simplicity, I have encoded important implementation information into the file name (and therefore resulting executable/binary) that will correspond to the indicated algorithm plus any optimizations.
-This program will eliminate the even values, checking only the odds.
+To break it down, all prime programs will be of the form:
+  * primeALG[O...]
+    * where each and every program starts with "prime"
+    * is immediately followed by a 3-letter (lowercase) abbreviation of the algorithm to be implemented (**reg**, for instance)
+    * and then is followed by 0 or more layered attributes describing the particular optimization that is applied (again, if any: **zero** or more).
-This program should be an optimization of your **primesqrt** program.
+The optimizations we will be implementing in this project (and their naming values) include:
+  * **break on composite (b)** - once a tested number is proven composite, there is no need to continue processing: break out of the factor loop and proceed to the next number
+  * **mapping factors of 6 (m)** - it turns out that, aside from the initial primes of **2** and **3**, that **all** prime numbers fall to a +1 or -1 off a factor of six (there is an algorithm for this: **6a+/-1**). This optimization will utilize this property, only testing numbers +/-1 off of factors of 6 (how might this impact overall processing?)
+  * **odds-only checking (o)** - aside from **2**, **all** other prime numbers are odd. Therefore, there is zero need to perform a composite check on an even number, allowing us to focus exclusively on odd values (luckily, they seem to occur in a predictable pattern).
+  * **sqrt() trick (s)** - mathematically it has been shown that if a number has any evenly divisible factors, at least one half of that factor pair will occur by the square root point of the number being tested.
+  * **sqrt()-less square root approximation (a)** - **sqrt()**, a function in the math library, does an industrial strength square root calculation. We don't need that, merely a whole integer value corresponding to the approximate square root. Here we will implement our own logic to approximate square root, hopefully with a considerable performance impact.
-====sqrt()-less square root (primesqrtopt)====
+Unless specified in the encoded name, your algorithm should only implement the algorithm and optimization(s) specified.
+That is, if your program to implement is **primerego**, that means you are ONLY to implement the brute force algorithm and odds-only checking. **NO** break on composite, **NO** sqrt() trick, etc. We are establishing separate data points for analytical comparison.
+Some of these optimizations can co-exist easily (break + map, odd + sqrt()), others are partially compatible (map + odd can coexist in a certain form), while others are mutually exclusive (sqrt() and approximated square root conflict). So there are definitely a few combinations that are possible using this scheme.
+Here are the variants you'll be implementing for this project:
+====break on composite (primeregb)====
+This optimization to primereg will make but one algorithmic change, and that takes place at the moment of identifying a number as composite. So, if we had our 119 example above, and discovered that 7 was a factor:
+There is no further need to check the remaining values, as once we have proven the non-primality of a number, the state is set: it is composite. So be sure to use a **break** statement to terminate the computation loop (how does this impact overall performance???).
+Make no other optimizations- this first project is to set up some important base line values that we can use for algorithmic comparison later on.
+====mapping factors of 6 (primeregm)====
+This optimization will check only the numbers that fall on either side of a factor of 6 for primality.
+NOTE: If applicable, just display the initial "2" and "3" as hardcoded values.
+====odds-only checking (primerego)====
+This optimization will check only the odd numbers for primality, skipping the evens entirely.
+NOTE: If applicable, just display the initial "2" as a hardcoded value.
+====sqrt() trick (primeregs)====
+This optimization employs the square root trick utilizing the C library's **sqrt()** function.
+====sqrt()-less square root approximation (primerega)====
+This optimization employs the approximated square root trick (**NOT** utilizing an existing square root function, but using simpler logic you implement to approximate the square root point).
+===Further explanation===
 An optimization to the previous process, which used **sqrt()**, this variation will do the exact same thing, but without using the **sqrt()** function. It will approximate the square root.
@@ Line 101: / Line 175: @@
 </cli>
-Square root of 81 is 9, but so is the square root of 82, 83, 84... etc. up until we hit 100.
+Or, if perhaps we instead order by square root value:
-If we were checking 87 to be prime, we'd only have to check up to 9.
+<cli>
+lab46:~$ oldsqrt=$(echo "sqrt(2)" | bc -q); for ((i=2; i<49; i++)); do newsqrt=$(echo "sqrt($i)" | bc -q); if [ "${newsqrt}" -ne "${oldsqrt}" ]; then echo; fi; printf "[%3d] %2d " "${i}" "${newsqrt}"; oldsqrt="${newsqrt}"; done; echo
+[  2]  1 [  3]  1
+[  4]  2 [  5]  2 [  6]  2 [  7]  2 [  8]  2
+[  9]  3 [ 10]  3 [ 11]  3 [ 12]  3 [ 13]  3 [ 14]  3 [ 15]  3
+[ 16]  4 [ 17]  4 [ 18]  4 [ 19]  4 [ 20]  4 [ 21]  4 [ 22]  4 [ 23]  4 [ 24]  4
+[ 25]  5 [ 26]  5 [ 27]  5 [ 28]  5 [ 29]  5 [ 30]  5 [ 31]  5 [ 32]  5 [ 33]  5 [ 34]  5 [ 35]  5
+[ 36]  6 [ 37]  6 [ 38]  6 [ 39]  6 [ 40]  6 [ 41]  6 [ 42]  6 [ 43]  6 [ 44]  6 [ 45]  6 [ 46]  6 [ 47]  6 [ 48]  6
+</cli>
+We see that the square root of 36 is 6, but so is the square root of 37, 38, 39... etc. up until we hit 49 (where the whole number square root increments to 7).
+Therefore, if we were checking 42 to be prime, we'd only have to check up to 6.
 We don't need a **sqrt()** function to tell us this, we can determine the approximate square root point ourselves- by squaring the current factor being tested, and so long as it hasn't exceeded the value we're checking, we know to continue.
@@ Line 111: / Line 197: @@
   * approximation can be powerful
   * approximation can result in a simpler algorithm, improving runtime
-    * **sqrt()** is more complex than you may be aware, not to mention it is in a function. By avoiding that function call, we eliminate some overhead, and that can make a big difference in runtime performance.
+    * **sqrt()** is more complex than you may be aware, not to mention it is in a function. By avoiding that function call, we eliminate some overhead, and that can make a difference in runtime performance.
-NOTE: Again, for comparison sake, check ALL numbers (even and odd) for this variant.
+Depending on how you implement this and the original sqrt() algorithms, this version may have a noticeable performance difference. If, on the other hand, you were really optimal in both implementations, the performance difference may be narrower (if negligible).
+=====Programs=====
+It is your task to write the following prime number variants:
-This program should be an optimization of your **primesqrt** program.
+  * **primeregb.c**: tests specifically the break optimization
+  * **primeregm.c**: tests specifically the map traversal
+  * **primerego.c**: tests specifically the odd traversal
+  * **primeregs.c**: tests specifically the square root trick (using sqrt())
+  * **primerega.c**: tests specifically the square root trick by approximating square root
-====sqrt()-less odds (primesqrtoptodds)====
-And, to round out our analysis, enhance the optimized sqrt variant to only check odd values.
-This program should be an optimization of your **primesqrtopt** program.
+====Program Specifications====
+Your program should:
+  * obtain 2-4 parameters from the command-line (see **command-line arguments** section below).
+    * check to make sure the user indeed supplied enough parameters, and exit with an error message if not.
+    * argv[1]: maximum quantity of primes to calculate (your program should run until it discovers **that** many primes).
+      * this value should be an integer value, greater than or equal to 0.
+        * if argv[1] is 0, disable the quantity check, and rely on provided lower and upper bounds (up to argv[4] would be required in this case).
+    * argv[2]: reserved for future compatibility; for now, require and expect it to be **1**.
+    * argv[3]: **conditionally optional** lower bound (starting value). Most of the time, this will probably be **2**, but should be a positive integer greater than or equal to 2. This defines where your program will start its prime quantity check from.
+      * if omitted, assume a lower bound of **2**.
+      * if you desired to specify an upper bound (argv[4]), you obviously MUST provide the lower bound argument under this scheme.
+    * argv[4]: **conditionally optional** upper bound (ending value). If provided, this is the ending value you'd like to check to.
+      * If doing a quantity run (argv[1] is NOT 0), this value isn't necessary.
+      * If doing a quantity run AND you specify an upper bound, whichever condition is achieved first dictates program termination. That is, upper bound could override quantity (if it is achieved before quantity), and quantity can override the upper bound (if it is achieved before reaching the specified upper bound).
+    * for each argument: you should do a basic check to ensure the user complied with this specification, and exit with a unique error message (displayed to STDERR) otherwise:
+      * for insufficient quantity of arguments, display: **PROGRAM_NAME: insufficient number of arguments!**
+      * for invalid argv[1], display: **PROGRAM_NAME: invalid quantity!**
+      * for invalid argv[2], display: **PROGRAM_NAME: invalid value!**
+      * for invalid argv[3], display: **PROGRAM_NAME: invalid lower bound!**
+        * if argv[3] is not needed, ignore (no error displayed not forced exit, as it is acceptable defined behavior).
+      * for invalid argv[4], display: **PROGRAM_NAME: invalid upper bound!**
+        * if argv[4] is not needed, ignore (no error displayed nor forced exit, as it is acceptable defined behavior).
+      * In these error messages, **PROGRAM_NAME** is the name of the program being run; this can be accessed as a string stored in **argv[0]**.
+  * implement ONLY the algorithm and optimization(s) specified in the program name. We are producing multiple data points for a broader performance comparison.
+  * please take note on differences in run-time, contemplating the impact the algorithm and optimization(s) have on performance (timing, specifically).
+  * immediately after argument processing: start your stopwatch (see **timing** section below).
+  * perform the correct algorithm and optimization(s) against the command-line input(s) given.
+    * each program is to have no fewer and no more than 2 loops in this prime processing section.
+  * display identified primes (space-separated) to **STDOUT**
+  * stop your stopwatch immediately following your prime processing loops (and terminating newline display to **STDOUT**). Calculate the time that has transpired (ending time minus starting time).
+  * output the processing run-time to **STDERR**
+  * your output **MUST** conform to the example output in the **execution** section below. This is also a test to see how well you can implement to specifications. Basically:
+    * as primes are being displayed, they are space-separated (first prime hugs the left margin), and when all said and done, a newline is issued (to **STDOUT**).
+    * the timing information will be displayed in accordance to code I will provide below (see the **timing** section).
-=====Program=====
+=====Grabit Integration=====
-It is your task to write some optimized prime number calculating programs:
+I have made some skeleton files and a custom **Makefile** available for this project. Since we've amassed considerable experience manually compiling our files, it is time to start experiencing some of the other development tools that can automate or facilitate various processes.
-  - **primeodds.c**: checking only odd values
+I have written a tool, known as **grabit**, which will let you obtain the files I have put together for this project. To "grab" it:
-  - **primesqrt.c**: for your **sqrt()**-based implementation
-  - **primesqrtodds.c**: **sqrt()**-based implementation only checking odds
-  - **primesqrtopt.c**: for your **sqrt()**-less square root approximated implementation
-  - **primesqrtoptodds.c**: **sqrt()**-less square root only checking odds
-Your program should:
+<cli>
-  * obtain 1 parameter from the command-line (see **command-line arguments** section below):
+lab46:~/src/cprog$ grabit cprog pnc1
-    * argv[1]: maximum value to calculate to (your program should run from (approximately) 2 through that number (inclusive of that number)
+make: Entering directory '/var/public/SEMESTER/cprog/pnc1'
-    * this value should be a positive integer value; you can make the assumption that the user will always do the right thing.
+Commencing copy process for SEMESTER cprog project pnc1:
-  * do the specified algorithmic optimizations
+ -> Creating project pnc1 directory tree           ... OK
-    * please take note in differences in run-time, contemplating the impact the various algorithms and approaches have on performance.
+ -> Copying pnc1 project files                     ... OK
-  * start your stopwatch (see **timing** section below):
+ -> Synchronizing pnc1 project revision level      ... OK
-  * perform the correct algorithm against the input
+ -> Establishing sane file permissions for pnc1    ... OK
-  * display (to STDOUT) the prime numbers found in the range
-  * output the processing run-time to STDERR
+*** Copy COMPLETE! You may now go to the '/home/USER/src/cprog/pnc1' directory ***
-  * your output **MUST** be conformant to the example output in the **execution** section below. This is also a test to see how well you can implement to specifications. Basically:
-    * as primes are being displayed, they are space-separated (first prime hugs the left margin), and when all said and done, a newline is issued.
+make: Leaving directory '/var/public/SEMESTER/cprog/pnc1'
-    * the timing information will be displayed in accordance to code I will provide (in the **timing** section).
+lab46:~/src/cprog$
+</cli>
+NOTE: You do NOT want to do this on a populated pnc1 project directory-- it will overwrite files.
+And, of course, your basic compile and clean-up operations via the Makefile.
+=====Makefile operations=====
+Makefiles provide a build automation system for our programs, instructing the computer on how to compile files, so we don't have to constantly type compiler command-lines ourselves. I've also integration some other useful, value-added features that will help you with overall administration of the project.
+Basic operation of the Makefile is invoked by running the command "**make**" by itself. The default action is to compile everything in the project directory.
+Additional options are available, and they are provided as an argument to the make command. You can see the available options by running "**make help**":
+<cli>
+lab46:~/src/cprog/pnc1$ make help
+*******************[ C/C++ Programming pnc1 Project ]*******************
+** make                     - build everything                        **
+** make showerrors          - display compiler warnings/errors        **
+**                                                                    **
+** make debug               - build everything with debug symbols     **
+** make checkqty            - runtime evaluation for qty              **
+** make checkrange          - runtime evaluation for range            **
+**                                                                    **
+** make verifyqty           - check implementation for qty validity   **
+** make verifyrange         - check implementation for range validity **
+** make verifyall           - verify project specifications           **
+**                                                                    **
+** make save                - create a backup archive                 **
+** make submit              - submit assignment (based on dirname)    **
+**                                                                    **
+** make update              - check for and apply updates             **
+** make reupdate            - re-apply last revision                  **
+** make reupdate-all        - re-apply all revisions                  **
+**                                                                    **
+** make clean               - clean; remove all objects/compiled code **
+** make help                - this information                        **
+************************************************************************
+lab46:~/src/cprog/pnc1$
+</cli>
+A description of some available commands include:
+  * **make**: compile everything
+    * any **warnings** or **errors** generated by the compiler will go into a file in the base directory of pnc1 in a file called **errors**; you can **cat** it to view the information.
+  * **make debug**: compile everything with debug support
+    * any **warnings** or **errors** generated by the compiler will be displayed to the screen as the programs compile.
+  * **make clean**: remove all binaries
+  * **make save**: make a backup of your current work
+  * **make submit**: archive and submit your project
+The various "check" options do a runtime performance grid, allowing you to compare timings between your implementations.
+The various "verify" options do more aggressive checks, helping to ensure your project falls within stated project specifications.
+Just another "nice thing" we deserve.
 =====Command-Line Arguments=====
-To automate our comparisons, we will be making use of command-line arguments in our programs. As we have yet to really get into arrays, I will provide you same code that you can use that will allow you to utilize them for the purposes of this project.
+To automate our comparisons, we will be making use of command-line arguments in our programs.
 ====header files====
@@ Line 164: / Line 338: @@
 int main(int argc, char **argv)
 </code>
+There are two very important variables involved here (the types are actually what are important, the names given to the variables are actually quite, variable; you may see other references refer to them as things like "ac" and "av"):
+  * int argc: the count (an integer) of tokens given on the command line (program name + arguments)
+  * <nowiki>char **argv</nowiki>: an array of strings (technically an array of an array of char) that contains "strings" of the various tokens provided on the command-line.
 The arguments are accessible via the argv array, in the order they were specified:
@@ Line 169: / Line 348: @@
   * argv[0]: program invocation (path + program name)
   * argv[1]: our maximum / upper bound
+  * argv[2]: reserved value, should still be provided and be a 1 for this project
+  * argv[3]: conditionally optional; represents lower bound
+  * argv[4]: conditionally optional; represents upper bound
+Additionally, let's not forget the **argc** variable, an integer, which contains a count of arguments (argc == argument count). If we provided argv[0] through argv[4], argc would contain a 5.
+===example===
+For example, if we were to execute the **primereg** program:
+<cli>
+lab46:~/src/cprog/pnc1$ ./primeregb 128 1 2 2048
+</cli>
+We'd have:
+  * <nowiki>argv[0]</nowiki>: "./primereg"
+  * <nowiki>argv[1]</nowiki>: "128" (note, NOT the scalar integer 128, but a string)
+  * <nowiki>argv[2]</nowiki>: "1"
+  * <nowiki>argv[3]</nowiki>: "2"
+  * <nowiki>argv[4]</nowiki>: "2048"
+and let's not forget:
+  * argc: 5   (there are 5 things, argv indexes 0, 1, 2, 3, and 4)
+With the conditionally optional arguments as part of the program spec, for a valid execution of the program, argc could be a value anywhere from 3 to 5.
 ====Simple argument checks====
-Although I'm not going to require extensive argument parsing or checking for this project, we should check to see if the minimal number of arguments has been provided:
+While there are a number of checks we should perform, one of the first should be a check to see if the minimal number of arguments has been provided:
 <code c>
-    if (argc < 2)  // if less than 2 arguments have been provided
+    if (argc < 3)  // if less than 3 arguments (program_name + quantity + argv[2] == 3) have been provided
     {
-        fprintf(stderr, "Not enough arguments!\n");
+        fprintf(stderr, "%s: insufficient number of arguments!\n", argv[0]);
         exit(1);
     }
 </code>
+Since argv[3] (lower bound) and argv[4] (upper bound) are conditionally optional, it wouldn't make sense to check for them in the overall count. But we can and do still want to stategically utilize **argc** to determine if an argv[3] or argv[4] is present.
 ====Grab and convert max====
-Finally, we need to put the argument representing the maximum value into a variable.
+Finally, we need to put the argument representing the maximum quantity into a variable.
 I'd recommend declaring a variable of type **int**.
@@ Line 189: / Line 396: @@
 <code c>
-    max  = atoi(argv[1]);
+    max  = atoi (argv[1]);
 </code>
@@ Line 238: / Line 445: @@
 ====Displaying the runtime====
-Once we having the starting and ending times, we can display this to STDERR. You'll want this line:
+Once we have the starting and ending times, we can display this to the **timing** file pointer. You'll want this line:
 <code c>
-    fprintf(stderr, "%10.6lf\n", time_end.tv_sec - time_start.tv_sec + ((time_end.tv_usec - time_start.tv_usec) / 1000000.0));
+fprintf(stderr, "%8.4lf\n",
+time_end.tv_sec-time_start.tv_sec+((time_end.tv_usec-time_start.tv_usec)/1000000.0));
 </code>
-For clarity sake, that format specifier is "%10.6lf", where the "lf" is "long float", that is **NOT** a number one but a lowercase letter 'ell'.
+For clarity sake, that format specifier is "%8.4lf", where the "lf" is "long float", that is **NOT** a number 'one' but a lowercase letter 'ell'.
 And with that, we can compute an approximate run-time of our programs. The timing won't necessarily be accurate down to that level of precision, but it will be informative enough for our purposes.
 =====Execution=====
-Your program output should be as follows (given the specified range):
+====specified quantity====
+Your program output should be as follows (given the specified quantity):
 <cli>
-lab46:~/src/cprog/pnc1$ ./primesqrt 90
+lab46:~/src/cprog/pnc1$ ./primeregm 24 1
 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89
-.000088
+.0001
 lab46:~/src/cprog/pnc1$
 </cli>
 The execution of the programs is short and simple- grab the parameters, do the processing, produce the output, and then terminate.
+====invalid lower bound====
+Here's an example that should generate an error upon running (based on project specifications):
+<cli>
+lab46:~/src/cprog/pnc1$ ./primerego 32 1 0
+./primereg: invalid lower bound
+lab46:~/src/cprog/pnc1$
+</cli>
+In this case, the program logic should have detected an invalid condition and bailed out before prime computations even began. No timing data is displayed, because exiting should occur even prior to that.
+====upper bound overriding quantity====
+As indicated above, there is potential interplay with an active quantity and upper bound values. Here is an example where upper bound overrides quantity, resulting in an early termination (ie upper bound is hit before quantity):
+<cli>
+lab46:~/src/cprog/pnc1$ ./primeregs 128 1 7 23
+11 13 17 19 23
+.0001
+lab46:~/src/cprog/pnc1$
+</cli>
+Also for fun, I set the lower bound to 7, so you'll see computation starts at 7 (vs. the usual 2).
 =====Check Results=====
-If you'd like to compare your implementations, I rigged up a script called **primerun** which you can run.
+If you'd like to compare your implementations, I rigged up a Makefile checking rule called "**make checkqty**" and "**make checkrange**" which you can run to get a nice side-by-side runtime comparisons of your implementations.
-In order to work, you **MUST** be in the directory where your **primesqrt**, **primesqrtopt** and **primemap** binaries reside, and must be named as such. You'll also want to copy in your **primebrute** and **primebruteopt** binaries to truly get the full picture.
+In order to work, you **MUST** be in the directory where your pnc1 binaries reside, and must be named as such (which occurs if you ran **make** to compile them).
-For instance (running on my implementations of the programs):
+====check qty====
+For instance (running on my implementation of the pnc1 programs):
 <cli>
-lab46:~/src/cprog/pnc1$ primerun
+lab46:~/src/cprog/pnc1$ make checkqty
-====================================================================================================
+=========================================================
-    range        brute     bruteopt         odds         sqrt     sqrtodds      sqrtopt  sqrtoptodds
+      qty     reg    regm    rego    regb    regs    rega
-====================================================================================================
+=========================================================
-     0.000179     0.000139     0.000124     0.000108     0.000085     0.000112     0.000078
+  0.0001  0.0001  0.0001  0.0001  0.0001  0.0001
-     0.000401     0.000161     0.000120     0.000149     0.000128     0.000119     0.000085
+  0.0003  0.0001  0.0001  0.0001  0.0001  0.0001
-     0.001535     0.000345     0.000213     0.000207     0.000179     0.000134     0.000134
+  0.0012  0.0004  0.0003  0.0002  0.0001  0.0001
-     0.005385     0.000919     0.000542     0.000428     0.000268     0.000184     0.000159
+  0.0057  0.0020  0.0014  0.0009  0.0003  0.0003
-     0.019076     0.002767     0.001481     0.000857     0.000517     0.000335     0.000302
+  0.0278  0.0098  0.0066  0.0038  0.0009  0.0009
-     0.070836     0.009331     0.004770     0.002034     0.001148     0.000708     0.000480
+  0.1348  0.0476  0.0318  0.0166  0.0025  0.0025
-     0.270955     0.032402     0.016253     0.004934     0.002525     0.001575     0.000950
+  0.6416  0.2317  0.1510  0.0727  0.0073  0.0073
-     1.059970     0.116575     0.058424     0.012190     0.006239     0.003676     0.002117
+  3.0281  1.0707  0.7096  0.3144  0.0218  0.0217
-     4.209891     0.424113     0.212701     0.030711     0.015568     0.008867     0.004950
+  ------  ------  3.2926  1.3627  0.0649  0.0649
-   ----------     1.626774     0.787444     0.078278     0.039605     0.022158     0.012015
+  ------  ------  ------  ------  0.1955  0.1954
-   ----------     7.769508     3.954632     0.211732     0.105749     0.066574     0.035054
+  ------  ------  ------  ------  0.5910  0.5905
-   ----------   ----------   ----------     0.553307     0.275414     0.175391     0.091195
+  ------  ------  ------  ------  1.7891  1.7864
-   ----------   ----------   ----------     1.440572     0.713855     0.444240     0.229179
+  ------  ------  ------  ------  ------  ------
-  1048576   ----------   ----------   ----------     3.743303     1.856485     1.137094     0.574455
+=========================================================
-  2097152   ----------   ----------   ----------   ----------     4.857408     2.923402     1.451850
+ verify:     OK      OK      OK      OK      OK      OK
-  4194304   ----------   ----------   ----------   ----------   ----------   ----------     3.708858
+=========================================================
-  8388608   ----------   ----------   ----------   ----------   ----------   ----------   ----------
-====================================================================================================
- verify:       OK           OK           OK           OK           OK           OK           OK
-====================================================================================================
 lab46:~/src/cprog/pnc1$
 </cli>
-For evaluation, each test is run 4 times, and the resulting time is averaged. During development, I have it set to only run each test once.
+====check range====
+Or check range runtimes:
+<cli>
+lab46:~/src/cprog/pnc1$ make checkrange
+=========================================================
+    range     reg    regm    rego    regb    regs    rega
+=========================================================
+  0.0001  0.0000  0.0000  0.0000  0.0001  0.0000
+  0.0001  0.0001  0.0000  0.0000  0.0000  0.0000
+  0.0001  0.0001  0.0001  0.0001  0.0001  0.0001
+  0.0002  0.0001  0.0001  0.0001  0.0001  0.0001
+  0.0006  0.0003  0.0002  0.0002  0.0001  0.0001
+  0.0023  0.0008  0.0006  0.0004  0.0002  0.0002
+  0.0088  0.0032  0.0021  0.0013  0.0004  0.0004
+  0.0344  0.0125  0.0082  0.0047  0.0010  0.0010
+  0.1358  0.0495  0.0322  0.0167  0.0025  0.0025
+  0.5402  0.1968  0.1270  0.0616  0.0065  0.0065
+  2.1530  0.7857  0.5050  0.2271  0.0170  0.0171
+  ------  3.1395  2.0088  0.8468  0.0454  0.0455
+  ------  ------  ------  3.1817  0.1230  0.1230
+  ------  ------  ------  ------  0.3359  0.3359
+  ------  ------  ------  ------  0.9245  0.9240
+  1048576  ------  ------  ------  ------  2.5601  2.5585
+  2097152  ------  ------  ------  ------  ------  ------
+=========================================================
+ verify:     OK      OK      OK      OK      OK      OK
+=========================================================
+lab46:~/src/cprog/pnc1$
+</cli>
-If the runtime of a particular prime variant exceeds an upper threshold (likely to be set at 2 seconds), it will be omitted from further tests, and a series of dashes will instead appear in the output.
+If the runtime of a particular prime variant exceeds an upper runtime threshold (likely to be set at 1 second), it will be omitted from further tests, and a series of dashes will instead appear in the output.
-If you don't feel like waiting, simply hit **CTRL-c** and the script will terminate.
+If you don't feel like waiting, simply hit **CTRL-c** (maybe a couple of times) and the script will terminate.
+====Verification====
 I also include a validation check- to ensure your prime programs are actually producing the correct list of prime numbers. If the check is successful, you will see "OK" displayed beneath in the appropriate column; if unsuccessful, you will see "MISMATCH".
+====Full Verification Compliance====
+There's also a more rigorous verification step you can take, which runs your programs through a series to tests to see if they conform to project specifications:
+<cli>
+lab46:~/src/cprog/pnc1$ make verifyall
+=========================================================
+              reg    regm    rego    regb    regs    rega
+=========================================================
+ qtynorm:    OK      OK      OK      OK      OK      OK
+ qtypart:    OK      OK      OK      OK      OK      OK
+ rngnorm:    OK      OK      OK      OK      OK      OK
+ rngpart:    OK      OK      OK      OK      OK      OK
+    coop:    OK      OK      OK      OK      OK      OK
+   coop2:    OK      OK      OK      OK      OK      OK
+   coop3:    OK      OK      OK      OK      OK      OK
+  noargs:    OK      OK      OK      OK      OK      OK
+ invargs:    OK      OK      OK      OK      OK      OK
+  invqty:    OK      OK      OK      OK      OK      OK
+ invnary:    OK      OK      OK      OK      OK      OK
+  invlow:    OK      OK      OK      OK      OK      OK
+ invhigh:    OK      OK      OK      OK      OK      OK
+=========================================================
+lab46:~/src/cprog/pnc1$
+</cli>
+===verifyall tests===
+The "**verifyall**" is an industrial grade verification; there are 13 specific tests performed, they are:
+  * **qtynorm**: a normal quantity run (2-max)
+    * **./primealg 2048 1 2 0**
+  * **qtypart**: an offset quantity run (24-max)
+    * **./primealg 2048 1 24 0**
+  * **rngnorm**: a normal range run (2-max)
+    * **./primealg 0 1 2 2048**
+  * **rngpart**: an offset range run (24-max)
+    * **./primealg 0 1 24 2048**
+  * **coop**: both qty and upper bounds set (q: 2048, ub: 8192)
+    * **./primealg 2048 1 2 8192**
+  * **coop2**: both qty and upper bounds set (q: 512, ub: 8192)
+    * **./primealg 512 1 2 8192**
+  * **coop3**: both qty and upper bounds set, offset start (24-max, q: 2048, ub: 8192)
+    * **./primealg 2048 1 24 8192**
+  * **noargs**:  no arguments provided on command line (invokes error message)
+    * **./primealg**
+  * **invargs**: insufficient number of arguments provided (invokes error)
+    * **./primealg 128**
+  * **invqty**: invalid value for quantity argument given (invokes error)
+    * **./primealg -2 1**
+  * **invnary**: invalid value given for n-ary (invokes error)
+    * **./primealg 128 2**
+  * **invlow**: invalid value given for lower bound (invokes error)
+    * **./primealg 128 1 1**
+  * **invhigh**: invalid value given for upper bound (invokes error)
+    * **./primealg 128 1 32 24**
+If you'd actually to see the output your program's output is being tested against, that can be found in the **/usr/local/etc** directory in the file **primeTEST**, where "TEST" is the name of the verify test mentioned above.
+For example, if you wanted to see the intended output of the **invnary** test, that would be found in:
+  * **/usr/local/etc/primeinvnary**
+You could easily run your program with the stated arguments for the test, then use **cat** to display the test results and do a visual comparison.
+====In general====
+Analyze the times you see... do they make sense, especially when comparing the algorithm used and the quantity being processed? These are related to some very important core Computer Science considerations we need to be increasingly mindful of as we design our programs and implement our solutions. Algorithmic complexity and algorithmic efficiency will be common themes in all we do.
 =====Submission=====
@@ Line 309: / Line 633: @@
   * Output must be correct, and match the form given in the sample output above.
   * Code must be nicely and consistently indented (you may use the **indent** tool)
-  * Code must utilize the algorithm(s) presented above.
+  * Code must utilize the algorithm(s) presented above:
-    * **primeodds.c**
+    * **primeregb.c** adds in the break on composite optimization
-    * **primesqrt.c**
+    * **primeregm.c** implements the map traversal
-    * **primesqrtodds.c**
+    * **primerego.c** implements odds-only checking
-    * **primesqrtopt.c**
+    * **primeregs.c** implements the sqrt() trick
-    * **primesqrtoptodds.c**
+    * **primerega.c** implements square root trick by approximating square root
   * Code must be commented
     * have a properly filled-out comment banner at the top
@@ Line 326: / Line 650: @@
 <cli>
-$ submit cprog pnc1 primeodds.c primesqrt.c primesqrtodds.c primesqrtopt.c primesqrtoptodds.c
+lab46:~/src/cprog/pnc1$ make submit
+removed ‘primeregb’
+removed ‘primeregm’
+removed ‘primerego’
+removed ‘primeregs’
+removed ‘primerega’
+removed ‘errors’
+Project backup process commencing
+Taking snapshot of current project (pnc1)      ... OK
+Compressing snapshot of pnc1 project archive   ... OK
+Setting secure permissions on pnc1 archive     ... OK
+Project backup process complete
 Submitting cprog project "pnc1":
-    -> primeodds.c(OK)
+    -> ../pnc1-20171025-17.tar.gz(OK)
-    -> primesqrt.c(OK)
-    -> primesqrtodds.c(OK)
-    -> primesqrtopt.c(OK)
-    -> primesqrtoptodds.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.
+You should get that final "SUCCESSFULLY SUBMITTED" with no error messages occurring. If not, check for typos and or locational mismatches.
-What I will be looking for:
+====Evaluation Criteria====
+Grand total points:
 <code>
-:pnc1:final tally of results (78/78)
+:pnc1:final tally of results (80/80)
-*:pnc1:submit all programs correctly named using submit tool [3/3]
-*:pnc1:primeodds.c no negative compiler messages [2/2]
-*:pnc1:primeodds.c implements only specified algorithm [4/4]
-*:pnc1:primeodds.c adequate indentation and comments [3/3]
-*:pnc1:primeodds.c output conforms to specifications [3/3]
-*:pnc1:primeodds.c primerun runtime tests succeed [3/3]
-*:pnc1:primesqrt.c no negative compiler messages [2/2]
-*:pnc1:primesqrt.c implements only specified algorithm [4/4]
-*:pnc1:primesqrt.c adequate indentation and comments [3/3]
-*:pnc1:primesqrt.c output conforms to specifications [3/3]
-*:pnc1:primesqrt.c primerun runtime tests succeed [3/3]
-*:pnc1:primesqrtodds.c no negative compiler messages [2/2]
-*:pnc1:primesqrtodds.c implements only specified algorithm [4/4]
-*:pnc1:primesqrtodds.c adequate indentation and comments [3/3]
-*:pnc1:primesqrtodds.c output conforms to specifications [3/3]
-*:pnc1:primesqrtodds.c primerun runtime tests succeed [3/3]
-*:pnc1:primesqrtopt.c no negative compiler messages [2/2]
-*:pnc1:primesqrtopt.c implements only specified algorithm [4/4]
-*:pnc1:primesqrtopt.c adequate indentation and comments [3/3]
-*:pnc1:primesqrtopt.c output conforms to specifications [3/3]
-*:pnc1:primesqrtopt.c primerun runtime tests succeed [3/3]
-*:pnc1:primesqrtoptodds.c no negative compiler messages [2/2]
-*:pnc1:primesqrtoptodds.c implements only specified algorithm [4/4]
-*:pnc1:primesqrtoptodds.c adequate indentation and comments [3/3]
-*:pnc1:primesqrtoptodds.c output conforms to specifications [3/3]
-*:pnc1:primesqrtoptodds.c primerun runtime tests succeed [3/3]
 </code>
+What I will be looking for (for each file):
+<code>
+*:pnc1:primeALGO.c compiles cleanly, no compiler messages [1/1]
+*:pnc1:primeALGO.c implements only specified algorithm [4/4]
+*:pnc1:primeALGO.c consistent indentation throughout code [1/1]
+*:pnc1:primeALGO.c relevant comments throughout code [1/1]
+*:pnc1:primeALGO.c code conforms to project specifications [2/2]
+*:pnc1:primeALGO.c runtime output conforms to specifications [1/1]
+*:pnc1:primeALGO.c make checkqty test times within reason [1/1]
+*:pnc1:primeALGO.c make checkrange test times within reason [1/1]
+*:pnc1:primeALGO.c make verifyall tests succeed [4/4]
+</code>
+As the optimizations improve upon others, some evaluations will be based upon differences between a baseline (in some cases, primereg) and the optimization.

Lab46 Wiki

User Tools

Site Tools

Differences

Page Tools