Classes on John Bowers

Programming Fundamentals (CS 139)

Thu, 20 Aug 2015 10:55:38 -0400

CS240

Thu, 20 Aug 2015 10:55:33 -0400

This is the course website for the Fall 2015 offering of CS 240 (Algorithms and Datastructures) taught by John Bowers (i.e. Sec. 03).

Welcome!

The class meets MWF 11:15-12:05 in ISAT 243 or ISAT 248 starting August 31 and ending December 11. Please visit the calendar for a detailed schedule.

My office hours are posted on my teaching page.

I am available outside of office hours by appointment. Please send me an email with several candidate times to meet and I will do my best to accomodate.

News and Updates!

Note that Lecture 2 is in the Mac lab, ISAT 248.
Lecture 1 slides are posted!

Course Links

Piazza

This semester we are using Piazza for class discussions and announcements. If you have questions during this course, I encourage you to post them to Piazza rather than emailing me directly. If you email me directly a question that I think may be of general interest, you should expect a “please post this question to Piazza and I’ll answer it” response. I believe that using Piazza as the primary means of electronic communication is a value-add for everyone in the course, since you can sometimes get responses back faster from other students (especially the night before things are due) and everyone benefits from my responses.

Class Grades & Quizzes

Class grades and quizzes are accessible in Canvas.

Syllabus

Thu, 20 Aug 2015 11:13:50 -0400

Objectives and Expectations

The goal of this course is to become proficient in using and analyzing basic data structures and algorithms. By the end of the course, you should be able to do the following:

Develop programs in a non-Java language (in this case, C) utilizing common data structures, modular/reusable patterns, memory management strategies, and error handling.
Describe, explain, and use an abstract container framework that includes stacks, queues, lists, sets, and maps.
Implement the containers in the container framework using contiguous or linked data structures. Contiguous data structures include arrays and hash tables, and linked data structures include linked lists and binary trees.
Implement searching algorithms, including linear search and binary search.
Implement a variety of sorting algorithms, including insertion sort, selection sort, merge sort, quick sort, and heap sort.
Read and write recursive algorithms, analyze recursion, and remove recursion when appropriate.
Implement tree traversal algorithms as well as binary search tree insertion, deletion, and search algorithms.
Implement hash tables using chaining or open addressing for collision resolution.
State the asymptotic running times of the algorithms and data structure operations studied in this course, and explain the practical behavior of algorithms with various asymptotic running times.

Course Textbook

Open Data Structures by Pat Morin

We will be using an open-source textbook this semester. The compiled text itself as well as all of its source materials (in LaTeX and various other languages) are available on the textbook website. We will be using the pseudocode version. The textbook is required for the course, so I highly recommend obtaining a printed copy. You have several options for doing so:

We have arranged with the campus bookstore to sell a “coursepack” consisting of a coil-bound, landscape printout of the pdf (four PDF pages per 8.5” x 11” sheet). The cost should be $17.39. This is the recommended option for conveniency.
We have uploaded the PDF to a web-based printing service, and you may order a 6” x 9” paperbound copy from the product page if you prefer a more traditionally-bound book. The cost is $5.61 plus shipping. I recommend ordering early because it takes 2-3 weeks to print and ship your copy.
You may print it yourself using your own equipment or a standard print center such as FedEx. This could end up being more expensive that the other two options, but if you already have an established account at such a business, you may find it more convenient.

We will also be using excerpts from other resources as needed, such as the Mathematics for Computer Science online textbook by Eric Lehman, F. Thomson Leighton, and Albert R. Meyer.

Grading Criteria

You are responsible for all material discussed in lecture and discussion section and posted on the class web page, including announcements, deadlines, policies, etc.

Your final course grade will be determined according to the following percentages:

Quizzes and Homeworks	30%
Programming Projects	25%
Midterm Exams	30%
Final Exam	15%

Final course letter grades may be curved if necessary at the end of the semester, based on each student’s overall performance for all coursework.

If you believe I have made an error while grading your work or calculating your final score, please bring it to my attention after class or during office hours. If I determine that there has been a simple mistake, I will fix it immediately and no formal request is necessary.

If you believe an exam question or assignment has been graded unfairly, you must submit a verbal or written formal request for a regrade. Such requests must be submitted within one week of when the assignment in question is returned to you. Any coursework submitted for reconsideration may be regraded in its entirety, which could result in a lower score if warranted.

Completing the programming assignments is an essential part of the course. Therefore, I reserve the right to fail any student who does not make a good-faith attempt on all course projects, regardless of the student’s performance or scores on the other coursework.

Instructor Contact Info

Please post generic questions to Piazza, where other students may answer and/or benefit from my answers. My email is bowersjc at the standard domain. My office is in ISAT 217, and my office hours are posted on my teaching page.

I am also sometimes available outside office hours by appointment; if you wish to make an appointment, please email me several candidate times that work for you and I will do my best to accommodate.

Course Policies

Important announcements will be made in class and/or on Piazza. Please make it a habit to check Piazza daily.

Although every effort has been made to be complete and accurate, unforeseen circumstances arising during the semester could require the adjustment of any material given here. Consequently, given due notice to students, I reserve the right to change any information on this syllabus or in other course materials.

You are permitted to use course materials for your own personal use only. Course materials may not be distributed publicly or provided to others (excepting other students in the course), in any way or format unless explicitly allowed.

Attendance and Participation

I view your time as valuable, and my goal as a teacher is to make class attendance and participation well worth your time investment. Though I will not take attendance in this course, I strongly encourage you to attend every class session and participate fully in order to derive the maximum benefit of this course. If you believe that there is something I could change about the way I am handling the course in order to improve its effectiveness for you, please let me know via email or office hours.

Please Note: I do occasionally give graded quizzes or graded group work assignments during class periods without advance notice.*

Please silence your cell phone while class is in session. If you have a laptop or tablet, you are encouraged to bring it to class and use it to work along with programming examples and exercises. Mute the volume to avoid unintended interruptions, and do not use any electronic devices for activities that may distract other students. Repeated violations of this policy may result in disciplinary action or a grade penalty in the course.

I strongly encourage you to check the main website and the Piazza web forum regularly for important announcements (usually regarding programming projects). You may also use the Piazza forum to ask general questions of interest to the class as a whole (e.g., administrative issues or project clarification questions) as well as to offer each other general advice on class assignments. However, do not post any information that would violate the university academic integrity policy. If you are unsure about this, please email me for approval before you post.

Programming Projects

Projects must be submitted electronically following the instructions given in class and on the website. Projects may not be submitted by any other means (e.g., do not email your projects to me unless I request that). It is your responsibility to test your program and verify that it works properly before submitting it.

All projects are due at 23:59 (11:59pm) on the day indicated on the project assignment unless noted otherwise.

Projects may be submitted up to 72 hours late for a 10% penalty per 24-hour period. For example, a submission that would have earned 90 points in an on-time submission will earn 90 x 0.90 = 81 points if submitted up to 24 hours late, or 90 x 0.80 = 72 points if submitted up to 48 hours late. If you make multiple submissions, I will typically grade the latest submission. If you wish me to grade a different submission, you must indicate this before the 72-hour late period is over.

Regardless of the above policy, I reserve the right to refuse to grade any projects submitted after the beginning of the second class period following the project deadline, because I may discuss the solution in class.

Project extensions will not necessarily be granted due to server congestion, system problems, network problems, power outages, etc., so do not wait to submit a project until the night it is due. No consideration in grading will be made for errors made in transferring files or submitting the wrong version of your project. Having a working, non-submitted version will not count; only submitted code will be be counted.

You are responsible for developing your own techniques for testing your projects before submitting it. I will grade your projects based on test cases not provided to you in advance. Because grading may be done automatically, you must follow the project specification exactly.

Your code will be graded on a combination of correctness, completeness, documentation, and code style.

Any “hard coding” in a project assignment will result in a score of zero for that project, and is considered a bad-faith effort. Hard coding refers to attempting to make a program appear as if it works correctly, when in fact it does not. One example of hard coding would be printing the desired output instead of computing it. If you have any questions as to what constitutes hard coding for a particular assignment, be sure to ask ahead of time.

Adding and Dropping the Course

Students are responsible for adding and dropping courses. Please consult the appropriate academic calendar for the exact deadlines. I will not give “WP” or “WF” grades to students requesting a drop after the deadline except in extraordinary circumstances.

Academic Honesty

You are expected to comply with the JMU Honor Code as stated in the Student Handbook and available from the Honor Council website on all assignments, projects, and exams.

Consulting with other students about problems and solutions is not necessarily a violation of the honor code, depending on the particular assignment. All final work turned in for an assignment must be your own unless it is a group project. In particular, you may not share source or binary code on programming assignments unless the project specification explicitly allows it. If you are in doubt about whether something is an honor code violation, please contact me immediately.

If I find evidence of a violation of the honor code, I will bring the matter to the attention of the involved individuals via email and request a face-to-face meeting. As per section IV of the honor code, first time student offenders may agree that a violation has occurred and accept an appropriate penalty by submitting an “Informal Resolution Agreement Form” to the honor council. If the student is not a first-time offender or if there is disagreement about the violation or penalty, the matter will be refered to the honor council under section V of the honor code.

Disability Accommodations

If you need an accommodation based on the impact of a disability, you must contact the Office of Disability Services if you have not previously done so. Disability Services will provide you with an Access Plan letter that will verify your need for services and make recommendations for accommodations to be used in the classroom. Once you have shown me this letter, we will sit down and review the course requirements, your disability characteristics, and your requested accommodations to develop an individualized plan appropriate for this course. I will not make any accommodations without the appropriate documentation, as I am not qualified to diagnose disabilities.

Excused Absences

Besides the policies in this syllabus, the University’s policies apply during the semester. Various policies that may be relevant appear in the Undergraduate Catalog.

Excused absences will be granted at my discretion and only with appropriate documentation. Please contact me as soon as possible if you wish to request an excused absence.

Missing an exam for reasons such as illness, religious observance, participation in required university activities, or family or personal emergency (such as a serious automobile accident or the funeral of a close relative) all are circumstances that may qualify as an excused absence. However, you must provide documentation that the absence qualifies as excused. I will arrange a makeup exam or substitute assignment at my discretion.

The policies for excused absences do not apply to in-class activities (which cannot be made up) or project assignments. Projects will be assigned with sufficient time to be completed by students who have a reasonable understanding of the necessary material and begin promptly. In cases of extremely serious documented illness of lengthy duration or other protracted, severe emergency situations, I may consider extensions on project assignments depending upon the specific circumstances. Please contact me as early as possible if you believe you will need such an extension.

Inclement Weather

This class will operate in accord with JMU’s official cancellation policy.

Catalog Description

Students learn to implement and analyze elementary data structures and the basic complexity classes of algorithms that use strategies such as greedy algorithms, divide-and-conquer algorithms and backtracking algorithms. This analysis is especially applied to problems in searching, sorting and parsing.

Prerequisites: Grades of “C-” or better in CS/MATH 227, MATH 231 or equivalent and either CS 159 or CS 239.

Section: 0003
Instructor: Dr. John Bowers
Credits: 3

Calendar

Thu, 20 Aug 2015 11:13:15 -0400

Note: Calendar is always subject to change. Please check regularly for updates.

Unless explicitly marked, all class periods will be held in ISAT 243 and labs will be held in ISAT 248. Unless noted otherwise, all readings are from the class textbook. Unless noted otherwise, all quizzes will be given on Canvas, and all homeworks (HWs) and programming assignments (PAs) will be posted on the assignments page.

Calendar

August
Su	M	Tu	W	Th	F	Sa
30	31 Intro Reading: Ch. 1 (through 1.2) [slides]
September
Su	M	Tu	W	Th	F	Sa
		1	2 Lab: GCC and Make UUG Linux InstallFest (7pm in ISAT/CS 259)	3	4 Lab: Basic C ACM Competitive Programming Club (2:30pm every Friday in ISAT/CS 143)	5
6	7 Lab: Arrays & Strings	8 Deadline to drop class UUG Linux InstallFest (7pm in ISAT/CS 259)	9 Lab: Structs	10	11 Lab: Testing PA 0 due	12
13	14 Lab: Pointers	15	16 Lab: Debugging	17	18 Algorithm Analysis Reading: 1.3-1.5 HW 1 due	19
20	21 Algorithm Analysis	22	23 Dynamic Arrays	24	25 Lab: Dynamic Arrays PA 1 due	26
27	28 Stacks & Queues	29	30 Lab: Stacks & Queues
October
Su	M	Tu	W	Th	F	Sa
				1	2 Linked Lists HW 2 due	3
4	5 Lab: Linked Lists	6	7 Adv. Linked Lists	8	9 MIDTERM 1	10
11	12 Lab: Linked Sorted Set	13	14 Skip Lists Reading Ch. 4 UUG Vim Tutorial (7:30pm in HHS 2207)	15	16 Binary Trees PA 2 due	17
18	19 Lab: Binary Tree Traversal	20	21 AVL Trees Reading: avl_trees.pdf on Canvas	22	23 Recursion Reading: recursion.pdf on Canvas HW 3 due	24
25	26 Recurrences	27	28 Recurrences	29 Deadline to withdraw with "W"	30 MORE RECURRENCES? SRLSY. Oh, and Tail Recursion. PA 3 due	31
November
Su	M	Tu	W	Th	F	Sa
1	2 Basic Sorts and Merge Sort	3	4 Quicksort	5	6 Lab - Sorting	7
8	9 Lab - Sorting (contd.)	10	11 Priority Queues and Heaps	12	13 Heap sort	14
15	16 Lab - Heap sort	17	18 Midterm Review	19	20 MIDTERM 2	21
22	23-27 Thanksgiving Break	28
29	30 Maps and Hashing
December
Su	M	Tu	W	Th	F	Sa
		1	2 Hasing Activity	3	4 Lab - Hashing	5
6	7 Applications	8	9 Applications	10	11 Final Exam Review	12
13	14-18 Final Exams Section 1: Mon 8:00-10:00 (8:00am-10:00pm) Section 2: Wed 8:00-10:00 (8:00am-10:00pm)

Assignments

Thu, 20 Aug 2015 11:13:54 -0400

