gh-186: Rename operators.

Closes #186

Author: python-processing-unit

docs/SPECIFICATION.html

@@ -685,7 +685,7 @@
 
 The subsections below use a type-annotation convention. A type annotation is written as `TYPE name`, where `TYPE` is followed by one or more space characters and then the annotated name. A union notation such as `INT|FLT` restricts an argument to any one of the listed types. `ANY` denotes any runtime type (`BOOL`, `INT`, `FLT`, `STR`, `TNS`, `MAP`, `FUNC`, or `THR`), including extension-defined types when extensions are active, unless the signature narrows the set explicitly. `SYMBOL` is a pseudo-type indicating that the argument MUST be a plain unquoted identifier; such operators receive the symbol name rather than its runtime value.
 
-`MODULE` is a pseudo-type indicating that the argument MUST be a plain unquoted module identifier or a package-qualified module name using the language's `..` separator. A slash-separated signature such as `ADD/SUB/MUL` denotes a family of distinct operators that share the same argument rules and differ only in the named operation.
+`MODULE` is a pseudo-type indicating that the argument MUST be a plain unquoted module identifier or a package-qualified module name using the language's `..` separator. A comma-separated signature such as `+, -, *` denotes a family of distinct operators that share the same argument rules and differ only in the named operation.
 
 `EXTENSION` is a pseudo-type indicating that the argument MUST be a plain unquoted extension specifier used by `EXTEND`, excluding the platform filename suffix and optionally using package-style `..` separators.
 
@@ -737,15 +737,15 @@
 
 #### 9.1.3 Arithmetic operators
 
-- `INT|FLT ADD/SUB/MUL/DIV/CDIV/POW/MOD(INT|FLT a, INT|FLT b)` = MUST implement, respectively, addition, subtraction, multiplication, division, ceiling division, exponentiation, and remainder. Except where an operator explicitly states otherwise, `a` and `b` MUST have the same numeric type. Division by zero MUST raise a runtime error.
+- `INT|FLT +, -, *, /, CDIV, POW, MOD(INT|FLT a, INT|FLT b)` = MUST implement, respectively, addition, subtraction, multiplication, division, ceiling division, exponentiation, and remainder. Except where an operator explicitly states otherwise, `a` and `b` MUST have the same numeric type. Division by zero MUST raise a runtime error.
 
 - `INT|FLT NEG/ABS(INT|FLT value)` = MUST return the additive inverse or absolute value of `value`, respectively.
 
 - `INT|FLT GCD/LCM(INT|FLT a, INT|FLT b)` = MUST compute the greatest common divisor or least common multiple of `a` and `b`. Mixed `INT` and `FLT` operands MUST be rejected.
 
 - `INT|FLT ROOT(INT|FLT x, INT|FLT n)` = MUST compute the `n`th root of `x`. For `INT` operands, positive `n` MUST produce the greatest integer `r` such that `r^n <= x` when that notion is defined; `n = 0` MUST raise a runtime error; and negative-`n` integer results are valid only where the reciprocal remains an integer. For `FLT` operands, the result MUST be `x^(1/n)`, with negative `x` permitted only when `n` denotes an odd integer. Invalid roots MUST raise a runtime error.
 
-- `INT IADD/ISUB/IMUL/IDIV/IPOW/IROOT(INT|FLT a, INT|FLT b)` and `FLT FADD/FSUB/FMUL/FDIV/FPOW/FROOT(INT|FLT a, INT|FLT b)` = MUST first coerce both operands to the target numeric type and then perform the corresponding arithmetic operation. Failed coercion MUST raise a runtime error.
+- `INT I+, I-, I*, I/, IPOW, IROOT(INT|FLT a, INT|FLT b)` and `FLT F+, F-, F*, F/, FPOW, FROOT(INT|FLT a, INT|FLT b)` = MUST first coerce both operands to the target numeric type and then perform the corresponding arithmetic operation. Failed coercion MUST raise a runtime error.
 
 - `INT|FLT SUM/PROD(INT|FLT a1, ..., INT|FLT aN)`, `INT ISUM/IPROD(INT|FLT a1, ..., INT|FLT aN)`, and `FLT FSUM/FPROD(INT|FLT a1, ..., INT|FLT aN)` = MUST compute the corresponding aggregate sum or product across all arguments. The unprefixed forms MUST reject mixed `INT` and `FLT` operands.
 
