public TermExecutionPosition(TermExecutionPosition CopyFromThis)
{
int Count = CopyFromThis.S_vector.Length;
S_vector = new double[Count];
D_vector = new double[Count];
X_vector = new double[Count];
for (int i = 0; i < Count; i++)
{
S_vector[i] = CopyFromThis.S_vector[i];
D_vector[i] = CopyFromThis.D_vector[i];
X_vector[i] = CopyFromThis.X_vector[i];
}
Factor = CopyFromThis.Factor;
FactorArray = CopyFromThis.FactorArray;
NumBuildings = CopyFromThis.NumBuildings;
}
public TermExecutionPosition Execute(List <TermExecutionPosition> _SubjectPositions,
Dictionary <SimpleExpression <SymbolicValue>, double> Bindings)
{
#region IF per-risk, multi-building
if (IsMultiBuildingPerRisk())
{
// Compute aggregate subject position
TermExecutionPosition ExecutionPosition
= _SubjectPositions.Aggregate(new TermExecutionPosition(),
(accumulator, it) => accumulator + it);
// NEW ALGO....
int MultiBldgSampleCount = ExecutionPosition.S_vector.Length;
double[] S_MultiBldg = new double[MultiBldgSampleCount];
double[] D_MultiBldg = new double[MultiBldgSampleCount];
double[] X_MultiBldg = new double[MultiBldgSampleCount];
#region Iterate over terms in this collection, in order (and, internally, over building samples)
for (int i = 0; i < MultiBldgSampleCount; i++)
{
S_MultiBldg[i] = ExecutionPosition.S_vector[i];
D_MultiBldg[i] = ExecutionPosition.D_vector[i];
X_MultiBldg[i] = ExecutionPosition.X_vector[i];
}
foreach (IGenericTerm term in this.GetContent())
{
for (int i = 0; i < MultiBldgSampleCount; i++)
{
Bindings[new SymbolicExpression("Subject")] =
S_MultiBldg[i];
double A = term.GetEvaluatedExpression(Bindings);
if (term is ISublimit)
{
// Functional Form
double X_ = 0.0;
if (!(term as ISublimit).IsNetOfDeductible())
{
// 1. Ground-up Sublimit
X_ = Math.Max(S_MultiBldg[i] - A, 0.0);
}
else
{
// 5. Net of Deductible Sublimit
X_ = Math.Max(S_MultiBldg[i] - D_MultiBldg[i] - A, 0.0);
}
// Interaction
double X__ = Math.Max(X_MultiBldg[i], X_);
// Final Adjustment
X_MultiBldg[i] = Math.Min(X__, S_MultiBldg[i] - D_MultiBldg[i]);
}
else // if (term is IDeductible)
{
// Functional Form
double D_ = 0.0;
if (!(term as IDeductible).IsFranchise())
{
D_ = Math.Min(S_MultiBldg[i], A);
}
else
{
D_ = (S_MultiBldg[i] > A) ? 0.0 : S_MultiBldg[i];
}
// Interaction
double D__ = 0.0;
switch ((term as IDeductible).GetInteraction())
{
case Interaction.SINGLELARGEST:
D__ = _SubjectPositions.Select(s => s.D_vector.Max()).Max();
break;
case Interaction.MIN:
if (!(term as IDeductible).IsAbsorbable())
{
D__ = Math.Max(D_MultiBldg[i], D_);
}
else
{
D__ = Math.Max(D_MultiBldg[i], D_ - X_MultiBldg[i]);
}
break;
case Interaction.MAX:
D__ = Math.Min(D_MultiBldg[i], D_);
break;
}
// Final Adjustment
D_MultiBldg[i] = Math.Min(D__, S_MultiBldg[i] - X_MultiBldg[i]);
}
} // end of for loop iteration over multi-building samples
} // end of for loop iteration over terms
#endregion
#region Iterate over building samples (and, internally, over terms, in order)
// ALGO....
//List<TermExecutionPosition.Component> SampledMultiBuildingOutputPositionComponents =
// new List<TermExecutionPosition.Component>();
//foreach (TermExecutionPosition.Component SampledMultiBuildingExecutionPositionComponent
// in ExecutionPosition.components)
//{
// TermExecutionPosition.Component SampledMultiBuildingOutputPositionComponent =
// new TermExecutionPosition.Component(SampledMultiBuildingExecutionPositionComponent);
// Bindings.Remove(new SymbolicExpression("Subject"));
// Bindings.Add(new SymbolicExpression("Subject"),
// SampledMultiBuildingOutputPositionComponent.S);
// // Iterate over terms in this collection, in order
// foreach (IGenericTerm term in this.GetContent())
// {
// double A = term.GetEvaluatedExpression(Bindings);
// if (term is ISublimit)
// {
// // Functional Form
// double X_ = 0.0;
// if (!(term as ISublimit).IsNetOfDeductible())
// // 1. Ground-up Sublimit
// X_ = Math.Max(SampledMultiBuildingOutputPositionComponent.S - A, 0.0);
// else
// // 5. Net of Deductible Sublimit
// X_ = Math.Max(SampledMultiBuildingOutputPositionComponent.S - SampledMultiBuildingOutputPositionComponent.D - A, 0.0);
// // Interaction
// double X__ = Math.Max(SampledMultiBuildingOutputPositionComponent.X, X_);
// // Final Adjustment
// SampledMultiBuildingOutputPositionComponent.X = Math.Min(X__, SampledMultiBuildingOutputPositionComponent.S - SampledMultiBuildingOutputPositionComponent.D);
// }
// else // if (term is IDeductible)
// {
// // Functional Form
// double D_ = 0.0;
// if (!(term as IDeductible).IsFranchise())
// D_ = Math.Min(SampledMultiBuildingOutputPositionComponent.S, A);
// else
// D_ = (SampledMultiBuildingOutputPositionComponent.S > A) ? 0.0 : SampledMultiBuildingOutputPositionComponent.S;
// // Interaction
// double D__ = 0.0;
// switch ((term as IDeductible).GetInteraction())
// {
// case Interaction.SINGLELARGEST:
// D__ = _SubjectPositions.Select(s => s.components.Select(c => c.D).Max()).Max();
// break;
// case Interaction.MIN:
// if (!(term as IDeductible).IsAbsorbable())
// D__ = Math.Max(SampledMultiBuildingOutputPositionComponent.D, D_);
// else
// D__ = Math.Max(SampledMultiBuildingOutputPositionComponent.D, D_ - SampledMultiBuildingOutputPositionComponent.X);
// break;
// case Interaction.MAX:
// D__ = Math.Min(ExecutionPosition.D, D_);
// break;
// }
// // Final Adjustment
// SampledMultiBuildingOutputPositionComponent.D = Math.Min(D__, SampledMultiBuildingOutputPositionComponent.S - SampledMultiBuildingOutputPositionComponent.X);
// }
// }
// SampledMultiBuildingOutputPositionComponents.Add(SampledMultiBuildingOutputPositionComponent);
//}
#endregion
// Calculate number of buildings
int NumBuildings = 1;
Subject _TermNodeSubject = this.GetSubject();
if (_TermNodeSubject.PerRisk)
{
NumBuildings = _TermNodeSubject.NumBuildings;
}
return(new TermExecutionPosition(S_MultiBldg, D_MultiBldg, X_MultiBldg, ExecutionPosition.FactorArray, NumBuildings));
}
#endregion IF per-risk, multi-building
#region Single-building OR Summed
else
{
// Compute aggregate subject position & coalesce
_SubjectPositions.ForEach(x => x.Coalesce());
TermExecutionPosition ExecutionPosition
= _SubjectPositions.Aggregate(new TermExecutionPosition(), (accumulator, it) => accumulator + it);
ExecutionPosition.Coalesce(); // @FACTORCHANGES : ExecutionPosition.Coalesce(1);
Bindings.Remove(new SymbolicExpression("Subject"));
Bindings.Add(new SymbolicExpression("Subject"), ExecutionPosition.S);
// Iterate over terms in this collection, in order
foreach (IGenericTerm term in this.GetContent())
{
double A = term.GetEvaluatedExpression(Bindings);
if (term is ISublimit)
{
// Functional Form
double X_ = 0.0;
if (!(term as ISublimit).IsNetOfDeductible())
{
// 1. Ground-up Sublimit
X_ = Math.Max(ExecutionPosition.S - A, 0.0);
}
else
{
// 5. Net of Deductible Sublimit
X_ = Math.Max(ExecutionPosition.S - ExecutionPosition.D - A, 0.0);
}
// Interaction
double X__ = Math.Max(ExecutionPosition.X, X_);
// Final Adjustment
ExecutionPosition.X = Math.Min(X__, ExecutionPosition.S - ExecutionPosition.D);
}
else // if (term is IDeductible)
{
// Functional Form
double D_ = 0.0;
if (!(term as IDeductible).IsFranchise())
{
D_ = Math.Min(ExecutionPosition.S, A);
}
else
{
D_ = (ExecutionPosition.S > A) ? 0.0 : ExecutionPosition.S;
}
// Interaction
double D__ = 0.0;
switch ((term as IDeductible).GetInteraction())
{
case Interaction.SINGLELARGEST:
D__ = _SubjectPositions.Select(s => s.D).Max();
break;
case Interaction.MIN:
if (!(term as IDeductible).IsAbsorbable())
{
D__ = Math.Max(ExecutionPosition.D, D_);
}
else
{
D__ = Math.Max(ExecutionPosition.D, D_ - ExecutionPosition.X);
}
break;
case Interaction.MAX:
D__ = Math.Min(ExecutionPosition.D, D_);
break;
}
// Final Adjustment
ExecutionPosition.D = Math.Min(D__, ExecutionPosition.S - ExecutionPosition.X);
}
}
return(ExecutionPosition);
}
#endregion Single-building OR Summed
}
