Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://en.cppreference.com/w/cpp/language/../algorithm/../language/../numeric/lerp.html below:

std::lerp - cppreference.com

Computes the

between

and

, if the parameter

is inside

(the

otherwise), i.e. the result of

with accounting for floating-point calculation imprecision.

A) Additional overloads are provided for all other combinations of arithmetic types.

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

When std::isfinite(a) && std::isfinite(b) is true, 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 std::isfinite(t) && a == b, the result is equal to a.
• If std::isfinite(t) || (b - a != 0 && std::isinf(t)), 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(std::lerp(a, b, t2), std::lerp(a, b, t1)),
• CMP(t2, t1), and
• CMP(b, a)

is non-negative. (That is, std::lerp is monotonic.)

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, second argument num2 and third argument num3:

• If num1, num2 or num3 has type long double, then std::lerp(num1, num2, num3) has the same effect as std::lerp(static_cast<long double>(num1),
            static_cast<long double>(num2),
            static_cast<long double>(num3)).
• Otherwise, if num1, num2 and/or num3 has type double or an integer type, then std::lerp(num1, num2, num3) has the same effect as std::lerp(static_cast<double>(num1),
            static_cast<double>(num2),
            static_cast<double>(num3)).
• Otherwise, if num1, num2 or num3 has type float, then std::lerp(num1, num2, num3) has the same effect as std::lerp(static_cast<float>(num1),
            static_cast<float>(num2),
            static_cast<float>(num3)).

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

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.

#include <cassert>
#include <cmath>
#include <iostream>
 
float naive_lerp(float a, float b, float t)
{
    return a + t * (b - a);
}
 
int main()
{
    std::cout << std::boolalpha;
 
    const float a = 1e8f, b = 1.0f;
    const float midpoint = std::lerp(a, b, 0.5f);
 
    std::cout << "a = " << a << ", " << "b = " << b << '\n'
              << "midpoint = " << midpoint << '\n';
 
    std::cout << "std::lerp is exact: "
              << (a == std::lerp(a, b, 0.0f)) << ' '
              << (b == std::lerp(a, b, 1.0f)) << '\n';
 
    std::cout << "naive_lerp is exact: "
              << (a == naive_lerp(a, b, 0.0f)) << ' '
              << (b == naive_lerp(a, b, 1.0f)) << '\n';
 
    std::cout << "std::lerp(a, b, 1.0f) = " << std::lerp(a, b, 1.0f) << '\n'
              << "naive_lerp(a, b, 1.0f) = " << naive_lerp(a, b, 1.0f) << '\n';
 
    assert(not std::isnan(std::lerp(a, b, INFINITY))); // lerp here can be -inf
 
    std::cout << "Extrapolation demo, given std::lerp(5, 10, t):\n";
    for (auto t{-2.0}; t <= 2.0; t += 0.5)
        std::cout << std::lerp(5.0, 10.0, t) << ' ';
    std::cout << '\n';
}

Possible output:

a = 1e+08, b = 1
midpoint = 5e+07
std::lerp is exact?: true true
naive_lerp is exact?: true false
std::lerp(a, b, 1.0f) = 1
naive_lerp(a, b, 1.0f) = 0
Extrapolation demo, given std::lerp(5, 10, t):
-5 -2.5 0 2.5 5 7.5 10 12.5 15

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4