コード例 #1
0
ファイル: hw3.py プロジェクト: srikanth235/Matrix
def dot_product_vec_mat_mult(v, M):
    assert v.D == M.D[0]
    result = Vec(M.D[1], {r: 0 for r in M.D[1]})
    cols = mat2coldict(M)
    for k in M.D[1]:
        result.f[k] = v * cols[k]
    return result
コード例 #2
0
ファイル: matrix.py プロジェクト: bcottman/Python3.4
def matrix_matrix_mul(A, B):
    """
    Returns the result of the matrix-matrix multiplication, A*B.

    >>> A = Mat(({0,1,2}, {0,1,2}), {(1,1):4, (0,0):0, (1,2):1, (1,0):5, (0,1):3, (0,2):2})
    >>> B = Mat(({0,1,2}, {0,1,2}), {(1,0):5, (2,1):3, (1,1):2, (2,0):0, (0,0):1, (0,1):4})
    >>> A*B == Mat(({0,1,2}, {0,1,2}), {(0,0):15, (0,1):12, (1,0):25, (1,1):31})
    True
    >>> C = Mat(({0,1,2}, {'a','b'}), {(0,'a'):4, (0,'b'):-3, (1,'a'):1, (2,'a'):1, (2,'b'):-2})
    >>> D = Mat(({'a','b'}, {'x','y'}), {('a','x'):3, ('a','y'):-2, ('b','x'):4, ('b','y'):-1})
    >>> C*D == Mat(({0,1,2}, {'x','y'}), {(0,'y'):-5, (1,'x'):3, (1,'y'):-2, (2,'x'):-5})
    True
    >>> M = Mat(({0, 1}, {'a', 'c', 'b'}), {})
    >>> N = Mat(({'a', 'c', 'b'}, {(1, 1), (2, 2)}), {})
    >>> M*N == Mat(({0,1}, {(1,1), (2,2)}), {})
    True
    >>> E = Mat(({'a','b'},{'A','B'}), {('a','A'):1,('a','B'):2,('b','A'):3,('b','B'):4})
    >>> F = Mat(({'A','B'},{'c','d'}),{('A','d'):5})
    >>> E*F == Mat(({'a', 'b'}, {'d', 'c'}), {('b', 'd'): 15, ('a', 'd'): 5})
    True
    >>> F.transpose()*E.transpose() == Mat(({'d', 'c'}, {'a', 'b'}), {('d', 'b'): 15, ('d', 'a'): 5})
    True
    """
    M = Mat((A.D[0],B.D[1]),{})
    v = Vec(B.D[0],{})   #each column of matrix B is a Rx1 vector
    for col in B.D[1]:
        v.f = {}   #init the function of the vector
        for row in B.D[0]:
            if (row,col) in B.f: 
                v.f[row] = B.f[row,col]
        M.f.update({(r,col):v for r,v in matrix_vector_mul(A, v).f.items() if v != 0})
    return M
コード例 #3
0
ファイル: geom_gl.py プロジェクト: ont/cbox
def draw_gl( self ):
    n = self.n
    r = self.r

    vt = Vec( 1,2,3 ).norm()
    if vt == n:
        vt = Vec( 3,2,1 ).norm()

    v1 = vt.vcross( n )
    v2 = v1.vcross( n )

    v1,v2,v3,v4 = r + v1+v2, r + v1-v2, r + v2-v1, r -v1-v2

    glBegin( GL_LINES )
    glVertex3f( *v1 )
    glVertex3f( *v4 )

    glVertex3f( *v2 )
    glVertex3f( *v3 )

    glVertex3f( *v1 )
    glVertex3f( *v2 )

    glVertex3f( *v1 )
    glVertex3f( *v3 )

    glVertex3f( *v3 )
    glVertex3f( *v4 )

    glVertex3f( *v2 )
    glVertex3f( *v4 )

    glEnd( )
コード例 #4
0
ファイル: world.py プロジェクト: RyanHope/pyagar
 def __init__(self):
     self.cells = {}
     self.leaderboard_names = []
     self.leaderboard_groups = []
     self.top_left = Vec(0, 0)
     self.bottom_right = Vec(0, 0)
     self.reset()
コード例 #5
0
def vector_matrix_mul(v, M):
    """
    returns the product of vector v and matrix M

    Consider using brackets notation v[...] in your procedure
    to access entries of the input vector.  This avoids some sparsity bugs.

    >>> v1 = Vec({1, 2, 3}, {1: 1, 2: 8})
    >>> M1 = Mat(({1, 2, 3}, {'a', 'b', 'c'}), {(1, 'b'): 2, (2, 'a'):-1, (3, 'a'): 1, (3, 'c'): 7})
    >>> v1*M1 == Vec({'a', 'b', 'c'},{'a': -8, 'b': 2, 'c': 0})
    True
    >>> v1 == Vec({1, 2, 3}, {1: 1, 2: 8})
    True
    >>> M1 == Mat(({1, 2, 3}, {'a', 'b', 'c'}), {(1, 'b'): 2, (2, 'a'):-1, (3, 'a'): 1, (3, 'c'): 7})
    True
    >>> v2 = Vec({'a','b'}, {})
    >>> M2 = Mat(({'a','b'}, {0, 2, 4, 6, 7}), {})
    >>> v2*M2 == Vec({0, 2, 4, 6, 7},{})
    True
    >>> v3 = Vec({'a','b'},{'a':1,'b':1})
    >>> M3 = Mat(({'a', 'b'}, {0, 1}), {('a', 1): 1, ('b', 1): 1, ('a', 0): 1, ('b', 0): 1})
    >>> v3*M3 == Vec({0, 1},{0: 2, 1: 2})
    True
    """
    assert M.D[0] == v.D
    result = Vec( M.D[1], {})
    for key in M.f :
        if result.f.get( key[1] ) == None : resultf = 0
        else : resultf = result.f.get( key[1] )
        if v.f.get(key[0]) == None : vf = 0
        else : vf = v.f.get(key[0])
        result.f[key[1]] = resultf + vf * M.f[key]

    return result
コード例 #6
0
def matrix_vector_mul(M, v):
    """
    Returns the product of matrix M and vector v.

    Consider using brackets notation v[...] in your procedure
    to access entries of the input vector.  This avoids some sparsity bugs.

    >>> N1 = Mat(({1, 3, 5, 7}, {'a', 'b'}), {(1, 'a'): -1, (1, 'b'): 2, (3, 'a'): 1, (3, 'b'):4, (7, 'a'): 3, (5, 'b'):-1})
    >>> u1 = Vec({'a', 'b'}, {'a': 1, 'b': 2})
    >>> N1*u1 == Vec({1, 3, 5, 7},{1: 3, 3: 9, 5: -2, 7: 3})
    True
    >>> N1 == Mat(({1, 3, 5, 7}, {'a', 'b'}), {(1, 'a'): -1, (1, 'b'): 2, (3, 'a'): 1, (3, 'b'):4, (7, 'a'): 3, (5, 'b'):-1})
    True
    >>> u1 == Vec({'a', 'b'}, {'a': 1, 'b': 2})
    True
    >>> N2 = Mat(({('a', 'b'), ('c', 'd')}, {1, 2, 3, 5, 8}), {})
    >>> u2 = Vec({1, 2, 3, 5, 8}, {})
    >>> N2*u2 == Vec({('a', 'b'), ('c', 'd')},{})
    True
    >>> M3 = Mat(({0,1},{'a','b'}),{(0,'a'):1, (0,'b'):1, (1,'a'):1, (1,'b'):1})
    >>> v3 = Vec({'a','b'},{'a':1,'b':1})
    >>> M3*v3 == Vec({0, 1},{0: 2, 1: 2})
    True
    """
    assert M.D[1] == v.D
    result = Vec( M.D[0], {})
    for key in M.f :
        if result.f.get( key[0] ) == None : resultf = 0
        else : resultf = result.f.get( key[0] )
        if v.f.get(key[1]) == None : vf = 0
        else : vf = v.f.get(key[1])
        result.f[key[0]] = resultf + vf * M.f[key]

    return result
