def test_something(self): proxy = SolverProxy() proxy.read_or_calc_and_write() tau = 0.35 delta = 0.85 a = 0.001 s = 0 cr = 0.2125 cn = 0.5 par_nb = Parameter(MODEL_NB, tau=tau, a=a, s=s, cn=cn) sol_nb = ModelNBSolver.solve(par_nb, 'very high') print('wn = {}, b={}, rho={}, pn={}'.format(sol_nb.dec.wn, sol_nb.dec.b, sol_nb.dec.rho, sol_nb.dec.pn)) print(sol_nb.profit_man) print(sol_nb.profit_ret) par_o = Parameter(MODEL_2, tau=tau, a=a, s=s, cr=cr, cn=cn, delta=delta) sol_o = proxy.calculate(par_o) print(sol_o.profit_man)
def __calc__(self): p = Factorial iter = self.__state_iter proxy = SolverProxy() num = 0 for tau, tau_state in iter(p.tau_lh()): for delta, delta_state in iter(p.delta_lh()): for cn, cn_state in iter(p.cn_lh()): for cr, cr_state in iter(p.cr_lh(cn, delta)): for s, s_state in iter(p.s_lh(cn)): for a, a_state in iter(p.a_lh()): # calculate model with restocking_fee par_nb = Parameter(MODEL_NB, tau=tau, a=a, s=s, cn=cn) sol_nb = proxy.read_or_calc_and_write(par_nb, resolution='middle') num += 1; print(num) #sol_nb = ModelNBSolver.solve(par_nb, 'low') key_n = self.__key(MODEL_NB, tau_state, a_state, s_state, cr_state, cn_state, delta_state) self._add(key_n, par_nb, sol_nb) # calculate model two par_o = Parameter(MODEL_2, tau=tau, a=a, s=s, cr=cr, cn=cn, delta=delta) sol_o = proxy.calculate(par_o) key_o = self.__key(MODEL_2, tau_state, a_state, s_state, cr_state, cn_state, delta_state) self._add(key_o, par_o, sol_o) proxy.commit()
def plottiplotti(): proxy = SolverProxy() a = [float(a) for a in np.linspace(0.0, 0.01, num=48 + 2)] x = np.zeros((len(a), 1)) y = np.zeros((len(a), 1)) dist = 0 for i, act_a in enumerate(a): if act_a == 0: x[0] = None y[0] = None continue par = Parameter(MODEL_2, tau=0.09, a=act_a, s=0.04000000000000001, cn=0.1, cr=0.04000000000000001, delta=0.7956) solP = ModelTwoSolver.solve(par) solA = proxy.calculate(par) x[i] = solP.dec.wn y[i] = solA.dec.wn dist += abs(solP.dec.wn - solA.dec.wn) from matplotlib import pyplot as plt plt.plot(a, x, label='search') plt.plot(a, y, label='analy') plt.legend() plt.show() print(dist)
def __calc__(self): p = Factorial iter = self.__state_iter proxy = SolverProxy() num = 0 for tau, tau_state in iter([p.tau_lo(), p.tau_hi()]): for cn, cn_state in iter([p.cn_lo(), p.cn_hi()]): for s, s_state in iter([p.s_lo(), p.s_hi(cn)]): for a, a_state in iter([p.a_lo(), p.a_hi()]): # calculate model with restocking_fee par_nb = Parameter(MODEL_NB, tau=tau, a=a, s=s, cn=cn) sol_nb = proxy.read_or_calc_and_write( par_nb, resolution='high') num += 1 print(num) #sol_nb = ModelNBSolver.solve(par_nb, 'low') key_nb = self.__key(MODEL_NB, tau_state, a_state, s_state, Factorial.HIGH, cn_state, Factorial.HIGH) self._add(key_nb, par_nb, sol_nb) # calculate model without online store par_no = Parameter(MODEL_1, tau=tau, a=a, s=s, cn=cn) sol_no = proxy.calculate(par_no) key_no = self.__key(MODEL_1, tau_state, a_state, s_state, Factorial.HIGH, cn_state, Factorial.HIGH) self._add(key_no, par_no, sol_no) proxy.commit()
def test_db_and_plot(): from matplotlib import pyplot as plt from solver import SolverProxy proxy = SolverProxy() a = [float(a) for a in np.linspace(0.0, 0.01, num=48 + 2)] x = np.zeros((len(a), 1)) y = np.zeros((len(a), 1)) for i, act_a in enumerate(a): if act_a == 0: x[0] = None y[0] = None continue par = Parameter(MODEL_2_QUAD, tau=0.09, a=act_a, s=0.04000000000000001, cn=0.1, cr=0.04000000000000001, delta=0.7956) #solP = ModelTwoQuadSolver.solve(par) solP = proxy.calculate(par, resolution='very-high') x[i] = solP.dec.wn y[i] = solP.profit_ret # plot actual a on x[i] #plt.text(act_a, x[i], str(act_a)) proxy.commit() plt.plot(a, x, label='x', marker='o') plt.plot(a, y, label='y') plt.legend() #plt.savefig('figure_quad.pdf') plt.show()
def __calc__(self): p = Factorial iter = self.__state_iter proxy = SolverProxy() for tau, tau_state in iter(p.tau_lh()): for delta, delta_state in iter(p.delta_lh()): for cn, cn_state in iter(p.cn_lh()): for cr, cr_state in iter(p.cr_lh(cn, delta)): for s, s_state in iter(p.s_lh(cn)): for a, a_state in iter(p.a_lh()): # calculate model one par_n = Parameter(MODEL_1, tau=tau, a=a, s=s, cn=cn) sol_n = proxy.calculate(par_n) key_n = self.__key(MODEL_1, tau_state, a_state, s_state, cr_state, cn_state, delta_state) self._add(key_n, par_n, sol_n) # calculate model two par_o = Parameter(MODEL_2, tau=tau, a=a, s=s, cr=cr, cn=cn, delta=delta) sol_o = proxy.calculate(par_o) key_o = self.__key(MODEL_2, tau_state, a_state, s_state, cr_state, cn_state, delta_state) self._add(key_o, par_o, sol_o)
pass act_it += 1 assert func(x, args) != sys.maxsize return HillClimber.resObj(x, 0) #return {'x': currentP, 'fun': best_score} if __name__ == '__main__': from model2 import ModelTwoSolver from solver import SolverProxy, Parameter, MODEL_2 proxy = SolverProxy() minimize_func = ModelTwoSolver._minimize_func par = Parameter(MODEL_2, tau=0.09, a=0.00040816326530612246, s=0.04000000000000001, cn=0.1, cr=0.04000000000000001, delta=0.7956) analySol = proxy.calculate(par) hcSol = ModelTwoSolver.solve(par) print('anal sol', analySol, analySol.profit_man, analySol.case) print('found sol', hcSol, hcSol.profit_man, hcSol.case) #res = minimize(func, args=args, x0=[1], method='Nelder-Mead') #myres = HillClimber.minimimize(func, args=None, x0=[5,5]) #print(myres)
class Factorial: tau_lh = lambda : (.15, .5) s_lh = lambda cn: (0, cn/2) cr_lh = lambda cn, delta : (.1*cn, .4*cn) delta_lh = lambda : (.5, .85) cn_lh = lambda : (.1, .5) a_lh = lambda : (.001, .01) LOW, HIGH = 'LOW', 'HIGH' def __init__(self): self.__dict = {} self.__proxy = SolverProxy() self.__calc__() self.__fullFactorialTable() def __key(self, model, tau, a, s, cr, cn, delta): assert model in (MODEL_1, MODEL_2) for val in (tau, a, s, cr, cn): assert val in (Factorial.LOW, Factorial.HIGH) return '{},tau={},a={},s={},cr={},cn={},delta={}'.format(model, tau, a, s, cr, cn,delta) def _add(self, key, par, sol): assert key not in self.__dict self.__dict[key] = {'par' : par, 'sol': sol} def _get(self, key): return self.__dict[key] def __calc__(self): p = Factorial iter = self.__state_iter proxy = SolverProxy() for tau, tau_state in iter(p.tau_lh()): for delta, delta_state in iter(p.delta_lh()): for cn, cn_state in iter(p.cn_lh()): for cr, cr_state in iter(p.cr_lh(cn, delta)): for s, s_state in iter(p.s_lh(cn)): for a, a_state in iter(p.a_lh()): # calculate model one par_n = Parameter(MODEL_1, tau=tau, a=a, s=s, cn=cn) sol_n = proxy.calculate(par_n) key_n = self.__key(MODEL_1, tau_state, a_state, s_state, cr_state, cn_state, delta_state) self._add(key_n, par_n, sol_n) # calculate model two par_o = Parameter(MODEL_2, tau=tau, a=a, s=s, cr=cr, cn=cn, delta=delta) sol_o = proxy.calculate(par_o) key_o = self.__key(MODEL_2, tau_state, a_state, s_state, cr_state, cn_state, delta_state) self._add(key_o, par_o, sol_o) def __fullFactorialTable(self): self.__ff_table = [[None for j in range(8)] for i in range(8)] lohi = (Factorial.LOW, Factorial.HIGH) for i, (s, cr, a) in enumerate([(s, cr, a) for s in lohi for cr in lohi for a in lohi]): for j, (cn, delta, tau) in enumerate([(cn, delta, tau) for cn in lohi for delta in lohi for tau in lohi]): key_n = self.__key(MODEL_1, tau, a, s, cr, cn, delta) key_o = self.__key(MODEL_2, tau, a, s, cr, cn, delta) val_n = self._get(key_n) val_o = self._get(key_o) self.__ff_table[i][j] = {'o' : val_o, 'n' : val_n} def __anal_line_parameters(self, table, par): f = Factorial pars = [] if table == 'delta': delta = par for tau, cn in [(tau,cn) for tau in f.tau_lh() for cn in f.cn_lh()]: for a, s, cr in [(a,s,cr) for a in f.a_lh() for s in f.s_lh(cn) for cr in f.cr_lh(cn,delta)]: pars.append([tau, a, s, cr, cn, delta]) if table == 'tau': tau = par for delta, cn in [(delta,cn) for delta in f.delta_lh() for cn in f.cn_lh()]: for a, s, cr in [(a,s,cr) for a in f.a_lh() for s in f.s_lh(cn) for cr in f.cr_lh(cn,delta)]: pars.append([tau, a, s, cr, cn, delta]) if table == 'cn': cn = par for tau, delta in [(tau, delta) for tau in f.tau_lh() for delta in f.delta_lh()]: for a, s, cr in [(a,s,cr) for a in f.a_lh() for s in f.s_lh(cn) for cr in f.cr_lh(cn,delta)]: pars.append([tau, a, s, cr, cn, delta]) if table == 'a': a = par for tau, delta, cn in [(tau,delta,cn) for tau in f.tau_lh() for delta in f.delta_lh() for cn in f.cn_lh()]: for s, cr in [(s,cr) for s in f.s_lh(cn) for cr in f.cr_lh(cn,delta)]: pars.append([tau, a, s, cr, cn, delta]) assert len(pars) == int(2**5) return pars def getAnalysisLineAbsoluteMN(self, table, par): pars = self.__anal_line_parameters(table, par) profits, rhos, pns, wns, prs = [], [], [], [], [] sol_ids = [] # calc all vals for i, par in enumerate(pars): tau, a, s, cr, cn, delta = par sol_n, sol_o = self.__both_solutions(tau, a, s, cr, cn, delta) if sol_o.case in ('1a', '1b', '1c'): sol_ids.append(i) profits.append( sol_o.profit_man ) rhos.append( sol_o.dec.rho ) pns.append( sol_o.dec.pn ) wns.append( sol_o.dec.wn ) prs.append( sol_o.dec.qn ) if len(profits) == 0: return r'-&-&-&-&-' mean_profits = mean(profits) mean_rhos = mean(rhos) mean_pns = mean(pns) mean_wns = mean(wns) mean_prs = mean(prs) id_string = sum(sol_ids) return r'{:.5f}&{:.5f}&{:.5f}&{:.5f}&{:.5f} (n={},id={})'.format( mean_profits, mean_rhos, mean_pns, mean_wns, mean_prs, len(profits), id_string) def getAnalysisLineAbsoluteMO(self, table, par): pars = self.__anal_line_parameters(table, par) profits, rhos, pns, wns, prs, qrs, real_prs = [], [], [], [], [], [], [] sol_ids = [] # calc all vals for i, par in enumerate(pars): tau, a, s, cr, cn, delta = par sol_n, sol_o = self.__both_solutions(tau, a, s, cr, cn, delta) if sol_o.case in ('2a', '2b', '2c'): #if sol_o.case in ('1c'): sol_ids.append(i) profits.append( sol_o.profit_man ) rhos.append( sol_o.dec.rho ) pns.append( sol_o.dec.pn ) wns.append( sol_o.dec.wn ) prs.append( sol_o.dec.qn ) qrs.append (sol_o.dec.qr ) real_prs.append( sol_o.dec.pr) if len(profits) == 0: return r'-&-&-&-&-' mean_profits = mean(profits) mean_rhos = mean(rhos) mean_pns = mean(pns) mean_wns = mean(wns) mean_prs = mean(prs) mean_qrs = mean(qrs) mean_real_prs = mean(real_prs) mean_real_prs = mean(real_prs) id_string = sum(sol_ids) return r'{:.5f}&{:.5f}&{:.5f}&{:.5f}&{:.5f} qr={:.5f} pr={:.5f}, (n={},id={})'.format( mean_profits, mean_rhos, mean_pns, mean_wns, mean_prs, mean_qrs, mean_real_prs, len(profits), id_string) def getAnalysisLine(self, table, par): pars = self.__anal_line_parameters(table, par) profits, rhos, pns, wns, prs = [], [], [], [], [] # calc all vals for par in pars: tau, a, s, cr, cn, delta = par sol_n, sol_o = self.__both_solutions(tau, a, s, cr, cn, delta) profits.append(sol_o.profit_man / sol_n.profit_man) rhos.append(sol_o.dec.rho / sol_n.dec.rho) pns.append(sol_o.dec.pn / sol_n.dec.pn) wns.append(sol_o.dec.wn / sol_n.dec.wn) prs.append(sol_o.dec.pr) mean_profits = mean(profits)*100 mean_rhos = mean(rhos)*100 mean_pns = mean(pns)*100 mean_wns = mean(wns)*100 mean_prs = mean(prs) return r'{:.2f}\%&{:.2f}\%&{:.2f}\%&{:.2f}\%&{:.3f}'.format( mean_profits, mean_rhos, mean_pns, mean_wns, mean_prs) def __both_solutions(self, tau, a, s, cr, cn, delta): par_n = Parameter(MODEL_1, tau=tau, a=a, s=s, cn=cn) sol_n = self.__proxy.calculate(par_n) par_o = Parameter(MODEL_2, tau=tau, a=a, s=s, cr=cr, cn=cn, delta=delta) sol_o = self.__proxy.calculate(par_o) return (sol_n, sol_o) def __state_iter(self, iterable): state = Factorial.LOW for val in iterable: yield (val, state) state = Factorial.HIGH if state == Factorial.LOW else Factorial.LOW def getTableValue(self, table, i, j): o_val, n_val = self.__ff_table[i][j]['o'], self.__ff_table[i][j]['n'] o_sol, n_sol = o_val['sol'], n_val['sol'] if table == 'case': o_case = '-' if o_sol is None else o_sol.case n_case = '-' if n_sol is None else n_sol.case return '{}/{}'.format(o_case, n_case) if None in (o_sol, n_sol): return '-' if table == 'profits': prof = (o_val['sol'].profit_man / n_val['sol'].profit_man)*100 return '{:.2f}\\%'.format(prof) elif table == 'retailerprof': prof = (o_val['sol'].profit_ret / n_val['sol'].profit_ret)*100 return '{:.2f}\\%'.format(prof) elif table == 'rho': rho_dec = (o_val['sol'].dec.rho / n_val['sol'].dec.rho) *100 return '{:.2f}\\%'.format(rho_dec) elif table == 'price_new': price_dec = (o_val['sol'].dec.pn / n_val['sol'].dec.pn) * 100 return '{:.2f}\\%'.format(price_dec) elif table == 'wholesale_price': wn_dec = (o_val['sol'].dec.wn / n_val['sol'].dec.wn) * 100 return '{:.2f}\\%'.format(wn_dec) elif table.startswith('par'): par = table.split('_')[1] if par == 'tau': return o_val['par'].tau elif par == 'cn': return o_val['par'].cn elif par == 'cr': return o_val['par'].cr elif par == 'a': return o_val['par'].a elif par == 's': return o_val['par'].s elif par == 'delta': return o_val['par'].delta
class CountourPlotter: def __init__(self, type, params): self.proxy = SolverProxy() self.type = type self.tau, self.s, self.cr, self.delta = params['tau'], params[ 's'], params['cr'], params['delta'] self.count_a, self.lower_bound_a, self.upper_bound_a = params[ 'count_a'], params['lower_bound_a'], params['upper_bound_a'] self.count_cn, self.lower_bound_cn, self.upper_bound_cn = params[ 'count_cn'], params['lower_bound_cn'], params['upper_bound_cn'] self._calc_func = { PLOT_CASES_MODEL_TWO: self.__case_calc_func_model_two }[type] self.absolute = params['absolute'] self.gray = params['gray'] self.output = params['output'] self.nolegend = params['nolegend'] if type == PLOT_PROFIT_DIFFERENCE_MAN and self.absolute: self._calc_func = self.__profit_calc_func_man_absolute elif type == PLOT_PROFIT_DIFFERENCE_RET and self.absolute: self._calc_func = self.__profit_calc_func_ret_absolute elif type == PLOT_RHO_DIFFERENCE and self.absolute: self._calc_func = self.__rho_calc_func_absolute self.matrix = None def _a_cn_generator(self): """ Helper generator to generate parameters for plotting it varies cn from [cr, 1] and a from [0, upper_bound_a] Returns a tuple of (par_model_1, par_model_2) """ def __cr(cn): #if self.cr == 'delta*cn/2': # return self.delta * cn / 2 if self.cr == '0.5*cn': return 0.5 * cn else: return self.cr def __s(cn): if self.s == 'cn/2': return cn / 2 else: return self.s for line, cn in enumerate( np.linspace(self.lower_bound_cn, self.upper_bound_cn, self.count_cn)): for col, a in enumerate( np.linspace(self.lower_bound_a, self.upper_bound_a, self.count_a)): cn, a = float(cn), float(a) par_model_1 = None par_model_2 = Parameter(MODEL_2_QUAD, tau=self.tau, a=a, s=__s(cn), cr=__cr(cn), cn=cn, delta=self.delta) yield (line, col, par_model_1, par_model_2) def calc(self): self.nr_cols = self.count_a self.nr_lines = self.count_cn self.matrix = np.zeros([self.nr_lines, self.nr_cols]) i = 0 numall = self.nr_cols * self.nr_lines print(numall) #self.proxy.beginWrite() for line, col, par_model_1, par_model_2 in self._a_cn_generator(): # calc solutions if par_model_2.a == .0: sol_model_1, sol_model_2 = None, None else: #sol_model_1 = solver_m1.optimize(par_model_1) #sol_model_2 = solver_m2.optimize(par_model_2) #sol_model_1 = self.proxy.read_or_calc_and_write(par_model_1, resolution='low') sol_model_1 = None #todo hier fuer model 1 aufschalten #sol_model_2 = self.proxy.read_or_calc_and_write(par_model_2, resolution='low') sol_model_2 = self.proxy.calculate(par_model_2, resolution=RESOLUTION) self.matrix[line, col] = self._calc_func(sol_model_1, sol_model_2, par_model_2) if i % 100 == 0: #self.proxy.commit() print('{} ({:.2f} %) at {}'.format( i, (i / numall) * 100, str(datetime.datetime.now()))) i += 1 self.proxy.commit() #self.proxy.endWrite() def __profit_calc_func_man(self, sol_model_1, sol_model_2, par): if sol_model_1 is None or sol_model_2 is None: return np.nan rel = (sol_model_2.profit_man - sol_model_1.profit_man) / sol_model_1.profit_man #if rel <= 0 or rel >= .3: #if rel < .3: # return np.nan #return max(0, min(.5, rel)) return rel def __profit_calc_func_ret(self, sol_model_1, sol_model_2, par): if sol_model_1 is None or sol_model_2 is None: return np.nan rel = (sol_model_2.profit_ret - sol_model_1.profit_ret) / sol_model_1.profit_ret return rel def __profit_calc_func_ret_absolute(self, sol_model_1, sol_model_2, par): if sol_model_1 is None or sol_model_2 is None: return np.nan rel = sol_model_2.profit_ret - sol_model_1.profit_ret return rel def __profit_calc_func_man_absolute(self, sol_model_1, sol_model_2, par): if sol_model_1 is None and sol_model_2 is None or par.cn <= par.cr: return np.nan prof_1 = sol_model_1.profit_man if sol_model_1 is not None else 0 prof_2 = sol_model_2.profit_man if sol_model_2 is not None else 0 rel = (prof_2 - prof_1) return rel def __case_calc_func_model_one(self, sol_model_1, sol_model_2, par): return NotImplementedError() def __case_calc_func_model_two(self, sol_model_1, sol_model_2, par): if sol_model_2 == None: return np.nan #elif round(sol_model_2.profit_man, 1) == 0 or round(sol_model_2.profit_ret, 1) == 0: # return np.nan else: return _ALL_CASES_MODEL_2.index(sol_model_2.case) + 1 def plot_contourf(self): cmap = cm.gray if self.gray else None fig = plt.figure() ax = plt.subplot(111) levels, colors, extend = None, None, 'both' yticklabels = None if self.type == PLOT_PROFIT_DIFFERENCE_MAN: title = 'Increase of Profits with vs. without Online Store' side_title = r'relative increase of $\pi_{man}$' if self.absolute: side_title = side_title.replace('relative', 'absolute') cbar_ticks = None elif self.type == PLOT_PROFIT_DIFFERENCE_RET: title = 'Increase of Profits with vs. without Online Store' side_title = r'relative increase of $\pi_{ret}$' if self.absolute: side_title = side_title.replace('relative', 'absolute') cbar_ticks = None elif self.type == PLOT_RHO_DIFFERENCE: title = r'Increase of Efforts $\rho$ with vs. without Online Store' side_title = r'relative increase of $\rho$' if self.absolute: side_title = side_title.replace('relative', 'absolute') cbar_ticks = None elif self.type == PLOT_CASES_MODEL_ONE: title = r'Which case will be active in the event of no Online Shop' side_title = r'0 = no solution, 1 = case 1, 2 = case 2' levels = [0, 1, 2] yticklabels = r'case $\rho\geq1$', r'case $\rho = 1$' elif self.type == PLOT_CASES_MODEL_TWO: title = r'Which case will be active in the event of having an Online Shop' #side_title = r'1=c1a, 2=c1b, 3=c1c, 4=c2a, 5=c2b, 6=c3b' side_title = '' levels = [0, 1, 2, 3, 4, 5, 6] colors = [ '#ee4b4b', '#e12726', '#960000', '#44db6b', '#0ed040', '#009727' ] yticklabels = '1a', '1b', '1c', '2a', '2b', '2c' elif self.type == PLOT_COMPARE_CASES: title = r'Comparison of Cases Model 1 vs. 2' cbar_ticks = None side_title = '' yticklabels = [ 'same case', 'M1C1, M2C2', 'M1C2, M2C1', 'S1N2', 'S2N1' ] levels = [0, 1, 2, 3, 4] #fig.suptitle(title) x_vector = np.linspace(self.lower_bound_a, self.upper_bound_a, num=self.nr_cols) # x is a y_vector = np.linspace(self.lower_bound_cn, self.upper_bound_cn, num=self.nr_lines) # y is cn cont = ax.contourf(x_vector, y_vector, self.matrix, label='heatmap', levels=levels, colors=colors, origin='lower', extend=extend) cont.cmap.set_under('yellow') cont.cmap.set_over('cyan') cbar = fig.colorbar(cont) if yticklabels: cbar.ax.set_yticklabels( yticklabels) # vertically oriented colorbar cbar.ax.set_ylabel(side_title) ax.set_xlabel('a') ax.set_ylabel(r'$c_n$') # Put a text of paramaters below current axis if not self.nolegend: txt = self.__par_txt() fig.text(0.20, 0.83, txt, fontsize=12) #, bbox=dict(facecolor='white', alpha=0.5)) plt.subplots_adjust(bottom=0.15) if self.output == None: plt.show() else: plt.savefig(self.output) plt.close(fig) def __par_txt(self): if self.cr == 'delta*cn/2': _cr = r'$\frac{\delta*cn}{2}$' elif self.cr == '0.4*cn': _cr = '40% of cn' else: _cr = '{:.2f}'.format(self.cr) if self.s == 'cn/2': _s = r'$\frac{1}{2}cn$' else: _s = '{:.2f}'.format(self.s) return r'par: $\tau$={:.2f}, s={}, cr={}, $\delta$={:.2f}'.format( self.tau, _s, _cr, self.delta) def plot(self): self.plot_contourf()
class Factorial: tau_lo = lambda: .005 tau_hi = lambda: 0.35 tau_lh = lambda: (.005, .35) s_lo = lambda: 0 s_hi = lambda cn: cn / 2 s_lh = lambda cn: (0, cn / 2) cr_lo = lambda: .1 cr_hi = lambda cn, delta: delta * (cn / 2) cr_lh = lambda cn, delta: (.1, delta * (cn / 2)) delta_lo = lambda: .5 delta_hi = lambda: .85 delta_lh = lambda: (.5, .85) cn_lo = lambda: .1 cn_hi = lambda: .5 cn_lh = lambda: (.1, .5) a_lo = lambda: .001 a_hi = lambda: .1 a_lh = lambda: (.001, .1) LOW, HIGH = 'LOW', 'HIGH' def __init__(self): self.__dict = {} self.__proxy = SolverProxy() self.__calc__() self.__fullFactorialTable() def __key(self, model, tau, a, s, cr, cn, delta): assert model in (MODEL_NB, MODEL_1) for val in (tau, a, s, cr, cn): assert val in (Factorial.LOW, Factorial.HIGH) return '{},tau={},a={},s={},cr={},cn={},delta={}'.format( model, tau, a, s, cr, cn, delta) def _add(self, key, par, sol): assert key not in self.__dict self.__dict[key] = {'par': par, 'sol': sol} def _get(self, key): return self.__dict[key] def __calc__(self): p = Factorial iter = self.__state_iter proxy = SolverProxy() num = 0 for tau, tau_state in iter([p.tau_lo(), p.tau_hi()]): for cn, cn_state in iter([p.cn_lo(), p.cn_hi()]): for s, s_state in iter([p.s_lo(), p.s_hi(cn)]): for a, a_state in iter([p.a_lo(), p.a_hi()]): # calculate model with restocking_fee par_nb = Parameter(MODEL_NB, tau=tau, a=a, s=s, cn=cn) sol_nb = proxy.read_or_calc_and_write( par_nb, resolution='high') num += 1 print(num) #sol_nb = ModelNBSolver.solve(par_nb, 'low') key_nb = self.__key(MODEL_NB, tau_state, a_state, s_state, Factorial.HIGH, cn_state, Factorial.HIGH) self._add(key_nb, par_nb, sol_nb) # calculate model without online store par_no = Parameter(MODEL_1, tau=tau, a=a, s=s, cn=cn) sol_no = proxy.calculate(par_no) key_no = self.__key(MODEL_1, tau_state, a_state, s_state, Factorial.HIGH, cn_state, Factorial.HIGH) self._add(key_no, par_no, sol_no) proxy.commit() def __fullFactorialTable(self): self.__ff_table = [[None for j in range(4)] for i in range(4)] lohi = (Factorial.LOW, Factorial.HIGH) for i, (s, a) in enumerate([(s, a) for s in lohi for a in lohi]): for j, (cn, tau) in enumerate([(cn, tau) for cn in lohi for tau in lohi]): key_nb = self.__key(MODEL_NB, tau, a, s, Factorial.HIGH, cn, Factorial.HIGH) key_no = self.__key(MODEL_1, tau, a, s, Factorial.HIGH, cn, Factorial.HIGH) val_nb = self._get(key_nb) val_no = self._get(key_no) self.__ff_table[i][j] = {'no': val_no, 'nb': val_nb} def __anal_line_parameters(self, table, par): f = Factorial pars = [] if table == 'delta': delta = par for tau, cn in [(tau, cn) for tau in f.tau_lh() for cn in f.cn_lh()]: for a, s, cr in [(a, s, cr) for a in f.a_lh() for s in f.s_lh(cn) for cr in f.cr_lh(cn, delta)]: pars.append([tau, a, s, cr, cn, delta]) if table == 'tau': tau = par for delta, cn in [(delta, cn) for delta in f.delta_lh() for cn in f.cn_lh()]: for a, s, cr in [(a, s, cr) for a in f.a_lh() for s in f.s_lh(cn) for cr in f.cr_lh(cn, delta)]: pars.append([tau, a, s, cr, cn, delta]) if table == 'cn': cn = par for tau, delta in [(tau, delta) for tau in f.tau_lh() for delta in f.delta_lh()]: for a, s, cr in [(a, s, cr) for a in f.a_lh() for s in f.s_lh(cn) for cr in f.cr_lh(cn, delta)]: pars.append([tau, a, s, cr, cn, delta]) if table == 'a': a = par for tau, delta, cn in [(tau, delta, cn) for tau in f.tau_lh() for delta in f.delta_lh() for cn in f.cn_lh()]: for s, cr in [(s, cr) for s in f.s_lh(cn) for cr in f.cr_lh(cn, delta)]: pars.append([tau, a, s, cr, cn, delta]) assert len(pars) == int(2**5) return pars def getAnalysisLine(self, table, par): pars = self.__anal_line_parameters(table, par) profits, rhos, pns, wns, prs = [], [], [], [], [] # calc all vals for par in pars: tau, a, s, cr, cn, delta = par sol_n, sol_o = self.__both_solutions(tau, a, s, cr, cn, delta) profits.append(sol_o.profit_man / sol_n.profit_man) rhos.append(sol_o.dec.rho / sol_n.dec.rho) pns.append(sol_o.dec.pn / sol_n.dec.pn) wns.append(sol_o.dec.wn / sol_n.dec.wn) prs.append(sol_o.dec.pr) mean_profits = mean(profits) * 100 mean_rhos = mean(rhos) * 100 mean_pns = mean(pns) * 100 mean_wns = mean(wns) * 100 mean_prs = mean(prs) return r'{:.2f}\%&{:.2f}\%&{:.2f}\%&{:.2f}\%&{:.3f}'.format( mean_profits, mean_rhos, mean_pns, mean_wns, mean_prs) def __both_solutions(self, tau, a, s, cr, cn, delta): par_n = Parameter(MODEL_1, tau=tau, a=a, s=s, cn=cn) sol_n = self.__proxy.calculate(par_n) par_o = Parameter(MODEL_2, tau=tau, a=a, s=s, cr=cr, cn=cn, delta=delta) sol_o = self.__proxy.calculate(par_o) return (sol_n, sol_o) def __state_iter(self, iterable): state = Factorial.LOW for val in iterable: yield (val, state) state = Factorial.HIGH if state == Factorial.LOW else Factorial.LOW def getTableValue(self, table, i, j): no_val, nb_val = self.__ff_table[i][j]['no'], self.__ff_table[i][j][ 'nb'] no_sol, nb_sol = no_val['sol'], nb_val['sol'] if table == 'case': return '{}/{}'.format(no_sol.case, nb_sol.case) elif table == 'profits': prof = (nb_sol.profit_man / no_sol.profit_man) * 100 return '{:.2f}\\%'.format(prof) elif table == 'retailerprof': prof = (nb_sol.profit_ret / no_sol.profit_ret) * 100 return '{:.2f}\\%'.format(prof) elif table == 'rho': rho_dec = (nb_sol.dec.rho / no_sol.dec.rho) * 100 return '{:.2f}\\%'.format(rho_dec) elif table == 'price_new': price_dec = (nb_sol.dec.pn / no_sol.dec.pn) * 100 return '{:.2f}\\%'.format(price_dec) elif table == 'wholesale_price': wn_dec = nb_sol.dec.wn return '{:.2f}\\%'.format(wn_dec) elif table == 'restocking_price': rest_price = nb_sol.dec.b #'{:.2f}\\%'.format(b_rel) return '{:.2f}'.format(rest_price) elif table.startswith('par'): par = table.split('_')[1] if par == 'tau': return o_val['par'].tau elif par == 'cn': return o_val['par'].cn elif par == 'cr': return o_val['par'].cr elif par == 'a': return o_val['par'].a elif par == 's': return o_val['par'].s elif par == 'delta': return o_val['par'].delta