def inverse(self): "Returns the inverse of a rank-2 tensor." if self.rank == 2: from LinearAlgebra import inverse return Tensor(inverse(self.array)) else: raise ValueError, 'Undefined operation'
def spline(data, quality): """Interpolate a trajectory using natural cubic splines. Arguments: - data a list or AMC object containing the data to be interpolated - quality the number of new points to insert between data points """ # Special case: The input data is an AMC object. For each bone in the AMC # object create a spline. Return an AMC object. if data.__class__ == AMC: interpolated = AMC() for bone, motion in data.bones.iteritems(): interpolated.bones[bone] = spline(motion, quality) return interpolated data = Numeric.array(data) quality += 1 # Assumming a 2-dimensional array. # FIXME - Needs error checking? length, dof = Numeric.shape(data) interpolated = Numeric.empty((length * quality, dof)) # Range of times we'll be using for the vast majority of the splining process times = Numeric.arange(2, 3, 1. / quality)[:-1] # For calculating interpolated data points f = lambda c: lambda t: c[0] + c[1] * t + c[2] * t**2 + c[3] * t**3 # Interpolate the data using chunks of the trajectory. Each chunk consists # of 4 points. Except for the first and last chunk, interpolate only the # inner 2 points of each chunk. for frame in range(length - 3): # Generate matrices and solve for the constants A, b = _getMatrix(data[frame:frame + 4], dof) Ainv = inverse(A) z = [Numeric.matrixmultiply(Ainv, x) for x in b] # Handle each degree of freedom individually for degree in range(dof): # At the beginning of the trajectory interpolate the first 2 points if frame == 0: smoothedFrame = frame * quality interpolated[smoothedFrame:smoothedFrame + quality, degree] = \ map(f(z[degree][:4]), Numeric.arange(1, 2, 1. / quality)[:-1]) # At the end of the trajectory interpolate the last 2 points elif frame == length - 4: smoothedFrame = (frame + 2) * quality interpolated[smoothedFrame:smoothedFrame + quality, degree] = \ map(f(z[degree][-4:]), Numeric.arange(3, 4, 1. / quality)[:-1]) # Interpolate the middle 2 points smoothedFrame = (frame + 1) * quality interpolated[smoothedFrame:smoothedFrame + quality, degree] = \ map(f(z[degree][4:8]), times) return interpolated
def GetReciprocalBravaisLattice(self): from LinearAlgebra import inverse from Numeric import transpose, pi import copy reciprocal = copy.copy(self) # Using : rec=2pi*(unitcell^T)^-1 recbasis = 2 * pi * inverse(transpose(self.GetBasis())) reciprocal.SetBasis(recbasis) return reciprocal
def GetReciprocalBravaisLattice(self): from LinearAlgebra import inverse from Numeric import transpose,pi import copy reciprocal=copy.copy(self) # Using : rec=2pi*(unitcell^T)^-1 recbasis=2*pi*inverse(transpose(self.GetBasis())) reciprocal.SetBasis(recbasis) return reciprocal
def hermite(x0, x1, v0, v1, t): a = array([1, t, t**2, t**3]) M = array([[1, 0, 0, 0], [1, 1, 1, 1], [0, 1, 0, 0], [0, 1, 2, 3]]) p = transpose([[x0, x1, v0, v1]]) return dot(dot(a, inverse(M)), p)
def kfupdate(self, dt, rs): self.ab = array((rs.ax, -rs.ay, -rs.az)) ph = self.phi th = self.theta P = self.pmat A = array(((-rs.q*cos(ph)*tan(th)+rs.r*sin(ph)*tan(th), (-rs.q*sin(ph)+rs.r*cos(ph))/(cos(th)*cos(th))), (rs.q*sin(ph)-rs.r*cos(ph) , 0))) dph = rs.p - rs.q*sin(ph)*tan(th) - rs.r*cos(ph)*tan(th) dth = - rs.q*cos(ph) - rs.r*sin(ph) dP = dot(A, P) + dot(P, transpose(A)) + self.Q ph = ph + dph * dt th = th + dth * dt P = P + dP * dt Cx = array((0 , cos(th))) Cy = array((-cos(th)*cos(ph), sin(th)*sin(ph))) Cz = array((cos(th)*sin(ph) , sin(th)*cos(ph))) C = array((Cx, Cy, Cz)) L = dot(dot(P, transpose(C)), inverse(self.R + dot(dot(C, P), transpose(C)))) h = array((sin(th), -cos(th)*sin(ph), -cos(th)*cos(ph))) P = dot(identity(2) - dot(L, C), P) ph = ph + dot(L[0], self.ab - h) th = th + dot(L[1], self.ab - h) ph = ((ph+pi) % (2*pi)) - pi; th = ((th+pi) % (2*pi)) - pi; self.pmat = P self.phi = ph self.theta = th psidot = rs.q * sin(ph) / cos(th) + rs.r * cos(ph) / cos(th); self.psi += psidot * dt; self.quat = eul2quat(ph,th,self.psi) # self.dcmb2e = quat2dcm(quatinv(self.quat)) # self.ae = dot(self.dcmb2e, self.ab) self.ae = quatrotate(quatinv(self.quat), self.ab) self.ae[2] = -self.ae[2]-1 self.ae[1] = -self.ae[1] self.ve += self.ae * dt * 9.81 self.xe += self.ve * dt
def bezier2(x0, p1, p2, x1, t): a = array([1, t, t**2, t**3]) M = array([[1, 0, 0, 0], [1, 1, 1, 1], [0, 1, 0, 0], [0, 1, 2, 3]]) B = array([[1, 0, 0, 0], [0, 0, 0, 1], [-3, 3, 0, 0], [0, 0, -3, 3]]) p = transpose([[x0, p1, p2, x1]]) C = dot(inverse(M), B) return dot(dot(a, C), p)
def savitzky_golay(window_size=None,order=2): if window_size is None: window_size = order + 2 if window_size % 2 != 1 or window_size < 1: raise TypeError("window size must be a positive odd number") if window_size < order + 2: raise TypeError("window size is too small for the polynomial") # A second order polynomial has 3 coefficients order_range = range(order+1) half_window = (window_size-1)//2 B = array( [ [k**i for i in order_range] for k in range(-half_window, half_window+1)] ) # -1 # [ T ] T # [ B * B ] * B M = matrixmultiply( inverse( matrixmultiply(transpose(B), B)), transpose(B) ) return M
def iagaussian(s,mu,sigma): """ o Purpose Generate a 2D Gaussian image. o Synopsis g = iagaussian(s,mu,sigma) o Input s: [rows columns] mu: Mean vector. 2D point (x;y). Point of maximum value. sigma: covariance matrix (square). [ Sx^2 Sxy; Syx Sy^2] o Output g: o Description A 2D Gaussian image is an image with a Gaussian distribution. It can be used to generate test patterns or Gaussian filters both for spatial and frequency domain. The integral of the gaussian function is 1.0. o Examples import Numeric f = iagaussian([8,4], [3,1], [[1,0],[0,1]]) print Numeric.array2string(f, precision=4, suppress_small=1) g = ianormalize(f, [0,255]).astype(Numeric.UnsignedInt8) print g f = iagaussian(100, 50, 10*10) g = ianormalize(f, [0,1]) g,d = iaplot(g) showfig(g) f = iagaussian([50,50], [25,10], [[10*10,0],[0,20*20]]) g = ianormalize(f, [0,255]).astype(Numeric.UnsignedInt8) iashow(g) """ from Numeric import asarray,product,arange,NewAxis,transpose,matrixmultiply,reshape,concatenate,resize,sum,zeros,Float,ravel,pi,sqrt,exp from LinearAlgebra import inverse,determinant if type(sigma).__name__ in ['int', 'float', 'complex']: sigma = [sigma] s, mu, sigma = asarray(s), asarray(mu), asarray(sigma) if (product(s) == max(s)): x = arange(product(s)) d = x - mu if len(d.shape) == 1: tmp1 = d[:,NewAxis] tmp3 = d else: tmp1 = transpose(d) tmp3 = tmp1 if len(sigma) == 1: tmp2 = 1./sigma else: tmp2 = inverse(sigma) k = matrixmultiply(tmp1, tmp2) * tmp3 else: aux = arange(product(s)) x, y = iaind2sub(s, aux) xx = reshape(concatenate((x,y)), (2, product(x.shape))) d = transpose(xx) - resize(reshape(mu,(len(mu),1)), (s[0]*s[1],len(mu))) if len(sigma) == 1: tmp = 1./sigma else: tmp = inverse(sigma) k = matrixmultiply(d, tmp) * d k = sum(transpose(k)) g = zeros(s, Float) aux = ravel(g) if len(sigma) == 1: tmp = sigma else: tmp = determinant(sigma) aux[:] = 1./(2*pi*sqrt(tmp)) * exp(-1./2 * k) return g
def vcross(a, b): return [a[1]*b[2]-a[2]*b[1], a[2]*b[0]-a[0]*b[2], a[0]*b[1]-a[1]*b[0]] print "enter groove position" g = readVector() print "enter a" a = readVector() print "enter b" b = readVector() va = vsub(a, g) vb = vsub(b, g) vc = vcross(va, vb) mat = array([[va[0], vb[0], vc[0]], [va[1], vb[1], vc[1]], [va[2], vb[2], vc[2]]]) inv = inverse(mat) while (True): print "enter vector" v = readVector() vv = vsub(v, g) A = vv[0]*inv[0, 0] + vv[1]*inv[0, 1] + vv[2]*inv[0, 2] B = vv[0]*inv[1, 0] + vv[1]*inv[1, 1] + vv[2]*inv[1, 2] C = vv[0]*inv[2, 0] + vv[1]*inv[2, 1] + vv[2]*inv[2, 2] vcalc1 = vadd(vmulk(va, A), vmulk(vb, B)) vcalc = vadd(vcalc1, vmulk(vc, C)) delta = vsub(vv, vcalc) error = math.sqrt(vdot(delta, delta)) delta2d = vsub(vv, vcalc1)
def ACL(tree): """Returns a normalized dictionary of sequence weights {seq_id: weight} tree: a PhyloNode object The ACL method is named after Altschul, Carroll and Lipman, who published a paper on sequence weighting in 1989. The ACL method is based on an idea of Felsenstein (1973). Imagine electrical current flows from the root of the tree down the edges and out the leaves. If the edge lengths are proportional to their electrical resistances, current flowing out each leaf equals the leaf weight. The first step in the calculation of the weight vector is calculating a variance-covariance matrix. The variance of a leaf is proportional to the distance from the root to that leaf. The covariance of two leaves is proportional to the distance from the root to the last common ancestor of the two leaves. The second step in the calculation results in a vector of weights. Suppose there are n leaves on the tree. Let i be the vector of size n, all of whose elements are 1.0. The weight vector is calculated as: w = (inverse(M)*i)/(transpose(i)*inverse(M)*i) See Altschul 1989 """ #clip branch lengths to avoid error due to negative or zero branch lengths _clip_branch_lengths(tree) #get a list of sequence IDs (in the order that the tree will be traversed) seqs = [] for n in tree.TerminalDescendants: seqs.append(n.Data) #initialize the variance-covariance matrix m = zeros([len(seqs),len(seqs)],Float64) #calculate (co)variances #variance of a node is defined as the distance from the root to the leaf #covariance of two nodes is defined as the distance from the root to the #last common ancestor of the two leaves. for x in tree.TerminalDescendants: for y in tree.TerminalDescendants: idx_x = seqs.index(x.Data) idx_y = seqs.index(y.Data) if idx_x == idx_y: m[idx_x,idx_y] = x.distance(tree) else: lca = x.lastCommonAncestor(y) dist_lca_root = lca.distance(tree) m[idx_x,idx_y] = dist_lca_root m[idx_y,idx_x] = dist_lca_root #get the inverse of the variance-covariance matrix inv = inverse(m) #build vector i (vector or ones, length = # of leaves in the tree) i = ones(len(seqs),Float64) numerator = matrixmultiply(inv, i) denominator = matrixmultiply(matrixmultiply(transpose(i),inv),i) weight_vector = numerator/denominator #return a Weights object (is dict {seq_id: weight}) return Weights(dict(zip(seqs,weight_vector)))
import string