Lab46 Wiki

User Tools

Site Tools

You are here: start » haas » fall2017 » discrete » projects » pnc2
haas:fall2017:discrete:projects:pnc2

Differences

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

Link to this comparison view

Both sides previous revisionPrevious revision
Next revision		Previous revision
haas:fall2017:discrete:projects:pnc2 [2017/09/11 14:46] – [Grabit Integration] wedgehaas:fall2017:discrete:projects:pnc2 [2017/09/18 15:58] (current) – [Evaluation Criteria] wedge
Line 111: Line 111:
  
 For this project, you'll be implementing various combinations of optimizations, giving us a full set of programs to analyze performance. For this project, you'll be implementing various combinations of optimizations, giving us a full set of programs to analyze performance.
 +
 +=====A note on comments=====
 +Something I noticed (and have historically noticed) in relation to comments that I'd like to point out:
 +
 +Comments should be describing what is going on in your code.
 +
 +With projects like this, often relying on a common base, comments become even more important, as they allow me to see specifically what is changed or unique about one variant over the other.
 +
 +As such, when evaluating the project, I will be looking for pertinent comments specifically covering the how or why of the particular change unique to the variant in question.
 +
 +And notice I said the "how" and/or "why". NOT the "what". I see all the time vague comments like "<nowiki>// doing the sqrt() optimization</nowiki>"... but:
 +
 +  * WHY is that important to the process?
 +  * HOW does it impact the efficiency of the algorithm?
 +
 +These are things I'd like to see addressed in your comments, as there were some cases where the WHAT was claimed, yet what actually followed had little resemblance (if any) on the requirements for that variant.
 +
 +Just like if you can't do it by hand you have no business trying to code it- if you cannot adequately explain the WHY and HOW, you similarly will have trouble.
  
 =====Programs===== =====Programs=====
