binary-equalab 1.0.0__py3-none-any.whl → 2.0.1__py3-none-any.whl

binary_equalab/functions.py

@@ -1,18 +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 - 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/geometry.py

@@ -0,0 +1,69 @@
+
+from sympy import Point, Line, N, simplify, symbols, var
+import sympy as sp
+
+class GeometryEngine:
+    """
+    Geometry extraction from GeoGebra concepts.
+    Handles 2D analytic geometry.
+    """
+    
+    @staticmethod
+    def _parse_point(p):
+        """Convert input (tuple, list, or existing Point) to SymPy Point."""
+        if isinstance(p, (tuple, list)):
+            return Point(*p)
+        if isinstance(p, Point):
+            return p
+        # Attempt to parse string "1,2" or "(1,2)"
+        s = str(p).strip("()")
+        try:
+            parts = s.split(',')
+            return Point(float(parts[0]), float(parts[1]))
+        except:
+            raise ValueError(f"Invalid point format: {p}")
+
+    def distancia(self, p1, p2):
+        """Distance between two points."""
+        A = self._parse_point(p1)
+        B = self._parse_point(p2)
+        return A.distance(B)
+
+    def punto_medio(self, p1, p2):
+        """Midpoint of segment P1-P2."""
+        A = self._parse_point(p1)
+        B = self._parse_point(p2)
+        return A.midpoint(B)
+
+    def pendiente(self, p1, p2):
+        """Slope of line passing through P1 and P2."""
+        A = self._parse_point(p1)
+        B = self._parse_point(p2)
+        if A.x == B.x:
+            return float('inf') # Vertical line
+        return (B.y - A.y) / (B.x - A.x)
+
+    def recta(self, p1, p2):
+        """Equation of line passing through P1 and P2."""
+        A = self._parse_point(p1)
+        B = self._parse_point(p2)
+        line = Line(A, B)
+        # SymPy Line equation is generic. We want y = mx + b form usually.
+        # equation() method returns a*x + b*y + c = 0
+        x, y = symbols('x y')
+        eq = line.equation(x, y)
+        # Solve for y
+        res = sp.solve(eq, y)
+        if res:
+            return sp.Eq(y, res[0])
+        else:
+            # Vertical line x = c
+            res_x = sp.solve(eq, x)
+            return sp.Eq(x, res_x[0])
+
+    def circulo(self, centro, radio):
+        """Equation of circle."""
+        C = self._parse_point(centro)
+        r = float(radio)
+        x, y = symbols('x y')
+        return sp.Eq((x - C.x)**2 + (y - C.y)**2, r**2)

binary_equalab/giac_poc.py

@@ -0,0 +1,74 @@
+"""
+Binary EquaLab - Giac Engine Connector (PoC)
+--------------------------------------------
+Bridge between Python and the C++ Giac CAS engine via 'giacpy'.
+This module provides raw speed for Gröbner bases and heavy algebra.
+"""
+
+import sys
+
+HAS_GIAC = False
+try:
+    import giacpy
+    from giacpy import giac
+    HAS_GIAC = True
+except ImportError:
+    pass
+
+class GiacEngine:
+    def __init__(self):
+        if not HAS_GIAC:
+            print("⚠️  GiacPy not installed. Running in SymPy-only mode.")
+            print("   To enable C++ speed: pip install giacpy")
+            
+    def eval(self, expr: str):
+        """Evaluate expression using Giac C++ engine"""
+        if not HAS_GIAC:
+            return "Error: Giac C++ engine not available."
+        
+        try:
+            # Giac handles the string parsing
+            result = giac(expr)
+            return result
+        except Exception as e:
+            return f"Giac Error: {e}"
+
+    def benchmark(self):
+        """Run a speed test vs SymPy"""
+        if not HAS_GIAC:
+            return
+        
+        import time
+        from sympy import expand, symbols
+        
+        print("\n🏎️  BENCHMARK: Python (SymPy) vs C++ (Giac)")
+        print("-" * 40)
+        
+        # Test Case: Expand big polynomial
+        poly_str = "(x+y+z+1)^15"
+        
+        # SymPy
+        x, y, z = symbols('x y z')
+        start = time.time()
+        # sympy_res = expand((x+y+z+1)**15) # Warning: This is huge
+        # Keeping it smaller for quick test
+        _ = expand((x+y+z+1)**5)
+        dt_sympy = time.time() - start
+        print(f"SymPy (Power 5): {dt_sympy:.4f}s")
+        
+        # Giac
+        start = time.time()
+        _ = giac("(x+y+z+1)^5").expand()
+        dt_giac = time.time() - start
+        print(f"Giac  (Power 5): {dt_giac:.4f}s")
+        
+        print(f"🏆 Winner: {'Giac' if dt_giac < dt_sympy else 'SymPy'}")
+
+if __name__ == "__main__":
+    g = GiacEngine()
+    if HAS_GIAC:
+        print("Testing Giac...")
+        print(f"Diff(sin(x^2)): {g.eval('diff(sin(x^2), x)')}")
+        g.benchmark()
+    else:
+        print("Install giacpy to run this test.")

