查表法比计算要快多少？

最新推荐文章于 2024-04-26 00:30:00 发布
最新推荐文章于 2024-04-26 00:30:00 发布
阅读量770 收藏
点赞数
分类专栏： Java程序设计 性能测试
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-NC-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43145361/article/details/106406850
版权

目标与结论

本文通过对sin不同角度的值分别进行计算和查表操作，以比较两者的性能差距。根据实验结果，使用sin进行直接计算每秒能完成1万次，而查表每秒可进行300万次，相差巨大。同时还需要注意一点，sin在计算的时候，如果是在 2 π 2\pi 2π以内的，可以效率要高于其他范围的值，因为其他值还需要进行一个取余操作，使其落在 2 π 2\pi 2π以内，而浮点型的取余计算相对要耗时，所以导致性能会有明显的差异。

过程

36000000 / 3600 = 10000 每秒约1万次 sin 计算，查表每秒可以进行300万次。根据 Java内存性能测试的结果，内存读写大约5百万次左右，与本次测试结果基本一致。

以下是测试数据和代码。

---------------------------------
Table.length = 36000000, sum(table) = -0.1235.
test0: 361 ms, test1: 3944 ms, test2: 371 ms.
Pure time: test1 = 3583 ms, test2 = 10 ms, test1/test2 = 358.30.
---------------------------------
Table.length = 36000000, sum(table) = -0.1235.
test0: 360 ms, test1: 3947 ms, test2: 372 ms.
Pure time: test1 = 3587 ms, test2 = 12 ms, test1/test2 = 298.92.
---------------------------------
Table.length = 36000000, sum(table) = -0.1235.
test0: 362 ms, test1: 3964 ms, test2: 374 ms.
Pure time: test1 = 3602 ms, test2 = 12 ms, test1/test2 = 300.17.
---------------------------------
Table.length = 36000000, sum(table) = -0.1235.
test0: 359 ms, test1: 3959 ms, test2: 373 ms.
Pure time: test1 = 3600 ms, test2 = 14 ms, test1/test2 = 257.14.
---------------------------------
Table.length = 36000000, sum(table) = -0.1235.
test0: 359 ms, test1: 3942 ms, test2: 371 ms.
Pure time: test1 = 3583 ms, test2 = 12 ms, test1/test2 = 298.58.
---------------------------------
Table.length = 36000000, sum(table) = -0.1235.
test0: 363 ms, test1: 3952 ms, test2: 372 ms.
Pure time: test1 = 3589 ms, test2 = 9 ms, test1/test2 = 398.78.
---------------------------------
Table.length = 36000000, sum(table) = -0.1235.
test0: 362 ms, test1: 4019 ms, test2: 402 ms.
Pure time: test1 = 3657 ms, test2 = 40 ms, test1/test2 = 91.43.
---------------------------------
Table.length = 36000000, sum(table) = -0.1235.
test0: 386 ms, test1: 3959 ms, test2: 372 ms.
Pure time: test1 = 3573 ms, test2 = -14 ms, test1/test2 = -255.21.
---------------------------------
Table.length = 36000000, sum(table) = -0.1235.
test0: 359 ms, test1: 4167 ms, test2: 375 ms.
Pure time: test1 = 3808 ms, test2 = 16 ms, test1/test2 = 238.00.
---------------------------------
Table.length = 36000000, sum(table) = -0.1235.
test0: 359 ms, test1: 4068 ms, test2: 387 ms.
Pure time: test1 = 3709 ms, test2 = 28 ms, test1/test2 = 132.46.

public class TrigonometricTest {
	static double delta = 0.00001 * Math.PI / 180;
	static int len = 0;

	public static void main(String[] args) {
		for (int i = 0; i < 10; i++)
			test();
	}

