Beispiel #1
0
    def spatial_corr(self, cross_len = 2.0, nos = 80):
        """Spatial Correlatoin, cross length (corss_len) is assigned as two lambdas by default.  nos means number of sections."""
        self.spatial_correlation = []
        spatial_max = 0
        step = float(cross_len) / nos
        for each in range(nos + 1):
            temp = 0
            for k, each_AoA in enumerate(self.AoA_all):
                each_step = each*step*sine(each_AoA/180.0*PI)*2*PI
                phase = cosine(each_step) + 1j*sine(each_step)
                temp = temp + self.power_from_BS_to_UE_V[k]*phase
            self.spatial_correlation.append(abs(temp))
        self.spatial_correlation = [each / self.spatial_correlation[0] for each in self.spatial_correlation]

        step_tenth_lambda = 0.1
        step_half_lambda = 0.5
        step_full_lambda = 1.0
        self.power_from_BS_to_UE_tenth_lambda = []
        self.power_from_BS_to_UE_half_lambda = []
        self.power_from_BS_to_UE_full_lambda = []
        for k, each_AoA in enumerate(self.AoA_all):
            step = step_tenth_lambda*sine(each_AoA/180.0*PI)*2*PI
            phase = cosine(step) + 1j*sine(step)            
            self.power_from_BS_to_UE_tenth_lambda.append(self.power_from_BS_to_UE_V[k]*phase)
            
            step = step_half_lambda*sine(each_AoA/180.0*PI)*2*PI
            phase = cosine(step) + 1j*sine(step)
            self.power_from_BS_to_UE_half_lambda.append(self.power_from_BS_to_UE_V[k]*phase)
            
            step = step_full_lambda*sine(each_AoA/180.0*PI)*2*PI
            phase = cosine(step) + 1j*sine(step)
            self.power_from_BS_to_UE_full_lambda.append(self.power_from_BS_to_UE_V[k]*phase)
Beispiel #2
0
def print_math():
    """ Prints some calculated values. """
    x = math.cosine(Pi)
    print(x)

    y = math.sine(Pi)
    print("The sine of PI is", y)
def make_planet(ox,oy,r,texture):
    if ox + rad > 0 and ox - rad < xSize:
        for y in range(oy - r + 1, oy + r):
            ncol = int((y - oy + r)/(r/len(texture))/2)
            
            r2 = sqrt(r**2 - (y - oy)**2)
            c = 2*3.141*r2
            n = len(texture[ncol])

            n/=2
            for i in range(int(n)):
                icol = i
                while icol >= 2*n:
                    icol = int(i - 2*n)
                if r2 == 0: r2 = 0.000001
                x = r2*cosine(i*c/(2*n)/r2) - r2*cosine(i*c/(2*n)/r2 + c/(2*n)/r2)
                x1 = r2 - r2*cosine(i*c/(2*n)/r2)
                pygame.draw.line(screen, texture[ncol][icol], (ox - r2 + x1, y), (ox - r2 + x1 + x, y))
Beispiel #4
0
    def spatial_corr(self, cross_len=2.0, nos=80):
        """Spatial Correlatoin, cross length (corss_len) is assigned as two lambdas by default.  nos means number of sections."""
        self.spatial_correlation = []
        spatial_max = 0
        step = float(cross_len) / nos
        for each in range(nos + 1):
            temp = 0
            for k, each_AoA in enumerate(self.AoA_all):
                each_step = each * step * sine(each_AoA / 180.0 * PI) * 2 * PI
                phase = cosine(each_step) + 1j * sine(each_step)
                temp = temp + self.power_from_BS_to_UE_V[k] * phase
            self.spatial_correlation.append(abs(temp))
        self.spatial_correlation = [
            each / self.spatial_correlation[0]
            for each in self.spatial_correlation
        ]

        step_tenth_lambda = 0.1
        step_half_lambda = 0.5
        step_full_lambda = 1.0
        self.power_from_BS_to_UE_tenth_lambda = []
        self.power_from_BS_to_UE_half_lambda = []
        self.power_from_BS_to_UE_full_lambda = []
        for k, each_AoA in enumerate(self.AoA_all):
            step = step_tenth_lambda * sine(each_AoA / 180.0 * PI) * 2 * PI
            phase = cosine(step) + 1j * sine(step)
            self.power_from_BS_to_UE_tenth_lambda.append(
                self.power_from_BS_to_UE_V[k] * phase)

            step = step_half_lambda * sine(each_AoA / 180.0 * PI) * 2 * PI
            phase = cosine(step) + 1j * sine(step)
            self.power_from_BS_to_UE_half_lambda.append(
                self.power_from_BS_to_UE_V[k] * phase)

            step = step_full_lambda * sine(each_AoA / 180.0 * PI) * 2 * PI
            phase = cosine(step) + 1j * sine(step)
            self.power_from_BS_to_UE_full_lambda.append(
                self.power_from_BS_to_UE_V[k] * phase)
