测试算法对比

最新推荐文章于 2022-08-10 14:30:43 发布
原创 最新推荐文章于 2022-08-10 14:30:43 发布 · 814 阅读 · 4 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文对比了STM32F103C8T6芯片上不同开方、正余弦及反正切函数的实现效率，包括自定义算法与库函数。通过代码大小和执行时间分析，探讨了各种算法的优劣。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

测试条件：

开发环境：keil4

芯片信号：STM32F103C8T6

主频：64MHZ

开方函数

1、测试math_temp1 = SquareRootFloat(5.0f);

float SquareRootFloat(float number)

{

   long i;

   float x, y;

   const float f = 1.5F;

 

    x= number * 0.5F;

   y  = number;

   i  = * ( long * ) &y;                      // evil floating point bit level hacking

   i  = 0x5f3759df - ( i >> 1);  //¿¨Âí¿Ë

 //i  = 0x5f375a86 - ( i >> 1);  //Lomont

   y  = * ( float * ) &i;

   y  = y * ( f - ( x * y * y ) ); //1st iteration

   y  = y * ( f - ( x * y * y ) ); //2nd iteration, this can be removed

   return number * y;

}

含有math_temp1 =SquareRootFloat(5.0f);代码大小如下：

Program Size: Code=25296 RO-data=1016 RW-data=572ZI-data=1564 

不含math_temp1 =SquareRootFloat(5.0f); 代码大小如下：

Program Size:Code=24764 RO-data=1012 RW-data=564 ZI-data=1052 

math_temp1 =SquareRootFloat(5.0f);代码占：532byte

执行时间：13us；执行结果：math_temp1 = 2.236068

2、测试math_temp1 = sqrt(5.0f);//函数库自带的开根号函数

含有math_temp1 =sqrt(5.0f);代码大小如下：

Program Size: Code=25080 RO-data=1016 RW-data=564ZI-data=1052    

不含math_temp1 =sqrt(5.0f); 代码大小如下：

Program Size:Code=24764 RO-data=1012 RW-data=564 ZI-data=1052 

math_temp1 = sqrt(5.0f);代码占：216byte

执行时间：41us；执行结果：math_temp1 = 2.236068

3、测试math_temp1 = _sqrt(5.0f);//函数库自带的开根号函数

含有math_temp1 =_sqrt(5.0f);代码大小如下：

Program Size: Code=25084 RO-data=1012 RW-data=564ZI-data=1052      

不含math_temp1 =_sqrt(5.0f); 代码大小如下：

Program Size:Code=24764 RO-data=1012 RW-data=564 ZI-data=1052 

math_temp1 = _sqrt(5.0f);代码占：220byte

执行时间：44us；执行结果：math_temp1 = 2.236068

Atan函数

1、  测试math_temp1 =utils_fast_atan2(6.0f, 2.0f);//非查表

floatutils_fast_atan2(float y, float x) {

float abs_y = fabsf(y) + 1e-10; // kludge toprevent 0/0 condition

float angle;

 

if (x >= 0) {

           float r = (x - abs_y) / (x + abs_y);

           float rsq = r * r;

           angle = ((0.1963 * rsq) - 0.9817) * r+ (M_PI / 4.0);

} else {

           float r = (x + abs_y) / (abs_y - x);

           float rsq = r * r;

           angle = ((0.1963 * rsq) - 0.9817) * r+ (3.0 * M_PI / 4.0);

}

 

if (y < 0) {

           return(-angle);

} else {

           return(angle);

}

}

含有math_temp1 =utils_fast_atan2(6.0f, 2.0f);代码大小如下：

         ProgramSize: Code=26144 RO-data=1016 RW-data=1600 ZI-data=1560 

不含math_temp1 =utils_fast_atan2(6.0f, 2.0f);代码大小如下：

Program Size:Code=24764 RO-data=1012 RW-data=564 ZI-data=1052 

math_temp1 =utils_fast_atan2(6.0f, 2.0f);代码占：1380byte

执行时间：32us；执行结果：math_temp1 = -0.000002

2、  测试math_temp1 = fast_atan2(6.0f,2.0f);//查表算法

REALfast_atan2(REAL y, REAL x)

