Fourier Approximations Worksheet by Michael K. May, S.J., revised by Russell Blyth. restart:with(plots):

Warning, the name changecoords has been redefined

Explore Fourier approximations both symbolically and graphically

We first explore further the example given in class, and then tackle new examples. First, instruct Maple to assume that i and j are integers. assume(i,integer): assume(j,integer): interface(showassumed=0): Compute the Fourier coefficients for the function f(x) = x F := x; Int(F*sin(j*Pi*x),x=-1..1) = int(F*sin(j*Pi*x),x=-1..1); Int(F*cos(j*Pi*x),x=-1..1) = int(F*cos(j*Pi*x),x=-1..1); Int(F,x=-1..1) = int(x,x=-1..1);

NiQtSSVtcm93RzYjL0krbW9kdWxlbmFtZUc2IkksVHlwZXNldHRpbmdHSShfc3lzbGliR0YoNiUtSSNtaUdGJTY5USJGRigvJSdmYW1pbHlHUTBUaW1lc35OZXd+Um9tYW5GKC8lJXNpemVHUSMxMkYoLyUlYm9sZEdRJmZhbHNlRigvJSdpdGFsaWNHUSV0cnVlRigvJSp1bmRlcmxpbmVHRjgvJSpzdWJzY3JpcHRHRjgvJSxzdXBlcnNjcmlwdEdGOC8lK2ZvcmVncm91bmRHUSpbMCwwLDI1NV1GKC8lK2JhY2tncm91bmRHUS5bMjU1LDI1NSwyNTVdRigvJSdvcGFxdWVHRjgvJStleGVjdXRhYmxlR0Y4LyUpcmVhZG9ubHlHRjsvJSljb21wb3NlZEdGOC8lKmNvbnZlcnRlZEdGOC8lK2ltc2VsZWN0ZWRHRjgvJSxwbGFjZWhvbGRlckdGOC8lMGZvbnRfc3R5bGVfbmFtZUdRKjJEfk91dHB1dEYoLyUqbWF0aGNvbG9yR0ZELyUvbWF0aGJhY2tncm91bmRHRkcvJStmb250ZmFtaWx5R0YyLyUsbWF0aHZhcmlhbnRHUSdpdGFsaWNGKC8lKW1hdGhzaXplR0Y1LUkjbW9HRiU2M1EjOj1GKC8lJWZvcm1HUSZpbmZpeEYoLyUmZmVuY2VHRjgvJSpzZXBhcmF0b3JHRjgvJSdsc3BhY2VHUS90aGlja21hdGhzcGFjZUYoLyUncnNwYWNlR0ZbcC8lKXN0cmV0Y2h5R0Y4LyUqc3ltbWV0cmljR0Y4LyUobWF4c2l6ZUdRKWluZmluaXR5RigvJShtaW5zaXplR1EiMUYoLyUobGFyZ2VvcEdGOC8lLm1vdmFibGVsaW1pdHNHRjgvJSdhY2NlbnRHRjgvJTBmb250X3N0eWxlX25hbWVHRlgvJSVzaXplR0Y1LyUrZm9yZWdyb3VuZEdGRC8lK2JhY2tncm91bmRHRkctRi02OVEieEYoRjBGM0Y2RjlGPEY+RkBGQkZFRkhGSkZMRk5GUEZSRlRGVkZZRmVuRmduRmluRlxvNyMtX0YpSSxtcHJpbnRzbGFzaEdGKDYkNyM+SSJGR0YoSSJ4R0YoNyNGYXI=

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

NiQtSSVtcm93RzYjL0krbW9kdWxlbmFtZUc2IkksVHlwZXNldHRpbmdHSShfc3lzbGliR0YoNiUtRiQ2Jy1JKG1zdWJzdXBHRiU2Jy1JI21vR0YlNjRRJiZpbnQ7RigvJSVmb3JtR1EhRigvJSZmZW5jZUdRJmZhbHNlRigvJSpzZXBhcmF0b3JHRjovJSdsc3BhY2VHUSQwZW1GKC8lJ3JzcGFjZUdGPy8lKXN0cmV0Y2h5R0Y6LyUqc3ltbWV0cmljR0Y6LyUobWF4c2l6ZUdRKWluZmluaXR5RigvJShtaW5zaXplR1EiMUYoLyUobGFyZ2VvcEdGOi8lLm1vdmFibGVsaW1pdHNHRjovJSdhY2NlbnRHRjovJTBmb250X3N0eWxlX25hbWVHUSoyRH5PdXRwdXRGKC8lJXNpemVHUSMxMkYoLyUrZm9yZWdyb3VuZEdRLlsxNDQsMTQ0LDE0NF1GKC8lK2JhY2tncm91bmRHUS5bMjU1LDI1NSwyNTVdRigvSSttc2VtYW50aWNzR0YlUSZpbmVydEYoLUkjbW5HRiU2OVEpJm1pbnVzOzFGKC8lJ2ZhbWlseUdRMFRpbWVzfk5ld35Sb21hbkYoLyUlc2l6ZUdGVy8lJWJvbGRHRjovJSdpdGFsaWNHRjovJSp1bmRlcmxpbmVHRjovJSpzdWJzY3JpcHRHRjovJSxzdXBlcnNjcmlwdEdGOi8lK2ZvcmVncm91bmRHUSpbMCwwLDI1NV1GKC8lK2JhY2tncm91bmRHRmduLyUnb3BhcXVlR0Y6LyUrZXhlY3V0YWJsZUdGOi8lKXJlYWRvbmx5R1EldHJ1ZUYoLyUpY29tcG9zZWRHRjovJSpjb252ZXJ0ZWRHRjovJStpbXNlbGVjdGVkR0Y6LyUscGxhY2Vob2xkZXJHRjovJTBmb250X3N0eWxlX25hbWVHRlQvJSptYXRoY29sb3JHRmBwLyUvbWF0aGJhY2tncm91bmRHRmduLyUrZm9udGZhbWlseUdGYW8vJSxtYXRodmFyaWFudEdRJ25vcm1hbEYoLyUpbWF0aHNpemVHRlctRlxvNjlGS0Zfb0Zib0Zkb0Zmb0Zob0Zqb0ZccEZecEZhcEZjcEZlcEZncEZqcEZccUZecUZgcUZicUZkcUZmcUZocUZqcUZdci8lMXN1cGVyc2NyaXB0c2hpZnRHUSIyRigvJS9zdWJzY3JpcHRzaGlmdEdRIjBGKC1JI21pR0YlNjlRInhGKEZfb0Zib0Zkby9GZ29GaXBGaG9Gam9GXHBGXnBGYXBGY3BGZXBGZ3BGanBGXHFGXnFGYHFGYnFGZHFGZnFGaHEvRltyUSdpdGFsaWNGKEZdci1JJ21zcGFjZUdGJTYmLyUnaGVpZ2h0R1EnMC4wfmV4RigvJSZ3aWR0aEdRJzAuM35lbUYoLyUmZGVwdGhHRmNzLyUqbGluZWJyZWFrR1ElYXV0b0YoLUYyNjRRMCZEaWZmZXJlbnRpYWxEO0YoL0Y2USdwcmVmaXhGKEY4RjtGPUZARkJGREZGRklGTEZORlBGUkZVRlhGZW5GaG5GZ3ItRjI2M1EiPUYoL0Y2USZpbmZpeEYoRjhGOy9GPlEvdGhpY2ttYXRoc3BhY2VGKC9GQUZndEZCRkRGRkZJRkxGTkZQRlJGVS9GWUZgcEZlbi1GXG82OVEiMEYoRl9vRmJvRmRvRmZvRmhvRmpvRlxwRl5wRmFwRmNwRmVwRmdwRmpwRlxxRl5xRmBxRmJxRmRxRmZxRmhxRmpxRl1yNyMvLUkkSW50RzYkJSpwcm90ZWN0ZWRHRio2JEkieEdGKC9GZHU7ISIiIiIiIiIh

We have obtained the following n term Fourier approximation to the function f(x) = x. Fapprox := (x,n) -> sum(-2*(-1)^j/(j*Pi)*sin(j*Pi*x),j=1..n);

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

Let's plot a 6 term approximation against the function. eval(Fapprox(x,6)); plot([Fapprox(x,6),x],x=-2..2,y = -2..2, title = " 6th Order Fourier approximation to y =x", titlefont = [HELVETICA,12], color = [green,blue]);

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

6'-I'CURVESG6"6$7^y7$$!"#""!$"35"*Gk(["z$Q%!#^7$$!3"om;HU,"*)>!#<$"3e&3F:8C?#*)!#A7$$!3RLL$e%G?y>F2$"34'>,D2Bj3(!#@7$$!3(****\(oUIn>F2$"32!fb]#p.jB!#?7$$!3xmmm"p0k&>F2$"3UP>]l)Rw]&FA7$$!3%*****\P&3Y$>F2$"344L%yTL7x"!#>7$$!3MLLL$Q6G">F2$"3mi(G3jNJ#RFL7$$!30++v3-)[(=F2$"3_y[^Q4-F)*FL7$$!3amm;M!\p$=F2$"38FV,nn?M<!#=7$$!3#)***\7Y"H%z"F2$"3,Nd$GWI0^#Ffn7$$!3LLLL))Qj^<F2$"3*))R!**f#y)pHFfn7$$!3NLLe/))*3u"F2$"3g")R7zvnCIFfn7$$!39LL$3sj,t"F2$"3@Vth<ekdIFfn7$$!3:LL3P'G%><F2$"3Bx_<e>-sIFfn7$$!3<LLL`Np3<F2$"3\F;$Hat>2$Ffn7$$!3>LL$eQBso"F2$"3uN))4#Q+)[IFfn7$$!3ALLL=Kvl;F2$"3%*zDvx[NKIFfn7$$!3(**\il:p]l"F2$"3)4#["[3E2/$Ffn7$$!3sm;z%4&QW;F2$"3&fsNbouo1$Ffn7$$!3ZL3-L5qL;F2$"3A^_v_Q,:JFfn7$$!3+++Drp,B;F2$"3rMGUSdT)=$Ffn7$$!3FL$3x%)[;g"F2$"3!RBIR$QT=MFfn7$$!3wmm;C2G!e"F2$"3F`([)Gs&*ePFfn7$$!3OLL$3yO5]"F2$"3iOzT=``'\&Ffn7$$!31++]_O_!["F2$"3)yT_c")Gd'eFfn7$$!3amm;C0,g9F2$"3!47U))G?T7'Ffn7$$!3y******fRv\9F2$"3U$e\[hja?'Ffn7$$!3CLL$eR(\R9F2$"3'zv\E,vSD'Ffn7$$!3rmmmJ3CH9F2$"3z^"Hn%R1riFfn7$$!3&*****\nU)*=9F2$"37CDUoZ%*eiFfn7$$!3ymm;a[bw8F2$"3eAdAr(4P+'Ffn7$$!3SLL$3WDTL"F2$"3]K"GMLb!*y&Ffn7$$!3zmmT0@bB8F2$"3qfkH#)eX0eFfn7$$!3'*******p(yHJ"F2$"3,FdN!3TT'eFfn7$$!3NLLeMaS-8F2$"3_I=!R![+qfFfn7$$!3umm;*4K=H"F2$"35gC7Zc7EhFfn7$$!3`LLLGaoq7F2$"3SM"ebA%*4f'Ffn7$$!35++]d(Q&\7F2$"3(oVzI]P'RsFfn7$$!3ZLL3d[.17F2$"3C<eQ=^nw))Ffn7$$!3gmmmc4`i6F2$"3SfJYQ/L:5F27$$!3BL3Fu6ud6F2$"3'yzlH#)zD-"F27$$!3%)**\(=R^H:"F2$"3)fYr)Q<(z-"F27$$!3om"z%4;;[6F2$"3)eI,f\%QJ5F27$$!3HLL3F=PV6F2$"3Wo5A7SqK5F27$$!3!**\(oW?eQ6F2$"3'=w2"oY#=."F27$$!3um;HiAzL6F2$"3u=!RS6]'G5F27$$!3OLe*)zC+H6F2$"3Qye=FS4B5F27$$!3(*****\(p7U7"F2$"3%)e+i533:5F27$$!3kmm"zc`]5"F2$"37j:T+%QNd*Ffn7$$!3KLLLQW*e3"F2$"3CH@!3r[Ud)Ffn7$$!3hm;H<,6v5F2$"3HmdN(zh&HyFfn7$$!3!****\izDV1"F2$"34\S0#Qy<'pFfn7$$!3>L$3_ZTN0"F2$"3FRZ,zJS")fFfn7$$!3qmm;arvU5F2$"3"4"3<aP0-\Ffn7$$!3@+]7LG(>."F2$"3wDG#Rx9,u$Ffn7$$!3]LL37&)=@5F2$"3.#RkO#**H9DFfn7$$!3zm;/">//,"F2$"3*zxVgvN^C"Ffn7$$!3w++++()>'***Ffn$!3y&Q$pbNahXFA7$$!3E,++vE"z))*Ffn$!3p;#yv`Q3M"Ffn7$$!3k+++]miz(*Ffn$!3D)HP<=JEh#Ffn7$$!3-+++D1Mr'*Ffn$!364Q(3oO!RQFfn7$$!3^++++Y0j&*Ffn$!3eHHTGCS**\Ffn7$$!3,,++v&oZX*Ffn$!3$o.Urhk\2'Ffn7$$!3Q+++]D[Y$*Ffn$!3gL?iB*o$\qFfn7$$!3w*****\_'>Q#*Ffn$!3=a@A"z4"4zFfn7$$!3E++++0"*H"*Ffn$!3?6%**\#R(Qk)Ffn7$$!3y++++K?@*)Ffn$!3XtdJTi3&o*Ffn7$$!3=++++f\7()Ffn$!3K;I$G=MF-"F27$$!3J+++v!>.m)Ffn$!31*e\<E3)G5F27$$!3L******\A93')Ffn$!3tk3]D+1K5F27$$!3X*****\Ulfb)Ffn$!3vzs!)G@gK5F27$$!3f*******f)y.&)Ffn$!3Wx>'H@h0."F27$$!3%)******\\V*R)Ffn$!3!4]vCp*H>5F27$$!35++++83&H)Ffn$!3-1P<Jp@&***Ffn7$$!3!ommT&)Gg"zFfn$!3i&og)f&ovy)Ffn7$$!3[LLL3k(p`(Ffn$!3Nw!y=%)e?N(Ffn7$$!3Omm"zR6;J(Ffn$!3$G,#)fIo3k'Ffn7$$!3M++](QYi3(Ffn$!3Qrg3lc-MhFfn7$$!3zm;H#)QctpFfn$!3uWw[*ouq'fFfn7$$!3MML3x8)3'oFfn$!3"3tw:mBr&eFfn7$$!3y+](=())>[nFfn$!3`V%eaA@.!eFfn7$$!3Anmmmj^NmFfn$!3E<!p3?20z&Ffn7$$!3fnmm;*)o`iFfn$!3@mUfJj&*))fFfn7$$!3(zmmmYh=(eFfn$!31AUf^N>RiFfn7$$!3KM$3FWA3w&Ffn$!3<IL*ei$>oiFfn7$$!3n++v=My\cFfn$!3Rr%>FUh_E'Ffn7$$!38o;z%RW(QbFfn$!3'zmG%G[PEiFfn7$$!3[ML$3P0xU&Ffn$!3"[,:bI>%\hFfn7$$!3Iom"HKFc?&Ffn$!3g[Zy")*GC)eFfn7$$!3+,++v#\N)\Ffn$!3'H*e([Q=U[&Ffn7$$!3wML$3(eR!f%Ffn$!3[v+*z))Q%*f%Ffn7$$!3commmCC(>%Ffn$!37AVDd#[!fPFfn7$$!3?,+vomc")RFfn$!36d^*))R4eT$Ffn7$$!3%QLL3(3*ew$Ffn$!3baWk+?B&=$Ffn7$$!3*)**\(=(H0eOFfn$!3aXg)z/aA6$Ffn7$$!3\mm"H2:-b$Ffn$!3!)\&)3F1)[1$Ffn7$$!34L$eR<xBW$Ffn$!3nT`%*zOpRIFfn7$$!39*****\FRXL$Ffn$!3C[)Gur4B.$Ffn7$$!3G****\7\;HJFfn$!3oB*G:U@'[IFfn7$$!3V******\0zBHFfn$!3.o;_2)f82$Ffn7$$!3y***\(oL5@GFfn$!3t3G;$)GzsIFfn7$$!3e****\(=;%=FFfn$!3eWr=A*H;1$Ffn7$$!3Q***\i+Hdh#Ffn$!33#[!)ea,T.$Ffn7$$!3t*****\#=/8DFfn$!3cDS8k3>()HFfn7$$!3%HLL3ioW3#Ffn$!3f(f_'yNN^DFfn7$$!3<mmm;a*el"Ffn$!3y=lR+pC&y"Ffn7$$!3_mm;H9Li7Ffn$!3h2/,%=iL+"Ffn7$$!3jomm;Wn(o)FL$!3Y[>:pa\&)QFL7$$!3sNL$3x9^c'FL$!3mh(>gMy6z"FL7$$!3#G++]7bDW%FL$!3'4Ti'HQ4?eFA7$$!3POL3-`F"Q$FL$!31'>v')>n'4EFA7$$!3$*pm;za**>BFL$!3)3c?pY9N`)F;7$$!3[.+Dccre7FL$!3'*ey9NDPt8F;7$$!3IqLLL$eV(>FA$!3(zfC&R:p;`!#C7$$"3N$fmTNc$\!*FA$"3'QG7^])H6^F57$$"3qbm;/rI2?FL$"3Ed_Lm#)RUbF;7$$"31_m"Hdy'4JFL$"3A&HSsJOs.#FA7$$"3V[mmT+07UFL$"3Dbu>Y=Y!)\FA7$$"3:Tm;zHz;kFL$"3&3a0wnl!z;FL7$$"3)Qjmm"f`@')FL$"3**=t#3xBj!QFL7$$"3mILLL1+Y7Ffn$"3E<$*)[Du5t*FL7$$"3%z****\nZ)H;Ffn$"3S_-WaC(Gt"Ffn7$$"3CJL$e*HTW?Ffn$"3)=*)pN)e;"\#Ffn7$$"3bkmm;$y*eCFfn$"3qw(f(\,%R&HFfn7$$"3IJL3_*\gc#Ffn$"322"*=t4)R,$Ffn7$$"31)***\(e@Jn#Ffn$"393Ym6@q^IFfn7$$"3"[m;HA$>!y#Ffn$"3K)42m)33qIFfn7$$"3cJLLe[E()GFfn$"3(zR4&[#\I2$Ffn7$$"33lm;H"395$Ffn$"3d!e)>![6A0$Ffn7$$"3f)******R^bJ$Ffn$"30s5'e*oZKIFfn7$$"3D)**\i5+.U$Ffn$"3=]u(p)4*o.$Ffn7$$"3!z***\7)[]_$Ffn$"3N#3SJ0lr0$Ffn7$$"3c(**\(=vzHOFfn$"3OErC.f[(4$Ffn7$$"3A(****\AYXt$Ffn$"3#*pj(oiB7;$Ffn7$$"3`'***\PO/WRFfn$"3@q-t5)*QnLFfn7$$"3&e*****\5a`TFfn$"3X9H@1P,"o$Ffn7$$"3N'***\(3S*eXFfn$"3!=Ia*oeMEXFfn7$$"3&o****\7RV'\Ffn$"3-"o_RF()[W&Ffn7$$"3v'**\7Q-%*=&Ffn$"3(zrLrOrt&eFfn7$$"3l'***\PcY9aFfn$"3cDYvn[nPhFfn7$$"3g'*\ils*p_&Ffn$"3c2@PEK0?iFfn7$$"3a'**\P*)G&RcFfn$"3()[N*4YBKE'Ffn7$$"3]'*\(=_g?v&Ffn$"3D7!H!Rp=piFfn7$$"3X'*****\@fkeFfn$"3/)ejH1j>C'Ffn7$$"3[jmmT30piFfn$"3."*z3F,ExfFfn7$$"3_ILLL&4Nn'Ffn$"3m.I.b,.*y&Ffn7$$"3bjm;H5Z"y'Ffn$"3Z]&\Cv()="eFfn7$$"3p(****\_K%*)oFfn$"3J42(Q\g(zeFfn7$$"3#=LL3-%R(*pFfn$"3]*ykNkYv*fFfn7$$"3([mmm^b`5(Ffn$"3&)*f&o]!>"ohFfn7$$"3/KLL3&y7K(Ffn$"3(oisx$y`nmFfn7$$"3A*******\,s`(Ffn$"3n%yU#43&GN(Ffn7$$"3.KL$e9=&GzFfn$"33e[IG_zM))Ffn7$$"3%[mm;zM)>$)Ffn$"3<P!ek$="\+"F27$$"3lJ$3_!zyE%)Ffn$"3m6_>(oGJ-"F27$$"3Y)**\(=5uL&)Ffn$"3_#3>HyS?."F27$$"3IJ3_vv@(e)Ffn$"3WNBQjgfK5F27$$"3Gl;HKTpS')Ffn$"3C-V[<nNI5F27$$"3A*\i!*oqTp)Ffn$"3gF?vsa>D5F27$$"33KL$eCZwu)Ffn$"3:277X7+<5F27$$"3qlm"HZ`:'*)Ffn$"3,P:e\++B&*Ffn7$$"3L*******pfa<*Ffn$"3b:UrzXb]$)Ffn7$$"3xJLe*yGnP*Ffn$"3XMe"3%y@)y'Ffn7$$"3Bkm;zy*zd*Ffn$"3%)yc"**o<R%[Ffn7$$"3,J$eRUK'y'*Ffn$"3J"\h()e/$ePFfn7$$"3o'**\(opEz(*Ffn$"3o)))39y"z;EFfn7$$"3Ni;a8:!*z)*Ffn$"3[elzc]+O9Ffn7$$"38HLLeg`!)**Ffn$"3OT^WaAXNBFL7$$"3@mmT:Gd35F2$!3oZY?[L&o-"Ffn7$$"3^*****\-#4>5F2$!3Rc!Q))H-.F#Ffn7$$"3"GL$eM7hH5F2$!3GM,*fv`kZ$Ffn7$$"3Lmm;W/8S5F2$!3;#)y%)[A(fi%Ffn7$$"3&)***\Pl\10"F2$!3Nl>$*HN0,dFfn7$$"3:LLLj)o61"F2$!3(****y.O%*eo'Ffn7$$"3Xmm"H2)or5F2$!3??"=rS)4nvFfn7$$"3v****\#G2A3"F2$!3UQEl6c+M$)Ffn7$$"36L$3F=wF5"F2$!3DNaa?S#pZ*Ffn7$$"3Ymm"H3XL7"F2$!3Iw#4OFhL,"F27$$"3')\(ozI([G6F2$!3,t/C<8NA5F27$$"3CL3-L&HO8"F2$!37v(R#*)3]G5F27$$"3k;H2e<xQ6F2$!31r^TZD!>."F27$$"3")**\7$)R"R9"F2$!3)>Byi7jE."F27$$"3)H3x"3i0\6F2$!3">*Q%)RF!4."F27$$"3Pm"HKV)>a6F2$!3S7]2(p`n-"F27$$"3x\7Ge1Mf6F2$!37>SOR$f.-"F27$$"3:LLL$)G[k6F2$!3'=v<+"G(=,"F27$$"3\mm"zM]v?"F2$!3<D`&oA:'>))Ffn7$$"3")****\7yh]7F2$!39sC+w;#G?(Ffn7$$"3Wm;/ctNr7F2$!3wJ%Q!y$)>tlFfn7$$"3GLLe**o4#H"F2$!3LQ)HaZ*e@hFfn7$$"3$o;a8nmCI"F2$!3,j2A6!\#pfFfn7$$"39+]7Vk$GJ"F2$!38ml:&zV_'eFfn7$$"3YLe*[@1KK"F2$!3\%evifvm!eFfn7$$"3wmmm')fdL8F2$!3V)o.'**H'*)y&Ffn7$$"3lmm;WV*fP"F2$!3-aUH!o,%**fFfn7$$"3bmmm,FT=9F2$!3smB+l\[diFfn7$$"3%)*\(oz%H*G9F2$!3p21:$=36F'Ffn7$$"37L$3xDY%R9F2$!3RPi4ZmBaiFfn7$$"3im"Hd.j*\9F2$!3m:\ACO8/iFfn7$$"3"****\P")z/Y"F2$!3>#zZUq9'>hFfn7$$"3qm;zpL^"["F2$!3@&)>/P0C]eFfn7$$"3FLL$e#pa-:F2$!397g/DY$eY&Ffn7$$"3emm"HB-7a"F2$!3#Q")3FK1Qf%Ffn7$$"3*)******Rv&)z:F2$!3)*4g^$)[smPFfn7$$"3OLL37#4?g"F2$!3qME3,af8MFfn7$$"3gmm;%)3;C;F2$!3A$\*QoSFzJFfn7$$"3KL$3-sO_j"F2$!3kBGJa_g1JFfn7$$"3$)***\ib7jk"F2$!3\S:Z.GkgIFfn7$$"3dm;H#R)Qd;F2$!3w&RY`-fv.$Ffn7$$"3HLLLGUYo;F2$!3Gg+HH0[KIFfn7$$"3fmm"z%pF)o"F2$!3DLDU_l:]IFfn7$$"3"*****\n'*33<F2$!3sD%)Q,%R;2$Ffn7$$"3cm;HFg*zr"F2$!3RC59(*)[F2$Ffn7$$"3@LL3(Q-zs"F2$!3J6Nt%*G4iIFfn7$$"3')**\(ou3yt"F2$!3a^l[/:GOIFfn7$$"3_mmm1^rZ<F2$!3#*\AISSd#*HFfn7$$"3ILLe*3k**y"F2$!3pt@&["*)QuDFfn7$$"34++]sI@K=F2$!3!HE"4q.>H=Ffn7$$"33+++S2ls=F2$!3Sw]+na@C5Ffn7$$"34++]2%)38>F2$!3YuKE$e"p*)QFL7$$"31+]i0j"[$>F2$!3jlr(Rqs`v"FL7$$"3/++v.Uac>F2$!3uxo07GkcaFA7$$"3.+D"G:3u'>F2$!3o45f$*e!4M#FA7$$"3-+](=5s#y>F2$!3aMp&=x>%>qF;7$$"3,+v$40O"*)>F2$!3/?0:\]QP))F57$$""#F+$!35"*Gk(["z$Q%F.-I'COLOURG6$%*protectedGI(_syslibGF%6&I$RGBGF%$F+F+$"*++++"!")F\co-F$6$7S7$F)F)7$FNFN7$FXFX7$F]oF]o7$F[qF[q7$FirFir7$F^sF^s7$F\uF\u7$FfuFfu7$FdwFdw7$F^xF^x7$F`[lF`[l7$Fh]lFh]l7$F``lF``l7$FhblFhbl7$FbclFbcl7$F`elF`el7$FjelFjel7$FhglFhgl7$FbhlFbhl7$F`jlF`jl7$F^\mF^\m7$Fh\mFh\m7$Fb]mFb]m7$F`_mF`_m7$F_amF_am7$FiamFiam7$FcbmFcbm7$FadmFadm7$F_fmF_fm7$FifmFifm7$FghmFghm7$FaimFaim7$F_[nF_[n7$Fi[nFi[n7$Fa^nFa^n7$F_`nF_`n7$FgbnFgbn7$FienFien7$FcfnFcfn7$FahnFahn7$F[inF[in7$FijnFijn7$Fc[oFc[o7$Fa]oFa]o7$F__oF__o7$Fi_oFi_o7$Fc`oFc`o7$FaboFabo-Ffbo6&F[coF\coF\coF]co-I+AXESLABELSGFgbo6$Q"xF%Q"yF%-I&TITLEGFgbo6$QJ~6th~Order~~Fourier~approximation~to~y~=xF%-I%FONTGF%6$I*HELVETICAGF%"#7-I%VIEWGFgbo6$;F)FaboFggo

It is also useful to plot the error, that is, the difference between the function and the approximation. plot(Fapprox(x,6)-x,x=-1..1,y=-1..1, title = "error in 6th Order Fourier approximation to y = x", titlefont = [HELVETICA,10], color = red);

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

1) Plot the function f(x) = x against the Fourier approximation with 100 terms 2) Plot the error function for f(x) = x and its Fourier approximation with 100 terms.

It is instructive to see an animation of the Fourier approximations as they converge to the function that is being approximated. The following block of code sets up frames that plot a Fourier approximation Fapprox against the function func. func := x: Fapprox := (x,n) -> sum(-2*(-1)^j/(j*Pi)*sin(j*Pi*x), j=1..n): framer := proc(n) local A, B, C, D: A := plot([Fapprox(x,n),func], x = -2..2, y = -2..2, color = [blue,green]): B := textplot({[0,1.8, `The `||n||` term Fourier approximation (blue)`], [0,1.6, `graphed against the function (green)`]}, font = [HELVETICA, BOLD, 12] ): C := textplot([-0.05,1.4, `f(x) = `], align=LEFT, font = [HELVETICA, BOLD, 12] ): D := textplot([0.05,1.4, func], align = RIGHT, font = [HELVETICA, BOLD, 12] ): display({A, B,C, D},view=[-2..2,-2..2]); end: With framer defined, it is a simple matter to animate a sequence of 30 frames. display([seq(framer(count), count=1..30)], insequence = true);

6#-I(ANIMATEG6$%*protectedGI(_syslibG6"6@7*-I'CURVESGF%6$7[s7$$!"#""!$"3Y\x+L(o#f:!#L7$$!3xmmm"p0k&>!#<$"3[j]&o&3j"p)!#>7$$!3MLLL$Q6G">F9$"3!=Tyx*)[?s"!#=7$$!30++v3-)[(=F9$"3]1(>rn^%QCFB7$$!3amm;M!\p$=F9$"3!fP/03p-7$FB7$$!3#)***\7Y"H%z"F9$"39kS6WlrLQFB7$$!3LLLL))Qj^<F9$"3&>\w&3dTyWFB7$$!3<LLL`Np3<F9$"3gf%R]Bbi/&FB7$$!3ALLL=Kvl;F9$"3Idr%Qs+C_&FB7$$!3+++Drp,B;F9$"3AnC$y)Hm'*eFB7$$!3wmm;C2G!e"F9$"3\7x`_KzkhFB7$$!3YLLLQ(p/c"F9$"3G&QHskn;D'FB7$$!3<++]_(e1a"F9$"3Q\`5dNL9jFB7$$!3_LLefKvI:F9$"3KM853)3lL'FB7$$!3)ommmwZ3_"F9$"3-5tV>$[DN'FB7$$!3,++vtA%4^"F9$"3:Df!)flVijFB7$$!3OLL$3yO5]"F9$"3:=3FaR;mjFB7$$!3#ommm@!y!\"F9$"3!\&)R#=u_jjFB7$$!31++]_O_!["F9$"3Nf.-(\%GajFB7$$!3JLLL)3n-Z"F9$"32d0G'yW%QjFB7$$!3amm;C0,g9F9$"37"=Q-tCgJ'FB7$$!3CLL$eR(\R9F9$"3TH7M#\V:D'FB7$$!3&*****\nU)*=9F9$"33=lB#[36;'FB7$$!3ymm;a[bw8F9$"3a:fM**)HM*eFB7$$!3SLL$3WDTL"F9$"33*p_/&H>@bFB7$$!3umm;*4K=H"F9$"3fk"G`sdE0&FB7$$!35++]d(Q&\7F9$"3!G!43.R0&\%FB7$$!3ZLL3d[.17F9$"3sdtcG[#*QQFB7$$!3gmmmc4`i6F9$"3o#G2?h*>6JFB7$$!3(*****\(p7U7"F9$"3::b`0No@CFB7$$!3KLLLQW*e3"F9$"3E.N!z4;rp"FB7$$!3qmm;arvU5F9$"3IjH"y$ztD&)F<7$$!3w++++()>'***FB$!3s'\HH>)f-w!#@7$$!3^++++Y0j&*FB$!3Q_%\)\!*[6()F<7$$!3E++++0"*H"*FB$!3clrm[#*e=<FB7$$!3=++++f\7()FB$!3uF-/MiO0DFB7$$!35++++83&H)FB$!3]H-T$*=7\KFB7$$!3!ommT&)Gg"zFB$!3pqU;nv]wQFB7$$!3[LLL3k(p`(FB$!3k!=xW\')*[WFB7$$!3Anmmmj^NmFB$!3u'\([eZ<WbFB7$$!3fnmm;*)o`iFB$!3b$)R=`CxyeFB7$$!3(zmmmYh=(eFB$!3cM!pl?"))GhFB7$$!3n++v=My\cFB$!3?\KP`Q,MiFB7$$!3[ML$3P0xU&FB$!3m>Rl"R9)3jFB7$$!3%3+voMmmJ&FB$!3?B8%zc?ZL'FB7$$!3Iom"HKFc?&FB$!3zFKAt)=HN'FB7$$!3kM$e*)H)e%4&FB$!3K3^UkrQjjFB7$$!3+,++v#\N)\FB$!3"))z)3/F6mjFB7$$!3WM$eR#4E&)[FB$!35b/IZA1ijFB7$$!3*ym;Hdspy%FB$!3lx&G:GY>N'FB7$$!3M,](=A%o)o%FB$!3yxe?^WxNjFB7$$!3wML$3(eR!f%FB$!3iw!\V<iNJ'FB7$$!3m,+vo">QR%FB$!3u!fLts16D'FB7$$!3commmCC(>%FB$!3V*3>11=[;'FB7$$!3%QLL3(3*ew$FB$!3mg@wz()o$*eFB7$$!39*****\FRXL$FB$!3:ed=+X\9bFB7$$!3V******\0zBHFB$!38W-xj]If]FB7$$!3t*****\#=/8DFB$!3b5!32n()*>XFB7$$!3%HLL3ioW3#FB$!3*f0W`u'HxQFB7$$!3<mmm;a*el"FB$!3O=s%3KCW;$FB7$$!3_mm;H9Li7FB$!3.qfPnb+fCFB7$$!3jomm;Wn(o)F<$!3!G-$R_J/;<FB7$$!3#G++]7bDW%F<$!3G%3\U!HHc))F<7$$!3IqLLL$eV(>!#?$!3@L)RrM"p[RF]`l7$$"3V[mmT+07UF<$"35p6\Hs`*R)F<7$$"3)Qjmm"f`@')F<$"3gdG@#Q,Lq"FB7$$"3mILLL1+Y7FB$"3o9`(*3m%)GCFB7$$"3%z****\nZ)H;FB$"3mzF*)y\6>JFB7$$"3CJL$e*HTW?FB$"3!R"HL0BX8QFB7$$"3bkmm;$y*eCFB$"3A%ev9&f>VWFB7$$"3cJLLe[E()GFB$"3"*Q')*o!>j9]FB7$$"3f)******R^bJ$FB$"3!G*o'e3@a\&FB7$$"3A(****\AYXt$FB$"3/9='**p-(peFB7$$"3&e*****\5a`TFB$"3qGg/<#GC9'FB7$$"34'**\(o0CcVFB$"3-t%==1XkB'FB7$$"3N'***\(3S*eXFB$"3<alzK3=0jFB7$$"3Z'*\(o%)*GgYFB$"3H$o^S?x*HjFB7$$"3g'**\igR;w%FB$"3#Q'fT"*oN[jFB7$$"3t'*\il$*)H'[FB$"3dq4Wj7IgjFB7$$"3&o****\7RV'\FB$"3'**>V@@)zljFB7$$"3!o*\7`2(o2&FB$"3c)z&R69MkjFB7$$"3v'**\7Q-%*=&FB$"3PI:yI6$\N'FB7$$"3q'*\P4S$>I&FB$"3`"\s-8zvL'FB7$$"3l'***\PcY9aFB$"3>>7c%42BJ'FB7$$"3a'**\P*)G&RcFB$"3I>*R\5R"QiFB7$$"3X'*****\@fkeFB$"32-4G&z(zKhFB7$$"3[jmmT30piFB$"3P\;<TO"p'eFB7$$"3_ILLL&4Nn'FB$"3`O8?`LV1bFB7$$"3A*******\,s`(FB$"3D^#z$zWm[WFB7$$"3.KL$e9=&GzFB$"3g/Np$)RmcQFB7$$"3%[mm;zM)>$)FB$"3Uz6AI.X1KFB7$$"33KL$eCZwu)FB$"335G'H0&eSCFB7$$"3L*******pfa<*FB$"3?yfp9,qI;FB7$$"3Bkm;zy*zd*FB$"3)Qx(\F*R`T)F<7$$"38HLLeg`!)**FB$"3[8C\uSw#*QF]`l7$$"3Lmm;W/8S5F9$!3hu+c1R%[+)F<7$$"3v****\#G2A3"F9$!38U^W>$Hfi"FB7$$"3Ymm"H3XL7"F9$!34w')=Fni0CFB7$$"3:LLL$)G[k6F9$!31<n77+?XJFB7$$"3\mm"zM]v?"F9$!3H?pYH-1jQFB7$$"3")****\7yh]7F9$!3E,oR%G5.^%FB7$$"3GLLe**o4#H"F9$!3fdI6)zxe0&FB7$$"3wmmm')fdL8F9$!3[&H^`)Qr:bFB7$$"3lmm;WV*fP"F9$!3J,*)4[9=*)eFB7$$"3bmmm,FT=9F9$!3%yf$Q"Q?#ehFB7$$"37L$3xDY%R9F9$!3ko!4!z,N^iFB7$$"3"****\P")z/Y"F9$!3inKF4R><jFB7$$"3?L3x"f'*4Z"F9$!3[dx`(**)yRjFB7$$"3qm;zpL^"["F9$!3A"fGc<kaN'FB7$$"3)**\7y9I?\"F9$!3?6N,MB?kjFB7$$"3FLL$e#pa-:F9$!3qE1&\$R*fO'FB7$$"3gmTg_2@7:F9$!3)*Gta0T^hjFB7$$"3#***\PzX(=_"F9$!3N)\J^?r6N'FB7$$"3DLe91%Q:`"F9$!3g)G2iwu\L'FB7$$"3emm"HB-7a"F9$!35Dc<;(RHJ'FB7$$"3BL$ek))H0c"F9$!3&eDr$z.W^iFB7$$"3*)******Rv&)z:F9$!3^7*>_')**o;'FB7$$"3gmm;%)3;C;F9$!3jPLKZ;+))eFB7$$"3HLLLGUYo;F9$!3Cg+M@bA&\&FB7$$"3"*****\n'*33<F9$!3*[a^hV4O0&FB7$$"3_mmm1^rZ<F9$!3ZrAc*fyP`%FB7$$"3ILLe*3k**y"F9$!3GUK(3'\X-RFB7$$"34++]sI@K=F9$!3bn^O&f#[-KFB7$$"33+++S2ls=F9$!3tSd>:.ezCFB7$$"34++]2%)38>F9$!3?$pm/J9nr"FB7$$"3/++v.Uac>F9$!3y=!4q,(=k')F<7$$""#F2$!3Y\x+L(o#f:F5-I'COLOURGF%6&I$RGBGF($F2F2F_dm$"*++++"!")-F,6$7S7$F0F07$F>F>7$FIFI7$FSFS7$FgnFgn7$FaoFao7$F_qF_q7$F]sF]s7$FgsFgs7$FatFat7$F[uF[u7$FeuFeu7$F_vF_v7$FjvFjv7$FdwFdw7$F^xF^x7$FcxFcx7$F]yF]y7$F[[lF[[l7$Fi\lFi\l7$Fc]lFc]l7$F]^lF]^l7$Fg^lFg^l7$Fa_lFa_l7$F[`lF[`l7$Ff`lFf`l7$F`alF`al7$FjalFjal7$FdblFdbl7$F^clF^cl7$F\elF\el7$FjflFjfl7$FdglFdgl7$FiglFigl7$FchlFchl7$F]ilF]il7$FgilFgil7$FajlFajl7$F[[mF[[m7$Fe[mFe[m7$F_\mF_\m7$Fi\mFi\m7$Fg^mFg^m7$Fe`mFe`m7$F_amF_am7$FiamFiam7$FcbmFcbm7$F]cmF]cm7$FgcmFgcm-F\dm6&F^dmF_dmF`dmF_dm-I%TEXTGF%6&7$$""&F1$"#9!""Q"xF(I+ALIGNRIGHTGF%-I%FONTGF(6%I*HELVETICAGF(I%BOLDGF("#7-Fjgm6%7$F_dm$"#;FahmQEgraphed~against~the~function~(green)F(Fdhm-Fjgm6%7$F_dm$"#=FahmQHThe~1~term~Fourier~approximation~(blue)F(Fdhm-Fjgm6&7$$!"&F1F_hmQ(f(x)~=~F(I*ALIGNLEFTGF%Fdhm-I+AXESLABELSGF%6$FbhmQ"yF(-I%VIEWGF%6$;F0FgcmFdjm7*Fjhm-Fjgm6%FbimQHThe~2~term~Fourier~approximation~(blue)F(Fdhm-F,6$7cs7$F0F_dm7$F7$"3B7@I'zO'Q")Fcv7$F>$"3'\\U+'\u>kF]`l7$FD$"3fL-M.Unf=F<7$FI$"3TV[?4%)*[+%F<7$FN$"3!zRH&)*e$3t(F<7$FS$"3!>I?1e%[&H"FB7$FX$"3HKsdx5wp>FB7$Fgn$"3boJ;#3O\x#FB7$F\o$"3(f>aJW!4uOFB7$Fao$"3_:p`fgSEYFB7$F[p$"3:(o&*fuu*4bFB7$F_q$"3(>ofU[GaM'FB7$Fcr$"3vY.oa`U2rFB7$F]s$"3)pj;tc[Br(FB7$$!3OLL$3cpxR"F9$"3V(eoLNjv%zFB7$Fbs$"3Tm$)*>nC@7)FB7$$!3\LL$3]ZfO"F9$"3dX/dN&\]=)FB7$$!3?++]Z,Mb8F9$"3F;JdJp(4B)FB7$$!3omm;%zKZM"F9$"3;$*Q$4X.%f#)FB7$Fgs$"3w0b8WA))p#)FB7$$!3zmmT0@bB8F9$"3lG`+I-3i#)FB7$$!3'*******p(yHJ"F9$"3oZ,v6gtN#)FB7$$!3NLLeMaS-8F9$"3'4O*)Rs(e!>)FB7$F\t$"3AOg9@rVE")FB7$$!3`LLLGaoq7F9$"3iNt***ph1%zFB7$Fat$"3;kzy(RR"ywFB7$Fft$"3pvCxFUM,pFB7$F[u$"35*GcO*4cDeFB7$F`u$"3#)RVmjEJhYFB7$Feu$"3MORX$><GL$FB7$$!3!****\izDV1"F9$"3i:0:R=bHDFB7$Fju$"3;'4Q%*\nup"FB7$$!3]LL37&)=@5F9$"3C/LNQ*o(f%)F<7$F_v$!3E`^Y'4>0_"F]`l7$$!3k+++]miz(*FB$!3W)R^lvVtz)F<7$Fev$!3AoAA%3.Tt"FB7$$!3Q+++]D[Y$*FB$!31Mm2"='[oDFB7$Fjv$!3h52P`@PtLFB7$F_w$!3_9yoMgc3[FB7$Fdw$!3bRRMk&=K/'FB7$Fiw$!3t$*oeu[Z^pFB7$F^x$!3v[fWBjAJwFB7$$!3Omm"zR6;J(FB$!39T\3I=z?zFB7$$!3M++](QYi3(FB$!3R1CbfbBB")FB7$$!3zm;H#)QctpFB$!3avlUBL"=>)FB7$$!3MML3x8)3'oFB$!3"R&3=)*R")Q#)FB7$$!3y+](=())>[nFB$!3)*\4?D=[k#)FB7$Fcx$!3]n?'*RH9p#)FB7$$!3gnm;/&f+a'FB$!3I*\*Q$QbpD)FB7$$!3'zmm;k-YW'FB$!3;1=u=GFI#)FB7$$!3Anm;zd9\jFB$!3pVjzRQU*=)FB7$Fhx$!3=Ql'*3TxM")FB7$$!3Anmm">vF1'FB$!3X-G(*)>6d)zFB7$F]y$!35xVq$[!p'y(FB7$Fgy$!3T-3q^h'R:(FB7$F[[l$!3v]`%*R=@LjFB7$F_\l$!3\rY%ySnL]&FB7$Fi\l$!3?#>WK!z^EYFB7$F^]l$!3vbmn"*G[lOFB7$Fc]l$!3f**z'fvc!fFFB7$Fh]l$!3Cd5&p/'Q))>FB7$F]^l$!3!\!zYyc*pL"FB7$Fb^l$!39vb"HhC2-)F<7$Fg^l$!34pAyA99'=%F<7$F\_l$!3kkn!3PK%3>F<7$Fa_l$!3\]%*\C]&>N'F]`l7$Ff_l$!3?6!=w5p:h)Fcv7$F[`l$!3)>vRdi*z&f(!#D7$Fa`l$"3d*fv<c"3VtFcv7$Ff`l$"3,'[i*[ju4iF]`l7$F[al$"31z1pv()=P=F<7$F`al$"3Vc[kJ$Q-+%F<7$Feal$"3%QX(=R%)y)f(F<7$Fjal$"3oo7-_V:h7FB7$F_bl$"3QKz#f^+`#>FB7$Fdbl$"3&>4V!*4n6s#FB7$Fibl$"3EK"=&=M;(f$FB7$F^cl$"3qq!3D$*)>GXFB7$Fhcl$"3e^J-+(3VV&FB7$F\el$"3gPizHC[%H'FB7$F`fl$"33n-:a3!>8(FB7$Fjfl$"31fwiW'y"yxFB7$$"3'*HL$e\@o1'FB$"3Zc*z`J-%*)zFB7$F_gl$"3\(='>,X[W")FB7$$"3CILe9b;qjFB$"3=d5Tdqh*>)FB7$$"3+(***\(=!GrkFB$"3-"4O.*4<R#)FB7$$"3wjmTg[RslFB$"3y2*y'fDsi#)FB7$Fdgl$"3h"y#o'>&*)p#)FB7$$"3bjm;H5Z"y'FB$"3#=>$o0Y5f#)FB7$$"3p(****\_K%*)oFB$"3'\%)4Z.M*G#)FB7$$"3#=LL3-%R(*pFB$"3tboI2i6z")FB7$$"3([mmm^b`5(FB$"3$Qne+G`%4")FB7$$"3/KLL3&y7K(FB$"3*\j9B-c,"zFB7$Figl$"3Kj/P=Q*3j(FB7$F^hl$"3Or?0<93DpFB7$Fchl$"3c6@qRS\wfFB7$Fhhl$"3'H**e'z1q%p%FB7$F]il$"3R.7o_`*p?$FB7$Fbil$"3&\$p%zD$ov;FB7$Fgil$"35YP+t`X&y(F]`l7$$"3^*****\-#4>5F9$!39#o*Rh'p`i(F<7$F\jl$!3AcJuTbh%f"FB7$$"3:LLLj)o61"F9$!3X!))>iFU$4CFB7$Fajl$!3CPDg0`$z>$FB7$Ffjl$!3wSJ5*>#*Gj%FB7$F[[m$!33P(R)\yuzeFB7$F`[m$!3g67(eS2O$pFB7$Fe[m$!3OV7$Q;&Q$p(FB7$$"3Wm;/ctNr7F9$!3FR'ezbYx%zFB7$Fj[m$!3=#=]d"pFG")FB7$$"3$o;a8nmCI"F9$!3K:J$Rv.4>)FB7$$"39+]7Vk$GJ"F9$!3DzTqYODN#)FB7$$"3YLe*[@1KK"F9$!3<Ubp"Q8:E)FB7$F_\m$!3%ffPhiG*p#)FB7$$"3um;/w0=W8F9$!3vQnoUaRg#)FB7$$"3rmmTl^ya8F9$!3;!4uYA-HB)FB7$$"3om;za(*Ql8F9$!3SHrxcC*y=)FB7$Fd\m$!3N4yO_i'e7)FB7$$"3gmm"H_.sR"F9$!3W7"GxfKI&zFB7$Fi\m$!3CVGyICV>xFB7$Fc]m$!3[f0TK+]*4(FB7$Fg^m$!3."[&R#fd]J'FB7$F[`m$!3qkeLu(o!)\&FB7$Fe`m$!3UvVZ!oFfj%FB7$Fj`m$!3zE8#[(*3"\OFB7$F_am$!3"*G;%=j"y?FFB7$Fdam$!3pzt%z%pB!)>FB7$Fiam$!35rYqgx+^8FB7$F^bm$!3UNB@/Z!=>)F<7$Fcbm$!3X%3&R3*QqM%F<7$Fhbm$!3VO.%)pP7e>F<7$F]cm$!3'3KhXY1&fjF]`l7$Fbcm$!3;"eavYY:1)Fcv7$FgcmF_dmF[dmFcdmFigmFfimF]jmFajm7*-F,6$7_u7$F0$"3@\x+L(o#f:F57$F>$"3/FP;jTC=;FB7$FD$"3B**Q6siTZ@FB7$FI$"3)*R0DRPK@DFB7$$!3>L$3xC?c"=F9$"3G>[zg?-hEFB7$FN$"3!**3[3C/Jv#FB7$$!3pm;zuE'Hx"F9$"3Oi9aWS7.GFB7$FS$"3k&\?ZiR*=GFB7$FX$"3F$RIy%=\)y#FB7$Fgn$"3;8_;TtmcFFB7$$!3(**\il:p]l"F9$"390AfnVjgFFB7$$!3sm;z%4&QW;F9$"3@W?u'QsCx#FB7$$!3ZL3-L5qL;F9$"3cr$[,kTOz#FB7$F\o$"3%f"=bVL^DGFB7$$!3FL$3x%)[;g"F9$"3cJ9N2]HEHFB7$Fao$"3q#))eaPNL3$FB7$F[p$"3%4&)H'=e"=a$FB7$F_q$"3=9i'Q)QYBUFB7$Fcr$"3;x,k(*3IM^FB7$F]s$"30XZ]*41%zhFB7$Fbs$"3Q-zCpMS"G(FB7$Fgs$"3]P&*GT-/a#)FB7$Fg_n$"3[32#*Q\LS')FB7$F\t$"3W(HEm!)ea$*)FB7$$!39++vj(e7G"F9$"3HD7r_7LV!*FB7$Fd`n$"3;fC%\xw?7*FB7$$!3qmm"H47,E"F9$"3/x,$eb'*)p"*FB7$Fat$"3vp#eoMv^=*FB7$$!3gLeR#yi'Q7F9$"3AU"Q)[9Xl"*FB7$$!3*om"H2oyF7F9$"3QP1[O**\3"*FB7$$!3=+v=K3"p@"F9$"39'f=AkwK,*FB7$Fft$"3R#po_*y+z))FB7$$!3.+](o!HG%="F9$"3?S=n!4b;\)FB7$F[u$"3D\#\C3:g%zFB7$F`u$"3Y))f``iw:mFB7$Feu$"3+jt@bK7p[FB7$Fhan$"3-7))3IVpQPFB7$Fju$"3Uo4W-LlHDFB7$F`bn$"3Dk(*Rkh$pE"FB7$F_v$!3^1J5qux!G#F]`l7$Fhbn$!3Tgpty!>tJ"FB7$Fev$!3%zrp(o@]$e#FB7$F`cn$!3-^q?4TV%z$FB7$Fjv$!3'\V^&\(p\#\FB7$$!3y++++K?@*)FB$!3"zJ+[*oD<fFB7$F_w$!3#Rwm&*4tlz'FB7$$!3f*******f)y.&)FB$!3yQfj#)4!*[vFB7$Fdw$!3EX!o5d0R;)FB7$$!3*GL$3x]b0")FB$!3CKHm<p&zf)FB7$Fiw$!3z'o%y='>:"*)FB7$$!3IM$3Ful7#yFB$!3qefs)3qK-*FB7$$!3q++DJE]ExFB$!3w*GV2S<a5*FB7$$!34n;z>&R<j(FB$!3`;&yI&zZe"*FB7$F^x$!306fP!QCJ=*FB7$$!3#***\7.RHCuFB$!3G,[lqnfw"*FB7$Fddn$!32DH"370F8*FB7$$!3#RL3F*)G*)>(FB$!3!R1xWZbL0*FB7$Fidn$!3p3KwzXpS*)FB7$Fcen$!3*z"Gv5!y]i)FB7$Fcx$!3*RPg#*G^o?)FB7$Fhx$!35')y9nd^HtFB7$F]y$!3!p`h0[F;M'FB7$Fgy$!3mu'p&*\()>?&FB7$F[[l$!3!eysi)4S6UFB7$F_\l$!3)\"HH)=su`$FB7$Fi\l$!38&yjR(*yL3$FB7$$!3?,+vomc")RFB$!3&\M5c@N^#HFB7$F^]l$!3'Q\\")4LT#GFB7$$!3*)**\(=(H0eOFB$!3Q=ts;yV#z#FB7$$!3\mm"H2:-b$FB$!3>*yo&pKerFFB7$$!34L$eR<xBW$FB$!3zMK))4W:gFFB7$Fc]l$!3dXR:t[kcFFB7$Fh]l$!3P'[:t3%G(y#FB7$F]^l$!3XtU;fg'*=GFB7$$!3Mmm"HAb()H#FB$!3Me*R%fd+2GFB7$Fb^l$!3D8Ap'oN<w#FB7$$!3c***\(=?=q=FB$!3!**GiTU/\n#FB7$Fg^l$!3c)y)*\qq0a#FB7$F\_l$!3%3#QgW>og@FB7$Fa_l$!3)otkt97Lh"FB7$F[`l$!3H*fFCvk&[RF]`l7$Ff`l$"3=Mp*f8CGg"FB7$F[al$"3#*Q[oLs<T@FB7$F`al$"3-NsS5A"3_#FB7$$"3gkmTN.8P=FB$"3Kp-op&)RdEFB7$Feal$"3*HZSK#\()[FFB7$$"3*y**\il&p^AFB$"3!)>(ym')Q-!GFB7$Fjal$"3*pZ-l>f&=GFB7$F_bl$"31o[&*=()Q"z#FB7$Fdbl$"3/*)*[4IHnv#FB7$$"3D)**\i5+.U$FB$"3js`.,>%)eFFB7$$"3!z***\7)[]_$FB$"3)*yPw!*p7oFFB7$$"3c(**\(=vzHOFB$"3f=1`'>")fy#FB7$Fibl$"36;^**HRs8GFB7$$"3`'***\PO/WRFB$"3=#o20mmO!HFB7$F^cl$"3j$o0L][j/$FB7$Fhcl$"3S!Q\,nhH\$FB7$F\el$"3Ib'=i&\htTFB7$F`fl$"3p;!H*>sop^FB7$Fjfl$"3$HL]@$G]AjFB7$F_gl$"3FB4A1atntFB7$Fdgl$"3Q@\9N3e$G)FB7$F^_o$"3$Rh./!)*>r')FB7$Fh_o$"3l54C-m/i*)FB7$$"3!z***\7qJ8sFB$"3]]%yFt*Ql!*FB7$F]`o$"3)\1c$o)*)y8*FB7$$"3>mm;/+CHuFB$"3^>se'H!ox"*FB7$Figl$"3:DW[$)))4$=*FB7$$"3)HLe9mI]j(FB$"3.npL\d6d"*FB7$$"3ilm"H#)fGt(FB$"3!GpRaLB35*FB7$$"3F)*\P%)*)oIyFB$"3!HIEuA!\8!*FB7$F^hl$"3Mrul;Hc%*))FB7$$"3W)**\(ok<C")FB$"3=V4so"Q1c)FB7$Fchl$"3Iz*R/A)Q)4)FB7$$"3Y)**\(=5uL&)FB$"3nHmNs3<\uFB7$Fhhl$"30#[*GP)Hql'FB7$$"3qlm"HZ`:'*)FB$"3sma$RDHPt&FB7$F]il$"31lx1Nf.&p%FB7$$"3xJLe*yGnP*FB$"30dd"oa'fHOFB7$Fbil$"3sqLK[5h(\#FB7$$"3o'**\(opEz(*FB$"3/`g_eIX>8FB7$Fgil$"3%et-!QD!y;"F<7$Fgao$!3]C2hy-KU6FB7$F\jl$!3u`BE#>D#yBFB7$F_bo$!37"\f]tqgc$FB7$Fajl$!3'p<BB``Co%FB7$$"36L$3F=wF5"F9$!32TsL&=PWo&FB7$Ffjl$!3!3t!e;8_!e'FB7$$"3")**\7$)R"R9"F9$!37dm++0XctFB7$F[[m$!3x"=_WJk8+)FB7$$"3")**\i:m,'="F9$!3qL<UV"e$G&)FB7$F`[m$!3eo\sR*z+!*)FB7$$"3#)*\iS@<$=7F9$!3sM&R#eWxF!*FB7$$"3:L$3-3%3H7F9$!33d<#fF&G<"*FB7$$"3[mTNY4&)R7F9$!3H@Rq&G'Rp"*FB7$Fe[m$!3DCD\"y\^=*FB7$$"38L3F%e()4E"F9$!3\1Zd*z^r;*FB7$Fcco$!3QG&*y'ouz6*FB7$$"3v*\7y7F<G"F9$!3[Fy0!\b"R!*FB7$Fj[m$!3#*>e8f+SK*)FB7$F`do$!3kSJ]GlkU')FB7$F_\m$!3!=J,Pcv]E)FB7$Fd\m$!3kQ\YJ'\aH(FB7$Fi\m$!3;;fTaoT%>'FB7$Fc]m$!3tJJX61%H7&FB7$Fg^m$!3!RT&eCIg$>%FB7$F[`m$!35.iM'o**R`$FB7$Fe`m$!3%)zIg">fq3$FB7$$"3OLL37#4?g"F9$!3CNLK2(\T#HFB7$Fj`m$!3fq>ZF-b@GFB7$$"3KL$3-sO_j"F9$!36Bo"zKr**y#FB7$$"3$)***\ib7jk"F9$!3xF:T(H)opFFB7$$"3dm;H#R)Qd;F9$!3'\H<*)=c"fFFB7$F_am$!3+A;UX6tcFFB7$Fdam$!3U"*yI=>"yy#FB7$Fiam$!3>m`)oEw)=GFB7$$"3-+]7)fR)o<F9$!3U'3b!o'o&3GFB7$F^bm$!3G?T$p#4VmFFB7$$"3fm;/"e)36=F9$!3r<@=\%>Wo#FB7$Fcbm$!3SHKM?:lcDFB7$Fhbm$!3b8%fH3WQ<#FB7$F]cm$!3$404ynjQh"FB7$Fgcm$!3@\x+L(o#f:F5F[dmFcdmFjhm-Fjgm6%FbimQHThe~3~term~Fourier~approximation~(blue)F(FdhmFigmFfimF]jmFajm7*Figm-F,6$7au7$F0$!3!>m:)G.>lC!#\7$$!3RLL$e%G?y>F9$"3KR3[.")*=R$Fcv7$F7$"3c/fJ&zdun#F]`l7$$!3%*****\P&3Y$>F9$"39Z!f=(3$o$))F]`l7$F>$"37k26sQ,I?F<7$FD$"3#4)phWkoebF<7$FI$"3+eA%oUz#36FB7$FS$"3(Q:sR:kiy#FB7$FX$"3l)[G#Q#>!yNFB7$Fgn$"3o*GE(eI.WTFB7$Fj[p$"3YSe"ysKqJ%FB7$F\o$"3GgUqR'olT%FB7$$!3_m"z%4HL7;F9$"3,<!H"z*z2W%FB7$Fg\p$"3`Z*[dE8)\WFB7$$!3++v$fyk4f"F9$"3U>N<v*GbW%FB7$Fao$"3Zk$[x-D,V%FB7$F[p$"3YK,$fep+K%FB7$F_q$"35)\9R"*)>WUFB7$Fdq$"3B)))p')3x(\UFB7$Fiq$"3+o/%R)[xqUFB7$F^r$"3\]ZqE7W4VFB7$Fcr$"3x`hVm0vnVFB7$Fhr$"3cM'y$*)4b\XFB7$F]s$"3\f;c'4T[#[FB7$Fbs$"3u]flHy:!p&FB7$Fgs$"3t=(p.Mly'oFB7$F\t$"3f5X&yV?o8)FB7$Fat$"3WRk?X,S%>*FB7$F\`p$"3@#zIf"o,Z&*FB7$Fft$"3B+)Q[$fD9(*FB7$$!3um"z>))e^>"F9$"3OI14NGC<(*FB7$Fi`p$"3aLSTP^hh'*FB7$$!3KL3xJpSt6F9$"3$HzRZ4@Xa*FB7$F[u$"3*Q:A5#["QO*FB7$$!3HLL3F=PV6F9$"3![wuSpip)))FB7$F`u$"3%\*=/$zPs?)FB7$$!3kmm"zc`]5"F9$"3xQ'pzTm4L(FB7$Feu$"3bW'QNNQBF'FB7$Fhan$"3q9mI@>h*)[FB7$Fju$"31d,<30CWLFB7$F`bn$"38iV8por&o"FB7$F_v$!3MWYzyX.TIF]`l7$Fhbn$!3?[FguQX_<FB7$Fev$!3!=e]<^QTT$FB7$F`cn$!3$*4aL%3G%f\FB7$Fjv$!3eHR4l]cQjFB7$F_cp$!3.>!R"pa6suFB7$F_w$!3p%>>`KbjQ)FB7$Fgcp$!3cdkMg(y[1*FB7$Fdw$!3AY'*y@%)R-&*FB7$$!3]m;a)==.?)FB$!3F9$fv%GlA'*FB7$F_dp$!3C(e`q")>bp*FB7$$!3H**\il>z5!)FB$!3Tb^McenA(*FB7$Fiw$!3BpP5b$*=1(*FB7$F\ep$!3V413y1L_&*FB7$F^x$!3NLO@)e]qD*FB7$Fidn$!3`e%*oU2(*\")FB7$Fcx$!3GF`2tDW)z'FB7$Fhx$!3cj)[mV$)zt&FB7$F]y$!3Gf3[/tSE\FB7$Fby$!3Q+N(\gn9g%FB7$Fgy$!3^u^2i.<(Q%FB7$F\z$!3!z?@\@x)=VFB7$Faz$!3H_'3w$p*RF%FB7$Ffz$!3U5fSt<3]UFB7$F[[l$!3nST)G4+VC%FB7$F_\l$!3&Qe!f]I)4K%FB7$Fi\l$!33![d*\c6IWFB7$$!3gM$3xc/%*3%FB$!3`Hm)oK>cW%FB7$Fahp$!3%oLeg+u(\WFB7$$!3!ym"zp(GP(QFB$!3OR2s'=C.W%FB7$F^]l$!3MeS!R@l`T%FB7$F^ip$!3[Ap2l"QKJ%FB7$Fc]l$!3)e(QBq9<OTFB7$Fh]l$!3am]2zcO&f$FB7$F]^l$!3Q[v_T&[]%GFB7$Fg^l$!3T'RGa!Qg^6FB7$F\_l$!3yys,$*fB$p&F<7$Fa_l$!3Zw=C2qL4?F<7$$!3sNL$3x9^c'F<$!3ipp#QQl'R*)F]`l7$Ff_l$!3diaNW!4;$GF]`l7$$!3$*pm;za**>BF<$!3%4."pW]S(3%Fcv7$F[`l$!3IV')HA]'=`#!#C7$$"3qbm;/rI2?F<$"3**3&>,173l#Fcv7$Fa`l$"3F%\<#>%[yT#F]`l7$$"3:Tm;zHz;kF<$"3NzD!>N&[i$)F]`l7$Ff`l$"3tmw%>t<f'>F<7$F[al$"3GW5]D!zk\&F<7$F`al$"3cF>hl"fr5"FB7$Fjal$"3%H)z:h@bOFFB7$F_bl$"3%=[)z&\1d`$FB7$Fdbl$"3msBM*)p#p6%FB7$F^^q$"3kP%\L44lH%FB7$Fibl$"3pUfLhK(\S%FB7$$"3)o**\7$\HRQFB$"3$****4fl?TV%FB7$F[_q$"37D7b.S8[WFB7$$"3>'**\PM#z[SFB$"3K=&y/'\k[WFB7$F^cl$"3!QL[oF3wV%FB7$Fhcl$"3)3nR5F11L%FB7$F\el$"3yYSSPG"\C%FB7$Fael$"3+^n#o\@![UFB7$Ffel$"3Cz\Ui"e#pUFB7$F[fl$"3?3^$yRC;J%FB7$F`fl$"3G>+'y$ysxVFB7$Fefl$"3FWP$elu"*e%FB7$Fjfl$"3$)Hh7^I*R"\FB7$F_gl$"3D3$\0.Umx&FB7$Fdgl$"3*\8:rL_@"pFB7$Fh_o$"34g!Q!f_r/#)FB7$Figl$"3)y7)y&yuuD*FB7$F`bq$"3(*yO\W]#*f&*FB7$F^hl$"3YEt*o)fx5(*FB7$$"3yl;H2tME!)FB$"3K\=*G#=F@(*FB7$F]cq$"3zFlU7$o[o*FB7$$"33J$3-j0?A)FB$"3SpR`^`O*f*FB7$Fchl$"3j*H'HtU,j%*FB7$Fecq$"3Z/hiv2J#)*)FB7$Fhhl$"3wa"f@Js&[#)FB7$F]dq$"3.eTH/&o$psFB7$F]il$"3[bc3x6[kgFB7$Fedq$"3=3.c5Wa_ZFB7$Fbil$"3U,?#f34EI$FB7$F]eq$"3!)eSNk(z_v"FB7$Fgil$"3EoxFeD/d:F<7$Fgao$!3'ePh)e"30_"FB7$F\jl$!3kD%z)G^CZJFB7$F_bo$!3`^DYZW[sYFB7$Fajl$!3y87"ykx$\gFB7$Fafq$!3XX-&p*QK9sFB7$Ffjl$!3P2'e$)fE<<)FB7$Fifq$!33vk?'QcK!*)FB7$F[[m$!3c0/P(o-5S*FB7$$"3[m"z%\(\_<"F9$!3cj8Qfyyo&*FB7$Fagq$!3M)f:u-NXn*FB7$$"39L3x"[$y'>"F9$!3XQ.3DBW?(*FB7$F`[m$!3(*oT#=ix$4(*FB7$F^hq$!3?<wg0Q!3`*FB7$Fe[m$!3`2)>cl$zs"*FB7$Fj[m$!3A))>Wd^=H")FB7$F_\m$!31N*GM?LV)oFB7$Fd\m$!36&R*=XW-/dFB7$Fi\m$!3gRRqG`)Q$[FB7$F^]m$!3`'\+)y(=,b%FB7$Fc]m$!3"=IO=**GYO%FB7$Fh]m$!3GpR;dP11VFB7$F]^m$!3JD9(GP7!oUFB7$Fb^m$!3640N@)>$[UFB7$Fg^m$!3cm+9XG`WUFB7$F[`m$!3y<QCmmr@VFB7$Fe`m$!39#)[u!**>$HWFB7$$"3im;/wL$4f"F9$!32IA4K))\XWFB7$Fc[r$!3@%Qft,P(\WFB7$$"3')**\7[]38;F9$!3mB#ynu"fRWFB7$Fj`m$!3Q]BYx6,8WFB7$F`\r$!3-DCQ&\)\/VFB7$F_am$!3+xE'HmFn6%FB7$Fdam$!3o;8p7L!ye$FB7$Fiam$!3rqssayckGFB7$Fcbm$!3KuoB&4o'*="FB7$Fhbm$!3])f%*\U"))HeF<7$F]cm$!3/"4')Q'4k6?F<7$$"31+]i0j"[$>F9$!3rzVGU;5b()F]`l7$Fbcm$!3O^d;)*yJ_EF]`l7$$"3-+](=5s#y>F9$!3[de[4XwfLFcv7$Fgcm$"3!>m:)G.>lCFe_rF[dmFcdm-Fjgm6%FbimQHThe~4~term~Fourier~approximation~(blue)F(FdhmFjhmFfimF]jmFajm7*Figm-F,6$7_vFbio7$F7$"3!*3nOav*4K)F<7$F>$"3&)Rbw+ha]9FB7$$!3em;/'zXQ*=F9$"3x"Q&H`7>@;FB7$FD$"35n=Lv'p7t"FB7$$!3ymT5:uRl=F9$"3wg_)p*pzl<FB7$$!3IL$e9i9f&=F9$"3W='zqrk&)y"FB7$$!3")*\7y#=VY=F9$"3*QO+ge:9!=FB7$FI$"3n&G'Q8[Y1=FB7$F_jo$"3YvpS$yb;!=FB7$FN$"3klGk++H)z"FB7$$!3EL3-oqi$y"F9$"3faccLpO1=FB7$Fgjo$"3=xl3f2eD=FB7$$!3!**\i:G)Hi<F9$"3r-6w]?-f=FB7$FS$"3a_^Ls%[$4>FB7$FX$"3C/a;+Ij;BFB7$Fgn$"3%*GWvTHi]IFB7$Fao$"3#=0lg=M#=[FB7$Ffo$"3C&49N^$e@^FB7$F[p$"39O(4r!HMU`FB7$F`p$"3d8g<!4F">aFB7$Fep$"3z"yvQ(yKtaFB7$Fjp$"3x=!*)*png0bFB7$F_q$"3CWs?:'ps^&FB7$Fcr$"3O'fg4qYzR&FB7$F]s$"3]nJp9T#*)>&FB7$$!3mmm;9pP39F9$"3-T2;A`"=<&FB7$Fh]n$"3yW,5R[;l^FB7$$!32++]2A;(Q"F9$"3$QU?zBcP=&FB7$Fbs$"3)G-U.d#yJ_FB7$Fe^n$"3ER5Etc/HaFB7$Fgs$"3]R$R?x8Kx&FB7$F\t$"3=&>!4Jg/uoFB7$Fat$"3h/u&eNI1I)FB7$Fft$"3U><5z%RPf*FB7$F[u$"3h6<u$Rnq+"F97$F`u$"3**Q3$[R$\*Q*FB7$Feu$"3u#[7z!>X9vFB7$Fhan$"3\')eNR47ofFB7$Fju$"3aCF+:z_OTFB7$$!3@+]7LG(>."F9$"3H\!*=g7nQJFB7$F`bn$"3"4H*H#\1<5#FB7$$!3zm;/">//,"F9$"3]`sH>KQQ5FB7$F_v$!3_J#G61!H,QF]`l7$$!3E,++vE"z))*FB$!3ZRM7%*zK=6FB7$Fhbn$!3u,CUr3X%=#FB7$$!3-+++D1Mr'*FB$!3Q/F$z)Q'HA$FB7$Fev$!3E5.Z)R:5A%FB7$F`cn$!3![$zy%R-([gFB7$Fjv$!3.!)*)GdlQ&e(FB7$F_w$!3tdDIUo%>`*FB7$Fdw$!3Ff'fDZlr+"F97$Fiw$!3k')HJ<OtQ&*FB7$F^x$!3W$y_Wi:0T)FB7$Fidn$!3'e-$Q6wR))oFB7$Fcx$!39lVV$RU#GdFB7$Fefn$!3;?>+0!=lU&FB7$Fhx$!3+.5VYx#RC&FB7$$!3(zmmT0K#ehFB$!3SC:&*\F8%>&FB7$Fbgn$!3i'>*>>v.p^FB7$$!3fnm;H$=t'fFB$!3;_"G#R;vl^FB7$F]y$!3]'o+$Gu&4=&FB7$Fgy$!3[l@td"3PQ&FB7$F[[l$!3FrARiX6<bFB7$F`[l$!3j5v'>I7W]&FB7$Fe[l$!3%3<)=ThKraFB7$Fj[l$!3bEFX'Q6mT&FB7$F_\l$!3$\,>>O['R`FB7$Fd\l$!3ZSBK;Tg>^FB7$Fi\l$!3l`$4D\>$=[FB7$Fc]l$!3'*o]o)f@Z.$FB7$Fh]l$!3pye(=CQ7L#FB7$F]^l$!3;H%HY]yk#>FB7$$!3/L$eR_)*eS#FB$!32)HQ"o[)3(=FB7$Fajp$!3s"Rs8JtH$=FB7$$!3k**\(=#>h">#FB$!3+eN)H5$=5=FB7$Fb^l$!3G5***>;'[*z"FB7$Fijp$!3Ggk#=Oc0!=FB7$Fg^l$!3EnqO?zy1=FB7$$!3Em;z>W]d:FB$!3*fq#*=)p=.=FB7$$!3Mmm"HU8"f9FB$!3_H,'RG[<z"FB7$$!3Vm;/ECsg8FB$!3,h=(ej_+x"FB7$F\_l$!3I,k%\S&)ft"FB7$$!3ommTN%\b1"FB$!3t#H`6*o7C;FB7$Fa_l$!3%=(Q^vm@Z9FB7$Ff_l$!33"[IR(>\k%)F<7$F[`l$!3g1*=U*oL[RF]`l7$Fa`l$"3Vc<GK')ek!)F<7$Ff`l$"33u2=e+5S9FB7$$"3-(***\7r2a5FB$"3zC`*4,]ch"FB7$F[al$"3Cm3J3c+H<FB7$$"3[(**\PRi>M"FB$"3&y64!p1dk<FB7$$"3Ikm;aT#zV"FB$"38A.z++-)y"FB7$$"37JLe9f)Q`"FB$"3Qg6#yu^7!=FB7$F`al$"3*R/\rL^k!=FB7$Fc\q$"3G4e=^#R>!=FB7$Feal$"3/iM0/F"zz"FB7$$"3dk;/EV0[@FB$"3c'RnVSgX!=FB7$F[]q$"3Rq$HxPq7#=FB7$$"3BJ$ek)pLbBFB$"3fo'HXSN4&=FB7$Fjal$"3/&[Y%yv2'*=FB7$F_bl$"3y5k(*>%yBG#FB7$Fdbl$"31dp&zo>p*HFB7$F^cl$"3i%HdJ$>sTZFB7$Fccl$"3FHJQ7)>z1&FB7$Fhcl$"3hx!4^h,.J&FB7$F]dl$"3I\>x-Wn'R&FB7$Fbdl$"3w'fQEgG$faFB7$Fgdl$"3]gp-Tdv)\&FB7$F\el$"3M4+'eKbh^&FB7$F`fl$"3gE(>WWI0R&FB7$Fjfl$"3Y)R,?RrF=&FB7$$"3?jm"H#oqlfFB$"3[4Be[Z'e;&FB7$F_]o$"3pFMAXmjp^FB7$$"3t'**\(oh$z;'FB$"314*fp$G-)>&FB7$F_gl$"3:YMo*Q;WD&FB7$F\^o$"3I\jBG4RhaFB7$Fdgl$"3F`R))3br-eFB7$Fh_o$"3n3R()e9()[pFB7$Figl$"3M:xmWhF6%)FB7$F^hl$"3RI;S$\7"o&*FB7$Fchl$"3t)3+ND6w+"F97$$"3p(\P%[8Jt$)FB$"33p#HcV2r+"F97$$"3lJ$3_!zyE%)FB$"3l4U#4HMX+"F97$$"3hl"z>Yk-[)FB$"3E=!f(H4@)***FB7$Fecq$"3R>LT]v0H**FB7$$"3Gl;HKTpS')FB$"3m!QkJbiEs*FB7$Fhhl$"3'G(oN=N3B%*FB7$F]dq$"3yB[*[!pGS&)FB7$F]il$"3pQPOitm*G(FB7$Fedq$"3WkB-s&z#4eFB7$Fbil$"3R966"pYh3%FB7$F]eq$"3IA(4NQ`z=#FB7$Fgil$"3%\&yAZ2EY>F<7$$"3@mmT:Gd35F9$!3Yj0Q'fA9c)F<7$Fgao$!3e=&zRn]m*=FB7$$"3"GL$eM7hH5F9$!3tZ6=&)R]9HFB7$F\jl$!3]cYM9cu(*QFB7$F_bo$!3%o%[U+L7;dFB7$Fajl$!3+JzIf;@tsFB7$Fafq$!33u`)3*HN'[)FB7$Ffjl$!3>d$R=)QJg$*FB7$Fifq$!3(fk1_++a))*FB7$F[[m$!3i[Fmwk]25F97$F`[m$!3$G&HuFWse&*FB7$Fe[m$!3Y23Y$o#yj#)FB7$Fj[m$!3%>L?a0Wd'oFB7$F_\m$!35R&e)\*4Ty&FB7$Fbeo$!3#\!>#[CVhV&FB7$Fd\m$!3Eej&f`3_B&FB7$$"3im;aL*)f'Q"F9$!3$H3GJiKb=&FB7$F_fo$!3!y#yje$za;&FB7$$"3em;H7"3yS"F9$!3%3m9*=[*3<&FB7$Fi\m$!3u;D&RhEq>&FB7$Fc]m$!3&zPg0m7.S&FB7$Fg^m$!38*H8nd`n^&FB7$F\_m$!3,()yNiyl-bFB7$Fa_m$!3?&zLYOW(oaFB7$Ff_m$!3-u]IJ#pQT&FB7$F[`m$!3G')3yoJZP`FB7$F``m$!3c&okm]"y?^FB7$Fe`m$!3gwc#3T"[D[FB7$F_am$!31ORnuh`'*HFB7$Fdam$!3EXoMh'H[K#FB7$Fiam$!3%)e))3?]_K>FB7$$"3FLeR_tFe<F9$!3w*>g;#p)e(=FB7$Fc]r$!3Mggl9mmO=FB7$$"3bmT&Q%=Sz<F9$!3u,3(yxmC"=FB7$F^bm$!3AZ:c3xV+=FB7$F[^r$!3+VK">X7)*z"FB7$Fcbm$!3$zH![=oy1=FB7$$"34+]P*[AB%=F9$!3*=NG#p*GW!=FB7$$"34++D1>V_=F9$!3a#4mT.IVz"FB7$$"34+]7B8ai=F9$!3[DTa]N"Qx"FB7$Fhbm$!3OzT]w3`S<FB7$$"33++vt&pG*=F9$!3]C>_#*\HG;FB7$F]cm$!3+'4I:a*eZ9FB7$Fbcm$!3'>)G-Zt+(H)F<Fh^rF[dmFcdmFjhm-Fjgm6%FbimQHThe~5~term~Fourier~approximation~(blue)F(FdhmFfimF]jmFajm7*Fjhm-Fjgm6%FbimQHThe~6~term~Fourier~approximation~(blue)F(FdhmFigmFfim-F,6$7^y7$F0$"35"*Gk(["z$Q%!#^7$$!3"om;HU,"*)>F9$"3e&3F:8C?#*)!#A7$Fg_r$"34'>,D2Bj3(Fcv7$$!3(****\(oUIn>F9$"32!fb]#p.jBF]`l7$F7$"3UP>]l)Rw]&F]`l7$F_`r$"344L%yTL7x"F<7$F>$"3mi(G3jNJ#RF<7$FD$"3_y[^Q4-F)*F<7$FI$"38FV,nn?M<FB7$FN$"3,Nd$GWI0^#FB7$FS$"3*))R!**f#y)pHFB7$$!3NLLe/))*3u"F9$"3g")R7zvnCIFB7$$!39LL$3sj,t"F9$"3@Vth<ekdIFB7$$!3:LL3P'G%><F9$"3Bx_<e>-sIFB7$FX$"3\F;$Hat>2$FB7$$!3>LL$eQBso"F9$"3uN))4#Q+)[IFB7$Fgn$"3%*zDvx[NKIFB7$Fe[p$"3)4#["[3E2/$FB7$Fj[p$"3&fsNbouo1$FB7$F_\p$"3A^_v_Q,:JFB7$F\o$"3rMGUSdT)=$FB7$Fg\p$"3!RBIR$QT=MFB7$Fao$"3F`([)Gs&*ePFB7$F_q$"3iOzT=``'\&FB7$Fiq$"3)yT_c")Gd'eFB7$Fcr$"3!47U))G?T7'FB7$$!3y******fRv\9F9$"3U$e\[hja?'FB7$Fhr$"3'zv\E,vSD'FB7$$!3rmmmJ3CH9F9$"3z^"Hn%R1riFB7$F]s$"37CDUoZ%*eiFB7$Fbs$"3eAdAr(4P+'FB7$Fgs$"3]K"GMLb!*y&FB7$Fb_n$"3qfkH#)eX0eFB7$Fg_n$"3,FdN!3TT'eFB7$F\`n$"3_I=!R![+qfFB7$F\t$"35gC7Zc7EhFB7$Fd`n$"3SM"ebA%*4f'FB7$Fat$"3(oVzI]P'RsFB7$Fft$"3C<eQ=^nw))FB7$F[u$"3SfJYQ/L:5F97$$!3BL3Fu6ud6F9$"3'yzlH#)zD-"F97$$!3%)**\(=R^H:"F9$"3)fYr)Q<(z-"F97$$!3om"z%4;;[6F9$"3)eI,f\%QJ5F97$Fffr$"3Wo5A7SqK5F97$$!3!**\(oW?eQ6F9$"3'=w2"oY#=."F97$$!3um;HiAzL6F9$"3u=!RS6]'G5F97$$!3OLe*)zC+H6F9$"3Qye=FS4B5F97$F`u$"3%)e+i533:5F97$F^gr$"37j:T+%QNd*FB7$Feu$"3CH@!3r[Ud)FB7$$!3hm;H<,6v5F9$"3HmdN(zh&HyFB7$Fhan$"34\S0#Qy<'pFB7$$!3>L$3_ZTN0"F9$"3FRZ,zJS")fFB7$Fju$"3"4"3<aP0-\FB7$Fdjt$"3wDG#Rx9,u$FB7$F`bn$"3.#RkO#**H9DFB7$F\[u$"3*zxVgvN^C"FB7$F_v$!3y&Q$pbNahXF]`l7$Fd[u$!3p;#yv`Q3M"FB7$Fhbn$!3D)HP<=JEh#FB7$F\\u$!364Q(3oO!RQFB7$Fev$!3eHHTGCS**\FB7$$!3,,++v&oZX*FB$!3$o.Urhk\2'FB7$F`cn$!3gL?iB*o$\qFB7$$!3w*****\_'>Q#*FB$!3=a@A"z4"4zFB7$Fjv$!3?6%**\#R(Qk)FB7$F_cp$!3XtdJTi3&o*FB7$F_w$!3K;I$G=MF-"F97$$!3J+++v!>.m)FB$!31*e\<E3)G5F97$$!3L******\A93')FB$!3tk3]D+1K5F97$$!3X*****\Ulfb)FB$!3vzs!)G@gK5F97$Fgcp$!3Wx>'H@h0."F97$$!3%)******\\V*R)FB$!3!4]vCp*H>5F97$Fdw$!3-1P<Jp@&***FB7$Fiw$!3i&og)f&ovy)FB7$F^x$!3Nw!y=%)e?N(FB7$Fddn$!3$G,#)fIo3k'FB7$Fidn$!3Qrg3lc-MhFB7$F^en$!3uWw[*ouq'fFB7$Fcen$!3"3tw:mBr&eFB7$Fhen$!3`V%eaA@.!eFB7$Fcx$!3E<!p3?20z&FB7$Fhx$!3@mUfJj&*))fFB7$F]y$!31AUf^N>RiFB7$$!3KM$3FWA3w&FB$!3<IL*ei$>oiFB7$Fby$!3Rr%>FUh_E'FB7$$!38o;z%RW(QbFB$!3'zmG%G[PEiFB7$Fgy$!3"[,:bI>%\hFB7$Faz$!3g[Zy")*GC)eFB7$F[[l$!3'H*e([Q=U[&FB7$F_\l$!3[v+*z))Q%*f%FB7$Fi\l$!37AVDd#[!fPFB7$Fahp$!36d^*))R4eT$FB7$F^]l$!3baWk+?B&=$FB7$Fihp$!3aXg)z/aA6$FB7$F^ip$!3!)\&)3F1)[1$FB7$Fcip$!3nT`%*zOpRIFB7$Fc]l$!3C[)Gur4B.$FB7$$!3G****\7\;HJFB$!3oB*G:U@'[IFB7$Fh]l$!3.o;_2)f82$FB7$$!3y***\(oL5@GFB$!3t3G;$)GzsIFB7$$!3e****\(=;%=FFB$!3eWr=A*H;1$FB7$$!3Q***\i+Hdh#FB$!33#[!)ea,T.$FB7$F]^l$!3cDS8k3>()HFB7$Fb^l$!3f(f_'yNN^DFB7$Fg^l$!3y=lR+pC&y"FB7$F\_l$!3h2/,%=iL+"FB7$Fa_l$!3Y[>:pa\&)QF<7$Fi_s$!3mh(>gMy6z"F<7$Ff_l$!3'4Ti'HQ4?eF]`l7$$!3POL3-`F"Q$F<$!31'>v')>n'4EF]`l7$Fa`s$!3)3c?pY9N`)Fcv7$$!3[.+Dccre7F<$!3'*ey9NDPt8Fcv7$F[`l$!3(zfC&R:p;`Fh`s7$$"3N$fmTNc$\!*F]`l$"3'QG7^])H6^Fhiv7$Fj`s$"3Ed_Lm#)RUbFcv7$$"31_m"Hdy'4JF<$"3A&HSsJOs.#F]`l7$Fa`l$"3Dbu>Y=Y!)\F]`l7$Fbas$"3&3a0wnl!z;F<7$Ff`l$"3**=t#3xBj!QF<7$F[al$"3E<$*)[Du5t*F<7$F`al$"3S_-WaC(Gt"FB7$Feal$"3)=*)pN)e;"\#FB7$Fjal$"3qw(f(\,%R&HFB7$$"3IJL3_*\gc#FB$"322"*=t4)R,$FB7$$"31)***\(e@Jn#FB$"393Ym6@q^IFB7$$"3"[m;HA$>!y#FB$"3K)42m)33qIFB7$F_bl$"3(zR4&[#\I2$FB7$$"33lm;H"395$FB$"3d!e)>![6A0$FB7$Fdbl$"30s5'e*oZKIFB7$Fi]q$"3=]u(p)4*o.$FB7$F^^q$"3N#3SJ0lr0$FB7$Fc^q$"3OErC.f[(4$FB7$Fibl$"3#*pj(oiB7;$FB7$F[_q$"3@q-t5)*QnLFB7$F^cl$"3X9H@1P,"o$FB7$Fhcl$"3!=Ia*oeMEXFB7$F\el$"3-"o_RF()[W&FB7$Ffel$"3(zrLrOrt&eFB7$F`fl$"3cDYvn[nPhFB7$$"3g'*\ils*p_&FB$"3c2@PEK0?iFB7$Fefl$"3()[N*4YBKE'FB7$$"3]'*\(=_g?v&FB$"3D7!H!Rp=piFB7$Fjfl$"3/)ejH1j>C'FB7$F_gl$"3."*z3F,ExfFB7$Fdgl$"3m.I.b,.*y&FB7$Fi^o$"3Z]&\Cv()="eFB7$F^_o$"3J42(Q\g(zeFB7$Fc_o$"3]*ykNkYv*fFB7$Fh_o$"3&)*f&o]!>"ohFB7$F]`o$"3(oisx$y`nmFB7$Figl$"3n%yU#43&GN(FB7$F^hl$"33e[IG_zM))FB7$Fchl$"3<P!ek$="\+"F97$Fg\v$"3m6_>(oGJ-"F97$Fecq$"3_#3>HyS?."F97$$"3IJ3_vv@(e)FB$"3WNBQjgfK5F97$Fd]v$"3C-V[<nNI5F97$$"3A*\i!*oqTp)FB$"3gF?vsa>D5F97$Fhhl$"3:277X7+<5F97$F]dq$"3,P:e\++B&*FB7$F]il$"3b:UrzXb]$)FB7$Fedq$"3XMe"3%y@)y'FB7$Fbil$"3%)yc"**o<R%[FB7$$"3,J$eRUK'y'*FB$"3J"\h()e/$ePFB7$F]eq$"3o)))39y"z;EFB7$$"3Ni;a8:!*z)*FB$"3[elzc]+O9FB7$Fgil$"3OT^WaAXNBF<7$F^_v$!3oZY?[L&o-"FB7$Fgao$!3Rc!Q))H-.F#FB7$Ff_v$!3GM,*fv`kZ$FB7$F\jl$!3;#)y%)[A(fi%FB7$$"3&)***\Pl\10"F9$!3Nl>$*HN0,dFB7$F_bo$!3(****y.O%*eo'FB7$$"3Xmm"H2)or5F9$!3??"=rS)4nvFB7$Fajl$!3UQEl6c+M$)FB7$Fafq$!3DNaa?S#pZ*FB7$Ffjl$!3Iw#4OFhL,"F97$$"3')\(ozI([G6F9$!3,t/C<8NA5F97$$"3CL3-L&HO8"F9$!37v(R#*)3]G5F97$$"3k;H2e<xQ6F9$!31r^TZD!>."F97$Fifq$!3)>Byi7jE."F97$$"3)H3x"3i0\6F9$!3">*Q%)RF!4."F97$$"3Pm"HKV)>a6F9$!3S7]2(p`n-"F97$$"3x\7Ge1Mf6F9$!37>SOR$f.-"F97$F[[m$!3'=v<+"G(=,"F97$F`[m$!3<D`&oA:'>))FB7$Fe[m$!39sC+w;#G?(FB7$Fcco$!3wJ%Q!y$)>tlFB7$Fj[m$!3LQ)HaZ*e@hFB7$F[do$!3,j2A6!\#pfFB7$F`do$!38ml:&zV_'eFB7$Fedo$!3\%evifvm!eFB7$F_\m$!3V)o.'**H'*)y&FB7$Fd\m$!3-aUH!o,%**fFB7$Fi\m$!3smB+l\[diFB7$$"3%)*\(oz%H*G9F9$!3p21:$=36F'FB7$F^]m$!3RPi4ZmBaiFB7$$"3im"Hd.j*\9F9$!3m:\ACO8/iFB7$Fc]m$!3>#zZUq9'>hFB7$F]^m$!3@&)>/P0C]eFB7$Fg^m$!397g/DY$eY&FB7$F[`m$!3#Q")3FK1Qf%FB7$Fe`m$!3)*4g^$)[smPFB7$Fc[r$!3qME3,af8MFB7$Fj`m$!3A$\*QoSFzJFB7$F[\r$!3kBGJa_g1JFB7$F`\r$!3\S:Z.GkgIFB7$Fe\r$!3w&RY`-fv.$FB7$F_am$!3Gg+HH0[KIFB7$$"3fmm"z%pF)o"F9$!3DLDU_l:]IFB7$Fdam$!3sD%)Q,%R;2$FB7$$"3cm;HFg*zr"F9$!3RC59(*)[F2$FB7$$"3@LL3(Q-zs"F9$!3J6Nt%*G4iIFB7$$"3')**\(ou3yt"F9$!3a^l[/:GOIFB7$Fiam$!3#*\AISSd#*HFB7$F^bm$!3pt@&["*)QuDFB7$Fcbm$!3!HE"4q.>H=FB7$Fhbm$!3Sw]+na@C5FB7$F]cm$!3YuKE$e"p*)QF<7$Fh`t$!3jlr(Rqs`v"F<7$Fbcm$!3uxo07GkcaF]`l7$$"3.+D"G:3u'>F9$!3o45f$*e!4M#F]`l7$F`at$!3aMp&=x>%>qFcv7$$"3,+v$40O"*)>F9$!3/?0:\]QP))Fhiv7$Fgcm$!35"*Gk(["z$Q%FbivF[dmFcdmF]jmFajm7*Figm-F,6$7]yFbio7$F7$"3cN-4DE6%*zF<7$F>$"3%e*y4]NpZ7FB7$$!3&)*\(o*eGL!>F9$"3B*yWPV)*))G"FB7$Febt$"3fXrBMDt88FB7$$!3JLeR-IO%)=F9$"3[K7%*R.fD8FB7$FD$"3S&fj;\@&G8FB7$Fbct$"3)R[OD["*eK"FB7$FI$"3Cr3A!*[ZV8FB7$$!3w*\P4k%GE=F9$"3K2,K_'>aP"FB7$F_jo$"3s,ERU*3'H9FB7$$!3im"zW&e&\!=F9$"3^f%Qw`b&4:FB7$FN$"3s$4h.:/sh"FB7$Fgjo$"3FWUtfG$[">FB7$FS$"3X9%4ub3TI#FB7$FX$"3CH73j]`$=$FB7$Fgn$"3qEre^D%*GQFB7$Fe[p$"3edXm>Me<RFB7$Fj[p$"3![U"*z8=e(RFB7$F_\p$"3_4WsQn41SFB7$F\o$"3-aWo=Gn7SFB7$Fg\p$"3$>&y*p#3IzRFB7$Fao$"3o`V*e>%)[$RFB7$$!36++DJ_Pq:F9$"3Ac&ygF?)GRFB7$Ffo$"3i&z6qe30%RFB7$$!3#om;aCk0b"F9$"3xZ8mv<=vRFB7$F[p$"3ui)*pV.(p.%FB7$Fep$"3c"eK([@[^UFB7$F_q$"3%z%Qbw[J(e%FB7$Fcr$"3Q/:&4`[Ua&FB7$F]s$"33aE\K1F\kFB7$Ffgt$"32!yN5cl1h'FB7$Fh]n$"3IHDn&z"fHnFB7$F^ht$"34_t17>E.oFB7$Fbs$"3bSJlc"\:$oFB7$F`^n$"3g1R&4&)>r"oFB7$Fe^n$"3t<*f(e'4aw'FB7$Fj^n$"3ArIX6(QWo'FB7$Fgs$"3cXDUC#pWe'FB7$Fg_n$"3k6ZU=<MxjFB7$F\t$"3:-BvLJ6[iFB7$Fg^p$"3I[pz&QdXC'FB7$Fd`n$"3;6,m\$feH'FB7$F__p$"39kpb\id4kFB7$Fat$"39$fs'fY1!f'FB7$Fft$"3%f)of3"[@)zFB7$F[u$"3#yT3'e#*)>x*FB7$Fffr$"31,qulYnJ5F97$F`u$"3m(ogEnL80"F97$F^gr$"3Euj"Q%zaC5F97$Feu$"3Q4!RTNt!Q%*FB7$Fddw$"36z>*3hRgt)FB7$Fhan$"3O]R=KL;gyFB7$F\ew$"3UO^<$G-9#oFB7$Fju$"3WJ-**fDkOcFB7$Fdjt$"3w$Q#)4')p"GVFB7$F`bn$"3m&pRj0,H#HFB7$F\[u$"3s2?M4)39X"FB7$F_v$!3U[@3,Zz@`F]`l7$Fd[u$!3s4Auy*\Fc"FB7$Fhbn$!3!*G7]goKOIFB7$F\\u$!3GArK$>.1W%FB7$Fev$!3mq*yCL()[u&FB7$F\gw$!3k1c**4FHApFB7$F`cn$!3R'>."opr]zFB7$Fdgw$!3!o_w:m0O"))FB7$Fjv$!3*p@L?$yY+&*FB7$$!3_+++]obD!*FB$!35:qU'Hr=***FB7$F_cp$!32%4m5^m<."F97$$!3!4++]PE!p))FB$!3%=NdN4W?/"F97$$!3.,++]&\o"))FB$!3?A8-30[[5F97$$!30+++DFnk()FB$!3Pwi>&=O70"F97$F_w$!3AH:M%G(\]5F97$Fgcp$!3#HQ?-0$3<5F97$Fdw$!3*>_'R7,#fZ*FB7$Fiw$!3XC)zelEd)yFB7$F^x$!3\$H'*>vl)emFB7$Fiep$!3%QCYNCunW'FB7$Fddn$!3A3>#fr`5J'FB7$Fafp$!3!\k9<<BtC'FB7$Fidn$!3n1l-R\&pC'FB7$Fcen$!3$fUZj">i&Q'FB7$Fcx$!39FlTp&)R2mFB7$F`fn$!3y'zA]V!G&p'FB7$Fefn$!3;-18J;omnFB7$Fjfn$!3GU`#f8<U"oFB7$Fhx$!3P6W3n0)>$oFB7$Fb^u$!3;'H\[O\d"oFB7$Fbgn$!3&y6A!ek5jnFB7$Fj^u$!3opdbFhZtmFB7$F]y$!3FGDXGb2[lFB7$Fgy$!3$R@6+m`Mh&FB7$F[[l$!3XhetSmNvXFB7$Fe[l$!30"QDm]d^C%FB7$F_\l$!35Ea?0xlMSFB7$$!3Ao;z>v5#\%FB$!3Ax9hzk5uRFB7$Fd\l$!3o*4+,%e<SRFB7$$!35N$3x"3`&H%FB$!3wM/kjs!)GRFB7$Fi\l$!3iK!*Q%ox[$RFB7$Fahp$!3P(fN19`(zRFB7$F^]l$!3I2i&Hn(y7SFB7$Fihp$!3rtj->!f_+%FB7$F^ip$!3OV[+&*zMtRFB7$Fcip$!36c[z=5x7RFB7$Fc]l$!3%Q2RdfD6#QFB7$Fh]l$!3Op![JZyT?$FB7$F]^l$!3NoWg]O"GO#FB7$Fajp$!3'3xyE4Z?'>FB7$Fb^l$!3Y\L2JPQ\;FB7$$!3Em;z>`Kx>FB$!3w+Y<&zTS`"FB7$Fijp$!3+05e%4()oW"FB7$$!3'GL3xrQIw"FB$!3fwt,;-P'Q"FB7$Fg^l$!3tS#RPm+$\8FB7$F\_l$!3wt!)>fb[G8FB7$Fa_l$!3=3'H^;GgC"FB7$Ff_l$!3s>%G)oWj>")F<7$F[`l$!3poBb$z2![RF]`l7$Fa`l$"3zF*zgEZ"oxF<7$Ff`l$"3K)=dp&zUU7FB7$$"32-L$3_`6e*F<$"33d8O:>)eG"FB7$F_eu$"3G4pc\pH78FB7$$"3&Qm;H()Q+:"FB$"3mx$4&[X7D8FB7$F[al$"3A#e;@z<&G8FB7$F\fu$"3MF)*p<Y(eK"FB7$F`al$"3]]&e%QlLV8FB7$$"3EJ$3_+*[L<FB$"3.;>d#=xRP"FB7$Fc\q$"3`VHat_\D9FB7$$"3#z*\il;xS>FB$"3f!*H7o;=,:FB7$Feal$"3it8zH"QHg"FB7$F[]q$"3bJkML=m%)=FB7$Fjal$"3<;.'>EPbD#FB7$F_bl$"30'=GC?\K8$FB7$Fdbl$"3MTzY%35<!QFB7$Fi]q$"3-GN"*e5e'*QFB7$F^^q$"3nJ.z$\&*='RFB7$Fc^q$"3#=H#4j2Y**RFB7$Fibl$"3sX#33`#z7SFB7$F[_q$"3[#\+7*QA))RFB7$F^cl$"3Yp4JBOlTRFB7$$"3(f*\P43*[D%FB$"3;Oc(>^D&HRFB7$Fccl$"3`')ezjLULRFB7$$"3B'*\7G.fdWFB$"3jTk:J1MfRFB7$Fhcl$"3<%*[d+k=7SFB7$Fbdl$"3')Q')e-&Q6@%FB7$F\el$"3([7zKjD#QXFB7$F`fl$"3^=")HZna!e&FB7$Fjfl$"3-io0H<8PlFB7$F`ju$"3l2\vr+lrmFB7$F_]o$"3%esa"z34mnFB7$Fhju$"3yW6A:i.>oFB7$F_gl$"3#eVN?,G8$oFB7$Fg]o$"3yRdREY71oFB7$F\^o$"3y9Vaez$)[nFB7$Fa^o$"3kEBD#o\pm'FB7$Fdgl$"3#GWu'y5rplFB7$F^_o$"3_WS@ynxgjFB7$Fh_o$"33fjB6t.ViFB7$F[aq$"3G(z\//9<D'FB7$F]`o$"3aw-f!3"y>jFB7$Fcaq$"3cFK/*pmWX'FB7$Figl$"3"3Dp[Qm$fmFB7$F^hl$"3"=vs)o'=l$zFB7$Fchl$"3k+TmlN@r&*FB7$Fecq$"3-std)*=^C5F97$Fhhl$"3At5fa%p80"F97$F]dq$"3#y@dz]*4@5F97$F]il$"3=gZ&>]4MB*FB7$$"35m;zWU4w#*FB$"3?.z7/6BJ&)FB7$Fedq$"3iS<"fr=&zwFB7$$"3X(*\PMLOx%*FB$"3!=ea`ag#)o'FB7$Fbil$"3Xgx><X)=d&FB7$F^]y$"3+)46ixc)[VFB7$F]eq$"3s!eG[&Q7TIFB7$Ff]y$"3pIW\"H>Mn"FB7$Fgil$"3cG.7IAhCFF<7$F^_v$!3;woy2eH(>"FB7$Fgao$!3K8R\sG-TEFB7$Ff_v$!3M35RfAqFSFB7$F\jl$!3WH5#*\3QG`FB7$Fj^y$!3">wRPK,s^'FB7$F_bo$!3Cw#\C(4IsvFB7$Fb_y$!3x7?w:/aw%)FB7$Fajl$!3//]e"QK!=#*FB7$Fafq$!3YaM*\Nqy,"F97$Ffjl$!3z!R8l%))>^5F97$Fifq$!3qM:-O'\0."F97$F[[m$!3y$GN"fOL-(*FB7$F`[m$!3^Mx,.l6?zFB7$Fe[m$!3'\L#)\'[`olFB7$F[iq$!3![=l)=9m(R'FB7$Fcco$!3EVnx8l!3H'FB7$Fciq$!3+AN_?,iViFB7$Fj[m$!3X%f>Z,B)[iFB7$F`do$!3t@KO&*=4wjFB7$F_\m$!3V4zV:5**ylFB7$F]eo$!3%3k3;a0'zmFB7$Fbeo$!3"e*Gle"==w'FB7$Fgeo$!3$>`n;"*p_"oFB7$Fd\m$!3;m#RNd>=$oFB7$Fbbv$!3c@n%)pN*e!oFB7$F_fo$!3"[K/@2zYt'FB7$Fjbv$!3VEqGth:=mFB7$Fi\m$!3^(QWJpt*ekFB7$Fc]m$!3WB;liMaKbFB7$Fg^m$!3SSQ<jR!yb%FB7$Fa_m$!3f^'eb(4IPUFB7$F[`m$!3#o`hO*Q#G.%FB7$$"3"**\(ofg'3b"F9$!3>IX..EutRFB7$F``m$!3;&\az/t.%RFB7$$"3cm"HKr$>q:F9$!3I"4)G.u&)GRFB7$Fe`m$!3\[v,L0MMRFB7$Fc[r$!3W"=r88Q,)RFB7$Fj`m$!3Y[bf0w$H,%FB7$F[\r$!3!>Vqd[@L+%FB7$F`\r$!3<K;Bn^ZnRFB7$Fe\r$!3_")>ylP(4!RFB7$F_am$!3cZw$y*p],QFB7$Fdam$!3?V,=Ms<&>$FB7$Fiam$!3.v_h"H-EQ#FB7$F^bm$!3Dv^p"*4!*o;FB7$Fcbm$!3qzA)GU)>b8FB7$Fhbm$!3ynW?3eRG8FB7$F]cm$!3=FUNx_@Y7FB7$Fbcm$!39WR5%ygI(zF<Fh^rF[dmFcdmFfimFjhm-Fjgm6%FbimQHThe~7~term~Fourier~approximation~(blue)F(FdhmF]jmFajm7*FigmFfimFjhm-Fjgm6%FbimQHThe~8~term~Fourier~approximation~(blue)F(Fdhm-F,6$7_yFb_r7$Fdiv$"3)y$Go&=-o_"Fcv7$Fg_r$"3J.=V`tF17F]`l7$F]jv$"3esG&='>@()RF]`l7$F7$"3;@*pKX()*y"*F]`l7$F_`r$"3_^#ecxC!\GF<7$F>$"3D)3/&G]d-gF<7$FD$"37BU/8t"4L"FB7$FI$"3_:Bd@_o$*>FB7$F\]z$"3_o9!3"Q"R7#FB7$F_jo$"3GqA`,!QHA#FB7$Fd]z$"3K^z3t*o5H#FB7$FN$"3#RZ?]<&4JBFB7$Fgjo$"37E)RhD9!\BFB7$FS$"3a#\$)49xnL#FB7$Fg[w$"3/RR:MR%=M#FB7$F\\w$"3x_C'>r/gO#FB7$Fa\w$"3w<d3/PO;CFB7$FX$"3we')4PV+)\#FB7$Fi\w$"33#pj=e-Hw#FB7$Fgn$"3f7uw9n4\JFB7$F\o$"3=/"pn(pJ_SFB7$Fao$"3Fze;aU^_YFB7$Fj_z$"3%\S-%o'e!4ZFB7$Ffo$"3/iN2lvCNZFB7$Fb`z$"39F7d<&>at%FB7$F[p$"3@=RO'HKer%FB7$Fep$"36%*\%HZ>'\YFB7$F_q$"3">t1o9[!3YFB7$Fdq$"39b!eB3z&>YFB7$Fiq$"3qV6m$GmUm%FB7$F^r$"39d%yp2@wu%FB7$Fcr$"3_)R#RAlYs[FB7$Fhr$"3/#GO@'*zGC&FB7$F]s$"3'yu+pO:"QdFB7$Fbs$"344yG()*f/!oFB7$Fgs$"3bd^iJKdlsFB7$F\t$"3"\a$[;E#*QpFB7$Fat$"30m)yi,S3e'FB7$Fft$"3Dp"fJck6F(FB7$F[u$"3#)RWbn-$y7*FB7$Fffr$"3S!>tQ!yAi**FB7$F`u$"3MQB"\<3H0"F97$$!3emT5:HU>6F9$"3o&4a"z^[g5F97$$!3?L$3F8LY6"F9$"309lNn2$[1"F97$$!3.+DJ]L%)46F9$"3$H:Dezzc1"F97$F^gr$"3dOxak2zi5F97$$!33+]7.SZ&4"F9$"3)[`DpZp\/"F97$Feu$"3U(fHOR@+,"F97$Fddw$"3Sl0szG=#\*FB7$Fhan$"3X^ao'Q+^l)FB7$F\ew$"3g6FDS<4(f(FB7$Fju$"39=#ppP[kL'FB7$Fdjt$"3Ml>()[l*4!\FB7$F`bn$"3VV.;cV#pK$FB7$F\[u$"3hxfiS%Hrl"FB7$F_v$!3ZN"))e8V?3'F]`l7$Fd[u$!3/HL5\8(Ry"FB7$Fhbn$!32%HHd!G)[X$FB7$F\\u$!3lPuR?MoD]FB7$Fev$!3g]%e3aBMX'FB7$F\gw$!3rMVO*))G@q(FB7$F`cn$!3%f$)e3l[Wu)FB7$Fdgw$!3%pQo">b!Gc*FB7$Fjv$!31aV]c')*\,"F97$Fbhz$!3#Qp09[(**\5F97$F_cp$!3br3()G.'\1"F97$Fjhz$!3e(y")\!f\l5F97$F_iz$!31NJE1wyh5F97$Fdiz$!3'4gN^1qT0"F97$F_w$!3_udNmv+V5F97$Fgcp$!3uiV+bqB4(*FB7$Fdw$!3;YV7&=[<v)FB7$Fiw$!3=aREMU?(>(FB7$F^x$!3X`,=O$>]e'FB7$Fidn$!3%[08-c%=LpFB7$Fcx$!3d:R[t-LjsFB7$Fhx$!3mkIs%He$RoFB7$F]y$!3'RF8&f2h+fFB7$Fby$!3dE)pM\dCM&FB7$Fgy$!3-Fc"eX?N"\FB7$F\z$!3+kJhWy%zw%FB7$Faz$!3yYme)[">rYFB7$Ffz$!3qa"[([r@?YFB7$F[[l$!3iW@y<([#3YFB7$Fe[l$!3;0tb&RZ6l%FB7$F_\l$!3Oi39&4[mr%FB7$F^^[l$!3DdLm@=mNZFB7$Fd\l$!3%>xBvhg]t%FB7$Ff^[l$!3%[jvVYi(3ZFB7$Fi\l$!3(G6C-q]Dl%FB7$F^]l$!3)=opj'4cWSFB7$Fc]l$!3mJ'R;etJ8$FB7$Fh^x$!3;volW@1lFFB7$Fh]l$!3c@x%zI/!3DFB7$F`_x$!3ha,RFr0ECFB7$Fe_x$!39Et3m'QKP#FB7$Fj_x$!3gf-"R,HaM#FB7$F]^l$!3#*)>j4nMnL#FB7$Fajp$!3]jA$*=UfZBFB7$Fb^l$!3)pDu!fnSPBFB7$F\a[l$!3)*zUfhgk.BFB7$Fijp$!3)Qbj-Z.EC#FB7$Fda[l$!3J*eo[aZ3:#FB7$Fg^l$!3R+L(*R$Ru-#FB7$F\_l$!3eL]_pW9`8FB7$Fa_l$!3&peyEl`)\fF<7$Fi_s$!3/sUUBxjzGF<7$Ff_l$!3QMe^o&f"*o*F]`l7$Fdax$!3/[RPV4])R%F]`l7$Fa`s$!3'*zSj9#o7X"F]`l7$F\bx$!3#zXSbwN)[BFcv7$F[`l$!3kbnT(Q-Q6*Fh`s7$Fdbx$"3@tZpa#3;v)Fhiv7$Fj`s$"3_<K(R#=rW%*Fcv7$F\cx$"3g">W\7"pUMF]`l7$Fa`l$"3U15wE(>gJ)F]`l7$Fbas$"3Bq)[J6$>2FF<7$Ff`l$"3UOsdq(*oQeF<7$F[al$"3Kk:Z$>>0K"FB7$F`al$"37"e"HoEy#*>FB7$Fdd[l$"3!zf/(f4&*>@FB7$Fc\q$"3?Hpr$Row@#FB7$F\e[l$"3o"z7^"*3hG#FB7$Feal$"3uY/qTJmFBFB7$F_gu$"3TH.>z3yYBFB7$F[]q$"3fX&)f1'e'\BFB7$Fggu$"3OCmTtMzVBFB7$Fjal$"3a)Ra7ONuL#FB7$Ffdx$"3$R:=&RkDRBFB7$F[ex$"3z`!zJ%>?eBFB7$F`ex$"38=8l:(4<S#FB7$F_bl$"392b8ZQMvCFB7$Fhex$"3$Gdk$=#3Ks#FB7$Fdbl$"3I)R$zd5Y&4$FB7$Fibl$"31,$f4v#*=)RFB7$F^cl$"3t&[J)elJ<YFB7$Fbg[l$"3W#R]kn<$*o%FB7$Fccl$"3/q.0"y8$GZFB7$Fjg[l$"3)4_;9OL!QZFB7$Fhcl$"3MUylu2VCZFB7$Fbdl$"3dw4qDC&)fYFB7$F\el$"3ozkxO>X4YFB7$Fael$"3<A!RGf9fh%FB7$Ffel$"3Yw'=z$*45m%FB7$F[fl$"3:ke+5nK_ZFB7$F`fl$"3Kr.M!>(f$*[FB7$Fefl$"3#z=8N9Q">`FB7$Fjfl$"3z_WfLHK")eFB7$F_gl$"3$eVi!R^TpoFB7$Fdgl$"3bo6"G"GhlsFB7$Fh_o$"3(>z+%y@84pFB7$Figl$"3Z>u7S<2&e'FB7$F^hl$"3;6uR9N"eB(FB7$Fchl$"3B()z4[I&*o))FB7$Fecq$"3.`(H^%QeL)*FB7$Fhhl$"3]l)*\1*)*30"F97$$"3%\;/E!Q7,))FB$"3S\m\xr))f5F97$$"3*))*\Pf.ga))FB$"3[(f8-X")[1"F97$$"3'G$e9;p23*)FB$"38%y1')o6b1"F97$F]dq$"3^G39zYWh5F97$$"3_K$eke1&o!*FB$"3m]#)Q.C5Q5F97$F]il$"3cT9tfY>J**FB7$Fj\\l$"3F0uLLka-$*FB7$Fedq$"3.Fp#*>fGv%)FB7$Fb]\l$"3_;X`qa%yX(FB7$Fbil$"3z()pSr*=jE'FB7$F^]y$"3gnMGVV&R#\FB7$F]eq$"3>s?rZ9HgMFB7$Ff]y$"3SC[wYb)*4>FB7$Fgil$"3!4`^^#et8JF<7$F^_v$!3JijwD'GuO"FB7$Fgao$!3go@#3ay$3IFB7$Ff_v$!32SpnpOvmXFB7$F\jl$!3C&p64'*p;+'FB7$Fj^y$!3***[Zg2UzF(FB7$F_bo$!3r)[ihRIwO)FB7$Fb_y$!3U`$R`,#>^#*FB7$Fajl$!3Pwi))Ql<=**FB7$$"3amTgK<\#4"F9$!3_O@Z!Huf."F97$Fafq$!3_Z>_&pU+1"F97$$"3G;/w2%=z5"F9$!3ct=.%p!)\1"F97$$"3n*\7GjgI6"F9$!3bO.DSt]l5F97$$"32$eky&G?=6F9$!3^+c)yr4>1"F97$Ffjl$!3YPwXEx]a5F97$Fifq$!3sMjDvIIT**FB7$F[[m$!3*y>W?8Pg.*FB7$F`[m$!3].n3o%fKA(FB7$Fe[m$!3i,xZ=1*3e'FB7$Fj[m$!3'yUG:4YA%pFB7$F_\m$!3FYFu+GrlsFB7$Fd\m$!3GSK8gZ$>"oFB7$Fi\m$!3)[xz[F@Iv&FB7$F^]m$!3UO$z(\W)RC&FB7$Fc]m$!3<hDi<$Re'[FB7$Fh]m$!3V/%[ziQ.u%FB7$F]^m$!3,M:-TsLeYFB7$Fb^m$!3x;7P.d`;YFB7$Fg^m$!3@`ot+xq3YFB7$Fa_m$!3ha[O\\3`YFB7$F[`m$!3+cCLLQH<ZFB7$Ffd\l$!3GTz@v@uNZFB7$F``m$!3UEfqtC<NZFB7$F^e\l$!37.i'[`,)4ZFB7$Fe`m$!3esezNvebYFB7$Fj`m$!3S-*y#y'=(HSFB7$F_am$!3QtsK_&z]4$FB7$F`gy$!3S3d%))Q2ou#FB7$Fdam$!3D!4`YR#f.DFB7$Fhgy$!3*pHD'GhODCFB7$F]hy$!3N\K+t.BuBFB7$Fbhy$!3+u#*G4k\YBFB7$Fiam$!3?$*>9P&HpL#FB7$Fc]r$!3eR%40a:oM#FB7$F^bm$!3sb6](p5/M#FB7$$"31+DJNj_+=F9$!3g#ec9ak3J#FB7$F[^r$!3ZU?-FtbbAFB7$$"3ML3xE3l@=F9$!3jWDk[V"3<#FB7$Fcbm$!38_%QP`(Gb?FB7$Fhbm$!3h[&\Or``P"FB7$F]cm$!3'f@Nj6Nd&fF<7$Fh`t$!3DO"[XbgY#GF<7$Fbcm$!3I3t,q(Gc4*F]`l7$F\jy$!3Nv"RIhn-&RF]`l7$F`at$!3[1aGl?%\>"F]`l7$Fdjy$!3QJ]y.]L7:FcvFdatF[dmFcdmF]jmFajm7*FigmFfimFjhm-Fjgm6%FbimQHThe~9~term~Fourier~approximation~(blue)F(Fdhm-F,6$7[\l7$F0$"3'*[x+L(o#f:F57$Fg_r$"3[G!Gw!=G4UF<7$F7$"3Ye*>g$yw!f(F<7$$!3OLLe9r]X>F9$"3uUD6#\.pz)F<7$F_`r$"35EK+Sgz]'*F<7$$!3vmmTg*4P#>F9$"3]$47vf-w,"FB7$F>$"3%e[iua]I/"FB7$Febt$"3[,3GDic\5FB7$FD$"3k&[i6E7!e5FB7$F]ct$"35WxBa=>"3"FB7$Fbct$"3$[!f!*es6D6FB7$Fgct$"3Qtv4+#zR>"FB7$FI$"3'\v0r3B+H"FB7$FN$"31&G^Qw"p7?FB7$FS$"3v-D7%y?L"GFB7$Fg[w$"3S25)[%[%G&HFB7$F\\w$"3$G")pG#HgbIFB7$Fa\w$"3hj)H8f8:7$FB7$FX$"3&3Zc\[QU:$FB7$Fi\w$"3AZVKMiF^JFB7$Fgn$"3Kd*e!z(H38$FB7$Fe[p$"3g5vI**\,WJFB7$Fj[p$"3RWK&)z-a'=$FB7$F_\p$"3-L;&\q]bE$FB7$F\o$"38Pu!GNjYQ$FB7$Fg\p$"3bu30U>yPPFB7$Fao$"3%\S#fHsJ(>%FB7$Ffo$"35t)\[%)zsj%FB7$F[p$"3C@C#H%o.0]FB7$F`p$"3LH3Qb0mS^FB7$Fep$"3=/fg)[.wB&FB7$Fjp$"3-jVp.[#\H&FB7$F_q$"3/atGY&*4:`FB7$Fiq$"3MJE"Q>_qE&FB7$Fcr$"3)**z3(*>MQ<&FB7$F\_w$"3:w\+!QGW9&FB7$Fhr$"3:WFW-8EW^FB7$Fd_w$"3\@"G-r!>%=&FB7$F]s$"3o$*=c-bwr_FB7$Fbs$"3YFH_8QoNhFB7$Fgs$"39?>)fSK(\sFB7$Fb_n$"35?INW3FOuFB7$Fg_n$"3LX`;ep/evFB7$F\`n$"3PO)RS;n$4wFB7$F\t$"3e'[@GRg6f(FB7$Fd`n$"3jV9(>oiVQ(FB7$Fat$"3RK#3]W]W2(FB7$Fg_p$"3#=_P4:t%RpFB7$F\`p$"30l"p-X3!foFB7$$!3a$eR(>)[BA"F9$"3_dG;3`XZoFB7$Fa`p$"3nn^Y')zxeoFB7$$!3#oTNY%GZ67F9$"3_t$\j$oC&*oFB7$Fft$"3N&=![=CgepFB7$Fi`p$"3aoi62_s$\(FB7$F[u$"3AE)>k_0`U)FB7$Fffr$"3E.yGNf$GS*FB7$F`u$"3%Q;86>+t-"F97$Fj`]l$"3FB8rg$)zd5F97$F^gr$"3&3;1iqY[2"F97$$!3EL3_&yj-5"F9$"3\'4n*4^Ix5F97$Fga]l$"32?HQ-ZBv5F97$$!3qm"H2A%o!4"F9$"3@rt>+(>$o5F97$Feu$"3yax6+"*Gc5F97$Fddw$"32*\Ex([T45F97$Fhan$"3ndd_(4>3M*FB7$F\ew$"3Hh&**))R+LI)FB7$Fju$"3%z?[9w$*z*pFB7$Fdjt$"3)Q>(Rqf%oX&FB7$F`bn$"3<Vmo(R'zDPFB7$F\[u$"3jh$4]1DA'=FB7$F_v$!3$4H2()\)GUoF]`l7$Fd[u$!3vel#G>7W+#FB7$Fhbn$!3o"=(G:'ew'QFB7$F\\u$!3!o(z>.:S#f&FB7$Fev$!3WWK()yGP@rFB7$F\gw$!3#>O_Q%G=4%)FB7$F`cn$!3wt'GMUV[U*FB7$Fdgw$!3:F7(3pD`,"F97$Fjv$!3j%y$[4wbf5F97$F_w$!3()o"*HDM<45F97$Fdw$!3LB%yF+E&[!)FB7$F_dp$!3*)QrLljREtFB7$Fiw$!37()*3D/!pFpFB7$Fgdp$!3j\NFy/+boFB7$F\ep$!3J+Lo#H'HdoFB7$Faep$!39_]@g4I@pFB7$F^x$!3#>?1+om-.(FB7$Fddn$!3&\d%3#R$zetFB7$Fidn$!3&Gw$o4I!*)e(FB7$F^en$!3"p*=HJH**3wFB7$Fcen$!3@Y?4"*f4]vFB7$Fhen$!3")3/iY9a6uFB7$Fcx$!3r"G/%*=56?(FB7$Fhx$!3%ef!oygq)='FB7$F]y$!3Y2F<z0-\`FB7$Fj[x$!3)[DZ$*>uLA&FB7$Fby$!30?!HuLBi:&FB7$Fb\x$!3]_5"R.3/9&FB7$Fgy$!38em&4A)oj^FB7$Faz$!3y[$>;WDBE&FB7$F[[l$!3,E6P!)*Q[J&FB7$F`[l$!3qN">DaGGH&FB7$Fe[l$!3$=Lt'*QCSB&FB7$Fj[l$!35ZXZ#Guh8&FB7$F_\l$!3(\)RK#GO.+&FB7$Fd\l$!3s;#3\YbTj%FB7$Fi\l$!3ezigw(Hu>%FB7$Fahp$!3ib$[z=sRt$FB7$F^]l$!3`u8$*[6bzLFB7$Fihp$!3/)*3;h&H5E$FB7$F^ip$!3$H]*=NFF$=$FB7$Fcip$!3u9KXqQOUJFB7$Fc]l$!3%zzzHqh28$FB7$Fh^x$!3!*><Y5Y4^JFB7$Fh]l$!3n2zO93$f:$FB7$F`_x$!3Pg,?p;6GJFB7$Fe_x$!35!yd3.a12$FB7$Fj_x$!3fIS+Bj#)zHFB7$F]^l$!3v$R6!G,,bGFB7$Fb^l$!3"z%)3Ft7)o?FB7$Fg^l$!37]*>.07/K"FB7$Fibu$!3F-oYlZj87FB7$F^cu$!3D+B3&GSj8"FB7$Fccu$!3&HI=%zY^'3"FB7$F\_l$!3t&\?#R\$)f5FB7$F[du$!3d8oCD=^\5FB7$Fa_l$!39v(*o>`iU5FB7$$!3<-+v$f%REwF<$!37!4@z67v,"FB7$Fi_s$!3Mt.]`t'pm*F<7$$!3Fpm"z%\$Q]&F<$!3=*z-sHlz%))F<7$Ff_l$!3M"RRC.'4&p(F<7$Fa`s$!3&o_g?k[%fWF<7$F[`l$!3bKS"3[xv%RF]`l7$Fj`s$"3W][j^u(p*QF<7$Fa`l$"3#z*4%yz34S(F<7$$"3zWmT5:U9`F<$"3EBX(p/Iom)F<7$Fbas$"3D#*pj471s&*F<7$$"3_Pm"zWk">vF<$"3Q5_sPsl85FB7$Ff`l$"3^[4m(3s;/"FB7$F_eu$"3/Pa%[Tp'\5FB7$F[al$"3/GvS`IBd5FB7$Fgeu$"3%[0&p\%4)z5FB7$F\fu$"3a(p9J$QSB6FB7$Fafu$"3g#HZfVEC>"FB7$F`al$"3(y$*==)oD*G"FB7$Feal$"3EXS&)4q$o)>FB7$Fjal$"3A<b.`qOwFFB7$Ffdx$"3w(pH.4-O#HFB7$F[ex$"3()*)=F8R"[.$FB7$F`ex$"3B*yQ?_[!4JFB7$F_bl$"3')fcIF`2\JFB7$Fhex$"31@?)=cAX:$FB7$Fdbl$"3M(G'HV*458$FB7$Fi]q$"3K@^J0i!z8$FB7$F^^q$"3YddX&)HlqJFB7$Fc^q$"3i[l8wQ!oB$FB7$Fibl$"3eXEta%H3M$FB7$F[_q$"3V_ab")zLiOFB7$F^cl$"3=EJBmq#*)4%FB7$Fhcl$"3DmJ!)RKW\\FB7$F\el$"3Y(47Kk9KJ&FB7$Fael$"3$><%RTzi1`FB7$Ffel$"3BJ=kbpLp_FB7$F[fl$"3R3!)eT2?<_FB7$F`fl$"3HHY(*[?No^FB7$F^hx$"3)QBdz+u79&FB7$Fefl$"3CgPgb\w_^FB7$Ffhx$"3#p7')H(p+;_FB7$Fjfl$"3;3g^f.&*Q`FB7$F_gl$"3]:w7<dUJiFB7$Fdgl$"3:C!=Bp(HzsFB7$Fi^o$"3wl7"4%=VguFB7$F^_o$"3Z[j'o=!osvFB7$Fc_o$"3'=&p4"*496wFB7$Fh_o$"3%*zL^u4AyvFB7$F]`o$"3b'f!*o:=^M(FB7$Figl$"3_!4;U=p*HqFB7$F[bq$"3qKH(Q2?#=pFB7$F`bq$"3#HUI;zT]&oFB7$Febq$"3o\Q!zM!peoFB7$F^hl$"37ASvTxPVpFB7$F]cq$"3Q**GR\"))RQ(FB7$Fchl$"3U/LMrG6i")FB7$Fecq$"3/wS4/8yO#*FB7$Fhhl$"3.W8&3Y&RB5F97$Fhf^l$"3g9/)=[M!e5F97$F]dq$"3qA,#*ob(e2"F97$$"3c)\(oH+.:!*FB$"3%)GaL`i3x5F97$Feg^l$"3Tn!3#4:]s5F97$$"3[m"HK9$)>7*FB$"3S'>a-%yqh5F97$F]il$"3O"*QVw\OW5F97$Fj\\l$"3#)z@Us)o7$**FB7$Fedq$"3*zN4$Qerp"*FB7$Fb]\l$"3/R7#p-R@;)FB7$Fbil$"3%y)f;A"RQ#pFB7$F^]y$"37jP-8a#=[&FB7$F]eq$"3gHZhA7ltQFB7$Ff]y$"3Ex&o3&HfX@FB7$Fgil$"3%o'HD">=G]$F<7$F^_v$!3ElB<C4@P:FB7$Fgao$!3hdV(HoU>P$FB7$Ff_v$!33vEud[<#4&FB7$F\jl$!3rxXBF1"Gk'FB7$Fj^y$!3lTe@_K]yzFB7$F_bo$!3'Gw?6O&4m!*FB7$Fb_y$!3#QUnw6Gi))*FB7$Fajl$!3xJ2e&3-M/"F97$$"39$3_v]\t3"F9$!3O]*ew0*\g5F97$F][_l$!30.x<1m^r5F97$$"3#*\ildRj(4"F9$!3wKrht,vw5F97$Fafq$!3`_+5z'el2"F97$Fj[_l$!30e[+r-hh5F97$Ffjl$!3>&\d9"[_I5F97$Fifq$!3D2PJ#pS`P*FB7$F[[m$!3iv#>&y(H+L)FB7$Fagq$!3=UREUO&[V(FB7$F`[m$!3CN**\Uh;QpFB7$Figq$!3wbBz$e@N&oFB7$F^hq$!3k-Vki@&['oFB7$Fchq$!3e![TJ)*o?&pFB7$Fe[m$!3v](3QyE(*3(FB7$Fcco$!3W*pNJ_nMR(FB7$Fj[m$!3C-;SZgT#f(FB7$F[do$!3`LHHYVF4wFB7$F`do$!3'y%eVr6@fvFB7$Fedo$!3#[z_e!oKTuFB7$F_\m$!3*\W\@xf3E(FB7$Fd\m$!3=S$fGbs5:'FB7$Fi\m$!3(*e/<ov8y_FB7$$"3I$3x14rOU"F9$!3SBdo*R9bA&FB7$Fbdy$!3=u?$4s>h=&FB7$$"3O;zpoy=M9F9$!3"3'[Pj.Of^FB7$F^]m$!33?]$)>JNW^FB7$Fjdy$!3s<NDktxW^FB7$Fc]m$!3<%>#4X:nv^FB7$Fh]m$!3uh-m(\%)GA&FB7$F]^m$!3p/wmONCr_FB7$Fb^m$!3i+pRHu+1`FB7$Fg^m$!3?78`(oHUJ&FB7$F\_m$!3'=$f\$pV(*G&FB7$Fa_m$!3xv+W'[1%H_FB7$Ff_m$!3'y\x0p'GJ^FB7$F[`m$!3?C$4+-Xl*\FB7$F``m$!3WcMiEN,OYFB7$Fe`m$!3a=7q%H,p?%FB7$Fc[r$!3"f_d<2I2t$FB7$Fj`m$!3:0Q'3!)p*pLFB7$F[\r$!3tE"*HM"p<D$FB7$F`\r$!3!)['R3&fLwJFB7$Fe\r$!3OaP<<\'*QJFB7$F_am$!3/0ul4`,JJFB7$F`gy$!3b+h;_sh_JFB7$Fdam$!30/3w[IAbJFB7$Fhgy$!3&>GhmVxw7$FB7$F]hy$!3i#=S)eF[sIFB7$Fbhy$!3N)fwulmi)HFB7$Fiam$!32XkM\ENoGFB7$F^bm$!3;e\@0&y95#FB7$Fcbm$!3/RG!*RqG[8FB7$Fifv$!3y6b%)eb?K7FB7$F^gv$!3H6!34%pMZ6FB7$Fcgv$!3mXRt,C,#4"FB7$Fhbm$!3!)zp%Gv!)=1"FB7$F[hv$!3pj\&HPO%\5FB7$F]cm$!3UqcX(ftE/"FB7$$"33+DccB&R#>F9$!3%oT.z/cn,"FB7$Fh`t$!3#)yPP>AsP'*F<7$$"30+voa-oX>F9$!3R,'p][40y)F<7$Fbcm$!3+vl?T&*=tvF<7$F`at$!3qTswYv$o>%F<7$Fgcm$!3'*[x+L(o#f:F5F[dmFcdmF]jmFajm7*Figm-F,6$7_[l7$F0$!3h3ne]D()4[Fe_r7$F>$"3q%4&*eU[o$zF<7$FD$"3W&)RfJ8')4:FB7$FI$"33"H)yf#yQ(=FB7$F_jo$"33tnJ0AZ->FB7$FN$"3g'4Y"3?8**=FB7$Fedt$"3Cwn$f7C%=>FB7$Fgjo$"3-Yy+9-*p'>FB7$F]et$"3)f@ab]IB0#FB7$FS$"3c'H,W]Rv<#FB7$FX$"3Mzy[Y4_#)HFB7$Fgn$"3+D&**y!\1"p$FB7$Fe[p$"3lA<js!zDx$FB7$Fj[p$"3I+Lce6G8QFB7$F_\p$"3-qy>J(>0#QFB7$F\o$"3HvDd3@#f!QFB7$F\br$"3/4'G8riSy$FB7$Fg\p$"3vUvj]TuqPFB7$Fdbr$"3n(fj=S!4"y$FB7$Fao$"3qYlr@#yw#QFB7$F[p$"3MJN2!4McR%FB7$F_q$"3;4A#efnVH&FB7$Fdq$"3r1]OsQ'[[&FB7$Fiq$"3B&>J(zZsKcFB7$$!3pmmTq`Rv9F9$"3By7%4Vx$)o&FB7$F^r$"3P8Lh#Qv7t&FB7$$!3$****\i!)Q^Y"F9$"3+.ayxPVhdFB7$Fcr$"3nAGg10BzdFB7$F\_w$"3`&)>iM"H5y&FB7$Fhr$"36G`]v5aYdFB7$Fd_w$"37C]@Pn:!p&FB7$F]s$"344J-5'Q$HcFB7$Ffgt$"38f(=rCa;e&FB7$Fh]n$"3Z>:Bsm!*obFB7$$!3gmm;%)eY#R"F9$"3u2T!>_H4e&FB7$F^ht$"3"*[R!R*QU2cFB7$$!3`LL$3`e=Q"F9$"3-P]:*[b&\cFB7$Fbs$"3yr]68G/3dFB7$Fe^n$"3l%)*4]')RG5'FB7$Fgs$"3Gj$Q-&Rl!p'FB7$Fg_n$"3j[FD$\/cI(FB7$F\t$"3)yX5IfJFv(FB7$$!3LL$e9VXlG"F9$"3(R:zA-I$>yFB7$Fg^p$"34m"peC_['yFB7$$!3&pmTg4sfF"F9$"3b1%*ep#z())yFB7$Fd`n$"3CjjDBCA"*yFB7$$!37+]ig()Rl7F9$"3zU-y0B%H(yFB7$F__p$"3QFR+b*\`$yFB7$$!3HL$3_UD[D"F9$"3fW7')o'*[!y(FB7$Fat$"3CfU%GQ.5r(FB7$F\`p$"3iM4%3b.oM(FB7$Fft$"3z*)o-!zx&yqFB7$$!36]7`pof+7F9$"3#R#[c^`#>1(FB7$Ffer$"3v&\kg0ZM2(FB7$$!3R$3FW*3s*="F9$"3cR@@3D4;rFB7$Fi`p$"3E]tQ/;+#>(FB7$F^fr$"3gcCB**f]ZuFB7$F[u$"31Vc"*eFQPyFB7$F`u$"30mtaWW6M)*FB7$Feu$"3&[_$QKfe$3"F97$Fddw$"3&)o*4^puU0"F97$Fhan$"3))3rA?a/9**FB7$F\ew$"3#eI5R.%)f$*)FB7$Fju$"3a:6/%4/#=wFB7$Fdjt$"3M61h"\qS*fFB7$F`bn$"37F\*>Od*=TFB7$F\[u$"3%feDw\Bm1#FB7$F_v$!3(Q>Q"G/`-wF]`l7$Fd[u$!3A!pNPj#)RA#FB7$Fhbn$!3/.l^$RISF%FB7$F\\u$!3Se)GK<(**QhFB7$Fev$!3=P>-RGaXxFB7$F\gw$!3#=efn4'QR!*FB7$F`cn$!3uE')*)[u%)))**FB7$Fdgw$!3Dg)Q(z;ke5F97$Fjv$!3u)**\1SC[3"F97$F_w$!3!*o!*o!*3y"f*FB7$Fdw$!3miV!eKL$RvFB7$Fjir$!3!*e3N+FuwsFB7$F_dp$!3@sawXT8>rFB7$Fbjr$!3Mr)\&y5KiqFB7$Fiw$!3]'p>;>"p$4(FB7$F\ep$!3d%RPphG%RtFB7$F^x$!3.?W(G#ffiwFB7$Fiep$!3z&)pf-F)4"yFB7$Fddn$!3*[YpV'R8()yFB7$$!38+DJX,FbsFB$!3I5kkxMj"*yFB7$Fafp$!3!GX_CM5>(yFB7$$!3onT5SweUrFB$!3HU6>3QjFyFB7$Fidn$!37<]NTHHfxFB7$Fcen$!3b$\O,]K1G(FB7$Fcx$!3w!p\2f=8i'FB7$Fefn$!3S)p6UgM!)4'FB7$Fhx$!3]d:n]8OLdFB7$$!3MomT&[gf?'FB$!3_eO]XZcucFB7$Fb^u$!3c&HnM/f"HcFB7$$!3gnm"Hi.06'FB$!3M]o-Nqz'f&FB7$Fbgn$!3C_O@))\#od&FB7$Fj^u$!3hk20"HT+d&FB7$F]y$!3m)4JetJ%)f&FB7$Fj[x$!3;R))*))*)pzl&FB7$Fby$!35#=y$GAlBdFB7$Fb\x$!3!3gIFp<Bx&FB7$Fgy$!3\?orx)eRy&FB7$$!3@oT&)ee=s`FB$!3hw->]N6rdFB7$F\z$!3M#on)p48WdFB7$$!3cMe*[$o9h_FB$!3(eMM?8SBq&FB7$Faz$!3&[)H&oSnbk&FB7$Ffz$!3$zq$*[qI))[&FB7$F[[l$!3"H@2\<_>G&FB7$F_\l$!3#zg]jp:#*Q%FB7$Fi\l$!3uKLCJ)4x#QFB7$Fd]s$!3T'e(=/`&3y$FB7$Fahp$!3+V)z![#=3x$FB7$F\^s$!3AXj1BIi%y$FB7$F^]l$!3-IMA9Zo1QFB7$Fihp$!3ob5=[#p2#QFB7$F^ip$!3!oc"fGs)>"QFB7$Fcip$!3(*>oi&y!eoPFB7$Fc]l$!3Bo#)[!e#H$o$FB7$Fh]l$!3#=73G*Q'\+$FB7$F]^l$!3DM_(=jC*=AFB7$Fcau$!3VhycVvG#3#FB7$Fajp$!3a**p(>\**e)>FB7$F[bu$!3.;ajA4#z#>FB7$Fb^l$!3.S'QnD^=!>FB7$Fijp$!3c^g-v$e;!>FB7$Fg^l$!3-_&3`^%>#)=FB7$F\_l$!37)[j/D!4F:FB7$Fa_l$!3#Qnf&)[E`(yF<7$F[`l$!3+;@-)p%G#R"!#B7$Ff`l$"3/COx?+;XxF<7$F[al$"3skSPq)*p,:FB7$F`al$"3")eD"paQO(=FB7$Fc\q$"3*4Qb%f[g->FB7$Feal$"3)HEWv%*)H)*=FB7$F_gu$"3y=e6pJ)R">FB7$F[]q$"3?q%3=\()f&>FB7$Fggu$"3_rIwRNyJ?FB7$Fjal$"3=7J[sl-X@FB7$F_bl$"3Z@'H'4#*GGHFB7$Fdbl$"3,f;:*41Pm$FB7$Fi]q$"3P_Ud*QuYv$FB7$F^^q$"3kuZ\/EI0QFB7$Fc^q$"32:G")G`A@QFB7$Fibl$"3QpJ*ya.B"QFB7$F_cs$"3kz9h*)>b"z$FB7$F[_q$"3q2.i#>vOx$FB7$Fgcs$"3*QNGZ>uLx$FB7$F^cl$"3(3HMTb:O!QFB7$Fhcl$"3e$Hxd+1PK%FB7$F\el$"3!zs#o%*>/U_FB7$Fael$"3R9=L;%z)eaFB7$Ffel$"3;Y#**)f6=EcFB7$$"3<'\7`>ocC&FB$"3#3oi2e8!)o&FB7$F[fl$"3+k"=-+,Xt&FB7$$"3B(\PM#)*>e`FB$"3g'oVIG$oldFB7$F`fl$"37,&*G+b7#y&FB7$F^hx$"3[7YT&R0cx&FB7$Fefl$"33"z68H'>HdFB7$Ffhx$"3<G=y,<CjcFB7$Fjfl$"3>g$=Kvr;g&FB7$F`ju$"3&z[wyti-d&FB7$F_]o$"3)pVa,$*e!ybFB7$Fhju$"3_"R"**='=tj&FB7$F_gl$"3-Rl@zw9bdFB7$F\^o$"3!*Q<CSyqjhFB7$Fdgl$"3hL-'y_Q\t'FB7$F^_o$"3>w)=)>a'fN(FB7$Fh_o$"3AS.-xd5&y(FB7$$"3QJLekiLfrFB$"3K:;!H&pMVyFB7$F[aq$"3qq4?hHGzyFB7$$"3TkmTgxHnsFB$"3y.T?7&zE*yFB7$F]`o$"3=R_?(y**R)yFB7$Fcaq$"3]Jda)e)z0yFB7$Figl$"3A/:1"4YAm(FB7$F`bq$"3CQT>QcxGtFB7$F^hl$"3*yM[(fG9&3(FB7$Fifs$"3+>2h[(p^1(FB7$F]cq$"3'Q#oy5o)=9(FB7$Fags$"3e*GR"=>hFtFB7$Fchl$"3c/**4QTxCwFB7$Fhhl$"36Np]!["[!y*FB7$F]il$"3<m")=Dmqx5F97$Fj\\l$"3%etD#zwnT5F97$Fedq$"3")41<$H!>f(*FB7$Fb]\l$"3I*[>qm\rz)FB7$Fbil$"3s=E?C>WTvFB7$F^]y$"3!ep$4n=!3-'FB7$F]eq$"37zfT"[w0G%FB7$Ff]y$"3/LuO\98!Q#FB7$Fgil$"3!esj5[a=*QF<7$F^_v$!312PUx>g1<FB7$Fgao$!3%)*z%H>oHJPFB7$Ff_v$!3Tb#p;c-Eg&FB7$F\jl$!3gvU=8J2\sFB7$Fj^y$!3DX&p#Q/*\h)FB7$F_bo$!3!**\"eIi#Rm*FB7$Fb_y$!3qG*4j]q!Q5F97$Fajl$!3?xp?HJ;x5F97$Ffjl$!3=.SXO<4z)*FB7$F[[m$!3d!>![Wr<exFB7$Fijs$!3'\)eL5NZ%R(FB7$Fagq$!3,)=W)[[4krFB7$$"3g;zp[+S">"F9$!3)o!)G6,d%*4(FB7$Fa[t$!3zW%GV#R'o1(FB7$$"3r\P%["p;-7F9$!3xX!H5')))R1(FB7$F`[m$!3!pIwl-hx3(FB7$F^hq$!3+xjsx$4*otFB7$Fe[m$!3X"ysxkEis(FB7$$"3Z;aQ)p-eD"F9$!3u%o/@@>=z(FB7$F[iq$!3A')o1))3$G%yFB7$$"3y\i:qC<m7F9$!3jtIo"zko(yFB7$Fcco$!3'4J^%)p$3#*yFB7$$"35$3F>CUlF"F9$!3$fNY0xRs)yFB7$Fciq$!3oRJ&>&yohyFB7$$"3j;zp8?"pG"F9$!30m3fsCQ:yFB7$Fj[m$!3IRj(*4"f)[xFB7$F`do$!3On)*p(R%Q4tFB7$F_\m$!39i*okQ?rq'FB7$Fbeo$!3ui#*o=_H;hFB7$Fd\m$!3$=m'[yQ>:dFB7$$"3vmT&)QmH"Q"F9$!39S?iI!p\l&FB7$Fbbv$!3`Qfef)R6h&FB7$$"3]m"H#G7!>R"F9$!3e(R1m$z.$e&FB7$F_fo$!3?ex;uSapbFB7$Fjbv$!3s&3%)o$*>*zbFB7$Fi\m$!3Q3?:Xd>EcFB7$Fbdy$!3aJcJVBG)o&FB7$F^]m$!3'3FXgu+ju&FB7$Fjdy$!3oOtO2nR"y&FB7$Fc]m$!3'o)pIV))4ydFB7$$"3W;/w-#QdY"F9$!3[i_")otbedFB7$Fh]m$!3MMVWxX&fs&FB7$$"3&*\7y!)\Dw9F9$!3jf1aYP$*zcFB7$F]^m$!3O<d&ezQ0i&FB7$Fb^m$!3&*p0cWUujaFB7$Fg^m$!3z]>&p]XLE&FB7$F[`m$!3he7k%*p3%Q%FB7$Fe`m$!3feYE&G//$QFB7$Fc^t$!3xGtBm*o6y$FB7$Fc[r$!3sb$QWj()3x$FB7$F[_t$!3ZcJ\)H2by$FB7$Fj`m$!3p%ott.1"3QFB7$F[\r$!3e+$pS<N6#QFB7$F`\r$!3%3*3'))z)o3QFB7$Fe\r$!3xc)*R9@^ePFB7$F_am$!3s*pS\D*\jOFB7$Fdam$!3-J+Erd;&*HFB7$Fiam$!3t'*H"fJsLB#FB7$Fcev$!39ODF^W%[4#FB7$Fc]r$!3%[K5_)*\`*>FB7$F[fv$!3'z>?d[dO$>FB7$F^bm$!3ru'=_CpS!>FB7$F[^r$!3;%=gN9t3!>FB7$Fcbm$!3r/0DJU2))=FB7$Fhbm$!3e+%p([o+W:FB7$F]cm$!3*\)yPrk>#)yF<7$Fgcm$"3h3ne]D()4[Fe_rF[dmFcdmFfimFjhm-Fjgm6%FbimQIThe~10~term~Fourier~approximation~(blue)F(FdhmF]jmFajm7*Fjhm-Fjgm6%FbimQIThe~11~term~Fourier~approximation~(blue)F(FdhmFigmFfim-F,6$7cv7$F0$"3JE`V[5]rcF57$F>$"35&yJ\%\*)y')F<7$FI$"3RBtMb')HC:FB7$FS$"3S3n5Ck@4EFB7$Fgn$"3)>5L)z%R#*>$FB7$Fj[p$"3;vx\%p)*[l$FB7$F\o$"3\HUx19\jSFB7$F\br$"3uIJ!)*p48@%FB7$Fg\p$"3iX@xt`35VFB7$Fdbr$"3,F'=vdM)fVFB7$Fao$"3z@V@?M#yO%FB7$Ffo$"3n!QVhn&z@VFB7$F[p$"3tP$p)4n:+VFB7$F`p$"3hRT@fXPNVFB7$Fep$"39G[;@;*[T%FB7$Fjp$"3.W4(*4^]UXFB7$F_q$"3uVMEsP*fr%FB7$Fcr$"3O-yP8xdqcFB7$F]s$"3MlUJbweuhFB7$Ffgt$"3U\uJLLAghFB7$Fh]n$"36$)\7\1#R5'FB7$F^ht$"37EA_H[zFgFB7$Fbs$"35jxFIb"z&fFB7$F`^n$"3#[$=$*yer?fFB7$Fe^n$"3#*zr0V#z"RfFB7$Fj^n$"3#=LhaGK$HgFB7$Fgs$"3m3a=9Pb(>'FB7$F\t$"3q'RkAl%z(R(FB7$Fat$"3Q[w"\w3n7)FB7$F\`p$"3OQt$GZda#zFB7$Fft$"3S,kDnXK3vFB7$Ffer$"3gv&zc^44L(FB7$Fi`p$"3GY!yR_O7C(FB7$$!3n;HK>\%)y6F9$"3'Q^'=$)y.VsFB7$F^fr$"3kvJC/*R;G(FB7$$!3'*\(=U%*oz;"F9$"31!)om?4&*ftFB7$F[u$"3/!4_()\r&zuFB7$F`u$"3j(310XYcI*FB7$Feu$"3KTf&[6lN4"F97$Fhan$"3sW2,GBSP5F97$Fju$"3]jdQ%yOW>)FB7$Fdjt$"3Q'***f;J86lFB7$F`bn$"3=`ic"\ie]%FB7$$!39+Dc^jz:5F9$"3E"Qj**o<-T$FB7$F\[u$"3dbHm**HDqAFB7$$!3VL3_I?,05F9$"3:7;2oGb+6FB7$F_v$!3qjByi&oFO)F]`l7$$!3-,+](ob?%**FB$!3ro%e,[S:F"FB7$Fd[u$!3H*=#yTMfUCFB7$$!3S++]i'pP$)*FB$!3Bt3uR;U"e$FB7$Fhbn$!3**R%y:]#RtYFB7$F\\u$!3ak">ZKOQm'FB7$Fev$!3'z'*Hi&z@B$)FB7$F`cn$!3s!4@fg3O/"F97$Fjv$!33gZ*z3,E4"F97$F_w$!3BJCZI.&H.*FB7$Fdw$!3gj1qfpa=tFB7$Fjir$!3_EnL')ywRsFB7$F_dp$!3*p.Eg"3!*psFB7$Fbjr$!34(ocit/[Q(FB7$Fiw$!3K;nM-hh`vFB7$F\ep$!3qK">^"=<=zFB7$F^x$!3'pm>)*\W17)FB7$Fidn$!3_$4vO4:;T(FB7$Fcx$!3rF\%3)=5ahFB7$F`fn$!32STC-*[X,'FB7$Fefn$!3yTIY!o1#QfFB7$Fjfn$!3U#z#p;#p)>fFB7$Fhx$!3*R<yz_.![fFB7$Fbgn$!3RfT"H))\e2'FB7$F]y$!3YRF+1QRshFB7$Fgy$!3'yqAhkb.t&FB7$F[[l$!3d].*H*=9/ZFB7$F`[l$!3T\%GRnWW`%FB7$Fe[l$!3mb[]5C>5WFB7$Fj[l$!3+y#[CneKL%FB7$F_\l$!3u+g(z$Rp*H%FB7$Fd\l$!3:$3&H!y3AK%FB7$Fi\l$!3Kc2\A$>yO%FB7$Fd]s$!3u+kSHFffVFB7$Fahp$!3qL27"fO(3VFB7$F\^s$!3PJtDm(yy?%FB7$F^]l$!32s+%R"[<dSFB7$F^ip$!30qg5lRAUOFB7$Fc]l$!3">o!G%y%H$=$FB7$F]^l$!3KhMX"31$4EFB7$Fg^l$!36l$R=HqVd"FB7$Fa_l$!3&orG")Q)=z')F<7$F[`l$!3iOSt&*f/ZRF]`l7$Ff`l$"35?irq`zz')F<7$F`al$"3Pyev2Z+B:FB7$Fc\q$"3\$o!=<[ZS>FB7$Feal$"3FCaU:!egI#FB7$F_gu$"37)RyuAS)RCFB7$F[]q$"35"))fK$[?LDFB7$Fggu$"3k^5M2_5(e#FB7$Fjal$"3!p_n'Qa(zg#FB7$F[ex$"3_>><PTs(f#FB7$F_bl$"3e'>O8GgVi#FB7$Fhex$"3-.,#H%3Q(z#FB7$Fdbl$"3km))GvKnXJFB7$Fibl$"3VR&e1tA\+%FB7$F^cl$"34nc6Zv&)oVFB7$Fccl$"3"p]`j$=(HL%FB7$Fhcl$"3CipI$oWnH%FB7$F]dl$"3#*HL.N8U>VFB7$Fbdl$"3/hE'RV'*eQ%FB7$Fgdl$"3/Q!HYHY@]%FB7$F\el$"3#elE4'eonYFB7$F`fl$"3^zc,;>A-dFB7$Fjfl$"3!y$Hr.wethFB7$F_]o$"3#oui%[k$H2'FB7$F_gl$"3OZ1%>;o4%fFB7$Fg]o$"3Ql;Nb!G%>fFB7$F\^o$"3Pe&3#*3^L&fFB7$Fa^o$"3a9r[7))oagFB7$Fdgl$"3U5^_T$GqA'FB7$Fh_o$"3`ZcF&y;(ouFB7$Figl$"3?/#pgpp07)FB7$F`bq$"3u7@l:IT2zFB7$F^hl$"3CoTw#*=[HvFB7$Fifs$"3/*)GKNmOhtFB7$F]cq$"3$>V\FO4kD(FB7$$"3?k"z%\54t")FB$"3-O)Q0vs"QsFB7$Fags$"3G_n>Q^\ZsFB7$$"3'z\P4@?4F)FB$"3zW=">VOrG(FB7$Fchl$"3cTiGwz3ftFB7$Fhhl$"3XslRkv+W#*FB7$F]il$"3]o/xhrP%4"F97$Fedq$"3-Ra)3<JU-"F97$Fbil$"3+')GM\6`;")FB7$F^]y$"3!3:?"e*G$RlFB7$F]eq$"3kW?6H*e/o%FB7$Ff]y$"3=R:[)*=\8EFB7$Fgil$"3/XlD[)R3G%F<7$$"3c**\i5KJ.5F9$!3I*yC_\6IG(F<7$F^_v$!33!z"**H7cv=FB7$$"3'GL3-UKQ,"F9$!3gC!zt#=S**HFB7$Fgao$!3.q1Q)\Jg3%FB7$Ff_v$!3C!)RmG,v'4'FB7$F\jl$!3%[XG'p-0=yFB7$Fj^y$!3]a`?HRV%=*FB7$F_bo$!3l$4#G&=Tf,"F97$Fb_y$!3k]0#RYZP2"F97$Fajl$!3q]e(Hj0V4"F97$Ffjl$!3MMrW$HMzN*FB7$F[[m$!39RFS$zR=V(FB7$$"3$*\iS;j')p6F9$!3^iOCxw)zK(FB7$Fijs$!3h4*zY1IUE(FB7$$"3/$3_D=L1="F9$!3)Q^,gwg&QsFB7$Fagq$!3v#z1'R#pxC(FB7$Fa[t$!3sKv&pB0IN(FB7$F`[m$!3Y:"y(o0@PvFB7$F^hq$!3U!)o[j6_YzFB7$Fe[m$!3+=?HY:jE")FB7$Fj[m$!3/FEX#)Rv*Q(FB7$F_\m$!3bZ'HhUc$3iFB7$F]eo$!3Op%3DRch.'FB7$Fbeo$!3GRo^d(=?%fFB7$Fgeo$!3e#*G:**\7?fFB7$Fd\m$!3$38xR#)3\&fFB7$Fbbv$!3;3R!ze)oBgFB7$F_fo$!3e0=d'**Q,5'FB7$Fjbv$!3'[\j-h'4ehFB7$Fi\m$!36NX'4uq^<'FB7$Fc]m$!3L)QD)Q=CgcFB7$Fg^m$!3]>?^+0%oo%FB7$F\_m$!3_#[8%f_\BXFB7$Fa_m$!3GZ&\*)[JWS%FB7$Ff_m$!3%)ysbVd0JVFB7$F[`m$!35$R-n\Y$*H%FB7$F``m$!3EU9(*3I'>K%FB7$Fe`m$!3GL<pIEXnVFB7$Fc^t$!35f^.5S"*fVFB7$Fc[r$!3&H2#G$=tvI%FB7$F[_t$!3%[trW-kC?%FB7$Fj`m$!3^VlQ6=*\/%FB7$F`\r$!3vKi>[tg8OFB7$F_am$!3'*)*z'4$QHXJFB7$Fiam$!3&p#oLJA04EFB7$Fcbm$!3'4v+l1<$=;FB7$F]cm$!39Y+a"ob"z')F<7$Fgcm$!3JE`V[5]rcF5F[dmFcdmF]jmFajm7*-F,6$7ex7$F0$"3MxvU:BB7TF57$F>$"3ji(z?&)RsW*F<7$FI$"3M(*[xY*)Q'f"FB7$FS$"3%R(3A<$fld#FB7$Fgn$"3U`^mBT(4=$FB7$Fe[p$"3GMmKwHN*>$FB7$Fj[p$"39&)3"R&[&)fKFB7$F_\p$"3'[P:lWm9P$FB7$F\o$"3II-]?nXMNFB7$Fg\p$"3A`#Rb6'>sRFB7$Fao$"3m*[TZ$4uGWFB7$Fj_z$"31$>P$["*p)f%FB7$Ffo$"3af8J<M^CZFB7$Fb`z$"3dPG5I(35![FB7$F[p$"3Mfu/^-HI[FB7$Fep$"3)pFy@[F-z%FB7$F_q$"3HLJs4TsOZFB7$Fcr$"3$p3<vM@69&FB7$F]s$"3%4TT'*e%HGhFB7$Ffgt$"3vK'**GwKLK'FB7$Fh]n$"3u<x-Lap]kFB7$F^ht$"3N$H+M:<N]'FB7$Fbs$"3*e'H?l3_(['FB7$Fe^n$"35)e%\FT`IjFB7$Fgs$"3g6$>)4NR8iFB7$F\t$"3xXxr#\)GnoFB7$Fat$"3yUu0]J$f8)FB7$$!3'p"z%*p25W7F9$"3Q1TS$H`#G#)FB7$Fg_p$"35If'GbI0H)FB7$$!3D]P%[zCKB"F9$"3Omu")\A3@$)FB7$F\`p$"3:5'3i=(e>$)FB7$Fa`p$"3771<8VOE#)FB7$Fft$"3U1hg[1&o.)FB7$Ffer$"31#)pIRrK(z(FB7$Fi`p$"34'\WDkF#ovFB7$Feefl$"3^<(Hr;O"yuFB7$F^fr$"3-Ds^,#**\T(FB7$F]ffl$"3L?(z+,')fQ(FB7$F[u$"3+ZOj/?>(R(FB7$F`u$"3(*yU_KOOv()FB7$Feu$"3)o8*\f3X)3"F97$$!3'**\7yF-03"F9$"3#)QGZF=(*)4"F97$Fddw$"3?"))3kJ505"F97$$!3DL3xczrp5F9$"33*\*Rw(=>4"F97$Fhan$"3(=u7DlYA2"F97$F\ew$"3G&3mGO90(**FB7$Fju$"3'z141-0Xs)FB7$Fdjt$"3A[%=O5;m+(FB7$F`bn$"3)zYFx\$)f)[FB7$Fggfl$"3D$p`c:+yq$FB7$F\[u$"3[o(fSKUIZ#FB7$F_hfl$"3j_'[73)>+7FB7$F_v$!3T$>W7a-I7*F]`l7$Fghfl$!3(H1rfj4lQ"FB7$Fd[u$!38AD%*)4c,m#FB7$F_ifl$!3W;1.%)\a#*QFB7$Fhbn$!3@*>2cCf^1&FB7$F\\u$!3))[eKP1UlrFB7$Fev$!3"pAU()*[=_))FB7$F\gw$!3gov3fd$f+"F97$F`cn$!3wgnG$**zo2"F97$$!3i++]P&RBH*FB$!3'y]JWuHW4"F97$Fdgw$!3k:)*3Po(45"F97$$!3M***\(=]76#*FB$!3g`**3&HI/5"F97$$!3,++]7N0%=*FB$!3'yU"fad_(4"F97$$!3p++D1?)p:*FB$!3c=O-P&=C4"F97$Fjv$!3%[;%>dLF&3"F97$F_cp$!3U_@%)RT19)*FB7$F_w$!3wwN"HiFx])FB7$Fghw$!3W8h@j#y"zzFB7$Fgcp$!31hbJ]4*)3wFB7$$!3r*****\x6;X)FB$!3[&>l6,B0\(FB7$Fdiw$!37Ev=!=PpT(FB7$$!3(******\7esM)FB$!3KB2,HI='Q(FB7$Fdw$!3C!fVS9'y%R(FB7$F_dp$!3!*RHK"z*\rwFB7$Fiw$!3hIDqX58%3)FB7$Fgdp$!3sSixmS.R#)FB7$F\ep$!3b">Ys6*4=$)FB7$$!3*Q$3_v57zwFB$!3&oIN#\QSB$)FB7$Faep$!3xvSwTIW/$)FB7$$!3G+D1kzN%e(FB$!3())pwf,u6E)FB7$F^x$!3'Q>kP/eV>)FB7$Fidn$!3iq<T218")oFB7$Fcx$!3;nmg%Qfi@'FB7$Fefn$!3G+&[eZXAL'FB7$Fhx$!3i0jU/(o%ykFB7$Fb^u$!3@t?k9ET0lFB7$Fbgn$!3R5u20]hzkFB7$Fj^u$!3GZ1cE"HQR'FB7$F]y$!3\#*yA<%z"\iFB7$Fgy$!3O;m!yZ)H+_FB7$F[[l$!3DFv4cA-PZFB7$Fe[l$!3%*)GQpd.>z%FB7$F_\l$!3a.Q,&QA+$[FB7$F^^[l$!3ME$o40<)*z%FB7$Fd\l$!3c2zEz)))Hs%FB7$Ff^[l$!3G;(fyH<wf%FB7$Fi\l$!3wea-&fN)GWFB7$Fahp$!3Rx#Q]qdy'RFB7$F^]l$!3?K#=%H+hFNFB7$Fihp$!3Me'*=!yW^O$FB7$F^ip$!3OD)G"p(*>bKFB7$Fcip$!3QXi)[!Q-(>$FB7$Fc]l$!3())yb#4H)3=$FB7$$!3[***\P4_=B$FB$!3I/Q]#=E#*=$FB7$Fh^x$!3xP\#e"yR-KFB7$$!33***\7txk-$FB$!36Ayn5h">?$FB7$Fh]l$!3fxB4icxrJFB7$Fe_x$!38t'="QS%\)HFB7$F]^l$!399>&QAz`j#FB7$Fg^l$!3y3w3so!ff"FB7$Fa_l$!3%=l![]Zw&Q*F<7$F[`l$!3kK8=J"QV(>Fjddl7$Ff`l$"3A_PK]r1b#*F<7$F`al$"3c>[LfkS'f"FB7$Fjal$"3EVO^1(ei_#FB7$Fdbl$"3k/NR60@"=$FB7$Fi]q$"3MMgG*pg2>$FB7$F^^q$"33X=h\I@PKFB7$Fc^q$"3$4zD&p?7JLFB7$Fibl$"3L1$*3EjIvMFB7$F[_q$"3c?+Bn:o%)QFB7$F^cl$"3uF-?DqhUVFB7$Fbg[l$"3j+VBKGdKXFB7$Fccl$"3fi,Jz"e1o%FB7$$"3;'\P%[a"pS%FB$"3')zb)*>01OZFB7$Fjg[l$"3T/adR"*RyZFB7$$"3H'\7y?l#3XFB$"3)z=()fvHy![FB7$Fhcl$"3[XVwG&>]#[FB7$Fbdl$"3>b&RSN,5![FB7$F\el$"3SR()3kHzQZFB7$F`fl$"38YMQ-Psr^FB7$Fjfl$"3A8vzS1'fB'FB7$F`ju$"3U'pDwpg=R'FB7$F_]o$"3A-q[LP!>['FB7$Fhju$"37XHh&4))[]'FB7$F_gl$"33'\[e*p6qkFB7$F\^o$"3**\*\gzL(4jFB7$Fdgl$"387M3ETM8iFB7$Fh_o$"3cY9%pdF+%pFB7$Figl$"3]$=4*H!HZ>)FB7$$"34m"H23;he(FB$"3"=(HZTs?j#)FB7$F[bq$"3M[?@I(\lI)FB7$$"3&)*\(=U_%Ro(FB$"3wC/[f_'RK)FB7$F`bq$"3aC&4>oybJ)FB7$Febq$"3gFFN/"RmA)FB7$F^hl$"3T$*eHX*o%f!)FB7$F]cq$"3/hOV+SqKwFB7$Fchl$"3vL(*44M2'Q(FB7$Fecq$"3;SO]1hC(p(FB7$Fhhl$"3r>)\a&>^8()FB7$F]dq$"3!z4?=&=815F97$F]il$"3-P(zjWNh4"F97$Fedq$"3L6Y0S!))>1"F97$Fbil$"3g'4/;JSpk)FB7$F^]y$"3))HNp0T(f.(FB7$F]eq$"3R5kru.rs]FB7$$"32Ie9TUeH)*FB$"3mLr1q6b&)RFB7$Ff]y$"3B@B_dhcXGFB7$$"3u&\Pfy=-$**FB$"3M;7xB#*\n;FB7$Fgil$"3#=]YwWp(pYF<7$Fgigl$!3;v9^_>$R%zF<7$F^_v$!3zvb(RJ[S/#FB7$F_jgl$!3pj)3$*R"ojKFB7$Fgao$!3'QuH5;ZdV%FB7$Ff_v$!3c5!Qyy8Md'FB7$F\jl$!3dN#4RIxwM)FB7$Fj^y$!3^`k%y3>[o*FB7$F_bo$!3)=d6='))Gb5F97$$"3!)**\7o%Gk1"F9$!3f+w&\7(G"3"F97$Fb_y$!33[Uj6qH'4"F97$$"35L$3xnZp2"F9$!3QF#pe**p55"F97$Fajl$!3)3v&Geqb'4"F97$Ffjl$!3:)3]i'*\%G))FB7$F[[m$!3?+cmYM@)Q(FB7$Fagq$!3K?GPDtM,wFB7$F`[m$!3k0O.Uf\n!)FB7$$"3E$e*)4yLH@"F9$!3dxZ&p<zh;)FB7$Figq$!3'o)Guy'4YC)FB7$$"3Q;a8Z1qB7F9$!3/L^l=V*zH)FB7$F^hq$!3YBvs!4>GK)FB7$$"3$*\7G8vYM7F9$!3wM%y%oj$pJ)FB7$Fchq$!3&e!4r')Rfz#)FB7$$"3/$3F%zVBX7F9$!3Oov7frS6#)FB7$Fe[m$!3!\g5MTwU6)FB7$Fj[m$!3C'fU^G2$foFB7$F_\m$!3;a/6D%4K@'FB7$Fbeo$!3qQ+<'o%zDjFB7$Fd\m$!3;7c"eg_]['FB7$Fbbv$!3B3srp%*G/lFB7$F_fo$!3^6u5Y;SbkFB7$Fjbv$!3t'fjrs#*>L'FB7$Fi\m$!3a,O(GDv-9'FB7$Fc]m$!3q:_!\Nh98&FB7$Fg^m$!3m<IB%y+xt%FB7$Fa_m$!3qxq:pf*Rz%FB7$F[`m$!3woaDf;yH[FB7$Ffd\l$!3yzoRsXS*z%FB7$F``m$!3Xv<BDm*Qs%FB7$F^e\l$!3?o!3/-G9g%FB7$Fe`m$!3(H[3ptpnV%FB7$Fc[r$!3U<1<"))eT'RFB7$Fj`m$!3@ON_d2u9NFB7$F[\r$!36!R]R_o@N$FB7$F`\r$!3&GLgYj8`C$FB7$Fe\r$!33!>RG?WA>$FB7$F_am$!3Y$[qTb<7=$FB7$$"3%***\7)eq$y;F9$!3_h^F^rP">$FB7$F`gy$!3#*yhS\<Q.KFB7$$"3CL$3xI$=)p"F9$!3Rovk@aw+KFB7$Fdam$!3&)y<Nb$)[pJFB7$F]hy$!37krb\jP))HFB7$Fiam$!3'o$G@2OpaEFB7$Fcbm$!3%RU6'4&=ff"FB7$F]cm$!3%ey+g+RER*F<7$Fgcm$!3MxvU:BB7TF5F[dmFcdmFigm-Fjgm6%FbimQIThe~12~term~Fourier~approximation~(blue)F(FdhmFjhmFfimF]jmFajm7*Figm-F,6$7[]l7$F0$"3sX"e%e)>>>#F57$F>$"3:i)))Q._PX(F<7$FD$"3N<D'GvgK0"FB7$FI$"3hx%*e<&zhx"FB7$F\]z$"3JDsVd@Va>FB7$F_jo$"3-I3m\UQ*3#FB7$Fd]z$"3ZC+ka3!\<#FB7$FN$"3*>>d]>OZ@#FB7$Fgjo$"3[`b:,41;AFB7$FS$"3)fD$H&*R9aAFB7$FX$"3?Lej!H:E'GFB7$Fgn$"3xIo`d0"Rh$FB7$Fe[p$"3C&p[:v\%)o$FB7$Fj[p$"3W!o?&oxX8PFB7$F_\p$"33;o:kEd/PFB7$F\o$"3dM(3;'Qk%o$FB7$F\br$"3(zeC#[jEzOFB7$Fg\p$"3OY$[)3Wm6PFB7$Fdbr$"3'4vC4ZPzz$FB7$Fao$"3eIRK/0jVRFB7$F[p$"3jbY[B\S'y%FB7$F_q$"3!pHj)*o#*fA&FB7$Fiq$"3Tkr"f#z^n^FB7$Fcr$"3"ep?*GCe5^FB7$$!3;LL3UA)[X"F9$"3uNTr+G9@^FB7$F\_w$"36;^$o8<n9&FB7$$!3imm"znDYW"F9$"3Q05r[/"))=&FB7$Fhr$"3fq/2pn<[_FB7$Fd_w$"3!Qi.'fys<aFB7$F]s$"39)4T#4>TXcFB7$Fh]n$"3lK4gn`3+iFB7$Fbs$"33X@"yWNek'FB7$$!3-++]x6Dr8F9$"3+?Wz/k58nFB7$F`^n$"3yqd!4xh)enFB7$$!3&pmmT#Qkg8F9$"3w_;Qer"Hy'FB7$Fe^n$"3(3B3`Izhy'FB7$$!3WLL$3ZO+N"F9$"3#p&Q1h"H1x'FB7$Fj^n$"3g@9@^8DRnFB7$$!3#*****\<"H%R8F9$"3oN]1F@"fp'FB7$Fgs$"3g?#o^X!>XmFB7$Fb_n$"3R!=U]b&\UlFB7$Fg_n$"3&z,kP*))zskFB7$$!3bm;H-@p28F9$"3#G]RbH@DY'FB7$F\`n$"3/VSma9"RZ'FB7$$!3;+](ow=rH"F9$"3!o6"pn2y4lFB7$F\t$"3$)*\dv:0=d'FB7$Fd`n$"3')pA)*yv9qqFB7$Fat$"3'fq:#[;C'z(FB7$Fg_p$"3'G:A\()z`8)FB7$F\`p$"3mO=br#)3z$)FB7$Fd^`l$"3)=*f*)pyE_%)FB7$Fa`p$"3>,l@h%p*)[)FB7$F\_`l$"3?e%3\9u$)[)FB7$Fft$"3m5X6WYf^%)FB7$Fi`p$"3sjm"*p%p=.)FB7$F[u$"3*e"yAf)osc(FB7$Fjaw$"3qv07MNs@vFB7$F_bw$"3PPD/<*G-^(FB7$Fdbw$"3'>OnZFBu`(FB7$Fffr$"3"zX#=B'ymg(FB7$Facw$"3q,2Y(*)Qt(yFB7$F`u$"3z`!Ra-UrJ)FB7$F^gr$"3KB4t>z$=a*FB7$Feu$"3h#=$o3p!42"F97$Fb[il$"3G%[;;*)Q=4"F97$Fddw$"3$f[<N#H8/6F97$Fj[il$"3Iu7*3&>716F97$Fhan$"3GdgrmVM'4"F97$F\ew$"3'eaB:qCq."F97$Fju$"3/wIV"z&p1#*FB7$$!3MLek$*\OP5F9$"3hq@smC]5%)FB7$Fdjt$"3w%3*>L(G#zuFB7$$!3'o;/En!eE5F9$"3K*e,u$fyBkFB7$F`bn$"3ks@E;*4)e_FB7$Fggfl$"3od,nMSE-SFB7$F\[u$"35"oC3w?\n#FB7$F_hfl$"3%[y!RV,u*H"FB7$F_v$!3_9C8-?B$))*F]`l7$Fghfl$!3$ftj'3'>8]"FB7$Fd[u$!3*)He[kGewGFB7$F_ifl$!39&f(RQ#\+?%FB7$Fhbn$!3"\&e*p\m([aFB7$$!3*3++vj$[D(*FB$!3**\2&Q")3@g'FB7$F\\u$!3'oL'RzhRUwFB7$$!3F++]7w><'*FB$!3Net7"*[Sb&)FB7$Fev$!3!pE))y(4vI$*FB7$F\gw$!3"*o;'3/VZ/"F97$F`cn$!3#QaOZ!3<*4"F97$Fb_il$!3`m;*RW9m5"F97$Fdgw$!3&foW"o?Y-6F97$F_`il$!3`090">R#)3"F97$Fjv$!3,0#\bAnc1"F97$F_cp$!3K">ZzB!=Z$*FB7$F_w$!3It2>**f=*3)FB7$Fghw$!3zdr&e*z<.xFB7$Fgcp$!3)HOoMP4[_(FB7$Fhail$!3IC<?Y4P5vFB7$Fdiw$!3'o_gzv;)RvFB7$F`bil$!3**y4&e\Nlg(FB7$Fdw$!3E?5PDLk-xFB7$F_dp$!3U?m"f.jy:)FB7$Fiw$!3zM>trU'=Z)FB7$$!35,vV)HZ'oyFB$!35I#[F9'[#\)FB7$Fgdp$!3;"f3_w!>&[)FB7$$!3\n"zp=%)Qx(FB$!3y<<K+jb\%)FB7$F\ep$!3'*Ru11pE'Q)FB7$Faep$!3"eftqHQX=)FB7$F^x$!3@Q5g0v6/zFB7$Fddn$!3"4oo#\78HrFB7$Fidn$!3)\0PNg9%ylFB7$$!3-Le*[80*HqFB$!3;$\f=[%z5lFB7$F^en$!36I+,])))GZ'FB7$$!3c+voHEA<pFB$!3c!>80)QlikFB7$Fcen$!39d*)fd5fwkFB7$Fhen$!3]*Gh"=>?dlFB7$Fcx$!3$3DlM\(*zm'FB7$F]y$!3<dg+HN'=!eFB7$Fby$!3&)4o=-*)39`FB7$Fgy$!3O]&eskiX6&FB7$Faz$!3W!e60oWD;&FB7$F[[l$!3u%e0>$\iD_FB7$F_\l$!3bd/a1;8!y%FB7$Fi\l$!3\5WT%e6P%RFB7$Fd]s$!3KZi"zi5pz$FB7$Fahp$!3bbVCMxi5PFB7$F\^s$!3RT"G%eH+zOFB7$F^]l$!3.y"eRcw_o$FB7$Fihp$!3v'e:O8?aq$FB7$F^ip$!3vo6_?:98PFB7$Fcip$!3cyq_+EB&o$FB7$Fc]l$!3Rs?n_G=1OFB7$Fh]l$!3Sh(Q!*p)3&)GFB7$F]^l$!3pp=j"ff6F#FB7$Fcau$!3wwaEm<NDAFB7$Fajp$!3Ct;Z%3,_@#FB7$F[bu$!3c;PLm4r?AFB7$Fb^l$!3\<MI+D**=AFB7$F\a[l$!39G"3ai$)))=#FB7$Fijp$!3!R#H3#\o^6#FB7$Fda[l$!3gc)3EGh:*>FB7$Fg^l$!3faTn;M(=#=FB7$F\_l$!3An*eb&)p42"FB7$Fa_l$!3RI&)ys&4%\uF<7$F[`l$!3*zC#Q(Q8k%RF]`l7$Ff`l$"3*f.9Md+4W(F<7$F^c[l$"3ii9q0kpvwF<7$F_eu$"37$3%*Q**R'>#)F<7$Ffc[l$"3Q;v<ak?U"*F<7$F[al$"3*e5cN'e9X5FB7$F\fu$"3k^%[ushbR"FB7$F`al$"3[7f]l['\x"FB7$Fdd[l$"3lOcVgE'*[>FB7$Fc\q$"32fWCc7Q#3#FB7$F\e[l$"3'R%Qo,s:p@FB7$Feal$"33=3+lB/7AFB7$F[]q$"3P[_5J(Hq@#FB7$Fjal$"3Wt'G)4RdUAFB7$F_bl$"3*[N^ku7"4GFB7$Fdbl$"3m))Rp&[Dke$FB7$Fibl$"3qq*o00s3p$FB7$F^cl$"3&R=`fUmq(QFB7$Fhcl$"3YMuBgw78ZFB7$F\el$"3(eHh5&fJB_FB7$Ffel$"3eX'[!eX(*p^FB7$F`fl$"34pKpm4<7^FB7$$"32'\i:XJ2Z&FB$"31@>Ynd-H^FB7$F^hx$"3")=dOd9tk^FB7$$"38(\(ozIE$e&FB$"3e0(z./e3A&FB7$Fefl$"3["\*G=#[yH&FB7$Ffhx$"3xs")[XbK5bFB7$Fjfl$"3?%37EtDHy&FB7$Fdgl$"3/<64'pN/j'FB7$Fi^o$"3#ofIx?"*z_'FB7$F^_o$"3%p'**e(QvnY'FB7$$"3Klm"HF8M%pFB$"3u*[G"*>hTY'FB7$Fc_o$"3%\>Y'=5R&['FB7$$"3N)**\(oZP^qFB$"3EBED$4)*H`'FB7$Fh_o$"3ijd`A=A3mFB7$F]`o$"3QD>!yD(ogrFB7$Figl$"3Ztqk37&[!zFB7$F[bq$"3c1*G,bPI>)FB7$F`bq$"3CP\*)zEJ'R)FB7$Febq$"3)=mT6*>!*)[)FB7$F^hl$"3^%z%)Q%)[>Y)FB7$F]cq$"3:t>vL0K8")FB7$Fchl$"3_g+N+N#Rl(FB7$Fb\v$"3;f,P!*)H!pvFB7$Fg\v$"3aieK#py#>vFB7$F\]v$"3b:Ie#y2D^(FB7$Fecq$"3tU"))*)oC\b(FB7$Fd]v$"3Es[v([R;!yFB7$Fhhl$"3"fy.>y-HE)FB7$F]dq$"3!\n#Hc&**\i*FB7$F]il$"3DK$QNPn^3"F97$$"3sKeRspxD#*FB$"3gPE9]*H+5"F97$Fj\\l$"3\+:,&G@l5"F97$$"3D#e*)4)GD,$*FB$"3*45&Q#pBi5"F97$$"3R)\(=<:TE$*FB$"3rsD%fHpL5"F97$$"3j:aQ`,d^$*FB$"3/xv^3v#y4"F97$Fedq$"3)Q&)y'Q:[*3"F97$Fb]\l$"3IfA%oIji-"F97$Fbil$"3'QWtzK]48*FB7$F^]y$"3l&4O["[V4vFB7$F]eq$"3v#RHNOknX&FB7$Facjl$"3eH[BF\_*H%FB7$Ff]y$"366sI!=Zi2$FB7$Ficjl$"3jTA!p4!=0=FB7$Fgil$"3"3k*HN%Q'e]F<7$Fgigl$!3YIry#y`Xg)F<7$F^_v$!3kR%zl1B?@#FB7$F_jgl$!3Sf()e`y%e_$FB7$Fgao$!3bvU))y\0!y%FB7$$"3;m;zH;NC5F9$!3e"z0JEEX&fFB7$Ff_v$!3A=CW;%y9.(FB7$$"3Y**\PR3([."F9$!35;tQf'ff*zFB7$F\jl$!3qcLBZxCO))FB7$Fj^y$!3e/$*y1+^65F97$F_bo$!3\F%\!oym%3"F97$$"3[m"Hdm)zj5F9$!3-bN2[(4Z4"F97$Fiejl$!3t^%[^eR;5"F97$$"38L3_q#e!p5F9$!3)p_^-@%e06F97$Fb_y$!3m6W/Ouo16F97$Fafjl$!3'H*pI%z?55"F97$Fajl$!38&4uA\qg3"F97$Fafq$!37^t>3NA)p*FB7$Ffjl$!3g!y6vl&Rk$)FB7$Fe`y$!3p0+]$>_M)yFB7$Fifq$!3;I4knZl'f(FB7$Fgay$!3Sv%G!eNm4vFB7$F[[m$!3Wr&)H5*>Vf(FB7$Fagq$!3;aw`x(z\2)FB7$F`[m$!3Sb'o]")R`Y)FB7$Fegjl$!3y&p_<Zq@\)FB7$Figq$!37XH@5M0$[)FB7$F]hjl$!39<U=:0TP%)FB7$F^hq$!3+w%R@]&\c$)FB7$Fchq$!3`L0d!o&4-")FB7$Fe[m$!3)>ff"o[PfxFB7$Fcco$!3@aBmr69\qFB7$Fj[m$!3FC(f#RW1olFB7$$"3%*\(oay"G(H"F9$!3R$ziUT*G3lFB7$F[do$!3vlE"=yVOZ'FB7$$"3[$eRsb^wI"F9$!3E/'z=%>_ikFB7$F`do$!36:^%)[!pAZ'FB7$Fedo$!3)fm&3>wYRlFB7$F_\m$!3-q]nVUrRmFB7$F]eo$!3#3p$f&HB_t'FB7$Fbeo$!3JA0J!y*Q&y'FB7$$"3"o;/,Y(3g8F9$!3K**=7p*4Uy'FB7$Fgeo$!3S(e'RydSinFB7$$"3cm"z%\?pq8F9$!3toV77n&*=nFB7$Fd\m$!3plt)z,LRl'FB7$F_fo$!3!G_1$)p$e9iFB7$Fi\m$!3K\=)3yD%fcFB7$Fbdy$!35:Z'H-mQU&FB7$F^]m$!3\!e&ehi&)[_FB7$$"3()\(=nk/ZW"F9$!3O]z,cA.)=&FB7$Fjdy$!3!4SUUHf`9&FB7$$"3P$eRZU@_X"F9$!3IT0Z#>,+7&FB7$Fc]m$!3e&G7^*\H5^FB7$F]^m$!3v)pq%H.0s^FB7$Fg^m$!3[$yE<UhZA&FB7$F[`m$!3z)37n:#3vZFB7$Fe`m$!39(Q*[N[d]RFB7$Fc^t$!3)HB:`*)y#)z$FB7$Fc[r$!3)4XDC$yv4PFB7$F[_t$!3Z%4r"*))\'yOFB7$Fj`m$!3H\*o5(=`'o$FB7$F[\r$!3.QUq;'=rq$FB7$F`\r$!3a1ml^U-7PFB7$$"3JL3Fu/&=l"F9$!3'4#z,W7m+PFB7$Fe\r$!3">J%*G=Oon$FB7$$"3")*\7.JEHm"F9$!3*G%zrRx&*QOFB7$F_am$!3O1#Rw)[@'e$FB7$Fdam$!3*>?spEa_(GFB7$Fiam$!3#4&4"fHewF#FB7$Fcev$!3vnxQ\D@GAFB7$Fc]r$!3gDk:DM::AFB7$F[fv$!3%>kvKv'))>AFB7$F^bm$!3#)e:<ard?AFB7$Fab_l$!3S;"pU:Rk>#FB7$F[^r$!3RXy-XPxJ@FB7$Fib_l$!3c<?9i;(*=?FB7$Fcbm$!3c[RweF"*f=FB7$Fhbm$!3asmV<l:*3"FB7$F]cm$!3P>rY@T))\uF<7$Fgcm$!3sX"e%e)>>>#F5F[dmFcdmFfim-Fjgm6%FbimQIThe~13~term~Fourier~approximation~(blue)F(FdhmFjhmF]jmFajm7*Figm-F,6$7j^l7$F0$"3#R'R]a7^Ej!#M7$Fdiv$"3![qE&pAG<WFcv7$Fg_r$"3Tl(o&)f8hS$F]`l7$F]jv$"3eG"Q)\<+"3"F<7$F7$"3Yt!o\5_.N#F<7$F_`r$"30ilbU&e&*='F<7$F>$"39aM')yX$f."FB7$Ff[z$"3B#)y^hvQy6FB7$Febt$"3WJ9,H5.#G"FB7$F^\z$"31QZ9\q0X8FB7$FD$"3$G#HBNP5t8FB7$F]ct$"3`"*fkF=Ey8FB7$Fbct$"3IH]1Rp*oP"FB7$Fgct$"3l^>nWxn'Q"FB7$FI$"3H0zWpqMB9FB7$FN$"3-JcYSEBZ?FB7$FS$"3V%oZ=w)p2FFB7$Fg[w$"3`KUim2\`FFB7$F\\w$"3!oI+dta*fFFB7$Fa\w$"34T\++II]FFB7$FX$"3rcvm8j*=v#FB7$$!32L$e9,ELq"F9$"3\P;ZR"G]w#FB7$$!3=LLep%ezp"F9$"36%H\WR())*y#FB7$$!3IL$3x#4f#p"F9$"3CvL`>YHGGFB7$Fi\w$"3WNW_%4!G")GFB7$$!3?LL3-$)[w;F9$"3l/E92vzIIFB7$Fgn$"3W'*Qr.SbHKFB7$Fao$"3"e]s!>XB;TFB7$Fj_z$"3=p([/UQ`5%FB7$Ffo$"3oQ-CB/[ITFB7$Fb`z$"3"z4&o]Qb2UFB7$F[p$"3UEsA()oQUVFB7$Fep$"335:fQ5'>v%FB7$F_q$"3(*)p&eeUE0_FB7$Fdq$"3NGv2MSK*Q&FB7$Fiq$"3c]0B!3C6^&FB7$F^r$"3GvYbU)RVc&FB7$Fcr$"3oiODSdHdbFB7$F\_w$"32*4M.H'o6bFB7$Fhr$"3!)y%QxL#QeaFB7$Fd_w$"3A^&3u)R6JaFB7$F]s$"33]d"=V+$faFB7$Fbs$"3.BK1fO2.jFB7$Fgs$"3"oX!3s$Q3.(FB7$Fg_n$"3#o%ey+T['*oFB7$F\t$"3mT")*pH!p#p'FB7$Fhbcl$"3n$)\_GU-xmFB7$Fg^p$"36(GGmETho'FB7$F`ccl$"3ne#=$3Y[BnFB7$Fd`n$"3YhVB=b)4z'FB7$F__p$"3E$)*oZYGd,(FB7$Fat$"3#G<ah!ogTtFB7$F\`p$"3!GBcindY7)FB7$Fft$"30umw+P,8')FB7$F^ecl$"34"))fG`Y#R')FB7$Ffer$"33$zD8W0Fi)FB7$Ffecl$"3!3uJZZ'\l&)FB7$Fi`p$"3LNbt4dKs%)FB7$F^fr$"3GZupMz&*3#)FB7$F[u$"3r35MG)[M"zFB7$F_bw$"3I1Vnpna0xFB7$Fffr$"3#)>1fG9(ph(FB7$F\cw$"3_2Pz+l*[j(FB7$Facw$"3/iU5Zj!3q(FB7$Ffcw$"3E>U2Z6E<yFB7$F`u$"3f!R')QKhY)zFB7$F^gr$"3$*4(=X/G!*3*FB7$Feu$"3S3vW#*z)Q/"F97$Fddw$"35Y*H^'>!o4"F97$Fhan$"3wO"4^)*>.6"F97$F\ew$"3y())3#)=@#p5F97$Fju$"3Q4r)y)>yR'*FB7$F_^\m$"30o:7cH.k))FB7$Fdjt$"3y!>$\vT"y#zFB7$Fg^\m$"3'zfWR#QJUoFB7$F`bn$"398r)pS]Qi&FB7$Fggfl$"3abm'of"Q$H%FB7$F\[u$"3(y&y%>==e(GFB7$F_hfl$"3QE.Hu3<*R"FB7$F_v$!3n@fSecMk5F<7$Fghfl$!36D7)="y&fh"FB7$Fd[u$!3[.WbRoy"4$FB7$F_ifl$!3x#)p!H'Gn.XFB7$Fhbn$!3u2"*QRKnBeFB7$Fg`\m$!3Y!>m+#*Qr-(FB7$F\\u$!3#Rov.$4c$4)FB7$F_a\m$!3')p/CF0C2!*FB7$Fev$!3C*p;Z(evd(*FB7$F\gw$!3`lT5'\Bb2"F97$F`cn$!3J&3*pu-=66F97$Fdgw$!3]#Qc&[v-$4"F97$Fjv$!3#p7`=g))o."F97$F_cp$!35$z"f"f!p#*))FB7$F_w$!3o'=U'yv![#yFB7$Fbhw$!3=$f:?d-vp(FB7$Fghw$!3%o"Gp;$p+j(FB7$F\iw$!3!*G@fE7**=wFB7$Fgcp$!3m#4%*)fE5ewFB7$Fdiw$!3HL%=&>E#>&yFB7$Fdw$!3ui$*f!Gh*G")FB7$Fjir$!3!)H9h_f[x$)FB7$F_dp$!3;3:&HZx:c)FB7$Fbjr$!3Xo_c)4i'Q')FB7$Fiw$!37'4(oBSK)e)FB7$F\ep$!34`!e!))y7R")FB7$F^x$!3t&z$)[N*QbuFB7$Fiep$!3`PNW<\5'3(FB7$Fddn$!3!)GRWh'o<#oFB7$Fh[dl$!3q*QMFx=&RnFB7$Fafp$!3CiU[;+y"p'FB7$F`\dl$!3`Ot:"p6nn'FB7$Fidn$!3MCO"=))p/p'FB7$Fcen$!3H)zjOe%p1pFB7$Fcx$!3!>S6pngq-(FB7$Fhx$!3^MdnFQQcjFB7$F]y$!3r*f[^:U8^&FB7$Fj[x$!3I*z31#pKPaFB7$Fby$!3M8q]*)*p8W&FB7$Fb\x$!3kubj$pe>\&FB7$Fgy$!3#pQ%*z<nva&FB7$F\z$!3hkmxM(Hrc&FB7$Faz$!3re**Q!)[)*>bFB7$Ffz$!3#>&**GZJ#HR&FB7$F[[l$!3#*el^"=_F>&FB7$Fe[l$!3K@.:'ou7u%FB7$F_\l$!3e$*o!4LauL%FB7$F^^[l$!3u'o.u#G;0UFB7$Fd\l$!3cc__7$\(HTFB7$Ff^[l$!30w$QI/7`5%FB7$Fi\l$!3Ed=m=OA;TFB7$Fc]l$!3(RZyT(ze8KFB7$Ffhil$!3mwbJRkWDIFB7$Fh^x$!3Nz%*)\FfG)GFB7$F^iil$!3E:G2X-_$z#FB7$Fh]l$!3f")\OeSp`FFB7$F`_x$!3F'*)oCB)>\FFB7$Fe_x$!3(zFUYZt&eFFB7$Fj_x$!3Rp)4=_Sxv#FB7$F]^l$!3A*o">9,9DFFB7$Fb^l$!3&oc_Gz%\.@FB7$Fg^l$!3s:3g=hFR9FB7$Fibu$!33,]<:AC#R"FB7$F^cu$!3**)\\%*)4Qx8FB7$Fccu$!3cMprb4.y8FB7$F\_l$!3rU2(\'ygu8FB7$$!3gm;HK/%R;"FB$!3_*Ge&>wX[8FB7$F[du$!38<)>(o>]&G"FB7$$!3wnmT&Q%er'*F<$!3.r4"p.o*y6FB7$Fa_l$!31A(RF7v1."FB7$Fi_s$!35(pR3#HJTiF<7$Ff_l$!3&fl[DY6&oCF<7$Fdax$!37*z\\@[k="F<7$Fa`s$!3r#)*=!))eC!3%F]`l7$F\bx$!3sTmF14@xnFcv7$F[`l$!3:!R^/!o[dEFjddl7$Fdbx$"3g#pp%4HNQDFcv7$Fj`s$"3NXCEr[/!o#F]`l7$F\cx$"3or,)yZA#*R*F]`l7$Fa`l$"3#edeHP')z9#F<7$Fbas$"3BAJCa/YYfF<7$Ff`l$"3o<-!oo9%>5FB7$F^c[l$"3`7G"4a%)p;"FB7$F_eu$"3Qzx+i)o`F"FB7$Ffc[l$"3%)z<n=&R?M"FB7$F[al$"3c2^qGLHs8FB7$Fgeu$"3M\Rts.Iy8FB7$F\fu$"33*oN6bhoP"FB7$Fafu$"3&G!GI&\'G'Q"FB7$F`al$"3qf%HG6pHU"FB7$Feal$"3))G46#\[7-#FB7$Fjal$"312>#y7@**o#FB7$Ffdx$"3>cKVx1/ZFFB7$F[ex$"3Hmg9!fb3w#FB7$F`ex$"3HCgerGh_FFB7$F_bl$"3hIU)>#[/\FFB7$$"3K)**\P\OV*HFB$"3'GmOOL7ix#FB7$Fhex$"3:$p-&3yS`GFB7$$"3%=L$ek(z%3KFB$"3M$Q9=QM&))HFB7$Fdbl$"3DIv-&4fg<$FB7$F^^q$"3bkwk5=U=OFB7$Fibl$"3yHvgJI$)*)RFB7$$"3/(*\7y0#py$FB$"3QG"RDrV90%FB7$F_cs$"3Gy')>#3a!)4%FB7$$"3q'*\P%Gp;*QFB$"3?]d45F#)HTFB7$F[_q$"3Qn%z!o;vZTFB7$Fgcs$"3`[7'y>*)*\TFB7$F^cl$"3G(oLuZtn7%FB7$Fbg[l$"3Ctb"\+)p1TFB7$Fccl$"3N]j5z-0:TFB7$Fi\jl$"3fHbq^ehOTFB7$Fjg[l$"3h;Rnm4FsTFB7$Fa]jl$"3Ax6m,c+BUFB7$Fhcl$"3A*fC:*=-*G%FB7$Fbdl$"3(RjlR&QN#o%FB7$F\el$"3@k!GRE'G_^FB7$Fael$"3g734VsVl`FB7$Ffel$"3$*z6O@GY1bFB7$F[fl$"3PXw93")>lbFB7$F`fl$"3()*Q5$=O__bFB7$F^hx$"3/Xut;9O)\&FB7$Fefl$"3k%RP#\CoWaFB7$Ffhx$"3k;4<?I7NaFB7$Fjfl$"3>f6>tat.bFB7$F_gl$"3))fdhQeh)R'FB7$Fdgl$"3+$GRBa04.(FB7$F^_o$"3[*)f^xZ+voFB7$Fh_o$"3,:$pUX&)Go'FB7$Fe\el$"3`()y[A3(zn'FB7$F[aq$"3")zC0;]v+nFB7$F]]el$"3KtE$)yz:anFB7$F]`o$"3'*>1g2!e$RoFB7$Fcaq$"3:][:7MX+rFB7$Figl$"3-6&e"ph>cuFB7$F`bq$"3Rie%eaT*f")FB7$F^hl$"3+D8R'HmBg)FB7$$"3"*)\ilsKu(zFB$"3(Hx#>mB!ej)FB7$Fifs$"3mhZFBw\M')FB7$$"3mK3-))=Ev!)FB$"3E_vbQxI*f)FB7$F]cq$"3Z#=Rbu,G`)FB7$Fags$"3=RSi3cOC$)FB7$Fchl$"3gb#y[jE01)FB7$Fg\v$"3Nv>D$*)Q%*y(FB7$Fecq$"3!4-N>5b*HwFB7$Fb[y$"3=3,Du$\">wFB7$Fd]v$"3O#*G"*o7ClwFB7$Fj[y$"3kWHjJp<txFB7$Fhhl$"3())>#4$p0Z%zFB7$F]dq$"32!\zYAZ]<*FB7$F]il$"3pV$)Rs0(R1"F97$F[g]m$"3fsif\3=)3"F97$Fj\\l$"3?7i%3&yf/6F97$Fhg]m$"33,a'yMl96"F97$Fedq$"3:y]0u@?26F97$Fb]\l$"3J&R%*>s7-1"F97$Fbil$"3nf3EG<In&*FB7$F^]y$"3%\rbEmX&ezFB7$F]eq$"3=!*QHNx2KeFB7$Facjl$"38M"[FCG$4YFB7$Ff]y$"3'=!QY0"HaI$FB7$Ficjl$"3**z:>#yhD%>FB7$Fgil$"38.;ko>WZaF<7$Fgigl$!3p-bx'=`[E*F<7$F^_v$!38u[[ZbWzBFB7$F_jgl$!3X0:m@Mu&y$FB7$Fgao$!3#[+]cmx&=^FB7$Fij]m$!3NM\jI7k`jFB7$Ff_v$!3Y\tclF#*puFB7$Fa[^m$!3*4^!G8_P]%)FB7$F\jl$!3?W:;haU#G*FB7$Fj^y$!3%ofM9o>v/"F97$F_bo$!3`nIbqz\/6F97$Fiejl$!3?Pboz$f:6"F97$Fb_y$!3KPjLW%oh5"F97$Fafjl$!3/y5ql14!4"F97$Fajl$!3W#>@2`6`1"F97$Fafq$!3qE/<He&=D*FB7$Ffjl$!3K%y8Z4A.-)FB7$F``y$!3y!HB=BNG$yFB7$Fe`y$!3y\rAm[#Rq(FB7$Fj`y$!3GVw'*evHLwFB7$Fifq$!3wZSXiRy<wFB7$Fgay$!3)fSd)H$*>FxFB7$F[[m$!3rd,=?p]kzFB7$Fijs$!3!>a$*R:(Re#)FB7$Fagq$!3(o>6U^Xb])FB7$F_cel$!3gFSL3)ose)FB7$Fa[t$!36:Ds]J0K')FB7$Fgcel$!35Kh'3Y"4O')FB7$F`[m$!3)3w5N`&3)f)FB7$F^hq$!3u!G6Vh')43)FB7$Fe[m$!3+=9.EV"[I(FB7$F[iq$!3YC^QFH%G*pFB7$Fcco$!3YeX*Ha22y'FB7$Feeel$!33UPXJr-=nFB7$Fciq$!3>t*)*yXMUo'FB7$F]fel$!3;2\sj'etn'FB7$Fj[m$!3CLgL2n/%p'FB7$F`do$!3a"y^SD7\*oFB7$F_\m$!39<5)Hor5.(FB7$Fd\m$!3!z]3MDT'=jFB7$Fi\m$!3%4(*RX<WHY&FB7$Fbdy$!3kV[I\n-JaFB7$F^]m$!3?2@ntV:eaFB7$Fjdy$!3Puuvxs!G^&FB7$Fc]m$!3))z$\M[n'ebFB7$Fh]m$!3u)[%ojisibFB7$F]^m$!3!G_R7!)pB]&FB7$Fb^m$!3W[LO8&[*p`FB7$Fg^m$!3RIw1r$HR<&FB7$Fa_m$!3a;xQVL)ys%FB7$F[`m$!3#o(3Ldf`LVFB7$Ffd\l$!3=+G<;NN/UFB7$F``m$!3A](R4c#=ITFB7$F^e\l$!3(fGEE!QT0TFB7$Fe`m$!3/]K$)R">`6%FB7$F_am$!3!e/&fk<ovJFB7$Fg][m$!3tIpG<*)f+IFB7$F`gy$!35,VYp$4(pGFB7$F_^[m$!3]VPvKVe)y#FB7$Fdam$!3PD^t![hGv#FB7$F]hy$!3NNsH)zk$eFFB7$Fiam$!3'4YziV#4IFFB7$F^bm$!3e]!>+9vg8#FB7$Fcbm$!3h,k"HD'Qb9FB7$Fifv$!3#px#)ei([)R"FB7$F^gv$!3w@0[!R'Gy8FB7$Fcgv$!3@[(H%)4FxP"FB7$Fhbm$!3-@SX"p=eP"FB7$$"33+](o:gF)=F9$!3iP<2P]*>N"FB7$F[hv$!3gi<@')yN!H"FB7$$"34+]i!**yH!>F9$!3"\JdGEJH="FB7$F]cm$!3]$))*oEWEJ5FB7$Fh`t$!3"o7)\:x=[hF<7$Fbcm$!3'=I)[;D%4L#F<7$F\jy$!3#R-(y8P[r5F<7$F`at$!3m"4c_d,[P$F]`l7$Fdjy$!3$QGCF9^cP%Fcv7$Fgcm$!3#R'R]a7^EjF[[_mF[dmFcdmFfimFjhm-Fjgm6%FbimQIThe~14~term~Fourier~approximation~(blue)F(FdhmF]jmFajm7*-F,6$7g]l7$F0$"3S-<x*)ob2_F57$F>$"3xdg#[(oXloF<7$FD$"3>6b)=(Q!H@"FB7$FI$"3=x&pp\9;%=FB7$F\]z$"3p"\i?i]7">FB7$F_jo$"3SFk1.:OM>FB7$Fd]z$"3E3S^BrgK>FB7$FN$"3'RZjx*QVM>FB7$Fedt$"3Oc@Q6^kn>FB7$Fgjo$"3S@!f&[=1_?FB7$F]et$"3Gc5&=8-U>#FB7$FS$"3d<(=!)e)R&Q#FB7$Fgn$"3$\Kj#y1H6KFB7$F\o$"38/zMB9tdOFB7$Fao$"3nx;vP>EcWFB7$Fj_z$"3PaZ_>pGBXFB7$Ffo$"3$[_"3j`#p`%FB7$Fb`z$"3iF#>O!>`:XFB7$F[p$"39,3%**y-g[%FB7$F`p$"3Q*HJ[2JyZ%FB7$Fep$"3P0")[!y4k^%FB7$Fjp$"3"QjifS)3<YFB7$F_q$"3Qdwx<vN"y%FB7$Fiq$"3HFc-0UE`_FB7$Fcr$"325>LGkC)o&FB7$Fed[m$"3.6r<=4HhdFB7$F\_w$"3_G!**3,^_"eFB7$F]e[m$"34FGDe%)f\eFB7$Fhr$"3Wh_FDg,leFB7$Fd_w$"3J.#yL-fw%eFB7$F]s$"3Q=QQg&G.z&FB7$Ffgt$"3[y7"4dQ'HdFB7$Fh]n$"3bpk?$y-9r&FB7$F\acl$"3&QP!o#*e$)HdFB7$F^ht$"3+rQ(Gib2x&FB7$Fdacl$"3quQ2:W^NeFB7$Fbs$"3!y%>2j(3R#fFB7$Fe^n$"3*)oe;<h"oX'FB7$Fgs$"3sB_o+***\,(FB7$$!3?+]7t(Q)G8F9$"3FuK>[#[B6(FB7$Fb_n$"3l*)z8/H,%=(FB7$$!3QL$3xVl#=8F9$"3kKJE@y'zA(FB7$Fg_n$"3_C`y)fhRC(FB7$Fgh[m$"3p`#H3y(eLsFB7$F\`n$"3ov>u2tB+sFB7$F_i[m$"34rW58F$*[rFB7$F\t$"37FxW'=^g3(FB7$Fg^p$"3x'4v^g@b&pFB7$Fd`n$"3G0`"R<")3(oFB7$Fhccl$"3/wF$G.cN'oFB7$F__p$"3fw8yK:r')oFB7$F`dcl$"3O&y/*4/_VpFB7$Fat$"3p8%=U")\].(FB7$F\`p$"3'fDi+KfYr(FB7$Fft$"3yU47(*o$R\)FB7$F^ecl$"3;DF:;2JF')FB7$Ffer$"3QO"e;9!p=()FB7$Ffecl$"3AC3&f"H8j()FB7$Fi`p$"3\@&4UA1(e()FB7$F^fr$"3G5Dbm:97')FB7$F[u$"3LxEgtt#)H$)FB7$F_bw$"3#G<TR))eV/)FB7$Fffr$"3n;lDFmL5yFB7$F\cw$"3n#[&pjO!)QxFB7$Facw$"3")Hy!3@%)*4xFB7$Ffcw$"3)\AnQ6W7t(FB7$F`u$"3@Lzy"38y!yFB7$F^gr$"30[#p6&Gfw')FB7$Feu$"3%\RSbe#[55F97$Fddw$"32(H$=DrN!3"F97$Fhan$"3^7!enB#*\6"F97$F\ew$"3uS#)*QfHQ4"F97$Fju$"3$*G'*HZGI-5F97$F_^\m$"3-%Gg%)\43G*FB7$Fdjt$"3nBZ16aN^$)FB7$Fg^\m$"3@cvcg*>aC(FB7$F`bn$"3<B<G$*Rj!)fFB7$Fggfl$"3/C_z7+$4e%FB7$F\[u$"3dS)oe3lc2$FB7$F_hfl$"3)[R'G5@[)\"FB7$F_v$!3p'4kDfn.9"F<7$Fghfl$!31P.Q$p6/t"FB7$Fd[u$!3nc,+J?o0LFB7$F_ifl$!3Gt$[]ggJ![FB7$Fhbn$!3d]%Hs.j$*='FB7$Fg`\m$!3'yC%*3*RNNuFB7$F\\u$!3-*)4!)p6(y^)FB7$F_a\m$!33L@_SP<?%*FB7$Fev$!3(=EzykdK,"F97$F\gw$!3mE4`Kl])4"F97$F`cn$!3u"RYaV3Q6"F97$Fdgw$!3$RY2T?JY2"F97$Fjv$!3zU(*))f\:-5F97$F_cp$!3E'>uyo,s\)FB7$F_w$!3K"oX'e*fQt(FB7$Fgcp$!3V%*3&om-G&zFB7$Fdw$!3ioz,gy\Y&)FB7$$!3IL3FW(*pZ#)FB$!3=BM5Sy>[')FB7$Fjir$!3Vnn3'4<7s)FB7$$!3p*\7GjOH:)FB$!3Ep1;y[zg()FB7$F_dp$!32?;`*4*3k()FB7$Fbjr$!3]***orsO-m)FB7$Fiw$!3')*fx@MIZU)FB7$F\ep$!3+f"*f#=v9t(FB7$F^x$!3wz1:%***z2rFB7$$!3En"Hd:N1[(FB$!3)p)\RhvD*)pFB7$Fiep$!3@F8hhOq4pFB7$$!3fK3_]E&zO(FB$!3!\RuK5R#poFB7$Fddn$!3N9lP/n8loFB7$Fafp$!3Q_;NGP(H%pFB7$Fidn$!3K4tC/,J!3(FB7$Fcf\m$!3=8T4=hsZrFB7$F^en$!3i&eVU8p@?(FB7$F[g\m$!3))=s"oHXfB(FB7$Fcen$!3joHC&HCJC(FB7$$!37o"zW7SX!oFB$!3v\=DC#3*>sFB7$Fhen$!3c$eCUHO[;(FB7$$!3WL3F>w&=p'FB$!3UD^gnf")yqFB7$Fcx$!3S8_2yN)\'pFB7$Fefn$!3c;klwV0^kFB7$Fhx$!3@t^M(=8:'fFB7$Fb^u$!3GH/yC<D/eFB7$Fbgn$!3-G![2P<Ns&FB7$Fj^u$!3(**=)*R9XIr&FB7$F]y$!3v,6x'pEBv&FB7$Fj[x$!3khC=3Uk?eFB7$Fby$!34=0*4kSW'eFB7$$!3SM3x1RE%f&FB$!3H*Gk@^uK'eFB7$Fb\x$!38dOeX\cTeFB7$$!3u+D"G)[A$[&FB$!3)[kUrm2tz&FB7$Fgy$!3wnoxW5:IdFB7$Faz$!33P'z<"Hrz_FB7$F[[l$!3$eOJ!eOhpZFB7$F`[l$!3+je%GI=+h%FB7$Fe[l$!3q0mS(RYL^%FB7$Fj[l$!3%\&Gb]6UxWFB7$F_\l$!3#=-PL#Gt'[%FB7$F^^[l$!3S$Qs\!)>i^%FB7$Fd\l$!3UC7]b%Qq`%FB7$Ff^[l$!3*HP$3o)3I_%FB7$Fi\l$!37\'3D_5jX%FB7$F^]l$!3;eBG%3J'\OFB7$Fc]l$!3'32FQ5w6@$FB7$F]^l$!3&3N:"zN.WCFB7$Fcau$!3,9Zyri%=C#FB7$Fajp$!3)o4:G-UV3#FB7$$!3*H$eRsN=XAFB$!3g#fqd;4p-#FB7$F[bu$!3)=KWS*QC%)>FB7$$!3ImTNr-/Q@FB$!3"RkyA=@b&>FB7$Fb^l$!3'yc=j\$)*Q>FB7$F\a[l$!3p;2%Q`k:$>FB7$Fijp$!34IyMxJ?N>FB7$Fda[l$!3x"[?o3'[?>FB7$Fg^l$!3<$H+qoUJ'=FB7$F\_l$!3fIC]3)Q_B"FB7$Fa_l$!3k*HzQ-\'[oF<7$F[`l$!3@iG;9(zc%RF]`l7$Ff`l$"3KI(Qp&*)R9oF<7$F[al$"3U,+v]o^-7FB7$F`al$"3z'\O-,55%=FB7$Fdd[l$"3.Ev/'GA(4>FB7$Fc\q$"3O`]K+&=R$>FB7$F\e[l$"3'*39nAP1L>FB7$Feal$"3"*3%fObpI$>FB7$F_gu$"3XN5iC&**)f>FB7$F[]q$"3+@Q&=5'4L?FB7$Fggu$"3e/ld#=N3;#FB7$Fjal$"3YwSCgFvPBFB7$Fdbl$"34%))*pc8e6KFB7$Fibl$"3T#yopI[pe$FB7$F^cl$"3OCW%oVaxS%FB7$$"3"f\(oHf@/UFB$"3O7Q(yTvHY%FB7$Fbg[l$"3JunF`MW-XFB7$$"3/'\i!*olbI%FB$"3)e5o8TVm_%FB7$Fccl$"3))3TAvI*p`%FB7$Fjg[l$"3-\Dh[5)f_%FB7$Fhcl$"3)[:*yf&R`\%FB7$F]dl$"31t#QYaMkZ%FB7$Fbdl$"3S`-U8eo)\%FB7$Fgdl$"34K.86tW#e%FB7$F\el$"3[_?LG<&Qt%FB7$Ffel$"3mDr;])p,C&FB7$F`fl$"3%*)G%QwQ'3r&FB7$F\a]m$"3;C>$*=<<%y&FB7$F^hx$"3g!o=_Y=T$eFB7$Fda]m$"3))y\:q:pgeFB7$Fefl$"37$HX!y)Hc'eFB7$Ffhx$"3#HY"3dTjDeFB7$Fjfl$"3w&[Io%RacdFB7$F`ju$"3Md@bc)pLr&FB7$F_]o$"3CFNcS_TDdFB7$Fhju$"3g*Q"[u7y;eFB7$F_gl$"3yp"z<#p_$*fFB7$F\^o$"3oB?"4s'=GlFB7$Fdgl$"3'=L6S!*)eWqFB7$Fh_o$"3nb.&fvdg0(FB7$Figl$"3G$z8To[$3rFB7$F`bq$"3pKtZ$)*3gv(FB7$F^hl$"3/39%z#44i%)FB7$Fcdam$"3[FO]XGv!f)FB7$Fifs$"3hb"Hu&p0(o)FB7$F[eam$"3:'e/,n&pY()FB7$F]cq$"3&>jm6#=An()FB7$F_ggl$"3&*=D`OTF[()FB7$Fags$"3cq]9A9q"p)FB7$Fgggl$"38LJ$ylu:g)FB7$Fchl$"3dPNfe93%[)FB7$Fg\v$"3))G!yp6cL<)FB7$Fecq$"3%H-<@!)e(yyFB7$Fb[y$"3Q:)HtJhVx(FB7$Fd]v$"37b&4bucqr(FB7$Fj[y$"3u`CznFK=xFB7$Fhhl$"3YeG2;qk'y(FB7$F]dq$"3YJ'*zf0ed()FB7$F]il$"30ry9b*G_."F97$Fj\\l$"351X!\M)G$4"F97$Fedq$"3A9@C+4#e6"F97$Fb]\l$"32-OVTu&o3"F97$Fbil$"3')e-Z+8?b**FB7$$"3i(\i:::$G'*FB$"3h)=SOI!=]#*FB7$F^]y$"3w%))3iI%G#Q)FB7$$"3HjTN'p\*G(*FB$"3)oz*4\@FgtFB7$F]eq$"3e!=II5K")>'FB7$Facjl$"3mMB/)e)o9\FB7$Ff]y$"3qaA`Xt+LNFB7$Ficjl$"34%)3)3bA'z?FB7$Fgil$"3;Cjc1_<OeF<7$Fgigl$!3Fq;:'Q1[#**F<7$F^_v$!3>qq5cgFYDFB7$F_jgl$!3I'3[0*G@VSFB7$Fgao$!3S@e%)e-&4X&FB7$Fij]m$!3*zh%GOKgSnFB7$Ff_v$!35UZ"\6Cy)yFB7$Fa[^m$!3>Csv3\nt))FB7$F\jl$!3kL$=Hd__o*FB7$Fj^y$!3FCoPdvfw5F97$F_bo$!3SgRs#)4P:6F97$Fb_y$!3#Q>P34>i4"F97$Fajl$!3(R1ev&\$p."F97$Fafq$!3q+rT)Rp5$))FB7$Ffjl$!3)Q5X4&>&y#yFB7$F``y$!3yC57I\vOxFB7$Fe`y$!3A4!>wm[)4xFB7$Fj`y$!3]Q,#zJz3u(FB7$Fifq$!3*z=(>`tt?yFB7$Fgay$!3L`s+p&Q/3)FB7$F[[m$!3RL[f)yumQ)FB7$Fijs$!3/^LZ%>l&[')FB7$Fagq$!3k'[k()o3aw)FB7$F_cel$!3%z?%[5#)fa()FB7$Fa[t$!3E2(GrYPhp)FB7$Fgcel$!3/HAhS%GGf)FB7$F`[m$!34wS(oeW-X)FB7$F^hq$!3BIb!4!Q0lwFB7$Fe[m$!3!*3,K=?d8qFB7$Fedel$!3Z@9O7[SIpFB7$F[iq$!3#>*[AKAh!)oFB7$F]eel$!3p:0/9[#G'oFB7$Fcco$!3HBk'RBfP(oFB7$Fciq$!3oGMn]rygpFB7$Fj[m$!3<)H>(4aO*3(FB7$Fe`^m$!3&**yh!pLs]rFB7$F[do$!39r^D:vt+sFB7$F]a^m$!3NU?o**RTLsFB7$F`do$!3MRLnnj,WsFB7$$"3!oT5!H8-=8F9$!3TFQdhnJHsFB7$Fedo$!3WKi(pB[x=(FB7$$"36]7y+6RG8F9$!3I_;gi=X>rFB7$F_\m$!3:aK2A(=i-(FB7$Fbeo$!3io2-\4&GZ'FB7$Fd\m$!3qH"*>wDdMfFB7$Fagel$!3sH!ok0yP%eFB7$Fbbv$!3#y#G4VA\wdFB7$Figel$!39'oE-i'3LdFB7$F_fo$!3[Qdf?4P7dFB7$Fjbv$!3`7l(eH5ss&FB7$Fi\m$!3p-k@U"*p'y&FB7$Fbdy$!3%**eh5^Lj%eFB7$F^]m$!3,9n_1)z]'eFB7$F]d^m$!3Fyi4aj@\eFB7$Fjdy$!3r.7l9]V8eFB7$Fed^m$!3+G!pYgOqv&FB7$Fc]m$!3d>nPB!f1o&FB7$F]^m$!3W$evw,u!H_FB7$Fg^m$!3XVO$*o$pDv%FB7$F\_m$!3TkO/%eH0g%FB7$Fa_m$!3)3Unk9%o4XFB7$Ff_m$!3xoO_Pk0xWFB7$F[`m$!3H(f7A-Kt[%FB7$Ffd\l$!3zAzQ"f`k^%FB7$F``m$!3)Q'p9*=sp`%FB7$F^e\l$!3AcNDG#yR_%FB7$Fe`m$!3BCEM%eV.Y%FB7$Fj`m$!3$H]25:RVj$FB7$F_am$!3qe/!*=+f6KFB7$Fiam$!3eQKFAe(RY#FB7$Fcbm$!3UeRRu"3#z=FB7$F]cm$!3Ap#)o!310&oF<7$Fgcm$!3S-<x*)ob2_F5F[dmFcdmFigmFfimFjhm-Fjgm6%FbimQIThe~15~term~Fourier~approximation~(blue)F(FdhmF]jmFajm7*FigmFfim-F,6$7ex7$F0$"3$H&Rwc")G[OF57$Fdiv$"3-)p;\Aj1q&Fcv7$Fg_r$"3I[&3av!*yM%F]`l7$F]jv$"3z6KqNf%[N"F<7$F7$"3jayJ.'R2(GF<7$F_`r$"3MK@'oe/2-(F<7$F>$"3fpflC$))H1"FB7$FD$"3I))HOh!30@"FB7$FI$"3['QNO'4vm9FB7$F_jo$"3p"3]X37A(=FB7$FN$"3..g$G%y%)\AFB7$$!3V;ajk#f*)y"F9$"3%p9]sC**RJ#FB7$Fedt$"3i&p2%>cpiBFB7$$!34]iSr[Hy<F9$"3_g16C#)>'R#FB7$Fgjo$"3F%GL$GL#fT#FB7$F]et$"3$*>K'Qh)zCCFB7$FS$"3T&*\gJ'R!=CFB7$Fgn$"3g@x$pNRYc$FB7$Fao$"34kt8$HOh9%FB7$F_q$"3[Z]u\P3-[FB7$Fcr$"3Qez:9w8G`FB7$F]s$"3hYb4h*\%4hFB7$Ffgt$"3BL$H>?a_7'FB7$Fh]n$"3!R8/(yVotgFB7$F^ht$"3#p.su*)G"**fFB7$Fbs$"3e9Oy(>u\&fFB7$Faf[m$"3Ruhgh8iffFB7$F`^n$"3v$>118,"))fFB7$Fif[m$"3S?g[pa*G/'FB7$Fe^n$"3qIXyPGcChFB7$Fj^n$"3>c*e&)fF2O'FB7$Fgs$"3`))RC_MximFB7$Fb_n$"3Lw:bZk;upFB7$Fg_n$"3e'QHI7(QMsFB7$Fgh[m$"3zGBzYC")GtFB7$F\`n$"3yd$*e)>wNR(FB7$F_i[m$"3%4*=sVJ"oU(FB7$F\t$"3_%>Wm_l*GuFB7$Fd`n$"3C-"*QuJ(R@(FB7$Fat$"3lSoi!zDe-(FB7$Fft$"3We![F>(eu")FB7$F[u$"3#=#H:d*[!3()FB7$Fffr$"3'R9vQoIx7)FB7$F`u$"3CV0[T62#z(FB7$F^gr$"3kOA[B2AT$)FB7$Feu$"3Ag"\*4jbP(*FB7$Fddw$"3aLyty?zc5F97$Fhan$"3sF=1odM66F97$$!3am"HdjL*e5F9$"3/#e2^*ed>6F97$F\ew$"3]3w&QBZ66"F97$$!30+vo9$\"[5F9$"3o!)R)>z9P3"F97$Fju$"3wV./4#>c."F97$F_^\m$"3zPoAG&[+m*FB7$Fdjt$"3]G)3n;!)*[()FB7$Fg^\m$"3#pb5PM)RKwFB7$F`bn$"3a]WwP7rGjFB7$Fggfl$"3bns!Gn"pk[FB7$F\[u$"3Q2uYTERuKFB7$F_hfl$"3]seZ0dm(f"FB7$F_v$!3!=&)\l'*)Q;7F<7$Fghfl$!3=?i^P(oY%=FB7$Fd[u$!3m+4U9M==NFB7$F_ifl$!3_c%pH!RE)4&FB7$Fhbn$!3=.S*4UX`a'FB7$Fg`\m$!3a4fil7,EyFB7$F\\u$!3o!p)f*oYW"*)FB7$F_a\m$!3g#[_>@vMz*FB7$Fev$!3*oH!G$[7b/"F97$$!3w++](e6*3&*FB$!3$=;e$o*p+4"F97$F\gw$!3o7;\#>OS6"F97$$!3e++voqpF%*FB$!3sEln*oO)=6F97$$!39++]ibi+%*FB$!3o]O&ptD#>6F97$$!3q***\i0aNP*FB$!3!G\.W-Mb6"F97$F`cn$!3(pWgvXC"36F97$Fdgw$!3\@](4Sw$\5F97$Fjv$!3M*))y%\gGY'*FB7$F_cp$!3o(H#=*3?b>)FB7$F_w$!3PVP`pYU3yFB7$Fgcp$!3$R[))Q21)G$)FB7$Fdw$!3v&yWZo6n%))FB7$Fiw$!3X/&**>u8&z!)FB7$F^x$!3%*or')HAFMqFB7$Fddn$!3(f`W&Qd2)=(FB7$Fidn$!3wsnbumwFuFB7$Fcen$!3GaM,Y2"\@(FB7$Fcx$!35>*fTB&f$f'FB7$F`fn$!37xGUskGGjFB7$Fefn$!3M3UB')R,@hFB7$$!3gnmT5U(oR'FB$!3$)GzDTU@ZgFB7$Fjfn$!3U1We8x<&*fFB7$$!3'om;zM<9I'FB$!3pT59T*fY'fFB7$Fhx$!326^ywd8afFB7$Fbgn$!3()[C$**="4XgFB7$F]y$!38Cg9KLvGhFB7$Fgy$!3w\`MIQ8(R&FB7$F[[l$!3d"yGeixC![FB7$Fi\l$!3/P6'4<Zi9%FB7$Fc]l$!3T;n/ni&pb$FB7$F]^l$!3Eh)RvgozT#FB7$Fg^l$!3?LVrj5I3:FB7$Fibu$!3gywFEi'RO"FB7$F^cu$!3r!R1p'*4"p7FB7$Fccu$!3E*G>NloCA"FB7$F\_l$!3%oX>*R<f57FB7$Fef`m$!3/'4L+nA8@"FB7$F[du$!35["\5H^%*>"FB7$$!3tm"zp$RN;5FB$!3(pb^$3)f;="FB7$F]g`m$!3;amjC95`6FB7$$!3>o;/,%H'z"*F<$!3imC=^-Z76FB7$Fa_l$!3,()[N!GT#f5FB7$Fi_s$!3H>Z6xn$>2(F<7$Ff_l$!3)*=e;!=0#3IF<7$Fdax$!3%=a0(Q1f$["F<7$Fa`s$!3a"4s@m7$)>&F]`l7$F\bx$!3U()QcIShN()Fcv7$F[`l$!3=8%4ojn;W$Fjddl7$Fdbx$"3bUHx7-azKFcv7$Fj`s$"3**=&)3i"o'GMF]`l7$F\cx$"3J*QN+C[<="F<7$Fa`l$"3Ig.QHV*Qj#F<7$Fbas$"3/nLr&3\#ynF<7$Ff`l$"3kaYU,18^5FB7$F[al$"3d@#Q`/:0@"FB7$F`al$"3*o2jSr/dY"FB7$Fc\q$"3_M)*oRdje=FB7$Feal$"3'pq)>+XSKAFB7$F_gu$"34tIad8**\BFB7$F[]q$"3>Tl_gxW5CFB7$Fggu$"3W9'o1wH`U#FB7$Fjal$"3=b#*>$)f@>CFB7$Ffdx$"3lLv#R^wNU#FB7$F[ex$"3&\E6KG%fpCFB7$F`ex$"3OKuVqnLwDFB7$F_bl$"3@Vd(pYV[u#FB7$Fhex$"3Kd*z'>E?$=$FB7$Fdbl$"3j1_%H7Gq`$FB7$Fi]q$"3')*fAa()[.i$FB7$F^^q$"3!H%\!3>S]k$FB7$Fc^q$"3;_ji1G;LOFB7$Fibl$"3QImR$yCyh$FB7$F_cs$"3-p_$QYVQj$FB7$F[_q$"3$4Bmsq;xq$FB7$Fgcs$"3^fEzuIx\QFB7$F^cl$"3FK;.su!30%FB7$F\el$"39PX3_@z/[FB7$Fjfl$"31&Q9[65!GhFB7$Fdgl$"3=e$\dn`qq'FB7$Fi^o$"3Wfggk$o4-(FB7$F^_o$"3B()\fT&R>F(FB7$F[c]m$"3"y>kg<%QdtFB7$Fc_o$"3ujRFz&*)3T(FB7$Fcc]m$"3%))o3&*oC9V(FB7$Fh_o$"3d"H'4Yl]?uFB7$F]`o$"3)zW>CfAZ<(FB7$Figl$"3?Fx:P&yV.(FB7$F^hl$"3a[x\'3m*H")FB7$Fchl$"31.&\8&4Q9))FB7$Fecq$"3&=/![/&*)4B)FB7$Fhhl$"3aS<s9CN"z(FB7$F]dq$"3aBf)*Q^#)4%)FB7$F]il$"3A'3tzc$o,5F97$Fj\\l$"3X9\/V?Ju5F97$Fedq$"3!zB2Qlmh6"F97$$"3#zC"yDu)=S*FB$"3-rS()p4I>6F97$$"3<l"z>1YqU*FB$"3;B9xdl*)=6F97$$"3J"3x")p/AX*FB$"361-MN#)o96F97$Fb]\l$"3-I#p*\'Qk5"F97$$"3%3$3x11oF&*FB$"3`5sIG^-x5F97$Fbil$"3!3YSKJK%H5F97$Fdcem$"3)*4*e:"**eI'*FB7$F^]y$"3)e\eAZw(z()FB7$F\dem$"3i@sF.Zb\xFB7$F]eq$"3\vwjZ_ValFB7$Facjl$"3)[tHR)4M:_FB7$Ff]y$"3r(4wZny)ePFB7$Ficjl$"36l!olwSj@#FB7$Fgil$"3'R\W&4L$[A'F<7$Fgigl$!33*f3D'*Q%e5FB7$F^_v$!3'GZF([^Z7FFB7$F_jgl$!3_AtluP5)H%FB7$Fgao$!3x#o@,(3#ox&FB7$Fij]m$!3I]0g8#4[6(FB7$Ff_v$!3_Cr0IBO%G)FB7$Fa[^m$!3x')>(GR!*\E*FB7$F\jl$!3oi<&yK:W+"F97$Fj^y$!3?nH%fM@*)4"F97$F_bo$!3Jl=,q7.=6F97$Fb_y$!3S%>m<G*[y5F97$Fajl$!3!\kcO`dO+"F97$Fafq$!3&R$HpEmVt%)FB7$Ffjl$!33G>Fo<z%z(FB7$Fifq$!3eRMvn<bW")FB7$F[[m$!3Q)*[&RZv4v)FB7$F`[m$!3o8&)o+(eP6)FB7$Fe[m$!3A4MP#GEf-(FB7$Fcco$!356?7&))fMA(FB7$Fj[m$!3g*p$H-McHuFB7$F`do$!3zw*3f#yGPsFB7$F_\m$!3N.))Q?tBzmFB7$F]eo$!3gWtDLwBvjFB7$Fbeo$!3"zd%o"*3iMhFB7$Fab^m$!3.">m3[4-0'FB7$Fgeo$!3MnF#pC*f#*fFB7$Fib^m$!3Wu=Q!*=WhfFB7$Fd\m$!3rQ))f!=^W&fFB7$Fbbv$!3O*fjK9]b*fFB7$F_fo$!3b_B:1c#)pgFB7$Fjbv$!3c)zN^(z(Q7'FB7$Fi\m$!38K](>]:D6'FB7$Fc]m$!39PMN#)*emJ&FB7$Fg^m$!3fQYma)oL![FB7$Fe`m$!3'oF'>*4!fbTFB7$F_am$!3M(H\ex8o`$FB7$Fiam$!3L+Rqa$y$=CFB7$Fcbm$!3tHa!*o/PY:FB7$F]cm$!3J=X5VCmf5FB7$Fgcm$!3$H&Rwc")G[OF5F[dmFcdmFjhm-Fjgm6%FbimQIThe~16~term~Fourier~approximation~(blue)F(FdhmF]jmFajm7*Fjhm-Fjgm6%FbimQIThe~17~term~Fourier~approximation~(blue)F(FdhmFigm-F,6$7jx7$F0$"390:n&o+na#F57$F>$"3a'pBxX54*oF<7$FI$"32itMm"\Fr"FB7$FS$"3(e'ygsOveEFB7$Fgn$"3,Ax1Y\%)\KFB7$Fao$"3)*Hw;&Q(y"*RFB7$F_q$"3j!oa].#*f<&FB7$Fdq$"3tddCx,Zc^FB7$Fiq$"3`^#)f0$eD6&FB7$F^r$"3sVJ0PF_*3&FB7$Fcr$"3%fm&fbxlF^FB7$Fhr$"3U/z2iw:_aFB7$F]s$"3S%*p7o*4'ofFB7$Ffgt$"3Q84Yg4k#>'FB7$Fh]n$"3!\vx=iV#GjFB7$F^ht$"3dW+qJjKhjFB7$Fbs$"3wA+4O^k6jFB7$F`^n$"3i+!Q,e2yA'FB7$Fe^n$"3"f5V.56C<'FB7$Fag[m$"3Y-"=Xf%ythFB7$Fj^n$"3Gct*)**zw,iFB7$Fig[m$"3t2NVRYCfiFB7$Fgs$"3gKvv17nYjFB7$Fg_n$"3G$oTI4*z<pFB7$F\t$"3:VjdbIcuuFB7$Fhbcl$"3W!\m&Gf<]vFB7$Fg^p$"3QIFn8C%3f(FB7$F`ccl$"3M0zQ&enjf(FB7$Fd`n$"3@=ocZ9_pvFB7$F__p$"3f7klF\iVuFB7$Fat$"3'4]Q\2ASG(FB7$Fft$"3tvsz%R<,!yFB7$F[u$"3P&Ruex#zh*)FB7$Fffr$"3'fh*=/i(\\)FB7$F`u$"3(f&\/]%42#zFB7$Fe`]l$"3%zp[`K[x'yFB7$Fj`]l$"3c64]!)yiwyFB7$F_a]l$"3EJ>Ln'o`&zFB7$F^gr$"3%3A!yVb"z5)FB7$Fga]l$"3oS2Us(4li)FB7$Feu$"3l=]Uyn*fO*FB7$Fddw$"3a!*fu*ot"G5F97$Fhan$"30_eHK*)\+6F97$$!36$e*)frH;1"F9$"3rc1IzBy66F97$Fg\gm$"3^E>u$ob$>6F97$$!3(*\(oabPi0"F9$"3yClTS/wA6F97$F\ew$"3jc:k$yr:7"F97$F_]gm$"3"Hq7.`DR5"F97$Fju$"3T#=Xlc^R1"F97$F_^\m$"3@S<Pe`7+5F97$Fdjt$"3+KvZN['*>"*FB7$Fg^\m$"34Rza!43E+)FB7$F`bn$"36A#G0Nbwm'FB7$Fggfl$"3uqh-(\aW9&FB7$F\[u$"3nlSaJF$>Z$FB7$F_hfl$"3;]7#H`8np"FB7$F_v$!3U^dAW(4CH"F<7$Fghfl$!3bn*>xY;(e>FB7$Fd[u$!3(*36M'*p?HPFB7$F_ifl$!3Yi/wv7u)Q&FB7$Fhbn$!377yc%=d6*oFB7$Fg`\m$!3')>[x-MW)>)FB7$F\\u$!3(pN/gzuDG*FB7$F_a\m$!3+(>tiAtE,"F97$Fev$!3!R9`u#Res5F97$Fg`gm$!3]l:Z5$R'36F97$F\gw$!3wkF1_:cA6F97$F_agm$!3gK)f%=$>?7"F97$Fdagm$!3JWY:A#**p6"F97$Fiagm$!3%*p=KF[%z5"F97$F`cn$!3W%GpS%4L&4"F97$Fdgw$!3F(G?v(\U>5F97$Fjv$!3nKt)Hu1EF*FB7$Fbhz$!31')[q6pU)\)FB7$F_cp$!3[1PwuA"*3!)FB7$$!3G++](y9^*))FB$!3-t$37U-0%zFB7$Fjhz$!3#4@]![%))R*yFB7$$!3_,+]iz$H%))FB$!3I">M&R8zoyFB7$F_iz$!3"o.Y'eD&R'yFB7$Fdiz$!3cM)>!Q8#)4zFB7$F_w$!3&yGp`y.x,)FB7$Fgcp$!3Mu(>$Qty*p)FB7$Fdw$!33l;n!\kU'*)FB7$Fiw$!3)*3[WERS3xFB7$F^x$!3cT^MA7(>C(FB7$Fiep$!3!yS!Rro50uFB7$Fddn$!352kY/AZ`vFB7$Fh[dl$!3yAxGV,&=f(FB7$Fafp$!3'H'R:F'*)\f(FB7$F`\dl$!3C=-+?UlevFB7$Fidn$!3RWcSHlT#[(FB7$Fcen$!3L^D81?v))oFB7$Fcx$!3*zw@[foZI'FB7$$!3&om;a$zy(e'FB$!35+5D<PWOiFB7$F`fn$!3%)*z==()4D>'FB7$$!3Mom"H2JB\'FB$!3z"zk6q2@<'FB7$Fefn$!3uED./&=G<'FB7$Fjfn$!3ax=*=G)Q@iFB7$Fhx$!3MhIw**=A(H'FB7$Fb^u$!3G,)=1#\0ajFB7$Fbgn$!3ciFk88j_jFB7$Fj^u$!3')\i**>.jqiFB7$F]y$!37Ez)4O"y2hFB7$Fby$!3S`%ot:Z%fbFB7$Fgy$!3`\*QR^a?:&FB7$F\z$!37A$G)R9/"4&FB7$Faz$!3Rn41LeL3^FB7$Ffz$!3*eU$RIabb^FB7$F[[l$!3oX(f"Qa^v^FB7$Fi\l$!3/.K/*o2=*RFB7$Fc]l$!3a$f)y6y&QB$FB7$F]^l$!3P4.GmWb+FFB7$Fg^l$!3/"[&))3&yQr"FB7$Fa_l$!3tJ@(*3MWdoF<7$F[`l$!39*)z!Q/X[%RF]`l7$Ff`l$"3f$o(H=ND)y'F<7$F`al$"3EU^1;'*p7<FB7$Fjal$"3cGU@/\8?EFB7$Fdbl$"3;"z2U;Bk>$FB7$F^cl$"3K@CVn$e%zRFB7$F\el$"3&4,^*3J]s^FB7$Fael$"3N,V-Sn)>;&FB7$Ffel$"3p6dG(\LZ6&FB7$F[fl$"3Gvd$4&Qn*3&FB7$F`fl$"3?V<'z9T'R^FB7$Fefl$"3wd9bZN9MbFB7$Fjfl$"3q\%=hxTD4'FB7$F`ju$"3>7v&e]?&oiFB7$F_]o$"3_3*Q+cUUN'FB7$Fhju$"3$>_ym:(Q]jFB7$F_gl$"3V)R[a#\6&G'FB7$Fg]o$"3boY#3T_n?'FB7$F\^o$"37o2FfR,qhFB7$$"3QI$eR_P=_'FB$"35e&3yVU?='FB7$Fa^o$"3W;T>F"='>iFB7$$"39(*\(o>_Hi'FB$"3o*3&\2CV%G'FB7$Fdgl$"3@Q"pnw<hP'FB7$F^_o$"3)edF/;9v(pFB7$Fh_o$"34F"3,b:E^(FB7$Fe\el$"3/DC,,yntvFB7$F[aq$"3gx[JRz$yf(FB7$F]]el$"3%y5$[S?S'e(FB7$F]`o$"3RjSbnL'Qa(FB7$Fcaq$"3+Vox;wZ(R(FB7$Figl$"3ar9M$y-<C(FB7$F^hl$"336(e,IRjv(FB7$Fchl$"3(p*zX"zvx(*)FB7$Fecq$"3g\e3I;P0')FB7$Fhhl$"3U*3&*3X'**QzFB7$Fcf^l$"3U!>bCnO.(yFB7$Fhf^l$"3EFPT(\tu(yFB7$F]g^l$"3#y_5AqM<(zFB7$F]dq$"3pwlt[l5e")FB7$Feg^l$"3r4mopF"**y)FB7$F]il$"3$z/P`Ni+m*FB7$Fj\\l$"3C,%\(z1\\5F97$Fedq$"3&39#**)G+#46F97$Fdchm$"3l*[A*HkK<6F97$Fichm$"3/]6HP%\>7"F97$F^dhm$"3/jvs+NrA6F97$Fb]\l$"3oF!)[J;H>6F97$Ffdhm$"3go.%ofb()4"F97$Fbil$"3k_dY3/[e5F97$Fdcem$"3%3\@ex&Rt**FB7$F^]y$"39gHc(*)*H]"*FB7$F\dem$"3)>)Q!=r)>@")FB7$F]eq$"3w&[kOUA0!pFB7$Facjl$"3"o_*yO%G5^&FB7$Ff]y$"3O$*Hh:8%H)RFB7$Ficjl$"3HKmS"*[p_BFB7$Fgil$"3/5@tR9T8mF<7$Fgigl$!3e4'yr"zNC6FB7$F^_v$!3DwM\bO+yGFB7$F_jgl$!3=jH$R[m-b%FB7$Fgao$!3_**)pAS^e4'FB7$Fij]m$!30^$ySf*pvuFB7$Ff_v$!3,*)oc*HB)e')FB7$Fa[^m$!3.y&**)G*oOi*FB7$F\jl$!3)*G0D]L*e."F97$$"3?L$e*[+RX5F9$!3oNwt@%zj3"F97$Fj^y$!3mr^f"zaZ6"F97$$"3=Le9c%zK0"F9$!3$QH9=n'>@6F97$$"3]m;ae#4f0"F9$!3'*=CG,%pG7"F97$$"3$)*\P41R&e5F9$!3=NPl:\7?6F97$F_bo$!3!o?&>eGN86F97$Fb_y$!348?xzrta5F97$Fajl$!3!f%)3%pDL"o*FB7$Fafq$!3S`FvcYJ1#)FB7$Ffjl$!3@@;?W9+2zFB7$Fifq$!3Jbf)3UkP^)FB7$F[[m$!3BJTj.Jou*)FB7$Fe[m$!3u"zV1n;$*H(FB7$F[iq$!35H<?_P[cuFB7$Fcco$!3mVQ!e7hXd(FB7$Feeel$!3[&=Ru&HS(f(FB7$Fciq$!3Sn*G\Ew')e(FB7$F]fel$!3v@)R:sSga(FB7$Fj[m$!3$z(G&R%***)puFB7$F`do$!3xgd&)\$HA#pFB7$F_\m$!3ts;(Q!*ztN'FB7$$"3'o;a8Gy)Q8F9$!3`@flUf%pE'FB7$F]eo$!3<RGBC'[j?'FB7$$"3hm"H2(G[\8F9$!3)=q%[BMRvhFB7$Fbeo$!3`Ta4&3T9<'FB7$Fgeo$!3'p9%H./jBiFB7$Fd\m$!39RkY0na2jFB7$Fbbv$!38f,X$3X/O'FB7$F_fo$!3!)\(=wFqDL'FB7$Fjbv$!3,Cb`hAU-iFB7$Fi\m$!3pNBnI:L#)fFB7$F^]m$!3_u(>(p@L`aFB7$Fc]m$!3BnS0q(oT7&FB7$Fh]m$!37v+1G3a*3&FB7$F]^m$!3>J&Gg[9m6&FB7$Fb^m$!3*Hm4!oy,h^FB7$Fg^m$!3B%p4`)>Ru^FB7$Fe`m$!3!yjb=$*pN*RFB7$F_am$!3O/m!)**z/'>$FB7$Fiam$!3:&\K[ETMr#FB7$Fcbm$!3-OMWSY)Qr"FB7$F]cm$!3L0knci:hoF<7$Fgcm$!390:n&o+na#F5F[dmFcdmFfimF]jmFajm7*FigmFjhm-Fjgm6%FbimQIThe~18~term~Fourier~approximation~(blue)F(FdhmFfim-F,6$7ev7$F0$"3NfvjE&>V()*F[[_m7$F>$"3(\bzr)pRM5FB7$FI$"3Em=@Zz$4k"FB7$FS$"3(zNjec%e1BFB7$Fgn$"3;16U-TeJKFB7$Fao$"3QJY\k'3-M%FB7$F_q$"3%QhpaHo_:&FB7$F]s$"3u-rYb`'zh&FB7$Fgs$"3lS!H(f!3DO'FB7$Fat$"3C^@")G%zvj(FB7$Fg_p$"3%4$*p%>MrguFB7$F\`p$"3$y?>vEG/K(FB7$Fd^`l$"3sf.!\DAzH(FB7$Fa`p$"3eUene!Q3K(FB7$F\_`l$"3]&=\Q%)yXR(FB7$Fft$"3#>GMU4D(>vFB7$Fi`p$"3-dHqA$RTP)FB7$F[u$"3!yWV5.bP/*FB7$Fffr$"300,:],NP))FB7$F`u$"3IosoW!>%f")FB7$Fe`]l$"3hZBYW3$z-)FB7$Fj`]l$"3=r3QUNgYzFB7$F_a]l$"3?R2ck^.IzFB7$F^gr$"3>!*)3.3?"*)zFB7$Fga]l$"3VL!G/pfHN)FB7$Feu$"33m(H=#=-;!*FB7$Fddw$"3dShluShl**FB7$Fhan$"3ZQ>&yqoO3"F97$Fg\gm$"3-tkAQ0k76F97$F\ew$"35l;FT7fD6F97$F_]gm$"3-Y1(\w3$=6F97$Fju$"3;=<O8;P(3"F97$F_^\m$"3yf%>l`@/."F97$Fdjt$"3u;)HzNPPY*FB7$Fg^\m$"3DiZ\ucZb$)FB7$F`bn$"3!H=ylAjq*pFB7$Fggfl$"3F8tlNA,?aFB7$F\[u$"3d$Hdd*z@oOFB7$$!3+]7y5"3x+"F9$"3e`N%)[ULVFFB7$F_hfl$"3a.^&e[<cz"FB7$$!3(oTg-&fJ-5F9$"3PO:'H*o!)G$)F<7$F_v$!3Mq[X*))H%o8F<7$$!3L++v$>F"p**FB$!3%Q$HmK8Q46FB7$Fghfl$!3e$)p'*[Cas?FB7$$!3p,+D"=%)\"**FB$!3@9?$>4Y#=IFB7$Fd[u$!3H)e#[v)p'QRFB7$F_ifl$!34#zY+qeVn&FB7$Fhbn$!3&\\C0fjjA(FB7$Fg`\m$!3-w1%f!41_&)FB7$F\\u$!3FsnFxIr@'*FB7$F_a\m$!3!=z(*Hx%)>/"F97$Fev$!3idqP'*oc%4"F97$$!33++v$4$)f`*FB$!39&Gr'=1,66F97$Fg`gm$!3Q$*zdV!\77"F97$$!3V,+D"3S=[*FB$!3EK*yMnWc7"F97$F\gw$!3k(p6a?DY7"F97$Fdagm$!3g*fvK&[K36F97$F`cn$!3U]Ksk`sw5F97$Fdgw$!3*RA1A-8"p)*FB7$Fjv$!3z[b&3WTl#*)FB7$Fbhz$!3$eI7Eb*\^#)FB7$F_cp$!3N0[#esUY%zFB7$Fjhz$!3bXBk,+jLzFB7$F_iz$!30AesK"zS+)FB7$Fdiz$!3%zO&fyAKQ")FB7$F_w$!3F^"Q$[0$[J)FB7$Fghw$!3WhCN_vS,()FB7$Fgcp$!3S"y]9L1.**)FB7$Fhail$!3UEyYtw0e!*FB7$Fdiw$!3Ac0RSb]j!*FB7$F`bil$!3")>lHq!ya+*FB7$Fdw$!3X<y0NcN))))FB7$F_dp$!3u`CoO&=k9)FB7$Fiw$!37/Mi)o>#fuFB7$Fgd\m$!3iAU]yy]mtFB7$Fgdp$!3ECUegU<8tFB7$F_e\m$!3Sqs3?r-)H(FB7$F\ep$!3F*)z<(yUrJ(FB7$Faep$!3M]rI!H38V(FB7$F^x$!3yXB"*e`%ze(FB7$Fcx$!3Y`,p0vumjFB7$F]y$!3Fh(3$QZYidFB7$F[[l$!33vWEA9mU^FB7$Fi\l$!33a^Iy=@SVFB7$Fc]l$!3iC#\r%fWJKFB7$F]^l$!3,eO&3@QyM#FB7$Fg^l$!33WV&pK\Bp"FB7$Fa_l$!3vW!p6gXB."FB7$F[`l$!3#)\q"pC3oK%Fjddl7$Ff`l$"3kF)RmT;y-"FB7$F`al$"3a?sZ9DfR;FB7$Fjal$"3<><$faIfF#FB7$Fdbl$"3=-q$*Gr#>B$FB7$F^cl$"3]01BNA;KVFB7$F\el$"3>4z0pPm,^FB7$Fjfl$"3)49J**>vVu&FB7$Fdgl$"3"o#*\&[aVijFB7$Figl$"3miBE#>$e(e(FB7$F[bq$"3#=">p#*R>EuFB7$F`bq$"35XJsTJz7tFB7$$"3QJek.Wx"y(FB$"3QP&e2SM!)H(FB7$Febq$"3fTKY,-m?tFB7$$"39lT5lNgzyFB$"3ke4R[;Y%Q(FB7$F^hl$"3`*oK%y[1!\(FB7$F]cq$"3DvqzAQxG#)FB7$Fchl$"3****=b<\!3&*)FB7$$"3E"3_+2tlM)FB$"3uN]"=%yI/!*FB7$Fb\v$"3OQtx(3PA/*FB7$$"379H#oi\+S)FB$"3uv_WdT"Q1*FB7$Fg\v$"3D.B4^iio!*FB7$$"3=\Pf$=ENX)FB$"3*G!3"RmZm0*FB7$F\]v$"37F1!*eIDG!*FB7$$"3/#ek.u-q])FB$"3kx+$Q4AU)*)FB7$Fecq$"3gVx7a]tD*)FB7$Fd]v$"3!*>;q")G%Qe)FB7$Fhhl$"3WnG["Q*Q#>)FB7$Fcf^l$"3I[woh"\(Q!)FB7$Fhf^l$"3I60!)e;iXzFB7$F]g^l$"3%)z<w1RVLzFB7$F]dq$"3Z<Fo'pKo,)FB7$Feg^l$"3?S<=%HP$*[)FB7$F]il$"3MR@uL=#oI*FB7$Fj\\l$"3=KS;X4o?5F97$Fedq$"3+-.d6d)f4"F97$Fichm$"3tzOzr`Z=6F97$Fb]\l$"337C>^u$e7"F97$Ffdhm$"3h*o$y2\z96F97$Fbil$"3.t)p.QBF3"F97$Fdcem$"3EXZ*ymOy-"F97$F^]y$"3I1'3l>(G$\*FB7$F\dem$"3P#R))3Y?YZ)FB7$F]eq$"3[v`(>ddfB(FB7$Facjl$"3#GsN&eB],eFB7$Ff]y$"3Cn&yN-&40UFB7$Ficjl$"3oJ7F#\j')[#FB7$Fgil$"3K]*y5w/>+(F<7$$"3Cm"H#3Mo+5F9$!3p6XEv"[+Y#F<7$Fgigl$!3Y6P+K^B!>"FB7$$"3*G$3-8I%f+"F9$!3G-]e0G(\7#FB7$F^_v$!3o(\wspAG/$FB7$F_jgl$!3'*f[6)[a&*z%FB7$Fgao$!3(**fZ6B=xS'FB7$Fij]m$!34\anB+wAyFB7$Ff_v$!3PNS^L<g5!*FB7$Fa[^m$!3m&4u)zaF\**FB7$F\jl$!3R1AGXw(H1"F97$Faa[n$!3AuXen!4c5"F97$Fj^y$!3E'Rj3ATW7"F97$Fia[n$!3eIL97jtD6F97$F^b[n$!3]3kZU?;A6F97$Fcb[n$!3"H!**Gsh=96F97$F_bo$!3"H?S\#QJ-6F97$Fb_y$!3)))fuK%\wE5F97$Fajl$!3'Q\pvqr$G$*FB7$F][_l$!3ipg,>?/J&)FB7$Fafq$!3"z(HRR*>d/)FB7$$"3![PM_HZ`5"F9$!3wnn'\dzJ)zFB7$Fe[_l$!3DG!=6bFU%zFB7$$"3)zX'G?&*[56F9$!33+8"e=^!GzFB7$Fj[_l$!3=#>gs00M$zFB7$F_\_l$!3g&)z7`<#=+)FB7$Ffjl$!3g1S?y]iK")FB7$Fe`y$!3kXBy!)>X(\)FB7$Fifq$!3S8J#HZeK&))FB7$Fbay$!3R4LEzGZz*)FB7$Fgay$!3wf.\z1,`!*FB7$F\by$!31e2P!*)[l1*FB7$F[[m$!3vS!eu%yC=!*FB7$Fagq$!3u1SUic-)H)FB7$F`[m$!3ik39h"\)zuFB7$Fegjl$!3LLdl&z]'ptFB7$Figq$!3OwUzIi<5tFB7$F]hjl$!3Uz&3;V"e*H(FB7$F^hq$!3u&)[0'>L:L(FB7$Fchq$!3)pStU.K.[(FB7$Fe[m$!3za*4?]yFl(FB7$F_\m$!3*>&fC=GBijFB7$Fi\m$!3a%=kNWw.j&FB7$Fg^m$!3A04P"RHO7&FB7$Fe`m$!3qkgTDyVSVFB7$F_am$!3z-"4JNP>B$FB7$Fiam$!3_'f&4m<riBFB7$Fcbm$!3e@9Gu[FO<FB7$F]cm$!3!G?%)3\xD."FB7$Fgcm$!3NfvjE&>V()*F[[_mF[dmFcdmF]jmFajm7*FigmFfim-F,6$7_u7$F0$"3A7V-jnYF\F57$F>$"3Yj-PR_j!R(F<7$FI$"3OVe/yPVR:FB7$FS$"3gL[7)4aac#FB7$Fgn$"374*Hx%fXINFB7$Fao$"3#=L5OppNJ%FB7$F_q$"3?qY*=nY3#[FB7$F]s$"3u9n4&3.nd&FB7$Fgs$"3!e5*o0]FgmFB7$Fat$"3Q<g%o6P4)yFB7$F\`p$"30+8f;js2wFB7$Fft$"3M*)p$y9o4V(FB7$Fi`p$"3G:+v6%z!R!)FB7$F[u$"3n_:uO'4A&*)FB7$Fjaw$"3/mKOgr0s!*FB7$F_bw$"3Xgr'\3Rz8*FB7$Fdbw$"3,dvI]o!\9*FB7$Fffr$"3u/%G6PsF4*FB7$Facw$"3(ywl'3iuN))FB7$F`u$"3tZ.>K;hi%)FB7$Fj`]l$"3U!pZDd%QC")FB7$F^gr$"3o-74!RG\)zFB7$Fga]l$"3lUO4p)G"o")FB7$Feu$"3(pcu&GfN4()FB7$Fddw$"3=G?=p<IR'*FB7$Fhan$"3*>=C*eQ8i5F97$Fg\gm$"3*\yLfeJ.5"F97$F\ew$"3];YGVBxB6F97$$!3i;z%\RX30"F9$"3Ibo**y0GG6F97$F_]gm$"3/!***GEn;F6F97$$!3E$3FWB`a/"F9$"31_e.cN*)>6F97$Fju$"3=xd,,n*f5"F97$F_^\m$"3j4(H7"4!p0"F97$Fdjt$"3wa>h\!z)z(*FB7$Fg^\m$"3mOX$H$o\!p)FB7$F`bn$"3A!*oN4kb;tFB7$$!3r;H#=V#\=5F9$"33<c#oWzD`'FB7$Fggfl$"3#)=*>"fZ;"p&FB7$$!3e$3-8F+J,"F9$"3SqI6C()*))z%FB7$F\[u$"3Jv])H(==jQFB7$Fga\n$"3;(H^Zh9@*GFB7$F_hfl$"3/&*4))y%pV*=FB7$F_b\n$"3kn+rxI_!z)F<7$F_v$!3"\#35m$\WW"F<7$Fgb\n$!3jviwk!y2<"FB7$Fghfl$!3DGbB!HMh=#FB7$F_c\n$!3V[#>wVt5=$FB7$Fd[u$!3)RSrII!\YTFB7$$!3$3+](o6%3')*FB$!33)o46oiP2&FB7$F_ifl$!3U*=w@(**)[&fFB7$$!3'****\i:)p1)*FB$!3_'f&Q%p>Ey'FB7$Fhbn$!3%QSD%z%f0b(FB7$Fg`\m$!38EMLYTN')))FB7$F\\u$!3C`ORB4\J**FB7$F_a\m$!3&f%4<wNIn5F97$Fev$!3wa$Ru?0;6"F97$Fid\n$!3\[)*e7_=B6F97$Fg`gm$!3!oE'f9FCG6F97$Fae\n$!3![J(Q._FF6F97$F\gw$!3U$y$>6,&37"F97$Fdagm$!3?yRMn=<%4"F97$F`cn$!3\oGC)))fO0"F97$Fdgw$!39EjQK(4'Q&*FB7$Fjv$!3vjCG'yF&H')FB7$F_w$!3$[/UoKH^k)FB7$Fdw$!3*[s#\%)=\f')FB7$F_dp$!3o(Q:)=ZdFyFB7$Fiw$!32C7&=@]nT(FB7$F\ep$!3G*Q"[ha%)*f(FB7$F^x$!3I44AuA*4(yFB7$Fcx$!3&[#yK],*Go'FB7$F]y$!3_A^lW4D/cFB7$F[[l$!3Xz"eBY7#4[FB7$Fi\l$!3$32d0,sOJ%FB7$Fc]l$!3kRybju"G_$FB7$F]^l$!3G[#3]r?cc#FB7$Fg^l$!3hd#[HX2Qa"FB7$Fa_l$!3Yj9"z+u6M(F<7$F[`l$!3'4@qLX4R%RF]`l7$Ff`l$"3Y'H,AXDzB(F<7$F`al$"3'e_8s)3NR:FB7$Fjal$"3R5Jp&=CKc#FB7$Fdbl$"3e$oC\n=F]$FB7$F^cl$"3S2I@]nP?UFB7$F\el$"36RDN6H;uZFB7$Fjfl$"3s$>d20A"*f&FB7$Fdgl$"3#[#H/ob_XmFB7$Figl$"3zUH_n2(3(yFB7$F`bq$"3vj=To#p%)e(FB7$F^hl$"33d[M#=fHU(FB7$F]cq$"3P[Z6AUZ+zFB7$Fchl$"3tT1hV?Yg()FB7$Fb\v$"3ab73)fT![*)FB7$Fg\v$"3u*)f'zb%4!3*FB7$F\]v$"3Cqq`QlAW"*FB7$Fecq$"3oF"3/5(\M"*FB7$Fd]v$"3)*Q[3Efm2*)FB7$Fhhl$"3bwGs*R<P])FB7$Fhf^l$"3'H)Q_*\?=7)FB7$F]dq$"338"\"zk\))zFB7$Feg^l$"3$[(ogSyin#)FB7$F]il$"3+"\4U&>2z*)FB7$Fj\\l$"3YN6TwA3(*)*FB7$Fedq$"3xQmwz!fw2"F97$Fichm$"3B8ghaxE46F97$Fb]\l$"3za%=o@tl7"F97$$"3q9Hdq>_-&*FB$"3/@=jYv`G6F97$Ffdhm$"3aM4I#=3a7"F97$$"3)puoHCRGb*FB$"3N!Q^5\pn6"F97$Fbil$"3[O+aXRE-6F97$Fdcem$"3_!\Y_.bX0"F97$F^]y$"3&>BH7kF$3)*FB7$F\dem$"389xRc<J4))FB7$F]eq$"3JPQRNWLgvFB7$Facjl$"30$=G&pH_'3'FB7$Ff]y$"3f>!Q2<T_U%FB7$$"3gz&R(\,10**FB$"3(z<j#fq()QNFB7$Ficjl$"3'GG()oCDUi#FB7$$"3)=TN@Ux`&**FB$"30TRriSX)o"FB7$Fgil$"3YzpVR%3.R(F<7$Fee]n$!3%=J]m">p'f#F<7$Fgigl$!3&***R2R#ogD"FB7$F]f]n$!334/X*zb8C#FB7$F^_v$!3db(zBq$*o?$FB7$$"3a*\7yh-7,"F9$!3](\n>a\V9%FB7$F_jgl$!3Vll*oZCe/&FB7$$"3>mTgAAY;5F9$!3U!)z*40tR!fFB7$Fgao$!31@d#3&G67nFB7$Fij]m$!3&oJ$)Q*G_b")FB7$Ff_v$!3)p0d!4L?R$*FB7$Fa[^m$!39]/o+$fT-"F97$F\jl$!3LNb#eTBd3"F97$Faa[n$!38BI$>KX'>6F97$Fj^y$!3VeD'=$eRG6F97$F^b[n$!3(HDMMU[c6"F97$F_bo$!33Z-x?(of3"F97$Fb_y$!3AU8#=]_N'**FB7$Fajl$!3#z6Tv)>j***)FB7$F][_l$!3Gw#H)GZk*H)FB7$Fafq$!3a0nG=H;'*zFB7$Fe[_l$!3]r7c&\5r*zFB7$Fj[_l$!3P$>6%>Zy$3)FB7$F_\_l$!3y!*=__8kN#)FB7$Ffjl$!3T"H!>j#G!G%)FB7$Fe`y$!3?f+AM#3+$))FB7$Fifq$!3e+;u'RI:5*FB7$Fbay$!3ZDCF(fc"["*FB7$Fgay$!3QuqaM%Qj7*FB7$F\by$!3IFHJ]jmP!*FB7$F[[m$!3PIpp:[&)*)))FB7$Fagq$!3vcl)3"y!\'zFB7$F`[m$!3:X`)*GBk?uFB7$F^hq$!3Qj-67zIJwFB7$Fe[m$!3xF_Kcv!3)yFB7$F_\m$!3piyyK>![l'FB7$Fi\m$!3kA8&*zgzxbFB7$Fg^m$!3c'4Vz!4V#z%FB7$Fe`m$!37#o2tMVAK%FB7$F_am$!3FJ[l%e+D]$FB7$Fiam$!3Rmik,QAlDFB7$Fcbm$!3dM<aP(G(\:FB7$F]cm$!3*p+Z-NwmM(F<7$Fgcm$!3A7V-jnYF\F5F[dmFcdm-Fjgm6%FbimQIThe~19~term~Fourier~approximation~(blue)F(FdhmFjhmF]jmFajm7*FigmFfimFjhm-Fjgm6%FbimQIThe~20~term~Fourier~approximation~(blue)F(Fdhm-F,6$7]x7$F0$"3xil,I!)>oLF57$F>$"3:#[GuqG]o*F<7$FI$"32B&G#y#o@x"FB7$FS$"3#G*oQ+P$G`#FB7$Fgn$"3,!4K$o[PkKFB7$Fao$"3q"z"ft4i7SFB7$F_q$"3of()3EwcT[FB7$F]s$"3BI$Hv:WD(eFB7$Fgs$"3s?ce1.oFpFB7$Fat$"3KsBgv1;!*yFB7$Fdhhl$"3=zsshX=rzFB7$Fg_p$"3M9>!>z[=+)FB7$F\ihl$"3]"45%[t)G)zFB7$F\`p$"3S,Zu]*o6#zFB7$Fa`p$"33*y'oHN`BxFB7$Fft$"3'e!=oOPz[vFB7$Fi`p$"3/isfmbRtxFB7$F[u$"3klzO!>$pE()FB7$F_bw$"3t:<dz*[#z!*FB7$Fffr$"3%*[#))=(p`@#*FB7$Facw$"3O=XD1uq1"*FB7$F`u$"3CaZaP@`!y)FB7$Fj`]l$"3*)*))ob'=_x$)FB7$F^gr$"3R")4l<*4V3)FB7$Ff``l$"3<>6#4'frO!)FB7$Fga]l$"3#p$*yy1C)y!)FB7$F^a`l$"3!G;em,q.A)FB7$Feu$"3a8,!)*f`FY)FB7$Fddw$"3@YR%=]**4K*FB7$Fhan$"3'*=e[([(>P5F97$Fg\gm$"3esto.zQ$3"F97$F\ew$"3!3o<#*pZn6"F97$Fhd^n$"3ES43%e!fE6F97$F_]gm$"3k+]?h(f38"F97$F`e^n$"3oY*ew*Q')G6F97$Fju$"3g!*>.\v)*>6F97$F_^\m$"36!>u[$*)fz5F97$Fdjt$"33K_yOD"o+"F97$Fg^\m$"3eT$))*Q"Qs+*FB7$F`bn$"3wmX\x>yDwFB7$Fdf^n$"3-$>M0n\Y#oFB7$Fggfl$"3prX]P$=x&fFB7$F\g^n$"32&GM$R[IK]FB7$F\[u$"3DA(yIken0%FB7$Fga\n$"3_j,f!Q?./$FB7$F_hfl$"3=51<\9'H*>FB7$F_b\n$"3/!>sV?!3_#*F<7$F_v$!3C.y-Q"o/_"F<7$Fgb\n$!3fa05xr8K7FB7$Fghfl$!3'y%[&pkz%*H#FB7$F_c\n$!3Ss]l$eLJM$FB7$Fd[u$!3mF$G@u(e_VFB7$F\i^n$!3")))>#4))[zJ&FB7$F_ifl$!3I!=<`0<,B'FB7$Fdi^n$!3QXj;fQ%43(FB7$Fhbn$!36(z-'z-PjyFB7$Fg`\m$!3F$*G&H(\*3?*FB7$F\\u$!3FC4Sz4<@5F97$F_a\m$!3'=v\,Y"o)3"F97$Fev$!3CVG(>!)))Q7"F97$Fid\n$!3"\!)pun?.8"F97$Fg`gm$!3c.?"45C+8"F97$Fae\n$!3%o$z[&4^O7"F97$F\gw$!3)=i$o5^#>6"F97$Fdagm$!3%e5qSWjb2"F97$F`cn$!3c?;.**3]F5F97$Fdgw$!3/1S7J[<@#*FB7$Fjv$!3U532OCh(R)FB7$$!3R+++vOtx!*FB$!3%[rJmknO;)FB7$Fbhz$!3meMa%zV)\!)FB7$$!3-++]P%o%***)FB$!35pwf8ReO!)FB7$$!3k+++D+Qt*)FB$!3uS>;a$H-0)FB7$$!3E,+]7;HZ*)FB$!33uJF-,N)3)FB7$F_cp$!3IfzELX*z9)FB7$F_iz$!3ATlof@9I&)FB7$F_w$!3o&ox6PUY&*)FB7$Fbhw$!3,%*>G0i+6"*FB7$Fghw$!30;Cj6Ea-#*FB7$F\iw$!3grg0oeY=#*FB7$Fgcp$!3%3,#e;,rc"*FB7$Fdiw$!3%[(ev7"zB$))FB7$Fdw$!3LgY`9j'QN)FB7$Fjir$!3Y&QEw!fyHzFB7$F_dp$!3mI,wQVgJwFB7$$!34mTN@N<e!)FB$!38*e&fA]\]vFB7$Fbjr$!3C4F%)\ZI<vFB7$$!3[Ke*)4/TjzFB$!3S^Mc?qcGvFB7$Fiw$!3aI'Gwf3qd(FB7$Fgdp$!3qx.(f$)zBu(FB7$F\ep$!3]CtOKDp9zFB7$Fdcil$!3ka`S$\"=tzFB7$Faep$!3UZB-bnx+!)FB7$F\dil$!3[wN\ZX&=*zFB7$F^x$!37otc"f"GWzFB7$Fcx$!3yf`Y?'RB#pFB7$F]y$!3^a=rHXsLeFB7$F[[l$!3%HiywNb?%[FB7$Fi\l$!3/'Q:4#4p7SFB7$Fc]l$!3.hfLfoO[KFB7$F]^l$!3I-t\$=v;f#FB7$Fg^l$!3uNl>-y23=FB7$Fa_l$!3S6fb\$e$y'*F<7$F[`l$!3LiK2@p#GJ&Fjddl7$Ff`l$"3o%)>Mjl'Gm*F<7$F`al$"3W?1_a,=r<FB7$Fjal$"3ZS%>,@'3#[#FB7$Fdbl$"3d#zG:.G5@$FB7$F^cl$"3W67:o*f(eRFB7$F\el$"3FK[Lx$*)[%[FB7$Fjfl$"3'G`suYG%QeFB7$Fdgl$"31745@gxFpFB7$Figl$"3k)\E&*4)fWzFB7$F]`jl$"3!H+!H$ztG*zFB7$F[bq$"3u$Q*oMU****zFB7$Fe`jl$"3yMhBM`^ozFB7$F`bq$"3.5'*>G]$\!zFB7$Febq$"3Ye.7W*GRs(FB7$F^hl$"31v_RqY;hvFB7$Fcdam$"3_eN-Xw'4_(FB7$Fifs$"3)[a/XpYI_(FB7$F[eam$"3XDOK`8<uvFB7$F]cq$"3f]T6+GcwwFB7$Fags$"3S7)=Bd)4>!)FB7$Fchl$"3JHd9=hIs%)FB7$Fg\v$"3E5[I:+yQ*)FB7$Fecq$"3<-i2#yu9?*FB7$Fb[y$"3UX,:v5K=#*FB7$Fd]v$"3nw6U'[5Q:*FB7$Fj[y$"3)H*fgsy"f,*FB7$Fhhl$"3+3$oi]#*>#))FB7$Fhf^l$"3e"eeKuBQP)FB7$F]dq$"3B??KqQkk!)FB7$$"38#3-8v"H))*)FB$"3M]-VCUER!)FB7$Fbial$"3=FOq[U7T!)FB7$$"3)\"H23$o</*FB$"3yZg8ykYs!)FB7$Feg^l$"3=%H!erl![8)FB7$Fjial$"3)Qj$)QRZWN)FB7$F]il$"3#HJ)o`&R]p)FB7$Fj\\l$"3$Qi&G'4TIe*FB7$Fedq$"3zb(fE)pRb5F97$Fichm$"31+a?$e#=&4"F97$Fb]\l$"3+/[_K61A6F97$F^d_n$"3'H6Q'>>/H6F97$Ffdhm$"3XNm[Nk"48"F97$Ffd_n$"3)HE$zpU9F6F97$Fbil$"3?ev!GaYs6"F97$Fdcem$"3*QmC)fo_x5F97$F^]y$"3Y%pxZy;&45F97$F\dem$"3@<=_B:%[7*FB7$F]eq$"3[CLvtvFtyFB7$Facjl$"3cb&HOofeO'FB7$Ff]y$"35V>YFGGVYFB7$F`f_n$"36'eb^C%p<PFB7$Ficjl$"32SE#*\*e$fFFB7$Fhf_n$"3=hCroX`w<FB7$Fgil$"3e!zoEk<'yxF<7$Fee]n$!3uPLZj:LLFF<7$Fgigl$!3gcZMt[&=K"FB7$F]f]n$!3![uo>.tuN#FB7$F^_v$!3V[r3B%y,P$FB7$F\h_n$!3)[i$HnPN]VFB7$F_jgl$!3\@xw:l$*)G&FB7$Fdh_n$!3h#)f+r.dxhFB7$Fgao$!3?/?Q![U(3qFB7$Fij]m$!3SxPe"ooNZ)FB7$Ff_v$!3)HohJ:YUk*FB7$Fa[^m$!3=&zv"*4i+0"F97$F\jl$!3g>cN7:A/6F97$$"3m*\ilCgF/"F9$!3uURJ")=+?6F97$Faa[n$!3Gm'Q;%otG6F97$$"3`mTN^)>![5F9$!3aW'3TN748"F97$Fj^y$!3n!HZ^)o4F6F97$F^b[n$!3R#otIe*4/6F97$F_bo$!3]7Q/4)>a1"F97$Fb_y$!3l[i")>(4@l*FB7$Fajl$!3)zwh,51Mr)FB7$Fb]bl$!3fJ"*4>Duy$)FB7$F][_l$!3G0'fzv()\:)FB7$$"3C3-8XG1&4"F9$!3k\"46!G*p3)FB7$Fj]bl$!3(p,th')Hz/)FB7$$"3T"H#=q]?+6F9$!3oMy*Hbhm.)FB7$Fafq$!3uKK%HV090)FB7$Fj[_l$!3Jo[qu5l;$)FB7$Ffjl$!31E>c"*)=Yu)FB7$Fe`y$!3ksor<Jm-"*FB7$Fifq$!3%*y#=9*eI?#*FB7$Fgay$!3K*41aDSL/*FB7$F[[m$!3t\*pvi]&Q')FB7$Fijs$!3uwu$e+S78)FB7$Fagq$!3*R4aeyd)>xFB7$F_cel$!3EL&QH-uAf(FB7$Fa[t$!3\r[iu)pk_(FB7$Fgcel$!3gl1Szyf?vFB7$F`[m$!3I1#\^Z[gc(FB7$Figq$!3X'zbbh(4^xFB7$F^hq$!3_!Hd&4]>RzFB7$Fehjl$!3[R'\\-L8*zFB7$Fchq$!3Gk))[.r]**zFB7$F]ijl$!3&oZ'f=.OezFB7$Fe[m$!3G"y#G4WXoyFB7$F_\m$!3+uJ\-z+GpFB7$Fi\m$!3"ex;BlG#peFB7$Fg^m$!3[-@*))G_J%[FB7$Fe`m$!36*=HQMW'=SFB7$F_am$!3F4oo%3b1@$FB7$Fiam$!3(yo8H&[w5EFB7$Fcbm$!3g"HC.%R!f$=FB7$F]cm$!3QyZL<N7z'*F<7$Fgcm$!3xil,I!)>oLF5F[dmFcdmF]jmFajm7*FigmFfim-F,6$7iw7$F0$"33dg37.WtFF57$F>$"3G9(=l`U(\")F<7$FI$"3[&zes3+wZ"FB7$FS$"3![C\wyyFM#FB7$Fgn$"3yOcYdp6YKFB7$Fao$"3i(GW3Uq(zTFB7$F_q$"3u&Qcp,6S9&FB7$F]s$"3)4G&z#3c<0'FB7$Fgs$"3?w(ohOX="pFB7$Fat$"3Vq2gL3U#o(FB7$Fg_p$"3oJe'zb+0*zFB7$F\`p$"39r'4'y%3=6)FB7$Fa`p$"3MbT^j2:A!)FB7$Fft$"3O?cs#eJ"3yFB7$F^ecl$"3?yHL=T@/xFB7$Ffer$"3K_b0j5'>j(FB7$Ffecl$"3^#4ZY!4X5wFB7$Fi`p$"3t#[#z_x%Hl(FB7$F^fr$"33sB@ljGUzFB7$F[u$"3kFi)*[_vM%)FB7$F_bw$"3%yjV"))*e>*))FB7$Fffr$"3](H6`EX7@*FB7$F\cw$"3?7Gdq\1!G*FB7$Facw$"3rIaQ#o*Qx#*FB7$Ffcw$"3$oP2t$=_.#*FB7$F`u$"3fYSjSODm!*FB7$Fj`]l$"3Dg@wc!3zm)FB7$F^gr$"3=\)=QG%=n#)FB7$Ff``l$"3GbK5D#)RN")FB7$Fga]l$"3%**\T^.UN3)FB7$F^a`l$"3#3A4:[c18)FB7$Feu$"3)pL$37E\(G)FB7$Fddw$"3/ZBO__uE!*FB7$Fhan$"3(yYPI7],,"F97$F\ew$"3C(R7K$>?06F97$Fju$"3`9>.aaaH6F97$F_^\m$"3i[^%p?y&)4"F97$Fdjt$"3EEd!>cOG."F97$Fg^\m$"3N'QO4BQ`I*FB7$F`bn$"3ydQ=_LTCzFB7$Fdf^n$"37*GE(e2M4rFB7$Fggfl$"3_m0))3f[>iFB7$F\g^n$"3kF$)G***))GE&FB7$F\[u$"3-Nv(zY$))[UFB7$Fga\n$"3G6$4X]Bz=$FB7$F_hfl$"3?#)old`Q"4#FB7$F_b\n$"3_1![::qMr*F<7$F_v$!3Iv05ph['f"F<7$Fgb\n$!3a"fT`vcMH"FB7$Fghfl$!3^RBWBic7CFB7$F_c\n$!3x[E^.&*Q/NFB7$Fd[u$!3:B5pDH)ob%FB7$F\i^n$!3Jw\RGSyebFB7$F_ifl$!3s<t"3TI)*\'FB7$Fdi^n$!35$G/j&\&4P(FB7$Fhbn$!3(pHfU"HXk")FB7$Fg`\m$!3s"))fP!zL&\*FB7$F\\u$!3kxP5CUBY5F97$F_a\m$!3=]ubY'*>16F97$Fev$!3!f-EhT];8"F97$F\gw$!3ki_z_%*e)4"F97$F`cn$!3U"y<Nq%*e***FB7$Fdgw$!3eNY]_tzK*)FB7$Fjv$!3/4GuNi*4C)FB7$$!3x****\(3AQ5*FB$!3ObU;b-*e:)FB7$F[]an$!3.@rgUQ$Q5)FB7$$!3,,+]i_k^!*FB$!3:L:Aznx$3)FB7$Fbhz$!3Efz=cD"Q4)FB7$Fh]an$!3s+W$G#>%G>)FB7$F_cp$!3;J#*=)[=DP)FB7$F_iz$!39'GP\WSH$))FB7$F_w$!3U#[p)4mx(>*FB7$Fbhw$!3wVc%3!3xy#*FB7$Fghw$!3%oy#)46a_F*FB7$F\iw$!3`$G****=$f(=*FB7$Fgcp$!3;hQ"\[ve-*FB7$Fdiw$!3hTBSp%*fd&)FB7$Fdw$!3F)oV>F;.1)FB7$Fjir$!3%Q(Rql%fgt(FB7$F_dp$!3AN\b.j)4h(FB7$Fc`an$!3MboeJw)Qi(FB7$Fbjr$!3!G*37@ZfxwFB7$F[aan$!3bxUp'*)=-w(FB7$Fiw$!3#[/dqXqv&yFB7$Fgdp$!3qs_"Qzzq.)FB7$F\ep$!3IB7V&\[?6)FB7$Faep$!3unc8048E!)FB7$F^x$!3BsPJ.F/)y(FB7$Fiep$!3OOS7Z=%**R(FB7$Fddn$!3A]]!*RNaYqFB7$Fh[dl$!3x>?](zl^#pFB7$Fafp$!3'o>%o;t#G&oFB7$F`\dl$!3]*e`+qU*HoFB7$Fidn$!3__*p]V4+&oFB7$F^en$!3[")f$Q9zg'pFB7$Fcen$!3WnUAm-.rqFB7$F\_dm$!3axMBb")z!3(FB7$Fhen$!3-ND\1yT\qFB7$Fd_dm$!3J#H3#\#oY(pFB7$Fcx$!3y5q&)HmZgoFB7$F]y$!3iy<t*3+^4'FB7$F[[l$!3TJ#zn'RUV^FB7$Fi\l$!3K#)H$)>uvzTFB7$Fc]l$!3')orW,]&fC$FB7$F]^l$!3cW'o+'fofBFB7$Fg^l$!3lpyOI1p0:FB7$Fa_l$!3bf"ea(ph*3)F<7$F[`l$!3)G59#HI(G%RF]`l7$Ff`l$"3ktg8pj,jzF<7$F`al$"3(f'>`/w#pZ"FB7$Fjal$"3WB!**RUNGL#FB7$Fdbl$"3*\%o))z.^YKFB7$F^cl$"3'*oT!Q.d3>%FB7$F\el$"3Q^\8Z/pR^FB7$Fjfl$"3m_&p3LT@4'FB7$Fdgl$"3XS,@1rXTpFB7$Figl$"3GfN1t^u)y(FB7$Fchl$"3C*oGw:b.<)FB7$Fg\v$"3%4mlN/X9p)FB7$Fecq$"3'4lAQ!R(o7*FB7$$"3)[TNrHz/c)FB$"3mM"3O*zI)>*FB7$Fb[y$"3!3'pO3?%)\#*FB7$$"3uZi!R&e&Rh)FB$"3,^))f,r!*z#*FB7$Fd]v$"3<![tIMqvG*FB7$Fj[y$"3!)G$f;_RaB*FB7$Fhhl$"3!>L,'*HM-5*FB7$Fhf^l$"3>*)o#\SpOm)FB7$F]dq$"3^KMN]PnF#)FB7$Fgian$"3N3k;qB"\:)FB7$Fbial$"3OOk&oH,e5)FB7$F_jan$"3:9Tv^];%3)FB7$Feg^l$"3%=%['GejJ4)FB7$Fjial$"33r:#f89;@)FB7$F]il$"3&3bP#f3ho%)FB7$Fj\\l$"3'eC.8<*\!G*FB7$Fedq$"3'\z'[?XQI5F97$Fb]\l$"3M&R77e;H6"F97$Fbil$"3/Pb*=$[&y7"F97$Fdcem$"3i"[lB*4"o4"F97$F^]y$"3X%yMq8r`."F97$F\dem$"3q3?U>q&3U*FB7$F]eq$"3&ykk^FVW<)FB7$$"3#G"z%\gDW!)*FB$"3]'4z-PZ1W(FB7$Facjl$"3.Y0lu9HRmFB7$$"3@YPMxGua)*FB$"3@C8$RPBkx&FB7$Ff]y$"3)Rf%[U[7f[FB7$F`f_n$"35v5.l(*R&*QFB7$Ficjl$"3yi"R!>N/%*GFB7$Fhf_n$"3x_TS:i\k=FB7$Fgil$"3XPevSv#o;)F<7$Fee]n$!3of`$e!p'*pGF<7$Fgigl$!3la)*ysEf(Q"FB7$F]f]n$!3AN,@l7JtCFB7$F^_v$!3ALZ/_*QE`$FB7$F\h_n$!3eG><"eeXb%FB7$F_jgl$!3#*yeL(>a(GbFB7$Fdh_n$!3,V_V(>+eW'FB7$Fgao$!35]>'3jItH(FB7$Fij]m$!3eM8x#4Flx)FB7$Ff_v$!3B#fXolha#**FB7$Fa[^m$!38"G-7AdE2"F97$F\jl$!3iFZHGof=6F97$Fg`bn$!39CRw;RbH6F97$Faa[n$!3e[4*))yyJ8"F97$F_abn$!3CD#\+%36I6F97$Fj^y$!347S*e(f2@6F97$F^b[n$!3A8M9?NL)3"F97$F_bo$!32J,\MzyT5F97$Fb_y$!3TTzOt=+\$*FB7$Fajl$!3()p(z<?EP[)FB7$Fb]bl$!3'QK9?9(*zA)FB7$F][_l$!3VlXOW0O+")FB7$Fibbn$!3Gm-/xy[$3)FB7$Fj]bl$!3)y7jh$yk&4)FB7$Facbn$!3u!*=VJFBM")FB7$Fafq$!3W$e)>f"Hg>)FB7$Fj[_l$!3u*\1vmhkf)FB7$Ffjl$!3O&)elc%oc.*FB7$F``y$!3QE`7.Ff">*FB7$Fe`y$!3#*[=UD_-w#*FB7$Fj`y$!3@:;Z$Gw'y#*FB7$Fifq$!3U#)HZ2i=*>*FB7$Fgay$!3X"f)*4=%4P))FB7$F[[m$!3dp9sI"R&Q$)FB7$Fijs$!3.Hk<X]SvyFB7$Fagq$!3+cI!3\Z>j(FB7$F_cel$!3R(Q7$\(R2h(FB7$Fa[t$!3?k:p:n+\wFB7$Fgcel$!3O7?n)o5>t(FB7$F`[m$!3>liz=5wRyFB7$Fegjl$!3*p;?!G6r]zFB7$Figq$!3?9`V#H!fV!)FB7$F]hjl$!3fo3+6x^+")FB7$F^hq$!3]VV;W#))*3")FB7$Fchq$!3r(\TXSrW'zFB7$Fe[m$!3!=[(H[m`XwFB7$F_\m$!31iE6V]:BpFB7$Fi\m$!3:y*)\i4`dgFB7$Fg^m$!3O;O.N].U^FB7$Fe`m$!3h]$oklo'yTFB7$F_am$!3h,\83@_YKFB7$Fiam$!3#R_b<nVmO#FB7$Fcbm$!3YEgOZ#zN`"FB7$F]cm$!3%HU(38AK'4)F<7$Fgcm$!33dg37.WtFF5F[dmFcdmFjhm-Fjgm6%FbimQIThe~21~term~Fourier~approximation~(blue)F(FdhmF]jmFajm7*-F,6$7cu7$F0$!3Cp#\jtg!)*GF57$F>$"3kT@yfVm&)))F<7$FI$"3'31P%\:?c<FB7$FS$"3$>\#[#G3.j#FB7$Fgn$"3<5\Ad,N0NFB7$Fao$"3#HKIO!)HPP%FB7$F_q$"3=B54TJHB^FB7$F]s$"33(*[&3S^*oeFB7$Fgs$"3)*zUSj'*p`mFB7$Fat$"37Wv)eB&>$R(FB7$Fg_p$"3'=G8q$*4by(FB7$F\`p$"3]@2RT!H:5)FB7$$!3@Dc^8y1D7F9$"3i*p&o&RR::)FB7$Fd^`l$"3EuVtQX)p=)FB7$$!3'=ajf#)H'>7F9$"3;_NS_O@2#)FB7$Fa`p$"3R*e*zPC77#)FB7$$!3]e9TQ=>97F9$"3DN,r#))p@?)FB7$F\_`l$"3ui@@!*\Py")FB7$$!39v$f3&Qv37F9$"3Tg&*)o7$HU")FB7$Fft$"3a08GnB(f4)FB7$Ffer$"3g]4/lSaiyFB7$Fi`p$"3T'flp=/?q(FB7$Feefl$"3KhSr6cv0xFB7$F^fr$"396k8,"yLy(FB7$F]ffl$"3EEm&p4ff$zFB7$F[u$"3nz$[:>BN:)FB7$Fffr$"3OZ!G`G)\w!*FB7$F`u$"3W_F&fx'p"G*FB7$F^gr$"3x>cq5$>r])FB7$Feu$"3>"G(4ba>*=)FB7$Fhan$"3!eptJdWB#)*FB7$Fju$"3'pDh//4\8"F97$F_^\m$"3L`s8Zu#R6"F97$Fdjt$"31TbdhT1c5F97$Fg^\m$"3DUQs%p3Xe*FB7$F`bn$"3&p#*[G-^@@)FB7$Fdf^n$"3.!H5?h1kQ(FB7$Fggfl$"3$H[)*fL(GwkFB7$F\g^n$"3YOS'*))\`!\&FB7$F\[u$"3LTL:KC\RWFB7$Fga\n$"3O%)znbh*[L$FB7$F_hfl$"3HJHA!>L'*=#FB7$F_b\n$"3"f_9.[ou,"FB7$F_v$!3U4Y=BM]s;F<7$Fgb\n$!3*Q*[R()[ta8FB7$Fghfl$!34\"H`x"QDDFB7$F_c\n$!3)*=:(G^/[m$FB7$Fd[u$!3kjs"R"zHfZFB7$F\i^n$!3I")y;dM8'z&FB7$F_ifl$!3BHH?8$HQw'FB7$Fdi^n$!3Bg(yM8)Q_wFB7$Fhbn$!3<&)Q4.m\`%)FB7$Fg`\m$!3$4(za$*3Up(*FB7$F\\u$!3?C:AqHNo5F97$F_a\m$!3Y:qiku'*>6F97$Fev$!3iNE`_<;N6F97$F`cn$!3x&><N4S?r*FB7$Fjv$!3&oo)4GY$R;)FB7$F_cp$!3[1D'3O(GR')FB7$F_w$!3-^EL996V$*FB7$Fgcp$!31_cKD;I'z)FB7$Fdw$!3VNIScuAcyFB7$F^[dm$!32fsQj#H)[xFB7$Fjir$!3]!H3#)=g"*p(FB7$Ff[dm$!3R1'[5MVXq(FB7$F_dp$!3vp*)RKtacxFB7$Fbjr$!3y))>V:cPXzFB7$Fiw$!3#HM5q2]n8)FB7$Fgd\m$!3UfTRVQ\%>)FB7$Fgdp$!3$4Tnij>@@)FB7$F_e\m$!3Xy)4h+<U=)FB7$F\ep$!3%o$yl5$306)FB7$Faep$!3Fc8q)4['[yFB7$F^x$!3'pSRdao!3vFB7$Fidn$!3!o\Z+Zdz7(FB7$Fcx$!3v%pe0*zu%e'FB7$F]y$!30xgpK,Y@gFB7$F[[l$!3,mN**fLf5^FB7$Fi\l$!3h0q]p0ztVFB7$Fc]l$!3I^`$yEcx\$FB7$F]^l$!3a3,Y2Q)yk#FB7$Fg^l$!3*yh,o&=Om<FB7$Fa_l$!3P8q=moo&)))F<7$F[`l$!3QqX>UEj*R'Fjddl7$Ff`l$"3.fN+-NQ&)))F<7$F`al$"3/[o16S)ev"FB7$Fjal$"3![5V(=_l5EFB7$Fdbl$"3RM7J"*p[xMFB7$F^cl$"3#3)>hD`C7VFB7$F\el$"3rQY96')3p]FB7$Fjfl$"3[fK'RASX+'FB7$Fdgl$"3c7XK)ftzp'FB7$Figl$"3c"o))f:&))3vFB7$Fchl$"3;QgL?*>V$zFB7$Fecq$"3_'H$o])4%Q*)FB7$Fhhl$"3\Dz&=W(\,$*FB7$Fhf^l$"3TK'p@*yZ_*)FB7$F]dq$"33W5)GOrKX)FB7$Fbial$"3UHqswzp]#)FB7$Feg^l$"3i!p'G"y*yP")FB7$$"31]P%['[C&4*FB$"3-1lLV8\E")FB7$Fjial$"3h[\9*pU*\")FB7$$"3!He9;U@(["*FB$"3;$>CCo*R5#)FB7$F]il$"37sVvZ5(*3$)FB7$Fj\\l$"3D:P]]KG.!*FB7$Fedq$"3utS6(>%y.5F97$Fb]\l$"3%G.#)y[&z*4"F97$Fbil$"3,<?"yv3V8"F97$Fdcem$"3+$oi&y>\76F97$F^]y$"3lnbR@<Se5F97$F\dem$"3'HO9Wl%3(p*FB7$F]eq$"3'zy*og._j%)FB7$F`ddn$"3aUI;cJ5BxFB7$Facjl$"3BxqYBsg1pFB7$Fhddn$"3k:N&['p`?gFB7$Ff]y$"3pQZ;@Rns]FB7$F`f_n$"3gzL%))yV>2%FB7$Ficjl$"3!4;-4+e#GIFB7$Fhf_n$"35+z(yILB&>FB7$Fgil$"3"Ry1fIL\b)F<7$Fee]n$!3S'4]Qt(f1IF<7$Fgigl$!3d-\by#zKX"FB7$F]f]n$!3$)yIV>t&))e#FB7$F^_v$!3c,kYQxB%p$FB7$F\h_n$!3T&fVd:')ov%FB7$F_jgl$!3j>!HzyW^w&FB7$Fdh_n$!3Lhan5eY3nFB7$Fgao$!3kq?/JwhxvFB7$Fij]m$!3_n@51!yS1*FB7$Ff_v$!3+^L(>Yp#=5F97$Fa[^m$!3A]is!y')>4"F97$F\jl$!3)pj'eZj+H6F97$Fj^y$!3()f6(Ge246"F97$F_bo$!3umo&f#Q=;5F97$Fb_y$!3+ykQGY3o!*FB7$Fajl$!3.lM]lP**>$)FB7$$"3XTg-&RyZ3"F9$!3;.1P$o26A)FB7$Fb]bl$!3m#)R'[Y@v:)FB7$$"3%[7y+i?**3"F9$!31+gU>+TG")FB7$F][_l$!350"Q`H]>8)FB7$Fj]bl$!33l\y]YND#)FB7$Fafq$!31mNyS6k2%)FB7$Fj[_l$!3&QL'pG_g&)))FB7$Ffjl$!3l?vM\=Ii#*FB7$Fifq$!3nX?qY-%\0*FB7$F[[m$!3@K;$o5H!p!)FB7$F_\hl$!3O\*4ji*fuyFB7$Fijs$!3?>PfTD][xFB7$Fg\hl$!3%Q^*G^3t'p(FB7$Fagq$!3"QRNptUZr(FB7$Fa[t$!3E%HgK!zs(*yFB7$F`[m$!3%*=oCz`"H7)FB7$Fegjl$!3'4NF8l)z#>)FB7$Figq$!3BprU'3"[6#)FB7$F]hjl$!3P_mordBr")FB7$F^hq$!3/y&[AubG2)FB7$Fchq$!39>#G4(zTVxFB7$Fe[m$!3ttD="zFkN(FB7$F_\m$!3N/)eD#)f,n'FB7$Fi\m$!3bLRdU!GP)eFB7$Fg^m$!3%)>B%>=f84&FB7$Fe`m$!3$[Ae0>D)yVFB7$F_am$!3=Tuzk^ExMFB7$Fiam$!3+hY^taT_EFB7$Fcbm$!3%yES<2TAx"FB7$F]cm$!3D"Rx)e!*o&)))F<7$Fgcm$"3Cp#\jtg!)*GF5F[dmFcdmFigm-Fjgm6%FbimQIThe~22~term~Fourier~approximation~(blue)F(FdhmFjhmFfimF]jmFajm7*Fjhm-Fjgm6%FbimQIThe~23~term~Fourier~approximation~(blue)F(Fdhm-F,6$7gs7$F0$"3E-1*o*zFziF[[_m7$F>$"3Ix"f%p63K*)F<7$FI$"3p#)o/Ileg:FB7$FS$"3m%3-zq'*GT#FB7$Fgn$"3FA;5K<HvKFB7$Fao$"3%[lbj5@&GTFB7$F_q$"3p_#Q&p#ys%[FB7$F]s$"3xsph@DF<cFB7$Fgs$"3[d(3cr+BU'FB7$Fat$"37&ox*Q71">(FB7$F\`p$"3![6j!eei7zFB7$Fft$"3e6YLJjX)H)FB7$Ffer$"3(*RM'>Yf"R")FB7$Fi`p$"3C%HGICK0*yFB7$$!3Ne*)48Rc"="F9$"31cL%z1w/%yFB7$Feefl$"3irj#Hj=B!yFB7$$!3+voaDf7w6F9$"3rG*zu'p2zxFB7$F^fr$"3#ov9I7eKx(FB7$F]ffl$"3kJKi)e)p?yFB7$F[u$"3vIDKb**o]zFB7$Fffr$"3!eE&>5t#Q&))FB7$F`u$"37dW#GW))>S*FB7$F^gr$"3#[MrJ-"Qu()FB7$Feu$"3(o=L5juz;)FB7$Fddw$"3d/03JH)3c)FB7$Fhan$"3.H"zscFha*FB7$F\ew$"3j<JujzXr5F97$Fju$"3GMrP,1NO6F97$F_^\m$"3q7ZTN-wD6F97$Fdjt$"3$y>f+`9l2"F97$Fg^\m$"3nMI#ofMX%)*FB7$F`bn$"3*Qmc!*=B()[)FB7$Fdf^n$"3Jl<6wghbwFB7$Fggfl$"3;[a&4l\zs'FB7$F\g^n$"3UE<)G`H^r&FB7$F\[u$"3_>XN#eA&GYFB7$Fga\n$"3[BU#Rs57[$FB7$F_hfl$"3Kvl))epp(G#FB7$F_b\n$"3t"pj[grN1"FB7$F_v$!3Aaf9k)>&[<F<7$Fgb\n$!3fDL]j'pfT"FB7$Fghfl$!3cYO(>69zj#FB7$F_c\n$!3N!*e,&GUV#QFB7$Fd[u$!3b([>+:c(f\FB7$F\i^n$!3qqxlFk')HgFB7$F_ifl$!3&z^O#[@#>-(FB7$Fdi^n$!3]85IZo*\#zFB7$Fhbn$!3#*GB0cNAI()FB7$Fg`\m$!3f"fhwc'H-5F97$F\\u$!3<*)*z"4zb(3"F97$$!3f***\(="pUk*FB$!3giw'='R&R6"F97$F_a\m$!3I=6]+37I6F97$$!3%4+]i5E,f*FB$!3Gnr"Qsbn8"F97$Fev$!3/`#y=@HZ8"F97$F\gw$!3vxo!pA)zh5F97$F`cn$!3J()4-J>EN%*FB7$Fdgw$!3u,yEc;8#\)FB7$Fjv$!3nh!33>$)\;)FB7$F_cp$!3XX!)G8wf:*)FB7$F_w$!3iEH`hdrw$*FB7$Fgcp$!3%R)>Q'z0U_)FB7$Fdw$!3Ah;(Hu)\)y(FB7$F^x$!3_92My#>wE(FB7$Fcx$!3^P)4B9u>Q'FB7$F]y$!3KMvjDqqWdFB7$F[[l$!3AfX43`vN[FB7$Fi\l$!3^+N^0!G'GTFB7$Fc]l$!3#\N#>zIEfKFB7$F]^l$!3t>]H0zWrCFB7$Fg^l$!31^jezwu4;FB7$Fa_l$!31p$e+WJ(p))F<7$F[`l$!3)Gv1q'etTRF]`l7$Ff`l$"3SM'>I$=AP()F<7$F`al$"3,IS(3aM$f:FB7$Fjal$"3s=G/4<ImBFB7$Fdbl$"3?z/dX;-AKFB7$F^cl$"3UGX%e%HIRSFB7$F\el$"3=!zQy`N9![FB7$Fjfl$"3alu6+x#zs&FB7$Fdgl$"3*QowdD=<X'FB7$Figl$"301fn:K@osFB7$Fchl$"3aR^i*>D*>yFB7$Fecq$"3&))pILJjNo)FB7$Fhhl$"3g*)))*4VeIS*FB7$F]dq$"3S/-8wBB8()FB7$F]il$"3Ih]O[8]?#)FB7$Fedq$"3i/G1M\1n(*FB7$Fbil$"3!QzSQAho8"F97$Fdcem$"3ykNGc)yY7"F97$F^]y$"3$yy@%G(H'y5F97$F\dem$"3[;nR>/L`**FB7$F]eq$"3Sx`+!)3BS()FB7$F`ddn$"3K2=tCAY'*zFB7$Facjl$"3Nfc8XggnrFB7$Fhddn$"3fj4i'3u0E'FB7$Ff]y$"3k*=r=qQQG&FB7$F`f_n$"3Xzw_,rFZUFB7$Ficjl$"33^c9x:)>;$FB7$Fhf_n$"3O,M)e;S+/#FB7$Fgil$"3(zklE6IH%*)F<7$Fee]n$!3BHPkPQAVJF<7$Fgigl$!3Kr,6NB"*=:FB7$F]f]n$!3_]f"e2)4/FFB7$F^_v$!3>;a:/w$\&QFB7$F\h_n$!3"fXTD/gs&\FB7$F_jgl$!3SbpGp$zz*fFB7$Fdh_n$!3f<vk'>z`'pFB7$Fgao$!3l()Qu56O\yFB7$Fij]m$!3O"RDJ@_fL*FB7$Ff_v$!3Iz&3GF!fT5F97$Fa[^m$!32B*z'pI636F97$F\jl$!3"['R)3(ojN6F97$Fj^y$!3q$fz55)>(4"F97$F_bo$!3W9a!o61o*)*FB7$Fb_y$!3]&Hw`%***4#))FB7$Fajl$!3E]uy$HioA)FB7$Fafq$!3@DG$o=(\f')FB7$Ffjl$!3M4_59\(zR*FB7$Fifq$!3oCf$\0,g#))FB7$F[[m$!3Qx+U)Q&o%*yFB7$$"3a"zp)*fur;"F9$!3i2M%ftcX$yFB7$F_\hl$!3gV%GTZ8[z(FB7$$"353F%H.eD<"F9$!3k/dX$GE`x(FB7$Fijs$!3vs!\Y6&>vxFB7$Fg\hl$!3tQu_3R"f#yFB7$Fagq$!3gcF$e`9r#zFB7$Fa[t$!3%G_&fT[ft")FB7$F`[m$!3DEJYYEc.$)FB7$F^hq$!3i$H-_&e%e'yFB7$Fe[m$!3D^#Qc7O'prFB7$F_\m$!31c%=/'["HV'FB7$Fi\m$!3=$Q*z:u]FcFB7$Fg^m$!3K^%z%G>C>[FB7$Fe`m$!3wvS,ZmlPTFB7$F_am$!37^f=n4l@KFB7$Fiam$!3SGwg&fA:\#FB7$Fcbm$!3Nz=TI4o`;FB7$F]cm$!3>'[NoA.n())F<7$Fgcm$!3E-1*o*zFziF[[_mF[dmFcdmFigmFfimF]jmFajm7*FigmFjhm-Fjgm6%FbimQIThe~24~term~Fourier~approximation~(blue)F(FdhmFfim-F,6$7hs7$F0$!3')*)o=L$4MJ*F[[_m7$F>$"3.u>9@s$=<)F<7$FI$"3W&3dm83?j"FB7$FS$"3SjSY#)=\XCFB7$Fgn$"3!z8h[?PqD$FB7$Fao$"3bw'G"Hl+oSFB7$F_q$"3-;b@uF*z'[FB7$F]s$"3b"QxT+*QjcFB7$Fgs$"3gcRS\M8QkFB7$Fat$"3tuTL[#Q==(FB7$F[u$"3*elp_q4$pyFB7$Fffr$"3O4'H=OCJf)FB7$F`u$"3@R6#pCDxT*FB7$F^gr$"3Mnq&[SY!R!*FB7$Feu$"3)*pi%**)*y)=#)FB7$Fddw$"3!*)=q!R^v1%)FB7$Fhan$"3$*[k*eyyLG*FB7$F\ew$"3\A*\Okc20"F97$Fju$"3c1U(G3sT8"F97$$!38]i!R2h+/"F9$"3S29BC2rQ6F97$F_^\m$"3K3"=S`8U8"F97$$!3y;aQ8*oY."F9$"3;)>P*['f'>6F97$Fdjt$"3K'zDi`@U4"F97$Fg^\m$"3#=OdmYF&35F97$F`bn$"3^GA!pJ')Qv)FB7$Fdf^n$"3^-v`ULv;zFB7$Fggfl$"3uVMT(G2V(pFB7$F\g^n$"3vD'yOSil$fFB7$F\[u$"3m8(>m'>"f"[FB7$Fga\n$"3e.9GH)Roi$FB7$F_hfl$"3AA-)HqobQ#FB7$F_b\n$"3^F=Lybl46FB7$F_v$!3l(R^eXNX#=F<7$Fgb\n$!3u:YNw"frZ"FB7$Fghfl$!3w+A'))4^,v#FB7$F_c\n$!3St80mo'H)RFB7$Fd[u$!3\#=#)\^#=e^FB7$F\i^n$!39'z9rEc)fiFB7$F_ifl$!3pcN[$pERF(FB7$Fdi^n$!3yB,C=Lb)=)FB7$Fhbn$!3Mtc>d&*Q%**)FB7$Fg`\m$!3Y_MZoxeD5F97$F\\u$!34D;TAe*Q5"F97$Fa[hn$!3&[Jax&orD6F97$F_a\m$!3:%)fa/.#o8"F97$Fi[hn$!3A?)QXo8"Q6F97$Fev$!3/%)\;\#*oI6F97$F\gw$!3u"*R^Br#*R5F97$F`cn$!3^.f(y#=6w"*FB7$Fdgw$!31b+(y.2fN)FB7$Fjv$!3!R%)po7evB)FB7$Fbhz$!3F>rA8\FU')FB7$F_cp$!3P(*=.8)G0<*FB7$Fjhz$!3yk]N4kcd$*FB7$F_iz$!3Fj%Rxl.![%*FB7$$!3_++]P6w!z)FB$!3uf(o_s"4_%*FB7$Fdiz$!3:q40D(p$G%*FB7$$!3c****\7VeQ()FB$!3[D0K<I*yP*FB7$F_w$!3O,(=y>.FI*FB7$Fgcp$!3GIn)R(>pp#)FB7$Fdw$!3[Y=j!eYR'yFB7$F^x$!3-"*>hm2i%>(FB7$Fcx$!3!)3$p-a.PW'FB7$F]y$!3)HEL(f*H(ocFB7$F[[l$!3P[I<fCdo[FB7$Fi\l$!3,W)Gvj;!oSFB7$Fc]l$!3*fn#4H7&oD$FB7$F]^l$!3cQMYqiSXCFB7$Fg^l$!3N/`V1lEJ;FB7$Fa_l$!3P(f`@(*\%p")F<7$F[`l$!3[m.#e4Dre(Fjddl7$Ff`l$"3l3w\$>U`;)F<7$F`al$"3DpZRC..K;FB7$Fjal$"3:?h+<K/ZCFB7$Fdbl$"3yh7xh!zuD$FB7$F^cl$"3^'zR#\8^lSFB7$F\el$"3DtqDD5!>([FB7$Fjfl$"3h@@8[s)fm&FB7$Fdgl$"3M:QS$fQ!QkFB7$Figl$"3Er7h3?y%>(FB7$F`bq$"3b56e0@`*o(FB7$F^hl$"3<c81aDOE$)FB7$Fcdam$"3Hg+/`a^#Q)FB7$Fifs$"3O@U[R?Z!Q)FB7$F[eam$"3%Q%z6t*=ZK)FB7$F]cq$"3'*REfzDgF#)FB7$Fags$"3mJDT!R#))))zFB7$Fchl$"36/"y*)pvo%yFB7$Fecq$"38'>3Yby(=%)FB7$Fhhl$"39;MXpJN)R*FB7$F]dq$"3Mr^yNCTy*)FB7$F]il$"31=6(=;GH?)FB7$Fj\\l$"3<nqo/+*zc)FB7$Fedq$"33zbiH#H=]*FB7$Fb]\l$"31J)\*\8Pk5F97$Fbil$"3c=.!3U%zN6F97$$"3["ek`^cJg*FB$"3)Rjn`c]'Q6F97$Fdcem$"3GgWwRP]L6F97$$"3w8/w(ytMl*FB$"3GW,9U$R&>6F97$F^]y$"3W>/5!G"4'4"F97$F\dem$"3q#3R>*z%*=5F97$F]eq$"3)oJSgpIV+*FB7$F`ddn$"3c"o8!)*R\g#)FB7$Facjl$"3#f[x`f(4AuFB7$Fhddn$"3GGy\!\&R'\'FB7$Ff]y$"3iFsTI)HD\&FB7$F`f_n$"3EtybG6N@WFB7$Ficjl$"3#)*Q"HqN>&H$FB7$Fhf_n$"3WBs\C6hF@FB7$Fgil$"3#Q'*>!QJ"3L*F<7$Fee]n$!3hnaN2]%)zKF<7$Fgigl$!3#3D./\*[%e"FB7$F]f]n$!3'>Ot"z/->GFB7$F^_v$!3]@OLf<q9SFB7$F\h_n$!3GUJ2F_gb^FB7$F_jgl$!3A=p:vH8FiFB7$Fdh_n$!3j!z[wJhj@(FB7$Fgao$!3=GXcSkL7")FB7$Fij]m$!3u,#fH&>$>f*FB7$Ff_v$!3ZO/QPb^i5F97$Fa[^m$!3=gy(=u<67"F97$F\jl$!3W.mQ]CqQ6F97$Fj^y$!3v#==@du03"F97$F_bo$!3)R"e0dF)Gj*FB7$Fb_y$!3sVH5B"))oh)FB7$Fajl$!3o3#zSKoV?)FB7$Fafq$!3y.NUw*)HB*)FB7$Ffjl$!3jg<;Nu)4V*FB7$Fifq$!34n)=9d:Nc)FB7$F[[m$!3yG/+,o?^yFB7$Fe[m$!300v_2z)>=(FB7$F_\m$!3_#3XjlnxV'FB7$Fi\m$!3AKjoLtKicFB7$Fg^m$!3vdn$e%z')p[FB7$Fe`m$!3"**)Q%pxL*oSFB7$F_am$!3!\ksdB#\dKFB7$Fiam$!3i%4T2W]gW#FB7$Fcbm$!3"HOGdM-8j"FB7$F]cm$!3<'H"=#y,(p")F<7$Fgcm$"3')*)o=L$4MJ*F[[_mF[dmFcdmF]jmFajm7*-F,6$7iv7$F0$!3It!*4>WX"="F57$F>$"3!>1C=:'QM&*F<7$FI$"3E\zQ%=XCp"FB7$FS$"3"y"z8*GJ5g#FB7$Fgn$"3dOlWE"Gh[$FB7$Fao$"3Ga*\ka#fAVFB7$F_q$"38];n8pz@^FB7$F]s$"37U:mPqA<fFB7$Fgs$"3AT")oYV:mmFB7$Fat$"3#HPar%=EbtFB7$F[u$"3U=@DPhf>zFB7$Fffr$"3.0))4_PNZ$)FB7$F`u$"31-^QO,+N$*FB7$$!3R$3-j!y"=7"F9$"3!f$)>X4J3T*FB7$Fe`]l$"3***eIN/*pk%*FB7$$!3y\i!R-Gq6"F9$"3AEx\Pag%\*FB7$Fj`]l$"3Qo!e]&zM*\*FB7$F_a]l$"3N3jgaT$HV*FB7$F^gr$"3.^_*QK)*QF*FB7$Fga]l$"3&\g&f]Y:#y)FB7$Feu$"3aVj+Z;gK$)FB7$$!3`;H2e$)>$3"F9$"3t48f_9/k#)FB7$Fb[il$"30G@vf4NM#)FB7$$!3R$3_v>1y2"F9$"3QWMo\[))[#)FB7$Fddw$"3e(z-Y#RM6$)FB7$Fj[il$"3*HTuk3=]e)FB7$Fhan$"3\27wCoGV!*FB7$F\ew$"3_Ln)=I)\G5F97$Fju$"3/))\2q2qG6F97$Fd`in$"32;t)od)eQ6F97$F_^\m$"3!ziF&3gWR6F97$F\ain$"3_!p"Q2I,I6F97$Fdjt$"3M_*)e(GL#46F97$Fg^\m$"3+qq*G6m1."F97$F`bn$"3Oc6R3cU2!*FB7$Fdf^n$"3:^H*HJ='p")FB7$Fggfl$"3eOY)**H-_@(FB7$F\g^n$"3H]@/FlsahFB7$F\[u$"36,?`s'*f,]FB7$Fga\n$"3st'Q9Lc<x$FB7$F_hfl$"3HXfK!\SK[#FB7$F_b\n$"3k'Rc3f>d:"FB7$F_v$!3D!\o@;]0!>F<7$Fgb\n$!3y!p)=@:IQ:FB7$Fghfl$!3#pp'**f13iGFB7$F_c\n$!3%))\K**oU19%FB7$Fd[u$!3XAZ,"Q.XN&FB7$F\i^n$!3y7j=/0)f['FB7$F_ifl$!3u/s(3Qq'>vFB7$Fdi^n$!3ugfAP*[GW)FB7$Fhbn$!3*y(G3PWyX#*FB7$Fg`\m$!3fs%GVb9o/"F97$F\\u$!3hRZ[6!Hu6"F97$Fa[hn$!3`Mo[qLRM6F97$F_a\m$!3'yMO#y$\-9"F97$Fi[hn$!3gr%\X)39O6F97$Fev$!3e"=qTU.M7"F97$F\gw$!348\.3@y;5F97$F`cn$!3))*o?XSHO%*)FB7$Fb_il$!3S3%4&yN[;&)FB7$Fdgw$!3oh:!))pa1G)FB7$Fj_il$!3Ql-kVoYP#)FB7$F_`il$!3)er3`r>8C)FB7$Fd`il$!35=^NMiv(G)FB7$Fjv$!3TAy]$)Qwq$)FB7$Fbhz$!3sB+.u,"=*))FB7$F_cp$!3G<%pd_[zP*FB7$F]]jm$!3O2mq^mhZ%*FB7$Fjhz$!3")*[[))Rb*)[*FB7$Fe]jm$!37Vbe/mP+&*FB7$F_iz$!3#*f5s#[/;[*FB7$Fdiz$!3Z;?0O#='e$*FB7$F_w$!3/HW&f$*\69*FB7$Fghw$!36G*[Y"=#)o&)FB7$Fgcp$!3%)QHd>8N%3)FB7$Fhail$!3_EB>CIh_zFB7$Fdiw$!3sYG<%R3,"zFB7$F`bil$!3kO^%)))>h\zFB7$Fdw$!3&*G#Q5')H30)FB7$Fjir$!3gT8G\kq%H)FB7$F_dp$!3?EQ^Cf6c%)FB7$Fc`an$!3zm7ao]-i%)FB7$Fbjr$!35\9S&R#))3%)FB7$F[aan$!3:r"Qos#=+$)FB7$Fiw$!3dM3Ti0$p9)FB7$Fgdp$!3"pN=>/1mx(FB7$F\ep$!3D!p:`_F>X(FB7$Fdcil$!3p,"[f7\oM(FB7$Faep$!3!=KJ3e?1H(FB7$F\dil$!3x8dC?#GEG(FB7$F^x$!3KtmevMe:tFB7$Fcx$!3y:$RLT3&)o'FB7$F]y$!3Vnu(Gj%)Q)eFB7$F[[l$!3/`R"*Gy4@^FB7$Fi\l$!3m]<@F[gAVFB7$Fc]l$!3j*)>A>)y&yMFB7$F]^l$!3Yj_'=WPHk#FB7$Fg^l$!33S=\;5]R<FB7$Fa_l$!3*="o7_5!*y%*F<7$F[`l$!3YTsqr!)\SRF]`l7$Ff`l$"3YA7%RfH'f$*F<7$F`al$"3u5l=B/="p"FB7$Fjal$"3poW.$fE3c#FB7$Fdbl$"3:%=naBR"eMFB7$F^cl$"3ve]C9UR.VFB7$F\el$"3kyeRihi;^FB7$Fjfl$"3K%p'pfRc))eFB7$Fdgl$"3-,?fk@T^mFB7$Figl$"3S)=a&y$[`J(FB7$F]`jl$"3=uj"GzH@G(FB7$F[bq$"3afJ(>F@HH(FB7$Fe`jl$"3,)p)e%Gm`N(FB7$F`bq$"3nQ+x"ev%puFB7$Febq$"3%pCYn=&*Q"yFB7$F^hl$"3u(G#ey9z!>)FB7$Fcdam$"3xC0p_ohP$)FB7$Fifs$"3mc_p*Q"zK%)FB7$F[eam$"3TNq^v*GmY)FB7$F]cq$"3gl:J'4:%Q%)FB7$Fags$"3d/N;%[O(R#)FB7$Fchl$"3/+t+r6#o*zFB7$Fb\v$"3g)4BIYQ1#zFB7$Fg\v$"3&)e!G$4WO@zFB7$F\]v$"3QdO)3UeS,)FB7$Fecq$"3ce#>AWSy>)FB7$Fd]v$"3*y.?;'pt_()FB7$Fhhl$"3G(\!*\>tlH*FB7$$"3^[(=U_&Qu()FB$"3k3J*)yC_*Q*FB7$Fcf^l$"3o0,M2'ogX*FB7$$"3O"e*)43iy#))FB$"3o@S:sc<$\*FB7$Fhf^l$"3M'\BhR;!*\*FB7$F]g^l$"3U'o73[#R;%*FB7$F]dq$"34v;CQ!R:A*FB7$Feg^l$"3(fXAhf/^l)FB7$F]il$"3AMEg[aq^#)FB7$Fj\\l$"362`,"z+ZU)FB7$Fedq$"3bg;D6GU^#*FB7$Fb]\l$"3;Rm-#QkM/"F97$Fbil$"3ucIOkeTJ6F97$Fc_jn$"3<4cx.=GR6F97$Fdcem$"38!)302-7R6F97$F[`jn$"3>:*)phC#*H6F97$F^]y$"3]"G`5(p$36"F97$F\dem$"33#zA:!)\0/"F97$F]eq$"3]:*zp&*4cD*FB7$F`ddn$"3]Qp_%4))\^)FB7$Facjl$"3H#HZeN-*pwFB7$Fhddn$"3t'R^G2nys'FB7$Ff]y$"3o4-ZK+m)p&FB7$F`f_n$"3%e$))4hz6%f%FB7$Ficjl$"3Kt'>'\M(yU$FB7$Fhf_n$"35"p'yM0/:AFB7$Fgil$"35i)3:cx&=(*F<7$Fee]n$!3/W#QJ.hkT$F<7$Fgigl$!3YE9,'R3+l"FB7$F]f]n$!3#)4nlS:hLHFB7$F^_v$!3pH-F=Q\tTFB7$F\h_n$!31$RW@=[=N&FB7$F_jgl$!39MhhAZ[_kFB7$Fdh_n$!3*eB=jOU7Y(FB7$Fgao$!3>d,,FrLm$)FB7$Fij]m$!3K9$*3S7&=$)*FB7$Ff_v$!3Eg#>E=j53"F97$Fa[^m$!3jlBoZ35J6F97$F\jl$!3/4rhm:WQ6F97$Fj^y$!3&>=Y"HLnh5F97$F_bo$!3B(yu#QrIz$*FB7$Fb_y$!3H;[[r"3AY)FB7$Fajl$!3<$fcR=$H[#)FB7$F][_l$!3l+p7">@.i)FB7$Fafq$!3VGL#fh<><*FB7$Fe[_l$!3Dfo-cu<z$*FB7$Fj[_l$!3R],1W)y&)[*FB7$$"3PT&Q`uJc6"F9$!36P(\;$4Z+&*FB7$F_\_l$!34;4#=)R-$[*FB7$$"3wC1RqRx?6F9$!3U![=y+XrV*FB7$Ffjl$!3=kf5]F&[O*FB7$Fifq$!3Y=IUN\!3K)FB7$F[[m$!3Ie=7KN-RzFB7$Fe[m$!3tlKd&*HdqtFB7$F_\m$!3SL#[Ib&ogmFB7$Fi\m$!3pGX"4)*)*\"fFB7$Fg^m$!3$Q>t_2Q%>^FB7$Fe`m$!3rP!=lulNK%FB7$F_am$!3"pI+2o8zX$FB7$Fiam$!3!>"fd*>i`l#FB7$Fcbm$!3N%H8%[A^x<FB7$F]cm$!3*)fmqTb7&[*F<7$Fgcm$"3It!*4>WX"="F5F[dmFcdmFjhm-Fjgm6%FbimQIThe~25~term~Fourier~approximation~(blue)F(FdhmFigmFfimF]jmFajm7*Figm-F,6$7\w7$F0$"36$e.(y.e)Q(F[[_m7$F>$"3#o=jp&oa8xF<7$FI$"3i;KMp+@D:FB7$FS$"37"4_b&[NeBFB7$Fgn$"3?%)G")=Xz$G$FB7$Fao$"3y$>2GGyiD%FB7$F_q$"37Gg&H2'3,^FB7$F]s$"3-vBH)4kv*fFB7$Fgs$"3Wp1S"pW)poFB7$Fat$"35R")[`=%**f(FB7$F[u$"3E,kr;i3z!)FB7$$!3.](oa1O,;"F9$"3')3`N_$o/.)FB7$Fjaw$"39-pP#>vY*zFB7$$!3U;H2$GY`:"F9$"3&H7J;e#\uzFB7$F_bw$"3]M$f1Bq@(zFB7$Fdbw$"3)z\#)G()>o-)FB7$Fffr$"3Sd+0NY]i")FB7$Facw$"31&>EJ;J&H')FB7$F`u$"3(*H<(HtYL<*FB7$Fe`]l$"3M%y/"3(*Q&Q*FB7$Fj`]l$"3//_Js"oV^*FB7$$!3h;/^T#QA6"F9$"3v5gKrA$3a*FB7$F_a]l$"31%[m/-9+a*FB7$$!3X$e9"f%[u5"F9$"3-U&e%=as6&*FB7$F^gr$"3#z%**y!eboX*FB7$Fga]l$"33#z=d)4jE!*FB7$Feu$"3o]RdLiR'\)FB7$Fb\[o$"3O*))\()4BTQ)FB7$Fb[il$"3())oA2g>\I)FB7$Fj\[o$"3Mu.%)[>`m#)FB7$Fddw$"3'y9N#4r@v#)FB7$Fj[il$"3iZO-y84\%)FB7$Fhan$"3k`f1(p/N$))FB7$F\ew$"3I1e')=oS05F97$Fju$"3_po4OZG?6F97$Fd`in$"3ofMg*f)RN6F97$F_^\m$"3exB1nhjT6F97$F\ain$"3Y$*f'[^xu8"F97$Fdjt$"3^nHx+;h@6F97$Fg^\m$"3([xq!>*p30"F97$F`bn$"3NQZj#Qb"\#*FB7$Fdf^n$"3rb$pn#p-9%)FB7$Fggfl$"3!z2A/d%[]uFB7$F\g^n$"3*ptoG3=&pjFB7$F\[u$"3Bi\oke_&=&FB7$Fga\n$"3?p84RL$f"RFB7$F_hfl$"3C(\0%=Wq!e#FB7$F_b\n$"3l&[3K$Gw,7FB7$F_v$!3Nla'p%Rcw>F<7$Fgb\n$!3Gc[!fz%R*f"FB7$Fghfl$!3uK#o-y!ptHFB7$F_c\n$!3mtMH$fMtH%FB7$Fd[u$!3!R\$pjmk[bFB7$F\i^n$!3#)fT"y*473nFB7$F_ifl$!3"oC23a!**exFB7$Fdi^n$!3'yi'*Hi%p(o)FB7$Fhbn$!3M@6ZKCB%[*FB7$Fg`\m$!3TB,3:S)f1"F97$F\\u$!3uWeP@YBG6F97$Fa[hn$!3_EpmDo6S6F97$F_a\m$!3#*)\1W'>hS6F97$Fi[hn$!3h1:!\%\7J6F97$Fev$!3'R!y@>KD86F97$F\gw$!3#yF&ot`7J**FB7$F`cn$!3M8"zD&G:X()FB7$Fb_il$!3IblOs&o%)R)FB7$Fdgw$!3EcQt?#4eE)FB7$F_`il$!3coiot-]K$)FB7$Fjv$!3<(*RrueU]&)FB7$Fbhz$!3a*zlI%\IN"*FB7$F_cp$!3yCn<p9#)=&*FB7$F]]jm$!3'zBxU7\Ha*FB7$Fjhz$!3)z@nl![VM&*FB7$Fe]jm$!3ay@!pdXR\*FB7$F_iz$!3a$oiE%RbB%*FB7$Fdiz$!3-*>]i<Bu?*FB7$F_w$!3%*p"R"Q'fQ#*)FB7$Fghw$!3#=@Ug"G$3M)FB7$Fgcp$!3RwYRy$=:+)FB7$Fhail$!3vG)p/lWC(zFB7$Fdiw$!3wJ*zikc!H!)FB7$F`bil$!3A)H-Dk'RY")FB7$Fdw$!3!3Et(4bC!H)FB7$Fiw$!3Tf*p$[I45zFB7$F^x$!3b)4\G%RN\vFB7$Fcx$!3hk8VZc"H'oFB7$F]y$!3H87*4`Nf1'FB7$F[[l$!3W;F&)*H&H)3&FB7$Fi\l$!3a"yf,F'QcUFB7$Fc]l$!33m6c`aunKFB7$F]^l$!3q0mY#or%*R#FB7$Fg^l$!3m+uSu*G!R:FB7$Fa_l$!3u3T$o7].q(F<7$F[`l$!3,zh8"o%>v))Fjddl7$Ff`l$"3'[Qn$fKauwF<7$F`al$"3XXIy(z9\_"FB7$Fjal$"3;s3E'))*eHBFB7$Fdbl$"3mr4[uHgIKFB7$F^cl$"3St^,l&z*eTFB7$F\el$"3H;66,(3j/&FB7$Fjfl$"3U1/<ytdggFB7$Fdgl$"3&f`"****)p*poFB7$Figl$"3l1DOSX)*[vFB7$F^hl$"3?Gy&)GM^hzFB7$Fchl$"3;7$p]La5A)FB7$Fb\v$"3dDU5s6@#3)FB7$Fg\v$"3Obll(*f$**)zFB7$Fc`]n$"3&ohs[r%)=(zFB7$F\]v$"36IDQ&G_n(zFB7$F[a]n$"3=3=jcSV1!)FB7$Fecq$"3AlOEa?mh!)FB7$Fd]v$"3:=KQMZH4&)FB7$Fhhl$"3[aYA?.9?"*FB7$Fcf^l$"3NF=ela-o$*FB7$Fhf^l$"3Iqh7Cg*e^*FB7$$"3V;/wP'Q8)))FB$"3&**REfO7Da*FB7$F]g^l$"3r$pe`;D]`*FB7$$"3G\7`%>:[$*)FB$"3=U^!)R1\$\*FB7$F]dq$"3DFB`Nvk>%*FB7$Feg^l$"3'3&[Hm=i#*))FB7$F]il$"3?Gk*Q!)*fe$)FB7$$"3e;z>O$=1?*FB$"37bK1"RxKH)FB7$F[g]m$"3'=El[uqZE)FB7$$"3')[Pf3c$4D*FB$"320ebnA#zF)FB7$Fj\\l$"3;'p^<U2hL)FB7$Fhg]m$"3m4ev@6T#f)FB7$Fedq$"33<p^uo!R-*FB7$Fb]\l$"3F%>J_)pM@5F97$Fbil$"3+8%*f&>aS7"F97$Fc_jn$"3#f?p![-%o8"F97$Fdcem$"36#=`)3:qT6F97$F[`jn$"3"y'f#e*zTP6F97$F^]y$"3K]>!QJJH7"F97$F\dem$"3l]Vv2G9g5F97$F]eq$"3Ew=WaM*Q\*FB7$F`ddn$"3*=%pB$pa(f()FB7$Facjl$"3W:)\w*=&3"zFB7$Fhddn$"3!Ggms-g[&pFB7$Ff]y$"33p\'Q=W@!fFB7$F`f_n$"3vczt!QIbw%FB7$Ficjl$"3l,**)p$3+gNFB7$Fhf_n$"3Pf:ZkFK-BFB7$Fgil$"3$z5Ll&=i55FB7$Fee]n$!3?w"f^qrIb$F<7$Fgigl$!3-*z$H2nY:<FB7$F]f]n$!3WO#Q/Mey/$FB7$F^_v$!3ay@q9yFJVFB7$F\h_n$!3zEl()>p"fa&FB7$F_jgl$!3TN=&z$z"Rn'FB7$Fdh_n$!3Mb2F-?')*p(FB7$Fgao$!3d::9i^<6')FB7$Fij]m$!3FL&)[)ffb+"F97$Ff_v$!3)Q5Us(=E(4"F97$$"39m"zp.TA."F9$!3Y#>QMMYP7"F97$Fa[^m$!3w%*fFH(z"Q6F97$$"3+L3xT1]P5F9$!32Da:a(e:9"F97$F\jl$!3j>lA$39^8"F97$Fj^y$!3$\nd<xG6/"F97$F_bo$!3[1P.!ffU9*FB7$Fiejl$!3=aQJKs!)f')FB7$Fb_y$!3z=[=x'p1O)FB7$$"3y*\7`(yJu5F9$!3xPkA8zS(G)FB7$Fafjl$!3\bs*=kRRE)FB7$$"3VmT5![x&z5F9$!3F_9!=>-oG)FB7$Fajl$!3*oQFwGE2N)FB7$F][_l$!3%p6M4.-V&))FB7$Fafq$!3r(G+*zY"=Q*FB7$Fei]n$!35"z#fj*e\Y*FB7$Fe[_l$!3&pzBJ<;%>&*FB7$F]j]n$!3e*epe6_Ha*FB7$Fj[_l$!3dl#)*o&)zZ`*FB7$F_\_l$!3os$o5ibrU*FB7$Ffjl$!3r5jpusi;#*FB7$Fe`y$!3.S4VO7*)Q')FB7$Fifq$!3)QQP&3cCV")FB7$$"3^T5l&4&[Y6F9$!3vvJECWFl!)FB7$Fbay$!3N'R#*)e^S5!)FB7$$"3oCJq?ti^6F9$!3Pib..(p"zzFB7$Fgay$!3F'[[HsN5(zFB7$F\by$!371&[N<6q,)FB7$F[[m$!316ZJ*Q')f7)FB7$F`[m$!3*3SruaD\%zFB7$Fe[m$!3#)Hqp[]6:wFB7$F_\m$!3iC:-/rEqoFB7$Fi\m$!3q'R#y(3Vg+'FB7$Fg^m$!3!*yP(Q>m)o]FB7$Fe`m$!3"\<*HSoVlUFB7$F_am$!3ub!3[hM-B$FB7$Fiam$!3Wc[F\/w9CFB7$Fcbm$!39C5]DG;b:FB7$F]cm$!3)y\T#p:z,xF<7$Fgcm$!36$e.(y.e)Q(F[[_mF[dmFcdmFjhm-Fjgm6%FbimQIThe~26~term~Fourier~approximation~(blue)F(FdhmFfimF]jmFajm7*FigmFjhm-Fjgm6%FbimQIThe~27~term~Fourier~approximation~(blue)F(FdhmFfim-F,6$7jw7$F0$"3U;M;x1[tRF57$F>$"3!=WCQg'*z#)*F<7$FI$"3\$R**4m#**\<FB7$FS$"34"z['RU^YDFB7$Fgn$"3R6P*e#QalKFB7$Fao$"3(HUj2M@C0%FB7$F_q$"3JwnLf@@m[FB7$F]s$"3j*)\x+][,eFB7$Fgs$"3^:.AeW,aoFB7$Fat$"3HOrd,31txFB7$F[u$"3RS4B&G60I)FB7$Fjaw$"33cuepJ0m")FB7$F_bw$"3QLel_$*fl!)FB7$Fdbw$"3alVW*4*3F!)FB7$Fffr$"34#yZQ8q&p!)FB7$Facw$"3>o%QDr"H3%)FB7$F`u$"3"**4Nwa;?'*)FB7$Fj`]l$"317qE$)3(\W*FB7$F^gr$"3d%zXX`XFd*FB7$Fga]l$"3[.H)>i3aD*FB7$Feu$"3qcE2J!Q^p)FB7$Fb[il$"3A#z1x=2sU)FB7$Fddw$"33UM'GJ6fH)FB7$Fj[il$"3Q%\WR+QRO)FB7$Fhan$"3Ryp,#34+m)FB7$F\ew$"3u.Sx)e:<#)*FB7$Fju$"3bJ<*z6)G46F97$Fd`in$"3S*H)[JmTH6F97$F_^\m$"3Sa&Q%Q.)49"F97$F\ain$"3?XKlv>=U6F97$Fdjt$"3X9]2$QJ98"F97$Fg^\m$"3b?'4%=m9p5F97$F`bn$"3D&HtzO>*y%*FB7$Fdf^n$"3**RET]9")\')FB7$Fggfl$"3LG"z-+7+o(FB7$F\g^n$"3!G(4`-m$3e'FB7$F\[u$"3KAFL@=jn`FB7$Fga\n$"3U=v=>UMfSFB7$F_hfl$"3A$4Dbh_zn#FB7$F_b\n$"3OY%=o\%yZ7FB7$F_v$!3p;96und_?F<7$Fgb\n$!31*yo65P/m"FB7$Fghfl$!3aGk"y]p\3$FB7$F_c\n$!3o6Z2Iy+`WFB7$Fd[u$!3aA%[F(=aSdFB7$F\i^n$!3W^xHgS;EpFB7$F_ifl$!31=$)HFYt"*zFB7$Fdi^n$!39]pRH6#H#*)FB7$Fhbn$!3Kc#[DV#f4(*FB7$Fg`\m$!3fau%\L6J3"F97$F\\u$!3#Gr"3jQSO6F97$Fa[hn$!3`cRo/s.V6F97$F_a\m$!36XPhm,8Q6F97$Fi[hn$!3A&Ht(f7PB6F97$Fev$!3e'3%))*pM15"F97$F\gw$!3K\ny.QC'p*FB7$F`cn$!3bx)z#47>'e)FB7$$!31,+vV5T>$*FB$!3v_P7))*[0V)FB7$Fb_il$!3%>cp=zsJL)FB7$$!3?++DJ!o_E*FB$!3ew7Lv")Q$H)FB7$Fdgw$!3?6wIU4r2$)FB7$F_`il$!3+,oH]f"HZ)FB7$Fjv$!3JgQ'pJc-w)FB7$Fbhz$!3n')po%f.9N*FB7$F_cp$!3_l!e5'Qk#e*FB7$F_iz$!3$fz4iov#)G*FB7$F_w$!3CCRCQ*H()o)FB7$Fghw$!3#*HBk&fe$y")FB7$Fgcp$!3#)o)Qhi,4.)FB7$Fdiw$!3Y-1FS)R(G#)FB7$Fdw$!3q.q%>mFP^)FB7$F^[dm$!3x,4!o*e2*e)FB7$Fjir$!3$=qoEY^Fg)FB7$Ff[dm$!3u&R-F7Z![&)FB7$F_dp$!3f'fu>M9&H%)FB7$Fbjr$!3gN)RfO8j1)FB7$Fiw$!3OB*QdOZFp(FB7$Fgd\m$!3,6&4<*evevFB7$Fgdp$!3Y_f0O2zyuFB7$F_e\m$!3cwKaNg)eX(FB7$F\ep$!3F)RMt)4x$[(FB7$Faep$!3n)))e;o!yHwFB7$F^x$!3T[qaG\QfxFB7$Fcx$!3a.(*[XuL,oFB7$F]y$!3&Q&QCzpbhfFB7$F[[l$!3<z"y0,-[&[FB7$Fi\l$!3$[$**="RzC0%FB7$Fc]l$!3@I"*G7OLlKFB7$F]^l$!3/Uaif9xYDFB7$Fg^l$!3\z'zYkIQx"FB7$Fa_l$!3E&R@Qtiky*F<7$F[`l$!3c1^bd(f"RRF]`l7$Ff`l$"3#p[KF)ov&p*F<7$F`al$"3g()yCITH\<FB7$Fjal$"3O3M<dK<VDFB7$Fdbl$"36'fQp9KgE$FB7$F^cl$"3=P4C#o5=,%FB7$F\el$"3:=_WE&G7#[FB7$Fjfl$"3r0yH()*oL%fFB7$Fdgl$"3)Q<P+&zk$)oFB7$Figl$"3)R%QKG(>#fxFB7$F[bq$"3Kc`a,Z,CwFB7$F`bq$"3\aFS"RCvZ(FB7$F]^]n$"3VKifYu*eX(FB7$Febq$"3e`O4ky5!\(FB7$Fe^]n$"31c!><2U_e(FB7$F^hl$"3!oL`rs?dt(FB7$Fifs$"3W]grNE(>8)FB7$F]cq$"3(o'p"o5zH[)FB7$$"3w!e9"fPj[")FB$"3M#)foGZwR&)FB7$F_ggl$"37--7[>jz&)FB7$$"3kZP%)R$[v>)FB$"3`Iy7EMW,')FB7$Fags$"3Ge!\^iQ[g)FB7$Fgggl$"3dJ_(G&f+f&)FB7$Fchl$"3@Z$*\ebHb%)FB7$Fg\v$"3&3R&*HxPa:)FB7$Fecq$"3%\Dj?e,8.)FB7$Fd]v$"3()f"Qe0#R1$)FB7$Fhhl$"3S^aroga+*)FB7$Fcf^l$"3H\(H#*>l#3#*FB7$Fhf^l$"3q-\c><G[%*FB7$F^c^o$"3Y="zT=Au_*FB7$F]g^l$"3Md$Q:,KKd*FB7$Ffc^o$"3d_so%fPIe*FB7$F]dq$"3shD9(3[fb*FB7$Feg^l$"3OGt'34W"G"*FB7$F]il$"3%RMe,#yV7&)FB7$Fdd^o$"310],oCy0%)FB7$F[g]m$"3W)eLmrQ3L)FB7$F\e^o$"397c_Tdb%H)FB7$Fj\\l$"3NV6Al<b-$)FB7$Fhg]m$"3K"RdVA__Y)FB7$Fedq$"3?y*Hs%*ef#))FB7$Fb]\l$"37$\*Gcq"o)**FB7$Fbil$"3]j$*[-[096F97$Fc_jn$"3_*y#=4+fJ6F97$Fdcem$"3QIoo='Q99"F97$F[`jn$"3J*zj7Qa@9"F97$F^]y$"3yAJ,$4_C8"F97$F\dem$"3G\`$f3Rx2"F97$F]eq$"3[gf/n3/>(*FB7$F`ddn$"3Q_?hV[i%**)FB7$Facjl$"3xqXhA"*yW")FB7$Fhddn$"3=pV*)))4DxrFB7$Ff]y$"3([#=vy$**G5'FB7$F`f_n$"3Yh0y$)=aN\FB7$Ficjl$"3+D*3E^b:p$FB7$Fhf_n$"3'>L$e)>_%*Q#FB7$Fgil$"3^*GXM8t$\5FB7$Fee]n$!3wc,g8on*o$F<7$Fgigl$!3$Q4VN3i3y"FB7$F]f]n$!3E[zPI![<;$FB7$F^_v$!3.">Qq@=!)[%FB7$F\h_n$!3EVLPU5uPdFB7$F_jgl$!3C'4PpF?8*oFB7$Fdh_n$!3\Mg)4dp?$zFB7$Fgao$!3rjh'pK"oY))FB7$Fij]m$!3!*4[t!R5j-"F97$Ff_v$!3)p**pYs]66"F97$Fhj^o$!3OGHT_f2L6F97$Fa[^m$!3%*zgf(y([U6F97$F`[_o$!3GzFk$yJ19"F97$F\jl$!3<8%e#=!)**G6F97$Fj^y$!32B!H-[i&>5F97$F_bo$!3Gk1rC/qM*)FB7$Fiejl$!3cGPuV1R<&)FB7$Fb_y$!3M&)ykiZF8$)FB7$Fd\_o$!3!RAb/f$G#H)FB7$Fafjl$!3qloO0V%3K)FB7$F\]_o$!3k,x)>.;HR)FB7$Fajl$!3SE#f;-"z+&)FB7$F][_l$!3GJD/.&y+4*FB7$Fafq$!3M')[45"p\`*FB7$Fei]n$!3kSEp!\(pv&*FB7$Fe[_l$!3ufgZ"e#\#e*FB7$F]j]n$!3r\()>t"y`b*FB7$Fj[_l$!3!pn97)o'f\*FB7$F_\_l$!3URdby6s$H*FB7$Ffjl$!3`,EN4wb8!*FB7$Fe`y$!3e\5uuua;%)FB7$Fifq$!3U)Hg.=r.1)FB7$Fbay$!3MM#RrS[&G!)FB7$Fgay$!3#y'GtO#*z'3)FB7$F\by$!3Egrkvwr3#)FB7$F[[m$!3W6I06ztd$)FB7$F_\hl$!3+37\Co)**\)FB7$Fijs$!3=X!>tAp#*e)FB7$Fg\hl$!3%=B26Q7#*f)FB7$Fagq$!3WsvaO$*>@&)FB7$Fa[t$!3p'>ae3zi:)FB7$F`[m$!3U_rqs/e@xFB7$Fegjl$!3KV*)yT*4Mc(FB7$Figq$!3*4N/>0aUZ(FB7$F]hjl$!3f%>q+,.#euFB7$F^hq$!3*zHE"H_2/vFB7$Fchq$!3<`3&Gt>3o(FB7$Fe[m$!37LQG?#yGx(FB7$F_\m$!3_(p3+Q9a'oFB7$Fi\m$!3?mU)HbSl"eFB7$Fg^m$!3W!y_10i&Q[FB7$Fe`m$!3[*QdtGfu0%FB7$F_am$!3rv,'zqYgE$FB7$Fiam$!3EO2K'y_ia#FB7$Fcbm$!3X$*3w6U))*y"FB7$F]cm$!3u&f`(fL9"z*F<7$Fgcm$!3U;M;x1[tRF5F[dmFcdmF]jmFajm7*FigmFfim-F,6$7ju7$F0$"3(pmbT%>@9CF57$F>$"3O(oFF@IHf(F<7$FI$"35F:Y-XTF:FB7$FS$"3c:A@f)[R^#FB7$Fgn$"3#4kw*oj$4Z$FB7$Fao$"3Dfoyjx57UFB7$F_q$"35)[5M/>p)[FB7$F]s$"3/%pWvGv;j&FB7$Fgs$"3g[*RvRu'\mFB7$Fat$"3)4iT37$G#y(FB7$F[u$"3;"4JFdy\_)FB7$F`u$"3Whdmpt>N()FB7$Feu$"3@pF/Y/Y7*)FB7$Fb[il$"3([y7">t,!f)FB7$Fddw$"36z8YU>Eo$)FB7$$!3#)\7.PSTs5F9$"3<%Q)*GvV>K)FB7$Fj[il$"3,4)*4sY&)H$)FB7$$!3o;/^w=-n5F9$"3/p$\[v-uR)FB7$Fhan$"3&e'[)[7<q_)FB7$F\ew$"3kx$yN<_Vf*FB7$Fju$"3e]DI&G'3'4"F97$Fd`in$"3J.50[L$47"F97$F_^\m$"35CVh60pP6F97$F\ain$"3ww*[]xpU9"F97$Fdjt$"32[JWI*z(Q6F97$Fg^\m$"323n_P5^&3"F97$F`bn$"3EQAW/4f'p*FB7$Fdf^n$"3cmN3H2#o())FB7$Fggfl$"3z'fE(*o]O!zFB7$F\g^n$"3Ry29i]e)y'FB7$F\[u$"3S-n>q*fya&FB7$Fga\n$"3=Vm11E'>?%FB7$F_hfl$"39`Z(>Cx\x#FB7$F_b\n$"3OD:!Qx$y$H"FB7$F_v$!3:*=wug)eG@F<7$Fgb\n$!3>N$>0aE9s"FB7$Fghfl$!3y'ztj&\!f>$FB7$F_c\n$!38Ky$f3Gwg%FB7$Fd[u$!3<:.Xh,7IfFB7$F\i^n$!3quUOu0+SrFB7$F_ifl$!3uc?)QUgx@)FB7$Fdi^n$!3:ib(>Iz$["*FB7$Fhbn$!3[vZK6"e<#**FB7$Fg`\m$!3cUHk>'>#)4"F97$F\\u$!3uB'RD9T?9"F97$F_a\m$!3wrW+D</L6F97$Fev$!3b-Lh&4`f3"F97$F\gw$!3b%*Rs")enp%*FB7$F`cn$!3#z!Gd-0Oq%)FB7$F^^`o$!3ki&RM,QTO)FB7$Fb_il$!3@)4BxyH*>$)FB7$Ff^`o$!3Osa\x01M$)FB7$Fdgw$!3%G_.&)>.+S)FB7$F_`il$!3')3f&[a,-l)FB7$Fjv$!3n4OVgf2$)*)FB7$F[]an$!3wrIT4[L%H*FB7$Fbhz$!3E_4KbkoA&*FB7$Fc]an$!3rp(G4Zn%*e*FB7$Fh]an$!3.=[9Hwq>'*FB7$F]^an$!3d1,0^KC7'*FB7$F_cp$!3Q^-Z>x"zc*FB7$F_iz$!3gS<7o=5*4*FB7$F_w$!3xdie\mit%)FB7$Fbhw$!3QeMpT^BR#)FB7$Fghw$!3'oO5Q(4?1")FB7$F\iw$!3#\PqIwrQ3)FB7$Fgcp$!3C')ok'zR$e")FB7$Fdiw$!3/X:k\Nsb%)FB7$Fdw$!3x)G]+fa?m)FB7$F_dp$!3!z;f1HCPC)FB7$Fiw$!3efmgq<<!e(FB7$F\ep$!3;Jo*4"QA"p(FB7$F^x$!3Iv!z@lS?$yFB7$Fcx$!3![U:&)>=5e'FB7$F]y$!3c.&[mSf!QdFB7$F[[l$!3Q-"\Av)e()[FB7$Fi\l$!3g%[)yH]47UFB7$Fc]l$!3Rh">'H;VjMFB7$F]^l$!3?'Q'HKzzsDFB7$Fg^l$!3IP")z*\bqc"FB7$Fa_l$!3jKm`>qnjvF<7$F[`l$!39x;I_APE5Fhiv7$Ff`l$"3&*)fjs"p`/vF<7$F`al$"3W[H=C&\k_"FB7$Fjal$"3$\_**f!))*GY#FB7$Fdbl$"3q/(zK%>#GW$FB7$F^cl$"3v7-oa$*\?UFB7$F\el$"3K]ibGjQ"*[FB7$Fjfl$"3<^cxKi*Hs&FB7$Fdgl$"3IbO;5,%Rp'FB7$Figl$"3!3#y@))=IKyFB7$F]`jl$"3W1pQ'H@0'yFB7$F[bq$"3LgGdba!\$yFB7$Fe`jl$"3[$>g_%zlnxFB7$F`bq$"3/-@/lBXzwFB7$F]^]n$"3AA1/4@$ef(FB7$Febq$"3gz%*)GTRDa(FB7$Fe^]n$"381@(GM71a(FB7$F^hl$"37A]&)Gc;-wFB7$F]cq$"3")o8j:z/@$)FB7$Fchl$"3v8B:[aMP')FB7$Fhhl$"3@<4%\bIKn)FB7$F]il$"3K%p19-o**p)FB7$F[g]m$"3I^?"[FO_W)FB7$Fj\\l$"3Fp>Y#*)o<K)FB7$Fhg]m$"3">/=F@&e&Q)FB7$Fedq$"3:B@f#)>wi')FB7$Fb]\l$"3aPZ`+c&4w*FB7$Fbil$"3NA.!>Kv<5"F97$Fc_jn$"36Jn5'H5Q7"F97$Fdcem$"3OV&Rc9Q&Q6F97$F[`jn$"3p4,;DYFW6F97$F^]y$"3cI5KM'*[R6F97$F\dem$"3qOYb*HeL4"F97$F]eq$"3<Iu,*)o%4$**FB7$F`ddn$"3y^c6@2X>#*FB7$Facjl$"37F'))=[o:P)FB7$Fhddn$"3MED$3<A\R(FB7$Ff]y$"3a/D^&*\%3I'FB7$F`f_n$"3\sS40n5/^FB7$Ficjl$"3/I_u?u^AQFB7$Fhf_n$"3'3;A,CBkZ#FB7$Fgil$"3o'frc56")3"FB7$Fee]n$!3IJ&e'[hFEQF<7$Fgigl$!3Awr8)=#>Y=FB7$F]f]n$!3!Gtsm$yEvKFB7$F^_v$!3=.)QL%*zOk%FB7$F\h_n$!3-()R*4z^s#fFB7$F_jgl$!3zm!\$RQe/rFB7$Fdh_n$!3$[]tXICx:)FB7$Fgao$!3V%=RzW0F2*FB7$Fij]m$!37E8bCkVX5F97$Ff_v$!3$>_0s*)yF7"F97$Fhj^o$!3ISt(Q)["*R6F97$Fa[^m$!32;82LJ<W6F97$F`[_o$!39#eShvtq8"F97$F\jl$!3c<K8shQ?6F97$Fj^y$!3)z$)>hoGd(**FB7$F_bo$!3&4f#*=T[iv)FB7$Fiejl$!33zkU/=e?%)FB7$Fb_y$!3kpRpTVY=$)FB7$Fafjl$!3LcL=I6%pU)FB7$Fajl$!3?rxgMp[&o)FB7$F][_l$!3!\&3v&)4Y3$*FB7$Fafq$!3V&\!z<3<?'*FB7$Fj[_l$!3)z]eeo%)GQ*FB7$Ffjl$!3SSKE%G)f)y)FB7$Fe`y$!3$H@'zoPg^#)FB7$Fifq$!3q%)eS`vZ"3)FB7$Fgay$!3P#etW=GyF)FB7$F[[m$!3-,6L'3BFd)FB7$F_\hl$!3**o/P\lcd')FB7$Fijs$!3&e^X2ahZl)FB7$Fg\hl$!30K(=.)H?e&)FB7$Fagq$!3Aox'G/9FQ)FB7$Fa[t$!3,W%HQnD!HzFB7$F`[m$!3qsc)*=ph%f(FB7$Fegjl$!34z`Aj\VOvFB7$Figq$!36xG^7Y?`vFB7$F]hjl$!3-(p>5w-di(FB7$F^hq$!3#R(Qv&*)eKs(FB7$Fehjl$!3V#o>kKM5"yFB7$Fchq$!3>fiCe>*y&yFB7$F]ijl$!3N#4=CH6J%yFB7$Fe[m$!3K\2k^!G0w(FB7$F_\m$!3z*)*3tqHhm'FB7$Fi\m$!3[ZYRPqMRcFB7$Fg^m$!3A=@=/b2*)[FB7$Fe`m$!3#4:g=l65@%FB7$F_am$!3;&=4$pEfUMFB7$Fiam$!3a$Q\()fV;f#FB7$Fcbm$!3<72D*y?^g"FB7$F]cm$!33$Rl'=A!pc(F<7$Fgcm$!3(pmbT%>@9CF5F[dmFcdm-Fjgm6%FbimQIThe~28~term~Fourier~approximation~(blue)F(FdhmFjhmF]jmFajm7*Figm-F,6$7`w7$F0$"3RQue>%oOT#F57$F>$"3MlD3ygRz(*F<7$FI$"3+h%Q(*=uFp"FB7$FS$"3aL'GN'*fMQ#FB7$Fgn$"3#*o3Ra[g!H$FB7$Fao$"35:G$*>i&\K%FB7$F_q$"3LgD:<XY0^FB7$F]s$"3[g6Z66nJdFB7$Fgs$"350")G>+(zY'FB7$Fat$"3?Q`%zB9Pj(FB7$Fdhhl$"3k$H)e?],)z(FB7$Fg_p$"3cC<#>`6h!zFB7$F\ihl$"3OR%3B5$*=%zFB7$F\`p$"3#oT^&Qi$o!zFB7$Fa`p$"30T0PUk/;xFB7$Fft$"3DM+N[x73wFB7$Fi`p$"3'4])eI@W_#)FB7$F[u$"3kRG]Y0*pp)FB7$F_bw$"3%)=&f:9FqX)FB7$Fffr$"3q@Ha=WF%=)FB7$F\cw$"3_=u#*eU!*G")FB7$Facw$"3A6vy/qxk")FB7$Ffcw$"3e[L9@f&3I)FB7$F`u$"3zxti/X)o_)FB7$Fj`]l$"3Ws*fr9F)="*FB7$F^gr$"3bF2Sz\I#e*FB7$Ff``l$"3x:&4#QP4c'*FB7$Fga]l$"3m$zV?!>t&f*FB7$F^a`l$"3.4%>5jx&4%*FB7$Feu$"3ob+Rkb*=8*FB7$Fb[il$"3p`&*e"Qa0y)FB7$Fddw$"3-n[E`\$[[)FB7$Ff]bo$"3@uVqd]y*Q)FB7$Fj[il$"3Y"oP)y;*[M)FB7$F^^bo$"3$3f&fuFte$)FB7$Fhan$"3wZTKh:'pV)FB7$F\ew$"3mS0+C-$yP*FB7$Fju$"3*pByv'41"3"F97$F_^\m$"3eH5+g?*>8"F97$Fdjt$"3#RG%zZhvV6F97$Fg^\m$"3%[7![W\)**4"F97$F`bn$"3*zQ(HcI2-**FB7$Fdf^n$"3g(\<"*R?\4*FB7$Fggfl$"3$)pFC-^F@")FB7$F\g^n$"3#\n,<(*pE*pFB7$F\[u$"3/ODSBR:EdFB7$Fga\n$"3-Zq[5CwVVFB7$F_hfl$"3qp>="\q<(GFB7$F_b\n$"3KxM)p&)f(R8FB7$F_v$!3cV0$4T*f/AF<7$Fgb\n$!3&H8v/AhBy"FB7$Fghfl$!3aTYf2`[1LFB7$F_c\n$!3Zu=Y#\h6w%FB7$Fd[u$!3@QnbuVJ<hFB7$F\i^n$!3!p/'4/h_\tFB7$F_ifl$!3'GD3)Hi$pV)FB7$Fdi^n$!3'=!3P$GSRO*FB7$Fhbn$!3&*zDi%zl?,"F97$Fg`\m$!3!*4(zZoR86"F97$F\\u$!3L,M`.JEX6F97$F_a\m$!3+e?RxtfD6F97$Fev$!3TUITxthp5F97$F\gw$!3]fj@u3Dd#*FB7$F`cn$!3y^#)RRPQ*R)FB7$Fdgw$!3C&ovC4JT`)FB7$Fjv$!3/xu&Q?9??*FB7$F[]an$!3Ta%)HuPm"[*FB7$Fbhz$!3%434Y`moj*FB7$Fc]an$!3meiY_AHc'*FB7$Fh]an$!3w$e>/v>aj*FB7$F]^an$!3))=7Kl#ffd*FB7$F_cp$!3'ez+%pxn"[*FB7$F_iz$!3"=%oYu]p%)))FB7$F_w$!3*z%eK%R'o5$)FB7$$!3z++]([2ko)FB$!3D(4b.gf:A)FB7$Fbhw$!3jJ&>94(oh")FB7$$!3#)****\i1BM')FB$!3%)HDn$)R)=8)FB7$Fghw$!3!y/cS;T78)FB7$F\iw$!3\oYj5w%f?)FB7$Fgcp$!3d/YSn8Q]$)FB7$Fhail$!3'ojWJH!G;&)FB7$Fdiw$!3A$4LU0rQl)FB7$F`bil$!39(*om"e!zA()FB7$Fdw$!3"RV_W$pH+()FB7$F^x$!3(zovt'y%ot(FB7$Fcx$!3#**='Q)QV#HkFB7$F]y$!3A8I)\P+&=dFB7$F[[l$!3vz![+&=l/^FB7$Fi\l$!3[_wW\(G]K%FB7$Fc]l$!3loQ74c`uKFB7$F]^l$!3mW70!)[E+CFB7$Fg^l$!3E:LUqe"\p"FB7$Fa_l$!3TR(ze)4$[v*F<7$F[`l$!3z$zd![5sPRF]`l7$Ff`l$"33%))p"fox*p*F<7$F`al$"3!yh)3&*pn#p"FB7$Fjal$"3._')3D$f]P#FB7$Fdbl$"3^$oD1j$\PKFB7$F^cl$"3'Q(o?^Uh^UFB7$F\el$"3c3$Qw)fU*4&FB7$Fjfl$"3QdpC3.&zr&FB7$Fdgl$"3irz^#fdt\'FB7$Figl$"3U)*R*)e\^PxFB7$F]`jl$"3m:Dwk'R.'yFB7$F[bq$"3'yW&3+YOHzFB7$Fe`jl$"3=e\O))pIQzFB7$F`bq$"3g`_)o6eH*yFB7$Febq$"3ne,d0,U;xFB7$F^hl$"3]>t(='y>2wFB7$F]cq$"3M8Wg'oEa5)FB7$Fchl$"3zm"3rAdHs)FB7$Fg\v$"3$pgCNT!3)e)FB7$Fecq$"3w'>wn'fdh#)FB7$Fj_dn$"3)pBR7$R5'>)FB7$Fb[y$"3C/%yd-[,:)FB7$Fb`dn$"3)[ABX#['*G")FB7$Fd]v$"3gPF&>q'[O")FB7$Fj[y$"3j'GfHL1^C)FB7$Fhhl$"3o"orC%REs%)FB7$Fhf^l$"3M/KU#\*fC"*FB7$F]dq$"3D\/X`[18'*FB7$Fgian$"3y(=FI[MAl*FB7$Fbial$"3OGJ<z<d\'*FB7$F_jan$"3]O!f^>QYg*FB7$Feg^l$"3EQ&of#3c>&*FB7$Fjial$"3"y`[<%eC]#*FB7$F]il$"3qfM3%>&y1*)FB7$F[g]m$"3#f**y60G")f)FB7$Fj\\l$"3K2WS"yj"*Q)FB7$Fcg]m$"3?c4/**R'fM)FB7$Fhg]m$"3n2!44YmNN)FB7$F]h]m$"3=CVfN-"oT)FB7$Fedq$"35XY"RKTz`)FB7$Fb]\l$"32Elu*o'pT&*FB7$Fbil$"3#yzUC3"e(3"F97$Fdcem$"3oS5MK,AL6F97$F^]y$"3axk%R*f9W6F97$F\dem$"3WFL'R^Fq5"F97$F]eq$"3C)H)QCT&H,"F97$F`ddn$"3&\fGw#e5M%*FB7$Facjl$"3GsoXrh0"f)FB7$Fhddn$"33a3N#\hxg(FB7$Ff]y$"3)fkz.w-f\'FB7$F`f_n$"3&))4'[T)z6F&FB7$Ficjl$"3U.qQvm'G&RFB7$Fhf_n$"3vC7r5.BjDFB7$Fgil$"39@XH#HNo7"FB7$Fee]n$!3]yva+&pG'RF<7$Fgigl$!3;O-p)oa9">FB7$F]f]n$!3d,q[i]S)Q$FB7$F^_v$!3iKZ1w$G#)z%FB7$F\h_n$!3;t'*=%4#Q9hFB7$F_jgl$!3/NXex_g8tFB7$Fdh_n$!3:gA2/bpw$)FB7$Fgao$!3+;H11m6*G*FB7$Fij]m$!3N2R3E<%H1"F97$Ff_v$!3SO=B9_?K6F97$Fhj^o$!38m+MBsOW6F97$Fa[^m$!37^SELrRV6F97$F`[_o$!3G*Qa)\P6J6F97$F\jl$!3-D(GRl#e46F97$Fj^y$!3F"\@Fibsv*FB7$F_bo$!3!f6aKQ,Jh)FB7$F_\^m$!3#=zhyjK+Y)FB7$Fiejl$!3MI9=K9Hq$)FB7$Fg\^m$!3M_#G9K!eU$)FB7$Fb_y$!3:k:^A)eBP)FB7$Fafjl$!3)GFK6U!)Gd)FB7$Fajl$!3_>'4zO(f!*))FB7$F][_l$!3A3eEs8(H\*FB7$Fafq$!3rVmv#G/Oj*FB7$Fj[_l$!3ec?\3cG9#*FB7$Ffjl$!3yupQ?rYv&)FB7$F``y$!3gH`eaU@@$)FB7$Fe`y$!3VeJez*ex;)FB7$Fj`y$!3J&zg\!=[H")FB7$Fifq$!3')QUC(\)H&>)FB7$Fgay$!3U^0$Ga)['\)FB7$F[[m$!3y3[e!3&*yr)FB7$Fagq$!3i7.&*o:9v")FB7$F`[m$!3d&GL?6&o2wFB7$Figq$!3cSv+_ydUxFB7$F^hq$!3(4_U>+p3#zFB7$Fehjl$!35)e68)QJSzFB7$Fchq$!3$fF!*pbg$))yFB7$F]ijl$!3TV5z9`enxFB7$Fe[m$!3Sb6J`V"of(FB7$F_\m$!39>K(e3*[ykFB7$Fi\m$!3]S">yTN!HdFB7$Fg^m$!3!yb0(Ghr-^FB7$Fe`m$!3qK#3%4U.JVFB7$F_am$!35r,ERw7PKFB7$Fiam$!3)=c=JT(o2CFB7$Fcbm$!3%[CON"=%\p"FB7$F]cm$!3)GdHm1?wv*F<7$Fgcm$!3RQue>%oOT#F5F[dmFcdmFfimFjhm-Fjgm6%FbimQIThe~29~term~Fourier~approximation~(blue)F(FdhmF]jmFajm7*Figm-F,6$7cv7$F0$!3+nQtWtBh@F57$F>$"3[1Rr#>yez(F<7$FI$"3Qok`^;&=i"FB7$FS$"3!4%y&>\bJf#FB7$Fgn$"3VjyJY%eBF$FB7$Fao$"30\qEC;Z@TFB7$F_q$"3o-.I#)=w%3&FB7$F]s$"3Kee]"\N)QfFB7$Fgs$"3i@S%zX(z$['FB7$Fat$"37:doA"3<U(FB7$F[u$"3&))e(fVhix()FB7$F_bw$"3S)*)zg(o2h')FB7$Fffr$"3'p_pra/kN)FB7$F\cw$"3?M^*>B\'H#)FB7$Facw$"3lZDIAF&R<)FB7$$!3;]P4rtRJ6F9$"35PT_z_'>=)FB7$Ffcw$"3Rs:DUSi;#)FB7$$!3b;zp)e2m7"F9$"3i>\wa<My#)FB7$F`u$"3!R_pjv?hO)FB7$Fj`]l$"3G/%4@.10"*)FB7$F^gr$"3LjvyZ=,&[*FB7$$!3%)\(=nneE5"F9$"3Dph-*f_Ge*FB7$Ff``l$"3&)4RCr&=3l*FB7$$!3o;HK%*)oy4"F9$"3^\-rH]6&o*FB7$Fga]l$"3^(Q#Hr:`$o*FB7$F^a`l$"3jFa93;'Gd*FB7$Feu$"3?]*yj:]zL*FB7$Fddw$"3fegPdoVO')FB7$Fhan$"3?/i8GI_!R)FB7$F\ew$"3Ck[S**[Lx"*FB7$Fju$"3q(\IpS&fk5F97$F_^\m$"3(yS1_P@T7"F97$Fdjt$"3+s-:)ppk9"F97$Fg^\m$"3=WD1lof76F97$F`bn$"3v"yhM')H&45F97$Fdf^n$"3w??RhI*RI*FB7$Fggfl$"3i8#=\@oFL)FB7$F\g^n$"3#f^[+Y,I>(FB7$F\[u$"31>8_6&eC!fFB7$Fga\n$"3Y#*y`Gyr%[%FB7$F_hfl$"3qN&f3fC$oHFB7$F_b\n$"3tHh#*R>r&Q"FB7$F_v$!3YegM["41G#F<7$Fgb\n$!3<C5k]#RK%=FB7$Fghfl$!3/6zO8))p;MFB7$F_c\n$!3QkO6TYd8\FB7$Fd[u$!3,&evZ4f?I'FB7$F\i^n$!3*p>u&**4kavFB7$F_ifl$!3YP6GE59\')FB7$Fdi^n$!3Y1%>rm&\p&*FB7$Fhbn$!3E\NL7biI5F97$Fg`\m$!3d8=(p!)4D7"F97$F\\u$!3&=R.Hf(>Y6F97$F_a\m$!35=pBN"eg6"F97$Fev$!3C'QQ)3\._5F97$F\gw$!3%o=k8-OS1*FB7$F`cn$!34qQvqD:t$)FB7$Fdgw$!3]'4iw]9**p)FB7$Fjv$!3\2U1*f9;S*FB7$F[]an$!3Kj**HP@fB'*FB7$Fbhz$!3Yofe?u[(o*FB7$Fh]an$!3!fqJ>dOFe*FB7$F_cp$!3I)p&Hae<Q$*FB7$F_iz$!3O%[0=>W]n)FB7$F_w$!3T$oib[^=A)FB7$Fbhw$!3![$oX.ZPu")FB7$Fghw$!35@]$QZWCC)FB7$F\iw$!3P].^pEJ*Q)FB7$Fgcp$!3.W.6%p_Cc)FB7$Fhail$!3#49V*R$*z1()FB7$Fdiw$!37e.ACpox()FB7$$!3N****\PlMt$)FB$!3#=O'=$[hpx)FB7$F`bil$!3@4')e*Gg0v)FB7$$!3f++]7(p6K)FB$!3iDY'>=*G*p)FB7$Fdw$!35*[G"o$Rai)FB7$F^x$!33H+,guRPvFB7$Fcx$!37b].pGl!\'FB7$F]y$!3")pLO:(po"fFB7$F[[l$!3U*))G,1#)=2&FB7$Fi\l$!3K/"*\&Qs:7%FB7$Fc]l$!3+**zrxP7sKFB7$F]^l$!3sRl=N/(3h#FB7$Fg^l$!3Mh2'GN5Mn"FB7$Fa_l$!3XM"=0g/+v(F<7$F[`l$!3zH#4&[!e_<"Fhiv7$Ff`l$"3_i8n<P^bwF<7$F`al$"3L"\52,30i"FB7$Fjal$"3!4MLXn-;d#FB7$Fdbl$"3Ws>^_7*GF$FB7$F^cl$"3"4?O'3$H5/%FB7$F\el$"3Q_JtH%R%H]FB7$Fjfl$"3I8Q4NU,@fFB7$Fdgl$"3g+-NW8o$['FB7$Figl$"3HGGCI(=#QvFB7$F[bq$"3OqKt>f-nyFB7$F`bq$"3dR$4fiAp,)FB7$Febq$"3-)GVizg&GzFB7$F^hl$"3PV$zm!)*eRxFB7$Fcdam$"3Wa(*>9!=Co(FB7$Fifs$"3J_))\5!pco(FB7$F[eam$"3:z#R=PfBw(FB7$F]cq$"3#RaYKc4+"zFB7$Fags$"3#Rr#Q/:$GL)FB7$Fchl$"3K]7/5H.'p)FB7$Fecq$"3_)>D^(H9j%)FB7$Fhhl$"3-L)Qe8vbK)FB7$Fhf^l$"3w.yV[8k;*)FB7$F]dq$"3))p="=VVy`*FB7$Fgian$"3&HGP*ya')G'*FB7$Fbial$"3='QW#39`z'*FB7$F_jan$"3y**HB8R.'o*FB7$Feg^l$"3J3fx!)3DZ'*FB7$Fjial$"3d?;]K7"RW*FB7$F]il$"3)y&o;-NE="*FB7$F[g]m$"3hYMzNrCy()FB7$Fj\\l$"3))>*\Jcp")\)FB7$Fcg]m$"3P#>OW!=:4%)FB7$Fhg]m$"3]F_(fF+uO)FB7$F]h]m$"3PL4q9f^!Q)FB7$Fedq$"3m"\n7"*\NX)FB7$Fb]\l$"37="z.C,VL*FB7$Fbil$"3b%fz'[0%=2"F97$Fdcem$"3#Gd#phdrD6F97$F^]y$"3([p,f2Ml9"F97$F\dem$"3!\"Q+v4y=6F97$F]eq$"3%z]t$e)y9."F97$F`ddn$"388YXO^[Q'*FB7$Facjl$"3$)4*\UIIJ!))FB7$Fhddn$"3o<[y)pic"yFB7$Ff]y$"3iN")p3o*zo'FB7$F`f_n$"3$***>guqrOaFB7$Ficjl$"3Tp@%ec$e#3%FB7$Fhf_n$"3m*\[7&y')\EFB7$Fgil$"3/Ucq7_al6FB7$Fee]n$!3_Br\fmX*4%F<7$Fgigl$!3IlO?dskw>FB7$F]f]n$!3,NUc!4Z6]$FB7$F^_v$!3/)3'ew$H;&\FB7$F\h_n$!3[YN'Qhm!*H'FB7$F_jgl$!3]NjB**eG=vFB7$Fdh_n$!3T^E)Hqi))e)FB7$Fgao$!3)z91#)H.e\*FB7$Fij]m$!3Ne&zVNN)y5F97$Ff_v$!3?-_anw\R6F97$Fhj^o$!35V)z$fzaY6F97$Fa[^m$!3NB`NrGLS6F97$F`[_o$!3F+!y$p<*H7"F97$F\jl$!3+DKJ[$**o4"F97$Fj^y$!3=k'G/oYaa*FB7$F_bo$!3*)\*zC&***z])FB7$F_\^m$!3"oC8(f&oLS)FB7$Fiejl$!3onA]hy_l$)FB7$Fg\^m$!3wXYu%R3+R)FB7$Fb_y$!3mxobk)z!p%)FB7$Fafjl$!3"R3'p[?!yu)FB7$Fajl$!3y7H2F+h,"*FB7$Fb]bl$!3O@-)*4#3,U*FB7$F][_l$!37#*)*==U"4j*FB7$Fibbn$!3C&>S5;"fz'*FB7$Fj]bl$!38!\*yc"olo*FB7$Facbn$!3&HaK"QW2_'*FB7$Fafq$!3$[0g0*>ry&*FB7$Fj[_l$!3,!\qx*p@9!*FB7$Ffjl$!3_'[!*>hERS)FB7$F``y$!3]u5;u$GwA)FB7$Fe`y$!3>(3BR?#ot")FB7$Fj`y$!3vw3;6*\NB)FB7$Fifq$!3pm-FnFat$)FB7$Fbay$!3m$4@iffTa)FB7$Fgay$!3/lGnfyH#p)FB7$F\by$!36lS_W6Yt()FB7$F[[m$!3D+hlXIEh()FB7$F`[m$!3nr;#4Tmiu(FB7$Fe[m$!3i)[)R(Rn\Q(FB7$F_\m$!3FdD^H<M$['FB7$Fi\m$!3T#3SH@v$QfFB7$Fg^m$!3Oa*))fQlA0&FB7$Fe`m$!3U*R9UO7,8%FB7$F_am$!3<+oUTr!HF$FB7$Fiam$!3OzIIgD*\h#FB7$Fcbm$!3`'RygU0tr"FB7$F]cm$!3QPp*e/*3bxF<7$Fgcm$"3+nQtWtBh@F5F[dmFcdmFfimFjhm-Fjgm6%FbimQIThe~30~term~Fourier~approximation~(blue)F(FdhmF]jmFajm

To run the animation click once on the graph, then use the playback controls on the control bar. A second example: We would now like to look at approximations to the function that is -1 on [-1,0) and 1 on [0,1). This is a piecewise defined function. Note that we are approximating a very discontinuous function with continuous trigonometric polynomials. g:=x->piecewise(x<0,-1,1): plot(g(x),x=-2..2);

NiUtSSdDVVJWRVNHNiQlKnByb3RlY3RlZEdJKF9zeXNsaWJHNiI2JDdobjckJCEiIyIiISQhIiJGLjckJCEzTUxMTCRRNkciPiEjPEYvNyQkITNhbW07TSFccCQ9RjRGLzckJCEzTExMTCkpUWpePEY0Ri83JCQhM0FMTEw9S3ZsO0Y0Ri83JCQhM3dtbTtDMkchZSJGNEYvNyQkITNPTEwkM3lPNV0iRjRGLzckJCEzJioqKioqXG5VKSo9OUY0Ri83JCQhM1NMTCQzV0RUTCJGNEYvNyQkITM1KytdZChRJlw3RjRGLzckJCEzZ21tbWM0YGk2RjRGLzckJCEzS0xMTFFXKmUzIkY0Ri83JCQhM3crKysrKCk+JyoqKiEjPUYvNyQkITNFKysrKzAiKkgiKkZWRi83JCQhMzUrKysrODMmSClGVkYvNyQkITNbTExMM2socGAoRlZGLzckJCEzQW5tbW1qXk5tRlZGLzckJCEzKHptbW1ZaD0oZUZWRi83JCQhMyssKyt2I1xOKVxGVkYvNyQkITNjb21tbUNDKD4lRlZGLzckJCEzOSoqKioqXEZSWEwkRlZGLzckJCEzdCoqKioqXCM9LzhERlZGLzckJCEzPG1tbTthKmVsIkZWRi83JCQhM2pvbW07V24obykhIz5GLzckJCEzI0crK103YkRXJUZicEYvNyQkITNJcUxMTCRlVig+ISM/Ri83JCQiMzgxaVQmUS5kInkhI0AkIiIiRi43JCQiM182bVQ1ISpcUE5GaXBGXnE3JCQiM1ctO0gjb0ZNSCdGaXBGXnE3JCQiM04kZm1UTmMkXCEqRmlwRl5xNyQkIjNfZDt6cDg3YzlGYnBGXnE3JCQiM3FibTsvckkyP0ZicEZecTckJCIzMV9tIkhkeSc0SkZicEZecTckJCIzVlttbVQrMDdVRmJwRl5xNyQkIjM6VG07ekh6O2tGYnBGXnE3JCQiMylRam1tImZgQCcpRmJwRl5xNyQkIjNtSUxMTDErWTdGVkZecTckJCIzJXoqKioqXG5aKUg7RlZGXnE3JCQiM2JrbW07JHkqZUNGVkZecTckJCIzZikqKioqKipSXmJKJEZWRl5xNyQkIjMmZSoqKioqXDVhYFRGVkZecTckJCIzJm8qKioqXDdSVidcRlZGXnE3JCQiM1gnKioqKipcQGZrZUZWRl5xNyQkIjNfSUxMTCY0Tm4nRlZGXnE3JCQiM0EqKioqKioqXCxzYChGVkZecTckJCIzJVttbTt6TSk+JClGVkZecTckJCIzTCoqKioqKipwZmE8KkZWRl5xNyQkIjM4SExMZWdgISkqKkZWRl5xNyQkIjN2KioqKlwjRzJBMyJGNEZecTckJCIzOkxMTCQpR1trNkY0Rl5xNyQkIjMiKSoqKipcN3loXTdGNEZecTckJCIzd21tbScpZmRMOEY0Rl5xNyQkIjNibW1tLEZUPTlGNEZecTckJCIzRkxMJGUjcGEtOkY0Rl5xNyQkIjMqKSoqKioqKlJ2Jil6OkY0Rl5xNyQkIjNITExMR1VZbztGNEZecTckJCIzX21tbTFeclo8RjRGXnE3JCQiMzQrK11zSUBLPUY0Rl5xNyQkIjM0KytdMiUpMzg+RjRGXnE3JCQiIiNGLkZecS1JJ0NPTE9VUkdGJTYmSSRSR0JHRigkIiM1RjAkRi5GLkZpdy1JK0FYRVNMQUJFTFNHRiU2JFEieEYoUSFGKC1JJVZJRVdHRiU2JDtGLEZhd0koREVGQVVMVEdGKA==

We determine the Fourier coefficients Int(g(x)*sin(j*Pi*x),x=-1..1) = int(g(x)*sin(j*Pi*x),x=-1..1); Int(g(x)*cos(j*Pi*x),x=-1..1) = int(g(x)*cos(j*Pi*x),x=-1..1); Int(g(x),x=-1..1) = int(g(x),x=-1..1);

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

Again, the only Fourier coefficients that are nonzero are the sine ones, and even some of them are zero. Note that the sine coefficient is 0 if j is even and 4/(j\317\200) if j is odd. Fapprox := (x,n) -> sum((-2*((-1)^j-1))/(j*Pi)*sin(j*Pi*x), j=1..n);

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

eval(Fapprox(x,10)); plot([Fapprox(x,10),g(x)],x=-2..2,y=-2..2, title=" 10th Order Fourier approximation to g(x)", titlefont=[HELVETICA,12], color=[green,blue]);

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

6'-I'CURVESG6$%*protectedGI(_syslibG6"6$7a^l7$$!"#""!$"3:\x+L(o#f:!#K7$$!3"om;HU,"*)>!#<$"3Vh[kO&4d;#!#=7$$!3RLL$e%G?y>F5$"3CR^V&GJ&[UF87$$!3(****\(oUIn>F5$"3X9q7Vk@rhF87$$!3xmmm"p0k&>F5$"3eNjn-MMnyF87$$!3OLLe9r]X>F5$"3=6p")\Jk&G*F87$$!3%*****\P&3Y$>F5$"3y-:y!Q7$R5F57$$!3vmmTg*4P#>F5$"3#z^Vu*en<6F57$$!3MLLL$Q6G">F5$"3kaYIrEOk6F57$$!3q;/^')*p!3>F5$"385(fg.y`<"F57$$!3&)*\(o*eGL!>F5$"3Yi<kv!y6="F57$$!3?$ekG>(e)*=F5$"3flQ:Yr7#="F57$$!3em;/'zXQ*=F5$"3siO+-^jy6F57$$!3JLeR-IO%)=F5$"3C,iW"H_,;"F57$$!30++v3-)[(=F5$"3EC+9"=V'H6F57$$!3IL$e9i9f&=F5$"3h[m@V\<\5F57$$!3amm;M!\p$=F5$"35')oB3()y*o*F87$$!3w*\P4k%GE=F5$"3\'o929roL*F87$$!3>L$3xC?c"=F5$"37\W(e^AG4*F87$$!3-]P4^!)G5=F5$"3k#G[Do,n,*F87$$!3im"zW&e&\!=F5$"3%\#>))R$z@(*)F87$$!3A$ekylB'*z"F5$"39#f@:Tj*e*)F87$$!3#)***\7Y"H%z"F5$"3-g7H6$zf(*)F87$$!3pm;zuE'Hx"F5$"3N;j6/B<,$*F87$$!3LLLL))Qj^<F5$"3l>a>B!e9()*F87$$!39LL$3sj,t"F5$"3"4zBiIIG/"F57$$!3<LLL`Np3<F5$"3;!RZq3zU2"F57$$!3=LLep%ezp"F5$"3s,)[*GT2x5F57$$!3>LL$eQBso"F5$"3m(=8bH(4r5F57$$!3?LL3-$)[w;F5$"3rRtj!o+u0"F57$$!3ALLL=Kvl;F5$"3k'o+3_3y."F57$$!3sm;z%4&QW;F5$"3CrF4`1^4**F87$$!3+++Drp,B;F5$"3"Q%Q`#RF'3&*F87$$!3:$ek.%\n<;F5$"3?nF?j)>,W*F87$$!3_m"z%4HL7;F5$"3'*e(\x81$)Q*F87$$!3*)\Pfy3*pg"F5$"3X,F$zH3WN*F87$$!3FL$3x%)[;g"F5$"3)yQE3J\"R$*F87$$!3++v$fyk4f"F5$"3/D")R&3y[O*F87$$!3wmm;C2G!e"F5$"3G()p\QL7h%*F87$$!3<++]_(e1a"F5$"3GQ#4e)4j<5F57$$!3OLL$3yO5]"F5$"34Etb---j5F57$$!3amm;C0,g9F5$"3#zkHaY=*=5F57$$!3&*****\nU)*=9F5$"3&*>[dk+X_%*F87$$!3mmm;9pP39F5$"3_^O&)=/<h$*F87$$!3OLL$3cpxR"F5$"34&[')=h&*)R$*F87$$!3gmm;%)eY#R"F5$"3U%*\t[@,d$*F87$$!32++]2A;(Q"F5$"3i..ZW>X#R*F87$$!3`LL$3`e=Q"F5$"3/B1ul(eaW*F87$$!3ymm;a[bw8F5$"3*)="))yH$z9&*F87$$!3?++]Z,Mb8F5$"33)G-\(\`:**F87$$!3SLL$3WDTL"F5$"3W0b#*)[a!Q5F57$$!3zmmT0@bB8F5$"3br?@RmLd5F57$$!3'*******p(yHJ"F5$"3B:G'e/142"F57$$!3NLLeMaS-8F5$"3orXib;,x5F57$$!3umm;*4K=H"F5$"3#)yBS`giu5F57$$!3`LLLGaoq7F5$"3-V&RZk\Y/"F57$$!35++]d(Q&\7F5$"3="R\iH:Z!**F87$$!3*om"H2oyF7F5$"39<+g"\F&=$*F87$$!3ZLL3d[.17F5$"3.frrrd'z(*)F87$$!36]7`pof+7F5$"3#\?`>(y2f*)F87$$!3um"z>))e^>"F5$"3[[Ka#*ycr*)F87$$!3R$3FW*3s*="F5$"3U\a>(\+m,*F87$$!3.+](o!HG%="F5$"3%yl4`=&\%4*F87$$!3KL3xJpSt6F5$"3TYAz)o_cM*F87$$!3gmmmc4`i6F5$"3BF[2+fM4(*F87$$!3HLL3F=PV6F5$"3*>$[<g@Q_5F57$$!3(*****\(p7U7"F5$"36I@#fHoH8"F57$$!3?L$3F8LY6"F5$"3n*=Y4G\F;"F57$$!3kmm"zc`]5"F5$"3McajR&=)z6F57$$!3EL3_&yj-5"F5$"3oz5$o9@B="F57$$!33+]7.SZ&4"F5$"30:^Hbj=!="F57$$!3qm"H2A%o!4"F5$"3^j>U5E+t6F57$$!3KLLLQW*e3"F5$"3gW=X%[2/;"F57$$!3hm;H<,6v5F5$"3eMO#3>]26"F57$$!3!****\izDV1"F5$"3[LUlxk!*H5F57$$!3>L$3_ZTN0"F5$"30>*oYQrQ<*F87$$!3qmm;arvU5F5$"3H#HIyQiju(F87$$!3@+]7LG(>."F5$"3:*fj(3@/]gF87$$!3]LL37&)=@5F5$"3v#4l2&)ed8%F87$$!3zm;/">//,"F5$"3<"QRj[\'o?F87$$!3w++++()>'***F8$!3>;[%pOSDg(!#?7$$!3E,++vE"z))*F8$!3)GP#>NN^EAF87$$!3k+++]miz(*F8$!3;v=">w&*GH%F87$$!3-+++D1Mr'*F8$!37=A#4y,'*>'F87$$!3^++++Y0j&*F8$!3T9fmO#=<)yF87$$!3,,++v&oZX*F8$!3thzxl(e"*G*F87$$!3Q+++]D[Y$*F8$!3))[1t.u'*Q5F57$$!3w*****\_'>Q#*F8$!3/h[Q4y/<6F57$$!3E++++0"*H"*F8$!3P5Uxa$QQ;"F57$$!3R+++vOtx!*F8$!3x;uvv-*e<"F57$$!3_+++]obD!*F8$!3`#RHWR`;="F57$$!3k+++D+Qt*)F8$!3(=()f1K?;="F57$$!3y++++K?@*)F8$!3')f>JX([j<"F57$$!3.,++]&\o"))F8$!3+X(*3=qd_6F57$$!3=++++f\7()F8$!3XAV3%)3l:6F57$$!3f*******f)y.&)F8$!3m4QX!4bW-"F57$$!35++++83&H)F8$!3l\jj0C4L%*F87$$!3]m;a)==.?)F8$!3#*3]&y^K$z"*F87$$!3*GL$3x]b0")F8$!3`UW6F"o(>!*F87$$!3H**\il>z5!)F8$!3*pY;%p@^f*)F87$$!3!ommT&)Gg"zF8$!3)e!4nb4[&**)F87$$!3q++DJE]ExF8$!3!))y2\hp$3$*F87$$!3[LLL3k(p`(F8$!3S=6=$o2G")*F87$$!3Omm"zR6;J(F8$!3v!\b+"GkS5F57$$!3M++](QYi3(F8$!3Tx&eL!eKu5F57$$!3zm;H#)QctpF8$!3VGXIs_'p2"F57$$!3MML3x8)3'oF8$!3m/e"=!y)*p5F57$$!3y+](=())>[nF8$!3OW0Bnxoa5F57$$!3Anmmmj^NmF8$!3UVD_U3FL5F57$$!3'zmm;k-YW'F8$!32fd,fw:6**F87$$!3fnmm;*)o`iF8$!3V$H!>")3mV&*F87$$!3(zmmT0K#ehF8$!3+!4)>Wm>?%*F87$$!3Anmm">vF1'F8$!3bB`$e\#G^$*F87$$!3fnm;H$=t'fF8$!3y7%zU!ywT$*F87$$!3(zmmmYh=(eF8$!3[@v_Z-K"R*F87$$!3[ML$3P0xU&F8$!3^-M'48:N,"F57$$!3+,++v#\N)\F8$!3viYnn*oH1"F57$$!3wML$3(eR!f%F8$!3)[%[5ay/<5F57$$!3commmCC(>%F8$!3Em["[&H=h%*F87$$!3gM$3xc/%*3%F8$!3UO*QzqFVO*F87$$!3?,+vomc")RF8$!3#\#H"G&RPR$*F87$$!3yM3F>xkFRF8$!3d%GQ<kbbN*F87$$!3!ym"zp(GP(QF8$!3g41#4g-2R*F87$$!3#3]7.#)4)>QF8$!3Qm(33:XSW*F87$$!3%QLL3(3*ew$F8$!3(pOh%*z'H9&*F87$$!3\mm"H2:-b$F8$!31Ptxcc`A**F87$$!39*****\FRXL$F8$!3#yl%4\tSR5F57$$!3[***\P4_=B$F8$!3E<HtI]"z0"F57$$!3G****\7\;HJF8$!388LNe_'42"F57$$!33***\7txk-$F8$!3LunKBW'p2"F57$$!3V******\0zBHF8$!3d9kznT'\2"F57$$!3e****\(=;%=FF8$!3'*Ri`771Z5F57$$!3t*****\#=/8DF8$!3V%z\g^sX&**F87$$!3Mmm"HAb()H#F8$!3D$Hs^gK%o$*F87$$!3%HLL3ioW3#F8$!3m1\b0#3f**)F87$$!3Em;z>`Kx>F8$!3:1tHLFlh*)F87$$!3c***\(=?=q=F8$!3/hCyY6A^!*F87$$!3'GL3xrQIw"F8$!352hK7f%oE*F87$$!3<mmm;a*el"F8$!3_W;RWH=(f*F87$$!3Mmm"HU8"f9F8$!3#3Z_=Bx4/"F57$$!3_mm;H9Li7F8$!3O$Q&3&)RYD6F57$$!3gm;HK/%R;"F8$!3Yh/VjU5e6F57$$!3ommTN%\b1"F8$!3)e`;_W]"y6F57$$!3tm"zp$RN;5F8$!3C=.-(>f?="F57$$!3wnmT&Q%er'*!#>$!33VR6!))37="F57$$!3>o;/,%H'z"*F]im$!3u"*pqO/9v6F57$$!3jomm;Wn(o)F]im$!3sbxQfuWj6F57$$!3<-+v$f%REwF]im$!3]?tqzn_<6F57$$!3sNL$3x9^c'F]im$!3**[[]"Hd:/"F57$$!3Fpm"z%\$Q]&F]im$!3-n)etF^'[$*F87$$!3#G++]7bDW%F]im$!3E1,_N$Re)zF87$$!3POL3-`F"Q$F]im$!3*)zYA-xZcjF87$$!3$*pm;za**>BF]im$!3R?#3uz:l]%F87$$!3[.+Dccre7F]im$!3'zZtlQze\#F87$$!3IqLLL$eV(>F^el$!3D6B&[@")y%RF]im7$$"3N$fmTNc$\!*F^el$"3eA&zv$\%=!=F87$$"3qbm;/rI2?F]im$"3k-JEKF#y#RF87$$"31_m"Hdy'4JF]im$"3\ewiC$y=!fF87$$"3V[mmT+07UF]im$"3)\:`iJlKl(F87$$"3zWmT5:U9`F]im$"3k&352D+l7*F87$$"3:Tm;zHz;kF]im$"3aR,d]m[G5F57$$"3_Pm"zWk">vF]im$"3P&yUzwS76"F57$$"3)Qjmm"f`@')F]im$"3Hrn.1qUh6F57$$"3)z'*\(=ZM,"*F]im$"3e)y[$Rdmt6F57$$"32-L$3_`6e*F]im$"3e@0*\g(\!="F57$$"3ij;HKi415F8$"38REIv0H#="F57$$"3-(***\7r2a5F8$"3-9gZ*fh%z6F57$$"3&Qm;H()Q+:"F8$"38r/\sh!=;"F57$$"3mILLL1+Y7F8$"3V#4$[ztbJ6F57$$"3Ikm;aT#zV"F8$"3!oxq&o;\]5F57$$"3%z****\nZ)H;F8$"3A,mV]wE#p*F87$$"3EJ$3_+*[L<F8$"3$\U_z>:tM*F87$$"3gkmTN.8P=F8$"3M"ySu\XX5*F87$$"3DJ3_+5&*))=F8$"3a"pv(foJE!*F87$$"3#z*\il;xS>F8$"38c]%pA5z(*)F87$$"3ek"H2L#f#*>F8$"3$Q+$>(p"=f*)F87$$"3CJL$e*HTW?F8$"3`Sqa%3"Gp*)F87$$"3*y**\il&p^AF8$"3S;U&=L#Hf#*F87$$"3bkmm;$y*eCF8$"3#R!RXM+J,)*F87$$"31)***\(e@Jn#F8$"3'**z_G!H>P5F57$$"3cJLLe[E()GF8$"3(*)[QOpkA2"F57$$"3K)**\P\OV*HF8$"3iw,1bHAx5F57$$"33lm;H"395$F8$"3)f+?jrML2"F57$$"3%=L$ek(z%3KF8$"3QY:%*o7Vh5F57$$"3f)******R^bJ$F8$"3UE%*47;:V5F57$$"3!z***\7)[]_$F8$"3H)[W0r%Gy**F87$$"3A(****\AYXt$F8$"3Y8Qc&GDAc*F87$$"3)o**\7$\HRQF8$"3GcYXt*QFU*F87$$"3`'***\PO/WRF8$"3'*4R*)opg[$*F87$$"3>'**\PM#z[SF8$"3#3<M#=O2Y$*F87$$"3&e*****\5a`TF8$"3$pf/tt$)QT*F87$$"3N'***\(3S*eXF8$"3?@;vGk(3,"F57$$"3&o****\7RV'\F8$"3OGnbe[li5F57$$"3l'***\PcY9aF8$"3I&[:5c/h,"F57$$"3X'*****\@fkeF8$"3#yM(QJGR(R*F87$$"3?jm"H#oqlfF8$"3#>cSkZA@M*F87$$"3'*HL$e\@o1'F8$"3@I\cbX,`$*F87$$"3t'**\(oh$z;'F8$"3;vcuTJQI%*F87$$"3[jmmT30piF8$"3A(H'oOZ.o&*F87$$"3+(***\(=!GrkF8$"3d,)z.!*3,(**F87$$"3_ILLL&4Nn'F8$"3'y6;Lf45/"F57$$"3bjm;H5Z"y'F8$"3o#z5Rrb*f5F57$$"3p(****\_K%*)oF8$"3'4-v>u6E2"F57$$"3#=LL3-%R(*pF8$"3zg@&\yKs2"F57$$"3([mmm^b`5(F8$"31Ql0FN*G2"F57$$"3/KLL3&y7K(F8$"3=[T(*eAZQ5F57$$"3A*******\,s`(F8$"3cwe<Yy;7)*F87$$"3ilm"H#)fGt(F8$"3%e`Yhf!y$H*F87$$"3.KL$e9=&GzF8$"3REaX:$Rb)*)F87$$"3yl;H2tME!)F8$"3wW$*H)RCE'*)F87$$"3W)**\(ok<C")F8$"3Ny2<(HCL/*F87$$"33J$3-j0?A)F8$"3[PW`fAXH#*F87$$"3%[mm;zM)>$)F8$"30i`)Rf&R8&*F87$$"3Y)**\(=5uL&)F8$"34QRdorxP5F57$$"33KL$eCZwu)F8$"3r#*3+6Y@H6F57$$"3*))*\Pf.ga))F8$"3([4&R*G$)H;"F57$$"3qlm"HZ`:'*)F8$"36$)e/IM'3="F57$$"3c)\(oH+.:!*F8$"3?sFASj4#="F57$$"3_K$eke1&o!*F8$"3VuP%4.at<"F57$$"3[m"HK9$)>7*F8$"3MI=+m?4m6F57$$"3L*******pfa<*F8$"3jF<%=QZy9"F57$$"35m;zWU4w#*F8$"39ux[')eN$4"F57$$"3xJLe*yGnP*F8$"3D'yu;oF9,"F57$$"3X(*\PMLOx%*F8$"3'Gb!)*Hc.?!*F87$$"3Bkm;zy*zd*F8$"3(e"GrKF(\m(F87$$"3,J$eRUK'y'*F8$"3#)4%fse1w2'F87$$"3o'**\(opEz(*F8$"3A/Ea`F`*H%F87$$"3Ni;a8:!*z)*F8$"3y3*pdhTKQ#F87$$"38HLLeg`!)**F8$"3CDmvxy)>*QF]im7$$"3@mmT:Gd35F5$!3m*Qto\Pxq"F87$$"3^*****\-#4>5F5$!3!)\0mvUkVPF87$$"3"GL$eM7hH5F5$!3+2L!*\_TZcF87$$"3Lmm;W/8S5F5$!3qJH2)e(GctF87$$"3&)***\Pl\10"F5$!3())yBW4#p>))F87$$"3:LLLj)o61"F5$!3VGdx'4?-+"F57$$"3Xmm"H2)or5F5$!3Kr?O5j`)3"F57$$"3v****\#G2A3"F5$!3\"=.*G0$o9"F57$$"39$3_v]\t3"F5$!3jWo@_a#[;"F57$$"3amTgK<\#4"F5$!3T"*f^l3Lw6F57$$"3#*\ildRj(4"F5$!3.&p#f/0v"="F57$$"36L$3F=wF5"F5$!3:(px8))e:="F57$$"3n*\7GjgI6"F5$!3."GC=QMl;"F57$$"3Ymm"H3XL7"F5$!33[tVTz2O6F57$$"3")**\7$)R"R9"F5$!3ejk_i_%*\5F57$$"3:LLL$)G[k6F5$!3_r"eG_`pj*F87$$"3[m"z%\(\_<"F5$!3[!4+&39c%H*F87$$"3")**\i:m,'="F5$!3cj"42[4h1*F87$$"3g;zp[+S">"F5$!3+l![f!f=***)F87$$"39L3x"[$y'>"F5$!3wOy#erkW'*)F87$$"3r\P%["p;-7F5$!3OHum`4Qh*)F87$$"3\mm"zM]v?"F5$!3a0-jR]d))*)F87$$"3:L$3-3%3H7F5$!3[<R0neE\$*F87$$"3")****\7yh]7F5$!3I!**>%olAN**F87$$"3Wm;/ctNr7F5$!3TA6K'\gg/"F57$$"3GLLe**o4#H"F5$!3"R*z#pm#zu5F57$$"3$o;a8nmCI"F5$!33r)G\9+q2"F57$$"39+]7Vk$GJ"F5$!3?B"e9)4/r5F57$$"3YLe*[@1KK"F5$!3[&3U_5#)y0"F57$$"3wmmm')fdL8F5$!3-2rJ6D;R5F57$$"3rmmTl^ya8F5$!3VqdrpwtF**F87$$"3lmm;WV*fP"F5$!3E3#oy?4I_*F87$$"3vmT&)QmH"Q"F5$!3IfLR.q0_%*F87$$"3im;aL*)f'Q"F5$!3C(fTp[lsR*F87$$"3]m"H#G7!>R"F5$!3uK.wkG#*f$*F87$$"3gmm"H_.sR"F5$!3Ig%zy*p$3M*F87$$"3em;H7"3yS"F5$!3PF!3wz&=e$*F87$$"3bmmm,FT=9F5$!3Y/fRBA!fW*F87$$"3"****\P")z/Y"F5$!3%fn#eGe")>5F57$$"3FLL$e#pa-:F5$!3(e@FZG]G1"F57$$"3emm"HB-7a"F5$!3kC0nx"zl,"F57$$"3*)******Rv&)z:F5$!3t"fs'4WCm%*F87$$"3OL3-eaR&e"F5$!30peq:o$oS*F87$$"3im;/wL$4f"F5$!3S05Ne<1l$*F87$$"3))*\iSHrkf"F5$!39m"pWm\BM*F87$$"3OLL37#4?g"F5$!3Em))yS`eR$*F87$$"3hmT5Ira2;F5$!309u<%*o2d$*F87$$"3')**\7[]38;F5$!39qA^@0a%R*F87$$"3MLe9mHi=;F5$!3">@(zR<5^%*F87$$"3gmm;%)3;C;F5$!3mC_+">8`_*F87$$"3$)***\ib7jk"F5$!31iia)G'*>&**F87$$"3HLLLGUYo;F5$!3Q1=]a"*=V5F57$$"3%***\7)eq$y;F5$!3h2P"Qn)Gg5F57$$"3fmm"z%pF)o"F5$!3"[Jw26\?2"F57$$"3CL$3xI$=)p"F5$!3)\8Hrk2r2"F57$$"3"*****\n'*33<F5$!38.MT[enu5F57$$"3@LL3(Q-zs"F5$!3^;Te%p%eZ5F57$$"3_mmm1^rZ<F5$!3+lSCp76#)**F87$$"3-+]7)fR)o<F5$!3JA<!=Jw,S*F87$$"3ILLe*3k**y"F5$!3JObCT[z5!*F87$$"31+DJNj_+=F5$!3'HZ"G#3O!f*)F87$$"3fm;/"e)36=F5$!3WJ@_(\<h-*F87$$"3ML3xE3l@=F5$!3Y]='\5%G;#*F87$$"34++]sI@K=F5$!3lJa89I6@&*F87$$"34++D1>V_=F5$!3k!fSVKoN."F57$$"33+++S2ls=F5$!3pKX6FC<@6F57$$"33+](o:gF)=F5$!3"4i"Q"*ysb6F57$$"33++vt&pG*=F5$!3A@Nz'40u<"F57$$"3?+v=#GCz*=F5$!3@%yX25'*=="F57$$"34+]i!**yH!>F5$!3VpIf[*39="F57$$"3)**\i!*pL!3>F5$!3-'y$)ozTa<"F57$$"34++]2%)38>F5$!3CLVs94bj6F57$$"33+DccB&R#>F5$!3W0ZbVOG;6F57$$"31+]i0j"[$>F5$!3'\4'RqH]P5F57$$"30+voa-oX>F5$!3k==HI%zaE*F87$$"3/++v.Uac>F5$!3PrH6f'Ru%yF87$$"3.+D"G:3u'>F5$!3fC)Q+NkQ:'F87$$"3-+](=5s#y>F5$!3!\'GiWUsNUF87$$"3,+v$40O"*)>F5$!3'R4)34n"*e@F87$$""#F.$!3:\x+L(o#f:F1-I'COLOURGF%6&I$RGBGF($F.F.$"*++++"!")Fh\q-F$6$7hn7$F,$!""F.7$FXF`]q7$FjpF`]q7$FbsF`]q7$F`uF`]q7$FhwF`]q7$FbxF`]q7$F\yF`]q7$Fd[lF`]q7$Fb]lF`]q7$Fj_lF`]q7$FbblF`]q7$FjdlF`]q7$FcglF`]q7$F[jlF`]q7$Fi[mF`]q7$Fg]mF`]q7$Fe_mF`]q7$F_`mF`]q7$Fi`mF`]q7$FacmF`]q7$F_emF`]q7$F]gmF`]q7$FfimF`]q7$FjjmF`]q7$F^\nF`]q7$$"381iT&Q.d"y!#@$"""F.7$$"3_6mT5!*\PNF^elF__q7$$"3W-;H#oFMH'F^elF__q7$Fc\nF__q7$$"3_d;zp87c9F]imF__q7$Fh\nF__q7$F]]nF__q7$Fb]nF__q7$F\^nF__q7$Ff^nF__q7$Fd`nF__q7$F^anF__q7$FfcnF__q7$FdenF__q7$FbgnF__q7$F\hnF__q7$FfhnF__q7$FdjnF__q7$Fb\oF__q7$F`^oF__q7$Fh`oF__q7$F`coF__q7$FheoF__q7$F`hoF__q7$FhjoF__q7$Ff\pF__q7$F^_pF__q7$Fh_pF__q7$Fb`pF__q7$FdcpF__q7$FbepF__q7$F`gpF__q7$FhipF__q7$F`\qF__q-Fe\q6&Fg\qFh\qFh\qFi\q-I+AXESLABELSGF%6$Q"xF(Q"yF(-I&TITLEGF%6$QK~10th~Order~~Fourier~approximation~to~g(x)F(-I%FONTGF(6$I*HELVETICAGF("#7-I%VIEWGF%6$;F,F`\qF[cq

3) Write down the 11th and 15th order Fourier approximations to g(x). Then animate the Fourier approximations up to order 30 4) Find the coefficients for the Fourier approximations of h(x) = x3. 5) Write down the 10th order Fourier approximation to h(x) = x3. Then animate the Fourier approximations up to order 30.

In this third example we find Fourier approximations for the absolute value function. k :=x->abs(x);

NiQtSSVtcm93RzYjL0krbW9kdWxlbmFtZUc2IkksVHlwZXNldHRpbmdHSShfc3lzbGliR0YoNiUtSSNtaUdGJTY5USJrRigvJSdmYW1pbHlHUTBUaW1lc35OZXd+Um9tYW5GKC8lJXNpemVHUSMxMkYoLyUlYm9sZEdRJmZhbHNlRigvJSdpdGFsaWNHUSV0cnVlRigvJSp1bmRlcmxpbmVHRjgvJSpzdWJzY3JpcHRHRjgvJSxzdXBlcnNjcmlwdEdGOC8lK2ZvcmVncm91bmRHUSpbMCwwLDI1NV1GKC8lK2JhY2tncm91bmRHUS5bMjU1LDI1NSwyNTVdRigvJSdvcGFxdWVHRjgvJStleGVjdXRhYmxlR0Y4LyUpcmVhZG9ubHlHRjsvJSljb21wb3NlZEdGOC8lKmNvbnZlcnRlZEdGOC8lK2ltc2VsZWN0ZWRHRjgvJSxwbGFjZWhvbGRlckdGOC8lMGZvbnRfc3R5bGVfbmFtZUdRKjJEfk91dHB1dEYoLyUqbWF0aGNvbG9yR0ZELyUvbWF0aGJhY2tncm91bmRHRkcvJStmb250ZmFtaWx5R0YyLyUsbWF0aHZhcmlhbnRHUSdpdGFsaWNGKC8lKW1hdGhzaXplR0Y1LUkjbW9HRiU2M1EjOj1GKC8lJWZvcm1HUSZpbmZpeEYoLyUmZmVuY2VHRjgvJSpzZXBhcmF0b3JHRjgvJSdsc3BhY2VHUS90aGlja21hdGhzcGFjZUYoLyUncnNwYWNlR0ZbcC8lKXN0cmV0Y2h5R0Y4LyUqc3ltbWV0cmljR0Y4LyUobWF4c2l6ZUdRKWluZmluaXR5RigvJShtaW5zaXplR1EiMUYoLyUobGFyZ2VvcEdGOC8lLm1vdmFibGVsaW1pdHNHRjgvJSdhY2NlbnRHRjgvJTBmb250X3N0eWxlX25hbWVHRlgvJSVzaXplR0Y1LyUrZm9yZWdyb3VuZEdGRC8lK2JhY2tncm91bmRHRkctRiQ2JS1GLTY5USJ4RihGMEYzRjZGOUY8Rj5GQEZCRkVGSEZKRkxGTkZQRlJGVEZWRllGZW5GZ25GaW5GXG8tRl9vNjNRJyZyYXJyO0YoL0Zjb1EhRihGZW9GZ28vRmpvUSQwZW1GKC9GXXBGYXJGXnBGYHBGYnBGZXBGaHBGanBGXHFGXnFGYHFGYnFGZHEtRiQ2JS1GX282M1EpJnZlcmJhcjtGKEZib0Zlb0Znb0ZgckZici9GX3BGO0ZgcEZicEZlcEZocEZqcEZccUZecUZgcUZicUZkcUZocUZlcjcjLV9GKUksbXByaW50c2xhc2hHRig2JDcjPkkia0dGKGYqNiNJInhHRihGKDYkSSlvcGVyYXRvckdGKEkmYXJyb3dHRihGKC1JJGFic0clKnByb3RlY3RlZEdGYnNGKEYoRig3I0Zhcw==

Find the Fourier coefficients: Int(k(x)*sin(j*Pi*x),x=-1..1) = int(k(x)*sin(j*Pi*x),x=-1..1); Int(k(x)*cos(j*Pi*x),x=-1..1) = int(k(x)*cos(j*Pi*x),x=-1..1); Int(k(x),x=-1..1) = int(k(x),x=-1..1);

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

NiQtSSVtcm93RzYjL0krbW9kdWxlbmFtZUc2IkksVHlwZXNldHRpbmdHSShfc3lzbGliR0YoNiUtRiQ2Jy1JKG1zdWJzdXBHRiU2Jy1JI21vR0YlNjRRJiZpbnQ7RigvJSVmb3JtR1EhRigvJSZmZW5jZUdRJmZhbHNlRigvJSpzZXBhcmF0b3JHRjovJSdsc3BhY2VHUSQwZW1GKC8lJ3JzcGFjZUdGPy8lKXN0cmV0Y2h5R0Y6LyUqc3ltbWV0cmljR0Y6LyUobWF4c2l6ZUdRKWluZmluaXR5RigvJShtaW5zaXplR1EiMUYoLyUobGFyZ2VvcEdGOi8lLm1vdmFibGVsaW1pdHNHRjovJSdhY2NlbnRHRjovJTBmb250X3N0eWxlX25hbWVHUSoyRH5PdXRwdXRGKC8lJXNpemVHUSMxMkYoLyUrZm9yZWdyb3VuZEdRLlsxNDQsMTQ0LDE0NF1GKC8lK2JhY2tncm91bmRHUS5bMjU1LDI1NSwyNTVdRigvSSttc2VtYW50aWNzR0YlUSZpbmVydEYoLUkjbW5HRiU2OVEpJm1pbnVzOzFGKC8lJ2ZhbWlseUdRMFRpbWVzfk5ld35Sb21hbkYoLyUlc2l6ZUdGVy8lJWJvbGRHRjovJSdpdGFsaWNHRjovJSp1bmRlcmxpbmVHRjovJSpzdWJzY3JpcHRHRjovJSxzdXBlcnNjcmlwdEdGOi8lK2ZvcmVncm91bmRHUSpbMCwwLDI1NV1GKC8lK2JhY2tncm91bmRHRmduLyUnb3BhcXVlR0Y6LyUrZXhlY3V0YWJsZUdGOi8lKXJlYWRvbmx5R1EldHJ1ZUYoLyUpY29tcG9zZWRHRjovJSpjb252ZXJ0ZWRHRjovJStpbXNlbGVjdGVkR0Y6LyUscGxhY2Vob2xkZXJHRjovJTBmb250X3N0eWxlX25hbWVHRlQvJSptYXRoY29sb3JHRmBwLyUvbWF0aGJhY2tncm91bmRHRmduLyUrZm9udGZhbWlseUdGYW8vJSxtYXRodmFyaWFudEdRJ25vcm1hbEYoLyUpbWF0aHNpemVHRlctRlxvNjlGS0Zfb0Zib0Zkb0Zmb0Zob0Zqb0ZccEZecEZhcEZjcEZlcEZncEZqcEZccUZecUZgcUZicUZkcUZmcUZocUZqcUZdci8lMXN1cGVyc2NyaXB0c2hpZnRHUSIyRigvJS9zdWJzY3JpcHRzaGlmdEdRIjBGKC1GJDYlLUYyNjNRKSZ2ZXJiYXI7RigvRjZRJmluZml4RihGOEY7Rj1GQC9GQ0ZpcEZERkZGSUZMRk5GUEZSRlUvRllGYHBGZW4tSSNtaUdGJTY5USJ4RihGX29GYm9GZG8vRmdvRmlwRmhvRmpvRlxwRl5wRmFwRmNwRmVwRmdwRmpwRlxxRl5xRmBxRmJxRmRxRmZxRmhxL0ZbclEnaXRhbGljRihGXXJGaXItSSdtc3BhY2VHRiU2Ji8lJ2hlaWdodEdRJzAuMH5leEYoLyUmd2lkdGhHUScwLjN+ZW1GKC8lJmRlcHRoR0ZcdC8lKmxpbmVicmVha0dRJWF1dG9GKC1GMjY0UTAmRGlmZmVyZW50aWFsRDtGKC9GNlEncHJlZml4RihGOEY7Rj1GQEZCRkRGRkZJRkxGTkZQRlJGVUZYRmVuRmhuRmBzLUYyNjNRIj1GKEZcc0Y4RjsvRj5RL3RoaWNrbWF0aHNwYWNlRigvRkFGXnVGQkZERkZGSUZMRk5GUEZSRlVGX3NGZW5GX3I3Iy8tSSRJbnRHNiQlKnByb3RlY3RlZEdGKjYkLUkkYWJzR0ZldTYjSSJ4R0YoL0ZqdTshIiIiIiJGXnY=

Now the sine coefficients are all zero, along with half of the cosines terms - not surprising since k is an even function. Recall that the constant term is half the integral of k on the interval. Let's check: 1/2*Int(k(x),x=-1..1) = 1/2*int(k(x),x=-1..1);

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

Fapprox := (x,n) -> 1/2 + sum(2*((-1)^j-1)*cos(j*Pi*x)/(j*Pi)^2,j=1..n);

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

Plot the 6th Fourier approximation eval(Fapprox(x,6)); plot({k(x), Fapprox(x,6)},x=-2..2,y=-2..2);

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

6) Write down the 11th and 15th order Fourier approximations to k(x) = abs(x). Animate up to the 30th order approximation. 7) Find the coefficients for the Fourier approximations of f(x) = x3- x2. (The series has coefficients for both sine and cosine functions.) 8) Write down the 6th order Fourier approximation to f(x) = x3-x2. Plot the function against the approximation. Animate up to the 30th order approximation.