示例#1
0
 // construct from either value or log
 public CQuantity(CQuantityList thatQuantityList, string strThatLabel, double dblToken, bool bIsValue)
 {
     Init(thatQuantityList);
     _symbol    = new CSymbol(strThatLabel);
     _number    = new CNumber(dblToken, bIsValue);
     _isInteger = _number.IsInteger;
 }
示例#2
0
        // this constructor initializes from a line of QuantityValues.txt
        public CQuantity(CQuantityList thatQuantityList, string strLine)
        {
            Init(thatQuantityList);
            string strThatLabel = ParseLine(ref strLine);
            string strToken     = ParseLine(ref strLine);
            string strExactFlag = ParseLine(ref strLine);

            _symbol = new CSymbol(strThatLabel);
            if (strToken == "")
            {
                _number = new CNumber();
            }
            else
            {
                _number      = new CNumber(strToken, true);
                _uncertainty = new CNumber(_number.Uncertainty);
                _lowfence    = new CNumber(_number.Value - _uncertainty.Value, true);
                _highfence   = new CNumber(_number.Value + _uncertainty.Value, true);
            }
            _isExact         = strExactFlag.ToUpper() == "X";
            _isComputational = strExactFlag.ToUpper() == "C";
            _isQED           = strExactFlag.ToUpper() == "Q";
            _isSuppressed    = strExactFlag.ToUpper() == "S";
            _isInteger       = _number.IsInteger;
        }
示例#3
0
 // construct integer quantity from label and value
 public CQuantity(CQuantityList thatQuantityList, bool bIsInteger, string strThatLabel, double dblToken)
 {
     Init(thatQuantityList);
     _isExact   = true;
     _isInteger = true;
     _symbol    = new CSymbol(strThatLabel);
     _number    = new CNumber(dblToken, true);
 }
示例#4
0
        // This constructor makes an index that points into a Quantity List
        public CQtyPointerList(ref CQuantityList thatQuantityList) : base()
        {
            int i;

            for (i = 0; i < thatQuantityList.Count; ++i)
            {
                CQtyPointer thisQtyPointer = new CQtyPointer(thatQuantityList[i]);
                Add(thisQtyPointer);
            }
            Sort();
        }
示例#5
0
        // This constructor makes an index that points into a Quantity List
        public CFactorList(ref CQuantityList thatQuantityList) : base()
        {
            int i;

            for (i = 0; i < thatQuantityList.Count; ++i)
            {
                CFactor thisFactor = new CFactor(thatQuantityList[i]);
                Add(thisFactor);
            }
            Sort();
        }
示例#6
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);
     }
 }
示例#7
0
 private void Init(CQuantityList thatQuantityList)
 {
     _intIndex                = -1;
     _isExact                 = false;
     _isComputational         = false;
     _isQED                   = false;
     _isSuppressed            = false;
     _isInteger               = false;
     _uncertainty             = new CNumber(0);
     _lowfence                = new CNumber();
     _highfence               = new CNumber();
     _candidate               = new CNumber();
     _expressionList          = new CExpressionList();
     _candidateExpressionList = new CExpressionList();
     _inverseQty              = null;
     _quantityList            = thatQuantityList;
 }
示例#8
0
        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();
        }
