Implementation of all sutras in computer lab using C / Python / any other programming language

📖 Theory

પદ્ધતિઓથી toolkit સુધી

આ આખા એકમમાં તમે દરેક સૂત્રને મનમાં ગણવાની ટૂંકી રીત તરીકે મળ્યા અને એને અલગ અલગ code માં લખ્યું. અભ્યાસક્રમ કહે છે કે અંતે computer lab માં સૂત્રો implement કરો, એટલે કે એમને એક ચાલતા code માં ભેગાં કરો. આ Python નો વિષય હોવાથી તમે એક નાની Python toolkit બનાવો છો: દરેક પદ્ધતિ માટે એક એવાં થોડાં ટૂંકાં functions, જેને તમે ચલાવી, ચકાસી અને ફરી વાપરી શકો.

આ સમાપન પાઠ એ toolkit ભેગી કરે છે અને, જે વધુ અગત્યનું છે, દરેક function ને સામાન્ય ગણિત સામે ચકાસવાનું પણ બતાવે છે, જેથી તમને તમારા code પર ભરોસો બેસે. અહીંનાં બધાં પરિણામ ચકાસેલાં છે.

📖 Theory

ગુણાકાર અને વર્ગનાં functions

ત્રણ સૂત્રો એવી ગણતરીની ટૂંકી રીતો છે જે સફાઈથી functions માં ઊતરી જાય છે:

Nikhilam આધારની નજીકની બે સંખ્યાઓનો ગુણાકાર કરે છે (ઘટ, આડી બાદબાકી, ગુણાકાર). Ekadhikena Purvena 5 થી પૂરી થતી સંખ્યાનો વર્ગ કાઢે છે (આગળનો ભાગ ગુણ્યા એક વધુ, પછી પાછળ 25). Yavadunam આધારની નજીકની સંખ્યાનો વર્ગ કાઢે છે (સંખ્યા વત્તા ઘટ, પછી ઘટનો વર્ગ).

દરેક ફક્ત થોડી લીટીઓનું છે, કારણ કે દરેક સૂત્ર પોતે જ સંક્ષિપ્ત નિયમ છે. ભેગાં મળીને એ ઝડપી, ખાસ કિસ્સાના ગણકોની નાનકડી library બનાવે છે, અને વ્યવહારમાં 'સૂત્રો implement કરવાં' નો અર્થ બરાબર એ જ છે.

⌨️ Practical

સૂત્રોની toolkit (ચકાસેલાં પરિણામ)

def nikhilam(a, b, base=100):        # આધારની નજીક ગુણાકાર
    da, db = base - a, base - b
    return (a - db) * base + da * db

def square_ending_in_5(n):           # Ekadhikena Purvena
    f = n // 10
    return f * (f + 1) * 100 + 25

def square_near_base(n, base=100):   # Yavadunam
    d = n - base
    return (n + d) * base + d * d

print(nikhilam(97, 96))         # 9312
print(square_ending_in_5(65))   # 4225
print(square_near_base(98))     # 9604
print(square_near_base(103))    # 10609

This example runs in Gri-Learn on the web, where you can edit it and see the output.

📖 Theory

સમીકરણ ઉકેલતું function પણ

દરેક સૂત્ર અંકગણિતનું જ હોય એવું નથી. Sankalana-Vyavakalanabhyam સરવાળા અને બાદબાકી વડે simultaneous સમીકરણોની જોડ ઉકેલે છે, અને એ પણ સુઘડ function બની જાય છે.

સરવાળા-તફાવતના સ્વરૂપ (x + y = s, x - y = d) માટે ઉકેલ છે x બરાબર (s + d) / 2 અને y બરાબર (s - d) / 2. એટલે solve_sum_diff(10, 4) એ (7, 3) પાછું આપે છે, જે ગણી બતાવેલા દાખલા સાથે મળે છે. Toolkit માં સમીકરણ ઉકેલનાર ઉમેરવાથી દેખાય છે કે સૂત્રો અંકગણિત અને algebra બંનેમાં ફેલાયેલાં છે, અને બંને સીધાં code માં ઊતરે છે.