binary_equalab/parser_enhanced.py

@@ -0,0 +1,66 @@
+import re
+
+class EnhancedParser:
+    """
+    Pre-processor for mathematical expressions to support 'human' syntax 
+    that SymPy doesn't natively understand.
+    
+    Inspired by GeoGebra and WolframAlpha input parsing.
+    """
+    
+    @staticmethod
+    def preprocess(expr: str) -> str:
+        """
+        Transform raw input into SymPy-compatible syntax.
+        """
+        if not expr:
+            return ""
+            
+        original = expr
+        
+        # 1. Handle Trig Powers: sin^2(x) -> (sin(x))**2
+        # Use specific list of functions to avoid false positives
+        funcs = r'(sin|cos|tan|sec|csc|cot|active|sinh|cosh|tanh|asin|acos|atan|ln|log|exp)'
+        
+        # Regex for func^n(arg) -> (func(arg))**n
+        # Limitation: Simple arguments balanced with one level of parens or just alphanumeric
+        # Match: sin^2(x)
+        expr = re.sub(rf'\b{funcs}\^(\d+)\s*\(', r'(\1(', expr)
+        # Note: We replace 'sin^2(' with '(sin('. 
+        # But we need to put ')**2' at the end of the group. 
+        # This is hard with regex. 
+        # Workaround: Replace sin^2(x) with sin(x)**2 logic is complex without AST.
+        # Fallback: Just remove the ^2 from the function name and append **2 to the block is risky.
+        # Let's try a different strategy commonly used: 
+        # Convert sin^2(x) -> sin(x)**2 works in SymPy ONLY IF sin(x) returns an object that supports **2. It does.
+        # SO: Replace 'sin^2' with 'sin' ... wait, no.
+        # Let's trust the user to write sin(x)^2 or implement a proper parser later.
+        # For now, let's fix the implicit multiplication 'cos2x'
+        
+        # 2. Handle 'cos 2x' or 'cos2x'
+        # Pattern: func followed by digit
+        # cos2x -> cos(2x)
+        expr = re.sub(rf'\b{funcs}(\d+[a-z]*)', r'\1(\2)', expr)
+        
+        # Pattern: func followed by space and alphanumeric
+        # cos x -> cos(x)
+        expr = re.sub(rf'\b{funcs}\s+([a-z0-9]+)\b', r'\1(\1)', expr) # Wait, regex group \1 is func. Argument is \2
+        expr = re.sub(rf'\b{funcs}\s+([a-z][a-z0-9]*|[0-9]+)\b', r'\1(\2)', expr)
+
+        # 3. Implicit Multiplication
+        # Digit followed by Letter: 2x -> 2*x
+        expr = re.sub(r'(\d)([a-zA-Z\(])', r'\1*\2', expr)
+        
+        # Letter followed by Digit? x2 usually means variable name, so ignore.
+        
+        # Parenthesis groups: (a)(b) -> (a)*(b)
+        expr = re.sub(r'\)([\w\(])', r')*\1', expr)
+        
+        # 4. Power ^ to ** (if not handled by parser, but good to be explicit)
+        expr = expr.replace('^', '**')
+        
+        return expr
+
+    @staticmethod
+    def extract_steps(expr: str):
+        pass

binary_equalab/shell_setup.py

