A symbolic math library written in Julia modelled off scmutils
MIT License
This is a package I'm throwing together after getting inspired by the talk Physics in Clojure which was about porting scmutils to clojure. scmutils is a Scheme package with a very interesting and powerful computer algebra system meant as a companion to the book Structure and Interpretation of Classical Mechanics.
My intention with Symbolics.jl is to attempt to recreate the functionality of scmutils in julia using julian syntax. The package is slowly morphing into some sort of hybrid between scmutils and Mathematica.
This package works on Julia 1.0. To add it, simply
pkg> add https://github.com/MasonProtter/Symbolics.jl
Note: This package is very much a work in progress! Don't rely on it for anything important.
Examples of use:
julia > using Symbolics
julia> @sym x y z t;
julia> x^2 + x^2
2 * x ^ 2
julia> ex = 2x + x^2
2x + x^2
julia> ex(x => y)
2y + y^2
julia> f(x) = x^3;
julia> g(x) = x^2;
julia> f + g
(::#70) (generic function with 1 method)
julia> ans(x)
x ^ 3 + x ^ 2
julia> f * g
(::#72) (generic function with 1 method)
julia> ans(x)
x ^ 5
julia> D(f+g)(x)
3 * x ^ 2 + 2x
julia> (D^2)(f+g)(x)
3 * (2x) + 2
julia> (D^3)(f+g)(x)
6
The derivative operator, D
is of type Dtype <: Operator <: Function
. The reason for this is because operations on functions should sometimes behave differently than operations on differential operators. Currently the only difference is in exponentiation, such that :^(f::Function, n) = x -> f(x)^n
whereas :^(o::Operator,n::Integer) = x -> o(o( ... o(x)))
where the operator o
has been applied to x
n
times.
julia> D(x(t)^2 + 2x(t), t)
2 * (x)(t) * (D(x))(t) + 2 * (D(x))(t)
We can now define a Lagrangian, say that of a simple harmonic oscillator as
using Symbolics
@sym x m t
function L(local_tuple::UpTuple)
t, q, qdot = local_tuple.data
(0.5m)*qdot^2 - (0.5m*^2)*q^2
end
where the local_tuple is an object describing a time, posisition and velocity (ie. all the relevant phase space data). According to SICM, this data should be provided by a function (w)
where w
defines a trajectory through space. `` is defined as
(w) = t -> UpTuple([t, w(t), D(w)(t)])
Hence, as shown in SICM, the Euler-Lagrange condition for stationary action may be written as the functional
Lagrange_Equations(L) = w -> D((3)(L)(w)) - (2)(L)(w)
where (3)
means partial derivative with respect to velocity and (2)
means partial derivative with respect to position (ie. the third and second elements of the local tuple respectively). Putting this all together, we may execute
julia> Lagrange_Equations(L)(x)(t)
(D(D(x)))(t) * m + (x)(t) * m * ^ 2
which when set equal to zero is the equation of motion for a simple harmonic oscillator, generated in pure Julia code code symbolically!