jijmodeling 0.10.15__cp310-cp310-win_amd64.whl → 1.11.0__cp310-cp310-win_amd64.whl

jijmodeling/latex_repr/latex_repr.py

@@ -1,243 +0,0 @@
-from __future__ import annotations
-
-from jijmodeling.expression.condition import (
-    AndOperator,
-    CompareCondition,
-    Condition,
-    ConditionOperator,
-    Equal,
-    LessThan,
-    LessThanEqual,
-    NoneCondition,
-    NotEqual,
-    OrOperator,
-    XorOperator,
-)
-from jijmodeling.expression.expression import (
-    Add,
-    BinaryOperator,
-    Div,
-    Expression,
-    Mod,
-    Mul,
-    Number,
-    Power,
-)
-from jijmodeling.expression.mathfunc import (
-    AbsoluteValue,
-    Ceil,
-    Floor,
-    Log2,
-    UnaryOperator,
-)
-from jijmodeling.expression.prod import ProdOperator
-from jijmodeling.expression.sum import ReductionOperator, SumOperator
-from jijmodeling.expression.variables.placeholders import ArrayShape
-from jijmodeling.expression.variables.variable import Range, Subscripts, Variable
-
-
-def condition_latex_repr(expr: Condition) -> str:
-    if isinstance(expr, CompareCondition):
-        left = expr_latex_repr(expr.left)
-        right = expr_latex_repr(expr.right)
-        mark = r" \cdot "
-        if isinstance(expr, Equal):
-            mark = "="
-        elif isinstance(expr, NotEqual):
-            mark = r"\neq"
-        elif isinstance(expr, LessThan):
-            mark = "<"
-        elif isinstance(expr, LessThanEqual):
-            mark = r"\leq"
-        return left + f" {mark} " + right
-    elif isinstance(expr, ConditionOperator):
-        left = condition_latex_repr(expr.left)
-        right = condition_latex_repr(expr.right)
-        mark = r" \cdot "
-        if isinstance(expr, AndOperator):
-            mark = r" \ \land \ "
-        elif isinstance(expr, OrOperator):
-            mark = r" \ \lor \ "
-        elif isinstance(expr, XorOperator):
-            mark = r" \ \veebar \ "
-        return left + f"{mark}" + right
-    else:
-        return ""
-
-
-def expr_latex_repr(expr: Expression) -> str:
-    if expr._latex_repr is not None:
-        return expr._latex_repr
-    if isinstance(expr, Number):
-        return str(expr.value)
-    elif isinstance(expr, UnaryOperator):
-        return _unary_latex_repr(expr)
-    elif isinstance(expr, BinaryOperator):
-        return _binary_latex_repr(expr)
-    elif isinstance(expr, Variable):
-        if isinstance(expr, ArrayShape):
-            array = expr_latex_repr(expr.array)
-            axis = str(expr.dimension)
-            return rf"{array}_{{\mathrm{{shape}}({axis})}}"
-        label = expr.label.replace("_", r"\_").replace("^", r"\_")
-        if "_" in label:
-            label = r"\mathrm{" + label + r"}"
-        return label
-    elif isinstance(expr, Subscripts):
-        label = expr_latex_repr(expr.variable)
-        subs = ",".join([expr_latex_repr(x) for x in expr.subscripts])
-        return label + r"_{" + subs + r"}"
-    elif isinstance(expr, ReductionOperator):
-        return _reduction_latex_repr(expr)
-
-    return rf"\mathrm{{ {str(expr)} }}"
-
-
-def _unary_latex_repr(expr: UnaryOperator) -> str:
-    operand = expr_latex_repr(expr.operand)
-    if isinstance(expr, Ceil):
-        return rf"\left\lceil {operand} \right\rceil"
-    elif isinstance(expr, Floor):
-        return rf"\left\lfloor {operand} \right\rfloor"
-    elif isinstance(expr, AbsoluteValue):
-        return rf"\left| {operand} \right|"
-    elif isinstance(expr, Log2):
-        return rf"\log_2 \left( {operand} \right)"
-
-
-def _binary_latex_repr(expr: BinaryOperator) -> str:
-    left = expr_latex_repr(expr.left)
-    right = expr_latex_repr(expr.right)
-
-    if isinstance(expr, Add):
-        return _add_latex_repr(expr, left, right)
-    elif isinstance(expr, Mul):
-        return _mul_latex_repr(expr, left, right)
-    elif isinstance(expr, Power):
-        # Check if the base needs parentheses
-        if isinstance(expr.left, (BinaryOperator, ReductionOperator)):
-            left = rf"\left( {left} \right)"
-        return rf"{left} ^ {{ {right} }}"
-    elif isinstance(expr, Mod):
-        # Check if the left hand side needs parentheses
-        if isinstance(expr.left, BinaryOperator):
-            left = rf"\left( {left} \right)"
-        # Check if the left hand side needs parentheses
-        if isinstance(expr.right, BinaryOperator):
-            right = rf"\left( {right} \right)"
-        return rf"{left} \mod {right}"
-    elif isinstance(expr, Div):
-        return rf"\frac{{ {left} }}{{ {right} }}"
-    else:
-        return r"\left(" + str(expr) + r"\right)"
-
-
-def _add_latex_repr(expr: Add, left: str, right: str) -> str:
-    symbol = "+"
-    is_right_negative = False
-    # check if the right hand side has a negative sign
-    if (
-        isinstance(expr.right, Mul)
-        and isinstance(expr.right.left, Number)
-        and expr.right.left.value == -1.0
-    ):
-        right = right[2:]
-        symbol = "-"
-        is_right_negative = True
-
-    if isinstance(expr.right, Number) and expr.right.value < 0.0:
-        num_abs = Number(expr.right.value * -1, dtype=expr.right.dtype)
-        return f"{left} - {num_abs}"
-
-    # check if the left hand side needs parentheses
-    # ex: (a mod b) + right
-    # ex: (a mod b) - right
-    if isinstance(expr.left, Mod):
-        left = rf"\left( {left} \right)"
-    # check if the right hand side needs parentheses
-    # ex: left + (a mod b)
-    # ex: left - (a mod b)
-    if isinstance(expr.right, Mod) or (
-        is_right_negative and isinstance(expr.right.right, Mod)
-    ):
-        right = rf"\left( {right} \right)"
-
-    return f"{left} {symbol} {right}"
-
-
-def _mul_latex_repr(expr: Mul, left: str, right: str) -> str:
-    if isinstance(expr.left, Number):
-        coeff = expr.left.value
-        if coeff == -1:
-            # check if the right hand side needs parentheses
-            if isinstance(expr.right, Add):
-                return rf"- \left( {right} \right)"
-            else:
-                return f"- {right}"
-        if coeff < 0:
-            # check if the right hand side needs parentheses
-            if isinstance(expr.right, Add):
-                return rf"\left( {left} \right) \cdot \left( {right} \right)"
-            else:
-                return rf"\left( {left} \right) \cdot {right}"
-    if isinstance(expr.right, Number):
-        coeff = expr.right.value
-        if coeff == -1:
-            return f"- {right}"
-        if coeff < 0:
-            return rf"\left( {right} \right) \cdot {left}"
-
-        # put coefficient in front of variable terms
-        return rf"{right} \cdot {left}"
-
-    parentheses_required_type = (Add, Mod)
-    # check if the left hand side needs parentheses
-    if isinstance(expr.left, parentheses_required_type):
-        left = rf"\left( {left} \right)"
-    # check if the right hand side needs parentheses
-    if isinstance(expr.right, parentheses_required_type):
-        right = rf"\left( {right} \right)"
-
-    if left[0] == "-":
-        left = rf"\left( {left} \right)"
-    if right[0] == "-":
-        right = rf"\left( {right} \right)"
-
-    return left + r" \cdot " + right
-
-
-def _reduction_latex_repr(expr: ReductionOperator) -> str:
-    # select operator symbol in LaTeX
-    if isinstance(expr, SumOperator):
-        operator = r"\sum"
-    elif isinstance(expr, ProdOperator):
-        operator = r"\prod"
-    # NOTE: When is this needed?
-    else:
-        operator = r"\Otimes"
-
-    # make condition string in LaTeX
-    condition = ""
-    if not isinstance(expr.condition, NoneCondition):
-        condition = rf",\ {condition_latex_repr(expr.condition)}"
-    index = expr_latex_repr(expr.sum_index)
-
-    # make index string in LaTeX
-    # case: index belongs to range
-    if isinstance(expr.sum_index.parent, Range):
-        start = expr_latex_repr(expr.sum_index.parent.start)
-        end = expr_latex_repr(expr.sum_index.parent.last - 1)
-        operator = rf"{operator}_{{ {index} = {start}{condition} }}^{{ {end} }}"
-    # case: index belongs to a set
-    else:
-        parent = expr_latex_repr(expr.sum_index.parent)
-        operator = rf"{operator}_{{ {index} \in {parent}{condition} }}"
-
-    operand = expr_latex_repr(expr.operand)
-
-    # check if the operand needs parentheses
-    parentheses_required_type = (Add, Mod)
-    if isinstance(expr.operand, parentheses_required_type):
-        return rf"{operator} \left( {operand} \right)"
-    else:
-        return rf"{operator} {operand}"

