Hacked together script to test a stock portfolio strategy over a long historical period

stocks.rb

# Stock simulation script
# 
# reads in historical values from 'testdata.csv' and tests
# whether or not the programmed trading algorithm beats
# the market

require 'date'
require 'csv'
require 'bigdecimal'

# node of doubly linked list
class Day

    attr_reader :date, :close
    attr_accessor :nxt, :prev
    
    def initialize(date, close, nxt = nil, prev = nil)
        @date = Date.parse(date)
        @close = BigDecimal(close)
        @nxt = nxt
        @prev = prev
    end

    def change
        return 0 if prev == nil
        (close - prev.close) / prev.close
    end

    # returns 1 if there have been (days) consecutive days of the market going up
	# returns -1 if there have been (days) consecutive days of the market going down
	# otherwise returns 0
	def check(days = 1)
        if prev == nil or prev.prev == nil
            return 0
        end
        node = prev
        if node.change > 0
            (days-1).times do
                node = node.prev
                return 0 if node.change <= 0 or node.prev == nil
            end
            return 1
        elsif node.change < 0
            (days-1).times do
                node = node.prev
                return 0 if node.change >= 0 or node.prev == nil
            end
            return -1
        else
            return 0
        end
    end

    def to_s
        "Date: #{date} Closing Price: #{close.to_s('F')}"
    end

end

# basically serves instantiate the list from the csv
class DayList

    attr_reader :head

    def initialize(filename)
        @head = nil
        CSV.foreach(filename, :headers => true) do |row|

            unless head
                @head = Day.new(row['Date'], row['Close'])
            else
                @head.prev = Day.new(row['Date'], row['Close'], @head)
                @head = @head.prev
            end

        end
    end

end


class Position

    attr_reader :principle, :balance, :transactions

    def initialize(seed)
        @principle = BigDecimal(seed.to_s)
        @balance = BigDecimal(seed.to_s)
        @transactions = []
    end

    def invested
        @transactions.length > 0 and @transactions.last.value == nil
    end

    def buy(date)
        @transactions.push Transaction.new(date, @balance) unless invested
    end

    def sell(date)
        @transactions.last.complete(date, @balance) if invested
    end

    def apply(change)
        @balance += @balance * change if invested
    end

end


class Transaction

    attr_reader :buyDate, :cost, :sellDate, :value

    def initialize(date, cost)
        @buyDate = date
        @cost = cost
        @sellDate = nil
        @value = nil
    end

    def complete(sellDate, value)
        @sellDate = sellDate
        @value = value
    end

    def to_s
        "Bought #{@buyDate} for #{@cost.round(2).to_s('F')}, Sold #{@sellDate} for #{@value.round(2).to_s('F')}"
    end

end

list = DayList.new('testdata.csv')

# test tests the implemented algorithm
test = Position.new(100000)

# control leaves its money in the market the whole time
control = Position.new(100000)

node = list.head
while node

    control.buy(node.date) unless control.invested

    if test.invested

        if node.check(2) < 0 and test.transactions.last.cost < test.balance

            test.sell(node.date)

        else

            test.apply(node.change)
        end

    else

        if node.check(2) > 0

            test.buy(node.date)
            test.apply(node.change)

        end

    end

    control.apply(node.change)

    # sell before the simulation runs out
	unless node.nxt
        test.sell(node.date)
        control.sell(node.date)
    end

    node = node.nxt

end

puts 'Test Portfolio:    ' << test.balance.round(2).to_s('F')
puts 'Control Portfolio: ' << control.balance.round(2).to_s('F')
puts 'Transactions:      ' << test.transactions.length.to_s

testdata.csv