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

📖 Theory

શ્લોકથી code સુધી

છેલ્લા બે વિષયોમાં Lilavati નું નોંધાયેલું ગણિત આવ્યું: સંખ્યાઓને ભાગોમાં તોડતી ગુણાકારની પદ્ધતિ, અને કાટખૂણ ત્રિકોણનો સંબંધ. તમારો અભ્યાસક્રમ એમની સાથે એક સંતોષકારક કામ કરવાનું કહે છે: એમને code માં ઉતારો.

આ સામાન્ય programming કસરત છે, બરાબર એ જ પ્રકારની જે તમે BCA104 થી કરતા આવ્યા છો: સ્પષ્ટ રીતે define કરેલી પદ્ધતિ લો અને એને function તરીકે લખો. એ લગભગ 900 વર્ષ જૂના ગણિતના ગ્રંથને તમે આખા BCA દરમિયાન કેળવેલાં coding કૌશલ્યો સાથે જોડે છે. આ પાઠ બંને પદ્ધતિઓ ટૂંકા Python programs તરીકે, એમનાં પરિણામો સાથે, બતાવે છે, જેથી શાસ્ત્રીય અંકગણિતને આધુનિક machine પર ચાલતું તમે જોઈ શકો.

📖 Theory

ગુણાકારની પદ્ધતિ code માં ઉતારવી

Lilavati નો ભાગ-ભાગ ગુણાકાર (વિષય 1 માંથી) ગુણકને place value ના ભાગોમાં તોડે છે અને આંશિક ગુણનફળોનો સરવાળો કરે છે, જે વિભાજનનો નિયમ જ છે. Code માં એની સૌથી સાદી અને વફાદાર રીત ગુણકને એક એક અંક પ્રમાણે (place value પ્રમાણે) છૂટો પાડે છે, ગુણે છે અને ઉમેરે છે.

ગણી બતાવેલા દાખલા 125 × 12 માટે, 12 ને 10 વત્તા 2 માં તોડતાં મળે છે 125×10 વત્તા 125×2 બરાબર 1250 વત્તા 250 બરાબર 1500. Program આને સામાન્ય સ્વરૂપ આપી શકે છે. (Python નું * તો સીધું જ ગુણી આપે છે; આ કસરતનો મુદ્દો એ operator ને બદલવાનો નથી, પણ નોંધાયેલી પદ્ધતિ ને વ્યક્ત કરવાનો છે, એટલે કે ઐતિહાસિક રીત code માં કઈ રીતે ઊતરે છે એ બતાવવાનો છે.)

⌨️ Practical

ભાગ-ભાગ ગુણાકાર (નોંધાયેલી પદ્ધતિ)

# ગુણકને place value ના ભાગોમાં તોડીને ગુણાકાર કરો,
# અને આંશિક ગુણનફળોનો સરવાળો કરો (Lilavati ની distributive પદ્ધતિ).
def multiply_by_parts(a, b):
    total = 0
    place = 1                 # 1, 10, 100, ... (place values)
    for digit in reversed(str(b)):   # b ને એક એક અંક લઈને તપાસો
        total += a * int(digit) * place
        place *= 10
    return total

print(multiply_by_parts(125, 12))   # 1500
# 125*2*1 + 125*1*10 = 250 + 1250 = 1500

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

⌨️ Practical

કાટખૂણ ત્રિકોણનો સંબંધ code માં

import math

# કાટખૂણ ત્રિકોણનો સંબંધ ચકાસો: a^2 + b^2 == c^2
def is_right_triangle(a, b, c):
    return a*a + b*b == c*c

# અથવા બે નાની બાજુઓ પરથી કર્ણ ગણો:
def hypotenuse(a, b):
    return math.sqrt(a*a + b*b)

print(is_right_triangle(3, 4, 5))   # True  (9 + 16 = 25)
print(hypotenuse(3, 4))             # 5.0
print(is_right_triangle(3, 4, 6))   # False (9 + 16 = 25, not 36)

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

🧩 Quiz

Function is_right_triangle(a, b, c) એ a*a + b*b == c*c પાછું આપે છે. is_right_triangle(3, 4, 5) શું પાછું આપશે, અને શા માટે?

