Upload 22 files

algorithm/plot2D.py

@@ -0,0 +1,37 @@
+import numpy as np
+import matplotlib.pyplot as plt
+
+def plot_2d(C, A, B, initial_point):
+    n_constraints = A.shape[0]  # Get the number of constraints
+
+    plt.figure(figsize=(8, 6))
+    plt.xlim(0, 5)  # Adjust based on your problem
+    plt.ylim(0, 5)  # Adjust based on your problem
+    plt.xlabel('X1')
+    plt.ylabel('X2')
+
+    # Plot feasible region (constraints)
+    x1 = np.linspace(0, 5, 100)
+    
+    for i in range(n_constraints):
+        x2_i = (B[i] - A[i, 0] * x1) / A[i, 1]  # Calculate x2 values for each constraint
+        plt.plot(x1, x2_i, label=f'{A[i, 0]}*X1 + {A[i, 1]}*X2 <= {B[i]}')
+
+    # Fill the feasible region
+    min_x2 = np.minimum.reduce([(B[i] - A[i, 0] * x1) / A[i, 1] for i in range(n_constraints)])
+    plt.fill_between(x1, min_x2, 0, where=(x1 >= 0) & (x1 <= 5), alpha=0.2)
+
+    # Plot the initial feasible solution point
+    plt.scatter(initial_point[0], initial_point[1], color='red', marker='o', label='Initial Point')
+
+    plt.legend()
+    plt.show()
+
+# Example usage with variable-sized A and B:
+C = np.array([2, 3])  # Objective function coefficients
+A = np.array([[1, 1],  # Constraint matrix
+              [2, 1],
+              [3, 1]])  # Add more rows for additional constraints
+B = np.array([4, 5, 6])  # Right-hand side, add more values for additional constraints
+initial_point = np.array([1.0, 3.0])
+plot_2d(C, A, B, initial_point)

algorithm/solver.py

@@ -0,0 +1,143 @@
+import numpy as np
+from ast_parser.parser import EquationKind  # Assuming EquationKind is imported from another module
+
+class Solver:
+    """Solver takes in the equations which have been parsed from the input,
+    it converts them to matrix arrays and applies the matrix operations on 
+    them.
+
+    Args:
+        objective_functions (list of Equation objects): List of objective functions.
+        constraints (list of Equation objects): List of constraint equations.
+    """
+    def __init__(self, objective_functions, constraints):
+        # Extract objective function variables and negate their coefficients
+        self.objective_functions = objective_functions[0].variables
+        self.objective_functions.pop('Z')
+
+        self.constraints = []
+
+        for i, _ in enumerate(constraints):
+            self.constraints.append(constraints[i])
+
+        # Negate coefficients of objective function for maximization
+        for key in self.objective_functions:
+            self.objective_functions[key] *= -1
+
+        # Add slack variables to constraints if necessary
+        for temp_dict in constraints:
+            for key in self.objective_functions.keys():
+                if key not in temp_dict.variables:
+                    temp_dict.variables[key] = 0
+                
+        slack = len(self.constraints)
+        i = 0
+        
+        for _, constraint in enumerate(self.constraints):
+            if constraint.kind == EquationKind.LEQ:
+                constraint.variables["s_" + str(i)] = 1.0
+                self.objective_functions["s_" + str(i)] = 0
+                i += 1
+
+        while i < slack:
+            constraint.variables["s_" + str(i)] = 1.0
+            self.objective_functions["s_" + str(i)] = 0
+            i += 1
+
+        self.A, self.B, self.C = self.convert_to_matrices()
+
+   
+    def get_results(self): 
+        
+        objective_values, solution, variable_names = self.advanced_simplex(self.A, self.B, self.C)
+        variable_names = list(variable_names.values())
+        results_str = "The vector of decision variables is : \n"
+        for i in range(len(objective_values)):
+            results_str+= f"{variable_names[i]} : {round(objective_values[i, 0], 2)}\n"
+        results_str+= "The optimal solution is {}\n".format(solution) 
+        return results_str
+
+    def convert_to_matrices(self):
+        """Converts objective functions and constraints to matrices.
+
+        Returns:
+            A (numpy.ndarray): Coefficients matrix for constraints.
+            B (numpy.ndarray): Right-hand side matrix for constraints.
+            C (numpy.ndarray): Coefficients matrix for objective function.
+        """
+        num_constraints = len(self.constraints)
+        num_variables = len(self.objective_functions)
+
+        A = np.zeros((num_constraints, num_variables))
+        C = np.zeros((1, num_variables))
+        B = np.zeros((num_constraints, 1))
+
+        for i, constraint in enumerate(self.constraints):
+            for variable_name, coefficient in constraint.variables.items():
+                j = list(self.objective_functions.keys()).index(variable_name)
+                A[i, j] = coefficient
+
+            for variable_name, coefficient in self.objective_functions.items():
+                j = list(self.objective_functions.keys()).index(variable_name)
+                C[0, j] = coefficient
+
+            B[i, 0] = constraint.bound
+
+        return A, B, C
+
+    def advanced_simplex(self, A, b, C):
+        """Performs the advanced simplex algorithm to find the optimal solution.
+
+        Args:
+            A (numpy.ndarray): Coefficients matrix for constraints.
+            b (numpy.ndarray): Right-hand side matrix for constraints.
+            C (numpy.ndarray): Coefficients matrix for objective function.
+
+        Returns:
+            objective_values (numpy.ndarray): The values of the objective function variables.
+            solution (float): The optimal solution value.
+        """
+        n, m = A.shape
+
+        B = np.eye(n)
+        C_B = np.zeros((1, n))
+
+        count = 0
+        
+        variable_names = list(self.objective_functions.keys())[-n:]  
+        variable_names = {key: value for key, value in zip(range(n), variable_names)}
+       
+        prev_solution = float('inf')
+        while True:
+            count += 1
+            B_inverse = np.around(np.linalg.inv(B), decimals=2)
+            for row in B_inverse:
+                for value in row:
+                    if value == -0:
+                        value = 0
+
+            X_B = np.matmul(B_inverse, b)
+            P_table = np.round(np.matmul(B_inverse, A), 2)
+            objective_values = np.matmul(C_B, P_table) - C
+            solution = np.round(np.matmul(C_B, X_B), 2)
+            
+            if abs(prev_solution - solution) < 0.0001:
+                return X_B, solution, variable_names
+
+            entering_var_idx = np.argmin(objective_values)
+
+            ratios = []
+            for i in range(n):
+                if P_table[i, entering_var_idx] > 0:
+                    ratios.append(X_B[i, 0] / P_table[i, entering_var_idx])
+                else:
+                    ratios.append(np.inf)  
+
+            exiting_var_idx = np.argmin(ratios)
+            
+            temp_list = list(self.objective_functions.keys())
+
+            variable_names[exiting_var_idx] = temp_list[entering_var_idx]
+            B[:, exiting_var_idx] = A[:, entering_var_idx]
+            C_B[:, exiting_var_idx] = C[:, entering_var_idx]
+            prev_solution = solution

