diff --git a/CMakeLists.txt b/CMakeLists.txt
index 6bd07e7f256..05418566772 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -42,6 +42,7 @@ set(QL_INSTALL_CMAKEDIR "lib/cmake/${PACKAGE_NAME}" CACHE STRING
option(QL_BUILD_BENCHMARK "Build benchmark" ON)
option(QL_BUILD_EXAMPLES "Build examples" ON)
option(QL_BUILD_TEST_SUITE "Build test suite" ON)
+option(QL_BUILD_FUZZ_TEST_SUITE "Build fuzz test suite" OFF)
option(QL_ENABLE_OPENMP "Detect and use OpenMP" OFF)
option(QL_ENABLE_PARALLEL_UNIT_TEST_RUNNER "Enable the parallel unit test runner" OFF)
option(QL_ENABLE_SESSIONS "Singletons return different instances for different sessions" OFF)
@@ -269,6 +270,10 @@ if (QL_BUILD_TEST_SUITE OR QL_BUILD_BENCHMARK)
add_subdirectory(test-suite)
endif()
+if ('${CMAKE_CXX_COMPILER_ID}' MATCHES 'Clang' AND QL_BUILD_FUZZ_TEST_SUITE)
+ add_subdirectory(fuzz-test-suite)
+endif()
+
# CPack support (make package, make package_source)
set(CPACK_PACKAGE_VERSION_MAJOR ${QUANTLIB_VERSION_MAJOR})
set(CPACK_PACKAGE_VERSION_MINOR ${QUANTLIB_VERSION_MINOR})
diff --git a/CMakePresets.json b/CMakePresets.json
index 189ba7abbeb..632c4ad97b6 100644
--- a/CMakePresets.json
+++ b/CMakePresets.json
@@ -174,51 +174,49 @@
{
"name": "linux-clang-ninja-debug",
"inherits": [
- "linux-clang-debug",
- "ninja"
+ "ninja",
+ "linux-clang-debug"
]
},
{
"name": "linux-clang-ninja-release",
"inherits": [
- "linux-clang-release",
- "ninja"
+ "ninja",
+ "linux-clang-release"
]
},
{
"name": "linux-clang-ninja-relwithdebinfo",
"inherits": [
- "linux-clang-relwithdebinfo",
- "ninja"
+ "ninja",
+ "linux-clang-relwithdebinfo"
]
},
{
"name": "linux-gcc-ninja-debug",
"inherits": [
- "linux-gcc-debug",
- "ninja"
+ "ninja",
+ "linux-gcc-debug"
]
},
{
"name": "linux-gcc-ninja-release",
"inherits": [
- "linux-gcc-release",
- "ninja"
+ "ninja",
+ "linux-gcc-release"
]
},
{
"name": "linux-gcc-ninja-relwithdebinfo",
"inherits": [
- "linux-gcc-relwithdebinfo",
- "ninja"
+ "ninja",
+ "linux-gcc-relwithdebinfo"
]
},
{
"name": "linux-gcc-debug-with-clang-tidy",
"inherits": [
- "linux-gcc-base",
- "make",
- "_debug"
+ "linux-gcc-debug"
],
"cacheVariables": {
"QL_CLANG_TIDY_OPTIONS": "-warnings-as-errors=*",
@@ -276,9 +274,7 @@
{
"name": "linux-ci-build-with-clang-tidy",
"inherits": [
- "linux-gcc-base",
- "make",
- "_debug"
+ "linux-gcc-debug"
],
"cacheVariables": {
"BOOST_ROOT": "/usr",
@@ -292,9 +288,7 @@
{
"name": "linux-ci-build-with-nonstandard-options",
"inherits": [
- "linux-gcc-base",
- "ninja",
- "_release"
+ "linux-gcc-ninja-release"
],
"cacheVariables": {
"BOOST_ROOT": "/usr",
@@ -319,9 +313,7 @@
{
"name": "windows-ci-build-with-nonstandard-options",
"inherits": [
- "windows-msvc-base",
- "ninja",
- "_release"
+ "windows-msvc-release"
],
"cacheVariables": {
"CMAKE_CXX_STANDARD": "17",
diff --git a/QuantLib.vcxproj b/QuantLib.vcxproj
index cdbdcdd64d9..81efc70968c 100644
--- a/QuantLib.vcxproj
+++ b/QuantLib.vcxproj
@@ -1109,6 +1109,7 @@
+
@@ -2311,6 +2312,7 @@
+
diff --git a/QuantLib.vcxproj.filters b/QuantLib.vcxproj.filters
index 9ad95815029..2a38c4cbf63 100644
--- a/QuantLib.vcxproj.filters
+++ b/QuantLib.vcxproj.filters
@@ -1242,6 +1242,9 @@
math\randomnumbers
+
+ math\randomnumbers
+
math\randomnumbers
@@ -4967,6 +4970,9 @@
math\matrixutilities
+
+ math\randomnumbers
+
math\randomnumbers
diff --git a/fuzz-test-suite/CMakeLists.txt b/fuzz-test-suite/CMakeLists.txt
new file mode 100644
index 00000000000..aaddcbfefd4
--- /dev/null
+++ b/fuzz-test-suite/CMakeLists.txt
@@ -0,0 +1,21 @@
+# Determine the flags for fuzzing. Use OSS-Fuzz's configuration if available, otherwise fall back to defaults.
+if(DEFINED ENV{LIB_FUZZING_ENGINE})
+ set(FUZZING_ENGINE $ENV{LIB_FUZZING_ENGINE})
+ set(FUZZING_COMPILE_FLAGS "")
+ set(FUZZING_LINK_FLAGS "${FUZZING_ENGINE}")
+else()
+ set(FUZZING_COMPILE_FLAGS "-fsanitize=fuzzer")
+ set(FUZZING_LINK_FLAGS "-fsanitize=fuzzer")
+endif()
+
+# Define the fuzz target
+add_executable(DateParserFuzzer dateparserfuzzer.cpp)
+
+# Apply the determined flags
+set_target_properties(DateParserFuzzer PROPERTIES
+ COMPILE_FLAGS "${FUZZING_COMPILE_FLAGS}"
+ LINK_FLAGS "${FUZZING_LINK_FLAGS}"
+)
+
+# Link QuantLib and any other necessary libraries
+target_link_libraries(DateParserFuzzer ql_library ${QL_THREAD_LIBRARIES})
diff --git a/fuzz-test-suite/dateparserfuzzer.cpp b/fuzz-test-suite/dateparserfuzzer.cpp
new file mode 100644
index 00000000000..7c6f6423fdd
--- /dev/null
+++ b/fuzz-test-suite/dateparserfuzzer.cpp
@@ -0,0 +1,24 @@
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+
+#ifndef __clang__
+#pragma message("Fuzzer headers are available from clang, other compilers have not been tested.")
+#endif
+#include
+
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
+ FuzzedDataProvider fdp(data, size);
+ constexpr int kMaxString = 100;
+ try {
+ (void)QuantLib::DateParser::parseFormatted(fdp.ConsumeRandomLengthString(kMaxString), "%Y-%m-%d");
+ (void)QuantLib::DateParser::parseISO(fdp.ConsumeRandomLengthString(kMaxString));
+ } catch (const std::exception& e) {
+ // Handle or ignore exceptions
+ }
+ return 0;
+}
diff --git a/ql/CMakeLists.txt b/ql/CMakeLists.txt
index 21a14c304f5..9e578e0d265 100644
--- a/ql/CMakeLists.txt
+++ b/ql/CMakeLists.txt
@@ -414,6 +414,7 @@ set(QL_SOURCES
math/polynomialmathfunction.cpp
math/primenumbers.cpp
math/quadratic.cpp
+ math/randomnumbers/burley2020sobolrsg.cpp
math/randomnumbers/faurersg.cpp
math/randomnumbers/haltonrsg.cpp
math/randomnumbers/knuthuniformrng.cpp
@@ -1518,6 +1519,7 @@ set(QL_HEADERS
math/primenumbers.hpp
math/quadratic.hpp
math/randomnumbers/boxmullergaussianrng.hpp
+ math/randomnumbers/burley2020sobolrsg.hpp
math/randomnumbers/centrallimitgaussianrng.hpp
math/randomnumbers/faurersg.hpp
math/randomnumbers/haltonrsg.hpp
diff --git a/ql/math/randomnumbers/Makefile.am b/ql/math/randomnumbers/Makefile.am
index 21faedb2ad0..ac088630f85 100644
--- a/ql/math/randomnumbers/Makefile.am
+++ b/ql/math/randomnumbers/Makefile.am
@@ -5,6 +5,7 @@ this_includedir=${includedir}/${subdir}
this_include_HEADERS = \
all.hpp \
boxmullergaussianrng.hpp \
+ burley2020sobolrsg.hpp \
centrallimitgaussianrng.hpp \
faurersg.hpp \
haltonrsg.hpp \
@@ -27,8 +28,9 @@ this_include_HEADERS = \
xoshiro256starstaruniformrng.hpp
cpp_files = \
- faurersg.cpp \
- haltonrsg.cpp \
+ faurersg.cpp \
+ haltonrsg.cpp \
+ burley2020sobolrsg.cpp \
knuthuniformrng.cpp \
latticersg.cpp \
latticerules.cpp \
diff --git a/ql/math/randomnumbers/all.hpp b/ql/math/randomnumbers/all.hpp
index adcaafb4a07..6b1d5fc35a4 100644
--- a/ql/math/randomnumbers/all.hpp
+++ b/ql/math/randomnumbers/all.hpp
@@ -2,6 +2,7 @@
/* Add the files to be included into Makefile.am instead. */
#include
+#include
#include
#include
#include
diff --git a/ql/math/randomnumbers/burley2020sobolrsg.cpp b/ql/math/randomnumbers/burley2020sobolrsg.cpp
new file mode 100644
index 00000000000..ec441ee21b7
--- /dev/null
+++ b/ql/math/randomnumbers/burley2020sobolrsg.cpp
@@ -0,0 +1,153 @@
+/* -*- mode: c++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+
+/*
+ Copyright (C) 2023 Peter Caspers
+
+ This file is part of QuantLib, a free-software/open-source library
+ for financial quantitative analysts and developers - http://quantlib.org/
+
+ QuantLib is free software: you can redistribute it and/or modify it
+ under the terms of the QuantLib license. You should have received a
+ copy of the license along with this program; if not, please email
+ . The license is also available online at
+ .
+
+ This program is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ FOR A PARTICULAR PURPOSE. See the license for more details.
+*/
+
+#include
+#include
+#include
+
+namespace QuantLib {
+
+ Burley2020SobolRsg::Burley2020SobolRsg(Size dimensionality,
+ unsigned long seed,
+ SobolRsg::DirectionIntegers directionIntegers,
+ unsigned long scrambleSeed)
+ : dimensionality_(dimensionality), seed_(seed), directionIntegers_(directionIntegers),
+ integerSequence_(dimensionality), sequence_(std::vector(dimensionality), 1.0) {
+ reset();
+ group4Seeds_.resize((dimensionality_ - 1) / 4 + 1);
+ MersenneTwisterUniformRng mt(scrambleSeed);
+ for (auto& s : group4Seeds_) {
+ s = static_cast(mt.nextInt32());
+ }
+ }
+
+ void Burley2020SobolRsg::reset() const {
+ sobolRsg_ = ext::make_shared(dimensionality_, seed_, directionIntegers_, false);
+ nextSequenceCounter_ = 0;
+ }
+
+ const std::vector& Burley2020SobolRsg::skipTo(std::uint32_t n) const {
+ reset();
+ for (Size k = 0; k < n + 1; ++k) {
+ nextInt32Sequence();
+ }
+ return integerSequence_;
+ }
+
+ namespace {
+
+ // for reverseBits() see http://graphics.stanford.edu/~seander/bithacks.html#BitReverseTable
+
+ static const std::uint8_t bitReverseTable[] = {
+ 0u, 128u, 64u, 192u, 32u, 160u, 96u, 224u, 16u, 144u, 80u, 208u, 48u, 176u,
+ 112u, 240u, 8u, 136u, 72u, 200u, 40u, 168u, 104u, 232u, 24u, 152u, 88u, 216u,
+ 56u, 184u, 120u, 248u, 4u, 132u, 68u, 196u, 36u, 164u, 100u, 228u, 20u, 148u,
+ 84u, 212u, 52u, 180u, 116u, 244u, 12u, 140u, 76u, 204u, 44u, 172u, 108u, 236u,
+ 28u, 156u, 92u, 220u, 60u, 188u, 124u, 252u, 2u, 130u, 66u, 194u, 34u, 162u,
+ 98u, 226u, 18u, 146u, 82u, 210u, 50u, 178u, 114u, 242u, 10u, 138u, 74u, 202u,
+ 42u, 170u, 106u, 234u, 26u, 154u, 90u, 218u, 58u, 186u, 122u, 250u, 6u, 134u,
+ 70u, 198u, 38u, 166u, 102u, 230u, 22u, 150u, 86u, 214u, 54u, 182u, 118u, 246u,
+ 14u, 142u, 78u, 206u, 46u, 174u, 110u, 238u, 30u, 158u, 94u, 222u, 62u, 190u,
+ 126u, 254u, 1u, 129u, 65u, 193u, 33u, 161u, 97u, 225u, 17u, 145u, 81u, 209u,
+ 49u, 177u, 113u, 241u, 9u, 137u, 73u, 201u, 41u, 169u, 105u, 233u, 25u, 153u,
+ 89u, 217u, 57u, 185u, 121u, 249u, 5u, 133u, 69u, 197u, 37u, 165u, 101u, 229u,
+ 21u, 149u, 85u, 213u, 53u, 181u, 117u, 245u, 13u, 141u, 77u, 205u, 45u, 173u,
+ 109u, 237u, 29u, 157u, 93u, 221u, 61u, 189u, 125u, 253u, 3u, 131u, 67u, 195u,
+ 35u, 163u, 99u, 227u, 19u, 147u, 83u, 211u, 51u, 179u, 115u, 243u, 11u, 139u,
+ 75u, 203u, 43u, 171u, 107u, 235u, 27u, 155u, 91u, 219u, 59u, 187u, 123u, 251u,
+ 7u, 135u, 71u, 199u, 39u, 167u, 103u, 231u, 23u, 151u, 87u, 215u, 55u, 183u,
+ 119u, 247u, 15u, 143u, 79u, 207u, 47u, 175u, 111u, 239u, 31u, 159u, 95u, 223u,
+ 63u, 191u, 127u, 255u};
+
+ inline std::uint32_t reverseBits(std::uint32_t x) {
+ return (bitReverseTable[x & 0xff] << 24) | (bitReverseTable[(x >> 8) & 0xff] << 16) |
+ (bitReverseTable[(x >> 16) & 0xff] << 8) | (bitReverseTable[(x >> 24) & 0xff]);
+ }
+
+ inline std::uint32_t laine_karras_permutation(std::uint32_t x, std::uint32_t seed) {
+ x += seed;
+ x ^= x * 0x6c50b47cu;
+ x ^= x * 0xb82f1e52u;
+ x ^= x * 0xc7afe638u;
+ x ^= x * 0x8d22f6e6u;
+ return x;
+ }
+
+ inline std::uint32_t nested_uniform_scramble(std::uint32_t x, std::uint32_t seed) {
+ x = reverseBits(x);
+ x = laine_karras_permutation(x, seed);
+ x = reverseBits(x);
+ return x;
+ }
+
+ // the results depend a lot on the details of the hash_combine() function that is used
+ // we use hash_combine() calling hash(), hash_mix() as implemented here:
+ // https://github.com/boostorg/container_hash/blob/boost-1.83.0/include/boost/container_hash/hash.hpp#L560
+ // https://github.com/boostorg/container_hash/blob/boost-1.83.0/include/boost/container_hash/hash.hpp#L115
+ // https://github.com/boostorg/container_hash/blob/boost-1.83.0/include/boost/container_hash/detail/hash_mix.hpp#L67
+
+ inline std::uint64_t local_hash_mix(std::uint64_t x) {
+ const std::uint64_t m = 0xe9846af9b1a615d;
+ x ^= x >> 32;
+ x *= m;
+ x ^= x >> 32;
+ x *= m;
+ x ^= x >> 28;
+ return x;
+ }
+
+ inline std::uint64_t local_hash(const std::uint64_t v) {
+ std::uint64_t seed = 0;
+ seed = (v >> 32) + local_hash_mix(seed);
+ seed = (v & 0xFFFFFFFF) + local_hash_mix(seed);
+ return seed;
+ }
+
+ inline std::uint64_t local_hash_combine(std::uint64_t x, const uint64_t v) {
+ return local_hash_mix(x + 0x9e3779b9 + local_hash(v));
+ }
+ }
+
+ const std::vector& Burley2020SobolRsg::nextInt32Sequence() const {
+ auto n = nested_uniform_scramble(nextSequenceCounter_, group4Seeds_[0]);
+ const auto& seq = sobolRsg_->skipTo(n);
+ std::copy(seq.begin(), seq.end(), integerSequence_.begin());
+ Size i = 0, group = 0;
+ do {
+ std::uint64_t seed = group4Seeds_[group++];
+ for (Size g = 0; g < 4 && i < dimensionality_; ++g, ++i) {
+ seed = local_hash_combine(seed, g);
+ integerSequence_[i] =
+ nested_uniform_scramble(integerSequence_[i], static_cast(seed));
+ }
+ } while (i < dimensionality_);
+ QL_REQUIRE(++nextSequenceCounter_ != 0,
+ "Burley2020SobolRsg::nextIn32Sequence(): period exceeded");
+ return integerSequence_;
+ }
+
+ const SobolRsg::sample_type& Burley2020SobolRsg::nextSequence() const {
+ const std::vector& v = nextInt32Sequence();
+ // normalize to get a double in (0,1)
+ for (Size k = 0; k < dimensionality_; ++k) {
+ sequence_.value[k] = static_cast(v[k]) / 4294967296.0;
+ }
+ return sequence_;
+ }
+}
diff --git a/ql/math/randomnumbers/burley2020sobolrsg.hpp b/ql/math/randomnumbers/burley2020sobolrsg.hpp
new file mode 100644
index 00000000000..445fc3a7679
--- /dev/null
+++ b/ql/math/randomnumbers/burley2020sobolrsg.hpp
@@ -0,0 +1,64 @@
+/* -*- mode: c++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+
+/*
+ Copyright (C) 2023 Peter Caspers
+
+ This file is part of QuantLib, a free-software/open-source library
+ for financial quantitative analysts and developers - http://quantlib.org/
+
+ QuantLib is free software: you can redistribute it and/or modify it
+ under the terms of the QuantLib license. You should have received a
+ copy of the license along with this program; if not, please email
+ . The license is also available online at
+ .
+
+ This program is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ FOR A PARTICULAR PURPOSE. See the license for more details.
+*/
+
+/*! \file burley2020sobolrsg.hpp
+ \brief scrambled Sobol sequence following Burley, 2020
+*/
+
+#ifndef quantlib_burley2020_scrambled_sobolrsg_hpp
+#define quantlib_burley2020_scrambled_sobolrsg_hpp
+
+#include
+#include
+
+namespace QuantLib {
+
+ //! Scrambled sobol sequence according to Burley, 2020
+ /*! Reference: Brent Burley: Practical Hash-based Owen Scrambling,
+ Journal of Computer Graphics Techniques, Vol. 9, No. 4, 2020 */
+ class Burley2020SobolRsg {
+ public:
+ typedef Sample> sample_type;
+ explicit Burley2020SobolRsg(
+ Size dimensionality,
+ unsigned long seed = 42,
+ SobolRsg::DirectionIntegers directionIntegers = SobolRsg::Jaeckel,
+ unsigned long scrambleSeed = 43);
+ const std::vector& skipTo(std::uint32_t n) const;
+ const std::vector& nextInt32Sequence() const;
+ const SobolRsg::sample_type& nextSequence() const;
+ const sample_type& lastSequence() const { return sequence_; }
+ Size dimension() const { return dimensionality_; }
+
+ private:
+ void reset() const;
+ Size dimensionality_;
+ unsigned long seed_;
+ SobolRsg::DirectionIntegers directionIntegers_;
+ mutable ext::shared_ptr sobolRsg_;
+ mutable std::vector integerSequence_;
+ mutable sample_type sequence_;
+ mutable std::uint32_t nextSequenceCounter_;
+ mutable std::vector group4Seeds_;
+ };
+
+}
+
+
+#endif
diff --git a/ql/math/randomnumbers/sobolbrownianbridgersg.cpp b/ql/math/randomnumbers/sobolbrownianbridgersg.cpp
index 19198fc3687..8845d16f15d 100644
--- a/ql/math/randomnumbers/sobolbrownianbridgersg.cpp
+++ b/ql/math/randomnumbers/sobolbrownianbridgersg.cpp
@@ -25,27 +25,31 @@
#include
namespace QuantLib {
- SobolBrownianBridgeRsg::SobolBrownianBridgeRsg(
- Size factors, Size steps,
- SobolBrownianGenerator::Ordering ordering,
- unsigned long seed,
- SobolRsg::DirectionIntegers directionIntegers)
- : factors_(factors), steps_(steps), dim_(factors*steps),
- seq_(sample_type::value_type(factors*steps), 1.0),
- gen_(factors, steps, ordering, seed, directionIntegers) {
+
+ namespace {
+ void setNextSequence(SobolBrownianGeneratorBase& gen, std::vector& seq) {
+ gen.nextPath();
+ std::vector output(gen.numberOfFactors());
+ for (Size i = 0; i < gen.numberOfSteps(); ++i) {
+ gen.nextStep(output);
+ std::copy(output.begin(), output.end(), seq.begin() + i * gen.numberOfFactors());
+ }
+ }
}
+ SobolBrownianBridgeRsg::SobolBrownianBridgeRsg(Size factors,
+ Size steps,
+ SobolBrownianGenerator::Ordering ordering,
+ unsigned long seed,
+ SobolRsg::DirectionIntegers directionIntegers)
+ : seq_(sample_type::value_type(factors * steps), 1.0),
+ gen_(factors, steps, ordering, seed, directionIntegers) {}
+
const SobolBrownianBridgeRsg::sample_type&
SobolBrownianBridgeRsg::nextSequence() const {
- gen_.nextPath();
- std::vector output(factors_);
- for (Size i=0; i < steps_; ++i) {
- gen_.nextStep(output);
- std::copy(output.begin(), output.end(),
- seq_.value.begin()+i*factors_);
- }
-
+ setNextSequence(gen_, seq_.value);
return seq_;
+
}
const SobolBrownianBridgeRsg::sample_type&
@@ -54,6 +58,32 @@ namespace QuantLib {
}
Size SobolBrownianBridgeRsg::dimension() const {
- return dim_;
+ return gen_.numberOfFactors() * gen_.numberOfSteps();
+ }
+
+ Burley2020SobolBrownianBridgeRsg::Burley2020SobolBrownianBridgeRsg(
+ Size factors,
+ Size steps,
+ SobolBrownianGenerator::Ordering ordering,
+ unsigned long seed,
+ SobolRsg::DirectionIntegers directionIntegers,
+ unsigned long scrambleSeed)
+ : seq_(sample_type::value_type(factors * steps), 1.0),
+ gen_(factors, steps, ordering, seed, directionIntegers, scrambleSeed) {}
+
+ const Burley2020SobolBrownianBridgeRsg::sample_type&
+ Burley2020SobolBrownianBridgeRsg::nextSequence() const {
+ setNextSequence(gen_, seq_.value);
+ return seq_;
+ }
+
+ const Burley2020SobolBrownianBridgeRsg::sample_type&
+ Burley2020SobolBrownianBridgeRsg::lastSequence() const {
+ return seq_;
}
+
+ Size Burley2020SobolBrownianBridgeRsg::dimension() const {
+ return gen_.numberOfFactors() * gen_.numberOfSteps();
+ }
+
}
diff --git a/ql/math/randomnumbers/sobolbrownianbridgersg.hpp b/ql/math/randomnumbers/sobolbrownianbridgersg.hpp
index ee699be9690..e877fe34516 100644
--- a/ql/math/randomnumbers/sobolbrownianbridgersg.hpp
+++ b/ql/math/randomnumbers/sobolbrownianbridgersg.hpp
@@ -45,10 +45,30 @@ namespace QuantLib {
Size dimension() const;
private:
- const Size factors_, steps_, dim_;
mutable sample_type seq_;
mutable SobolBrownianGenerator gen_;
};
+
+ class Burley2020SobolBrownianBridgeRsg {
+ public:
+ typedef Sample > sample_type;
+
+ Burley2020SobolBrownianBridgeRsg(
+ Size factors,
+ Size steps,
+ SobolBrownianGenerator::Ordering ordering = SobolBrownianGenerator::Diagonal,
+ unsigned long seed = 42,
+ SobolRsg::DirectionIntegers directionIntegers = SobolRsg::JoeKuoD7,
+ unsigned long scrambleSeed = 43);
+
+ const sample_type& nextSequence() const;
+ const sample_type& lastSequence() const;
+ Size dimension() const;
+
+ private:
+ mutable sample_type seq_;
+ mutable Burley2020SobolBrownianGenerator gen_;
+ };
}
#endif
diff --git a/ql/math/randomnumbers/sobolrsg.cpp b/ql/math/randomnumbers/sobolrsg.cpp
index 30264c10f7d..1e0810e843c 100644
--- a/ql/math/randomnumbers/sobolrsg.cpp
+++ b/ql/math/randomnumbers/sobolrsg.cpp
@@ -78479,10 +78479,14 @@ namespace QuantLib {
const double SobolRsg::normalizationFactor_ =
0.5/(1UL<<(SobolRsg::bits_-1));
- SobolRsg::SobolRsg(Size dimensionality, unsigned long seed, DirectionIntegers directionIntegers)
+ SobolRsg::SobolRsg(Size dimensionality,
+ unsigned long seed,
+ DirectionIntegers directionIntegers,
+ bool useGrayCode)
: dimensionality_(dimensionality), sequence_(std::vector(dimensionality), 1.0),
integerSequence_(dimensionality, 0),
- directionIntegers_(dimensionality, std::vector(bits_)) {
+ directionIntegers_(dimensionality, std::vector(bits_)),
+ useGrayCode_(useGrayCode) {
QL_REQUIRE(dimensionality>0,
"dimensionality must be greater than 0");
@@ -78765,33 +78769,60 @@ namespace QuantLib {
*/
// initialize the Sobol integer/double vectors
- // first draw
- for (k=0; k& SobolRsg::skipTo(std::uint_least32_t skip) const {
+ std::uint_least32_t N = skip + 1;
- // Convert to Gray code
- std::uint_least32_t G = N ^ (N>>1);
- for (Size k=0; k> index & 1) != 0U)
- integerSequence_[k] ^= directionIntegers_[k][index];
+ if (useGrayCode_) {
+ unsigned int ops = (unsigned int)(std::log((double)N) / M_LN2) + 1;
+
+ // Convert to Gray code
+ std::uint_least32_t G = N ^ (N >> 1);
+ for (Size k = 0; k < dimensionality_; k++) {
+ integerSequence_[k] = 0;
+ for (Size index = 0; index < ops; index++) {
+ if ((G >> index & 1) != 0U)
+ integerSequence_[k] ^= directionIntegers_[k][index];
+ }
+ }
+ } else {
+ std::fill(integerSequence_.begin(), integerSequence_.end(), 0u);
+ std::uint_least32_t mask = 1;
+ for (Size index = 0; index < bits_; index++) {
+ if ((N & mask) != 0U) {
+ for (Size k = 0; k < dimensionality_; k++) {
+ integerSequence_[k] ^= directionIntegers_[k][index];
+ }
+ }
+ mask = mask << 1;
}
}
sequenceCounter_ = skip;
+ return integerSequence_;
}
-
-
const std::vector& SobolRsg::nextInt32Sequence() const
{
+
+ if (!useGrayCode_) {
+ skipTo(sequenceCounter_);
+ if (firstDraw_) {
+ firstDraw_ = false;
+ } else {
+ ++sequenceCounter_;
+ QL_REQUIRE(sequenceCounter_ != 0, "period exceeded");
+ }
+ return integerSequence_;
+ }
+
if (firstDraw_) {
// it was precomputed in the constructor
firstDraw_ = false;
diff --git a/ql/math/randomnumbers/sobolrsg.hpp b/ql/math/randomnumbers/sobolrsg.hpp
index d94581f390b..ee52a5084fa 100644
--- a/ql/math/randomnumbers/sobolrsg.hpp
+++ b/ql/math/randomnumbers/sobolrsg.hpp
@@ -114,12 +114,21 @@ namespace QuantLib {
Unit, Jaeckel, SobolLevitan, SobolLevitanLemieux,
JoeKuoD5, JoeKuoD6, JoeKuoD7,
Kuo, Kuo2, Kuo3 };
- /*! \pre dimensionality must be <= PPMT_MAX_DIM */
+ /*! The so called generating integer is chosen to be \f$\gamma(n) = n\f$ if useGrayCode is set to false and
+ \f$\gamma(n) = G(n)\f$ where \f$G(n)\f$ is the Gray code of \f$n\f$ otherwise. The Sobol integers are then
+ constructed using formula 8.20 resp. 8.23, see "Monte Carlo Methods in Finance" by Peter Jäckel. The default
+ is to use the Gray code since this allows a faster sequence generation. The Burley2020SobolRsg relies on an
+ underlying SobolRsg not using the Gray code on the other hand due to its specific way of constructing the
+ integer sequence.
+
+ \pre dimensionality must be <= PPMT_MAX_DIM
+ */
explicit SobolRsg(Size dimensionality,
unsigned long seed = 0,
- DirectionIntegers directionIntegers = Jaeckel);
+ DirectionIntegers directionIntegers = Jaeckel,
+ bool useGrayCode = true);
/*! skip to the n-th sample in the low-discrepancy sequence */
- void skipTo(std::uint_least32_t n);
+ const std::vector& skipTo(std::uint_least32_t n) const;
const std::vector& nextInt32Sequence() const;
const SobolRsg::sample_type& nextSequence() const {
@@ -140,6 +149,7 @@ namespace QuantLib {
mutable sample_type sequence_;
mutable std::vector integerSequence_;
std::vector> directionIntegers_;
+ bool useGrayCode_;
};
}
diff --git a/ql/models/marketmodels/browniangenerators/sobolbrowniangenerator.cpp b/ql/models/marketmodels/browniangenerators/sobolbrowniangenerator.cpp
index 20d7f6a2411..038fa5af280 100644
--- a/ql/models/marketmodels/browniangenerators/sobolbrowniangenerator.cpp
+++ b/ql/models/marketmodels/browniangenerators/sobolbrowniangenerator.cpp
@@ -107,13 +107,10 @@ namespace QuantLib {
}
- SobolBrownianGenerator::SobolBrownianGenerator(Size factors,
+ SobolBrownianGeneratorBase::SobolBrownianGeneratorBase(Size factors,
Size steps,
- Ordering ordering,
- unsigned long seed,
- SobolRsg::DirectionIntegers integers)
+ Ordering ordering)
: factors_(factors), steps_(steps), ordering_(ordering),
- generator_(SobolRsg(factors * steps, seed, integers), InverseCumulativeNormal()),
bridge_(steps), orderedIndices_(factors, std::vector(steps)),
bridgedVariates_(factors, std::vector(steps)) {
@@ -133,12 +130,8 @@ namespace QuantLib {
}
- Real SobolBrownianGenerator::nextPath() {
- typedef InverseCumulativeRsg::sample_type
- sample_type;
-
- const sample_type& sample = generator_.nextSequence();
+ Real SobolBrownianGeneratorBase::nextPath() {
+ const auto& sample = nextSequence();
// Brownian-bridge the variates according to the ordered indices
for (Size i=0; i >&
- SobolBrownianGenerator::orderedIndices() const {
+ SobolBrownianGeneratorBase::orderedIndices() const {
return orderedIndices_;
}
- std::vector > SobolBrownianGenerator::transform(
+ std::vector > SobolBrownianGeneratorBase::transform(
const std::vector >& variates) {
QL_REQUIRE( (variates.size() == factors_*steps_),
@@ -190,7 +183,7 @@ namespace QuantLib {
return retVal;
}
- Real SobolBrownianGenerator::nextStep(std::vector& output) {
+ Real SobolBrownianGeneratorBase::nextStep(std::vector& output) {
#if defined(QL_EXTRA_SAFETY_CHECKS)
QL_REQUIRE(output.size() == factors_, "size mismatch");
QL_REQUIRE(lastStep_
+ Burley2020SobolBrownianGeneratorFactory::create(Size factors, Size steps) const {
+ return ext::shared_ptr(new Burley2020SobolBrownianGenerator(
+ factors, steps, ordering_, seed_, integers_, scrambleSeed_));
+ }
}
diff --git a/ql/models/marketmodels/browniangenerators/sobolbrowniangenerator.hpp b/ql/models/marketmodels/browniangenerators/sobolbrowniangenerator.hpp
index f769bf2605d..eacb9abbae3 100644
--- a/ql/models/marketmodels/browniangenerators/sobolbrowniangenerator.hpp
+++ b/ql/models/marketmodels/browniangenerators/sobolbrowniangenerator.hpp
@@ -24,6 +24,7 @@
#include
#include
#include
+#include
#include
#include
#include
@@ -34,7 +35,7 @@ namespace QuantLib {
/*! Incremental Brownian generator using a Sobol generator,
inverse-cumulative Gaussian method, and Brownian bridging.
*/
- class SobolBrownianGenerator : public BrownianGenerator {
+ class SobolBrownianGeneratorBase : public BrownianGenerator {
public:
enum Ordering {
Factors, /*!< The variates with the best quality will be
@@ -46,13 +47,10 @@ namespace QuantLib {
most important factors and the largest
steps. */
};
- SobolBrownianGenerator(
+ SobolBrownianGeneratorBase(
Size factors,
Size steps,
- Ordering ordering,
- unsigned long seed = 0,
- SobolRsg::DirectionIntegers directionIntegers
- = SobolRsg::Jaeckel);
+ Ordering ordering);
Real nextPath() override;
Real nextStep(std::vector&) override;
@@ -65,10 +63,12 @@ namespace QuantLib {
std::vector > transform(
const std::vector >& variates);
+ protected:
+ virtual const SobolRsg::sample_type& nextSequence() = 0;
+
private:
Size factors_, steps_;
Ordering ordering_;
- InverseCumulativeRsg generator_;
BrownianBridge bridge_;
// work variables
Size lastStep_ = 0;
@@ -76,19 +76,62 @@ namespace QuantLib {
std::vector > bridgedVariates_;
};
+ class SobolBrownianGenerator : public SobolBrownianGeneratorBase {
+ public:
+ SobolBrownianGenerator(Size factors,
+ Size steps,
+ Ordering ordering,
+ unsigned long seed = 0,
+ SobolRsg::DirectionIntegers directionIntegers = SobolRsg::Jaeckel);
+
+ private:
+ const SobolRsg::sample_type& nextSequence() override;
+ InverseCumulativeRsg generator_;
+ };
+
class SobolBrownianGeneratorFactory : public BrownianGeneratorFactory {
public:
- SobolBrownianGeneratorFactory(
- SobolBrownianGenerator::Ordering ordering,
- unsigned long seed = 0,
- SobolRsg::DirectionIntegers directionIntegers
- = SobolRsg::Jaeckel);
+ explicit SobolBrownianGeneratorFactory(
+ SobolBrownianGenerator::Ordering ordering,
+ unsigned long seed = 0,
+ SobolRsg::DirectionIntegers directionIntegers = SobolRsg::Jaeckel);
+ ext::shared_ptr create(Size factors, Size steps) const override;
+
+ private:
+ SobolBrownianGenerator::Ordering ordering_;
+ unsigned long seed_;
+ SobolRsg::DirectionIntegers integers_;
+ };
+
+ class Burley2020SobolBrownianGenerator : public SobolBrownianGeneratorBase {
+ public:
+ Burley2020SobolBrownianGenerator(
+ Size factors,
+ Size steps,
+ Ordering ordering,
+ unsigned long seed = 42,
+ SobolRsg::DirectionIntegers directionIntegers = SobolRsg::Jaeckel,
+ unsigned long scrambleSeed = 43);
+
+ private:
+ const Burley2020SobolRsg::sample_type& nextSequence() override;
+ InverseCumulativeRsg generator_;
+ };
+
+ class Burley2020SobolBrownianGeneratorFactory : public BrownianGeneratorFactory {
+ public:
+ explicit Burley2020SobolBrownianGeneratorFactory(
+ SobolBrownianGenerator::Ordering ordering,
+ unsigned long seed = 42,
+ SobolRsg::DirectionIntegers directionIntegers = SobolRsg::Jaeckel,
+ unsigned long scrambleSeed = 43);
ext::shared_ptr create(Size factors, Size steps) const override;
private:
SobolBrownianGenerator::Ordering ordering_;
unsigned long seed_;
SobolRsg::DirectionIntegers integers_;
+ unsigned long scrambleSeed_;
};
}
diff --git a/test-suite/CMakeLists.txt b/test-suite/CMakeLists.txt
index 68052a261c8..3d9a1050d39 100644
--- a/test-suite/CMakeLists.txt
+++ b/test-suite/CMakeLists.txt
@@ -126,6 +126,7 @@ set(QL_TEST_SOURCES
period.cpp
piecewiseyieldcurve.cpp
piecewisezerospreadedtermstructure.cpp
+ quantlibglobalfixture.cpp
quantlibtestsuite.cpp
quantooption.cpp
quotes.cpp
@@ -140,6 +141,7 @@ set(QL_TEST_SOURCES
shortratemodels.cpp
sofrfutures.cpp
solvers.cpp
+ speedlevel.cpp
spreadoption.cpp
squarerootclvmodel.cpp
stats.cpp
@@ -172,103 +174,6 @@ set(QL_TEST_SOURCES
)
set(QL_TEST_HEADERS
- americanoption.hpp
- amortizingbond.hpp
- andreasenhugevolatilityinterpl.hpp
- array.hpp
- asianoptions.hpp
- assetswap.hpp
- autocovariances.hpp
- barrieroption.hpp
- basismodels.hpp
- basisswapratehelpers.hpp
- basketoption.hpp
- batesmodel.hpp
- bermudanswaption.hpp
- binaryoption.hpp
- blackdeltacalculator.hpp
- blackformula.hpp
- bondforward.hpp
- bonds.hpp
- brownianbridge.hpp
- businessdayconventions.hpp
- calendars.hpp
- callablebonds.hpp
- capfloor.hpp
- capflooredcoupon.hpp
- cashflows.hpp
- catbonds.hpp
- cdo.hpp
- cdsoption.hpp
- chooseroption.hpp
- cliquetoption.hpp
- cms.hpp
- cms_normal.hpp
- cmsspread.hpp
- commodityunitofmeasure.hpp
- compiledboostversion.hpp
- compoundoption.hpp
- convertiblebonds.hpp
- covariance.hpp
- creditdefaultswap.hpp
- creditriskplus.hpp
- crosscurrencyratehelpers.hpp
- currency.hpp
- curvestates.hpp
- dates.hpp
- daycounters.hpp
- defaultprobabilitycurves.hpp
- digitalcoupon.hpp
- digitaloption.hpp
- distributions.hpp
- dividendoption.hpp
- doublebarrieroption.hpp
- doublebinaryoption.hpp
- equityindex.hpp
- equitycashflow.hpp
- equitytotalreturnswap.hpp
- europeanoption.hpp
- everestoption.hpp
- exchangerate.hpp
- extendedtrees.hpp
- extensibleoptions.hpp
- fastfouriertransform.hpp
- fdcev.hpp
- fdcir.hpp
- fdheston.hpp
- fdmlinearop.hpp
- fdsabr.hpp
- fittedbonddiscountcurve.hpp
- forwardoption.hpp
- forwardrateagreement.hpp
- functions.hpp
- garch.hpp
- gaussianquadratures.hpp
- gjrgarchmodel.hpp
- gsr.hpp
- hestonmodel.hpp
- hestonslvmodel.hpp
- himalayaoption.hpp
- hybridhestonhullwhiteprocess.hpp
- indexes.hpp
- inflation.hpp
- inflationcapfloor.hpp
- inflationcapflooredcoupon.hpp
- inflationcpibond.hpp
- inflationcpicapfloor.hpp
- inflationcpiswap.hpp
- inflationvolatility.hpp
- instruments.hpp
- integrals.hpp
- interestrates.hpp
- interpolations.hpp
- jumpdiffusion.hpp
- lazyobject.hpp
- libormarketmodel.hpp
- libormarketmodelprocess.hpp
- linearleastsquaresregression.hpp
- lookbackoptions.hpp
- lowdiscrepancysequences.hpp
margrabeoption.hpp
marketmodel.hpp
marketmodel_cms.hpp
@@ -300,6 +205,7 @@ set(QL_TEST_HEADERS
period.hpp
piecewiseyieldcurve.hpp
piecewisezerospreadedtermstructure.hpp
+ quantlibglobalfixture.hpp
quantooption.hpp
quotes.hpp
rangeaccrual.hpp
@@ -330,6 +236,7 @@ set(QL_TEST_HEADERS
timegrid.hpp
timeseries.hpp
tqreigendecomposition.hpp
+ toplevelfixture.hpp
tracing.hpp
transformedgrid.hpp
twoassetbarrieroption.hpp
@@ -349,26 +256,27 @@ set(QL_TEST_HEADERS
set(QL_BENCHMARK_SOURCES
quantlibbenchmark.cpp
- americanoption.cpp americanoption.hpp
- asianoptions.cpp asianoptions.hpp
- barrieroption.cpp barrieroption.hpp
- basketoption.cpp basketoption.hpp
- batesmodel.cpp batesmodel.hpp
- convertiblebonds.cpp convertiblebonds.hpp
- digitaloption.cpp digitaloption.hpp
- dividendoption.cpp dividendoption.hpp
- europeanoption.cpp europeanoption.hpp
- fdheston.cpp fdheston.hpp
- hestonmodel.cpp hestonmodel.hpp
- interpolations.cpp interpolations.hpp
- jumpdiffusion.cpp jumpdiffusion.hpp
- lowdiscrepancysequences.cpp lowdiscrepancysequences.hpp
+ americanoption.cpp
+ asianoptions.cpp
+ barrieroption.cpp
+ basketoption.cpp
+ batesmodel.cpp
+ convertiblebonds.cpp
+ digitaloption.cpp
+ dividendoption.cpp
+ europeanoption.cpp
+ fdheston.cpp
+ hestonmodel.cpp
+ interpolations.cpp
+ jumpdiffusion.cpp
+ lowdiscrepancysequences.cpp
marketmodel_cms.cpp marketmodel_cms.hpp
marketmodel_smm.cpp marketmodel_smm.hpp
quantooption.cpp quantooption.hpp
+ quantlibglobalfixture.cpp quantlibglobalfixture.hpp
riskstats.cpp riskstats.hpp
shortratemodels.cpp shortratemodels.hpp
-
+ speedlevel.cpp speedlevel.hpp
utilities.cpp utilities.hpp
swaptionvolstructuresutilities.hpp
)
@@ -408,6 +316,7 @@ endif()
IF (QL_BUILD_BENCHMARK)
add_executable(ql_benchmark ${QL_BENCHMARK_SOURCES})
set_target_properties(ql_benchmark PROPERTIES OUTPUT_NAME "quantlib-benchmark")
+ set_source_files_properties(quantlibbenchmark.cpp PROPERTIES SKIP_UNITY_BUILD_INCLUSION true)
if (NOT Boost_USE_STATIC_LIBS)
target_compile_definitions(ql_benchmark PRIVATE BOOST_ALL_DYN_LINK BOOST_TEST_DYN_LINK)
endif()
diff --git a/test-suite/Makefile.am b/test-suite/Makefile.am
index df3d28b1e93..03f366045df 100644
--- a/test-suite/Makefile.am
+++ b/test-suite/Makefile.am
@@ -128,6 +128,7 @@ QL_TEST_SRCS = \
period.cpp \
piecewiseyieldcurve.cpp \
piecewisezerospreadedtermstructure.cpp \
+ quantlibglobalfixture.cpp \
quantooption.cpp \
quotes.cpp \
rangeaccrual.cpp \
@@ -141,6 +142,7 @@ QL_TEST_SRCS = \
shortratemodels.cpp \
sofrfutures.cpp \
solvers.cpp \
+ speedlevel.cpp \
spreadoption.cpp \
squarerootclvmodel.cpp \
stats.cpp \
@@ -172,104 +174,6 @@ QL_TEST_SRCS = \
zerocouponswap.cpp
QL_TEST_HDRS = \
- speedlevel.hpp \
- americanoption.hpp \
- amortizingbond.hpp \
- andreasenhugevolatilityinterpl.hpp \
- array.hpp \
- asianoptions.hpp \
- assetswap.hpp \
- autocovariances.hpp \
- barrieroption.hpp \
- binaryoption.hpp \
- basismodels.hpp \
- basisswapratehelpers.hpp \
- basketoption.hpp \
- batesmodel.hpp \
- bermudanswaption.hpp \
- blackdeltacalculator.hpp \
- blackformula.hpp \
- bondforward.hpp \
- bonds.hpp \
- brownianbridge.hpp \
- businessdayconventions.hpp \
- calendars.hpp \
- callablebonds.hpp \
- capfloor.hpp \
- capflooredcoupon.hpp \
- cashflows.hpp \
- catbonds.hpp \
- cdo.hpp \
- cdsoption.hpp \
- chooseroption.hpp \
- cliquetoption.hpp \
- cms.hpp \
- cms_normal.hpp \
- cmsspread.hpp \
- commodityunitofmeasure.hpp \
- compiledboostversion.hpp \
- compoundoption.hpp \
- convertiblebonds.hpp \
- covariance.hpp \
- creditdefaultswap.hpp \
- creditriskplus.hpp \
- crosscurrencyratehelpers.hpp \
- currency.hpp \
- curvestates.hpp \
- dates.hpp \
- daycounters.hpp \
- defaultprobabilitycurves.hpp \
- digitalcoupon.hpp \
- digitaloption.hpp \
- distributions.hpp \
- dividendoption.hpp \
- doublebarrieroption.hpp \
- doublebinaryoption.hpp \
- equityindex.hpp \
- equitycashflow.hpp \
- equitytotalreturnswap.hpp \
- europeanoption.hpp \
- everestoption.hpp \
- exchangerate.hpp \
- extendedtrees.hpp \
- extensibleoptions.hpp \
- fastfouriertransform.hpp \
- fdheston.hpp \
- fdcir.hpp \
- fdmlinearop.hpp \
- fdcev.hpp \
- fdsabr.hpp \
- fittedbonddiscountcurve.hpp \
- forwardoption.hpp \
- forwardrateagreement.hpp \
- functions.hpp \
- garch.hpp \
- gaussianquadratures.hpp \
- gjrgarchmodel.hpp \
- gsr.hpp \
- hestonmodel.hpp \
- hestonslvmodel.hpp \
- himalayaoption.hpp \
- hybridhestonhullwhiteprocess.hpp \
- indexes.hpp \
- inflation.hpp \
- inflationcapfloor.hpp \
- inflationcapflooredcoupon.hpp \
- inflationcpibond.hpp \
- inflationcpicapfloor.hpp \
- inflationcpiswap.hpp \
- inflationvolatility.hpp \
- instruments.hpp \
- integrals.hpp \
- interestrates.hpp \
- interpolations.hpp \
- jumpdiffusion.hpp \
- lazyobject.hpp \
- libormarketmodel.hpp \
- libormarketmodelprocess.hpp \
- linearleastsquaresregression.hpp \
- lookbackoptions.hpp \
- lowdiscrepancysequences.hpp \
margrabeoption.hpp \
marketmodel.hpp \
marketmodel_cms.hpp \
@@ -300,6 +204,7 @@ QL_TEST_HDRS = \
period.hpp \
piecewiseyieldcurve.hpp \
piecewisezerospreadedtermstructure.hpp \
+ quantlibglobalfixture.hpp \
quantooption.hpp \
quotes.hpp \
rangeaccrual.hpp \
@@ -313,6 +218,7 @@ QL_TEST_HDRS = \
shortratemodels.hpp \
sofrfutures.hpp \
solvers.hpp \
+ speedlevel.hpp \
spreadoption.hpp \
squarerootclvmodel.hpp \
stats.hpp \
@@ -330,6 +236,7 @@ QL_TEST_HDRS = \
timeseries.hpp \
transformedgrid.hpp \
tqreigendecomposition.hpp \
+ toplevelfixture.hpp \
tracing.hpp \
twoassetbarrieroption.hpp \
twoassetcorrelationoption.hpp \
@@ -365,32 +272,21 @@ QL_BENCHMARK_SRCS = \
lowdiscrepancysequences.cpp \
marketmodel_cms.cpp \
marketmodel_smm.cpp \
+ quantlibglobalfixture.cpp \
quantooption.cpp \
riskstats.cpp \
shortratemodels.cpp \
+ speedlevel.cpp \
utilities.cpp
QL_BENCHMARK_HDRS = \
- americanoption.hpp \
- asianoptions.hpp \
- barrieroption.hpp \
- doublebarrieroption.hpp \
- basketoption.hpp \
- batesmodel.hpp \
- convertiblebonds.hpp \
- digitaloption.hpp \
- dividendoption.hpp \
- europeanoption.hpp \
- fdheston.hpp \
- hestonmodel.hpp \
- interpolations.hpp \
- jumpdiffusion.hpp \
- lowdiscrepancysequences.hpp \
marketmodel_cms.hpp \
marketmodel_smm.hpp \
+ quantlibglobalfixture.hpp \
quantooption.hpp \
riskstats.hpp \
shortratemodels.hpp \
+ speedlevel.hpp \
utilities.hpp
QL_BENCHMARKS = ${QL_BENCHMARK_SRCS} ${QL_BENCHMARK_HDRS}
@@ -427,13 +323,14 @@ unity_test.cpp: Makefile.am
echo "#include \"test-suite/$$i\"" >> $@; \
done
-nodist_quantlib_benchmark_SOURCES = unity_benchmark.cpp
+nodist_quantlib_benchmark_SOURCES = unity_benchmark.cpp quantlibbenchmark.cpp
+UNITY_SRC = $(filter-out quantlibbenchmark.cpp,$(QL_BENCHMARK_SRCS))
unity_benchmark.cpp: Makefile.am
echo "/* This file is automatically generated; do not edit. */" > $@
echo "/* Add the files to be included into Makefile.am instead. */" >> $@
echo >> $@
- for i in $(QL_BENCHMARK_SRCS); do \
+ for i in $(UNITY_SRC); do \
echo "#include \"test-suite/$$i\"" >> $@; \
done
diff --git a/test-suite/americanoption.cpp b/test-suite/americanoption.cpp
index 777c4ce53e0..3c2688f8403 100644
--- a/test-suite/americanoption.cpp
+++ b/test-suite/americanoption.cpp
@@ -19,7 +19,8 @@
FOR A PARTICULAR PURPOSE. See the license for more details.
*/
-#include "americanoption.hpp"
+#include "speedlevel.hpp"
+#include "toplevelfixture.hpp"
#include "utilities.hpp"
#include
#include
@@ -83,8 +84,11 @@ namespace {
}
+BOOST_FIXTURE_TEST_SUITE(QuantLibTest, TopLevelFixture)
-void AmericanOptionTest::testBaroneAdesiWhaleyValues() {
+BOOST_AUTO_TEST_SUITE(AmericanOptionTest)
+
+BOOST_AUTO_TEST_CASE(testBaroneAdesiWhaleyValues) {
BOOST_TEST_MESSAGE("Testing Barone-Adesi and Whaley approximation "
"for American options...");
@@ -184,8 +188,7 @@ void AmericanOptionTest::testBaroneAdesiWhaleyValues() {
}
}
-
-void AmericanOptionTest::testBjerksundStenslandValues() {
+BOOST_AUTO_TEST_CASE(testBjerksundStenslandValues) {
BOOST_TEST_MESSAGE("Testing Bjerksund and Stensland approximation "
"for American options...");
@@ -330,8 +333,7 @@ namespace {
}
-
-void AmericanOptionTest::testJuValues() {
+BOOST_AUTO_TEST_CASE(testJuValues) {
BOOST_TEST_MESSAGE("Testing Ju approximation for American options...");
@@ -381,8 +383,7 @@ void AmericanOptionTest::testJuValues() {
}
}
-
-void AmericanOptionTest::testFdValues() {
+BOOST_AUTO_TEST_CASE(testFdValues) {
BOOST_TEST_MESSAGE("Testing finite-difference and QR+ engine "
"for American options...");
@@ -563,18 +564,17 @@ namespace {
}
-
-void AmericanOptionTest::testFdAmericanGreeks() {
+BOOST_AUTO_TEST_CASE(testFdAmericanGreeks) {
BOOST_TEST_MESSAGE("Testing finite-differences American option greeks...");
testFdGreeks();
}
-void AmericanOptionTest::testFdShoutGreeks() {
+BOOST_AUTO_TEST_CASE(testFdShoutGreeks, *precondition(if_speed(Fast))) {
BOOST_TEST_MESSAGE("Testing finite-differences shout option greeks...");
testFdGreeks();
}
-void AmericanOptionTest::testFDShoutNPV() {
+BOOST_AUTO_TEST_CASE(testFDShoutNPV) {
BOOST_TEST_MESSAGE("Testing finite-differences shout option pricing...");
const auto dc = Actual365Fixed();
@@ -631,7 +631,7 @@ void AmericanOptionTest::testFDShoutNPV() {
}
}
-void AmericanOptionTest::testZeroVolFDShoutNPV() {
+BOOST_AUTO_TEST_CASE(testZeroVolFDShoutNPV) {
BOOST_TEST_MESSAGE("Testing zero volatility shout option pricing with discrete dividends...");
const auto dc = Actual365Fixed();
@@ -710,7 +710,7 @@ void AmericanOptionTest::testZeroVolFDShoutNPV() {
}
}
-void AmericanOptionTest::testLargeDividendShoutNPV() {
+BOOST_AUTO_TEST_CASE(testLargeDividendShoutNPV) {
BOOST_TEST_MESSAGE("Testing zero strike shout option pricing with discrete dividends...");
const auto dc = Actual365Fixed();
@@ -792,7 +792,7 @@ void AmericanOptionTest::testLargeDividendShoutNPV() {
}
}
-void AmericanOptionTest::testEscrowedVsSpotAmericanOption() {
+BOOST_AUTO_TEST_CASE(testEscrowedVsSpotAmericanOption) {
BOOST_TEST_MESSAGE("Testing escrowed vs spot dividend model for American options...");
const auto dc = Actual360();
@@ -863,8 +863,7 @@ void AmericanOptionTest::testEscrowedVsSpotAmericanOption() {
}
}
-
-void AmericanOptionTest::testTodayIsDividendDate() {
+BOOST_AUTO_TEST_CASE(testTodayIsDividendDate) {
BOOST_TEST_MESSAGE("Testing escrowed vs spot dividend model on dividend dates for American options...");
const auto dc = Actual360();
@@ -982,8 +981,7 @@ void AmericanOptionTest::testTodayIsDividendDate() {
}
}
-
-void AmericanOptionTest::testCallPutParity() {
+BOOST_AUTO_TEST_CASE(testCallPutParity) {
BOOST_TEST_MESSAGE("Testing call/put parity for American options...");
// R.L. McDonald, M.D. Schroder: A parity result for American option
@@ -1071,7 +1069,7 @@ void AmericanOptionTest::testCallPutParity() {
}
}
-void AmericanOptionTest::testQdPlusBoundaryValues() {
+BOOST_AUTO_TEST_CASE(testQdPlusBoundaryValues) {
BOOST_TEST_MESSAGE("Testing QD+ boundary approximation...");
const DayCounter dc = Actual365Fixed();
@@ -1122,7 +1120,7 @@ void AmericanOptionTest::testQdPlusBoundaryValues() {
}
}
-void AmericanOptionTest::testQdPlusBoundaryConvergence() {
+BOOST_AUTO_TEST_CASE(testQdPlusBoundaryConvergence) {
BOOST_TEST_MESSAGE("Testing QD+ boundary convergence...");
const DayCounter dc = Actual365Fixed();
@@ -1187,7 +1185,7 @@ void AmericanOptionTest::testQdPlusBoundaryConvergence() {
}
}
-void AmericanOptionTest::testQdAmericanEngines() {
+BOOST_AUTO_TEST_CASE(testQdAmericanEngines) {
BOOST_TEST_MESSAGE("Testing QD+ American option pricing...");
const DayCounter dc = Actual365Fixed();
@@ -1432,7 +1430,7 @@ void AmericanOptionTest::testQdAmericanEngines() {
};
}
-void AmericanOptionTest::testQdFpIterationScheme() {
+BOOST_AUTO_TEST_CASE(testQdFpIterationScheme) {
BOOST_TEST_MESSAGE("Testing Legendre and tanh-sinh iteration "
"scheme for QD+ fixed-point American engine...");
@@ -1459,8 +1457,7 @@ void AmericanOptionTest::testQdFpIterationScheme() {
}
}
-
-void AmericanOptionTest::testAndersenLakeHighPrecisionExample() {
+BOOST_AUTO_TEST_CASE(testAndersenLakeHighPrecisionExample) {
BOOST_TEST_MESSAGE("Testing Andersen, Lake and Offengenden "
"high precision example...");
@@ -1556,8 +1553,7 @@ void AmericanOptionTest::testAndersenLakeHighPrecisionExample() {
}
}
-
-void AmericanOptionTest::testQdEngineStandardExample() {
+BOOST_AUTO_TEST_CASE(testQdEngineStandardExample) {
BOOST_TEST_MESSAGE("Testing Andersen, Lake and Offengenden "
"standard example...");
@@ -1649,7 +1645,7 @@ namespace {
};
}
-void AmericanOptionTest::testBulkQdFpAmericanEngine() {
+BOOST_AUTO_TEST_CASE(testBulkQdFpAmericanEngine) {
BOOST_TEST_MESSAGE("Testing Andersen, Lake and Offengenden "
"bulk examples...");
@@ -1758,7 +1754,7 @@ void AmericanOptionTest::testBulkQdFpAmericanEngine() {
<< "\n tol : " << tolMax);
}
-void AmericanOptionTest::testQdEngineWithLobattoIntegral() {
+BOOST_AUTO_TEST_CASE(testQdEngineWithLobattoIntegral) {
BOOST_TEST_MESSAGE("Testing Andersen, Lake and Offengenden "
"with high precision Gauss-Lobatto integration...");
@@ -1825,7 +1821,7 @@ void AmericanOptionTest::testQdEngineWithLobattoIntegral() {
}
}
-void AmericanOptionTest::testQdNegativeDividendYield() {
+BOOST_AUTO_TEST_CASE(testQdNegativeDividendYield) {
BOOST_TEST_MESSAGE("Testing Andersen, Lake and Offengenden "
"with positive or zero interest rate and "
"negative dividend yield...");
@@ -1896,7 +1892,7 @@ void AmericanOptionTest::testQdNegativeDividendYield() {
}
}
-void AmericanOptionTest::testBjerksundStenslandEuropeanGreeks() {
+BOOST_AUTO_TEST_CASE(testBjerksundStenslandEuropeanGreeks) {
BOOST_TEST_MESSAGE("Testing Bjerksund-Stensland greeks when early "
"exercise is not optimal...");
@@ -1973,8 +1969,7 @@ void AmericanOptionTest::testBjerksundStenslandEuropeanGreeks() {
}
}
-
-void AmericanOptionTest::testBjerksundStenslandAmericanGreeks() {
+BOOST_AUTO_TEST_CASE(testBjerksundStenslandAmericanGreeks) {
BOOST_TEST_MESSAGE("Testing Bjerksund-Stensland American greeks...");
const Date today = Date(5, December, 2022);
@@ -2164,8 +2159,7 @@ void AmericanOptionTest::testBjerksundStenslandAmericanGreeks() {
}
}
-
-void AmericanOptionTest::testSingleBjerksundStenslandGreeks() {
+BOOST_AUTO_TEST_CASE(testSingleBjerksundStenslandGreeks) {
BOOST_TEST_MESSAGE("Testing a single Bjerksund-Stensland greeks set...");
const Date today = Date(20, January, 2023);
@@ -2248,39 +2242,6 @@ void AmericanOptionTest::testSingleBjerksundStenslandGreeks() {
BOOST_FAIL("American exercise type expected");
}
+BOOST_AUTO_TEST_SUITE_END()
-test_suite* AmericanOptionTest::suite(SpeedLevel speed) {
- auto* suite = BOOST_TEST_SUITE("American option tests");
-
- suite->add(QUANTLIB_TEST_CASE(&AmericanOptionTest::testBaroneAdesiWhaleyValues));
- suite->add(QUANTLIB_TEST_CASE(&AmericanOptionTest::testBjerksundStenslandValues));
- suite->add(QUANTLIB_TEST_CASE(&AmericanOptionTest::testJuValues));
- suite->add(QUANTLIB_TEST_CASE(&AmericanOptionTest::testFdValues));
- suite->add(QUANTLIB_TEST_CASE(&AmericanOptionTest::testFdAmericanGreeks));
- suite->add(QUANTLIB_TEST_CASE(&AmericanOptionTest::testFDShoutNPV));
- suite->add(QUANTLIB_TEST_CASE(&AmericanOptionTest::testZeroVolFDShoutNPV));
- suite->add(QUANTLIB_TEST_CASE(&AmericanOptionTest::testLargeDividendShoutNPV));
- suite->add(QUANTLIB_TEST_CASE(&AmericanOptionTest::testEscrowedVsSpotAmericanOption));
- suite->add(QUANTLIB_TEST_CASE(&AmericanOptionTest::testTodayIsDividendDate));
- suite->add(QUANTLIB_TEST_CASE(&AmericanOptionTest::testCallPutParity));
- suite->add(QUANTLIB_TEST_CASE(&AmericanOptionTest::testQdPlusBoundaryValues));
- suite->add(QUANTLIB_TEST_CASE(&AmericanOptionTest::testQdPlusBoundaryConvergence));
- suite->add(QUANTLIB_TEST_CASE(&AmericanOptionTest::testQdAmericanEngines));
- suite->add(QUANTLIB_TEST_CASE(&AmericanOptionTest::testQdFpIterationScheme));
- suite->add(QUANTLIB_TEST_CASE(&AmericanOptionTest::testAndersenLakeHighPrecisionExample));
- suite->add(QUANTLIB_TEST_CASE(&AmericanOptionTest::testQdEngineStandardExample));
- suite->add(QUANTLIB_TEST_CASE(&AmericanOptionTest::testBulkQdFpAmericanEngine));
- suite->add(QUANTLIB_TEST_CASE(&AmericanOptionTest::testQdEngineWithLobattoIntegral));
- suite->add(QUANTLIB_TEST_CASE(&AmericanOptionTest::testQdNegativeDividendYield));
- suite->add(QUANTLIB_TEST_CASE(&AmericanOptionTest::testBjerksundStenslandEuropeanGreeks));
- suite->add(QUANTLIB_TEST_CASE(&AmericanOptionTest::testBjerksundStenslandAmericanGreeks));
- suite->add(QUANTLIB_TEST_CASE(&AmericanOptionTest::testSingleBjerksundStenslandGreeks));
-
-
- if (speed <= Fast) {
- suite->add(QUANTLIB_TEST_CASE(&AmericanOptionTest::testFdShoutGreeks));
- }
-
- return suite;
-}
-
+BOOST_AUTO_TEST_SUITE_END()
\ No newline at end of file
diff --git a/test-suite/americanoption.hpp b/test-suite/americanoption.hpp
deleted file mode 100644
index 251eade5538..00000000000
--- a/test-suite/americanoption.hpp
+++ /dev/null
@@ -1,62 +0,0 @@
-/* -*- mode: c++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
-
-/*
- Copyright (C) 2003 Ferdinando Ametrano
- Copyright (C) 2005 Joseph Wang
- Copyright (C) 2005 StatPro Italia srl
-
- This file is part of QuantLib, a free-software/open-source library
- for financial quantitative analysts and developers - http://quantlib.org/
-
- QuantLib is free software: you can redistribute it and/or modify it
- under the terms of the QuantLib license. You should have received a
- copy of the license along with this program; if not, please email
- . The license is also available online at
- .
-
- This program is distributed in the hope that it will be useful, but WITHOUT
- ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
- FOR A PARTICULAR PURPOSE. See the license for more details.
-*/
-
-#ifndef quantlib_test_american_option_hpp
-#define quantlib_test_american_option_hpp
-
-#include
-#include "speedlevel.hpp"
-
-/* remember to document new and/or updated tests in the Doxygen
- comment block of the corresponding class */
-
-class AmericanOptionTest {
- public:
- static void testBaroneAdesiWhaleyValues();
- static void testBjerksundStenslandValues();
- static void testJuValues();
- static void testFdValues();
- static void testFdAmericanGreeks();
- static void testFdShoutGreeks();
- static void testFDShoutNPV();
- static void testZeroVolFDShoutNPV();
- static void testLargeDividendShoutNPV();
- static void testEscrowedVsSpotAmericanOption();
- static void testTodayIsDividendDate();
- static void testCallPutParity();
- static void testQdPlusBoundaryValues();
- static void testQdPlusBoundaryConvergence();
- static void testQdAmericanEngines();
- static void testQdFpIterationScheme();
- static void testAndersenLakeHighPrecisionExample();
- static void testQdEngineStandardExample();
- static void testBulkQdFpAmericanEngine();
- static void testQdEngineWithLobattoIntegral();
- static void testQdNegativeDividendYield();
- static void testBjerksundStenslandEuropeanGreeks();
- static void testBjerksundStenslandAmericanGreeks();
- static void testSingleBjerksundStenslandGreeks();
-
- static boost::unit_test_framework::test_suite* suite(SpeedLevel);
-};
-
-
-#endif
diff --git a/test-suite/amortizingbond.cpp b/test-suite/amortizingbond.cpp
index 0cf4bc7fc5e..c5ad555cd26 100644
--- a/test-suite/amortizingbond.cpp
+++ b/test-suite/amortizingbond.cpp
@@ -15,7 +15,7 @@
FOR A PARTICULAR PURPOSE. See the license for more details.
*/
-#include "amortizingbond.hpp"
+#include "toplevelfixture.hpp"
#include "utilities.hpp"
#include
#include
@@ -31,7 +31,11 @@
using namespace QuantLib;
using namespace boost::unit_test_framework;
-void AmortizingBondTest::testAmortizingFixedRateBond() {
+BOOST_FIXTURE_TEST_SUITE(QuantLibTest, TopLevelFixture)
+
+BOOST_AUTO_TEST_SUITE(AmortizingBondTest)
+
+BOOST_AUTO_TEST_CASE(testAmortizingFixedRateBond) {
BOOST_TEST_MESSAGE("Testing amortizing fixed rate bond...");
/*
@@ -93,7 +97,7 @@ void AmortizingBondTest::testAmortizingFixedRateBond() {
}
}
-void AmortizingBondTest::testBrazilianAmortizingFixedRateBond() {
+BOOST_AUTO_TEST_CASE(testBrazilianAmortizingFixedRateBond) {
BOOST_TEST_MESSAGE("Testing Brazilian amortizing fixed rate bond...");
/*
@@ -213,7 +217,7 @@ void AmortizingBondTest::testBrazilianAmortizingFixedRateBond() {
}
-void AmortizingBondTest::testAmortizingFixedRateBondWithDrawDown() {
+BOOST_AUTO_TEST_CASE(testAmortizingFixedRateBondWithDrawDown) {
BOOST_TEST_MESSAGE("Testing amortizing fixed rate bond with draw-down...");
Date issueDate = Date(19, May, 2012);
@@ -273,10 +277,6 @@ void AmortizingBondTest::testAmortizingFixedRateBondWithDrawDown() {
}
-test_suite* AmortizingBondTest::suite() {
- auto* suite = BOOST_TEST_SUITE("Amortizing Bond tests");
- suite->add(QUANTLIB_TEST_CASE(&AmortizingBondTest::testAmortizingFixedRateBond));
- suite->add(QUANTLIB_TEST_CASE(&AmortizingBondTest::testBrazilianAmortizingFixedRateBond));
- suite->add(QUANTLIB_TEST_CASE(&AmortizingBondTest::testAmortizingFixedRateBondWithDrawDown));
- return suite;
-}
+BOOST_AUTO_TEST_SUITE_END()
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/test-suite/amortizingbond.hpp b/test-suite/amortizingbond.hpp
deleted file mode 100644
index dd9a9597a18..00000000000
--- a/test-suite/amortizingbond.hpp
+++ /dev/null
@@ -1,33 +0,0 @@
-/* -*- mode: c++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
-
-/*
- Copyright (C) 2014 Cheng Li
-
- This file is part of QuantLib, a free-software/open-source library
- for financial quantitative analysts and developers - http://quantlib.org/
-
- QuantLib is free software: you can redistribute it and/or modify it
- under the terms of the QuantLib license. You should have received a
- copy of the license along with this program; if not, please email
- . The license is also available online at
- .
-
- This program is distributed in the hope that it will be useful, but WITHOUT
- ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
- FOR A PARTICULAR PURPOSE. See the license for more details.
-*/
-
-#ifndef quantlib_test_amortizing_bond_hpp
-#define quantlib_test_amortizing_bond_hpp
-
-#include
-
-class AmortizingBondTest {
- public:
- static void testAmortizingFixedRateBond();
- static void testBrazilianAmortizingFixedRateBond();
- static void testAmortizingFixedRateBondWithDrawDown();
- static boost::unit_test_framework::test_suite* suite();
-};
-
-#endif
diff --git a/test-suite/andreasenhugevolatilityinterpl.cpp b/test-suite/andreasenhugevolatilityinterpl.cpp
index 1f7747ca563..26973bb8710 100644
--- a/test-suite/andreasenhugevolatilityinterpl.cpp
+++ b/test-suite/andreasenhugevolatilityinterpl.cpp
@@ -17,7 +17,8 @@
FOR A PARTICULAR PURPOSE. See the license for more details.
*/
-#include "andreasenhugevolatilityinterpl.hpp"
+#include "speedlevel.hpp"
+#include "toplevelfixture.hpp"
#include "utilities.hpp"
#include
#include
@@ -341,10 +342,56 @@ namespace andreasen_huge_volatility_interpl_test {
return { spot, rTS, qTS, calibrationSet };
}
+
+ std::pair > sabrData() {
+
+ const DayCounter dc = Actual365Fixed();
+ const Date today = Date(4, January, 2018);
+
+ const Real alpha = 0.15;
+ const Real beta = 0.8;
+ const Real nu = 0.5;
+ const Real rho = -0.48;
+ const Real forward = 0.03;
+ const Size maturityInYears = 20;
+
+ const Date maturityDate = today + Period(maturityInYears, Years);
+ const Time maturity = dc.yearFraction(today, maturityDate);
+
+ AndreasenHugeVolatilityInterpl::CalibrationSet calibrationSet;
+
+ const Real strikes[] = { 0.02, 0.025, 0.03, 0.035, 0.04, 0.05, 0.06 };
+
+ for (Real strike : strikes) {
+ const Volatility vol = sabrVolatility(strike, forward, maturity, alpha, beta, nu, rho);
+
+ calibrationSet.emplace_back(
+ ext::make_shared(
+ ext::make_shared(
+ Option::Call, strike),
+ ext::make_shared(maturityDate)),
+ ext::make_shared(vol));
+ }
+
+ const Handle rTS(flatRate(today, forward, dc));
+ const Handle qTS(flatRate(today, forward, dc));
+
+ Handle spot(ext::make_shared(forward));
+
+ const CalibrationData data = { spot, rTS, qTS, calibrationSet};
+
+ std::vector parameter = { alpha, beta, nu, rho, forward, maturity };
+
+ return std::make_pair(data, parameter);
+ }
}
-void AndreasenHugeVolatilityInterplTest::testAndreasenHugePut() {
+BOOST_FIXTURE_TEST_SUITE(QuantLibTest, TopLevelFixture)
+
+BOOST_AUTO_TEST_SUITE(AndreasenHugeVolatilityInterplTest)
+
+BOOST_AUTO_TEST_CASE(testAndreasenHugePut, *precondition(if_speed(Fast))) {
BOOST_TEST_MESSAGE(
"Testing Andreasen-Huge example with Put calibration...");
@@ -363,7 +410,7 @@ void AndreasenHugeVolatilityInterplTest::testAndreasenHugePut() {
testAndreasenHugeVolatilityInterpolation(data, expected);
}
-void AndreasenHugeVolatilityInterplTest::testAndreasenHugeCall() {
+BOOST_AUTO_TEST_CASE(testAndreasenHugeCall, *precondition(if_speed(Fast))) {
BOOST_TEST_MESSAGE(
"Testing Andreasen-Huge example with Call calibration...");
@@ -382,7 +429,7 @@ void AndreasenHugeVolatilityInterplTest::testAndreasenHugeCall() {
testAndreasenHugeVolatilityInterpolation(data, expected);
}
-void AndreasenHugeVolatilityInterplTest::testAndreasenHugeCallPut() {
+BOOST_AUTO_TEST_CASE(testAndreasenHugeCallPut, *precondition(if_speed(Fast))) {
BOOST_TEST_MESSAGE(
"Testing Andreasen-Huge example with instantaneous "
@@ -402,7 +449,7 @@ void AndreasenHugeVolatilityInterplTest::testAndreasenHugeCallPut() {
testAndreasenHugeVolatilityInterpolation(data, expected);
}
-void AndreasenHugeVolatilityInterplTest::testLinearInterpolation() {
+BOOST_AUTO_TEST_CASE(testLinearInterpolation, *precondition(if_speed(Fast))) {
BOOST_TEST_MESSAGE(
"Testing Andreasen-Huge example with linear interpolation...");
@@ -420,7 +467,7 @@ void AndreasenHugeVolatilityInterplTest::testLinearInterpolation() {
testAndreasenHugeVolatilityInterpolation(data, expected);
}
-void AndreasenHugeVolatilityInterplTest::testPiecewiseConstantInterpolation() {
+BOOST_AUTO_TEST_CASE(testPiecewiseConstantInterpolation, *precondition(if_speed(Fast))) {
BOOST_TEST_MESSAGE(
"Testing Andreasen-Huge example with piecewise constant interpolation...");
@@ -438,7 +485,7 @@ void AndreasenHugeVolatilityInterplTest::testPiecewiseConstantInterpolation() {
testAndreasenHugeVolatilityInterpolation(data, expected);
}
-void AndreasenHugeVolatilityInterplTest::testTimeDependentInterestRates() {
+BOOST_AUTO_TEST_CASE(testTimeDependentInterestRates, *precondition(if_speed(Fast))) {
BOOST_TEST_MESSAGE(
"Testing Andreasen-Huge volatility interpolation with "
@@ -524,7 +571,7 @@ void AndreasenHugeVolatilityInterplTest::testTimeDependentInterestRates() {
testAndreasenHugeVolatilityInterpolation(irData, expected);
}
-void AndreasenHugeVolatilityInterplTest::testSingleOptionCalibration() {
+BOOST_AUTO_TEST_CASE(testSingleOptionCalibration) {
BOOST_TEST_MESSAGE(
"Testing Andreasen-Huge volatility interpolation with "
"a single option...");
@@ -583,7 +630,7 @@ void AndreasenHugeVolatilityInterplTest::testSingleOptionCalibration() {
}
}
-void AndreasenHugeVolatilityInterplTest::testArbitrageFree() {
+BOOST_AUTO_TEST_CASE(testArbitrageFree) {
BOOST_TEST_MESSAGE(
"Testing Andreasen-Huge volatility interpolation gives "
"arbitrage free prices...");
@@ -672,7 +719,7 @@ void AndreasenHugeVolatilityInterplTest::testArbitrageFree() {
}
}
-void AndreasenHugeVolatilityInterplTest::testBarrierOptionPricing() {
+BOOST_AUTO_TEST_CASE(testBarrierOptionPricing, *precondition(if_speed(Fast))) {
BOOST_TEST_MESSAGE(
"Testing Barrier option pricing with Andreasen-Huge "
"local volatility surface...");
@@ -776,51 +823,7 @@ void AndreasenHugeVolatilityInterplTest::testBarrierOptionPricing() {
}
}
-namespace andreasen_huge_volatility_interpl_test {
- std::pair > sabrData() {
-
- const DayCounter dc = Actual365Fixed();
- const Date today = Date(4, January, 2018);
-
- const Real alpha = 0.15;
- const Real beta = 0.8;
- const Real nu = 0.5;
- const Real rho = -0.48;
- const Real forward = 0.03;
- const Size maturityInYears = 20;
-
- const Date maturityDate = today + Period(maturityInYears, Years);
- const Time maturity = dc.yearFraction(today, maturityDate);
-
- AndreasenHugeVolatilityInterpl::CalibrationSet calibrationSet;
-
- const Real strikes[] = { 0.02, 0.025, 0.03, 0.035, 0.04, 0.05, 0.06 };
-
- for (Real strike : strikes) {
- const Volatility vol = sabrVolatility(strike, forward, maturity, alpha, beta, nu, rho);
-
- calibrationSet.emplace_back(
- ext::make_shared(
- ext::make_shared(
- Option::Call, strike),
- ext::make_shared(maturityDate)),
- ext::make_shared(vol));
- }
-
- const Handle rTS(flatRate(today, forward, dc));
- const Handle qTS(flatRate(today, forward, dc));
-
- Handle spot(ext::make_shared(forward));
-
- const CalibrationData data = { spot, rTS, qTS, calibrationSet};
-
- std::vector parameter = { alpha, beta, nu, rho, forward, maturity };
-
- return std::make_pair(data, parameter);
- }
-}
-
-void AndreasenHugeVolatilityInterplTest::testPeterAndFabiensExample() {
+BOOST_AUTO_TEST_CASE(testPeterAndFabiensExample) {
BOOST_TEST_MESSAGE(
"Testing Peter's and Fabien's SABR example...");
@@ -868,7 +871,7 @@ void AndreasenHugeVolatilityInterplTest::testPeterAndFabiensExample() {
}
}
-void AndreasenHugeVolatilityInterplTest::testDifferentOptimizers() {
+BOOST_AUTO_TEST_CASE(testDifferentOptimizers) {
BOOST_TEST_MESSAGE(
"Testing different optimizer for Andreasen-Huge "
"volatility interpolation...");
@@ -899,7 +902,7 @@ void AndreasenHugeVolatilityInterplTest::testDifferentOptimizers() {
}
}
-void AndreasenHugeVolatilityInterplTest::testMovingReferenceDate() {
+BOOST_AUTO_TEST_CASE(testMovingReferenceDate) {
BOOST_TEST_MESSAGE(
"Testing that reference date of adapter surface moves along with "
"evaluation date...");
@@ -974,7 +977,7 @@ void AndreasenHugeVolatilityInterplTest::testMovingReferenceDate() {
<< "\n tolerance : " << tol);
}
-void AndreasenHugeVolatilityInterplTest::testFlatVolCalibration() {
+BOOST_AUTO_TEST_CASE(testFlatVolCalibration) {
BOOST_TEST_MESSAGE(
"Testing Andreasen-Huge example with flat volatility surface...");
@@ -1036,27 +1039,6 @@ void AndreasenHugeVolatilityInterplTest::testFlatVolCalibration() {
testAndreasenHugeVolatilityInterpolation(flatVolData, expected);
}
+BOOST_AUTO_TEST_SUITE_END()
-test_suite* AndreasenHugeVolatilityInterplTest::suite(SpeedLevel speed) {
- auto* suite = BOOST_TEST_SUITE("Andreasen-Huge volatility interpolation tests");
-
- suite->add(QUANTLIB_TEST_CASE(&AndreasenHugeVolatilityInterplTest::testSingleOptionCalibration));
- suite->add(QUANTLIB_TEST_CASE(&AndreasenHugeVolatilityInterplTest::testArbitrageFree));
- suite->add(QUANTLIB_TEST_CASE(&AndreasenHugeVolatilityInterplTest::testPeterAndFabiensExample));
- suite->add(QUANTLIB_TEST_CASE(&AndreasenHugeVolatilityInterplTest::testDifferentOptimizers));
- suite->add(QUANTLIB_TEST_CASE(&AndreasenHugeVolatilityInterplTest::testMovingReferenceDate));
- suite->add(QUANTLIB_TEST_CASE(&AndreasenHugeVolatilityInterplTest::testFlatVolCalibration));
-
- if (speed <= Fast) {
- suite->add(QUANTLIB_TEST_CASE(&AndreasenHugeVolatilityInterplTest::testAndreasenHugePut));
- suite->add(QUANTLIB_TEST_CASE(&AndreasenHugeVolatilityInterplTest::testAndreasenHugeCall));
- suite->add(QUANTLIB_TEST_CASE(&AndreasenHugeVolatilityInterplTest::testAndreasenHugeCallPut));
- suite->add(QUANTLIB_TEST_CASE(&AndreasenHugeVolatilityInterplTest::testLinearInterpolation));
- suite->add(QUANTLIB_TEST_CASE(&AndreasenHugeVolatilityInterplTest::testPiecewiseConstantInterpolation));
- suite->add(QUANTLIB_TEST_CASE(&AndreasenHugeVolatilityInterplTest::testTimeDependentInterestRates));
- suite->add(QUANTLIB_TEST_CASE(&AndreasenHugeVolatilityInterplTest::testBarrierOptionPricing));
- }
-
- return suite;
-}
-
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/test-suite/andreasenhugevolatilityinterpl.hpp b/test-suite/andreasenhugevolatilityinterpl.hpp
deleted file mode 100644
index 3522e75cf35..00000000000
--- a/test-suite/andreasenhugevolatilityinterpl.hpp
+++ /dev/null
@@ -1,49 +0,0 @@
-/* -*- mode: c++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
-
-/*
- Copyright (C) 2017, 2018 Klaus Spanderen
-
- This file is part of QuantLib, a free-software/open-source library
- for financial quantitative analysts and developers - http://quantlib.org/
-
- QuantLib is free software: you can redistribute it and/or modify it
- under the terms of the QuantLib license. You should have received a
- copy of the license along with this program; if not, please email
- . The license is also available online at
- .
-
- This program is distributed in the hope that it will be useful, but WITHOUT
- ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
- FOR A PARTICULAR PURPOSE. See the license for more details.
-*/
-
-#ifndef quantlib_test_local_volatility_hpp
-#define quantlib_test_local_volatility_hpp
-
-#include
-#include "speedlevel.hpp"
-
-/* remember to document new and/or updated tests in the Doxygen
- comment block of the corresponding class */
-
-class AndreasenHugeVolatilityInterplTest {
- public:
- static void testAndreasenHugePut();
- static void testAndreasenHugeCall();
- static void testAndreasenHugeCallPut();
- static void testLinearInterpolation();
- static void testPiecewiseConstantInterpolation();
- static void testTimeDependentInterestRates();
- static void testSingleOptionCalibration();
- static void testArbitrageFree();
- static void testBarrierOptionPricing();
- static void testPeterAndFabiensExample();
- static void testDifferentOptimizers();
- static void testMovingReferenceDate();
- static void testFlatVolCalibration();
-
- static boost::unit_test_framework::test_suite* suite(SpeedLevel speed);
-};
-
-
-#endif
diff --git a/test-suite/array.cpp b/test-suite/array.cpp
index 33cc2abe197..673a58b6790 100644
--- a/test-suite/array.cpp
+++ b/test-suite/array.cpp
@@ -17,7 +17,7 @@
FOR A PARTICULAR PURPOSE. See the license for more details.
*/
-#include "array.hpp"
+#include "toplevelfixture.hpp"
#include "utilities.hpp"
#include
#include
@@ -32,7 +32,11 @@ namespace array_test {
};
}
-void ArrayTest::testConstruction() {
+BOOST_FIXTURE_TEST_SUITE(QuantLibTest, TopLevelFixture)
+
+BOOST_AUTO_TEST_SUITE(ArrayTest)
+
+BOOST_AUTO_TEST_CASE(testConstruction) {
BOOST_TEST_MESSAGE("Testing array construction...");
@@ -117,7 +121,7 @@ void ArrayTest::testConstruction() {
}
}
-void ArrayTest::testArrayFunctions() {
+BOOST_AUTO_TEST_CASE(testArrayFunctions) {
BOOST_TEST_MESSAGE("Testing array functions...");
@@ -178,7 +182,7 @@ void ArrayTest::testArrayFunctions() {
}
}
-void ArrayTest::testArrayResize() {
+BOOST_AUTO_TEST_CASE(testArrayResize) {
BOOST_TEST_MESSAGE("Testing array resize...");
Array a(10,1.0,1.0);
@@ -213,7 +217,7 @@ void ArrayTest::testArrayResize() {
QL_CHECK_CLOSE(actual[i], expected[i], 100 * QL_EPSILON); \
} \
-void ArrayTest::testArrayOperators() {
+BOOST_AUTO_TEST_CASE(testArrayOperators) {
BOOST_TEST_MESSAGE("Testing array operators...");
auto get_array = []() {
@@ -327,12 +331,7 @@ void ArrayTest::testArrayOperators() {
QL_CHECK_CLOSE_ARRAY(real_rvalue_quotient, scalar_quotient_2);
}
-test_suite* ArrayTest::suite() {
- auto* suite = BOOST_TEST_SUITE("array tests");
- suite->add(QUANTLIB_TEST_CASE(&ArrayTest::testConstruction));
- suite->add(QUANTLIB_TEST_CASE(&ArrayTest::testArrayFunctions));
- suite->add(QUANTLIB_TEST_CASE(&ArrayTest::testArrayResize));
- suite->add(QUANTLIB_TEST_CASE(&ArrayTest::testArrayOperators));
- return suite;
-}
+BOOST_AUTO_TEST_SUITE_END()
+
+BOOST_AUTO_TEST_SUITE_END()
diff --git a/test-suite/array.hpp b/test-suite/array.hpp
deleted file mode 100644
index ea2d280d3b0..00000000000
--- a/test-suite/array.hpp
+++ /dev/null
@@ -1,38 +0,0 @@
-/* -*- mode: c++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
-
-/*
- Copyright (C) 2005 StatPro Italia srl
-
- This file is part of QuantLib, a free-software/open-source library
- for financial quantitative analysts and developers - http://quantlib.org/
-
- QuantLib is free software: you can redistribute it and/or modify it
- under the terms of the QuantLib license. You should have received a
- copy of the license along with this program; if not, please email
- . The license is also available online at
- .
-
- This program is distributed in the hope that it will be useful, but WITHOUT
- ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
- FOR A PARTICULAR PURPOSE. See the license for more details.
-*/
-
-#ifndef quantlib_test_array_hpp
-#define quantlib_test_array_hpp
-
-#include
-
-/* remember to document new and/or updated tests in the Doxygen
- comment block of the corresponding class */
-
-class ArrayTest {
- public:
- static void testConstruction();
- static void testArrayFunctions();
- static void testArrayResize();
- static void testArrayOperators();
- static boost::unit_test_framework::test_suite* suite();
-};
-
-
-#endif
diff --git a/test-suite/asianoptions.cpp b/test-suite/asianoptions.cpp
index 07c30b134e1..836e7b452e7 100644
--- a/test-suite/asianoptions.cpp
+++ b/test-suite/asianoptions.cpp
@@ -22,7 +22,8 @@
FOR A PARTICULAR PURPOSE. See the license for more details.
*/
-#include "asianoptions.hpp"
+#include "speedlevel.hpp"
+#include "toplevelfixture.hpp"
#include "utilities.hpp"
#include
#include
@@ -89,10 +90,63 @@ namespace {
QL_FAIL("unknown averaging");
}
+ struct DiscreteAverageData {
+ Option::Type type;
+ Real underlying;
+ Real strike;
+ Rate dividendYield;
+ Rate riskFreeRate;
+ Time first;
+ Time length;
+ Size fixings;
+ Volatility volatility;
+ bool controlVariate;
+ Real result;
+ };
+
+ struct ContinuousAverageData {
+ Option::Type type;
+ Real spot;
+ Real currentAverage;
+ Real strike;
+ Rate dividendYield;
+ Rate riskFreeRate;
+ Volatility volatility;
+ Natural length;
+ Natural elapsed;
+ Real result;
+ };
+
+ struct DiscreteAverageDataTermStructure {
+ Option::Type type;
+ Real underlying;
+ Real strike;
+ Rate b;
+ Rate riskFreeRate;
+ Time first; // t1
+ Time expiry;
+ Size fixings;
+ Volatility volatility;
+ std::string slope;
+ Real result;
+ };
+
+ struct VecerData {
+ Real spot;
+ Rate riskFreeRate;
+ Volatility volatility;
+ Real strike;
+ Natural length;
+ Real result;
+ Real tolerance;
+ };
}
+BOOST_FIXTURE_TEST_SUITE(QuantLibTest, TopLevelFixture)
-void AsianOptionTest::testAnalyticContinuousGeometricAveragePrice() {
+BOOST_AUTO_TEST_SUITE(AsianOptionTest)
+
+BOOST_AUTO_TEST_CASE(testAnalyticContinuousGeometricAveragePrice) {
BOOST_TEST_MESSAGE(
"Testing analytic continuous geometric average-price Asians...");
@@ -172,8 +226,7 @@ void AsianOptionTest::testAnalyticContinuousGeometricAveragePrice() {
}
-
-void AsianOptionTest::testAnalyticContinuousGeometricAveragePriceGreeks() {
+BOOST_AUTO_TEST_CASE(testAnalyticContinuousGeometricAveragePriceGreeks) {
BOOST_TEST_MESSAGE(
"Testing analytic continuous geometric average-price Asian greeks...");
@@ -316,8 +369,7 @@ void AsianOptionTest::testAnalyticContinuousGeometricAveragePriceGreeks() {
}
}
-
-void AsianOptionTest::testAnalyticDiscreteGeometricAveragePrice() {
+BOOST_AUTO_TEST_CASE(testAnalyticDiscreteGeometricAveragePrice) {
BOOST_TEST_MESSAGE(
"Testing analytic discrete geometric average-price Asians...");
@@ -379,7 +431,7 @@ void AsianOptionTest::testAnalyticDiscreteGeometricAveragePrice() {
}
}
-void AsianOptionTest::testAnalyticDiscreteGeometricAverageStrike() {
+BOOST_AUTO_TEST_CASE(testAnalyticDiscreteGeometricAverageStrike) {
BOOST_TEST_MESSAGE(
"Testing analytic discrete geometric average-strike Asians...");
@@ -438,8 +490,7 @@ void AsianOptionTest::testAnalyticDiscreteGeometricAverageStrike() {
}
}
-
-void AsianOptionTest::testMCDiscreteGeometricAveragePrice() {
+BOOST_AUTO_TEST_CASE(testMCDiscreteGeometricAveragePrice) {
BOOST_TEST_MESSAGE(
"Testing Monte Carlo discrete geometric average-price Asians...");
@@ -508,7 +559,6 @@ void AsianOptionTest::testMCDiscreteGeometricAveragePrice() {
}
}
-
void testDiscreteGeometricAveragePriceHeston(const ext::shared_ptr& engine,
const Real tol[]) {
@@ -571,7 +621,7 @@ void testDiscreteGeometricAveragePriceHeston(const ext::shared_ptr tolerance) {
REPORT_FAILURE("value", averageType, 1.0, 0.0,
std::vector(), payoff, europeanExercise, spot->value(),
@@ -581,44 +631,7 @@ void testDiscreteGeometricAveragePriceHeston(const ext::shared_ptr spot(ext::shared_ptr(new SimpleQuote(100)));
- ext::shared_ptr qRate(new SimpleQuote(0.0));
- ext::shared_ptr qTS = flatRate(today, qRate, dc);
- ext::shared_ptr rRate(new SimpleQuote(0.05));
- ext::shared_ptr rTS = flatRate(today, rRate, dc);
-
- Real v0 = 0.09;
- Real kappa = 1.15;
- Real theta = 0.0348;
- Real sigma = 0.39;
- Real rho = -0.64;
-
- ext::shared_ptr hestonProcess(new
- HestonProcess(Handle(rTS), Handle(qTS),
- spot, v0, kappa, theta, sigma, rho));
-
- ext::shared_ptr engine(new
- AnalyticDiscreteGeometricAveragePriceAsianHestonEngine(hestonProcess));
-
- testDiscreteGeometricAveragePriceHeston(engine, tol);
-}
-
-
-void AsianOptionTest::testMCDiscreteGeometricAveragePriceHeston() {
+BOOST_AUTO_TEST_CASE(testMCDiscreteGeometricAveragePriceHeston, *precondition(if_speed(Fast))) {
BOOST_TEST_MESSAGE("Testing MC discrete geometric average-price Asians under Heston...");
@@ -657,179 +670,7 @@ void AsianOptionTest::testMCDiscreteGeometricAveragePriceHeston() {
testDiscreteGeometricAveragePriceHeston(engine, tol);
}
-
-void AsianOptionTest::testDiscreteGeometricAveragePriceHestonPastFixings() {
-
- BOOST_TEST_MESSAGE("Testing Analytic vs MC for seasoned discrete geometric Asians under Heston...");
-
- // 30-day options need wider tolerance due to uncertainty around what "weekly
- // fixing" dates mean over a 30-day month!
-
- int days[] = {30, 90, 180, 360, 720};
- Real strikes[] = {90, 100, 110};
-
- Real tol[3][5][2] = {{{
- 0.04, // strike=90, days=30, k=0
- 0.04, // strike=90, days=30, k=1
- },
- {
- 0.04, // strike=90, days=90, k=0
- 0.04, // strike=90, days=90, k=1
- },
- {
- 0.04, // strike=90, days=180, k=0
- 0.04, // strike=90, days=180, k=1
- },
- {
- 0.05, // strike=90, days=360, k=0
- 0.04, // strike=90, days=360, k=1
- },
- {
- 0.04, // strike=90, days=720, k=0
- 0.04, // strike=90, days=720, k=1
- }},
-
- {{
- 0.04, // strike=100, days=30, k=0
- 0.04, // strike=100, days=30, k=1
- },
- {
- 0.04, // strike=100, days=90, k=0
- 0.04, // strike=100, days=90, k=1
- },
- {
- 0.04, // strike=100, days=180, k=0
- 0.04, // strike=100, days=180, k=1
- },
- {
- 0.06, // strike=100, days=360, k=0
- 0.06, // strike=100, days=360, k=1
- },
- {
- 0.06, // strike=100, days=720, k=0
- 0.05, // strike=100, days=720, k=1
- }},
-
- {{
- 0.04, // strike=110, days=30, k=0
- 0.04, // strike=110, days=30, k=1
- },
- {
- 0.04, // strike=110, days=90, k=0
- 0.04, // strike=110, days=90, k=1
- },
- {
- 0.04, // strike=110, days=180, k=0
- 0.04, // strike=110, days=180, k=1
- },
- {
- 0.05, // strike=110, days=360, k=0
- 0.04, // strike=110, days=360, k=1
- },
- {
- 0.06, // strike=110, days=720, k=0
- 0.05, // strike=110, days=720, k=1
- }}};
-
- DayCounter dc = Actual365Fixed();
- Date today = Settings::instance().evaluationDate();
-
- Handle spot(ext::shared_ptr(new SimpleQuote(100)));
- ext::shared_ptr qRate(new SimpleQuote(0.0));
- ext::shared_ptr qTS = flatRate(today, qRate, dc);
- ext::shared_ptr rRate(new SimpleQuote(0.05));
- ext::shared_ptr rTS = flatRate(today, rRate, dc);
-
- Real v0 = 0.09;
- Real kappa = 1.15;
- Real theta = 0.0348;
- Real sigma = 0.39;
- Real rho = -0.64;
-
- ext::shared_ptr hestonProcess(new
- HestonProcess(Handle(rTS), Handle(qTS),
- spot, v0, kappa, theta, sigma, rho));
-
- ext::shared_ptr analyticEngine(new
- AnalyticDiscreteGeometricAveragePriceAsianHestonEngine(hestonProcess));
-
- ext::shared_ptr mcEngine =
- MakeMCDiscreteGeometricAPHestonEngine(hestonProcess)
- .withSamples(8191)
- .withSeed(43);
-
- Option::Type type(Option::Call);
- Average::Type averageType = Average::Geometric;
-
- for (Size strike_index = 0; strike_index < LENGTH(strikes); strike_index++) {
-
- for (Size day_index = 0; day_index < LENGTH(days); day_index++) {
-
- for (Size k=0; k<2; k++) {
-
- Size futureFixings = int(std::floor(days[day_index] / 30.0));
- std::vector fixingDates(futureFixings);
- Date expiryDate = today + days[day_index] * Days;
-
- for (int i=futureFixings-1; i>=0; i--) {
- fixingDates[i] = expiryDate - i * 30;
- }
-
- ext::shared_ptr europeanExercise(new EuropeanExercise(expiryDate));
- ext::shared_ptr payoff(new PlainVanillaPayoff(type, strikes[strike_index]));
-
- Real runningAccumulator = 1.0;
- Size pastFixingsCount = 0;
- if (k == 0) {
- runningAccumulator = 100.0;
- pastFixingsCount = 1;
- } else {
- runningAccumulator = 95.0 * 100.0 * 105.0;
- pastFixingsCount = 3;
- }
-
- DiscreteAveragingAsianOption option(averageType, runningAccumulator, pastFixingsCount,
- fixingDates, payoff, europeanExercise);
-
- option.setPricingEngine(analyticEngine);
- Real analyticPrice = option.NPV();
-
- option.setPricingEngine(mcEngine);
- Real mcPrice = option.NPV();
-
- auto tolerance = tol[strike_index][day_index][k];
-
- if (std::fabs(analyticPrice-mcPrice) > tolerance) {
- REPORT_FAILURE("value", averageType, runningAccumulator, pastFixingsCount,
- std::vector(), payoff, europeanExercise, spot->value(),
- qRate->value(), rRate->value(), today,
- std::sqrt(v0), analyticPrice, mcPrice, tolerance);
- }
- }
- }
- }
-}
-
-namespace {
-
- struct DiscreteAverageData {
- Option::Type type;
- Real underlying;
- Real strike;
- Rate dividendYield;
- Rate riskFreeRate;
- Time first;
- Time length;
- Size fixings;
- Volatility volatility;
- bool controlVariate;
- Real result;
- };
-
-}
-
-
-void AsianOptionTest::testMCDiscreteArithmeticAveragePrice() {
+BOOST_AUTO_TEST_CASE(testMCDiscreteArithmeticAveragePrice, *precondition(if_speed(Fast))) {
BOOST_TEST_MESSAGE(
"Testing Monte Carlo discrete arithmetic average-price Asians...");
@@ -990,8 +831,7 @@ void AsianOptionTest::testMCDiscreteArithmeticAveragePrice() {
}
}
-
-void AsianOptionTest::testMCDiscreteArithmeticAveragePriceHeston() {
+BOOST_AUTO_TEST_CASE(testMCDiscreteArithmeticAveragePriceHeston, *precondition(if_speed(Slow))) {
BOOST_TEST_MESSAGE(
"Testing Monte Carlo discrete arithmetic average-price Asians in Heston model...");
@@ -1183,8 +1023,7 @@ void AsianOptionTest::testMCDiscreteArithmeticAveragePriceHeston() {
}
-
-void AsianOptionTest::testMCDiscreteArithmeticAverageStrike() {
+BOOST_AUTO_TEST_CASE(testMCDiscreteArithmeticAverageStrike) {
BOOST_TEST_MESSAGE(
"Testing Monte Carlo discrete arithmetic average-strike Asians...");
@@ -1317,7 +1156,7 @@ void AsianOptionTest::testMCDiscreteArithmeticAverageStrike() {
}
}
-void AsianOptionTest::testAnalyticDiscreteGeometricAveragePriceGreeks() {
+BOOST_AUTO_TEST_CASE(testAnalyticDiscreteGeometricAveragePriceGreeks) {
BOOST_TEST_MESSAGE("Testing discrete-averaging geometric Asian greeks...");
@@ -1465,8 +1304,7 @@ void AsianOptionTest::testAnalyticDiscreteGeometricAveragePriceGreeks() {
}
}
-
-void AsianOptionTest::testPastFixings() {
+BOOST_AUTO_TEST_CASE(testPastFixings) {
BOOST_TEST_MESSAGE("Testing use of past fixings in Asian options...");
@@ -1634,7 +1472,7 @@ void AsianOptionTest::testPastFixings() {
}
-void AsianOptionTest::testPastFixingsModelDependency() {
+BOOST_AUTO_TEST_CASE(testPastFixingsModelDependency) {
BOOST_TEST_MESSAGE(
"Testing use of past fixings in Asian options where model dependency is flagged...");
@@ -1759,8 +1597,7 @@ void AsianOptionTest::testPastFixingsModelDependency() {
}
}
-
-void AsianOptionTest::testAllFixingsInThePast() {
+BOOST_AUTO_TEST_CASE(testAllFixingsInThePast) {
BOOST_TEST_MESSAGE(
"Testing Asian options with all fixing dates in the past...");
@@ -1893,49 +1730,214 @@ void AsianOptionTest::testAllFixingsInThePast() {
}
}
-namespace {
+BOOST_AUTO_TEST_CASE(testTurnbullWakemanAsianEngine) {
- struct ContinuousAverageData {
- Option::Type type;
- Real spot;
- Real currentAverage;
- Real strike;
- Rate dividendYield;
- Rate riskFreeRate;
- Volatility volatility;
- Natural length;
- Natural elapsed;
- Real result;
- };
+ BOOST_TEST_MESSAGE("Testing Turnbull-Wakeman engine for discrete-time arithmetic average-rate "
+ "Asians options with term structure support...");
+
+ // Data from Haug, "Option Pricing Formulas", Table 4-28, p.201
+ // Type, underlying, strike, b, rfRate, t1, expiry, fixings, base vol, slope, expected result
+ DiscreteAverageDataTermStructure cases[] = {
+ {Option::Call, 100, 80, 0, 0.05, 1.0 / 52, 0.5, 26, 0.2, "flat", 19.5152},
+ {Option::Call, 100, 80, 0, 0.05, 1.0 / 52, 0.5, 26, 0.2, "up", 19.5063},
+ {Option::Call, 100, 80, 0, 0.05, 1.0 / 52, 0.5, 26, 0.2, "down", 19.5885},
+ {Option::Put, 100, 80, 0, 0.05, 1.0 / 52, 0.5, 26, 0.2, "flat", 0.0090},
+ {Option::Put, 100, 80, 0, 0.05, 1.0 / 52, 0.5, 26, 0.2, "up", 0.0001},
+ {Option::Put, 100, 80, 0, 0.05, 1.0 / 52, 0.5, 26, 0.2, "down", 0.0823},
+
+ {Option::Call, 100, 90, 0, 0.05, 1.0 / 52, 0.5, 26, 0.2, "flat", 10.1437},
+ {Option::Call, 100, 90, 0, 0.05, 1.0 / 52, 0.5, 26, 0.2, "up", 9.8313},
+ {Option::Call, 100, 90, 0, 0.05, 1.0 / 52, 0.5, 26, 0.2, "down", 10.7062},
+ {Option::Put, 100, 90, 0, 0.05, 1.0 / 52, 0.5, 26, 0.2, "flat", 0.3906},
+ {Option::Put, 100, 90, 0, 0.05, 1.0 / 52, 0.5, 26, 0.2, "up", 0.0782},
+ {Option::Put, 100, 90, 0, 0.05, 1.0 / 52, 0.5, 26, 0.2, "down", 0.9531},
+
+ {Option::Call, 100, 100, 0, 0.05, 1.0 / 52, 0.5, 26, 0.2, "flat", 3.2700},
+ {Option::Call, 100, 100, 0, 0.05, 1.0 / 52, 0.5, 26, 0.2, "up", 2.2819},
+ {Option::Call, 100, 100, 0, 0.05, 1.0 / 52, 0.5, 26, 0.2, "down", 4.3370},
+ {Option::Put, 100, 100, 0, 0.05, 1.0 / 52, 0.5, 26, 0.2, "flat", 3.2700},
+ {Option::Put, 100, 100, 0, 0.05, 1.0 / 52, 0.5, 26, 0.2, "up", 2.2819},
+ {Option::Put, 100, 100, 0, 0.05, 1.0 / 52, 0.5, 26, 0.2, "down", 4.3370},
+
+ {Option::Call, 100, 110, 0, 0.05, 1.0 / 52, 0.5, 26, 0.2, "flat", 0.5515},
+ {Option::Call, 100, 110, 0, 0.05, 1.0 / 52, 0.5, 26, 0.2, "up", 0.1314},
+ {Option::Call, 100, 110, 0, 0.05, 1.0 / 52, 0.5, 26, 0.2, "down", 1.2429},
+ {Option::Put, 100, 110, 0, 0.05, 1.0 / 52, 0.5, 26, 0.2, "flat", 10.3046},
+ {Option::Put, 100, 110, 0, 0.05, 1.0 / 52, 0.5, 26, 0.2, "up", 9.8845},
+ {Option::Put, 100, 110, 0, 0.05, 1.0 / 52, 0.5, 26, 0.2, "down", 10.9960},
+
+ {Option::Call, 100, 120, 0, 0.05, 1.0 / 52, 0.5, 26, 0.2, "flat", 0.0479},
+ {Option::Call, 100, 120, 0, 0.05, 1.0 / 52, 0.5, 26, 0.2, "up", 0.0016},
+ {Option::Call, 100, 120, 0, 0.05, 1.0 / 52, 0.5, 26, 0.2, "down", 0.2547},
+ {Option::Put, 100, 120, 0, 0.05, 1.0 / 52, 0.5, 26, 0.2, "flat", 19.5541},
+ {Option::Put, 100, 120, 0, 0.05, 1.0 / 52, 0.5, 26, 0.2, "up", 19.5078},
+ {Option::Put, 100, 120, 0, 0.05, 1.0 / 52, 0.5, 26, 0.2, "down", 19.7609}};
+
+ DayCounter dc = Actual360();
+ Date today = Settings::instance().evaluationDate();
+
+ for (auto& l : cases) {
+ Time dt = (l.expiry - l.first) / (l.fixings - 1);
+ std::vector fixingDates(l.fixings);
+ fixingDates[0] = today + timeToDays(l.first, 360);
+
+ for (Size i = 1; i < l.fixings; i++) {
+ fixingDates[i] = today + timeToDays(i * dt + l.first, 360);
+ }
+
+ // Set up market data
+ ext::shared_ptr spot(new SimpleQuote(l.underlying));
+ ext::shared_ptr qTS = flatRate(today, l.b + l.riskFreeRate, dc);
+ ext::shared_ptr rTS = flatRate(today, l.riskFreeRate, dc);
+ ext::shared_ptr volTS;
+ Volatility volSlope = 0.005;
+ if (l.slope == "flat") {
+ volTS = flatVol(today, l.volatility, dc);
+ } else if (l.slope == "up") {
+ std::vector volatilities(l.fixings);
+ for (Size i = 0; i < l.fixings; ++i) {
+ // Loop to fill a vector of vols from 7.5 % to 20 %
+ volatilities[i] = l.volatility - (l.fixings - 1) * volSlope + i * volSlope;
+ }
+ volTS =
+ ext::make_shared(today, fixingDates, volatilities, dc, true);
+ } else if (l.slope == "down") {
+ std::vector volatilities(l.fixings);
+ for (Size i = 0; i < l.fixings; ++i) {
+ // Loop to fill a vector of vols from 32.5 % to 20 %
+ volatilities[i] = l.volatility + (l.fixings - 1) * volSlope - i * volSlope;
+ }
+ volTS =
+ ext::make_shared(today, fixingDates, volatilities, dc, false);
+ } else {
+ QL_FAIL("unexpected slope type in engine test case");
+ }
+
+ Average::Type averageType = Average::Arithmetic;
+
+ ext::shared_ptr payoff(new PlainVanillaPayoff(l.type, l.strike));
+
+ Date maturity = today + timeToDays(l.expiry, 360);
+
+ ext::shared_ptr exercise(new EuropeanExercise(maturity));
+
+ ext::shared_ptr stochProcess(new BlackScholesMertonProcess(
+ Handle(spot), Handle(qTS), Handle(rTS),
+ Handle(volTS)));
+
+ // Construct engine
+ ext::shared_ptr engine(
+ new TurnbullWakemanAsianEngine(stochProcess));
+
+ DiscreteAveragingAsianOption option(averageType, 0, 0, fixingDates, payoff, exercise);
+ option.setPricingEngine(engine);
+
+ Real calculated = option.NPV();
+ Real expected = l.result;
+ Real tolerance = 2.5e-3;
+ Real error = std::fabs(expected - calculated);
+ if (error > tolerance) {
+ BOOST_ERROR(
+ "Failed to reproduce expected NPV:"
+ << "\n type: " << l.type << "\n spot: " << l.underlying
+ << "\n strike: " << l.strike << "\n dividend yield: "
+ << l.b + l.riskFreeRate << "\n risk-free rate: " << l.riskFreeRate
+ << "\n volatility: " << l.volatility << "\n slope: " << l.slope
+ << "\n reference date: " << today << "\n expiry: " << l.expiry
+ << "\n expected value: " << expected << "\n calculated: " << calculated
+ << "\n error: " << error);
+ }
+
+ // Compare greeks to numerical greeks
+ Real dS = 0.001;
+ Real delta = option.delta();
+ Real gamma = option.gamma();
+
+ ext::shared_ptr spotUp(new SimpleQuote(l.underlying+dS));
+ ext::shared_ptr spotDown(new SimpleQuote(l.underlying-dS));
+
+ ext::shared_ptr stochProcessUp(new BlackScholesMertonProcess(
+ Handle(spotUp), Handle(qTS), Handle(rTS),
+ Handle(volTS)));
+
+ ext::shared_ptr stochProcessDown(new BlackScholesMertonProcess(
+ Handle(spotDown), Handle(qTS), Handle(rTS),
+ Handle(volTS)));
+
+ ext::shared_ptr engineUp(
+ new TurnbullWakemanAsianEngine(stochProcessUp));
+
+ ext::shared_ptr engineDown(
+ new TurnbullWakemanAsianEngine(stochProcessDown));
+
+ option.setPricingEngine(engineUp);
+ Real calculatedUp = option.NPV();
+
+ option.setPricingEngine(engineDown);
+ Real calculatedDown = option.NPV();
+ Real deltaBump = (calculatedUp - calculatedDown) / (2 * dS);
+ Real gammaBump = (calculatedUp + calculatedDown - 2*calculated) / (dS * dS);
+
+ tolerance = 1.0e-6;
+ Real deltaError = std::fabs(deltaBump - delta);
+ if (deltaError > tolerance) {
+ BOOST_ERROR(
+ "Analytical delta failed to match bump delta:"
+ << "\n type: " << l.type << "\n spot: " << l.underlying
+ << "\n strike: " << l.strike << "\n dividend yield: "
+ << l.b + l.riskFreeRate << "\n risk-free rate: " << l.riskFreeRate
+ << "\n volatility: " << l.volatility << "\n slope: " << l.slope
+ << "\n reference date: " << today << "\n expiry: " << l.expiry
+ << "\n analytic delta: " << delta << "\n bump delta: " << deltaBump
+ << "\n error: " << deltaError);
+ }
+
+ Real gammaError = std::fabs(gammaBump - gamma);
+ if (gammaError > tolerance) {
+ BOOST_ERROR(
+ "Analytical gamma failed to match bump gamma:"
+ << "\n type: " << l.type << "\n spot: " << l.underlying
+ << "\n strike: " << l.strike << "\n dividend yield: "
+ << l.b + l.riskFreeRate << "\n risk-free rate: " << l.riskFreeRate
+ << "\n volatility: " << l.volatility << "\n slope: " << l.slope
+ << "\n reference date: " << today << "\n expiry: " << l.expiry
+ << "\n analytic gamma: " << gamma << "\n bump gamma: " << gammaBump
+ << "\n error: " << gammaError);
+ }
+ }
}
-void AsianOptionTest::testLevyEngine() {
+BOOST_AUTO_TEST_SUITE_END()
+
+BOOST_AUTO_TEST_SUITE(AsianOptionExperimentalTest)
+
+BOOST_AUTO_TEST_CASE(testLevyEngine) {
BOOST_TEST_MESSAGE("Testing Levy engine for Asians options...");
// data from Haug, "Option Pricing Formulas", p.99-100
ContinuousAverageData cases[] = {
- { Option::Call, 6.80, 6.80, 6.90, 0.09, 0.07, 0.14, 180, 0, 0.0944 },
- { Option::Put, 6.80, 6.80, 6.90, 0.09, 0.07, 0.14, 180, 0, 0.2237 },
- { Option::Call, 100.0, 100.0, 95.0, 0.05, 0.1, 0.15, 270, 0, 7.0544 },
- { Option::Call, 100.0, 100.0, 95.0, 0.05, 0.1, 0.15, 270, 90, 5.6731 },
- { Option::Call, 100.0, 100.0, 95.0, 0.05, 0.1, 0.15, 270, 180, 5.0806 },
- { Option::Call, 100.0, 100.0, 95.0, 0.05, 0.1, 0.35, 270, 0, 10.1213 },
- { Option::Call, 100.0, 100.0, 95.0, 0.05, 0.1, 0.35, 270, 90, 6.9705 },
- { Option::Call, 100.0, 100.0, 95.0, 0.05, 0.1, 0.35, 270, 180, 5.1411 },
- { Option::Call, 100.0, 100.0, 100.0, 0.05, 0.1, 0.15, 270, 0, 3.7845 },
- { Option::Call, 100.0, 100.0, 100.0, 0.05, 0.1, 0.15, 270, 90, 1.9964 },
- { Option::Call, 100.0, 100.0, 100.0, 0.05, 0.1, 0.15, 270, 180, 0.6722 },
- { Option::Call, 100.0, 100.0, 100.0, 0.05, 0.1, 0.35, 270, 0, 7.5038 },
- { Option::Call, 100.0, 100.0, 100.0, 0.05, 0.1, 0.35, 270, 90, 4.0687 },
- { Option::Call, 100.0, 100.0, 100.0, 0.05, 0.1, 0.35, 270, 180, 1.4222 },
- { Option::Call, 100.0, 100.0, 105.0, 0.05, 0.1, 0.15, 270, 0, 1.6729 },
- { Option::Call, 100.0, 100.0, 105.0, 0.05, 0.1, 0.15, 270, 90, 0.3565 },
- { Option::Call, 100.0, 100.0, 105.0, 0.05, 0.1, 0.15, 270, 180, 0.0004 },
- { Option::Call, 100.0, 100.0, 105.0, 0.05, 0.1, 0.35, 270, 0, 5.4071 },
- { Option::Call, 100.0, 100.0, 105.0, 0.05, 0.1, 0.35, 270, 90, 2.1359 },
- { Option::Call, 100.0, 100.0, 105.0, 0.05, 0.1, 0.35, 270, 180, 0.1552 }
+ { Option::Call, 6.80, 6.80, 6.90, 0.09, 0.07, 0.14, 180, 0, 0.0944 },
+ { Option::Put, 6.80, 6.80, 6.90, 0.09, 0.07, 0.14, 180, 0, 0.2237 },
+ { Option::Call, 100.0, 100.0, 95.0, 0.05, 0.1, 0.15, 270, 0, 7.0544 },
+ { Option::Call, 100.0, 100.0, 95.0, 0.05, 0.1, 0.15, 270, 90, 5.6731 },
+ { Option::Call, 100.0, 100.0, 95.0, 0.05, 0.1, 0.15, 270, 180, 5.0806 },
+ { Option::Call, 100.0, 100.0, 95.0, 0.05, 0.1, 0.35, 270, 0, 10.1213 },
+ { Option::Call, 100.0, 100.0, 95.0, 0.05, 0.1, 0.35, 270, 90, 6.9705 },
+ { Option::Call, 100.0, 100.0, 95.0, 0.05, 0.1, 0.35, 270, 180, 5.1411 },
+ { Option::Call, 100.0, 100.0, 100.0, 0.05, 0.1, 0.15, 270, 0, 3.7845 },
+ { Option::Call, 100.0, 100.0, 100.0, 0.05, 0.1, 0.15, 270, 90, 1.9964 },
+ { Option::Call, 100.0, 100.0, 100.0, 0.05, 0.1, 0.15, 270, 180, 0.6722 },
+ { Option::Call, 100.0, 100.0, 100.0, 0.05, 0.1, 0.35, 270, 0, 7.5038 },
+ { Option::Call, 100.0, 100.0, 100.0, 0.05, 0.1, 0.35, 270, 90, 4.0687 },
+ { Option::Call, 100.0, 100.0, 100.0, 0.05, 0.1, 0.35, 270, 180, 1.4222 },
+ { Option::Call, 100.0, 100.0, 105.0, 0.05, 0.1, 0.15, 270, 0, 1.6729 },
+ { Option::Call, 100.0, 100.0, 105.0, 0.05, 0.1, 0.15, 270, 90, 0.3565 },
+ { Option::Call, 100.0, 100.0, 105.0, 0.05, 0.1, 0.15, 270, 180, 0.0004 },
+ { Option::Call, 100.0, 100.0, 105.0, 0.05, 0.1, 0.35, 270, 0, 5.4071 },
+ { Option::Call, 100.0, 100.0, 105.0, 0.05, 0.1, 0.35, 270, 90, 2.1359 },
+ { Option::Call, 100.0, 100.0, 105.0, 0.05, 0.1, 0.35, 270, 180, 0.1552 }
};
DayCounter dc = Actual360();
@@ -1959,14 +1961,14 @@ void AsianOptionTest::testLevyEngine() {
ext::shared_ptr exercise(new EuropeanExercise(maturity));
ext::shared_ptr stochProcess(new
- BlackScholesMertonProcess(Handle(spot),
- Handle(qTS),
- Handle(rTS),
- Handle(volTS)));
+ BlackScholesMertonProcess(Handle(spot),
+ Handle(qTS),
+ Handle(rTS),
+ Handle(volTS)));
ext::shared_ptr engine(
new ContinuousArithmeticAsianLevyEngine(
- stochProcess, Handle(average), startDate));
+ stochProcess, Handle(average), startDate));
ContinuousAveragingAsianOption option(averageType,
payoff, exercise);
@@ -1990,21 +1992,7 @@ void AsianOptionTest::testLevyEngine() {
}
}
-namespace {
-
- struct VecerData {
- Real spot;
- Rate riskFreeRate;
- Volatility volatility;
- Real strike;
- Natural length;
- Real result;
- Real tolerance;
- };
-
-}
-
-void AsianOptionTest::testVecerEngine() {
+BOOST_AUTO_TEST_CASE(testVecerEngine) {
BOOST_TEST_MESSAGE("Testing Vecer engine for Asian options...");
VecerData cases[] = {
@@ -2056,7 +2044,7 @@ void AsianOptionTest::testVecerEngine() {
}
}
-void AsianOptionTest::testAnalyticContinuousGeometricAveragePriceHeston() {
+BOOST_AUTO_TEST_CASE(testAnalyticContinuousGeometricAveragePriceHeston) {
BOOST_TEST_MESSAGE("Testing analytic continuous geometric Asians under Heston...");
@@ -2070,11 +2058,11 @@ void AsianOptionTest::testAnalyticContinuousGeometricAveragePriceHeston() {
// Prices from Table 1 (params obey Feller condition)
Real prices[] = {10.6571, 6.5871, 3.4478, 1.4552, 0.4724, 16.5030, 13.7625, 11.3374, 9.2245,
- 7.4122, 20.5102, 18.3060, 16.2895, 14.4531, 12.7882};
+ 7.4122, 20.5102, 18.3060, 16.2895, 14.4531, 12.7882};
// Prices from Table 4 (params do not obey Feller condition)
Real prices_2[] = {10.6425, 6.4362, 3.1578, 1.1936, 0.3609, 14.9955, 11.6707, 8.7767, 6.3818,
- 4.5118, 18.1219, 15.2009, 12.5707, 10.2539, 8.2611};
+ 4.5118, 18.1219, 15.2009, 12.5707, 10.2539, 8.2611};
// 0.2 and 3.0 match to 1e-4. Unfortunatly 1.5 corresponds to 547.5 days, 547 and 548
// bound the expected answer but are both out by ~5e-3
@@ -2098,11 +2086,11 @@ void AsianOptionTest::testAnalyticContinuousGeometricAveragePriceHeston() {
Real rho = -0.64;
ext::shared_ptr hestonProcess(new
- HestonProcess(Handle(rTS), Handle(qTS),
- spot, v0, kappa, theta, sigma, rho));
+ HestonProcess(Handle(rTS), Handle(qTS),
+ spot, v0, kappa, theta, sigma, rho));
ext::shared_ptr engine(new
- AnalyticContinuousGeometricAveragePriceAsianHestonEngine(hestonProcess));
+ AnalyticContinuousGeometricAveragePriceAsianHestonEngine(hestonProcess));
for (Size i=0; i tolerance) {
REPORT_FAILURE("value", averageType, 1.0, 0.0,
- std::vector(), payoff, europeanExercise, spot->value(),
- qRate->value(), rRate->value(), today,
- std::sqrt(v0), expected, calculated, tolerance);
+ std::vector(), payoff, europeanExercise, spot->value(),
+ qRate->value(), rRate->value(), today,
+ std::sqrt(v0), expected, calculated, tolerance);
}
}
@@ -2134,11 +2122,11 @@ void AsianOptionTest::testAnalyticContinuousGeometricAveragePriceHeston() {
Real rho_2 = -0.3;
ext::shared_ptr hestonProcess_2(new
- HestonProcess(Handle(rTS), Handle(qTS),
- spot, v0_2, kappa_2, theta_2, sigma_2, rho_2));
+ HestonProcess(Handle(rTS), Handle(qTS),
+ spot, v0_2, kappa_2, theta_2, sigma_2, rho_2));
ext::shared_ptr engine_2(new
- AnalyticContinuousGeometricAveragePriceAsianHestonEngine(hestonProcess_2));
+ AnalyticContinuousGeometricAveragePriceAsianHestonEngine(hestonProcess_2));
for (Size i=0; i tolerance) {
REPORT_FAILURE("value", averageType, 1.0, 0.0,
- std::vector(), payoff, europeanExercise, spot->value(),
- qRate->value(), rRate->value(), today,
- std::sqrt(v0), expected, calculated, tolerance);
+ std::vector(), payoff, europeanExercise, spot->value(),
+ qRate->value(), rRate->value(), today,
+ std::sqrt(v0), expected, calculated, tolerance);
}
}
@@ -2170,19 +2158,19 @@ void AsianOptionTest::testAnalyticContinuousGeometricAveragePriceHeston() {
// 73, 348 and 1095 are 0.2, 1.5 and 3.0 years respectively in Actual365Fixed
Time days_3[] = {30, 91, 182, 365, 730, 1095, 30, 91, 182, 365, 730, 1095, 30,
- 91, 182, 365, 730, 1095};
+ 91, 182, 365, 730, 1095};
Real strikes_3[] = {90, 90, 90, 90, 90, 90, 100, 100, 100, 100, 100, 100, 110,
110, 110, 110, 110, 110};
// 30-day options need wider tolerance due to the day-bracket issue discussed above
Real tol_3[] = {2.0e-2, 1.0e-2, 1.0e-2, 1.0e-2, 1.0e-2, 1.0e-2, 2.0e-2, 1.0e-2,
- 1.0e-2, 1.0e-2, 1.0e-2, 1.0e-2, 2.0e-2, 1.0e-2, 1.0e-2, 1.0e-2,
- 1.0e-2, 1.0e-2};
+ 1.0e-2, 1.0e-2, 1.0e-2, 1.0e-2, 2.0e-2, 1.0e-2, 1.0e-2, 1.0e-2,
+ 1.0e-2, 1.0e-2};
// Prices from Tables 1, 2 and 3
Real prices_3[] = {10.1513, 10.8175, 11.8664, 13.5931, 16.0988, 17.9475, 2.0472,
- 3.5735, 5.0588, 7.1132, 9.9139, 11.9959, 0.0350, 0.4869,
- 1.3376, 2.8569, 5.2804, 7.2682};
+ 3.5735, 5.0588, 7.1132, 9.9139, 11.9959, 0.0350, 0.4869,
+ 1.3376, 2.8569, 5.2804, 7.2682};
// Note that although these parameters look similar to the first set above, theta
// is a factor of 10 smaller. I guess there is a mis-transcription somewhere!
@@ -2193,11 +2181,11 @@ void AsianOptionTest::testAnalyticContinuousGeometricAveragePriceHeston() {
Real rho_3 = -0.64;
ext::shared_ptr hestonProcess_3(new
- HestonProcess(Handle(rTS), Handle(qTS),
- spot, v0_3, kappa_3, theta_3, sigma_3, rho_3));
+ HestonProcess(Handle(rTS), Handle(qTS),
+ spot, v0_3, kappa_3, theta_3, sigma_3, rho_3));
ext::shared_ptr engine_3(new
- AnalyticContinuousGeometricAveragePriceAsianHestonEngine(hestonProcess_3));
+ AnalyticContinuousGeometricAveragePriceAsianHestonEngine(hestonProcess_3));
for (Size i=0; i tolerance) {
REPORT_FAILURE("value", averageType, 1.0, 0.0,
- std::vector(), payoff, europeanExercise, spot->value(),
- qRate->value(), rRate->value(), today,
- std::sqrt(v0), expected, calculated, tolerance);
+ std::vector(), payoff, europeanExercise, spot->value(),
+ qRate->value(), rRate->value(), today,
+ std::sqrt(v0), expected, calculated, tolerance);
}
}
}
-namespace {
- struct DiscreteAverageDataTermStructure {
- Option::Type type;
- Real underlying;
- Real strike;
- Rate b;
- Rate riskFreeRate;
- Time first; // t1
- Time expiry;
- Size fixings;
- Volatility volatility;
- std::string slope;
- Real result;
- };
-}
+BOOST_AUTO_TEST_CASE(testAnalyticDiscreteGeometricAveragePriceHeston) {
-void AsianOptionTest::testTurnbullWakemanAsianEngine() {
+ BOOST_TEST_MESSAGE("Testing analytic discrete geometric average-price Asians under Heston...");
- BOOST_TEST_MESSAGE("Testing Turnbull-Wakeman engine for discrete-time arithmetic average-rate "
- "Asians options with term structure support...");
+ // 30-day options need wider tolerance due to uncertainty around what "weekly
+ // fixing" dates mean over a 30-day month!
+ Real tol[] = {3.0e-2, 2.0e-2, 2.0e-2, 2.0e-2, 3.0e-2, 4.0e-2, 8.0e-2, 1.0e-2,
+ 2.0e-2, 3.0e-2, 3.0e-2, 4.0e-2, 2.0e-2, 1.0e-2, 1.0e-2, 2.0e-2,
+ 3.0e-2, 4.0e-2};
- // Data from Haug, "Option Pricing Formulas", Table 4-28, p.201
- // Type, underlying, strike, b, rfRate, t1, expiry, fixings, base vol, slope, expected result
- DiscreteAverageDataTermStructure cases[] = {
- {Option::Call, 100, 80, 0, 0.05, 1.0 / 52, 0.5, 26, 0.2, "flat", 19.5152},
- {Option::Call, 100, 80, 0, 0.05, 1.0 / 52, 0.5, 26, 0.2, "up", 19.5063},
- {Option::Call, 100, 80, 0, 0.05, 1.0 / 52, 0.5, 26, 0.2, "down", 19.5885},
- {Option::Put, 100, 80, 0, 0.05, 1.0 / 52, 0.5, 26, 0.2, "flat", 0.0090},
- {Option::Put, 100, 80, 0, 0.05, 1.0 / 52, 0.5, 26, 0.2, "up", 0.0001},
- {Option::Put, 100, 80, 0, 0.05, 1.0 / 52, 0.5, 26, 0.2, "down", 0.0823},
-
- {Option::Call, 100, 90, 0, 0.05, 1.0 / 52, 0.5, 26, 0.2, "flat", 10.1437},
- {Option::Call, 100, 90, 0, 0.05, 1.0 / 52, 0.5, 26, 0.2, "up", 9.8313},
- {Option::Call, 100, 90, 0, 0.05, 1.0 / 52, 0.5, 26, 0.2, "down", 10.7062},
- {Option::Put, 100, 90, 0, 0.05, 1.0 / 52, 0.5, 26, 0.2, "flat", 0.3906},
- {Option::Put, 100, 90, 0, 0.05, 1.0 / 52, 0.5, 26, 0.2, "up", 0.0782},
- {Option::Put, 100, 90, 0, 0.05, 1.0 / 52, 0.5, 26, 0.2, "down", 0.9531},
+ DayCounter dc = Actual365Fixed();
+ Date today = Settings::instance().evaluationDate();
- {Option::Call, 100, 100, 0, 0.05, 1.0 / 52, 0.5, 26, 0.2, "flat", 3.2700},
- {Option::Call, 100, 100, 0, 0.05, 1.0 / 52, 0.5, 26, 0.2, "up", 2.2819},
- {Option::Call, 100, 100, 0, 0.05, 1.0 / 52, 0.5, 26, 0.2, "down", 4.3370},
- {Option::Put, 100, 100, 0, 0.05, 1.0 / 52, 0.5, 26, 0.2, "flat", 3.2700},
- {Option::Put, 100, 100, 0, 0.05, 1.0 / 52, 0.5, 26, 0.2, "up", 2.2819},
- {Option::Put, 100, 100, 0, 0.05, 1.0 / 52, 0.5, 26, 0.2, "down", 4.3370},
+ Handle spot(ext::shared_ptr(new SimpleQuote(100)));
+ ext::shared_ptr qRate(new SimpleQuote(0.0));
+ ext::shared_ptr qTS = flatRate(today, qRate, dc);
+ ext::shared_ptr rRate(new SimpleQuote(0.05));
+ ext::shared_ptr rTS = flatRate(today, rRate, dc);
- {Option::Call, 100, 110, 0, 0.05, 1.0 / 52, 0.5, 26, 0.2, "flat", 0.5515},
- {Option::Call, 100, 110, 0, 0.05, 1.0 / 52, 0.5, 26, 0.2, "up", 0.1314},
- {Option::Call, 100, 110, 0, 0.05, 1.0 / 52, 0.5, 26, 0.2, "down", 1.2429},
- {Option::Put, 100, 110, 0, 0.05, 1.0 / 52, 0.5, 26, 0.2, "flat", 10.3046},
- {Option::Put, 100, 110, 0, 0.05, 1.0 / 52, 0.5, 26, 0.2, "up", 9.8845},
- {Option::Put, 100, 110, 0, 0.05, 1.0 / 52, 0.5, 26, 0.2, "down", 10.9960},
+ Real v0 = 0.09;
+ Real kappa = 1.15;
+ Real theta = 0.0348;
+ Real sigma = 0.39;
+ Real rho = -0.64;
- {Option::Call, 100, 120, 0, 0.05, 1.0 / 52, 0.5, 26, 0.2, "flat", 0.0479},
- {Option::Call, 100, 120, 0, 0.05, 1.0 / 52, 0.5, 26, 0.2, "up", 0.0016},
- {Option::Call, 100, 120, 0, 0.05, 1.0 / 52, 0.5, 26, 0.2, "down", 0.2547},
- {Option::Put, 100, 120, 0, 0.05, 1.0 / 52, 0.5, 26, 0.2, "flat", 19.5541},
- {Option::Put, 100, 120, 0, 0.05, 1.0 / 52, 0.5, 26, 0.2, "up", 19.5078},
- {Option::Put, 100, 120, 0, 0.05, 1.0 / 52, 0.5, 26, 0.2, "down", 19.7609}};
+ ext::shared_ptr hestonProcess(new
+ HestonProcess(Handle(rTS), Handle(qTS),
+ spot, v0, kappa, theta, sigma, rho));
- DayCounter dc = Actual360();
- Date today = Settings::instance().evaluationDate();
+ ext::shared_ptr engine(new
+ AnalyticDiscreteGeometricAveragePriceAsianHestonEngine(hestonProcess));
- for (auto& l : cases) {
- Time dt = (l.expiry - l.first) / (l.fixings - 1);
- std::vector fixingDates(l.fixings);
- fixingDates[0] = today + timeToDays(l.first, 360);
+ AsianOptionTest::testDiscreteGeometricAveragePriceHeston(engine, tol);
+}
- for (Size i = 1; i < l.fixings; i++) {
- fixingDates[i] = today + timeToDays(i * dt + l.first, 360);
- }
+BOOST_AUTO_TEST_CASE(testDiscreteGeometricAveragePriceHestonPastFixings) {
- // Set up market data
- ext::shared_ptr spot(new SimpleQuote(l.underlying));
- ext::shared_ptr qTS = flatRate(today, l.b + l.riskFreeRate, dc);
- ext::shared_ptr rTS = flatRate(today, l.riskFreeRate, dc);
- ext::shared_ptr volTS;
- Volatility volSlope = 0.005;
- if (l.slope == "flat") {
- volTS = flatVol(today, l.volatility, dc);
- } else if (l.slope == "up") {
- std::vector volatilities(l.fixings);
- for (Size i = 0; i < l.fixings; ++i) {
- // Loop to fill a vector of vols from 7.5 % to 20 %
- volatilities[i] = l.volatility - (l.fixings - 1) * volSlope + i * volSlope;
- }
- volTS =
- ext::make_shared(today, fixingDates, volatilities, dc, true);
- } else if (l.slope == "down") {
- std::vector volatilities(l.fixings);
- for (Size i = 0; i < l.fixings; ++i) {
- // Loop to fill a vector of vols from 32.5 % to 20 %
- volatilities[i] = l.volatility + (l.fixings - 1) * volSlope - i * volSlope;
- }
- volTS =
- ext::make_shared(today, fixingDates, volatilities, dc, false);
- } else {
- QL_FAIL("unexpected slope type in engine test case");
- }
+ BOOST_TEST_MESSAGE("Testing Analytic vs MC for seasoned discrete geometric Asians under Heston...");
- Average::Type averageType = Average::Arithmetic;
+ // 30-day options need wider tolerance due to uncertainty around what "weekly
+ // fixing" dates mean over a 30-day month!
- ext::shared_ptr payoff(new PlainVanillaPayoff(l.type, l.strike));
+ int days[] = {30, 90, 180, 360, 720};
+ Real strikes[] = {90, 100, 110};
- Date maturity = today + timeToDays(l.expiry, 360);
+ Real tol[3][5][2] = {{{
+ 0.04, // strike=90, days=30, k=0
+ 0.04, // strike=90, days=30, k=1
+ },
+ {
+ 0.04, // strike=90, days=90, k=0
+ 0.04, // strike=90, days=90, k=1
+ },
+ {
+ 0.04, // strike=90, days=180, k=0
+ 0.04, // strike=90, days=180, k=1
+ },
+ {
+ 0.05, // strike=90, days=360, k=0
+ 0.04, // strike=90, days=360, k=1
+ },
+ {
+ 0.04, // strike=90, days=720, k=0
+ 0.04, // strike=90, days=720, k=1
+ }},
- ext::shared_ptr exercise(new EuropeanExercise(maturity));
+ {{
+ 0.04, // strike=100, days=30, k=0
+ 0.04, // strike=100, days=30, k=1
+ },
+ {
+ 0.04, // strike=100, days=90, k=0
+ 0.04, // strike=100, days=90, k=1
+ },
+ {
+ 0.04, // strike=100, days=180, k=0
+ 0.04, // strike=100, days=180, k=1
+ },
+ {
+ 0.06, // strike=100, days=360, k=0
+ 0.06, // strike=100, days=360, k=1
+ },
+ {
+ 0.06, // strike=100, days=720, k=0
+ 0.05, // strike=100, days=720, k=1
+ }},
- ext::shared_ptr stochProcess(new BlackScholesMertonProcess(
- Handle(spot), Handle(qTS), Handle(rTS),
- Handle(volTS)));
+ {{
+ 0.04, // strike=110, days=30, k=0
+ 0.04, // strike=110, days=30, k=1
+ },
+ {
+ 0.04, // strike=110, days=90, k=0
+ 0.04, // strike=110, days=90, k=1
+ },
+ {
+ 0.04, // strike=110, days=180, k=0
+ 0.04, // strike=110, days=180, k=1
+ },
+ {
+ 0.05, // strike=110, days=360, k=0
+ 0.04, // strike=110, days=360, k=1
+ },
+ {
+ 0.06, // strike=110, days=720, k=0
+ 0.05, // strike=110, days=720, k=1
+ }}};
- // Construct engine
- ext::shared_ptr engine(
- new TurnbullWakemanAsianEngine(stochProcess));
+ DayCounter dc = Actual365Fixed();
+ Date today = Settings::instance().evaluationDate();
- DiscreteAveragingAsianOption option(averageType, 0, 0, fixingDates, payoff, exercise);
- option.setPricingEngine(engine);
+ Handle spot(ext::shared_ptr(new SimpleQuote(100)));
+ ext::shared_ptr qRate(new SimpleQuote(0.0));
+ ext::shared_ptr qTS = flatRate(today, qRate, dc);
+ ext::shared_ptr