예제 #1
0
파일: detrend.py 프로젝트: wilseypa/eis
def testDetrend():
    import pylab
    #something random to test with
    data = [[ (sin(random.gauss(0,1)*.01+float(i)/(n/51.0)))*(cos(random.gauss(0,1)*.01+float(i)/(n/31.0))) for i in range(n)] ]
    plot(data,'--',label="Original Data")
    detrend(data,channels = 1)
    plot(data,label="Detrended Data")
예제 #2
0
def genDistribution(xMean, xSD, yMean, ySD, n, namePrefix):
    samples = []
    for s in range(n):
        x = random.gauss(xMean, xSD)
        y = random.gauss(yMean, ySD)
        samples.append(Example(namePrefix+str(s), [x, y]))
    return samples
예제 #3
0
파일: A1.py 프로젝트: borundev/KrauthCourse
def levy_harmonic_path(k):
    x = [random.gauss(0.0, 1.0 / math.sqrt(2.0 * math.tanh(k * beta / 2.0)))]
    if k == 2:
        Ups1 = 2.0 / math.tanh(beta)
        Ups2 = 2.0 * x[0] / math.sinh(beta)
        x.append(random.gauss(Ups2 / Ups1, 1.0 / math.sqrt(Ups1)))
    return x[:]
예제 #4
0
    def execute(self, userdata):
        self.world.inc_time()
        if self.world.time_step >= self.experiment.max_transitions:
            return "timeout"
       
        newx = random.gauss(self.mu_x, self.si_x)
        newy = random.gauss(self.mu_y, self.si_y)
        newth = random.gauss(self.mu_th, self.si_th)
        
        #denormalizing the network output
#        lx = self.world.min_x
#        rx = self.world.max_x
#        ly = self.world.min_y
#        ry = self.world.max_y
        
        lx = 0
        rx = 5
        ly = -2.5
        ry = 2.5
        
        lt = -math.pi
        rt = math.pi
        
        newpos = (lx + newx *(rx-lx),
                  ly + newy *(ry-ly),  
                  lt + newth *(rt-lt))
               
        if self.world.move_robot(newpos):
            return "success"
        else:
            return "failure"
예제 #5
0
    def move(self, motion): # Do not change the name of this function

        (alpha, distance) = motion  # alpha = lenkwinkel
        alpha += random.gauss(0., self.steering_noise)
        distance += random.gauss(0., self.distance_noise)

        # see https://www.udacity.com/course/viewer#!/c-cs373/l-48726342/m-48693619
        b = distance/self.length * tan(alpha)  # turning angle

        if b < 0.001:
            x = self.x + distance * cos(self.orientation)
            y = self.y + distance * sin(self.orientation)
            o = self.orientation
        else:
            radius = distance / b

            cx = self.x - sin(self.orientation) * radius
            cy = self.y + cos(self.orientation) * radius

            x = cx + sin(self.orientation + b) * radius
            y = cy - cos(self.orientation + b) * radius

            o = (self.orientation + b) % (2*pi)

        result = robot()
        result.set(x, y, o)
        result.set_noise(self.bearing_noise, self.steering_noise, self.distance_noise)
        return result # make sure your move function returns an instance
예제 #6
0
    def localize(self, robot_pose, laser_scan):
        sigma_coord, sigma_theta = RobotParams.sigmaCoord, RobotParams.sigmaTheta
        laser_scan_obstacles = filter(lambda rec: rec[2] == Map.OBSTACLE, laser_scan.data)
        
        estimated_pose = robot_pose.copy().translate_by_dist(0) # laser offset
        estimated_dist = self.__scanDistance(estimated_pose, laser_scan_obstacles)
        init_dist = estimated_dist
    
        bad_samples_cnt = total_samples_cnt = 0
        while bad_samples_cnt < RobotParams.badMCIterations and total_samples_cnt < RobotParams.maxMCIterations:
            total_samples_cnt += 1
            
            sample = estimated_pose.copy() \
                                   .translate(random.gauss(0, sigma_coord), random.gauss(0, sigma_coord)) \
                                   .rotate(random.gauss(0, sigma_theta))
            sample_dist = self.__scanDistance(sample, laser_scan_obstacles)
            
            if estimated_dist <= sample_dist:
                bad_samples_cnt += 1 
                continue
            
            estimated_dist, estimated_pose = sample_dist, sample
            if RobotParams.badMCIterations // 3 < bad_samples_cnt:
                bad_samples_cnt = 0
                sigma_coord *= 0.5
                sigma_theta *= 0.5

        pose_diff = estimated_pose - robot_pose
        d_pose = max(abs(pose_diff[0]), abs(pose_diff[1]), abs(pose_diff[2]))
        if 0.0 < d_pose:
            rospy.loginfo("MC Correction -- dx: %.2f | dy: %.2f | dt: %.2f ",
                          pose_diff[0], pose_diff[1], pose_diff[2])
        return estimated_pose.translate_by_dist(-0) # laser offset
예제 #7
0
    def move(self, motion): # Do not change the name of this function

        # ADD CODE HERE
        alpha = random.gauss(motion[0], self.steering_noise) #steering angle
        distance = motion[1] + random.gauss(0, self.distance_noise) #Distance moved
        theta = self.orientation #Orientation of the robot
        beta = distance / self.length * tan(alpha)
        result = robot(self.length)
        result.set(self.x, self.y, self.orientation)
        result.set_noise(bearing_noise, steering_noise, distance_noise)
        if beta > 0.001:
            radius = distance / beta
            cx = self.x - sin(theta) * radius
            cy = self.y + cos(theta) * radius 
            result.x = cx + (sin(theta + beta) * radius)
            result.y = cy - (cos(theta + beta) * radius)
            theta = (theta + beta) % (2 * pi) 
            result.orientation = theta    	
		
        else:
            result.x = self.x + distance * cos(theta)
            result.y = self.y + distance * sin(theta)
            result.orientation = (theta + beta) % 2 * pi
		        	
        return result
예제 #8
0
def writeTuple() : 

    # create Tuple

    s=Proxy_Store("treeDemo.root","root",1)
    tuple = Tuple(s,"t","Example tuple with particles","TVector3 p; double mass")
    
    im = tuple.findColumn("mass")
    
    # create p vector
    v=TVector3()
    v_pointer = v._C_instance
    
    tuple.setAddress("p",v_pointer.address())
    im=tuple.findColumn("mass")
    
    import random
    for i in range(0,1000) : 
        v.SetXYZ( random.gauss(0,1), random.gauss(1,2), random.gauss(2,5) )
        tuple.fill(im, random.gauss(10,1) )
        tuple.addRow()
        
        
    print "Tuple filled with ",tuple.rows()," rows "
    s.close()

    return
예제 #9
0
    def run(self):
        sim_bam = pysam.Samfile(self.out + ".bam", "wb", header=TEST_HEADER)
        # Randomly generate number from 2 to value normalized for genomic region for N value
        read_range = xrange(2, self.total_reads / 500)
        # pdb.set_trace()
        mid_position = self.initial_mid_position

        count = 0
        total_reads = self.total_reads
        while total_reads > 0:
            N = random.sample(read_range, 1)[0]
            total_reads = total_reads - N
            while N > 0:
                count = count + 1
                N = N - 1

                # Introduce jitter
                tmp_mid_position = int(round(mid_position + random.uniform(-1, 1) * self.jitter))

                isize = int(round(random.gauss(145, self.insert_sd)))
                positions = ((tmp_mid_position - (isize / 2), isize), (tmp_mid_position + (isize / 2), -isize))

                # Construct/write paired AlignedReads
                for position in positions:
                    read = construct_read(count, 0, position[0], position[1], position[1] > 0)
                    sim_bam.write(read)

                # Advance position by 300
            advance = self.advance
            if self.jitter_advance > 0:
                advance = int(round(random.gauss(advance, self.jitter_advance)))
            mid_position = mid_position + advance
        sim_bam.close()
예제 #10
0
파일: hw3-6.py 프로젝트: Dmdv/CS373
 def move(self, motion): # Do not change the name of this function
     theta = self.orientation
     alfa = float(motion[0]) + random.gauss(0.0, self.steering_noise)
     d = float(motion[1]) + random.gauss(0.0, self.distance_noise)
     beta = (d/self.length)*tan(alfa)
     newx = 0.0
     newy = 0.0
     newtheta = 0.0
     
     if (abs(beta) < 0.001):
         newx = self.x + d * cos(theta)
         newy = self.y + d * sin(theta)
         newtheta = (theta + beta) % (2*pi)
     else:    
         R = d/beta
         cx = self.x - R * sin(theta)
         cy = self.y + R * cos(theta)
     
         newx = cx + R * sin(beta + theta)
         newy = cy - R * cos(beta + theta)
         newtheta = (theta + beta) % (2*pi)
     
     result = robot(self.length)
     result.set(newx, newy, newtheta)
     
     return result # make sure your move function returns an instance
