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

📖 Theory

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

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

આ વિષય Kotlin નો હોવાથી તમે એમને એ જ ભાષામાં ઉતારી શકો છો જે તમે હમણાં જ શીખ્યા છો, એટલે કે લગભગ 900 વર્ષ જૂના ગણિત પર fun, val અને if-expressions લગાડીને. આ સામાન્ય programming કસરત છે જે એક શાસ્ત્રીય ગ્રંથને તમારાં તાજાં Kotlin કૌશલ્યો સાથે જોડે છે. આ પાઠ બંને પદ્ધતિઓ ટૂંકા Kotlin programs તરીકે, એમનાં પરિણામો સાથે, બતાવે છે, જેથી Lilavati નું અંકગણિત આધુનિક machine પર ચાલતું તમે જોઈ શકો.

📖 Theory

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

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

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

⌨️ Practical

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

// ગુણકને place value ના ભાગોમાં તોડીને ગુણાકાર કરો,
// અને આંશિક ગુણનફળોનો સરવાળો કરો (Lilavati ની distributive પદ્ધતિ).
fun multiplyByParts(a: Int, b: Int): Int {
    var total = 0
    var place = 1                     // 1, 10, 100, ... (place values)
    for (digit in b.toString().reversed()) {
        total += a * (digit - '0') * place   // digit char -> Int
        place *= 10
    }
    return total
}

fun main() {
    println(multiplyByParts(125, 12))   // 1500
    // 125*2*1 + 125*1*10 = 250 + 1250 = 1500
}

⌨️ Practical

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

import kotlin.math.sqrt

// કાટખૂણ ત્રિકોણનો સંબંધ ચકાસો: a^2 + b^2 == c^2
fun isRightTriangle(a: Int, b: Int, c: Int): Boolean {
    return a * a + b * b == c * c
}

// અથવા બે નાની બાજુઓ પરથી કર્ણ ગણો:
fun hypotenuse(a: Int, b: Int): Double {
    return sqrt((a * a + b * b).toDouble())
}

fun main() {
    println(isRightTriangle(3, 4, 5))   // true  (9 + 16 = 25)
    println(hypotenuse(3, 4))           // 5.0
    println(isRightTriangle(3, 4, 6))   // false (9 + 16 = 25, not 36)
}

🧩 Quiz

Kotlin નું function isRightTriangle(a, b, c) એ a*a + b*b == c*c પાછું આપે છે. isRightTriangle(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

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

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

⚠️ Watch out

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

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

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

Char માંથી Int: અંકના character ને ફેરવવા માટે (digit - '0') જોઈએ, સીધો char નહીં.

Float ની સરખામણી: sqrt એ Double પાછું આપે છે; ચોક્કસ સમાનતા માટે પૂર્ણાંકોવાળી વર્ગ ચકાસણી (aa + bb == c*c) વધુ સારી.

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

📖 Theory

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

તમે Lilavati ની નોંધાયેલી પદ્ધતિઓ Kotlin માં ઉતારી છે, અને એ રીતે ઐતિહાસિક ગણિત તથા તમે હમણાં જ શીખેલી ભાષા વચ્ચે સેતુ બાંધ્યો છે. આખા વિષયનો છેલ્લો વિષય capstone PROJECT છે: Units 1 થી 3 પર આધારિત નાનું Kotlin Android application બનાવવું. હવે પછીનો પાઠ એની મર્યાદા બાંધવા અને એને સારી રીતે બનાવવા વિશે માર્ગદર્શન આપે છે, અને Advance Mobile Technology માં તમે જે શીખ્યા એ બધું સાથે બાંધે છે.

✅ Summary

Key takeaways

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