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());
}