API tools faq
paste
cr88192

Some Decimal128 DPD test code...

cr88192
Nov 7th, 2025
245
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 26.79 KB | None | 0 0
raw download clone embed print report
  1. /*
  2. Written 2025-11-07 by Brendan G Bohannon.
  3.  
  4. Do whatever with this, just assume Public Domain or MIT-0 or CC0 or whatever.
  5. I take no responsibility for anything that may result from using this code.
  6. */
  7.  
  8. /*
  9. Decimal128 DPD test stuff...
  10. */
  11.  
  12.  
  13. #include <stdio.h>
  14. #include <stdlib.h>
  15. #include <string.h>
  16. #include <math.h>
  17. #include <stdint.h>
  18. #include <time.h>
  19.  
  20.  
  21. #ifndef BTIC2F_BYTE
  22. #define BTIC2F_BYTE
  23. typedef unsigned char           byte;
  24. typedef unsigned short      u16;
  25. typedef unsigned int            u32;
  26. typedef unsigned long long  u64;
  27.  
  28. typedef signed char         sbyte;
  29. typedef signed short            s16;
  30. typedef signed int          s32;
  31. typedef signed long long        s64;
  32. #endif
  33.  
  34. #define TKD128_MASK30   0x3FFFFFFFU
  35. #define TKD128_MASK20   0x000FFFFFU
  36. #define TKD128_MASK46   0x00003FFFFFFFFFFFULL
  37.  
  38. // #define TKD128_BIAS      6176
  39. #define TKD128_BIAS     6143
  40.  
  41. typedef struct TKD128_Packed128_s TKD128_Packed128;
  42. typedef struct TKD128_Unpacked4x30_s TKD128_Unpacked4x30;
  43. typedef struct TKD128_Unpacked8x30_s TKD128_Unpacked8x30;
  44.  
  45. struct TKD128_Packed128_s {
  46. u64 lo;
  47. u64 hi;
  48. };
  49.  
  50. struct TKD128_Unpacked4x30_s {
  51. u32 m[4];
  52. s16 exp;
  53. byte sgn;
  54. };
  55.  
  56. struct TKD128_Unpacked8x30_s {
  57. u32 m[8];
  58. s16 exp;
  59. byte sgn;
  60. };
  61.  
  62. char *TKD128_OprDumpAsString(
  63.     TKD128_Unpacked4x30 val);
  64.  
  65. u16 tkd128_unpackdpd[1024];
  66. u16 tkd128_packdpd[1024];
  67.  
  68. int TKD128_InitDPD()
  69. {
  70.     int d0, d1, d2;
  71.     int i, j, k;
  72.    
  73.     if(tkd128_packdpd[999])
  74.         return(0);
  75.    
  76.     for(i=0; i<1024; i++)
  77.     {
  78.         if(i&8)
  79.         {
  80.             if(((i>>1)&3)==0)
  81.             {
  82.                 d0=(i>>7)&7;
  83.                 d1=(i>>4)&7;
  84.                 d2=8+(i&1);
  85.             }else
  86.                 if(((i>>1)&3)==1)
  87.             {
  88.                 d0=(i>>7)&7;
  89.                 d1=8+((i>>4)&1);
  90.                 d2=((i>>4)&6)|(i&1);
  91.             }else
  92.                 if(((i>>1)&3)==2)
  93.             {
  94.                 d0=8+((i>>7)&1);
  95.                 d1=(i>>4)&7;
  96.                 d2=((i>>7)&6)|(i&1);
  97.             }else
  98.             {
  99.                 if(((i>>5)&3)==0)
  100.                 {
  101.                     d0=8+((i>>7)&1);
  102.                     d1=8+((i>>4)&1);
  103.                     d2=((i>>7)&6)|(i&1);
  104.                 }else
  105.                     if(((i>>5)&3)==1)
  106.                 {
  107.                     d0=8+((i>>7)&1);
  108.                     d1=((i>>7)&6)+((i>>4)&1);
  109.                     d2=8+((i>>0)&1);
  110.                 }else
  111.                     if(((i>>5)&3)==2)
  112.                 {
  113.                     d0=((i>>7)&6)+((i>>7)&1);
  114.                     d1=8+((i>>4)&1);
  115.                     d2=8+((i>>0)&1);
  116.                 }else
  117.                 {
  118.                     d0=8+((i>>7)&1);
  119.                     d1=8+((i>>4)&1);
  120.                     d2=8+((i>>0)&1);
  121.                 }
  122.             }
  123.         }else
  124.         {
  125.             d0=(i>>7)&7;
  126.             d1=(i>>4)&7;
  127.             d2=(i>>0)&7;
  128.         }
  129.        
  130.         j=d0*100+d1*10+d2;
  131.        
  132.         tkd128_unpackdpd[i]=j;
  133.         if(!tkd128_packdpd[j])
  134.             tkd128_packdpd[j]=i;
  135.     }
  136.  
  137.     return(1);
  138. }
  139.  
  140. TKD128_Unpacked4x30 TKD128_UnpackValueX30(TKD128_Packed128 val)
  141. {
  142.     TKD128_Unpacked4x30 tmp;
  143.     int mc, mcd, ex;
  144.    
  145.     tmp.m[0]=(val.lo>> 0)&TKD128_MASK30;
  146.     tmp.m[1]=(val.lo>>30)&TKD128_MASK30;
  147.     tmp.m[2]=((val.hi<< 4)|(val.lo>>60))&TKD128_MASK30;
  148.     tmp.m[3]=(val.hi>>26)&TKD128_MASK20;
  149.  
  150.     mc=(val.hi>>46)&0x1FFFF;
  151.     if((mc>>15)==3)
  152.         { mcd=8+(mc>>12)&1; ex=(mc&0xFFF)|(((mc>>13)&3)<<12); }
  153.     else
  154.         { mcd=(mc>>12)&7; ex=(mc&0xFFF)|(((mc>>15)&3)<<12); }
  155.     tmp.m[3]+=mcd*1000000;
  156.  
  157.     tmp.exp=ex;
  158.     tmp.sgn=val.hi>>63;
  159.  
  160.     return(tmp);
  161. }
  162.  
  163. TKD128_Packed128 TKD128_PackValueX30(TKD128_Unpacked4x30 val)
  164. {
  165.     TKD128_Packed128 tmp;
  166.     int m3n, mcd, mc, ex;
  167.    
  168.     m3n=val.m[3]%1000000000;
  169.     mcd=val.m[3]/1000000000;
  170.    
  171.     ex=val.exp;
  172.     if(mcd>=8)
  173.         { mc=0x18000|(ex&0xFFF)|((mcd&1)<<12)|(((ex>>12)&3)<<13); }
  174.     else
  175.         { mc=(ex&0xFFF)|((mcd&7)<<12)|(((ex>>12)&3)<<15); }
  176.    
  177.     tmp.lo=val.m[0]|(((u64)(val.m[1]))<<30)|(((u64)(val.m[2]))<<60);
  178.     tmp.hi=(val.m[2]>>4)|(((u64)m3n)<<26)|
  179.         (((u64)mcd)<<46)|(((u64)val.sgn)<<63);
  180.    
  181.     return(tmp);
  182. }
  183.  
  184.  
  185. #if 1
  186. void TKD128_UnpackValueX30R(
  187.     TKD128_Unpacked4x30 *rtmp, TKD128_Packed128 *rval)
  188. {
  189. //  TKD128_Unpacked4x30 tmp;
  190.     u64 lo, hi;
  191.     int mc, mcd, ex;
  192.    
  193.     lo=rval->lo;
  194.     hi=rval->hi;
  195.     rtmp->m[0]=(lo>> 0)&TKD128_MASK30;
  196.     rtmp->m[1]=(lo>>30)&TKD128_MASK30;
  197.     rtmp->m[2]=((hi<< 4)|(lo>>60))&TKD128_MASK30;
  198.     rtmp->m[3]=(hi>>26)&TKD128_MASK20;
  199.  
  200.     mc=(hi>>46)&0x1FFFF;
  201.     if((mc>>15)==3)
  202.     {
  203.         mcd=8+(mc>>12)&1;
  204.         ex=(mc&0xFFF)|(((mc>>13)&3)<<12);
  205.     }else
  206.     {
  207.         mcd=(mc>>12)&7;
  208.         ex=(mc&0xFFF)|(((mc>>15)&3)<<12);
  209.     }
  210.     rtmp->m[3]+=mcd*1000000;
  211.  
  212.     rtmp->exp=ex;
  213.     rtmp->sgn=hi>>63;
  214. }
  215.  
  216. void TKD128_PackValueX30R(
  217.     TKD128_Unpacked4x30 *rval, TKD128_Packed128 *rtmp)
  218. {
  219.     u32 m0, m1, m2, m3;
  220.     int m3n, mcd, mc, ex, sgn;
  221.    
  222.     m0=rval->m[0];
  223.     m1=rval->m[1];
  224.     m2=rval->m[2];
  225.     m3=rval->m[3];
  226.    
  227.     m3n=m3%1000000000;
  228.     mcd=m3/1000000000;
  229.     sgn=rval->sgn;
  230.    
  231.     ex=rval->exp;
  232.     if(mcd>=8)
  233.         { mc=0x18000|(ex&0xFFF)|((mcd&1)<<12)|(((ex>>12)&3)<<13); }
  234.     else
  235.         { mc=(ex&0xFFF)|((mcd&7)<<12)|(((ex>>12)&3)<<15); }
  236.  
  237.     rtmp->lo=m0|(((u64)(m1))<<30)|(((u64)(m2))<<60);
  238.     rtmp->hi=(m2>>4)|(((u64)m3n)<<26)|
  239.         (((u64)mcd)<<46)|(((u64)sgn)<<63);
  240. }
  241. #endif
  242.  
  243.  
  244. u32 TKD128_UnpackBitsDPD30(u32 val)
  245. {
  246.     u32 v0, v1, v2, v;
  247.     v0=tkd128_unpackdpd[(val>> 0)&1023];
  248.     v1=tkd128_unpackdpd[(val>>10)&1023];
  249.     v2=tkd128_unpackdpd[(val>>20)&1023];
  250.     v=v0+(v1*1000)+(v2*1000000);
  251.     return(v);
  252. }
  253.  
  254. u32 TKD128_PackBitsDPD30(u32 val)
  255. {
  256.     u32 v0, v1, v2, v;
  257.     v=val;
  258.     v1=v/1000;
  259.     v0=v-(v1*1000);
  260.     v2=v1/1000;
  261.     v1=v1-(v2*1000);
  262.     v0=tkd128_packdpd[v0];
  263.     v1=tkd128_packdpd[v1];
  264.     v2=tkd128_packdpd[v2];
  265.     v=v0|(v1<<10)|(v2<<20);
  266.     return(v);
  267. }
  268.  
  269. TKD128_Unpacked4x30 TKD128_UnpackValueDPD(TKD128_Packed128 val)
  270. {
  271.     TKD128_Unpacked4x30 tmp;
  272.     int mc, mcd, ex;
  273.    
  274.     tmp.m[0]=TKD128_UnpackBitsDPD30((val.lo>> 0)&TKD128_MASK30);
  275.     tmp.m[1]=TKD128_UnpackBitsDPD30((val.lo>>30)&TKD128_MASK30);
  276.     tmp.m[2]=TKD128_UnpackBitsDPD30(((val.hi<< 4)|(val.lo>>60))&TKD128_MASK30);
  277.     tmp.m[3]=TKD128_UnpackBitsDPD30((val.hi>>26)&TKD128_MASK20);
  278.  
  279.     mc=(val.hi>>46)&0x1FFFF;
  280.     if((mc>>15)==3)
  281.     {
  282.         mcd=8+(mc>>12)&1;
  283.         ex=(mc&0xFFF)|(((mc>>13)&3)<<12);
  284.     }else
  285.     {
  286.         mcd=(mc>>12)&7;
  287.         ex=(mc&0xFFF)|(((mc>>15)&3)<<12);
  288.     }
  289.     tmp.m[3]+=mcd*1000000;
  290.  
  291.     tmp.exp=ex;
  292.     tmp.sgn=val.hi>>63;
  293.  
  294.     return(tmp);
  295. }
  296.  
  297. TKD128_Packed128 TKD128_PackValueDPD(TKD128_Unpacked4x30 val)
  298. {
  299.     TKD128_Packed128 tmp;
  300.     u32 m0, m1, m2, m3;
  301.     int m3n, mcd, mc, ex;
  302.    
  303.     mcd=val.m[3]/1000000;
  304.     m3n=val.m[3]%1000000;
  305.    
  306.     ex=val.exp;
  307.     if(mcd>=8)
  308.         { mc=0x18000|(ex&0xFFF)|((mcd&1)<<12)|(((ex>>12)&3)<<13); }
  309.     else
  310.         { mc=(ex&0xFFF)|((mcd&7)<<12)|(((ex>>12)&3)<<15); }
  311.  
  312.     m0=TKD128_PackBitsDPD30(val.m[0]);
  313.     m1=TKD128_PackBitsDPD30(val.m[1]);
  314.     m2=TKD128_PackBitsDPD30(val.m[2]);
  315.     m3=TKD128_PackBitsDPD30(m3n);
  316.     tmp.lo=m0|(((u64)m1)<<30)|(((u64)m2)<<60);
  317.     tmp.hi=(m2>>4)|(((u64)m3)<<26)|
  318.         (((u64)mc)<<46)|(((u64)val.sgn)<<63);
  319.    
  320.     return(tmp);
  321. }
  322.  
  323.  
  324. int TKD128_ScaleLeftArray8(u32 *arr, int shl)
  325. {
  326.     int sh;
  327.  
  328.     sh=shl;
  329.  
  330.     while(sh>=9)
  331.     {
  332.         sh-=9;
  333.         arr[7]=arr[6];
  334.         arr[6]=arr[5];
  335.         arr[5]=arr[4];
  336.         arr[4]=arr[3];
  337.         arr[3]=arr[2];
  338.         arr[2]=arr[1];
  339.         arr[1]=arr[0];
  340.         arr[0]=0;
  341.     }
  342.  
  343.     while(sh>=3)
  344.     {
  345.         sh-=3;
  346.         arr[7]=((arr[7]%1000000)*1000)+(arr[6]/1000000);
  347.         arr[6]=((arr[6]%1000000)*1000)+(arr[5]/1000000);
  348.         arr[5]=((arr[5]%1000000)*1000)+(arr[4]/1000000);
  349.         arr[4]=((arr[4]%1000000)*1000)+(arr[3]/1000000);
  350.         arr[3]=((arr[3]%1000000)*1000)+(arr[2]/1000000);
  351.         arr[2]=((arr[2]%1000000)*1000)+(arr[1]/1000000);
  352.         arr[1]=((arr[1]%1000000)*1000)+(arr[0]/1000000);
  353.         arr[0]=((arr[0]%1000000)*1000);
  354.     }
  355.  
  356.     while(sh>=1)
  357.     {
  358.         sh--;
  359.         arr[7]=((arr[7]%100000000)*10)+(arr[6]/100000000);
  360.         arr[6]=((arr[6]%100000000)*10)+(arr[5]/100000000);
  361.         arr[5]=((arr[5]%100000000)*10)+(arr[4]/100000000);
  362.         arr[4]=((arr[4]%100000000)*10)+(arr[3]/100000000);
  363.         arr[3]=((arr[3]%100000000)*10)+(arr[2]/100000000);
  364.         arr[2]=((arr[2]%100000000)*10)+(arr[1]/100000000);
  365.         arr[1]=((arr[1]%100000000)*10)+(arr[0]/100000000);
  366.         arr[0]=((arr[0]%100000000)*10);
  367.     }
  368.     return(0);
  369. }
  370.  
  371.  
  372. int TKD128_ScaleRightArray8(u32 *arr, int shl)
  373. {
  374.     int sh;
  375.  
  376.     sh=shl;
  377.  
  378.     while(sh>=9)
  379.     {
  380.         sh-=9;
  381.         arr[0]=arr[1];
  382.         arr[1]=arr[2];
  383.         arr[2]=arr[3];
  384.         arr[3]=arr[4];
  385.         arr[4]=arr[5];
  386.         arr[5]=arr[6];
  387.         arr[6]=arr[7];
  388.         arr[7]=0;
  389.     }
  390.  
  391.     while(sh>=3)
  392.     {
  393.         sh-=3;
  394.         arr[0]=((arr[1]%1000)*1000000)+(arr[0]/1000);
  395.         arr[1]=((arr[2]%1000)*1000000)+(arr[1]/1000);
  396.         arr[2]=((arr[3]%1000)*1000000)+(arr[2]/1000);
  397.         arr[3]=((arr[4]%1000)*1000000)+(arr[3]/1000);
  398.         arr[4]=((arr[5]%1000)*1000000)+(arr[4]/1000);
  399.         arr[5]=((arr[6]%1000)*1000000)+(arr[5]/1000);
  400.         arr[6]=((arr[7]%1000)*1000000)+(arr[6]/1000);
  401.         arr[7]=(arr[7]/1000);
  402.     }
  403.  
  404.     while(sh>=1)
  405.     {
  406.         sh--;
  407.         arr[0]=((arr[1]%10)*100000000)+(arr[0]/10);
  408.         arr[1]=((arr[2]%10)*100000000)+(arr[1]/10);
  409.         arr[2]=((arr[3]%10)*100000000)+(arr[2]/10);
  410.         arr[3]=((arr[4]%10)*100000000)+(arr[3]/10);
  411.         arr[4]=((arr[5]%10)*100000000)+(arr[4]/10);
  412.         arr[5]=((arr[6]%10)*100000000)+(arr[5]/10);
  413.         arr[6]=((arr[7]%10)*100000000)+(arr[6]/10);
  414.         arr[7]=(arr[7]/10);
  415.     }
  416.     return(0);
  417. }
  418.  
  419. int TKD128_AddArray8(u32 *arr_a, u32 *arr_b, u32 *arr_c)
  420. {
  421.     u32 v, c;
  422.     int i;
  423.    
  424.     c=0;
  425.     for(i=0; i<8; i++)
  426.     {
  427.         v=arr_a[i]+arr_b[i]+c;
  428.         c=0;
  429.         if(v>=1000000000U)
  430.             { c=1; v-=1000000000U; }
  431.         arr_c[i]=v;
  432.     }
  433.     return(0);
  434. }
  435.  
  436. int TKD128_SubArray8(u32 *arr_a, u32 *arr_b, u32 *arr_c)
  437. {
  438.     u32 v, c;
  439.     int i;
  440.    
  441.     c=0;
  442.     for(i=0; i<8; i++)
  443.     {
  444.         v=arr_a[i]-arr_b[i]-c;
  445.         c=0;
  446.         if(v>=1000000000U)
  447.             { c=1; v+=1000000000U; }
  448.         arr_c[i]=v;
  449.     }
  450.     return(0);
  451. }
  452.  
  453. TKD128_Unpacked8x30 TKD128_Conv4to8x30(
  454.     TKD128_Unpacked4x30 val)
  455. {
  456.     TKD128_Unpacked8x30 tmp;
  457.     tmp.sgn=val.sgn;
  458.     tmp.exp=val.exp;
  459.     tmp.m[7]=val.m[3];
  460.     tmp.m[6]=val.m[2];
  461.     tmp.m[5]=val.m[1];
  462.     tmp.m[4]=val.m[0];
  463.     tmp.m[3]=0;
  464.     tmp.m[2]=0;
  465.     tmp.m[1]=0;
  466.     tmp.m[0]=0;
  467.     return(tmp);
  468. }
  469.  
  470. TKD128_Unpacked4x30 TKD128_OprNormalize8to4x30(TKD128_Unpacked8x30 valc0)
  471. {
  472.     TKD128_Unpacked4x30 valc;
  473.     u32 m0, m1, m2, m3;
  474.  
  475.     if(valc0.m[7]>=10000000)
  476.         { valc0.exp++; TKD128_ScaleRightArray8(valc0.m, 1); }
  477.     while(!valc0.m[7] && !valc0.m[6] && (valc0.exp>=9))
  478.         { valc0.exp-=9; TKD128_ScaleLeftArray8(valc0.m, 9); }
  479.     while(!valc0.m[7] && (valc0.exp>=6))
  480.         { valc0.exp-=6; TKD128_ScaleLeftArray8(valc0.m, 6); }
  481.     while((valc0.m[7]<=1000) && (valc0.exp>=3))
  482.         { valc0.exp-=3; TKD128_ScaleLeftArray8(valc0.m, 3); }
  483.     while((valc0.m[7]<1000000) && (valc0.exp>=1))
  484.         { valc0.exp--; TKD128_ScaleLeftArray8(valc0.m, 1); }
  485.    
  486.     m0=valc0.m[4];
  487.     m1=valc0.m[5];
  488.     m2=valc0.m[6];
  489.     m3=valc0.m[7];
  490.  
  491.     m0+=(valc0.m[3]>500000000);
  492.  
  493.     if(m0>=1000000000)
  494.         { m1++; m0-=1000000000; }
  495.     if(m1>=1000000000)
  496.         { m2++; m1-=1000000000; }
  497.     if(m2>=1000000000)
  498.         { m3++; m2-=1000000000; }
  499.    
  500.     valc.sgn=valc0.sgn;
  501.     valc.exp=valc0.exp;
  502.     valc.m[0]=m0;   valc.m[1]=m1;
  503.     valc.m[2]=m2;   valc.m[3]=m3;
  504.    
  505.     return(valc);
  506. }
  507.  
  508. TKD128_Unpacked4x30 TKD128_OprAdd(
  509.     TKD128_Unpacked4x30 vala,
  510.     TKD128_Unpacked4x30 valb)
  511. {
  512.     TKD128_Unpacked8x30 vala0, valb0, valc0;
  513.     TKD128_Unpacked4x30 valc;
  514.     int maxexp, flip;
  515.    
  516.     vala0=TKD128_Conv4to8x30(vala);
  517.     valb0=TKD128_Conv4to8x30(valb);
  518.     maxexp=vala0.exp;
  519.     flip=0;
  520.     if(valb0.exp>maxexp)
  521.     {
  522.         maxexp=valb0.exp;
  523.         flip=1;
  524.     }else
  525.         if(vala0.exp==valb0.exp)
  526.     {
  527.         if(valb0.m[7]>vala0.m[7])
  528.             { flip=1; }
  529.         else if(valb0.m[7]==vala0.m[7])
  530.         {   if(valb0.m[6]>vala0.m[6])
  531.                 { flip=1; }
  532.             else if(valb0.m[6]==vala0.m[6])
  533.             {   if(valb0.m[5]>vala0.m[5])
  534.                     { flip=1; }
  535.                 else if(valb0.m[5]==vala0.m[5])
  536.                 {   if(valb0.m[4]>vala0.m[4])
  537.                         { flip=1; }
  538.                 }
  539.             }
  540.         }
  541.     }
  542.    
  543.     if(flip)
  544.     {
  545.         valc0=vala0;
  546.         vala0=valb0;
  547.         valb0=valc0;
  548.     }
  549.  
  550.     TKD128_ScaleRightArray8(vala0.m, maxexp-vala0.exp);
  551.     TKD128_ScaleRightArray8(valb0.m, maxexp-valb0.exp);
  552.     vala0.exp=maxexp;
  553.     valb0.exp=maxexp;
  554.     valc0.exp=maxexp;
  555.     valc0.sgn=vala0.sgn;
  556.    
  557.     if(vala0.sgn==valb0.sgn)
  558.         { TKD128_AddArray8(vala0.m, valb0.m, valc0.m); }
  559.     else
  560.         { TKD128_SubArray8(vala0.m, valb0.m, valc0.m); }
  561.  
  562.     valc=TKD128_OprNormalize8to4x30(valc0);
  563.     return(valc);
  564. }
  565.  
  566. TKD128_Unpacked4x30 TKD128_OprSub(
  567.     TKD128_Unpacked4x30 vala,
  568.     TKD128_Unpacked4x30 valb)
  569. {
  570.     TKD128_Unpacked4x30 valb1;
  571.     valb1=valb;
  572.     valb1.sgn=!valb.sgn;
  573.     return(TKD128_OprAdd(vala, valb1));
  574. }
  575.  
  576. TKD128_Unpacked4x30 TKD128_OprMul(
  577.     TKD128_Unpacked4x30 vala,
  578.     TKD128_Unpacked4x30 valb)
  579. {
  580.     TKD128_Unpacked8x30 valc0;
  581.     TKD128_Unpacked4x30 valc;
  582.     u64 m0_aa, m0_ab, m0_ac, m0_ad;
  583.     u64 m0_ba, m0_bb, m0_bc, m0_bd;
  584.     u64 m0_ca, m0_cb, m0_cc, m0_cd;
  585.     u64 m0_da, m0_db, m0_dc, m0_dd;
  586.     u64 m1a, m1b, m1c, m1d;
  587.    
  588.     valc0.exp=vala.exp+valb.exp-TKD128_BIAS;
  589.     valc0.sgn=vala.sgn^valb.sgn;
  590.    
  591.     m0_aa=((u64)vala.m[3])*((u64)valb.m[3]);
  592.     m0_ab=((u64)vala.m[3])*((u64)valb.m[2]);
  593.     m0_ac=((u64)vala.m[3])*((u64)valb.m[1]);
  594.     m0_ad=((u64)vala.m[3])*((u64)valb.m[0]);
  595.     m0_ba=((u64)vala.m[2])*((u64)valb.m[3]);
  596.     m0_bb=((u64)vala.m[2])*((u64)valb.m[2]);
  597.     m0_bc=((u64)vala.m[2])*((u64)valb.m[1]);
  598.     m0_bd=((u64)vala.m[2])*((u64)valb.m[0]);
  599.     m0_ca=((u64)vala.m[1])*((u64)valb.m[3]);
  600.     m0_cb=((u64)vala.m[1])*((u64)valb.m[2]);
  601.     m0_cc=((u64)vala.m[1])*((u64)valb.m[1]);
  602.     m0_cd=((u64)vala.m[1])*((u64)valb.m[0]);
  603.     m0_da=((u64)vala.m[0])*((u64)valb.m[3]);
  604.     m0_db=((u64)vala.m[0])*((u64)valb.m[2]);
  605.     m0_dc=((u64)vala.m[0])*((u64)valb.m[1]);
  606.     m0_dd=((u64)vala.m[0])*((u64)valb.m[0]);
  607.  
  608. /*
  609.  * AA
  610.  *  AB
  611.  *  BA
  612.  *   BB
  613.  *   AC
  614.  *   CA
  615.  *    AD
  616.  *    DA
  617.  *    BC
  618.  *    CB
  619.  *     CC
  620.  *     BD
  621.  *     DB
  622.  *      CD
  623.  *      DC
  624.  *       DD
  625.  */
  626.  
  627.     m1a=m0_aa+
  628.         (m0_ba/1000000000ULL) +
  629.         (m0_ab/1000000000ULL) ;
  630.     m1b=m0_bb+
  631.         m0_ac+
  632.         m0_ca+
  633.         (m0_cb/1000000000ULL) +
  634.         (m0_bc/1000000000ULL) +
  635.         (m0_ad/1000000000ULL) +
  636.         (m0_da/1000000000ULL) +
  637.         ((m0_ba%1000000000ULL)*1000000000ULL) +
  638.         ((m0_ab%1000000000ULL)*1000000000ULL) ;
  639.     m1c=m0_cc+
  640.         m0_bd+
  641.         m0_db+
  642.         (m0_dc/1000000000ULL) +
  643.         (m0_cd/1000000000ULL) +
  644.         ((m0_ad%1000000000ULL)*1000000000ULL) +
  645.         ((m0_da%1000000000ULL)*1000000000ULL) +
  646.         ((m0_cb%1000000000ULL)*1000000000ULL) +
  647.         ((m0_bc%1000000000ULL)*1000000000ULL) ;
  648.    
  649.     m1d=m0_dd+
  650.         ((m0_dc%1000000000ULL)*1000000000ULL) +
  651.         ((m0_cd%1000000000ULL)*1000000000ULL) ;
  652.  
  653.     while(m1d>=1000000000000000000ULL)
  654.         { m1d-=1000000000000000000ULL; m1c++; }
  655.     while(m1c>=1000000000000000000ULL)
  656.         { m1c-=1000000000000000000ULL; m1b++; }
  657.     while(m1b>=1000000000000000000ULL)
  658.         { m1b-=1000000000000000000ULL; m1a++; }
  659.  
  660.     valc0.m[7]=m1a/1000000000ULL;
  661.     valc0.m[6]=m1a%1000000000ULL;
  662.     valc0.m[5]=m1b/1000000000ULL;
  663.     valc0.m[4]=m1b%1000000000ULL;
  664.     valc0.m[3]=m1c/1000000000ULL;
  665.     valc0.m[2]=m1c%1000000000ULL;
  666.     valc0.m[1]=m1d/1000000000ULL;
  667.     valc0.m[0]=m1d%1000000000ULL;
  668.    
  669.     TKD128_ScaleLeftArray8(valc0.m, 3);
  670.  
  671.     valc=TKD128_OprNormalize8to4x30(valc0);
  672.     return(valc);
  673. }
  674.  
  675. TKD128_Unpacked4x30 TKD128_OprRecipApx(
  676.     TKD128_Unpacked4x30 val)
  677. {
  678.     TKD128_Unpacked4x30 valc;
  679.    
  680.     valc.sgn=val.sgn;
  681.     valc.exp=(2*TKD128_BIAS-1)-val.exp;
  682.     valc.m[3]=1000000000-val.m[3];
  683.     valc.m[2]=1000000000-val.m[2];
  684.     valc.m[1]=1000000000-val.m[1];
  685.     valc.m[0]=1000000000-val.m[0];
  686.     return(valc);
  687. }
  688.  
  689. int TKD128_OprCompare(
  690.     TKD128_Unpacked4x30 vala,
  691.     TKD128_Unpacked4x30 valb)
  692. {
  693.     if(vala.sgn!=valb.sgn)
  694.     {
  695.         if(!vala.sgn)
  696.             return(1);
  697.         return(-1);
  698.     }
  699.  
  700.     if(vala.exp!=valb.exp)
  701.     {
  702.         if(vala.exp>valb.exp)
  703.             return(1);
  704.         return(-1);
  705.     }
  706.     if(vala.m[3]!=valb.m[3])
  707.     {
  708.         if(vala.m[3]>valb.m[3])
  709.             return(1);
  710.         return(-1);
  711.     }
  712.     if(vala.m[2]!=valb.m[2])
  713.     {
  714.         if(vala.m[2]>valb.m[2])
  715.             return(1);
  716.         return(-1);
  717.     }
  718.     if(vala.m[1]!=valb.m[1])
  719.     {
  720.         if(vala.m[1]>valb.m[1])
  721.             return(1);
  722.         return(-1);
  723.     }
  724.     if(vala.m[0]!=valb.m[0])
  725.     {
  726.         if(vala.m[0]>valb.m[0])
  727.             return(1);
  728.         return(-1);
  729.     }
  730.     return(0);
  731. }
  732.  
  733. TKD128_Unpacked4x30 TKD128_OprRecip(
  734.     TKD128_Unpacked4x30 val)
  735. {
  736.     static TKD128_Unpacked4x30 cnst_0p5 ={{0,0,0, 500000}, TKD128_BIAS, 0};
  737.     static TKD128_Unpacked4x30 cnst_2p0 ={{0,0,0,2000000}, TKD128_BIAS, 0};
  738.     static TKD128_Unpacked4x30 cnst_1p0 ={{0,0,0,1000000}, TKD128_BIAS, 0};
  739.     static TKD128_Unpacked4x30 cnst_3p0 ={{0,0,0,3000000}, TKD128_BIAS, 0};
  740.     static TKD128_Unpacked4x30 cnst_0p75={{0,0,0, 750000}, TKD128_BIAS, 0};
  741.     static TKD128_Unpacked4x30 cnst_1p25={{0,0,0,1250000}, TKD128_BIAS, 0};
  742.     static TKD128_Unpacked4x30 cnst_0p875={{0,0,0, 875000}, TKD128_BIAS, 0};
  743.     static TKD128_Unpacked4x30 cnst_1p125={{0,0,0,1125000}, TKD128_BIAS, 0};
  744.  
  745.     TKD128_Unpacked4x30 valc, valb, valt;
  746.     int d0, d1, d2, d3, de;
  747.     int i;
  748.    
  749.     valc=TKD128_OprRecipApx(val);
  750.  
  751. //  printf("Rcp Apx-0:\n  %s\n  %s\n",
  752. //      TKD128_OprDumpAsString(val),
  753. //      TKD128_OprDumpAsString(valc));
  754.  
  755.     for(i=0; i<32; i++)
  756.     {
  757.         valb=TKD128_OprMul(val, valc);
  758.         de=valb.exp-TKD128_BIAS;
  759.         if(de>0)
  760.             { valc=TKD128_OprMul(valc, cnst_0p5); continue; }
  761.         if(de<0)
  762.             { valc=TKD128_OprMul(valc, cnst_2p0); continue; }
  763.  
  764.         if(valb.m[3]>=2000000)
  765.             { valc=TKD128_OprMul(valc, cnst_0p5); continue; }
  766.         if(valb.m[3]<= 500000)
  767.             { valc=TKD128_OprMul(valc, cnst_2p0); continue; }
  768.  
  769.         if(valb.m[3]>=1500000)
  770.             { valc=TKD128_OprMul(valc, cnst_0p75); continue; }
  771.         if(valb.m[3]<= 750000)
  772.             { valc=TKD128_OprMul(valc, cnst_1p25); continue; }
  773.  
  774.         if(valb.m[3]>=1250000)
  775.             { valc=TKD128_OprMul(valc, cnst_0p875); continue; }
  776.         if(valb.m[3]<= 875000)
  777.             { valc=TKD128_OprMul(valc, cnst_1p125); continue; }
  778.  
  779.         break;
  780.     }
  781.  
  782. //  printf("Rcp Apx-1:\n  %s\n  %s\n",
  783. //      TKD128_OprDumpAsString(val),
  784. //      TKD128_OprDumpAsString(valc));
  785.  
  786.     for(i=0; i<32; i++)
  787.     {
  788.         valb=TKD128_OprMul(val, valc);
  789.  
  790.         valt=TKD128_OprSub(cnst_2p0, valb);
  791.        
  792.         de=TKD128_OprCompare(valt, cnst_1p0);
  793.         if(!de)
  794.             break;
  795.  
  796. //      valt=TKD128_OprSub(cnst_3p0, valb);
  797. //      valt=TKD128_OprMul(valt, cnst_0p5);
  798.  
  799. //      printf("Rcp Apx-I:\n  %s\n  %s\n",
  800. //          TKD128_OprDumpAsString(valb),
  801. //          TKD128_OprDumpAsString(valt));
  802.  
  803.         valc=TKD128_OprMul(valc, valt);
  804.     }
  805.    
  806. //  printf("Rcp Apx-2:\n  %s\n  %s\n",
  807. //      TKD128_OprDumpAsString(val),
  808. //      TKD128_OprDumpAsString(valc));
  809.     return(valc);
  810. }
  811.  
  812. TKD128_Unpacked4x30 TKD128_OprDiv(
  813.     TKD128_Unpacked4x30 vala,
  814.     TKD128_Unpacked4x30 valb)
  815. {
  816.     TKD128_Unpacked4x30 valb1;
  817.     valb1=TKD128_OprRecip(valb);
  818.     return(TKD128_OprMul(vala, valb1));
  819. }
  820.  
  821.  
  822.  
  823. int TKD128_OprDump30ToString(char *ct, u32 v)
  824. {
  825.     u32 v0, v1, vt;
  826.     int i;
  827.    
  828.     vt=v;
  829.     for(i=0; i<9; i++)
  830.     {
  831.         v1=vt/10;
  832.         v0=vt-(v1*10);
  833.         vt=v1;
  834.         ct[8-i]='0'+v0;
  835.     }
  836.     return(0);
  837. }
  838.  
  839. char *TKD128_RAlloc(int sz)
  840. {
  841.     static char buf[4096];
  842.     static u16 pos;
  843.     char *ct;
  844.    
  845.     if((pos+sz)>=4096)
  846.         pos=0;
  847.     ct=buf+pos;
  848.     pos+=sz;
  849.     return(ct);
  850. }
  851.  
  852. char *TKD128_RStrDup(char *str)
  853. {
  854.     char *ct;
  855.     ct=TKD128_RAlloc(strlen(str)+1);
  856.     strcpy(ct, str);
  857.     return(ct);
  858. }
  859.  
  860. char *TKD128_OprDumpAsString(
  861.     TKD128_Unpacked4x30 val)
  862. {
  863.     static char tbuf[256], tb1[48];
  864.     char *ct, *cs;
  865.     int i, j, k, ex, exn;
  866.  
  867.     if((val.exp==0) && !val.m[3] && !val.m[2] && !val.m[1] && !val.m[0])
  868.     {
  869.         if(val.sgn)
  870.             return("-0.0");
  871.         return("0.0");
  872.     }
  873.  
  874.     TKD128_OprDump30ToString(tb1+ 0, val.m[3]);
  875.     TKD128_OprDump30ToString(tb1+ 9, val.m[2]);
  876.     TKD128_OprDump30ToString(tb1+18, val.m[1]);
  877.     TKD128_OprDump30ToString(tb1+27, val.m[0]);
  878.     tb1[36]=0;
  879.    
  880.     ex=val.exp-TKD128_BIAS;
  881.     exn=0;
  882.  
  883.     if((ex>32) || (ex<(-32)))
  884.         exn=1;
  885.  
  886.     ct=tbuf;
  887.     if(val.sgn)
  888.         *ct++='-';
  889.     if(exn)
  890.     {
  891.         *ct++='0';
  892.         *ct++='.';
  893.         strcpy(ct, tb1+2);
  894.         ct+=strlen(ct);
  895.         *ct++='E';
  896.         sprintf(ct, "%+d", ex);
  897.     }else
  898.         if(ex<0)
  899.     {
  900.         k=(-ex)-1;
  901.         *ct++='0';
  902.         *ct++='.';
  903.         while(k--)
  904.             *ct++='0';
  905.         strcpy(ct, tb1+2);
  906.     }else
  907.     {
  908.         k=ex+1;
  909.         cs=tb1+2;
  910.  
  911.         while(k && *cs=='0')
  912.             { *cs++; k--; }
  913.  
  914.         while(k && *cs)
  915.             { *ct++=*cs++; k--; }
  916.         if(*cs)
  917.         {
  918.             *ct++='.';
  919.             strcpy(ct, cs);
  920.         }else
  921.         {
  922.             while(k--)
  923.                 *ct++='0';
  924.             *ct++='.';
  925.             *ct++='0';
  926.             *ct=0;
  927.         }
  928.     }
  929.    
  930.     return(TKD128_RStrDup(tbuf));
  931. }
  932.  
  933. u32 TKD128_OprParse30ToString(char *str)
  934. {
  935.     u32 v;
  936.     int i;
  937.    
  938.     v=0;
  939.     for(i=0; i<9; i++)
  940.         { v=(v*10)+(str[i]-'0'); }
  941.     return(v);
  942. }
  943.  
  944. TKD128_Unpacked4x30 TKD128_OprParseFromString(char *str)
  945. {
  946.     TKD128_Unpacked4x30 val;
  947.     char tb[64];
  948.     char *cs, *ct;
  949.     int exh, exn, exsz, ex, exadj, sgn;
  950.    
  951.     cs=str;
  952.     ct=tb;
  953.  
  954.     sgn=0;
  955.     if(*cs=='+')
  956.         { cs++; sgn=0; }
  957.     if(*cs=='-')
  958.         { cs++; sgn=1; }
  959.    
  960.     while(*cs=='0')
  961.         cs++;
  962.    
  963.     *ct++='0';
  964.     *ct++='0';
  965.    
  966.     exh=0;
  967.     while((*cs>='0') && (*cs<='9') && (exh<34))
  968.         { *ct++=*cs++; exh++; }
  969.     if(exh>=34)
  970.     {
  971.         while((*cs>='0') && (*cs<='9'))
  972.             { cs++; exh++; }
  973.     }else
  974.     {
  975.         exn=0;
  976.         exsz=0;
  977.         if(*cs=='.')
  978.         {
  979.             cs++;
  980.            
  981.             if(!exh)
  982.             {
  983.                 while(*cs=='0')
  984.                     { cs++; exsz++; }
  985.             }
  986.            
  987.             while((*cs>='0') && (*cs<='9') && ((exh+exn)<34))
  988.                 { *ct++=*cs++; exn++; }
  989.         }
  990.         while((exh+exn)<34)
  991.             { *ct++='0'; exn++; }
  992.  
  993.         while((*cs>='0') && (*cs<='9'))
  994.             { cs++; }
  995.     }
  996.     *ct=0;
  997.    
  998.     exadj=0;
  999.     if((*cs=='e') || (*cs=='E'))
  1000.     {
  1001.         if(cs[1]=='+')
  1002.             { exadj=atoi(cs+2); }
  1003.         else
  1004.             { exadj=atoi(cs+1); }
  1005.     }
  1006.    
  1007.     ex=TKD128_BIAS+exh+exadj-1-exsz;
  1008.  
  1009.     val.sgn=sgn;
  1010.     val.exp=ex;
  1011.     val.m[3]=TKD128_OprParse30ToString(tb+ 0);
  1012.     val.m[2]=TKD128_OprParse30ToString(tb+ 9);
  1013.     val.m[1]=TKD128_OprParse30ToString(tb+18);
  1014.     val.m[0]=TKD128_OprParse30ToString(tb+27);
  1015.     return(val);
  1016. }
  1017.  
  1018. TKD128_Packed128 TKD128_OprAddDPD(
  1019.     TKD128_Packed128 vala,
  1020.     TKD128_Packed128 valb)
  1021. {
  1022.     TKD128_Packed128 vpc;
  1023.     TKD128_Unpacked4x30 vna, vnb, vnc;
  1024.  
  1025.     vna=TKD128_UnpackValueDPD(vala);
  1026.     vnb=TKD128_UnpackValueDPD(valb);
  1027.     vnc=TKD128_OprAdd(vna, vnb);
  1028.     vpc=TKD128_PackValueDPD(vnc);
  1029.     return(vpc);
  1030. }
  1031.  
  1032. TKD128_Packed128 TKD128_OprMulDPD(
  1033.     TKD128_Packed128 vala,
  1034.     TKD128_Packed128 valb)
  1035. {
  1036.     TKD128_Packed128 vpc;
  1037.     TKD128_Unpacked4x30 vna, vnb, vnc;
  1038.  
  1039.     vna=TKD128_UnpackValueDPD(vala);
  1040.     vnb=TKD128_UnpackValueDPD(valb);
  1041.     vnc=TKD128_OprMul(vna, vnb);
  1042.     vpc=TKD128_PackValueDPD(vnc);
  1043.     return(vpc);
  1044. }
  1045.  
  1046. TKD128_Packed128 TKD128_OprSubDPD(
  1047.     TKD128_Packed128 vala,
  1048.     TKD128_Packed128 valb)
  1049. {
  1050.     TKD128_Packed128 vpc;
  1051.     TKD128_Unpacked4x30 vna, vnb, vnc;
  1052.  
  1053.     vna=TKD128_UnpackValueDPD(vala);
  1054.     vnb=TKD128_UnpackValueDPD(valb);
  1055.     vnc=TKD128_OprSub(vna, vnb);
  1056.     vpc=TKD128_PackValueDPD(vnc);
  1057.     return(vpc);
  1058. }
  1059.  
  1060. TKD128_Packed128 TKD128_OprDivDPD(
  1061.     TKD128_Packed128 vala,
  1062.     TKD128_Packed128 valb)
  1063. {
  1064.     TKD128_Packed128 vpc;
  1065.     TKD128_Unpacked4x30 vna, vnb, vnc;
  1066.  
  1067.     vna=TKD128_UnpackValueDPD(vala);
  1068.     vnb=TKD128_UnpackValueDPD(valb);
  1069.     vnc=TKD128_OprDiv(vna, vnb);
  1070.     vpc=TKD128_PackValueDPD(vnc);
  1071.     return(vpc);
  1072. }
  1073.  
  1074.  
  1075. TKD128_Packed128 TKD128_OprAddX30(
  1076.     TKD128_Packed128 vala,
  1077.     TKD128_Packed128 valb)
  1078. {
  1079.     TKD128_Packed128 vpc;
  1080.     TKD128_Unpacked4x30 vna, vnb, vnc;
  1081.  
  1082. //  vna=TKD128_UnpackValueX30(vala);
  1083. //  vnb=TKD128_UnpackValueX30(valb);
  1084.     TKD128_UnpackValueX30R(&vna, &vala);
  1085.     TKD128_UnpackValueX30R(&vnb, &valb);
  1086.     vnc=TKD128_OprAdd(vna, vnb);
  1087. //  vpc=TKD128_PackValueX30(vnc);
  1088.     TKD128_PackValueX30R(&vnc, &vpc);
  1089.     return(vpc);
  1090. }
  1091.  
  1092. TKD128_Packed128 TKD128_OprMulX30(
  1093.     TKD128_Packed128 vala,
  1094.     TKD128_Packed128 valb)
  1095. {
  1096.     TKD128_Packed128 vpc;
  1097.     TKD128_Unpacked4x30 vna, vnb, vnc;
  1098.  
  1099. //  vna=TKD128_UnpackValueX30(vala);
  1100. //  vnb=TKD128_UnpackValueX30(valb);
  1101.     TKD128_UnpackValueX30R(&vna, &vala);
  1102.     TKD128_UnpackValueX30R(&vnb, &valb);
  1103.     vnc=TKD128_OprMul(vna, vnb);
  1104. //  vpc=TKD128_PackValueX30(vnc);
  1105.     TKD128_PackValueX30R(&vnc, &vpc);
  1106.     return(vpc);
  1107. }
  1108.  
  1109. char *TKD128_OprDumpAsStringDPD(TKD128_Packed128 val)
  1110. {
  1111.     return(TKD128_OprDumpAsString(TKD128_UnpackValueDPD(val)));
  1112. }
  1113.  
  1114. TKD128_Packed128 TKD128_OprParseFromStringDPD(char *str)
  1115. {
  1116.     return(TKD128_PackValueDPD(TKD128_OprParseFromString(str)));
  1117. }
  1118.  
  1119. // #define TEST_PI_DPD_HI       0x4329F0D84E95AF97
  1120. // #define TEST_PI_DPD_LO       0x7B1E09EE2B4D7F06
  1121. // 2F3F 1D4C 5D9C 1E8A
  1122. // 5E7F 1A5B 2C3A 5E3A
  1123.  
  1124. #define TEST_PI_DPD_HI      0x2200431857ACAD71ULL
  1125. #define TEST_PI_DPD_LO      0xF6F1CAC9A334F3DBULL
  1126.  
  1127.  
  1128. int main()
  1129. {
  1130.     TKD128_Packed128 vp0, vp1, vp2;
  1131.     TKD128_Unpacked4x30 vn0, vn1, vn2, vn3;
  1132.     u32 v0, v1, v2, v3;
  1133.     int t0, t1, t2, t0e;
  1134.     int i, n;
  1135.    
  1136.     TKD128_InitDPD();
  1137.    
  1138.     v0=0x12345678;
  1139.  
  1140.     v2=v0&1023;
  1141.     if(v2>=1000)    v2-=1000;
  1142.     v3=v0%1000;
  1143.    
  1144.     printf("A %d %d\n", v2, v3);
  1145.    
  1146.     v1=((((u64)v0)<<10)+(((u64)v0)<<4)+(((u64)v0)<<3))>>20;
  1147.    
  1148. //  v1=v0>>10;
  1149. //  v1=(v0+(v0>>6)+(v0>>7))>>10;
  1150. //  v1=v0/1000;
  1151.     v2=v0-v1*1000;
  1152.     if(v2>1000)
  1153.     {
  1154.         v1++;
  1155.         v2=v0-v1*1000;
  1156.     }
  1157.     printf("B %d (%X) %d %d\n", v2, v2, v1, v0/1000);
  1158.    
  1159. #if 1
  1160.     vp0.hi=TEST_PI_DPD_HI;
  1161.     vp0.lo=TEST_PI_DPD_LO;
  1162.     vn0=TKD128_UnpackValueDPD(vp0);
  1163.     printf("DPD Test:  %s\n",
  1164.         TKD128_OprDumpAsString(vn0));
  1165. #endif
  1166.  
  1167.  
  1168.     vn0.sgn=0;
  1169.     vn1.sgn=0;
  1170.     vn0.exp=TKD128_BIAS;
  1171.     vn1.exp=TKD128_BIAS;
  1172.     vn0.m[3]=  1234567;
  1173.     vn0.m[2]=890000000;
  1174.     vn0.m[1]=0;
  1175.     vn0.m[0]=0;
  1176.  
  1177.     vn1.m[3]=  3141592;
  1178.     vn1.m[2]=653589793;
  1179.     vn1.m[1]=238462643;
  1180.     vn1.m[0]=383279500;
  1181.  
  1182.     vp0=TKD128_PackValueDPD(vn0);
  1183.     vp1=TKD128_PackValueDPD(vn1);
  1184.  
  1185.     printf("%016llX %016llX\n", vp1.hi, vp1.lo);
  1186.     vn1=TKD128_UnpackValueDPD(vp1);
  1187.    
  1188.     for(i=0; i<16; i++)
  1189.     {
  1190.         printf("%02X ", ((byte *)(&vp1))[i]);
  1191.     }
  1192.     printf("\n");
  1193.  
  1194.     vn2=TKD128_OprParseFromString("987.654321");
  1195.     printf("Parse Test 1:  %s\n", TKD128_OprDumpAsString(vn2));
  1196.     vn2=TKD128_OprParseFromString("0.0707123");
  1197.     printf("Parse Test 2:  %s\n", TKD128_OprDumpAsString(vn2));
  1198.  
  1199.     t0=clock(); t0e=t0+CLOCKS_PER_SEC;
  1200.     t1=t0;  n=0;
  1201.     while(t1<t0e)
  1202.     {
  1203.         n++;
  1204.         for(i=0; i<10000; i++)
  1205.             vn2=TKD128_OprMul(vn0, vn1);
  1206.         t1=clock();
  1207.     }
  1208.     printf("MUL %d\n", n);
  1209.  
  1210.     printf("  %s\n  %s\n  %s\n",
  1211.         TKD128_OprDumpAsString(vn0),
  1212.         TKD128_OprDumpAsString(vn1),
  1213.         TKD128_OprDumpAsString(vn2));
  1214.  
  1215.     t0=clock(); t0e=t0+CLOCKS_PER_SEC;
  1216.     t1=t0;  n=0;
  1217.     while(t1<t0e)
  1218.     {
  1219.         n++;
  1220.         for(i=0; i<10000; i++)
  1221.             vn2=TKD128_OprAdd(vn0, vn1);
  1222.         t1=clock();
  1223.     }
  1224.     printf("ADD %d\n", n);
  1225.     printf("  %s\n  %s\n  %s\n",
  1226.         TKD128_OprDumpAsString(vn0),
  1227.         TKD128_OprDumpAsString(vn1),
  1228.         TKD128_OprDumpAsString(vn2));
  1229.  
  1230.     vn3=TKD128_OprSub(vn0, vn1);
  1231.     printf("SUB %d\n", n);
  1232.     printf("  %s\n  %s\n  %s\n",
  1233.         TKD128_OprDumpAsString(vn0),
  1234.         TKD128_OprDumpAsString(vn1),
  1235.         TKD128_OprDumpAsString(vn3));
  1236.  
  1237.  
  1238.     t0=clock(); t0e=t0+CLOCKS_PER_SEC;
  1239.     t1=t0;  n=0;
  1240.     while(t1<t0e)
  1241.     {
  1242.         n++;
  1243.         for(i=0; i<10000; i++)
  1244.             vn3=TKD128_OprDiv(vn0, vn1);
  1245.         t1=clock();
  1246.     }
  1247.  
  1248. //  vn3=TKD128_OprDiv(vn0, vn1);
  1249.     printf("DIV %d\n", n);
  1250.     printf("  %s\n  %s\n  %s\n",
  1251.         TKD128_OprDumpAsString(vn0),
  1252.         TKD128_OprDumpAsString(vn1),
  1253.         TKD128_OprDumpAsString(vn3));
  1254.  
  1255. //  vp0=vp2;
  1256.  
  1257.     t0=clock(); t0e=t0+CLOCKS_PER_SEC;
  1258.     t1=t0;  n=0;
  1259.     while(t1<t0e)
  1260.     {
  1261.         n++;
  1262.         for(i=0; i<10000; i++)
  1263.             vn2=TKD128_UnpackValueX30(vp0);
  1264.         t1=clock();
  1265.     }
  1266.     printf("UP X30 %d\n", n);
  1267.  
  1268.     t0=clock(); t0e=t0+CLOCKS_PER_SEC;
  1269.     t1=t0;  n=0;
  1270.     while(t1<t0e)
  1271.     {
  1272.         n++;
  1273.         for(i=0; i<10000; i++)
  1274.             vn2=TKD128_UnpackValueDPD(vp0);
  1275.         t1=clock();
  1276.     }
  1277.     printf("UP DPD %d\n", n);
  1278.  
  1279.     t0=clock(); t0e=t0+CLOCKS_PER_SEC;
  1280.     t1=t0;  n=0;
  1281.     while(t1<t0e)
  1282.     {
  1283.         n++;
  1284.         for(i=0; i<10000; i++)
  1285.             vp2=TKD128_PackValueX30(vn0);
  1286.         t1=clock();
  1287.     }
  1288.     printf("PK X30 %d\n", n);
  1289.  
  1290.     t0=clock(); t0e=t0+CLOCKS_PER_SEC;
  1291.     t1=t0;  n=0;
  1292.     while(t1<t0e)
  1293.     {
  1294.         n++;
  1295.         for(i=0; i<10000; i++)
  1296.             vp2=TKD128_PackValueDPD(vn0);
  1297.         t1=clock();
  1298.     }
  1299.     printf("PK DPD %d\n", n);
  1300.  
  1301.  
  1302.     t0=clock(); t0e=t0+CLOCKS_PER_SEC;
  1303.     t1=t0;  n=0;
  1304.     while(t1<t0e)
  1305.     {
  1306.         n++;
  1307.         for(i=0; i<10000; i++)
  1308.             vp2=TKD128_OprMulDPD(vp0, vp1);
  1309.         t1=clock();
  1310.     }
  1311.     printf("MUL(DPD) %d\n", n);
  1312.  
  1313.     t0=clock(); t0e=t0+CLOCKS_PER_SEC;
  1314.     t1=t0;  n=0;
  1315.     while(t1<t0e)
  1316.     {
  1317.         n++;
  1318.         for(i=0; i<10000; i++)
  1319.             vp2=TKD128_OprAddDPD(vp0, vp1);
  1320.         t1=clock();
  1321.     }
  1322.     printf("ADD(DPD) %d\n", n);
  1323.  
  1324.  
  1325.     vp0=TKD128_PackValueX30(vn0);
  1326.     vp1=TKD128_PackValueX30(vn1);
  1327.  
  1328.     t0=clock(); t0e=t0+CLOCKS_PER_SEC;
  1329.     t1=t0;  n=0;
  1330.     while(t1<t0e)
  1331.     {
  1332.         n++;
  1333.         for(i=0; i<10000; i++)
  1334.             vp2=TKD128_OprMulX30(vp0, vp1);
  1335.         t1=clock();
  1336.     }
  1337.     printf("MUL(X30) %d\n", n);
  1338.  
  1339.     t0=clock(); t0e=t0+CLOCKS_PER_SEC;
  1340.     t1=t0;  n=0;
  1341.     while(t1<t0e)
  1342.     {
  1343.         n++;
  1344.         for(i=0; i<10000; i++)
  1345.             vp2=TKD128_OprAddX30(vp0, vp1);
  1346.         t1=clock();
  1347.     }
  1348.     printf("ADD(X30) %d\n", n);
  1349. }
  1350.  
  1351.  
Tags: Decimal128 DPD
Advertisement
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!