 # Vdsp(bf561)中的浮点运算（11）：fract16与float的转换

### 时间：2015/5/19 21:37:27 作者：平凡之路　来源：xuhantao.com 浏览： vdsp提供了两个函数用以实现fract16与float之间的相互转换：

```fract16 float_to_fr16 (float _x); float fr16_to_float (fract16 _x);```

1.1 float_to_fr16

```/*************************************************************************** * * Function:　 FLOAT_TO_FR16 -- Convert a floating-point value to a fract16 * * Synopsis: * *　　　　　　 #include <fract2float_conv.h> *　　　　　　 fract16 float_to_fr16(float x); * * Description: * *　　　　　　 The float_to_fr16 function converts a single precision, 32-bit IEEE *　　　　　　 value into a fract16 number in 1.15 notation. Floating-point values *　　　　　　 that cannot be converted to fract15 notation are handled as follows: * *　　　　　　　　　　 Return 0x7fffffff if x >= 1.0 or　 NaN or +Inf *　　　　　　　　　　 Return 0x80000000 if x < -1.0 or -NaN or -Inf *　　　　　　　　　　 Return 0　　　　　　　　　 if fabs(x) < 3.0517578125e-5 * *　　　　　　 (Note that the IEEE single precision, 32-bit, representation *　　　　　　 contains 24 bits of precision, made up of a hidden bit and 23 *　　　　　　 bits of mantissa, and thus some precision may be lost by converting *　　　　　　 a float to a fract16). * * Algorithm: * *　　　　　　 The traditional　algorithm to convert a floating-point value to 1.15 *　　　　　　 fractional　notation is: * *　　　　　　　　　　 (fract16) (x * 32768.0) * *　　　　　　 However on Blackfin, floating-point multiplication is relatively *　　　　　　 slow is emulated in software, and this basic algorithm does not *　　　　　　 handle out of range results. * *　　　　　　 This implementation is based on the support routine that converts *　　　　　　 a float to fract32, and then converts the fract32 into a fract16 *　　　　　　 by performing an arithmetic right shift by 16 bits. (It is possible *　　　　　　 to avoid the shift by coding the function to "multiply" the input *　　　　　　 input argument by 2^15 (rather than 2^31) but this approach can lead *　　　　　　 to the loss of 1-bit precision when handling negative inputs). * *　　　　　　 The following is a C implementation of this function and is about *　　　　　　 a third slower: #include <fract2float_conv.h> extern fract16 float_to_fr16(float x) { int temp; fract32 result; temp = *(int *)(&x); if ((temp & 0x7f800000) >= 0x3f800000) { result = 0x7fffffff; if (temp < 0) result = 0x80000000; } else { temp = temp + 0x0f800000; result = *(float *)(&temp); } return (result >> 16); } * *　　　　　　 WARNING: This algorithm assumes that the floating-point number *　　　　　　 representation is conformant with IEEE. * * Cycle Counts: * *　　　　　　 31 cycles when the result is within range *　　　　　　 30 cycles when the result is out of range *　　　　　　 28 cycles when the input is 0.0 * *　　　　　　 These cycle counts were measured using the BF532 cycle accurate *　　　　　　 simulator and include the overheads involved in calling the function *　　　　　　 as well　as the costs associated with argument passing. * * Code Size: * *　　　　　　 76 bytes * * Registers Used: * *　　　　　　 R0 - the input argument *　　　　　　 R1 - various constants *　　　　　　 R2 - the exponent of the input argument or a shift amount *　　　　　　 R3 - the mantissa of the input argument * * (c) Copyright 2006 Analog Devices, Inc.　 All　rights reserved. *　　　　 \$Revision: 1.3 \$ * ***************************************************************************/```

l　当输入值>=1、为nan或者为inf时

l　当输入值<-1或者为-inf时

l　范围内的值

1.2 fr16_to_float

```/*************************************************************************** * * Function:　 FR16_TO_FLOAT -- Convert a fract16 to a floating-point value * * Synopsis: * *　　　　　　 #include <fract2float_conv.h> *　　　　　　 float fr16_to_float(fract16 x); * * Description: * *　　　　　　 The fr16_to_float converts a fixed-point, 16-bit fractional　number *　　　　　　 in 1.15 notation into a single precision, 32-bit IEEE floating-point *　　　　　　 value; no precision is lost during the conversion. * * Algorithm: * *　　　　　　 The traditional　algorithm to convert a 1.15 fractional　numbers to *　　　　　　 floating-point value is: * *　　　　　　　　　　 (float)(x) / 32768.0 * *　　　　　　 However on Blackfin, floating-point division is relatively slow, *　　　　　　 and one can alternatively adapt the algorithm for converting from *　　　　　　 a short int to a float and then subtracting 15 from the exponent *　　　　　　 to simulate a division by 32768.0. * *　　　　　　 The following is a slower C implementation of this function: #include <fract2float_conv.h> extern float fr16_to_float(fract16 x) { float result = fabsf(x); int *presult = (int *)(&result); if (result != 0.0) { *presult = *ptemp - 0x07800000; if (x < 0) result = -result; } return result; } * *　　　　　　 WARNING: This algorithm assumes that the floating-point number *　　　　　　 representation is conformant with IEEE. * * Cycle Counts: * *　　　　　　 22 cycles when the input is 0 *　　　　　　 25 cycles for all　other input * *　　　　　　 These cycle counts were measured using the BF532 cycle accurate *　　　　　　 simulator and include the overheads involved in calling the function *　　　　　　 as well　as the costs associated with argument passing. * * Code Size: * *　　　　　　 38 bytes * * Registers Used: * *　　　　　　 R0 - the input argument and result *　　　　　　 R1 - various *　　　　　　 R2 - various * * (c) Copyright 2006 Analog Devices, Inc.　 All　rights reserved. *　　　　 \$Revision: 1.2 \$ * ***************************************************************************/```

1.3 fract16常量赋值

vdsp虽然没有将fract16当成内置类型，但是对于常量，编译器还是网开一面，使用r16或者r32后缀，编译器会自动将这个常量正确转换为fract16类型，如

fract16 r = 0.2r16;

1.4 不幸的事件

```float r; fract16 r1 = 0.2r16; r = r1;```

Fract的其它运算也一样，务必通过函数调用来完成。

• 没有相关文章
###### 共有评论 0 条相关评论 ###### 发表我的评论                              • 大名：
• 内容：
• 部分内容来自网络，如有侵权请联系站长尽快处理 站长QQ:965898558(广告及站内业务受理) 网站备案号：蒙ICP备15000590号-1