Homeworks

HW1: Basic C (details TBD)
HW2: Big-O Notation (details TBD)

Programming Assignments

PA0: Adding Numbers
PA1: Turtle Geometry (details TBD)

Resources

Thu, 20 Aug 2015 11:13:58 -0400

This page contains links to third-party resources that you may find helpful. If you have suggestions for other resources that your fellow students may find helpful, please let me know.

Installing a C Compiler

GNU/Linux is the preferred operating system for this class. The GNU C compiler is an integral part of a GNU/Linux operating system and is easy to install and use in such an environment. Our lab runs a specific GNU/Linux distribution called Mint. If you do not already have access to a C compiler on your personal computer, you may wish to set one up using one of the following options depending on your operating system:

Ubuntu or Mint Linux (or any other Debian-based distribution): Run sudo apt-get install build-essential in a terminal as an admin user.
Fedora or other RPM-based distribution: Run yum groupinstall "Development tools" in a terminal as an admin user.
Mac OS X: You will need to install the Xcode Command Line Tools package. Here is one guide.
Native Windows: You have two main options, Cygwin or MinGW. The former is a larger system that includes a variety of tools to create a development environment similar to Linux on Windows. The later is a smaller system that focuses more closely on providing compilers.
Any platform: You can use VirtualBox to create a virtual machine on your system that runs GNU/Linux. Here is a tutorial; you should also consider attending the Unix Users’ Group tutorial at 7:00pm on Wednesday, September 2, in ISAT/CS 259.
SSH server: You can develop C programs on stu.cs.jmu.edu (a departmental server) or educ.jmu.edu (a university server). You will need an SSH client (the ssh command-line utility is installed by default in GNU/Linux or Mac OS X; try PuTTY on Windows). To access Educ, you’ll first need to request an account. If you are a CS student, you should already have an account on stu.

Learning C

C Language Tutorial - Basic tutorial from Drexel University
C Tutorial - Another basic tutorial
Learn C The Hard Way - Yet another (rather humorous) tutorial
Programming in C - Reference document (also covers threads and other systems topics)
printf reference
ideone.com - Web-based online compiler and IDE (make sure you choose “C” as your language!)

LaTeX

LaTeX-Project.org - LaTeX home page
ShareLaTeX - Web-based LaTeX collaborative editor
Texmaker - Cross-platform LaTeX editor
Lyx - Graphical semi-WYSIWYG LaTeX editor

Miscellaneous

OpenClipArt - Public domain images (clipart on this website comes from here)
Wolfram Alpha - General purpose mathematical engine

Lab 01

Tue, 01 Sep 2015 10:55:33 -0400

Using C and Make

The goal of this lab is to introduce you to the main tools you will use throughout this course to produce executables from C source files.

Learning Objectives

By the end of this lab, you should be able to:

Interact with the command line using a terminal.
Write a simple “Hello, World” application in C.
Compile a C source file using gcc.
Understand the difference between:
- header files and source files,
- object files and executables,
- compiling and linking,
- declarations and definitions.
Write a simple makefile to help automate compilation.
Understand how the course’s project makefiles work and how to edit them.

Launching and Using the Command Line

All steps of this lab will be done using the command line in a terminal window.

DO THIS IN THE LINUX LAB (ISAT 250): Press ALT-F2, type in “gnome-terminal” and press ENTER. Alternatively, just click this button at the bottom of the screen:

DO THIS IN THE MAC LAB (ISAT 248): Press COMMAND-SPACE, type in “terminal“ and press ENTER.

The terminal functions as an intermediary between you and the computer system, allowing you to have a “conversation” of sorts with the programs on the system. Using the terminal, you will execute commands by typing them and pressing ENTER, and the system will respond with any output in the same window. Try this now:

DO THIS: Execute the following line in your terminal window:

# date

Question: What is the output? If you run the command again, does the output change?

Here is a quick reference to common terminal commands on Unix-based systems (e.g., Ubuntu/Mint Linux or Mac OS X):

pwd                     "print working directory;" essentially "where am I?"
ls                      list the files in the current working directory
cd <dir>                "change directory" to the given directory name
cd ..                   change to the parent of the current directory
cd                      change to your home directory
cat <file>              "concatenate" a file; essentially "print this file to the screen"
cp <src> <dest>         copy a file from "src" to "dest"
mv <src> <dest>         move a file from "src" to "dest"; essentially "rename a file"
rm <file>               remove a file
mkdir <dir>             create a new directory
rmdir <dir>             remove a directory (it must be empty first!)
man <command>           read the "manual" page for the given command

If you are interested in becoming more skilled with command-line interaction, you could work through this tutorial or this online class.

You-Probably-Knew-It-Was-Coming: Hello World

Open a text editor to create a new C file called hello.c in nano by executing the following line in a terminal window:

# nano hello.c

Type the following program, save your code (CTRL+O then ENTER) and exit nano (CTRL+X).

#include <stdio.h>

int main()
{
    puts("Hello world!");
    return 0;
}

Congratulations! You have typed your first C program. For reference, this is essentially the same as the following Java program:

public class Hello
{
    public static void main(String[] args)
    {
        System.out.println("Hello world!");
    }
}

Take a moment to note some of the similaries and differences betweeen the Java version and the C version.

Now let’s compile your hello.c file.

DO THIS: From the command line:

# gcc -o hello hello.c

If you typed the code exactly as it appears above then it should compile. This replaces the command you would have used in Java: (”javac Hello.java”). The command above has several parts:

The program we are invoking (”gcc”, the GNU C Compiler)
The program options (”-o hello”, which tells the compiler to produce a file called hello as output)
The file to compile (”hello.c”)

Let’s see what this produced.

DO THIS: List the contents of the current folder:

# ls

If all has gone according to plan you should now have a file called hello. Furthermore, this file is executable, and can be run via:

# ./hello

At this point the immortal words Hello world! should appear on your terminal. Success!

Question: What happens if you don’t compile with the -o hello flag? (try it and see!)

Question: Can you get gcc to compile hello.c as a binary called hw instead of hello?

Makefiles

When you are compiling one file like we did above (gcc -o hello hello.c), it may not feel that tedious, but most programming projects require that you compile more than one file. We’ll see later exactly how this works, but for now let’s assume that each source file (called a module) is compiled independently into an intermediate file called an object file and then all the object files are combined into a single executable file.

This is somewhat similar to the Java process of compiling a bunch of .java files into .class files, and then combining them all into a single .jar file. In earlier classes, you probably used an integrated development environment (IDE) such as JGrasp or Eclipse to manage the compilation process. While IDEs exist for the C language, the C build process is simple enough that we do not need one in this course.

To more easily handle compiling large projects we will use a tool called make. The purpose of make is to automate the process of compiling and recompiling multiple files. To use make we need to create a special file, called a makefile, which tells make how to make our program. Do:

# nano Makefile

Note the capitalization of the filename. It is necessary to capitalize the filename, but it is customary not to capitalize it in other contexts.

Type in the following simple makefile:

helloworld: hello.c
    gcc -o helloworld hello.c
clean:
    rm -f helloworld

Pitfall Alert: In makefiles, whitespace is very important! The first and third lines of the above example should have no space before helloworld and clean, while the second and fourth line should have exactly one tab (not four or eight spaces!) at the beginning of the line.

Now, let’s use the makefile by running make. Go ahead and close nano. (Remember: CTRL-O and ENTER to save, CTRL-X to exit.)

DO THIS:

# make

You should see that make builds the helloworld executable using gcc -o helloworld hello.c.

DO THIS: Why don’t you try running it again? Type:

# make

This time you should get a message back, make: 'helloworld' is up to date.

OK. So what is going on? The basic idea is that a makefile is a series of build targets followed by the commands to build the target. A particular build target may depend on other build targets or files (listed after the colon). If there is a change in a dependency, make will run the target. So let’s dissect the first build target helloworld.

helloworld: hello.c
    gcc -o helloworld hello.c

The first part, helloworld: is telling make that the build target for the coming list of commands is to build a file called helloworld. The string after the colon tells make exactly which other files this depends on. Here building helloworld only depends on the source file hello.c. Then the next line tells make how to build the helloworld file, namely by running the compiler.

The first time you called make, it looked at the first build target in your make file, which is helloworld. It then checked the file system to see if a helloworld file already existed. Next it checked the dependency list, and found that indeed a hello.c file does exist. Since the build target did not exist, but all of its dependencies did exist, make ran the commands we placed there (i.e. gcc -o helloworld hello.c) which produced the helloworld file.

The second time you ran make however, when make checked the file system to see whether a helloworld file existed it found one! Since one already existed, there was no reason to run the compiler again, and so make told you everything was up to date.

“But wait!” you say, “what if I had modified the hello.c file after calling make?” This is where the dependency list comes in. make is not only checking that helloworld exists, but it is also checking to make sure that helloworld is newer than its dependency hello.c. To see this, let’s make a change to hello.c and run make again.

DO THIS: Add a new line to your hello.c file:

...
puts("Hello world!");
puts("Hello make!");
...

DO THIS: run make:

# make

You’ll see that this time make does run the compiler. This is because your file hello.c is now newer than the helloworld file, and make realizes that it needs to rebuild helloworld since something has changed.

So far, so good. However, there is a second build target: clean. By default make will use the first build target it comes across; however, you can also specify a build target by passing it as a command line argument to make.

DO THIS:

# make clean

This tells make to use the clean target. Note that this doesn’t actually “build” anything, instead it just deletes the helloworld file. This is an important point: you can put whatever commands you want in a build target.

DO THIS: For instance, add the following after the clean target:

gettime:
    date

Then call make again using the gettime target. What happened?

Larger Projects

As your program grows much beyond the basic “Hello world.” example, you are going to need to break it up into separate files for manageability.

The C language lets you “embed” one file into another using the #include directive. If you look back at hello.c, you’ll see that the first line reads:

#include <stdio.h>

This tells the C compiler to include the stdio.h file at this point in the program. You can think of this as a copy/paste–the compiler basically reads the contents of the stdio.h file and copies them into your hello.c program exactly where you put the #include directive. This is similar to Java’s import statement, but is closer to a literal copy-and-paste.

There are two ways to include a file, using either angle brackets (’<’ and ‘>’) or quote marks:

#include <stdio.h>

#include "helloprinter.h"

The difference is that angle brackets are used for library files that are part of the standard (system-wide) C library, while quotes are used for local files. In other words, you will use #include "somefile.h" to include your files, and #include <somefile.h> to include library files.

C comes with many standard library files. The stdio.h file is a particularly handy one that you will use a lot. We included it above because that is where the puts function is defined. That function prints a simple string to the screen with a newline at the end; it is roughly equivalent to System.out.println() in Java.

DO THIS: Create a file called helloprinter.h and put the following in it:

#include <stdio.h>

void helloprinter()
{
    puts("Hello from another file.");
}

DO THIS: Edit your hello.c by adding the appropriate #include statement to include your helloprinter.h file.

DO THIS: Edit the main() function in hello.c so that it calls helloprinter() instead of calling puts.

DO THIS: Recompile everything using make.

Question: Should we edit our makefile at this point? If so, how?

Question: What happens if you #include your helloprinter.h file twice in hello.c?

Separate Your API from Your Code

One common practice in C that is a little different from Java is that we often separate the declaration of a function (its interface) from the definition of that function (its implementation; i.e., its code). In C, the declaration of a function is simply its return type, name, and function parameters followed by a semicolon. Thus, a declaration for the helloprinter() function would look like this:

void helloprinter();

Somewhere else we would put the definition:

void helloprinter()
{
    // code goes here
}

You can think of the declaration as a promise to or a contract with the compiler: void helloprinter(); says to the compiler, “Hey, I’m going to define a function with signature void helloprinter() somewhere down the line, I promise.”

This can be useful, for instance, if a function calls another function that is defined below it. For instance, the following will not compile:

void call_helloprinter()
{
    helloprinter(); // this will cause an error, since helloprinter has not yet been defined
}

