Differences

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

--- haas:fall2017:cprog:projects:pnc1 [2017/10/15 21:06] – [Submission] wedge
+++ haas:fall2017:cprog:projects:pnc1 [2017/10/15 21:27] (current) – [Full Verification Compliance] wedge
@@ Line 112: / Line 112: @@
     * 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).
+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.
 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 **primereg**, that means you are ONLY to implement the brute force algorithm, in all its unoptimized, inefficient glory. This is important for establishing separate data points for analytical comparison (with future projects).
+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.
+We know that a square root (especially a whole numbered square root), is when we have whole number factors that are squared. But in addition, only considering the whole number aspect of the square root, we start seeing series of values with the same whole square root value:
+<cli>
+lab46:~$ count=0; for ((i=2; i<152; i++)); do printf "[%3d] %2d " "${i}" `echo "sqrt($i)" | bc -q`; let count=count+1; if [ "${count}" -eq 10 ]; then echo; count=0; fi; 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 [ 49]  7 [ 50]  7 [ 51]  7
+[ 52]  7 [ 53]  7 [ 54]  7 [ 55]  7 [ 56]  7 [ 57]  7 [ 58]  7 [ 59]  7 [ 60]  7 [ 61]  7
+[ 62]  7 [ 63]  7 [ 64]  8 [ 65]  8 [ 66]  8 [ 67]  8 [ 68]  8 [ 69]  8 [ 70]  8 [ 71]  8
+[ 72]  8 [ 73]  8 [ 74]  8 [ 75]  8 [ 76]  8 [ 77]  8 [ 78]  8 [ 79]  8 [ 80]  8 [ 81]  9
+[ 82]  9 [ 83]  9 [ 84]  9 [ 85]  9 [ 86]  9 [ 87]  9 [ 88]  9 [ 89]  9 [ 90]  9 [ 91]  9
+[ 92]  9 [ 93]  9 [ 94]  9 [ 95]  9 [ 96]  9 [ 97]  9 [ 98]  9 [ 99]  9 [100] 10 [101] 10
+[102] 10 [103] 10 [104] 10 [105] 10 [106] 10 [107] 10 [108] 10 [109] 10 [110] 10 [111] 10
+[112] 10 [113] 10 [114] 10 [115] 10 [116] 10 [117] 10 [118] 10 [119] 10 [120] 10 [121] 11
+[122] 11 [123] 11 [124] 11 [125] 11 [126] 11 [127] 11 [128] 11 [129] 11 [130] 11 [131] 11
+[132] 11 [133] 11 [134] 11 [135] 11 [136] 11 [137] 11 [138] 11 [139] 11 [140] 11 [141] 11
+[142] 11 [143] 11 [144] 12 [145] 12 [146] 12 [147] 12 [148] 12 [149] 12 [150] 12 [151] 12
+</cli>
+Or, if perhaps we instead order by square root value:
+<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.
+There are some important lessons at play here:
+  * 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 difference in runtime performance.
+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:
-  - **primereg.c**: our baseline (does JUST the process, no optimizations)
+  * **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
 ====Program Specifications====
@@ Line 174: / Line 262: @@
 make: Leaving directory '/var/public/SEMESTER/cprog/pnc1'
-lab46:~/src/cprog/$
+lab46:~/src/cprog$
-lab46:~/src/cprog$ cd pnc1
-lab46:~/src/cprog/pnc1$ ls
-Makefile      primereg.c
-lab46:~/src/cprog/pnc1$
 </cli>
@@ Line 234: / Line 318: @@
 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.
@@ Line 273: / Line 358: @@
 <cli>
-lab46:~/src/cprog/pnc1$ ./primereg 128 1 2 2048
+lab46:~/src/cprog/pnc1$ ./primeregb 128 1 2 2048
 </cli>
@@ Line 370: / Line 455: @@
 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.