コード例 #7
0
ファイル: hw3.py プロジェクト: srikanth235/Matrix
def dot_product_mat_vec_mult(M, v):
    assert M.D[1] == v.D
    result = Vec(M.D[0], {c: 0 for c in M.D[0]})
    rows = mat2rowdict(M)
    for k in M.D[0]:
        result.f[k] = rows[k] * v
    return result
コード例 #8
0
ファイル: simplex.py プロジェクト: imsukmin/codingTheMatrix
def simplex_step(A, b, c, R_square, show_bases=False):
    if show_bases: print("basis: ", R_square)
    R = A.D[0]
    # Extract the subsystem
    A_square = Mat((R_square, A.D[1]), {(r,c):A[r,c] for r,c in A.f if r in R_square})
    b_square = Vec(R_square, {k:b[k] for k in R_square})
    # Compute the current vertex
    x = solve(A_square, b_square)
    print("(value: ",c*x,") ",end="")
    # Compute a possibly feasible dual solution
    y_square = solve(A_square.transpose(), c) #compute entries with labels in R_square
    y = Vec(R, y_square.f) #Put in zero for the other entries
    if min(y.values()) >= -1e-10: return ('OPTIMUM', x) #found optimum!
    R_leave = {i for i in R if y[i]< -1e-10} #labels at which y is negative
    r_leave = min(R_leave, key=hash) #choose first label at which y is negative
    # Compute the direction to move
    d = Vec(R_square, {r_leave:1})
    w = solve(A_square, d)
    # Compute how far to move
    Aw = A*w # compute once because we use it many times
    R_enter = {r for r in R if Aw[r] < -1e-10}
    if len(R_enter)==0: return ('UNBOUNDED', None)
    Ax = A*x # compute once because we use it many times
    delta_dict = {r:(b[r] - Ax[r])/(Aw[r]) for r in R_enter}
    delta = min(delta_dict.values())
    # Compute the new tight constraint
    r_enter = min({r for r in R_enter if delta_dict[r] == delta}, key=hash)[0]
    # Update the set representing the basis
    R_square.discard(r_leave)
    R_square.add(r_enter)
    return ('STEP', None)
コード例 #9
0
ファイル: mat.py プロジェクト: LeonRaykin/MOOC
def vector_matrix_mul(v, M):
    "Returns the product of vector v and matrix M"
    assert M.D[0] == v.D
    new_vec = Vec(M.D[1], {i: 0 for i in M.D[1]})
    for i in new_vec.f:
        for j in M.D[1]:
            new_vec.f[i] = new_vec.f[i] + v.f.get(j, 0)*M.f.get((j, i), 0)
    return new_vec
コード例 #10
0
ファイル: mat.py プロジェクト: LeonRaykin/MOOC
def matrix_vector_mul(M, v):
    "Returns the product of matrix M and vector v"
    assert M.D[1] == v.D
    new_vec = Vec(M.D[0], {i: 0 for i in M.D[0]})
    for i in new_vec.f:
        for j in M.D[1]:
            new_vec.f[i] = new_vec.f[i] + v.f.get(j, 0)*M.f.get((i, j), 0)
    return new_vec
コード例 #11
0
ファイル: hw3.py プロジェクト: buptdjd/linearAlgebra-coursera
def dot_product_mat_vec_mult(M, v):
    assert(M.D[1] == v.D)

    new_v = Vec(M.D[0], {})

    row_dict = matutil.mat2rowdict(M)

    for key, val in row_dict.items():
        new_v.f[key] = val * v

    return new_v
コード例 #12
0
ファイル: mat.py プロジェクト: AamirManasawala/matrics
def matrix_vector_mul(M, v):
    "Returns the product of matrix M and vector v"
    assert M.D[1] == v.D
    resultVec = Vec(M.D[0],dict())
    for k in M.f.keys():
        if k[0] in resultVec.f:
            resultVec.f[k[0]] = resultVec.f[k[0]] + M[k[0],k[1]]*v[k[1]]
        else:
            resultVec.f[k[0]] = M[k[0],k[1]] * v[k[1]]
    return resultVec     
    pass
コード例 #13
0
ファイル: hw3.py プロジェクト: buptdjd/linearAlgebra-coursera
def dot_product_vec_mat_mult(v, M):
    assert(v.D == M.D[0])

    new_v = Vec(M.D[1], {})

    col_dict = matutil.mat2coldict(M)

    for key, val in col_dict.items():
        new_v.f[key] = v * val

    return new_v
コード例 #14
0
ファイル: hw3.py プロジェクト: iryek219/LinearAlgebra_python
def extract_col(M, column):
    '''
    Takes a matrix, M and a col key from that matrix and returns a vector
    representing that col.
    '''
    assert column in M.D[1]
    v = Vec(M.D[0], {})
    for row in M.D[0]:
        key = (row, column)
        if key in M.f:
            v.f[row] = M.f[key]
    return v
コード例 #15
0
ファイル: mat.py プロジェクト: iryek219/LinearAlgebra_python
def extract_row(M, row):
    """
    Takes a matrix, M and a row key from that matrix and returns a vector
    representing that row.
    """
    assert row in M.D[0]
    v = Vec(M.D[1], {})
    for column in M.D[1]:
        key = (row, column)
        if key in M.f:
            v.f[column] = M.f[key]
    return v
コード例 #16
0
ファイル: mat.py プロジェクト: buptdjd/linearAlgebra-coursera
def vector_matrix_mul(v, M):
    "Returns the product of vector v and matrix M"
    assert M.D[0] == v.D

    ret_v = Vec(M.D[1], {})

    for d in ret_v.D:
        ret_v.f[d] = 0

    for (k1, k2), val in M.f.items():
        ret_v.f[k2] += val * v[k1]

    return ret_v
コード例 #17
0
ファイル: mat.py プロジェクト: buptdjd/linearAlgebra-coursera
def matrix_vector_mul(M, v):
    "Returns the product of matrix M and vector v"
    assert M.D[1] == v.D

    ret_v = Vec(M.D[0], {})

    for d in ret_v.D:
        ret_v.f[d] = 0

    for (k1, k2), val in M.f.items():
        ret_v.f[k1] += val * v[k2]

    return ret_v
コード例 #18
0
ファイル: hw2.py プロジェクト: RohinBhargava/Matrix
def vec_sum(veclist, D): 
    '''
    >>> D = {'a','b','c'}
    >>> v1 = Vec(D, {'a': 1})
    >>> v2 = Vec(D, {'a': 0, 'b': 1})
    >>> v3 = Vec(D, {        'b': 2})
    >>> v4 = Vec(D, {'a': 10, 'b': 10})
    >>> vec_sum([v1, v2, v3, v4], D) == Vec(D, {'b': 13, 'a': 11})
    True
    '''
    sumvec = Vec(D, {})
    for k in D:
        sumvec.f[k] = sum(getitem(g,k) for g in veclist)
    return sumvec
