/// <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);
}
