Java to C programming assignment help

java files are in the Zip file. And need make a C file can do the same function. Then add some new function to it._x000D_
All the requirements are below._x000D_
_x000D_
PROGRAM REQUIREMENTS_x000D_
_x000D_
The program will read all lines from a text (ascii) file using the_x000D_
facilities of fgets for C (see "man fgets")._x000D_
_x000D_
The program should do exactly what graph.java does in the text appendix,_x000D_
except that you may (optionally) improve the appearance of the output._x000D_
You should be able to get the entire java program, including all_x000D_
ADTs, libraries, whatever, from AppendixCode.tar in Handouts._x000D_
Probably the Java program will run correctly with no changes._x000D_
_x000D_
The above READING section tells you where to find documentation on_x000D_
what graph.java does.  Trying to figure it out from the code only is not_x000D_
recommended._x000D_
_x000D_
This assigned program will use data structures that are different from_x000D_
graph.java.  Only the observable behavior is to be mimicked._x000D_
_x000D_
Most of this handout is about how to go about the assignment._x000D_
It does not repeat what is in the text appendix and other sections_x000D_
mentioned in READING above. It does not teach C._x000D_
_x000D_
We recommend that you work directly on your C program, using the_x000D_
text and possibly the Java code as a guide to expected behavior._x000D_
Do not try to convert from java line by line._x000D_
_x000D_
We'll follow the C convention of lowercase file names, but type names_x000D_
will remain capitalized._x000D_
_x000D_
Give your binary compiled C program the name graph01._x000D_
Your main source file should be named graph01.c._x000D_
_x000D_
Your source file that IMPLEMENTS the IntVec ADT should be named intVec.c._x000D_
The ADT header file is intVec.h, supplied in the class locker, a directory_x000D_
named cmps101-avg.  The complete path is given in the syllabus and on_x000D_
the class web page and later in this handout._x000D_
The file standardVec.txt in Handouts/ and in the course locker_x000D_
describes how "vector" ADTs are usually implemented in C._x000D_
_x000D_
(graph.java uses an IntList ADT, which is more flexible and simpler to_x000D_
implement, compared to the "vector" idea, but experience shows that_x000D_
the IntList approach is less efficient on modern hardware.)_x000D_
_x000D_
Reading input in C is trickier than it sounds, so don't wait too long to_x000D_
get started.  As a C program, this is a pretty simple warm-up to get some_x000D_
routines in place that you will need later.  Also, there is a lot to do_x000D_
besides write C code._x000D_
_x000D_
==========================================================================_x000D_
_x000D_
COMMAND-LINE ARGUMENTS_x000D_
_x000D_
If your program receives no command-line arguments, it should print_x000D_
a usage message on stderr using fprintf() and exit 0._x000D_
_x000D_
Note that the Unix convention is that an exit code of 0 means_x000D_
"normal completion" and non-zero exit codes denote various errors._x000D_
The exit code of 0 is established by "return 0" from main() or by calling_x000D_
exit(0) anywhere.  Similarly, non-zero codes may be established._x000D_
_x000D_
Command-line arguments of the form "-something" are often called "flags",_x000D_
and provide the means for varying the way the program runs,_x000D_
or varying the form of the output.  ("-" by itself denotes stdin.)_x000D_
This assignment does not require flags._x000D_
_x000D_
The final command-line argument is the name of the  input file,_x000D_
and this name will not begin with a "-" unless it is "-" by itself._x000D_
_x000D_
If the program has command-line arguments but cannot get the file name_x000D_
from the command line or cannot open the input file,_x000D_
then a non-zero exit code should be returned._x000D_
_x000D_
==========================================================================_x000D_
_x000D_
INPUT FORMAT_x000D_
_x000D_
Input consists of a sequence of lines on ``standard input'' or in_x000D_
an ascii file (also called text file)._x000D_
The line formats are as described in the text appendix for graph.java._x000D_
_x000D_
Standard input is called stdin for C.  stdin is of type FILE *._x000D_
_x000D_
End-of-file signals the end of input, and is typed on the keyboard_x000D_
as cntl-D in Unix (Linux is Unix; maybe cntl-Z in DOS, Windows, etc.)._x000D_
Disk files do not need an End-of-file character, though._x000D_
_x000D_
Part of the assignment is to create a set of useful test files on disk._x000D_
We do NOT supply a thorough set of test files._x000D_
_x000D_
In the course locker (see below) gr01_test1.in is an example input._x000D_
It contains:_x000D_
8_x000D_
6 1 2.2_x000D_
1 2 1.0_x000D_
4 3_x000D_
1 3_x000D_
4 5 1.2_x000D_
2 4 0.0_x000D_
5 2_x000D_
6 6_x000D_
3 4_x000D_
_x000D_
Line 1 has a single positive int (8 in this case) that tells you the_x000D_
input may contain vertices in the range 1-8 (not 0)._x000D_
_x000D_
Each subsequent line defines one directed edge.  The first two ints_x000D_
are vertices usually named "from" and "to"._x000D_
The third number, if present, states the weight or cost of that edge._x000D_
If there is no third number, the edge weight is 0.0.  weights are doubles._x000D_
_x000D_
==========================================================================_x000D_
_x000D_
OUTPUT FORMAT_x000D_
_x000D_
Running graph.java on example inputs is the easiest way to see the_x000D_
expected output format.  What is most important is that the correct NUMBERs_x000D_
in the correct sequence appear on each line.  The punctuation like commas_x000D_
and brackets is for human readability._x000D_
_x000D_
A common convention in programming languages is that lists print as_x000D_
[4, 5, 1] for a list whose first element is 4, etc. [] is the empty list._x000D_
For this assignment the entire list should print on a single line._x000D_
_x000D_
When you run graph.java you will notice that a number appears on each_x000D_
line BEFORE the list.  That is explained in the reading material._x000D_
_x000D_
When you run graph.java you will notice that weights do not appear in the_x000D_
output.  For this assignment the weights are read if present, and stored_x000D_
temporarily, but are not stored in the permanent graph data structure._x000D_
Later assignments will use weights._x000D_
_x000D_
PRINT AN INFORMATIVE ERROR MESSAGE on stderr if the input contains a bad vertex_x000D_
number, outside 1,...,n, or has the wrong number of words on a line._x000D_
This is for your own protection.  It is not a grading issue and_x000D_
submitting a lot of tests to check bad input is not asked or desired,_x000D_
and does not gain credit._x000D_
_x000D_
==========================================================================_x000D_
_x000D_
INFORMATION SOURCES_x000D_
_x000D_
All code in the Appendix is on-line, and it worked when it was created,_x000D_
but java might have evolved.  The subset of Java used is described in Ch. 1.2_x000D_
(8 pp.) and the Appendix of the text.  See READING above._x000D_
You should be able to see the general logic of the program by looking at_x000D_
this code, but many details will not translate literally._x000D_
_x000D_
As advised in ho01.pdf (the first handout), to easily access the locker_x000D_
set up this symbolic link (colloquially called "soft link" or "s-link")_x000D_
in any directory that you are working in:_x000D_
_x000D_
    ln -s /afs/cats.ucsc.edu/courses/cmps101-avg ._x000D_