コード例 #19
0
def find_matrix_inverse(A):
    '''
    input: An invertible matrix, A, over GF(2)
    output: Inverse of A

    >>> M = Mat(({0, 1, 2}, {0, 1, 2}), {(0, 1): one, (1, 2): 0, (0, 0): 0, (2, 0): 0, (1, 0): one, (2, 2): one, (0, 2): 0, (2, 1): 0, (1, 1): 0})
    >>> find_matrix_inverse(M) == Mat(({0, 1, 2}, {0, 1, 2}), {(0, 1): one, (2, 0): 0, (0, 0): 0, (2, 2): one, (1, 0): one, (1, 2): 0, (1, 1): 0, (2, 1): 0, (0, 2): 0})
    True
    '''
    b_vecs = list()
    id_vec = Vec(A.D[1], { })
    for c in A.D[1]:
        id_vec.f = { c:one }
        b_vecs.append(solve(A, id_vec))
    return coldict2mat(b_vecs)
コード例 #20
0
def make_Vec(primeset, factors):
    '''
    Input:
        - primeset: a set of primes
        - factors: a list of factors [(p_1,a_1), ..., (p_n, a_n)]
                   with p_i in primeset
    Output:
        - a vector v over GF(2) with domain primeset
          such that v[p_i] = int2GF2(a_i) for all i
    Example:
        >>> make_Vec({2,3,11}, [(2,3), (3,2)]) == Vec({2,3,11},{2:one})
        True
    '''
    return_vec = Vec(primeset,{})
    for each in factors:
        return_vec.f[each[0]] = int2GF2(each[1])
    return return_vec
コード例 #21
0
ファイル: ecc_lab.py プロジェクト: srikanth235/Matrix
def find_error(e):
    """
    Input: an error syndrome as an instance of Vec
    Output: the corresponding error vector e
    Examples:
        >>> find_error(Vec({0,1,2}, {0:one}))
        Vec({0, 1, 2, 3, 4, 5, 6},{3: one})
        >>> find_error(Vec({0,1,2}, {2:one}))
        Vec({0, 1, 2, 3, 4, 5, 6},{0: one})
        >>> find_error(Vec({0,1,2}, {1:one, 2:one}))
        Vec({0, 1, 2, 3, 4, 5, 6},{2: one})    
    """
    result = Vec({0,1,2,3,4,5,6},{})
    cols = mat2coldict(H)
    for k,v in cols.items():
        if e==v:
            result.f[k] = one
    return result
コード例 #22
0
ファイル: mat.py プロジェクト: iryek219/LinearAlgebra_python
def extract_col(M, column):
    '''
    Takes a matrix, M and a col key from that matrix and returns a vector
    representing that col.
    '''
    
    list_rc_M = [(r,c) for r in M.D[0] for c in M.D[1] ]
    for (d1,d2) in list_rc_M:
        if not ((d1,d2) in M.f):
            M.f[d1,d2]=0
        else:
            pass
    #assert column in M.D[1]
    v = Vec(M.D[0], {})
    for row in M.D[0]:
        key = (row, column)
        if key in M.f:
            v.f[row] = M.f[key]
    return v
コード例 #23
0
def find_triangular_matrix_inverse(A): 
    '''
    input: An upper triangular Mat, A, with nonzero diagonal elements
    output: Inverse of A
    >>> A = listlist2mat([[1, .5, .2, 4],[0, 1, .3, .9],[0,0,1,.1],[0,0,0,1]])
    >>> find_triangular_matrix_inverse(A) == Mat(({0, 1, 2, 3}, {0, 1, 2, 3}), {(0, 1): -0.5, (1, 2): -0.3, (3, 2): 0.0, (0, 0): 1.0, (3, 3): 1.0, (3, 0): 0.0, (3, 1): 0.0, (2, 1): 0.0, (0, 2): -0.05000000000000002, (2, 0): 0.0, (1, 3): -0.87, (2, 3): -0.1, (2, 2): 1.0, (1, 0): 0.0, (0, 3): -3.545, (1, 1): 1.0})
    True
    '''
    b = Vec(A.D[1], {})
    rowList = [ mat2rowdict(A)[i] for i in A.D[1] ]
    colList = list()
    for i in A.D[1]:
        b.f = { i:1 }
        colList.append(triangular_solve_n(rowList, b))
    return coldict2mat(colList)

# A = listlist2mat([[1, .5, .2, 4],[0, 1, .3, .9],[0,0,1,.1],[0,0,0,1]])
# print(A)
# print(mat2rowdict(A))
# print(find_triangular_matrix_inverse(A))
# print(A*find_triangular_matrix_inverse(A))
# print(find_triangular_matrix_inverse(A) == Mat(({0, 1, 2, 3}, {0, 1, 2, 3}), {(0, 1): -0.5, (1, 2): -0.3, (3, 2): 0.0, (0, 0): 1.0, (3, 3): 1.0, (3, 0): 0.0, (3, 1): 0.0, (2, 1): 0.0, (0, 2): -0.05000000000000002, (2, 0): 0.0, (1, 3): -0.87, (2, 3): -0.1, (2, 2): 1.0, (1, 0): 0.0, (0, 3): -3.545, (1, 1): 1.0}))
コード例 #24
0
ファイル: world.py プロジェクト: RyanHope/pyagar
class Cell(object):
    def __init__(self, *args, **kwargs):
        self.pos = Vec()
        self.update(*args, **kwargs)

    def update(self, cid=-1, x=0, y=0, size=0, name='',
               color=(1, 0, 1), is_virus=False, is_agitated=False, skin_url=''):
        self.cid = cid
        self.pos.set(x, y)
        self.size = size
        self.mass = size ** 2 / 100.0
        self.name = getattr(self, 'name', name) or name
        self.color2 = color
        self.color = tuple(map(lambda rgb: rgb / 255.0, color))
        self.is_virus = is_virus
        self.is_agitated = is_agitated
        self.skin_url = skin_url

    @property
    def is_food(self):
        return self.size < 20 and not self.name

    @property
    def is_ejected_mass(self):
        return self.size in (37, 38) and not self.name

    def same_player(self, other):
        """
        Compares name and color.
        Returns True if both are owned by the same player.
        """
        return self.name == other.name \
            and self.color == other.color

    def __lt__(self, other):
        if self.mass != other.mass:
            return self.mass < other.mass
        return self.cid < other.cid
コード例 #25
0
ファイル: matrix.py プロジェクト: bcottman/Python3.4
def vector_matrix_mul(v, M):
    """
    returns the product of (1xn) vector v and matrix M

    >>> v1 = Vec({1, 2, 3}, {1: 1, 2: 8})
    >>> M1 = Mat(({1, 2, 3}, {'a', 'b', 'c'}), {(1, 'b'): 2, (2, 'a'):-1, (3, 'a'): 1, (3, 'c'): 7})
    >>> v1*M1 == Vec({'a', 'b', 'c'},{'a': -8, 'b': 2, 'c': 0})
    True
    >>> v1 == Vec({1, 2, 3}, {1: 1, 2: 8})
    True
    >>> M1 == Mat(({1, 2, 3}, {'a', 'b', 'c'}), {(1, 'b'): 2, (2, 'a'):-1, (3, 'a'): 1, (3, 'c'): 7})
    True
    >>> v2 = Vec({'a','b'}, {})
    >>> M2 = Mat(({'a','b'}, {0, 2, 4, 6, 7}), {})
    >>> v2*M2 == Vec({0, 2, 4, 6, 7},{})
    True
    """
    assert M.D[0] == v.D
    nv = Vec(M.D[1],{})  # column labels are now domain
    if len(v.f) == 0:    # if function is empty, retutn empty function in vector
        return nv 
    listv = [0]*len(v.D)   # create a list a long a vector filled with zeros  
    vcsd = list(v.D)       # create a list of vector coumn domain
    lmr  = list(M.D[0])    # create a list of matrix rows
    nc = len(M.D[0])# number of rows
    for i in range(len(v.D)):
        vcn = vcsd[i]
        if vcn in v.f:
            listv[i] = v.f[vcn] #actal f(x) FOR X, remember speed hack init with 0, dont have to set 0
    for mcn in M.D[1]:
        listim = [0]*nc
        for i in range(nc):
            mrn = lmr[i]
            if (mrn,mcn) in M.f:
                listim[i] = M.f[mrn,mcn] #actal f(x) FOR X
        nv.f[mcn] = sum(a*b for a,b in zip(listim,listv))
    return nv