app.py

@@ -0,0 +1,68 @@
+import gradio as gr
+
+from ast_parser import Parser, EquationKind
+from algorithm import solver
+
+def process(input_equation):
+
+    parser = Parser(input_equation)
+
+    equations = tuple(parser)
+
+    for equation in equations:
+        if equation.kind == EquationKind.GEQ and equation.bound < 0.0:
+            for variable, coefficient in equation.variables.items():
+                equation.variables[variable] *= -1.0
+
+            equation.bound *= -1.0
+            equation.kind = EquationKind.LEQ
+
+            continue
+
+        if equation.kind == EquationKind.GEQ:
+            raise ValueError("Equation kind must be either EQ or LEQ")
+        if equation.bound < 0.0:
+            raise ValueError("Equation bound must be non-negative")
+
+    demand: dict[str, list[int]] = {}
+    for i, equation in enumerate(equations):
+        for variable, coefficient in equation.variables.items():
+            if coefficient == 0.0:
+                continue
+
+            if variable not in demand:
+                demand[variable] = []
+
+            demand[variable].append(i)
+
+    objective_variables = tuple(
+        filter(lambda variable: len(demand[variable]) == 1, demand.keys())
+    )
+
+    objective_functions = tuple(
+        filter(
+            lambda function: function.kind == EquationKind.EQ,
+            map(lambda variable: equations[demand[variable][0]], objective_variables),
+        )
+    )
+
+    if len(objective_variables) != len(objective_functions):
+        raise ValueError("Objective functions must be equalities")
+
+    constraints = tuple(
+        filter(
+            lambda function: function not in objective_functions,
+            equations,
+        )
+    )
+
+    solver_instance  = solver.Solver(objective_functions, constraints)
+
+    results = solver_instance.get_results()
+    return results
+    
+description = "This app calculates optimum value using Simplex Method. Enter all equations, following each with a comma. The last equation should be without a comma. As an example 'Z = 5x_1 + 4x_2', '6x_1 + 4x_2 <= 24'"
+examples = [["Z = 5x_1 + 4x_2,6x_1 + 4x_2 <= 24"]]
+demo = gr.Interface(fn=process, inputs="text", outputs="text", title="Optimization Assignment",examples=examples,description=description)
+    
+demo.launch() 

ast_parser/__init__.py

@@ -0,0 +1,47 @@
+from ast_parser.chars import (
+    is_alpha,
+    is_ascii,
+    is_coefficient_start,
+    is_digit,
+    is_lower_alpha,
+    is_upper_alpha,
+    is_variable_continue,
+    is_variable_start,
+    print_char_code,
+)
+from ast_parser.errors import LexerException, LinterException, PositionedException
+from ast_parser.lexer import Lexer
+from ast_parser.linter import Linter
+from ast_parser.parser import Equation, EquationKind, Parser
+from ast_parser.token import (
+    Location,
+    Token,
+    TokenKind,
+    is_binary_operator,
+    is_relational_operator,
+)
+
+__all__ = (
+    "is_digit",
+    "is_coefficient_start",
+    "is_lower_alpha",
+    "is_upper_alpha",
+    "is_alpha",
+    "is_variable_start",
+    "is_variable_continue",
+    "is_ascii",
+    "print_char_code",
+    "PositionedException",
+    "LexerException",
+    "LinterException",
+    "Lexer",
+    "Linter",
+    "EquationKind",
+    "Equation",
+    "Parser",
+    "TokenKind",
+    "Location",
+    "Token",
+    "is_binary_operator",
+    "is_relational_operator",
+)

ast_parser/chars.py

