1

Stock Market Software First Semester Report

Fall Semester 2012

by

Jordan Courville

Rayan Alanazi

Prepared to partially fulfill the requirements for

ECE401

Department of Electrical and Computer Engineering

Colorado State University

Fort Collins, Colorado 80538

Project advisor: Dr. Edwin Chong g

Approved by: Dr. Edwin Chong g

2

Abstract

The goal of our senior design project is to create a program that forecast the fluctuation of

stock data. These future predictions will help an investor decide if they should sell, buy, or keep

their stock. The ideology might seem unrealistic, but certain companies are known to have such

complex prediction/recommendation programs. Their programs, however, are not open to the

public. Our prediction program will use a company’s historical data to construct the predictions.

The problem that we need to solve is how to create our own successful prediction

algorithm. In order to forecast future stock trends the algorithm will need to use pattern

matching, statistics, linear algebra, and partial differential equations. To achieve this goal we will

use a revolving process consisting of research, design, programming, and testing.

The results found from last semester have shown that singular value decomposition has

very strong predictive power and has great potential in predictive forecasting. They also found a

positive tendency towards accurate predictions of whether a stock price will rise or fall

(Turner, Burkhart, 2).

3

Table of Contents

Title Page 1

Abstract 2

Table of Contents 3

List of Figures and Tables 4

I: Introduction 5

II: Web Crawler 7

III: Mathematical Analysis

A. Singular Value Decomposition 8

B. Method of Prediction 9

IV: Results and Analysis of our Prediction Algorithm 10

V: Matlab Programs

A. Stock Matrix 13

B. Normalization 13

C. NormSubAve 14

D. Overlap 14

E. Right Singular Vectors 14

F. Prediction Algorithm 15

VI: Conclusions and Future Work 16

Bibliography 17

Appendix A – Abbreviations 18

Appendix B – Budget 18

Appendix C – Project Timelines 19

4

List of Figures

Figure 1: Selected Right Singular Vectors (Turner, Burkhart, 10) 8

Figure 2: Magnitude of Variance (Turner, Burkhart, 10) 8

Figure 3: Actual data prices vs. Predicted data prices (Turner, Burkhart, 11) 9

Figure 4: Prediction on General Electric for next 30 days 10

Figure 5: Prediction on General Electric for next 15 days 11

Figure 6: Prediction on General Electric for next 10 days 11

Figure 7: Prediction on Apple for next 15 days 12

5

Chapter I – Introduction The stock market is a primary indicator of the strength of United States’ economy. It

provides a source for companies to raise money. On the market, companies sell shares to

investors and in return the investor gains partial ownership of the company. The investors range

from individual investors to hedge fund traders. Once an investor purchases a share they can sell

or trade the share whenever they so choose. A good investor can become quite rich, by knowing

how to invest in the stock market. The key to turning a profit is to purchase shares when they are

low and sell them when they are high.

For years investors have been trying to forecast stock prices. If they could accurately

determine the future value of a stock they can decide whether to keep, trade, or sell the stock.

However, there are thousands of different factors that will cause a stock to fluctuate, thus

forecasting is difficult. The qualitative factors that play a role are the company image, quarterly

earnings, dividends, national economic status, an election year, ect.

The goal of the design is to write a program that can effectively predict upcoming stock

trends. When we say trends, we are not looking to accurately predict the exact stock value. We

are more interested in the shape, whether the stock is going to rise or going to fall. Our design

takes a quantitative approach and looks at a company’s historical stock. The idea being that over

time stock patterns and trends repeat. The prediction algorithm that we are writing, in Matlab,

relies on the historical stock data and the most recent days of data, to forecast future prices.

This project is a continuation project on its fourth year. Over the past three years every

team has approached the design differently. However, we determined very early in the semester

that we would be using the same prediction method that the 2011-2012 team used. This method

of analysis is a linear algebra tool called Singular Value Decomposition (SVD). The results from

the last semester have shown that Singular Value Decomposition has strong potential in

predictive forecasting. At the beginning stages of the project we were looking to continue to

