Change linear expression representation

grammar/Expr.g4

@@ -26,17 +26,19 @@ expr
     | expr op=('+' | '-') expr                 # addsub
     | expr COMPARISON expr                     # comparison
     | IDENTIFIER '(' expr ')'                  # function
-    | IDENTIFIER '[' shift (',' shift)* ']'    # timeShift
-    | IDENTIFIER '[' expr  (',' expr )* ']'    # timeIndex
-    | IDENTIFIER '[' shift1=shift '..' shift2=shift ']'     # timeShiftRange
-    | IDENTIFIER '[' expr '..' expr ']'        # timeRange
+    | IDENTIFIER '[' shift ']'    # timeShift
+    | IDENTIFIER '[' expr  ']'    # timeIndex
+    | TIME_SUM '(' ((expr | shift | timeShiftRange | timeRange) ',')? IDENTIFIER ')'  #timeSum
     ;
 
 atom
     : NUMBER                                   # number
     | IDENTIFIER                               # identifier
     ;
 
+timeShiftRange: shift1=shift '..' shift2=shift;
+timeRange: expr1=expr '..' expr2=expr;
+
 // a shift is required to be either "t" or "t + ..." or "t - ..."
 // Note: simply defining it as "shift: TIME ('+' | '-') expr" won't work
 //       because the minus sign will not have the expected precedence:
@@ -74,5 +76,6 @@ NUMBER        : DIGIT+ ('.' DIGIT+)?;
 TIME          : 't';
 IDENTIFIER    : CHAR CHAR_OR_DIGIT*;
 COMPARISON    : ( '=' | '>=' | '<=' );
+TIME_SUM      : 'sum';
 
 WS: (' ' | '\t' | '\r'| '\n') -> skip;

requirements-dev.txt

@@ -8,3 +8,4 @@ types-PyYAML~=6.0.12.12
 antlr4-tools~=0.2.1
 pandas~=2.0.3
 pandas-stubs<=2.0.3
+types-PyYAML~=6.0.12

src/andromede/expression/__init__.py

@@ -11,29 +11,28 @@
 # This file is part of the Antares project.
 
 from .copy import CopyVisitor, copy_expression
-from .degree import ExpressionDegreeVisitor, compute_degree
-from .evaluate import EvaluationContext, EvaluationVisitor, ValueProvider, evaluate
-from .evaluate_parameters import (
-    ParameterResolver,
-    ParameterValueProvider,
-    resolve_parameters,
-)
+from .evaluate_parameters import ValueProvider
 from .expression import (
     AdditionNode,
-    Comparator,
     ComparisonNode,
+    ComponentParameterNode,
     DivisionNode,
     ExpressionNode,
+    ExpressionRange,
+    InstancesTimeIndex,
     LiteralNode,
     MultiplicationNode,
     NegationNode,
     ParameterNode,
+    PortFieldAggregatorNode,
+    PortFieldNode,
+    ScenarioOperatorName,
+    ScenarioOperatorNode,
     SubstractionNode,
-    VariableNode,
-    literal,
-    param,
-    sum_expressions,
-    var,
+    TimeAggregatorName,
+    TimeAggregatorNode,
+    TimeOperatorName,
+    TimeOperatorNode,
 )
 from .print import PrinterVisitor, print_expr
 from .visitor import ExpressionVisitor, visit

src/andromede/expression/context_adder.py

@@ -13,13 +13,7 @@
 from dataclasses import dataclass
 
 from . import CopyVisitor
-from .expression import (
-    ComponentParameterNode,
-    ComponentVariableNode,
-    ExpressionNode,
-    ParameterNode,
-    VariableNode,
-)
+from .expression import ComponentParameterNode, ExpressionNode, ParameterNode
 from .visitor import visit
 
 
@@ -32,21 +26,10 @@ class ContextAdder(CopyVisitor):
 
     component_id: str
 
-    def variable(self, node: VariableNode) -> ExpressionNode:
-        return ComponentVariableNode(self.component_id, node.name)
-
     def parameter(self, node: ParameterNode) -> ExpressionNode:
         return ComponentParameterNode(self.component_id, node.name)
 
-    def comp_variable(self, node: ComponentVariableNode) -> ExpressionNode:
-        raise ValueError(
-            "This expression has already been associated to another component."
-        )
-
-    def comp_parameter(self, node: ComponentParameterNode) -> ExpressionNode:
-        raise ValueError(
-            "This expression has already been associated to another component."
-        )
+    # Nothing is done is a component parameter node is encountered as it may have been generated from port resolution
 
 
 def add_component_context(id: str, expression: ExpressionNode) -> ExpressionNode:

src/andromede/expression/copy.py

@@ -11,30 +11,23 @@
 # This file is part of the Antares project.
 
 from dataclasses import dataclass