_x000D_
Don't forget the final dot, preceded by a space. ^^^_x000D_
If this does not work due to file-sytem changes, another form is:_x000D_
_x000D_
    ln -s ~avg/cmps101-avg ._x000D_
_x000D_
This points to my symbolic link._x000D_
_x000D_
After this command, cmps101-avg appears to be a subdirectory, so you can_x000D_
do "pushd cmps101-avg" and you are in the course locker._x000D_
_x000D_
Then you can do "popd" and you are back where you came from._x000D_
_x000D_
Or you can do "pushd" again while in cmps101-avg._x000D_
That command puts you back where you came from, and cmps101-avg_x000D_
is remembered on the directory stack.  This might sound confusing,_x000D_
but just try it and you will see what happens._x000D_
Use "pwd" to check what your current working directory is._x000D_
_x000D_
Notice that "cd cmps101-avg" would get you into cmps101-avg, but then_x000D_
"cd .." would NOT bring you back where you came from._x000D_
So learn "pushd" by reading "man pushd" and get in the habit of using it._x000D_
_x000D_
AppendixCode and Supplements are subdirectories in the course locker._x000D_
_x000D_
There are usually quite a few questions and clarifications about programs_x000D_
on the "C101" mailing list, so keep up.  Consider the source when_x000D_
evaluating a message, because there is no screening of the postings._x000D_
_x000D_
The class web page and the syllabus handout have a lot of "orientation"_x000D_
information.  Check them if you see things whose meaning is not clear._x000D_
_x000D_
==========================================================================_x000D_
_x000D_
WORDS AND DELIMITERS_x000D_
_x000D_
In C, allocate a character array larger than you expect to need_x000D_
(e.g., 2000 characters).  Say you call this array "inbuff"._x000D_
_x000D_
Use fgets to get ONE input line into it._x000D_
See javaToC.pdf for more details._x000D_
Use the search function in pdf to find the fgets discussion._x000D_
_x000D_
There are several ways to extract words from that line._x000D_
javaToC.pdf gives a straightforward method using sscanf()._x000D_
It relies on knowing the expected format of one line, which is our case._x000D_
An appendix in javaToC.pdf describes an overly general, complicated approach,_x000D_
based on strtok_r() and strdup().  DO NOT use these functions for this class._x000D_
_x000D_
For this assignment we will use sscanf() to get the words out of the_x000D_
input line as stored in "inbuff" by fgets()._x000D_
_x000D_
The simplest, and quite common case is that you expect a specific_x000D_
sequence of words to be on the line.  Then one sscanf() call can extract_x000D_
the expected words, and its return code can be checked to see how many_x000D_
words were successfully extracted._x000D_
Assume these declarations_x000D_
_x000D_
    int p, q;_x000D_
    double wgt;_x000D_
    char junk;_x000D_
    int sscanfRetn;_x000D_