	public static void test() {
		System.out.println("---------------------------------");
		len = (int) (2 * Math.PI / delta);
		var table = generateTable();
		int loops = 10;
		double r = 0;

		// warm up
		for (int i = 0; i < 2; i++) {
			test0();
			r = test1(r);
			r = test2(table, r);
		}

		// start real test
		long t0 = System.nanoTime();
		for (int i = 0; i < loops; i++)
			test0();
		long t1 = System.nanoTime();
		for (int i = 0; i < loops; i++)
			r = test1(r);
		long t2 = System.nanoTime();
		for (int i = 0; i < loops; i++)
			r = test2(table, r);
		long t3 = System.nanoTime();

		long t_empty = (t1 - t0) / 1000000;
		long t_test1 = (t2 - t1) / 1000000;
		long t_test2 = (t3 - t2) / 1000000;

		System.out.printf("Table.length = %d, sum(table) = %.4f.\n", table.length, r);
		System.out.printf("test0: %d ms, test1: %d ms, test2: %d ms.\n", t_empty, t_test1, t_test2);
		System.out.printf("Pure time: test1 = %d ms, test2 = %d ms, test1/test2 = %.2f.\n", t_test1 - t_empty,
				t_test2 - t_empty, 1.0 * (t_test1 - t_empty) / (t_test2 - t_empty));
	}

	public static double test0() {
		double p = 0;
		for (int i = 0; i < len; i++)
			p += delta;
		return p;
	}

	public static double test1(double r) {
		double p = 0;
		for (int i = 0; i < len; i++) {
			r += Math.sin(p);
			p += delta;
		}
		return r;
	}

	public static double test2(double[] table, double r) {
		for (int i = 0; i < table.length; i++)
			r += table[i];
		return r;
	}

	public static double[] generateTable() {
		double[] table = new double[len];
		for (int i = 0; i < table.length; i++)
			table[i] = Math.sin(i * delta);
		return table;
	}

}


package tests;

public class TrigonometricTest {
	static double delta = 0.0001 * Math.PI / 180;
	static int len = 0;
	static int totalRuns = 100;

	public static void main(String[] args) {
		for (int i = 0; i < 10; i++)
			test();
	}



	public static void Test1() {
		len = (int) (2 * Math.PI / delta);
		var table = generateTable();
		double r = 0;
		// warm up
		for (int i = 0; i < 2; i++) {
			test0();
			r = test1(r);
			r = test2(table, r);
		}

		// start real test
		long t0 = System.nanoTime();
		test0();
		long t1 = System.nanoTime();
		r = test1(r);
		long t2 = System.nanoTime(); 

		double totalTimes = len * totalRuns;
		double t_loop = (t1 - t0) / 1000000.0;
		double t_test1 = (t2 - t1) / 1000000.0; 
		double diff = t_test1 - t_loop;
		double speed = totalTimes / diff;

		System.out.printf("----\ntotal runs = %.0f, sum = %.4f.\n", totalTimes, r);
		System.out.printf("test0: %.4f ms, test1: %.4f ms\ndiff = %.4f, speed: %.0f Times/ms.\n", t_loop, t_test1, diff, speed); 
	}

	public static void test() {
		len = (int) (2 * Math.PI / delta);
		var table = generateTable();
		System.out.println("---------------------------------");
		System.out.printf("table.length: %.2E, len = %.2E.\n", 1.0 * table.length, 1.0 * len);
		double r = 0;
		// warm up
		for (int i = 0; i < 2; i++) {
			test0();
			r = test1(r);
			r = test2(table, r);
		}

		// start real test
		long t0 = System.nanoTime();
		test0();
		long t1 = System.nanoTime();
		r = test1(r);
		long t2 = System.nanoTime();
		r = test2(table, r);
		long t3 = System.nanoTime();

		double totalTimes = len * totalRuns;
		long t_empty = (t1 - t0) / 1000000;
		long t_test1 = (t2 - t1) / 1000000;
		long t_test2 = (t3 - t2) / 1000000;

		System.out.printf("totalTimes = %.2E, sum(table) = %.4f.\n", totalTimes, r);
		System.out.printf("test0: %d ms, test1: %d ms, test2: %d ms.\n", t_empty, t_test1, t_test2);
		System.out.printf("Pure time: test1 = %d ms, test2 = %d ms, test1/test2 = %.2f.\n", t_test1 - t_empty,
				t_test2 - t_empty, 1.0 * (t_test1 - t_empty) / (t_test2 - t_empty));
	}

	public static double test0() {
		double p = 0;
		for (int runTimes = 0; runTimes < totalRuns; runTimes++)
			for (int i = 0; i < len; i++)
				p += delta;
		return p;
	}

	public static double test1(double r) {
		double p = 0;
		for (int runTimes = 0; runTimes < totalRuns; runTimes++)
			for (int i = 0; i < len; i++) {
				r += Math.sin(p);
				p += delta;
			}
		return r;
	}