{

REAL x_abs, y_abs, z;

REAL alpha, angle, base_angle;

int index;

 

/* don't divide by zero! */

if ((y == 0.0f) || (x == 0.0f))//if ((y ==0.0f) && (x == 0.0f))

           angle = 0.0f;

else

{

           /* normalize to +/- 45 degree range*/

           y_abs = my_abs(y);

           x_abs = my_abs(x);

           //z = (y_abs < x_abs ? y_abs /x_abs : x_abs / y_abs);

           if (y_abs < x_abs)

                    z = y_abs / x_abs;

           else

                    z = x_abs / y_abs;

           /* when ratio approaches the tableresolution, the angle is */

           /*      best approximated with the argumentitself...       */

           if (z < TAN_MAP_RES)

                    base_angle = z;

           else

           {

                    /* find index andinterpolation value */

                    alpha = z * (REAL)TAN_MAP_SIZE - .5f;

                    index = (int) alpha;

                    alpha -= (REAL) index;

                    /* determine base anglebased on quadrant and */

                    /* add or subtract tablevalue from base angle based on quadrant */

                    base_angle =fast_atan_table[index];

                    base_angle +=(fast_atan_table[index + 1] - fast_atan_table[index]) * alpha;

           }

 

           if (x_abs > y_abs)

           {        /* -45 -> 45 or 135 -> 225 */

                    if (x >= 0.0f)

                    {           /* -45 -> 45 */

                             if (y >= 0.0f)

                                       angle =base_angle;   /* 0 -> 45, angle OK */

                             else

                                       angle = -base_angle;  /* -45 -> 0, angle = -angle */

                    }

                    else

                    {                  /* 135 -> 180 or 180 ->-135 */

                             angle =3.14159265358979323846;

 

                             if (y >= 0.0f)

                                       angle -=base_angle;  /* 135 -> 180, angle =180 - angle */

                             else

                                       angle = base_angle- angle;   /* 180 -> -135, angle =angle - 180 */

                    }

           }

           else

           {                    /* 45 -> 135 or -135-> -45 */

                    if (y >= 0.0f)

                    {           /* 45 -> 135 */

                             angle =1.57079632679489661923;

 

                             if (x >= 0.0f)

                                       angle -=base_angle;  /* 45 -> 90, angle = 90 -angle */

                             else

                                       angle +=base_angle;  /* 90 -> 135, angle = 90+ angle */

                    }

                    else

                    {                  /* -135 -> -45 */

                             angle =-1.57079632679489661923;

 

                             if (x >= 0.0f)

                                       angle +=base_angle;  /* -90 -> -45, angle =-90 + angle */

                             else

                                       angle -=base_angle;  /* -135 -> -90, angle =-90 - angle */

                    }

           }

}

 

 

#ifdefZERO_TO_TWOPI

if (angle < 0)

           return (angle + TWOPI);

else

           return (angle);

#else

return (angle);

#endif

}

含有math_temp1 =fast_atan2(6.0f, 2.0f);代码大小如下：

Program Size: Code=26144 RO-data=1016 RW-data=1600ZI-data=1560 

不含math_temp1 =fast_atan2(6.0f, 2.0f);代码大小如下：

Program Size:Code=24764 RO-data=1012 RW-data=564 ZI-data=1052 

math_temp1 = fast_atan2(6.0f,2.0f);代码占：1380byte

执行时间：22us；执行结果：math_temp1 = 1.249635

3、  测试math_temp1 = atan2f(6.0f, 2.0f);//函数库带有的

含有math_temp1 =atan2f(6.0f, 2.0f);代码大小如下：

Program Size: Code=25620 RO-data=1012 RW-data=564ZI-data=1052 

不含math_temp1 =atan2f(6.0f, 2.0f);代码大小如下：

Program Size:Code=24764 RO-data=1012 RW-data=564 ZI-data=1052 

math_temp1 = atan2f(6.0f, 2.0f);代码占：856byte

执行时间：22us；执行结果：math_temp1 = 1.249046

 

正余弦函数

1、测试正余弦函数utils_fast_sincos_better(2.0f,&s,&c);//本杰明

