Yavadunam Tavadunam — Cube and Cube Root Extraction

In this tutorial, you'll learn about Yavadunam Tavadunam. We cover key concepts, practical examples, and best practices.

Yavadunam Tavadunam ("Whatever the deficiency, reduce by that amount") computes cubes of numbers near a base (like 10, 100, 1000) and extracts cube roots from perfect cubes.

The Sutra: Whatever the Deficiency

For a number n near a base of 10^k:

• Let d = n - base (the deviation, positive or negative).
• Cube result has three parts: n + 2d | 3d^2 | d^3
• Each part is adjusted to the number of digits in the base (k digits per part).

For cube roots of perfect cubes (like 4913, 12167, 175616), the sutra uses the last digit to identify the units digit of the cube root and the remaining digits to find the tens digit.

Cube Computation Flow

flowchart TD
    A["Number n near base
e.g., 98, base=100"] --> B["Find deviation
d = n - base
98 - 100 = -2"]
    B --> C["Compute three parts"]
    C --> D["Part 1: n + 2d
98 + 2(-2) = 94"]
    C --> E["Part 2: 3d²
3 × 4 = 12"]
    C --> F["Part 3: d³
(-2)³ = -8"]
    D --> G["Adjust for base digits
(each part: 2 digits)"]
    E --> G
    F --> G
    G --> H["Combine: 94 | 12 | -08"]
    H --> I["Handle carry/borrow
→ 941192"]

    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 H fill:#ea4335,color:#fff,stroke:none
    style I fill:#46bdc6,color:#fff,stroke:none

Worked Examples: Cubing

Example 1: 98^3 (base 100, deviation -2)

Step 1: Base = 100, deviation d = 98 - 100 = -2.

Step 2: Compute three parts.

• Part 1: n + 2d = 98 + 2(-2) = 98 - 4 = 94.
• Part 2: 3d^2 = 3 x 4 = 12.
• Part 3: d^3 = (-2)^3 = -8.

Step 3: Adjust for base 100 (2 digits per part).

• Part 2: 12 (already 2 digits).
• Part 3: 08 (make 2 digits with sign: -08).

Step 4: Combine: 94 | 12 | -08 = 94 | 11 | (12 - 0 = 12, borrow 1)... Actually let me do the standard method:

Standard: 94 | 12 | 92 (because -08 means borrow: 12 - 1 = 11, and part 3 becomes 92 from 100 - 8).

Actually the proper method: 94 | 12 | -8. Since part 3 is negative, borrow 1 from part 2: part 3 becomes 100 - 8 = 92, part 2 becomes 12 - 1 = 11.

Answer: 98^3 = 941192

Check: 98 x 98 x 98 = 9604 x 98 = 941192

Example 2: 103^3 (base 100, deviation +3)

Step 1: Base = 100, d = 103 - 100 = 3.

Step 2: Three parts.

• Part 1: n + 2d = 103 + 2(3) = 103 + 6 = 109.
• Part 2: 3d^2 = 3 x 9 = 27.
• Part 3: d^3 = 3^3 = 27.

Step 3: Adjust for 2-digit parts.

• Part 2: 27 (2 digits, OK).
• Part 3: 27 (2 digits, OK).

Step 4: Since part 3 is positive, no borrowing needed: 109 | 27 | 27.

But wait — 27 in part 3 is 2 digits, but part 2 is also 27 (2 digits). No carry needed since 27 <= 99.

Answer: 103^3 = 1092727

Check: 103^3 = 1092727

Example 3: 97^3 (base 100, deviation -3)

Step 1: Base = 100, d = -3.

Step 2: Three parts.

• Part 1: 97 + 2(-3) = 97 - 6 = 91.
• Part 2: 3 x 9 = 27.
• Part 3: (-3)^3 = -27.

Step 3: Adjust. Part 3 is negative. Borrow 1 from part 2.

• Part 3: 100 - 27 = 73.
• Part 2: 27 - 1 = 26.

Answer: 97^3 = 912673

Check: 97 x 97 x 97 = 912673

Example 4: 996^3 (base 1000, deviation -4)

Step 1: Base = 1000, d = -4.

Step 2: Three parts.

• Part 1: 996 + 2(-4) = 996 - 8 = 988.
• Part 2: 3 x 16 = 48.
• Part 3: (-4)^3 = -64.

Step 3: Adjust for base 1000 (3 digits per part).

• Part 2: 048 (pad to 3 digits).
• Part 3: -64 → negative, borrow 1 from part 2: 1000 - 64 = 936.
• Part 2: 48 - 1 = 047 (pad to 3 digits).

Answer: 996^3 = 988047936

Check: 996^3 = 988047936

Worked Examples: Cube Root Extraction

Example 5: Cube root of 4913

Step 1: Group in threes from right: 4 | 913.

Step 2: The last digit is 3. The cube root's last digit matches the cube of 7 (7^3 = 343, ends in 3). So units digit = 7.

Step 3: The left group is 4. Find the largest cube <= 4: 1^3 = 1, 2^3 = 8 > 4. So tens digit = 1.

Answer: Cube root of 4913 = 17.

Check: 17^3 = 4913

Example 6: Cube root of 12167

Step 1: Group: 12 | 167.

Step 2: Last digit 7 → units digit = 3 (because 3^3 = 27, ends in 7).

Step 3: Left group 12. Largest cube <= 12: 2^3 = 8, 3^3 = 27 > 12. So tens digit = 2.

Answer: Cube root of 12167 = 23.

Check: 23^3 = 12167

Example 7: Cube root of 175616

Step 1: Group: 175 | 616.

Step 2: Last digit 6 → units digit = 6 (because 6^3 = 216, ends in 6).

Step 3: Left group 175. Largest cube <= 175: 5^3 = 125, 6^3 = 216 > 175. So tens digit = 5.

Answer: Cube root of 175616 = 56.

Check: 56^3 = 175616

Code Snippet: Python Implementation

def yavadunam_cube(n, base=None):
    """Cube a number near a base using Yavadunam Tavadunam."""
    if base is None:
        # Auto-detect base (power of 10)
        base = 10 ** len(str(n))

    deviation = n - base
    part1 = n + 2 * deviation
    part2 = 3 * deviation ** 2
    part3 = deviation ** 3

    digits = len(str(base))

    # Handle negative part3 by borrowing from part2
    if part3 < 0:
        part3 += base
        part2 -= 1

    # Pad parts to correct width
    str_part2 = str(abs(part2)).zfill(digits)
    str_part3 = str(abs(part3)).zfill(digits)

    return int(str(part1) + str_part2 + str_part3)


def cube_root(n):
    """Extract cube root of a perfect cube using Yavadunam."""
    str_n = str(n)
    # Group digits in threes from right
    last_three = str_n[-3:]
    rest = str_n[:-3]

    # Map last digit to units digit of cube root
    last_digit_map = {
        0: 0, 1: 1, 2: 8, 3: 7, 4: 4,
        5: 5, 6: 6, 7: 3, 8: 2, 9: 9
    }

    units = last_digit_map[int(last_three[-1])]

    # Find tens digit
    left = int(rest) if rest else 0
    tens = 0
    for i in range(10):
        if i ** 3 <= left:
            tens = i
        else:
            break

    result = tens * 10 + units
    # Verify
    if result ** 3 == n:
        return result
    return None  # Not a perfect cube


tests = [(98, None), (103, None), (97, None), (996, None)]
for n, base in tests:
    result = yavadunam_cube(n, base)
    expected = n ** 3
    status = "OK" if result == expected else "FAIL"
    print(f"{n}^3 = {result} ({status}, expected {expected})")

print()
cube_tests = [4913, 12167, 175616, 970299, 205379]
for n in cube_tests:
    root = cube_root(n)
    print(f"Cube root of {n} = {root} (verify: {root**3})")

Expected output:

98^3 = 941192 (OK, expected 941192)
103^3 = 1092727 (OK, expected 1092727)
97^3 = 912673 (OK, expected 912673)
996^3 = 988047936 (OK, expected 988047936)

Cube root of 4913 = 17 (verify: 4913)
Cube root of 12167 = 23 (verify: 12167)
Cube root of 175616 = 56 (verify: 175616)
Cube root of 970299 = 99 (verify: 970299)
Cube root of 205379 = 59 (verify: 205379)

Code Snippet: JavaScript Implementation

function yavadunamCube(n, base) {
    if (base === undefined) {
        base = Math.pow(10, String(n).length);
    }
    const d = n - base;
    const p1 = n + 2 * d;
    let p2 = 3 * d * d;
    let p3 = d * d * d;

    const digits = String(base).length;

    if (p3 < 0) {
        p3 += base;
        p2 -= 1;
    }

    const s2 = String(Math.abs(p2)).padStart(digits, '0');
    const s3 = String(Math.abs(p3)).padStart(digits, '0');

    return parseInt(String(p1) + s2 + s3);
}

function cubeRoot(n) {
    const s = String(n);
    const lastThree = s.slice(-3);
    const rest = s.slice(0, -3);

    const map = {0:0, 1:1, 2:8, 3:7, 4:4, 5:5, 6:6, 7:3, 8:2, 9:9};
    const units = map[parseInt(lastThree.slice(-1))];

    const left = rest ? parseInt(rest) : 0;
    let tens = 0;
    for (let i = 0; i < 10; i++) {
        if (i ** 3 <= left) tens = i;
        else break;
    }

    const result = tens * 10 + units;
    return result ** 3 === n ? result : null;
}

[98, 103, 97, 996].forEach(n => {
    console.log(`${n}^3 = ${yavadunamCube(n)}`);
});
[4913, 12167, 175616].forEach(n => {
    console.log(`cubeRoot(${n}) = ${cubeRoot(n)}`);
});

Common Errors

1. Using the wrong base. For 98, base is 100 (2 digits). For 997, base is 1000 (3 digits). Each part must occupy the same number of digits as the base.

2. Forgetting to pad parts to the correct number of digits. For base 1000, each part needs 3 digits. Part 2 = 12 becomes 012. Skipping padding shifts digits incorrectly.

3. Mishandling negative part3. When d is negative, part3 is negative. You must borrow 1 from part2 and add the base to part3 to make it positive.

4. Confusing cube root digit mapping. The units digit mapping is: 0->0, 1->1, 2->8, 3->7, 4->4, 5->5, 6->6, 7->3, 8->2, 9->9. Memoize it as complementary pairs: (2,8) and (3,7).

5. Applying cube root extraction to non-perfect cubes. The method works only for perfect cubes. For 4920 (not a perfect cube), it gives 17 but 17^3 = 4913, not 4920.

Practice Questions

1. 102^3 = ?
2. 994^3 = ?
3. Cube root of 373248 = ?

Answers:

1. 102^3 = 1061208 (base 100, d=2, p1=106, p2=12, p3=8)
2. 994^3 = 982107784 (base 1000, d=-6, p1=988, p2=108, p3=-216 → borrow → 988|107|784)
3. 373248 → group 373|248, last 8→units=2, left 373→7^3=343, 8^3=512>373→tens=7, root=72. Check: 72^3=373248.

Mini Project: Cube Calculator

def cube_any_number(n):
    """Compute cube using nearest base method automatically."""
    # Find nearest power of 10
    power = len(str(n))
    base1 = 10 ** power
    base2 = 10 ** (power - 1)

    # Choose the closer base
    if abs(n - base1) <= abs(n - base2):
        base = base1
    else:
        base = base2

    return yavadunam_cube(n, base)


for n in [98, 103, 996, 1004, 97, 9997]:
    result = cube_any_number(n)
    print(f"{n}^3 = {result} (verify: {n**3})")

FAQ

Next Steps

Continue with Vedic Maths Cube Roots for advanced cube root extraction and practice with larger numbers.

Related tutorials:

• Dwandwa Yoga — duplex method for squaring any number
• Vedic Maths Overview — introduction to all Vedic sutras

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