@@ -815,11 +815,11 @@
 
 - `BOOL IN(ANY value, TNS tensor)` = MUST return `TRUE` if any tensor element is equal to `value` and `FALSE` otherwise.
 
-- `TNS MADD/MSUB/MMUL/MDIV(TNS x, TNS y)` = MUST perform elementwise tensor-tensor arithmetic. The input shapes MUST match exactly, the element types MUST be uniformly numeric and mutually compatible, and division by zero MUST raise a runtime error.
+- `TNS M+, M-, M*, M/(TNS x, TNS y)` = MUST perform elementwise tensor-tensor arithmetic. The input shapes MUST match exactly, the element types MUST be uniformly numeric and mutually compatible, and division by zero MUST raise a runtime error.
 
 - `TNS MSUM/MPROD(TNS t1, ..., TNS tN)` = MUST perform elementwise sum or product across tensors of identical shape and mutually compatible numeric element type.
 
-- `TNS TADD/TSUB/TMUL/TDIV/TPOW(TNS tensor, INT|FLT scalar)` = MUST perform tensor-scalar arithmetic. All tensor elements and the scalar MUST share the same numeric type, except where a specific operator explicitly permits widening. Division by zero MUST raise a runtime error.
+- `TNS T+, T-, T*, T/, TPOW(TNS tensor, INT|FLT scalar)` = MUST perform tensor-scalar arithmetic. All tensor elements and the scalar MUST share the same numeric type, except where a specific operator explicitly permits widening. Division by zero MUST raise a runtime error.
 
 ---
 

lib/std/csprng.pre

@@ -1,6 +1,6 @@
 ! ChaCha20-based cryptographically secure pseudorandom number generator
 
-INT MASK32 = SUB( POW(0b10, 0b100000), 1 )  ! 2^32-1
+INT MASK32 = -( POW(0b10, 0b100000), 1 )  ! 2^32-1
 
 ! ChaCha20 constants ("expand 32-byte k")
 MAP CH_CONST = < ^
@@ -19,7 +19,7 @@ INT ch_buf_pos = TLEN(ch_buf, 0b1)  ! set to buffer length to force refill
 FUNC INT ROTL32(INT x, INT n){
     INT x32 = BAND(x, MASK32)
     INT left = BAND(SHL(x32, n), MASK32)
-    INT right = SHR(x32, SUB(0b100000, n))  ! 32 - n
+    INT right = SHR(x32, -(0b100000, n))  ! 32 - n
     RETURN( BAND(BOR(left, right), MASK32) )
 }
 
@@ -29,13 +29,13 @@ FUNC INT QR(TNS s, INT ia, INT ib, INT ic, INT id){
     INT c = s[ic]
     INT d = s[id]
 
-    a = BAND( ADD(a, b), MASK32 )
+    a = BAND( +(a, b), MASK32 )
     d = ROTL32( BXOR(d, a), 0b10000 )   ! 16
-    c = BAND( ADD(c, d), MASK32 )
+    c = BAND( +(c, d), MASK32 )
     b = ROTL32( BXOR(b, c), 0b1100 )    ! 12
-    a = BAND( ADD(a, b), MASK32 )
+    a = BAND( +(a, b), MASK32 )
     d = ROTL32( BXOR(d, a), 0b1000 )    ! 8
-    c = BAND( ADD(c, d), MASK32 )
+    c = BAND( +(c, d), MASK32 )
     b = ROTL32( BXOR(b, c), 0b111 )     ! 7
 
     s[ia] = a
@@ -78,45 +78,45 @@ FUNC INT CHACHA_BLOCK(){
         QR(state, 0b100, 0b101, 0b1010, 0b1111)
     }
 
-    ch_buf[0b1] = BAND( ADD(state[0b1], CH_CONST<0b0>), MASK32 )
-    ch_buf[0b10] = BAND( ADD(state[0b10], CH_CONST<0b1>), MASK32 )
-    ch_buf[0b11] = BAND( ADD(state[0b11], CH_CONST<0b10>), MASK32 )
-    ch_buf[0b100] = BAND( ADD(state[0b100], CH_CONST<0b11>), MASK32 )
-    ch_buf[0b101] = BAND( ADD(state[0b101], k[0b1]), MASK32 )
-    ch_buf[0b110] = BAND( ADD(state[0b110], k[0b10]), MASK32 )
-    ch_buf[0b111] = BAND( ADD(state[0b111], k[0b11]), MASK32 )
-    ch_buf[0b1000] = BAND( ADD(state[0b1000], k[0b100]), MASK32 )
-    ch_buf[0b1001] = BAND( ADD(state[0b1001], k[0b101]), MASK32 )
-    ch_buf[0b1010] = BAND( ADD(state[0b1010], k[0b110]), MASK32 )
-    ch_buf[0b1011] = BAND( ADD(state[0b1011], k[0b111]), MASK32 )
-    ch_buf[0b1100] = BAND( ADD(state[0b1100], k[0b1000]), MASK32 )
-    ch_buf[0b1101] = BAND( ADD(state[0b1101], ch_counter), MASK32 )
-    ch_buf[0b1110] = BAND( ADD(state[0b1110], n[0b1]), MASK32 )
-    ch_buf[0b1111] = BAND( ADD(state[0b1111], n[0b10]), MASK32 )
-    ch_buf[0b10000] = BAND( ADD(state[0b10000], n[0b11]), MASK32 )
+    ch_buf[0b1] = BAND( +(state[0b1], CH_CONST<0b0>), MASK32 )
+    ch_buf[0b10] = BAND( +(state[0b10], CH_CONST<0b1>), MASK32 )
+    ch_buf[0b11] = BAND( +(state[0b11], CH_CONST<0b10>), MASK32 )
+    ch_buf[0b100] = BAND( +(state[0b100], CH_CONST<0b11>), MASK32 )
+    ch_buf[0b101] = BAND( +(state[0b101], k[0b1]), MASK32 )
+    ch_buf[0b110] = BAND( +(state[0b110], k[0b10]), MASK32 )
+    ch_buf[0b111] = BAND( +(state[0b111], k[0b11]), MASK32 )
+    ch_buf[0b1000] = BAND( +(state[0b1000], k[0b100]), MASK32 )
+    ch_buf[0b1001] = BAND( +(state[0b1001], k[0b101]), MASK32 )
+    ch_buf[0b1010] = BAND( +(state[0b1010], k[0b110]), MASK32 )
+    ch_buf[0b1011] = BAND( +(state[0b1011], k[0b111]), MASK32 )
+    ch_buf[0b1100] = BAND( +(state[0b1100], k[0b1000]), MASK32 )
+    ch_buf[0b1101] = BAND( +(state[0b1101], ch_counter), MASK32 )
+    ch_buf[0b1110] = BAND( +(state[0b1110], n[0b1]), MASK32 )
+    ch_buf[0b1111] = BAND( +(state[0b1111], n[0b10]), MASK32 )
+    ch_buf[0b10000] = BAND( +(state[0b10000], n[0b11]), MASK32 )
 
     RETURN(0b0)
 }
 
 FUNC INT REFILL_BUF(){
     CHACHA_BLOCK()
     ch_buf_pos = 0b0
-    ch_counter = BAND( ADD(ch_counter, 0b1), MASK32 )
+    ch_counter = BAND( +(ch_counter, 0b1), MASK32 )
     RETURN(0b0)
 }
 
 FUNC INT DERIVE_KEY_AND_NONCE(INT seed){
     INT s = BAND(seed, MASK32)
     FOR(i, 0b1000){  ! 8 key words (1000 == 8)
-        s = BAND( ADD( MUL(s, ^
+        s = BAND( +( *(s, ^
             0b01000001110001100100111001101101), ^
             0b00000000000000000011000000111001 ), ^
             MASK32 ^
         )
         ch_key[i] = s
     }
     FOR(j, 0b11){  ! 3 nonce words (11 == 3)
-        s = BAND( ADD( MUL(s, ^
+        s = BAND( +( *(s, ^
             0b01000001110001100100111001101101), ^
             0b00000000000000000011000000111001 ), ^
             MASK32 ^
@@ -138,8 +138,8 @@ FUNC INT NEXT(){
     IF( GTE(ch_buf_pos, TLEN(ch_buf, 0b1)) ){  ! buffer length
         REFILL_BUF()
     }
-    INT v = ch_buf[ ADD(ch_buf_pos, 0b1) ]
-    ch_buf_pos = ADD(ch_buf_pos, 0b1)
+    INT v = ch_buf[ +(ch_buf_pos, 0b1) ]
+    ch_buf_pos = +(ch_buf_pos, 0b1)
     RETURN(v)
 }
 
@@ -150,9 +150,9 @@ FUNC INT RANGE(INT max){
 
 FUNC INT RANGE_MIN_MAX(INT min, INT max){
     ASSERT( LTE(min, max) )
-    INT range = SUB(max, min)
+    INT range = -(max, min)
     IF( EQ(range, 0b0) ){ RETURN(min) }
     ASSERT( GT(range, 0b0) )
     INT offset = RANGE(range)
-    RETURN( ADD(offset, min) )
+    RETURN( +(offset, min) )
 }

lib/std/diff.pre

@@ -31,7 +31,7 @@ FUNC STR UNIFIED(STR mod, STR src){
                 out = _append_line(out, JOIN("+", right))
             }
         }
-        i = ADD(i, 0d1)
+        i = +(i, 0d1)
     }
     RETURN(out)
 }
@@ -61,7 +61,7 @@ FUNC STR SIDE_BY_SIDE(STR mod, STR src){
         IF( NEQ(left, right)){ marker = "|" }
         STR line = JOIN(left, " ", marker, " ", right)
         out = _append_line(out, line)
-        i = ADD(i, 0d1)
+        i = +(i, 0d1)
     }
     RETURN(out)
 }

lib/std/image/init.pre

@@ -80,17 +80,17 @@ FUNC TNS FLIP_H(TNS img){
 }
 
 FUNC TNS INVERT(TNS img){
-    TNS return = MSUB(TNS(SHAPE(img), 0xFF), img)
+    TNS return = M-(TNS(SHAPE(img), 0xFF), img)
     return[# , # , 0d4] = img[# , # , 0d4] ! Preserve alpha
     POP(return)
 }
 
 FUNC TNS RECT(TNS img, INT x, INT y, INT width, INT height, TNS color, INT fill, INT thickness){
     TNS pts = [ ^
         [x, y], ^
-        [ADD(x, SUB(width, 0d1)), y], ^
-        [ADD(x, SUB(width, 0d1)), ADD(y, SUB(height, 0d1))], ^
-        [x, ADD(y, SUB(height, 0d1))], ^
+        [+(x, -(width, 0d1)), y], ^
+        [+(x, -(width, 0d1)), +(y, -(height, 0d1))], ^
+        [x, +(y, -(height, 0d1))], ^
         [x, y] ^
     ]
     RETURN(POLYGON(img, pts, color, fill, thickness))

lib/std/prime.pre

@@ -12,40 +12,40 @@ FUNC BOOL IS_PRIME(INT n){
         RETURN(FALSE)
     }
     INT i = 0d3
-    WHILE(LTE(MUL(i, i), n)){
+    WHILE(LTE(*(i, i), n)){
         IF(EQ(MOD(n, i), 0d0)){
             RETURN(FALSE)
         }
-        ADD(@i, 0d2)
+        +(@i, 0d2)
     }
     RETURN(TRUE)
 }
 
 FUNC INT NEXT_PRIME(INT start){
-    INT n = ADD(start, 0d1)
+    INT n = +(start, 0d1)
     WHILE(0d1){
         IF(IS_PRIME(n)){
             RETURN(n)
         }
-        ADD(@n, 0d1)
+        +(@n, 0d1)
     }
 }
 
 FUNC INT PREV_PRIME(INT start){
-    INT n = SUB(start, 0d1)
+    INT n = -(start, 0d1)
     WHILE(GT(n, 0d1)){
         IF(IS_PRIME(n)){
             RETURN(n)
         }
-        SUB(@n, 0d1)
+        -(@n, 0d1)
     }
     RETURN(0d0)
 }
 
 FUNC BOOL IS_MERSENNE_PRIME(INT p){
     IF(IS_PRIME(p)){
         INT exp = POW(0d2, p)
-        INT mersenne = SUB(exp, 0d1)
+        INT mersenne = -(exp, 0d1)
         IF(IS_PRIME(mersenne)){
             RETURN(TRUE)
         }
@@ -63,15 +63,15 @@ FUNC TNS FACTOR(INT n){
     INT p = 0d2
     INT coll_len = 0d0
     TNS coll = [0d0]  ! placeholder, real shape tracked by coll_len
-    WHILE(LTE(MUL(p, p), n)){
+    WHILE(LTE(*(p, p), n)){
         IF(EQ(MOD(n, p), 0d0)){
             IF(EQ(coll_len, 0d0)){
                 TNS first = [p]
                 coll = first
                 coll_len = 0d1
             } ELSE {
                 INT old_len = TLEN(coll, 0d1)
-                INT new_len = ADD(old_len, 0d1)
+                INT new_len = +(old_len, 0d1)
                 TNS new_coll = TNS([new_len], 0d0)
                 FOR(i, old_len){
                     new_coll[i] = coll[i]
@@ -80,9 +80,9 @@ FUNC TNS FACTOR(INT n){
                 coll = new_coll
                 coll_len = new_len
             }
-            DIV(@n, p)
+            /(@n, p)
         } ELSE {
-            p = NEXT_PRIME( ADD(p, 0d1) )
+            p = NEXT_PRIME( +(p, 0d1) )
         }
     }
     IF(GT(n, 0d1)){
@@ -92,7 +92,7 @@ FUNC TNS FACTOR(INT n){
             coll_len = 0d1
         } ELSE {
             INT old_len2 = TLEN(coll, 0d1)
-            INT new_len2 = ADD(old_len2, 0d1)
+            INT new_len2 = +(old_len2, 0d1)
             TNS new_coll2 = TNS([new_len2], 0d0)
             FOR(j, old_len2){
                 new_coll2[j] = coll[j]

lib/std/prng.pre

@@ -1,6 +1,6 @@
 ! LCG-based pseudorandom number generator
 
-INT MASK32 = SUB( POW(0b10, 0b100000), 0b1 )  ! 2^32 - 1
+INT MASK32 = -( POW(0b10, 0b100000), 0b1 )  ! 2^32 - 1
 
 ! LCG constants: state = (A * state + C) mod 2^32
 INT LCG_A = 0b000110010110011000001101          ! 1664525
@@ -13,7 +13,7 @@ FUNC INT SEED(INT seed){
 }
 
 FUNC INT NEXT(){
-    lcg_state = BAND( ADD( MUL(LCG_A, lcg_state), LCG_C ), MASK32 )
+    lcg_state = BAND( +( *(LCG_A, lcg_state), LCG_C ), MASK32 )
     RETURN(lcg_state)
 }
 
@@ -24,9 +24,9 @@ FUNC INT RANGE(INT max){
 
 FUNC INT RANGE_MIN_MAX(INT min, INT max){
     ASSERT( LTE(min, max) )
-    INT range = SUB(max, min)
+    INT range = -(max, min)
     IF( EQ(range, 0b0) ){ RETURN(min) }
     ASSERT( GT(range, 0b0) )
     INT offset = RANGE(range)
-    RETURN( ADD(offset, min) )
+    RETURN( +(offset, min) )
 }