
Chaos Theory vs Clojure - fogus
http://bestinclass.wordpress.com/2009/09/24/chaos-theory-vs-clojure/
======
icey
Awesome quote:

"If you’re on Windows it’s basically the same approach, _you just have to
start by installing Linux_ , but afterwards you’ll also get this result in all
its animated splendor:"

(Emphasis mine)

~~~
rortian
It would be funnier if it were true. Instead this would run in the command
line.

------
jazzdev

       (-> #(animate panel) Thread. .start))
    

>I doubt you’ll ever see such impressive Java Interop mixed with Closures in
other languages!

Rhino is pretty impressive too:

    
    
      new Thread(function () { print("\nrun"); }).start()

~~~
gps408
Your Rhino example isn't creating a closure, is it?

------
radu_floricica
Most interesting thing was two links away and unrelated:

<http://www.assembla.com/wiki/show/clojure/New_new>

------
joe_the_user
I'm not sure if this demonstrates great ability for Clojure.

One of the first programs I ever wrote, when I was still in High School, was a
simple simulation of planetary motion using BASIC. For this, I used a naive
approximation of Newton's laws. I was disappointed to discover that because of
approximation error, my planets all fell into the sun! But the program did put
the death-spirals on the screen in black and whie!

My impression is that while mathematical formulas generally aren't that hard
to interpolate into any programming language, the art of such interpolation is
making sure that arithmetic error and such don't pile up to spoil things.

Given this, Chaos Theory graphics would be great fodder for _seeming_ like
you've done something amazing since you don't have to simulate anything
correctly, you only have to create a swirl which looks intriguing. Oddly
enough, planets orbiting a sun are better since you've got to create a useful
simulation with the properties of the original system.

~~~
ZitchDog
I've always wanted to write a planetary simulator. I think clojure might be a
decent language for it, as long as you avoid floating point as much as
possible and use clojure's Ratios class instead.

    
    
      user=> (type (/ 1 3))
      clojure.lang.Ratio
      
      user=> (* (/ 1 3) 3)       
      1
    

I'd really like to see an arithmetic macro for clojure to allow infix
notation, constants, and lazy evaluation. Something like (arith 2m/s^2) would
be crazy awesome.

~~~
jackdawjack
check out "the structure and interpretation of classical mechanics" by
sussmann et al for a whole raft of things like this done in scheme.

I don't see why would you want to stay away from floats, using rationals isn't
going to magically fix the numerical errors from approximating derivatives and
such.

I believe they develop an automatic differentiation routine in SICM that will
actually allow you to make a pretty good planetary motion simulator, i.e one
that won't just go horribly wrong if you run it for a few thousand years.

Of course if you're really interested/mathematically inclined one of the best
ways to simulate Hamiltonian systems is via iterated maps, not unlike what was
in the article. A good (but quite hard) ref to this is "simulating hamiltonian
dynamics" by Leimkuhler and Reich.

