Name Change

Author: cybergeek1943

README.md

@@ -1,14 +1,14 @@
-# FunKit 🧮
+# MathFlow 🧮
 **A Pythonic Interface for Symbolic and Numerical Mathematics**
 
-FunKit bridges the gap between symbolic mathematics (SymPy) and numerical computations (NumPy/SciPy), offering a unified interface that maintains mathematical rigor while providing practical tools for real-world problems.  
+MathFlow bridges the gap between symbolic mathematics (SymPy) and numerical computations (NumPy/SciPy), offering a unified interface that maintains mathematical rigor while providing practical tools for real-world problems.  
 
 ![Static Badge](https://img.shields.io/badge/Python-3.11%2B-blue?logo=python)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)  
 
 **Ready to revolutionize your mathematical computing workflow?**
 ```bash
-pip install funkit
+pip install mathflow
 ```
 
 **Have Questions? Take a look at the Q&A:**
@@ -23,14 +23,14 @@ pip install funkit
 - **📡 Signal System**: Qt-like signals for tracking expression mutations and clones, enabling reactive programming  
 - **🔄 Automatic Type Conversions**: Seamlessly and automatically converts between internal Poly and Expr representations based on context
 - **📦 Lightweight**: ~0.5 MB itself, ~100 MB including dependencies
-- **🧩 Fully backward compatible**: Seamlessly integrate SymPy and FunKit in the same script. All methods that work on SymPy Expr or Poly objects work on FunKit objects
+- **🧩 Fully backward compatible**: Seamlessly integrate SymPy and MathFlow in the same script. All methods that work on SymPy Expr or Poly objects work on MathFlow objects
 - **🔍 Exploratory**: Full IDE support, enabling easy tool finding and minimizing the learning curve.
 
 
 ## 🚀 Quick Start
 
 ```python
-from funkit import Expression, Polynomial, Rational
+from mathflow import Expression, Polynomial, Rational
 
 # Create expressions naturally
 f = Expression("2x^2 + 3x + \frac{1}{2}")  # latex is automatically parsed
@@ -60,7 +60,7 @@ print(f.print.ccode())    # c code output
 
 ## 🎯 Numerical Computing
 
-FunKit excels at bridging symbolic and numerical mathematics:  
+MathFlow excels at bridging symbolic and numerical mathematics:  
 ```python
 f = Expression("x^3 - 2x^2 + x - 1")
 
@@ -269,7 +269,7 @@ Step 9. `h` may be substituted for the original (x-c), and then expanded. `c` is
 
 ## 🏗️ Design Philosophy  
 
-FunKit follows several key principles:
+MathFlow follows several key principles:
 
 1. **Intuitive API**: Mathematical operations should feel natural in Python, providing an "exploratory" experience
 2. **Performance**: Automatic optimizations (Horner's method, efficient algorithms, automatic numerical computing when needed)  

docs/QA.md

@@ -1,12 +1,12 @@
-# FunKit Q&A: Addressing Potential Concerns
+# MathFlow Q&A: Addressing Potential Concerns
 
 ### Performance & Overhead
 
 **Q: Doesn't adding an abstraction layer introduce significant performance overhead compared to using SymPy/NumPy directly?**
 **A:** The overhead is minimal - just one or two `getattr()` calls, which are negligible compared to the actual mathematical computations. Python's attribute lookup is highly optimized, and mathematical operations like integration, differentiation, or root-finding completely dominate any method dispatch overhead.
-In fact, FunKit often provides performance _improvements_ through cached lambdified expressions (eliminating repeated compilation) and automatic algorithm selection (like Horner's method for polynomial evaluation).
+In fact, MathFlow often provides performance _improvements_ through cached lambdified expressions (eliminating repeated compilation) and automatic algorithm selection (like Horner's method for polynomial evaluation).
 
-**Q: How does FunKit's performance compare to direct SymPy usage in practice?**
+**Q: How does MathFlow's performance compare to direct SymPy usage in practice?**
 **A:** For typical mathematical workflows, performance is equivalent or better. The `.n` attribute provides direct access to optimized numerical routines without manual lambdification overhead. Any microsecond differences in method dispatch are irrelevant when you're computing integrals or solving equations.
 
 **Q: How does automatic type conversion between Poly and Expr work? Could this cause unexpected behavior?**
@@ -15,21 +15,21 @@ In fact, FunKit often provides performance _improvements_ through cached lambdif
 ### Practical Usage
 
 **Q: How stable is the API?**
-**A:** The core API is designed for stability, following established patterns from libraries like `requests`. The mathematical operations and core classes are unlikely to change significantly. Also, because FunKit has been designed using metaprogramming techniques, any changes to SymPy will naturally present themselves in FunKit.
+**A:** The core API is designed for stability, following established patterns from libraries like `requests`. The mathematical operations and core classes are unlikely to change significantly. Also, because MathFlow has been designed using metaprogramming techniques, any changes to SymPy will naturally present themselves in MathFlow.
 
 **Q: What about debugging and error messages?**
-**A:** Since FunKit is built on SymPy, you get the same detailed error messages and debugging capabilities. The abstraction layer preserves the underlying mathematical error handling.
+**A:** Since MathFlow is built on SymPy, you get the same detailed error messages and debugging capabilities. The abstraction layer preserves the underlying mathematical error handling.
 
 ### Ecosystem & Adoption
 
 **Q: Why not just use SymPy directly? What's the compelling advantage?**
-**A:** FunKit eliminates the friction of switching between symbolic and numerical computing. With SymPy, you constantly write boilerplate code for lambdification, handle type conversions, and manage separate workflows. FunKit provides a unified interface where every symbolic expression has numerical methods available via the `.n` attribute. It also adds additional convenience utilities such as the `.n.all_roots()`, `.n.all_poly_roots()`, `.nsolve_all()`, and more.
+**A:** MathFlow eliminates the friction of switching between symbolic and numerical computing. With SymPy, you constantly write boilerplate code for lambdification, handle type conversions, and manage separate workflows. MathFlow provides a unified interface where every symbolic expression has numerical methods available via the `.n` attribute. It also adds additional convenience utilities such as the `.n.all_roots()`, `.n.all_poly_roots()`, `.nsolve_all()`, and more.
 
 **Q: Is this just another "wrapper library" that adds complexity?**
-**A:** No - FunKit is fully backward compatible with SymPy. You can seamlessly mix FunKit and SymPy objects in the same script. It's purpose is to add a better and more pythonic interface to existing functionality rather than replacing it. **It is intended to be used alongside SymPy**.
+**A:** No - MathFlow is fully backward compatible with SymPy. You can seamlessly mix MathFlow and SymPy objects in the same script. It's purpose is to add a better and more pythonic interface to existing functionality rather than replacing it. **It is intended to be used alongside SymPy**.
 
 **Q: How does this compare to existing solutions like SymEngine or SageMath?**
-**A:** SymEngine focuses on computational speed for symbolic operations. FunKit focuses on workflow ergonomics and the symbolic-numerical interface. They solve different problems and could even be used together. FunKit has also been developed to be minimal and lightweight (~0.5 MB itself, and ~100 MB including dependencies) with a focus toward the analysis of functions and expressions, unlike SageMath (2 GB) or similar libraries which provide comprehensive mathematical tools.
+**A:** SymEngine focuses on computational speed for symbolic operations. MathFlow focuses on workflow ergonomics and the symbolic-numerical interface. They solve different problems and could even be used together. MathFlow has also been developed to be minimal and lightweight (~0.5 MB itself, and ~100 MB including dependencies) with a focus toward the analysis of functions and expressions, unlike SageMath (2 GB) or similar libraries which provide comprehensive mathematical tools.
 
 ### Design Philosophy
 
@@ -43,7 +43,7 @@ In fact, FunKit often provides performance _improvements_ through cached lambdif
 These aren't random features - they're solving real workflow problems.
 
 **Q: Is there a learning curve for existing SymPy users?**
-**A:** Minimal. All existing SymPy knowledge transfers directly. FunKit adds convenience features without changing fundamental concepts. Most methods are directly inherited from SymPy's Expr and Poly classes. You can gradually adopt FunKit features while keeping existing SymPy workflows.
+**A:** Minimal. All existing SymPy knowledge transfers directly. MathFlow adds convenience features without changing fundamental concepts. Most methods are directly inherited from SymPy's Expr and Poly classes. You can gradually adopt MathFlow features while keeping existing SymPy workflows.
 
 
 

pyproject.toml

@@ -3,10 +3,10 @@ requires = ["setuptools"]
 build-backend = "setuptools.build_meta"
 
 [project]
-name = "funkit"
+name = "mathflow"
 version = "0.1.0"
 description = "A Pythonic Interface for Symbolic and Numerical Mathematics"
-license = {text = "MIT"}
+license = 'MIT'
 authors = [{name = "Isaac Wolford", email = "[email protected]"}]
 requires-python = ">=3.11"
 dependencies = [

src/funkit/__init__.py

@@ -1,13 +1,13 @@
 """
-FunKit - A Pythonic Interface for Symbolic and Numerical Mathematics
+MathFlow - A Pythonic Interface for Symbolic and Numerical Mathematics
 =====================================================================
 
-FunKit provides an object-oriented wrapper around SymPy with seamless integration of numerical 
+MathFlow provides an object-oriented wrapper around SymPy with seamless integration of numerical
 computations, making symbolic mathematics more intuitive and powerful for Python developers.
 
 Overview
 --------
-FunKit bridges the gap between symbolic mathematics (SymPy) and numerical computations (NumPy/SciPy),
+MathFlow bridges the gap between symbolic mathematics (SymPy) and numerical computations (NumPy/SciPy),
 offering a unified interface that maintains mathematical rigor while providing practical tools for
 real-world problems. It extends SymPy's capabilities with features like operative closure, mutability
 control, and automatic type conversions between different mathematical representations.
@@ -55,7 +55,7 @@
 
 Design Philosophy
 -----------------
-FunKit follows several key principles:
+MathFlow follows several key principles:
 
 1. **Intuitive API**: Mathematical operations should feel natural in Python while maintaining
    mathematical correctness.

src/funkit/core.py

@@ -239,7 +239,7 @@ def __repr__(self) -> str:
         return self.expr.__repr__()
 
 
-def _handle_args_with_funkit_objects(args, kwargs) -> tuple[list, dict]:
+def _handle_args_with_mathflow_objects(args, kwargs) -> tuple[list, dict]:
     out_args = [arg.expr if isinstance(arg, BaseExpression) else arg for arg in args]
     for k, v in kwargs.items():
         if isinstance(v, BaseExpression):
@@ -250,7 +250,7 @@ def _handle_args_with_funkit_objects(args, kwargs) -> tuple[list, dict]:
 def _delegate_dunder_method(name: str) -> Callable:
     """This is a function that helps delegate dunder methods to BaseExpression.expr object."""
     def dunder_method(self: BaseExpression, *args, **kwargs) -> Any:
-        args, kwargs = _handle_args_with_funkit_objects(args, kwargs)  # this enables operation between types BaseExpression and BaseExpression.
+        args, kwargs = _handle_args_with_mathflow_objects(args, kwargs)  # this enables operation between types BaseExpression and BaseExpression.
         result: Any = getattr(self.expr, name)(*args, **kwargs)
         if self.operative_closure and isinstance(result, SympyExpr):
             return self._clone_self(new_expr=result)