예제 #11
0
 def __init__(self, world, space, pos, color, capsules, radius, mass=2, fixed=False, orientation=v(1, 0, 0, 0)):
     "capsules is a list of (start, end) points"
     
     self.capsules = capsules
     
     self.body = ode.Body(world)
     self.body.setPosition(pos)
     self.body.setQuaternion(orientation)
     m = ode.Mass()
     # computing MOI assuming sphere with .5 m radius
     m.setSphere(mass/(4/3*math.pi*.5**3), .5) # setSphereTotal is broken
     self.body.setMass(m)
     
     self.geoms = []
     self.geoms2 = []
     for start, end in capsules:
         self.geoms.append(ode.GeomTransform(space))
         x = ode.GeomCapsule(None, radius, (end-start).mag())
         self.geoms2.append(x)
         self.geoms[-1].setGeom(x)
         self.geoms[-1].setBody(self.body)
         x.setPosition((start+end)/2 + v(random.gauss(0, .01), random.gauss(0, .01), random.gauss(0, .01)))
         a = (end - start).unit()
         b = v(0, 0, 1)
         x.setQuaternion(sim_math_helpers.axisangle_to_quat((a%b).unit(), -math.acos(a*b)))
     
     self.color = color
     self.radius = radius
     
     if fixed:
         self.joint = ode.FixedJoint(world)
         self.joint.attach(self.body, None)
         self.joint.setFixed()
예제 #12
0
파일: task.py 프로젝트: mmmarcos/cs373
    def move(self, motion):

        # obtain steering angle and distance forward
        steering = random.gauss(motion[0], self.steering_noise)
        distance = random.gauss(motion[1], self.distance_noise)

        # compute turning angle
        turning_angle = distance / self.length * tan(steering)

        if turning_angle < 0.001:
            # approximate by straight line motion
            new_x = self.x + (distance * cos(self.orientation))
            new_y = self.y + (distance * sin(self.orientation))
            new_orientation = (self.orientation + turning_angle) % (2*pi)
        else:
            # compute radio and center of the circular path
            R = distance / turning_angle
            cx = self.x - (R*sin(self.orientation))
            cy = self.y + (R*cos(self.orientation))

            new_x = cx + (R*sin(self.orientation+turning_angle))
            new_y = cy - (R*cos(self.orientation+turning_angle))
            new_orientation = (self.orientation + turning_angle) % (2*pi)
        
        # copy values to the new robot
        result = robot()
        result.length = self.length
        result.set(new_x, new_y, new_orientation)
        result.set_noise(self.bearing_noise, self.steering_noise, self.distance_noise)

        return result
예제 #13
0
def initial(average):
	a=[0 for i in range(2*NP+2)]
	for i in range(0,2*NP):
		a[i]=average[i]+random.gauss(0.0,0.1)
	for i in range(2):
		a[2*NP+i]=2.8+random.gauss(0.0,0.2)
	return a
예제 #14
0
    def resample_particles(self):
        """ Resample the particles according to the new particle weights.
            The weights stored with each particle should define the probability that a particular
            particle is selected in the resampling step.  You may want to make use of the given helper
            function draw_random_sample.
        """
        #Primeiro de tudo, normalizar particulas
        self.normalize_particles()

        #Criar array do numpy vazia do tamanho do numero de particulas.
        values = np.empty(self.n_particles)

        #Preencher essa lista com os indices das particulas
        for i in range(self.n_particles):
            values[i] = i

        #Criar uma lista para novas particulas
        new_particles = []

        #Criar lista com os indices das particulas com mais probabilidade
        random_particles = ParticleFilter.weighted_values(values,[p.w for p in self.particle_cloud],self.n_particles)
        for i in random_particles:
            #Transformar o I em inteiro para corrigir bug de float
            int_i = int(i)

            #Pegar particula na possicao I na nuvem de particulas.
            p = self.particle_cloud[int_i]

            #Adicionar particulas somando um valor aleatorio da distribuicao gauss com media = 0 e desvio padrao = 0.025
            new_particles.append(Particle(x=p.x+gauss(0,.025),y=p.y+gauss(0,.025),theta=p.theta+gauss(0,.025)))

        #Igualar nuvem de particulas a novo sample criado
        self.particle_cloud = new_particles
        #Normalizar mais uma vez as particulas.
        self.normalize_particles()
예제 #15
0
	def update(self, velX, velY):
		#Don't update after a crash
		#if self.crashed:
		#	return

		velY -= gravity

		#Update true position
		#True velocity is intentional accel + random force accel
		self.posX += self.velX + random.gauss(0, self.randomForce)
		self.posY += self.velY + random.gauss(0, self.randomForce)
		self.velX = velX
		self.velY = velY

		sensorX = self.posX + random.gauss(0,self.sensorNoise)
		sensorY = self.posY + random.gauss(0,self.sensorNoise)

		#update naive estimated position
		self.posXEst = sensorX 
		self.posYEst = sensorY

		self.kalman(timeUpdate, sensorX, sensorY)

		#Crash if we hit the ground
		if self.posY < 0:
			self.crashed = True
			
		self.logGT.log(self.posX, self.posY)
		self.logEst.log(self.posXEst, self.posYEst)
		self.logKal.log(self.x[0], self.x[1])
		
		self.time += 1
		self.printValues()	
예제 #16
0
    def move(self, motion): # Do not change the name of this function
        theta = self.orientation
        alpha = float(motion[0]) + random.gauss(0.0, self.steering_noise)
        alpha %= 2.0 * pi
        d = float(motion[1]) + random.gauss(0.0, self.distance_noise)
        beta = (d/self.length) * tan(alpha)

        if (beta < 0.001):
            xnew = self.x + d*cos(theta)
            ynew = self.y + d*sin(theta)
        else:
            R = d/beta
            cx = self.x - sin(theta)*R
            cy = self.y + cos(theta)*R
            xnew = cx + sin(theta+beta)*R
            ynew = cy - cos(theta+beta)*R

        theta_new = (theta+beta) % (2*pi)

        result = robot(self.length)
        result.set(xnew, ynew, theta_new)
        result.set_noise(self.bearing_noise, self.steering_noise, 
                self.distance_noise )
        
        return result # make sure your move function returns an instance
예제 #17
0
 def __init__(self, name="anonymous goblin", **kwargs):
     """creates a new goblin instance
     every attribute can be overwritten with an argument like      
     g = Goblin(attack = 33.2)
     this will overwrite the random self.attack attribute with 33.2
     """
     self.name = name
     self.attack = random.gauss(Config.attack, 2) # float values
     self.defense = random.gauss(Config.defense, 2)
     # always create an goblin with twice the "normal" hitpoints
     # to make him cost real money
     self.hitpoints = random.gauss(Config.hitpoints*2, 3) 
     self.fullhealth = self.hitpoints 
     self.defense_penalty = 0 # integer value
     self.sleep = False # boolean 
     #statistics
     self.damage_dealt = 0
     self.damage_received = 0
     self.victory = 0  # over all rounds
     self.streak = 0  # victories in this combat
     self.lastround = 0 # number of combatround whre goblin lost
     self.lost = 0
     self.fights = 0
     # overwrite attributes if keywords were passed as arguments
     for key in kwargs:
         self.__setattr__(key, kwargs[key])
     # but do not mess around with number
     self.number = Goblin.number # access class attribute
     Goblin.number += 1 # prepare class attribute for next goblin
     # calculate value based on averages described in class Config
     self.value = self.calculate_value()
예제 #18
0
파일: ga.py 프로젝트: jeepq/pybrain
    def old_jpq_mutated(self, indiv, pop):
        """ mutate some genes of the given individual """
        res = indiv.copy()
        #to avoid having a child identical to one of the currentpopulation'''
        in_pop = self.childexist(indiv,pop)
        for i in range(self.numParameters):
            if random() < self.mutationProb:
                res[i] = max(min(indiv[i] + gauss(0, self.mutationStdDev),self.maxs[i]),
                             self.mins[i])
            
            if random() < self.mutationProb or in_pop:
                if self.xBound is None:
                    res[i] = indiv[i] + gauss(0, self.mutationStdDev)
                else:
                    if in_pop:
                        cmin = abs(indiv[i] - self.mins[i])/(self.maxs[i]-self.mins[i])
                        cmax = abs(indiv[i] - self.maxs[i])/(self.maxs[i]-self.mins[i])
                        if cmin < 1.e-7 or cmax < 1.e-7:
                            res[i] = self.mins[i] + random()*random()*(self.maxs[i]-self.mins[i])
                        else:
                            res[i] = max(min(indiv[i] + gauss(0, self.mutationStdDev),self.maxs[i]),
                             self.mins[i])
                    else:
                        res[i] = max(min(indiv[i] + gauss(0, self.mutationStdDev),self.maxs[i]),
                             self.mins[i])

        return res