jijmodeling/latex_repr/problem_latex_repr.py

@@ -1,209 +0,0 @@
-from __future__ import annotations
-
-import re
-
-from itertools import zip_longest
-
-from jijmodeling.expression.condition import NoneCondition
-from jijmodeling.expression.constraint import Constraint, Penalty
-from jijmodeling.expression.extract import extract_vars_from_problem
-from jijmodeling.expression.variables.deci_vars import Binary, DecisionVariable, Integer
-from jijmodeling.expression.variables.variable import Range
-from jijmodeling.latex_repr.latex_repr import condition_latex_repr, expr_latex_repr
-from jijmodeling.problem.problem import Problem, ProblemSense
-
-
-def range_latex_repr(el_range: Range):
-    start_str = expr_latex_repr(el_range.start)
-    last_str = expr_latex_repr(el_range.last - 1)
-    latex_str: str = rf"\left\{{ {start_str} ,\ldots , {last_str} \right\}}"
-    return latex_str
-
-
-def escape_latex_special_character(text: str) -> str:
-    """
-    Replace characters that matches with the 10 latex special characters.
-
-    There are 10 latex special characters:
-    1. tilde (~)
-    2. circumflex (^)
-    3. backslash (\\)
-    4. percent sign (%)
-    5. ampersand (&)
-    6. dollar sign ($)
-    7. number sign (#)
-    8. underscore (_)
-    9. left brace ({)
-    10. right brace (})
-    https://tex.stackexchange.com/questions/34580/escape-character-in-latex/34586#34586
-
-    If `latex` has some latex special characters, then replace the characters into other strings by following the below table:
-
-    | name         | src  | dst                  |
-    | ------------ | ---- | -------------------- |
-    | backslash    | "\\" | "\textbackslash{}"   |
-    | tilde        | "~"  | "\textasciitilde{}"  |
-    | circumflex   | "^"  | "\textasciicircum{}" |
-    | ampersand    | "&"  | "\\&"                |
-    | percent sign | "%"  | "\\%"                |
-    | dollar sign  | "$"  | "\\$"                |
-    | number sign  | "#"  | "\\#"                |
-    | underscore   | "_"  | "\\_"                |
-    | left brace   | "{"  | "\\{"                |
-    | right brace  | "}"  | "\\}"                |
-
-    Args:
-        text (str): string
-
-    Returns:
-        str: string without 10 latex special characters
-    """
-    latex_special_chars = "|".join(
-        [r"\\", "~", r"\^", "&", "%", r"\$", "#", "_", "{", "}"]
-    )
-
-    replaced_special_chars = []
-    for c in re.findall(latex_special_chars, text):
-        if c == "\\":
-            replaced_special_chars.append(r"\textbackslash{}")
-        elif c == "~":
-            replaced_special_chars.append(r"\textasciitilde{}")
-        elif c == "^":
-            replaced_special_chars.append(r"\textasciicircum{}")
-        else:
-            replaced_special_chars.append(rf"\{c}")
-
-    text_without_special_chars = re.split(latex_special_chars, text)
-    result = "".join(
-        [
-            no_special_char + replaced_special_char
-            for no_special_char, replaced_special_char in zip_longest(
-                text_without_special_chars, replaced_special_chars, fillvalue=""
-            )
-        ]
-    )
-    return result
-
-
-def constraint_latex_repr(constraint: Constraint) -> str:
-    name = escape_latex_special_character(constraint.label)
-    latex_str = rf"\text{{{name}}} :\\ &\quad \quad "
-    latex_str += condition_latex_repr(constraint.condition)
-    latex_str += ","
-    # case: condition has a forall condition
-    if len(constraint.forall) > 0:
-        for_all_str = ""
-        condition_str = ""
-        for index, condition in constraint.forall:
-            parent_str = (
-                range_latex_repr(index.parent)
-                if isinstance(index.parent, Range)
-                else expr_latex_repr(index.parent)
-            )
-            for_all_str += rf"\forall {expr_latex_repr(index)} \in {parent_str} "
-            condition_str += (
-                ""
-                if isinstance(condition, NoneCondition)
-                else condition_latex_repr(condition) + r"\land "
-            )
-        # for_all_str = for_all_str.rstrip(', ')
-        latex_str += rf"\ {for_all_str}"
-
-        condition_str = condition_str.rstrip(r"\land ")
-        if condition_str != "":
-            latex_str += rf" \ {condition_str}"
-    return latex_str
-
-
-def penalty_latex_repr(penalty: Penalty) -> str:
-    name = escape_latex_special_character(penalty.label)
-    latex_str = rf"\text{{{name}}} :\\ &\quad \quad "
-    latex_str += expr_latex_repr(penalty.penalty_term)
-    latex_str += ","
-
-    # case: penalty has a forall condition
-    if len(penalty.forall) > 0:
-        for_all_str = ""
-        condition_str = ""
-        for index, condition in penalty.forall:
-            parent_str = (
-                range_latex_repr(index.parent)
-                if isinstance(index.parent, Range)
-                else expr_latex_repr(index.parent)
-            )
-            for_all_str += rf"\forall {expr_latex_repr(index)} \in {parent_str} "
-            condition_str += (
-                ""
-                if isinstance(condition, NoneCondition)
-                else condition_latex_repr(condition) + r"\land "
-            )
-        # for_all_str = for_all_str.rstrip(', ')
-        latex_str += rf"\ {for_all_str}"
-
-        condition_str = condition_str.rstrip(r"\land ")
-        if condition_str != "":
-            latex_str += rf" \ {condition_str}"
-
-    return latex_str
-
-
-def problem_latex_repr(problem: Problem) -> str:
-    name = escape_latex_special_character(problem.name)
-    latex_str = rf"\text{{Problem}} & \text{{: {name}}} \\"
-    if problem.sense == ProblemSense.MAXIMUM:
-        latex_str += rf"\max & \quad {problem.objective._make_latex()} \\"
-    else:
-        latex_str += rf"\min & \quad {problem.objective._make_latex()} \\"
-
-    # case: Problem has more than one penalties.
-    if len(problem.penalties) > 0:
-        latex_str += r"\text{Penalties} & \\"
-        # Shows all penalties.
-        for penalty in problem.penalties.values():
-            latex_str += rf"& {penalty_latex_repr(penalty)}\\[8pt]"
-
-    # case: Problem has more than one constraints.
-    if len(problem.constraints) > 0:
-        latex_str += r"\text{s.t.} & \\"
-        # show all constraints
-        for _, constraint in problem.constraints.items():
-            latex_str += rf"& {constraint_latex_repr(constraint)}\\[8pt]"
-
-    latex_str += "&"
-
-    # Extracts all decision variables from the Problem object.
-    deci_var_list = {
-        var.label: var
-        for var in extract_vars_from_problem(problem)
-        if isinstance(var, DecisionVariable)
-    }
-
-    # Checks if the problem does not have any decision variable
-    if deci_var_list == {}:
-        return latex_str
-
-    used_decision_variable = ""
-    for deci_var in deci_var_list.values():
-        label = deci_var._make_latex()
-        has_subscripts = deci_var.dim > 0
-        if has_subscripts:
-            subscripts = ""
-            for i in range(deci_var.dim):
-                subscripts += rf"i_{{{format(str(i))}}},"
-            subscripts = subscripts.rstrip(",")
-
-            used_decision_variable += rf"{label}_{{{subscripts}}}"
-        else:
-            used_decision_variable += label
-
-        # case: Binary
-        if isinstance(deci_var, Binary):
-            used_decision_variable += r" \in \{0, 1\}"
-        # case: Integer
-        elif isinstance(deci_var, Integer):
-            used_decision_variable += r" \in \mathbb{Z}"
-
-        used_decision_variable += r",\ "
-    used_decision_variable = used_decision_variable.rstrip(r",\ ")
-
-    return rf"{latex_str} {used_decision_variable}"

