/// <summary>
/// When array creations are assigned to stochastic arrays, this creates corresponding arrays for the marginal and uses channels.
/// </summary>
/// <param name="iace"></param>
/// <returns></returns>
protected override IExpression ConvertArrayCreate(IArrayCreateExpression iace)
{
IAssignExpression iae = context.FindAncestor <IAssignExpression>();
if (iae == null)
{
return(iace);
}
if (iae.Expression != iace)
{
return(iace);
}
IVariableDeclaration ivd = Recognizer.GetVariableDeclaration(iae.Target);
VariableToChannelInformation vtci = context.InputAttributes.Get <VariableToChannelInformation>(ivd);
if (vtci == null)
{
return(iace); // not a stochastic variable
}
// Check if this is the last level of indexing
bool lastLevel = (!(iace.Type is IArrayType));
if ((lastLevel) && (vtci.usesEqualDefsStatements != null))
{
if (vtci.IsUsesEqualDefsStatementInserted)
{
//Error("Duplicate array allocation.");
}
else
{
// Insert the UsesEqualDef statement after the array is fully allocated.
// Note the array elements will not have been defined yet.
LoopContext lc = context.InputAttributes.Get <LoopContext>(ivd);
RefLoopContext rlc = lc.GetReferenceLoopContext(context);
// IMPORTANT TODO: add this statement at the right level!
IStatement ist = context.FindAncestor <IStatement>();
if (rlc.loops.Count > 0)
{
ist = rlc.loops[0];
}
int ancIndex = context.GetAncestorIndex(ist);
Containers containers = context.InputAttributes.Get <Containers>(ivd);
Containers containersNeeded = containers.GetContainersNotInContext(context, ancIndex);
vtci.usesEqualDefsStatements = Containers.WrapWithContainers(vtci.usesEqualDefsStatements, containersNeeded.outputs);
context.AddStatementsAfter(ist, vtci.usesEqualDefsStatements);
vtci.IsUsesEqualDefsStatementInserted = true;
}
}
return(iace);
}
protected IExpression ConvertWithReplication(IExpression expr)
{
IVariableDeclaration baseVar = Recognizer.GetVariableDeclaration(expr);
// Check if this is an index local variable
if (baseVar == null) return expr;
// Check if the variable is stochastic
if (!CodeRecognizer.IsStochastic(context, baseVar)) return expr;
// Get the loop context for this variable
LoopContext lc = context.InputAttributes.Get<LoopContext>(baseVar);
if (lc == null)
{
Error("Loop context not found for '" + baseVar.Name + "'.");
return expr;
}
// Get the reference loop context for this expression
RefLoopContext rlc = lc.GetReferenceLoopContext(context);
// If the reference is in the same loop context as the declaration, do nothing.
if (rlc.loops.Count == 0) return expr;
// the set of loop variables that are constant wrt the expr
Set<IVariableDeclaration> constantLoopVars = new Set<IVariableDeclaration>();
constantLoopVars.AddRange(lc.loopVariables);
// collect set of all loop variable indices in the expression
Set<int> embeddedLoopIndices = new Set<int>();
List<IList<IExpression>> brackets = Recognizer.GetIndices(expr);
foreach (IList<IExpression> bracket in brackets)
{
foreach (IExpression index in bracket)
{
IExpression indExpr = index;
if (indExpr is IBinaryExpression ibe)
{
indExpr = ibe.Left;
}
IVariableDeclaration indVar = Recognizer.GetVariableDeclaration(indExpr);
if (indVar != null)
{
if (!constantLoopVars.Contains(indVar))
{
int loopIndex = rlc.loopVariables.IndexOf(indVar);
if (loopIndex != -1)
{
// indVar is a loop variable
constantLoopVars.Add(rlc.loopVariables[loopIndex]);
}
else
{
// indVar is not a loop variable
LoopContext lc2 = context.InputAttributes.Get<LoopContext>(indVar);
foreach (var ivd in lc2.loopVariables)
{
if (!constantLoopVars.Contains(ivd))
{
int loopIndex2 = rlc.loopVariables.IndexOf(ivd);
if (loopIndex2 != -1)
embeddedLoopIndices.Add(loopIndex2);
else
Error($"Index {ivd} is not in {rlc} for expression {expr}");
}
}
}
}
}
else
{
foreach(var ivd in Recognizer.GetVariables(indExpr))
{
if (!constantLoopVars.Contains(ivd))
{
// copied from above
LoopContext lc2 = context.InputAttributes.Get<LoopContext>(ivd);
foreach (var ivd2 in lc2.loopVariables)
{
if (!constantLoopVars.Contains(ivd2))
{
int loopIndex2 = rlc.loopVariables.IndexOf(ivd2);
if (loopIndex2 != -1)
embeddedLoopIndices.Add(loopIndex2);
else
Error($"Index {ivd2} is not in {rlc} for expression {expr}");
}
}
}
}
}
}
}
// Find loop variables that must be constant due to condition statements.
List<IStatement> ancestors = context.FindAncestors<IStatement>();
foreach (IStatement ancestor in ancestors)
{
if (!(ancestor is IConditionStatement ics))
continue;
ConditionBinding binding = new ConditionBinding(ics.Condition);
IVariableDeclaration ivd = Recognizer.GetVariableDeclaration(binding.lhs);
IVariableDeclaration ivd2 = Recognizer.GetVariableDeclaration(binding.rhs);
int index = rlc.loopVariables.IndexOf(ivd);
if (index >= 0 && IsConstantWrtLoops(ivd2, constantLoopVars))
{
constantLoopVars.Add(ivd);
continue;
}
int index2 = rlc.loopVariables.IndexOf(ivd2);
if (index2 >= 0 && IsConstantWrtLoops(ivd, constantLoopVars))
{
constantLoopVars.Add(ivd2);
continue;
}
}
// Determine if this expression is being defined (is on the LHS of an assignment)
bool isDef = Recognizer.IsBeingMutated(context, expr);
Containers containers = context.InputAttributes.Get<Containers>(baseVar);
IExpression originalExpr = expr;
for (int currentLoop = 0; currentLoop < rlc.loopVariables.Count; currentLoop++)
{
IVariableDeclaration loopVar = rlc.loopVariables[currentLoop];
if (constantLoopVars.Contains(loopVar))
continue;
IForStatement loop = rlc.loops[currentLoop];
// must replicate across this loop.
if (isDef)
{
Error("Cannot re-define a variable in a loop. Variables on the left hand side of an assignment must be indexed by all containing loops.");
continue;
}
if (embeddedLoopIndices.Contains(currentLoop))
{
string warningText = "This model will consume excess memory due to the indexing expression {0} inside of a loop over {1}. Try simplifying this expression in your model, perhaps by creating auxiliary index arrays.";
Warning(string.Format(warningText, originalExpr, loopVar.Name));
}
// split expr into a target and extra indices, where target will be replicated and extra indices will be added later
var extraIndices = new List<IEnumerable<IExpression>>();
AddUnreplicatedIndices(rlc.loops[currentLoop], expr, extraIndices, out IExpression exprToReplicate);
VariableInformation varInfo = VariableInformation.GetVariableInformation(context, baseVar);
IExpression loopSize = Recognizer.LoopSizeExpression(loop);
IList<IStatement> stmts = Builder.StmtCollection();
List<IList<IExpression>> inds = Recognizer.GetIndices(exprToReplicate);
IVariableDeclaration newIndexVar = loopVar;
// if loopVar is already an indexVar of varInfo, create a new variable
if (varInfo.HasIndexVar(loopVar))
{
newIndexVar = VariableInformation.GenerateLoopVar(context, "_a");
context.InputAttributes.CopyObjectAttributesTo(loopVar, context.OutputAttributes, newIndexVar);
}
IVariableDeclaration repVar = varInfo.DeriveArrayVariable(stmts, context, VariableInformation.GenerateName(context, varInfo.Name + "_rep"),
loopSize, newIndexVar, inds, useArrays: true);
if (!context.InputAttributes.Has<DerivedVariable>(repVar))
context.OutputAttributes.Set(repVar, new DerivedVariable());
if (context.InputAttributes.Has<ChannelInfo>(baseVar))
{
VariableInformation repVarInfo = VariableInformation.GetVariableInformation(context, repVar);
ChannelInfo ci = ChannelInfo.UseChannel(repVarInfo);
ci.decl = repVar;
context.OutputAttributes.Set(repVar, ci);
}
// Create replicate factor
Type returnType = Builder.ToType(repVar.VariableType);
IMethodInvokeExpression repMethod = Builder.StaticGenericMethod(
new Func<PlaceHolder, int, PlaceHolder[]>(Clone.Replicate),
new Type[] {returnType.GetElementType()}, exprToReplicate, loopSize);
IExpression assignExpression = Builder.AssignExpr(Builder.VarRefExpr(repVar), repMethod);
// Copy attributes across from variable to replication expression
context.InputAttributes.CopyObjectAttributesTo<Algorithm>(baseVar, context.OutputAttributes, repMethod);
context.InputAttributes.CopyObjectAttributesTo<DivideMessages>(baseVar, context.OutputAttributes, repMethod);
context.InputAttributes.CopyObjectAttributesTo<GivePriorityTo>(baseVar, context.OutputAttributes, repMethod);
stmts.Add(Builder.ExprStatement(assignExpression));
// add any containers missing from context.
containers = new Containers(context);
// RemoveUnusedLoops will also remove conditionals involving those loop variables.
// TODO: investigate whether removing these conditionals could cause a problem, e.g. when the condition is a conjunction of many terms.
containers = Containers.RemoveUnusedLoops(containers, context, repMethod);
if (context.InputAttributes.Has<DoNotSendEvidence>(baseVar)) containers = Containers.RemoveStochasticConditionals(containers, context);
//Containers shouldBeEmpty = containers.GetContainersNotInContext(context, context.InputStack.Count);
//if (shouldBeEmpty.inputs.Count > 0) { Error("Internal: Variable is out of scope"); return expr; }
if (containers.Contains(loop))
{
Error("Internal: invalid containers for replicating " + baseVar);
break;
}
int ancIndex = containers.GetMatchingAncestorIndex(context);
Containers missing = containers.GetContainersNotInContext(context, ancIndex);
stmts = Containers.WrapWithContainers(stmts, missing.inputs);
context.OutputAttributes.Set(repVar, containers);
List<IForStatement> loops = context.FindAncestors<IForStatement>(ancIndex);
foreach (IStatement container in missing.inputs)
{
if (container is IForStatement ifs) loops.Add(ifs);
}
context.OutputAttributes.Set(repVar, new LoopContext(loops));
// must convert the output since it may contain 'if' conditions
context.AddStatementsBeforeAncestorIndex(ancIndex, stmts, true);
baseVar = repVar;
expr = Builder.ArrayIndex(Builder.VarRefExpr(repVar), Builder.VarRefExpr(loopVar));
expr = Builder.JaggedArrayIndex(expr, extraIndices);
}
return expr;
}
