- The maRla Project
- Fall Semester 2010
- Fall Semester 2009
- Spring Semester 2009
- Fall Semester 2008
- Fall Semester 2007

## Fall Semester 2010

### Parallel Computing

- Calculating Pi (Message Passing)

We implemented calculations for pi and ran some time testings on them. You will need MPI installed on your parallel servers in order to use this source, and you’ll need to change the server names in the lamHosts files.

Download Source - Sieve to Find Primes (Message Passing)

We implemented prime calculation in parallel and ran some benchmark tests on it. You will need MPI installed on your parallel servers in order to use this source, and you’ll need to change the server names in the lamHosts files.

Download Source - Life (Message Passing)

We implemented the game of life using parallel processing. Boards are included. You will need MPI installed on your parallel servers in order to use this source, and you’ll need to change the server names in the lamHosts files. We implemented this project on the OSC computers, so the job files are the scripts to compile and run the program on those servers.

Download Source - Matrix Multiplication (Message Passing)

We implemented the most obviously parallel problem, matrix multiplication, in using multiple processors. You will need MPI installed on your parallel servers in order to use this source, and you’ll need to change the server names in the lamHosts files. We implemented this project on the OSC computers, so the job files are the scripts to compile and run the program on those servers.

Download Source - Sieve to Find Primes (Shared Memory)

We implemented prime calculation in parallel and ran some benchmark tests on it. You will need OpenMP installed on your servers in order to use this source, and you’ll need to change the server names appropriately.

Download Source - QuickSort (Shared Memory)

We implemented QuickSort sequentially and two parallel ways (using standard threads as well as Executors) in Java.

Download Source

## Fall Semester 2009

### Algorithms

- Roads Scholar

A map is read in from the data file accompanying the source files. Predecessor and adjacency matrices are then created and filled using the Floyd-Warshall algorithm for single-source shortest path of the built map. Signs are also placed along a particular direction on roads between intersections, and cities are placed at given intersections. Distances to cities are added to the signs from the filled in adjacency matrix if the sign is along a road in a direction that is the shortest path to a given city on the map.

Download Source - Rush Hour

