量子コンピュータの基礎数理：最初の無駄に長い線形代数とテンソル積の説明はいらんが、算数がだらだら書いてるだけなので、量子力学が簡単におもえていい。量子論の基礎と似た公理が最初にかいてある。

C++プログラミングの処方箋：こういう本は、内容を圧縮して1/3の厚さの本として出してほしいところ。文字でかいしぐだぐだ書きすぎ。

進化するWeb セマンティックWeb：よみ中だけど電波な香りがする。

今月のSofrwareDesign(1)のatomの記事とC-magazin(1)のCωの記事はよかった。

C++の設計と進化がまちどおしい。 監修者の紹介文によると、DBjの(!=djb)書きおろし神託付き。

教科書優先度低の マクスウェル理論の基礎はむずい。

なりゆきでゴジラとかAVPとか見にいった。そういえばハウルとか新海誠の新作とかもいった。

源泉徴収票って何？

源泉徴収税額表・月額表

年末調整で、12月の源泉徴収額分もどってきてないけど、これは来年の年末調整で調整するんかな。 その他税金関係複雑すぎなのはわかったから、プログラミング言語並の厳密さで、記号で処理の定義がかいてあったりするとわかりやすくていいと思うんだけど。

え？そんなことしたら税理士の仕事がなくなるって？

MFCは使う気おきないがこれならなんとか。

LCD-AD202GB

20.1UXGA液晶モニタ。今まで1024x769@15inchだったため世界変る。 meadowを開きつつPuttyを右に表示できるから、エラーメッセージよみながらコード修正とか、Ctl-x-3で画面分割とかできる。 でもVisualStudioだとOuputとか右のクラスビューとかで場所くうからもう少し大きいといいんだけども。

• ハッカーのたのしみ
• コンパイラI
• コンパイラII
• C言語による最新アルゴリズム事典
• 画像処理アルゴリズム 斎藤 恒雄

訳者の一人にすすめられて、ハッカーのたのしみ。コンパイラは2巻だけでいい気がするけど一応最初から目とおし中。 画像処理はCT再構成のところだけ。経済的面から優先度の引くかった辞書的な物を徐々に査収するキャンペーン実施中。

「ドミノカップ2004〜小学生が挑戦！ ドミノたおしスピード競争」

NHKにて。

★ルールはかんたん　ドミノたおし40m走！
　全国の小学生たちが挑戦するドミノたおしは、片道20m（往復40m）をいかにして速く倒しきるかという、ドミノ版40m走。ルールはいたってかんたん。
　・ドミノは何を使ってもOK！　枚数は自由
　・参加チームはクラス単位
　・途中で止まってしまったら失格
　・速く倒すためには、ドミノの間隔を狭くしたり、なが〜い下り坂を作ってその上にドミノを並べたり、重いドミノで軽いドミノを倒して加速したりと、アイデアは盛りだくさんである。
　どんな作戦を立てるのか？　クラスのみんなで考えて、目指せドミノたおし日本一！

T字型のドミノつかったり、やじろべえつかったりしてる。優勝チームは6秒あたり。ドミノなんでもいいなら40m棒つかって理論的には光の速度で伝搬。電磁気つかっていいらしいからそれでもOK。一定の長さを速く倒すという課題自体に意味がない。 できるだけ制限なく子供が自由に試行錯誤できるという設定はいい。でも、小学生はドミノの上に定規つけたりやじろべえを使ったりすると速くなるということを実験的に知って改良することはできるのに、それ以上の考察には頭がまわらずに、頭をつかった戦略性を感じられない。なぜT字型が速いのかを考えれば、すぐわかることなのに。

解が存在していて最適化問題でないため、試行錯誤自体に意味がない。この大会去年もやっていたけど、小学生の誰かが気づくまで続ける気なんだろうか。

ゆとり教育のいう考える力っていうのは例えばこういった試行錯誤から何かを本質的なことを得る力だと思うんだが、こんなゲーム設定する大会主催者もわけわかんないし、生徒が積極的に参加する形の総合的学習で考える力が育つというのも幻想であるか恐しく非効率に思える。

Java GenericsとC++ templateとの比較[豆蔵]

import Char(isSpace,isAlpha)

--Def: Lambda Term

data Variable = Var Char deriving(Eq)

data LambdaTerm = VT Variable
                | FuncAbs Variable LambdaTerm
                | FuncApp LambdaTerm LambdaTerm
                  deriving(Eq)