jijmodeling/match/__init__.py

@@ -1,19 +0,0 @@
-from pkgutil import extend_path
-
-__path__ = extend_path(__path__, __name__)
-
-import jijmodeling.match.condition_same as condition_same
-import jijmodeling.match.constraint_same as constraint_same
-import jijmodeling.match.expr_same as expr_same
-import jijmodeling.match.is_same_expr as is_same_expr
-import jijmodeling.match.penalty_same as penalty_same
-import jijmodeling.match.problem_same as problem_same
-
-__all__ = [
-    "condition_same",
-    "constraint_same",
-    "expr_same",
-    "is_same_expr",
-    "penalty_same",
-    "problem_same",
-]

jijmodeling/match/condition_same.py

@@ -1,44 +0,0 @@
-from __future__ import annotations
-
-import jijmodeling.expression.condition as _condition
-
-from jijmodeling.match.expr_same import expr_same
-
-
-def condition_same(
-    target: _condition.Condition, pattern: _condition.Condition, check_id: bool = True
-) -> bool:
-    if target.uuid == pattern.uuid:
-        return True
-    if not isinstance(target, type(pattern)):
-        return False
-
-    # case: CompareCondition
-    if isinstance(target, _condition.CompareCondition) and isinstance(
-        pattern, _condition.CompareCondition
-    ):
-        # Check the equality of left hand side
-        is_left_same = expr_same(target.left, pattern.left, check_id)
-        if is_left_same is False:
-            return False
-
-        # Check the equality of right hand side
-        is_right_same = expr_same(target.right, pattern.right, check_id)
-        if is_right_same is False:
-            return False
-        return True
-
-    # case: ConditionOperator
-    elif isinstance(target, _condition.ConditionOperator) and isinstance(
-        pattern, _condition.ConditionOperator
-    ):
-        return condition_same(target.left, pattern.left, check_id) & condition_same(
-            target.right, pattern.left, check_id
-        )
-
-    elif isinstance(target, _condition.NoneCondition) and isinstance(
-        pattern, _condition.NoneCondition
-    ):
-        return True
-
-    return False

