public void TestOr()
{
{
var res = new Or(
BooleanFalse.Instance,
BooleanFalse.Instance
);
Assert.AreEqual(false, res.Value);
}
{
var res = new Or(
BooleanTrue.Instance,
BooleanFalse.Instance
);
Assert.AreEqual(true, res.Value);
}
{
var res = new Or(
BooleanFalse.Instance,
BooleanTrue.Instance
);
Assert.AreEqual(true, res.Value);
}
{
var res = new Or(
BooleanTrue.Instance,
BooleanTrue.Instance
);
Assert.AreEqual(true, res.Value);
}
}
public static LogicElement C2prime(ParserState state)
{
Token t = state.PeepToken();
if (t == null)
{
return(null);
}
if (t.Name == "||")
{
state.PopToken();
LogicElement exp = C3(state);
if (exp.Right == null)
{
exp.Right = C2prime(state);
}
Or or = new Or(null, exp);
return(or);
}
else if (t.Type == TokenType.Operator)
{
return(null);
}
else if (t.Type != TokenType.Keyword && !state.Action.ContainsKey(t.Name))
{
t.ThrowException("Expected keyword token or action.");
}
return(null);
}
public void XOrNotX()
{
INode root = new Or(new Not(VariableNode.Make<bool>(0, "x")), VariableNode.Make<bool>(0, "x"));
Assert.AreEqual(
new Constant<bool>(true).ToString(),
SimplifyLogicTree(root).ToString());
}
public void OrFalseFalse( )
{
Or <object> or = new Or <object>(False <object> .Instance, False <object> .Instance);
IViolation <object> violation = or.Check(null);
Assert.AreNotEqual(NonViolation <object> .Instance, violation);
}
private Node ApplyDeMorgan(Node current)
{
// Pending: There should be a cleaner way of resolving all this casting
if (current is LiteralNode)
{
return(new ComplementNode(current.cargo));
}
else if (current is ComplementNode)
{
return(new LiteralNode(current.cargo));
}
else if (current is And)
{
Or result = new Or(new OrOperator());
result.left = ApplyDeMorgan((current as And).left);
result.right = ApplyDeMorgan((current as And).right);
return(result);
}
else if (current is Or)
{
And result = new And(new AndOperator());
result.left = ApplyDeMorgan((current as Or).left);
result.right = ApplyDeMorgan((current as Or).right);
return(result);
}
else
{
return((current as Not).left);
}
}
public void Visit(Or c)
{
Console.WriteLine("pop stack into a");
Console.WriteLine("pop stack into b");
Console.WriteLine("or b");
Console.WriteLine("push 1 if zero flag set, else push 0");
}
public override void Init(Color color)
{
Color = color;
Step.setConstsFor(color);
DefaultConstraints.SetupBuildDefaults();
move = new Or(
new Or(
new Step(Step.LEFT_FORWARD),
new Step(Step.RIGHT_FORWARD)
).AddConstraint(new StartLevelConstraint(3)),
new Or(
color == Color.BLACK ? BlackLevelTwoMoves : WhiteLevelTwoMoves
).AddConstraint(new StartLevelConstraint(2))
);
DefaultConstraints.SetupBuildDefaults(new BlockAllyAndVoidCapture());
capture = new Or(
new Step(Step.DOWN),
new Step(Step.FORWARD)
).AddConstraint(new StartLevelConstraint(3));
addBasicConstraints();
}
/// <summary>
/// Get the binary tree of DNF
/// </summary>
/// <param name="rows"></param>
/// <returns></returns>
private Proposition GetDNFRecursively(List <Row> rows)
{
Proposition root = null;
//if there is 1 row, return the DNF of it
if (rows.Count == 1)
{
root = rows[0].GetDNF();
}
//if there is more than 1 row, return a binary tree with root 'Or'
else if (rows.Count > 1)
{
root = new Or();
root.LeftNode = rows[0].GetDNF();
rows.RemoveAt(0);
//if there is 1 row in the right, return the right node
if (rows.Count == 1)
{
root.RightNode = rows[0].GetDNF();
}
//if there is more than 1 row, create the right sub-tree
else
{
root.RightNode = GetDNFRecursively(rows);
}
}
return(root);
}
public IArithmeticLogicUnit Create(Action <IByte> updateAcc, Action <Caez> updateFlags)
{
var not = new Not();
var and = new And();
var nAnd = new NAnd(not, and);
var or = new Or(not, nAnd);
var xOr = new XOr(not, nAnd);
var byteFactory = new ByteFactory(new Base10Converter());
return(new ArithmeticLogicUnit(
new ByteXOr(xOr, byteFactory),
new ByteOr(or, byteFactory),
new ByteAnd(and, byteFactory),
new Inverter(not, byteFactory),
new ByteAdder(new BitAdder(xOr, or, and), byteFactory),
new ByteEnabler(and, byteFactory),
and,
new IsZeroGate(or, not),
new ByteDecoder(new Decoder(not, and), byteFactory),
new ByteRightShifter(byteFactory),
new ByteLeftShifter(byteFactory),
or,
new AluWire(byteFactory),
new ByteComparator(new BitComparator(xOr, and, or, not), byteFactory), updateFlags,
updateAcc, byteFactory));
}
public override Item Clone()
{
return(new OrItem()
{
Or = Or?.Select(o => o?.Clone()).ToArray(),
});
}
public override Value Visit(Or or)
{
Value left = or.Left.Accept(this);
Value right = or.Right.Accept(this);
return(left.Or(right));
}
public void OrOne()
{
INode root = new Or(VariableNode.Make<bool>(0, "x"), new Constant<bool>(true));
Assert.AreEqual(
bool.TrueString,
SimplifyLogicTree(root).ToString());
}
public object Visit(Or expression)
{
object leftValue = expression.Left.Accept <object>(this);
object rightValue = expression.Right.Accept <object>(this);
return((bool)leftValue || (bool)rightValue);
}
public override void Init(Color color)
{
Color = color;
Step.setConstsFor(color);
DefaultConstraints.SetupBuildDefaults();
move = new Or(
new Step(Step.RIGHT_FORWARD),
new Step(Step.RIGHT_BACKWARD),
new Step(Step.LEFT_BACKWARD),
new Step(Step.LEFT_FORWARD),
new Step(2f * Step.RIGHT_BACKWARD),
new Step(2f * Step.RIGHT_FORWARD),
new Step(2f * Step.LEFT_BACKWARD),
new Step(2f * Step.LEFT_FORWARD),
new Step(Step.TRIAGONAL_DOWN_LEFT_BACKWARD),
new Step(Step.TRIAGONAL_DOWN_LEFT_FORWARD),
new Step(Step.TRIAGONAL_DOWN_RIGHT_BACKWARD),
new Step(Step.TRIAGONAL_DOWN_RIGHT_FORWARD),
new Step(Step.TRIAGONAL_UP_LEFT_BACKWARD),
new Step(Step.TRIAGONAL_UP_LEFT_FORWARD),
new Step(Step.TRIAGONAL_UP_RIGHT_BACKWARD),
new Step(Step.TRIAGONAL_UP_RIGHT_FORWARD)
).AddConstraint(new StartLevelConstraint(2));
DefaultConstraints.SetupBuildDefaults(new BlockAllyAndVoidCapture());
capture = move.Clone();
addBasicConstraints();
}
public new static And Where(params Where[] wheres)
{
var or = new Or();
or.Wheres.AddRange(wheres);
return(or);
}
public string ToStringTree(int level = 0)
{
var indent = new string(' ', level *2);
if (level != 0)
{
indent += "| ";
}
string PrintChildren(params AstNode[] nodes)
{
string res = "\n";
foreach (var n in nodes)
{
res += n.ToStringTree(level + 1);
}
return(res);
}
return(indent + this switch {
Int v => $"int: {v.val}\n",
Binary v => $"binary: " + PrintChildren(v.a, v.b),
Unary v => $"unary: " + PrintChildren(v.a),
Variable v => $"var '{v.name}'\n",
FunCall v => $"funCall: " + PrintChildren(v.fun, v.arg),
Lambda v => $"lambda {v.param}: " + PrintChildren(v.body),
Assign v => $"assign {v.name}:" + PrintChildren(v.val),
Or v => $"or: " + PrintChildren(v.a, v.b),
And v => $"and: " + PrintChildren(v.a, v.b),
If v => $"if: " + PrintChildren(v.cond, v.t, v.f),
_ => ToString() + "\n",
});
public override string ToString()
{
Not notLeft = new Not(Left);
Or or = new Or(notLeft, Right);
return(or.ToString());
}
public Value Visit(Or node)
{
Value left = node.Left().Accept(this);
Value right = node.Right().Accept(this);
return(left.Or(right));
}
public void EqualsTestDifferentTypes()
{
IOperator firestOperator = new Not("token");
IOperator secondOperator = new Or("token");
Assert.False(firestOperator.Equals(secondOperator));
}
public bool Evaluate(string rawMessage)
{
if (rawMessage == null)
{
return(false);
}
bool AndResult = true, OrResult = true, NotAllResult = true, NotAnyResult = true;
if (And != null && And.Count > 0)
{
AndResult = And.All(x => Regex.IsMatch(rawMessage, x, (RegexOptions)Options));
}
if (Or != null && Or.Count > 0)
{
OrResult = Or.Any(x => Regex.IsMatch(rawMessage, x, (RegexOptions)Options));
}
if (NotAll != null && NotAll.Count > 0)
{
NotAllResult = !NotAll.All(x => Regex.IsMatch(rawMessage, x, (RegexOptions)Options));
}
if (NotAny != null && NotAny.Count > 0)
{
NotAnyResult = !NotAny.Any(x => Regex.IsMatch(rawMessage, x, (RegexOptions)Options));
}
return(AndResult && OrResult && NotAllResult && NotAnyResult);
}
public void ShouldBuildOrPredicate()
{
Terminal a, b, c;
Or predicate;
ISituationGraph <char> graph;
LexicalRule rule;
SituationGraphFactory <char> situationGraphFactory;
situationGraphFactory = new SituationGraphFactory <char>(new SituationGraphSegmentFactory <char>());
a = new Terminal('a');
b = new Terminal('b');
c = new Terminal('c');
predicate = new Or();
predicate.Items.Add(a);
predicate.Items.Add(b);
predicate.Items.Add(c);
rule = new LexicalRule()
{
Name = "A", Predicate = predicate
};
graph = situationGraphFactory.BuildSituationGraph(rule.AsEnumerable());
Assert.IsTrue(graph.Contains(a));
Assert.IsTrue(graph.Contains(b));
Assert.IsTrue(graph.Contains(c));
}
public static Schaltnetz Tests()
{
var and1 = new And();
var and2 = new And();
var and3 = new And();
var or4 = new Or();
var sn = new Schaltnetz(2, new Gatter[] { or4 });
sn.Inputs[0].OutputsTo.Add(and1);
sn.Inputs[1].NOT.OutputsTo.Add(and1);
sn.Inputs[0].OutputsTo.Add(and2);
sn.Inputs[0].NOT.OutputsTo.Add(and2);
sn.Inputs[0].NOT.OutputsTo.Add(and3);
sn.Inputs[1].OutputsTo.Add(and3);
and1.OutputsTo.Add(or4);
and2.OutputsTo.Add(or4);
and3.OutputsTo.Add(or4);
return(sn);
}
public void Visit(Or or)
{
AddToQueue(or);
or.Left.Accept(this);
or.Right.Accept(this);
//return true;
}
public IEnumerable <Query> All()
{
yield return(this);
if (And != null)
{
foreach (var q in And.All())
{
yield return(q);
}
}
if (Or != null)
{
foreach (var q in Or.All())
{
yield return(q);
}
}
if (Not != null)
{
foreach (var q in Not.All())
{
yield return(q);
}
}
}
public override void Init(Color color)
{
Color = color;
Step.setConstsFor(color);
DefaultConstraints.SetupBuildDefaults();
move = new Or(
new Or(
new Step(Step.FORWARD),
new Step(Step.LEFT),
new Step(Step.RIGHT)
).AddConstraint(new StartLevelConstraint(1, 2)),
new Step(Step.DOWN).AddConstraint(new StartLevelConstraint(2))
);
DefaultConstraints.SetupBuildDefaults(new BlockAllyAndVoidCapture());
capture = new Or(
new Or(
new Step(Step.LEFT_FORWARD),
new Step(Step.RIGHT_FORWARD)
).AddConstraint(new StartLevelConstraint(1, 2)),
new Step(Step.UP).AddConstraint(new StartLevelConstraint(1))
);
addBasicConstraints();
}
public void EqualsTestNullInput()
{
var invertedIndex = new Mock <InvertedIndex>();
IOperator testOperator = new Or("token", invertedIndex.Object);
Assert.False(testOperator.Equals(null));
}
public void ThenResolveReturnsTrue()
{
var subject = new Or(0, 1);
var result = subject.Resolve(new object(), new List<IExpression> { new TrueExpression(), new FalseExpression() });
Assert.That(result, Is.True);
}
public void OrZero()
{
INode root = new Or(VariableNode.Make<bool>(0, "x"), new Constant<bool>(false));
Assert.AreEqual(
VariableNode.Make<bool>(0, "x").ToString(),
SimplifyLogicTree(root).ToString());
}
public void OrTest()
{
Assert.Equal(
$"{OP_0} OR {OP_1}",
Or.Do(op0, op1).ToString()
);
}
public void OrTrueTrue( )
{
Or <object> or = new Or <object>(True <object> .Instance, True <object> .Instance);
IViolation <object> violation = or.Check(null);
Assert.AreEqual(NonViolation <object> .Instance, violation);
}
public void CloneTest()
{
var exp = new Or(new Bool(true), new Bool(false));
var clone = exp.Clone();
Assert.Equal(exp, clone);
}
public void FilterTestwithStartingList()
{
var expectedResult = new List <string> {
"file4", "file1", "file2", "file3"
};
var mockedDatabase = new Mock <IProgramDatabase>();
var firstOperator = new Or("test");
mockedDatabase = GeneralFunctions.SetupDatabaseTryGetTokenDocumentIDs(
mockedDatabase,
firstOperator.Token,
new List <string> {
"file1", "file2"
},
true
);
var secondOperator = new Or("test2");
mockedDatabase = GeneralFunctions.SetupDatabaseTryGetTokenDocumentIDs(
mockedDatabase,
secondOperator.Token,
new List <string> {
"file1", "file3"
},
true
);
var testResult = new List <string> {
"file4"
};
testResult = firstOperator.Filter(testResult, mockedDatabase.Object);
testResult = secondOperator.Filter(testResult, mockedDatabase.Object);
Assert.Equal(expectedResult, testResult);
}
public void EqualsTestSameOperators()
{
IOperator firestOperator = new Or("token");
IOperator secondOperator = new Or("token");
Assert.True(firestOperator.Equals(secondOperator));
}
public void TestSimpleOr()
{
var or = new Or(new Property("False"), new Property("False"));
Assert.That(or.Evaluate(new Reflection(this)), Is.EqualTo(false));
or = new Or(new Property("True"), new Property("False"));
Assert.That(or.Evaluate(new Reflection(this)), Is.EqualTo(true));
or = new Or(new Property("True"), new Property("True"));
Assert.That(or.Evaluate(new Reflection(this)), Is.EqualTo(true));
}
private static Condition GetWhereCondition(List<Compare> conditions, bool andOperator = true)
{
if (conditions.Count == 1)
return conditions[0];
LogicalCondition result;
if (andOperator)
result = new And();
else
result = new Or();
result.Conditions =(Condition[]) Convert.ChangeType( conditions.ToArray(),typeof(Condition[]));
return result;
}
private void add(String[] tags)
{
Or or = new Or();
foreach (String tag in tags)
{
bool negation;
string trimmedTag = tag.Trim();
if (trimmedTag.StartsWith("~"))
{
trimmedTag = trimmedTag.Substring(1);
negation = true;
}
else
{
negation = false;
}
String[] tagAndLimit = trimmedTag.Split(':');
if (tagAndLimit.Length == 2)
{
trimmedTag = tagAndLimit[0];
int limit = int.Parse(tagAndLimit[1]);
if (_limits.ContainsKey(trimmedTag) && _limits[trimmedTag] != limit)
{
throw new BadTagLimitException(trimmedTag, _limits[trimmedTag], limit);
}
_limits[trimmedTag] = limit;
}
if (negation)
{
or.add(new Not(new TagExp(trimmedTag)));
}
else
{
or.add(new TagExp(trimmedTag));
}
}
and.add(or);
}
public Node AndDistribute()
{
var distributedNodes = Nodes.Select (x => x.AndDistribute ()).ToList ();
var i = distributedNodes.FindIndex (x => x.GetType () == typeof(Or));
if (i >= 0) {
var pivot = (Or)distributedNodes.ElementAt (i);
var newNode = new Or ();
var remainingNodes = distributedNodes.Where (x => x != pivot).Select (x => x.AndDistribute ());
var head = new List<Node> (pivot.Nodes.Take (1).Select (x => x.AndDistribute ()));
var tail = new List<Node> (pivot.Nodes.Skip (1).Select (x => x.AndDistribute ()));
// Console.WriteLine ("Head = " + string.Join (",", head.Select (x => x.ToString ())));
// Console.WriteLine ("Tail = " + string.Join (",", tail.Select (x => x.ToString ())));
newNode.Nodes.Add (new And (new List<Node> (remainingNodes).Union (head)).AndDistribute ());
newNode.Nodes.Add (new And (new List<Node> (remainingNodes).Union (tail)).AndDistribute ());
return newNode;
}
return new And { Nodes = distributedNodes };
}
private Node ApplyDistributiveProperty(Node current)
{
if ((current == null) || (current is TerminalNode))
{
return current;
}
else if (!(current is And))
{
NonTerminalNode nt = (NonTerminalNode)current;
nt.left = ApplyDistributiveProperty(nt.left);
nt.right = ApplyDistributiveProperty(nt.right);
return nt;
}
else
{
And and = (And) current;
// Check for an OR child
Or childOr = (and.left as Or);
Node otherChild = and.right;
if (childOr == null)
{
childOr = (and.right as Or);
otherChild = and.left;
}
// If neither child is an OR simply recurse
if (childOr == null)
{
and.left = ApplyDistributiveProperty(and.left);
and.right = ApplyDistributiveProperty(and.right);
return and;
}
// If either child is an OR
// convert (child.left OR child.right) AND otherChild into
// (child.left AND otherChild) OR (child.right AND otherChild)
else
{
// Create new operator nodes
Or or = new Or(new OrOperator());
And left = new And(new AndOperator());
And right = new And(new AndOperator());
// Populate new terms
left.left = childOr.left;
left.right = otherChild;
right.left = childOr.right;
right.right = otherChild;
// Recursively apply distributive rule to new terms
or.left = ApplyDistributiveProperty(left);
or.right = ApplyDistributiveProperty(right);
return or;
}
}
}
private Node expression()
{
Node n = term();
while (_tokens.Current is OrOperator)
{
Or or = new Or(_tokens.Current);
or.left = n;
_tokens.MoveNext();
n = term();
or.right = n;
n = or;
}
return n;
}
private Node ApplyDeMorgan(Node current)
{
// Pending: There should be a cleaner way of resolving all this casting
if (current is LiteralNode)
{
return new ComplementNode(current.cargo);
}
else if (current is ComplementNode)
{
return new LiteralNode(current.cargo);
}
else if (current is And)
{
Or result = new Or(new OrOperator());
result.left = ApplyDeMorgan((current as And).left);
result.right = ApplyDeMorgan((current as And).right);
return result;
}
else if (current is Or)
{
And result = new And(new AndOperator());
result.left = ApplyDeMorgan((current as Or).left);
result.right = ApplyDeMorgan((current as Or).right);
return result;
}
else
{
return (current as Not).left;
}
}
public void Visit(Or or)
{
or.Left.Accept(this);
_sb.Append(" || ");
or.Right.Accept(this);
}
// EliminateVarAnd
// EliminateVarOr
// EliminateVarLs
// EliminateVar
// EliminateVars
public static MathObject EliminateVariableEqLs(this List<Equation> eqs, Symbol sym)
{
if (eqs.Any(elt =>
elt.Operator == Equation.Operators.Equal &&
elt.Has(sym) &&
elt.AlgebraicExpand().Has(sym) &&
elt.IsolateVariableEq(sym).Has(obj => obj is Equation && (obj as Equation).a == sym && (obj as Equation).b.FreeOf(sym))
) == false)
return new And() { args = eqs.Select(elt => elt as MathObject).ToList() };
var eq = eqs.First(elt =>
elt.Operator == Equation.Operators.Equal &&
elt.Has(sym) &&
elt.AlgebraicExpand().Has(sym) &&
elt.IsolateVariableEq(sym).Has(obj => obj is Equation && (obj as Equation).a == sym && (obj as Equation).b.FreeOf(sym)));
var rest = eqs.Except(new List<Equation>() { eq });
var result = eq.IsolateVariableEq(sym);
// sym was not isolated
if (result is Equation &&
((result as Equation).a != sym || (result as Equation).b.Has(sym)))
return new And() { args = eqs.Select(elt => elt as MathObject).ToList() };
if (result is Equation)
{
var eq_sym = result as Equation;
return new And() { args = rest.Select(elt => elt.Substitute(sym, eq_sym.b)).ToList() }.Simplify();
// return new And() { args = rest.Select(rest_eq => rest_eq.SubstituteEq(eq_sym)).ToList() };
// rest.Map(rest_eq => rest_eq.Substitute(eq_sym)
}
// Or(
// And(eq0, eq1, eq2, ...)
// And(eq3, eq4, eq5, ...)
// )
if (result is Or && (result as Or).args.All(elt => elt is And))
{
(result as Or).args.ForEach(elt => (elt as And).args.AddRange(rest));
return new Or() { args = (result as Or).args.Select(elt => EliminateVariable(elt, sym)).ToList() };
}
if (result is Or)
{
var or = new Or();
foreach (Equation eq_sym in (result as Or).args)
or.args.Add(new And() { args = rest.Select(rest_eq => rest_eq.Substitute(sym, eq_sym.b)).ToList() }.Simplify());
return or;
// (result as Or).Map(eq_sym => new And() { args = rest.Select(rest_eq => rest_eq.SubstituteEq(eq_sym)).ToList() });
// (result as Or).Map(eq_sym => rest.Map(rest_eq => rest_eq.Substitute(eq_sym))
}
throw new Exception();
}
public static Node GetNonSatisfactionFormula(this Obstacle o)
{
if (o.Refinements ().Count () == 0) {
return new ObstacleRef { Obstacle = o };
}
var or = new Or ();
foreach (var refinement in o.Refinements ()) {
var and = new And ();
foreach (var obstacle in refinement.SubObstacles ()) {
and.Nodes.Add (GetNonSatisfactionFormula (obstacle));
}
foreach (var domprop in refinement.DomainProperties ()) {
and.Nodes.Add (GetNonSatisfactionFormula (domprop));
}
if (and.Nodes.Count == 1)
or.Nodes.Add (and.Nodes.Single ());
else
or.Nodes.Add (and);
}
if (or.Nodes.Count == 1)
return or.Nodes.Single ();
return or;
}
void Awake()
{
node = new Or(null, null);
lChild.OnSlotFilled += LeftChildFilled;
rChild.OnSlotFilled += RightChildFilled;
}
public void Visit(Or or)
{
// "Or" operator must be short circuited.
or.Left.Accept(this);
var br = Instruction.Create(OpCodes.Ldc_I4_1);
_instructions.Add(Instruction.Create(OpCodes.Brtrue_S, br));
or.Right.Accept(this);
var end = Instruction.Create(OpCodes.Nop);
_instructions.Add(Instruction.Create(OpCodes.Br, end));
_instructions.Add(br);
_instructions.Add(end);
}
private string BuildQuery()
{
Criteria contentTypeCriteria = Criteria.Eq("Content Type", "Computed", NewsContentType);
Criteria dateCriteria = Criteria.Geq("Modified", "DateTime", "<Today OffsetDays='-7'/>");
List<Expression> domainCriteria = new List<Expression>();
List<Expression> audienceCriteria = new List<Expression>();
bool joinWithAnd = false;
if (ddlCommunities.SelectedItem.Text != "All")
{
domainCriteria.Add(Criteria.Eq(CategoryDomains, "LookupMulti", ddlCommunities.SelectedItem.Text));
joinWithAnd = true;
}
else
{
CreateCriteria(EstablishedCommunities, CategoryDomains, ref domainCriteria);
}
if (ddlAudience.SelectedItem.Text != "All")
{
audienceCriteria.Add(Criteria.Eq(CategoryAudience, "LookupMulti", ddlAudience.SelectedItem.Text));
joinWithAnd = true;
}
else
{
CreateCriteria(EstablilshedAudiences, CategoryAudience, ref audienceCriteria);
}
Expression expression = null;
Expression domainExpression = null;
Expression audienceExpression = null;
switch (domainCriteria.Count)
{
default:
Operator domainOperator = new Or();
domainOperator.AddRange((IEnumerable<Expression>)domainCriteria);
domainExpression = domainOperator;
break;
case 0:
domainExpression = contentTypeCriteria;
break;
case 1:
domainExpression = domainCriteria[0];
break;
}
switch (audienceCriteria.Count)
{
default:
Operator audienceOperator = new Or();
audienceOperator.AddRange((IEnumerable<Expression>)audienceCriteria);
audienceExpression = audienceOperator;
break;
case 0:
audienceExpression = contentTypeCriteria;
break;
case 1:
audienceExpression = audienceCriteria[0];
break;
}
if (joinWithAnd == true)
{
expression = domainExpression * audienceExpression;
}
else
{
expression = domainExpression + audienceExpression;
}
Or freeTextCriteria = null;
//check free text
if (!string.IsNullOrEmpty(txtSearch.Text))
{
freeTextCriteria = Operator.Or(
Criteria.Contains("Title", "Text", txtSearch.Text),
Criteria.Contains("PublishingPageContent", "Note", txtSearch.Text)
);
}
if (freeTextCriteria != null)
{
expression = expression * freeTextCriteria;
}
if ((ddlCommunities.SelectedItem.Text == "All") && (ddlAudience.SelectedItem.Text == "All") && freeTextCriteria == null)
{
expression = dateCriteria * expression;
}
string result = String.Format("<Where>{0}</Where>", expression.GetCAML());
return(result);
}
public void Visit(Or or)
{
ResultIsBoolAndBothOperandsMustBeBool(or);
}
public static Node Simplify(this Node node)
{
var nvars = node.ReferencedObstacles ().Count ()
+ node.ReferencedVariables ().Count ()
+ node.ReferencedDomainProperties ().Count ();
var conversionMap = new Dictionary<Obstacle, int> ();
var i = 0;
var iEnumerable = node.ReferencedObstacles ();
foreach (var o in iEnumerable) {
if (!conversionMap.ContainsKey (o))
conversionMap.Add (o, i++);
}
var conditionMap = new Dictionary<Condition, int> ();
var iEnumerable2 = node.ReferencedVariables ();
foreach (var o in iEnumerable2) {
if (!conditionMap.ContainsKey (o))
conditionMap.Add (o, i++);
}
var dompropMap = new Dictionary<DomainProperty, int> ();
var iEnumerable3 = node.ReferencedDomainProperties ();
foreach (var o in iEnumerable3) {
if (!dompropMap.ContainsKey (o))
dompropMap.Add (o, i++);
}
// Console.WriteLine (node);
node = node.AndDistribute ();
// Console.WriteLine (node);
node = node.Flatten ();
// Console.WriteLine (node);
if (node is Or) {
var or = (Or)node;
var terms = new List<BoolSimplify.Term> ();
foreach (var n in or.Nodes) {
var vars = new byte[nvars];
for (int j = 0; j < nvars; j++)
vars [j] = Term.DontCare;
if (NewMethod (n, vars, conversionMap, conditionMap, dompropMap)) {
terms.Add (new Term (vars));
}
}
var karnaughFormula = new BoolSimplify.Formula (terms);
if (karnaughFormula.Terms.Count() == 0)
return new False ();
//Console.WriteLine (karnaughFormula);
karnaughFormula.ReduceToPrimeImplicants ();
if (karnaughFormula.Terms.Count() == 0)
return new False ();
// Console.WriteLine (karnaughFormula);
karnaughFormula.ReducePrimeImplicantsToSubset ();
if (karnaughFormula.Terms.Count() == 0)
return new False ();
// Console.WriteLine (karnaughFormula);
var simplifiedFormula = new Or ();
foreach (var t in karnaughFormula.Terms) {
var and = new And ();
for (int j = 0; j < t.NumVars; j++) {
if (t.Values [j] == 1) {
if (conversionMap.ContainsValue (j)) {
and.Nodes.Add (new ObstacleRef () {
Obstacle = conversionMap.Where (x => x.Value == j).Select (x => x.Key).Single ()
});
}
if (conditionMap.ContainsValue (j)) {
and.Nodes.Add (conditionMap.Where (x => x.Value == j).Select (x => x.Key).Single ());
}
if (dompropMap.ContainsValue (j)) {
and.Nodes.Add (new DomPropRef () {
DomainProperty = dompropMap.Where (x => x.Value == j).Select (x => x.Key).Single ()
});
}
}
if (t.Values [j] == 0) {
if (conversionMap.ContainsValue (j)) {
and.Nodes.Add (new ObstacleRef () {
Obstacle = conversionMap.Where (x => x.Value == j).Select (x => x.Key).Single ()
}.Negate ());
}
if (conditionMap.ContainsValue (j)) {
and.Nodes.Add (conditionMap.Where (x => x.Value == j).Select (x => x.Key).Single ().Negate ());
}
if (dompropMap.ContainsValue (j)) {
and.Nodes.Add (new DomPropRef () {
DomainProperty = dompropMap.Where (x => x.Value == j).Select (x => x.Key).Single ()
}.Negate ());
}
}
}
if (and.Nodes.Count > 0)
simplifiedFormula.Nodes.Add (and);
}
if (simplifiedFormula.Nodes.Count > 0)
return simplifiedFormula;
else
return new Not { Enclosed = new False () };
}
if (node is ObstacleRef | node is DomPropRef | node is False)
return node;
return node;
// throw new NotSupportedException (node.GetType ().ToString ());
}
public static Node GetNonSatisfactionFormula(this Goal g)
{
var refinements = g.Refinements ();
if (refinements.Count () > 1)
throw new NotSupportedException ();
if (refinements.Count () == 1) {
var refinement = refinements.Single ();
if (refinement.RefinementPattern == RefinementPattern.Redundant) {
return ANDPropagate (refinement);
}
if (refinement.RefinementPattern == RefinementPattern.Case) {
var orNode = new Or();
if (refinement.SubGoals().Count () != 2) {
throw new NotImplementedException ();
}
int index = 0;
foreach (var c in refinement.SubGoals ()) {
var andNode = new And ();
var probability = refinement.Parameters.ElementAt (index);
var condition = new Condition {
Cond = string.Format ("Case condition {0}", index),
Proba = probability
};
if (index == 0)
andNode.Nodes.Add (condition);
else if (index == 1)
andNode.Nodes.Add (condition.Negate ());
// TODO fix this bug, with Simplify() required.
var node = GetNonSatisfactionFormula (c);
andNode.Nodes.Add (node);
orNode.Nodes.Add (andNode);
index++;
}
return orNode;//.ToOr ();
}
return ORPropagate (refinement);
}
if (g.Obstructions().Count () == 1)
return GetNonSatisfactionFormula (g.Obstructions().Single().Obstacle ());
return new False ();
}
public List<UserObject> SearchUsers(string query)
{
List<UserObject> lst = new List<UserObject>();
IFilter filter = new Or(new Contains("ObjectSID", query),
new Contains("name", query),
new Contains(PersonAttributeNames.TelephoneNumber, query),
new Contains(PersonAttributeNames.Department, query),
new Contains(PersonAttributeNames.Title, query));
foreach (var adObject in ADObjectQuery.List(ADOil, filter))
{
using (adObject)
{
if (adObject.Type == ADObjectType.User)
{
UserObject User = (UserObject)adObject;
lst.Add(User);
}
}
}
return lst;
}
public void Visit(Or or)
{
// Nothing to do here...
}
public void XOrX()
{
INode root = new Or(VariableNode.Make<bool>(0, "x"), VariableNode.Make<bool>(0, "x"));
Assert.AreEqual(
VariableNode.Make<bool>(0, "x").ToString(),
SimplifyLogicTree(root).ToString());
}
public static bool StringIntOrEq
( Or<string, int> x
, Or<string, int> y
)
=>
x.Eq(y, (a, b) => a == b, (a, b) => a == b);
public void Or(Rule rule)
{
Or newRoot = new Or(root, rule.root);
root = newRoot;
}
public static int StringIntOrHash(Or<string, int> e)
=>
e.Cata(s => s.GetHashCode() * 37, i => i);
public void Or(INode node)
{
Or newRoot = new Or(root,node);
root = newRoot;
}
public void Evaluate_Or_True_Test()
{
Expression left = CreateBoolLiteral(true);
Expression right = CreateBoolLiteral(false);
Expression or = new Or(left, right, pos);
Values.Bool value = ((Values.Bool)or.Accept(evaluator));
Assert.IsTrue(value.GetValue());
}
