दिलचस्प पोस्ट
मैक पीएचपी कारीसियन माइग्रेट त्रुटि पर Laravel की स्थापना: ऐसी कोई फ़ाइल या निर्देशिका मैं कई जुड़ने वाले शब्दों को कैसे विभाजित कर सकता हूं? जावा में विरासत को निषेध करने के लिए अच्छे कारण हैं? वालग्रिंड: मेमोरी अभी भी <iostream> का उपयोग कर तुच्छ कार्यक्रम के साथ पहुंच योग्य है क्या पायथन का आदेश दिया गया सेट है? JDBC का उपयोग कर SQL सर्वर स्थानीयडीबी से कनेक्ट करना ब्लूटूथ के जरिए आईओएस और एंड्रॉयड के बीच डेटा ट्रांसफर करना है Google ऐप इंजन में तीसरे पक्ष के पायथन पुस्तकालयों को कैसे शामिल करें? 400 बैड अनुरोध HTTP त्रुटि कोड अर्थ है? मैं आईओएस पर एक कैद वीडियो में एक वॉटरमार्क कैसे जोड़ सकता / सकती हूं लिखने / लिखना बंद करने के बाद इनपुट पाठ में एक घटना को ट्रिगर कैसे करें? JUnit दावा में सरणी की तुलना, अंतर्निहित तरीके से संक्षिप्त? क्या एंड्रॉइड v2.0 का उपयोग करते हुए पॉपअपवंडो वर्ग का एक सरल उदाहरण है? आईफ्रेम से एक मूल विंडो फ़ंक्शन कॉल करना वेबपैक में jQuery प्लगिन निर्भरता को प्रबंधित करना

सन्निकटन खोज कैसे काम करता है

[प्रस्तावना]

यह क्यू एंड ए का अर्थ है कि मैं अपने अनुमानित खोज वर्ग के अंदरूनी काम को और अधिक स्पष्ट रूप से समझाता हूं जिसे मैंने पहले यहां प्रकाशित किया था

  • ट्रान्सेंडैंटल समीकरण के समाधान की सटीकता में वृद्धि

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

[सवाल]

बहुपद, पैरामीट्रिक फ़ंक्शंस के फिटिंग को प्राप्त करने के लिए वास्तविक डोमेन ( double ) में अनुमानित मान / पैरामीटर कैसे करें या (कठिन) समीकरणों को हल करें (जैसे ट्रान्सेंडैंटल)?

प्रतिबंध

  • असली डोमेन ( double सटीक)
  • सी ++ भाषा
  • सन्निकटन के विन्यास योग्यता
  • खोज के लिए ज्ञात अंतराल
  • फिट मूल्य / पैरामीटर कड़ाई से मोनोटोनिक नहीं है या सभी पर कार्य नहीं करता है

वेब के समाधान से एकत्रित समाधान "सन्निकटन खोज कैसे काम करता है"

सख्ती खोज

यह द्विआधारी खोज का सादृश्य है, लेकिन इसकी प्रतिबंधों के बिना कि O(n.log(n)) जटिलता को साझा करते हुए फ़ंक्शन / मान / पैरामीटर का सख्ती से O(n.log(n)) फ़ंक्शन होना चाहिए।

उदाहरण के लिए, निम्न समस्या मान लीजिए

हमें फ़ंक्शन y=f(x) ज्ञात है और x0 को ढूंढना है जैसे y0=f(x0) । यह मूल रूप से इनवर्स फ़ंक्शन द्वारा f करने के लिए किया जा सकता है, लेकिन कई फ़ंक्शन हैं जो हमें इसके बारे में उलटा गिनने का तरीका नहीं पता है। तो इस तरह के मामले में यह कैसे गणना करना है?

knowns

  • y=f(x) – इनपुट फ़ंक्शन
  • y0 – बिंदु y मान चाहता था
  • a0,a1 – समाधान x अंतराल श्रेणी

अननोंस

  • x0 – वांछित बिंदु x मान x0=<a0,a1> में होना चाहिए

