Python Project

Dictionaries and Files

This project allows read/write files in the CSV format. More specifically, I have write Python code that reads in annual population estimates for 50 states and the District of Columbia as released by U.S. Census Bureau.
I have created dictionary entries for individual states, reading, combining and relating data from multiple years, providing brief reports and finally storing data into another CSV format file. You must define certain functions in you resolution, with the described behaviors. I have created a simple menu structure for testing purposes.
I have written a program that will read data from a file, it creates dictionaries with the data and we will creates statistics from them. In the end we will write these reports in files. Show the menu helps to understand what this program does with data that has been read by the CSV file.

This menu makes more user friendly to understand:
• Choose an option:
• 0 - clear out current population data
• 1 - display current report
• 2 - read file, update current population data
• 3 - write report file about current population data
• 4 - write statistics file about current population data
• 5 - quit

Java Projects

Project Five - Gate Simulator

This project was a simulator for logic gates. I read in descriptions of circuits from files, created and attached the necessary gates and wires, and then I tried propagating signals through the structures to see what the outputs are. Along the way, I was playing with the List as one of my first examples of Java's generics.
At the near-lowest level, a processor is just billions of logical gates glued together to represent ever more complex structure and calculations. Mathematical operations, registers, really everything that our computers do can be traced down to the gates and wires at some point. I have modeled some simple logic gates, which each accept some inputs and generate an output. For instance, the AND gate can accept two inputs that are each either high or low signals. If all (both) inputs are high, the output is also high; if any signals are low, we can specify the output as low. This is analagous to the && operator, treating true as a high signal and false as a low signal. I have also represent 'unknown' signals. If we think of the voltage running through a wire as high or low, there's a middle ground (or a time waiting for the magnitude to stabilize) when I don't know what the answer is yet; I have modeled this to a small degree in my project as well.

For a detailed information check out the API documentation that I have created for this project on Project 5 API

Project Six - You Must Fit It. Fit It Good.

This project presented an opportunity in which a rough design is required (a few classes and interfaces are required) but there was otherwise have a free hand to create whatever classes are necessary to solve the given problem.
Two-Dimensional Packing
Packing shapes into fixed size containers is an old problem with continued applications, particularly in shipping and handling services. For example, online retailers may seek to pack as many items in an order as possible into a single box to reduce shipping costs. On a larger scale, packing shipping containers onto oceanic container ships that travel around the world devolves to the same basic problem of packing a set of objects into a fixed volume.
This project will focus on a problem in this class which has the following properties. So, I have to write program that packs different kind of shapes on a box that we will try to fit as much as possible if we can.

For a detailed information check out the API documentation that I have created for this project on Project 6 API

Computer Systems Project

Lab 1: Floating Point Representation

I implemented a 10 bit floating point representation, where 4 bits are for the exponent and 5 are for the fraction. Using bit level operators, I wrote functions to help implement the program statements:
-- computeFP() will be called that will take the input floating point value and convert it to our 10 bit representation, returning this as an integer. This integer will be saved as the value of the given variable.
-- float getFP(int val) for this function, the value of the variable in our representation will be converted back to a C floating point using your function and this will be printed. // Using the defined representation, compute the and return the floating point value
-- int addVals(int source1, int source2) for this statement, I took the two values in our representation and use the same the formula to devide one of the numbers until they have the same comon exponent to add these values and return the result in our representation.
-- int multVals(int source1, int source2) for this statement, I took two values in our representation and use the same formala to find the common exponent and multiply these values and return the result in our representation.

Lab 2: Defusing a Binary Bomb

A binary bomb is a program that consists of a sequence of phases. Each phase expects you to type a particular string on stdin. If you type the correct string, then the phase is defused and the bomb proceeds to the next phase. Otherwise, the bomb explodes by printing "BOOM!!!" and then terminating. The bomb is defused when every phase has been defused.
To difuse the boombs I used gdb debbuger to step into instructions code to find where the bombs where hided it and to set the breakpoints to avoid steping bombs. After I found the bombs, I took the part of instructions where the bomb was and from reading the function instruction on that code I figure out what the string need to be to pass without stepping on bomb. It was fun Lab because it made my mind work and figure out how some of data structers were represent on assembly code.

Lab 3 Heap Memory Management

For this assignment, I use C to implement a simulation of the algorithms for implicit lists.Using C I will represent the current free list after calls to malloc(), free(), and realloc() that I will implement for the heap. For example, initially, the entire heap is available in one block.

Lab 4: Address Translation

I implemented a virtual to physical memory mapping using bit- level operators for the given scheme: Virtual address – 20 bits total with an 11-bit offset. This means we are using 9 bits to hold the VPN, so the page table will have up to 29 entries. The TLB is a direct mapped cache using 4 index bits and 5 tag bits in the same manner as described in class. The data in this cache will be a 13 bit PPNPhysical address – 24 bits total – the PPN will be 13 bits with the 11-bit offset. Both the virtual address and physical address are fewer than 32 bits in length and will fit into a standard 32 bit integer. You must use an integer (and bit-level operators) to do your work. Use masks and shifting to get to the parts of the address you need to use at a given time. The TLB is initially empty – when you get a page table hit, I will update the TLB appropriately so that the next time an address with the same physical page number is referenced, I will be able to get it from the TLB instead of the page table.

Data Structure Projects

Projects to be updated

Low Level C Project

Steganography program

The Steganopraphy program consisted in two part program.

The first program is called Stego.c and what it does it reads an information from any kind of file and hides this information in a image file of pgm format. The image remain the same because all what we change on image file is going to be the last significant bit of the image file. The amount of the information to hide is restricted to the size of image file because we don't want to change more than one byte every bit of image file to not lose image quality from the orginal one.

The second program will be called StegoExtract.c by using this program we will be able to extra the information that we hide on the image on the first part. Our StegoExtract it will create a new file with same information as the one hided and same format.

Database Concepts Project

Designed a database system in different phases that will work in application program.

Phase 1: E-R Modeling

Designed an Entity-Relationship of a department store environment, in the form of an annotated diagram. Click here to view the diagram pdf of E-R..

Phase 2: Relational Modeling

Converted the Entity-Relationship design to a schema for a relational database. For each relation schema I have state the name of the relation, the names of the attributes, the domains of the attributes, the primary keys and the foreign keys. By cliking here it will display all the relation database.

Phase 3: Database Installation

I created an ORACLE “department store” database that corresponds the design in phase 1 and 2 which include all appropriate constraints. Also, I have load the database with more than 250 tuples which will help to test the database. I have generate a “printout” showing all relation schemas and relations.

Phase 4: Relational Algebra

Using the data that we created on the previous phase we will formulate relation algebra queries for each statements. To evaluate this queries will be using reaval software which is straight forward langauge from relation algebra. The queries3.pdf contain the relation algebra queries and excute3 contains the log file from reveal for each table and statements.

Phase 5: SQL statments queries

From the database in phase 3 and the relation algebra in phase 4 we will create SQL statements queries with some that are similiar to the one in phase 4. Also, some of the statments are new since we need to use some more functionalities that SQL gives us. In queries.txt file you will find the excutions of the sql statements and the output using database that we used in created in phase 3.

Phase 6: Java Embedded SQL Program

In this last phase I wrote an application program in java that uses all the concepts from previous phase. So, we connect our program with the database that we creted. I wrote the sql statments to get information about the customers and procurements to perform quarter reports for the given dates. The output.txt file displays the script when we run the application.