public string Label_with_ProductQuotient_Power(string value, string powerValue) { ProductQuotientSet power = new ProductQuotientSet(powerValue); PrimitiveUnit unit = new PrimitiveUnit(value, power); return(unit.Label()); }
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)); }
/// <summary> /// Simplifies the specified is recursive. /// </summary> /// <param name="isRecursive">if set to <c>true</c> [is recursive].</param> /// <returns>IBase.</returns> public override IBase Simplify(bool isRecursive = false) { if (string.IsNullOrEmpty(_base)) { return(new PrimitiveUnit(string.Empty)); } switch (PowerLabel()) { case "0": return(new PrimitiveUnit(1)); case "1": case "": return(SimplifyBase()); default: IBase newPower = SimplifyPower(isRecursive); if (newPower.Label() == "0") { return(new PrimitiveUnit(1)); } IBase newBase; if (newPower.ValueIsNegative()) { // Flip the fraction and use a positive power newBase = getInvertedSimplifiedBase(newPower, isRecursive); IBase simplifiedUnit = new ProductQuotientSet(1); return(simplifiedUnit.Divide(newBase)); } newBase = SimplifyBase(newPower); newBase.ExtractSign(isRecursive); return(newBase); } }
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 override bool AppendItemToGroup(char lastOperand, IBase newValuePrimitive) { switch (lastOperand) { case Query.ADD: return(SumItem(newValuePrimitive)); case Query.SUBTRACT: return(SubtractItem(newValuePrimitive)); case Query.MULTIPLY: case Query.DIVIDE: IBase lastUnit = _unitOperatorPair[_unitOperatorPair.Count - 1].Unit; ProductQuotientSet productQuotientSet; if (!(lastUnit is ProductQuotientSet)) { productQuotientSet = new ProductQuotientSet(lastUnit); } else { productQuotientSet = lastUnit as ProductQuotientSet; } productQuotientSet.AppendItemToGroup(lastOperand, newValuePrimitive); _unitOperatorPair[_unitOperatorPair.Count - 1] = _unitOperatorPair[_unitOperatorPair.Count - 1].UpdateUnit(productQuotientSet); return(true); default: return(false); } }
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; }); }
private static ProductQuotientSet finalizeProductQuotientSet(ProductQuotientSet productQuotientSet, string newValue, char lastOperand) { IBase newValuePrimitive = parseToObject(newValue); if (productQuotientSet == null) { return(new ProductQuotientSet(newValuePrimitive)); } switch (lastOperand) { case Query.POWER when !productQuotientSet.HasPower(): productQuotientSet.SetPower(newValuePrimitive); break; case Query.POWER: productQuotientSet = new ProductQuotientSet(productQuotientSet); productQuotientSet.SetPower(newValuePrimitive); break; default: productQuotientSet.AppendItemToGroup(lastOperand, newValuePrimitive); break; } return(productQuotientSet); }
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); }
private static void aggregateAndCombineItems( string value, ref ProductQuotientSet productQuotientSet, ref char lastOperand, ref string newValue) { int continueIndex = -1; // Aggregate and combine items for (int i = 0; i < value.Length; i++) { if (i < continueIndex) { continue; } IBase newValuePrimitive; if (isGroupByProductQuotient(value, i, lastOperand)) { // newValuePrimitive needs to be formulated from all values leading up to next SumDifference newValuePrimitive = newValueFromProductQuotientGroup(value, i, out continueIndex, newValue); } else if (addNewProductQuotient(newValue, value[i])) { newValuePrimitive = parseToObject(newValue); } else if (addNewSumDifference(newValue, value, i)) { newValuePrimitive = parseToObject(newValue); } else if (isGroupByBrackets(value, i)) { newValuePrimitive = newValueFromBracketGroup(value, i, out continueIndex, newValue); if (lastOperand == Query.ADD || lastOperand == Query.SUBTRACT) { string remainingValue = value.Substring(i); newValue += remainingValue; continueIndex += remainingValue.Length; newValuePrimitive = parseToObject(newValue); } } else if (value[i] == Query.POWER && (newValue.Contains(Query.POWER) || lastOperand == Query.POWER)) { newValuePrimitive = parseToObject(newValue); } else { newValuePrimitive = null; } productQuotientSet = (ProductQuotientSet)updateSet <ProductQuotientSet>( value, i, ref newValue, ref lastOperand, productQuotientSet, newValuePrimitive); } }
private static IBase parseAsProductQuotient(string value) { string newValue = string.Empty; char lastOperand = Query.EMPTY; ProductQuotientSet productQuotientSet = null; aggregateAndCombineItems(value, ref productQuotientSet, ref lastOperand, ref newValue); // Combine final item and return return(finalizeProductQuotientSet(productQuotientSet, newValue, lastOperand)); }
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> /// Simplifies the power. /// </summary> /// <param name="isRecursive">if set to <c>true</c> [is recursive].</param> /// <returns>IBase.</returns> public virtual IBase SimplifyPower(bool isRecursive = false) { if (!HasPower()) { return(new PrimitiveUnit(string.Empty)); } string powerLabel = PowerLabel(); if (powerLabel == "0" || powerLabel == "-0") { return(new ProductQuotientSet(0)); } Sign powerSign = GetPower().GetSign(); if (string.IsNullOrEmpty(powerLabel) || powerLabel == "1") { return(new ProductQuotientSet(powerSign * powerLabel)); } if (isRecursive) { IBase newSimplifiedPower = GetPower().Simplify(true); powerLabel = newSimplifiedPower.Label(); } else { powerLabel = GetPower().Label(); } // If power is negative, make it positive for fraction simplification bool powerIsNegative = Query.IsNegative(powerLabel, 0); if (powerIsNegative && powerLabel.Length > 1) { powerLabel = powerLabel.Substring(1); if (powerLabel == "0") { return(new PrimitiveUnit("1")); } } powerLabel = Query.IsSymbolicFraction(powerLabel) ? Query.SimplifiedFraction(powerLabel) : powerLabel; IBase newPower = new ProductQuotientSet(powerSign * powerLabel); return(newPower); }
private static IBase newValueFromBracketGroup(string value, int i, out int continueIndex, string newValue = "") { // Check for negative sign & adjust index to include if ((i > 0 && value[i - 1] == Sign.NEGATIVE) && (i == 1 || (i > 1 && Query.OperatorAllTypes.Contains(value[i - 2])))) { i--; } // Create new item from grouped parentheses Group group = new Group(value.Substring(i)); continueIndex = group.ContinueIndex >= 0 ? i + group.ContinueIndex : i; bool isNegative = group.IsNegative; IBase newValueBase = string.IsNullOrEmpty(group.Base) ? null : parseToObject(group.Base); IBase newPower = string.IsNullOrEmpty(group.Power) ? null : parseToObject(group.Power); IBase newGroup; if (newValueBase == null) { return(null); } if (newPower == null && !isNegative) { newGroup = newValueBase; } else { newGroup = new ProductQuotientSet(newValueBase, newPower, isNegative); } if (!string.IsNullOrEmpty(newValue) && (i > 0 && value[i - 1] == Query.POWER)) { return(new ProductQuotientSet(newValue, newGroup)); } return(newGroup); }
/// <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); }
/// <summary> /// Simplifies the variables. /// </summary> /// <param name="isRecursive">if set to <c>true</c> [is recursive].</param> /// <returns>IBaseSet.</returns> /// <exception cref="NotImplementedException"></exception> public override IBaseSet SimplifyVariables(bool isRecursive = false) { Dictionary <string, int> variables = ExtractVariableAndValue(); SumDifferenceSet newSet = null; foreach (var variableSet in variables) { if (variables.Count == 1 && variableSet.Value == 0) { return(new ProductQuotientSet(0)); } if (variableSet.Value == 0) { continue; } bool variableIsPositive = variableSet.Value > 0; ProductQuotientSet currentVariable = gatherVariables(variableSet.Key, variableSet.Value); if (newSet == null) { newSet = new SumDifferenceSet(currentVariable); } else if (variableIsPositive) { newSet.SumItem(currentVariable); } else { currentVariable.FlipSign(); newSet.SubtractItem(currentVariable); } } return(newSet == null?CloneSet() : newSet.SimplifyUnitsOfOne()); throw new NotImplementedException(); }
/// <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); }