Beispiel #5
0
 def ani(self, cross_len = 2.0, nos = 80):
     """cross length (corss_len) is assigned as two lambdas by default.  nos means number of sections."""
     self.ani_x = {}
     self.ani_y = {}
     spatial_max = 0
     delta = float(cross_len) / nos
     
     for n in range(nos + 1):
         step = n*delta
         data = []
         for k, each_AoA in enumerate(self.AoA_all):
             step2 = step*sine(each_AoA/180.0*PI)*2*PI
             phase = cosine(step2) + 1j*sine(step2)
             data.append(self.power_from_BS_to_UE_V[k]*phase)
             self.ani_x[n] = np.array([each.real for each in data])
             self.ani_y[n] = np.array([each.imag for each in data])
def set_effect(selection,
               value_args,
               fade=0,
               curve='linear',
               verbose=False,
               cuelist_mode=False):
    # [selection, parameter, formula, amplitude, absolute/relative, vertical shift, horizontal shift, spread, buddy]
    formula = {
        'sine':
        lambda x, amp, absrel, ver, hor, freq: amp * math.sin(freq * x),
        'cosine': lambda x: math.cosine(x),
        'ramp': lambda x: x % 1
    }

    def effect():
        return

    timer = time.perf_counter()
    while True:
        deltaTime = time.perf_counter() - timer
        if CLIENT_CONNECTION_STATUS: dClient.write(new_values)
    return
    def _do_wave_processing(self):
        while self.keep_peripheral_threads_alive:
            if self.hub_node.current_mode == ModeChange.WAVE:
                self.wave_update_change_mutex.acquire()
                try:
                    self.wave_position = self.wave_position + self.wave_position_increment
                    while self.wave_position >= _2PI:
                        self.wave_position = self.wave_position - _2PI

                    id_intensity_pairs = []
                    for p_id, p_location in self.hub_node.participant_locations:
                        intensity = cosine(p_location - self.wave_position)
                        if intensity < WAVE_NEGLIGIBLE_THRESHOLD:
                            intensity = 0.0

                        id_intensity_pairs.append((p_id, intensity))

                    self.hub_node.send_wave_update(id_intensity_pairs)
                finally:
                    self.wave_update_change_mutex.release()

            sleep(WAVE_UPDATE_WAIT_TIME_S)
Beispiel #8
0
    def __init__(self):
        Power_array = [0, -2.2, -1.7, -5.2, -9.1, -12.5]
        Power_array = [10**(each/10.0) for each in Power_array]
        N_path = len(Power_array)  ## number of clusters
        AoA_array = [65.7, 45.6, 143.2, 32.5, -91.1, -19.2]
        AoD_array = [82,   80.5, 79.6,  98.6, 102.1, 107.1]
        AS_AoD = 5.0
        AS_AoA = 35.0
        self.Frequency = 7.51e6  ## in Hz
        self.V_MA = 100000.0 / 60 / 60    ## 100km/hr, mobile speed in m/s
        self.V_direction = 120.0
        XPR = 9           ## in dB

        subpath10_1 = [-75.4274, -53.1816, -40.1824, -30.9538, -23.7899, -17.9492, -13.0045, -8.7224, -4.9447, -1.4649]
        subpath10_2 = [-1*each for each in subpath10_1[::-1]]
        subpath20 = subpath10_1 + subpath10_2
        subpath20_AoA = list(subpath20)        
        subpath20_AoD = [each / AS_AoA * AS_AoD for each in subpath20] ## normalizaing subpath, so can be extened later for either AoA or AoD

        self.AoD_all = []
        for each_AoD in AoD_array:
            for each_subpath in subpath20_AoD:
                self.AoD_all.append(each_AoD + each_subpath)

        self.AoA_all = []
        for each_AoA in AoA_array:
            for each_subpath in subpath20_AoA:
                self.AoA_all.append(each_AoA + each_subpath)

        ## BS antenna model
        V_power_BS = [ 0.5 for each in range(120)]
        H_power_BS = [ pow(cosine(each/180.0*PI), 2) for each in self.AoD_all]

        self.V_power_BS = V_power_BS
        self.H_power_BS = H_power_BS
        
        ## XPR
        XPR = 10**(XPR/10.0)
        co_pol = XPR / (XPR + 1.0)
        cr_pol = 1 / (XPR + 1.0)

        ## BS power after XPR
        power_from_BS_V = [ V_power_BS[i]*co_pol + H_power_BS[i]*cr_pol for i in range(120) ]
        power_from_BS_H = [ H_power_BS[i]*co_pol + V_power_BS[i]*cr_pol for i in range(120) ]

        self.power_from_BS_V = power_from_BS_V
        self.power_from_BS_H = power_from_BS_H

        ## calculate the V and H power on each subpath from BS to the UE
        power_array_all = []
        for each in Power_array:
            for each_subpath in range(20):
                power_array_all.append(each/20.0)
        self.power_from_BS_to_UE_V = []
        self.power_from_BS_to_UE_H = []
        
        for each in range(120):
            self.power_from_BS_to_UE_V.append( power_from_BS_V[each]*power_array_all[each] )
            self.power_from_BS_to_UE_H.append( power_from_BS_H[each]*power_array_all[each] )

        self.cross_pol = 10*log10(sum(self.power_from_BS_to_UE_V) / sum(self.power_from_BS_to_UE_H))