void helloprinter()
{
    ...

but the following will compile:

void helloprinter(); // we promise to define a helloprinter() function

void call_helloprinter()
{
    helloprinter(); // no error this time, since the compiler is taking us at our word, for now
}

void helloprinter()
{
    // code goes here
}

This highlights an important difference between C compilers and the Java compiler: a C compiler looks through source code in order, so you can only use a function if it has already been declared. The Java compiler does multiple passes over the code; it uses one pass to read off all of the functions and find where they are defined, then it uses a second pass to actually compile things.

Header Files vs. Source Files

The other reason to use forward declarations is to separate your code into header files and source files. You can think of header files as the public interface to your code, or rather the part of your code that some other programmer might need to see, while the source files are the private part of your code, which contains implementations. Above we just defined the helloprinter() function in the header file, but now we are going to break it into two pieces, a header file containing only the declaration of the helloprinter() function, and a source file containing the actual definition.

DO THIS: Create the following two files if you haven’t already:

File 1 - helloprinter.h:

void helloprinter();

File 2 - helloprinter.c:

void helloprinter()
{
    puts("Hello world.");
}

This way someone using the code only needs to look through the helloprinter.h file to see what functions are available and how to use it. The header file is sort of like an index to a book, it gives you a guide for what is there, but doesn’t give you the actual content.

Question: What happens when you call make now?

Creating Object Files

Now that we’ve split our little hello printer library into a header file and a source file, we need to start compiling a little differently. The reason make now fails is that hello.c only #includes the helloprinter.h file, but it does not include the helloprinter.c file anywhere. So when the compiler tried to compile, it saw in helloprinter.h that we promised we would define the helloprinter() function somewhere, but we never made good on that promise (at least not according to the compiler). When the compiler is building the final executable, it has to check that we made good on all of our promises, otherwise the executable would not know what to do when the helloprinter() function was called!

To handle this situation, we will begin using a kind of intermediate file called an object file. An object file contains compiled code from a single source code file (as you will recall, source code files are also sometimes called modules).

Thus, we will separate compilation into two processes. The first step is to compile all modules into object files. At this point, the compiler does not yet check that we’ve made good on all of our promises. Then, in a second step called linking, the compiler will take all of our object files and link (combine) them into one executable. Only then will it “connect the dots” and check that we’ve actually made good on our promises.

So now we have two source files, helloprinter.c and hello.c. For a second, let’s ignore the makefile and compile them by hand again. The -c flag tells the compiler to compile to an object file (i.e., only perform the first step of compilation). When we compile a file called xyz.c, the compiler will automatically produce an object file called xyz.o. Thus, there is no need to specify output using the -o flag like we did before.

DO THIS:

# gcc -c helloprinter.c
# gcc -c hello.c
# ls

You should now see that the compiler has produced helloprinter.o and hello.o object files. However, attempting to run either of these will not work:

# ./hello.o

It’s not executable yet, since it doesn’t know where to find things like helloprinter(). These “.o” files are the object files. They are the output of the first step of compilation (actual “compiling”) and the input to the second step of compilation (“linking”).

Linking Object Files

The final step, then, is to link all of our object files together into an executable. This time the compiler will check that we have actually defined all of the function that we declared and used. The command looks very similar to the command we were using before, except that we call it on the object files instead of the source files:

DO THIS:

# gcc -o helloworld_linked hello.o helloprinter.o

This time, all should be well and you should have a brand new helloworld_linked binary to run.

Makefiles Revisited

Now the compilation is getting more complicated–we’re both compiling files to object code and linking them. Let’s see how to handle this in the makefile.

Question: How many build targets do we need now? What are they?

DO THIS: Modify the makefile in order to correctly build the helloworld_linked binary.

Hint: You are going to need build targets for each of the files you want to build: hello.o, helloprinter.o, and helloworld_linked. Think about what other files each one depends on when you are designing your makefile. You will probably also want to add “*.o” to the clean target to remove any compiled object files.

In future labs, we will be providing default makefiles. For the programming assignments, you will need to download and modify the generic makefiles that we have provided on Piazza.

Review of file types:

Extension Description

.c C source code file .h C header file .o object file (created by compiling a .c file) (none) executable file (created by linking .o files)

Compiler Flags

One quick side note: throughout this exercise, we’ve been compiling and linking without any special flags sent to gcc. However, the gcc compiler has a lot of useful options, some of which we will use in this course. Typically, we will use the following flags:

-g -O0 -Wall --std=c99 -pedantic

-g Tells the compiler to compile with additional debug information so that when you use a debugger it can tell you things like what line number the program crashed on (similar to the stack traces from Java). This is very useful.
-O0 (Note that is an Oh-Zero, not two Os or two 0s) Tells the compiler not to do any code optimization. GCC can do lots of optimizations to make your code run faster, which is great, but it often makes debugging a lot more difficult. Thus, when you are in development, its best to use -O0 to ensure no optimization is done.
--std=c99 Tells the compiler we want to use the C99 version of the C language standard. This allows us to incorporate some useful features that were added after the original ANSI C standard (C90). There is an even newer version of the language standard (C11), but we will not use any of its features in this class.
-Wall As with Java, in addition to errors the compiler can also warn you about various potential problems with the code. Warnings come at different severity levels and -Wall tells the compiler to show you any warning no matter how slight. This may frustrate you at times, but it will save you time in the long run by catching mistakes earlier.
-pedantic This one is like -Wall but essentially tells the compiler to be even pickier and complain about things that it normally would not complain about. This will also help you a lot with debugging.

Thus, a compilation step will usually look like:

# gcc -c -g -O0 -Wall --std=c99 -pedantic some_file.c

Similarly, when linking we will pass the -g and -O0 flags:

# gcc -g -O0 -o my_shiny_new_binary all.o of.o my.o object.o files.o to.o link.o

Hopefully now you can see how useful makefiles are. Those are really long commands; you don’t want to have to type all of that out every time you want to compile your code!

(Optional) Other Useful Makefile Things: Variables

Two other useful things to know for building makefiles are variables and patterns. This is useful, for instance, in specifying what flags you use in compiling.

For instance, you might have:

file1.o: file1.c
    gcc -g -O0 -Wall --std=c99 -pedantic file1.c
file2.o: file2.c
    gcc -g -O0 -Wall --std=c99 -pedantic file2.c

Now assume you decide to stop using the -O0 flag. You’d have to edit the file in two places. Instead, you could use a variable:

CFLAGS=-g -O0 -Wall --std=c99 -pedantic

file1.o: file1.c
    gcc $(CFLAGS) file1.c
file2.o: file2.c
    gcc $(CFLAGS) file2.c

The variable (note it is in all caps) is called CFLAGS and you refer to it using $(CFLAGS). Now we can update the CFLAGS variable (in one place) and it will change the flags we use in all of the compilation steps.

Maybe you even want to play around with which compiler to use (and not necessarily use gcc). That can be done using a variable as well:

CC=gcc
CFLAGS=-g -O0 -Wall --std=c99 -pedantic

file1.o: file1.c
    $(CC) $(CFLAGS) file1.c
file2.o: file2.c
    $(CC) $(CFLAGS) file2.c

There are also special variables. For instance, the $< variable refers to the first dependency in the dependency list. We can modify our makefile to use this as follows:

CC=gcc
CFLAGS=-g -O0 -Wall --std=c99 -pedantic

file1.o: file1.c
    $(CC) $(CFLAGS) $<
file2.o: file2.c
    $(CC) $(CFLAGS) $<

(Optional) Other Useful Makefile Things: Patterns

As you see above, using variables can help us make our makefile more maintainable. Another nice feature of makefiles is the ability to do pattern matching. Notice that the following two rules are essentially the same:

file1.o: file1.c
    $(CC) $(CFLAGS) $<
file2.o: file2.c
    $(CC) $(CFLAGS) $<

We can replace this with a single rule:

%.o: %.c
    $(CC) $(CFLAGS) $<

This rule essentially uses % as a wild card. Thus, it will match both file1.o and file2.o. In the first case it will use file1.c as a dependency (and compile it thanks to the $< variable), and in the second will compile file2.c.

The makefile system is very powerful, and we have only scratched the surface in this tutorial. Makefiles allow many other time-saving tricks. There is also a platform-independent system for generating makefiles called autotools, as well as more modern implementations such as CMake. Such systems are outside the scope of this course, but if you are interested we encourage you to join your local Unix Users Group.

(Challenge Problem) Add another code module

Create two new files, name_printer.h and name_printer.c. Add a function called print_name() to your new name_printer module that prints out your name. You should declare print_name() in the header file (.h) and define print_name() in the source file (.c).

Then, add a call to print_name() in the main() function in main.c. Make sure that your code compiles and runs. This will require making changes to the makefile in order to compile the name_printer module.

PA 0

Tue, 01 Sep 2015 10:55:33 -0400

PA 0: Arithmetic

Objective

This is a very simple “programming assignment” designed to make sure that your development environment is set up correctly and to familiarize you with the PA completion process in CS 240.

PLEASE READ THIS DOCUMENT CAREFULLY! Although this project spec is rather lengthy, the amount of code you will need to write is very small (fewer than ten lines). Use this opportunity to become more comfortable with the tools that you be using throughout the semester (the compiler, the make system, the test suite, the debugger, etc.) without the stress of a “real” programming assignment.

If you have questions or run into issues, please post a question on Piazza or come to office hours.

Introduction

Here are the starter files for this project:

The two versions contain identical files, and differ only in the container format. If you are using GNU/Linux or Mac OS X, you probably want to use the tarball (.tar.gz) and if you’re using Windows you probably want to use the zip file.

The rest of this section contains step-by-step instructions for setting up your working environment. Pay close attention to this process; future project descriptions will not contain this level of detail.

First you will need to create a folder in which to work. We recommend using version control software (e.g., Git or Mercural) to track your changes, or keeping your project files in a location that is automatically backed up (e.g., using Dropbox). Download one of the starter files linked above and put it in the working folder.

Next, unzip the starter files into the project folder. If you’re using the tarball, use a command like the following:

tar -zxvf 00_arith.tar.gz

On some operating systems, you can create a folder, download the starter files, and unzip them using a graphical interface. That’s fine. For the rest of the steps, however, you will want to open a terminal and cd to the folder where the unzipped project files are.

First, do an ls to see what files you have to work with. For this project, the results should look like this:

$ ls
arith.c     arith.h     main.c      testsuite.c

Notice that there is currently no makefile. Because the Makefile needs to be customized for various operating systems, we will NOT be distributing makefiles with the other starter files. However, we have posted generic makefiles for each supported operating system on Piazza in the “Generic C Makefiles” thread. Open this thread and download the appropriate file into the project folder.

For example, suppose you were on an ISAT 250 lab machine running Mint Linux. Consulting the Piazza thread, you will find that the correct makefile for that environment is Makefile.ubuntu. After downloading that file to the working folder, you should see it in ls results:

$ ls
Makefile.ubuntu arith.c         arith.h         main.c          testsuite.c

Rename the file to remove the .ubuntu extension because it is no longer necessary:

$ mv Makefile.ubuntu Makefile

$ ls
Makefile    arith.c     arith.h     main.c      testsuite.c

Take a moment to look over the Makefile. It includes very generic support for compiling a main.c module and a testsuite.c module (both of which should be included in the starter files). Before you compile, you will need to update the Makefile to include any extra modules or libraries needed by the project. This may require modifying the following section:

# application-specific settings and run target

EXE=main
TEST=testsuite
MODS=
LIBS=

For this project, you can see from the provided files that there is one additional module: arith.c. Thus, you will need to modify the Makefile, adding the extra module to the MODS variable. The new line should look like this:

MODS=arith.o

Note that the extension is .o instead of .c; that is because the MODS variable is used to denote object dependencies later in the makefile, ensuring that the build system re-compiles the object files when necessary.

In addition, if the project requires any library linking options (e.g., -lm for the math library), you would need to add them to the LIBS definition. However, this particular project does not need any external libraries.

At this point, you should be able to build and run the project:

$ make
gcc -c -g -O0 -Wall --std=c99 -pedantic main.c
gcc -c -g -O0 -Wall --std=c99 -pedantic arith.c
gcc -g -O0 -o main main.o arith.o

$ ./main
|2| + |3| = 0

You can see that the result is incorrect; this is because you have not yet completed the project.

Project Description

This project is very simple. You must implement a single function in arith.c as follows:

int add_abs(int a, int b)

Takes two integer parameters and returns the sum of their absolute values.

Project Testing

Public Tests

If you have the Check unit testing framework installed (highly recommended!), you can run the test suite with the make test target. If you run it before working on the project, you will see output that looks like the following:

$ make test
gcc -c -g -O0 -Wall --std=c99 -pedantic -Wno-gnu-zero-variadic-macro-arguments testsuite.c
gcc -L/opt/local/lib -o testsuite testsuite.o arith.o  -lcheck -lm -lpthread
./testsuite
Running suite(s): Default
0%: Checks: 1, Failures: 1, Errors: 0
testsuite.c:11:F:Core:add_pos:0: Assertion 'add_abs(2, 3)==5' failed: add_abs(2, 3)==0, 5==5
FAILURE: At least one test failed or crashed.
make: *** [test] Error 1

You can see that the test suite ran a single check that failed. To see the actual test, look at the testsuite.c file for the test name (the label after “Core” in the printout: in this case, “add_pos”):

START_TEST (add_pos)
{ ck_assert_int_eq(add_abs(2, 3), 5); }
END_TEST

As you can see, this test calls add_abs with parameters 2 and 3, expecting the result to be 5. The test output indicates that the result is in fact 0. If you haven’t started work on the project, this makes sense considering that the starter file contains a non-functional implementation of the add_abs function:

int add_abs(int a, int b)
{
    return 0;   // TODO: finish this function!
}

Alternatively, if you HAD already done some work on the project and had thus been expecting the test to pass, the tests results would indicate that the add_abs function is a good place to start debugging.

After you have implemented the function using a native solution (”return a + b;”), the test should pass:

$ make test
gcc -c -g -O0 -Wall --std=c99 -pedantic arith.c
gcc -L/opt/local/lib -o testsuite testsuite.o arith.o  -lcheck -lm -lpthread
./testsuite
Running suite(s): Default
100%: Checks: 1, Failures: 0, Errors: 0
SUCCESS: All current tests passed!

At this point, it is tempting to consider your work done. After all, you have passed the test! However, this is only a single test, and may not be exhaustive (in fact, it is by design NOT exhaustive for this assignment). Thus, your code might not in fact be fully compliant with the project specification and would therefore not be eligible for full credit.

In fact, there is a key type of input that the provided public testsuite does not test for. Can you figure out what it is?

Private Tests

For this assignment (and this assignment ONLY) we have posted the full “private” testsuite in the Files section of Canvas. It is strongly recommended that you download this testsuite, replace the original (public) version of testsuite.c, and then re-run the tests to make sure that your code passes.

Look carefully at the private testsuite; you should now be able to see the class of inputs that the public testsuite does not check for. You should think about how you could have anticipated that class of inputs from the project description without seeing the private test suite.

This is why it is very important to write your own tests while working on PAs in this class; as stated in the course syllabus, we will be testing your code at least partially based on test cases that you will not be aware of when you submit. This reflects a typical software development situation in industry, where clients often have “hidden” requirements that only surface after you have delivered the project. In many cases, even the client is unaware of these requirements (e.g., compatibility issues with legacy systems). Thus, the ability to write good tests is an important skill that you will find very valuable in your career.

One important difference between this class and dealing with clients in industry is that in this class we will be providing exceptionally clear project specifications. This should enable you to anticipate the full range of tests that we might apply. To write your own tests, you can use the Check testing framework and add more tests to testsuite.c, or you can write your own ad-hoc testing methods in main.c.

Feel free to share and discuss test cases on Piazza; however, be aware that test cases provided by other students may not be entirely true to the project spec. Always read the spec carefully and test your code thoroughly!

Submission

DUE DATE: Friday, September 11, 2015 at 23:59 EDT (11:59pm)

Submit ONLY your completed arith.c file on Canvas using the appropriate assignment submission. Make sure the file contains a comment field at the top with your name and a statement of compliance with the JMU honor code.

Please check your code carefully and make sure that it complies with the project specification. In addition, make sure that your code adheres to general good coding style guidelines. Fix any spelling mistakes, incorrect code formatting, and inconsistent whitespace before submitting. Make sure you include any appropriate documentation.

Lab 02

Tue, 01 Sep 2015 10:55:33 -0400

Basic C programming

The goal of this tutorial is to learn basic C programming constructs. We will do this by examining some of the familiar constructs from Java and learning their C equivalents.

In order to make things more interesting than simply printing out “Hello world.” like we did in the last class, we will be using a basic bitmap drawing package base on turtle graphics.

Learning Objectives

By the end of this lab, you should be able to:

Write basic C programs using standard constructs.
Perform basic formatted output.
Write basic C functions.
Generate images using turtle graphics.

Starter Code

First, download the starter files:

IN THE LINUX LAB (ISAT 250): Download lab02.tar.gz and untar it from the command line with the following command from the folder that you saved the file in:

tar -zxvf lab02.tar.gz

IN THE MAC LAB (ISAT 248): Download lab02.zip and unzip it by either double-clicking it or using the following command line command in the Terminal from the folder that you saved the file in:

unzip lab02.zip

The starter code has four files: a main.c, which you will be modifying; turtle.h and turtle.c, which contain the turtle graphics library; and an OS-specific Makefile (the latter is why it is important to download the correct file for your lab).

Open up the main.c file, and add the following lines to int main() where it says // TODO: add your code here:

turtle_forward(100);
turtle_turn_left(90);
turtle_forward(100);
turtle_draw_turtle();

Now compile and run the main program. You’ll see that it produced an output file, output.bmp. Open this in an image viewer:

IN THE LINUX LAB (ISAT 250): Use the following command from the project folder:

eog output.bmp

IN THE MAC LAB (ISAT 248): Double-click the bitmap file in Finder or use the following command in the Terminal from the project folder:

open output.bmp

The turtle.h contains complete documentation for the functions available to you in the turtle library. The following functions should be enough for today’s lab:

turtle_forward(int distance) / turtle_backward(int distance)

Move the turtle forwards/backwards by the number of pixels indicated.
turtle_turn_left(double angle) / turtle_turn_right(double angle)

Rotate the turtle left/right by angle degrees.
turtle_pen_up() / turtle_pen_down()

After turtle_penup() is called the turtle will not draw until turtle_pendown() is called.
turtle_goto(int x, int y)

Go to the (x, y) position indicated. Note that (0,0) is the center of the screen and this command preserves the orientation (direction) of the turtle.
turtle_set_heading(double angle)

Set the turtle’s orientation to the indicated angle. Zero degrees points towards the right, and ninety degrees points up.
turtle_init(int w, int h)

Initializes the image size of the turtle’s space to width x height = (w, h).
turtle_save_bmp(char* filename)

Saves the computed image to a file specified by the filename.

To learn more about the turtle library, see the reference page.

Getting Started

Spend a few minutes experimenting with compiling the code. Make changes to main.c to draw different things using the commands listed above. Can you make the turtle draw a square? What about a rectangle or a triangle?

Java to C: A Crash Course

Data types

C has multiple integer data types; the most common is int, which is sufficient for our current needs. It is a signed integer at least 16 bits wide. On most modern architectures, it is at least 32 bits.

You can read about the other integer data types at the wikipedia page. In future labs, we will use the size_t type, which is used by convention when we want to store non-negative size values.

Like Java, C has two floating-point formats: the 32-bit float and the 64-bit double.

Like Java, C also has a single character data type called char. However, unlike Java, C does not have a built-in string type. Rather, strings are conventionally stored as an array of char values. We will discuss strings in C next week.

Finally, if you #include <stdbool.h>, you may use the bool data type, which is the same as the boolean data type from Java. The bool data type is not part of the original C specification; it was a convention to use integers instead (0 for false and 1 for true).

Comments

Like Java, C has two kinds of comments: a single line format and a multi-line format. Here are examples of both:

c = a + b;          // this is a single line comment

/* this is a
 * multi-line comment */
d = a * b;

Console output: Using `printf`

The C standard library contains a very powerful string output function called printf; it can handle many different kinds of output formats. For the purposes of this class, we will only need a few features.

The printf function is rather unusual in that it can take a variable number of parameters. The first parameter is always a string, often called the “format string.” If all you want to do is print a simple string, that’s all you have to pass:

printf("Hello!\nThis is some simple text.");

The resulting output is:

Hello!
This is some simple text.

There are several important escape sequences:

Code	Description
`\n`	newline
`\r`	tab
`\"`	quote mark

To print the values of variables, you can embed format specifiers into the format string. For example:

int a = 42;
float pi = 3.141592;
printf("The answer is %d and %s is approximately %f.\n", a, "PI", pi);

The resulting output is:

The answer is 42 and PI is approximately 3.141592.

Here is a list of important format specifiers:

Code	Description
`%d`	signed integer (`int`)
`%u`	unsigned integer (`size_t`)
`%f`	floating-point number (`float` or `double`)
`%e`	scientific notation (`float` or `double`)
`%c`	character (`char`)
`%s`	character string (`char[]`)

There is no format specifier for the bool data type. If you wish to output the value of a boolean, you will need to use a conditional to print different strings (perhaps "true" and "false").

Here is a full reference to all the capabilities of the printf function.

Conditionals

Conditional statements in C look exactly like their Java counterparts.

if (some-test) {
    ...
} else if (a-second-test) {
    ...
} else {
    ...
}

Functions, parameters, calling, and recursion

Function definitions in C look very similar to their Java counterparts. For example:

int add(int a, int b) {
    return a + b;
}

In this example, the function add takes two integer parameters, a and b and returns an their sum as an integer.

One difference between Java and C is that in Java every “function” is a method of some class. So the add function defined above would be part of some class and to call it, you would need an object of that class. Something like:

int result = obj.add(3, 4); // add 3 and 4 using the add method of obj

C, however, is not object oriented. Functions are not part of some parent object, so you call them directly:

int result = add(3, 4); // add 3 and 4 using the add function

Exercise: Drawing Rectangles

Add a new function with the following signature:

void rectangle(int x, int y, int width, int height);

This function should draw a rectangle with the indicated width and height. The lower-left corner of the rectangle should be at position (x, y).
Call your function from inside main(). Test it by recompiling and running the application from the command line.

Question: Can you define the function after main()?

Looping: `for` and `while`

As with Java, the main looping constructs in C are the for and while loops. Unlike Java, there is only one syntax for the for loop, namely:

for (int i = 0; i < n; i++) {
    ...
}

or more generally,

for (initialization; condition; update) {
    ...
}

The while loop behaves exactly the same as in Java:

while (something_is_true) {
    do_this();
}

Exercise: Rows

Add a new function with the following signature:

void row(int x, int y, int count, int size);

This function should draw a horizontal row of squares with the lower-left corner of the row at position (x, y). The count and size parameters indicate the number of squares in the row and the size of each square respectively. Your function should leave a small (5-10 pixel) fixed space between each square.

Do not copy/paste code from the existing rectangle function! Your row function should invoke rectangle with appropriate parameter values.
Update the main function so that it includes several calls to your newly defined row function.

Optional Exercises

Polygons

Add a new function with the following signature:

void polygon(int x, int y, int num_sides, int size);

This function should draw a regular polygon with the indicated number of sides starting at position (x, y). The length of each side is determined by the size parameter. This function should work for any value of sides that is greater than 2. Do not hard-code the function for any particular number of sides.

Hint: * This can be accomplished using either a for or a while loop. * Note that the turning angles required to draw a square are all 90 degrees and that 90 = 360 / 4.

Update the main function so that it draws several different polygons in different places with different numbers of sides and side lengths.
Challenge Goal: Try writing code to draw a series of polygons with the same general size but with an increasing number of sides (as in the graphic at the top of this page). You need to change the side length of the polygons as you increase the number of sides. Here are some questions to think about:
- Do you need to increase or decrease the side length as you increase the number of sides.
- After how many sides is the polygon indistinguishable from a circle?
- Does this number vary if you change the initial size?

Grids

Write a new function with the following signature:

void grid(int x, int y, int columns, int size)

This function should create a rows x columns grid of squares each of size size with the lower-left corner at (x, y). The size parameter indicates teh width of the individual squares.

For further experimentation, make alternating squares filled in a checkerboard pattern. You will need to look through the documentation for the turtle_begin_fill() and turtle_end_fill() functions. Here is an example of what it could look like:

Update the main function so that it includes several calls to your newly defined grid function.

Random Walks

Here is some code that simulates rolling a single die, generating a single random number in the range [0,5]:

#include <time.h>
#include <stdlib.h>

/*
 * returns a random integer from 0 to 5 (inclusive)
 */
int roll_dice()
{
    static int initialized = 0;
    if (!initialized) {
        srand(time(NULL));
        initialized = true;
    }
    return rand() % 6;
}

Don’t worry about the details of how that function works right now; just copy-and-paste it into your main.c above the main() function declaration. Now write a function called turtle_random_walk that does a random walk. It should take an integer parameter telling the turtle how many steps to take.

For each step, the function should call the roll_dice function to generate a random number. If the number is 0 or 1, the turtle should move forward 10 spaces. If the number is 2 or 3, the turtle should turn left 90 degrees. If the number is 4 or 5, the turtle should turn right 90 degrees.

Run your program several times and observe the results.

Challenge Problem: Sierpinski

If you want some practice with a more complex algorithm, try writing a function that draws a Sierpinski triangle. You should be able to reuse the polygon function you wrote earlier. Here is an example of what the end result should look like:

Hint: Use recursion =D.

Lab 03

Mon, 07 Sep 2015 10:55:33 -0400

Arrays in C

The goal of this tutorial is to learn how to use basic static arrays in C.

We will also continue to make use of the turtle graphics library used in the last class.

Learning Objectives

By the end of this lab, you should be able to:

Write basic C programs using arrays and strings
Calculate the length of arrays
Traverse and search an array in multiple directions and intervals
Use arrays in combination with turtle graphics to draw lines and triangles
Explain C strings and their storage format

Starter Code

Begin by downloading the starter files:

IN THE LINUX LAB (ISAT 250): Download lab03.tar.gz and untar it from the command line with the following command from the folder that you saved the file in:

tar -zxvf lab03.tar.gz

IN THE MAC LAB (ISAT 248): Download lab03.zip and unzip it by either double-clicking it or using the following command line command in the Terminal from the folder that you saved the file in:

unzip lab03.zip

The starter code has four files, a main.c, which you will be modifying; turtle.h and turtle.c, which contain the turtle graphics library; and an Makefile to help with building the lab.

An array of options

Array data types

An array in C is a bounded sequence of memory locations that store data elements. These locations are accessed by an indexed offset from the variable name. Some examples of arrays are a list of grades for students in a class, salaries for employees in a company, or number of seats in each row at a theater.

An array can be of any C type, but all elements in the array must be of the same type.

One important difference betweeen C and Java is that in Java the size of the array is explicitly tracked by the language runtime, while C arrays do not explicitly track such information.

In particular, this means that you no longer have a .length attribute attached to each array. In Java, you might have done something like this:

	int[] numbers = {1, 2, 5, 9};
	for (int i = 0; i < numbers.length; i++) {
		System.out.println(numbers[i]);
	}

In C, however, there is no numbers.length attribute to access, and we would have to track the length manually. Thus, the loop above would have to be written something like:

	int numbers[4] = {1, 2, 5, 9};
	for (int i = 0; i < 4; i++) {
		printf("%d\n", numbers[i]);
	}

More importantly: if you write a function that takes an array as input, it will need to also take the length of the array as input. For example, in Java you could write an arithmetic product function like this:

	public int product(int[] nums)
	{
		int prod = 1;
		for (int i = 0; i < nums.length; i++) {
			prod *= nums[i];
		}
		return prod;
	}

In C, because there is no nums.length, you should pass the length of the array in as a parameter to the function as well:

	int product(int nums[], int nums_len)
	{
		int prod = 1;
		for (int i = 0; i < nums_len; i++) {
			prod *= nums[i];
		}
		return prod;
	}

Question: Can you think of another way to solve this problem? How else could we indicate the end of an array?

Declaration of an array

Static arrays in C are declared using syntax similar to (but not identical to) Java’s:

    int numbers[4];         // this creates an array of four integers

Recall that in Java, you must both declare and allocate space for an array before you use it:

    int[] numbers = new int[4];

This is not the case for the kind of C arrays that we will use in this lab.

Arrays can also be declared and initialized in one statement as such:

    int a[4] = { 1, 2, 3, 4 };

Question: What would happen if you tried to read an array location before writing something to it?

Question: Can you create an array with a negative size?

Memory model

It is important to note at this point that the C arrays that we will use in this lab are allocated in a very different way than the arrays in Java.

Specifically, we are only currently using fixed-sized arrays, which means that the space for the array can be allocated from a fixed-size chuck of memory that is reserved for the program when it launches (or when the current function is executed). This means that we don’t have to do any memory management, but it also means that we must know exactly how large each array should be in advance.

In Java, however, arrays were allocated from heap memory, which is a large pool of memory available to a program while it is running. You may not have been aware of this because Java managed the memory for you. In C, this is not the case, and you will need to think carefully about how much memory to reserve and when to reserve it.

Next week, we will learn how to allocate space for arrays and other data structures on the heap in C, but for now we will stick with fixed-size arrays.

We are also glossing over the details of how arrays are passed into functions. For now, just realize that you can pass arrays into functions by putting “[]“ brackets after the parameter name in the function signature:

    int my_function(int numbers[], char characters[])

Also, we will for now NOT use arrays as return values from functions. Next week we will learn how to do this.

Exercise: Your first foray into arrays

For our first excercise, let’s find the sum of elements in an array of numbers of type int.

DO THIS: Fill in the code of the sum function:

    int sum(int nums[], int nums_len) {
        // add your code here
        return 0;
    }

The input to this function is an array of integers and the length of that array. The output of the function is the sum of all numbers in the array. Add a call to sum() in your main() function to test it.

Multidimensional arrays

The C language provides support for multidimensional arrays. For instance, we could have an array of two dimensions to store x and y coordinates of points, or we could have a 3 dimensional array to store Minecraft-like block/cube data.

The syntax for declaring and accessing multidimensional arrays is array[i][j] where i is the row index and j is the column index.

A two-dimensional array of (x,y) points could be created in C as follows:

	int my_points[4][2] = {
		{11,12},
		{13,14},
		{15,16},
		{17,18}
	};

You can also think of multidimensional arrays as “array of arrays”. In the example above, the first dimension ([4]), tells us that we are creating an array with 4 entries, and the second dimension ([2]) says that each of those four entries is itself an array with two entries (an x-coordinate and a y-coordinate).

Our first point is (x,y) = (11,12), which is stored at array[0]. To access the x-coordinate of this first point you would use my_points[0][0] and to access the y-coordinate of the first point, you would use: my_points[0][1].

Similarly, the value of my_points[1][0] is 13 and the value of my_points[1][1] is 14.

Question: How would you access the y-coordinate of the third point?

Exercise: Drawing points

DO THIS: Fill in the code of the draw_points function:

	void draw_points(int points[][2], int num_points) {
		// add your code here
	}

The input to draw_points is a 2D array named points, containing num_points number of points stored in the same way as in the example above.

As output, your function should draw all of the points in points using the turtle graphics library. You may use the turtle_draw_pixel function, or you may manually move the turtle using turtle_goto function and draw the point using the turtle_draw_dot function. See the link for documentation on these functions.

The resulting image should have four dots in a diagonal row, as below:

Recall the following instructions for viewing the turtle graphics output:

IN THE LINUX LAB (ISAT 250): Use the following command from the project folder:

`eog output.bmp`

IN THE MAC LAB (ISAT 248): Double-click the bitmap file in Finder or use the following command in the Terminal from the project folder:

`open output.bmp`

Exercise: Drawing line segments

DO THIS: Fill in the code of the draw_segments function:

	void draw_segments(int points[][2], int num_points) {
		// add your code here
	}

The input to draw_segments is a 2D array named points that represents a list of segment endpoints. Each consecutive pair of points represents the two endpoints for a single segment. Note that because each segment has two endpoints, the length of points should be twice the value of num_points. As output, your function should draw the segments using turtle graphics.

For example, if your code is called in the following way:

	int my_segments[4][2] = {
		{10,40},
		{70,100},
		{50,40},
		{10,80}
	};
	draw_segments(my_segments, 2)

Then your code should draw two line segments as below:

C strings

As with arrays, strings are handled a bit differently (and more low-level) than in Java.

In Java a string is stored in an actual object, which gives you access to various helpful attributes and functions, most notably a .length attribute for determining the length of the string. In C, however, a string is just an array of characters. You can declare and initialize a simple static C string using code like this:

	char my_message[] = "C ya, Morehead State!!";

This defines a string simply as a character array. Since a string is just an array, you can access a single character the same way you would an element of an array, i.e. my_message[6] will give you the 7th character (which is 'M')

Note that the quotes are really just syntactic sugar for a long array of characters. It is not, in principle, different from:

	char my_message[22] = {'C', ' ', 'y', 'a', ',', ' ',
        'M', 'o', 'r', 'e', 'h', 'e', 'a', 'd', ' ',
        'S', 't', 'a', 't', 'e', '!', '!'};

There is one important caveat. Notice that in the second case, as we have above, we gave the length of the array (22), but in the first case we did not.

Why? This is because C strings are just character arrays, but by convention they have one extra special character at the end. This character is called the null terminator, has the value zero, and is indicated in C code using an escape code: '\0'. In other words, the first definition for my_message above is really equivalent to:

	char my_message[23] = {'C', ' ', 'y', 'a', ',', ' ',
        'M', 'o', 'r', 'e', 'h', 'e', 'a', 'd', ' ',
        'S', 't', 'a', 't', 'e', '!', '!', '\0'};

Why is this helpful? The main reason is that when we are dealing with strings, unlike arrays, we don’t necessarily have to keep track of how long the string is. We can simply rifle through the string until we find the null terminator '\0'. In fact, you can now use this to determine the length of any given string:

Exercise: Length of strings

DO THIS: Fill in the code of the string_length function:

int string_length(char my_string[]) {
    // add your code here
    return 0;
}

This function takes a character string (char[]) as input and returns the length of the string as an int.

Exercise: String splitting

DO THIS: Fill in the code of the tokenize function:

void tokenize(char my_string[])
{
    // add your code here
}

This function takes as input a string made up of words separated by spaces, (e.g. “fifty-six to seven”) and prints each word on a new line, e.g.:

fifty-six
to
seven

The function should print a newline character after each token, even the last one.

HINT: Use printf("%c", a_string[i]) to print the ith character of the string named a_string. Recall that %c is the printf format specifier for a char value.

String library reference

The standard C library provides many useful functions for working with strings. Most of these functions are declared in the string.h header file. Here is a full reference to these functions.

Optional exercises

Finding the minimum value

In this exercise we will explore finding minimum values in an array.

1) DO THIS: Create a function to return the minimum value of an array of numbers. It should have the following signature:

