मुझे एक एल्गोरिथ्म की आवश्यकता है जो है
- छोटी शाखा (उम्मीद है CMOVs)
- कोई त्रिकोणमितीय फ़ंक्शन कॉल नहीं
- 32 बिट फ्लोट के साथ उच्च संख्यात्मक सटीकता
हम निम्न प्रकार से और गणना करना चाहते हैं:c1,s1,c2,s2,σ1σ2
A=USV , जिसे बढ़ाया जा सकता है जैसे:
[acbd]=[c1−s1s1c1][σ100σ2][c2s2−s2c2]
मुख्य विचार एक घूर्णन मैट्रिक्स को खोजना है जो विकर्ण करता है, यह विकर्ण है।VATAVATAVT=D
याद करें कि
USV=A
US=AV−1=AVT (चूंकि ऑर्थोगोनल है)V
VATAVT=(AVT)TAVT=(US)TUS=STUTUS=D
दोनों पक्षों को गुणा करके हम प्राप्त करते हैंS−1
(S−TST)UTU(SS−1)=UTU=S−TDS−1
चूंकि विकर्ण है, को सेट करने से हमें मिलेगी , जिसका अर्थ है कि एक घूर्णन मैट्रिक्स है, एक विकर्ण मैट्रिक्स है, एक घूर्णन मैट्रिक्स और , बस जिसे हम देख रहे हैं। के लिये।DSD−−√UTU=IdentityUSVUSV=A
विकर्ण रोटेशन की गणना निम्नलिखित समीकरण को हल करके की जा सकती है:
t22−β−αγt2−1=0
कहा पे
ATA=[abcd][acbd]=[a2+c2ab+cdab+cdb2+d2]=[αγγβ]
और , के कोण का स्पर्शरेखा है । यह विस्तार करके और इसके ऑफ-विकर्ण तत्वों को शून्य के बराबर बनाकर (वे एक-दूसरे के बराबर हैं) हो सकते हैं।t2VVATAVT
इस विधि के साथ समस्या यह है कि यह महत्वपूर्ण फ्लोटिंग पॉइंट सटीक खो देता है जब गणना में घटाव के कारण कुछ मैट्रिसेस के लिए और की गणना की जाती है। इसका समाधान पहले एक आरक्यू अपघटन ( , ऊपरी त्रिकोणीय और ऑर्थोगोनल) करना है, फिर को फैक्ट करने के लिए एल्गोरिथ्म का उपयोग करें । यह । सूचना कैसे स्थापित करने 0 (के रूप में ) अतिरिक्त / subtractions से कुछ दूर करता है। (मैट्रिक्स उत्पाद के विस्तार से आरक्यू अपघटन काफी तुच्छ है)।β−αγA=RQRQUSV′=RUSV=USV′Q=RQ=AdR
एल्गोरिथ्म ने इस तरह लागू किया कुछ संख्यात्मक और तार्किक विसंगतियाँ हैं (उदाहरण के लिए या ), जो मैंने नीचे दिए गए कोड में तय किया है।S +D−−√−D−−√
मैंने लगभग 2000 मिलियन रैंडमाइज्ड मेट्रिसेस को कोड में फेंक दिया, और निर्मित सबसे बड़ी संख्यात्मक त्रुटि लगभग (32 बिट फ़्लोट, ) के साथ थी। एल्गोरिथ्म लगभग 340 घड़ी चक्र (MSVC 19, आइवी ब्रिज) में चलता है।6⋅10−7error=||USV−M||/||M||
template <class T>
void Rq2x2Helper(const Matrix<T, 2, 2>& A, T& x, T& y, T& z, T& c2, T& s2) {
T a = A(0, 0);
T b = A(0, 1);
T c = A(1, 0);
T d = A(1, 1);
if (c == 0) {
x = a;
y = b;
z = d;
c2 = 1;
s2 = 0;
return;
}
T maxden = std::max(abs(c), abs(d));
T rcmaxden = 1/maxden;
c *= rcmaxden;
d *= rcmaxden;
T den = 1/sqrt(c*c + d*d);
T numx = (-b*c + a*d);
T numy = (a*c + b*d);
x = numx * den;
y = numy * den;
z = maxden/den;
s2 = -c * den;
c2 = d * den;
}
template <class T>
void Svd2x2Helper(const Matrix<T, 2, 2>& A, T& c1, T& s1, T& c2, T& s2, T& d1, T& d2) {
// Calculate RQ decomposition of A
T x, y, z;
Rq2x2Helper(A, x, y, z, c2, s2);
// Calculate tangent of rotation on R[x,y;0,z] to diagonalize R^T*R
T scaler = T(1)/std::max(abs(x), abs(y));
T x_ = x*scaler, y_ = y*scaler, z_ = z*scaler;
T numer = ((z_-x_)*(z_+x_)) + y_*y_;
T gamma = x_*y_;
gamma = numer == 0 ? 1 : gamma;
T zeta = numer/gamma;
T t = 2*impl::sign_nonzero(zeta)/(abs(zeta) + sqrt(zeta*zeta+4));
// Calculate sines and cosines
c1 = T(1) / sqrt(T(1) + t*t);
s1 = c1*t;
// Calculate U*S = R*R(c1,s1)
T usa = c1*x - s1*y;
T usb = s1*x + c1*y;
T usc = -s1*z;
T usd = c1*z;
// Update V = R(c1,s1)^T*Q
t = c1*c2 + s1*s2;
s2 = c2*s1 - c1*s2;
c2 = t;
// Separate U and S
d1 = std::hypot(usa, usc);
d2 = std::hypot(usb, usd);
T dmax = std::max(d1, d2);
T usmax1 = d2 > d1 ? usd : usa;
T usmax2 = d2 > d1 ? usb : -usc;
T signd1 = impl::sign_nonzero(x*z);
dmax *= d2 > d1 ? signd1 : 1;
d2 *= signd1;
T rcpdmax = 1/dmax;
c1 = dmax != T(0) ? usmax1 * rcpdmax : T(1);
s1 = dmax != T(0) ? usmax2 * rcpdmax : T(0);
}
से विचार:
http://www.cs.utexas.edu/users/inderjit/public_papers/HLA_SVD.pdf
http://www.math.pitt.edu/~sussmanm/2071Sprn08/lab09/index.html
http: // www.lucidarme.me/singular-value-decomposition-of-a-2x2-matrix/