പൈത്തണിനൊപ്പം എഞ്ചിനീയറിംഗ് കണക്കുകൂട്ടൽ ഓട്ടോമേഷൻ

നേട്ടങ്ങൾ:

• AI- പവർഡ് പൈത്തൺ കോഡ് ഉപയോഗിച്ച് എഞ്ചിനീയറിംഗ് കണക്കുകൂട്ടൽ, യൂണിറ്റ് മാനേജ്മെൻ്റ്, ഡാറ്റ പ്രോസസ്സിംഗ് എന്നിവ ഓട്ടോമേറ്റ് ചെയ്യാനുള്ള കഴിവ്
• യൂണിറ്റ് ചെക്കിംഗ്, അറിയപ്പെടുന്ന ഫല പരിശോധന, എഡ്ജ് കേസുകൾ എന്നിവ ഉപയോഗിച്ച് AI കോഡ് സാധൂകരിക്കാനുള്ള കഴിവ്
• ആവർത്തിക്കാവുന്നതും കണ്ടെത്താവുന്നതും പതിപ്പ് നിയന്ത്രിതവുമായ അക്കൗണ്ട് ഡോക്യുമെൻ്റുകൾ നിർമ്മിക്കാനുള്ള ശീലം നേടാനുള്ള കഴിവ്

മെക്കാനിക്കൽ എഞ്ചിനീയറിംഗിൽ, ഒരേ കണക്കുകൂട്ടൽ വീണ്ടും വീണ്ടും നടത്തുന്നു: ഒരു കുടുംബത്തിൻ്റെ ഭാഗങ്ങളുടെ സമ്മർദ്ദം, ഓപ്പറേറ്റിംഗ് പോയിൻ്റുകളുടെ ഒരു ശ്രേണിക്ക് പമ്പ് പവർ, വ്യത്യസ്ത താപനിലയിലുള്ള പ്രോപ്പർട്ടി ടേബിളുകൾ. ഇവ സ്വമേധയാ ചെയ്യുന്നത് മന്ദഗതിയിലുള്ളതും പിശക് സാധ്യതയുള്ളതുമാണ്. പൈത്തൺ (എൻജിനീയറിങ്ങിനുള്ള സമ്പന്നമായ ലൈബ്രറികളുള്ള, എളുപ്പത്തിൽ പഠിക്കാവുന്ന പ്രോഗ്രാമിംഗ് ഭാഷ) ഈ ആവർത്തനങ്ങളെ ഓട്ടോമേറ്റ് ചെയ്യുന്നു; ഇത് അക്കൗണ്ടിനെ ആവർത്തിക്കാവുന്നതും കണ്ടെത്താവുന്നതും പതിപ്പ് നിയന്ത്രിക്കുന്നതുമാക്കുന്നു. ആർട്ടിഫിഷ്യൽ ഇൻ്റലിജൻസ് (AI) പൈത്തൺ കോഡ് സൃഷ്ടിക്കുന്നതിൽ അവിശ്വസനീയമാംവിധം വേഗതയുള്ളതാണ്: ഒരു ഫോർമുലയെ ഒരു ഫംഗ്‌ഷനാക്കി മാറ്റുന്നു, യൂണിറ്റ് മാനേജ്‌മെൻ്റ് ചേർക്കുന്നു, ഡാറ്റ വായിക്കുന്നു, ഗ്രാഫുകൾ പ്ലോട്ടിംഗ് ചെയ്യുന്നു. എന്നാൽ ഇവിടെ അപകടകരമായ ഒരു തെറ്റിദ്ധാരണയുണ്ട്: കോഡ് പിശകുകളില്ലാതെ പ്രവർത്തിക്കുന്നതിനാൽ അത് ശരിയായി കണക്കാക്കുന്നു എന്ന് അർത്ഥമാക്കുന്നില്ല. തെറ്റായ യൂണിറ്റ് പരിവർത്തനം, തെറ്റായ ഫോർമുല അല്ലെങ്കിൽ എഡ്ജ് കേസുകൾ എന്നിവ കാരണം AI കോഡ് നിശബ്ദമായി തെറ്റായ ഫലങ്ങൾ നൽകിയേക്കാം, കൂടാതെ പ്രോഗ്രാം പിശകുകളില്ലാതെ പ്രവർത്തിക്കുന്നത് തുടരും. അതുകൊണ്ടാണ് AI ഉപയോഗിച്ച് നിർമ്മിച്ച എല്ലാ എഞ്ചിനീയറിംഗ് കോഡുകളും; യൂണിറ്റ് (വലിപ്പം) പരിശോധനയും എഡ്ജ് കേസ് ട്രയലുകളും പരിശോധിച്ചുറപ്പിക്കാതെ, അറിയപ്പെടുന്ന ഫലങ്ങളുള്ള ടെസ്റ്റ് ഇൻപുട്ടുകൾ വിശ്വസനീയമല്ല. ഈ യൂണിറ്റിൽ, AI ഉപയോഗിച്ച് പൈത്തൺ അക്കൗണ്ട് ഓട്ടോമേഷൻ എങ്ങനെ സുരക്ഷിതമായി സജ്ജീകരിക്കാമെന്ന് നിങ്ങൾ പഠിക്കും.

