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