_x000D_
The call might be_x000D_
_x000D_
    sscanfRetn = sscanf(inbuff, " %d %d %lf %c ", &p, &q, &wgt, &junk);_x000D_
_x000D_
Note the spaces between the quotes._x000D_
_x000D_
If you are expecting a weighted graph, sscanfRetn should be 3;_x000D_
for an unweighted graph sscanfRetn should be 2; and any other_x000D_
value indicates the line is not formatted as expected._x000D_
_x000D_
This assignment expects a weighted graph, but does not use the weight_x000D_
and permits zero weights to be omitted._x000D_
The function parseEdge() in the AppendixCode should be imitated, as it_x000D_
extracts both weighted and unweighted edges.  In C, parseEdge() should_x000D_
return a struct as shown in javaToC.pdf._x000D_
_x000D_
==========================================================================_x000D_
_x000D_
HOW TO PROCEED_x000D_
_x000D_
Find the AppendixCode directory and make a soft link to it (ln -s ...),_x000D_
to make it easier to find again.  Become familiar with what files are_x000D_
there._x000D_
_x000D_
Copy any java files that look useful to your own directory._x000D_
They are all mentioned in the text appendix discussion of graph.java._x000D_
They might help as starters even if you are working in C._x000D_
_x000D_
(Note that ho05.txt has Unix commands and editor skills that you are_x000D_
expected to have to do this class work.  Take a look at that if you see_x000D_
terms that are unfamiliar in the ensuing discussion.  TAs will help_x000D_
you brush up EARLY in the quarter; then we expect you to be up to speed.)_x000D_
_x000D_
Make up several small test files, following the format described above, and_x000D_
in the text appendix for graph.java.  Try to test a wide variety of_x000D_
conditions in the input.  In your README file, state what each test file_x000D_
is testing for.  It is best to do this BEFORE running your tests._x000D_
Then you can go back and compare what you got with what you expected,_x000D_
and try to resolve discrepancies._x000D_
_x000D_
To run graph.java you need to compile it first with javac, together with_x000D_
the associated java files it calls, in your own directory._x000D_
We assume students learned this in a beginning course; if not,_x000D_
Appendix A.1 gives some URLs that may be obsolete, but there are many_x000D_
other sources.  After compiling, type_x000D_
_x000D_
    java graph mytest1.in_x000D_
