Calculate a Derivative

From CodeCodex

Image:Lightbulb.png Related content:
<DPL>

category=Math shownamespace=false </DPL>

Compute and print a derivative of the symbolic expression a x^2 + b x + c in Mathematica syntax, preferably with simplification.

Contents

[edit] C++


#include <iostream>

using namespace std;

class Var;

class Base {
        public:
        virtual ~Base() {};
        virtual const Base *clone() = 0;
        virtual const Base *d(const string &v) const = 0;
        virtual ostream &print(ostream &o) const = 0;
};

ostream &operator<<(ostream &o, const Base &e) { e.print(o); return o; }

class Int : public Base {
        const int n;
        public:
        Int(int m) : n(m) {}
        ~Int() {}
        const Base *clone() { return new Int(n); }
        const Base *d(const string &v) const { return new Int(0); }
        ostream &print(ostream &o) const { return o << n; }
};

class Var : public Base {
        const string var;
        public:
        Var(string v) : var(v) {}
        ~Var() {}
        const Base *clone() { return new Var(var); }
        const Base *d(const string &v) const { return new Int(var == v ? 1 : 0); }
        ostream &print(ostream &o) const { return o << var; }
};

class Plus : public Base {
        const Base *e1, *e2;
        public:
        Plus(const Base *a, const Base *b) : e1(a), e2(b) {}
        ~Plus() { delete e1; delete e2; }
        const Base *clone() { return new Plus(e1, e2); }
        const Base *d(const string &v) const { return new Plus(e1->d(v), e2->d(v)); }
        ostream &print(ostream &o) const
        { return o << "(" << *e1 << " + " << *e2 << ")"; }
};

class Times : public Base {
        const Base *e1, *e2;
        public:
        Times(const Base *a, const Base *b) : e1(a), e2(b) {}
        ~Times() { delete e1; delete e2; }
        const Base *clone() { return new Times(e1, e2); }
        const Base *d(const string &v) const
        { return new Plus(new Times(e1, e2->d(v)), new Times(e1->d(v), e2)); }
        ostream &print(ostream &o) const { return o << "(" << *e1 << " * " << *e2 << ")"; }
};

class Expr {
        public:
        Base *e;
        Expr(Base *a) : e(a) {}
};

const Expr operator+(const Expr e1, const Expr e2)
{ return Expr(new Plus(e1.e->clone(), e2.e->clone())); }
const Expr operator*(const Expr e1, const Expr e2)
{ return Expr(new Times(e1.e->clone(), e2.e->clone())); }

ostream &operator<<(ostream &o, const Expr e) { return o << e.e; }

int main() {
        Var vx("x"), va("a"), vb("b"), vc("c");
        Expr x(&vx), a(&va), b(&vb), c(&vc);
        Expr e = a*x*x + b*x + c;
        cout << "d(" << *(e.e) << ", x) = " << *(e.e->d("x")) << endl;
        return 0;
}

[edit] Common Lisp

Lisp benefits from the use of the built-in s-expression type: 

