Eric gave a talk today about the Connection Machines and CM Lisp. One of the examples was of a way to compute the histogram of a set of numbers:

(β+ X ⍺1)


The basic idea here is that given a Xector X (e.g. -- [5 5 2 5 3 2]), you can compute a Xector of the counts of each using the above expression.

I began to think that this looks a lot of like an APL function/operator combination, so I went to my APLX scrapbook to find something for a histogram. I found one, but I was not quite happy with it. It works well enough, but it does not handle arrays that don't have a one in them. Instead, with a little twist, I managed to make it work for any given range:

+/((¯1+⌊/X)↓⍳1+⌈/X)∘.=X
⍝ Another Possibility
+/((⌊/X)+⍳1+(⌈/X)-⌊/X)∘.=X


Of course, why stop there when we can use a few more characters and get the actual visual representation of things all laid out for us:

' ⎕'[⎕IO+(⌽⍳⌈/A)∘.≤A←+/((⌊/X)+⍳1+(⌈/X)-⌊/X)∘.=X]


This actually does a bit more than the CM Lisp expression above does. The output of this for an array X where X=5 5 2 5 3 2 would be something more like this:

   ⎕
⎕  ⎕
⎕⎕ ⎕


And of course, none of this would be complete without an example in Scheme of doing the same thing.

(define (histogram x)
  (let* ([sm (apply min x)] 
         [rng (1+ (- (apply max x) sm))] 
         [v (make-vector rng 0)]
         [inc (lambda (n) (vector-set! v n (1+ (vector-ref v n))))])
    (for-each inc x)
    (map list 
      (map (lambda (x) (+ x sm)) (iota rng))
      (vector->list v))))


Without a doubt, the β operator in CM Lisp is a very cool thing. It's almost like a combination of APL's reduce and indexing operators combined into one. We simulate this sort of behavior using a matrix in the APL version, and in the Scheme version, I manually do the tracking with the vector.

Actually, I think both the APL and Scheme versions are pleasantly concise. If I did not care about keeping the actual indexes in the Scheme version, then it would be even more concise.