🤜 🏏 💹 अजगर में फजी त्रिकोणीय संख्याओं के साथ प्रतीकात्मक अभिव्यक्तियों की गणना करें 💯 ❣️ 🍆

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

आवश्यकताएँ:

प्रोग्रामिंग भाषा अजगर 3.x (लेख में प्रदान किया गया कोड अजगर 3.5 पर परीक्षण किया गया था)
हमदर्द पुस्तकालय , टर्मिनल (कंसोल) के माध्यम से स्थापित किया जा सकता है:
```
pip install sympy 
```

समस्या को हल करने की प्रक्रिया:

हम पुस्तकालयों को जोड़ते हैं
```
 from fractions import Fraction import re from typing import Iterable from random import random import sympy 
```
कनेक्शन अंश वैकल्पिक हैं, हम अंश के रूप में वास्तविक संख्या को स्टोर करने के लिए फ़्रैक्शन का उपयोग करेंगे (सटीकता की हानि को कम करने के लिए)। हम स्ट्रिंग को पार्स करने के लिए पुनः लाइब्रेरी का उपयोग करेंगे और स्वचालित रूप से वर्ण चर की एक सूची तैयार करेंगे।

टाइपिंग लाइब्रेरी का उपयोग करना वैकल्पिक है; हम इसका उपयोग फ़ंक्शन मापदंडों के प्रकारों को स्पष्ट रूप से इंगित करने के लिए करते हैं। फ़र्ज़ी वैरिएबल के लिए परीक्षण मान उत्पन्न करने के लिए रैंडम लाइब्रेरी का उपयोग किया जाएगा। सिम्पी पायथन में चरित्र गणना के लिए एक महान पुस्तकालय है, इसके साथ हम अभिव्यक्ति स्ट्रिंग के साथ ही काम करेंगे।

हम उन पर फजी त्रिकोणीय संख्याओं और संचालन के वर्ग का वर्णन करते हैं। इस उदाहरण में, तीन ऑपरेशन पर्याप्त हैं (इसके अलावा, घटाव और विभाजन)। हम इसी वर्ग के "जादू" तरीकों के अधिभार का उपयोग करके संचालन शुरू करेंगे:

 class FuzzyTriangular(object): """  FuzzyTriangular""" def __init__(self, floatdigit = None, ABC = None, CAB = None, CDD = None): super(FuzzyTriangular, self).__init__() if ABC or floatdigit: if isinstance(floatdigit, (int, float)): self._a = Fraction(floatdigit) # "0" self._b = Fraction(floatdigit) # ("1") self._c = Fraction(floatdigit) # "0" elif isinstance(floatdigit, (tuple,list)): if len(floatdigit) == 2: #    self._a = Fraction(floatdigit[0] - abs(floatdigit[1])) # "0" self._b = Fraction(floatdigit[0]) # ("1") self._c = Fraction(floatdigit[0] + abs(floatdigit[1])) # "0" else: #3  ,   3 self._a = Fraction(floatdigit[0]) # "0" self._b = Fraction(floatdigit[1]) # ("1") self._c = Fraction(floatdigit[2]) # "0" else: self._a = Fraction(ABC[0]) # "0" self._b = Fraction(ABC[1]) # ("1") self._c = Fraction(ABC[2]) # "0" self._center = self._b # self._alpha = self._b - self._a #    self._beta = self._c - self._b #    self._d = (self._alpha + self._beta)/2 self._delta = (self._beta - self._alpha)/2 elif CAB: self._center = Fraction(CAB[0]) # self._alpha = Fraction(CAB[1]) #    self._beta = Fraction(CAB[2]) #    self._d = (self._alpha + self._beta)/2 self._delta = (self._beta - self._alpha)/2 self._b = self._center # ("1") self._a = self._center - self._alpha # "0" self._c = self._center + self._beta # "0" elif CDD: self._center = Fraction(CDD[0]) # self._d = Fraction(CDD[1]) self._delta = Fraction(CDD[2]) self._alpha = self._d - self._delta #    self._beta = self._d + self._delta #    self._b = self._center # ("1") self._a = self._center - self._alpha # "0" self._c = self._center + self._beta # "0" else: raise Exception("No input data to create class") def __repr__(self): return str((round(float(self._a), 12), round(float(self._b), 12),\ round(float(self._c), 12))) def __CDD_add(self, other): center = self._center + other._center d = self._d + other._d delta = self._delta + other._delta return FuzzyTriangular(CDD = (center, d, delta)) def __CDD_sub(self, other): center = self._center - other._center d = self._d + other._d delta = self._delta - other._delta return FuzzyTriangular(CDD = (center, d, delta)) def __CDD_mul(self, other): center = self._center*other._center d = abs(self._center)*other._d + abs(other._center)*self._d delta = self._center*other._delta + other._center*self._delta return FuzzyTriangular(CDD = (center, d, delta)) def __add__(self, other): if isinstance(other, FuzzyTriangular): return self.__CDD_add(other) else: return self.__CDD_add(FuzzyTriangular(other)) def __sub__(self, other): if isinstance(other, FuzzyTriangular): return self.__CDD_sub(other) else: return self.__CDD_sub(FuzzyTriangular(other)) def __mul__(self,other): if isinstance(other, FuzzyTriangular): return self.__CDD_mul(other) else: return self.__CDD_mul(FuzzyTriangular(other)) def __pos__(self): return FuzzyTriangular(1)*self def __neg__(self): return FuzzyTriangular(-1)*self def __eq__(self, other): return (self._a == other._a) and (self._b == other._b) and \ (self._c == other._c)

फजी त्रिकोणीय संख्याओं के प्रतिनिधित्व के रूप अलग-अलग हो सकते हैं, हम गहराई तक नहीं जाएंगे। प्रस्तुत कोड में, हम __add__ (अतिरिक्त संचालक), __sub__ (घटाव ऑपरेटर), __mul__ (गुणन ऑपरेटर) के तरीकों पर ध्यान देंगे। यदि आप एक वास्तविक संख्या को फ़ज़ी त्रिकोणीय संख्या में जोड़ने का प्रयास करते हैं, तो इसे फ़ज़ी त्रिकोणीय संख्या में परिवर्तित कर दिया जाएगा। टपल या वास्तविक संख्याओं की सूची के साथ एक समान स्थिति - पहले तीन नंबरों को एक फजी त्रिकोणीय के रूप में माना जाएगा (और फ़ज़्रीट्रायंगुलर क्लास में भी परिवर्तित किया गया है)। __Pos__ विधि एकतरफा ऑपरेटर "+" से आगे निकल जाती है। __Neg__ विधि एक "" - है। __Eq__ मेथड == ऑपरेटर को ओवरराइड करता है। यदि वांछित है, तो आप इसके अतिरिक्त संचालन को फिर से परिभाषित कर सकते हैं जैसे:

विभाजन
पेचीदगी
संख्या मापांक
तुलना (अधिक / कम, अधिक या बराबर / कम या बराबर)
स्केलराइजेशन (कास्ट टू इंट, फ्लोट, कॉम्प्लेक्स नंबर, राउंडिंग)
उलटा और अन्य ...

