20thSept_SymbolicProcessing3

function is_variable(x) {
    return is_string(x);
}

function is_same_variable(v1, v2) {
    return is_variable(v1) && is_variable(v2) && v1 === v2;
}

function is_sum(x) {
    return is_pair(x) && head(x) === "+";
}

function is_product(x) {
    return is_pair(x) && head(x) === "*";
}

function addend(s) {
    return head(tail(s));
}

function augend(s) {
    return head(tail(tail(s)));
}

function multiplier(s) {
    return head(tail(s));
}

function multiplicand(s) {
    return head(tail(tail(s)));
}

function number_equal(exp, num) {
    return is_number(exp) && exp === num;
}

// make_sum and make_product by expression simplification

function make_sum(a1, a2) {
    return number_equal(a1, 0)
           ? a2
           : number_equal(a2, 0)
           ? a1
           : is_number(a1) && is_number(a2)
           ? a1 + a2
           : list("+", a1, a2);
}

function make_product(m1, m2) {
    return number_equal(m1, 0) || number_equal(m2, 0)
           ? 0
           : number_equal(m1, 1)
           ? m2
           : number_equal(m2, 1)
           ? m1
           : is_number(m1) && is_number(m2)
           ? m1 * m2
           : list("*", m1, m2);
}

function deriv_symbolic(exp, variable) {
    return is_number(exp)
           ? 0
           : is_variable(exp)
           ? (is_same_variable(exp, variable)) ? 1 : 0
           : is_sum(exp)
           ? make_sum(deriv_symbolic(addend(exp), variable),
                      deriv_symbolic(augend(exp), variable))
           : is_product(exp)
           ? make_sum(make_product(multiplier(exp),
                                   deriv_symbolic(multiplicand(exp),
                                                  variable)),
                      make_product(deriv_symbolic(multiplier(exp),
                                                  variable),
                                   multiplicand(exp)))
           : error(exp, "unknown expression type");
}

// my_exp represents x * x + x + 4
const my_exp = make_sum(make_product("x", "x"),
                make_sum("x", 4));

display_list(deriv_symbolic(my_exp, "x"));
// should return make_sum(make_product("x", 2), 1)
// now returns an expression
// equivalent to 2 * x + 1