Warning: This resource is provisional

Function Repository Resource:

GenericIntegralTransform

Source Notebook

Compute a variety of integral transforms on input expressions

Contributed by: Paco Jain & Oleg Marichev

ResourceFunction["GenericIntegralTransform"][f,z,t,transform]

gives the integral transform 𝒯_transform[f(z)](t) of the input function f(z), in terms of new variable t.

ResourceFunction["GenericIntegralTransform"][]

prints a table of all available transforms and their definitions.

ResourceFunction["GenericIntegralTransform"][patt]

prints a table of available transforms whose names match the string pattern patt.

ResourceFunction["GenericIntegralTransform"][…, form]

prints a table of transforms with definitions displayed in the specified form.

Details and Options

ResourceFunction["GenericIntegralTransform"] supports the following options:

GenerateConditions

False

whether to provide conditions under which the given result is valid

"FoxHForm"

False

whether to provide results (where possible) in terms of the FoxH function

The only option values supported for the GenerateConditions options are True and False.

The argument form can be StandardForm, InputForm, or TraditionalForm (the default).

Supported values for the transform argument are given in the second column of the table below, with corresponding definitions given in the third column:

Fourier transform

"Fourier" | "FourierExp"

Fourier cosine transform

"FourierCos"

Fourier sine transform

"FourierSin"

G-transform

Hankel transform

{"Hankel",ν}

Hankel transform with Power

{"Hankel",ν,α}

Hartley tranform

"Hartley"

Hilbert transform

"Hilbert"

Hilbert transform with Power

{"Hilbert",α}

Integrate transform

"Integrate"

Integrate transform with Power

{"Integrate",α}

Laplace transform

"Laplace"

Laplace transform with Power

{"Laplace",α}

Laplace transform (2‐sided)

"LaplaceTwoSided"

Mellin transform

"Mellin"

Mellin transform with Power

{"Mellin",α}

Neumann transform