int min(int nums[], int nums_len)

This should take as input an array of integers called nums. The second parameter, nums_len is the length of the array.

Next we want to modify the function to return not just the minimum but another like the second smallest or 3rd smallest value.

2) DO THIS: Create a function that returns the k-th minimum value of an array. So for example, calling min_k(nums, n, 2) should return the 2nd smallest element in the array. Here is the function signature:

int min_k(int nums[], int nums_len, int k)

The input to this function is the array of integers, the length of the array, and an integer k specifying which minimum value to find. For instance if k=3 you should find the third smallest element in nums. If there are duplicate elements, you should only count them once.

3) DO THIS: Use the min_k function to print the array in sorted order. Use this signature:

void print_sorted(int nums[], int nums_len)

The function should print the whole array on a single line, with a space character after each number. The function should print a single newline after the last number (and its associated space).

Question: How efficient (or inefficient) is your solution? Can you think of a faster way to print a sorted version of the array?

Triangle man

Do This: Write a function with the following signature:

void draw_triangles(int points[][2], int num_points)

Your function should take as input an array of points; numpoints is the number of points. Each three consecutive points represents a triangle. As _output your function should draw each three consecutive points as a triangle.

Palindromes

DO THIS: Write a routine with the following signature:

bool is_palindrome(char word[])

