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)
