Python में बहुपद (polynomial) समीकरण की गणना करने के लिए गुणांकों की सूची और चर के मान का उपयोग किया जाता है। मानक रूप: aₙxⁿ + aₙ₋₁xⁿ⁻¹ + ... + a₁x + a₀
हॉर्नर की विधि (Horner's Method) - कुशल दृष्टिकोण
यह विधि कम गुणा ऑपरेशन्स का उपयोग करती है और संख्यात्मक रूप से स्थिर होती है।
def evaluate_polynomial(coeffs, x):
"""
बहुपद का मान निकालें: coeffs[0]*x^n + coeffs[1]*x^(n-1) + ... + coeffs[n]
जहां coeffs = [a_n, a_{n-1}, ..., a_0] (उच्चतम घात से स्थिरांक तक)
"""
result = 0
for coeff in coeffs:
result = result * x + coeff
return result
# उदाहरण: 3x^7 - 6x^6 + 3x^5 - x^4 + 23x^3 - 11x^2 + 0x - 8, x=3 पर
coeffs = [3, -6, 3, -1, 23, -11, 0, -8]
x = 3
print(f"P({x}) = {evaluate_polynomial(coeffs, x)}") # 3349
मूल लेख की विधि (नेस्टेड लूप)
# मूल लेख का दृष्टिकोण (कम कुशल)
my_list = [3, -6, 3, -1, 23, -11, 0, -8]
x = 3
my_list_length = len(my_list)
my_result = 0
for i in range(my_list_length):
my_sum = my_list[i]
for j in range(my_list_length - i - 1):
my_sum = my_sum * x
my_result = my_result + my_sum
print("मूल विधि परिणाम:", my_result) # 3349
आउटपुट
मूल विधि परिणाम: 3349
हॉर्नर विधि परिणाम: 3349
NumPy के साथ (सबसे सरल)
import numpy as np
coeffs = [3, -6, 3, -1, 23, -11, 0, -8]
x = 3
# np.polyval गुणांकों को उच्चतम घात से निम्नतम की अपेक्षा करता है
result = np.polyval(coeffs, x)
print(f"NumPy polyval: {result}") # 3349.0
# बहुपद ऑब्जेक्ट बनाएं
p = np.polynomial.Polynomial(coeffs[::-1]) # NumPy निम्नतम से उच्चतम क्रम चाहता है
print(f"Polynomial ऑब्जेक्ट: {p(x)}") # 3349.0
सिम्बॉलिक गणना (SymPy)
import sympy as sp
x = sp.symbols('x')
# बहुपद परिभाषित करें
poly = 3*x**7 - 6*x**6 + 3*x**5 - x**4 + 23*x**3 - 11*x**2 + 0*x - 8
# मान निकालें
val = poly.subs(x, 3)
print(f"SymPy परिणाम: {val}") # 3349
# विस्तारित रूप देखें
print(f"बहुपद: {poly.expand()}")
व्यावहारिक उदाहरण
def polyval(coeffs, x):
"""बहुपद मान निकालें - हॉर्नर की विधि"""
return sum(c * (x ** i) for i, c in enumerate(reversed(coeffs)))
# टेस्ट केस
test_cases = [
([1, -2, 1], 2), # x^2 - 2x + 1 = (x-1)^2, x=2 पर 1
([1, 0, -1], 3), # x^2 - 1, x=3 पर 8
([2, 3, 1], 2), # 2x^2 + 3x + 1, x=2 पर 15
([1, -3, 3, -1], 2), # x^3 - 3x^2 + 3x - 1 = (x-1)^3, x=2 पर 1
]
for coeffs, x_val in test_cases:
print(f"गुणांक {coeffs}, x={x_val}: {polyval(coeffs, x_val)}")
आउटपुट
गुणांक [1, -2, 1], x=2: 1
गुणांक [1, 0, -1], x=3: 8
गुणांक [2, 3, 1], x=2: 15
गुणांक [1, -3, 3, -1], x=2: 1
मूल लेख के कोड की व्याख्या
मूल कोड में नेस्टेड लूप का उपयोग है:
- बाहरी लूप: प्रत्येक गुणांक के लिए
- आंतरिक लूप: गुणांक को x से उचित घात तक गुणा करता है
- समय जटिलता: O(n²) - द्विघात
- हॉर्नर की विधि: O(n) - रैखिक, अधिक कुशल
सारांश
| विधि | समय जटिलता | उपयोग में आसानी | सटीकता |
|---|---|---|---|
| नेस्टेड लूप (मूल) | O(n²) | मध्यम | अच्छी |
| हॉर्नर की विधि | O(n) | आसान | उत्कृष्ट (संख्यात्मक स्थिरता) |
| NumPy polyval | O(n) | सबसे आसान | उत्कृष्ट |
| SymPy | O(n) | मध्यम | सटीक (सिम्बॉलिक) |