Your function should determine if the given string is a palindrome word (can be written the same way forwards and backwards - like “madam”, “otto”, “anna”, “redivider”, “kayak”, and “racecar”. Empty words and one-character words should be considered palindromes for the purposes of this function.

Challenge exercise: Same things in strings

DO THIS: Write a routine with the following signature:

int same_things(char string1[], char string2[])

This function should search through the given strings and determine the longest set of letters that match. It should return the first index of the longest match, or -1 if there is no match.

Lab 04

Mon, 07 Sep 2015 10:55:33 -0400

Structures in C

In this lab you will learn how to define and use C structures.

Learning Objectives

By the end of this lab, you should be able to:

Define a struct for encapsulating data.
Create new types using enum.
Use structs and enums to make your programs more readable.

Starter code

The starter code for this lab can be found at the following links:

Download the starter code and unzip it. Make sure it compiles by running make. You will be editing the main.c file.

Your first structure

You already know about primitive data types in C such as int, char, etc. You can create more complex data types using the struct keyword. A struct combines several pieces of data into a single aggregate data structure (thus the name).

struct point {
    int x;
    int y;
};

Question: What does this code remind you of from Java?

A struct allows us to abstract away some of the underlying memory layout details, collecting related information inside of a single structure. This is a form of encapsulation, a term you may remember from your Java courses.

Question: What is the benefit of encapsulation?

DO THIS: Fill in the code of the print_point function; it is a function that takes a parameter of type struct point, and prints out the x- and y-coordinates:

    void print_point(struct point p)
    {
        printf("Point: (%d, %d)\n", p.x, p.y);
    }

This code can be tested using this following snippet:

    struct point the_point = {.x = 5, .y = 7};
    print_point(the_point);

Try this yourself. Make sure that it prints what you expect and that you understand what each piece does.

Key differences from Java

One key difference between a Java class and a C struct is that the struct cannot directly contain member methods. It can only contain member data. This is why C is not considered to be object-oriented: we cannot call methods on structs. This makes the language simpler but more limited.

Another major difference is that there is no notion of a “private” member variable. All variables are publicly-visible by default. It is possible to define a struct in a header file such that its members are not visible to files that include that header, but we will not be using such functionality in this lab.

Initializing Structs

Note that initializing a struct can be done in multiple ways. It can be done inline, as was done above:

    struct point the_point = {.x = 5, .y = 7};

Here we create a new point with the x member set to 5 and the y member set to 7.

You can also create the struct without initialization and then modify its data afterwards, like:

    struct point the_point;
    the_point.x = 5;
    the_point.y = 7;

Question: What do you think happens if you do this:

    struct point the_point;
    print_point(the_point);

Accessing Attributes

Note that here the dot (.) syntax is used to access the struct’s variables. These can also be used in computations. For instance, we could define a function that adds two points together:

     struct point add(struct point p1, struct point p2)
     {
        // Get the sums of the x and y values:
        int sum_x = p1.x + p2.x;
        int sum_y = p1.y + p2.y;

        // Create a new point with the sum values:
        struct point ret_point;
        ret_point.x = sum_x;
        ret_point.y = sum_y;

        return ret_point;
     }

Or, much more succinctly:

    struct point add(struct point p1, struct point p2)
    {
        struct point ret_point = {.x = p1.x + p2.x, .y = p1.y + p2.y};
        return ret_point;
    }

Exercise: Drawing points revisited

Remember that in the last lab we used 2-dimensional arrays to create a list of points. This was a little cumbersome from a code-readability standpoint because when you look at a piece of code that reads “points[5][0]” it is not really clear exactly what the indices are referring to.

Using structs, we can now make this a bit more readable. We can use our point type to create an array of points:

    struct point my_points[4] = {
        {.x = 13, .y = 14},
        {.x = 15, .y = 16},
        {.x = 17, .y = 18},
        {.x = 19, .y = 20}
    };

Now, rewrite your draw_points function from the last lab to use your new type struct point.

DO THIS: Fill in the code of the draw_points function:

    void draw_points(struct point points[], int num_points) {
        // add your code here
    }

The input to draw_points is an array (one dimensional) named points, containing num_points number of points.

The resulting image should have four dots in a diagonal row, as below:

Exercise: distances between points

DO THIS: Fill in the code of the dist function:

    double dist(struct point p1, struct point p2);

This function takes as input two points (p1 and p2), calculating and returning the distance between them as a double.

Hint 1: Remember that the distance between two points $$(x_1, y_1)$$ and $$(x_2, y_2)$$ is given by $$\sqrt{(x_2 - x_1)^2 + (y_2 - y_1)^2}$$

Hint 2: The math.h library file contains a function called sqrt that takes an integer (or a double) as a parameter and returns the square root of the number as a result. For instance sqrt(4) returns 2.0.

Check to make sure that the distance between the points in the testing code in main() is approximately 305.9.

Typedefs for the win

Notice that every time we want to take a struct as a parameter to a function or define a struct we have to use the struct keyword. This starts to get cluttered. For instance, the signature for our add function above is:

    struct point add(struct point p1, struct point p2);

In Java, this would undoubtedly look a lot prettier, something like:

    Point add(Point p1, Point p2);

In such cases, the struct keyword is just cluttering things up. Fortunately C has a useful tool for dealing with this: the typedef. The typedef keyword allows you to define new types for your program.

For a silly example, you could do:

    typedef int integer;

That defines a new type called integer, which is basically just an alias for int. After adding that typedef, you could do this:

    integer x = 5;

More helpfully, programmers sometimes use typedef to create shorthand versions of types, for instance, rather than unsigned int you can use typedef unsigned int uint; to use uint as shorthand for unsigned int. This sort of shorthanding also works for for structs.

Exercise: Create a `point_t` type using `typedef`.

DO THIS:

Create a new type called point_t using typedef as an alias for struct point.
Convert your code so that it no longer uses struct point but instead uses point_t as the type.

Another way to create types: `enum`

Another useful method for creating types is with the enum keyword. The enum keyword allows you to create an enumerated type, or rather a type whose values come from a pre-defined finite list. You can also combine typedefs and enums.

Consider the following code:

    // Define a new type called fruit_t, which
    // is either APPLES, ORANGES, or BANANAS:
    //
    typedef enum {
        APPLES,
        ORANGES,
        BANANAS
    } fruit_t;

    void print_fruit(fruit_t which_fruit)
    {
        if (which_fruit == APPLES) {
            printf("Apples!\n");
        } else if (which_fruit == ORANGES) {
            printf("Oranges!\n");
        } else if (which_fruit == BANANAS) {
            printf("Bananas!\n");
        }
    }

Another (shorter) way to create typedef’ed structs

You may have noticed in the previous code example that we declare the enum and the typedef in one declaration, rather than two separate ones as we did with structs. The former syntax is cleaner and avoids any intermediate names for the enum. In fact, you can use it for structs as well. Here is our point_t type defined using this syntax:

    typedef struct {
        int x;
        int y;
    } point_t;

Additional Exercises

Drawing triangles

Create a struct called triangle_t for storing triangles. Each triangle should store three points: p1, p2, p3, which are its endpoints.
Write a function called draw_triangle, which takes as input a triangle_t and then draws the triangle using the turtle graphics library.
In your main() function, create a triangle with corners at (0,0), (100,75), (-60,80) using your new triangle_t type and draw it.

Your output should look like this:

Icons

For this exercise you are going to create an icon_t type to define icons. An icon will have a shape (either CIRCLE, SQUARE, or TRIANGLE), a dimension (width x height). You will then write a draw_icons function that takes as input an array of of icon_ts and draws the icons along a row in the image.

Your tasks:

Define a new enumerated type called shapetype_t which can be either CIRCLE, SQUARE, or TRIANGLE. (Hint: use enum.)
Define a new type called icon_t which stores a size_t called size and a shapetype_t called icon_type.
Define a function called draw_icons which takes as input an array of icons and the number of icons in the array and a starting (x, y) position and draws them in a row (according to their icon_type) using the turtle graphics library. Hint: the function’s signature should be:

void draw_icons(icon_t icons[], int num_icons, int start_x, int start_y).
In your main() function add code to create an array called icons which has at least one icon of each type. Use your draw_icons function to draw the icons in the array.

Your output should look something like this:

Lab 05

Mon, 14 Sep 2015 10:55:33 -0400

Testing in C

In this lab, you will learn how to use a testing framework in C.

Objectives:

Describe the benefits of automated testing
Assemble a test suite using the Check software package
Add and modify tests in a test suite

Introduction

You may be familiar with the JUnit framework from Java. JUnit allows you to write automated tests for your code. In this course, we will be using Check, which is a C-based testing framework similar to JUnit.

Throughout this lab, we will be testing implementations of the following function:

    // takes an integer and returns the next prime number
    // that is greater than the parameter
    //
    int next_prime(int x)
    {
        return 0;   // TODO: finish this
    }

You should take a few minutes to consider how you would implement this function.

Lab setup

Here are the starter files for this project:

Download one of the archives and decompress it to a working folder. You will find three code modules (*.c files):

1) main.c - the main() program 2) primes.c - the implementation of the next_prime function 3) testsuite.c - the automated tests

