simple-regression-grqphical 0.0.1__tar.gz

simple_regression_grqphical-0.0.1/.gitignore

@@ -0,0 +1,7 @@
+venv/
+.venv/
+env/
+dist/
+build/
+*.egg-info/
+__pycache__/

simple_regression_grqphical-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Nathan Jacobson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

simple_regression_grqphical-0.0.1/PKG-INFO

@@ -0,0 +1,17 @@
+Metadata-Version: 2.4
+Name: simple_regression_grqphical
+Version: 0.0.1
+Summary: This is a simple implementation of Linear Regression using the method of Least Squares
+Author-email: Nathan Jacobson <nathan@nathanjacobson.ca>
+License-File: LICENSE
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+
+# Simple Regression
+This is a super simple implementation of Linear Regression, built from scratch using numpy.
+
+## License
+This project is licensed under the MIT License

simple_regression_grqphical-0.0.1/README.md

@@ -0,0 +1,5 @@
+# Simple Regression
+This is a super simple implementation of Linear Regression, built from scratch using numpy.
+
+## License
+This project is licensed under the MIT License

simple_regression_grqphical-0.0.1/pyproject.toml

@@ -0,0 +1,21 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "simple_regression_grqphical"
+version = "0.0.1"
+authors = [
+  { name="Nathan Jacobson", email="nathan@nathanjacobson.ca" },
+]
+description = "This is a simple implementation of Linear Regression using the method of Least Squares"
+readme = "README.md"
+requires-python = ">=3.7"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/simple_regression"]

simple_regression_grqphical-0.0.1/src/simple_regression/__init__.py

@@ -0,0 +1 @@
+from .simple_regression import LinearRegression

simple_regression_grqphical-0.0.1/src/simple_regression/simple_regression.py

@@ -0,0 +1,52 @@
+"""This is a simple implementation of LinearRegression using the method of Least Squares"""
+import numpy as np
+from typing import List, Tuple
+
+class LinearRegression:
+    """Represents a LinearRegression model that can be trained by giving it input points."""
+    def __init__(self, data: List[Tuple[float, float]]):
+        """
+        :param data: The data to train the model on, should be a list of tuples representing points in 2D space
+        """
+        self.data = data
+        self.design_matrix = np.ones((len(data), 2))
+        self.result_vector = np.zeros(len(data))
+        
+        self._generate_coefficients()
+
+    def _generate_coefficients(self):
+        """Generates the coefficients by using the method of least squares"""
+        self.design_matrix = np.ones((len(self.data), 2))
+        self.result_vector = np.zeros(len(self.data))
+        
+        for i, point in enumerate(self.data):
+            x, y = point
+            self.result_vector[i] = y
+            self.design_matrix[i][1] = x
+
+        X = self.design_matrix
+        y  = self.result_vector
+        
+        XTX = X.T @ X
+        XTy = X.T @ y
+        self.coefficients = np.linalg.solve(XTX, XTy)
+
+    def train(self, data: List[Tuple[float, float]]):
+        """
+        Trains the model on new data, changing the coefficients
+
+        :param data: The data to train the model on, should be a list of tuples representing points in 2D space
+        """
+        self.data += data
+        self._generate_coefficients()
+    
+    def predict(self, x: float) -> float:
+        """
+        Uses the coefficients stored in the class to predict the output of the given input data.
+
+        :param x: X coordinate (input) of data to predict
+        :returns: The predicted value (Y-Coordinate)
+        :raises AssertionError: If the coefficients haven't been generated an exception will be raised. However this should NEVER happen
+        """
+        assert len(self.coefficients) == 2 # this should always be true
+        return self.coefficients[0] + self.coefficients[1] * x # y = a + bx

simple_regression_grqphical-0.0.1/tests/simple_regression_tests.py

@@ -0,0 +1,49 @@
+import unittest
+from simple_regression import LinearRegression
+import numpy as np
+
+class TestLinearRegression(unittest.TestCase):
+    def test_initialization(self):
+        expected_design_matrix = np.array([
+            [1, 0],
+            [1, 1],
+            [1, 2],
+            [1, -3],
+        ])
+        expected_result_vector = np.array([0,3,5,7])
+
+        data = [(0,0), (1, 3), (2, 5), (-3, 7)]
+        lr = LinearRegression(data)
+        
+        np.testing.assert_array_equal(lr.design_matrix, expected_design_matrix)
+        np.testing.assert_array_equal(lr.result_vector, expected_result_vector)
+
+    def test_coefficients(self):
+        expected = np.array([5, -1])
+
+        data = [(3,4), (-1, 8), (1,0)]
+        lr = LinearRegression(data)
+
+        np.testing.assert_array_equal(lr.coefficients, expected)
+    
+    def test_regression(self):
+        expected = 5 # y-intercept should be 5
+
+        data = [(3,4), (-1, 8), (1,0)]
+        lr = LinearRegression(data)
+        prediction = lr.predict(0)
+
+        self.assertEqual(prediction, expected)
+    
+    def test_training(self):
+        expected = np.array([5, -1])
+
+        data = [(3,4), (-1, 8)]
+        lr = LinearRegression(data)
+
+        lr.train([(1,0)])
+
+        np.testing.assert_array_equal(lr.coefficients, expected)
+
+if __name__ == '__main__':
+    unittest.main()