Mavusi.Linq.DataScience.GpuBound.FastMode 1.0.0

Mavusi.Linq.DataScience.GpuBound.FastMode

Ultra-fast GPU-accelerated data science extensions using 32-bit float precision for maximum performance.

⚡ FastMode: Speed vs Precision Trade-off

This package uses 32-bit float precision instead of 64-bit double precision for GPU calculations, delivering:

• 2-4x faster processing on most GPUs
• 50% lower VRAM usage (crucial for large datasets)
• 6-7 significant digits of precision (vs 15-16 for doubles)
• Up to 200x performance gains on massive datasets compared to CPU

When to Use FastMode

✅ USE FastMode when:

• Speed is more important than precision
• Working with large datasets (millions+ of data points)
• Building machine learning pipelines (most ML algorithms work fine with float32)
• Real-time analytics and streaming data processing
• VRAM is limited on your GPU
• Results need ~0.0001% accuracy (e.g., trend analysis, approximate statistics)

❌ DON'T use FastMode when:

• You need maximum precision (financial calculations, scientific simulations)
• Working with very small or very large numbers (floats have limited range)
• Accumulating many operations where rounding errors can compound
• You need more than 6-7 significant digits of accuracy

Precision Comparison

For most data science and machine learning applications, float precision is more than sufficient!

🚀 Features

All GPU-accelerated methods from Mavusi.Linq.DataScience.GpuBound, optimized with 32-bit float precision:

Statistical Analysis (Fast Float Mode)

• StandardDeviationGpu() - Returns float
• VarianceGpu() - Returns float
• CorrelationGpu() - Returns float
• CovarianceGpu() - Returns float

Distribution Analysis (Fast Float Mode)

• MedianGpu() - Returns float
• QuartileGpu() - Returns float
• PercentileGpu() - Returns float
• SkewnessGpu() - Returns float
• KurtosisGpu() - Returns float

Rolling Windows (Fast Float Mode)

• RollingAverageGpu() - Returns IEnumerable<float>
• RollingSumGpu() - Returns IEnumerable<float>
• RollingMinGpu() - Returns IEnumerable<float>
• RollingMaxGpu() - Returns IEnumerable<float>
• RollingStandardDeviationGpu() - Returns IEnumerable<float>

Linear Algebra (Fast Float Mode)

• DotProductGpu() - Returns float
• MagnitudeGpu() - Returns float
• MultiplyGpu() (Matrix/Vector) - Uses float internally

Geospatial (Fast Float Mode)

• HaversineDistanceGpu() - Returns float (km)
• HaversineDistanceMilesGpu() - Returns float (miles)
• CalculateDistancesGpu() - Returns float[]
• PairwiseDistancesGpu() - Returns float[,]

Time Series (Fast Float Mode)

• DifferenceGpu() - Returns time series with float values
• PercentageChangeGpu() - Returns time series with float values
• CumulativeSumGpu() - Returns time series with float values
• ExponentialMovingAverageGpu() - Returns time series with float values

📦 Installation

dotnet add package Mavusi.Linq.DataScience.GpuBound.FastMode

Prerequisites

• .NET 8, 9, or 10
• CUDA-capable GPU (NVIDIA), OpenCL-compatible GPU, or CPU fallback
• No additional drivers required - ILGPU handles hardware abstraction

💡 Usage Examples

Basic Statistics (Float Precision)

using Mavusi.Linq.DataScience.GpuBound;

var data = Enumerable.Range(1, 10_000_000)
    .Select(x => (double)x).ToArray();

// Fast float-based GPU calculation - returns float
float stdDev = data.StandardDeviationGpu();  // ~6-7 digit precision
float correlation = dataset1.CorrelationGpu(dataset2);  // Much faster than double!

Console.WriteLine($"StdDev: {stdDev:F6}");  // Format to 6 decimal places

Rolling Windows (Float Precision)

var stockPrices = GetStockPrices(); // Millions of data points

// Returns IEnumerable<float> - 2-4x faster than double precision
var movingAvg = stockPrices.RollingAverageGpu(windowSize: 50);
var volatility = stockPrices.RollingStandardDeviationGpu(windowSize: 20);

// Perfect for real-time dashboards and ML feature engineering!

Linear Algebra (Float Precision)

using Mavusi.Linq.DataScience.Models;

var vector1 = new Vector(new[] { 1.0, 2.0, 3.0, /* ... millions more */ });
var vector2 = new Vector(new[] { 4.0, 5.0, 6.0, /* ... millions more */ });

// Returns float - ideal for ML embeddings and similarity calculations
float dotProduct = vector1.DotProductGpu(vector2);
float magnitude = vector1.MagnitudeGpu();

// Matrix ops use float internally - much faster with lower VRAM
var result = matrix1.MultiplyGpu(matrix2);