One of the best puzzle games of all time (in my opinion) is the Rush Hour board game. This Java program will solve any game board given in the minimum number of moves using properties of the Greedy algorithm. It’s abstracted enough that I went ahead and built a playable interface for it in Java as well. Yup, play it on any operating system (with the stand-alone version) or in your browser (with the applet version). Standard levels are included, and you can even make your own levels! (It’s worth noting that clicking the Solve button may take a ridiculous amount of time if the applet version is run.

Play Rush Hour 0.2 in Your Browser (Requires Java 1.5 or Higher)

Download Rush Hour 0.2 (Requires Java 1.5 or Higher)

Clone Version 0.2 (Playable Interface) on GitHub

Download Version 0.1 (Console Interface) Source - Making Change

The classic, dynamic programming problem for making coins for a given value out of a particular set of denominations. The greedy algorithm is really only efficient for U.S. coin denominations, so for this project we implemented it using an algorithm that would always guarantee we found the optimal (least amount of coins used) solution. Three separate algorithms were implemented to better show the value of dynamic programming: bottom-up iterative, recursive with memoization, recursive without memoization. I don’t recommend running anything higher than twenty-five on the recursive without memoization since it’ll take … Forever. A brief summary of our findings can be found here. We originally implemented this project in Java, but for fun, curiosity, and speed comparisons, I went back and implemented it in Python and C++ as well. All language implementations are contained within the zip file.

Download Source - Sort Comparisons

A benchmark framework developed using Java to compare the sort times of QuickSort and InsertionSort. A complete report of our findings can be found here.

Download Source

### Microprocessors

- Lab 11 – Service Interrupt
- Lab 9 – ADC and Interrupt Modes
- Lab 7 – Stopwatch
- Lab 5 – Functions
- Lab 4 – Branches and Loops
- Lab 3 – Multi-Byte Logic and Arithmetic
- Lab 2 – Addressing Mode

## Spring Semester 2009

### Survey of Programming Languages

- Topic Paper #22 – Report for the Java/C++ Concurrency Benchmark
- Topic Paper #20 – Report for the Sudoku Solver in Python
- Topic Paper #19 (Term Paper) – Concurrency in Eiffel
- Topic Paper #18 – Choosing a Programming Language
- Topic Paper #17 – The Four Major Programming Paradigms
- Topic Paper #16 – Functional Versus Logic Programming
- Topic Paper #14 – Report for the IBM 650 Emulator in Scheme
- Topic Paper #13 – The Development of LISP
- Topic Paper #12 – Object-Oriented vs. Imperative Programming
- Topic Paper #11 – Object-Oriented Design
- Topic Paper #10 – IBM 650 Emulator in Scheme Design
- Topic Paper #9 – Report for the IBM 650 Emulator in Python
- Topic Paper #7 – The Development of Smalltalk
- Topic Paper #6 – The Development of COBOL
- Topic Paper #5 – The Development of FORTRAN and ALGOL
- Topic Paper #4 – IBM 650 Emulator in Python Design
- Topic Paper #3 – The Von Neumann Bottleneck
- Topic Paper #2 – IBM 650
- Topic Paper #1 – History of Zero and One

- IBM 650 Emulator

This program emulates the base-10 IBM 650, publicly released in 1954 and support for the computer and its components was withdrawn in 1969. A description of the IBM 650, how it was designed, and how it interpreted commands can be found in this Topic Paper. A discussion of the design for the Python emulator can be found in this Topic Paper, and a discussion for the Scheme emulator can be found in this Topic Paper. The final report for the Python emulator can be found in this Topic Paper, and the final report for the Scheme emulator can be found in this Topic Paper. The way commands are interpreted by the IBM 650 is also discussed in detail in the comments in the initial lines of the source files.

Download Version 0.2 in Python 3 (or higher)

Download Version 0.1 in Python 3 (or higher)

Download Version 0.1 in PLT Scheme - Java vs. C++ Concurrency Benchmark

This project illustrates the use of concurrent programming practices in Java and C++ through the simple task of matrix multiplication. Using pthreads in C++ and the Thread object in Java, the coding shows the simplicity of concurrency in the languages and benchmarks the speed comparison. In summary, Java was much easier to implement and had a faster runtime than C++. A more detailed discussion of the design, implementation, and results from the benchmark can be found in this Topic Paper.

Download Version 0.1 in Java (NetBeans Project)

Download Version 0.1 in C++ (NetBeans Project) - Sudoku Solver

This program will solve a Sudoku puzzle to any degree of difficulty received from an input file. The input file may be specified via an argument when launching the program, or if an argument is not specified the default filename “sudoku.txt” is used. This application solves using no efficiency algorithms, simply through brute force deduction. A discussion of the design, implementation, and testing of the Python Sudoku solver can be found in this Topic Paper.

Download Version 0.1 in Python 3 (or higher)

## Fall Semester 2008

### Data Structures Using Java

- Two-Four Tree

Java code that will construct and deconstruct an (2, 4) Search Tree. Includes a bit of testing.

Download Source (NetBeans Project) - Array Heap

Java code that is a test builds a Heap out of an Array. Includes a bit of testing.

Download Source (Eclipse Project) - List Binary Tree

Java code that is a test harness for a List Binary Tree that is implement using left child and sibling instead of left and right children.

Download Source (Eclipse Project) - Sequence Stack

Java code that would implement a Stack using methods from an ArraySequence. It won’t compile or run, so the code is essentially worthless to you and, in fact, anyone.

Download Source - Array Queue

A Java program which implements the Queue interface to develop an ArrayQueue, one that is expandable, supports wrapping, and throws exceptions properly. The main method is a test harness wrapped around the ArrayQueue methods to ensure that the ArrayQueue expands, wraps, enqueues, dequeues, etc. properly.

Download Source (Eclipse Project) - Reverse Polish Notation

A Java program developed to calculate the RPN (Reverse Polish Notation) of an RPN equation. The RPN methods specifically implement java.util.Stack. The main method is simply a test harness wrapped around the RPN methods to ensure that they calculate various types of RPN equations properly.

Download Source (Eclipse Project) - Mega Math

A GUI-based implementation of Factorial and GCD. (After all, who*really*likes entering things through the command line? Besides Linux nerds, I mean.)

Download Source (JBuilder Project) - GCD

A very simply Java program which will calculate the Greatest Common Divisor of two numbers, separated by a space, passed in through the command line.

Download Source - Factorial

A very simple Java program which will calculate the Factorial of a number passed in through the command line.

Download Source

## Fall Semester 2007

### Digital Logic Design (DLD)

#### Lab Reports

- Lab 8 – Creative Design Using Altera CAD Tools and UP1 Board
- Lab 7 – Introduction to the Quartus II Tools and PS/2 Keyboard Interface
- Lab 6 – Four by Four (4 x 4) Sorting Stack
- Lab 5 – Multiplexers and Decoders
- Lab 4 – Three (3) Digit Binary Coded Decimal (BCD) Adder
- Lab 3 – Introduction to CedarLogic
- Lab 2 – Introduction to Combinational Logic Design
- Lab 1 – Introduction to DLD Laboratory

#### CedarLogic Files

- Lab 6 – Four by Four (4 x 4) Sorting Stack
- Lab 5 – Multiplexed Communication Channel
- Lab 4 – Three (3) Digit Binary Coded Decimal (BCD) Adder
- Lab 3 – Full Circuit
- Lab 2 – Full Adder
- Homework – Binary Coded Decimal (BCD) Display
- Homework – 4-Bit Serial Multiplier
- Homework – 4-Bit Parallel Multiplier
- Homework – 2’s Compliment Adder and Subtracter
- Homework – 16 Number Sum and Average