コード例 #26
0
ファイル: matrix.py プロジェクト: bcottman/Python3.4
def matrix_vector_mul(M, v):
    """
    Returns the product of matrix M and (nx1) vector v.
    >>> N1 = Mat(({1, 3, 5, 7}, {'a', 'b'}), {(1, 'a'): -1, (1, 'b'): 2, (3, 'a'): 1, (3, 'b'):4, (7, 'a'): 3, (5, 'b'):-1})
    >>> u1 = Vec({'a', 'b'}, {'a': 1, 'b': 2})
    >>> N1*u1 == Vec({1, 3, 5, 7},{1: 3, 3: 9, 5: -2, 7: 3})
    True
    >>> N1 == Mat(({1, 3, 5, 7}, {'a', 'b'}), {(1, 'a'): -1, (1, 'b'): 2, (3, 'a'): 1, (3, 'b'):4, (7, 'a'): 3, (5, 'b'):-1})
    True
    >>> u1 == Vec({'a', 'b'}, {'a': 1, 'b': 2})
    True
    >>> N2 = Mat(({('a', 'b'), ('c', 'd')}, {1, 2, 3, 5, 8}), {})
    >>> u2 = Vec({1, 2, 3, 5, 8}, {})
    >>> N2*u2 == Vec({('a', 'b'), ('c', 'd')},{})
    True
    """
    assert M.D[1] == v.D
    nv = Vec(M.D[0],{})  # row labels are now domain
    if len(v.f) == 0:    # if function is empty, retutn empty function in vector
        return nv 
    listv = [0]*len(v.D)   # create a list a long a vector filles with zeros  
    vrs = v.D.copy() 
    lmc  = list(M.D[1])
    nc = len(M.D[1])        
    for i in range(len(v.D)):
        vrn = vrs.pop()
        if vrn in v.f:
            listv[i] = v.f[vrn] #actal f(x) FOR X 
    for mrn in M.D[0]:
        listim = [0]*nc
        for i in range(nc):
            mcn = lmc[i]
            if (mrn,mcn) in M.f:
                listim[i] = M.f[mrn,mcn] #actal f(x) FOR X
        nv.f[mrn] = sum(a*b for a,b in zip(listim,listv))
    return nv
コード例 #27
0
ファイル: world.py プロジェクト: RyanHope/pyagar
class World(object):
    cell_class = Cell

    def __init__(self):
        self.cells = {}
        self.leaderboard_names = []
        self.leaderboard_groups = []
        self.top_left = Vec(0, 0)
        self.bottom_right = Vec(0, 0)
        self.reset()

    def reset(self):
        """
        Clears the `cells` and leaderboards, and sets all corners to `0,0`.
        """
        self.cells.clear()
        del self.leaderboard_names[:]
        del self.leaderboard_groups[:]
        self.top_left.set(0, 0)
        self.bottom_right.set(0, 0)

    def create_cell(self, cid):
        """
        Creates a new cell in the world.
        Override to use a custom cell class.
        """
        self.cells[cid] = self.cell_class()

    @property
    def center(self):
        return Vec(self.size.x/2,self.size.y/2)

    @property
    def size(self):
        return self.top_left.abs() + self.bottom_right.abs()

    def __eq__(self, other):
        """Compares two worlds by comparing their leaderboards."""
        for ls, lo in zip(self.leaderboard_names, other.leaderboard_names):
            if ls != lo:
                return False
        for ls, lo in zip(self.leaderboard_groups, other.leaderboard_groups):
            if ls != lo:
                return False
        if self.top_left != other.top_left:
            return False
        if self.bottom_right != other.bottom_right:
            return False
        return True
コード例 #28
0
 def adjust(v,multipliers):
     return Vec(v.D,{i: v.f[i]*multipliers[i] if i in v.f else 0 for i in v.D})
コード例 #29
0
 def test_sub(self):
     vec = Vec(10, 0) / Vec(5, 1)
     self.assertEqual(vec, Vec(2, 0))
コード例 #30
0
def list2vec(L):
    return Vec(set(range(len(L))),
               {i: L[i]
                for i in range(len(L)) if L[i] != 0})
コード例 #31
0
 def test_sub(self):
     vec = Vec(10, 0) - Vec(5, 0)
     self.assertEqual(vec, Vec(5, 0))
コード例 #32
0
from bitutil import noise
from GF2 import one

## Task 1 part 1
""" Create an instance of Mat representing the generator matrix G. You can use
the procedure listlist2mat in the matutil module (be sure to import first).
Since we are working over GF (2), you should use the value one from the
GF2 module to represent 1"""
G = listlist2mat([[one, 0, one, one], [one, one, 0, one], [0, 0, 0, one],
                  [one, one, one, 0], [0, 0, one, 0], [0, one, 0, 0],
                  [one, 0, 0, 0]])
#print(G)

## Task 1 part 2
# Please write your answer as a list. Use one from GF2 and 0 as the elements.
encoding_1001 = G * Vec({0, 1, 2, 3}, {0: one, 3: one})
#print(encoding_1001)

## Task 2
# Express your answer as an instance of the Mat class.
#R = listlist2mat( [[1.0/8,1.0/8,-1.0/4,1.0/8,-1.0/4,-1.0/4,5.0/8],[-1.0/4,1.0/4,0,1.0/4,0,1.0/2,-1.0/4],[1.0/4,-1.0/4,0,1.0/4,1.0/2,0,-1.0/4],[1.0/4,1.0/4,1.0/2,-1.0/4,0,0,-1.0/4]])
R = listlist2mat([[0.125, 0.125, -0.25, 0.125, -0.25, -0.25, 0.625],
                  [-0.25, 0.25, 0, 0.25, 0, 0.5, -0.25],
                  [0.25, -0.25, 0, 0.25, 0.5, 0, -0.25],
                  [0.25, 0.25, 0.5, -0.25, 0, 0, -0.25]])
#print(R*G)

## Task 3
# Create an instance of Mat representing the check matrix H.
H = None
コード例 #33
0
        })
    v = Vec(
        D, {
            ('y2', 'x1'): -x1,
            ('y2', 'x2'): -x2,
            ('y2', 'x3'): -1,
            ('y3', 'x1'): w2 * x1,
            ('y3', 'x2'): w2 * x2,
            ('y3', 'x3'): w2
        })
    return [u, v]


## 4: () Scaling row
# This is the vector defining the scaling equation
w = Vec(D, {('y1', 'x1'): 1})

