pkg

mivertowski/DotCompute.Algorithmsv0.6.2

.NET 9.0

GPU-accelerated algorithms for DotCompute. Includes FFT, AutoDiff, sparse matrix operations, signal processing, and cryptographic primitives.

License

MIT

Deps

22

Install Size

—

Vulns

✓ 0

Published

Feb 9, 2026

Get Started

$ dotnet add package DotCompute.Algorithms

Readme

DotCompute.Algorithms

Comprehensive library of GPU-accelerated algorithms for scientific computing, signal processing, and numerical analysis.

Status: 🚧 Active Development

The Algorithms library provides implementations across multiple domains:

Linear Algebra: Production-ready matrix operations and decompositions
Signal Processing: FFT, convolutions, and filtering operations
Numerical Methods: Integration, polynomial solving, optimization
SIMD Optimizations: Hardware-accelerated vectorized operations
Native AOT: Full compatibility with Native AOT compilation

Key Components

Linear Algebra

Matrix Operations

Basic Operations: Addition, subtraction, multiplication, transpose
Matrix Multiplication: Tiled algorithms with shared memory optimization
Element-wise Operations: Hadamard product, element-wise functions
Matrix Statistics: Norms, traces, determinants, condition numbers

Matrix Decompositions

LU Decomposition: Lower-upper factorization with partial pivoting
Cholesky Decomposition: Symmetric positive-definite matrices
QR Decomposition: Orthogonal-triangular factorization
SVD (Singular Value Decomposition): Full and economy SVD
Eigenvalue Decomposition: Symmetric and general eigenvalue problems

Linear Solvers

Direct Solvers: LU, Cholesky, QR-based solvers
Iterative Solvers: Conjugate gradient, GMRES, BiCGSTAB
Sparse Solvers: Sparse matrix-specific algorithms
Least Squares: Overdetermined and underdetermined systems

Advanced Linear Algebra

Householder Transformations: For QR and eigenvalue algorithms
BLAS Kernels: Level 1, 2, and 3 BLAS operations
LAPACK Kernels: Advanced factorization and solver routines
Sparse Matrix Kernels: CSR/CSC format operations

Signal Processing

Fast Fourier Transform (FFT)

: Cooley-Tukey algorithm with radix-2 and mixed-radix

dotnet add package DotCompute.Algorithms --version 0.5.3

using DotCompute.Algorithms.LinearAlgebra;
using DotCompute.Abstractions;

// Create GPU linear algebra provider
var provider = new GPULinearAlgebraProvider(accelerator, logger);

// Create matrices
var matrixA = new Matrix(rows: 1024, cols: 512);
var matrixB = new Matrix(rows: 512, cols: 2048);

// Fill with data
matrixA.Fill(/* data */);
matrixB.Fill(/* data */);

// Perform matrix multiplication on GPU
var result = await provider.MultiplyAsync(matrixA, matrixB);

// Result is a 1024x2048 matrix
Console.WriteLine($"Result: {result.Rows}x{result.Columns}");

using DotCompute.Algorithms.LinearAlgebra.Operations;

var decomposition = new LuDecomposition(accelerator);

// Decompose matrix A into L and U
var (L, U, P) = await decomposition.DecomposeAsync(matrixA);

// Solve Ax = b using LU decomposition
var solution = await decomposition.SolveAsync(L, U, P, vectorB);

using DotCompute.Algorithms.SignalProcessing;

var fft = new FFT(accelerator);

// Perform 1D FFT
var signal = new Complex[1024];
// ... fill signal with data ...

var spectrum = await fft.ForwardAsync(signal);

// Perform inverse FFT
var reconstructed = await fft.InverseAsync(spectrum);

using DotCompute.Algorithms.SignalProcessing;

var convOps = new ConvolutionOperations(accelerator);

// 1D convolution
float[] signal = /* input signal */;
float[] kernel = /* convolution kernel */;

var output = await convOps.Convolve1DAsync(signal, kernel);

// 2D convolution (for images)
float[,] image = /* input image */;
float[,] filter = /* filter kernel */;

var filtered = await convOps.Convolve2DAsync(image, filter);

using DotCompute.Algorithms.Optimized.Simd;
using System.Runtime.Intrinsics;

// Check SIMD capabilities
var capabilities = SimdCapabilities.Detect();
Console.WriteLine($"AVX2: {capabilities.HasAvx2}");
Console.WriteLine($"AVX-512: {capabilities.HasAvx512}");

// Vectorized addition
float[] a = new float[1024];
float[] b = new float[1024];
float[] result = new float[1024];

SimdMathOperations.Add(a, b, result);

// Vectorized reduction (sum)
float sum = SimdReductionOperations.Sum(a);

// Dot product
float dotProduct = SimdReductionOperations.DotProduct(a, b);

using DotCompute.Algorithms.NumericalMethods;

var integration = new AdvancedIntegration();