@@ -0,0 +1,131 @@
+from ast_parser.token import TokenKind
+
+
+def is_digit(code: int) -> bool:
+    """Check if code is a digit.
+
+    Args:
+        code (int): Unicode code point.
+
+    Returns:
+        bool: True if code is a digit, False otherwise.
+    """
+    return 0x0030 <= code <= 0x0039  # <digit>
+
+
+def is_coefficient_start(code: int) -> bool:
+    """Check if code is a coefficient start.
+
+    The Coefficient can start with a digit or a dot.
+
+    Args:
+        code (int): Unicode code point.
+
+    Returns:
+        bool: True if code is a Coefficient start, False otherwise.
+    """
+    return is_digit(code) or code == 0x002E  # <digit> | `.`
+
+
+def is_lower_alpha(code: int) -> bool:
+    """Check if code is a lowercased alpha.
+
+    Args:
+        code (int): Unicode code point.
+
+    Returns:
+        bool: True if code is a lowercased alpha, False otherwise.
+    """
+    return 0x0061 <= code <= 0x007A  # <lower_alpha>
+
+
+def is_upper_alpha(code: int) -> bool:
+    """Check if code is an uppercased alpha.
+
+    Args:
+        code (int): Unicode code point.
+
+    Returns:
+        bool: True if code is an uppercased alpha, False otherwise.
+    """
+    return 0x0041 <= code <= 0x005A  # <upper_alpha>
+
+
+def is_alpha(code: int) -> bool:
+    """Check if code is an alpha.
+
+    Args:
+        code (int): Unicode code point.
+
+    Returns:
+        bool: True if code is an alpha, False otherwise.
+    """
+    return is_lower_alpha(code) or is_upper_alpha(code)  # <alpha>
+
+
+def is_variable_start(code: int) -> bool:
+    """Check if code is a variable start.
+
+    The Variable can start with an alpha or an underscore.
+
+    Args:
+        code (int): Unicode code point.
+
+    Returns:
+        bool: True if code is a Variable start, False otherwise.
+    """
+    return is_alpha(code) or code == 0x005F  # <alpha> | `_`
+
+
+def is_variable_continue(code: int) -> bool:
+    """Check if code is a variable continue.
+
+    The Variable can continue with an alpha, an underscore or a digit.
+
+    Args:
+        code (int): Unicode code point.
+
+    Returns:
+        bool: True if code is a Variable continue, False otherwise.
+    """
+    return is_variable_start(code) or is_digit(code)  # <alpha> | `_` | <digit>
+
+
+def is_ascii(code: int) -> bool:
+    """Check if code is an ASCII.
+
+    Args:
+        code (int): Unicode code point.
+
+    Returns:
+        bool: True if code is an ASCII, False otherwise.
+    """
+    return 0x0020 <= code <= 0x007E  # <ASCII>
+
+
+def print_char_code(code: int | None) -> str:
+    """Describe code as a character or Unicode code point.
+
+    Args:
+        code (int | None): Unicode code point. None for EOF.
+
+    Returns:
+        str: Character or Unicode code point.
+    """
+    if code is None:  # <EOF>
+        return TokenKind.EOF.value
+
+    return chr(code) if is_ascii(code) else f"U+{code:04X}"
+
+
+__all__ = (
+    "is_digit",
+    "is_coefficient_start",
+    "is_lower_alpha",
+    "is_upper_alpha",
+    "is_alpha",
+    "is_variable_start",
+    "is_variable_continue",
+    "is_ascii",
+    "print_char_code",
+)

ast_parser/errors.py

@@ -0,0 +1,52 @@
+from ast_parser.token import Location
+
+
+class PositionedException(Exception):
+    """Base class for exceptions with Location.
+
+    Args:
+        source (str): The source string being tokenized.
+        location (Location): The Location of the exception.
+        description (str, optional): An optional description of the
+            error.
+    """
+
+    source: str
+    """The source string being tokenized."""
+    location: Location
+    """The Location of the error in the source."""
+
+    def __init__(
+        self, source: str, location: Location, description: str | None = None
+    ) -> None:
+        super().__init__(description)
+
+        self.source = source
+        self.location = location
+
+
+class LexerException(PositionedException):
+    """A LexerException is raised when the Lexer encounters an invalid
+    character or token.
+
+    Args:
+        source (str): The source string being tokenized.
+        location (Location): The Location of the exception.
+        description (str, optional): An optional description of the
+            error.
+    """
+
+
+class LinterException(PositionedException):
+    """A LinterException is raised when the Linter encounters an invalid
+    token chain.
+
+    Args:
+        source (str): The source string being tokenized.
+        location (Location): The Location of the exception.
+        description (str, optional): An optional description of the
+            error.
+    """
+
+
+__all__ = ("PositionedException", "LexerException", "LinterException")

ast_parser/lexer.py

