def main(): print "=======================Problem 1=========================" Problem1.main() print "=======================Problem 2=========================" Problem2.main() print "=======================Problem 3=========================" Problem3.main() print "=======================Problem 4=========================" Problem4.main()
def test6(self): input = "https://www.netflix.com/watch/70152014?trackId=200257859" expected = [ "https", "www.netflix.com", "watch/70152014?trackId=200257859" ] actual = Problem1.URLSplit( "https://www.netflix.com/watch/70152014?trackId=200257859") self.assertEqual(expected, actual)
def test_smallest_factor(): assert p1.smallest_factor(1) == 1, "failed on 1" assert p1.smallest_factor(2) == 2, "failed on smallest prime number case" assert p1.smallest_factor(3) == 3, "failed on small prime number cases" assert p1.smallest_factor( 4) == 2, "failed on smallest composite number case" assert p1.smallest_factor(6) == 2, "failed on small composite number cases" assert p1.smallest_factor( 9) == 3, "failed when n is the square of prime number cases" assert p1.smallest_factor( 16) == 2, "failed when n is the square of composite number cases" assert p1.smallest_factor(17) == 17, "failed on large prime number cases" assert p1.smallest_factor( 18) == 2, "failed on large composite number cases"
def problem1(input1, input2): # Put problem1 code here alphabet = "0 1 2 3 4 5 6 7 8 9".split() d = Problem1.gen_dfa(input2, alphabet) print("True means the number is not strongly divisible:", d.run_with_input_list(input1)) d.print() return
def sample_posterior(self): """ sample the posterior distribution of the mortality probability """ # find values of mortality probability at which the posterior should be evaluated self._mortalitySamples = np.random.uniform(low=CalibSets.POST_L, high=CalibSets.POST_U, size=CalibSets.POST_N) # create a multi cohort multiCohort = SurvivalCls.MultiCohort( ids=self._cohortIDs, mortality_probs=self._mortalitySamples, pop_sizes=[CalibSets.SIM_POP_SIZE] * CalibSets.POST_N) # simulate the multi cohort multiCohort.simulate(CalibSets.TIME_STEPS) # calculate the likelihood of each simulated cohort for cohort_id in self._cohortIDs: # get the average survival time for this cohort mean = multiCohort.get_cohort_mean_survival(cohort_id) #survivaltimes = multiCohort.get_survival_times(cohort_id) fiveyearlist = multiCohort.get_five_year_survival(cohort_id) fiveyearrate = sum(fiveyearlist) / CalibSets.OBS_N # construct a gaussian likelihood # with mean calculated from the simulated data and standard deviation from the clinical study. # evaluate this pdf (probability density function) at the mean reported in the clinical study. weight = stat.binom.pmf(k=CalibSets.OBS_FIVE_YEAR_RATE, n=CalibSets.OBS_N, p=fiveyearrate) # store the weight self._weights.append(weight) # normalize the likelihood weights sum_weights = np.sum(self._weights) self._normalizedWeights = np.divide(self._weights, sum_weights) # re-sample mortality probability (with replacement) according to likelihood weights self._mortalityResamples = np.random.choice( a=self._mortalitySamples, size=CalibSets.NUM_SIM_COHORTS, replace=True, p=self._normalizedWeights) # produce the list to report the results for i in range(0, len(self._mortalitySamples)): self._csvRows.append([ self._cohortIDs[i], self._normalizedWeights[i], self._mortalitySamples[i] ]) # write the calibration result into a csv file InOutSupport.write_csv('CalibrationResults.csv', self._csvRows)
def test5(self): input = "https://cs-people.bu.edu/dharmesh/teaching/cs591_sp20/assignments/assignment6/" expected = [ "https", "cs-people.bu.edu", "dharmesh/teaching/cs591_sp20/assignments/assignment6/" ] actual = Problem1.URLSplit( "https://cs-people.bu.edu/dharmesh/teaching/cs591_sp20/assignments/assignment6/" ) self.assertEqual(expected, actual)
def apply_monte_carlo_simulation( costOfLiving , numTimes ): utilMap = UtilityMap() transitionModel = TransitionModel() rewardSet = RewardSet( costOfLiving ) utilMap = Problem1.apply_value_iteration( utilMap , transitionModel , rewardSet ) policy = utilMap.get_optimal_policy( transitionModel ) rewards = [] for _ in range( numTimes ): rewards.append( simulate_run( 2 , 3 , policy , rewardSet ) ) return rewards
def simulate(self, num_of_simulated_cohorts, cohort_size, time_steps, cohort_ids=None): """ simulate the specified number of cohorts based on their associated likelihood weight :param num_of_simulated_cohorts: number of cohorts to simulate :param cohort_size: the population size of cohorts :param time_steps: simulation length :param cohort_ids: ids of cohort to simulate """ # resample cohort IDs and mortality probabilities based on their likelihood weights # sample (with replacement) from indices [0, 1, 2, ..., number of weights] based on the likelihood weights sampled_row_indices = np.random.choice(a=range(0, len(self._weights)), size=num_of_simulated_cohorts, replace=True, p=self._weights) # use the sampled indices to populate the list of cohort IDs and mortality probabilities resampled_ids = [] resampled_probs = [] for i in sampled_row_indices: resampled_ids.append(self._cohortIDs[i]) resampled_probs.append(self._mortalityProbs[i]) # simulate the desired number of cohorts if cohort_ids is None: # if cohort ids are not provided, use the ids stored in the calibration results self._multiCohorts = SurvivalCls.MultiCohort( ids=resampled_ids, pop_sizes=[cohort_size] * num_of_simulated_cohorts, mortality_probs=resampled_probs) else: # if cohort ids are provided, use them instead of the ids stored in the calibration results self._multiCohorts = SurvivalCls.MultiCohort( ids=cohort_ids, pop_sizes=[cohort_size] * num_of_simulated_cohorts, mortality_probs=resampled_probs) # simulate all cohorts self._multiCohorts.simulate(time_steps)
def apply_monte_carlo_simulation(costOfLiving, numTimes): utilMap = UtilityMap() transitionModel = TransitionModel() rewardSet = RewardSet(costOfLiving) utilMap = Problem1.apply_value_iteration(utilMap, transitionModel, rewardSet) policy = utilMap.get_optimal_policy(transitionModel) rewards = [] for _ in range(numTimes): rewards.append(simulate_run(2, 3, policy, rewardSet)) return rewards
def problem1(): import Problem1 print "Solving Problem 1" answers = Problem1.solve() f = open("generated/P1-output.txt", "w") f.write("0.0000\n\n") prevPolicyStr = str(Problem1.get_optimal_policy(0)) f.write(prevPolicyStr + "\n") for i in range(0, 8): f.write(str('{0:.4f}'.format(answers[i])) + "\n\n") nextPolicyStr = str(Problem1.get_optimal_policy(answers[i] - 0.0001)) output = "" for i in range(len(nextPolicyStr)): if (nextPolicyStr[i] == prevPolicyStr[i]): output += nextPolicyStr[i] else: output += nextPolicyStr[i] + "*" f.write(output + "\n") prevPolicyStr = nextPolicyStr f.close() print "Finished Solving Problem 1"
def problem1(): import Problem1 print "Solving Problem 1" answers = Problem1.solve() f = open( "generated/P1-output.txt" , "w" ) f.write( "0.0000\n\n" ) prevPolicyStr = str(Problem1.get_optimal_policy( 0 )) f.write( prevPolicyStr + "\n" ) for i in range(0,8): f.write( str('{0:.4f}'.format(answers[ i ])) + "\n\n" ) nextPolicyStr = str(Problem1.get_optimal_policy( answers[ i ] - 0.0001 )) output = "" for i in range(len(nextPolicyStr)): if ( nextPolicyStr[ i ] == prevPolicyStr[ i ] ): output += nextPolicyStr[ i ] else: output += nextPolicyStr[ i ] + "*" f.write( output + "\n" ) prevPolicyStr = nextPolicyStr f.close() print "Finished Solving Problem 1"
def solve(): utilMap = UtilityMap() transitionModel = TransitionModel() rewardSet = RewardSet( -0.04 ) utilMap = Problem1.apply_value_iteration( utilMap , transitionModel , rewardSet ) rewards10 = apply_monte_carlo_simulation( -0.04 , 10 ) print "10 run mean:", sum( rewards10 ) / 10.0 print "10 run stddev:" , numpy.std( numpy.array( rewards10 ) ) rewards100 = apply_monte_carlo_simulation( -0.04 , 100 ) print "100 run mean:" , sum( rewards100 ) / 100.0 print "100 run stddev:" , numpy.std( numpy.array( rewards100 ) ) rewards1000 = apply_monte_carlo_simulation( -0.04 , 1000 ) print "1000 run mean:" , sum( rewards1000 ) / 1000.0 print "1000 run stddev:" , numpy.std( numpy.array( rewards1000 ) ) return (utilMap , rewards10 , rewards100 , rewards1000)
def solve(): utilMap = UtilityMap() transitionModel = TransitionModel() rewardSet = RewardSet(-0.04) utilMap = Problem1.apply_value_iteration(utilMap, transitionModel, rewardSet) rewards10 = apply_monte_carlo_simulation(-0.04, 10) print "10 run mean:", sum(rewards10) / 10.0 print "10 run stddev:", numpy.std(numpy.array(rewards10)) rewards100 = apply_monte_carlo_simulation(-0.04, 100) print "100 run mean:", sum(rewards100) / 100.0 print "100 run stddev:", numpy.std(numpy.array(rewards100)) rewards1000 = apply_monte_carlo_simulation(-0.04, 1000) print "1000 run mean:", sum(rewards1000) / 1000.0 print "1000 run stddev:", numpy.std(numpy.array(rewards1000)) return (utilMap, rewards10, rewards100, rewards1000)
zeros(upper_bound+1 - lower_bound)] for N in N_values: # Loop as required by problem max_error = [0, 0, 0] # Used store the maximum error of each interpolation max_x = [0, 0, 0] # Used to store the abscicas at which the maximum error occurs # Generating the ordinates and absciccas interval = [-5, 5] spacing = 10 / N points = [interval[0] + spacing / 2 + spacing * m for m in range(N)] # creates the absiccas values = [f(x) for x in points] # creates the ordinates # Newton approximation: newton_poly = pb1.newton_interpolation(values, points) # This gives us our newton_polynomial # Newton with Chebyshev zeros: cheb_zeros = pb2.chebyshev(-5, 5, N) # Retrieves the Chebyshev zeros cheb_values = [f(x) for x in cheb_zeros] # Retrieves the ordinates for the Chebyshev zeros cheb_newton_poly = pb1.newton_interpolation(cheb_values, cheb_zeros) # Generates polynomial spline_coeff = pb3.SplineCoefficients(points, values) # Returns our spline interpolation coefficients x = linspace(interval[0], interval[1], 1001) for i in range(1001): # We loop through the 1001 points x_coord = x[i] # We evaluate all of the approximations at the iteration absica and store it in an array
def test3(self): input = "https://www.facebook.com/messages/t/2972109159468035" expected = ["https", "www.facebook.com", "messages/t/2972109159468035"] actual = Problem1.URLSplit( "https://www.facebook.com/messages/t/2972109159468035") self.assertEqual(expected, actual)
def test4(self): input = "https://github.com/sumara523/cs591_c2_assignment_6" expected = ["https", "github.com", "sumara523/cs591_c2_assignment_6"] actual = Problem1.URLSplit( "https://github.com/sumara523/cs591_c2_assignment_6") self.assertEqual(expected, actual)
import Parameters as P import Problem1 as Cls import SupportSteadyState as Support # create a cohort of patients for when the drug is not available cohortFairCoin = Cls.Cohort(id=1, pop_size=P.SIM_POP_SIZE, mortality_prob=P.MORTALITY_PROB) # simulate the cohort FairCoinOutcome = cohortFairCoin.simulate(P.TIME_STEPS) # create a cohort of patients for when the drug is available cohortUnfairCoin = Cls.Cohort(id=2, pop_size=P.SIM_POP_SIZE, mortality_prob=P.MORTALITY_PROB * P.DRUG_EFFECT_RATIO) # simulate the cohort UnfairCoinOutcome = cohortUnfairCoin.simulate(P.TIME_STEPS) # print outcomes of each cohort Support.print_outcomes(FairCoinOutcome, 'When coin is fair:') Support.print_outcomes(UnfairCoinOutcome, 'When coin is unfair:') # draw survival curves and histograms Support.draw_survival_curves_and_histograms(FairCoinOutcome, UnfairCoinOutcome) # print comparative outcomes Support.print_comparative_outcomes(FairCoinOutcome, UnfairCoinOutcome)
import Problem1 as pb unfair = pb.Cohort(2,1000,20,0.4) print('Average reward for unfair coin is', unfair.get_average())
import unittest from Problem1 import * problem1 = Problem1() class TestProblem1(unittest.TestCase): def test_returnType(self): self.assertTrue(type(problem1.urlSplit("a://b/c")) is list, "test_returnType should return a list") def test_inputWithAllComponents(self): self.assertEqual(problem1.urlSplit("https://www.google.com/some-path"), ["https", "www.google.com", "some-path"], "test_returnType should return all its components: http, www.google.com, some-path") def test_inputWithPathMissing(self): self.assertEqual(problem1.urlSplit("ftp://bu.edu/"), ["ftp", "bu.edu", ""], "test_returnType should return all its components: ftp, bu.edu, "" ") if __name__ == "__main__": unittest.main()
def test1(self): input = "https://www.google.com/some-path" expected = ["https", "www.google.com", "some-path"] actual = Problem1.URLSplit("https://www.google.com/some-path") self.assertEqual(expected, actual)
def containsError(sensorNetwork): '''Function check a dataset, log sensor errors and return a filtered dataset. Function accepts a dataset as a parameter. The dataset is examined for sensor errors. Identified errors are modified to -1, a non-valid float value. The Cluster and Sensor ID are logged to repair. The filtered dataset is returned.''' # Loop through entire dataset, sensor by sensor for i in range(0, 32): for j in range(0, 16): # If the sensor reports an error if sensorNetwork[i][j] == 'err': # Filter the error to -1 (non-valid float) sensorNetwork[i][j] = -1 # Log the failed sensor information to the log file for repair. logger.info("SENSOR ERROR: Cluster: " + str(i + 1) + ", Sensor: " + str(j + 1)) # Return the filtered dataset return sensorNetwork # Main - no specific main, not required in assessment. This block is demonstrating the functions sensorData = dataGenerate.dataStreamGenerate() corruptSensorData = corruptDataSet(sensorData) dataStore.storeDataset(corruptSensorData) filteredSensorData = containsError(corruptSensorData)
import Problem1 as Cls import scr.FigureSupport as figureLibrary # expected rewards from 1000 games setOfGames = Cls.SetOfGames(id=1, prob_head=0.45, n_games=1000) outcomes = setOfGames.simulation() ##### Problem 1 ##### print("Estimated expected reward:", outcomes.get_ave_reward()) print("The 95% CI of expected reward:", outcomes.get_CI_reward(0.05)) print("Probability of loss in a single game:", outcomes.get_prob_loss()) print("The 95% CI of loss probability:", outcomes.get_CI_probLoss(0.05)) ##### Problem 2 ##### print( "If we run our simulation many times, " "on average 95% of the confidence intervals generated will capture the true mean." ) # plot figureLibrary.graph_histogram(data=outcomes.get_rewards(), title="Histogram of rewards", x_label='Rewards', y_label='Count')
def test2(self): input = "ftp://bu.edu/" expected = ["ftp", "bu.edu", ""] actual = Problem1.URLSplit("ftp://bu.edu/") self.assertEqual(expected, actual)
if __name__ == "__main__": N = 9 # number of points interval = [-5, 5] cheb_zeros = chebyshev(interval[0], interval[1], N) # retrieve the chebyshev zeros values = [f(x) for x in cheb_zeros] # calculate the function for the zeros print("The interpolation points are as follows:") print(cheb_zeros) print("Respectively, the function value at these points are:") print(values) P = pb1.newton_interpolation(values, cheb_zeros) X = cheb_zeros print("This gives the following interpolation polynomial:") pb1.print_polynomial(P, X) max_diff = 0 max_x = 0 poly_values = zeros(1001) x = linspace(interval[0], interval[1], 1001) for i in range(1001): x_coord = x[i] y_coord = pb1.get_value_of_polynomial(P, X, x_coord) fx = f(x_coord) if abs(fx - y_coord) > max_diff:
# -*- coding: utf-8 -*- __author__ = 'Vietworm' import Problem1 import Problem2 """Problem 1: If we list all the natural numbers below 10 that are multiples of 3 or 5, we get 3, 5, 6 and 9. The sum of these multiples is 23. Find the sum of all the multiples of 3 or 5 below 1000. """ if Problem1.sumMultiples() == 233168: print "Problem 1 solved!" """Problem 2: Each new term in the Fibonacci sequence is generated by adding the previous two terms. By starting with 1 and 2, the first 10 terms will be: 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, ... By considering the terms in the Fibonacci sequence whose values do not exceed four million, find the sum of the even-valued terms. """ if Problem2.sumFibonacci(4000000) == 4613732: print "Problem 2 solved!"