Rename SCATTER to SCAT; fix REPL PRINT output error; rewrite stats.asmln; clean up the rest of the stdlib

Author: python-processing-unit

SPECIFICATION.html

@@ -453,15 +453,14 @@
 - `ALL(ANY: a1, ..., ANY: aN):INT` ; Boolean AND (empty string -> false, non-empty -> true)
 - `ANY(ANY: a1, ..., ANY: aN):INT` ; Boolean OR (empty string -> false, non-empty -> true)
 - `JOIN(INT|STR: a1, INT|STR: a2, ..., INT|STR: aN):INT|STR` ; `INT` -> concatenate binary spellings with consistent sign; `STR` -> concatenate strings; mixing `INT` and `STR` or supplying tensors raises an error
-- `PROD(INT: a1, ..., INT: aN):INT` ; product of the arguments
 - `PROD(INT|FLT: a1, ..., INT|FLT: aN):INT|FLT` ; product of the arguments (no mixing INT/FLT)
 
 ### Tensor operations
 - `SHAPE(TNS: tensor):TNS` — Returns the tensor's shape as a 1D `TNS` (vector) of `INT` lengths (one entry per dimension).
 - `TLEN(TNS: tensor, INT: dim):INT` — Returns the length of the specified 1-based dimension. Errors if `dim` is out of range.
 - `FLIP(INT|STR: obj):INT|STR` — For `INT` input, returns an `INT` whose binary-digit spelling is the reverse of the absolute-value binary spelling of `obj` (sign is preserved). For `STR` input, returns the character-reversed `STR`.
 - `TFLIP(TNS: obj, INT: dim):TNS` — Returns a new `TNS` with the elements along 1-based dimension `dim` reversed. Errors if `dim` is out of range.