_x000D_
to run the compiled program.  Making a jar file is not necessary. 

Keep it simple.

PROGRAM REQUIREMENTS

This program (named graph02) will perform the same functions as pa01,_x000D_
plus some new functions, once the input graph is loaded._x000D_
_x000D_
Give your binary compiled C program the name graph02._x000D_
Your main source file should be named graph02.c._x000D_
Your source file that IMPLEMENTS the IntVec ADT should be named intVec.c._x000D_
The ADT header file is intVec.h, supplied in the class locker, a directory_x000D_
named cmps101-avg.  The complete path is given in the syllabus and on_x000D_
the class web page and in ho04.txt._x000D_
_x000D_
In this assignment, your intVec.o will be tested with_x000D_
other students' programs and their intVec.o will be tested with_x000D_
yours.  So use the standard names in this class._x000D_
_x000D_
A starter intVec.h is in the course locker, but you should replace the_x000D_
questions with your own comments.  It is unchanged from pa01._x000D_
_x000D_
graph01.c, etc.,_x000D_
can be used right from pa01, except that the "main" procedure_x000D_
will be changed to check for some command-line flags and_x000D_
call different procedures depending on whether the input file is to be_x000D_
interpreted as a directed or undirected graph._x000D_
Thus, the loadGraph functionality will be separated if it has not_x000D_
been separated in an earlier assignment.  See HOW TO PROCEED below_x000D_
for more details._x000D_
_x000D_
Allocating all the arrays in graph02.c makes it easier to pass them as_x000D_
arguments to functions in other files, without making any global arrays._x000D_
However, if you already have working code that allocates and returns_x000D_
an array from a different file (such as loadGraph.c),_x000D_
it is okay to use and build upon that code._x000D_
_x000D_
Aside from intVec.h, intVec.c, graph02.c and graph02,_x000D_
the names of files, functions and arrays should be understandable but_x000D_
do not need to be strictly the same as this handout._x000D_
_x000D_
==========================================================================_x000D_
COMMAND-LINE ARGUMENTS_x000D_
_x000D_
If your program receives no command-line arguments, it should print_x000D_
a usage message and exit with return code 0._x000D_
_x000D_
Command-line arguments of the form "-something" are often called "flags",_x000D_
and provide the means for varying the way the program runs,_x000D_
or varying the form of the output.  ("-" by itself denotes stdin.)_x000D_
_x000D_
The final command-line argument is the name of the  input file,_x000D_
and this name will not begin with a "-" unless it is "-" by itself._x000D_
_x000D_
The command-line flag "-U" instructs the program to build the_x000D_
UNdirected unweighted graph from the input using ADT IntVec._x000D_
_x000D_
If the command-line arguments do not make sense or the file cannot be read,_x000D_
print an error message on stderr (use fprintf(stderr, ...)) and exit with code 1 or 2._x000D_
_x000D_
Note that the Unix convention is that an exit code of 0 means_x000D_
"normal completion" and non-zero exit codes denote various errors._x000D_
The exit code of 0 is established by "return 0" from main() or by calling_x000D_
exit(0) anywhere.  Similarly, non-zero codes may be established._x000D_
_x000D_
==========================================================================_x000D_
INPUT FORMAT_x000D_
_x000D_
Just like pa01; see ho04.txt and related mailing list messages._x000D_
_x000D_
In the class locker (see below) gr01_test1.in is an example input._x000D_
_x000D_
It is NOT an error to have duplicate edges; just load them all._x000D_
_x000D_
OUTPUT FORMAT_x000D_
_x000D_
Print information on stdout._x000D_
_x000D_
The first part is just like pa01.  See ho04.txt and related mailing list messages._x000D_
The "array of adjacency lists" data structure is printed,_x000D_
followed by at least one blank line to separate it from the following parts._x000D_
_x000D_
A common convention in programming languages is that lists print as_x000D_
[4, 5, 1] for a list whose first element is 4, etc. [] is the empty list._x000D_
For this assignment the entire list should print on a single line._x000D_
_x000D_
When you run graph.java you will notice that a number appears on each_x000D_
line BEFORE the list.  That is explained in the reading material._x000D_
_x000D_
Although the program is using the IntVec ADT, you want the order to be the same_x000D_
as it WOULD BE if the IntList ADT as specified in the text were used._x000D_
_x000D_
PRINT AN INFORMATIVE ERROR MESSAGE if the input contains a bad vertex_x000D_
number, outside 1,...,n, or has the wrong number of words on a line._x000D_
This is for your own protection.  It is not a grading issue and_x000D_
submitting a lot of tests to check bad input is not asked or desired._x000D_
_x000D_
Example 1 input, unweighted_x000D_
_x000D_
6_x000D_
1 4_x000D_
5 4_x000D_
1 3_x000D_
2 3_x000D_
3 3_x000D_
5 6_x000D_
6 5_x000D_
4 3_x000D_
1 2_x000D_
_x000D_
Example 2, with weights:_x000D_
6_x000D_
1 3 2.7_x000D_
5 4 -3_x000D_
1 5 0.0_x000D_
1 4 0.0_x000D_
_x000D_
The weights should be parsed to prepare for future programs, but they_x000D_
are not entered into the data structure for the graph._x000D_
_x000D_
Remember that graphs want to start on index 1, not index 0._x000D_
So allocate 1 extra space in the arrays and start loading at 1._x000D_
_x000D_
Do not worry if edges are not unique.  The algorithms will work anyway._x000D_
_x000D_
Example 2 output would look something like this for the array of adjacency lists:_x000D_
    1  [4, 5, 3]_x000D_
    2  []_x000D_
    3  []_x000D_
    4  []_x000D_
    5  [4]_x000D_
    6  []_x000D_
