yellowflash

object AutoDiff {

  // When we are computing derivative for say f(x) we would like to keep track of dx/dt (t being independent variable)
  // in-case t == x then diff = 1.
  // Suppose x is not a scalar ie., R^k then we would like to keep track of partial derivatives on each co-ordinate.
  // Hence V is a vector space (which is just enough for our case), this would be final Jacobian
  case class Dual[K, V](value: K, diff: V)

  // We define a Vectorspace V over the field K, we can reduce the generalization by keeping K == Double and it should mostly work too.

yellowflash

object Integration {
  def integrate(fn: Double => Double,
                interval: (Double, Double),
                precision: Double = 0.0001): Double = {
    def areaBetween(start: Double, end: Double): Double = (fn(end) + fn(start)) / 2  * (end - start)

    def doIntegrate(start: Double, end: Double, area: Double): Double = {
      val mid = (start + end)/2
      val left = areaBetween(start, mid)
      val right = areaBetween(mid, end)

yellowflash

class Line {
    constructor(m, c) {
        this.m = m;
        this.c = c
    }

    apply(x) {
        return this.m * x + this.c;
    }

yellowflash

{-# LANGUAGE NoMonomorphismRestriction #-}
{-# LANGUAGE FlexibleContexts          #-}
{-# LANGUAGE TypeFamilies              #-}
import Diagrams.Prelude
import Diagrams.Backend.SVG.CmdLine

appendsEx k n c = appends c (zip (iterateN n (rotateBy (1/(fromIntegral k))) unitX) (repeat circ))

circ = (circle 1 # fc red # lc white # lwL 0.25)
sides = 6

yellowflash

import scala.annotation.tailrec
import scala.collection.mutable

case class Point(x: Int, y: Int) {
  def geoHash(precision: Int): BigInt = {
    @tailrec
    def hash(minX: Int, maxX: Int, minY: Int, maxY: Int, prec: Int, sofar: BigInt) : BigInt = {
      if(prec == 0) return sofar;
      val quadrant = if((minX + maxX)/2 < x) {
        if((minY + maxY)/2 < y) 0 else 1

yellowflash

class Regex {
    constructor(matchesEmpty) {
        this.matchesEmpty = matchesEmpty;
    }

    derivativeBy(ch) {
        throw "Not implemented";
    }

    matches(str) {

yellowflash

class Map {
    constructor(loadfactor = 0.7) {
        this.size = 0;
        this.loadfactor = 0.7;
        this.entries = new Array(1);
    }

    put(key, value) {
        this.resizeIfNecessary();
        for(var i = key.hashCode();; i++) {

yellowflash

module Godel.Core where
  
import Control.Monad (bind, pure)
import Control.Monad.Eff.Console (log)
import Data.Either (Either(..))
import Data.Eq (class Eq, (==))
import Data.Map (Map, empty, insert, lookup)
import Data.Maybe (Maybe(..))
import Data.Show (class Show, show)
import Prelude (otherwise, negate, (+), (-), (>=), ($), (<>))

yellowflash

package cont

import scala.util.Try

abstract class Cont[A] {
  def run[R](cont: A => R): R
  def map[B](fn: A => B): Cont[B] = {
    val self = this
    new Cont[B] {def run[R](cont: B => R) = self.run(cont compose fn)}
  }

yellowflash

sealed trait RegExp {
  def isFinal:Boolean
  def acceptsEmpty:Boolean
  def shift(prev:Boolean, character:Char):RegExp
  def matches(str:String) =
    if(str.isEmpty) this.acceptsEmpty
    else str.foldLeft(this.shift(true, str.head))(_.shift(false,_)).isFinal
}

object Epsilon extends RegExp {