എന്തുകൊണ്ട് കോഡ് അക്കൗണ്ട്? കണ്ടെത്തലും പുനരുൽപാദനക്ഷമതയും

ഒരു മാനുവൽ കണക്കുകൂട്ടൽ ഒറ്റത്തവണയാണ്; ഒരു ഇൻപുട്ട് മാറുമ്പോൾ, അത് സ്ക്രാച്ചിൽ നിന്ന് ചെയ്യപ്പെടുകയും ഇൻ്റർമീഡിയറ്റ് ഘട്ടങ്ങൾ നഷ്ടപ്പെടുകയും ചെയ്യും. കോഡിൽ ചെയ്യുന്ന കണക്കുകൂട്ടൽ ഒരു പ്രമാണം പോലെയാണ്: ഇൻപുട്ടുകളും ഫോർമുലകളും ഔട്ട്പുട്ടുകളും വ്യക്തമായി എഴുതിയിരിക്കുന്നു; നിങ്ങൾ ഒരു ഇൻപുട്ട് മാറ്റി നിമിഷങ്ങൾക്കുള്ളിൽ ഒരു പുതിയ ഫലം നേടുക; പതിപ്പ് നിയന്ത്രണം ഉപയോഗിച്ച് (ജിറ്റ് പോലെ), "ഏത് തീയതിയിൽ ഏത് മൂല്യം ഉപയോഗിച്ച് ഞാൻ കണക്കാക്കിയത്" ട്രാക്ക് ചെയ്യാൻ കഴിയും. നിയന്ത്രണത്തിൻ്റെയും ഉത്തരവാദിത്തത്തിൻ്റെയും കാര്യത്തിൽ ഇത് വിലമതിക്കാനാവാത്തതാണ്. എന്നാൽ ഈ ശക്തി കോഡിൻ്റെ കൃത്യതയെ ആശ്രയിച്ചിരിക്കുന്നു; ഒരു തെറ്റായ കോഡ് തെറ്റായ ഫലം നൽകുന്നു, അത് പുനരുൽപ്പാദിപ്പിക്കാവുന്ന രീതിയിലും വേഗത്തിലും.

നുറുങ്ങ്: ഓരോ കമ്പ്യൂട്ട് ഫംഗ്ഷനും ഒരു ടെസ്റ്റ് എഴുതുക, അതിനടുത്തായി അറിയപ്പെടുന്ന യഥാർത്ഥ ഫലം (പൈത്തണിൽ ഉറപ്പിക്കുക). ഉദാഹരണത്തിന്, നിങ്ങളുടെ സ്ട്രെസ് ഫംഗ്‌ഷൻ അറിയപ്പെടുന്ന സാമ്പിളിൽ 28.1 MPa നൽകണം. ഭാവിയിൽ നിങ്ങൾ കോഡ് മാറ്റുമ്പോൾ എന്തെങ്കിലും തകരാറുണ്ടായാൽ ഈ പരിശോധന ഉടനടി മുന്നറിയിപ്പ് നൽകുന്നു. പരിശോധിച്ചിട്ടില്ലാത്ത എഞ്ചിനീയറിംഗ് കോഡ് പരിശോധിച്ചുറപ്പിക്കാത്ത അക്കൗണ്ടാണ്.

