Why does InverseFourierTransform gives different result to doing it by hand?

When I can calculate an inverse fourier transform by the built-in function InverserFourierTransform, the result is different from what I calculate by definition through integration manually. and I noticed that if I give a negative sign in the Exp function, then the solution is exact the same.

See here:

=================

  

 

Welcome to Mathematica.SE! I suggest the following: 1) As you receive help, try to give it too, by answering questions in your area of expertise. 2) Read the faq! 3) When you see good questions and answers, vote them up by clicking the gray triangles, because the credibility of the system is based on the reputation gained by users sharing their knowledge. Also, please remember to accept the answer, if any, that solves your problem, by clicking the checkmark sign!
– Louis
May 6 ’15 at 9:07

2

 

Check your setting of FourierParameters for consistency with your convention.
– J. M.♦
May 6 ’15 at 9:07

=================

2 Answers
2

=================

The functions Fourier, FourierTransform, InverseFourier, and InverseFourierTransform (possibly others that I am not aware of) all accept a parameter called FourierParameters to determine the flavor of transform performed. By default, the value of FourierParameters is {0, 1}, which gives the results you’ve observed. To run a ‘traditional’ Fourier transform, you will need to set these to {0, -1}.

The explanation for these parameters can be found under the Details and Options section of this help page for the Fourier function (currently the 5th bullet). Basically, there are many conventions for how to perform the Fourier transform that are used in different situations and have similar properties to the convention that most of us learn in college; more information about these conventions can also be found on the wikipedia page for Fourier transforms.

One mildly confusing point: Fourier[x, FourierParameters -> {0,-1}] should give the same result as InverseFourier[x, FourierParameters -> {0,1}] due to the way the parameters are interpreted. Make sure to keep in mind that if you use FourierParameters -> {0, -1} with the forward function then you have to use it for the inverse as well; i.e.:

x == InverseFourier[
Fourier[x, FourierParameters -> {0,-1}],
FourierParameters -> {0, -1}];
(* => True *)

  

 

Thanks! that is exactly what I am looking for.
– waynezw0618
May 6 ’15 at 16:05

There appears to be a problem with version 10.1 compared to version 10.0

Your direct integration implies that your Fourier parameters are {-1, 1}

$Version

“10.0 for Mac OS X x86 (64-bit) (December 4, 2014)”

F[w_] = 1/(1 – I*w);

f[t_] = InverseFourierTransform[F[w], w, t,
FourierParameters -> {-1, 1}]

(2*Pi*HeavisideTheta[t])/E^t

F[w] == FourierTransform[f[t], t, w,
FourierParameters -> {-1, 1}] // Simplify

True

test = Simplify[f[t], #] & /@ {t < 0, t > 0}

{0, (2*Pi)/E^t}

Version 10.0 handles the direct integration easily

f2[t_] = Integrate[F[w]*Exp[-I*w*t],
{w, -Infinity, Infinity}, Assumptions -> Element[t, Reals]]

(Pi*(1 + Sign[t]))/E^Abs[t]

This is equivalent except for t==0 for which the HeavisideTheta is undefined

test == (Simplify[f2[t], #] & /@ {t < 0, t > 0})

True

However, with version 10.1 while the built-in functions work the direct integration does not

$Version

“10.1.0 for Mac OS X x86 (64-bit) (March 24, 2015)”

F[w_] = 1/(1 – I*w);

f[t_] = InverseFourierTransform[F[w], w, t,
FourierParameters -> {-1, 1}]

(2*Pi*HeavisideTheta[t])/E^t

Simplify[f[t], #] & /@ {t < 0, t > 0}

{0, (2*Pi)/E^t}

F[w] == FourierTransform[f[t], t, w,
FourierParameters -> {-1, 1}] // Simplify

True

Version 10.1 does not handle the direct integration

f2[t_] = Integrate[F[w]*Exp[-I*w*t],
{w, -Infinity, Infinity}, Assumptions -> Element[t, Reals]]

(1/2)I((1/Sqrt[Pi])*
(-MeijerG[{{1/2, 1, 1}, {}},
{{1}, {}}, (2*I)/Abs[t],
1/2] – I*MeijerG[
{{1/2, 1/2, 1}, {}},
{{1/2}, {}}, (2*I)/Abs[t],
1/2]*Sign[t]) +
2*CosIntegral[IAbs[t]]
(-Cosh[Abs[t]] + Sign[t]*
Sinh[Abs[t]]) –
I*(Cosh[Abs[t]]Sign[t] –
Sinh[Abs[t]])(Pi –
2*I*SinhIntegral[Abs[t]]))