kwantam.github.io

Snippets

or, my irregularly updated code blog

2011 June 17

A quine in Scheme derived via the applicative-order Y-combinator:

    ((eval '(lambda (x) (pp `((eval '(lambda (x) (pp ,x))) ',x))))
           '`((eval '(lambda (x) (pp ,x))) ',x))

2013 March 10

A meditation on efficiently detecting illegal states in twisted-ring FSM state vectors. Literate Haskell is a beautiful thing.

2013 April 21

Uncurrying functions for mad(wo)men, or, an entertaining line of thought about something almost entirely pointless.

2013 May 2

BeagleBoard Black Notes, Part 1 — some notes I wrote while playing with my new BeagleBoard Black for the first time. Debian Wheezy installation ; setting up the USB gadgets ; installing a few useful packages.

2013 May 4

BeagleBoard Black Notes, Part 2 — USB network bridging; working with the PRUSS; updating the eMMC's Ångstrom image from Debian.

2014 June 23

Cross Bootstrapping Rust — The Rust build system doesn't presently support bootstrapping a compiler to a different architecture, but with a few modifications we can get it there. This is useful if you're building for a slow device, or for one that doesn't yet have an official stage0 image.

Projects

eccons

eccons is a toolkit for constructing elliptic curves. Its focus is on constructing Weierstrass and Edwards curves having specified order (or, for Edwards curves, specified subgroup order) via complex multiplication.

addchain

addchain implements several methods from the literature for computing short addition chains. You should also see Mike McLoughlin's addchain library, which often gives better results.

conec

conec (COordinated NEtwork Channels) is a Rust library that provides a high-level networking abstraction: it lets clients communicate with one another using arbitrary names rather than network addresses, handles NAT traversal, and provides a number of other nice features.

fffft

fffft is a parallel FFT implementation for Rust.

`lviv`

lviv is a hybrid functional/stack programming language. Here's some example code:

; qsort.lviv
; quicksort implemented in lviv

; filter2
; given a predicate in slot 0 and a list in slot 1
; filter the list into two lists, one for which the
; predicate is true and one for which it is false
( (*tList *fList) ; if the list is null, return the true and false lists
  (*lList uncons (*tList cons *fList) ; otherwise, take the first element, cons it to tlist
                 (*fList cons *tList swap) ; or flist as appropriate
                 3 pick *pred apply if ; (test whether to cons to tList or fList)
   3 roll ***pred eval *filt2Hlp) ; then get the stack back in order and call again
  *lList null? if ) ; (test whether list is null)
(*tList *fList *lList *pred) lambda *filt2Hlp define

( () () *lList **pred eval *filt2Hlp ) ; call the helper function with empty tList and fList
(*lList *pred) lambda *filt2 define

; qsort: use the first element of the list as the pivot
; filter the list and qsort the resulting lists
( (*lList) ; if it's 0 or 1 elm long, just return it
  (*lList uncons dup 3 unroll ; otherwise, get the next pivot, save off the pivot
   (***n <) cons (***n) lambda filt2    ; filter the list into greater and lesser lists
   *qsort swap                          ; sort the first part
   *qsort 3 roll :cons                  ; sort the second part, then replace the pivot
   append                               ; append them, and we are sorted
  )
  (#t) (*lList cdr null?) *lList null? if if )
(*lList) lambda *qsort define