വോളിയം മാനേജ്മെൻ്റ്: പിശകിൻ്റെ ഏറ്റവും സാധാരണമായ ഉറവിടം

എഞ്ചിനീയറിംഗ് കോഡിൽ, മിക്ക പിശകുകളും യൂണിറ്റുകളിൽ നിന്നാണ് വരുന്നത്: kN ഉള്ള N, mm ഉള്ള m, MPa ഉള്ള Pa, ഇത് 1000 അല്ലെങ്കിൽ 1,000,000 എന്ന ഘടകം കൊണ്ട് ആശയക്കുഴപ്പത്തിലാക്കാം. രണ്ട് പ്രതിരോധങ്ങളുണ്ട്. ആദ്യത്തേത് അച്ചടക്കമാണ്: തുടക്കം മുതൽ ഒരൊറ്റ യൂണിറ്റ് സിസ്റ്റം തിരഞ്ഞെടുത്ത് (ഉദാ. N, mm, MPa) എല്ലാ ഇൻപുട്ടുകളും അതിലേക്ക് പരിവർത്തനം ചെയ്യുകയും വേരിയബിൾ പേരുകളിലേക്ക് യൂണിറ്റുകൾ ചേർക്കുകയും ചെയ്യുന്നു (length_mm, force_N). രണ്ടാമത്തേത് ടൂളാണ്: പിൻ്റ് പോലുള്ള ഒരു ലൈബ്രറി കോഡിനുള്ളിലെ യൂണിറ്റുകൾ വഹിക്കുകയും പൊരുത്തമില്ലാത്ത പ്രവർത്തനം ഒരു പിശകായി പിടിക്കുകയും ചെയ്യുന്നു.

സമീപിക്കുക

ഇത് എങ്ങനെ പ്രവർത്തിക്കുന്നു

പ്രയോജനം

പേരിടൽ അച്ചടക്കം

ഫോഴ്‌സ്_എൻ പോലെ, നീളം_മിമി

ലളിതമാണ്, ആശ്രിതത്വങ്ങളില്ല

ഒറ്റ യൂണിറ്റ് സിസ്റ്റം

എല്ലാം N-mm-MPa-ലേക്ക് പരിവർത്തനം ചെയ്തു

ലാളിത്യം, വേഗത

പിൻ്റ് ലൈബ്രറി

വേരിയബിൾ ഉപയോഗിച്ച് യൂണിറ്റ് നീക്കുന്നു

പൊരുത്തക്കേട് യാന്ത്രികമായി പിടിക്കുന്നു

അറിയപ്പെടുന്ന ഫലം പരിശോധന

ഉറപ്പോടെയുള്ള പരാമർശം

ഫോർമുല/യൂണിറ്റ് പിശക് പിടിക്കുന്നു

മുന്നറിയിപ്പ്: AI- ജനറേറ്റ് ചെയ്‌ത കോഡിൽ ഒരു യൂണിറ്റ് പരിവർത്തനം നഷ്‌ടമാകാം അല്ലെങ്കിൽ തെറ്റായിരിക്കാം, കോഡ് ഇപ്പോഴും "പ്രവർത്തിക്കുന്നു". ഉദാഹരണത്തിന്, വ്യാസം mm ആണെങ്കിൽ, വിസ്തീർണ്ണം m² ആയിരിക്കുമെന്ന് പ്രതീക്ഷിക്കുന്നുവെങ്കിൽ, ഫലം 1,000,000 മടങ്ങ് വ്യതിചലിക്കും, പക്ഷേ പ്രോഗ്രാം ഒരു പിശക് നൽകില്ല. കോഡ് പ്രവർത്തിപ്പിക്കുന്നതിന് മുമ്പ്, ഇൻപുട്ടുകളുടെയും ഔട്ട്പുട്ടിൻ്റെയും യൂണിറ്റുകൾ കമൻ്റ് ചെയ്യുക; തുടർന്ന് അറിയപ്പെടുന്ന ഒരു ഉദാഹരണം ഉപയോഗിച്ച് ഫലം നൽകുക.