_x000D_
Remember, the punctuation can be to taste, but the numbers should be_x000D_
in the same order as shown, line by line._x000D_
_x000D_
When running the program on a large input file remember to use ">"_x000D_
to redirect the stdout to a file.  DO NOT SUBMIT VERY LARGE TEST FILES_x000D_
OR THEIR OUTPUTS.  We will supply some large files._x000D_
_x000D_
When printing an adjacency matrix, print a line above it to show the second index_x000D_
and print the first index before the matrix row contents.  Make things line up_x000D_
correctly for human readability.  Learn how to use things like "%3d" in printf_x000D_
to do that._x000D_
_x000D_
Example 2 output should look something like this for the adjacency matrix:_x000D_
_x000D_
         1  2  3  4  5  6_x000D_
       ------------------_x000D_
    1 :  0  0  1  1  1  0_x000D_
    2 :  0  0  0  0  0  0_x000D_
    3 :  0  0  0  0  0  0_x000D_
    4 :  0  0  0  0  0  0_x000D_
    5 :  0  0  0  1  0  0_x000D_
    6 :  0  0  0  0  0  0_x000D_
_x000D_
As stated later, if n > 20, do not print the adjacency matrix._x000D_
_x000D_
==========================================================================_x000D_
_x000D_
STANDARD VEC DATA STRUCTURE_x000D_
_x000D_
See ho04.txt and related mailing-list messages._x000D_
_x000D_
==========================================================================_x000D_
_x000D_
HOW TO PROCEED_x000D_
_x000D_
Make a new directory to work in.  Do this first._x000D_
Assuming pa01 was in pretty good shape, copy those files into your_x000D_
new directory as starters for pa02._x000D_
UPDATING files from a previous assignment is VERY BAD practice._x000D_
Copy them to a new directory and work in the new directory._x000D_
_x000D_
If your pa01 was incomplete, you might need to refer to ho04.txt_x000D_
for how to complete it.  This file does not repeat that information._x000D_
_x000D_
YOU NEED TO USE THE STANDARD NAMES GIVEN IN THIS SECTION so your ADTs_x000D_
can interface with other students' clients and vice versa._x000D_
_x000D_
The function names in the intVec ADT must be as given in the intVec.h_x000D_
starter file for pa01._x000D_
_x000D_
These names must be spelled and capitalized as shown in that file._x000D_
_x000D_
For this program, loadGraph.c should be a separate file, although that_x000D_
was not required before.  loadGraph.h will provide the interface._x000D_
Functions in loadGraph.c that are only called WITHIN loadGraph.c should NOT_x000D_
appear in loadGraph.h._x000D_
_x000D_
loadGraph is NOT required to be an ADT, so the functions and prototypes_x000D_
do not need to agree with other students._x000D_
_x000D_
NEW OR MODIFIED FUNCTION: adding undirected edges_x000D_
_x000D_
When the -U flag is specified each line after the first defines TWO edges_x000D_
in the "array of adjacency lists" structure: (from, to) AND (to, from), both_x000D_
with the same weight._x000D_
_x000D_
NEW FUNCTION: makeAdjMatrix()_x000D_
_x000D_
Write a function to create the adjacency matrix that corresponds to an_x000D_
"array of adjacency lists" data structure, which it takes as a parameter._x000D_
The adjacency matrix should be an (n+1)X(n+1) 2-D array in C.  Index 0 is not used_x000D_
but is allocated by the rules of C._x000D_
The type is "int * *" in C.  It should NOT use IntVec because all sizes are known_x000D_
when construction starts._x000D_
_x000D_
It may be implemented in loadGraph.c or in a separate file._x000D_
_x000D_
NEW FUNCTION: transposeGraph()_x000D_
_x000D_
Write a function to transpose a graph, after it is built._x000D_
_x000D_
Make your function as simple as you can to be sure it is correct._x000D_
There is a fast way to do this, but if you do not see it, think of a_x000D_
simpler, possibly slower, way._x000D_
_x000D_
For C the function prototype is_x000D_
_x000D_
        IntVec* transposeGraph(IntVec* origGraph, int n);_x000D_