@@ -0,0 +1,382 @@
+from __future__ import annotations
+
+from typing import Callable
+
+from ast_parser.chars import (
+    is_coefficient_start,
+    is_digit,
+    is_variable_continue,
+    is_variable_start,
+    print_char_code,
+)
+from ast_parser.errors import LexerException
+from ast_parser.token import Location, Token, TokenKind
+
+
+class Lexer:
+    """A Lexer is a stateful stream generator in that every time it is
+    advanced, it returns the next token in the source.
+
+    Assuming the source lexes, the final Token emitted by the Lexer
+    will be of kind EOF, after which the Lexer will repeatedly return
+    the same EOF token whenever called.
+
+    Args:
+        source (str): The source string being tokenized.
+    """
+
+    _source: str
+    """The source string being tokenized."""
+
+    _token: Token
+    """The currently active Token."""
+
+    _line: int
+    """The current line number."""
+    _line_start: int
+    """The index of the start of the current line."""
+
+    def __init__(self, source: str) -> None:
+        self._source = source
+
+        self._token = Token(TokenKind.SOF, 0, 0, Location(0, 0), "")
+
+        self._line = 1
+        self._line_start = 0
+
+    @property
+    def source(self) -> str:
+        """Gets the source string being tokenized.
+
+        Returns:
+            str: The source string being tokenized.
+        """
+        return self._source
+
+    def __iter__(self) -> Lexer:
+        """Gets an iterator over the Tokens in the source.
+
+        Returns:
+            Lexer: An iterator over the tokens in the source.
+        """
+        return self
+
+    def __next__(self) -> Token:
+        """Gets the next Token from the source.
+
+        Raises:
+            StopIteration: The end of the source has been reached.
+            LexerException: Unexpected character, less than operator is
+                not allowed.
+            LexerException: Unexpected character, greater than operator
+                is not allowed.
+            LexerException: Invalid character: <code>.
+            LexerException: Invalid coefficient, unexpected digit after
+                0: <code>.
+            LexerException: Invalid coefficient, expected digit but
+                got: <code>.
+
+        Returns:
+            Token: The next token from the source.
+        """
+        last_token = self._token
+        next_token = self._next_token()
+
+        if last_token.kind == TokenKind.EOF and next_token.kind == TokenKind.EOF:
+            if last_token.prev_token is None:
+                raise LexerException(
+                    self._source,
+                    last_token.location,
+                    "Crude modification of the token chain is detected",
+                )
+
+            if last_token.prev_token.kind == TokenKind.EOF:
+                raise StopIteration
+
+            self._token = next_token
+
+            return last_token
+
+        self._token.next_token = next_token
+        next_token.prev_token = self._token
+
+        self._token = next_token
+
+        return last_token
+
+    def _create_token(self, kind: TokenKind, start: int, end: int, value: str) -> Token:
+        """Creates a token with the given parameters.
+
+        A token is created relative to the current state of the Lexer.
+
+        Args:
+            kind (TokenKind): The kind of token.
+            start (int): The index of the first character of the token.
+            end (int): The index of the first character after the token.
+            value (str): The value of the token.
+
+        Returns:
+            Token:
+        """
+        location = Location(self._line, 1 + start - self._line_start)
+
+        return Token(kind, start, end, location, value, self._token)
+
+    def _read_code(self, position: int) -> int | None:
+        """Reads the character code at the given position in the source.
+
+        Args:
+            position (int): The index of the character to read.
+
+        Returns:
+            int | None: The character code at the given position, or
+                None if the position is out of bounds.
+        """
+        return ord(self._source[position]) if position < len(self._source) else None
+
+    def _read_while(self, start: int, predicate: Callable[[int], bool]) -> int:
+        """Reads a sequence of characters from the source starting at
+        the given position while the predicate is satisfied.
+
+        Args:
+            start (int): The index of the first character of the token.
+            predicate (Callable[[int], bool]): A function that takes a
+                character code and returns whether it satisfies the
+                predicate.
+
+        Returns:
+            int: The index of the first character after the sequence.
+        """
+        position = start
+
+        while position < len(self._source) and predicate(ord(self._source[position])):
+            # print(
+            #     self._source[position],
+            #     ord(self._source[position]),
+            #     is_digit(ord(self._source[position])),
+            # )
+            position += 1
+
+        return position
+
+    def _read_digits(self, start: int, first_code: int | None) -> int:
+        """Reads a sequence of digits from the source starting at the
+        given position.
+
+        Args:
+            start (int): The index of the first character of the token.
+            first_code (int | None): The code of the first character of
+                the token.
+
+        Raises:
+            LexerException: Unexpected character, expected digit but
+                got: <code>.
+
+        Returns:
+            int: The index of the first character after the digits.
+        """
+        if not is_digit(first_code):  # not <digit>
+            raise LexerException(
+                self._source,
+                Location(self._line, 1 + start - self._line_start),
+                f"Unexpected character, expected digit but got: {print_char_code(first_code)}",
+            )
+
+        return self._read_while(start + 1, is_digit)
+
+    def _read_coefficient(self, start: int, first_code: int) -> Token:
+        """Reads a coefficient token from the source starting at the
+        given position.
+
+        Args:
+            start (int): The index of the first character of the token.
+            first_code (int): The code of the first character of the
+                token.
+
+        Raises:
+            LexerException: Invalid coefficient, expected digit but
+                got: <code>.
+
+        Returns:
+            Token: The coefficient token.
+        """
+        position, code = start, first_code
+
+        # Leftmost digits.
+        if code == 0x0030:  # `0`
+            position += 1
+            code = self._read_code(position)
+
+            if is_digit(code):  # <digit>
+                raise LexerException(
+                    self._source,
+                    Location(self._line, 1 + position - self._line_start),
+                    f"Invalid coefficient, unexpected digit after 0: {print_char_code(code)}",
+                )
+        elif code != 0x002E:  # not `.`
+            position = self._read_digits(position, code)
+            code = self._read_code(position)
+
+        # Rightmost digits.
+        if code == 0x002E:  # `.`
+            position += 1
+            code = self._read_code(position)
+
+            position = self._read_digits(position, code)
+            code = self._read_code(position)
+
+        # Exponent.
+        if code in (0x0045, 0x0065):  # `E` | `e`
+            position += 1
+            code = self._read_code(position)
+
+            if code in (0x002B, 0x002D):  # `+` | `-`
+                position += 1
+                code = self._read_code(position)
+
+            position = self._read_digits(position, code)
+
+        return self._create_token(
+            TokenKind.COEFFICIENT, start, position, self._source[start:position]
+        )
+
+    def _read_variable(self, start: int) -> Token:
+        """Reads a variable token from the source starting at the given
+        position.
+
+        Args:
+            start (int): The index of the first character of the token.
+
+        Returns:
+            Token: The variable token.
+        """
+        position = self._read_while(start + 1, is_variable_continue)
+
+        return self._create_token(
+            TokenKind.VARIABLE, start, position, self._source[start:position]
+        )
+
+    def _next_token(self) -> Token:
+        """Gets the next token from the source starting at the given
+        position.
+
+        This skips over whitespace until it finds the next lexable
+        token, then lexes punctuators immediately or calls the
+        appropriate helper function for more complicated tokens.
+
+        Raises:
+            LexerException: Unexpected character, less than operator is
+                not allowed.
+            LexerException: Unexpected character, greater than operator
+                is not allowed.
+            LexerException: Invalid character: <code>.
+            LexerException: Invalid coefficient, unexpected digit after
+                0: <code>.
+            LexerException: Invalid coefficient, expected digit but
+                got: <code>.
+
+        Returns:
+            Token: The next token from the source.
+        """
+        position = self._token.end
+
+        while position < len(self._source):
+            char = self._source[position]
+            code = ord(char)
+
+            match code:
+                # Ignored:
+                # - unicode BOM;
+                # - white space;
+                # - line terminator.
+                case 0xFEFF | 0x0009 | 0x0020:  # <BOM> | `\t` | <space>
+                    position += 1
+
+                    continue
+                case 0x000A:  # `\n`
+                    position += 1
+
+                    self._line += 1
+                    self._line_start = position
+
+                    continue
+                case 0x000D:  # `\r`
+                    position += (
+                        2 if self._read_code(position + 1) == 0x000A else 1
+                    )  # `\r\n` | `\r`
+
+                    self._line += 1
+                    self._line_start = position
+
+                    continue
+                # Single-char tokens:
+                # - binary plus and minus operators;
+                # - multiplication operator;
+                # - relational operators;
+                # - comma.
+                case 0x002B | 0x002D | 0x002A:  # `+` | `-` | `*`
+                    return self._create_token(
+                        TokenKind(char), position, position + 1, char
+                    )
+                case 0x003D:  # `=`
+                    if self._read_code(position + 1) == 0x003D:
+                        return self._create_token(
+                            TokenKind.EQ, position, position + 2, "=="
+                        )
+
+                    return self._create_token(
+                        TokenKind.EQ, position, position + 1, char
+                    )
+                case 0x003C:  # `<`
+                    if self._read_code(position + 1) == 0x003D:  # `=`
+                        return self._create_token(
+                            TokenKind.LEQ, position, position + 2, "<="
+                        )
+
+                    raise LexerException(
+                        self._source,
+                        Location(self._line, 1 + position - self._line_start),
+                        "Unexpected character, less than operator is not allowed",
+                    )
+                case 0x003E:  # `>`
+                    if self._read_code(position + 1) == 0x003D:  # `=`
+                        return self._create_token(
+                            TokenKind.GEQ, position, position + 2, ">="
+                        )
+
+                    raise LexerException(
+                        self._source,
+                        Location(self._line, 1 + position - self._line_start),
+                        "Unexpected character, greater than operator is not allowed",
+                    )
+                case 0x2264:  # `≤`
+                    return self._create_token(
+                        TokenKind.LEQ, position, position + 1, char
+                    )
+                case 0x2265:  # `≥`
+                    return self._create_token(
+                        TokenKind.GEQ, position, position + 1, char
+                    )
+                case 0x002C:  # `,`
+                    return self._create_token(
+                        TokenKind.COMMA, position, position + 1, char
+                    )
+
+            # Multi-char tokens:
+            # - coefficient;
+            # - variable.
+            if is_coefficient_start(code):  # <digit> | `.`
+                return self._read_coefficient(position, code)
+            if is_variable_start(code):  # <alpha> | `_`
+                return self._read_variable(position)
+
+            raise LexerException(
+                self._source,
+                Location(self._line, 1 + position - self._line_start),
+                f"Invalid character: {print_char_code(code)}",
+            )
+
+        return self._create_token(TokenKind.EOF, position, position, "")
+
+
+__all__ = ("Lexer",)

