oikan 0.0.2.3__py3-none-any.whl → 0.0.2.5__py3-none-any.whl

oikan/model.py

@@ -30,7 +30,10 @@ class KANLayer(nn.Module):
             for _ in range(input_dim)
         ])
         
-        self.combination_weights = nn.Parameter(torch.randn(input_dim, output_dim) * 0.1)
+        # Updated initialization using Xavier uniform initialization
+        self.combination_weights = nn.Parameter(
+            nn.init.xavier_uniform_(torch.empty(input_dim, output_dim))
+        )
     
     def forward(self, x):
         x_split = x.split(1, dim=1)  # list of (batch, 1) tensors for each input feature
@@ -49,7 +52,8 @@ class KANLayer(nn.Module):
             for i in range(self.input_dim):
                 weight = self.combination_weights[i, j].item()
                 if abs(weight) > 1e-4:
-                    edge_formula = self.edges[i][j].get_symbolic_repr()
+                    # Pass lower threshold for improved precision
+                    edge_formula = self.edges[i][j].get_symbolic_repr(threshold=1e-6)
                     if edge_formula != "0":
                         terms.append(f"({weight:.4f} * ({edge_formula}))")
             formulas.append(" + ".join(terms) if terms else "0")
@@ -57,15 +61,13 @@ class KANLayer(nn.Module):
 
 class BaseOIKAN(BaseEstimator):
     """Base OIKAN model implementing common functionality"""
-    def __init__(self, hidden_dims=[64, 32], num_basis=10, degree=3, dropout=0.1):
+    def __init__(self, hidden_dims=[32, 16], dropout=0.1):
         self.hidden_dims = hidden_dims
-        self.num_basis = num_basis
-        self.degree = degree
         self.dropout = dropout  # Dropout probability for uncertainty quantification
         self.device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')  # Auto device chooser
         self.model = None
         self._is_fitted = False
-        self.__name = "OIKAN v0.0.2" # Version info (manually configured)
+        self.__name = "OIKAN v0.0.2"  # Manual configured version
         self.loss_history = []  # <-- new attribute to store loss values
         
     def _build_network(self, input_dim, output_dim):
@@ -73,7 +75,9 @@ class BaseOIKAN(BaseEstimator):
         prev_dim = input_dim
         for hidden_dim in self.hidden_dims:
             layers.append(KANLayer(prev_dim, hidden_dim))
-            layers.append(nn.Dropout(self.dropout))  # Apply dropout for uncertainty quantification
+            layers.append(nn.BatchNorm1d(hidden_dim))  # Added batch normalization
+            layers.append(nn.ReLU())                  # Added activation function
+            layers.append(nn.Dropout(self.dropout))   # Apply dropout for uncertainty quantification
             prev_dim = hidden_dim
         layers.append(KANLayer(prev_dim, output_dim))
         return nn.Sequential(*layers).to(self.device)
@@ -85,6 +89,25 @@ class BaseOIKAN(BaseEstimator):
             y = torch.FloatTensor(y)
         return X.to(self.device), (y.to(self.device) if y is not None else None)
 
+    def _process_edge_formula(self, edge_formula, weight):
+        """Helper to scale symbolic formula terms by a given weight"""
+        terms = []
+        for term in edge_formula.split(" + "):
+            if term and term != "0":
+                if "*" in term:
+                    coef_str, rest = term.split("*", 1)
+                    try:
+                        coef = float(coef_str)
+                        terms.append(f"{(coef * weight):.4f}*{rest}")
+                    except Exception:
+                        terms.append(term)  # fallback
+                else:
+                    try:
+                        terms.append(f"{(float(term) * weight):.4f}")
+                    except Exception:
+                        terms.append(term)
+        return " + ".join(terms) if terms else "0"
+
     def get_symbolic_formula(self):
         """Generate and cache symbolic formulas for production‐ready inference."""
         if not self._is_fitted:
@@ -100,17 +123,9 @@ class BaseOIKAN(BaseEstimator):
                 for j in range(n_classes):
                     weight = first_layer.combination_weights[i, j].item()
                     if abs(weight) > 1e-4:
-                        edge_formula = first_layer.edges[i][j].get_symbolic_repr()
-                        terms = []
-                        for term in edge_formula.split(" + "):
-                            if term and term != "0":
-                                if "*" in term:
-                                    coef, rest = term.split("*", 1)
-                                    coef = float(coef) * weight
-                                    terms.append(f"{coef:.4f}*{rest}")
-                                else:
-                                    terms.append(f"{float(term)*weight:.4f}")
-                        formulas[i][j] = " + ".join(terms) if terms else "0"
+                        # Use improved threshold for formula extraction
+                        edge_formula = first_layer.edges[i][j].get_symbolic_repr(threshold=1e-6)
+                        formulas[i][j] = self._process_edge_formula(edge_formula, weight)
                     else:
                         formulas[i][j] = "0"
             self.symbolic_formula = formulas
@@ -119,8 +134,9 @@ class BaseOIKAN(BaseEstimator):
             formulas = []
             first_layer = self.model[0]
             for i in range(first_layer.input_dim):
-                formula = first_layer.edges[i][0].get_symbolic_repr()
-                formulas.append(formula)
+                # Use improved threshold for formula extraction in regressor branch
+                edge_formula = first_layer.edges[i][0].get_symbolic_repr(threshold=1e-6)
+                formulas.append(self._process_edge_formula(edge_formula, 1.0))
             self.symbolic_formula = formulas
             return formulas
 
@@ -131,7 +147,7 @@ class BaseOIKAN(BaseEstimator):
         - A header with the version and timestamp
         - The symbolic formulas for each feature (and class for classification)
         - A general formula, including softmax for classification
