Don't think, feel! (別館)

移転します。

2011-08-02T08:26:00.002+09:00

http://green.sphere.sc に移転します。日本語コンテンツは http://green.sphere.sc/jp にあります。

basic individual based models / clojure

2011-06-28T20:56:00.014+09:00

https://gist.github.com/35bd78f7bb197e39164f (scripts of clojure with comments in English)

今回のソースはブログに載せるのは長すぎる（２つのファイルで３５０行くらい。拡張性を考えて関数を結構細かく分けています。）ので、ソースは載せないです。上記を参考にしてください。いずれは解説を加える予定ですが、こちらじゃなくて、ホームページに載せると思います。（ブログでソースを取り扱うのは何かと面倒なので。）

上記プログラムの実行例です。連続時間モデル(イベントベースシミュレーション)も離散時間モデルも同じような図ですが、各シミュレーションは５０回試行したものをそれぞれIncanter chartsを利用してグラフ化しています。1000個体のものを50回試行させてグラフ化した時の時間が２分３０秒ほどかかってます。これは未最適状態です。

離散：初期個体数 10でt=100まで

離散：初期個体数100でt=100まで

離散：初期個体数 1000でt=100まで

連続：初期個体数 10でt=100まで

連続：初期個体数 100でt=100まで

連続：初期個体数 1000でt=100まで

メアドの暗号化について / javascript

2011-06-28T06:12:00.006+09:00

もともと持っていたホームページを改変することを考えててどうしようかって検討してたんだけど、jekyllを利用することを考えてます。jekyllの場合、わざわざブラウザのエディタを使わなくてよいので、emacs/vimで作れるので大変楽です。作成したものをそのまま、ホームページのホスティングに転送するようにしておけばいいですからね。個人のページなんで動的なことが必要なのはあまりないものでこれで十分かと思ったくらいです。

そこですこしjavascriptをいじってみた。メールアドレス用のスクリプトを作ってました。もっとも、僕の場合、普段からメアドを野ざらしにしているからいまさら暗号化する必要はないんですがね。その暗号を解読する関数ですね。作りは簡単なんですが。nこの長さmの文字列を用意してみます。以下は3つの文字列で5の長さを持ってるものです：

abcde
fghij
klmno

ここから先頭から縦に取ってきて順番並べると "afkbglchmdinejo"が作れますね。これをキャラクターコードの配列に置き換えます。(97, 102, 107, 98, 103, 108, 99, 104, 109, 100, 105, 110, 101, 106, 111)これをdecipherに読み込ませると終了です。


function decipher(c,n)
{
  var s0 = String.fromCharCode.apply(String, c);
  var s1=new Array(n);

  for(i=0 ; i < n ; i++){
      s1[i]="";
  }

  for(i=0 ; i < s0.length/n ; i++){
    for(j=0 ; j < n ; j++){
      s1[j]=s1[j] + s0.charAt(n*i+j);
    }
  }
  return(s1);
};

これを実際に使うと次のようになります。node.jsで試してます。

> var arr = new Array(97, 102, 107, 98, 103, 108, 99, 104, 109, 100, 105, 110, 101, 106, 111);
> var result = decipher(arr,3);
> result[0];
'abcde'
> result[1];
'fghij'
> result[2];
'klmno'

ちょっとしたことを組み込んでました。野ざらしにしてる僕のメアドですが、gmailのスパムを見てるとさほど多くないから、意外と取られてないんだなとは思いますよ。これをどう使ったかというのはここで書かないけど。

階乗計算の比較(apply, reduce, cps, recur and iterate) / clojure

2011-06-20T20:30:00.006+09:00

上記のグラフはIncanter/chartsの練習で作ったものなんです。同じ作るならば、ちょっとは参考になるものをと考えて見るのが良いだろうと思って、階乗計算のパフォーマンスをグラフ化してみた。赤色は継続渡し、青色は再帰、緑はiterate, 黄色とラベンダー色（重なってる）はapply,reduceを利用して、それぞれ要素が1000,2000,3000,4000,5000の時の階乗計算を１０回行いその平均をグラフ化したものです。その結果は、apply,reduceのパフォーマンスは圧倒的に悪いですね。特に型宣言を行うといったチューニングはしていないですが、この位の差が出てくるようです。視覚化するとよくわかりますね。継続渡し再帰を利用したものが一番パフォーマンスが良かったです。継続渡しっていいんですね。要素数が少ない時はさほど気にはならないけど、大規模なことをするときは注意する必要があるってことを示してるのでしょう。

;;; time+ origins from 'time' of clojure.core under EPL by Rich Hickey.
(defmacro time+
"Evaluates expr and prints the time it took.  Returns the value of
expr."
{:added "1.0"}
[expr]
`(let [start# (. System (nanoTime))
       ret# ~expr]
   (/ (double (- (. System (nanoTime)) start#)) 1000000.0)))

(defmacro time-repeat [t expr]
  `(take ~t (repeatedly (fn[] (time+ ~expr)))))

(defn fact-cps [n cont]
  (if (zero? n)
      (cont 1)
      (recur (dec n) (fn[x] (cont (* n x))))))

(defn fact-recur [n result]
  (if (zero? n)
      result
      (recur (dec n) (* n result))))