ast_parser/linter.py

@@ -0,0 +1,291 @@
+from ast_parser.errors import LinterException
+from ast_parser.token import (
+    Token,
+    TokenKind,
+    is_binary_operator,
+    is_relational_operator,
+)
+
+
+class Linter:
+    """Linter enables real-time validation of the token chain.
+
+    Args:
+        source (str): The source string being tokenized.
+    """
+
+    _source: str
+
+    _variable_provided: bool
+    _relation_provided: bool
+
+    def __init__(self, source: str) -> None:
+        self._source = source
+
+        self._variable_provided = False
+        self._relation_provided = False
+
+    def lint(self, token: Token) -> None:
+        """The lint method checks the token for integrity, validity and
+        relevance. It raises a LinterException if the token is invalid
+        or unexpected.
+
+        Args:
+            token (Token): The starting token.
+            source (str): The source string being tokenized. Used for
+                exception messages.
+
+        Raises:
+            LinterException: Unexpected binary operator, term missed.
+            LinterException: Equation must contain only one relational
+                operator.
+            LinterException: Term must contain no more than one
+                variable.
+            LinterException: Unexpected comma at the beginning of the
+                equation.
+            LinterException: Unexpected comma, equation missed.
+            LinterException: Unexpected comma at the end of the
+                equation.
+            LinterException: Equation must contain a relational
+                operator.
+        """
+        if token.kind != TokenKind.SOF and (
+            token.prev_token is None or token.prev_token.next_token is not token
+        ):
+            raise LinterException(
+                self._source,
+                token.location,
+                "Crude modification of the token chain is detected",
+            )
+
+        if token.kind == TokenKind.EOF:
+            self._lint_eof(token)
+
+        if is_binary_operator(token):
+            self._lint_binary_operator(token)
+
+            self._variable_provided = False
+
+        if token.kind == TokenKind.MUL:
+            self._lint_multiplication_operator(token)
+
+        if is_relational_operator(token):
+            self._lint_relational_operator(token)
+
+            self._variable_provided = False
+            self._relation_provided = True
+
+        if token.kind == TokenKind.VARIABLE:
+            self._lint_variable(token)
+
+            self._variable_provided = True
+
+        if token.kind == TokenKind.COMMA:
+            self._lint_comma(token)
+
+            self._variable_provided = False
+            self._relation_provided = False
+
+    def _lint_eof(self, token: Token) -> None:
+        """Lint the EOF Token.
+
+        Args:
+            token (Token): The EOF Token.
+
+        Raises:
+            LinterException: Equation must contain a relational
+                operator.
+            LinterException: Unexpected binary operator at the end of
+                the equation.
+            LinterException: Unexpected EOF, right side of the equation
+                is missed.
+            LinterException: Unexpected comma at the end of the
+                equation.
+        """
+        if token.prev_token.kind != TokenKind.SOF and not self._relation_provided:
+            raise LinterException(
+                self._source,
+                token.location,
+                "Equation must contain a relational operator",
+            )
+        if is_binary_operator(token.prev_token):
+            raise LinterException(
+                self._source,
+                token.prev_token.location,
+                "Unexpected binary operator at the end of the equation",
+            )
+        if token.prev_token.kind == TokenKind.MUL:
+            raise LinterException(
+                self._source,
+                token.location,
+                "Unexpected EOF, multiplier missed",
+            )
+        if is_relational_operator(token.prev_token):
+            raise LinterException(
+                self._source,
+                token.location,
+                "Unexpected EOF, right side of the equation is missed",
+            )
+        if token.prev_token.kind == TokenKind.COMMA:
+            raise LinterException(
+                self._source,
+                token.location,
+                "Unexpected comma at the end of the equation",
+            )
+
+    def _lint_binary_operator(self, token: Token) -> None:
+        """Lint the binary operator Token.
+
+        Args:
+            token (Token): The binary operator Token.
+
+        Raises:
+            LinterException: Unexpected binary operator, term missed.
+        """
+        if is_binary_operator(token.prev_token):
+            raise LinterException(
+                self._source,
+                token.location,
+                "Unexpected binary operator, term missed",
+            )
+        if token.prev_token.kind == TokenKind.MUL:
+            raise LinterException(
+                self._source,
+                token.location,
+                "Unexpected binary operator, multiplier missed",
+            )
+
+    def _lint_multiplication_operator(self, token: Token) -> None:
+        """Lint the multiplication operator Token.
+
+        Args:
+            token (Token): The multiplication operator Token.
+
+        Raises:
+            LinterException: Unexpected multiplication operator, term
+                missed.
+        """
+        if (
+            is_binary_operator(token.prev_token)
+            or is_relational_operator(token.prev_token)
+            or token.prev_token.kind == TokenKind.COMMA
+        ):
+            raise LinterException(
+                self._source,
+                token.location,
+                "Unexpected multiplication operator, term missed",
+            )
+        if token.prev_token.kind == TokenKind.MUL:
+            raise LinterException(
+                self._source,
+                token.location,
+                "Unexpected multiplication operator, multiplier missed",
+            )
+
+    def _lint_relational_operator(self, token: Token) -> None:
+        """Lint the relational operator Token.
+
+        Args:
+            token (Token): The relational operator Token.
+
+        Raises:
+            LinterException: Equation must contain only one relational
+                operator.
+            LinterException: Unexpected binary operator, term missed.
+            LinterException: Unexpected relational operator, left side
+                of the equation is missed.
+        """
+        if token.prev_token.kind in (TokenKind.SOF, TokenKind.COMMA):
+            raise LinterException(
+                self._source,
+                token.location,
+                "Unexpected relational operator, left side of the equation is missed",
+            )
+        if self._relation_provided:
+            raise LinterException(
+                self._source,
+                token.location,
+                "Equation must contain only one relational operator",
+            )
+        if is_binary_operator(token.prev_token):
+            raise LinterException(
+                self._source,
+                token.location,
+                "Unexpected binary operator, term missed",
+            )
+        if token.prev_token.kind == TokenKind.MUL:
+            raise LinterException(
+                self._source,
+                token.location,
+                "Unexpected relational operator, multiplier missed",
+            )
+
+    def _lint_variable(self, token: Token) -> None:
+        """Lint the variable Token.
+
+        Args:
+            token (Token): The variable Token.
+
+        Raises:
+            LinterException: Term must contain no more than one
+                variable.
+        """
+        if self._variable_provided:
+            raise LinterException(
+                self._source,
+                token.location,
+                "Term must contain no more than one variable",
+            )
+
+    def _lint_comma(self, token: Token) -> None:
+        """Lint the comma Token.
+
+        Args:
+            token (Token): The comma Token.
+
+        Raises:
+            LinterException: Unexpected comma at the beginning of the
+                equation.
+            LinterException: Unexpected comma, equation missed.
+            LinterException: Unexpected comma at the end of the
+                equation.
+        """
+        if token.prev_token.kind == TokenKind.SOF:
+            raise LinterException(
+                self._source,
+                token.location,
+                "Unexpected comma at the beginning of the equation",
+            )
+        if not self._relation_provided:
+            raise LinterException(
+                self._source,
+                token.location,
+                "Equation must contain a relational operator",
+            )
+        if is_binary_operator(token.prev_token):
+            raise LinterException(
+                self._source,
+                token.prev_token,
+                "Unexpected binary operator at the end of the equation",
+            )
+        if token.prev_token.kind == TokenKind.MUL:
+            raise LinterException(
+                self._source,
+                token.location,
+                "Unexpected comma, multiplier missed",
+            )
+        if is_relational_operator(token.prev_token):
+            raise LinterException(
+                self._source,
+                token.location,
+                "Unexpected comma, right side of the equation is missed",
+            )
+        if token.prev_token.kind == TokenKind.COMMA:
+            raise LinterException(
+                self._source,
+                token.location,
+                "Unexpected comma, equation missed",
+            )
+
+
+__all__ = ("Linter",)