Geospatial Analysis (Float Precision)

using Mavusi.Linq.DataScience.Models;

var newYork = new GeoCoordinate(40.7128, -74.0060);
var london = new GeoCoordinate(51.5074, -0.1278);

// Returns float - accurate to ~1 meter for distances up to 10,000 km
float distanceKm = newYork.HaversineDistanceGpu(london);  // ~5570 km
float distanceMiles = newYork.HaversineDistanceMilesGpu(london);  // ~3461 miles

// Filter millions of locations in milliseconds
var nearbyLocations = locations
    .WithinRadiusGpu(c => c, centerPoint, radiusKm: 50.0f);

Time Series (Float Precision)

using Mavusi.Linq.DataScience.Models;

var timeSeries = GetTimeSeriesData(); // Millions of points

// All return TimeSeriesPoint<double> with float-calculated values
var differences = timeSeries.DifferenceGpu();
var percentChanges = timeSeries.PercentageChangeGpu();
var cumulativeSum = timeSeries.CumulativeSumGpu();
var ema = timeSeries.ExponentialMovingAverageGpu(alpha: 0.3f);

// Outlier detection with float threshold
var outliers = timeSeries.DetectOutliersGpu(threshold: 3.0f);

🎯 Performance Characteristics

Speed Comparison (Float vs Double on GPU)

Tested on NVIDIA RTX 3080 with 10M data points

Memory Usage Comparison

🔄 Comparing FastMode vs Accurate

Both packages are part of the Mavusi.Linq.DataScience ecosystem:

You can install both and choose based on your needs:

// FastMode - for speed
using Mavusi.Linq.DataScience.GpuBound;  // FastMode namespace
float fastResult = data.StandardDeviationGpu();  // Returns float

// Accurate - for precision (separate package)
// using Mavusi.Linq.DataScience.GpuBound;  // Accurate namespace
// double preciseResult = data.StandardDeviationGpu();  // Returns double

🖥️ Hardware Support

FastMode automatically detects and uses the best available hardware:

1. CUDA (NVIDIA GPUs) - Best performance
2. OpenCL (AMD, Intel, others) - Good performance
3. CPU Fallback - Guaranteed compatibility

No configuration needed - just call the methods with Gpu suffix!

📊 Precision Considerations

Float Precision is Perfect For:

• ✅ Machine learning (most frameworks use float32)
• ✅ Data visualization and dashboards
• ✅ Statistical trend analysis
• ✅ Approximate analytics (percentiles, quartiles)
• ✅ Geospatial distance calculations (accurate to ~1m)
• ✅ Real-time stream processing
• ✅ Large-scale ETL pipelines

Consider Double Precision For:

• ⚠️ Financial calculations requiring exact decimal precision
• ⚠️ Scientific simulations with extreme precision needs
• ⚠️ Accumulating millions of operations where errors compound
• ⚠️ Working with very large (>10³⁸) or very small (<10⁻³⁸) numbers

Accuracy Examples

// Float precision examples (FastMode)
float pi = 3.141593f;           // Accurate to 6 decimals
float distance = 5570.234f;     // km - accurate to 1 meter
float correlation = 0.987654f;   // Accurate for ML models
float avg = 12345.67f;          // Accurate for analytics

// Double precision (Accurate package)
double pi = 3.14159265358979;   // 15 decimals
double distance = 5570.2345678; // Sub-millimeter accuracy
double correlation = 0.98765432109876;
double avg = 12345.6789012345;

🧪 Testing

Comprehensive test suite with 79 unit tests covering:

• ✅ Statistical calculations with float precision
• ✅ Distribution analysis accuracy
• ✅ Rolling window operations
• ✅ Linear algebra correctness
• ✅ Geospatial distance accuracy
• ✅ Time series transformations
• ✅ Edge cases and error handling
• ✅ GPU capability detection

97.5% test pass rate (77/79 tests passing)

🤝 Related Packages

• Mavusi.Linq.DataScience - CPU-based data science extensions
• Mavusi.Linq.DataScience.GpuBound.Accurate - GPU with 64-bit precision
• Mavusi.Linq.DataScience.Models - Shared models

📄 License

MIT License - see LICENSE file for details.

🐛 Issues & Contributions

• Report issues: GitHub Issues
• Contribute: GitHub Repository

🌟 Why FastMode?

"In data science, speed often matters more than precision. FastMode lets you process 2-4x more data in the same time, using half the memory. For machine learning and analytics, that's a game-changer."

Perfect for:

• 🤖 Machine learning pipelines
• 📊 Real-time analytics dashboards
• 🌍 Large-scale geospatial analysis
• 📈 High-frequency trading signals
• 🎯 IoT data processing
• 🔬 Experimental data exploration

Made with ⚡ by Mavusi | GitHub