ZeroTensor.Core 1.5.0

ZeroTensor

ZeroTensor is an ultra-high-performance, multidimensional strided tensor computing library for .NET with zero external dependencies. Built from first principles in pure C#, it delivers NumPy/PyTorch-grade N-dimensional tensor operations, zero-copy slicing, cache-blocked BLAS matrix arithmetic, and numerical decompositions across modern .NET and legacy .NET Framework platforms.

🌟 Key Capabilities

• Pure C# / Zero Dependencies: No native C++ wrappers, no Python runtimes, no MKL or OpenBLAS shared library setup. Copy and run anywhere.
• N-Dimensional Strided Memory Layout: Flexible shape descriptors and strides allowing zero-copy views, broadcasting, slicing, transposing, and reshaping.
• Zero-GC Memory Pooling (TensorPool): Rent and recycle tensor memory buffers with using var t = Tensor.Rent<float>(shape) backed by ArrayPool<T>.Shared to eliminate GC pauses in hot inference loops.
• In-Place SIMD Vector Operations: High-throughput vectorized in-place mutators (Add_, Subtract_, Multiply_, Divide_, Relu_, Clamp_) and destination buffer overloads.
• Next-Gen AI Datatypes (FP16 & BFloat16): First-class Tensor<Half> and Tensor<BFloat16> data structures, instant bitshift conversions, element-wise arithmetic, activations (ReLU, GELU, Sigmoid, Tanh, Exp), and mixed-precision GEMM accumulating in FP32 registers. Includes transparent zero-dependency IEEE 754 half-precision polyfill for netstandard2.0 and net462.
• Quantized Matrix Arithmetic (INT8 & INT4): Highly optimized FP32/FP64 GEMM with register and L1/L2 cache tiling, INT8 matrix multiplication (GemmInt8), and packed 4-bit nibble quantized GEMM (GemmInt4) with per-channel scale and zero-point dequantization for edge LLMs.
• Universal Model & Array Serialization: Zero-dependency reading and writing of standard NumPy (.npy) files and Hugging Face Safetensors (.safetensors) weights.
• Advanced Reductions & Slicing: TopK, Gather, CumSum, OneHot, ArgMax, ArgMin, and C# 8+ Range/Index slicing.
• Numerical Matrix Decompositions:
  • SVD (Singular Value Decomposition via Golub-Reinsch / Jacobi rotations)
  • QR (Householder reflections)
  • Cholesky ($L L^T$ decomposition for positive-definite systems)
  • Eigenvalues & Eigenvectors (Symmetric Jacobi method Eigh)
  • Moore-Penrose Pseudoinverse (Pinverse)
• Multi-Targeting: Seamlessly compiles and runs on .NET 8.0+, .NET Framework 4.6.2+, and .NET Standard 2.0.

📦 Installation

Install via the .NET CLI:

dotnet add package ZeroTensor.Core

Or via the NuGet Package Manager:

Install-Package ZeroTensor.Core

🚀 Quick Start

1. Creating and Slicing Tensors

using ZeroTensor.Core;

// Create a 3x3 tensor
var a = Tensor.Create<float>(new[] { 3, 3 }, new float[]
{
    1f, 2f, 3f,
    4f, 5f, 6f,
    7f, 8f, 9f
});

// Reshape without copying memory
var reshaped = a.Reshape(1, 9);

// Transpose matrix view
var transposed = a.Transpose();
Console.WriteLine($"Original (0,1): {a[0, 1]}, Transposed (1,0): {transposed[1, 0]}");

2. Cache-Blocked Matrix Multiplication (GEMM)

var m1 = Tensor.RandomUniform(512, 512, min: -1.0f, max: 1.0f);
var m2 = Tensor.RandomUniform(512, 512, min: -1.0f, max: 1.0f);

// High-speed Level-3 BLAS multiplication
var result = TensorBlas.Gemm(m1, m2);

3. Singular Value Decomposition (SVD)

var matrix = Tensor.Create<double>(new[] { 3, 3 }, new double[]
{
    4.0, 11.0, 14.0,
    8.0,  7.0, -2.0,
    1.0,  2.0,  3.0
});

// Compute SVD: A = U * S * V^T
TensorDecompositions.Svd(matrix, out var u, out var s, out var vt);

Console.WriteLine($"Top Singular Value: {s[0]:F4}");

4. Zero-GC Memory Rental & In-Place Operations

// Rent tensor buffer from ArrayPool.Shared (0 GC allocations in loops)
using var rented = Tensor.Rent<float>(128, 128);

// Access and mutate directly
rented[0, 0] = 1.0f;

// High-speed in-place SIMD operations without allocating new tensors
rented.Tensor.AddScalar_(5.0f);
rented.Tensor.Relu_();

5. Universal Serialization (.safetensors & .npy)

// Save and load NumPy array (.npy) without Python or external dependencies
var t = Tensor.RandomUniform(128, 64);
t.SaveNpy("features.npy");
var loadedNpy = Tensor.LoadNpy<float>("features.npy");

// Save and load Hugging Face Safetensors (.safetensors)
var weights = new Dictionary<string, Tensor<float>>
{
    ["encoder.weight"] = Tensor.RandomUniform(512, 256),
    ["encoder.bias"] = Tensor.Zeros<float>(512)
};
SafetensorsFile.Save("model.safetensors", weights);
var loadedWeights = SafetensorsFile.Load("model.safetensors");

6. Half-Precision (FP16) Computing & Mixed-Precision GEMM

// Convert FP32 tensor to FP16
var floatTensor = Tensor.RandomUniform(256, 256);
Tensor<Half> halfTensorA = floatTensor.ToHalf();
Tensor<Half> halfTensorB = floatTensor.ToHalf();

// Element-wise FP16 arithmetic and activations
var sum = TensorOps.Add(halfTensorA, halfTensorB);
var activated = TensorOps.ReLUHalf(sum);

// Cache-blocked mixed-precision matrix multiplication (FP16 input/output, FP32 accumulator)
Tensor<Half> matmulResult = TensorBlas.MatMul(halfTensorA, halfTensorB);

// Convert back to FP32 if needed
Tensor<float> floatResult = matmulResult.ToFloat();

📊 Benchmark & Performance

Tested on Intel Core i7 / AMD Ryzen 9 (.NET 8.0, AVX2 enabled):

🏛 Ecosystem Architecture

ZeroTensor serves as the numerical foundation for the ZeroPlatform industrial automation and compute ecosystem:

graph TD
    ZeroTensor["ZeroTensor.Core (N-D Strided Tensors)"]
    ZeroCompute["ZeroCompute.Core (SIMD / D3D11 Compute)"]
    ZeroInference["ZeroInference.Core (Pure C# ONNX Engine)"]
    ZeroSignal["ZeroSignal.Core (DSP, FFT, EKF)"]
    ZeroGeometry["ZeroGeometry.Core (3D PointCloud, ICP, KdTree)"]
    ZeroNeural["ZeroNeural.Core (Autonomous ML Networks)"]

    ZeroTensor --> ZeroCompute
    ZeroTensor --> ZeroInference
    ZeroTensor --> ZeroSignal
    ZeroTensor --> ZeroGeometry
    ZeroTensor --> ZeroNeural

📄 License

MIT License © 2026 Phong Võ. Part of the ZeroPlatform project.