68 |
69 | Black-Scholes Hedge Simulator for a European Call Option
53 | 54 | Getting Started 55 | 56 |
57 | Checkout finmath-experiments from git and run maven (mvn or mvnw) from
58 | its directory. This will start a JShell.
59 | See Getting Started for details.
60 |
Running the Hedge Simulator
63 | 64 |65 | 66 | Note: due to a bug in Java 11.0.7 for macOS, the simulator does not run 67 | when launched with Java 11.0.7. Please use Java 11.0.8 or Java 14.0.1 or better. 68 | 69 |
70 |71 | The Hedge Simulator is a GUI application. To run it just type the following in JShell: 72 |
73 | 74 |
75 | JShell:
76 |
77 |
80 |
81 |
82 |
78 | net.finmath.experiments.hedgesimulator.HedgeSimulator.run();
79 | 
84 | Where to continue
87 | 88 | You may continue with 89 |-
90 |
- 91 | Monte-Carlo Simulation 92 | 93 |
Getting started
52 | 53 |54 | Some experiments on this site use Java JShell started from a Maven project as a starting point. 55 |
56 | 57 |58 | There are several options on how you can start that JShell. 59 |
60 | 61 |Requirement
62 | 63 |64 | To checkout the project you need git. 65 |
66 | 67 |Running from a Command Shell (macOS: Terminal, Windows: Cmd.exe)
68 | 69 |Checkout the finmath-experiments project from its Git repository and run it via Maven
70 | 71 | This assumes that you have Git installed on your machine. 72 | 73 |-
74 |
- Open a command shell 75 |
- Type
mkdir git(to create a foldergit, if you do not have one)
76 | - Type
cd git(to enter yourgitfolder)
77 | - Next, clone (i.e. download) the repository (
git), change to the cloned directory (cd) and start jshell via Maven (mvn) by typing the following three commands:
78 |
81 | Terminal Window
82 |
83 |
88 |
89 | Note: If
84 | git clone https://github.com/finmath/finmath-experiments
85 | cd finmath-experiments
86 | mvnw
87 | mvnw fails, try ./mvnw on Linux, macOS or .\mvnw on Windows. Alternatively, if you Maven installed run mvn.
90 |
91 | Running from a Eclipse
92 | 93 | You may also directly run the JShell experiments from Ecplise. To do so: 94 | 95 |-
96 |
- Install Eclipse (2020-3 or better) from eclipse.org. 97 |
- In Eclipse, checkout finmath-experiments from GitHub. 98 |
- Right-click on the finmath-experiments projects and select
99 | Run As → Maven build.
100 |
101 |
- Note: The Maven build had to be run with Java 11 or better. 102 | If this is not already your default setup, there are two possibilities here: 103 |
115 |-
104 |
- 105 | In the Run As Maven build dialog select the tab JRE, 106 | then check "Execution environment" and select Java 11 or better. 107 | 108 |
- 109 | Ensure that your default workspace JDK is Java 11 or better. 110 | Go to Eclipse Preferences and go to Java → Installed JREs... 111 | Select the checkbox for a JRE being Java 11 or better. 112 | 113 |
- Note: The Maven build had to be run with Java 11 or better. 102 | If this is not already your default setup, there are two possibilities here: 103 |
Where to continue
118 | 119 | You may continue with 120 |-
121 |
- 122 | Monte-Carlo Simulation 123 | 124 |
33 | 
34 | Experiments
35 |
36 |
37 | Risk Neutral Valuation
38 | 39 |42 | Some experiments on risk neutral valuation. 43 |
44 | 45 |-
46 |
- 47 | Risk Neutral Density (Breeden-Litzenberger Theorem). 48 | 49 |
Random Numbers
52 | 53 |56 | Small experiments related to the generation of normal distributed random numbers. 57 |
58 | 59 |-
60 |
- 61 | Quasi and pseudo random number sequences. 62 | 63 |
Black-Scholes Model Hedge Simulation GUI
66 | 67 |-
68 |
- 69 | Black-Scholes Model Hedge Simulation 70 | 71 |
Monte-Carlo Simulation, Bermudan Options, and Algorithmic Differentiation
74 | 75 |78 | Some experiments on Monte-Carlo simulation, Bermudan option valuation in a Monte-Carlo simulation and algorithmic differentiation. 79 |
80 | 81 |-
82 |
- 83 | Monte-Carlo Simulation 84 | 85 |
- 86 | Bermudan Option Valuation in a Monte-Carlo Simulation of Black-Scholes Model 87 | 88 |
- 89 | Algorithmic Differentiation and Dependency Injection: Basics with AAD 90 | 91 |
- 92 | Algorithmic Differentiation for Forward Sensitivities 93 | 94 |
Interest Rate Modelling
97 | 98 |101 | Some experiments related to interest rate modelling. 102 |
103 | 104 |-
105 |
- 106 | Factor Reduction / Correlated Brownian Motion 107 | 108 |
- 109 | 110 |
113 | 114 | 117 | 118 | 119 | -------------------------------------------------------------------------------- /docs/mathematical-finance-laboratory.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/finmath/finmath-experiments/1a652ef083db4b6903b0eb06f43806f06b0e6a64/docs/mathematical-finance-laboratory.png -------------------------------------------------------------------------------- /docs/montecarlo-blackscholes/experiment-01.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/finmath/finmath-experiments/1a652ef083db4b6903b0eb06f43806f06b0e6a64/docs/montecarlo-blackscholes/experiment-01.jpg -------------------------------------------------------------------------------- /docs/montecarlo-blackscholes/experiment-02.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/finmath/finmath-experiments/1a652ef083db4b6903b0eb06f43806f06b0e6a64/docs/montecarlo-blackscholes/experiment-02.jpg -------------------------------------------------------------------------------- /docs/montecarlo-blackscholes/experiment-03.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/finmath/finmath-experiments/1a652ef083db4b6903b0eb06f43806f06b0e6a64/docs/montecarlo-blackscholes/experiment-03.jpg -------------------------------------------------------------------------------- /docs/parallel-computing-animation/ParallelComputingAnimation5b.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/finmath/finmath-experiments/1a652ef083db4b6903b0eb06f43806f06b0e6a64/docs/parallel-computing-animation/ParallelComputingAnimation5b.png -------------------------------------------------------------------------------- /docs/parallel-computing-animation/index.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 |
Parallel Computing Animation
53 | 54 |
55 | To run the animation checkout the project JavaGPUExperiments and launch
56 | com.christianfries.teaching.gpu.ParallelComputingAnimation via Maven exec.
57 |
60 | Terminal / Console:
61 |
62 |
67 |
68 |
69 | Below you see a screenshot of the application.
70 |
63 | git clone https://github.com/cfries/JavaGPUExperiments
64 | cd JavaGPUExperiments
65 | mvn clean install exec:java -Dexec.mainClass=com.christianfries.teaching.gpu.ParallelComputingAnimation
66 | 
72 | IntStream.range(0,numberOfTasks).parallel().forEach (for example:
17 | * the parallel executions of the outer forEach should be limited due to a
18 | * memory constrain).
19 | *
20 | * Inside the execution block of the outer forEach we use another parallel stream
21 | * to create an inner forEach. The number of concurrent
22 | * executions of the inner forEach is not limited by us (it is however limited by a
23 | * system property "java.util.concurrent.ForkJoinPool.common.parallelism").
24 | *
25 | * Problem: If the semaphore is used AND the inner forEach is active, then
26 | * the execution will be DEADLOCKED.
27 | *
28 | * @author Christian Fries
29 | */
30 | public class ForkJoinPoolTest {
31 |
32 | // Any combination of the booleans works, except (true,true,false)
33 | private final boolean isUseSemaphore = true;
34 | private final boolean isUseInnerStream = true;
35 | private final boolean isWrappedInnerLoopThread = false;
36 |
37 | private final int numberOfTasksInOuterLoop = 20; // In real applications this can be a large number (e.g. > 1000).
38 | private final int numberOfTasksInInnerLoop = 100; // In real applications this can be a large number (e.g. > 1000).
39 | private final int concurrentExecusionsLimitInOuterLoop = 5;
40 | private final int concurrentExecutionsLimitForStreams = 10;
41 |
42 | private final Semaphore concurrentExecutions;
43 |
44 | public static void main(String[] args) {
45 | (new ForkJoinPoolTest()).testNestedLoops();
46 | }
47 |
48 | public ForkJoinPoolTest() {
49 | super();
50 | this.concurrentExecutions = new Semaphore(concurrentExecusionsLimitInOuterLoop);
51 | }
52 |
53 | public void testNestedLoops() {
54 |
55 | System.setProperty("java.util.concurrent.ForkJoinPool.common.parallelism",Integer.toString(concurrentExecutionsLimitForStreams));
56 | System.out.println("java.util.concurrent.ForkJoinPool.common.parallelism = " + System.getProperty("java.util.concurrent.ForkJoinPool.common.parallelism"));
57 |
58 | // Outer loop
59 | IntStream.range(0,numberOfTasksInOuterLoop).parallel().forEach(i -> {
60 |
61 | if(isUseSemaphore) {
62 | concurrentExecutions.acquireUninterruptibly();
63 | }
64 |
65 | try {
66 | System.out.println(i + "\t" + "-" + "\t" + concurrentExecutions.availablePermits() + "\t" + Thread.currentThread());
67 |
68 | if(isUseInnerStream) {
69 | try {
70 | Thread.sleep(10*numberOfTasksInInnerLoop);
71 | } catch (final Exception e) {
72 | }
73 | runCodeWhichUsesParallelStream(i, Thread.currentThread().toString());
74 | }
75 | else {
76 | try {
77 | Thread.sleep(10*numberOfTasksInInnerLoop);
78 | } catch (final Exception e) {
79 | }
80 | }
81 | }
82 | finally {
83 | if(isUseSemaphore) {
84 | concurrentExecutions.release();
85 | }
86 | }
87 | });
88 |
89 | System.out.println("D O N E");
90 | }
91 |
92 | /**
93 | * Runs code in a parallel forEach using streams.
94 | *
95 | * @param numberOfTasksInInnerLoop Number of tasks to execute.
96 | */
97 | private void runCodeWhichUsesParallelStream(int i, String callingThread) {
98 |
99 | final Runnable innerLoop = new Runnable() {
100 | @Override
101 | public void run() {
102 | // Inner loop
103 | IntStream.range(0,numberOfTasksInInnerLoop).parallel().forEach(j -> {
104 | try {
105 | System.out.println(i + "\t" + j + "\t" + concurrentExecutions.availablePermits() + "\t" + callingThread + "\t" + Thread.currentThread());
106 | Thread.sleep(10);
107 | } catch (final Exception e) {
108 | }
109 | });
110 | }
111 | };
112 |
113 | if(isWrappedInnerLoopThread) {
114 | final Thread t = new Thread(innerLoop, "Wrapper Thread");
115 | try {
116 | t.start();
117 | t.join();
118 | } catch (final InterruptedException e) {
119 | }
120 | }
121 | else {
122 | innerLoop.run();
123 | }
124 | }
125 | }
126 |
--------------------------------------------------------------------------------
/src/main/java/net/finmath/experiments/concurrency/NestedParallelForEachTest.java:
--------------------------------------------------------------------------------
1 | /*
2 | * (c) Copyright Christian P. Fries, Germany. All rights reserved. Contact: email@christian-fries.de.
3 | *
4 | * Created on 06.05.2014
5 | */
6 | package net.finmath.experiments.concurrency;
7 |
8 | import java.util.stream.IntStream;
9 |
10 | /**
11 | * This is a test of Java 8 parallel streams.
12 | *
13 | * We are testing nested parallel forEach loops, which appear to
14 | * have unexpected poor performance in Java 1.8.0u5.
15 | *
16 | * We have a nested stream.parallel().forEach():
17 | *
18 | * The inner loop is independent (stateless, no interference, etc. - except of the use of a common pool)
19 | * and consumes 1 second in total in the worst case, namely if processed sequential.
20 | * Half of the tasks of the outer loop consume 10 seconds prior that loop.
21 | * Half consume 10 seconds after that loop.
22 | * We have a boolean which allows to switch the inner loop from parallel() to sequential().
23 | * Hence every thread consumes 11 seconds (worst case) in total.
24 | * Now: submitting 24 outer-loop-tasks to a pool of 8 we would expect 24/8 * 11 = 33 seconds at best (on an 8 core or better machine).
25 | *
26 | * The result is:
27 | * - With inner sequential loop: 33 seconds.
28 | * - With inner parallel loop: >80 seconds (I had 92 seconds).
29 | *
30 | * Now, there is a funny workaround. The method
31 | * wraps every operation in its own thread. Use this to wrap the inner loop in its
32 | * own thread via
33 | * {@code
34 | * wrapInThread( () ->
35 | * IntStream.range(0,numberOfTasksInInnerLoop).parallel().forEach(j -> {
36 | * burnTime(10);
37 | * }));
38 | * }
39 | * And the performance issue is gone. Note that this does not introduce any new
40 | * parallelism and that the inner loop tasks are still submitted to the same
41 | * common fork-join pool.
42 | *
43 | * The reason, why this fix works, is because the inner loop is started form a Thread
44 | * and not from possible ForkJoinWorkerThread of the outer loop. In the latter case
45 | * the ForkJoinTask by mistake assumes that the starting thread is a worker of itself
46 | * and issues a join, effectively joining inner loop tasks with outer loop tasks.
47 | *
48 | * @author Christian Fries
49 | */
50 | public class NestedParallelForEachTest {
51 |
52 | // The program uses 33 sec with this boolean to false and around 80+ with this boolean true:
53 | private final boolean isInnerStreamParallel = true;
54 |
55 | // Setup: Inner loop task 0.01 sec in worse case. Outer loop task: 10 sec + inner loop. This setup: (100 * 0.01 sec + 10 sec) * 24/8 = 33 sec.
56 | private final int numberOfTasksInOuterLoop = 24; // In real applications this can be a large number (e.g. > 1000).
57 | private final int numberOfTasksInInnerLoop = 100; // In real applications this can be a large number (e.g. > 1000).
58 | private final int concurrentExecutionsLimitForStreams = 8; // java.util.concurrent.ForkJoinPool.common.parallelism
59 |
60 | // For those, who do not trust the use of Thread.sleep().
61 | private final boolean isCPUTimeBurned = false; // Set to true, if you like a true loop, and not Thread.sleep()
62 | private final long cpuTimeBurningCountPerMillis = 800000; // You might need to calibrate this for your machine
63 |
64 | public static void main(String[] args) {
65 | (new NestedParallelForEachTest()).testNestedLoops();
66 | }
67 |
68 | public void testNestedLoops() {
69 |
70 | final long start = System.currentTimeMillis();
71 |
72 | System.setProperty("java.util.concurrent.ForkJoinPool.common.parallelism",Integer.toString(concurrentExecutionsLimitForStreams));
73 | System.out.println("java.util.concurrent.ForkJoinPool.common.parallelism = " + System.getProperty("java.util.concurrent.ForkJoinPool.common.parallelism"));
74 |
75 | // Outer loop
76 | IntStream.range(0,numberOfTasksInOuterLoop).parallel().forEach(i -> {
77 |
78 | try {
79 | if(i < 10) {
80 | burnTime(10 * 1000);
81 | }
82 |
83 | System.out.println(i + "\t" + Thread.currentThread());
84 |
85 | if(isInnerStreamParallel) {
86 | // Inner loop as parallel: worst case (sequential) it takes 10 * numberOfTasksInInnerLoop millis
87 | IntStream.range(0,numberOfTasksInInnerLoop).parallel().forEach(j -> {
88 | burnTime(10);
89 | });
90 | }
91 | else {
92 | // Inner loop as sequential
93 | IntStream.range(0,numberOfTasksInInnerLoop).sequential().forEach(j -> {
94 | burnTime(10);
95 | });
96 | }
97 |
98 | if(i >= 10) {
99 | burnTime(10 * 1000);
100 | }
101 | } catch (final Exception e) { e.printStackTrace(); }
102 |
103 | });
104 |
105 | final long end = System.currentTimeMillis();
106 |
107 | System.out.println("Done in " + (end-start)/1000 + " sec.");
108 | }
109 |
110 | private double burnTime(long millis) {
111 | if(isCPUTimeBurned) {
112 | double x = 0;
113 | for(long i=0; inet.finmath.montecarlo.assetderivativevaluation.products.EuropeanOption.
17 | *
18 | * @author Christian Fries
19 | * @version 1.0
20 | */
21 | public class EuropeanOption2 extends AbstractAssetMonteCarloProduct {
22 |
23 | private final double maturity;
24 | private final double strike;
25 |
26 | /**
27 | * Construct a product representing an European option on an asset S (where S the asset with index 0 from the model - single asset case).
28 | *
29 | * @param strike The strike K in the option payoff max(S(T)-K,0).
30 | * @param maturity The maturity T in the option payoff max(S(T)-K,0)
31 | */
32 | public EuropeanOption2(double maturity, double strike) {
33 | super();
34 | this.maturity = maturity;
35 | this.strike = strike;
36 | }
37 |
38 | /**
39 | * Calculates the value of the option under a given model.
40 | *
41 | * @param model A reference to a model
42 | * @return the value
43 | * @throws CalculationException
44 | */
45 | public double getValue(AssetModelMonteCarloSimulationModel model) throws CalculationException
46 | {
47 | // Get underlying and numeraire
48 | final RandomVariable underlyingAtMaturity = model.getAssetValue(maturity,0);
49 | final RandomVariable numeraireAtMaturity = model.getNumeraire(maturity);
50 | final RandomVariable monteCarloWeights = model.getMonteCarloWeights(maturity);
51 | final RandomVariable numeraireAtToday = model.getNumeraire(0);
52 |
53 | /*
54 | * The following way of calculating the expected value (average) is discouraged since it makes too strong
55 | * assumptions on the internals of the RandomVariableAccumulator. Instead you should use
56 | * the mutators sub, div, mult and the getter getAverage. This code is provided for illustrative purposes.
57 | */
58 | double average = 0.0;
59 | for(int path=0; pathRandomVariableAccumulator. Instead you should use
67 | * the mutators sub, div, mult and the getter getAverage. This code is provided for illustrative purposes.
68 | */
69 | double average = 0.0;
70 | for(int path=0; pathcause() method.
51 | */
52 | @Override
53 | public RandomVariable getValue(double evaluationTime, AssetModelMonteCarloSimulationModel model) throws CalculationException {
54 | if(!MonteCarloBlackScholesModel.class.isInstance(model)) {
55 | Logger.getLogger("net.finmath").warning("This method assumes a Black-Scholes type model (MonteCarloBlackScholesModel).");
56 | }
57 |
58 | // Get S(T), S(0)
59 | final RandomVariable underlyingAtMaturity = model.getAssetValue(maturity,0);
60 | final RandomVariable underlyingAtEvalTime = model.getAssetValue(evaluationTime,0);
61 |
62 | // The "payoff": values = indicator(S(T)-K) * S(T)/S(0)
63 | final RandomVariable trigger = underlyingAtMaturity.sub(strike);
64 | RandomVariable values = trigger.choose(underlyingAtMaturity, new Scalar(0.0)).div(underlyingAtEvalTime);
65 |
66 | // Discounting...
67 | final RandomVariable numeraireAtMaturity = model.getNumeraire(maturity);
68 | final RandomVariable monteCarloWeights = model.getMonteCarloWeights(maturity);
69 | values = values.div(numeraireAtMaturity).mult(monteCarloWeights);
70 |
71 | // ...to evaluation time.
72 | final RandomVariable numeraireAtEvalTime = model.getNumeraire(evaluationTime);
73 | final RandomVariable monteCarloProbabilitiesAtEvalTime = model.getMonteCarloWeights(evaluationTime);
74 | values = values.mult(numeraireAtEvalTime).div(monteCarloProbabilitiesAtEvalTime);
75 |
76 | return values;
77 | }
78 | }
79 |
--------------------------------------------------------------------------------
/src/main/java/net/finmath/experiments/montecarlo/assetderivativevaluation/products/EuropeanOptionGammaLikelihood.java:
--------------------------------------------------------------------------------
1 | /*
2 | * (c) Copyright Christian P. Fries, Germany. All rights reserved. Contact: email@christian-fries.de.
3 | *
4 | * Created on 12.02.2013
5 | */
6 | package net.finmath.experiments.montecarlo.assetderivativevaluation.products;
7 |
8 | import net.finmath.exception.CalculationException;
9 | import net.finmath.montecarlo.assetderivativevaluation.AssetModelMonteCarloSimulationModel;
10 | import net.finmath.montecarlo.assetderivativevaluation.MonteCarloBlackScholesModel;
11 | import net.finmath.montecarlo.assetderivativevaluation.products.AbstractAssetMonteCarloProduct;
12 | import net.finmath.stochastic.RandomVariable;
13 | import net.finmath.stochastic.RandomVariableAccumulator;
14 |
15 | /**
16 | * Implements calculation of the delta of a European option.
17 | *
18 | * @author Christian Fries
19 | * @version 1.0
20 | */
21 | public class EuropeanOptionGammaLikelihood extends AbstractAssetMonteCarloProduct {
22 |
23 | private final double maturity;
24 | private final double strike;
25 |
26 | private final boolean isLikelihoodByFiniteDifference = false;
27 |
28 | /**
29 | * Construct a product representing an European option on an asset S (where S the asset with index 0 from the model - single asset case).
30 | *
31 | * @param strike The strike K in the option payoff max(S(T)-K,0).
32 | * @param maturity The maturity T in the option payoff max(S(T)-K,0)
33 | */
34 | public EuropeanOptionGammaLikelihood(double maturity, double strike) {
35 | super();
36 | this.maturity = maturity;
37 | this.strike = strike;
38 | }
39 |
40 | /**
41 | * Calculates the value of the option under a given model.
42 | *
43 | * @param model A reference to a model
44 | * @return the value
45 | * @throws CalculationException
46 | */
47 | public double getValue(AssetModelMonteCarloSimulationModel model) throws CalculationException
48 | {
49 | MonteCarloBlackScholesModel blackScholesModel = null;
50 | try {
51 | blackScholesModel = (MonteCarloBlackScholesModel)model;
52 | }
53 | catch(final Exception e) {
54 | throw new ClassCastException("This method requires a Black-Scholes type model (MonteCarloBlackScholesModel).");
55 | }
56 |
57 | // Get underlying and numeraire
58 | final RandomVariable underlyingAtMaturity = model.getAssetValue(maturity,0);
59 | final RandomVariable numeraireAtMaturity = model.getNumeraire(maturity);
60 | final RandomVariable underlyingAtToday = model.getAssetValue(0.0,0);
61 | final RandomVariable numeraireAtToday = model.getNumeraire(0);
62 | final RandomVariable monteCarloWeights = model.getMonteCarloWeights(maturity);
63 |
64 | /*
65 | * The following way of calculating the expected value (average) is discouraged since it makes too strong
66 | * assumptions on the internals of the RandomVariable. Instead you should use
67 | * the mutators sub, div, mult and the getter getAverage. This code is provided for illustrative purposes.
68 | */
69 | double average = 0.0;
70 | for(int path=0; pathRandomVariableAccumulator. Instead you should use
64 | * the mutators sub, div, mult and the getter getAverage. This code is provided for illustrative purposes.
65 | */
66 | double average = 0.0;
67 | for(int path=0; pathRandomVariableAccumulator. Instead you should use
65 | * the mutators sub, div, mult and the getter getAverage. This code is provided for illustrative purposes.
66 | */
67 | double average = 0.0;
68 | for(int path=0; pathRandomVariableAccumulator. Instead you should use
67 | * the mutators sub, div, mult and the getter getAverage. This code is provided for illustrative purposes.
68 | */
69 | double average = 0.0;
70 | for(int path=0; pathRandomVariableAccumulator. Instead you should use
65 | * the mutators sub, div, mult and the getter getAverage. This code is provided for illustrative purposes.
66 | */
67 | double average = 0.0;
68 | for(int path=0; pathcause() method.
87 | */
88 | @Override
89 | public RandomVariable getValue(final double evaluationTime, final TermStructureMonteCarloSimulationModel model) throws CalculationException {
90 |
91 | // Get random variables
92 | final RandomVariable forwardRate = model.getForwardRate(fixingTime, periodStartTime, periodEndTime);
93 | final RandomVariable numeraire = model.getNumeraire(paymentTime);
94 | final RandomVariable monteCarloProbabilities = model.getMonteCarloWeights(periodStartTime);
95 |
96 | RandomVariable values = forwardRate.mult(daycountFraction);
97 |
98 | values = values.div(numeraire).mult(monteCarloProbabilities);
99 |
100 | final RandomVariable numeraireAtValuationTime = model.getNumeraire(evaluationTime);
101 | final RandomVariable monteCarloProbabilitiesAtValuationTime = model.getMonteCarloWeights(evaluationTime);
102 | values = values.mult(numeraireAtValuationTime).div(monteCarloProbabilitiesAtValuationTime);
103 |
104 | return values;
105 | }
106 | }
107 |
--------------------------------------------------------------------------------
/src/main/java/net/finmath/experiments/montecarlo/interestrates/package-info.java:
--------------------------------------------------------------------------------
1 | /**
2 | * Monte Carlo methods for interest rate products
3 | *
4 | * @author Christian Fries
5 | */
6 | package net.finmath.experiments.montecarlo.interestrates;
7 |
--------------------------------------------------------------------------------
/src/main/java/net/finmath/experiments/montecarlo/package-info.java:
--------------------------------------------------------------------------------
1 | /**
2 | * Experiments related to Monte Carlo methods.
3 | *
4 | * @author Christian Fries
5 | */
6 | package net.finmath.experiments.montecarlo;
7 |
--------------------------------------------------------------------------------
/src/main/java/net/finmath/experiments/montecarlo/randomnumbers/HaltonSequence.java:
--------------------------------------------------------------------------------
1 | /*
2 | * (c) Copyright Christian P. Fries, Germany. All rights reserved. Contact: email@christian-fries.de.
3 | *
4 | * Created on 18.10.2012
5 | */
6 | package net.finmath.experiments.montecarlo.randomnumbers;
7 |
8 | /**
9 | * This class represents a Halton sequence (a low discrepancy sequence), or equivalently a vector of
10 | * Van der Corput sequences. For a given base b the van der Corput sequence is given by
11 | * 12 | * 13 | * xi = Σx1 ≤ j ≤ i ai,j b-j 14 | * 15 | *
16 | * where ai,j is such that 17 | *
18 | * 19 | * i = Σx1 ≤ j ≤ i ai,j bj-1 20 | * 21 | * 22 | * 23 | * @author Christian Fries 24 | */ 25 | public class HaltonSequence { 26 | 27 | private final int[] baseVector; 28 | 29 | /** 30 | * Construct a Halton sequence with d = base.length dimensions where the i-th component 31 | * uses base[i] as base of the corresponding van der Corput sequence. 32 | * 33 | * @param baseVector Vector of base integers for each component. 34 | */ 35 | public HaltonSequence(int[] baseVector) { 36 | // Check base 37 | for(final int base : baseVector) { 38 | if(base < 2) { 39 | throw new RuntimeException("Cannot create Halton sequence with base less than two."); 40 | } 41 | } 42 | 43 | this.baseVector = baseVector; 44 | } 45 | 46 | /** 47 | * Construct a one dimensional Halton sequence (Van der Corput sequence) with given base. 48 | * 49 | * @param base Base of the sequence. 50 | */ 51 | public HaltonSequence(int base) { 52 | // Check base 53 | if(base < 2) { 54 | throw new RuntimeException("Cannot create Halton sequence with base less than two."); 55 | } 56 | 57 | this.baseVector = new int[] { base }; 58 | } 59 | 60 | /** 61 | * Print the first 1000 Halton numbers for base b = (2,3). 62 | * 63 | * @param args 64 | */ 65 | public static void main(String[] args) { 66 | System.out.println("Halton sequence (base b = (2,3)):"); 67 | for(int i=0; i<1000; i++) { 68 | System.out.println("" + getHaltonNumber(i, 2) + "\t" + getHaltonNumber(i, 3)); 69 | } 70 | } 71 | 72 | /** 73 | * Get Halton number for given index. 74 | * 75 | * @param index Index of the Halton number. 76 | * @return Halton number (vector). 77 | */ 78 | public double[] getHaltonNumber(long index) { 79 | final double[] x = new double[baseVector.length]; 80 | for(int baseIndex=0; baseIndex < baseVector.length; baseIndex++) { 81 | x[baseIndex] = getHaltonNumber(index, baseVector[baseIndex]); 82 | } 83 | return x; 84 | } 85 | 86 | /** 87 | * Get Halton number for given index and base. 88 | * 89 | * @param index Index of the Halton number (starting at 0). 90 | * @param base Base of the Halton number. 91 | * @return Halton number. 92 | */ 93 | public static double getHaltonNumber(long index, int base) { 94 | // Check base 95 | if(base < 2) { 96 | throw new RuntimeException("Cannot create Halton number with base less than two."); 97 | } 98 | if(index < 0) { 99 | throw new RuntimeException("Cannot create Halton number with index less than zero."); 100 | } 101 | 102 | // Index shift: counting of the function starts at 0, algorithm below starts at 1. 103 | index++; 104 | 105 | // Calculate Halton number x 106 | double x = 0; 107 | double factor = 1.0/base; 108 | while(index > 0) { 109 | x += (index % base) * factor; 110 | factor /= base; 111 | index /= base; 112 | } 113 | return x; 114 | } 115 | } 116 | -------------------------------------------------------------------------------- /src/main/java/net/finmath/experiments/montecarlo/randomnumbers/PseudoRandomNumberSequence.java: -------------------------------------------------------------------------------- 1 | /* 2 | * (c) Copyright Christian P. Fries, Germany. All rights reserved. Contact: email@christian-fries.de. 3 | * 4 | * Created on 25.10.2012 5 | */ 6 | package net.finmath.experiments.montecarlo.randomnumbers; 7 | 8 | import java.util.Random; 9 | 10 | import net.finmath.randomnumbers.MersenneTwister; 11 | 12 | /** 13 | * @author Christian Fries 14 | */ 15 | public class PseudoRandomNumberSequence { 16 | 17 | enum RandomNumberGeneratorType { 18 | LCG_JAVA, 19 | MERSENNE_TWISTER 20 | } 21 | 22 | private final RandomNumberGeneratorType type; 23 | private final long seed; 24 | private final int length; 25 | private double[] randomNumbers; 26 | 27 | 28 | /** 29 | * Create a random number sequence using a specified generator, seed and length. 30 | * Note: The sequence is pre-calculated and stored in memory to allow random access. 31 | * 32 | * @param type Random number generator to use. 33 | * @param seed Seed of the generator. 34 | * @param length Length of the sequence. 35 | */ 36 | public PseudoRandomNumberSequence(RandomNumberGeneratorType type, long seed, int length) { 37 | super(); 38 | this.type = type; 39 | this.seed = seed; 40 | this.length = length; 41 | } 42 | 43 | /** 44 | * Create a random number sequence using a specified generator, seed and length. 45 | * Note: The sequence is pre-calculated and stored in memory to allow random access. 46 | * Using a Mersenne Twister as default. 47 | * 48 | * @param seed Seed of the generator. 49 | * @param length Length of the sequence. 50 | */ 51 | public PseudoRandomNumberSequence(long seed, int length) { 52 | super(); 53 | this.type = RandomNumberGeneratorType.MERSENNE_TWISTER; 54 | this.seed = seed; 55 | this.length = length; 56 | } 57 | 58 | public double getRandomNumber(int index) { 59 | if(randomNumbers == null || randomNumbers.length < length) { 60 | initRandomNumbers(); 61 | } 62 | return randomNumbers[index]; 63 | } 64 | 65 | private void initRandomNumbers() { 66 | randomNumbers = new double[length]; 67 | 68 | // Create random number sequence 69 | switch(type) { 70 | case LCG_JAVA: 71 | final Random lcgJava = new Random(seed); 72 | for(int numberIndex=0; numberIndex < length; numberIndex++) { 73 | randomNumbers[numberIndex] = lcgJava.nextDouble(); 74 | } 75 | break; 76 | case MERSENNE_TWISTER: 77 | default: 78 | final MersenneTwister mersenneTwister = new MersenneTwister(seed); 79 | for(int numberIndex=0; numberIndex < length; numberIndex++) { 80 | randomNumbers[numberIndex] = mersenneTwister.nextDouble(); 81 | } 82 | break; 83 | } 84 | } 85 | } 86 | -------------------------------------------------------------------------------- /src/main/java/net/finmath/experiments/montecarlo/randomnumbers/package-info.java: -------------------------------------------------------------------------------- 1 | /** 2 | * Experiments related to random number generation. 3 | * 4 | * @author Christian Fries 5 | */ 6 | package net.finmath.experiments.montecarlo.randomnumbers; 7 | -------------------------------------------------------------------------------- /src/main/java/net/finmath/experiments/montecarlo/schemes/LogProcessEulerScheme.java: -------------------------------------------------------------------------------- 1 | /* 2 | * (c) Copyright Christian P. Fries, Germany. All rights reserved. Contact: email@christian-fries.de. 3 | * 4 | * Created on 20.12.2003 5 | */ 6 | package net.finmath.experiments.montecarlo.schemes; 7 | 8 | import net.finmath.montecarlo.BrownianMotion; 9 | import net.finmath.montecarlo.BrownianMotionFromMersenneRandomNumbers; 10 | import net.finmath.montecarlo.RandomVariableFromDoubleArray; 11 | import net.finmath.stochastic.RandomVariable; 12 | import net.finmath.time.TimeDiscretization; 13 | import net.finmath.time.TimeDiscretizationFromArray; 14 | 15 | /** 16 | * Monte-Carlo simulation of a time-discrete process. 17 | * Time discretization of a log-normal process using the Euler scheme. 18 | * 19 | * Note: We do not use RandomVariable for the arithmetics. This is just for didactical reasons. 20 | * 21 | * @author Christian Fries 22 | */ 23 | public class LogProcessEulerScheme implements LognormalProcess 24 | { 25 | private final int numberOfTimeSteps; 26 | private final double deltaT; 27 | private final int numberOfPaths; 28 | private final double initialValue; 29 | private final double mu; 30 | private final double sigma; 31 | 32 | private RandomVariable[] discreteProcess = null; 33 | 34 | /** 35 | * Create a Euler scheme on X. 36 | * 37 | * @param numberOfTimeSteps The number of time steps. 38 | * @param deltaT The time step size. 39 | * @param numberOfPaths The number of Monte-Carlo paths. 40 | * @param initialValue The initial value. 41 | * @param mu The parameter mu (the drift). 42 | * @param sigma The parameter sigma. 43 | */ 44 | public LogProcessEulerScheme( 45 | int numberOfTimeSteps, 46 | double deltaT, 47 | int numberOfPaths, 48 | double initialValue, 49 | double mu, 50 | double sigma) { 51 | super(); 52 | this.numberOfTimeSteps = numberOfTimeSteps; 53 | this.deltaT = deltaT; 54 | this.numberOfPaths = numberOfPaths; 55 | this.initialValue = initialValue; 56 | this.mu = mu; 57 | this.sigma = sigma; 58 | } 59 | 60 | @Override 61 | public RandomVariable getProcessValue(int timeIndex) 62 | { 63 | if(discreteProcess == null) 64 | { 65 | doPrecalculateProcess(); 66 | } 67 | 68 | // Return value of process 69 | return discreteProcess[timeIndex]; 70 | } 71 | 72 | /** 73 | * Calculates the whole (discrete) process. 74 | */ 75 | private void doPrecalculateProcess() { 76 | 77 | final TimeDiscretization timeDiscretization = new TimeDiscretizationFromArray( 78 | 0.0 /* initial */, getNumberOfTimeSteps(), getDeltaT()); 79 | 80 | final BrownianMotion brownianMotion = new BrownianMotionFromMersenneRandomNumbers( 81 | timeDiscretization, 1 /* numberOfFactors */, getNumberOfPaths(), 31415 /* seed */); 82 | 83 | // Allocate Memory 84 | discreteProcess = new RandomVariable[getNumberOfTimeSteps()+1]; 85 | 86 | for(int timeIndex = 0; timeIndex < getNumberOfTimeSteps()+1; timeIndex++) 87 | { 88 | final double[] newRealization = new double[numberOfPaths]; 89 | 90 | // Generate process at timeIndex 91 | if(timeIndex == 0) 92 | { 93 | // Set initial value 94 | for (int iPath = 0; iPath < numberOfPaths; iPath++ ) 95 | { 96 | newRealization[iPath] = initialValue; 97 | } 98 | } 99 | else 100 | { 101 | // The numerical scheme 102 | final RandomVariable previouseRealization = discreteProcess[timeIndex-1]; 103 | final RandomVariable deltaW = brownianMotion.getBrownianIncrement(timeIndex-1, 0); 104 | 105 | // Generate values 106 | for (int iPath = 0; iPath < numberOfPaths; iPath++ ) 107 | { 108 | // Drift 109 | final double drift = mu * deltaT; 110 | 111 | // Diffusion 112 | final double diffusion = sigma * deltaW.get(iPath); 113 | 114 | // Previous value 115 | final double previousValue = previouseRealization.get(iPath); 116 | 117 | // Numerical scheme 118 | final double newValue = previousValue + previousValue * drift + previousValue * diffusion; 119 | 120 | // Store new value 121 | newRealization[iPath] = newValue; 122 | } 123 | } 124 | 125 | // Store values 126 | discreteProcess[timeIndex] = new RandomVariableFromDoubleArray(timeIndex, newRealization); 127 | } 128 | } 129 | 130 | /** 131 | * Returns the time step size deltaT. 132 | * 133 | * @return the time step size deltaT. 134 | */ 135 | @Override 136 | public double getDeltaT() { 137 | return deltaT; 138 | } 139 | 140 | /** 141 | * Returns the initial value. 142 | * 143 | * @return the initial value. 144 | */ 145 | @Override 146 | public double getInitialValue() { 147 | return initialValue; 148 | } 149 | 150 | /** 151 | * Returns the number of paths. 152 | * 153 | * @return the number of paths. 154 | */ 155 | @Override 156 | public int getNumberOfPaths() { 157 | return numberOfPaths; 158 | } 159 | 160 | /** 161 | * Returns the number of time steps. 162 | * 163 | * @return the number of time steps. 164 | */ 165 | @Override 166 | public int getNumberOfTimeSteps() { 167 | return numberOfTimeSteps; 168 | } 169 | 170 | /** 171 | * Returns the log-normal drift μ. 172 | * 173 | * @return the log-normal drift μ. 174 | */ 175 | @Override 176 | public double getDrift() { 177 | return mu; 178 | } 179 | 180 | /** 181 | * Returns the log-normal volatiltiy σ. 182 | * 183 | * @return the log-normal volatiltiy σ. 184 | */ 185 | @Override 186 | public double getSigma() { 187 | return sigma; 188 | } 189 | } 190 | -------------------------------------------------------------------------------- /src/main/java/net/finmath/experiments/montecarlo/schemes/LogProcessLogEulerScheme.java: -------------------------------------------------------------------------------- 1 | /* 2 | * (c) Copyright Christian P. Fries, Germany. All rights reserved. Contact: email@christian-fries.de. 3 | * 4 | * Created on 16.01.2004 5 | */ 6 | package net.finmath.experiments.montecarlo.schemes; 7 | 8 | import net.finmath.montecarlo.BrownianMotion; 9 | import net.finmath.montecarlo.BrownianMotionFromMersenneRandomNumbers; 10 | import net.finmath.montecarlo.RandomVariableFromDoubleArray; 11 | import net.finmath.stochastic.RandomVariable; 12 | import net.finmath.time.TimeDiscretization; 13 | import net.finmath.time.TimeDiscretizationFromArray; 14 | 15 | /** 16 | * Monte-Carlo simulation of a time-discrete process. 17 | * Time discretization of a log-normal process using the Log-Euler scheme. 18 | * 19 | * Note: We do not use RandomVariable for the arithmetics. This is just for didactical reasons. 20 | * 21 | * @author Christian Fries 22 | */ 23 | public class LogProcessLogEulerScheme implements LognormalProcess 24 | { 25 | private final int numberOfTimeSteps; 26 | private final double deltaT; 27 | private final int numberOfPaths; 28 | private final double initialValue; 29 | private final double mu; 30 | private final double sigma; 31 | 32 | private RandomVariable[] discreteProcess = null; 33 | 34 | /** 35 | * Create a Euler scheme on log(X). 36 | * 37 | * @param numberOfTimeSteps The number of time steps. 38 | * @param deltaT The time step size. 39 | * @param numberOfPaths The number of Monte-Carlo paths. 40 | * @param initialValue The initial value. 41 | * @param mu The parameter mu (the drift). 42 | * @param sigma The parameter sigma. 43 | */ 44 | public LogProcessLogEulerScheme( 45 | int numberOfTimeSteps, 46 | double deltaT, 47 | int numberOfPaths, 48 | double initialValue, 49 | double mu, 50 | double sigma) { 51 | super(); 52 | this.numberOfTimeSteps = numberOfTimeSteps; 53 | this.deltaT = deltaT; 54 | this.numberOfPaths = numberOfPaths; 55 | this.initialValue = initialValue; 56 | this.mu = mu; 57 | this.sigma = sigma; 58 | } 59 | 60 | @Override 61 | public RandomVariable getProcessValue(int timeIndex) 62 | { 63 | if(discreteProcess == null) 64 | { 65 | doPrecalculateProcess(); 66 | } 67 | 68 | // Return value of process 69 | return discreteProcess[timeIndex]; 70 | } 71 | 72 | /** 73 | * Calculates the whole (discrete) process. 74 | */ 75 | private void doPrecalculateProcess() { 76 | 77 | final TimeDiscretization timeDiscretization = new TimeDiscretizationFromArray( 78 | 0.0 /* initial */, getNumberOfTimeSteps(), getDeltaT()); 79 | 80 | final BrownianMotion brownianMotion = new BrownianMotionFromMersenneRandomNumbers( 81 | timeDiscretization, 1 /* numberOfFactors */, getNumberOfPaths(), 31415 /* seed */); 82 | 83 | // Allocate Memory 84 | discreteProcess = new RandomVariable[getNumberOfTimeSteps()+1]; 85 | 86 | for(int timeIndex = 0; timeIndex < getNumberOfTimeSteps()+1; timeIndex++) 87 | { 88 | final double[] newRealization = new double[numberOfPaths]; 89 | 90 | // Generate process at timeIndex 91 | if(timeIndex == 0) 92 | { 93 | // Set initial value 94 | for (int iPath = 0; iPath < numberOfPaths; iPath++ ) 95 | { 96 | newRealization[iPath] = initialValue; 97 | } 98 | } 99 | else 100 | { 101 | // Euler Scheme 102 | final RandomVariable previouseRealization = discreteProcess[timeIndex-1]; 103 | final RandomVariable deltaW = brownianMotion.getBrownianIncrement(timeIndex-1, 0); 104 | 105 | // Generate values 106 | for (int iPath = 0; iPath < numberOfPaths; iPath++ ) 107 | { 108 | // Drift 109 | final double drift = mu * deltaT; 110 | 111 | // Diffusion 112 | final double diffusion = sigma * deltaW.get(iPath); 113 | 114 | // Previous value 115 | final double previousValue = previouseRealization.get(iPath); 116 | 117 | // Numerical scheme 118 | final double newValue = previousValue * Math.exp(drift - 0.5 * sigma * sigma * deltaT + diffusion); 119 | 120 | // Store new value 121 | newRealization[iPath] = newValue; 122 | } 123 | } 124 | 125 | // Store values 126 | discreteProcess[timeIndex] = new RandomVariableFromDoubleArray(timeIndex, newRealization); 127 | } 128 | } 129 | 130 | /** 131 | * Returns the time step size deltaT. 132 | * 133 | * @return the time step size deltaT. 134 | */ 135 | @Override 136 | public double getDeltaT() { 137 | return deltaT; 138 | } 139 | 140 | /** 141 | * Returns the initial value. 142 | * 143 | * @return the initial value. 144 | */ 145 | @Override 146 | public double getInitialValue() { 147 | return initialValue; 148 | } 149 | 150 | /** 151 | * Returns the number of paths. 152 | * 153 | * @return the number of paths. 154 | */ 155 | @Override 156 | public int getNumberOfPaths() { 157 | return numberOfPaths; 158 | } 159 | 160 | /** 161 | * Returns the number of time steps. 162 | * 163 | * @return the number of time steps. 164 | */ 165 | @Override 166 | public int getNumberOfTimeSteps() { 167 | return numberOfTimeSteps; 168 | } 169 | 170 | /** 171 | * Returns the log-normal drift μ. 172 | * 173 | * @return the log-normal drift μ. 174 | */ 175 | @Override 176 | public double getDrift() { 177 | return mu; 178 | } 179 | 180 | /** 181 | * Returns the log-normal volatiltiy σ. 182 | * 183 | * @return the log-normal volatiltiy σ. 184 | */ 185 | @Override 186 | public double getSigma() { 187 | return sigma; 188 | } 189 | } 190 | -------------------------------------------------------------------------------- /src/main/java/net/finmath/experiments/montecarlo/schemes/LogProcessMilsteinScheme.java: -------------------------------------------------------------------------------- 1 | /* 2 | * (c) Copyright Christian P. Fries, Germany. All rights reserved. Contact: email@christian-fries.de. 3 | * 4 | * Created on 16.01.2004 5 | */ 6 | package net.finmath.experiments.montecarlo.schemes; 7 | 8 | import net.finmath.montecarlo.BrownianMotion; 9 | import net.finmath.montecarlo.BrownianMotionFromMersenneRandomNumbers; 10 | import net.finmath.montecarlo.RandomVariableFromDoubleArray; 11 | import net.finmath.stochastic.RandomVariable; 12 | import net.finmath.time.TimeDiscretization; 13 | import net.finmath.time.TimeDiscretizationFromArray; 14 | 15 | /** 16 | * Monte-Carlo simulation of a time-discrete process. 17 | * Time discretization of a log-normal process using the Milstein scheme. 18 | * 19 | * Note: We do not use RandomVariable for the arithmetics. This is just for didactical reasons. 20 | * 21 | * @author Christian Fries 22 | */ 23 | public class LogProcessMilsteinScheme implements LognormalProcess 24 | { 25 | private final int numberOfTimeSteps; 26 | private final double deltaT; 27 | private final int numberOfPaths; 28 | private final double initialValue; 29 | private final double mu; 30 | private final double sigma; 31 | 32 | private RandomVariable[] discreteProcess = null; 33 | 34 | /** 35 | * Create a Milstein scheme on X. 36 | * 37 | * @param numberOfTimeSteps The number of time steps. 38 | * @param deltaT The time step size. 39 | * @param numberOfPaths The number of Monte-Carlo paths. 40 | * @param initialValue The initial value. 41 | * @param mu The parameter mu (the drift). 42 | * @param sigma The parameter sigma. 43 | */ 44 | public LogProcessMilsteinScheme( 45 | int numberOfTimeSteps, 46 | double deltaT, 47 | int numberOfPaths, 48 | double initialValue, 49 | double mu, 50 | double sigma) { 51 | super(); 52 | this.numberOfTimeSteps = numberOfTimeSteps; 53 | this.deltaT = deltaT; 54 | this.numberOfPaths = numberOfPaths; 55 | this.initialValue = initialValue; 56 | this.mu = mu; 57 | this.sigma = sigma; 58 | } 59 | 60 | @Override 61 | public RandomVariable getProcessValue(int timeIndex) 62 | { 63 | if(discreteProcess == null) 64 | { 65 | doPrecalculateProcess(); 66 | } 67 | 68 | // Return value of process 69 | return discreteProcess[timeIndex]; 70 | } 71 | 72 | /** 73 | * Calculates the whole (discrete) process. 74 | */ 75 | private void doPrecalculateProcess() { 76 | 77 | final TimeDiscretization timeDiscretization = new TimeDiscretizationFromArray( 78 | 0.0 /* initial */, getNumberOfTimeSteps(), getDeltaT()); 79 | 80 | final BrownianMotion brownianMotion = new BrownianMotionFromMersenneRandomNumbers( 81 | timeDiscretization, 1 /* numberOfFactors */, getNumberOfPaths(), 31415 /* seed */); 82 | 83 | // Allocate Memory 84 | discreteProcess = new RandomVariable[getNumberOfTimeSteps()+1]; 85 | 86 | for(int timeIndex = 0; timeIndex < getNumberOfTimeSteps()+1; timeIndex++) 87 | { 88 | final double[] newRealization = new double[numberOfPaths]; 89 | 90 | // Generate process at timeIndex 91 | if(timeIndex == 0) 92 | { 93 | // Set initial value 94 | for (int iPath = 0; iPath < numberOfPaths; iPath++ ) 95 | { 96 | newRealization[iPath] = initialValue; 97 | } 98 | } 99 | else 100 | { 101 | // Milstein Scheme 102 | final RandomVariable previouseRealization = discreteProcess[timeIndex-1]; 103 | final RandomVariable deltaW = brownianMotion.getBrownianIncrement(timeIndex-1, 0); 104 | 105 | // Generate values 106 | for (int iPath = 0; iPath < numberOfPaths; iPath++ ) 107 | { 108 | // Drift 109 | final double drift = mu * deltaT; 110 | 111 | // Diffusion 112 | final double diffusion = sigma * deltaW.get(iPath); 113 | 114 | // Previous value 115 | final double previousValue = previouseRealization.get(iPath); 116 | 117 | // Numerical scheme 118 | final double newValue = previousValue + previousValue * drift + previousValue * diffusion // Euler step 119 | + 1.0/2.0 * previousValue * sigma * sigma * (deltaW.get(iPath) * deltaW.get(iPath) - deltaT); // Milstein correction 120 | 121 | // Store new value 122 | newRealization[iPath] = newValue; 123 | } 124 | } 125 | 126 | // Store values 127 | discreteProcess[timeIndex] = new RandomVariableFromDoubleArray(timeIndex, newRealization); 128 | } 129 | } 130 | 131 | /** 132 | * Returns the time step size deltaT. 133 | * 134 | * @return the time step size deltaT. 135 | */ 136 | @Override 137 | public double getDeltaT() { 138 | return deltaT; 139 | } 140 | 141 | /** 142 | * Returns the initial value. 143 | * 144 | * @return the initial value. 145 | */ 146 | @Override 147 | public double getInitialValue() { 148 | return initialValue; 149 | } 150 | 151 | /** 152 | * Returns the number of paths. 153 | * 154 | * @return the number of paths. 155 | */ 156 | @Override 157 | public int getNumberOfPaths() { 158 | return numberOfPaths; 159 | } 160 | 161 | /** 162 | * Returns the number of time steps. 163 | * 164 | * @return the number of time steps. 165 | */ 166 | @Override 167 | public int getNumberOfTimeSteps() { 168 | return numberOfTimeSteps; 169 | } 170 | 171 | /** 172 | * Returns the log-normal drift μ. 173 | * 174 | * @return the log-normal drift μ. 175 | */ 176 | @Override 177 | public double getDrift() { 178 | return mu; 179 | } 180 | 181 | /** 182 | * Returns the log-normal volatiltiy σ. 183 | * 184 | * @return the log-normal volatiltiy σ. 185 | */ 186 | @Override 187 | public double getSigma() { 188 | return sigma; 189 | } 190 | } 191 | -------------------------------------------------------------------------------- /src/main/java/net/finmath/experiments/montecarlo/schemes/LognormalProcess.java: -------------------------------------------------------------------------------- 1 | package net.finmath.experiments.montecarlo.schemes; 2 | 3 | import net.finmath.stochastic.RandomVariable; 4 | 5 | /** 6 | * Interface for classes that implement different time discrete approximations 7 | * \[ 8 | * i \mapsto \tilde{X}(t_{i}) 9 | * \] 10 | * of the lognormal process 11 | * \[ 12 | * dX(t) = mu X(t) dt + sigma X(t) dW(t), X(0) = X_0 13 | * \] 14 | * with a given time discretization 15 | * \[ 16 | * 0 = t_{0} < t_{1} < ... < t_{n} 17 | * \] 18 | * 19 | * @author Christian Fries 20 | * 21 | */ 22 | public interface LognormalProcess { 23 | 24 | /** 25 | * Returns the approximation \tilde{X}(t_{i}) as a sample vector. 26 | * 27 | * @param timeIndex The time index i 28 | * @return The RandomVariable \tilde{X}(t_{i}) 29 | */ 30 | RandomVariable getProcessValue(int timeIndex); 31 | 32 | /** 33 | * Returns E(X(t_i)) - the average of the random variable given by the process at the given time index. 34 | * 35 | * @param timeIndex The time index 36 | * @return The average 37 | */ 38 | default double getExpectation(int timeIndex) { 39 | return getProcessValue(timeIndex).getAverage(); 40 | } 41 | 42 | /** 43 | * Returns E(log(X(t_i))) 44 | * 45 | * @param timeIndex The time index 46 | * @return The average of log(X) 47 | */ 48 | default double getExpectationOfLog(int timeIndex) { 49 | return getProcessValue(timeIndex).log().getAverage(); 50 | } 51 | 52 | /** 53 | * Returns Variance(log(X(t_i))) 54 | * 55 | * @param timeIndex The time index 56 | * @return The variance of log(X) 57 | */ 58 | default double getVarianceOfLog(int timeIndex) { 59 | return getProcessValue(timeIndex).log().getVariance(); 60 | } 61 | 62 | /** 63 | * @return Returns the nPaths. 64 | */ 65 | int getNumberOfPaths(); 66 | 67 | /** 68 | * @return Returns the numberOfTimeSteps. 69 | */ 70 | int getNumberOfTimeSteps(); 71 | 72 | /** 73 | * @return Returns the deltaT. 74 | */ 75 | double getDeltaT(); 76 | 77 | /** 78 | * @return Returns the initialValue. 79 | */ 80 | double getInitialValue(); 81 | 82 | /** 83 | * @return Returns the mu. 84 | */ 85 | double getDrift(); 86 | 87 | /** 88 | * @return Returns the sigma. 89 | */ 90 | double getSigma(); 91 | } -------------------------------------------------------------------------------- /src/main/java/net/finmath/experiments/montecarlo/schemes/MonteCarloSchemeTests.java: -------------------------------------------------------------------------------- 1 | /* 2 | * (c) Copyright Christian P. Fries, Germany. All rights reserved. Contact: email@christian-fries.de. 3 | * 4 | * Created on 15.01.2004 5 | */ 6 | 7 | package net.finmath.experiments.montecarlo.schemes; 8 | 9 | import java.text.DecimalFormat; 10 | 11 | /** 12 | * Testing the behaviour of some time discretization schemes w.r.t. time step size. 13 | * 14 | * @author Christian Fries 15 | */ 16 | public class MonteCarloSchemeTests { 17 | 18 | public static void main(String[] args) 19 | { 20 | System.out.println("Checking the mean (m) and the variance (V) of the terminal distribution of log(S(T)).\n" 21 | +"Generated using different numerical scheme for S (comparing to the analytic values).\n" 22 | + "\n" 23 | + "Output shows the error \u0394m (error on mean) and \u0394V (error on variance) comparing to theoretical mean and variance at time T.\n"); 24 | 25 | final double initialValue = 1.0; 26 | final double mu = 0.0; 27 | final double sigma = 0.5; // Note: Try different sigmas: 0.2, 0.5, 0.7, 0.9 28 | final int numberOfPath = 100000; // Note: Try different number of path. For 10000000 you need around 6 GB (parameter is -mx6G) 29 | final double lastTime = 10.0; 30 | 31 | for(int numberOfTimeSteps=1; numberOfTimeSteps<=1001; numberOfTimeSteps+=10) 32 | { 33 | final double deltaT = lastTime/numberOfTimeSteps; 34 | 35 | // Create an instance of the Euler scheme class 36 | final LognormalProcess eulerScheme = new LogProcessEulerScheme( 37 | numberOfTimeSteps, // numberOfTimeSteps 38 | deltaT, // deltaT 39 | numberOfPath, // numberOfPaths 40 | initialValue, // initialValue 41 | mu, // mu (drift) 42 | sigma); // sigma (volatility) 43 | 44 | // Create an instance of the Milstein scheme class 45 | final LognormalProcess milsteinScheme = new LogProcessMilsteinScheme( 46 | numberOfTimeSteps, // numberOfTimeSteps 47 | deltaT, // deltaT 48 | numberOfPath, // numberOfPaths 49 | initialValue, // initialValue 50 | mu, // mu (drift) 51 | sigma); // sigma (volatility) 52 | 53 | // Create an instance of the Log-Euler scheme class 54 | final LognormalProcess logEulerScheme = new LogProcessLogEulerScheme( 55 | numberOfTimeSteps, // numberOfTimeSteps 56 | deltaT, // deltaT 57 | numberOfPath, // numberOfPaths 58 | initialValue, // initialValue 59 | mu, // mu (drift) 60 | sigma); // sigma (volatility) 61 | 62 | // Get start time of calculation 63 | final double startMillis = System.currentTimeMillis(); 64 | 65 | final int lastTimeIndex = eulerScheme.getNumberOfTimeSteps(); 66 | 67 | final double averageEuler = eulerScheme.getExpectationOfLog( lastTimeIndex ); 68 | final double averageMilstein = milsteinScheme.getExpectationOfLog( lastTimeIndex ); 69 | final double averageLogEuler = logEulerScheme.getExpectationOfLog( lastTimeIndex ); 70 | final double averageAnalytic = Math.log(initialValue) + (mu - 0.5 * sigma * sigma) * (lastTimeIndex * deltaT); 71 | 72 | final double varianceEuler = eulerScheme.getVarianceOfLog( lastTimeIndex ); 73 | final double varianceMilstein = milsteinScheme.getVarianceOfLog( lastTimeIndex ); 74 | final double varianceLogEuler = logEulerScheme.getVarianceOfLog( lastTimeIndex ); 75 | final double varianceAnalytic = sigma * sigma * (lastTimeIndex * deltaT); 76 | 77 | // Get end time of calculation 78 | final double endMillis = System.currentTimeMillis(); 79 | 80 | final double calculationTimeInSeconds = ((float)( endMillis - startMillis )) / 1000.0; 81 | 82 | // Print result 83 | final DecimalFormat decimalFormatInteger = new DecimalFormat("000"); 84 | final double errorAverageEuler = Math.abs(averageEuler - averageAnalytic); 85 | final double errorVarianceEuler = Math.abs(varianceEuler - varianceAnalytic); 86 | final double errorAverageMilstein = Math.abs(averageMilstein - averageAnalytic); 87 | final double errorVarianceMilstein = Math.abs(varianceMilstein- varianceAnalytic); 88 | final double errorAverageLogEuler = Math.abs(averageLogEuler - averageAnalytic); 89 | final double errorVarianceLogEuler = Math.abs(varianceLogEuler- varianceAnalytic); 90 | 91 | System.out.print("nPath = " + numberOfPath); 92 | System.out.print("\tnSteps = " + decimalFormatInteger.format(numberOfTimeSteps)); 93 | System.out.print("\tEuler...: \u0394m=" + formatPercent(errorAverageEuler) + " \u0394V=" + formatPercent(errorVarianceEuler)); 94 | System.out.print("\tMilstein: \u0394m=" + formatPercent(errorAverageMilstein) + " \u0394V=" + formatPercent(errorVarianceMilstein)); 95 | System.out.print("\tLogEuler: \u0394m=" + formatPercent(errorAverageLogEuler) + " \u0394V=" + formatPercent(errorVarianceLogEuler)); 96 | System.out.println("\t(Time=" + calculationTimeInSeconds + " sec)." ); 97 | } 98 | } 99 | 100 | /* 101 | * Small helper to create nice output string. 102 | */ 103 | private static String formatInteger(int value) { 104 | return String.format("%4d", value); 105 | } 106 | 107 | /* 108 | * Small helper to create nice output string. 109 | */ 110 | private static String formatPercent(double value) { 111 | if(Double.isNaN(value)) { 112 | return "--NaN--"; 113 | } else { 114 | return String.format("%6.3f%%", value * 100); 115 | } 116 | } 117 | } 118 | -------------------------------------------------------------------------------- /src/main/java/net/finmath/experiments/montecarlo/schemes/package-info.java: -------------------------------------------------------------------------------- 1 | /** 2 | * Experiments related to time discretizations of SDEs. 3 | * These are used for illustration in a lecture. 4 | * 5 | * @author Christian Fries 6 | */ 7 | package net.finmath.experiments.montecarlo.schemes; 8 | -------------------------------------------------------------------------------- /src/main/java/net/finmath/experiments/optionvalueinterpolation/package-info.java: -------------------------------------------------------------------------------- 1 | /** 2 | * Experiments related to option value interpolation 3 | * 4 | * @author Christian Fries 5 | */ 6 | package net.finmath.experiments.optionvalueinterpolation; 7 | -------------------------------------------------------------------------------- /src/main/java/net/finmath/experiments/package-info.java: -------------------------------------------------------------------------------- 1 | /** 2 | * Experiments illustrating numerical methods, mathematics and the use of finmath lib 3 | * 4 | * @author Christian Fries 5 | */ 6 | package net.finmath.experiments; 7 | -------------------------------------------------------------------------------- /src/main/java/net/finmath/experiments/performance/package-info.java: -------------------------------------------------------------------------------- 1 | /** 2 | * Experiments related to performance of algorithms. 3 | * 4 | * @author Christian Fries 5 | */ 6 | package net.finmath.experiments.performance; 7 | -------------------------------------------------------------------------------- /src/main/java/net/finmath/experiments/randomnumbers/NormalViaICDFPlot.java: -------------------------------------------------------------------------------- 1 | package net.finmath.experiments.randomnumbers; 2 | 3 | import java.util.ArrayList; 4 | import java.util.List; 5 | 6 | import net.finmath.functions.NormalDistribution; 7 | import net.finmath.plots.Plots; 8 | import net.finmath.randomnumbers.MersenneTwister; 9 | import net.finmath.randomnumbers.RandomNumberGenerator1D; 10 | 11 | public class NormalViaICDFPlot { 12 | 13 | public static void main(String[] args) throws Exception { 14 | 15 | final int numberOfSamples = 100000; 16 | 17 | RandomNumberGenerator1D randomNumberGenerator = new MersenneTwister(3636); 18 | 19 | List