pywayne-maths

What this skill does

# Pywayne Maths

Mathematical utility functions for number theory, digit analysis, and optimized integer operations.

## Quick Start

```python
from pywayne.maths import get_all_factors, digitCount, karatsuba_multiplication

# Get all factors of a number
factors = get_all_factors(28)
print(factors)  # [1, 2, 4, 7, 14, 28]

# Count digit occurrences
count = digitCount(100, 1)
print(count)  # 21 (digit 1 appears 21 times in 1-100)

# Large integer multiplication
product = karatsuba_multiplication(1234, 5678)
print(product)  # 7006652
```

## Functions

### get_all_factors

Return all factors of a positive integer.

```python
get_all_factors(n: int) -> list
```

**Parameters:**
- `n` - Positive integer to factorize

**Returns:**
- List of all factors of `n`

**Use Cases:**
- Number theory problems
- Finding divisors
- Simplifying fractions
- Greatest common divisor (GCD) calculation

**Example:**
```python
from pywayne.maths import get_all_factors

factors = get_all_factors(36)
print(factors)  # [1, 2, 3, 4, 6, 9, 12, 18, 36]

# Check if number is prime
n = 17
factors = get_all_factors(n)
if len(factors) == 2:  # Only 1 and itself
    print(f"{n} is prime")
else:
    print(f"{n} is not prime")
```

### digitCount

Count occurrences of digit `k` from 1 to `n`.

```python
digitCount(n, k) -> int
```

**Parameters:**
- `n` - Positive integer, upper bound of counting range
- `k` - Digit to count (0-9)

**Returns:**
- Count of digit `k` in range [1, n]

**Special Case:**
- When `k = 0`, counts all numbers with trailing zeros after `n`

**Use Cases:**
- Digit frequency analysis
- Number theory problems
- Data analysis tasks

**Example:**
```python
from pywayne.maths import digitCount

# Count digit 1 from 1 to 100
count = digitCount(100, 1)
print(count)  # 21

# Count each digit 0-9 in range 1-1000
for k in range(10):
    count = digitCount(1000, k)
    print(f"Digit {k}: {count} times")
```

### karatsuba_multiplication

Multiply two integers using Karatsuba's divide-and-conquer algorithm.

```python
karatsuba_multiplication(x: int, y: int) -> int
```

**Parameters:**
- `x` - Integer multiplier
- `y` - Integer multiplicand

**Returns:**
- Product of `x` and `y`

**Algorithm:**
- Karatsuba algorithm uses recursive divide-and-conquer to multiply large integers
- Time complexity: O(n^log₂3) ≈ O(n^1.585)
- More efficient than naive multiplication O(n²) for very large numbers

**Use Cases:**
- Large integer multiplication
- Algorithm optimization
- Competitive programming
- Cryptography applications

**Example:**
```python
from pywayne.maths import karatsuba_multiplication

# Compare with standard multiplication
a, b = 123456789, 987654321
result = karatsuba_multiplication(a, b)
print(result)  # 121932631112635269

# Verify
assert result == a * b
```

## Common Applications

### Prime Number Detection

```python
from pywayne.maths import get_all_factors

def is_prime(n):
    factors = get_all_factors(n)
    return len(factors) == 2 and factors == [1, n]

print(is_prime(17))   # True
print(is_prime(18))   # False
```

### Greatest Common Divisor (GCD)

```python
from pywayne.maths import get_all_factors

def gcd(a, b):
    factors_a = set(get_all_factors(a))
    factors_b = set(get_all_factors(b))
    common = factors_a & factors_b
    return max(common)

print(gcd(24, 36))  # 12
```

### Digit Frequency Analysis

```python
from pywayne.maths import digitCount

def digit_frequency(n):
    frequency = {}
    for k in range(10):
        frequency[k] = digitCount(n, k)
    return frequency

print(digit_frequency(1000))
# {0: 189, 1: 301, 2: 300, 3: 300, ...}
```

### Large Number Calculations

```python
from pywayne.maths import karatsuba_multiplication

# Very large numbers
x = 123456789012345678901234567890
y = 9876543210987654321098765432109876

# Use Karatsuba for efficiency
product = karatsuba_multiplication(x, y)
```

## Notes

- `get_all_factors` returns sorted unique factors
- `digitCount` counts from 1 to n inclusive
- `karatsuba_multiplication` is optimized for large integers (hundreds+ of digits)
- For small integers, standard multiplication `*` may be faster due to overhead