## 5: () Right-hand side
# Now construct the Vec b that serves as the right-hand side for the matrix-vector equation L*hvec=b
# This is the {0, ..., 8}-Vec whose entries are all zero except for a 1 in position 8
b = Vec({i for i in range(9)}, {8: 1})


## 6: () Rows of constraint matrix
def make_nine_equations(corners):
    '''
    input: a list of four tuples:
           [(i0,j0),(i1,j1),(i2,j2),(i3,j3)]
           where i0,j0 are the pixel coordinates of the top-left corner,
                 i1,j1 are the pixel coordinates of the bottom-left corner,
                 i2,j2 are the pixel coordinates of the top-right corner,
コード例 #34
0
These procedures use the list-of-lists-of-integers representation
of grayscale images.  This is the representation used by the image module.
"""

def import_faces(path=''):
    "call import_faces() to obtain a list of images of faces"
    faces = {}
    for i in range(1, 21):
        name = path + ('faces/img%02d.png' % i)
        print('Reading '+name)
        faces[i-1] = image.file2image(name)
    return faces

def import_unclassified(path=''):
    "call import_faces() to obtain a list of images of things including faces"
    unclassified = {}
    for i in range(1, 12):
        name = path + ('unclassified/img%02d.png' % i)
        print('Reading '+name)
        unclassified[i-1] = image.file2image(name)
    return unclassified

# Test data
M_d = ({0,1,2},{0,1})
M_f = {(0,0):1/sqrt(2) , (1,0):1/sqrt(2) , (0,1):1/sqrt(3), (1,1):-1/sqrt(3), (2,1):1/sqrt(3)}
test_M = Mat(M_d, M_f)
x_d = {0,1,2}
x_f = {0:10,1:20,2:30}
test_x = Vec(x_d, x_f)
コード例 #35
0
 ('y1', 'x1') ('y1', 'x2') ('y1', 'x3') ('y2', 'x1') ('y2', 'x2') ('y2', 'x3') ('y3', 'x1') ('y3', 'x2') ('y3', 'x3')
---------------------------------------------------------------------------------------------------------------------
            0            0            0          -18          -23           -1           18           23            1

    Again, the negations of these vectors form an equally valid solution.
    '''
    
    u = Vec(D, {('y1', 'x1'):(-x1), ('y1', 'x2'):(-x2), ('y1', 'x3'):(-1), ('y3', 'x1'):(w1*x1), ('y3', 'x2'):(w1*x2), ('y3', 'x3'):w1})
    v = Vec(D, {('y2', 'x1'):(-x1), ('y2', 'x2'):(-x2), ('y2', 'x3'):(-1), ('y3', 'x1'):(w2*x1), ('y3', 'x2'):(w2*x2), ('y3', 'x3'):w2})
    return [u, v]



## 4: () Scaling row
# This is the vector defining the scaling equation
w = Vec(D, {('y1', 'x1'):1})



## 5: () Right-hand side
# Now construct the Vec b that serves as the right-hand side for the matrix-vector equation L*hvec=b
# This is the {0, ..., 8}-Vec whose entries are all zero except for a 1 in position 8
b = Vec({0, 1, 2, 3, 4, 5, 6, 7, 8}, {8:1})



## 6: () Rows of constraint matrix
def make_nine_equations(corners):
    '''
    input: a list of four tuples:
           [(i0,j0),(i1,j1),(i2,j2),(i3,j3)]
コード例 #36
0
## 3: (Problem 12.14.3) Finding the eigenvalue associated with an eigenvector
# Part a
p3_part_a_eigenvalue1 = -1
p3_part_a_eigenvalue2 = 5

# Part b
p3_part_b_eigenvalue1 = 2
p3_part_b_eigenvalue2 = 5

## 4: (Problem 12.14.11) Markov chains and eigenvectors
# a Mat
D = {'S', 'R', 'F', 'W'}
transition_matrix = coldict2mat({
    'S': Vec(D, {
        'S': 0.5,
        'W': 0.3,
        'R': 0.2
    }),
    'W': Vec(D, {
        'S': 0.1,
        'W': 0.1,
        'F': 0.8
    }),
    'R': Vec(D, {
        'S': 0.2,
        'F': 0.2,
        'R': 0.6
    }),
    'F': Vec(D, {
        'W': 0.6,
        'F': 0.4
コード例 #37
0
ファイル: hw3.py プロジェクト: Shubashree/matrix_coding
your_answer_c_AB = [[6,0,0,0],[6,0,0,0],[8,0,0,0],[5,0,0,0]]
your_answer_c_BA = [[4,2,1,-1],[4,2,1,-1],[0,0,0,0],[0,0,0,0]]

your_answer_d_AB = [[0,3,0,4],[0,4,0,1],[0,4,0,4],[0,-6,0,-1]]
your_answer_d_BA = [[0,11,0,-2],[0,0,0,0],[0,0,0,0],[1,5,-2,3]]

your_answer_e_AB = [[0,3,0,8],[0,-9,0,2],[0,0,0,8],[0,15,0,-2]]
your_answer_e_BA = [[-2,12,4,-10],[0,0,0,0],[0,0,0,0],[-3,-15,6,-9]]

your_answer_f_AB = [[-4,4,2,-3],[-1,10,-4,9],[-4,8,8,0],[1,12,4,-15]]
your_answer_f_BA = [[-4,-2,-1,1],[2,10,-4,6],[8,8,8,0],[-3,18,6,-15]]



## Problem 10
column_row_vector_multiplication1 = Vec({0, 1}, {0:13,1:20})

column_row_vector_multiplication2 = Vec({0, 1, 2}, {0:24,1:11,2:4})

column_row_vector_multiplication3 = Vec({0, 1, 2, 3}, {0:4,1:8,2:11,3:3})

column_row_vector_multiplication4 = Vec({0,1}, {0:30,1:16})

column_row_vector_multiplication5 = Vec({0, 1, 2}, {0:-3,1:1,2:9})



## Problem 11
def lin_comb_mat_vec_mult(M, v):
    assert(M.D[1] == v.D)
    from matutil import mat2coldict
コード例 #38
0
#task 1
def move2board(y_vec):
    """function that maps the location of a point in the whiteboard plane not
    on the whiteboard to a point on the white board such that the line from the origin
    through the y_vec will intersect the whiteboard at the output point
    input must be a 'y1','y2','y3' vector.
    would have liked a more general function but I guess there's no situation where this
    applies where the labels aren't defined."""
    #return Vec(y_vec.D, {y_vec.D[0]:y_vec.D[0]/y_vec.D[2],y_vec.D[1]:y_vec.D[1]/y_vec.D[2], y_vec.D[2]:1})
    y3 = y_vec
    assert y_vec.D == {'y1', 'y2', 'y3'}
    return Vec(y_vec.D, {k: v / y_vec.f['y3'] for k, v in y_vec.f.items()})


v = Vec({'y1', 'y2', 'y3'}, {'y1': 5, 'y2': 3, 'y3': 0.5})
print(move2board(v))

#task 2
D = {(y, x) for y in ['y3', 'y2', 'y1'] for x in ['x1', 'x2', 'x3']}


def make_equations(w1, w2, x1, x2):
    """this prodedure returns the vectors that if multiplied by the unknown values in H would produce 0, hence giving us opportunity
    to solve for the values of H.  Could use solver to do it but that so far has not been part of the lab.  This procedure is in service of converting from the camera basis to the
    whiteboard basis."""
    u = Vec(
        D, {
            ('y3', 'x1'): w1 * x1,
            ('y3', 'x2'): w1 * x2,
            ('y3', 'x3'): w1,
コード例 #39
0
    Examples:
        >>> find_error(Vec({0,1,2}, {0:one})) == Vec({0, 1, 2, 3, 4, 5, 6},{3: one})
        True
        >>> find_error(Vec({0,1,2}, {2:one})) == Vec({0, 1, 2, 3, 4, 5, 6},{0: one})
        True
        >>> find_error(Vec({0,1,2}, {1:one, 2:one})) == Vec({0, 1, 2, 3, 4, 5, 6},{2: one})
        True
        >>> find_error(Vec({0,1,2}, {})) == Vec({0,1,2,3,4,5,6}, {})
        True
    """
    col_dict = mat2coldict(H)
    return Vec(H.D[1], {err: one for err in col_dict if col_dict[err] == syndrome})

## Task 6
# Use the Vec class for your answers.
non_codeword = Vec({0,1,2,3,4,5,6}, {0: one, 1:0, 2:one, 3:one, 4:0, 5:one, 6:one})
error_vector = find_error(H * non_codeword)
code_word = error_vector + non_codeword
original = R * code_word # R * code_word


## Task 7
def find_error_matrix(S):
    """
    Input: a matrix S whose columns are error syndromes
    Output: a matrix whose cth column is the error corresponding to the cth column of S.
    Example:
        >>> S = listlist2mat([[0,one,one,one],[0,one,0,0],[0,0,0,one]])
        >>> find_error_matrix(S) == Mat(({0, 1, 2, 3, 4, 5, 6}, {0, 1, 2, 3}), {(1, 3): 0, (3, 0): 0, (2, 1): 0, (6, 2): 0, (5, 1): one, (0, 3): 0, (4, 0): 0, (1, 2): 0, (3, 3): 0, (6, 3): 0, (5, 0): 0, (2, 2): 0, (4, 1): 0, (1, 1): 0, (3, 2): one, (0, 0): 0, (6, 0): 0, (2, 3): 0, (4, 2): 0, (1, 0): 0, (5, 3): 0, (0, 1): 0, (6, 1): 0, (3, 1): 0, (2, 0): 0, (4, 3): one, (5, 2): 0, (0, 2): 0})
        True
    """
コード例 #40
0
 def test_mul(self):
     vec = Vec(10, 0) * Vec(5, 0)
     self.assertEqual(vec, Vec(50, 0))
コード例 #41
0
ファイル: hw7.py プロジェクト: Shubashree/matrix_coding
## Problem 6
# Write your solution for this problem in orthonormalization.py.

## Problem 7
# Write your solution for this problem in orthonormalization.py.

## Problem 8
# Please give each solution as a Vec

least_squares_A1 = listlist2mat([[8, 1], [6, 2], [0, 6]])
least_squares_Q1 = listlist2mat([[.8, -0.099], [.6, 0.132], [0, 0.986]])
least_squares_R1 = listlist2mat([[10, 2], [0, 6.08]])
least_squares_b1 = list2vec([10, 8, 6])

x_hat_1 = Vec({0, 1}, {0: 1.0832236842105263, 1: 0.9838815789473685})

least_squares_A2 = listlist2mat([[3, 1], [4, 1], [5, 1]])
least_squares_Q2 = listlist2mat([[.424, .808], [.566, .115], [.707, -.577]])
least_squares_R2 = listlist2mat([[7.07, 1.7], [0, .346]])
least_squares_b2 = list2vec([10, 13, 15])

x_hat_2 = Vec({0, 1}, {0: 2.501098838207519, 1: 2.658959537572254})


## Problem 9
def QR_solve(A, b):
    '''
    Input:
        - A: a Mat
        - b: a Vec
