public void ForEach_Resets()
{
PrimitiveUnit unit0 = new PrimitiveUnit("a");
ProductQuotientSet productQuotientSet = new ProductQuotientSet(unit0);
PrimitiveUnit unit1 = new PrimitiveUnit("b", new PrimitiveUnit("2"));
productQuotientSet.MultiplyItem(unit1);
PrimitiveUnit unit2 = new PrimitiveUnit("c");
productQuotientSet.DivideItem(unit2);
IEnumerator enumerator = productQuotientSet.GetEnumerator();
enumerator.MoveNext();
UnitOperatorPair unitOperatorPair = (UnitOperatorPair)enumerator.Current;
Assert.IsTrue(unitOperatorPair.Unit.Equals(unit0));
enumerator.MoveNext();
unitOperatorPair = (UnitOperatorPair)enumerator.Current;
Assert.IsTrue(unitOperatorPair.Unit.Equals(unit1));
enumerator.Reset();
unitOperatorPair = (UnitOperatorPair)enumerator.Current;
Assert.IsTrue(unitOperatorPair.Unit.Equals(unit0));
}
public void ForEach_Iterates_Items()
{
PrimitiveUnit unit0 = new PrimitiveUnit("a");
ProductQuotientSet productQuotientSet = new ProductQuotientSet(unit0);
PrimitiveUnit unit1 = new PrimitiveUnit("b", new PrimitiveUnit("2"));
productQuotientSet.MultiplyItem(unit1);
PrimitiveUnit unit2 = new PrimitiveUnit("c");
productQuotientSet.DivideItem(unit2);
int counter = 0;
foreach (UnitOperatorPair item in productQuotientSet)
{
switch (counter)
{
case 0:
Assert.IsTrue(item.Unit.Equals(unit0));
break;
case 1:
Assert.IsTrue(item.Unit.Equals(unit1));
break;
case 2:
Assert.IsTrue(item.Unit.Equals(unit2));
break;
}
counter++;
}
}
public void ForEach_Throws_Exception()
{
PrimitiveUnit unit0 = new PrimitiveUnit("a");
ProductQuotientSet productQuotientSet = new ProductQuotientSet(unit0);
PrimitiveUnit unit1 = new PrimitiveUnit("b", new PrimitiveUnit("2"));
productQuotientSet.MultiplyItem(unit1);
PrimitiveUnit unit2 = new PrimitiveUnit("c");
productQuotientSet.DivideItem(unit2);
// Not incremented yet
IEnumerator enumerator = productQuotientSet.GetEnumerator();
Assert.Throws <ArgumentOutOfRangeException>(() => { IBase badUnit = (IBase)enumerator.Current; });
enumerator.MoveNext();
UnitOperatorPair unitOperatorPair = (UnitOperatorPair)enumerator.Current;
Assert.IsTrue(unitOperatorPair.Unit.Equals(unit0));
enumerator.MoveNext();
unitOperatorPair = (UnitOperatorPair)enumerator.Current;
Assert.IsTrue(unitOperatorPair.Unit.Equals(unit1));
enumerator.MoveNext();
unitOperatorPair = (UnitOperatorPair)enumerator.Current;
Assert.IsTrue(unitOperatorPair.Unit.Equals(unit2));
// Too many increments
enumerator.MoveNext();
Assert.Throws <ArgumentOutOfRangeException>(() => { IBase badUnit = (IBase)enumerator.Current; });
}
protected override ProductQuotientSet simplifyFractional <T>(T newSetGeneric)
{
if (!(newSetGeneric is SumDifferenceSet))
{
return(new ProductQuotientSet(newSetGeneric));
}
SumDifferenceSet newSet = newSetGeneric as SumDifferenceSet;
if (newSet.Count < 2)
{
return(new ProductQuotientSet(newSet));
}
ProductQuotientSet leftSet = fractionSet(newSet, 0);
for (int i = 1; i < newSet.Count; i++)
{
ProductQuotientSet rightSet = fractionSet(newSet, i);
IBase unitA = unitSet(leftSet, 0);
IBase unitB = unitSet(leftSet, 1);
IBase unitC = unitSet(rightSet, 0);
IBase unitD = unitSet(rightSet, 1);
ProductQuotientSet numeratorSetLeft = new ProductQuotientSet(unitA);
numeratorSetLeft.MultiplyItem(unitD);
numeratorSetLeft = simplifyNumeric <ProductQuotientSet>(numeratorSetLeft);
ProductQuotientSet numeratorSetRight = new ProductQuotientSet(unitC);
numeratorSetRight.MultiplyItem(unitB);
numeratorSetRight = simplifyNumeric <ProductQuotientSet>(numeratorSetRight);
ProductQuotientSet denominatorSet = new ProductQuotientSet(unitB);
denominatorSet.MultiplyItem(unitD);
denominatorSet = simplifyNumeric <ProductQuotientSet>(denominatorSet);
SumDifferenceSet numeratorSet = new SumDifferenceSet(numeratorSetLeft);
if (newSet._unitOperatorPair[i].OperatorEquals(Query.ADD))
{
numeratorSet.SumItem(numeratorSetRight);
}
else if (newSet._unitOperatorPair[i].OperatorEquals(Query.SUBTRACT))
{
numeratorSet.SubtractItem(numeratorSetRight);
}
numeratorSet = simplifyNumeric <SumDifferenceSet>(numeratorSet);
leftSet = new ProductQuotientSet(numeratorSet);
leftSet.DivideItem(denominatorSet);
}
string simplifiedFraction = Query.SimplifiedFraction(leftSet.Label());
ProductQuotientSet set = new ProductQuotientSet(simplifiedFraction);
return((ProductQuotientSet)set.SimplifyUnitsOfOne());
}
public void Index_Accesses_Invalid_Index_Throws_Exception()
{
ProductQuotientSet productQuotientSet = new ProductQuotientSet("a");
PrimitiveUnit unit1 = new PrimitiveUnit("b", new PrimitiveUnit("2"));
productQuotientSet.MultiplyItem(unit1);
PrimitiveUnit unit2 = new PrimitiveUnit("c");
productQuotientSet.DivideItem(unit2);
Assert.Throws <ArgumentOutOfRangeException>(() => { UnitOperatorPair unitOperatorPair = productQuotientSet[-1]; });
Assert.Throws <ArgumentOutOfRangeException>(() => { UnitOperatorPair unitOperatorPair = productQuotientSet[3]; });
}
public void Index_Accesses_Valid_Index_Returns_Item()
{
ProductQuotientSet productQuotientSet = new ProductQuotientSet("a");
PrimitiveUnit unit1 = new PrimitiveUnit("b", new PrimitiveUnit("2"));
productQuotientSet.MultiplyItem(unit1);
PrimitiveUnit unit2 = new PrimitiveUnit("c");
productQuotientSet.DivideItem(unit2);
UnitOperatorPair unitOperatorPair = productQuotientSet[1];
Assert.IsTrue(unitOperatorPair.Unit.Equals(unit1));
Assert.That(unitOperatorPair.Operator, Is.EqualTo("*"));
}
/// <summary>
/// Divides the symbolic.
/// </summary>
/// <param name="value1">The value1.</param>
/// <param name="value2">The value2.</param>
/// <returns>ProductQuotientSet.</returns>
protected static ProductQuotientSet divideSymbolic(IBase value1, IBase value2)
{
ProductQuotientSet set;
switch (value1)
{
case ProductQuotientSet set1 when set1.Count > 1 && value2 is ProductQuotientSet set2 && set2.Count > 1:
return(new ProductQuotientSet(
Group.AddOuterBrackets(value1.Label()) + Query.DIVIDE + Group.AddOuterBrackets(value2.Label())));
case ProductQuotientSet productQuotientSet:
set = productQuotientSet.CloneSet();
break;
default:
set = new ProductQuotientSet(value1);
break;
}
set.DivideItem(value2);
return(set);
}
