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