_x000D_
It may be implemented in loadGraph.c or in a separate file._x000D_
_x000D_
The transpose graph has edges in the opposite direction of the_x000D_
original graph, in one-to-one correspondence._x000D_
Suppose the original graph prints like this_x000D_
_x000D_
        1  [ 3, 2 ]_x000D_
        2  [ 3, 4 ]_x000D_
        3  [ ]_x000D_
        4  [ 1 ]_x000D_
_x000D_
The transpose graph should have edges (2,1), (3,1), (4,2), (3,2), (1,4),_x000D_
and print accordingly.  Most likely it would appear as_x000D_
_x000D_
        1  [ 4 ]_x000D_
        2  [ 1 ]_x000D_
        3  [ 2, 1 ]_x000D_
        4  [ 1 ]_x000D_
_x000D_
but other orders are possible._x000D_
See the text for more details. if needed._x000D_
_x000D_
NEW FUNCTIONS: printAdjVerts() and printAdjMatrix()_x000D_
_x000D_
If you had printAdjVerts() in pa01 you need to make sure it takes the graph data structure_x000D_
(array of adjacency lists) as a parameter so it can print various graphs._x000D_
If you did not have printAdjVerts() in pa01, make that function for pa02._x000D_
See OUTPUT FORMAT above for details._x000D_
_x000D_
Print the transpose graph in the same format as the original graph._x000D_
The same print function should work for both (the title can be printed_x000D_
before calling the function or passed as a parameter)._x000D_
_x000D_
printAdjMatrix() takes the matrix to be printed as a parameter so it can print_x000D_
various matrices created by makeAdjMatrix().  See OUTPUT FORMAT above for details._x000D_
_x000D_
Print functions may be implemented in loadGraph.c or in a separate file._x000D_
The spelling can vary as long as the purpose is recognizable.  Be sure you get_x000D_
the prototypes in the appropriate .h file._x000D_
_x000D_
OVERALL REQUIREMENT:_x000D_
_x000D_
Call the main program graph02.c._x000D_
Do you need a graph02.h too?  Why or why not?_x000D_
Hint: Think about the command-line flags like -U._x000D_
Do you want to "share" this value or pass it to all functions?_x000D_
Both decisions have merit, but stick to one or the other._x000D_
_x000D_
The function main() will guide the program through the following sequence:_x000D_
_x000D_
    Read input file setting up original array of adjacency lists;_x000D_
    Print original array of adjacency lists;_x000D_
    makeAdjMatrix() on original array of adjacency lists;_x000D_
    printAdjMatrix() IF n <= 20 on original array of adjacency lists;_x000D_
