It's defined as
In my code, it's
(defn entropy [X]
(* -1 (Σ [i X] (* (p i) (log (p i))))))
Compare the similarity of my code above with the actual definition. Having a language that lets you declare constructs that look very similar to their mathematical definition is a huge win for readability.
The two important features I used in this example are
1) Clojure allows identifiers to be unicode
2) Macros
My macro is defined as
(defmacro Σ
"computes the sum of a series."
[[var-name values] & body]
`(reduce +
(map (fn [~var-name]
~@body) ~values)))
Of course, I have a similar one:
(defmacro Π
"computes the product of a series."
You can imagine how it looks.
The other big win here is I've abstracted out *how* the sum and product of a series are implemented. This allows me to do performance optimizations behind the scenes. For example, I could replace that call to map with a call to pmap.
The point of this isn't to show off how Clojure is better than other languages; I'm trying to show that these features are powerful. If your language of choice doesn't have these features, maybe it should.
Of course, macros are just a means to an end. I find them great, but that doesn't mean they're the One True Way to accomplish our goal of readable code. I'd love to see examples of solving this problem in other ways, in any language.
