public virtual BDDNode GetObstructionSet(Goal goal)
{
if (goalCache.ContainsKey(goal))
{
return(goalCache[goal]);
}
IEnumerable <GoalRefinement> refinements = goal.Refinements();
IEnumerable <Obstruction> obstructions = goal.Obstructions();
if ((refinements.Count() + obstructions.Count()) > 1)
{
throw new PropagationException(PropagationException.INVALID_MODEL + $". Check '{goal.Identifier}' for obstructions and refinements.");
}
var r = refinements.SingleOrDefault();
if (r != null)
{
BDDNode acc = null;
foreach (var child in goal.Exceptions())
{
if (acc == null)
{
acc = GetObstructionSet(child);
}
else
{
var bDDNode = GetObstructionSet(child);
acc = _manager.Or(acc, bDDNode);
}
}
if (acc == null)
{
acc = GetObstructionSet(r);
}
else
{
var bDDNode = GetObstructionSet(r);
acc = _manager.Or(acc, bDDNode);
}
goalCache.Add(goal, acc);
return(acc);
}
var o = obstructions.SingleOrDefault();
if (o != null)
{
BDDNode bn = GetObstructionSet(o);
goalCache.Add(goal, bn);
return(bn);
}
goalCache.Add(goal, _manager.Zero);
return(_manager.Zero);
}
private BDDNode GetAndOr(int height, int max, int m2, BDDManager manager, Random r)
{
if (r.NextDouble() > .5)
{
return(manager.Or(Generate(height + 1, max, m2, manager, r), Generate(height + 1, max, m2, manager, r)));
}
else
{
return(manager.And(Generate(height + 1, max, m2, manager, r), Generate(height + 1, max, m2, manager, r)));
}
}
private BDDNode AppyToAll(List <GeneLink> froms, int i,
bool value, string func)
{
BDDNode app = null;
foreach (var f in froms)
{
var formatParameter = Formater.FormatParameter(f.From, i);
var param = _nodeStore[formatParameter];
var node1 =
BDDSharpSolver.CreateNodeBasedOnAutomata(
formatParameter, true, _manager,
param.Index);
if (func == OR)
{
if (app == null)
{
app = node1;
}
else
{
app = _manager.Or(app, node1);
}
}
else
if (func == AND)
{
if (app == null)
{
app = node1;
}
else
{
app = _manager.And(app, node1);
}
}
}
if (!value)
{
app = _manager.Not(app);
}
return(app);
}
static void Main(string[] args)
{
var manager = new BDDManager(10);
//var n3 = new BDDNode(2, manager.One, manager.One);
//var n4 = new BDDNode(1, n3, manager.Zero);
//var n2 = new BDDNode(1, n3, manager.Zero);
//var n3 = manager.Create(2, manager.One, manager.One);
//var n4 = manager.Create(1, n3, manager.Zero);
//var n2 = manager.Create(1, n3, manager.Zero);
//var root = manager.Create(0,n2, n4);
//Console.WriteLine(n2);
//Console.WriteLine(n3);
//Console.WriteLine(n4);
//Console.WriteLine(root);
int index = 1;
var p1_s = manager.Create(index++, manager.One, manager.Zero);
var p1_k = manager.Create(index++, manager.One, manager.Zero);
//var root = manager.Create(3, p1_s, p1_k);
Console.WriteLine(p1_k);
Console.WriteLine(p1_s);
//var n2 = new BDDNode(1, p1_s, manager.Zero);
var node = manager.Or(p1_k, p1_s);
//node.Index = index++;
var root = manager.Create(0, node, manager.Zero);
Console.WriteLine(node);
Console.WriteLine(root);
//var reducedNode=manager.Reduce(root);
//Console.WriteLine(reducedNode);
var str = manager.ToDot(node);
Console.WriteLine(str);
//var root = new BDDNode(0, node, manager.Zero);
//Console.WriteLine(root);
//var node1 = manager.And(p1_k, p1_s);
//var root1 = new BDDNode(0, node1, manager.Zero);
//
//var c = manager.Create(10, manager.Zero, manager.One);
//string str = manager.Zero.ToString();
//string str1 = manager.One.ToString();
//Console.WriteLine(node1);
//Console.WriteLine(node);
//Console.WriteLine(node1);
//Console.WriteLine(reucedBddNode);
// --------------------------
//Program p = new Program();
//p.TestLarge01(30, 30);
// Console.WriteLine(manager.ToDot(root));
//var reucedBddNode = manager.Reduce(node);
//Console.WriteLine(manager.ToDot(reucedBddNode));
//Console.WriteLine(str);
//Console.WriteLine(str1);
//Console.WriteLine(root1);
//Console.WriteLine(reucedBddNode);
Console.Read();
//var root =new BDDNode(0, P1_1&000&000BI, P1_1&000&000CSL, P1_1&500&000BI, P1_1&500&000CSL, P1_10&000&000BI, P1_10&000&000CSL, P1_100&000BI, P1_100&000CSL, P1_2&000&000BI, P1_2&000&000CSL, P1_200&000BI, P1_200&000CSL, P1_25&000BI, P1_25&000CSL, P1_3&000&000BI, P1_3&000&000CSL, P1_300&000BI, P1_300&000CSL, P1_4&000&000BI, P1_4&000&000CSL, P1_5&000&000BI, P1_5&000&000CSL, P1_50&000BI, P1_50&000CSL, P1_500&000BI, P1_500&000CSL)
// var P2_1&000&000BI = new BDDNode(2, false);
//var P1_1 &000&000BI=new BDDNode(1,)
}
private BDDNode CreateFunctionApplication(
BDDManager manager,
Dictionary <string, List <int> > availableFunctions,
IEnumerable <IGrouping <string, GeneLink> > toDictionary,
int i,
Dictionary <string, BDDNode> nodeStore)
{
BDDNode res = null;
toDictionary.ToList().ForEach(ff =>
{
BDDNode ass = null;
var froms = ff.Where(a => !a.IsOptional).ToList();
// can be null!!
var to = Formater.FormatParameter(ff.Key, i + 1);
if (availableFunctions == null || !availableFunctions.ContainsKey(ff.Key))
{
var from1 = Formater.FormatParameter(ff.FirstOrDefault().From, i);
//TODO: NOT!
res = manager.Equal(nodeStore[from1], nodeStore[to]);
}
else // real functions
{
var availableFunc = availableFunctions[ff.Key];
var funcAssignmentHelper =
new BddNodeFuncAssignmentHelper(manager, nodeStore);
BDDNode rightSide = null;
var leftSide =
BDDSharpSolver.CreateNodeBasedOnAutomata(
to, true, manager,
nodeStore[to].Index);
availableFunc.ForEach(f =>
{
ass =
funcAssignmentHelper.CreateFuncAssignment(to, froms, i, f);
ass = manager.And(nodeStore[CreateFunctionKey(f, ff.Key)], ass);
if (rightSide == null)
{
rightSide = ass;
}
else
{
rightSide = manager.Or(rightSide, ass);
}
});
logger.Info("Right Side");
LogToDotFormat(rightSide, manager, nodeStore);
res = manager.Equal(leftSide, rightSide);
}
});
return(res);
}
public bool IsValidPath(GeneNode automata, List <GeneLink> booleanNetwok, Dictionary <string, List <int> > availableFunctions = null)
{
var nodeStore = new Dictionary <string, BDDNode>();
var letters = new List <string>();
var depth = automata.NodeLength;
int z = 0;
var manager = new BDDManager(50);
automata.GetAllConditionLetters(letters);
letters =
letters.SelectMany(l => Enumerable.Range(0, depth).ToList().Select(n => Formater.FormatParameter(l, n)))
.ToList();
int nodeNumber = 0;
logger.Info(string.Join(",", letters));
var assignments = BDDLogicHelper.CreateDictBasedOnAutomata(automata);
nodeStore["1"] = manager.One;
nodeStore["0"] = manager.Zero;
var assignmentsBDDNode = CreateAssignmentsBddNodes(assignments, manager, nodeStore, ref nodeNumber);
BDDNode functionNodes = null;
var functionsKeys = CreateFunctionsKeys(availableFunctions);
functionsKeys.ToList().ForEach(f =>
{
BDDNode currentNodeOr = null;
List <BDDNode> currents = new List <BDDNode>();
f.Value.ForEach(d =>
{
var c = manager.Create(nodeNumber++, 1, 0);
nodeStore[d] = c;
currents.Add(c);
if (currentNodeOr == null)
{
currentNodeOr = c;
}
else
{
currentNodeOr = manager.Or(c, currentNodeOr);
}
});
currentNodeOr = manager.Equal(manager.One, currentNodeOr);
if (functionNodes == null)
{
functionNodes = currentNodeOr;
}
else
{
functionNodes = manager.And(functionNodes, currentNodeOr);
}
});
var relations =
CreateExpressionsFromBooleanNetwork(manager, booleanNetwok, availableFunctions, depth, nodeStore);
relations = manager.And(relations, functionNodes);
var root = manager.And(relations, assignmentsBDDNode);
//// LOG PART
LogToDotFormat(root, manager, nodeStore);
//logger.Info("relations");
//logger.Info(manager.ToDot(relations, show_all: false));
//logger.Info("assignments");
//logger.Info(manager.ToDot(assignmentsBDDNode, show_all: false));
IEnumerable <KeyValuePair <string, bool> > truth = BuildThruthTable(manager, root, nodeNumber);
assignments.ToList().ForEach(a =>
{
var index = nodeStore[a.Key].Index;
truth = truth.Where(d =>
d.Key[index] == (a.Value ? '1' : '0'));
});
var pathes = truth.Where(a => a.Value).ToList();
LogValidPathes(pathes, nodeStore);
return(pathes.Any());
// CheckThruthTable(truth, res);
//return true;
}
public override BDDNode Or(BDDNode a, BDDNode b)
{
var bddNode = _manager.Or(a, b);
return(bddNode);
}
