パラメトロン計算機

除算サブルーチン

2012-01-26T20:10:00.001+09:00

パラメトロン計算機 PC-1 が完成し稼働し始めたのは, 1958年3月26日ということになっているが, この時は乗算も除算も出来なかった. その後, それらの回路を設計し, やがて乗算が付き, 夏頃には除算も出来るようになった.

イニシアルオーダーは十進二進変換もするが, その際の10倍に乗算を使わず, シフトしたり足したりしているのは, 当時, 乗算命令が未実装だったからである.

従って, 始めの頃は, 乗算や除算のサブルーチンが存在した. 私は数値計算には興味がないので, 除算は必要なく, 高橋先生が作られたはずの除算のサブルーチンがどうなっていたかは知らない. 先生のライブラリのファイルが手元に来たので, 除算サブルーチンを探したが, 見つからなかった.

ところで, PC-1がお手本にした, Cambridge大学のEDSACには, 最後まで除算はなく, サブルーチンを使っていた. そういえば, EDSACでは除算はどうやったか知りたくなり, 例のEDSACの本を見ると, 思いの他簡単であった.

a₀←被除数,
c₀←除数-1
と初期化し, 漸化式
a_k+1←-a_kc_k+a_k,
c_k+1←-c_k².
で繰り返すと, c_k=0の時, a_kが商になる.

これをそのままSchemeでプログラムにする.


(define (div n d) ;n 被除数 d 除数
 (define (dv a c)
  (display (list a c)) ;途中の様子を見る
  (if (< (abs c) 0.0001) a
   (dv (- a (* a c)) (- (* c c)))))
 (dv n (- d 1)))

PC-1もEDSACも当時の計算機は, -1≤n<1の固定小数点数しか扱わない. 利用者は, 計算がこの範囲になるよう, 絶えず位取りに注意する必要があった.

そこで, 上のサブルーチンを(div 0.4 0.8), (div 0.4 0.5)でやってみると,


> (div 0.4 0.8)
(.4 -.19999999999999996)
(.48 -.03999999999999998)
(.4992 -1.5999999999999983e-3)
(.49999871999999995 -2.5599999999999945e-6)
=> .49999871999999995

> (div 0.4 0.5)
(.4 -.5)
(.6000000000000001 -.25)
(.7500000000000001 -.0625)
(.7968750000000001 -.00390625)
(.7999877929687501 -.0000152587890625)
=> .7999877929687501

正しい商は, 0.5と0.8である. 目がちらちらするから, 途中のa_k, c_kを整数でシミュレートしてから同様な表にすると,


0.4/0.8
k a          c           delta
0 0.4        -0.2        0.1
1 0.48       -0.04       0.02
2 0.4992     -0.0016     0.0008
3 0.4999872  -0.00000256 0.0000128
4 0.49999999 -0.00000000 0.00000000
    99967232    00065536   00032768

0.4/0.5
k a          c           delta
0 0.4        -0.5        0.4
1 0.60       -0.25       0.2
2 0.7500     -0.0625     0.05
3 0.796875   -0.00390625 0.003125
4 0.79998779 -0.00001525 0.00001220
    296875      87890625   703125

左端のkはaとcの添字, 右端のdeltaは正確なn/dとa_kとの差である. 最後のk=4の行は長いので, 少数点以下8桁目で折り返してある.

こういうのの性質をしらべるには, 各回におけるinvariantを発見するのが常道である. ためつすがめつするまでもなく, この例ではcとdeltaには比例関係があることが分かる. つまり, 上の計算ではdelta/cは-1/2, 下のではdelta/cは-4/5, つまり除算の商の符号を変えたものであった.

すなわち, n/d=a_k-(n/d)*c_kということだ.

ここまで分かると, 次は帰納法で証明するだけである.

k=0の時

a₀-(n/d)*c₀=n-(n/d)*(d-1)=n/d.

k=kで

a_k-(n/d)*c_k=n/d

が成立しているとする. その時k+1の式は

a_k+1-(a/d)*c_k+1
=-a_kc_k+a_k-(n/d)*(-c_k²)
=-a_kc_k+a_k+(n/d)*c_k²
=c_k(a_k-(n/d)*c_k)+a_k
=a_k-(n/d)*c_k)=n/d.

やはり, n/dになる. 一方 c_kはどんどん小さくなっていくから, c_k=0の時, a_k→n/d.

そういう風にEDSACの除算サブルーチンは出来ていたのであった.

世界一周プログラム

2012-01-25T22:58:00.004+09:00

1月15日は私の恩師, 高橋秀俊先生の誕生日で, OBが先生のお宅に集まった. 先生が他界されたのは, 1985年だから, それから27年が経った. 成人の日は1月の第2月曜に変ったから, 15日ではなくなったが, 成人の日には今でもOBが某所に集まっている.

今回, その会で思わぬものを渡された. 高橋先生が東大にいらした頃の, パラメトロン計算機 PC-1 のライブラリのファイルである.

先生は1975年に東大を定年退官され, 慶応義塾大学へ移られた. 東大の教授室を後片付けした筑波大学の長谷部君が, そのファイルを見つけ, 自分の部屋で保管していたが, その長谷部君も定年になり, 筑波大学の教授室を片付けた. そしてそのファイルを私に委ねてきたのであった.

PC-1のライブラリを整備していた頃, 紙の質はまだ悪く, 日焼けで茶色になり, 縁もぼろぼろになってきた. 私が東大工学部にいた時, このままでは持たないと思って全部コピーしなおし, 製本した. その折, もう1部を作って高橋先生に差し上げたら大変喜ばれ, 「これを見ると, PC-1をやっていた頃が昨日のように思い出されます」という, 葉書の礼状を下さった.

先生がPC-1のライブラリファイルを, 東大に残していかれたとは, この正月まで知らなかった.

こうして手元にめぐってきたライブラリを見ると, 私の書いたイニシアルオーダーの前に, 先生が書かれたイニシアルオーダーがあった. 確かに1958年3月26日稼働開始の直後は先生のイニシアルオーダーが使われていたが, 長いし遅いので, 連休中に私が書き直したのが, その後1964年まで, 長く使われた.

先生のファイルには, "self reproducing program"もあった. これは計算機のメモリーをテストするため, 短いプログラムを走らせると, そのプログラムが自分を, アドレス部を修正しながら, 少し先のメモリーにコピーし, コピーが終わると, 新しい部分が走るようなものである.

Illinois大学のIlliac Iで使っていたと聞いていて, 高橋先生も書いてみられたのだろう.

Illiacのは, アドレス部がそれぞれその場所になっている, 2つのプログラムがあり, その差から新しいコピーを作っていると聞いたが, PC-1のは違っていた. (Illiacではこのプログラムをleapfrog(カエル跳び)と呼んでいたらしい.)

先生のスケッチは途中らしく, 正しくなさそうなので, 実際に使われていたプログラムを紹介しよう.

やはり, PC-1の命令から説明しなければなるまい. 1語は18ビットで, そのうち左端の6ビットが命令コード, 上のプログラムで, 各命令の先頭の"o"や"p"や"j"が入る. その右の1ビットが, l/sビットで, オペランドが長語(36ビット)か, 短語(18ビット)を区別し, 長語なら, 命令に"l"をつけ, そのビットが1になる. 残りの11ビットがアドレス部だが, PC-1は512語しかなかったので, 9ビットだけが必要, 上の2ビットは無視する.

0番地は"o"命令, outputの意味で, アキュムレータの左端の6ビットをテレタイプコードとして送り出す. アドレス部は, 命令の置いてある番地とすることになっているから, "0"である.

1番地は"p 16". "p"はpositive loadで, 16番地の短語をアキュムレータに取り出す. 従ってアキュムレータは, 16番地の命令"jl 17"になる.

2番地"jl"は, jump命令で, "j"の場合, lは長短ではなく, この場合は無条件ジャンプである. 従って, 3番地へ飛ぶ.

3番地"x 8"は, アキュムレータのアドレス部だけ, 8番地のアドレス部へ入れる命令. したがって, 8番地は "p 17"になる. 8番地のアドレスにかっこがついているのは, このアドレスは変更されるという意味である.

4番地の"a"はadd, 5番地の"s"はsubtractで, アキュムレータの"p 17"に, 16番地の"jl 17"を足し, 0番地の"o 0"を引く. 命令コード部も変るが今は関係なく, 17に17を足し0を引くから, アドレス部は17増えて34になり, 6番地, 7番地の"x"命令で, 9番地と12番地のアドレス部に入れられる.

このように, 定数を足すのにも, アドレス部は絶えず変るので, 定数を持っているわけにはいかず, 差を使う必要があった.

8番地に来て, "p 17", つまり"jl 3"をアキュムレータに持ってきて, それを9番地の"t", transfer命令で34番地にいれる. 10, 11番地は4, 5番地と同様で, アキュムレータのアドレス部を17増やし, 20にしてそれを34番地のアドレス部に入れる. 最終的に34番地は"jl 20"になる.

13番地は"p 8"だから, アキュムレータは"p 17"になる. 14, 15番地は, 14を足し, 15を引くから, 1引くことになり, アドレス部は16になり, 17番地へ飛び, さらに3番地へ飛ぶと, 今度は8番地, 9番地, 12番地のアドレス部がそれぞれ1減り, 16番地の"jl 17"が"jl 34"になって33番地に入る.

これを繰り返していると, やがて1番地の"p 16"が18番地に"p 33"として入り, 次のサイクルでは, "o 0"が"o 17"になって7番地の"jl 3"に上書きされる. コピーサイクルが17番地に到達した時点からコピーされたプログラムが走り出し, 同じことを繰り返すのである.

制御が新しいコピーに移ると, そこに出力命令があるので, プリンターが1文字打出す. つまりプリンターが文字を打ち続けている限り, メモリーは正常であるわけだ. 512/17=30だから, 30回のコピーでメモリーの始めに戻る. PC-1では, これを世界とみて, このプログラムを世界一周と呼んだ. 80日世界一周という映画があったから, ○○秒世界一周ともいったが, それが何秒だったかは, 残念ながら思い出せない.

素因数探し

2012-01-23T10:36:00.003+09:00

昔は計算機はなくても, 計算用の道具はいろいろあった. 12月3日のブログに書いたfactor stencilもそういうものの1つである. 竹内端三先生はfactor stencilを「因数型紙」と訳された.

Derrick Norman Lehmerがfactor stencilを作ったのは1925年頃のことである. それ以前, 1914年にLehmerは10006721までの素数表を完成し出版した. といってみるだけは簡単であるが, 665000個の素数があるわけで, (Legendreの素数定理で計算すると(define (pi x) (/ x (- (log x) 1.08366))) (pi 10006721) => 665556.99...) 1ページに5000個ずつ, 133ページに収められている.

その第1ページ目には48593までの素数が縦100行, 横50列に印刷してある. factor stencilはこの第1ページの素数の, それぞれのRに対応する位置に穴を開けて作られた. Lehmerの当時の寄書に, "The device for cutting the stencils is already constructed and..."とあるから, 何かの器具を工夫したのであろうが, 詳しいことは分からない.

かくして作られた初版のfactor stencilには, しかし誤りが多数あったようで, 1937年にMichigan大学のJ.D.Elderがそれらを指摘するとともに, そういうものを作るならHollerithカードで作るのはどうかと提案した. Hollerithカードは, 今から50年くらい前, FortranプログラムをパンチしたいわゆるIBMカードで, 20世紀の初めの頃のアメリカの国勢調査の集計用にHerman Hollerithが開発した. 統計機械で読むため, 穴の位置は正確であり, パンチ用の機械も沢山あったはずだ.

Lermerもその案に賛成し, Elderに多くのノウハウを提供した. そういう次第でHollerithカード版のfactor stencilが完成出版されたらしい. 1枚のHollerithカードの, 縦10行横80列の位置を使い, Lehmerの5000個の代りに, 7枚の組で5600個の素数を収めたという. これが完成する直前にLehmerは他界した.

Hollerithカードのfactor stencilがどのようなものであったかに私は興味を持った. Lehmer流に素数を1から始めると1枚目のカードの最後の800番目は6131であり, そこまでの素数について, R=-1とR=2(12月3日のブログの表の1行目と2行目


    3 5 7111317192329313741434753596167717379838997
-1    X     X X     X   X X     X   X     X     X X
 2      X     X   X   X   X   X         X X X   X X

)について, 多分このようであったろうと想像して描いてみたのが下の図だ.

IBMカードは昔のプログラマにはお馴染だが, 最近は見たこともない人が多かろう. この図のように, 横187ミリ, 縦83ミリ程度のカードで, 向きが分かるように, 隅に1ヶ所にコーナーカットがある. 下の拡大図で分かるように, 0から9の行番号は大きい数字で, 0から79の列番号は小さい数字で示す. 本来のIBMカードの列番号は1から80であり, 行は0の上にXとYとがある.

列0, 1の各行に対する素数は


     0  1  2  3  4  5  6  7  8  9
列0  1  2  3  5  7 11 13 17 19 23
列1 29 31 37 41 43 47 53 59 61 67

である. 列2以降に対しても, 素数表があれば, 穴の位置と素数は対応づけられる. 上の表と図の穴の位置とを較べてみて欲しい.

こういう絵を描くと, 実際に穴のあちあカードを作ってみたくなる. 鎌倉のFabLabの田中君と相談し, craftroboを使って試作したR=2のカードが下だ. まだ調整の必要があるらしく, うまく切れていない穴もあるが, 感触は得られた.

プログラムのカードと違い, 穴の数が多くてバイナリカードのようであり, 丁寧に扱わないとすぐに切れそうなのが心配だ. Edlerの作ったカードのセットはどこかに残っていないかしら.

中央値関数の排他的論理和

2011-12-27T22:51:00.004+09:00

TAOCPには面白い話が満載である. 今回は多数決関数関連の話だ. この本では, 多数決関数のことを中央値(median)関数というので, そう書くことにしよう.

中央値関数は, 奇数個の引数を大きさの順に並べ, その中央の値を返す(平均値でないことに注意).

x≤y≤zの時 <xyz>=y.

あるグループで流行っている最中限ゲームみたいなものである.

論理関数としては, x,yを偽か真とする時, 常に反対するか常に賛成する偽か真のサクラの入力を加え, <偽xy>がxとyの論理積, <真xy>が論理和である.

実数値については, <-∞xy>はxとyの最小値, <+∞xy>は最大値になる.

こういう話題がいちおう終わってから,

m>0について,
x₀⊕x₁⊕...⊕x_2m=<¬x₀s₁s₁...s_2m>
ここで, s_j=<x₀x_jx_j+1...x_j+m-1¬x_j+m¬x_j+m+1...¬x_j+2m-1>,
ただし, k≥1について, x_2m+k=x_kとする;

と書いてあった.

つまり, 何変数であっても, その排他的論理和がサクラ(定数)なしの2段の中央値関数で得られるのである. 美しい.

そもそも排他的論理和は単調関数ではないから, 中央値関数1段だけでは得られない. 3変数の排他的論理和, つまり全加算器もパラメトロンでは2段必要であった.

上の見事な式は, TAOCPによると, 量子化学が専門の佐々木不可止(ふかし)君が考えたという.

佐々木君は東大物理の学生時代に, 高橋研によく出入りしていて, 多数決論理に関心があったのは知っていたが, こういうことも考えたのかと驚いた. 北海道大学の化学科の教授を定年退職し, 苫小牧駒沢大学に移られたが, そこも退職の後, 惜しいことに2007年に他界された.

あの長々とした式は眼がくらくらするので, TAOCPにあったようにm=1とm=2について書き直すと

x₀⊕x₁⊕x₂=<¬x₀<x₀x₁¬x₂><x₀x₂¬x₁>>

x₀⊕...⊕x₄=<¬x₀<x₀x₁x₂¬x₃¬x₄><x₀x₂x₃¬x₄¬x₁><x₀x₃x₄¬x₁¬x₂><x₀x₄x₁¬x₂¬x₃>>

となる.

この式をテストしてみよう. ます多数決関数mを定義する. nは否定をとる関数.


(define (m . xs)
 (define (n x) (- 1 x))
 (let ((l (length xs)))
  (if (> (apply + xs) (/ (- l 1) 2)) 1 0)))
