protected override void _setName(string name)
{
base._setName(name);
if (String.IsNullOrEmpty(name))
{
return;
}
var cs = this.Color;
if (cs == null)
{
this._func = null;
this.Tokens = null;
return;
}
if (this.ParsedFunction != null)
{
this.Tokens = new MultiSet<Function>(this.ParsedFunction);
foreach (var token in this.Tokens)
{
Token t = new Token(token.Key, cs);
if (!t.IsLegal())
{
this._func = null;
this.Tokens = null;
break;
}
}
}
}
public void TestEmptyEquals()
{
MultiSet<string> a = new MultiSet<string>();
MultiSet<string> b = new MultiSet<string>();
Assert.AreEqual<IEquatable<MultiSet<string>>>(a, b);
}
public void TestEmptyExcept()
{
MultiSet<string> a = new MultiSet<string>();
MultiSet<string> b = new MultiSet<string>();
MultiSet<string> diff = a.Except(b);
Assert.AreEqual<int>(0, diff.Count);
}
public void Add_T_int_Method()
{
multiSet = new MultiSet <char>();
multiSet.Add('a', 5);
multiSet.Add('b', 1);
Assert.AreEqual(5, multiSet['a']);
Assert.AreEqual(1, multiSet['b']);
Assert.IsTrue(multiSet.Count == 2);
}
public void StringBuilder_Operator_Minus()
{
stringBuilderSet = new MultiSet <StringBuilder>(stringBuilderCollection);
MultiSet <StringBuilder> test = new MultiSet <StringBuilder>(stringBuilderCollection);
test.Remove(c);
MultiSet <StringBuilder> multiSets = stringBuilderSet - test;
Assert.AreEqual("ccc: 1", multiSets.ToString());
}
public void StringBuilder_Add_T_int_Method()
{
stringBuilderSet = new MultiSet <StringBuilder>();
stringBuilderSet.Add(a, 5);
stringBuilderSet.Add(b, 1);
Assert.AreEqual(5, stringBuilderSet[a]);
Assert.AreEqual(1, stringBuilderSet[b]);
Assert.IsTrue(stringBuilderSet.Count == 2);
}
public void ParameterlessConstructorTest()
{
MultiSet <char> mschar = new MultiSet <char>();
Assert.AreEqual(true, mschar.IsEmpty);
Assert.AreEqual(0, mschar.Count);
MultiSet <StringBuilder> ms = new MultiSet <StringBuilder>();
Assert.AreEqual(true, ms.IsEmpty);
Assert.AreEqual(0, ms.Count);
}
public void StringBuilder_MultiSetEquals_Method()
{
stringBuilderSet = new MultiSet <StringBuilder>();
stringBuilderSet.Add(a, 3);
stringBuilderSet.Add(b, 2);
stringBuilderSet.Add(c);
bool isEqual = stringBuilderSet.MultiSetEquals(stringBuilderCollection);
Assert.IsTrue(isEqual);
}
public void OperatorPlusMs()
{
char[] chars = new char[] { 'a', 'd' };
var ms = new MultiSet <char>(chars);
char[] chars2 = new char[] { 'd', 'c' };
var ms2 = new MultiSet <char>(chars2);
var ms3 = ms + ms2;
Assert.AreEqual("a, d, d, c", ms3.ToString());
}
public void MultiSetEquals_Method()
{
multiSet = new MultiSet <char>();
multiSet.Add('a', 2);
multiSet.Add('b', 2);
multiSet.Add('c');
bool isEqual = multiSet.MultiSetEquals(collection);
Assert.IsTrue(isEqual);
}
public void OperatorMultiplyMs()
{
char[] chars = new char[] { 'a', 'd' };
var ms = new MultiSet <char>(chars);
char[] chars2 = new char[] { 'd', 'c' };
var ms2 = new MultiSet <char>(chars2);
var ms3 = ms * ms2;
Assert.AreEqual("d", ms3.ToString());
}
public void Symmetric_Except_With_Method()
{
multiSet = new MultiSet <char>();
multiSet.Add('a', 3);
multiSet.Add('b', 2);
multiSet.Add('e', 2);
MultiSet <char> multiSets = multiSet.SymmetricExceptWith(collection);
Assert.AreEqual("e: 2, c: 1", multiSets.ToString());
}
public void Operator_Minus()
{
multiSet = new MultiSet <char>(collection);
MultiSet <char> test = new MultiSet <char>(collection);
test.Remove('c');
MultiSet <char> multiSets = multiSet - test;
Assert.AreEqual("c: 1", multiSets.ToString());
}
public void GetItemCount()
{
IMultiSet <string> multiSet = new MultiSet <string>();
multiSet.Add(null, 3);
multiSet.Add("ab");
Assert.AreEqual(3, multiSet.GetItemCount(null));
Assert.AreEqual(1, multiSet.GetItemCount("ab"));
Assert.AreEqual(0, multiSet.GetItemCount("abc"));
}
public void StringBuilder_Overlaps_Method()
{
stringBuilderSet = new MultiSet <StringBuilder>();
stringBuilderSet.Add(a);
stringBuilderSet.Add(c, 5);
stringBuilderSet.Add(b, 10);
bool isOverlaps = stringBuilderSet.Overlaps(stringBuilderCollection);
Assert.IsTrue(isOverlaps);
}
public void Overlaps_Method()
{
multiSet = new MultiSet <char>();
multiSet.Add('a');
multiSet.Add('x', 5);
multiSet.Add('z', 10);
bool isOverlaps = multiSet.Overlaps(collection);
Assert.IsTrue(isOverlaps);
}
public void StringBuilder_Constructor_1_Param()
{
stringBuilderSet = new MultiSet <StringBuilder>(stringBuilderComparer);
stringBuilderSet.Add(a);
stringBuilderSet.Add(a);
stringBuilderSet.Add(b);
Assert.AreEqual(2, stringBuilderSet.Count);
Assert.AreEqual(2, stringBuilderSet[a]);
Assert.AreEqual(1, stringBuilderSet[b]);
}
public void Operator_Multiply()
{
multiSet = new MultiSet <char>(collection);
MultiSet <char> test = new MultiSet <char>();
test.Add('a', 2);
test.Add('b');
MultiSet <char> multiSets = multiSet * test;
Assert.AreEqual("a: 2, b: 1", multiSets.ToString());
}
public void Constructor_1_Param()
{
multiSet = new MultiSet <char>(comparer);
multiSet.Add('a');
multiSet.Add('a');
multiSet.Add('b');
Assert.AreEqual(2, multiSet.Count);
Assert.AreEqual(2, multiSet['a']);
Assert.AreEqual(1, multiSet['b']);
}
public JsonDataObject Push <TKey>(string Name_, MultiSet <TKey> Data_)
{
var Collection = new JsonDataArray();
foreach (var i in Data_)
{
Collection.Push(i);
}
Add(Name_, Collection);
return(this);
}
public void RemoveChar(int itemsToAdd, int itemsToRemove, int expected)
{
char testChar = 'a';
MultiSet <char> mschar = new MultiSet <char>();
mschar = mschar.Add(testChar, itemsToAdd);
for (int i = 0; i < itemsToRemove; i++)
{
mschar.Remove(testChar);
}
Assert.AreEqual(expected, mschar.Count);
}
public void StringBuilder_ExceptWith_Method()
{
stringBuilderSet = new MultiSet <StringBuilder>();
stringBuilderSet.Add(a);
stringBuilderSet.Add(b);
stringBuilderSet.Add(c);
MultiSet <StringBuilder> multiSets = stringBuilderSet.ExceptWith(stringBuilderCollection);
Assert.AreEqual(0, multiSets.Count);
}
public void StringBuilder_Operator_Multiply()
{
stringBuilderSet = new MultiSet <StringBuilder>(stringBuilderCollection);
MultiSet <StringBuilder> test = new MultiSet <StringBuilder>();
test.Add(a, 2);
test.Add(b);
MultiSet <StringBuilder> multiSets = stringBuilderSet * test;
Assert.AreEqual("aaa: 2, bbb: 1", multiSets.ToString());
}
public void IsEmptyTest(int intCount, bool expected)
{
var list = new List <int>();
var rnd = new Random();
for (int i = 0; i < intCount; i++)
{
list.Add(rnd.Next());
}
var ms = new MultiSet <int>(list);
Assert.AreEqual(expected, ms.IsEmpty);
}
public void IsProperSupersetOf_Method()
{
multiSet = new MultiSet <char>();
multiSet.Add('a', 3);
multiSet.Add('b', 2);
multiSet.Add('c');
multiSet.Add('x', 5);
bool isProperSupersetOf = multiSet.IsProperSupersetOf(collection);
Assert.IsTrue(isProperSupersetOf);
}
public void StringBuilder_IsProperSupersetOf_Method()
{
stringBuilderSet = new MultiSet <StringBuilder>();
stringBuilderSet.Add(a, 3);
stringBuilderSet.Add(b, 2);
stringBuilderSet.Add(c);
stringBuilderSet.Add(c, 5);
bool isProperSupersetOf = stringBuilderSet.IsProperSupersetOf(stringBuilderCollection);
Assert.IsTrue(isProperSupersetOf);
}
public void SymmetricExceptMs()
{
char[] chars = new char[] { 'a', 'b', 'c', 'd', 'e' };
var ms = new MultiSet <char>(chars);
char[] chars2 = new char[] { 'a', 'b', 'x' };
var ms2 = new MultiSet <char>(chars2);
ms = ms.SymmetricExceptWith(ms2);
string output = "x, c, d, e";
Assert.AreEqual(output, ms.ToString().Trim());
}
public void IntersectMs()
{
char[] chars = new char[] { 'a', 'b', 'c', 'd', 'e' };
var ms = new MultiSet <char>(chars);
char[] chars2 = new char[] { 'a', 'b', 'x' };
var ms2 = new MultiSet <char>(chars2);
ms = ms.IntersectWith(ms2);
string output = "a, b";
Assert.AreEqual(output, ms.ToString());
}
public void UnionMs()
{
char[] chars = new char[] { 'a', 'b', 'c', 'd', 'e' };
var ms = new MultiSet <char>(chars);
char[] chars2 = new char[] { 'a', 'b', 'x' };
var ms2 = new MultiSet <char>(chars2);
ms = ms.UnionWith(ms2);
string output = "a, a, b, b, c, d, e, x";
Assert.AreEqual(output, ms.ToString());
}
public void Add()
{
IMultiSet <string> multiSet = new MultiSet <string>();
Assert.AreEqual(0, multiSet.Add(null, 3));
Assert.AreEqual(0, multiSet.Add(string.Empty, 4));
multiSet.Add("ab");
Assert.AreEqual(1, multiSet.Add("ab", 2));
Assert.AreEqual(3, multiSet.Count(i => i == null));
Assert.AreEqual(4, multiSet.Count(i => i == string.Empty));
Assert.AreEqual(3, multiSet.Count(i => i == "ab"));
}
public JsonDataObject Pop <TKey>(string Name_, ref MultiSet <TKey> Data_) where TKey : new()
{
var Collection = (JsonDataArray)this[Name_];
for (Int32 i = 0; i < Collection.Count; ++i)
{
var Key = new TKey();
Collection.Pop(i, ref Key);
Data_.Add(Key);
}
return(this);
}
public void TestCount()
{
MultiSet<string> empty = new MultiSet<string>();
Assert.AreEqual<int>(0, empty.Count);
empty.Add("foo");
empty.Add("bar");
Assert.AreEqual<int>(2, empty.Count);
empty.Add("foo");
empty.Add("foo");
Assert.AreEqual<int>(4, empty.Count);
}
public void Contains()
{
IMultiSet <string> multiSet = new MultiSet <string>();
multiSet.Add("item1", 3);
multiSet.Add("item2", 1);
multiSet.Add(null, 3);
Assert.IsTrue(multiSet.Contains("item1"));
Assert.IsTrue(multiSet.Contains("item2"));
Assert.IsTrue(multiSet.Contains(null));
Assert.IsFalse(multiSet.Contains("itemNotExist"));
}
public JsonDataObject Pop(string Name_, ref MultiSet <string> Data_)
{
var Collection = (JsonDataArray)this[Name_];
for (Int32 i = 0; i < Collection.Count; ++i)
{
string Key = "";
Collection.Pop(i, ref Key);
Data_.Add(Key);
}
return(this);
}
public void add(Aspects.Primary primary1, Aspects.Primary primary2, Aspects.Primary primary3, MultiSet<Aspects.Secondary> secondaries, PotionSlot slot, Aspects.Secondary type, Effect effect)
{
Potion potion = new Potion(primary1, primary2, primary3, secondaries, slot, type, effect);
MultiSet<Aspects.Primary> primaries = new MultiSet<Aspects.Primary>();
primaries.Add(primary1);
primaries.Add(primary2);
primaries.Add(primary3);
if (!potions.ContainsKey(primaries)) {
potions.Add(primaries, new List<Potion>());
}
potions[primaries].Add(potion);
}
public Potion(Aspects.Primary primary1, Aspects.Primary primary2, Aspects.Primary primary3,
MultiSet<Aspects.Secondary> secondaries, PotionSlot slot, Aspects.Secondary type, Effect effect)
{
primaries = new MultiSet<Aspects.Primary>();
primaries.Add(primary1);
primaries.Add(primary2);
primaries.Add(primary3);
this.secondaries = new MultiSet<Aspects.Secondary>(secondaries);
_slot = slot;
_type = type;
_effect = effect;
}
public static string GetCharRange(string text)
{
MultiSet<string> counter = new MultiSet<string>();
foreach (int ch in text)
{
if (ch >= mCharRanges.Count) { counter.Add("Other"); continue; }
counter.Add(mCharRanges[ch]);
}
int max = 0;
string charRange = "Other";
foreach (KeyValuePair<string, int> item in counter)
{
if (item.Value > max) { max = item.Value; charRange = item.Key; }
}
return charRange;
}
private static void Sixth( )
{
var set1 = new MultiSet<char>("abcde".ToCharArray());
foreach (var list in set1.MultiVectors(3))
{
Write(list, " ");
}
Console.ReadKey();
Console.WriteLine("\n");
var set2 = new MultiSet<char>("abcdef".ToCharArray());
foreach (var list in set2.MultiSets(4))
{
Write(list, " ");
}
}
public Potion createPotion(IngredientType ingredient1, IngredientType ingredient2, IngredientType ingredient3)
{
IngredientData data1 = Ingredients.instance().getIngredient(ingredient1);
IngredientData data2 = Ingredients.instance().getIngredient(ingredient2);
IngredientData data3 = Ingredients.instance().getIngredient(ingredient3);
MultiSet<Aspects.Secondary> secondaries = new MultiSet<Aspects.Secondary>();
secondaries.Add(data1.secondary);
secondaries.Add(data2.secondary);
secondaries.Add(data3.secondary);
Potion createdPotion = getBestMatch(data1.primary, data2.primary, data3.primary, secondaries);
logPotionCreation(createdPotion, ingredient1, ingredient2, ingredient3);
if (!hasDoneAutoPause && createdPotion != defaultPotion) {
hasDoneAutoPause = true;
GameObject.FindObjectOfType<PauseMenuController>().pause();
}
return createdPotion;
}
private Potion getBestMatch(Aspects.Primary primary1, Aspects.Primary primary2, Aspects.Primary primary3, MultiSet<Aspects.Secondary> secondaries)
{
MultiSet<Aspects.Primary> primaries = new MultiSet<Aspects.Primary>();
primaries.Add(primary1);
primaries.Add(primary2);
primaries.Add(primary3);
if (!potions.ContainsKey(primaries)) {
return defaultPotion;
}
List<Potion> primaryMatches = potions[primaries];
Potion bestMatch = null;
foreach (Potion primaryMatch in primaryMatches) {
bool match = (primaryMatch.getSecondaries().Except(secondaries).Count == 0);
if (match && (bestMatch == null || bestMatch.getSecondaries().Count() < primaryMatch.getSecondaries().Count())) {
bestMatch = primaryMatch;
}
}
return bestMatch;
}
List<Possibility> FindPossibilitiesForMultiplyCage(int dimension)
{
List<Possibility> possibilities = new List<Possibility>();
List<int> primeFactors = Helper.PrimeFactors(TargetValue);
primeFactors.Add(1);
MultiSet multisetOfPrimes = new MultiSet(primeFactors);
IEnumerable<Partition> partitions = multisetOfPrimes.Partition().Filter(CellCount, dimension);
foreach (var partion in partitions)
{
Possibility newPossibility = new Possibility(partion);
if (newPossibility.MaxRepeatCount <= this.RepeatCount
&& !possibilities.Contains(newPossibility, new SequenceComparer<Possibility>()))
possibilities.Add(newPossibility);
}
return possibilities;
}
public virtual Dictionary<ColouredPlace, MultiSet<Function>> GetAddingTokens()
{
Dictionary<ColouredPlace, MultiSet<Function>> tokens = new Dictionary<ColouredPlace, MultiSet<Function>>();
foreach (var p in this.GetExits())
{
var temp = (Graph[this.Value, p.Value] as ColouredArc).ParsedFunction.Clone() as Function;
temp = temp.SetVariablesValues(this._assVariables);
foreach (var var in temp.Variables)
{
temp = temp.SetVariableValue(var, this._graph.Colors.GetVariable(var).ColorSet.GetRandomValue()) as Function;
}
tokens[p] = new MultiSet<Function>(temp);
}
return tokens;
}
public virtual Dictionary<ColouredPlace, MultiSet<Function>> GetRemovingTokens()
{
Dictionary<ColouredPlace, MultiSet<Function>> tokens = new Dictionary<ColouredPlace, MultiSet<Function>>();
foreach (var p in this.GetEnters())
{
var temp = (Graph[p.Value, this.Value] as ColouredArc).ParsedFunction.Clone() as Function;
tokens[p] = new MultiSet<Function>(temp.SetVariablesValues(this._assVariables));
}
return tokens;
}
public Dictionary<string, FunctionElement> AssignVariables()
{
Dictionary<string, FunctionElement> d = new Dictionary<string, FunctionElement>();
Dictionary<ColouredPlace, Function> arcs = new Dictionary<ColouredPlace, Function>();
foreach (var p in this.GetEnters())
{
arcs.Add(p, (this.Graph[p.Value, this.Value] as ColouredArc).ParsedFunction);
}
var flag1 = true; // индикатор того, что мы что-то нашли
bool flag2 = false; // индикатор ошибки
while (flag1)
{
flag1 = false;
flag2 = false;
// Проходимся по всем выражениям на дугах
foreach (var arc in arcs)
{
if (arc.Key.Tokens.Count == 0)
{
return null;
}
var ms = arc.Value.ToLeaf() as MultiSet<Function>;
if (ms != null) // если выражение на дуге - это мультимножество, то проходимся еще и по нему
{
MultiSet<Function> newMS = new MultiSet<Function>();
foreach (var set in ms)
{
foreach (var token in arc.Key.Tokens) // разбираем фишки в позиции, вдруг что подойдёт
{
if (token.Value != set.Value)
{
continue;
}
var newValue = set.Key.SetVariablesValues(d) as Function;
newMS[newValue] = ms[set.Key];
if (!newValue.IsConstant())
{
flag2 = true;
var d1 = newValue.GetVariablesByConstant(token.Key);
if (d1 == null) // ошибочка какая-то
{
return null;
}
if (d1.Count > 0) // если что-то нашли
{
foreach (var item in d1)
{
if (item.Value.IsConstant()) // и это еще и константа
{
flag1 = true;
d[item.Key] = item.Value;
}
}
}
}
} // конец цикла по фишкам
} // конец цикла по мультимножеству
}
else
{
foreach (var token in arc.Key.Tokens) // разбираем фишки в позиции, вдруг что подойдёт
{
var newValue = arc.Value.SetVariablesValues(d) as Function;
if (!newValue.IsConstant())
{
flag2 = true;
var d1 = newValue.GetVariablesByConstant(token.Key);
if (d1 == null) // ошибочка какая-то
{
continue;
//return null;
}
if (d1.Count > 0) // если что-то нашли
{
foreach (var item in d1)
{
if (item.Value.IsConstant()) // и это еще и константа
{
flag1 = true;
d[item.Key] = item.Value;
}
}
}
}
} // конец цикла по фишкам
}
}
}
return flag2 ? null : d;
}
public void TestEquals()
{
MultiSet<String> requirements = new MultiSet<string>();
requirements.Add("DAIRY");
requirements.Add("PLANT");
requirements.Add("PLANT");
MultiSet<String> available = new MultiSet<string>();
available.Add("PLANT");
available.Add("PLANT");
available.Add("DAIRY");
Assert.AreEqual(requirements, available);
Assert.AreEqual<int>(requirements.GetHashCode(), available.GetHashCode());
}
public void TestExcept()
{
MultiSet<String> requirements = new MultiSet<string>();
requirements.Add("DAIRY");
requirements.Add("PLANT");
requirements.Add("PLANT");
MultiSet<String> available = new MultiSet<string>();
available.Add("PLANT");
available.Add("PLANT");
available.Add("DAIRY");
Assert.AreEqual(requirements.Except(available), new MultiSet<string>());
Assert.AreEqual(available.Except(requirements), new MultiSet<String>());
}
