Added new example image for README.MD

Author: Nucs

docfx_project/images/python-csharp-comparision.png

@@ -0,0 +1,72 @@
+namespace NumSharp.UnitTest.Others
+{
+    public class LinearRegression {
+        private float alpha;
+        private int n_iter;
+        private int n_samples;
+        private int n_features;
+        private NDArray X;
+        private NDArray y;
+        private NDArray @params;
+        private NDArray coef_;
+        private float? intercept_;
+
+        public LinearRegression(NDArray X, NDArray y, float alpha = 0.03f, int n_iter = 1500) {
+            this.alpha = alpha;
+            this.n_iter = n_iter;
+            this.n_samples = y.size;
+            this.n_features = np.size(X, 1);
+            this.X = np.hstack(np.ones(this.n_samples, 1), 
+                                    (X - np.mean(X, 0) / np.std(X, 0)));
+            this.y = np.expand_dims(y, -1);
+            this.@params = np.zeros((this.n_features + 1, 1), NPTypeCode.Single);
+            this.coef_ = null;
+            this.intercept_ = null;
+        }
+
+        public LinearRegression fit() {
+            for (int i = 0; i < this.n_iter; i++) {
+                this.@params = this.@params - (this.alpha / this.n_samples) *
+                               np.matmul(this.X.T, np.matmul(this.X, this.@params) - this.y);
+            }
+            
+            this.intercept_ = @params.GetSingle(0);
+            this.coef_ = @params["1:"];
+            
+            return this;
+        }
+
+        public float score(NDArray X = null, NDArray y = null) {
+            if (X is null)
+                X = this.X;
+            else {
+                n_samples = np.size(X, 0);
+                this.X = np.hstack(np.ones(this.n_samples, 1), 
+                    (X - np.mean(X, 0) / np.std(X, 0)));
+            }
+
+            if (y is null) {
+                y = this.y;
+            } else
+                y = np.expand_dims(y, -1);
+
+            var y_pred = np.matmul(X, @params);
+            var score = 1 - ((np.power((y - y_pred), 2)).sum() / (np.power(y - y.mean(), 2)).sum());
+
+            return score;
+        }
+
+        public NDArray predict(NDArray X) {
+            n_samples = np.size(X, 0);
+            y = np.matmul(
+                    np.hstack(np.ones(this.n_samples, 1), (X - np.mean(X, 0) / np.std(X, 0))), 
+                    @params
+                );
+
+            return y;
+        }
+
+        public NDArray get_params() 
+            => @params;
+    }
+}

test/NumSharp.UnitTest/Others/ReadmeExample.cs

@@ -0,0 +1,63 @@
+import numpy as np
+from sklearn.datasets import load_boston
+import matplotlib.pyplot as plt
+class LinearRegression():
+    def __init__(self, X: np.ndarray, y, alpha=0.03, n_iter=1500):
+        self.alpha = alpha
+        self.n_iter = n_iter
+        self.n_samples = len(y)
+        self.n_features = np.size(X, 1)
+        self.X = np.hstack((np.ones((self.n_samples, 1)), 
+                            (X - np.mean(X, 0)) / np.std(X, 0)))
+        self.y = np.expand_dims(y, -1)
+        self.params = np.zeros((self.n_features + 1, 1))
+        self.coef_ = None
+        self.intercept_ = None
+
+
+    def fit(self):
+        for i in range(self.n_iter):
+            self.params = self.params - (self.alpha/self.n_samples) * \
+            self.X.T @ (self.X @ self.params - self.y)
+
+
+        self.intercept_ = self.params[0]
+        self.coef_ = self.params[1:]
+
+        return self
+
+
+
+    def score(self, X=None, y=None):
+        if X is None:
+            X = self.X
+        else:
+            n_samples = np.size(X, 0)
+            X = np.hstack((np.ones((n_samples, 1)), 
+                           (X - np.mean(X, 0)) / np.std(X, 0)))
+
+
+        if y is None:
+            y = self.y
+        else:
+            y = np.expand_dims(y, -1)
+
+        y_pred = X @ self.params
+        score = 1 - (((y - y_pred)**2).sum() / ((y - y.mean())**2).sum())
+
+        return score
+
+
+
+    def predict(self, X):
+        n_samples = np.size(X, 0)
+        y = np.hstack((np.ones((n_samples, 1)), (X-np.mean(X, 0)) \
+                            / np.std(X, 0))) @ self.params
+        return y
+
+
+
+
+
+    def get_params(self):
+        return self.params