// Integrate f(x) = x^2 from 0 to 10
double result = integration.AdaptiveQuadrature(
    x => x * x,
    lowerBound: 0,
    upperBound: 10,
    tolerance: 1e-6
);

Console.WriteLine($"Integral: {result:F6}");

using DotCompute.Algorithms.Optimized;

var autoTuner = new AutoTuner(accelerator);

// Auto-tune matrix multiplication parameters
var tuningResult = await autoTuner.TuneMatrixMultiplicationAsync(
    matrixSize: 2048,
    dataType: typeof(float)
);

Console.WriteLine($"Optimal tile size: {tuningResult.OptimalTileSize}");
Console.WriteLine($"Optimal work group: {tuningResult.OptimalWorkGroupSize}");
Console.WriteLine($"Expected performance: {tuningResult.EstimatedGFlops:F2} GFLOPS");

using DotCompute.Algorithms.Management;

var discovery = new AlgorithmPluginDiscovery(logger);

// Discover all available algorithms
var algorithms = await discovery.DiscoverAsync(searchPaths);

foreach (var algorithm in algorithms)
{
    Console.WriteLine($"Algorithm: {algorithm.Name}");
    Console.WriteLine($"Version: {algorithm.Version}");
    Console.WriteLine($"Backends: {string.Join(", ", algorithm.SupportedBackends)}");
}

using DotCompute.Algorithms.Security;

var scanner = new VulnerabilityScanner(logger);

// Scan project dependencies
var scanOptions = new VulnerabilityScanOptions
{
    ScanNuGetPackages = true,
    ScanGitHubAdvisories = true,
    MinimumSeverity = Severity.Medium,
    IncludeDevDependencies = false
};

var vulnerabilities = await scanner.ScanAsync(projectPath, scanOptions);

// Generate report
var report = scanner.GenerateReport(vulnerabilities);
Console.WriteLine(report.Summary);

foreach (var vuln in vulnerabilities.Where(v => v.Severity >= Severity.High))
{
    Console.WriteLine($"[{vuln.Severity}] {vuln.PackageName} - {vuln.CveId}");
    Console.WriteLine($"  Description: {vuln.Description}");
    Console.WriteLine($"  Fix: Upgrade to {vuln.RecommendedVersion}");
}

DotCompute.Algorithms/
├── LinearAlgebra/              # Matrix and vector operations
│   ├── Components/             # GPU implementation components
│   ├── Operations/             # High-level operations (solvers, decompositions)
│   └── LinearAlgebraKernels/   # Kernel implementations
├── SignalProcessing/           # FFT, convolution, filtering
├── NumericalMethods/           # Integration, ODE solvers, polynomial ops
├── Optimized/                  # Performance-optimized implementations
│   └── Simd/                   # SIMD vectorized operations
├── Kernels/                    # GPU kernel library
│   └── LinearAlgebra/          # Linear algebra GPU kernels
├── Management/                 # Algorithm plugin management
│   ├── Discovery/              # Algorithm discovery
│   ├── Lifecycle/              # Plugin lifecycle
│   └── Execution/              # Algorithm execution
├── Security/                   # Vulnerability scanning
│   ├── DataTransfer/           # CVE database integration
│   └── Reports/                # Security report generation
└── Selection/                  # Algorithm selection strategies

var options = new AlgorithmOptions
{
    DefaultBackend = AcceleratorType.Auto,
    EnableAutoTuning = true,
    CacheKernels = true,
    ValidationLevel = ValidationLevel.Release,
    PerformanceProfile = PerformanceProfile.Balanced
};

var laConfig = new LinearAlgebraConfiguration
{
    TileSize = 16, // For tiled matrix multiplication
    UseSharedMemory = true,
    EnableFusedOperations = true,
    NumericalStability = NumericalStability.Balanced
};

var fftConfig = new FFTConfiguration
{
    Algorithm = FFTAlgorithm.CooleyTukey,
    UseRadix4 = true, // When input size is power of 4
    EnableCaching = true
};

public class CustomAlgorithm : IAlgorithmPlugin
{
    public string Name => "CustomAlgorithm";
    public Version Version => new Version(1, 0, 0);
    public AcceleratorType[] SupportedBackends => new[] { AcceleratorType.CUDA };

    public async Task<object> ExecuteAsync(object input, CancellationToken ct)
    {
        // Custom algorithm implementation
        return result;
    }
}

using DotCompute.Algorithms.Kernels.LinearAlgebra;

// Create sparse matrix in CSR format
var sparseMatrix = SparseMatrix.CreateCSR(rows, cols, nonZeroValues, columnIndices, rowPointers);

// Sparse matrix-vector multiplication
var result = await sparseMatrix.MultiplyVectorAsync(vector);

// Use float for computation, double for accumulation
var result = await provider.MultiplyAsync<float, double>(matrixA, matrixB);