binary-equalab 1.0.0__py3-none-any.whl

binary_equalab/__init__.py

@@ -0,0 +1,23 @@
+"""
+Binary EquaLab CLI
+Command-line CAS calculator with Spanish math functions.
+"""
+
+__version__ = "1.0.0"
+__author__ = "BinaryEquaLab Team"
+
+from .engine import MathEngine
+from .functions import (
+    derivar, integrar, limite, sumatoria,
+    simplificar, expandir, factorizar, resolver,
+    van, tir, depreciar, interes_simple, interes_compuesto,
+    media, mediana, desviacion, varianza
+)
+
+__all__ = [
+    "MathEngine",
+    "derivar", "integrar", "limite", "sumatoria",
+    "simplificar", "expandir", "factorizar", "resolver",
+    "van", "tir", "depreciar", "interes_simple", "interes_compuesto",
+    "media", "mediana", "desviacion", "varianza",
+]

binary_equalab/cli.py

@@ -0,0 +1,180 @@
+"""
+Binary EquaLab CLI
+Interactive REPL and command-line interface.
+"""
+
+import sys
+from typing import Optional
+from rich.console import Console
+from rich.panel import Panel
+from rich.markdown import Markdown
+from rich.text import Text
+from prompt_toolkit import PromptSession
+from prompt_toolkit.history import FileHistory
+from prompt_toolkit.auto_suggest import AutoSuggestFromHistory
+from prompt_toolkit.styles import Style
+import os
+
+from .engine import MathEngine
+
+console = Console()
+
+BANNER = """
+[bold orange1]╔══════════════════════════════════════════════════════════╗
+║    [white]Binary EquaLab CLI[/white]   [dim]v1.0.0[/dim]                          ║
+║    [dim italic]"El álgebra también siente"[/dim italic]                           ║
+╚══════════════════════════════════════════════════════════╝[/bold orange1]
+
+[dim]Comandos:[/dim]
+  [cyan]help[/cyan]     - Lista de funciones disponibles
+  [cyan]exit[/cyan]     - Salir
+  [cyan]cls[/cyan]      - Limpiar pantalla
+  
+[dim]Ejemplos:[/dim]
+  derivar(x^2 + 3x, x)
+  integrar(sin(x), x)
+  van(0.10, -1000, 300, 400, 500)
+"""
+
+HELP_TEXT = """
+## Funciones Disponibles
+
+### Cálculo
+| Función | Ejemplo |
+|---------|---------|
+| `derivar(expr, var)` | `derivar(x^2, x)` → `2*x` |
+| `integrar(expr, var)` | `integrar(sin(x), x)` → `-cos(x)` |
+| `limite(expr, var, punto)` | `limite(sin(x)/x, x, 0)` → `1` |
+| `sumatoria(expr, var, a, b)` | `sumatoria(n^2, n, 1, 10)` |
+
+### Álgebra
+| Función | Ejemplo |
+|---------|---------|
+| `simplificar(expr)` | `simplificar((x^2-1)/(x-1))` |
+| `expandir(expr)` | `expandir((x+1)^2)` |
+| `factorizar(expr)` | `factorizar(x^2-1)` |
+| `resolver(expr, var)` | `resolver(x^2-4, x)` → `[-2, 2]` |
+
+### Estadística
+| Función | Ejemplo |
+|---------|---------|
+| `media(...)` | `media(1, 2, 3, 4, 5)` → `3` |
+| `mediana(...)` | `mediana(1, 2, 3, 4, 5)` → `3` |
+| `desviacion(...)` | `desviacion(1, 2, 3, 4, 5)` |
+| `varianza(...)` | `varianza(1, 2, 3, 4, 5)` |
+
+### Finanzas
+| Función | Ejemplo |
+|---------|---------|
+| `van(tasa, flujo0, flujo1, ...)` | `van(0.10, -1000, 300, 400)` |
+| `tir(flujo0, flujo1, ...)` | `tir(-1000, 300, 400, 500)` |
+| `depreciar(costo, residual, años)` | `depreciar(10000, 1000, 5)` |
+| `interes_simple(capital, tasa, tiempo)` | `interes_simple(1000, 0.05, 3)` |
+| `interes_compuesto(capital, tasa, n, tiempo)` | `interes_compuesto(1000, 0.05, 12, 3)` |
+"""
+
+
+def get_prompt_style():
+    return Style.from_dict({
+        'prompt': '#ff6b35 bold',
+    })
+
+
+def repl():
+    """Start the interactive REPL."""
+    console.print(BANNER)
+    
+    engine = MathEngine()
+    
+    # Setup history file
+    history_path = os.path.expanduser("~/.binary_math_history")
+    session: PromptSession = PromptSession(
+        history=FileHistory(history_path),
+        auto_suggest=AutoSuggestFromHistory(),
+        style=get_prompt_style(),
+    )
+    
+    while True:
+        try:
+            # Read input
+            user_input = session.prompt([('class:prompt', '>>> ')]).strip()
+            
+            if not user_input:
+                continue
+            
+            # Handle special commands
+            if user_input.lower() in ('exit', 'quit', 'q'):
+                console.print("[dim]¡Hasta luego![/dim]")
+                break
+            
+            if user_input.lower() in ('cls', 'clear'):
+                console.clear()
+                console.print(BANNER)
+                continue
+            
+            if user_input.lower() == 'help':
+                console.print(Markdown(HELP_TEXT))
+                continue
+            
+            if user_input.lower() == 'history':
+                for i, h in enumerate(engine.history[-10:], 1):
+                    console.print(f"[dim]{i}.[/dim] {h}")
+                continue
+            
+            # Evaluate expression
+            try:
+                result = engine.evaluate(user_input)
+                
+                if result is None:
+                    continue
+                
+                # Format output
+                if isinstance(result, (list, tuple)):
+                    console.print(f"[bold green]→[/bold green] {list(result)}")
+                elif isinstance(result, dict):
+                    for key, value in result.items():
+                        console.print(f"  [cyan]{key}:[/cyan] {value}")
+                else:
+                    console.print(f"[bold green]→[/bold green] {result}")
+                    
+            except Exception as e:
+                console.print(f"[bold red]Error:[/bold red] {e}")
+                
+        except KeyboardInterrupt:
+            console.print()
+            continue
+        except EOFError:
+            console.print("\n[dim]¡Hasta luego![/dim]")
+            break
+
+
+def one_liner(expression: str):
+    """Evaluate a single expression from command line."""
+    engine = MathEngine()
+    try:
+        result = engine.evaluate(expression)
+        if isinstance(result, (list, tuple)):
+            print(list(result))
+        elif isinstance(result, dict):
+            for key, value in result.items():
+                print(f"{key}: {value}")
+        else:
+            print(result)
+    except Exception as e:
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)
+
+
+def main():
+    """CLI entry point."""
+    if len(sys.argv) > 1:
+        # One-liner mode
+        expression = " ".join(sys.argv[1:])
+        one_liner(expression)
+    else:
+        # REPL mode
+        repl()
+
+
+if __name__ == "__main__":
+    main()

