Index

  • AADET, 504, 513, 520–522
  • Acceleration, expression templates (usage), 503
  • Accessors, 218–221, 380
  • Accumulator, updating, 28
  • Active calculations, 408–409
  • Active local volatilities, 424
  • Active Numbers, counting, 517
  • Active object, 54–55, 75
  • Active wait, 104–108
  • Acyclic graphs, 326
  • Adapters, lambda function, 27
  • Adjoint, 344–349, 416, 444, 490
    • back-propagation, 431
    • calculus, application, 441
    • path-wise back-propagation, 410
    • propagation, 341–342, 415, 486
    • pushing, ease, 519
  • Adjoint differentiation (AD), 291–319
  • Adjoint mathematics, 340–344
  • Adjoints, back-propagation, 379
  • Administrative overhead, 350
  • Administrative work, conducting, 253
  • Advanced synchronization, 80–83
  • Affinity, 50
  • Aggregator, usage, 411
  • Algorithmic adjoint differentiation (AAD), 9–12, 15, 120, 287, 321
    • allowance, 57
    • benefit, 230
    • bugs, causes, 543
    • constant time, 289
    • context, 188, 393
    • discussion, 401
    • effectiveness, 357
    • instrumentation, debugging, 541
    • library support, 487–494
    • limitations, 401
    • noninvasiveness, 289
    • origins, 290
    • parallelism, combination, 435
    • upgrade, 219
    • usage, 140, 161, 241
  • Amdahl's law, 11
  • American options, 135–137
  • Analytic differentiation, 305
  • Annuity, 147
  • Antithetic sampling, 202
  • Arrow-Debreu security, 156
  • Asian options, 134
  • Asset prices, forwards, 148
  • Asset pricing, 127
  • Asset pricing theorem (APT), 140–151
  • Asymptotic differentiation time, 483–484
  • Async, 89–90
  • Asynchronous tasks, completion, 109
  • Atomics, 87, 88
  • Atomic types, 86–89
  • Automatic AD (AAD), 305–306, 318–319, 447
  • Average payoff, differential, 403
  • AVX2, 9–10, 20, 23
  • AVX512, processing, 10
  • Back-propagation, 304–308, 385, 389–390
    • deep learning, relationship, 315
    • equation, 487
    • time, computation, 359
    • usage, 443
  • Backward auto-differentiation, 289
  • Backward differentiation, propagation, 293
  • Balanced sampling, 210
  • Bank account, 141
  • Barriers, 80, 82, 134–135, 234–238
  • Base classes, 218–222, 227
  • Basket options, 134–135
  • Binary constructor, 387, 394
  • Binary decomposition, consideration, 277
  • Binary nodes, 505
  • Binary operations, 230, 525–526
  • Binary operator, 527–528, 531–534
  • Binomial trees, 179
  • Bisection, implementation, 117
  • Black and Scholes (BS), 161–162, 197, 245, 544
  • Black and Scholes (BS) formula, 165–166, 295–297, 450
  • Black and Scholes (BS) market-implied volatilities, 457
  • Black-Scholes inputs, 308
  • Blocklist, 362, 363–376
  • Boost.Thread, usage, 12–13
  • Breadth-first traversal, 348–349
  • Brownian Bridge formula, 189–190
  • Brownian increments, impact, 169
  • Brownian motion, 141, 170, 174, 178, 186, 450
  • Brownian path, 173
  • Bugs, 113–114, 543–544
  • Bump risk, comparison, 475
  • Bumps, implementation, 422
  • C++, 17, 25, 47
    • functional programming, usage, 28–33
    • idioms, 524
    • mathematical functions, 531
  • Cache, 59–60, 293–294
  • Calculation, 23, 299–301, 327
  • Calculation graphs, 322–328
  • Calibration, 439–447, 475–478
  • Callable argument, 51, 85
  • Callable object, 25–27
  • Callable product, 134, 190–192
  • Callables, 94–95, 137–138
  • Call options, 165, 296
  • Call-put parity, 165
  • Calls/puts, 127
  • Cancellable cash flows, 136
  • Cancellable products, 135–137
  • Caplet, 134
  • Caps/floors, 127
  • Capture clause, 25, 53
  • Carr-Madan, formula, 133, 151, 154
  • Cash-flows, 127–129, 139, 142–143, 164
  • Casual vectorization, application, 12
  • Central Processing Unit (CPU), 8–9, 104, 118–119
    • caches, 18, 61
    • core, consumption, 66–67
    • sampling, 120
    • time, 255
  • Child adjoints, pointer storage, 359
  • Child nodes, 322, 341
  • Cholesky decomposition, 194, 446
  • Closed-form derivatives, impact, 298
  • Close memory, concurrent writing, 62
  • Close-to-the-metal programming, 74
  • Coalescent data, access, 23
  • Coalescent memory, 18, 21
  • Code, 115, 120
    • DAGS, usage (avoidance), 327
    • serialization, locks (usage), 65
  • Collection, conversion, 388–389
  • Comparison operators, usage, 397, 532–533
  • Compiler, inlining, 515
  • Complexity, convergence (relationship), 187–188
  • Composite pattern, 510
  • Computation, completeness, 91
  • Computer programs, calculation graphs (relationship), 325
  • Compute Unified Device Architecture (CUDA), 8
  • Concrete models, 245–263
  • Concrete products, 230–244
  • Concurrent data structures, 72–74
  • Concurrent efficiency, 117, 118
  • Concurrent lambda, 110
  • Concurrent lock-free allocator, 18
  • Concurrent programming, 7–8
  • Condition variables (CVs), 74–80
  • Constant maturity swap (CMS), 149–151
  • Constant time, 306–307, 483, 499–501
  • Constant time computation, 443–444
  • Constant-time differentiation, 518–520
  • Constant time risk reports, production, 401
  • Const incorrectness, 391–393
  • Consumers, 75
  • Context switches, 24
  • Contingent floater, 241–244
  • Continuous path-dependence, 189–190
  • Control flow, 326–328, 402–403
  • Control variates, 188, 202
  • Convergence, 187–188, 199
  • Conversions, 388–389
  • Convexity adjustment, 150
  • Convolution kernels, usage, 289
  • Copula, 158
  • Copy assignment operator, 34
  • Copy constructors operator, 34
  • Cores, 47
  • Corridors, 135
  • Counterparty credit adjustment (CCR), 139
  • Counterparty Value Adjustment (CVA), 15, 138–140
  • Covariance matrix, 194
  • C++, Python (relationship), 17–18
  • Craig-Sneyd scheme, 182
  • Crank-Nicolson (CN) scheme, 181
  • Credit counterparty risk (CCR), 161
  • Credit spreads/events, 215
  • Critical sections, 64
  • Cross-derivatives, treatment, 182
  • Cumulative distribution, 322
  • Cumulative Gaussian distribution, 385–386
  • Cumulative probability distribution, 157
  • Curiously recursive template pattern (CRTP), 509–512, 524
  • Currencies, 127, 129
  • Danske Bank systems, AAD implementation, 290
  • Data, 55–56, 62–64, 89
    • members, 379–380
    • ownership, swapping, 37
  • Deadlocks, 67–68
  • Debugging programs, 113–121
  • Deep learning, 192, 315
  • Delta, 466, 469
  • Depth-first postorder, 332
  • Deque, 72
  • Dereference, 44
  • Derivative chain rule, 341
  • Derivatives, 151, 298, 437
  • Derivative sensitivities, 142
  • Design Patterns (Gamma/Helm/Johnson/Vlissides), 223
  • Differentials, 292, 340, 478
  • Differentiated aggregate, value, 417
  • Differentiation, 297–299, 321, 476–477
    • algorithm, 417
    • analytic differentiation, 305
    • complexity (reduction), AAD (usage), 293
    • constant-time differentiation, 518–520
    • linear complexity, 287
  • Diffusive models, presentation, 178
  • Dirac mass, 156, 448
  • Directed acyclic graphs (DAGs), 326–331, 344–349, 505, 510
    • control flow, relationship, 326–328
    • creation, cost, 507
    • edges, 394
    • nodes, processing, 342
    • topological order, 350
  • Direction numbers (Sobol), 205, 207–208, 211–212
  • Discontinuous cash-flows, usage, 237–238
  • Discount basis, ignoring, 150
  • Discount curve, 130
  • Discount factors, 175, 296
  • DiscountMats (vector), 216, 234
  • Discount rate, 131
  • Discrepancy, minimization, 205
  • Discretely monitored barrier, 135, 189
  • Discrete path-dependence, 189
  • Distributed programming, 7–8
  • Divide-and-conquer idiom, 3–4
  • Dividend-paying asset, holding, 161
  • Dividends, schedule, 130
  • Domain-specific knowledge, 407
  • Double checked locking, proposal, 85
  • Doublers, building, 392
  • Doubles, usage, 388, 408, 530
  • Duck-typing, 29
  • Dupire, Bruno, 268–270
    • bi-dimensional local volatility surface, 178
    • formula, 155, 166–167, 440, 448–449
    • local volatility model, 183–184
    • model, 254–263, 424, 453–456
  • Dynamic models, 158–161, 177–179, 186, 192–200
  • Dynamic polymorphism, usage, 361
  • Early exerciseable product, 134–135
  • Eigenvalue decomposition, 446
  • Elements, reduction, 5
  • Euler, scheme, 198–200
  • European call, 133, 154, 231–234, 450–451, 472
  • European cash-flow, 156–158, 181
  • European models, 154–158
  • European options, 127, 168, 238, 254, 317
  • European portfolio, 238–241
  • European products, pricing, 156–157
  • European put, 133
  • Event dates, 129, 199
  • Event-driven behavior, 74–75
  • Exercise date, 133
  • Exotics, 127, 134–135, 157, 183
  • Expectations Ek(sk), defining, 153
  • Expiry, 133
  • Explicit calibration, 448–475
  • Explicit qualifier, usage, 383
  • Exponential martingale, usage, 164–165
  • Exposure schedule, 139
  • Expression DAGs, 506, 519
  • Expressions, 504–507, 512–540
  • Fallback, 183, 198
  • False constness, 71
  • False sharing, 57–62, 120
  • Feynman-Kac, theorem, 179
  • Finance, 14–15, 315–319
  • Financial cash-flows (replication), self-financing strategies (usage), 140
  • Financial derivatives, calibration, 316–318
  • Financial models, 151
  • Financial products, 127–140
  • Finite difference method (FDM), 6–7, 138–139, 160, 179–184
  • Finite difference superbucket risk, 469–471
  • First axis, direction numbers, 207–208
  • First-generation foreign exchange exotics, 183
  • First-order derivatives, computation, 402
  • Fixing date, 152
  • Flattening, occurrence, 523
  • Floorlet, 134
  • Forward bank account, 146
  • Forward contracts, 131, 144–145
  • Forward discount factors, 145–146, 148
  • Forward discount rates, 146
  • Forward factors, 253
  • Forward Libor, 131–132, 137
  • Forward measures, 144–151, 162–163
  • Forward, natural measure, 148
  • Forward-neutral measures, means (implication), 144–145
  • Forward prices, 144–145
  • Forward rate agreement (FRA), 131–132, 145
  • Forward rates, 131–132, 145, 175
  • Forward scenario (ΩF), 153
  • ForwardsMats (vector), 216, 234
  • Forward swap rate, 133
  • Functional algorithms, requirements, 105
  • Functional programming, 25–26, 28–33, 71
  • Function literal, assignation, 29
  • Function object, 26–29, 51–52
  • Functions, 29–31, 89
  • Future discount factors, forward-neutral expectations, 145–146
  • Futures, 90, 91, 272
  • Future values, dependency, 138
  • Fuzzy logic, 289
  • Gamma, Erich, 223
  • Gang of four (GOF), 223, 263, 510, 526
  • Gatheral's SVI, 155, 449, 453
  • Gaussian density, 322, 385, 397
  • Gaussian distribution, 175, 385
  • Gaussian first increments, 150
  • Gaussian functions, 387, 447, 531
  • Gaussian number, 193, 202
  • Gaussian random vector, 403
  • Gaussian sampling, 196
  • Gaussian scalars, 200
  • Gaussian scheme, expectations/variances/standard deviations, 253–254
  • Gaussian transformation, 210
  • Gaussian transition probabilities, usages, 197
  • Gaussian variables, 166, 172–173, 194, 197
  • Gaussian vector, 203, 214, 429
  • Generality, loss, 143
  • Generalized derivatives (Schwartz), 155
  • Girsanov, theorem, 150, 164, 170
  • Graphical User Interface (GUI), freezing (impossibility), 90
  • Graphic Processing Unit (GPU), 8–9
  • Hagan SABR, 453
  • Hand-crafted loops, 12, 23, 27–28, 59, 61, 115
  • Hardware concurrency, 119
  • Hardware threads, 24, 47
  • Haskell (functional language), 4, 28, 33, 71
  • Headers, signatures (usage), 446
  • Heap data, access, 61
  • Heath-Jarrow-Morton (HJM) formula, 169, 172–177
  • Heath-Jarrow-Morton (HJM) framework, 169–171
  • Hedge coefficients, 141, 407, 440
  • Helm, Richard, 223
  • Heston model, 155, 160, 200
  • Higher-order derivatives, 402
  • Higher-order functions, 27, 29, 445
  • High-level parallelism, 7
  • Huge analogy, usage, 291
  • Hybrid option, 139
  • Hypercube, sampling, 210
  • Hyper-threaded cores, usage, 59
  • Hyper-threading, 24, 50
  • Idiom, usage, 4
  • Implicit branches, 68
  • Implicit calibration, 475–481
  • Implicit Function Theorem, 440, 476–479
  • Implied volatility, 155, 166, 448, 453, 457
  • Implied volatility surface (IVS), 155–159, 167, 245, 449–453
  • Incremental sampling, 210
  • Initialization (protection), locks (usage), 84
  • Initializers, 212
  • Initial value conditions, 152
  • Inputs/outputs, 401–402
  • Instantaneous forward rate (IFR), 131, 145–146, 172
  • Instructions, thread pools (usage), 108–109
  • Instrumentation, 398–395, 542
  • Integral types, 88
  • Integrated Performance Primitive (IPP), 10
  • Interest rate models, 169–177
  • Interest rate swap (IRS), 128–129, 132–133, 146–147
  • Interface, definition, 223
  • Interruption, 100–102
  • Introspection, 321
  • Inverse chi-square distribution, 193
  • Inverse Gaussian, 426
  • Iterative calibration, 475–476
  • Iterators, addition, 365
  • Ito's lemma, application, 163, 448
  • Jacobian matrices, 292, 483
  • Jacobians, 292–293, 443–444, 476–477
  • Johnson, Ralph, 223
  • Joint distribution, 157, 197, 211
  • Jump-diffusion model (Merton), 449–453
  • Koksma-Hhlawka inequality, 204–205
  • L3 cache contention, 120
  • Lambda, 27, 53, 110
  • Lambda expressions, 25–28
  • Latin hypercube, 188, 208–211
  • Launch policy, 90
  • Lazy evaluation, 331–335, 351, 516
  • Lazy initialization, 83–86
  • Leaf nodes, 382–385
  • Least squares method (LSM), 138, 191
  • Leaves (childless nodes), 322
  • L'Ecuyer, random generator, 223
  • Levenberg-Marquardt algorithm, 317
  • lhs (left-hand side), 394
  • Libor basis, 132
  • Libor coupons, payment, 128
  • LiborDefs (vector), 216
  • Libor Market Model (LMM), 134, 171–172, 317, 480
  • Lifting, 31–33
  • Linear acceleration, achievement, 11
  • Linear algebra, loops (relationship), 314–315
  • Linear cash-flows, definition, 133
  • Linear complexity, 187–188
  • Linear Gauss Markov (LGM), 174, 175, 186, 197, 220
  • Linear improvement, 6
  • Linear models, 152–154
  • Linear performance improvement, 17
  • Linear products, 133, 149
  • Linear rate market (LRM), 479–480
  • Linear time, characteristic, 402
  • Linear transactions, 131–133
  • Load balancing, 112–113, 119
  • Local volatility, 255, 266, 288
  • Local volatility surface, 167
  • Lockable interface, implementation, 68
  • Lockable objects, 67
  • Lock-free algorithms, usage, 89
  • Locking (operation), 18
  • Locks, 64–72, 77, 82–83, 87, 120
  • Logarithmic complexity, 274
  • Logical cores, 47, 119
  • Logic efficiency, 117
  • Log-moneyness, 296
  • Longstaff-Schwartz algorithm, usage, 405
  • Loops, 11, 22–23, 89–90, 314–315
  • Loosely coupled models/products, 192
  • Low-dimension Monte-Carlo simulation, 172
  • Low-discrepancy sequences, 204–205
  • Machine learning, applications, 315–319
  • Main thread, 47
  • Manual adjoint differentiation, 295, 318–319
  • Marginal distributions, 155, 157, 210, 211
  • Market-implied volatilities, 424, 456
  • Market risks, 440
  • Market samples, collection, 151
  • Market variable, 148–149, 158–159, 407
  • Markov dynamic, postulation, 174
  • Markov interest rate model, 182
  • Martingales, 143, 147, 164–167
  • Mathematical operations, 325
  • Math Kernel Library (MKL), 10
  • Matrix algebra, usage, 314–315
  • Matrix class, 21, 255
  • Matrix products, associative characteristics, 292
  • Maturity, 131, 133, 170
  • Memory, 22, 72, 362, 366, 403–405
  • Merton IVS, parameterization, 457
  • Merton, jump-diffusion model, 449–453
  • Merton price, calculation, 472
  • Message Passing Interface (MPI), 7
  • Meta-programming, 321
  • Meyers, Scott, 28
  • MFC. See Multifactor Cheyette
  • Microbucket, 424, 439, 466, 468, 500–501
  • Model hierarchies, 479–481
  • Model parameters, 407, 408
  • Model risk, 159
  • Model sensitivities, check-pointing, 456–457
  • Modulo discrete time, 204
  • Monte-Carlo (MC), 54, 118, 268, 416
    • algorithm, 185–192, 222
    • numerical integration, 202–204
    • risk sensitivities, instability (mitigation), 237–238
    • simulator, 54–55
  • Monte-Carlo (MC) simulation, 6, 14, 74, 121, 223
    • context, 125
    • convergence, 210
    • linear models, suitability, 154
    • low-dimension Monte-Carlo simulation, 172
    • usage, 129, 324
    • variation, 135
  • Moore's law, deceleration, 14
  • Moro's approximation, 193
  • Moveable objects, 53
  • Move semantics, 34–41
  • MRG32k3a, 223–228, 276–281
  • Multidimensional adjoints, 485–487
  • Multidimensional differentiation, 483–485
  • Multidimensional distribution, random number (drawing), 194
  • Multidimensional FDM, differentiation, 439
  • Multifactor Cheyette (MFC), 177, 317
  • Multinomial node, 523, 536
  • Multiplier class, 391–392
  • Multi-threaded application, 48
  • Multi-threaded Hello World, 49–50
  • Multi-threaded programs, 13–14, 108
  • Multi-threaded template algorithms, 495
  • Multi-threading (MT), 9–13, 58, 111, 115, 424
  • Multi-underlying/multi-currency models/products, 215
  • Mutable objects, 71–72, 109–112, 273, 392, 426
  • Mutex, 64–67, 74, 80–82
  • Natural numeraires, 147–150
  • Nested MC Simulations, 190–191
  • Nest moduli, 278
  • Netting set, 138
  • Nodes, 322, 326–327, 381–387, 512
    • class, 359–362, 489–491
    • mathematical operation representation, 481
    • multinomial node, creation, 523
    • processing, 342
    • static multidimensional indicators, 487–489
    • visitation, 347
  • Non-callable products, payment, 136
  • Non-const pointers, 392
  • Non-European exotics, characteristics, 157
  • Non-Gaussian schemes, accommodation, 214
  • Non-Markov model, 171
  • Non-parametric distribution, computation, 57
  • Number class, 379–398, 493–494
  • Numbers, collection (conversion), 388–389
  • Numeraire, 142–150, 162–165, 170, 179
  • Numerical minimization, 476
  • Numerical Recipes, 19
  • Object-oriented (OO) architecture, usage, 324
  • Object Oriented Design (OOD), 213
  • Object-oriented (OO) polymorphism, 509
  • Observation date (fixing date), 152
  • One-dimensional FDM, 160
  • One-dimensional Markov specification, benefit, 176
  • One-factor Gaussian form, 172
  • One-sided finite differences, usage, 297
  • One-time callable exercise date, 136
  • OpenMP, 12–13, 24, 89–90
  • Operating system (OS), independence, 91
  • Operation, 297, 507
  • Operator nodes, 385–387
  • Operator overloading, 291, 321, 393–398
  • Options, 135–137, 139, 167, 295
  • Order independence, 211
  • Overloading, 387, 511
  • Packaged tasks, 94–96
  • Parallel acceleration, 59
  • Parallel algorithms, 3–7
  • Parallel C++, 47
  • Parallel computing, usage, 14–15
  • Parallel designs, 94
  • Parallel efficiency, 11
  • Parallel execution, 118
  • Parallel implementation, 271, 283–284
  • Parallelism, 65, 183–184, 230, 435
  • Parallel logic, profiling, 117–118
  • Parallel programming, 7–13
  • Parallel programs, optimization, 113–121
  • Parallel simulation, 271–272, 547
  • Parallel template algorithm, 274–276
  • Parent node, 322
  • Par swap rate, 133
  • Partial derivatives, solution, 342
  • Partial differential equation (PDE), 179–180
  • Path-dependency, impact, 137
  • Path-dependent cash-flows, timeline, 134–135
  • Path-dependent exotics, 134–135
  • Path-dependents, callables (conversion), 137–138
  • Path generation/evaluation, 415
  • Path-wise AAD simulations, 403–404, 468
  • Path-wise simulations, 188, 210
  • Payoff, 152, 187, 190, 214, 404, 417
  • Perfect forwarding, 371
  • Physical cores, 119–120
  • Physically settled payer swaption, 147
  • Pointers, 88, 368
  • Points, sequence (discrepancy), 204
  • Poisson process, 449–450
  • Policy design, 526
  • Polymorphism, 510
  • Pool jobs, usage, 109
  • Postorder, 332
  • Preorder traversal, 344–348
  • Pre-simulations, 191
  • Pricing, MC application, 189–192
  • Private (shortcut) accessors, usage, 380
  • Private unary, implementation, 394
  • Probability distribution, 153
  • Probability measure, 141, 185
  • Processes, usage, 7
  • Producer-consumer queue, 75
  • Producers, 75
  • Products, 127–128, 153–154, 218, 230–244
  • Profiling, initialization, 115
  • Promises, 90, 91–94
  • Proxy dates, 191
  • Proxy function, 138
  • Put prices, equation, 154
  • Python, C++ (relationship), 17–18
  • Quadratic convergence, 181
  • Quantum bugs, 63
  • Race conditions, 55, 62–64, 87, 116–117
  • Radon-Nikodym derivative, usage, 164, 170
  • Random Access Memory (RAM), 404–405, 439–446
    • cell, validity (absence), 60
    • footprint, alleviation, 293–294
  • Random grids, 200
  • Random number generator (RNG), 200–201, 214, 220–230, 511
  • Random numbers, 200–212
  • Random uniform data, vector generation, 58
  • Reconstruction formulas, 175
  • Reduction, 4, 28
  • Reference counted shared pointers, 43–44
  • References, 88
  • Regression proxies, 138
  • Regularization, 192
  • Resource Acquisition Is Initialization (RAII), 68–70, 80–82, 432, 488
  • Rethrows, 91
  • Return Value Optimization (RVO), 34
  • Reverse differentiation, propagation, 293
  • rhs (right-hand side), 35–39, 394–395
  • Risk-neutral dynamics, 163
  • Risk-neutral expectations, 163
  • Risk-neutral measure, 141, 170, 186, 197, 296
  • Risk-neutral transition probabilities, 197
  • Risk propagation, 479–481
  • Risk reports, production, 434
  • Risk sensitivities, 14–15, 448, 495
  • RiskView object, defining, 460
  • Risk views, 456–464
  • Run-time overhead, 369, 506, 508, 509
  • SABR. See Sigma-Alpha-Beta-Rho
  • Same Instruction Multiple Data (SIMD), 9–12
  • SampleDef, 216, 217
  • Samples, 143, 193–195, 217
  • Scenarios, 128–129, 143, 153, 215–218
  • Schwartz, Laurent (generalized derivatives), 448
  • Scripting libraries, usage, 230–231
  • Seeding, 304, 389, 468
  • Self-financing strategies, usage, 140–142
  • Semaphores, 80, 81
  • Separable volatility specification, 173
  • Serial differentiation, 432
  • Serial implementation, 213
  • Serial results, 424–426
  • Shared locks, 82–83
  • Shared memory parallelism, 7
  • Shared mutexes, 80, 82
  • Shared pointers, 43–44, 93
  • Short rate, integral form, 174
  • Sigma-Alpha-Beta-Rho (SABR), 147, 155, 167–168, 453
  • Simulated learning set, generation, 191
  • Simulation, 194–195, 199–200, 433–437
    • algorithm, 440, 494–499
    • library, differentiation, 407
  • Single Instruction Multiple Data (SIMD), 22–23
  • Single-period swaptions, 176
  • Single-threaded template algorithms, signature, 495
  • Singleton pattern, 96–97
  • Singleton template, 263
  • Singular value decomposition (SVD), 192, 446
  • Skip ahead, 271, 273–274, 276–284
  • Small object optimization (SMO), 29
  • Smart bump, implementation, 424
  • Smart pointers, 41–46
  • Smooth barrier, 237–238, 403
  • Smoothing, 289, 313–314
  • Sobol, 205–208, 269, 282–283
  • Spectral schemes, 200
  • Speed, problem/resolution, 289
  • Spinlocks, 66–67, 70, 81
  • Splines, initialization, 83
  • Spot measure, 163–165
  • Spot price, risk-neutral transition probabilities, 197
  • Stack Overflow, 29
  • Standard deviations, 253–254
  • Standardization initiatives, implementation, 12–13
  • Standard Template Library (STL), 27, 238, 256, 362
  • Standard Threading Library (STL), 13, 15, 19, 23
  • State vector, 178
  • Static array, zero-cost wrapper (usage), 363
  • Static data member, addition, 487
  • Static memory, presence, 521
  • Static multidimensional indicators, 487–489
  • Static polymorphism, 509–512
  • Step-wise simulations, 188
  • Stochastic and local volatility (SLV), 183
  • Stochastic differential equation (SDE), 186, 195
  • Stochastic gradient descent (SGD), 316
  • Stochastic volatility, 159–160, 167–168, 200, 453
    • martingale, 147
  • Sub-expressions, 512
  • Superbucket, 424, 439, 464–469, 472–475
  • Swap rates, 481
  • Swaption-implied volatilities, 481
  • Swaptions, 127, 147
  • Synchronization, 6, 80–83, 91
  • Temporary object, 35
  • Terms, sum, 5
  • Third-party software, usage, 446
  • Threading Building Blocks (TBB) library, 18, 72, 121
  • Thread local tape, 380–381
  • Thread pools, 48–49, 96–113, 272
  • Threads, 47–57, 82–83, 102–104
    • synchronization, 55
    • synchronization primitive, 64, 74
    • worker threads, 99–100
  • Thread safe, 4, 11, 18, 71, 273
  • Threads, work (division), 7
  • Timeline, 129, 199, 233
  • Time steps, collection, 199
  • Time volatilities, 255
  • Time-wise mapping, usage, 179, 186, 197
  • Toggle Breakpoint item, usage, 114
  • Trailing syntax, 256
  • Transactions, sensitivity, 440
  • Transformation, 3–4
  • Transition probabilities, sampling, 195–198
  • Trinomial trees, 179
  • Two-dimensional interpolation object, 461
  • Two-dimensional IVS, 167
  • Type erasure, 29
  • Unary expressions, usage, 528–529
  • Unary nodes, 505
  • Unary on-class operators, 539
  • Unary operation, 340, 395
  • Unary operator, 387, 531, 533–534
  • Underlying assets, 129–131
  • Up-and-out call, defining, 234
  • User interface, 263–268, 417–423
  • Value semantics, 29
  • Variables, capture, 26
  • Variadic templates, 371
  • Vector generation, 58
  • Vectorization, 9–10
  • Vega, 475
  • Virtual copy constructor idiom (implementation), clone() (usage), 219
  • Visual Studio, 20, 113–116
  • Vlissides, John, 223
  • Volatility Index (VIX) index, 159
  • Volatility matrix, 454
  • Wakes, impact, 76–77
  • Walkaround, 447
  • Williams, Anthony, 3
  • Worker threads, 99–100
  • Working memory, requirement, 110
  • Workspace, preallocation, 112
  • Work stealing, 49, 105
  • Wrapper, usage, 19, 88
  • Zero-cost wrapper, usage, 363
  • Zero-coupon bonds, 127, 144, 186
  • Zero-strike put, 138–139
..................Content has been hidden....................

You can't read the all page of ebook, please click here login for view all page.
Reset