コード例 #42
0
ファイル: hw3.py プロジェクト: dimr/computing-the-matrix
def dot_product_mat_vec_mult(M, v):
    assert(M.D[1] == v.D)
    dot_prod = Vec(M.D[0],{})
    for (key,value) in mat2rowdict(M).items():
        dot_prod.f[key] = value*v
    return dot_prod
コード例 #43
0
def make_equations(x1, x2, w1, w2):
    '''
    Input:
        - x1, x2: pixel coordinates of a point q in the image plane
        - w1, w2: w1=y1/y3 and w=y2/y3 where y1,y2,y3 are the whiteboard coordinates of q.
    Output:
        - List [u,v] of D-vectors that define linear equations u*h = 0 and v*h = 0

    For example, suppose we have an image of the whiteboard in which
       the top-left whiteboard corner appears at pixel coordinates 9, 18
       the bottom-left whiteboard corner appears at pixel coordinates 8,25
       the top-right whiteboard corner appears at pixel coordinates 20,20
       the bottom-right whiteboard corner appears at pixel coordinates 18,23

    Let q be the point in the image plane with pixel coordinates x=8,y=25, i.e. camera coordinates (8,25,1).
    Let y1,y2,y3 be the whiteboard coordinates of the same point.  The line that goes through the
    origin and p intersects the whiteboard at a point p.  That point p is the bottom-left corner of
    the whiteboard, so its whiteboard coordinates are 1,0,1.  Therefore (y1/y3,y2/y3,y3/y3) = (1,0,1).
    We define w1=y1/y3 and w2=y2/y3, so w1 = 1 and w2 = 0.  Given this input-output pair, let's find
    two linear equations u*h=0 and v*h=0 constraining the unknown vector h whose entries are the entries
    of the matrix H. 

>>> for v in make_equations(8,25,1,0): print(v)
<BLANKLINE>
 ('y1', 'x1') ('y1', 'x2') ('y1', 'x3') ('y2', 'x1') ('y2', 'x2') ('y2', 'x3') ('y3', 'x1') ('y3', 'x2') ('y3', 'x3')
---------------------------------------------------------------------------------------------------------------------
           -8          -25           -1            0            0            0            8           25            1
<BLANKLINE>
 ('y1', 'x1') ('y1', 'x2') ('y1', 'x3') ('y2', 'x1') ('y2', 'x2') ('y2', 'x3') ('y3', 'x1') ('y3', 'x2') ('y3', 'x3')
---------------------------------------------------------------------------------------------------------------------
            0            0            0           -8          -25           -1            0            0            0

    Note that the negations of these vectors form an equally valid solution.

    Similarly, consider the point q in the image plane with pixel coordinates 18, 23.  Let y1,y2,y3 be the whiteboard
    coordinates of p.  The corresponding point p in the whiteboard plane is the bottom-right corner, and the whiteboard
    coordinates of p are 1,1,1, so (y1/y3,y2/y3,y3/y3)=(1,1,1).  We define w1=y1/y3 and w2=y2/y3, so w1=1 and w2=1.
    We obtain the vectors u and v defining equations u*h=0 and v*h=0 as follows:

>>> for v in make_equations(18,23,1,1): print(v)
<BLANKLINE>
 ('y1', 'x1') ('y1', 'x2') ('y1', 'x3') ('y2', 'x1') ('y2', 'x2') ('y2', 'x3') ('y3', 'x1') ('y3', 'x2') ('y3', 'x3')
---------------------------------------------------------------------------------------------------------------------
          -18          -23           -1            0            0            0           18           23            1
<BLANKLINE>
 ('y1', 'x1') ('y1', 'x2') ('y1', 'x3') ('y2', 'x1') ('y2', 'x2') ('y2', 'x3') ('y3', 'x1') ('y3', 'x2') ('y3', 'x3')
---------------------------------------------------------------------------------------------------------------------
            0            0            0          -18          -23           -1           18           23            1

    Again, the negations of these vectors form an equally valid solution.
    '''
    u = Vec(
        D, {
            ('y1', 'x1'): -x1,
            ('y1', 'x2'): -x2,
            ('y1', 'x3'): -1,
            ('y3', 'x1'): w1 * x1,
            ('y3', 'x2'): w1 * x2,
            ('y3', 'x3'): w1
        })
    v = Vec(
        D, {
            ('y2', 'x1'): -x1,
            ('y2', 'x2'): -x2,
            ('y2', 'x3'): -1,
            ('y3', 'x1'): w2 * x1,
            ('y3', 'x2'): w2 * x2,
            ('y3', 'x3'): w2
        })
    return [u, v]
