public void ParseMethod_NullString_ThrowNullArgumentException()
{
Should.Throw <ArgumentNullException>(() =>
{
var parseResult = PolynomialParser.Parse(null);
});
}
public void ParseMethod_OnlyWhiteSpaceString_ThrowNullArgumentException()
{
Should.Throw <NotValidPolynomialArgumentException>(() =>
{
var parseResult = PolynomialParser.Parse(" ");
});
}
public void ParseMethod_ValidInitialString_NotValidEquationArgumentException(
string initialPolymial, string expectedPolymial)
{
var polymial = PolynomialParser.Parse(initialPolymial);
polymial.ToString().ShouldBe(expectedPolymial);
}
public void Test_Valid(string input, string expected)
{
Polynomial actualPolynomial = PolynomialParser.TryParse(input);
string actual = actualPolynomial.ToString();
Assert.Equal(expected, actual);
}
public void Setup()
{
_parser =
new PolynomialParser(
new SummandParser(
new VariablesParser()));
}
public void Setup()
{
expressionConverter = new ExpressionConverter();
tokenizer = new Tokenizer();
parser = new PolynomialParser(tokenizer);
sorter = new Sorter <PolynomialNode <double> >();
}
/// <summary>
/// подставляет polynomial вместо x и получает полином
/// </summary>
/// <param name="polynomial"></param>
/// <returns></returns>
public Polynomial Eval(Polynomial polynomial)
{
string poly = "";
foreach (int deg in this.coeff.Keys)
{
poly = poly + "+" + (this[deg] * (polynomial ^ deg)).ToString();
}
return(new Polynomial(PolynomialParser.Parse(poly)));
}
/// <summary>
/// If <paramref name="poly"/> is a correct representaion of a polynomial (i.e. a sum of monomials of the form either a, ax or ax^b for some integers a and b.),
/// constructs the corresponding polynomial. Otherwise the polynomial is initialized as 0.
/// </summary>
/// <param name="poly">string representation of a polynomial</param>
public Polynomial(string poly)
{
try
{
coeff = PolynomialParser.Parse(poly);
}
catch (InvalidPolynomialStringException)
{
coeff.Add(0, 0);
}
Deg = this.coeff.Keys[this.coeff.Keys.Count - 1];
}
/// <summary>
/// Input: a and b ≠ 0 two polynomials in the variable x;
/// Output: q, the quotient, and r, the remainder;
/// </summary>
/// <param name="p1"></param>
/// <param name="p2"></param>
/// <returns></returns>
//https://en.wikipedia.org/wiki/Polynomial_greatest_common_divisor#GCD_over_a_ring_and_its_field_of_fractions
public static Polynomial operator %(Polynomial p1, Polynomial p2)
{
Polynomial q = 0;
Polynomial r = p1;
double d = p2.Deg;
double c = p2[p2.Deg];
while (r.Deg >= d)
{
Polynomial s = (r[r.Deg] / c) * new Polynomial(PolynomialParser.Parse("x^" + (r.Deg - d).ToString()));
q = new Polynomial(q + s);
r = new Polynomial(r - s * p2);
}
return(new Polynomial(r));
}
public void Parse_ValidParse_EqualsExpected <TSet, TStruct, TParser> (
TSet hack1,
TStruct hack2,
TParser hack3,
PolynomialParser <TSet, TStruct, TParser> parser,
String stringInput,
Polynomial <TSet, TStruct> expected)
where TStruct : IStructure, new()
where TParser : IParser <TSet>, new()
{
var result = parser.Parse(stringInput);
Assert.IsNotNull(result);
Assert.AreEqual(expected, result);
}
public Evaluator(string polynomial)
{
if (string.IsNullOrWhiteSpace(polynomial))
{
throw new ArgumentException($"{nameof(polynomial)} cannot be null or empty");
}
if (polynomial.StartsWith('-'))
{
polynomial = "0" + polynomial;
}
var inputStream = new AntlrInputStream(polynomial);
var lexer = new PolynomialLexer(inputStream);
var commonTokenStream = new CommonTokenStream(lexer);
var parser = new PolynomialParser(commonTokenStream);
var context = parser.expr();
var visitor = new VisitorImpl();
_expr = visitor.Visit(context);
}
public void TestComplicatedParseSqrt2()
{
string somePolynomial = "(x*x + sqrt2*x + 1)*(x*x - sqrt2*x + 1)";
SlowOperatorBasedField<double> rationalField = new SlowOperatorBasedField<double>();
PolynomialOverFieldRing<double> rationalPolynomialRing = new PolynomialOverFieldRing<double>(rationalField);
IRing<Polynomial<double>> rationalWithSqrt2Ring =
new QuotientRing<Polynomial<double>>
(new PrincipalIdeal<Polynomial<double>>
(rationalPolynomialRing,
new Polynomial<double>(new double[] {-2, 0, 1}, rationalField)));
var sqrt2 = rationalField.CreateMonomial(1, 1);
PolynomialParser parser = new PolynomialParser
(new PolynomialParserOptions()
{
Aliases = new Dictionary<string, object>()
{
{"sqrt2", sqrt2}
}
});
Polynomial<Polynomial<double>> parsed =
parser.Parse(somePolynomial, rationalWithSqrt2Ring);
PolynomialRing<Polynomial<double>> complexPolynomialRing =
new PolynomialRing<Polynomial<double>>(rationalWithSqrt2Ring);
Polynomial<Polynomial<double>> expectedResult =
complexPolynomialRing.Add(
rationalWithSqrt2Ring.CreateMonomial(rationalWithSqrt2Ring.Identity, 4),
complexPolynomialRing.Identity);
Assert.IsTrue(complexPolynomialRing.Comparer.Equals(parsed, expectedResult));
}
private static (IParseTree tree, string parseErrorMessage) TryParseExpression(string expression)
{
ICharStream stream = CharStreams.fromstring(expression);
PolynomialLexer lexer = new PolynomialLexer(stream);
ITokenStream tokens = new CommonTokenStream(lexer);
PolynomialParser parser = new PolynomialParser(tokens)
{
BuildParseTree = true
};
parser.RemoveErrorListeners();
parser.AddErrorListener(new PolynomialErrorListener());
try
{
var tree = parser.parse();
return(tree, string.Empty);
}
catch (ParseCanceledException pce)
{
return(null, pce.Message);
}
}
/// <summary>
/// Input: a and b ≠ 0 two polynomials in the variable x;
/// Output: q, the quotient, and r, the remainder;
/// </summary>
/// <param name="p1"></param>
/// <param name="p2"></param>
/// <returns></returns>
public static Polynomial operator /(Polynomial p1, Polynomial p2)
{
if (p1.Deg == 1 && p2.Deg == 1)
{
return(p1[1] / p2[1]);
}
if (p2 == 0)
{
throw new DivideByZeroException();
}
Polynomial q = 0;
Polynomial r = p1;
double d = p2.Deg;
double c = p2[p2.Deg];
while (r.Deg >= d)
{
Polynomial s = (r[r.Deg] / c) * new Polynomial(PolynomialParser.Parse("x^" + (r.Deg - d).ToString()));
q = new Polynomial(q + s);
r = new Polynomial(r - s * p2);
}
return(new Polynomial(q));
}
public void Test_ExponentSyntaxException(string input, string expectedError)
{
Exception ex = Assert.Throws <ExponentSyntaxException>(() => PolynomialParser.TryParse(input));
Assert.Equal(expectedError, ex.Message);
}
public void TestParse()
{
string somePolynomial = "(x*x + 1)*(x*x - 1)";
PolynomialParser parser = new PolynomialParser();
IRing<double> ring = new SlowOperatorBasedRing<double>();
Polynomial<double> parsed =
parser.Parse(somePolynomial, ring);
PolynomialRing<double> polynomialRing = new PolynomialRing<double>(ring);
Assert.IsTrue(polynomialRing.Comparer.Equals(parsed,
new Polynomial<double>(new double[] {-1, 0, 0, 0, 1}, ring)));
}
public EquationParser(PolynomialParser polynomialParser)
{
_polynomialParser = polynomialParser;
}
public void Teardown()
{
expressionConverter = null;
tokenizer = null;
parser = null;
}
public void Setup()
{
expressionConverter = new ExpressionConverter();
tokenizer = new Tokenizer();
parser = new PolynomialParser(tokenizer);
}
public IComputerAlgebraType ParseExpression(string expr)
{
return(new Polynomial(PolynomialParser.Parse(expr)));
}
/// <summary>
/// вычисляет выражение, записанное в RPN(обратная польская запись)
/// </summary>
/// <param name="expression"></param>
/// <returns></returns>
public string RPNToAnswer(string expression)
{
var text = ExpressionToRPN(expression, out var tokensList);
var tokens = tokensList.ToArray();
var stack = new Stack <Token>();
Token leftOp, rightOp;
Polynomial result;
for (int i = 0; i < tokens.Length; i++)
{
switch (tokens[i].Type)
{
case TokenType.Polynomial:
stack.Push(tokens[i]);
break;
case TokenType.Variable:
if (PolyVars.ContainsKey(tokens[i].Value.ToString()))
{
stack.Push(new Token(TokenType.Polynomial, PolyVars[tokens[i].Value].ToString()));
}
else
{
stack.Push(tokens[i]);
}
break;
case TokenType.Function:
if (Function.GetFunctions()[tokens[i].Value].Type == FunctionType.Unary)
{
try
{
leftOp = stack.Pop();
}
catch (System.InvalidOperationException)
{
SyntaxException syntaxException = new SyntaxException("Не удалось определить функцию");
leftOp = new Token(TokenType.Exeption, syntaxException.Message);
}
result = Function.GetFunctions()[tokens[i].Value].UFunction
(
new Polynomial(PolynomialParser.Parse(leftOp.Value))
);
stack.Push(new Token(TokenType.Polynomial, result.ToString()));
}
else
{
try
{
rightOp = stack.Pop();
leftOp = stack.Pop();
}
catch (System.InvalidOperationException)
{
SyntaxException syntaxException = new SyntaxException("Не удалось применить функцию к операнду(ам)");
rightOp = new Token(TokenType.Exeption, syntaxException.Message);
leftOp = new Token(TokenType.Exeption, syntaxException.Message);
}
result = Function.GetFunctions()[tokens[i].Value].BiFunction
(
new Polynomial(PolynomialParser.Parse(leftOp.Value)),
new Polynomial(PolynomialParser.Parse(rightOp.Value))
);
stack.Push(new Token(TokenType.Polynomial, result.ToString()));
}
break;
case TokenType.Operator:
try
{
rightOp = stack.Pop();
//leftOp = stack.Pop();
}
catch (System.InvalidOperationException)
{
SyntaxException syntaxException = new SyntaxException("Не удалось применить оператор к операнду(ам)");
rightOp = new Token(TokenType.Polynomial, "0");
//leftOp = new Token(TokenType.Exeption, syntaxException.Message);
}
try
{
//rightOp = stack.Pop();
leftOp = stack.Pop();
}
catch (System.InvalidOperationException)
{
SyntaxException syntaxException = new SyntaxException("Не удалось применить оператор к операнду(ам)");
//rightOp = new Token(TokenType.Exeption, syntaxException.Message);
leftOp = new Token(TokenType.Polynomial, "0");
}
if (Operator.GetOperators()[tokens[i].Value].Type == OperatorType.Binary)
{
try
{
result = Operator.GetOperators()[tokens[i].Value].biOperator
(
new Polynomial(PolynomialParser.Parse(leftOp.Value)),
new Polynomial(PolynomialParser.Parse(rightOp.Value))
);
stack.Push(new Token(TokenType.Polynomial, result.ToString()));
}
catch (InvalidPolynomialStringException exception)
{
stack.Push(new Token(TokenType.Exeption, exception.Message));
}
}
else //TODO подумать как детальнее реализовать взаимодействие с логическими операциями
{
result = Convert.ToDouble(Operator.GetOperators()[tokens[i].Value].biBoolOperator
(
new Polynomial(PolynomialParser.Parse(leftOp.Value)),
new Polynomial(PolynomialParser.Parse(rightOp.Value))
));
stack.Push(new Token(TokenType.Polynomial, result.ToString()));
}
break;
default:
throw new Exception("Wrong token");
}
}
try
{
text = stack.Pop().Value;
}
catch (System.InvalidOperationException)
{
text = "";
}
return(text);
}
