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/07/13 20:43] – wedgehaas:fall2017:discrete:projects:pnc2 [2017/09/18 15:58] (current) – [Evaluation Criteria] wedge
Line 6: Line 6:
 ~~TOC~~ ~~TOC~~
  
-======Project: ALGORITHMS - PRIME NUMBER CALCULATION (pnc2)======+======Project: ALGORITHMS AND OPTIMIZATIONS - PRIME NUMBER COMPUTATION (pnc2)======
  
 =====Errata===== =====Errata=====
Line 14: Line 14:
  
 ====Revision List==== ====Revision List====
-  * revision 0: initial release (20170713) 
   * revision #: <description> (DATESTRING)   * revision #: <description> (DATESTRING)
  
Line 29: Line 28:
   * if optimizing for (or trying to take up less) space, the program runtime can grow.   * if optimizing for (or trying to take up less) space, the program runtime can grow.
  
-Let it be clear: using modern computers bound by fourth dimensional constraints, we **cannot** write solutions without some foothold in both space and time (any program has statements in it that accomplish the task at hand (space occupied), and that same program takes time to run (even if it happens rather quickly)). What we can do is influence where on the space-time spectrum our implementation falls, and if done strategically for the particular constraint at hand, can aid us in achieving desired improvements in program efficiency.+Let it be clear: using modern computers bound by these so-called fourth dimensional constraints, we **cannot** write solutions without some foothold in both space and time (any program has statements in it that accomplish the task at hand (space occupied), and that same program takes time to run (even if it happens rather quickly)). What we can do is influence where on the space-time spectrum our implementation falls, and if done strategically for the particular constraint at hand, can aid us in achieving desired improvements in program efficiency.
  
 In the previous projects, we focused on algorithms that were more constrained by time- taking progressively more time the larger the data set to be processed became. These time-constrained algorithms also happen to be the type of algorithm you're most familiar with (or at least, were indoctrinated into thinking with...). Your third grade self, on the other hand,  potentially would have found more familiarity with the space-constrained methods this project will explore. In the previous projects, we focused on algorithms that were more constrained by time- taking progressively more time the larger the data set to be processed became. These time-constrained algorithms also happen to be the type of algorithm you're most familiar with (or at least, were indoctrinated into thinking with...). Your third grade self, on the other hand,  potentially would have found more familiarity with the space-constrained methods this project will explore.
Line 47: Line 46:
  
   * unless otherwise specified, you are doing all values (odds AND evens).   * unless otherwise specified, you are doing all values (odds AND evens).
-  * if you exceed some threshold of values get "--error!---" from "**make check**" that's okay: I have memory limits in place (just like I have time limits in place). +  * if you exceed some threshold of values and get "--error!---" from "**make check**" that's okay: I have memory limits in place (just like I have time limits in place). 
-  * as the space-based approach to solving our prime number computation problem is fundamentally different from those we took in previous projects, you will want to look to start from scratch. Trying to reuse old code and shoehorn it into what effectively amounts to an entirely different paradigm will create a lot of problems.+  * as the storage-based approach to solving our prime number computation problem is fundamentally different from those we took in previous projects, you will want to look to start from scratch. Trying to reuse old code and shoehorn it into what effectively amounts to an entirely different paradigm will create a lot of problems.
  
-But, the conceptual level, at least for the baseline implementation, we'll be pursuing will be the space-based equivalent of **primereg**, that is, no fancy optimizations for odd numbers, no map traversals, nor the **sqrt()** tricks, just straight up processing of the values that need to be processed.+But, the conceptual level, at least for the baseline implementation, what we'll be pursuing will be the space-based equivalent of **primereg**, that is, no fancy optimizations for odd numbers, no map traversals, nor the **sqrt()** tricks, just straight up processing of the values that need to be processed.
  
 You may find some of the previous optimizations aren't even applicable based on how this algorithm works (break on composite, for instance). You may find some of the previous optimizations aren't even applicable based on how this algorithm works (break on composite, for instance).
Line 112: 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 157: 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 162: Line 200:
  
 To "grab" it: To "grab" it:
- 
-NOTE: You will **NEED** to specify the semester as indicated as the semester in question has not yet started. 
  
 <cli> <cli>
-lab46:~/src/discrete$ SEMESTER=fall2017 grabit discrete pnc2 +lab46:~/src/discrete$ grabit discrete pnc2 
-make: Entering directory '/var/public/fall2017/discrete/pnc2' +make: Entering directory '/var/public/SEMESTER/discrete/pnc2' 
-Commencing copy process for fall2017 discrete project pnc2:+Commencing copy process for SEMESTER discrete project pnc2:
  -> Creating project pnc2 directory tree           ... OK  -> Creating project pnc2 directory tree           ... OK
  -> Copying pnc2 project files                     ... OK  -> Copying pnc2 project files                     ... OK
