Getting real performance from pricing and risk models requires thinking about everything: architecture, coding patterns, optimisations, and AAD.

We Built the Compiler.
So You Don't Have To.

AADC is a specialized JIT compiler that extracts your valuation graph and accelerates existing C++ and Python code—with minimal code changes. All sensitivities computed automatically.

Integration Should Take
Days, Not Months

AADC uses operator overloading to capture your calculations as they run. No extensive refactoring. No new language to learn. No weeks of training.

• ✓ Typically less than 1% code changes
• ✓ No C++ template complexity
• ✓ Works with your existing design patterns
• ✓ NumPy and Python supported

Your Code. Minimal Changes.
Major Results.

Same logic. Type changes and recording setup. 6-1000× faster with all sensitivities.

import numpy as np

# Vectorized NumPy Monte Carlo
def monte_carlo_european(S0, K, r, sigma, T, n_paths):
    dt = T / 252

    # Simulate GBM paths
    Z = np.random.randn(n_paths, 252)
    S = S0 * np.exp(np.cumsum((r - 0.5*sigma**2)*dt +
                    sigma*np.sqrt(dt)*Z, axis=1))

    payoffs = np.maximum(S[:,-1] - K, 0)
    return np.exp(-r*T) * np.mean(payoffs)

# Call function - returns value only
price = monte_carlo_european(100, 100, 0.05, 0.2, 1.0, 100000)

import aadc
import numpy as np

# Same NumPy code - no changes needed
def monte_carlo_european(S0, K, r, sigma, T, n_paths):
    dt = T / 252

    # Simulate GBM paths
    Z = np.random.randn(n_paths, 252)
    S = S0 * np.exp(np.cumsum((r - 0.5*sigma**2)*dt +
                    sigma*np.sqrt(dt)*Z, axis=1))

    payoffs = np.maximum(S[:,-1] - K, 0)
    return np.exp(-r*T) * np.mean(payoffs)

# One line to accelerate + get all Greeks
fast_mc = aadc.record(monte_carlo_european)
price, greeks = fast_mc(100, 100, 0.05, 0.2, 1.0, 100000)

Capturing Your
Valuation Graph

When your code runs with AADC types, operator overloading captures a stream of elementary operations—building the complete computational graph of your valuation. This graph becomes the blueprint for optimization and automatic differentiation.

• ✓ Captures full computation structure
• ✓ Handles branches and conditions
• ✓ Supports nested function calls
• ✓ Works across C++ and Python boundaries

The Fastest Graph
Compilation Available

Traditional compilers (LLVM, GCC) aren't designed for runtime compilation of large computational graphs. Compilation time becomes part of your execution time. AADC's specialized JIT compiler is built specifically for financial valuation graphs—optimized for the patterns that appear in pricing and risk models.

• ✓ Purpose-built for financial computations
• ✓ Handles graphs with millions of operations
• ✓ Compilation time suitable for production use

Monte Carlo:
From Hours to Seconds

AADC compiles your Monte Carlo simulation into a single, optimized kernel: automatic vectorization (AVX2/AVX512), automatic multi-threading, cache-optimized memory layout, no interpreter overhead (Python).

• ✓ XVA calculations
• ✓ VaR & stress testing
• ✓ Exotic derivatives pricing
• ✓ American Monte Carlo (Longstaff-Schwartz)

All Greeks. Automatically.
Adjoint Factor < 1.

AADC computes all sensitivities automatically using Adjoint Algorithmic Differentiation—no manual derivative coding. The breakthrough: adjoint factor <1 means computing the price plus all Greeks takes less time than computing just the price with your original code.

Live Risk. For Everyone.

Real-time portfolio revaluation with automatic Greeks. Choose your path.

However You're Starting,
AADC Fits

Whether you're building new, modernizing old, replacing vendors, or cutting cloud costs—the same technology applies.

Beyond Finance:
ML & Scientific Computing

AADC's JIT compilation and automatic differentiation work for any numerical code—not just finance.

• ✓ Neural network training
• ✓ Time series analysis
• ✓ Physics simulations
• ✓ Optimization problems

"For applications like time series analysis, recursive neural nets, and similar, the performance of MatLogica AADC is impressive."

— Dr. Roland Olsson, Østfold University College

Performance
Without Compromise

We've thought about the hard problems—so you can focus on finance.

What Practitioners Say

Antoine Savine

Author, Modern Computational Finance

MatLogica offers a unique AAD engine, bundled with a purposely developed just-in-time compiler, whereby banks can effortlessly optimize existing code with AAD, into machine code optimized for modern hardware. Because of this optimizing compiler, Matlogica's offering currently stands way above competition. I have seen the results and they are truly impressive.

Senior Quant

Tier-2 European Bank

One notable feature of AADC is that complex model calibration procedures do not require any special attention as is often the case with other AAD approaches. For example, we 'AADC-record' simple Dupire volatility calculations, regression-based continuation value calibration and even Monte-Carlo based Cheyette model calibrations, with no special care needed to back-propagate adjoints. This has allowed us to eliminate a large amount of complex and hard to maintain code.

Luigi Ballabio

Co-founder and Administrator, QuantLib

I've been very impressed by performance gains up to two orders of magnitude obtained by MatLogica after some integration work on QuantLib, and by the fact that the same work also enabled AAD; especially considering that the library contains hundreds of thousands of lines of code developed over more than 20 years.

Sid Dash

Chief Researcher at Chartis Research (2025)

MatLogica's suite of tools enables acceleration and scalability in both analytical and quantitative code.The transformational nature of MatLogica's offering is reflected in its top 15 placing in the QuantitativeAnalytics50, alongside several awards for innovation in computational frameworks and code acceleration.