def new_demo(test=False):
import pygame
from demo.game import Game
if test is False:
game = Game(640, 480, None)
else:
def _render(game):
while True:
game.draw()
for event in pygame.event.get():
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_9:
game.increase_fps()
elif event.key == pygame.K_0:
game.decrease_fps()
pygame.init()
DISPLAYSURF = pygame.display.set_mode((640, 480), 0, 32)
pygame.display.set_caption('Demo')
game = Game(640, 480, DISPLAYSURF)
t = Thread(target=lambda: _render(game))
t.start()
parameter = Parameter(lr=1e-3)
parameter.gamma = 0.9
parameter.iteration_num = 300000
parameter.num_history_frames = 1
parameter.network_type = 'mlp'
parameter.update_method = 'rmsprop'
parameter.rho = 0.95
parameter.async_update_interval = 5
parameter.input_scale = 1.0
return game, parameter
def initialize(self):
parameters = []
configure_parameters = self.configure.get(self.name)
if type(configure_parameters) is list:
parameters.extend(configure_parameters)
else:
parameters.append(configure_parameters)
files = listdir(self.path)
for parameterName in parameters:
##for example cpu.shares then it will start with cpu, we only configure these files.
if parameterName in files:
##we pass the path fo the file under this subsystem to Parameter class
fileName = self.path + "/" + parameterName
parameter = Parameter(name=parameterName,
path=fileName,
configure=self.configure)
self.subParameters[parameterName] = parameter
else:
log.error("can not find file parameter %s", parameterName)
##TODO we can't find a file mathed with parameter log error message here
pass
##read initial values
for parameter in self.subParameters.values():
parameter.read()
class Gauss1D(ArithmeticModel):
def __init__(self, name='gauss1d'):
self.fwhm = Parameter(name, 'fwhm', 10, tinyval, hard_min=tinyval)
self.pos = Parameter(name, 'pos', 0)
self.ampl = Parameter(name, 'ampl', 1)
ArithmeticModel.__init__(self, name, (self.fwhm, self.pos, self.ampl))
def get_center(self):
return (self.pos.val,)
def set_center(self, pos, *args, **kwargs):
self.pos.set(pos)
def guess(self, dep, *args, **kwargs):
norm = guess_amplitude(dep, *args)
pos = get_position(dep, *args)
fwhm = guess_fwhm(dep, *args)
param_apply_limits(norm, self.ampl, **kwargs)
param_apply_limits(pos, self.pos, **kwargs)
param_apply_limits(fwhm, self.fwhm, **kwargs)
@modelCacher1d
def calc(self, *args, **kwargs):
kwargs['integrate']=bool_cast(self.integrate)
return _modelfcts.gauss1d(*args, **kwargs)
def compile(self, network):
if self.output is not None:
raise Exception("Layer " + self.name + " is already compiled!")
if self.parameters is None:
self.W = tf.Variable(tf.random_normal(
[self.input_layers[0].get_size(), self.size],
mean=0.0,
stddev=(self.weights_init_stddev /
sqrt(self.input_layers[0].get_size()))),
name=(network.name + "_" + self.name + "_W"))
self.b = tf.Variable(tf.random_normal(
[self.size], mean=0.0, stddev=self.bias_init_stddev),
name=(network.name + "_" + self.name + "_b"))
self.parameters = [
Parameter(self.W, trainable=True, regularizable=True),
Parameter(self.b)
]
else:
self.W = self.parameters[0].tf_variable
self.b = self.parameters[1].tf_variable
self.output = self.activation_fn(
tf.matmul(self.input_layers[0].get_output(), self.W) + self.b,
name=(network.name + "_" + self.name))
class NormGauss1D(ArithmeticModel):
def __init__(self, name='normgauss1d'):
self.fwhm = Parameter(name, 'fwhm', 10, tinyval, hard_min=tinyval)
self.pos = Parameter(name, 'pos', 0)
self.ampl = Parameter(name, 'ampl', 1)
ArithmeticModel.__init__(self, name, (self.fwhm, self.pos, self.ampl))
def get_center(self):
return (self.pos.val,)
def set_center(self, pos, *args, **kwargs):
self.pos.set(pos)
def guess(self, dep, *args, **kwargs):
ampl = guess_amplitude(dep, *args)
pos = get_position(dep, *args)
fwhm = guess_fwhm(dep, *args)
param_apply_limits(pos, self.pos, **kwargs)
param_apply_limits(fwhm, self.fwhm, **kwargs)
# Apply normalization factor to guessed amplitude
norm = numpy.sqrt(numpy.pi/_gfactor)*self.fwhm.val
for key in ampl.keys():
if ampl[key] is not None:
ampl[key] *= norm
param_apply_limits(ampl, self.ampl, **kwargs)
@modelCacher1d
def calc(self, *args, **kwargs):
kwargs['integrate']=bool_cast(self.integrate)
return _modelfcts.ngauss1d(*args, **kwargs)
def __init__(self):
# Parameters
self.charging_current_limit = 5
self.gyro_limit = 0.15
self.min_number_of_values_over_limit = 25
self.array_length = 90
self.min_trip_length = 300 #s
self.trip_started = False
self.max_time_between_movement = 280 #s
self.max_avg_speed = 30 #km/h
# Declaring variables
self.charging_currents = Parameter(self.array_length, self.charging_current_limit, self.min_number_of_values_over_limit)
self.gyroscopes = Parameter(self.array_length, self.gyro_limit, self.min_number_of_values_over_limit)
self.start_times = []
self.end_times = []
# Declaring temporary variable for trips
self.tmp_start_time = 0
# Defining positions of variables in DB
self.time_db = 0
# latGPS_db = 3
# lenGPS_db = 4
self.charging_current_db = 26
self.gyro_x_db = 13
self.gyro_y_db = 14
self.gyro_z_db = 15
def test_spider():
from session import Session
from condition import Condition
from spider import Spider
from parameter import Parameter
from datetime import datetime
s = Session()
c = Condition()
# parameter = Parameter(param=str(c), sess=s)
spider = Spider(sess=s)
# page: 每页几条; order: 排序标准; direction: 顺序 (asc - 正序 desc - 倒序)
print(
spider.tree_content(param=Parameter(param=str(
c.district('西藏自治区').date(datetime(1991, 1, 1), datetime(
2018, 9, 15))),
sess=s)))
for i in spider.content_list(param=Parameter(param=str(
c.district('西藏自治区').date(datetime(1991, 1, 1),
datetime(2018, 9, 15))),
sess=s),
page=20,
order='法院层级',
direction='asc'):
print(i)
class Delta2D(ArithmeticModel):
def __init__(self, name='delta2d'):
self.xpos = Parameter(name, 'xpos', 0)
self.ypos = Parameter(name, 'ypos', 0)
self.ampl = Parameter(name, 'ampl', 1)
ArithmeticModel.__init__(self, name, (self.xpos, self.ypos, self.ampl))
self.cache = 0
def get_center(self):
return (self.xpos.val, self.ypos.val)
def set_center(self, xpos, ypos, *args, **kwargs):
self.xpos.set(xpos)
self.ypos.set(ypos)
def guess(self, dep, *args, **kwargs):
xpos, ypos = guess_position(dep, *args)
norm = guess_amplitude2d(dep, *args)
param_apply_limits(xpos, self.xpos, **kwargs)
param_apply_limits(ypos, self.ypos, **kwargs)
param_apply_limits(norm, self.ampl, **kwargs)
def calc(self, *args, **kwargs):
kwargs['integrate']=bool_cast(self.integrate)
return _modelfcts.delta2d(*args, **kwargs)
class Gauss2D(ArithmeticModel):
def __init__(self, name='gauss2d'):
self.fwhm = Parameter(name, 'fwhm', 10, tinyval, hard_min=tinyval)
self.xpos = Parameter(name, 'xpos', 0)
self.ypos = Parameter(name, 'ypos', 0)
self.ellip = Parameter(name, 'ellip', 0, 0, 0.999, 0, 0.9999,
frozen=True)
self.theta = Parameter(name, 'theta', 0, 0, 2*numpy.pi, -2*numpy.pi,
4*numpy.pi, 'radians', frozen=True)
self.ampl = Parameter(name, 'ampl', 1)
ArithmeticModel.__init__(self, name,
(self.fwhm, self.xpos, self.ypos, self.ellip,
self.theta, self.ampl))
self.cache = 0
def get_center(self):
return (self.xpos.val, self.ypos.val)
def set_center(self, xpos, ypos, *args, **kwargs):
self.xpos.set(xpos)
self.ypos.set(ypos)
def guess(self, dep, *args, **kwargs):
xpos, ypos = guess_position(dep, *args)
norm = guess_amplitude2d(dep, *args)
param_apply_limits(xpos, self.xpos, **kwargs)
param_apply_limits(ypos, self.ypos, **kwargs)
param_apply_limits(norm, self.ampl, **kwargs)
def calc(self, *args, **kwargs):
kwargs['integrate']=bool_cast(self.integrate)
return _modelfcts.gauss2d(*args, **kwargs)
def __init__(self, name, parts):
self.parts = tuple(parts)
allpars = []
for part in self.parts:
for p in part.pars:
if p in allpars:
# If we already have a reference to this parameter, store
# a hidden, linked proxy instead
pnew = Parameter(p.modelname, p.name, 0.0, hidden=True)
pnew.link = p
p = pnew
allpars.append(p)
Model.__init__(self, name, allpars)
for part in self.parts:
try:
self.is_discrete = self.is_discrete or part.is_discrete
except:
warning(
"Could not determine whether the model is discrete.\n" +
"This probably means that you have restored a session saved with a previous version of Sherpa.\n"
+
"Falling back to assuming that the model is continuous.\n")
self.is_discrete = False
def __init__(self, name='integrate1d'):
tol = numpy.finfo(float).eps
self.epsabs = Parameter(name, 'epsabs', tol, alwaysfrozen=True)
self.epsrel = Parameter(name, 'epsrel', 0, alwaysfrozen=True)
self.maxeval = Parameter(name, 'maxeval', 10000, alwaysfrozen=True)
ArithmeticModel.__init__(self, name,
(self.epsabs, self.epsrel, self.maxeval))
def __init__(self):
# Parameters
self.charging_current_limit = 5
self.gyro_limit = 0.15
self.min_number_of_values_over_limit = 25
self.array_length = 90
self.min_trip_length = 300 # s
self.trip_started = False
self.max_time_between_movement = 280 # s
self.max_avg_speed = 30 # km/h
# Declaring variables
self.charging_currents = Parameter(
self.array_length, self.charging_current_limit,
self.min_number_of_values_over_limit)
self.gyroscopes = Parameter(self.array_length, self.gyro_limit,
self.min_number_of_values_over_limit)
self.start_times = []
self.end_times = []
# Declaring temporary variable for trips
self.tmp_start_time = 0
# Defining positions of variables in DB
self.time_db = 0
# latGPS_db = 3
# lenGPS_db = 4
self.charging_current_db = 26
self.gyro_x_db = 13
self.gyro_y_db = 14
self.gyro_z_db = 15
def initialize(self):
parameters = []
configure_parameters = self.configure.get(self.name)
if type(configure_parameters) is list:
parameters.extend(configure_parameters)
else:
parameters.append(configure_parameters)
files=listdir(self.path)
for parameterName in parameters:
##for example cpu.shares then it will start with cpu, we only configure these files.
if parameterName in files:
##we pass the path fo the file under this subsystem to Parameter class
fileName = self.path+"/"+parameterName
parameter = Parameter(name=parameterName,
path=fileName,
configure=self.configure)
self.subParameters[parameterName]=parameter
else:
log.error("can not find file parameter %s",parameterName)
##TODO we can't find a file mathed with parameter log error message here
pass
##read initial values
for parameter in self.subParameters.values():
parameter.read()
def getParameters(aParams, aTypes, aOffset):
if aParams == []:
return []
if aParams[0] in aTypes:
t = aTypes[aParams[0]]
elif aParams[0][0] == '@' and aParams[0][1:] in aTypes:
t = aTypes[aParams[0][1:]]
else: # Type not known, assume TDesC8
t = aTypes.get(
aParams[1],
Type(aParams[0], 'TDesC8', 'TPtrC8', 'TPtrC8', aParams[1],
'AsString', 'PutString', 'PutString', '', True, False, False,
'_L8("\\x0")', '_L8("\\xff")', 'UnknownType_instance', '',
''))
newOffset = aOffset
if t.iSize != 'n': # Not of 'infinite' size
newOffset += int(t.iSize)
if len(aParams) > 2 and aParams[
2] == '*': # Is 'array', delimited by other parameter.
return [Parameter(t, aParams[0], aOffset, aParams[3])] + getParameters(
aParams[4:], aTypes, newOffset)
else:
return [Parameter(t, aParams[0], aOffset)] + getParameters(
aParams[2:], aTypes, newOffset)
def __init__(self, name='logparabola'):
self.ref = Parameter(name, 'ref', 1, alwaysfrozen=True)
self.c1 = Parameter(name, 'c1', 1)
self.c2 = Parameter(name, 'c2', 1)
self.ampl = Parameter(name, 'ampl', 1, 0)
ArithmeticModel.__init__(self, name,
(self.ref, self.c1, self.c2, self.ampl))
class Gauss1D(ArithmeticModel):
def __init__(self, name='gauss1d'):
self.fwhm = Parameter(name, 'fwhm', 10, tinyval, hard_min=tinyval)
self.pos = Parameter(name, 'pos', 0)
self.ampl = Parameter(name, 'ampl', 1)
ArithmeticModel.__init__(self, name, (self.fwhm, self.pos, self.ampl))
def get_center(self):
return (self.pos.val, )
def set_center(self, pos, *args, **kwargs):
self.pos.set(pos)
def guess(self, dep, *args, **kwargs):
norm = guess_amplitude(dep, *args)
pos = get_position(dep, *args)
fwhm = guess_fwhm(dep, *args)
param_apply_limits(norm, self.ampl, **kwargs)
param_apply_limits(pos, self.pos, **kwargs)
param_apply_limits(fwhm, self.fwhm, **kwargs)
@modelCacher1d
def calc(self, *args, **kwargs):
kwargs['integrate'] = bool_cast(self.integrate)
return _modelfcts.gauss1d(*args, **kwargs)
class Delta2D(ArithmeticModel):
def __init__(self, name='delta2d'):
self.xpos = Parameter(name, 'xpos', 0)
self.ypos = Parameter(name, 'ypos', 0)
self.ampl = Parameter(name, 'ampl', 1)
ArithmeticModel.__init__(self, name, (self.xpos, self.ypos, self.ampl))
self.cache = 0
def get_center(self):
return (self.xpos.val, self.ypos.val)
def set_center(self, xpos, ypos, *args, **kwargs):
self.xpos.set(xpos)
self.ypos.set(ypos)
def guess(self, dep, *args, **kwargs):
xpos, ypos = guess_position(dep, *args)
norm = guess_amplitude2d(dep, *args)
param_apply_limits(xpos, self.xpos, **kwargs)
param_apply_limits(ypos, self.ypos, **kwargs)
param_apply_limits(norm, self.ampl, **kwargs)
def calc(self, *args, **kwargs):
kwargs['integrate'] = bool_cast(self.integrate)
return _modelfcts.delta2d(*args, **kwargs)
class NormGauss1D(ArithmeticModel):
def __init__(self, name='normgauss1d'):
self.fwhm = Parameter(name, 'fwhm', 10, tinyval, hard_min=tinyval)
self.pos = Parameter(name, 'pos', 0)
self.ampl = Parameter(name, 'ampl', 1)
ArithmeticModel.__init__(self, name, (self.fwhm, self.pos, self.ampl))
def get_center(self):
return (self.pos.val, )
def set_center(self, pos, *args, **kwargs):
self.pos.set(pos)
def guess(self, dep, *args, **kwargs):
ampl = guess_amplitude(dep, *args)
pos = get_position(dep, *args)
fwhm = guess_fwhm(dep, *args)
param_apply_limits(pos, self.pos, **kwargs)
param_apply_limits(fwhm, self.fwhm, **kwargs)
# Apply normalization factor to guessed amplitude
norm = numpy.sqrt(numpy.pi / _gfactor) * self.fwhm.val
for key in ampl.keys():
if ampl[key] is not None:
ampl[key] *= norm
param_apply_limits(ampl, self.ampl, **kwargs)
@modelCacher1d
def calc(self, *args, **kwargs):
kwargs['integrate'] = bool_cast(self.integrate)
return _modelfcts.ngauss1d(*args, **kwargs)
def __init__(self, D=None, R=None):
if D is None:
raise(ValueError, 'Distributions must be given')
else:
self.D = D
if R is None:
raise(ValueError, 'Correlation matrix must be specified')
else:
self.R = R
self.std = Parameter(order=5, distribution='normal',shape_parameter_A = 0.0, shape_parameter_B = 1.0)
#
# R0 = fictive matrix of correlated normal intermediate variables
#
# 1) Check the type of correlated marginals
# 2) Use Effective Quadrature for solving Legendre
# 3) Calculate the fictive matrix
inf_lim = -8.0
sup_lim = - inf_lim
p1 = Parameter(distribution = 'uniform', lower = inf_lim, upper = sup_lim, order = 31)
myBasis = Basis('Tensor grid')
Pols = Polyint([p1, p1], myBasis)
p = Pols.quadraturePoints
w = Pols.quadratureWeights * (sup_lim - inf_lim)**2
p1 = p[:,0]
p2 = p[:,1]
R0 = np.eye((len(self.D)))
for i in range(len(self.D)):
for j in range(i+1, len(self.D), 1):
if self.R[i,j] == 0:
R0[i,j] = 0.0
else:
tp11 = -(np.array(self.D[i].getiCDF(self.std.getCDF(points=p1))) - self.D[i].mean ) / np.sqrt( self.D[i].variance )
tp22 = -(np.array(self.D[j].getiCDF(self.std.getCDF(points=p2))) - self.D[j].mean)/np.sqrt( self.D[j].variance )
rho_ij = self.R[i,j]
bivariateNormalPDF = (1.0 / (2.0 * np.pi * np.sqrt(1.0-rho_ij**2)) * np.exp(-1.0/(2.0*(1.0 - rho_ij**2)) * (p1**2 - 2.0 * rho_ij * p1 * p2 + p2**2 )))
coefficientsIntegral = np.flipud(tp11*tp22 * w)
def check_difference(rho_ij):
bivariateNormalPDF = (1.0 / (2.0 * np.pi * np.sqrt(1.0-rho_ij**2)) * np.exp(-1.0/(2.0*(1.0 - rho_ij**2)) * (p1**2 - 2.0 * rho_ij * p1 * p2 + p2**2 )))
diff = np.dot(coefficientsIntegral, bivariateNormalPDF)
return diff - self.R[i,j]
rho = optimize.newton(check_difference, self.R[i,j])
R0[i,j] = rho
R0[j,i] = R0[i,j]
self.A = np.linalg.cholesky(R0)
print 'The Cholesky decomposition of fictive matrix R0 is:'
print self.A
print 'The fictive matrix is:'
print R0
def __init__(self, name='box2d'):
self.xlow = Parameter(name, 'xlow', 0)
self.xhi = Parameter(name, 'xhi', 0)
self.ylow = Parameter(name, 'ylow', 0)
self.yhi = Parameter(name, 'yhi', 0)
self.ampl = Parameter(name, 'ampl', 1)
ArithmeticModel.__init__(
self, name, (self.xlow, self.xhi, self.ylow, self.yhi, self.ampl))
self.cache = 0
def __init_default_params(self):
self.add_param(Parameter('spark.sql.shuffle.partitions', IntRangeDomain(10, 2000, 50)))\
.add_param(Parameter('spark.executor.memory',
IntRangeDomain(self._get_min_executor_mem(), # min executor memory
self._get_max_executor_mem(), # max executor memory
512)))\
.add_param(Parameter('spark.driver.memory',
IntRangeDomain(256, self._get_max_driver_memory(), 256))) \
.add_param(Parameter('spark.executor.cores', IntRangeDomain(2, self.num_cores, 1)))
def __init__(self, scene):
self.batch = pyglet.graphics.Batch()
self.translate = Parameter(default=Vector3(0,0,0))
self.rotate= Parameter(default=Vector3(0,0,0))
self.scale= Parameter(default=Vector3(1,1,1))
self.shader = Shader(self.vertex_shader, self.fragment_shader)
scene.objects.append( self )
def __init__(self, name="normgauss2d"):
self.fwhm = Parameter(name, "fwhm", 10, tinyval, hard_min=tinyval)
self.xpos = Parameter(name, "xpos", 0)
self.ypos = Parameter(name, "ypos", 0)
self.ellip = Parameter(name, "ellip", 0, 0, 0.999, 0, 0.9999, frozen=True)
self.theta = Parameter(
name, "theta", 0, -2 * numpy.pi, 2 * numpy.pi, -2 * numpy.pi, 4 * numpy.pi, "radians", frozen=True
)
self.ampl = Parameter(name, "ampl", 1)
ArithmeticModel.__init__(self, name, (self.fwhm, self.xpos, self.ypos, self.ellip, self.theta, self.ampl))
self.cache = 0
class NormGauss2D(ArithmeticModel):
def __init__(self, name='normgauss2d'):
self.fwhm = Parameter(name, 'fwhm', 10, tinyval, hard_min=tinyval)
self.xpos = Parameter(name, 'xpos', 0)
self.ypos = Parameter(name, 'ypos', 0)
self.ellip = Parameter(name,
'ellip',
0,
0,
0.999,
0,
0.9999,
frozen=True)
self.theta = Parameter(name,
'theta',
0,
-2 * numpy.pi,
2 * numpy.pi,
-2 * numpy.pi,
4 * numpy.pi,
'radians',
frozen=True)
self.ampl = Parameter(name, 'ampl', 1)
ArithmeticModel.__init__(self, name,
(self.fwhm, self.xpos, self.ypos, self.ellip,
self.theta, self.ampl))
self.cache = 0
def get_center(self):
return (self.xpos.val, self.ypos.val)
def set_center(self, xpos, ypos, *args, **kwargs):
self.xpos.set(xpos)
self.ypos.set(ypos)
def guess(self, dep, *args, **kwargs):
xpos, ypos = guess_position(dep, *args)
ampl = guess_amplitude2d(dep, *args)
param_apply_limits(xpos, self.xpos, **kwargs)
param_apply_limits(ypos, self.ypos, **kwargs)
# Apply normalization factor to guessed amplitude
norm = (numpy.pi /
_gfactor) * self.fwhm.val * self.fwhm.val * numpy.sqrt(
1.0 - (self.ellip.val * self.ellip.val))
for key in ampl.keys():
if ampl[key] is not None:
ampl[key] *= norm
param_apply_limits(ampl, self.ampl, **kwargs)
def calc(self, *args, **kwargs):
kwargs['integrate'] = bool_cast(self.integrate)
return _modelfcts.ngauss2d(*args, **kwargs)
def run(agent):
Machine.reset()
Job.reset()
pa = Parameter()
pa.agent = agent
env = Environment(pa)
mac_gen = MacGenerator(pa)
job_gen = JobGenerator(pa)
for i in mac_gen.mac_sequence:
env.add_machine(i)
batch_id = 0
job_idx = 0
current_time = 0
while True:
env.step()
env.time_log()
# while ( env.job_count < pa.job_queue_num and
while (job_gen.job_sequence[batch_id][job_idx] is not None
and job_gen.job_sequence[batch_id][job_idx].submission_time <=
current_time):
if (job_gen.job_sequence[batch_id][job_idx].submission_time ==
current_time): # add job to environment
env.add_job(job_gen.job_sequence[batch_id][job_idx])
job_idx += 1
if agent == "ecs":
ecs_agent.schedule(env)
elif agent == "k8s":
k8s_agent.schedule(env)
elif agent == "pack":
pack_agent.schedule(env)
elif agent == "ecs_dp":
ecs_dp_agent.schedule(env)
elif agent == "ecs_ml":
ecs_ml_agent.schedule(env)
elif agent == "swarm":
swarm_agent.schedule(env)
if job_gen.job_sequence[batch_id][job_idx] is None:
if env.status() == "Idle": # finish all jobs
break
current_time += 1
env.job_log()
env.finish()
def uav_swarm_step(time_counter: int, p: parameter.Parameter,
uav_swarm: uav.Uav_Swarm,
target_swarm: target.Target_Swarm):
# 求下一步策略
p.S_a_p = p.S_a
p.S_a = cal_S_a(p)
p.S_r_p = p.S_r
p.S_r = cal_S_r(p)
search_way_local(p, uav_swarm, target_swarm)
for i in range(p.nu):
search_way_global(time_counter, p, uav_swarm[i], uav_swarm,
target_swarm)
optimal.interation(time_counter, uav_swarm, target_swarm, p)
def __init__(self, name='normgauss2d'):
self.fwhm = Parameter(name, 'fwhm', 10, tinyval, hard_min=tinyval)
self.xpos = Parameter(name, 'xpos', 0)
self.ypos = Parameter(name, 'ypos', 0)
self.ellip = Parameter(name, 'ellip', 0, 0, 0.999, 0, 0.9999,
frozen=True)
self.theta = Parameter(name, 'theta', 0, 0, 2*numpy.pi, -2*numpy.pi,
4*numpy.pi, 'radians', frozen=True)
self.ampl = Parameter(name, 'ampl', 1)
ArithmeticModel.__init__(self, name,
(self.fwhm, self.xpos, self.ypos, self.ellip,
self.theta, self.ampl))
self.cache = 0
def _get_parameter(parameter_name, fixed_attributes,
uri_parameters) -> Parameter:
if fixed_attributes is not None and parameter_name in fixed_attributes:
return Parameter(parameter_name, fixed_attributes[parameter_name],
None, None, True)
elif any(parameter["Name"] == parameter_name
for parameter in uri_parameters):
for parameter in uri_parameters:
if parameter["Name"] == parameter_name:
return Parameter(parameter_name, parameter["ExampleValue"],
parameter["Type"], parameter["Format"],
False)
else:
return Parameter(parameter_name, 'attribute', None, None, False)
def __init__(self, name='normgauss2d'):
self.fwhm = Parameter(name, 'fwhm', 10, tinyval, hard_min=tinyval)
self.xpos = Parameter(name, 'xpos', 0)
self.ypos = Parameter(name, 'ypos', 0)
self.ellip = Parameter(name,
'ellip',
0,
0,
0.999,
0,
0.9999,
frozen=True)
self.theta = Parameter(name,
'theta',
0,
-2 * numpy.pi,
2 * numpy.pi,
-2 * numpy.pi,
4 * numpy.pi,
'radians',
frozen=True)
self.ampl = Parameter(name, 'ampl', 1)
ArithmeticModel.__init__(self, name,
(self.fwhm, self.xpos, self.ypos, self.ellip,
self.theta, self.ampl))
self.cache = 0
def __init__(self, name='polynom1d'):
pars = []
for i in xrange(9):
pars.append(Parameter(name, 'c%d' % i, 0, frozen=True))
pars[0].val = 1
pars[0].frozen = False
for p in pars:
setattr(self, p.name, p)
self.offset = Parameter(name, 'offset', 0, frozen=True)
pars.append(self.offset)
ArithmeticModel.__init__(self, name, pars)
def read_config(self):
self.gscale_options = tuple(self.cfg["gscale"]["options"])
for p in self.cfg["resp_params"].keys():
assert p in list(ParamEnum.__members__)
screen_name = self.cfg["resp_params"][p]["screen_name"]
min_ = self.cfg["resp_params"][p]["min"]
max_ = self.cfg["resp_params"][p]["max"]
fmt = self.cfg["resp_params"][p]["format"]
step = self.cfg["resp_params"][p]["step"]
default = self.cfg["resp_params"][p]["default"]
units = self.cfg["resp_params"][p]["units"]
measured = self.cfg["resp_params"][p]["measured"]
options = None
try:
options = tuple(self.cfg["resp_params"][p]["options"])
print(options)
except KeyError:
pass
min_ = tuple(float(v) for v in min_.split(",")) if (isinstance(min_, str) and "," in min_) else float(min_)
max_ = tuple(float(v) for v in max_.split(",")) if (isinstance(max_, str) and "," in max_) else float(max_)
step = tuple(float(v) for v in step.split(",")) if (isinstance(step, str) and "," in step) else float(step)
default = tuple(float(v) for v in default.split(",")) if (
isinstance(default, str) and "," in default) else float(default)
fmt = tuple(f for f in fmt.split(",")) if "," in fmt else fmt
self.params[p] = Parameter(name=p, screen_name=screen_name, units=units, min_=min_, max_=max_, step=step,
fmt=fmt, default=default, measured=measured)
if options is not None:
self.params[p].options = options
self.params[p].value_as_index = True
if ParamEnum.ier.name in self.params.keys():
options = self.params[ParamEnum.ier.name].options
self.params[ParamEnum.ier.name].options = tuple((f"{v.split(':')[0].rjust(3)}:{v.split(':')[1].rjust(3)}" for v in options))
print(self.params[ParamEnum.ier.name].options)
for m in self.cfg["modes"].keys():
assert m in list(OpModEnum.__members__)
self.modes[m] = OpMode(name=m)
for p in self.cfg['modes'][m].keys():
if self.cfg['modes'][m][p]['adjustable']:
self.modes[m].adjustable_params.append(p)
self.params['mode'] = Parameter(name='mode')
self.params['mode'].value = OpModEnum.vcv.value #VCV by default upon starting
self.update_adjustable()
self.params[ParamEnum.gscale.name] = Parameter(name=ParamEnum.gscale.name)
def interation(time_counter: int, uav_swarm: uav.Uav_Swarm, target_swarm: target.Target_Swarm, p: parameter.Parameter):
"""
:param uav_swarm:
:param target_swarm:
:param p:
:return:
"""
p.inter_counter = 0
p.last_J_group = -np.Inf
while inter_restric(time_counter, uav_swarm, p):
for i in range(p.nu):
uav_swarm[i].all_way_local = scheduling.get_all_way_local(p, uav_swarm[i])
scheduling.interation_global(time_counter, p, uav_swarm[i], uav_swarm, target_swarm)
p.inter_counter += 1
print("time_counter", time_counter, "interation end")
def __init__(self, in_dim, out_dim, with_bias=True):
super(Linear, self).__init__()
self.in_dim = in_dim
self.out_dim = out_dim
w = FloatTensor(out_dim, in_dim)
w = xavier_normal(w)
w_grad = FloatTensor(out_dim, in_dim).zero_()
self.w = Parameter(w, w_grad)
self.bias = None
if with_bias:
bias = FloatTensor(out_dim).zero_()
bias_grad = FloatTensor(out_dim).zero_()
self.bias = Parameter(bias, bias_grad)
def __init__(self, name, parts):
self.parts = tuple(parts)
allpars = []
for part in self.parts:
for p in part.pars:
if p in allpars:
# If we already have a reference to this parameter, store
# a hidden, linked proxy instead
pnew = Parameter(p.modelname, p.name, 0.0, hidden=True)
pnew.link = p
p = pnew
allpars.append(p)
Model.__init__(self, name, allpars)
def load_dagger_generator(args):
port = args.port
ports = args.ports
assert ports
assert port in ports
assert args.dataset_name
assert args.eval_dataset_name
port_index = ports.index(port)
eval_param = Parameter()
eval_param.exp_index = args.exp_index
eval_param.exp_name = args.exp_name
eval_param.load()
eval_param.batch_size = 1
eval_param.dataset_data_names = [args.dataset_name]
eval_param.eval_data_name = args.eval_dataset_name
eval_param.max_data_length = -1
if eval_param.split_train:
train_dataset, valid_dataset = fetch_dataset_pair(eval_param)
else:
train_dataset = fetch_dataset(eval_param)
num_data = len(train_dataset)
index_func = partial(fetch_index_from_road_option,
low_level=eval_param.use_low_level_segment)
data_list = []
for i in range(num_data):
# road_option, data_frame = train_dataset.get_trajectory_data(i)
# images = data_frame.images
# drives = data_frame.drives
# fixme: this may not work if train_dataset is a HighLevelDataset? Cuz it does not even have this method!
road_option, images, drives = train_dataset.get_trajectory_data(i)
data_list.append({
'road_option': road_option,
'action_index': index_func(road_option),
'src_transform': drives[0].state.transform,
'dst_location': drives[-1].state.transform.location,
'length': len(images)
})
def chunker_list(seq, size):
return (seq[i::size] for i in range(size))
index_data_lists = list(
chunker_list(list(enumerate(data_list)), len(ports)))
index_data_list = index_data_lists[port_index]
return DaggerGeneratorEnvironment(args, eval_param, index_data_list)
def inject(cls, cmd):
if isinstance(cmd, type):
if issubclass(cmd, Action):
return A_CMD(cmd)
if isinstance(cmd, CLI_CMD):
return cmd
elif isinstance(cmd, str):
return LIT_CMD(cmd)
elif isinstance(cmd, Message):
return MESSAGE_CMD(cmd)
elif isinstance(cmd, dict):
return ASSIGN_CMD(**cmd)
elif isinstance(cmd, Delete):
return ENVIRONMENT_DEL_CMD(*cmd.keys)
elif isinstance(cmd, GetVariable):
return ENVIRONMENT_CMD(cmd.name)
elif isinstance(cmd, GeneratorType):
return GEN_CMD(cmd)
elif isinstance(cmd, tuple):
return PAR_CMD(*cmd)
try:
cmd = Parameter.inject(cmd)
return PAR_INP(cmd)
except:
pass
raise TypeError('invalid command value: {} '
'(type: {})'.format(cmd, type(cmd)))
def __init__(self, cur_pressure: deque, cur_flow: deque, total_flow: deque,
p_max: deque, p_avg: deque, peep: deque, fio2: deque,
f_max: deque, user_set_param: deque, data_msg: deque):
QThread.__init__(self)
self.logger = logging.getLogger('gui')
try:
os.unlink(SOCKET_ADDRESS)
except OSError:
if os.path.exists(SOCKET_ADDRESS):
raise
self.dq_cp = cur_pressure
self.dq_cf = cur_flow
self.dq_tv = total_flow
self.dq_p_max = p_max
self.dq_p_avg = p_avg
self.dq_peep = peep
self.dq_fio2 = fio2
self.dq_f_max = f_max
self.buf_rx = deque(maxlen=BUF_RX_SIZE)
self.parsed_data = ""
self.socket = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
self.socket.bind(SOCKET_ADDRESS)
#self.socket = socket.socket()
#self.socket.bind(('', 5040))
self.stop = Event()
self.connection = None
self.socket.listen(1)
self.socket.setblocking(True)
self.operation_mode = OpMode.VCV
self.user_set_param: deque = user_set_param
self.data_msg: deque = data_msg
self.params = dict()
for p in PARAM_NAMES:
self.params[p] = Parameter(name=p)
def __init__(self, param: Parameter, num_words: int):
param.attention_type = 'none'
ModelIntegratedBase.__init__(self, param, num_words)
assert not self.use_attention
self.image_processor = ConvLayers(self.channels)
self.linear = torch.nn.Linear(self.image_vec_dim, self.out_linear)
def __init__(cls):
'''Method init'''
cls.accountName = os.getenv('ACCOUNT_NAME')
print('cls.accountName ',cls.accountName)
#cls.accountKey = os.getenv('ACCOUNT_KEY')
print('cls.accountKey ', cls.accountKey )
cls.config = Parameter(cls.accountName, cls.accountKey).get_parameters()
def vandermonde(eta, p):
"""
Internal function to variable_projection
Calculates the Vandermonde matrix using polynomial basis functions
:param eta: ndarray, the affine transformed projected values of inputs in active subspace
:param p: int, the maximum degree of polynomials
:return:
* **V (numpy array)**: The resulting Vandermode matrix
* **Polybasis (Poly object)**: An instance of Poly object containing the polynomial basis derived
"""
_, n = eta.shape
listing = []
for i in range(0, n):
listing.append(p)
Object = Basis('Total order', listing)
#Establish n Parameter objects
params = []
P = Parameter(order=p, lower=-1, upper=1, param_type='Uniform')
for i in range(0, n):
params.append(P)
#Use the params list to establish the Poly object
Polybasis = Poly(params, Object)
V = Polybasis.getPolynomial(eta)
V = V.T
return V, Polybasis
class NormGauss2D(ArithmeticModel):
def __init__(self, name='normgauss2d'):
self.fwhm = Parameter(name, 'fwhm', 10, tinyval, hard_min=tinyval)
self.xpos = Parameter(name, 'xpos', 0)
self.ypos = Parameter(name, 'ypos', 0)
self.ellip = Parameter(name, 'ellip', 0, 0, 0.999, 0, 0.9999,
frozen=True)
self.theta = Parameter(name, 'theta', 0, 0, 2*numpy.pi, -2*numpy.pi,
4*numpy.pi, 'radians', frozen=True)
self.ampl = Parameter(name, 'ampl', 1)
ArithmeticModel.__init__(self, name,
(self.fwhm, self.xpos, self.ypos, self.ellip,
self.theta, self.ampl))
self.cache = 0
def get_center(self):
return (self.xpos.val, self.ypos.val)
def set_center(self, xpos, ypos, *args, **kwargs):
self.xpos.set(xpos)
self.ypos.set(ypos)
def guess(self, dep, *args, **kwargs):
xpos, ypos = guess_position(dep, *args)
ampl = guess_amplitude2d(dep, *args)
param_apply_limits(xpos, self.xpos, **kwargs)
param_apply_limits(ypos, self.ypos, **kwargs)
# Apply normalization factor to guessed amplitude
norm = (numpy.pi/_gfactor)*self.fwhm.val*self.fwhm.val*numpy.sqrt(1.0 - (self.ellip.val*self.ellip.val))
for key in ampl.keys():
if ampl[key] is not None:
ampl[key] *= norm
param_apply_limits(ampl, self.ampl, **kwargs)
def calc(self, *args, **kwargs):
kwargs['integrate']=bool_cast(self.integrate)
return _modelfcts.ngauss2d(*args, **kwargs)
class Delta1D(ArithmeticModel):
def __init__(self, name="delta1d"):
self.pos = Parameter(name, "pos", 0)
self.ampl = Parameter(name, "ampl", 1)
ArithmeticModel.__init__(self, name, (self.pos, self.ampl))
def get_center(self):
return (self.pos.val,)
def set_center(self, pos, *args, **kwargs):
self.pos.set(pos)
def guess(self, dep, *args, **kwargs):
norm = guess_amplitude(dep, *args)
pos = get_position(dep, *args)
param_apply_limits(norm, self.ampl, **kwargs)
param_apply_limits(pos, self.pos, **kwargs)
@modelCacher1d
def calc(self, *args, **kwargs):
kwargs["integrate"] = bool_cast(self.integrate)
return _modelfcts.delta1d(*args, **kwargs)
def __init__(self, name, parts):
self.parts = tuple(parts)
allpars = []
for part in self.parts:
for p in part.pars:
if p in allpars:
# If we already have a reference to this parameter, store
# a hidden, linked proxy instead
pnew = Parameter(p.modelname, p.name, 0.0, hidden=True)
pnew.link = p
p = pnew
allpars.append(p)
Model.__init__(self, name, allpars)
for part in self.parts:
try:
self.is_discrete = self.is_discrete or part.is_discrete
except:
warning("Could not determine whether the model is discrete.\n"+
"This probably means that you have restored a session saved with a previous version of Sherpa.\n"+
"Falling back to assuming that the model is continuous.\n")
self.is_discrete = False
def parse(tkns):
""" Parse a verilog module
module :=
'module' identifier [module_param_port_list] [list_of_ports]
';' {module_item} 'endmodule'
| 'module' identifier [module_param_port_list]
[list_of_port_declarations] ';' {non_port_module_item}
'endmodule'
"""
tkns.expect(Tokens.KW_MODULE)
# get module name
name = tkns.current().text
tkns.expect(Tokens.IDENTIFIER)
# get parameter port list, if it exists
params = []
if tkns.check(Tokens.HASH):
params = Parameter.parse_module_param_port_list(tkns)
# get i/o port list, if it exists
io = []
if tkns.check(Tokens.OPEN_PAREN):
if tkns.peek(Tokens.CLOSE_PAREN):
tkns.next()
tkns.next()
elif tkns.peek(Tokens.KW_INOUT) or tkns.peek(Tokens.KW_INPUT) or tkns.peek(Tokens.KW_OUTPUT):
io = Port.parse_list_of_port_declarations(tkns)
else:
io = Port.parse_list_of_ports(tkns)
# get module contents
# TODO: look at contents for more parameters, do other parsing
contents = []
while not tkns.accept(Tokens.KW_ENDMODULE):
contents.append(tkns.next())
return Module(name, params, io, contents)
def __init__(self, name="normgauss1d"):
self.fwhm = Parameter(name, "fwhm", 10, tinyval, hard_min=tinyval)
self.pos = Parameter(name, "pos", 0)
self.ampl = Parameter(name, "ampl", 1)
ArithmeticModel.__init__(self, name, (self.fwhm, self.pos, self.ampl))
def __init__(self, *keys):
super().__init__()
self.keys = [Parameter.inject(k).name for k in keys]
def __init__(self, name='delta2d'):
self.xpos = Parameter(name, 'xpos', 0)
self.ypos = Parameter(name, 'ypos', 0)
self.ampl = Parameter(name, 'ampl', 1)
ArithmeticModel.__init__(self, name, (self.xpos, self.ypos, self.ampl))
self.cache = 0
def __init__(self, name='normgauss1d'):
self.fwhm = Parameter(name, 'fwhm', 10, tinyval, hard_min=tinyval)
self.pos = Parameter(name, 'pos', 0)
self.ampl = Parameter(name, 'ampl', 1)
ArithmeticModel.__init__(self, name, (self.fwhm, self.pos, self.ampl))
class TripDetection:
def __init__(self):
# Parameters
self.charging_current_limit = 5
self.gyro_limit = 0.15
self.min_number_of_values_over_limit = 25
self.array_length = 90
self.min_trip_length = 300 #s
self.trip_started = False
self.max_time_between_movement = 280 #s
self.max_avg_speed = 30 #km/h
# Declaring variables
self.charging_currents = Parameter(self.array_length, self.charging_current_limit, self.min_number_of_values_over_limit)
self.gyroscopes = Parameter(self.array_length, self.gyro_limit, self.min_number_of_values_over_limit)
self.start_times = []
self.end_times = []
# Declaring temporary variable for trips
self.tmp_start_time = 0
# Defining positions of variables in DB
self.time_db = 0
# latGPS_db = 3
# lenGPS_db = 4
self.charging_current_db = 26
self.gyro_x_db = 13
self.gyro_y_db = 14
self.gyro_z_db = 15
def detect_trips(self, dbc, imei, start_date, end_date):
# Obtaining all the data from the DB
query = "select * from imei{0} where stamp >= \"{1}\" and stamp <= \"{2}\" order by stamp".format(imei, start_date, end_date)
for record in dbc.SQLSelectGenerator(query):
# Setting the data required for the algorithm
if record[self.charging_current_db] is not None:
charging_current = Data(record[self.time_db], record[self.charging_current_db])
self.charging_currents.add_data(charging_current)
gyro_x = record[self.gyro_x_db]
gyro_y = record[self.gyro_y_db]
gyro_z = record[self.gyro_z_db]
if gyro_x is not None and gyro_y is not None and gyro_z is not None:
gyro_module = calculate_module([gyro_x, gyro_y, gyro_z])
gyro = Data(record[self.time_db], gyro_module)
self.gyroscopes.add_data(gyro)
# If trip has not started we check current and
if not self.trip_started:
if not self.charging_currents.max_limit_reached() and self.gyroscopes.max_limit_reached():
self.start_trip(self.gyroscopes.get_min_time_over_limit())
# Case when trip has started
else:
if self.charging_currents.max_limit_reached() or not self.gyroscopes.max_limit_reached():
self.end_trip(record[self.time_db])
self.validate_all_trips(dbc,imei)
return self.start_times, self.end_times
def validate_all_trips(self, dbc, imei):
beta = 0.06
for i, j in zip(self.start_times, self.end_times):
time = (j - i).total_seconds()/3600
_, _, _, _,distance, _, _ = trajectory.get_trajectory_information(dbc, imei, beta, [i], [j])
if distance:
speed = distance[0] / time
if speed > self.max_avg_speed:
self.start_times.remove(i)
self.end_times.remove(j)
def start_trip(self, start_time):
self.trip_started = True
self.tmp_start_time = start_time
def end_trip(self, end_time):
self.trip_started = False
if self.validate_trip(end_time):
# If there is at least one value saved, then check that trips do not overlap
# If they overlap then join the trips together
if len(self.end_times) > 0:
if (self.tmp_start_time - self.end_times[-1]).total_seconds() > self.max_time_between_movement:
self.start_times.append(self.tmp_start_time)
self.end_times.append(end_time)
else:
self.end_times[-1] = end_time
else:
self.start_times.append(self.tmp_start_time)
self.end_times.append(end_time)
self.tmp_start_time = 0
def validate_trip(self, end_time):
return (end_time - self.tmp_start_time).total_seconds() > self.min_trip_length
def __init__(self, name='delta1d'):
self.pos = Parameter(name, 'pos', 0)
self.ampl = Parameter(name, 'ampl', 1)
ArithmeticModel.__init__(self, name, (self.pos, self.ampl))
def __init__(self, name="delta1d"):
self.pos = Parameter(name, "pos", 0)
self.ampl = Parameter(name, "ampl", 1)
ArithmeticModel.__init__(self, name, (self.pos, self.ampl))
def __init__(self):
super(SimpleLinearRegression, self).__init__()
self.intercept = Parameter(name="intercept", value=None)
self.slope = Parameter(name="slope", value=None)
self.nparams = 2
'''
@author: Zxh
'''
from parameter import Parameter
import json
p=Parameter()
def get_json_value(obj,Parameter):
keys=obj.keys()
for key in keys:
value=obj.get(key)
setattr(Parameter,"_Parameter__"+key, value)
print key,getattr(Parameter,"_Parameter__"+key)
return Parameter
# data=p.build_to_json()
# print data
data='''{ "update_time":"",
"plant_parameter_setting":{
"time1":"1",
"temperature1":"2",
"time2":"3",
"temperature2":"4",
"time3":"",
"temperature3":"5",
"time4":"",
"temperature4":"6"
},
"co2_parameter_setting":{
Created on 2016/06/20
@author: Zxh
'''
from autorun import auto_run_main
from currenttime import get_time
from indoor import Indoor
from outdoor import Outdoor
from parameter import Parameter
from arm_project.control import Control
node0 = Indoor('node0')
o = Outdoor()
c = Control()
p = Parameter()
p.set_expect_humidity("80")
p.set_humidity_influence_range_of_air_temperature("5")
p.set_high_humidity_influence_on_air_temperature("3")
p.set_low_humidity_influence_on_air_temperature("4")
p.set_light_influence_on_air_temperature_slope("0.7")
p.set_roof_vent_open_time("10")
p.set_shade_screen_in_time("5")
p.set_shade_screen_out_time("7")
p.set_side_vent_time("9")
start_time = get_time()
auto_run_main(node0, o, c, p)
class SimpleLinearRegression(Hypothesis):
"""
Constructor creates two Parameter objects: intercept and slope
nparams is set to 2
"""
def __init__(self):
super(SimpleLinearRegression, self).__init__()
self.intercept = Parameter(name="intercept", value=None)
self.slope = Parameter(name="slope", value=None)
self.nparams = 2
def parameters_initialized(self):
"""Checks to see whether parameters have been initialized.
:return True if parameters have been initialized, false otherwise
"""
return self.intercept.is_initialized() and self.slope.is_initialized()
def initialize_parameters(self, param_dict):
"""
initializes parameter values
:param param_values A dict of parameter_name: parameter_value
"""
self.intercept.value = param_dict["intercept"]
self.slope.value = param_dict["slope"]
def update_parameters(self, param_array):
"""
Updates parameter values
:param_array A list of parameter values including intercept and slope
of dimension nparam x 1
"""
if not self.parameters_initialized():
raise ParameterValuesNotInitialized(
"Parameter values have not yet been initialized")
if param_array.shape[0] != self.nparams:
raise IncorrectMatrixDimensions(
"Parameter array needs to be %d by 1" % self.nparams)
self.intercept.value = param_array[0][0]
self.slope.value = param_array[1][0]
def get_parameters(self):
"""
Reshapes parameters into form suitable for later computation.
First horizontally stacks (hstack) intercept and slope
Next reshapes into an array of dimension number of parameters
by 1.
:returns A numpy array of dimension number of nparams by 1
containing the values of the parameters.
"""
if not self.parameters_initialized():
raise ParameterValuesNotInitialized(
"Parameter values have not yet been initialized")
parms_tmp = hstack((self.intercept.value, self.slope.value))
parms_tmp = parms_tmp.reshape(self.nparams, 1)
return parms_tmp
def feature_setup(self, features):
"""
Reshapes features into suitable form for later computation.
Adds a vector of 1s indicating the intercept.
:param features A vector of x values of dimension 1 x nobs
:returns A matrix of dimension nobs x 2 with the first column
consisting of 1s and the second column consisting of x values.
"""
if features.shape[1] != 1:
raise IncorrectMatrixDimensions(
"Number of rows is equal to %d but should be equal to 1" % features.shape[0])
return append(ones(features.shape[0]).reshape(features.shape[0], 1), features, 1)
def hypothesis_function(self, features):
"""
Computes the hypothesis function.
theta*features
:param features A vector of feature values of dimension 1 x nobs
:returns A matrix of dimension nobs x 1 with the results of the
hypothesis computation.
"""
features_ = self.feature_setup(features)
return features_.dot(self.get_parameters())
def save_db_parameter(Parameter):
with app.app_context():
db=get_db()
db.execute('insert into parameter(update_time,time1,temperature1,time2,temperature2,time3,temperature3,time4,temperature4, co2_upper_limit,co2_lower_limit, cooling_start_temperature,cooling_stop_temperature,\
expect_humidity,humidity_influence_range_of_air_temperature,low_humidity_influence_on_air_temperature,high_humidity_influence_on_air_temperature,expect_light,light_influence_on_air_temperature_slope,high_light_influence_on_temperature,low_light_influence_on_temperature,frost_temperature,\
indoor_temperature_lower_limit,roof_vent_wind_speed_upper_limit,roof_vent_rain_upper_limit, heating_start_lowest_temperature,heating_stop_highest_temperature, month_to_open_thermal_screen,month_to_close_thermal_screen,time_to_open_thermal_screen,time_to_close_thermal_screen, temperature_to_open_side,\
wait_time_to_open_side,rain_upper_limit_to_close, upper_limit_light_to_open_shade_screen_out,upper_limit_light_to_open_shade_screen_in,soil_humidity_to_start_irrigation,soil_humidity_to_stop_irrigation,temperature_to_open_fogging,temperature_to_open_cooling_pad,\
month_to_open_lighting,month_to_close_lighting,period1_start_lighting,period1_stop_lighting,period2_start_lighting,period2_stop_lighting,radiation1_to_open_lighting,radiation2_to_open_lighting,roof_vent_open_time,side_vent_open_time,shade_screen_out_open_time,\
shade_screen_in_open_time,thermal_screen_open_time ) values(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)',\
[get_current_time(),Parameter.get_time_1(),Parameter.get_temperature_1(),Parameter.get_time_2(),Parameter.get_temperature_2(),Parameter.get_time_3(),Parameter.get_temperature_3(),Parameter.get_time_4(),Parameter.get_temperature_4(),Parameter.get_co_2_upper_limit(),Parameter.get_co_2_lower_limit(),
Parameter.get_cooling_start_temperature(),Parameter.get_cooling_stop_temperature(),
Parameter.get_expect_humidity(),Parameter.get_humidity_influence_range_of_air_temperature(),Parameter.get_low_humidity_influence_on_air_temperature(),Parameter.get_high_humidity_influence_on_air_temperature(),Parameter.get_expect_light(),Parameter.get_light_influence_on_air_temperature_slope(),
Parameter.get_high_light_influence_on_temperature(),Parameter.get_low_light_influence_on_temperature(),Parameter.get_frost_temperature(),Parameter.get_indoor_temperature_lower_limit(),Parameter.get_roof_vent_wind_speed_upper_limit(),Parameter.get_roof_vent_rain_upper_limit(),
Parameter.get_heating_start_lowest_temperature(),Parameter.get_heating_stop_highest_temperature(),Parameter.get_month_to_open_thermal_screen(),Parameter.get_month_to_close_thermal_screen(),Parameter.get_time_to_open_thermal_screen(),Parameter.get_time_to_close_thermal_screen(),
Parameter.get_temperature_to_open_side(),
Parameter.get_wait_time_to_open_side(),
Parameter.get_rani_upper_limit_to_close(),
Parameter.get_upper_limit_light_to_open_shade_screen_out(),
Parameter.get_upper_limit_light_to_open_shade_screen_in(),
Parameter.get_soil_humidity_to_start_irrigation(),
Parameter.get_soil_humidity_to_stop_irrigation(),
Parameter.get_temperature_to_open_fogging(),
Parameter.get_temperature_to_open_cooling_pad(),
Parameter.get_month_to_open_lighting(),
Parameter.get_month_to_close_lighting(),
Parameter.get_period_1_start_lighting(),
Parameter.get_period_1_stop_lighting(),
Parameter.get_period_2_start_lighting(),
Parameter.get_period_2_stop_lighting(),
Parameter.get_radiation_1_to_open_lighting(),
Parameter.get_radiation_2_to_open_lighting(),
Parameter.get_roof_vent_open_time(),
Parameter.get_side_vent_time(),
Parameter.get_shade_screen_out_time(),
Parameter.get_shade_screen_in_time(),
Parameter.get_thermal_screen_open_time()
])
db.commit()
print 'parameter save success'
table = [
['BRD', 'MLK'],
['.....'],
['.....'],
['.....'],
['.....'],
['.....'],
['.....']
]
title('CGE')
parameter = Parameter(
index=['BRD', 'MLK', 'CAP', 'LAB', 'HH', 'GOV'],
industries=['BRD', 'MLK'],
factors=['CAP', 'LAB'],
consumers=['HH'], #'GOV'
)
parameter.sam['HH']['BRD'] = 15
parameter.sam['HH']['MLK'] = 35
parameter.sam['BRD']['CAP'] = 5
parameter.sam['MLK']['CAP'] = 20
parameter.sam['BRD']['LAB'] = 10
parameter.sam['MLK']['LAB'] = 15
parameter.sam['CAP']['HH'] = 25
parameter.sam['LAB']['HH'] = 25
heading('unbalanced')
print(parameter.sam)
parameter.sam.balance()
def __init__(self, name="delta2d"):
self.xpos = Parameter(name, "xpos", 0)
self.ypos = Parameter(name, "ypos", 0)
self.ampl = Parameter(name, "ampl", 1)
ArithmeticModel.__init__(self, name, (self.xpos, self.ypos, self.ampl))
self.cache = 0
for x in open("contain-angle-quotes.csv")]
def title_index(lst, title):
try:
return lst.index(title)
except Exception:
return -1
def generate_csv_list(clm1, index, title_lst):
line_count = max(len(clm1), len(title_lst), 1)
column1 = clm1 + ['']*(line_count-1)
column2 = [index+1] + ['']*(line_count-1)
column3 = title_lst + ['']*(line_count-len(title_lst))
return zip(column1, column2, column3)
Parameter.setEnv('kevin')
simpleRes = LncSimpleSearchResultTestCase()
csv_output_filename = "angle-quotes-results.csv"
csv_output_file = open(csv_output_filename, "a")
for legal in legislation:
for tag in legal[2:]:
cur_titles = simpleRes.get_results_list(tag)
index = title_index(cur_titles, legal[1])
csv_line = generate_csv_list([tag, legal[1], legal[0]], index, cur_titles)
for cl in csv_line:
line = ("%s\t%s\t%s\n" % cl)
csv_output_file.write(line.encode('utf-8'))
def get_db_parameter():
query='select * from parameter where id=(select max(id) from parameter)'
row=query_db(query)
a=1
para=Parameter()
para.set_time_1(row[a])
para.set_temperature_1(row[a+1])
para.set_time_2(row[a+2])
para.set_temperature_2(row[a+3])
para.set_time_3(row[a+4])
para.set_temperature_3(row[a+5])
para.set_time_4(row[a+6])
para.set_temperature_4(row[a+7])
para.set_co_2_upper_limit(row[a+8])
para.set_co_2_lower_limit(row[a+9])
para.set_cooling_start_temperature(row[a+10])
para.set_cooling_stop_temperature(row[a+11])
para.set_expect_humidity(row[a+12])
para.set_humidity_influence_range_of_air_temperature(row[a+13])
para.set_low_humidity_influence_on_air_temperature(row[a+14])
para.set_high_humidity_influence_on_air_temperature(row[a+15])
para.set_expect_light(row[a+16])
para.set_light_influence_on_air_temperature_slope(row[a+17])
para.set_high_light_influence_on_temperature(row[a+18])
para.set_low_light_influence_on_temperature(row[a+19])
para.set_frost_temperature(row[a+20])
para.set_indoor_temperature_lower_limit(row[a+21])
para.set_roof_vent_wind_speed_upper_limit(row[a+22])
para.set_roof_vent_rain_upper_limit(row[a+23])
para.set_heating_start_lowest_temperature(row[a+24])
para.set_heating_stop_highest_temperature(row[a+25])
para.set_month_to_open_thermal_screen(row[a+26])
para.set_month_to_close_thermal_screen(row[a+27])
para.set_time_to_open_thermal_screen(row[a+28])
para.set_time_to_close_thermal_screen(row[a+29])
para.set_temperature_to_open_side(row[a+30])
para.set_wait_time_to_open_side(row[a+31])
para.set_rani_upper_limit_to_close(row[a+32])
para.set_upper_limit_light_to_open_shade_screen_out(row[a+33])
para.set_upper_limit_light_to_open_shade_screen_in(row[a+34])
para.set_soil_humidity_to_start_irrigation(row[a+35])
para.set_soil_humidity_to_stop_irrigation(row[a+36])
para.set_temperature_to_open_fogging(row[a+37])
para.set_temperature_to_open_cooling_pad(row[a+38])
para.set_month_to_open_lighting(row[a+39])
para.set_month_to_close_lighting(row[a+40])
para.set_period_1_start_lighting(row[a+41])
para.set_period_1_stop_lighting(row[a+42])
para.set_period_2_start_lighting(row[a+43])
para.set_period_2_stop_lighting(row[a+44])
para.set_radiation_1_to_open_lighting(row[a+45])
para.set_radiation_2_to_open_lighting(row[a+46])
para.set_roof_vent_open_time(row[a+47])
para.set_side_vent_time(row[a+48])
para.set_shade_screen_out_time(row[a+49])
para.set_shade_screen_in_time(row[a+50])
para.set_thermal_screen_open_time(row[a+51])
return para.build_to_json()
print 'get parameter success'