Beispiel #9
0
#The script is supposed to print out the cosine of 90
import math
print(math.cosine(1))
Beispiel #10
0
import random  # fully

for i in range(5):
    value = random.randint(1, 6)
    print(value)

from math import pi  #just one

print(pi)

from math import sqrt, cos  #various
import math

print(math.cos == cos)

from math import sqrt as square_root  #import as a diferent name

print(square_root(100))
from math import sqrt as square_root, cos as cosine, tan as tangent

print(square_root(49))
print(cosine(0))
print(tangent(45))

print(dir(math))

import math as m

print(math.sqrt(25))
# +
# Import anything, and use it with the dot accessor.
import math

a = math.cos(4 * math.pi)

# You can also selectively import things.
from math import pi

b = 3 * pi

# And even rename them if you don't like their name.
from math import cos as cosine

c = cosine(b)
# -

# How to know what is available?
#
# 1. Read the [documentation](https://docs.python.org/3/library/math.html)
# 2. Interactively query the module

print(dir(math))

# Typing the dot and the TAB will kick off tab-completion.

# math.

# In the IPython framework you can also use a question mark to view the documentation of modules and functions.
Beispiel #12
0
from math import cos as cosine, pi as piGreco

print(2 * cosine(30))

print(piGreco)

Beispiel #13
0
    def __init__(self):
        Power_array = [0, -2.2, -1.7, -5.2, -9.1, -12.5]
        Power_array = [10**(each/10.0) for each in Power_array]
        N_path = len(Power_array)  ## number of clusters
        AoA_array = [65.7, 45.6, 143.2, 32.5, -91.1, -19.2]
        AoD_array = [82,   80.5, 79.6,  98.6, 102.1, 107.1]
        AS_AoD = 5.0
        AS_AoA = 35.0
        self.Frequency = 7.51e6  ## in Hz
        self.V_MA = 100000.0 / 60 / 60    ## 100km/hr, mobile speed in m/s
        self.V_direction = 120.0
        XPR = 9           ## in dB

        subpath10_1 = [-75.4274, -53.1816, -40.1824, -30.9538, -23.7899, -17.9492, -13.0045, -8.7224, -4.9447, -1.4649]
        subpath10_2 = [-1*each for each in subpath10_1[::-1]]
        subpath20 = subpath10_1 + subpath10_2
        subpath20_AoA = list(subpath20)        
        subpath20_AoD = [each / AS_AoA * AS_AoD for each in subpath20] ## normalizaing subpath, so can be extened later for either AoA or AoD

        self.AoD_all = []
        for each_AoD in AoD_array:
            for each_subpath in subpath20_AoD:
                self.AoD_all.append(each_AoD + each_subpath)

        self.AoA_all = []
        for each_AoA in AoA_array:
            for each_subpath in subpath20_AoA:
                self.AoA_all.append(each_AoA + each_subpath)

        ## BS antenna model
        V_power_BS = [ 0.5 for each in range(120)]
        H_power_BS = [ pow(cosine(each/180.0*PI), 2) for each in self.AoD_all]

        self.V_power_BS = V_power_BS
        self.H_power_BS = H_power_BS
        
        ## XPR
        XPR = 10**(XPR/10.0)
        co_pol = XPR / (XPR + 1.0)
        cr_pol = 1 / (XPR + 1.0)

        ## BS power after XPR
        power_from_BS_V = [ V_power_BS[i]*co_pol + H_power_BS[i]*cr_pol for i in range(120) ]
        power_from_BS_H = [ H_power_BS[i]*co_pol + V_power_BS[i]*cr_pol for i in range(120) ]

        self.power_from_BS_V = power_from_BS_V
        self.power_from_BS_H = power_from_BS_H

        ## calculate the V and H power on each subpath from BS to the UE
        power_array_all = []
        for each in Power_array:
            for each_subpath in range(20):
                power_array_all.append(each/20.0)
        self.power_from_BS_to_UE_V = []
        self.power_from_BS_to_UE_H = []
        
        for each in range(120):
            self.power_from_BS_to_UE_V.append( power_from_BS_V[each]*power_array_all[each] )
            self.power_from_BS_to_UE_H.append( power_from_BS_H[each]*power_array_all[each] )

        self.cross_pol = 10*log10(sum(self.power_from_BS_to_UE_V) / sum(self.power_from_BS_to_UE_H))
