C++ में हॉर्नर नियम से कुशल बहुपद मूल्यांकन

हॉर्नर विधि बहुपदों के मूल्यांकन का एक कुशल तरीका प्रदान करती है, जिससे आवश्यक गुणाओं की संख्या कम से कम होती है। यह विशेष रूप से उच्च-डिग्री बहुपदों के लिए, साधारण तरीके की तुलना में प्रदर्शन में काफी सुधार करता है। यह लेख इस रूप के बहुपद के मूल्यांकन के लिए हॉर्नर नियम के विभिन्न C++ कार्यान्वयन का पता लगाता है:

P(x) = a_nxⁿ + a_n-1x^n-1 + … + a₁x + a₀

विषयवस्तु की तालिका

• पुनरावृति दृष्टिकोण (पश्चगामी लूप)
• पुनरावृति दृष्टिकोण (अग्रगामी लूप)
• पुनरावर्ती दृष्टिकोण
• निष्कर्ष

पुनरावृति दृष्टिकोण (पश्चगामी लूप)

यह कार्यान्वयन पश्चगामी-पुनरावृति लूप का उपयोग करके सीधे हॉर्नर नियम की नेस्टेड गुणन संरचना को दर्शाता है।

#include <iostream>
#include <vector>

double hornerBackward(const std::vector<double>& coefficients, double x) {
  double result = coefficients.back(); 
  for (int i = coefficients.size() - 2; i >= 0; --i) {
    result = result * x + coefficients[i];
  }
  return result;
}

int main() {
  std::vector<double> coefficients = {2, -6, 2, -1}; 
  double x = 3;
  double result = hornerBackward(coefficients, x);
  std::cout << "The value of the polynomial at x = " << x << " is: " << result << std::endl;
  return 0;
}

पुनरावृति दृष्टिकोण (अग्रगामी लूप)

जबकि पश्चगामी पुनरावृत्ति अधिक सहज है, एक अग्रगामी लूप समान रूप से कुशल है। यह संस्करण स्थिरांक पद से पुनरावृति करता है, परिणाम को क्रमिक रूप से बनाता है।

#include <iostream>
#include <vector>

double hornerForward(const std::vector<double>& coefficients, double x) {
  double result = coefficients[0];
  for (size_t i = 1; i < coefficients.size(); ++i) {
    result = result * x + coefficients[i];
  }
  return result;
}

int main() {
  std::vector<double> coefficients = {2, -6, 2, -1}; 
  double x = 3;
  double result = hornerForward(coefficients, x);
  std::cout << "The value of the polynomial at x = " << x << " is: " << result << std::endl;
  return 0;
}

पुनरावर्ती दृष्टिकोण

हॉर्नर नियम को सुंदरतापूर्वक पुनरावर्ती रूप से लागू किया जा सकता है, जो सीधे नेस्टेड गुणन संरचना को दर्शाता है। हालाँकि, बहुत उच्च-डिग्री बहुपदों के लिए, फ़ंक्शन कॉल ओवरहेड प्रदर्शन को प्रभावित कर सकता है।

#include <iostream>
#include <vector>

double hornerRecursive(const std::vector<double>& coefficients, double x, int n) {
  if (n == 0) {
    return coefficients[0];
  } else {
    return x * hornerRecursive(coefficients, x, n - 1) + coefficients[n];
  }
}

int main() {
  std::vector<double> coefficients = {2, -6, 2, -1}; 
  double x = 3;
  double result = hornerRecursive(coefficients, x, coefficients.size() - 1);
  std::cout << "The value of the polynomial at x = " << x << " is: " << result << std::endl;
  return 0;
}

निष्कर्ष

इस लेख में हॉर्नर नियम के तीन C++ कार्यान्वयन प्रस्तुत किए गए हैं: पुनरावृति (पश्चगामी और अग्रगामी लूप) और पुनरावर्ती। जबकि पुनरावर्ती दृष्टिकोण सुंदरता प्रदान करता है, पुनरावृति विधियाँ आम तौर पर बेहतर प्रदर्शन प्रदान करती हैं, खासकर बड़े बहुपदों के लिए, कम ओवरहेड के कारण। इष्टतम विकल्प आपके अनुप्रयोग की विशिष्ट आवश्यकताओं और प्राथमिकताओं पर निर्भर करता है; हालाँकि, कुशल बहुपद मूल्यांकन के लिए हॉर्नर नियम को समझना महत्वपूर्ण है।