ഘട്ടം ഘട്ടമായി: AI പരിശോധിക്കാവുന്ന അക്കൗണ്ട് കോഡ്

1. പ്രശ്നവും യൂണിറ്റ് സിസ്റ്റവും വ്യക്തമാക്കുക. ഇൻപുട്ടുകൾ, ഔട്ട്പുട്ടുകൾ, യൂണിറ്റുകൾ.
2. ഫംഗ്ഷൻ ജനറേറ്റ് ചെയ്യുക. ഏക ഉത്തരവാദിത്തമുള്ള, വ്യാഖ്യാനിക്കുന്ന, ഏകീകൃത.
3. അറിയപ്പെടുന്ന ഫലങ്ങൾ പരിശോധന ചേർക്കുക. റഫറൻസ് ഉദാഹരണം ഉപയോഗിച്ച് ഉറപ്പിക്കുക.
4. എഡ്ജ് കേസുകൾ പരീക്ഷിക്കുക. പൂജ്യം, നെഗറ്റീവ്, വളരെ വലുത്/ചെറിയ ഇൻപുട്ട്.
5. ഒരു യൂണിറ്റ് പരിശോധന നടത്തുക. ഔട്ട്‌പുട്ട് യൂണിറ്റ് പ്രതീക്ഷിക്കുന്നതിനോട് പൊരുത്തപ്പെടുന്നുണ്ടോ?
6. പ്രമാണവും പതിപ്പും. അനുമാനങ്ങൾ, ഉറവിടം, തീയതി; git ഉപയോഗിച്ചുള്ള കണ്ടെത്തൽ.

പ്രവർത്തനങ്ങളും പരിശോധനകളും സൃഷ്ടിക്കുന്ന പ്രോംപ്റ്റ്

റോൾ: എഞ്ചിനീയറിംഗ് കണക്കുകൂട്ടലുകൾ എഴുതുന്ന പരിചയസമ്പന്നനായ പൈത്തൺ ഡെവലപ്പർ. ടാസ്ക്: ചതുരാകൃതിയിലുള്ള ക്രോസ്-സെക്ഷൻ കാൻ്റിലവർ ബീമിൽ പരമാവധി വളയുന്ന സമ്മർദ്ദം കണക്കാക്കുന്ന ഒരു ഫംഗ്ഷൻ എഴുതുക. ഇൻപുട്ട്: F (N), L (mm), b (mm), h (mm). ഔട്ട്പുട്ട്: സിഗ്മ (എംപിഎ). കൺവെൻഷൻ: യൂണിറ്റ് സിസ്റ്റം N-mm-MPa; ഓരോ എൻട്രിയുടെയും യൂണിറ്റ് കമൻ്റ് ചെയ്യുക.റൂൾ: I = b*h^3/12, സിഗ്മ = M*c/I എന്നിവ ഉപയോഗിക്കുക; ഘട്ടങ്ങൾ കമൻ്റ് ചെയ്യുക.നിയമം: അറിയാവുന്ന ഫലങ്ങളുള്ള ഒരു ടെസ്റ്റ് ചേർക്കുക: F=500,L=300,b=20,h=40 എന്നതിന് സിഗ്മ ~28.1 MPa; ഉറപ്പോടെ (ചെറിയ സഹിഷ്ണുത) പരിശോധിക്കുക.

എഡ്ജ് സ്റ്റാറ്റസ് പ്രോംപ്റ്റ്

മുകളിലെ ഫംഗ്‌ഷനിലേക്ക് എഡ്ജ് കെയ്‌സ് ചെക്കുകൾ ചേർക്കുക:- ബി, എച്ച് അല്ലെങ്കിൽ എൽ പൂജ്യമോ നെഗറ്റീവോ ആണെങ്കിൽ, ഒരു കാര്യമായ പിശക് നൽകുക (മൂല്യം ഉയർത്തുക).- വളരെ വലിയ/ചെറിയ ഇൻപുട്ടുകൾ ഉപയോഗിച്ച് ഓവർഫ്ലോ/പ്രിസിഷൻ പ്രശ്‌നം ഉണ്ടെങ്കിൽ കമൻ്റ് ചെയ്യുക. കൂടാതെ 3 വ്യത്യസ്ത ടെസ്റ്റ് ഇൻപുട്ടുകൾ കൂടി ചേർത്ത് പ്രതീക്ഷിച്ച ഫലം എഴുതുക; എനിക്ക് സ്വമേധയാ പരിശോധിക്കാൻ കഴിയുന്ന തരത്തിൽ ഫലങ്ങൾ വിശദീകരിക്കുക.

