One of the early projects I’m considering undertaking in the new transparent workshops we’re starting (Coscience.org and Vague Innovation, LLC) is a genetic programming-based financial portfolio management system.

Ten years ago, we developed a powerful suite of design patterns for agent-based real-time datamining and adaptive control. We’ve left finance behind in the meantime, but now and then I find myself laying awake at night thinking about that neat old system.

You think about something enough, and stuff comes to you. A few days ago a little 21st-century LED lightbulb went off in my head. Maybe because I’m proofreading manuscripts from a conference I attended a few months ago, where old colleagues reported preliminary results more or less like what we were expecting to see ten years back. Maybe it just takes ten years to put two and two together.

At any rate, what the lightbulb revealed was pretty straightforward: If you have enough pixel bit depth, you could potentially treat a 2000-entry financial time-series—say for example stock price ticks—as a 1×2000 pixel image. As it happens, graphics processing primitives (and low-level filter routines) are surprisingly similar to the tools used in financial time-series analysis: averaging, phase-shifting, smoothing, kernel methods…. Everybody does it.

The initial picture I saw was pretty simple: Take every minute closing price of every stock in the S&P 500, and plot all that data as a big pixelmap: horizontal position is stock (say), vertical position indicates time, and color depth is price. Something like that.

Now I woke up a few minutes ago thinking about that again after a couple of days, and after a poke or two of the ol’ Google, I find this long-suppressed memory cropping up:

Core Image Accuracy

Because Core Image uses 32-bit floating point numbers instead of fixed scalars, it can handle over 10²⁵ colors. Each pixel is specified by a set of four floating point numbers, one each for the red, green, blue, and alpha components of a pixel. This color space is far greater than the human eye can perceive. This level of precision in specifying color components allows image fidelity to be preserved even through a large number of processing steps without truncation.

More than that, Core Image offers recipe-driven “lazy evaluation”, a language for writing advanced filters and algorithmic transformations, and parallelization methods built in.

So. That’s enough to make me think.

How about you?