home | help 
std::lerp(3)		       C++ Standard Libary		    std::lerp(3)

NAME
     std::lerp - std::lerp

Synopsis
	Defined in header <cmath>
	constexpr float       lerp( float a, float b, float t )
	noexcept;

	constexpr   double	  lerp(   double   a,	double	b,  double  t  )
     (since C++20)
	noexcept;
     (until C++23)
	constexpr long double lerp( long double a, long double b,

				    long double t ) noexcept;
	constexpr /* floating-point-type */

	    lerp(	  /*	     floating-point-type	  */	      a,
     (since C++23)
		  /* floating-point-type */ b,			       (1)

		  /* floating-point-type */ t ) noexcept;
	Additional overloads
	Defined in header <cmath>
	template< class Arithmetic1, class Arithmetic2, class
	Arithmetic3 >

	constexpr  /*  common-floating-point-type */			     (A)
     (since C++20)

	    lerp( Arithmetic1 a, Arithmetic2 b, Arithmetic3 t )
	noexcept;

	1) Computes the linear interpolation between a and b, if the parameter t
     is inside
	[0,  1)  (the  linear  extrapolation  otherwise),  i.e.  the  result  of
     \(a+t(baa)\)a+t(baa)
	with accounting for floating-point calculation imprecision.
	The  library  provides	overloads  for all cv-unqualified floating-point
     types as the
	type of the parameters a, b and t.
	(since C++23)
	A) Additional overloads are  provided  for  all  other	combinations  of
     arithmetic types.

Parameters
	a, b, t - floating-point or integer values

Return value
	\(a + t(b a a)\)a + t(b a a)

	When std::isfinite(a) && std::isfinite(b) is true, the following proper-
     ties 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.)

Notes
	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, sec-
     ond 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),
     (until C++23)
		      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
     (since C++23)
	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.

	 Feature-test macro    Value	Std	      Feature
	__cpp_lib_interpolate 201902L (C++20) std::lerp, std::midpoint

Example
     // Run this code

      #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

See also
	midpoint midpoint between two numbers or pointers
	(C++20)  (function template)

http://cppreference.com 	   2024.06.10			    std::lerp(3)
home | help