/// <summary> /// Method to copy the data in this Sparse2DMatrix instance to another instance. /// </summary> /// <param name="sparse2DMatrix">An instance of the Sparse2DMatrix class.</param> public void CopyTo(Sparse2DMatrix <TKey0, TKey1, TValue> sparse2DMatrix) { sparse2DMatrix.m_dictionary.Clear(); // Copy each key value pair to the dictionary. foreach (KeyValuePair <ComparableTuple2 <TKey0, TKey1>, TValue> pair in m_dictionary) { ComparableTuple2 <TKey0, TKey1> newCombinedKey = new ComparableTuple2 <TKey0, TKey1>(pair.Key); sparse2DMatrix.m_dictionary.Add(newCombinedKey, pair.Value); } }
/// <summary> /// Method to copy the data in another Sparse2DMatrix instance to this instance. /// </summary> /// <param name="sparse2DMatrix">An instance of the Sparse2DMatrix class.</param> private void Initialize(Sparse2DMatrix <TKey0, TKey1, TValue> sparse2DMatrix) { m_dictionary.Clear(); // Copy each key value pair to the dictionary. foreach (KeyValuePair <ComparableTuple2 <TKey0, TKey1>, TValue> pair in sparse2DMatrix) { ComparableTuple2 <TKey0, TKey1> newCombinedKey = new ComparableTuple2 <TKey0, TKey1>(pair.Key); m_dictionary.Add(newCombinedKey, pair.Value); } }
public LinearEquationParserStatus Parse(string inputLine, Sparse2DMatrix <int, int, double> aMatrix, SparseArray <int, double> bVector, SparseArray <string, int> variableNameIndexMap, ref int numberOfEquations) { //------------------------------------------------------------------ // Trim any space characters from the end of the line. //------------------------------------------------------------------ inputLine.TrimEnd(null); //------------------------------------------------------------------ // Assume success status. //------------------------------------------------------------------ int positionIndex = 0; SetLastStatusValue(LinearEquationParserStatus.Success, positionIndex); //------------------------------------------------------------------ // Skip whitespace characters //------------------------------------------------------------------ SkipSpaces(inputLine, ref positionIndex); m_startPosition = positionIndex; bool operatorFoundLast = false; while (positionIndex < inputLine.Length) { if (m_parserState == LinearEquationParserState.ParseTerm) { //------------------------------------------------------ // Skip whitespace characters //------------------------------------------------------ SkipSpaces(inputLine, ref positionIndex); if (positionIndex < inputLine.Length) { if (GetTerm(inputLine, ref positionIndex, aMatrix, bVector, variableNameIndexMap)) { m_parserState = LinearEquationParserState.ParseOperator; operatorFoundLast = false; } else { if (LastStatusValue == LinearEquationParserStatus.Success) { SetLastStatusValue(LinearEquationParserStatus.ErrorIllegalEquation, positionIndex); } break; } } else { break; } } else if (m_parserState == LinearEquationParserState.ParseOperator) { //------------------------------------------------------ // Skip whitespace characters //------------------------------------------------------ SkipSpaces(inputLine, ref positionIndex); if (positionIndex < inputLine.Length) { //------------------------------------------------------ // Check for plus sign, minus sign, or an equal sign. //------------------------------------------------------ if (GetOperator(inputLine, ref positionIndex)) { m_parserState = LinearEquationParserState.ParseTerm; operatorFoundLast = true; } else { if (LastStatusValue != LinearEquationParserStatus.Success) { if (positionIndex == m_startPosition) { SetLastStatusValue(LinearEquationParserStatus.ErrorIllegalEquation, positionIndex); } } break; } } } } // If an operator was found at if ((positionIndex >= inputLine.Length) && (positionIndex > 0) && (!operatorFoundLast)) { ResetForNewEquation(); numberOfEquations = m_equationIndex; } return(LastStatusValue); }
/// <summary> /// Copy constructor. /// </summary> /// <param name="sparse2DMatrix">The sparse array instance to be copied</param> public Sparse2DMatrix(Sparse2DMatrix <TKey0, TKey1, TValue> sparse2DMatrix) { InitializeDictionary(); Initialize(sparse2DMatrix); DefaultValue = sparse2DMatrix.DefaultValue; }
private bool GetTerm(string inputLine, ref int positionIndex, Sparse2DMatrix <int, int, double> aMatrix, SparseArray <int, double> bVector, SparseArray <string, int> variableNameIndexMap) { bool numberIsNegativeFlag = false; GetSign(inputLine, ref positionIndex, ref numberIsNegativeFlag); //------------------------------------------------------------------ // Skip whitespace characters //------------------------------------------------------------------ SkipSpaces(inputLine, ref positionIndex); //------------------------------------------------------------------ // Check to see if this is a number or a variable. //------------------------------------------------------------------ string numberString = ""; bool haveNumberFlag = GetNumber(inputLine, ref positionIndex, ref numberString); //------------------------------------------------------------------ // If an error occurred then abort. //------------------------------------------------------------------ if (LastStatusValue != LinearEquationParserStatus.Success) { return(false); } //------------------------------------------------------------------ // If there was a number encountered then test to see if the // number has an exponent. //------------------------------------------------------------------ if (haveNumberFlag) { if (positionIndex < inputLine.Length) { //---------------------------------------------------------- // Does the number have an exponent? //---------------------------------------------------------- if (inputLine[positionIndex] == '^') { positionIndex++; //------------------------------------------------------ // Does the exponent have a sign. //------------------------------------------------------ bool negativeExponentFlag = false; GetSign(inputLine, ref positionIndex, ref negativeExponentFlag); //------------------------------------------------------ // Get the exponent digits. //------------------------------------------------------ string exponentString = ""; if (GetNumber(inputLine, ref positionIndex, ref exponentString)) { //-------------------------------------------------- // Is the exponent a valid exponent. //-------------------------------------------------- int exponentLength = exponentString.Length; if (exponentLength <= 2) { bool exponent_error_flag = false; for (int i = 0; i < exponentLength; ++i) { if (!Char.IsDigit(exponentString[i])) { exponent_error_flag = true; } } if (!exponent_error_flag) { numberString += 'E'; if (negativeExponentFlag) { numberString += '-'; } numberString += exponentString; } else { SetLastStatusValue(LinearEquationParserStatus.ErrorIllegalExponent, positionIndex); return(false); } } else { SetLastStatusValue(LinearEquationParserStatus.ErrorIllegalExponent, positionIndex); return(false); } } else { SetLastStatusValue(LinearEquationParserStatus.ErrorMissingExponent, positionIndex); return(false); } } } } //------------------------------------------------------------------ // Skip whitespace characters //------------------------------------------------------------------ SkipSpaces(inputLine, ref positionIndex); string variableName = ""; bool haveVariableNameFlag = GetVariableName(inputLine, ref positionIndex, ref variableName); //------------------------------------------------------------------ // Calculate the sign of the value. The sign is negated // if the equals sign has been encountered. //------------------------------------------------------------------ bool negativeFlag = m_equalSignInEquationFlag ^ m_negativeOperatorFlag ^ numberIsNegativeFlag; double value = 0.0; if (haveNumberFlag) { value = Convert.ToDouble(numberString); if (negativeFlag) { value = -value; } } else { value = 1.0; if (negativeFlag) { value = -value; } } //------------------------------------------------------------------ // If a variable was encountered then add to the aMatrix. //------------------------------------------------------------------ bool haveTermFlag = false; if (haveVariableNameFlag) { //-------------------------------------------------------------- // If either a number or a variable is found then a term was // found. //-------------------------------------------------------------- haveTermFlag = true; //-------------------------------------------------------------- // Each equation must have at least one variable. // Record that a variable was encountered in this equation. //-------------------------------------------------------------- m_atLeastOneVariableInEquationFlag = true; //-------------------------------------------------------------- // If this variable has not been encountered before then add // the variable to the variableNameIndexMap. //-------------------------------------------------------------- int variableNameIndex = 0; if (!variableNameIndexMap.TryGetValue(variableName, out variableNameIndex)) { // This is a new variable. Add it to the map. variableNameIndex = variableNameIndexMap.Count; variableNameIndexMap[variableName] = variableNameIndex; } aMatrix[m_equationIndex, variableNameIndex] = aMatrix[m_equationIndex, variableNameIndex] + value; } else if (haveNumberFlag) { //-------------------------------------------------------------- // If either a number or a variable is found then a term was // found. //-------------------------------------------------------------- haveTermFlag = true; //-------------------------------------------------------------- // Put the value in the B vector. //-------------------------------------------------------------- bVector[m_equationIndex] = bVector[m_equationIndex] - value; } else { haveTermFlag = false; SetLastStatusValue(LinearEquationParserStatus.ErrorNoTermEncountered, positionIndex); return(false); } //------------------------------------------------------------------ // There must be at least one term on each side of the equal sign. //------------------------------------------------------------------ if (haveTermFlag) { if (m_equalSignInEquationFlag) { m_termAfterEqualSignExistsFlag = true; } else { m_termBeforeEqualSignExistsFlag = true; } } //------------------------------------------------------------------ // Skip whitespace characters //------------------------------------------------------------------ SkipSpaces(inputLine, ref positionIndex); return(haveTermFlag); }