def encode(Fn, A, B):
"""
implement dyadic ⊤
"""
if B.isEmptyVector():
# Simplistic
return makeEmptyVector()
if A.isEmptyVector():
# Simplistic
return makeEmptyVector()
if B.isArray():
if A.isScalarLike():
Rpy = []
Apy = A.vectorToPy()
for Bpy in B.arrayToPy():
Rpy.append(Fn(Apy, Bpy).__next__())
return makeArray(Rpy, B.dimension())
assertError("WIP - RANK ERROR")
if B.isVector():
assertTrue(B.tally() == 2, "WIP - LENGTH ERROR")
if A.isArray():
assertError("WIP - RANK ERROR")
if A.isVector():
assertTrue(A.tally() == 2, "WIP - LENGTH ERROR")
Rpy, Apy = [], A.vectorToPy()
for Bpy in B.vectorToPy():
Rpy += Fn(Apy, Bpy)
Rpy = monadicTranspose(Rpy, (A.tally(), B.tally()))
return makeArray(Rpy, (A.tally(), B.tally()))
Rpy, Apy = [], A.vectorToPy()
for Bpy in B.vectorToPy():
Rpy += Fn(Apy, Bpy)
if A.isArray():
Rpy, Bpy = [], B.scalarToPy()
for Ait in A.arrayByFirstAxis():
Rpy += Fn(Ait.vectorToPy(), Bpy)
return makeArray(Rpy, A.dimension(), B.prototype())
if A.isVector():
Rpy = Fn(A.vectorToPy(), B.scalarToPy())
return makeVector(Rpy, A.tally())
Rpy = Fn(A.vectorToPy(), B.scalarToPy())
return makeScalar(Rpy)
def index(Fn, A, B):
"""
implement dyadic ⍳
"""
assertNotArray(A)
if B.isEmptyVector():
return makeEmptyVector(B.prototype())
if A.isEmptyVector():
Rpy = scalarIterator(indexOrigin(), B.elementCount(), B.expressionToGo)
elif B.isArray():
Rpy = Fn(A.vectorToPy(), B.arrayToPy())
else:
Rpy = Fn(A.vectorToPy(), B.vectorToPy())
if B.isArray():
return makeArray(Rpy, B.dimension())
if B.isVector():
return makeVector(Rpy, B.dimension())
return makeScalar(Rpy)
def take(Fn, A, B):
"""
implement dyadic ↑
"""
assertNotArray(A)
if B.isScalar() or B.isEmptyVector():
if A.isEmptyVector():
return B
if B.isVectorLike():
assertScalarLike(A)
Apy = confirmInteger(A.scalarToPy())
if Apy == 0:
return makeEmptyVector(B.prototype())
Rpy = Fn(Apy, B.vectorToPy(), B.padFill())
return makeVector(Rpy, abs(Apy), B.prototype())
Apy = [confirmInteger(I) for I in A.vectorToPy()]
assertTrue(B.dimension() == (2, 2), "WIP - MATRIX ERROR")
assertTrue(len(Apy) == B.rank(), "LENGTH ERROR")
Rpy = []
for Bit in Fn(Apy[0], B.arrayByLastAxis(), B.padFill()):
Rpy += Fn(Apy[1], Bit.vectorToPy(), Bit.padFill())
return makeArray(Rpy, [abs(I) for I in Apy], B.prototype())
def reshape(Fn, A, B):
"""
implement dyadic ⍴
"""
assertNotArray(A)
if A.isScalarLike():
Apy = confirmInteger(A.scalarToPy())
assertTrue(Apy >= 0, "DOMAIN ERROR")
if Apy == 0:
return makeEmptyVector(B.prototype())
Bpy = B.castToVectorPy()
return makeVector(Fn(Apy, Bpy), Apy, B.prototype())
if A.isEmptyVector():
Bpy = B.castToVectorPy()
return makeVector(Fn(1, Bpy), 1, B.prototype())
Apy = tuple([confirmInteger(I) for I in A.vectorToPy()])
assertTrue(Apy == (2, 2), "WIP - MATRIX ERROR")
for I in Apy:
assertTrue(I >= 0, "DOMAIN ERROR")
Bpy = B.castToVectorPy()
return makeArray(Fn(Apy, Bpy), Apy, 2 * B.prototype())
def rho(_, B):
"""
implement monadic ⍴
"""
if B.isArray():
return makeVector(B.dimension(), B.rank())
if B.isVector():
return makeVector((B.tally(), ), 1)
return makeEmptyVector()
def tail(Fn, B):
"""
implement monadic ↓
"""
assertNotArray(B, "RANK ERROR")
if B.isScalarLike():
return makeEmptyVector(B.prototype())
if B.isEmptyVector():
return B
return makeVector(Fn(B.vectorToPy()), B.dimension() - 1, B.prototype())
def expandFirst(Fn, A, B):
"""
implement dyadic ⍀
"""
assertNotArray(A)
if B.isScalar() and A.isEmptyVector():
return makeEmptyVector(B.prototype())
if B.isVectorLike():
if A.isScalar():
Apy = confirmInteger(A.scalarToPy())
assertTrue(Apy >= 0, "LENGTH ERROR")
if Apy == 0:
return makeVector(B.prototype(), 1, B.prototype())
Rpy = Fn(A.promoteScalarToVectorPy(), B.vectorToPy(), B.padFill())
return makeVector(Rpy, -1, B.prototype())
if B.isArray():
assertTrue(B.dimension() == (2, 2), "WIP - MATRIX ERROR")
Apy = [confirmInteger(I) for I in A.vectorToPy()]
if A.isScalarLike():
if Apy[0] < B.dimension()[0]:
assertError("LENGTH ERROR")
else:
assertError("DOMAIN ERROR")
else:
Lpy = sum(abs(I) if I != 0 else 1 for I in Apy)
Dpy = list(B.dimension())
Dpy[-1] = Lpy
assertTrue(tuple(Dpy) == (2, 2), "WIP - MATRIX ERROR")
Rpy = []
for Bit in B.arrayByFirstAxis():
Rpy += Fn(A.promoteScalarToVectorPy(), Bit.vectorToPy(),
B.padFill()[-1])
Rpy = monadicTranspose(Rpy, Dpy)
Dpy[0], Dpy[-1] = Dpy[-1], Dpy[0]
return makeArray(Rpy, Dpy, B.prototype())
def drop(Fn, A, B):
"""
implement dyadic ↓
"""
assertNotArray(A)
if B.isScalar():
if A.isEmptyVector():
return B
assertScalarLike(A)
Apy = confirmInteger(A.scalarToPy())
if Apy == 0:
return makeVector(B.vectorToPy(), 1, B.prototype())
return makeEmptyVector(B.prototype())
if B.isVector():
if A.isEmptyVector():
Apy = 1
else:
assertScalarLike(A)
Apy = confirmInteger(A.scalarToPy())
if Apy == 0:
return B
Rpy = Fn(Apy, B.vectorToPy())
return makeVector(Rpy, -1, B.prototype())
Apy = [confirmInteger(I) for I in A.vectorToPy()]
assertTrue(B.dimension() == (2, 2), "WIP - MATRIX ERROR")
assertTrue(len(Apy) == B.rank(), "LENGTH ERROR")
Rpy = []
for Bit in Fn(Apy[0], B.arrayByLastAxis()):
Rpy += Fn(Apy[1], Bit.vectorToPy())
Dpy = [max(0, I[1] - abs(I[0])) for I in zip(Apy, B.dimension())]
return makeArray(Rpy, Dpy, B.prototype())
def compressFirst(Fn, A, B):
"""
implement dyadic ⌿
"""
assertNotArray(A)
if B.isScalar() and A.isEmptyVector():
return makeEmptyVector(B.prototype())
if B.isVectorLike():
Rpy = Fn(A.promoteScalarToVectorPy(), B.vectorToPy(), B.padFill())
return makeVector(Rpy, -1, B.prototype())
if B.isArray():
assertTrue(B.dimension() == (2, 2), "WIP - MATRIX ERROR")
Apy = [confirmInteger(I) for I in A.vectorToPy()]
if A.isScalarLike():
Lpy = abs(Apy[0]) * B.dimension()[0]
else:
Lpy = sum(abs(I) for I in Apy)
Dpy = list(B.dimension())
Dpy[0] = Lpy
Dpy[0], Dpy[-1] = Dpy[-1], Dpy[0]
if Lpy == 0:
return makeArray(B.padFill(), Dpy, B.prototype())
assertTrue(tuple(Dpy) == (2, 2), "WIP - MATRIX ERROR")
Rpy = []
for Bit in B.arrayByFirstAxis():
Rpy += Fn(A.promoteScalarToVectorPy(), Bit.vectorToPy(),
B.padFill()[-1])
Rpy = monadicTranspose(Rpy, B.dimension())
return makeArray(Rpy, Dpy, B.prototype())
def partition(Fn, A, B):
"""
implement dyadic ⊂
"""
assertNotArray(A)
assertNotTrue(B.isScalar(), "RANK ERROR")
if A.isEmptyVector() and B.isEmptyVector():
return B
if A.isScalar():
Apy = confirmInteger(A.scalarToPy())
if Apy == 0:
return makeEmptyVector()
return makeScalar((B, ), B.prototype())
if B.isArray():
assertTrue(B.dimension() == (2, 2), "WIP - MATRIX ERROR")
Apy = A.vectorToPy()
assertTrue(len(Apy) == B.rank(), "LENGTH ERROR")
Rpy = []
for Bit in B.arrayByLastAxis():
Rpy += makeScalar((Fn(
A.vectorToPy(),
Bit.vectorToPy(),
), B.prototype()))
Dpy = list(B.dimension())
Dpy[-1] = 1
return makeArray(Rpy, Dpy, None)
return makeVector(Fn(A.vectorToPy(), B.vectorToPy()), -1, B.prototype())
raise exception
return None, 0
# ------------------------------
_ParserFunctions = (
extractNumber,
extractString,
extractString,
handleSystemCommand,
evaluateSubexpression,
evaluateBoxIO,
evaluateBoxTickIO,
lambda e, c: (makeEmptyVector(), 1),
lambda e, c: (None, len(e)),
)
# --------------
def parseFunction(expr, lhs):
"""
chose function that will parse the next token
"""
leader = expr[0]
if leader.isalpha():
return evaluateName