Line 156: Line 174:
     * 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.     * 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.
     * the timing information will be displayed in accordance to code I will provide below (see the **timing** section).     * the timing information will be displayed in accordance to code I will provide below (see the **timing** section).
 +
 +=====Implementation Restrictions=====
 +
 +As our goal is not only to explore the more subtle concepts of computing but to promote different methods of thinking (and arriving at solutions seemingly in different ways), one of the themes I have been harping on is the stricter adherence to the structured programming philosophy/paradigm. It isn't just good enough to be able to crank out a solution if you remain blind to the many nuances of the tools we are using, so we will at times be going out of our way to emphasize focus on certain areas that may see less exposure (or avoidance due to it being less familiar-- and from what I've witnessed so far this semester, avoidance is alive and well).
 +
 +As such, the following implementation restrictions are also in place:
 +
 +  * focus on **if()**, **ternary**, and **conditional chaining** over switch/case statements.
 +  * keep your use of **continue** and **break** statements (especially **break** statements) to a necessary minimum).
 +  * absolutely **NO** other non-structured program flow alteration (jumps, gotos, etc.)
 +  * absolutely **NO** infinite loops (**while(1)**, which are more-or-less unviable anyway if you cannot **break** out of them).
 +  * no forced redirection of the flow of the process (no seeking to the end of the file to grab a max size only to zip back somewhere else: deal with the data in as you are naturally encountering it).
 +  * All "arrays" must be declared and referenced using ONLY pointer notation, NO square brackets.
 +  * **NO** logic shunts (ie having an if statement nested inside a loop to bypass an undesirable iteration)- this should be handled by the loop condition!
 +  * At most, **ONE** return statement per function (in the case of **void**, 0 return statements).
 +  * No redundant duplication of code to address different top-level conditions or operational constraints (think quantity vs. range- these can successfully co-exist in the same block of code).
 +  * Never leave an initialized or allocated resource unverified- always do proper error checking (was the file successfully opened? Was the memory successfully allocated?
 +
 +A common resistance or complaint I get with imposing these is that it may make your solutions more cumbersome or less optimal; that actually may not be an incorrect assertion, but remember: we are interested in the longer-term pursuit of structured thinking and effective problem solving. To foster your ability to think flexibly and differently. We tend to be naturally more averse to going against the grain, but to be an effective programmer/problem solver, this is absolutely necessary. It may be "annoying", and you may choose to make it more aggravating on both yourself and me by agonizing over it, but history and experience teaching has shown me, time and time again, that this is an investment and it pays off in the long run (assuming one actually plays along).
 +
 +I am seeking to make you all better thinkers and programmers, and I cannot do that if I cave to your innate desires not to change your ways of doing things. Yes, it may be unfamiliar; yes, it may be perceived as challenging. But you know what? Work through it and eventually it becomes the new normal- what was challenging is now no longer an issue.
  
 =====Grabit Integration===== =====Grabit Integration=====
Line 174: Line 213:
  
 make: Leaving directory '/var/public/SEMESTER/discrete/pnc2' make: Leaving directory '/var/public/SEMESTER/discrete/pnc2'
-lab46:~/src/discrete/$  
 lab46:~/src/discrete$ cd pnc2 lab46:~/src/discrete$ cd pnc2
 lab46:~/src/discrete/pnc2$  lab46:~/src/discrete/pnc2$ 
Line 191: Line 229:
  
 <cli> <cli>
-lab46:~/src/discrete/pnc1$ make help +lab46:~/src/discrete/pnc2$ make help 
-******************[ Discrete Structures pnc1 Project ]******************+******************[ Discrete Structures pnc2 Project ]******************
 ** make                     - build everything                        ** ** make                     - build everything                        **
 ** make showerrors          - display compiler warnings/errors        ** ** make showerrors          - display compiler warnings/errors        **
Line 216: Line 254:
 ** make help                - this information                        ** ** make help                - this information                        **
 ************************************************************************ ************************************************************************
-lab46:~/src/discrete/pnc1$ +lab46:~/src/discrete/pnc2$ 
 </cli> </cli>
  
Line 232: Line 270:
  
 The various "verify" options do more aggressive checks, helping to ensure your project falls within stated project specifications. The various "verify" options do more aggressive checks, helping to ensure your project falls within stated project specifications.
- 
-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 
  
 Just another "nice thing" we deserve. Just another "nice thing" we deserve.
 +
 =====Command-Line Arguments===== =====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==== ====header files====
Line 281: Line 292:
 int main(int argc, char **argv) int main(int argc, char **argv)
 </code> </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: The arguments are accessible via the argv array, in the order they were specified:
  
-  * **argv[0]**: program invocation (path + program name) +  * argv[0]: program invocation (path + program name) 
-  * **argv[1]**: our maximum / upper bound+  * 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 **primeregbms** program: 
 + 
 +<cli> 
 +lab46:~/src/discrete/pnc1$ ./primeregbms 128 1 2 2048 
 +</cli> 
 + 
 +We'd have: 
 + 
 +  * <nowiki>argv[0]</nowiki>: "./primeregbms"  
 +  * <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==== ====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> <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);         exit(1);
     }     }
 </code> </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==== ====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**. I'd recommend declaring a variable of type **int**.
Line 306: Line 350:
  
 <code c> <code c>
-    max  = atoi(argv[1]);+    max  = atoi (argv[1]);
 </code> </code>
  
Line 564: Line 608:
  
 And of course the same for the 3 variants, and the same error message reporting if invalid values are given. And of course the same for the 3 variants, and the same error message reporting if invalid values are given.
 +
 ====Performance changes==== ====Performance changes====
 You may notice a change with the sieves as compared to the other algorithms you've implemented with respect to performance- there will likely be a lower bound of performance, ie you have to exceed a certain threshold before the algorithm truly enters its power band, and then it may truly be a step-up in terms of performance. You may notice a change with the sieves as compared to the other algorithms you've implemented with respect to performance- there will likely be a lower bound of performance, ie you have to exceed a certain threshold before the algorithm truly enters its power band, and then it may truly be a step-up in terms of performance.
