7 мин

9K

Финансовые системы предъявляют жёсткие требования к производительности.

Риск-департамент запрашивает переоценку портфеля из 200 000 опционов. Маржинальная система требует пересчитать все позиции клиентов после сильного движения рынка. Алгоритмический трейдер хочет оценить Greeks для тысяч потенциальных сделок за миллисекунды.

Стандартные подходы на .NET дают сбой по трём причинам.

Причина 1: Объектная модель

Каждый опцион становится отдельным объектом в куче. Виртуальные методы, ссылки, разрозненное расположение в памяти. Для 200 000 объектов — миллионы байтов, GC-паузы на сборку, промахи кэша процессора.

Причина 2: Позлементные вычисления

Вызов функции ценообразования в цикле — плохо. Процессор не может векторизовать код, потому что не видит всю картину целиком. SIMD-инструкции простаивают.

Причина 3: Аллокации в горячем пути

Каждый вызов new double[100000] для хранения промежуточных результатов — это давление на GC. В 24/7 сервисе такие аллокации накапливаются и вызывают непредсказуемые паузы.

Требования к решению

• Батчевая обработка: передаём массивы параметров, получаем массивы результатов за один вызов.

• Zero-аллокации в горячем пути: все буферы предоставляет вызывающий код.

• SIMD-ускорение для матричных операций.

• Детерминированность: одинаковый вход → одинаковый выход (важно для регрессионного тестирования).

• Компактное представление данных: структуры, а не объекты.

Решение: QuantCore.Net

QuantCore.Net — библиотека количественного анализа для .NET 8.0+, реализующая перечисленные принципы.

dotnet add package QuantCore.Net --version 0.1.5

Библиотека состоит из четырёх независимых модулей, которые можно использовать по отдельности.

Модуль 1: Black–Scholes ценообразование

Одиночный расчёт (для прототипирования)

using QuantCore.Net;
using QuantCore.Net.Pricing;
double price = BlackScholes.Price(
    type: OptionType.Call,
    s: 100.0,      // спот
    k: 100.0,      // страйк
    r: 0.03,       // безрисковая ставка
    q: 0.01,       // дивидендная доходность
    sigma: 0.20,   // волатильность
    t: 0.5         // время до экспирации (годы)
);
// price = ~7.96

Батчевый расчёт (для production)

Самый важный сценарий: оценить 100 000 опционов за один вызов без аллокаций.

int batchSize = 100000;
// Входные параметры (массивы должны быть предвыделены)
double[] spots = new double[batchSize];
double[] strikes = new double[batchSize];
double[] rates = new double[batchSize];
double[] dividends = new double[batchSize];
double[] vols = new double[batchSize];
double[] times = new double[batchSize];
double[] prices = new double[batchSize];
// ... заполняем входные массивы данными ...
BlackScholes.PriceBatch(
    type: OptionType.Call,
    s: spots,
    k: strikes,
    r: rates,
    q: dividends,
    sigma: vols,
    t: times,
    outPrice: prices  // <- результат записывается в этот массив
);
// prices[i] содержит цену i-го опциона

Ключевая деталь: outPrice — это параметр, а не возвращаемое значение. Вы передаёте свой массив, библиотека его заполняет. Ни одной аллокации внутри вызова.

Батчевые греки

// Массив структур Greeks (дельта, гамма, вега, тета, ро)
Greeks[] greeks = new Greeks[batchSize];
BlackScholes.GreeksBatch(
    type: OptionType.Put,
    s: spots,
    k: strikes,
    r: rates,
    q: dividends,
    sigma: vols,
    t: times,
    outGreeks: greeks
);
// Доступ к результатам
for (int i = 0; i < batchSize; i++)
{
    double delta = greeks[i].Delta;
    double gamma = greeks[i].Gamma;
    double vega = greeks[i].Vega;
    // ...
}

Модуль 2: Monte Carlo для европейских опционов

