// candidate has been calculated so replace the primary with the candidate. public void ApplyCandidateExpressionList() { _expressionList.Clear(); // Give the garbage collector a heads up. _expressionList = _candidateExpressionList; _candidateExpressionList = new CExpressionList(); GC.Collect(); }
// Construct a deep copy public CExpressionList(CExpressionList thatExpressionList) : base() { for (int i = 0; i < thatExpressionList.Count; ++i) { CExpression newExpression = new CExpression(thatExpressionList[i]); Add(newExpression); } }
// Construct shallow copy for purposes of display and printing public CExpressionList(CExpressionList thatExpressionList, bool bNotSense) : base() { for (int i = 0; i < thatExpressionList.Count; ++i) { CExpression thisExpression = thatExpressionList[i]; if (!bNotSense || !thisExpression.ContainsSense()) { Add(thisExpression); } } }
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; }
// Deep copy. Used in CQuantity::CalculateSubstitution and in deep copy constructors. public CQuantity(CQuantity thatQuantity) { Init(thatQuantity.QuantityList); _symbol = new CSymbol(thatQuantity._symbol); _number = new CNumber(thatQuantity._number); _uncertainty = new CNumber(thatQuantity._uncertainty); _lowfence = new CNumber(thatQuantity._lowfence); _highfence = new CNumber(thatQuantity._highfence); _intIndex = thatQuantity._intIndex; _inverseQty = thatQuantity.InverseQty; _expressionList = new CExpressionList(thatQuantity._expressionList); _isExact = thatQuantity._isExact; _isComputational = thatQuantity._isComputational; _isQED = thatQuantity._isQED; _isSuppressed = thatQuantity._isSuppressed; _isInteger = thatQuantity.IsInteger; }
public bool WriteExpressions(string strPath, string strLogPath) { bool bSuccess = true; StreamWriter swExpressions = null; string strLine; try { swExpressions = new StreamWriter(strPath); for (int i = 0; i < this.Count; ++i) { CQuantity thisQuantity = this[i].Qty; strLine = thisQuantity.SimpleLabel + "\t= "; CExpressionList thisExpressionList = thisQuantity.ExpressionList; thisExpressionList.SuppressDupes(); if (thisExpressionList.Count > 0) { strLine += thisExpressionList[0].ToString(); } swExpressions.WriteLine(strLine); for (int j = 1; j < thisExpressionList.Count; ++j) { strLine = "\t= " + thisExpressionList[j].ToString(); swExpressions.WriteLine(strLine); } } } catch (Exception e) { bSuccess = false; string strLogEntry = "\r\n Error writing expression file:" + e.Message; File.AppendAllText(strLogPath, strLogEntry); } finally { if (swExpressions != null) { swExpressions.Close(); } } return(bSuccess); }
// Substitute every term of each expression to form potential new expressions public void CalculateSubstitution(int intMaxFactors, bool bFirstPass) { int intLimit = _expressionList.Count; double dblLogThis = this.Log; CExpressionList thisExpressionList; // Integers are never substituted. if (!this._isInteger) { // On first pass initialize from the established expression list. // On subsequent passes build on previous candidate list. if (bFirstPass) { thisExpressionList = new CExpressionList(_expressionList); _candidateExpressionList = new CExpressionList(_expressionList); } else { thisExpressionList = new CExpressionList(_candidateExpressionList); } // Limit this to only the expressions that are already in the list. intLimit = thisExpressionList.Count; // for each expression in this quantity's expression list for (int i = 0; i < intLimit; ++i) { CExpression baseExpression = thisExpressionList[i]; CNumber baseNumber = new CNumber(baseExpression.Log, false); int intNumeratorLimit = baseExpression.Numerator.Count; int intDenominatorLimit = baseExpression.Denominator.Count; // for each factor in the numerator for (int intFactorIndex = 0; intFactorIndex < intNumeratorLimit; ++intFactorIndex) { CFactor baseFactor = baseExpression.Numerator[intFactorIndex]; CQuantity baseQuantity = new CQuantity(baseFactor.Qty); // Integers are never substituted. // Computational intermediates are never substituted. They are expanded on printout. if (!baseQuantity._isInteger /* && !baseQuantity._isComputational*/) { // for each expression associated with the numerator factor for (int k = 0; k < baseQuantity.ExpressionList.Count; ++k) { CExpression insertExpression = new CExpression(baseQuantity.ExpressionList[k]); if (!insertExpression.ContainsSymbol(this.Symbol)) { CExpression newExpression = new CExpression(baseExpression); newExpression.SubstituteIntoNumerator(intFactorIndex, insertExpression); CNumber newNumber = new CNumber(newExpression.Log, false); if (!baseNumber.IsEquivalent(newNumber)) { // !!! error double dblLogTest = newExpression.Log; // testing only } newExpression.Normalize(); if (newExpression.SymbolCount <= intMaxFactors) { _candidateExpressionList.Add(newExpression); } } } } } // for each factor in the denominator for (int intFactorIndex = 0; intFactorIndex < intDenominatorLimit; ++intFactorIndex) { CFactor baseFactor = baseExpression.Denominator[intFactorIndex]; CQuantity baseQuantity = new CQuantity(baseFactor.Qty); // Integers are never substituted. // Computational intermediates are never substituted. They are expanded on printout. if (!baseQuantity._isInteger /* && !baseQuantity._isComputational*/) { for (int k = 0; k < baseQuantity.ExpressionList.Count; ++k) { // for each expression associated with the denominator factor CExpression insertExpression = new CExpression(baseQuantity.ExpressionList[k]); if (!insertExpression.ContainsSymbol(this.Symbol)) { CExpression newExpression = new CExpression(baseExpression); newExpression.SubstituteIntoDenominator(intFactorIndex, insertExpression); CNumber newNumber = new CNumber(newExpression.Log, false); if (!baseNumber.IsEquivalent(newNumber)) { // !!! error double dblLogTest = newExpression.Log; // testing only } newExpression.Normalize(); if (newExpression.SymbolCount <= intMaxFactors) { _candidateExpressionList.Add(newExpression); } } } } } _candidateExpressionList.SuppressDupes(); _candidateExpressionList.SuppressTautology(this); } GC.Collect(); } }