mjwillson

require 'set'
class EquivalenceRelation
  def initialize
    @equivalence_class_by_member = {}
  end
  
  def declare_equivalent(*items)
    combined_equivalence_class = items.map {|item| equivalence_class_of(item)}.inject(Set.new) {|accum,set| accum.union(set)}
    combined_equivalence_class.each {|member| @equivalence_class_by_member[member] = combined_equivalence_class}
  end

mjwillson

# This is a mixin for Test::Unit::TestCase, for providing tests with a simple facility to load fixtures from 
# YAML files. It aims to do as much as possible in a generic way with the YAML library rather than couple
# tightly to a database library.
#
# Fixtures can use arbitrary YAML to represent ruby objects, using !ruby/object:Some::ClassName where needed.
# you will typically need to implement yaml_initialize on the relevant class, in order for this to 
# work in the way you desire (we do so here for Sequel::Model; others including ActiveRecord shouldn't be hard)
#
# Data within one fixture can refer to other fixtures by file and name, using the syntax: !fixture file/name.
# this is achieved by adding a special YAML domain type.

mjwillson

# Drop me a line if you wanna see this as a proper merb plugin.

class Merb::Controller
  ITEM_RANGE = /^items=(\d+)-(\d+)$/
  RANGE = /^(\d+)-(\d+)$/

  # Displays a collection resource (using Merb's display method) while supporting requests for sub-ranges of items in a RESTful fashion.
  # This supports a subset of the HTTP/1.1 spec for content ranges, using a custom range unit 'items'. eg:
  #    GET /collection HTTP/1.1
  #    Range: items 10-20

mjwillson

infinity = 1.0/0
savingsIncomeTax200910 = [(0, 6475), (0.1, 8915), (0.2, 43875), (0.4, infinity)]
incomeTax200910        = [(0, 6475), (0.2, 43875), (0.4, infinity)]

taxWithBands bands income
  = if income <= threshold then
      rate * income
    else 
      rate * threshold + taxWithBands loweredRemainingBands remainingIncome
  where

mjwillson

Infinity = 1.0/0
SAVINGS_INCOME_TAX_200910 = [[0, 6475], [0.1, 8915], [0.2, 43875], [0.4, Infinity]]
INCOME_TAX_200910         = [[0, 6475], [0.2, 43875], [0.4, Infinity]]

def tax(income, bands=INCOME_TAX_200910)
  rate, threshold = bands.first
  if income <= threshold
    rate * income
  else
    lowered_remaining_bands = bands[1..-1].map {|r, t| [r, t - threshold]}

mjwillson

;; First some dummy matrix types and operations for us to play with later:
(deftype GenericDense [])
(deftype FooMatrix [])
(deftype BarMatrix [])
(defn generic-multiply [x y] "generic-multiply")
(defn foo-multiply [x y] "foo-multiply")
(defn bar-multiply [x y] "bar-multiply")
(defn foo-generic-multiply [x y] "foo-generic-multiply")
(defn generic-foo-multiply [x y] "generic-foo-multiply")
(defn bar-generic-multiply [x y] "bar-generic-multiply")

mjwillson

;; I'm sure I'm wrong here -- please correct me!
;; (Although note I'm not trying to capture the exact algorithms and dataflow complexities of hadoop here, just the logical structure of MapReduce computations and a rough sketch of how they're distributed.)

;; not just

(->> data
     (pmap mapper)
     (reduce reducer))

;; but something more like this.

mjwillson

package randomindexing;

/* Helpers for encoding various primitive arrays as byte arrays.
   (Why this isn't in the stdlib I have no idea! feel free to replace
   with some existing library implementation...)

   All encodings use little-endian byte order.
   I benchmarked using
   ByteBuffer.wrap(b).order(LITTLE_ENDIAN).asFloatBuffer().get(f),
   but it's around 3 times slower even on big input.

mjwillson

(defprotocol ToHtml
  (to-html [x]))

(extend-protocol ToHtml
  String
  (to-html [s]
    (clojure.string/escape s {\< "&lt;" \> "&gt;" \" "&quot;" \& "&amp;"}))

  clojure.lang.IPersistentMap
  (to-html [attrs]

mjwillson

(ns streams.core
  (:require [clojure.java.io :as io]))

(def END (Object.))

(defprotocol Stream
  (with-generator [_ callback]
    "Should call callback with a generator function, finally closing any
     resources associated with the stream after the callback returns.