--show and read

instance Show Variable where
    showsPrec _ (Var c) = (c:)

instance Show LambdaTerm where
    showsPrec _ (VT var) = showsPrec 0 var
    showsPrec _ (FuncAbs var term) = ("(/"++) . showsPrec 0 var . ('.':) . showsPrec 0 term . (')':)
    showsPrec _ (FuncApp t0 t1) = ('(':) . showsPrec 0 t0 . showsPrec 0 t1 . (')':)

instance Read Variable where
    readsPrec _ [] = []
    readsPrec _ s = if isAlpha c then [(Var c,l)] else []
        where (c:l) = dropWhile isSpace s

instance Read LambdaTerm where
    readsPrec _ s = [(VT var,q) | (var,q) <- reads s]
                    ++
                    [(FuncAbs var term,q) |
                     ("(",l00) <- lex s,
                     ("/",l01) <- lex l00,
                     (var,l1) <- reads l01,
                     (".",l2) <- lex l1,
                     (term,l3) <- reads l2,
                     (")",q) <- lex l3]
                    ++
                    [(FuncApp t0 t1,q) |
                     ("(",l0) <- lex s,
                     (t0,l1) <- reads l0,
                     (t1,l2) <- reads l1,
                     (")",q) <- lex l2]


--for only reading omit format of lambda-term

data LambdaTermOmit = VTOmit Variable
                    | FuncAbsOmit [Variable] [LambdaTermOmit]
                    | FuncAppOmit [LambdaTermOmit]

instance Read LambdaTermOmit where
    readsPrec _ s = [(VTOmit x,q) | (x,q) <- reads s]
                    ++
                    [(FuncAbsOmit (x:xs) (t:ts),q) |
                     ("(",l0)  <- lex s,
                     ("/",l1)  <- lex l0,
                     (x,l2)    <- reads l1,  --needs at least one parameter
                     (xs,l3)   <- readlv l2,  --terminated by "."
                     (t,l4)    <- reads l3,
                     (ts,q)    <- readlt l4]  --terminated by ")"
                    ++
                    [(FuncAppOmit (x:y:xs),q) |
                     ("(",l0) <- lex s,
                     (x,l1)   <- reads l0,
                     (y,l2)   <- reads l1,
                     (xs,q)   <- readlt l2] --terminated by ")"
                    ++
                    [(lto,q) | 
                     ("(",l0)   <- lex s,
                     (lto,l1)   <- reads l0,
                     (")",q)    <- lex l1]
        where readlv s = [([],q)   | (".",q)<- lex s] ++
                         [(x:xs,q) | (x,l)  <- reads s,
                                     (xs,q) <- readlv l]
              readlt :: String -> [([LambdaTermOmit],String)]
              readlt s = [([],q)   | (")",q)<- lex s] ++
                         [(x:xs,q) | (x,l)  <- reads s,
                                     (xs,q) <- readlt l]

validLTomit :: LambdaTermOmit -> Bool
validLTomit (VTOmit var) = True
validLTomit (FuncAbsOmit vs l) = (and (map validLTomit l)) && unique vs
    where unique (x:xs) = (not(x `elem` xs)) && (unique xs)
          unique [] = True
validLTomit (FuncAppOmit p) = (and (map validLTomit p))


canonicalize :: LambdaTermOmit -> LambdaTerm
canonicalize (VTOmit var) = (VT var)
canonicalize (FuncAbsOmit (x:xs) ts) = (FuncAbs (x) (canonicalize(FuncAbsOmit xs ts))) 
canonicalize (FuncAbsOmit [] ts) = (canonicalize (FuncAppOmit ts))
--left associate
canonicalize (FuncAppOmit [x,y]) = FuncApp (canonicalize x) (canonicalize y)
canonicalize (FuncAppOmit []) = error "never come"
canonicalize (FuncAppOmit l) = canonicalize(la l)
    where la (x:y:xs) = la ((FuncAppOmit [x,y]):xs)
          la [x] = x


readLambdaTerm :: String -> LambdaTerm
readLambdaTerm s = if validLTomit o then canonicalize o else error "invalid FunctionalAbstruction"
    where o :: LambdaTermOmit
          o = read ("("++s++")")

--Def: FV (free variable), closed term

fv :: LambdaTerm -> [Variable]
fv (VT var) = [var]
fv (FuncApp t0 t1) = (fv t0)++(fv t1)
fv (FuncAbs x t) = filter (x/=) (fv t)

