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 test_write_and_read(self):
proxy = SolverProxy()
#par = Parameter(MODEL_2_QUAD, tau=.09, a=0.00146, s=.04, cr=.04, cn=.1, delta=.7956)
par = Parameter(MODEL_1, tau=0.09, a=0.00146, s=.04, cn=.1)
sol = proxy.read_or_calc_and_write(par, comment='unittest')
proxy.commit()
print(sol)
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 __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()
class Factorial:
tau_lh = lambda: (.15, .5)
s_lh = lambda cn: (0, cn / 2)
cr_lh = lambda cn: (.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, model):
self._model = model
self._solverProxy = SolverProxy()
self._calcTable()
def _calcTable(self):
self.__ff_table = [[None for j in range(8)] for i in range(8)]
lohi = (0, 1)
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]):
tau_val = Factorial.tau_lh()[tau]
delta_val = Factorial.delta_lh()[delta]
cn_val = Factorial.cn_lh()[cn]
cr_val = Factorial.cr_lh(cn_val)[cr]
s_val = Factorial.s_lh(cn_val)[s]
a_val = Factorial.a_lh()[a]
par_o = Parameter(MODEL_2,
tau=tau_val,
a=a_val,
s=s_val,
cr=cr_val,
cn=cn_val,
delta=delta_val)
par_n = Parameter(MODEL_1,
tau=tau_val,
a=a_val,
s=s_val,
cn=cn_val)
par_nb = Parameter(MODEL_NB,
tau=tau_val,
a=a_val,
s=s_val,
cn=cn_val)
par_oq = Parameter(MODEL_2_QUAD,
tau=tau_val,
a=a_val,
s=s_val,
cr=cr_val,
cn=cn_val,
delta=delta_val)
par_nq = Parameter(MODEL_1_QUAD,
tau=tau_val,
a=a_val,
s=s_val,
cn=cn_val)
if self._model == 'modelo':
par_1, par_2 = par_o, par_n
elif self._model == 'modelnb':
par_1, par_2 = par_o, par_nb
elif self._model == 'modeloq':
par_1, par_2 = par_oq, par_nq
# solve
self.__ff_table[i][j] = {
'par_1': par_1,
'par_2': par_2,
'sol_1': self._solverProxy.read_or_calc_and_write(par_1),
'sol_2': self._solverProxy.read_or_calc_and_write(par_2)
}
if self.__ff_table[i][j]['sol_2'] is None or self.__ff_table[
i][j]['sol_2'].profit_ret < 0.00005:
self.__ff_table[i][j]['sol_2'] = None
print(par_2)
self._solverProxy.commit()
def _latex_percentage(self, value):
if self._isLatex:
return '{:.2f}\\%'.format(value * 100)
else:
return '{:.4f}'.format(value)
def template_table_val(self, table, i, j):
# sol_1 is online store!
par_1, par_2 = self.__ff_table[i][j]['par_1'], self.__ff_table[i][j][
'par_2']
sol_1, sol_2 = self.__ff_table[i][j]['sol_1'], self.__ff_table[i][j][
'sol_2']
percentage = self._latex_percentage
if table == 'case':
case_1 = '-' if sol_1 is None else sol_1.case
case_2 = '-' if sol_2 is None else sol_2.case
return '{}/{}'.format(case_1, case_2)
if None in (sol_1, sol_2): return '-'
if table == 'profits':
return percentage(sol_1.profit_man / sol_2.profit_man)
elif table == 'retailerprof':
return percentage(sol_1.profit_ret / sol_2.profit_ret)
elif table == 'rho':
return percentage(sol_1.dec.rho / sol_2.dec.rho)
elif table == 'price_new':
return percentage(sol_1.dec.pn / sol_2.dec.pn)
elif table == 'wholesale_price':
return percentage(sol_1.dec.wn / sol_2.dec.wn)
elif table == 'restocking_price':
return percentage(
(sol_2.dec.b - par_2.s) / (sol_2.dec.wn - par_2.s))
elif table == 'retailerprof2':
return sol_2.profit_ret
def getTemplateVariables(self):
return {'esc': utils.escape_tex, 'ft': self.template_table_val}
def render_template(self, tpl_filename, out_filename, isLatex):
self._isLatex = isLatex
env = Environment(loader=FileSystemLoader('templates'))
template = env.get_template(tpl_filename)
with open(out_filename, 'w', newline='\n') as f:
renderedString = template.render(self.getTemplateVariables())
f.write(renderedString)
