net.finmath.montecarlo.automaticdifferentiation.backward.alternative.RandomVariableAAD Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of finmath-lib Show documentation
Show all versions of finmath-lib Show documentation
finmath lib is a Mathematical Finance Library in Java.
It provides algorithms and methodologies related to mathematical finance.
/**
*
*/
package net.finmath.montecarlo.automaticdifferentiation.backward.alternative;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.function.DoubleBinaryOperator;
import java.util.function.DoubleUnaryOperator;
import java.util.function.IntToDoubleFunction;
import java.util.stream.DoubleStream;
import net.finmath.functions.DoubleTernaryOperator;
import net.finmath.montecarlo.RandomVariableFromDoubleArray;
import net.finmath.stochastic.RandomVariable;
/**
* Implementation of RandomVariable having the additional feature to calculate the backward algorithmic differentiation.
*
* For construction use the factory method constructNewAADRandomVariable.
*
* @author Stefan Sedlmair
* @version 1.0
*/
public class RandomVariableAAD implements RandomVariable {
private static final long serialVersionUID = 2459373647785530657L;
/* static elements of the class are shared between all members */
private static ArrayList arrayListOfAllAADRandomVariables = new ArrayList<>();
private static AtomicInteger indexOfNextRandomVariable = new AtomicInteger(0);
private enum OperatorType {
ADD, MULT, DIV, SUB, SQUARED, SQRT, LOG, SIN, COS, EXP, INVERT, CAP, FLOOR, ABS,
ADDPRODUCT, ADDRATIO, SUBRATIO, BARRIER, DISCOUNT, ACCRUE, POW, AVERAGE, VARIANCE,
STDEV, MIN, MAX, STDERROR, SVARIANCE
}
/* index of corresponding random variable in the static array list*/
private final RandomVariable ownRandomVariable;
private final int ownIndexInList;
/* this could maybe be outsourced to own class ParentElement */
private final int[] parentIndices;
private final OperatorType parentOperator;
private ArrayList childrenIndices;
private boolean isConstant;
/**
* @param indexOfRandomVariable
* @param parentRandomVariables
* @param parentOperator
* @param isConstant
*/
private RandomVariableAAD(int ownIndexInList, RandomVariable ownRandomVariable,
int[] parentIndices, OperatorType parentOperator, ArrayList childrenIndices ,boolean isConstant) {
super();
this.ownIndexInList = ownIndexInList;
this.ownRandomVariable = ownRandomVariable;
this.parentIndices = parentIndices;
this.parentOperator = parentOperator;
this.childrenIndices = childrenIndices;
this.isConstant = isConstant;
}
public static RandomVariableAAD constructNewAADRandomVariable(RandomVariable randomVariable, int[] parentIndices,
OperatorType parentOperator, ArrayList childrenIndices, boolean isConstant){
/* TODO: how to handle cases with different realization lengths? */
if(!arrayListOfAllAADRandomVariables.isEmpty()){
if(arrayListOfAllAADRandomVariables.get(0).size() != randomVariable.size() && !randomVariable.isDeterministic()) {
throw new IllegalArgumentException("RandomVariables with different sizes are not supported at the moment!");
}
}
/* get index of this random variable */
int indexOfThisAADRandomVariable = indexOfNextRandomVariable.getAndIncrement();
RandomVariableAAD newAADRandomVariable = new RandomVariableAAD(indexOfThisAADRandomVariable, randomVariable,
parentIndices, parentOperator, childrenIndices, isConstant);
/* add random variable to static list for book keeping */
arrayListOfAllAADRandomVariables.add(indexOfThisAADRandomVariable, newAADRandomVariable);
/* return a new random variable */
return newAADRandomVariable;
}
public static RandomVariableAAD constructNewAADRandomVariable(double value){
return constructNewAADRandomVariable(new RandomVariableFromDoubleArray(value), /*parentRandomVariables*/ null, /*parentOperator*/ null, /*childrenIndices*/ null ,/*isConstant*/ true);
}
public static RandomVariableAAD constructNewAADRandomVariable(RandomVariable randomVariable) {
return constructNewAADRandomVariable(randomVariable, /* no parents*/ null,
/*no parent operator*/ null, /*no childrenIndices*/ null, /*not constant*/ false);
}
public static RandomVariableAAD constructNewAADRandomVariable(double time, double[] realisations) {
return constructNewAADRandomVariable(new RandomVariableFromDoubleArray(time, realisations), /* no parents*/ null,
/*no parent operator*/ null, /*no childrenIndices*/ null, /*not constant*/ false);
}
private RandomVariableAAD[] getParentAADRandomVariables(){
if(getParentIDs() == null) {
return null;
}
int[] parentIndices = getParentIDs();
RandomVariableAAD[] parentAADRandomVariables = new RandomVariableAAD[getNumberOfParentVariables()];
for(int i=0; i < parentAADRandomVariables.length; i++){
parentAADRandomVariables[i] = getAADRandomVariableFromList(parentIndices[i]);
}
return parentAADRandomVariables;
}
/**
* @return
*/
private RandomVariable[] getParentRandomVariableInderfaces(){
RandomVariableAAD[] parentAADRandomVariables = getParentAADRandomVariables();
RandomVariable[] parentRandomVariableInderfaces = new RandomVariable[parentAADRandomVariables.length];
for(int i=0;i (x == X.getMin()) ? 1.0 : 0.0);
// resultRandomVariableRealizations = new double[X.size()];
// for(int i = 0; i < X.size(); i++) resultRandomVariableRealizations[i] = (X.getRealizations()[i] == X.getMin()) ? 1.0 : 0.0;
// resultrandomvariable = new RandomVariableFromDoubleArray(X.getFiltrationTime(), resultRandomVariableRealizations);
break;
case MAX:
resultrandomvariable = X.apply(x -> (x == X.getMax()) ? 1.0 : 0.0);
// resultRandomVariableRealizations = new double[X.size()];
// for(int i = 0; i < X.size(); i++) resultRandomVariableRealizations[i] = (X.getRealizations()[i] == X.getMax()) ? 1.0 : 0.0;
// resultrandomvariable = new RandomVariableFromDoubleArray(X.getFiltrationTime(), resultRandomVariableRealizations);
break;
case ABS:
resultrandomvariable = X.apply(x -> (x > 0.0) ? 1.0 : (x < 0) ? -1.0 : 0.0);
// resultRandomVariableRealizations = new double[X.size()];
// for(int i = 0; i < X.size(); i++) resultRandomVariableRealizations[i] = (X.getRealizations()[i] > 0) ? 1.0 : (X.getRealizations()[i] < 0) ? -1.0 : 0.0;
// resultrandomvariable = new RandomVariableFromDoubleArray(X.getFiltrationTime(), resultRandomVariableRealizations);
break;
case STDERROR:
resultrandomvariable = X.sub(X.getAverage()*(2.0*X.size()-1.0)/X.size()).mult(2.0/X.size()).mult(0.5).div(Math.sqrt(X.getVariance() * X.size()));
break;
case SVARIANCE:
resultrandomvariable = X.sub(X.getAverage()*(2.0*X.size()-1.0)/X.size()).mult(2.0/(X.size()-1));
break;
default:
break;
}
} else if(getParentIDs().length == 2){
X = getRandomVariableInterfaceOfIndex(getParentIDs()[0]);
Y = getRandomVariableInterfaceOfIndex(getParentIDs()[1]);
switch(parentOperator){
case ADD:
resultrandomvariable = new RandomVariableFromDoubleArray(1.0);
break;
case SUB:
resultrandomvariable = new RandomVariableFromDoubleArray((variableIndex == getParentIDs()[0]) ? 1.0 : -1.0);
break;
case MULT:
resultrandomvariable = (variableIndex == getParentIDs()[0]) ? Y : X;
break;
case DIV:
resultrandomvariable = (variableIndex == getParentIDs()[0]) ? Y.invert() : X.div(Y.squared()).mult(-1);
break;
case CAP:
resultrandomvariable = X.apply(x -> (x > Y.getAverage()) ? 0.0 : 1.0);
// resultRandomVariableRealizations = new double[X.size()];
// for(int i = 0; i < X.size(); i++) resultRandomVariableRealizations[i] = (X.getRealizations()[i] > Y.getAverage()) ? 0.0 : 1.0;
// resultrandomvariable = new RandomVariableFromDoubleArray(X.getFiltrationTime(), resultRandomVariableRealizations);
break;
case FLOOR:
resultrandomvariable = X.apply(x -> (x > Y.getAverage()) ? 1.0 : 0.0);
// resultRandomVariableRealizations = new double[X.size()];
// for(int i = 0; i < X.size(); i++) resultRandomVariableRealizations[i] = (X.getRealizations()[i] > Y.getAverage()) ? 1.0 : 0.0;
// resultrandomvariable = new RandomVariableFromDoubleArray(X.getFiltrationTime(), resultRandomVariableRealizations);
break;
case AVERAGE:
resultrandomvariable = (variableIndex == getParentIDs()[0]) ? Y : X;
break;
case VARIANCE:
resultrandomvariable = (variableIndex == getParentIDs()[0]) ? Y.mult(2.0).mult(X.mult(Y.add(X.getAverage(Y)*(X.size()-1)).sub(X.getAverage(Y)))) :
X.mult(2.0).mult(Y.mult(X.add(Y.getAverage(X)*(X.size()-1)).sub(Y.getAverage(X))));
break;
case STDEV:
resultrandomvariable = (variableIndex == getParentIDs()[0]) ? Y.mult(2.0).mult(X.mult(Y.add(X.getAverage(Y)*(X.size()-1)).sub(X.getAverage(Y)))).div(Math.sqrt(X.getVariance(Y))) :
X.mult(2.0).mult(Y.mult(X.add(Y.getAverage(X)*(X.size()-1)).sub(Y.getAverage(X)))).div(Math.sqrt(Y.getVariance(X)));
break;
case STDERROR:
resultrandomvariable = (variableIndex == getParentIDs()[0]) ? Y.mult(2.0).mult(X.mult(Y.add(X.getAverage(Y)*(X.size()-1)).sub(X.getAverage(Y)))).div(Math.sqrt(X.getVariance(Y) * X.size())) :
X.mult(2.0).mult(Y.mult(X.add(Y.getAverage(X)*(X.size()-1)).sub(Y.getAverage(X)))).div(Math.sqrt(Y.getVariance(X) * Y.size()));
break;
case POW:
/* second argument will always be deterministic and constant! */
resultrandomvariable = (variableIndex == getParentIDs()[0]) ? Y.mult(X.pow(Y.getAverage() - 1.0)) : new RandomVariableFromDoubleArray(0.0);
break;
default:
break;
}
} else if(getParentIDs().length == 3){
X = getRandomVariableInterfaceOfIndex(getParentIDs()[0]);
Y = getRandomVariableInterfaceOfIndex(getParentIDs()[1]);
Z = getRandomVariableInterfaceOfIndex(getParentIDs()[2]);
switch(parentOperator){
case ADDPRODUCT:
if(variableIndex == getParentIDs()[0]){
resultrandomvariable = new RandomVariableFromDoubleArray(1.0);
} else if(variableIndex == getParentIDs()[1]){
resultrandomvariable = Z;
} else {
resultrandomvariable = Y;
}
break;
case ADDRATIO:
if(variableIndex == getParentIDs()[0]){
resultrandomvariable = new RandomVariableFromDoubleArray(1.0);
} else if(variableIndex == getParentIDs()[0]){
resultrandomvariable = Z.invert();
} else {
resultrandomvariable = Y.div(Z.squared());
}
break;
case SUBRATIO:
if(variableIndex == getParentIDs()[0]){
resultrandomvariable = new RandomVariableFromDoubleArray(1.0);
} else if(variableIndex == getParentIDs()[1]){
resultrandomvariable = Z.invert().mult(-1.0);
} else {
resultrandomvariable = Y.div(Z.squared()).mult(-1.0);
}
break;
case ACCRUE:
if(variableIndex == getParentIDs()[0]){
resultrandomvariable = Y.mult(Z).add(1.0);
} else if(variableIndex == getParentIDs()[1]){
resultrandomvariable = X.mult(Z);
} else {
resultrandomvariable = X.mult(Y);
}
break;
case DISCOUNT:
if(variableIndex == getParentIDs()[0]){
resultrandomvariable = Y.mult(Z).add(1.0).invert();
} else if(variableIndex == getParentIDs()[1]){
resultrandomvariable = X.mult(Z).div(Y.mult(Z).add(1.0).squared());
} else {
resultrandomvariable = X.mult(Y).div(Y.mult(Z).add(1.0).squared());
}
break;
case BARRIER:
if(variableIndex == getParentIDs()[0]){
resultrandomvariable = X.apply(x -> (x == 0.0) ? Double.POSITIVE_INFINITY : 0.0);
} else if(variableIndex == getParentIDs()[1]){
resultrandomvariable = X.choose(new RandomVariableFromDoubleArray(1.0), new RandomVariableFromDoubleArray(0.0));
} else {
resultrandomvariable = X.choose(new RandomVariableFromDoubleArray(0.0), new RandomVariableFromDoubleArray(1.0));
}
default:
break;
}
} else {
/* if non of the above throw exception */
throw new IllegalArgumentException("Operation not supported!\n");
}
return resultrandomvariable;
}
/**
* Implements the AAD Algorithm
* @return HashMap where the key is the internal index of the random variable with respect to which the partial derivative was computed. This key then gives access to the actual derivative.
* */
public Map getGradient(){
int numberOfCalculationSteps = getFunctionList().size();
RandomVariable[] omegaHat = new RandomVariable[numberOfCalculationSteps];
omegaHat[numberOfCalculationSteps-1] = new RandomVariableFromDoubleArray(1.0);
for(int variableIndex = numberOfCalculationSteps-2; variableIndex >= 0; variableIndex--){
omegaHat[variableIndex] = new RandomVariableFromDoubleArray(0.0);
ArrayList childrenList = getAADRandomVariableFromList(variableIndex).getChildrenIndices();
for(int functionIndex:childrenList){
RandomVariable D_i_j = getPartialDerivative(functionIndex, variableIndex);
omegaHat[variableIndex] = omegaHat[variableIndex].addProduct(D_i_j, omegaHat[functionIndex]);
}
}
ArrayList arrayListOfAllIndicesOfDependentRandomVariables = getArrayListOfAllIndicesOfDependentRandomVariables();
Map gradient = new HashMap();
for(Integer indexOfDependentRandomVariable: arrayListOfAllIndicesOfDependentRandomVariables){
gradient.put(indexOfDependentRandomVariable, omegaHat[arrayListOfAllIndicesOfDependentRandomVariables.get(indexOfDependentRandomVariable)]);
}
return gradient;
}
private ArrayList getArrayListOfAllIndicesOfDependentRandomVariables(){
ArrayList arrayListOfAllIndicesOfDependentRandomVariables = new ArrayList<>();
for(int index = 0; index < getNumberOfParentVariables(); index++){
int currentParentIndex = getParentIDs()[index];
/* if current index belongs to a true variable and is not yet in the list: add it*/
if(getAADRandomVariableFromList(currentParentIndex).isVariable() &&
!arrayListOfAllIndicesOfDependentRandomVariables.contains(currentParentIndex)){
arrayListOfAllIndicesOfDependentRandomVariables.add(currentParentIndex);
} else {
arrayListOfAllIndicesOfDependentRandomVariables.addAll(
getAADRandomVariableFromList(currentParentIndex).getArrayListOfAllIndicesOfDependentRandomVariables());
}
}
return arrayListOfAllIndicesOfDependentRandomVariables;
}
/* for all functions that need to be differentiated and are returned as double in the Interface, write a method to return it as RandomVariableAAD
* that is deterministic by its nature. For their double-returning pendant just return the average of the deterministic RandomVariableAAD */
public RandomVariable getAverageAsRandomVariableAAD(RandomVariable probabilities){
/*returns deterministic AAD random variable */
return apply(OperatorType.AVERAGE, new RandomVariable[]{this, probabilities});
}
public RandomVariable getVarianceAsRandomVariableAAD(RandomVariable probabilities){
/*returns deterministic AAD random variable */
return apply(OperatorType.VARIANCE, new RandomVariable[]{this, probabilities});
}
public RandomVariable getStandardDeviationAsRandomVariableAAD(RandomVariable probabilities){
/*returns deterministic AAD random variable */
return apply(OperatorType.STDEV, new RandomVariable[]{this, probabilities});
}
public RandomVariable getStandardErrorAsRandomVariableAAD(RandomVariable probabilities){
/*returns deterministic AAD random variable */
return apply(OperatorType.STDERROR, new RandomVariable[]{this, probabilities});
}
public RandomVariable getAverageAsRandomVariableAAD(){
/*returns deterministic AAD random variable */
return apply(OperatorType.AVERAGE, new RandomVariable[]{this});
}
public RandomVariable getVarianceAsRandomVariableAAD(){
/*returns deterministic AAD random variable */
return apply(OperatorType.VARIANCE, new RandomVariable[]{this});
}
public RandomVariable getSampleVarianceAsRandomVariableAAD() {
/*returns deterministic AAD random variable */
return apply(OperatorType.SVARIANCE, new RandomVariable[]{this});
}
public RandomVariable getStandardDeviationAsRandomVariableAAD(){
/*returns deterministic AAD random variable */
return apply(OperatorType.STDEV, new RandomVariable[]{this});
}
public RandomVariable getStandardErrorAsRandomVariableAAD(){
/*returns deterministic AAD random variable */
return apply(OperatorType.STDERROR, new RandomVariable[]{this});
}
public RandomVariable getMinAsRandomVariableAAD(){
/*returns deterministic AAD random variable */
return apply(OperatorType.MIN, new RandomVariable[]{this});
}
public RandomVariable getMaxAsRandomVariableAAD(){
/*returns deterministic AAD random variable */
return apply(OperatorType.MAX, new RandomVariable[]{this});
}
/* setter and getter */
private OperatorType getParentOperator(){
return parentOperator;
}
private boolean isConstant(){
return isConstant;
}
private boolean isVariable() {
return (isConstant() == false && getParentIDs() == null);
}
private ArrayList getFunctionList(){
return arrayListOfAllAADRandomVariables;
}
public static void resetArrayListOfAllAADRandomVariables(){
synchronized (arrayListOfAllAADRandomVariables) {
arrayListOfAllAADRandomVariables = new ArrayList<>();
indexOfNextRandomVariable = new AtomicInteger(0);
}
}
public void setIsConstantTo(boolean isConstant){
this.isConstant = isConstant;
}
private RandomVariable getRandomVariableInterface(){
return ownRandomVariable;
}
private RandomVariable getRandomVariableInterfaceOfIndex(int index){
return getFunctionList().get(index).getRandomVariableInterface();
}
private int getFunctionIndex(){
return ownIndexInList;
}
private int[] getParentIDs(){
return parentIndices;
}
private ArrayList getChildrenIndices(){
if(childrenIndices == null) {
childrenIndices = new ArrayList<>();
}
return childrenIndices;
}
private int getNumberOfParentVariables(){
if(getParentIDs() == null) {
return 0;
}
return getParentIDs().length;
}
private RandomVariableAAD getAADRandomVariableFromList(int index){
return getFunctionList().get(index);
}
private void addToChildrenIndices(int index){
getChildrenIndices().add(index);
}
/*--------------------------------------------------------------------------------------------------------------------------------------------------*/
/* (non-Javadoc)
* @see net.finmath.stochastic.RandomVariable#equals(net.finmath.stochastic.RandomVariable)
*/
@Override
public boolean equals(RandomVariable randomVariable) {
return getRandomVariableInterface().equals(randomVariable);
}
/* (non-Javadoc)
* @see net.finmath.stochastic.RandomVariable#getFiltrationTime()
*/
@Override
public double getFiltrationTime() {
return getRandomVariableInterface().getFiltrationTime();
}
@Override
public int getTypePriority() {
return 3;
}
/* (non-Javadoc)
* @see net.finmath.stochastic.RandomVariable#get(int)
*/
@Override
public double get(int pathOrState) {
return getRandomVariableInterface().get(pathOrState);
}
/* (non-Javadoc)
* @see net.finmath.stochastic.RandomVariable#size()
*/
@Override
public int size() {
return getRandomVariableInterface().size();
}
/* (non-Javadoc)
* @see net.finmath.stochastic.RandomVariable#isDeterministic()
*/
@Override
public boolean isDeterministic() {
return getRandomVariableInterface().isDeterministic();
}
/* (non-Javadoc)
* @see net.finmath.stochastic.RandomVariable#getRealizations()
*/
@Override
public double[] getRealizations() {
return getRandomVariableInterface().getRealizations();
}
@Override
public Double doubleValue() {
return getRandomVariableInterface().doubleValue();
}
/* (non-Javadoc)
* @see net.finmath.stochastic.RandomVariable#getMin()
*/
@Override
public double getMin() {
return ((RandomVariableAAD) getMinAsRandomVariableAAD()).getRandomVariableInterface().getAverage();
}
/* (non-Javadoc)
* @see net.finmath.stochastic.RandomVariable#getMax()
*/
@Override
public double getMax() {
return ((RandomVariableAAD) getMaxAsRandomVariableAAD()).getRandomVariableInterface().getAverage();
}
/* (non-Javadoc)
* @see net.finmath.stochastic.RandomVariable#getAverage()
*/
@Override
public double getAverage() {
return ((RandomVariableAAD) getAverageAsRandomVariableAAD()).getRandomVariableInterface().getAverage();
}
/* (non-Javadoc)
* @see net.finmath.stochastic.RandomVariable#getAverage(net.finmath.stochastic.RandomVariable)
*/
@Override
public double getAverage(RandomVariable probabilities) {
return ((RandomVariableAAD) getAverageAsRandomVariableAAD(probabilities)).getRandomVariableInterface().getAverage();
}
/* (non-Javadoc)
* @see net.finmath.stochastic.RandomVariable#getVariance()
*/
@Override
public double getVariance() {
return ((RandomVariableAAD) getVarianceAsRandomVariableAAD()).getRandomVariableInterface().getAverage();
}
/* (non-Javadoc)
* @see net.finmath.stochastic.RandomVariable#getVariance(net.finmath.stochastic.RandomVariable)
*/
@Override
public double getVariance(RandomVariable probabilities) {
return ((RandomVariableAAD) getAverageAsRandomVariableAAD(probabilities)).getRandomVariableInterface().getAverage();
}
/* (non-Javadoc)
* @see net.finmath.stochastic.RandomVariable#getSampleVariance()
*/
@Override
public double getSampleVariance() {
return ((RandomVariableAAD) getSampleVarianceAsRandomVariableAAD()).getRandomVariableInterface().getAverage();
}
/* (non-Javadoc)
* @see net.finmath.stochastic.RandomVariable#getStandardDeviation()
*/
@Override
public double getStandardDeviation() {
return ((RandomVariableAAD) getStandardDeviationAsRandomVariableAAD()).getRandomVariableInterface().getAverage();
}
/* (non-Javadoc)
* @see net.finmath.stochastic.RandomVariable#getStandardDeviation(net.finmath.stochastic.RandomVariable)
*/
@Override
public double getStandardDeviation(RandomVariable probabilities) {
return ((RandomVariableAAD) getStandardDeviationAsRandomVariableAAD(probabilities)).getRandomVariableInterface().getAverage();
}
/* (non-Javadoc)
* @see net.finmath.stochastic.RandomVariable#getStandardError()
*/
@Override
public double getStandardError() {
return ((RandomVariableAAD) getStandardErrorAsRandomVariableAAD()).getRandomVariableInterface().getAverage();
}
/* (non-Javadoc)
* @see net.finmath.stochastic.RandomVariable#getStandardError(net.finmath.stochastic.RandomVariable)
*/
@Override
public double getStandardError(RandomVariable probabilities) {
return ((RandomVariableAAD) getStandardErrorAsRandomVariableAAD(probabilities)).getRandomVariableInterface().getAverage();
}
/* (non-Javadoc)
* @see net.finmath.stochastic.RandomVariable#getQuantile(double)
*/
@Override
public double getQuantile(double quantile) {
return ((RandomVariableAAD) getRandomVariableInterface()).getRandomVariableInterface().getQuantile(quantile);
}
/* (non-Javadoc)
* @see net.finmath.stochastic.RandomVariable#getQuantile(double, net.finmath.stochastic.RandomVariable)
*/
@Override
public double getQuantile(double quantile, RandomVariable probabilities) {
return ((RandomVariableAAD) getRandomVariableInterface()).getRandomVariableInterface().getQuantile(quantile, probabilities);
}
/* (non-Javadoc)
* @see net.finmath.stochastic.RandomVariable#getQuantileExpectation(double, double)
*/
@Override
public double getQuantileExpectation(double quantileStart, double quantileEnd) {
return ((RandomVariableAAD) getRandomVariableInterface()).getRandomVariableInterface().getQuantileExpectation(quantileStart, quantileEnd);
}
/* (non-Javadoc)
* @see net.finmath.stochastic.RandomVariable#getHistogram(double[])
*/
@Override
public double[] getHistogram(double[] intervalPoints) {
return getRandomVariableInterface().getHistogram(intervalPoints);
}
/* (non-Javadoc)
* @see net.finmath.stochastic.RandomVariable#getHistogram(int, double)
*/
@Override
public double[][] getHistogram(int numberOfPoints, double standardDeviations) {
return getRandomVariableInterface().getHistogram(numberOfPoints, standardDeviations);
}
/* (non-Javadoc)
* @see net.finmath.stochastic.RandomVariable#cache()
*/
@Override
public RandomVariable cache() {
return this;
}
@Override
public RandomVariable cap(double cap) {
return apply(OperatorType.CAP, new RandomVariable[]{this, constructNewAADRandomVariable(cap)});
}
/* (non-Javadoc)
* @see net.finmath.stochastic.RandomVariable#floor(double)
*/
@Override
public RandomVariable floor(double floor) {
return apply(OperatorType.FLOOR, new RandomVariable[]{this, constructNewAADRandomVariable(floor)});
}
/* (non-Javadoc)
* @see net.finmath.stochastic.RandomVariable#add(double)
*/
@Override
public RandomVariable add(double value) {
return apply(OperatorType.ADD, new RandomVariable[]{this, constructNewAADRandomVariable(value)});
}
/* (non-Javadoc)
* @see net.finmath.stochastic.RandomVariable#sub(double)
*/
@Override
public RandomVariable sub(double value) {
return apply(OperatorType.SUB, new RandomVariable[]{this, constructNewAADRandomVariable(value)});
}
/* (non-Javadoc)
* @see net.finmath.stochastic.RandomVariable#mult(double)
*/
@Override
public RandomVariable mult(double value) {
return apply(OperatorType.MULT, new RandomVariable[]{this, constructNewAADRandomVariable(value)});
}
/* (non-Javadoc)
* @see net.finmath.stochastic.RandomVariable#div(double)
*/
@Override
public RandomVariable div(double value) {
return apply(OperatorType.DIV, new RandomVariable[]{this, constructNewAADRandomVariable(value)});
}
/* (non-Javadoc)
* @see net.finmath.stochastic.RandomVariable#pow(double)
*/
@Override
public RandomVariable pow(double exponent) {
return apply(OperatorType.POW, new RandomVariable[]{this, constructNewAADRandomVariable(exponent)});
}
@Override
public RandomVariable average() {
return apply(OperatorType.AVERAGE, new RandomVariable[]{this});
}
/* (non-Javadoc)
* @see net.finmath.stochastic.RandomVariable#squared()
*/
@Override
public RandomVariable squared() {
return apply(OperatorType.SQUARED, new RandomVariable[]{this});
}
/* (non-Javadoc)
* @see net.finmath.stochastic.RandomVariable#sqrt()
*/
@Override
public RandomVariable sqrt() {
return apply(OperatorType.SQRT, new RandomVariable[]{this});
}
/* (non-Javadoc)
* @see net.finmath.stochastic.RandomVariable#exp()
*/
@Override
public RandomVariable exp() {
return apply(OperatorType.EXP, new RandomVariable[]{this});
}
/* (non-Javadoc)
* @see net.finmath.stochastic.RandomVariable#log()
*/
@Override
public RandomVariable log() {
return apply(OperatorType.LOG, new RandomVariable[]{this});
}
/* (non-Javadoc)
* @see net.finmath.stochastic.RandomVariable#sin()
*/
@Override
public RandomVariable sin() {
return apply(OperatorType.SIN, new RandomVariable[]{this});
}
/* (non-Javadoc)
* @see net.finmath.stochastic.RandomVariable#cos()
*/
@Override
public RandomVariable cos() {
return apply(OperatorType.COS, new RandomVariable[]{this});
}
/* (non-Javadoc)
* @see net.finmath.stochastic.RandomVariable#add(net.finmath.stochastic.RandomVariable)
*/
@Override
public RandomVariable add(RandomVariable randomVariable) {
return apply(OperatorType.ADD, new RandomVariable[]{this, randomVariable});
}
/* (non-Javadoc)
* @see net.finmath.stochastic.RandomVariable#sub(net.finmath.stochastic.RandomVariable)
*/
@Override
public RandomVariable sub(RandomVariable randomVariable) {
return apply(OperatorType.SUB, new RandomVariable[]{this, randomVariable});
}
@Override
public RandomVariable bus(RandomVariable randomVariable) {
return apply(OperatorType.SUB, new RandomVariable[]{randomVariable,this}); // SUB with swapped arguments
}
/* (non-Javadoc)
* @see net.finmath.stochastic.RandomVariable#mult(net.finmath.stochastic.RandomVariable)
*/
@Override
public RandomVariable mult(RandomVariable randomVariable) {
return apply(OperatorType.MULT, new RandomVariable[]{this, randomVariable});
}
/* (non-Javadoc)
* @see net.finmath.stochastic.RandomVariable#div(net.finmath.stochastic.RandomVariable)
*/
@Override
public RandomVariable div(RandomVariable randomVariable) {
return apply(OperatorType.DIV, new RandomVariable[]{this, randomVariable});
}
@Override
public RandomVariable vid(RandomVariable randomVariable) {
return apply(OperatorType.DIV, new RandomVariable[]{randomVariable, this}); // DIV with swapped arguments
}
/* (non-Javadoc)
* @see net.finmath.stochastic.RandomVariable#cap(net.finmath.stochastic.RandomVariable)
*/
@Override
public RandomVariable cap(RandomVariable cap) {
return apply(OperatorType.CAP, new RandomVariable[]{this, cap});
}
/* (non-Javadoc)
* @see net.finmath.stochastic.RandomVariable#floor(net.finmath.stochastic.RandomVariable)
*/
@Override
public RandomVariable floor(RandomVariable floor) {
return apply(OperatorType.FLOOR, new RandomVariable[]{this, floor});
}
/* (non-Javadoc)
* @see net.finmath.stochastic.RandomVariable#accrue(net.finmath.stochastic.RandomVariable, double)
*/
@Override
public RandomVariable accrue(RandomVariable rate, double periodLength) {
return apply(OperatorType.ACCRUE, new RandomVariable[]{this, rate, constructNewAADRandomVariable(periodLength)});
}
/* (non-Javadoc)
* @see net.finmath.stochastic.RandomVariable#discount(net.finmath.stochastic.RandomVariable, double)
*/
@Override
public RandomVariable discount(RandomVariable rate, double periodLength) {
return apply(OperatorType.DISCOUNT, new RandomVariable[]{this, rate, constructNewAADRandomVariable(periodLength)});
}
@Override
public RandomVariable choose(RandomVariable valueIfTriggerNonNegative, RandomVariable valueIfTriggerNegative) {
return apply(OperatorType.BARRIER, new RandomVariable[]{this, valueIfTriggerNonNegative, valueIfTriggerNegative});
}
@Override
public RandomVariable invert() {
return apply(OperatorType.INVERT, new RandomVariable[]{this});
}
@Override
public RandomVariable abs() {
return apply(OperatorType.ABS, new RandomVariable[]{this});
}
@Override
public RandomVariable addProduct(RandomVariable factor1, double factor2) {
return apply(OperatorType.ADDPRODUCT, new RandomVariable[]{this, factor1, constructNewAADRandomVariable(factor2)});
}
@Override
public RandomVariable addProduct(RandomVariable factor1, RandomVariable factor2) {
return apply(OperatorType.ADDPRODUCT, new RandomVariable[]{this, factor1, factor2});
}
@Override
public RandomVariable addRatio(RandomVariable numerator, RandomVariable denominator) {
return apply(OperatorType.ADDRATIO, new RandomVariable[]{this, numerator, denominator});
}
@Override
public RandomVariable subRatio(RandomVariable numerator, RandomVariable denominator) {
return apply(OperatorType.SUBRATIO, new RandomVariable[]{this, numerator, denominator});
}
@Override
public RandomVariable isNaN() {
return getRandomVariableInterface().isNaN();
}
@Override
public IntToDoubleFunction getOperator() {
throw new UnsupportedOperationException("Not supported.");
}
@Override
public DoubleStream getRealizationsStream() {
throw new UnsupportedOperationException("Not supported.");
}
@Override
public RandomVariable apply(DoubleUnaryOperator operator) {
throw new UnsupportedOperationException("Applying functions is not supported.");
}
@Override
public RandomVariable apply(DoubleBinaryOperator operator, RandomVariable argument) {
throw new UnsupportedOperationException("Applying functions is not supported.");
}
@Override
public RandomVariable apply(DoubleTernaryOperator operator, RandomVariable argument1, RandomVariable argument2) {
throw new UnsupportedOperationException("Applying functions is not supported.");
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy