Implementation of Vedic Mathematics Sutras using Python Code

Are you curious about how ancient Vedic Mathematics can be applied using Python? Vedic Mathematics offers unique, efficient ways to solve complex arithmetic problems with surprising speed! Let’s dive into the first three Main Sutras of Vedic Mathematics and see how they outperform traditional methods.

1. Ekadhikena Purvena (By One More than the Previous One) - एकाधिकेन पूर्वेण

This sutra is used for squaring numbers ending in 5. Let’s take a number ending in 5, and compare both the traditional and Vedic methods.

Traditional Method

def traditional_square(n):
    return n * n

# Example
n = 35
print("Traditional Method:", traditional_square(n))  # Output: 1225

Vedic Method

1. Split the number into two parts:

   • The part before the 5 (like 3 in 35).

2. Multiply this part by one more than itself (3 becomes 3 × 4 = 12).

3. Concatenate this result with 25.

def vedic_square(n):
    if n % 10 != 5:
        raise ValueError("Number does not end in 5")
    
    first_part = n // 10
    result = first_part * (first_part + 1)
    return int(str(result) + "25")

# Example
n = 35
print("Vedic Method:", vedic_square(n))  # Output: 1225

Curious Fact:

The Vedic method only takes a few steps and avoids full multiplication, making it super quick for mental math and programming alike!

2. Nikhilam Navatashcaramam Dashatah (All from 9 and the Last from 10) - निखिलं नवतश्चरमं दशतः

This sutra is ideal for multiplication when numbers are close to a base (like 10, 100, 1000). For example, multiplying 97 and 96 (both close to 100).

Traditional Method

def traditional_multiplication(a, b):
    return a * b

# Example
a, b = 97, 96
print("Traditional Method:", traditional_multiplication(a, b))  # Output: 9312

Vedic Method

1. Find the base (like 100).

2. Calculate the differences: 97 − 100 =−3 , 96 − 100 = −4.

3. Multiply the differences (-3 × -4 = 12) for the right part.

4. Subtract the cross difference (97 - 4 or 96 - 3 = 93) for the left part.

def vedic_multiplication(a, b):
    base = 100  # Base can vary depending on proximity (10, 100, etc.)
    diff_a, diff_b = base - a, base - b
    left_part = a - diff_b
    right_part = diff_a * diff_b
    return int(str(left_part) + str(right_part).zfill(2))  # Ensure right part has two digits

# Example
a, b = 97, 96
print("Vedic Method:", vedic_multiplication(a, b))  # Output: 9312

Curious Fact:

The Vedic method here turns a complex multiplication into a series of smaller steps, allowing faster calculations by reducing the number of digits involved!

3. Urdhva-Tiryagbyham (Vertically and Crosswise) - ऊर्ध्व-तिर्यग्भ्याम्

This general multiplication formula is particularly useful for multiplying two numbers of the same length. Let’s take 23 × 21 as an example.

Traditional Method

def traditional_multiplication(a, b):
    return a * b

# Example
a, b = 23, 21
print("Traditional Method:", traditional_multiplication(a, b))  # Output: 483

Vedic Method

For two 2-digit numbers:

1. Multiply the units digits.

2. Cross-multiply and add the results.

3. Multiply the tens digits.

def vedic_multiplication_urdhva(a, b):
    # Separate digits
    a1, a0 = divmod(a, 10)  # Tens and units of first number
    b1, b0 = divmod(b, 10)  # Tens and units of second number

    # Urdhva-Tiryagbyham steps
    part1 = a0 * b0
    part2 = (a1 * b0) + (a0 * b1)
    part3 = a1 * b1

    # Combining parts (handling carry)
    result = part3 * 100 + part2 * 10 + part1
    return result

# Example
a, b = 23, 21
print("Vedic Method:", vedic_multiplication_urdhva(a, b))  # Output: 483

Curious Fact:

This method gives you a result by vertically and crosswise multiplication of digits, allowing faster computation, especially in hardware-limited environments!

These examples show the power of Vedic Mathematics, which not only simplifies complex calculations but also improves efficiency. Implementing these Sutras in Python gives a modern twist to these ancient techniques, opening a world of possibilities for those interested in AI, data science, or mathematics.

Ready to dive deeper? Try implementing these Vedic Mathematics Sutras in Python yourself! Experiment with different numbers and see how the techniques simplify calculations. If you’re excited to learn more, stay tuned for future posts where we’ll explore additional sutras and dive into advanced Vedic techniques. Feel free to share your results or questions in the comments—let’s unlock the power of Vedic math together!

Note: In this post, I'm focusing on demonstrating how Vedic Mathematics techniques can be implemented in Python code. The intention here is to illustrate the methods rather than to focus on optimizing for efficiency, time, or space complexity. These factors may vary, and deeper experimentation on various AI algorithms would be necessary to fully understand their impact. For now, let’s enjoy the unique approach Vedic Mathematics offers to problem-solving!

For more in-depth technical insights and articles, feel free to explore:

• Technical Blog: Ebasiq Blog

• GitHub Code Repository: Girish GitHub Repos

• YouTube Channel: Ebasiq YouTube Channel

• Instagram: Ebasiq Instagram

• Substack: ebasiq by Girish