예제 #19
0
    def move(self, motion): # Do not change the name of this function
          steering = motion[0]
          dist = motion[1]

          result = self

          # add noise
          steering2 = random.gauss(steering, result.steering_noise)
          dist2 = random.gauss(dist, result.distance_noise)

          turn = tan(steering2) * dist2 / result.length

          tolerance = 0.001

          if abs(turn) < tolerance:
               # approximate by straight line motion
               result.x+=(cos(result.orientation) * dist2)
               result.y+=(sin(result.orientation) * dist2)
               result.orientation = (result.orientation + turn) % (2.0 * pi)
          else:
               # bicycle motion
               radius = dist2 / turn

               cx = result.x - (sin(result.orientation) * radius)
               cy = result.y + (cos(result.orientation) * radius)

               result.orientation = (result.orientation + turn) % (2.0 * pi)
               result.x = cx + sin(result.orientation) * radius
               result.y = cy + cos(result.orientation) * radius 

          return result # make sure your move function returns an instance
예제 #20
0
파일: task.py 프로젝트: Qworg/cs373
    def move(self, motion): # Do not change the name of this function

        theta = self.orientation
        length = self.length
        x = self.x
        y = self.y
        alpha, d = motion;
        alphar = random.gauss(alpha, self.steering_noise)
        dr = random.gauss(d, self.distance_noise)
        alpha = alphar
        d = dr
        beta = (d/length)*tan(alpha)
        if (abs(beta) > 0.001):
            R = d/beta
            cx = x - sin(theta)*R
            cy = y + cos(theta)*R
            x = cx + sin(theta+beta)*R
            y = cy - cos(theta+beta)*R
            theta = (theta+beta)%(2*pi)
        else:
            x = x+d*cos(theta)
            y = y+d*sin(theta)
            theta = (theta+beta)%(2*pi)
        
        result = robot()
        result.set_noise(self.bearing_noise, self.steering_noise, self.distance_noise)
        result.set(x,y,theta)
        
        return result # make sure your move function returns an instance
예제 #21
0
 def modify(self):
     data_vars = []
     if not self._2D:
         data_vars.append('roll')
         data_vars.append('pitch')
     data_vars.append('yaw')
     # generate a gaussian noise rotation vector
     rot_vec = Vector((0.0, 0.0, 0.0))
     for i in range(0, 3):
         if data_vars[i] in self._rot_std_dev:
             rot_vec[i] = random.gauss(rot_vec[i], self._rot_std_dev[data_vars[i]])
     # convert rotation vector to a quaternion representing the random rotation
     angle = rot_vec.length
     if angle > 0:
         axis = rot_vec / angle
         noise_quat = Quaternion(axis, angle)
     else:
         noise_quat = Quaternion()
         noise_quat.identity()
     try:
         self.data['orientation'] = (noise_quat * self.data['orientation']).normalized()
     except KeyError:
         # for eulers this is a bit crude, maybe should use the noise_quat here as well...
         for var in data_vars:
             if var in self.data and var in self._rot_std_dev:
                 self.data[var] = random.gauss(self.data[var], self._rot_std_dev[var])
    def move(self, motion): # Do not change the name of this function

        # ADD CODE HERE
        if motion[1] < 0:
            raise ValueError, 'Robot cannot move backwards'
       
        # move, and add randomness to the motion command
        dist = float(motion[1]) + random.gauss(0.0, self.distance_noise)
    
         # turn, and add randomness to the turning command
        theta = self.orientation + random.gauss(0.0, self.bearing_noise)
        alpha = float(motion[0]) + random.gauss(0.0, self.steering_noise)
        alpha %= 2 * pi
   
        beta = tan(alpha) * dist / float(self.length)
        if beta < 0.001:
            x = self.x + dist * cos(theta)
            y = self.y + dist * sin(theta)
            theta = theta + beta
        else:
            r = dist / beta
            cx = self.x - r * sin(theta)
            cy = self.y + r * cos(theta)
    
            x = cx + r * sin(theta + beta)
            y = cy - r * cos(theta + beta)
            theta = theta + beta
     
    
        # set particle
        res = robot(self.length)
        res.set(x, y, theta)
        res.set_noise(self.bearing_noise, self.steering_noise, self.distance_noise)
          
        return res # make sure your move function returns an instance
def get_cuckoo(nests, best_nest, Lb, Ub, nest_number,nd,stepsize, percentage): 
    import math 
    import scipy.special 
    import random 
    #Mantegna's Algorithm 
    alpha = 1.5 #flexible parameter but this works well. Also need to plug in decimal form 
    sigma=(scipy.special.gamma(1+alpha)*math.sin(math.pi*alpha/2)/(scipy.special.gamma((1+alpha)/2)*alpha*2**((alpha-1)/2)))**(1/alpha) 
    for i in range(int(round(nest_number*percentage))): 
        temp = nests[i][:] 
        step = [0]*len(temp) 
        for j in range(len(temp)): 
            sign = 1
            a = random.gauss(0,1)*sigma 
            b = random.gauss(0,1) 
            if a < 0: 
                sign = -1
            step[j] = sign*stepsize[j]*((abs(a)/abs(b))**(1/alpha))*(temp[j]-best_nest[j]) 
            temp[j] = round(temp[j]+step[j]*random.gauss(0,1),3) 
            #check to see if new solution is within bounds 
            if temp[j] <= Lb[j]: 
                temp[j] = Lb[j] 
            elif temp[j] >= Ub[j]: 
                temp[j] = Ub[j] 
            #!!!we need second parameter to be larger than first. If conditions like these are necessary, change this section to 
            #!!!needed conditions. Otherwise remove or comment out.  
            if j == 1 and temp[j] < temp[0]: 
                coin = random.randint(0,1) 
                if coin == 0: 
                    temp[0] = round(random.uniform(Lb[0],temp[j]),3) 
                else: 
                    temp[j] = round(random.uniform(temp[0],Ub[j]),3) 
        nests[i][:] = temp 
    return nests 
예제 #24
0
def logPokemonDb(p):
    pokemon_id = int(p['pokemon_data']['pokemon_id'])
    pokemon_name = get_pokemon_name(str(pokemon_id)).lower().encode('ascii','ignore')

    last_modified_time = int(p['last_modified_timestamp_ms'])
    time_until_hidden_ms = int(p['time_till_hidden_ms'])

    hidden_time_unix_s = int((p['last_modified_timestamp_ms'] + p['time_till_hidden_ms']) / 1000.0)
    hidden_time_utc = datetime.utcfromtimestamp(hidden_time_unix_s)

    encounter_id = str(p['encounter_id'])
    spawnpoint_id = str(p['spawn_point_id'])

    longitude = float(p['longitude'])
    latitude = float(p['latitude'])
    longitude_jittered = longitude + (random.gauss(0, 0.3) - 0.5) * 0.0005
    latitude_jittered = latitude + (random.gauss(0, 0.3) - 0.5) * 0.0005

    #query =  "INSERT INTO spotted_pokemon (name, encounter_id, last_modified_time, time_until_hidden_ms, hidden_time_unix_s, hidden_time_utc, spawnpoint_id, longitude, latitude, pokemon_id, longitude_jittered, latitude_jittered) VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s);"
    query =  "INSERT INTO spotted_pokemon (name, encounter_id, last_modified_time, time_until_hidden_ms, hidden_time_unix_s, hidden_time_utc, spawnpoint_id, longitude, latitude, pokemon_id, longitude_jittered, latitude_jittered) VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s) ON CONFLICT (encounter_id) DO UPDATE SET last_modified_time = EXCLUDED.last_modified_time, time_until_hidden_ms = EXCLUDED.time_until_hidden_ms, hidden_time_unix_s = EXCLUDED.hidden_time_unix_s, hidden_time_utc = EXCLUDED.hidden_time_utc;"

    data = (pokemon_name, encounter_id, last_modified_time, time_until_hidden_ms, hidden_time_unix_s, hidden_time_utc, spawnpoint_id, longitude, latitude, pokemon_id, longitude_jittered, latitude_jittered)

    try:
        cursor.execute(query, data)
    except Exception,e:
        log.error('Postgresql error (%s)', str(e))
