👩‍👩‍👦‍👦 👨‍🍳 👨‍🚒 पायथन के साथ चरित्र कंप्यूटिंग। भाग 1। मूल बातें 🌫️ 💀 🚈

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

प्रतीकात्मक गणनाओं का उपयोग करते समय, उपयोगकर्ता को किसी दिए गए चर के साथ किसी भी मान्य फ़ंक्शन में प्रवेश करके कार्यक्रम को नियंत्रित करने का अवसर दिया जाता है।

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

प्रतीकात्मक कंप्यूटिंग की दिशा में पहला कदम पाइप, पायथन पैकेज प्रबंधन प्रणाली के उपयोग से सिम्पी मॉड्यूल के कार्यों को आयात करना है। यदि आप इसे संभाल सकते हैं, तो चलिए चर घोषित करते हैं।

नोट। रिकॉर्ड को छोटा करने के लिए, निम्नलिखित पंक्ति सभी उदाहरणों में नहीं दिखाई गई है: सहानुभूति आयात से *

वर्ण चर की स्पष्ट घोषणा

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

कोड उदाहरण

>>> x,y,a,b = symbols('xya b') #    ,      >>> f=a**3*x + 3*a**2*x**2/2 + a*x**3 + x**4/4 #  f    >>> type(f) <class 'sympy.core.add.Add'> >>> var('u,v') (u, v) >>> f=sin(u)**2+tan(v) #  f    >>> type(f) <class 'sympy.core.add.Add'>

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

कोड उदाहरण

 >>> x=symbols('x:9'); x #    0  9 (x0, x1, x2, x3, x4, x5, x6, x7, x8) >>> x=symbols('x5:10'); x #    5  9 (x5, x6, x7, x8, x9) >>> x=var('x:9'); x #    0  9 (x0, x1, x2, x3, x4, x5, x6, x7, x8) >>> x=var('x5:10'); x #    5  9 (x5, x6, x7, x8, x9)

आप एक प्रकार भी निर्दिष्ट कर सकते हैं और सीधे प्रतीकों () और var () फ़ंक्शन में प्रतीक चर पर प्रतिबंध लगा सकते हैं। कभी-कभी ऐसे प्रतिबंधों के बिना स्पष्ट परिवर्तन काम नहीं करते हैं, उदाहरण के लिए, तुलना करें:

कोड उदाहरण

 >>> x = symbols('x', integer=True) #   >>> sqrt(x**2) Abs(x) >>> x = symbols('x', positive = True, integer=True) >>> sqrt(x**2) x >>> x = symbols('x') >>> sqrt(x**2) #  x,  x≥0 sqrt(x**2) >>> x = var('x', integer=True) >>> sqrt(x**2) Abs(x) >>> x = var('x', positive = True, integer=True) >>> sqrt(x**2) x >>> x = var('x') >>> sqrt(x**2) #  x,  x≥0 sqrt(x**2)

किसी एकल वर्ण के लिए कंटेनर बनाने के लिए, seq = True का उपयोग करें :

 >>> symbols('x',seq=True) (x,)

चरित्र चर के लिए वैध मान का निर्धारण:

 >>> x, y, z = symbols('x,y,z', real=True) >>> x.is_real and y.is_real and z.is_real True

फंक्शन s ()

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

 >>> expr = x**2 + sin(y) + S(10)/2; expr x**2 + sin(y) + 5 >>> type(10) <class 'int'> >>> type(S(10)) #    <class 'sympy.core.numbers.Integer'>

पायथन स्थिरांक और एक वर्ण स्थिरांक के बीच का अंतर यह है कि एक वर्ण स्थिरांक की गणना सटीकता की दी गई डिग्री के साथ की जा सकती है, जैसा कि निम्नलिखित उदाहरण में दिखाया गया है, मानक दौर () फ़ंक्शन की तुलना में:

 z=1/7; z #   z    0.14285714285714285 z1=S(1)/7; z1 1/7 z2=z1.n(30); z2 #   z2    30   0.142857142857142857142857142857 z3=round(z1,30); z3 0.14285714285714285

चरित्र के नाम

