Skip to content


Subversion checkout URL

You can clone with
Download ZIP
[This repo is deprecated] Playing around with ODE code gen for PyDy
Python C Objective-C
Branch: master
Fetching latest commit...
Cannot retrieve the latest commit at this time.
Failed to load latest commit information.
bin Fixed benchmark script loc and MANIFEST.
pydy_code_gen Fixed theano import error.
.gitignore Added a python gitignore.
.travis.yml Moved to sympy and theano releases on travis. Added explicit tests for generated Cython files.
README.rst Added deprecation notice in the README.
UNLICENSE Set SymPy version req to (required only for Theano).


PyDy Code Generation


pydy-code-gen has been merged into the main pydy repository. This independent project is now deprecated, all development and subsequent releases will be from

This distribution provides code generation facilities for PyDy. For now, it generates functions that can evaluate the right hand side of the ordinary differential equations generated with sympy.physics.mechanics with three different backends: SymPy's lambdify, Theano, and Cython.

Master Branch Build Status



  • Python: 2.7 (Python 3+ may work)
  • setuptools
  • NumPy: >=1.6.1
  • SymPy: >=0.7.3


  • Cython: >=0.15.1
  • Theano: >=0.6.0
  • SciPy: >=0.9 (only for full examples)
  • matplotlib: >=0.99 (only for full examples)

There are a variety of methods to install these packages. Refer to the SciPy Stack installation instructions for details.


Once the dependencies are installed, the package can be installed from PyPi using:

$ easy_install pydy-code-gen


$ pip install pydy-code-gen

You can also grab the source and then install[1].

Using the zip download:

$ wget
$ unzip
$ cd pydy-code-gen-master
$ python install

Using Git:

$ git clone
$ cd pydy-code-gen
$ python install
[1]Note that this is the latest development version. Specific releases can be found here: or by checking out a tag with Git.


This is an example of a simple 1 degree of freedom system: a mass, spring, damper system under the influence of gravity and a force:

/ / / / / / / / /
  |    |     |   | g
  \   | |    |   V
k /   --- c  |
  |    |     | x, v
 --------    V
 |  m   | -----
    | F

Derive the system:

from sympy import symbols
import sympy.physics.mechanics as me

mass, stiffness, damping, gravity = symbols('m, k, c, g')

position, speed = me.dynamicsymbols('x v')
positiond = me.dynamicsymbols('x', 1)
force = me.dynamicsymbols('F')

ceiling = me.ReferenceFrame('N')

origin = me.Point('origin')
origin.set_vel(ceiling, 0)

center = origin.locatenew('center', position * ceiling.x)
center.set_vel(ceiling, speed * ceiling.x)

block = me.Particle('block', center, mass)

kinematic_equations = [speed - positiond]

force_magnitude = mass * gravity - stiffness * position - damping * speed + force
forces = [(center, force_magnitude * ceiling.x)]

particles = [block]

kane = me.KanesMethod(ceiling, q_ind=[position], u_ind=[speed],
kane.kanes_equations(forces, particles)

Store the expressions and symbols in sequences for the code generation:

mass_matrix = kane.mass_matrix_full
forcing_vector = kane.forcing_full
constants = (mass, stiffness, damping, gravity)
coordinates = (position,)
speeds = (speed,)
specified = (force,)

Now generate the function needed for numerical evaluation of the ODEs. The generator can use various back ends: lambdify, theano, or cython:

from pydy_code_gen.code import generate_ode_function

evaluate_ode = generate_ode_function(mass_matrix, forcing_vector, constants,
                                     coordinates, speeds, specified,

Integrate the equations of motion under the influence of a specified sinusoidal force:

from numpy import array, linspace, sin
from scipy.integrate import odeint

x0 = array([0.1, -1.0])
args = {'constants': array([1.0, 1.0, 0.2, 9.8]),
        'specified': lambda x, t: sin(t)}
t = linspace(0.0, 10.0, 1000)

y = odeint(evaluate_ode, x0, t, args=(args,))

Plot the results:

import matplotlib.pyplot as plt

plt.plot(t, y)
plt.legend((str(position), str(speed)))

Development Environment

Development Dependencies

  • nose: 1.3.0


The following installation assumes you have virtualenvwrapper and all the dependencies needed to build the packages:

$ mkvirtualenv pydy-dev
(pydy-dev)$ pip install numpy scipy cython nose theano sympy
(pydy-dev)$ pip install matplotlib # make sure to do this after numpy
(pydy-dev)$ git clone
(pydy-dev)$ cd pydy-code-gen
(pydy-dev)$ python develop

Run the tests:

(pydy-dev)$ nosetests

Run the benchmark to test the n-link pendulum problem.:

(pydy-dev)$ python bin/ <max # of links> <# of time steps>

Release Notes


  • Initial version.
Something went wrong with that request. Please try again.