def iota(B):
"""
the iterator for monadic ⍳
"""
IO = indexOrigin()
return range(IO, B + IO)
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 pick(_, A, B):
"""
implement dyadic ⊃
"""
assertNotArray(A)
assertNotArray(B)
if A.isEmptyVector():
return B
assertNotScalar(B)
if B.isVector():
IO = indexOrigin()
try:
for X in A.vectorToPy():
X = confirmInteger(X)
assertTrue(X >= IO, "INDEX ERROR")
if isinstance(B, aplQuantity):
B = B.vectorToPy()[X - IO]
else:
assertError("RANK ERROR")
except IndexError:
assertError("INDEX ERROR")
if isinstance(B, aplQuantity):
return B
return makeScalar((B, ), None)
def transpose(_, A, B):
"""
implement dyadic ⍉
"""
assertNotArray(A)
if B.isArray():
assertTrue(A.tally() == B.rank(), "LENGTH ERROR")
IO = indexOrigin()
Apy = [confirmInteger(I) - IO for I in A.vectorToPy()]
high = B.rank() + 1
assertTrue(all(x >= 0 and x <= high for x in Apy), "DOMAIN ERROR")
assertTrue(sum(Apy) <= sum(range(B.rank())), "DOMAIN ERROR")
Rpy = dyadicTranspose(B.arrayToPy(), Apy, B.dimension())
def newDimensions(A, B):
"""
determine dimensions of the transposed result
"""
R = list(range(len(A)))
for I in R:
H = [B[X] for X in R if A[X] == I]
if H:
yield min(H)
Dpy = tuple(newDimensions(Apy, B.dimension()))
if len(Dpy) == 1:
return makeVector(Rpy, Dpy[0], None)
return makeArray(Rpy, Dpy, None)
if B.isVector():
assertScalarLike(A)
Apy = confirmInteger(A.scalarToPy())
assertTrue(Apy == 1, "DOMAIN ERROR")
return B
assertEmptyVector(A)
return B
def saveIndexOrigin():
"""
return ⎕IO so the test function can save it
"""
return systemVariables.indexOrigin()
def __init__(self, B):
self._B = B.__iter__()
self._IO = indexOrigin()
def __init__(self, A, B):
self._A = A.__iter__()
self._B = B.__iter__()
self._L = -1
self._V = []
self._IO = indexOrigin()