voidutils_fast_sincos_better(float angle, float *sin, float *cos) {

//always wrap input angle to -PI..PI

while (angle < -M_PI) {

           angle += 2.0 * M_PI;

}

 

while (angle >  M_PI) {

           angle -= 2.0 * M_PI;

}

 

//compute sine

if (angle < 0.0) {

           *sin = 1.27323954 * angle +0.405284735 * angle * angle;

 

           if (*sin < 0.0) {

                    *sin = 0.225 * (*sin * -*sin- *sin) + *sin;

           } else {

                    *sin = 0.225 * (*sin * *sin- *sin) + *sin;

           }

} else {

           *sin = 1.27323954 * angle -0.405284735 * angle * angle;

 

           if (*sin < 0.0) {

                    *sin = 0.225 * (*sin * -*sin- *sin) + *sin;

           } else {

                    *sin = 0.225 * (*sin * *sin- *sin) + *sin;

           }

}

 

// compute cosine: sin(x + PI/2) = cos(x)

angle += 0.5 * M_PI;

if (angle > M_PI) {

           angle -= 2.0 * M_PI;

}

 

if (angle < 0.0) {

           *cos = 1.27323954 * angle +0.405284735 * angle * angle;

 

           if (*cos < 0.0) {

                    *cos = 0.225 * (*cos * -*cos- *cos) + *cos;

           } else {

                    *cos = 0.225 * (*cos * *cos- *cos) + *cos;

           }

} else {

           *cos = 1.27323954 * angle -0.405284735 * angle * angle;

 

           if (*cos < 0.0) {

                    *cos = 0.225 * (*cos * -*cos- *cos) + *cos;

           } else {

                    *cos = 0.225 * (*cos * *cos- *cos) + *cos;

           }

}

}

含有utils_fast_sincos_better(2.0f,&s,&c);代码大小

Program Size: Code=28100 RO-data=1012 RW-data=1608ZI-data=1560 

不含utils_fast_sincos_better(2.0f,&s,&c);代码大小

Program Size: Code=24768 RO-data=1016 RW-data=572ZI-data=1052 

utils_fast_sincos_better(2.0f,&s,&c);代码占：3332byte

执行时间：87us；执行结果：s = 0.9097958；c = -0.4157479

 

2、测试s = my_sin(2.0f);c = my_cos(2.0f);//匿名飞控

#define ONE_PI   (3.14159265)

#define TWO_PI   (2.0 * 3.14159265)

#define ANGLE_UNIT (TWO_PI/10.0)

double mx_sin(double rad)

{  

         doublesine;

         if(rad < 0)

                   sine= rad*(1.27323954f + 0.405284735f * rad);

         else

                   sine= rad * (1.27323954f - 0.405284735f * rad);

         if(sine < 0)

                   sine= sine*(-0.225f * (sine + 1) + 1);

         else

                   sine= sine * (0.225f *( sine - 1) + 1);

         returnsine;

}

 

double my_sin(double rad)

{

         s8flag = 1;

 

         if(rad >= ONE_PI)

         {

                   rad-= ONE_PI;

                   flag= -1;

         }

 

         returnmx_sin(rad) * flag;

}

 

float my_cos(double rad)

{

         s8flag = 1;

         rad+= ONE_PI/2.0;

 

         if(rad >= ONE_PI)

         {

                   flag= -1;

                   rad-= ONE_PI;

         }

 

         returnmy_sin(rad)*flag;

}

含有s = my_sin(2.0f);c =my_cos(2.0f);代码大小

Program Size:Code=28120 RO-data=1016 RW-data=1608 ZI-data=1560 

不含s = my_sin(2.0f);c =my_cos(2.0f); 代码大小

Program Size:Code=24768 RO-data=1016 RW-data=572 ZI-data=1052

s = my_sin(2.0f);c =my_cos(2.0f); 代码占：3352byte

执行时间：95us；执行结果：s = 0.9097958；c = -0.4157479

 

3、测试s = sinf(2.0f);c = cosf(2.0f);//库函数带有

含有s = sinf(2.0f);c =cosf(2.0f);代码大小

Program Size: Code=26292 RO-data=1044 RW-data=572ZI-data=1052 

不含s = sinf(2.0f);c =cosf(2.0f); 代码大小

Program Size: Code=24768 RO-data=1016 RW-data=572ZI-data=1052

s = sinf(2.0f);c = cosf(2.0f);代码占：1524byte

执行时间：43us；执行结果：s = 0.9092974；c = -0.4161468

 

 

 

 

 

 

 

 