コード例 #44
0
 def test_mul_scalar(self):
     self.assertEqual(Vec(5, 5) * 5, Vec(25, 25))
コード例 #45
0
 def adjust(v,mul):
     return Vec(v.D,{i:mul[i]*v[i] for i in v.D})
コード例 #46
0
def dot_product_vec_mat_mult(v, M):
    assert(v.D == M.D[0])
    from matutil import mat2coldict
    matcolumn = mat2coldict(M)
    return Vec(M.D[1], {i:(matcolumn[i]*v) for i in matcolumn.keys()} )
コード例 #47
0
 def on_button_down(self, mouse_pos):
     self.vel_placing = self.pos_placing - self.camera.screen_to_world(
         Vec.from_tuple(mouse_pos))
コード例 #48
0
def dot_product_mat_vec_mult(M, v):
    assert(M.D[1] == v.D)
    from matutil import mat2rowdict
    matrow = mat2rowdict(M)
    return Vec(M.D[0], {i:(matrow[i]*v) for i in matrow.keys()} )
コード例 #49
0
 def test_sub(self):
     self.assertEqual(Vec(10, 5).square(), Vec(100, 25))
コード例 #50
0
def zero_vec(D):
    return Vec(D, {})
コード例 #51
0
from orthogonalization import orthogonalize
from orthogonalization import aug_orthogonalize

from triangular import triangular_solve

## 1: (Problem 1) Generators for orthogonal complement
U_vecs_1 = [list2vec([0, 0, 3, 2])]
W_vecs_1 = [
    list2vec(v)
    for v in [[1, 2, -3, -1], [1, 2, 0, 1], [3, 1, 0, -1], [-1, -2, 3, 1]]
]
# Give a list of Vecs
ortho_compl_generators_1 = [
    Vec({0, 1, 2, 3}, {
        0: 1.0,
        1: 2.0,
        2: -0.4615384615384617,
        3: 0.6923076923076923
    }),
    Vec({0, 1, 2, 3}, {
        0: 2.2432432432432434,
        1: -0.5135135135135134,
        2: 0.810810810810811,
        3: -1.2162162162162162
    })
]

U_vecs_2 = [list2vec([3, 0, 1])]
W_vecs_2 = [list2vec(v) for v in [[1, 0, 0], [1, 0, 1]]]