Line 176: Line 212:
 *** Copy COMPLETE! You may now go to the '/home/USER/src/discrete/pnc2' directory *** *** Copy COMPLETE! You may now go to the '/home/USER/src/discrete/pnc2' directory ***
  
-make: Leaving directory '/var/public/fall2017/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 194: 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        **
-**                                                                    ** 
 ** make debug               - build everything with debug symbols     ** ** make debug               - build everything with debug symbols     **
-** make check               - check implementation for validity       **+** 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 link                - link in previous prime programs         ** ** make link                - link in previous prime programs         **
Line 215: Line 254:
 ** make help                - this information                        ** ** make help                - this information                        **
 ************************************************************************ ************************************************************************
-lab46:~/src/discrete/pnc1$ +lab46:~/src/discrete/pnc2$ 
 </cli> </cli>
  
Line 221: Line 260:
  
   * **make**: compile everything   * **make**: compile everything
-    * any **warnings** or **errors** generated by the compiler will go into a file in the base directory of the project in a file called **errors**; you can **cat** it to view the information.+    * any **warnings** or **errors** generated by the compiler will go into a file in the base directory of pnc0 in a file called **errors**; you can **cat** it to view the information.
   * **make debug**: compile everything with debug support   * **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.     * any **warnings** or **errors** generated by the compiler will be displayed to the screen as the programs compile.
Line 227: Line 266:
   * **make save**: make a backup of your current work   * **make save**: make a backup of your current work
   * **make submit**: archive and submit your project   * **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. 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 249: 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 274: Line 350:
  
 <code c> <code c>
-    max  = atoi(argv[1]);+    max  = atoi (argv[1]);
 </code> </code>
  
Line 532: 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.
  
 =====Check Results===== =====Check Results=====
-To verify your program's correctness and view your implementation's performance, "**make check**" will recognize the indicated program names listed above:+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 pnc2 binaries reside, and must be named as such (which occurs if you ran **make** to compile them).
 +
 +====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 557: Line 638:
  verify:     OK      OK      OK      OK      OK      OK  verify:     OK      OK      OK      OK      OK      OK
 ========================================================= =========================================================
 +lab46:~/src/discrete/pnc2$ 
 </cli> </cli>
  
