Most code examples for Julia are aimed at users of existing statistical and 
numerical software without demonstrating how functional programming can be 
substantially more useful for their field. In many ways, Julia is a Lisp 
without S-Expressions, so I didn't think it would be unwise to port code 
examples from Structure and Interpretation of Classical 
Mechanics<http://en.wikipedia.org/wiki/Structure_and_Interpretation_of_Classical_Mechanics>from
 Scheme to Julia. This book shows how functional programming can be 
directly applied to the formalism of Lagrangian and Hamiltonian Mechanics, 
but Scheme & 
SCMUtils<http://groups.csail.mit.edu/mac/users/gjs/6946/refman.txt>may be too 
obscure and syntactically different from what people are used to 
for most people in the physical sciences.

Book review: http://www.ids.ias.edu/~piet/publ/other/sicm.html

I was impatient, and decided to just start porting code, so the first 
example was easy enough:

(define ((L-free-particle mass) local)
  (let ((v (velocity local)))
  (* 1/2 mass (dot-product v v))))

would become something like lFreeParticle(mass) = tuple -> begin v = 
velocity(tuple); mass * dot(v,v) / 2 end. So far so good.

But it's not long that I encounter usage of SCMUTILS

(define q
  (up (literal-function ’x)
      (literal-function ’y)
      (literal-function ’z)))

So I turn to the Appendix which talks about Symbolic values in Scheme, and 
confirming it in the SCMUTILS documentation, it appears that symbols have 
the same type as real numbers, which seems very different than symbolic 
expressions as described in the Julia documentation. Here, up constructs a 
tuple, and literal-function is a constructor for symbolic manipulation. At 
this point, I'm not sure how to proceed, but am still looking into the 
matter. I see that the only packages that mention symbolic manipulation are 
a SymPy interface and a Calculus package.

Reply via email to