सबसे अधिक संभावना है, आप स्कूल से निम्नलिखित अनुपात जानते हैं:

$$

$$\ sin \ \ cos \ beta - \ sin \ Alpha \ गुना \ sin \ beta$$

जब आप पहली बार बचपन में इस सूत्र से परिचित हुए, तो सबसे अधिक संभावना है, आपकी पहली भावना इस तथ्य के कारण दर्द थी कि इस सूत्र को याद किया जाना चाहिए। यह बहुत बुरा है, क्योंकि वास्तव में आपको इस सूत्र को याद रखने की आवश्यकता नहीं है - यह तब प्रदर्शित होता है जब आप कागज पर त्रिकोण को घुमाते हैं। वास्तव में, मैं ऐसा ही करता हूं जब मैं इस सूत्र को लिखता हूं। यह व्याख्या इस लेख के मध्य तक स्पष्ट होगी। लेकिन अब, बाद में सभी मौज-मस्ती को छोड़ने और उस क्षण को स्थगित करने के लिए जब आप कहते हैं "यूरेका!", आइए इस बारे में सोचें कि हमें इस सूत्र के बारे में क्यों सोचना चाहिए।

प्रविष्टि

त्रिकोणमितीय कार्य sin() और cos() शायद कंप्यूटर ग्राफिक्स में सबसे लोकप्रिय हैं, क्योंकि वे किसी भी गोल आकार को पैरामीट्रिक तरीके से वर्णन करने का आधार हैं। उनके संभावित अनुप्रयोग के स्थानों में सर्कल की पीढ़ी या क्रांति की बड़ी वस्तुएं हैं, जब फूरियर रूपांतरण, जल विमान पर तरंगों की प्रक्रियात्मक पीढ़ी की गणना, एक सॉफ्टवेयर ध्वनि सिंथेसाइज़र के लिए जनरेटर, और इसी तरह। इन सभी मामलों में, sin() और cos() को लूप के अंदर कहा जाता है, जैसे कि:

 for(int n=0; n < num; n++) { const float t = 2.0f*PI*(float)n/(float)num; const float s = sinf(t); const float c = cosf(t); // do something with s and c ... } 

हम चक्र को फिर से लिखना शुरू करते हैं (नीचे दिए गए कोड को देखें), इसलिए हमारे लिए यह कल्पना करना आसान है कि चरण t साथ इस चक्र के पुनरावृत्ति n , अगला पुनरावृत्ति, n+1 , sin() और cos() लिए t+f विचार करेगा। दूसरे शब्दों में, sin(t) और cos(t) हमारे लिए गिने जाते हैं और हमें sin(t+f) और cos(t+f) गिनने की आवश्यकता है:

 const float f = 2.0f*PI/(float)num; const float t = 0.0f; for( int n=0; n < num; n++ ) { const float s = sinf(t); const float c = cosf(t); // do something with s and c ... t += f; } 

इससे कोई फर्क नहीं पड़ता है कि हमें t कैसे मिली और इसके मूल्यों की सीमा क्या है (ऊपर के उदाहरण में - $$$[0; 2 \ pi]$ )। केवल एक चीज जो हमें परेशान करती है वह यह है कि एक लूप है जो लगातार sin() और cos() को एक पैरामीटर के साथ कहता है जो निरंतर चरणों में बढ़ता है (इस मामले में, $$$\ frac {2 \ pi} {\ text {संख्या}}$ )। यह आलेख इस कोड को गति के लिए इस तरह से अनुकूलित करने के तरीके के बारे में है कि sin() या cos() फ़ंक्शन (इनर लूप में) या यहां तक ​​कि तेज sincos() फ़ंक्शन का उपयोग किए बिना एक ही गणना की जा सकती है।

लेकिन यदि आप लेख में पहले सूत्र को देखते हैं, तो हम देखेंगे कि यदि $$$च = \ अल्फा$ और $$$t = \ बीटा$ हम इसे फिर से लिख सकते हैं

 sin(t+f) = sin(f)*cos(t) + cos(f)*sin(t) cos(t+f) = cos(f)*cos(t) - sin(f)*sin(t) 

या दूसरे शब्दों में

 new_s = sin(f)*old_c + cos(f)*old_s new_c = cos(f)*old_c - sin(f)*old_s 

चूँकि f एक स्थिर है, sin(f) और cos(f) भी। क्रमशः उन्हें a और b कहें:

 new_s = b*old_c + a*old_s new_c = a*old_c - b*old_s 

यह अभिव्यक्ति सीधे हमारे कोड में उपयोग की जा सकती है, और फिर हमें एक लूप मिलता है जिसमें महंगे (और वास्तव में नहीं) त्रिकोणमितीय फ़ंक्शन कहलाते हैं!

 const float f = 2.0f*PI/(float)num; const float a = cosf(f); const float b = sinf(f); float s = 0.0f; float c = 1.0f; for( int n=0; n < num; n++ ) { // do something with s and c ... const float ns = b*c + a*s; const float nc = a*c - b*s; c = nc; s = ns; } 

व्याख्या

अब तक, हम आँख बंद करके गणित के साथ खेल रहे हैं, यह नहीं समझ रहे हैं कि वास्तव में क्या हो रहा है। आइए इस तरह से आंतरिक लूप को फिर से लिखें:

$$

$$s_ {n + 1} = s_na + c_nb \\ c_ {n + 1} = c_na - s_nb$$

आप में से कुछ ने देखा होगा कि यह दो-आयामी अंतरिक्ष में किसी वस्तु को घुमाने का एक सूत्र है। यदि आप अभी भी इसे नहीं समझते हैं, तो शायद मैट्रिक्स फॉर्म आपकी मदद करेगा।

$$

$$\ छोड़ दिया (\ शुरू {मैट्रिक्स} s_ {n + 1} \\ c_ {n + 1} \ अंत {मैट्रिक्स} \ सही) = \ बाएं (\ शुरू {मैट्रिक्स} एक & b \\ -b & a \ अंत {मैट्रिक्स} \ राइट) \ cdot \ left (\ start {मैट्रिक्स} s_ {n} \\ c_ {n} \ end {मैट्रिक्स} \ राइट)$$

वास्तव में, sin(t) और cos(t) को लंबाई 1 के वेक्टर में वर्गीकृत किया जा सकता है और स्क्रीन पर एक बिंदु के रूप में खींचा जा सकता है। इस वेक्टर x कॉल करें। फिर, $$$x = \ {\ sin \ beta, \ cos \ beta \}$ । तो अभिव्यक्ति का वेक्टर रूप है $$$x_ {n + 1} = Rx_n$ जहाँ $$$R = \ left (\ start {मैट्रिक्स} a & b \\ - b & a \ end {मैट्रिक्स} \ right)$ । हम देखते हैं कि हमारा लूप प्रत्येक पुनरावृत्ति को एक छोटे से दो-आयामी रोटेशन करता है ताकि चक्र के निष्पादन के दौरान x एक सर्कल में घूम जाए। प्रत्येक पुनरावृति x द्वारा घूमता है $$$\ frac {2 \ pi} {\ text {संख्या}}$ रेडियंस।
तो मूल रूप से

$$

$$\ sin \ \ cos \ beta - \ sin \ Alpha \ गुना \ sin \ beta$$

यह बिंदु गति सूत्र है $$$x = \ {\ cos \ Alpha, \ sin \ Alpha \}$ की वृद्धि में परिधि $$$\ बीटा$ रेडियंस। ऐसा करने के लिए, हम दो रोटेशन अक्षों में से एक का निर्माण करेंगे, उदाहरण के लिए, $$$u = \ {\ cos \ beta, \ sin \ beta \}$ । रोटेशन का पहला घटक प्रक्षेपण है। $$$x$ पर $$$यू$ । क्योंकि $$$x$ और $$$यू$ सामान्यीकृत (1 की लंबाई है), प्रक्षेपण उनका अदिश उत्पाद है। इसलिए, $$$s = x \ cdot u = \ sin \ Alpha \ cdot \ cos \ beta + \ cos \ Alpha \ cdot \ \ \ $$ , और निश्चित रूप से दूसरा घटक एंटी-प्रोजेक्शन है, जिसे लंबवत अक्ष पर प्रोजेक्ट करके पाया जा सकता है, $$$वी$ । हम निर्देशांक का विस्तार करके इस वेक्टर को बना सकते हैं $$$यू$ और पहले समन्वय में विपरीत को संकेत बदलें: $$$c = x \ cdot v = \ cos \ Alpha \ cdot \ cos \ beta + \ sin \ Alpha \ cdot \ \ \ $$

नोट

आमतौर पर आपको बार-बार इन छोटे घुमावों को करने में सक्षम होना चाहिए। वास्तव में $$$| R | = \ बाएँ | \ start {मैट्रिक्स} a & b \\ - b & a \ end {मैट्रिक्स} \ right | = a ^ 2 + b ^ 2 = \ sin ^ 2 \ अल्फा + \ cos ^ 2 \ अल्फा = 1$ , जिसका मतलब है कि मैट्रिक्स $$$आर$ जिस स्थान पर इसे लागू किया जाता है, उसका स्थान घटता या बढ़ता नहीं है, जिसका अर्थ है $$$x$ एक सही सर्कल में कदम होगा। हालाँकि, क्योंकि कंप्यूटर सटीक नहीं हैं, $$$x$ एक सर्पिल में चलेगा और अंततः रोटेशन के सर्कल के केंद्र के साथ मेल खाता है। मुझे ऐसी समस्याएं नहीं थीं, लेकिन मुझे लगता है कि वे बहुत बड़ी num साथ हो सकते हैं, अर्थात। छोटे मोड़ कोण।

उदाहरण

किंडरक्रैशर में , 2008 से 4096-बाइट डेमो (केडीपीवी पर स्क्रीनशॉट), गोले का एक समूह संगीत के लिए स्पंदित करता है। इसके लिए, मैंने ध्वनि के फूरियर रूपांतरण को गिना। ऐसे एल्गोरिदम हैं जो वास्तविक समय में ऐसा करते हैं, उदाहरण के लिए, एफएफटी । हालांकि, मेरा कोड कुछ किलोबाइट में फिट होना चाहिए, और मैंने दूसरे रास्ते पर जाने का फैसला किया। एफएफटी को लागू करने के बजाय, मैंने इसकी सरल परिभाषा से डीएफटी लिखा। आप इसे विकिपीडिया पर देख सकते हैं।

$$

$$X_k = \ sum_ {n = 0} ^ {N-1} {x_ne ^ {- \ frac {2 \ _ pi i} {N} kn}} \ quad k = 0,1, \ ldots, N-1$$

मेरा फ़ंक्शन 16-बिट स्टीरियो ऑडियो बफर, x भी लेता है, और ध्वनि y के ध्वनि स्पेक्ट्रम के पहले 128 आवृत्तियों को लौटाता है। देखें कि आंतरिक लूप का आयोजन कैसे किया जाता है, जो 4096 बार चलता है: sin() या cos() फ़ंक्शन के लिए एक कॉल नहीं, हालांकि अन्य कार्यान्वयन में ये कॉल होंगे।

 #include <math.h> void iqDFT12( float *y, const short *x ) { for( int i=0; i<128; i++ ) { const float wi = (float)i*(2.0f*3.1415927f/4096.0f); const float sii = sinf( wi ); const float coi = cosf( wi ); float co = 1.0f; float si = 0.0f; float acco = 0.0f; float acsi = 0.0f; for( int j=0; j<4096; j++ ) { const float f = (float)(x[2*j+0]+x[2*j+1]); const float oco = co; acco += co*f; co = co*coi - si*sii; acsi += si*f; si = si*coi + oco*sii; } y[i] = sqrtf(acco*acco+acsi*acsi)*(1.0f/32767.0f); } }