FFTを作ろう
time領域と周波数領域
このワークシートはMath by Codeの一部です。
アプレット、背景、実装の順に見ていきましょう。
フーリエ変換のよさはオイラーがeixに三角関数を詰め込んでくれた周期Ｔを∞にすることで、
周期的でない波の周波数分析ができるようになることだ。
しかし、難点は積分と複素数計算が必要になること、そして、関数が連続的であることだ。
サンプリングデータはデジタルで、離散量だ。
そこで、離散フーリエ変換が考案された。今回は離散フーリエ変換とその高速化としてのFFTを調べてみよう。
１．背景
＜フーリエ変換をデジタル化しよう＞
調べる時間がＴ秒間で、サンプリング間隔がＤ秒だとすると、n=T/D
時刻リストts={0,D,2D,....(n-1)D}に対する
f(t)のデータx={x0, x1,x2,....x(n-1)}が得られたとしよう。
xj=f(jD)という関係ができます。サンプリングなので、f(t)の関数式は不明でもよいでしょう。
ｆ(t)が連続的なときと同様にxt =...+c-1e-ik-1t+c0+c1eik1t+......= Σcn eiknt(‐∞,∞)とします。
たとえば、n=4 のとき、ts={0, D, 2D, 3D}に対して、xt=c0+ c1eik1t+c2eik2t+c3eik3tとおける。
T=nDだから、eikt＝ei2πt/T＝ei2πt/nD, t=jDのとき、eikjD＝ei2π jD/nD＝ei2πj/n ＝ei2πj/n=(j)とおこう。
つまり、(j)はガウス平面の単位円のn等分のj番目の点です。(j)の共役複素数を(-j)とおこう。
n=4なら、{(0),(1),(2),(3),(4),(5),(6),(7),(8),(9)}={1,i,-1,-i, 1,i,-1,-i, 1, i}
{(-1),(-2),(-3),(-4),(-5),(-6),(-7),(-8),(-9)}={-i,-1,i, 1, -i,-1,i, 1,-i }
この場合は、複素数と共役複素数の積は(i)*(-i)=(i-i)=(0)=1になります。
するとn=4なら、
xj=c0(0)+c1(j)+c2(2j)+c3(3j)だから、
x0=c0+c1(0)+c2(0)+c3(0)
x1=c0+c1(1)+c2(2)+c3(3)
x2=c0+c1(2)+c2(4)+c3(6)
x3=c0+c1(3)+c2(6)+c3(9)
これで、４つの時刻に対する音や波の信号データから、フーリエ係数c0,c1,c2,c3を逆算して、求めることができるはずだ。
ベクトルと行列で再表現してみよう。
この式を、ベクトルA＝[c0,c1,c2,c3]からベクトルx=[x0,x1,x2,x3]を求める
かけ算ｘ＝Ａｃとするとき、これが逆離散フーリエ変換（IDFT）で、
この逆算のc=A-1xが離散フーリエ変換(DFT)です。
A={{1, 1 , 1 , 1 },
{1, (1),(2),(3)},
{1, (2),(4),(6)},
{1, (3),(6),(9)}}
Aの随伴行列（共役複素数にして転置した行列）B=*Ａは
B={{1, 1, 1, 1},
{1,(-1),(-2),(-3)},
{1,(-2),(-4),(-6)},
{1,(-3),(-6),(-9)}}
積BAは、とても特徴的な結果になるね。
Bのi行とAのi列の内積は
(i=1のとき) 1^2+1^2+1^2+1^2=4。
(i=2のとき) 1*(1)+1*(-1)+2*(-2)+3*(-3)＝1×4=4
(i=3のとき) 1*(1)+2*(-2)+4*(-4)+6*(-6)＝1×4=4
(i=4のとき) 1*(1)+3*(-3)+6*(-6)+9*(-9)＝1×4=4
つまり、BAの対角成分はすべて４になる。
Bのj行とAi列の内積は、合同式と同様に(i)=(i+4),番号が2の差の和は(i)+(i+2)=0、
番号の定数倍は分配法則のように外に出せる。指数法則が使えて(i)(j)=(i+j)。
i=1: (j=2) (0)+(-1)+(-2)+(-3)=(0)+(3)+(2)+(1)=0, (j=3) (0)+(-2)+(-4)+(-6)=2*0=0 (j=4) 3*0=0
i=2: (j=3) (0)(0)+(1)(-2)+(2)(-4)+(3)(-6)=(0)(0)+(1-2)+(2-4)+(3-6)= (0)+(3)+(2)+(1)=0
(j=4) (0)(0)+(1)(-3)+(2)(-6)+(3)(-9)=(0)(0)+(1)(1)+(2)(2)+(3)(3)= (0)+(2)+(4)+(6)=2*0=0
i=3: (j=4) (0)(0)+(2)(-3)+(4)(-6)+(6)(-9)=(0)(0)+(2-3)+(4-6)+(6-9)= (0)+(-1)+(-2)+(-3)=(-1)*0=0
一般に、Bj×Ai=(0)(0)+(i)(-j)+(2i)(-2j)+(3i)(-3j)=(0)+(i-j)+(2(i-j))+(3(i-j))=(i-j){(0)+(1)+(2)+(3)}=(i-j)0=0
だから、対角成分以外の内積は０になる。
結局は単位行列をEとすると、BA＝4Eとなるね。
だから、ｘ＝Acの両辺に左からBをかけると、
Bx=BAｃ＝4Ec=4cになる。これから、c=1/4 Bxになる。A-1=1/4Bということだ。
＜FFTの行列＞
離散フーリエ変換と逆変換は、
普通のフーリエ変換の発想をデジタルデータでできるようにした点がすばらしい。
しかし、弱点がある。
n=4のときは、4×4回の複素数のかけ算が必要になる。nの2乗の計算オーダーは大きすぎる。
その弱点を克服するのが高速(fast)フーリエ変換（FFT)という計算手順だ。
新しい発想というよりも、アルゴリズムの工夫と考えた方がよいでしょう。
n=2,4,8,16と観測範囲Tを等分する数を倍ばいに増やすことで、規則を見つけよう。
ベクトルｃ＝[c0,c1,c2,c3,......]、x=[x0,x1,x2,x3,........]
さらに、4c=X=4[c0,c1,c2,c3,.......]=[X0,X1,X2,X3,..........]とする。Aの随伴行列がB=*A。
X=Bx（離散フーリエ変換）の行列Bの特徴をさぐろう。
n=2のとき、行列Bはガウス平面の単位円の正２角形（線分） の頂点。(0)=1, (1)=-1。
合同式のように(i)=(i+2)で、{(0),(1)}={1,-1}
n=4のとき、行列Bは正４角形の頂点。(0)=1, (1)= i。
合同式と同様に(i)=(i+4)で、{(0),(1),(2),(3)}={1,i,-1,-i}
n=8のとき、行列Bは正８角形の頂点。(0)=1,(1)=1/√2(1+i)
合同式と同様に(i)=(i+8)で、{(0),(2),(4),(6)}={1,i,-1,-i}
B={{(0),(0),(0),(0),(0),(0),(0),(0)}
{(0),(-1),(-2),(-3),(-4),(-5),(-6),(-7)},
{(0),(-2),(-4),(-6),(-8),(-10),(-12),(-14)},
{(0),(-3),(-6),(-9),(-12),(-15),(-18),(-21)},
{(0),(-4),(-8),(-12),(-16),(-20),(-24),(-28)},
{(0),(-5),(-10),(-15),(-20),(-25),(-30),(-35)},
{(0),(-6),(-12),(-18),(-24),(-30),(-36),(-42)},
{(0),(-7),(-14),(-21),(-28),(-35),(-42),(-49)}}
={{(0),(0),(0),(0),(0),(0),(0),(0)}
{(0),(7),(6),(5),(4),(3),(2),(1)},
{(0),(6),(4),(2),(0),(6),(4),(2)},
{(0),(5),(2),(7),(4),(1),(6),(3)},
{(0),(4),(0),(4),(0),(4),(0),(4)},
{(0),(3),(6),(1),(4),(7),(2),(5)},
{(0),(2),(4),(6),(0),(2),(4),(6)},
{(0),(1),(2),(3),(4),(5),(6),(7)}}
データ数nは2のp乗。pがビット数。
(j)はガウス平面での単位円周上の点で,１＋０i を(0)とする、j番目の複素数を表しているね。
＜FFTの数式の規則性＞
次は、X=Bx（離散フーリエ変換）の行列Bにx=[{x0},{x1},{x2},{x3},......]をかけたときの数式の規則性を探ろう。
・ n=2のとき、(0)=1, (1)=-1で、
X=Bｘは、[{X0},{X1}]={{x0+x1, x0+(1)x1}だから、
X0=x0+x1, X1=x0-x1（和と差）になる。
・n=4のとき、{(0),(1),(2),(3)}={1,i,-1,-i}で、
正方形の頂点の時計回り回転の1個分、回転子w=(-1)=-i=(3)、w0=1
X=Bxは、{{X0},{X1},{X2},{X3}]
={{x0+x1+x2+x3},(x0+(3)x1+(2)x2+(1)x3},{x0+(2)x1+(0)x2+(2)x3},{x0+(1)x1+(2)x2+(3)x3}}
={{x0+x1+x2+x3},(x0-ix1-x2+ix3},{x0 - x1 +x2 - x3},{x0+x1i-x2-ix3}}
={{(x0+x2)+(x1+x3)},{(x0-x2) +w(x1-x3)},{(x0 +x2)- (x1+x3)},{(x0-x2)-w(x1-x3)}}
{{X0},{X1},
{X2},{X3}}
={{(x0+x2)+(x1+x3)},{(x0-x2) +w(x1-x3)},
{(x0 +x2)- (x1+x3)},{(x0-x2) -w(x1-x3)}}
{X0},{X2}だけ見ると、x=[x0,x1,x2,x3}=>L={x0,x1},R={x2,x3}のようにｘを前半Lと後半Rに分ける。
対応する番号どうしの和、(x0+x2)と(x1+x3)を求めた上で、さらに（和と差）を求めている。
これはn=2と同じ。
{X1},{X3}だけ見ると、x=[x0,x1,x2,x3}=>L={x0,x1},R={x2,x3}
対応する番号どうしの差,(x0-x2)、(x1-x3)それぞれのw0、w1倍求めて、（和と差）を求めている。
・n=8のとき、行列Bは正８角形の頂点。(0)=1,(1)=1/√2(1+i) 、{(0),(2),(4),(6)}={1,i,-1,-i}
Bｘ={{X0},{X1},{X2},{X3},{X4},{X5},{X6},{X7}]
={{x0+x1+x2+x3+x4+x5+x6+x7}
{x0+(7)x1+(6)x2+(5)x3+(4)x4+(3)x5+(2)x6+(1)x7},
{x0-ix1-x2+ix3+x4-ix5-x6+ix7},
{x0+(5)x1+(2)x2+(7)x3+(4)x4+(1)x5+(6)x6+(3)x7},
{x0- x1+ x2 - x3 + x4 - x5 + x6 -x7},
{x0+(3)x1+(6)x2+(1)x3+(4)x4+(7)x5+(2)x6+(5)x7},
{x0+ix1-x2-ix3+x4+ix5-x6-ix7},
{x0+(1)x1+(2)x2+(3)x3+(4)x4+(5)x5+(6)x6+(7)x7}}
{{X0},{X2},
{X4},{X6}}
={{x0+x1+x2+x3+x4+x5+x6+x7}, {x0-ix1-x2+ix3+x4-ix5-x6+ix7},
{x0- x1+ x2 -x3+x4 -x5 + x6 -x7}, {x0+ix1-x2-ix3+x4+ix5-x6-ix7},
={{[(x0+x4)+(x2+x6)]+[(x1+x5)+(x3+x7)]}, {w0[(x0+x4)-(x2+x6)]+w1[(x1+x5)-(x3+x7)]},
{([x0+x4)+ (x2+ x6)]- [(x1+x3) +(x5+x7)]}}, {w0[(x0+x4)-(x2+x6)]-w1[(x1+x5)-(x3+x7)]},
{X0},{X4}だけ見ると、x=[x0,x1,x2,....,x7}=>L={x0,x1,x2,x3},R={x4,x5,x6,x7}のようにｘをLとRに2分して、
対応する番号どうしの和リスト{(x0+x4),(x1+x5),(x2+x6),(x3+x7)}をLとRに分け、n=4のように対応する順に和(x0+x4)+(x2+x6)]と[(x1+x5)+(x3+x7)]を求め、さらにn=2のように和と差を求めています。
{X2},{X6}も{(x0+x4),(x1+x5),(x2+x6),(x3+x7)}をLとRに分けるところまでは、同じでn=4のように対応する順に差のw0倍とw1倍を求めて、n=2のように和と差を求めています。
正８角形の時計回りの回転の1個分、回転子p=(-1)=1/√2(1-i)
{(0),(1),(2),(3),(4),(5),(6),(7)}={p0,p7,p6,p5,p4,p3,p2,p1}={p0,-p3,-p2,-p1,-p0,p3,p2,p1}
={1, -p3, -p2=i , -p1, -1,p3, p2=-i, p1 } , p3=p1*p2=p1*w
{{X1},{X3},
{X5},{X7}}
= {x0+(7)x1+(6)x2+(5)x3+(4)x4+(3)x5+(2)x6+(1)x7}, {x0+(5)x1+(2)x2+(7)x3+(4)x4+(1)x5+(6)x6+(3)x7},
{x0+(3)x1+(6)x2+(1)x3+(4)x4+(7)x5+(2)x6+(5)x7}, {x0+(1)x1+(2)x2+(3)x3+(4)x4+(5)x5+(6)x6+(7)x7}}
= {x0+p1x1+p2x2+p3x3-x4-p1x5-p2x6-p3x7}, {x0+p3x1-p2x2+p1x3-x4-p3x5+p2x6-p1x7},
{x0-p1x1+p2x2-p3x3-x4+p1x5-p2x6+p3x7}, {x0-p3x1-p2x2-p1x3-x4+p3x5+p2x6+p1x7}}
= {[(x0-x4)+p2(x2-x6)]+[p1(x1-x5)+p3(x3-x7)}, {w0[(x0-x4)-p2(x2-x6)]+w1[p1(x1-x5)+p3(x3-x7)]},
{[(x0-x4) +p2(x2-x6)]-[p1(x1-x5) +p3(x3-x7)]}, {w0[(x0-x4)-p2(x2-x6)]-w1[p1(x1-x5)+p3(x3-x7)]}}
{X1},{X5}だけ見ると、x=[x0,x1,x2,....,x7}=>L={x0,x1,x2,x3},R={x4,x5,x6,x7}のようにｘをLとRに2分して、
対応する番号どうしの差(x0-x4),(x1-x5),(x2-x6),(x3ーx7)にそれぞれのp0,p1,p2,p3倍を求めます。その4項目をLとRに分けて、n=4のように対応する和[p0(x0-x4)+p2(x2-x6)],[p1(x1-x5)+p3(x3ーx7)]を求めてから、n=2のように和と差を求めています。
{X3},{X7}だけ見ても同様で、n=4の段階で対応する順に差のw0倍とw1倍を求めて、n=2のように和と差を求めています。
こうしてみると、FFTのアルゴリズムの基本は、
ｘをLとRに分けて、対応する番号順の和と差にし、
差については、回転子にリストの番号乗をしてかけることです。
これをn=8,n=4,n=2に対して再帰的に実行しよう。
すると、
時間順に区切った音波の振幅データx=[x0,x1,x2,x3,x4,x5,x6,x7]に対してX=[X0,X4,X2,X6,X1,X5,X3,X7]を順に求めることができますね。
このインデックスの入れ替わりは2進数にしたときに左右逆転する数同士になっていることを使うと、
計算で求めることもできるはず。
このXをインデックス順に並べ替えることで、
[X0,X1,X2,X3,X4,X5,X6,X7]が周波数を小さい順にならべた周波数特性のデータになります。
FFTを使うと、たとえば、n=8の場合複素数のかけ算が8*8=64個出てきます。
n=4にsizeダウンしたことで、8/2=4個。n=2にサイズダウンしたことで、4/2=2個を2回。
結果として、4+2*2=4×2=8個ですみます。
一般に、サイズがnなら複素数のかけ算の回数がn^2回からFFTでn/2×(log2(n)-1)回に激減します。
N*NのオーダーからN*logNのオーダーに減るということですね。
２．実装
質問：FFTをpythonで実装するにはどうしたらよいでしょうか。
FFTの核心となる関数を作りましょう。
FFTのロジック、音声データlstとインデックスnumsを受け取り、どんどん2等分、対応する順に和データと差データを作る関数sizeDownです。
lstのサイズsegから、その半分のサイズsubsize=seg/2を得ます。
lstの0番以上subsize未満、つまり前半をLとします。
L=lst[ :subsize]です。同じように、残り半分がR=lst[subsize: ]です。
（最初のインデックスnumsも左と右に2等分して、後々まで引き継げるようにして、渡します。）
このLとRをジッパーのように、対応する順の和リストLA=[l+r for l,r in zip(l,r)]を求めましょう。
同様に差のリストRdif=[l-r for l,r zip(l,r)]を求めましょう。
ただし、差の方は、三角関数を使って、回転子w=e ^(- 2pi / seg) のｋ乗を求める無名関数wを作っておいて指数を求めるための０から始まるインデックスnumを作ります。
RM=[r*(w(idx)) for r, idx in zip( Rdif, num)]
これで、下半分のリストができました。
あとは、再帰関数としてどんどんサイズを半分して計算します。
再帰関数の脱出条件はサイズseg==1です。
1個になったら最初にもらったインデックス番号リストnumsの内容[0]を受け取り、
その番号をビット反転関数bit_revにより、入れ替わってしまったXの番号で、データを辞書resltXに記録しましょう。
全体の流れはFFT関数で作ります。
うけとった波形データをtargetとしてうけとったら、サイズN = len(target)を求めます。
Nを使って、０からN-1までの調査データにインデックスをつけるためのリストnumsを用意します。
データ数は２のべき乗なので、２の何乗かを bits = int(np.log2(N))で求めましょう。
sizeDown関数にtargetデータ,インデックスリストnums,ビット数bits, 計算結果辞書fftDictを渡します。
処理の結果はfftDictで参照されるため、あとは計算結果辞書fftDictを正しい順にします。
FFTは調査時間が長いと周波数の小さい部分の振幅が大きくなりすぎるので、
データ数Nで割って正規化しましょう。
実際に色々やってみると、微小な虚部がじゃまだったり、必要以上に表示の桁数が増えて
データの可読性が下がるためにto_real関数で小数点以下の桁数をけずっています。
ビット反転はbit_rev（n, bits)関数でやります。
bitsは2進数にしたときの桁数です。たとえば、n=3,bits=3とすると、
n=3は2進数では、n=011です。
これをreturn で110(つまり6）が返ればよいですね。for i in range(bits)で３けた分、
i=0,1,2動かして調べます。
n>>i はiけた右にずらすので、011, 001, 000となります。
& 001をしてtrueになるのは、1の位が１のときですから、i=0,1で通ります。
result |= 1 << (bits - 1 - i) はreult or 1 << (bits - 1 - i)でresultを更新していきます。
i=0 では、1<<(3-1-0) で1=001を左に2シフトし、100にします。
この100を、初期値のresult=000とorでけたごとに１を上書きするので、result=100です。
i=1では、 1<<(3-1-1)で1=001を左に１シフトし、010にします。
この010の1をresultに上書きするから、result=100 or 010 = 110
これで、ｎにある１を下の位からみつけて、
あれば、それを反対の位に移動していることがわかります
ｎの「１」が、０位 ...... i 位...... (bits-1)位まで動くとき、
その移動先は、(bits-1)位…（bits-1 -i)位 .. ....０位になります。
つまり、移動前の位と移動後の位の和が一定になることがわかりますね。
これで、ビットの左右が逆転することが確認できました。
グラフ作成
時間領域では、時刻データｔぜんぶとその波形データsignalをぜんぶ使います。
n = len(signal)がデータ数です。
周波数領域では、最大周波数をfreqmax = sampling_rate / 2にしましょう。
線対称なグラフになるだけなので、情報量の関係で半分の範囲で十分です。
表示データ数は半分になりました。だから、これに対応して、プロットする範囲を[:n//2]にします。
それに連動して、周波数軸を0からfreqmaxをnではなく、n//2で割ります。
[IN]Python===================================
import matplotlib.pyplot as plt
from numpy import cos, sin, pi, exp, log2
import numpy as np
# 微小な虚部を切り捨てて実数を返す。
def to_real(z, precision=8):
return float(int(z.real * (10**precision))) / (10**precision)
#ビット反転により、指定桁数で2進数の左右逆の番号に変換して10進数にもどす。
def bit_rev(n, bits):
result = 0
for i in range(bits):
if (n >> i) & 1:
result |= 1 << (bits - 1 - i)
return result
#FFTの核心部分
def sizeDown(lst,nums,bits,resultX):
seg = len(nums)
if seg ==1:
resultX[bit_rev(nums[0],bits)]=lst[0] #ビットリバースしてFFT結果を格納する
else:
subsize = seg//2
L=lst[:subsize]
R=lst[subsize:]
numL=nums[:subsize]
numR=nums[subsize:]
LA = [l+r for l,r in zip(L,R)]
Rdif = [l-r for l,r in zip(L,R)]
num = list(range(len(R))) # seg//2のサイズまでの0から始まるインデックスの作成
w = lambda k: complex(cos(-2*pi*k/seg),sin(-2*pi*k/seg)) #回転子wのｋ乗を関数化する
RM = [ r*(w(idx)) for r,idx in zip(Rdif, num)]
sizeDown(LA,numL,bits,resultX)
sizeDown(RM,numR,bits,resultX)
#FFTの全体の流れ
def FFT(target, fftDict):
#グローバル変数の初期化
N = len(target)
nums = list(range(N))
bits = int(np.log2(N))
sizeDown(target,nums,bits,fftDict)
srt = sorted(fftDict.items()) #ビットリバースされた順番のFFTのデータを正しい順番に並べる
res = [v / N for k, v in srt] #振幅をデータ点数で正規化する
return res
#======================= ここからが設定と視覚化============================
# 音データ
sampling_rate = 256 #２のべき乗
T = 1.0 #時間領域の調査期間
num_samples = int(sampling_rate * T) #サンプル数
t = np.linspace(0, T, num_samples) #時間領域の調査時刻リスト
frq = 2 * pi * 10 * t #基本周波数frqは10とする
signal = sin(frq) + 1/2* sin(frq * 3) + 1/4* sin(frq * 5) + 1/6* sin(frq *10)
signal *= exp(-5 * t) #減衰をかける
n = len(signal) #作成データ数
# プロットサイズ
plt.figure(figsize=(14, 10))
# f(t)のグラフ
plt.subplot(2, 1, 1)
plt.plot(t[: n ], signal)
plt.title('signal')
plt.xlabel('t[s]')
plt.grid(True)
# FFTのグラフ
freqmax = sampling_rate / 2 #最大の周波数メモリ
yF = FFT(signal,{})
xF = np.linspace(0, freqmax, n // 2) #FFTの周波数軸のメモリリスト
plt.subplot(2, 1, 2)
plt.plot(xF[: n // 2], np.abs(yF[: n // 2]))
plt.title('FFT')
plt.xlabel('freq[Hz]')
plt.grid(True)
plt.xlim(0, freqmax)
#[OUT]
#==============================================
質問：FFTをgeogebraの中のjavasctiptにするにはどんな準備が必要でしょうか。
pythonにあって、javascriptにないのが、複素数とzip関数です。また、javascriptとgeogebraをデータ交換する関数も必要です。
１．複素数クラスで和、差、積、絶対値の計算ができるようにしょう。
class Complex{
constructor(a, b){
this.real = a;
this.imag = b;
}
set re(a){ this.real = a; }
get re(){ return this.real; }
set im(a){ this.imag = a; }
get im(){ return this.imag; }
abs(){return Math.sqrt(this.real*this.real+this.imag*this.imag);}
add(a){return new Complex(this.real+a.real, this.imag+a.imag);}
sub(a){return new Complex(this.real-a.real, this.imag-a.imag);}
mul(a){return new Complex(this.real*a.real-this.imag*a.imag, this.real*a.imag+this.imag*a.real);}
}
２、複素数リストの２つ読み取りる関数（和、差、積など）を読み取る関数、高階関数で、
zipして演算する関数をカリー化で実現しよう。
function Zip(operation) {
return function(arr1, arr2) {
const result = [];
const length = Math.min(arr1.length, arr2.length);
for (let i = 0; i < length; i++) {
if (arr1[i] instanceof Complex && arr2[i] instanceof Complex) {
result.push(operation(arr1[i], arr2[i]));
}
}
return result;
};
}
const CLadd = Zip((a, b) => a.add(b));
const CLdif = Zip((a, b) => a.sub(b));
const CLmul = Zip((a, b) => a.mul(b));
３．リスト操作関連の関数群1,2,3,4
1 整数列(0 to n)の作成
function range(n){return [...Array(n).keys()];}
2 js実数List をggb実数Listにする書き方はとてもよく使います。
（アプレットオブジェクトがggap、リスト名somelistの場合）
ggap.evalCommand(`somelist ={${somelist}}`);
${somelist}はsomelistの名前ではなく、データとして読み取ったものをgeogebraの数式に入力します。
3 ggb複素数List をjs複素数List(アプレットオブジェクトがggap)にする。
function ggbC2jsRList(ggbListName,Listsize,ggap){
let jsTarget=[];
for (let i=0; i<Listsize; i++ ){
let citem = new Complex(ggap.getListValue(ggbListName, i+1),0)
jsTarget.push(citem);//geogebraのインデックスは1スタート
}
return jsTarget;
}
4 ガウス平面のｎ等分点の複素数e^2πk/n（左回りにｋ番目）を作成する。
function eZ(k,n){return new Complex(Math.cos(2*Math.PI*k/n),Math.sin(2*Math.PI*k/n));}
質問：geogebraでFFTを作るにはどうしたらよいでしょう。
バグ取りも含めたコードなので冗長ですが、
たとえば、以下のようになります。
時間領域ボタン、周波数領域のボタン、ビット増加ボタン、ビット減少ボタンをアプレット領域に貼ります。それぞ、ボタンをクリックすると、
timeview, fftview, up,downのjavascriptの関数を呼びだすように、設定のスクリプト記述にかきましょう。
そして、グローバルスクリプト記述のところに、
以下のコードをはりつければよいですね。
動きを確認できたら、アプレット自体をダウンロードして、改良してみてください。
//global
let ggap;
let width;
let height;
let sampling_rate;
let fftDict;
let xlim;
let ylim;
let bits;
let choice;
function ggbOnInit() {
ggap = window.ggbApplet;
width = 1.0;
height = 2.0;
sampling_rate=3;
fftDict= {};
xlim = 2.0;
ylim = 1.0;
bits = 3;
choice = 0;
setup();
timeview();
}
'use strict';
//複素数の和、差、積
class Complex{
constructor(a, b){
this.real = a;
this.imag = b;
}
set re(a){ this.real = a; }
get re(){ return this.real; }
set im(a){ this.imag = a; }
get im(){ return this.imag; }
abs(){return Math.sqrt(this.real*this.real+this.imag*this.imag);}
add(a){return new Complex(this.real+a.real, this.imag+a.imag);}
sub(a){return new Complex(this.real-a.real, this.imag-a.imag);}
mul(a){return new Complex(this.real*a.real-this.imag*a.imag, this.real*a.imag+this.imag*a.real);}
}
//複素数リストの要素単位の和、差、積
function Zip(operation) {
return function(arr1, arr2) {
const result = [];
const length = Math.min(arr1.length, arr2.length);
for (let i = 0; i < length; i++) {
if (arr1[i] instanceof Complex && arr2[i] instanceof Complex) {
result.push(operation(arr1[i], arr2[i]));
}
}
return result;
};
}
const CLadd = Zip((a, b) => a.add(b));
const CLdif = Zip((a, b) => a.sub(b));
const CLmul = Zip((a, b) => a.mul(b));
//リスト操作関連の関数群1,2,3,4
//1 整数列(0 to n)の作成
function range(n){return [...Array(n).keys()];}
//2 js実数List to ggb実数List
// （アプレットオブジェクトがggap、リスト名somelistの場合）
// ggap.evalCommand(`somelist ={${somelist}}`);
//3 ggb複素数List to js複素数List(アプレットオブジェクトがggap)
function ggbC2jsRList(ggbListName,Listsize,ggap){
let jsTarget=[];
for (let i=0; i> i) & 1){
result |= 1 << (bits - 1 - i);
}
}
return result;
}
//FFTの核心部分
function sizeDown(lst,nums,bits){
let seg = nums.length;
if(seg ==1){
fftDict[bit_rev(nums[0],bits)]=lst[0];
}else{
subsize = seg/2;
let L = lst.slice(0,subsize);
let R = lst.slice(subsize,seg);
let numL = nums.slice(0,subsize);
let numR = nums.slice(subsize,seg);
let LA = CLadd(L,R,subsize);
let Rdif = CLdif(L,R,subsize);
let w =[];
for(let i = 0; i < subsize; i++){
let citem = eZ(-i,seg);
w.push(citem);
}
let RM = CLmul(Rdif, w,subsize);
sizeDown(LA,numL,bits);
sizeDown(RM,numR,bits);
}
}
function setup() {
sampling_rate = Math.pow(2,bits); //２のべき乗
let sampleSize = sampling_rate; //サンプル数
let intsample = range(sampleSize);
let t = intsample.map((x) => x/sampleSize);
let frq =t.map((val) => 2 * Math.PI * 10 * val);
ggap.evalCommand(`t={${t}}`);
ggap.evalCommand(`frq={${frq}}`);
ggap.evalCommand("oto=Zip(sin(v)+1/2*sin(3*v)+1/4*sin(5*v)+1/6*sin(10*v),v,frq)");
ggap.evalCommand("mult=Zip(e^(-5*k),k,t)");
ggap.evalCommand("signal= oto*mult");
ggap.evalCommand("pnts=Zip((a,b),a,t,b,signal)");
ggap.evalCommand("graph=Polyline(pnts)");
ggap.setVisible("pnts", false);
ggap.setVisible("graph", false);
let n = sampling_rate; //作成データ数
let freqmax = n / 2; //最大の周波数メモリ
let signal = ggbC2jsRList("signal",n,ggap);
let nums = range(n);
sizeDown(signal,nums,bits);
let yF=[];
for(key in fftDict) {
yF.push(fftDict[key].abs()/(n/2));
}
let fftY = yF.slice(0,freqmax);
ggap.evalCommand(`fftY={${fftY}}`);
let xF = range(freqmax);
let fftX = xF.slice(0,freqmax);
ggap.evalCommand(`fftX={${fftX}}`);
ggap.evalCommand("fftpnt=Zip((a,b),a,fftX,b,fftY)");
ggap.evalCommand("fftgrf=Polyline(fftpnt)");
ggap.setVisible("fftpnt", false);
ggap.setVisible("fftgrf", false);
}
function timeview(){
choice =1;
bits = 3;
alert("timeview called. choice: " + choice + ", bits: " + bits);
if (!ggap) { // ggapが未定義またはnullの場合
ggap = window.ggbApplet;
}
setup();
ggap.setVisible("graph", true);
ggap.setVisible("fftgrf", false);
sampling_rate = Math.pow(2,bits); //２のべき乗
sampleSize = sampling_rate; //サンプル数
xlim = width/2;
ylim = height;
ggap.setCoordSystem(0, xlim, - ylim, ylim);
}
function fftview(){
choice =2;
bits = 3;
alert("timeview called. choice: " + choice + ", bits: " + bits);
if (!ggap) { // ggapが未定義またはnullの場合
ggap = window.ggbApplet;
}
setup();
ggap.setVisible("graph", false);
ggap.setVisible("fftgrf", true);
let n = sampling_rate; //作成データ数
let freqmax = n / 2; //最大の周波数メモリ
xlim = freqmax;
ylim = height/10;
ggap.setCoordSystem(0, xlim, - ylim, ylim);
}
function up() {
bits +=1;
alert("timeview called. choice: " + choice + ", bits: " + bits);
if (!ggap) { // ggapが未定義またはnullの場合
ggap = window.ggbApplet;
}
setup();
console.log(sampling_rate);
redraw();
}
function down(){
bits -=1;
alert("timeview called. choice: " + choice + ", bits: " + bits);
if (!ggap) { // ggapが未定義またはnullの場合
ggap = window.ggbApplet;
}
setup();
console.log(sampling_rate);
redraw();
}
function redraw(){
if (!ggap) { // ggapが未定義またはnullの場合
ggap = window.ggbApplet;
}
setup();
if (choice==1){
ggap.setVisible("graph", true);
ggap.setVisible("fftgrf", false);
xlim = width/2;
ylim = height;
}else if(choice==2){
ggap.setVisible("graph", false);
ggap.setVisible("fftgrf", true);
let n = sampling_rate; //作成データ数
let freqmax = n / 2; //最大の周波数メモリ
xlim = freqmax;
ylim = height/10;
}
ggap.setCoordSystem(0, xlim, - ylim, ylim);
}