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'