louisswarren

from time import time, sleep

def runtime(f, retcont):
    t = time()
    r = f()
    tt = time()
    if retcont == []:
        retcont.append(r)
    elif retcont is not None:
        assert(r == retcont[0])

louisswarren

from collections import namedtuple
import re

# Literal patterns only match themselves, but quack like regular expressions

class LiteralPattern(str):
    def match(self, other):
        if other.startswith(self):
            return LiteralMatch(str(self))
        return None

louisswarren

CFLAGS = -std=c99 -Wall

main : main.o

.PHONY : test clean

test : main
	./$^ "*regex*" "*vtable*" < main.c

clean :

louisswarren

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>

void print_bin(uint32_t x)
{
	int i;
	for (i = 31; i >= 0; --i)
		putchar(x & (1 << i) ? '1' : '0');
}

louisswarren

arrowelim : {A B : Set} → (A → B) → A → B
arrowelim f a = f a


data _⊎_ (A B : Set) : Set where
  inl : A → A ⊎ B
  inr : B → A ⊎ B

disjintro₁ : {A : Set} → A → (X : Set) → A ⊎ X
disjintro₁ a X = inl a

louisswarren

data ℕ : Set where
  zero : ℕ
  suc  : (n : ℕ) → ℕ
{-# BUILTIN NATURAL ℕ #-}


infixl 6 _+_
_+_ : (n m : ℕ) → ℕ
n + zero = n
n + suc m = suc (n + m)

louisswarren

\documentclass[a4paper]{article}
\usepackage{bussproofs}
\usepackage{savetrees}
\usepackage{amsmath}

\newcommand{\using}[2]{\AxiomC{}\RightLabel{#1}\UnaryInfC{#2}}

\newcommand{\assume}[1]{\AxiomC{#1}}
\newcommand{\closed}[2]{\AxiomC{$\left[\text{#2}\right]^\text{#1}$}}

louisswarren

.PHONY: test test-video
test: nz.png
	sxiv $^

test-video: fire
	./fire | mpv --no-correct-pts --fps=30 --scale=oversample -

%.png: %.ppm
	convert $< $@

louisswarren

CC = gcc
CFLAGS = -O3 -std=c99

.PHONY: test
test: life
	./life < gosper.pbm | mpv --no-correct-pts --fps=20 --scale=oversample -

.PHONY: time
time: life-limited
	time ./$< < pulsar.pbm > /dev/null

louisswarren

class Turtle:
    directions = [( 0,  1),
                  (-1,  0),
                  ( 0, -1),
                  ( 1,  0)]

    def __init__(self, x=0, y=0, d=0, boundary=lambda x, y: True):
        self.x = x
        self.y = y
        self.d = d