CODEWITHSUNDEEP
python-2.7python-3.x
KSoliman
KSoliman

Reputation: 13

Python: How to create a function that uses its own output and uses an array of random generated numbers

Disclaimer: I am quite new to Python and programming as a whole.

I have been trying to create a function to generated random stock prices using the following:

New stock price = previous price + (previous price*(return + (volatility * random number)))

The return and volatility numbers are fixed. Also, I have generated the random numbers for N times.

The problem is how to create a function that has the output re-used again on itself as an input previous price.

Basically to have an array of NEW stock prices generated from this formula and the previous price variable is the output of the function on itself.

I have been trying to do this for a couple of days and I am sure I am not fully equipped to do it (given that I am a newbie) but ANY HELP would really really be more than appreciated...!!!

Please any help would be useful.

import random

initial_price = 10
return_daily = 0.12 / 252
vol_daily = 0.30 / (math.sqrt(252))


random_numbers = []
for i in range (5):
    random_numbers.append(random.gauss(0,1))

 def stock_prices(random_numbers):
    prices = []
    for i in range(0,len(random_numbers)):
        calc = initial_price + (initial_price * (return_daily+(vol_daily*random_numbers[i])))
        prices.append(calc)
    return prices

Upvotes: 1

Views: 205

Answers (2)

ssm
ssm

Reputation: 5383

This is the classic Markov process. The present value depends upon its previous value, and only its previous value. The best thing to use in this case is what is called an iterator. Iterators can be created to generate arbitrary iterators that model the markov model.

Learn about how iterators can be generated here http://anandology.com/python-practice-book/iterators.html

Now that you have some understanding of how iterators work, you can create your own iterators for your problem. You need a class that implements the __iter__() method and the next() method.

Something like this:

import random
from math import sqrt

class Abc:

    def __init__(self, initPrice):

        self.v = initPrice # This is the initial price
        self.dailyRet  = 0.12/252
        self.dailyVol = 0.3/sqrt(252)
        return

    def __iter__(self): return self

    def next(self):
        self.v += self.v * (self.dailyRet + self.dailyVol*random.gauss(0,1) )
        return self.v


if __name__ == '__main__':

    initPrice = 10
    temp = Abc(initPrice)

    for i in range(10):
        print temp.next()

This will give the output:

> python test.py
10.3035353791
10.3321905359
10.3963790497
10.5354048937
10.6345509793
10.2598381299
10.3336476153
10.6495914319
10.7915999185
10.6669136891

Note that this does not have the stop iteration command, so if you use this incorrectly, you may get into trouble. However, that is not difficult to implement and I hope you try to implement it ...

Upvotes: 0

Byte Commander
Byte Commander

Reputation: 6776

You can't really use recursion here, because you don't have a break condition that ends the recursion. You could construct one by passing an additional counter parameter that specifies how many more levels to recurse, but that would be not optimal in my opinion.

Instead, I recommend you to use a for loop that gets repeated a fixed number of times you can specify. This way you can add one new price value to a list per loop iteration step and access the previous one to calculate it:

first_price = 100
list_length = 20

def price_formula(previous_price):
    return previous_price * 1.2  # you would replace this with your actual calculation

prices = [first_price]  # create list with initial item
for i in range(list_length):  # repeats exactly 'list_length' times, turn number is 'i'
    prices.append(price_formula(prices[-1]))  # append new price to list
    # prices[-1] always returns the last element of the list, i.e. the previously added one.

print("\n".join(map(str, prices)))

My optimization of your code snippet:

import random

initial_price = 10
return_daily = 0.12 / 252
vol_daily = 0.30 / (math.sqrt(252))

def stock_prices(number_of_prices):
    prices = [initial_price]
    for i in range(0, number_of_prices):
        prices.append(prices[-1] + (prices[-1] * (return_daily+(vol_daily*random.gauss(0,1))))
    return prices

Upvotes: 1

Related Questions