@@ -0,0 +1,128 @@
+import platform
+import os
+import subprocess
+import shutil
+import sys
+
+def detect_shell():
+    """Detect current shell based on OS and Env"""
+    system = platform.system()
+    
+    if system == "Windows":
+        return "powershell"
+    
+    # Check for Termux
+    if "com.termux" in os.environ.get("PREFIX", ""):
+        return "termux"
+        
+    shell_env = os.environ.get("SHELL", "")
+    if "zsh" in shell_env:
+        return "zsh"
+    elif "bash" in shell_env:
+        return "bash"
+        
+    return "unknown"
+
+def install_nerd_font():
+    """Install Cascadia Code Nerd Font"""
+    print("📦 [Binary Setup] Instalando Nerd Font...")
+    system = platform.system()
+    
+    if system == "Windows":
+        try:
+            # Try via oh-my-posh if installed, or winget
+            subprocess.run(["oh-my-posh", "font", "install", "CascadiaCode"], check=False)
+        except FileNotFoundError:
+            print("⚠️ Oh My Posh no encontrado, omitiendo fuente automática.")
+
+    elif system == "Linux":
+        if "com.termux" in os.environ.get("PREFIX", ""):
+            print("ℹ️ En Termux, configura la fuente manualmente en Termux Settings.")
+        else:
+            # Generic Linux font install (simple version)
+            font_dir = os.path.expanduser("~/.local/share/fonts")
+            os.makedirs(font_dir, exist_ok=True)
+            # Todo: Download zip logic if needed
+            print("ℹ️ Descarga CascadiaCode.zip de NerdFonts y ponlo en ~/.local/share/fonts")
+
+def install_oh_my_posh_windows():
+    print("📦 [Binary Setup] Instalando Oh My Posh en Windows...")
+    
+    # Check if winget exists
+    if shutil.which("winget"):
+        subprocess.run(["winget", "install", "JanDeDobbeleer.OhMyPosh"])
+    else:
+        # Fallback to store or manual
+        print("⚠️ Winget no encontrado. Instala Oh My Posh desde Microsoft Store.")
+        return
+
+    # Theme config
+    # We can inject our theme later
+    print("✅ Oh My Posh instalado. Configura tu $PROFILE.")
+
+def install_oh_my_zsh_termux():
+    print("📦 [Binary Setup] Configurando Termux (Zsh + Oh My Zsh)...")
+    
+    # Install dependencies
+    subprocess.run(["pkg", "install", "zsh", "git", "curl", "-y"])
+    
+    # Install Oh My Zsh (Unattended)
+    subprocess.run([
+        "sh", "-c",
+        'sh -c "$(curl -fsSL https://raw.githubusercontent.com/ohmyzsh/ohmyzsh/master/tools/install.sh)" "" --unattended'
+    ])
+    
+    # Plugins (Autosuggestions!)
+    custom_dir = os.path.expanduser("~/.oh-my-zsh/custom")
+    subprocess.run([
+        "git", "clone", 
+        "https://github.com/zsh-users/zsh-autosuggestions.git",
+        f"{custom_dir}/plugins/zsh-autosuggestions"
+    ])
+    
+    subprocess.run([
+        "git", "clone", 
+        "https://github.com/zsh-users/zsh-syntax-highlighting.git",
+        f"{custom_dir}/plugins/zsh-syntax-highlighting"
+    ])
+    
+    # Update .zshrc
+    zshrc_path = os.path.expanduser("~/.zshrc")
+    with open(zshrc_path, "r") as f:
+        content = f.read()
+    
+    content = content.replace('plugins=(git)', 'plugins=(git zsh-autosuggestions zsh-syntax-highlighting)')
+    # Set Theme (agnoster is good default, or powerlevel10k)
+    content = content.replace('ZSH_THEME="robbyrussell"', 'ZSH_THEME="agnoster"')
+    
+    with open(zshrc_path, "w") as f:
+        f.write(content)
+        
+    # Change shell
+    subprocess.run(["chsh", "-s", "zsh"])
+    
+    print("✅ Termux configurado. Reinicia la app.")
+
+def run_setup():
+    print("╔═══════════════════════════════════════╗")
+    print("║   🎨 Binary EquaLab Shell Setup       ║")
+    print("╚═══════════════════════════════════════╝")
+    
+    shell = detect_shell()
+    print(f"🔍 Entorno detectado: {shell.upper()}")
+    
+    if shell == "powershell":
+        install_oh_my_posh_windows()
+        install_nerd_font()
+    
+    elif shell == "termux":
+        install_oh_my_zsh_termux()
+        
+    elif shell == "zsh" or shell == "bash":
+        print(f"ℹ️ Para Linux/Mac ({shell}), recomendamos Starship o Oh My Zsh manualmente por ahora.")
+    
+    else:
+        print("⚠️ Shell no soportado totalmente. Intenta instalar 'starship' manualmente.")
+
+if __name__ == "__main__":
+    run_setup()