कलन विधि

  1. कुछ बिंदुओं x(i)=<a0,a1> समानता से कुछ चरण da साथ सीमा के साथ छितरी हुई जांच करें

    इसलिए उदाहरण के लिए x(i)=a0+i*da जहां i={ 0,1,2,3... }

  2. प्रत्येक x(i) y=f(x(i)) की दूरी / त्रुटि ee की गणना करें

    इसे इस तरह उदाहरण के लिए गणना किया जा सकता है: ee=fabs(f(x(i))-y0) लेकिन किसी भी अन्य मेट्रिक्स का भी उपयोग किया जा सकता है

  3. याद बिंदु aa=x(i) न्यूनतम दूरी / त्रुटि के साथ

  4. रोक जब x(i)>a1

  5. लगातार सटीकता में वृद्धि

    तो पहले उदाहरण के लिए केवल समाधान के आस-पास खोजने के लिए सीमा को प्रतिबंधित करें:

     a0'=aa-da; a1'=aa+da; 

    फिर खोज चरण कम करके खोज की सटीकता बढ़ाएं:

     da'=0.1*da; 

    यदि da' बहुत छोटा नहीं है या यदि अधिकतम पुनरावर्ती गिनती तक नहीं पहुंच जाती तो # 1 पर जाएं

  6. पाया समाधान में aa

यह मेरे मन में है:

img1