1. False, કારણ કે 3 વત્તા 4 એ 5 થતા નથી
2. True, કારણ કે 3*3 વત્તા 4*4 બરાબર 9 વત્તા 16 બરાબર 25, અને 5*5 બરાબર 25, એટલે સમાનતા ટકે છે
3. એક error
4. True, પણ ફક્ત યોગાનુયોગે

💭 Think first

Python તો * થી કરી શકે એવી પદ્ધતિ code માં કેમ ઉતારવી?

Python સાદા * થી ગુણી આપે છે, તો Lilavati ની ભાગ-ભાગ પદ્ધતિ code માં ઉતારવાની તકલીફ કેમ લેવી? એનું શૈક્ષણિક મૂલ્ય શું છે? વિચારીને પછી tap કરો.

⚠️ Watch out

Implementation માં પડતી ભૂલો

વર્ગ કરવાને બદલે બાજુઓ ઉમેરવી: કાટખૂણ ત્રિકોણની ચકાસણી aa + bb == c*c છે, a + b નહીં.

c નો વર્ગ અને c વચ્ચેનો ફેર: 5 ની બાજુ માટે c*c એ 25 થાય છે; c પોતે 5 છે (લંબાઈ માટે વર્ગમૂળ લેવું).

Floating-point ની સરખામણી: math.sqrt એ float પાછું આપે છે; ચોક્કસ સમાનતા માટે float સરખાવવા નબળા પડી શકે, એટલે પૂર્ણાંકો સાથે વર્ગવાળી ચકાસણી (aa + bb == c*c) વધુ સારી.

Comments માં શ્લોકનું લખાણ ઉપજાવવું: code ના comments હકીકતલક્ષી રાખો; પદ્ધતિનો ઉલ્લેખ કરો, ઉપજાવેલા શ્લોકોનો નહીં.

વધુ પડતું ગૂંચવવું: વફાદાર અને સાદું implementation ચતુરાઈભર્યા પણ અસ્પષ્ટ implementation કરતાં ચડિયાતું છે.

📖 Theory

પદ્ધતિઓ code માં ઊતરી; હવે capstone project

તમે Lilavati ની નોંધાયેલી પદ્ધતિઓ Python માં ઉતારી છે, અને એ રીતે ઐતિહાસિક ગણિત તથા આધુનિક code વચ્ચે સેતુ બાંધ્યો છે. આખા વિષયનો છેલ્લો વિષય capstone PROJECT છે: Units 1 થી 3 (MongoDB, React, Angular) પર આધારિત નાનું application બનાવવું. હવે પછીનો પાઠ એની મર્યાદા બાંધવા અને એને સારી રીતે બનાવવા વિશે માર્ગદર્શન આપે છે, અને Advance Web Designing માં તમે જે શીખ્યા એ બધું સાથે બાંધે છે.

✅ Summary

Key takeaways

• અભ્યાસક્રમ Lilavati ની નોંધાયેલી પદ્ધતિઓ code (Python કે C) માં ઉતારવાનું કહે છે: આ સામાન્ય programming કસરત છે.
• ભાગ-ભાગ ગુણાકાર (distributive પદ્ધતિ) ગુણકને place value પ્રમાણે તોડીને અને આંશિક ગુણનફળોનો સરવાળો કરીને લખાય છે: multiply_by_parts(125, 12) બરાબર 1500.
• કાટખૂણ ત્રિકોણનો સંબંધ aa + bb == c*c તરીકે લખાય છે: is_right_triangle(3, 4, 5) એ True છે (9 વત્તા 16 બરાબર 25).
• કર્ણ math.sqrt(aa + bb) વડે ગણો: hypotenuse(3, 4) બરાબર 5.0.
• એનું મૂલ્ય ઐતિહાસિક પદ્ધતિ સમજવામાં અને એને code સાથે જોડવામાં છે, built-in operators ને બદલવામાં નહીં.
• Float ની સરખામણી કરતાં પૂર્ણાંકોવાળી વર્ગ ચકાસણી વધુ સારી; comments હકીકતલક્ષી રાખો (ઉપજાવેલા શ્લોકો નહીં).
• યાદ રાખવાની કડી: નોંધાયેલું ગણિત code ની થોડી સાફ લીટીઓમાં ઊતરી જાય છે.