💎 😍 🚭 GPU के लिए Math.Sin (डबल) फ़ंक्शन 👨🏾‍🌾 👨🏻‍💼 🖖🏾

प्रस्तावना

मुझे वास्तविक समय में वीडियो कार्ड प्रोसेसर पर बढ़ी सटीकता के साथ चाप की गणना करने की आवश्यकता थी।

लेखक ने मानक फ़ंक्शन System.Math.Sin () (C #) को पार करने के लिए एक लक्ष्य निर्धारित नहीं किया और उस तक नहीं पहुंचा।

काम और मेरी पसंद का परिणाम (उन लोगों के लिए जो पढ़ना नहीं चाहते):

सिन_3 (रेड)

using System; class Math_d { const double PI025 = Math.PI / 4; /// <summary> 2^17 = 131072 (1 ),   10000 ( ),  2^21 = 22097152 (16 )   +-1 ( ) (  ) </summary> const int length_mem = 22097152; const int length_mem_M1 = length_mem - 1; /// <summary>    sin,    . </summary> static double[] mem_sin; /// <summary>    cos,    . </summary> static double[] mem_cos; /// <summary>  ,   sin,    . </summary> public static void Initialise() { Ini_Mem_Sin(); Ini_Mem_Cos(); } /// <summary>       Cos,   . </summary> /// <param name="rad"></param> public static double Sin_3(double rad) { double rad_025; int i; //    //if (rad < 0) { rad = -rad + Math.PI; } i = (int)(rad / PI025); //   rad_025 = rad - PI025 * i; //     ( ) i = i & 7; //      8 //    switch (i) { case 0: return Sin_Lerp(rad_025); case 1: return Cos_Lerp(PI025 - rad_025); case 2: return Cos_Lerp(rad_025); case 3: return Sin_Lerp(PI025 - rad_025); case 4: return -Sin_Lerp(rad_025); case 5: return -Cos_Lerp(PI025 - rad_025); case 6: return -Cos_Lerp(rad_025); case 7: return -Sin_Lerp(PI025 - rad_025); } return 0; } /// <summary>   sin    </summary> static void Ini_Mem_Sin() { double rad; mem_sin = new double[length_mem]; for (int i = 0; i < length_mem; i++) { rad = (i * PI025) / length_mem_M1; mem_sin[i] = Math.Sin(rad); } } /// <summary>   cos    </summary> static void Ini_Mem_Cos() { double rad; mem_cos = new double[length_mem]; for (int i = 0; i < length_mem; i++) { rad = (i * PI025) / length_mem_M1; mem_cos[i] = Math.Cos(rad); } } /// <summary>      sin  0  pi/4. </summary> /// <param name="rad">     0  pi/4. </param> static double Sin_Lerp(double rad) { int i_0; int i_1; double i_0d; double percent; double a; double b; double s; percent = rad / PI025; i_0d = percent * length_mem_M1; i_0 = (int)i_0d; i_1 = i_0 + 1; a = mem_sin[i_0]; b = mem_sin[i_1]; s = i_0d - i_0; return Lerp(a, b, s); } /// <summary>      cos  0  pi/4. </summary> /// <param name="rad">     0  pi/4. </param> static double Cos_Lerp(double rad) { int i_0; int i_1; double i_0d; double percent; double a; double b; double s; percent = rad / PI025; i_0d = percent * length_mem_M1; i_0 = (int)i_0d; i_1 = i_0 + 1; a = mem_cos[i_0]; b = mem_cos[i_1]; s = i_0d - i_0; return Lerp(a, b, s); } /// <summary>      . (return a + s * (b - a)) </summary> /// <param name="a">  . </param> /// <param name="b">  . </param> /// <param name="s">  . 0 = a, 1 = b, 0.5 =   a  b. </param> public static double Lerp(double a, double b, double s) { return a + s * (b - a); } }

प्रकाशन के कारण

एचएलएसएल भाषा में दोहरे के लिए कोई मानक पाप कार्य नहीं है (लेकिन यह सटीक नहीं है)
इस विषय पर इंटरनेट पर बहुत कम जानकारी उपलब्ध है।

माना जाता है

टेलर सीरीज़ (विकिपीडिया)
बहुपद ( समारोह लेखक: "asvp" )
Math.Sin और Math.Cos के पूर्व-परिकलित परिणामों का रेखीय प्रक्षेप (लेखक: )

विश्लेषण किया गया पैरामीटर

Math.Sin के साथ सटीकता
Math.Sin के संबंध में गति

विश्लेषण के अलावा, हम उनके प्रदर्शन में सुधार करेंगे।

टेलर रैंक

पेशेवरों:

उच्चतम परिशुद्धता
इस फ़ंक्शन का उपयोग पाप मूल्य की गणना करने के लिए किया जाता है, का उपयोग असीम रूप से सटीक पाप मूल्य की गणना करने के लिए किया जा सकता है। जितने अधिक पुनरावृत्तियों से गुजरना पड़ता है, उतना ही सही मूल्य आउटपुट पर (एक परिकल्पना में) प्राप्त होता है। प्रोग्रामिंग अभ्यास में, यह उपयोग किए जाने वाले मापदंडों के प्रकार (डबल, फ्लोट, दशमलव, और अन्य) के आधार पर गणनाओं की राउंड-ऑफ त्रुटियों पर विचार करने के लायक है।
किसी भी कोण की गणना करता है
आप फ़ंक्शन के तर्क के रूप में किसी भी मूल्य को दर्ज कर सकते हैं, इसलिए इनपुट मापदंडों की निगरानी करने की कोई आवश्यकता नहीं है।
स्वतंत्रता
इसके लिए प्रारंभिक गणना की आवश्यकता नहीं है (जैसा कि नीचे चर्चा किए गए कार्यों के अनुसार), और यह अक्सर आधार होता है जिस पर तेजी से कार्य किए जाते हैं।

विपक्ष:

बहुत कम गति (4-10%)
मैथ्स की सटीकता के करीब सटीकता प्राप्त करने के लिए बहुत सारे पुनरावृत्तियों का उपयोग किया जाता है। इसके परिणामस्वरूप, यह मानक फ़ंक्शन की तुलना में 25 गुना धीमी गति से काम करता है।
कोण जितना बड़ा होगा, सटीकता उतनी ही कम होगी
फंक्शन में जितना बड़ा कोण प्रवेश करता है, उतना ही पुनरावृत्तियों को Math.Sin के समान सटीकता प्राप्त करने की आवश्यकता होती है।

मूल रूप (गति: 4%):

मानक फ़ंक्शन में फैक्टोरियल की गणना करना शामिल है, साथ ही साथ प्रत्येक पुनरावृत्ति को शक्ति प्रदान करना।

$छवि$

संशोधित (गति: 10%):

कुछ डिग्री की गणना को एक चक्र (* * =?) में कम किया जा सकता है, और अन्य factorials को पूर्व-संगणित किया जा सकता है और एक सरणी में रखा जा सकता है, जबकि संकेत (+, -, +, ...) को एक शक्ति में नहीं उठाया जा सकता है और उनकी गणना भी कम की जा सकती है। पिछले मूल्यों का उपयोग करते हुए।

परिणाम निम्नलिखित कोड है:

पाप (मूल, चरण)

  // <summary>  ,    Fact </summary> static double[] fact; /// <summary>            . ///   rad,   . ///  ( Math): 4% (fps)  steps = 17 </summary> /// <param name="rad">   .      pi/4. </param> /// <param name="steps">  :  ,   .  pi/4   E-15  8. </param> public static double Sin(double rad, int steps) { double ret; double a; //,     double aa; // *  int i_f; //  int sign; // (  -  +,     = +) ret = 0; sign = -1; aa = rad * rad; a = rad; i_f = 1; //      for (int n = 0; n < steps; n++) { sign *= -1; ret += sign * a / Fact(i_f); a *= aa; i_f += 2; } return ret; } /// <summary>   (n!).  n > fact.Length,  -1. </summary> /// <param name="n"> ,     . </param> public static double Fact(int n) { if (n >= 0 && n < fact.Length) { return fact[n]; } else { Debug.Log("    . n = " + n + ",   = " + fact.Length); return -1; } } /// <summary>  . </summary> static void Init_Fact() { int steps; steps = 46; fact = new double[steps]; fact[0] = 1; for (int n = 1; n < steps; n++) { fact[n] = fact[n - 1] * n; } }

सुपीरियर दृश्य (गति: 19%):

हम जानते हैं कि कोण जितना छोटा होगा, उतनी ही कम पुनरावृत्तियों की आवश्यकता होगी। सबसे छोटा कोण जिसकी हमें आवश्यकता है वह है = 0.25 * PI, अर्थात 45 डिग्री से। 45 डिग्री के क्षेत्र में पाप और कॉस को ध्यान में रखते हुए, हम पाप के लिए -1 से 1 तक सभी मान प्राप्त कर सकते हैं (2 / पीआई के क्षेत्र में)। ऐसा करने के लिए, हम सर्कल (2 * PI) को 8 भागों में विभाजित करते हैं और प्रत्येक भाग के लिए हम साइन की गणना करने के अपने तरीके का संकेत देते हैं। इसके अलावा, गणना को गति देने के लिए, हम शेष (%) प्राप्त करने के कार्य का उपयोग करने से इंकार कर देंगे (45 डिग्री के क्षेत्र के अंदर कोण की स्थिति प्राप्त करने के लिए):

सिन २ (रेड)

  // <summary>  ,    Fact </summary> static double[] fact; /// <summary>   Sin </summary> /// <param name="rad"></param> public static double Sin_2(double rad) { double rad_025; int i; //rad = rad % PI2; //% -   .  , fps   90  150 (  100 000   ) //rad_025 = rad % PI025; i = (int)(rad / PI025); rad_025 = rad - PI025 * i; i = i & 7; //     8  //    switch (i) { case 0: return Sin(rad_025, 8); case 1: return Cos(PI025 - rad_025, 8); case 2: return Cos(rad_025, 8); case 3: return Sin(PI025 - rad_025, 8); case 4: return -Sin(rad_025, 8); case 5: return -Cos(PI025 - rad_025, 8); case 6: return -Cos(rad_025, 8); case 7: return -Sin(PI025 - rad_025, 8); } return 0; } /// <summary>            . ///   rad,   . ///  ( Math): 10% (fps)  steps = 17 </summary> /// <param name="rad">   .      pi/4. </param> /// <param name="steps">  :  ,   .  pi/4   E-15  8. </param> public static double Sin(double rad, int steps) { double ret; double a; //,     double aa; // *  int i_f; //  int sign; // (  -  +,     = +) ret = 0; sign = -1; aa = rad * rad; a = rad; i_f = 1; //      for (int n = 0; n < steps; n++) { sign *= -1; ret += sign * a / Fact(i_f); a *= aa; i_f += 2; } return ret; } /// <summary>            . ///   rad,   . ///  ( Math): 10% (fps), 26% (test)  steps = 17 </summary> /// <param name="rad">   .      pi/4. </param> /// <param name="steps">  :  ,   .  pi/4   E-15  8. </param> public static double Cos(double rad, int steps) { double ret; double a; double aa; // *  int i_f; //  int sign; // (  -  +,     = +) ret = 0; sign = -1; aa = rad * rad; a = 1; i_f = 0; //      for (int n = 0; n < steps; n++) { sign *= -1; ret += sign * a / Fact(i_f); a *= aa; i_f += 2; } return ret; } /// <summary>   (n!).  n > fact.Length,  -1. </summary> /// <param name="n"> ,     . </param> public static double Fact(int n) { if (n >= 0 && n < fact.Length) { return fact[n]; } else { Debug.Log("    . n = " + n + ",   = " + fact.Length); return -1; } } /// <summary>  . </summary> static void Init_Fact() { int steps; steps = 46; fact = new double[steps]; fact[0] = 1; for (int n = 1; n < steps; n++) { fact[n] = fact[n - 1] * n; } }

बहुआयामी पद

मैं इंटरनेट पर इस पद्धति के पार आया था, लेखक को पूर्व-परिकलित मूल्यों के पुस्तकालयों का उपयोग किए बिना कम सटीकता (त्रुटि <0.000 001) के डबल के लिए एक तेज़ पाप खोज फ़ंक्शन की आवश्यकता थी।

पेशेवरों:

उच्च गति (9-84%)
प्रारंभ में, परिवर्तन के बिना फेंके गए बहुपद को मूल Math.Sin की 9% की गति दिखाई गई, जो कि 10 गुना धीमी है। छोटे परिवर्तनों के लिए धन्यवाद, गति तेजी से 84% तक बढ़ जाती है, जो खराब नहीं है यदि आप सटीकता के लिए अपनी आँखें बंद करते हैं।
कोई अतिरिक्त प्रारंभिक गणना और स्मृति की आवश्यकता नहीं है
यदि ऊपर और नीचे हमें गणनाओं को तेज करने के लिए चर के सरणियों की रचना करने की आवश्यकता है, तो यहां सभी प्रमुख गुणांकों की गणना की गई है और लेखक द्वारा स्थिरांक के रूप में स्वयं सूत्र में रखा गया है।
Mathf.Sin (फ्लोट) की तुलना में सटीकता
तुलना के लिए:

0.84147 1 - Mathf.Sin (1) (एकता इंजन);
0.841470984807897 - Math.Sin (1) (मानक C # फ़ंक्शन);
0.8414709 56802368 - पाप (1) (GPU, hlsl भाषा);
0.84147 1184637935 - सिन_0 (1) ।

विपक्ष:

सार्वभौमिक नहीं है
आप मैन्युअल रूप से सटीकता को समायोजित नहीं कर सकते क्योंकि यह ज्ञात नहीं है कि लेखक ने इस बहुपद की गणना करने के लिए किन उपकरणों का उपयोग किया है।
क्यों?
लेखक को एक फ़ंक्शन की आवश्यकता क्यों थी जिसमें किसी भी सरणियों की आवश्यकता नहीं होती है और जिसमें इतनी कम (दोहरी की तुलना में) सटीकता होती है?

मूल दृश्य:

पाप १ (x)

 /// <summary>  ( Math): 9% (fps)</summary> /// <param name="x">     -2*Pi  2*Pi </param> public static double Sin_1(double x) { return 0.9999997192673006 * x - 0.1666657564532464 * Math.Pow(x, 3) + 0.008332803647181511 * Math.Pow(x, 5) - 0.00019830197237204295 * Math.Pow(x, 7) + 2.7444305061093514e-6 * Math.Pow(x, 9) - 2.442176561869478e-8 * Math.Pow(x, 11) + 1.407555708887347e-10 * Math.Pow(x, 13) - 4.240664814288337e-13 * Math.Pow(x, 15); }

बेहतर दृश्य:

सिन_0 (रेड)

 /// <summary>  ( Math): 83% (fps)</summary> /// <param name="rad">     -2*Pi  2*Pi </param> public static double Sin_0(double rad) { double x; double xx; double ret; xx = rad * rad; x = rad; //1 ret = 0.9999997192673006 * x; x *= xx; //3 ret -= 0.1666657564532464 * x; x *= xx; //5 ret += 0.008332803647181511 * x; x *= xx; //7 ret -= 0.00019830197237204295 * x; x *= xx; //9 ret += 2.7444305061093514e-6 * x; x *= xx; //11 ret -= 2.442176561869478e-8 * x; x *= xx; //13 ret += 1.407555708887347e-10 * x; x *= xx; //15 ret -= 4.240664814288337e-13 * x; return ret; }

रैखिक प्रक्षेप

यह विधि एक सरणी में दो रिकॉर्ड के परिणामों के बीच रैखिक प्रक्षेप पर आधारित है।
प्रविष्टियों को mem_sin और mem_cos में विभाजित किया गया है, उनके पास मानक फ़ंक्शन Math.Sin और Math.Cos के पूर्व-परिकलित परिणाम हैं। इनपुट मापदंडों के एक सेगमेंट पर 0 से 0.25 * PI तक।

0 से 45 डिग्री के कोण के साथ जोड़तोड़ का सिद्धांत टेलर श्रृंखला के बेहतर संस्करण से अलग नहीं है, लेकिन एक ही समय में एक फ़ंक्शन को कहा जाता है जो पाता है - जिसके बीच दो रिकॉर्ड एक कोण है - और उनके बीच एक मान पाता है।

पेशेवरों:

उच्च गति (65%)
प्रक्षेप एल्गोरिथ्म की सादगी के कारण, गति Math.Sin की गति का 65% तक पहुंच जाती है। मुझे लगता है कि गति> 33% संतोषजनक है।
उच्चतम परिशुद्धता
अस्वीकृति के एक दुर्लभ मामले का एक उदाहरण:
0.255835595715180 - मैथ.इन;
0.2558355957151 79 - पाप_3 ।
तेजी से पैर
मुझे यह फ़ंक्शन बहुत पसंद है क्योंकि यह मेरे द्वारा लिखी गई पीड़ा में पैदा हुआ था और आवश्यकताओं से अधिक था: गति> 33%, सटीकता 1e-14 से ऊपर। मैं उसे एक गौरवशाली नाम दूंगा - Vēl givex Pes।

विपक्ष:

इसके लिए स्मृति में जगह की आवश्यकता होती है
काम करने के लिए, आपको पहले दो सरणियों की गणना करनी चाहिए: पाप के लिए और कॉस के लिए; प्रत्येक सरणी का वजन ~ 16mb (16 * 2 = 32mb)

मूल दृश्य:

सिन_3 (रेड)

 class Math_d { const double PI025 = Math.PI / 4; /// <summary> 2^17 = 131072 (1 ),   10000 ( ),  2^21 = 22097152 (16 )   +-1 ( ) (  ) </summary> const int length_mem = 22097152; const int length_mem_M1 = length_mem - 1; /// <summary>    sin,    . </summary> static double[] mem_sin; /// <summary>    cos,    . </summary> static double[] mem_cos; /// <summary>  ,   sin,    . </summary> public static void Initialise() { Ini_Mem_Sin(); Ini_Mem_Cos(); } /// <summary>       Cos,   . </summary> /// <param name="rad"></param> public static double Sin_3(double rad) { double rad_025; int i; //    //if (rad < 0) { rad = -rad + Math.PI; } i = (int)(rad / PI025); //   rad_025 = rad - PI025 * i; //     ( ) i = i & 7; //      8 //    switch (i) { case 0: return Sin_Lerp(rad_025); case 1: return Cos_Lerp(PI025 - rad_025); case 2: return Cos_Lerp(rad_025); case 3: return Sin_Lerp(PI025 - rad_025); case 4: return -Sin_Lerp(rad_025); case 5: return -Cos_Lerp(PI025 - rad_025); case 6: return -Cos_Lerp(rad_025); case 7: return -Sin_Lerp(PI025 - rad_025); } return 0; } /// <summary>   sin    </summary> static void Ini_Mem_Sin() { double rad; mem_sin = new double[length_mem]; for (int i = 0; i < length_mem; i++) { rad = (i * PI025) / length_mem_M1; mem_sin[i] = Math.Sin(rad); } } /// <summary>   cos    </summary> static void Ini_Mem_Cos() { double rad; mem_cos = new double[length_mem]; for (int i = 0; i < length_mem; i++) { rad = (i * PI025) / length_mem_M1; mem_cos[i] = Math.Cos(rad); } } /// <summary>      sin  0  pi/4. </summary> /// <param name="rad">     0  pi/4. </param> static double Sin_Lerp(double rad) { int i_0; int i_1; double i_0d; double percent; double a; double b; double s; percent = rad / PI025; i_0d = percent * length_mem_M1; i_0 = (int)i_0d; i_1 = i_0 + 1; a = mem_sin[i_0]; b = mem_sin[i_1]; s = i_0d - i_0; return Lerp(a, b, s); } /// <summary>      cos  0  pi/4. </summary> /// <param name="rad">     0  pi/4. </param> static double Cos_Lerp(double rad) { int i_0; int i_1; double i_0d; double percent; double a; double b; double s; percent = rad / PI025; i_0d = percent * length_mem_M1; i_0 = (int)i_0d; i_1 = i_0 + 1; a = mem_cos[i_0]; b = mem_cos[i_1]; s = i_0d - i_0; return Lerp(a, b, s); } /// <summary>      . (return a + s * (b - a)) </summary> /// <param name="a">  . </param> /// <param name="b">  . </param> /// <param name="s">  . 0 = a, 1 = b, 0.5 =   a  b. </param> public static double Lerp(double a, double b, double s) { return a + s * (b - a); } }

UPD: Sin_Lerp (), Cos_Lerp (), Ini_Mem_Sin () और Ini_Mem_Cos () में सूचकांक के निर्धारण में निश्चित त्रुटि।

GPU के लिए Math.Sin (डबल) फ़ंक्शन

प्रस्तावना

प्रकाशन के कारण

माना जाता है

विश्लेषण किया गया पैरामीटर

टेलर रैंक

बहुआयामी पद

रैखिक प्रक्षेप

More articles: