[新手上路]批处理新手入门导读[视频教程]批处理基础视频教程[视频教程]VBS基础视频教程[批处理精品]批处理版照片整理器
[批处理精品]纯批处理备份&还原驱动[批处理精品]CMD命令50条不能说的秘密[在线下载]第三方命令行工具[在线帮助]VBScript / JScript 在线参考
返回列表 发帖
happy886rr

帖子
961 
积分
2350 
技术
334  
捐助
0  
注册时间
2016-3-7 
1楼 跳转到 » 倒序看帖
打印
tT
发表于 2017-2-1 02:47 | 只看该作者

FPU_MATH.H双精度数学库

本帖最后由 happy886rr 于 2017-2-1 02:56 编辑

发现FPU指令集速度惊人，比直接调用math.h计算快一倍，因此查阅了intel的技术文档，对该指令集做了内联封装，成为单一头文件，直接include就可使用。也弥补了VS编译器没有双曲函数系的通病。部分函数实现的很仓促，如有疏漏，在所难免。FPU指令集版权归intel所有，本人只做封装，个别数学函数做了粗糙的实现，但精度分毫不差，后续将推出超double类型即 super double型的新型数学库，采用混合数据压缩技术，届时将支持万位精度。
摘要：
=============================================================================
FPU双精度数学库。即FPU指令集内联汇编。比MATH.H速度快一倍。部分函数实现仅凭
数学定义、未做严密测试，若有计算出入，请自行完善。
=============================================================================

用法：
-----------------------------------------------------------------------------
#include "FPU_MATH.H"
-----------------------------------------------------------------------------

备注：需CPU支持FPU浮点加速指令，传入传出均为double型。

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
常数类
        FPU_PI    3.1415926535897932
        FPU_E     2.7182818284590452       

通用类
        FPU_random随机数
        FPU_round 四舍五入
        FPU_ceil  向上舍入
        FPU_floor 向下舍入
        FPU_abs   绝对值
        FPU_sqrt  开方
        FPU_log10    常用对数，以10为底
        FPU_log2   2底对数
        FPU_log    自然对数
        FPU_exp   e的次幂
        FPU_torad 度转弧度

三角函数类
        FPU_sin、FPU_cos、FPU_tan   
        FPU_arcsin、FPU_arccos、FPU_arctan

双曲函数类
        FPU_sinh、FPU_cosh、FPU_tanh
        FPU_arcsinh、FPU_arccosh、FPU_arctanh

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
2017-02-01