{"Neumann”, ν}

Neumann transform with Power

{"Neumann”, ν,α}

Riesz transform

{"Riesz”, α}

with Re[α]>0

Stieltjes transform

{"Stieltjes”, ρ}

Struve transform

{“Struve”, ν}

Struve transform with Power

{"Struve”, ν,α}

Weyl transform

{“Weyl”, α}

In the table above, p.v. indicates the Cauchy principal value of the integral.

Examples

Basic Examples (5)

Compute the Mellin transform of a Bessel function:

In[1]:=

$ResourceFunction[ "GenericIntegralTransform", ResourceSystemBase -> "https://www.wolframcloud.com/obj/resourcesystem/api/1.0"][BesselJ[\[Nu], z], z, t, "Mellin"]$

Out[1]=

Compute the Mellin transform of an exponential function:

In[2]:=

Out[2]=

Get the conditions of convergence for when the result above is valid:

In[3]:=

Out[3]=

Generically, the result returned is a ConditionalExpression. The conditions under which this result holds can be expanded by clicking the “+“, followed by “Uniconize”, or simply by examining the InputForm:

In[4]:=

Out[4]=

In[5]:=

$ConditionalExpression[ a^-s Gamma[ s], (Abs[Arg[a]] <= \[Pi]/2 && Re[s] < 1 && Re[s] + Inactive[Max][{}] < 1 && Re[s] + Inactive[Min][{0}] > 0) || (Abs[Arg[a]] < \[Pi]/2 && Re[s] + Inactive[Max][{}] < 1 && Re[s] + Inactive[Min][{0}] > 0)] \[AliasDelimiter]$

Compute the Laplace transform of a cosine. By default, GenericIntegralTransform gives results in terms of an Inactive MeijerG function:

In[6]:=

Out[6]=

Use Activate to allow the Inactive[MeijerG] to evaluate to elementary functions:

In[7]:=

Out[7]=

Compute the Hankel transform of an arctangent:

In[8]:=

$ResourceFunction[ "GenericIntegralTransform", ResourceSystemBase -> "https://www.wolframcloud.com/obj/resourcesystem/api/1.0"][ ArcTan[z], z, t, {"Hankel", {\[Alpha], \[Nu]}}]$

Out[8]=

To evaluate in terms of simpler functions, use Activate and FunctionExpand:

In[9]:=

Out[9]=

Some results are available in terms of the FoxH function. To return this form where possible, use the "FoxHForm" option:

In[10]:=

$ResourceFunction[ "GenericIntegralTransform", ResourceSystemBase -> "https://www.wolframcloud.com/obj/resourcesystem/api/1.0"][Sin[z], z, t, {"Hankel", {\[Alpha], \[Nu]}}, "FoxHForm" -> True]$

Out[10]=

Scope (26)

lists of transforms (2)

Get a table of all available transforms, with definitions in TraditionalForm:

In[11]:=

List all transforms starting with the character "H", with definitions given in InputForm:

In[12]:=

G-transform (2)

Compute the G-transform of a sine:

In[13]:=

$ResourceFunction[ "GenericIntegralTransform", ResourceSystemBase -> "https://www.wolframcloud.com/obj/resourcesystem/api/1.0"][ Sin[z], z, t, {"G", {{{}, {\[Alpha]}}, {{0}, {}}}}]$

Out[13]=

Get the result in terms of FoxH:

In[14]:=

$ResourceFunction[ "GenericIntegralTransform", ResourceSystemBase -> "https://www.wolframcloud.com/obj/resourcesystem/api/1.0"][ Sin[z], z, t, {"G", {{{}, {\[Alpha]}}, {{0}, {}}}}, "FoxHForm" -> True]$

Out[14]=

Hankel transform (2)

Compute the Hankel transform of a sine:

In[15]:=

$ResourceFunction[ "GenericIntegralTransform", ResourceSystemBase -> "https://www.wolframcloud.com/obj/resourcesystem/api/1.0"][Sin[z], z, t, {"Hankel", {\[Alpha], \[Nu]}}]$

Out[15]=

Get the result in terms of FoxH:

In[16]:=

$ResourceFunction[ "GenericIntegralTransform", ResourceSystemBase -> "https://www.wolframcloud.com/obj/resourcesystem/api/1.0"][Sin[z], z, t, {"Hankel", {\[Alpha], \[Nu]}}, "FoxHForm" -> True]$

Out[16]=

Hilbert transform (2)

Compute the Hilbert transform of a sine:

In[17]:=

$ResourceFunction[ "GenericIntegralTransform", ResourceSystemBase -> "https://www.wolframcloud.com/obj/resourcesystem/api/1.0"][Sin[z], z, t, {"Hilbert", \[Alpha]}]$

Out[17]=

Get the result in terms of FoxH:

In[18]:=

$ResourceFunction[ "GenericIntegralTransform", ResourceSystemBase -> "https://www.wolframcloud.com/obj/resourcesystem/api/1.0"][Sin[z], z, t, {"Hilbert", \[Alpha]}, "FoxHForm" -> True]$

Out[18]=

Integrate transform (2)

Compute the "Integrate transform" of a sine:

In[19]:=

$ResourceFunction[ "GenericIntegralTransform", ResourceSystemBase -> "https://www.wolframcloud.com/obj/resourcesystem/api/1.0"][Sin[z], z, t, {"Integrate", \[Alpha]}]$

Out[19]=

Get the result in terms of FoxH:

In[20]:=

$ResourceFunction[ "GenericIntegralTransform", ResourceSystemBase -> "https://www.wolframcloud.com/obj/resourcesystem/api/1.0"][Sin[z], z, t, {"Integrate", \[Alpha]}, "FoxHForm" -> True]$

Out[20]=

Laplace transform (2)

Compute the Laplace transform of a sine:

In[21]:=

$ResourceFunction[ "GenericIntegralTransform", ResourceSystemBase -> "https://www.wolframcloud.com/obj/resourcesystem/api/1.0"][Sin[z], z, t, {"Laplace", \[Alpha]}]$

Out[21]=

Get the result in terms of FoxH:

In[22]:=

$ResourceFunction[ "GenericIntegralTransform", ResourceSystemBase -> "https://www.wolframcloud.com/obj/resourcesystem/api/1.0"][Sin[z], z, t, {"Laplace", \[Alpha]}, "FoxHForm" -> True]$

Out[22]=

Liouville transform (2)

Compute the Liousville transform of a sine:

In[23]:=

$ResourceFunction[ "GenericIntegralTransform", ResourceSystemBase -> "https://www.wolframcloud.com/obj/resourcesystem/api/1.0"][Sin[z], z, t, {"Liouville", \[Alpha]}]$

Out[23]=

Get the result in terms of FoxH:

In[24]:=

$ResourceFunction[ "GenericIntegralTransform", ResourceSystemBase -> "https://www.wolframcloud.com/obj/resourcesystem/api/1.0"][Sin[z], z, t, {"Liouville", \[Alpha]}, "FoxHForm" -> True]$

Out[24]=

Meijer transform (2)

Compute the Meijer transform of a sine:

In[25]:=

$ResourceFunction[ "GenericIntegralTransform", ResourceSystemBase -> "https://www.wolframcloud.com/obj/resourcesystem/api/1.0"][Sin[z], z, t, {"Meijer", {\[Alpha], \[Nu]}}]$

Out[25]=

Get the result in terms of FoxH:

In[26]:=

$ResourceFunction[ "GenericIntegralTransform", ResourceSystemBase -> "https://www.wolframcloud.com/obj/resourcesystem/api/1.0"][Sin[z], z, t, {"Meijer", {\[Alpha], \[Nu]}}, "FoxHForm" -> True]$

Out[26]=

Mellin transform (2)

Compute the Mellin transform of a sine:

In[27]:=

Out[27]=

A result in terms of FoxH is not available:

In[28]:=

Out[28]=

Compute the Mellin transform of BesselJ:

In[29]:=

$ResourceFunction[ "GenericIntegralTransform", ResourceSystemBase -> "https://www.wolframcloud.com/obj/resourcesystem/api/1.0"][BesselJ[\[Nu], z], z, t, "Mellin"]$

Out[29]=

Neumann transform (2)

Compute the Neumann transform of a sine:

In[30]:=

$ResourceFunction[ "GenericIntegralTransform", ResourceSystemBase -> "https://www.wolframcloud.com/obj/resourcesystem/api/1.0"][Sin[z], z, t, {"Neumann", {\[Alpha], \[Nu]}}]$

Out[30]=

Get the result in terms of FoxH:

In[31]:=

$ResourceFunction[ "GenericIntegralTransform", ResourceSystemBase -> "https://www.wolframcloud.com/obj/resourcesystem/api/1.0"][Sin[z], z, t, {"Neumann", {\[Alpha], \[Nu]}}, "FoxHForm" -> True]$

Out[31]=

Riesz transform (2)

Compute the Riesz transform of a sine:

In[32]:=

$ResourceFunction[ "GenericIntegralTransform", ResourceSystemBase -> "https://www.wolframcloud.com/obj/resourcesystem/api/1.0"][Sin[z], z, t, {"Riesz", \[Alpha]}]$

Out[32]=

Get the result in terms of FoxH:

In[33]:=

$ResourceFunction[ "GenericIntegralTransform", ResourceSystemBase -> "https://www.wolframcloud.com/obj/resourcesystem/api/1.0"][Sin[z], z, t, {"Riesz", \[Alpha]}, "FoxHForm" -> True]$

Out[33]=

Stieltjes transform (2)

Compute the Stieltjes transform of a sine:

In[34]:=

$ResourceFunction[ "GenericIntegralTransform", ResourceSystemBase -> "https://www.wolframcloud.com/obj/resourcesystem/api/1.0"][Sin[z], z, t, {"Stieltjes", \[Rho]}]$

Out[34]=

Get the result in terms of FoxH:

In[35]:=

$ResourceFunction[ "GenericIntegralTransform", ResourceSystemBase -> "https://www.wolframcloud.com/obj/resourcesystem/api/1.0"][Sin[z], z, t, {"Stieltjes", \[Rho]}, GenerateConditions -> False, "FoxHForm" -> True]$

Out[35]=

Struve transform (2)

Compute the Struve transform of a sine:

In[36]:=

$ResourceFunction[ "GenericIntegralTransform", ResourceSystemBase -> "https://www.wolframcloud.com/obj/resourcesystem/api/1.0"][Sin[z], z, t, {"Struve", {\[Nu], \[Alpha]}}]$

Out[36]=

Get the result in terms of FoxH:

In[37]:=

$ResourceFunction[ "GenericIntegralTransform", ResourceSystemBase -> "https://www.wolframcloud.com/obj/resourcesystem/api/1.0"][Sin[z], z, t, {"Struve", {\[Nu], \[Alpha]}}, "FoxHForm" -> True]$

Out[37]=

Options (4)

FoxHForm (2)

Compute a G-transform of a BesselY function:

In[38]:=

$ResourceFunction["GenericIntegralTransform"][ BesselY[\[Nu], z], z, t, {"G", {{{}, {\[Alpha]}}, {{0}, {}}}}]$

Out[38]=

Get the result instead in terms of FoxH:

In[39]:=

$ResourceFunction[ "GenericIntegralTransform", ResourceSystemBase -> "https://www.wolframcloud.com/obj/resourcesystem/api/1.0"][ BesselY[\[Nu], z], z, t, {"G", {{{}, {\[Alpha]}}, {{0}, {}}}}, GenerateConditions -> False, "FoxHForm" -> True]$

Out[39]=

GenerateConditions (2)

The default setting GenerateConditions→False returns a result only, without regard to conditions of convergence:

In[40]:=

$ResourceFunction[ "GenericIntegralTransform", ResourceSystemBase -> "https://www.wolframcloud.com/obj/resourcesystem/api/1.0"][BesselJ[\[Nu], z], z, t, "Mellin"]$

Out[40]=

With GenerateConditions→True, the result can be a ConditionalExpression whose second part gives the conditions of convergence:

In[41]:=

$res = ResourceFunction[ "GenericIntegralTransform", ResourceSystemBase -> "https://www.wolframcloud.com/obj/resourcesystem/api/1.0"][BesselJ[\[Nu], z], z, t, "Mellin", GenerateConditions -> True]$