ast_parser/parser.py

@@ -0,0 +1,245 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from enum import Enum
+
+from ast_parser.lexer import Lexer
+from ast_parser.linter import Linter
+from ast_parser.token import Token, TokenKind
+
+
+class EquationKind(str, Enum):
+    """Kind of relationship between the left and right parts of the
+    Equation."""
+
+    EQ = "="
+    """Equality operator."""
+    LEQ = "<="
+    """Less than or equal to operator."""
+    GEQ = ">="
+    """Greater than or equal to operator."""
+
+
+@dataclass
+class Equation:
+    """Equation definition."""
+
+    kind: EquationKind
+    """Kind of relationship between the left and right parts of the
+    Equation.
+    """
+    variables: dict[str, float]
+    """Equation variables. The names are the keys, the coefficients are
+    the values.
+    """
+    bound: float
+    """Bound of the Equation. Must be non-negative."""
+
+
+@dataclass
+class EquationAccumulator:
+    """The EquationAccumulator collects equation Tokens: variables,
+    coefficients, and bounds.
+    """
+
+    kind: EquationKind | None = field(default=None)
+    """Kind of relationship between the left and right parts of the
+    Equation.
+    """
+    variables: dict[str, float] = field(default_factory=dict)
+    """Equation variables. The names are the keys, the coefficients are
+    the values.
+    """
+    bound: float = field(default=0.0)
+    """Bound of the Equation. Must be non-negative."""
+
+    coefficient: float | None = field(default=None)
+    """Coefficient of the current variable."""
+    variable: str | None = field(default=None)
+    """Name of the current variable."""
+
+
+class Parser:
+    """Source Parser. It parses the source and returns a list of
+    Equation objects found in the source.
+
+    Args:
+        source (str): The source to parse.
+    """
+
+    _lexer: Lexer
+    """Lexer of the source."""
+    _linter: Linter
+    """Linter of the source."""
+
+    _accumulator: EquationAccumulator
+    """Equation accumulator."""
+
+    def __init__(self, source: str) -> None:
+        self._lexer = Lexer(source)
+        self._linter = Linter(source)
+
+        self._accumulator = EquationAccumulator()
+
+    def __iter__(self) -> Parser:
+        """Gets an iterator over the Equations in the source.
+
+        Returns:
+            Parser: _description_
+        """
+        return self
+
+    def __next__(self) -> Equation:
+        """Gets the next Equation in the source.
+
+        Accumulation, processing and validation of Equations in
+        real-time. The source is parsed sequentially, token by token.
+
+        Raises:
+            StopIteration: The end of the source has been reached.
+            LexerException: Unexpected character, less than operator is
+                not allowed.
+            LexerException: Unexpected character, greater than operator
+                is not allowed.
+            LexerException: Invalid character: <code>.
+            LexerException: Invalid coefficient, unexpected digit after
+                0: <code>.
+            LexerException: Invalid coefficient, expected digit but
+                got: <code>.
+            LinterException: Unexpected binary operator, term missed.
+            LinterException: Equation must contain only one relational
+                operator.
+            LinterException: Term must contain no more than one
+                variable.
+            LinterException: Unexpected comma at the beginning of the
+                equation.
+            LinterException: Unexpected comma, equation missed.
+            LinterException: Unexpected comma at the end of the
+                equation.
+            LinterException: Equation must contain a relational
+                operator.
+
+        Returns:
+            Equation: The next Equation from the source.
+        """
+        while True:
+            token = next(self._lexer)
+
+            self._linter.lint(token)
+
+            match token.kind:
+                case TokenKind.SOF | TokenKind.MUL:
+                    continue
+                case TokenKind.EOF:
+                    if token.prev_token.kind == TokenKind.SOF:
+                        raise StopIteration
+
+                    return self._derive_equation()
+                case TokenKind.ADD:
+                    self._parse_addition_operator()
+
+                    continue
+                case TokenKind.SUB:
+                    self._parse_subtraction_operator()
+
+                    continue
+                case TokenKind.EQ | TokenKind.LEQ | TokenKind.GEQ:
+                    self._parse_relational_operator(token)
+
+                    continue
+                case TokenKind.COEFFICIENT:
+                    self._parse_coefficient(token)
+
+                    continue
+                case TokenKind.VARIABLE:
+                    self._parse_variable(token)
+
+                    continue
+                case TokenKind.COMMA:
+                    return self._derive_equation()
+
+    def _extend_variables(self) -> None:
+        """Extend the variables with the current variable and
+        coefficient.
+        """
+        if self._accumulator.coefficient:
+            if self._accumulator.kind:
+                self._accumulator.coefficient *= -1.0
+            if self._accumulator.variable:
+                if self._accumulator.variable in self._accumulator.variables:
+                    self._accumulator.variables[
+                        self._accumulator.variable
+                    ] += self._accumulator.coefficient
+                else:
+                    self._accumulator.variables[
+                        self._accumulator.variable
+                    ] = self._accumulator.coefficient
+            else:
+                self._accumulator.bound -= self._accumulator.coefficient
+
+    def _derive_equation(self) -> Equation:
+        """Derive the Equation from the EquationAccumulator.
+
+        Returns:
+            Equation: The derived Equation.
+        """
+        self._extend_variables()
+
+        equation = Equation(
+            self._accumulator.kind, self._accumulator.variables, self._accumulator.bound
+        )
+
+        self._accumulator = EquationAccumulator()
+
+        return equation
+
+    def _parse_addition_operator(self) -> None:
+        """Parse the addition operator Token."""
+        self._extend_variables()
+
+        self._accumulator.variable = None
+        self._accumulator.coefficient = 1.0
+
+    def _parse_subtraction_operator(self) -> None:
+        """Parse the subtraction operator Token."""
+        self._extend_variables()
+
+        self._accumulator.variable = None
+        self._accumulator.coefficient = -1.0
+
+    def _parse_relational_operator(self, token: Token) -> None:
+        """Parse the relational operator Token.
+
+        Args:
+            token (Token): The relational operator Token.
+        """
+        self._extend_variables()
+
+        self._accumulator.kind = EquationKind(token.kind.value)
+        self._accumulator.variable = None
+        self._accumulator.coefficient = None
+
+    def _parse_coefficient(self, token: Token) -> None:
+        """Parse the coefficient Token.
+
+        Args:
+            token (Token): The coefficient Token.
+        """
+        if not self._accumulator.coefficient:
+            self._accumulator.coefficient = 1.0
+
+        self._accumulator.coefficient *= float(token.value)
+
+    def _parse_variable(self, token: Token) -> None:
+        """Parse the variable Token.
+
+        Args:
+            token (Token): The variable Token.
+        """
+        if not self._accumulator.coefficient:
+            self._accumulator.coefficient = 1.0
+
+        self._accumulator.variable = token.value
+
+
+__all__ = ("EquationKind", "Equation", "Parser")