build on their code. The problem was that neither my partner nor I were experienced with the

program Matlab; trying to read, interpret, and fix somebody else’s code was becoming a

straining task. So we decided to start fresh and write our own code.

Before we could start writing code, in Matlab, we first had to devise a way to get the

stock data for any company on the market and store it. This was done by using Yahoo Finance

along with a web crawler program. Once we define the time window and the companies whose

data we want to analyze we can run the web crawler. The web crawler will automatically

download and store the stock data into a desired folder. The web crawler is discussed further in

Chapter II.

Chapter III contains the mathematical analysis that has been used all year. The first

section of this chapter, section A, goes over a linear algebra tool called singular value

decomposition (SVD). Where SVD is used to break down a KxN matrix X into its principle

components U, S, V; where X = USVT. Our entire prediction method revolves around this linear

algebra tool. In the next section, section B, we go over how SVD is used to create a prediction on

future stock prices. In Chapter IV, Results and Analysis of our Prediction Algorithm, we run our

algorithm to on different companies to see if it can predicted data points.

Chapter V goes over the key subroutine programs created this semester. These programs

are subcomponents that will form our prediction program. Each subroutine plays a vital role in

whether or not our prediction program produces an accurate prediction. Once the historical stock

data was saved into a folder, we could import it into Matlab for analysis using the command

xlsread(‘Stock Name’,’range’). This data was then used to create the stock matrix talked about in

6

section A. This subroutine is titled StockToMatrix.m and its purpose is to create a matrix that

contains the historical stock data. The historical stock data is the engine that drives the entire

prediction algorithm. Also note that this data does not need to be updated, however, since the

data does span over a number of years inflation has accounted for. In order to implement the

effects of inflation we wrote two separate programs, the first is titled Normalization.m and the

second is titled NormSubAve. In section B, we normalize the stock matrix and as a result we get

a new normalized matrix, of the same dimensions as the stock matrix. In section C, we wrote a

program that will determine the mean of the original stock matrix and then subtract it from the

normalization matrix. As a result we get a new matrix, which also has the same dimension as the

stock matrix. When we run the program it gives us a new matrix, of the same dimensions as both

the stock matrix and the normalized matrix. The program in section D, will create a new matrix

and is titled Overlap.m.The rows of this matrix are formed by overlapping the periods of the

historical stock data. The program that we wrote in section E, of Chapter V, will calculate the

singular value vectors, V. This V will be used is a vital part of our prediction algorithm and was

found by applying SVD to the overlap matrix. Section F goes into the details of our prediction

program.

7

Chapter II – Web Crawler The first task that our team had to solve was how to extract historical stock data from the

web. Like Frank Turner and Greg Burkhart we decided to use Yahoo.com to provide this

information. Under the finance section of Yahoo.com you can find the stock data for a

company’s first day on the market to its last day. There are seven different elements that make up

the stock data. For each date there is an opening price, closing price, lowest price, highest price,

volume price, and adjusted closing price. Downloading the stock data will create a .csv file in

Microsoft Excel.

At first we decided to download the stock data over a company's entire existence

manually. The problem with doing this is that it soon becomes tedious. When we want to

perform test on the predictive algorithm, we have to use multiple stocks to check for its validity.

So, instead of sorting through the Yahoo finance page and downloading historical stock for

various companies, we created a web crawler that would do this for us. The web crawler will

download the stock data automatically. All that we need to specify is the list of companies and

for what date range we want. The web crawler will automatically save the spreadsheets to a

designated folder. The web crawler was designed by us, but the original idea was sparked by the

2011-2012 team, Frank Turner and Greg Burkhart.

8

Chapter III – Mathematical Analysis

A. Singular Value Decomposition

At the beginning of the semester we determined that the mathematical method of

prediction we would use was singular value decomposition (SVD). SVD allows us to take a KxN

matrix X and break down into its principle components X = USV’. U is a KxK matrix, where the

m columns of U are known as the right singular vectors. The right singular vectors of X are

eigenvectors of X’X. V is an NxN matrix, where the n columns of V are known as the left