-=====Loops=====
-A loop is basically instructing the computer to repeat a section, or block, or code a given amount of times (it can be based on a fixed value-- repeat this 4 times, or be based on a conditional value-- keep repeating as long as (or while) this value is not 4).
-Loops enable us to simplify our code-- allowing us to write a one-size-fits all algorithm (provided the algorithm itself can appropriately scale!), where the computer merely repeats the instructions we gave. We only have to write them once, but the computer can do that task any number of times.
-Loops can be initially difficult to comprehend because unlike other programmatic actions, they are not single-state in nature-- loops are multi-state. What this means is that in order to correctly "see" or visualize a loop, you must analyze what is going on with EACH iteration or cycle, watching the values/algorithm/process slowly march from its initial state to its resultant state. Think of it as climbing a set of stairs... yes, we can describe that action succinctly as "climbing a set of stairs", but there are multiple "steps" (heh, heh) involved: we place our foot, adjust our balance-- left foot, right foot, from one step, to the next, to the next, allowing us to progress from the bottom step to the top step... that process of scaling a stairway is the same as iterating through a loop-- but what is important as we implement is what needs to happen each step along the way.
-With that said, it is important to be able to focus on the process of the individual steps being taken. What is involved in taking a step? What constitutes a basic unit of stairway traversal? If that unit can be easily repeated for the next and the next (and in fact, the rest of the) steps, we've described the core process of the loop, or what will be iterated a given number of times.
-In C and C-syntax influenced languages (C++, Java, PHP, among others), we typically have 3 types of loops:
-  * **for** loop (automatic counter loop, stepping loop; top-driven) - when we know exactly how many times we wish something to run; we know where we want to start, where we want to end, and exactly how to progress from start to end (step value)
-  * **while** loop (top-driven conditional loop) - when we want to repeat a process, but the exact number of iterations is either not known, not important, not known, or variable in nature. While loops can run 0 or more times.
-  * **do-while** loop (bottom-driven conditional loop) - similar to the while loop, only we do the check for loop termination at the bottom of the loop, meaning it runs 1 or more times (a do-while loop is guaranteed to run at least once).
-====for() loops====
-A **for()** loop is the most syntactically unique of the loops, so care must be taken to use the proper syntax.
-With any loop, we need (at least one) looping variable, which the loop will use to analyze whether or not we've met our looping destination, or to perform another iteration.
-A for loop typically also has a defined starting point, a "keep-looping-while" condition, and a stepping equation.
-Here's a sample for() loop, in C, which will display the squares of each number, starting at 0, and stepping one at a time, for 8 total iterations:
-<code c>
-int i = 0;
-for (i = 0; i < 8; i++)
-{
-    fprintf(stdout, "loop #%d ... %d\n", (i+1), (i*i));
-}
-</code>
-The output of this code, with the help of our loop should be:
-<cli>
-loop #1 ... 0
-loop #2 ... 1
-loop #3 ... 4
-loop #4 ... 9
-loop #5 ... 16
-loop #6 ... 25
-loop #7 ... 36
-loop #8 ... 49
-</cli>
-Note how we can use our looping variable (**i**) within mathematical expressions to drive a process along... loops can be of enormous help in this way.
-And again, we shouldn't look at this as one step-- we need to see there are 8 discrete, distinct steps happening here (when i is 0, when i is 1, when i is 2, ... up until (and including) when i is 7).
-The loop exits once **i** reaches a value of 8, because our loop determinant condition states as long as **i** is **less than** **8**, continue to loop. Once **i** becomes **8**, our looping condition has been satisfied, and the loop will no longer iterate.
-The stepping (that third) field is a mathematical expression indicating how we wish for **i** to progress from its starting state (of being equal to 0) to satisfying the loop's iterating condition (no longer being less than 8).
-**i++** is a shortcut we can use in C; the longhand (and likely more familiar) equivalent is: **i = i + 1**
-====while() loops====
-A **while()** loop isn't as specific about starting and stepping values, really only caring about what condition needs to be met in order to exit the loop (keep looping while this condition is true).
-In actuality, anything we use a for loop for can be expressed as a while loop-- we merely have to ensure we provide the necessary loop variables and progressions within the loop.
-That same loop above, expressed as a while loop, could look like:
-<code c>
-int i = 0;
-while (i < 8)
-{
-    fprintf(stdout, "loop #%d ... %d\n", (i+1), (i*i));
-    i = i + 1;   // I could have used "i++;" here
-}
-</code>
-The output of this code should be identical, even though we used a different loop to accomplish the task (try them both out and confirm!)
-**while()** loops, like **for()** loops, will run 0 or more times; if the conditions enabling the loop to occur are not initially met, they will not run... if met, they will continue to iterate until their looping conditions are met.
-It is possible to introduce a certain kind of **logical error** into your programs using loops-- what is known as an "infinite loop"; this is basically where you erroneously provide incorrect conditions to the particular loop used, allowing it to start running, but never arriving at its conclusion, thereby iterating forever.
-Another common **logical error** that loops will allow us to encounter will be the "off by one" error-- where the conditions we pose to the loop are incorrect, and the loop runs one magnitude more or less than we had intended. Again, proper debugging of our code will resolve this situation.
-====do-while loops====
-The third commonly recognized looping structure in C, the do-while loop is identical to the while() (and therefore also the for()) loop, only it differs in where it checks the looping condition: where **for()** and **while()** are "top-driven" loops (ie the test for loop continuance occurs at the top of the loop, **before** running the code in the loop body), the **do-while** is a "bottom-driven" loop (ie the test for loop continuance occurs at the bottom of the loop).
-The placement of this test determines the minimal number of times a loop can run.
-In the case of the for()/while() loops, because the test is at the top- if the looping conditions are not met, the loop may not run at all. It is for this reason why these loops can run "0 or more times"
-For the do-while loop, because the test occurs at the bottom, the body of the loop (one full iteration) is run before the test is encountered. So even if the conditions for looping are not met, a do-while will run "1 or more times".
-That may seem like a minor, and possibly annoying, difference, but in nuanced algorithm design, such distinctions can drastically change the layout of your code, potentially being the difference between beautifully elegant-looking solutions and those which appear slightly more hackish. They can BOTH be used to solve the same problems, it is merely the nature of how we choose express the solution that should make one more preferable over the other in any given moment.
-I encourage you to intentionally try your hand at taking your completed programs and implementing other versions that utilize the other types of loops you haven't utilized. This way, you can get more familiar with how to structure your solutions and express them. You will find you tend to think in a certain way (from experience, we seem to get in the habit of thinking "top-driven", and as we're unsure, we tend to exert far more of a need to control the situation, so we tend to want to use **for** loops for everything-- but practicing the others will free your mind to craft more elegant and efficient solutions; but only if you take the time to play and explore these possibilities).
-So, expressing that same program in the form of a do-while loop (note the changes from the while):
-<code c>
-int i = 0;
-do
-{
-    fprintf(stdout, "loop #%d ... %d\n", (i+1), (i*i));
-    i = i + 1;  // again, we could just as easily use "i++;" here
-} while(i < 8);
-</code>
-In this case, the 0 or more vs. 1 or more minimal iterations wasn't important; the difference is purely syntactical.
-With the do-while loop, we start the loop with a **do** statement.
-Also, the do-while is the only one of our loops which NEEDS a terminating semi-colon (**;**).. please take note of this.
 =====Execution=====