യൂണിറ്റ് സെക്യൂരിറ്റി (പിൻ്റ്) പ്രോംപ്റ്റ്

'പിൻ്റ്' ലൈബ്രറിയിൽ അതേ അക്കൗണ്ട് യൂണിറ്റ്-സേഫ്. ഇൻപുട്ടുകൾ യൂണിറ്റുകളിൽ നിർവചിക്കട്ടെ (ഉദാ. 500 * ureg.newton). ഔട്ട്പുട്ട് MPa ആയി പരിവർത്തനം ചെയ്ത് പ്രിൻ്റ് ചെയ്യുക. തെറ്റായ യൂണിറ്റിൽ ഒരു ഇൻപുട്ട് നൽകുമ്പോൾ പിൻ്റ് എങ്ങനെ പരാജയപ്പെടുമെന്ന് കാണിക്കുന്ന ഒരു ചെറിയ ഉദാഹരണം ചേർക്കുക.

കോഡ് ചെക്ക് പ്രോംപ്റ്റ്

ഒരു കോഡ് അവലോകന വീക്ഷണകോണിൽ നിന്ന് താഴെയുള്ള എൻ്റെ എഞ്ചിനീയറിംഗ് കണക്കുകൂട്ടൽ കോഡ് വിമർശിക്കുക, എന്നോട് യോജിക്കരുത്. പ്രത്യേകിച്ചും: യൂണിറ്റ് പരിവർത്തനം ശരിയാണോ, ഫോർമുല ശരിയാണോ, എഡ്ജ് കേസുകൾ (പൂജ്യം, നെഗറ്റീവ്) പരിഗണിച്ചിട്ടുണ്ടോ, പരിശോധനകൾ യഥാർത്ഥത്തിൽ സ്ഥിരീകരണമാണോ? ഓരോ കണ്ടെത്തലിനും, അത് എങ്ങനെ പരിഹരിക്കാമെന്ന് എഴുതുക.[code]

ദുർബലമായ പ്രോംപ്റ്റ് / ശക്തമായ പ്രോംപ്റ്റ്

ദുർബലമായ പ്രോംപ്റ്റ്:

സ്ട്രെസ് കണക്കുകൂട്ടലിനായി പൈത്തൺ കോഡ് എഴുതുക.

യൂണിറ്റുകൾ, ഫോർമുലകൾ, ഇൻപുട്ട് നിർവചനങ്ങൾ, ടെസ്റ്റുകൾ എന്നിവ തിരഞ്ഞെടുക്കേണ്ടതില്ല; AI പ്രവർത്തിക്കുന്ന കോഡ് സൃഷ്ടിക്കുന്നു, എന്നാൽ അത് പരിശോധിച്ചുറപ്പിച്ചിട്ടില്ല, അതിൻ്റെ യൂണിറ്റ് അജ്ഞാതമാണ്.

ശക്തമായ നിർദ്ദേശം:

കാൻ്റിലിവർ ബീമിൽ ബെൻഡിംഗ് സ്ട്രെസ് ഫംഗ്ഷൻ എഴുതുക. ഇൻപുട്ട് F(N), L(mm), b(mm),h(mm); ഔട്ട്പുട്ട് സിഗ്മ(എംപിഎ). N-mm-MPa സിസ്റ്റം, അഭിപ്രായത്തിൽ ഓരോ യൂണിറ്റും വ്യക്തമാക്കുക. അറിയപ്പെടുന്ന ഫലങ്ങളുള്ള ഒരു ടെസ്റ്റ് ചേർക്കുക (F=500, L=300, b=20, h=40 → ~28.1 MPa, ഉറപ്പിക്കുക). പൂജ്യം/നെഗറ്റീവ് ഇൻപുട്ടിൽ ഒരു പിശക് നൽകുക. എഡ്ജ് കേസുകൾ വ്യാഖ്യാനിക്കുക.