_x000D_
    transposeGraph() on original array of adjacency lists giving_x000D_
        transposed array of adjacency lists;_x000D_
    Print transposed array of adjacency lists;_x000D_
    makeAdjMatrix() on transposed array of adjacency lists;_x000D_
    printAdjMatrix() IF n <= 20 on transposed array of adjacency lists;_x000D_
_x000D_
    transposeGraph() on transposed array of adjacency lists giving_x000D_
        twice-transposed array of adjacency lists;_x000D_
    Print twice-transposed array of adjacency lists;_x000D_
    makeAdjMatrix() on twice-transposed array of adjacency lists;_x000D_
    printAdjMatrix() IF n <= 20 on twice-transposed array of adjacency lists;_x000D_
_x000D_
Do you observe anything interesting by comparing original array of adjacency lists_x000D_
and twice-transposed array of adjacency lists?_x000D_
What about the matrices?_x000D_
Mention observations in your README._x000D_
_x000D_
==========================================================================_x000D_
_x000D_
SUBMITTING_x000D_
_x000D_
The assignment name is pa02.  An example (but incomplete) submit command is:_x000D_
_x000D_
	submit cmps101-avg.s17 pa02  graph02.c  intVec.c README  Makefile_x000D_
_x000D_
Submit ALL the work you want to be considered for grading, but DO NOT SUBMIT_x000D_
files produced by compilers, such as *.o and binaries._x000D_
Also, DO NOT SUBMIT VERY LARGE TEST FILES OR THEIR OUTPUTS._x000D_
_x000D_
You can list as many files as you want to submit.  If you update files,_x000D_
just submit them again.  Don't resubmit unchanged files needlessly._x000D_
_x000D_
Simply typing "make" should compile your program, creating a binary_x000D_
named after the main program, graph02._x000D_
To accomplish this, simply list graph02 as the first "target" in Makefile._x000D_
_x000D_
Your Makefile should have an entry for each file that needs to be compiled._x000D_
A "generic" that just compiles everything it can find will lose credit._x000D_
The example mentioned in pa01 is a guide.  It is in the CMake directory._x000D_
_x000D_
You should understand your own Makefile._x000D_
Do not use fancy features, as the grading script will not_x000D_
recognize that you understand Makefile structure._x000D_
_x000D_
Submit a README that includes the certification mentioned at the beginning of_x000D_
this file, then briefly describes your program with a few sentences,_x000D_
mainly to tell the reader how to compile it, how to run it,_x000D_
what test inputs and outputs you supplied, any known bugs._x000D_
If the purpose of some files might be mysterious, here is the place to_x000D_
explain them._x000D_
_x000D_
==========================================================================_x000D_
_x000D_
PROGRAMMING STANDARDS_x000D_
_x000D_
All code to be graded should follow good style practices including_x000D_
appropriate indentation, descriptive names, consistent capitalization,_x000D_
and useful comments.  Comments should indicate the purpose, preconditions,_x000D_
and postconditions of important procedures.  Avoid comments of_x000D_
self-explanatory code.  The reader may grade your program low_x000D_
if it is sloppily done, making it hard to understand or follow._x000D_
RESPECT THE READER'S TIME._x000D_

Do you need help with this or a different assignment? Even when your task is complicated and the deadline is in less than 2 days, you still have every chance to get a good grade for it. How? By completing the order form, you will get the finest custom-written assignment at an affordable price. We also deliver a number of services for free (e.g., revisions, editing, checking the text for authenticity). Use our paper writing service to receive effective help with your homework.

Order a Similar Paper Order a Different Paper