For your amusement and edification, the following is a very simple interpreter for fractran

programs which, in addition to running the program to generate its result also generates a trace

to show you how the program executed.

;; A Trivial Fractran Interpreter

;;

;; Copyright 2006 Mark C. Chu-Carroll

;; http://scienceblogs.com/goodmath

;;

;; You’re welcome to do anything you want with this code as long

;; as you keep a copy of this header to identify the original source.

;;

;; This program runs a fractran program. A fractran program is a list

;; of fractions. The fractions are represented by a list of two integers:

;; the numerator, and the denominator. For example, the classic fractran

;; multiplication program could be written:

;; ((385 13) (13 21) (1 7) (3 11) (7 2) (1 3))

;; or:

;; (((* 7 11 5) 13) (13 (* 3 7)) (1 7) (3 11) (7 2) (1 3))

;;

;;

;; To run a program until it terminates, call (run-fractran program input).

;; This will return a list; the car of the list will be the result of

;; running the program, and the cdr will be a trace of the executions in the

;; form of a list of the fractions that ran at each step.

;;

;; To run a program for a specific maximum number of steps, call

;; (run-fractran-bounded program input maxsteps)

;;

(define (step-fractran fract int)

(if (equal? fract ()) int

(let ((fr (car fract)))

(if (= (remainder int (cadr fr)) 0)

(cons (/ (* int (car fr)) (cadr fr))

(list fr))

(step-fractran (cdr fract) int)))))

(define (run-fractran fract int)

(let ((step-result (step-fractran fract int)))

(if (list? step-result)

(let ((new-int (car step-result))

(last-step (cadr step-result)))

(cons step-result (run-fractran fract new-int)))

(list int ))))

(define (run-fractran-bounded fract int bound)

(if (> bound 0)

(let ((step-result (step-fractran fract int)))

(if (list? step-result)

(let ((new-int (car step-result))

(last-step (cadr step-result)))

(cons step-result (run-fractran-bounded fract new-int (- bound 1))))

(list int)))

(list int)))

;; The mult program.

(define mult ‘((385 13) (13 21) (1 7) (3 11) (7 2) (1 3)))

;;

;; (run-fractran mult 432)

;; The primes program

(define primes ‘((17 91) (78 85) (19 51) (23 38) (29 33) (77 29) (95 23)

(77 19) (1 17) (11 13) (13 11) (15 2) (1 7) (55 1)))

;; (run-fractran-bounded primes 2 1000)

———-

Commenter Pseudonym has kindly provided a Haskell version in the comments, which was mangled by MTs comment formatting, so I’m adding a properly formatted version here. I think it’s a really interesting comparison to the scheme code above. The Haskell code is very nice; cleaner than my rather slapdash Scheme version. But overall, I think it’s a pretty good comparison – it gives you a sense of what the same basic code looks like in the two languages. Personally, I think the Haskell is clearer than the Scheme, even though the Scheme is my own code.

module Fractran where

import Ratio

import Data.Maybe

import Control.Monad.Fix

type Program = [Rational]

runFractran :: [()] -> Program -> Integer -> [Integer]

runFractran bound prog l

= step bound prog l

where

step _ [] l = []

step [] (f:fs) l

= []

step (_:bound) (f:fs) l

= let p = f * fromIntegral l

in case denominator p of

1 -> let pi = numerator p

in pi : step bound prog pi

_ -> step bound fs l

fractran :: Program -> Integer -> [Integer]

fractran prog l

= runFractran (fix (():)) prog l

fractranBounded :: Int -> Program -> Integer -> [Integer]

fractranBounded b prog l

= runFractran (take b $ fix (():)) prog l

mult = [385%13, 13%21, 1%7, 3%11, 7%2, 1%3]

primes = [17%91, 78%85, 19%51, 23%38, 29%33, 77%29, 95%23,

77%19, 1%17, 11%13, 13%11, 15%2, 1%7, 55%1]

— fractran mult (2^4 * 3^3)

— fractranBounded 1000 primes 2

### Like this:

Like Loading...