രണ്ടാമത്തെ പ്രോംപ്റ്റിന് യൂണിറ്റ് സിസ്റ്റം, ഫോർമുല, ഇൻപുട്ടുകൾ, ടെസ്റ്റ്, എഡ്ജ് കേസുകൾ എന്നിവ ആവശ്യമാണ്; ഇത് കോഡ് പരിശോധിക്കാവുന്നതാക്കി മാറ്റുന്നു.

മൂന്ന് മിനി കേസുകൾ (നമ്പറുകൾ പ്രകാരം)

കേസ് 1 - സൈലൻ്റ് വോളിയം പിശക്. AI നിർമ്മിക്കുന്ന ഏരിയ കണക്കുകൂട്ടൽ വ്യാസം mm ൽ എടുക്കുകയും pi*d**2/4 ഉപയോഗിച്ച് mm² നൽകുകയും ചെയ്യുന്നു, എന്നാൽ അടുത്ത വരി അതിനെ m² പ്രതീക്ഷിക്കുന്ന ഒരു ഫോർമുലയിൽ ഉൾപ്പെടുത്തുന്നു; കോഡ് പിശകുകളില്ലാതെ പ്രവർത്തിക്കുകയും സമ്മർദ്ദം 1,000,000 മടങ്ങ് കുറയ്ക്കുകയും ചെയ്യുന്നു. എഞ്ചിനീയർ അറിയാവുന്ന ഫലം ഉപയോഗിച്ച് ടെസ്റ്റ് നടത്തുമ്പോൾ (അസേർട്ട് abs(sigma-28.1)<0.5), ടെസ്റ്റ് പൊട്ടിത്തെറിക്കുകയും പിശക് പിടിക്കപ്പെടുകയും ചെയ്യുന്നു. പരിശോധന ഇല്ലായിരുന്നുവെങ്കിൽ, തെറ്റായ ഫലം റിപ്പോർട്ടിൽ ശ്രദ്ധിക്കപ്പെടാതെ വന്നേനെ. പാഠം: പ്രവർത്തന കോഡ് ≠ ശരിയായ കോഡ്.

കേസ് 2 - എഡ്ജ് സ്റ്റേറ്റ് ക്രാഷ്. ഒരു പാർട്ട് ഫാമിലിക്കായി ലൂപ്പ് ചെയ്യുന്ന കോഡിൽ, കനം h=0 ഒരു വരിയിൽ നൽകിയിട്ടുണ്ട്; I = b*h**3/12 = 0 ആകുമ്പോൾ, sigma = M*c/I പൂജ്യം പിശക് കൊണ്ട് ഒരു വിഭജനം നൽകുന്നു. AI ചേർത്ത if h<=0: lift ValueError നിയന്ത്രണത്തിന് നന്ദി, കോഡ് അർത്ഥവത്തായ ഒരു സന്ദേശത്തോടെ നിർത്തുന്നു, കൂടാതെ നിശബ്‌ദമായി inf നിർമ്മിക്കുന്നില്ല. പാഠം: എഡ്ജ് കേസുകൾ മുൻകൂട്ടി കൈകാര്യം ചെയ്യുക.

കേസ് 3 - ആവർത്തനക്ഷമത നേട്ടം. 40 വ്യത്യസ്‌ത പ്രവർത്തന പോയിൻ്റുകൾക്കായി പമ്പ് പവർ സ്വമേധയാ കണക്കാക്കാൻ ഒരു എഞ്ചിനീയർക്ക് അര ദിവസമെടുത്തു. AI-ൽ എഴുതിയ, സ്ക്രിപ്റ്റ് CSV വായിക്കുന്നു, ഓരോ വരിയുടെയും പവർ കണക്കാക്കുന്നു, കൂടാതെ അറിയപ്പെടുന്ന ഒരു പോയിൻ്റ് ഉറപ്പിച്ചുകൊണ്ട് സ്ഥിരീകരിക്കുന്നു, ജോലി ~2 മിനിറ്റായി കുറയ്ക്കുകയും കണ്ടെത്താവുന്ന ഫയലിലേക്ക് ഫലങ്ങൾ എഴുതുകയും ചെയ്യുന്നു. ഒരു എൻട്രി മാറുമ്പോൾ, മുഴുവൻ പട്ടികയും ഓരോ സെക്കൻഡിലും അപ്ഡേറ്റ് ചെയ്യപ്പെടും. പാഠം: പരിശോധിച്ച ഓട്ടോമേഷൻ വേഗതയേറിയതും വിശ്വസനീയവുമാണ്.

