Actualización del historial de cálculos con un nuevo formato de salario. Refactorización del motor algebraico para mejorar la gestión de ecuaciones y la resolución de variables, optimizando la salida de resultados y asegurando un manejo más eficiente de las soluciones simbólicas.

.data/history.txt

@@ -1,6 +1,6 @@
 
 salario=horas*tarifa
-salario=8000
+salario=800
 tarifa=36
 
 horas=?

app/evaluation.py

@@ -552,18 +552,17 @@ class PureAlgebraicEngine:
             return EvaluationResult(line, error_msg, "error", False, str(e))
     
     def _smart_solve(self, *args, **kwargs):
-        """Función solve inteligente que usa nuestro sistema de ecuaciones"""
-        if not args:
-            # solve() sin argumentos - resolver todo el sistema
-            if not self.equations:
-                return "No hay ecuaciones en el sistema"
-            
+        """Función inteligente de resolución que maneja variables y valores"""
+        if len(args) == 1 and isinstance(args[0], (list, tuple)):
+            # solve([ecuaciones], [variables])
             try:
-                all_vars = list(self.variables)
-                solution = solve(self.equations, all_vars, dict=True)
-                
-                if solution:
-                    return solution[0] if len(solution) == 1 else solution
+                if all(hasattr(eq, 'func') and eq.func.__name__ == 'Equality' for eq in args[0]):
+                    # Es una lista de ecuaciones
+                    solutions = solve(args[0], **kwargs)
+                    if solutions:
+                        return solutions
+                    else:
+                        return "Sin solución"
                 else:
                     return "Sin solución"
             except Exception as e:
@@ -575,7 +574,7 @@ class PureAlgebraicEngine:
             
             # Si encontramos una solución diferente de la variable
             if solution_value != var_symbol:
-                # Verificar si la solución contiene otras variables
+                # Verificar si todas las variables libres tienen valores numéricos
                 free_symbols = solution_value.free_symbols
                 unresolved_vars = free_symbols - {var_symbol}
                 
@@ -599,26 +598,18 @@ class PureAlgebraicEngine:
                         # Todas las variables tienen valores numéricos, resolver iterativamente
                         final_value = self._resolve_iteratively(solution_value)
                         
-                        # Auto-aplicar la solución numérica al sistema
-                        if final_value != var_symbol and not str(final_value) in ['True', 'False']:
-                            self._auto_apply_solution(var_symbol, final_value)
-                        
-                        return Eq(var_symbol, final_value)
+                        # Verificar que el resultado no sea problemático
+                        if final_value != var_symbol and not isinstance(final_value, (sp.logic.boolalg.BooleanTrue, sp.logic.boolalg.BooleanFalse)):
+                            return Eq(var_symbol, final_value)
+                        else:
+                            # Si hay problema con la resolución, devolver simbólico
+                            return Eq(var_symbol, solution_value)
                     else:
-                        # Hay variables con valores simbólicos, intentar resolver lo máximo posible
-                        # Aplicar resolución iterativa parcial
-                        resolved_solution = self._resolve_iteratively(solution_value)
-                        result_eq = Eq(var_symbol, resolved_solution)
-                        return result_eq
+                        # Hay variables con valores simbólicos, devolver ecuación simbólica
+                        return Eq(var_symbol, solution_value)
                 else:
-                    # No hay variables sin resolver, intentar resolver completamente
-                    final_value = self._resolve_iteratively(solution_value)
-                    
-                    # Auto-aplicar la solución al sistema solo si es un valor específico
-                    if final_value != var_symbol and not str(final_value) in ['True', 'False']:
-                        self._auto_apply_solution(var_symbol, final_value)
-                    
-                    return Eq(var_symbol, final_value)
+                    # No hay variables sin resolver, es ya un valor final
+                    return Eq(var_symbol, solution_value)
             else:
                 # Si no hay solución en las ecuaciones, verificar en symbol_table
                 var_name = str(var_symbol)
@@ -626,11 +617,10 @@ class PureAlgebraicEngine:
                     value = self.symbol_table[var_name]
                     # Si el valor en symbol_table es diferente de la variable, devolverlo
                     if value != var_symbol:
-                        final_value = self._resolve_iteratively(value)
-                        return Eq(var_symbol, final_value)
+                        return Eq(var_symbol, value)
                 
-                # Si no hay información, devolver la variable tal como está
-                return var_symbol
+                # Si no hay información, devolver ecuación con la variable sin resolver
+                return Eq(var_symbol, var_symbol)
         else:
             # solve() con argumentos específicos (múltiples variables, ecuaciones, etc.)
             return solve(*args, **kwargs)