def main():
parser = argparse.ArgumentParser()
parser.add_argument('-p', '--peng', type=int,
help='initial penguin population size')
parser.add_argument('-b', '--bear', type=int,
help='initial bear population size')
parser.add_argument('-d', '--dim', type=int,
help='dimension of square world')
parser.add_argument('-g', '--gen', type=int,
help='number of generations')
parser.add_argument('-o', '--out', type=str,
help='frame output file')
args = parser.parse_args()
#Default simulation parameters
num_peng = 50
num_bear = 10
dim = 10
gen = 100
outfile = "lattice.frames"
if(args.peng):
num_peng = args.peng
if(args.bear):
num_bear = args.bear
if(args.dim):
dim = args.dim
if(args.gen):
gen = args.gen
if(args.out):
outfile = args.out
sim.run_simulation(num_peng, num_bear, dim, gen, outfile)
vis.run_visualizer(outfile)
def main():
welcome()
coins = fetch_coins()
currency, quantity = input_buy()
try:
price = coins[currency]['price']
except Exception as e:
dramatic_typing("Invalid currency entered, please try again \n")
input_buy()
run_simulation(coins[currency]['price'], quantity, currency)
quitMenu()
def agregate_methods_case1(lamb_array):
mu_case1 = 1
results = []
for lamb in lamb_array:
results.append(
s.run_simulation(lamb / 2, lamb / 2, mu_case1, mu_case1, 'exp'))
print(f'Simulação {lamb}')
print(results)
return results
def simulate_earn_rate(self, df_historical_price, strategy):
history = run_simulation(crypto_amount=self.init_crypto_amount,
assets_jpy=self.initial_currency,
strategy=strategy,
df_historical_price=df_historical_price)
final_state = history[-1]
final_total_asset = final_state["total"]
earn_rate = calc_earn_rate(final_total_asset, self.initial_currency)
return earn_rate
def run():
logger.info("/run")
try:
for res in run_simulation(step_by_step=False):
logger.info(res)
json_dump = json.dumps({"result": "success", "message": "OK"})
return Response(response=json_dump, status=200)
except Exception as e:
json_dump = json.dumps({"result": "error", "message": str(e)})
return Response(response=json_dump, status=200)
def run_ga(df_historical_price, coef):
initial_jpy_asset = 200000
crypto_amount = 0
history = run_simulation(crypto_amount=crypto_amount, assets_jpy=initial_jpy_asset, coef=coef,
df_historical_price=df_historical_price)
final_state = history[-1]
final_total_asset = final_state["total"]
earn_rate = (final_total_asset - initial_jpy_asset) / initial_jpy_asset * 100
return earn_rate
def home():
form = InputForm()
if form.validate_on_submit():
prediction = simulator.run_simulation([
form.num_col.data, form.num_brit.data, form.general.data,
form.offensive.data, form.allies.data
])
print(prediction)
flash(f'It looks like the {prediction} win this one!', 'info')
# return redirect(url_for('home'))
return render_template('index.html', form=form)
def run_test(user_polarization, film_polarization, model, always_watch,
rewatch_rec_mult, rewatch_view_mult, anti_bubble_sys,
recommender_randomness, user_discovery_factor):
"""
Runs a test with the provided simulator parameters.
"""
test_name = "test-up%1.1f-fp%1.1f-%s-%s-%s-rrm%1.1f-rvm%1.1f-rr%1.1f-udf%1.1f" % (
user_polarization, film_polarization, model, anti_bubble_sys,
str(always_watch).lower(), rewatch_rec_mult, rewatch_view_mult,
recommender_randomness, user_discovery_factor)
print("Running %s..." % test_name, file=master_log)
print("Running (%d of %d) %s... " % (test_idx, NUM_TESTS, test_name),
end="")
master_log.flush()
sys.stdout.flush()
reload(simulator)
simulator.TEST_NAME = test_name
simulator.MAX_STEPS = 100
simulator.USER_POLARIZATION_STRENGTH = user_polarization
simulator.FILM_POLARIZATION_STRENGTH = film_polarization
simulator.RECOMMENDER_MODEL = model
simulator.ALWAYS_WATCH = always_watch
simulator.REWATCH_RECOMMENDATION_MULTIPLIER = rewatch_rec_mult
simulator.REWARCH_VIEW_MULTIPLIER = rewatch_view_mult
simulator.ANTI_BUBBLE_SYSTEM = anti_bubble_sys
simulator.RECOMMENDER_RANDOMNESS = recommender_randomness
simulator.USER_DISCOVERY_FACTOR = user_discovery_factor
simulator.K_VAL = 200
try:
simulator.run_simulation()
print("Succeeded")
except simulator.TestAlreadyCompletedException as e:
print("Previously Completed", file=master_log)
print("Previously Completed")
except Exception as e:
print("FAILED: %s" % str(e), file=master_log)
print("FAILED!\n%s" % str(e))
def main():
robot_params = {"ROBOT_SIZE": ROOMBA_SIZE, "HEAD_SIZE": 1.9, "SPEED": 3}
room_params = {"ROOM_POLYGON": ROOM_POLYGON, "OBSTECLES": OBSTECLES}
stop_conditions = {
"MIN_COVERAGE_TO_EXIT": MIN_COVERAGE_TO_EXIT,
"MAX_NO_GAIN_STEPS": MAX_NO_GAIN_STEPS,
"MAX_TIME": 9000
}
stats = run_simulation(robot_params,
room_params,
stop_conditions,
visual_feedback=True)
matplotlib.pyplot.plot(stats)
matplotlib.pyplot.show()
def generator():
for res in run_simulation(step_by_step=True):
yield json.dumps(res) + "\n"
import random
import matplotlib.pyplot as plt
import numpy as np
import custom_math as cm
from simulator import run_simulation
import parameters as p
market_prices = []
complete_infos = []
tracker = []
for i in range(p.N_AGENTS * 2 + 1):
print(i, "/", p.N_AGENTS * 2 + 1)
signal_diff = p.N_AGENTS - i
true_state = "A" if random.uniform(0, 1) > 0.5 else "B"
result = run_simulation(true_state, signal_diff, verbose=False)
market_prices.append(result[1])
complete_infos.append(result[2])
tracker.append(result[2] * (1 - p.ERROR_AVERAGE) + (1 - result[2]) *
(p.ERROR_AVERAGE))
#what percentage of the total bits are retained by each aggregation method in our simulations?
#price_retention = []
#average_retention = []
#for i in range(len(complete_infos)):
# if abs(complete_infos[i]) > 0.1:
# price_retention.append(market_prices[i] / complete_infos[i])
# average_retention.append(average_beliefs[i] / complete_infos[i])
#
#print("Averaging: ", np.mean(average_retention), "(", np.std(average_retention), ")")
#print("Mkt_price: ", np.mean(price_retention), "(", np.std(price_retention), ")")
from reconfig import dynamic_reconfigurator
from cost import cost_calculator
import simulator
import simpy
import cPickle
sim_context = context.SimulationContext(simpy.Environment(), 86400, "../data/vm_configuration.csv")
simulator = simulator.Simulator(sim_context)
workload_file = open("../data/sess.dat",'r')
workload = cPickle.load(workload_file)
workload_file.close()
workload = workload[0,86400*52:86400*53]
workload_generator = workload_generator.WorkloadGenerator(workload, sim_context)
simulator.add_workload_generator(workload_generator)
stat_collector = statistics_collector.StatisticsCollector(sim_context)
simulator.add_statistics_collector(stat_collector)
perf_calculator = perf_calculator.PerformanceCalculator(sim_context)
simulator.add_performance_calculator(perf_calculator)
vm_reconfigurator = dynamic_reconfigurator.DynamicReconfigurator(sim_context)
simulator.add_vm_reconfigurator(vm_reconfigurator)
cost_calculator = cost_calculator.CostCalculator(sim_context)
simulator.add_cost_calculator(cost_calculator)
simulator.run_simulation()
import matplotlib.pyplot as plt
from simulator import run_simulation
p, b = run_simulation(n_agents=100,
n_time_steps=100,
time_per_evidence=100,
n_evidence=1,
starting_cash=1000,
update_when_receiving=False)
plt.figure(figsize=(12, 4))
plt.plot(p)
plt.plot(b)
plt.legend(['Price', 'Total evidence as belief'])
plt.xlabel("Time (market cycles)")
plt.grid()
plt.show()
import random import matplotlib.pyplot as plt import numpy as np import custom_math as cm from simulator import run_simulation import parameters as p true_state = "A" #if random.uniform(0,1) > 0.5 else "B" result = run_simulation(true_state, signal_diff=1) print(result[1], result[2])
import simulator tax_rate = .3 simulation_length_in_months = 48 simulator.run_simulation(simulation_length_in_months, tax_rate)
if constants.PROCESS_DIVIDEND_ANNOUNCEMENTS:
dividend_data = dividend_declaration_data_loader.get_data()
x_table, y_table = dividend_declaration_data_loader.process_dividend_announcements(historical_prices,
dividend_data,
constants.STORE_DATA)
if constants.PROCESS_EARNING_ANNOUNCEMENTS:
earning_announcement_data = earning_announcement_data_loader.get_data()
# x_table, y_table = earning_announcement_data_loader.process_earning_announcements(historical_prices,
# earning_announcement_data,
# company_sentiment,
# trends,
# constants.STORE_DATA)
if constants.RUN_SIMULATION:
simulator.run_simulation(historical_prices, earning_announcement_data, company_sentiment, trends)
if constants.RUN_MACHINE_LEARNING:
if constants.USE_CACHED_MACHINE_LEARNING_DATA:
encoded_x, x_table, y_table, trades = machine_learning.get_cached_data()
else:
encoded_x, x_table, y_table, trades = machine_learning.get_data(historical_prices,
earning_announcement_data,
company_sentiment,
trends,
constants.STORE_DATA)
final = list()
for i in range(2014, 2019):
res = machine_learning.run_machine_learning(encoded_x, x_table, y_table, trades, i)
final.append(res)
print(final)
# Announce the start of the simulation
test_name = "test-up%1.1f-fp%1.1f-%s-%s-%s-rrm%1.1f-rvm%1.1f-rr%1.1f-udf%1.1f" % (
user_polarization, film_polarization, model, anti_bubble_sys,
str(always_watch).lower(), rewatch_rec_mult, rewatch_view_mult,
recommender_randomness, user_discovery_factor)
print("Running %s... " % test_name, end="")
sys.stdout.flush()
# Actually set the simulator module's parameters
simulator.TEST_NAME = test_name
simulator.MAX_STEPS = 100
simulator.USER_POLARIZATION_STRENGTH = user_polarization
simulator.FILM_POLARIZATION_STRENGTH = film_polarization
simulator.RECOMMENDER_MODEL = model
simulator.ALWAYS_WATCH = always_watch
simulator.REWATCH_RECOMMENDATION_MULTIPLIER = rewatch_rec_mult
simulator.REWARCH_VIEW_MULTIPLIER = rewatch_view_mult
simulator.ANTI_BUBBLE_SYSTEM = anti_bubble_sys
simulator.RECOMMENDER_RANDOMNESS = recommender_randomness
simulator.USER_DISCOVERY_FACTOR = user_discovery_factor
# Run the simulation and print the result
try:
simulator.run_simulation()
print("Succeeded")
except simulator.TestAlreadyCompletedException as e:
print("Previously Completed")
except Exception as e:
print("FAILED!\n%s" % str(e))