TODO

TODO

Coastline problem
When to automate
Why did you leave?
Redesign is the new rewrite
What problem is this solving?
Can't understand a solution if you don't understand the problem (git flow)
Burnout
People believe what they want to
Managing expectations

Block math
- even and odd
- factoring
- +, x commutivity
- staircase
- x^2 - 1
- pythagorean theorem

Reverse a one-way function with some data loss via bayesian methods
- easier if you have some idea about internal parameters

Pythagorean runs

Many worlds
bootstrap

001110100
  1376524

001110100
011011100

533
000 0
001 1
010 1
011 1
100 0
101 1
110 1
111 0

01234567
10110011

Grover's algorithm
QFT
how many infinities are there?
describeable numbers

more fun examples
more experiment analysis
do-notation
markov chains
k-s test
alias method
stochastic calculus, ito calculus
kalman filter (iterated PGM), conjugate priors
beta distribution, priors, minimum entropy
more probability: http://www.amazon.com/Problems-Probability-Mathematical-Statistics-Mathematics/dp/0387735119/ref=sr_1_2?s=books&ie=UTF8&qid=1373846207&sr=1-2&keywords=40+statistics

diagram of probability distribution derivations

move non-technical posts to Medium
rewrite home page

generative models for lognormal and power law, + G-test

3 ways your A/B test can go wrong
- underlying distribution has no mean
- independence assumption

reversible computing
fib in log n (F(n) * F(n-1) is a known identity)

computational algebra
polynomial tetris?
poly in haskell
complex/quaternion/dual tower - other combinations?
automatic symbolic differentiation

linear logic https://secure.flickr.com/photos/8243148@N08/sets/72157635668011986

code: overflow-y: scroll

scala compile challenge: compile time / lines of code


val harmonic: Stream[Double] = Stream.from(1).map(n => 1.0 / n)

def kahan(xs: Seq[Double]): (Double, Double) = {
  xs.foldLeft((0.0, 0.0)){ case ((sum, carry), x) => {
    val x2 = x - carry
    val newSum = sum + x2
    (newSum, (newSum - sum) - x2)
  }}
}

val rs: Stream[Rational] = Stream.from(1).map(n => Rational(1, n))

def extend(s: List[Int => Int]): Int => (Int => Int) = {
  (n: Int) => if (n < s.size) s(n) else zero
}

def invert(inj: (Int => Int) => Int): List[Int => Int] = {
  def helper(s: List[Int => Int]): List[Int => Int] = {
    if (H(diag(extend(s))) < s.size) {
      s
    } else {
      val r = helper(s ++ List(zero))
      val dr = diag(extend(r))
      if (H(dr) != s.size) {
        r
      } else {
        helper(s ++ List(dr))
      }
    }
  }
  helper(Nil)
}

def invert2(inj: (Int => Int) => Int): Int => (Int => Int) = {
  def update(f: Int => (Int => Int), n: Int, g: Int => Int): Int => (Int => Int) = {
    (a: Int) => if (a == n) g else f(a)
  }
  def iter(hinv: Int => (Int => Int)): Int => (Int => Int) = {
    val f = diag(hinv)
    val k = H(f)
    if (H(hinv(k)) == k) {
      hinv
    } else {
      iter(update(hinv, k, f))
    }
  }
  iter((n: Int) => zero)
}

def h(ns: Int*) = (f: Int => Int) => ns.map(f).sum

def p2(inj: (Int => Int) => Int) {
  val hinv = invert2(inj)
  val f = diag(hinv)
  val n = H(f)
  for (i <- 0 to n) {
    val f = hinv(i)
    println("%d: %s".format(H(f), (0 to n).map(f).mkString(" ")))
  }
  println("H(diag) = %d".format(H(f)))
}


def p(inj: (Int => Int) => Int) {
  val s = invert(inj)
  for (f <- s) {
    println("%d: %s".format(H(f), (0 to s.size-1).map(f).mkString(" ")))
  }
  val hinv = extend(s)
  val f = diag(hinv)
  println("H(diag) = %d".format(H(f)))
}

