public CNumber(CRatio thatRatio)
{
double dblValue = thatRatio.Numerator;
dblValue /= thatRatio.Denominator;
InitFromNumber(dblValue, true);
}
// Divide like quantities by subtracting powers.
// This is usually applied to matching numerator and denominator factors in an Expression when normalizing.
public bool DivideLike(CFactor thatFactor)
{
bool bSuccess = false;
if (this.Label == thatFactor.Label)
{
if (this.Root == 1 && thatFactor.Root == 1)
{
_ratioPower.NumeratorSubtract(thatFactor.Power);
}
else
{
if (this.Root == thatFactor.Root)
{
_ratioPower.NumeratorSubtract(thatFactor.Power);
}
else
{
// Cross multiply
int intRootM = _ratioPower.Denominator * thatFactor.Root;
int intPowerM = _ratioPower.Numerator * thatFactor.Root - thatFactor.Power * _ratioPower.Denominator;
_ratioPower = new CRatio(intRootM, intPowerM);
}
_ratioPower.Normalize();
}
bSuccess = true;
}
return(bSuccess);
}
// deep copy
public CExpression(CExpression thatExpression)
{
Init();
_numerator = new CFactorList(thatExpression.Numerator);
_denominator = new CFactorList(thatExpression.Denominator);
_power = new CRatio(thatExpression.RatioPower);
_log = thatExpression.Log;
_symbolCount = thatExpression.SymbolCount;
}
private void Init()
{
_power = new CRatio(1);
_numerator = new CFactorList();
_denominator = new CFactorList();
_log = 0;
_isLogValid = false;
_isValid = true;
_symbolCount = 0;
}
// Simplify integer to an integer power.
// Resultant power is either 1 or 1/n.
public void ApplyPowerToInteger()
{
if (Qty.IsInteger)
{
int intValue = (int)Qty.Number.Value;
CRatio thisRatio = new CRatio(intValue);
bool bSuccess = thisRatio.ApplyPower(ref _ratioPower);
CNumber numberToPower = new CNumber(thisRatio);
CQuantityList theQuantityList = this.Qty.QuantityList;
// Because the calculated quantity value has changed, the factor qty must be replaced.
this.Qty = theQuantityList.ReplaceIntegerQuantity(numberToPower);
}
}
// Return true and apply root to value if the result works out to integer
// else return false.
public bool ApplyRoot(int intRoot)
{
bool bSuccess = false;
if (intRoot == 0)
{
// panic, zero root
bSuccess = false;
}
else if (intRoot == 1)
{
bSuccess = true;
}
else if (intRoot < 0)
{
// panic, negative root
bSuccess = false;
}
else if (_remainder == 1)
{
// general case
bSuccess = true; // innocent until proven guilty
for (int i = 0; i < Count; ++i)
{
CPrimeFactor thisFactor = this[i];
int intTrial = thisFactor.Count;
bSuccess = CRatio.DivideInt(ref intTrial, intRoot);
if (bSuccess)
{
thisFactor.SetCount(intTrial);
}
else
{
break; // guilty
}
}
if (bSuccess)
{
Recalc();
}
}
return(bSuccess);
}
public void Normalize()
{
int intNumIndex, intDenomIndex = 0;
_numerator.Normalize();
_denominator.Normalize();
if (_numerator.Count > 0 && _denominator.Count > 0)
{
for (intNumIndex = _numerator.Count - 1; intNumIndex > -1; --intNumIndex)
{
// if dupe is found in denominator then adjust both numerator and denominator
CFactor numeratorFactor = _numerator[intNumIndex];
intDenomIndex = _denominator.Find(numeratorFactor.Label);
if (intDenomIndex > -1)
{
CFactor denominatorFactor = _denominator[intDenomIndex];
numeratorFactor.DivideLike(denominatorFactor);
_denominator.RemoveAt(intDenomIndex);
_isLogValid = false;
}
// if inverse is found in denominator then adjust both numerator and denominator
intDenomIndex = _denominator.Find(numeratorFactor.Qty.InverseLabel);
if (intDenomIndex > -1)
{
CFactor denominatorFactor = _denominator[intDenomIndex];
CQuantity inverseQty = denominatorFactor.Qty.InverseQty;
denominatorFactor.Qty = inverseQty;
numeratorFactor.MultiplyLike(denominatorFactor);
_denominator.RemoveAt(intDenomIndex);
_isLogValid = false;
}
}
}
// if numerator factor has negative power swap it to denominator
for (intNumIndex = _numerator.Count - 1; intNumIndex > -1; --intNumIndex)
{
CFactor numeratorFactor = _numerator[intNumIndex];
if (numeratorFactor.Power == 0)
{
_numerator.RemoveAt(intNumIndex);
}
else if (numeratorFactor.Power < 0)
{
_numerator.RemoveAt(intNumIndex);
numeratorFactor.FlipPower();
_denominator.Add(numeratorFactor);
_isLogValid = false;
}
}
// if denominator factor has negative power swap it to numerator
for (intDenomIndex = _denominator.Count - 1; intDenomIndex > -1; --intDenomIndex)
{
CFactor denominatorFactor = _denominator[intDenomIndex];
if (denominatorFactor.Power == 0)
{
_denominator.RemoveAt(intDenomIndex);
}
else if (denominatorFactor.Power < 0)
{
_denominator.RemoveAt(intDenomIndex);
denominatorFactor.FlipPower();
_numerator.Add(denominatorFactor);
_isLogValid = false;
}
}
// net out integers between numerator and denominator
int intNumeratorIndex = _numerator.FindInteger();
int intDenominatorIndex = _denominator.FindInteger();
if (intNumeratorIndex > -1 && intDenominatorIndex > -1)
{
CFactor numeratorFactor = _numerator[intNumeratorIndex];
CFactor denominatorFactor = _denominator[intDenominatorIndex];
if (numeratorFactor.RatioPower.Equals(1) && denominatorFactor.RatioPower.Equals(1))
{
int intNumeratorValue = (int)numeratorFactor.Qty.Value;
int intDenominatorValue = (int)denominatorFactor.Qty.Value;
// Putting both integers into a CRatio has the effect of reducing them
CRatio ratioThis = new CRatio(intNumeratorValue, intDenominatorValue);
double dblNumerator = (double)ratioThis.Numerator;
double dblDenominator = (double)ratioThis.Denominator;
CNumber numberNumerator = new CNumber(dblNumerator);
CNumber numberDenominator = new CNumber(dblDenominator);
CQuantityList theQuantityList = numeratorFactor.Qty.QuantityList;
numeratorFactor.Qty = theQuantityList.ReplaceIntegerQuantity(numberNumerator);
denominatorFactor.Qty = theQuantityList.ReplaceIntegerQuantity(numberDenominator);
}
}
_numerator.Normalize();
_denominator.Normalize();
SetSymbolCount();
}
private void Init()
{
_ratioPower = new CRatio(1);
}
// Raise this factor to p/r
public void ApplyPower(CRatio thatPower)
{
_ratioPower.ApplyMultiplication(thatPower);
}