binary_equalab/sonify.py

@@ -0,0 +1,91 @@
+
+import numpy as np
+import wave
+import struct
+import os
+from typing import Union, List
+import sympy as sp
+from .parser_enhanced import EnhancedParser
+
+class AudioEngine:
+    """
+    Las matemáticas también suenan.
+    Converts math expressions to .wav audio files.
+    """
+    
+    def __init__(self, sample_rate=44100):
+        self.sample_rate = sample_rate
+        
+    def generate(self, expr_str: str, duration: float = 3.0, filename: str = "output.wav"):
+        """
+        Evaluate expression f(t) and save as WAV.
+        t is time in seconds.
+        """
+        # Parse expression to SymPy
+        # We need a secure parsing way that allows 't' symbol
+        t = sp.symbols('t')
+        
+        # Preprocess using our EnhancedParser (supports 2t, sin^2(t))
+        clean_expr = EnhancedParser.preprocess(expr_str)
+        # Also standardize python power
+        clean_expr = clean_expr.replace('^', '**')
+        
+        try:
+            # Parse with SymPy
+            sym_expr = sp.sympify(clean_expr)
+            # Create lambda for fast numeric evaluation
+            f = sp.lambdify(t, sym_expr, modules=['numpy', 'math'])
+        except Exception as e:
+            raise ValueError(f"Error parsing '{expr_str}': {e}")
+            
+        print(f"🎵 Synthesizing: {clean_expr} for {duration}s...")
+        
+        # Generate Time Array
+        t_arr = np.linspace(0, duration, int(self.sample_rate * duration))
+        
+        # Evaluate function
+        try:
+            audio_data = f(t_arr)
+            
+            # Handle scalar result (e.g. "440")
+            if np.isscalar(audio_data):
+                audio_data = np.full_like(t_arr, float(audio_data))
+                
+        except Exception as e:
+            raise ValueError(f"Math Error: {e}")
+            
+        # Normalize and Clip to -1..1
+        max_val = np.max(np.abs(audio_data))
+        if max_val > 0:
+            audio_data = audio_data / max_val * 0.9  # Normalize and leave headroom
+        else:
+            # Silence
+            pass
+            
+        # Convert to 16-bit PCM
+        # audio_data is float -1..1
+        audio_int16 = (audio_data * 32767).astype(np.int16)
+        
+        # Save WAV
+        try:
+            with wave.open(filename, 'w') as wav_file:
+                # 1 Channel (Mono), 2 bytes (16 bit), Sample Rate, Count, Method
+                wav_file.setparams((1, 2, self.sample_rate, len(audio_int16), 'NONE', 'not compressed'))
+                
+                # Write frames
+                # struct.pack isn't efficient for arrays, use tobytes()
+                wav_file.writeframes(audio_int16.tobytes())
+                
+            print(f"✅ Saved audio to: {os.path.abspath(filename)}")
+            return os.path.abspath(filename)
+            
+        except Exception as e:
+            raise IOError(f"File Error: {e}")
+
+# Standalone CLI test
+if __name__ == "__main__":
+    engine = AudioEngine()
+    # A440 Sine Wave
+    engine.generate("sin(440*2*pi*t)", duration=2.0, filename="test_tone.wav")
+    # AM Synthesis (Tremolo)
+    engine.generate("sin(440*2*pi*t) * (0.5 + 0.5*sin(5*2*pi*t))", duration=3.0, filename="test_tremolo.wav")

{binary_equalab-1.0.0.dist-info → binary_equalab-2.0.1.dist-info}/METADATA

@@ -1,11 +1,11 @@
 Metadata-Version: 2.4
 Name: binary-equalab
