/// <summary>
/// Distributes the sign from power.
/// </summary>
/// <returns>IBase.</returns>
public override IBase DistributeSignFromPower()
{
if (IsEmpty())
{
return(new SumDifferenceSet());
}
SumDifferenceSet newSet = CloneSet();
//for (int i = 0; i < _units.Count; i++)
//{
// if (_operators[i] == Query.EMPTY.ToString())
// {
// newSet._units[i].FlipSign();
// }
// else if (_operators[i] == Query.ADD.ToString())
// {
// newSet._operators[i] = Query.SUBTRACT.ToString();
// }
// else if (_operators[i] == Query.SUBTRACT.ToString())
// {
// newSet._operators[i] = Query.ADD.ToString();
// }
//}
return(newSet);
}
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 IBase parseAsSumDifference(string value)
{
string newValue = string.Empty;
char lastOperand = Query.EMPTY;
SumDifferenceSet sumDifferenceSet = null;
aggregateAndCombineItems(value, ref sumDifferenceSet, ref lastOperand, ref newValue);
return(finalizeSumDifferenceSet(sumDifferenceSet, newValue, lastOperand));
}
/// <summary>
/// Extracts the sign.
/// </summary>
/// <param name="isRecursive">if set to <c>true</c> [is recursive].</param>
/// <returns>IBase.</returns>
public override IBase ExtractSign(bool isRecursive = false)
{
if (IsEmpty())
{
return(new SumDifferenceSet());
}
SumDifferenceSet newSet = CloneSet();
return(extractSign(newSet, isRecursive));
}
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());
}
/// <summary>
/// Extracts the sign from power.
/// </summary>
/// <returns>IBase.</returns>
public override IBase ExtractSignFromPower()
{
if (IsEmpty())
{
return(new SumDifferenceSet());
}
SumDifferenceSet newSet = CloneSet();
IBase power = newSet.GetPower()?.ExtractSign();
newSet.addPower(power);
return(newSet);
}
private static SumDifferenceSet finalizeSumDifferenceSet(SumDifferenceSet sumDifferenceSet,
string newValue,
char lastOperand)
{
IBase newValuePrimitive = parseToObject(newValue);
if (sumDifferenceSet == null)
{
return(new SumDifferenceSet(newValuePrimitive));
}
sumDifferenceSet.AppendItemToGroup(lastOperand, newValuePrimitive);
return(sumDifferenceSet);
}
/// <summary>
/// Subtracts the symbolic.
/// </summary>
/// <param name="value1">The value1.</param>
/// <param name="value2">The value2.</param>
/// <returns>SumDifferenceSet.</returns>
protected static SumDifferenceSet subtractSymbolic(IBase value1, IBase value2)
{
SumDifferenceSet set;
if (value1 is SumDifferenceSet differenceSet)
{
set = differenceSet.CloneSet();
}
else
{
set = new SumDifferenceSet(value1);
}
set.SubtractItem(value2);
return(set);
}
/// <summary>
/// Inverts all operators (flips all + & - operators).
/// </summary>
/// <param name="newSet">The new set.</param>
/// <returns>MPT.SymbolicMath.SumDifferenceSet.</returns>
protected SumDifferenceSet invertOperators(SumDifferenceSet newSet)
{
for (int i = 0; i < newSet.Count; i++)
{
if (newSet._unitOperatorPair[i].OperatorEquals(Query.ADD))
{
newSet._unitOperatorPair[i] = newSet._unitOperatorPair[i].UpdateOperator(Query.SUBTRACT);
}
else if (newSet._unitOperatorPair[i].OperatorEquals(Query.SUBTRACT))
{
newSet._unitOperatorPair[i] = newSet._unitOperatorPair[i].UpdateOperator(Query.ADD);
}
}
return(newSet);
}
/// <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 (IsEmpty())
{
return(new SumDifferenceSet());
}
SumDifferenceSet newSet = CloneSet();
// Simplify base & power items
if (isRecursive)
{
for (int i = 0; i < newSet.Count; i++)
{
newSet._unitOperatorPair[i] = newSet._unitOperatorPair[i].UpdateUnit(newSet._unitOperatorPair[i].Unit.Simplify(isRecursive: true));
}
}
// Simplified Group
// TODO: Simplified Group
//newSet = SimplifyOperandGroups(isRecursive);
// Sort Numeric vs. Variable
// TODO: Sort Numeric vs. Variable
//newSet = SortNumericBeforeVariables(isRecursive);
// Combine powers
newSet = combinePowers(newSet);
// Simplify Signs
newSet = extractSign(newSet, isRecursive);
newSet = (SumDifferenceSet)newSet.ExtractSignFromPower();
// Simplified Fractional
//newSet = new SumDifferenceSet(simplifyFractional(newSet));
// Combine Numeric
// TODO: Combine Numeric
//newSet = CombineNumeric(isRecursive);
// Combine Variables
// TODO: Simplified Variables
//newSet = CombineVariables(isRecursive);
return(newSet);
}
public override object Clone()
{
IBase unit = Count > 0 ? _unitOperatorPair[0].Unit : null;
SumDifferenceSet newSet = new SumDifferenceSet(unit, _power, SignIsNegative());
for (int i = 1; i < Count; i++)
{
if (_unitOperatorPair[i].OperatorEquals(Query.ADD))
{
newSet.SumItem(_unitOperatorPair[i].Unit);
}
if (_unitOperatorPair[i].OperatorEquals(Query.SUBTRACT))
{
newSet.SubtractItem(_unitOperatorPair[i].Unit);
}
}
return(newSet);
}
private static void aggregateAndCombineItems(
string value,
ref SumDifferenceSet sumDifferenceSet,
ref char lastOperand,
ref string newValue)
{
int continueIndex = -1;
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 (addNewSumDifference(newValue, value, i))
{
newValuePrimitive = parseToObject(newValue);
}
else if (isGroupByBrackets(value, i))
{
newValuePrimitive = newValueFromBracketGroup(value, i, out continueIndex, newValue);
}
else
{
newValuePrimitive = null;
}
sumDifferenceSet = (SumDifferenceSet)updateSet <SumDifferenceSet>(
value, i,
ref newValue,
ref lastOperand,
sumDifferenceSet,
newValuePrimitive);
}
}
/// <summary>
/// Distributes the sign.
/// </summary>
/// <returns>IBase.</returns>
public override IBase DistributeSign()
{
SumDifferenceSet newSet = CloneSet();
for (int i = 0; i < Count; i++)
{
if (_unitOperatorPair[i].OperatorEquals(Query.EMPTY))
{
newSet._unitOperatorPair[i].Unit.FlipSign();
}
else if (_unitOperatorPair[i].OperatorEquals(Query.ADD))
{
newSet._unitOperatorPair[i] = newSet._unitOperatorPair[i].UpdateOperator(Query.SUBTRACT);
}
else if (_unitOperatorPair[i].OperatorEquals(Query.SUBTRACT))
{
newSet._unitOperatorPair[i] = newSet._unitOperatorPair[i].UpdateOperator(Query.ADD);
}
}
return(newSet);
}
/// <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();
}
protected SumDifferenceSet extractSign(SumDifferenceSet newSet, bool isRecursive = false)
{
bool firstValueWasNegative = newSet._unitOperatorPair[0].Unit.SignIsNegative();
if (isRecursive)
{
for (int i = 0; i < newSet.Count; i++)
{
newSet._unitOperatorPair[i] = newSet._unitOperatorPair[i].UpdateUnit(newSet._unitOperatorPair[i].Unit.ExtractSign(isRecursive: true));
}
}
newSet = factorOutNegativeSigns(newSet);
if (!firstValueWasNegative)
{
return(newSet);
}
newSet.FlipSign();
newSet = invertOperators(newSet);
return(newSet);
}
protected IBase getBase(bool getAbsolute = false)
{
if (Count == 0)
{
return(new SumDifferenceSet());
}
IBase unitBase = getUnit(0, getAbsolute);
SumDifferenceSet newSet = new SumDifferenceSet(unitBase);
for (int i = 1; i < Count; i++)
{
if (_unitOperatorPair[i].OperatorEquals(Query.ADD))
{
newSet.SumItem(_unitOperatorPair[i].Unit);
}
if (_unitOperatorPair[i].OperatorEquals(Query.SUBTRACT))
{
newSet.SubtractItem(_unitOperatorPair[i].Unit);
}
}
return(newSet);
}
/// <summary>
/// Factors the out negative signs (all +- and -- cases).
/// </summary>
/// <param name="newSet">The new set.</param>
/// <returns>MPT.SymbolicMath.SumDifferenceSet.</returns>
protected SumDifferenceSet factorOutNegativeSigns(SumDifferenceSet newSet)
{
for (int i = 0; i < newSet.Count; i++)
{
if (!newSet._unitOperatorPair[i].Unit.SignIsNegative())
{
continue;
}
// Flip sign of unit and flip operator
newSet._unitOperatorPair[i].Unit.FlipSign();
if (newSet._unitOperatorPair[i].OperatorEquals(Query.ADD))
{
newSet._unitOperatorPair[i] = newSet._unitOperatorPair[i].UpdateOperator(Query.SUBTRACT);
}
else if (newSet._unitOperatorPair[i].OperatorEquals(Query.SUBTRACT))
{
newSet._unitOperatorPair[i] = newSet._unitOperatorPair[i].UpdateOperator(Query.ADD);
}
}
return(newSet);
}
/// <summary>
/// Simplifies the units of one.
/// </summary>
/// <param name="isRecursive">if set to <c>true</c> [is recursive].</param>
/// <returns>IBaseSet.</returns>
public override IBaseSet SimplifyUnitsOfOne(bool isRecursive = true)
{
if (IsEmpty())
{
return(new SumDifferenceSet());
}
SumDifferenceSet newSet = CloneSet();
if (!isRecursive)
{
return(newSet);
}
// Simplify
for (int i = 0; i < newSet.Count; i++)
{
if (_unitOperatorPair[i].Unit is IBaseSet unitSet)
{
newSet._unitOperatorPair[i] = newSet._unitOperatorPair[i].UpdateUnit(unitSet.SimplifyUnitsOfOne(isRecursive: true));
}
}
return(newSet);
}
