सी ++

Question

में क्वाड्रैटिक समीकरण हल करें मैं सी ++ में एक फ़ंक्शन लिखने की कोशिश कर रहा हूं जो वर्ग के समीकरण का उपयोग कर एक्स के लिए हल करता है। यह वही है मैं शुरू में लिखा है, जो जब तक एक जवाब के लिए कोई जटिल नंबर दिए गए हैं काम करने के लिए लगता है:

float solution1 = (float)(-1.0 * b) + (sqrt((b * b) - (4 * a * c))); 
solution1 = solution1/(2*a); 

cout << "Solution 1: " << solution1 << endl; 

float solution2 = (float)(-b) - (sqrt((b*b) - (4 * a * c))); 
solution2 = solution2/(2*a); 
cout << "Solution 2: " << solution2; 

, उदाहरण के लिए, मैं समीकरण का उपयोग करें: x^2 - x - 6, मैं समाधान 3, -2 सही ढंग से प्राप्त करें।

मेरा प्रश्न मैं जटिल संख्या के लिए कैसे खाते हैं, उदाहरण के लिए .... समीकरण दिया है:

x^2 + 2x + 5

हाथ से हल, मैं मिलेगा -1 + 2i, -1 - 2i।

ठीक है, मुझे लगता है कि दो प्रश्न हैं, क्या मैं ऊपर से बेहतर लिख सकता हूं और इसे जटिल संख्या के लिए भी खाता बना सकता हूं?

किसी भी मदद के लिए धन्यवाद!

Answer 1

कुछ इस तरह काम करेंगे:

struct complex { double r,i; } 
struct pair<T> { T p1, p2; } 

pair<complex> GetResults(double a, double b, double c) 
{ 
    pair<complex> result={0}; 

    if(a<0.000001) // ==0 
    { 
    if(b>0.000001) // !=0 
     result.p1.r=result.p2.r=-c/b; 
    else 
     if(c>0.00001) throw exception("no solutions"); 
    return result; 
    } 

    double delta=b*b-4*a*c; 
    if(delta>=0) 
    { 
    result.p1.r=(-b-sqrt(delta))/2/a; 
    result.p2.r=(-b+sqrt(delta))/2/a; 
    } 
    else 
    { 
    result.p1.r=result.p2.r=-b/2/a; 
    result.p1.i=sqrt(-delta)/2/a; 
    result.p2.i=-sqrt(-delta)/2/a; 
    } 

    return result; 
} 

इस तरह आप दोनों वास्तविक और जटिल परिणामों के लिए एक समान तरीके से परिणाम प्राप्त (वास्तविक परिणाम केवल 0 के लिए काल्पनिक भाग सेट है)। बढ़ावा के साथ भी सुंदर दिखेंगे!

संपादित करें: डेल्टा चीज़ के लिए तय किया गया है और एक = 0 जैसे अपमानजनक मामलों के लिए एक चेक जोड़ा गया है। नींद की रात ftl!

Answer 2

आप इसे कम या ज्यादा रखते हैं, बस यह देखने के लिए जांचें कि वर्ग रूट के अंदर का हिस्सा नकारात्मक है और फिर अपनी कटौती में अलग से ट्रैक रखें।

Answer 3

एक sidenote के रूप में: विभाजित करते समय, हमेशा जांचें कि denominator शून्य नहीं है या नहीं। आप मूल रूप से सिर्फ std::complex<float> बजाय float का उपयोग जटिल संख्या के लिए समर्थन प्राप्त करने के सकता है

#inlcude <float.h> 
if (fabs(a) < FLT_EPSILON) 
    then a is considered 0 

Answer 4

: और चल बिन्दु संख्या की तरह कुछ का उपयोग करने के लिए याद है।

Answer 5

Blindy से विचार Nicking:

typedef std::complex<double> complex; 
using std::pair; 
pair<complex> GetResults(double a, double b, double c) 
{ 
    double delta=(b*b-4*a*c); 
    double inv_2a = 1/2/a; 
    if(delta >= 0) { 
    double root = sqrt(delta); 
    return std::make_pair(
     complex((-b-root)*inv_2a), 
     complex((-b+root)*inv_2a); 
    } else { 
    double root = sqrt(-delta); 
    return std::make_pair(
     complex(-b*inv_2a, -root*inv_2a)), 
     complex(-b*inv_2a, +root*inv_2a))); 
    } 
} 

Answer 6

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

अच्छी तरह से ज्ञात समाधान (-b + - sqrt (ख^2 - 4ac))/2 ए गणना में गैर मजबूत होने के लिए जब एसी बहुत छोटा b^2 करने का संचालन किया है जाना जाता है, क्योंकि एक दो बहुत ही समान मूल्यों को घटा रहा है। अन्य रूट के लिए कम ज्ञात समाधान 2c/(-b - + sqrt (b^2 -4ac)) का उपयोग करना बेहतर है।

एक मजबूत समाधान के रूप में गणना की जा सकती:

temp = -0.5 * (b + sign(b) * sqrt(b*b - 4*a*c); 
x1 = temp/a; 
x2 = c/temp; 

हस्ताक्षर के उपयोग (ख) सुनिश्चित करता है कि हम इसी तरह के दो मूल्यों घटाकर नहीं कर रहे हैं।

ओपी के लिए, अन्य पोस्टर्स द्वारा दिखाए गए जटिल संख्याओं के लिए इसे संशोधित करें।

Answer 7

मैंने 'math.h' हेडर का उपयोग किए बिना प्रोग्राम की कोशिश की और विभिन्न तर्कों का भी प्रयास किया ... लेकिन मेरा प्रोग्राम केवल उन वर्गिक समीकरणों का उत्तर दे सकता है जिनमें 'x वर्ग' का गुणांक एक ..... और कहां है 'एक्स' के गुणांक को दो संख्याओं के अतिरिक्त के रूप में व्यक्त किया जा सकता है जो निरंतर अवधि के कारक हैं। उदाहरण के लिए। एक्स वर्ग + 8x + 16; एक्स वर्ग + 7x + 12; इत्यादि यहां 8 = 4 + 4 & 16 = 4 * 4; यहां एक्स के गुणांक को दो संख्याओं के अतिरिक्त के रूप में व्यक्त किया जा सकता है जो स्थिर अवधि 16 के कारक हैं ... मैं स्वयं से पूरी तरह संतुष्ट नहीं हूं लेकिन वर्गबद्ध समीकरण को हल करने के लिए सूत्र का उपयोग किए बिना कुछ अलग करने की कोशिश की। कोड है;

 #include<iostream.h> 
     #include<conio.h> 
     class quadratic 
       { 
       int b,c ; 
       float l,k; 
       public: 
       void solution(); 
       }; 
     void quadratic::solution() 
      { 
       cout<<"Enter coefficient of x and the constant term of the quadratic eqn where coefficient of x square is one"; 
       cin>>b>>c; 

       for(l=1;l<b;l++) 
        { 
        for(k=1;k<b;k++) 
        { 
        if(l+k==b&&l*k==c) 
         { 
          cout<<"x="<<-l<<"\t"<<"or"<<"\t"<<"x="<<-k; 
          cout<<"\n"; 
         } 
        } 
       } 
      } 
       void main() 
       { 
        quadratic a; 
        clrscr(); 
        a.solution(); 
        getch(); 
       }