std::lerp

 

C++

Compiler support

Freestanding and hosted

Language

Standard library

Standard library headers

Named requirements

Feature test macros (C++20)

Language support library

Concepts library (C++20)

Metaprogramming library (C++11)

Diagnostics library

General utilities library

Strings library

Containers library

Iterators library

Ranges library (C++20)

Algorithms library

Numerics library

Localizations library

Input/output library

Filesystem library (C++17)

Regular expressions library (C++11)

Concurrency support library (C++11)

Execution support library (C++26)

Technical specifications

Symbols index

External libraries

 

Numerics library

Common mathematical functions
Mathematical special functions (C++17)
Mathematical constants (C++20)
Basic linear algebra algorithms (C++26)
Floating-point environment (C++11)
Complex numbers
Numeric array (valarray)
Pseudo-random number generation
Factor operations
gcd (C++17)	lcm (C++17)
Interpolations
midpoint (C++20)	lerp (C++20)
Saturation arithmetic
add_sat (C++26) sub_sat (C++26) saturate_cast (C++26)	mul_sat (C++26) div_sat (C++26)
Generic numeric operations
iota (C++11) ranges::iota (C++23) accumulate inner_product adjacent_difference partial_sum	reduce (C++17) transform_reduce (C++17) inclusive_scan (C++17) exclusive_scan (C++17) transform_inclusive_scan (C++17) transform_exclusive_scan (C++17)
Bit operations
has_single_bit (C++20)     bit_cast (C++20) bit_ceil (C++20) bit_floor (C++20) bit_width (C++20) rotl (C++20) rotr (C++20)	popcount (C++20) countl_zero (C++20) countl_one (C++20) countr_zero (C++20) countr_one (C++20) byteswap (C++23) endian (C++20)

 

Defined in header <cmath>
constexpr float       lerp( float a, float b, float t ) noexcept;	(1)	(since C++20)
constexpr double      lerp( double a, double b, double t ) noexcept;	(2)	(since C++20)
constexpr long double lerp( long double a, long double b, long double t ) noexcept;	(3)	(since C++20)
constexpr Promoted    lerp( Arithmetic1 a, Arithmetic2 b, Arithmetic3 t ) noexcept;	(4)	(since C++20)

1-3) Computes \(a+t(b−a)\)a+t(b−a), i.e. the linear interpolation between a and b for the parameter t (or extrapolation, when t is outside the range [0,1]).

4) A set of overloads or a function template for all combinations of arguments of arithmetic type not covered by 1-3). If any argument has integral type, it is cast to double. If any other argument is long double, then the return type is long double, otherwise it is double.

Parameters

a, b, t

-

values of floating-point or integral types

Return value

\(a+t(b−a)\)a+t(b−a)

When isfinite(a) && isfinite(b), the following properties are guaranteed:

• If t == 0, the result is equal to a.
• If t == 1, the result is equal to b.
• If t >= 0 && t <= 1, the result is finite.
• If isfinite(t) && a == b, the result is equal to a.
• If isfinite(t) || (!isnan(t) && b-a != 0), the result is not NaN.

Let CMP(x,y) be 1 if x > y, -1 if x < y, and 0 otherwise. For any t1 and t2, the product of CMP(lerp(a, b, t2), lerp(a, b, t1)), CMP(t2, t1), and CMP(b, a) is non-negative. (That is, lerp is monotonic.)

Notes

lerp is available in the global namespace when <math.h> is included, even if it is not a part of C.

Feature testing macro: __cpp_lib_interpolate.

Example

Run this code

#include <iostream>
#include <cmath>
 
int main()
{
    float a=10.0f, b=20.0f;
 
    std::cout << "a=" << a << ", " << "b=" << b << '\n'
              << "mid point=" << std::lerp(a,b,0.5f) << '\n'
              << std::boolalpha << (a == std::lerp(a,b,0.0f)) << ' '
              << std::boolalpha << (b == std::lerp(a,b,1.0f)) << '\n';
 
    for (float t{}; t <= 1.0f; t += 0.1f)
        std::cout << std::lerp(10.f, 20.f, t) << ' ';
    std::cout << '\n';
 
    for (double t{}; t <= 1.0; t += 0.1)
        std::cout << std::lerp(10., 20., t) << ' ';
    std::cout << '\n';
}

Output:

a=10, b=20
mid point=15
true true
10 11 12 13 14 15 16 17 18 19 
10 11 12 13 14 15 16 17 18 19 20

See also

midpoint (C++20)

midpoint between two numbers or pointers (function template)