How do you evaluate a derivative in python?

Question

I'm a beginner in python. I've recently learned about Sympy and its symbolic manipulation capabilities, in particular, differentiation. I am trying to do the following in the easiest way possible:

1. Define f(x,y) = x^2 + xy^2.
2. Differentiate f with respect to x. So f'(x,y) = 2x + xy^2.
3. Evaluate the derivative, e.g., f'(1,1) = 2 + 1 = 3.

I know how to do 1 and 2. The problem is, when I try to evaluate the derivative in step 3, I get an error that python can't calculate the derivative. Here is a minimal working example:

import sympy as sym
import math


def f(x,y):
    return x**2 + x*y**2


x, y = sym.symbols('x y')

def fprime(x,y):
    return sym.diff(f(x,y),x)

print(fprime(x,y)) #This works.

print(fprime(1,1)) 

I expect the last line to print 3. It doesn't print anything, and says "can't calculate the 1st derivative wrt 1".

Answer 1

Your function fprime is not the derivative. It is a function that returns the derivative (as a Sympy expression). To evaluate it, you can use .subs to plug values into this expression:

>>> fprime(x, y).evalf(subs={x: 1, y: 1})
3.00000000000000

If you want fprime to actually be the derivative, you should assign the derivative expression directly to fprime, rather than wrapping it in a function. Then you can evalf it directly:

>>> fprime = sym.diff(f(x,y),x)
>>> fprime.evalf(subs={x: 1, y: 1})
3.00000000000000

Answer 2

The answer to this question is pretty simple. Sure, the subs option given in the other answer works for evaluating the derivative at a number, but it doesn't work if you want to plot the derivative. There is a way to fix this: lambdify, as explained below.

Use lambdify to convert all of the sympy functions (which can be differentiated but not evaluated) to their numpy counterparts (which can be evaluated, plotted, etc., but not differentiated). For example, sym.sin(x) will be replaced with np.sin(x). The idea is: define the function using sympy functions, differentiate as needed, and then define a new function which is the lambdified version of the original function.

As in the code below, sym.lambdify takes the following inputs:

sym.lambdify(variable, function(variable), "numpy")

The third input, "numpy", is what replaces sympy functions with their numpy counterparts. An example is:

def f(x):
    return sym.cos(x)

def fprime(x):
    return sym.diff(f(x),x)

fprimeLambdified = sym.lambdify(x,f(x),"numpy")

Then the function fprime(x) returns -sym.sin(x), and the function fprimeLambdified(x) returns -np.sin(x). We can "call"/evaluate fprimeLambdified at specific input values now, whereas we cannot "call"/evaluate fprime, since the former is composed of numpy expressions and the latter sympy expressions. In other words, it makes sense to input fprimelambdified(math.pi), and this will return an output, while fprime(math.pi) will return an error.

An example of using sym.lambdify in more than one variable is seen below.

import sympy as sym
import math


def f(x,y):
    return x**2 + x*y**2


x, y = sym.symbols('x y')

def fprime(x,y):
    return sym.diff(f(x,y),x)

print(fprime(x,y)) #This works.

DerivativeOfF = sym.lambdify((x,y),fprime(x,y),"numpy")

print(DerivativeOfF(1,1))

Answer 3

When you call fprime(1,1) in the function fprime(x,y) you call it like this sym.diff(f(1,1),1)

You have to use different variables for x and the value of x