def solve(inj: (Int => Int) => Int): (Int => Int, Int => Int, Int) = {
  val hinv = extend(invert(inj))
  val f = diag(hinv)
  val n = H(f)
  val g = hinv(n)
  (f, g, n)
}

def evalMulti(x: Int, y: Int, coeffs: List[List[Int]]): Int = {
  def eval(cs: List[Int]): Int = {
    cs match {
      case Nil => 0
      case h :: t => x * eval(t) + h
    }
  }
  def eval2(cs: List[List[Int]]): Int = {
    cs match {
      case Nil => 0
      case h :: t => y * eval2(t) + eval(h)
    }
  }
  eval2(coeffs)
}

def unevalMulti(x: Int, y: Int, z: Int): List[List[Int]] = {
  def uneval(z: Int): List[Int] = {
    z match {
      case 0 => Nil
      case z => (z % x) :: uneval(z / x)
    }
  }
  def uneval2(z: Int): List[List[Int]] = {
    z match {
      case 0 => Nil
      case z => uneval(z % y) :: uneval2(z / y)
    }
  }
  uneval2(z)
}


val rushHour: Distribution[Boolean] = tf(0.2)
val badWeather: Distribution[Boolean] = tf(0.05)

def accident(badWeather: Boolean): Distribution[Boolean] = {
  badWeather match {
    case true => tf(0.3)
    case false => tf(0.1)
  }
}

def sirens(accident: Boolean): Distribution[Boolean] = {
  accident match {
    case true => tf(0.9)
    case false => tf(0.2)
  }
}

def trafficJam(rushHour: Boolean, badWeather: Boolean, accident: Boolean): Distribution[Boolean] = {
  (rushHour, badWeather, accident) match {
    case (true, true, _) => tf(0.95)
    case (true, _, true) => tf(0.95)
    case (_, true, true) => tf(0.95)
    case (true, false, false) => tf(0.5)
    case (false, true, false) => tf(0.3)
    case (false, false, true) => tf(0.6)
    case (false, false, false) => tf(0.1)
  }
}
case class Traffic(rushHour: Boolean, badWeather: Boolean, accident: Boolean, sirens: Boolean, trafficJam: Boolean)

val traffic = for {
  r <- rushHour
  w <- badWeather
  a <- accident(w)
  s <- sirens(a)
  t <- trafficJam(r, w, a)
} yield Traffic(r, w, a, s, t)



def partition(xs: List[A]): (List[A], List[A]) = {
  xs match {
    case Nil => (Nil, Nil)
    case h :: t => {
      (a, b) = partition(t)
      if (h < p) (h :: a, b) else (a, h :: b)
    }
  }
}

def merge(xs: List[A], ys: List[A]): List[A] = {
  (xs, ys) match {
    case ...
    case (x :: xt, y :: yt) => {
      val (a, at, b, bt) = sort2(x, xt, y, yt)
      val bs = b :: bt
      val abs = merge(at, bs)
      a :: abs
    }
  }
}

def extract(xs: List[A]): (List[A], List[A]) = {
  xs match {
    case Nil => (Nil, Nil)
    case h :: t => {
      val (s, r) = extract(t)
      s match {
        case Nil => (h :: Nil, r)
        case sh :: st => {
          if (h < sh) (h :: sh :: st, r) else (sh :: st, h :: r)
        }
      }
    }
  }
}

def extract(xs: List[A]): (List[A], List[A]) = {
  xs match {
    case Nil => (Nil, Nil)
    case a :: abs => {
      val (bs, at) = extract(abs)
      bs match {
        case ... =>
        case b :: bt => {
          (x, xt, y, yt) = sort2(a, at, b, bt)
          (x :: xt, y :: yt)
        }
      }
    }
  }
}



def strand(xs: List[A]): List[A] = {
  val (s, r) = extract(xs)
  merge(s, strand(r))
}