ast_parser/token.py

@@ -0,0 +1,106 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from enum import Enum
+
+
+class TokenKind(str, Enum):
+    """Kind of the Token."""
+
+    SOF = "<SOF>"
+    """Start of file."""
+    EOF = "<EOF>"
+    """End of file."""
+
+    ADD = "+"
+    """Addition operator."""
+    SUB = "-"
+    """Subtraction operator."""
+    MUL = "*"
+    """Multiplication operator."""
+
+    EQ = "="
+    """Equality operator."""
+    LEQ = "<="
+    """Less than or equal to operator."""
+    GEQ = ">="
+    """Greater than or equal to operator."""
+
+    COEFFICIENT = "Coefficient"
+    """Coefficient of a variable."""
+    VARIABLE = "Variable"
+    """Variable name."""
+
+    COMMA = ","
+    """Comma."""
+
+
+@dataclass
+class Location:
+    """Location of the Token in the source.
+
+    The Location is more user-friendly than the start and end indices.
+    """
+
+    line: int
+    """Line number of the token in the source. Starts at 1."""
+    column: int
+    """Column number of the token in the source. Starts at 1."""
+
+
+@dataclass
+class Token:
+    """Token of the source code."""
+
+    kind: TokenKind
+    """Kind of the token."""
+
+    start: int = field(repr=False)
+    """The index of the first character of the token."""
+    end: int = field(repr=False)
+    """The index of the first character after the token."""
+    location: Location
+    """The Location of the token in the source."""
+
+    value: str
+    """The value of the token."""
+
+    prev_token: Token | None = field(repr=False, default=None)
+    """The previous Token in the source."""
+    next_token: Token | None = field(repr=False, default=None)
+    """The next Token in the source."""
+
+
+def is_binary_operator(token: Token) -> bool:
+    """Check if the Token is an algebraic binary operator.
+
+    Args:
+        token (Token): The Token to check.
+
+    Returns:
+        bool: True if the Token is an algebraic binary operator, False
+            otherwise.
+    """
+    return token.kind in (TokenKind.ADD, TokenKind.SUB)
+
+
+def is_relational_operator(token: Token) -> bool:
+    """Check if the Token is a relational operator.
+
+    Args:
+        token (Token): The Token to check.
+
+    Returns:
+        bool: True if the Token is a relational operator, False
+            otherwise.
+    """
+    return token.kind in (TokenKind.EQ, TokenKind.LEQ, TokenKind.GEQ)
+
+
+__all__ = (
+    "TokenKind",
+    "Location",
+    "Token",
+    "is_binary_operator",
+    "is_relational_operator",
+)

