On Nov 20, 5:57 pm, Garth Sheldon-Coulson <g...@mit.edu> wrote:
> Dear Clojurians,
>
> I am very happy to announce Clojuratica version 2.
>
> Clojuratica now offers the **syntactic** integration of Clojure and
> Mathematica.
>
> What does this mean? It means you can write Clojure code that looks like
> this:
>
> => (FactorInteger 12345)
> [[3 1] [5 1] [823 1]]
>
> You guessed it. FactorInteger is a Mathematica function. And that's a
> Clojure REPL.
>
> Symbolic math in Clojure? Syntax-unquoting to feed in Clojure data
> structures? Absolutely.
>
> => (Sqrt (* 9 a))
> (* 3 (Power a 1/2))
>
> => (let [x [[2 1] [1 2]]]
> (CholeskyDecomposition ~x))
> [[(Power 2 1/2) (Power 2 -1/2)] [0 (Power 3/2 1/2)]]
>
> Note that the Clojure "matrix" (vector of vectors) is converted on the fly
> to a Mathematica matrix, and vice versa. Automatic conversions take place
> for all Clojure and Mathematica data structures.
>
> There's more. Mathematica functions are now Clojure functions. The following
> is a Mathematica function written in Clojure that finds the n shortest genes
> in the human genome. (Mathematica has some cool functions like GenomeData to
> try out.)
>
> => (Function [n]
> (Take
> (Sort
> (Map
> (Function [gene] [(GenomeData gene "SequenceLength") gene])
> (GenomeData)))
> n))
> #<parse$parse_fn__1230$fn__
> 1234 clojuratica.base.parse$parse_fn__1230$fn__1...@19fa0b5>
>
> What's that ugly return value? It's a first-class Clojure function. We
> evaluated a Mathematica function in Clojure and got back a Clojure function
> which, when we call it, hands off the computation to Mathematica and returns
> the result:
>
> => (*1 4)
> [[11 "IGHD727"] [16 "IGHD411"] [16 "IGHD417"] [16 "IGHD44"]]
>
> All the power of Mathematica is now seamlessly available in Clojure. If you
> like, you can think of Mathematica as a particularly mature Clojure library
> for linear algebra, matrix decomposition, symbolic mathematics,
> optimization, differential equations, symbolic and numerical integration,
> Fourier analysis, 2D and 3D visualization, image and photo manipulation,
> exploratory data analysis, probability and statistics, graph theory, number
> theory, geodesy, and access to the Wolfram Research internet data feeds on
> finance, chemistry, geometry, meteorology, astronomy, protein structure,
> and, as we've seen, the human genome.
>
> Let's take a step back and see how it all works.
>
> Observe: Clojure and Mathematica are remarkably similar languages despite
> their different areas of strength.
>
> Constant-lookup arrays:
>
> Clj vectors: [1 2 3]
> Mma lists: {1, 2, 3}
>
> Matrices as nested arrays:
>
> Clj: [[1 0] [0 1]]
> Mma: {{1, 0}, {0, 1}}
>
> Function calls *always* use prefix notation:
>
> Clj: (func arg1 arg2 arg3)
> Mma: Func[arg1, arg2, arg3]
>
> In Mathematica, common functions do have syntactic sugar, but it always is
> just syntactic sugar:
>
> Clj: none
> Mma: 1 + 1 is just Plus[1, 1]
> !foo && (bar > baz) is just And[Not[foo], Greater[bar, baz]]
>
> Homoiconicity:
>
> Clj: (nth '(func arg1 arg2) 1) ==> arg1
> Mma: Part[Func[arg1, arg2], 1] ==> arg1
>
> The similarities suggest the core idea: Mathematica expressions can be
> written as Clojure expressions without any loss of information, and vice
> versa. There is perfect correspondence. Happily, Mathematica functions are
> PascalCase by convention. This allows the interning of Mathematica functions
> right into your Clojure namespace without conflict.
>
> Mma: FactorInteger[1091]
> Clj: (FactorInteger 1091)
>
> Mma: Function[{x}, x + 1]
> Clj: (Function [x] (Plus x 1))
>
> The heart of Clojuratica is simple. Convert Clojure expressions to
> Mathematica expressions, evaluate them in Mathematica, and parse the result
> back into Clojure expressions.
>
> As you will see in the tutorial on the Clojuratica web page
> <http://clojuratica.weebly.com>, you are not forced to intern Mathematica
> functions directly into your namespace. You may, but you do not have to. The
> generic way to call Mathematica code is using the math macro (which you
> yourself define, so it need not be called "math"):
>
> => (let [x "World"]
> (math (StringJoin "Hello, " ~x "! This is some Mathematica code's
> output.")))
> "Hello, World! This is some Mathematica code's output."
>
> => (def hello
> (math
> (Function [x]
> (StringJoin "Hello, " x "! This is a Mathematica function's
> output."))))
> #'user/hello
>
> => (hello "World")
> "Hello, World! This is a Mathematica function's output."
>
> There are other features, too:
>
> * A concurrency framework for multithreaded, parallel computation.
> Mathematica is not designed for threads or concurrency. It has excellent
> support for parallel computation, but parallel evaultions are initiated from
> a single-threaded master kernel which blocks until all parallel evaluations
> return. By contrast, Clojuratica includes a concurrency framework that lets
> multiple Clojure threads execute Mathematica expressions without blocking
> others. The computations will be farmed out to as many Mathematica kernels
> as are parallelized on the local machine or across a cluster or grid. The
> computations will return asynchronously, and some threads will go about
> their business while others continue to wait. I have worked to make the
> system as high-performance as possible.
>
> * Hashmap conversion. Mathematica has no map data structure, so I
> include a basic one with Clojuratica, along with a few other helpful
> Mathematica funcions and features (e.g. Let, with is akin to With but allows
> later bindings to see earlier bindings, just like Clojure's let).
>
> Version 2 of Clojuratica is a complete rewrite of version 1. It should be
> considered alpha software for the time being. I would appreciate suggestions
> and bug reports.
>
> I plan to make the integration work in the opposite direction when I have
> time. It might be a while! The Clojure-in-Mathematica integration that was
> available in version 1 has been removed for now.
>
> I encourage you to read the tutorial on the web page
> <http://clojuratica.weebly.com>. You can download the software there as well.
>
> I hope you enjoy it!
Very cool!
Rich
--
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To post to this group, send email to clojure@googlegroups.com
Note that posts from new members are moderated - please be patient with your
first post.
To unsubscribe from this group, send email to
clojure+unsubscr...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/clojure?hl=en