예제 #25
0
파일: impl.py 프로젝트: nebw/CS373
 def move(self, motion): # Do not change the name of this function
     alpha = random.gauss(motion[0], sqrt(self.steering_noise))
     d = random.gauss(motion[1], sqrt(self.distance_noise))
     
     beta = (d / self.length) * tan(alpha)
     
     if(beta >= abs(0.001)):
         R = d / beta
         
         cx = self.x - sin(self.orientation) * R
         cy = self.y + cos(self.orientation) * R
         
         x = cx + sin(self.orientation + beta) * R
         y = cy - cos(self.orientation + beta) * R
         orientation = (self.orientation + beta) % (2*pi)
     else:
         x = self.x + d * cos(self.orientation)
         y = self.y + d * sin(self.orientation)
         orientation = (self.orientation + beta) % (2*pi) 
         
     result = robot(self.length)
     result.set(x, y, orientation)
     result.set_noise(self.bearing_noise, self.steering_noise, self.distance_noise)
         
     return result
 def move(self, robot, steering, distance, 
          tolerance = 0.001, max_steering_angle = pi / 4.0):
     if steering > max_steering_angle:
         steering = max_steering_angle
     if steering < -max_steering_angle:
         steering = -max_steering_angle
     if distance < 0.0:
         distance = 0.0
     # apply noise
     steering2 = random.gauss(steering, self.steering_noise)
     distance2 = random.gauss(distance, self.distance_noise)
     # Execute motion
     turn = tan(steering2) * distance2 / self.length
     if abs(turn) < tolerance:
         # approximate by straight line motion
         x = robot.pos.x + (distance2 * cos(robot.orientation))
         y = robot.pos.y + (distance2 * sin(robot.orientation))
         orientation = (robot.orientation + turn) % (2.0 * pi)
     else:
         # approximate bicycle model for motion
         radius = distance2 / turn
         cx = robot.pos.x - (sin(robot.orientation) * radius)
         cy = robot.pos.y + (cos(robot.orientation) * radius)
         orientation = (robot.orientation + turn) % (2.0 * pi)
         x = cx + (sin(orientation) * radius)
         y = cy - (cos(orientation) * radius)
     return (x,y,orientation)
예제 #27
0
    def move(self, motion, tol = 0.001): # Do not change the name of this function
        result = robot()
        steerangle = motion[0]
        dist = motion[1]
        #if abs(steerangle)
        result.length = self.length
        result.bearing_noise = self.bearing_noise  
        result.steering_noise = self.steering_noise
        
        steerangle +=random.gauss(0.0, self.steering_noise)
        steerangle %= (2*pi)
        result.distance_noise = self.distance_noise 
        
        dist += random.gauss(0.0, self.distance_noise)
        
        beta = dist / self.length * tan(steerangle)

        if abs(beta)<= tol:
            result.x = self.x + dist * cos(self.orientation)
            result.y = self.y + dist * sin(self.orientation)
            result.orientation = (self.orientation + beta ) % (2.0 *pi)
            
        else:
           

            R = dist / beta
            cx = self.x - R * sin(self.orientation)
            cy = self.y + R * cos(self.orientation)
            result.orientation = (self.orientation + beta) % (2*pi)
            result.x = cx + sin(beta + self.orientation) * R
            result.y = cy - cos(beta + self.orientation) * R
        return result # make sure your move function returns an instance
예제 #28
0
 def compute_random_cut_off(self):
     desired_v_removed = int(gauss(len(self.V) / 2, len(self.V)/6))
     while desired_v_removed >= len(self.V) - self.threshold or desired_v_removed < self.threshold:
         desired_v_removed = int(gauss(len(self.V) / 2, len(self.V)/6))
     ratio = 1
     estimate_block_size = int(((len(self.L) - self.received_count) / (len(self.V) - self.threshold)) * ratio)
     return estimate_block_size * desired_v_removed + randint(0, estimate_block_size) - self.received_count
예제 #29
0
 def GaussLk( self, newLkFile, sigma ) :
   fout = open( newLkFile, "w" )
   fout.write("# input data : %s\n" % "+ Gaussian error"  )
   percentU = percentQ = 0.
   for lineStr,f1,f2 in zip (self.LeakList[0].lineStr, self.LeakList[0].f1, self.LeakList[0].f2) :
     print lineStr
     fout.write("#\n")
     for ant in range(1,16) :
       DRlist = []
       DLlist = []
       for Lk in self.LeakList :
         if Lk.ant == ant :
           for lineStr1,DR1,DL1 in zip( Lk.lineStr, Lk.DR, Lk.DL ) :
             if (lineStr1 == lineStr) and (abs(DR1) > 0.) and (abs(DL1) > 0.) :
               DRlist.append( DR1 )
               DLlist.append( DL1 )
               print "... ant %d - appending data from %s" % ( ant, Lk.legend )
       if len(DRlist) > 0 :
         DRmean = numpy.mean(DRlist)
         DLmean = numpy.mean(DLlist)
         DRnew = random.gauss(numpy.real(DRmean), sigma) + random.gauss(numpy.imag(DRmean), sigma) * 1j
         DLnew = random.gauss(numpy.real(DLmean), sigma) + random.gauss(numpy.imag(DLmean), sigma) * 1j
       else :
         DRnew = 0. + 0j
         DLnew = 0. + 0j
       print ant, DRnew, DLnew
       fout.write("C%02d %8.3f %8.3f %8.3f %6.3f %8.3f %6.3f %8.3f %6.3f    %s\n" % \
           ( ant, f1, f2, DRnew.real, DRnew.imag, DLnew.real, \
           DLnew.imag, percentQ, percentU, lineStr) )
   fout.close()
    def move(self, motion):

        a = random.gauss(motion[0], self.steering_noise)
        d = random.gauss(motion[1], self.distance_noise)

        b = (d * tan(a)) / self.length
        new_orientation = (b + self.orientation) % (2 * pi)
        if b > 0.001:
            r = d / b
            cx = self.x - r * sin(self.orientation)
            cy = self.y + r * cos(self.orientation)

            new_x = cx + r * sin(new_orientation)
            new_y = cy - r * cos(new_orientation)
        else:
            new_x = self.x + d * cos(new_orientation)
            new_y = self.y + d * sin(new_orientation)

        res = robot()
        res.x = new_x
        res.y = new_y
        res.orientation = new_orientation
        res.length = self.length
        res.bearing_noise = self.bearing_noise
        res.steering_noise = self.steering_noise
        res.distance_noise = self.distance_noise

        return res
예제 #31
0
import os
from collections import defaultdict
import sys
import math
import json
import random
import collections

#random.seed(777)

weight = {}
bias = {}
sOperation = ["shift", "reduce left", "reduce right"]
for sOp in sOperation:
    weight[sOp] = []
    bias[sOp] = random.gauss(0, 1)
i_phi = {}
pathInput = "../../data/mstparser-en-train.dep"
pathModel = "model.json"
dElements = {}
tdict = {}
tdict["a"] = 0
for i, j in tdict.items():
    print(i, j)


class cElement:
    def __init__(self, index, word, POS, head, label):
        self.index = index
        self.word = word
        self.POS = POS
예제 #32
0
    def sense(self):

        return [
            random.gauss(self.x, self.measurement_noise),
            random.gauss(self.y, self.measurement_noise)
        ]
예제 #33
0
def lombScargle(frequencyRange,objectmag=20,loopNo=looooops,df=0.001,fmin=0.001,numsteps=100000,modulationAmplitude=0.1,Nquist=200): # frequency range and object mag in list
    #global totperiod, totmperiod, totpower, date, amplitude, frequency, periods, LSperiod, power, mag, error, SigLevel
    results = {}
    totperiod = []
    totmperiod = []
    totpower = [] # reset
    SigLevel = []
    filterletter = ['o','u','g','r','i','z','y']
    
    period = 1/(frequencyRange)
    if period > 0.5:
        numsteps = 10000
    elif period > 0.01:
        numsteps = 100000
    else:
        numsteps = 200000
    freqs = fmin + df * np.arange(numsteps) # for manuel
    allobsy, uobsy, gobsy, robsy, iobsy, zobsy, yobsy = [], [], [], [], [], [], [] #reset
    measuredpower = [] # reset
    y = [allobsy, uobsy, gobsy, robsy, iobsy, zobsy, yobsy] # for looping only
    for z in range(1, len(y)):
        #y[z] = averageFlux(obs[z], frequencyRange[frange], 30)  # amplitde calculation for observations, anf frequency range
        y[z] = ellipsoidalFlux(obs[z], frequencyRange,30)
        y[z] = [modulationAmplitude * t for t in y[z]] # scaling
        for G in range(0, len(y[z])):
            flareMinute = int(round((obs[z][G]*24*60*2)%((dayinsec/(30*2))*flarecycles)))
            y[z][G] = y[z][G] + longflare[flareMinute] # add flares swapped to second but not changing the name intrtoduces fewer bugs
    date = []
    amplitude = []
    mag = []
    error = []
    filts = []
    for z in range(1, len(y)):
        if objectmag[z] > sat[z] and objectmag[z] < lim[z]:
            #date.extend([x for x in obs[z]])
            date.extend(obs[z])
            amplitude = [t + random.gauss(0,magUncertainy(zeroPoints[z],objectmag[z],30,background,FWHMeff[z])) for t in y[z]] # scale amplitude and add poisson noise
            mag.extend([objectmag[z] - t for t in amplitude]) # add actual mag
            error.extend([sigSys + magUncertainy(zeroPoints[z],objectmag[z],30,background,FWHMeff[z])+0.2]*len(amplitude))
            filts.extend([filterletter[z]]*len(amplitude))

            phase = [(day % (period*2))/(period*2) for day in obs[z]]
            pmag = [objectmag[z] - t for t in amplitude]