singular vectors. The left singular vectors of X are the eigenvectors of XXT. S is a KxN matrix,

and has non-values along its diagonal called singular values. These values range from largest to

smallest, where the singular values equal the square root of the eigenvalues of XTX and XX

T.

Let X be the KxN matrix formed by stacking the vectors x1,…,xK one on top of another

as rows. Each vector can be represented as a linear combination of V, . If we let

L < N and define we can represent each row Where

are the coefficients (Chong, 1). This is true because

the first L singular values account for the bulk sum of the squared singular values. The results of

figure 1 and figure 2 verify the statement that the first L rows of V carry a bulk of the singular

values (Turner, Burkhart, 10).

Figure 1: Selected Right Singular Vectors Figure 2: Magnitude of Variance

9

B. Method of Prediction

If we let and create a vector , where y represents the first M data

points of a vector and come from the same distribution as We want to predict the

N-M data points. The prediction method starts by defining , where be the first M rows of We now compute

, our prediction

method is as follows, . Then our prediction of the remaining N-M days is

. We use only the first M rows of because we only have the first M components

of (Chong, 2). Figure 3 below represents the plot of what our prediction should look like

(Turner, Burkhart, 11). The blue line of length M represents y, the actual first M data prices. The

red line represents , does not match the actual data perfectly. It is smooth because we are only

using the first L singular values. will produce the section of the red line that

represents the predicted N-M data prices. The purpose is to have the prediction map the actual

data prices of N-M.

Figure 3: Actual data prices vs. Predicted data prices

10

Chapter IV – Results and Analysis of our Prediction Algorithm

We used the prediction method, discussed in section B of chapter III, to create a

prediction algorithm. The prediction algorithm was created in Matlab, and the programs that

were used to create it are discussed in detail in Chapter V. The goal is to have the plots of our

actual analyzed data vs. predicted analyzed data to look similar to figure 3 on page nine.

Throughout the semester we have been using the closing prices as the analyzed data. Before

running the prediction algorithm we must first declare the stockname, period, M, and L. The

stockname indicates the name of the company that we are wishing to perform our prediction

method on. The period, N = period, is the interval of days that we are interested in. M represents

the number of first M known days of data (where the vector y, discussed in section B of Chapter

III, is a vector composed of these first M data points). The value of L is a natural number and is

used to declare the number of important singular vectors, as discussed earlier in section B of

Chapter III. After declaring these four variables we can run the prediction algorithm and obtain

the predicted N – M closing prices.

If we run our prediction algorithm after setting stockname = GE (General Electric),

N= period = 90, M = 60, and L = 10, we get the plot shown in figure 4 below.

Figure 4: Prediction on GE for the next 30 days

If you compare figures 4 and 3, it is evident that the prediction software is not producing

an accurate prediction. If we look at the first M days, we can see that over-fitting is occurring.

The blue line should not perfectly match the red line for the first M days. Instead it should look

resemble figure 3, where the predicted data line will be smooth, but still give the general shape

of the actual data. If we look at the predicted data, the N-M days in this case the next 30 days, we

can tell that the prediction algorithm is not predicting data points that can represent the actual

stock data.

11

If we rerun the prediction algorithm and keep the same stockname, N, and L as before,

but increase the number of days that are known to M = 75. We do this to see if predicting a

smaller number of days will produce better results. Figure 5, below shows the plots of the

predicted closing prices vs. the actual closing prices. Again there is over-fitting for the first

M =75 days (the blue line matches perfectly with the red line) and the predicted M-N = 15 days

is not producing a plot that can represent the M-N = 15 days of actual stock data.

Figure 5: Prediction on GE for the next 15 days

If we continue with the same approach as above, and increase the known days to M = 80

and decrease the days we wish to predict to N – M =10 days. A plot shown in figure 6 shows the

results of predicted closing prices vs. actual closing prices. Once again the first M days of the

plot suggest that the blue predictive curve is experiencing over-fitting.

Figure 6: Prediction on GE for the next 10 days

12

