/// <summary>
/// Tenta ler o vector a partir de um leitor de símbolos.
/// </summary>
/// <param name="reader">O leitor de símbolos.</param>
/// <param name="parser">O interpretador do vector.</param>
/// <param name="vector">Estabelece vector lido.</param>
/// <returns>Verdadeiro caso a operação seja bem sucedida e falso caso contrário.</returns>
public bool TryParseVector(
MementoSymbolReader <InputReader, SymbValue, SymbType> reader,
IParse <T, SymbValue, SymbType> parser,
out IMathVector <T> vector)
{
return(this.TryParseVector(reader, parser, null, out vector));
}
/// <summary>
/// Efectua a leitura de um polinómio.
/// </summary>
/// <param name="polynomialReader">A cadeia de carácteres que contém o polinómimo.</param>
/// <param name="resultPolynomial">O polinómio lido.</param>
/// <param name="conversion">O conversor entre o tipo de coeficiente e um inteiro.</param>
/// <returns>Verdadeiro caso a leitura seja bem sucedida e falso caso contrário.</returns>
public bool TryParsePolynomial(
MementoSymbolReader <InputReader, string, string> polynomialReader,
IConversion <int, T> conversion,
out Polynomial <T> resultPolynomial)
{
return(this.TryParsePolynomial(polynomialReader, conversion, null, out resultPolynomial));
}
/// <summary>
/// Tenta ler o vector a partir de um leitor de símbolos.
/// </summary>
/// <param name="reader">O leitor de símbolos.</param>
/// <param name="parser">O interpretador do vector.</param>
/// <param name="errors">A lista de erros.</param>
/// <param name="vector">Estabelece o vector lido.</param>
/// <returns>Verdadeiro caso a operação seja bem sucedida e falso caso contrário.</returns>
public bool TryParseVector(
MementoSymbolReader <InputReader, SymbValue, SymbType> reader,
IParse <T, SymbValue, SymbType> parser,
List <string> errors,
out IMathVector <T> vector)
{
vector = default(IMathVector <T>);
this.rangeReader.ReadRangeValues(reader, parser);
if (this.rangeReader.HasErrors)
{
if (errors != null)
{
foreach (var message in this.rangeReader.ErrorMessages)
{
errors.Add(message);
}
}
return(false);
}
else
{
var lines = -1;
var configurationEnumerator = this.rangeReader.Configuration.GetEnumerator();
if (configurationEnumerator.MoveNext())
{
lines = configurationEnumerator.Current;
if (configurationEnumerator.MoveNext())
{
lines = configurationEnumerator.Current;
}
}
vector = this.vectorFactory.CreateVector(lines);
this.SetupResultVector(vector, lines, this.rangeReader.Elements);
return(true);
}
}
/// <summary>
/// Tenta fazer a leitura da expressão.
/// </summary>
/// <param name="reader">O leitor de símbolos.</param>
/// <param name="errors">A lista que irá receber os erros.</param>
/// <param name="element">O elemento lido.</param>
/// <returns>Verdadeiro caso a leitura seja bem-sucedida e falso caso contrário.</returns>
public bool TryParsePolynomial(
MementoSymbolReader <InputReader, string, string> reader,
ILogStatus <string, EParseErrorLevel> errors,
out ObjectType element)
{
if (reader == null)
{
throw new ArgumentNullException("reader");
}
else
{
var expressionReader = new ExpressionReader <ObjectType, string, string>(
this.objectParser);
expressionReader.RegisterBinaryOperator("plus", Add, 0);
expressionReader.RegisterBinaryOperator("times", Multiply, 1);
expressionReader.RegisterBinaryOperator("minus", Subtract, 0);
expressionReader.RegisterBinaryOperator("hat", Power, 2);
expressionReader.RegisterUnaryOperator("minus", Symmetric, 0);
expressionReader.RegisterBinaryOperator("over", Divide, 1);
if (this.expressionDelimiterTypes.Any())
{
foreach (var expressionDelimiterKvp in this.expressionDelimiterTypes)
{
foreach (var closeDelimiter in expressionDelimiterKvp.Value)
{
expressionReader.RegisterExpressionDelimiterTypes(
expressionDelimiterKvp.Key,
closeDelimiter);
}
}
}
else
{
expressionReader.RegisterExpressionDelimiterTypes("left_parenthesis", "right_parenthesis");
}
expressionReader.RegisterSequenceDelimiterTypes("left_parenthesis", "right_parenthesis");
foreach (var kvp in this.externalDelimitersTypes)
{
foreach (var delimiter in kvp.Value)
{
expressionReader.RegisterExternalDelimiterTypes(kvp.Key, delimiter);
}
}
expressionReader.AddVoid("blancks");
expressionReader.AddVoid("space");
expressionReader.AddVoid("carriage_return");
expressionReader.AddVoid("new_line");
var innerErrors = new LogStatus <string, EParseErrorLevel>();
element = expressionReader.Parse(reader, innerErrors);
foreach (var kvp in innerErrors.GetLogs())
{
errors.AddLog(kvp.Value, kvp.Key);
}
if (innerErrors.HasLogs(EParseErrorLevel.ERROR))
{
return(false);
}
else
{
return(true);
}
}
}
/// <summary>
/// Tenta fazer a leitura da expressão.
/// </summary>
/// <param name="reader">O leitor de símbolos.</param>
/// <param name="element">O valor lido.</param>
/// <returns>Verdadeiro caso a leitura seja bem-sucedida e falso caso contrário.</returns>
public bool TryParsePolynomial(
MementoSymbolReader <InputReader, string, string> reader,
out ObjectType element)
{
return(this.TryParsePolynomial(reader, null, out element));
}
/// <summary>
/// Efectua a leitura de um polinómio.
/// </summary>
/// <param name="polynomialReader">A cadeia de carácteres que contém o polinómimo.</param>
/// <param name="conversion">O conversor entre o tipo de coeficiente e um inteiro.</param>
/// <param name="errors">A lista de errros encontrados.</param>
/// <param name="resultPolynomial">O polinómio lido.</param>
/// <returns>Verdadeiro caso a leitura seja bem sucedida e falso caso contrário.</returns>
/// <exception cref="ArgumentNullException">Se o leitor de símbolos ou conversor forem nulos.</exception>
public bool TryParsePolynomial(
MementoSymbolReader <InputReader, string, string> polynomialReader,
IConversion <int, T> conversion,
ILogStatus <string, EParseErrorLevel> errors,
out Polynomial <T> resultPolynomial)
{
if (polynomialReader == null)
{
throw new ArgumentNullException("polynomialReader");
}
if (conversion == null)
{
throw new ArgumentNullException("conversion");
}
this.conversion = conversion;
resultPolynomial = default(Polynomial <T>);
var expressionReader = new ExpressionReader <ParsePolynomialItem <T>, string, string>(
new SimplePolynomialReader <T>(this.coeffParser, this.ring));
expressionReader.RegisterBinaryOperator("plus", Add, 0);
expressionReader.RegisterBinaryOperator("times", Multiply, 1);
expressionReader.RegisterBinaryOperator("minus", Subtract, 0);
expressionReader.RegisterBinaryOperator("hat", Power, 2);
expressionReader.RegisterUnaryOperator("minus", Symmetric, 0);
expressionReader.RegisterExpressionDelimiterTypes("left_parenthesis", "right_parenthesis");
expressionReader.RegisterSequenceDelimiterTypes("left_parenthesis", "right_parenthesis");
foreach (var kvp in this.externalDelimitersTypes)
{
foreach (var delimiter in kvp.Value)
{
expressionReader.RegisterExternalDelimiterTypes(kvp.Key, delimiter);
}
}
expressionReader.AddVoid("space");
expressionReader.AddVoid("carriage_return");
expressionReader.AddVoid("new_line");
var innerErrors = new LogStatus <string, EParseErrorLevel>();
var expressionResult = expressionReader.Parse(polynomialReader, innerErrors);
if (innerErrors.HasLogs(EParseErrorLevel.ERROR))
{
if (errors != null)
{
foreach (var message in innerErrors.GetLogs(EParseErrorLevel.ERROR))
{
errors.AddLog(message, EParseErrorLevel.ERROR);
}
}
return(false);
}
else
{
if (expressionResult.ValueType == EParsePolynomialValueType.COEFFICIENT)
{
resultPolynomial = new Polynomial <T>(expressionResult.Coeff, this.ring);
return(true);
}
else if (expressionResult.ValueType == EParsePolynomialValueType.INTEGER)
{
if (typeof(T).IsAssignableFrom(typeof(int)))
{
resultPolynomial = new Polynomial <T>((T)(object)expressionResult.Degree, this.ring);
return(true);
}
else
{
return(false);
}
}
else if (expressionResult.ValueType == EParsePolynomialValueType.POLYNOMIAL)
{
resultPolynomial = expressionResult.Polynomial;
return(true);
}
else
{
if (errors != null)
{
errors.AddLog("Severe error.", EParseErrorLevel.ERROR);
}
return(false);
}
}
}
