用python导出复杂函数

Question

I have a pretty complicated diespersion relation which I want to derive. Here is the code for the dispersion relation:

import numpy as np
import pylab as pl

#function definitions. compare following paper eqs. (60) and (61)
#"Hamiltionian formalism for two magnon scattering microwave relaxation:
#Theory and applications"
#Krivosik, Kalarickal, Patton
#JAP 101, 083901 (2007)

def omega(gamma,Bx,By): #resonance frequency
    return gamma*sqrt(Bx*By)

def Bx(B,A,k,mu_0,Ms,Nk): #magnetic field in x-direction
    return B+(2*A/Ms)*k**2+mu_0*Ms*Nk

def By(B,A,k,mu_0,Ms,phi,Nk): #magnetic field in y-direction
    return B+(2*A/Ms)*k**2+mu_0*Ms*(sin(phi)**2)*(1-Nk)

def k(kx,n,w): #k-vektor of spin wave
    return sqrt(kx**2+(n*pi/w)**2)

def Nk(k,d): #Dipole field function
    return (1-exp(-k*d))/(k*d)

def phi(kx,n,w): #angle between k vector and magnetization which points along x-axis
    return arctan(n*pi/(w*kx))

#constants and parameters
gamma=28 #GHz/T
mu_0=4*pi*1e-7 #As/Vm

#range of k-vectors
kx=linspace(0,25000000,1000)

#sample parameters
A=3.5e-12 #J/m
Ms=140000 #A/m
B=0.05 #mT
w=2e-6 #m
d=100e-9 #m

fig=pl.figure(num=None, figsize=(10, 6.25), dpi=80, facecolor='w', edgecolor='k')
font = {'weight' : 'normal', 'size'   : 13}
matplotlib.rc('font', **font)

n=1
plot(kx/1e6, omega(gamma,Bx(B,A,k(kx,n,w),mu_0,Ms,Nk(k(kx,n,w),d)),By(B,A,k(kx,n,w),mu_0,Ms,phi(kx,n,w),Nk(k(kx,n,w),d))), 'k-')

Now I want to derive the function since the slope of the function is of crucial importance for me...

1. Is there an easier way to define the function?

2. For the derivative I need to calculate d_omega/d_kx. I do not need the analytical expression! Which way would you recommend?

3. Should I just take the values of omega and compute manually

   (omega(n+1)-omega(n))/(kx(n+1)-kx(n))

   or is there a more elegant way?

Answer 1

You can use the function gradient, which is implemented in numpy.

The gradient is computed using central differences in the interior and first differences at the boundaries. The returned gradient hence hasthe same shape as the input array.

This is how you can use it to plot the derivative, just copying your example.

plot(kx/1e6, gradient(omega(gamma,Bx(B,A,k(kx,n,w),mu_0,Ms,Nk(k(kx,n,w),d)),By(B,A,k(kx,n,w),mu_0,Ms,phi(kx,n,w),Nk(k(kx,n,w),d)))), 'k-')

Hope it helps.

Answer 2

There are a number of ways:

1. Numerical approximation (as listed above by others).
   • numdifftools , (just updated to version 0.5) this uses a finite difference approach but keeps track of the numerical error estimate thus giving reliable results ie it automatically takes care of mesh size.
2. Automatic differentiation .
   • numdifftools , (just updated to version 0.5)
   • pyautodiff , very elegant code thanks to Theano and decorators
   • adol-c has a python wrapper
3. Symbolic derivative.
   • sympy , the classic python symbolic derivative module
   • Sage , an iPython-like environment intended as a alternative to Mathematica, built on python.

Both 2 and 3 will be more accurate than numerical derivatives because to preserve accuracy you need to sample the equation over a very fine mesh.

Answer 3

You can rely on this scipy utility function, that allows to play both with the size of the discretization dx and with order of the finite difference scheme, set by default to 3 . This is an example:

from scipy.misc import derivative
f=lambda kx : omega(gamma,Bx(B,A,k(kx,n,w),mu_0,Ms,Nk(k(kx,n,w),d)),By(B,A,k(kx,n,w),mu_0,Ms,phi(kx,n,w),Nk(k(kx,n,w),d)))
df = derivative(f,kx,dx=kx[1]-kx[0])
fig,ax=plt.subplots()
ax.plot(kx/1e6,f(kx),'b')
bx=ax.twinx()
bx.plot(kx/1e6,df,'r')
bx.grid()

Answer 4

I found a solution for my problem

#Definitions from above
dispersion =lambda n : omega(gamma,Bx(B,A,k(kx,n,w),mu_0,Ms,Nk(k(kx,n,w),d)),By(B,A,k(kx,n,w),mu_0,Ms,phi(kx,n,w),Nk(k(kx,n,w),d)))
derivative=diff(dispersion(n))/diff(kx)