FPU_MATH.H源码。仅单一头文件，方便调用。
  1. /*

  2.         FPU_MATH.H COPYRIGHT@2017~2019 BY HAPPY

  3. */

  4. 

  5. //常数定义

  6. #define FPU_PI 3.1415926535897932

  7. #define FPU_E  2.7182818284590452

  8. 

  9. //正弦函数

  10. double FPU_sin(double x)

  11. {

  12. 	double FPU_RET;                     

  13. 	__asm__                     

  14. 	(                           

  15. 		"fsin\n"              

  16. 		: "=t" (FPU_RET)    

  17. 		: "0"  (x)          

  18. 	);

  19. 	return FPU_RET;

  20. }

  21. 

  22. //余弦函数

  23. double FPU_cos(double x) 

  24. {                      

  25. 	double FPU_RET;

  26. 	__asm__                     

  27. 	(                           

  28. 		"fcos\n"              

  29. 		: "=t" (FPU_RET)    

  30. 		: "0"  (x)          

  31. 	);

  32. 	return FPU_RET;

  33. }

  34. 

  35. //正切函数

  36. double FPU_tan(double x) 

  37. {                      

  38. 	double FPU_RET, FPU_VAL;

  39. 	__asm__                     

  40. 	(                           

  41. 		"fptan\n"             

  42. 		: "=t" (FPU_VAL),   

  43. 		  "=u" (FPU_RET)    

  44. 		: "0"  (x)          

  45. 	);

  46. 	return FPU_RET;

  47. }

  48. 

  49. //ABS函数

  50. double FPU_fabs(double x) 

  51. {                       

  52. 	double FPU_RET;

  53. 	__asm__                     

  54. 	(                           

  55. 		"fabs\n"              

  56. 		: "=t" (FPU_RET)    

  57. 		: "0"  (x)          

  58. 	);

  59. 	return FPU_RET;

  60. }

  61. 

  62. //自然对数

  63. double FPU_log2(double x)

  64. {                    

  65. 	double FPU_RET;

  66. 	__asm__                     

  67. 	(                           

  68. 		"fld1\n"          

  69. 		"fxch\n"            

  70. 		"fyl2x\n"           

  71. 		: "=t" (FPU_RET)    

  72. 		: "0"  (x)          

  73. 	);

  74. 	return FPU_RET;

  75. }

  76. 

  77. //自然对数

  78. double FPU_log(double x) 

  79. {                    

  80. 	double FPU_RET;

  81. 	__asm__                     

  82. 	(                           

  83. 		"fldln2\n"          

  84. 		"fxch\n"            

  85. 		"fyl2x\n"           

  86. 		: "=t" (FPU_RET)    

  87. 		: "0"  (x)          

  88. 	);

  89. 	return FPU_RET;

  90. }

  91. 

  92. //常用对数

  93. double FPU_log10(double x) 

  94. {                    

  95. 	double FPU_RET;

  96. 	__asm__                     

  97. 	(                           

  98. 		"fldlg2\n"          

  99. 		"fxch\n"            

  100. 		"fyl2x\n"           

  101. 		: "=t" (FPU_RET)    

  102. 		: "0"  (x)          

  103. 	);

  104. 	return FPU_RET;

  105. }

  106. 

  107. //开方函数

  108. double FPU_sqrt(double x) 

  109. {                     

  110. 	double FPU_RET;

  111. 	__asm__                     

  112. 	(                           

  113. 		"fsqrt\n"           

  114. 		: "=t" (FPU_RET)    

  115. 		: "0"  (x)          

  116. 	);

  117. 	return FPU_RET;

  118. }

  119. 

  120. //EXP函数

  121. double FPU_exp(double x) 

  122. {

  123. 	double FPU_RET, FPU_VAL;

  124. 	__asm__                     

  125. 	(                           

  126. 		"fldl2e\n"          

  127. 		"fmul %%st(1)\n"    

  128. 		"fst   %%st(1)\n"  

  129. 		"frndint\n"         

  130. 		"fxch;\n"         

  131. 		"fsub %%st(1)\n"    

  132. 		"f2xm1\n"           

  133. 		: "=t" (FPU_RET), "=u" (FPU_VAL)

  134. 		: "0" (x)           

  135. 		);                  

  136. 		FPU_RET+= 1.0f;    

  137. 	__asm__                     

  138. 	(                           

  139. 		"fscale\n"          

  140. 		: "=t" (FPU_RET)    

  141. 		: "0" (FPU_RET), "u" (FPU_VAL)

  142. 	);

  143. 	return FPU_RET;

  144. }

  145. 

  146. //次方函数

  147. double FPU_pow(double x, double y)

  148. {

  149. 	double FPU_RET, FPU_VAL;

  150. 	double FPU_RES=1.0f;

  151. 	int FPU_INT=(int)y;

  152. 	if (x==0.0 && y >0.0){return 0.0;}

  153. 	if (y==(double)FPU_INT){

  154. 		if(FPU_INT==0){return 1.0;}

  155. 		if(FPU_INT <0){FPU_INT=-FPU_INT, x=1.0/x;}

  156. 		while(1){

  157. 			if(FPU_INT&1){FPU_RES*=x;}

  158. 			FPU_INT>>=1;

  159. 			if(FPU_INT==0){return FPU_RES;}

  160. 			x*=x;

  161. 		}

  162. 	}

  163. 	__asm__

  164. 	(

  165. 		"fmul %%st(1)\n"

  166. 		"fst  %%st(1)\n"

  167. 		"frndint;\n"

  168. 		"fxch;\n"

  169. 		"fsub %%st(1);\n"

  170. 		"f2xm1;\n"

  171. 		: "=t" (FPU_RET), "=u" (FPU_VAL) 

  172. 		: "0"  (FPU_log2(x)), "1" (y)

  173. 	);

  174. 	FPU_RET+=1.0;

  175. 	__asm__

  176. 	(

  177. 		"fscale"

  178. 		: "=t" (FPU_RET) 

  179. 		: "0" (FPU_RET), "u" (FPU_VAL)	

  180. 	);

  181. 	return FPU_RET;

  182. }

  183. 

  184. //四舍五入

  185. double FPU_round(double x)

  186. {

  187. 	return (x<=0)?(float)((int)(x-0.5)):(float)((int)(x+0.5));

  188. }

  189. 

  190. //向下取整

  191. double FPU_floor(double x)

  192. {

  193. 	return (x<0)?(float)((int)x)-1:(float)((int)x);

  194. }

  195. 

  196. //向上取整

  197. double FPU_ceil(double x)

  198. {

  199. 	return (x<=0)?(float)((int)x):(float)((int)x)+1;

  200. }

  201. 

  202. //双目反正切

  203. double FPU_atan2(double x, double y) 

  204. { 

  205. 	double FPU_RET;

  206. 	__asm__                     

  207. 	(                           

  208. 		"fpatan\n"          

  209. 		"fld %%st(0)"     

  210. 		: "=t" (FPU_RET)  

  211. 		: "0" (y), "u" (x)  

  212. 	);

  213. 	return FPU_RET;

  214. }

  215. 

  216. //反正弦函数

  217. double FPU_asin(double x)

  218. {

  219. 	return FPU_atan2(x,FPU_sqrt(1.0-x*x));

  220. }

  221. 

  222. //反余弦函数

  223. double FPU_acos(double x)

  224. {

  225. 	return FPU_atan2(FPU_sqrt(1.0-x*x), x);

  226. }

  227. 

  228. //反正切函数

  229. double FPU_atan(double x) 

  230. {                      

  231. 	return FPU_atan2(x,1.0f);

  232. }

  233. 

  234. //双曲正弦函数

  235. double FPU_sinh(double x)

  236. {                     

  237. 	return (FPU_exp(x)-FPU_exp(-x))/2;

  238. }

  239. 

  240. //双曲余弦函数

  241. double FPU_cosh(double x) 

  242. {                    

  243. 	return (FPU_exp(x)+FPU_exp(-x))/2;

  244. }

  245. 

  246. //双曲正切函数

  247. double FPU_tanh(double x) 

  248. {                     

  249. 	return (FPU_exp(x)-FPU_exp(-x))/(FPU_exp(x)+FPU_exp(-x));

  250. }

  251. 

  252. //反双曲正弦函数

  253. double FPU_asinh(double x)

  254. {                     

  255. 	return FPU_log(x+FPU_sqrt(x*x+1));

  256. }

  257. 

  258. //反双曲余弦函数

  259. double FPU_acosh(double x) 

  260. {                    

  261. 	return FPU_log(x+FPU_sqrt(x*x-1));

  262. }

  263. 

  264. //反双曲正切函数

  265. double FPU_atanh(double x) 

  266. {                     

  267. 	return FPU_log((1+x)/(1-x))/2;

  268. }

  269. 

  270. //度转弧度

  271. double FPU_torad(double x) 

  272. {

  273. 	return x*FPU_PI/180;

  274. }

  275. 

  276. //随机数函数

  277. double FPU_random(double x) 

  278. {

  279. 	return (x<2)?rand()%8192/8192.0:rand()%(int)(x);

  280. }
复制代码
收藏 分享

B魔方大人

Rank: 1

帖子
35 
积分
61 
技术
4  
捐助
0  
注册时间
2015-11-7 
2楼
发表于 2017-2-1 18:46 | 只看该作者
如果使用math.h
优化的时候启用SSE试试如何!

TOP

返回列表