സാധാരണ തെറ്റുകൾ

• "ജോലി ചെയ്തു = ശരി" തെറ്റ്: പിശകുകളില്ലാതെ പ്രവർത്തിക്കുന്ന കോഡ് ശരിയാണെന്ന് ചിന്തിക്കുന്നത്.
• ടെസ്റ്റുകൾ എഴുതുന്നില്ല: അറിയപ്പെടുന്ന ഫലമുള്ള ഒരു റഫറൻസ് ടെസ്റ്റ് കൂടാതെ കോഡിനെ ആശ്രയിക്കുന്നു.
• യൂണിറ്റ് അവ്യക്തത: ഇൻപുട്ട്/ഔട്ട്പുട്ട് യൂണിറ്റുകൾ വ്യാഖ്യാനിക്കാതെ വിടുന്നു, പരിവർത്തനം ഒഴിവാക്കുന്നു.
• എഡ്ജ് കേസുകൾ അവഗണിക്കുന്നു: സീറോ/നെഗറ്റീവ് ഇൻപുട്ടിൽ നിശബ്ദ പിശക് അല്ലെങ്കിൽ ക്രാഷ്.
• ഉറവിടം/ അനുമാനം രേഖപ്പെടുത്തുന്നില്ല: ഉപയോഗിച്ച സൂത്രവാക്യത്തിൻ്റെ ഉറവിടവും അനുമാനവും എഴുതുന്നില്ല.
• വേർഷൻ ചെയ്യുന്നില്ല: അക്കൗണ്ട് ട്രേസ് ചെയ്യാതെ ഒറ്റത്തവണ ഫയലായി വിടുന്നു (ജിറ്റ്).

ചുരുക്കത്തിൽ

• പൈത്തൺ എഞ്ചിനീയറിംഗ് കമ്പ്യൂട്ടേഷൻ ആവർത്തിക്കാവുന്നതും കണ്ടെത്താവുന്നതും പതിപ്പ് നിയന്ത്രിക്കുന്നതും ആക്കുന്നു.
• കോഡ് സൃഷ്ടിക്കുന്നതിൽ AI വളരെ വേഗത്തിലാണ്; എന്നാൽ കോഡ് പിശകുകളില്ലാതെ പ്രവർത്തിക്കുന്നു എന്നത് അത് ശരിയായി കണക്കാക്കുന്നു എന്നല്ല അർത്ഥമാക്കുന്നത്.
• അറിയപ്പെടുന്ന ഫല പരിശോധന, യൂണിറ്റ് പരിശോധന, എഡ്ജ് കേസുകൾ എന്നിവയിലൂടെ ഓരോ കോഡും സാധൂകരിക്കണം.
• യൂണിറ്റ് പിശകുകൾ പിശകിൻ്റെ ഏറ്റവും പതിവുള്ളതും വഞ്ചനാപരമായ ഉറവിടവുമാണ്; ഒറ്റ യൂണിറ്റ് സിസ്റ്റം, നാമകരണം അല്ലെങ്കിൽ പൈൻ്റ് എന്നിവ ഉപയോഗിച്ച് പ്രതിരോധിക്കുക.
• സാധൂകരിച്ച ഓട്ടോമേഷൻ സമയം ലാഭിക്കുകയും ആത്മവിശ്വാസം നൽകുകയും ചെയ്യുന്നു; പരിശോധിച്ചുറപ്പിക്കാത്ത കോഡ് അപകടകരമാണ്.

ആപ്ലിക്കേഷൻ ടാസ്ക്