यदि आपको वर्तमान सत्र में लगातार सांकेतिक गणित का उपयोग करने की आवश्यकता है, तो आप सिम्पी.बेक मॉड्यूल से सामान्य प्रतीकात्मक नाम आयात कर सकते हैं:

कोड उदाहरण

 >>> import sympy.abc >>> dir(sympy.abc) ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', '_clash', '_clash1', '_clash2', 'a', 'alpha', 'b', 'beta', 'c', 'chi', 'd', 'delta', 'division', 'e', 'epsilon', 'eta', 'exec_', 'f', 'g', 'gamma', 'greeks', 'h', 'i', 'iota', 'j', 'k', 'kappa', 'l', 'lamda', 'm', 'mu', 'n', 'nu', 'o', 'omega', 'omicron', 'p', 'phi', 'pi', 'print_function', 'psi', 'q', 'r', 'rho', 's', 'sigma', 'string', 'symbols', 't', 'tau', 'theta', 'u', 'upsilon', 'v', 'w', 'x', 'xi', 'y', 'z', 'zeta']

चर का नाम कमांड डेल name1, name2, .. के साथ नाम स्थान से हटाया जा सकता है:

 >>> type(x) <class 'sympy.core.symbol.Symbol'> >>> del x,y >>> x NameError: name 'x' is not defined

मानक स्थिरांक के मूल्यों को पुनर्स्थापित करने के लिए, साथ ही साथ कुछ कार्यों के नाम, आपको सहानुभूति मॉड्यूल को फिर से लोड करने की आवश्यकता है।

 >>> from sympy import *

विधि उप (...)

यह याद रखना चाहिए कि प्रतीकात्मक अभिव्यक्ति लिखते समय, इसका सरलीकरण स्वचालित रूप से किया जा सकता है, उदाहरण के लिए:

 >>> a,b,c,d,x,y,z,u,v,w = symbols('abcdxyzuv w') >>> x - z + 20 -z- 15 + 3*sin(pi/2)+2*z x + 8

चर (...) विधि का उपयोग चर के दिए गए मानों के लिए वर्ण अभिव्यक्ति की गणना के लिए किया जाता है, उदाहरण के लिए:

 >>> a, x = symbols('a x') >>> f= a**3*x + 3*a**2*x**2/2 + a*x**3 + x**4/4 >>> f.subs(a,1) #   f   a    x**4/4 + x**3 + 3*x**2/2 + x

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

 >>> a,b,c,d,x,y,z = symbols('abcdxy z') >>> f=a*x**3 +b*y**2 + c*z+d >>> f.subs([(a,1),(b,2),(c,3),(d,4)]) #   a=1, b=2, c=3, d=4 x**3 + 2*y**2 + 3*z + 4 >>> pr= x**3+4*x**2+6*x+10 >>> pr.subs(x,1/x) #     10 + 6/x + 4/x**2 + x**(-3)

आइए हम आपका ध्यान चर (अजगर के प्रतीकात्मक और साधारण चर) के साथ काम करने की निम्न विशिष्टता की ओर आकर्षित करते हैं। निम्नलिखित कोड चलाएँ:

 >>> x='Hello' >>> pr=x+'world' >>> pr 'Helloworld' >>> x='AAA' #   x   >>> pr 'Helloworld'

नियम यहां लागू होता है: यदि चर बदल गया है, तो इस चर वाले पूर्व में बनाई गई अभिव्यक्ति स्वचालित रूप से पुनर्गणना नहीं है। यह नियम नियमित पायथन चरों के लिए भी काम करता है।

अंश संचालन

SymPy मॉड्यूल अंशों के साथ गणना कर सकता है और उन्हें एक आम भाजक में ला सकता है, उदाहरण के लिए, तुलना करें:

 >>> S(1)/3+S(2)/5 11/15 >>> 1/3+2/5 0.7333333333333334

दशमलव गोलाई के बिना परिमेय भिन्नों को बनाने के लिए तर्कसंगत (अंश, भाजक) और पूर्णांक (...) का उपयोग किया जाता है:

 >>> z=Rational(1, 7)+Rational(2, 5); z 19/35 >>> Integer(1)/Integer(5) 1/5 >>> 1/5 0.2 >>> z=Integer(1)/Integer(5)+Rational(2, 7); z 17/35

