Glossary

A

AADC++: LLVM/Clang-based compiler that eliminates the performance overhead of wholesale double to idouble integration, achieving near-native performance (1-5% overhead) when AADC recording is disabled while maintaining the simplicity of type redefinition integration.
Active Type: A data type (e.g., idouble, ibool, iint) that enables automatic differentiation and JIT compilation by tracking operations in the computational graph. Contrasts with passive types (double, bool, int64_t).
Active-to-Passive Conversion (A2P): The conversion of AADC active types to their native counterparts. Can be problematic if stochastic variables are converted during recording, potentially leading to incomplete computational graphs.
Adjoint: A value used in reverse-mode automatic differentiation representing the sensitivity of an output with respect to an intermediate or input variable. Also called adjoint seed when set for output variables.
Adjoint Seed: Initial values set on output variables before reverse pass execution, typically 1.0 for computing derivatives. Controls which partial derivatives are computed.
Automatic Differentiation (AD): A computational technique for calculating exact derivatives of functions specified by computer programs. AADC uses reverse-mode AD (backpropagation). See Wikipedia: Automatic Differentiation.
AVX2/AVX512: Advanced Vector Extensions instruction sets that enable SIMD (Single Instruction, Multiple Data) operations. AVX2 processes 4 doubles simultaneously, AVX512 processes 8 doubles. See Wikipedia: Advanced Vector Extensions.

B

Branch: A conditional execution path in code (if/else statements). AADC distinguishes between static branches (conditions don’t depend on kernel inputs) and stochastic branches (conditions depend on kernel inputs).
Branchless Execution: Execution strategy that avoids conditional jumps by using functional forms like iIf() instead of traditional if/else statements for stochastic conditions.

C

Checkpointing: Memory optimization technique that saves intermediate values at specific points during forward execution and restores them during reverse execution to reduce memory requirements. See Wikipedia: Checkpointing.
Computational Graph: Directed acyclic graph representing mathematical operations and data dependencies captured during the recording phase. Forms the basis for JIT compilation and automatic differentiation.
Constants: Variables with fixed values that don’t change between kernel executions and aren’t marked for differentiation (IsRandom=false, IsDiff=false).

D

Diff-only Variables: Variables marked with markAsDiff() that have fixed values during kernel execution but are needed for derivative computation (IsRandom=false, IsDiff=true).
Dynamic Index: Array index computed from kernel inputs that can vary between evaluations, requiring iint type for proper tracking in the computational graph.

F

Forward Pass: Execution of the compiled kernel to compute function values at specified input points. Typically runs 5-100x faster than original code due to JIT optimization.
Functional Form: Mathematical expression using functions like iIf() instead of control flow statements, required for stochastic conditions during recording.

I

ibool: AADC’s active boolean type that tracks logical operations in computational graphs involving conditional logic.
idouble: AADC’s primary active type, a drop-in replacement for double that enables JIT compilation and automatic differentiation.
iIf(): Functional conditional operation analogous to Excel’s IF() function, used for stochastic branches during recording.
iint: AADC’s active integer type for tracking integer operations and array indexing in computational graphs.
Implicit Function Theorem (IFT): Mathematical technique used in AADC for handling iterative algorithms and optimization problems with automatic differentiation. See Wikipedia: Implicit Function Theorem.
IsRandom Flag: Internal flag indicating whether a variable connects to graph inputs that can change between kernel executions.
IsDiff Flag: Internal flag indicating whether a variable connects to graph inputs used for derivative computation.

J

JIT Compilation: Just-In-Time compilation that transforms recorded mathematical operations into optimized machine code for fast execution. See Wikipedia: Just-in-time compilation.

K

Kernel: Compiled representation of a mathematical function that can be executed repeatedly with different input values. Created by the AADCFunctions class.

L

Lower Bound: Binary search operation implemented in AADC for finding positions in sorted arrays, useful for interpolation and lookup operations.

M

markAsInput(): Method that designates a variable as a kernel input that can vary between executions and requires derivatives (sets IsRandom=true, IsDiff=true).
markAsDiff(): Method that designates a variable as needing derivatives but with fixed values during execution (sets IsRandom=false, IsDiff=true).
markAsInputNoDiff(): Method that designates a variable as varying between executions but not requiring derivatives (sets IsRandom=true, IsDiff=false).
markAsOutput(): Method that designates a variable as a function output, creating a handle for retrieving values and setting adjoint seeds.
mmType: Template parameter specifying SIMD instruction set for vectorized execution (e.g., __m256d for AVX2, __m512d for AVX512).

P

Passive Type: Native C++ data types (double, bool, int64_t) that don’t participate in automatic differentiation or JIT compilation.
Primal: The original function value computation, as opposed to derivative computation. “Faster than primal” refers to AADC’s ability to compute both function and derivatives faster than original code computes just function values.

R

Recording Phase: Period between startRecording() and stopRecording() when AADC captures the computational graph of mathematical operations.
Reverse Pass: Execution of the reverse-mode automatic differentiation algorithm to compute derivatives via backpropagation through the computational graph.
Random Variables: Variables with IsRandom=true that can have different values between kernel executions, typically marked with markAsInput() or markAsInputNoDiff().

S

SIMD: Single Instruction, Multiple Data - parallel processing technique that performs the same operation on multiple data elements simultaneously. See Wikipedia: SIMD.
Static Branch: Conditional logic where the condition doesn’t depend on kernel inputs, allowing use of traditional if/else statements.
Static Index: Fixed array index that doesn’t depend on kernel inputs, can use native integer types.
Stochastic Branch: Conditional logic where the condition depends on kernel inputs, requiring functional forms like iIf() during recording.
Stochastic Variables: Variables whose values can affect execution paths during kernel evaluation, requiring special handling for branches and conversions.

T

Tape: Data structure used in automatic differentiation to store intermediate values and operations needed for gradient computation.
TestDriver: AADC’s automated testing framework template that validates function compilation, execution, and automatic differentiation accuracy by comparing active type implementations against passive reference implementations using random inputs and finite difference gradient checking.

V

Vectorization: SIMD optimization that processes multiple values simultaneously, automatically applied by AADC for performance improvement. See Wikipedia: Vectorization.

W

Workspace: Execution context (AADCWorkSpace) that provides memory and state management for compiled kernels, including input values, intermediate variables, and adjoint values.

Note: This glossary covers core AADC concepts. For detailed implementation information, refer to the specific documentation sections for each topic.