Vedic Maths Squaring — Advanced Sutras for Any Number

def duplex_square(n):
    """Square any integer using the Duplex (Dwanda Yoga) method."""
    digits = [int(d) for d in str(n)]
    length = len(digits)

    # Compute duplex values for each position
    duplex_values = []
    for pos in range(2 * length - 1):
        d = 0
        # For each diagonal position, compute the duplex
        # Position corresponds to the line from leftmost to rightmost
        left = max(0, pos - length + 1)
        right = min(pos, length - 1)

        count = 0
        for i in range(left, right + 1):
            j = pos - i
            if 0 <= j < length:
                if i == j:
                    d += digits[i] ** 2
                    count += 1
                elif i < j:
                    d += 2 * digits[i] * digits[j]

        duplex_values.append(d)

    # Combine with carries
    result = []
    carry = 0
    for val in reversed(duplex_values):
        total = val + carry
        result.append(str(total % 10))
        carry = total // 10

    while carry > 0:
        result.append(str(carry % 10))
        carry //= 10

    return int(''.join(reversed(result)))


def yavadunam_square(n):
    """Square using Yavadunam (near a power-of-10 base)."""
    base = 10 ** len(str(n))
    deviation = n - base
    # (n - d)(n + d) + d² = (n - deviation)(n + deviation) + deviation²
    # Wait: let's use n ± deviation from base
    # n = base + d where d = n - base
    # n² = (base + d)² = base² + 2*base*d + d²
    # The Yavadunam method: (n + d) × base + d²... no.
    # Actually n - d = base (if n = base + d)
    # and n + d = base + 2d
    # So (n - d)(n + d) + d² = base(base + 2d) + d² = base² + 2*base*d + d² = (base + d)² = n² ✓

    # For deviation d where n = base + d:
    # n - d = base
    # (n - d)(n + d) = base × (n + d)
    # base × (n + d) is just (n + d) shifted left (multiplied by base)
    # Then add d²

    left = n + deviation  # = base + 2d
    right = deviation ** 2

    # left gets multiplied by base and right is added
    result = left * base + right
    return result


def smart_square(n):
    """Choose the best squaring method based on the number pattern."""
    if n % 10 == 5:
        # Ekadhikena Purvena
        a = n // 10
        return int(str(a * (a + 1)) + "25")

    base = 10 ** len(str(n))
    deviation = n - base

    if abs(deviation) < base * 0.15:
        return yavadunam_square(n)

    return duplex_square(n)


# Test
tests = [34, 57, 98, 123, 2345, 1003, 85]
for n in tests:
    result = smart_square(n)
    print(f"{n}² = {result} (expected: {n**2})")

function duplexSquare(n) {
    const digits = String(n).split('').map(Number);
    const len = digits.length;

    const duplexValues = [];
    for (let pos = 0; pos < 2 * len - 1; pos++) {
        let d = 0;
        const left = Math.max(0, pos - len + 1);
        const right = Math.min(pos, len - 1);

        for (let i = left; i <= right; i++) {
            const j = pos - i;
            if (j >= 0 && j < len) {
                if (i === j) d += digits[i] ** 2;
                else if (i < j) d += 2 * digits[i] * digits[j];
            }
        }
        duplexValues.push(d);
    }

    const result = [];
    let carry = 0;
    for (const val of duplexValues.reverse()) {
        const total = val + carry;
        result.push(total % 10);
        carry = Math.floor(total / 10);
    }
    while (carry > 0) {
        result.push(carry % 10);
        carry = Math.floor(carry / 10);
    }

    return parseInt(result.reverse().join(''));
}

function smartSquare(n) {
    if (n % 10 === 5) {
        const a = Math.floor(n / 10);
        return parseInt((a * (a + 1)) + '25');
    }

    const base = Math.pow(10, String(n).length);
    const deviation = n - base;

    if (Math.abs(deviation) < base * 0.15) {
        const left = n + deviation;
        return left * base + deviation ** 2;
    }

    return duplexSquare(n);
}

[34, 57, 98, 123, 2345, 1003, 85].forEach(n => {
    console.log(`${n}² = ${smartSquare(n)} (expected: ${n ** 2})`);
});

import time


def benchmark_squaring():
    """Compare Duplex method against standard Python multiplication."""
    import random
    numbers = [random.randint(10, 10**6) for _ in range(1000)]

    # Standard squaring
    start = time.perf_counter()
    for n in numbers:
        n ** 2
    std_time = time.perf_counter() - start

    # Duplex squaring (through our function)
    start = time.perf_counter()
    for n in numbers:
        duplex_square(n)
    duplex_time = time.perf_counter() - start

    print(f"Standard squaring: {std_time:.4f}s")
    print(f"Duplex squaring: {duplex_time:.4f}s")
    print(f"Ratio: {duplex_time / std_time:.2f}x")
    print("(Duplex is Python emulation — actual mental calculation is faster!)")


benchmark_squaring()

import random
import time


def squaring_practice():
    """Interactive squaring practice with timer and score."""
    score = 0
    total = 0

    print("Vedic Squaring Practice")
    print("Choose your method wisely!")
    print()

    while True:
        # Generate an appropriate number
        pattern = random.choice(['five', 'near_base', 'general'])
        if pattern == 'five':
            a = random.randint(1, 100)
            n = a * 10 + 5
            hint = "Ends in 5 — use Ekadhikena!"
        elif pattern == 'near_base':
            base = 10 ** random.randint(2, 3)
            offset = random.randint(1, 20)
            n = base + random.choice([-offset, offset])
            hint = f"Near {base} — use Yavadunam!"
        else:
            n = random.randint(11, 999)
            hint = "Use Duplex method!"

        correct = n ** 2
        total += 1

        start = time.perf_counter()
        try:
            answer = int(input(f"{n}² = ? "))
            elapsed = time.perf_counter() - start

            if answer == correct:
                score += 1
                print(f"✓ Correct! ({elapsed:.1f}s)")
            else:
                print(f"✗ Wrong. Answer: {correct}")
        except ValueError:
            print(f"Game over! Score: {score}/{total}")
            break

        if total >= 10:
            print(f"\nFinal score: {score}/{total}")
            break


squaring_practice()