7ª Aula Prática de TFCOMP-II

Comecem por criar e guardar em disco um Notebook com o nome TFC7_grupo.nb, onde 'grupo' é o nome do vosso grupo de trabalho. Neste Notebook criem uma célula de título identificando os elementos constituintes do grupo (nome, número e contactos).

Inicial.

<< Calculus`FourierTransform`

SetOptions[Plot, Axes -> True, Frame -> True, 
        FrameTicks -> None, PlotStyle -> Thickness[0.01`], 
        Ticks -> {{#  π, SequenceForm @@ (#  π)} & /@ 
              Range[-5, 5], Automatic}];

FT = FourierTransform;
IFT = InverseFourierTransform;

Problema 1

Usando as funções nativas FourierTransform  (e suas variações)  e as funcionalidades de Calculus`FourierTransform`calcule as expressões e  crie uma tabela de gráficos de pares função⟷transformada para as seguintes funções periódicas.

({{f[x]=|({{1, 0 < x < π}, {-1, -π < x < 0}})|, f[x]=({{|x|, \(\(-π\) < x < π\)}}), f[x]=({{x, -π < x < π}}), f[x]=({{|Cos[
                        x]|, -π < 
                      x < π}})}})

Solução 1

Note que, enquanto uma série de Fourier representa sempre uma função periódica (portanto com suporte em todo o ℝ) com um período finito  2  L (porque os números de onda (Subscript[k, n]) são múltiplos inteiros de (Subscript[k, 1]) = (π/L))  é necessário um integral de Fourier para representar fielmente em todo o ℝuma função com suporte compacto de comprimento 2  L, porque o efeito de cancelamento fora do suporte só é possível invocando um contínuo de frequências. Se a função tiver suporte em ℝ mas não for periódica, poderíamos vê-la como períódica com 2  L -> ∞, e no limite a respectiva série de Fourier  tende para o integral porque Δk = (Subscript[k, 1]) -> 0 e (1/(2  L)) -> 0.

O Mathematica define as transformadas e séries de Fourier com valores pré-estabelecidos {0, 1} para dois parâmetros ajustáveis FourierParameters -> {a, b}. 
Em geral f[x]=|b(|^((1 + 
                        a)/2))(∑_(n = -∞)^∞)\(F\_n\ e\^\(\(-i\)\ \ 2\ π\ b\ n\ x\)\)  com  (Subscript[F, n])=|b(|^((1 - 
                        a)/2))\(∫\_\(\(-1\)/\((2 |b|)\)\)\%\(1/\((2 |b|)\)\)\)f(x) (e^(i 2  π b n x))dx.
Pode-se reconhecer aqui que b = (1/(2  L)) para uma função de suporte 2  L.
 A convenção  a = 1 é arbitrária, mas qualquer outra deve ser tomada igualmente para a transformada e a sua inversa.
Por outro lado a transformada de Fourier definida no Mathematica é F[k]=\(\@\(|b|\/\((2  π)\)\^\(1 - a\)\)\)(∫_(-∞)^∞)f[x] (e^(i  b  k  x)) dx  e a transformada inversa é f[x]=\(\@\(|b|\/\((2  π)\)\^\(1 + a\)\)\)(∫_(-∞)^∞)F[
                    k] (e^(-i b  k  t)) dk.  
Neste caso a convenção b = 1 é mais natural para transformadas em x, com k = ((2  π)/λ)interpretado como um número de ondas, mas b = 2  π se quisermos usar k = (1/λ) como uma frequência de ondas, enquanto que para sinais temporais (i.e. x -> t) é frequente usar b = 2  π para que k -> ν = (1/T)seja uma frequência pura, ou b = 1 para k -> ω = ((2  π)/T) frequência angular.

f[x]=|({{1, 0 < x < π}, {-1, -π < x < 0}})|

A função periódica aqui pedida é a repetição da parte compreendida entre [-π, π] da função f[x] em ℝ, transladada para 𝒻[x]=f[x - Quotient[x + π, 2 π] 2  π]

f[x_] := If[Abs[x] < π, Sign[x], 0]

SetOptions[Plot, Frame -> True, FrameTicks -> None, 
        PlotStyle -> Thickness[0.01`], 
        Ticks -> {{#  π, SequenceForm @@ (#  π)} & /@ 
              Range[-5, 5], Automatic}];

grf = 
        Plot[f[x], {x, -3 π , 3  π }, 
          DisplayFunction -> Identity];
grf2 = 
        Plot[f[x - 
              Quotient[x + π, 2  π] 2  π], {x, -3.01 π , 
            3.01  π }, PlotStyle -> RGBColor[1, 0, 0], 
          DisplayFunction -> Identity];
Show[{grf, grf2}, 
        DisplayFunction -> (Display[$Display, #1] &), 
        AxesLabel -> {x, None}];

Com os parâmetros de Fourier {a, b} -> {1, 1} a seguinte transformada de Fourier é uma função F[k] com k = ((2  π)/λ)número de onda.

F[k_] = FourierTransform[f[x], x, k, 
            FourierParameters -> {1, 1}] // ExpToTrig // 
        Simplify

Com os parâmetros de Fourier {a, b} -> {1, (1/(2  L))} os  coeficientes de Fourier ℱ[n] definem a contribuição de ondas com número de onda (Subscript[k, n]) = n (((2  π)/(2  L))). Note que usamos f[x] para calcular os coeficientes da série de Fourier, já que o integral apenas considera os valores da função dentro dum intervalo de período.

ℱ[
        n_] = FourierCoefficient[f[x], x, n, 
            FourierParameters -> {1, (((2  π))^(-1))}] // 
          ExpToTrig // Simplify
ℱ[0] = 
      Limit[ℱ[n], n -> 0]

Como f[x] = -f[-x]  é ímpar, a transformada e os coeficientes de Fourier são imaginários puros. Apenas os termos em i Sin[n x] sobrevivem na transformação.

lp1 = 
        ListPlot[Table[{k, ℱ[k] // Im}, {k, -20, 20}], 
          PlotJoined -> False, PlotStyle -> PointSize[ .01], 
          DisplayFunction -> Identity];
\(\(fp1 = 
        Plot[F[k] // Im, {k, \(-20\), 20}, PlotRange -> 5 {\(-1\), 1}, 
          PlotStyle -> \((RGBColor[1, 0, 0])\), PlotPoints -> 30, 
          DisplayFunction -> Identity];\)
\)
SH[fp1, lp1, DisplayFunction -> (Display[$Display, #1] &), 
        AxesLabel -> {k, None}, 
        PlotLabel -> "Transformada de Fourier e coeficientes da s\
érie de Fourier"];

A transformada inversa de Fourier ensina-nos como se representa esta função sem condições por troços:

InverseFourierTransform[F[k], k, x, 
      FourierParameters -> {1, 1}]

Plot[{(1/2) (Sign[π - x] + 2 Sign[x] - Sign[π + x]), 
        (1/2) Sign[π - x] +  .01, 
        1.02 Sign[
            x], -(1/2) Sign[π + x] -  .01}, {x, -3 π, 
        3  π}, 
      PS -> {{TH[1], RGBColor[1, 0, 0]}, {RGBColor[0, 1, 0]}, 
          RGBColor[0, 0, 1], RGBColor[1, 1, 0]}]

Note que, embora exista, a reconstrução a partir da série de Fourier nem sempre é conseguida. Quando isso acontece, há que fazer aproximações ou procurar formas de soma alternativas.

InverseFourierCoefficient[ℱ[n], n, x, 
      FourierParameters -> {1, (((2  π))^(-1))}]

Nota: Use  Release do primeiro argumento de Plot para evitar múltiplas chamadas a InverseFourierTransform (ou use uma atribuição exterior ao Plot para calcular a transformada uma vez só)

O seguinte gráfico mostra as diferenças entre a reconstrução de f[x] com transformadas ou séries de Fourier. O efeito que se nota nas descontinuidades em x ∈ ℤπ acentuam-se ainda mais com maior número de termos somados na série (fenómeno de Gibbs).

Show[
        GraphicsArray[{Plot[
              InverseFourierTransform[F[k], k, x, 
                  FourierParameters -> {1, 1}] // 
                Release, {x, -3 π, 3  π}, 
              DisplayFunction -> Identity], 
            Plot[FourierTrigSeries[f[x], x, 20, 
                  FourierParameters -> {1, (((2  π))^(-1))}] // 
                Release, {x, -3.01 π , 3.01  π }, 
              PlotStyle -> RGBColor[1, 0, 0], 
              DisplayFunction -> Identity]}], 
        DisplayFunction -> (Display[$Display, #1] &)];

f[x]=({{|x|, -π < 
                x < π}})

f[x_] := If[Abs[x] < π, Abs[x], 0]

grf = 
        Plot[f[x], {x, -3 π , 3  π }, 
          DisplayFunction -> Identity, 
          PlotRange -> {-1, 1.1  π}];
grf2 = 
        Plot[f[x - 
              Quotient[x + π, 2  π] 2  π], {x, -3.01 π , 
            3.01  π }, PlotStyle -> RGBColor[1, 0, 0], 
          DisplayFunction -> Identity];
Show[{grf, grf2}, 
        DisplayFunction -> (Display[$Display, #1] &), 
        AxesLabel -> {x, None}];

F[k_] = FourierTransform[f[x], x, k, 
            FourierParameters -> {-1, 1}] // ExpToTrig // 
        Simplify

ℱ[
        n_] = FourierCoefficient[f[x], x, n, 
            FourierParameters -> {-1, (1/(2  π))}] // 
          ExpToTrig // Simplify
ℱ[0] = 
      Limit[ℱ[n], n -> 0]

lp1 = 
        ListPlot[Table[{k, ℱ[k]}, {k, -20, 20}], 
          PlotJoined -> False, PlotStyle -> PointSize[ .01], 
          DisplayFunction -> Identity];
fp1 = 
        Plot[F[k], {k, -20, 20}, PlotRange -> {-1, 1.6}, 
          PlotStyle -> (RGBColor[1, 0, 0]), PlotPoints -> 30, 
          DisplayFunction -> Identity];

Show[fp1, lp1, DisplayFunction -> (Display[$Display, #1] &), 
        AxesLabel -> {k, None}, 
        PlotLabel -> "Transformada de Fourier e coeficientes da s\
érie de Fourier"];

IF[x_] = 
      InverseFourierTransform[F[k], k, x, 
          FourierParameters -> {-1, 1}] // 
        Simplify[#, x ∈ Reals] &

ft[n_] = 
      FourierCoefficient[If[Abs[x] < π, Abs[x], 0], x, n, 
        FourierParameters -> {-1, (1/(2  π))}]

ift[x_] = 
      InverseFourierCoefficient[ft[n], n, x, 
          FourierParameters -> {-1, (1/(2  π))}] // 
        FullSimplify

ftrg[x_] = 
      FourierTrigSeries[f[x], x, 5, 
        FourierParameters -> {-1, (((2  π))^(-1))}]

Plot[{IF[x], ift[x], ftrg[x]}, {x, -3 π, 3  π}, 
        PlotRange -> {-1, 4}, 
        PlotStyle -> {Thickness[0.005`], bl, rd}];

f[x]=({{|Cos[
                  x]|, -π < x < π}})

<< Graphics`FilledPlot`

A função UnitStep pode ser utilizada para definir funções por troços

{FilledPlot[{-UnitStep[x - π] + 
                UnitStep[π + x]}, {x, -3 π, 
              3  π}, 
Fills -> {{{1, Axis}, 
                  RGBColor[1, 1, 0]}}, DisplayFunction -> Identity], 
          Plot[{-UnitStep[x - π] + UnitStep[π + x], 
              Abs[Cos[x]]}, {x, -3 π, 3  π}, 
            PlotStyle -> {RGBColor[0, 0, 1], RGBColor[1, 0, 0]}, 
            DisplayFunction -> Identity]} // 
        Show[#, PlotRange -> {-3, 3}, 
            DisplayFunction -> (Display[$Display, #1] &)] &;

Eis um cálculo explícito da transformada de Fourier com parâmetros {a, b} -> {-1, 1}, e a

(1/(2  π)) (∫_(-π)^π) Abs[
                Cos[x]] (UnitStep[π + x] - 
                  UnitStep[
                    x - π]) (E^(I  k x)) \[DifferentialD]x // ExpToTrig // TrigReduce

F[k_] = FourierTransform[If[Abs[x] < π, Abs[Cos[x]], 0], x, k, 
            FourierParameters -> {-1, 1}] // ExpToTrig // 
        TrigReduce

ℱ[
        n_] = FourierCoefficient[If[Abs[x] < π, Abs[Cos[x]], 0], x, n, 
            FourierParameters -> {-1, (1/(2  π))}] // 
          ExpToTrig // Simplify
ℱ[1] = 
      Limit[ℱ[n], n -> 1]
ℱ[-1] = 
      Limit[ℱ[n], n -> -1]

lp1 = 
        ListPlot[{#, ℱ[#]} & /@ Rg[-15, 15], 
          PlotJoined -> False, Axes -> False, 
          PS -> PointSize[ .01], NoDspl];
\(\(fp1 = 
        Plot[F[k], {k, \(-5\) π, 5  π}, 
          PlotRange -> {\(- .6\), 1}, 
          PlotStyle -> \((RGBColor[1, 0, 0])\), 
          NoDspl];\)
\)
SH[fp1, lp1, Dspl];

IF[x_] = 
      IFT[F[k], k, x, FourierParameters -> {-1, 1}] // 
        Sp[#, x ∈ Reals] &

ft[n_] = FourierCoefficient[If[Abs[x] < π, Abs[Cos[x]], 0], x, n, 
            FourierParameters -> {-1, (1/(2  π))}] // 
          FullSimplify // TrigToExp

ft[1] = ft[-1] = 0;

ift[x] = 
      InverseFourierCoefficient[ft[n] // Release, n, x, 
          FourierParameters -> {-1, (1/(2  π))}] // 
        FullSimplify

iift = 
        Replace[ift[
              x], {n, _, _} :> {n, 2, 20}, {0, ∞}] + 
          Replace[ift[
              x], {n, _, _} :> {n, 0, 0}, {0, ∞}] + 
          Replace[ift[
              x], {n, _, _} :> {n, -20, -2}, {0, ∞}];

Plot[{%, IF[x]}, {x, -5 π, 5  π}, PlotRange -> All, 
        PlotStyle -> {RGBColor[0, 0, 1], 
            RGBColor[1, 0, 0]}];

Problema 2

Usando as funções nativas FourierTransform  (e suas variações)  e as funcionalidades de Calculus`FourierTransform`calcule as expressões e  crie uma tabela de gráficos de pares função⟷transformada para as seguintes funções em (Subscript[ℒ, 2])[ℝ]:

({{\(f[x] = 
              c\ e\^\(\(-κ\) |x|\)\), f[x] = 
              c (e^(-κ (((x - a))^2))), f[x]=|({{c Cos[κ x], \(|x| < a\)}, {0, resto}})|, f[x]=|({{c, L - 
                          a < |x| < 
                        L + a}, {0, resto}})|}})

Solução 2

As funções aqui indicadas em ℝ representam alguns candidatos a sinais com localização espacial  mais ou menos bem definida. Torna-se interessante estudar como  essa localização se traduz no espaço de Fourier dual. Para isso executámos algumas animações em que os parâmetros que controlam a localização e a dispersão do sinal são alterados, e qual o seu efeito nas  transformadas de Fourier da função a que se referem.

\(f[x] = \ \(c\ e\^\(\(-κ\) \(|x|\)\(\ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \ \)\)⟷\ \ \ F[
              k] = \ \(2\ c\ κ\)\/\(k\^2 + κ\^2\)\)\)

fft = 
      FT[c (E^(-κ Abs[x])), x, k, 
        FourierParameters -> {1, 1}]

Neste caso, a transformada de Fourier é uma curva Lorentziana cuja largura varia de forma inversa à da função original. Este efeito é geral entre funções e  e suas  transformadas de Fourier,  e é conhecido em física como uma relação de Heisenberg entre a incerteza/indeterminação na localização Δx e no momento Δp =  ℏ Δk.

Show[
            GraphicsArray[{Plot[c (E^(-κ Abs[x])) /. c -> 1 /. κ ->  .3  # // Release, {x, -4 π, 
                    4  π}, DisplayFunction -> Identity, 
                  PlotRange -> {- .1, 1}, 
                  Axes -> 
                    True, 
AxesLabel -> {x, None}], 
                Plot[fft /. c -> 1 /. κ ->  .3  # // 
                    Release, {k, -4 π, 4  π}, 
                  DisplayFunction -> Identity, 
                  PlotRange -> {- .1, 4}, Axes -> True, 
                  AxesLabel -> {k, None}]}], 
            DisplayFunction -> (Display[$Display, #1] &)] & /@ 
        Rg[2, 10, 5];

\(f[x] = \(c\ e\^\(\(-κ\)\ \((x - a)\)\^2\)\ \ \ \ \ \ \ \ \ \ \ \ ⟷\ \ \ F[
              k] = \ \(\(c\) \(\@\( π\/κ\)\)\(\ \)\(e\^\(i\ a\ k - 
                k\^2\/\(4\ κ\)\)\)\(\ \)\)\)\)

A transformada de Fourier duma gaussiana é outra gaussiana, mas uma translacção do seu valor médio causa alterações não só na fase da transformada (que passa a ter uma componente imaginária, previsível porque a função deixa de ser par) como na frequência de oscilação.

fft = FT[c (E^(-κ (((x - a))^2))), x, k, 
            FourierParameters -> {1, 1}] /. 
          Erfi[((k - 2 I a κ)/(2 (Sqrt[κ])))] -> (1/I) Erf[((I k + 2 a κ)/(2 (Sqrt[κ])))] /. ((-I k - 2 a κ)/(2 (Sqrt[κ]))) -> -((I k + 
                  2 a κ)/(2 (Sqrt[κ])))

Show[
            GraphicsArray[{Plot[c (E^(-κ (((x - a))^2))) /. c -> 1 /. κ ->  .2 /. a -> # // 
                    Release, {x, -4 π, 4  π}, 
                  PlotRange -> {- .1, 1.5}, NoDspl], 
                Plot[{Re[#], 
                          Im[#]} &@(fft /. 
                                c -> 1 /. κ ->  .2 /. 
                            a -> # // Sp) // 
                    Release, {k, -π, π}, 
                  PlotStyle -> {rd, bl}, 
                  PlotRange -> 2 {-2, 2}, NoDspl]}], Dspl] & /@ 
        Rg[-10, 10, 5];

f[x]=|({{c Cos[
                      b x], |x| < 
                    a}, {0, resto}})|   ⟷  F[k]= \(c \((\(\(\ \)\(Sin[a \((b - k)\)]\)\)\/\(b - k\) + \(\(\ \)\(Sin[a \((b + k)\)]\)\)\/\(b + k\))\)\)

Note que nem sempre é possível obter uma resposta quando a função é definida com condições envolvendo variáveis.

fft = 
      FT[If[Abs[x] < a, c Cos[b x], 0], x, k, 
        FourierParameters -> {1, 1}]

Contudo por vezes existem outras representações equivalentes da função que permitem obter uma resposta explícita. Neste caso

f[x] = (UnitStep[x + a] - UnitStep[x - a]) 
          c Cos[b x];

fft = 
      FT[f[x], x, k, FourierParameters -> {1, 1}] // Simplify

Show[
            GraphicsArray[{Plot[f[x] /. a -> π /. 
                        c -> 1 /. b -> (2  # + 1)/2 // 
                    Release, {x, -4, 4}, PlotRange -> All, 
                  DisplayFunction -> Identity], 
                Plot[fft /. a -> π /. c -> 1 /. 
                      b -> (2  # + 1)/2 // 
                    Release, {k, -5 π, 5  π}, 
                  PlotRange -> {-1, 4}, 
                  PlotStyle -> RGBColor[1, 0, 0], 
                  DisplayFunction -> Identity]}, 
              PlotLabel -> ({{a == π, b == (2  # + 1)/2, 
                        c == 1, 
                        If[# == 1, ℱ[k] == 
                            fft, "                                  "]}} // 
                    TF)], 
            DisplayFunction -> (Display[$Display, #1] &)] & /@ 
        Range[1, 10, 3];

f[x]=|({{c, L - a < |x| < 
                    L + a}, {0, resto}})|	  ⟷  F[k]= ((4 c Cos[k L] Sin[a k])/k)

fft = (∫_(-L - a)^(-L + a))c (E^(I k x)) \[DifferentialD]x + (∫_(L - a)^(L + a))c (E^(I k x)) \[DifferentialD]x // ExpToTrig // TrigReduce // Sp

Show[
            GraphicsArray[{Plot[If[
                            Abs[x] < L + a  &&  Abs[x] > L - a , c , 0] /. 
                          c -> 1 /. a -> # /. L -> 2.5 // 
                    Release, {x, -10, 10}, PlotRange -> All, 
                  DisplayFunction -> Identity], 
                Plot[fft /. c -> 1 /. a -> # /. 
                      L -> 3 // Release, {k, -10 π, 10  π}, 
                  PlotRange -> All, PlotPoints -> 3550, 
                  PlotStyle -> RGBColor[1, 0, 0], 
                  DisplayFunction -> Identity]}], 
            DisplayFunction -> (Display[$Display, #1] &)] & /@ 
        Rg[ .1, 2.5,  .2];

Show[
            GraphicsArray[{
Plot[If[
                            Abs[x] < L + a  &&  Abs[x] > L - a , c , 0] /. 
                          c -> 1 /. a ->  .5 /. L -> # // 
                    Release, {x, -10, 10}, PlotRange -> All, 
                  DisplayFunction -> 
                    Identity], 
Plot[{fft, 
                            fft /. L -> 0, -fft /. L -> 0} /. 
                          c -> 1 /. a ->  .5 /. L -> # // 
                    Release, {k, -5 π, 5  π}, 
                  PlotRange -> {-4, 4}, PlotPoints -> 3550, 
                  PlotStyle -> {RGBColor[1, 0, 0], RGBColor[0, 1, 0], 
                      RGBColor[0, 1, 0]}, 
                  DisplayFunction -> Identity]}], 
            DisplayFunction -> (Display[$Display, #1] &)] & /@ 
        Rg[0, 10];

Problema 3

Interpretando cada uma das funções do problema anterior como uma amplitude de probabilidade, pode-se definir um valor médio \(TraditionalForm\`x\&_ = ∫x\ Ψ[
              x] dx\) e uma variância \(TraditionalForm\`σ\^2 = ∫\(\((x - 
                    x\&_)\)\^2\) Ψ[x] dx\) onde Ψ[x] = f[x]^2. Estude para cada um dos casos do problema anterior a relação entre uma noção de localização da função original em x e da localização no espectro de frequências para a sua transformada de Fourier, fazendo variar os parâmetros a e κ.  Faça animações mostrando efeito de localizar e deslocar a função no seu espectro de frequências.

Problema 4

Para analisar uma  função f[x]com a função nativa Fourier é necessário discretizar f num intervalo e fornecer uma lista de valores. Construa um operador  Sample[𝒻, n, ℐ] para a discretização de uma função 𝒻 (x) num intervalo ℐ = [(Subscript[x, min]), (Subscript[x, max])], utilizando Ν = (2^n) pontos, cujos produtos são:

                              ({{Cdata, Lista de N = 
                    (2^n) valores complexos 𝒻[(Subscript[x, i])]}, {sr, Taxa de Amostragem       =  
                    (N/((Subscript[x, max]) - (Subscript[x, min])))}, {ny, Frequencia de Nyquist    =  (1/2) sr}, {Δx, \(Resolução\ da\ Amostragem\  = \ \(x\_max - x\_min\)\/N\)}})

Construa ainda um operador SampleWindow[ny_, ns_, xo_:  0] que determina o intervalo {(Subscript[x, min]), (Subscript[x, max])} centrado em xo dada a frequência de Nyquist ny e o números de pontos da amostragem ns. Utilize estes operadores para fazer a análise duma das funções do problema 2 e compare os resultados numéricos com os analíticos.

Solução 4

\(Sample[f_, 
        n_, {xmin_, 
          xmax_}] := \((
step = \(xmax - xmin\)\/2. \^n; 	
Cdata = 
          N[HoldForm[f] /@ Range[xmin + step\/2, xmax, step] // 
              ReleaseHold]; 	
        Print[TableForm[
\({
{"Sampling Window     sw = ", "" @@ \((sw = {xmin, 
                            xmax})\), "Sampling Rate       sr = ", 
                    sr = 1\/step}, 
{"Nyquist Frequency   ny = ", ny = 1\/\(2. \ step\), \ "Number of Samples   ns = ", 
                    ns = Length[
                        Cdata]}
} /. z_Integer :> 
                  PaddedForm[z, 
                    5]\) /. z_Real :> 
                PaddedForm[z, {4, 2}], 
            TableSpacing -> {0, 2}]];)\)\)

\(SamplingWindow[nyquist_, samples_, xo_:  0] := \((ny = nyquist; 	
        ns = samples; 	{xo - ns\/\(\((2\ ny)\)\ 2. \), 
          xo + ns\/\(\((2\ ny)\)\ 2. \)})\)\)

Nas células seguintes, displayAnalysis[{(Subscript[f, min]), (Subscript[f, max])}, {(Subscript[x, min]), 
          (Subscript[x, max])}, {f - options}, {x - options}] mostra gráficos de transformadas e respectivas inversas. Os dois primeiros argumentos representam os domínios visualizados em frequência e espaço, e os dois últimos opções a aplicar nos gráficos de cada tipo. A correspondência entre índice da lista de pontos e a respectiva coordenada em frequência ou espaço é dada por:
Nas listas de transformadas, índices 1  <  n  <  ns correspondem  a frequências   f = (n - (ns/2) - 1) - ((2 ny)/ns). Conversamente, frequências -ny  <  f  <  ny correspondem a índices n = 1 + ((ns (f + ny))/(2 ny)). Note que nos espectros, f representa uma frequência e não uma frequência angular \(TraditionalForm\`ω\  = \ \(\(2\)  \(π\)\(\ \)\(f\)\(\ \)\)\)!
Nas listas de amostragem espacial, índices  1  <  n  <  ns correpondem a posições  x = step (n - (ns/2)) (para intervalos simétricos com respeito à origem).

f = 
        Compile[{c, κ, x}, 
          c (E^(-κ Abs[x]))];

SetOptions[ListPlot,PlotJoined -> False,Frame -> True,DefaultFont -> {"Times", 8. }];

FFTAnalyse[f[1,1.1,#]&,10,10]

displayAnalysis[{-.5,.5},{-4,4},{PlotJoined->False},{PlotJoined->False,PlotRange:>{Min[0,ymin-.1],Max[1.1,ymax]}}];

f = 
        Compile[{c, κ, x, a}, 
          c (E^(-κ (((x - a))^2)))];

FFTAnalyse[f[1,1.1,#,2]&,10,10]

displayAnalysis[{-1.5,1.5},{-8,8},{PlotJoined->False},{PlotJoined->False,PlotRange:>{Min[0,ymin-.1],Max[1.1,ymax]}}];

f = 
        Compile[{c, b, x, a}, 
          If[Abs[x] < a,  c Cos[b x], 0]];

FFTAnalyse[f[1, (5/2), #1, π] &, 10, 10]

displayAnalysis[{-1.5,1.5},{-8,8},{PlotJoined->False},{PlotJoined->False,PlotRange:>{Min[0,ymin-.1],Max[1.1,ymax]}}];

f = 
        Compile[{c, L, x, a}, If[L - a < Abs[x] < L + a, c, 0]];

FFTAnalyse[f[1, 2, #1,  .5] &, 11, 2.5]

displayAnalysis[{-1.5, 1.5}, {-8, 
          8}, {PlotJoined -> False}, {PlotJoined -> True, 
          PlotRange :> {Min[0, ymin -  .1], 
              Max[1.1, ymax]}}];