- 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), –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, –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
- 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), –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),
- 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, –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, –8
- Divide-and-conquer idiom, –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,
- 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), –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), –9
- Hagan SABR, 453
- Hand-crafted loops, 12, 23, 27–28, 59, 61, 115
- Hardware concurrency, 119
- Hardware threads, 24, 47
- Haskell (functional language), , 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,
- Huge analogy, usage, 291
- Hybrid option, 139
- Hypercube, sampling, 210
- Hyper-threaded cores, usage, 59
- Hyper-threading, 24, 50
- Idiom, usage,
- 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,
- 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),
- 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, , 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), –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, –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, –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,
- 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, , 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), –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,
- 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
- Sub-expressions, 512
- Superbucket, 424, 439, 464–469, 472–475
- Swap rates, 481
- Swaption-implied volatilities, 481
- Swaptions, 127, 147
- Synchronization, , 80–83, 91
- Tanaka, formula, 448
- Tape, 289, 380–381, 415, 543
- Tape classes, 362–379, 485, 487–489, 491–493
- Tapes, 349–355, 442
- Tasks, 48, 89–98
- Templates
- algorithm, 222–223, 427, 494–495
- instantiation, 508
- meta-programming, 507–508
- simulation algorithm, 213–223
- Temporary object, 35
- Terms, sum,
- 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, , 11, 18, 71, 273
- Threads, work (division),
- 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, –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, –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,
- 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.