def load(directoryname=""): global rawcorpus, currentdirectoryname if directoryname == "": directoryname = currentdirectoryname else: currentdirectoryname = directoryname if not corpusExists(directoryname): print(directoryname + "/corpus does not exist") else: resetMemory() if corpusCompiled(directoryname): Vec.load(directoryname) O.load(directoryname) S.load(directoryname) for i in range(OrderVec.NumberOfSlots): SP[i].load(directoryname) else: rawcorpus = open(directoryname + "/corpus", "r").read() rawcorpus = rawcorpus.lower().split() log.write("corpus size = " + str(len(rawcorpus)) + " vocab size = " + str(len(set(rawcorpus)))) encodeCorpus() O.save(directoryname) S.save(directoryname) [SP[i].save(directoryname) for i in range(OrderVec.NumberOfSlots)] Vec.save(directoryname) print(directoryname + " loaded")
def __init__(self, label): self.outputs = set() self.inputs = set() self.label : str = label self.rank = None self.pos = Vec(0,0) # position on terminal self.coords = Vec(0,0) # coords in grid self.dims = Vec(len(label),1) + (2,2) # size in grid
def updateMat(self): self.mat = [ self.row0.x, self.row0.y, self.row0.z, self.row0.w, self.row1.x, self.row1.y, self.row1.z, self.row1.w, self.row2.x, self.row2.y, self.row2.z, self.row2.w, self.row3.x, self.row3.y, self.row3.z, self.row3.w ] self.row0 = Vec(self.row0.x, self.row0.y, self.row0.z, self.row0.w) self.row1 = Vec(self.row1.x, self.row1.y, self.row1.z, self.row1.w) self.row2 = Vec(self.row2.x, self.row2.y, self.row2.z, self.row2.w) self.row3 = Vec(self.row3.x, self.row3.y, self.row3.z, self.row3.w)
def reciprocal(vs): dual_vs = [] for i in xrange(len(vs)): v0 = vs[-i-1] # more CW v1 = vs[-i] # more CCW e = v1-v0 outwardNormal = Vec([e[1],-e[0]]) #dual_v = v0.dot(outwardNormal)/outwardNormal.dot(outwardNormal) * outwardNormal dual_v = outwardNormal/outwardNormal.dot(v0) dual_vs.append(dual_v) return dual_vs
def centerFacet(pickPoint, model, worldTrans, ray, facet=None): """ Centriert Kamera auf gepickten punkt """ normale = Vec(0, 0, 0) point = Vec(0, 0, 0) points = [] # wenn facet gefunden wurde if facet is not None: for face in facet: # normale+=Vec(model.vn[face[2]]) point += Vec(model.v[face[0]]) points.append(Vec(model.v[face[0]])) # normale=normale.normalized() # Senkrechter Vecktor zum Dreick bestimmen normale = calcSenkrecht(points, ray) # Punkt auf Uniformgroesse skalieren point = point / 3.0 point = point - (Vec(model.box.center)) point = point / max(model.box.length) else: # Falls kein Facet geliefert wurde, Senkrecht zu "PickPunkt zum Mittelpunkt des Models" schauen. point = pickPoint point = point - (Vec(model.box.center)) point = point / max(model.box.length) normale = point.normalized() # HitPunkt mit ModelTransformation transformieren mT = model.modTrans point = mT.rotation.rotateVec(point) point = point * mT.scalar point = point + mT.translation normale = mT.rotation.rotateVec(normale) """ #idle model dirBlick=-worldTrans.directionZ winkel=dirBlick.winkel(normale) achse= dirBlick%normale quat=rotationQuat(winkel, -achse.normalized() ) point = quat.rotateVec(-point) point = point + worldTrans.center # zentriert auf aktuellen blickpunkt point =point - worldTrans.getDisAtT(0.8) model.initIdle(rotation=quat, translation= point , scale=1 ) #""" # ZielTransformation bestimmen winkel = normale.winkel(worldTrans.startVec) achse = worldTrans.startVec % normale rotattion = rotationQuat(winkel, achse.normalized()) # Idle Starten worldTrans.initIdle(point, rotattion, 1 * mT.scalar)
def checkSoln( newAg ): # checks if there is a unique solution for an augmented matrix inner = Matrix.getSubmatrix(newAg) soln = Matrix.getSolnMatrix(newAg) n = Matrix(inner).dim()[1] if (Matrix(inner).rank() < n): if (abs(Vec(inner[-1])) == 0): # no solution if (soln[-1] != 0): return 0 elif (abs(Vec(inner[-1])) > 0): # infinite solutions return 2 return 1 # one unique solution
def populate_grid(self): ranks = defaultdict(list) for i in self.nodes: ranks[self.nodes[i].rank].append(i) for i, rank in pipe( ranks.items(), sorted, partial(map,lambda x: x[1]), enumerate): for j, node in rank |p| enumerate: self.grid[(i*2+1, j*2+1)] = self.nodes[node] self.grid[(i*2+1, j*2+1)].coords = Vec(i*2+1, j*2+1) self.grid_dims = Vec(pipe( self.grid.keys(), Map(lambda x: x[0]), max) + 2, pipe( self.grid.keys(), Map(lambda x: x[1]), max ) + 2 ) for i in Vec.dim_range((0,0),self.grid_dims): if i not in self.grid: self.grid[i] = Conduit() self.grid[i].coords = i self.grid_col_widths = {} self.grid_row_heights = {} for x in range(self.grid_dims.x): self.grid_col_widths[x] = pipe( range(self.grid_dims.y), Map(lambda y: self.grid[x,y].dims.x), max ) for y in range(self.grid_dims.y): self.grid_row_heights[y] = pipe( range(self.grid_dims.x), Map(lambda x: self.grid[x,y].dims.y), max ) for item in self.grid.values(): item.dims.x = self.grid_col_widths[item.coords.x] item.dims.y = self.grid_row_heights[item.coords.y]
def xformVec(z,p): z = Vec(z) p = Vec(p) pp = p.dot(p) zp = z.dot(p) zz = z.dot(z) # Worked out on paper... # Also agrees with the paper "The Hyperbolic Triangle Centroid" # by Abraham A. Ungar. denominator = 1 + 2*zp + zz*pp pCoeff = (1 + 2*zp + zz) / denominator zCoeff = (1-pp) / denominator answer = pCoeff*p + zCoeff*z return answer
def translate(p,t): p = Vec(p) t = Vec(t) tt = t.dot(t) pt = p.dot(t) pp = p.dot(p) # Worked out on paper... # Also agrees with the paper "The Hyperbolic Triangle Centroid" # by Abraham A. Ungar. denominator = 1 + 2*pt + pp*tt tCoeff = (1 + 2*pt + pp) / denominator pCoeff = (1-tt) / denominator answer = tCoeff*t + pCoeff*p return answer
def xformKlein(z,p): if type(z) == complex: return v2c(xformKlein(c2v(z),c2v(p))) if type(z) == list: z = Vec(z) p = Vec(p) # formula (13) from paper "The Hyperbolic Triangle Centroid" # rearranged so it's robust even for ideal points zp = z.dot(p) pp = p.dot(p) denominator = 1 + zp pCoeff = (1 + zp/(1+sqrt(1-pp)) ) / denominator zCoeff = sqrt(1-pp) / denominator answer = pCoeff*p + zCoeff*z do('answer') return answer
def stp( self, v ): # can we make this faster by keeping the M and the stp part separate during eigenvalue computation rather than adding and subtracting?? out = v.transpose().dot(v) self.M += out val, vec = self.eig() self.M -= out vec = vec.transpose() vec = csr_matrix(vec) return Vec(vec)
def showActiveTraces(self, corpus=None, showTraceNumber=False): if self.TraceActivations.nnz > 0: res = self.TraceActivations reorder = np.argsort(res.data)[::-1] res.data = res.data[reorder] res.indices = res.indices[reorder] for i in range(len(res.indices)): realind = res.indices[i] if res.data[i] > 0.1 or i < 4: if showTraceNumber: print("%4d " % realind, Vec(self.M[realind])) if corpus: print( "%1.7f" % res.data[i], " ".join( corpus[realind:(realind + Vec.NumberOfSlots)])) else: print("%1.7f" % res.data[i], Vec(self.M[realind])) else: print("TraceActivations has %d non zeros" % self.TraceActivations.nnz)
def rank(self): """returns the rank form of matrix A INPUT: A - n X m matrix OUTPUT: rank of A as an integer """ rank = 0 A = Matrix.RREF(self) for row in A.Rowsp: if abs(Vec(row)) != 0.0: rank += 1 return rank
def strTraceActivations(self): result = "" res = self.TraceActivations if res.nnz > 0: reorder = np.argsort(res.data)[::-1] res.data = res.data[reorder] res.indices = res.indices[reorder] for i in range(len(res.indices)): realind = res.indices[i] if res.data[i] > 0.01 and i < 10: result += "%1.3f" % res.data[i] + " " + str( Vec(self.M[realind])) + "\n" else: result += "TraceActivations has %d non zeros" % res.nnz return result
def getTraceActivationsFromHistory(self, endofframeword, indexinframe=None): for index in range(len(self.TraceActivationHistory) - 1, 0, -1): if self.TraceActivationHistory[index][0] == endofframeword: break result = "Segment: " result += " " + endofframeword + " " result += "%d " % index result += " %d " % indexinframe result += " %d " % len(self.TraceActivationHistory) result += "\n" for l in range( len(self.TraceActivationHistory) - 100, len(self.TraceActivationHistory)): result += self.TraceActivationHistory[l][0] + " " result += "\n" start = max(0, index - Vec.NumberOfSlots) result += " ".join( t[0] for t in self.TraceActivationHistory[start:(index + 1)]) + "\n" if indexinframe != None: word = self.TraceActivationHistory[index - Vec.NumberOfSlots + indexinframe + 1][0] result += word + "\n" print(self.TraceActivationHistory[index]) if self.TraceActivationHistory[index][2].nnz > 0: res = self.TraceActivationHistory[index][2] reorder = np.argsort(res.data)[::-1] res.data = res.data[reorder] res.indices = res.indices[reorder] for i in range(len(res.indices)): realind = res.indices[i] if res.data[i] > 0.01 and i < 10: result += "%1.3f" % res.data[i] + " " + str( Vec(self.M[realind])) + "\n" else: result += "TraceActivations has %d non zeros" % self.TraceActivationHistory[ index][2].nnz return result
def solve(A, b): #checking if upper diagonal isValid = True for i in range(len(A.Rowsp)): d = A.getdiag(-1 * (i + 1)) for e in d: if e != 0: isValid = False if isValid: x = [] n = len(A.Rowsp[0]) for z in range(n): x.append(0) b = b.Rowsp for i in reversed(range(n)): add = [] for k in range(n): add.append(A.Rowsp[i][k] * x[k]) x[i] = (b[i][0] - sum(add)) / A.Rowsp[i][i] return Vec(x) else: print("Unsupported Matrix Type")
def svd(self): # singular value decomposition # self = UwV' (V' is V transpose) # replaces self with U # returns self, w, V (NOT V TRANSPOSE), # where s is a vector of singular values in decreasing order # to make this work for arbitrary sizes, just make the function take in m and n # instead of hardcoding to be 4. (where self is an mxn matrix) # lol def pythag(a, b): absa = math.fabs(a) absb = math.fabs(b) if absa > absb: return absa * math.sqrt(1.0 + math.pow(absb / absa, 2)) elif absb == 0.0: return 0.0 else: return absb * math.sqrt(1.0 + math.pow(absa / absb, 2)) w = [0] * 4 v = Mat44(row0x=0, row1y=0, row2z=0, row3y=0) rv1 = [0] * 4 g = scale = anorm = 0.0 m = n = 4 for i in range(1, 5): l = i + 1 rv1[i - 1] = scale * g g = s = scale = 0.0 if i <= m: for k in range(i, m + 1): scale += abs(self[k - 1, i - 1]) if scale: for k in range(i, m + 1): self[k - 1, i - 1] /= scale s += self[k - 1, i - 1] * self[k - 1, i - 1] f = self[i - 1, i - 1] g = -(f / f) * math.sqrt(s) h = f * g - s self[i - 1, i - 1] = f - g for j in range(l, n + 1): s = 0.0 for k in range(i, m + 1): s += self[k - 1, i - 1] * self[k - 1, j - 1] f = s / h for k in range(i, m + 1): self[k - 1, j - 1] += f * self[k - 1, i - 1] for k in range(i, m + 1): self[k - 1, i - 1] *= scale w[i - 1] = scale * g g = s = scale = 0.0 if i <= m and i != n: for k in range(l, n + 1): scale += math.fabs(self[i - 1, k - 1]) if scale: for k in range(l, n + 1): self[i - 1, k - 1] /= scale s += self[i - 1, k - 1] * self[i - 1, k - 1] f = self[i - 1, l - 1] g = -(f / f) * math.sqrt(s) h = f * g - s self[i - 1, l - 1] = f - g for k in range(l, n + 1): if h != 0: rv1[k - 1] = self[i - 1, k - 1] / h for j in range(l, m + 1): s = 0.0 for k in range(l, n + 1): s += self[j - 1, k - 1] * self[i - 1, k - 1] for k in range(l, n + 1): self[j - 1, k - 1] += s * rv1[k - 1] for k in range(l, n + 1): self[i - 1, k - 1] *= scale anorm = max(anorm, (math.fabs(w[i - 1]) + math.fabs(rv1[i - 1]))) for i in range(n, 0, -1): if i < n: if g: for j in range(l, n + 1): if self[i - 1, l - 1] != 0 and g != 0: v[j - 1, i - 1] = (self[i - 1, j - 1] / self[i - 1, l - 1]) / g for j in range(l, n + 1): s = 0.0 for k in range(l, n + 1): s += self[i - 1, k - 1] * v[k - 1, j - 1] for k in range(l, n + 1): v[k - 1, j - 1] += s * v[k - 1, i - 1] v[i - 1, i - 1] = 1.0 g = rv1[i - 1] l = i for i in range(min(m, n), 0, -1): l = i + 1 g = w[i - 1] for j in range(l, n + 1): self[i - 1, j - 1] = 0.0 if g: g = 1.0 / g for j in range(l, n + 1): s = 0.0 for k in range(l, m + 1): s += self[k - 1, i - 1] * self[k - 1, j - 1] f = (s / self[i - 1, i - 1]) * g for k in range(i, m + 1): self[k - 1, j - 1] += f * self[k - 1, i - 1] else: for j in range(i, m + 1): self[k - 1, i - 1] = 0.0 self[i - 1, i - 1] += 1 for k in range(n, 0, -1): for its in range(1, 31): flag = 1 for l in range(k, 0, -1): nm = l - 1 if float(math.fabs(rv1[l - 1]) + anorm) == anorm: flag = 0 break if float(math.fabs(w[nm - 1]) + anorm) == anorm: break if flag: c = 0.0 s = 1.0 for i in range(l, k + 1): f = s * rv1[i - 1] rv1[i - 1] = c * rv1[i - 1] if float(math.fabs(f) + anorm) == anorm: break g = w[i - 1] h = pythag(f, g) w[i - 1] = h h = 1.0 / h c = g * h s = -f * h for j in range(1, m + 1): y = self[j - 1, nm - 1] z = self[j - 1, i - 1] self[j - 1, nm - 1] = y * c + z * s self[j - 1, i - 1] = z * c - y * s z = w[k - 1] if l == k: if z < 0.0: w[k - 1] = -z for j in range(1, n + 1): v[j - 1, k - 1] = -v[j - 1, k - 1] break if its == 30: raise Exception('no convergence in 30 iterations') x = w[l - 1] nm = k - 1 y = w[nm - 1] g = rv1[nm - 1] h = rv1[k - 1] f = ((y - z) * (y + z) + (g - h) * (g + h)) / (2.0 * h * y) g = pythag(f, 1.0) if x != 0 and (f + (g * (f / f))) != 0: f = ((x - z) * (x + z) + h * ((y / (f + (g * (f / f)))) - h)) / x c = s = 1.0 for j in range(l, nm + 1): i = j + 1 g = rv1[i - 1] y = w[i - 1] h = s * g g = c * g z = pythag(f, h) rv1[j - 1] = z c = f / z s = h / z f = x * c - x * s h = y * s y *= c for jj in range(1, n + 1): x = v[jj - 1, j - 1] z = v[jj - 1, i - 1] v[jj - 1, j - 1] = x * c + z * s v[jj - 1, i - 1] = z * c - x * s z = pythag(f, h) w[j - 1] = z if z: z = 1.0 / z c = f * z s = h * z f = c * g + s * y x = c * y - s * g for jj in range(1, m + 1): y = self[jj - 1, j - 1] z = self[jj - 1, i - 1] self[jj - 1, j - 1] = y * c + z * s self[jj - 1, i - 1] = z * c - y * s rv1[l - 1] = 0.0 rv1[k - 1] = f w[k - 1] = x return self, Vec(w), v
def rSub(r1, r2): # returns the difference between r1 and r2 result = Vec(r1) + (-1 * Vec(r2)) return result.vec
def listTraces(self, corpus): for i in range(self.NumberOfTraces): print("%4d %s" % (i, " ".join(corpus[i:(i + Vec.NumberOfSlots)]))) print("%4d" % i, Vec(self.M[i]))
def idealTriangleCenterSmart(a,b,c): if type(a) == complex: return v2c(idealTriangleCenterSmart(c2v(a),c2v(b),c2v(c))) if type(a) != Vec: a = Vec(a) b = Vec(b) c = Vec(c) # fix non-units, so caller can be sloppy a = a.normalized() b = b.normalized() c = c.normalized() print " in idealTriangleCenterSmart" # Either of the following works... if False: aCoeff = 1-b.dot(c) bCoeff = 1-c.dot(a) cCoeff = 1-a.dot(b) else: # better aCoeff = (c-b).length2() bCoeff = (a-c).length2() cCoeff = (b-a).length2() denominator = aCoeff + bCoeff + cCoeff aCoeff /= denominator bCoeff /= denominator cCoeff /= denominator kleinCenter = a*aCoeff + b*bCoeff + c*cCoeff poincareCenter = hhalf(kleinCenter) p = poincareCenter do('xform(a,-p)+xform(b,-p)+xform(c,-p)') # poincareCenter = hhalf(kleinCenter) = kleinCenter / (1+sqrt(1-length2(kleinCenter))) # We need a better way of estimating 1-length2(kleinCenter). # Even if kleinCenter is unstable due to a,b,c being close together, 1-length2(kleinCenter) should be totally stable. # 1-length2(kleinCenter) # = 1-kleinCenter.dot(kleinCenter) # = 1 - (A*a+B*b+B*c).dot(A*a+B*b+C*c) # = 1 - (A^2*a.a + B^2*b.b + C^2*c.c + 2*A*B*a.b + 2*B*C*b.c + 2*C*A*c.a) # = 1 - (A^2*(1-(1-a.a)) + B^2*(1-(1-b.b)) + C^2*(1-(1-c.c)) + 2*A*B*(1-(1-a.b)) + 2*B*C*(1-(1-b.c)) + 2*C*A*(1-(1-c.a))) # = 1 - (A^2+B^2+C^2+2*A*B+2*B*C+2*C*A) + 2*(A*B*(1-a.b) + B*C*(1-b.c) + C*A*(1-c.a)) # = 1 - (A+B+C)^2 + 2*(A*B*(1-a.b) + B*C*(1-b.c) + C*A*(1-c.a)) # = 1 - 1 + 2*(A*B*(1-a.b) + B*C*(1-b.c) + C*A*(1-c.a)) # = 2*(A*B*(1-a.b) + B*C*(1-b.c) + C*A*(1-c.a)) # But |a-b|^2 = (a-b).(a-b) = a.a - 2*a.b + b.b = 2-2*a.b = 2*(1-a.b), so... # = A*B*|b-a|^2 + B*C*|c-b|^2 + C*A*|a-c|^2 poincareCenter = kleinCenter / (1+sqrt(aCoeff*bCoeff*length2(b-a) + bCoeff*cCoeff*length2(c-b) + cCoeff*aCoeff*length2(a-c))) p = poincareCenter do('xform(a,-p)+xform(b,-p)+xform(c,-p)') # GRRR that was worse!! why?? did I mess it up? # okay, the following is a little better... still not what I was hoping though. maybe what I was hoping was not realistic. # oh hell, it's not better with thin isosceles... bleah! what went wrong?? # maybe its main advantage is when summing lots of points, not sure scaleFactor = (1+sqrt(aCoeff*bCoeff*length2(b-a) + bCoeff*cCoeff*length2(c-b) + cCoeff*aCoeff*length2(a-c))) aCoeff /= scaleFactor bCoeff /= scaleFactor cCoeff /= scaleFactor poincareCenter = aCoeff*a + bCoeff*b + cCoeff*c p = poincareCenter do('xform(a,-p)+xform(b,-p)+xform(c,-p)') print " out idealTriangleCenterSmart" return poincareCenter
def invGammaKleinSegment(a,b): if type(a) == complex: a = c2v(a) b = c2v(b) if type(a) == list: a = Vec(a) b = Vec(b) assert type(a) == Vec if False: ab = xformKlein(-a,b) return invGamma(ab) aa = a.dot(a) ab = a.dot(b) bb = b.dot(b) print "-------" if True: if False: foo = (1 - ab/(1+sqrt(1-bb)))*b - sqrt(1-bb)*a length2foo = length2(foo) print "-------" do('length2foo') length2foo = (1 - ab/(1+sqrt(1-bb)))**2*bb + (1-bb)*aa - 2*(1 - ab/(1+sqrt(1-bb)))*sqrt(1-bb)*ab do('length2foo') length2foo = (1 + (ab/(1+sqrt(1-bb)))**2 - 2*ab/(1+sqrt(1-bb))) * bb + (1-bb)*aa - 2*(1 - ab/(1+sqrt(1-bb)))*sqrt(1-bb)*ab do('length2foo') length2foo = (1 + ab**2/(1+sqrt(1-bb))**2 - 2*ab/(1+sqrt(1-bb))) * bb + (1-bb)*aa - (2*ab*sqrt(1-bb) - 2*ab**2/(1+sqrt(1-bb))*sqrt(1-bb)) do('length2foo') length2foo = (aa + bb - aa*bb + bb*ab**2/(1+sqrt(1-bb))**2 - 2*bb*ab/(1+sqrt(1-bb)) - 2*ab*sqrt(1-bb) + 2*ab**2*sqrt(1-bb)/(1+sqrt(1-bb))) do('length2foo') # why is it symmetric in a,b?? it doesn't look it, yet length2foo = (bb + aa - bb*aa + aa*ab**2/(1+sqrt(1-aa))**2 - 2*aa*ab/(1+sqrt(1-aa)) - 2*ab*sqrt(1-aa) + 2*ab**2*sqrt(1-aa)/(1+sqrt(1-aa))) do('length2foo') length2foo = (bb + aa - bb*aa + ab*( aa*ab/(1+sqrt(1-aa))**2 - 2*aa/(1+sqrt(1-aa)) - 2*sqrt(1-aa) + 2*ab*sqrt(1-aa)/(1+sqrt(1-aa)) )) if False: do('length2foo') answer = sqrt(1 - length2foo/(1-ab)**2) do('answer') if False: # This was was right but inaccurate # convert to poincare disk and do calculation there. # A and B are the points in the poincare disk. A = hhalf(a) B = hhalf(b) AA = A.dot(A) AB = A.dot(B) BB = B.dot(B) # pp = || (A-B) / (1 - A*conj(B)) || # = ||A-B|| / ((1-A*conj(B)) * (1-B*conj(A))) # = ||A-B|| / ((1-A*conj(B)) * (1-B*conj(A))) # = ||A-B|| / (1-2*(A dot B) + (A dot A)*(B dot B)) pp = length2(A-B)/(1 - 2*AB + AA*BB) # given p poincare, # k = 2*p/(1+pp) # so kk = 4*pp/(1+pp)^2 kk = 4*pp/(1+pp)**2 answer = sqrt(1-kk) do('answer') if True: # convert to poincare disk and do calculation there A = a / (1+sqrt(1-length2(a))) B = b / (1+sqrt(1-length2(b))) AA = A.dot(A) AB = A.dot(B) BB = B.dot(B) # given p poincare, # k = 2*p/(1+pp) # so sqrt(1-kk) = sqrt((1-k)*(1+k)) pp = length2(A-B)/(1-2*AB+AA*BB) k = 2*sqrt(pp)/(1+pp) answer = sqrt((1-k)*(1+k)) do('answer') if True: aa = a.dot(a) ab = a.dot(b) bb = b.dot(b) afoo = (1+sqrt(1-aa)) bfoo = (1+sqrt(1-bb)) afoo2 = (1+(1-aa)+2*sqrt(1-aa)) bfoo2 = (1+(1-bb)+2*sqrt(1-bb)) afoo2 = (2-aa+2*sqrt(1-aa)) bfoo2 = (2-bb+2*sqrt(1-bb)) pp = (aa*bfoo2-2*ab*afoo*bfoo+bb*afoo2)/(afoo2*bfoo2-2*ab*afoo*bfoo+aa*bb) k = 2*sqrt(pp)/(1+pp) answer = sqrt((1-k)*(1+k)) do('answer') if True: aa = a.dot(a) ab = a.dot(b) bb = b.dot(b) afoo = (1+sqrt(1-aa)) bfoo = (1+sqrt(1-bb)) afoo2 = (2-aa+2*sqrt(1-aa)) bfoo2 = (2-bb+2*sqrt(1-bb)) pp = (aa*(2-bb+2*sqrt(1-bb))-2*ab*afoo*bfoo+bb*(2-aa+2*sqrt(1-aa))) / ((2-aa+2*sqrt(1-aa))*(2-bb+2*sqrt(1-bb))-2*ab*afoo*bfoo+aa*bb) pp = (2*aa-2*bb*aa+2*aa*sqrt(1-bb)-2*ab*afoo*bfoo+2*bb+2*bb*sqrt(1-aa)) / ((2-aa+2*sqrt(1-aa))*(2-bb+2*sqrt(1-bb))-2*ab*afoo*bfoo+aa*bb) pp = (2*aa-2*bb*aa+2*bb + 2*aa*sqrt(1-bb) - 2*ab*(1+sqrt(1-aa))*(1+sqrt(1-bb)) + 2*bb*sqrt(1-aa)) / ((2-aa+2*sqrt(1-aa))*(2-bb+2*sqrt(1-bb))-2*ab*(1+sqrt(1-aa))*(1+sqrt(1-bb))+aa*bb) k = 2*sqrt(pp)/(1+pp) answer = sqrt((1-k)*(1+k)) do('answer') if False: aa = a.dot(a) ab = a.dot(b) bb = b.dot(b) pp = (aa-bb*aa+bb + aa*sqrt(1-bb) - ab*(1+sqrt(1-aa))*(1+sqrt(1-bb)) + bb*sqrt(1-aa)) / ( 2 + aa*bb + 2*sqrt(1-aa)*sqrt(1-bb) - aa - bb + 2*sqrt*(1-aa) + 2*sqrt(1-bb) -aa*sqrt(1-bb) -bb*sqrt(1-aa) -ab*(1+sqrt(1-aa))*(1+sqrt(1-bb))) k = 2*sqrt(pp)/(1+pp) answer = sqrt((1-k)*(1+k)) do('answer') if False: aa = a.dot(a) ab = a.dot(b) bb = b.dot(b) pp = (aa-bb*aa+bb + aa*sqrt(1-bb) - ab*(1+sqrt(1-aa))*(1+sqrt(1-bb)) + bb*sqrt(1-aa)) / ( 2 + aa*bb + 2*sqrt(1-aa)*sqrt(1-bb) - aa - bb + 2*sqrt*(1-aa) + 2*sqrt(1-bb) -aa*sqrt(1-bb) -bb*sqrt(1-aa) -ab*(1+sqrt(1-aa))*(1+sqrt(1-bb))) k = 2*sqrt(pp)/(1+pp) answer = sqrt((1-k)*(1+k)) do('answer') if True: # and then a miracle happens... I read the book. easy as pie. # gamma(xform(b,-a)) = gamma(a)*gamma(b)*(1 - (a dot b)) # so, invGamma(xform(b,-a)) = invGamma(a)*invGamma(b)/(1-(a dot b)) answer = invGamma(a)*invGamma(b)/(1-a.dot(b)) answer = sqrt((1-length2(a))*(1-length2(b)))/(1-a.dot(b)) do('answer') # IDEA: can we just compute the coeffs in poincare space? might be easier return answer
def getCol(self, index): self.updateMat() return Vec([self.mat[4 * i + index] for i in xrange(4)])
def __init__(self, row0x=1.0, row0y=0.0, row0z=0.0, row0w=0.0, row1x=0.0, row1y=1.0, row1z=0.0, row1w=0.0, row2x=0.0, row2y=0.0, row2z=1.0, row2w=0.0, row3x=0.0, row3y=0.0, row3z=0.0, row3w=1.0): if isinstance(row0x, list): if len(row0x) == 16: self.row0 = Vec(row0x[0], row0x[1], row0x[2], row0x[3]) self.row1 = Vec(row0x[4], row0x[5], row0x[6], row0x[7]) self.row2 = Vec(row0x[8], row0x[9], row0x[10], row0x[11]) self.row3 = Vec(row0x[12], row0x[13], row0x[14], row0x[15]) self.col0 = Vec(row0x[0], row0x[4], row0x[8], row0x[12]) self.col1 = Vec(row0x[1], row0x[5], row0x[9], row0x[13]) self.col2 = Vec(row0x[2], row0x[6], row0x[10], row0x[14]) self.col3 = Vec(row0x[3], row0x[7], row0x[11], row0x[15]) elif isinstance(row0x, Vec) and isinstance(row0y, Vec) and isinstance( row0z, Vec) and isinstance(row0w, Vec): self.row0 = row0x self.row1 = row0y self.row2 = row0z self.row3 = row0w else: self.row0 = Vec(row0x, row0y, row0z, row0w) self.row1 = Vec(row1x, row1y, row1z, row1w) self.row2 = Vec(row2x, row2y, row2z, row2w) self.row3 = Vec(row3x, row3y, row3z, row3w) self.mat = [ self.row0.x, self.row0.y, self.row0.z, self.row0.w, self.row1.x, self.row1.y, self.row1.z, self.row1.w, self.row2.x, self.row2.y, self.row2.z, self.row2.w, self.row3.x, self.row3.y, self.row3.z, self.row3.w ]
def showTraces(self, corpus=None): for i in range(self.NumberOfTraces): if corpus: print(" ".join(corpus[realind:(realind + Vec.NumberOfSlots)])) else: print(Vec(self.M[i]))
def print(self, term: Term, pos: Vec): term.write_here(self.pos+Vec(2,2), self.label)
return self def __str__(self): res = "Memory shape = %d %d" % (self.M.shape[0], self.M.shape[1]) return (res) def save(self, directoryname): save_npz(directoryname + "/Memory.npz", self.M) def load(self, directoryname): self.M = load_npz(directoryname + "/Memory.npz") if __name__ == "__main__": M = Memory() vec = Vec("oneandone one one zero").normalize() print vec M.add(vec) vec = Vec("oneandzero one zero one").normalize() print vec M.add(vec) vec = Vec("zeroandone zero one one").normalize() print vec M.add(vec) vec = Vec("zeroandzero zero zero zero").normalize() print vec M.add(vec) val = M.eigenvalue() M /= val
def points_to_vec(a, b): return Vec((a[0] - b[0], a[1] - b[1]))
def getEcho(self, vec, verbose=False): self.retrieveFromMemory(vec, verbose=verbose) echo = self.TraceActivations * self.M return Vec(echo.tolil())
def matrixVectorMul(self, vec): if not isinstance(vec, Vec): raise Exception('invalid type: must be Vec') return Vec([vec * self.getRow(i) for i in range(4)])
def __init__(self): self.dims = Vec(1,1)