ChebyshevSharp 0.13.0

ChebyshevSharp

Multi-dimensional Chebyshev tensor interpolation with analytical derivatives for .NET.

ChebyshevSharp is a C# port of PyChebyshev, providing fast polynomial evaluation of smooth multi-dimensional functions via barycentric interpolation with pre-computed weights. On low-dimensional problems (1-3D), C# is 17-42x faster than the Python reference; see Performance.

Project Links

• Documentation
• API Reference
• NuGet Package
• Changelog
• Contributing
• Security Policy

Features

Installation

dotnet add package ChebyshevSharp

No system BLAS installation required — cross-platform OpenBLAS binaries are included.

Quick Start

using ChebyshevSharp;

// 1. Define a function
double MyFunc(double[] x, object? data)
    => Math.Sin(x[0]) * Math.Cos(x[1]);

// 2. Build the interpolant
var cheb = new ChebyshevApproximation(
    function: MyFunc,
    numDimensions: 2,
    domain: new[] { new[] { -1.0, 1.0 }, new[] { -1.0, 1.0 } },
    nNodes: new[] { 11, 11 }
);
cheb.Build();

// 3. Evaluate — function value and derivatives
double value = cheb.VectorizedEval(new[] { 0.5, 0.3 }, new[] { 0, 0 });
double dfdx  = cheb.VectorizedEval(new[] { 0.5, 0.3 }, new[] { 1, 0 });
double d2fdy = cheb.VectorizedEval(new[] { 0.5, 0.3 }, new[] { 0, 2 });

// Query points must be inside the declared domain; out-of-domain points throw.

// 4. Check accuracy
double error = cheb.ErrorEstimate();  // ~1e-15 for this function

// 5. Save for deployment
cheb.Save("interpolant.json");

Runnable example projects are available in examples/:

dotnet run --project examples/QuickStart/QuickStart.csproj
dotnet run --project examples/TensorTrainHighDim/TensorTrainHighDim.csproj

Classes

Example: Option Pricing

Replace a slow Black-Scholes pricer with a fast Chebyshev interpolant that returns price in ~500 ns, or price plus delta and gamma in ~2 us:

var cheb = new ChebyshevApproximation(
    function: BsPrice,
    numDimensions: 3,
    domain: new[] {
        new[] { 80.0, 120.0 },   // spot
        new[] { 0.1, 0.5 },      // volatility
        new[] { 0.25, 2.0 }      // maturity
    },
    nNodes: new[] { 15, 12, 10 }
);
cheb.Build();  // 1,800 function evaluations (one-time cost)

// Price, delta, and gamma in one call
double[] results = cheb.VectorizedEvalMulti(
    new[] { 100.0, 0.2, 1.0 },
    new[] {
        new[] { 0, 0, 0 },  // price
        new[] { 1, 0, 0 },  // delta
        new[] { 2, 0, 0 },  // gamma
    }
);

Status

See the changelog for per-release feature parity with PyChebyshev.

Documentation

Full documentation is available at 0xc000005.github.io/ChebyshevSharp.

• Getting Started
• Which Class Should I Use?
• Mathematical Concepts
• Piecewise Chebyshev (Splines)
• Sliding Technique
• Tensor Train
• Computing Greeks
• Chebyshev Algebra
• Advanced Usage
• Calculus
• Error Estimation
• Serialization
• Performance
• Testing & Validation
• Support & Reporting
• Citations
• API Reference

Support and Reporting

• Questions and usage problems: start a GitHub Discussion with a small runnable example.
• Bugs: use the bug report template and include OS, .NET SDK version, ChebyshevSharp version, expected behavior, and actual behavior.
• Numerical accuracy concerns: use the numerical accuracy template and include the function, domain, node counts, construction method, tolerance, and a reference value or independent check.
• Security issues: do not open a public issue; follow the security policy.

Contributing

See CONTRIBUTING.md for the development workflow, required checks, Codecov policy, Stryker.NET mutation-testing expectations, and PR checklist. For a shorter site version, see Contributing.

This project follows CODE_OF_CONDUCT.md. Keep issue and PR discussions focused, reproducible, and respectful.

License

MIT