-If/when the runtime of a particular prime variant exceeds an upper threshold (1 second), it will be omitted from further tests, and a series of dashes will instead appear in the output.+When the runtime of a particular prime variant exceeds an upper threshold (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** and the script will terminate.
  
-If the check is successful, you will see "OK" displayed beneath in the appropriate column; if unsuccessful, you will see "MISMATCH".+====check range==== 
 +<cli> 
 +lab46:~/src/discrete/pnc2$ make checkrange 
 +coming soon 
 +lab46:~/src/discrete/pnc2$  
 +</cli> 
 + 
 +====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/discrete/pnc2$ make verifyall 
 +coming soon 
 +lab46:~/src/discrete/pnc2$  
 +</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===== =====Submission=====
Line 572: 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 597: 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 641: Line 746:
 You should get that final "SUCCESSFULLY SUBMITTED" with no error messages occurring. 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> <code>
-364:pnc1:final tally of results (364/364) +390:pnc2:final tally of results (390/390)
-*:pnc1:primeregbma.c performs proper argument checking [2/2] +
-*:pnc1:primeregbma.c no negative compiler messages [2/2] +
-*:pnc1:primeregbma.c implements only specified algorithm [6/6] +
-*:pnc1:primeregbma.c consistent indentation and comments [4/4] +
-*:pnc1:primeregbma.c data and output conform to specifications [6/6] +
-*:pnc1:primeregbma.c make check runtime tests succeed [6/6] +
-*:pnc1:primeregbmoa.c performs proper argument checking [2/2] +
-*:pnc1:primeregbmoa.c no negative compiler messages [2/2] +
-*:pnc1:primeregbmoa.c implements only specified algorithm [6/6] +
-*:pnc1:primeregbmoa.c consistent indentation and comments [4/4] +
-*:pnc1:primeregbmoa.c data and output conform to specifications [6/6] +
-*:pnc1:primeregbmoa.c make check runtime tests succeed [6/6] +
-*:pnc1:primeregbmo.c performs proper argument checking [2/2] +
-*:pnc1:primeregbmo.c no negative compiler messages [2/2] +
-*:pnc1:primeregbmo.c implements only specified algorithm [6/6] +
-*:pnc1:primeregbmo.c consistent indentation and comments [4/4] +
-*:pnc1:primeregbmo.c data and output conform to specifications [6/6] +
-*:pnc1:primeregbmo.c make check runtime tests succeed [6/6] +
-*:pnc1:primeregbmos.c performs proper argument checking [2/2] +
-*:pnc1:primeregbmos.c no negative compiler messages [2/2] +
-*:pnc1:primeregbmos.c implements only specified algorithm [6/6] +
-*:pnc1:primeregbmos.c consistent indentation and comments [4/4] +
-*:pnc1:primeregbmos.c data and output conform to specifications [6/6] +
-*:pnc1:primeregbmos.c make check runtime tests succeed [6/6] +
-*:pnc1:primeregbms.c performs proper argument checking [2/2] +
-*:pnc1:primeregbms.c no negative compiler messages [2/2] +
-*:pnc1:primeregbms.c implements only specified algorithm [6/6] +
-*:pnc1:primeregbms.c consistent indentation and comments [4/4] +
-*:pnc1:primeregbms.c data and output conform to specifications [6/6] +
-*:pnc1:primeregbms.c make check runtime tests succeed [6/6] +
-*:pnc1:primeregboa.c performs proper argument checking [2/2] +
-*:pnc1:primeregboa.c no negative compiler messages [2/2] +
-*:pnc1:primeregboa.c implements only specified algorithm [6/6] +
-*:pnc1:primeregboa.c consistent indentation and comments [4/4] +
-*:pnc1:primeregboa.c data and output conform to specifications [6/6] +
-*:pnc1:primeregboa.c make check runtime tests succeed [6/6] +
-*:pnc1:primeregbos.c performs proper argument checking [2/2] +
-*:pnc1:primeregbos.c no negative compiler messages [2/2] +
-*:pnc1:primeregbos.c implements only specified algorithm [6/6] +
-*:pnc1:primeregbos.c consistent indentation and comments [4/4] +
-*:pnc1:primeregbos.c data and output conform to specifications [6/6] +
-*:pnc1:primeregbos.c make check runtime tests succeed [6/6] +
-*:pnc1:primeregma.c performs proper argument checking [2/2] +
-*:pnc1:primeregma.c no negative compiler messages [2/2] +
-*:pnc1:primeregma.c implements only specified algorithm [6/6] +
-*:pnc1:primeregma.c consistent indentation and comments [4/4] +
-*:pnc1:primeregma.c data and output conform to specifications [6/6] +
-*:pnc1:primeregma.c make check runtime tests succeed [6/6] +
-*:pnc1:primeregmoa.c performs proper argument checking [2/2] +
-*:pnc1:primeregmoa.c no negative compiler messages [2/2] +
-*:pnc1:primeregmoa.c implements only specified algorithm [6/6] +
-*:pnc1:primeregmoa.c consistent indentation and comments [4/4] +
-*:pnc1:primeregmoa.c data and output conform to specifications [6/6] +
-*:pnc1:primeregmoa.c make check runtime tests succeed [6/6] +
-*:pnc1:primeregmo.c performs proper argument checking [2/2] +
-*:pnc1:primeregmo.c no negative compiler messages [2/2] +
-*:pnc1:primeregmo.c implements only specified algorithm [6/6] +
-*:pnc1:primeregmo.c consistent indentation and comments [4/4] +
-*:pnc1:primeregmo.c data and output conform to specifications [6/6] +
-*:pnc1:primeregmo.c make check runtime tests succeed [6/6] +
-*:pnc1:primeregmos.c performs proper argument checking [2/2] +
-*:pnc1:primeregmos.c no negative compiler messages [2/2] +
-*:pnc1:primeregmos.c implements only specified algorithm [6/6] +
-*:pnc1:primeregmos.c consistent indentation and comments [4/4] +
-*:pnc1:primeregmos.c data and output conform to specifications [6/6] +
-*:pnc1:primeregmos.c make check runtime tests succeed [6/6] +
-*:pnc1:primeregms.c performs proper argument checking [2/2] +
-*:pnc1:primeregms.c no negative compiler messages [2/2] +
-*:pnc1:primeregms.c implements only specified algorithm [6/6] +
-*:pnc1:primeregms.c consistent indentation and comments [4/4] +
-*:pnc1:primeregms.c data and output conform to specifications [6/6] +
-*:pnc1:primeregms.c make check runtime tests succeed [6/6] +
-*:pnc1:primeregoa.c performs proper argument checking [2/2] +
-*:pnc1:primeregoa.c no negative compiler messages [2/2] +
-*:pnc1:primeregoa.c implements only specified algorithm [6/6] +
-*:pnc1:primeregoa.c consistent indentation and comments [4/4] +
-*:pnc1:primeregoa.c data and output conform to specifications [6/6] +
-*:pnc1:primeregoa.c make check runtime tests succeed [6/6] +
-*:pnc1:primeregos.c performs proper argument checking [2/2] +
-*:pnc1:primeregos.c no negative compiler messages [2/2] +
-*:pnc1:primeregos.c implements only specified algorithm [6/6] +
-*:pnc1:primeregos.c consistent indentation and comments [4/4] +
-*:pnc1:primeregos.c data and output conform to specifications [6/6] +
-*:pnc1:primeregos.c make check runtime tests succeed [6/6]+
 </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.1499978624.txt.gz · Last modified: 2017/07/13 20:43 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