#         plt.plot(phase, pmag, 'o', markersize=4)
#         plt.xlabel('Phase')
#         plt.ylabel('Magnitude')
#         plt.gca().invert_yaxis()
#         plt.title('filter'+str(z)+', Period = '+str(period))#+', MeasuredPeriod = '+str(LSperiod)+', Periodx20 = '+(str(period*20)))
#         plt.show()

#     plt.plot(date, mag, 'o')
#     plt.xlim(lower,higher)
#     plt.xlabel('time (days)')
#     plt.ylabel('mag')
#     plt.gca().invert_yaxis()
#     plt.show()

    model = periodic.LombScargleMultibandFast(fit_period=False)
    model.fit(date, mag, error, filts)
    power = model.score_frequency_grid(fmin, df, numsteps) 

    if period > 10.:
        model.optimizer.period_range=(10, 110)
    elif period > 0.51:
        model.optimizer.period_range=(0.5, 10)
    elif period > 0.011:
        model.optimizer.period_range=(0.01, 0.52)
    else:
        model.optimizer.period_range=(0.0029, 0.012)


    LSperiod = model.best_period
    if period < 10:
        higher = 10
    else:
        higher = 100
#     fig, ax = plt.subplots()
#     ax.plot(1./freqs, power)
#     ax.set(xlim=(0, higher), ylim=(0, 1.2),
#            xlabel='period (days)',
#            ylabel='Lomb-Scargle Power',
#           title='Period = '+str(period)+', MeasuredPeriod = '+str(LSperiod)+', Periodx20 = '+(str(period*20)));
#     plt.show()


    phase = [(day % (period*2))/(period*2) for day in date]
    #idealphase = [(day % (period*2))/(period*2) for day in dayZ]
    #print(len(phase),len(idealphase))
    #plt.plot(idealphase,Zmag,'ko',)
#     plt.plot(phase, mag, 'o', markersize=4)
#     plt.xlabel('Phase')
#     plt.ylabel('Magnitude')
#     plt.gca().invert_yaxis()
#     plt.title('Period = '+str(period)+', MeasuredPeriod = '+str(LSperiod)+', Periodx20 = '+(str(period*20)))
#     plt.show()
    #print(period, LSperiod, period*20)

#         print('actualperiod', period, 'measured period', np.mean(LSperiod),power.max())# 'power',np.mean(power[maxpos]))
#         print(frequencyRange[frange], 'z', z)

#     totperiod.append(period)
#     totmperiod.append(np.mean(LSperiod))
#     totpower.append(power.max())
    mpower = power.max()
    measuredpower.append(power.max()) # should this correspond to period power and not max power?
    maxpower = []           
    counter = 0.
    for loop in range(0,loopNo):
        random.shuffle(date)
        model = periodic.LombScargleMultibandFast(fit_period=False)
        model.fit(date, mag, error, filts)
        power = model.score_frequency_grid(fmin, df, numsteps)  
        maxpower.append(power.max())


    for X in range(0, len(maxpower)):
        if maxpower[X] > measuredpower[-1]:
            counter = counter + 1. 
    Significance = (1.-(counter/len(maxpower)))
    #print('sig', Significance, 'counter', counter)
    SigLevel.append(Significance)
    
    #freqnumber = FrangeLoop.index(frequencyRange)
    #magnumber = MagRange.index(objectmag)
    #print(fullmaglist)
    #listnumber = (magnumber*maglength)+freqnumber
#     print(listnumber)
#     measuredperiodlist[listnumber] = LSperiod
#     periodlist[listnumber] = period
#     powerlist[listnumber] = mpower
#     siglist[listnumber] = Significance
#     fullmaglist[listnumber] = objectmag
# results order, 0=mag,1=period,2=measuredperiod,3=siglevel,4=power,5=listnumber
    results[0] = objectmag[3]
    results[1] = period
    results[2] = LSperiod
    results[3] = Significance
    results[4] = mpower
    results[5] = 0#listnumber
    return results
 def process  ( self , item ) :
     i, n = item 
     import ROOT, random 
     h1 = ROOT.TH1F ( 'h%d' %  i , '' , 100 , 0 , 10 )
     for i in range ( n ) : h1.Fill ( random.gauss (  5 ,  1 ) )
     return h1
def rand_vector():
    vec = [gauss(0, 1) for i in range(3)]
    mag = sum(x**2 for x in vec) ** 0.5
    return [x/mag for x in vec]
예제 #36
0
 def Mutate(self):
     geneToMutate = random.randint(0, 3)
     self.genome[geneToMutate] = random.gauss(geneToMutate,
                                              math.fabs(geneToMutate))
예제 #37
0
#! /usr/bin/env python2
"""
histogram.py: A program to print "
"""
__author__ = "Seshagiri Prabhu"
__copyright__ = "MIT License"

import random

if __name__ == "__main__":
    """
    Main function
    """
    # Generates random numbers
    gen_numbers = []
    for x in xrange(1001):
        gen_numbers.append(int(random.gauss(5, 2)))

    # Finds the frequency of numbers
    normalized = dict((i, gen_numbers.count(i)) for i in gen_numbers)

    # Prints histogram
    for key, value in normalized.iteritems():
        if key > -1 and key < 11:
            print str(key) + ":\t" + (value / 10) * "*"
예제 #38
0
    def data_augmentation(self):
        #数据集增强,主要通过计算正负样本的均值,方差,向正负样本加上高斯噪声
        #高斯噪声

        label="host"
        data=self.get_dataset(cond={'label':label})
        avg=list()
        std=list()
        veclen=len(data[0]['vec'])
        sampleSize=len(data)
        for j in range(0,veclen):
            avg.append(0)
            for i in range(0,sampleSize):
                avg[j]+=data[i]['vec'][j]
        for  j in range(0,veclen):
            avg[j]/=sampleSize

        for j in range(0,veclen):
            std.append(0)
            for i in range(0,sampleSize):
                std[j]+=(data[i]['vec'][j]-avg[j])**2

        for j in range(0,veclen):
            std[j]/=(0.000001+sampleSize-1)
            std[j]=std[j]**0.5+0.000001
        for each in data:
            for j in range(0,veclen):
                #each['vec'][j]=(each['vec'][j]-avg[j])/std[j]
                each['vec'][j]=0.95*each['vec'][j]+0.05*random.gauss(avg[j],std[j])
            each.setdefault('tag','data_augmentation')
            each.pop('_id')
        self.insert(data)




        label="nat"
        data=self.get_dataset(cond={'label':label})
        nat_data=data.copy()
        avg=[]
        std=[]
        veclen=len(data[0]['vec'])
        sampleSize=len(data)
        for j in range(0,veclen):
            avg.append(0)
            for i in range(0,sampleSize):
                avg[j]+=data[i]['vec'][j]
        for  j in range(0,veclen):
            avg[j]/=sampleSize

        for j in range(0,veclen):
            std.append(0)
            for i in range(0,sampleSize):
                std[j]+=(data[i]['vec'][j]-avg[j])**2

        for j in range(0,veclen):
            std[j]/=(0.000001+sampleSize-1)
            std[j]=std[j]**0.5+0.000001
        for each in data:
            for j in range(0,veclen):
                #each['vec'][j]=(each['vec'][j]-avg[j])/std[j]
                each['vec'][j]=0.95*each['vec'][j]+0.05*random.gauss(avg[j],std[j])
            each.setdefault('tag','data_augmentation_gauss')
            each.pop('_id')
        self.insert(data)
        #将部分Nat的TTL个数改为1,因为也的确会有同一个局域网中所有主机的OS会是一致的情况.将比例控制在10%
        for each in nat_data:
            p=random.uniform(0,1)
            if p<0.1 and each['vec'][-2]!=1:
                each['vec'][-2]=1
                each.setdefault('tag','data_augmentation_nat_synthes')
                each.pop('_id')
                self.insert(each)
예제 #39
0
train_data = np.delete(train_data, -1, 1)
train_label = np.array(uni[:,-1]).reshape((train_data.shape[0],1))

train_label[train_label==0] = -1

no_train_sample = train_data.shape[0]
no_variable = train_data.shape[1] + 1

c = [0]*(no_variable*2) + [-1]*no_train_sample + [0]*no_train_sample
b = [-1]*no_train_sample


U = np.diag([-1]*no_train_sample)
S = np.diag([1]*no_train_sample)
A = np.zeros((no_train_sample,no_variable*2))
one = np.array([random.gauss(1, 0.1) for i in range(no_train_sample)]).reshape((no_train_sample,1))
Z = train_label*np.concatenate((train_data,one),axis = 1)

for i in range(no_variable):
    A[:,2*i] = Z[:,i] 
    A[:,2*i+1] = -1*Z[:,i] 

A = np.concatenate((A,U),axis = 1)
A = np.concatenate((A,S),axis = 1)