@@ Line 489: / Line 462: @@
 <cli>
-lab46:~/src/cprog/pnc1$ ./primereg 24 1
+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
 .0001
@@ Line 501: / Line 474: @@
 <cli>
-lab46:~/src/cprog/pnc1$ ./primereg 32 1 0
+lab46:~/src/cprog/pnc1$ ./primerego 32 1 0
 ./primereg: invalid lower bound
 lab46:~/src/cprog/pnc1$
@@ Line 512: / Line 485: @@
 <cli>
-lab46:~/src/cprog/pnc1$ ./primereg 128 1 7 23
+lab46:~/src/cprog/pnc1$ ./primeregs 128 1 7 23
 11 13 17 19 23
 .0001
@@ Line 526: / Line 499: @@
 ====check qty====
-For instance (running on my implementation of the pnc1 programs, some output omitted to keep the surprise alive):
+For instance (running on my implementation of the pnc1 programs):
 <cli>
 lab46:~/src/cprog/pnc1$ make checkqty
-=================
+=========================================================
-      qty     reg
+      qty     reg    regm    rego    regb    regs    rega
-=================
+=========================================================
-  0.0002
+  0.0001  0.0001  0.0001  0.0001  0.0001  0.0001
-  0.0006
+  0.0003  0.0001  0.0001  0.0001  0.0001  0.0001
-  0.0028
+  0.0012  0.0004  0.0003  0.0002  0.0001  0.0001
-  0.0123
+  0.0057  0.0020  0.0014  0.0009  0.0003  0.0003
-  0.0574
+  0.0278  0.0098  0.0066  0.0038  0.0009  0.0009
-  0.2690
+  0.1348  0.0476  0.0318  0.0166  0.0025  0.0025
-...
+  0.6416  0.2317  0.1510  0.0727  0.0073  0.0073
-  ------
+  3.0281  1.0707  0.7096  0.3144  0.0218  0.0217
-=================
+  ------  ------  3.2926  1.3627  0.0649  0.0649
- verify:     OK
+  ------  ------  ------  ------  0.1955  0.1954
-=================
+  ------  ------  ------  ------  0.5910  0.5905
+  ------  ------  ------  ------  1.7891  1.7864
+  ------  ------  ------  ------  ------  ------
+=========================================================
+ verify:     OK      OK      OK      OK      OK      OK
+=========================================================
 lab46:~/src/cprog/pnc1$
 </cli>
