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 SumDifferenceSet combinePowers(SumDifferenceSet newSet)
{
for (int i = 0; i < newSet.Count - 1; i++)
{
bool baseAIsNegative = newSet._unitOperatorPair[i].Unit.GetSign().IsNegative();
IBase baseA = newSet._unitOperatorPair[i].Unit.GetBase();
IBase powerA = newSet._unitOperatorPair[i].Unit.GetPower() ?? new PrimitiveUnit(1);
IBase baseB = newSet._unitOperatorPair[i + 1].Unit.GetBase();
IBase powerB = newSet._unitOperatorPair[i + 1].Unit.GetPower() ?? new PrimitiveUnit(1);
bool baseSignIsSame = newSet._unitOperatorPair[i].Unit.GetSign().Equals(newSet._unitOperatorPair[i + 1].Unit.GetSign());
bool isSum = (newSet._unitOperatorPair[i + 1].OperatorEquals(Query.ADD));
bool baseIsSame = baseA.GetBase().Equals(baseB.GetBase());
bool exponentIsSame = powerA.GetBase().Equals(powerB.GetBase());
bool powerSignIsSame = powerA.GetSign().Equals(powerB.GetSign());
// (1a) Same Base, Same exponent, Same exponent sign
if (baseIsSame && exponentIsSame && powerSignIsSame)
{
if ((isSum && baseSignIsSame) ||
(!isSum && !baseSignIsSame))
{ // Add Exponent Same Sign
ProductQuotientSet newBasePower = new ProductQuotientSet(2);
newBasePower.MultiplyItem(new ProductQuotientSet(baseA, powerA));
newSet = new SumDifferenceSet(newBasePower, null, baseAIsNegative);
}
else
{ // Subtract Exponent Same Sign
newSet = new SumDifferenceSet(0);
}
}
// (1b) Same Base, Same exponent, Different sign
// (2) Same Base, Different exponent (ignore sign)
// (3) Different Base, Same exponent (ignore sign)
// (4) Different Base, Different exponent (ignore sign)
if (!baseIsSame && !exponentIsSame)
{
// Do Nothing
}
}
// Calculate if numeric
IBase power = newSet.GetPower();
if (power == null || !power.IsNumber())
{
return(newSet);
}
power = new PrimitiveUnit(power.Calculate());
newSet = new SumDifferenceSet(
new ProductQuotientSet(newSet.GetBase(), power, newSet.SignIsNegative())
);
return(newSet);
}
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>
/// Gathers the variables.
/// </summary>
/// <param name="label">The label.</param>
/// <param name="count">The count.</param>
/// <returns>ProductQuotientSet.</returns>
private ProductQuotientSet gatherVariables(string label, int count)
{
if (count == 1)
{
return(new ProductQuotientSet(label));
}
else if (count == -1)
{
return(new ProductQuotientSet(label, null, isNegative: true));
}
else
{
ProductQuotientSet newSetMultiple = new ProductQuotientSet(count);
newSetMultiple.MultiplyItem(new ProductQuotientSet(label));
return(newSetMultiple);
}
}
/// <summary>
/// Multiplies the symbolic.
/// </summary>
/// <param name="value1">The value1.</param>
/// <param name="value2">The value2.</param>
/// <returns>ProductQuotientSet.</returns>
protected static ProductQuotientSet multiplySymbolic(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.MULTIPLY + Group.AddOuterBrackets(value2.Label())));
case ProductQuotientSet differenceSet:
set = differenceSet.CloneSet();
break;
default:
set = new ProductQuotientSet(value1);
break;
}
set.MultiplyItem(value2);
return(set);
}
