150× Faster JIT Compilation.
82ms Graph Build.

Total eval time (JIT compilation + execution) represents the true wall-clock time users experience in production. JAX shows 6.5s eval_time but 19s total_eval_time because of 12.5s JIT compilation. AADC shows 6.4s eval_time and 6.5s total_eval_time because JIT compilation is only 82ms. JIT compilation repeats on every cold start (model changes, parameter updates, restarts), so total_eval_time is what matters in production.

AADC JIT graph compilation takes 82ms compared to 12,500ms (12.5 seconds) for JAX XLA - that's 150× faster. This makes AADC ideal for real-time pricing where trade structures change frequently and JIT compilation overhead cannot be amortized.

AADC Python computes Greeks 4.1× faster than PyTorch (6,529ms vs 26,407ms total time). Note: PyTorch runs at 1 thread (Python GIL), while AADC uses 8 threads. AADC uses 195MB memory compared to PyTorch's 192MB.

AAD methods add approximately 26-31% overhead to compute Greeks (Delta, Rho, Vega) compared to price-only calculation. Finite difference requires 4× full pricing runs, resulting in 300-600% overhead depending on implementation.

Use AADC for real-time pricing with dynamic trade structures where JIT compilation time matters. JAX is fast after warm-up (6.5s Greeks execution) but the 12.5s JIT compilation penalty makes it unsuitable when trade parameters change frequently. AADC's 82ms JIT compilation enables responsive pricing.

AADC C++ is fastest at 2.2s for Greeks execution. JAX is competitive at 6.5s once JIT-compiled. However, JAX's 12.5s JIT compilation time means AADC Python (6.4s + 82ms compile = 6.5s total) beats JAX (6.5s + 12.5s compile = 19s total) for first-run scenarios.

AADC Python uses 195MB peak memory during Greeks computation. PyTorch uses 192MB, JAX uses 80MB, and TensorFlow uses 200MB. All frameworks are memory-efficient at this scale.

GBM Asian Option Monte Carlo with 100 trades, 100,000 scenarios, 252 timesteps, and 8 threads for AADC/C++. Note: NumPy, PyTorch, Autograd run at 1 thread due to Python GIL. This represents a realistic production workload for derivatives pricing with Greeks computation (Delta, Rho, Vega).

Yes. AADC combines fast compilation (82ms), efficient execution (6.4s for Greeks), reasonable memory usage (195MB), and minimal code changes (176 lines). It's designed for production quant systems where real-time pricing, dynamic trade parameters, and low latency are requirements.

AADC Python requires only 176 lines of integration code. NumPy needs 781 lines, Autograd needs 629, PyTorch needs 350, JAX needs 400, and TensorFlow needs 450 lines. AADC C++ requires just 50 lines of changes.

TensorFlow has the slowest JIT compilation at 18,000ms (18 seconds) due to its graph compilation and optimization passes. While it produces efficient execution code (6.1s for Greeks), the JIT compilation overhead makes it unsuitable for dynamic trade structures.

JIT compilation is problematic in scenarios requiring dynamic pricing: (1) RFQs needing instant quotes for new trade structures, (2) Intraday risk recalculation with changing parameters, (3) Production systems with frequent restarts, (4) Exotic derivatives with unique payoff structures. JAX (12.5s), TensorFlow (18s), and Enzyme-AD (2s) all suffer from JIT compilation overhead that makes real-time pricing impractical.

NAG dco/c++ is a tape-based AAD library similar to Adept. Based on benchmarks with similar tape-based tools, NAG dco/c++ performance should be comparable to Adept results - approximately 6-100× slower than AADC. NAG uses operator overloading with tape recording, while AADC uses Code Generation AAD with JIT compilation to binary kernels, which is fundamentally faster.

Tape-based AAD (CppAD, Adept, NAG dco/c++) stores operations to a tape during forward pass, then replays in reverse. This has memory overhead and cache-unfriendly access patterns. AADC uses Code Generation AAD which JIT compiles the computational graph into optimized binary kernels with AVX2/AVX512 vectorization, eliminating tape overhead and achieving adjoint factor less than 1.

Enzyme-AD is the fastest open-source AAD tool, but it's still significantly slower than AADC. Enzyme-AD has 2,054ms JIT compilation time and 61,010ms Greeks execution (63s total) compared to AADC Python's 82ms compile + 6,447ms execution (6.5s total) - about 10× slower overall.