-Version: 1.0.0
-Summary: Command-line CAS calculator with Spanish math functions
+Version: 2.0.1
+Summary: Advanced Algebra & Calculus CLI Tool
 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
+Author-email: Malexnnn <carde@example.com>
 License-Expression: MIT
 Keywords: algebra,calculator,calculus,cas,math,spanish,symbolic
 Classifier: Development Status :: 4 - Beta
@@ -39,7 +39,7 @@ Description-Content-Type: text/markdown
 </p>
 
 <p align="center">
-  <em>⌨️ Calculadora CAS en la terminal</em>
+  <em>"Las matemáticas también sienten, pero estas no se equivocan."</em>
 </p>
 
 ---
@@ -52,13 +52,42 @@ pip install binary-equalab
 
 Or from source:
 ```bash
-cd binary-cli
+# En carpeta binary-cli
 pip install -e .
+bneqls
+```
+(La opción `-e` hace que los cambios se reflejen al momento sin reinstalar).
+
+### 📱 Termux (Android)
+La instalación en Termux nativo requiere compilar algunas dependencias (NumPy/SymPy).
+
+```bash
+# 1. Instalar compiladores y librerías del sistema
+pkg update
+pkg install python clang make pkg-config libjpeg-turbo freetype libpng
+
+# 2. Instalar Binary EquaLab
+pip install binary-equalab
 ```
 
 ---
 
-## 📖 Usage
+## 🐚 Universal Shell Setup
+Binary EquaLab incluye un configurador mágico para tu terminal. Instala temas (Oh My Posh/Zsh), fuentes y plugins automáticamente.
+
+```bash
+# Ejecutar configurador
+binary setup-shell
+# O directamente:
+python -m binary_equalab.cli setup-shell
+```
+
+Soporta:
+-   **Windows**: Oh My Posh + Nerd Fonts.
+-   **Termux**: Zsh + Oh My Zsh + Autosuggestions.
+-   **Linux**: Recomendaciones de Starship.
+
+## 🚀 Uso del CLI
 
 ### REPL Mode
 ```bash

binary_equalab-2.0.1.dist-info/RECORD

@@ -0,0 +1,13 @@
+binary_equalab/__init__.py,sha256=WFF_aioc3t6xkz0qU_RI4FeqY4UT92c8wE5cDDJWenY,675
+binary_equalab/cli.py,sha256=-L4obeppbbfi8ZuuXoGuF0HgFu0o8W-G0bQProNsNOY,8733
+binary_equalab/engine.py,sha256=WhkKpdDCg2zqH9cMXDPMQ7Ut7Awyn4WzkVrRVP7_dtE,15931
+binary_equalab/functions.py,sha256=F6GPCXoScCHVZ4CDEE2Rns5i3x89DAcKRVBte88j9oE,569
+binary_equalab/geometry.py,sha256=YPn59oQtTY_hb4LZyIEJUvN1pWJz_y5uk8gVBio1Gwo,2217
+binary_equalab/giac_poc.py,sha256=_XdxE2lrvFH7M6qDfzSQHRdplxPzKhKfIWAcsOQq8Ho,2226
+binary_equalab/parser_enhanced.py,sha256=P7oMnGHWn3xoqVChkPJ6B_i_IR9TeJMJXBjKoCO13ts,2735
+binary_equalab/shell_setup.py,sha256=9Ax_QcHEAopYIjShuBaHglg4HPysXJKbNL3D_FjexrU,4518
+binary_equalab/sonify.py,sha256=HfAYPtXLRyb3miLBsd8liqk4D5hvXVBHEEyV6fj9Za8,3274
+binary_equalab-2.0.1.dist-info/METADATA,sha256=GcxDwiPnhKaKIY5B_SLUIZVQdbD0pdY81Q923WieATs,5084
+binary_equalab-2.0.1.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+binary_equalab-2.0.1.dist-info/entry_points.txt,sha256=2Io1Wi069dvgPHmGXmAT1a6rNA-DIq7tChai69jtbF0,119
+binary_equalab-2.0.1.dist-info/RECORD,,

{binary_equalab-1.0.0.dist-info → binary_equalab-2.0.1.dist-info}/entry_points.txt

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

binary_equalab-1.0.0.dist-info/RECORD

@@ -1,8 +0,0 @@
-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,,