# std::lerp

From cppreference.com
< cpp‎ | numeric

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

### Examples

| This section is incomplete Reason: no example

Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/numeric/lerp&oldid=109963"