आप परीक्षण के एक छोटे सेट के साथ दर्ज किए गए कार्यों की पर्याप्तता की जांच कर सकते हैं, उदाहरण के लिए:

 ZERO = FuzzyTriangular((0,0,0)) ONE = FuzzyTriangular((1,1,1)) A = FuzzyTriangular((0.3,0.5,0.9)) B = FuzzyTriangular((0.2,0.4,0.67)) C = FuzzyTriangular((0,0.33,0.72)) print('ZERO = '+str(ZERO)) print('ONE = '+str(ONE)) print('A = '+str(A)) print('B = '+str(B)) print('C = '+str(C)) #some tests print('\n') print('A + B = ', A + B) print('A + B == B + A', A + B == B + A) #   print('A + C = ', A + C) print('A + C == C + A', A + C == C + A) print('B + C = ', B + C) print('B + C == C + B', B + C == C + B) print('A + B + C = ', A + B + C) print('(A + B) + C == A + (B + C) == (A + C) + B', \ (A + B) + C == A + (B + C) == (A + C) + B) print('C + 1 = ', C + 1) print('1 + C = ', ONE + C) print('\n') print('A - A =', A - A) print('A - A == 0', A - A == ZERO) print('A - B = ', A - B) print('B - A = ', B - A) #   "-"  "+" print('A - B == -(B - A)', A - B == -(B - A)) print('(A + B + C) - (A + B) = ', (A + B + C) - (A + B)) #    print('(A + B + C) - (A + B) == C', (A + B + C) - (A + B) == C) print('1 - A = ', ONE - A) print('A - 1 = ', A - 1) print('1 - A == -(A - 1)', ONE - A == -(A - 1)) print('\n') print('A*B == B*A', A*B == B*A) print('-1*C =', -ONE*C) print('-1*C == -C', -ONE*C == -C) print('-1*C == C*-1', -ONE*C == C*-1) print('C*-1 = ', C*-1) print('C*-1 =', C*-1) print('-C*1 == -C', -C*1 == -C) print('-C*1 =', -C*1) print('-C =', -C) print('C*-1 == -C', C*-1 == -C) print('(A + B)*C == A*C + B*C', (A + B)*C == A*C + B*C) print('(A - B)*C == A*C - B*C', (A - B)*C == A*C - B*C) print('A*C = ', A*C) print('B*C = ', B*C) print('-B*C = ', -B*C) print('-B*C == B*-C', -B*C == B*-C) print('B*C == -B*-C', B*C == -B*-C)

जोड़, विभाजन और गुणा के ये सत्यापन संचालन कोड में निर्दिष्ट हैं और "जादू" विधियों के पुन: निर्धारण के अनुसार किए गए हैं। हम पहले अज्ञात अभिव्यक्तियों में प्रतीक चर का उपयोग करके समान संचालन करने में सक्षम होना चाहते हैं। इसके लिए कई सहायक कार्यों की शुरूआत की आवश्यकता होती है।

