WOLFRAM

Wolfram Language & System Documentation Center

EllipticF[ϕ,m]

gives the elliptic integral of the first kind TemplateBox[{phi, m}, EllipticF].

Details
Details and Options Details and Options
Examples  
Basic Examples  
Scope  
Numerical Evaluation  
Specific Values  
Visualization  
Show More Show More
Function Properties  
Differentiation  
Integration  
Series Expansions  
Function Representations  
Applications  
Properties & Relations  
Possible Issues  
Neat Examples  
See Also
Tech Notes
Related Guides
Related Links
History
Cite this Page

EllipticF

EllipticF[ϕ,m]

gives the elliptic integral of the first kind TemplateBox[{phi, m}, EllipticF].

Details

Examples

open all close all

Basic Examples  (4)

Evaluate numerically:

Wolfram Language code: EllipticF[0.3, 0.8]

Plot over a subset of the reals:

Wolfram Language code: Plot[EllipticF[ϕ, 0.5], {ϕ, 0, Pi / 2}]

Plot over a subset of the complexes:

Wolfram Language code: ComplexPlot3D[EllipticF[z, 0.5], {z, -2 - 2 I, 2 + 2 I}, PlotLegends -> Automatic, Exclusions -> All]

Series expansion at the origin:

Wolfram Language code: Series[EllipticF[ϕ, m], {ϕ, 0, 8}]

Scope  (36)

Numerical Evaluation  (5)

Evaluate for complex arguments:

Wolfram Language code: EllipticF[3 + 2.5 I, 2.3 - 1.5 I]

Evaluate to high precision:

Wolfram Language code: N[EllipticF[12 / 5, 3], 50]

The precision of the output tracks the precision of the input:

Wolfram Language code: EllipticF[2, 0.9999999999999999990000000000000000000]
Wolfram Language code: EllipticF[2, 0.9999999999999999990000000000000000000000000000000000]

Evaluate EllipticF efficiently at high precision:

Wolfram Language code: EllipticF[2, 0.4`500]//Timing
Wolfram Language code: EllipticF[2, 0.4`100000];//Timing

Compute worst-case guaranteed intervals using Interval and CenteredInterval objects:

Wolfram Language code: EllipticF[0.2, Interval[{0.3, 0.4}]]
Wolfram Language code: EllipticF[1, CenteredInterval[-4, 1 / 10]]

Or compute average case statistical intervals using Around:

Wolfram Language code: EllipticF[ Around[2, 0.01], 1 / 2]

Compute the elementwise values of an array:

Wolfram Language code: EllipticF[{{1, 0}, {0, 1}}, 0]

Or compute the matrix EllipticF function using MatrixFunction:

Wolfram Language code: MatrixFunction[EllipticF[#, 0]&, {{1, 0}, {0, 1}}]

Specific Values  (5)

Simple exact values are generated automatically:

Wolfram Language code: EllipticF[ϕ, 0]
Wolfram Language code: {EllipticF[0, m], EllipticF[Pi / 2, m]}

Value at infinity:

Wolfram Language code: EllipticF[ϕ, Infinity]

Limiting values on branch cuts:

Wolfram Language code: Limit[EllipticF[2 + ε I, 2], ε -> 0, Direction -> -1]
Wolfram Language code: Limit[EllipticF[2 + ε I, 2], ε -> 0, Direction -> +1]

Find the root of the equation TemplateBox[{pi, m}, EllipticF]=3:

Wolfram Language code: f[m_] := EllipticF[π, m] - 3; xzero = Solve[f[m] == 0 && -1.0 < m < 0, m][[1, 1, 2]]//Quiet
Wolfram Language code: Plot[f[m], {m, -1, 1}, Epilog -> Style[Point[{xzero, f[xzero]}], PointSize[Large], Red]]

EllipticF is an odd function with respect to its first parameter:

Wolfram Language code: EllipticF[-ϕ, m]

Visualization  (3)

Plot the elliptic integral for various values of parameter :

Wolfram Language code: Plot[{EllipticF[ϕ, 0], EllipticF[ϕ, 1], EllipticF[ϕ, 2]}, {ϕ, -2, 2}]

Plot the elliptic integral as a function of its parameter :

Wolfram Language code: Plot[{EllipticF[π, m], EllipticF[π / 2, m], EllipticF[-π / 2, m], EllipticF[-π, m]}, {m, -10, 2}, IconizedObject[«PlotOptions»]]

Plot the real part of TemplateBox[{z, 1}, EllipticF]:

Wolfram Language code: ComplexContourPlot[Re[EllipticF[z, 1]], {z, -π / 2 - I π / 2 , π / 2 + I π / 2}, IconizedObject[«PlotOptions»]]

Plot the imaginary part of TemplateBox[{z, 1}, EllipticF]:

Wolfram Language code: ComplexContourPlot[Im[EllipticF[z, 1]], {z, -π / 2 - I π / 2 , π / 2 + I π / 2}, IconizedObject[«PlotOptions»]]

Function Properties  (10)

TemplateBox[{phi, 0.5`}, EllipticF] is defined for all real values:

Wolfram Language code: FunctionDomain[EllipticF[ϕ, 0.5], ϕ]

TemplateBox[{phi, 0.5`}, EllipticF] takes all real values:

Wolfram Language code: FunctionRange[EllipticF[ϕ, 0.5], ϕ, y]//Quiet

EllipticF is an odd function with respect to its first parameter:

Wolfram Language code: EllipticF[-ϕ, m]

TemplateBox[{phi, 0.5`}, EllipticF] is an analytic function of :

Wolfram Language code: FunctionAnalytic[EllipticF[ϕ, .5], ϕ]

Has no singularities or discontinuities:

Wolfram Language code: FunctionSingularities[EllipticF[ϕ, .5], ϕ]//Quiet
Wolfram Language code: FunctionDiscontinuities[EllipticF[ϕ, .5], ϕ]//Quiet

TemplateBox[{n, m}, EllipticF] is not a meromorphic function of and :

Wolfram Language code: FunctionMeromorphic[EllipticF[n, m], {n, m}]

TemplateBox[{phi, 2}, EllipticF] is nondecreasing on its real domain:

Wolfram Language code: FunctionDomain[EllipticF[ϕ, 2], ϕ]
Wolfram Language code: FunctionMonotonicity[{EllipticF[ϕ, 2], -(π/4) ≤ ϕ ≤ (π/4)}, ϕ]//Quiet

TemplateBox[{phi, 2}, EllipticF] is injective:

Wolfram Language code: FunctionInjective[EllipticF[ϕ, 2], ϕ]
Wolfram Language code: Plot[{EllipticF[ϕ, 2], .5}, {ϕ, -π / 2, π / 2}]

TemplateBox[{phi, 2}, EllipticF] is not surjective:

Wolfram Language code: FunctionSurjective[EllipticF[ϕ, 2], ϕ]
Wolfram Language code: Plot[{EllipticF[ϕ, 2], 2}, {ϕ, -π, π}]

TemplateBox[{phi, 2}, EllipticF] is neither non-negative nor non-positive:

Wolfram Language code: FunctionSign[{EllipticF[ϕ, 2], -(π / 4) <= ϕ <= π / 4}, ϕ]

TemplateBox[{phi, 2}, EllipticF] is neither convex nor concave:

Wolfram Language code: FunctionConvexity[{EllipticF[ϕ, 2], -(π / 4) <= ϕ <= π / 4}, ϕ]

Differentiation  (3)

First derivative:

Wolfram Language code: D[EllipticF[ϕ, m], ϕ]

Higher derivatives:

Wolfram Language code: derivs = Table[D[EllipticF[ϕ, m], {ϕ, n}], {n, 1, 3}]//FullSimplify

Plot higher derivatives for :

Wolfram Language code: Plot[Evaluate[derivs /. m -> 1], {ϕ, -π / 2, π / 2}, PlotLegends -> {"First Derivative", "Second Derivative", "Third Derivative"}]

Differentiate with respect to parameter :

Wolfram Language code: D[EllipticF[ϕ, m], m]

Integration  (3)

Indefinite integral of EllipticF:

Wolfram Language code: Integrate[EllipticF[ϕ, m], m]

Definite integral of an odd function over an interval centered at the origin is 0:

Wolfram Language code: Integrate[EllipticF[ϕ, m], {ϕ, -1, 1}]

More integrals:

Wolfram Language code: Integrate[Sin[z]EllipticF[z, m] , z]
Wolfram Language code: Integrate[( Sin[2 z]EllipticF[z, m]/(1 - m Sin[z]^2)^3 / 2), z]

Series Expansions  (3)

Taylor expansion for EllipticF:

Wolfram Language code: Series[EllipticF[ϕ, m], {ϕ, 0, 5}]

Plots of the first three approximations for TemplateBox[{phi, 1}, EllipticF] around :

Wolfram Language code: terms = Normal@Table[Series[EllipticF[ϕ, 1], {ϕ, 0, n}], {n, 1, 5, 2}]; Plot[{EllipticF[ϕ, 1], terms}, {ϕ, -2, 2}]

Expand in series with respect to the modulus:

Wolfram Language code: Series[EllipticF[ϕ, m], {m, 0, 3}]

Plots of the first three approximations for TemplateBox[{pi, m}, EllipticF] around :

Wolfram Language code: terms = Normal@Table[Series[EllipticF[π, m], {m, 0, n}], {n, 1, 3}]; Plot[{EllipticF[π, m], terms}, {m, -1, 1}, PlotLegends -> "Expressions"]

EllipticF can be applied to power series:

Wolfram Language code: EllipticF[ϕ + (ϕ^2/2) + (ϕ^3/3) + O[ϕ]^4, m]
Wolfram Language code: EllipticF[ϕ, m + (m^2/2) + (m^3/3) + O[m]^4]

Function Representations  (4)

The definition of the elliptic integral of the second kind:

Wolfram Language code: Integrate[(1/Sqrt[1 - m Sin[θ] ^ 2]), {θ, 0, ϕ}, Assumptions -> 0 ≤ ϕ ≤ π / 2]

Relation to EllipticPi:

Wolfram Language code: EllipticPi[0, ϕ, m]

EllipticF can be represented as a DifferentialRoot:

Wolfram Language code: DifferentialRootReduce[EllipticF[ϕ, m], m]

TraditionalForm formatting:

Wolfram Language code: EllipticF[ϕ, m] // TraditionalForm

Applications  (5)

Carry out an elliptic integral:

Wolfram Language code: Integrate[(1/Sqrt[a x^4 + b]), x]

Plot an incomplete elliptic integral over the complex plane:

Wolfram Language code: Plot3D[Im[EllipticF[x + I y, 1 / 2]], {x, -2Pi, 2Pi}, {y, -3, 3}]

Calculate the surface area of a triaxial ellipsoid:

Wolfram Language code: area[a_, b_, c_] := With[{m = (a^2(b^2 - c^2)/b^2(a^2 - c^2)), ϑ = ArcSin[Sqrt[1 - (c^2/a^2)]]}, 2 π((b c^2 /Sqrt[a^2 - c^2])EllipticF[ϑ, m] + c^2 + b Sqrt[a^2 - c^2] EllipticE[ϑ, m])] /; a > b > c;

The area of an ellipsoid with half axes 3, 2, 1:

Wolfram Language code: area[3, 2, 1]//N

Calculate volume through integrating the differential surface elements:

Wolfram Language code: With[{a = 3, b = 2, c = 1}, NIntegrate[Sin[ϑ]Sqrt[b^2c^2Cos[φ]^2Sin[ϑ]^2 + a^2c^2Sin[φ]^2Sin[ϑ]^2 + a^2b^2Cos[ϑ]^2], {φ, 0, 2Pi}, {ϑ, 0, Pi}]]

Arc length parametrization of a curve that minimizes the integral of the square of its curvature:

Wolfram Language code: DSolve[s'[φ] == -(c/Sqrt[Cos[φ]]), s[φ], φ]

Parametrization of a Mylar balloon (two flat sheets of plastic sewn together at their circumference and then inflated):

Wolfram Language code: x[u_, v_] := (Cos[v]/Sqrt[Cosh[2u]]) y[u_, v_] := (Sin[v]/Sqrt[Cosh[2u]]) z[u_, v_] := With[{f = ArcSin[(Sqrt[2]Sinh[u]/Sqrt[Cosh[2u]])]}, Sqrt[2](EllipticE[f, (1/2)] - (1/2)EllipticF[f, (1/2)])]

Plot the resulting balloon:

Wolfram Language code: ParametricPlot3D[{x[u, v], y[u, v], z[u, v]}, {v, 0, 2Pi}, {u, -8, 8}, PlotRange -> All]

Calculate the ratio of the main curvatures:

Wolfram Language code: Block[{h, g}, h[u_] = x[u, v] / Cos[v];g[u_] = z[u, v];(((g''[u]h'[u] - g'[u]h''[u]/(g'[u]^2 + h'[u]^2)^3 / 2))/((g'[u]/h[u]Sqrt[g'[u]^2 + h'[u]^2])))//Simplify]

Express the radius of the original sheets through the radius of the inflated balloon:

Wolfram Language code: Module[{h, g}, h[u_] = x[u, v] / Cos[v];g[u_] = z[u, v];Integrate[Sqrt[h'[u]^2 + g'[u]^2]//Simplify, {u, 0, ∞}]]
Wolfram Language code: N[%, $MachinePrecision]

Properties & Relations  (7)

EllipticF[ϕ,m] is real valued for real arguments subject to the following conditions:

Wolfram Language code: FunctionDomain[EllipticF[ϕ, m], {ϕ, m}, Reals]

Expand special cases:

Wolfram Language code: EllipticF[ArcCsc[Sqrt[m]], m]//FunctionExpand

Expand special cases under argument restrictions:

Wolfram Language code: EllipticF[z, 1]//FunctionExpand
Wolfram Language code: FunctionExpand[%, 0 < z < Pi / 2]

Compositions with the inverse function need PowerExpand:

Wolfram Language code: EllipticF[JacobiAmplitude[z, m], m]
Wolfram Language code: PowerExpand[%]
Wolfram Language code: JacobiAmplitude[EllipticF[z, m], m]
Wolfram Language code: PowerExpand[%]

Solve an equation containing EllipticF:

Wolfram Language code: Solve[EllipticF[z, m]^3 + EllipticF[z, m] == x, z]

Numerically find a root of a transcendental equation:

Wolfram Language code: FindRoot[EllipticF[z, 2]^3 + EllipticF[z, 2] + z == 2, {z, 1}]

Limits on branch cuts:

Wolfram Language code: Limit[EllipticF[2 + ε I, 2], ε -> 0, Direction -> -1]//Quiet
Wolfram Language code: Limit[EllipticF[2 + ε I, 2], ε -> 0, Direction -> +1]//Quiet

For and phi=TemplateBox[{u, m}, JacobiAmplitude], TemplateBox[{phi, m}, EllipticF]=u:

Wolfram Language code: With[{m = 1 / 3}, {ParametricPlot[{ϕ, EllipticF[ϕ, m]}, {ϕ, -2Pi, 2Pi}, PlotStyle -> Thick], ParametricPlot[{JacobiAmplitude[u, m], u}, {u, -4 EllipticK[m], 4EllipticK[m]}, PlotStyle -> Directive[Dashed, Orange]]}]
Wolfram Language code: Show[%, ImageSize -> Tiny]

For , this is only true for :

Wolfram Language code: With[{m = 4}, {ParametricPlot[{ϕ, EllipticF[ϕ, m]}, {ϕ, -ArcSin[m^-1 / 2], ArcSin[m^-1 / 2]}, PlotStyle -> Thick], ParametricPlot[{JacobiAmplitude[u, m], u}, {u, -(1/Sqrt[m])EllipticK[1 / m], (1/Sqrt[m])EllipticK[1 / m]}, PlotStyle -> Directive[Dashed, Orange]]}]
Wolfram Language code: Show[%, ImageSize -> Tiny]

Possible Issues  (2)

The defining integral converges only under additional conditions:

Wolfram Language code: Integrate[(1/Sqrt[1 - m Sin[t]^2]), {t, 0, z}]

Different conventions exist for the second argument:

Wolfram Language code: Integrate[1 / Sqrt[1 - k ^ 2 Sin[t] ^ 2], {t, 0, z}, Assumptions -> 0 < k < 1 && 0 < z < 1]
Wolfram Language code: Integrate[1 / Sqrt[(1 - t ^ 2) (1 - m t ^ 2)], {t, 0, z}, Assumptions -> 0 < m < 1 && 0 < z < 1]

Neat Examples  (2)

Nested derivatives:

Wolfram Language code: NestList[D[#, x]&, EllipticF[x, m], 4]//Simplify//TraditionalForm

Plot EllipticF at integer points:

Wolfram Language code: ArrayPlot[Table[Mod[Round[Abs[EllipticF[x y, 0.3]]], 2], {x, -50, 50}, {y, -50, 50}]]
Wolfram Research (1988), EllipticF, Wolfram Language function, https://reference.wolfram.com/language/ref/EllipticF.html (updated 2022).

Text

Wolfram Research (1988), EllipticF, Wolfram Language function, https://reference.wolfram.com/language/ref/EllipticF.html (updated 2022).

CMS

Wolfram Language. 1988. "EllipticF." Wolfram Language & System Documentation Center. Wolfram Research. Last Modified 2022. https://reference.wolfram.com/language/ref/EllipticF.html.

APA

Wolfram Language. (1988). EllipticF. Wolfram Language & System Documentation Center. Retrieved from https://reference.wolfram.com/language/ref/EllipticF.html

BibTeX

@misc{reference.wolfram_2026_ellipticf, author="Wolfram Research", title="{EllipticF}", year="2022", howpublished="\url{https://reference.wolfram.com/language/ref/EllipticF.html}", note=[Accessed: 12-June-2026]}

BibLaTeX

@online{reference.wolfram_2026_ellipticf, organization={Wolfram Research}, title={EllipticF}, year={2022}, url={https://reference.wolfram.com/language/ref/EllipticF.html}, note=[Accessed: 12-June-2026]}