# In[24]:
#==============================================================================
# import numpy as np
# 
# train_data = np.load("dataset\DB_Vecs.npy")
# train_label = np.load("dataset\DB_Labels.npy")
예제 #40
0
 def get_random_unit_vector(self):
     v = np.array([random.gauss(0, 1) for _ in range(self.n)])
     return v / np.linalg.norm(v)
예제 #41
0
 def gen(self):
     return random.gauss(0, 1)
예제 #42
0
파일: examples.py 프로젝트: mfkiwl/chevrons
def add_noise(data_point):
    return random.gauss(data_point, 1)
	matrx_all_X.append([a11**2, 2*a11*a12,a12**2])
	
#=========================================
#  Only x-axis analysis
#=========================================
sigma_rel_err = 0.05

n_ws = len(matrx_all_X)

mMatrX = Matrix(matrx_all_X,n_ws,3)

sigma2Vector = Matrix(n_ws,1)
weightM = Matrix.identity(n_ws,n_ws)

for ind in range(n_ws):
	sigma = sizes_X_arr[ind]*(1.0 +	random.gauss(0.,sigma_rel_err))
	sigma2Vector.set(ind,0,sigma**2)
	err2 = (2*sigma*sigma*sigma_rel_err)**2
	weightM.set(ind,ind,1.0/err2)
	
#=== mwmMatr = (M^T*W*M) =======
mwmMatr = ((mMatrX.transpose()).times(weightM)).times(mMatrX)

#=== corr2ValMatr = [(M^T*W*M)^-1] * M^T * W * Vector(sigma**2)
corr2ValMatr = (((mwmMatr.inverse()).times(mMatrX.transpose())).times(weightM)).times(sigma2Vector)

corr2ErrMatr = mwmMatr.inverse()

print "========================================"
print "<x^2>            = ","%12.5e"%corr2ValMatr.get(0,0)," +- ","%12.5e"%math.sqrt(abs(corr2ErrMatr.get(0,0)))
print "<x*x'>           = ","%12.5e"%corr2ValMatr.get(1,0)," +- ","%12.5e"%math.sqrt(abs(corr2ErrMatr.get(1,1)))
 def generate_turbulence(self, wind_level):
     self.tiltAngle += gauss(0.75, 1.0 * wind_level)
     logging.info('Tilt after turbulence {}'.format(self.tiltAngle))
예제 #45
0
 def make_rand_vector(dims):
     vec = [gauss(0, 1) for i in range(dims)]
     mag = sum(x**2 for x in vec)**0.5
     return [x / mag for x in vec]
예제 #46
0
 def resfit(self):
     """
     implements logic of resfit.pro for this resonator
     """
     rfp = self.resFitPrep()
     x = rfp['functkw']['x']
     y = rfp['functkw']['y']
     err = rfp['functkw']['err']
     p = rfp['p0']
     parinfo = rfp['parinfo']
     functkw = rfp['functkw']
     m = mpfit(Resonator.resDiffLin,
               p,
               parinfo=parinfo,
               functkw=functkw,
               quiet=1)
     rdlFit = Resonator.resDiffLin(m.params, fjac=None, x=x, y=y, err=err)
     bestChi2 = np.power(rdlFit[1], 2).sum()
     bestIter = 0
     parold = p.copy()
     random.seed(y.sum())
     bestPar = p.copy()
     bestM = m
     for k in range(1, 12):
         parnew = parold.copy()
         parnew[0] = 20000 + 30000.0 * random.random()
         parnew[1] = parold[1] + 5000 * random.gauss(0.0, 1.0)
         parnew[2] = parold[2] + 0.2 * parold[2] * random.gauss(0.0, 1.0)
         parnew[3] = parold[3] + 0.2 * parold[3] * random.gauss(0.0, 1.0)
         parnew[4] = parold[4] + 5.0 * parold[4] * random.gauss(0.0, 1.0)
         parnew[5] = parold[5] + 0.2 * parold[5] * random.gauss(0.0, 1.0)
         parnew[6] = parold[6] + 0.5 * parold[6] * random.gauss(0.0, 1.0)
         parnew[7] = parold[7] + 0.5 * parold[7] * random.gauss(0.0, 1.0)
         parnew[8] = parold[8] + 0.5 * parold[8] * random.gauss(0.0, 1.0)
         parnew[9] = parold[9] + 0.5 * parold[9] * random.gauss(0.0, 1.0)
         m = mpfit(Resonator.resDiffLin,
                   parnew,
                   parinfo=parinfo,
                   functkw=functkw,
                   quiet=1)
         rdlFit = Resonator.resDiffLin(m.params,
                                       fjac=None,
                                       x=x,
                                       y=y,
                                       err=err)
         thisChi2 = np.power(rdlFit[1], 2).sum()
         if m.status > 0 and thisChi2 < bestChi2:
             bestIter = k
             bestChi2 = thisChi2
             bestM = m
     p = bestM.params
     yFit = Resonator.resModel(x, bestM.params)
     ndf = len(x) - len(bestM.params)
     # size of loop from fit
     radius = (p[6] + p[7]) / 4.0
     # normalized diamter of the loop (off resonance = 1)
     diam = (2.0 * radius) / (math.sqrt(p[8]**2 + p[9]**2) + radius)
     Qc = p[0] / diam
     Qi = p[0] / (1.0 - diam)
     dip = 1.0 - diam
     try:
         dipdb = 20.0 * math.log10(dip)
     except ValueError:
         dipdb = -99
     chi2Mazin = math.sqrt(bestChi2 / ndf)
     return {
         "m": bestM,
         "x": x,
         "y": y,
         "yFit": yFit,
         "chi2": bestChi2,
         "ndf": ndf,
         "Q": p[0],
         "f0": p[1] / 1e9,
         "Qc": Qc,
         "Qi": Qi,
         "dipdb": dipdb,
         "chi2Mazin": chi2Mazin,
         "dip": dip
     }
예제 #47
0
# -*- coding: utf-8 -*-
# 平均 μ=0,標準偏差 σ=0.7 のデータを200個生成して,ファイルに保存
import random

filename = "random200.dat"
T = 200;
mu = 0.0
sigma = 0.7
# random.seed( 20131107 )

f = open(filename, 'w')
for i in range(T):
    f.write("%f\n" % random.gauss(mu,sigma) )

f.close()
예제 #48
0
	def calcScore(self, song):
		scores = []
		scores += [song.rating * random.gauss(1, 0.5)]
		scores += [self.calcContextMatchScore(song) * random.gauss(1, 0.5)]
		return sum(scores) + random.gauss(1, 0.5)
예제 #49
0
    def crear_hogares(self):
        """
        Consideranco la probabilidad de que en una casa exista un matrimonio, 
        y el promedio de hijos menores a 23 años en cada casa, se asignan
        individuos a cada nodo hogar.
        Se consideran personas solteras con y sin hijos.
        """
        #Se generan las listas con cada tipo de individuos a repartir
        hombres = [
            ind for ind in self.agentes_a_asignar
            if ind.sexo == 'h' and ind.edad >= 23
        ]
        mujeres = [
            ind for ind in self.agentes_a_asignar
            if ind.sexo == 'm' and ind.edad >= 23
        ]
        hijos = [ind for ind in self.agentes_a_asignar if ind.edad < 23]
        print(
            f'Cantidad de hombres {len(hombres)}, mujeres {len(mujeres)}, hijos {len(hijos)}'
        )
        contador_nodos = 0
        while len(hombres) > 0 or len(mujeres) > 0:
            a_agregar = []
            matrimonio = random() < self.p_matrimonio
            ##Se asignan primero los jefes de familia (hombre y/o mujer)
            if len(hombres) * len(mujeres) > 0 and matrimonio:
                a_agregar.append(hombres.pop())
                a_agregar.append(mujeres.pop())
            else:
                seleccion = sample([hombres, mujeres], 2)
                if len(seleccion[0]) > 0:
                    a_agregar.append(seleccion[0].pop())
                else:
                    a_agregar.append(seleccion[1].pop())

            ##Se asignan los hijos a cada casa
            n_hijos = abs(int(gauss(self.promedio_hijos, 0.5)))
            while len(hijos) > 0 and n_hijos > 0:
                a_agregar.append(hijos.pop())
                n_hijos -= 1

            print(
                f'En la casa {contador_nodos} hay {len(a_agregar)} personas. Matrimonio : {matrimonio}'
            )
            for i in a_agregar:
                i.casa_id = contador_nodos
                i.nodo_actual = contador_nodos

            ##Se procede a crear el nodo correspondiente
            self.add_node(contador_nodos,
                          tipo='casa',
                          habitantes=[ind.unique_id for ind in a_agregar],
                          ocupantes=a_agregar)
            self.casasids.append(contador_nodos)
            contador_nodos += 1

        ##Si sobran hijos, entonces se agregan al azar a todos los nodos
        while len(hijos) > 0:
            hijo = hijos.pop()
            idcasa = choice(list(self.nodes))
            print(f'Se agrega un hijo a la casa {idcasa}... ', end='')
            self.nodes[idcasa]['habitantes'].append(hijo.unique_id)
            self.nodes[idcasa]['ocupantes'].append(hijo)
            hijo.casa_id = idcasa
            hijo.nodo_actual = idcasa
            print('Agregado')