Line 570: Line 615:
 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. 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 pnc0 binaries reside, and must be named as such (which occurs if you ran **make** to compile them).+In order to work, you **MUST** be in the directory where your pnc2 binaries reside, and must be named as such (which occurs if you ran **make** to compile them).
  
 ====check qty==== ====check qty====
 <cli> <cli>
 +lab46:~/src/discrete/pnc2$ make checkqty
 ========================================================= =========================================================
       qty   soe     soeo    soes    soea    soeos   soeoa       qty   soe     soeo    soes    soea    soeos   soeoa
Line 592: Line 638:
  verify:     OK      OK      OK      OK      OK      OK  verify:     OK      OK      OK      OK      OK      OK
 ========================================================= =========================================================
 +lab46:~/src/discrete/pnc2$ 
 </cli> </cli>
  
Line 600: Line 647:
 ====check range==== ====check range====
 <cli> <cli>
 +lab46:~/src/discrete/pnc2$ make checkrange 
 +coming soon 
 +lab46:~/src/discrete/pnc2$ 
 </cli> </cli>
  
Line 610: Line 659:
  
 <cli> <cli>
-lab46:~/src/discrete/pnc1$ make verifyall +lab46:~/src/discrete/pnc2$ make verifyall 
-========================================================================================= +coming soon 
-              reg    regm    rego    regb   regbm   regbo    regs    rega   regbs   regba +lab46:~/src/discrete/pnc2$ 
-========================================================================================= +
- qtynorm:    OK      OK      OK      OK      OK      OK      OK      OK      OK      OK +
- qtypart:    OK      OK      OK      OK      OK      OK      OK      OK      OK      OK +
- rngnorm:    OK      OK      OK      OK      OK      OK      OK      OK      OK      OK +
- rngpart:    OK      OK      OK      OK      OK      OK      OK      OK      OK      OK +
-    coop:    OK      OK      OK      OK      OK      OK      OK      OK      OK      OK +
-   coop2:    OK      OK      OK      OK      OK      OK      OK      OK      OK      OK +
-   coop3:    OK      OK      OK      OK      OK      OK      OK      OK      OK      OK +
-  noargs:    OK      OK      OK      OK      OK      OK      OK      OK      OK      OK +
- invargs:    OK      OK      OK      OK      OK      OK      OK      OK      OK      OK +
-  invqty:    OK      OK      OK      OK      OK      OK      OK      OK      OK      OK +
- invnary:    OK      OK      OK      OK      OK      OK      OK      OK      OK      OK +
-  invlow:    OK      OK      OK      OK      OK      OK      OK      OK      OK      OK +
- invhigh:    OK      OK      OK      OK      OK      OK      OK      OK      OK      OK +
-========================================================================================= +
-lab46:~/src/discrete/pnc1$ +
 </cli> </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==== ====In general====
Line 641: Line 711:
   * Code must be nicely and consistently indented (you may use the **indent** tool)   * 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:
-    * **primeregmo.c**: map + odd traversal optimizations +  * soe     soeo    soes    soea    soeos   soeoa 
-    * **primeregms.c**: map traversal + sqrt() trick +    * **primesoe.c**: baseline sieve of eratosthenes 
-    * **primeregma.c**: map treversal + approximated square root trick +    * **primesoeo.c**: odd traversal optimization 
-    * **primeregos.c**: odd traversal + sqrt() trick +    * **primesoes.c**: sqrt() trick 
-    * **primeregoa.c**: odd traversal + approximated square root trick +    * **primesoea.c**: approximated square root 
-    * **primeregbmo.c**: break + map + odd traversal +    * **primesoeos.c**: odd traversal + sqrt() trick 
-    * **primeregbms.c**: break + map + sqrt() trick +    * **primesoeoa.c**: odd traversal + approximated square root 
-    * **primeregbma.c**: break + map + approximated square root trick +  * Code must be commented, and comments must focus on the how and why of the process.
-    * **primeregbos.c**: break + odd + sqrt() trick +
-    * **primeregboa.c**: break + odd + approximated square root trick +
-    * **primeregmos.c**: map + odd traversal + sqrt() trick +
-    * **primeregmoa.c**: map + odd traversal + approximated square root trick +
-    * **primeregbmos.c**: break + map + odd + sqrt() trick +
-    * **primeregbmoa.c**: break + map + odd + approximated square root trick +
-  * Code must be commented +
-    * have a properly filled-out comment banner at the top +
-      * be sure to include any compiling instructions +
-    * have at least 20% of your program consist of **<nowiki>//</nowiki>**-style descriptive comments+
   * Output Formatting (including spacing) of program must conform to the provided output (see above).   * Output Formatting (including spacing) of program must conform to the provided output (see above).
   * Track/version the source code in a repository   * Track/version the source code in a repository