OpenCV学习：理解fastAtan2函数
MwgmPhilosophy的博客
09-19 654
函数是OpenCV中用于计算给定点角度的快速函数。在计算机视觉和图像处理领域，OpenCV是一个非常流行的开源库，它提供了许多用于处理图像和视频的函数和工具。函数的实现基于查表法（lookup table），它通过查表的方式快速计算反正切值。但是在实际应用中，通常会限制坐标的范围，以便满足特定的需求。它返回的是从x轴正方向到该点的射线与x轴正方向之间的夹角的弧度值。函数的参数是浮点数类型，因此在使用该函数之前，需要确保输入的坐标值已经转换为浮点数。函数的用法和原理，并提供相应的源代码示例。
OpenCV学习：fastAtan2函数解密
honpey爱编程
06-04 8822
高中数学中各种正弦函数，余弦函数总是把人搞得头大，但是具体应用时你会发现，其实你只需要搞清楚一个2π空间内函数分布即可。下面分析OpenCV中fastAtan2函数是怎么处理的方向问题。 fastAtan2函数在OpenCV中用户非常广，比如在SIFT描述子求取过程中需要计算特征点的方向，此时OpenCV的源码中就是使用的fastAtan2函数，fastAtan2函数原型如下： float
随机森林算法4种实现方法对比测试：DolphinDB速度最快，XGBoost表现最差
cpongo011702
07-23 922
随机森林是常用的机器学习算法，既可以用于分类问题，也可用于回归问题。本文对scikit-learn、Spark MLlib、DolphinDB、XGBoost四个平台的随机森林算法实现进行对比测试。评价指标包括内存占用、运行速度和分类准确性。本次测试使用模拟生成的数据作为输入进行二分类训练，并用生成的模型对模拟数据进行预测。1.测试软件本次测试使用的各平台版本如下：scikit-learn：Pyt...
重拾算法(5)——最小生成树的两种算法及其对比测试
weixin_33835690的博客
08-01 179
重拾算法(5)——最小生成树的两种算法及其对比测试 什么是最小生成树 求解最小生成树(Minimum Cost Spanning Tree，以下简写做MST）是图相关的算法中常见的一个，用于解决类似如下的问题： 假设要在N个城市之间建立通信联络网，那么连通N个城市只需N-1条线路。这时自然会考虑这样一个问题：如何在最节省经费的前提下建立这个通信网。 在任意两个城市间都可以设置一条线路，相...
目标检测算法汇总比较
热门推荐
别说话写代码的博客
10-16 1万+
作者：金天 链接：https://zhuanlan.zhihu.com/p/39579528 来源：知乎 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。 很难衡量一个检测算法的好坏，因为除了算法本身的思路之外，还有许多因素影响它的速度和精度，比如： 特征提取网络(VGG, ResNet, Inception, MobileNet); 输出的步长，越大分类数目越多，相...
EMOresults.tar.gz_多目标_多目标对比_测试函数对比_算法对比_算法测试对比
07-14
"EMOresults.tar.gz" 是一个包含多目标优化算法测试结果的压缩文件，它提供了不同算法在特定多目标测试函数上的表现对比。这个压缩包里的子文件以 ".dat" 结尾，可能存储了各种算法在不同测试函数上的运行数据，例如...
灰狼算法、鲸鱼算法与人工蜂群算法的CEC21测试函数对比及测试环境说明
最新发布
08-13
灰狼算法、鲸鱼算法和人工蜂群算法在MATLAB中的应用，并通过CEC21测试函数对其性能进行了全面对比。首先，文章分别阐述了三种算法的基本原理和应用场景，接着在相同的测试环境中（相同种群数量和迭代次数），利用CEC...
经典函数.rar_quiteg5v_测试函数_算法函数测试_算法对比测试_算法测试函数
07-15
经典的测试函数，可用于算法的测试，对比算法的性能，具有很大的作用。
乌燕优化算法23种测试函数对比
07-14
每种函数都具有独特的挑战，测试算法在局部最小值和全局最小值识别、收敛速度和计算效率等方面的能力。 乌燕优化算法的核心机制包括以下几个步骤：随机初始化乌鸦的位置（解决方案），然后根据乌燕间的距离和食物...
late chunking 文本分块算法对比测试代码
06-12
此外，文本分块算法的对比测试不仅限于late chunking，还包括其他算法，如基于规则的分块算法、基于机器学习的分块算法等。通过这样的测试，可以全面评估各种方法在实际应用中的适用性和效率，进而为开发者和研究...
检测算法对比_测试
JullyZ
05-02 574
不同检测算法误检率、漏检率、检测时间对比测试： void main() { DetectTask* d_task = NewDetectTaskInstance(60,"pico"); //给facedeletedll就是facedeletedll算法，根据参数，有不同的分配算法 FileSupport file; std::string root = "D:\\project\\we
如何对算法进行测试？
manok的专栏
03-13 5852
1、正确性；一个好的算法必需能够正确的执行要求的功能和性能要求。这要求我们对一个算法进行功能测试和性能测试。&#13; 2、可用性；一个好的算法能够很方便的使用。测试算法是否具有良好的界面、完备的文档。要求算法的输入和输出都良好的接口，一个算法只完成一个特定的功能与其它模块的藕合尽量少。&#13; 3、可读性；一个好的算法应该具有很好的可读性。这样有利于理解、测试。要测试算...
算法测试及对比度进一步增强
weixin_30266829的博客
11-13 105
今天在测试相似度算法的过程中，出现了一些问题，比如 ('预付卡怎么设置\n', '预付卡 设置', '预付卡怎么设置\n', '预付卡 设置', 1.029370301661967)('预付卡怎么设置\n', '预付卡 设置', '怎么使用购物卡\n', '使用 购物卡', 0.59755888783038)('预付卡怎么设置\n', '预付卡 设置', '购物卡怎么办理\n', '购物卡 办理...
对一些常见的排序算法进行演算测试，对比效率。（JAVA 实现）
卖画的作家
05-02 449
大三下了，正在找实习，把一些常用的排序算法重新复习一遍，同时简单的比较了一下各个算法的效率，总的来说，快排效率最高，冒泡效率最低。-----具体的排序算法包括：直接插入排序、折半插入排序、Shell排序（插入排序） 冒泡、快速排序（交换排序）欢迎大家一起讨论，如有错误务必指出~~~先验证排序算法的正确性：接着比较效率（注释掉了打印数组的功能）：得出结论：当待排数的数量较大时（示例中采用102400...
软件测试中如何测试算法？
软件自动化测试技术交流、资源分享
08-10 7703
广义的算法是指解决问题的方案,小到求解数学题,大到制定商业策略,都可以叫做算法。而我们 今天讨论的软件测试中的算法,对应的英文单词为Algorithm ,专指计算机处理复杂问题的程序或 指令。
用于比较分类算法的统计测试
orDream的博客
03-11 2156
用于比较分类算法的统计测试 回顾开创性的论文和实施，以发现适合您的数据的最佳选择 对大多数数据科学家来说，比较预测方法以确定哪种方法应该用于手头的任务是一项日常活动。通常，我们会有一个分类模型库，并使用交叉验证来验证它们，以确定哪一个是最好的。 然而，另一个目标不是比较分类器，而是比较学习算法本身。其想法是：给定这个任务（数据），哪种学习算法（KNN、SVM、随机森林等）将在大小为D的数据集上生成更准确的分类器？ 正如我们将看到的，这里介绍的每种方法都有一些优点和缺点。然而，使用两个比例测试的第一直觉可能会
查找算法的实现及性能测试与比较
Rikkaの博客
11-23 1689
查找算法的实现及性能测试与比较 问题描述 在顺序线性表中存放n个整数，n的值由用户输入确定，线性表可以是有序表或无序表。比较各查找算法在不同情况下的时间性能。 各查找算法的实测时间性能包括两个指标：算法执行的绝对时间和关键字的平均比较次数。 各查找算法要求评测查找成功与不成功的两种情形。 为了能比较出各种查找算法执行的绝对时间，需要对表中的数据进行较大量的查找，设为m次，m的值也由用户输入确定。当输入m为1000000时，则对线性表作1000000次查找。 （1）比较在有序表和无序表中进行顺序查找时，查找成
算法测试之实践与小结
蝉之洞
12-10 1万+
因项目需要，我从上半年开始接触算法测试。本文主要对于算法测试的类型和方法这里做一下总结。在项目中，所接触算法测试的类型主要包括如下图所示的几个方面 一，算法模型 根据之前的调研，在测试阶段，对于新采用的算法模型，比如协同过滤，机器学习算法等的测试，很多项目上只是回归下功能和流程，不对具体的算法模型进行评测；一般会通过线上或者灰度发布的推荐效果来评测算法模型。 那么，在测试阶段有没有什么方...
测试算法方法
weixin_30437337的博客
01-08 677
测试时间的方法： Stopwatch sw = new Stopwatch(); sw.Start(); //启动计时 //编写代码执行被测试的算法 sw.Stop();//停止计时 //获取算法执行时间 long UsedTime = sw.ElapsedMilliseconds; //... 转载于:https://www.cnblogs.com/...
多种优化算法对比测试与性能分析
资源摘要信息:"HPO（Hyperparameter Optimization，超参数优化）、GWO（Grey Wolf ...优化算法函数测试是对这四种优化算法进行测试，通过编写测试函数，比较不同算法在相同问题上的优化效果，从而评估算法的性能。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值