Namespaces
Variants

std:: lerp

From cppreference.net
C++
Numerics library
Определено в заголовочном файле <cmath>
(1)
constexpr float lerp ( float a, float b, float t ) noexcept ;

constexpr double lerp ( double a, double b, double t ) noexcept ;
constexpr long double lerp ( long double a, long double b,

long double t ) noexcept ;
(начиная с C++20)
(до C++23)
constexpr /* floating-point-type */

lerp ( /* floating-point-type */ a,
/* floating-point-type */ b,

/* floating-point-type */ t ) noexcept ;
(начиная с C++23)
Определено в заголовочном файле <cmath>
template < class Arithmetic1, class Arithmetic2, class Arithmetic3 >

constexpr /* common-floating-point-type */

lerp ( Arithmetic1 a, Arithmetic2 b, Arithmetic3 t ) noexcept ;
(A) (начиная с C++20)
1) Вычисляет линейную интерполяцию между a и b , если параметр t находится внутри [ ​ 0 ​ , 1 ) ( линейную экстраполяцию в противном случае), т.е. результат a+t(b−a) с учётом погрешности вычислений с плавающей точкой. Библиотека предоставляет перегрузки для всех cv-неквалифицированных типов с плавающей точкой в качестве типа параметров a , b и t . (начиная с C++23)
A) Дополнительные перегрузки предоставляются для всех остальных комбинаций арифметических типов.

Содержание

Параметры

a, b, t - значения с плавающей точкой или целочисленные значения

Возвращаемое значение

a + t(b − a)

Когда std:: isfinite ( a ) && std:: isfinite ( b ) имеет значение true , гарантируются следующие свойства:

  • Если t == 0 , результат равен a .
  • Если t == 1 , результат равен b .
  • Если t >= 0 && t <= 1 , результат конечен.
  • Если std:: isfinite ( t ) && a == b , результат равен a .
  • Если std:: isfinite ( t ) || ( b - a ! = 0 && std:: isinf ( t ) ) , результат не является NaN .

Пусть CMP ( x, y ) будет равно 1 если x > y , - 1 если x < y , и ​ 0 ​ в противном случае. Для любых t1 и t2 произведение

  • CMP ( std :: lerp ( a, b, t2 ) , std :: lerp ( a, b, t1 ) ) ,
  • CMP ( t2, t1 ) , и
  • CMP ( b, a )

неотрицательно. (То есть, std::lerp является монотонной.)

Примечания

Дополнительные перегрузки не обязаны быть предоставлены в точности как (A) . Они должны быть лишь достаточными для обеспечения того, чтобы для их первого аргумента num1 , второго аргумента num2 и третьего аргумента num3 :

  • Если num1 , num2 или num3 имеет тип long double , тогда std :: lerp ( num1, num2, num3 ) имеет тот же эффект, что и std :: lerp ( static_cast < long double > ( num1 ) ,
    static_cast < long double > ( num2 ) ,
    static_cast < long double > ( num3 ) )     .
  • В противном случае, если num1 , num2 и/или num3 имеет тип double или целочисленный тип, тогда std :: lerp ( num1, num2, num3 ) имеет тот же эффект, что и std :: lerp ( static_cast < double > ( num1 ) ,
    static_cast < double > ( num2 ) ,
    static_cast < double > ( num3 ) )     .
  • В противном случае, если num1 , num2 или num3 имеет тип float , тогда std :: lerp ( num1, num2, num3 ) имеет тот же эффект, что и std :: lerp ( static_cast < float > ( num1 ) ,
    static_cast < float > ( num2 ) ,
    static_cast < float > ( num3 ) )     .
(до C++23)

Если num1 , num2 и num3 имеют арифметические типы, то std :: lerp ( num1, num2, num3 ) имеет тот же эффект, что и std :: lerp ( static_cast < /*common-floating-point-type*/ > ( num1 ) ,
static_cast < /*common-floating-point-type*/ > ( num2 ) ,
static_cast < /*common-floating-point-type*/ > ( num3 ) ) , где /*common-floating-point-type*/ - это тип с плавающей запятой с наибольшим рангом преобразования с плавающей запятой и наибольшим подрангом преобразования с плавающей запятой среди типов num1 , num2 и num3 , при этом аргументы целочисленного типа считаются имеющими тот же ранг преобразования с плавающей запятой, что и double .

Если такого типа с плавающей запятой с наибольшим рангом и подрангом не существует, то разрешение перегрузки не приводит к пригодному кандидату из предоставленных перегрузок.

(начиная с C++23)
Макрос тестирования возможностей Значение Стандарт Возможность
__cpp_lib_interpolate 201902L (C++20) std::lerp , std::midpoint

Пример

Запустить этот код 
#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 здесь может быть -inf
    std::cout << "Демонстрация экстраполяции, задано 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';
}

Возможный вывод: 

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

Смотрите также

(C++20)
середина между двумя числами или указателями
(шаблон функции)