def cal(X, Y):
    C = cosine(X)
    S = sine(Y)
    print('The Cosine is:', C, ', and the Sine is:', S)
    return C, S
def cos(deg):
    return cosine(radians(deg))
Beispiel #16
0
 if d >= 11: rad = int(pythag(ySize,xSize)*degrees(atan(r/(d - 8)))/150)
 else: rad = int(pythag(ySize,xSize)*degrees(atan(r/(d*d*d*3/1331)))/150)
 
 #Stars
 for star in stars:
     origx = star[0]
     origy = star[1]
     star[0] += 90
     star[1] -= ySize/2
     col = [star[2],star[2],star[2]]
     odist = sqrt(pow(star[1]*fov/xSize,2) + pow(star[0] - 90 - angle,2))
     if odist < 2*rad*fov/xSize:
         #col = [255,0,0]
         arg = atan2(star[1]*fov/xSize, star[0] - 90 - angle)
         dist = pow(odist,2)/(4*rad*fov/xSize) + rad*fov/xSize
         star[0] = angle + 90 + dist*cosine(arg)
         star[1] = dist*sine(arg)*xSize/fov
         #if star[0] - 90 > angle: star[0] = angle + 90 + pow(star[0] - 90 - angle,2)/(4*rad*fov/xSize) + rad*fov/xSize
         #elif star[0] - 90 < angle: star[0] = angle + 90 - pow(star[0] - 90 - angle,2)/(4*rad*fov/xSize) - rad*fov/xSize
         #print(angle, rad*fov/xSize, arg, odist, dist, origx, origy, star[0], star[1])
         
     for n in range(-1,2):
         screen.set_at((int(xSize/2 + (star[0] + offset + 360*n)/fov*xSize), int(star[1] + ySize/2) + 1), col)
         screen.set_at((int(xSize/2 + (star[0] + offset + 360*n)/fov*xSize), int(star[1] + ySize/2) - 1), col)
         screen.set_at((int(xSize/2 + (star[0] + offset + 360*n)/fov*xSize), int(star[1] + ySize/2)), col)
         screen.set_at((int(xSize/2 + (star[0] + offset + 360*n)/fov*xSize + 1), int(star[1] + ySize/2)), col)
         screen.set_at((int(xSize/2 + (star[0] + offset + 360*n)/fov*xSize - 1), int(star[1] + ySize/2)), col)
     star[0] = origx
     star[1] = origy
 
 for c in collect:
Beispiel #17
0
def cos(deg): return cosine(radians(deg))

def pythag(a,b):
Beispiel #18
0
# import modules and use .var to call functions and variables
# you can import specific methods or variables with from __ import __

# how can you tell what is in the module?
# is there a module reference?

import random
from math import pi, sqrt, cos as cosine

for i in range(1, 11):
    print(random.randint(1, 20))

print pi
print sqrt(36)
print cosine(pi)


def print_nums(x):
    for i in range(x):
        print(i)
        return


print_nums(10)
Beispiel #19
0
def cos(degrees):
    return(cosine(radians(degrees)))