ആവർത്തിച്ചുള്ള എഞ്ചിനീയറിംഗ് കണക്കുകൂട്ടൽ തിരഞ്ഞെടുക്കുക (സ്ട്രെസ്, പമ്പ് പവർ, ഹീറ്റ് ലോഡ് പോലുള്ളവ). ഈ കണക്കുകൂട്ടൽ നടത്തുന്ന AI-യിലേക്ക് ഒരു പൈത്തൺ ഫംഗ്‌ഷൻ എഴുതുക; ഓരോ ഇൻപുട്ടിൻ്റെയും ഔട്ട്‌പുട്ടിൻ്റെയും യൂണിറ്റ് കമൻ്റ് ചെയ്യുകയും അറിയപ്പെടുന്ന ഫലത്തോടുകൂടിയ ഒരു അസെർട്ട് ടെസ്റ്റ് ചേർക്കുകയും ചെയ്യുക. ടെസ്റ്റ് നടത്തി അത് വിജയിച്ചോ എന്ന് നോക്കുക. തുടർന്ന് രണ്ട് പരിശോധനകൾ കൂടി ചെയ്യുക: കോഡ് ഒരു പ്രധാന പിശക് നൽകുന്നുണ്ടോയെന്ന് പരിശോധിക്കാൻ ഒരു എഡ്ജ് കേസ് (പൂജ്യം അല്ലെങ്കിൽ നെഗറ്റീവ് ഇൻപുട്ട്) പരീക്ഷിക്കുക, കൂടാതെ ഒരു ഉദാഹരണത്തിൽ ഔട്ട്പുട്ടിൻ്റെ യൂണിറ്റ് സ്വമേധയാ നൽകുക. സാധ്യമെങ്കിൽ, പൈൻറിൽ നിർമ്മിച്ച ഒരു യൂണിറ്റ്-സേഫ് പതിപ്പും ഉണ്ടായിരിക്കുക. അവസാനമായി, കണക്കുകൂട്ടലിൻ്റെ അനുമാനങ്ങൾ, ഫോർമുല ഉറവിടം, തീയതി എന്നിവ കോഡിലേക്ക് ഒരു ചെറിയ ശീർഷകമായി ചേർക്കുകയും ഈ കോഡിന് ഇപ്പോഴും എഞ്ചിനീയർ അംഗീകാരം ആവശ്യമായി വരുന്നത് എന്തുകൊണ്ടെന്ന് എഴുതുകയും ചെയ്യുക.

ചെക്ക്ലിസ്റ്റ്

• [ ] ഇൻപുട്ട്, ഔട്ട്പുട്ട് യൂണിറ്റുകൾ കോഡിൽ വ്യക്തമായി രേഖപ്പെടുത്തിയിട്ടുണ്ട്; സിംഗിൾ യൂണിറ്റ് സിസ്റ്റം തിരഞ്ഞെടുത്തു.
• [ ] അറിയാവുന്ന ഫലമുള്ള ഒരു ടെസ്റ്റ് (അവകാശവാദം) ചേർക്കുകയും വിജയിക്കുകയും ചെയ്തു.
• [ ] കുറഞ്ഞത് ഒരു എഡ്ജ് കേസെങ്കിലും (പൂജ്യം/നെഗറ്റീവ്) ശ്രമിച്ചു; കോഡ് കാര്യമായ പിശക് നൽകി.
• [ ] ഔട്ട്പുട്ടിൻ്റെ യൂണിറ്റ് നൽകിയത് ഒരു മാനുവൽ ഉദാഹരണമാണ് ("ജോലി ചെയ്തു = ശരി" ​​എന്ന് കരുതുന്നില്ല).
• [ ] ഫോർമുല ഉറവിടം, അനുമാനങ്ങൾ, തീയതി എന്നിവ കോഡിൽ രേഖപ്പെടുത്തിയിട്ടുണ്ട്.
• [ ] അക്കൗണ്ട് ട്രാക്ക് ചെയ്യാവുന്ന/ട്രാക്ക് ചെയ്തിരിക്കുന്നു; അന്തിമ അനുമതി എൻജിനീയർക്ക് വിട്ടു.