-from typing import List, Union, cast
+from typing import List, cast
 
 from .expression import (
-    AdditionNode,
     ComparisonNode,
     ComponentParameterNode,
-    ComponentVariableNode,
-    DivisionNode,
     ExpressionNode,
     ExpressionRange,
     InstancesTimeIndex,
     LiteralNode,
-    MultiplicationNode,
-    NegationNode,
     ParameterNode,
     PortFieldAggregatorNode,
     PortFieldNode,
     ScenarioOperatorNode,
-    SubstractionNode,
     TimeAggregatorNode,
     TimeOperatorNode,
-    VariableNode,
 )
-from .visitor import ExpressionVisitor, ExpressionVisitorOperations, T, visit
+from .visitor import ExpressionVisitorOperations, visit
 
 
 @dataclass(frozen=True)
@@ -51,15 +44,9 @@ def comparison(self, node: ComparisonNode) -> ExpressionNode:
             visit(node.left, self), visit(node.right, self), node.comparator
         )
 
-    def variable(self, node: VariableNode) -> ExpressionNode:
-        return VariableNode(node.name)
-
     def parameter(self, node: ParameterNode) -> ExpressionNode:
         return ParameterNode(node.name)
 
-    def comp_variable(self, node: ComponentVariableNode) -> ExpressionNode:
-        return ComponentVariableNode(node.component_id, node.name)
-
     def comp_parameter(self, node: ComponentParameterNode) -> ExpressionNode:
         return ComponentParameterNode(node.component_id, node.name)
 
@@ -69,9 +56,11 @@ def copy_expression_range(
         return ExpressionRange(
             start=visit(expression_range.start, self),
             stop=visit(expression_range.stop, self),
-            step=visit(expression_range.step, self)
-            if expression_range.step is not None
-            else None,
+            step=(
+                visit(expression_range.step, self)
+                if expression_range.step is not None
+                else None
+            ),
         )
 
     def copy_instances_index(

src/andromede/expression/equality.py

@@ -14,25 +14,23 @@
 from dataclasses import dataclass
 from typing import Optional
 
-from andromede.expression import (
+from andromede.expression.expression import (
     AdditionNode,
+    BinaryOperatorNode,
     ComparisonNode,
+    ComponentParameterNode,
     DivisionNode,
     ExpressionNode,
+    ExpressionRange,
+    InstancesTimeIndex,
     LiteralNode,
     MultiplicationNode,
     NegationNode,
     ParameterNode,
-    SubstractionNode,
-    VariableNode,
-)
-from andromede.expression.expression import (
-    BinaryOperatorNode,
-    ExpressionRange,
-    InstancesTimeIndex,
     PortFieldAggregatorNode,
     PortFieldNode,
     ScenarioOperatorNode,
+    SubstractionNode,
     TimeAggregatorNode,
     TimeOperatorNode,
 )
@@ -72,10 +70,12 @@ def visit(self, left: ExpressionNode, right: ExpressionNode) -> bool:
             return self.multiplication(left, right)
         if isinstance(left, ComparisonNode) and isinstance(right, ComparisonNode):
             return self.comparison(left, right)
-        if isinstance(left, VariableNode) and isinstance(right, VariableNode):
-            return self.variable(left, right)
         if isinstance(left, ParameterNode) and isinstance(right, ParameterNode):
             return self.parameter(left, right)
+        if isinstance(left, ComponentParameterNode) and isinstance(
+            right, ComponentParameterNode
+        ):
+            return self.comp_parameter(left, right)
         if isinstance(left, TimeOperatorNode) and isinstance(right, TimeOperatorNode):
             return self.time_operator(left, right)
         if isinstance(left, TimeAggregatorNode) and isinstance(
@@ -124,12 +124,14 @@ def division(self, left: DivisionNode, right: DivisionNode) -> bool:
     def comparison(self, left: ComparisonNode, right: ComparisonNode) -> bool:
         return left.comparator == right.comparator and self._visit_operands(left, right)
 
-    def variable(self, left: VariableNode, right: VariableNode) -> bool:
-        return left.name == right.name
-
     def parameter(self, left: ParameterNode, right: ParameterNode) -> bool:
         return left.name == right.name
 
+    def comp_parameter(
+        self, left: ComponentParameterNode, right: ComponentParameterNode
+    ) -> bool:
+        return left.component_id == right.component_id and left.name == right.name
+
     def expression_range(self, left: ExpressionRange, right: ExpressionRange) -> bool:
         if not self.visit(left.start, right.start):
             return False
@@ -183,7 +185,10 @@ def port_field_aggregator(
 
 
 def expressions_equal(
-    left: ExpressionNode, right: ExpressionNode, abs_tol: float = 0, rel_tol: float = 0
+    left: ExpressionNode,
+    right: ExpressionNode,
+    abs_tol: float = 0,
+    rel_tol: float = 0,
 ) -> bool:
     """
     True if both expression nodes are equal. Literal values may be compared with absolute or relative tolerance.