	public static double test2(double[] table, double r) {
		for (int runTimes = 0; runTimes < totalRuns; runTimes++)
			for (int i = 0; i < table.length; i++)
				r += table[i];
		return r;
	}

	public static double[] generateTable() {
		double[] table = new double[len];
		for (int i = 0; i < table.length; i++)
			table[i] = Math.sin(i * delta);
		return table;
	}

}
郝伟博士
关注
专栏目录
程序加速之查表法
superguang9527的专栏
08-27 2934
查表法是通常采用的一种以空间（内存空间）换时间（运行时间）的程序加速方法，基本过程是把需要经常查询数据库或复杂浮点计算的结果保存到一个数据结构中（数组最为常见），以后只要根据条件取出相应的数据即可。比如把1-360度的正切值保存到数组中，当输入45度时，只需取出第45个元素。这样就节约了不必要的计算时间。对于作为基本定义使用的表，数据不经常改变的数据表也可以使用这种方法。注意:1.表的数据
CRC--CRC8的查表法及直接计算法
CLL的博客
10-19 652
CRC创建表，及直接计算和查表计算
RGB2GRAY 各种算法速度比较，整形乘法比查表法快！
weixin_30457065的博客
05-27 165
1. 查表法，外循环用 这种格式 ： //for(int j = 0; j != h; ++j)// for(int i = 0; i!=w;++i)//、 for(int j = 0; j != h; ++j) for(int i = 0; i!=w;++i) { int r,g,b,y,r1,g1,b1,y1; r = D[in[of3]];//查表 //这里...
计算机找表格,查找表
weixin_29505425的博客
07-27 194
在计算机科学中，查找表是用简单的查询操作替换运行时计算的数组或者 associative array 这样的数据结构。中文名查找表学科在计算机科学中特点用简单的查询操作类型数据结构查找表原理语音由于从内存中提取数值经常要比复杂的计算速度快很多，所以这样得到的速度提升是很显著的。一个经典的例子就是三角表。每次计算所需的正弦值在一些应用中可能会慢得无法忍受，为了避免这种情况，应...
查表法和计算2种方法求CRC校验码
04-01
代码附有注释，可以直接使用VC6.0等工具编译。具体理解可以参照Modbus_over_serial_line_V1_02.pdf文档，百度文库有下。
单片机C语言查表法实现arctan arcsin 反正切 反正弦计算（不使用库函数）
03-18
采用优化的单片机查表法计算atan角度的方法，重点解决了几个问题： （1）且用asin曲线计算代替难以描述的atan曲线，快速开方函数 （2）全部采用整形运算，加快了运算速度，返回的角度范围是0~360.00，包含4个象限，输出角度值 （3）asin曲线使用了一半的曲线，解决了asin邻近90度时十分陡峭的难题。本代码稍微加以修改也可以作为asin和acos的计算。
电机控制DSP高效算法——1、正余弦
匠心独蕴
12-12 200
【代码】电机控制DSP高效算法——1、正余弦
crc查表快还是逐位计算快
05-31
从速度上来看，使用查表法比逐位计算法更快一些，因为使用查表法可以预先计算好所有可能的CRC值，然后直接查表即可，而逐位计算法需要逐位计算每个字节的值，这个过程比较耗时。但是，使用查表法需要占用额外的内存...
城门洞形断面隧洞临界水深度的近似算法 (2004年)
04-25
城门洞形断面是输水隧洞工程中一种经常采用的过水断面形式。其临界水深方程是含未知参数的超越方程,数学上无解析解。常见计算方法有图解法或迭代试算法。...该法比现行的查图查表法、迭代试算法更简捷、更精确。
有关方差分析的所有
Siemer的博客
03-07 2105
不是所有也会慢慢补充 方差分析，又称 F检验。 借助于方差，对数据误差来源进行分析，从而检验多个母体平均数是否相等，也就是判断均值之间是否有差异。 **单因素方差分析：**众多因素中只有一个因素的水平有多个，其余因素只有一个水平。 **多因素方差分析：**多个因素有多个水平。 一、要清楚的基本概念 **指标：**试验结果称为指标，一般表示为数值，用X表示。 **因素（因子）：**试验中需要考察的可以控制的条件。用A,B,C表示。 **水平：因素所处的状态，一般用A1、A2、A3、…Ar**表示。一般将因子控
《高性能JavaScript》读书笔记
沈鸿斌的博客
03-20 1212
1.加载和运行 1.把标签放在尽可能接近标签底部的位置 因为浏览器在遇到标签之前,不会渲染页面的任何部分。 2.减少标签总数 Yahoo! 为他的“Yahoo! 用户接口(Yahoo! User Interface,YUI)”库创建一个“联合句柄”,这是通过他们的“内容投递网络(Content Delivery Network,CDN)”实现的。任何一个网站
MATLAB基础应用精讲-【数模应用】方差分析（最终篇）（附python代码）
最新发布
qq_36130719的博客
04-26 221
方差分析（）又称“变异数分析”或“F检验”，是由罗纳德·费舍尔（Ronald Aylmer Fisher）发明的，用于两个及两个以上样本均数差别的显著性检验，其原理是认为不同处理组的均数间的差别基本来源有两个：(1) 实验条件，即不同的处理造成的差异，称为组间差异。用变量在各组的均值与总均值之偏差平方和的总和表示，记作SSa，组间自由度dfa。(2) 随机误差，如测量误差造成的差异或个体间的差异，称为组内差异，用变量在各组的均值与该组内变量值之偏差平方和的总和表示， 记作SSe，组内自由度dfe。
C语言优化实例：C代码优化的必修课——查表
chfe910的专栏
05-11 5538
如果某些运算频繁地进行，可以提前保存该运算所有可能的结果，之后当需要用到该运算的时候，直接通过查表获取结果即可。这种方法对时间性能优化特别有效，但是时间性能和空间性能总是一对矛盾的存在体，这样做是以牺牲空间性能为代价的，这是因为我们需要保存运算所有可能的结果。 举例如下： 还是这个例子： for (int i = 0; i {      sum += data[i/1000][i%
C语言知识：C标准库函数深度解读（三）
weixin_56154577的博客
04-02 854
三角函数（sin(), cos(), tan()）：现代编译器和运行时库通常使用查表法与多项式插值、CORDIC算法或快速傅里叶变换（FFT）等高效算法实现。对于小角度，查表法与插值能提供极高精度且快速；对于大角度，可以先将其转换到 [-π, π] 范围内，再进行计算。
DSP程序优化方法
左超
09-14 3596
1、选择合适的算法和数据结构     选择一种合适的数据结构很重要，如果在一堆随机存放的数中使用了大量的插入和删除指令，那使用链表要快得多。数组与指针语句具有十分密切的关系，一般来说，指针比较灵活简洁，而数组则比较直观，容易理解。对于大部分的编译器，使用指针比使用数组生成的代码更短，执行效率更高。     在许多种情况下，可以用指针运算代替数组索引，这样做常常能产生又快又短的代码。与数组索引相比，
C语言正余弦函数定点查表算法原理及实现
热门推荐
主要分享硬件、嵌入式软件部分知识
04-24 1万+
如果用数学库中的sin和cos函数计算，可能涉及浮点、乘法、除法运算，运行速率较低。这里介绍一种正余弦查表算法。 参考代码：SMT32 FOC电机库的mc_math.c。 首先我们知道正弦和余弦的函数值差了90°，所以查表数据只需要保存正弦或者余弦的结果即可。待计算的角度范围为[0,2π]，我们只需要保存的角度，其它象限的角度通过三角函数公式变换一下即可。 （1）正余弦表格生成 第一步当然是保存范围内正余弦函数的值，保存的越多计算结果越精确，但又消耗更多的存储空间。在STM32电机库中采用int16.
c,python,java,octave，golang，julia编程计算十万次，一百万次，一千万次sinx，比较效率
qq_44420246的博客
10-29 2302
使用python计算sin(3.14)，循环不同次数，计算时间： 1 循环十万次： import math import time start = time.time() for i in range(100000): y = math.sin(3.14) end = time.time() print("耗时{0}".format(end-start)) # print(y) ...
实现一个基于c语言的sin查找表，查找范围为[0 - 2*pi]
taiyangshenniao的专栏
09-18 6529
1、制作一张查找表； 查找表的制作范围可以定义范围为【0-pi/2】;或者【0-pi】；根据个人实现的功能和复杂度来自己确定，范围制作范围越广，程序代码越简单 下面是一张制作范围为【0-pi/2】的sin查找表的matlab程序 2、生成表格后写c语言程序 说到底查找表就是将不同区间映射到已存在的查找表区间上
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值