(defun d (e x)
  (cond
   ((atom e) (if (eq e x) 1 0))
   ((eq (car e) '+) `(+ ,(d (cadr e) x) ,(d (caddr e) x)))
   ((eq (car e) '*) `(+ (* ,(cadr e) ,(d (caddr e) x))
                        (* ,(caddr e) ,(d (cadr e) x))))))

(defvar *e* '(+ (+ (* a (* x x)) (* b x)) c))

(d *e* 'x)

The result is printed as: 

(+ (+ (+ (* A (+ (* X 1) (* X 1))) (* (* X X) 0)) (+ (* B 1) (* X 0))) 0)

[edit] F#

In F#, the + and * operators can be overloaded to work with the user-defined expr type: 

type expr =
  | Int of int
  | Add of expr * expr
  | Mul of expr * expr
  | Var of string with
    static member ( + ) (f, g) = Add(f, g)
    static member ( * ) (f, g) = Mul(f, g)
  end

let rec d e x = match e with
  | Int n -> Int 0
  | Add(f, g) -> d f x + d g x
  | Mul(f, g) -> f * d g x + g * d f x
  | Var v -> Int (if v=x then 1 else 0)

let rec string_of = function
  | Int n -> string_of_int n
  | Var v -> v
  | Add(f, g) -> "("^string_of f^" + "^string_of g^")"
  | Mul(f, g) -> "("^string_of f^" * "^string_of g^")"

let x = Var "x" and a = Var "a" and b = Var "b" and c = Var "c"

let e = a * x * x + b * x + c

let () = Printf.printf "d %s x = %s\n" (string_of e) (string_of (d e "x"))

[edit] Java


abstract class Expr {
        public abstract Expr d(String v);
        public Expr plus(Expr e2) { return new Plus(this, e2); }
        public Expr times(Expr e2) { return new Times(this, e2); }
}

class Int extends Expr {
        private final int n;
        public Int(int m) { n = m; }
        public Expr d(String v) { return new Int(0); }
        public String toString() { return Integer.toString(n); }
}

class Var extends Expr {
        private final String var;
        public Var(String v) { var = v; }
        public Expr d(String v) { return new Int(var.equals(v) ? 1 : 0); }
        public String toString() { return var; }
}

class Plus extends Expr {
        private final Expr e1, e2;
        public Plus(Expr a, Expr b) { e1 = a; e2 = b; }
        public Expr d(String v) { return new Plus(e1.d(v), e2.d(v)); }
        public String toString() { return "(" + e1 + " + " + e2 + ")"; }
}

class Times extends Expr {
        private final Expr e1, e2;
        public Times(Expr a, Expr b) { e1 = a; e2 = b; }
        public Expr d(String v)
        { return new Plus(new Times(e1, e2.d(v)), new Times(e1.d(v), e2)); }
        public String toString() { return "(" + e1 + " * " + e2 + ")"; }
}

public class Derivative {
        public static void main(String[] args) {
                Expr x = new Var("x"), a = new Var("a"),
                b = new Var("b"), c = new Var("c");
                Expr e = a.times(x).times(x).plus(b.times(x)).plus(c);
                System.out.println("d(" + e + ", x) = " + e.d("x"));
        }
}

[edit] OCaml

Note that this implementation performs simple simplifications as expressions are constructed and pretty prints expressions with minimal bracketing (only sums inside products are bracketed). 


type expr =
| Int of int
| Var of string
| Add of expr * expr
| Mul of expr * expr

let ( +: ) f g = match f, g with
| Int n, Int m -> Int (n + m)
| Int 0, f
| f, Int 0 -> f
| f, g -> Add(f, g)

let ( *: ) f g = match f, g with
| Int n, Int m -> Int (n * m)
| Int 0, _
| _, Int 0 -> Int 0
| Int 1, f
| f, Int 1 -> f
| f, g -> Mul (f, g)

let rec d e x = match e with
| Int _ -> Int 0
| Add (f, g) -> d f x +: d g x
| Mul (f, g) -> f *: d g x +: g *: d f x
| Var v -> Int (if v=x then 1 else 0)

open Printf

let rec print ff = function
| Int n -> fprintf ff "%d" n
| Var v -> fprintf ff "%s" v
| Add (f, g) -> fprintf ff "%a + %a" print f print g
| Mul (f, g) ->
let product ff = function
| Add _ as expr -> fprintf ff "(%a)" print expr
| expr -> print ff expr
in
fprintf ff "%a %a" product f product g

let x = Var "x"
and a = Var "a"
and b = Var "b"
and c = Var "c"

let e = a *: x *: x +: b *: x +: c

let () = Printf.printf "d (%a) x = %a\n" print e print (d e "x")

The result is printed as: 

d (a x x + b x + c) x = a x + x a + b

[edit] Perl


use Math::Symbolic qw();
my $tree = Math::Symbolic->parse_from_string('a x^2 + b x + c');
$tree->new(
'partial_derivative', $tree, 'x'
)->apply_derivatives->simplify; # returns string


[edit] Python


class Expr:
  def __add__(self, other):
    return Plus(self, other)
  def __mul__(self, other):
    return Times(self, other)

class Int(Expr):
  def __init__(self, n):
    self.n = n
  def d(self, v):
    return Int(0)
  def __str__(self):
    return `self.n`

class Var(Expr):
  def __init__(self, var):
    self.var = var
  def d(self, v):
    return Int(self.var == v and 1 or 0)
  def __str__(self):
    return self.var

class Plus(Expr):
  def __init__(self, a, b):
    self.e1 = a
    self.e2 = b
  def d(self, v):
    return Plus(self.e1.d(v), self.e2.d(v))
  def __str__(self):
    return "(%s + %s)" % (self.e1, self.e2)

class Times(Expr):
  def __init__(self, a, b):
    self.e1 = a
    self.e2 = b
  def d(self, v):
    return Plus(Times(self.e1, self.e2.d(v)), Times(self.e1.d(v), self.e2))
  def __str__(self):
    return "(%s * %s)" % (self.e1, self.e2)

if __name__ == "__main__":
  x = Var("x")
  a = Var("a")
  b = Var("b")
  c = Var("c")
  e = a * x * x + b * x + c
  print "d(%s, x) = %s" % (e, e.d("x"))
Retrieved from "http://www.codecodex.com/wiki/Calculate_a_Derivative"