jijmodeling/match/constraint_same.py

@@ -1,53 +0,0 @@
-from __future__ import annotations
-
-import jijmodeling.expression.constraint as _constraint
-import jijmodeling.expression.expression as _expression
-
-from jijmodeling.match.condition_same import condition_same
-from jijmodeling.match.expr_same import expr_same
-
-
-def constraint_same(
-    target: _constraint.Constraint,
-    pattern: _constraint.Constraint,
-    check_id: bool = True,
-) -> bool:
-    # Is the same label?
-    if target.label != pattern.label:
-        return False
-    # Is the same `with_penalty`?
-    if target.with_penalty != pattern.with_penalty:
-        return False
-    # Is the same `with_multiplier`?
-    if target.with_multiplier != pattern.with_multiplier:
-        return False
-    # Is the same `auto_qubo`?
-    if target.auto_qubo != pattern.auto_qubo:
-        return False
-    # Is the same `condition`?
-    if condition_same(target.condition, pattern.condition, check_id) is False:
-        return False
-    # Is the same `left_lower`?
-    if target.left_lower is None and pattern.left_lower is None:
-        is_same_left_lower = True
-    elif isinstance(target.left_lower, _expression.Expression) and isinstance(
-        pattern.left_lower, _expression.Expression
-    ):
-        is_same_left_lower = expr_same(target.left_lower, pattern.left_lower, check_id)
-    else:
-        return False
-    if is_same_left_lower is False:
-        return False
-    # Is the same `forall`?
-    if len(target.forall) != len(pattern.forall):
-        return False
-    for target_forall, pattern_forall in zip(target.forall, pattern.forall):
-        target_element, target_condition = target_forall
-        pattern_element, pattern_condition = pattern_forall
-        is_same_forall = expr_same(
-            target_element, pattern_element, check_id
-        ) and condition_same(target_condition, pattern_condition, check_id)
-
-        if is_same_forall is False:
-            return False
-    return True

jijmodeling/match/expr_same.py

@@ -1,23 +0,0 @@
-from __future__ import annotations
-
-from typing import Union
-
-from jijmodeling.expression.condition import Condition
-from jijmodeling.expression.expression import Expression
-from jijmodeling.expression.variables.variable import Range
-from jijmodeling.match.is_same_expr import ExpressionType, is_same_cond, is_same_expr
-
-
-def expr_same(
-    target: Union[ExpressionType, Condition],
-    pattern: Union[ExpressionType, Condition],
-    check_id: bool = True,
-) -> bool:
-    if isinstance(target, (Expression, Range)) and isinstance(
-        pattern, (Expression, Range)
-    ):
-        return is_same_expr(target, pattern, check_id)
-    elif isinstance(target, Condition) and isinstance(pattern, Condition):
-        return is_same_cond(target, pattern, check_id)
-    else:
-        return False