(m 1 0 0) => 0
(m 1 0 1) => 1
(m (n 1）(n 1) 1) => 0

すると5変数(m=2)の排他的論理和はこう書ける.


(define (ex x0 x1 x2 x3 x4)
 (let ((s1 (m x0 x1 x2 (n x3) (n x4)))
       (s2 (m x0 x2 x3 (n x4) (n x1)))
       (s3 (m x0 x3 x4 (n x1) (n x2)))
       (s4 (m x0 x4 x1 (n x2) (n x3))))
  (m (n x0) s1 s2 s3 s4)))
(map (lambda (x) (apply ex (n2bs x 5))) (a2b 0 32)) =>
(0 1 1 0 1 0 0 1 1 0 0 1 0 1 1 0 1 0 0 1 0 1 1 0 0 1 1 0 1 0 0 1)

でどうやらよさそうだ.

パラメトロンは通常3入力止りだが, 5入力が許されるとしてこの回路はこう描ける.

これをさらに納得すべく, s₁,...s₄や, その計算の元になっているx₁+x₂-x₃-x₄
などを, x₀=0である前半の16個について出力してみよう. 自己相対関数なので, 半分やればいいことになっている.

xの否定は1-xと計算し, (l-1)/2の2と比較したから, 閾値と較べる値は, 本来は
x₁+x₂+(1-x₃)+(1-x₄)=2+x₁+x₂-x₃-x₄.

従って, 先頭の2を外して,
x₁+x₂-x₃-x₄
の和sumについてs₁はsum≤0なら偽(x₀=0を除外したから, 等号が要る), sum>0なら真である.

s₁と添字がmだけ違うs₃は, 足す項と引く項がちょうど反対だから, 和も正負逆で同じ値になる. こういう対を相棒といおう. ところで, 真が奇数個だと, 和が0になることはないので, 相棒同士の真理値は反対になり, x₀がキャスティングボートをとって, exは真になる. すなわち排他的論理和である.

ところが, 真が偶数個だと, どこかに相棒同士で和が0になるものがあり, x₀は0だから, sは2つとも偽になる. 先頭の¬x₀が1を主張しても, 和が0でない他の相棒同士は打ち消し合い, この2個(あるいは4個)の0連合には勝てず, exは0になる.


   + s1 + s2 + s3 + s4 ex
0( 0 0  0 0  0 0  0 0  0)
1(-1 0 -1 0  1 1  1 1  1)
2(-1 0  1 1  1 1 -1 0  1)
3(-2 0  0 0  2 1  0 0  0)
4( 1 1  1 1 -1 0 -1 0  1)
5( 0 0  0 0  0 0  0 0  0)
6( 0 0  2 1  0 0 -2 0  0)
7(-1 0  1 1  1 1 -1 0  1)
8( 1 1 -1 0 -1 0  1 1  1)
9( 0 0 -2 0  0 0  2 1  0)
a( 0 0  0 0  0 0  0 0  0)
b(-1 0 -1 0  1 1  1 1  1)
c( 2 1  0 0 -2 0  0 0  0)
d( 1 1 -1 0 -1 0  1 1  1)
e( 1 1  1 1 -1 0 -1 0  1)
f( 0 0  0 0  0 0  0 0  0)

左端は行数である. 各行のかっこ内の9個の値は, 左からx₁+x₂-x₃-x₄, s₁, x₂+x₃-x₄-x₁, s₂, x₃+x₄-x₁-x₂, s₃, x₄+x₁-x₂-x₃, s₄, exである. 偶数個の場合, どの対で和が0になるかを調べたのが下だ. 赤の-は, x₁とx₂の和がx₃とx₄の和に等しい(つまりs₁s₃が0になる)場合, 青の-は, x₂とx₃の和がx₄とx₁の和に等しい(つまりs₂s₄が0になる)場合である.

0(0 0-0-0-0-) 1(0 0 0 0 1 ) 2(0 0 0 1 0 ) 3(0 0 0-1 1-) 4(0 0 1 0 0 ) 5(0 0-1-0-1-) 6(0 0-1 1-0 ) 7(0 0 1 1 1 ) 8(0 1 0 0 0 ) 9(0 1-0 0-1 ) a(0 1-0-1-0-) b(0 1 0 1 1 ) c(0 1 1-0 0-) d(0 1 1 0 1 ) e(0 1 1 1 0 ) f(0 1-1-1-1-)

和が0になる対は本当にあるか. こういう図を描いてみた.

いま真というか1の数は偶数である. s₁とs_m+1の範囲で1の数が同じであれば, 一発で和が同じところは見つかったわけでハッピーだ.

一方, s₁がオール0でs_m+1がオール1なら, 左の密度は0, 右の密度は1. そこで図の下へs₂, s₃のように加算の範囲をずらしていけば, どこかで2つの範囲の1の数が一致する, 同じ密度になる場所があり, そこで赤や青の-が引ける対が見つかるはずである(平均値の定理を習ったのは高校生の時だっけ).

こういうわけで, 偶数の場合はexが偽になるのである.

「なるほど」であった.

実はサクラを使うと, どんな関数でも2段の中央値関数で作れるが, そのことはいずれ.

平方根の連分数展開

2011-12-04T09:27:00.002+09:00

Norman Lehmerの論文に, factor stencilはNの連分数展開でも使えると書いてあった.

その始めの方. まずx₁=√N=q₁+1/x₂とおく. 但し, q₁はNの平方根の最大整数. 同様にx₂=(√N+P₂)/Q₂=q₂+1/x₃のようにする. (ははぁ. TAOCPの連分数展開のUとVがPとQになっているわけだ.)

順に進んで, x_n=(√N+P_n)/Q_n=q_n+1/x_n+1になるというまでは明快だが, その後に
「従って
P_n=q_n-1Q_n-1-P_n-1,
Q_n=q_n-1(P_n-1-P_n)+Q_n-2
がexpediouslyに得られる」
と書いてある.

上の方の式は11月30日のブログの(4)と(5)の間にあるU_n=A_nV_n-U_n-1と同じだが, 下の方の式はどう導くか.

今回のブログはその計算法である.

(0)はx_nの標準形である. (1)はx_n-1で, そのx_nに(0)を代入し, 前回のように計算を続けると(1)の最後になる. (1)の最初と分母を等しいとしたのが(2)で, ただちに(3)と書ける. 分子の√Nの後に続く項を等しいとしたのが(4)で, 途中で(3)を利用する. P_nとP_n-1を交換したのが上の式(5)だ.

一方, (3)の添字を1減らしたのが(6)で, (3)-(6)が(7),(8)である. 1/Q_n-1は, (5)を移項した(9)から(10)のように得られ, これを(8)に代入すると(11)を経て, 下の方の式(12)になるのが分かる.

漸化式はP₁=0, Q₁=1から始まるが, 問題は, Q_n-2があるので, Q₀が必要なことだ.

実はQ₀=Nなのだが, この計算は次の通り.

これで, 連分数のP,Q,qが次々と求まることになる. なんだかまた久しぶりにこのような計算をした.

素因数探し

2011-12-03T14:38:00.004+09:00

11月6日の本ブログにある自転車チェーンの篩を作ったのはHenry Lehmerだ. その父親のNorman LehmerもCalifornia大学Berkeley校の数学の教授であった. 父のLehmerが素因数探しの道具として, Factor Stencilを考案したという話がある.

それがどういうものかが分かってきた. 今回はその話をしよう.

aが素数pの平方剰余であるとは, x²=a mod pとなる何かのxがあることなのは周知のとおり. こういうa(≠0)の時, Legendreの記法で(a/p)=+1とする. (htmlなので, 分子分母が横並びだが, 通常は上下に書く.)

xがないときは, aを平方非剰余といい, (a/p)=-1とする.

p=7の時, 剰余は(0,1,2,4), 非剰余は(3,5,6)である. ここで, 0を除外し, 非剰余同士を掛けると, 3*3=2 mod 7, 3*5=1 mod 7, 5*5=4 mod 7のように剰余になり, 剰余と非剰余を掛けると2*3=6 mod 7のように非剰余のまま, 剰余同士を掛けると4*4=2 mod 7で剰余であり, +1と-1で掛算になる.

ところで, ある整数Nを素因数分解する場合, 任意の整数aについて, a²-N=Rは, Nがpで割れるなら, mod pで考えると, Nの項はないのと同じだから, Rはこのpの平方剰余になる.

aを√Nの程度にとると, Rは小さくなり, 平方剰余の乗算に規則でもっと分解すると, さらに小さい剰余か非剰余が得られ, それから素因数の形が決るという.

たとえば, 平方剰余に-1があるなら, すなわちp-1なら, 素因数は4n+1, 2があるなら, 素因数は8n±1の形, というふうに, 素因数はlinear formになっている. それを組み合せて, 素因数の探索の範囲を狭めたい. ところが, 平方剰余が段々大きくなってくると, linear formの形も複雑になり, 式の形を決めにくくなる. Normanの論文によると, Rが113と199の場合, formの形は11088にもなるそうだ.

そこで, 各平方剰余について, 候補になる素数の表をあらかじめ作っておこうというのが, この発想である.

小さい範囲で, テストしてみよう. 下がその剰余(縦方向)と素数(横方向)の表である. 10月26日のブログの図の素数のところを抜き出したものと思えばよい.


    3 5 7111317192329313741434753596167717379838997
-1    X     X X     X   X X     X   X     X     X X
 2      X     X   X   X   X   X         X X X   X X
 3        X X     X     X     X   X X   X X   X   X
 5        X     X   X X   X       X X   X   X   X
 7  X           X   X X X     X X X           X
11    X X       X       X   X   X           X X X X
13  X         X   X X       X   X   X       X
17          X   X           X X X X   X       X X
19  X X       X       X           X X X X X X

Normanの素数表には1があるというので, この左に1と2の列があるかも知れないが, 除数としては不要なので, とりあえず3からの表だ. 7の下を見ると, 2と11にXがあり, 2と11=4 mod 7が平方剰余であることを示す. 他の素数についても同じだ. たとえば,


(quadres 97)=>(0 1 2 3 4 6 8 9 11 12 16 18 22 24 25 27 31 32
 33 35 36 43 44 47 48 49 50 53 54 61 62 64 65 66 70 72 73 75
 79 81 85 86 88 89 91 93 94 95 96)

のうち, 19までの素数, 2,3,11と, 96(= -1 mod 97)があるから-1とにXがある.

また, 横向きに眺めると, -1の行は, 5,13,17,29,37,41,53,61,73,89,97で, すべて4n+1. 2の行の7,23,31,47,71,79は8n-1, 17,41,73,89,97は8n+1である.

さて, これを使い, N=2279(=43x53) の素因数を探してみる. (sqrt N) => 47.738873049120045 だから, aを48から順に増やしながら, a²-Nを計算し, その素因数分解もしておく.


 (map (lambda (a) (factorize (- (* a a) n))) (a2b 48 80))
=> ((5 5) (61 2) (17 13) (23 7 2) (17 5 5) (53 5 2) (13 7 7)
 (373 2) (857) (97 5 2) (31 7 5) (601 2) (1321) (103 7 2)
 (313 5) (13 13 5 2) (79 23) (139 7 2) (67 31) (17 13 5 2)
 (67 7 5) (73 17 2) (2621) (1381 2) (83 7 5) (61 5 5 2)
 (139 23) (239 7 2) (269 13) (73 5 5 2) (761 5) (283 7 2))

ここに並んでいるのは, 掛けると+1になるもの同士である. (5 5)からは, 5が+1かも, -1かも知れないということが分かるだけだ. (61 2)では, 61が上の表の剰余にないから, 無視. (17 13)は, とりあえず13と17は+1と+1か, -1と-1が分かっただけ. その次の(17 5 5)はラッキーだ. 5と5は打ち消すから, 17が+1と判明した. したがって, (17 13)から, 13も+1と決る.

(13 7 7)からも13が剰余と確信出来る. さらに進むと, (13 13 5 2)や(17 13 5 2)から, 2と5は+1同士か-1同士か, いずれにしろ同じ仲間ということが分かるが, 役にたつかどうかは不明.

しかし, 13と17が得られたので, 13と17の行にXのある素数を探すと, ブラボー! 43と53が見つかった. ついでだが, 43と53の列では, 2と5は空白で, 同じ組なことが示せる. いまは1組だけが見つかったが, 通常は候補がたくさん得られ, 実際に割ってみる必要がある.

Norman Lehmerが1914年に出版したFactor Stencilは, 剰余が±238まで, 素数が48593までの素数表であって, 各剰余ごとに1枚で, Xの代りに素数の位置に孔をあけてある. 今の例では13と17の紙を取り出してきて重ねると, 条件に合う素数のところから光が洩れる仕掛けであった. 当時としては大変な労作であった. いまでは, MacBookで簡単に実験が出来, ありがたい時代だ.

平方根の連分数展開

2011-11-30T20:26:00.003+09:00

TAOCPの第4.5.3項の演習問題12は, quadratic irrationalityという話題である. よく分からぬが, どうやら平方数でない整数の平方根の連分数展開をしているらしい.

そのアルゴリズムを, さっそくSchemeに書き直した.


(define (cf d n)
 (let* ((x (sqrt d)) (v 1)
   (a (inexact->exact (floor x))) (u a))
  (define (loop)
   (display (list 'v v 'a a 'u u)) (newline)
   (set! v (/ (- d (* u u)) v))
   (set! a (inexact->exact (floor (/ (+ x u) v))))
   (set! u (- (* a v) u))
   (set! n (- n 1))
   (if (> n 0) (loop) 'ok))
  (loop)))

関数cfは, dの平方根の連分数の部分商をn回計算するものである. 31の平方根は


(cf 31 13)
(v 1 a 5 u 5)
(v 6 a 1 u 1)
(v 5 a 1 u 4)
(v 3 a 3 u 5)
(v 2 a 5 u 5)
(v 3 a 3 u 4)
(v 5 a 1 u 1)
(v 6 a 1 u 5)
(v 1 a 10 u 5)
(v 6 a 1 u 1)
(v 5 a 1 u 4)
(v 3 a 3 u 5)
(v 2 a 5 u 5)

となる. このaの値の5,1,1,3,5,3,1,1,10,1,1,3,5が, √31の連分数の部分商である. √31=5+1/(1+1/(1+1/(3+1/(5+....)))).

アルゴリズムに戻って, 変数はv,a,uの3個(nは繰返し数). let*で設定するvの初期値は1, aは√dの整数部分, つまり最初の部分商, uもaであって,
v_n+1=(d-u_n²)/v_n,
a_n+1=floor((√d+u_n)/v_n+1),
u_n+1=a_n+1v_n+1-u_n
を繰り返す. aに√dがあるが, 整数部分をとるので下の方はいらない. vもuも整数のままで, 誤差が入らないから, いつまでも計算が続く.

この演習問題の次の設問は, ある回数から先は, 0<u_n<√d, 0<v_n<2√dを証明せよというのだ. 私は証明しようとも思わないが, そういうことはこの計算が周期的になるわけで, 平方根は無理数なのに, 連分数にすると繰り返すというのは面白い.

さて, このアルゴリズムは何をやっていたか調べてみる. √dをx₀, 最初の部分商をa₀とすると, (1)のように書ける. (TEXのプログラムでは, D,A,U,Vは大文字になっている.) ただし, u_-1, v₀は(0)のようだ. uの添字がvのより1だけ小さいのに注意. x=(√d+u)/vを各xの標準形とする.

(1)の添字をnだけ増やすと, 一般形x_nが(2)のように得られる. a_nを左辺に移すと, 1/x_n+1が(3)である. 上下を引っくり返せば(4)のx_n+1になるが, 分母に平方根があるので, 有理化し, 左上に√dが来るように, v_nで割る. これを(4)の最後のような標準形だと思うと, 対応する項から(5)の漸化式を得る. u_nを書いたら, 添字を1増やすとu_n+1が出来る. v_n+1も作れるが, u_nの式を入れると, vの漸化式になり, たしかにschemeで書いたプログラムが得られる.

というわけで, 今回もアルゴリズムが解明出来た.

素因数探し

2011-11-19T11:58:00.002+09:00

TAOCPの素因数探しの最初のアルゴリズム4.5.4Aは, 2,3,...と素数で次々を割ってみるやつだ.


A1. t←0, k←0, n←N.
A2. if n=1, 終了.
A3. q←floor(n/d_k), r←n mod d_k.
A4. if r≠0 →A6.
A5. t←t+1, p_t←d_k, n←q, →A2.
A6. if q>d_k, (k←k+1, →A3).
A7. t←t+1, p_t←n, 終了.

ここでd₀=2,d₁=3, ....は割ってみるべき, 次々の素数で, d₂=5の次は, 2,4,2,4,...と足していくという方法があるとこのアルゴリズムには書いてある. つまり, d=2,3,5,7,11,13,17,19,23,25,29,31,35,...とする. これをみると, 25,35以外は素数で, 一見うまく行きそうだが, 要するに2と3で割れない数を仮に素数としている. 多くの素数を記憶するわけにはいかぬので, 疑似素数列を生成するわけだ.

上のプログラムをSchemeでコーディングしてみる. p_tは素因数の列の配列なので, Schemeではリストpにする. A5とA7でtを1増やすのは, 配列pの添字を進めるので, リストではいらない. t←t+1, p_t←nは(set! p (cons n p))となる. kは約数の配列の添字だ. A6でkを増やすのは次の約数にするのだから, ここは(nextd)として, 後で考える.


 (define (a2) (if (= n 1) p (a3)))
 (define (a3) (set! q (quotient n d))
  (set! r (modulo n d)) (a4))
 (define (a4) (if (not (= r 0)) (a6) (a5)))
 (define (a5) (set! p (cons d p)) (set! n q) (a2))
 (define (a6) (if (> q d) (begin (nextd) (a3)) (a7)))
 (define (a7) (cons n p))

a4の(not (= r 0))は(> r 0)でよいが, その辺にはこだわらぬ. dは初期値を2とし, 1,2,2,4と順に足せば3,5,7,11が得られる. そこでこのリスト(1 2 2 4)の最後を(...2 _^ 2...)の間の ^ のところに繋げれば無限リスト(1 2 2 4 2 4 2 4 ...)が作れて, その後も2,4,2,4と足せるはずだ. このリストをddといおう. 次のようにして作る.


 (define dd '(1 2 2 4))
 (set-cdr! (list-tail dd 3) (cddr dd))

そうすれば, (nextd)は


 (define (nextd)
  (set! d (+ d (car dd))) (set! dd (cdr dd)))

でよい.
その上と下に


(define (algorithm454a n)
 (let ((p '()) (d 2) (q 0) (r 0))
と
 (a2)))

をつければ完成で, (algorithm454a 3628800)でよべば, (7 5 5 3 3 3 3 2 2 2 2 2 2 2 2)が得られる.

このプログラムでは, 1をfactorizeしようとすると, a2でいきなり止り, 空リストが返る. TAOCPを読み直すと, 「every positive integer n」は p_kを素数, p₁ ≤ p₂ ≤...≤ p_tとして,


n=p₁p₂...p_t

のように一意に表わせる. n=1の時はt=0で成り立つとあるので, 空リストは当然だ. n=0ならどうか. 0をpositive integerとするかどうかだが, 上のプログラムは止らない.

ところで, 50年も前, パラメトロン計算機でこういう計算をしたころ, 疑似素数列に現れる非素数を, 我々は臨時素数と呼んでいた.

2,4,2,4と足すということは, 6の幅の間に2つの数をテストするから, 疑似素数の全整数に対する頻度は1/3=0.333...である.

2と3と5で割れない疑似素数列なら, その頻度はどうなるか. TAOCPは, 計算時間は20%節約になると説明する.

0から2,3,5のLCM, 30の前までで, 29までで, 2でも3でも5でも割れない数は, 1,7,11,13,17,19,23,29の8個なので, 8/30=0.266... . これが1/3の何%かを計算すると, (8/30)/(1/3)=8/10だから, 計算時間は80%になり, 20%の節約になる.

ついでに, TAOCPに7までにすると, さらに14%節約とあるのを確認しよう.

2*3*5*7=210個のうち, 2でも3でも5でも7でも割れないものは,


(filter (lambda (n) (> (* (modulo n 2) (modulo n 3)
(modulo n 5) (modulo n 7)) 0))  (a2b 0 (* 2 3 5 7))) =>
(1 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79
83 89 97 101 103 107 109 113 121 127 131 137 139 143 149
151 157 163 167 169 173 179 181 187 191 193 197 199 209)

このリストのlengthは48なので, 頻度は48/210. (48/210)/(8/30)=6/7=0.857... これを0.86と思えばTAOCPのいうように節約は14%である.

ところで, 2でも3でも5でも割れない数は, 0から29までに8個あると上に述べた. 計算方法はこうだ. 0から29までの数を書き, 2で割れるもの, 3で割れるもの, 5でわれるものに印をつけると図のようになる.

2で割れる15個の数には赤線を引いた. 3の10個は緑で, 5の6個は青である. これらを30から引くと, 30 - 15 - 10 - 6=-1. 6や10のように2重線のものは, 2回引いたから, 実は引きすぎである. これは1回ずつ戻さなければならない. それは6で割れる0,6,12,18,24の(30/6=)5個, 10で割れる0,10,20の(30/10=)3個, 15で割れる0と15の(30/15=)2個で, -1+5+3+2=9になる. しかし, 0は今度は3回戻されてしまった. ここは本来は1回引く場所であるが, -3+3をやってしまった. そこで(30/30=)1回を引いて, 結局四角で囲んだ8個が残る.

こういう計算法をprinciple of inclusion and exclusionという. 日本語では包除原理とか和積の原理とかいうらしい.

この原理により, 2,3,5,7,11までの頻度を計算してみよう.


(define t (* 2 3 5 7 11))
t=>2310

(- t
(+ (/ t 2) (/ t 3) (/ t 5) (/ t 7) (/ t 11))
(- (+ (/ t 2 3) (/ t 2 5) (/ t 2 7) (/ t 2 11) (/ t 3 5)
      (/ t 3 7) (/ t 3 11) (/ t 5 7) (/ t 5 11) (/ t 7 11)))
(+ (/ t 2 3 5) (/ t 2 3 7) (/ t 2 3 11) (/ t 2 5 7)
   (/ t 2 5 11) (/ t 2 7 11) (/ t 3 5 7) (/ t 3 5 11)
   (/ t 3 7 11) (/ t 5 7 11))
(- (+ (/ t 2 3 5 7) (/ t 2 3 5 11) (/ t 2 3 7 11)
      (/ t 2 5 7 11) (/ t 3 5 7 11)))
(+ (/ t 2 3 5 7 11)))
=> 480

(/ 480 2310)=>16/17=.20779...

大体1/5である.

上に書いたSchemeのプログラムは, dやpの列をリストにした以外はTAOCPのプログラムの焼き直しである. もう少しSchemeらしくしたのが, 次のプログラムだ.


(define (factor n)
 (define dd '(1 2 2 4))
 (set-cdr! (list-tail dd 3) (cddr dd))
 (define (loop n d p)
  (define (nextd)
   (set! d (+ d (car dd))) (set! dd (cdr dd)))
  (define (next)
   (let ((q (quotient n d)))
    (cond ((= (modulo n d) 0) (loop q d (cons d p)))
          ((> q d) (nextd) (next))
          (else (cons n p)))))
  (if (= n 1) p (next)))
 (loop n 2 '()))

(map factor (a2b 1 30))
=> (() (2) (3) (2 2) (5) (3 2) (7) (2 2 2) (3 3) (5 2) (11)
(3 2 2) (13) (7 2) (5 3) (2 2 2 2) (17) (3 3 2) (19) (5 2 2)
(7 3) (11 2) (23) (3 2 2 2) (5 5) (13 2) (3 3 3) (7 2 2) (29))

プログラムは本質的にループだから, loopというプログラムを末尾再帰で呼ぶことにする. ある約数dで割れなければ, 次の約数を(nextd)で準備し, nextを呼ぶ. 素因数分解のたびにddを作り直すのも癪だが, そう長くはないから我慢する. さらに多くの素数の倍数をスキップするddの作り方については, またいつか書こう.

素因数探し

2011-11-07T10:46:00.001+09:00

昨日のブログ(篩を使った素因数探し)は, TAOCPのアルゴリズムを理解するのが目的であったので, 同書のアルゴリズムの特徴であるgoto文をそのまま反映していた.

しかし, もっとSchemeらしくするにはどうするか.

前のアルゴリズムでは, 絶えずmoduloを取っているのが問題であった. あのアルゴリズムでは, 篩が2重の配列になっているので, 添字を配列の範囲に収めるためにmoduloを取るのである.

しかし, Scheme風にすると, 配列はリストになり, リストとなれば, 自転車のチェーンのように無限リストが作れる.

すなわち, (define foo '(0 1 2 3)) と設定し(図の上), (set-cdr! (list-tail foo 3) foo)
とすると, (list-tail foo 3)でfooのcdrを3回とり, 3のセルに達する. そのcdrのnilをfooに書き換えると(図の下), 3の次が0になり, 無限ループが出来る.

第2の改良点は, 篩の要素を0と1にせず, #fと#tにする. そうするとandが一発でとれる. TAOCPでは[述語]というIverson blacketを多用していて, これは述語が真のとき1, 偽のとき0になるものなので, 前回のプログラムもそうなっていた. これを(1 1 1... 1)とequal?で真偽を判定した.

lispのandは先頭からみて, 偽をみつけると途端に終了するから, この方が早いのである.

第3は, 無限リストを次々とcdr downするのに, いちいち代入するのではなく, 引数として末尾再帰で渡すことである.

このようにして書直したのが, 次のプログラムである.


(define (algorithm454d n)
 (define (makesieve m n)
  (let* ((x (a2b 0 m))
    (x2 (map (lambda (a) (modulo (* a a) m)) x))
    (s (map (lambda (b)
     (if (member (modulo (- (* b b) n) m) x2) #t #f)) x)))
   (set-cdr! (list-tail s (- (length s) 1)) s)
  s))
 (define s3 (makesieve 3 n))
 (define s5 (makesieve 5 n))
 (define s7 (makesieve 7 n))
 (define s11 (makesieve 11 n))
 (define s13 (makesieve 13 n))
 (define s17 (makesieve 17 n))
 (define s19 (makesieve 19 n))
 (call-with-current-continuation
  (lambda (throw)
   (define (next x s3 s5 s7 s11 s13 s17 s19)
    (if (and (car s3) (car s5) (car s7) (car s11)
         (car s13) (car s17) (car s19))
     (let ((y (sqrt (- (* x x) n))))
      (if (integer? y) (throw (cons (+ x y) (- x y))))))
    (next (+ x 1) (cdr s3) (cdr s5) (cdr s7) (cdr s11)
      (cdr s13) (cdr s17) (cdr s19)))
   (let ((x (inexact->exact (ceiling (sqrt n)))))
    (next x
     (list-tail s3 (modulo x 3))
     (list-tail s5 (modulo x 5))
     (list-tail s7 (modulo x 7))
     (list-tail s11 (modulo x 11))
     (list-tail s13 (modulo x 13))
     (list-tail s17 (modulo x 17))
     (list-tail s19 (modulo x 19)))))))

解が見つかったとき, 脱出するのにcall-with-current-continuationを使っているが, これが結局一番簡単なようである.

引数をぞろぞろ引き摺っていくのは, 素数の個数を変更するのに困るわけだが, とりあえずはこれでさくさく動く.

篩全体をリストにするプログラムも書いてはみたが, mapをとったりするので, 上のプログラムより遅かった. プログラムを動的に生成するという考えもあるが, 分かり難くもなり, 今はためらっている.

素因数探し

2011-11-06T17:29:00.005+09:00

前回のブログはTAOCPのAlgorithm4.5.4Cが話題であった.

TAOCPのその次はAlgorithm4.5.4Dで, 篩を使うものである. 今回はその説明をしたい.

以下の例で, 素因数を探す数Nは, 23番のMersenne数M₂₃=2²³-1
=8388607=178481×47である. また, この方法では複数の素数を利用する. それに3,5,7,11を使おう.

TAOCPの説明の通りに進めると, まず下のような表を作る. 一番左が法にする素数mである. 次にその法に現れる数x, つまり0からm-1を書く. 更にその右は, xの自乗のmod mである. つまりmを法として, 自乗の数にはこれしか現れないことを確認する.

最後は0〜m-1のxについて, (x²-N)mod mを書く. この中で, 隣りの自乗の表にあるものだけが, 考慮に値するので, それを赤で示す. 例えばm=3だと, 2,0,0のうち, 自乗の表には0と1しかないので, 2は黒のまま, 0は赤にする. するとその2つの赤なので, xの1と2の場合に対応する.

m=5だと, 赤の位置, x=1か4ならよい.

上の表の最後の数列は,


(define n (- (expt 2 23) 1))
(map (lambda (m)
(let* ((x (a2b 0 m))
 (x2 (map (lambda (x) (modulo (* x x) m)) x))
 (s (map (lambda (x) (modulo (- (* x x) n) m)) x)))
(display (list x x2 s)))) '(3 5 7 11))

のように計算した.

このようにして, あるxについて, xがすべての素数の法で赤の位置に対応したとき, つまり, この表で篩われた時に, x²-Nがあるyの自乗かどうかを調べるのである.

TAOCPのアルゴリズムはごちゃごちゃしているが, わたし流にSchemeで書き直すとこうなる.


(define (algorithm454d n)
 (define (makesieve m n)
  (let* ((x (a2b 0 m)) 
   (x2 (map (lambda (a) (modulo (* a a) m)) x))
   (s (map (lambda (b) 
    (if (member (modulo (- (* b b) n) m) x2) 1 0)) x)))
   s))
 (define ms '(3 5 7 11 13 17 19))
 (define m1 (map (lambda (x) 1) ms)) ;ms length 1's
 (define ss (map (lambda (m) (makesieve m n)) ms))
 (display ss)
 (define x 0) (define ks '())

 (define (d1)
  (set! x (inexact->exact (ceiling (sqrt n)))) (display x)
  (set! ks (map (lambda (m) (modulo x m)) ms))
  (display ks) (d2))

 (define (d2)
  (if (equal? (map (lambda (s k) (list-ref s k)) ss ks) m1)
   (d4) (d3)))

 (define (d3)
  (set! x (+ x 1))
  (set! ks (map (lambda (k m) (modulo (+ k 1) m)) ks ms))
  (d2))

 (define (d4)
  (let* ((d (- (* x x) n)))
    (if (integer? (sqrt d)) (let ((y (sqrt d)))
        (list (+ x y) (- x y)))
        (d3))))
 (d1))

もう少しScheme風にも改良できそうだが, 今はこの辺で. 途中でss, xとksの初期値を出力している. それらは次の通りである.


ss=((0 1 1) (0 1 0 0 1) (1 0 1 0 0 1 0)
(1 1 0 0 1 0 0 1 0 0 1) (0 0 0 1 1 0 1 1 0 1 1 0 0)
(1 0 1 1 1 1 0 0 0 0 0 0 1 1 1 1 0)
(1 0 1 1 1 0 1 0 0 0 0 0 0 1 0 1 1 1 0))
x=2897
kx=(2 2 6 4 11 7 9)

TAOCPのアルゴリズムでは, kを(-x)mod mと計算しているが, 上の表から分かるように, 篩の値は, 0を除いて対称的なので, マイナスにする理由がなく, 私のアルゴリズムでは, x mod mで計算する.

素数をたくさん使うと, d4に来る回数が少なくなるのは当然である. ms=(3 5 7 11 13 17 19)だと523回だが, (3 5 7 11 13 17 19 23 29 31 37 41 43 47)では11回であった.

ところで, 1926年に, Henry Lehmerが自転車のチェーンをつかって篩を作った話は有名である. Mountain ViewのComputer History Museumにはその複製が展示されている.

小さい素数はチェーンが短いので, 何回か繰り返て実装されている. 篩われる数がチェーンの輪の上端に来ると, 設定してあるピンで回路が切れ, 回転が止る. つまり上のアルゴリズムのstep D4へ来る. 結果を調べ, 必要なら再起動するようになっていた.

上の例で, ピンがどうなっているかを示したのが次の図である.

篩のピンが対称的なのがよく分かるではないか.

素因数探し

2011-10-28T13:00:00.008+09:00

大きい数が素数かどうか知りたいことがある. 素数と分かればそれでよし. 素数でなければ, 素因数が知りたくなるのが人情だ. 素数であるかは素数性のテストがあるので, それによればよい. 素因数探しはそれに較べ困難である.

Knuth先生のTAOCP第2巻の4.5.4項は素因数に分解する話題である. 最初のアルゴリズム4.5.4Aは2,3,5,...と順に割ってみる方法である. 素数を全部覚えているわけにもいかぬから, 2,3,5のあとは4,2,4,2,...と足して疑似素数を発生する. この辺はもう少し凝れるが, とりあえずはここまで.

その後にあるアルゴリズム4.5.4Cはちょっと面白いので, 今回はその話にしよう. TAOCPによると, この方法は1643年にFermatが使ったものらしい.

分解したい奇数nが与えられた時, このアルゴリズムは下の図の左上のように, 正の整数aとbについて, a²の正方形からb²の正方形を引いた面積をnにするのである. 灰色の部分がnになる.

そういうaとbは, 右上の図のように, aとbの差が1の時, からなず存在する. その隙間の狭い面積をnにするのである. nは奇数だから出来るわけだ. つまりa=(n+1)/2, b=(n-1)/2とすると, a²-b²=(n²+2n+1)/2-(n²-2n+1)/2=4n/4=nである.

このようなaとbが分かれば, n=a²-b²=(a+b)(a-b)だから, a+bとa-bが素因数である. 2つの素因数の差は2b.

素因数がいくつもあると, aとbの組はいくつもあったりする. n=5005なら下の2つの図のように, 71²-6²も73²-18²も5005になる.

求め方はこうだ. 最初a=floor(√n), b=0とする. つまりa²がnに等しいか, ぎりぎりに近いが少し小さ目にする. そしてr=a²-b²を計算し, r<nならaを1増やす. r>nならbを1増やす. r=nならそのaとbが求めるものだ. 素因数を求めるのに割り算をしていない.

たとえばn=9なら, a=3, b=0で決まる. 素因数は3.

n=15ならa=3, b=0, r=9から始め, r<nだからaを4にする. するとr=16になり, r>nだから今度はbを1にする. するとr=15iになり, a=4, b=1に決まる. 素因数は5と3.

n=21ならa=4, b=0, r=16から始める. そろそろ面倒になってきたから, プログラムを書こう.


(define (fermat n)
 (define (try a b)
  (let ((r (- (* a a) (* b b))))
   (display (list a b r)) (newline) ;a,b,rを出力
   (cond ((< r n) (try (+ a 1) b))
         ((= r n) (cons (+ a b) (- a b))) ;素因数が決まる
         ((> r n) (try a (+ b 1))))))
 (try (inexact->exact (floor (sqrt n))) 0))

実行してみると


(fermat 21)
(4 0 16)
(5 0 25)
(5 1 24)
(5 2 21)
=>  (7 . 3)

上の図の下の左は


(fermat 5005)
(70 0 4900)
(71 0 5041)
(71 1 5040)
(71 2 5037)
(71 3 5032)
(71 4 5025)
(71 5 5016)
(71 6 5005)
=> (77 . 65)

これで分かるように, このアルゴリズムはaとbの差の大きい方の解を得る.

TAOCPのアルゴリズム4.5.4Cでは, rの計算を加減算だけで出来るように, うえのaとbの代りにx=2a+1, y=2b+1を使い, rもnと比較するのでなく,　r-nにして0と比較する.

こういうアルゴリズムだ.

C1 x←2(floor(√n)), y←1, r←floor(√n)²-n.
C2 if r=0,終了 n=((x-y)/2)((x+y-2)/2).
C3 r←r+x, x←x+2.
C4 r←r-y, y←y+2.
C5 if r>0 →C4, else →C2.

(TAOCP風の記述では, C2, C3のような各ステップの終わりに, 行き先(→)の指定がなければ, 次のステップへ進むことが了解されている.)

このプログラムの意外なのは, C2でr=0でなければxとyを増やしてしまう点だ.　xを増やした結果はr=0にならなず, r>0になるから, yも同時に増やしている.　n=19(素数)でトレースしてみる. 赤字のrはnより小さく, aを増やす時を示す.


(fermat 19)
(4 0 16)
(5 0 25)
(5 1 24)
(5 2 21)
(5 3 16)
(6 3 27)
(6 4 20)
(6 5 11)
(7 5 24)
(7 6 13)
(8 6 28)
(8 7 15)
(9 7 32)
(9 8 17)
(10 8 36)
(10 9 19)
=> (19 . 1)

nが平方数なら, n=9の例のように一発で決る. そうでないなら, aは√nより小さいからr<nになり, aを増やす. その後bを増やすとrは減って, nに等しくなるか(つまり停止するか), r<nになりaを増やす. 先ほどはr>nだったrからb²を引いてr<nになったところへ, bより大きいa²を足すのだから, b²を引くまえのrより大きくなり, r=nとなるはずはないのである. (上の結果の赤字の上下のrの値を見較べると, 下の方が大きいのが分かる.)

前のプログラムも


(define (fermat n)
 (define (try a b)
  (let ((r (- (* a a) (* b b))))
   (display (list a b r)) (newline) ;a,b,rを出力
   (cond ((< r n) (try (+ a 1) (+ b 1)))
         ((= r n) (cons (+ a b) (- a b))) ;素因数が決まる
         ((> r n) (try a (+ b 1))))))
 (try (inexact->exact (floor (sqrt n))) 0))

と改良できて,


(fermat 19)
(4 0 16)
(5 1 24)
(5 2 21)
(5 3 16)
(6 4 20)
(6 5 11)
(7 6 13)
(8 7 15)
(9 8 17)
(10 9 19)
=> (19 . 1)

たしかにこの方がスマートだ.

平方剰余

2011-10-26T20:45:00.003+09:00

MathworldのQuadratic Residueを見ると, 10月1日のブログUlam Spiralのような, なんやらフラクタル風の図がある. これもやはり自分でも描くべしと, 調べてみた.

Quadratic Residue, つまり平方剰余に興味を持つ人には時々出会う.

まずaがpの平方剰余であるとは, 0<x<pのxについて, x²=a (mod p)となるxがあることだ. 従って, この範囲のについて計算すると, たとえばp=10として


(define p 10)
(map (lambda (x) (modulo (* x x) p)) (a2b 1 p))
=>(1 4 9 6 5 6 9 4 1)

従って10に対しては, 1,4,5,6,9が平方剰余であり, ここに現れない2,3,7,8が平方非剰余(Quadratic Nonresidue)である. 上の計算で見る通り, 1からp-1のxに対して, 現れる平方剰余は対称なので, 真ん中まで計算すれば良い.

従って


(define (quadratic-residue p)
 (map (lambda (x) (modulo (* x x) p))
  (a2b 1 (+ (quotient p 2) 1))))

(quadratic-residue 10) => (1 4 9 6 5)
(quadratic-residue 11) => (1 4 9 5 3)
(quadratic-residue 12) => (1 4 9 4 1 0)
(quadratic-residue 13) => (1 4 9 3 12 10)

0は平方剰余と言わないらしいから, 0を除き, nubを使って重複を省き, 大きさの順にするには,


(define (quadratic-residue p)
 (sort (nub (filter (lambda (x) (> x 0))
  (map (lambda (x) (modulo (* x x) p))
   (a2b 1 (+ (quotient p 2) 1)))
   )) <))

(map (lambda (p) (quadratic-residue p)) (a2b 10 14))
=> ((1 4 5 6 9) (1 3 4 5 9) (1 4 9) (1 3 4 9 10 12))

これを見るとどれにも1,4,9があるが, xが1,2,3の時のもので当然だ.

そこで, p=2から40までの平方剰余を計算してみると


(for-each (lambda (p) (display p) 
 (display (quadratic-residue p)) (newline))
 (a2b 2 41))
=>
2(1)
3(1)
4(1)
5(1 4)
6(1 3 4)
7(1 2 4)
8(1 4)
9(1 4 7)
10(1 4 5 6 9)
11(1 3 4 5 9)
12(1 4 9)
13(1 3 4 9 10 12)
14(1 2 4 7 8 9 11)
15(1 4 6 9 10)
16(1 4 9)
17(1 2 4 8 9 13 15 16)
18(1 4 7 9 10 13 16)
19(1 4 5 6 7 9 11 16 17)
20(1 4 5 9 16)
21(1 4 7 9 15 16 18)
22(1 3 4 5 9 11 12 14 15 16 20)
23(1 2 3 4 6 8 9 12 13 16 18)
24(1 4 9 12 16)
25(1 4 6 9 11 14 16 19 21 24)
26(1 3 4 9 10 12 13 14 16 17 22 23 25)
27(1 4 7 9 10 13 16 19 22 25)
28(1 4 8 9 16 21 25)
29(1 4 5 6 7 9 13 16 20 22 23 24 25 28)
30(1 4 6 9 10 15 16 19 21 24 25)
31(1 2 4 5 7 8 9 10 14 16 18 19 20 25 28)
32(1 4 9 16 17 25)
33(1 3 4 9 12 15 16 22 25 27 31)
34(1 2 4 8 9 13 15 16 17 18 19 21 25 26 30 32 33)
35(1 4 9 11 14 15 16 21 25 29 30)
36(1 4 9 13 16 25 28)
37(1 3 4 7 9 10 11 12 16 21 25 26 27 28 30 33 34 36)
38(1 4 5 6 7 9 11 16 17 19 20 23 24 25 26 28 30 35 36)
39(1 3 4 9 10 12 13 16 22 25 27 30 36)
40(1 4 9 16 20 24 25 36)

これを使って描いたのが次の図である.

p=200までを描くと

これは, 最初に述べた, Mathworldにあった図と同じである.

PostScriptのプログラムは


40 40 translate
/d 2 def
/dot {2 dict begin /b exch def /a exch def a d mul
b d mul moveto d 0 rlineto 0 d rlineto d neg 0 rlineto
closepath fill end} def

1 1 200{/p exch def
1 1 p 1 sub{/x exch def
/a x x mul p mod def
a 0 gt {p a dot} if} for} for

のようになっている.

高さ1,4,9のような横線の他に, 右下がりの線も目立つ. つまり座標でいうと(5,4)(6,3)(7,2)(8,1)の線; (9,7)(10,6)(11,5)(12,4)(13,3)(14,2)(15,1)の線などだ. 最初の線はxとyの和が9, 次のでは和が16なのに気づく.

最初の(5,4)は, 5を法として, 4は平方剰余であるということだが, 4に法の5を足してみると9になり, 3掛ける3を5で割った余りが4なのである. その次の(6,3)は同じ9は6を法として3であるということで, この線は9を9未満の数で割った剰余の線. 次は16を16未満の数で割った剰余の線であった.

Ulam Spiral

2011-10-01T11:52:00.002+09:00

WikipediaにUlam Spiralという項目があった.

1から図のように螺旋状に自然数を配置し, それが素数ならその場所に点を打つというものである.

私は100万くらいまでの素数のビット表を持っているから, こういう図を再現するのは何でもない.

Wikipediaには縦横200ドットの図があるので, 同じものを書いてみた.

まったく同じ図が出来て安心する.

PostScriptのプログラムはこんな具合いだ.


/n 1 def /x 0 def /y 0 def /d 2.5 def /p 1 def
/q {n primep {x y dot}if /n n 1 add def} def
/x+ {q /x x d add def} def
/x- {q /x x d sub def} def
/y+ {q /y y d add def} def
/y- {q /y y d sub def} def
100 {
p {x+} repeat p {y+} repeat /p p 1 add def
p {x-} repeat p {y-} repeat /p p 1 add def} repeat

primepは引数nが素数なら真, 合成数なら偽を返す. dotはx, yに点を打つ.

再帰曲線

2011-09-25T11:18:00.002+09:00

このブログにdragon曲線のことを書いたのは, 2年以上も前であった.

dragon曲線は, 紙を同じ向きに半分半分と折り, 折り目を90度になるように広げたものであった.

最近, この折る向きを毎回逆にしたらどうなるかと思った. 紙を折ってやってみるのは, やはり3,4回が限度であり, 手元の計算機の威力を借りたくなった.

下の図を見て欲しい.

左端のAは折る前である. 下の黒丸は出発点を示す. その上の方に右向きの矢印が示すように, 最初は右に折る. するとBのようになる. 紙の長さが倍にになっているが, 今は折り方が問題なので, 分かりやすく描いてある.

出発点から途中右折したので, その角には+が付けてある.

Bを今度は左へ折る. 最初の折り目の+は左の下へ移動する. Cの出発点から辿ると, 最初は左折, 次がBで出来た右折, さらに右折する.

Cを次は右へ折るとDになる. 上の方の+や-は, 今回出来たのもで, 下の方のは左がCの下にあった折り目, 右がCの上にあったものだ.

出発点からの右折左折を抜き出すと

B +
C - + +
D + - - + + + -
この伝でつづけると次は
E - + + - - - + + - + + + - - +
となる.

一段上の列の要素を間に+と-を交互に入れたものになっているが, dragon曲線の場合と同じで, このパターンに着目する.

EをX₃, DをX₃とすると, X₃の左半分はX₂の+-を反対にしたものだ. 右半分は中央だけが違って右半分を殆んど同じである.

そこで, 'で+-の反転を表わすとすると,
X₃=X₂'+Y₂'.

結局
X₀=+, Y₀=-,
X_n=X_n-1'+Y_n-1',
Y_n=X_n-1'-Y_n-1'
となることが分かる.

Schemeでプログラムしてみる. この引数のnは上の漸化式の2^n-1になっている.


(define (r s) (if (eq? s '+) '- '+))

(define (x n i) (cond ((= i n) '+)
                      ((< i n) (r (x (/ n 2) i)))
                      ((> i n) (r (y (/ n 2) (- i n))))))
(define (y n i) (cond ((= i n) '-)
                      ((< i n) (r (x (/ n 2) i)))
                      ((> i n) (r (y (/ n 2) (- i n))))))

(map (lambda (i) (x 8 i)) (a2b 1 16))
=> (- + + - - - + + - + + + - - +)

これで右折左折の情報が得られたから, いよいよ交互折りの曲線を描くことする.

そして出来たのが次の図である. X₁からX₈までが, 色を変えながら描いてある. 左中ほど上の, 直角に下の曲がった青の線がB(X₁)である.

左から右向きに出発するのが, 出発点である. その下の緑の線がC(X₂)に対応する.

折角描いてみたが, 竜にも鳳凰にもならず, 単に三角形が出来ただけであった. 思うにdragon曲線を考えた人も, これもやっては見たが, つまらない結果だったので, このことは書いて置かなかったのかもしれない.

つまらない絵しか描けないことが分かっただけでも, 一応の知見が得られたというべきか.

整数立方根

2011-09-02T12:59:00.005+09:00

平方根に較べ, 立方根はおおいに疎外されている感があるが, 立方根を計算したいこともある.

その場合, 実用的には
(expt 9270 (/ 1 3)) => 21.00680051861007
なことで済ませてしまう.

さて, Warrenの「ハッカーの楽しみ」を眺めていたら, 整数立方根という話題があった(訳書の226ページ). こういうプログラムが書いてある(32ビット用だ).

同書の巻頭の「推薦の辞」に私が書いたように, 本書にはそのアルゴリズムでよい理由が殆んど書いてない.

このアルゴリズムは下の説明のように出来ているのだ.

例によってSchemeに書き直すと

最初のsの設定が30でなく18なのは, そんなに大きい数でテストすることもないからだ. また最後にyだけでなく, xも返すのは, 余りも欲しいからである.

途中の経過を見るdisplayが3行ある. 9270の立方根を計算してみる.

すなわち, 立方根は21で, 剰余が9. 整数の範囲で開立をやめ, 剰余が得られるから, 整数立方根というわけである. 同じものを十進法で書くと,

つまりbの始めの方は, xより小さくなるまで2¹⁸, 2¹⁵, 2¹²,... と減っていき, 4096がxより初めて小さくなった時点でyを1とする. yは最後は二進で10101だが, その最初の1(=2⁴)が決ったのである.

xの方はそれを引いて, 9270-4096=5174になった.

次はyのその下のビットを1にするか, 0にするかを決めることである. y=16の時, その下のビットは8だから(16+8)³=16³+3*16²*8+3*16*8²+8³=13824

しかし, 最初の4096はすでに引いてあるので, 比較するbは, 上の4段目の13824-4096=9728である. こうするよりは, y=2, (y+1)³-y³=3y(y+1)+1を作り, 左シフトする方が楽というのが, プログラムの趣旨であろう.

8のビットは立たなかった. 次は4のビットで, (16+4)³-16³=3904である. これはxより小さいからyは1増えて101になった.

このようにしてyのビットを上から次々を立てていき, 1ビットごとにきめていく. 最後に残ったxが開立の剰余である.

このプログラムの場合は, 方針は最初から見え見えであったが.

多面体描画道楽

2011-08-28T13:32:00.001+09:00

Archimedes多面体13種のうち, rhomb(斜方とか菱形)という形容詞のつくものが2つある. 斜方立方八面体と斜方二十十二面体である. 何ゆえに斜方といわれるのか.

これらの図に示すように, この2種類の多面体には, それぞれ3種類の面がある.

斜方立方八面体では, 青は元々の立方体の面, 緑は正八面体の面である. 斜方二十十二面体では, 青は元々の正十二面体の面, 緑は正二十面体の面である.

では, それぞれの赤の面はなにか.

赤の面を延長して, 緑の面の上方での交点を決め, 赤の正方形に外接する菱形を考えることが出来る. 赤は元々そういう面の多面体の面である.

この多面体がどちらも菱形になるので, 斜方といわれる所以である. つまり, 斜方(赤)立方(青)八(緑)面体, 斜方(赤)二十(緑)十二(青)面体という命名であったわけだ.

ではその斜方多面体を描いてみよう.

上は斜方立方八面体である. ｘ, y, zの対称軸も描いてある. z軸(青)のまわりに少し回転し, y軸(緑)のまわりにも僅かに回転したようになっている.

そのz軸, y軸まわりの回転をやめ, x軸方向から眺めたのが, この上の図だ. そこで, 最初の赤い正方形を含む面を考えてみると, この図の赤線で示す菱形が得られる. その座標が分かれば, 次の図が描けるわけだ.

これは, 対角線の比が1:√2の菱形が12個で構成されているので, 斜方十二面体(rhombic dodecahedron)という.

斜方二十十二面体の方は, 面が多いせいか, 多少手ごわい.

これが元の斜方二十十二面体で, 上と同様にz軸, y軸について回転してある.

回転角を0とし, x方向から眺めると, このように見えるはずだ. 赤線はそこにかぶせた菱形である. この方は, 菱形30枚で構成され, 斜方三十面体(triacontahedron)という.

菱形の対角線の比は1:φ(黄金比)である.

同一の菱形だけで出来る多面体はこの2つだけらしい. またKeplerはこの2つの多面体のあることを知っていたといわれる.

3シリンダ機関車

2011-08-27T13:13:00.002+09:00

ずいぶん前のこのブログに3シリンダ機関車のことを書いた. そこで引用しているURLが, 最近なくなっているのに気づいたので, もう一度3シリンダ機関車の弁装置について書くことにする.

今でも蒸気機関車は人気があり, 各地で復活されているが, その構造はあまり理解されていないに違いない.

簡単にいってしまえば, 機関車の左右の前方につけた2個のシリンダ(気筒)の中にピストンを入れ, ピストンの両側から交互に蒸気を補給してピストンを前後に動かす. ピストンの往復運動を主連棒で繋ぎ, 動輪を回転して機関車を進める. ピストンがどちらかの端に寄っていると, 蒸気の補給が出来ず, 死点といって力が出せないが, 反対側のピストンが最も力の出る中央にいるように, 左右のピストンの位相を90度づらせて配置してある. このことは, 鉄道博物館で実物の機関車を見ると確認出来る.

ピストンの前後に交互に蒸気の補給をしているのが, シリンダと並んだ蒸気室で, その中に滑り弁があり, これが蒸気室の中を前後に滑りながら, 蒸気をピストンの一方に送り込む.

Walschaertの走り装置の図はここにあるので参照されたい.

滑り弁は, 動輪に動力を伝える主連棒と90度づれたエキセン棒から, 逆転装置を経由した弁棒で押し引きされて運動する. この辺の装置は大変に込み入っているから, 説明は省略!

ところで, 表題の3シリンダ機関車は, 2つのシリンダでは力不足の時, 第3のシリンダを両シリンダの中央に搭載し, 合わせて3本の主連棒で動輪を駆動する方式である. 動輪軸の中央はクランク状になっていて, そこに中央の主連棒が接続されている.

問題は, 左右の動輪のエキセン棒のようなものが, 中央のクランクからも出ているかということだが, そういう複雑な走り装置にはなっておらず, 中央のシリンダの弁の制御は両側の弁の制御から構成していたというのが前回のブログであった.

下の図を見て欲しい. Cylinder AとCylinder Bと書いたのが, 両端のシリンダの蒸気室で, 左(機関車の後方)から弁棒が入り, 途中に滑り弁があり, 弁棒の延長が右方に突き出している. 機関車の先頭にAOD, BDCのような梃子があり, 支点AはCylinder Aの弁棒の先に, 支点BはCylinder Bの弁棒の先に固定されている. 梃子だから, 図で左右に揺れると支点の上下移動もあるはずだが, 今は各支点は左右にだけ動くとしている.

支点Oは固定点である. またOD=OA/2, つまりAが動くとDはAの半分の振幅で逆位相に動く. そのDを支点として, DB=DCの梃子があり, CがCylinder Cの弁棒になっている. そうすると, CはAとBが120度の位相差で動くと, さらに120度の位相差で動き, 3番目の滑り弁が望み通りに動くのである.

このアニメーションがここにある.

アニメの下でくるくる回る3芒星は, 120度の位相で回転することを示す.

ベクトルの和

2011-08-26T15:39:00.002+09:00

「とっておきの数学パズル」に, 多面体の各面の, 直交外向きで, 面積に比例する大きさのベクトルの和が0になることを証明せよというのがあった. Q5.13

多分そうなりそうだが, 証明となると....

「いかにして問題を解くか」には, 「一様な四面体の重心を求めよ」という問題が解けなければ, 平面の類似の問題「一様な三角形の重心を求めよ」を考えてみるという教訓がある.

その伝でいくなら, 多角形の各辺の, 直交外向きで, 辺の長さに比例する大きさのベクトルの和が0になることを証明せよとなる.

たとえば, 下の図の左は, 最も簡単な多角形の三角形の場合で, 辺の長さをa,b,cとする. (5:3:4になっている.) 従って, 外向きのベクトルは, 黒い矢印のように出来る. ベクトルの和を計算するのだから, aの先端までbの付け根を移動し(青矢印), その先端までcの付け根を移動する(青矢印)と, 3つのベクトルで構成される三角形は, もとの三角形と相似になり, cの先端はaの付け根に一致し, 和が0なことが分かる.

しかし, こういう方法はどうだろうか. (図の右)

元の三角形の左右方向をx軸. 上下方向をy軸とする. 各ベクトルのx, y成分を考える. bはx成分しか, cはy成分しか持たない. aは, 図にa_x, a_yと書いて示したx成分とｙ成分がある. ベクトルaの大きさが, 斜面aの長さに比例するなら, a_xはaの斜めの面の, x方向からみた断面(青線で示す)の長さに比例するわけで, この断面の長さはbの辺の長さに等しく, 従ってa_xの大きさはbの大きさを同じで方向が反対である.従って, ベクトルのx成分の和は0.

同様にして, y方向の成分の和も0. 従って, ベクトル全体の和も0になる.

これを3次元の問題でも使ってみよう. ある面の, その面積に比例した直交外向きベクトルaのx成分は, ベクトルとｘ軸のなす角をθとすると, a cosθ, この面のx方向から見た断面積もa cosθのはずである.

したがって, この多面体の直交外向きのベクトルのx+方向の和は, x+方向から見た断面積になり, x-方向の和は同じ断面積で反対向きになり, x方向全体は打ち消す.

y,z方向も同じわけだから, 結局和は0というので証明出来たのではないか.

ところで, ある時気づいた, 多面体を水の中に置くという考えも棄て難い. ある面に立てた, 面積に比例する直交外向きのベクトルは, その面に働く水圧に相当する. 水中の多面体が流れないのは, その水圧の総和が0だからだと思うと, この証明は終りらしいが.

3での整除

2011-08-12T20:51:00.007+09:00

TAOCPに, レジスタ上の64ビットの数が3で整除出来るかどうかの判定プログラムをMMIXで書けという問題7.1.3-215がある.

十進の場合, 各桁の和が3で整除出来るなら, 元の数も3で整除出来るのは知られている.

理由は1も10も100も..., つまり10ⁿが3を法として1であるからだ.

二進の場合も同様に考えられる. 二進の1, 10, 100,...は, 交互に3を法として1と-1だから, ビットに右から0,1,2,...と番号をつければ, 偶数番目の1の数と奇数番目の1の数の差が3の倍数の時に3で整除出来る.

これは十進法で11で整除出来る判定と同じだ. 3003や1023や5060は11で整除出来る.

だから, (nu x)をxの横方向の和をとる関数, (band x y)をxとyとのビットごとのandをとる関数とし, 32ビットでお許し頂くと

(= (modulo (- (nu (band x #x55555555)) (nu (band x #xaaaaaaaa))) 3) 0)

ということになる. 最後にまた3での剰余をとるのは違反っぽいが, 十進の場合の各桁の和の3の整除と同じで, 大きい数をいきなり割るのよりは簡単であり, とりあえずはこういう考えでよかろう.

この辺でTAOCPの解答をみると, 一見妙なプログラムである. MMIXのアセンブリコードに慣れていない向きには申し訳ないが, コメントをつけてある.

最後の3で割った剰余をみるのに, 001001...を左シフトし, 符号ビットが1になるのを利用している. これはうまい.

ではその前は何をしたか. レジスタ0は偶数ビットと奇数ビットの横方向の和(これをr0とする). レジスタ1は偶数ビットの横方向の和(r1とする). ところで, 奇数ビットの横方向の和(r2とする)も欲しい. r2=r0-r1のはず. レジスタ0はその後32-r0になり, 2ADDUでレジスタ1の2倍に足される.

つまりレジスタ1はr1+r1+(32-r0)=32+r1-r2になり, #x249...をこれだけ左シフトすることになる. bの定数は32ビット目, 8文字目の次が#x9なので, r1=r2のとき符号ビットが1, 負数になり, 3で整除出来ることが分かる.

巧妙なプログラムであった. 斯くの如きプログラムの解読は楽しい.

多面体描画道楽

2011-08-11T19:37:00.004+09:00

立方体は正方形6枚で出来ている. 正方形は1つの内角が90度. 従って正方形全体で内角の和は360度. それがF=6枚あるから, 2160度, つまり12π(パイ)になる.

一方頂点の数Vは8. それに対して内角の総和は(2V-4)π=12πという関係をEulerは知っていたらしい.

別の例. 正十二面体は正五角形がF=12枚. 頂点はHamilton世界巡礼でお馴染のV=20. 正五角形の内角は108度. 従って内角の総和は, 108*5*12=6480. 6480/180=36(π). 2V-4も36だ.

さらに2種類の面のある, 切頭二十面体(サッカーボール)は, 正五角形が12, 正六角形が20, 頂点は60. 内角の総和は, 108*5*12+120*6*20=20880, 20880/180=116. 2*60-4=116となる.

こう考えてみた.

Eulerの式に, 面の数F, 辺の数E, 頂点の数Vとすると, F+V=E+2という有名なのがある.

いま, ある多面体がn₁角形, n₂角形,...,n_F角形のFの面で出来ていたとする.

n角形の内角の和は(n-2)πであったから, 計算したい内角の総和Sは
S=(n₁-2)π+(n₂-2)π+...+(n_F-2)π=(n₁+n₂+...+n_F)π-2Fπ.

一方, この多面体の辺の数を計算すると, 各多角形の辺は2回ずつ寄与しているから, E=(n₁+n₂+...+n_F)/2.

従って, n₁+n₂+...+n_F=2E. これをSの式に入れると,

S=2Eπ-2Fπ. Eulerの式から, E-F=V-2.

ゆえにS=2(V-2)π.

なるほど.

また, Descartesの定理というのもある.

左下は, 正四面体の頂点は, 正三角形が3個集まっていて, その内角の和が, 360度より足りない度合い(deficiency)が180度であることを示す. 正四面体には頂点が4個あるから,deficiencyの総和は720度. 4πである.

これを他の正多面体でやって見ると, やはり, どれも720度になるのである.

サッカーボールではどうか.

この図のように, 120度, 120度, 108度に挟まれた角は12度. それが60個あるから, やはり720度である.

Eulerの方は, サッカーボールの図でいうと, 348度の方を総和している. 60倍すれば先ほどの20880度になる.

V個のradianで表わしたdeficiencyをd₁, d₂,...,d_Vとする.

Eulerの方の内角の和は, (2π-d₁)+(2π-d₂)+...(2π-d_V)
=2πV-(d₁+d₂+...+d_V) と足す.

これが2(V-2)πだったから, d₁+d₂+...+d_V=2πV-2(V-2)π=4π.

これもなるほどであった.

正多面体では, 面の数の順に正四面体, 立方体(正六面体), 正八面体, 正十二面体, 正二十面体と並べる. 正四面体の頂点は尖っているから, あとに行くほど丸くなるかと思うのは誤解であって, 正八面体も正二十面体も結構尖っている. それは正八面体は立方体より, 正二十面体は正十二面体よりも, deficiencyが大きく, 頂点の数が少ないためであろう.

サッカーボールがよく転がるのは, deficiencyが12度で, V=60もあるからである.

3つの円

2011-08-04T20:22:00.003+09:00

「とっておきの数学パズル」に, 「3つの円」という問題があった. 5.14

平面上で離れている, 半径の違う2つの円の, 円の間で交わらない(外側の)共通接線の交点を, それらの円の焦点という. 3つの円があると, 焦点は3個出来るわけだが, その3点は一直線上にあることを証明せよというのである.

こういう図で考えてみる.

円O₀は中心の座標をx₀,y₀, 半径をr₀, 円O₁は座標をx₁,y₁, 半径をr₁とする. また共通接線の1本と, 円との接点をT₀, T₁, 共通接線の交点P₀₁の座標を, x₀₁, y₀₁とする.

三角形O₀P₀₁T₀と三角形O₁P₀₁T₁とは相似で, 大きさの比はr₀ : r₁である. 従って
(x₀₁-x₀) : (x₀₁-x₁)=r₀ : r₁,   (y₀₁-y₀) : (y₀₁-y₁)=r₀ : r₁.

これから, x₀₁=(r₀x₁-r₁x₀)/(r₀-r₁),   y₀₁=(r₀y₁-r₁y₀)/(r₀-r₁).

x₁₂, y₁₂, x₂₀, y₂₀についても, 同様な式が得られる.

ここで, 3点(x₀,y₀), (x₁,y₁), (x₂,y₂)が一直線上にあることの検査は, このブログの2008年4月24日の「同一直線上の3点」にあるように, 3点で作る三角形の面積が0かどうかで判定出来る.

今回もP₀₁, P₁₂, P₂₀の三角形の面積を求めれば良い.

まず座標は
x₀₁=(r₀x₁-r₁x₀)/(r₀-r₁)
y₀₁=(r₀y₁-r₁y₀)/(r₀-r₁)
x₁₂=(r₁x₂-r₂x₁)/(r₁-r₂)
y₁₂=(r₁y₂-r₂y₁)/(r₁-r₂)
x₂₀=(r₂x₀-r₀x₂)/(r₂-r₀)
y₂₀=(r₂y₀-r₀y₂)/(r₂-r₀)
だから, 三角形の面積の2倍は
x₀₁y₁₂+x₁₂y₂₀+x₂₀y₀₁-x₁₂y₀₁-x₂₀y₁₂-x₀₁y₂₀

通分して分母を払い, 計算を続けると

  (r₀x₁-r₁x₀)(r₁y₂-r₂y₁)(r₂-r₀)+(r₁x₂-r₂x₁)(r₂y₀-r₀y₂)(r₀-r₁)
+(r₂x₀-r₀x₂)(r₀y₁-r₁y₀)(r₁-r₂)-(r₁x₂-r₂x₁)(r₀y₁-r₁y₀)(r₂-r₀)
-(r₂x₀-r₀x₂)(r₁y₂-r₂y₁)(r₀-r₁)-(r₀x₁-r₁x₀)(r₂y₀-r₀y₂)(r₁-r₂)

展開すると,
(r₀r₁x₁y₂-r₀r₂x₁y₁-r₁r₁x₀y₂+r₁r₂x₀y₁)(r₂-r₀)
+(r₁r₂x₂y₀-r₁r₀x₂y₂-r₂r₂x₁y₀+r₂r₀x₁y₂)(r₀-r₁)
+(r₂r₀x₀y₁-r₂r₁x₀y₀-r₀r₀x₂y₁+r₀r₁x₂y₀)(r₁-r₂)
-(r₁r₀x₂y₁-r₁r₁x₂y₀-r₂r₀x₁y₁+r₂r₁x₁y₀)(r₂-r₀)
-(r₂r₁x₀y₂-r₂r₂x₀y₁-r₀r₁x₂y₂+r₀r₂x₂y₁)(r₀-r₁)
-(r₀r₂x₁y₀-r₀r₀x₁y₂-r₁r₂x₀y₀+r₁r₀x₀y₂)(r₁-r₂)

さらに展開する.
+r₀r₁r₂x₁y₂-r₀r₂r₂x₁y₁-r₁r₁r₂x₀y₂+r₁r₂r₂x₀y₁
-r₀r₀r₁x₁y₂+r₀r₀r₂x₁y₁+r₀r₁r₁x₀y₂-r₀r₁r₂x₀y₁
+r₀r₁r₂x₂y₀-r₀r₀r₁x₂y₂-r₀r₂r₂x₁y₀+r₀r₀r₂x₁y₂
-r₁r₁r₂x₂y₀+r₀r₁r₁x₂y₂+r₁r₂r₂x₁y₀-r₀r₁r₂x₁y₂
+r₀r₁r₂x₀y₁-r₁r₁r₂x₀y₀-r₀r₀r₁x₂y₁+r₀r₁r₁x₂y₀
-r₀r₂r₂x₀y₁+r₁r₂r₂x₀y₀+r₀r₀r₂x₂y₁-r₀r₁r₂x₂y₀
-r₀r₁r₂x₂y₁+r₁r₁r₂x₂y₀+r₀r₂r₂x₁y₁-r₁r₂r₂x₁y₀
+r₀r₀r₁x₂y₁-r₀r₁r₁x₂y₀-r₀r₀r₂x₁y₁+r₀r₁r₂x₁y₀
-r₀r₁r₂x₀y₂+r₀r₂r₂x₀y₁+r₀r₀r₁x₂y₂-r₀r₀r₂x₂y₁
+r₁r₁r₂x₀y₂-r₁r₂r₂x₀y₁-r₀r₁r₁x₂y₂+r₀r₁r₂x₂y₁
-r₀r₁r₂x₁y₀+r₀r₀r₁x₁y₂+r₁r₁r₂x₀y₀-r₀r₁r₁x₀y₂
+r₀r₂r₂x₁y₀-r₀r₀r₂x₁y₂-r₁r₂r₂x₀y₀+r₀r₁r₂x₀y₂

同じrの項をまとめると,
r₀r₀r₁(-x₁y₂-x₂y₂-x₂y₁+x₂y₁+x₂y₂+x₁y₂)
r₀r₀r₂(+x₁y₁+x₁y₂+x₂y₁-x₁y₁-x₂y₁-x₁y₂)
r₀r₁r₁(+x₀y₂+x₂y₂+x₂y₀-x₂y₀-x₂y₂-x₀y₂)
r₀r₂r₂(-x₁y₁-x₁y₀-x₀y₁+x₁y₁+x₀y₁+x₁y₀)
r₁r₁r₂(-x₀y₂-x₂y₀-x₀y₀+x₂y₀+x₀y₂+x₀y₀)
r₁r₂r₂(+x₀y₁+x₁y₀+x₀y₀-x₁y₀-x₀y₁-x₀y₀)
r₀r₁r₂(+x₁y₂-x₀y₁+x₂y₀-x₁y₂+x₀y₁-x₂y₀
  -x₂y₁+x₁y₀-x₀y₂+x₂y₁-x₁y₀+x₀y₂)

となり, かっこ内はプラスマイナス打ち消し, めでたく0になった.

実際に上のように書いて計算したわけではない. 変数の順を覚えておき, 引数だけを使って計算した. 最後に, ブログ用に変数名を追加するには, utilispのプログラムを書いて実行した.

ところで, 数式処理システムrisa/asirを使ってみたら,

X01=(r0*x1-r1*x0)/(r0-r1);
X12=(r1*x2-r2*x1)/(r1-r2);
X20=(r2*x0-r0*x2)/(r2-r0);

Y01=(r0*y1-r1*y0)/(r0-r1);
Y12=(r1*y2-r2*y1)/(r1-r2);
Y20=(r2*y0-r0*y2)/(r2-r0);

X01*Y12+X12*Y20+X20*Y01-X12*Y01-X20*Y12-X01*Y20;

を入力すると, 瞬時に0が返り, 安堵する.

さて, 例によって, 幾何学的に証明できないかと考える. 幾何の証明で大切なのは, 図をなるべく正確に描くことだ. 幸い, このブログの最初の図を描いたPostScriptのプログラムがあるから, それを多少修正すると以下の図が得られる.

今度は3つの円O₀, O₁, O₂の中心をA, B, Cとしている. また, 焦点をE, F, Gとした. BからEFに平行線を引き, AFとの交点をDとする.

円の中心O₀, O₁と焦点P₀₁の距離の比は, 半径r₀, r₁の比であった.

EはA,Bの焦点だから, BE/AE=r₁/r₀
FはA,Cの焦点だから, CF/AF=r₂/r₀

BD//EFにしたから, DF/AF=r₁/r₀
従って, CF/DF==r₂/r₁

また, GがB,Cの焦点だから, CF/DR=r₂/r₁=CG/GB
従って, FG//BD//EF

QED.

この方が楽だなぁ.

条件付きの倍数

2011-08-02T21:06:00.005+09:00

三角関数表, 対数表をはじめとして, 数表の存在感の薄い昨今である. なにしろ手元の計算機で関数値が一発で計算出来る世の中だからだ. だが今でも, 理科年表には, 10.0から100.9までの四桁の対数表があり, なんとなく空しい.

計算機が手元にない, 古き良き時代には, 数表は重要であった. Charles Babbageが階差機関を考案したのも, 数表を自動作成したいからであった.

江戸時代に歩いて日本地図を作成した伊能忠敬に関連した展示会にいってみると, 漢数字で書かれた各種の数表も並べられていて, そんな昔から数表が使われていたことに驚く.

ところで対数表の話だ. 高木先生の解析概論には気になる脚注がある. 「Wolframノ表ニハ1000以下ノ素数ノ自然対数ノ50桁ノ表ガ掲ゲラレテヰル. コノ表ハ既ニ少年がうすガ愛用シタモノデアル. 」だ.

なるほど, ある数の対数は, その素因数の対数の和なので, 素数の対数表だけあれば充分なのであった. しかし50桁も足すのは大変であったろう. また常用対数に変換するには, ln 10で割らなければならず, これも一仕事であるが, 昔の人は計算は得意であったからだとまずは納得する.

常用対数表は, スコットランド人のJohn Napierが1614年に作成, 出版したといわれている. そこで, 2014年に, 出版400年を記念してエディンバラで会合を開こうという話が進んでいる.

Napierの後, 何人もが常用対数表を計算し, 刊行したが, 先頃, Edward Sangの対数表の話をウェブで見つけた. Sangは1875年に, 素数について28桁の常用対数表を完成させた. その計算方法は次のようだ.

小さい素数の方から順に計算していく. さて, 素数1619の常用対数を計算するには, その1619を何倍かし, 下の方の桁を...999999のようにする. 9は何桁でもよいが, 多い方がよい. 例えば

714021*1619=1155999999

を作る. この計算が, このブログのタイトルの, ...9999で終るという「条件付きの倍数」である.

この倍数の作り方は次の通り.

まず1619の1から9までの倍数表を用意する.


(map (lambda (x) (display (list x (* x 1619))) (newline))
 (a2b 1 10))
(1 1619)
(2 3238)
(3 4857)
(4 6476)
(5 8095)
(6 9714)
(7 11333)
(8 12952)
(9 14571)

被乗数が2と5以外の素数だから, 最後の桁には1から9が出揃う.

次にこの表を見ながら, 下の桁から積の各桁が9になるように1619の倍数を足していく. まず1倍の1619が9で終るから, 1619と書く. 下から2桁目は, 1だから, 最後が8で終る倍数, 3238をそこに足す. すると33999になる. 4桁目は3だから, 最後が6で終る倍数, 6476を足す. 今度は6509になる. 0のところを9にしなければならにから, 9で終る1619をもう一度足す. 2269になる. 6のところを9にするので, 11333を足す. こうしてここまでで1155999999が得られる.


      1619       1
     3238       2
----------
     33999
   6476       40
   ----
   6509
  1619       1
  -----
  2269
11333       7
-----
11559

この数を素因数分解すると, 1155999999=3×7×11×11×281×1619 である. いま常用対数を求めようとしている1619以外の素因数は, すべてこれより小さいから, それらの常用対数は分かっているはずだ.

従って, 1155999999の常用対数が得られれば, 1619の常用対数は,
log 1619=log 1155999999 - log 3 - log 7 - log 11 - log 11 - log 281
で得られるわけである.

ところで, log 1155999999=log(1156×10⁶-1).
1156=17×17×2×2だから, この常用対数は既知である.

一方, x=1/(1156×10⁶)とおいて,

log(1156×10⁶-1)=log(1156×10⁶×(1-x))=log(1156×10⁶)+log(1-x).

自然対数をlnと書くと, ln(1+x)のTaylor展開は

ln(1+x)=x-x²/2+x³/3-x⁴/4+... (|x|≤1, x≠-1)

だったから,

log(1-x)=ln(1-x)/ln 10=(-x-x²/2-x³/3-x⁴/4-...)/ln 10

Schemeで計算してみよう. Schemeのlog関数は自然対数lnのことである.

(define x (/ 1. (* 1156 1000000)))

x=>8.650519031141868e-10

(/ (* x x) 2)=>3.741573975407383e-19

(/ (* x x x) 3)=>2.157770458712447e-28

(log 10)=>2.302585092994046

常用対数のlog 1156×10⁶ は

(/ (log (* 1156 (expt 10 6))) (log 10))=>9.06295783408451

従って log 11559999として

(- 9.06295783408451
(/ (+ x (/ (* x x) 2) (/ (* x x x) 3)) 2.302585092994046))
=> 9.062957833708824

が得られる. そこでlog 1619は

(- 9.062957833708824
(/ (+ (log 3) (log 7) (log 11) (log 11) (log 281)) (log 10)))
=>3.2092468487533754

log 1619をSchemeで直接計算すると

(/ (log 1619) (log 10)) => 3.2092468487533736

最後の2桁が違うがまぁよかろう.

こんな数値計算をするもの久しぶりだ.

条件付きの倍数

2011-07-30T10:31:00.003+09:00

「とっておきの数学パズル」に0,1,2という問題があった. 2.2

「十進表記で0と1のみからなる自然数nの0でない倍数が存在する」というのである.

計算してみると0から9のnについて, 次のようになる. つまり3は37倍すると1だけの十進数111となる.


n       倍  十進表記
0        1         0
1        1         1
2        5        10
3       37       111
4       25       100
5        2        10
6      185      1110
7      143      1001
8      125      1000
9 12345679 111111111

この9の場合はタイガー計算器でよく遊んだ計算である.

十進表記の求め方を考えてみた. %で剰余を表すと, 3の場合は, 1%3=1, 10%3=1, 100%3=1だから, 111ではその和が3, つまり剰余が0, よって111は3の倍数である.

7の場合は, 1%7=1, 10%7=3, 100%7=2, 1000%7=6だから, 和が7の倍数になるように1と1000を選び, 1001が7の倍数となるわけだ.

そこで早速プログラムを考えてみる.

10のべきをnで割った剰余のべき集合の和のnによる剰余が0のものを求めたい.

まず(0)なるリストを用意する. これは空のべき集合である. 次に10の0乗, 1をnで割った剰余1を, これまでのリストの各要素に足し, (1)が出来, これを(0)の前にappendする. (1 0)が出来る.

次は10の1乗, 10をnで割った剰余を, これまでのリストの各要素に足す. nが7なら, 剰余3を足し, (4 3)が出来る. appendすると(4 3 1 0)になる. それぞれ(11 10 1 0)を7で割った剰余である.

同様に100を7で割った剰余2を足すと(6 5 3 2)が出来, appendして(6 5 3 2 4 3 1 0)になる. この段階では, 最後の0以外に7の倍数はないので, まだ続ける.

1000でやると剰余は10の時の剰余3と100の時の剰余2の積で6. よって新しいリストは(12 11 9 8 10 9 7 6)となり, べき集合に7の倍数7が現れた.

7は新しいリストにあるから1000番台は1, リストの右半分にあるから, 100番台は0, そのまた右半分にあるから, 10番台も0, その(7 0)では左にあるから, 1番台は1で, 結局1001が7の0と1による倍数(の最小のもの)であった.

Schemeのプログラムは次のとおり.


(define (zeroone n e rs)
 (let* ((r (modulo e n))
  (rs1 (map (lambda (x) (modulo (+ x r) n)) rs)))
  (if (member 0 rs1)
   (- (length (member 0 (append rs1 rs))) 1)
   (zeroone n (* e 10) (append rs1 rs)))))

引数のeは10の順次のべきで, 最初の起動では1, rsはリストで最初は(0). let*で用意するrはこの桁の剰余, rs1は新しいリストである. let*の後の本体のifは, 新しいリストに0があるかを見, あればその位置を返す. なければ次の桁へ進む.

起動は次のようにする.


(zeroone 13 1 '(0))

9が結果の値だが, これを二進で1001としたのが求める十進表記になる. n=2から20までの値は


(map (lambda (x) (zeroone x 1 '(0))) (a2b 2 21)) =>
 (2 7 4 2 14 9 8 511 2 3 28 9 18 14 16 29 1022 25 4)

二進で示すと


(map (lambda (x) (number->string (zeroone x 1 '(0)) 2))
 (a2b 2 21)) =>
 ("10" "111" "100" "10" "1110" "1001" "1000" "111111111"
  "10" "11" "11100" "1001" "10010" "1110" "10000" "11101"
  "1111111110" "11001" "100")

ところでこういう倍数が存在する理由はなにか. 10のべきをnで割った剰余を表示してみると:


(define (foo n)
 (map (lambda (x) (modulo (expt 10 x) n)) (a2b 0 20)))

(foo 2) =>
 (1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
(foo 3) =>
 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)
(foo 4) =>
 (1 2 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
(foo 5) =>
 (1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
(foo 6) =>
 (1 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4)
(foo 7) =>
 (1 3 2 6 4 5 1 3 2 6 4 5 1 3 2 6 4 5 1 3)
(foo 8) =>
 (1 2 4 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)
(foo 9) =>
 (1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)

のようで, 0があるものはその桁を1つとれば完成. 0がないものは剰余だから当然同じ数が何回も現れる. その桁をn個足せば当然nの倍数が得られるわけだ.

面白い問題であった. ところでこういう条件付き倍数の生成を対数表の計算で利用した人がいた. Edward Sangのその話は次回に.

板チョコ分割

2011-07-28T19:31:00.004+09:00

数日前に書いた私のツィッター

割れ目でm×nのピースになる板チョコ. 割れ目に沿って割りピースにまで分ける時の割る回数は, 割る順に関係なく一定とパズル本にあった. 証明は易しい. トーナメントの試合数を思い出す.

について書いてみたい.

これは先頃頂いた, ピーター・ウィンクラー著, 坂井, 岩沢, 小副川訳「とっておきの数学パズル」にあったものだ. 8.11

やってみよう.

2×3だと, たしかにすべて5回だ.

3×4だと, 11回. ということは, m×n-1かもしれない.

そこで数学的帰納法のお出ましとなる.

m×nに分割する回数をf(m,n)と書き, m×n-1であろうとして証明する. f(1,1)は分割するまでもなく1区画になっているから, 1×1-1=0だ.

n≥1,n'≥1,n+n'>1について, nとn'の幅に分割したとする. 分割に1回かかるから, f(1,n+n')=f(1,n)+f(1,n')+1={仮定により}(n-1)+(n'-1)+1=n+n'-1. 横1列の板チョコの分割はf(1,n)=n-1で良さそうである.

今度は縦がm≥1,m'≥1でm+m'列ある板チョコを, m列とm'列に分割したとする. 分割に今度も1回かかるから,

f(m+m',n)=f(m,n)+f(m',n)+1={仮定により}(m×n-1)+(m'×n-1)+1
=(m+m')×n-1

確かにf(m,n)=m×n-1であった.

こんなに簡単な式だと, もっと別のエレガントな考え方がありそうだ.

板チョコは最初ひと(1)塊である. 1回分割すると, ふた(2)塊になる. そのいずれかを分割すると, 3塊になる. つまり, t回分割すると, t+1塊が得られる. 斯くしてm×n塊が得られるまでには, m×n-1回の分割が必要なのであった.

問題を解くとき, とりあえず絶対に答がえられそうな, 正面からの道をとる. それで答が得られてから, 次にもっとうまい手がないか探すのが, 私の普段のやり方だ. プログラムを書くときもそうで, きたなくてもよいから, まず動くプログラムを書く. すると見通しがよくなり, さらにきれいで速いプログラムが得られるのである.

ラスターグラフィック

2011-07-23T17:15:00.004+09:00

TAOCPV4F1はビット操作が前半の話題で, 当然ラスターグラフィックの話も登場する. そのうち, 細線化アルゴリズムの話は前に書いた. 今回は, 塗り潰しについて.

ビットマップが閉曲線で囲まれている時, その内部を塗り潰したい. PostScriptなら, 閉曲線を描き. strokeの代りにfillとすればよい. ProcessingならFill(色); としておくと, その色で塗り潰してくれるから, 簡単である.

それを自分でやる方法が, filling algorithmである.

TAOCPによると, 正方形ピクセルの2次元配列を, 円錐曲線が正方形の中心のいずれの側を通るかにより, 縦横の線の境界で分離するのは簡単だそうである.

下の図はTAOCPの7.1.3(171)を私が描き直したもので, 黒の曲線で示す, 円錐曲線の代表選手, 長軸20, 短軸10の楕円の長軸の右端の辺りのピクセルの様子である. 右下の黒丸の座標が(20,0)だ.

ピクセルの格子点は, x, yが整数値のところに対応している. 座標の整数値の間にピクセルがあるから, ピクセルの中央の座標には, 1/2が付くわけだが, それはいやらしいから, ピクセルの右上の隅の座標で指定する.

従って, ピクセル(20,0)は, 黒丸の左下のピクセルである.

さて, このピクセルを塗るべきか否かは, ピクセルの中央における, 楕円の式の値の正負で決める. 丁度0のところを楕円が通る. 楕円の式は(x/20)²+(y/10)²-1=0だが, ピクセルの中央の値は, xとyからそれぞれ1/2を引いて計算する.

つまり, ピクセル(x,y)の中央の値は,
((x-1/2)/20)²+((y-1/2)/10)²-1
=(x²-x+1/4)/400+(y²-y+1/4)/100-1

1/4や1/100がついて回って, これもやめたいから整数係数にする

400倍して
x²-x+1/4+4y²-4y+1-400
4倍して
4x²-4x+1+16y²-16y+4-1600
=4x²+16y²-4x-16y+1+4-1600
=4x²+16y²-4x-16y+-1595
これをQ(x,y)とする. このx,yに20,0を入れると, その左下のピクセルの中央の値, Q(20,0)=-75が得られる.

こういう値を, この図のピクセルについて計算した結果が, ピクセルの下の方の数値である. これが分かると, 正と負のピクセルの境界が, 塗る塗らぬの境界になる.

この図には, すべてのピクセルの値が計算してあるが, 曲線が左上へ単調に伸びると分かっていれば, 上隣りのピクセルの値を計算し, 負なら上へ進み, 正なら左へ進めば良い. すなわち, 今黒丸の点にいて, 上のピクセルが-75なので, 赤線のように境界を上に延ばす. その上も-43なので, 上へ延ばす. その上は21だから左へ行く. その上は-131だから上へ. というように進むと, 左上へ単調に進む第1象限の部分の境界が得られる.

ところで, 一般的な円錐曲線の式Q(x,y)=ax²+bxy+cy²+dx+ey+fの順次の計算は, Qx(x,y)=2ax+by+d, Qy(x,y)=bx+2cy+eを保持していると, 簡単に求まるということを見つけた知恵者がいて, これを3レジスタ法という. それを使ったアルゴリズムがTAOCPにあるが, 例によってgoto文だらけなので, Scheme風に書いたプログラムが以下である. 関数定義の後のTと番号のコメントは, TAOCPのアルゴリズムTの番号である.


(define (algorithm713t x x1 y y1 a b c d e f)
  (define (q x y) (+ (* a x x) (* b x y)
   (* c y y) (* d x) (* e y) f))
  (define (qx x y) (+ (* 2 a x) (* b y) d))
  (define (qy x y) (+ (* b x) (* 2 c y) e))
  (let ((qreg 0) (rreg 0) (sreg 0))

   (call-with-current-continuation
    (lambda (exit)
     (define (left) (display "left\n")
      (bit-string-xor!
       (list-ref hs (+ y 11)) (- xmax x)))
     (define (right) (display "right\n")
      (bit-string-xor!
       (list-ref hs (+ y 11)) (- xmax (+ x 1))))
     (define (up) (display "up\n"))
     (define (down) (display "down\n"))
     (define (initset x y a c)
      (set! qreg (q x y)) (set! rreg (+ (qx x y) a))
      (set! sreg (+ (qy x y) c)))
     (define (update rs ab bc)
      (set! qreg (+ qreg rs)) (set! rreg (+ rreg ab))
      (set! sreg (+ sreg bc)))

     (define (hfinish) ;T10
      (cond ((< x x1) (right) (set! x (+ x 1)) (hfinish))
            ((> x x1) (left) (set! x (- x 1)) (hfinish))
            (else (exit 'ok))))
     (define (vfinish) ;T11
      (cond ((< y y1) (up) (set! y (+ y 1)) (vfinish))
            ((> y y1) (down) (set! y (- y 1)) (vfinish))
            (else (exit 'ok))))

     (define (moveup) (up) (set! y (+ y 1)) ;T6
      (if (= y y1) (hfinish) (update sreg b (* 2 c))))
     (define (movedown) (down) (set! y (- y 1)) ;T7
      (if (= y y1) (hfinish)
       (update (- sreg) (- b) (- (* 2 c)))))
     (define (moveleft) (left) (set! x (- x 1)) ;T8
      (if (= x x1) (vfinish)
       (update (- rreg) (- (* 2 a)) (- b))))
     (define (moveright) (right) (set! x (+ x 1)) ;T9
      (if (= x x1) (vfinish) (update rreg (* 2 a) b)))
     (define (rightup) ;T2
      (if (< qreg 0) (moveright) (moveup)) (rightup))
     (define (downright) ;T3
      (if (< qreg 0) (movedown) (moveright)) (downright))
     (define (upleft) ;T4
      (if (< qreg 0) (moveup) (moveleft)) (upleft))
     (define (leftdown) ;T5
      (if (< qreg 0) (moveleft) (movedown)) (leftdown))

     (if (= x x1) (vfinish))
     (if (= y y1) (hfinish))
     (if (< x x1)
      (if (< y y1)
       (begin (initset (+ x 1) (+ y 1) a c) (rightup))
       (begin (initset (+ x 1) y a (- c)) (downright)))
      (if (< y y1)
       (begin (initset x (+ y 1) (- a) c) (upleft))
       (begin (initset x y (- a) (- c)) (leftdown))))
      ))))

こう定義してから, 順次の象限について


(algorithm713t 20 0 0 10 4 0 16 -4 -16 -1595)
(algorithm713t 0 -20 10 0 4 0 16 -4 -16 -1595)
(algorithm713t -20 0 0 -10 4 0 16 -4 -16 -1595)
(algorithm713t 0 20 -10 0 4 0 16 -4 -16 -1595)

のように呼ぶと, 下のような境界が得られる.

しかし, 境界だけでは塗り潰したことにならない. 塗り潰しの実装はこのようにする. 境界の横線の真上のピクセルを1に, それ以外を0のビット列の配列hs[-11..10], bs[-11..10]を用意する. 私流のプログラムでは,


(define hs
 (map (lambda (x) (make-bit-string 42 #f)) (a2b -11 11)))
(define bs
 (map (lambda (x) (make-bit-string 42 #f)) (a2b -11 11)))

これはMIT Schemeにある長さ42ビットのbit-stringで, 初期値はオール0である. リストの長さは22だ.

上のプログラムの, 下請け関数leftとrightのところは,


(define (left) (display "left\n")
 (bit-string-xor! (list-ref hs (+ y 11)) (- xmax x)))
(define (right) (display "right\n")
 (bit-string-xor! (list-ref hs (+ y 11)) (- xmax (+ x 1))))

となっていて, 横向きの境界に対応するビットを0から1にしている. その結果, 1周すると, hsとして(最下行がリストの先頭)


#*000000000000000111111111111000000000000000
#*000000000011111000000000000111110000000000
#*000000001100000000000000000000001100000000
#*000000110000000000000000000000000011000000
#*000011000000000000000000000000000000110000
#*000100000000000000000000000000000000001000
#*001000000000000000000000000000000000000100
#*000000000000000000000000000000000000000000
#*010000000000000000000000000000000000000010
#*000000000000000000000000000000000000000000
#*000000000000000000000000000000000000000000
#*000000000000000000000000000000000000000000
#*010000000000000000000000000000000000000010
#*000000000000000000000000000000000000000000
#*001000000000000000000000000000000000000100
#*000100000000000000000000000000000000001000
#*000011000000000000000000000000000000110000
#*000000110000000000000000000000000011000000
#*000000001100000000000000000000001100000000
#*000000000011111000000000000111110000000000
#*000000000000000111111111111000000000000000
#*000000000000000000000000000000000000000000

のようなビット列が得られる. hsが出来たら,


(do ((i 1 (+ i 1))) ((= i 22))
 (list-set! bs i (bit-string-xor (list-ref bs (- i 1))
                                 (list-ref hs i))))

のプログラムで, bsが作れる. bsはこういう値である.


#*000000000000000000000000000000000000000000
#*000000000000000111111111111000000000000000
#*000000000011111111111111111111110000000000
#*000000001111111111111111111111111100000000
#*000000111111111111111111111111111111000000
#*000011111111111111111111111111111111110000
#*000111111111111111111111111111111111111000
#*001111111111111111111111111111111111111100
#*001111111111111111111111111111111111111100
#*011111111111111111111111111111111111111110
#*011111111111111111111111111111111111111110
#*011111111111111111111111111111111111111110
#*011111111111111111111111111111111111111110
#*001111111111111111111111111111111111111100
#*001111111111111111111111111111111111111100
#*000111111111111111111111111111111111111000
#*000011111111111111111111111111111111110000
#*000000111111111111111111111111111111000000
#*000000001111111111111111111111111100000000
#*000000000011111111111111111111110000000000
#*000000000000000111111111111000000000000000
#*000000000000000000000000000000000000000000

タイプの文字の縦横比は1:1でなく, これは正しい形ではない. 再びMIT Schemeの機能graphicsを利用すると,


(define mydevice (make-graphics-device 'x))
(graphics-set-coordinate-limits mydevice -24 -24 24 24)
(do ((i 0 (+ i 1))) ((= i 22))
 (let ((b (list-ref bs i)))
  (do ((j 0 (+ j 1))) ((= j 42))
   (if (bit-string-ref b j)
    (graphics-operation mydevice 'fill-circle
     (- 21 j) (- i 11) 0.5)))))

によって, 次のようなパターンが得られる.

多面体描画道楽

2011-07-09T22:06:00.002+09:00

Archimedesに興味をもって, その多面体を描いてきた. 今回はその総括である. この多面体は13種ある. まとめると以下の通り.

ます, 英語名と日本語名を並べる. 次の行は(p_i n_{p_i})のリストで, 正p_i角形の面がn_{p_i}枚あることを示す. 多面体屋なら, この情報から稜の数と頂点の数は計算できるので, その情報をここには記載しない. その次は各頂点について, 何角形が集まっているかを示すリストである. これがこの立方体の実在正を示すキューになる.

日付がある項は, その日のこのブログに絵があったことを示す.

a. truncated tetrahedron 切頭四面体
((3 4) (6 4)) (3 6 6)
2008年10月29日

b. cub octahedron 立方八面体
((3 8) (4 6)) (3 4 3 4)

c. truncated octahedron 切頭八面体
(4 6) (6 8)) (4 6 6)
2008年10月29日

d. truncated cube 切頭立方体
((3 8) (8 6)) (3 8 8)

e. rhomb cub octahedron 斜方立方八面体
((3 8) (4 18)) (3 4 4 4)

f. truncated cub octahedron 切頭立方八面体
((4 12) (6 8) (8 6)) (4 6 8)

g. icosi dodecahedron 二十十二面体
((3 20) (5 12)) (3 5 3 5)

h. truncated icosahedron 切頭二十面体
((5 12) (6 20)) (5 6 6)
2008年10月29日

i. truncated dodecahedron 切頭十二面体
((3 20) (10 12)) (3 10 10)

j. snub cube 変形立方体
((3 32) (4 6)) (3 3 3 3 5)
2011年6月30日

k. rhomb icosi dodecahedron 斜方二十十二面体
((3 20) (4 30) (5 12)) (3 4 5 4)
2011年6月19日

l. truncated icosi dodecahedron 切頭二十十二面体
((4 30) (6 20) (10 12)) (4 6 8)
2011年6月29日

m. snub dodecahedron 変形十二面体
((3 80) (5 12)) (3 3 3 3 5)
2011年7月7日

それ以外のを以下に示す. 描いた時が違うので, 描画法がばらばらだが, ご容赦を. また時間のある時に揃えることもあろう.

立方八面体

切頭立方体

斜方立方八面体

切頭立方八面体

二十十二面体

切頭十二面体

ところで私はこれらの立体の頂点の座標を計算し, PostScriptでプログラムして描いただけだが, 東京理科大学近代科学資料館には菱田為吉氏による, 木製の多面体模型がある. 私は資料館に行くたびに, うっとりと眺めてくる.

Platonの5個の正多面体, Archimedesの13個の多面体は, 立体マニアの興味を引き続けてきた. 私もそれに取り込まれた1人である.

多面体描画道楽

2011-07-07T19:39:00.002+09:00

Archimedesの多面体の最後は, snubdodecahedron, 日本語では変形正十二面体という.

ものの本によると, この立体は, 三角形が80, 五角形が12で構成される. 従って稜は(3×80+5×12)/2=150, 頂点は150+2-(80+12)=60である.

正十二面体は, 正五角形の面が12, 頂点はHamilton巡礼で良く知られた20, 稜(辺)はEulerの式から12+20-2=30あった. 従って, 変形正十二面体では, 正五角形は正十二面体の面に対応し, 三角形は頂点+2×稜である.

さて, 下の図を見て欲しい. 大きい正五角形が3つ描いてある. 左の上と下は, x軸の方から見て正面になるものだ. 右の寝そべったのは, y軸方向から見えるものだ.

それぞれの正五角形の中に, 適当に縮小した正五角形を描き, それをθだけ傾ける. 縮小しただけでは, 斜方正十二面体になる. 今回は傾けるのが味噌だ. 縮小したことで元は3つの正五角形が1点に集まっていたものが, 図のE, H, Fのように分かれ, 三角形EHFが出来る.

また元は1つの辺だったものが, AEとGFに分かれる. 傾けたため, AとFが近づき, それを結ぶと, 三角形AFGと三角形FAEが図のように出来る.

つまり1つの頂点が1つの三角形, 1つの辺が2つの三角形になるから, 前述のように20+30*2=80の三角形になる.

従って, この立体の図を描くためには, 赤で示した線分の長さが等しくなるように, 縮小比と回転角を決めなければならない.

正面上の辺AEを持つ正五角形の各頂点の立体座標が分かれば, 下の辺FGを持つ正五角形の各頂点の立体座標は, 上の座標をx軸について, 180度回転すれば得られるということから始まり, すべての面の頂点の座標はなんとか軸対称回転で計算出来, 思い通りの変形正十二面体の図が得られるはずである.

いつものように, 1辺が2の正五角形で出来た正十二面体で計算する. 正五角形の中心までの高さは, tan 54°=1.3763819204711734; 上の頂点までの高さは, tan72°=3.0776835371752527; 半径はこの差だから 1.7013016167040793. その中に半径rに内接する正五角形を作る.

その中心から見た頂点の座標をまず計算する. 72n+36°の正弦と余弦をsn0やcs0のように書くことにする.

rとθが与えられると, 以下のプログラムは, 3次元に変換し, 各点のx,y,z座標を計算する. うっとうしいが全部書くと

これらの点から, AF, FE, EH, HFの距離とAEの距離の差の絶対値の和を最小にするrとθを決めたい. こんな式は, これ以上計算する気にならないので, 今回は山登り法で最適値を探すようにした.

とりあえず, rを0.8, 0.85, ... 1.25, thetaを0, 0.5, ...0.45と変え, この関数の値をプロットすると, この範囲に最小値があるらしい.

大体r=0.95, θ=0.21 radianあたりが解らしい. PostScriptで描画するから, この程度の値で充分である.

今回の描画プログラムは, 見えない面の破線は, 一度しか描かないようにしているから, 破線がきれいに見えている.

八方睨みの猫

2011-07-03T20:03:00.002+09:00

ご近所の知友金子和夫氏の個展があった. 鉛筆画の「八方睨みの猫」が評判である. チラシからその一部をスキャンさせていただいた. この猫ちゃんには, 金子家で会ったことがある. 可愛い猫だ.

ところで八方睨みとは, この猫をどの方向から見ても, 猫は見られている方を向いているように見えるということである. このチラシを, 右左に傾けても, 上下から眺めても, 確かに視線はこちらを向いている.

実はこの猫だけでなく, 多くの肖像画の目付きも, 大体はこうなっている.

歩きながら月をみると, 歩くにつれて, いつまでも月が付けて来るように, 絵の前を通り過ぎても, 肖像の眼の視線はずーっと自分を追ってくる. 私は若い頃は, これを不思議に思っていた. また, それについて, おそらく黒目が眼の中央にあるからだろうと想像してた.

大学院生の頃, 研究室でこれが話題になったことがあり, 高橋秀俊先生は「黒目が真ん中だから」とこともなげにいわれ, 私としては, 決着がついている.

この猫の黒目は, 上下左右の真ん中にある. 従って四方八方を睨むことになる.

私は, ご存じのようにPostScriptで絵を描くのが大好き人間だ. で, さっそくやってみた. それぞれの絵では, 上から黒目が右より, 中央, 左よりに描いてある. やはり中央のが八方睨みに見える.

横方向から見ても, (つまり横方向を縮小しても)

のようになろう. 真昼の猫の眼のように, 細くなっても同じだろうか.

再帰曲線

2011-07-02T08:11:00.001+09:00

私が昭和13年4月に出会った算術の教科書の表紙の再帰曲線の続きである.

収束点の座標が1,1と分かったからには, さらに直観的でエレガントな求め方があるに違いないと思う.

次のように考えて見た.

A点から上向きに出発する. 4歩進みB点に至る. ここは次に下向きに出発する点である. ABの直線を赤のように引く. Bから4歩進むと, 先ほどとは上下左右が入れ替わり, C点に至るが, これは赤線の上に来るはずである. 従って, 4歩毎の点は, 右上に行ったり, 左下へ行ったりするが, 赤線の上にある. つまり, 収束するのは赤線の上である.

上向きに進み終ったD点から, 同じように考える. 4歩進むと下向きに進み終ったE点に至る. DEに青で直線を引く. Eから4歩進んだF点も同じように青線上にあるはずだ. 従って, 収束点は青線上にある.

赤線はy=x, 青線はy=1だから, 交点は1,1だ.

Gorge Polyaの「いかにして問題を解くか」には, 問題を解いた後で, もう一度振り返れと書いてある. もっとうまい解法が見つかるかも知れないからである.

とりあえずは数値計算で遮二無二解いたとしても, その後, 今回のような解法が見つかると, やはり嬉しい.

再帰曲線

2011-07-01T14:52:00.004+09:00

はるか昔のことを思い出した. 小学校に入学したら, 算術という科目があった. (その後しばらくして, 算数と名前が変った.) その教科書の表紙に面白い図形があったのを鮮明に覚えている. 少しずつ小さくなった直角二等辺三角形が繋がっているのが見える.

(教科書の絵はウェブページwww-cc.gakushuin.ac.jp/~851051/maed/09sakurai.pdfにもあった.)

これをいつまでも続けていくとどうなるかというのが, その図形を見たときのとっさの疑問であった.

70余年を経て, 計算してみた.

これは上に伸びる三角形の列の外側の線を描いたものだ. 最初の二等辺の長さを1とする. 真上に1だけ伸びると, 45°右に折れ, √(1/2)だけ伸びるという操作を繰り返す. 8回すすむと, 次はまた真上に進むから, ここで1サイクル終了したとして, この座標を計算すると,

x座標は 0+0.5+0.5+0.25+0-0.125-0.125-0.0625=0.9375
y座標は 1+0.5+0-0.25-0.25-0.125+0-0.0625=0.9375

である. 最初に1伸びたのが, 1サイクル終ると, 次は1/16だけ真上に伸びるから, 次のサイクルの終りの座標は, xもyも 0.9375+0.9375/16 だ. さらに次はこれに0.9375/16²を足すことになるから, 初項が0.9375で公比が1/16の無限級数を計算することになる.

0.9375/(1-1/16)

だけれど, 0.9375が1-1/16だったから, この値は1だ. (上の図の赤線が1,1を示す.)

なーんだ, という結論だが, やっとせいせいした.

多面体描画道楽

2011-06-30T21:34:00.003+09:00

Archimedesの多面体はまだsnub cubeとsnub dodecahedronの2つが残っている. 今回は前者変形立方体に挑戦.

元は立方体である. その各面の正方形を縮小し, どちらかに多少回転する. その方向により, 2つの相対の形がある.

どのくらい縮小するか, どのくらい回転するかを計算しなければならない. そこで次の図のように考える.

3つの似たような図があるが, 上が平面図(z方向から見た), 右下が側面図(y方向から見た), 左下が正面図(x方向から見た)である.

この立体は6の正方形と32の正三角形で被われる. 正方形と正三角形は辺を共有するから, すべての辺は同じ長さになる. それをdとする.

また, 座標の中心を立方体の中心にし, 立方体の1辺の長さを2とすると, A, B, C, Dの座標はそれぞれ


A(1,a,b)
B(1,-b,a)
C(a,b,1)
D(b,-a,1)

である. ABの距離の2乗はd²=(a+b)²+(a-b)²=2a²+2b².

ACの距離の2乗はd²=(1-a)²+(1-b)²+(a-b)².
従って, a+b+ab=1.

ADの距離の2乗はd²=(1-b)²+(2a)²+(1-b)².
従って, 2b-a²=1, b=(1+a²)/2.

このbを上の式に入れると, a³+a²+3a=1. 3次式だから, 実数解はあるはずと思い, WolframAlphaの解いてもらうと, a=0.295598, 従ってb=0.543689, 念のため a+b+abを計算する.


(define a 0.295598)
(define b 0.543698)
(+ a b (* a b)) => 1.0000120414040001

計算は存外簡単であった. 球に内接の件は, どの頂点の座標も, 1とaとbで出来ているから, 当然である.

これさえ分かれば, 変形立方体を描くのはわけけない. いや1点落とし穴があった. 手前の面の座標から, 向こうの面の座標を得るのに, ついyz軸面の鏡面対称を使ったが, 正方形がが傾いているから, z軸に対して180度回転しなければならなかった.

ところで, Archimedesたちが, こういう形になぜ気づいたかは不思議だ.

多面体描画道楽

2011-06-29T13:01:00.002+09:00

Archimedes多面体には, もう1つの二十・十二面体がある. 英語ではtruncatedicosidodecahedronとかgreat rhombicosidodecahedronという. 日本語では切頭二十・十二面体であろう. 図を描くのは存外難しかった. (いや, さらに難物が今後に控えている.)

これは正十二面体の12の正五角形を正十角形にし, その隙間に20の正六角形と30の正方形を詰めたものである.

まず, 正五角形に内接する正十角形を作らなければならない. それには, 下の図のように考える.

左のPOは, もとになる正十二面体の1つの正五角形を横(y軸)方向から見たものだ. この下の稜線上にx方向から見える正方形があり, その1辺の長さを2xとする. このxは, 正五角形の面内では, yの長さになる. 面のなす角をαとすると, y=x/sin αだ. 但し, tan α=(3+√5)/(1+√5).

右は, 正五角形の右下を法線方向から見たものだ. Aの所に54°の三角形があり, その縦はy+x sin 36°, 横はOAが1だから, 1-x-x cos 36°であり, この比がtan 54°なので, xが解ける.

この代表の正十角形の各点のx, y, z座標は


    x                  y                   z
0 2.4180339887498947 -.3236067977499789  .32360679774997897
1 2.218033988749895  -.8472135954999578  .6472135954999579
2 1.8944271909999162 -1.0472135954999577 1.1708203932499366
3 1.5708203932499372 -.8472135954999578  1.6944271909999156
4 1.3708203932499372 -.32360679774997897 2.0180339887498944
5 1.3708203932499372 .3236067977499789   2.0180339887498944
6 1.5708203932499372 .8472135954999578   1.6944271909999156
7 1.8944271909999162 1.0472135954999577  1.1708203932499366
8 2.218033988749895  .8472135954999578   .6472135954999578
9 2.4180339887498947 .3236067977499789   .3236067977499789

と計算出来る. Archimedesの多面体も, 各頂点は球に内接するから, 上の座標からx²+y²+z² を計算したのが下だ.


0 2.4609614157580197
1 2.46096141575802
2 2.46096141575802
3 2.4609614157580197
4 2.4609614157580197
5 2.4609614157580197
6 2.4609614157580197
7 2.46096141575802
8 2.46096141575802
9 2.4609614157580197

まぁ, よかろう. あとは隙間の面を指定するだけである.

そうして描いたのがこの図である.

多面体描画道楽

2011-06-19T21:39:00.002+09:00

Archimedes多面体というのがある. 切頭八面体とか切頭二十面体とかはその仲間だ. その中に, 斜方二十・十二面体という長い名前のものがあった. 英語ではrhomb icosi dodecahedronという. rhombが斜方, icosiが二十, dodecaが十二, hedronが面体の単数だ.

これば難しそうだ. 図面を何日も眺めたが, アタックの入口が見つからない. 空しく過しているうちに, やっと解決の糸口が見えてきた. 次の図で説明しよう.

左は正十二面体をx軸方向から見たもので, 真下のXと書いた上の点がX軸である. 右はそれをy軸方向から見た図である.

斜方二十・十二面体には, 五角形が12, 四角形が30, 三角形が20ある. 一方, その元になる正十二面体は, 面Fが12, 頂点VがHamiltonianの巡礼で分かるように20, 辺Eが30ある. Eulerの式 V+F=E+2である.

つまり, 五角形は面が, 四角形は辺が, 三角形は頂点に対応している.

正十二面体の頂点は, 3つの面が合わさっているから, それを削っていけば, 三角形が現れるが, それでは五角形が十角形になる切頭十二面体が出来るだけである.

下の左の図で, 正五角形ABCDE(面が傾いているから, 上下がつぶれて見える)を中心に向って縮小すると, 下の辺と下にある五角形の対応する辺で作る四角形が正方形になる時点があるはずで, その時, 同じ辺の長さを持つ正五角形A'B'C'D'E'と正方形が出来る.

というわけで, A', B', C', D', E'の右方向へのy座標と, 上方向のz座標が計算出来る. 各点のz座標が分かると, 右の図のようにして, x座標も決る.

AEの距離を2とした時, A',B',C'の座標は次の通りである.

こうして描いた多面体は次の通り.

もっともらしいではないか.

ビットスワップ

2011-06-14T20:28:00.006+09:00

MOR命令4つで完全シャッフルをするのは超絶技巧だ. Schemeで書いたMORのシミュレータを使い, 実際にシャッフルしてみる.

MMIXのMORは$Yと$ZをMORして$Xに置くが, Schemeは関数なので, MORした値を返す.

まず行列の転置の関数がいる.


(define (tr m)  ;行列mの転置
 (map (lambda (i)
  (map (lambda (b) (list-ref b i)) m))
   (a2b 0 (length (car m)))))
;(tr '((1 1 1 1) (0 0 1 0) (0 1 0 0) (1 1 1 1)))
;=>((1 0 0 1) (1 0 1 1) (1 1 0 1) (1 0 0 1))

真理値に0,1を使うor関数もいる.


(define (or x y) (quotient (+ x y 2) 3))
;(or 0 0)=>0, (or 0 1)=>1, (or 1 0)=>1, (or 1 1)=>1

するとmorは


(define (mor y z)
 (let ((zb (map (lambda (n) (n2bs n 8)) (n2bytes z 8)))
       (yb (tr (map (lambda (n) (n2bs n 8)) (n2bytes y 8)))))
 (bytes2n
  (map bs2n
   (map (lambda (z)
    (map (lambda (y)
     (fold-right or 0 (map * z y))) yb)) zb)))))

と書ける. (n2bs n w)は整数nをwビットのリストにする. n2bytesはバイトのリストにする.

あと, MUX関数も必要だ.


(define (mux m y z)
  (let ((ms (n2bs m 64)) (ys (n2bs y 64)) (zs (n2bs z 64)))
  (define (mx m y z)
   (if (null? m) '()
     (cons (if (= (car m) 1) (car y) (car z))
       (mx (cdr m) (cdr y) (cdr z)))))
 (bs2n (mx ms ys zs))))

この準備のもとで, 完全シャッフル関数は


(define (perfectshuffle z)
 (let ((t (mor z #x8008400420021001)) (u 0))
  (set! t (mor #x8020080240100401 t))
  (set! u (mor t #x4080102004080102))
  (set! u (mor #x4080102004080102 u))
  (mux #xaa55aa55aa55aa55 t u)))

である. どのビットがどこへいったかを調べるには,


(define bin '(
#xffffffff00000000
#xffff0000ffff0000
#xff00ff00ff00ff00
#xf0f0f0f0f0f0f0f0
#xcccccccccccccccc
#xaaaaaaaaaaaaaaaa))

を次々とシャッフルし, 結果を二進法で出力する. それには


(define (bs x)
  (substring (number->string (+ x (expt 2 64))2) 1 65))

を使う.


(map (lambda (n) (display (bs (perfectshuffle n))) (newline))
  bin)

をやってみると,

が得られる. つまり, 左から元の位置は63, 31, 62, 30,...,32,0であったことが分かる.

ビットスワップ

2011-06-13T19:13:00.004+09:00

TAOCP V4F0にはビット交換の技法がいろいろ書いてある. その大方の仕掛けはδスワップだが, TAOCPのベースのRISCマシン, MMIXにはMORとMXORという大形命令が存在し, それを巧みに利用する例題も多い.

これらの命令の説明はややこしく, なかなか覚えられないが, 今回のブログはその機能を覚えるためのものでもある.

MORはmultiple orのことで, 命令MOR $X, $Y, $Zは, 64ビットのレジスタ$Yと$Zのビットに演算を施し, レジスタ$Xに置くものである. TAOCP V1F1では,

m($X) ← m($Z)^v_xm($Y)

と説明する. レジスタ$Zと$Yの順が命令での順と逆なことに注意. この演算は, 64ビットレジスタをそれぞれ8ビットの行が縦に8行並んだ8 × 8の行列とみて, 2つの行列の乗算のような演算をするのである.

行列の乗算では, 積のi,j要素は, 被演算子の左の行列のi行と, 右の行列のj列の要素を次々と掛けて全体を足すのであった. それを2つの行列の間の演算⁺_xで表わす.

今は要素は0か1である. それを次々と掛けて全体のor(v)を取るのである. MXOR命令は全体のxorを取る.

使い方の例として, TAOCPには
$Z = #0102040810204080
とすると, $Yのバイトの順が逆になるというのがある. つまり(abcdefgh)₂₅₆が(hgfedcba)₂₅₆になる. それを説明するのが, 次の図の上だ.

まず$Xの左上, X_0,0は, $Zの0行目, 000...01と$Yの0列目のそれぞれを掛けるが, 1が最後にしかないので, ここに来るのはhのバイトの左端のビットである. その右隣りX_0,1も, 同じ0行目と掛けるから, hのさっきのバイトの右隣りになる. 同様にした結果, $Xの0行目はhのバイトになる.

$Xの1行目は, $Zの1行目が000...10, つまり最後の1つ前にだけ1があるから, gの行が来る.

hの行が0行へ移った理由を再確認すると, Zの0行目の1が右端にあるからだ. つまり0行目へ置きたい$Yのバイトの位置を1にする. 赤矢印が0行目へ来るバイトの位置を示す.

そういう次第で, このパターンを使うと, $Yのバイトが逆転するのである.

下の図は左右逆転, つまりバイトの順は同じだが, バイトのビットを逆転する方法を示す. 上と同じで, $Xの0列目は, $Yの0列目の最後だけが1なので, hの各ビットが移動してきて, hになる. そして結局左からhgf...aと並ぶ.

ビット交換では, Yの0列の1の位置がXの0列に持ってきたいビットの位置である. (赤矢印)

これだけ分かると, V4F0にある完全シャッフルの問題(演習問題7.1.3-204)が解ける.

64ビットのレジスタzは

z = (x₃₁...x₁x₀y₃₁...y₁y₀)₂

である. それを

w = (x₃₁y₃₁...x₁y₁x₀y₀)₂

にしたい. ヒントがあって,

t = (x₃₁x₂₇x₃₀x₂₆x₂₉x₂₅x₂₈x₂₄y₃₁y₂₇y₃₀y₂₆y₂₉y₂₅y₂₈y₂₄...
x₇x₃x₆x₂x₅x₁x₄x₀y₇y₃y₆y₂y₅y₁y₄y₀)₂

u = (y₂₇y₃₁y₂₆y₃₀y₂₅y₂₉y₂₄y₂₈x₂₇x₃₁x₂₆x₃₀x₂₅x₂₉x₂₄x₂₈...
y₃y₇y₂y₆y₁y₅y₀y₄x₃x₇x₂x₆x₁x₅x₀x₄)₂

を中間結果とし, tとuを

MOR t,z,p; MOR t,q,t; MOR u,t,r; MOR u,r,u;

で作り,

PUT rM,m; MUX w,t,u;

とすると, 6命令で完全シャッフルが出来る. パターンp, q, r, mは何かという問題である.

このうちMUX命令は多重化マスクレジスタrMを見ながら, そのビットが1の所は$Yから, 0の所は$Zからデータを取る. PUT rM,mはパターンmをrMへ設定する命令だ. そうすると,

w₃₁はx₃₁にしたいからtから取る.
w₃₀はy₃₁にしたいからuから取る.
w₂₉はx₃₀にしたいからtから取る.
...
28まで行くと, 取るレジスタが交代する. 従って, 1010101001010101の繰り返しになるのだ. m = #aa55aa55aa55aa55

さて, zとtとの関係は, 次の図の上半分にある通り. バイトの交換とビットの交換をしている. 命令列の最初はMOR t,z,p;なので, $Zの方がパターンになり, バイトの交換だ. バイト位置の0,1,2,3,4,5,6,7に持ってきたいのは, それぞれ0,4,1,5,2,6,3,7だから, 下に示す行列のようになり, p = #8008400420021001でよかろう.

次の命令はパターンが$Yにあるから, ビット交換である. ビットの取り先は同じ関係だが, 縦と横が違うから転置のパターンにしなければならない.

q = #8020080240100401.

最後にtからuへの変換も, バイト交換とビット交換になっている. これはどちらも隣り同士の交換なので, パターンは同じである.

r = #4080102004080102.

TAOCPの演習問題には解答があるから覗いてみると, 正解であった.

Banbury Road

2011-06-06T22:00:00.003+09:00

前のブログ(グラフの描き方)に英国の道の図を載せた.

それにBanbury Rdの表示がある. Banbury RoadはOxfordから北の方Banburyへ行く道である. さらに北へ進むとCoventryへ至る.

英国の初期の計算機研究の中心はもちろんCambridge大学のComputer LaboratoryとOxfordのComputing Laboratoryであった. まぁEdinburghとかNew Castle upon TyneとかManchesterとかImperial Collegeとか他にもあるにはあるが.

CambridgeはWilkes. OxfordはLeslie Foxがリーダーであった.

私は1971年にIFIPの会議でWarwick大学へ行ったとき, OxfordのChristopher Stracheyがいて, 当時のMiniの後の座席に私を押し込み, 助手席にBrian Randellを乗せ, 大柄な自分も運転席へ潜り込むように乗り込み, John Buxtonの1400年頃に出来た家へ, 田舎道を走った.

ところで, そのBanburyという町は, Mother Gooseの詩

Ride a cock horse to Banbury Cross
To see a fine lady upon a white horse
With rings on her fingers and bells on her toes
She shall have music wherever she goes

で有名である. Banbury Crossは十字路ではなく, 十字架というか, 記念碑である. 私は1998年, Oxfordにいったついでに, Banburyまで列車で行き, Banbury Crossを見てきた.

Baring-GouldのThe Annotated Mother Gooseによると, このa fine ladyはElisabeth I女王か, Coventryが近いのでLady Godivaかとか書いてあるが正確なことは分からない.

Coventryには町の中心にLady Godivaの像がある. また私がBanburyに行った時はなかったが, いまはCrossの近くに, a fine ladyの像があるらしい.

Banbury Roadという住所に思い出があるのは, 1974年に私が訪ねたころの, Oxford大学のComputing LaboratoryがBanbury Roadの何番地かにあったからだ. 大学の研究所とは思えない, 普通の家であった. そこで, StracheyとJoe StoyのOS6をコピーを手にいれた. その後, Computing Laboratoryは, 大きなビルに移転し, Banbury Roadとは無縁になった.

今でもBanbury Roadは懐かしい道だ.

曜日の計算

2011-06-05T20:55:00.003+09:00

5月25日の私のブログにある2番目のh(m)の表は


m 1月 2月 3月 4月 5月 6月 7月 8月 9月10月11月12月
h   2   5   5   8   3   6   1   4   7   2   5   0

となっており, 1月2月は別として, 3月以降は基数月の値は基数, 偶数月に値は偶数になっていて, 一見美しい. だが待てよ. 大小の月は, 大体交互だが, 7, 8月と大の月が並ぶ. さてはこの表は間違っているかと一瞬疑った.

ある月が小の月, 30日だと次の月は 30 mod 7=2だから, 2だけ増え, 大の月, 31日だと31 mod 7=3だけ増えるはずである. そうすると小の月の後では偶奇は変らず, 大の月の後では変るはずである. しかし, 奇数の除数7で mod 7を取っているので, 商が1増えた時, 今の関係は反対になるわけだ.

3月を5, 4月を8にしたことが, 効いているかも知れないが, どこで商が増えるかにも注意して, もう一度きちんと計算してみたい.

その結果が次の表である. Aの行は月, Bの行はその大小. Cは3月を5として, 大の月には3, 小の月には2を足したものである. ところどころの赤の縦線は, 7のmodを取ると, その前で商が1増えることを示す. DはCの偶奇を示す.

さて, 前回述べたように, 7のmodをとるについて, 4月の1は8に, 9月の0は7にした. 従って, Eの行に示すような値になり, 商が増える場所を赤の長い縦線で示す. FはEの偶奇である.

この赤線で囲まれた区間は, 交互にDの偶奇と同じ, 反対を繰り返す. つまり3, 4月はDとFは同じ, 5, 6月は反対, 7, 8, 9月は同じ, 10, 11月は反対, 12月は同じである. この区間の境界は, Dの行で, 偶偶, 奇奇と並んでいる間にある. 従って, Fの行では偶奇が交互に現れるのであった.

要は4月を8, 9月を7にして, 商の増えるのを1ヶ月遅らせたところに, 仕掛けがあったのだ.

こう検討してみると, あの表はいよいよ忘れ難くなるわけだ.

グラフの描き方

2011-06-04T16:14:00.003+09:00

Frank HararyのGraph Theoryに下のような図があり, 読者を悩ませる. つまり頂点の黒丸が小さいので, 中央の線の集まったところに頂点があるようなないような.

説明を読むと, 上のFig.12.8はA uniquely 3-colorable graph having no triangles, 下のFig.12.9はA uniquely 3-colorable planer graphだから, 上は頂点なし, 下は頂点ありだ.

回路図の上で線が交差する場合, そこが接続されているか, 別の線なのかを表わすのに, 下のA, B2つの流儀がある.

どちらも左は別の線, 右は接続である. 用心深い人は, 接続には黒丸をつけ, 別線の時は飛び越えるように描く. 私は, 接続する場合は丁字に描き, 十字路は別線とするようにしていた.

英国の田舎の道は, 細い道が太い道と交わるとき, 細い方が必ず少し食い違いになっていて, 停車せず突っ切れないようになっている. 私のやり方と同じである. 都会の横断歩道にもそんな感じだったりする.

しかし, 私の流儀は回路図だから出来るので, グラフ理論では, 次数3の頂点までしか表示出来ず, 実用にならぬ.

例えば, 別の線が2本以上, 1点で交わらないように描くというのはどうか. 上の図の中央のW₉のようなところを, そのように描いたのがこれだ.

描いてはみたが, センスあるとは申せない. もう1工夫必要だ.

最初の図は, uniquelyに3色塗り分け可能という. どう塗り分けられるか. 以前のブログのプログラムを使って, 塗り分けたのが下だ.

ところで, 上の図は, 中央に頂点があっても3色塗り分け可能である.

この程度に頂点がしっかり描いてあれば, 悩むことはないのだが.

曜日の計算

2011-05-25T19:43:00.004+09:00

1989年12月19日に59歳で他界された基礎論の数学者, 島内剛一(しまうちたかかず)先生を知る人はもう少ないに違いない. 私はプログラミング言語の設計などで, 島内さんには多くの影響を受けた. 基礎論の専門家だけあって, 計算機の見方も一種独特であり, 島内マニュアルは「計算機は順序のあるビットの有限集合である.」のように書き始める.

島内さんの多くの特技の1つが, 曜日の計算であった. 年月日をいうと10秒くらいで何曜と返ってくる.

その秘法は何か. 私の推測では, 島内さんは,


m 1月 2月 3月 4月 5月 6月 7月 8月 9月10月11月12月
h   2   5   5   1   3   6   1   4   0   2   5   0

のような, 月始めの曜日の表h(m)だけを記憶していたらしい.

すると, 21世紀中の 2000+y年m月d日の曜日は, y+floor(y/4)+h(m)+d+4 mod 7 を計算するとそれが曜日になる.

やってみよう. 2011年5月25日の曜日は, 11+floor(11/4)+h(5)+25+4 = 13+3+25+4 = 45, 45 mod 7 = 3 すなわち水曜である.

だれもが知っているように, 平年ならある日の曜日は, 365 mod 7 = 1 ゆえ, 翌年は次の曜日になる. うるう日をまたぐと, 2日増える. これがyとfloor(y/4)を足す理由である.

うるう年は1月2月も2増やしてしまったが, これでは駄目なので, うるう年の1月と2月はh(m)の値から1を引く必要がある.

最後の+4は21世紀中に通用する定数で, 曜日を合わせるためのものだ. そもそもh(m)の表は全体を一斉に増やしても減らしても問題ない. 補正値をそれに応じて変えるだけである.

要はh(m)の表を覚えやすく作ることだ. 島内さんは似たような表を, おそらく無理に覚えてしまったのだろうが, 私は上の表を工夫をして書いた. mod 7を取るのだから, 7を足しても意味は変らないので, 4月を8に, 9月を7にする.


m 1月 2月 3月 4月 5月 6月 7月 8月 9月10月11月12月
h   2   5   5   8   3   6   1   4   7   2   5   0

この表で, 4月から始まる偶数の月の値は, 8, 6, 4, 2, 0である. 一方, 3月から始まる7月までの奇数の月の値は, 5, 3, 1で, その先は負になるから, 心機一転9月は7に, 11月は5にするのである.

残りは, 経験で知っているように, 2月は3月と同じ, 1月は10月と同じと覚える.

3月は5で, 4月は8の出発の値の記憶が肝心である(9月の7も?). そして2か月で2ずつ減る(2か月の間に, 通常は30日の月と31日の月があり, 30+31=61=-2 mod 7だからだ). それと世紀の定数の+4を忘れないこと.

練習問題
2000年1月1日は何曜か. (うるう年に注意)
9.11の2001年9月11日は何曜か.
来年日本で金環食が見られる2012年5月21日は何曜か.
unix timeの31ビットが立つ, 2038年1月19日は何曜か.

今年ももう年の半ばまで来た. 今年中は, 11+floor(11/4)+4=17 そのmod 7は3だから, 3+h(m)+d mod 7で計算する.

曜日に計算では, 無理に誤差をいれる島内の方法や, John Conwayの方法などが面白いが, それらはまたいずれ.

unix time

2011-05-23T19:01:00.001+09:00

前回のunix timeのブログに書いたように, Calendricalの方法は, 確かに簡単ではあるが, 1から勘定を始めるプログラムに, 多少の違和感を持っていた私は, やはり0から始めるプログラムが書いてみたく, そのため, 366, 365, 365, 365のように, おなじものが並ぶ後続の前に, それらより1だけ多いか少ない要素が先頭にあるときの処理について考えていた.

つまり例えば1600年1月1日から1999年12月31日の400年間, 146097日には, 最初の100年は1600年がうるう年なので, 36525日あり, 後の3回の100年は, 最初の00年が平年なので, 36524日であって, 36525, 36524, 36524, 36524であり, またその36524日ある100年を4年ごと25組に分けると, 第2組以降は最初の4年が1日少なく, 1460, 1461, 1461, ..., 1461となる.

このような問題提起について, d日目を入力し, その該当する年yと, その年内の日数d'を計算する方法を探した.

何万日を扱うのも憂鬱なので, とりあえず, 先頭が1多い4日, 3日, 3日, 3日のパターンと, 先頭が1少ない, 3日, 4日, 4日, 4日のパターンを考える.

4,3,3,3のパターンでは, 総日数は13日で, 0≤d<13に対し,


d         y  d'
0,1,2,3   0  0,1,2,3
4,5,6     1  0,1,2
7,8,9     2  0,1,2
10,11,12  3  0,1,2

また, 3,4,4,4のパターンでは, 総日数は15日で, 0≤d<15に対し,


d             y  d'
0,1,2         0  0,1,2
3,4,5,6       1  0,1,2,3
7,8,9,10      2  0,1,2,3
11,12,13,14   3  0,1,2,3

となるようにしたい.

前者については


(define (foo d)
(let ((y (floor (/ d 3.25))))
(list y (+ d -13 (floor (* 3.25 (- 4 y)))))))

とする. 13は総日数, 4は年の幅, 怪しげな3.25は13/4である.

後者については


(define (bar d)
(let ((y (- 3 (floor (/ (- 14 d) 3.75)))))
(list y (- d (floor (* y 3.75))))))

とする. 14は総日数-1, 3.75は総日数の15を4で割ったものだ.

とりあえず, これでdに対して(y d')を求めてみると


(map foo (a2b 0 13))
=>((0 0.) (0. 1.) (0. 2.) (0. 3.) (1. 0.) (1. 1.) (1. 2.)
(2. 0.) (2. 1.) (2. 2.) (3. 0.) (3. 1.) (3. 2.))

(map bar (a2b 0 15))
=>((0. 0.) (0. 1.) (0. 2.) (1. 0.) (1. 1.) (1. 2.) (1. 3.)
(2. 0.) (2. 1.) (2. 2.) (2. 3.) (3. 0.) (3. 1.) (3. 2.) (3 3.))

とうまく行きそうである.

fooとbarの図を描いてみるとこうなる. 上がfoo, 下がbar.

図でははっきりしないが, dに対するfloorを取る前の値は
(0 .31 .62 .92 1.23 1.54 1.85 2.15 2.46 2.77 3.08 3.38 3.69)
と
(3.73 3.47 3.2 2.93 2.67 2.4 2.13 1.87 1.6 1.33 1.07 .8
.53 .27 0)
である.

そこで, この3とか4とかを実際の値に変えて関数を書き, クリティカルな値に対してテストすると次の通りだ.


(define (foo d)
(let ((y (floor (/ d 36524.25))))
(list y (+ d -146097 (floor (* 36524.25 (- 4 y)))))))
(map foo '(0 36524 36525 73048 73049 109572 109573 146096))
=>((0 0.) (0. 36524.) (1. 0.) (1. 36523.) (2. 0.) (2. 36523.)
  (3. 0.) (3. 36523.))

(define (bar d)
(let ((y (- 24 (floor (/ (- 36523 d) 1460.96)))))
(list y (- d (floor (* y 1460.96))))))
(map bar '(0 1459 1460 2920 2921 4381 4382 5842 33602 35062
  35063 36523))
=>((0. 0.) (0. 1459.) (1. 0.) (1. 1460.) (2. 0.) (2. 1460.)
  (3. 0.) (3. 1460.) (23. 0.) (23. 1460.) (24. 0.) (24 1460.))

(define (foo d)
(let ((y (floor (/ d 365.25))))
(list y (+ d -1461 (floor (* 365.25 (- 4 y)))))))
(map foo '(0 365 366 730 731 1095 1096 1460))
=>((0 0.) (0. 365.) (1. 0.) (1. 364.) (2. 0.) (2. 364.)
  (3. 0.) (3. 364.))

あとはこれを繋げるだけ. 注意すべきは, Calendricalの方は1年1月1日から始まるのに対し, こちらは0年から399年までの400年から始まるので, 0年分の366日を足す; Calendricalは1月1日のfixed dateが1なのに対し, こちらは, 0年1月1日が0なので1日分の修正が必要だ. この修正の結果がd0である. 400年のところは, 常に146097日なので, 計算は簡単だ. 残りは上の関数を利用している.


(define (gr rd)
(let* ((d0 (+ rd 366 -1))
       (y400 (quotient d0 146097))
       (d1 (modulo d0 146097))
       (y100 (floor (/ d1 36524.25)))
       (d2 (+ d1 -146097 (floor (* 36524.25 (- 4 y100)))))
       (y4 (if (= y100 0) (quotient d2 1461)
           (- 24 (floor (/ (- 36523 d2) 1460.96)))))
       (d3 (if (= y100 0) (modulo d2 1461)
           (- d2 (floor (* y4 1460.96)))))
       (y1 (if (and (> y100 0) (= y4 0)) (quotient d3 365)
           (floor (/ d3 365.25))))
       (d4 (if (and (> y100 0) (= y4 0)) (modulo d3 365)
           (+ d3 -1461 (floor (* 365.25 (- 4 y1))))))
       (y (+ (* y400 400) (* y100 100) (* y4 4) y1))
       (leap (if (= (modulo y 100) 0) (= (modulo y 400) 0)
           (= (modulo y 4) 0)))
       (e (if leap
        '(0 31 60 91 121 152 182 213 244 274 305 335)
        '(0 31 59 90 120 151 181 212 243 273 304 334)))
       (mon (apply + (map (lambda (f) (if (<= f d4) 1 0)) e)))
       (d (- d4 (list-ref e (- mon 1)) -1)))
    (list y mon d)))

テスト


(gr 1) => (1. 1 1.)
(gr 734274) => (2011. 5 16.)

こんな具合いだが, まぁいいか.

曜日の計算

2011-05-23T08:52:00.006+09:00

森本雅樹君の追悼文集, 「森本さんの宇宙」の最後の年表「森本おじさんの足跡」に「1932年5月14日(何曜かわかりますか) 東京に生まれました」と書いてある. よし, 計算しよう.

その頃の日付と曜日の組で分かっているのは, 1941年12月8日が月曜ということだ. 太平洋戦争開戦の日を私は記憶している. その日, 学校に行ったという他は曜日は怪しい(月曜だったらしいというかすかな記憶はあるが). 一方, ハワイの軍港は, 12月7日の日曜で, 軍艦にいない水兵が多かったという話から, 12月8日は確かに月曜であったろう. その前, 数年の12月8日の曜日を書いてみると,

1941 月
   40 日うるう年
   39 金
   38 木
   37 水
   36 火うるう年
   35 日
   34 土
   33 金
   32 木

従って, 1932年12月8日は木曜だ. 12月12日と5月9日の曜日は同じだから, 5月14日曜日は木曜の4日後の5日後だから, 土曜か.

そこで, 手元のHHC電卓で確認する. 1932年5月14日を19320514と入力し, JDを押すと2426842. それに1を足して7で割る. 商は346691. 剰余は6. たしかに土曜であった.

ついでに,... 手元にMacBookもあるから, 道具がますます高級になり,


% cal 5 1932
      May 1932
 S  M Tu  W Th  F  S
 1  2  3  4  5  6  7
 8  9 10 11 12 13 14
15 16 17 18 19 20 21
22 23 24 25 26 27 28
29 30 31

個人用電卓のプログラミング

2011-05-19T23:28:00.002+09:00

またThe Art of Happy Hacking Calculator Programmingの話だ. 2年ほど前のこのブログに, 私のデザインしたHappy Hacking Calculatorのプログラミングの話を何回か書いた. 例えば1から10までの和のプログラムは,


(0Ua"N+U1-"_aG^N)X=

factorialは


("_6_G1+5_"G"1-!*)!=

という具合いである. Gの命令について復習すると, スタックの上から2段目の内容が負なら, プログラム制御をスタック最上段の数だけバックする(左へ進む), 非負ならそのまま進むというのであった. そこで, プログラムを書くのに面倒なのは, 飛び先までの長さの計測である. factorialのプログラムの左から5文字目のGはスタックの最上段に-6があるので, その下が負なら, 右へ(1+5_"G)の6文字を飛び越えることを示す. つまり右のGの次の"のところだ. 当時のプログラムでは, 長さのところを空けておき, 他が出来てから手作業で長さを数えていた.

またこの図の左のようだと, G命令から10文字左へ飛び, 右のようだと9文字左へ行く. それが同じ場所である. 従って, 工夫によってはプログラムが短く出来る.

これをなんとか自動化したい, つまりコンパイラを書きたいとかねがね考えていた.

飛び先までの間に条件付きのbranch命令や無条件のjump命令があると, そのパラメータの文字数が未定であったりするので, 自縄自縛(という表現が適切かな)になり, コンパイラの書き方が決らなかった.

最近, 思いついた方法があり, それでプログラムを生成してみたが, なんとかなりそうである. そのことを書きたい.

コンパイルされるプログラムはこんな形をしている.


(define sum '(0 up 10 'foo dup down + up 1 - dup neg
 (branch foo) pop down 'exit))

(define factorial
'(dup neg (branch bar) 1 ent (branch exit) 'bar
 dup 1 sub ! * 'exit))

(define ackermann '(
dup 1 - (branch a) exch dup 1 - (branch b)
exch dup 2 - (branch c)
up dup 1 - exch down 1 - A A (jump exit)
'c pop pop 2 ent (jump exit)
'b pop 2 * (jump exit)
'a pop pop 0
'exit
))

sumが10までの和のプログラムで, クォートされているリスト内がプログラム本体である. 0とか10は定数で, そのまま文字に置き換わる. 今の版ではコンパイラの関数によって十進だったり十六進数だったりする. up, dup, down, +, -, negなどが, プログラムの命令だ. (このAckermann関数は, SICPのex1.10にあるものだ.)

(branch foo)はfooへのbranch命令を挿入することを示す. その飛び先は'fooのところである. jump命令では, スタックの判定用に無理に負の数をおいて常に飛ぶのである.

それぞれの図の箱は, 長さ固定のプログラム. その間のb_mやその間j_mはbranchやjump命令. 矢印はそこから飛ぶ飛び先で, l_nは飛ぶ長さである.
b_mやj_mは, 対応する飛ぶ距離l_nの文字に変換した長さlに,


a. 左へのbranchはlの次にGの1文字,
b. 右へのbranchはlの次に_とGの2文字,
c. 左へのjumpは1_の2文字とlの次にGの1文字,
d. 右へのjumpはlの次に_"Gの3文字
をつける. つまり追加文字数は, a, b, c, dのそれぞれで, 1, 2, 3, 3である.

ackermannのプログラムは, 二進十進(あるいは十六進)変換を


(define (f n)
 (if (< n 10) 1 (if (< n 100) 2 3)))

と定義し,


(define b0 0)
(define b1 0)
(define b2 0)
(define j0 0)
(define j1 0)
(define j2 0)

(define (iter)
 (let* ((l0 (+ 4 b1 4 b2 10 j0 4 j1 3 j2))
        (l1 (+ 4 b2 10 j0 4 j1))
        (l2 (+ 10 j0))
        (l3 (+ 4 j1 3 j2 3))
        (l4 (+ 3 j2 3))
        (l5 3)
        (c0 (+ (f l0) 2))
        (c1 (+ (f l1) 2))
        (c2 (+ (f l2) 2))
        (k0 (+ (f l3) 3))
        (k1 (+ (f l4) 3))
        (k2 (+ (f l5) 3)))
(if (equal? (list c0 c1 c2 k0 k1 k2) (list b0 b1 b2 j0 j1 j2))
    (list b0 b1 b2 j0 j1 j2 l0 l1 l2 l3 l4 l5)
    (begin (set! b0 c0) (set! b1 c1) (set! b2 c2)
           (set! j0 k0) (set! j1 k1) (set! j2 k2) (iter)))))

のプログラムで(iter)とすると,

 (4 4 4 5 5 4 47 32 15 19 10 3)

が得られる. したがってb₀は47_G, b₁は 32_G, b₂は15_G, j₀は 19_"G, j₁は10_"G, j₂は 3_"G となる.

facotorialは


(define (iter)
(let* ((l0 (+ 2 b1))
       (l1 5)
       (c0 (+ (f l0) 2))
       (c1 (+ (f l1) 2)))
(if (equal? (list c0 c1) (list b0 b1))
    (list b0 b1 l0 l1)
    (begin (set! b0 c0) (set! b1 c1) (iter)))))

で,

(3 3 5 5)

が得られるから, b₀は 5_G, b₁も 5_G でよい.

10までの和は,


(2 9)

が得られ, b₀はすなわち9Gとなる.

以上は, それぞれの関数用のプログラムを実行した例だが, プログラムの半ばコンパイルした中間出力のリストを使うことも出来るようになった.

ackermann関数の例では, b_mやj_mをリストにし, プログラムのブロックをその長さl_nで置き換えた中間出力


((3 "\"1-") (b a 0 0) (4 ":\"1-") (b b 0 0) (4 ":\"2-") (b c 0 0)
 (10 "U\"1-:N1-AA") (j exit 0 0) c (4 "^^2E") (j exit 0 0)
 b (3 "^2*") (j exit 0 0) a (3 "^^0") exit))

から


"1-47_G:"1-32_G:"2-15_GU"1-:N1-AA19_"G^^2E10_"G^2*3_"G^^0

を得るプログラムは走るようになっているが, まだ改善の余地だらけで, 公開ははばかられる.

unix time

2011-05-18T20:29:00.006+09:00

前回のblog以後, ユリウス日を年月日に変換するプログラムも書きたくなっている.

私の愛読書の1つ, E.M.Reingold, N. DershowitzのCalendrical Calculationsでその辺の計算法を見てみよう. ユリウス日は, Julian暦-4712年1月1日が起点だが, 本書のカレンダーの起点は, Gregorian暦を昔の方へ外挿した1年1月1日を1とし, それからのFixed Day Numberで表わす. この日数をR.D.(Rata Die, fixed dateのラテン語)という.

本書の関数は, 本文では不思議な構文で書いてあり, 付録にはCommon Lispによる実装があるが, Scheme風にすると,


(define gregorian-epoch 1)
(define (gregorian-leap? y)
 (and (= (modulo y 4) 0)
   (not (member (modulo y 400) '(100 200 300)))))

(define (fixed-from-gregorian y m d)
 (+ gregorian-epoch -1 (* 365 (- y 1)) (quotient (- y 1) 4)
    (- (quotient (- y 1) 100)) (quotient (- y 1) 400)
    (quotient (- (* 367 m) 362) 12)
    (cond ((<= m 2) 0)
      ((gregorian-leap? y) -1)
      (else -2)) d))

(fixed-from-gregorian 1 1 1) => 1
(fixed-from-gregorian 2011 5 16) => 734273

この本では, 年内の日数と月の変換は, 2月も30日あるとして計算し, 補正する


(map (lambda (m) (quotient (- (* 367 m) 362) 12)) (a2b 1 13))
=> (0 31 61 92 122 153 183 214 245 275 306 336)

floorをとらないと, 以下のような値である.


(.417 31. 61.583 92.167 122.75 153.333 183.917 214.5
245.083 275.667 306.25 336.833)

隣り同士の差を取ってみると,


(map (lambda (a b) (- a b))
 '(31 61 92 122 153 183 214 245 275 306 336)
 '(0 31 61 92 122 153 183 214 245 275 306))
=>
(31 30 31 30 31 30 31 31 30 31 30)

補正は, 1月2月はこのまま, 3月から後はうるう年なら1を引き, 平年なら2を引く.

さて, Gregorian暦のy, m, dからfixed dateを得る最初の関数fixed-from-gregorianの解説である.

前年までの経過日数が必要なので, (- y 1)が頻出する.


(* 365 (- y 1))      ;前年までの平日の日数
(quotient (- y 1) 4) ;Julian暦のうるう日の日数
(- (quotient (- y 1) -100)) ;100年の倍数の年はうるうをやめる
(quotient (- y 1) 400) ;しかし400年の倍数なら, やはりうる
う年にする
(quotient (- (* 367 m) 362) 12) ;2月を30日と仮定して, m月
の前月までの日数
(cond ((<= m 2) 0) ;補正
 ((gregorian-leap? y) -1)
 (else -2)) d))      ;dを足す.

最初のgregorian-epochは, 1年1月1日を1にするためである.
最後のテスト例のようにうまく行く.
予想通り, 逆は難しい. プログラムは以下のようだ.


(define (gregorian-year-from-fixed rd)
  (let* ((d0 (- rd gregorian-epoch))
         (n400 (quotient d0 146097))
         (d1 (modulo d0 146097))
         (n100 (quotient d1 36524))
         (d2 (modulo d1 36524))
         (n4 (quotient d2 1461))
         (d3 (modulo d2 1461))
         (n1 (quotient d3 365))
         (y (+ (* 400 n400) (* 100 n100) (* 4 n4) n1)))
  (if (or (= n100 4) (= n1 4)) y (+ y 1))))

(define (gregorian-from-fixed rd)
  (let* ((y (gregorian-year-from-fixed rd))
   (prior-days (- rd (fixed-from-gregorian y 1 1))     
　 (correction (cond ((< rd (fixed-from-gregorian y 3 1)) 0)
                ((gregorian-leap? y) 1
                (else 2)))
   (m (quotient (+ (* 12 (+ prior-days correction)) 373)
             367))
   (d (+ (- rd (fixed-from-gregorian y m 1)) 1)))
  (list y m d)))

(gregorian-from-fixed 1) => (1 1 1)
(gregorian-from-fixed 734273) => (2011 5 16)

と定義しておき, (gregorian-year-from-fixed rd)
で rd に対する年 y を計算する.

(n400 (quotient d0 146097)) :d0に400年の日数が何回あるか見る. 146097は400年の日数.
(d1 (modulo d0 146097)) :その400年内の日数

(n100 (quotient d1 36524)) ;その日数に100年は何回あるか. しかし400年の100年の日数は, 最初の100年の先頭の00年はうるう年なので, 36525日あるから

(d2 (modulo d1 36524)) ;その100年内の日数
(n4 (quotient d2 1461)) ;その日数内の4年の数
(d3 (modulo d2 1461)) ;その4年内の日数
(n1 (quotient d3 365)) ;4年内の1年の数
(n1 (quotient d3 365)) ;4年内の1年の数

基数変換をやっているみたいに簡単なのに驚く. 400年の中の日数d1のいろいろな値から得られるyをみてみる.


(define (gregorian-year-from-fixed rd)
  (let* ((n100 (quotient rd 36524))
         (d2 (modulo d 36524))
         (n4 (quotient d2 1461))
         (d3 (modulo d2 1461))
         (n1 (quotient d3 365))
         (y (+ (* 100 n100) (* 4 n4) n1)))
  (if (or (= n100 4) (= n1 4)) y (+ y 1))))

すると, 以下のようになっていることが分かる.


       rd       y                 rd       y
     0-   364   1   365     35794- 36158  99   365
   365-   729   2   365     36159- 36523 100   365
   730-  1094   3   365     36524- 36888 101   365
  1095-  1460   4   366
  1461-  1825   5   365     72318- 72682 199   365
  1826-  2190   6   365     72683- 73047 200   365
  2191-  2555   7   365     73088- 73412 201   365
  2556-  2921   8   366
  2922-  3286   9   365    108842-109206 299   365
  3287-  3651  10   365    109207-109571 300   365
  3652-  4016  11   365    109572-109936 301   365
  4017-  4382  12   366
  4383   4747  13   365    145001-145365 398   365
  4748-  5112  14   365    145366-145730 399   365
  5113-  5477  15   365    145731-146096 400   366
  5478-  5843  16   366

0から勘定を始めるのが基本と思っている私なら, 下の図の左のような関数を書くところだが, 本書の流儀は違う. d1=0ならy=1が返る. d1=146096なら, y=400であった. なるほど! (図の太い横線は366日の年を示す. 横線の左の黒丸は閉区間, 右の白丸は開区間を示す.)

別の図を描くと下のようになる. つまり, 図で網掛けの例外を最後に置くので計算が簡単になっていたのだ.

それなら, 私の流儀でも, 400年紀末から逆に計算すればおなじわけだった.

ところで, これではまだfixedから, 年が得られただけである. 本番のプログラムはこれを下請けに使う(gregorian-from-fixed d)である. その解法はこうだ.

とりあえずこのrdの落ちるyを求める. 次のその年の1月1日のfixed dateを求め, prior-daysとする. その年の3月1日のfixed dateを求め, prior-daysがそれより小さければ, 補正は0, そうでなくて, うるう年なら補正は1, 平年なら補正は2である. 次に前に日数を計算した式で, 月を見つけ, その月の1日のfixed dateとの差から, 日が分かるのである.

fixed-dateを何回も使うが, それだけ分かりやすいアルゴリズムになっている.

こういうプログラムの解読もなかなか面白い.

unix time

2011-05-16T13:45:00.003+09:00

unixには1970年1月1日正子(0時0分)からの延秒数を数えている32ビットの時計がある. 2038年1月19日にサインビットが立つといわれ, 2000年問題みたいになにか起きかもしれないが, 私は多分もうこの世にはいず, 状況を知ることはかなわぬ.

この時計の元は, MITのMulticsではないか. Multicsには, 1900年1月1日正子からのマイクロ秒を数える52ビット時計があった. マイクロは10^-6だから, 20ビット程度であり, unixの32ビットに対して52ビットなのは分かる. 私がMITに滞在したのは, 1973年9 月から74年7月までだが, その時計のサインビットが立ったのは, その少し前のたしか5月だったとある院生から聞いた.

まず脱線して, それがいつだったか計算してみよう. 例の個人用電卓が活躍する. 2⁵¹は2251799813685248. これを1日のマイクロ秒864000000000で割る.

商は26062, 剰余は43013685248. つまり1900年1月1日から26062日後を知りたい. それには1900年1月1日のユリウス日2415021に26062を足し, その2441083がユリウス日になる日を知ればよい.

ここから先は電卓から離れ, 理科年表のユリウス日の表による.

すると, 1971年5月11日がその日であることが判明. 日以下を計算すると, 11時 56分 53秒 685248マイクロ秒であった.

jdをユリウス日を計算する関数として, Schemeで検算すると,


(+ (* (- (jd 1971 5 11) (jd 1900 1 1)) 86400000000)
   (* 11 3600000000) (* 56 60000000) (* 53 1000000) 685248)
=> 2251799813685248

(factorize 2251799813685248)
=>
(2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2
 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2)

(length (factorize 2251799813685248)) => 51

本題へ戻り, 通常のy年mon月d日h時min分s秒からunix timeへの変換の方は, Multicsの場合と同様に簡単だ.


(JD(y,mon,d)-JD(1970,1,1))*86400+h*3600+min*60+s

となる.

一方, unix time tからy,mon,d,h,min,sへの変換は, ユリウス日からy,mon,dへの変換関数があればなんでもないが, まだそういうプログラムは書いたことがない.

カレンダーの変換で一番面倒なのは, Grogorian暦でのうるう年の計算である. しかし, ことunix timeに限れば, 2000年が通常のうるう年なのが幸いだ. そこで書いたのが次のSchemeのプログラムである.


(define (unixtime t)
 (let* ((s (modulo t 60)) (m (quotient (modulo t 3600) 60))
  (h (quotient (modulo t 86400) 3600)) (d (quotient t 86400))
  (y (- (floor (/ (+ d 731) 365.25)) 2))
  (c (- d (floor (+ (* y 365.25) 0.25))))
  (e (if (= (modulo y 4) 2)
        '(0 31 60 91 121 152 182 213 244 274 305 335)
        '(0 31 59 90 120 151 181 212 243 273 304 334)))
  (n (apply + (map (lambda (f) (if (<= f c) 1 0)) e))))
 (list (inexact->exact (+ 1970 y)) n
  (inexact->exact (- c (list-ref e (- n 1)) -1)) h m s)))

引数のtがunixtimeである. 最初にs(秒), m(分), h(時)を取り出す. dは通算の日数になる. その後の変数は, yが1970年以降の年数, cがその年内の日数, nが月だ. yはdを365で割ってfloorを取ればよいが, 閏年があるからそうは問屋が卸ろさない.

まず, y年について, 前の年の終りまでの日数は,

欲しい値は,

365の代りに365.25で割ればよさそうに見えるので, 2.25でテストしてみる.


(map (lambda (n) (floor (/ n 2.25))) (a2b 0 20))
=> (0 0. 0. 1. 1. 2. 2. 3. 3. 4. 4. 4. 5. 5. 6. 6. 7. 7.
   8. 8.)

4が3個並ぶのがうるう年に対応し, これを2年にしたいから, 3つの0と2つの1の5個をスキップするために, nの代りに(+ n 5)とし, 最後に2を引く.


(map (lambda (n) (- (floor (/ (+ n 5) 2.25)) 2)) (a2b 0 20))
=> (0. 0. 1. 1. 2. 2. 2. 3. 3. 4. 4. 5. 5. 6. 6. 6. 7. 7.
   8. 8.)

なるほどうまくいくので, 356.25に修正し, テストする.


(map (lambda (n) (- (floor (/ (+ n 366 365) 365.25)) 2))
'(0 364 365 729 730 1095 1096 1460 1461 1825 1826 2190
   2191 2555))
=> (0. 0. 1. 1. 2. 2. 3. 3. 4. 4. 5. 5. 6. 6.)

うまくいく. これを1970に足せばよい.

次に上の表にあった前年までの日数の和を計算するには,


(lambda (y) (+ (* y 365) (quotient (+ y 1) 4)))

か


(lambda (y) (floor (+ (* y 365.25) 0.25)))

とする. これをdから引くと, その年内の日数cが得られる. 前の年の終りまでの日数の和のように, 前の月の終りまでの日数の和のリストを, うるう年か否かで変数eに用意する.

月nは, このリストで, cが越えるものの数として得る. nが決れば, 月内の日数は, cから先ほどのリストの要素を引いて作る.

これで完成. テストしてみる.


(unixtime 0) => (1970 1 1 0 0 0)
(unixtime (expt 2 31)) => (2038 1 19 3 14 8)

加算の順序

2011-05-10T16:02:00.002+09:00

桁数が多い十進数でも, その筆算による足し算は小学校で習う. 最近のことは知らぬが, 昔は算盤も小学校で習った.

ところで, 筆算は下の桁から始め, 算盤は上の桁から足し始める. もちろん, 結果は同じになる. これは一体どういうことかと, 子供のころ不思議であった.

実は, 足し算(引き算もだが)は, 繰上げを正しく処理し, 全部の桁について加算するなら, どの順に桁を選んでやっても構わないのである.

算盤で 8 8 8 8 8 8 8 8 に 1 1 1 2 1 1 1 2 を足すとき, まず最初の3桁で,


8 8 8 に
1 1 1 を足すと
9 9 9 になる.

次に8に2を足すから, 10になるが, 算盤流では8を払ってその桁を0にしてから, 繰上げ処理に入る. つまり, 次の9に1を足す. それには9を払い, さらに繰上げを処理する. 3つの9から繰上げが続き, 9の上の桁に1がでて止る. 都合4回繰り上げた. 繰上げをピリオドで示し, これを 1.0.0.0.0 と表わす.

その次に3回9が得られ, 1.0.0.0.0 9 9 9 となり, 最後の8+2でまた繰上げが発生. 4回繰り上げて1.0.0.0.1.0.0.0.0 が得られる.

以上が算盤であった.

筆算だと右端の8+2から始め, この桁の結果が0, 繰上げがでる. 従って .0 となり, 繰上げがあったことを記憶して, 次の8+1に進む. この和は9だが, 繰上げがあったので, 0になって再び繰上げを記憶, 次へ進む. このようにして, .0.0.0.0 まで来た. 次は8+2なので, 和は10. それに繰上げで11になり, この桁が1となり, さらに繰上げが続く. こうして,1.0.0.0.1.0.0.0.0となる.

左右のどちらから計算しても, 繰上げの出る場所は決っている.

タイガーのような計算機ではどうか.


8 8 8 8 8 8 8 8 に
1 1 1 2 1 1 1 2 を足すと一旦
9 9 9.0 9 9 9.0 となり,

繰上げが発生した場所がマークされる. その後, 下の桁から繰上げセンサーがマークをスキャンし始める. マークがあると, 繰上げピンにより, 次の桁を1増やす. この結果繰上げが生じることがある. 今の場合もそうだ.

9 9 9.0 9 9.0.0 となり, スキャンは今つけたマークのところに来る. そして9を0にし, 次に桁との間にマークする. 繰上げで1増やそうとするとき, その桁が9でなければ繰上げ処理は終る. 0のところが 1.0.0.0.0 となるが, その次にすでにマークがあるので, 続く9を次々を0にして繰上げを伝える.

結局, 上の算盤や筆算と同じ場所で繰上げが生じ, 同じ結果になる.

足し算をランダムな順でやってみよう.


  0 3 6 2 7 5 1 4 ← 足す順
  1 1 1 2 1 1 1 2 ← 足す数
  8 8 8 8 8 8 8 8 ← 元の数

まず順が0の桁で足す. 従って

  0 3 6 2 7 5 1 4 ← 足す順
  1 1 1 2 1 1 1 2 ← 足す数
  9 8 8 8 8 8 8 8 ← 元の数

となる. 繰上げはない. 次に順が1の桁へ行く.

    3 6 2 7 5 1 4 ← 足す順
    1 1 2 1 1 1 2 ← 足す数
  9 8 8 8 8 8 9 8 ← 元の数

順が2の桁へ行く

    3 6 2 7 5   4 ← 足す順
    1 1 2 1 1   2 ← 足す数
  9 8 8.0 8 8 9 8 ← 元の数

と繰上げが生じたからその処理をして

    3 6 2 7 5   4 ← 足す順
    1 1 2 1 1   2 ← 足す数
  9 8 9.0 8 8 9 8 ← 元の数

順が3の桁

    3 6   7 5   4 ← 足す順
    1 1   1 1   2 ← 足す数 
  9 9 9.0 8 8 9 8 ← 元の数

順が4の桁, 繰上げも処理する.

      6   7 5   4 ← 足す順
      1   1 1   2 ← 足す数
  9 9 9.0 8 9.0.0 ← 元の数

順が5の桁

      6   7 5     ← 足す順
      1   1 1     ← 足す数
  9 9 9.0 9.0.0.0 ← 元の数

順が6の桁

      6   7       ← 足す順
      1   1       ← 足す数
1.0.0.0.0 9.0.0.0 ← 元の数

順が7の桁
          7       ← 足す順
          1       ← 足す数
1.0.0.0.1.0.0.0.0 ← 元の数

これで, お勧めはしないが, どういう順に足してもよさそうだと分かる.

十進法の2つの数を足すとき, 各桁で加算し, 仮の和 0≤t<19を得る.

それと下の桁からの繰上げの有無により, その桁の真の和と, 上の桁への繰上げが得られる.

t<9なら, 繰上げのありなしに拘らず, 上の桁への繰上げは生じない. 真の和は, 繰上げがないならt, あるならt+1.

t=9で, 繰上げがないなら, 繰上げは生じず, 真の和は9. 繰上げがあるなら, 繰上げが生じ, 真の和は0.

10≤tなら, 繰上げのありなしに拘らず, 上の桁への繰上げが生じる. 真の和は, 繰上げがないならt-9, あるならt-10.

上の加算の例でいうと,


  8 8 8 8 8 8 8 8
  1 1 1 2 1 1 1 2
  9 9 9 0 9 9 9 0 ← 仮の和
       .       .  ← 繰上げ
      0       0   ← 真の和
     .       .    ← 繰上げ
    0       0     ← 真の和
   .       .      ← 繰上げ
  0       0       ← 真の和
 .       .        ← 繰上げ
1       1         ← 真の和

古い計算機

2011-04-29T11:06:00.008+09:00

今回はPascalが発明したといわれる計算機, パスカリーヌの繰上げ処理のことを書きたい.

Pascalは1623年生まれ. 計算機を考えたのが1642年から45年だから, 20歳くらいのことになる.

そんなに高級なことが出来たわけではなく, 例によって歯車にスタイラスを指してぐるーっと回すと, その分だけ加算出来, 結果が表数車に現れるという代物である. 減算は補数を足して実現したようだ. つまり歯車類は, 一方向にだけ回転する構造であった.

ウェブページにあった図を一つ借用すると, 計算機構は下のようになっていたらしい.

図の 0 と 1 は表数車で, パスカリーヌは十進法以外にも対応していたらしいが, 一応は外側に0から9と, 内側にその補数が書いてあった. 2 は歯止めである. 歯車といっても, 精密な工作は出来ぬ時代なので, 円周から棒がたっている程度のもので, むかしのからくりでよく見かけるものがあり, 歯止めはそれを上から重力で押さえている.

図の 3 はベベルギアの片割れである. 下の方の図にも 3 はあるが, 表面の歯車をスタイラスで回すと, このベベルギアで水平面の軸の回転に変わる. この軸が1段の歯車を介して表数車を回す.

ところで繰上げは, 下の桁の水平軸の用意した2本のピン 4 が主役である. 軸が図でみて時計方向に回ると, このピンは, 上の桁の水平軸で回転する 5 のフォーク状のフックを押し上げ始める. やがて 4 は 5 の下から抜けるが, それがちょうど表数車が9から0になる時で, フックが重力で墜落することにより, 上の桁のピン 6 が押されて, 繰上げを生じる仕掛けである.

繰上げ処理には, 力がいるのが普通だが, パスカリーヌでは重力を利用するのが面白い. 表数車が5, 6, 7, 8と回るにつれ, ポテンシャルを高めていき, 9を過ぎると一気に落ちるのである.

私はこの仕掛けをみると, 昔のテレタイプを思い出す. テレタイプは1文字ずつ受信, 印字しながら, 印字位置が次第に右に移動し, 復帰信号を受信すると印字位置を左端へ戻すのだが, このエネルギーは, 印字位置を右に移動するときにためていく. 復帰でフックがはずれ, 蓄えたエネルギーで左端へ飛んで戻るが, 最後にダッシュポットがあって, ブレーキをかけ, 静止する. 従って, 左からほんの数文字を印字した後の復帰では, 力が弱く, 左端まで充分戻れないこともあった.

これは, 手動のタイプライタとは, 全く反対のエネルギーの使い方であった. 手動のタイプライタでは, 手でプラテンを右に寄せると, その時にエネルギーを蓄えるのであった. 1文字打つたびに, そのエネルギーにより, プラテンが左へ送られるのである.

パスカリーヌのこの動きを, いつものようにポストスクリプトで描いたのが次の紙芝居である. 4 あたりから, ピンがフックを押し上げ始め, 9 で最高点に達する. その直後にフックは墜落し, 上の桁のピンを回す.

いかにもうまく行きそうだが, 繰上げが続くと, 2, 3段で駄目になったという説明を読んだようにも思う. なお上の図の動画がhttp://playground.iijlab.net/~ew/pascalinecarry/pascalinecarry.htmlにある.

八進法算盤

2011-04-05T20:21:00.006+09:00

以前このブログに八進法算盤のことを書いた(2008年9月14日). 今回もその話題だ.

前回のブログを書いたころ, 八進法の算盤は私のが最初だろうと思っていた. しかし, 東京理科大学の近代科学資料館で蒐集した算盤群を眺めて目をこする.

手前にあるのは下が3珠の算盤ではないか! これは八進法用なのか. 説明がないから目的は皆目不明である. この算盤の奥には, なんやら二進法の算盤らしいものさえある. 故事来歴を知りたいところである.

ところで...
子供のころ, 学校で算盤を習った. もちろん十進法の算盤である. すこし使い方を覚えると, 1+2+...+10とかやってみたくなる. 答が10までなら55, 100までなら5050なのは, 周知のとうり.

自作の八進法の算盤でも, 1から八進法の10まで足してみると, 上の(天の)珠が並び, 44になって驚く. 同じパターンだ. これは偶然であろうか. たしかに1+2+...+8=36. これは4*8+4だから44なわけだ.

Gaussが子供のころ, 1+2+...+100を計算するのに, (1+100)+(2+99)+...とやった逸話は有名である.

その伝でいくと, 十進法で1から10まで足すのは, まず10を除外し, 1+9, 2+8,...を作るとそれらも10で, 4通り出来る. 5は継子になる. 合計55の1の桁の5は, その継子の5である. 4通りの10と, 最初に除外した10と合わせると10も5組になり, 55になる. この推論はこのまま八進法に適応出来る. なーんだという気分. 八進法の100までの和も4040だ.

もっと一般的にやろう. 2n進法で1から2nまで足すと, 2n(2n+1)/2=n(2n+1)だから, 2nの桁も1の桁もnになるのだね.

Gaussは子供のころ家が貧しかったせいか, こういう神童的な話が伝わる. Gaussが自分で復活祭の日取りを計算する式を考え出したのは, 母親がGaussの誕生日もろくに覚えていないような人だったかららしい.

Gaussといえば, 高木先生の解析概論に, 「Wolframの表には1000以下の素数の自然対数の50桁の表が掲げられてゐる. この表は既に少年がうすが愛用したものである.」という脚注がある. どんな表なのか興味はある. そのWolframはMathematicaのWolfram Researchとは関係ないはずだが, おなじWolframなのも何かの因縁であろう.

さて, iPod touch用に私が開発した電卓は, 八進法, 十進法, 十六進法の各基数で計算が出来る. 基数を十進法に設定し, 10 Ent 11 * 2 /とすると55; 八進法, 十六進法で全く同じ入力をすると, 44と88になり, 当然とはいえ, 楽しい.

古い計算機

2011-04-04T11:01:00.006+09:00

前回のブログのDial-A-Maticの計算機の特許の図で, その上方にある歯止めの機能を理解したいと思い, ひがな一日PostScritpで描いた図をこねくりまわした.

すなわち, ダイアルと伝達歯車と歯止めを表示し, パラメータを変えて, ダイアルを少しずつ回転しながら, この点とこの点が接しているはずと, 伝達歯車や歯止めの回転角度を繰り返し調整した.

ダイアルが加算方向に右回転し, 状態が9から0になって繰上げが出る過程の最初が0番の図で, それから以下の紙芝居, あるいはパラパラ漫画は始まる. それぞれの図の右上の番号nは, ダイアルの0番からの回転角が3n度であることを示す.

鳥のようにも見える歯止めには, 左と右に下向きの三角がある. 左のをストッパー, 右のをフォロワーといおう.

最初の0番では, 歯止めは伝達歯車の2本のピンの間をしっかり押さえている. 1番の図に向って, ダイアルの右回転を始めると, ダイアルの突起が伝達歯車のピンを押し, 伝達歯車が左回転し始める. それにより歯止めのストッパーの斜辺が, ピンで上に押され, 歯止めは右に傾く. 1番以降, 赤線は0番の位置を示す.

2番と3番では, ダイアル, 伝達歯車, 歯止めの回転が継続中.

4番. 伝達歯車のピンによるストッパーの押し上げはここまで. つまり歯止めの右回転は終り. この後しばらく, フォロワーはダイアルの0の数字の上の谷の部分を移動する.

6番. 18度回転したので, 状態9と0との中間点に来た.

9番から10番にかけて, フォロワーは0の数字の左の斜面に当り, 押し上げられ, 左回転を始める. 同時にストッパーが, 次のピンの間に下がり始める.

12番でダイアルは36度回転し, 状態0になる. しかし, ストッパーはピンの間に充分には下がっていない.

13, 14, 15番で, 状態が0からさらに1へと変る時, 数字1の方にある高い山の斜面でフォロワーが押し上げられ, ストッパーが伝達歯車のピンの間にしっかり止る.

フォロワーを押し上げる斜面が, なぜ2つに分かれているかは, 残念ながら未解決である. また, 歯止めは, ダイアルの急回転により, 繰上げが2回生じるのを防ぐのが目的なのだが, 8番の図で, ストッパーが上がっている間に, もう1本のピンもストッパーの下を通過しそうにも思える. その辺りも解明出来ていない.

前回も引用した, 繰上げ処理に詳しいウェブの最後の方に, この計算機の内部の写真が2つある. 特許の図の上の写真は, 蓋を取ったものであり, 最後のは, 教育用に蓋を透明にしたものだ. これ, 欲しいなぁ.

古い計算機

2011-04-02T11:50:00.004+09:00

このブログに何回か書いた昔の計算機は, タイガー計算器のような乗除算は出来ないが, 簡単な加減算ならお手の物だ. そういう計算機をウェブページで探していたら, Sterling Dial-A-Maticというのを見つけた. これが理科大の近代科学資料館にあったかどうかは分からぬ.

John Wolffさんのウェブページには, 1950年代かとある.

この画像を頂いたもとのURLが思い出せないのが申し訳ない.

プラスティック製だから, 古いとはいえない. 古いのと同じく簡単なのである. 簡単なので, 筆箱に蓋に組込める. この計算機を使うにはスタイラスがいるが, スタイラスが筆箱に仕舞えるのも都合がいい.

この計算機は十進4桁. 右からunits(一の桁), tens(十の桁), hundreds(百の桁), thousands(千の桁)である. それぞれの桁にnを足すには, 周囲に書いてある外側の大きい数字のnのところの穴にスタイラスを差し, 馬蹄形の最後まで右に回す.

nを引くには, 内側に書いてある小さい数字のnの穴にスタイラスを差し, 左に回す.

すると上の穴にその桁の答が現れる.

予想されるように, 繰上げ, 繰下げは正しく反映される.

2桁だけを書き出すと次の図だ.

中が気になるが, 繰上げ処理に詳しいウェブにこの計算機の説明があり, そこからUS Patent 2,797,047に辿り着ける. するとこういう図を始めいろいろ見つかる.

特許の図だからごちゃごちゃしているし, 説明も回りくどい. 今回はそれを私なりに説明したい. 十進歯車の相当する円盤の上方にカムのような切り込みがあり, それに噛み合う上側の歯止めや下側のバネみたいなものは, 回転しすぎ防止と位置の調整用のものなので省略し, 特許の図の繰上げに本質的な部分を描くとこうなる.

この赤で示した蓋を外すと

になる. 右が一の桁のダイアル, 左が十の桁のダイアルで, その状態が真上にある数字で読めるように, 数字は放射状に書いてある.

中央に繰上げ用の伝達歯車があり, 歯は十の桁のダイアルの下の歯車と噛み合っている. 伝達歯車には, 緑で示す10本のピンが立っていて, またダイアルの2の数字の下あたりに, これも緑で示す突起とぶつかる高さになっている.

ダイアルが36度左回転して, 0から9の状態に変ると, 突起はピンに当って, 伝達歯車を36度右回転させる仕掛けである.

ここが繰上げ機構の微妙なところで, 一の桁のダイアルの繰上げは, 伝達歯車に伝わるが, 伝達歯車の回転は一の桁の突起に当ってはいけないのである. 従って, 突起はピンの外側の包絡円のすぐ外側に控えている.

この構造で伝達歯車と十の桁のダイアルを36度ピッタリに回すのはむずかしく, 従って, 特許の図では, 針金のバネでダイアルの下の歯車を, 定位置に止めようとする.

もう一つ微妙なのは, 一の桁のダイアルを, 勢い良く回転して, 繰上げを伝えた場合である. 突起がピンを急に押すと, 36度どころか, 72度まで回転してしまうかも知れない. これを防ぐのが, ダイアルの上の切り込みと歯止めである.

歯止めの動きはまだよく理解してはいないが, そういう機能である.

私がProcessingで描いたシミュレータが,
http://playground.iijlab.net/~ew/dialamatic/dialamatic.html
にある.

起動時には, 0 0 の状態である. 一の桁に1を足すには, 一のダイアルの大きい数字の横の円をクリックすると, 青色に変る. 右下の + の箱をクリックすると1が足される仕掛けだ. 引くには左下の - の箱をクリックする.

クリアの機能はない.

古い計算機

2011-03-18T13:02:00.002+09:00

東京理科大学の近代科学資料館で見かけた古い計算機に以下のようなのがあった.

白状するとどのように使うのかさっぱり分からなかった. 仕方なく, あとからウェブでいろいろ探し, やっとChadwick Magic Brain Calculatorの使用法というページを見つけた. そのページのと形は多少違うが, 同じシリーズである. Chadwickという会社製だが, 生産は日本と書くページもあった.

繰上げは人間オペレータに依存する, 実に簡単な仕掛けであった. いわばpoorman's calculatorである. 今回も私流の図で説明しよう. その前に, 最初の写真で, 左端にある針金は, 引き抜くとすべての桁を0にクリアする仕掛けである.

基本は, スタイラスを使ってAのような滑り板を, Bの青枠の操作窓の中で上下に動かす. Bの上右側の緑枠は結果窓である. 左側の結果枠は1桁上のもので, もっと左にあるべきだ. 操作窓の左の1から9は, 黒数字が加算用, 赤数字が減算用である.

十進歯車の役目を果たす滑り板には, 両側にスタイラスを掛ける窪みがある. 左側のが加減算用. 右側のが繰上げ, 繰下げ用である.

ある桁の操作窓には, Cのように, その桁の滑り板(の加減算用の窪み)が右に, その上の桁の滑り板(の繰上げ, 繰下げ用の窪み)が左に現れる. (今は見えないはずの滑り板も描いてある.) それぞれの反対側の窪みは関係ないから, 以後はDのように表わすことにする.

これからの説明は次の図による.

Aは, 緑枠に見るように, この桁と, すぐ上の桁がともに0の状態である. 加算の規則は, 操作窓の左の黒数字に対応する右の窪みにスタイラスを差し, そこが赤なら, 操作窓の下までスタイラスを押し下げる.

BはAの黒字1の窪みのスタイラスを下まで押し下げたところで, 状態1になり, 右の緑窓に1が見える.

CはBにさらに4を足したところだ. (状態は5)

スタイラスを差した場所か白なら, スタイラスの操作窓の上まで押し上げ, さらに左に押して, 上の桁の繰上げ, 繰下げ用の窪みに差し, 操作窓の左縁に沿い, 1段下げる. 操作窓の構造上, 1段しか下がらない. 従って, Cに5を足そうとすると, Cの黒5のところは白だから, 5の窪みを上まで押し上げ, (この桁は0になる.) さらにスタイラスを左に回し, 上の桁を1段下げて1にする. (Dになる.)

なにをやったかを算盤で説明しよう.

Aのように, ある桁が8とする. 1を足すには, 下の1を押し上げる. (Bになる.) Cのように, 8に3を足そうとすると, 11になり, この桁だけでは処理出来ず, この桁から(10に対する3の補数の)7を払って, 上の桁に1を足す. (Dになる.) これが滑り板の白部分に相当する. 上の図で, Cの5に5を足すのに, 補数の5を払って(上に押し上げて)上の桁に1を足したのである.

算盤の図のEは, 99に1を足すところで, 最も右の桁の9を払って, 次の桁に1を足そうとするが, その桁も9なので, 再び9を払い, さらに次の桁に1を足す.

残念ながら, Chadwick Brain Calculatorはそこまでは出来ない. 上の図のEが状態99で, 1を足すべく, スタイラスを上まで押し上げても, 左に繰上げの窪みがない. すぐ上の桁で繰上げが処理出来るところまでしか, この計算機は対応していない. 前記の使用法によると, こういう場合は, 上の桁にいき, そこは状態9のはずだから, 1の窪み(白)にスタイラスをいれ, 押し上げ, 左へ回して繰上げをせよと書いてある. 9への繰上げはひと様を使うのである.

減算の方法は説明するまでもないであろう. この計算機は1960年代まで売られていたらしい. ウェブを探すと, 類似の計算機はいろいろある.

Gaussの正十七角形

2011-03-16T08:31:00.003+09:00

高木先生の近世数学史談に, 19歳のGaussが, 1796年3月30日の朝, 正17角形の描き方に気づいた話が出ていることは, すでにこのブログで述べた(2008年12月12日). 今回はその計算を追ってみたい.

360°=17φ とおく. また,

cos φ+cos 4φ=a
cos 2φ+cos 8φ=b
cos 3φ+cos 5φ=c
cos 6φ+cos 7φ=d
a+b=e
c+d=f

とする. 「よく知られているように」 e+f=-1/2 (「...」内は高木先生)

ここでまずえ? と思う. 計算してみると,


(define pi (* 4 (atan 1)))
(apply + (map (lambda (n) (cos (* n (/ (* 2 pi) 17))))
  (a2b 1 9)))
=> -.4999999999999999

(いつものように(a2b m n)は[m .. n)を生成する.)

しかし, この図をみれば, 1辺の長さ1の正17角形の1辺の半分だから, 当然な話だ. つまり, 角CABは正17角形の外角なので, これがφ. 従って多角形の1辺を1とすると, ABがcos φ, CDがcos 2φ, EFがcos 3φ,... . cos 8φまでいくと, 頂点の8までの横軸の和になり, これはAからみれば-1/2なのは明らか. 一旦そうと分かると, よく知られているとも思える.^^)

「con nφ=cos(17-n)φに注意し, 簡単な計算によって」
2ab=e+f=-1/2
2ac=2a+b+d
2ad=b+c+2d
2bc=a+2c+d
2bd=a+2b+c
2cd=e+f=-1/2

これはなぜか. 正直に掛けてみる.
2ab=2(cos φ+cos 4φ)*(cos 2φ+cos 8φ)
=2cos φ*cos 2φ+2cos φ*cos 8φ+2cos 4φ*cos 2φ+2cos 4φ*cos 8φ.

三角法の公式を見ると,
cosα+cosβ=2 cos(α+β)/2*cos(α-β)/2
というのがあり, cosの積を和に出来る. これを使うとm>nとして,
2cos mφ*cos nφ=cos(m+n)φ+cos(m-n)φ
だから

2cos φ*cos 2φ=cos 3φ+cos φ
2cos φ*cos 8φ=cos 8φ+cos 7φ
2cos 4φ*cos 2φ=cos 6φ+cos 2φ
2cos 4φ*cos 8φ=cos 5φ+cos 4φ
と1から8までそろうから, e+fになる.

これを6回もやるのは面倒だから,


(define a '(1 4))
(define b '(2 8))
(define c '(3 5))
(define d '(6 7))
(define (foo m n) (list (min (+ m n) (- 17 m n))
  (abs (- m n))))
(define (prod x y)
 (sort (append (foo (car x) (car y)) (foo (car x) (cadr y))
  (foo (cadr x) (car y)) (foo (cadr x) (cadr y))) <))

と定義し,


(prod a b) => (1 2 3 4 5 6 7 8) = e + f
(prod a c) => (1 1 2 4 4 6 7 8) = 2a + b + d
(prod a d) => (2 3 5 6 6 7 7 8) = b + c + 2d
(prod b c) => (1 3 3 4 5 5 6 7) = a + 2c + d
(prod b d) => (1 2 2 3 4 5 8 8) = a + 2b + c
(prod c d) => (1 2 3 4 5 6 7 8) = e + f

「故に」
2ac+2ad+2bc+2bd= (上の真ん中の4行を足すから) 4a+4b+4c+4d=4e+4f=-2.

左辺は2(a+b)(c+d)=2efなので, ef=-1. e+f=-1/2だったから, 入試問題みたいだが,
x²+1/2*x-1=0
を解いて,
x=-1/4+√(17/16), x=-1/4-√(17/16),

高木先生は前のがeなのは数値的に分かるといわれるので, やってみる.


(apply + (map (lambda (n) (cos (* n (/ (* 2 pi) 17))))
  '(1 2 4 8)))
=> .780776406404415

一方


(- (sqrt (/ 17 16)) (/ 1 4)) => .7807764064044151

eとfが分かったが, まだφが4つも入っているので, aやbを知らなければならない. 幸い, aとbの和(= e)と積(= -1/4)も分かったので, 先ほどと同様に解ける. 後は数値計算だから, WolframAlpha様にお出まし願う. 入試の答をインターネットに聞くのは止めた方がよさそうだが, いまは試験ではないので許されよう.

solve x^2-(-1/4+sqrt(17/16))*x-1/4=0
と入力すると,
x=1/8{-1+√17±&radic(16+(1-√17)²)}
と出た. 高木先生のとすこし違って見えるが, 16+(1-√17)²が34-2√17なので安心する. つまり,

a=1/8{-1+√17+&radic(34-2√17)}
b=1/8{-1+√17-&radic(34-2√17)}

cとdも同じように得られる.

c=1/8{-1-√17+&radic(34-2√17)}
d=1/8{-1-√17-&radic(34-2√17)}

ところで, 前のSchemeで (foo 1 4) => (5 3) だから, cos φ*cos 4φ=(cos 5φ+cos 3φ)/2=c/2. cos φ+cos 4φ=a と一緒にすると, cos φとcos 4φが解ける. そうしてやっと念願の

が得られるのであった. それにしても, 最初のa, b, c, dの組分けあたりに気づくところは凄い.

古い計算機

2011-03-15T13:16:00.001+09:00

東京理科大学の近代科学資料館で見せて頂いた, もう1つの古い計算機はADALLというものだ. 丸いので変な向きに置いてあるが, 以下のである.

これは英国バーミンガムのTemple Courts, Temple RawにあるThe ADALL Co.製らしい. いうなれば百進法の計算機である. 気宇壮大だ.

いつものように自分で描き直したのが以下だ.

灰色の背景の手前にある白い歯車状なのが, 百進歯車である. その少し内側に00から99まで十進2桁の数字(内数字)が書いてあり, 中央右の窓の内側に見える数字が歯車の状態を示す. この図の状態は00である.

さて, これに0≤n<100を足すには, 外側の数字(外数字)のnのところにある, 歯車の窪みにスタイラス(最初の写真の箱の蓋に見える)を差し, 真横にあるストッパーまで右回転する. そうするとnステップだけ百進歯車が回転し, 状態がnだけ進む. 上の図で, 窪みの説明が差している先は, 11に対応するそれである. 0に対応する窪みはストッパーに接していて, もう回せない.

A足すBの計算には, 最初, 図のように状態を00にしておき, 外数字のAのところから, Aだけ回転; 次に外数字のBのところから, Bだけ回転すると, 窓に現れる内数字がA足すBになる. AもBも99まではOKだが, 足した結果が100を超えると, 状態はA+B mod 100 になる.

この計算機の秀逸なのは, 内側にある渦巻きである. レコードの溝状というか, 蚊取り線香状というか, 1本の溝の線で出来ている. 歯車を右回転すると, 渦巻きは順に内側に入るようになっている.

長窓の中で, この溝には, 3mmφくらいのボールが載っている. 加算の結果が増えると, ボールは徐々に内側に移動する. 長窓の上に, 右から1, 2, ..., 11 と書いてあり, ボールが1と2の間の下にあれば, 加算の結果の百の桁は1ということになる. だから, 2桁の数を何回も足しても, 総和が約1100になるまでは, この計算機は正確な答を示す. もちろん, 下の2桁が丁度00以外では, ボールは百の桁の数字の真下にはないが, 時計の短針が, 1時と2時の中間にあっても, 1時台の時刻が分かるように, この計算機でも百の桁は読み取れるはずである.

この計算機はいうなれば, 離散的円形計算尺である. 計算尺は普通は直線で, A尺とB尺が並び, A尺のa点にB尺の0を合わせると, B尺のbに対応するA尺はA尺の0からa足すbの距離になる. 従って, A尺とB尺を対数目盛にするとa掛けるbが計算できる.

ところで, 普通の計算尺では, A尺のaにB尺の左端を合わせるか右端を合わせるかが, 悩ましいところである.

上の計算尺は3掛ける2で, B尺は左の1をA尺の3に合わせ, B尺2のA尺には6がある. 下は3掛ける4で, 12になるので, B尺の右の10をA尺の3に合わせている.

この面倒を省いたのが下の円形計算尺である. ADALLの計算機は, 対数目盛の代りに等間隔に目盛をつけた加算用の計算尺である.

John Wolffさんのウェブページにも, この計算機の簡単な説明がある. 同ページによると, 理科大でこの計算機の箱に入っていた数表の説明もあった. 要は1シリングが12ペンスなので, sシリングpペンスを十進法にし, 12*s+pペンスに換算する表だったらしい.

古い計算機

2011-03-14T09:52:00.006+09:00

東京理科大学の近代科学資料館には古い計算機の貴重な収集がある. なんども訪れて眺めているが, その中に使い方がわからない計算機があった.

先日お願いして, それをよく見せて頂き, 使用法が確認できた. 今回はそれを説明したい.

下の写真は, Calculatorという, なんの変哲もないない名前の計算機である. 会社もCalculator Corporationといい, 銘板からすると, ミシガン州のGrand Rapidsという町にあったらしい.

真ん中辺を拡大すると, ピントは甘いが,

のようだ. この4桁分を説明用にPostScriptで描いたのが次である. この方で話を進める.

まず1桁分を取り出したものを2個並べる.

こういう計算機の基本構造は, 10の状態を取りうる十進歯車を必要な桁数分用意し, 各桁の歯車を加算する数だけ回転し, 繰上げを次の桁に伝えることである.

この計算機の十進歯車は, 中央の灰色の部分で, これが回転する. ラチェットがあるのか, 離散的な位置に止るみたいである. 周囲に白い窪みが10個見えるが, その内1つが他より大きく窪み, 下に書いてある赤字の数字が読める. その数字がその桁の歯車の状態である. 左は0, 右は5を示している.

この調子で, 上の4桁の状態を読んだのが, それぞれの右下の0000, 1234, 6912である.

次は加算の仕方. タイガー計算機などでは, 十進歯車に噛み合う出入りピンの数を調整して, 0から9までの数を足す. この計算機ははるかに簡単で, ひと様がスタイラスという棒を窪みに差し込み, 昔の電話器のダイアルのように, 右下に飛び出したフックに当るまで, 右回転をするのである. 加算すべき数は外側に白抜きで書いてある.

白い窪みにある, 青い点は, スタイラスを差す場所で, 一番上は左から順に1, 2, 3, 4である. それぞれ回転すると, 最初0, 0, 0, 0であった歯車は, その数だけ状態が進み, 中央の図のようになる.

中央の図になったところで, 再び5, 6, 7, 8にスタイラスを差し込み, 回転すると, 下のように, 加算が出来て, 6, 9, 1, 2になるのである.

極めて簡単だ. 加算では歯車は電話のダイアルのように右にしか回さない. このままでは減算には対応していない.

そうそう, 加算の前に, 各桁を0にリセットしておく必要がある. それには大きい窪みにスタイラスを差して, フックまで左回転する. (と書いたウェブページがあるが, 左に回転出来るのだろうか.)

問題は繰上げだ. 最初のズームの写真を見ると, 下の桁の7と8の間から, 上の桁の0と9の間にかけて, 盛り上がっている形がある. ここに繰上げの仕掛けが隠れているらしい. いろいろ想像しているが, こんなに簡単な仕掛けはまだ思いつかない.

なお, 古い計算機を収集している, オーストラリアのJohn Wolffさんのウェブページにも, この計算機の簡単な説明があった.

二進乗算

2011-03-11T08:53:00.002+09:00

仕事がら二進法の乗算の機会は多い. 二進だから十進の九々の代りに一々だけが必要だが, 逆に足す数が多い. 11111(被乗数)に111(乗数)を掛ける例を下の左に示す. 被乗数を乗数に1がある場所に書き移し(今はすべての場所)て部分積を積み重ね, 各桁を二進法で縦に足す. 足すというのは1を数えるだけ. その和が奇数なら, その桁は1; 偶数なら0だ. 和を2で割った商が繰上げで, 次の桁は繰上げから1を足し始める.

つまり, 積の1の桁は, 1が1個だから1で, 繰上げは0; 10の桁は, 0に1,2と数え, 和が2だから積は0, 繰上げは1, 100の桁はその1に3を足し, 積は0で繰上げは2. これを繰り返す. 最後の繰上げは高々1だが, 1ならそれを書いて終る.

右のDCBAなどの図は, 部分積がどのビットの積かを示したものだ. 1の桁はA掛けるa; 10の桁はB掛けるaとA掛けるbの和; 100の桁はC掛けるaとB掛けるbとA掛けるcの和のように見る.

そこで次の図のように, 被乗数DCBAと, 乗数を逆にabcdと書いたカードを作り, 上下に合わせ, 下のカードを順に左へずらしながら, 重なった部分を見ると, その桁で部分積の足し合わせる位置が分かる.

だから, 例えば3番ではCBAとabcで上下がともに1の場所を数えると和が得られる仕掛けである.

11101掛ける1011を, カード方式でやってみると, このようになる.

tはそのカード位置での, 上下が1の場所の数(十進). sはその桁の積(二進). cはその桁からの繰上げ(十進)である.

一番上はtが1. 従って, (その前のcは0なので,) その1からs=1, c=0となる.

2段目, 3段目も繰上げなしなので, 簡単だ. 4段目で繰上げ1が出た. 従って5段目はt=2と4段目のc=1を足して, 3になり, この段のs=1とc=1となる.

cを一瞬だけ記憶し, tを足し, sを書き出し, cを次へ送る. これで乗算が出来るわけだ. 最後のcが1なら, それを書くのも上と同じである.

実際に計算した積, 100111111と同じものが得られている.

ところで最初の計算のように, 1が何個が並んだもの同士の積は簡単である. 2^p-1掛ける2^q-1で考えると, 1かp個と1がq個並んだものを書けるので, (2^p-1)(2^q-1)=2^p+q-2^p-2^q+1.

つまり, p≥qとし, 1の桁を0桁目というと, p+q-1桁目からq桁目まで1を並べ, q-1桁目から1桁目まで0を並べ, 0桁目に1を書き, 最後にp桁目の1を0にする.

p=q=4の場合は, 上の伝で書くと, 1111掛ける1111は11100001だが, これは十六進の九々に相当する, ffe1である. ELIS風ではフフテイだ.

対称関数

2011-02-24T16:33:00.001+09:00

対称関数の続きである. そのブログの中程にある図に示すように, 2変数対称関数は8個, 3変数対称関数は16個ある.

n変数のBoole関数は, 定数関数も含めて2^2ⁿ(2の2のn乗乗)あるが, n変数の対称関数は2ⁿ⁺¹しかない.

3変数対称関数の図を眺めると, 各立方体で, 同じ色の対称同士の点は, 000の(赤の)点から, 等距離にあることが分かる. 距離の計測法は, 000から立方体の稜にそって目的地まで進む最短距離, いわゆるマンハッタン距離である.

改めて眺めると, 赤までの距離は0, 緑までは1, 橙までは2, 青までは3である.

つまり対称の要素は4個あり, その要素を採用するか, しないかの問題であった. n変数は000...0の点から111...1まで行く辺の種類はn個なので, 要素の数は両端を含めてn+1, 従って2ⁿ⁺¹になるのであった.

乗算表

2011-02-21T17:25:00.002+09:00

「昔のウクライナの人たちはこうやって計算した」と話し出したのはMike Williamsさんだ.

指を出し, 小指の外から指の間を順に0,1,2,...と数える. 親指を飛び越えると5になる. そこで折り返し, 6,7,...と続ける. 小指を過ぎると10になる.

さて, 7×8をウクライナの人はどう計算するか. 片手(左とする)の指をさっき7と数えたところで, 上下に開く. 反対の手(右とする)でも, 8と数えたところで, 上下に開く. 左の上の指が2本. 右の上の指が3本. 左の下の指が3本. 右の下の指が2本となる.

10×(上+上)+(下×下)と計算する. つまり 10×(2+3)+(3×2)=56 が答だ.

下の指は最大で5だから, 5×5までを知っていれば良いのだ.

これで5<M,N≤10について, M×Nが計算出来る理由を, 下の色付きの図で説明する.

まず上左の図. 縦軸がMで, 中央に5があるから, Mは中央より上にある. 横軸がNで, Nも中央より右にある. この場合, Mの上(upper) M_uとMの下(lower) M_l, Nの上(upper) N_uとNの下(lower) N_lはそれぞれ図に示す範囲だ. 従ってM_u×10は, 途中で色が変っているが, 横ハッチの部分である. 一方, N_u×10は, 縦ハッチの部分だ. そしてM_l×N_lは, 斜めハッチの赤い部分である.

ところで, この図の右上の4半分は, 図の中心で180度回転すると, 左下に移すことが出来て, 右の図のようになる. Dと書いてある縦ハッチと横ハッチが重なっている部分は, 面積の計算で2回足しているが, 右上のD'のところへ移動することが出来, 全体がちょうどM×Nになるのである.

下の, 白黒の淋しい図は, 乗算の一方が≤5の時の方法である. 今, Mの方が5より小さいとする. M×Nは, 図では, ハッチに囲まれた左下の小さい白い部分である. この場合は 50−(10×M_u+M_l×N_l)と計算することになるが, これは面倒な気もする.

昔のウクライナ人に聞いてみたい.

水計算器

2011-02-14T18:48:00.004+09:00

計算機にディジタルとアナログがあるのは周知のことだ.

アナログは計算尺のように物理量を使うといわれるが, 殆んどの機械は長さが基本である. しかし, もっと違う物理量を使うものはないか.

小学校のとき, 曲線で囲まれた面積を計測しようという課題があった. 私は, その形を厚紙から切抜き, 重さを測ればよいと考えたが, 先生の用意した解は方眼紙にコピーして, 桝目を数えるのだった.

面積計の話題は, このブログに何回も登場したが, 毛色が違うのは, ボストンの科学博物館にあった, 液体を使うPithagorasの定理の証明である.

ガラスで被われた一様な厚さの正方形の箱が3個, 3:4:5のPithagoras三角形の形においてあり, 色のついた水がはいっている. 箱の繋ぎ目は水が通れる. 全体の装置は垂直面になっていて, 中央あたりの水平の軸で回転できる.

まず3と4の箱が下に来るようにすると, その2つの箱に丁度いっぱいに水が入る. 次にそれを180度回転すると, 水はすべて5の箱に収まる.

「水は器に従いて」の歌の通り, 面積を保ちながら, 形が変えられるのを利用したものだ.

それなら体積は使えないかと考えたのが, 次の立方根計算器である.

右の円筒の途中まで水が入っている. 上まで満杯の時, 水面の高さを1とする. 図では0.5になっている. この水をそのまま, 左の円錐へ移す. そうすると円錐の母線に沿った目盛で, 先ほどの量の立方根0.79が読める仕掛けである.

しかしびしょびしょして, 実用にはなりそうもない. 粉体も無理だが, 微小な球の粒を, Pitagorasの機械のように, 閉じ込めて使うことなら出来そうである.

体積2倍の立方体をつくるのに, 使えたかもしれない.

対称関数

2011-02-13T16:42:00.002+09:00

TAOCP V4F1にきれいな絵があった. 元の絵はもちろん白黒である.

これは3変数対称関数のBDD(二分決定図)ベースの図である.

そもそも対称関数とは, 変数をとりかえても値が変らないものである.

以下に2変数(xとy), 3変数(xとyとz)の対称関数を示す. 頂点にある色つきの丸は関数値が1の点で, 同じ色は対称の相手を表わす.

上の方の2変数対称関数は, それぞれの図で, 左下がx=0, y=0. 右上がx=1, y=1の点で, 破線は対称軸. 従って対称関数は, 同じ色の丸が対称軸について対称であるものである.

2変数関数が16あるうち, 対称なのはここにある0番から7番の8個である.

3変数のx, y, zは, 左上の0番の図に示す通りで, 3変数の場合も, 同じ色の丸は対称軸について3回対称である.

3変数関数は全部で256あり, 対称なのは0番から15番の16個である.

Boole関数は, こういう図の他, その真理値表で表わすことも出来る. x, y, zの各値に対し, 関数値を並べて書く. 例えば3番は多数決関数で

である. 図からは右下の経路で頂点をたどり1と0を書き取ればよい.

ところで, TAOCP 7.1.4項は, BDDが話題であった. BDDは下に示すような図で, 変数を調べる節点を実線と破線で繋げたものである.

一番上の入口(根)から出発し, 丸で示す変数の値を調べ, 値が1なら実線方向へ, 0なら破線方向へ進み, 次の変数をチェックする. 四角に⊥は, 関数の値が0で確定する, 四角にTは, 1で確定し, BDDの出口である.

下の図は, 3変数の16個の対称関数のうち16個のBDDで, 0番のオール0, 15番のオール1は定数関数なので, 省いてある.

最上段の右端の3番が, 話題の多数決関数で, 根の1番変数(xのこと)の脇に先ほどの真理値表が書いてある. xが0なら左下の2番変数へ進み, yを調べる. ここでyも0ならzと無関係に0なので, 0の出口になる. yが1なら, 決定はzによる. そこで3番へ進む. 上へもどり, xが1なら右下の2番変数へ進み, 2も1なら1の出口. 2が0なら3番の変数をしらべる. BDDはこのような図である.

ところでそれぞれの図の節点の数は, 0と1の出口は1個と数えるので, 1番から順に, 5, 7, 6, 7, 7, 7, 5, 5, 7, 7, 7, 6, 7, 5 で合計88個ある. 1の節点は14個あるが, 1段下の2の節点は6種類, 3の節点は2種類しかない. 同じものをまとめてメモリーにいれれば節約になるといってまとめたのが最初に掲げたBDDベースである. ここには節点は24しかない.

1の節点の左下の青の番号は, 対称関数の3変数の番号と一致している. 一番上の3番は, 実線で左の2へ, 破線で右の2に進むが, それぞれの2の左に青で1と3とあるのは, BDDの2の添字に合っている.

もう一度対称関数の絵で3番をみると, xが1の手前の四角の丸は, 直ぐ上の2変数の3番と同じ. xが0の向こうの四角は, 2変数の1番と同じであり, さきほどの添字はそれを表わしている.

変数の図はyの値で1変数の図に分解できる. 下の図が1変数の(対称)関数の図と, その右が0変数の図である.

乗算表

2011-01-24T09:32:00.022+09:00

TAOCP V4F1にnim multiplicationという話題がある(演習問題7.1.3-10).

結論からいうとこういう乗算表を作るのだ.


   0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15
 0 0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0
 1 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15
 2 0  2  3  1  8 10 11  9 12 14 15 13  4  6  7  5
 3 0  3  1  2 12 15 13 14  4  7  5  6  8 11  9 10
 4 0  4  8 12  6  2 14 10 11 15  3  7 13  9  5  1
 5 0  5 10 15  2  7  8 13  3  6  9 12  1  4 11 14
 6 0  6 11 13 14  8  5  3  7  1 12 10  9 15  2  4
 7 0  7  9 14 10 13  3  4 15  8  6  1  5  2 12 11
 8 0  8 12  4 11  3  7 15 13  5  1  9  6 14 10  2
 9 0  9 14  7 15  6  1  8  5 12 11  2 10  3  4 13
10 0 10 15  5  3  9 12  6  1 11 14  4  2  8 13  7
11 0 11 13  6  7 12 10  1  9  2  4 15 14  5  3  8
12 0 12  4  8 13  1  9  5  6 10  2 14 11  7 15  3
13 0 13  6 11  9  4 15  2 14  3  8  5  7 10  1 12
14 0 14  7  9  5 11  2 12 10  4 13  3 15  1  8  6
15 0 15  5 10  1 14  4 11  2 13  7  8  3 12  6  9

乗算法はここにある.

2と4と16と...,つまり2^2ⁿはFermat 2-powerといって, 特別の数である. 特別の数の2乗はそれを1.5倍する. 2²=3, 4²=6,... 特別の数同士の積は, 通常の積で計算する. 2.4=8.

0×n=0, 1×1=nである. 残りは分配則やnim addition(二進法の排他的論理和)で計算する.

こうなるかと思い, 始めの方を計算してみる. 赤字はnim additionのところだ.

2の段:
2.2=3, 2.3=2.(2+1)=2.2+2=3+2=11+10=1, 2.4=8, 2.5=
2.(4+1)=8+2=1000+10=10, 2.6=2(4+2)=8+2.2=8+3=11, 2.7=2(4+2+1)=8+2.2+2=8+3+2=1000+11+10=9, 2.8=2.2.4=3.4=(2+1)4=8+4=12, 2.9=2(2.4+1)=12+2=1100+10=14, 2.10=2(2.4+2)=12+2.2=12+3=15, 2.11=2(2.4+3)=
12+2.3=12+1=13, 2.12=2(2.4+4)=12+8=1100+1000=4, 2.13=2(2.4+5)=12+10=6, 2.14=2(2.4+6)=12+11=1100+1011=7, 2.15=2(2.4+7)=12+9=1100+1001=5.
3の段:
3.3=(2+1)(2+1)=2.2+2+2+1=3+1=10+1=2, 3.4=2(2+1)=2.2+2=
3+2=11+10=1, 3.5=(2+1)(4+1)=2.4+2+4+1=8+2+4+1=15,
3.6=(2+1)(4+2)=2.4+2.2+4+2=8+3+4+2=1000+11+100+10=13, 3.7=(2+1)(4+3)=2.4+2.3+4+3=8+1+4+3=14, 3.8=(2+1)8=
2.8+8=1100+1000=4, 3.9=(2+1)(8+1)=2.8+2+8+1=
1100+10+1000+1=7, 3.10=(2+1)(8+2)=2.8+2.2+8+2=
1100+11+1000+10=5, 3.11=(2+1)(8+3)=2.8+2.3+8+3=
1100+1+1000+11=6, 3.12=(2+1)(8+4)=2.8+2.4+8+4=
1100+1000+1000+100=8, 3.13=(2+1)(8+5)=2.8+2.5+8+5=
1100+1010+1000+101=11, 3.14=(2+1)(8+6)=2.8+2.6+8+6=
1100+1011+1000+110=9, 3.15=(2+1)(8+7)=2.8+2.7+8+7=
1100+1001+1000+111=10.

すでに計算した積の値は利用している.

ところで, 上の表はこのようにして作ったものではない. TAOCPの方法を説明しよう. この方法が, なぜ上の乗算法と同じになるかは, 今は私の理解の範囲外である.

演習問題7.1.3-8に, 非負の整数の有限集合Sのminimum excludantというのがある.

mex(S) = min {k | k ≥ 0 and k ∉ S}

つまり mex({0,1,2})=3, mex({0,1,2,3,5,7})=4.

これを使い nim multiplication x ⊗ y は

x ⊗ y = mex {(x ⊗ j) ⊕ (i ⊗ y) ⊕ (i ⊗ i) | 0 ≤ i < x, 0 ≤ j < y}

で計算する.

上の図で, x ⊗ y (赤丸)を計算するには, 緑の範囲内の i と j に対して, 青丸で示す x ⊗ j, i ⊗ y, i ⊗ iのnim和をとり, その緑の範囲のすべての値のmexをとると, それが赤丸の値になるのである.

上から順に横向きにnim productが計算してあれば, 赤丸まで来たとき, オレンジ色の値はすべて分かっているから, 再帰計算はせずに済む.

mexはこう計算する.


(define (mex xs)  ;関数mex
 (define (mx n)
  (if (member n xs) (mx (+ n 1)) n))
 (mx 0))

表の(x,y)の値をとる関数を(get x y)とすると, nim productは以下のようだ.


(define (nimprod x y)
 (let ((s '()))
   (do ((i 0 (+ i 1))) ((= i x))
    (do ((j 0 (+ j 1))) ((= j y))
     (set! s (cons (bxor (bxor (get i j) (get x j)) (get i y)) s))))
   (mex s)))

表の0 ≤ j < 16 の(0,j)を0, (1,0)も0にし, (1,1)から始められる. こうして作ったのが最初にあった乗算表である.

TAOCP

2011-01-16T11:30:00.002+09:00

TAOCP V4F1にこういう問題があった(7.1.3-102).

日, 時, 分, 秒, ミリ秒がそれぞれ3, 1, 1, 1, 2バイトに収まっている. 3バイトで日を表わすと, 2²⁴/365=45964年分だから, ここはどうでもいい. こういう時間データ2つを足したり引いたりする方法である. その解答の最後に「`fc81'の`c'が偶数なのは運が良かった.」とあるのはなぜか.

方法はこうである. 2つの数をxとyとする. 減算ならz←x-y, 加算ならz←x+y+#e8c4c4c4fc18とする. 分の桁でいうと, xの分とyの分を足して60になるか60を超えたとき, 256の桁に1を送りたいので, 256-60=196=11000100₂=#c4を足す. しかし和が60に満たない時はどうするか. 60はバイトサイズ256の半分以下なので, バイトの先頭のビットが1なら繰上げはなかった, 0なら繰上げがあったが分かる. なかった場合は先ほどの#c4を引かなければならない. 従って, 先頭のビットが1ならそのバイトを#c4に, 0ならそのバイトを0にしたものが欲しい. それは簡単だ. バイトを#80で&をとる. その1を左に1ビットシフトしたものから, その1を右に7ビットシフトしたものを引けば, 11111111か00000000になるので, これを#c4を&したものを引く. 時, 分, 秒はそれで良い. ミリ秒はどうするか.

2バイトのミリ秒の区域の先頭が1のとき, 上の伝では 11111111 0000000になってしまう. そこで, 先頭が１の時, この区域ではさらに1を引くのである. するとこの右端の1から引かれて,11111110 11111111が出来る. これとfc18の&をとることになり, うまい具合いにマスクが0になったビットは, cなので0であったわけだ.

なるほど. 運がよかった.

乗算表

2011-01-15T09:55:00.002+09:00

乗算の九々は一旦覚えてしまえば後は何の道具もいらないはずだが, 「Napier の骨(Napier's Bones)」のような乗算用具もあるから, 九々を諳じない人も多いかもしれない.

これは以前自作したNapierの骨で, 中央に3本, 2と5と6の棒を置いてみた. 見ての通り, 各棒にはその段の九々が書いてある. 256を4倍するには, 左のIVの行に注目. /8 2/0 2/4になっている. 右端の4から, 積の1の桁は4. その分子の2と, 左隣りの分母の0を足し, 10の桁は2. さらにその分子の2と, 左隣りの分母の8を足し, 100の桁は10. すなわち1024が得られるの図だ.

つい先頃, 「Genailleの棒(Genaille's Rods)」というものがあると教わった. これは九々を図にしたものである.

6×8は以下のとおり.

左に6, 上に8と見出しがあるので, 6×8なのが分かる. 中央の箱の右に上から890123とあるが, 一番上の8が積の1の桁の8を示す. そこから左へ楔状の影があり, その先に4とあるのが積の10の桁の4を示す. その4の上と下の012...は繰上げの数で, 10の桁が4というのは, 繰上げが4と言うことだ. 一方1の桁の8の, その4の高さに2があるのは, 下から4の繰上げがあると, 6×8に繰上げを足すと, 1の桁が２になること, その左の楔の先が5になっているのは, その時の繰上げは5であることを示す.

私も小学生の上級になると, 繰上げ4を思い出しながら, ロクハチゴジュウニなどと唱えたものだが, そういう乗算表になっている.

次の図は, 4×256を示す.

2と5と6の棒を並べ, 4の段を見る. 6の棒の4の段の一番上の4から出発し左へ進む. 楔の影に入ったら, 楔の先に進む. そして通過する数字を読み取る. 従って, 4×256は下の桁から, 4,2,0,1なことが分かる.

これで分かるように, 被乗数は何桁でもよいが, 乗数は1桁である. また被乗数に同じ数字があると, それだけ同じ棒が必要で, そこにこの種の道具の限界が存在する.

棒による乗算とは別に, 棒を順に並べると, 九々の表が出来る. それが下の図だ. 九々の範囲は2から9だが, 被乗数に0もあることから, 棒には0も1もある.

棒に書いてある乗数は, Wikipediaの図などでは1から始まっているが, 乗数1はいらないので, 2から始まるのも目につく. この表も2から9である.

インターネットで探していたら, 除算表というのも見つけた. これも面白い.

乗算表

2011-01-12T20:34:00.005+09:00

その名を聞いた人ももうあまりないであろうが, 計算機のほとんどない頃, 乗算表といものがあった. 九々の表の大親分みたいなものである.

私も詳しくは知らないが, 例えば3桁掛ける3桁というのもあったであろう. つまり000×000から999×999までの積が印刷された表である.

最後の方はこういう風だったろう.

例えば 123456×987654を計算したいなら, 下3桁 456×654の積298224を表で引く. 算盤にその298224を置く.

次に456×987の積450072を3桁ずらして足す.


       298224
+   450072
-------------
    450370244

次に123×654=80442を3桁ずらして足す.


    450370244
+    80442
-------------
    530812244

次に123×987=121401を6桁ずらして足す.


    530812244
+121401
-------------
 121931812244

検算すると,
(* 123456 987654)=>121931812224
となる. 日本人は算盤を補助に使えるから, 積が簡単に求まるのである.

私も自分で乗算表を持っていたわけではない. 立教大学の島内剛一先生がお持ちで, 見せて頂いた. 島内さんは「乗算は簡単にできるが, 乗算表は正しかったのかと一抹の不安が残る」と笑われた.

除算も出来る.
9876543210を123で割る場合を見よう. 下から6桁を外した9876と除数123を乗算表で見る.


(* 123 81)=>9963
(* 123 80)=>9840

なので, 最初の商は80, 最初の剰余は


 9876543210
-9863
-----------
   36543210

下3桁を外して


(* 123 298)=>36654
(* 123 297)=>36531

従って次の商は297, 剰余は


   36543210
-  36531
-----------
      12210

(* 123 100)=>12300
(* 123 99)=>12177

従って次の商は099, 剰余は


      12210
-     12177
-----------
         33

確かに,


(quotient 9876543210 123)=>80297099
(modulo 9876543210 123)=>33

要するに, 我々が十進1桁でやっていることを, 十進3桁でやっているに過ぎない. さらに長い除数で割るには, 日常で2桁以上の除数で割るのと同様に面倒である.

3色合衆国

2011-01-03T09:08:00.002+09:00

TAOCPには, グラフの例として, 連なっている合衆国(contiguous USA)が登場する.

ある演習問題に, 3色塗分け可能な誘導部分グラフを作れというのがあった. そんなにたやすい問題ではない. 解答を見ると意外にも, カリフォルニア州とオハイオ州を除くと, 3色で塗分けられるらしい.

そこまで分かると, 実際の塗分けは, 最初の2つの色を決めれば, その後の色は次々と決るので, あっという間の作業であった.

進んで戻って

2010-12-26T20:05:00.003+09:00

いよいよ年末が迫る. 元日からの通日は360+αまで来た.

ずいぶん前になるが, 365歩のマーチという曲があり, その中に「3歩進んで2歩さがる」という文句があった. これを聞いて, 昼間に2メートル登り, 夜間に1メートル滑り落ちるカタツムリが, 地上から5メートルの電柱を登りきるのに何日かかるかというクイズを思い出す向きもあろう.

TAOCP V4F3に
"To take one step forward, take two steps forward, then one step backward; to take two steps forward, take one step forward, then another"
という禅問答のような記載があり, 私も直ぐには悟りえず, しばし悩んだことがある.

順列組合せと一緒にしていわれることが多いが, 組合せは, 0,1,...,n-1のn人から, s人を選ぶ方法のことである. これはn - s = t人を選ばない方法でもあるから, TAOCPでは(s,t)組合せという.

つまり, 0号室と1号室があり, 0号室の人数をs, 1号室の人数をtとする. 0番君からn-1番君のそれぞれが, どちらの号室にいるかを, nビットの二進数で表わす.

当然_s+tC_s=_s+tC_t組が作れるわけだ.

その組合せを書き出すのに, 常識的には辞書式順, あるいは昇順に並べる. 次は(3,3)組合せの例である.

この図の赤点は, 前後の組合せで異なる位置を示す. 二進数の位置を右から0,1,2,...とすると, 始めの方の最初の赤点は, 000111から001011になった時に, 2番君が1号室から0号室に, 3番君が0号室から1号室に移ったことを示す. 右下の最後の組合せの下に6つの赤点があるのは, 111000から最初の組合せ000111に戻るには, 全員が部屋を移る必要があるということである.

かくも大勢が右往左往しては, ドア回りが混雑するので, 回転ドア方式を考えた人がいる. 0号室と1号室の間に回転ドアがあり, 回転ドアを通って1人ずつだけが入れ替わるのである.

すなわち, この図で見るように, 赤点は常に2個である. なかなかうまく出来ている.

これは6ビットのGray codeを作り, 1のビットが3個のものだけリストして作った.


(define (gray bs)
 (define (xor a b) (modulo (+ a b) 2))
 (map xor bs (cons 0 (reverse (cdr (reverse bs))))))

(for-each (lambda (n) (for-each display n) (newline))
 (filter (lambda (x) (= (apply + x) 3))
  (map gray (map (lambda (n) (n2bs n 6)) (a2b 0 64)))))

ところでよく見ると, この赤点の間隔はいろいろだ. 2つ隣り同士のところが10, 間が1個空いているのが4, 2個空いているのが4, 3個空いているのが2で計20である.

この間の幅を0と1にしても出来るといい出した人がいるらしい.

がその1例である. 最後から最初に戻るのは別として, 途中の赤点はすべて隣り同士か1個空きである. このパターンをA₃₃という. しかし, こういうパターンはこれだけでなく, 次のB₃₃もそうなっている.

途中には目をつぶると, A₃₃は111000から始まり, 011100で終る. B₃₃は111000から始まり, 001110で終る. 一般にA_stは, 0がs個, 1がt個から始まり, 0が1個, 1がt個, 0がs-1個で終り, B_stは, 0がs個, 1がt個から始まり, 0が2個, 1がt個, 0がs-2個で終る.

AとBの漸化式も知られている.

A_st = 1B_s(t-1), 0A_(s-1)t^R;
B_st = 1A_s(t-1), 0A_(s-1)t.

これを図で示すと次のようになる. いまはs=t=3である.

左の組合せは, は下の黒文字の説明にあるように, B₃₃である. 上の漸化式に当てはめると, B₃₃ = 1A₃₂, 0A₂₃.

つまり, 左のB₃₃は, A₃₂の前に1を置いたものを並べ, 次にA₂₃の前に0を置いたものを並べると読む. 1や0の後に置く部品の組合せは赤で囲んである. 説明も赤文字である.

また, A₃₃ = 1B₃₂, 0A₂₃^R.

つまり, 右のA₃₃は, B₃₂の前に1を置いたものを並べ, 次にA₂₃の, 右肩にRがついているから, 上下逆転したものの前に0を置いたものを並べると読む.

たしかに左の下半分のA₂₃と右の下半分のA₂₃^Rは, 上下が逆である.

改めて右のA₃₃を見ると, 最初の111000は最後は011100になり, 111は右へ1歩進んだ. B₃₃では, 111は右に2歩進んだ. 部品を見るとA₃₂は11が右へ1歩進み, A₂₃は111が右へ1歩進み, B₃₂は11が右へ2歩進む. 右下のA₂₃^Rを上から下へ眺めると, 今度は01110が11100になるから, 111が1歩戻ったことになる.

これが最初の「一歩進む(A_st)には, 二歩進み(B_s(t-1)), 一歩戻る(A_(s-1)t^R). 二歩進む(B_st)には, 一歩進み(A_s(t-1)), もう一歩進む(A_(s-1)t)」の謎解きであった.

私がこの解釈に気づいたのは, 2008年の1月頃であった, 2008年の夏にKnuth先生に会った時, 「あの2歩前進, 1歩後退の意味は, 苦労したがついに分かった.」と報告した. Knuth先生は笑っただけであった.

微分解析機

2010-12-25T20:41:00.003+09:00

今回は微分解析機といっても, トルクアンプ, 日本語では回転力増幅器の, それも図の話である.

微分解析機の積分機の出力は, 摩擦で生じる微少な力なので, これで他のものを駆動することは出来ない. ところがNewmanにより, トルクアンプが発明され, それによって微分解析機は実用になった.

トルクアンプは, 下の図のような構造である.

右のinputの軸の回転を, 左のoutputの軸から力を増幅して取り出すのである. その間にロープを書けたドラムが2組あり, ロープの端は, 入力と出力軸に取りつけたT字状のレバーの先に固定されている. ドラムは両端のプーリーにかけたベルトで, 矢印の方向に, 逆方向に回転している. 入力軸が回転しない時は, ロープはドラムの面を滑っている.

今, 入力軸が, 右に回転したとする. そうすると, 下のT字状のレバーが持ち上がり, 左のロープがドラムの上で締まり, ドラムとの間に摩擦が生じ, 上のT字状のレバーが押し下げられ, 出力軸が入力軸と同じ方向に回転する. 回転角が同じになれば, ロープは弛み, 再び滑り出す.

入力軸が反対に回る場合は, 右のドラムの摩擦が生じ, 出力軸はやはり入力軸と同回転する.

つまり, 回転するドラムが動力になり, 入力の微少な力を増幅するのである.

こういう仕掛けは船の碇を巻き上げる装置にもあるらしい.

さて, 上のような図で説明したが, 私としては, ロープを直線で描いたのが気に入らないのである. 図はなるべく正確に描きたいというからには, このようにドラムの縁で光の反射のような図はだめである.

そこで考えたのがこの図である. 上と下のT字状のレバーにロープが繋がっている点をAとEとする. 図の円はドラムの断面である. ロープは, AからBに至ってドラムに接し, BCDFBCDとドラムを1回とすこし回り, Dから離れてEでもう一方のT字状のレバーに辿り着く. 先ほどの図は, これを左から見たものだ. そうすると, ロープ上の点は, Aから下がり, ドラムの円の右半分を上がり, また下がるように見えるはずである. また左右の座標位置は, ロープの長さに比例して右へ移動するはずである.

その移動の様子を, 半径の右の, 点の列で示す. 赤はロープのAからBに対応する. 緑はBCDFBCDに対応, 最後の青はDからEである.

そういう解釈で, 最初の図を描き直すと下の絵になる.

ざっと見ると最初の図と左程違わないが, ドラム回りのロープは本当らしくなったのではないか.

クリスマスツリー講義

2010-12-23T15:22:00.004+09:00

今月(2010年12月)始め, Knuth先生から, いつもの航空便ではなく, 珍しくメイルで返事が来た. その最後に

By the way, my lecture next Monday will probably be webcast live, so you might be able to watch it via Internet in Japan.

と書いてあった. その日(日本時間では7日朝)は所用あって, インターネットも見ずに過ぎたが, ホームページには,

Monday, 06 December, 5:30pm, in the new NVIDIA auditorium (Huang Engineering Center) A Computer Musing entitled ``Why pi?'' [the sixteenth annual Christmas Tree Lecture]

あ, これがあのクリスマスツリー講義(Christmas Tree Lecture)だったのか.

すぐに連想するのは, 元祖「クリスマス講演」である.

「これから皆さんにロウソクのお話をいたそうと思います.」で始まるMichael Faradayの「ロウソクの科学」は, 1860年のクリスマスであった. だから150年前の話だ. ところでこの原題はThe Chemical History of a Candleという.

Royal Institution Christmas LecturesをWikipediaでみると, 1825年に始まり, 第２次世界大戦中を除き, 今年も続けているというから, 英国のこだわりにはまったく脱帽する.

一方, クリスマスツリー講義は, Knuth先生が, 年末に一般向けに講義するものらしい.

TAOCP V4F4の表4に8次のクリスマスツリーパターンという図があり, その脚注に(TAOCPに脚注があるのは異例なことだが),

"This name was chosen for sentimental reasons, because the pattern has a general shape not unlike that of a festive tree, and because it was the subject of the author's ninth annual "Christman Tree Lecture" at Stanford University in December 2002."

と書いてある.

8次は大きすぎるから遠慮し, 6次のクリスマスツリーは以下のように, 6ビットの二進数64個を, ₆C₃=20行, 6+1列に配置する.

左からの各列は, 1の個数が0, 1, ..., 6である. 従って中央の高さは₆C₃である. 同じ行では, 右に行くに従い, 0が1に変っていく. 赤い0は, 次に1になるもの, 青い1は, 前に0だったものだ.

この配置法は, 1951年にde Bruijn, van Ebbenhorst Tengbergen, Kruyswijkが発見した.



                     101010
              101000 101001 101011
                     101100
              100100 100101 101101
              100010 100110 101110
       100000 100001 100011 100111 101111
                     110010
              110000 110001 110011
                     110100
              010100 010101 110101
              010010 010110 110110
       010000 010001 010011 010111 110111
                     111000
              011000 011001 111001
              001010 011010 111010
       001000 001001 001011 011011 111011
              001100 011100 111100
       000100 000101 001101 011101 111101
       000010 000110 001110 011110 111110
000000 000001 000011 000111 001111 011111 111111

これはどうできているかというと, 1次は

0 1

の1行. これではクリスマスツリーにならない. 2次は


   10
00 10 11

の2行. いささかツリーらしくなる.

さて, n次のツリーの各行を,
σ₁,...,σ_s
とすると, n+1次のツリーは, 各行を
σ₂0,...,σ_s0と
σ₁0,σ₁1,...,σ_s1の
2行にする.

すなわち, 後に0をつけたものと, 後に1をつけたものを作り, 0をつけたものの先頭の1個を1をつけたものの先頭に移動するのである. 先頭を外した後が0個になったら, その行は除く.

Schemeで書くと


(define (next ct)
 (if (null? ct) '()
  (let ((ss0 (map (lambda (s) (string-append s "0"))
　　　　　　　 (car ct)))
        (ss1 (map (lambda (s) (string-append s "1"))
　　　　　　　 (car ct))))
   (set! ss1 (cons (car ss0) ss1))
   (set! ss0 (cdr ss0))
   (if (null? ss0) (cons ss1 (next (cdr ct)))
       (cons ss0 (cons ss1 (next (cdr ct))))))))

である. ctを


(define ct '(("0" "1")))

によって１次のクリスマスツリーとし, ctにnextを順に作用させると,


(("10") ("00" "01" "11"))

(("100" "101") ("010" "110") ("000" "001" "011" "111"))

(("1010") ("1000" "1001" "1011") ("1100") 
　("0100" "0101" "1101") ("0010" "0110" "1110")
  ("0000" "0001" "0011" "0111" "1111"))

が得られる. クリスマスツリーらしいのは, 次数nが偶数の時である.

6次のクリスマスツリーパターンは, 異なる64の要素があるから, それを八卦の64のパターンで置き換えたのか以下である.

これは, 昨年の, 私からKnuth先生へのクリスマスカードであった.

1のかたまり

2010-12-22T19:52:00.005+09:00

TAOCPに A_n=Σ_k=0ⁿ _n-kC_2k という式があった(演習問題7.1.4--125).

その解答のHistorical Noteに A_ncounts binary x₁...x_n-1 with each 1 next to another と書いてある. なんだろうと思っているうちに, Knuth先生からのある手紙にヒントがあった.

ちなみにA_nの値は


n   1 2 3 4 5  6  7  8  9 ...
A_n  1 1 2 4 7 12 21 37 65 ... .

とりあえずn=5を考える. するとbinary x₁...x_n-1は

with each 1 next to another は, 1があれば単独では現れないということで, そういうものは, 上で星印をつけた7=A₅個になる. 1は孤立していて失格である. 問題はこのパターンの見つけかたである. 星印のものを取り出すと

最初のは1がないから別にして, 残りは1のかたまりが1個ある. 1が孤立するかたまりはないから, 1のかたまりから1個外したパターンを書くと

となる. ビットの境界に左から1,2,3,4と番号をつけ, 0と1の境界の位置を書いてみると

となり, これは4個から2個選ぶ数であった. つまり₄C₂=_n-1C₂=6.

同様にして, 1のかたまりが2個あるパターンは, n=7の0 1 1 0 1 1 から考え始めて


1 2 3 4 5
 0 1 0 1    2 3 4 5
 1 0 0 1    1 2 4 5
 1 0 1 0    1 2 3 4
 1 0 1 1    1 2 3 5
 1 1 0 1    1 3 4 5

だから, 右にあるような境界の位置を見れば, ₅C₄=_n-2C₄(1のかたまりが2個の場合).

という次第で, 一般に1のかたまりがk個ある数は_n-kC_2k.
一番上の1のかたまりのないものは_nC₀=1.

2項係数_nC_mは, n<mの時に0だから, かたまりがとれるところまで足せばよく, 1のかたまりの置き方の数になるのであった. 結構むずかしい. 私もヒントなしでは, ここまで辿りつかなかっただろう.

2011

2010-12-11T11:51:00.001+09:00

1年ほど前 2010が1から9までを使ったどういう式で表わせるかを計算し, このブログに書いたことがある.

今回は2011である. 28個の解があった.


(+ 1 (* (/ 2 3) (- (* (* (* (+ 4 5) 6) 7) 8) 9)))
(- 1 (* 2 (+ 3 (* (* (- (- (- 4 5) 6) 7) 8) 9))))
(- (* (- (/ 1 2) (* (* (- (- 3 4) 5) 6) 7)) 8) 9)
(+ (* 1 2) (* (+ 3 4) (- (* (+ (* 5 6) 7) 8) 9)))
(* 1 (+ 2 (* (+ 3 4) (- (* (+ (* 5 6) 7) 8) 9))))
(* 1 (- (* (+ (* 2 3) 4) (- (* (* 5 6) 7) 8)) 9))
(- (* (+ (+ (+ 1 2) 3) 4) (- (* (* 5 6) 7) 8)) 9)
(- (* (+ (* (* 1 2) 3) 4) (- (* (* 5 6) 7) 8)) 9)
(- (* (* 1 (+ (* 2 3) 4)) (- (* (* 5 6) 7) 8)) 9)
(- 1 (* (/ 2 3) (- (+ 4 5) (* (* (* 6 7) 8) 9))))
(+ 1 (* (* (/ 2 3) (+ (- 4 5) (* (* 6 7) 8))) 9))
(+ (- (* 1 2) 3) (* 4 (+ (- 5 6) (* (* 7 8) 9))))
(* 1 (+ (- 2 3) (* 4 (+ (- 5 6) (* (* 7 8) 9)))))
(+ (* 1 (- 2 3)) (* 4 (+ (- 5 6) (* (* 7 8) 9))))
(+ (/ 1 (- 2 3)) (* 4 (+ (- 5 6) (* (* 7 8) 9))))
(+ 1 (* (+ 2 (* (- 3 (* 4 (- (/ 5 6) 7))) 8)) 9))
(+ (* 1 2) (* (+ 3 4) (+ 5 (* 6 (- (* 7 8) 9)))))
(* 1 (+ 2 (* (+ 3 4) (+ 5 (* 6 (- (* 7 8) 9))))))
(- (- 1 (* 2 3)) (* (* (* (* 4 (- 5 6)) 7) 8) 9))
(- (- 1 (* 2 3)) (* (* (* (/ 4 (- 5 6)) 7) 8) 9))
(- 1 (* (+ (/ 2 3) (* (* (* 4 (- 5 6)) 7) 8)) 9))
(- 1 (* (+ (/ 2 3) (* (* (/ 4 (- 5 6)) 7) 8)) 9))
(- (* 1 2) (* (+ 3 4) (+ (* (- 5 (* 6 7)) 8) 9)))
(* 1 (- 2 (* (+ 3 4) (+ (* (- 5 (* 6 7)) 8) 9))))
(- 1 (* (* 2 3) (+ (* (- (- 4 5) (* 6 7)) 8) 9)))
(+ 1 (* (* 2 3) (- (* 4 (+ (* 5 6) (* 7 8))) 9)))
(- 1 (* (* (- (/ 2 3) 4) (+ (+ 5 6) (* 7 8))) 9))
(+ (* (+ 1 (* (* 2 (+ 3 (* 4 5))) 6)) 7) (* 8 9))

最後の
(1+2*(3+4*5)*6)*7+8*9
が美しい.

双曲線

2010-11-20T14:35:00.002+09:00

円錐曲線の中で, もっとも馴染みがないのが双曲線である. したがってda Vinciも双曲線コンパスは考えなかったかも知れない.

反比例 y=1/xを習うと, この形は双曲線と教わる. 確かにx軸とy軸は漸近線だし, 第1象限と同じ図形が第3象限にもある.

xy=1を x'=√2 x-√2 y, y'=√2 7+√2で置き換える. つまり45度回転すると, 確かにx²/2-y²/2=1となり, 双曲線である.

ところで, 双曲線というと, 以前から気になる文言がある. 高橋秀俊先生の「数理と現象」に

「楕円は丸い茶碗やお盆を横から見たときの形として, 万人の日常接しているところであるが, 放物線と双曲線はそれほど親しみがあるとはいえないかもしれない. しかし, 円錐曲線はすべて円錐の切り口, つまり円形をある方向から見たときの形であって, 誰でも目にふれるはずのものである. すなわち大きい円を近くから見て, 円の一部が眼よりも後に来るような場合は, 円は双曲線(の片側)に見え, ちょうど眼の平面(眼のところを通って視線に垂直な平面)に接する場合は放物線に見えるのである.」

と書いてある. 確かに付随する写真では放物線や双曲線のように見える. これはどういうことか, ずーっと疑問に思っていた.

私は自他ともに認めるPostScript描画大好き人間なので, さっそく図を実際に書いてみることにした.

すなわち, 円Oの中央の真上の点Hから, 水平に置いた円Oを, その円周上で接している面Pに投影し, 得られる(赤線の)図形を描いてみたのである. 特殊な環境だが, 計算式を簡単にしたかったからである.

たしかにHの真横の円の部分は右下, 左下の遠方に投影されるから, 双曲線になりそうである. そして出来た図が下である.

視点HをOの真上にとったのは, 怪我の功名であって, 実はHを頂点とする円錐を平面Pで切ったので, 断面が双曲線なのは当たり前である. 高橋先生がいわれるのは, 円内のもっと一般的なところで見ても双曲線ということで, それには別の視点が必要そうだ.

楕円コンパス(つづき)

2010-11-17T20:26:00.002+09:00

Leonardo da Vinciは放物線のためのコンパスも考案した. この方はたまたまウェブに図があった(http://www.japandesign.ne.jp/HTM/REPORT/art_review/38/big/05.html)ので, 借用させていただく.

前回のブログの最後に書いたように, 離心率が大きい(=1に近い)と楕円コンパスは苦しくなる. 放物線は離心率が1なので, 発想の転換が必要だ. そこでda Vinciは別の機構を考えたのであろう.

こちも原理は楕円の場合と同じである. 円錐を母線と平行な面で切ると放物線になる性質を利用している. 前回の図で, 切断面が母線と平行になると, 上の球は作図出来るが, 下の球は存在しない. つまり焦点は1つになる.

放物線コンパスの仕掛けを上の図で説明しよう.

ACは鉛直な回転軸である. Cを頂点とし, 底面が円DQEFの円錐を考える. 回転軸を支えるのに, CD, CE, CFの3本がある. 3本の足は, 別に母線に合っている必要はないが, da Vinciの図がなんとなくそうなっているのに従った.

P点に筆記具をつけた伸縮自在の腕 BPは, 母線に沿って回転し, PはDからスタートしてPへ至り, さらにEまで進む. すると放物線DPEが描けるのである.

円錐の角度を一定に保つために, GHがある. 模型で見るように, 放物線を描く面は, 母線と平行に傾けてある. その面の上をPが伸縮しながら放物線を描くのである. 筆記具を平面に押し付けるためか, CPの中間に錘りがぶら下がっているのも面白い.

楕円コンパス

2010-11-01T09:46:00.003+09:00

この世には円(お金ではない)も多いが, 楕円はもっと多いに違いない. 丸いものも正面以外の方向から見ればみな楕円に見える. そもそもが, 惑星の軌道から楕円である. また円は楕円の特殊な場合に過ぎぬ.

正弦や余弦の曲線も正確に手書き出来る人はまずいないが, 楕円や放物線も正確には書きにくい曲線である. 最近楕円型の炬燵があると聞いたが, 見ると陸上競技のトラックの形(小判形)であった. 世の常識はそれも楕円だ.

小学生の頃習った楕円の書き方は, 2本のピンと糸を使うものであった. 実際にやってみると, 鉛筆の芯から糸が外れたりで, 結構苦心する. 与えられた長径2a, 短径2bの楕円を描こうとすると, まずピンの間隔を2√(a²-b²), 糸の輪の長さを2(a+√(a²-b²))にしなければならず, 糸の輪の長さをこのように正確にするのは, 極めて難しい.

従って, 製図では, 楕円上の点を適当にとり, 雲形定規でつなげて描いたりする.

最近はPostScriptさまさまで, 縦横のスケールを変えて円を描けば簡単に出来るようになった. しかし線の太さも影響を受けるのが問題である. 長径a, 短径bの楕円は,


a 0 moveto
1 1 360 {dup cos a mul exch sin b mul lineto} for stroke

で描くのがよい. Processingはellipse関数の方が基本で, 円はその特殊なケースとする. この方が正しいやり方である.

しかし, やはりコンパスで円を描くような, 名案はないであろうか.

Archimedesの楕円コンパスというものがある. 我が家にはそのおもちゃがある.

おもちゃとしては, これは何の軌跡かというクイズなのだが. ...

Archimedesの楕円コンパス下の図のようなものだ.

長さaの棒の一端Pに筆記具, 他端と, 筆記具からbの距離に, それぞれ短軸, 長軸に沿って動くスライダN, Mをつけ, その棒を回転すると, 長径2a, 短径2bの楕円が描ける. この動画はここにある.

∠PMQをθ. Pの座標をx, yとする. x=a cos (θ), y=a sin (θ) - (a - b) sin (θ) = b sin (θ)で, Pの軌跡は, 長径2a, 短径2bの楕円になる.

2007年に東京国立博物館で,「レオナルド・ダ・ヴィンチ--天才の実像」という特別展があった. 殆んどの入場者には, 「受胎告知」が関心の的であったろう.

私の場合は, 「レオナルドの書斎」が面白く, 中でもアトランティコ手稿に基づく楕円作図のためのコンパス[複製]に目がとまった.

上の図のようなものである. 通常のコンパス同様, 回転軸ABがあり, Aを固定し, Bをつまんで回す. 通常のコンパスとは異なり, 軸は傾斜している. その傾斜角を維持するために, 支柱CDとCEがある.

軸上の点Qから腕QPが分かれており, Pに筆記具を着ける. AQPの角 θ が一定になるようにして, 軸を回すと, Pが楕円を描くという仕掛けである. ただし, PQは, 軸が傾斜しているから, 通常のコンパスと違い, 伸縮できなければならない.

このコンパスに味噌は, θを一定にして軸を回転すると, QPを母線として円錐が描け, それを平面で切っているのである.

なるほど, 円錐を斜めに切ると楕円が出来ることの応用と思い, さっそくアニメーションのプログラムを書いた.

これは面白かったので, 2007年のlightweight languages spiritで話をした.

円錐を斜めに切ると, 卵形ではなく, 楕円になるというのも, 直ぐには信じ難い.

上のような図を描くといちおう納得する. 円錐を右上から左下へ平面で切った断面である. 円錐と切った平面に上から内接する球を O , 下から内接する球を O'とする. O と円錐の接円, O'と円錐の接円は赤い横線のようになる. また, O , O' と切った平面の接点をそれぞれ F, F' とする.

さて, 任意の母線ABを考える. この母線と Oの接円, 切った平面, O'の接円との交点を, T, P, T'とする. 球面外の点から, 球面へ引いた接線の, 接点までの距離は等しいから, PT=PFであり, PT'=PF'である. 従って, FP+F'P=PT+PT'=TT'=一定となって, Pは楕円となる.

ところで, da Vinciのコンパスの最大の問題は, 伸縮する腕のことだ. 長い時と短い時の長さの比が大きい腕は作るのが困難である. つまり離心率の大きい楕円は描けない. 私の図でも, 比を2:1にとるのがやっとであった. 要するにこのコンパスは話だけで, 実用には遠いのだ.

Maxwellの面積計

2010-10-24T21:12:00.001+09:00

またまた面積計の話で恐縮だ.

RutherfordJournalには, こういう図

も出ている. 前回(10月15日)のブログにあった図と, 似ているがいささか異なる. これもMaxwellのもう1つの面積計なのだ. その理由はご賢察の通りであるが, 老婆心ながら説明しよう.

前回の図では, 水平軸ABを持つ半球が, 車輪Hの回転と共に回転した. また伸縮棒MSにより, 全球と半球を結ぶ直線と水平軸のなす角が変化した.

今回は, 垂直な回転軸に半球がついており, 図形の周囲を追跡する針の, 回転軸の円周方向の移動に応じて, 半球と全球の仕掛けも回転する. また, 針の, 半径方向の移動は, 前回の図のOMの移動同様に, 回転軸と, 半球と全球を結ぶ直線のなす角を変える.

そうと分かると, 前回は車輪の回転がdxで, 半球と全球の角度がyであったように, 円周方向がdθ, 半径方向がrの極座標で, r dθの極座標での積分をすることになる.

前回のMSは伸縮出来る棒であった. 今回も針の先と, 半球の中心と, 全球の中心が1直線になるような, 伸縮棒でもよいわけだが, 今回は曲線部分を持つ部品が回転し, バネにより, それに接触している半球と全球を結ぶ棒の延長が針先になるように工夫したカム機構になっているのである.

Maxwellは理論的な面にしか関心がなかったらしく, ものは作らず, こういうメカを考えて楽しんでいたらしい.

Maxwellの面積計

2010-10-22T09:46:00.002+09:00

面積計の歴史をウェブで探すといろいろ見つかる. それを読むと, 円錐(cone)がどうのこうのと書いてあったりする. 面積計の基本知識として, このブログでは円錐の機能を説明しよう.

この図は, Johannes Oppikoferの面積計といわれるものである. Maxwellのと違い, 台枠は固定されていて, 手前にある針を前後に動かすと, その支持腕が伸び縮みし, また腕を左右に動かすと, 支持腕とその右にごちゃごちゃ見える機構が一緒に左右に動く.

ごちゃごちゃの機構の中央に横倒しになった円錐が見える. 円錐は, 機構が左右に動くと, その幅に従った角度だけ水平の軸の周りに回転する. また円錐の上方に, 立っている文字盤があり, その下に小さい円板があって, 円錐に接している. この円板から上は, 支持棒の前後の動きと連動しており, 針が奥に行くほど円板は円錐の頂点に近いところで円錐に接するようになる.

つまり, 針が左右に dx 動くとき, 円板, つまり文字盤の回転する量 dφ は, 針の奥からの距離 y に dx を掛けたものに比例するわけである.

というわけで, 面積計になるのだが, 針を前後に動かす時, 円板が円錐面を横車を押すように動くのが, Maxwellたちの気に入らなかったようである. たしかに, Maxwellの半球と全球の機構はそうなっていない.

また, 円錐の母線が奥の方では低くなるので, 円板や文字盤の高さを変えることも考えなければならない.

Oppikoferの面積計は, 1827年に考案され, 1836年にパリで制作, 販売されたそうだ.

マッチ棒の立方体

2010-10-18T22:32:00.002+09:00

すいぶん前のことだが, 数学セミナーにSystem-5というコラムがあった. 東大の高橋秀俊先生, 森口繁一先生, 学習院大学, のちに東大情報科学科の米田信夫先生, 立教大学の島内剛一先生と私が, 持ち回りでなにか書いていた.

今回のブログは, 私が以前そこに書いたものだ.

オランダ Delft大学のvan der Poel先生が大宮の拙宅に来られた時, おみやげといって, 下の写真のようなマッチ棒で出来た箱を下さった. van der Poel先生によると, デンマークのPeter Naur先生(Backus Naur FormのNaurさん)の問題「接着剤を使わずマッチ棒だけで立方体を作れ」を考えた結果作ったものだそうだ.

van der Poel先生に頂いたものは, 遠の昔にどこかへいってしまった. この写真のは, 私がこの週末に作ったものである.

マッチ棒を90本も使っているから, ちらちらするが, 三面図を書いてみると, このようになる. 第3角法になっていて, 右下が正面図, 左が側面図, 上が平面図である. マッチの軸に色が着いていて, 薬の部分が白くなっている.

原理的には, 下の図のように, 3対のカードを組合わせ, 対同士を輪ゴムで止めると立体が出来るのと同様である.

実際に作ってみると, この写真のようになる.

ただ, 輪ゴムは, 接着剤ではないが, 違反であって, 輪ゴムの代りにマッチ棒を使えばいいのである. (上の図の左下.) この図ではマッチ棒は抜けてしまいそうだ. しかし, 別の面の力で絞められると, 抜けなくなるのである.

というわけで, 下の図のように, 1,2,3,...,21の順で, マッチ棒を組み立てると, この立方体が完成する. この図では, 薬の方に色がついている. 20と21では, 上に薬が来る時に色がついている.

この図と三面図の正面図の対応は, こうだ. 1は正面図の底の緑の横向きのマッチ. 2は下から2段目の青の奥向きのマッチ. 3から17は, 赤の横向き, 奥向きのマッチ, 18は上から2段目の青の奥向きのマッチ. 19は蓋の緑の横向きのマッチ. 20と21は平面図の奥向きのマッチである.

しかし, 実際やってみると, 賽の河原よろしく, 出来上がる前に崩れてしまう. まぁ, 完成するには, よく考え, ちょっとしたノウハウを利用する必要がある. それはひみつ.

Maxwellの面積計

2010-10-15T17:27:00.004+09:00

Maxwellといえば電磁気学で習う4つの式や悪魔(demon)を思い出す. 昔の学者はなんでも屋で, そのMaxwellは面積計も, しかも2種類も, 発明したことを最近知った.

Internetで探すと, The Scientific Letters and Papers of James Clerk Maxwellにあるこういう図

や, RutherfordJournalにあるこういう図

が見つかる.

今回は, この面積計の説明である.

下の図を見て欲しい.

これは面積計を上から見たところである. 水平に置かれた回転軸ABがあり, 右方に車輪Hがある. 左方には, 半球KCBがあり, Bが極に対応する. 手前の方, VXに沿って動くMと, 半球の中心Sを通る鉛直軸を結ぶ, 伸縮する棒MSがある. MSから直角に出た枠SDがあり, EFを回転軸とする全球ECB'Fが半球にCで接している. MがOの位置にあると, SDはASと重なり, 全球の赤道DB'が半球の極Bに接し, MがOから左へ行くにつれ, 全球はSを中心に上にあがるが, 球面同士は滑らないものとする. 従って, ∠OSMをθとすると, ∠BSC, ∠B'DCもθである.

面積を計測する時は, 面積計を平行に手前に引いたり, 遠方に押したりしながら, Mが図形の周囲を辿るようにする. RutherfordJournalの図の破線や, 台車の右下の車輪から推察出来る通りである. 面積計の押し引きに応じ, 車輪Hが紙との摩擦で回転し, 同軸の半球も回転し, それに接する全球も回転する.

OMの距離をy, OSの距離をh, 車輪Hの半径をR, 半球, 全球の半径をr とし, 面積計をdxだけ奥に押した時の全球の回転角dψを計算してみる. xの正方向は, Hと半球の向こうへの回転, 全球の手前への回転とする. Hの回転角(radian)は dφ=dx/R. するとC点で半球の緯線が鉛直方向に動く距離は, rsinθdφ. 全球のCでの緯線の半径はr cosθ. 全球の緯線も鉛直方向に同じ長さ動くから, 従って回転角dψ=r sinθdφ/r cosθ=dφtan θ. ところで, tanθ=y/h. ∴dψ=dφy/h=(dx y)/hR.

この面積計で円の面積を計ってみる. R=1, h=2, 円の半径=1とする.

最初, Mを計測対象の赤線の円の真下に置く. この時の半球と全球の中央の経線を赤で示す. 以後の図で,この経線の移動が分かる.

円周の1/4のところまでMが移動した. 面積計も奥へ移動し, 車輪Hが回転し, 半球の目印の経線も1radianだけ回った. ここまででスキャンした面積をオレンジ色で示す. それに相当した角度だけ, 全球も回転した.

Mは円の真上まで来た. 面積計はさらに奥まで移動した. 半球も全球も回転を続ける. 半球の回転角は2 radian. 半球の下側に入ったので, 破線で示す.

円周の右を辿って下がり, 3/4来たところ. 車輪も半球も先ほどとは逆に回転し, 面積を記録している全球も逆回転した.

Mは円周を一周した. 半球の経線は元に戻り, 全球の経線は, 面積πの半分を円周に一致して示す.

Maxwellはこの面積計を作成したわけではない. 実際に作るのは難しそうである.

学者猿コンサル

2010-09-29T14:08:00.002+09:00

前回のブログ(コンサル)は, 検討も設計も多少杜撰であった. 改めて考えた描き方はこうだ.

これは2変数関数の値を表示するいわば計算図表みたいなものである. 計算図表には, 変数の変域があるわけで, 今回はそれをx_minと, x_maxとする. また2つの変数をx₀と, x₁とする. つまりx_min≤x₀, x₁≤x_maxである.

x_minとx_maxの基線の上に, x₀とx₁の点A, Bをとり, それを脚とする長さlの二等辺三角形CABを描く. ACをCで左に135度曲げてDの方向へ長さm(=l/√2)だけ伸ばしDとする. BCをCで右に135度曲げてFの方向へ長さmだけ伸ばしFとする. CD, CFを2辺とする菱形CDEFを作ると, Eが関数の値の場所になり, その座標は(x₀+x₁)/2, (x₁-x₀)/2となる.

x座標は誰にでもすぐ分かるが, y座標がかくもきれいな形なのは不思議である. これからは幾何学だが, まず二等辺三角形CABの底角はどちらもαなので, 頂角∠ACB180-2αである. ACの長さはl, ∠ACDは45度, CDはl/(√2)なので, DACは直角二等辺三角形である. DEの線はDから下向きに45-αなので, 菱形で上半分の角度も同じゆえ, ∠CDEは2α-90. 従って, ∠ADEは180-2αとなり, 先程の頂角とおなじである. また, DA=DE=mだから, DAEはCABと1:√2の相似形であった. 従って, AEはABの1/√2であり, 右側も同じなので, EABは直角二等辺三角形である. ゆえにEのy座標, EHはABの半分, つまり(x₁-x₀)/2である.

y座標は, x₀≤x₁なら正だが, 反対だと負になり, 基線より下になることに注意しよう.

こうして作った減算表(x₁-x₀)が次のものだ. 8-3=5と3-8=-5を示している. もうアニメーションを作る必要はないと思う.

学者猿コンサル

2010-09-26T14:04:00.003+09:00

2010年9月 Brisbaneで開催されたIFIP WCC2010でHistory of Computingのシンポジウムがあった. そこでオーストラリアのMonash大学のJudy Sheardさんが同大学のコンピュータ博物館を紹介した. そのスライドの中に, おや?と思う絵があった. 一瞬の内に次に進んだが, 同行の山田さんがその絵を写真に撮っておられたので, 頂いた.

Consul, the Educated Monkeyという計算関連の教育玩具である. ウェブページで調べると, 1916年頃にアメリカで売り出されたものらしい.

(出典http://www.rechenwerkzeug.de/consul.htm)

使い方はこうだ. 猿の両足を, 図のように下の目盛の3と9に合わせると, 猿の手が示す枠の中に積の27が現れるのである. 目盛の右端の12の右には四角が見えるが, 片足をそこに合わせると, 他方の足の自乗が現れる.

これは乗算表であるが, この表は差し換えられ, 加算にも使える.

こういうものがあると知ったら, プログラムしたくなるのは当然である.

http://playground.iijlab.net/~ew/consul/consul.htmlを見て欲しい. これは十六進の乗算表である. 下の目盛は0からfまであり, 目盛に乗っている足の辺りをマウスで横に動かすと, リンク機構がつられて動き, 赤印の交点の直ぐ上に積が現れるようになっている.

多少の設計ミスで, 0とfの積などでは, 赤印が頭の上に行ってしまうのは, ご愛敬である.

なお, Consulのシミュレータもウェブにあった.

http://www.edumedia-sciences.com/de/a572-consul-the-educated-monkey

入れ子のかっこ

2010-09-16T15:58:00.005+09:00

前回のブログの点記法の続きである. とりあえず練習をしよう. 私の手元のPaul Rosenbloom, The Elements of Mathematical Logic (Dover 1950)に点記法の論理式が沢山出てくる. それでテストしてみた. まずSchemeでBoole値が0と1のnot, or, impを定義する.


(define (not p) (- 1 p))
(define (or p q) (quotient (+ p q 2) 3))
(define (imp p q) (or (not p) q))

テストをするには, mapが便利.


(map not '(0 1)) => (1 0)
(map or '(0 0 1 1) (0 1 0 1)) => (0 1 1 1)
(map imp '(0 0 1 1) '(0 1 0 1)) => (1 1 0 1)

上の本では, 沢山並ぶ -> には特にかっこを(点で)示さない. -> はleft associativeであって, (p -> q -> r) は ((p -> q) -> r) なのだ.

ではやってみよう.


I4 p -> .q -> r. -> .p -> q -> .p -> r
かっこに変えると
((p -> (q -> r)) -> ((p -> q) -> (p -> r)))
Schemeの定義は
(define (i4 p q r)
 (imp (imp p (imp q r)) (imp (imp p q) (imp p r))))
実行
(map i4 '(0 0 0 0 1 1 1 1) '(0 0 1 1 0 0 1 1)
    '(0 1 0 1 0 1 0 1))
=> (1 1 1 1 1 1 1 1)

もう1つ.


T2 q -> r -> .p -> q -> .p -> r
かっこに変えると
((q -> r) -> ((p -> q) -> (p -> r)))
Schemeの定義は
(define (t2 p q r)
 (imp (imp q r) (imp (imp p q) (imp p r))))
実行
(map t2 '(0 0 0 0 1 1 1 1) '(0 0 1 1 0 0 1 1)
    '(0 1 0 1 0 1 0 1))
=> (1 1 1 1 1 1 1 1)

とうまくいく.

かっこ記法と点記法の変換だが, まずかっこから点へは, すべての2項演算子をかっこでくくることにし, つまり


<primary>==<letter>|(<expression>)
<expression>==<primary>|<expression>*<expression>

だけとする. expressionの例は a, a * b, (a * b) * c, ...など.

expression * expression を点記法にするには, expression' lp * rp expression とする. expression'はexpressionを点記法に変えたものである. lpとrpは, 左右のexpressionをひとまとまりにする点である. lpは左のexpression'で使った最大の右点の数より多く, rpは右のexpressionで使った最大の左点の数より多くなければならない. 従って, 下請けの変換は, expression'を返すと同時に, 自分の使った右点, 左点を返すことにする.

letterの場合は, letterの他に, 右点,左点として, 0,0を返す.

* の場合は, 左の式を変換て置き, その右点+1の左点を置き, 演算子を置き, 右の式を変換し, その左点+1の右点を置き, 右の式を置く. また自分で使った左点, 右点も返す.


(define (dotconv exp)
(display (list exp))
(if (symbol? exp) (list '(0 0) exp)
(let* ((l (dotconv (car exp)))
       (r (dotconv (caddr exp)))
       (op (cadr exp))
       (rlp (+ (cadar l) 1))
       (le (cadr l))
       (lrp (+ (cadar r) 1))
       (re (cadr r)))
       (list (list rlp lrp)(list le rlp op lrp re)))))


(dotconv 'a) => ((0 0) a)
(dotconv '(a * b)) => ((1 1) (a 1 * 1 b))
(dotconv '((a * b) * c)) => ((2 1) ((a 1 * 1 b) 2 * 1 c))
(dotconv '((a * b) * (c * d))) => 
   ((2 2) ((a 1 * 1 b) 2 * 2 (c 1 * 1 d)))

この後は ((a 1 * 1 b) 2 * 2 (c 1 * 1 d)) を a * b . * . c * d にしたい. flattenし, 整数はそれ引く1の点を出力する.

(flatten '((a 1 * 1 b) 2 * 2 (c 1 * 1 d))) => (a 1 * 1 b 2 * 2 c 1 * 1 d)


(define (convstream l)
 (apply string-append (apply append
  (map (lambda (x)
   (list (if (number? x) (make-string (- x 1) #\.)
             (symbol->string x)) " "))
       (flatten l)))))

(convstream '((a 1 * 1 b) 2 * 2 (c 1 * 1 d)))

(define (par->dot exp) (convstream (cdr (dotconv exp))))

(par->dot 'a) => "a "
(par->dot '(a * b)) => "a  *  b "
(par->dot '((a * b) * c)) => "a  *  b . *  c "
(par->dot '((a * b) * (c * d))) => "a  *  b . * . c  *  d "

一方, 私の考えた逆変換はこうだ.


1.(((a * b) * (c * d)) * ((e * f) * (g * h)))
2."a * b . * . c * d .. * .. e * f . * . g * h "

                       1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2 2
   0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8
3.(a 0 * 0 b 1 * 1 c 0 * 0 d 2 * 2 e 0 * 0 f 1 * 1 g 0 * 0 h)
4.29
5.((-1 5) (-1 13) (15 21) (23 29) (15 29) (7 13))
6.(< < < a * b > * < c * d > > * < < e * f > * < g * h > > >)
7.(((a * b) * (c * d)) * ((e * f) * (g * h)))

上の例で, 1. は元のかっこ記法の式. 2. はそれを点記法にしたもの. 逆変換はここから始まる. まず各演算子に左点と右点があるものとし, 3のように変換する. その上の2行は, 各要素の位置を示す. 0から28まであるから, lengthをとると, 4. のように, 29.

位置 1,5,9,..のように, 4を法として1の位置は左点. 3の位置は右点である. さらに, 演算子は2(mod 4), 変数は0(mod 4)である.

次に各右点>0にはこの右方にある相棒の左点を探し, また左点>0にはこの左方にある右点を探し, 対にする. 上の例では 5. が対のリストである. この読み方は, 5の位置の左点を越える右点は, 左方にはないので, -1とし, (-1 5)とする. 13の位置の左点も同じ. 21の位置の左点は, 15の位置の右点の方が大きいので, スコープはここまでとなり, (15 21)が出来る. 3. と5. の情報から, 6. を作るのだが, (-1 5)のような対があれば, -1に左かっこ, 5に右かっこを置く. この挿入で, 位置がずれると困るから, 挿入は番号の多い右端から行う. 右かっこと左かっこの区別は, 4を法とした剰余の1か3で決る. まだこの段階は記号列であるが, 通常のかっこを記号として挿入すると, 分かり難いから, 角かっこを使っている. 出来たのは6. である.後は, 入れ子の式の読込みルーチンを書けばよい. それにより, 7. が得られる.


(define (iconv s)  ;2. -> 3.
 (define (char->symbol c)
  (string->symbol (list->string (list c))))
 (define (reads n s)
  (cond ((null? s) s)
        ((char=? (car s) #\Space) (reads n (cdr s)))
        ((char=? (car s) #\.) (reads (+ n 1) (cdr s)))
        (else (cons n
          (cons (char->symbol (car s)) (reads 0 (cdr s)))))))
 (let ((ss (string->list s)))
   (cons (char->symbol (car ss)) (reads 0 (cdr ss)))))

(define (makepair s)  ;3. -> 5.
 (let ((len (length s)) (ps '()))
  (do ((i 3  (+ i 4))) ((>= i len))
   (let ((r (list-ref s i)) (k len))
    (do ((j (- len 4) (- j 4))) ((< j i))
     (let ((l (list-ref s j)))
      (if (< r l) (set! k j))))
    (if (> (- k i) 2) (set! ps (cons (list i k) ps)))))
  (do ((i (- len 4) (- i 4))) ((< i 0))
   (let ((l (list-ref s i)) (k -1))
    (do ((j 3 (+ j 4))) ((> j i))
     (let ((r (list-ref s j)))
      (if (> r l) (set! k j))))
    (if (> (- i k) 2) (set! ps (cons (list k i) ps)))))
  ps))

(define (makestr ps s len)   ;5. 3. (length 3) -> 6.
 (define (insert l n a)
  (if (<=  n 0) (cons a l)
   (cons (car l) (insert (cdr l) (- n 1) a))))
 (set! ps (sort (apply append ps) >))
 (for-each (lambda (x) (set! s (insert s x
   (if (= (modulo x 4) 3) '< '>))))  ps)
 (append '(<) (filter symbol? s) '(>)))

(define (str->sexp str) (define i 0)  ;6. -> 7.
 (define (getch) (let ((ch (list-ref str i)))
   (set! i (+ i 1)) ch))
 (define (read) (let ((ch (getch)))
  (cond ((eq? ch '<) (readtail))
        ((eq? ch '>) '())
        (else ch))))
 (define (readtail) (let ((x (read)))
  (if (null? x) x (cons x (readtail)))))
 (read))

入れ子のかっこ

2010-09-05T15:39:00.004+09:00

Lispの好きな人は, かっこだらけのS式を何とも思わない. 反対にhtmlのようなタグでの入れ子には耐えられない.

しかし, S式を声を出して読む時, 「かっこ開く」「かっこ閉じる」や「左かっこ」「右かっこ」というのは煩わしい. 私は昔から,左かっこを「かっこ」, 右かっこを「こっか」と読むことにしている. (Algol 68で, 添字に使う [ と ] を, sub symbol, bus symbolと呼んでいたのをまねした.)

ところで, 今回の話題は, 自然言語の構文解析である. 構文解析木を図で表わすのは容易だが, かっこ付きでも表わせる.

Time flies like an arrow は光陰矢の如しと構文解析するのが普通だが, 時間の蝿は矢が好きだという笑い話もある. 前者は Time (flies (like an arrow)), 後者は (Time flies) like an arrow と表現すればよい.

SICPに簡単な自然言語解析の話がある. その問題4.45は, The professor lectures to the student in the class with the cat を5通りに構文解析せよ, だ. やってみると


1  ((the professor)
     (((lectures
           (to (the student)))
         (in (the class)))
       (with (the cat))))
2  ((the professor)
     ((lectures
         (to (the student)))
       (in ((the class)
           (with (the cat))))))
3  ((the professor)
     ((lectures
         (to ((the student)
             (in (the class)))))
       (with (the cat))))
4  ((the professor)
     (lectures
       (to (((the student)
             (in (the class)))
           (with (the cat))))))
5  ((the professor)
     (lectures
       (to ((the student)
           (in ((the class)
               (with (the cat))))))))

それぞれの和訳は

1 教授は(猫を連れて(教室で(学生に講義する)))
2 教授は((猫を連れた教室)で(学生に講義する))
3 教授は(猫を連れて((教室の学生)に講義する))
4 教授は((猫を連れた(教室の学生))に講義する)
5 教授は(((猫を連れた教室)の学生)に講義する)

猫を連れているのは, 1と3は教授. 2と5は教室. 4は学生である.

ウェブを眺めていて, H.B.Curryの書いたページを見つけた. ただで見られるのは1ページ目だけだが, 今はそれだけ見られれば充分である.

論理の式には, かっこの代りに点が打ってあるものがある. 件のページには, その提案が書いてある.

Let us suppose that a group of dots on the right of an operation or prefix denotes the beginning of a bracket which extends to the right until it meets a group with an equal or larger number of dots on the left of an operation; and that the scope of a group of dots on the left of an operation shall extend to the left unitl it reaches a larger group of dots on right of some operation.

つまり,
p -> q . -> . q -> r .. -> . p -> r
は
((p -> q) -> (q -> r)) -> (p -> r)
のことである.

この方式を何と言うか知らないが, dot notation つまり点記法ということにする.

上の和訳の入れ子のかっこ構造から, 点記法を使い, かっこを外したい. それには, 演算子がどれか決めたい. 演算子は左かっこの右, 右かっこの左にあるのだから,

教授は猫を連れた教室の学生に講義する

の赤字の助詞類を演算子と考える. (猫を連れた, 教室のは形容詞句の時で, 副詞句の時は, 猫を連れて, 教室でになる.)

すると, それぞれの例文は

1 教授は . 猫を連れて . 教室で . 学生に講義する
2 教授は .. 猫を連れた教室 . で . 学生に講義する
3 教授は . 猫を連れて .. 教室の学生 . に講義する
4 教授は ... 猫を連れた . 教室の学生 .. に講義する
5 教授は .. 猫を連れた教室 . の学生 . に講義する

となる.

この点を , 2点を ,, に変えると
1 教授は, 猫を連れて, 教室で, 学生に講義する
2 教授は,, 猫を連れた教室, で, 学生に講義する
3 教授は, 猫を連れて,, 教室の学生, に講義する
4 教授は,,, 猫を連れた, 教室の学生,, に講義する
5 教授は,, 猫を連れた教室, の学生, に講義する
のようになる.

点記法に慣れると, これで読めなくもない. では声を出して読むにはどうするか.

Shakespeareの時代, 劇の台本には句読点が何種類かあり, それぞれで間の取り方が違うという話を読んだことがある. そのように, カンマ2つはカンマ1つより長く間をとれば, この例は構文木が分かるのではないかと考えるが, どうだろうか.

Penroseタイル

2010-08-29T16:06:00.002+09:00

GoogleでPenrose tileの記事を眺めていたら, Penrose tileは3 colorableという記述が! ジャジャーン. 平面の地図は4色で塗り分けられるが, 3色で塗り分けられるというわけだ. さっそく前回のブログの最後の図をプリントし, 4色のマーカーを手に, 塗り分けてみると, 確かに3色でうまく行く.

余談だが, 慶應の皆さんは, 慶應の校旗はblue red and blueの3色といい, 私の2010年5月13日のブログのように, オランダ国旗も3色だ. ジャジャーン.言語学者の用語では, 「サイタサイタサクラガサイタ」は, 延べ語数5,異なり語数3という. その伝では, 慶應の校旗は述べ3色旗. オランダ国旗は異なり3色旗である. Penrose tileは異なり3色で塗り分け可能である.

数学者なら, 3色塗り分け可能を証明するわけだが, 私の場合はプログラムで,3色塗り分けしたい. さっそくトライ.

前回のブログの最後にプログラムがあるが, そこで分かるように, それぞれの線分はtranslateで原点を移動し, rotateで向きを変えたユーザ座標て描いている. これでは誰が隣りかは判明しない. どうすれば絶対座標(装置座標)で描けるか, PostScriptのマニュアルをみると, transformという関数がある. PostScriptでは,装置座標とユーザ座標の関係は, current matrixが記憶していて, transformはユーザ座標を装置座標にしてくれるらしい.

ところが,例えば kite0のn=0の部分を0 0 transform == phi2 36 xy transform == phi -72 xy transform ==のようにし,
[1 0 0 1 0 0] setmatrix
300 400 translate
/n 0 def init
0 0 0 kite0

で起動すると, kite0の3点は,

A 300.0 400.0
B 469.442719 523.107361
C 340.0 276.892639
と出力された.

今, 単位長さが80なので, すこし計算してみる.
(* 80 phi phi (cos (d2r 36))) => 169.4427190999916
(* 80 phi phi (sin (d2r 36))) => 123.10734148701015
(* 80 phi (cos (d2r -72)) => 40.00000000000001
(* 80 phi (sin (d2r -72))) => -123.10734148701013

理由は分からないが, AとBは正しい; CはAから-72度の方向に移動した距離になっている. それが分かればあとはプログラムでCの位置は計算出来る.

こうしてkite0, kite1, dart0, dart1の3点の座標が得られた. 次はkite0とkite1, dart0とdart1を組合わせる. 始点と終点は合っているから, それらを対にする. 相棒のないのは外す. こうして95の四辺形が揃った. 各四辺形には0から94まで番号をつける.

次は隣りどうしを探す作業で, alistを作り, 辺を登録したり探索したりして,隣組のリストが出来た. 両方から指すこともないので, 自分より番号の少ない隣りの四辺形のリストになっている.

次にそれぞれに色0,1,2を対応させる. 目で見てやるのと違うから,バックトラックすることになる. SICPの8クィーン(ex2.42)のプログラムをちょっと改造して書いてみたが, これは全解探索だし, 深さも8段から95段になるので,たちまち再帰のオーバーフローを起した. うーん. 駄目か.

仕方ないので, 通常のバックトラックのプログラムを書く.解が1つ見つかったところで, call-ccを使って脱出する.


(define next' (() (0) () (0 2) (2 1) (3) (5) () (7) ()
(7 9 0) (10 0) (9 8) (7) (7 13 5 3) (6 13) (15 6) () (17) ()
(17 19) (19 18) (20) (22) () (24 2) (25 2 5) (4) ()
(24 28 17) (29 17) (28 27 25) (24 26) (24 32 22 20)
(23 6 32) (16 34 23) () (36) () (36 38) (38 37) (39) (41) ()
(43 19) (44 19 22) (21) () (43 47 36) (48 36) (47 46 44)
(43 45) (43 51 41 39) (42 23 51) (35 53 42) () (55) ()
(55 57) (57 56) (58) (60) () (62 38) (63 38 41) (40) ()
(62 66 55) (67 55) (66 65 63) (62 64) (62 70 60 58)
(61 42 70) (54 72 61) () (74) (8) (76 8 13) (74 76) (76 75)
(79 12) (78 77) (81 15) () (83 57) (84 57 60) (59) ()
(83 87 74) (88 74) (87 86 84) (83 85) (83 91 81 78)
(82 61 91) (73 93 82 16)))
(define colorlist '())
(define (search)
 (call-with-current-continuation
  (lambda (throw)
 (define (safe? n c)
  (let ((es (list-ref next n)) (revc (reverse colorlist)))
  (not (member c (map (lambda (x) (list-ref revc x)) es)))))
 (define (test n)
  (if (= n 95) (throw (reverse colorlist))
   (do ((m 0 (+ m 1))) ((= m 3))
    (let ((c (modulo (+ m n) 3)))
     (if (safe? n c)
      (begin (set! colorlist (cons c colorlist))
             (test (+ n 1))
             (set! colorlist (cdr colorlist))))))))
 (test 0))))
(search)

ジャジャーン. これでやっと色のリストが得られた.


(0 1 2 1 0 2 0 1 2 0 2 1 1 2 0 1 2 2 0 1 0 2 1 2 1 0 1 1 1 0
 1 2 0 2 1 0 0 1 2 1 0 2 0 1 2 0 1 1 2 1 0 2 0 1 2 1 2 0 2 1
 0 1 2 0 1 2 2 0 2 1 0 1 2 0 2 0 1 0 0 2 0 1 2 0 1 2 2 2 1 0
 0 1 2 0 1)

結果はご覧の通り.