Skip to content

Place set union and minus at same precedence, place xor above or in precedence, fix chained comparison parsing #658

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
Happypig375 merged 2 commits into from
Jan 21, 2026
Merged

Place set union and minus at same precedence, place xor above or in precedence, fix chained comparison parsing #658

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
15032e5
Place set union and minus at same precedence, place xor above or in p…
Happypig375 Jan 21, 2026
2741c6d
Add <> tests
Happypig375 Jan 21, 2026
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
2 changes: 1 addition & 1 deletion Sources/AngouriMath/Convenience/MathS.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -2380,7 +2380,7 @@ public static IEnumerable<Entity> TaylorTerms(Entity expr, params (Variable expr
/// Unhandled exception. AngouriMath.Core.Exceptions.CannotEvalException
/// </code>
/// </example>
public static Entity Equality(Entity a, Entity b) => a.Equalizes(b);
public static Entity Equality(Entity a, Entity b) => a.EqualTo(b);

/// <param name="a">Left argument node of which the greater than node will be taken</param>
/// <param name="b">Right argument node of which the greater than node function will be taken</param>
Expand Down
90 changes: 45 additions & 45 deletions Sources/AngouriMath/Core/Antlr/AngouriMath.g
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -114,31 +114,23 @@ Sets

set_operator_intersection returns[Entity value]
: left = sum_expression { $value = $left.value; }
(
'intersect' right = sum_expression { $value = $value.Intersect($right.value); } |
'/\\' right = sum_expression { $value = $value.Intersect($right.value); }
( 'intersect' right = sum_expression { $value = $value.Intersect($right.value); }
| '/\\' right = sum_expression { $value = $value.Intersect($right.value); }
)*
;

set_operator_union returns[Entity value]
set_operator_union_setsubtraction returns[Entity value]
: left = set_operator_intersection { $value = $left.value; }
(
'unite' right = set_operator_intersection { $value = $value.Unite($right.value); } |
'\\/' right = set_operator_intersection { $value = $value.Unite($right.value); }
)*
;

set_operator_setsubtraction returns[Entity value]
: left = set_operator_union { $value = $left.value; }
(
'setsubtract' right = set_operator_union { $value = $value.SetSubtract($right.value); } |
'\\' right = set_operator_union { $value = $value.SetSubtract($right.value); }
( 'unite' right = set_operator_intersection { $value = $value.Unite($right.value); }
| '\\/' right = set_operator_intersection { $value = $value.Unite($right.value); }
| 'setsubtract' right = set_operator_intersection { $value = $value.SetSubtract($right.value); }
| '\\' right = set_operator_intersection { $value = $value.SetSubtract($right.value); }
)*
;

in_operator returns[Entity value]
: m1 = set_operator_setsubtraction { $value = $m1.value; }
('in' m2 = set_operator_setsubtraction { $value = $value.In($m2.value); })*
: m1 = set_operator_union_setsubtraction { $value = $m1.value; }
('in' m2 = set_operator_union_setsubtraction { $value = $value.In($m2.value); })*
;


Expand All @@ -148,42 +140,50 @@ Equality/inequality nodes

*/

inequality_expression returns[Entity value]
: m1 = in_operator { $value = $m1.value; }
comparison_expression returns[Entity value]
@init { List<Entity> terms = []; List<string> operators = []; }
: m1 = in_operator { terms.Add($m1.value); }
(
'>=' m2 = in_operator { $value = $value >= $m2.value; } |
'<=' m2 = in_operator { $value = $value <= $m2.value; } |
'>' m2 = in_operator { $value = $value > $m2.value; } |
'<' m2 = in_operator { $value = $value < $m2.value; } |
'equalizes' m2 = in_operator { $value = MathS.Equality($value, $m2.value); })*
('>=' { operators.Add(">="); } |
'<=' { operators.Add("<="); } |
'>' { operators.Add(">"); } |
'<' { operators.Add("<"); } |
'=' { operators.Add("="); } |
'<>' { operators.Add("<>"); })
m2 = in_operator { terms.Add($m2.value); }
)*
{
if (terms.Count == 1)
$value = terms[0];
else
// Create chain: a < b = c < d becomes (a < b) and (b = c) and (c < d)
for (int i = 0; i < operators.Count; i++)
{
var connective = operators[i] switch
{ // Directly construct the nodes instead of using convenience methods to avoid built-in chained comparisons
">=" => new GreaterOrEqualf(terms[i], terms[i + 1]),
"<=" => new LessOrEqualf(terms[i], terms[i + 1]),
">" => new Greaterf(terms[i], terms[i + 1]),
"<" => new Lessf(terms[i], terms[i + 1]),
"=" => new Equalsf(terms[i], terms[i + 1]),
"<>" => !new Equalsf(terms[i], terms[i + 1]),
_ => throw new AngouriBugException($"Unknown operator in chained comparison: {operators[i]}")
};
if (i == 0) $value = connective; else $value &= connective;
}
}
;

terms_list returns[List<Entity> terms]
@init { $terms = new(); }
: ('=' term = inequality_expression { $terms.Add($term.value); })+
;

equality_expression returns[Entity value]
: expr = inequality_expression { $value = $expr.value; } (terms_list
{
var list = $terms_list.terms.Prepend($value).ToArray();
List<Entity> eqTerms = new();
for (int i = 0; i < list.Length - 1; i++)
eqTerms.Add(list[i].Equalizes(list[i + 1]));
$value = eqTerms.Aggregate((eq1, eq2) => eq1 & eq2);
})?
;

/*

Boolean nodes

*/

negate_expression returns[Entity value]
: 'not' op = equality_expression { $value = !$op.value; }
: 'not' op = comparison_expression { $value = !$op.value; }
| 'not' opn = negate_expression { $value = !$opn.value; }
| op = equality_expression { $value = $op.value; }
| op = comparison_expression { $value = $op.value; }
;

and_expression returns[Entity value]
Expand All @@ -200,8 +200,8 @@ xor_expression returns[Entity value]

or_expression returns[Entity value]
: m1 = xor_expression { $value = $m1.value; }
('or' m2 = xor_expression { $value = $value | $m2.value; } |
'|' m2 = xor_expression { $value = $value | $m2.value; })*
( 'or' m2 = xor_expression { $value = $value | $m2.value; }
| '|' m2 = xor_expression { $value = $value | $m2.value; })*
;

implies_expression returns[Entity value]
Expand All @@ -218,7 +218,7 @@ Keyword nodes

provided_expression returns[Entity value]
: expr = implies_expression { $value = $expr.value; }
('provided' pred = implies_expression { $value = $value.Provided($pred.value); })*
('provided' pred = provided_expression { $value = $value.Provided($pred.value); })?
;

/*
Expand Down
11 changes: 4 additions & 7 deletions Sources/AngouriMath/Core/Antlr/AngouriMath.interp
View file
Open in desktop

Large diffs are not rendered by default.

4 changes: 2 additions & 2 deletions Sources/AngouriMath/Core/Antlr/AngouriMath.tokens
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -142,8 +142,8 @@ WS=127
'<='=15
'>'=16
'<'=17
'equalizes'=18
'='=19
'='=18
'<>'=19
'not'=20
'and'=21
'&'=22
Expand Down
52 changes: 8 additions & 44 deletions Sources/AngouriMath/Core/Antlr/AngouriMathBaseListener.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -121,29 +121,17 @@ public virtual void EnterSet_operator_intersection([NotNull] AngouriMathParser.S
/// <param name="context">The parse tree.</param>
public virtual void ExitSet_operator_intersection([NotNull] AngouriMathParser.Set_operator_intersectionContext context) { }
/// <summary>
/// Enter a parse tree produced by <see cref="AngouriMathParser.set_operator_union"/>.
/// Enter a parse tree produced by <see cref="AngouriMathParser.set_operator_union_setsubtraction"/>.
/// <para>The default implementation does nothing.</para>
/// </summary>
/// <param name="context">The parse tree.</param>
public virtual void EnterSet_operator_union([NotNull] AngouriMathParser.Set_operator_unionContext context) { }
public virtual void EnterSet_operator_union_setsubtraction([NotNull] AngouriMathParser.Set_operator_union_setsubtractionContext context) { }
/// <summary>
/// Exit a parse tree produced by <see cref="AngouriMathParser.set_operator_union"/>.
/// Exit a parse tree produced by <see cref="AngouriMathParser.set_operator_union_setsubtraction"/>.
/// <para>The default implementation does nothing.</para>
/// </summary>
/// <param name="context">The parse tree.</param>
public virtual void ExitSet_operator_union([NotNull] AngouriMathParser.Set_operator_unionContext context) { }
/// <summary>
/// Enter a parse tree produced by <see cref="AngouriMathParser.set_operator_setsubtraction"/>.
/// <para>The default implementation does nothing.</para>
/// </summary>
/// <param name="context">The parse tree.</param>
public virtual void EnterSet_operator_setsubtraction([NotNull] AngouriMathParser.Set_operator_setsubtractionContext context) { }
/// <summary>
/// Exit a parse tree produced by <see cref="AngouriMathParser.set_operator_setsubtraction"/>.
/// <para>The default implementation does nothing.</para>
/// </summary>
/// <param name="context">The parse tree.</param>
public virtual void ExitSet_operator_setsubtraction([NotNull] AngouriMathParser.Set_operator_setsubtractionContext context) { }
public virtual void ExitSet_operator_union_setsubtraction([NotNull] AngouriMathParser.Set_operator_union_setsubtractionContext context) { }
/// <summary>
/// Enter a parse tree produced by <see cref="AngouriMathParser.in_operator"/>.
/// <para>The default implementation does nothing.</para>
Expand All @@ -157,41 +145,17 @@ public virtual void EnterIn_operator([NotNull] AngouriMathParser.In_operatorCont
/// <param name="context">The parse tree.</param>
public virtual void ExitIn_operator([NotNull] AngouriMathParser.In_operatorContext context) { }
/// <summary>
/// Enter a parse tree produced by <see cref="AngouriMathParser.inequality_expression"/>.
/// <para>The default implementation does nothing.</para>
/// </summary>
/// <param name="context">The parse tree.</param>
public virtual void EnterInequality_expression([NotNull] AngouriMathParser.Inequality_expressionContext context) { }
/// <summary>
/// Exit a parse tree produced by <see cref="AngouriMathParser.inequality_expression"/>.
/// <para>The default implementation does nothing.</para>
/// </summary>
/// <param name="context">The parse tree.</param>
public virtual void ExitInequality_expression([NotNull] AngouriMathParser.Inequality_expressionContext context) { }
/// <summary>
/// Enter a parse tree produced by <see cref="AngouriMathParser.terms_list"/>.
/// <para>The default implementation does nothing.</para>
/// </summary>
/// <param name="context">The parse tree.</param>
public virtual void EnterTerms_list([NotNull] AngouriMathParser.Terms_listContext context) { }
/// <summary>
/// Exit a parse tree produced by <see cref="AngouriMathParser.terms_list"/>.
/// <para>The default implementation does nothing.</para>
/// </summary>
/// <param name="context">The parse tree.</param>
public virtual void ExitTerms_list([NotNull] AngouriMathParser.Terms_listContext context) { }
/// <summary>
/// Enter a parse tree produced by <see cref="AngouriMathParser.equality_expression"/>.
/// Enter a parse tree produced by <see cref="AngouriMathParser.comparison_expression"/>.
/// <para>The default implementation does nothing.</para>
/// </summary>
/// <param name="context">The parse tree.</param>
public virtual void EnterEquality_expression([NotNull] AngouriMathParser.Equality_expressionContext context) { }
public virtual void EnterComparison_expression([NotNull] AngouriMathParser.Comparison_expressionContext context) { }
/// <summary>
/// Exit a parse tree produced by <see cref="AngouriMathParser.equality_expression"/>.
/// Exit a parse tree produced by <see cref="AngouriMathParser.comparison_expression"/>.
/// <para>The default implementation does nothing.</para>
/// </summary>
/// <param name="context">The parse tree.</param>
public virtual void ExitEquality_expression([NotNull] AngouriMathParser.Equality_expressionContext context) { }
public virtual void ExitComparison_expression([NotNull] AngouriMathParser.Comparison_expressionContext context) { }
/// <summary>
/// Enter a parse tree produced by <see cref="AngouriMathParser.negate_expression"/>.
/// <para>The default implementation does nothing.</para>
Expand Down
Loading
Loading