std::lerp

 

C++

Language

Standard Library Headers

Freestanding and hosted implementations

Named requirements

Language support library

Concepts library (C++20)

Diagnostics library

Utilities library

Strings library

Containers library

Iterators library

Ranges library (C++20)

Algorithms library

Numerics library

Input/output library

Localizations library

Regular expressions library (C++11)

Atomic operations library (C++11)

Thread support library (C++11)

Filesystem library (C++17)

Technical Specifications

 

Numerics library

Common mathematical functions

Special mathematical functions

Floating-point environment (C++11)

Complex numbers

Numeric arrays

Pseudo-random number generation

Compile-time rational arithmetic (C++11)

Numeric algorithms

gcd (C++17)

lcm (C++17)

Interpolations

midpoint (C++20)

lerp (C++20)

Generic numeric operations

iota (C++11)

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

bit_cast (C++20)

ispow2 (C++20)

ceil2 (C++20)

floor2 (C++20)

log2p1 (C++20)

 

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

1-3) Computes 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)

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.)