# Give a list of Vecs
ortho_compl_generators_2 = [
コード例 #52
0
ファイル: state.py プロジェクト: joseph-cheng/orbit-simulator
    def edit_existing_body(self, body):

        #If a body is already being edited, switch to editing the new body instead
        if self.editing_body:
            self.finish_editing_body()
        if self.infolabels:
            self.remove_planet_info_labels()

        self.editing_body = True
        self.mouse_objects_stack.append(
            slider.Slider("Radius",
                          body.radius,
                          1,
                          1 * 10**10,
                          body.radius.var,
                          Vec(10, 160),
                          200,
                          10,
                          10,
                          interpolation_type=1))
        self.mouse_objects_stack.append(
            slider.Slider("Mass",
                          body.mass,
                          1,
                          1 * 10**36,
                          body.mass.var,
                          Vec(10, 240),
                          200,
                          10,
                          10,
                          interpolation_type=1))

        self.mouse_objects_stack.append(
            slider.Slider("Red", body.colour[0], 0, 255, body.colour[0].var,
                          Vec(10, 320), 200, 10, 10))
        self.mouse_objects_stack.append(
            slider.Slider("Green", body.colour[1], 0, 255, body.colour[1].var,
                          Vec(10, 400), 200, 10, 10))
        self.mouse_objects_stack.append(
            slider.Slider("Blue", body.colour[2], 0, 255, body.colour[2].var,
                          Vec(10, 480), 200, 10, 10))

        self.mouse_objects_stack.append(
            button.Button(
                "Delete",
                Vec(10, 560),
                100,
                30,
                lambda body=body: self.delete_body_during_editing(body),
                self.renderer.font_medium))

        self.mouse_objects_stack.append(
            button.Button("Done", Vec(130, 560), 100, 30,
                          self.finish_editing_body, self.renderer.font_medium))

        self.infolabels.append(
            infolabel.InfoLabel("Velocity (m/s)", body.vel_magnitude,
                                Vec(640, 50)))
        self.infolabels.append(
            infolabel.InfoLabel("Accel (m/s^2)", body.accel_magnitude,
                                Vec(640, 100)))
コード例 #53
0
 def on_button_click(self, mouse_pos):
     self.pos_placing = self.camera.screen_to_world(
         Vec.from_tuple(mouse_pos))
     self.body_pos.x = self.pos_placing.x
     self.body_pos.y = self.pos_placing.y
コード例 #54
0
ファイル: state.py プロジェクト: joseph-cheng/orbit-simulator
    def generate_solar_system(self):

        self.finish_editing_body()
        self.remove_planet_info_labels()
        self.camera.stop_tracking()

        #Save a backup of the old solar system just in case they clicked it by accident
        self.save_bodies(filename="..\\save_states\\backup.stt")
        #Remove the current bodies
        self.bodies = []

        #Reset the bodies drop down list and mouse objects stack
        #Remove all buttons from the drop down list and the mouse object stack
        #I start at 1: because i don't want to remove the 'None' button
        for mouse_object in self.mouse_objects_stack:
            if isinstance(mouse_object, dropdownmenu.DropDownMenu
                          ) and mouse_object.name == "Bodies":
                for button in mouse_object.buttons[1:]:
                    self.mouse_objects_stack.remove(button)
                    mouse_object.buttons.remove(button)

        #Create a constellation name
        constellation = random.choice(naming.constellations)

        #Create a star name using the Bayer Designation
        star_name = random.choice(naming.greek_letters) + " " + constellation

        num_bodies = random.randint(3, 10)
        body_names = []

        #Create distinct planet names for each of the planets by the naming convention '[number] [constellation] [letter]'
        while len(body_names) < num_bodies:

            body_name = "%d %s %s" % (random.randint(
                1, 100), constellation, random.choice(string.ascii_letters))

            #Make sure if we have already generated this name, then generate a new one
            if body_name not in body_names:
                body_names.append(body_name)

        #Stars generally range from cyan to yellow, so I found that keeping green at a fixed value and keeping red and green to add to make 255 worked well to generate star colours
        star_red = random.randint(0, 255)

        #Add the star to the game
        star = body.Body(star_name,
                         random.randint(1 * 10**8, 5 * 10**9),
                         random.randint(1 * 10**27, 1 * 10**32),
                         Vec(0, 0),
                         Vec(0, 0), (star_red, 255, 255 - star_red),
                         emits_light=True)

        self.add_body_to_game(star)

        #Generate all of the bodies
        for body_num in range(num_bodies):
            body_mass = random.randint(1 * 10**22, 1 * 10**26)
            body_distance_from_sun = star.radius.var + random.randint(
                1 * 10**9, 1 * 10**12)
            """
            To calculate the velocity to keep the planet in orbit around the sun:
            G = universal gravitational constant
            M = mass of sun
            m = mass of body
            r = distance of body away from sun
            v = velocity of planet
            
            Centripetal force = GMm/r^2
            Centripetal force = mv^2/r
            GMm/r^2 = mv^2/r
            GM/r^2 = v^2/r
            GM/r = v^2
            sqrt(GM/r) = v
            """
            angle = random.uniform(0, 2 * math.pi)
            body_velocity = math.sqrt(self.G * star.mass.var /
                                      body_distance_from_sun)
            self.add_body_to_game(
                body.Body(
                    body_names[body_num], random.randint(1 * 10**6,
                                                         1 * 10**8), body_mass,
                    Vec(
                        math.cos(angle) * body_distance_from_sun,
                        math.sin(angle) * body_distance_from_sun),
                    Vec(
                        math.sin(angle) * body_velocity,
                        -math.cos(angle) * body_velocity),
                    (random.randint(0, 255), random.randint(
                        0, 255), random.randint(0, 255))))
コード例 #55
0
ファイル: world.py プロジェクト: RyanHope/pyagar
 def __init__(self, *args, **kwargs):
     self.pos = Vec()
     self.update(*args, **kwargs)
コード例 #56
0
ファイル: state.py プロジェクト: joseph-cheng/orbit-simulator
    def add_gui(self):

        #Quick function to format the time in the speed multiplier
        def format_time(x):
            if x > 31557600:
                return str(round(x / 31557600, 3)) + " years/s"
            if x > 2592000:
                return str(round(x / 2592000, 3)) + " months/s"
            if x > 604800:
                return str(round(x / 604800, 3)) + " weeks/s"
            if x > 86400:
                return str(round(x / 86400, 3)) + " days/s"
            if x > 3600:
                return str(round(x / 3600, 3)) + " hours/s"
            if x > 60:
                return str(round(x / 60, 3)) + " minutes/s"
            return str(round(x, 3)) + " seconds/s"

        # Add the GUI objects
        self.mouse_objects_stack.append(
            slider.Slider("Speed multiplier",
                          self.dt,
                          1,
                          50000000,
                          self.dt.var,
                          Vec(410, 10),
                          200,
                          10,
                          10,
                          var_formatter=format_time,
                          interpolation_type=1))
        self.scale = scale.Scale(Vec(630, 10), 150, 10, 1 / (self.camera.zoom))

        self.mouse_objects_stack.append(
            dropdownmenu.DropDownMenu("File", Vec(0, 0), 100, 30))
        self.mouse_objects_stack[-1].add_button("Save", self.save_bodies,
                                                self.renderer.font_medium,
                                                self.mouse_objects_stack)
        self.mouse_objects_stack[-2].add_button("Load", self.load_bodies,
                                                self.renderer.font_medium,
                                                self.mouse_objects_stack)
        self.mouse_objects_stack[-3].add_button("Random",
                                                self.generate_solar_system,
                                                self.renderer.font_medium,
                                                self.mouse_objects_stack)

        self.mouse_objects_stack.append(
            dropdownmenu.DropDownMenu("Options", Vec(297, 0), 100, 30))
        self.mouse_objects_stack[-1].add_button(
            "Tracers", lambda: self.change_flags(flags_file.RENDER_TRACERS),
            self.renderer.font_medium, self.mouse_objects_stack)
        self.mouse_objects_stack[-2].add_button(
            "Labels",
            lambda: self.change_flags(flags_file.RENDER_PLANET_LABELS),
            self.renderer.font_medium, self.mouse_objects_stack)
        self.mouse_objects_stack[-3].add_button(
            "Shadows", lambda: self.change_flags(flags_file.SHADOWS),
            self.renderer.font_medium, self.mouse_objects_stack)
        self.mouse_objects_stack[-4].add_button(
            "Unrealistic",
            lambda: self.change_flags(flags_file.REALISTIC),
            self.renderer.font_medium,
            self.mouse_objects_stack,
            toggled_name="Realistic")
        self.mouse_objects_stack[-5].add_button(
            "Pause",
            lambda: self.change_flags(flags_file.PAUSED),
            self.renderer.font_medium,
            self.mouse_objects_stack,
            toggled_name="Unpause")
        self.mouse_objects_stack[-6].add_button(
            "Fullscreen", lambda: self.renderer.toggle_fullscreen(self),
            self.renderer.font_medium, self.mouse_objects_stack)
        self.mouse_objects_stack[-7].add_button("Quit", pygame.quit,
                                                self.renderer.font_medium,
                                                self.mouse_objects_stack)

        self.mouse_objects_stack.append(
            button.Button("Add body", Vec(99, 0), 100, 30,
                          self.start_creating_new_body,
                          self.renderer.font_medium))

        self.mouse_objects_stack.append(
            dropdownmenu.DropDownMenu("Bodies", Vec(198, 0), 100, 30))
        self.mouse_objects_stack[-1].add_button(
            "None", lambda: [
                self.camera.stop_tracking(),
                self.finish_editing_body(),
                self.remove_planet_info_labels()
            ], self.renderer.font_medium, self.mouse_objects_stack)
        for body in self.bodies:
            self.mouse_objects_stack[-1].add_button(
                body.name,
                lambda body=body:
                [self.camera.track_body(body),
                 self.edit_existing_body(body)],
                self.renderer.font_medium,
                self.mouse_objects_stack)
コード例 #57
0
ファイル: hw3.py プロジェクト: Shubashree/matrix_coding
def dot_product_mat_vec_mult(M, v):
    assert(M.D[1] == v.D)
    from matutil import mat2rowdict
    rows = mat2rowdict(M)
    return Vec(M.D[0], {row:rowVec*v for row,rowVec in rows.items()})
コード例 #58
0
 def test_distance(self):
     self.assertEqual(Vec(0, 4).distance(Vec(0, 0)), 4)
     self.assertEqual(Vec(3, 0).distance(Vec(0, 0)), 3)
     self.assertEqual(Vec(3, 4).distance(Vec(0, 0)), 5)
コード例 #59
0
ファイル: hw3.py プロジェクト: Shubashree/matrix_coding
def dot_product_vec_mat_mult(v, M):
    assert(v.D == M.D[0])
    from matutil import mat2coldict
    cols = mat2coldict(M)
    return Vec(M.D[1], {col:v*colVec for col,colVec in cols.items()})
コード例 #60
0
ファイル: kmeans.py プロジェクト: jeremynealbrown/k-means
clusters = {}
# Count the number of iterations until convergence
iterations = 0
# Will be used to determine if the algorithm is complete
convergence = False
# Initialize the means to random points in the general range of our dataset
means = [Vec(randrange(minX, maxX), randrange(minY, maxY)) for x in range(k)]

while convergence is False:
    iterations += 1
    clusters = {i : [] for i in range(0,k)}
    for v in data:
        cluster = -1
        distance = float('inf')
        for i in range(len(means)):
            d = Vec.distance(v, means[i])
            if d < distance:
                distance = d
                cluster = i
        clusters[cluster].append(v)

    # Create a list to store the new means
    new_means = []        
    for key in clusters:
        # Sum the vectors in each cluster
        summed = Vec.zero()
        cluster = clusters[key]
        for v in cluster:
            summed += v
       
        # Find the mean of all the vectors in each cluster