main.py

@@ -0,0 +1,59 @@
+from ast_parser import Parser, EquationKind
+from algorithm import solver
+
+print("Enter all equations, following each with a comma. The last equation should be without a comma")
+print("As an example 'Z = 5x_1 + 4x_2', '6x_1 + 4x_2 <= 24'")
+input_equation = input()
+
+parser = Parser(input_equation)
+
+equations = tuple(parser)
+
+for equation in equations:
+    if equation.kind == EquationKind.GEQ and equation.bound < 0.0:
+        for variable, coefficient in equation.variables.items():
+            equation.variables[variable] *= -1.0
+
+        equation.bound *= -1.0
+        equation.kind = EquationKind.LEQ
+
+        continue
+
+    if equation.kind == EquationKind.GEQ:
+        raise ValueError("Equation kind must be either EQ or LEQ")
+    if equation.bound < 0.0:
+        raise ValueError("Equation bound must be non-negative")
+
+demand: dict[str, list[int]] = {}
+for i, equation in enumerate(equations):
+    for variable, coefficient in equation.variables.items():
+        if coefficient == 0.0:
+            continue
+
+        if variable not in demand:
+            demand[variable] = []
+
+        demand[variable].append(i)
+
+objective_variables = tuple(
+    filter(lambda variable: len(demand[variable]) == 1, demand.keys())
+)
+
+objective_functions = tuple(
+    filter(
+        lambda function: function.kind == EquationKind.EQ,
+        map(lambda variable: equations[demand[variable][0]], objective_variables),
+    )
+)
+
+if len(objective_variables) != len(objective_functions):
+    raise ValueError("Objective functions must be equalities")
+
+constraints = tuple(
+    filter(
+        lambda function: function not in objective_functions,
+        equations,
+    )
+)
+
+solver.Solver(objective_functions, constraints)