private static Matrix AllAre(IEnumerable <Variable> aVariables, UnaryPredicate aPredicate) { Matrix lMatrix = Predication(aPredicate, aVariables.First()); foreach (Variable lVariable in aVariables.Skip(1)) { lMatrix = And(lMatrix, Predication(aPredicate, lVariable)); } return(lMatrix); }
public UnaryPredicate AddUnaryPredicate(char aSymbol) { if (mUnaryPredicates.ContainsKey(aSymbol)) { return(mUnaryPredicates[aSymbol]); } else { UnaryPredicate aPredicate = Factory.UnaryPredicate(aSymbol); mUnaryPredicates.Add(aSymbol, aPredicate); return(aPredicate); } }
public Matrix AddUnaryPredication(UnaryPredicate aPredicate, Variable aVariable) { Matrix lPredication = Factory.Predication(aPredicate, aVariable); if (mPredications.ContainsKey(lPredication)) { return(mPredications[lPredication]); } else { mPredications.Add(lPredication, lPredication); return(lPredication); } }
public void Test_Bits_Needed_Modal() { NullPredicate[] lNullPredicates = new NullPredicate[34]; UnaryPredicate[] lUnaryPredicates = new UnaryPredicate[7]; bool[ , , ] lMap = new bool[lNullPredicates.Length + 2, lUnaryPredicates.Length + 2, 19]; for (int n = lNullPredicates.Length; n >= 0; n--) { for (int u = lUnaryPredicates.Length; u >= 0; u--) { for (int i = 17; i >= 1 || (i == 0 && u == 0); i--) { try { new Predicates(lNullPredicates.Take(n), lUnaryPredicates.Take(u), i, true, 0); lMap[n, u, i] = true; } catch (EngineException) { } } } } for (int n = lNullPredicates.Length; n >= 0; n--) { for (int u = lUnaryPredicates.Length; u >= 0; u--) { for (int i = 17; i >= 1 || (i == 0 && u == 0); i--) { if (lMap[n, u, i] && !lMap[n + 1, u, i] && !lMap[n, u + 1, i] && !lMap[n, u, i + 1]) { //Console.WriteLine( "n = {0}, u = {1}, i = {2}, t = {3}", n, u, i, t ); Console.WriteLine(" <tr><td>{0}</td><td>{1}</td><td>{2}</td></tr>", n, u, i); } } } } new Predicates(lNullPredicates.Take(32), lUnaryPredicates.Take(0), 0, false, 0); }
public static Matrix ThereAreThisManyOfThese(uint aNumber, UnaryPredicate aPredicate) { Variable[] lVariables = MakeNVariables(Math.Max(aNumber, 1)); switch (aNumber) { case 0: return(ForAll(lVariables[0], Not(Predication(aPredicate, lVariables[0])))); case 1: return(The(lVariables[0], Predication(aPredicate, lVariables[0]))); default: Variable lVariable = Variable('x'); return(Bind( lVariables, And( AllAre(lVariables, aPredicate), AreDistinct(lVariables), ForAll(lVariable, OnlyIf(Predication(aPredicate, lVariable), Disjoin(lVariables.Select(fVariable => TheSame(lVariable, fVariable)))))), ThereExists)); } }
public bool Denies(UnaryPredicate aPredicate) { return(mPredicates.ContainsKey(aPredicate) ? !mPredicates[aPredicate] : false); }
public bool Affirms(UnaryPredicate aPredicate) { return(mPredicates.ContainsKey(aPredicate) ? mPredicates[aPredicate] : false); }
/// <summary> /// Create a predication on a single variable. /// </summary> /// <param name="aPredicate">a predicate</param> /// <param name="aVariable">a variable</param> /// <returns>a new predication</returns> public static Matrix Predication(UnaryPredicate aPredicate, Variable aVariable) { return(new UnaryPredication(aPredicate, aVariable)); }
/// <summary> /// Create a term. /// </summary> /// <param name="aPredicate">a unary predicate</param> /// <param name="aIsNegative">true if the term contains all and only objects which verify the predicate, /// false if the term contains all and only objects which falsify the predicate</param> /// <returns>a term</returns> public static Term AllAndOnly(UnaryPredicate aPredicate, bool aIsNegative) { return(new Term(aPredicate, aIsNegative)); }
internal UnaryPredication(UnaryPredicate aPredicate, Variable aVariable) { mPredicate = aPredicate; mVariable = aVariable; }