If we change the company that we want to examine to Apple and let the parameters

(N = period, M, L) be set as N = 80, M =65, and L = 10 we obtain the plot in figure 7. Note that

the period had to be changed to N < 85 days, because we need our stock matrix to be a KxN

matrix such that K > N. Figure 7 below represents the plot of the actual closing prices vs. the plot

of the predicted closing prices. Once again the prediction plot is experiencing over-fitting, and

the predicted N-M days does not accurately represent the actual N-M days.

Figure 7: Prediction on Apple for the next 15 days

Based on the results shown in the above figures, it is evident that the code (described in

Chapter V) that our prediction algorithm uses is flawed. The over-fitting that is occurring

suggests that L does not accurately represent what it should. It has been suggested by Dr. Chong

that we may have used M to describe the number of important singular values. If this was the

case it would explain why the predicted plot is experiencing over-fitting.

13

Chapter V – Matlab Programs

Throughout this semester we have primarily be designing and writing code in Matlab, with

the one exception being our web crawler. The programs below are necessary elements of our

prediction algorithm. However, note that based on the results shown in figures 4 through 7, from

Chapter IV, that our code is not functioning as desired.

A. Stock Matrix

The Stock Matrix subroutine program was the first of many programs necessary for

predictive forecasting. The program is dependent on company name, period, and the data

analyzed (let us call these the dependent variables). The data analyzed tells the program what

column of the .csv file should be read (i.e. opening price, closing price, low price, high price,

volume price, or adjustment price). Throughout the semester we have been using the closing

price.

After declaring the dependent variables and running the program, we get our stock

matrix. From this point forward we will call this matrix X, where matrix X is a KxN matrix and

K >N. N equals the period that we declared before running the program. K is the number of rows

of X, and is found by K =⌈

⌉.

A row vector of matrix X is represented by , where each is a

column vector of height N (Chong, 1). Each of these vectors represents the data analyzed of the

company’s stock over N consecutive trading days, indexed by increasing order of days

(Chong, 1).

The stock matrix X is composed of the historical stock data. This variable does not

change. In this program we also define y, where “ representing the first M data points of

a vector we believe is drawn from the same distribution as (Chong, 2).”

B. Normalization