⌨️ Practical

Toolkit ને સામાન્ય ગણિત સામે ચકાસવી

def solve_sum_diff(s, d):            # Sankalana-Vyavakalanabhyam
    return (s + d) // 2, (s - d) // 2

# દરેક function ને Python ના પોતાના ગણિત સામે ચકાસો:
assert nikhilam(97, 96) == 97 * 96          # 9312
assert square_ending_in_5(65) == 65 ** 2    # 4225
assert square_near_base(98) == 98 ** 2      # 9604
assert solve_sum_diff(10, 4) == (7, 3)
print("All sutra functions match ordinary arithmetic.")

This example runs in Gri-Learn on the web, where you can edit it and see the output.

🧩 Quiz

Toolkit માં square_near_base(103) એ Yavadunam ઉતારે છે. એ શું પાછું આપે છે?

1. 10309, એક આશરે કિંમત
2. 10609, કારણ કે 103 નો વર્ગ 10609 છે (વધારો +3: 103+3=106, 3 નો વર્ગ એટલે 09)
3. 1069, જેમાં એક અંક છૂટી જાય છે
4. એ error આપે છે, કારણ કે 103 આધારથી ઉપર છે

💭 Think first

દરેક સૂત્રના function ને assert થી સામાન્ય ગુણાકાર સામે કેમ ચકાસવું?

સૂત્રો તો સાચાં હોવાનાં જ છે, તો દરેક function સામાન્ય ગણિત બરાબર છે એની ખાતરી કરવાની તકલીફ કેમ લેવી? વિચારીને પછી tap કરો.

📖 Theory

BCA602 પૂરું

તમે એક ખરા dataset ને શરૂથી અંત સુધી તપાસ્યો, એને ઓળખ્યો, એના પ્રકાર અને આકાર સમજ્યા, pandas વડે EDA આપોઆપ કર્યું, regression અને machine learning માં પગ મૂક્યો, અને શાસ્ત્રીય ગણતરીની પદ્ધતિઓની toolkit Python માં ઉતારી. Data Analytics using Python નો આખો પ્રવાસ આ જ છે. આ એકમ માટે તમારી સંસ્થાના માર્ગદર્શન પ્રમાણે ચાલો; દરેક પદ્ધતિને એ જે રીત બાંધી આપે છે એ રીતે જ રજૂ કરો, નિર્ધારિત પુસ્તકમાંથી લો, અને સ્રોતનો ઉલ્લેખ કરો. વિષયનું મજબૂત સમાપન.

✅ Summary

Key takeaways

• અભ્યાસક્રમ સૂત્રો code માં ઉતારવાનું કહે છે; આ Python વિષય હોવાથી અહીં નાની Python toolkit બને છે.
• nikhilam આધારની નજીક ગુણાકાર કરે છે: nikhilam(97, 96) બરાબર 9312.
• square_ending_in_5 (Ekadhikena) 5 થી પૂરી થતી સંખ્યાનો વર્ગ કાઢે છે: square_ending_in_5(65) બરાબર 4225.
• square_near_base (Yavadunam) આધારની નજીક વર્ગ કાઢે છે: square_near_base(98) બરાબર 9604 અને (103) બરાબર 10609.
• solve_sum_diff (Sankalana-Vyavakalanabhyam) સરવાળા-તફાવતની system ઉકેલે છે: solve_sum_diff(10, 4) બરાબર (7, 3).
• દરેક function ને assert વડે સામાન્ય ગણિત સામે ચકાસો, જેથી ફક્ત પદ્ધતિ પર નહીં પણ implementation પર પણ ભરોસો બેસે.
• યાદ રાખવાની કડી: દરેક સૂત્ર ટૂંકું ચકાસાયેલું function બને છે; code ને સાદા ગણિત સામે ચકાસો.