Когда аналитической формулы недостаточно (например, для более сложных условий), используется симуляция.

using QuantCore.Net.MonteCarlo;
double mcPrice = MonteCarloOptionPricing.PriceEuropeanGbmAntithetic(
    type: OptionType.Call,
    s: 100.0,
    k: 100.0,
    r: 0.03,
    q: 0.01,
    sigma: 0.20,
    t: 0.5,
    paths: 10000,
    seed: 12345        // детерминированный генератор
);

Особенности:

• Антитетические переменные уменьшают дисперсию без увеличения числа путей.

• Генератор XorShift128Plus даёт детерминированные результаты при одинаковом seed.

• Это важно для регрессионного тестирования: при изменении кода вы можете сравнить результаты с эталоном.

Модуль 3: Исторический риск (VaR и Expected Shortfall)

Для массива исторических PnL (прибылей и убытков) рассчитываются стандартные риск-метрики.

using QuantCore.Net.Risk;
double[] dailyPnl = LoadHistoricalPnl(); // массив дневных PnL
// Value at Risk на уровне 99%
double var99 = HistoricalRisk.ValueAtRisk(dailyPnl, alpha: 0.99);
// Expected Shortfall (CVaR) на уровне 99%
double es99 = HistoricalRisk.ExpectedShortfall(dailyPnl, alpha: 0.99);

Zero-аллокационный вариант (с пулом массивов)

Внутри ValueAtRisk обычно сортирует массив PnL. Сортировка изменяет порядок элементов. Если вы не хотите модифицировать исходный массив или создавать его копию, используйте overload с ArrayPool:

double var99 = HistoricalRisk.ValueAtRisk(dailyPnl, alpha: 0.99, usePool: true);
// Библиотека арендует временный массив из пула, сортирует его,
// возвращает в пул после использования. Аллокация — только при первом вызове.

Аналогично для Expected Shortfall:

double es99 = HistoricalRisk.ExpectedShortfall(dailyPnl, alpha: 0.99, usePool: true);

Модуль 4: Факторная модель PnL (SIMD)

В количественном анализе часто используется аппроксимация:

PnL ≈ Σ(экспозиция_фактор × доходность_фактора) × номинал

Например, 100 000 инструментов, 32 фактора (процентные ставки, валютные курсы, цены сырья и т.д.).

using QuantCore.Net.Risk;
using SlidingRank.FastOps;
int instruments = 100000;
int factors = 32;
// Матрица экспозиций: instruments × factors (row-major)
float[] exposures = new float[instruments * factors];
// Вектор факторных доходностей
float[] factorReturns = new float[factors];
// Номиналы инструментов
float[] notionals = new float[instruments];
// Результат: PnL для каждого инструмента
float[] pnl = new float[instruments];
// ... заполняем входные данные ...
FactorModelPnlFast.ComputePnL(
    exposures: exposures,
    factorReturns: factorReturns,
    notionals: notionals,
    outPnl: pnl
);

Внутри используется SIMD-умножение матрицы на вектор через SlidingRank.FastOps. Для 100 000 инструментов и 32 факторов — ~2.77 мс.

Производительность

Тестовый стенд: Intel Core i5-11400F (6 ядер, 12 потоков), Windows 11, .NET 8.0, BenchmarkDotNet 0.15.8

Практический смысл: портфель из 200 000 опционов пересчитывается за ~10–20 мс. Это оставляет запас на сеть, сериализацию и другие накладные расходы даже при жёстком SLA в 50 мс.

Пошаговая интеграция в существующий проект

Шаг 1. Установка

dotnet add package QuantCore.Net --version 0.1.5

Шаг 2. Предвыделение буферов (один раз при старте)