A dilemma for our prediction arises, in the case that the row vectors ( of our

stock matrix X contain stock data from prices spanning over a number of years. This is due to the

fact that the value of currency changes due to inflation (i.e. $20 dollars five years ago held more

value than $20 dollars today). Therefore, in order to get an accurate prediction we need to

account for inflation. We address the problem due to inflation, by normalizing our stock matrix

X (Chong, 4).

Suppose M is a variable that is given (we will explain the need for M later) and that

M<N. We will let represent the row vectors of matrix X

prior to normalization. From chapter four we know that is a vector of stock prices over N

consecutive trading days. If we let our normalized vector of be called

.

Thus, the normalization of matrix X will produce a new matrix Z, which holds the same KxN

dimensions. Note that matrix Z is formed by stacking the row vectors on top of each

other (Chong, 4).

14

In order to use vector y from section B, of this chapter, in our prediction method we also

have to normalize it. Vector y represents the last M days of data points, and is normalized by

, where y(M) is the value of the last M data point (Chong 5). Where ynorm a vector

of length M and is the normalized version of y.

C. NormSubMean

The next program that we wrote was titled NormSubMean. The first operation that the

program performs is calculating the mean of the normalization matrix Z. Where the mean is

described by the following average vector ̅

∑

(Chong, 1).

Once we have our average vector ̅, we subtract ̅ from the normalized ynorm. We

will define ynew to be ̅ . After determining the average vector ̅, we also

need to subtract it from each (Chong,5).

We felt like the easiest way to do this was to create a mean matrix which we called MU

and is composed of ̅ where . Thus, the mean matrix MU has

the dimensions KxN. Now we can subtract the mean matrix MU from our normalized matrix Z,

since they are of the same dimensions. The resulting matrix is our NormSubMean Matrix, which

we will call XNew.

D. Overlap Matrix

The next subroutine program that we wrote is called OverlapMatrix.m. This program will

use the NormSubMean matrix, XNew, to create overlap matrix . Where the

matrix is composed of vectors If we set our period

to N=90, and want our overlap to be 30 days,

= [day 90, day 89,…, day 1]

= [day 121, day 120,…, day 31]

= [day 152, day151 ,…,day 62]

Note that day 1 represents the latest date and that the last data point of matrix

represents the earliest date. If we set the overlap to equal zero, the resulting matrix will be the

same as Xnew. The reason that we wrote this program was for cycling, so that the historical stock

data could be used to predict trends/patterns.

E. Right Singular Vectors

This subroutine program, is used to determine the matrix V (where V is composed of all

the right singular vectors). This program simply reads the result of our overlap matrix program

and applies SVD to the matrix. The program then saves only V.

15

F. Prediction Algorithm

The prediction program is the final program that we wrote this semester. The program is

dependent on the stock name, period, M, and L variables. It begins by calling on our subroutine

program titled RightSingularVectors. The program is also dependent on the ynew found in section

C of this chapter. Using the concepts discussed in the Method of Prediction, section B of Chapter

III, we wrote our prediction program. However, because the stock data spans over years, we

replace the vector y, in section B of chapter III, with ynew. If we run the prediction program with

these changes we obtain a prediction of data. However the predicted data will not make much

sense. “To make use of the predicted values we should add back the average vector ̅

from days M+1 through N and also multiply the result by y(M) to get to actual stock prices

(Chong, 5).” As a result of running this program, we get a table where the values are the

remaining N-M days, indexed in increasing order of days. The results of running our prediction

algorithm can be seen in Chapter V.

16

Chapter VI – Conclusions and Future Work

The main priority for this semester was to create a predictive algorithm, this much was

achieved. The subroutines that are used by the predictive algorithm were those discussed in

Chapter V. We feel like we have a good base for the project, and now that we are more

experienced with Matlab we can continue to progress.

The results from Chapter IV indicate that our prediction algorithm is not coming close to

giving a good prediction curve to represent the actual curve. For starters our prediction curve is

experiencing over-fitting. The expected reason for this is that the first M (instead of L) “singular

vectors are being used to represent bulk of the sum of the squared singular values (Chong 1).”

Also, based on the results, it seems that the only way to make money would be to do the

complete opposite of what the prediction curve indicates (invert the curve).

We recently figured out that we were not reading in the correct data in order to make a

prediction. The stock matrix that we designed reads all of the stock data from the .csv file, and

the y vector was simply the first M days of the first vector of the stock matrix. This is wrong, our

stock matrix needs to contain the historical prices, which remain constant, and the y vector is the

data that needs to be updated consistently (where y represents the stock data over the last M

days)

Even though our results have yet to indicate it, we believe that there SVD has a high

degree of predictive power. In order to prove this though, we are going to have to refine our

coding and continue to run test on the prediction algorithm. We will also have to decide on a

figure of merit, so that we can determine which results are satisfying. Once we feel like we have

an algorithm, after experimentation, that can produce satisfying results we will need to change

the type of data analyzed. Thus far in the project we have been exclusively using the closing

prices. We will need to examine the prediction algorithm when we change the data analyzed to

high prices, low prices, opening prices, volume prices, or adjusted prices. It is expected that the

prediction algorithm would be independent of the analyzed data, but experimentation is

necessary to confirm this. The next step, after creating a prediction algorithm independent of the

data analyzed, would be create a variable that indicates the type of data to be analyzed.

At the end of next semester we are hoping to have a GUI implemented into the design.

Where the user can enter a company’s name and the GUI will give a group of plots. The user can

then decide whether the company is worth investing in.

17

Bibliography

Chong, E.K.P. "Prediction using Principal Components." (2012): 5. Print.

Turner, Frank, and Greg Burkhart. "Stock Market Software." (2012): 18. Print.

18

Appendix A: Abbreviations

SVD – Singular Value Decomposition

X – stock matrix, contains historical stock data

y – contains stock data over the last M days

Appendix B: Budget

This is a theoretical and software based senior design project, therefore we have no

expenses.

19

Appendix C: Project Timelines

Timeline September 3, 2012

Practice writing and reading matlab code

Reading matlab books

Finding code from online and

experiment with it.

(Summer-Present)

Read the final report of last year’s team and

their project continuation description. (8/20/12-8/25/12)

Obtain code from the 2011 senior design team. (8/26/12-9/1/12) Begin studying the current market stock

predictor programs, and decompose them to

figure out the method they used. We will do

this to see if there is an overlapping theme in

programs and then decide for ourselves what

direction we want to take.

(9/2/12-9/22/12)

Begin decomposing the code to understand its

purpose. (9/23/12-10/6/12)

Have either Frank or Greg run us through the

code and how it works (i.e. what functions it is

performing). Ask them where they left off and

what troubles they had.

(9/23/12-10/6/12)

Research the different methods of prediction (10/7/12-10/20/12) Determine if we want to continue working in

Greg’s and Frank’s direction or start over with

a new approach.

(10/21/12-10/27/12)

Pick the route that we want to take with the

method of prediction.

SVD

Correlation Coefficient

Bergman co-clustering

(10/21/12-10/27/12)

Determine how we want to analyze the data

(i.e. how/if we want to group the data to

analyze it). Whether it is looking at the data as

a whole, through a bear market, or through a

bull market. We also want to consider how/if

we should group the data (i.e. Microsoft,

Apple, Linux would fall under the computer

category and GE and Ford would fall into the

vehicle category).

(10/28/12-11/10/12)

Begin extracting stock market data, using a

web crawler to put the data into matlab. (11/11/12-11/24/12)

Start writing our matlab code for predicting the

rise and fall of stocks. (11/25/12-12/1/12)

20

Second Semester

Design pattern matching software. Week 1 - Week 5 Update web-crawler and implement prediction

software.

Week 6 - Week 9

After finishing writing code, we need to run

analysis and preform experiments on the code.

Week 10 - Week 12

Debug the code, and increase performance. Week 13 - Week 14 Summarize findings in a report. Week 15 - Week 16

Timeline: October 17, 2012

Task Begin End Assigned

Design web-crawler Monday 9/03/12 Thursday 9/20/12 Jordan

Design website Wednesday 9/12/12 Wednesday 9/19/12 Group

Notebook collection Monday 9/17/12 Friday 9/21/12 Individual

Research SVD

method of prediction

Monday 9/03/12 Sunday 9/30/12 Group

Complete

understanding of

previous teams code

Monday 9/03/12 Sunday 10/17/12 Group

Notebook collection Monday 10/08/12 Friday 10/12/12 Individual

Test StockToMatrix

algorithm (we will be

using Frank’s and

Greg’s

StockToMatrix

algorithm)

Monday 10/15/12 Wednesday 10/17/12 Jordan

Testing and

Measurement plan

Monday 10/15/12 Friday 10/19/12 Group

Research pattern

matching algorithm

Sunday 10/21/12 Wednesday 10/31/12 Rayan

Design our pattern

matching algorithm

Saturday 10/21/12 Saturday 11/03/12 Jordan

Notebook collection Monday 11/05/12 Friday 11/09/12 Individual

Test and debug

pattern matching

program

Monday 11/05/12 Friday 11/09/12 Jordan

Research prediction

algorithm

Monday 11/05/12 Friday 11/09/12 Rayan

Design our prediction

program

Saturday 11/10/12 Monday 11/19/12 Jordan

Test and debug

prediction program

Monday 11/19/12 Wednesday 11/21/12 Group

Run experiments on

prediction program

Monday 11/19/12 Saturday 12/01/12

Group

21

Summarize findings

in report

Monday 11/26/12 Wednesday 12/05/12 Group

Written report due Wednesday 12/05/12 Wednesday 12/05/12

Second Semester

Create a test bench

program

Monday 12/31/12 Monday 1/14/13 Rayan

Create an algorithm

that randomly predicts

stock fluctuations

Monday 1/14/13 Monday 1/28/13 Jordan

Create new

experiments for our

code.

Monday 1/14/13 Saturday 2/02/13 Rayan

Compare prediction

program to the

random guesser

program.

Monday 1/28/13 Saturday 2/02/13 Group

Create a bankroll

program.

Sunday 2/03/13 Saturday 2/16/13 Jordan

Test the bankroll

program.

Sunday 2/17/12 Friday 2/22/12 Rayan

Modify our prediction

program, to obtain

better results.

Saturday 2/23/13 Sunday 3/03/13 Jordan

Increase the

dimensionality of our

program, to be able to

make predictions on

all the elements of the

stock data.

Monday 3/04/13 Monday 3/18/13 Group

Rerun experiments on

the code.

Tuesday 3/19/13 Saturday 3/23/13 Rayan

Create new

experiments for our

code

Tuesday 3/19/13 Wednesday 4/02/13 Jordan

Prepare for E-days Tuesday 3/19/13 Thursday 4/12/13 Group

Run more

experiments

Friday 4/13/13 Saturday 5/04/13 Group

Write final report Sunday 4/28/13 Saturday 5/11/13 Group

22

Timeline: December 7, 2012

Task Length Begin End Assigned

Researching and practicing writing Matlab code 11 days Sat 8/11/12 Thu 8/23/12 Jordan

Reviewing last team's code and final paper 7 days Fri 8/31/12 Sun 9/9/12 Group

Research how to create a web-crawler 7 days Fri 8/31/12 Sun 9/9/12 Jordan

Research SVD method of Prediction 26 days Mon 9/3/12 9/30/12 Group

Design web-crawler 1 day Sun 9/9/12 Sun 9/9/12 Group

Design website 6 days Wed 9/12/12 Wed 9/19/12 Group

Notebook collection 3 days Mon 9/17/12 Fri 9/21/12 Individual

Researching low rank approximation 3 days Fri 9/28/12 Tue 10/2/12 Group

Commenting Frank's and Greg's code 1 days Thu 10/4/12 Thu 10/4/12 Jordan

Notebook collection 3 days Mon 10/8/12 Fri 10/12/12 Individual

Testing and measurement plan 6 days Mon 10/8/12 Sat 10/15/12 Group

Meeting with Frank Turner to go over his team's

coding 1 day Wed 10/17/12 Wed 10/17/12 Group

Create Stock Matrix subroutine program 11 days Mon 10/22/12 Fri 11/2/12 Jordan

Reviewing Dr. Chong's Prediction using Principle

Components 22 days Sat 10/27/12 Fri 11/23/12 Group

Notebook collection 3 days Mon 11/5/12 Fri 11/9/12 Individual

Modifying and debugging Stock Matrix subroutine

program 16 days Mon 11/5/12 Fri 11/23/12 Jordan

Design a Normalization program, then modify and

debug the program 7 days Sun 11/18/12 Sun 11/25/12 Jordan

Design NormSubAve subroutine program, then

modify and debug the program 7 days Sun 11/18/12 Sun 11/25/12 Jordan

Design Overlap subroutine program, modify and

debug 6 days Mon 11/19/12 Sun 11/25/12 Jordan

23

Design Right Singular Vectors subroutine

program, modify and debug 6 days Mon 11/19/12 Sun 11/25/12 Jordan

Design Prediction program, modify and debug 5 days Tue 11/20/12 Sun 11/25/12 Jordan

Link all subroutine programs to our Prediction

Program 2 days Mon 11/26/12 Tue 11/27/12 Jordan

Prepare Oral Presentation 6 days Fri 11/30/12 Wed 12/5/12 Group

Summarize findings in report 8 days Fri 11/30/12 Fri 12/7/12 Group

Presentation 0 days Wed 12/5/12 Wed 12/5/12 Group

Written report due 0 days Fri 12/7/12 Fri 12/7/12 Group

Notebook Collection 0 days Mon 12/10/12 Mon 12/10/12 Individual