@@ Line 552: / Line 530: @@
 <cli>
 lab46:~/src/cprog/pnc1$ make checkrange
-=================
+=========================================================
-    range     reg
+    range     reg    regm    rego    regb    regs    rega
-=================
+=========================================================
-  0.0001
+  0.0001  0.0000  0.0000  0.0000  0.0001  0.0000
-  0.0001
+  0.0001  0.0001  0.0000  0.0000  0.0000  0.0000
-  0.0002
+  0.0001  0.0001  0.0001  0.0001  0.0001  0.0001
-  0.0004
+  0.0002  0.0001  0.0001  0.0001  0.0001  0.0001
-  0.0015
+  0.0006  0.0003  0.0002  0.0002  0.0001  0.0001
-  0.0053
+  0.0023  0.0008  0.0006  0.0004  0.0002  0.0002
-  0.0191
+  0.0088  0.0032  0.0021  0.0013  0.0004  0.0004
-  0.0709
+  0.0344  0.0125  0.0082  0.0047  0.0010  0.0010
-  0.2712
+  0.1358  0.0495  0.0322  0.0167  0.0025  0.0025
-...
+  0.5402  0.1968  0.1270  0.0616  0.0065  0.0065
-  2097152  ------
+  2.1530  0.7857  0.5050  0.2271  0.0170  0.0171
-=================
+  ------  3.1395  2.0088  0.8468  0.0454  0.0455
- verify:     OK
+  ------  ------  ------  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>
@@ Line 584: / Line 568: @@
 <cli>
 lab46:~/src/cprog/pnc1$ make verifyall
-=================
+=========================================================
-              reg
+              reg    regm    rego    regb    regs    rega
-=================
+=========================================================
- qtynorm:    OK
+ qtynorm:    OK      OK      OK      OK      OK      OK
- qtypart:    OK
+ qtypart:    OK      OK      OK      OK      OK      OK
- rngnorm:    OK
+ rngnorm:    OK      OK      OK      OK      OK      OK
- rngpart:    OK
+ rngpart:    OK      OK      OK      OK      OK      OK
-    coop:    OK
+    coop:    OK      OK      OK      OK      OK      OK
-   coop2:    OK
+   coop2:    OK      OK      OK      OK      OK      OK
-   coop3:    OK
+   coop3:    OK      OK      OK      OK      OK      OK
-  noargs:    OK
+  noargs:    OK      OK      OK      OK      OK      OK
- invargs:    OK
+ invargs:    OK      OK      OK      OK      OK      OK
-  invqty:    OK
+  invqty:    OK      OK      OK      OK      OK      OK
- invnary:    OK
+ invnary:    OK      OK      OK      OK      OK      OK
-  invlow:    OK
+  invlow:    OK      OK      OK      OK      OK      OK
- invhigh:    OK
+ invhigh:    OK      OK      OK      OK      OK      OK
-=================
+=========================================================
 lab46:~/src/cprog/pnc1$
 </cli>

Lab46 Wiki

User Tools

Site Tools

Differences

Page Tools