public class PricingService
{
    private readonly double[] _spots;
    private readonly double[] _strikes;
    private readonly double[] _rates;
    private readonly double[] _dividends;
    private readonly double[] _vols;
    private readonly double[] _times;
    private readonly double[] _prices;
    private readonly Greeks[] _greeks;
    public PricingService(int maxBatchSize)
    {
        _spots = new double[maxBatchSize];
        _strikes = new double[maxBatchSize];
        _rates = new double[maxBatchSize];
        _dividends = new double[maxBatchSize];
        _vols = new double[maxBatchSize];
        _times = new double[maxBatchSize];
        _prices = new double[maxBatchSize];
        _greeks = new Greeks[maxBatchSize];
    }
    
    // ...
}

Шаг 3. Заполнение входных данных

public void LoadPortfolio(Portfolio portfolio)
{
    for (int i = 0; i < portfolio.Instruments.Count; i++)
    {
        var opt = portfolio.Instruments[i];
        _spots[i] = opt.Spot;
        _strikes[i] = opt.Strike;
        _rates[i] = opt.RiskFreeRate;
        _dividends[i] = opt.DividendYield;
        _vols[i] = opt.ImpliedVolatility;
        _times[i] = opt.TimeToExpiry;
    }
}

Шаг 4. Выполнение расчёта

public double[] CalculatePrices()
{
    BlackScholes.PriceBatch(
        type: OptionType.Call,
        s: _spots,
        k: _strikes,
        r: _rates,
        q: _dividends,
        sigma: _vols,
        t: _times,
        outPrice: _prices
    );
    
    return _prices;
}

Шаг 5. Полный пример: сервис переоценки портфеля

public class PortfolioRevaluationService
{
    private readonly PricingService _pricing;
    private readonly RiskCalculator _risk;
    
    public async Task<PortfolioMetrics> Revaluate(Portfolio portfolio)
    {
        // 1. Цены и греки
        var prices = _pricing.CalculatePrices(portfolio.Options);
        var greeks = _pricing.CalculateGreeks(portfolio.Options);
        
        // 2. PnL по факторной модели
        var factorPnl = _risk.CalculateFactorPnL(portfolio.Exposures);
        
        // 3. Risk metrics
        var var95 = HistoricalRisk.ValueAtRisk(portfolio.HistoricalPnl, 0.95);
        var es95 = HistoricalRisk.ExpectedShortfall(portfolio.HistoricalPnl, 0.95);
        
        return new PortfolioMetrics
        {
            TotalValue = prices.Sum(),
            WeightedDelta = greeks.Sum(g => g.Delta),
            WeightedGamma = greeks.Sum(g => g.Gamma),
            VaR95 = var95,
            ES95 = es95
        };
    }
}

Когда использовать, а когда нет

Подходит для:

• Высокочастотная переоценка портфелей (риск-менеджмент, маржирование)

• Батчевые расчёты в торговых системах

• Регрессионное тестирование quantitative-моделей (детерминированный MC)

• Встраивание в .NET-сервисы без внешних C++ зависимостей

Не подходит для:

• Экзотических опционов с барьерами, отложенными решениями и т.д. (нужно расширение)

• Интерактивных Excel-надстроек с тысячами отдельных вызовов (лучше батчевый API)

• Ситуаций, где нужна double-точность для экстремально больших чисел (но float и так нормально для большинства risk-метрик)

Бесплатное использование — для оценки и некоммерческих проектов. Коммерческое использование требует покупки лицензии.

Где взять

NuGet: dotnet add package QuantCore.Net

Github (бенчмарки и примеры) - https://github.com/likeslines-maker/QuantCore.Net

QuantCore.Net — это библиотека для количественных расчётов на .NET, построенная вокруг трёх принципов: батчевость, zero-аллокации, SIMD.

Она не пытается заменить полноценные quantitative-библиотеки вроде QuantLib. Она решает конкретную узкую задачу: быстрое in-process ценообразование, риск-метрики и факторные модели для больших портфелей.

Если ваш риск-сервис тормозит на портфеле из 50 000 инструментов — попробуйте QuantCore.Net. Возможно, вы просто считали не тем способом.