-- `SCATTER(TNS: src, TNS: dst, TNS: ind):TNS` — Returns a copy of `dst` with a rectangular slice replaced by `src`. `ind` must be a 2D tensor of `INT` pairs with shape `[TLEN(dst, 1), 10]` (binary `10` = decimal 2), i.e., one `[lo, hi]` row per destination dimension (rank; for example `rank = TLEN(SHAPE(dst), 1)`). Indices are 1-based; negatives follow the tensor indexing rules (for example, `-1` is the last element) and `0` is invalid. For each dimension, the inclusive span `hi - lo + 1` must equal the corresponding `src` dimension length, and all bounds must fall within `dst`. Elements outside the slice are copied from `dst` unchanged.
+- `SCAT(TNS: src, TNS: dst, TNS: ind):TNS` — Returns a copy of `dst` with a rectangular slice replaced by `src`. `ind` must be a 2D tensor of `INT` pairs with shape `[TLEN(dst, 1), 10]` (binary `10` = decimal 2), i.e., one `[lo, hi]` row per destination dimension (rank; for example `rank = TLEN(SHAPE(dst), 1)`). Indices are 1-based; negatives follow the tensor indexing rules (for example, `-1` is the last element) and `0` is invalid. For each dimension, the inclusive span `hi - lo + 1` must equal the corresponding `src` dimension length, and all bounds must fall within `dst`. Elements outside the slice are copied from `dst` unchanged.
 - `FILL(TNS: tensor, ANY: value):TNS` — Returns a new tensor with the same shape as `tensor`, filled with `value`. The supplied value`s type must match the existing element type at every position.
 - `TNS(TNS: shape, ANY: value):TNS` — Creates a new `TNS` with the shape described by a 1D `TNS` of positive `INT` lengths, filled with `value`.
 - `CONV(TNS: x, TNS: kernel):TNS` — N-dimensional discrete convolution producing an output tensor with the same shape as `x`. The `kernel` must have the same rank as `x` and each kernel dimension length must be odd (so the kernel has a well-defined center). At the boundaries, out-of-range sample coordinates are clamped to the nearest valid index (replicate padding). Both tensors must contain only `INT` or only `FLT` elements (no mixed element types within a tensor). If both tensors are `INT`-valued, the output is an `INT` tensor; otherwise the output is a `FLT` tensor.

asm-lang.exe

@@ -60,10 +60,19 @@ def run_repl(*, verbose: bool, services) -> int:
     print("\x1b[38;2;153;221;255mASM-Lang\033[0m REPL. Enter statements, blank line to run buffer.") # "ASM-Lang" in light blue
     # Use "<repl>" as the REPL's effective source filename so that MAIN() and imports behave
     had_output = False
+    # Tracks whether any PRINT has occurred since the last REPL input.
+    first_print_since_input = True
+
     def _output_sink(text: str) -> None:
-        nonlocal had_output
+        nonlocal had_output, first_print_since_input
+        # If this is not the first PRINT since the last REPL input,
+        # emit a leading newline so outputs appear on separate lines.
+        if not first_print_since_input:
+            print()
+        first_print_since_input = False
         had_output = True
-        print(text, end="")
+        # Print the text without appending a trailing newline.
+        print(text, end="", flush=True)
 
     picked = services.hook_registry.pick_repl() if services is not None else None
     if picked is not None:
@@ -120,6 +129,10 @@ def _output_sink(text: str) -> None:
             print()
             break
 
+        # Reset per-input PRINT tracking so the next PRINT is treated as
+        # the first since this REPL input.
+        first_print_since_input = True
+
         stripped = line.strip()
 
         is_block_start = False

asm-lang.py

@@ -523,7 +523,7 @@ def __init__(self) -> None:
         self._register_custom("CONV", 2, 2, self._convolve)
         self._register_custom("FLIP", 1, 1, self._flip)
         self._register_custom("TFLIP", 2, 2, self._tflip)
-        self._register_custom("SCATTER", 3, 3, self._scatter)
+        self._register_custom("SCAT", 3, 3, self._scatter)
         self._register_custom("PARALLEL", 1, None, self._parallel)
 
     def _register_int_only(self, name: str, arity: int, func: Callable[..., int]) -> None:
@@ -2966,36 +2966,36 @@ def _scatter(
         ___: Environment,
         location: SourceLocation,
     ) -> Value:
-        """SCATTER(TNS: src, TNS: dst, TNS: ind):TNS
+        """SCAT(TNS: src, TNS: dst, TNS: ind):TNS
 
         Copy `src` into a slice of `dst` defined by per-dimension [lo, hi] pairs.
         Returns a new tensor shaped like `dst` with the slice replaced.
         """
 
-        src = self._expect_tns(args[0], "SCATTER", location)
-        dst = self._expect_tns(args[1], "SCATTER", location)
-        ind = self._expect_tns(args[2], "SCATTER", location)
+        src = self._expect_tns(args[0], "SCAT", location)
+        dst = self._expect_tns(args[1], "SCAT", location)
+        ind = self._expect_tns(args[2], "SCAT", location)
 
         rank = len(dst.shape)
         if len(src.shape) != rank:
-            raise ASMRuntimeError("SCATTER requires src and dst to have the same rank", location=location, rewrite_rule="SCATTER")
+            raise ASMRuntimeError("SCAT requires src and dst to have the same rank", location=location, rewrite_rule="SCAT")
         if len(ind.shape) != 2 or ind.shape[0] != rank or ind.shape[1] != 2:
-            raise ASMRuntimeError("SCATTER indices must have shape [rank, 2]", location=location, rewrite_rule="SCATTER")
+            raise ASMRuntimeError("SCAT indices must have shape [rank, 2]", location=location, rewrite_rule="SCAT")
 
         pairs = ind.data.reshape((ind.shape[0], ind.shape[1]))
         slices: List[Tuple[int, int]] = []
 
         for axis in range(rank):
-            lo_raw = self._expect_int(pairs[axis, 0], "SCATTER", location)
-            hi_raw = self._expect_int(pairs[axis, 1], "SCATTER", location)
+            lo_raw = self._expect_int(pairs[axis, 0], "SCAT", location)
+            hi_raw = self._expect_int(pairs[axis, 1], "SCAT", location)
             dim_len = dst.shape[axis]
-            lo = self._resolve_tensor_index(lo_raw, dim_len, "SCATTER", location)
-            hi = self._resolve_tensor_index(hi_raw, dim_len, "SCATTER", location)
+            lo = self._resolve_tensor_index(lo_raw, dim_len, "SCAT", location)
+            hi = self._resolve_tensor_index(hi_raw, dim_len, "SCAT", location)
             if lo > hi:
-                raise ASMRuntimeError("SCATTER expects lo <= hi for each dimension", location=location, rewrite_rule="SCATTER")
+                raise ASMRuntimeError("SCAT expects lo <= hi for each dimension", location=location, rewrite_rule="SCAT")
             span = hi - lo + 1
             if span != src.shape[axis]:
-                raise ASMRuntimeError("SCATTER source shape must match index span", location=location, rewrite_rule="SCATTER")
+                raise ASMRuntimeError("SCAT source shape must match index span", location=location, rewrite_rule="SCAT")
             slices.append((lo - 1, hi))
 
         out_data = dst.data.copy()

interpreter.py

@@ -1,33 +1,40 @@
-#ChaCha20-based cryptographically secure pseudorandom number generator
+# ChaCha20-based cryptographically secure pseudorandom number generator
 #
 # API:
-# CS_PRNG_SEED(INT:seed) -> INT
-# CS_PRNG_NEXT() -> INT
-# CS_PRNG_RANGE(INT:max) -> INT
-# CS_PRNG_RANGE_MIN_MAX(INT:min, INT:max) -> INT
+# SEED(INT: seed) -> INT
+# NEXT() -> INT
+# RANGE(INT: max) -> INT
+# RANGE_MIN_MAX(INT: min, INT: max) -> INT
 
 INT: MASK32 = SUB( POW(10,100000), 1 )  # 2^32-1
 
 # ChaCha20 constants ("expand 32-byte k")
-INT: CH_CONST0 = 01100001011100000111000001100101
-INT: CH_CONST1 = 00110011001000000110010001101110
-INT: CH_CONST2 = 01111001011000100010110100110010
-INT: CH_CONST3 = 01101011001000000110010101110100
-
-TNS: ch_key = [0,0,0,0,0,0,0,0]
-TNS: ch_nonce = [0,0,0]
+MAP: CH_CONST = < ^
+    0 = 01100001011100000111000001100101, ^
+    1 = 00110011001000000110010001101110, ^
+    10 = 01111001011000100010110100110010, ^
+    11 = 01101011001000000110010101110100 ^
+>
+
+TNS: ch_key = TNS([1000], 0)  # 8 words
+TNS: ch_nonce = [0, 0, 0] # use literals for short TNS
 INT: ch_counter = 0
-TNS: ch_buf = [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]
-INT: ch_buf_pos = 10000  # 16 -> force refill
+TNS: ch_buf = TNS([10000], 0) # 16 words
+INT: ch_buf_pos = TLEN(ch_buf, 1)  # set to buffer length to force refill
 
-FUNC ROTL32(INT:x, INT:n):INT{
+FUNC ROTL32(INT: x, INT: n):INT{
     INT: x32 = BAND(x, MASK32)
-    INT: left = BAND( SHL(x32, n), MASK32 )
-    INT: right = DIV( x32, POW(10, SUB(100000, n)) )
-    RETURN( BOR(left, right) )
+    INT: left = BAND(SHL(x32, n), MASK32)
+    INT: right = SHR(x32, SUB(100000, n))  # 32 - n
+    RETURN( BAND(BOR(left, right), MASK32) )
 }
 
-FUNC QR(INT:a, INT:b, INT:c, INT:d):TNS{
+FUNC QR(TNS: s, INT: ia, INT: ib, INT: ic, INT: id):INT{
+    INT: a = s[ia]
+    INT: b = s[ib]
+    INT: c = s[ic]
+    INT: d = s[id]
+
     a = BAND( ADD(a, b), MASK32 )
     d = ROTL32( BXOR(d, a), 10000 )   # 16
     c = BAND( ADD(c, d), MASK32 )
@@ -36,154 +43,122 @@ FUNC QR(INT:a, INT:b, INT:c, INT:d):TNS{
     d = ROTL32( BXOR(d, a), 1000 )    # 8
     c = BAND( ADD(c, d), MASK32 )
     b = ROTL32( BXOR(b, c), 111 )     # 7
-    TNS: coll = [a, b, c, d]
-    RETURN(coll)
+
+    s[ia] = a
+    s[ib] = b
+    s[ic] = c
+    s[id] = d
+    RETURN(0)
 }
 
-FUNC CHACHA_BLOCK():TNS{
-    INT: x0 = CH_CONST0
-    INT: x1 = CH_CONST1
-    INT: x2 = CH_CONST2
-    INT: x3 = CH_CONST3
-    INT: x4 = ch_key[1]
-    INT: x5 = ch_key[10]
-    INT: x6 = ch_key[11]
-    INT: x7 = ch_key[100]
-    INT: x8 = ch_key[101]
-    INT: x9 = ch_key[110]
-    INT: x10 = ch_key[111]
-    INT: x11 = ch_key[1000]
-    INT: x12 = ch_counter
-    INT: x13 = ch_nonce[1]
-    INT: x14 = ch_nonce[10]
-    INT: x15 = ch_nonce[11]
-    INT: i = 0
-    WHILE( LT(i, 1010) ){  # 10 double-rounds
-        TNS: qr = QR(x0, x4, x8,  x12)
-        x0 = qr[1]
-        x4 = qr[10]
-        x8  = qr[11]
-        x12 = qr[100]
-        qr = QR(x1, x5, x9,  x13)
-        x1 = qr[1]
-        x5 = qr[10]
-        x9  = qr[11]
-        x13 = qr[100]
-        qr = QR(x2, x6, x10, x14)
-        x2 = qr[1]
-        x6 = qr[10]
-        x10 = qr[11]
-        x14 = qr[100]
-        qr = QR(x3, x7, x11, x15)
-        x3 = qr[1]
-        x7 = qr[10]
-        x11 = qr[11]
-        x15 = qr[100]
-
-        qr = QR(x0, x5, x10, x15)
-        x0 = qr[1]
-        x5 = qr[10]
-        x10 = qr[11]
-        x15 = qr[100]
-        qr = QR(x1, x6, x11, x12)
-        x1 = qr[1]
-        x6 = qr[10]
-        x11 = qr[11]
-        x12 = qr[100]
-        qr = QR(x2, x7, x8,  x13)
-        x2 = qr[1]
-        x7 = qr[10]
-        x8  = qr[11]
-        x13 = qr[100]
-        qr = QR(x3, x4, x9,  x14)
-        x3 = qr[1]
-        x4 = qr[10]
-        x9  = qr[11]
-        x14 = qr[100]
-
-        i = ADD(i, 1)
+FUNC CHACHA_BLOCK():INT{
+    TNS: k = ch_key
+    TNS: n = ch_nonce
+    TNS: state = [ ^
+        CH_CONST<0>, ^
+        CH_CONST<1>, ^
+        CH_CONST<10>, ^
+        CH_CONST<11>, ^
+        k[1], ^
+        k[10], ^
+        k[11], ^
+        k[100], ^
+        k[101], ^
+        k[110], ^
+        k[111], ^
+        k[1000], ^
+        ch_counter, ^
+        n[1], ^
+        n[10], ^
+        n[11] ^
+    ]
+    FOR(i, 1010){  # 10 double-rounds
+        QR(state, 1, 101, 1001, 1101)
+        QR(state, 10, 110, 1010, 1110)
+        QR(state, 11, 111, 1011, 1111)
+        QR(state, 100, 1000, 1100, 10000)
+
+        QR(state, 1, 110, 1011, 10000)
+        QR(state, 10, 111, 1100, 1101)
+        QR(state, 11, 1000, 1001, 1110)
+        QR(state, 100, 101, 1010, 1111)
     }
 
-    x0 = BAND( ADD(x0, CH_CONST0), MASK32 )
-    x1 = BAND( ADD(x1, CH_CONST1), MASK32 )
-    x2 = BAND( ADD(x2, CH_CONST2), MASK32 )
-    x3 = BAND( ADD(x3, CH_CONST3), MASK32 )
-    x4 = BAND( ADD(x4, ch_key[1]), MASK32 )
-    x5 = BAND( ADD(x5, ch_key[10]), MASK32 )
-    x6 = BAND( ADD(x6, ch_key[11]), MASK32 )
-    x7 = BAND( ADD(x7, ch_key[100]), MASK32 )
-    x8 = BAND( ADD(x8, ch_key[101]), MASK32 )
-    x9 = BAND( ADD(x9, ch_key[110]), MASK32 )
-    x10 = BAND( ADD(x10, ch_key[111]), MASK32 )
-    x11 = BAND( ADD(x11, ch_key[1000]), MASK32 )
-    x12 = BAND( ADD(x12, ch_counter), MASK32 )
-    x13 = BAND( ADD(x13, ch_nonce[1]), MASK32 )
-    x14 = BAND( ADD(x14, ch_nonce[10]), MASK32 )
-    x15 = BAND( ADD(x15, ch_nonce[11]), MASK32 )
-
-    TNS: out = [x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15]
-    RETURN(out)
+    ch_buf[1] = BAND( ADD(state[1], CH_CONST<0>), MASK32 )
+    ch_buf[10] = BAND( ADD(state[10], CH_CONST<1>), MASK32 )
+    ch_buf[11] = BAND( ADD(state[11], CH_CONST<10>), MASK32 )
+    ch_buf[100] = BAND( ADD(state[100], CH_CONST<11>), MASK32 )
+    ch_buf[101] = BAND( ADD(state[101], k[1]), MASK32 )
+    ch_buf[110] = BAND( ADD(state[110], k[10]), MASK32 )
+    ch_buf[111] = BAND( ADD(state[111], k[11]), MASK32 )
+    ch_buf[1000] = BAND( ADD(state[1000], k[100]), MASK32 )
+    ch_buf[1001] = BAND( ADD(state[1001], k[101]), MASK32 )
+    ch_buf[1010] = BAND( ADD(state[1010], k[110]), MASK32 )
+    ch_buf[1011] = BAND( ADD(state[1011], k[111]), MASK32 )
+    ch_buf[1100] = BAND( ADD(state[1100], k[1000]), MASK32 )
+    ch_buf[1101] = BAND( ADD(state[1101], ch_counter), MASK32 )
+    ch_buf[1110] = BAND( ADD(state[1110], n[1]), MASK32 )
+    ch_buf[1111] = BAND( ADD(state[1111], n[10]), MASK32 )
+    ch_buf[10000] = BAND( ADD(state[10000], n[11]), MASK32 )
+
+    RETURN(0)
 }
 
 FUNC REFILL_BUF():INT{
-    ch_buf = CHACHA_BLOCK()
+    CHACHA_BLOCK()
     ch_buf_pos = 0
     ch_counter = BAND( ADD(ch_counter, 1), MASK32 )
     RETURN(0)
 }
 
-FUNC DERIVE_KEY_AND_NONCE(INT:seed):INT{
+FUNC DERIVE_KEY_AND_NONCE(INT: seed):INT{
     INT: s = BAND(seed, MASK32)
-    INT: i = 0
-    WHILE( LT(i, 1000) ){  # 8 key words (1000 == 8)
+    FOR(i, 1000){  # 8 key words (1000 == 8)
         s = BAND( ADD( MUL(s, ^
             01000001110001100100111001101101), ^
             00000000000000000011000000111001 ), ^
             MASK32 ^
         )
-        ch_key[ ADD(i, 1) ] = s
-        i = ADD(i, 1)
+        ch_key[i] = s
     }
-    INT: j = 0
-    WHILE( LT(j, 11) ){  # 3 nonce words (11 == 3)
+    FOR(j, 11){  # 3 nonce words (11 == 3)
         s = BAND( ADD( MUL(s, ^
             01000001110001100100111001101101), ^
             00000000000000000011000000111001 ), ^
             MASK32 ^
         )
-        ch_nonce[ ADD(j, 1) ] = s
-        j = ADD(j, 1)
+        ch_nonce[j] = s
     }
     RETURN(0)
 }
 
-FUNC CS_PRNG_SEED(INT:seed):INT{
+FUNC SEED(INT: seed):INT{
     DERIVE_KEY_AND_NONCE(seed)
     ch_counter = 0
-    ch_buf = [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]
-    ch_buf_pos = 10000  # 16
+    ch_buf = TNS([10000], 0)
+    ch_buf_pos = TLEN(ch_buf, 1)  # set to buffer length to force refill
     RETURN(ch_counter)
 }
 
-FUNC CS_PRNG_NEXT():INT{
-    IF( GTE(ch_buf_pos, 10000) ){  # 16
+FUNC NEXT():INT{
+    IF( GTE(ch_buf_pos, TLEN(ch_buf, 1)) ){  # buffer length
         REFILL_BUF()
     }
     INT: v = ch_buf[ ADD(ch_buf_pos, 1) ]
     ch_buf_pos = ADD(ch_buf_pos, 1)
     RETURN(v)
 }
 
-FUNC CS_PRNG_RANGE(INT:max):INT{
+FUNC RANGE(INT: max):INT{
     ASSERT( GT(max, 0) )
-    RETURN( MOD(CS_PRNG_NEXT(), max) )
+    RETURN( MOD(NEXT(), max) )
 }
 
-FUNC CS_PRNG_RANGE_MIN_MAX(INT:min, INT:max):INT{
+FUNC RANGE_MIN_MAX(INT: min, INT: max):INT{
     ASSERT( LTE(min, max) )
     INT: range = SUB(max, min)
     IF( EQ(range, 0) ){ RETURN(min) }
     ASSERT( GT(range, 0) )
-    INT: offset = CS_PRNG_RANGE(range)
+    INT: offset = RANGE(range)
     RETURN( ADD(offset, min) )
 }