public void RemoveElementInverse() { var lookup = new BidirectionalLookup <string, string>(); lookup.Add("baz", "bar"); lookup.Add("foo", "bar"); lookup.Add("foo", "baz"); lookup.Remove("foo", "bar"); CollectionAssert.DoesNotContain(lookup["foo"], "bar"); CollectionAssert.DoesNotContain(lookup.Inverse["bar"], "foo"); CollectionAssert.Contains(lookup["foo"], "baz"); CollectionAssert.Contains(lookup.Inverse["bar"], "baz"); }
public void AddCustomValueComparer() { var comparer = new DelegatedEqualityComparer <string, int> (s => s.Length); var lookup = new BidirectionalLookup <string, string> (comparer, comparer); lookup.Add("foo", "bar1"); lookup.Add("bar", "baz1"); Assert.IsTrue(lookup.Contains("baz")); Assert.IsTrue(lookup.Inverse.Contains("foo1")); CollectionAssert.Contains(lookup["foo"], "bar1"); CollectionAssert.Contains(lookup["foo"], "baz1"); CollectionAssert.Contains(lookup["bar"], "bar1"); CollectionAssert.Contains(lookup["bar"], "bar1"); }
private OperatorGraphVisualizationInfo(OperatorGraphVisualizationInfo original, Cloner cloner) : base(original, cloner) { operatorShapeInfoMapping = new BidirectionalLookup<IOperator, IOperatorShapeInfo>(); operatorParameterCollectionMapping = new BidirectionalLookup<IOperator, IKeyedItemCollection<string, IParameter>>(); parameterOperatorMapping = new Dictionary<IParameter, IOperator>(); operatorGraph = cloner.Clone(original.operatorGraph); RegisterOperatorGraphEvents(); oldInitialShape = cloner.Clone(original.oldInitialShape); oldInitialShapeColor = original.oldInitialShapeColor; foreach (KeyValuePair<IOperator, IOperatorShapeInfo> pair in original.operatorShapeInfoMapping.FirstEnumerable) { IOperator op = cloner.Clone(pair.Key); IOperatorShapeInfo shapeInfo = cloner.Clone(pair.Value); RegisterOperatorEvents(op); operatorParameterCollectionMapping.Add(op, op.Parameters); operatorShapeInfoMapping.Add(op, shapeInfo); } foreach (IOperator oper in operatorShapeInfoMapping.FirstValues) { foreach (IParameter param in oper.Parameters) { parameterOperatorMapping.Add(param, oper); IValueParameter opParam = param as IValueParameter; if (opParam != null && typeof(IOperator).IsAssignableFrom(param.DataType)) RegisterOperatorParameterEvents(opParam); else RegisterParameterEvents(param); } } }
static InfixExpressionParser() { // populate bidirectional lookup var dict = new Dictionary <string, ISymbol> { { "+", new Addition() }, { "/", new Division() }, { "*", new Multiplication() }, { "-", new Subtraction() }, { "^", new Power() }, { "ABS", new Absolute() }, { "EXP", new Exponential() }, { "LOG", new Logarithm() }, { "POW", new Power() }, { "ROOT", new Root() }, { "SQR", new Square() }, { "SQRT", new SquareRoot() }, { "CUBE", new Cube() }, { "CUBEROOT", new CubeRoot() }, { "SIN", new Sine() }, { "COS", new Cosine() }, { "TAN", new Tangent() }, { "TANH", new HyperbolicTangent() }, { "AIRYA", new AiryA() }, { "AIRYB", new AiryB() }, { "BESSEL", new Bessel() }, { "COSINT", new CosineIntegral() }, { "SININT", new SineIntegral() }, { "HYPCOSINT", new HyperbolicCosineIntegral() }, { "HYPSININT", new HyperbolicSineIntegral() }, { "FRESNELSININT", new FresnelSineIntegral() }, { "FRESNELCOSINT", new FresnelCosineIntegral() }, { "NORM", new Norm() }, { "ERF", new Erf() }, { "GAMMA", new Gamma() }, { "PSI", new Psi() }, { "DAWSON", new Dawson() }, { "EXPINT", new ExponentialIntegralEi() }, { "AQ", new AnalyticQuotient() }, { "MEAN", new Average() }, { "IF", new IfThenElse() }, { "GT", new GreaterThan() }, { "LT", new LessThan() }, { "AND", new And() }, { "OR", new Or() }, { "NOT", new Not() }, { "XOR", new Xor() }, { "DIFF", new Derivative() }, { "LAG", new LaggedVariable() }, }; foreach (var kvp in dict) { knownSymbols.Add(kvp.Key, kvp.Value); } }
public void RemoveKeyInverse() { var lookup = new BidirectionalLookup <string, string>(); lookup.Add("baz", "bar"); lookup.Add("foo", "bar"); lookup.Add("foo", "baz"); lookup.Inverse.Remove("bar"); Assert.IsFalse(lookup.Contains("baz")); Assert.IsFalse(lookup.Inverse.Contains("bar")); CollectionAssert.Contains(lookup["foo"], "baz"); CollectionAssert.DoesNotContain(lookup["foo"], "bar"); CollectionAssert.IsEmpty(lookup["baz"]); CollectionAssert.IsEmpty(lookup.Inverse["bar"]); CollectionAssert.Contains(lookup.Inverse["baz"], "foo"); }
public void ClearInverse() { var lookup = new BidirectionalLookup <string, string>(); lookup.Add("foo", "bar"); lookup.Clear(); Assert.AreEqual(0, lookup.Count); Assert.AreEqual(0, lookup.Inverse.Count); Assert.IsFalse(lookup.Contains("foo")); CollectionAssert.IsEmpty(lookup["foo"]); CollectionAssert.IsEmpty(lookup.Inverse["bar"]); }
public void AddInverse() { var lookup = new BidirectionalLookup <string, string>(); lookup.Add("foo", "bar"); lookup.Add("foo", "baz"); lookup.Add("baz", "bar"); Assert.AreEqual(2, lookup.Count); Assert.AreEqual(2, lookup.Count); Assert.IsTrue(lookup.Contains("foo")); Assert.IsTrue(lookup.Contains("baz")); Assert.IsFalse(lookup.Contains("bar")); Assert.IsFalse(lookup.Inverse.Contains("foo")); Assert.IsTrue(lookup.Inverse.Contains("bar")); Assert.IsTrue(lookup.Inverse.Contains("baz")); CollectionAssert.Contains(lookup["foo"], "bar"); CollectionAssert.Contains(lookup["foo"], "baz"); CollectionAssert.Contains(lookup.Inverse["bar"], "foo"); CollectionAssert.Contains(lookup.Inverse["bar"], "baz"); CollectionAssert.Contains(lookup["baz"], "bar"); }
public void TestBidirectionalLookup() { var lookup1 = new BidirectionalLookup <int, double>(); lookup1.Add(4, 2); Assert.IsTrue(lookup1.ContainsFirst(4) && lookup1.ContainsSecond(2)); lookup1.Add(4, 3); Assert.IsTrue(lookup1.GetByFirst(4).Count() == 2); Assert.IsTrue(lookup1.GetBySecond(2).Contains(4)); Assert.IsTrue(lookup1.CountFirst == 1); Assert.IsTrue(lookup1.CountSecond == 2); lookup1.Add(3, 2); lookup1.Add(2, 2); lookup1.Add(1, 2); Assert.IsTrue(lookup1.GetByFirst(1).Single() == 2); Assert.IsTrue(lookup1.GetBySecond(2).Count() == 4); lookup1.RemovePair(2, 2); Assert.IsTrue(!lookup1.ContainsFirst(2)); Assert.IsTrue(lookup1.GetBySecond(2).Count() == 3); lookup1.RemoveByFirst(4); Assert.IsTrue(lookup1.CountFirst == 2); Assert.IsTrue(lookup1.CountSecond == 1); lookup1.RemoveBySecond(2); Assert.IsTrue(lookup1.CountFirst == 0); Assert.IsTrue(lookup1.CountSecond == 0); lookup1.Clear(); Assert.IsTrue(lookup1.CountFirst == 0); Assert.IsTrue(lookup1.CountSecond == 0); var dict2 = new BidirectionalLookup <ComplexType, int>(new ComplexTypeEqualityComparer()); Assert.IsTrue(!dict2.FirstEnumerable.Any()); dict2.Add(new ComplexType(1), 2); Assert.IsTrue(dict2.SecondEnumerable.Any()); dict2.Add(new ComplexType(2), 1); Assert.IsTrue(dict2.ContainsFirst(new ComplexType(2))); Assert.IsTrue(dict2.ContainsSecond(2)); dict2.Add(new ComplexType(2), 3); Assert.IsTrue(dict2.GetByFirst(new ComplexType(2)).Count() == 2); Assert.IsTrue(dict2.GetByFirst(new ComplexType(2)).Contains(1)); Assert.IsTrue(dict2.GetByFirst(new ComplexType(2)).Contains(3)); dict2.Add(new ComplexType(3), 1); Assert.IsTrue(dict2.GetBySecond(1).Count() == 2); Assert.IsTrue(dict2.GetBySecond(1).Any(x => x.Field == 2)); Assert.IsTrue(dict2.GetBySecond(1).Any(x => x.Field == 3)); Assert.IsTrue(dict2.CountFirst == 3); Assert.IsTrue(dict2.CountSecond == 3); dict2.Add(new ComplexType(2), 2); Assert.IsTrue(dict2.CountFirst == 3); Assert.IsTrue(dict2.CountSecond == 3); dict2.Add(new ComplexType(2), 4); Assert.IsTrue(dict2.CountFirst == 3); Assert.IsTrue(dict2.CountSecond == 4); dict2.RemoveByFirst(new ComplexType(2)); Assert.IsTrue(dict2.CountFirst == 2); Assert.IsTrue(dict2.CountSecond == 2); dict2.RemovePair(new ComplexType(1), 1); Assert.IsTrue(dict2.CountFirst == 2); Assert.IsTrue(dict2.CountSecond == 2); dict2.RemovePair(new ComplexType(1), 2); Assert.IsTrue(dict2.CountFirst == 1); Assert.IsTrue(dict2.CountSecond == 1); dict2.Clear(); Assert.IsTrue(!dict2.SecondEnumerable.Any()); }