isClosedTerm t = (fv t)==[]

--Def: Leftmost Reduction

isBetaNormalForm :: LambdaTerm -> Bool
isBetaNormalForm (VT var) = True
isBetaNormalForm (FuncAbs x t) = False
isBetaNormalForm (FuncApp p q) = (isBetaNormalForm p) && (isBetaNormalForm q)


--betaRedexReduction :: FuncApp (FuncAbs Variable LambdaTerm) LambdaTerm -> LambdaTerm
betaRedexReduction :: LambdaTerm -> LambdaTerm
betaRedexReduction (FuncApp (FuncAbs x t) s) = replaceLT t x s
betaRedexReduction o = error "bad argument"

replaceLT :: LambdaTerm -> Variable -> LambdaTerm -> LambdaTerm
replaceLT s@(VT var) from to = if var==from then to else s
replaceLT (FuncAbs x t) from to = (FuncAbs x (if x==from then t else (replaceLT t from to))) --guards
replaceLT (FuncApp p q) from to = (FuncApp (replaceLT p from to) (replaceLT q from to))

leftmostReduction :: LambdaTerm -> LambdaTerm
leftmostReduction (VT var) = (VT var)
leftmostReduction (FuncAbs x t) = error "dont have beta-nf"
leftmostReduction b@(FuncApp (FuncAbs x t) s) = betaRedexReduction b
leftmostReduction a@(FuncApp p q) | haslambda p = FuncApp (leftmostReduction p) q
                                  | haslambda q = FuncApp p (leftmostReduction q)
                                  | otherwise = a
    where haslambda (VT var)=False
          haslambda (FuncAbs x t)=False
          haslambda (FuncApp (FuncAbs x t) q)=True
          haslambda (FuncApp p q) = (haslambda p) || (haslambda q)


associateFreeVariable :: LambdaTerm -> [(Variable,LambdaTerm)] -> LambdaTerm
associateFreeVariable t [] = t
associateFreeVariable t (y:ys)= associateFreeVariable (FuncApp (FuncAbs v t) l) ys
    where (v,l) = y


--main

readLT = readLambdaTerm
lmr = leftmostReduction
afv = associateFreeVariable

lmrloop l = if isBetaNormalForm l then l else lmrloop (lmr l)

lmrloopprint l = do
                 putStrLn(show(l))
                 if isBetaNormalForm l 
                    then return()
                    else lmrloopprint (lmr l)

main :: IO()
main = do
       lmrloopprint skkx
--       lmrloopprint ym
    where k = readLT "(/xy.x)"
          s = readLT "(/xyz.xz(yz))"
          skk = readLT "skk"
          skkx = FuncApp (afv skk [(Var 's',s),(Var 'k',k)]) (VT (Var 'x'))
          ym = readLT "(/y.(/x.y(xx))(/x.y(xx)))m"

らぶHaskell。これC++で書く気になれないなぁ。

lexのあやしい構文を使う時、haskell-modeが邪魔だ。

一応本に忠実。\lambdaのかわりに"/"、省略記法対応。 mainではSKKxを最左変換(leftmost reduction)してxがでてくる。

*Main> main
(((/k.((/s.((sk)k))(/x.(/y.(/z.((xz)(yz)))))))(/x.(/y.x)))x)
(((/s.((s(/x.(/y.x)))(/x.(/y.x))))(/x.(/y.(/z.((xz)(yz))))))x)
((((/x.(/y.(/z.((xz)(yz)))))(/x.(/y.x)))(/x.(/y.x)))x)
(((/y.(/z.(((/x.(/y.x))z)(yz))))(/x.(/y.x)))x)
((/z.(((/x.(/y.x))z)((/x.(/y.x))z)))x)
(((/x.(/y.x))x)((/x.(/y.x))x))
((/y.x)((/x.(/y.x))x))
x

haskellの本それなりにまとまってるんだけど、標準ライブラリについてはあまり書いてない。 Prelude他のソースはかなり参考になる。

最近やっとboost本を買った。どうせリファレンスならもっとでかくてもよかったと思ったが、リファレンスではないのか。

Python入門(O'Reilly)つうのも入手した。でも1/3ほど読んでpythonへの熱はさめた。

学校を出よう(6)が熱い。ハルヒのほうが売れてるみたいだけど。