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.
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 _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_