| import math
|
|
|
| from typing import Any, Callable, Mapping
|
|
|
| DEFAULT_INT = ("INT", {"default": 0})
|
|
|
| INT_UNARY_OPERATIONS: Mapping[str, Callable[[int], int]] = {
|
| "Abs": lambda a: abs(a),
|
| "Neg": lambda a: -a,
|
| "Inc": lambda a: a + 1,
|
| "Dec": lambda a: a - 1,
|
| "Sqr": lambda a: a * a,
|
| "Cube": lambda a: a * a * a,
|
| "Not": lambda a: ~a,
|
| "Factorial": lambda a: math.factorial(a),
|
| }
|
|
|
| INT_UNARY_CONDITIONS: Mapping[str, Callable[[int], bool]] = {
|
| "IsZero": lambda a: a == 0,
|
| "IsNonZero": lambda a: a != 0,
|
| "IsPositive": lambda a: a > 0,
|
| "IsNegative": lambda a: a < 0,
|
| "IsEven": lambda a: a % 2 == 0,
|
| "IsOdd": lambda a: a % 2 == 1,
|
| }
|
|
|
| INT_BINARY_OPERATIONS: Mapping[str, Callable[[int, int], int]] = {
|
| "Add": lambda a, b: a + b,
|
| "Sub": lambda a, b: a - b,
|
| "Mul": lambda a, b: a * b,
|
| "Div": lambda a, b: a // b,
|
| "Mod": lambda a, b: a % b,
|
| "Pow": lambda a, b: a**b,
|
| "And": lambda a, b: a & b,
|
| "Nand": lambda a, b: ~a & b,
|
| "Or": lambda a, b: a | b,
|
| "Nor": lambda a, b: ~a & b,
|
| "Xor": lambda a, b: a ^ b,
|
| "Xnor": lambda a, b: ~a ^ b,
|
| "Shl": lambda a, b: a << b,
|
| "Shr": lambda a, b: a >> b,
|
| "Max": lambda a, b: max(a, b),
|
| "Min": lambda a, b: min(a, b),
|
| }
|
|
|
| INT_BINARY_CONDITIONS: Mapping[str, Callable[[int, int], bool]] = {
|
| "Eq": lambda a, b: a == b,
|
| "Neq": lambda a, b: a != b,
|
| "Gt": lambda a, b: a > b,
|
| "Lt": lambda a, b: a < b,
|
| "Geq": lambda a, b: a >= b,
|
| "Leq": lambda a, b: a <= b,
|
| }
|
|
|
|
|
| class IntUnaryOperation:
|
| @classmethod
|
| def INPUT_TYPES(cls) -> Mapping[str, Any]:
|
| return {
|
| "required": {"op": (list(INT_UNARY_OPERATIONS.keys()),), "a": DEFAULT_INT}
|
| }
|
|
|
| RETURN_TYPES = ("INT",)
|
| FUNCTION = "op"
|
| CATEGORY = "math/int"
|
|
|
| def op(self, op: str, a: int) -> tuple[int]:
|
| return (INT_UNARY_OPERATIONS[op](a),)
|
|
|
|
|
| class IntUnaryCondition:
|
| @classmethod
|
| def INPUT_TYPES(cls) -> Mapping[str, Any]:
|
| return {
|
| "required": {"op": (list(INT_UNARY_CONDITIONS.keys()),), "a": DEFAULT_INT}
|
| }
|
|
|
| RETURN_TYPES = ("BOOL",)
|
| FUNCTION = "op"
|
| CATEGORY = "math/int"
|
|
|
| def op(self, op: str, a: int) -> tuple[bool]:
|
| return (INT_UNARY_CONDITIONS[op](a),)
|
|
|
|
|
| class IntBinaryOperation:
|
| @classmethod
|
| def INPUT_TYPES(cls) -> Mapping[str, Any]:
|
| return {
|
| "required": {
|
| "op": (list(INT_BINARY_OPERATIONS.keys()),),
|
| "a": DEFAULT_INT,
|
| "b": DEFAULT_INT,
|
| }
|
| }
|
|
|
| RETURN_TYPES = ("INT",)
|
| FUNCTION = "op"
|
| CATEGORY = "math/int"
|
|
|
| def op(self, op: str, a: int, b: int) -> tuple[int]:
|
| return (INT_BINARY_OPERATIONS[op](a, b),)
|
|
|
|
|
| class IntBinaryCondition:
|
| @classmethod
|
| def INPUT_TYPES(cls) -> Mapping[str, Any]:
|
| return {
|
| "required": {
|
| "op": (list(INT_BINARY_CONDITIONS.keys()),),
|
| "a": DEFAULT_INT,
|
| "b": DEFAULT_INT,
|
| }
|
| }
|
|
|
| RETURN_TYPES = ("BOOL",)
|
| FUNCTION = "op"
|
| CATEGORY = "math/int"
|
|
|
| def op(self, op: str, a: int, b: int) -> tuple[bool]:
|
| return (INT_BINARY_CONDITIONS[op](a, b),)
|
|
|
|
|
| NODE_CLASS_MAPPINGS = {
|
| "CM_IntUnaryOperation": IntUnaryOperation,
|
| "CM_IntUnaryCondition": IntUnaryCondition,
|
| "CM_IntBinaryOperation": IntBinaryOperation,
|
| "CM_IntBinaryCondition": IntBinaryCondition,
|
| }
|
|
|