def visualizeSingleSystem(subplots, channel_file, power_system_object, pos, G,
                          a):
    node_labels = {i: str(i) for i in range(1, 40)}

    time, frequencies, res = getFrequencyDeviation(channel_file)

    gens = [gen._bus for gen in power_system_object._generators]
    loads = [load._bus for load in power_system_object._loads]
    stubs = list(
        set(range(1, power_system_object._nbus + 1)) - (set(gens + loads)))
    nodelists = [gens, loads, stubs]
    bus_colors = {}
    node_colors = []

    qss = nx.shortest_path_length(G, 10)
    qsna = {key: (12 - qss[key]) * 1.0 / 10 for key in qss}
    qsa = {key: (14 - qss[key]) * 1.0 / 9 for key in qss}
    qsna[10] = 2.4
    qsna[32] = 1.9
    qsna[13] = 1.3
    qsna[12] = 1.1
    qsna[11] = 1.15
    #qs = {10:0.99,32:0.93,13:0.94,12:0.923,11:0.947,14:0.912,15:0.901,6:0.873,31:}

    for nodelist in nodelists:
        #node_colors.append([float(res[key]) for key in res if key in nodelist])
        temp = []
        for i in range(len(nodelist)):
            if a:
                if nodelist[i] in qsa:
                    q = qsa[nodelist[i]] * random.gauss(.7, .08)
                else:
                    q = 0  #random.gauss(.25,.25)
            else:
                if nodelist[i] in qsna:
                    q = qsna[nodelist[i]] * random.gauss(.35, .08)
                else:
                    q = 0  #random.gauss(.25,.25)

            if q < 0:
                q = 0.0
            if q > 1:
                q = 1.0
            bus_colors[nodelist[i]] = q
            temp.append(q)
        node_colors.append(temp)

    shapes = ['s', 'o', 'o']
    node_sizes = [90, 90, 90]
    img = misc.imread('asd.PNG')
    img[:, :, 3] = 190  #set alpha

    plt.subplot(subplots[0])
    plt.imshow(img, zorder=0, extent=[0.0, 1.0, 0.0, 1.0])
    for i in range(3):
        im = nx.draw_networkx_nodes(G,
                                    pos,
                                    nodelist=nodelists[i],
                                    node_color=node_colors[i],
                                    node_shape=shapes[i],
                                    node_size=node_sizes[i],
                                    cmap=plt.cm.get_cmap('RdYlBu_r'),
                                    vmin=0.0,
                                    vmax=1.0)

    #nx.draw_networkx_labels(G,pos,labels=node_labels,font_size=15)

    plt.axis('off')

    nx.draw_networkx_edges(G, pos)

    cmap = plt.cm.get_cmap('RdYlBu_r')
    plt.subplot(subplots[1])
    #bus_colors[bus]
    for bus in sorted(bus_colors):
        #colorVal = plt.cm.get_cmap('RdYlBu_r').to_rgba(res[bus])
        plt.plot(time,
                 frequencies[bus],
                 color=cmap(bus_colors[bus]),
                 alpha=0.7)
        plt.xlim([0.0, 30.0])
        plt.ylim([59.62, 60.38])
        plt.xlabel('Time [s]')
        if a:
            plt.ylabel('Frequency [Hz]')
        plt.xticks([0, 10, 20, 30])
        plt.yticks([59.7, 60, 60.3])
    return im
예제 #51
0
'''
write a sequence of argv[1] normally distributed random numbers with mean argv[2] and std.dev argv[3] into argv[4] (ASCII text file)
Example:
python create_init_distr.py 20 -16.44 0.3 fens.txt
'''
from math import *
import random
import sys  #for getting command line args

noe = int(sys.argv[1])  #number of ensemble members
mu = float(sys.argv[2])  #mean of the normal distribution
sig = float(sys.argv[3])  #standard deviation of the normal distribution
f = open(sys.argv[4],
         'w')  #open the desired text file to write output in there

for i in range(noe):
    #r = random.gauss(log10(4e-17), log10(8e-17/4e-17)) #-16.4+-0.3 seems reasonable, 4e-17 is mu, 8e-17 is mu+1sigma
    r = random.gauss(mu, sig)
    f.write(str(r) + '\n')

f.close()

# DART $Id: create_init_distr.py 11001 2017-02-03 23:08:55Z [email protected] $
# from Alexey Morozov
#
# <next few lines under version control, do not edit>
# $URL: https://svn-dares-dart.cgd.ucar.edu/DART/branches/rma_trunk/models/gitm/python/create_init_distr.py $
# $Revision: 11001 $
# $Date: 2017-02-03 16:08:55 -0700 (Fri, 03 Feb 2017) $
예제 #52
0
eta = 5.0 * (10**(-2))
tau = 1.0 * (10**(2))
dt = 1.0
x_0 = 1.0

sigma = 10.0
constant = 1.0 / math.sqrt(2 * math.pi * (sigma**2))

for experiment in range(
        NUM_EXPTS
):  #simulate the paradigm using many different initializations of w_0
    mu = [(20.0 * j) + 10.0 for j in range(MU_RANGE)]
    y = []
    y2 = []
    # generate weights from a gaussian with mu = 3.0 and sigma = 1.0. Constrain w_i >= 0.
    w_0 = [random.gauss(3.0, 1.0) for i in range(NUM_NEURONS)
           ]  # at each of the 20 simulations, this is drawn
    tmp_w0 = copy.deepcopy(
        w_0)  # reassignment of list would create shallow copies!!

    for j in range(MU_RANGE):
        w_0 = copy.deepcopy(tmp_w0)  # use the same weights for all inputs
        #	print "init w_0: ",w_0
        f = open("weights_for_mu%d_expt%d_t%d" % (j, experiment, TIME_LIMIT),
                 'wt')
        #f_theta = open("theta_for_mu%d_expt%d_t%d"%(j , experiment,TIME_LIMIT),'wt')
        #f_y = open("response_for_mu%d_expt%d_t%d"%(j , experiment,TIME_LIMIT),'wt')
        #f_F = open("objective_for_mu%d_expt%d_t%d"%(j , experiment,TIME_LIMIT),'wt')
        theta_0 = [2.5 for i in range(MU_RANGE)]
        #	print "init theta_0: ",theta_0
예제 #53
0
        while True:
            # Round the position to the nearest tenth of a meter. This keeps the sprites from jumping around while
            # drawing due to floating point round-off to the nearest pixel.
            site_pos = (round(
                random.uniform(*DELIVERY_SITE_X_BOUNDS) % WORLD_LENGTH, 1),
                        round(
                            random.uniform(*DELIVERY_SITE_Y_BOUNDS) %
                            WORLD_WIDTH, 1))
            if min((s.distance_to(site_pos) for s in delivery_sites),
                   default=MIN_DELIVERY_DISTANCE) >= MIN_DELIVERY_DISTANCE:
                delivery_sites.append(DeliverySite(site_pos))
                break

    # Randomly generate trees that aren't too close to delivery sites.
    trees = []
    tree_density = random.gauss(TYPICAL_NUM_TREES, MAX_NUM_TREES / 3)
    '''
    num_trees = round(min(MAX_NUM_TREES, tree_density) if tree_density >= TYPICAL_NUM_TREES
                      else random.triangular(0, TYPICAL_NUM_TREES, TYPICAL_NUM_TREES))
    '''
    num_trees = 99
    for _ in range(num_trees):
        while True:
            # Round the position to the nearest tenth of a meter. This keeps the sprites from jumping around while
            # drawing due to floating point round-off to the nearest pixel.
            tree_pos = (round(random.uniform(*TREE_X_BOUNDS),
                              1), round(random.uniform(0, WORLD_WIDTH), 1))
            if min((s.distance_to(tree_pos) for s in delivery_sites),
                   default=MIN_TREE_DISTANCE) >= MIN_TREE_DISTANCE:
                trees.append(Tree(tree_pos))
                break
예제 #54
0
for t in range(0, total_steps):
    # Write positions to file
    with open('positions_hard_sphere.xyz', 'a') as f:
        f.write(str(len(x)) + '\n')
        f.write('\n')
        for i in range(len(x)):
            # xyz file is a file format to store 3D position
            # the general format is:
            # PARTICLE_TYPE  X  Y  Z
            # here we just call our hard spheres H
            f.write('H' + '\t' + str(x[i]) + '\t' + str(y[i]) + '\t' +
                    str(z[i]) + '\n')

    for i in range(0, particle_number):
        # Trial Move
        trial_x = x[i] + random.gauss(0, 1)
        trial_y = y[i] + random.gauss(0, 1)
        trial_z = z[i] + random.gauss(0, 1)

        # Check boundaries
        # We always move particles a small step, so don't worry if trial_x >> box_size
        if trial_x <= 0:
            trial_x += box_size
        elif trial_x >= box_size:
            trial_x -= box_size

        if trial_y <= 0:
            trial_y += box_size
        elif trial_y >= box_size:
            trial_y -= box_size