Line 666: Line 726:
  
 <cli> <cli>
-lab46:~/src/discrete/pnc1$ make submit+lab46:~/src/discrete/pnc2$ make submit
 Delinking ... Delinking ...
-removed ‘primerega.c’ 
-removed ‘primeregba.c’ 
-removed ‘primeregb.c’ 
-removed ‘primeregbm.c’ 
-removed ‘primeregbo.c’ 
-removed ‘primeregbs.c’ 
-removed ‘primereg.c’ 
-removed ‘primeregm.c’ 
-removed ‘primerego.c’ 
-removed ‘primeregs.c’ 
-removed ‘primeregbma’ 
-removed ‘primeregbmoa’ 
-removed ‘primeregbmo’ 
-removed ‘primeregbmos’ 
-removed ‘primeregbms’ 
-removed ‘primeregboa’ 
-removed ‘primeregbos’ 
-removed ‘primeregma’ 
-removed ‘primeregmoa’ 
-removed ‘primeregmo’ 
-removed ‘primeregmos’ 
-removed ‘primeregms’ 
-removed ‘primeregoa’ 
-removed ‘primeregos’ 
 removed ‘errors’ removed ‘errors’
  
 Project backup process commencing Project backup process commencing
  
-Taking snapshot of current project (pnc1)      ... OK +Taking snapshot of current project (pnc2)      ... OK 
-Compressing snapshot of pnc1 project archive   ... OK +Compressing snapshot of pnc2 project archive   ... OK 
-Setting secure permissions on pnc1 archive     ... OK+Setting secure permissions on pnc2 archive     ... OK
  
 Project backup process complete Project backup process complete
  
-Submitting discrete project "pnc1": +Submitting discrete project "pnc2": 
-    -> ../pnc1-20170713-11.tar.gz(OK)+    -> ../pnc2-DATESTRING-HR.tar.gz(OK)
  
 SUCCESSFULLY SUBMITTED SUCCESSFULLY SUBMITTED
Line 711: Line 747:
  
 ====Evaluation Criteria==== ====Evaluation Criteria====
-What I will be looking for:+Grand total points:
  
 <code> <code>
