设为首页收藏本站
切换到宽版

 找回密码
 注册
搜索
批处理之家»论坛 › 批处理专区: BAT CMD DOS › 开源原创工具 › FPU_MATH.H双精度数学库
[新手上路]批处理新手入门导读[视频教程]批处理基础视频教程[视频教程]VBS基础视频教程[批处理精品]批处理版照片整理器
[批处理精品]纯批处理备份&还原驱动[批处理精品]CMD命令50条不能说的秘密[在线下载]第三方命令行工具[在线帮助]VBScript / JScript 在线参考
返回列表 发新帖
查看: 9640|回复: 1

FPU_MATH.H双精度数学库

[复制链接]
happy886rr
发表于 2017-2-1 02:47:09 | 显示全部楼层 |阅读模式
本帖最后由 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源码。仅单一头文件，方便调用。

  2. /*
  3.         FPU_MATH.H COPYRIGHT@2017~2019 BY HAPPY
  4. */

  6. //常数定义
  7. #define FPU_PI 3.1415926535897932
  8. #define FPU_E  2.7182818284590452

  10. //正弦函数
  11. double FPU_sin(double x)
  12. {
  13.         double FPU_RET;                     
  14.         __asm__                     
  15.         (                           
  16.                 "fsin\n"              
  17.                 : "=t" (FPU_RET)   
  18.                 : "0"  (x)         
  19.         );
  20.         return FPU_RET;
  21. }

  23. //余弦函数
  24. double FPU_cos(double x)
  25. {                     
  26.         double FPU_RET;
  27.         __asm__                     
  28.         (                           
  29.                 "fcos\n"              
  30.                 : "=t" (FPU_RET)   
  31.                 : "0"  (x)         
  32.         );
  33.         return FPU_RET;
  34. }

  36. //正切函数
  37. double FPU_tan(double x)
  38. {                     
  39.         double FPU_RET, FPU_VAL;
  40.         __asm__                     
  41.         (                           
  42.                 "fptan\n"            
  43.                 : "=t" (FPU_VAL),   
  44.                   "=u" (FPU_RET)   
  45.                 : "0"  (x)         
  46.         );
  47.         return FPU_RET;
  48. }

  50. //ABS函数
  51. double FPU_fabs(double x)
  52. {                       
  53.         double FPU_RET;
  54.         __asm__                     
  55.         (                           
  56.                 "fabs\n"              
  57.                 : "=t" (FPU_RET)   
  58.                 : "0"  (x)         
  59.         );
  60.         return FPU_RET;
  61. }

  63. //自然对数
  64. double FPU_log2(double x)
  65. {                    
  66.         double FPU_RET;
  67.         __asm__                     
  68.         (                           
  69.                 "fld1\n"         
  70.                 "fxch\n"            
  71.                 "fyl2x\n"           
  72.                 : "=t" (FPU_RET)   
  73.                 : "0"  (x)         
  74.         );
  75.         return FPU_RET;
  76. }

  78. //自然对数
  79. double FPU_log(double x)
  80. {                    
  81.         double FPU_RET;
  82.         __asm__                     
  83.         (                           
  84.                 "fldln2\n"         
  85.                 "fxch\n"            
  86.                 "fyl2x\n"           
  87.                 : "=t" (FPU_RET)   
  88.                 : "0"  (x)         
  89.         );
  90.         return FPU_RET;
  91. }

  93. //常用对数
  94. double FPU_log10(double x)
  95. {                    
  96.         double FPU_RET;
  97.         __asm__                     
  98.         (                           
  99.                 "fldlg2\n"         
  100.                 "fxch\n"            
  101.                 "fyl2x\n"           
  102.                 : "=t" (FPU_RET)   
  103.                 : "0"  (x)         
  104.         );
  105.         return FPU_RET;
  106. }

  108. //开方函数
  109. double FPU_sqrt(double x)
  110. {                     
  111.         double FPU_RET;
  112.         __asm__                     
  113.         (                           
  114.                 "fsqrt\n"           
  115.                 : "=t" (FPU_RET)   
  116.                 : "0"  (x)         
  117.         );
  118.         return FPU_RET;
  119. }

  121. //EXP函数
  122. double FPU_exp(double x)
  123. {
  124.         double FPU_RET, FPU_VAL;
  125.         __asm__                     
  126.         (                           
  127.                 "fldl2e\n"         
  128.                 "fmul %%st(1)\n"   
  129.                 "fst   %%st(1)\n"  
  130.                 "frndint\n"         
  131.                 "fxch;\n"         
  132.                 "fsub %%st(1)\n"   
  133.                 "f2xm1\n"           
  134.                 : "=t" (FPU_RET), "=u" (FPU_VAL)
  135.                 : "0" (x)           
  136.                 );                  
  137.                 FPU_RET+= 1.0f;   
  138.         __asm__                     
  139.         (                           
  140.                 "fscale\n"         
  141.                 : "=t" (FPU_RET)   
  142.                 : "0" (FPU_RET), "u" (FPU_VAL)
  143.         );
  144.         return FPU_RET;
  145. }

  147. //次方函数
  148. double FPU_pow(double x, double y)
  149. {
  150.         double FPU_RET, FPU_VAL;
  151.         double FPU_RES=1.0f;
  152.         int FPU_INT=(int)y;
  153.         if (x==0.0 && y >0.0){return 0.0;}
  154.         if (y==(double)FPU_INT){
  155.                 if(FPU_INT==0){return 1.0;}
  156.                 if(FPU_INT <0){FPU_INT=-FPU_INT, x=1.0/x;}
  157.                 while(1){
  158.                         if(FPU_INT&1){FPU_RES*=x;}
  159.                         FPU_INT>>=1;
  160.                         if(FPU_INT==0){return FPU_RES;}
  161.                         x*=x;
  162.                 }
  163.         }
  164.         __asm__
  165.         (
  166.                 "fmul %%st(1)\n"
  167.                 "fst  %%st(1)\n"
  168.                 "frndint;\n"
  169.                 "fxch;\n"
  170.                 "fsub %%st(1);\n"
  171.                 "f2xm1;\n"
  172.                 : "=t" (FPU_RET), "=u" (FPU_VAL)
  173.                 : "0"  (FPU_log2(x)), "1" (y)
  174.         );
  175.         FPU_RET+=1.0;
  176.         __asm__
  177.         (
  178.                 "fscale"
  179.                 : "=t" (FPU_RET)
  180.                 : "0" (FPU_RET), "u" (FPU_VAL)       
  181.         );
  182.         return FPU_RET;
  183. }

  185. //四舍五入
  186. double FPU_round(double x)
  187. {
  188.         return (x<=0)?(float)((int)(x-0.5)):(float)((int)(x+0.5));
  189. }

  191. //向下取整
  192. double FPU_floor(double x)
  193. {
  194.         return (x<0)?(float)((int)x)-1:(float)((int)x);
  195. }

  197. //向上取整
  198. double FPU_ceil(double x)
  199. {
  200.         return (x<=0)?(float)((int)x):(float)((int)x)+1;
  201. }

  203. //双目反正切
  204. double FPU_atan2(double x, double y)
  205. {
  206.         double FPU_RET;
  207.         __asm__                     
  208.         (                           
  209.                 "fpatan\n"         
  210.                 "fld %%st(0)"     
  211.                 : "=t" (FPU_RET)  
  212.                 : "0" (y), "u" (x)  
  213.         );
  214.         return FPU_RET;
  215. }

  217. //反正弦函数
  218. double FPU_asin(double x)
  219. {
  220.         return FPU_atan2(x,FPU_sqrt(1.0-x*x));
  221. }

  223. //反余弦函数
  224. double FPU_acos(double x)
  225. {
  226.         return FPU_atan2(FPU_sqrt(1.0-x*x), x);
  227. }

  229. //反正切函数
  230. double FPU_atan(double x)
  231. {                     
  232.         return FPU_atan2(x,1.0f);
  233. }

  235. //双曲正弦函数
  236. double FPU_sinh(double x)
  237. {                     
  238.         return (FPU_exp(x)-FPU_exp(-x))/2;
  239. }

  241. //双曲余弦函数
  242. double FPU_cosh(double x)
  243. {                    
  244.         return (FPU_exp(x)+FPU_exp(-x))/2;
  245. }

  247. //双曲正切函数
  248. double FPU_tanh(double x)
  249. {                     
  250.         return (FPU_exp(x)-FPU_exp(-x))/(FPU_exp(x)+FPU_exp(-x));
  251. }

  253. //反双曲正弦函数
  254. double FPU_asinh(double x)
  255. {                     
  256.         return FPU_log(x+FPU_sqrt(x*x+1));
  257. }

  259. //反双曲余弦函数
  260. double FPU_acosh(double x)
  261. {                    
  262.         return FPU_log(x+FPU_sqrt(x*x-1));
  263. }

  265. //反双曲正切函数
  266. double FPU_atanh(double x)
  267. {                     
  268.         return FPU_log((1+x)/(1-x))/2;
  269. }

  271. //度转弧度
  272. double FPU_torad(double x)
  273. {
  274.         return x*FPU_PI/180;
  275. }

  277. //随机数函数
  278. double FPU_random(double x)
  279. {
  280.         return (x<2)?rand()%8192/8192.0:rand()%(int)(x);
  281. }
复制代码
回复

举报

B魔方大人
发表于 2017-2-1 18:46:25 | 显示全部楼层
如果使用math.h
优化的时候启用SSE试试如何!
回复

举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 注册

本版积分规则

Archiver|手机版|小黑屋|批处理之家 ( 渝ICP备10000708号 )

GMT+8, 2026-3-16 23:45 , Processed in 0.009946 second(s), 8 queries , File On.

Powered by Discuz! X3.5

© 2001-2026 Discuz! Team.

快速回复 返回顶部 返回列表