blocks|key|1783420|text|忽略精度上的差异，该表达式等同于|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1783421|float+lerp(float+a,+float+b,+float+f)
{
++++return+a+%2B+f+*+(b+-+a);
}|code-block|syntax|javascript|1783422|这是2个加法/减法和1个乘法，而不是2个加法/减法和2个乘法。|1783423|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Disregarding differences in precision, that expression is equivalent to

<pre class="lang-cpp prettyprint-override"><code>float lerp(float a, float b, float f)
{
 return a + f * (b - a);
}
</code></pre>

That's 2 additions/subtractions and 1 multiplication instead of 2 addition/subtractions and 2 multiplications.

blocks|key|1783446|text|如果您正在为不带浮点操作的微控制器编写代码，那么最好不要使用浮点数，而是使用fixed-point+arithmetic。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1783447|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Fixed-point_arithmetic^0|12|M|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

If you're coding for a microcontroller without floating-point operations, then it's better not to use floating-point numbers at all, and to use <a href="http://en.wikipedia.org/wiki/Fixed-point_arithmetic" rel="nofollow">fixed-point arithmetic</a> instead.

blocks|key|1997182|text|如果您希望最终结果是一个整数，那么使用整数作为输入可能会更快。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1997183|int+lerp_int(int+a,+int+b,+float+f)
{
++++//float+diff+=+(float)(b-a);
++++//float+frac+=+f*diff;
++++//return+a+%2B+(int)frac;
++++return+a+%2B+(int)(f+*+(float)(b-a));
}|code-block|syntax|javascript|1997184|这会进行两次强制转换和一次浮点相乘。如果强制转换在您的平台上比浮点加/减更快，并且整数答案对您有用，那么这可能是一个合理的替代方案。|1997185|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

If you want to the final result to be an integer, it might be faster to use integers for the input as well.

<pre class="lang-cpp prettyprint-override"><code>int lerp_int(int a, int b, float f)
{
 //float diff = (float)(b-a);
 //float frac = f*diff;
 //return a + (int)frac;
 return a + (int)(f * (float)(b-a));
}
</code></pre>

This does two casts and one float multiply. If a cast is faster than a float add/subtract on your platform, and if an integer answer is useful to you, this might be a reasonable alternative.

blocks|key|1997532|text|如果你在一个没有FPU的微控制器上，那么浮点运算将会非常昂贵。对于浮点运算来说，很容易就会慢20倍。最快的解决方案是使用整数来完成所有的数学运算。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1997533|固定二进制点(http://blog.credland.net/2013/09/binary-fixed-point-explanation.html?q=fixed%2Bbinary%2Bpoint)后的位数是:+XY_TABLE_FRAC_BITS。|offset|length|1997534|下面是我使用的一个函数：|1997535|inline+uint16_t+unsignedInterpolate(uint16_t+a,+uint16_t+b,+uint16_t+position)+{
++++uint32_t+r1;
++++uint16_t+r2;

++++/*+
+++++*+Only+one+multiply,+and+one+divide/shift+right.++Shame+about+having+to
+++++*+cast+to+long+int+and+back+again.
+++++*/

++++r1+=+(uint32_t)+position+*+(b-a);
++++r2+=+(r1+>>+XY_TABLE_FRAC_BITS)+%2B+a;
++++return+r2;++++
}|code-block|syntax|javascript|1997536|使用内联函数，它应该是近似的。10-20个周期。|1997537|如果你有一个32位微控制器，你将能够使用更大的整数，并在不影响性能的情况下获得更大的数字或更高的精度。此函数用于16位系统。|1997538|entityMap|0|LINK|mutability|MUTABLE|url|http://blog.credland.net/2013/09/binary-fixed-point-explanation.html?q=fixed%2Bbinary%2Bpoint^0|0|7|2H|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Z|8|@]|9|@$D|10|E|11|1|12]]|A|$]]|$1|F|3|G|5|6|7|13|8|@]|9|@]|A|$]]|$1|H|3|I|5|J|7|14|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|15|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|16|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|17|8|@]|9|@]|A|$]]]|R|$S|$5|T|U|V|A|$W|X]]]]

If you are on a micro-controller without an FPU then floating point is going to be very expensive. Could easily be twenty times slower for a floating point operation. The fastest solution is to just do all the math using integers. 