示例#9
0
        // This is a candidate group to define a quantity.
        // 1. Determine if the quantity already exists.
        // 2. If new then determine if it has enough members and sufficient diversity
        //    to define a new quantity.
        // 3. Assign the quantity to every matrix cell in this group.
        public void QualifyGroup(int intFirst, int intCount, CQuantityList myQuantityList)
        {
            CStringList labelList = new CStringList();

            bool bGoodQuantity = true;
            bool bIsExact      = false; // set flag if this is new quantity

            for (int i = intFirst; i < intFirst + intCount; ++i)
            {
                CMatrixCell myMatrixCell = this[i];
                if (myMatrixCell.IsExact)
                {
                    bIsExact = true;
                }
                CQuantity qtyX = myMatrixCell.PtrX.Qty;
                CQuantity qtyY = myMatrixCell.PtrY.Qty;
                if (!qtyX.IsInteger)
                {
                    labelList.Add(qtyX.Label);
                }
                if (!qtyY.IsInteger)
                {
                    labelList.Add(qtyY.Label);
                }
            }

            if (labelList.Count > 1)
            {
                // This is a qualifying quantity
                double dblLog       = this[intFirst].Number.Log;
                int    intQtyIndex  = myQuantityList.FindEquivalent(this[intFirst].Number);
                bool   bNewQuantity = (intQtyIndex < 0);
                bGoodQuantity = true;
                CQuantity thisQuantity;
                if (bNewQuantity)
                {
                    string strLabel = "X_" + myQuantityList.Count.ToString();
                    thisQuantity         = new CQuantity(myQuantityList, strLabel, dblLog, false);
                    thisQuantity.IsExact = bIsExact;
                    myQuantityList.Add(thisQuantity);
                }
                else
                {
                    thisQuantity = myQuantityList[intQtyIndex];
                }

                CSymbol   symbolInverse   = thisQuantity.SymbolInverse();
                CQuantity inverseQuantity = thisQuantity.Inverse(symbolInverse.Label);
                int       intInverse      = myQuantityList.FindEquivalent(inverseQuantity);
                bool      bNewInverse     = (intInverse < 0);
                if (bNewInverse)
                {
                    myQuantityList.Add(inverseQuantity);
                    inverseQuantity.SetInverse(ref thisQuantity);
                }
                else
                {
                    // inverse quantity already exists in the list
                    inverseQuantity = myQuantityList[intInverse];
                    if (bNewQuantity)
                    {
                        if (inverseQuantity.IsInteger)
                        {
                            // never add inverses to integers
                            bGoodQuantity = false;
                            myQuantityList.RemoveAt(thisQuantity.Index);
                        }
                        else
                        {
                            thisQuantity.Symbol = inverseQuantity.SymbolInverse();
                            thisQuantity.SetInverse(ref inverseQuantity);
                            thisQuantity.IsExact = inverseQuantity.IsExact;
                        }
                    }
                }

                if (bGoodQuantity)
                {
                    // assign the quantity to every matrix cell in the group
                    for (int i = intFirst; i < intFirst + intCount; ++i)
                    {
                        CMatrixCell myMatrixCell = this[i];
                        myMatrixCell.PtrQty = new CQtyPointer(thisQuantity);
                    }
                }
            }
        }
示例#10
0
        // Sort quantities and then combine dupes by adding powers.
        public void Normalize()
        {
            Sort();
            int i;

            // combine like factors
            for (i = this.Count - 1; i > 0; --i)
            {
                if (this[i].Label == this[i - 1].Label)
                {
                    // n^x * n^y = n^xy
                    this[i - 1].MultiplyLike(this[i]);
                    this.RemoveAt(i);
                }
            }
            // Simplify integer to a power
            for (i = this.Count - 1; i > -1; --i)
            {
                CFactor thisFactor = this[i];
                if (thisFactor.Qty.IsInteger && thisFactor.Power != 1)
                {
                    thisFactor.ApplyPowerToInteger();
                }
            }
            // combine integer factors
            for (i = this.Count - 1; i > 0; --i)
            {
                CFactor thisFactor = this[i];
                CFactor nextFactor = this[i - 1];
                if (thisFactor.IsInteger && nextFactor.IsInteger)
                {
                    // !!! ToDo: deal with root != 1
                    CNumber       numberProduct   = nextFactor.MultiplyIntegers(thisFactor);
                    CQuantityList theQuantityList = thisFactor.Qty.QuantityList;
                    // Because the calculated quantity value has changed, the factor qty must be replaced.
                    nextFactor.Qty = thisFactor.Qty.QuantityList.ReplaceIntegerQuantity(numberProduct);
                    this.RemoveAt(i);
                }
            }
            // combine inverses
            for (i = this.Count - 1; i > 0; --i)
            {
                CFactor thisFactor = this[i];
                if (thisFactor.Power != 0)
                {
                    CQuantity thisQuantity = thisFactor.Qty;
                    if (thisQuantity.InverseQty != null)
                    {
                        CQuantity inverseQty = thisQuantity.InverseQty;
                        int       intInverse = this.Find(inverseQty.Label);
                        if (intInverse > -1)
                        {
                            // n^x * 1/n^y = n^x/n^y = n^(x-y)
                            CFactor inverseFactor = this[intInverse];
                            thisFactor.Qty = inverseFactor.Qty;
                            inverseFactor.DivideLike(thisFactor);
                            this.RemoveAt(i);
                        }
                    }
                }
            }
            // drop factors that equal 1
            for (i = this.Count - 1; i > -1; --i)
            {
                CFactor thisFactor = this[i];
                // x^0 = 1 and log(1) = 0
                // n*1 = n
                if (thisFactor.Power == 0 || thisFactor.Log == 0)
                {
                    this.RemoveAt(i);
                }
            }
        }