हम सहायक कार्यों का परिचय देते हैं:
- ```
 def symbols_from_expr(expr_str: str, pattern=r"[A-Za-z]\d{,2}") -> tuple: """       """ symbols_set = set(re.findall(pattern, expr_str)) symbols_set = sorted(symbols_set) symbols_list = tuple(sympy.symbols(symbols_set)) return symbols_list 
```
  हम इस फ़ंक्शन का उपयोग अभिव्यक्ति स्ट्रिंग में वर्ण चर के लिए खोज करने के लिए करेंगे (डिफ़ॉल्ट टेम्पलेट A से Z तक का वर्ण है या 2 से लंबे वर्णों तक एक पूर्णांक है और एक पूर्णांक है (या किसी संख्या की अनुपस्थिति के बाद)।
- ```
 def expr_subs(expr_str: str, symbols: Iterable, values: Iterable): """    values   symbols  - expr_str""" expr = sympy.sympify(expr_str) func = sympy.lambdify(tuple(symbols), expr, 'sympy') return func(*values) 
```
  यह फ़ंक्शन आपको किसी भी मान्य प्रकार के प्रतीकात्मक चर चर के स्थान पर प्रतिस्थापन के साथ एक स्ट्रिंग अभिव्यक्ति के मूल्य की गणना करने की अनुमति देता है (यदि स्ट्रिंग अभिव्यक्ति में निहित संचालन स्वयं ओवरराइड हैं)। यह sympy.lambdify फ़ंक्शन के लिए धन्यवाद संभव है, जो "मैजिक" विधियों को स्वीकार करने वाले लैम्ब्डा फ़ंक्शन में एक सरल अभिव्यक्ति को परिवर्तित करता है। फ़ंक्शन को ठीक से काम करने के लिए एक महत्वपूर्ण शर्त प्रतीकों और मूल्यों में तत्वों का सही क्रम है (प्रतीकों और प्रतिस्थापित मूल्यों के पत्राचार)।
- हर बार लैंबडा फंक्शन बनाना महंगा होता है। यदि एक ही अभिव्यक्ति के कई उपयोग की आवश्यकता होती है, तो निम्नलिखित दो कार्यों का उपयोग करने की सिफारिश की जाती है:
```
 def lambda_func(expr_str: str, symbols: Iterable) -> callable: """ -,    - expr_str   symbols""" expr = sympy.sympify(expr_str) func = sympy.lambdify(tuple(symbols), expr, 'sympy') return func def func_subs(expr_func: callable, values: Iterable): """   - expr_func   values""" return expr_func(*values) 
```
  पहले एक लैंबडा फ़ंक्शन को स्वयं लौटाता है, और दूसरा आपको मूल्यों की सूची को प्रतिस्थापित करके परिणामी मूल्यों की गणना करने की अनुमति देता है। एक बार फिर, इस तथ्य पर ध्यान केंद्रित किया जाता है कि उपयोग किए जाने वाले मूल्यों में त्रिकोणीय फजी संख्याएं नहीं हैं।

हम फ़ाइल से सूत्र पंक्ति पढ़ते हैं

 with open('expr.txt', 'r') as file: expr_str = file.read() print('expr_str', expr_str)

कुछ इस तरह के expr.txt फ़ाइल के लिए लाइन सूत्र के रूप में इस्तेमाल किया जा सकता है:

 p36*q67*p57*p26*p25*p13*q12*q15 + + p36*q67*p47*p26*p24*p13*q12 + + p67*q57*p26*p25*q12*p15 + + q57*p47*p25*p24*q12*p15 + + p57*p25*p12*q15 + + p36*p67*p13 + + p67*p26*p12 + + p47*p24*p12 + + p57*p15 - - p57*p47*p24*p12*p15 - - p67*p47*p26*p24*p12 - - p67*p57*p26*p12*p15 + + p67*p57*p47*p26*p24*p12*p15 - - p36*p67*p26*p13*p12 - - p36*p67*p47*p24*p13*p12 - - p36*p67*p57*p13*p15 + + p36*p67*p57*p47*p24*p13*p12*p15 + + p36*p67*p47*p26*p24*p13*p12 + + p36*p67*p57*p26*p13*p12*p15 - - p36*p67*p57*p47*p26*p24*p13*p12*p15 - - p36*p67*p57*p25*p13*p12*q15 - - p67*p57*p26*p25*p12*q15 - - p57*p47*p25*p24*p12*q15 + + p67*p57*p47*p26*p25*p24*p12*q15 + + p36*p67*p57*p26*p25*p13*p12*q15 + + p36*p67*p57*p47*p25*p24*p13*p12*q15 - - p36*p67*p57*p47*p26*p25*p24*p13*p12*q15 - - p36*p67*q57*p47*q26*p25*p24*p13*q12*p15 - - p67*q57*p47*p26*p25*p24*q12*p15 - - p36*p67*q57*p26*p25*p13*q12*p15 - - p36*q67*q57*p47*p26*p25*p24*p13*q12*p15 - - p36*q67*p57*p47*p26*p24*p13*q12*p15 - - p36*q67*p57*p47*p26*p25*p24*p13*q12*q15

हम स्ट्रिंग अभिव्यक्ति से वर्ण चर प्राप्त करते हैं:
```
 symbols = symbols_from_expr(expr_str) print('AutoSymbols', symbols) 
```
हम परीक्षण यादृच्छिक त्रिकोणीय संख्या उत्पन्न करते हैं:
```
 values = tuple([FuzzyTriangular(sorted([random(),random(),random()]))\ for i in range(len(symbols))]) 
```
बाएं "0", केंद्र और दाएं "0" के मूल्यों के क्रम से मेल खाने के लिए यादृच्छिक मानों को क्रमबद्ध करना आवश्यक है।
सूत्र स्ट्रिंग को एक अभिव्यक्ति में बदलें:
```
 func = lambda_func(expr_str, symbols) print('func', '=', func) 
```
हम लैंबडा फ़ंक्शन का उपयोग करके सूत्र के मूल्य की गणना करते हैं (हम परिणाम मिलान से सुनिश्चित करने के लिए func_subs और expr_subs का उपयोग करते हैं):
```
 print('func_subs', '=', func_subs(func, values)) print('expr_subs', '=', expr_subs(expr_str, symbols, values)) 
```

आउटपुट उदाहरण:

 expr_str p36*q67*p57*p26*p25*p13*q12*q15 + + p36*q67*p47*p26*p24*p13*q12 + + p67*q57*p26*p25*q12*p15 + + q57*p47*p25*p24*q12*p15 + + p57*p25*p12*q15 + + p36*p67*p13 + + p67*p26*p12 + + p47*p24*p12 + + p57*p15 - - p57*p47*p24*p12*p15 - - p67*p47*p26*p24*p12 - - p67*p57*p26*p12*p15 + + p67*p57*p47*p26*p24*p12*p15 - - p36*p67*p26*p13*p12 - - p36*p67*p47*p24*p13*p12 - - p36*p67*p57*p13*p15 + + p36*p67*p57*p47*p24*p13*p12*p15 + + p36*p67*p47*p26*p24*p13*p12 + + p36*p67*p57*p26*p13*p12*p15 - - p36*p67*p57*p47*p26*p24*p13*p12*p15 - - p36*p67*p57*p25*p13*p12*q15 - - p67*p57*p26*p25*p12*q15 - - p57*p47*p25*p24*p12*q15 + + p67*p57*p47*p26*p25*p24*p12*q15 + + p36*p67*p57*p26*p25*p13*p12*q15 + + p36*p67*p57*p47*p25*p24*p13*p12*q15 - - p36*p67*p57*p47*p26*p25*p24*p13*p12*q15 - - p36*p67*q57*p47*q26*p25*p24*p13*q12*p15 - - p67*q57*p47*p26*p25*p24*q12*p15 - - p36*p67*q57*p26*p25*p13*q12*p15 - - p36*q67*q57*p47*p26*p25*p24*p13*q12*p15 - - p36*q67*p57*p47*p26*p24*p13*q12*p15 - - p36*q67*p57*p47*p26*p25*p24*p13*q12*q15 AutoSymbols (p12, p13, p15, p24, p25, p26, p36, p47, p57, p67, q12, q15, q26, q57, q67) func = <function <lambda> at 0x06129C00> func_subs = (-0.391482058715, 0.812813114469, 2.409570627378) expr_subs = (-0.391482058715, 0.812813114469, 2.409570627378) [Finished in 1.5s]

ट्यूटोरियल खत्म हो गया है। मुझे आशा है कि आपको यहां कुछ उपयोगी मिलेगा!

पुनश्च: वर्णित दृष्टिकोण का मुख्य "विशेषता" पायथन और सिम्पी के लिए उन पर मानक प्रकार के चर और संचालन से परे जाने की क्षमता है। अपनी कक्षा की घोषणा करके और "जादू" विधियों को ओवरलोड करके, आप पहले से अज्ञात गणितीय अभिव्यक्तियों को सहानुभूति का उपयोग करके गणना कर सकते हैं (लैम्बडा फ़ंक्शन का निर्माण जो मानक और उपयोगकर्ता दोनों प्रकार और संचालन को स्वीकार करते हैं)।

आपका ध्यान के लिए धन्यवाद!

अजगर में फजी त्रिकोणीय संख्याओं के साथ प्रतीकात्मक अभिव्यक्तियों की गणना करें

More articles: