lisp_eval_should_be '(sin 0)' '0' 'sin'
lisp_eval_should_be '(cos 0)' '1' 'cos'
lisp_eval_should_be '(sqrt 9)' '3' 'sqrt'
lisp_eval_should_be '(tolower "Title Case")' '"title case"' 'tolower'

\
(setq cos (lambda (x) (cos x))) \
(setq sin (lambda (x) (sin x))) \
(setq exp (lambda (x) (exp x))) \
(setq log (lambda (x) (log x))) \
(setq sqrt (lambda (x) (sqrt x))) \
(setq rand (lambda () (rand))) \
(setq srand (lambda (x) (srand x))) \
(setq int (lambda (x) (int x))) \
(setq system (lambda (x) (system x))) \
(setq tolower (lambda (x) (tolower x))) \
(setq toupper (lambda (x) (toupper x))) \

}
function _cos(a,     tv) {
    split(a, tv)
    if(tv[1] == "#") {
        a = tv[2]
        return _number(cos(a))
    } else {
        logg_err("_cos", "non-numeric-operand", d)
        return _nil()
    }
}
function _sin(a,     tv) {
    split(a, tv)
    if(tv[1] == "#") {
        a = tv[2]
        return _number(sin(a))
    } else {
        logg_err("_sin", "non-numeric-operand", d)
        return _nil()
    }
}
function _exp(a,     tv) {
    split(a, tv)
    if(tv[1] == "#") {
        a = tv[2]
        return _number(exp(a))
    } else {
        logg_err("_exp", "non-numeric-operand", d)
        return _nil()
    }
}
function _log(a,     tv) {
    split(a, tv)
    if(tv[1] == "#") {
        a = tv[2]
        return _number(log(a))
    } else {
        logg_err("_log", "non-numeric-operand", d)
        return _nil()
    }
}
function _sqrt(a,     tv) {
    split(a, tv)
    if(tv[1] == "#") {
        a = tv[2]
        return _number(sqrt(a))
    } else {
        logg_err("_sqrt", "non-numeric-operand", d)
        return _nil()
    }
}
function _srand(a,     tv) {
    split(a, tv)
    if(tv[1] == "#") {
        a = tv[2]
        return _number(srand(a))
    } else {
        logg_err("_srand", "non-numeric-operand", d)
        return _nil()
    }

function _int(a,     tv) {
    split(a, tv)
    if(tv[1] == "#") {
        a = tv[2]
        return _number(int(a))
    } else {
        logg_err("_int", "non-numeric-operand", d)
        return _nil()
    }
}

function _tolower(s,     tv) {
    if(_TYPE[s] == "s") {
        return _string(tolower(_STRING[s]))
    } else {
        logg_err("_tolower", "non-string operand " _repr(s))
        return _nil()
    }
}

function _toupper(a,     tv) {
    if(_TYPE[s] == "s") {
        return _string(toupper(_STRING[s]))
    } else {
        logg_err("_toupper", "non-string operand " _repr(s))
        return _nil()
    }
}

                else if(car == _symbol("cos"))
                    return _cos(_eval3(_cadr(form), env, env, d+1))
                else if(car == _symbol("sin"))
                    return _sin(_eval3(_cadr(form), env, env, d+1))
                else if(car == _symbol("exp"))
                    return _exp(_eval3(_cadr(form), env, env, d+1))
                else if(car == _symbol("log"))
                    return _log(_eval3(_cadr(form), env, env, d+1))
                else if(car == _symbol("sqrt"))
                    return _sqrt(_eval3(_cadr(form), env, env, d+1))
                else if(car == _symbol("rand"))
                    return _number(rand())
                else if(car == _symbol("srand"))
                    return _srand(_eval3(_cadr(form), env, env, d+1))
                else if(car == _symbol("int"))
                    return _int(_eval3(_cadr(form), env, env, d+1))
                else if(car == _symbol("system"))
                    return _system(_eval3(_cadr(form), env, env, d+1))
                else if(car == _symbol("tolower"))
                    return _tolower(_eval3(_cadr(form), env, env, d+1))
                else if(car == _symbol("toupper"))
                    return _toupper(_eval3(_cadr(form), env, env, d+1))