-546:pnc1:final tally of results (546/546) +390:pnc2:final tally of results (390/390)
-*:pnc1:primeregbma.c performs proper argument checking [2/2] +
-*:pnc1:primeregbma.c performs proper bounds checking [2/2] +
-*:pnc1:primeregbma.c compiles cleanly, no compiler messages [2/2] +
-*:pnc1:primeregbma.c implements only specified algorithm [6/6] +
-*:pnc1:primeregbma.c consistent indentation throughout code [2/2] +
-*:pnc1:primeregbma.c relevant comments throughout code [2/2] +
-*:pnc1:primeregbma.c code conforms to project specifications [3/3] +
-*:pnc1:primeregbma.c program output conforms to specifications [3/3] +
-*:pnc1:primeregbma.c make checkqty runtimes within reason [2/2] +
-*:pnc1:primeregbma.c make checkrange runtimes within reason [2/2] +
-*:pnc1:primeregbma.c make verifyall tests succeed [13/13] +
-*:pnc1:primeregbmo.c performs proper argument checking [2/2] +
-*:pnc1:primeregbmo.c performs proper bounds checking [2/2] +
-*:pnc1:primeregbmo.c compiles cleanly, no compiler messages [2/2] +
-*:pnc1:primeregbmo.c implements only specified algorithm [6/6] +
-*:pnc1:primeregbmo.c consistent indentation throughout code [2/2] +
-*:pnc1:primeregbmo.c relevant comments throughout code [2/2] +
-*:pnc1:primeregbmo.c code conforms to project specifications [3/3] +
-*:pnc1:primeregbmo.c program output conforms to specifications [3/3] +
-*:pnc1:primeregbmo.c make checkqty runtimes within reason [2/2] +
-*:pnc1:primeregbmo.c make checkrange runtimes within reason [2/2] +
-*:pnc1:primeregbmo.c make verifyall tests succeed [13/13] +
-*:pnc1:primeregbmoa.c performs proper argument checking [2/2] +
-*:pnc1:primeregbmoa.c performs proper bounds checking [2/2] +
-*:pnc1:primeregbmoa.c compiles cleanly, no compiler messages [2/2] +
-*:pnc1:primeregbmoa.c implements only specified algorithm [6/6] +
-*:pnc1:primeregbmoa.c consistent indentation throughout code [2/2] +
-*:pnc1:primeregbmoa.c relevant comments throughout code [2/2] +
-*:pnc1:primeregbmoa.c code conforms to project specifications [3/3] +
-*:pnc1:primeregbmoa.c program output conforms to specifications [3/3] +
-*:pnc1:primeregbmoa.c make checkqty runtimes within reason [2/2] +
-*:pnc1:primeregbmoa.c make checkrange runtimes within reason [2/2] +
-*:pnc1:primeregbmoa.c make verifyall tests succeed [13/13] +
-*:pnc1:primeregbmos.c performs proper argument checking [2/2] +
-*:pnc1:primeregbmos.c performs proper bounds checking [2/2] +
-*:pnc1:primeregbmos.c compiles cleanly, no compiler messages [2/2] +
-*:pnc1:primeregbmos.c implements only specified algorithm [6/6] +
-*:pnc1:primeregbmos.c consistent indentation throughout code [2/2] +
-*:pnc1:primeregbmos.c relevant comments throughout code [2/2] +
-*:pnc1:primeregbmos.c code conforms to project specifications [3/3] +
-*:pnc1:primeregbmos.c program output conforms to specifications [3/3] +
-*:pnc1:primeregbmos.c make checkqty runtimes within reason [2/2] +
-*:pnc1:primeregbmos.c make checkrange runtimes within reason [2/2] +
-*:pnc1:primeregbmos.c make verifyall tests succeed [13/13] +
-*:pnc1:primeregbms.c performs proper argument checking [2/2] +
-*:pnc1:primeregbms.c performs proper bounds checking [2/2] +
-*:pnc1:primeregbms.c compiles cleanly, no compiler messages [2/2] +
-*:pnc1:primeregbms.c implements only specified algorithm [6/6] +
-*:pnc1:primeregbms.c consistent indentation throughout code [2/2] +
-*:pnc1:primeregbms.c relevant comments throughout code [2/2] +
-*:pnc1:primeregbms.c code conforms to project specifications [3/3] +
-*:pnc1:primeregbms.c program output conforms to specifications [3/3] +
-*:pnc1:primeregbms.c make checkqty runtimes within reason [2/2] +
-*:pnc1:primeregbms.c make checkrange runtimes within reason [2/2] +
-*:pnc1:primeregbms.c make verifyall tests succeed [13/13] +
-*:pnc1:primeregboa.c performs proper argument checking [2/2] +
-*:pnc1:primeregboa.c performs proper bounds checking [2/2] +
-*:pnc1:primeregboa.c compiles cleanly, no compiler messages [2/2] +
-*:pnc1:primeregboa.c implements only specified algorithm [6/6] +
-*:pnc1:primeregboa.c consistent indentation throughout code [2/2] +
-*:pnc1:primeregboa.c relevant comments throughout code [2/2] +
-*:pnc1:primeregboa.c code conforms to project specifications [3/3] +
-*:pnc1:primeregboa.c program output conforms to specifications [3/3] +
-*:pnc1:primeregboa.c make checkqty runtimes within reason [2/2] +
-*:pnc1:primeregboa.c make checkrange runtimes within reason [2/2] +
-*:pnc1:primeregboa.c make verifyall tests succeed [13/13] +
-*:pnc1:primeregbos.c performs proper argument checking [2/2] +
-*:pnc1:primeregbos.c performs proper bounds checking [2/2] +
-*:pnc1:primeregbos.c compiles cleanly, no compiler messages [2/2] +
-*:pnc1:primeregbos.c implements only specified algorithm [6/6] +
-*:pnc1:primeregbos.c consistent indentation throughout code [2/2] +
-*:pnc1:primeregbos.c relevant comments throughout code [2/2] +
-*:pnc1:primeregbos.c code conforms to project specifications [3/3] +
-*:pnc1:primeregbos.c program output conforms to specifications [3/3] +
-*:pnc1:primeregbos.c make checkqty runtimes within reason [2/2] +
-*:pnc1:primeregbos.c make checkrange runtimes within reason [2/2] +
-*:pnc1:primeregbos.c make verifyall tests succeed [13/13] +
-*:pnc1:primeregma.c performs proper argument checking [2/2] +
-*:pnc1:primeregma.c performs proper bounds checking [2/2] +
-*:pnc1:primeregma.c compiles cleanly, no compiler messages [2/2] +
-*:pnc1:primeregma.c implements only specified algorithm [6/6] +
-*:pnc1:primeregma.c consistent indentation throughout code [2/2] +
-*:pnc1:primeregma.c relevant comments throughout code [2/2] +
-*:pnc1:primeregma.c code conforms to project specifications [3/3] +
-*:pnc1:primeregma.c program output conforms to specifications [3/3] +
-*:pnc1:primeregma.c make checkqty runtimes within reason [2/2] +
-*:pnc1:primeregma.c make checkrange runtimes within reason [2/2] +
-*:pnc1:primeregma.c make verifyall tests succeed [13/13] +
-*:pnc1:primeregmo.c performs proper argument checking [2/2] +
-*:pnc1:primeregmo.c performs proper bounds checking [2/2] +
-*:pnc1:primeregmo.c compiles cleanly, no compiler messages [2/2] +
-*:pnc1:primeregmo.c implements only specified algorithm [6/6] +
-*:pnc1:primeregmo.c consistent indentation throughout code [2/2] +
-*:pnc1:primeregmo.c relevant comments throughout code [2/2] +
-*:pnc1:primeregmo.c code conforms to project specifications [3/3] +
-*:pnc1:primeregmo.c program output conforms to specifications [3/3] +
-*:pnc1:primeregmo.c make checkqty runtimes within reason [2/2] +
-*:pnc1:primeregmo.c make checkrange runtimes within reason [2/2] +
-*:pnc1:primeregmo.c make verifyall tests succeed [13/13] +
-*:pnc1:primeregmoa.c performs proper argument checking [2/2] +
-*:pnc1:primeregmoa.c performs proper bounds checking [2/2] +
-*:pnc1:primeregmoa.c compiles cleanly, no compiler messages [2/2] +
-*:pnc1:primeregmoa.c implements only specified algorithm [6/6] +
-*:pnc1:primeregmoa.c consistent indentation throughout code [2/2] +
-*:pnc1:primeregmoa.c relevant comments throughout code [2/2] +
-*:pnc1:primeregmoa.c code conforms to project specifications [3/3] +
-*:pnc1:primeregmoa.c program output conforms to specifications [3/3] +
-*:pnc1:primeregmoa.c make checkqty runtimes within reason [2/2] +
-*:pnc1:primeregmoa.c make checkrange runtimes within reason [2/2] +
-*:pnc1:primeregmoa.c make verifyall tests succeed [13/13] +
-*:pnc1:primeregmos.c performs proper argument checking [2/2] +
-*:pnc1:primeregmos.c performs proper bounds checking [2/2] +
-*:pnc1:primeregmos.c compiles cleanly, no compiler messages [2/2] +
-*:pnc1:primeregmos.c implements only specified algorithm [6/6] +
-*:pnc1:primeregmos.c consistent indentation throughout code [2/2] +
-*:pnc1:primeregmos.c relevant comments throughout code [2/2] +
-*:pnc1:primeregmos.c code conforms to project specifications [3/3] +
-*:pnc1:primeregmos.c program output conforms to specifications [3/3] +
-*:pnc1:primeregmos.c make checkqty runtimes within reason [2/2] +
-*:pnc1:primeregmos.c make checkrange runtimes within reason [2/2] +
-*:pnc1:primeregmos.c make verifyall tests succeed [13/13] +
-*:pnc1:primeregms.c performs proper argument checking [2/2] +
-*:pnc1:primeregms.c performs proper bounds checking [2/2] +
-*:pnc1:primeregms.c compiles cleanly, no compiler messages [2/2] +
-*:pnc1:primeregms.c implements only specified algorithm [6/6] +
-*:pnc1:primeregms.c consistent indentation throughout code [2/2] +
-*:pnc1:primeregms.c relevant comments throughout code [2/2] +
-*:pnc1:primeregms.c code conforms to project specifications [3/3] +
-*:pnc1:primeregms.c program output conforms to specifications [3/3] +
-*:pnc1:primeregms.c make checkqty runtimes within reason [2/2] +
-*:pnc1:primeregms.c make checkrange runtimes within reason [2/2] +
-*:pnc1:primeregms.c make verifyall tests succeed [13/13] +
-*:pnc1:primeregoa.c performs proper argument checking [2/2] +
-*:pnc1:primeregoa.c performs proper bounds checking [2/2] +
-*:pnc1:primeregoa.c compiles cleanly, no compiler messages [2/2] +
-*:pnc1:primeregoa.c implements only specified algorithm [6/6] +
-*:pnc1:primeregoa.c consistent indentation throughout code [2/2] +
-*:pnc1:primeregoa.c relevant comments throughout code [2/2] +
-*:pnc1:primeregoa.c code conforms to project specifications [3/3] +
-*:pnc1:primeregoa.c program output conforms to specifications [3/3] +
-*:pnc1:primeregoa.c make checkqty runtimes within reason [2/2] +
-*:pnc1:primeregoa.c make checkrange runtimes within reason [2/2] +
-*:pnc1:primeregoa.c make verifyall tests succeed [13/13] +
-*:pnc1:primeregos.c performs proper argument checking [2/2] +
-*:pnc1:primeregos.c performs proper bounds checking [2/2] +
-*:pnc1:primeregos.c compiles cleanly, no compiler messages [2/2] +
-*:pnc1:primeregos.c implements only specified algorithm [6/6] +
-*:pnc1:primeregos.c consistent indentation throughout code [2/2] +
-*:pnc1:primeregos.c relevant comments throughout code [2/2] +
-*:pnc1:primeregos.c code conforms to project specifications [3/3] +
-*:pnc1:primeregos.c program output conforms to specifications [3/3] +
-*:pnc1:primeregos.c make checkqty runtimes within reason [2/2] +
-*:pnc1:primeregos.c make checkrange runtimes within reason [2/2] +
-*:pnc1:primeregos.c make verifyall tests succeed [13/13]+
 </code> </code>
  
 +What I will be looking for (for each file):
 +
 +<code>
 +*:pnc2:primeALGO.c compiles cleanly, no compiler messages [4/4]
 +*:pnc2:primeALGO.c implements only specified algorithm [8/8]
 +*:pnc2:primeALGO.c consistent indentation throughout code [4/4]
 +*:pnc2:primeALGO.c relevant how and why comments in code [7/7]
 +*:pnc2:primeALGO.c code conforms to project specifications [4/4]
 +*:pnc2:primeALGO.c implementation free from restrictions [13/13]
 +*:pnc2:primeALGO runtime output conforms to specifications [4/4]
 +*:pnc2:primeALGO make checkqty test times within reason [4/4]
 +*:pnc2:primeALGO make checkrange test times within reason [4/4]
 +*:pnc2:primeALGO make verifyall tests succeed [13/13]
 +</code>
haas/fall2017/discrete/projects/pnc2.1505141209.txt.gz · Last modified: 2017/09/11 14:46 by wedge

Page Tools

Except where otherwise noted, content on this wiki is licensed under the following license: CC Attribution-Share Alike 4.0 International
CC Attribution-Share Alike 4.0 International Donate Powered by PHP Valid HTML5 Valid CSS Driven by DokuWiki