-        - Recommendations for production use.
+        - Recommendations and performance results.
         """
         header = f"Generated by {self.__name} | Timestamp: {dt.now()}\n\n"
         header += "Symbolic Formulas:\n"
@@ -157,8 +173,14 @@ class BaseOIKAN(BaseEstimator):
             recs = ("\nRecommendations:\n"
                     "• Consider the symbolic formula for lightweight and interpretable inference.\n"
                     "• Validate approximation accuracy against the neural model.\n")
+       
+        # Disclaimer regarding experimental usage
+        disclaimer = ("\nDisclaimer:\n"
+                      "This experimental model is intended for research purposes only and is not production-ready. "
+                      "Feel free to fork and build your own project based on this research: "
+                      "https://github.com/silvermete0r/oikan\n")
         
-        output = header + formulas_text + general + recs
+        output = header + formulas_text + general + recs + disclaimer
         with open(filename, "w") as f:
             f.write(output)
         print(f"Symbolic formulas saved to {filename}")
@@ -174,30 +196,51 @@ class BaseOIKAN(BaseEstimator):
     def _eval_formula(self, formula, x):
         """Helper to evaluate a symbolic formula for an input vector x using ADVANCED_LIB basis functions."""
         import re
-        total = 0
+        from .utils import ensure_tensor  
+        
+        if isinstance(x, (list, tuple)):
+            x = np.array(x)
+        
+        total = torch.zeros_like(ensure_tensor(x))
         pattern = re.compile(r"(-?\d+\.\d+)\*?([\w\(\)\^]+)")
         matches = pattern.findall(formula)
+        
         for coef_str, func_name in matches:
             try:
                 coef = float(coef_str)
                 for key, (notation, func) in ADVANCED_LIB.items():
                     if notation.strip() == func_name.strip():
-                        total += coef * func(x)
+                        result = func(x)
+                        if isinstance(result, torch.Tensor):
+                            total += coef * result
+                        else:
+                            total += coef * ensure_tensor(result)
                         break
-            except Exception:
+            except Exception as e:
+                print(f"Warning: Error evaluating term {coef_str}*{func_name}: {str(e)}")
                 continue
-        return total
+        
+        return total.cpu().numpy() if isinstance(total, torch.Tensor) else total
 
     def symbolic_predict(self, X):
         """Predict using only the extracted symbolic formula (regressor)."""
         if not self._is_fitted:
             raise NotFittedError("Model must be fitted before prediction")
+        
         X = np.array(X) if not isinstance(X, np.ndarray) else X
-        formulas = self.get_symbolic_formula()  # For regressor: list of formula strings.
+        formulas = self.get_symbolic_formula()
         predictions = np.zeros((X.shape[0], 1))
-        for i, formula in enumerate(formulas):
-            x = X[:, i]
-            predictions[:, 0] += self._eval_formula(formula, x)
+        
+        try:
+            for i, formula in enumerate(formulas):
+                x = X[:, i]
+                pred = self._eval_formula(formula, x)
+                if isinstance(pred, torch.Tensor):
+                    pred = pred.cpu().numpy()
+                predictions[:, 0] += pred
+        except Exception as e:
+            raise RuntimeError(f"Error in symbolic prediction: {str(e)}")
+            
         return predictions
 
     def compile_symbolic_formula(self, filename="output/final_symbolic_formula.txt"):
@@ -263,7 +306,7 @@ class BaseOIKAN(BaseEstimator):
 
 class OIKANRegressor(BaseOIKAN, RegressorMixin):
     """OIKAN implementation for regression tasks"""
-    def fit(self, X, y, epochs=100, lr=0.01, batch_size=32, verbose=True):
+    def fit(self, X, y, epochs=100, lr=0.01, verbose=True):
         X, y = self._validate_data(X, y)
         if len(y.shape) == 1:
             y = y.reshape(-1, 1)
@@ -284,7 +327,7 @@ class OIKANRegressor(BaseOIKAN, RegressorMixin):
             if torch.isnan(loss):
                 print("Warning: NaN loss detected, reinitializing model...")
                 self.model = None
-                return self.fit(X, y, epochs, lr/10, batch_size, verbose)
+                return self.fit(X, y, epochs, lr/10, verbose)
                 
             loss.backward()
             
@@ -312,7 +355,7 @@ class OIKANRegressor(BaseOIKAN, RegressorMixin):
 
 class OIKANClassifier(BaseOIKAN, ClassifierMixin):
     """OIKAN implementation for classification tasks"""
-    def fit(self, X, y, epochs=100, lr=0.01, batch_size=32, verbose=True):
+    def fit(self, X, y, epochs=100, lr=0.01, verbose=True):
         X, y = self._validate_data(X, y)
         self.classes_ = torch.unique(y)
         n_classes = len(self.classes_)
@@ -414,8 +457,8 @@ class OIKANClassifier(BaseOIKAN, ClassifierMixin):
                 weight = first_layer.combination_weights[i, j].item()
                 
                 if abs(weight) > 1e-4:
-                    # Get the edge formula and scale by the weight
-                    edge_formula = edge.get_symbolic_repr()
+                    # Improved precision by using a lower threshold
+                    edge_formula = edge.get_symbolic_repr(threshold=1e-6)
                     terms = []
                     for term in edge_formula.split(" + "):
                         if term and term != "0":

oikan/utils.py

@@ -3,41 +3,47 @@ import torch
 import torch.nn as nn
 import numpy as np
 
-# Core basis functions with explicit variable notation
+def ensure_tensor(x):
+    """Helper function to ensure input is a PyTorch tensor."""
+    if isinstance(x, np.ndarray):
+        return torch.from_numpy(x).float()
+    elif isinstance(x, (int, float)):
+        return torch.tensor([x], dtype=torch.float32)
+    elif isinstance(x, torch.Tensor):
+        return x.float()
+    else:
+        raise ValueError(f"Unsupported input type: {type(x)}")
+
+# Updated to handle numpy arrays and scalars
 ADVANCED_LIB = {
-    'x':    ('x', lambda x: x),
-    'x^2':  ('x^2', lambda x: np.clip(x**2, -100, 100)),
-    'x^3':  ('x^3', lambda x: np.clip(x**3, -100, 100)),
-    'exp':  ('exp(x)', lambda x: np.exp(np.clip(x, -10, 10))),
-    'log':  ('log(x)', lambda x: np.log(np.abs(x) + 1)),
-    'sqrt': ('sqrt(x)', lambda x: np.sqrt(np.abs(x))),
-    'tanh': ('tanh(x)', lambda x: np.tanh(x)),
-    'sin':  ('sin(x)', lambda x: np.sin(np.clip(x, -10*np.pi, 10*np.pi))),
-    'abs':  ('abs(x)', lambda x: np.abs(x))
+    'x': ('x', lambda x: ensure_tensor(x)),
+    'x^2': ('x^2', lambda x: torch.pow(ensure_tensor(x), 2)),
+    'sin': ('sin(x)', lambda x: torch.sin(ensure_tensor(x))),
+    'tanh': ('tanh(x)', lambda x: torch.tanh(ensure_tensor(x)))
 }
 
 class EdgeActivation(nn.Module):
-    """Learnable edge-based activation function."""
+    """Learnable edge-based activation function with improved gradient flow."""
     def __init__(self):
         super().__init__()
         self.weights = nn.Parameter(torch.randn(len(ADVANCED_LIB)))
         self.bias = nn.Parameter(torch.zeros(1))
         
     def forward(self, x):
+        x_tensor = ensure_tensor(x)
         features = []
         for _, func in ADVANCED_LIB.values():
-            feat = torch.tensor(func(x.detach().cpu().numpy()), 
-                              dtype=torch.float32).to(x.device)
+            feat = func(x_tensor)
             features.append(feat)
         features = torch.stack(features, dim=-1)
         return torch.matmul(features, self.weights.unsqueeze(0).T) + self.bias
     
     def get_symbolic_repr(self, threshold=1e-4):
         """Get symbolic representation of the activation function."""
+        weights_np = self.weights.detach().cpu().numpy()
         significant_terms = []
         
-        for (notation, _), weight in zip(ADVANCED_LIB.values(), 
-                                       self.weights.detach().cpu().numpy()):
+        for (notation, _), weight in zip(ADVANCED_LIB.values(), weights_np):
             if abs(weight) > threshold:
                 significant_terms.append(f"{weight:.4f}*{notation}")
                 

{oikan-0.0.2.3.dist-info → oikan-0.0.2.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: oikan
-Version: 0.0.2.3
+Version: 0.0.2.5
 Summary: OIKAN: Optimized Interpretable Kolmogorov-Arnold Networks
 Author: Arman Zhalgasbayev
 License: MIT
@@ -32,20 +32,50 @@ OIKAN (Optimized Interpretable Kolmogorov-Arnold Networks) is a neuro-symbolic M
 [![GitHub issues](https://img.shields.io/github/issues/silvermete0r/OIKAN.svg)](https://github.com/silvermete0r/oikan/issues)
 [![Docs](https://img.shields.io/badge/docs-passing-brightgreen)](https://silvermete0r.github.io/oikan/)
 
+> **Important Disclaimer**: OIKAN is an experimental research project. It is not intended for production use or real-world applications. This framework is designed for research purposes, experimentation, and academic exploration of neuro-symbolic machine learning concepts.
+
 ## Key Features
 - 🧠 **Neuro-Symbolic ML**: Combines neural network learning with symbolic mathematics
 - 📊 **Automatic Formula Extraction**: Generates human-readable mathematical expressions
 - 🎯 **Scikit-learn Compatible**: Familiar `.fit()` and `.predict()` interface
-- 🚀 **Production-Ready**: Export symbolic formulas for lightweight deployment
+- 🔬 **Research-Focused**: Designed for academic exploration and experimentation
 - 📈 **Multi-Task**: Supports both regression and classification problems
 
 ## Scientific Foundation
 
-OIKAN is based on Kolmogorov's superposition theorem, which states that any multivariate continuous function can be represented as a composition of single-variable functions. We leverage this theory by:
+OIKAN implements the Kolmogorov-Arnold Representation Theorem through a novel neural architecture:
+
+1. **Theorem Background**: Any continuous multivariate function f(x1,...,xn) can be represented as:
+   ```
+   f(x1,...,xn) = ∑(j=0 to 2n){ φj( ∑(i=1 to n) ψij(xi) ) }
+   ```
+   where φj and ψij are continuous single-variable functions.
 
-1. Using neural networks to learn optimal basis functions through interpretable edge transformations
-2. Combining transformed features using learnable weights
-3. Automatically extracting human-readable symbolic formulas
+2. **Neural Implementation**:
+   ```python
+   # Pseudo-implementation of KAN architecture
+   class KANLayer:
+       def __init__(self, input_dim, output_dim):
+           self.edges = [SymbolicEdge() for _ in range(input_dim * output_dim)]
+           self.weights = initialize_weights(input_dim, output_dim)
+   
+       def forward(self, x):
+           # Transform each input through basis functions
+           edge_outputs = [edge(x_i) for x_i, edge in zip(x, self.edges)]
+           # Combine using learned weights
+           return combine_weighted_outputs(edge_outputs, self.weights)
+   ```
+
+3. **Basis functions**
+```python
+# Edge activation contains interpretable basis functions
+ADVANCED_LIB = {
+      'x': (lambda x: x),          # Linear
+      'x^2': (lambda x: x**2),     # Quadratic
+      'sin(x)': np.sin,            # Periodic
+      'tanh(x)': np.tanh          # Bounded
+}
+```
 
 ## Quick Start
 
@@ -68,11 +98,8 @@ pip install -e .  # Install in development mode
 from oikan.model import OIKANRegressor
 from sklearn.model_selection import train_test_split
 
-# Initialize model with optimal architecture
-model = OIKANRegressor(
-    hidden_dims=[16, 8],  # Network architecture
-    dropout=0.1           # Regularization
-)
+# Initialize model 
+model = OIKANRegressor()
 
 # Fit model (sklearn-style)
 model.fit(X_train, y_train, epochs=100, lr=0.01)
@@ -84,7 +111,7 @@ y_pred = model.predict(X_test)
 # The output file will contain:
 # - Detailed symbolic formulas for each feature
 # - Instructions for practical implementation
-# - Recommendations for production deployment
+# - Recommendations for testing and validation
 model.save_symbolic_formula("regression_formula.txt")
 ```
 
@@ -96,7 +123,7 @@ model.save_symbolic_formula("regression_formula.txt")
 from oikan.model import OIKANClassifier
 
 # Similar sklearn-style interface for classification
-model = OIKANClassifier(hidden_dims=[16, 8])
+model = OIKANClassifier()
 model.fit(X_train, y_train, epochs=100, lr=0.01)
 probas = model.predict_proba(X_test)
 
@@ -104,46 +131,12 @@ probas = model.predict_proba(X_test)
 # The output file will contain:
 # - Decision boundary formulas for each class
 # - Softmax application instructions
-# - Production deployment recommendations
+# - Recommendations for testing and validation
 model.save_symbolic_formula("classification_formula.txt")
 ```
 
 *Example of the saved symbolic formula instructions: [outputs/classification_symbolic_formula.txt](outputs/classification_symbolic_formula.txt)*
 
-## Architecture Details
-
-OIKAN implements a novel neuro-symbolic architecture based on Kolmogorov-Arnold representation theory through three specialized components:
-
-1. **Edge Symbolic Layer**: Learns interpretable single-variable transformations
-   - Adaptive basis function composition using 9 core functions:
-     ```python
-     ADVANCED_LIB = {
-         'x':    ('x', lambda x: x),
-         'x^2':  ('x^2', lambda x: x**2),
-         'x^3':  ('x^3', lambda x: x**3),
-         'exp':  ('exp(x)', lambda x: np.exp(x)),
-         'log':  ('log(x)', lambda x: np.log(abs(x) + 1)),
-         'sqrt': ('sqrt(x)', lambda x: np.sqrt(abs(x))),
-         'tanh': ('tanh(x)', lambda x: np.tanh(x)),
-         'sin':  ('sin(x)', lambda x: np.sin(x)),
-         'abs':  ('abs(x)', lambda x: np.abs(x))
-     }
-     ```
-   - Each input feature is transformed through these basis functions
-   - Learnable weights determine the optimal combination
-
-2. **Neural Composition Layer**: Multi-layer feature aggregation
-   - Direct feature-to-feature connections through KAN layers
-   - Dropout regularization (p=0.1 default) for robust learning
-   - Gradient clipping (max_norm=1.0) for stable training
-   - User-configurable hidden layer dimensions
-
-3. **Symbolic Extraction Layer**: Generates production-ready formulas
-   - Weight-based term pruning (threshold=1e-4)
-   - Automatic coefficient optimization
-   - Human-readable mathematical expressions
-   - Exportable to lightweight production code
-
 ### Architecture Diagram
 
 ![Architecture Diagram](https://raw.githubusercontent.com/silvermete0r/oikan/main/docs/media/oikan_model_architecture_v0.0.2.2.png)
@@ -152,45 +145,26 @@ OIKAN implements a novel neuro-symbolic architecture based on Kolmogorov-Arnold
 
 1. **Interpretability First**: All transformations maintain clear mathematical meaning
 2. **Scikit-learn Compatibility**: Familiar `.fit()` and `.predict()` interface
-3. **Production Ready**: Export formulas as lightweight mathematical expressions
+3. **Symbolic Formula Exporting**: Export formulas as lightweight mathematical expressions
 4. **Automatic Simplification**: Remove insignificant terms (|w| < 1e-4)
 
-## Model Components
 
-1. **Symbolic Edge Functions**
-   ```python
-   class EdgeActivation(nn.Module):
-       """Learnable edge activation with basis functions"""
-       def forward(self, x):
-           return sum(self.weights[i] * basis[i](x) for i in range(self.num_basis))
-   ```
+### Key Model Components
 
-2. **KAN Layer Implementation**
-   ```python
-   class KANLayer(nn.Module):
-       """Kolmogorov-Arnold Network layer"""
-       def forward(self, x):
-           edge_outputs = [self.edges[i](x[:,i]) for i in range(self.input_dim)]
-           return self.combine(edge_outputs)
-   ```
+1. **EdgeActivation Layer**:
+   - Implements interpretable basis function transformations
+   - Automatically prunes insignificant terms
+   - Maintains mathematical transparency
 
-3. **Formula Extraction**
-   ```python
-   def get_symbolic_formula(self):
-       """Extract interpretable mathematical expression"""
-       terms = []
-       for i, edge in enumerate(self.edges):
-           if abs(self.weights[i]) > threshold:
-               terms.append(f"{self.weights[i]:.4f} * {edge.formula}")
-       return " + ".join(terms)
-   ```
-
-### Key Design Principles
+2. **Formula Extraction**:
+   - Combines edge transformations with learned weights
+   - Applies symbolic simplification
+   - Generates human-readable expressions
 
-- **Modular Architecture**: Each component is independent and replaceable
-- **Interpretability First**: All transformations maintain symbolic representations
-- **Automatic Simplification**: Removes insignificant terms and combines similar expressions
-- **Production Ready**: Export formulas for lightweight deployment
+3. **Training Process**:
+   - Gradient-based optimization of edge weights
+   - Automatic feature importance detection
+   - Complexity control through regularization
 
 ## Contributing
 

oikan-0.0.2.5.dist-info/RECORD

@@ -0,0 +1,9 @@
+oikan/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+oikan/exceptions.py,sha256=UqT3uTtfiB8QA_3AMvKdHOme9WL9HZD_d7GHIk00LJw,394
+oikan/model.py,sha256=O5ozMUNCG-d7y5du1uG96psEgwMsN6H9CLQDtCg-AmM,21580
+oikan/utils.py,sha256=nLbzycmtNCj8806delPsLcKMaBuFhTHtrKXCf1NDMb0,2062
+oikan-0.0.2.5.dist-info/licenses/LICENSE,sha256=75ASVmU-XIpN-M4LbVmJ_ibgbzbvRLVti8FhnR0BTf8,1096
+oikan-0.0.2.5.dist-info/METADATA,sha256=3AgQFr8-ihylBaSKlYBDbRnU8yAajf_fRW8fJVOAGCM,7283
+oikan-0.0.2.5.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+oikan-0.0.2.5.dist-info/top_level.txt,sha256=XwnwKwTJddZwIvtrUsAz-l-58BJRj6HjAGWrfYi_3QY,6
+oikan-0.0.2.5.dist-info/RECORD,,

oikan/symbolic.py

@@ -1,28 +0,0 @@
-from .utils import ADVANCED_LIB
-
-def symbolic_edge_repr(weights, bias=None, threshold=1e-4):
-    """
-    Given a list of weights (floats) and an optional bias,
-    returns a list of structured terms (coefficient, basis function string).
-    """
-    terms = []
-    # weights should be in the same order as ADVANCED_LIB.items()
-    for (_, (notation, _)), w in zip(ADVANCED_LIB.items(), weights):
-        if abs(w) > threshold:
-            terms.append((w, notation))
-    if bias is not None and abs(bias) > threshold:
-        # use "1" to represent the constant term
-        terms.append((bias, "1"))
-    return terms
-
-def format_symbolic_terms(terms):
-    """
-    Formats a list of structured symbolic terms (coef, basis) to a string.
-    """
-    formatted_terms = []
-    for coef, basis in terms:
-        if basis == "1":
-            formatted_terms.append(f"{coef:.4f}")
-        else:
-            formatted_terms.append(f"{coef:.4f}*{basis}")
-    return " + ".join(formatted_terms) if formatted_terms else "0"

oikan-0.0.2.3.dist-info/RECORD

@@ -1,10 +0,0 @@
-oikan/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-oikan/exceptions.py,sha256=UqT3uTtfiB8QA_3AMvKdHOme9WL9HZD_d7GHIk00LJw,394
-oikan/model.py,sha256=iHWKjk_n0Kkw47UO2XFTc0faqGYBrQBJhmmRn1Po4qw,19604
-oikan/symbolic.py,sha256=TtalmSpBecf33_g7yE3q-RPuCVRWQNaXWE4LsCNZmfg,1040
-oikan/utils.py,sha256=sivt_8jzATH-eUZ3-P-tsdmyIgKsayibSZeP_MtLTfU,1969
-oikan-0.0.2.3.dist-info/licenses/LICENSE,sha256=75ASVmU-XIpN-M4LbVmJ_ibgbzbvRLVti8FhnR0BTf8,1096
-oikan-0.0.2.3.dist-info/METADATA,sha256=pr8kHktQQPBk9QA_gchl_ynHzCWWv6j9lib9dmXuYi0,8554
-oikan-0.0.2.3.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-oikan-0.0.2.3.dist-info/top_level.txt,sha256=XwnwKwTJddZwIvtrUsAz-l-58BJRj6HjAGWrfYi_3QY,6
-oikan-0.0.2.3.dist-info/RECORD,,