The number of places after the fixed binary point (<a href="http://blog.credland.net/2013/09/binary-fixed-point-explanation.html?q=fixed+binary+point" rel="nofollow noreferrer">http://blog.credland.net/2013/09/binary-fixed-point-explanation.html?q=fixed+binary+point</a>) is: XY_TABLE_FRAC_BITS. 

Here's a function I use: 

<pre class="lang-c prettyprint-override"><code>inline uint16_t unsignedInterpolate(uint16_t a, uint16_t b, uint16_t position) {
 uint32_t r1;
 uint16_t r2;

 /* 
 * Only one multiply, and one divide/shift right. Shame about having to
 * cast to long int and back again.
 */

 r1 = (uint32_t) position * (b-a);
 r2 = (r1 &gt;&gt; XY_TABLE_FRAC_BITS) + a;
 return r2; 
}
</code></pre>

With the function inlined it should be approx. 10-20 cycles. 

If you've got a 32-bit micro-controller you'll be able to use bigger integers and get larger numbers or more accuracy without compromising performance. This function was used on a 16-bit system.

blocks|key|1997749|text|值得注意的是，标准线性插值公式f1(t)=a%2Bt(b-a)，f2(t)=b-(b-a)(1-t)和f3(t)=a(1-t)%2Bbt不能保证在使用浮点运算时表现良好。也就是说，如果a+!=+b，则不保证f1(1.0)+==+b或f2(0.0)+==+a，而对于==+b，当0|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1997750|这个函数适用于我在支持IEEE754浮点的处理器上，当我需要结果表现良好并准确命中端点时(我使用双精度，但浮点也应该有效)：|1997751|
|1997752|double+lerp(double+a,+double+b,+double+t)+
{
++++if+(t+<=+0.5)
++++++++return+a%2B(b-a)*t;
++++else
++++++++return+b-(b-a)*(1.0-t);
}|code-block|syntax|javascript|1997753|1997754|1997755|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|Q|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|R|8|@]|9|@]|A|$I|J]]|$1|K|3|E|5|6|7|S|8|@]|9|@]|A|$]]|$1|L|3|-4|5|6|7|T|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|U|8|@]|9|@]|A|$]]]|N|$]]

It is worth to note, that the standard linear interpolation formulas f1(t)=a+t(b-a), f2(t)=b-(b-a)(1-t), and f3(t)=a(1-t)+bt do not guarantee to be well-behaved when using floating point arithmetic.
Namely, if a != b, it is not guaranteed that the f1(1.0) == b or that f2(0.0) == a, while for a == b, f3(t) is not guaranteed to be equal to a, when 0 &lt; t &lt; 1.
This function has worked for me on processors that support IEEE754 floating point when I need the results to behave well and to hit the endpoints exactly (I use it with double precision, but float should work as well):
<pre><code>double lerp(double a, double b, double t) 
{
 if (t &lt;= 0.5)
 return a+(b-a)*t;
 else
 return b-(b-a)*(1.0-t);
}
</code></pre>

blocks|key|1997870|text|既然有了C%2B%2B20，你就可以使用std::lerp()，这可能是你的目标最好的实现。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1997871|entityMap|0|LINK|mutability|MUTABLE|url|https://en.cppreference.com/w/cpp/numeric/lerp^0|G|B|G|B|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@$9|O|A|P|B|C]]|D|@$9|Q|A|R|1|S]]|E|$]]|$1|F|3|-4|5|6|7|T|8|@]|D|@]|E|$]]]|G|$H|$5|I|J|K|E|$L|M]]]]

Since C++20 you can use <a href="https://en.cppreference.com/w/cpp/numeric/lerp" rel="nofollow noreferrer"><code>std::lerp()</code></a>, which is likely to be the best possible implementation for your target.

To do a linear interpolation between two variables <code>a</code> and <code>b</code> given a fraction <code>f</code>, I'm currently using this code:

<pre><code>float lerp(float a, float b, float f) 
{
 return (a * (1.0 - f)) + (b * f);
}
</code></pre>

I think there's probably a more efficient way of doing it. I'm using a microcontroller without an FPU, so floating point operations are done in software. They are reasonably fast, but it's still something like 100 cycles to add or multiply.

Any suggestions?

n.b. for the sake of clarity in the equation in the code above, we can omit specifying <code>1.0</code> as an explicit floating-point literal.

Floating point linear interpolation

微控制器

为了在给定分数f的情况下在两个变量a和b之间进行线性插值，我目前使用以下代码：float lerp(float a, float b, float f) {    return (a * (1.0 - f)) + (b * f);}我认为可能有一种更有效的方法。我使用的是没有FPU的微控制器，所以浮点运算是在软件中完成...

问浮点线性插值
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问浮点线性插值EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问浮点线性插值
EN