def test_constructor(self): # unit tests for the investment constructor that pass input to # arguments positoins and num_trials self.assertEqual(investment([1, 10, 100], 1000).positions, [1, 10, 100]) self.assertEqual(investment([1, 10, 100], 1000).num_trials, 1000)
def test_investment(self): """ Tests to make sure that the class investment yields correct output for given input """ self.assertEqual(investment([1, 10, 100], 100).positions, [1, 10, 100]) self.assertEqual(investment([1, 10, 100], 100).num_trials, 100) self.assertEqual(investment([1, 100], 1000).positions, [1, 100]) self.assertEqual(investment([1, 100], 1000).num_trials, 1000)
def test_investment(self): """ Tests to make sure that the class investment yields correct output for given input """ self.assertEqual(investment([1,10,100], 100).positions, [1,10,100]) self.assertEqual(investment([1,10,100],100).num_trials, 100) self.assertEqual(investment([1,100],1000).positions, [1,100]) self.assertEqual(investment([1,100],1000).num_trials,1000)
def result_output(positions_set, num_trials): ''' This function outputs daily return performances in both PDF and TXT files. ''' text_file = open('results.txt', 'w') for p in positions_set: # for each position value, get investment performance result as a numpy array daily_ret = investment(int(p), num_trials).daily_returns() # plot the histogram of daily return and export PDF file for each position fig = plt.figure(figsize=(7, 4)) plt.hist(daily_ret, 100, range=[-1, 1], alpha=0.5) plt.title( 'The histogram of the result for {}-position of ${:d}'.format( p, int(1000 / int(p)))) plt.xlabel('Regularized Daily Return') plt.ylabel('Number of Trials') pdf_name = 'histogram_{}_pos.pdf'.format(str(p).zfill(4)) fig.savefig(pdf_name) # write the daily return's mean and standard deviation for each position to a txt file mean = np.average(daily_ret) std = np.std(daily_ret) text_file.write( 'For position = {}, the mean of daily return is {:f}, and the standard deviation is {:f}.\n' .format(p, mean, std)) text_file.close()
def result_output(positions_set, num_trials): ''' This function outputs daily return performances in both PDF and TXT files. ''' text_file = open('results.txt', 'w') for p in positions_set: # for each position value, get investment performance result as a numpy array daily_ret = investment(int(p), num_trials).daily_returns() # plot the histogram of daily return and export PDF file for each position fig = plt.figure(figsize=(7, 4)) plt.hist(daily_ret, 100, range=[-1, 1], alpha=0.5) plt.title('The histogram of the result for {}-position of ${:d}'.format(p, int(1000/int(p)))) plt.xlabel('Regularized Daily Return') plt.ylabel('Number of Trials') pdf_name = 'histogram_{}_pos.pdf'.format(str(p).zfill(4)) fig.savefig(pdf_name) # write the daily return's mean and standard deviation for each position to a txt file mean = np.average(daily_ret) std = np.std(daily_ret) text_file.write('For position = {}, the mean of daily return is {:f}, and the standard deviation is {:f}.\n'.format(p, mean, std)) text_file.close()
def test_investment(self): inv = list(investment([1], 100000).result()[1].values()) c = Counter(inv) # how many times to get the 2000 (which is 1 as daily_ret) pos = c[1] # how many times to get the 0 (which is -1 as daily_ret) neg = c[-1] self.assertAlmostEqual(round(pos / (neg + pos), 3), 0.51, places=2)
def test_investment(self): inv = list(investment([1], 100000).result()[1].values()) c = Counter(inv) # how many times to get the 2000 (which is 1 as daily_ret) pos = c[1] # how many times to get the 0 (which is -1 as daily_ret) neg = c[-1] self.assertAlmostEqual(round(pos/(neg+pos),3), 0.51,places=2)
def total_gain(sharesNumber, num_trials): '''This function gets a position, number of shares in one day, and number of trials or days. It returns the total gain over all the trials.''' from numpy import zeros daily_ret = zeros((num_trials,1)) for trial in range(num_trials): position_object = investment(sharesNumber) #Create an investment object daily_ret[trial,0] = position_object.daily_gain() #find the gain in a single day return daily_ret
def main(): while True: try: positions_input = input( "Please enter a list of number of shares to buy in parallel:") if positions_input == 'quit': sys.exit() ## check input if positions_input == '': raise ValueError("invalid input") if positions_input[0] != '[' or positions_input[-1] != ']': raise ValueError('input need be a list') else: positions = positions_input[1:-1].split(',') for i, item in enumerate(positions): positions[i] = int(item) break except KeyboardInterrupt: sys.exit() except EOFError: sys.exit() while True: try: num_trials_input = input( 'Please input a number of trials you want or enter quit to end:\n' ) if num_trials_input == 'quit': sys.exit() ##check input if num_trials_input == "": raise ValueError('invalid input') num_trials = int(num_trials_input) if num_trials <= 0: raise ValueError('Please enter a positive integer') break except KeyboardInterrupt: sys.exit() except EOFError: sys.exit() for pos in positions: inves = investment(pos, num_trials) inves.output_histogram() inves.print_result()
def main(): while True: try: positions_input = input("Please enter a list of number of shares to buy in parallel:") if positions_input == 'quit': sys.exit() ## check input if positions_input == '': raise ValueError("invalid input") if positions_input[0] != '[' or positions_input[-1] != ']': raise ValueError('input need be a list') else: positions = positions_input[1:-1].split(',') for i, item in enumerate(positions): positions[i] = int(item) break except KeyboardInterrupt: sys.exit() except EOFError: sys.exit() while True: try: num_trials_input = input('Please input a number of trials you want or enter quit to end:\n') if num_trials_input == 'quit': sys.exit() ##check input if num_trials_input == "" : raise ValueError('invalid input') num_trials = int(num_trials_input) if num_trials <= 0: raise ValueError('Please enter a positive integer') break except KeyboardInterrupt: sys.exit() except EOFError: sys.exit() for pos in positions: inves = investment(pos,num_trials) inves.output_histogram() inves.print_result()
def main(): try: positions = raw_input("Enter a list of the number of shares to buy in parallel: e.g. 1,10,100,1000 \n") positions_split = positions.split(",") position_list = [int(position) for position in positions_split] except: print ("Invalid Input. Please Enter a list of the number of shares, e.g. 1,10,100,1000 \n") try: num_trials = int(raw_input("How many times to randomly repeat the test?\n")) except: print ("Invalid Input. Please enter an positive integer") outcome = investment(position_list, num_trials) outcome.investments()
def loop(): positionList = getListPositions() num_trials = getNumTrials() clearTextFile(outputFile) for position in positionList: #instantiate investment object for current investment currInvestment = investment(investment_amount,position,pr_lose) cumu_ret = np.zeros(num_trials) daily_ret = np.zeros(num_trials) for trial in range(0, num_trials): cumu_ret[trial] = currInvestment.simulate_day() daily_ret[trial] = cumu_ret[trial]/investment_amount-1 printStatistics(outputFile,currInvestment.numShares,daily_ret) plotPositionHistogram(currInvestment.numShares,daily_ret)
def main(): try: positions = raw_input( "Enter a list of the number of shares to buy in parallel: e.g. 1,10,100,1000 \n" ) positions_split = positions.split(",") position_list = [int(position) for position in positions_split] except: print( "Invalid Input. Please Enter a list of the number of shares, e.g. 1,10,100,1000 \n" ) try: num_trials = int( raw_input("How many times to randomly repeat the test?\n")) except: print("Invalid Input. Please enter an positive integer") outcome = investment(position_list, num_trials) outcome.investments()
def test_stimulate(self): """unit tests for testing stimulate method. We test the each value of the return dictionary 'result' has the same length as num_trials, and every element in the value of dictionary 'result' bigger than or equal to -1, and less than or equal to 1 """ a = investment([1, 10, 100], 1000) result = a.stimulate([1000.0, 100.0, 10.0], 1000) self.assertEqual(len(result[1]), 1000) self.assertEqual(len(result[10]), 1000) self.assertEqual(len(result[100]), 1000) self.assertTrue(result[1].all() <= 1) self.assertTrue(result[1].all() >= -1) self.assertTrue(result[10].all() <= 1) self.assertTrue(result[10].all() >= -1) self.assertTrue(result[100].all() <= 1) self.assertTrue(result[100].all() >= -1)
def main(): """ The main function takes a list of the number of shares to buy in parallel as positions and how many times to randomly repeat the test as num_trials """ while True: try: position = input('Please input a list of shares to buy:\n') if (position == 'quit'): sys.exit() position = position.replace(' ', '') positions = position[1:-1].split(',') for i, item in enumerate(positions): positions[i] = int(item) break except ValueError: print('Invalid input!') except KeyboardInterrupt: sys.exit() except EOFError: sys.exit() while True: try: num_trials = int(input('Please input how many times you want to repeat the test')) break except ValueError: print('Invalid input!') except KeyboardInterrupt: sys.exit() except EOFError: sys.exit() #call the class investment constructor to create an object a a = investment(positions, num_trials) #call the method 'represent_results' in class investment to do the stimulation and represent the result a.represent_results(positions, num_trials)
def testSimulate(self): """Tests for function Simulate""" self.assertTrue(len(investment.simulate(investment(100, 10))) == 10) self.assertTrue(all(investment.simulate(investment(100, 10))) <= 1) self.assertTrue(all(investment.simulate(investment(100, 10))) >= -1)
def testInvestment(self): """Tests for class Investment""" self.assertEqual(investment(100, 10).positions, 100) self.assertEqual(investment(100, 10).num_trials, 10) self.assertEqual(investment(100, 10).position_value, 10)
def test_constructor(self): self.assertEqual(investment(10,10000).position, 10) self.assertEqual(investment(10,1000).num_trials, 1000) self.assertEqual(investment(10,10000).position_value, 100)
break inv_list = eval(input("Please input a list: ")) inv_trail = eval(input("How many times to try: ")) try: type(inv_list) is list except: raise ValueError("The input is not a list") try: type(inv_trail) is int except: raise ValueError("The input is not an integer") # call the investment function inv = investment(inv_list, inv_trail) # return the dict from the function inv = inv.result() txt = open('results.txt', 'w') for inv_pos in inv: fig = plt.figure() plt.hist((list(inv[inv_pos].values())), 100, range=[-1, 1]) mean = np.mean(list(inv[inv_pos].values())) std = np.sqrt(np.var(list(inv[inv_pos].values()))) title = "The histogram of the result for buying " + str( inv_pos) + " share(s) in parallel" plt.title(title) plt.savefig('histogram_%04d_pos.pdf' % int(inv_pos)) plt.show() txt.write("At the position of: " + str(inv_pos) + "\n")
def testInvestment6(self): #Test the daily_gain method. Because the outcome of this method is random, we cannot test it directly. So I just test its properties self.assertTrue(investment(10).daily_gain() <= 1 and investment(10).daily_gain() >= -1 ) self.assertTrue(investment(1000).daily_gain() <= 1 and investment(10).daily_gain() >= -1 )
def testInvestment5(self): #Test the daily_outcome method. Because the outcome of this method is random, we cannot test it directly. So I just test its properties self.assertTrue(investment(10).daily_outcome()[5] in [200,0]) self.assertTrue(investment(1).daily_outcome()[0] in [2000,0])
def test_investment(self): '''test the method of investment class''' self.assertEqual(100, len(investment(10, 100).daily_returns()))
def testInvestment3(self): #Test the position_value attribute self.assertEqual(investment(1000).position_value, 1) self.assertEqual(investment(10).position_value, 100)
def testInvestment2(self): #Test the position attribute self.assertEqual(investment(10).position, 10 ) self.assertEqual(investment(1000).position, 1000 )
def test_constructor(self): self.assertEqual(investment(10, 10000).position, 10) self.assertEqual(investment(10, 1000).num_trials, 1000) self.assertEqual(investment(10, 10000).position_value, 100)
def testinvestment(self): self.assertEqual(investment([1,10,100,1000],1000).positions, [1,10,100,1000]) self.assertEqual(investment([1,10,100,1000],1000).num_trials, 1000)
def testsimulate(self): self.assertTrue(len(investment.simulate(investment([1,10,100,1000],1000))[0]) == 1000) self.assertTrue(len(investment.simulate(investment([1,10,100,1000],1000))[1]) == 1000) self.assertTrue(len(investment.simulate(investment([1,10,100,1000],1000))[2]) == 1000) self.assertTrue(len(investment.simulate(investment([1,10,100,1000],1000))[3]) == 1000) self.assertTrue(all(investment.simulate(investment([1,10,100,1000],1000))[0]) <= 1) self.assertTrue(all(investment.simulate(investment([1,10,100,1000],1000))[1]) <= 1) self.assertTrue(all(investment.simulate(investment([1,10,100,1000],1000))[2]) <= 1) self.assertTrue(all(investment.simulate(investment([1,10,100,1000],1000))[3]) <= 1) self.assertTrue(all(investment.simulate(investment([1,10,100,1000],1000))[0]) >= -1) self.assertTrue(all(investment.simulate(investment([1,10,100,1000],1000))[1]) >= -1) self.assertTrue(all(investment.simulate(investment([1,10,100,1000],1000))[2]) >= -1) self.assertTrue(all(investment.simulate(investment([1,10,100,1000],1000))[3]) >= -1)
def testInvestment4(self): #Test the daily_outcome method. Because the outcome of this method is random, we cannot test it directly. So I just test its properties self.assertTrue(investment(10).daily_outcome().shape == (10, 1)) self.assertTrue(investment(100).daily_outcome().shape == (100, 1))
""" This is the main program that runs with positions set to [1, 10, 100, 1000] and num_trials set to 10000. It will save four histograms and a results.txt file. """ while True: positions = raw_input('Please enter a list of numbers of shares like [1,10,100,1000] or type "quit" to exit. ') #convert an input string [1,10,100,1000] into a list. positions = positions.split(',') positions[0] = positions[0][1:] positions[-1] = positions[-1][:-1] positions = [int(i) for i in positions] if positions == [1,10,100,1000]: num_trials = 10000 initial_amount = investment(1000) result_table = pd.DataFrame(columns = ["position", "mean", "std"]) n = 0 for position in positions: daily_ret = initial_amount.daily_investment(position, num_trials) result_table.loc[n] = [position, np.mean(daily_ret), np.std(daily_ret)] n = n + 1 picture = plt.figure() plt.hist(daily_ret, 100, range=[-1,1]) # plot histogram plt.title('Histogram of Daily Return for Position {}'.format(position)) plt.xlabel('Daily Return') picture.savefig('histogram_{}_pos.pdf'.format(str(position))) result_table.to_csv('results.txt', sep=',') print "Histograms have been saved as .pdf at current directory." print "Text file has been saved as \"results.txt\" at current directory."
break inv_list = eval(input("Please input a list: ")) inv_trail = eval(input("How many times to try: ")) try: type(inv_list) is list except: raise ValueError("The input is not a list") try: type(inv_trail) is int except: raise ValueError("The input is not an integer") # call the investment function inv = investment(inv_list, inv_trail) # return the dict from the function inv = inv.result() txt = open('results.txt', 'w') for inv_pos in inv: fig = plt.figure() plt.hist((list(inv[inv_pos].values())), 100, range=[-1, 1]) mean = np.mean(list(inv[inv_pos].values())) std = np.sqrt(np.var(list(inv[inv_pos].values()))) title = "The histogram of the result for buying " + str(inv_pos) + " share(s) in parallel" plt.title(title) plt.savefig('histogram_%04d_pos.pdf' % int(inv_pos)) plt.show() txt.write("At the position of: " + str(inv_pos) + "\n") txt.write("The mean of daily return: " + str(mean) + "\n")