राउंडिंग कम्प्यूटिंग

प्रतीकात्मक कंप्यूटिंग में, नियम काम करता है - अगर कुछ भी नहीं कहा जाता है, तो गोल न करें। देखें कि पहले मामले में, पायथन अभिव्यक्ति को कैसे बदलता है, लेकिन प्रतिक्रिया रिकॉर्ड में वर्गमूल को छोड़ देता है और कोई राउंडिंग नहीं करता है, और दूसरे में, चूंकि एक संख्या दशमलव बिंदु के साथ निर्दिष्ट की जाती है, परिणाम अनुमानित होगा:

 >>> sqrt(20) 2*sqrt(5) >>> sqrt(20.0) #        4.47213595499958

किसी भी वर्ण ऑब्जेक्ट के लिए, एक दशमलव (...) ( eval uate f loat) विधि है जो अपने दशमलव प्रतिनिधित्व को लौटाती है:

 >>> sqrt(20).evalf() #  sqrt()  sympy 4.47213595499958 >>> E.evalf() 2.71828182845905

Evalf ([n, ...]) विधि तर्क का उपयोग करके परिणाम की सटीकता को निर्दिष्ट कर सकती है (n = महत्वपूर्ण अंकों की संख्या)

 >>> sqrt(20).evalf(30) 4.47213595499957939281834733746 >>> pi.evalf(20) 3.1415926535897932385

आपको यह भी हमेशा याद रखना चाहिए कि वास्तविक अंकगणित एक सटीक परिणाम नहीं देता है, तुलना करें:

 >>> from sympy import * >>> one=S('one') >>> one = cos(1)**2 + sin(1)**2 >>> one.evalf() #  1 1.00000000000000 >>> (one-1).evalf() #    0 -0.e-124

यदि यह ज्ञात है कि परिणाम में गणना त्रुटि है, तो आप इसे evalf () विधि के chop = True विकल्प से हटा सकते हैं। इस मामले में परिणाम के वास्तविक या काल्पनिक भाग का बहुत कम मूल्य शून्य द्वारा प्रतिस्थापित किया जाता है। पिछला उदाहरण लें:

 >>> (one-1).evalf() #    0 -0.e-124 >>> (one - 1).evalf(chop=True) 0

अनन्तता

सिम्पी आयात * से पहली पंक्ति निष्पादित करने के बाद, अनंत प्रतीक oo (दो अक्षर ‟o line) उपलब्ध हो जाता है, जिसके साथ आप कुछ निश्चित कार्य भी कर सकते हैं:

 >>> oo+1 oo >>> 1000000<oo True >>> 1/oo 0

इन्फिनिटी प्रतीक मुख्य रूप से सीमा () और एकीकरण () फ़ंक्शंस द्वारा उपयोग किया जाता है जब एकीकरण सीमा निर्धारित की जाती है, जिसे हम निम्नलिखित लेखों में से एक में चर्चा करेंगे।

निष्कर्ष

लेख में विचार की गई प्रतीकात्मक गणना संख्यात्मक विधियों से भिन्न होती है जिसमें परिणामों की आगे जांच की जा सकती है, उदाहरण के लिए, कार्यों की विलुप्तता निर्धारित करने के लिए, एम्बेडेड चर के साथ समीकरणों को हल करना, और इसी तरह।

मुझे आशा है कि मेरा लेख पायथन प्रोग्रामिंग, छात्रों और वैज्ञानिक अनुसंधान में शामिल लोगों में रुचि रखने वाले सभी के लिए उपयोगी होगा।

पायथन के साथ चरित्र कंप्यूटिंग। भाग 1। मूल बातें

वर्ण चर की स्पष्ट घोषणा

फंक्शन s ()

चरित्र के नाम

विधि उप (...)

अंश संचालन

राउंडिंग कम्प्यूटिंग

अनन्तता

निष्कर्ष

More articles: