jaredj/glotawk - Change K3OVRFE3Y23DN47XNAISH6XM5JGSCNRR6TOEO5KAKBNB54MFO27AC

more arithmetic operators and mathematical functions

Created by jaredj on June 29, 2025

K3OVRFE3Y23DN47XNAISH6XM5JGSCNRR6TOEO5KAKBNB54MFO27AC

Dependencies

In channels

main

Change contents

Insertion in sane_lisp at line 130 [4.900]

[3.173]

[4.3557]

lisp_eval_should_be '(+ 1 2 3)' '6' 'multiarg +'
lisp_eval_should_be '(* 2 3 5)' '30' 'multiarg *'
lisp_eval_should_be '(/ 3 5)' '0.6' '/'
lisp_eval_should_be '(// 6 5)' '1' 'quotient'
lisp_eval_should_be '(% 6 5)'  '1' 'modulo'
lisp_eval_should_be '(** 3 4)' '81' 'power'
lisp_eval_should_be '(atan2 0 -1)' '3.14159' 'atan2'

Insertion in lib-eval.awk at line 70 [6.21710]

[5.376]

(setq reduce (lambda (f xs) \
               (cond ((null xs) nil) \
                     ((atom xs) (f xs)) \
                     ((null (cdr xs)) (f (car xs))) \
                     (true (foldl f (car xs) (cdr xs)))))) \
\

Insertion in lib-eval.awk at line 80 [6.21710]

[2.87]

[3.3365]

(setq only2- (lambda (a b) (only2- a b))) \
(setq - (lambda xs (reduce only2- xs)))   \
(setq only2/ (lambda (a b) (only2/ a b))) \
(setq / (lambda xs (reduce only2/ xs)))   \
(setq only2// (lambda (a b) (only2// a b))) \
(setq // (lambda xs (reduce only2// xs))) \
(setq only2% (lambda (a b) (only2% a b))) \
(setq % (lambda xs (reduce only2% xs))) \
(setq only2** (lambda (a b) (only2** a b))) \
(setq ** (lambda xs (reduce only2** xs))) \
(setq atan2 (lambda (a b) (atan2 a b))) \
(setq string-length (lambda (x) (string-length x))) \

Replacement in eval.awk at line 211 [4.11057]

∅:D[7.1695] → [8.1785:1796]

B:BD[8.1785] → [8.1785:1796]

[7.1695]

[9.4551]


function _only2_add(a, b,      tv) {
    split(a, tv)
    if(tv[1] == "#") {
        a = tv[2]
        split(b, tv)
        if(tv[1] == "#") {
            b = tv[2]
            return _number(a+b)
        }
    }
    # if either a or b was not a number, we're here
    logg_err("_only2_add", "non-numeric operand", d)
    return _nil()
}
function _only2_multiply(a, b,      tv) {
    split(a, tv)
    if(tv[1] == "#") {
        a = tv[2]
        split(b, tv)
        if(tv[1] == "#") {
            b = tv[2]
            return _number(a*b)
        }
    }
    # if either a or b was not a number, we're here
    logg_err("_only2_multiply", "non-numeric operand", d)
    return _nil()
}
function _only2_subtract(a, b,      tv) {
    split(a, tv)
    if(tv[1] == "#") {
        a = tv[2]
        split(b, tv)
        if(tv[1] == "#") {
            b = tv[2]
            return _number(a-b)
        }
    }
    # if either a or b was not a number, we're here
    logg_err("_only2_subtract", "non-numeric operand", d)
    return _nil()
}
function _only2_divide(a, b,      tv) {
    split(a, tv)
    if(tv[1] == "#") {
        a = tv[2]
        split(b, tv)
        if(tv[1] == "#") {
            b = tv[2]
            if(b==0) {
                logg_err("_only2_divide", "divide by zero", d)
                return _nil()
            }
            return _number(a/b)
        }
    }
    # if either a or b was not a number, we're here
    logg_err("_only2_divide", "non-numeric operand", d)
    return _nil()
}
function _only2_quotient(a, b,      tv) {
    split(a, tv)
    if(tv[1] == "#") {
        a = tv[2]
        split(b, tv)
        if(tv[1] == "#") {
            b = tv[2]
            if(b==0) {
                logg_err("_only2_quotient", "quotient by zero", d)
                return _nil()
            }            
            return _number(int(a/b))
        }
    }
    # if either a or b was not a number, we're here
    logg_err("_only2_quotient", "non-numeric operand", d)
    return _nil()
}
function _only2_modulo(a, b,      tv) {
    split(a, tv)
    if(tv[1] == "#") {
        a = tv[2]
        split(b, tv)
        if(tv[1] == "#") {
            b = tv[2]
            if(b==0) {
                logg_err("_only2_modulo", "modulo by zero", d)
                return _nil()
            }
            return _number(a%b)
        }
    }
    # if either a or b was not a number, we're here
    logg_err("_only2_modulo", "non-numeric operand", d)
    return _nil()
}
function _only2_power(a, b,      tv) {
    split(a, tv)
    if(tv[1] == "#") {
        a = tv[2]
        split(b, tv)
        if(tv[1] == "#") {
            b = tv[2]
            return _number(a^b)
        }
    }
    # if either a or b was not a number, we're here
    logg_err("_only2_power", "non-numeric operand", d)
    return _nil()
}
function _atan2(a, b,      tv) {
    split(a, tv)
    if(tv[1] == "#") {
        a = tv[2]
        split(b, tv)
        if(tv[1] == "#") {
            b = tv[2]
            return _number(atan2(a,b))
        }
    }
    # if either a or b was not a number, we're here
    logg_err("_atan2", "non-numeric operand", d)
    return _nil()
}

Replacement in eval.awk at line 454 [4.11057]

B:BD[3.6026] → [5.465:519]

∅:D[5.519] → [9.8069:8188]

∅:D[3.6075] → [9.8069:8188]

B:BD[6.34951] → [9.8069:8188]

B:BD[9.8188] → [5.520:592]

∅:D[5.592] → [6.35124:35348]

∅:D[9.8255] → [6.35124:35348]

B:BD[6.35124] → [6.35124:35348]

B:BD[6.35348] → [2.88:136]

∅:D[2.136] → [6.35394:35510]

B:BD[6.35394] → [6.35394:35510]

B:BD[6.35510] → [2.137:953]

∅:D[2.953] → [6.35574:35656]

∅:D[9.8323] → [6.35574:35656]

B:BD[6.35574] → [6.35574:35656]

                } else if(car == _symbol("only2+")) {
                    a = _eval3(_cadr(form), env, env, d+1)
                    b = _eval3(_caddr(form), env, env, d+1)
                    logg_dbg("_eval3 only2+", "adding " a " and " b, d)
                    split(a, tv)
                    if(tv[1] == "#") {
                        a = tv[2]
                        split(b, tv)
                        if(tv[1] == "#") {
                            b = tv[2]
                            return _number(a+b)
                        }
                    }
                    # if either a or b was not a number, we're here
                    logg_err("_eval3 only2+", "non-numeric operand", d)
                    return _nil()
                } else if(car == _symbol("only2*")) {
                    a = _eval3(_cadr(form), env, env, d+1)
                    b = _eval3(_caddr(form), env, env, d+1)
                    logg_dbg("_eval3 only2*", "multiplying " a " and " b, d)
                    split(a, tv)
                    if(tv[1] == "#") {
                        a = tv[2]
                        split(b, tv)
                        if(tv[1] == "#") {
                            b = tv[2]
                            return _number(a*b)
                        }
                    }
                    # if either a or b was not a number, we're here
                    logg_err("_eval3 only2*", "non-numeric operand", d)
                    return _nil()
                } else if(car == _symbol("gc"))

[3.6026]

[6.35656]

                } else if(car == _symbol("only2+"))
                    return _only2_add(_eval3(_cadr(form), env, env, d+1),
                                      _eval3(_caddr(form), env, env, d+1))
                else if(car == _symbol("only2*"))
                    return _only2_multiply(_eval3(_cadr(form), env, env, d+1),
                                           _eval3(_caddr(form), env, env, d+1))
                else if(car == _symbol("only2-"))
                    return _only2_subtract(_eval3(_cadr(form), env, env, d+1),
                                           _eval3(_caddr(form), env, env, d+1))
                else if(car == _symbol("only2/"))
                    return _only2_divide(_eval3(_cadr(form), env, env, d+1),
                                         _eval3(_caddr(form), env, env, d+1))
                else if(car == _symbol("only2//"))
                    return _only2_quotient( \
                        _eval3(_cadr(form), env, env, d+1),
                        _eval3(_caddr(form), env, env, d+1))
                else if(car == _symbol("only2%"))
                    return _only2_modulo(_eval3(_cadr(form), env, env, d+1),
                                         _eval3(_caddr(form), env, env, d+1))
                else if(car == _symbol("only2**"))
                    return _only2_power(_eval3(_cadr(form), env, env, d+1),
                                        _eval3(_caddr(form), env, env, d+1))
                else if(car == _symbol("atan2"))
                    return _atan2(_eval3(_cadr(form), env, env, d+1),
                                  _eval3(_caddr(form), env, env, d+1))
                else if(car == _symbol("gc"))

Replacement in eval.awk at line 489 [4.11057]

B:BD[6.36101] → [6.36101:36128]

                    } else

[6.36101]

[9.8491]

                    } else {

Insertion in eval.awk at line 491 [4.11057]
[9.8566]
[6.36198]
```
                    }
```