binary_equalab/engine.py

@@ -0,0 +1,405 @@
+"""
+Binary EquaLab - Math Engine
+Core symbolic computation using SymPy with Spanish function translations.
+"""
+
+import sympy as sp
+from sympy import (
+    Symbol, symbols, sin, cos, tan, sqrt, exp, log, ln, pi, E, I,
+    diff, integrate, limit, summation, simplify, expand, factor, solve,
+    Abs, factorial, gamma, binomial, floor, ceiling,
+    Matrix, det, Transpose
+)
+from sympy.parsing.sympy_parser import (
+    parse_expr, standard_transformations, implicit_multiplication_application,
+    convert_xor, function_exponentiation
+)
+from typing import Any, Union, List, Optional
+import re
+
+# Symbol shortcuts
+x, y, z, t, n, k = symbols('x y z t n k')
+
+
+class MathEngine:
+    """
+    Core math engine with Spanish function support.
+    Wraps SymPy with user-friendly Spanish aliases.
+    """
+    
+    def __init__(self):
+        self.symbols = {'x': x, 'y': y, 'z': z, 't': t, 'n': n, 'k': k}
+        self.last_result = None
+        self.history: List[str] = []
+        
+        # Spanish → SymPy function mapping
+        self.function_map = {
+            # Calculus
+            'derivar': self._derivar,
+            'integrar': self._integrar,
+            'limite': self._limite,
+            'sumatoria': self._sumatoria,
+            
+            # Algebra
+            'simplificar': self._simplificar,
+            'expandir': self._expandir,
+            'factorizar': self._factorizar,
+            'resolver': self._resolver,
+            
+            # Statistics
+            'media': self._media,
+            'mediana': self._mediana,
+            'desviacion': self._desviacion,
+            'varianza': self._varianza,
+            
+            # Finance
+            'van': self._van,
+            'tir': self._tir,
+            'depreciar': self._depreciar,
+            'interes_simple': self._interes_simple,
+            'interes_compuesto': self._interes_compuesto,
+            
+            # Trigonometry aliases
+            'seno': sin,
+            'coseno': cos,
+            'tangente': tan,
+            'arcoseno': sp.asin,
+            'arcocoseno': sp.acos,
+            'arcotangente': sp.atan,
+        }
+    
+    def parse(self, expression: str) -> Any:
+        """Parse a math expression string into SymPy."""
+        # Preprocess Spanish functions
+        expr = self._preprocess(expression)
+        
+        # Parse with transformations
+        transformations = (
+            standard_transformations + 
+            (implicit_multiplication_application, convert_xor, function_exponentiation)
+        )
+        
+        try:
+            result = parse_expr(expr, local_dict=self.symbols, transformations=transformations)
+            return result
+        except Exception as e:
+            raise ValueError(f"Parse error: {e}")
+    
+    def evaluate(self, expression: str) -> Any:
+        """Evaluate a math expression and return the result."""
+        expression = expression.strip()
+        
+        if not expression:
+            return None
+            
+        self.history.append(expression)
+        
+        # Check for function calls
+        for func_name, func in self.function_map.items():
+            if expression.startswith(f'{func_name}('):
+                result = self._call_function(expression)
+                self.last_result = result
+                return result
+        
+        # Standard expression evaluation
+        try:
+            parsed = self.parse(expression)
+            result = sp.simplify(parsed)
+            self.last_result = result
+            return result
+        except Exception as e:
+            raise ValueError(f"Evaluation error: {e}")
+    
+    def _preprocess(self, expr: str) -> str:
+        """Convert Spanish function names and shortcuts."""
+        # Replace Spanish trig
+        replacements = {
+            'seno': 'sin',
+            'coseno': 'cos', 
+            'tangente': 'tan',
+            'arcoseno': 'asin',
+            'arcocoseno': 'acos',
+            'arcotangente': 'atan',
+            'raiz': 'sqrt',
+            'absoluto': 'Abs',
+            'logaritmo': 'log',
+            'exponencial': 'exp',
+        }
+        
+        for es, en in replacements.items():
+            expr = re.sub(rf'\b{es}\b', en, expr, flags=re.IGNORECASE)
+        
+        # Handle ^ as power
+        expr = expr.replace('^', '**')
+        
+        return expr
+    
+    def _call_function(self, expression: str) -> Any:
+        """Call a Spanish function with arguments."""
+        # Extract function name and args
+        match = re.match(r'(\w+)\((.*)\)$', expression, re.DOTALL)
+        if not match:
+            raise ValueError(f"Invalid function call: {expression}")
+        
+        func_name = match.group(1)
+        args_str = match.group(2)
+        
+        if func_name not in self.function_map:
+            raise ValueError(f"Unknown function: {func_name}")
+        
+        func = self.function_map[func_name]
+        
+        # Parse arguments
+        args = self._parse_args(args_str)
+        
+        return func(*args)
+    
+    def _parse_args(self, args_str: str) -> List[Any]:
+        """Parse function arguments, handling nested parentheses."""
+        args = []
+        current = ""
+        depth = 0
+        
+        for char in args_str:
+            if char == '(':
+                depth += 1
+                current += char
+            elif char == ')':
+                depth -= 1
+                current += char
+            elif char == ',' and depth == 0:
+                if current.strip():
+                    args.append(self._parse_single_arg(current.strip()))
+                current = ""
+            else:
+                current += char
+        
+        if current.strip():
+            args.append(self._parse_single_arg(current.strip()))
+        
+        return args
+    
+    def _parse_single_arg(self, arg: str) -> Any:
+        """Parse a single argument - could be number, symbol, or expression."""
+        try:
+            return float(arg)
+        except ValueError:
+            pass
+        
+        if arg in self.symbols:
+            return self.symbols[arg]
+        
+        return self.parse(arg)
+    
+    # ============ CALCULUS ============
+    
+    def _derivar(self, expr, var=None, n=1):
+        """Derivative: derivar(x^2 + 3x, x) → 2x + 3"""
+        if var is None:
+            var = x
+        return diff(expr, var, n)
+    
+    def _integrar(self, expr, var=None, a=None, b=None):
+        """Integral: integrar(x^2, x) or integrar(x^2, x, 0, 1)"""
+        if var is None:
+            var = x
+        if a is not None and b is not None:
+            return integrate(expr, (var, a, b))
+        return integrate(expr, var)
+    
+    def _limite(self, expr, var=None, punto=0, direccion=None):
+        """Limit: limite(sin(x)/x, x, 0) → 1"""
+        if var is None:
+            var = x
+        if direccion:
+            return limit(expr, var, punto, direccion)
+        return limit(expr, var, punto)
+    
+    def _sumatoria(self, expr, var=None, a=0, b=10):
+        """Sum: sumatoria(n^2, n, 1, 10) → 385"""
+        if var is None:
+            var = n
+        return summation(expr, (var, a, b))
+    
+    # ============ ALGEBRA ============
+    
+    def _simplificar(self, expr):
+        """Simplify: simplificar((x^2-1)/(x-1)) → x+1"""
+        return simplify(expr)
+    
+    def _expandir(self, expr):
+        """Expand: expandir((x+1)^2) → x^2 + 2x + 1"""
+        return expand(expr)
+    
+    def _factorizar(self, expr):
+        """Factor: factorizar(x^2 - 1) → (x-1)(x+1)"""
+        return factor(expr)
+    
+    def _resolver(self, expr, var=None):
+        """Solve: resolver(x^2 - 4, x) → [-2, 2]"""
+        if var is None:
+            var = x
+        return solve(expr, var)
+    
+    # ============ STATISTICS ============
+    
+    def _media(self, *values):
+        """Mean: media(1, 2, 3, 4, 5) → 3"""
+        nums = [float(v) for v in values]
+        return sum(nums) / len(nums)
+    
+    def _mediana(self, *values):
+        """Median: mediana(1, 2, 3, 4, 5) → 3"""
+        nums = sorted([float(v) for v in values])
+        n = len(nums)
+        mid = n // 2
+        if n % 2 == 0:
+            return (nums[mid - 1] + nums[mid]) / 2
+        return nums[mid]
+    
+    def _desviacion(self, *values):
+        """Standard deviation: desviacion(1, 2, 3, 4, 5)"""
+        nums = [float(v) for v in values]
+        mean = sum(nums) / len(nums)
+        variance = sum((x - mean) ** 2 for x in nums) / len(nums)
+        return variance ** 0.5
+    
+    def _varianza(self, *values):
+        """Variance: varianza(1, 2, 3, 4, 5)"""
+        nums = [float(v) for v in values]
+        mean = sum(nums) / len(nums)
+        return sum((x - mean) ** 2 for x in nums) / len(nums)
+    
+    # ============ FINANCE ============
+    
+    def _van(self, tasa, *flujos):
+        """NPV: van(0.10, -1000, 300, 400, 500)"""
+        r = float(tasa)
+        result = 0
+        for i, flujo in enumerate(flujos):
+            result += float(flujo) / ((1 + r) ** i)
+        return round(result, 2)
+    
+    def _tir(self, *flujos):
+        """IRR: tir(-1000, 300, 400, 500) using Newton-Raphson"""
+        flows = [float(f) for f in flujos]
+        
+        def npv(r):
+            return sum(f / ((1 + r) ** i) for i, f in enumerate(flows))
+        
+        def npv_deriv(r):
+            return sum(-i * f / ((1 + r) ** (i + 1)) for i, f in enumerate(flows))
+        
+        r = 0.1  # Initial guess
+        for _ in range(100):
+            npv_val = npv(r)
+            if abs(npv_val) < 1e-10:
+                break
+            deriv = npv_deriv(r)
+            if deriv == 0:
+                break
+            r = r - npv_val / deriv
+        
+        return round(r * 100, 2)  # Return as percentage
+    
+    def _depreciar(self, costo, residual, años):
+        """Straight-line depreciation: depreciar(10000, 1000, 5)"""
+        c, r, n = float(costo), float(residual), int(años)
+        annual = (c - r) / n
+        schedule = []
+        for i in range(n):
+            schedule.append({
+                'año': i + 1,
+                'depreciacion': round(annual, 2),
+                'acumulado': round(annual * (i + 1), 2),
+                'valor_libro': round(c - annual * (i + 1), 2)
+            })
+        return schedule
+    
+    def _interes_simple(self, capital, tasa, tiempo):
+        """Simple interest: interes_simple(1000, 0.05, 3)"""
+        c, r, t = float(capital), float(tasa), float(tiempo)
+        interest = c * r * t
+        return {
+            'interes': round(interest, 2),
+            'monto_final': round(c + interest, 2)
+        }
+    
+    def _interes_compuesto(self, capital, tasa, n, tiempo):
+        """Compound interest: interes_compuesto(1000, 0.05, 12, 3)"""
+        c, r, periods, t = float(capital), float(tasa), int(n), float(tiempo)
+        monto = c * ((1 + r / periods) ** (periods * t))
+        return {
+            'monto_final': round(monto, 2),
+            'interes': round(monto - c, 2)
+        }
+
+
+# Convenience functions for direct import
+def derivar(expr, var=None, n=1):
+    engine = MathEngine()
+    return engine._derivar(engine.parse(str(expr)), var, n)
+
+def integrar(expr, var=None, a=None, b=None):
+    engine = MathEngine()
+    return engine._integrar(engine.parse(str(expr)), var, a, b)
+
+def limite(expr, var=None, punto=0):
+    engine = MathEngine()
+    return engine._limite(engine.parse(str(expr)), var, punto)
+
+def sumatoria(expr, var=None, a=0, b=10):
+    engine = MathEngine()
+    return engine._sumatoria(engine.parse(str(expr)), var, a, b)
+
+def simplificar(expr):
+    engine = MathEngine()
+    return engine._simplificar(engine.parse(str(expr)))
+
+def expandir(expr):
+    engine = MathEngine()
+    return engine._expandir(engine.parse(str(expr)))
+
+def factorizar(expr):
+    engine = MathEngine()
+    return engine._factorizar(engine.parse(str(expr)))
+
+def resolver(expr, var=None):
+    engine = MathEngine()
+    return engine._resolver(engine.parse(str(expr)), var)
+
+def van(tasa, *flujos):
+    engine = MathEngine()
+    return engine._van(tasa, *flujos)
+
+def tir(*flujos):
+    engine = MathEngine()
+    return engine._tir(*flujos)
+
+def depreciar(costo, residual, años):
+    engine = MathEngine()
+    return engine._depreciar(costo, residual, años)
+
+def interes_simple(capital, tasa, tiempo):
+    engine = MathEngine()
+    return engine._interes_simple(capital, tasa, tiempo)
+
+def interes_compuesto(capital, tasa, n, tiempo):
+    engine = MathEngine()
+    return engine._interes_compuesto(capital, tasa, n, tiempo)
+
+def media(*values):
+    engine = MathEngine()
+    return engine._media(*values)
+
+def mediana(*values):
+    engine = MathEngine()
+    return engine._mediana(*values)
+
+def desviacion(*values):
+    engine = MathEngine()
+    return engine._desviacion(*values)
+
+def varianza(*values):
+    engine = MathEngine()
+    return engine._varianza(*values)

