🧮 mdmath_core

Fundamental multidimensional mathematics for computer graphics and scientific computing

A high-performance, type-safe mathematics library providing essential vector operations and geometric primitives. Built specifically for computer graphics applications with support for n-dimensional vector spaces and optimized operations.

✨ Features

🔢 Vector Operations

• Dot Product - Efficient vector dot product calculations
• Magnitude & Normalization - Vector length and unit vector operations
• Projection - Project vectors onto other vectors
• Angular Calculations - Compute angles between vectors
• Orthogonality Testing - Check perpendicular relationships
• Dimension Handling - N-dimensional vector support

🛠️ Memory Management

• Zero-Copy Operations - Efficient slice and tuple conversions
• Mutable References - Safe in-place vector modifications
• Iterator Support - Standard Rust iteration patterns
• Type Safety - Compile-time guarantees for vector operations

🚀 Performance

• SIMD Optimization - Vectorized operations where possible
• Stack Allocation - Minimal heap usage for small vectors
• Generic Implementation - Works with any numeric type

📦 Installation

Add to your Cargo.toml:

mdmath_core = { workspace = true }

Or with specific features:

mdmath_core = { workspace = true, features = ["full"] }

🚀 Quick Start

Basic Vector Operations

use mdmath_core::vector;

fn main() {
  // Create vectors as arrays
  let vec_a = [1.0, 2.0, 3.0];
  let vec_b = [4.0, 5.0, 6.0];
  
  // Dot product
  let dot_result = vector::dot(&vec_a, &vec_b);
  println!("Dot product: {}", dot_result); // 32.0
  
  // Vector magnitude
  let magnitude: f32 = vector::mag2(&vec_a);
  let magnitude = magnitude.sqrt();
  println!("Magnitude: {}", magnitude); // ~3.74
  
  // Normalize vector
  let mut normalized = vec_a;
  vector::normalize(&mut normalized, &vec_a);
  println!("Normalized: {:?}", normalized);
}

Advanced Vector Operations

use mdmath_core::vector;
use approx::assert_ulps_eq;

fn advanced_example() {
  // Vector projection
  let mut vec_a = [1.0, 2.0, 3.0];
  let vec_b = [4.0, 5.0, 6.0];
  vector::project_on(&mut vec_a, &vec_b);
  
  // Angle between vectors
  let vec_x = [1.0, 0.0];
  let vec_y = [0.0, 1.0];
  let angle = vector::angle(&vec_x, &vec_y);
  assert_ulps_eq!(angle, std::f32::consts::FRAC_PI_2);
  
  // Check orthogonality
  let is_orthogonal = vector::is_orthogonal(&vec_x, &vec_y);
  assert!(is_orthogonal);
}

📖 API Reference

Core Functions

Features

Enable additional functionality:

mdmath_core = { workspace = true, features = ["full", "approx", "arithmetics"] }

• full - All features enabled
• approx - Floating-point comparison utilities
• arithmetics - Advanced arithmetic operations
• nd - N-dimensional array support

🎯 Use Cases

• Computer Graphics - 3D transformations and lighting calculations
• Game Development - Physics simulations and collision detection
• Scientific Computing - Mathematical modeling and analysis
• Machine Learning - Vector operations for neural networks
• Robotics - Spatial calculations and motion planning

⚡ Performance

mdmath_core is designed for high-performance applications:

• Zero-allocation operations on stack arrays
• Generic implementations work with any numeric type
• Optimized for common vector sizes (2D, 3D, 4D)
• SIMD optimizations where available