/**
* Copyright (C) 2009 - present by OpenGamma Inc. and the OpenGamma group of companies
*
* Please see distribution for license.
*/
package com.opengamma.analytics.financial.model.option.pricing.montecarlo;
import java.util.Set;
import org.apache.commons.lang.Validate;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.opengamma.analytics.financial.greeks.Greek;
import com.opengamma.analytics.financial.greeks.GreekResultCollection;
import com.opengamma.analytics.financial.model.option.definition.OptionDefinition;
import com.opengamma.analytics.financial.model.option.definition.StandardOptionDataBundle;
import com.opengamma.analytics.financial.model.option.pricing.OptionModel;
import com.opengamma.analytics.financial.model.stochastic.StochasticProcess;
import com.opengamma.analytics.math.function.Function1D;
import com.opengamma.analytics.math.random.RandomNumberGenerator;
import com.opengamma.util.ArgumentChecker;
/**
*
* @param <T>
* @param <U>
*/
public abstract class MonteCarloOptionModel<T extends OptionDefinition, U extends StandardOptionDataBundle> implements OptionModel<T, U> {
private static final Logger s_logger = LoggerFactory.getLogger(MonteCarloOptionModel.class);
private final int _n;
private final int _steps;
private final StochasticProcess<T, U> _process;
private final RandomNumberGenerator _generator;
public MonteCarloOptionModel(final int n, final int steps, final StochasticProcess<T, U> process, final RandomNumberGenerator generator) {
ArgumentChecker.notNegativeOrZero(n, "n");
ArgumentChecker.notNegativeOrZero(steps, "steps");
Validate.notNull(process, "process");
Validate.notNull(generator, "generator");
_n = n;
_steps = steps;
_process = process;
_generator = generator;
}
@Override
public GreekResultCollection getGreeks(final T definition, final U data, final Set<Greek> requiredGreeks) {
Validate.notNull(definition, "definition");
Validate.notNull(data, "data");
Validate.notNull(requiredGreeks, "required greeks");
Validate.notEmpty(requiredGreeks, "required greeks");
if (requiredGreeks.contains(Greek.FAIR_PRICE)) {
if (requiredGreeks.size() > 1) {
s_logger.warn("Can only produce fair price");
}
} else {
throw new IllegalArgumentException("Can only produce fair price");
}
final GreekResultCollection greeks = new GreekResultCollection();
final Function1D<U, Double> price = getPricingFunction(definition);
greeks.put(Greek.FAIR_PRICE, price.evaluate(data));
return greeks;
}
public abstract Function1D<U, Double> getPricingFunction(T definition);
protected int getN() {
return _n;
}
protected int getSteps() {
return _steps;
}
protected StochasticProcess<T, U> getProcess() {
return _process;
}
protected RandomNumberGenerator getGenerator() {
return _generator;
}
}