This project contains a Mandelbrot Set implementation in Clojure that

demonstrates the usage and impact of primitive type declarations on the

runtime of numerically-intensive algorithms.

A canonical rendering of the Mandelbrot Set can be obtained by running

the `-main` entry point in the

namespace using Leiningen:

After running this, you'll see this in `mandelbrot.png`:

The run arguments correspond exactly to those required by

`com.clojurebook.mandelbrot/mandelbrot`.

You can change the view you get by modifying the coordinates provided to

that function:

Of course, if you're going to do a bunch of exploration of the

Mandelbrot Set using this implementation, you'll be _way_ better off

working from the REPL rather than paying the JVM and Leiningen startup

cost repeatedly. Refer to the book or the sources here for

REPL-oriented examples.

A nearly order-of-magnitude improvement in the running time of

`com.clojurebook.mandelbrot/mandelbrot` can be had by replacing its

helper `escape` function with this implementation:

(defn- fast-escape

[^double a0 ^double b0 depth]

(loop [a a0

b b0

iteration 0]

(cond

(< 4 (+ (* a a) (* b b))) iteration

(>= iteration depth) -1

:else (recur (+ a0 (- (* a a) (* b b)))

(+ b0 (* 2 (* a b)))

(inc iteration)))))

Aside from the `^double` type declarations for the `a0` and `b0`

arguments, this implemenation is otherwise unchanged compared to the

default (boxing) `escape` function.

An alternative `lein run` alias — called `:fast` — is set up to use `fast-escape`:

The above will run far faster than the first `lein run` invocation

above.

(defproject com.clojurebook.mandelbrot "1.0.0-SNAPSHOT"

:description "A Mandelbrot Set implementation in Clojure that

:url "http://github.com/clojurebook/ClojureProgramming"

:dependencies [[org.clojure/clojure "1.3.0"]]

:main ^:skip-aot com.clojurebook.mandelbrot

:run-aliases {:fast com.clojurebook.mandelbrot/-fast-main})

(ns com.clojurebook.mandelbrot

(defn- fast-escape

"A primitive-hinted variant of `escape` that can result in an

[^double a0 ^double b0 depth]

(loop [a a0

b b0

iteration 0]

(cond

(< 4 (+ (* a a) (* b b))) iteration

(>= iteration depth) -1

:else (recur (+ a0 (- (* a a) (* b b)))

(+ b0 (* 2 (* a b)))

(inc iteration)))))

(defn mandelbrot

"Prints a basic textual rendering of mandelbrot set membership,

[mandelbrot-grid]

(doseq [row mandelbrot-grid]

"Given a mandelbrot set membership grid as returned by a call to

[mandelbrot-grid]

height (count mandelbrot-grid)

width (count (first mandelbrot-grid))

(doseq [[y row] (map-indexed vector mandelbrot-grid)

(defn- coerce-mandelbrot-args

[args]

(for [x args]

(if (= \: (first x))

(keyword (subs x 1))

(try

(if (.contains x ".")

(Double/parseDouble x)

(Long/parseLong x))

(catch NumberFormatException e

(println "Invalid number" x))))))

(defn- print-usage []

(println "Mandelbrot set visualization from 'Clojure Programming', chapter 11.")

(println "Please refer to documentation for com.clojurebook.mandelbrot/mandelbrot for information on what rmin, rmax, etc. mean.")

(println)

(println "Usage: lein run [:fast] output-path rmin rmax imin imax [:width XXX] [:height YYY] [:depth DDD]")

(println " e.g.: lein run mandelbrot.png -2.25 0.75 -1.5 1.5 :width 800 :height 800 :depth 500")

(println)

(println "Using the :fast option will result in the primitive-optimized `fast-escape` function being used instead of the default (boxing) `escape`."))

(defn -main

[& [output-path & opts]]

(let [args (coerce-mandelbrot-args opts)]

(when (or (not output-path)

(seq (filter nil? args))

(not (even? (count args))))

(print-usage)

(System/exit 1))

(javax.imageio.ImageIO/write

(render-image (apply mandelbrot args))

"png" (java.io.File. output-path))

(System/exit 0)))

(defn -fast-main

"Same as -main, but uses `with-redefs` to replace `escape` with its

[& args]

(with-redefs [escape fast-escape]

(apply -main args)))