public Decimal?Calculate(CalculationTicket ticket, ICalculationTracer tracer)
{
tracer.WriteLine("Add formula");
tracer.Indent();
var one = this.oneExpression.Value(ticket, tracer, No.ExpressionName);
var another = this.anotherExpression.Value(ticket, tracer, No.ExpressionName);
Decimal?result;
if (one.HasValue)
{
if (another.HasValue)
{
result = one.Value + another.Value;
}
else
{
result = one.Value;
}
}
else
{
if (another.HasValue)
{
result = another.Value;
}
else
{
result = null;
}
}
tracer.WriteValue("Sum", result);
tracer.Unindent();
return(result);
}
public Decimal?Calculate(IModel model, CalculationTicket ticket, ICalculationTracer tracer)
{
tracer.WriteLine("Base less overlay formula");
tracer.Indent();
var rescaledBaseValue = this.rescaledBaseForAdjustmentFormula.Calculate(model, ticket, tracer);
tracer.WriteValue("Rescaled base", rescaledBaseValue);
Decimal?result;
if (rescaledBaseValue.HasValue)
{
var overlayExpressionOpt = picker.Overlay.TryPickExpression(model);
if (overlayExpressionOpt == null)
{
throw new ApplicationException("There is no overlay expression.");
}
var overlayValue = overlayExpressionOpt.Value(ticket, tracer, "Overlay");
result = rescaledBaseValue.Value - overlayValue;
}
else
{
result = null;
}
tracer.WriteValue("Result", result);
tracer.Unindent();
return(result);
}
public static Decimal?CalculateRescaledBase(
Decimal? @base,
Decimal?portfolioAdjustment,
Decimal?baseWherePortfoioAdjustmentSetTotal,
Decimal?porfolioAdjustmentTotal,
ICalculationTracer tracer
)
{
Decimal?result;
if (portfolioAdjustment.HasValue)
{
result = portfolioAdjustment.Value;
tracer.WriteValue("Portfolio adjustment as is", result);
}
else if (@base.HasValue)
{
result = @base.Value
/ (1.0m - (baseWherePortfoioAdjustmentSetTotal.HasValue ? baseWherePortfoioAdjustmentSetTotal.Value : 0m))
* (1.0m - (porfolioAdjustmentTotal.HasValue ? porfolioAdjustmentTotal.Value : 0m));
tracer.WriteValue("Base / (1 - baseWherePortfoioAdjustmentSetTotal) * (1 - porfolioAdjustmentTotal)", result);
}
else
{
result = null;
}
return(result);
}
public Decimal?Calculate(IModel model, CalculationTicket ticket, ICalculationTracer tracer)
{
tracer.WriteLine("Base active formula");
tracer.Indent();
var baseExpressionOpt = picker.Base.TryPickExpression(model);
var benchmarkExpressionOpt = picker.Benchmark.TryPickExpression(model);
if (baseExpressionOpt == null || benchmarkExpressionOpt == null)
{
return(null);
}
var baseValue = baseExpressionOpt.Value(ticket, tracer, "Base");
var benchmarkValue = benchmarkExpressionOpt.Value(ticket, tracer, "Benchmark");
Decimal?result;
if (!baseValue.HasValue)
{
result = null;
}
else
{
result = baseValue.Value - benchmarkValue;
}
tracer.WriteValue("Base - Benchmark", result);
tracer.Unindent();
return(result);
}
public Decimal?Value(CalculationTicket ticket, ICalculationTracer tracer, String name)
{
var value = this.EditedValue;
tracer.WriteValue(name ?? this.Name, value);
return(value);
}
public decimal?Calculate(CalculationTicket ticket, ICalculationTracer tracer)
{
tracer.WriteLine("Base less overlay positive total formula");
tracer.Indent();
Decimal?result = this.cashRescaledBase.Value(ticket, tracer, "Cash rescaled base");
tracer.WriteValue(" + Cash rescaled base", result);
foreach (var model in models)
{
var value = this.baseLessOverlayFormula.Calculate(model, ticket, tracer);
if (value.HasValue && value.Value > 0)
{
tracer.WriteValue("+ Base less overlay", value);
if (result.HasValue)
{
result = result.Value + value.Value;
}
else
{
result = value.Value;
}
}
}
tracer.WriteValue("Total", result);
tracer.Unindent();
return(result);
}
public Decimal?Value(CalculationTicket ticket, ICalculationTracer tracer, String name)
{
tracer.WriteLine("Nullable sum: " + (name ?? this.Name));
tracer.Indent();
var result = this.defaultValue;
foreach (var expressionOpt in this.expressions)
{
if (expressionOpt == null)
{
continue;
}
var value = expressionOpt.Value(ticket);
tracer.WriteValue("+", value);
if (value.HasValue)
{
if (result.HasValue)
{
result = result.Value + value.Value;
}
else
{
result = value.Value;
}
}
}
tracer.WriteValue("Total", result);
tracer.Unindent();
return(result);
}
public TValue Value(CalculationTicket ticket, ICalculationTracer tracer, String name)
{
var result = this.InitialValue;
tracer.WriteValue(name ?? this.Name, result, this.Adapter);
return(result);
}
public TValue Value(CalculationTicket ticket, ICalculationTracer tracer, string name)
{
tracer.WriteLine("Model expression: " + (name ?? this.Name));
tracer.Indent();
var result = this.Formula.Calculate(this.Model, ticket, tracer);
tracer.Unindent();
return(result);
}
public Decimal?Calculate(CalculationTicket ticket, ICalculationTracer tracer)
{
tracer.WriteLine("Base where portfolio adjustment is set");
tracer.Indent();
var models = this.traverser.TraverseGlobe(this.root);
var result = this.ComputeBaseTotalWherePortfoioAdjustmentSetValue(models, tracer);
tracer.WriteValue("Total", result);
tracer.Unindent();
return(result);
}
public Decimal?Calculate(CalculationTicket ticket, ICalculationTracer tracer)
{
tracer.WriteLine("Base active formula");
tracer.Indent();
var baseValue = BaseExpression.Value(ticket, tracer, "Base");
var benchmarkValue = BenchmarkExpression.Value(ticket, tracer, "Benchmark");
var result = baseValue.HasValue ? baseValue - benchmarkValue : null;
tracer.WriteValue("Base - Benchmark", result);
tracer.Unindent();
return(result);
}
public RescaledBaseForAdjustmentValueMultimethod(
CalculationTicket ticket,
Decimal?baseWherePortfoioAdjustmentSetTotal,
Decimal?porfolioAdjustmentTotal,
ICalculationTracer tracer
)
{
this.ticket = ticket;
this.baseWherePortfoioAdjustmentSetTotal = baseWherePortfoioAdjustmentSetTotal;
this.porfolioAdjustmentTotal = porfolioAdjustmentTotal;
this.tracer = tracer;
}
public decimal?Calculate(CalculationTicket ticket, ICalculationTracer tracer)
{
Decimal?result;
var total = this.targetTotalExpression.Value(ticket);
if (total.HasValue)
{
result = 1.0m - total.Value;
}
else
{
result = null;
}
tracer.WriteLine("Undone");
return(result);
}
public Decimal?Calculate(IModel model, CalculationTicket ticket, ICalculationTracer tracer)
{
// if portfolio adjustment has anything return it
var baseWherePortfolioAdjustmentSetTotalValue = this.baseWherePortfoioAdjustmentSetTotal.Value(ticket, tracer, "");
var porfolioAdjustmentTotalValue = porfolioAdjustmentTotal.Value(ticket, tracer, "");
var multimethod = new RescaledBaseForAdjustmentValueMultimethod(
ticket,
baseWherePortfolioAdjustmentSetTotalValue,
porfolioAdjustmentTotalValue,
tracer
);
model.Accept(multimethod);
return(multimethod.Result);
}
public TValue Value(CalculationTicket ticket, ICalculationTracer tracer, String name)
{
TValue result;
tracer.WriteLine("Expession: " + (name ?? this.Name));
tracer.Indent();
if (this.ticket == ticket)
{
result = this.value;
tracer.WriteValue("CACHED", result, this.Adapter);
}
else
{
result = this.formula.Calculate(ticket, tracer);
this.ticket = ticket;
this.value = result;
}
tracer.Unindent();
return(result);
}
public Decimal?Calculate(CalculationTicket ticket, ICalculationTracer tracer)
{
var baseValue = cashBase.Value(ticket);
var baseWherePortfoioAdjustmentSetTotalValue = baseWherePortfoioAdjustmentSetTotal.Value(ticket);
var porfolioAdjustmentTotalValue = porfolioAdjustmentTotal.Value(ticket);
Decimal?result;
if (baseValue.HasValue)
{
result = baseValue.Value
/ (1 - (baseWherePortfoioAdjustmentSetTotalValue.HasValue ? baseWherePortfoioAdjustmentSetTotalValue.Value : 0m))
* (1 - (porfolioAdjustmentTotalValue.HasValue ? porfolioAdjustmentTotalValue.Value : 0m));
}
else
{
result = null;
}
tracer.WriteLine("Undone");
return(result);
}
public Decimal?Calculate(IModel model, CalculationTicket ticket, ICalculationTracer tracer)
{
var trueExposureExpressionOpt = this.picker.TrueExposure.TryPickExpression(model);
var benchmarkExpressionOpt = this.picker.Benchmark.TryPickExpression(model);
if (trueExposureExpressionOpt == null || benchmarkExpressionOpt == null)
{
return(null);
}
var trueExposure = trueExposureExpressionOpt.Value(ticket);
if (!trueExposure.HasValue)
{
return(null);
}
var benchmark = benchmarkExpressionOpt.Value(ticket);
var value = trueExposure.Value - benchmark;
tracer.WriteLine("Undone");
return(value);
}
public Decimal?Calculate(IModel model, CalculationTicket ticket, ICalculationTracer tracer)
{
var overlayExpressionOpt = this.picker.Overlay.TryPickExpression(model);
var portfolioScaledExpressionOpt = this.picker.PortfolioScaled.TryPickExpression(model);
if (overlayExpressionOpt == null || portfolioScaledExpressionOpt == null)
{
return(null);
}
var overlayValue = overlayExpressionOpt.Value(ticket);
var portfolioScaledValue = portfolioScaledExpressionOpt.Value(ticket);
if (!portfolioScaledValue.HasValue)
{
return(null);
}
var value = overlayValue + portfolioScaledValue.Value;
tracer.WriteLine("Undone");
return(value);
}
public decimal?Calculate(IModel model, CalculationTicket ticket, ICalculationTracer tracer)
{
tracer.WriteLine("Portfolio scaled formula");
tracer.Indent();
var baseLessOverlay = this.baseLessOverlayFormula.Calculate(model, ticket, tracer);
if (!baseLessOverlay.HasValue)
{
return(null);
}
if (baseLessOverlay.Value < 0)
{
return(0m);
}
var positiveTotal = baseLessOverlayPositiveTotal.Value(ticket, tracer, "Base less overlay positive total");
if (!positiveTotal.HasValue)
{
return(null);
}
var total = baseLessOverlayTotal.Value(ticket);
if (!total.HasValue)
{
return(null);
}
if (positiveTotal.Value == 0)
{
throw new NotImplementedException();
}
tracer.WriteLine("Undone");
var result = baseLessOverlay.Value / positiveTotal.Value * total.Value;
tracer.Unindent();
return(result);
}
public Decimal?Calculate(CalculationTicket ticket, ICalculationTracer tracer)
{
var rescaledBaseCash = this.rescaledCashBase.Value(ticket, tracer, "Rescaled cash base");
if (!rescaledBaseCash.HasValue)
{
return(null);
}
if (rescaledBaseCash.Value < 0)
{
return(0m);
}
var positiveTotal = baseLessOverlayPositiveTotal.Value(ticket, tracer, "Base less overlay positive total");
if (!positiveTotal.HasValue)
{
return(null);
}
var total = baseLessOverlayTotal.Value(ticket, tracer, "Base less overlay total");
if (!total.HasValue)
{
return(null);
}
if (positiveTotal.Value == 0)
{
throw new NotImplementedException();
}
var value = rescaledBaseCash.Value / positiveTotal.Value * total.Value;
tracer.WriteValue("Rescaled cash base / positive base less overlay total * base less overlay total", value);
return(value);
}
protected Decimal?ComputeBaseTotalWherePortfoioAdjustmentSetValue(IEnumerable <IModel> models, ICalculationTracer tracer)
{
Decimal?total = null;
foreach (var model in models)
{
var resolver = new BaseTotalWherePortfoioAdjustmentSetValueMultimethod();
model.Accept(resolver);
var value = resolver.Result;
if (value.HasValue)
{
tracer.WriteValue("+", value);
if (!total.HasValue)
{
total = value;
}
else
{
total += value;
}
}
}
return(total);
}
