big_complex 0.1.0

# Big Complex Number Calculator - Feature Summary


This project is a calculation module implemented in Rust language that supports large and complex arithmetic operations, offering a rich set of mathematical operation functions.

## Core Modules


### BigInt - Big Integer Module


#### Basic Functions


- ✅ Creation and basic operations (addition, subtraction, multiplication, division, modulo) of big integers.
- ✅ String parsing and display.
- ✅ Conversion to and from byte sequences.
- ✅ Sign detection and absolute value calculation.
- ✅ Comparison operations.

#### Mathematical Operation Functions


- ✅ Power operation (`pow`).
- ✅ Square root calculation (`sqrt`).
- ✅ Greatest common divisor (`gcd`).
- ✅ Least common multiple (`lcm`).
- ✅ Modular exponentiation (`mod_pow`).
- ✅ Modular inverse (`mod_inv`).

#### New Features


- ✅ **Factorial calculation** (`factorial`) - Calculate n!.
- ✅ **Prime number detection** (`is_prime`) - Determine whether a number is prime.
- ✅ **Next prime number** (`next_prime`) - Find the smallest prime number greater than the current number.
- ✅ **Binary operations**:
  - `bit_length()` - Get the binary bit length.
  - `count_ones()` - Count the number of 1s in the binary representation.
  - `trailing_zeros()` - Count the number of trailing zeros.
  - `is_power_of_two()` - Determine whether a number is a power of 2.
  - `next_power_of_two()` - Get the next power of 2.

### BigComplex - Big Complex Number Module


#### Basic Functions


- ✅ Creation and basic operations (addition, subtraction, multiplication, division) of complex numbers.
- ✅ Access to the real and imaginary parts.
- ✅ Complex conjugate (`conjugate`).
- ✅ Squared magnitude (`magnitude_squared`).
- ✅ Scaling operation (`scale`).
- ✅ Complex number power operation (`pow`).

#### Geometric and Polar Coordinate Functions


- ✅ **Magnitude calculation** (`magnitude`) - Calculate the magnitude of a complex number.
- ✅ **Polar coordinate construction** (`from_polar`) - Create a complex number from polar coordinates.
- ✅ **Quadrant determination** (`arg_quadrant`) - Determine the quadrant in which a complex number lies.
- ✅ **Rotation operations**:
  - `rotate_90()` - Rotate counter - clockwise by 90 degrees.
  - `rotate_180()` - Rotate by 180 degrees.
  - `rotate_270()` - Rotate counter - clockwise by 270 degrees.

#### Advanced Mathematical Operations


- ✅ **nth root** (`nth_root`) - Calculate the nth root of a complex number.
- ✅ **Natural logarithm approximation** (`ln_approx`) - Simplified calculation of the natural logarithm of a complex number.
- ✅ **Exponential function approximation** (`exp_approx`) - Simplified calculation of the exponential function of a complex number.

## Test Coverage


### Unit Tests


- ✅ BigInt: 18 test functions, covering all functions.
- ✅ BigComplex: 17 test functions, covering all functions.

### Integration Tests


- ✅ 12 integration tests, including:
  - Large number operation tests.
  - Complex number operation chain tests.
  - Polynomial evaluation tests.
  - Mathematical property verification tests.
  - Comprehensive tests of new features.

## Performance Characteristics


- ✅ Supports arbitrary - precision big integer operations.
- ✅ Efficient algorithm implementation (e.g., optimized trial division for prime number detection).
- ✅ Memory - safe Rust implementation.
- ✅ Zero - copy reference operations are supported.

## Usage Examples


```rust
use big_complex::{BigInt, BigComplex};

// Big integer operations
let n = BigInt::new(10);
println!("10! = {}", n.factorial().unwrap());

let num = BigInt::new(97);
println!("{} is prime: {}", num, num.is_prime());

// Complex number operations
let z = BigComplex::from_i64(3, 4);
println!("Magnitude: {}", z.magnitude());
println!("Rotated 90°: {}", z.rotate_90());

// Advanced operations
let roots = BigComplex::from_i64(16, 0).nth_root(2);
println!("Square roots: {:?}", roots);
```

## Compilation and Execution


```bash
# Run all tests

cargo test

# Run the example program

cargo run --example usage

# Run specific tests

cargo test test_big_int_factorial
cargo test test_big_complex_rotation
```

## Project Structure


```
src/
├── lib.rs          # Module export
├── big_int.rs      # Big integer implementation
└── big_complex.rs  # Big complex number implementation

tests/
└── integration_tests.rs  # Integration tests

examples/
└── usage.rs        # Usage example
```

## Dependencies


- `num-bigint` - Underlying implementation of big integers.
- `num-traits` - Numerical traits.
- `num-complex` - Complex number support.
- `num-integer` - Integer operations.

## Summary


This project has successfully implemented a fully - functional large and complex arithmetic calculation module, including:

- **28 unit tests** all passed.
- **12 integration tests** all passed.
- **15 new features** with corresponding tests.
- **A complete example program** demonstrating all functions.

The implementation of each new feature follows the "implement - test" development model to ensure code quality and function correctness.