public void ExcludeFactsFromSelection() { FactBase fb = new FactBase(); Assert.IsTrue(fb.Assert(new Fact("spending", new Individual("Peter Miller"), new Individual(5000), new Individual("previous year"))), "Assert 'P.Miller Spending'"); Fact jqdSpending = new Fact("JQD Spending", "spending", new Individual("John Q.Clone Doe"), new Individual(7000), new Individual("previous year")); Assert.IsTrue(fb.Assert(jqdSpending), "Assert 'JQD Spending'"); Atom filter = new Atom("spending", new Variable("name"), new Function(Function.FunctionResolutionType.NxBRE, "foo", null, "GreaterThanEqualTo", "5000"), new Individual("previous year")); Assert.AreEqual(2, CountEnumerator(fb.Select(filter, null)), "Query with NxBRE function and no fact exclusion"); IList <Fact> excludedFacts = new List <Fact>(); excludedFacts.Add(jqdSpending); Assert.AreEqual(1, CountEnumerator(fb.Select(filter, excludedFacts)), "Query with NxBRE function with fact exclusion"); }
public void ProcessOr() { FactBase fb = new FactBase(); PopulateFactBase(fb); Atom atom1 = new Atom("spending", new Variable("name"), new Function(Function.FunctionResolutionType.NxBRE, "foo", null, "GreaterThan", "1000"), new Individual("previous year")); Atom atom2 = new Atom("lending", new Variable("name"), new Function(Function.FunctionResolutionType.NxBRE, "foo", null, "GreaterThan", "5000"), new Individual("previous year")); IList <IList <FactBase.PositiveMatchResult> > result = fb.ProcessAtomGroup(new AtomGroup(AtomGroup.LogicalOperator.Or, atom1, atom2)); Assert.AreEqual(3, result.Count, "2 positive atoms"); atom1 = new Atom("spending", new Variable("name"), new Function(Function.FunctionResolutionType.NxBRE, "foo", null, "GreaterThan", "9999"), new Individual("previous year")); result = fb.ProcessAtomGroup(new AtomGroup(AtomGroup.LogicalOperator.Or, atom1, atom2)); Assert.AreEqual(1, result.Count, "1 positive atom"); }
public void FactBaseCloning() { FactBase fb = new FactBase(); PopulateFactBase(fb); FactBase clone = (FactBase)fb.Clone(); Assert.AreEqual(fb.Count, clone.Count, "Same number of facts"); Fact jqdSpending = clone.GetFact("JQD Spending"); Assert.AreEqual("JQD Spending", jqdSpending.Label, "Correct fact label"); int countBefore = clone.Count; Assert.IsTrue(clone.Retract(jqdSpending), "Retracted 'JQD Spending'"); Assert.AreEqual(countBefore - 1, clone.Count, "Count after retraction"); Assert.IsFalse(clone.Exists(jqdSpending), "'JQD Spending' really retracted"); Assert.IsTrue(fb.Exists(jqdSpending), "'JQD Spending' still in original"); Atom filter = new Atom("spending", new Variable("name"), new Function(Function.FunctionResolutionType.NxBRE, "foo", null, "GreaterThan", "5000"), new Individual("previous year")); Assert.AreEqual(1, CountEnumerator(fb.Select(filter, null)), "Query on the original"); Assert.AreEqual(0, CountEnumerator(clone.Select(filter, null)), "Query on the clone"); }
public void FactBaseAssertRetract() { FactBase fb = new FactBase(); Assert.IsTrue(fb.Assert(new Fact("spending", new Individual("Peter Miller"), new Individual("min(5000,EUR)"), new Individual("previous year"))), "Assert 'P.Miller Spending'"); Assert.IsTrue(fb.Assert(new Fact("JQD Spending", "spending", new Individual("John Q.Clone Doe"), new Individual("min(7000,EUR)"), new Individual("previous year"))), "Assert 'JQD Spending'"); Assert.IsNotNull(fb.GetFact("JQD Spending"), "Exist 'JQD Spending'"); Assert.IsFalse(fb.Assert(fact3bis), "Assert fact3bis"); Assert.IsTrue(fb.Assert(factX), "Assert factX"); Fact jqdSpending = fb.GetFact("JQD Spending"); Assert.IsTrue(fb.Exists(jqdSpending)); Assert.IsTrue(fb.Retract(jqdSpending)); Assert.IsFalse(fb.Exists(jqdSpending)); Assert.IsNull(fb.GetFact("JQD Spending"), "Get Retracted 'JQD Spending'"); }
public static FactBase GetFactBase(string item) { var fb = new FactBase(); fb.SetFromString(item); return(fb); }
/// <summary> /// Assert a fact to the FactBase. /// </summary> private static void CoreAssert(string rel, object e1, object e2, object e3, Tvar val) { // Don't assert a fact that's already been asserted if (!HasBeenAsserted(rel, e1, e2, e3)) { // Assert the fact Fact f = new Fact(rel, e1, e2, e3, val); FactBase.Add(f); // TODO: This breaks when the objects are not Things (hence the try-catch) try { // Add Things to the ThingBase AddThing((Thing)e1); AddThing((Thing)e2); AddThing((Thing)e3); // Look for additional inferences that can be drawn, based on assumptions. Assumptions.TriggerInferences(rel, (Thing)e1, (Thing)e2, (Thing)e3, val); } catch { } } }
public static string GetFactString(Concept concept, List <Dimension> dimensions) { var fb = new FactBase(); fb.Concept = concept; fb.Dimensions = dimensions; return(fb.GetFactString()); }
public string GetFactString(List <Dimension> dimensions) { var typedfact = new FactBase(); typedfact.Dimensions = dimensions.ToList(); var typedfactstring = typedfact.FactString.Trim(); return(typedfactstring); }
public void FactBaseAssertModify() { FactBase fb = new FactBase(); Fact spendingPM1 = new Fact("Spending of Peter Miller", "spending", new Individual("Peter Miller"), new Individual("min(5000,EUR)"), new Individual("previous year")); Assert.IsTrue(fb.Assert(spendingPM1), "Assert 'P.Miller Spending' v1"); Assert.IsFalse(fb.Assert(spendingPM1), "Can not assert 'P.Miller Spending' v1 twice!"); Assert.IsTrue(fb.Exists(spendingPM1), "Exists 'P.Miller Spending' v1"); Fact spendingJQD = new Fact("Spending of John Q. Doe", "spending", new Individual("John Q.Clone Doe"), new Individual("min(7000,EUR)"), new Individual("previous year")); Assert.IsTrue(fb.Assert(spendingJQD), "Assert 'JQD Spending'"); Fact spendingPM2 = new Fact("spending", new Individual("Peter Miller"), new Individual("min(9999,EUR)"), new Individual("previous year")); Assert.IsTrue(fb.Modify(spendingPM1, spendingPM2), "Modify 'P.Miller Spending' v1 to v2"); Assert.IsNotNull(fb.GetFact(spendingPM1.Label), "(1) Label has been maintained"); Assert.AreEqual(2, fb.Count, "(1) FactBase size"); Assert.IsFalse(fb.Exists(spendingPM1), "(1) Not Exists 'P.Miller Spending' v1"); Assert.IsTrue(fb.Exists(spendingPM2), "(1) Exists 'P.Miller Spending' v2"); Assert.IsTrue(fb.Exists(spendingJQD), "(1) Exists 'JQD Spending'"); Assert.IsFalse(fb.Modify(spendingPM1, spendingPM2), "Can not modify an inexistant fact"); Assert.AreEqual(2, fb.Count, "(2) FactBase size"); Assert.IsFalse(fb.Exists(spendingPM1), "(2) Not Exists 'P.Miller Spending' v1"); Assert.IsTrue(fb.Exists(spendingPM2), "(2) Exists 'P.Miller Spending' v2"); Assert.IsTrue(fb.Exists(spendingJQD), "(2) Exists 'JQD Spending'"); Assert.IsTrue(fb.Modify(spendingPM2, spendingPM2), "Can modify a fact to itself"); Assert.AreEqual(2, fb.Count, "(3) FactBase size"); Assert.IsFalse(fb.Exists(spendingPM1), "(3) Not Exists 'P.Miller Spending' v1"); Assert.IsTrue(fb.Exists(spendingPM2), "(3) Exists 'P.Miller Spending' v2"); Assert.IsTrue(fb.Exists(spendingJQD), "(3) Exists 'JQD Spending'"); Assert.IsTrue(fb.Modify(spendingJQD, spendingPM2), "Modify 'JQD Spending' to 'P.Miller Spending' v2"); Assert.IsNotNull(fb.GetFact(spendingJQD.Label), "(4) Label has been maintained"); Assert.AreEqual(1, fb.Count, "(4) FactBase size"); Assert.IsFalse(fb.Exists(spendingPM1), "(4) Not Exists 'P.Miller Spending' v1"); Assert.IsTrue(fb.Exists(spendingPM2), "(4) Exists 'P.Miller Spending' v2"); Assert.IsFalse(fb.Exists(spendingJQD), "(4) Not Exists 'JQD Spending'"); }
public void PredicateNxBREFunction() { FactBase fb = new FactBase(); PopulateFactBase(fb); Atom filter = new Atom("spending", new Variable("name"), new Function(Function.FunctionResolutionType.NxBRE, "foo", null, "GreaterThan", "5000"), new Individual("previous year")); Assert.AreEqual(1, CountEnumerator(fb.Select(filter, null)), "Query with NxBRE function"); }
public string GetDynamicCellID(string cellID, FactBase fact) { var intkeys = this.GetFactIntKey(fact.FactString); if (this.FactDictionary.FactsByInstanceKey.ContainsKey(intkeys)) { var ix = this.FactDictionary.FactsByInstanceKey[intkeys]; var instfact = this.FactDictionary.FactsByIndex[ix]; return(GetDynamicCellID(cellID, instfact)); } else { } return(cellID); }
private Fact BuildFact(Atom targetAtom, ArrayList processResult) { Atom factBuilder = FactBase.Populate(targetAtom, processResult, true); if (!factBuilder.IsFact) { if (IEImpl.StrictImplication) { throw new BREException("Strict implication rejected the assertion of incompletely resolved fact: " + factBuilder); } } else { return(new Fact(factBuilder)); } return(null); }
protected InstanceFact GetFact(string factstring, Instance instance) { var facts = new List <InstanceFact>(); if (instance.FactDictionary.ContainsKey(factstring)) { facts = instance.FactDictionary.GetFacts(factstring); if (facts.Count == 1) { return(facts[0]); } } var shouldprocess = false; foreach (var td in Taxonomy.TypedDimensions) { if (factstring.Contains(td.Key)) { shouldprocess = true; break; } } if (shouldprocess) { var factbase = new FactBase(); factbase.SetFromString(factstring); var factkey = factbase.GetFactKey(); if (instance.FactDictionary.ContainsKey(factkey)) { facts = instance.FactDictionary.GetFacts(factkey); foreach (var fact in facts) { if (fact.FactString == factstring) { return(fact); } } facts.Clear(); } } return(facts.FirstOrDefault()); }
private int RunStrictTypingFactBaseTest(bool strictTyping) { FactBase fb = new FactBase(); fb.strictTyping = strictTyping; Assert.IsTrue(fb.Assert(new Fact("spending", new Individual("foo"), new Individual(7000))), "Assert 'foo Spending'"); Assert.IsTrue(fb.Assert(new Fact("spending", new Individual("bar"), new Individual("7000"))), "Assert 'bar Spending'"); Atom filter = new Atom("spending", new Variable("name"), new Individual("7000")); return(CountEnumerator(fb.Select(filter, null))); }
private void PopulateFactBase(FactBase fb) { Assert.IsTrue(fb.Assert(new Fact("spending", new Individual("foo"), new Individual(7000))), "Assert 'foo Spending'"); Assert.IsTrue(fb.Assert(new Fact("spending", new Individual("Peter Miller"), new Individual(5000), new Individual("previous year"))), "Assert 'P.Miller Spending'"); Assert.IsTrue(fb.Assert(new Fact("JQD Spending", "spending", new Individual("John Q.Clone Doe"), new Individual(7000), new Individual("previous year"))), "Assert 'JQD Spending'"); Assert.IsTrue(fb.Assert(new Fact("lending", new Individual("John Q.Clone Doe"), new Individual(7000), new Individual("previous year"))), "Assert 'JQD Lending'"); }
public void ProcessAnd() { FactBase fb = new FactBase(); PopulateFactBase(fb); Atom atom1 = new Atom("spending", new Variable("name"), new Function(Function.FunctionResolutionType.NxBRE, "foo", null, "GreaterThan", "5000"), new Individual("previous year")); Atom atom2 = new Atom("lending", new Variable("name"), new Function(Function.FunctionResolutionType.NxBRE, "foo", null, "GreaterThan", "5000"), new Individual("previous year")); IList <IList <FactBase.PositiveMatchResult> > result = fb.ProcessAtomGroup(new AtomGroup(AtomGroup.LogicalOperator.And, atom1, atom2)); Assert.AreEqual(1, result.Count, "2 positive atoms"); atom2 = new Atom("lending", new Variable("name"), new Function(Function.FunctionResolutionType.NxBRE, "foo", null, "GreaterThan", "15000"), new Individual("previous year")); result = fb.ProcessAtomGroup(new AtomGroup(AtomGroup.LogicalOperator.And, atom1, atom2)); Assert.AreEqual(0, result.Count, "1 positive and 1 negative atoms"); atom2 = new Atom("spending", new Variable("otherName"), new Variable("whateverAmount"), new Individual("previous year")); result = fb.ProcessAtomGroup(new AtomGroup(AtomGroup.LogicalOperator.And, atom1, atom2)); Assert.AreEqual(2, result.Count, "2 positive combinatorial atoms"); atom2 = new Atom("spending", new Variable("otherName"), new Variable("whateverAmount"), new Individual("unknown year")); result = fb.ProcessAtomGroup(new AtomGroup(AtomGroup.LogicalOperator.And, atom1, atom2)); Assert.AreEqual(0, result.Count, "1 positive and 1 negative combinatorial atoms"); }
public static LayoutItem Copy(LayoutItem li_original) { var li_new = new LayoutItem(); li_new._Axis = li_original._Axis; li_new._Category = li_original._Category; li_new.FactString = li_original.FactString; var fact = new FactBase(); fact.SetFromString(li_new.FactString); li_new.Dimensions = fact.Dimensions; li_new.Concept = fact.Concept; li_new._ID = li_original._ID; li_new._IsAbstract = li_original._IsAbstract; li_new.Label = li_original.Label; li_new._LabelCode = li_original._LabelCode; li_new._LabelContent = li_original._LabelContent; li_new._LabelID = li_original._LabelID; li_new._Role = li_original._Role; return(li_new); }
public FactBase GetFactBaseByIndexString(string factstring) { if (factstring.StartsWith("I:")) { var id = Utilities.Converters.FastParse(factstring.Substring(2)); if (id > -1 && id < this.Facts.Count) { return(this.Facts[id]); } } if (factstring.StartsWith("T:")) { var id = Utilities.Converters.FastParse(factstring.Substring(2)); if (Taxonomy.FactsManager.Count > id) { var fact = new FactBase(); var key = Taxonomy.FactsManager.GetFactKey(id); var stringkey = Taxonomy.GetFactStringKey(key); fact.SetFromString(stringkey); return(fact); } } return(null); }
public void ProcessAnd() { FactBase fb = new FactBase(); PopulateFactBase(fb); Atom atom1 = new Atom("spending", new Variable("name"), new Function(Function.FunctionResolutionType.NxBRE, "foo", null, "GreaterThan", "5000"), new Individual("previous year")); Atom atom2 = new Atom("lending", new Variable("name"), new Function(Function.FunctionResolutionType.NxBRE, "foo", null, "GreaterThan", "5000"), new Individual("previous year")); IList<IList<FactBase.PositiveMatchResult>> result = fb.ProcessAtomGroup(new AtomGroup(AtomGroup.LogicalOperator.And, atom1, atom2)); Assert.AreEqual(1, result.Count, "2 positive atoms"); atom2 = new Atom("lending", new Variable("name"), new Function(Function.FunctionResolutionType.NxBRE, "foo", null, "GreaterThan", "15000"), new Individual("previous year")); result = fb.ProcessAtomGroup(new AtomGroup(AtomGroup.LogicalOperator.And, atom1, atom2)); Assert.AreEqual(0, result.Count, "1 positive and 1 negative atoms"); atom2 = new Atom("spending", new Variable("otherName"), new Variable("whateverAmount"), new Individual("previous year")); result = fb.ProcessAtomGroup(new AtomGroup(AtomGroup.LogicalOperator.And, atom1, atom2)); Assert.AreEqual(2, result.Count, "2 positive combinatorial atoms"); atom2 = new Atom("spending", new Variable("otherName"), new Variable("whateverAmount"), new Individual("unknown year")); result = fb.ProcessAtomGroup(new AtomGroup(AtomGroup.LogicalOperator.And, atom1, atom2)); Assert.AreEqual(0, result.Count, "1 positive and 1 negative combinatorial atoms"); }
public void ExcludeFactsFromSelection() { FactBase fb = new FactBase(); Assert.IsTrue(fb.Assert(new Fact("spending", new Individual("Peter Miller"), new Individual(5000), new Individual("previous year"))), "Assert 'P.Miller Spending'"); Fact jqdSpending = new Fact("JQD Spending", "spending", new Individual("John Q.Clone Doe"), new Individual(7000), new Individual("previous year")); Assert.IsTrue(fb.Assert(jqdSpending), "Assert 'JQD Spending'"); Atom filter = new Atom("spending", new Variable("name"), new Function(Function.FunctionResolutionType.NxBRE, "foo", null, "GreaterThanEqualTo", "5000"), new Individual("previous year")); Assert.AreEqual(2, CountEnumerator(fb.Select(filter, null)), "Query with NxBRE function and no fact exclusion"); IList<Fact> excludedFacts = new List<Fact>(); excludedFacts.Add(jqdSpending); Assert.AreEqual(1, CountEnumerator(fb.Select(filter, excludedFacts)), "Query with NxBRE function with fact exclusion"); }
public void FactBaseCloning() { FactBase fb = new FactBase(); PopulateFactBase(fb); FactBase clone = (FactBase)fb.Clone(); Assert.AreEqual(fb.Count, clone.Count, "Same number of facts"); Fact jqdSpending = clone.GetFact("JQD Spending"); Assert.AreEqual("JQD Spending", jqdSpending.Label, "Correct fact label"); int countBefore = clone.Count; Assert.IsTrue(clone.Retract(jqdSpending), "Retracted 'JQD Spending'"); Assert.AreEqual(countBefore-1, clone.Count, "Count after retraction"); Assert.IsFalse(clone.Exists(jqdSpending), "'JQD Spending' really retracted"); Assert.IsTrue(fb.Exists(jqdSpending), "'JQD Spending' still in original"); Atom filter = new Atom("spending", new Variable("name"), new Function(Function.FunctionResolutionType.NxBRE, "foo", null, "GreaterThan", "5000"), new Individual("previous year")); Assert.AreEqual(1, CountEnumerator(fb.Select(filter, null)), "Query on the original"); Assert.AreEqual(0, CountEnumerator(clone.Select(filter, null)), "Query on the clone"); }
private int RunStrictTypingFactBaseTest(bool strictTyping) { FactBase fb = new FactBase(); fb.strictTyping = strictTyping; Assert.IsTrue(fb.Assert(new Fact("spending", new Individual("foo"), new Individual(7000))), "Assert 'foo Spending'"); Assert.IsTrue(fb.Assert(new Fact("spending", new Individual("bar"), new Individual("7000"))), "Assert 'bar Spending'"); Atom filter = new Atom("spending", new Variable("name"), new Individual("7000")); return CountEnumerator(fb.Select(filter, null)); }
private int RunImplication(Implication implication) { int implicationResultsCount = 0; FactBase.ProcessResultSet processResults = WM.FB.ProcessAtomGroup(implication.AtomGroup); if (implication.Action == ImplicationAction.Count) { if (HasLogListener) { ForceDispatchLog("Counting Implication '" + implication.Label + "' counted: " + processResults.Count, LogEventImpl.DEBUG); } bool variableFound = false; IPredicate[] members = (IPredicate[])implication.Deduction.Members.Clone(); for (int i = 0; !variableFound && i < members.Length; i++) { if (members[i] is Variable) { members[i] = new Individual(processResults.Count); variableFound = true; break; } } if ((IEImpl.StrictImplication) && (!variableFound)) { throw new BREException("Strict counting implication rejected the assertion due to lack of variable predicate: " + implication.Deduction); } Fact deductedFact = new Fact(implication.Deduction.Type, members); implicationResultsCount++; // counting implication factbase action bool result = WM.FB.Assert(deductedFact); if ((result) && (NewFactHandler != null)) { NewFactHandler(new NewFactEventArgs(deductedFact)); } if (HasLogListener) { ForceDispatchLog((result?"Asserted":"Ignored Assertion of ") + " Fact: " + deductedFact.ToString(), LogEventImpl.DEBUG); } } else if ((implication.Action == ImplicationAction.Assert) || (implication.Action == ImplicationAction.Retract)) { // loop on each result and try to build a new fact out of the predicates coming for each result foreach (ArrayList processResult in processResults) { Fact deductedFact = BuildFact(implication.Deduction, processResult); if (deductedFact != null) { implicationResultsCount++; if (implication.Action == ImplicationAction.Retract) { // retracting implication factbase action bool result = WM.FB.Retract(deductedFact); if ((result) && (DeleteFactHandler != null)) { DeleteFactHandler(new NewFactEventArgs(deductedFact)); } if (HasLogListener) { ForceDispatchLog((result?"Retracted":"Ignored Retraction of ") + " Fact: " + deductedFact.ToString(), LogEventImpl.DEBUG); } } else { // asserting implication factbase action bool result = WM.FB.Assert(deductedFact); if ((result) && (NewFactHandler != null)) { NewFactHandler(new NewFactEventArgs(deductedFact)); } if (HasLogListener) { ForceDispatchLog((result?"Asserted":"Ignored Assertion of ") + " Fact: " + deductedFact.ToString(), LogEventImpl.DEBUG); } } } } } else if (implication.Action == ImplicationAction.Modify) { foreach (ArrayList processResult in processResults) { // look for facts to modify by: // - resolving variable predicates of the deduction // - replacing formulas with variables // and performing a search in the fact base Atom modificationTargetLookup = FactBase.BuildQueryFromDeduction(implication.Deduction, processResult); if (HasLogListener) { ForceDispatchLog("Modifying Implication '" + implication.Label + "' will target matches of: " + modificationTargetLookup, LogEventImpl.DEBUG); } foreach (Fact factToModify in FactBase.ExtractFacts(WM.FB.ProcessAtomGroup(new AtomGroup(AtomGroup.LogicalOperator.And, modificationTargetLookup)))) { if (HasLogListener) { ForceDispatchLog("-> found target: " + factToModify, LogEventImpl.DEBUG); } // for each fact, perform the modification Fact deductedFact = BuildFact(implication.Deduction, FactBase.EnrichResults(processResult, modificationTargetLookup, factToModify)); if (HasLogListener) { ForceDispatchLog("-> modified target: " + deductedFact, LogEventImpl.DEBUG); } if ((deductedFact != null) && (!factToModify.Equals(deductedFact))) { implicationResultsCount++; bool result = WM.FB.Modify(factToModify, deductedFact); if ((result) && (ModifyFactHandler != null)) { ModifyFactHandler(new NewFactEventArgs(factToModify, deductedFact)); } if (HasLogListener) { ForceDispatchLog((result?"Modified":"Ignored Modification of ") + " Fact: " + factToModify.ToString(), LogEventImpl.DEBUG); } } } } } else { throw new BREException("Implication action not supported: " + implication.Action); } return(implicationResultsCount); }
public override void PrepareInitialization() { lockStrategy.AcquireUniqueLock(lockTimeOut); WorkingType = WorkingMemoryTypes.Global; globalFactBase = new FactBase(); }
public override void PrepareInitialization() { WorkingType = WorkingMemoryTypes.Global; globalFactBase = new FactBase(); WorkingFactBase = globalFactBase; }
public void ProcessOr() { FactBase fb = new FactBase(); PopulateFactBase(fb); Atom atom1 = new Atom("spending", new Variable("name"), new Function(Function.FunctionResolutionType.NxBRE, "foo", null, "GreaterThan", "1000"), new Individual("previous year")); Atom atom2 = new Atom("lending", new Variable("name"), new Function(Function.FunctionResolutionType.NxBRE, "foo", null, "GreaterThan", "5000"), new Individual("previous year")); IList<IList<FactBase.PositiveMatchResult>> result = fb.ProcessAtomGroup(new AtomGroup(AtomGroup.LogicalOperator.Or, atom1, atom2)); Assert.AreEqual(3, result.Count, "2 positive atoms"); atom1 = new Atom("spending", new Variable("name"), new Function(Function.FunctionResolutionType.NxBRE, "foo", null, "GreaterThan", "9999"), new Individual("previous year")); result = fb.ProcessAtomGroup(new AtomGroup(AtomGroup.LogicalOperator.Or, atom1, atom2)); Assert.AreEqual(1, result.Count, "1 positive atom"); }
public Hierarchy <LayoutItem> GetInstanceExtensions(Table table) { if (table.ID.Contains("07")) { } if (ExtDictionary.Count == 0) { return(table.Extensions); } else { if (this.Extensions == null) { var hlroot = new Hierarchy <LayoutItem>(table.Extensions.Item); var ix = 1; foreach (var typedext in ExtDictionary) { var factstring = typedext.Key; var typedfact = new FactBase(); typedfact.SetFromString(factstring); typedfact.SetTyped(); foreach (var ext in table.Extensions.Children) { var li_original = ext.Item; var li_new = LayoutItem.Copy(li_original); foreach (var dim in li_new.Dimensions) { var instancedim = typedfact.Dimensions.FirstOrDefault(i => i.DimensionItem == dim.DimensionItem && i.Domain == dim.Domain); if (instancedim != null) { dim.DomainMember = instancedim.DomainMember; } } var fact = new FactBase(); fact.Dimensions = li_new.Dimensions; fact.Concept = li_new.Concept; fact.SetFactString(); li_new.FactString = fact.FactString; Label extensionlabel = new Label(); var code = String.Format(Table.LabelCodeFormat, typedext.Value); var content = String.Format(Table.ExtensionLableContentFormat, code); extensionlabel.LabelID = code; extensionlabel.Code = code; extensionlabel.Content = content; if (fact.Dimensions.Count == 1) { extensionlabel = table.Taxonomy.GetLabelForDimensionDomainMember(fact.Dimensions.FirstOrDefault()); extensionlabel.Code = code; } if (fact.Dimensions.Count > 1) { extensionlabel.Content = ""; extensionlabel.Code = ""; foreach (var dim in fact.Dimensions) { extensionlabel.Code += dim.DomainMemberFullName + ","; extensionlabel.Content += table.Taxonomy.GetLabelForDimensionDomainMember(dim) + ","; } } li_new.ID = extensionlabel.LabelID; li_new.LabelCode = extensionlabel.Code; li_new.LabelContent = extensionlabel.Content; var hli = new Hierarchy <LayoutItem>(li_new); hlroot.Children.Add(hli); hli.Parent = hlroot; ix++; } } Extensions = hlroot; } return(Extensions); } }
public Cell AddCells_Old_2(Cell cell, InstanceFact fact, Table table) { var dynamiccell = new Cell(); dynamiccell.Report = cell.Report; dynamiccell.Extension = cell.Extension; dynamiccell.Row = cell.Row; dynamiccell.Column = cell.Column; if (fact.Dimensions.Count == 0) { var factstring = Instance.GetFactStringKey(fact.InstanceKey); var tmpfact = new FactBase(); tmpfact.SetFromString(factstring); fact.Dimensions.AddRange(tmpfact.Dimensions); } if (cell.Extension == Literals.DynamicCode) { var ext = table.Extensions.Children.FirstOrDefault(); var opendimensions = ext.Item.Dimensions.Where(i => String.IsNullOrEmpty(i.DomainMember)).ToList(); //var typeddimensions = ext.Item.Dimensions.Where(i => i.IsTyped).ToList(); //var axistypeddimensions = Dimension.GetDimensions(fact.Dimensions, typeddimensions); var instanceopendimensions = Dimension.GetDimensions(fact.Dimensions, opendimensions); var openfactstring = GetFactString(instanceopendimensions); if (!ExtDictionary.ContainsKey(openfactstring)) { var extnr = String.Format("{0}", ExtDictionary.Count + 1); ExtDictionary.Add(openfactstring, extnr); } dynamiccell.Extension = ExtDictionary[openfactstring]; } if (cell.Row == Literals.DynamicCode) { // var cell = table.Rows var row = table.Rows.FirstOrDefault(i => i.Item.LabelCode == cell.Row); var typeddimensions = row.Item.Dimensions.Where(i => i.IsTyped).ToList(); var axistypeddimensions = Dimension.GetDimensions(fact.Dimensions, typeddimensions); var typedfactstring = GetTypedFactString(axistypeddimensions); if (!RowDictionary.ContainsKey(typedfactstring)) { var rownr = String.Format("{0}", RowDictionary.Count + 1); RowDictionary.Add(typedfactstring, rownr); } dynamiccell.Row = RowDictionary[typedfactstring]; } if (cell.Column == Literals.DynamicCode) { // var cell = table.Rows var col = table.Columns.FirstOrDefault(i => i.Item.LabelCode == cell.Row); var typeddimensions = col.Item.Dimensions.Where(i => i.IsTyped).ToList(); var axistypeddimensions = Dimension.GetDimensions(fact.Dimensions, typeddimensions); var typedfactstring = GetTypedFactString(axistypeddimensions); if (!ColDictionary.ContainsKey(typedfactstring)) { var rownr = String.Format("{0}", RowDictionary.Count + 1); ColDictionary.Add(typedfactstring, rownr); } dynamiccell.Column = ColDictionary[typedfactstring]; } //if (dynamiccell.CellID != cell.CellID) //{ // //var cellfactstring = fact.FactString; // //if (CellOfFact.ContainsKey(fact.FactString)) // //if (1 == 2) // //{ // // //var existing = CellOfFact[fact.FactString]; // // var existingfacts = TaxonomyEngine.CurrentEngine.CurrentInstance.FactDictionary.FactsByTaxonomyKey[fact.InstanceKey]; // // //var existingfact = existingfacts.FirstOrDefault(i => i.FactString == fact.FactString); // // var ctid = typeof(InstanceFact).IsAssignableFrom(fact.GetType()) ? ((InstanceFact)fact).ContextID : ""; // // var msg = String.Format("Fact {0} already exist >> {1}!", fact, ctid); // // Utilities.Logger.WriteLine(msg); // //} // //else // //{ // // //var item = this.Instance.FactDictionary[fact.FactIntkeys]; // // //CellOfFact.Add(fact.FactString, dynamiccell.CellID); // //} //} //else //{ //} fact.Cells.Add(dynamiccell.CellID); return(dynamiccell); }
public string CheckCells(LogicalModel.Validation.ValidationParameter parameter) { var cellfound = false; var sb = new StringBuilder(); var sequence = parameter.BindAsSequence ? "Sequence" : ""; sb.AppendLine("parameter: " + parameter.Name + " " + sequence); var c_sb = new StringBuilder(); var log = false; foreach (var factgroup in parameter.TaxFacts) { foreach (var factid in factgroup.AsEnumerable()) { var cellslist = new List <List <String> >(); var factkey = Taxonomy.FactsManager.GetFactKey(factid); var fact = FactBase.GetFactFrom(Taxonomy.GetFactStringKey(factkey)); if (Taxonomy.HasFact(factkey)) { var cells = Taxonomy.GetCellsOfFact(factkey); if (parameter.RuleID.Contains("0602")) { cellslist.Add(cells.Select(i => i + " {" + factkey + "} ").ToList()); } else { cellslist.Add(cells); } if (cells.Count == 0) { if (log) { c_sb.AppendLine(parameter.RuleID + " fact found but no cells! " + factkey); } } } else { var s_facts = Taxonomy.FactKeysAsEnumerable().Select(i => i).AsEnumerable(); if (fact.Concept != null) { //s_facts = s_facts.Where(i => i.StartsWith(fact.Concept.Content)); //if (Taxonomy.FactsOfDimensions.ContainsKey(fact.Concept.Content)) var ix = Taxonomy.FactParts[fact.Concept.Content]; if (Taxonomy.FactsOfParts.ContainsKey(ix)) { s_facts = Taxonomy.FactsOfParts[ix].Select( i => Taxonomy.FactsManager.GetFactKey(i)); } else { s_facts = new List <int[]>(); } } foreach (var dimension in fact.Dimensions) { s_facts = s_facts.Where(i => Taxonomy.GetFactStringKey(i).Contains(dimension.DomainMemberFullName)); } // var s_factlist = s_facts.ToList(); var hasanyfact = false; foreach (var s_fact in s_facts) { hasanyfact = true; var cells = Taxonomy.GetCellsOfFact(s_fact); if (cells.Count == 0) { if (log) { c_sb.AppendLine(parameter.RuleID + " for parameter " + parameter.Name + " no cells were found! " + s_fact); } } if (parameter.RuleID.Contains("0602")) { cellslist.Add(cells.Select(i => i + " {" + factkey + "} ").ToList()); } else { cellslist.Add(cells); } } if (!hasanyfact) { if (log) { c_sb.AppendLine(parameter.RuleID + " fact for parameter " + parameter.Name + " not found! " + factkey); } } } if (cellslist.Count == 0) { } else { cellfound = true; } //sb.AppendLine(fact.GetFactKey()); foreach (var cells in cellslist) { foreach (var cell in cells) { sb.Append(cell + ", "); } sb.AppendLine(); } } } if (!cellfound) { if (log) { c_sb.AppendLine("None of the Fact Groups can be found for " + parameter.RuleID + " - " + parameter.Name); } } if (c_sb.Length > 0) { Logger.WriteLine(c_sb.ToString()); } return(sb.ToString()); }