std::ellint...d::ellint_2l(3)

💅 NAME

std::ellint_2, std::ellint_2f, std::ellint_2l — literally those three, that's the whole name, no notes 🫶

Okay so real talk, this is the C++ Standard Libary manual page (yes bestie, that's how the header spells it, I'm not fixing it 💀), and the page title is std::ellint...d::ellint_2l(3) — that's the truncated version of the whole std::ellint_2 / std::ellint_2f / std::ellint_2l situation. C++17 math special functions era. Stay with me 🦋

---

✨ SYNOPSIS ✨

Defined in header <cmath>:

float       ellint_2 ( float k, float phi );
double      ellint_2 ( double k, double phi );
long double ellint_2 ( long double k, long double phi );
/* floating-point-type */ ellint_2( /* floating-point-type */ k,
                                    /* floating-point-type */ phi );
float       ellint_2f( float k, float phi );
long double ellint_2l( long double k, long double phi );

Here's the deets on which one landed when 👇

• (1) — the ellint_2 crew. The float one is (since C++17), the double one is (until C++23), and the /* floating-point-type */ overload is (since C++23).
• (2) — ellint_2f, (since C++17).
• (3) — ellint_2l, (since C++17).

Then there's the additional overloads situation 💫

Defined in header <cmath>

template< class Arithmetic1, class Arithmetic2 >
/* common-floating-point-type */
    ellint_2( Arithmetic1 k, Arithmetic2 phi );

• (A) — these extra overloads are (since C++17).

So what do 1–3 actually do? They compute the incomplete elliptic integral of the second kind of k and phi. Iconic.

And <pink>since C++23</pink>, the library provides overloads of std::ellint_2 for all cv-unqualified floating-point types as the type of the parameters k and phi. Slay.

(A) is your safety net: additional overloads are provided for all other combinations of arithmetic types. No cap.

---

🎀 PARAMETERS 🎀

• k — elliptic modulus or eccentricity (a floating-point or integer value)
• phi — Jacobi amplitude (a floating-point or integer value, measured in radians — do not come at me with degrees, bestie 😭)

---

🔥 RETURN VALUE 🔥

If no errors occur, you get the value of the incomplete elliptic integral of the second kind of k and phi, that is:

∫ from 0 to phi of √(1-k² sin²θ) dθ

That's the one. The math ate, fr fr 💅

---

💀 ERROR HANDLING 💀

Errors may be reported as specified in math_errhandling:

• If the argument is NaN, NaN is returned and domain error is not reported.
• If |k|>1, a domain error may occur.

⚠️ That |k|>1 one is your vibe check — it may blow up on you, so don't act surprised.

---

🦋 NOTES 🦋

Implementations that don't support C++17 but do support ISO 29124:2010 provide this function if __STDCPP_MATH_SPEC_FUNCS__ is defined by the implementation to a value at least 201003L, and if the user defines __STDCPP_WANT_MATH_SPEC_FUNCS__ before including any standard library headers. (Yes, that's a lot of underscores. Yes, you have to get them exactly right. 🙈)

Implementations that don't support ISO 29124:2010 but do support TR 19768:2007 (TR1) provide this function in the header tr1/cmath and namespace std::tr1.

An implementation of this function is also available in boost.math. Options, bestie 🌸

Here's the part everyone skips but shouldn't: the additional overloads are not required to be provided exactly as (A). They only need to be sufficient to ensure that, for their first argument num1 and second argument num2:

• If num1 or num2 has type long double, then std::ellint2(num1, num2) has the same effect as std::ellint2(static_cast<long double>(num1), static_cast<long double>(num2)).
• Otherwise, if num1 and/or num2 has type double or an integer type, then std::ellint2(num1, num2) has the same effect as std::ellint2(static_cast<double>(num1), static_cast<double>(num2)). — (until C++23)
• Otherwise, if num1 or num2 has type float, then std::ellint2(num1, num2) has the same effect as std::ellint2(static_cast<float>(num1), static_cast<float>(num2)).

If num1 and num2 have arithmetic types, then std::ellint2(num1, num2) has the same effect as std::ellint2(static_cast</* common-floating-point-type */>(num1), static_cast</* common-floating-point-type */>(num2)), where /* common-floating-point-type */ is the floating-point type with the greatest floating-point conversion rank and greatest floating-point conversion subrank between the types of num1 and num2. (since C++23) — and arguments of integer type are considered to have the same floating-point conversion rank as double.

And the plot twist: if no such floating-point type with the greatest rank and subrank exists, then overload resolution does not result in a usable candidate from the overloads provided. 💀 Overload resolution said "not today."

---

🌸 EXAMPLE 🌸

// Run this code

#include <cmath>
#include <iostream>
#include <numbers>

int main()
{
    const double hpi = std::numbers::pi / 2.0;

    std::cout << "E(0,π/2)  = " << std::ellint_2(0, hpi) << '\n'
              << "E(0,-π/2) = " << std::ellint_2(0, -hpi) << '\n'
              << "π/2       = " << hpi << '\n'
              << "E(0.7,0)  = " << std::ellint_2(0.7, 0) << '\n'
              << "E(1,π/2)  = " << std::ellint_2(1, hpi) << '\n';
}

🍓 OUTPUT 🍓

E(0,π/2)  = 1.5708
E(0,-π/2) = -1.5708
π/2       = 1.5708
E(0.7,0)  = 0
E(1,π/2)  = 1

Look at that symmetry. The way E(0,π/2) and E(0,-π/2) are literally mirror images 😭 beautiful.

---

👑 SEE ALSO 👑

• comp_ellint_2
• comp_ellint_2f
• comp_ellint_2l — (complete) elliptic integral of the second kind, (function), (C++17), (C++17), (C++17)

Not me pointing you at the complete version when you came here for the incomplete one — but go off, they're siblings 🫶

---

🌈 EXTERNAL LINKS 🌈

Weisstein, Eric W. "Elliptic Integral of the Second Kind." From MathWorld — A Wolfram Web Resource.

---

That's the whole page, bestie. Source and version: http://cppreference.com, 2024.06.10, and the page signs off as std::ellint...d::ellint_2l(3) — go forth and integrate elliptically ✨💜