From effc8b7a08a05045820c0edfacec0b97cf886727 Mon Sep 17 00:00:00 2001
From: anthonymakarewicz <138609270+anthonymakarewicz@users.noreply.github.com>
Date: Sat, 10 Aug 2024 13:42:53 +0200
Subject: [PATCH] added MC and QMC
---
.github/workflows/pr_ci.yml | 4 +-
.github/workflows/push_ci.yml | 2 +-
.idea/Option_pricer.iml | 8 +-
.idea/misc.xml | 3 +
CMakeLists.txt | 28 +-
examples/CMakeLists.txt | 15 +-
examples/generate_sobol.cpp | 81 +-
.../.ipynb_checkpoints/sobol-checkpoint.ipynb | 446 +
examples/notebooks/sobol.ipynb | 446 +
examples/output/sequences_1.csv | 1001 +
examples/output/sequences_2.csv | 2001 +
examples/output/sequences_50.csv | 50001 ++++++++++++++++
examples/sobol_sequence_5.csv | 6 -
ideas/factories/templated_factory.h | 53 +
ideas/monte_carlo/mc_inherit_marketdata.h | 58 +
include/market_data/stock_data.h | 4 +
include/option/base_option.h | 1 +
include/option/parameter_object.h | 5 +-
.../asian/arithmetic_asian_option.h | 19 -
.../path_dependent/asian/base_asian_option.h | 17 -
.../asian/factory_arithmetic_asian_option.h | 18 -
.../asian/factory_geometric_asian_option.h | 18 -
.../asian/geometric_asian_option.h | 20 -
include/option/path_dependent/asian_option.h | 43 +
.../barrier/base_barrier_option.h | 26 -
.../barrier/base_single_barrier_option.h | 21 -
.../path_dependent/barrier/double_barrier.h | 24 -
.../barrier/down_single_barrier_option.h | 21 -
.../factory_up_single_barrier_option.h | 20 -
.../path_dependent/barrier/knock_behavior.h | 24 -
.../barrier/up_single_barrier_option.h | 23 -
.../option/path_dependent/barrier_option.h | 69 +
.../path_dependent/factory_asian_option.h | 31 +
.../path_dependent/factory_barrier_option.h | 31 +
include/solver/base_solver.h | 4 +-
.../monte_carlo/gbm_stock_price_model.h | 32 +-
include/solver/monte_carlo/generator.h | 218 +
include/solver/monte_carlo/mc_base_strategy.h | 249 +-
include/solver/monte_carlo/mc_solver.h | 22 +-
.../solver/monte_carlo/stock_price_model.h | 5 +-
main.cpp | 127 +-
src/option/base_option.cpp | 4 +
.../asian/arithmetic_asian_option.cpp | 15 -
.../asian/base_asian_option.cpp | 9 -
.../asian/factory_arithmetic_asian_option.cpp | 26 -
.../asian/factory_geometric_asian_option.cpp | 26 -
.../asian/geometric_asian_option.cpp | 15 -
src/option/path_dependent/asian_option.cpp | 35 +
.../barrier/base_barrier_option.cpp | 21 -
.../barrier/base_single_barrier_option.cpp | 12 -
.../path_dependent/barrier/double_barrier.cpp | 29 -
.../barrier/down_single_barrier_option.cpp | 19 -
.../factory_up_single_barrier_option.cpp | 32 -
.../path_dependent/barrier/knock_behavior.cpp | 17 -
.../barrier/up_single_barrier_option.cpp | 19 -
src/option/path_dependent/barrier_option.cpp | 14 +
.../path_dependent/factory_asian_option.cpp | 47 +
.../path_dependent/factory_barrier_option.cpp | 54 +
.../single_strike/factory_payoff_digital.cpp | 2 +-
src/solver/base_solver.cpp | 1 -
src/solver/monte_carlo/stock_price_model.cpp | 6 +-
61 files changed, 55040 insertions(+), 608 deletions(-)
create mode 100644 examples/notebooks/.ipynb_checkpoints/sobol-checkpoint.ipynb
create mode 100644 examples/notebooks/sobol.ipynb
create mode 100644 examples/output/sequences_1.csv
create mode 100644 examples/output/sequences_2.csv
create mode 100644 examples/output/sequences_50.csv
delete mode 100644 examples/sobol_sequence_5.csv
create mode 100644 ideas/factories/templated_factory.h
create mode 100644 ideas/monte_carlo/mc_inherit_marketdata.h
delete mode 100644 include/option/path_dependent/asian/arithmetic_asian_option.h
delete mode 100644 include/option/path_dependent/asian/base_asian_option.h
delete mode 100644 include/option/path_dependent/asian/factory_arithmetic_asian_option.h
delete mode 100644 include/option/path_dependent/asian/factory_geometric_asian_option.h
delete mode 100644 include/option/path_dependent/asian/geometric_asian_option.h
create mode 100644 include/option/path_dependent/asian_option.h
delete mode 100644 include/option/path_dependent/barrier/base_barrier_option.h
delete mode 100644 include/option/path_dependent/barrier/base_single_barrier_option.h
delete mode 100644 include/option/path_dependent/barrier/double_barrier.h
delete mode 100644 include/option/path_dependent/barrier/down_single_barrier_option.h
delete mode 100644 include/option/path_dependent/barrier/factory_up_single_barrier_option.h
delete mode 100644 include/option/path_dependent/barrier/knock_behavior.h
delete mode 100644 include/option/path_dependent/barrier/up_single_barrier_option.h
create mode 100644 include/option/path_dependent/barrier_option.h
create mode 100644 include/option/path_dependent/factory_asian_option.h
create mode 100644 include/option/path_dependent/factory_barrier_option.h
create mode 100644 include/solver/monte_carlo/generator.h
delete mode 100644 src/option/path_dependent/asian/arithmetic_asian_option.cpp
delete mode 100644 src/option/path_dependent/asian/base_asian_option.cpp
delete mode 100644 src/option/path_dependent/asian/factory_arithmetic_asian_option.cpp
delete mode 100644 src/option/path_dependent/asian/factory_geometric_asian_option.cpp
delete mode 100644 src/option/path_dependent/asian/geometric_asian_option.cpp
create mode 100644 src/option/path_dependent/asian_option.cpp
delete mode 100644 src/option/path_dependent/barrier/base_barrier_option.cpp
delete mode 100644 src/option/path_dependent/barrier/base_single_barrier_option.cpp
delete mode 100644 src/option/path_dependent/barrier/double_barrier.cpp
delete mode 100644 src/option/path_dependent/barrier/down_single_barrier_option.cpp
delete mode 100644 src/option/path_dependent/barrier/factory_up_single_barrier_option.cpp
delete mode 100644 src/option/path_dependent/barrier/knock_behavior.cpp
delete mode 100644 src/option/path_dependent/barrier/up_single_barrier_option.cpp
create mode 100644 src/option/path_dependent/barrier_option.cpp
create mode 100644 src/option/path_dependent/factory_asian_option.cpp
create mode 100644 src/option/path_dependent/factory_barrier_option.cpp
diff --git a/.github/workflows/pr_ci.yml b/.github/workflows/pr_ci.yml
index 7e9d3a9..f5476a0 100644
--- a/.github/workflows/pr_ci.yml
+++ b/.github/workflows/pr_ci.yml
@@ -32,7 +32,7 @@ jobs:
cmake-version: '3.26.3'
- name: Install dependencies
- run: sudo apt-get install -y libgtest-dev libgmock-dev clang-tidy lcov #clang-format
+ run: sudo apt-get install -y libgtest-dev libgmock-dev libboost-all-dev
- name: Configure CMake
run: |
@@ -40,7 +40,7 @@ jobs:
- name: Build Main Executable and Test Executable
run: |
- cmake --build build
+ cmake --build build --target Unit_tests Integration_tests
# - name: Analyze code with clang-tidy
# run: |
diff --git a/.github/workflows/push_ci.yml b/.github/workflows/push_ci.yml
index 30adb40..266ba98 100644
--- a/.github/workflows/push_ci.yml
+++ b/.github/workflows/push_ci.yml
@@ -20,7 +20,7 @@ jobs:
cmake-version: '3.26.3'
- name: Install dependencies
- run: sudo apt-get install -y libgtest-dev libgmock-dev libboost-all-dev #clang-tidy lcov #clang-format
+ run: sudo apt-get install -y libgtest-dev libgmock-dev libboost-all-dev
- name: Configure CMake
run: |
diff --git a/.idea/Option_pricer.iml b/.idea/Option_pricer.iml
index f08604b..3f0f123 100644
--- a/.idea/Option_pricer.iml
+++ b/.idea/Option_pricer.iml
@@ -1,2 +1,8 @@
-
\ No newline at end of file
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/.idea/misc.xml b/.idea/misc.xml
index 0b76fe5..379e1db 100644
--- a/.idea/misc.xml
+++ b/.idea/misc.xml
@@ -1,5 +1,8 @@
+
+
+
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 43cab47..8796708 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -19,6 +19,8 @@ find_package(Boost REQUIRED COMPONENTS random)
# Check if random has been found before compiling src
if (Boost_FOUND)
message(STATUS "Boost found: ${Boost_VERSION}")
+ # Ensure Boost include directories are added
+ include_directories(${Boost_INCLUDE_DIRS})
else()
message(FATAL_ERROR "Boost not found!")
endif()
@@ -37,7 +39,6 @@ add_library(marketdata SHARED
src/market_data/market_data.cpp
src/market_data/market_data_observer.cpp
src/market_data/stock_data.cpp
- include/solver/base_solver.h
)
# Create dynamic library for payoff
@@ -69,24 +70,16 @@ add_library(option SHARED
src/option/single_path/double_digital_option.cpp
src/option/path_dependent/base_path_dependent_option.cpp
src/option/path_dependent/american_option.cpp
- src/option/path_dependent/asian/base_asian_option.cpp
- src/option/path_dependent/asian/arithmetic_asian_option.cpp
- src/option/path_dependent/asian/geometric_asian_option.cpp
- src/option/path_dependent/barrier/base_barrier_option.cpp
- src/option/path_dependent/barrier/knock_behavior.cpp
- src/option/path_dependent/barrier/double_barrier.cpp
- src/option/path_dependent/barrier/base_single_barrier_option.cpp
- src/option/path_dependent/barrier/up_single_barrier_option.cpp
- src/option/path_dependent/barrier/down_single_barrier_option.cpp
+ src/option/path_dependent/asian_option.cpp
+ src/option/path_dependent/barrier_option.cpp
# Factories
src/option/factory_option.cpp
src/option/single_path/factory_european_option.cpp
src/option/single_path/factory_digital_option.cpp
src/option/single_path/factory_double_digital_option.cpp
src/option/path_dependent/factory_american_option.cpp
- src/option/path_dependent/asian/factory_arithmetic_asian_option.cpp
- src/option/path_dependent/asian/factory_geometric_asian_option.cpp
- src/option/path_dependent/barrier/factory_up_single_barrier_option.cpp
+ src/option/path_dependent/factory_asian_option.cpp
+ src/option/path_dependent/factory_barrier_option.cpp
)
# Create dynamic library for marketdata
@@ -99,11 +92,12 @@ add_library(solver SHARED
src/solver/monte_carlo/stock_price_model.cpp
src/solver/monte_carlo/gbm_stock_price_model.cpp
include/solver/monte_carlo/gbm_stock_price_model.h
+ include/solver/monte_carlo/generator.h
)
# Link random library to the solver ONLY
-#target_link_libraries(solver PRIVATE Boost::random)
+target_link_libraries(solver PUBLIC Boost::random)
# Link the option library against marketdata and payoff
target_link_libraries(option PUBLIC marketdata payoff)
@@ -112,12 +106,12 @@ target_link_libraries(option PUBLIC marketdata payoff)
add_executable(Option_pricer main.cpp)
# Link the main executable to our dynamic libraries
-target_link_libraries(Option_pricer Boost::random marketdata payoff option solver)
-#target_link_libraries(Option_pricer Boost::random)
+target_link_libraries(Option_pricer PUBLIC marketdata payoff option solver)
+#target_link_libraries(Option_pricer marketdata payoff option solver)
# Enable testing and add the tests directory
enable_testing()
add_subdirectory(tests)
# Add the examples subdirectory
-add_subdirectory(examples)
\ No newline at end of file
+add_subdirectory(examples)
diff --git a/examples/CMakeLists.txt b/examples/CMakeLists.txt
index 85bac80..584afdd 100644
--- a/examples/CMakeLists.txt
+++ b/examples/CMakeLists.txt
@@ -1 +1,14 @@
-#find_package(Boost REQUIRED COMPONENTS random)
+find_package(Boost REQUIRED COMPONENTS random)
+
+if (Boost_FOUND)
+ message(STATUS "Boost found: ${Boost_VERSION}")
+else()
+ message(FATAL_ERROR "Boost not found!")
+endif()
+
+add_executable(sobol generate_sobol.cpp
+ generate_sobol.cpp)
+
+target_link_libraries(sobol Boost::random)
+
+set_target_properties(sobol PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/examples)
diff --git a/examples/generate_sobol.cpp b/examples/generate_sobol.cpp
index e8280b3..f04ae36 100644
--- a/examples/generate_sobol.cpp
+++ b/examples/generate_sobol.cpp
@@ -1,37 +1,82 @@
-#include
+#include
+#include
#include
+#include
#include
-#include
-#include
+#include
+#include
+#include
#include
+#include
+std::filesystem::path createOutputDir() {
+ std::filesystem::path outputDir = "output";
+ std::filesystem::path sourceDir = std::filesystem::current_path();
+ std::filesystem::path destDir = sourceDir.parent_path().parent_path() / "examples" / outputDir;
+ if (!exists(destDir)) {
+ create_directory(destDir);
+ std::cout << "Directory created: " << destDir << "\n";
+ }
+ return destDir;
+}
int main() {
- std::filesystem::path path = "";
-
- std::ofstream csvFile("sobol_sequence_5.csv");
+ unsigned int N = 0, s = 0;
+ do {
+ std::cout << "Enter the number of samples (N): ";
+ std::cin >> N;
+ std::cout << "Enter the number of dimensions (s): ";
+ std::cin >> s;
+ } while (N <= 0 || s <= 0);
+
+ std::string endFileName = boost::lexical_cast(s) + ".csv";
+ std::filesystem::path csvPath = createOutputDir() / ("sequences_" + endFileName);
+
+ std::ofstream csvFile(csvPath);
+
if (!csvFile.is_open()) {
std::cerr << "Failed to open file for writing." << std::endl;
return 1;
}
- boost::random::sobol qrng(2); // 3-dimensional Sobol sequence
- qrng.seed(42);
+ unsigned int seed = 42;
+ boost::mt19937 unifRng(seed); // Mersenne Twister Pseudo-Random Number Generator (PRNG)
+ boost::random::uniform_01<> uniformGen;
+
+ boost::random::sobol sobolQrng(s); // s-dimensional Sobol Quasi Random Number Generator (QRNG)
+ boost::random::faure faureQrng(s); // s-dimensional Faure Quasi Random Number Generator (QRNG)
- std::vector point(2);
+ sobolQrng.seed(seed);
+ faureQrng.seed(seed);
- csvFile << "x,y\n";
+ std::vector sobolPoint(s);
+ std::vector faurePoint(s);
- std::cout << "Sobol sequence using Boost:" << std::endl;
- for (int i = 0; i < 5; ++i) {
- qrng.generate(point.begin(), point.end());
- for (auto& coord : point)
- coord /= static_cast(boost::random::sobol::max());
+ // Write header to CSV file
+ csvFile << "Sample,Dimension,Sobol,Faure,Uniform\n";
- csvFile << std::fixed << std::setprecision(8) << point[0] << "," << point[1] << "\n";
- std::cout << std::endl;
+ for (unsigned int i = 1; i <= N; ++i) {
+ // Generate Sobol and Faure sequences for this sample
+ sobolQrng.generate(sobolPoint.begin(), sobolPoint.end());
+ faureQrng.generate(faurePoint.begin(), faurePoint.end());
+
+ for (unsigned int d = 1; d <= s; ++d) {
+ // Normalize Sobol and Faure values to [0, 1)
+ double sobolVal = sobolPoint[d - 1] / static_cast(boost::random::sobol::max());
+ double faureVal = faurePoint[d - 1] / static_cast(boost::random::faure::max());
+ double uniformVal = uniformGen(unifRng);
+
+ // Write values to CSV
+ csvFile << i << "," << d << ","
+ << std::fixed << std::setprecision(8)
+ << sobolVal << ","
+ << faureVal << ","
+ << uniformVal << "\n";
+ }
}
+
csvFile.close();
+ std::cout << "Sequences exported to " << csvPath << std::endl;
return 0;
-}
\ No newline at end of file
+}
diff --git a/examples/notebooks/.ipynb_checkpoints/sobol-checkpoint.ipynb b/examples/notebooks/.ipynb_checkpoints/sobol-checkpoint.ipynb
new file mode 100644
index 0000000..360552e
--- /dev/null
+++ b/examples/notebooks/.ipynb_checkpoints/sobol-checkpoint.ipynb
@@ -0,0 +1,446 @@
+{
+ "cells": [
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "id": "bc6741b6",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import matplotlib.pyplot as plt\n",
+ "import numpy as np\n",
+ "from pathlib import Path\n",
+ "import pandas as pd\n",
+ "import seaborn as sns"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "id": "7d253d8a",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "output_dir = Path(\"/Users/anthony/CLionProjects/Option_pricer/examples/output\")\n",
+ "sequences_2_file = output_dir / \"sequences_2.csv\"\n",
+ "sequences_50_file = output_dir / \"sequences_50.csv\""
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 14,
+ "id": "1a13052f",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "sequences_2 = pd.read_csv(sequences_2_file, index_col=[\"Sample\", \"Dimension\"])\n",
+ "sequences_50 = pd.read_csv(sequences_50_file, index_col=[\"Sample\", \"Dimension\"])"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 24,
+ "id": "4330efd5",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "\n",
+ "\n",
+ "
\n",
+ " \n",
+ " \n",
+ " | \n",
+ " | \n",
+ " Sobol | \n",
+ " Faure | \n",
+ " Uniform | \n",
+ "
\n",
+ " \n",
+ " Sample | \n",
+ " Dimension | \n",
+ " | \n",
+ " | \n",
+ " | \n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ " 1 | \n",
+ " 1 | \n",
+ " 0.484375 | \n",
+ " 0.328125 | \n",
+ " 0.374540 | \n",
+ "
\n",
+ " \n",
+ " 2 | \n",
+ " 0.828125 | \n",
+ " 0.984375 | \n",
+ " 0.796543 | \n",
+ "
\n",
+ " \n",
+ " 2 | \n",
+ " 1 | \n",
+ " 0.359375 | \n",
+ " 0.828125 | \n",
+ " 0.950714 | \n",
+ "
\n",
+ " \n",
+ " 2 | \n",
+ " 0.453125 | \n",
+ " 0.484375 | \n",
+ " 0.183435 | \n",
+ "
\n",
+ " \n",
+ " 3 | \n",
+ " 1 | \n",
+ " 0.859375 | \n",
+ " 0.203125 | \n",
+ " 0.731994 | \n",
+ "
\n",
+ " \n",
+ " ... | \n",
+ " ... | \n",
+ " ... | \n",
+ " ... | \n",
+ " ... | \n",
+ "
\n",
+ " \n",
+ " 998 | \n",
+ " 2 | \n",
+ " 0.095215 | \n",
+ " 0.689941 | \n",
+ " 0.790014 | \n",
+ "
\n",
+ " \n",
+ " 999 | \n",
+ " 1 | \n",
+ " 0.595215 | \n",
+ " 0.031738 | \n",
+ " 0.950237 | \n",
+ "
\n",
+ " \n",
+ " 2 | \n",
+ " 0.595215 | \n",
+ " 0.158691 | \n",
+ " 0.690560 | \n",
+ "
\n",
+ " \n",
+ " 1000 | \n",
+ " 1 | \n",
+ " 0.845215 | \n",
+ " 0.531738 | \n",
+ " 0.446006 | \n",
+ "
\n",
+ " \n",
+ " 2 | \n",
+ " 0.345215 | \n",
+ " 0.658691 | \n",
+ " 0.521301 | \n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
2000 rows × 3 columns
\n",
+ "
"
+ ],
+ "text/plain": [
+ " Sobol Faure Uniform\n",
+ "Sample Dimension \n",
+ "1 1 0.484375 0.328125 0.374540\n",
+ " 2 0.828125 0.984375 0.796543\n",
+ "2 1 0.359375 0.828125 0.950714\n",
+ " 2 0.453125 0.484375 0.183435\n",
+ "3 1 0.859375 0.203125 0.731994\n",
+ "... ... ... ...\n",
+ "998 2 0.095215 0.689941 0.790014\n",
+ "999 1 0.595215 0.031738 0.950237\n",
+ " 2 0.595215 0.158691 0.690560\n",
+ "1000 1 0.845215 0.531738 0.446006\n",
+ " 2 0.345215 0.658691 0.521301\n",
+ "\n",
+ "[2000 rows x 3 columns]"
+ ]
+ },
+ "execution_count": 24,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "sequences_2"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 25,
+ "id": "7ae13295",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "\n",
+ "\n",
+ "
\n",
+ " \n",
+ " \n",
+ " | \n",
+ " | \n",
+ " Sobol | \n",
+ " Faure | \n",
+ " Uniform | \n",
+ "
\n",
+ " \n",
+ " Sample | \n",
+ " Dimension | \n",
+ " | \n",
+ " | \n",
+ " | \n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ " 1 | \n",
+ " 1 | \n",
+ " 0.484375 | \n",
+ " 0.792453 | \n",
+ " 0.374540 | \n",
+ "
\n",
+ " \n",
+ " 2 | \n",
+ " 0.828125 | \n",
+ " 0.792453 | \n",
+ " 0.796543 | \n",
+ "
\n",
+ " \n",
+ " 3 | \n",
+ " 0.515625 | \n",
+ " 0.792453 | \n",
+ " 0.950714 | \n",
+ "
\n",
+ " \n",
+ " 4 | \n",
+ " 0.234375 | \n",
+ " 0.792453 | \n",
+ " 0.183435 | \n",
+ "
\n",
+ " \n",
+ " 5 | \n",
+ " 0.953125 | \n",
+ " 0.792453 | \n",
+ " 0.731994 | \n",
+ "
\n",
+ " \n",
+ " ... | \n",
+ " ... | \n",
+ " ... | \n",
+ " ... | \n",
+ " ... | \n",
+ "
\n",
+ " \n",
+ " 1000 | \n",
+ " 46 | \n",
+ " 0.885254 | \n",
+ " 0.780349 | \n",
+ " 0.191649 | \n",
+ "
\n",
+ " \n",
+ " 47 | \n",
+ " 0.126465 | \n",
+ " 0.138839 | \n",
+ " 0.637286 | \n",
+ "
\n",
+ " \n",
+ " 48 | \n",
+ " 0.550293 | \n",
+ " 0.497330 | \n",
+ " 0.602445 | \n",
+ "
\n",
+ " \n",
+ " 49 | \n",
+ " 0.458496 | \n",
+ " 0.855821 | \n",
+ " 0.951839 | \n",
+ "
\n",
+ " \n",
+ " 50 | \n",
+ " 0.357910 | \n",
+ " 0.214311 | \n",
+ " 0.196686 | \n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
50000 rows × 3 columns
\n",
+ "
"
+ ],
+ "text/plain": [
+ " Sobol Faure Uniform\n",
+ "Sample Dimension \n",
+ "1 1 0.484375 0.792453 0.374540\n",
+ " 2 0.828125 0.792453 0.796543\n",
+ " 3 0.515625 0.792453 0.950714\n",
+ " 4 0.234375 0.792453 0.183435\n",
+ " 5 0.953125 0.792453 0.731994\n",
+ "... ... ... ...\n",
+ "1000 46 0.885254 0.780349 0.191649\n",
+ " 47 0.126465 0.138839 0.637286\n",
+ " 48 0.550293 0.497330 0.602445\n",
+ " 49 0.458496 0.855821 0.951839\n",
+ " 50 0.357910 0.214311 0.196686\n",
+ "\n",
+ "[50000 rows x 3 columns]"
+ ]
+ },
+ "execution_count": 25,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "sequences_50"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 19,
+ "id": "585379ca",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def plot_sequences(sequences, s, sample_sizes=[5, 20, 100], s1=1, s2=2):\n",
+ " \"\"\"\n",
+ " Plot sequences for specified dimensions and sample sizes.\n",
+ "\n",
+ " :param sequences: DataFrame with a multi-level index (Sample, Dimension)\n",
+ " :param sample_sizes: List of sample sizes to plot\n",
+ " :param s1: Dimension to plot on the x-axis\n",
+ " :param s2: Dimension to plot on the y-axis\n",
+ " \"\"\"\n",
+ " # Plot configuration\n",
+ " num_rows = len(sample_sizes)\n",
+ " num_cols = 3\n",
+ " sequence_cols = ['Sobol', 'Faure', 'Uniform']\n",
+ " \n",
+ " # Create a plot grid based on the number of sample sizes and sequence types\n",
+ " num_rows = len(sample_sizes)\n",
+ " num_cols = 3\n",
+ " fig, axes = plt.subplots(nrows=num_rows, ncols=num_cols, figsize=(12, 12))\n",
+ " fig.subplots_adjust(hspace=0.4, wspace=0.3)\n",
+ "\n",
+ " for row, sample_size in enumerate(sample_sizes):\n",
+ " for col, seq_col in enumerate(sequence_cols):\n",
+ " \n",
+ " # Filter the data for the current sample size and dimensions\n",
+ " filtered_data = sequences.loc[:sample_size].unstack(level='Dimension')\n",
+ " \n",
+ " x = filtered_data[(seq_col, s1)]\n",
+ " y = filtered_data[(seq_col, s2)]\n",
+ " \n",
+ " ax = axes[row, col]\n",
+ " ax.scatter(x, y, alpha=0.7, s=50)\n",
+ " ax.set_title(f'{plot_titles[col]} (N={sample_size})')\n",
+ " ax.set_xlabel(f'Dimension {s1}')\n",
+ " ax.set_ylabel(f'Dimension {s2}')\n",
+ "\n",
+ " fig.suptitle(f'Comparison between Sobol, Faure sequences and Uniform draws for {s} dimensions', fontsize=16)\n",
+ " plt.show()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 20,
+ "id": "d8af158c",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "plot_sequences(sequences_2, 2)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 23,
+ "id": "11919da7",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "plot_sequences(sequences_50, 50, s1=49, s2=50)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "id": "f9384d46",
+ "metadata": {},
+ "outputs": [],
+ "source": []
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3 (ipykernel)",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.9.16"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/examples/notebooks/sobol.ipynb b/examples/notebooks/sobol.ipynb
new file mode 100644
index 0000000..360552e
--- /dev/null
+++ b/examples/notebooks/sobol.ipynb
@@ -0,0 +1,446 @@
+{
+ "cells": [
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "id": "bc6741b6",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import matplotlib.pyplot as plt\n",
+ "import numpy as np\n",
+ "from pathlib import Path\n",
+ "import pandas as pd\n",
+ "import seaborn as sns"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "id": "7d253d8a",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "output_dir = Path(\"/Users/anthony/CLionProjects/Option_pricer/examples/output\")\n",
+ "sequences_2_file = output_dir / \"sequences_2.csv\"\n",
+ "sequences_50_file = output_dir / \"sequences_50.csv\""
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 14,
+ "id": "1a13052f",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "sequences_2 = pd.read_csv(sequences_2_file, index_col=[\"Sample\", \"Dimension\"])\n",
+ "sequences_50 = pd.read_csv(sequences_50_file, index_col=[\"Sample\", \"Dimension\"])"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 24,
+ "id": "4330efd5",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "\n",
+ "\n",
+ "
\n",
+ " \n",
+ " \n",
+ " | \n",
+ " | \n",
+ " Sobol | \n",
+ " Faure | \n",
+ " Uniform | \n",
+ "
\n",
+ " \n",
+ " Sample | \n",
+ " Dimension | \n",
+ " | \n",
+ " | \n",
+ " | \n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ " 1 | \n",
+ " 1 | \n",
+ " 0.484375 | \n",
+ " 0.328125 | \n",
+ " 0.374540 | \n",
+ "
\n",
+ " \n",
+ " 2 | \n",
+ " 0.828125 | \n",
+ " 0.984375 | \n",
+ " 0.796543 | \n",
+ "
\n",
+ " \n",
+ " 2 | \n",
+ " 1 | \n",
+ " 0.359375 | \n",
+ " 0.828125 | \n",
+ " 0.950714 | \n",
+ "
\n",
+ " \n",
+ " 2 | \n",
+ " 0.453125 | \n",
+ " 0.484375 | \n",
+ " 0.183435 | \n",
+ "
\n",
+ " \n",
+ " 3 | \n",
+ " 1 | \n",
+ " 0.859375 | \n",
+ " 0.203125 | \n",
+ " 0.731994 | \n",
+ "
\n",
+ " \n",
+ " ... | \n",
+ " ... | \n",
+ " ... | \n",
+ " ... | \n",
+ " ... | \n",
+ "
\n",
+ " \n",
+ " 998 | \n",
+ " 2 | \n",
+ " 0.095215 | \n",
+ " 0.689941 | \n",
+ " 0.790014 | \n",
+ "
\n",
+ " \n",
+ " 999 | \n",
+ " 1 | \n",
+ " 0.595215 | \n",
+ " 0.031738 | \n",
+ " 0.950237 | \n",
+ "
\n",
+ " \n",
+ " 2 | \n",
+ " 0.595215 | \n",
+ " 0.158691 | \n",
+ " 0.690560 | \n",
+ "
\n",
+ " \n",
+ " 1000 | \n",
+ " 1 | \n",
+ " 0.845215 | \n",
+ " 0.531738 | \n",
+ " 0.446006 | \n",
+ "
\n",
+ " \n",
+ " 2 | \n",
+ " 0.345215 | \n",
+ " 0.658691 | \n",
+ " 0.521301 | \n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
2000 rows × 3 columns
\n",
+ "
"
+ ],
+ "text/plain": [
+ " Sobol Faure Uniform\n",
+ "Sample Dimension \n",
+ "1 1 0.484375 0.328125 0.374540\n",
+ " 2 0.828125 0.984375 0.796543\n",
+ "2 1 0.359375 0.828125 0.950714\n",
+ " 2 0.453125 0.484375 0.183435\n",
+ "3 1 0.859375 0.203125 0.731994\n",
+ "... ... ... ...\n",
+ "998 2 0.095215 0.689941 0.790014\n",
+ "999 1 0.595215 0.031738 0.950237\n",
+ " 2 0.595215 0.158691 0.690560\n",
+ "1000 1 0.845215 0.531738 0.446006\n",
+ " 2 0.345215 0.658691 0.521301\n",
+ "\n",
+ "[2000 rows x 3 columns]"
+ ]
+ },
+ "execution_count": 24,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "sequences_2"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 25,
+ "id": "7ae13295",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "\n",
+ "\n",
+ "
\n",
+ " \n",
+ " \n",
+ " | \n",
+ " | \n",
+ " Sobol | \n",
+ " Faure | \n",
+ " Uniform | \n",
+ "
\n",
+ " \n",
+ " Sample | \n",
+ " Dimension | \n",
+ " | \n",
+ " | \n",
+ " | \n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ " 1 | \n",
+ " 1 | \n",
+ " 0.484375 | \n",
+ " 0.792453 | \n",
+ " 0.374540 | \n",
+ "
\n",
+ " \n",
+ " 2 | \n",
+ " 0.828125 | \n",
+ " 0.792453 | \n",
+ " 0.796543 | \n",
+ "
\n",
+ " \n",
+ " 3 | \n",
+ " 0.515625 | \n",
+ " 0.792453 | \n",
+ " 0.950714 | \n",
+ "
\n",
+ " \n",
+ " 4 | \n",
+ " 0.234375 | \n",
+ " 0.792453 | \n",
+ " 0.183435 | \n",
+ "
\n",
+ " \n",
+ " 5 | \n",
+ " 0.953125 | \n",
+ " 0.792453 | \n",
+ " 0.731994 | \n",
+ "
\n",
+ " \n",
+ " ... | \n",
+ " ... | \n",
+ " ... | \n",
+ " ... | \n",
+ " ... | \n",
+ "
\n",
+ " \n",
+ " 1000 | \n",
+ " 46 | \n",
+ " 0.885254 | \n",
+ " 0.780349 | \n",
+ " 0.191649 | \n",
+ "
\n",
+ " \n",
+ " 47 | \n",
+ " 0.126465 | \n",
+ " 0.138839 | \n",
+ " 0.637286 | \n",
+ "
\n",
+ " \n",
+ " 48 | \n",
+ " 0.550293 | \n",
+ " 0.497330 | \n",
+ " 0.602445 | \n",
+ "
\n",
+ " \n",
+ " 49 | \n",
+ " 0.458496 | \n",
+ " 0.855821 | \n",
+ " 0.951839 | \n",
+ "
\n",
+ " \n",
+ " 50 | \n",
+ " 0.357910 | \n",
+ " 0.214311 | \n",
+ " 0.196686 | \n",
+ "
\n",
+ " \n",
+ "
\n",
+ "
50000 rows × 3 columns
\n",
+ "
"
+ ],
+ "text/plain": [
+ " Sobol Faure Uniform\n",
+ "Sample Dimension \n",
+ "1 1 0.484375 0.792453 0.374540\n",
+ " 2 0.828125 0.792453 0.796543\n",
+ " 3 0.515625 0.792453 0.950714\n",
+ " 4 0.234375 0.792453 0.183435\n",
+ " 5 0.953125 0.792453 0.731994\n",
+ "... ... ... ...\n",
+ "1000 46 0.885254 0.780349 0.191649\n",
+ " 47 0.126465 0.138839 0.637286\n",
+ " 48 0.550293 0.497330 0.602445\n",
+ " 49 0.458496 0.855821 0.951839\n",
+ " 50 0.357910 0.214311 0.196686\n",
+ "\n",
+ "[50000 rows x 3 columns]"
+ ]
+ },
+ "execution_count": 25,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "sequences_50"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 19,
+ "id": "585379ca",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "def plot_sequences(sequences, s, sample_sizes=[5, 20, 100], s1=1, s2=2):\n",
+ " \"\"\"\n",
+ " Plot sequences for specified dimensions and sample sizes.\n",
+ "\n",
+ " :param sequences: DataFrame with a multi-level index (Sample, Dimension)\n",
+ " :param sample_sizes: List of sample sizes to plot\n",
+ " :param s1: Dimension to plot on the x-axis\n",
+ " :param s2: Dimension to plot on the y-axis\n",
+ " \"\"\"\n",
+ " # Plot configuration\n",
+ " num_rows = len(sample_sizes)\n",
+ " num_cols = 3\n",
+ " sequence_cols = ['Sobol', 'Faure', 'Uniform']\n",
+ " \n",
+ " # Create a plot grid based on the number of sample sizes and sequence types\n",
+ " num_rows = len(sample_sizes)\n",
+ " num_cols = 3\n",
+ " fig, axes = plt.subplots(nrows=num_rows, ncols=num_cols, figsize=(12, 12))\n",
+ " fig.subplots_adjust(hspace=0.4, wspace=0.3)\n",
+ "\n",
+ " for row, sample_size in enumerate(sample_sizes):\n",
+ " for col, seq_col in enumerate(sequence_cols):\n",
+ " \n",
+ " # Filter the data for the current sample size and dimensions\n",
+ " filtered_data = sequences.loc[:sample_size].unstack(level='Dimension')\n",
+ " \n",
+ " x = filtered_data[(seq_col, s1)]\n",
+ " y = filtered_data[(seq_col, s2)]\n",
+ " \n",
+ " ax = axes[row, col]\n",
+ " ax.scatter(x, y, alpha=0.7, s=50)\n",
+ " ax.set_title(f'{plot_titles[col]} (N={sample_size})')\n",
+ " ax.set_xlabel(f'Dimension {s1}')\n",
+ " ax.set_ylabel(f'Dimension {s2}')\n",
+ "\n",
+ " fig.suptitle(f'Comparison between Sobol, Faure sequences and Uniform draws for {s} dimensions', fontsize=16)\n",
+ " plt.show()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 20,
+ "id": "d8af158c",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ "