AADC++ Compiler

The AADC++ compiler eliminates the performance trade-offs of wholesale double to idouble integration, enabling developers to use active types everywhere without performance concerns.

The Performance Trade-off Problem

When integrating AADC using the type redefinition approach (double → idouble), every mathematical operation includes recording checks, even when AADC recording is disabled. This creates a performance penalty in non-recording sections:

50-150% slowdown for code not using AADC recording (per-operation flag checks)
Trade-off consideration: While critical sections (Monte Carlo, calibration, risk calculations) benefit enormously from AADC’s JIT compilation and AAD capabilities, non-critical sections suffer performance degradation

In most cases, the significant performance gains in bottleneck areas should outweigh losses in non-critical sections. However, this trade-off can be concerning for performance-sensitive applications.

AADC++ Solution: No Trade-offs

For professional users requiring optimal performance across all code paths, Matlogica offers the AADC++ compiler. This optimization technology delivers a no trade-off solution:

Use active types everywhere without performance guilt
Near-native performance when recording is disabled
Full AADC benefits when recording is enabled
Simple integration - same code works optimally in both modes
Multi-thread friendly - non-recording threads unaffected by other threads’ recording

Key Benefits

Eliminates Performance Anxiety

1-5% overhead vs. native double when recording is disabled
No performance trade-offs - use idouble throughout your codebase
Consistent performance across AADC and non-AADC code paths

Maintains Integration Simplicity

Single codebase works optimally in both recording and non-recording modes
Automatic optimization requires no code changes
Drop-in replacement for standard compilation

Production Ready

Available with production AADC licenses
LLVM/Clang integration works with modern build systems
Proven performance in large-scale quantitative applications

Real-World Impact

The AADC++ compiler transforms the integration decision from:

“Should we use active types here? Will it slow down this section?”

To:

“Use active types everywhere and focus on building great analytics!”

This removes the cognitive overhead of deciding where to apply AADC optimization and enables teams to:

Integrate AADC comprehensively without performance concerns
Simplify architecture decisions by eliminating active/passive boundaries
Focus on mathematical modeling rather than performance optimization
Scale AAD adoption across entire analytical libraries

Use active types everywhere and don’t feel guilty about it!

This is a preview of AADC++ documentation.

The full documentation includes implementation details, performance benchmarks, integration guides, and configuration options.