You will also find primes.h, a header file for the primes.c module.

Because we will be using the Check framework, it is time to begin using the generic makefiles that we have posted on Piazza and/or on your course website. Download the makefile that is appropriate for the system you are working on and put it in the same folder as the other lab files, renaming it to simply Makefile (note the capitalization).

You will need to customize the generic makefile for each project. For this project, we will need to add a module target for the primes module to the MODS variable in the makefile. Find the appropriate line and add primes.o:

    # application-specific settings and run target

    EXE=main
    TEST=testsuite
    MODS=primes.o
    LIBS=

    ...

IMPORTANT: Even though you are adding an entry for the primes.c code file, you need to put primes.o (with the “.o” extension) in the makefile. Recall that the make build process runs on target information; i.e., a list of things that need to be built. All you need to do is tell make what you want to build, and the generic makefile has rules and patterns to help make figure out how to do it.

Also note that we didn’t have to include main.o and testsuite.o in that list. We only have to list any extra code objects beyond the basic main.o and testsuite.o objects, which are already accounted for elsewhere in the generic makefile.

Test the build with make to ensure that everything is set up properly. You will need to use a similar process to set up all of the programming assignments in this course.

Part 1: Manual testing

In this lab, we will alternate between improving our tests and improving our code. This resembles a formal software development process called test-driven development (TDD). The idea behind TDD is that you should write tests for a program before you write the program itself. This requires you to think critically about the expected behavior of your program even before you begin to code it.

After you write some initial tests, you then write the minimal amount of code necessary to pass the test. After you have fixed any problems and all of the current tests are passing, you write more tests and then more code. Gradually, you will build up a large list of tests that help you verify that new changes don’t break older features. This technique is also sometimes called the “test a little, code a little” strategy, and is a recommended approach for tackling the programming assignments in this class.

For this lab, we will (over the course of several exercises) gradually build up a suite of tests for the next_prime function. This suite will be tightly integrated with our build process (make) and thus it will be very easy to check that we haven’t broken anything if we ever have to make changes to the code in the future.

Exercise 1: Ad-hoc tests

Let’s write a test for next_prime. We’ll start by writing an ad-hoc test in the main() function. This is a very rudimentary method of testing, but it is quick and simple.

DO THIS: Add the following code to your main() function:

    if (next_prime(2) == 3) {
        printf("x=2: correct\n");
    } else {
        printf("x=2: incorrect\n");
    }

This test encodes the following specification: “when given the number 2, the next_prime function should return 3.” This is a concrete, testable statement that follows from the original function specification, which was the somewhat hard-to-test notion that the function “takes an integer and returns the next prime number that is greater than the parameter.” When writing tests, you should always begin with the project specification and work towards concrete, testable test cases that are easy to code.

Compile and run the main program and see that the test fails.

DO THIS: Fix the code to make the test pass. For now, just change return 0; in next_prime to return x+1;. This is a minimal change necessary to make the given test pass.

Hopefully you can see that this does not fully implement the project specification for next_prime. Later, we will need a better implementation. This also exposes the inadequacy of our current test; it now passes, but that doesn’t mean that the code matches the spec.

Exercise 2: Function-based tests

Ad-hoc tests in a main() function are quick to implement, but we want to be able to add lots of tests. If we have to duplicate all the code for a test every time we add a new one, we will end up with a very hard-to-maintain test suite.

We can improve the situation by extracting the test behavior into a separate function. Let’s do that by adding a new test_next_prime function:

DO THIS: Move the testing code from main() into the test_next_prime function, which takes two parameters: a test input value and an expected test result value. This function should test next_prime with the given input value and check it against the expected result value. Thus, this function should work for testing any integer input. You will need to parameterize the code from the last section by changing the constants (2 and 3) to variable references.

Then, add the following tests to the main() function:

    test_next_prime(2, 3);
    test_next_prime(3, 5);
    test_next_prime(5, 7);

Compile and run to verify that the first test passes but the latter two fail.

DO THIS: Fix the code for next_prime so that all three tests pass. Here is an easy fix that should cause your implementation to pass all three tests:

    if (x == 2) {
        return x+1;
    } else {
        return x+2;
    }

Again, hopefully you can see the futility of coding to an incomplete test suite. Even though we have already “fixed” the function twice, we are not much closer to a true implementation of the project specification. This is why it is so important to have a comprehensive test suite.

Part 2: Automated testing

Thus far, we have confined our tests to ad-hoc and function-based tests in the main program module. However, it is much more robust to separate a program’s tests into a separate module, enabling them to be maintained, compiled, and managed separately. This will also allow us to handle test crashes gracefully, and to use the main() function for actual program code.

As mentioned before, we will be using the Check framework for tests in this course. This will allow us to take advantage of robust testing code that someone else has written, meaning there is less work for us!

For this course, we will always put our test suites in a separate source code file that we will call testsuite.c. We have included a basic testsuite template in the starter files for this lab. Load that file now and look through it.

Actual tests are enclosed between START_TEST and END_TEST markers. These are actually macros, a copy/paste mechanism similar to the #include directive that we have seen already. The Check framework replaces these macros with code that runs the test, handles any crashes, and records the result. Every test is named, and the name is declared as a parameter to the START_TEST macro.

Inside of these tests, Check provides many convenience functions for actually performing tests. Here are the most important:

ck_assert(expr)

Evaluate expr; the check passes if the result is true and fails if it is false.
ck_assert_int_eq(x, y)

The check passes if the two integers are equal and fails if they are not.
ck_assert_str_eq(x, y)

The check passes if the two character strings are equal (according to the strcmp function) and fails if they are not.

Here is a reference to all of the checking functions provided by our testing framework.

IMPORTANT: Every test also needs to be registered with the testing framework using the tcase_add_test function; in our course framework, this is done in the test_suite function.

(Optional) Peeking behind the curtain

Read this section if you’re curious about what the rest of the code in testsuite.c is doing; however, it is not strictly necessary to understand the content in this section in order to use the framework.

The test suite module (testsuite.c) contains two major framework functions: test_suite() and run_testsuite(). The former is responsible for building a Suite object that contains a list of all the tests in the test suite, and the latter is responsible for running the Suite and printing the results. The file also contains a main(), but it just calls run_testsuite.

Here is the code for the test_suite() function:

Suite * test_suite(void)
{
    Suite *s;
    TCase *tc_core;
    s = suite_create("Default");
    tc_core = tcase_create("Core");

    tcase_add_test(tc_core, TEST_NAME);

    suite_add_tcase(s, tc_core);
    return s;
}

The first four lines create Suite and TCase structures and initialize them. These structs are defined in the Check framework files (which are not part of our project). A Suite is a collection of TCase objects, and a TCase is a collection of actual test functions, which by convention should begin with the prefix “test_”. The test functions themselves may contain multiple checks using the convenience functions (e.g., ck_assert_int_eq). Thus, there is a hierarchical, container-based relationship between all of these structures:

    + Suite struct
      + TCase struct
        + "test_*" function
          + individual "ck_assert_*" checks
        + "test_*" function
          + individual "ck_assert_*" checks
        + "test_*" function
          + individual "ck_assert_*" checks
        ...

For simplicity, we will only use a single Suite and TCase for all of the test suites in this course. We will separate tests into multiple “test_*“ functions, each of which should have a small number of individual checks (usually just one).

The only modification that you should ever need to make to the test_suite function is to add each new test case using a call to the tcase_add_test function.

Here is the code for the run_testsuite() function:

int run_testsuite()
{
    int number_failed;
    Suite *s;
    SRunner *sr;

    s = test_suite();
    sr = srunner_create(s);

    srunner_run_all(sr, CK_NORMAL);
    number_failed = srunner_ntests_failed(sr);
    srunner_free(sr);

    if (number_failed == 0) {
        printf("SUCCESS: All current tests passed!\n");
    } else {
        printf("FAILURE: At least one test failed or crashed.\n");
    }

    return (number_failed == 0) ? EXIT_SUCCESS : EXIT_FAILURE;
}