binary_equalab/functions.py

@@ -0,0 +1,18 @@
+"""
+Binary EquaLab - Exported Functions
+Convenience re-exports for direct import usage.
+"""
+
+from .engine import (
+    derivar, integrar, limite, sumatoria,
+    simplificar, expandir, factorizar, resolver,
+    van, tir, depreciar, interes_simple, interes_compuesto,
+    media, mediana, desviacion, varianza
+)
+
+__all__ = [
+    "derivar", "integrar", "limite", "sumatoria",
+    "simplificar", "expandir", "factorizar", "resolver",
+    "van", "tir", "depreciar", "interes_simple", "interes_compuesto",
+    "media", "mediana", "desviacion", "varianza",
+]

binary_equalab-1.0.0.dist-info/METADATA

@@ -0,0 +1,160 @@
+Metadata-Version: 2.4
+Name: binary-equalab
+Version: 1.0.0
+Summary: Command-line CAS calculator with Spanish math functions
+Project-URL: Homepage, https://github.com/Malexnnn/BinaryEquaLab
+Project-URL: Repository, https://github.com/Malexnnn/BinaryEquaLab
+Project-URL: Documentation, https://github.com/Malexnnn/BinaryEquaLab#readme
+Author: BinaryEquaLab Team
+License-Expression: MIT
+Keywords: algebra,calculator,calculus,cas,math,spanish,symbolic
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Education
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Requires-Python: >=3.9
+Requires-Dist: numpy>=1.24
+Requires-Dist: prompt-toolkit>=3.0
+Requires-Dist: rich>=13.0
+Requires-Dist: sympy>=1.12
+Provides-Extra: dev
+Requires-Dist: black>=23.0; extra == 'dev'
+Requires-Dist: mypy>=1.0; extra == 'dev'
+Requires-Dist: pytest-cov>=4.0; extra == 'dev'
+Requires-Dist: pytest>=7.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# Binary EquaLab CLI
+
+<p align="center">
+  <img src="../docs/banner_cli.png" alt="Binary EquaLab CLI" width="500">
+</p>
+
+<p align="center">
+  <em>⌨️ Calculadora CAS en la terminal</em>
+</p>
+
+---
+
+## 🚀 Installation
+
+```bash
+pip install binary-equalab
+```
+
+Or from source:
+```bash
+cd binary-cli
+pip install -e .
+```
+
+---
+
+## 📖 Usage
+
+### REPL Mode
+```bash
+binary-math
+```
+
+```
+Binary EquaLab CLI v1.0.0
+>>> derivar(x^2 + 3x, x)
+→ 2*x + 3
+
+>>> integrar(sin(x), x)
+→ -cos(x)
+
+>>> factorial(5)
+→ 120
+
+>>> van(0.10, -1000, 300, 400, 500)
+→ 78.82
+```
+
+### One-liner Mode
+```bash
+binary-math "derivar(x^3, x)"
+# Output: 3*x^2
+
+binary-math "factorial(10)"
+# Output: 3628800
+
+binary-math "0b1010 + 0b0101"
+# Output: 15
+```
+
+---
+
+## 🔢 Functions
+
+### Calculus
+| Function                | Example                    | Result    |
+| ----------------------- | -------------------------- | --------- |
+| `derivar(f, x)`         | `derivar(x^2, x)`          | `2*x`     |
+| `integrar(f, x)`        | `integrar(sin(x), x)`      | `-cos(x)` |
+| `limite(f, x, a)`       | `limite(sin(x)/x, x, 0)`   | `1`       |
+| `sumatoria(f, n, a, b)` | `sumatoria(n^2, n, 1, 10)` | `385`     |
+
+### Algebra
+| Function         | Example                      | Result        |
+| ---------------- | ---------------------------- | ------------- |
+| `simplificar(f)` | `simplificar((x^2-1)/(x-1))` | `x+1`         |
+| `expandir(f)`    | `expandir((x+1)^2)`          | `x^2+2*x+1`   |
+| `factorizar(f)`  | `factorizar(x^2-1)`          | `(x-1)*(x+1)` |
+| `resolver(f, x)` | `resolver(x^2-4, x)`         | `[-2, 2]`     |
+
+### Statistics
+| Function          | Example                        |
+| ----------------- | ------------------------------ |
+| `media(...)`      | `media(1, 2, 3, 4, 5)` → `3`   |
+| `mediana(...)`    | `mediana(1, 2, 3, 4, 5)` → `3` |
+| `desviacion(...)` | Standard deviation             |
+| `varianza(...)`   | Variance                       |
+
+### Finance
+| Function                        | Example                                |
+| ------------------------------- | -------------------------------------- |
+| `van(r, cf0, cf1, ...)`         | `van(0.10, -1000, 300, 400)`           |
+| `tir(cf0, cf1, ...)`            | `tir(-1000, 300, 400, 500)`            |
+| `depreciar(cost, res, years)`   | `depreciar(10000, 1000, 5)`            |
+| `interes_simple(c, r, t)`       | `interes_simple(1000, 0.05, 3)`        |
+| `interes_compuesto(c, r, n, t)` | `interes_compuesto(1000, 0.05, 12, 3)` |
+
+### Number Systems
+```
+0b1010    → 10   (binary)
+0xFF      → 255  (hexadecimal)
+0o17      → 15   (octal)
+```
+
+---
+
+## 🥚 Easter Eggs
+
+Try these:
+- `1+1`
+- `(-1)*(-1)`
+- `0b101010`
+
+---
+
+## 🛠️ Development
+
+```bash
+cd binary-cli
+pip install -e ".[dev]"
+pytest
+```
+
+---
+
+MIT © Malexnnn/ Aldra ORG.

binary_equalab-1.0.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+binary_equalab/__init__.py,sha256=h6Fi1RtNgWo6PnSqoRZX1ee2uvn9faJfneI16L14XR8,652
+binary_equalab/cli.py,sha256=mepUJ_5XBz93k0edpVsXXhgEgt1EqXEHJJ-K6cx69Vw,5759
+binary_equalab/engine.py,sha256=KTlpNvHMTODAl1haTw8tZUfxqU9CHNMx4XqVtyAa_SY,12831
+binary_equalab/functions.py,sha256=czx4m5ZZP8VL27TdC6p8cH4FNpkabTF-EymP5iC64nw,551
+binary_equalab-1.0.0.dist-info/METADATA,sha256=sCqgMV3c2YMq2Gn8c53IZ1N_o-hU0D24juie3yUHoiU,4215
+binary_equalab-1.0.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+binary_equalab-1.0.0.dist-info/entry_points.txt,sha256=KAAmBj-EOydDlCxIFK_NycbqimMK9_yp_VODFvoaaEI,86
+binary_equalab-1.0.0.dist-info/RECORD,,

binary_equalab-1.0.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any

binary_equalab-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+beq = binary_equalab.cli:main
+binary-math = binary_equalab.cli:main