बाईं तरफ प्रारंभिक खोज सचित्र है (बुलेट # 1, # 2, # 3, # 4 )। दाईं ओर अगले पुनरावर्ती खोज पर (बुलेट # 5 )। वांछित सटीकता तक पहुंचने तक (रिकर्सन की संख्या) यह पुनरावर्ती पाश होगा प्रत्येक पुनरावर्तन 10 गुना ( 0.1*da ) की सटीकता में वृद्धि ग्रे खड़ी रेखाएं x(i) बिंदुओं की जांच करती हैं

इसके लिए सी ++ स्रोत कोड यहां है:

 //--------------------------------------------------------------------------- //--- approx ver: 1.01 ------------------------------------------------------ //--------------------------------------------------------------------------- #ifndef _approx_h #define _approx_h #include <math.h> //--------------------------------------------------------------------------- class approx { public: double a,aa,a0,a1,da,*e,e0; int i,n; bool done,stop; approx() { a=0.0; aa=0.0; a0=0.0; a1=1.0; da=0.1; e=NULL; e0=NULL; i=0; n=5; done=true; } approx(approx& a) { *this=a; } ~approx() {} approx* operator = (const approx *a) { *this=*a; return this; } //approx* operator = (const approx &a) { ...copy... return this; } void init(double _a0,double _a1,double _da,int _n,double *_e) { if (_a0<=_a1) { a0=_a0; a1=_a1; } else { a0=_a1; a1=_a0; } da=fabs(_da); n =_n ; e =_e ; e0=-1.0; i=0; a=a0; aa=a0; done=false; stop=false; } void step() { if ((e0<0.0)||(e0>*e)) { e0=*e; aa=a; } // better solution if (stop) // increase accuracy { i++; if (i>=n) { done=true; a=aa; return; } // final solution a0=aa-fabs(da); a1=aa+fabs(da); a=a0; da*=0.1; a0+=da; a1-=da; stop=false; } else{ a+=da; if (a>a1) { a=a1; stop=true; } // next point } } }; //--------------------------------------------------------------------------- #endif //--------------------------------------------------------------------------- 

इसका उपयोग कैसे करें:

 approx aa; double ee,x,y,x0,y0=here_your_known_value; // a0, a1, da,n, ee for (aa.init(0.0,10.0,0.1,6,&ee); !aa.done; aa.step()) { x = aa.a; // this is x(i) y = f(x) // here compute the y value for whatever you want to fit ee = fabs(y-y0); // compute error of solution for the approximation search } 

for (aa.init(... नाम पर प्रारम्भ में हैं x(i) a0,a1 अंतराल है, जिस पर x(i) की जांच हो रही है, da x(i) बीच प्रारंभिक कदम है और n की संख्या है recursions.So यदि n=6 और da=0.1 x फिट की अंतिम अधिकतम त्रुटि ~0.1/10^6=0.0000001&ee चर में सूचक है, जहां वास्तविक त्रुटि की गणना होगी.मैं सूचक का चयन इसलिए वहाँ नहीं कर रहे हैं घोंसले के शिकार होने पर टकराव

[टिप्पणियाँ]

यह सन्निकटन खोज किसी भी आयामी (लेकिन मोटे तौर पर आपको गति के बारे में सावधान रहने की आवश्यकता है) के लिए नेस्टेड किया जा सकता है कुछ उदाहरण देखें

  • सबसे अच्छा फिट के साथ वक्र को एन अंक का सपना
  • दोहराया एक्स स्थिति (गैलेक्सी सर्पिल हथियार) पर वाई अंक के साथ वक्र फिटिंग
  • ट्रान्सेंडैंटल समीकरण के समाधान की सटीकता में वृद्धि
  • सी ++ में बिन्दुओं के एक सेट को संलग्न करना न्यूनतम क्षेत्र अंडाकार खोजें

गैर-फ़ंक्शन के मामले में और "सभी" समाधान प्राप्त करने की आवश्यकता में आप किसी अन्य समाधान की जांच करने के लिए समाधान के बाद खोज अंतराल के पुनरावर्ती उपखंड का उपयोग कर सकते हैं। उदाहरण देखें:

  • एक एक्स के समन्वय को देखते हुए, मैं एक बिंदु के लिए वाई के समन्वय की गणना कैसे करूं, ताकि यह एक बेज़िएर कर्व पर निर्भर हो

आपको किस बारे में पता होना चाहिए?

आपको सावधानी से खोज अंतराल <a0,a1> चुनना होगा ताकि इसमें समाधान हो लेकिन बहुत अधिक विस्तृत नहीं है (या यह धीमा होगा)। प्रारंभिक कदम da बहुत ही महत्वपूर्ण है यदि यह बहुत बड़ा है तो आप स्थानीय न्यूनतम / अधिकतम समाधान याद कर सकते हैं या यदि बहुत छोटी बात बहुत धीमी हो जाएगी (विशेषकर नेस्टेड बहुआयामी फ़िट के लिए)।

secant और bisection विधि का एक संयोजन बहुत बेहतर है:

यहां छवि विवरण दर्ज करें

हम secants द्वारा रूट अनुमानों को खोजते हैं, और द्विभाजन के रूप में रूट ब्रैकेट युक्त रखें।

यहां छवि विवरण दर्ज करें

हमेशा अंतराल के दो किनारों को रखें ताकि एक किनारे पर डेल्टा ऋणात्मक हो, और दूसरी ओर यह सकारात्मक है, इसलिए जड़ की अंदर की गारंटी है; और हेलविंग के बजाय, सिक्यंट विधि का उपयोग करें।

स्यूडोकोड:

 given a function f given two points a, b, such that a < b and sign(f(a)) /= sign(f(b)) given tolerance tol find root z of f such that abs(f(z)) < tol -- stop_condition DO: x = root of f by linear interpolation of f between a and b m = midpoint between a and b if stop_condition holds at x or m, set z and STOP [a,b] := [a,x,m,b].sort.choose_shortest_interval_with_ _opposite_signs_at_its_ends 

यह स्पष्ट रूप से प्रत्येक आवृत्ति पर अंतराल [a,b] या बेहतर करता है; इसलिए जब तक कि समारोह बेहद बुरा व्यवहार नहीं करता (जैसे, कहते हैं, x=0 पास sin(1/x) ), यह बहुत तेज़ हो जाएगा, प्रत्येक चरण चलने के लिए सबसे ज्यादा f केवल दो मूल्यांकन ले लेंगे।

और हम बुरे व्यवहार के मामलों का पता लगा सकते हैं कि ba बहुत छोटा नहीं हो जाता है (अगर हम परिमित परिशुद्धता के साथ काम कर रहे हैं, डबल्स के रूप में)।