Greg Buchholz's blog

Anyone out there?

Greg Buchholz — Sat, 23 Mar 2013 04:01:28 +0000

Just testing whether posting still works. Kerneltrap was offline for a couple of years there, and I see that no one has posted anything for quite some time.

Logical variables in Prolog

Greg Buchholz — Tue, 23 Jun 2009 03:55:58 +0000

I came across this code, which was supposed to demonstrate a Prolog program that couldn't be written in Mercury. I couldn't help but rewrite that as:

rank(Xs,Rs) :- pairs_keys_values(Decorated,Xs,Rs),
               keysort(Decorated,Sorted),
               numerate(Sorted,1).

numerate([],_).
numerate([_-N|Rest],N) :- N1 is N + 1, numerate(Rest,N1).

...This computes the rank order of a list of elements. For example rank([40,20,50,10],L). unifies L with [3,2,4,1], since 40 is the third largest element, etc.

Partition a list numerically?

Greg Buchholz — Wed, 10 Jun 2009 03:13:42 +0000

Over on the Haskell Cafe mailing list, the topic of which of the following two definitions was better came up:

buildPartitions xs ns = zipWith take ns . init $ scanl (flip drop) xs ns

...or...

takeList :: [Int] -> [a] -> [[a]]
takeList [] _         =  []
takeList _ []         =  []
takeList (n : ns) xs  =  head : takeList ns tail
     where (head, tail) = splitAt n xs

...with various parties declaring the first example as "too smart", and others claiming that the second example is newbie level code. Well I'm much too lazy to try to reason out what those snippets might do at a glance. But the type signature was a pretty big hint as to what the intent was. So I fired up

Non-ugly average in Haskell

Greg Buchholz — Sat, 08 Nov 2008 04:01:31 +0000

data E a b = L (E a b) | R b deriving (Show)

fold f acc [] = R acc                      
fold f acc (x:xs) = let x' = f acc x 
                    in x' `seq` (L $ fold f x' xs)

lift2 f = \x y -> par_eval x y
    where par_eval   (L x)   (L y) = par_eval x y
          par_eval x@(R _)   (L y) = par_eval x y
          par_eval   (L x) y@(R _) = par_eval x y
          par_eval   (R x)   (R y) = R $ f x y

lift1 f (L x) = lift1 f x
lift1 f (R x) = R (f x)

sum' xs = fold (+) 0 xs
len' xs = fold (\x y->succ x) 0 xs
avg  xs =  (sum' xs) / (len' xs)

main = print $ avg [1..1e7]

instance Eq b => Eq (E a b) where
    a == b = case (lift2 (==) a b) of (R x) -> x

instance Num b => Num (E a b) where
   (+) = lift2 (+)
   (*) = lift2 (*)
   fromInteger = R . fromInteger
   abs = lift1 abs 
   signum = lift1 signum

instance Fractional b => Fractional (E a b) where
   (/) = lift2 (/)
   fromRational = R . fromRational

Entering unicode

Greg Buchholz — Sat, 24 Nov 2007 00:57:04 +0000

Here's the configuration file I use to help me enter some of the fun mathematical unicode characters with vim. The commands were borrowed from TeX...

imap jj <ESC>
imap \div ÷
imap \times ×
imap \sum ∑
imap \int ∫
imap \oint ∮
imap \angle ∠
imap \forall ∀
imap \exists ∃
imap \partial ∂
imap \prod ∏
imap \infty ∞
imap \pm ±
imap \sqrt √
imap \circ ∘
imap \Re ℛ
imap \Im ℑ

Misc. ray tracers

Greg Buchholz — Wed, 10 Oct 2007 21:01:08 +0000

By popular demand, here's the more web accessible versions of a couple of simple ray tracers that I quickly cranked out in Perl and Haskell. Along with the respective source code.

It takes a POV-like scene file, and spits out a *.ppm file onto STDOUT.

Cellular Automata

Greg Buchholz — Thu, 08 Mar 2007 22:15:53 +0000

After seeing a cellular automata simulator in F#, I thought I'd make a more general version with Perl/TK which was also shorter. Invoke with a numeric argument on the command line to see automata other than rule 30 (e.g. 90, 110).

SWI-Prolog and Unicode.

Greg Buchholz — Thu, 15 Feb 2007 18:17:23 +0000

% fun with SWI-Prolog and Unicode.  Try some queries like... 
% Ans ≔ ∫x d x.
% Ans ≔ ∫ 2 + x^3 d x.

:- encoding(utf8).
:- op(699, xfy, ≔).
:- op(600, fx, ∫).
:- op(510, xfx, d).
:- op(200, xf, ²).

A+B ≔ ∫ Y+Z d X :- A ≔ ∫ Y d X, B ≔ ∫ Z d X. 
C*A ≔ ∫ C*Y d X :- free(C,X), A ≔ ∫ Y d X.
C*X ≔ ∫ C d X   :- free(C,X).
X² / 2 ≔ ∫ X d X.
X^N1/N1 ≔ ∫ X^N d X :- free(N,X), N =\= -1, N1 is N + 1. 
(log(A*X+B)/A) ≔ ∫ 1/(A * X + B) d X :- free(A,X),free(B,X).
(exp(A*X+B)/A) ≔ ∫ exp(A*X+B) d X    :- free(A,X), free(B,X).
∫ E d X ≔ ∫ E d X.

free(C,X) :- \+ bound(C,X).

bound(X,X).
bound(A+B,X) :- bound(A,X); bound(B,X).
bound(A-B,X) :- bound(A,X); bound(B,X).
bound(A*B,X) :- bound(A,X); bound(B,X).
bound(A/B,X) :- bound(A,X); bound(B,X).
bound(A^B,X) :- bound(A,X); bound(B,X).

Breaking free

Greg Buchholz — Fri, 05 Jan 2007 03:27:41 +0000

If you really want to break free from the von Neumann bottleneck , grab yourself an FPGA starter kit and start playing with Verilog or VHDL. FPGAs are quite interesting now that features like hardware multipliers are becoming more widespread.