(performance/time-repeat
10 (last (map #(second %)
           (take 5000 ; 5000までの階乗計算
                 (iterate (fn[[x y]][(inc x) (* x y)])
                 [2 1])))))

(reduce * 1 (range 2 5001))

(apply * (range 1 5001))

macroでmacroを作る。 /clojure

2011-06-10T00:10:00.005+09:00

Clojureでマクロをつくろうとする場合、common lispより制約が強いので作り方も若干変える必要があります。そこで一番大きいのは、マクロで悪名高かったバッククオート`を重ねられない点です。その点をよく考えて、障害を乗り越えなければいけません。制約があるために、バッククオート以前に処理をするのが勝負どころと言えるでしょうね。swingなどでproxyを設定することがあるけど、あれは糖衣するのに良い材料だと思ってます。残念ながら僕はJavaのライブラリを使うコツをまだつかんでないので、これは試作段階のものです。だからまだ、githubにはアップロードしないです。Practical clojureの共著者のSierraさんのブログをみてみる[1]と、この手のマクロはon-actionマクロのようにadd〜のところからマクロにするほうがいいのだろうな。と今は思ってます。以下のdefproxyってのはマクロ名とinterface名とが同じになるようにしているけど、それが適切かどうかまだ判断つかないですね。^^;

(defmacro defproxy [name]
(let [body# 'body
    name# name
    amp# '&]
`(defmacro ~name# [~amp# ~body#]
   (conj ~body# [] ['~name#] 'proxy))))

だからマクロでマクロをつくろうと思えば、作れないことはない。しかし、common lispのマクロとは違った工夫が必要だよ。ってことですね。もう少しわかりやすく作れないのか？まだ考えています。でも、ここまで出来れば、マクロで関数とマクロを同時に設定するという芸当も可能だってことはわかります。その時は、

(defmacro foo [bar ...]
(let [...]
`(do
   (defmacro ....)
   (defn ....)))

というような作成方法になります。さて、どこで使うかやね。笑

dopoll マクロ / clojure

2011-06-03T21:47:00.011+09:00

dopollマクロですが、ちょいと分かりにくいので解説です。サンプルと出力結果はPriorityBlokingQueueの利用例ですが、Javaのライブラリで供給されているデーター構造とそれの操作する関数群があるんですが、その操作を繰り返し行うときに利用するように作ったマクロです。だから恐らく.pollと.sizeをメソッドに持ってるjavaのクラスならば活用できるでしょう。

ご存知のように？この手の繰り返し操作をしようとすると、loopマクロを利用することになりますが、loopマクロは取り扱いがシンプルではないので、何かとエンバグしやすい印象があるんですね。loopで同じ事をさせようと思ったらwhen-not以下を普通に記述すればいいのですが、案外失敗して、無限ループに突入してしまうこともあるんですね。そのために常にqueueのサイズが0になってるかどうかチェックしています。これを常に知っておかないと、loopを使って記述しても悩んでしまうバグとして関数内に放置してしまう可能性がありますが、予めマクロを作っておくとその可能性はなくなります。使い方は極めてシンプルしていてdotimesやdoseqを知っていれば直感的に使えるようになっています。ただし、終了条件だけはいつも最後まで繰り返さないときのために第三項目として取り上げています。このマクロでは、マクロと解釈する前に、ベクターの３つめの項目があるかどうか調べて、なければ最後までループさせるようにして、あれば、それを終了条件になるようにしています。それはサンプルを見てください。

マクロとしては複雑に見えるけど、macroexpand-1をして分かりやすく加工すると次のように解釈してくれることがわかります。

user> (macroexpand-1 '(dopoll [i a]
       (println i)))
(when-not (zero? (.size a))
 (loop [i (.poll a)]
   (println i) (if-not (zero? (.size a))
    (recur (.poll a)))))

user> (macroexpand-1 '(dopoll [i a (> (.peek a) 10)]
       (println i)))
(when-not (or (zero? (.size a)) (> (.peek a) 10))
 (loop [i (.poll a)]
   (println i)
   (if-not (or (zero? (.size a)) (> (.peek a) 10))
     (recur (.poll a)))))

ソース：＆と不等号の箇所はブログの仕様上自動的に；が挿入されるので試すときは；を取ってくださいね。


(defmacro dopoll [bindings & body]
 "A macro for loop manipulations of java collection queues"
 (let [var# (bindings 0)
 pq# (bindings 1)
 term# (if (= (count bindings) 2)
  `(zero? (.size ~pq#))
  `(or (zero? (.size ~pq#)) ~(bindings 2)))]
   `(when-not ~term#
      (loop [~var# (.poll ~pq#)]
  ~@body
  (if-not ~term#
    (recur (.poll ~pq#)))))))

(comment =example=
 (import [java.util.concurrent PriorityBlockingQueue])
 (defn print-pq []
   (let [pq (new PriorityBlockingQueue)]
     (dotimes [_ 10]
 (.add pq (rand 1000)))
     (dopoll [i pq (> (.peek pq) 500)]
      (println i))
     (println "elements more than 500:")
     (dopoll [i pq]
       (println i))))
;; user> (print-pq)
;; 163.45692827827574
;; 335.192525607674
;; 440.69978223389404
;; elements more than 500:
;; 528.0780372058205
;; 608.7673080309557
;; 724.6340821453795
;; 731.3274923835517
;; 821.201362348645
;; 899.2657774538147
;; 968.5099196992995
;; nil
;; user>
 )

久しぶりにいっヶ月ばかりclojureと格闘したけど、プログラミンの感覚を少し取り戻したような気がします。:-)

incanter-processing を試すその４ + dopull macro / clojure

2011-06-03T20:18:00.010+09:00

これもincanter/processingのデモですけど、今度は動画に落としてみました。ubuntu上でconvertコマンドを利用して変換させています。

ここでは、Java標準に付いてるPriorityBlokingQueueを利用して、オブジェクトの優先順位をフレームごとに変えて描写させています。(ubuntu上のffmpegで再変換して動画を作り直しました。)そこで活躍してるのはdopollマクロなんですが、この説明はまたの機会にて。これはincanter/processingとPriorityBlokingQueueの練習とdopollの実戦投入テストですね。

https://gist.github.com/1006213


;;; -*- Mode: Clojure; Coding: utf-8 -*-
;;;
;;; rotate2.clj - an incanter/processing example of 'rotate'
;;;
;;; Copyright (C) 2011 by Yasuto TAKENAKA  y.takenaka@gmail.com
;;;
;;;                       Time-stamp: <2011-06-03 20:17:30 yasuto>
;;;                       License   :  http://en.wikipedia.org/wiki/MIT_License
;;;
(ns processing-samples.rotate2
(:use (incanter core processing))
(:import [java.util.concurrent PriorityBlockingQueue]))

(defstruct obj :tr :color :time)

(defmacro dopoll [bindings & body]
"A macro for loop manipulations of java collection queues"
(let [var# (bindings 0)
 pq# (bindings 1)
 term# (if (= (count bindings) 2)
  `(zero? (.size ~pq#))
  `(or (zero? (.size ~pq#)) ~(bindings 2)))]
`(when-not ~term#
   (loop [~var# (.poll ~pq#)]
  ~@body
  (if-not ~term#
    (recur (.poll ~pq#)))))))

(defn rloc []
(let [dif 180]
(- (int (rand (* 2 dif))) dif)))

(defn rcol []
(let [lim 256]
(int (rand lim))))

(defn init-objs [n]
(for [x (range n)]
(struct obj [(rloc)(rloc)] [(rcol)(rcol)(rcol)]
     (ref (rand 1)))))

(defn obj-comp [obj1 obj2]
(if (< @(:time obj1) @(:time obj2)) true false))

(defn four-circle [sktch [tr-x tr-y] [r g b] rad]
(doto sktch
push-matrix
(fill r g b)
(translate tr-x tr-y)
(rotate (radians rad))
(ellipse -15 -15 30 30)
(ellipse  15 -15 30 30)
(ellipse 15 15 30 30)
(ellipse -15 15 30 30)
pop-matrix))

(defn fname [cunt]
(cond
(> 10 cunt) (str "000" cunt)
(> 100 cunt) (str "00" cunt)
(> 1000 cunt) (str "0" cunt)
:else (str cunt)))

(defn rotate-example2 []
(let [objs (init-objs 30)
 pq (new PriorityBlockingQueue 10 obj-comp)
 rad (ref 0)
 cunt (ref 0)
 sktch (sketch
        (setup []
        (doto this
   (size 400 400)
   (background 255)
   smooth
   no-stroke
   ))
        (draw []
       (doseq [el objs]
         (.add pq el))
       (doto this
         (background 255)
         (translate (/ (width this) 2) (/ (height this) 2))
         (rotate (radians @rad)))
       (dopoll [ite pq]
        (four-circle this (:tr ite)
       (:color ite) @rad)
        (dosync (ref-set (:time ite) (rand 1))))
;;       (save this (str "sample" (fname @cunt) ".png"))
       (dosync (alter rad inc)
        (alter cunt inc))))]
(view sktch :size [400 400] :title "rotate example")))

incanter processingを試すその３ /clojure

2011-06-01T21:33:00.007+09:00

incanter/processingを使ってサンプルをいくつか作ってます。感覚的にはだいたい分かってきたんですが、使いやすいですね。あわないと感じてたけど、しばらく触ってみます。

ただ、processingを触るとどうしてもOOP（オブジェクト指向プログラミング)が関連してくるので、clojureのオブジェクト指向の関連のことを触ってるところですね。やはりというのかClojureでoopをするとCommon LispのCLOSやRのオブジェクト指向とに通った感じですね。決して、javaやC++に近いとは言えませんが、そのかわり柔軟性は高いと思う。したのはrotateなどのサンプルです。ただ、このようにprocessingの命令を呼ぶ程度の事ならば、clojureを使ってプログラミングする恩恵があまりありません。

https://gist.github.com/1002218


;;; -*- Mode: Clojure; Coding: utf-8 -*-
;;;
;;; rotate.clj - a incanter/processing example of 'rotate'
;;;
;;; Copyright (C) 2011 by Yasuto TAKENAKA y.takenaka@gmail.com
;;; 
;;;                       Time-stamp: <2011-06-01 21:32:42 yasuto>
;;;                       License   : http://en.wikipedia.org/wiki/MIT_License
;;;
(ns processing-samples.rotate
  (:use [incanter core processing]))

(defn rotate-box [sktch rad]
  (doto sktch
    push-matrix
    (fill 196 196 (mod rad 256))
    (rect-mode CENTER)
    (translate 100 100)
    (rotate (radians rad))
    (rect 0 0 100 100)
    (rect-mode CORNER)
    pop-matrix))

(defn draw-header [sktch rad]
  (doto sktch
    (background 255)
    (fill 196 (mod rad 256) 0)
    (create-font "Serif" 16)
    (text-align LEFT)
    (text "This is an example." 50 20)
    (rect 0 50 50 50)))

(defn draw-footer [sktch]
  (doto sktch
    (fill 255 196 0 200)
    (ellipse 100 150 50 50)))

(defn rotate-example []
  (let [rad (ref 0)
 sktch (sketch
        (setup []
        (doto this
   (size 200 200)
   (background 255)
   smooth
   no-stroke))
        (draw []
       (doto this
         (draw-header @rad)
         (rotate-box @rad)
         draw-footer
         (save "proc_example1.png"))
       (dosync (alter rad inc))))] 
    (view sktch :size [250 250] :title "rotate example")))

incanter processingを試す２１次元セルオートマトン /clojure

2011-05-27T18:57:00.009+09:00

incanter-processingも少しいじってるうちに扱いが分かるようになってきたけど、本来使おうとしてることに不適当かなと感じてるので、今後本格的に使うかどうかわからない。

今回の例は１次元セルオートマトンを利用したものです。１次元セルオートマトンは多くの方も知ってるだろうし、プログラムもあちこち出回っています。もちろん、ライフゲームも含めてよく見かけますね。だから、ただのプログラムよりちょっとひねってしまうことをやってます。セルオートマトンでよく見かけるのは次のセルの状態を決めるルールはルール３０というものを主に使ってるのですが、他のルールでも可能にしたものです。このルール３０ってのは２進数で表せば00011110Bとかけるので、これが隣接するセルで生成する状態のルールを表してます。隣接するものと中央のセルの状態が010ならばこれを２進数と見れば１０進数に直すと4ですね。30を２進数で表したところの４ビット目が1であるが、それが次の状態を決めるということです。つまり、全てで２５５ルールあるってことですね。使い方は下のソースを見てもらえばいいですが、例によってここでソースを書くと一部チウ記述に自動的になってしまうのでgithubの方を参考にしてもらえればいいです。ちなみに、ルールごとに関数を作りやすいように、今回は関数で関数を作るようにしています。つまり、(print-1dca 30)というのはこれそのものが関数で、ルール３０の１次元セルオートマトンを表示する関数ということになってます。いくつかのルールはwikipedia上でも説明されていますし、そのURLもソース中に示していmす。

次に、incanter processingを使ったものですが、普通によくあるセルを表示するものにしようかと思ったんですが。。。

ここは、２４個の２進数のリストを使って、色として表すようにしています。それが下の図です。これはある時のスナップショットですが、このダーツのマトが色変化をします。ただし、注意書きですが、癲癇を持ってる方は使わないでください。なぜなら、利用する初期状態（セルのリスト）やルール次第で、色変化が大変激しくなるからです。そのためにフレームレートを下げています。ルールや初期状態しだいでは穏やかな変化を示すものもありますし、不規則か規則かわからないような変化も当然出てきたり、簡単なパターンや白や黒あるいは他の色に固定されることもあったりします。

https://gist.github.com/994998

;;; -*- Mode: Clojure; Coding: utf-8 -*-
;;;
;;; one-d-cd.clj - a library for one dimention cellar automata
;;;
;;; Copyright (C) 2011 by Yasuto TAKENAKA  y.takenaka@gmail.com
;;;
;;;                       Time-stamp: <2011-05-27 18:55:54 yasuto>
;;;                       License   : http://en.wikipedia.org/wiki/MIT_License
;;;

(ns one-d-ca.core
(:use (incanter core processing)))

(defn- create-transition-rule
"create the transition rule list"
[rule]
(map #(bit-test rule %) (range 8)))

(defn- create-indexed-transition-rule
[rule]
(let [transition-rule (create-transition-rule rule)]
 (map-indexed list transition-rule)))

(defn- cell-transition
"detarmine the next statement of the cell from its present statement"
[rule]
(fn [n]
 (second (first (filter #(if (= (first %) n)
        (second %))
     (create-indexed-transition-rule rule))))))

(defn- present-state
"check the current pattern from a center cell with its neighbors"
[l c r]
(+ (bit-shift-left l 2) (bit-shift-left c 1) r))

(defn transition
"calculate a cell transition. This is a function generating
a function besed on a transition rule ,'rule'."
[rule]
(let [cell-trans-fn (cell-transition rule)]
 (fn [coll]
   (let [len (count coll)
    cycoll (drop (dec len) (cycle coll))]
(for [i (range len)]
  (let [cells (take 3 (drop i cycoll))]
    (if (cell-trans-fn (apply present-state cells))
      1 0)))))))

(defn print-1dca
"print one-dimention celler automata. e.g, ((print-1dca 30) coll)"
[rule]
(fn [n init-state]
   (doseq [i (take n (iterate (transition rule) init-state))]
 (println (apply str
   (map #(if (zero? %) " " "*") i))))))

;; #Example http://en.wikipedia.org/wiki/Rule_30
;; one-d-ca.core> ((print-1dca 30) 10 [0 0 0 0 0 1 0 0 0 0 0 ]) ; 30=00011110B
;;      *  
;;     *** 
;;    **  *
;;   ** ****
;;  **  *   *
;; ** **** ***
;;    *    *
;;   ***  ***
;;  **  ***  *
;;  * ***  ***
;; nil
;;((print-1dca 90) 8 [0 0 0 0 0 0 0 1 0 0 0 0 0 0 0]) ; the Sierpinski gasket
;;
;; c.f. http://en.wikipedia.org/wiki/Category:Cellular_automaton_rules
;;

(defn list->8bit [coll]
(reduce (fn[x y]
    (+ x (bit-shift-left (second y)
    (first y))))
  0 (map-indexed list coll)))

(defn to-rgb [coll]
(map #(list->8bit %)
    (partition 8 coll)))

(defn onedca-color
"CAUTION: DO NOT USE IF YOU HAVE EPILEPTIC.
watch the color animation of one dimention cellar automata.
this requires a list containing 24 elements of 0 or 1 because
this generates 24-bit color. "
[rule]
(fn [init-list & {:keys [rate] :or {rate 1.5}}]
 (let [dynamics (ref (iterate (transition rule) init-list))
  sktch (sketch
  (setup []
  (doto this
    (size 200 200)
    (background 255 255 255)
    (framerate rate)
    smooth
    no-stroke))
  (draw []
        (let [current (first @dynamics)
       [r g b] (to-rgb current)
       x (/ (width this) 2)
       y (/ (height this) 2)]
   (doto this
     (background 255 255 255)
     (fill r g b)
     (ellipse x y 135 135)
     (fill b r g)
     (ellipse x y 85 85)
     (fill g b r)
     (ellipse x y 40 40)
     )
   (dosync
    (ref-set dynamics (drop 1 @dynamics))))))]
   (view sktch :size [200 200]))))

;;
;; one-d-ca.core> ((onedca-color 30) [1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 ])
;; one-d-ca.core> ((onedca-color 90) [1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 ])

forマクロ / clojure

2011-05-25T19:37:00.026+09:00

forは内包表記として知られてるんですが、こちらはこちらでmapとはまた違った使い方にも対応していて便利な所がありますね。変数同士での条件付きループならこちらのほうが便利な場合もあります。例えば、x+y=5 を満たすx yの組み合わせを見つけろというならば、

user> (for [x (range 6) y (range 6) :when  (= 5 (+ x y))] [x y])
([0 5] [1 4] [2 3] [3 2] [4 1] [5 0])

同等なものをmapなどでつくろうとしたらこれほど簡単に書けない所があるしね。

他には偶数や奇数だけを取り出すというのならこのようなことも出来ます。(keepと同等)

user> (for [ x (range 10) :when (odd? x)] x)
(1 3 5 7 9)
user> (keep #(if(odd? %) %) (range 10))
(1 3 5 7 9)
user> (for [ x (range 10) :when (even? x)] x)
(0 2 4 6 8)
user> (keep #(if(even? %) %) (range 10))
(0 2 4 6 8)

次にトランプカードを例に更に複雑なものをforで扱ってみましょう。D,H,S,Cダイヤ、ハート、スペード、クラブとあらわしてx変数にリストとして格納して、A,J,Q,Kはエース、ジャック、クィーン、キングとそれぞれを表し、数字はy変数にリストとして格納します。ここから絵札だけを取り出すとしますね。そのために、trump-card-numberという関数を作って絵札を数字に表し直しています。そこでforないにキーワードletで新たに変数zをつくって、trump-card-numberで変換した数字を格納します。このzがキーワードwhen で zが10以上と書けばおしまいです。この手のことを使うならば、forの表記の強力さを感じられるようになっています。

https://gist.github.com/990795

user> (defn trump-card-number [n]
(cond (= n 'A) 1
(= n 'J) 11
(= n 'Q) 12
(= n 'K) 13
:else n))
#'user/trump-card-number
user> (for [x '(D H S C) y '(A 2 3 4 5 6 7 8 9 10 J Q K)
:let [z (trump-card-number y)] :when (> z 10)] (str x y))
("DJ" "DQ" "DK" "HJ" "HQ" "HK" "SJ" "SQ" "SK" "CJ" "CQ" "CK")
user>

このように、文字列と数字が混じったシーケンスで条件を与えて、結果を取り出すときには、forはすっきりした書き方ができるというところです。キーワード変数のlet,when,whileを知らなくても使えるけど、知ればもっと強力に使えるということでもありますよ。

多重ループをマクロでまとめる / clojure

2011-05-19T20:28:00.008+09:00

多重ループって多次元配列を扱うときや重複を許す組み合わせを全て出すときによく記述しますが、見た目も汚いし、美的な観点からも簡潔に書くという観点からもあまり良いものではないが、必要悪になってますね。clojureは幸いlisp系でそこそこのところまでマクロで記述できるのは大変な強みです。

そこで多重ループをマクロで簡潔にしてしまいましょう。本当はマクロでマクロを作るという形でdoseq/dotimesの両方を定義しようと思ったけど、マクロでマクロを定義するのが上手く行かないので、方針を変えて、一部は関数で書いて出力をマクロという形をとっています。この形で関数をコンパイルするときはコンパイラからは多重ループを記述した時と同じに見えるようになってます。

定義したマクロはnested-dotimesとnested-doseqですが、使用方法はソース内のサンプルを見れば一目瞭然でしょう。三重ループですら


(nested-dotimes [i 10 j 20 k 30] (print (+ i j k)))

でかけるので１行ですみます。変数はシーケンスの最初から後ろの変数の順番は多重ループの内側から外側に対応しています。これで２重だけじゃなくて５重だろうが６重だろうが同じで済みます。（もっとも、３重までしかほとんどでは使わないでしょう。)nested-do-関数は魔術みたいに視えるかもしれないけど、複雑なマクロを書くときはこのように、基本的なシーケンスを扱う関数・マクロを遊んでるといいですね。この関数もマクロ化しようかと思ったけど、別にそこまでこだわる必要はないしもういいか。。。と思いました。


;; * a utility for loop manipulation
;; nested-do- is a utilit for nestedo-doseq/nested-dotimes

(defn- nested-do- [doname bindings & body]
 (let [binds (map #(vec %)
    (partition 2 bindings))]
   (reduce #(if (list? %1)
            (list doname %2 %1)
            (reverse (into (list %2 doname) %1)))
    (concat body binds))))

;; an example for how to use nested-dotimes is as following:
;; user> (macroexpand-1 '(nested-dotimes [i 10 j 20 k 30] (print (+ i j k))))
;;(dotimes [k 30]
;;  (dotimes [j 20]
;;    (dotimes [i 10]
;;      (print (+ i j k)))))
;;
;; so, it is equal to nested dotimeses. nested-doseq also is a similar utility.
;;
;; Example 2:
;; user> (def foo (make-array Integer 10 10 10))
;; #'user/foo
;; user> (nested-dotimes [i 10 j 10 k 10]
;;  (aset foo i j k (+ i j k)))
;; nil
;; user> (aget foo 7 8 9)
;; 24

(defmacro nested-dotimes [bindings & body]
   (let [result# (nested-do- 'dotimes bindings body)]
     `~result#))

;; an example of nested-doseq:
;; user> (macroexpand-1
;;       '(nested-doseq [i (map char (range 70 75))
;;         j (map char (range 80 85))]
;;          (println  i j )))
;; (doseq [j (map char (range 80 85))]
;;   (doseq [i (map char (range 70 75))]
;;     (println (str i j))))

(defmacro nested-doseq [bindings & body]
 (let [result# (nested-do- 'doseq bindings body)]
   `~result#))

この記事で示したソースは不必要なものが自動的についてしまうようです。（＆が自動的に変換されるため。）ソースはgithubからどうぞhttps://gist.github.com/980582

incanter processing を試す/ clojure

2011-05-15T22:10:00.008+09:00

グラフィック関連のことを知りたかったので調べたらincanterというライブラリがありました。R的なことをclojureでするということができちゃうようですね。R以前にあったxlispstatという物があったけど、それの現代版という印象でしょうか。Rもschemeの影響をうけてるし、オブジェクト指向もCLOSと同じ考えだし、Rってlispとは相性はいいとは思う。このパッケージなら正規乱数も用意されてそうだなぁ。

さて、このclojureではincanterは有名なようで、あの充実っぷりはかなりのものかな。と思った。processingやcolt,Jfreechartも巻き込んでるのでシミュレーションをするときには願ったりかなったりのライブラリですね。それだけ幅広いものを扱うだけに全容を追いかけるのは時間が必要ですが、incanterのprocessingモジュールはcl-processingからのフォークのようです。

話はもどって、グラフィック関連のことを早速試してみた。ただサンプルを動かすんじゃなくて、なんか作ってみようと考えてました。最初はランダムウォークでもつくってみればいいかとは思ったんだけど、プログラミングをしてると目への負担が大きいので目のマッサージ目的のものを作ってみようと思った。そこで。。。

https://gist.github.com/973156 ここに一応置いてあります。


(use '(incanter core processing))
(defn rand-range [edge radious]
(+ (int (rand (- edge (* 2 radious)))) radious))

(defn eye-massager [speed sx sy]
(let [radious (ref 100.0)
 x (ref nil)
 y (ref nil)
 size-x sx
 size-y sy
 sktch (sketch
        (setup []
        (doto this
   (size size-x size-y)
   (background 196)
   (framerate speed)
   smooth))
        (draw []
       (dosync
        (ref-set x (rand-range (width this) @radious))
        (ref-set y (rand-range (height this) @radious))
        )
       (doto this
         (background (color 196 255 196))
         (fill 255 128 0)
         (ellipse @x @y @radious @radious))))]
(view sktch :size [size-x size-y])))

;; user> (eye-massager 10 1680 1000)

incanterのパッケージはこれからゆっくり中身を見てみようと思います。必要そうなものから覚えて使おうって思ってる。(eye-massager 10 1680 1000)というのは最初の引数がフレーム数(10では早いかもしれない。疲れすぎの場合は1か2くらいでいい) オレンジの円を１−３分くらい追いかけてみるといいです。1680はフレームの横幅 1000は縦幅です。グラフィック絡みのプログラムはどうしても見た目が汚くなりがちですね。できればマクロで糖衣したいんですけどね。適度な糖衣は見極めてからでいいかと思ってます。また、コンタクトレンズをしている人は目を傷つける可能性があるからやめてね。

https://gist.github.com/970660 こちらはおまけ sort/sort-by/Priority(Blocking)Queueを構造体を利用したデータで使う場合の練習です。

lazy-shuffle / clojure

2011-05-11T19:41:00.009+09:00

ランダムシャッフルは'shuffle'がclojureの標準関数としてあるんですけど、遅延ランダムシャッフルというのを作ってみた。これはfisher yeats法というランダムシャッフルで早い方法があるけど、あのアルゴリズムを見てると、遅延版は簡単に作れそうだと思ったので作ってみた。わかり易い説明はここにあります。この説明では後ろから入れ替えてるけど、前から入れ替えるようにして、その前の要素をとりだしたあとに同じ動作をするような形で遅延操作をさせています。

これは作成したlazy-shuffleとshuffleの比較。 0から999までの数列から１０個をランダムに取り出すというものです。


user> (time (lazy-shuffle (range 1000) 10))
"Elapsed time: 0.199614 msecs"
(41 838 249 657 708 559 897 167 865 659)
user> (time (take 10 (shuffle (range 1000))))
"Elapsed time: 1.707102 msecs"
(440 827 150 198 109 72 30 102 328 414)
user> (time (lazy-shuffle (range 1000) 10))
"Elapsed time: 0.581405 msecs"
(594 569 112 329 287 174 189 927 903 880)
user> (time (take 10 (shuffle (range 1000))))
"Elapsed time: 15.230183 msecs"
(718 704 163 400 391 287 175 796 115 834)
user> (time (lazy-shuffle (range 1000) 10))
"Elapsed time: 0.206874 msecs"
(356 142 80 403 3 121 160 224 443 663)
user> (time (take 10 (shuffle (range 1000))))
"Elapsed time: 6.538013 msecs"
(420 498 196 922 311 44 741 708 647 377)

これをみてもやはり、遅延させていたことはかなり効果が出ていることがわかります。標準関数のshuffleを使ったもので1.7-15.2秒ほど遅延版で 0.19-0.58秒なんですからね。1000個の要素で3-80倍の違いですかね。このように要素が比較的多くシャッフルしたものを全部必要としないような条件でランダムシャッフルが必要ならば、遅延版はいいと言えるかもしれません。

ソースは下にあります。


(defn create-shuffle-object [lst]
  (map #(ref %) lst))

(defn swap-elements [el1 el2]
  (let [tmp @el1]
    (dosync (ref-set el1 @el2)
     (ref-set el2 tmp))))

(defn lazy-shuffle-core [s-lst len]
  (lazy-seq
   (if (= 1 len)
     s-lst
     (let [fst-el (first s-lst)
    rst (rest s-lst)
    nlen (dec len)
    swap-el (nth rst (int (rand nlen)))]
       (swap-elements fst-el swap-el)
       (cons fst-el (lazy-shuffle-core rst nlen))))))

(defn fetch-elements [s-lst]
  (map (fn [el] @el) s-lst))

(defn lazy-shuffle [lst fetch-len]
  (let [len (count lst)
 s-lst (create-shuffle-object lst)]
    (if (> fetch-len len)
      (fetch-elements (take len (lazy-shuffle-core s-lst len)))
      (fetch-elements (take fetch-len (lazy-shuffle-core s-lst len))))))

;; example
;; user> (lazy-shuffle (range 100) 10)
;; (29 85 4 52 47 42 95 37 71 90)

box muller / clojure

2011-05-10T17:47:00.011+09:00

久々にclojureを少しいじってみた。案外忘れてないもんだな。というのが率直な感想です。

これはbox-mullerという正規乱数を発生させるアルゴリズムでいくつかの細工をしています。box-mullerでは一度に２つの正規乱数を作ってしまうので、片方を捨ててつくり直すのは大変もったいないということで、残りは*rnorm-temp*変数に置いておくようにしています。(lazy-unit-nrand)もうひとつの工夫というのは、このプログラムでは、x ∈ [-1,1]の乱数の遅延シーケンスを作成して、そこから２つ取り出します。これを(x,y)点として、それが原点から半径１以内になるものを返すようにする。もし、範囲から外れたときは、一つだけ乱数を捨てて、その後に新たに乱数をひとつ作成させています。(two-randoms-within-clrcle)まだ、作りたてということもあってプレリミナリ版です。乱数は付属のものを使ってるけど、base-rand関数を改変すれば、他の乱数ジェネレータを代用することは簡単です。

このグラフは下のプログラムから２０００個の正規乱数(μ=0.0,σ=1.0)を可視化したものです。


;;; -*- Mode: Clojure; Coding: utf-8 -*-
;;;
;;; box-muller/src/core.clj - utilities for the box muller method
;;;
;;; Copyright (C) 2011 by Yasuto TAKENAKA 
;;; 
;;;                       Time-stamp: <2011-05-10 19:37:08 yasuto>
;;;                       License   : http://en.wikipedia.org/wiki/MIT_License
;;;
;;; This is a clojure script of the box-muller method, a manner of generating
;;; normal random numbers.
;;;
;;; CAUTION: This is a preliminary version and has not been tested sufficiently.
;;;

(ns box-muller.core
  (:use clojure.contrib.generic.math-functions))

(def *rnorm-temp* (ref '()))

;; base-rand requires the rand function of clojure. If you hope to use another 
;; random number generator instead of this standard one, you would rewrite
;; this 'base-rand' function.

(defn- base-rand []
  "generate a floting random number between -1.0 and 1.0."
  (- (rand 2.0) 1.0))

(defn- lazy-randoms []
  "generate a lazy random sequence."
  (lazy-seq
   (cons (base-rand) (lazy-randoms))))

(defn- sum-of-squares [^List points]
  (let [^Float x (first points)
 ^Float y (second points)]
    (+ (* x x) (* y y))))

;; The below function requires 'clojure.contrib.generic.math-functions' due to
;; using 'sqrt' and 'log'. It might be no problem to use 'Math/Sqrt' and 
;; 'Math/log' instead of these.

(defn- two-randoms-within-clrcle [rnd-list]
  (let [two-rands (take 2 rnd-list)
 sos (sum-of-squares rnd-list)]
      (if (<= sos 1.0)
 (map (fn [n] (* (sqrt (/ (* -2.0 (log sos)) sos)) n))
      two-rands)
 (recur (drop 1 rnd-list)))))

(defn lazy-unit-nrand []
  "generate a sequence of unit normal randoms with the mean of 0 and the
   standard deviation of 1."
  (lazy-seq
   (if (= @*rnorm-temp* '())
     (let [rands (two-randoms-within-clrcle (lazy-randoms))]
       (dosync (ref-set *rnorm-temp* (rest rands)))
       (cons (first rands) (lazy-unit-nrand)))
     (let [rdn (first @*rnorm-temp*)]
       (dosync (ref-set *rnorm-temp* '()))
       (cons rdn (lazy-unit-nrand))))))

(defn lazy-nrand [^Float mu ^Float sigma]
  "generate a lazy sequence of random normal numbers."
  (map (fn [^Float unr] (+ (* unr sigma) mu)) (lazy-unit-nrand)))

(defn unit-nrand []
  "return a unit random normal number."
  (first (lazy-unit-nrand)))

(defn nrand [^Float mu ^Float sigma]
  "generate a random normal number."
  (+ (* (first (lazy-unit-nrand)) sigma) mu))

;; examples
;;  > (unit-nrand)                   ; get a unit normal random number
;;  > (take 10 (lazy-nrand 0.0 1.0)) ; take ten of unit normal random numbers
;;  > (nrand 0.0 1.0)                ; get a unit normal random number

はじめに

2011-05-09T21:59:00.005+09:00

こちらは雑談系より技術的なログになる予定。

久々にclojureを触ったけど、新しい言語だけに環境の変化が非常に激しいですね。leiningenやcakeというプロジェクト作成支援のものも最近は確立されてきてるようでずいぶん使いやすさがよくなったようですね。

ウチの環境ではなぜかleiningenとemacs+slime環境で上手く動作をしてくれないらしい。たぶん、利用しているバージョンに関連する何かが影響しているようだし、そのうち解決策が出てくると思う。一方でcakeは上手く動いてくれている。こちらはバックグラウンドでプロジェクトを動かせるようにしていたり、プロセスの管理もできるようでいろんなプロジェクトを並行して作ってる人なら使いやすい環境なのではなかろうかと思いましたね。emacs+slime+cakeは上手く動いてくれるようで何かをするとなればこちらかなと思ってる。

当初は様々なことをCommon lispで行うことを前提で考えてきたけど、Common lispは便利なんですが、環境依存になりやすい所がOSによって使い辛いことがあったりしてこの点がちょっと残念なんですよね。そこでlisp系のclojureを意識をし始めたけど、こちらは変化がはやくってまだ枯れてない所が強みであり弱みかな。と感じてる。いざ活用をしようと考えたところで浦島になってしまう点がいいのか悪いのか？というところです。haskellも面白いな。とは思ってるんですが、こちらはさほど調べてるところまで行かない。作るなら美しく速くというコードが一番の理想なんだけど、さてどうなるやらね。

blogger.comもupdated editor (recommended) では上手く動かなかったのでold editorで記事を書いてます。ウチの環境はUbuntu 10.04LTS(64bit)で運用してるから、updatedはまだ未対応なのか？という影響があるんでしょうね。 Linux環境も大昔に比べればすごく良くなったな。と思う。CUIとGUIの使い分けが一番触りやすい環境です。

これは計算機関連の話かな。他はどうするかな。いずれにしても本館とは色合いを変えてみる予定です。自分を枠にはめずに書ければいいかな。狭いところに押し込めたところで自分らしさはなくなっちゃうし、それは避けたいと思う。