def raytrace_2d(nrays, sigma0, vel, nscr):

# seed random number generator here (a second one below!!!@#@)
    np.random.seed(380340)
    rand.seed(32422005)
    
#    The screen strength weighting scheme is as follows (screen j):

#        sigma0 = passed in: sets the scale of all the deflections
#        Sr[j] = strength of the randdom component of the ray
#        Sd[j] = strength of the directed component of the ray
#          A[j] = axial ratio   sigmax/sigmay ; y gets divided by this value
#          psi[j] = position angle (rel. to x-axis) of the directed component

    # creating variables. Path is x or y location at each screen.
    # thetax and thetay are the angular positions at each screen.
    # omega and tau are the delay and fringe frequency corroloaries
    nscreen = nscr
    pathx = np.zeros((nrays, nscreen+1)) # x position. nscreen indices. 
    pathy = np.zeros((nrays, nscreen+1)) # y position with nscreen indices.
    thetax = np.zeros((nrays, nscreen+1)) # one deflection angle at each screen plus the initial one.
    thetay = np.zeros((nrays, nscreen+1))
    tau = np.zeros(nrays) # array that holds delays
    omega = np.zeros(nrays) # array of omega values for each ray.

    Sd = np.zeros(nrays)  # strength (in units of sigma0) of directed component
    psi = np.zeros(nrays)  # position angle (reltative to x-axis) of directed component
    AR = np.ones(nrays)    # axial ratio of ellipse  sigmay = sigmax / AR
    Sr = np.ones(nrays)

    # amplitudes
    amp = np.zeros(nrays)
    dz = 3.1e19/nscreen # distance between screens (1kpc is 3.1e19 meters)

    # GENERATE EACH RAY HERE:
    for i in range(nrays):
        pathx[i,0] = 0
        pathy[i,0] = 0
        for j in range(nscreen+1):
            
            theta1 = 0
            theta2 = 0
            # this is the general ray creation mechanism.
            gx = rand.gauss(0,1) # x amplitude of directed component
            gy = rand.gauss(0,1) # y amplitude of directed component
            gr = rand.gauss(0,1) # amplitude of the random component
            psi_rand = 2.*np.pi*rand.random()  # uniform [0, 2 pi)
            
            theta1 = sigma0*(Sd[j]*(gx*np.cos(psi[j]) - gy*np.sin(psi[j])/AR[j]) + Sr[j]*gr*np.cos(psi_rand))
#            theta2 = sigma0*(Sd[j]*(gx*np.sin(psi[j]) + gy*np.cos(psi[j])/AR[j]) + Sr[j]*gr*np.sin(psi_rand))
            
            # Calculate the amplitude of this ray
               # may need tweaking - Dan (3/23/18)

            amp[i] += (gx**2 + gy**2)           
            # adjust theta based on what our deflection did to photons.
            thetax[i,j] = thetax[i,j-1] + theta1
            thetay[i,j] = thetay[i,j-1] + theta2

            # tracks the path the ray takes.
            pathx[i,j] = ((thetax[i,j])*dz) + pathx[i,j-1]
            pathy[i,j] = ((thetay[i,j])*dz) + pathy[i,j-1]

        # take the sigma values and subtract avg, find probability
        amp[i] = amp[i] - (nscreen-1)
        amp[i] = np.exp(-amp[i])

    # converge on the observer more neatly by subtracting a small amount from
    # each step.   
    for ray in range(nrays):
        dispx = (pathx[ray,nscreen])/(nscreen)
        dispy = (pathy[ray,nscreen])/(nscreen)
        for scr in range(1,nscreen+1):
            pathx[ray,scr] = pathx[ray,scr] - (dispx*(scr))
            pathy[ray,scr] = pathy[ray,scr] - (dispy*(scr))

    # calculate the omega values assuming the pulsar is moving in only x or 
    # y direction and not a combination of the two.
    
    # the total weighting sum, divides at end.
    sum_weights = 0
    sj = 0.0
    wj = 0.0
    for i in range(1,nscreen):
        # the screen fractional distance
        sj = float(i)/float(nscreen)
        # the screen weighting
        wj = sj/(1-sj)
        # adding each weighting to the total
        sum_weights += wj


    # getting omega values
    for ray in range(nrays):
        for i in range(nscreen):
            # the screen fractional distance
            sj = float(i)/float(nscreen)
            # the screen weighting
            wj = sj/(1-sj)

            # update theta values for the bent ray
            thetax[ray,i] = (pathx[ray,i]-pathx[ray,i-1])/dz
            thetay[ray,i] = (pathy[ray,i]-pathy[ray,i-1])/dz

            # add the screen plus the weighting
            omega[ray] += (thetax[ray,i]*wj)

            # gets the tau delays relative to to straight-line path. (small
            # angle approximation used here.
            xdelay = ((thetax[ray,i]**2)*dz)/(2*(3e8)) #seconds
            ydelay = ((thetay[ray,i]**2)*dz)/(2*(3e8)) #seconds
            tau[ray] += np.sqrt(xdelay**2+ydelay**2)

#        print thetax[ray,nscreen]

        # calculate the final omega by getting right units/undo weighting
        omega[ray] = 2*np.pi*omega[ray]*vel/(sum_weights*0.37) #divide by wavelength of .37m

    # random phase approximation for a given ray.
#    phi = 2.0 * np.pi * np.random.rand(nrays) # random phase

    # set the omega and tau values to zero and make ray 0 the source point.
    amp[0] = 1e-2
    omega[0] = 0
    tau[0] = 0

    # FIND ALL INTERFERENCE TERMS HERE
    sec = [ (0,0) for i in range(nrays*nrays) ]
    sec_amp = np.zeros(nrays*nrays)
    idx = 0
    for ray1 in range(nrays):
        for ray2 in range(nrays):
            if (ray1 != ray2):
                # difference term
                sec[idx] = ((omega[ray2]-omega[ray1]),(tau[ray2]-tau[ray1]))
            elif (ray1 == ray2):
                # self term
                sec[idx] = (0,0)

            #saving the amplitude of the combined rays for every interference.
            sec_amp[idx] = amp[ray1]*amp[ray2]
            idx += 1
# if you wanted to, this is where you would create a dynamic.
#########    dyn = makeDyn(nx,ny,nscreen,phi,omega,tau, nrays)

    return pathx, pathy, thetax, thetay, sec, tau, omega, sec_amp
예제 #56
0
#!/usr/bin/python

import random

#########################################################################
# Generate data like [ x, y, z] [ val = (c1*x + c2*y + c3*z + noise) ]  #
# where x,y,z are random numbers and c1, c2, c3 are coefficients(known) #
#########################################################################
coefficients = [2, 4, 7]

minRandom = -50
maxRandom = 50

# random.gauss(mean, sigma)
# first param is mean,
# second param is standard deviation
noise = random.gauss(0, 10)

inputs = []
output = 0
for index in range(len(coefficients)):
    randFloat = random.uniform(minRandom, maxRandom)
    inputs.append(float(format(randFloat, '.3f')))
    output += inputs[index] * coefficients[index]

output += float(format(noise, '.3f'))
print inputs, "[", output, "]"
예제 #57
0
파일: util.py 프로젝트: nulledge/bilinear
def rand(x):
    return max(-2 * x, min(2 * x, gauss(0, 1) * x))
예제 #58
0
def noise():
    '''a noise vector'''
    from random import gauss
    v = Vector3(gauss(0, 1), gauss(0, 1), gauss(0, 1))
    v.normalize()
    return v * opts.noise
import torch
from torchvision.transforms import ToTensor
import numpy as np
import random

# Building random datasets of 100 elements in each class
# Building 1st dataset
n = 100
values1 = []
frequencies1 = {}
while len(values1) < n:
    value = random.gauss(5, 4)
    if 0 < value < 10:
        frequencies1[int(value)] = frequencies1.get(int(value), 0) + 1
        values1.append(value)

values1 = np.array(values1)
label1 = np.zeros(100).astype(int)
class1 = np.array([values1, label1]).T

# Building 2nd dataset
values2 = []
frequencies2 = {}
while len(values2) < n:
    value = random.gauss(15, 4)
    if 8 < value < 18:
        frequencies2[int(value)] = frequencies2.get(int(value), 0) + 1
        values2.append(value)

values2 = np.array(values2)
label2 = np.ones(100).astype(int)
예제 #60
0
 def random_point(self):
     c = self.center
     ll, ul = self.limits
     x, y, z = (gauss(0, 1), gauss(0, 1), gauss(0, 1))
     r = (uniform(ll[0]**3, ul[0]**3)**(1 / 3) / sqrt(x**2 + y**2 + z**2))
     return [r * x + c[0], r * y + c[1], r * z + c[2]]