The first three lines allocate some variables, including a Suite struct (which is initialized in the fourth line using the test_suite() function described above) and an SRunner struct (which manages the actual execution of tests. These variables are initialized, and then the runner is executed using the srunner_run_all function. The Check library is then polled to see how many tests failed, and a summary message is printed. Finally, the function returns an exit value to indicate whether or not all of the tests passed.

You should not need to modify the run_testsuite function in this course.

Finally, if you look through the generic makefile, you will see a separate CFLAGS and LIBS variables for compiling the test suite:

TESTCFLAGS=$(CFLAGS) -Wno-gnu-zero-variadic-macro-arguments
TESTLIBS=-lcheck

The -Wno-gnu-zero-variadic-macro-arguments flag suppresses a particular (harmless) warning that is produced when compiling the Check header files, and the -lcheck flag is what tells the linker to include the Check library when it builds the final executable.

Exercise 3: Automated test

Let’s re-implement our original ad-hoc test using the test framework.

DO THIS: Inside the test_prime_2 test case, add a check that the result of calling next_prime(2) is 3:

START_TEST (test_prime_2)
{
    ck_assert_int_eq(next_prime(2), 3);
}
END_TEST

This is much simpler than our previous code! We could also reformat the test to be even more compact:

START_TEST (test_prime_2)
{ ck_assert_int_eq(next_prime(2), 3); }
END_TEST

Such formatting would not be very readable for normal functions, but for simple test cases it is occasionally useful to be able to encode a large number of tests in a compact form.

In our generic Makefile, we provide a separate build target for automated tests: test. To compile and run the tests, just run make test. Verify that the test suite builds and runs. The output should look something like this:

Running suite(s): Default
100%: Checks: 1, Failures: 0, Errors: 0
SUCCESS: All current tests passed!

This output tells you how many checks were run, how many failures and errors were encountered, and what percentage of the tests passed. The last line is a general at-a-glance summary of the results.

Exercise 4: More tests

Now that it is easy to add more tests, let’s add a lot more.

In particular, we should try to anticipate edge cases, which are input values that lie on the border of acceptable values. To find edge cases, think about what sorts of input values make sense for any particular function, and choose values that are unexpected or extreme. For example, we know that two is the smallest prime number, so we need to think about the behavior of our function for values smaller than two. what is the next prime of the value one? Zero? A negative number?

DO THIS: Add more tests for the following cases:

next_prime(3) should be 5
next_prime(5) should be 7
next_prime(7) should be 11
next_prime(14) should be 17
next_prime(42000) should be 42013
next_prime(1) should be 2
next_prime(0) should be 2
next_prime(-1) should be 2

IMPORTANT: For each test you add, make sure you remember to add a corresponding call to tcase_add_test in the test_suite function. Always verify that the number of checks run by the test suite matches your expectations.

Re-run the test suite. Which tests pass and which tests fail?

DO THIS: Write a proper implementation for the next_prime function. Does your implementation pass all the tests?

PA 0

Don’t forget that PA 0 is due today. Hopefully you have already completed it; if not, make sure you do so. You may download the private test suite for this PA (and ONLY this PA) from Canvas. Just overwrite the old testsuite.c with the new one.

Lab 06

Fri, 11 Sep 2015 10:55:33 -0400

Pointers in C

In this lab, you will gain experience with pointer declaration and manipulation in C.

Objectives:

Define a “pointer” as used in C and explain dereferencing
Write code to declare and use pointers
Distinguish between data and pointers in existing code
Use the malloc and free functions to manage heap memory
Understand the link between arrays and pointers
Use pointers to allocate and access arrays on the heap
Use pointers to allocate and access structs on the heap

Setup

Begin this lab with an empty main.c and the standard makefile for your operating system. You will want to add the following includes at the top of your file:

#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

Of course, you will also want a basic definition of the main function. You should follow along with the code examples in this lab, adding them to your main function and testing them.

Review

As discussed in the first lecture, computer memory consists of a large bank of bytes. Every byte has a unique address. Until now, we have only been referring to a location in memory by a variable name:

    int x;
    x = 5;

The first line allocates space for an integer (usually 4 or 8 bytes), and gives it a name: “x”. In the second line, we store the value 5 in the memory location referenced by the name x. The association between x and the location never changes; i.e., x cannot be changed to reference a different location in memory.

You can see the actual address of the variable x using the “address-of” operator (&):

    printf("Variable x is located at %p\n", &x);

This uses the %p format specifier, which prints addresses in hexadecimal. The above code should print a slightly different address each time you run it, because the variable x will be assigned to different places in memory during each execution.

Pointers

We are now going to introduce a major new C concept: pointers. A pointer is a variable that holds a memory address. Pointers are declared using the asterisk (*) operator:

    int *p;

In the above example, the type of the variable p is int* (usually pronounced “int star” or “int pointer”). Like other variables, it is a fixed reference to an allocated place in memory. Unlike other variables, that memory location itself holds the address of another place in memory. That is what makes it a “pointer;” it “points” to another location.

Until it is initialized, however, it doesn’t point to anything in particular. To avoid a lot of headaches later on, pointers should always be intialized when they are declared. If you don’t know what it should point to immediately, you can always initialize it to a special value (zero) using the NULL constant:

    int *p = NULL;

Question: How would we initialize p so that it points to x?

WARNING: If you wish to declare multiple pointers on the same line, you must include an asterisk with each of them. For instance:

    int *p = NULL, *q = NULL;

In this course, we strongly recommend against declaring multiple pointers on a single line.

To assign pointers so that they point to existing variables, you can use the address-of operator (&) just as we used it earlier to print the address:

    p = &x;

After this line, p is now a pointer to the location that stores the value associated with the variable x. Note that x is NOT a pointer; it is just a variable name.

You can now print the value of p (the pointer) and verify that it is the same as the address of x:

    printf("Pointer value of p is %p\n", p);

Dereferencing pointers

To retrieve the value that a pointer points to, use the “dereference” operator (*). Yes, it’s an asterisk, the same as we used to declare the pointer.

In the running example, we know that p is an int* (an “int-pointer” or a “pointer to an int”). We have also initialized it to point to the location of variable x. Thus, we can print the integer that p points to using the following code:

    printf("Dereferenced value of p is %d, and x = %d\n", *p, x);

Question: What would happen if we passed p instead of *p to printf?

Question: What would happen if we dereferenced a pointer that had the value of NULL?

Exercise: Tracing

What does the following code print? Step through it as if you were the machine. This is sometimes referred to as “tracing” the code. You may find it helpful to draw diagrams with boxes for memory locations and arrows for pointers.

    int a = 42;
    int b = 7;
    int c = 999;
    int *t = &a;
    int *u = NULL;
    printf("%d %d\n", a, *t);

    c = b;
    u = t;
    printf("%d %d\n", c, *u);

    a = 8;
    b = 8;
    printf("%d %d %d %d\n", b, c, *t, *u);

    *t = 123;
    printf("%d %d %d %d %d\n", a, b, c, *t, *u);

DO THIS: Copy the previous code into your file and test it. Then, add more lines of code to do the following:

Update t to point to c. Use a pointer dereference to change the value of c to 555. Verify that it worked by adding a printout. Does this change any of the other values?
Change the value of c again using a direct assignment. Verify that the pointer t still points to the value by printing the result of dereferencing it.

Question: Would happen if you tried to execute the following code? How could you fix it?

    int *v = &t;
    printf("%d\n", *v);

This illustrates an important concept: pointers can point to almost anything, even other pointers!

Aside: The `sizeof` operator

There is a useful operator in C called the sizeof operator. You can use it to determine the size of a particular variable in memory. You can also use it to determine the size of a type.

DO THIS: Run the following code and take note of all the sizes.

    printf("sizeof(char): %lu\n",   sizeof(char));
    printf("sizeof(42): %lu\n",     sizeof(42));
    printf("sizeof(float): %lu\n",  sizeof(float));
    printf("sizeof(double): %lu\n", sizeof(double));
    printf("sizeof(NULL): %lu\n",   sizeof(NULL));

Note that we must put parentheses around the value when using the sizeof operator.

Note also that we are using the %lu format specifier, which denotes a “long unsigned integer” (i.e., a size_t value).

Question: What is sizeof(int)? What is sizeof(3.14)?

You can also use sizeof to detect the size of static arrays:

    int d[3] = { 1, 2, 3 };
    printf("sizeof(d) = %lu\n", sizeof(d));

Allocating memory

Now that we can track arbitrary locations in memory using pointers, we can begin allocating memory on the heap (a large chunk of memory set aside for programs to use during execution). Heap memory is allocated in C using a call to the malloc function (from stdlib.h), which takes a single size_t parameter: the number of bytes requested. It is conventional to use the sizeof operator to help request the correct amount of memory:

    int *r = (int*)malloc(sizeof(int));

The malloc function returns a pointer to the allocated memory. Technically, its return type is void*, a void pointer. This is why you have to cast the result to the type of pointer you need. Such casts are safe because all pointers are guaranteed to be the same width.

Note that malloc could potentially return NULL if it does not succeed (if the system is out of memory). Therefore, you should always check the return value to be safe:

    if (r == NULL) {
        printf("Out of memory!\n");
        exit(EXIT_FAILURE);
    }

The exit function immediately aborts the program with the provided error code.

IMPORTANT: Unlike Java, C does not automatically de-allocate memory when it is no longer needed. Thus, you will need to manually de-allocate memory when you are done, using the free function:

    free(r)

If your program allocates memory and does not free it, your program has a memory leak. The leaked memory will be reclaimed when your program exits, but until then it will continue to clog up the system.

In this course, a memory leak is considered to be a software defect. You should thoroughly debug your program to find and fix all memory leaks. You may use tools like Valgrind/Memcheck to help you find memory leaks. Here is a short tutorial.

Question: What happens if you try to dereference a pointer after you free it?

It is conventional to set set pointers to NULL immediately after you free them. This will trigger a segmentation fault at the offending location if you ever attempt to dereference it, making it easier to diagnose and fix software defects.

Arrays and pointers

Here’s a little secret: you’ve actually already been using pointers. In C, array variable names are actually just pointers to the first element. In fact, you can find out the address of an array using the same syntax as above:

    int d[3] = { 1, 2, 3 };
    printf("The array starts at %p\n", d);

You can also use pointer arithmetic to access array elements:

    printf("The first element is %d\n", *d);
    printf("The second element is %d\n", *(d+1));
    printf("The third element is %d\n", *(d+2));

This allows you to use pointers explicitly to iterate over arrays. The following two loops are equivalent:

    for (int i=0; i<3; i++) {
        printf("Element: %d\n", d[i]);
    }

    for (int *w = d; w < (d+3); w++) {
        printf("Element: %d\n", *w);
    }

In fact, the syntax you’re already familiar with for accessing array elements (i.e., the square brackets used in the first loop above) actually performs pointer dereferencing and arithmetic “under the hood.”

IMPORTANT: As mentioned before, there is no automatic bounds checking in C, so you must be careful not to read outside the bounds of the array. Now you can see that this is because C uses pointers and pointer arithmetic “under the hood,” and there is no sure-fire way to check whether a pointer is pointing to a location inside a particular array.

We can also allocate arrays on the heap, which is very useful when we don’t know at compile time how big the array should be. For example:

    int *e = (int*)malloc(sizeof(int) * b);

This will allocate an array big enough to hold a number of elements equal to the value of b. It is conventional in such allocations to use the sizeof function to determine the number of bytes needed for each element and then to multiply by the size of the array.

This now allows us to write functions that return arrays; in fact, they just return a pointer to an array. Note that you should never return a reference to a static array that is local to a function, because the array will be de-allocated at the end of the function and the pointer will be invalid. You should only return pointers to arrays that you allocate on the heap. Here is a function that returns a newly-allocated array:

char* alloc_alphabet_array()
{
    char *alphabet;
    alphabet = (char*)malloc(sizeof(char) * 27);
    if (alphabet == NULL) {
        printf("Out of memory!\n");
    }
    for (char c = 'a'; c <= 'z'; c++) {
        alphabet[c-'a'] = c;
    }
    alphabet[26] = '\0';    // null terminator
    return alphabet;
}

Question: What is sizeof(alph) if alph is the return value of this function?

Recall that in C, strings are just null-terminated arrays of characters. Thus, in this case we could describe alphabet using any of the following terms:

char * (“char star”)
“pointer to array of chars”
“pointer to a C string”

For return values that are pointers, some people put the asterisk (*) with the type:

    char* alloc_alphabet_array()

Others put the asterisk with the function name:

    char *alloc_alphabet_array()

In this course, either approach is fine as long as you are consistent.

IMPORTANT: Don’t forget to free these arrays when you’re done with them!

Structs and pointers

As you might suspect by now, you can also create pointers to structs. Assuming that point_t is defined as it was in a previous lab, you can allocate a point on the heap:

    point_t *pt = (point_t*)malloc(sizeof(point_t));

To access member variables, you have to dereference the pointer:

    (*pt).x = 2;
    (*pt).y = 3;
    printf("The point is (%d, %d)\n", (*pt).x, (*pt).y);

Because this is cumbersome, C also provides a more concise way to dereference a pointer and access a member variable: the arrow operator (->). The following code is exactly equivalent to the above code:

    pt->x = 2;
    pt->y = 3;
    printf("The point is (%d, %d)\n", pt->x, pt->y);

Of course, you can also use pointers to store references to arrays of structs:

    point_t *pts = (point_t*)malloc(sizeof(point_t) * 4);
    if (pts == NULL) {
        printf("Out of memory!\n");
        exit(EXIT_FAILURE);
    }

    for (int i=0; i<4; i++) {
        pts[i].x = i*10;
        pts[i].y = i*20;
    }

    for (int i=0; i<4; i++) {
        printf("Point: (%d, %d)\n", pts[i].x, pts[i].y);
    }

Question: Is the type of pt different from the type of pts? Why or why not?

Question: Why didn’t we need to use the -> operator to access the x and y member variables in the loops above?

We can also pass structs into functions using pointers, and we can return pointers to structs from functions:

point_t* midpoint(point_t *p1, point_t *p2)
{
    point_t* mid = (point_t*)malloc(sizeof(point_t));
    if (mid == NULL) {
        printf("Out of memory!\n");
        exit(EXIT_FAILURE);
    }
    mid->x = (p1->x + p2->x)/2;
    mid->y = (p1->y + p2->y)/2;
    return mid;
}

Because midpoint allocates memory and returns it, the calling function must remember to free the allocated memory. Otherwise, there will be a memory leak.

Here is some code to test the midpoint function:

    point_t pt1 = { .x =  0, .y =  0 };
    point_t pt2 = { .x = 10, .y = 10 };

    point_t *midpt = midpoint(&pt1, &pt2);

    printf("Midpoint: (%d, %d)\n", midpt->x, midpt->y);

Question: Why did we need to pass &pt1 and &pt2 into midpoint instead of just pt1 or pt2?

For large structs, this is far faster than passing or returning the struct itself, because it is quicker to copy a pointer than the entire struct. However, they are not exactly equivalent, because passing a pointer does not create a copy.

IMPORTANT: If you pass a struct into a function using a pointer, any changes you make to the struct inside the function will persist AFTER the function completes. This is because you are actually modifying the memory values of the original struct.

Exercise: More tracing

What does the following code print? Step through it as if you were the machine. You may find it helpful to draw diagrams with boxes for memory location and arrows for pointers.

typedef struct {
    int *a;
    int b;
} stuff_t;

void foo(stuff_t value)
{
    *(value.a) = 2;
    value.b = 3;
}

void bar(stuff_t *value)
{
    *(value->a) = 4;
    value->b = 5;
}

void do_stuff()
{
    stuff_t my_stuff;
    int temp = 0;

    my_stuff.a = &temp;
    my_stuff.b = 1;
    printf("a=%d b=%d\n", *(my_stuff.a), my_stuff.b);

    foo(my_stuff);
    printf("a=%d b=%d\n", *(my_stuff.a), my_stuff.b);

    bar(&my_stuff);
    printf("a=%d b=%d\n", *(my_stuff.a), my_stuff.b);
}

Exercise: Plug the leaks

Review your code from this lab; does it leak any memory?

We purposefully did not include all necessary free calls to give you experience with memory management. You should walk through your code and/or test it with a tool like Valgrind/Memcheck to find and fix any memory leaks. Here is a short tutorial.

(Optional) More exercises

You may find the following exercises helpful to reinforce your understanding of pointers:

JoeQuery’s C pointer exercises

HW 1

Mon, 14 Sep 2015 10:55:33 -0400

Homework 1

Introduction

The goal of this homework is to solidify your understanding of the C language and your ability to write simple programs in C. You will be finishing up some of the previous labs and submitting your solutions for grading.

For this homework, you must adhere to the specifications below, NOT the original lab pages. Please read this page carefully. We will attempt to highlight any differences from the exercises as they appeared on the labs, but you are responsible for making sure that your code implements this homework assignment correctly.

Starter Files

You should put your code for this homework into a file named hw1.c, that should compile against our hw1.h. If you wish, you may start from our boilerplate files:

The boilerplate archives include a main.c (for testing your graphical functions) and a testsuite.c (for testing your other functions). You will only need to submit hw1.c.

Lab 2: Grids

Write a function with the following signature:

void draw_grid(int x, int y, int rows, int columns, int size)

IMPORTANT: In Lab 2, this function was called “grid”, but now it should be called “draw_grid”.

This function should create a rows x columns grid of squares each of size size with the lower-left corner at (x, y). It is important to note that the size parameter indicates the width of the individual squares, not the size of the overall grid.

Alternating squares should be filled in a checkerboard pattern with the color blue (RGB values: 0, 0, 255). You will need to look through the documentation for the turtle_begin_fill() and turtle_end_fill() functions.

The output from the sample main.c should look something like this:

You may assume that rows, columns, and size are all positive integers.

HINT: It is not required for this homework, but you will probably find it very helpful to first write a draw_square() function like the following:

void draw_square(int x, int y, int size)

This function should draw a square of size size with the lower-left corner at (x, y).

Lab 3: Finding the second minimum value

Create a function that returns the 2nd minimum value of an array. Here is the function signature:

int second_min(int nums[], int nums_len)

The input to this function is the array of integers and the length of the array. If there are duplicate elements, you should only count them once. You may assume that the input array has at least two elements.

HINT: It is not required for this homework, but you may find it helpful to first write a min() function like the following:

int min(int nums[], int nums_len)

This should take as input an array of integers called nums. The second parameter, nums_len is the length of the array. After this function is working, think about how you would extend it to work for the second minimum.

HINT: You may wish to use the INT_MIN or INT_MAX constants for this exercise. They are defined in the limits.h standard header file.

Lab 3: Palindromes

Write a routine with the following signature:

bool is_palindrome(char word[])

Your function should determine if the given string is a palindrome word (can be written the same way forwards and backwards - like “madam”, “otto”, “anna”, “redivider”, “kayak”, and “racecar”. This function should do a strict character-based test; i.e., it should not ignore punctuation and whitespace. Empty words and one-character words should be considered palindromes for the purposes of this function.

Lab 3: Same things in strings

Write a routine with the following signature:

void same_things(char string1[], char string2[], char common[])

This function should search through the two given strings and determine the longest sequence of characters that match at any point in the string, saving the longest match to the string common.

IMPORTANT: In Lab 3, this function just returned the first index of the longest match; now it should save all the characters of the match to the common character array.

For example, given the following code:

char str1[] = "This is a long sentence of some sort.";
char str2[] = "This is not a long sentence of some sort";
char dest[1024];
same_things(str1, str2, dest);

After that code executes, dest should contain the following string:

" a long sentence of some sort"

Note the leading space in the output above. Also, don’t forget to add the null terminator character ('\0') to the output character string!

You may assume that common is large enough to hold the longest common character sequence.

Lab 4: Drawing icons

Define a function called draw_icons with the following signature:

void draw_icons(icon_t icons[], int num_icons, int start_x, int start_y)

This function takes as input an array of icon_t structs (defined in hw1.h and the number of icons in the array as well as a starting (x, y) position. The function should draw them in a row (according to their icon_type, also defined in hw1.h) using the turtle graphics library.

The output from the sample main.c should look something like this:

Submission

DUE DATE: Friday, September 18, 2015 at 23:59 EDT (11:59pm)

Submit ONLY your completed hw1.c file on Canvas using the appropriate assignment submission. Make sure the file contains a comment field at the top with your name and a statement of compliance with the JMU honor code.

PA 1

Wed, 16 Sep 2015 10:55:33 -0400

PA 1: Geometry

The purpose of this lab is for you to:

Practice basic C programming:
- Using structs and non-trivial loops (i.e. something more interesting than for (int i = 0; i < n; i++))
- Writing functions
- Using several different libraries (i.e. .h/.c files) in a single program.
Learn how to read an algorithm specification and write working code from it.
Practice working at the appropriate level of abstraction.
Solve problems in computational geometry, an important and fascinating domain of computer science and mathematics.

Getting Started

First download and decompress one of the starter files:

Don’t forget to download the appropriate Makefile for your platform from Piazza or the course website.

Starter Code

The starter code has 8 files. Four of these are modules that we are providing you, and you should not need to edit these:

geometry.h and geometry.c : A library of relatively simple functions for manipulating geometrical objects (called primitives).
turtle.h and turtle.c : The turtle graphics library.

The files you need to edit are:

main.c : Your main program.
pa1.h and pa1.c : A small library of geometry tools that you are going to write.
testsuite.c : The public tests for this assignment. You may want to try adding your own tests.

Be sure to add the following to your Makefile:

MODS=geometry.o turtle.o pa1.o
LIBS=-lm

This tells your Makefile to build the geometry, turtle, and pa1 modules and include the math library (libm.so) when linking.

Computational Geometry: A (Very, very, basic) Introduction

Computational geometry is a sub-field of computer science that focuses on algorithms and data-structures for solving geometric problems. A few typical examples of computational geometry in action are:

robot navigation (obstacles are polygons in the robots workspace),
map overlays (finding areas of special interest on a map),
computer aided design (CAD systems allow designers to build “working” models of products in 3D),
protein folding (researchers are trying to understand how proteins fold in order to combat diseases like mad-cow disease and are using computational geometry to do it–ask Dr. Bowers about this if you are interested),
and a lot more.

It is also related to several other areas of computer science including (but not limited to): computer vision, graphics, bioinformatics.

Polygons

In this PA you are going to be writing a few basic algorithms and data structures for dealing with polygons and for computing something called the “convex hull” of a polygon.

For our purposes a polygon is a drawing in the plane (i.e. on a flat sheet of paper) created by first putting the pen down at some start location, then drawing a series of straight line segments without lifting pen until eventually ending up back at the start location.

The points at which one line segment ends and the next begins are called the vertices and the line segments themselves are called the sides of the polygon. (These are also often called edges.)

You are already familiar with lots of different polygons. For instance, triangles, squares, rectangles, pentagons, octagons, dodecagons (you all know what a dodecagon is, right?). All of these things are formed by a bunch of straight line segments (the sides) connected end-to-end (at the vertices). All of these have something else in common–they are all simple, meaning that they do not self intersect. We will restrict our discussion to simple polygons.

Geometry Primitives Library

Included in the starter code for this PA is a small geometry primitives library. The word primitives is used to denote basic data structures and algorithms that are used to build more complex data structures and algorithms. This is much the same as the difference between primitive types, like int and char and the compound types you create using structs in C or classes in Java.

The geometryPrimitives library includes the following two structures (see geometryPrimitives.h):

    /*
     * 2D points (x,y)
     */
    typedef struct {
            int x;
            int y;
    } point_t;

    /*
     * 2D line segments ((x1, y1), (x2, y2));
     */
    typedef struct {
    	point_t p1;
    	point_t p2;
    } segment_t;

The first, point_t is used to specify 2D points (i.e. $(x, y)$) in the plane with integer coordinates. The second, segment_t specifies a line segment between its two points $(p_1, p_2)$. These structures may be useful for you in the remainder of this PA and you can use them in your code.

The geometryPrimitives library also defines several predicate functions, which are functions that return true or false based on some property. We will discuss these functions later as they become relevant.

Problem 1: Drawing a triangle

Write a function called drawTriangle which takes as input three point_ts, p_1, p_2, and p_3 and draws the triangle. In other words, your function’s signature should be:

    void draw_triangle(point_t p1, point_t p2, point_t p3);

Note that you should declare your function in pa1.h and define it in pa1.c.

Use your function to draw several different triangles in the main() function in main.c.

Reference solution: ~5-10 lines

Problem 2: Struct for storing polygons

We store a polygon as a list of vertices. The edges are inferred by connecting adjacent vertices in the list by line segments. In geometryPrimitives.h we have defined a type polygon_t for storing a polygon. It looks like this:

	typedef struct {
		point_t* verts;
		int num_verts;
	} polygon_t;

Note that this stores the vertices as a dynamically-allocated array called verts.

Write a function that can create a polygon_t from an array of vertices.

Add the following function declaration to pa1.h:

	polygon_t create_polygon(point_t vertices[], int num_vertices);

Define the create_polygon function in pa1.c. It should create and return a new polygon_t struct with the points from the input attribute vertices copied into the verts attribute of the struct. Note that this will require first allocating enough memory to store verts.

You should also implement the following function:

	void free_polygon(polygon_t *poly);

This function should free any allocated memory associated with the given polygon (setting pointers to NULL as appropriate) and should should also set the number of vertices in that polygon to zero. This function should be called by client programs for each polygon used in order to prevent memory leaks.

Note that this function is passed a polygon pointer; this will allow you to reset any de-allocated pointers and prevent dangling pointer problems.

Reference solution: ~15-20 lines

Problem 3: Drawing a polygon

Write a function called draw_polygon which takes as input a polygon_t (as you defined above) and draws the polygon. In other words, your function’s signature should be:

    void draw_polygon(polygon_t poly);

Declare your function in pa1.h and define it in pa1.c.

Use your function to draw several different polygons in the main() function in main.c (with different numbers of points in each polygon).

Reference solution: ~10-15 lines

Convex Polygons

One classification of polygons that is important for many computational purposes is the difference between convex and non-convex polygons.

A convex polygon is one where all the interior angles are less than 180 degrees. If even one angle is greater than 180 degrees, then the polygon is non-convex. See below:

Suppose you wanted to check if a polygon were convex or not. You could compute all of the angles at each vertex and test whether any one is greater than 180 degrees. The problem with this approach is that it requires you to use transcendental functions like $\sin()$ and $\cos()$ to compute the angles. When possible, we often avoid the use of these functions. One reason to avoid the use of these trig functions is that they require many more processor cycles to compute than simple arithmatical operations like addition and multiplication.

Another method for determining whether a polygon is convex is to walk around the polygon (think of redrawing it with the pen, or better yet, drawing it in the grass and walking along it) and keep track of how many left-hand-turns you make and how many right-hand-turns you make. (Whether a turn is a left-hand-turn or right-hand-turn can be computed with only simple arithmetic and without computing the angle or using trig functions.)

Notice that if the polygon is convex, then either 1) all of your turns will be right-hand-turns (if you are walking clockwise), or 3) they will all be left-hand-turns (if you are walking counter-clockwise). However, on a non-convex polygon, you always have a mix of right and left-hand-turns. In the geometryPrimitives library there are two functions you will need:

is_left_hand_turn(point_t p1, point_t p2, point_t p3): Returns true if and only if traveling from p1 to p2 and then from p2 to p3 consitutes a left-hand-turn.
is_right_hand_turn(point_t p1, point_t p2, point_t p3): Returns true if and only if traveling from p1 to p2 and then from p2 to p3 constitutes a right-hand-turn.

Problem 4: Convex test for 4-gons

A 4-gon is a polygon with 4 sides (for example, squares, parallelograms, rectangles, kites, diamonds, etc.). Write a function called is_4gon_convex with the following signature:

    bool is_4gon_convex(point_t p1, point_t p2, point_t p3, point_t p4);

The input to this function is the four vertices of the 4-gon, $(p1, p_2, p_3, p_4)$ and _output is true if and only if the 4-gon is convex, false otherwise.

You may wish to write a function called draw_4gon which takes as input the four points p1, p2, p3, p4 of a 4-gon and draws it blue if it is convex, or red otherwise. (Hint: use your is_4gon_convex function). Draw at least one convex and one non-convex 4-gon in your main() function in main.c.

Optional Challenge Question: Remember that we are assuming the input polygon is simple, i.e. it doesn’t self-cross. Does your method always work correctly when the polygon is not simple?

Reference solution: ~10-15 lines

Problem 5: Convex test for polygons

Write a function called is_polygon_convex with the following signature:

    bool is_polygon_convex(polygon_t poly);

The input to this function is a polygon (of type polygon_t which you defined above) and the output is true if and only if the polygon poly is convex, false otherwise.

Modify your draw_polygon function to draw the polygon blue if it is convex, red otherwise.

Hint 1: if you get stuck, think about writing a test for 5-gons, and then 6-gons. What is changing each time?

Hint 2: You might want to count the number of left hand turns and count the number of right hand turns you find. If both are non-zero, then you have a mix.

Hint 3: Remember that it takes 3 consecutive vertices to check whether something is a turn. Did you check all of the vertices (where does your loop end)?

Reference solution: ~15-20 lines

Convex Hulls

One very important concept from computational geometry is the convex hull of a polygon. The convex hull of a polygon P is the smallest convex polygon that contains P on its interior. See the figure below. Convex polygons are generally easier to work with computationally than non-convex polygons. Because of this, there are many applications that use the convex hulls to speed up computation.

For instance, in computer graphics applications such as a game or simulation you might have polygonal objects moving around and want to test whether two objects collide with one another. It turns out that testing whether two non-convex polygons have collided is a much more expensive operation than testing whether two convex polygons have collided.

A system for testing collisions for a bunch of non-convex polygons could simply test directly whether each polygon collides with every other polygon (slow), or instead it could store the convex hull of each polygon and as a first test determine whether any of the convex hulls collide (fast). The system would then only test whether the actual polygons collide if their convex hulls collide. Thus the slow operation is invoked only when it is more likely to return true.

An example of a convex hull is shown below:

The left of the image above shows a very non-convex polygon in red spelling out the letters JMU. The convex hull of the JMU-polygon is shown in the middle, and on the right the JMU polygon is shown on top of its convex polygon. You can think of the convex hull as what you get if you stretch a rubber-band around the polygon.

Problem 6: Drawing convex hulls

For this exercise you are going to draw the convex hull of a polygon. The essential idea for this is to take all pairs of vertices (not necessarily consecutive) and test the pair to see if all other points in the polygon are either ALL left-hand-turns or ALL right-hand-turns from that pair. The basic pseudo-code for this function is:

For all pairs (p, q):
    If all other points form a left-hand-turn with (p, q) or all other
    points form a right-hand-turn with (p, q):
        Draw the line segment (p, q)
    Otherwise:
        Do not draw (p, q)

Your function should have the following signature:

    void draw_convex_hull(polygon_t poly);

Note: When testing your code, you should only use polygons for which no three points are collinear. The pseudo-code above assumes that the polygon is “generic” which means no three points are collinear.

Reference solution: ~25-40 lines

Submission

DUE DATE: Friday, September 25, 2015 at 23:59 EDT (11:59pm)

Submit ONLY your completed pa1.h and pa1.c file on Canvas using the appropriate assignment submission. Submit both files separately; do NOT submit a zip file. Make sure both files contain a comment field at the top with your name and a statement of compliance with the JMU honor code.

Classes on John Bowers

Programming Fundamentals (CS 139)

CS240

Welcome!

News and Updates!

Course Links

Piazza

Class Grades & Quizzes

Syllabus

Objectives and Expectations

Course Textbook

Grading Criteria

Instructor Contact Info

Course Policies

Attendance and Participation

Programming Projects

Adding and Dropping the Course

Academic Honesty

Disability Accommodations

Excused Absences

Inclement Weather

Catalog Description

Calendar

Calendar

Assignments

Homeworks

Programming Assignments

Resources

Installing a C Compiler

Learning C

LaTeX

Miscellaneous

Lab 01

Using C and Make

Learning Objectives

Launching and Using the Command Line

You-Probably-Knew-It-Was-Coming: Hello World

Makefiles

Larger Projects

Separate Your API from Your Code

Header Files vs. Source Files

Creating Object Files

Linking Object Files

Makefiles Revisited

Compiler Flags

(Optional) Other Useful Makefile Things: Variables

(Optional) Other Useful Makefile Things: Patterns

(Challenge Problem) Add another code module

PA 0

PA 0: Arithmetic

Objective

Introduction

Project Description

Project Testing

Public Tests

Private Tests

Submission

Lab 02

Basic C programming

Learning Objectives

Starter Code

Getting Started

Java to C: A Crash Course

Data types

Comments

Console output: Using printf

Conditionals

Functions, parameters, calling, and recursion

Exercise: Drawing Rectangles

Looping: for and while

Exercise: Rows

Optional Exercises

Polygons

Grids

Random Walks

Challenge Problem: Sierpinski

Lab 03

Arrays in C

Learning Objectives

Starter Code

Console output: Using `printf`

Looping: `for` and `while`

Exercise: Create a `point_t` type using `typedef`.

Another way to create types: `enum`

Aside: The `sizeof` operator