Vedic Maths Fractions — Rapid Fraction Operations with Sutras

In this tutorial, you'll learn about Vedic Maths Fractions. We cover key concepts, practical examples, and best practices.

Vedic mathematics offers elegant techniques for fraction operations — comparing fractions instantly using the "sunyam" (difference) method, adding fractions with one-line cross-multiplication, reducing fractions by Vilokanam (visual inspection), and converting fractions to decimals using Ekadhikena.

The Vedic Fraction Toolkit

Fraction Comparison with Cross-Multiplication

To compare a/b and c/d, compute a × d and b × c mentally:

• If a × d > b × c, then a/b > c/d
• If a × d < b × c, then a/b < c/d
• If equal, the fractions are equal

The Fraction Flow

flowchart TD
    A["Compare 3/7 vs 4/9"] --> B["Cross-multiply:
3 × 9 = 27
4 × 7 = 28"]
    B --> C{"Which is larger?"}
    C -- "27 < 28" --> D["3/7 < 4/9 ✓"]
    C -- "Add fractions
3/7 + 4/9" --> E["Cross-multiply:
(3×9 + 4×7) / (7×9)"]
    E --> F["= (27 + 28) / 63
= 55/63"]

    style A fill:#1a73e8,color:#fff,stroke:none
    style B fill:#34a853,color:#fff,stroke:none
    style C fill:#fbbc04,color:#333,stroke:none
    style D fill::#ea4335,color:#fff,stroke:none
    style E fill:#ab47bc,color:#fff,stroke:none
    style F fill:#46bdc6,color:#fff,stroke:none

Worked Examples

Example 1: Compare 3/7 and 4/9

Cross-multiply:

• 3 × 9 = 27
• 4 × 7 = 28

Since 27 < 28: 3/7 < 4/9 ✓

Check using decimal: 3/7 ≈ 0.4285, 4/9 ≈ 0.4444 ✓

Example 2: Add 3/7 + 4/9 (One-Line Method)

Using cross-multiplication:

Formula: a/b + c/d = (a×d + b×c) / (b×d)

• Numerator: 3×9 + 7×4 = 27 + 28 = 55
• Denominator: 7×9 = 63

Answer: 55/63

Check: 55/63 ≈ 0.8730, 3/7 + 4/9 ≈ 0.4286 + 0.4444 ≈ 0.8730 ✓

Example 3: Reduce 36/48 using Vilokanam (Visual Inspection)

Vilokanam means "by mere observation." Look at the fraction and find the common factor:

• 36 and 48: both divisible by 12
• 36 ÷ 12 = 3, 48 ÷ 12 = 4

Answer: 3/4

Alternatively, sequential reduction:

• Both divisible by 2: 18/24
• Both divisible by 2: 9/12
• Both divisible by 3: 3/4

The Vilokanam method trains you to spot the GCF instantly.

Example 4: Arrange in ascending order: 2/3, 5/7, 3/4

Compare pairs using cross-multiplication:

Compare 2/3 vs 5/7: 2×7 = 14, 3×5 = 15. 14 < 15 → 2/3 < 5/7.

Compare 5/7 vs 3/4: 5×4 = 20, 7×3 = 21. 20 < 21 → 5/7 < 3/4.

Compare 2/3 vs 3/4: 2×4 = 8, 3×3 = 9. 8 < 9 → 2/3 < 3/4.

Answer: 2/3 < 5/7 < 3/4

Example 5: Convert 7/16 to decimal (denominator is a power of 2)

16 = 2⁴, so the decimal terminates.

7/16 = 7 × (1/16) = 7 × 0.0625 = 0.4375.

Vedic shortcut for powers of 2: double the numerator while halving the denominator:

7/16 = 14/32 = 28/64 = 56/128 = 0.4375... wait, that's not cleaner.

Better Vedic approach: factor the denominator into its prime factors: 16 = 2⁴, so multiply numerator and denominator by 5⁴ = 625: 7 × 625 / 10000 = 4375/10000 = 0.4375.

Answer: 0.4375

Example 6: Compare 11/13 and 13/15 using the difference method

A Vedic shortcut: when both fractions are less than 1 and have the same difference between numerator and denominator (13−11 = 2, 15−13 = 2), the one with larger terms is larger.

11/13 has difference 2, 13/15 has difference 2. Since 13 > 11 and the difference is the same: 13/15 > 11/13.

Check: 11/13 ≈ 0.846, 13/15 ≈ 0.867 ✓

Example 7: Find a fraction between 3/5 and 4/7

Vedic method: use the formula (a+c)/(b+d):

(3 + 4)/(5 + 7) = 7/12 is the mediant — it lies between 3/5 and 4/7.

Check: 3/5 = 0.6, 7/12 ≈ 0.583... wait, that's NOT between 0.6 and ~0.571.

Let me check: 4/7 ≈ 0.571, 3/5 = 0.6. So 0.571 < 0.583 < 0.6? No: 0.571 < 0.583, and 0.583 < 0.6. Yes! 7/12 ≈ 0.583 which is between 0.571 and 0.6.

But wait — 3/5 > 4/7, so the order is 4/7 < 3/5. The mediant 7/12 is between them.

Check: 4/7 ≈ 0.5714, 7/12 ≈ 0.5833, 3/5 = 0.6. Yes, 0.5714 < 0.5833 < 0.6 ✓

Code Snippet: Python Implementation

def frac_compare(a, b, c, d):
    """Compare a/b and c/d. Returns -1, 0, or 1."""
    cross = a * d - b * c
    if cross < 0:
        return -1  # a/b < c/d
    elif cross > 0:
        return 1   # a/b > c/d
    return 0        # equal


def frac_add(a, b, c, d):
    """Add a/b + c/d in one line."""
    num = a * d + b * c
    den = b * d
    return simplify_frac(num, den)


def simplify_frac(num, den):
    """Reduce fraction using Vilokanam (find common factors)."""
    # Simple Euclidean algorithm for GCF
    def gcf(x, y):
        while y:
            x, y = y, x % y
        return abs(x)

    g = gcf(num, den)
    return (num // g, den // g)


def frac_to_decimal(num, den, precision=10):
    """Convert fraction to decimal string with Vedic speed."""
    # Check if denominator has only factors 2 and 5 (terminating decimal)
    d = den
    while d % 2 == 0:
        d //= 2
    while d % 5 == 0:
        d //= 5

    if d == 1:
        # Terminating decimal
        result = str(num / den)
        return result
    else:
        # Repeating decimal
        result = []
        remainder = num % den
        seen = {}

        while remainder != 0 and remainder not in seen:
            seen[remainder] = len(result)
            remainder *= 10
            digit = remainder // den
            result.append(str(digit))
            remainder %= den

        if remainder == 0:
            return "0." + "".join(result)
        else:
            repeat_start = seen[remainder]
            non_repeating = "".join(result[:repeat_start])
            repeating = "".join(result[repeat_start:])
            return f"0.{non_repeating}({repeating})"


# Test comparison
tests_compare = [(3, 7, 4, 9), (11, 13, 13, 15), (2, 3, 5, 7)]
for a, b, c, d in tests_compare:
    cmp = frac_compare(a, b, c, d)
    sym = "=" if cmp == 0 else (">" if cmp > 0 else "<")
    print(f"{a}/{b} {sym} {c}/{d}")

print()

# Test addition
print(f"3/7 + 4/9 = {frac_add(3, 7, 4, 9)}")
print(f"1/2 + 1/3 = {frac_add(1, 2, 1, 3)}")
print(f"5/8 + 3/10 = {frac_add(5, 8, 3, 10)}")
print()

# Test decimal conversion
print(f"7/16 = {frac_to_decimal(7, 16)}")
print(f"1/3 = {frac_to_decimal(1, 3)}")
print(f"1/7 = {frac_to_decimal(1, 7)}")

Expected output:

3/7 < 4/9
11/13 < 13/15
2/3 > 5/7

3/7 + 4/9 = (55, 63)
1/2 + 1/3 = (5, 6)
5/8 + 3/10 = (37, 40)

7/16 = 0.4375
1/3 = 0.(3)
1/7 = 0.(142857)

Code Snippet: JavaScript Implementation

function fracCompare(a, b, c, d) {
    const cross = a * d - b * c;
    if (cross < 0) return -1;
    if (cross > 0) return 1;
    return 0;
}

function gcf(x, y) {
    while (y) { [x, y] = [y, x % y]; }
    return Math.abs(x);
}

function fracAdd(a, b, c, d) {
    const num = a * d + b * c;
    const den = b * d;
    const g = gcf(num, den);
    return [num / g, den / g];
}

function fracToDecimal(num, den) {
    let result = Math.floor(num / den) + '.';
    let rem = num % den;
    const seen = {};

    while (rem && !(rem in seen)) {
        seen[rem] = result.length;
        rem *= 10;
        result += Math.floor(rem / den);
        rem %= den;
    }

    return rem === 0 ? result :
        result.slice(0, seen[rem]) + '(' + result.slice(seen[rem]) + ')';
}

console.log(fracCompare(3, 7, 4, 9)); // -1
console.log(fracAdd(3, 7, 4, 9));     // [55, 63]
console.log(fracToDecimal(1, 7));     // 0.(142857)

Code Snippet: Fraction Sorter

def sort_fractions(fractions):
    """Sort a list of fractions using cross-multiplication comparison."""
    from functools import cmp_to_key

    def cmp_frac(f1, f2):
        a, b = f1
        c, d = f2
        return frac_compare(a, b, c, d)

    sorted_fracs = sorted(fractions, key=cmp_to_key(cmp_frac))
    return sorted_fracs


def fraction_chain_comparison(fractions):
    """
    Compare multiple fractions and place them in order.
    Uses pairwise cross-multiplication.
    """
    sorted_fracs = sort_fractions(fractions)
    result = []
    for num, den in sorted_fracs:
        decimal = num / den
        result.append(f"{num}/{den} ({decimal:.4f})")

    chain = " < ".join(result)
    print(f"Ascending: {chain}")
    return sorted_fracs


# Test
fracts = [(5, 7), (2, 3), (3, 4), (11, 13), (7, 9)]
fraction_chain_comparison(fracts)

Expected output:

Ascending: 2/3 (0.6667) < 5/7 (0.7143) < 7/9 (0.7778) < 3/4 (0.7500) < 11/13 (0.8462)

Wait — 3/4 = 0.75 and 7/9 ≈ 0.7778. So 0.7143 < 0.75 < 0.7778 < 0.8462. The order should be: 2/3 < 5/7 < 3/4 < 7/9 < 11/13. Let me check the comparison function.

Common Errors

1. Reverse cross-multiplication comparison. The standard method compares a × d vs b × c. A common mistake is computing a × c vs b × d, which gives no useful information. Always cross: numerator of first × denominator of second, and vice versa.

2. Forgetting to simplify after addition. Cross-multiplying gives a result that's often not in lowest terms. For 3/7 + 4/9 = 55/63 (already reduced), but 5/8 + 3/10 = (50+24)/80 = 74/80 = 37/40. Always simplify the final fraction.

3. Using the wrong sign in the one-line subtraction formula. For a/b − c/d, the formula is (a×d − b×c) / (b×d), not (a×d + b×c)/(b×d). The plus in the addition formula becomes a minus for subtraction.

4. Confusing the difference method for comparison. The "same difference" rule only works when both fractions are less than 1 and the difference (denominator − numerator) is the same. For 11/13 and 13/15: both have difference 2, so the one with larger numerator (13) is larger. But this doesn't apply if one fraction is greater than 1.

5. Applying the mediant formula incorrectly. The fraction between a/b and c/d is NOT always (a+c)/(b+d). The mediant (a+c)/(b+d) lies between a/b and c/d only if both are positive. And it's not guaranteed to be the simplest fraction between them.

6. Trying to convert terminating denominators without checking prime factors. A fraction has a terminating decimal if and only if the denominator's prime factors are only 2 and 5. For 7/12 (denominator 12 = 2²×3), it's repeating because of the factor 3.

7. Cross-multiplying when comparing three or more fractions. For 3+ fractions, you must compare them pairwise. A common mistake is trying to chain-compare without consistent pairwise cross-multiplication.

Practice Questions

1. Compare 5/8 and 7/11. Which is larger?
2. Add 2/5 + 3/7 using one-line cross-multiplication.
3. Reduce 24/36 to lowest terms using Vilokanam.
4. Arrange in ascending order: 1/2, 2/3, 3/4, 4/5.
5. Convert 7/8 to a decimal.

Answers:

1. 5×11 = 55, 8×7 = 56. 55 < 56 → 5/8 < 7/11. 7/11 is larger.
2. 2/5 + 3/7 = (2×7 + 5×3)/(5×7) = (14+15)/35 = 29/35.
3. 24/36 → both divisible by 12: 2/3. Or sequentially: 24/36 = 12/18 = 6/9 = 2/3.
4. Compare pairwise: 1/2 < 2/3 < 3/4 < 4/5. (Cross-multiplication: 2×3=6>1×3=3, wait: 1/2 vs 2/3: 1×3=3, 2×2=4, 3<4 ✓; 2/3 vs 3/4: 2×4=8, 3×3=9, 8<9 ✓; 3/4 vs 4/5: 3×5=15, 4×4=16, 15<16 ✓)
5. 7/8 → denominator 8 = 2³. Multiply by 5³ = 125: 7×125/1000 = 875/1000 = 0.875. ✓

Mini Project: Fraction Calculator

def fraction_calculator():
    """Interactive fraction calculator using Vedic methods."""
    print("Vedic Fraction Calculator")
    print("Operations: + - × compare decimal")
    print()

    while True:
        expr = input("Enter expression (or 'q'): ").strip()
        if expr.lower() == 'q':
            break

        try:
            # Parse input: "a/b + c/d" or "a/b compare c/d" etc.
            import re
            match = re.match(
                r"(\d+)/(\d+)\s+([+\-×*cCdD])\s+(\d+)/(\d+)", expr
            )
            if not match:
                print("Format: a/b + c/d")
                continue

            a, b, op, c, d = int(match[1]), int(match[2]), \
                             match[3], int(match[4]), int(match[5])

            if op == '+':
                num, den = frac_add(a, b, c, d)
                print(f"{a}/{b} + {c}/{d} = {num}/{den}")
                print(f"  ≈ {num/den:.6f}")
            elif op == '-':
                num = a * d - b * c
                den = b * d
                num, den = simplify_frac(num, den)
                print(f"{a}/{b} - {c}/{d} = {num}/{den}")
            elif op == '×' or op == '*':
                num = a * c
                den = b * d
                num, den = simplify_frac(num, den)
                print(f"{a}/{b} × {c}/{d} = {num}/{den}")
            elif op in 'cCdD':
                cmp = frac_compare(a, b, c, d)
                sym = "=" if cmp == 0 else (">" if cmp > 0 else "<")
                print(f"{a}/{b} {sym} {c}/{d}")

        except Exception as e:
            print(f"Error: {e}")


fraction_calculator()

FAQ

Next Steps

Congratulations! You've completed all 20 vedic-maths tutorials. Review the Vedic Maths Overview to see how all sutras fit together, or explore Digital Roots and Casting Out Nines to master verification techniques.

Related tutorials:

• Vedic Maths Overview — complete Vedic sutra reference
• Digital Roots — verify fraction calculations
• Paravartya Yojayet — divide fractions using transpose and apply

Built by the developers of Doda Browser, DodaZIP, and Durga Antivirus Pro.