How has the global mean temperature evolved in the past. This was a simple question I had that I couldn’t find a straight answer to. So, I set out to calculate it for myself; it would also serve as a nice simple exercise in statistics.
I’ve been kept busy by Schrödinger, Fourier and Dirac lately, but I had some free time finally and put together a more refined way to derive musical (or so) structures out of one dimensional cellular automata system. Partly inspired by the excelent lectures on early finnish experimental electronic music scene at the local media art museum (see http://mansedanse.com/events_fi.html).
The algorithm quantizes the chromatic scale down to any arbitrary scale and picks up two notes to be played. This produces a more music-like result than the total chaos of applying the whole automata state straight to the chromatic scale.. though I’m not saying that it can’t produce interesting results.
Here is the MATLAB code responsible for these, keep in mind though that the quantizer code was written in the middle of the night (I think you can tell) so there are probably some glitches to it.
Connection machines were a line of parallel supercomputers built by Thinking Machines Corporation. Notably Stephen Wolfram and Richard Feynman were involved in the early years of the corporation.
Here are some delightfully academic and stiff Thinking Machines Corp. promo videos from Youtube. The first one features some great footage from a lattice gas automata fluid dynamics model (I can’t believe it took a person year for the LGA model, I put one together in a week or so on MATLAB. My ego is pleased.)
Ironically Thinking Machines Corp. went bankcrupt in 1994, when parallel computing is a hot commodity today in 2009.
What would be better application for one dimensional cellular automata than autogenerative electronic music. I know Wolfram Tones offers something along these lines but I set out to experiment on my own first with just the bare rules applied to the chromatic scale. Couple of important rules rendered on the chromatic scale:
These does seem to hold a eerie quality to them, not that anyone would recognize them as music. Next I cherrypicked a good set of rules which seemed to work nice enough when applied in a random order. I think I used the c major scale for this one.
Since googling up NASA’s online VLF receiver mp3 stream (seems to be defunct now, fortunately there are other streams available.. see http://abelian.org/vlf/) I wanted to try to receive these signals myself. So I came up with some schematics on the internet for a basic vlf receiver and built and tested a couple of these.
The sferics are crisp, loud and clear, the circuits work very well if the conditions are right. Small enough to fit a pocket, it’s interesting to walk aroud the area I live and listen in to the various weird signals eminating from all sorts of electronics and machinery. I’ve yet to record auroral activity, but that is next on the agenda.
I want to write a little bit more about my studies on waves and automata models. I wrote a vastly improved TLM code on MATLAB which now includes for example first order absorbing boundaries. It is important to distinct this approach from a mathematical model, this is a analogous physical system to wave propagation. You could think of it as using computer memory element grid as an discrete analogy to the vacuum.
This sort of physical modelling and computation was first used by a Hungary born mathematician and electrical engineer Dr. Gabriel Kron in 1943 while working for General Electric (see paper called ‘Equivalent Circuits to Represent the Electromagnetic Field Equations’ on Physical Review Vol.64 Numbers 3-4 1943.) The approach involved analog computing in the form of a RLC network. The approach was then picked up by P.B. Johns and R.L. Beurle (see paper ‘Numerical solution of 2-dimensional scattering problems using a transmission-line matrix’ on Proc. IEE, Vol. 118, No. 9, 1971, pp. 1203-1208) applied to ‘computors’ as they were then called.
The Johns and Beurle numerical method involves applying a simple scattering automata rule to a discrete node grid. This doesn’t exactly involve integration in the sense that a discretisized mathematical model would; only arithmetic needed is addition (floating or fixed-point) for summing up the node incidence and reflection time-step impulses involved in the scattering rule (which are directly derivable from normalized unitary impedance electrical node network.)
The simple TLM here is configured for the classic Young double slit experiment. Although this particular setup could be thought to just propagate the electric field, the corresponding magnetic field can be derived aswell together with different permittivity and permeability coefficients to model material properties.
Studying wave equation discretization has personally led me to understand and appreciate the physics which rely heavily on this mathematics, namely electrodynamics and field theories. I think this sort of ‘visual intuition’ is a important part of learning when dealing with dynamics which can be extremely complicated and complex, at least it has been exactly that for me. Studying the computability of these equations has definetly paved some way in these theoretically dense subjects.
I recently made few basic computer models of the Schrödinger wave equation with MATLAB for computational physics course work.
Here is a two dimensional version of the discretisized time-dependent wave equation calculated using a clever leapfrog integration algorithm scheme by Visscher.
Things start to get visually more interesting when integrating the time-dependant equation in three dimensions.
Here is another run with a slightly different value for the momentum of the wavepacket.
Unfortunately MATLAB seriously lacks in the volumetric plotting department so we’ll have to do with phong shaded isosurfaces instead of a more appropriate voxel based plot. Don’t worry, this will not end up forming black holes and destroying Vulcan.
I recently got excited about cellular automata systems again, which is something that got me interested in computing in the first place. I suppose you could think of it as going back to the roots. Many nights and weekends I’d be obsessed about these seemingly simple but endlessly complex discrete systems as a kid and programming them in Basic. This also led me to study hardware level programming using machine language and assembler, since Basic was far too slow for most things.
Turns out this simple bit flipping is actually useful for something. Complexity is at the core of many important dynamic models, for example in hydrodynamics where in some cases traditional approaches are too prone for truncation and round-off noise errors to model turbulence accurately enough. Lattice gas and lattice Boltzmann models handle this sort of problem far better because of their discrete nature. Discreteness also means that the algorithms are perfect for massive parallel computing.
Here I’ve done a simple transmission line matrix model to simulate wave propagation. You could think of it as applying Huygens wavefront principle to a discrete node system, which turns out to work perfectly. The algorithm is very close to what you get if you discretisize a scalar wave equation.