blacktaxi

import random
random.seed()

import math

def rnd(_from=0, _to=1): return _from + random.random() * (_to - _from)

def rectangle_random(W=2, H=2):
    return (rnd(0, W), rnd(0, H))

blacktaxi

; Ruby has an awesome feature -- string interpolation. Read about it on the internet.
; On the other hand, Clojure only has cumbersome Java string formatting, which can not be
; used without pain after you've tried Ruby.

; So here's this simple macro that basically allows you to do most things you could do
; with Ruby string interpolation in Clojure.

(ns eis.stuff
  (:require [clojure.string]))

blacktaxi

;;; ENVIRONMENTAL IMPACT STATEMENT
;;;
;;; This program was written on recycled memory.
;;; No cons cells were created.
;;;

(ns interpolate
  (:use [clojure.walk :only (postwalk)]))

(defmacro s

blacktaxi

;;Using the Cassowary constraint solver from ClojureScript
;;This demo shows using multimethods for readable constraint syntax using +, -, and =.
;;Output is a row of circles with random radii spaced so that the space between their boundaries is uniform.

(ns c2.main
  ;;refer-clojure :exclude is currently broken in ClojureScript master
  ;;Ticket open: http://dev.clojure.org/jira/browse/CLJS-114
  ;;Fix applied here: https://github.com/lynaghk/clojurescript/tree/114-refer-clojure-exclude
  (:refer-clojure :exclude [+ - =])
  

blacktaxi

(ns overtone-xmas.bells
  ( :use [overtone.live]
         [overtone.sc.machinery.defcgen]))



;;http://computermusicresource.com/Simple.bell.tutorial.html
(def dull-partials
  [
   0.56

blacktaxi

(defn group [xs]
  "splits its sequence argument into a list of lists of equal, adjacent elements."
  (partition-by identity xs))

(defn zip [xs ys]
  "makes a list of vector tuples, each tuple containing elements of both sequences occuring at the same position"
  (map vector xs ys))

(defn lines [str]
  "For a given string, split it into a vector using a newline terminator as a delimiter"

blacktaxi

(ns people
  (:use [clojure.string :only (join)]
        [clojure.pprint :only (pprint simple-dispatch)]))

;; we can make maps using the special literal form:

{:a 100
 :b 200}

(class {:a 100 :b 200})

blacktaxi

(ns fsm
  (:refer-clojure :exclude [==])
  (:use [clojure.core.logic]))

;; Encoding a Finite State Machine and recognizing strings in its language in Clojure core.logic

;; We will encode the following FSM:
;;
;;  (ok) --+---b---> (fail) 
;;   ^     |

blacktaxi

(ns monad-explore.core
  (:use clojure.algo.monads))

(defmacro let?
  "Almost the same as let. If you add the :ensure keyword paired with
  some predicate as a var in the let form, let? will not continue
  unless the predicate evaluates to true. (The predicate will have
  access to all bindings above.)"
  [bindings & body]
  (let [[bind [kwd pred & more]] (split-with (complement #{:ensure}) bindings)]

blacktaxi

(defmacro defconst [const-name const-val]
  `(def
     ~(with-meta const-name
       (assoc (meta const-name) :const true)) 
     ~const-val))

(defmacro defconsts [bindings]
  `(do
     ~@(map (fn [[const-name const-val]]
               `(defconst ~const-name ~const-val))