Prove FT

$Version

Definizione della FT in termini di pulsazione

FourierTransform[1/(1 + x^2), x, ω, 
      FourierParameters -> {1, -1}]

InverseFourierTransform[%, ω, x, 
      FourierParameters -> {1, -1}]

FourierTransform[Exp[-Abs[x]], x, ω, 
      FourierParameters -> {1, -1}]

InverseFourierTransform[%, ω, x, 
      FourierParameters -> {1, -1}]

FourierTransform[Exp[-x^2], x, ω, 
      FourierParameters -> {1, -1}]

InverseFourierTransform[%, ω, x, 
      FourierParameters -> {1, -1}]

Introduciamo la densità di una v.a. normale:

f[μ_, σ_, x_] := 
      1/(Sqrt[
                2  π] σ) Exp[-(x - μ)^2/(2 σ^2)]

Trasformiamo due diverse densità:

FourierTransform[f[(Subscript[μ, 1]), (Subscript[σ, 1]), x], x, ω, 
      FourierParameters -> {1, -1}]

Simplify[%,  (Subscript[σ, 1]) > 0]

FourierTransform[f[(Subscript[μ, 2]), (Subscript[σ, 2]), x], x, ω, 
      FourierParameters -> {1, -1}]

Simplify[%,  (Subscript[σ, 2]) > 0]

Faccciamo il prodotto delle trasformate:

% %%%

Simplify[%]

... e invertiamo:

InverseFourierTransform[%, ω, x, 
      FourierParameters -> {1, -1}]

% /. {(Subscript[σ, 1]^2) + (Subscript[σ, 2]^2) -> (σ^2),  (Subscript[μ, 1]) + (Subscript[μ, 2]) -> μ}

Simplify[%,  σ > 0]

Conclusione: la somma di due v.a. normali, tra loro indipendenti, è una v.a. normale che ha come media la somma delle medie e come varianza la somma delle varianze.

Altri esempi:

FourierTransform[DiracDelta[x], x, ω, 
      FourierParameters -> {1, -1}]

InverseFourierTransform[%, ω, x, 
      FourierParameters -> {1, -1}]

FourierTransform[Sin[λ x], x, ω, 
      FourierParameters -> {1, -1}]

FourierTransform[Cos[λ x], x, ω, 
      FourierParameters -> {1, -1}]

FourierTransform[Sign[ x], x, ω, 
      FourierParameters -> {1, -1}]

InverseFourierTransform[%, ω, x, 
      FourierParameters -> {1, -1}]

FourierTransform[UnitStep[ x], x, ω, 
      FourierParameters -> {1, -1}]

-(I/ω) + π DiracDelta[ω]

InverseFourierTransform[%, ω, x, 
      FourierParameters -> {1, -1}]

FourierTransform[Sin[x]/x, x, ω, 
      FourierParameters -> {1, -1}]

Plot[%,  {ω, -2, 2}, 
        PlotStyle -> {RGBColor[1, 0, 0], Thickness[0.01]}];

InverseFourierTransform[%%, ω, x, 
      FourierParameters -> {1, -1}]

Mathematica conosce le regole che riguardano il prodotto di una funzione per la delta di Dirac:

Simplify[%]

Expand poi ExpToTrig a numeratore

-(((-2 Sin[x]))/(2 x))

Simplify[-(((-2 Sin[x]))/(2 x))]

FourierTransform[1/(1 + (x - 1)^2), x, ω, 
      FourierParameters -> {1, -1}]

Commento: per ω > 0, la funzione coincide col secondo addendo, per ω < 0 essa coincide col primo addendo. Possiamo applicare agli esponenziali le semplificazioni "in situ" ComplexExpand e Factor :

(E^ω) (Cos[ω] - I Sin[ω]) π UnitStep[-ω] + (E^(-ω)) (Cos[ω] - I Sin[ω]) π UnitStep[ω]

Applicando Factor a tutta l'espressione:

(E^(-ω)) π (Cos[ω] - I Sin[ω]) ((E^(2 ω)) UnitStep[-ω] + UnitStep[ω])

Volendo accostare l'esponenziale a ciascun gradino unitario occorre forzare Mathematica :

eee =  %

eee[[1]]

eee[[2]]

eee[[3]]

eee[[4]]

Expand[
      eee[[1]] eee[[4]]]

% eee[[2]] eee[[3]]

Commento finale: l'esempio precedente dava risultati errati nella versione 4.0 di Mathematica.

Definizione della FT in termini di frequenza

Utilizziamo la lettera ν per la frequenza (si usa spesso anche le lettera f ):

FourierTransform[1/(1 + t^2), t, ν, 
      FourierParameters -> {0, -2 π}]

InverseFourierTransform[%, ν, t, 
        FourierParameters -> {0, -2 π}] // Simplify

Il risultato ottenuto può essere calcolato dalla FT precedentemente calcolata in termini di pulsazione, con la sostituzione ω -> 2π ν

FourierTransform[1/(1 + x^2), x, ω, 
      FourierParameters -> {1, -1}]

% /. ω ->  2  π ν

FourierTransform[1/t, t, ν, 
      FourierParameters -> {0, -2 π}]

FourierTransform[Sign[t], t, ν, 
      FourierParameters -> {0, -2 π}]

FourierTransform[Sin[2  π λ t], t, ν, 
      FourierParameters -> {0, -2 π}]

Simplify[%]

Mathematica  non sembra sapere che la delta di Dirac è una funzione omogenea di grado -1. Possiamo tentare di insegnarglielo:

% /. DiracDelta[π x_]  -> DiracDelta[x]/π

DiracDelta[π λ - π ν] == 
      DiracDelta[π ν - π λ]

Proviamo con un numero al posto di λ:

FourierTransform[Sin[5  π  t], t, ν, 
      FourierParameters -> {0, -2 π}]

Simplify[%]

% /. DiracDelta[π x_]  -> DiracDelta[x]/π

FourierTransform[UnitStep[t], t, ν, 
      FourierParameters -> {0, -2 π}]

Expand[%]

FourierTransform[DiracDelta[t], t, ν, 
      FourierParameters -> {0, -2 π}]

FourierTransform[DiracDelta[t - t0], t, ν, 
      FourierParameters -> {0, -2 π}]