Evaluating Stocks Program

[Polantaris]

My coworker gave me a program for me to create for her husband (I guess his work? I don't know). The program should evaluate stocks between days/months, and create an evaluation report (csv file) based on the evaluations per day, and also a result of buys/shorts in each individual stock name.

It sounds a little confusing, but overall it hasn't really been TOO hard to program. The issue I have more of is the wording, and I'm not sure if my evaluation is being done properly.

Wording of Problem

In this section we need to implement a Contrarian trading strategy and see how it fares over sample stock data. More specifically, given a universe of stock, for each day, rank their returns in the previous day. Then short the top p percent of these stocks and buy the bottom p percent. The strategy’s return can be simply calculated using the average return of the bottom stocks minus the average return of the top stocks. The holding period for each stock will be one day, and new positions will be taken each day.

On each day (from Start Date to End Date), sort the stocks by their daily return. Choose the top P percent and sell them short and buy the lowest P percent. Evaluate the return for these stocks on the following day. No new positions should be taken on End Date.

So, using that description I have created the following code (A lot is excluded, the important part is below)

Code

	public static void shortNBuy(Vector<Stock> stocks, Vector<String> stockNames, int[] buys, int[] shorts, 
								int perc, Vector<String> days, Vector<Double> dailyReturn)
	{
		//Initialization
		Vector<Stock> dayStocks = new Vector<Stock>();
		Vector<Stock> prevBuy = new Vector<Stock>();
		Vector<Stock> prevShort = new Vector<Stock>();
		Vector<Stock> newBuy = new Vector<Stock>();
		Vector<Stock> newShort = new Vector<Stock>();
		int prevDaySize = 0;
		for(int date = smallestDay; date < biggestDay; date++)
		{
			//If it is not the first day, set the previous day's lists.
			if(date != smallestDay)
			{
				prevBuy = new Vector<Stock>(newBuy);
				prevShort = new Vector<Stock>(newShort);
				prevDaySize = dayStocks.size();
			}	
			//reset day's lists.
			newBuy = new Vector<Stock>();
			newShort = new Vector<Stock>();
			dayStocks = getOneDate(stocks, date);
			if(dayStocks.size() > 1 && date != biggestDay)
			{
				int percToTrade = dayStocks.size() / perc;
				//Cannot work with 0 buy/sell.
				if(percToTrade <= 0)
					percToTrade = 1;
				//Buy the bottom percentage.
				for(int i = 0; i < percToTrade-1; i++)
				{
					String ticker = dayStocks.elementAt(i).getTicker();
					newBuy.add(dayStocks.elementAt(i));
					int index = stockNames.indexOf(ticker);
					buys[index] += 1;
				}
				//Short the top percentage.
				for(int i = dayStocks.size() - percToTrade-1; i < dayStocks.size(); i++)
				{
					if(i < 0)
						break;
					String ticker = dayStocks.elementAt(i).getTicker();
					newShort.add(dayStocks.elementAt(i));
					int index = stockNames.indexOf(ticker);
					shorts[index] += 1;
				}
			}
			//If it is the first day, there are no returns to evaluate.
			if(date == smallestDay || prevDaySize <= 0 || prevBuy.size() <= 0 || prevShort.size() <= 0)
				continue;
			double prevAvgBuy = 0.0, prevAvgShort = 0.0;
			for(int i = 0; i < prevBuy.size(); i++)
			{
				prevAvgBuy += prevBuy.elementAt(i).getRet();
			}
			for(int i = 0; i < prevShort.size(); i++)
			{
				prevAvgShort += prevShort.elementAt(i).getRet();
			}
			prevAvgBuy /= prevBuy.size();
			prevAvgShort /= prevShort.size();
			//To get return, bottom stocks (bought) - top stocks (short).
			//Because bottoms stocks are negative in data, you add them.
			//EX: -1 + 2 = 1 / Low - High.
			double retu = prevAvgBuy + prevAvgShort;
			days.add(""+date);
			dailyReturn.add(retu);
		}
	}

So, although this coding block is a tad long, here's what it essentially does:
For every day between the smallestDay and biggestDay (Defined earlier, can change depending on input, but is set to not surpass the input file's bounds), it does the following:
If it's not the first day, it sets the Vectors for the previous Day's Buys and Shorts.
Then it resets the Vectors for the current day's Buys and Shorts (So that there is no accidental overlap).
Then, as long as it is not the last day, it does the current Day's trading and records them in the current day's Buys and Shorts, as well as adding them into Vectors for the total buys/shorts of a single stock.
Then, as long as it is not the first day, it does a comparison of the previous day's returns.

Here's the issue I'm having: Due to the wording (or my misunderstanding of the wording), I'm not sure if I should be evaluating the returns of the current day compared to the previous day's for the same stock, or just doing calculations on the previous day's return. I think the latter sounds a little silly (why wouldn't I just do it on the same day?), but really I'm unsure and I don't really want to write a whole lot if it will end up useless.

So really, at this point, I'm mostly looking for an outside thought at the moment as to what I need to do for the last part of this. The recording of total buys/shorts works, and the returns work as is, but I feel like they are wrong because of this misunderstanding of the wording.

If anyone has any insight, I would love to hear it. I still have some other stuff for this project (I have to implement a monthly returns scenario too), but it shouldn't be too hard once I figure this out.

Also, my code may not be the most efficient at the moment, but right now I'm more concerned with getting this working before my coworker needs it. If I have time left later I can tidy it up, but I'm still unsure of when she wants it by so I'm trying to get it working first.

Edit: So I ended up changing the lower section of the code to the following:

Code

//If it is the first day or an empty previous day, 
			//there are no returns to evaluate.
			if(date == smallestDay || prevDaySize <= 0 || prevBuy.size() <= 0 || prevShort.size() <= 0)
				continue;
			double[] buyAvgs = new double[prevBuy.size()];
			double[] shortAvgs = new double[prevShort.size()];
			int index = -1;
			//Add all Single Average Buys to a list to be averaged.
			for(int i = 0; i < prevBuy.size(); i++)
			{
				index = -1;
				for(int j = 0; j < dayStocks.size(); j++)
				{
					if(dayStocks.elementAt(j).getTicker().equals(prevBuy.elementAt(i).getTicker()))
					{	
						index = j;
						break;
					}
				}
				if(index >= 0)
					buyAvgs[i] = dayStocks.elementAt(index).getRet() - prevBuy.elementAt(i).getRet();
				else
					buyAvgs[i] = 0 - prevBuy.elementAt(i).getRet();
			}
			for(int i = 0; i < prevShort.size(); i++)
			{
				index = -1;
				for(int j = 0; j < dayStocks.size(); j++)
				{
					if(dayStocks.elementAt(j).getTicker().equals(prevShort.elementAt(i).getTicker()))
					{	
						index = j;
						break;
					}
				}
				if(index >= 0)
					shortAvgs[i] = dayStocks.elementAt(index).getRet() - prevShort.elementAt(i).getRet();
				else
					shortAvgs[i] = 0 - prevShort.elementAt(i).getRet();
			}
			double buyTotal = 0.0;
			for(int i = 0; i < buyAvgs.length; i++)
				buyTotal += buyAvgs[i];
			buyTotal /= buyAvgs.length;
			
			double shortTotal = 0.0;
			for(int i = 0; i < shortAvgs.length; i++)
				shortTotal += shortAvgs[i];
			shortTotal /= shortAvgs.length;
			
			double retu = buyTotal + shortTotal;
			days.add(""+date);
			dailyReturn.add(retu);

Basically it compares each of the previous day's sold/purchased stock to the current day's value. It subtracts current - previous, because I want the difference. I then average both bought and shorted stocks, and do the same buy + short as before.

In case anyone was wondering, if I do buy - short (As it is described in the documentation), Everything ends up positive change, so I know it's wrong (Sometimes as high as 14 or 15 percent).

I'm still not sure if this is right, but I cannot keep sitting around thinking about it so I did it anyway, and commented out the old stuff just in case I need to go back.