From 369ec06775c76a1e5f46def8bb3893a4de591d3d Mon Sep 17 00:00:00 2001
From: Pedro Albuquerque <pedro.melo.albuquerque@gmail.com>
Date: Wed, 27 Sep 2023 04:04:06 +0000
Subject: [PATCH 01/10] Add some examples

---
 examples.ipynb | 229 +++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 229 insertions(+)
 create mode 100644 examples.ipynb

diff --git a/examples.ipynb b/examples.ipynb
new file mode 100644
index 00000000..c53799b4
--- /dev/null
+++ b/examples.ipynb
@@ -0,0 +1,229 @@
+{
+    "cells": [
+        {
+            "cell_type": "markdown",
+            "id": "ac622319",
+            "metadata": {},
+            "source": [
+                "# Descriptive statistics examples"
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "id": "aa8993e4",
+            "metadata": {},
+            "source": [
+                "### Example 1"
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "id": "5e0ab0d5",
+            "metadata": {},
+            "source": [
+                "Show by coding one example that the mean is the estimator with the Minimum Square Error and give the intuiton on that.\n",
+                "\n",
+                "Note:\n",
+                "\n",
+                "$$\n",
+                "MSE=\\sum_{i=1}^{n}(X_{i}-\\mu)^2\n",
+                "$$\n",
+                "\n",
+                "Consider the following array `X=[3,5,6,3,1,5,7,9,5,4]`"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 5,
+            "id": "34720ab6",
+            "metadata": {},
+            "outputs": [
+                {
+                    "name": "stdout",
+                    "output_type": "stream",
+                    "text": [
+                        "Estimated mu: 4.799999977760703\n",
+                        "Minimum MSE: 45.6\n",
+                        "Populational mu: 4.8\n"
+                    ]
+                }
+            ],
+            "source": [
+                "# TODO\n"
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "id": "46c70c3d",
+            "metadata": {},
+            "source": [
+                "### Example 2\n",
+                "\n",
+                "Consider this data:\n",
+                "````\n",
+                "import numpy as np\n",
+                "import matplotlib.pyplot as plt\n",
+                "\n",
+                "# Set a seed for reproducibility\n",
+                "np.random.seed(0)\n",
+                "\n",
+                "# Generate left-skewed data using the gamma distribution\n",
+                "shape = 2  # Shape parameter (controls skewness, adjust as needed)\n",
+                "scale = 1  # Scale parameter (controls spread, adjust as needed)\n",
+                "size = 1000  # Number of data points\n",
+                "\n",
+                "# Generate left-skewed data\n",
+                "data = np.random.gamma(shape, scale, size)\n",
+                "\n",
+                "# Create a histogram\n",
+                "plt.hist(data, bins=30, density=True, alpha=0.6, color='b', label='Left-Skewed Data')\n",
+                "\n",
+                "# Add labels and a legend\n",
+                "plt.xlabel('Value')\n",
+                "plt.ylabel('Frequency')\n",
+                "plt.title('Left-Skewed Distribution')\n",
+                "plt.legend(loc='upper right')\n",
+                "\n",
+                "# Show the plot\n",
+                "plt.show()\n",
+                "````\n",
+                "\n",
+                "1. Run the code.\n",
+                "2. Shows that the distribution of the mean will follow a normal distribution"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 18,
+            "id": "d590308e",
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "# TODO"
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "id": "00a7f40c",
+            "metadata": {},
+            "source": [
+                "### Example 3\n",
+                "\n",
+                "Consider this data:\n",
+                "````\n",
+                "import numpy as np\n",
+                "import matplotlib.pyplot as plt\n",
+                "\n",
+                "# Set a seed for reproducibility\n",
+                "np.random.seed(0)\n",
+                "\n",
+                "# Parameters for the uniform distribution\n",
+                "low = 0  # Lower bound\n",
+                "high = 10  # Upper bound\n",
+                "size = 1000  # Number of data points\n",
+                "\n",
+                "# Generate random data from a uniform distribution\n",
+                "data = np.random.uniform(low, high, size)\n",
+                "\n",
+                "# Create a histogram\n",
+                "plt.hist(data, bins=30, density=True, alpha=0.6, color='b', label='Uniform Data')\n",
+                "\n",
+                "# Add labels and a legend\n",
+                "plt.xlabel('Value')\n",
+                "plt.ylabel('Frequency')\n",
+                "plt.title('Uniform Distribution')\n",
+                "plt.legend(loc='upper right')\n",
+                "\n",
+                "# Show the plot\n",
+                "plt.show()\n",
+                "````\n",
+                "\n",
+                "1. Run the code.\n",
+                "2. Shows that the distribution of the mean will follow a normal distribution"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 17,
+            "id": "12f8030c",
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "# TODO\n"
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "id": "2767a3c8",
+            "metadata": {},
+            "source": [
+                "### Example 4\n",
+                "\n",
+                "1. Simulate a normal distribution\n",
+                "2. Plot the histogram and add a vertical line for the mean and median.\n",
+                "3. Begin to add outliers and see how the mean, median and mode are affected.\n"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 33,
+            "id": "214ecc0d",
+            "metadata": {},
+            "outputs": [
+                {
+                    "data": {
+                        "image/png": "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",
+                        "text/plain": [
+                            "<Figure size 640x480 with 1 Axes>"
+                        ]
+                    },
+                    "metadata": {},
+                    "output_type": "display_data"
+                }
+            ],
+            "source": [
+                "# TODO\n"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "id": "0ea06451",
+            "metadata": {},
+            "outputs": [],
+            "source": []
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "id": "a0e55e5c",
+            "metadata": {},
+            "outputs": [],
+            "source": []
+        }
+    ],
+    "metadata": {
+        "interpreter": {
+            "hash": "9248718ffe6ce6938b217e69dbcc175ea21f4c6b28a317e96c05334edae734bb"
+        },
+        "kernelspec": {
+            "display_name": "Python 3.9.12 ('ML-BOOTCAMP')",
+            "language": "python",
+            "name": "python3"
+        },
+        "language_info": {
+            "codemirror_mode": {
+                "name": "ipython",
+                "version": 3
+            },
+            "file_extension": ".py",
+            "mimetype": "text/x-python",
+            "name": "python",
+            "nbconvert_exporter": "python",
+            "pygments_lexer": "ipython3",
+            "version": "3.11.4"
+        }
+    },
+    "nbformat": 4,
+    "nbformat_minor": 5
+}

From a255f5288eadd94306661803e68c80d3a13cb775 Mon Sep 17 00:00:00 2001
From: bobo305 <126503694+bobo305@users.noreply.github.com>
Date: Fri, 29 Sep 2023 11:45:47 +0000
Subject: [PATCH 02/10] added julio work folder and all done with the excercies

---
 JULIOs_work/problems.ipynb | 176 +++++++++++++++++++++++++++++++++++++
 notebook/problems.ipynb    |  90 -------------------
 2 files changed, 176 insertions(+), 90 deletions(-)
 create mode 100644 JULIOs_work/problems.ipynb
 delete mode 100644 notebook/problems.ipynb

diff --git a/JULIOs_work/problems.ipynb b/JULIOs_work/problems.ipynb
new file mode 100644
index 00000000..d8b5691c
--- /dev/null
+++ b/JULIOs_work/problems.ipynb
@@ -0,0 +1,176 @@
+{
+    "cells": [
+        {
+            "cell_type": "markdown",
+            "id": "ac622319",
+            "metadata": {},
+            "source": [
+                "# Descriptive statistics problems"
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "id": "aa8993e4",
+            "metadata": {},
+            "source": [
+                "### Exercise 1"
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "id": "5e0ab0d5",
+            "metadata": {},
+            "source": [
+                "We will use Numpy to obtain information to describe statistically.\n",
+                "\n",
+                "- Generate an array of 100 elements following a normal distribution.\n",
+                "- Generate an array of 100 elements following a chi-square distribution with 3 degrees of freedom.\n",
+                "- Calculate the main metrics and statistical measures that best describe the two vectors."
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 3,
+            "id": "34720ab6",
+            "metadata": {},
+            "outputs": [
+                {
+                    "name": "stdout",
+                    "output_type": "stream",
+                    "text": [
+                        "stats metrics for normal disturbution\n",
+                        "mean: -0.06865936071598043\n",
+                        "stander deviation: 0.9697609573818616\n",
+                        "meadian: -0.12619537311221996\n",
+                        "min: -1.9361951382884228\n",
+                        "max: 2.277103875562215\n",
+                        "variances: 0.9404363144621848\n",
+                        "\n",
+                        "stats metrics for chi square disturbution\n",
+                        "mean: 3.14695578992872\n",
+                        "stander deviation: 2.467973134872231\n",
+                        "meadian: 2.1340973003611277\n",
+                        "min: 0.18770455963586785\n",
+                        "max: 10.0705079466792\n",
+                        "variances: 6.0908913944510665\n"
+                    ]
+                }
+            ],
+            "source": [
+                "# TODO\n",
+                "import numpy as np \n",
+                "\n",
+                "normal_distribution= np.random.normal(loc=0, scale=1,size=100)\n",
+                "\n",
+                "chi_square_distribution=np.random.chisquare(df=3,size=100)\n",
+                "\n",
+                "mean_normal=np.mean(normal_distribution)\n",
+                "std_normal=np.std(normal_distribution)\n",
+                "meadian_normal=np.median(normal_distribution)\n",
+                "min_normal=np.min(normal_distribution)\n",
+                "max_normal=np.max(normal_distribution)\n",
+                "variances_normal=np.var(normal_distribution)\n",
+                "\n",
+                "\n",
+                "\n",
+                "mean_chi_square=np.mean(chi_square_distribution)\n",
+                "std_chi_square=np.std(chi_square_distribution)\n",
+                "meadian_chi_square=np.median(chi_square_distribution)\n",
+                "min_chi_square=np.min(chi_square_distribution)\n",
+                "max_chi_square=np.max(chi_square_distribution)\n",
+                "variances_chi_square=np.var(chi_square_distribution)\n",
+                "\n",
+                "\n",
+                "\n",
+                "\n",
+                "\n",
+                "print(\"stats metrics for normal disturbution\")\n",
+                "print(\"mean:\",mean_normal)\n",
+                "print(\"stander deviation:\",std_normal)\n",
+                "print(\"meadian:\",meadian_normal)\n",
+                "print(\"min:\",min_normal)\n",
+                "print(\"max:\",max_normal)\n",
+                "print(\"variances:\",variances_normal)\n",
+                "\n",
+                "print(\"\")\n",
+                "\n",
+                "print(\"stats metrics for chi square disturbution\")\n",
+                "print(\"mean:\",mean_chi_square)\n",
+                "print(\"stander deviation:\",std_chi_square)\n",
+                "print(\"meadian:\",meadian_chi_square)\n",
+                "print(\"min:\",min_chi_square)\n",
+                "print(\"max:\",max_chi_square)\n",
+                "print(\"variances:\",variances_chi_square)"
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "id": "46c70c3d",
+            "metadata": {},
+            "source": [
+                "### Exercise 2\n",
+                "\n",
+                "Write a Python program to calculate the standard deviation of the following data:\n",
+                "\n",
+                "```py\n",
+                "data = [4, 2, 5, 8, 6]\n",
+                "```"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 6,
+            "id": "d590308e",
+            "metadata": {},
+            "outputs": [
+                {
+                    "name": "stdout",
+                    "output_type": "stream",
+                    "text": [
+                        "stander diviation is : 2.0\n"
+                    ]
+                }
+            ],
+            "source": [
+                "# TODO\n",
+                "import numpy as np\n",
+                "\n",
+                "data = [4, 2, 5, 8, 6]\n",
+                "\n",
+                "mean_value=np.mean(data)\n",
+                "\n",
+                "squared_diffrince=[(x - mean_value)** 2 for x in data]\n",
+                "\n",
+                "mean_squared_diffrence=np.mean(squared_diffrince)\n",
+                "\n",
+                "std=np.sqrt(mean_squared_diffrence)\n",
+                "\n",
+                "print(\"stander diviation is :\", std)"
+            ]
+        }
+    ],
+    "metadata": {
+        "interpreter": {
+            "hash": "9248718ffe6ce6938b217e69dbcc175ea21f4c6b28a317e96c05334edae734bb"
+        },
+        "kernelspec": {
+            "display_name": "Python 3.9.12 ('ML-BOOTCAMP')",
+            "language": "python",
+            "name": "python3"
+        },
+        "language_info": {
+            "codemirror_mode": {
+                "name": "ipython",
+                "version": 3
+            },
+            "file_extension": ".py",
+            "mimetype": "text/x-python",
+            "name": "python",
+            "nbconvert_exporter": "python",
+            "pygments_lexer": "ipython3",
+            "version": "3.11.4"
+        }
+    },
+    "nbformat": 4,
+    "nbformat_minor": 5
+}
diff --git a/notebook/problems.ipynb b/notebook/problems.ipynb
deleted file mode 100644
index ff2c594b..00000000
--- a/notebook/problems.ipynb
+++ /dev/null
@@ -1,90 +0,0 @@
-{
-    "cells": [
-        {
-            "cell_type": "markdown",
-            "id": "ac622319",
-            "metadata": {},
-            "source": [
-                "# Descriptive statistics problems"
-            ]
-        },
-        {
-            "cell_type": "markdown",
-            "id": "aa8993e4",
-            "metadata": {},
-            "source": [
-                "### Exercise 1"
-            ]
-        },
-        {
-            "cell_type": "markdown",
-            "id": "5e0ab0d5",
-            "metadata": {},
-            "source": [
-                "We will use Numpy to obtain information to describe statistically.\n",
-                "\n",
-                "- Generate an array of 100 elements following a normal distribution.\n",
-                "- Generate an array of 100 elements following a chi-square distribution with 3 degrees of freedom.\n",
-                "- Calculate the main metrics and statistical measures that best describe the two vectors."
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": 1,
-            "id": "34720ab6",
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "# TODO"
-            ]
-        },
-        {
-            "cell_type": "markdown",
-            "id": "46c70c3d",
-            "metadata": {},
-            "source": [
-                "### Exercise 2\n",
-                "\n",
-                "Write a Python program to calculate the standard deviation of the following data:\n",
-                "\n",
-                "```py\n",
-                "data = [4, 2, 5, 8, 6]\n",
-                "```"
-            ]
-        },
-        {
-            "cell_type": "code",
-            "execution_count": 2,
-            "id": "d590308e",
-            "metadata": {},
-            "outputs": [],
-            "source": [
-                "# TODO"
-            ]
-        }
-    ],
-    "metadata": {
-        "interpreter": {
-            "hash": "9248718ffe6ce6938b217e69dbcc175ea21f4c6b28a317e96c05334edae734bb"
-        },
-        "kernelspec": {
-            "display_name": "Python 3.9.12 ('ML-BOOTCAMP')",
-            "language": "python",
-            "name": "python3"
-        },
-        "language_info": {
-            "codemirror_mode": {
-                "name": "ipython",
-                "version": 3
-            },
-            "file_extension": ".py",
-            "mimetype": "text/x-python",
-            "name": "python",
-            "nbconvert_exporter": "python",
-            "pygments_lexer": "ipython3",
-            "version": "3.11.4"
-        }
-    },
-    "nbformat": 4,
-    "nbformat_minor": 5
-}

From 794e48935f7ca791ba418e5c0a1c64d59ea7f958 Mon Sep 17 00:00:00 2001
From: Pedro Albuquerque <pedro.melo.albuquerque@gmail.com>
Date: Fri, 29 Sep 2023 23:36:49 +0000
Subject: [PATCH 03/10] New changes

---
 examples.ipynb | 801 +++++++++++++++++++++++++++++++++++++++++++++++--
 1 file changed, 784 insertions(+), 17 deletions(-)

diff --git a/examples.ipynb b/examples.ipynb
index c53799b4..1dfb01d1 100644
--- a/examples.ipynb
+++ b/examples.ipynb
@@ -34,7 +34,7 @@
         },
         {
             "cell_type": "code",
-            "execution_count": 5,
+            "execution_count": 2,
             "id": "34720ab6",
             "metadata": {},
             "outputs": [
@@ -42,14 +42,259 @@
                     "name": "stdout",
                     "output_type": "stream",
                     "text": [
-                        "Estimated mu: 4.799999977760703\n",
-                        "Minimum MSE: 45.6\n",
-                        "Populational mu: 4.8\n"
+                        "52\n",
+                        "46\n",
+                        "78\n"
                     ]
                 }
             ],
             "source": [
-                "# TODO\n"
+                "import numpy as np\n",
+                "#Sample from an unknown population\n",
+                "X = np.array([3,5,6,3,1,5,7,9,5,4])\n",
+                "\n",
+                "#Define the loss function\n",
+                "#Model: X=average+error ->(X-average)**2=error**2\n",
+                "def loss(mu):\n",
+                "    loss = np.sum(np.square(X-mu))\n",
+                "    return loss\n",
+                "\n",
+                "loss_sebastian = loss(4)\n",
+                "print(loss_sebastian)\n",
+                "loss_julio = loss(5)\n",
+                "print(loss_julio)\n",
+                "loss_rob = loss(3)\n",
+                "print(loss_rob)"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 6,
+            "id": "04777a53",
+            "metadata": {},
+            "outputs": [
+                {
+                    "name": "stdout",
+                    "output_type": "stream",
+                    "text": [
+                        "  message: Optimization terminated successfully.\n",
+                        "  success: True\n",
+                        "   status: 0\n",
+                        "      fun: 45.6\n",
+                        "        x: [ 4.800e+00]\n",
+                        "      nit: 3\n",
+                        "      jac: [ 4.768e-07]\n",
+                        " hess_inv: [[ 5.000e-02]]\n",
+                        "     nfev: 8\n",
+                        "     njev: 4\n",
+                        "The best possible average here that minimizes the MSE is [4.79999998]\n",
+                        "4.8\n"
+                    ]
+                }
+            ],
+            "source": [
+                "from scipy.optimize import minimize\n",
+                "initial_guess = [0.0]\n",
+                "result = minimize(loss,initial_guess,method='BFGS')\n",
+                "print(result)\n",
+                "print(f\"The best possible average here that minimizes the MSE is {result.x}\")\n",
+                "print(np.average(X))"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 8,
+            "id": "20626934",
+            "metadata": {},
+            "outputs": [
+                {
+                    "name": "stdout",
+                    "output_type": "stream",
+                    "text": [
+                        "[37.6271033  49.25801358 51.76774607 36.22546304 50.2132896  52.29252132\n",
+                        " 33.47598315 33.29169425 45.1421923  31.69617333 39.07981848 16.64922406\n",
+                        " 44.46305569 41.53569879 22.26300143 40.12042989 28.59536197 31.28348567\n",
+                        " 21.24463275 43.64034352 36.29472538 39.79036744 42.92675803 44.08036314\n",
+                        " 27.0221942  42.92165963 53.93568164 15.58799329 35.97759084 35.80911123\n",
+                        " 25.40344864 25.51276397 41.78591563 41.33882332 37.71804396 21.47226349\n",
+                        " 40.88133846 30.42494425 38.75105351 16.68685628 40.75261067 22.59483673\n",
+                        " 23.57046488 51.30310644 47.90359289 47.1199625  37.55664582 58.67891991\n",
+                        " 47.08333506 43.6471633  21.06627581 44.93842797 14.38227947 41.45057177\n",
+                        " 45.42567627 40.2609248  42.89635126 32.18323302 35.8783009  27.55322583\n",
+                        " 59.5951662  26.34265514 40.95002397 28.92083714 51.87142965 21.60613623\n",
+                        " 32.74510322 38.46097479 32.62149649 53.04653142 28.87114162 11.46899169\n",
+                        " 35.45433171 27.71723734 38.90942471 42.35887831 29.54521078 49.88116249\n",
+                        " 33.16924025 21.20547362 31.95823146 39.01894124 35.73001942 30.54317492\n",
+                        " 40.7309696  45.25116668 45.9546001  31.35156271 34.92569278 17.84320411\n",
+                        " 24.74321922 38.44962732 29.94635049 23.92951639 41.99514909 37.29367923\n",
+                        " 35.15682342 33.65987009 37.33368372 38.53353645 17.00252505 30.85557975\n",
+                        " 36.8799357  58.71850189 48.77093693 28.4106544  58.67011582 20.71058889\n",
+                        " 33.31723303 37.42226549 30.47728508 33.00324757 19.26339148 29.03583959\n",
+                        " 36.34123226 28.65708345 41.28780185 34.33694268 42.17958478 37.73892854\n",
+                        " 42.64160312 42.25986371 24.09219286 39.16890286 34.30521295 43.72606268\n",
+                        " 27.18128429 27.74442911 30.63108595 32.42735047 40.34309029 46.76953512\n",
+                        " 26.6181258  36.08910601 40.50778811 29.71097985 38.37919364 41.90300174\n",
+                        " 44.01173702 14.15731694 39.40005042 28.29002221 42.06454206 34.53417982\n",
+                        " 27.73660596 34.19351329 37.91951724 35.86194868 29.8935498  28.87236472\n",
+                        " 50.68483437 46.93282718 31.87627262 28.20381135 54.46247685 40.17232149\n",
+                        " 31.71801618 47.58242128 43.70776522 26.97317688 30.18391217 24.05483354\n",
+                        " 39.2945252  52.8269084  31.37036501 34.04346011 34.0168272  26.33779038\n",
+                        " 15.68519601 31.84014651 45.94614595 64.25252122 45.80270718 27.24683399\n",
+                        " 37.76055132 33.0356684  37.52237593 36.01707258 28.77881565 21.49235339\n",
+                        " 40.10557049 39.1053993  35.13057905 35.81233478 27.93090141 22.37256416\n",
+                        " 22.82835302 49.24594157 36.23375508 55.39824433 29.01726643 21.49416128\n",
+                        " 23.56604505 39.24976814 32.71944097 48.3173851  31.06737474 37.31946933\n",
+                        " 40.42457929 42.89022305 45.69393401 31.3760351  17.59115958 29.70300547\n",
+                        " 21.31643697 47.10826079 23.28275195 33.03813277 43.92689062 47.33194067\n",
+                        " 29.70881912 42.92083624 33.80712178 24.28087218 15.4272794  33.32847469\n",
+                        " 28.08721416 43.68647972 51.26621606 35.7289691  28.49790139 28.10140322\n",
+                        " 25.01076195 27.2121548  19.60673721 38.32378982 26.44174062 25.15051975\n",
+                        " 30.43094758 37.23872964 33.25837534 43.7353568  36.48502961 28.88881192\n",
+                        "  8.47679619 42.80186816 24.93626472 33.54017974 31.38396491 34.08251503\n",
+                        " 51.40049866 52.01859962 30.6907358  42.37705602 40.0831406  25.60653407\n",
+                        " 52.02401579 37.77617654 36.8180199  32.19304171 28.73822811  6.87340965\n",
+                        " 31.31660581 59.72930619 24.5956038  46.15265017 35.5047154  36.55953597\n",
+                        " 27.04767252 25.88642944 33.59118716 38.308081   26.45077719 38.34037476\n",
+                        " 25.69180679 30.58337288 33.46503559 30.45264568 27.72887534 37.38843452\n",
+                        " 25.00844618 33.81717209 34.48593226 37.12173383 40.49733151 35.87491923\n",
+                        " 20.58005942 35.64449106 33.04352454 37.06453805 29.30047899 44.80481871\n",
+                        " 45.478548   34.14161754 32.85733386 46.21229663 28.43302224 43.74762588\n",
+                        " 30.69849614 40.32553244 25.56395672 28.38307257 41.56990364 33.23794221\n",
+                        " 36.52646544 40.04885067 31.09838921 53.03270673 45.52241649 29.03175008\n",
+                        " 33.87863844 27.87869243 19.68766676 16.73992158 49.53369811 30.78795999\n",
+                        " 36.15056609 57.04903192 54.30629366 41.7722212  43.49585261 37.58210314\n",
+                        " 44.99784533 37.13064995 46.78135688 37.2399462  59.47026759 22.89722777\n",
+                        " 31.10253484 37.37357557 45.32189819 36.91006224 34.14291689 45.70301376\n",
+                        " 28.56414997 34.39922509 32.20884682 47.25931746 21.84499179 42.32438158\n",
+                        " 31.76288443 34.10348622 35.47645795 45.94195147 16.08864947 31.45474501\n",
+                        " 25.01768142 30.91915374 23.37797127 30.51707643 41.6452885  46.27321834\n",
+                        " 27.35955692 36.69504422 35.86885794 34.06295175 18.20374947 30.67715446\n",
+                        " 25.98299347 32.08140715 27.01210319 35.77896065 29.57560069 35.81726664\n",
+                        " 51.73358451 28.17674702 49.85585551 20.27533073 29.75737735 26.92718929\n",
+                        " 29.18608153 31.33606607 47.32348256 44.78818107 49.87525436 54.37068854\n",
+                        " 37.17813517 27.08510907 37.01053391 31.70403648 20.12252376 29.86800328\n",
+                        " 30.96901501 27.88858463 38.79726511 38.24965508 35.4723428  41.60353312\n",
+                        " 42.35877855 27.44766177 22.8172199  48.31092697 24.75297227 39.47912163\n",
+                        " 44.88777996 52.63077229 53.12375124 28.21980233 26.96067221 42.00635257\n",
+                        " 38.86017267 39.90899855 27.16387498 25.3107997  32.16652486 49.8775466\n",
+                        " 33.00255261 37.99004831 37.0523635  33.70075964 21.93285206 45.60234218\n",
+                        " 24.81843936 45.14834183 27.1558057  30.93362051 60.69170715 47.14031023\n",
+                        " 55.71759271 22.81929522 48.95898857 31.58654194 34.38132172 36.19659629\n",
+                        " 33.73701082 30.21185042 34.04335083 37.342922   45.43888311 26.20141771\n",
+                        " 37.56772188 36.07122086 51.2604662  38.28882591 46.05301764 22.92610221\n",
+                        " 43.98426988 24.63392141 53.1954661  46.34769484 36.26755507 20.40459942\n",
+                        " 40.98319971 39.11350058 41.55966377 31.9028619  41.06335146 25.61709318\n",
+                        " 27.25301991 30.17365721 22.45456682 40.20870966 35.10999385 22.51787005\n",
+                        " 19.710662   42.72933812 39.12090834 26.21576534 36.41849103 32.02162921\n",
+                        " 34.39417486 38.0533805  35.14770989 25.50996381 47.17279431 29.89374567\n",
+                        " 21.53513763 42.12579909 43.42316389 38.33001622 25.42705137 21.39660966\n",
+                        " 36.24277658 36.37626856 24.24420036 27.98874405 40.39879296 27.81771545\n",
+                        " 34.80368715 31.69797969 32.93309873 20.84028137 37.94723726 38.70398579\n",
+                        " 34.72272385 36.73491879 39.62436491 18.91914884 51.45619604 53.87208928\n",
+                        " 43.12896797 44.48837392 32.78176185 28.5209871  47.73275021 35.40403545\n",
+                        " 32.09242376 23.79112629 20.30874637 34.1527622  42.40065475 25.81785316\n",
+                        " 42.61344543 34.54718919 28.33044236 20.47876962 30.94956565 29.32865614\n",
+                        " 43.69635954 34.16016302 31.83089663 41.51065159 27.63431413 36.27974179\n",
+                        " 24.34445274 22.25187321 46.97955498 32.14865657 40.21304627 46.08822956\n",
+                        " 33.73338325 38.15488948 32.03095418 28.88133836 38.32902539 51.11385924\n",
+                        " 21.85178061 36.95591335 36.12394652 45.14274979 46.28499451 36.38677249\n",
+                        " 40.01872064 39.40698998 42.4601263  54.10675324 42.96062214 15.13892265\n",
+                        " 38.21812224 30.0684173  29.14213711 41.17387124 38.816888   50.17605158\n",
+                        " 42.65308097 33.08865337 31.96771417 33.11152265 33.17460256 28.49072814\n",
+                        " 27.01665856 30.30075813 34.71173089 37.79908716 28.05618723 33.05763839\n",
+                        " 43.29680192 45.14199094 31.62513387 26.28032018 40.9609272  42.34200181\n",
+                        " 36.09794431 19.20164807 26.17557974 35.51174555 28.73878925 46.0690601\n",
+                        " 24.25705377 56.71584853 26.49879721 28.11708707 32.4378332  51.8286247\n",
+                        " 44.51676618 34.28565391 42.6842464  29.50020428 36.55510181 46.5041759\n",
+                        " 33.83579774 22.93901401 50.70090422 31.38041174 33.13649345 30.20879415\n",
+                        " 33.69211786 17.52455314 37.60269218 41.42647786 37.95337958 28.91468894\n",
+                        " 42.57456418 42.82568052 28.77215427 23.04708821 36.90414174 27.62126509\n",
+                        " 42.72648944 27.87455518 13.14431961 25.07555968 40.85238456 29.3856915\n",
+                        " 48.02815202 25.05756998 42.52854966 39.62275343 28.01534438 29.63913156\n",
+                        " 38.81391413 32.75447654 37.19536911 44.59718681 15.19833643 34.45629317\n",
+                        " 55.4866157  37.35520707 38.49202261 31.02691191 26.61860874 40.48343272\n",
+                        " 44.77764451 21.34758406  4.25235367 39.20309797 28.78636928 21.55752219\n",
+                        " 52.22937556 38.41535476 30.52415089 36.22484696 42.14709895 28.57674673\n",
+                        " 35.22047217 43.38572917 38.1969869  34.3153107  38.31646818 46.74988571\n",
+                        " 27.48195934 37.56405542 45.41356082 30.65766971 20.42654532 37.12904577\n",
+                        " 36.84539366 55.88972075 44.01461788 23.27388926 35.15092116 47.62952487\n",
+                        " 30.98326792 21.24782571 35.86328502 45.18804163 40.25893958 33.45153073\n",
+                        " 24.92899299 30.7139417  44.95338101 43.11879029 34.72228902 36.67756086\n",
+                        " 32.22263432 30.3183397  50.63641709 42.52339935 28.03036458 44.71312325\n",
+                        " 31.65915943 19.75529224 48.35642314 39.07611962 43.34611629 35.95571245\n",
+                        " 47.59812422 34.22379036 38.12069392 30.56062644 22.82807128 31.61991098\n",
+                        " 36.62046516 37.43415848 24.58999172 46.48461169 32.56418452 33.32841156\n",
+                        " 35.16715432 41.56322131 43.55272442 51.89386671 21.53952737 46.70630144\n",
+                        " 38.2971253  31.98021485 21.99317535 57.23052554 20.91282493 43.41955171\n",
+                        " 50.22359797 49.0434095  14.64158345 36.45297714 25.65869071 29.11951102\n",
+                        " 32.46281845 35.64078196 63.62762105 46.9354579  26.71195957 24.44330004\n",
+                        " 40.51055204 31.37310319 36.13430857 35.89003814 29.31375206 33.03575386\n",
+                        " 26.80215643 30.51929856 39.27554641 41.20998643 41.86194231 33.35842579\n",
+                        " 26.02868124 28.48085486 27.58440669 33.12278693 55.33740159 44.25733949\n",
+                        " 56.25003924 28.81115565 40.9972882  38.83749043 35.44529207 38.5143657\n",
+                        " 20.35323318 30.14743284 23.94941884 35.08283378 32.39691886 34.89167625\n",
+                        " 29.52560325 48.38910035 46.90359673 45.68574567 56.24840083 34.37894556\n",
+                        " 34.98291611 44.33238555 48.45468265 50.66127207 18.75582914 35.40064419\n",
+                        " 41.53001797 24.65707374 26.53810222 38.01967702 18.2791755  23.51555598\n",
+                        " 34.87789433 32.55563348 32.98271228 28.90705387 42.60127768 48.83111866\n",
+                        " 23.34231814 37.21763627 34.49782475 46.29502028 58.59218696 37.59991144\n",
+                        " 33.38248529 36.51931324 33.76024346 36.75451201 39.37320724 43.12047734\n",
+                        " 38.70154982 48.62181336 33.45165008 35.27878824 45.87529456 21.42468512\n",
+                        " 39.35710867 30.88099022 39.64782182 51.17657228 10.80340239 29.03305738\n",
+                        " 45.02754792 33.84527162 44.73140395 32.26480696 19.96415119 56.44283652\n",
+                        " 34.69445925 44.99909046 28.18595618 36.9288248  51.18234609 46.52686298\n",
+                        " 31.3644046  52.99482279 36.61041958 34.62021921 47.35588893 41.0434417\n",
+                        " 10.80531375 54.71103257 26.13916272 47.41764395 29.93776823 37.43720007\n",
+                        " 34.26107875 46.43905543 33.20892231 33.49507214 39.80380618 49.46899822\n",
+                        " 47.65824528 20.69676039 25.39109345 23.61024291 14.43486396 22.99919505\n",
+                        " 34.13872547 33.28506543 27.86544376 33.89113246 20.67186095 20.68946873\n",
+                        " 36.23573613 30.97804693 35.03062128 27.37717032 45.02627582 20.78536352\n",
+                        " 26.69317775 39.24987156 31.96254073 37.23482516 44.60593676 15.73333883\n",
+                        " 49.99412037 34.05535435 37.19042554 24.58418902 40.55682113 17.32118345\n",
+                        " 36.90828742 58.5351077  34.60236214 37.47915452 20.56171677 14.72782384\n",
+                        " 22.8069674  38.15248659 37.26029311 28.1435699  44.91518261 33.74022694\n",
+                        " 36.63924745 25.70239379 27.16963868 37.0606325  38.34856402 23.41068339\n",
+                        " 32.30574233 23.68186265 45.13782968 40.41255425 56.85007977 27.05281095\n",
+                        " 55.20060582 37.69626218 38.39348554 34.25142032 28.61485855 15.99216949\n",
+                        " 46.24002651 48.73015347 25.13172188 42.43783752 30.86014808 39.95690746\n",
+                        " 35.13389349 38.05156307 51.85002861 35.96586431 44.39298008 43.01353641\n",
+                        " 41.10093496 39.08751427 41.11193204 30.30137095 24.72787933 24.19301203\n",
+                        " 27.95414429 38.73755272 31.67267154 38.59125155 35.8191196  53.54307631\n",
+                        " 41.34721065 33.04334995 31.72532719 44.65015683 34.06058516 32.8430232\n",
+                        " 20.20313491 43.54309672 38.01296394 40.20552166 28.73249195 41.09335347\n",
+                        " 24.77505335 22.48098287 53.9783682  18.75689617 50.70290157 26.92339217\n",
+                        " 45.46219454 34.72879137 30.02154642 36.30951646 22.81141219 36.64673172\n",
+                        " 21.51203028 49.30413496 50.99090809 43.36554515 28.94233676 50.95113623\n",
+                        " 35.49732452 29.29131048 31.9721603  23.58536017 31.80883592 18.33653162\n",
+                        " 35.65137103 30.66393808 38.78428117 22.49215745 36.23874598 36.93296819\n",
+                        " 22.20068958 25.96756587 43.68868152 46.55554667 26.75584609 38.83622013\n",
+                        " 20.38024383 22.12990042 37.04191752 35.73862099 22.20197927 46.81673536\n",
+                        " 47.85467733 37.09874902 30.39007704 32.94743567 23.41849114 46.97615713\n",
+                        " 24.81276828 25.80584881 29.66903405 30.49474184 59.72658415 35.92819481\n",
+                        " 28.57768615 22.67649635 28.13174626 51.01743823 31.46933004 26.80856595\n",
+                        " 43.002335   42.67905471 53.98883964 21.68076976 32.36388345 41.7092776\n",
+                        " 34.81552604 44.84564647 35.09172063 35.63727152 31.62884997 19.58149817\n",
+                        " 32.74915194 26.18873629 26.08546182 43.67064002 43.13422941 29.9120593\n",
+                        " 37.45110815 30.50059461 44.90810521 25.66562241 42.60583583 27.4032675\n",
+                        " 38.10547948 54.87444144 32.30925472 38.9353986  35.33900008 26.21056743\n",
+                        " 24.27830972 23.8452208  34.94479756 38.16253125]\n"
+                    ]
+                },
+                {
+                    "data": {
+                        "text/plain": [
+                            "35.30168305493937"
+                        ]
+                    },
+                    "execution_count": 8,
+                    "metadata": {},
+                    "output_type": "execute_result"
+                }
+            ],
+            "source": [
+                "age = np.random.normal(35,10,1000)\n",
+                "print(age)\n",
+                "np.average(age)"
             ]
         },
         {
@@ -94,12 +339,105 @@
         },
         {
             "cell_type": "code",
-            "execution_count": 18,
+            "execution_count": 9,
             "id": "d590308e",
             "metadata": {},
-            "outputs": [],
+            "outputs": [
+                {
+                    "data": {
+                        "image/png": "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",
+                        "text/plain": [
+                            "<Figure size 640x480 with 1 Axes>"
+                        ]
+                    },
+                    "metadata": {},
+                    "output_type": "display_data"
+                }
+            ],
+            "source": [
+                "import numpy as np\n",
+                "import matplotlib.pyplot as plt\n",
+                "\n",
+                "# Set a seed for reproducibility\n",
+                "np.random.seed(0)\n",
+                "\n",
+                "# Generate right-skewed data using the gamma distribution\n",
+                "shape = 2  # Shape parameter (controls skewness, adjust as needed)\n",
+                "scale = 1  # Scale parameter (controls spread, adjust as needed)\n",
+                "size = 1000  # Number of data points\n",
+                "\n",
+                "# Generate right-skewed data\n",
+                "data = np.random.gamma(shape, scale, size)\n",
+                "\n",
+                "# Create a histogram\n",
+                "plt.hist(data, bins=30, density=True, alpha=0.6, color='b', label='Right-Skewed Data')\n",
+                "\n",
+                "# Add labels and a legend\n",
+                "plt.xlabel('Value')\n",
+                "plt.ylabel('Frequency')\n",
+                "plt.title('Right-Skewed Distribution')\n",
+                "plt.legend(loc='upper right')\n",
+                "\n",
+                "# Show the plot\n",
+                "plt.show()"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 24,
+            "id": "e26e3c30",
+            "metadata": {},
+            "outputs": [
+                {
+                    "name": "stdout",
+                    "output_type": "stream",
+                    "text": [
+                        "[1.92931174 1.9599174  1.94880113 ... 1.89850062 1.8887389  2.00216321]\n"
+                    ]
+                }
+            ],
+            "source": [
+                "sample_size = 500\n",
+                "result = []\n",
+                "for i in range(5000):\n",
+                "    ids = np.random.choice(1000,sample_size)\n",
+                "    sample_data = data[ids]\n",
+                "    sample_mean = np.average(sample_data)\n",
+                "    result.append(sample_mean)\n",
+                "\n",
+                "result = np.array(result)\n",
+                "print(result)"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 25,
+            "id": "fbda0ad8",
+            "metadata": {},
+            "outputs": [
+                {
+                    "data": {
+                        "image/png": "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",
+                        "text/plain": [
+                            "<Figure size 640x480 with 1 Axes>"
+                        ]
+                    },
+                    "metadata": {},
+                    "output_type": "display_data"
+                }
+            ],
             "source": [
-                "# TODO"
+                "# Create a histogram\n",
+                "plt.hist(result, bins=30, density=True, alpha=0.6, color='b', label='Left-Skewed Data')\n",
+                "\n",
+                "# Add labels and a legend\n",
+                "plt.xlabel('Sample Average')\n",
+                "plt.ylabel('Frequency')\n",
+                "plt.title('Average Distribution')\n",
+                "plt.legend(loc='upper right')\n",
+                "\n",
+                "# Show the plot\n",
+                "plt.show()"
             ]
         },
         {
@@ -144,12 +482,107 @@
         },
         {
             "cell_type": "code",
-            "execution_count": 17,
+            "execution_count": 27,
             "id": "12f8030c",
             "metadata": {},
-            "outputs": [],
+            "outputs": [
+                {
+                    "data": {
+                        "image/png": "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",
+                        "text/plain": [
+                            "<Figure size 640x480 with 1 Axes>"
+                        ]
+                    },
+                    "metadata": {},
+                    "output_type": "display_data"
+                }
+            ],
             "source": [
-                "# TODO\n"
+                "### Example 3\n",
+                "\n",
+                "import numpy as np\n",
+                "import matplotlib.pyplot as plt\n",
+                "\n",
+                "# Set a seed for reproducibility\n",
+                "np.random.seed(0)\n",
+                "\n",
+                "# Parameters for the uniform distribution\n",
+                "low = 0  # Lower bound\n",
+                "high = 10  # Upper bound\n",
+                "size = 1000  # Number of data points\n",
+                "\n",
+                "# Generate random data from a uniform distribution\n",
+                "data = np.random.uniform(low, high, size)\n",
+                "\n",
+                "# Create a histogram\n",
+                "plt.hist(data, bins=30, density=True, alpha=0.6, color='b', label='Uniform Data')\n",
+                "\n",
+                "# Add labels and a legend\n",
+                "plt.xlabel('Value')\n",
+                "plt.ylabel('Frequency')\n",
+                "plt.title('Uniform Distribution')\n",
+                "plt.legend(loc='upper right')\n",
+                "\n",
+                "# Show the plot\n",
+                "plt.show()\n"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 36,
+            "id": "b01b7270",
+            "metadata": {},
+            "outputs": [
+                {
+                    "name": "stdout",
+                    "output_type": "stream",
+                    "text": [
+                        "[5.64348326 7.99291573 4.57052724 ... 4.6118553  3.68265736 8.0410782 ]\n"
+                    ]
+                }
+            ],
+            "source": [
+                "sample_size = 2\n",
+                "result = []\n",
+                "for i in range(5000):\n",
+                "    ids = np.random.choice(1000,sample_size)\n",
+                "    sample_data = data[ids]\n",
+                "    sample_mean = np.average(sample_data)\n",
+                "    result.append(sample_mean)\n",
+                "\n",
+                "result = np.array(result)\n",
+                "print(result)"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 37,
+            "id": "c7dbee06",
+            "metadata": {},
+            "outputs": [
+                {
+                    "data": {
+                        "image/png": "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",
+                        "text/plain": [
+                            "<Figure size 640x480 with 1 Axes>"
+                        ]
+                    },
+                    "metadata": {},
+                    "output_type": "display_data"
+                }
+            ],
+            "source": [
+                "# Create a histogram\n",
+                "plt.hist(result, bins=30, density=True, alpha=0.6, color='b', label='Left-Skewed Data')\n",
+                "\n",
+                "# Add labels and a legend\n",
+                "plt.xlabel('Sample Average')\n",
+                "plt.ylabel('Frequency')\n",
+                "plt.title('Average Distribution')\n",
+                "plt.legend(loc='upper right')\n",
+                "\n",
+                "# Show the plot\n",
+                "plt.show()"
             ]
         },
         {
@@ -166,7 +599,7 @@
         },
         {
             "cell_type": "code",
-            "execution_count": 33,
+            "execution_count": 38,
             "id": "214ecc0d",
             "metadata": {},
             "outputs": [
@@ -182,22 +615,356 @@
                 }
             ],
             "source": [
-                "# TODO\n"
+                "import numpy as np\n",
+                "import matplotlib.pyplot as plt\n",
+                "from scipy import stats\n",
+                "\n",
+                "# Set a seed for reproducibility\n",
+                "np.random.seed(0)\n",
+                "\n",
+                "# Parameters for the normal distribution\n",
+                "mu = 0  # Mean\n",
+                "sigma = 1  # Standard deviation\n",
+                "size = 1000  # Number of data points\n",
+                "\n",
+                "# Generate random data from a normal distribution\n",
+                "data = np.random.normal(mu, sigma, size)\n",
+                "\n",
+                "# Create a histogram\n",
+                "plt.hist(data, bins=30, density=True, alpha=0.6, color='b', label='Normal Data')\n",
+                "\n",
+                "# Calculate mean, median, and mode\n",
+                "mean = np.mean(data)\n",
+                "median = np.median(data)\n",
+                "\n",
+                "# Add vertical lines for mean, median, and mode\n",
+                "plt.axvline(mean, color='r', linestyle='dashed', linewidth=2, label='Mean')\n",
+                "plt.axvline(median, color='g', linestyle='dashed', linewidth=2, label='Median')\n",
+                "\n",
+                "# Add labels and a legend\n",
+                "plt.xlabel('Value')\n",
+                "plt.ylabel('Frequency')\n",
+                "plt.title('Normal Distribution with Mean, Median, and Mode')\n",
+                "plt.legend(loc='upper right')\n",
+                "\n",
+                "# Show the plot\n",
+                "plt.show()\n"
             ]
         },
         {
             "cell_type": "code",
-            "execution_count": null,
+            "execution_count": 42,
             "id": "0ea06451",
             "metadata": {},
-            "outputs": [],
-            "source": []
+            "outputs": [
+                {
+                    "name": "stdout",
+                    "output_type": "stream",
+                    "text": [
+                        "[ 1.76405235e+00  4.00157208e-01  1.00000000e+01  2.24089320e+00\n",
+                        "  1.86755799e+00 -9.77277880e-01  9.50088418e-01 -1.51357208e-01\n",
+                        " -1.03218852e-01  4.10598502e-01  1.44043571e-01  1.00000000e+01\n",
+                        "  7.61037725e-01  1.21675016e-01  4.43863233e-01  3.33674327e-01\n",
+                        "  1.49407907e+00 -2.05158264e-01  1.00000000e+01 -8.54095739e-01\n",
+                        " -2.55298982e+00  1.00000000e+01  8.64436199e-01 -7.42165020e-01\n",
+                        "  2.26975462e+00 -1.45436567e+00  4.57585173e-02 -1.87183850e-01\n",
+                        "  1.53277921e+00  1.46935877e+00  1.54947426e-01  3.78162520e-01\n",
+                        " -8.87785748e-01 -1.98079647e+00 -3.47912149e-01  1.56348969e-01\n",
+                        "  1.23029068e+00  1.20237985e+00  1.00000000e+01 -3.02302751e-01\n",
+                        " -1.04855297e+00 -1.42001794e+00 -1.70627019e+00  1.95077540e+00\n",
+                        " -5.09652182e-01 -4.38074302e-01 -1.25279536e+00  1.00000000e+01\n",
+                        " -1.61389785e+00 -2.12740280e-01 -8.95466561e-01  3.86902498e-01\n",
+                        " -5.10805138e-01 -1.18063218e+00 -2.81822283e-02  4.28331871e-01\n",
+                        "  6.65172224e-02  3.02471898e-01 -6.34322094e-01 -3.62741166e-01\n",
+                        " -6.72460448e-01 -3.59553162e-01 -8.13146282e-01  1.00000000e+01\n",
+                        "  1.77426142e-01 -4.01780936e-01 -1.63019835e+00  1.00000000e+01\n",
+                        " -9.07298364e-01  5.19453958e-02  7.29090562e-01  1.28982911e-01\n",
+                        "  1.13940068e+00 -1.23482582e+00  4.02341641e-01 -6.84810091e-01\n",
+                        " -8.70797149e-01 -5.78849665e-01 -3.11552532e-01  1.00000000e+01\n",
+                        " -1.16514984e+00  9.00826487e-01  4.65662440e-01 -1.53624369e+00\n",
+                        "  1.48825219e+00  1.89588918e+00  1.17877957e+00 -1.79924836e-01\n",
+                        " -1.07075262e+00  1.05445173e+00 -4.03176947e-01  1.22244507e+00\n",
+                        "  2.08274978e-01  9.76639036e-01  3.56366397e-01  7.06573168e-01\n",
+                        "  1.05000207e-02  1.78587049e+00  1.26912093e-01  4.01989363e-01\n",
+                        "  1.88315070e+00 -1.34775906e+00 -1.27048500e+00  9.69396708e-01\n",
+                        " -1.17312341e+00  1.94362119e+00 -4.13618981e-01 -7.47454811e-01\n",
+                        "  1.92294203e+00  1.48051479e+00  1.86755896e+00  9.06044658e-01\n",
+                        " -8.61225685e-01  1.91006495e+00 -2.68003371e-01  8.02456396e-01\n",
+                        "  9.47251968e-01 -1.55010093e-01  6.14079370e-01  9.22206672e-01\n",
+                        "  3.76425531e-01 -1.09940079e+00  2.98238174e-01  1.32638590e+00\n",
+                        " -6.94567860e-01 -1.49634540e-01 -4.35153552e-01  1.84926373e+00\n",
+                        "  6.72294757e-01  4.07461836e-01 -7.69916074e-01  1.00000000e+01\n",
+                        " -6.74332661e-01  1.00000000e+01 -6.35846078e-01  6.76433295e-01\n",
+                        "  5.76590817e-01 -2.08298756e-01  3.96006713e-01 -1.09306151e+00\n",
+                        " -1.49125759e+00  4.39391701e-01  1.66673495e-01  1.00000000e+01\n",
+                        "  2.38314477e+00  9.44479487e-01 -9.12822225e-01  1.11701629e+00\n",
+                        " -1.31590741e+00 -4.61584605e-01 -6.82416053e-02  1.71334272e+00\n",
+                        " -7.44754822e-01 -8.26438539e-01 -9.84525244e-02  1.00000000e+01\n",
+                        "  1.12663592e+00  1.00000000e+01 -1.14746865e+00 -4.37820045e-01\n",
+                        " -4.98032451e-01  1.92953205e+00  9.49420807e-01  8.75512414e-02\n",
+                        " -1.22543552e+00  8.44362976e-01 -1.00021535e+00 -1.54477110e+00\n",
+                        "  1.18802979e+00  3.16942612e-01  9.20858824e-01  1.00000000e+01\n",
+                        "  8.56830612e-01 -6.51025593e-01 -1.03424284e+00  1.00000000e+01\n",
+                        " -8.03409664e-01 -6.89549778e-01 -4.55532504e-01  1.74791590e-02\n",
+                        " -3.53993911e-01 -1.37495129e+00 -6.43618403e-01 -2.22340315e+00\n",
+                        "  6.25231451e-01 -1.60205766e+00  1.00000000e+01  1.00000000e+01\n",
+                        " -7.39562996e-01  1.54301460e+00 -1.29285691e+00  2.67050869e-01\n",
+                        " -3.92828182e-02 -1.16809350e+00  5.23276661e-01 -1.71546331e-01\n",
+                        "  7.71790551e-01  1.00000000e+01  2.16323595e+00  1.33652795e+00\n",
+                        "  1.00000000e+01 -2.39379178e-01  1.09965960e+00  1.00000000e+01\n",
+                        "  6.40131526e-01 -1.61695604e+00 -2.43261244e-02 -7.38030909e-01\n",
+                        "  2.79924599e-01 -9.81503896e-02  9.10178908e-01  3.17218215e-01\n",
+                        "  7.86327962e-01 -4.66419097e-01 -9.44446256e-01 -4.10049693e-01\n",
+                        " -1.70204139e-02  3.79151736e-01  2.25930895e+00 -4.22571517e-02\n",
+                        " -9.55945000e-01  1.00000000e+01 -4.63595975e-01  4.81481474e-01\n",
+                        " -1.54079701e+00  1.00000000e+01  1.56506538e-01  2.32181036e-01\n",
+                        "  1.00000000e+01  1.00000000e+01 -1.42406091e+00 -4.93319883e-01\n",
+                        " -5.42861476e-01  4.16050046e-01 -1.15618243e+00  7.81198102e-01\n",
+                        "  1.00000000e+01 -2.06998503e+00  4.26258731e-01  6.76908035e-01\n",
+                        " -6.37437026e-01 -3.97271814e-01 -1.32880578e-01 -2.97790879e-01\n",
+                        " -3.09012969e-01 -1.67600381e+00  1.15233156e+00  1.07961859e+00\n",
+                        " -8.13364259e-01 -1.46642433e+00  5.21064876e-01 -5.75787970e-01\n",
+                        "  1.41953163e-01 -3.19328417e-01  1.00000000e+01  6.94749144e-01\n",
+                        " -7.25597378e-01 -1.38336396e+00 -1.58293840e+00  6.10379379e-01\n",
+                        " -1.18885926e+00 -5.06816354e-01 -5.96314038e-01 -5.25672963e-02\n",
+                        " -1.93627981e+00  1.88778597e-01  5.23891024e-01  1.00000000e+01\n",
+                        " -3.10886172e-01  9.74001663e-02  3.99046346e-01 -2.77259276e+00\n",
+                        "  1.95591231e+00  3.90093323e-01 -6.52408582e-01 -3.90953375e-01\n",
+                        "  4.93741777e-01 -1.16103939e-01 -2.03068447e+00  2.06449286e+00\n",
+                        " -1.10540657e-01  1.02017271e+00 -6.92049848e-01  1.53637705e+00\n",
+                        "  2.86343689e-01  1.00000000e+01 -1.04525337e+00  1.21114529e+00\n",
+                        "  6.89818165e-01  1.30184623e+00 -6.28087560e-01 -4.81027118e-01\n",
+                        "  2.30391670e+00 -1.06001582e+00 -1.35949701e-01  1.13689136e+00\n",
+                        "  9.77249677e-02  5.82953680e-01 -3.99449029e-01  3.70055888e-01\n",
+                        " -1.30652685e+00  1.00000000e+01 -1.18164045e-01 -6.80178204e-01\n",
+                        "  6.66383082e-01  1.00000000e+01 -1.33425847e+00 -1.34671751e+00\n",
+                        "  6.93773153e-01 -1.59573438e-01 -1.33701560e-01  1.07774381e+00\n",
+                        " -1.12682581e+00 -7.30677753e-01 -3.84879809e-01  1.00000000e+01\n",
+                        "  1.00000000e+01 -2.86887192e-01 -6.16264021e-02 -1.07305276e-01\n",
+                        " -7.19604389e-01 -8.12992989e-01  2.74516358e-01 -8.90915083e-01\n",
+                        " -1.15735526e+00 -3.12292251e-01 -1.57667016e-01  2.25672350e+00\n",
+                        "  1.00000000e+01  9.43260725e-01  7.47188334e-01 -1.18894496e+00\n",
+                        "  7.73252977e-01 -1.18388064e+00 -2.65917224e+00  6.06319524e-01\n",
+                        " -1.75589058e+00  4.50934462e-01 -6.84010898e-01  1.65955080e+00\n",
+                        "  1.06850940e+00 -4.53385804e-01 -6.87837611e-01 -1.21407740e+00\n",
+                        "  1.00000000e+01 -2.80355495e-01 -3.64693544e-01  1.56703855e-01\n",
+                        "  5.78521498e-01  3.49654457e-01 -7.64143924e-01 -1.43779147e+00\n",
+                        "  1.36453185e+00 -6.89449185e-01 -6.52293600e-01 -5.21189312e-01\n",
+                        " -1.84306955e+00 -4.77974004e-01 -4.79655814e-01  6.20358298e-01\n",
+                        "  6.98457149e-01  3.77088909e-03  1.00000000e+01  3.39964984e-01\n",
+                        " -1.56821116e-02  1.60928168e-01 -1.90653494e-01 -3.94849514e-01\n",
+                        " -2.67733537e-01 -1.12801133e+00  2.80441705e-01 -9.93123611e-01\n",
+                        "  8.41631264e-01 -2.49458580e-01  1.00000000e+01  1.00000000e+01\n",
+                        "  6.43314465e-01 -1.57062341e+00 -2.06903676e-01  8.80178912e-01\n",
+                        " -1.69810582e+00  3.87280475e-01 -2.25556423e+00 -1.02250684e+00\n",
+                        "  3.86305518e-02 -1.65671510e+00 -9.85510738e-01 -1.47183501e+00\n",
+                        "  1.64813493e+00  1.64227755e-01  5.67290278e-01 -2.22675101e-01\n",
+                        "  1.00000000e+01 -1.61647419e+00 -2.91837363e-01  1.00000000e+01\n",
+                        "  8.57923924e-01  1.14110187e+00  1.46657872e+00  8.52551939e-01\n",
+                        " -5.98653937e-01 -1.11589699e+00  7.66663182e-01  3.56292817e-01\n",
+                        " -1.76853845e+00  3.55481793e-01  1.00000000e+01  5.89255892e-02\n",
+                        " -1.85053671e-01 -8.07648488e-01 -1.44653470e+00  8.00297949e-01\n",
+                        " -3.09114445e-01  1.00000000e+01  1.73272119e+00  6.84501107e-01\n",
+                        "  3.70825001e-01  1.42061805e-01  1.51999486e+00  1.71958931e+00\n",
+                        "  9.29505111e-01  5.82224591e-01 -2.09460307e+00  1.23721914e-01\n",
+                        " -1.30106954e-01  9.39532294e-02  9.43046087e-01 -2.73967717e+00\n",
+                        "  1.00000000e+01  2.69904355e-01 -4.66845546e-01 -1.41690611e+00\n",
+                        "  8.68963487e-01  2.76871906e-01  1.00000000e+01  3.14817205e-01\n",
+                        "  8.21585712e-01  5.29264630e-03  8.00564803e-01  7.82601752e-02\n",
+                        " -3.95228983e-01 -1.15942052e+00  1.00000000e+01  1.94292938e-01\n",
+                        "  8.75832762e-01 -1.15107468e-01  4.57415606e-01 -9.64612014e-01\n",
+                        " -7.82629156e-01 -1.10389299e-01 -1.05462846e+00  8.20247837e-01\n",
+                        "  4.63130329e-01  2.79095764e-01  3.38904125e-01  2.02104356e+00\n",
+                        " -4.68864188e-01 -2.20144129e+00  1.99300197e-01 -5.06035410e-02\n",
+                        " -5.17519043e-01  1.00000000e+01 -4.39189522e-01  1.81338429e-01\n",
+                        " -5.02816701e-01  2.41245368e+00 -9.60504382e-01 -7.93117363e-01\n",
+                        " -2.28862004e+00  2.51484415e-01 -2.01640663e+00 -5.39454633e-01\n",
+                        " -2.75670535e-01 -7.09727966e-01  1.73887268e+00  9.94394391e-01\n",
+                        "  1.31913688e+00 -8.82418819e-01  1.12859406e+00  4.96000946e-01\n",
+                        "  7.71405949e-01  1.02943883e+00 -9.08763246e-01 -4.24317621e-01\n",
+                        "  8.62596011e-01 -2.65561909e+00  1.51332808e+00  5.53132064e-01\n",
+                        " -4.57039607e-02  2.20507656e-01 -1.02993528e+00 -3.49943365e-01\n",
+                        "  1.00000000e+01  1.29802197e+00  2.69622405e+00 -7.39246663e-02\n",
+                        " -6.58552967e-01  1.00000000e+01  1.00000000e+01 -7.78547559e-02\n",
+                        "  3.82732430e-01 -3.42422805e-02  1.09634685e+00  1.00000000e+01\n",
+                        "  1.00000000e+01  1.00000000e+01 -1.63263453e+00 -1.56776772e+00\n",
+                        " -1.17915793e+00  1.30142807e+00  1.00000000e+01  1.37496407e+00\n",
+                        " -1.33221165e+00 -1.96862469e+00 -6.60056320e-01  1.00000000e+01\n",
+                        "  4.98690275e-01  1.04797216e+00  2.84279671e-01  1.74266878e+00\n",
+                        " -2.22605681e-01 -9.13079218e-01 -1.68121822e+00 -8.88971358e-01\n",
+                        "  2.42117961e-01 -8.88720257e-01  9.36742464e-01  1.41232771e+00\n",
+                        " -2.36958691e+00  1.00000000e+01 -2.23960406e+00  4.01499055e-01\n",
+                        "  1.22487056e+00  6.48561063e-02 -1.27968917e+00 -5.85431204e-01\n",
+                        " -2.61645446e-01 -1.82244784e-01 -2.02896841e-01 -1.09882779e-01\n",
+                        "  2.13480049e-01 -1.20857365e+00 -2.42019830e-01  1.51826117e+00\n",
+                        "  1.00000000e+01 -4.43836093e-01  1.07819730e+00 -2.55918467e+00\n",
+                        "  1.18137860e+00 -6.31903758e-01  1.63928572e-01  9.63213559e-02\n",
+                        "  9.42468119e-01 -2.67594746e-01 -6.78025782e-01  1.29784579e+00\n",
+                        " -2.36417382e+00  1.00000000e+01 -1.34792542e+00 -7.61573388e-01\n",
+                        "  2.01125668e+00 -4.45954265e-02  1.95069697e-01 -1.78156286e+00\n",
+                        " -7.29044659e-01  1.96557401e-01  3.54757693e-01  6.16886554e-01\n",
+                        "  1.00000000e+01  5.27004208e-01  4.53781913e-01 -1.82974041e+00\n",
+                        "  3.70057219e-02  7.67902408e-01  5.89879821e-01 -3.63858810e-01\n",
+                        " -8.05626508e-01 -1.11831192e+00 -1.31054012e-01  1.13307988e+00\n",
+                        "  1.00000000e+01 -6.59891730e-01 -1.13980246e+00  7.84957521e-01\n",
+                        " -5.54309627e-01 -4.70637658e-01 -2.16949570e-01  4.45393251e-01\n",
+                        " -3.92388998e-01 -3.04614305e+00  5.43311891e-01  4.39042958e-01\n",
+                        " -2.19541028e-01 -1.08403662e+00  3.51780111e-01  3.79235534e-01\n",
+                        " -4.70032883e-01 -2.16731471e-01 -9.30156503e-01 -1.78589092e-01\n",
+                        " -1.55042935e+00  4.17318821e-01  1.00000000e+01  1.00000000e+01\n",
+                        " -1.40596292e+00 -5.90057646e-01 -1.10489405e-01 -1.66069981e+00\n",
+                        "  1.15147873e-01 -3.79147563e-01 -1.74235620e+00 -1.30324275e+00\n",
+                        "  1.00000000e+01  1.00000000e+01 -1.31908640e-01  4.04761812e-01\n",
+                        "  2.23843563e-01  3.29622982e-01  1.28598401e+00 -1.50699840e+00\n",
+                        "  6.76460732e-01 -3.82008956e-01 -2.24258934e-01 -3.02249730e-01\n",
+                        "  1.00000000e+01 -1.22619619e+00  1.00000000e+01  1.67094303e+00\n",
+                        " -5.61330204e-02 -1.38504274e-03 -6.87299037e-01 -1.17474546e-01\n",
+                        "  4.66166426e-01 -3.70242441e-01 -4.53804041e-01  4.03264540e-01\n",
+                        " -9.18004770e-01  1.00000000e+01  8.20321797e-01  1.35994854e+00\n",
+                        " -9.03820073e-02  1.36759724e+00  1.03440989e+00 -9.96212640e-01\n",
+                        " -1.21793851e+00 -3.04963638e-01  1.00000000e+01 -7.22870076e-02\n",
+                        " -6.00657558e-01  1.55224318e+00  2.86904488e-01 -2.32059428e+00\n",
+                        "  3.17160626e-01  5.20040615e-01  2.25608654e-01  1.00000000e+01\n",
+                        " -6.72756089e-02  1.00000000e+01 -3.70704003e-01 -9.45615796e-01\n",
+                        " -9.32740911e-01 -1.26306835e+00  4.52489093e-01  9.78961454e-02\n",
+                        " -4.48165363e-01 -6.49337928e-01 -2.34231050e-02  1.07919473e+00\n",
+                        " -2.00421572e+00  3.76876521e-01 -5.45711974e-01 -1.88458584e+00\n",
+                        " -1.94570308e+00 -9.12783494e-01  2.19509556e-01  3.93062934e-01\n",
+                        " -9.38981573e-01  1.01702099e+00  1.42298350e+00  3.96086585e-01\n",
+                        " -5.91402668e-01  1.12441918e+00  7.55395696e-01  8.67407411e-01\n",
+                        " -6.56463675e-01 -2.83455451e+00  2.11679102e+00 -1.61087840e+00\n",
+                        " -3.57680719e-02  2.38074535e+00  3.30576756e-01  9.49246474e-01\n",
+                        " -1.50239657e+00 -1.77766695e+00 -5.32702792e-01  1.09074973e+00\n",
+                        " -3.46249448e-01 -7.94636321e-01  1.97967290e-01  1.08193522e+00\n",
+                        " -1.44494020e+00 -1.21054299e+00 -7.88669255e-01  1.09463837e+00\n",
+                        "  2.34821526e-01  2.13215341e+00  1.00000000e+01 -3.50951769e-02\n",
+                        "  1.26507784e+00  2.11497013e-01 -7.04921353e-01  6.79974844e-01\n",
+                        " -6.96326654e-01 -2.90397101e-01  1.32778270e+00 -1.01281486e-01\n",
+                        " -8.03141387e-01 -4.64337691e-01  1.02179059e+00  1.00000000e+01\n",
+                        " -3.86870847e-01 -5.10292740e-01  1.83925494e-01 -3.85489760e-01\n",
+                        " -1.60183605e+00 -8.87180942e-01  1.00000000e+01  1.24331938e+00\n",
+                        "  8.12674042e-01  5.87259379e-01 -5.05358317e-01 -8.15791542e-01\n",
+                        " -5.07517602e-01 -1.05188010e+00  1.00000000e+01 -2.24532165e+00\n",
+                        "  5.64008535e-01 -1.28455230e+00 -1.04343491e-01 -9.88001942e-01\n",
+                        " -1.17762896e+00  1.00000000e+01  1.75498615e+00 -1.32988422e-01\n",
+                        " -7.65702194e-01  5.55786964e-01  1.03493146e-02  7.20033759e-01\n",
+                        " -1.82425666e+00  1.00000000e+01  7.72694837e-01 -1.66159829e+00\n",
+                        "  4.48195284e-01  1.69618157e+00 -1.48577034e-02  8.21405937e-01\n",
+                        "  6.70570450e-01 -7.07505698e-01  3.97667346e-02 -1.56699471e+00\n",
+                        " -4.51303037e-01  2.65687975e-01  7.23100494e-01  2.46121252e-02\n",
+                        "  7.19983730e-01 -1.10290621e+00 -1.01697275e-01  1.92793845e-02\n",
+                        "  1.84959125e+00 -2.14166656e-01 -4.99016638e-01  2.13512238e-02\n",
+                        "  1.00000000e+01  1.92753849e-01 -3.65055217e-01 -1.79132755e+00\n",
+                        " -5.85865511e-02 -3.17543094e-01 -1.63242330e+00 -6.71341546e-02\n",
+                        "  1.48935596e+00  5.21303748e-01  6.11927193e-01 -1.34149673e+00\n",
+                        "  4.76898369e-01  1.00000000e+01  5.29045238e-01  4.22628622e-01\n",
+                        " -1.35978073e+00 -4.14008116e-02 -7.57870860e-01 -5.00840943e-02\n",
+                        " -8.97400927e-01  1.31247037e+00 -8.58972388e-01 -8.98942156e-01\n",
+                        "  7.45864065e-02 -1.07709907e+00 -4.24663302e-01 -8.29964598e-01\n",
+                        "  1.41117206e+00  7.85803827e-01 -5.74695185e-02 -3.91217052e-01\n",
+                        "  9.40917615e-01  1.00000000e+01  4.98052405e-01 -2.61922373e-02\n",
+                        "  1.00000000e+01 -1.12465983e-01 -5.32489919e-01  6.45055273e-01\n",
+                        "  1.01184243e+00 -6.57951045e-01  4.68385234e-01  1.73587900e+00\n",
+                        " -6.67712721e-01  1.68192174e+00 -8.52585847e-01  2.29597556e-02\n",
+                        " -1.11456118e-02  1.14988999e-02 -8.37678042e-01 -5.91183104e-01\n",
+                        " -6.67720286e-01  1.00000000e+01  3.30035115e-01  2.22594433e+00\n",
+                        "  1.37098901e+00 -5.09843242e-01  3.24869616e-01  9.97117981e-01\n",
+                        "  3.06018243e-02 -6.96415784e-02  5.15749428e-02  8.67276629e-01\n",
+                        " -8.48320523e-01 -3.25669469e-01  4.70433145e-01  3.11447072e-01\n",
+                        "  2.39582760e-01 -3.69801166e-01  9.72535789e-01  2.13386825e+00\n",
+                        "  4.06415494e-01 -1.93176702e-01  7.55740289e-01 -5.39132637e-01\n",
+                        " -7.49690345e-01  3.28087476e-02 -2.58279663e+00 -1.15395036e+00\n",
+                        " -3.47961856e-01 -1.35338886e+00 -1.03264310e+00 -4.36748337e-01\n",
+                        " -1.64296529e+00 -4.06071796e-01 -5.35270165e-01  2.54052084e-02\n",
+                        "  1.15418403e+00  1.72504416e-01  2.10620213e-02  9.94544570e-02\n",
+                        "  2.27392775e-01 -1.01673865e+00 -1.14775325e-01  3.08751242e-01\n",
+                        " -1.37075998e+00  8.65652923e-01  1.08137603e+00 -6.31375988e-01\n",
+                        " -2.41337791e-01 -8.78190343e-01  6.99380484e-01 -1.06122229e+00\n",
+                        " -2.22477010e-01 -8.58919908e-01  5.09542770e-02 -1.79422927e+00\n",
+                        "  1.32646164e+00 -9.64606424e-01  5.98946831e-02 -2.12523045e-01\n",
+                        " -7.62114512e-01 -8.87780137e-01  1.00000000e+01 -5.25640593e-01\n",
+                        "  2.71170185e-01 -8.01496885e-01 -6.47181432e-01  4.72247150e-01\n",
+                        "  9.30408496e-01 -1.75316402e-01 -1.42191987e+00  1.99795608e+00\n",
+                        " -8.56549308e-01  1.00000000e+01  2.59442459e+00 -4.04032294e-01\n",
+                        " -1.46173269e+00 -6.83439767e-01  3.67544896e-01  1.90311558e-01\n",
+                        " -8.51729197e-01  1.00000000e+01  1.00000000e+01 -1.18468659e+00\n",
+                        "  9.60693398e-01  1.32906285e+00 -8.17493098e-01 -1.40134729e+00\n",
+                        "  1.03043827e+00 -2.04732361e+00 -1.22662166e+00  9.67446150e-01\n",
+                        " -5.53525480e-02 -2.63937349e-01  3.52816606e-01 -1.52774424e-01\n",
+                        " -1.29868672e+00  1.27607535e+00  1.32501405e+00  2.05332564e-01\n",
+                        "  4.51340154e-02  2.33962481e+00  1.00000000e+01 -2.59576982e-01\n",
+                        "  3.64481249e-01  1.47132196e+00  1.00000000e+01 -2.58572632e-01\n",
+                        "  3.08331246e-01 -1.37808347e+00 -3.11976108e-01  1.00000000e+01\n",
+                        " -1.00683175e+00  1.68157672e+00 -7.92286662e-01 -5.31605908e-01\n",
+                        "  3.65848788e-01  1.29782527e+00  4.81115126e-01  2.75935511e+00\n",
+                        " -7.46679783e-02  2.58716440e-01  2.75600674e-01  1.00000000e+01\n",
+                        "  5.07238951e-01  1.00000000e+01  1.00000000e+01  2.44443456e-01\n",
+                        "  1.40134483e+00  1.00000000e+01  5.28943618e-01  2.46147789e-01\n",
+                        "  1.00000000e+01 -8.04753741e-01  2.34664703e+00 -1.27916111e+00\n",
+                        " -3.65551090e-01  9.38092541e-01  2.96733172e-01  8.29986159e-01\n",
+                        " -4.96102334e-01 -7.48049827e-02  1.22319836e-02  1.56925961e+00\n",
+                        "  6.90429024e-01  7.96672108e-01 -6.57926093e-01  9.68882639e-01\n",
+                        "  2.25581664e-01  1.38914532e+00  2.01406015e+00 -3.06765776e-01\n",
+                        " -4.06303130e-01 -8.64044991e-01 -1.43579512e-01 -3.82025449e-01\n",
+                        "  3.59504400e-01  1.00000000e+01 -3.61599281e-01  1.06458514e+00\n",
+                        " -9.37880231e-01  4.33107953e-01 -4.05941727e-01  7.24368505e-01\n",
+                        "  1.38526155e+00 -3.03098253e-01  4.41032907e-01  1.78792866e-01\n",
+                        " -7.99422400e-01  2.40787510e-01  2.89120505e-01  4.12870820e-01\n",
+                        "  1.00000000e+01  9.41923003e-02 -1.14761094e+00 -3.58114075e-01]\n"
+                    ]
+                }
+            ],
+            "source": [
+                "data_outliers = data.copy()\n",
+                "data_outliers[np.random.choice(1000,100)] = 10\n",
+                "print(data_outliers)"
+            ]
         },
         {
             "cell_type": "code",
-            "execution_count": null,
+            "execution_count": 43,
             "id": "a0e55e5c",
             "metadata": {},
+            "outputs": [
+                {
+                    "data": {
+                        "image/png": "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",
+                        "text/plain": [
+                            "<Figure size 640x480 with 1 Axes>"
+                        ]
+                    },
+                    "metadata": {},
+                    "output_type": "display_data"
+                }
+            ],
+            "source": [
+                "\n",
+                "# Create a histogram\n",
+                "plt.hist(data_outliers, bins=30, density=True, alpha=0.6, color='b', label='Normal Data')\n",
+                "\n",
+                "# Calculate mean, median, and mode\n",
+                "mean = np.mean(data_outliers)\n",
+                "median = np.median(data_outliers)\n",
+                "\n",
+                "# Add vertical lines for mean, median, and mode\n",
+                "plt.axvline(mean, color='r', linestyle='dashed', linewidth=2, label='Mean')\n",
+                "plt.axvline(median, color='g', linestyle='dashed', linewidth=2, label='Median')\n",
+                "\n",
+                "# Add labels and a legend\n",
+                "plt.xlabel('Value')\n",
+                "plt.ylabel('Frequency')\n",
+                "plt.title('Normal Distribution with Mean, Median, and Mode')\n",
+                "plt.legend(loc='upper right')\n",
+                "\n",
+                "# Show the plot\n",
+                "plt.show()"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "id": "c63e19a7",
+            "metadata": {},
             "outputs": [],
             "source": []
         }

From 85eb10bbf504a9801f7e6c35c3fafb35b825057e Mon Sep 17 00:00:00 2001
From: Israel Dellinger <51415637+idellinger@users.noreply.github.com>
Date: Mon, 2 Oct 2023 19:10:30 +0000
Subject: [PATCH 04/10] descriptive stats problems

---
 Israel/problems.ipynb | 270 ++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 270 insertions(+)
 create mode 100644 Israel/problems.ipynb

diff --git a/Israel/problems.ipynb b/Israel/problems.ipynb
new file mode 100644
index 00000000..b678bf10
--- /dev/null
+++ b/Israel/problems.ipynb
@@ -0,0 +1,270 @@
+{
+    "cells": [
+        {
+            "cell_type": "markdown",
+            "id": "ac622319",
+            "metadata": {},
+            "source": [
+                "# Descriptive statistics problems"
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "id": "aa8993e4",
+            "metadata": {},
+            "source": [
+                "### Exercise 1"
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "id": "5e0ab0d5",
+            "metadata": {},
+            "source": [
+                "We will use Numpy to obtain information to describe statistically.\n",
+                "\n",
+                "- Generate an array of 100 elements following a normal distribution.\n",
+                "- Generate an array of 100 elements following a chi-square distribution with 3 degrees of freedom.\n",
+                "- Calculate the main metrics and statistical measures that best describe the two vectors."
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 2,
+            "id": "34720ab6",
+            "metadata": {},
+            "outputs": [
+                {
+                    "data": {
+                        "text/plain": [
+                            "Text(0.5, 1.0, 'Chi-square Distribution')"
+                        ]
+                    },
+                    "execution_count": 2,
+                    "metadata": {},
+                    "output_type": "execute_result"
+                },
+                {
+                    "data": {
+                        "image/png": "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",
+                        "text/plain": [
+                            "<Figure size 640x480 with 2 Axes>"
+                        ]
+                    },
+                    "metadata": {},
+                    "output_type": "display_data"
+                }
+            ],
+            "source": [
+                "import numpy as np\n",
+                "import matplotlib.pyplot as plt\n",
+                "\n",
+                "np.random.seed(7)\n",
+                "\n",
+                "array1 = np.random.normal(size = 100)\n",
+                "array2 = np.random.chisquare(3, 100)\n",
+                "\n",
+                "fig, (ax1, ax2) = plt.subplots(1,2)\n",
+                "ax1.hist(array1)\n",
+                "ax1.set_title(\"Normal Distribution\")\n",
+                "ax2.hist(array2)\n",
+                "ax2.set_title(\"Chi-square Distribution\")\n",
+                "\n",
+                "\n"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 5,
+            "id": "95552460",
+            "metadata": {},
+            "outputs": [
+                {
+                    "name": "stdout",
+                    "output_type": "stream",
+                    "text": [
+                        "Normal Mean: 0.012065424517735459\n",
+                        "Chi-square Mean: 2.928575498384853\n",
+                        "\n",
+                        "Normal Median: -0.06576545576857008\n",
+                        "Chi-square Median: 2.382302084548116\n",
+                        "\n",
+                        "Normal Mode: 1.690525703800356\n",
+                        "Chi-square Mode: 0.9197430988873622\n",
+                        "\n"
+                    ]
+                }
+            ],
+            "source": [
+                "import statistics as stats\n",
+                "\n",
+                "### MEAN ###\n",
+                "print(f\"Normal Mean: {stats.mean(array1)}\")\n",
+                "print(f\"Chi-square Mean: {stats.mean(array2)}\")\n",
+                "print()\n",
+                "\n",
+                "### MEDIAN ###\n",
+                "print(f\"Normal Median: {stats.median(array1)}\")\n",
+                "print(f\"Chi-square Median: {stats.median(array2)}\")\n",
+                "print()\n",
+                "\n",
+                "### MODE ###\n",
+                "print(f\"Normal Mode: {stats.mode(array1)}\")\n",
+                "print(f\"Chi-square Mode: {stats.mode(array2)}\")\n",
+                "print()"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 7,
+            "id": "61808660",
+            "metadata": {},
+            "outputs": [
+                {
+                    "name": "stdout",
+                    "output_type": "stream",
+                    "text": [
+                        "Normal range: 4.548262088597983\n",
+                        "Chi-square range: 10.072765473935583\n",
+                        "\n",
+                        "Normal variance: 1.04831339674988 and stdev: 1.023871767727717\n",
+                        "Chi variance: 4.865280734391722 and stdev: 2.2057381382185244\n"
+                    ]
+                }
+            ],
+            "source": [
+                "### RANGE ###\n",
+                "range_normal = max(array1) - min(array1)\n",
+                "range_chi = max(array2) - min(array2)\n",
+                "print(f\"Normal range: {range_normal}\")\n",
+                "print(f\"Chi-square range: {range_chi}\")\n",
+                "print()\n",
+                "\n",
+                "### VARIENCE and STD DEVEATION ### \n",
+                "normal_varience = stats.variance(array1)\n",
+                "chi_varience = stats.variance(array2)\n",
+                "normal_stdev = stats.stdev(array1)\n",
+                "chi_stdev = stats.stdev(array2)\n",
+                "print(f\"Normal variance: {normal_varience} and stdev: {normal_stdev}\")\n",
+                "print(f\"Chi variance: {chi_varience} and stdev: {chi_stdev}\")"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 9,
+            "id": "491c2e42",
+            "metadata": {},
+            "outputs": [
+                {
+                    "name": "stdout",
+                    "output_type": "stream",
+                    "text": [
+                        "Normal skew is: 0.04690455383857406\n",
+                        "Chi-sq skew is: 1.1498285247258326\n",
+                        "\n",
+                        "Normal kurtosis is: -0.348889587599734\n",
+                        "Chi kurtosis is: 0.9091378874561746\n"
+                    ]
+                }
+            ],
+            "source": [
+                "from scipy.stats import skew\n",
+                "from scipy.stats import kurtosis\n",
+                "\n",
+                "### SKEW ###\n",
+                "normal_skew = skew(array1)\n",
+                "chi_skew = skew(array2)\n",
+                "print(f\"Normal skew is: {normal_skew}\")\n",
+                "print(f\"Chi-sq skew is: {chi_skew}\")\n",
+                "print()\n",
+                "\n",
+                "### KURTOSIS ###\n",
+                "\n",
+                "kurtosis_normal = kurtosis(array1)\n",
+                "kurtosis_chi = kurtosis(array2)\n",
+                "\n",
+                "print(f\"Normal kurtosis is: {kurtosis_normal}\")\n",
+                "print(f\"Chi kurtosis is: {kurtosis_chi}\")"
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "id": "46c70c3d",
+            "metadata": {},
+            "source": [
+                "### Exercise 2\n",
+                "\n",
+                "Write a Python program to calculate the standard deviation of the following data:\n",
+                "\n",
+                "```py\n",
+                "data = [4, 2, 5, 8, 6]\n",
+                "```"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 19,
+            "id": "d590308e",
+            "metadata": {},
+            "outputs": [
+                {
+                    "name": "stdout",
+                    "output_type": "stream",
+                    "text": [
+                        "Numpy's standard dev is: 2.0\n",
+                        "Stats standard dev is: 2.23606797749979\n",
+                        "Program's sdev is 2.0?\n"
+                    ]
+                }
+            ],
+            "source": [
+                "import math\n",
+                "\n",
+                "data = [4, 2, 5, 8, 6]\n",
+                "\n",
+                "# Seeing how the built-in functions compare\n",
+                "print(f\"Numpy's standard dev is: {np.std(data)}\")\n",
+                "print(f\"Stats standard dev is: {stats.stdev(data)}\")\n",
+                "\n",
+                "# find the mean of dataset\n",
+                "sm=0\n",
+                "for i in range(len(data)):\n",
+                "   sm+=data[i]\n",
+                "   mean = sm/len(data)\n",
+                "\n",
+                "# finding the standard dev \n",
+                "guess = 0\n",
+                "for i in range(len(data)):\n",
+                "   guess+=(data[i]- mean)**2\n",
+                "   sdev = math.sqrt((guess)/len(data))\n",
+                "print(f\"Program's sdev is {sdev}?\")\n",
+                "\n",
+                "\n"
+            ]
+        }
+    ],
+    "metadata": {
+        "interpreter": {
+            "hash": "9248718ffe6ce6938b217e69dbcc175ea21f4c6b28a317e96c05334edae734bb"
+        },
+        "kernelspec": {
+            "display_name": "Python 3.9.12 ('ML-BOOTCAMP')",
+            "language": "python",
+            "name": "python3"
+        },
+        "language_info": {
+            "codemirror_mode": {
+                "name": "ipython",
+                "version": 3
+            },
+            "file_extension": ".py",
+            "mimetype": "text/x-python",
+            "name": "python",
+            "nbconvert_exporter": "python",
+            "pygments_lexer": "ipython3",
+            "version": "3.11.4"
+        }
+    },
+    "nbformat": 4,
+    "nbformat_minor": 5
+}

From 6cec258ec2f7c9ca29bd8f83ac5352474bd9a3a5 Mon Sep 17 00:00:00 2001
From: Skcodingacademy <139916977+Skcodingacademy@users.noreply.github.com>
Date: Mon, 2 Oct 2023 21:18:30 +0000
Subject: [PATCH 05/10] Questions 1-2 answered

---
 SethKstats/problems.ipynb | 310 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 310 insertions(+)
 create mode 100644 SethKstats/problems.ipynb

diff --git a/SethKstats/problems.ipynb b/SethKstats/problems.ipynb
new file mode 100644
index 00000000..90358800
--- /dev/null
+++ b/SethKstats/problems.ipynb
@@ -0,0 +1,310 @@
+{
+    "cells": [
+        {
+            "cell_type": "markdown",
+            "id": "ac622319",
+            "metadata": {},
+            "source": [
+                "# Descriptive statistics problems"
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "id": "aa8993e4",
+            "metadata": {},
+            "source": [
+                "### Exercise 1"
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "id": "5e0ab0d5",
+            "metadata": {},
+            "source": [
+                "We will use Numpy to obtain information to describe statistically.\n",
+                "\n",
+                "- Generate an array of 100 elements following a normal distribution.\n",
+                "- Generate an array of 100 elements following a chi-square distribution with 3 degrees of freedom.\n",
+                "- Calculate the main metrics and statistical measures that best describe the two vectors."
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 38,
+            "id": "34720ab6",
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "import numpy as np\n",
+                "import statistics as stats\n",
+                "from scipy.stats import skew\n",
+                "from scipy.stats import kurtosis\n",
+                "\n",
+                "np.random.seed(0)\n",
+                "\n",
+                "norm = np.random.normal(size = 100) # This creates an array of 100 elements that have a normal distribution\n",
+                "chisq = np.random.chisquare(3, 100) # This creates an array of 100 elements the have a chi-square distribution with 3 degrees of freedom\n",
+                "\n",
+                "\n",
+                "\n",
+                "\n"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 39,
+            "id": "d643f90d",
+            "metadata": {},
+            "outputs": [
+                {
+                    "name": "stdout",
+                    "output_type": "stream",
+                    "text": [
+                        "Normal mean: 0.05980801553448498\n",
+                        "Chi mean: 3.0018406221613745\n"
+                    ]
+                }
+            ],
+            "source": [
+                "#What we are doing here is generating the mean to help describe the two vectors. \n",
+                "print(f\"Normal mean: {stats.mean(norm)}\") \n",
+                "print(f\"Chi mean: {stats.mean(chisq)}\")"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 40,
+            "id": "81a01c51",
+            "metadata": {},
+            "outputs": [
+                {
+                    "name": "stdout",
+                    "output_type": "stream",
+                    "text": [
+                        "Normal median: 0.09409611943799814\n",
+                        "Chi median: 2.3645115337568323\n"
+                    ]
+                }
+            ],
+            "source": [
+                "#What we are doing here is generating the median  to help describe the two vectors. \n",
+                "print(f\"Normal median: {stats.median(norm)}\")\n",
+                "print(f\"Chi median: {stats.median(chisq)}\")"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 41,
+            "id": "0c9e8edc",
+            "metadata": {},
+            "outputs": [
+                {
+                    "name": "stdout",
+                    "output_type": "stream",
+                    "text": [
+                        "Normal median: 1.764052345967664\n",
+                        "Chi median: 9.223556454255386\n"
+                    ]
+                }
+            ],
+            "source": [
+                "#What we are doing here is generating the mode to help describe the two vectors. \n",
+                "print(f\"Normal median: {stats.mode(norm)}\")\n",
+                "print(f\"Chi median: {stats.mode(chisq)}\")"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 42,
+            "id": "df442447",
+            "metadata": {},
+            "outputs": [
+                {
+                    "name": "stdout",
+                    "output_type": "stream",
+                    "text": [
+                        "Normal range: 4.822744439821687\n",
+                        "Normal chi: 11.255784308217786\n"
+                    ]
+                }
+            ],
+            "source": [
+                "#We now will calculate the range which is the max - the min\n",
+                "#We find the range for the normal distribution\n",
+                "norm_range = max(norm) - min(norm)\n",
+                "#Now we find the range for chi-square\n",
+                "chisq_range =  max(chisq) - min(chisq)\n",
+                "\n",
+                "#Now print our results \n",
+                "print(f\"Normal range: {norm_range}\")\n",
+                "print(f\"Normal chi: {chisq_range}\")\n"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 43,
+            "id": "832123a7",
+            "metadata": {},
+            "outputs": [
+                {
+                    "name": "stdout",
+                    "output_type": "stream",
+                    "text": [
+                        "Normal variance: 1.0260874941564964 and std: 1.0129597692685017\n",
+                        "Chi variance: 5.777917328519989 and std: 2.403729878443081\n"
+                    ]
+                }
+            ],
+            "source": [
+                "#Now we find the variance and standar deviation\n",
+                "var_normal = stats.variance(norm)\n",
+                "std_normal = stats.stdev(norm)\n",
+                "var_chi = stats.variance(chisq)\n",
+                "std_chi = stats.stdev(chisq)\n",
+                "\n",
+                "print(f\"Normal variance: {var_normal} and std: {std_normal}\")\n",
+                "print(f\"Chi variance: {var_chi} and std: {std_chi}\")"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 44,
+            "id": "379a56bb",
+            "metadata": {},
+            "outputs": [
+                {
+                    "name": "stdout",
+                    "output_type": "stream",
+                    "text": [
+                        "Normal skewness: 0.005171839713550013\n",
+                        "Chi skewness: 1.342791266776593\n"
+                    ]
+                }
+            ],
+            "source": [
+                "skew_normal = skew(norm)\n",
+                "skew_chi = skew(chisq)\n",
+                "\n",
+                "print(f\"Normal skewness: {skew_normal}\")\n",
+                "print(f\"Chi skewness: {skew_chi}\")"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 45,
+            "id": "06427a31",
+            "metadata": {},
+            "outputs": [
+                {
+                    "name": "stdout",
+                    "output_type": "stream",
+                    "text": [
+                        "Normal kurtosis: -0.3783545566331328\n",
+                        "Chi kurtosis: 1.6572033096538448\n"
+                    ]
+                }
+            ],
+            "source": [
+                "kurt_normal = kurtosis(norm)\n",
+                "kurt_chi = kurtosis(chisq)\n",
+                "\n",
+                "print(f\"Normal kurtosis: {kurt_normal}\")\n",
+                "print(f\"Chi kurtosis: {kurt_chi}\")\n"
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "id": "46c70c3d",
+            "metadata": {},
+            "source": [
+                "### Exercise 2\n",
+                "\n",
+                "Write a Python program to calculate the standard deviation of the following data:\n",
+                "\n",
+                "```py\n",
+                "data = [4, 2, 5, 8, 6]\n",
+                "```"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 37,
+            "id": "d590308e",
+            "metadata": {},
+            "outputs": [
+                {
+                    "name": "stdout",
+                    "output_type": "stream",
+                    "text": [
+                        "Sample Data: [4, 2, 5, 8, 6]\n",
+                        "Standard Deviation: 2.23606797749979\n"
+                    ]
+                }
+            ],
+            "source": [
+                "import math\n",
+                "import sys\n",
+                "\n",
+                "# Define the standard deviation function\n",
+                "\n",
+                "def sd_func(data):\n",
+                "    n = len(data)\n",
+                "\n",
+                "    if (n <= 1):\n",
+                "        return 0.0\n",
+                "\n",
+                "    mean, sd = avg_func(data), 0.0\n",
+                "\n",
+                "    for d in data:\n",
+                "        sd += (float(d) - mean) ** 2\n",
+                "    sd = math.sqrt(sd / float(n - 1))\n",
+                "\n",
+                "    return sd\n",
+                "\n",
+                "def avg_func(data):\n",
+                "    n, mean = len(data), 0.0\n",
+                "\n",
+                "    if (n <= 1):\n",
+                "        return data[0]\n",
+                "\n",
+                "    for d in data:\n",
+                "        mean = mean + float(d)\n",
+                "\n",
+                "    mean = mean / float(n)\n",
+                "    return mean\n",
+                "\n",
+                "#The f inside the print function allows for efficent formatting\n",
+                "#The sample data is our  data being tested and given\n",
+                "#When sd_func is called, it will find the standard deviation for our sample data\n",
+                "\n",
+                "data = [4, 2, 5, 8, 6]\n",
+                "print(f\"Sample Data: {data}\")\n",
+                "print(f\"Standard Deviation: {sd_func(data)}\")\n"
+            ]
+        }
+    ],
+    "metadata": {
+        "interpreter": {
+            "hash": "9248718ffe6ce6938b217e69dbcc175ea21f4c6b28a317e96c05334edae734bb"
+        },
+        "kernelspec": {
+            "display_name": "Python 3.9.12 ('ML-BOOTCAMP')",
+            "language": "python",
+            "name": "python3"
+        },
+        "language_info": {
+            "codemirror_mode": {
+                "name": "ipython",
+                "version": 3
+            },
+            "file_extension": ".py",
+            "mimetype": "text/x-python",
+            "name": "python",
+            "nbconvert_exporter": "python",
+            "pygments_lexer": "ipython3",
+            "version": "3.11.4"
+        }
+    },
+    "nbformat": 4,
+    "nbformat_minor": 5
+}

From 4d67842c202e3a85abae48ea45d4c8ae25225f7c Mon Sep 17 00:00:00 2001
From: Skcodingacademy <139916977+Skcodingacademy@users.noreply.github.com>
Date: Mon, 2 Oct 2023 21:20:29 +0000
Subject: [PATCH 06/10] 1-2 answered

---
 SethKstats/problems.ipynb | 2 +-
 notebook/solutions.ipynb  | 9 ++++++---
 2 files changed, 7 insertions(+), 4 deletions(-)

diff --git a/SethKstats/problems.ipynb b/SethKstats/problems.ipynb
index 90358800..f9ce6309 100644
--- a/SethKstats/problems.ipynb
+++ b/SethKstats/problems.ipynb
@@ -275,7 +275,7 @@
                 "\n",
                 "#The f inside the print function allows for efficent formatting\n",
                 "#The sample data is our  data being tested and given\n",
-                "#When sd_func is called, it will find the standard deviation for our sample data\n",
+                "#When sd_func is called, it will find the standard deviation for our  data\n",
                 "\n",
                 "data = [4, 2, 5, 8, 6]\n",
                 "print(f\"Sample Data: {data}\")\n",
diff --git a/notebook/solutions.ipynb b/notebook/solutions.ipynb
index ed71f320..ef5a9bd9 100644
--- a/notebook/solutions.ipynb
+++ b/notebook/solutions.ipynb
@@ -268,12 +268,12 @@
                 }
             ],
             "source": [
-                "from scipy.stats import skew\n",
+                "\n",
                 "\n",
                 "skew_normal = skew(normal)\n",
                 "skew_chi = skew(chi)\n",
                 "\n",
-                "print(f\"Normal skewness: {skew_normal}\")\n",
+                "print(f\"Normal skewness: {skew_nor}\n",
                 "print(f\"Chi skewness: {skew_chi}\")"
             ]
         },
@@ -331,7 +331,7 @@
         },
         {
             "cell_type": "code",
-            "execution_count": 27,
+            "execution_count": 4,
             "id": "d590308e",
             "metadata": {},
             "outputs": [
@@ -345,6 +345,9 @@
                 }
             ],
             "source": [
+                "\n",
+                "\n",
+                "   \n",
                 "import math\n",
                 "import sys\n",
                 "\n",

From 4b0d26c9983d02f5208d7fa35c1e491acd18d37d Mon Sep 17 00:00:00 2001
From: Skcodingacademy <139916977+Skcodingacademy@users.noreply.github.com>
Date: Mon, 2 Oct 2023 21:34:40 +0000
Subject: [PATCH 07/10] Another way I found to solve it using stats.stdev

---
 SethKstats/problems.ipynb | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/SethKstats/problems.ipynb b/SethKstats/problems.ipynb
index f9ce6309..9a3656c2 100644
--- a/SethKstats/problems.ipynb
+++ b/SethKstats/problems.ipynb
@@ -228,7 +228,7 @@
         },
         {
             "cell_type": "code",
-            "execution_count": 37,
+            "execution_count": 4,
             "id": "d590308e",
             "metadata": {},
             "outputs": [
@@ -237,13 +237,14 @@
                     "output_type": "stream",
                     "text": [
                         "Sample Data: [4, 2, 5, 8, 6]\n",
-                        "Standard Deviation: 2.23606797749979\n"
+                        "2.23606797749979\n"
                     ]
                 }
             ],
             "source": [
                 "import math\n",
                 "import sys\n",
+                "import statistics as stats\n",
                 "\n",
                 "# Define the standard deviation function\n",
                 "\n",
@@ -279,7 +280,8 @@
                 "\n",
                 "data = [4, 2, 5, 8, 6]\n",
                 "print(f\"Sample Data: {data}\")\n",
-                "print(f\"Standard Deviation: {sd_func(data)}\")\n"
+                "#print(f\"Standard Deviation: {sd_func(data)}\")\n",
+                "print(stats.stdev(data))\n"
             ]
         }
     ],

From a1094dd1848db50768bed005133d8d1c5f24d2cc Mon Sep 17 00:00:00 2001
From: Ricardo Hernandez <119596579+Ricoou@users.noreply.github.com>
Date: Mon, 2 Oct 2023 22:21:19 +0000
Subject: [PATCH 08/10] Finished Exercises

---
 Ricardo/problems.ipynb | 134 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 134 insertions(+)
 create mode 100644 Ricardo/problems.ipynb

diff --git a/Ricardo/problems.ipynb b/Ricardo/problems.ipynb
new file mode 100644
index 00000000..fc028bfb
--- /dev/null
+++ b/Ricardo/problems.ipynb
@@ -0,0 +1,134 @@
+{
+    "cells": [
+        {
+            "cell_type": "markdown",
+            "id": "ac622319",
+            "metadata": {},
+            "source": [
+                "# Descriptive statistics problems"
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "id": "aa8993e4",
+            "metadata": {},
+            "source": [
+                "### Exercise 1"
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "id": "5e0ab0d5",
+            "metadata": {},
+            "source": [
+                "We will use Numpy to obtain information to describe statistically.\n",
+                "\n",
+                "- Generate an array of 100 elements following a normal distribution.\n",
+                "- Generate an array of 100 elements following a chi-square distribution with 3 degrees of freedom.\n",
+                "- Calculate the main metrics and statistical measures that best describe the two vectors."
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 1,
+            "id": "34720ab6",
+            "metadata": {},
+            "outputs": [
+                {
+                    "name": "stdout",
+                    "output_type": "stream",
+                    "text": [
+                        "The mean of element 1 is 0.059808015534485\n",
+                        "The Standard Deviation of element 1 is 1.0078822447165796\n",
+                        "The mean of element 2 is 3.001840622161374\n",
+                        "The Standard Deviation of element 2 is 2.3916810312486882\n"
+                    ]
+                }
+            ],
+            "source": [
+                "import numpy as np\n",
+                "\n",
+                "np.random.seed(0)\n",
+                "\n",
+                "elements1 = np.random.normal(size=100)\n",
+                "elements2 = np.random.chisquare(df=3, size=100)\n",
+                "\n",
+                "elements1_mean = np.mean(elements1)\n",
+                "elements2_mean = np.mean(elements2)\n",
+                "\n",
+                "elements1_std = np.std(elements1)\n",
+                "elements2_std = np.std(elements2)\n",
+                "\n",
+                "print(f\"The mean of element 1 is {elements1_mean}\")\n",
+                "print(f\"The Standard Deviation of element 1 is {elements1_std}\")\n",
+                "print(f\"The mean of element 2 is {elements2_mean}\")\n",
+                "print(f\"The Standard Deviation of element 2 is {elements2_std}\")\n"
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "id": "46c70c3d",
+            "metadata": {},
+            "source": [
+                "### Exercise 2\n",
+                "\n",
+                "Write a Python program to calculate the standard deviation of the following data:\n",
+                "\n",
+                "```py\n",
+                "data = [4, 2, 5, 8, 6]\n",
+                "```"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 2,
+            "id": "d590308e",
+            "metadata": {},
+            "outputs": [
+                {
+                    "name": "stdout",
+                    "output_type": "stream",
+                    "text": [
+                        "Standard Deviation: 2.0\n"
+                    ]
+                }
+            ],
+            "source": [
+                "data = [4, 2, 5, 8, 6]\n",
+                "\n",
+                "\n",
+                "mean = sum(data) / len(data)\n",
+                "\n",
+                "variance = sum((x - mean) ** 2 for x in data) / len(data)\n",
+                "\n",
+                "standard_deviation = variance ** 0.5\n",
+                "\n",
+                "print(\"Standard Deviation:\", standard_deviation)"
+            ]
+        }
+    ],
+    "metadata": {
+        "interpreter": {
+            "hash": "9248718ffe6ce6938b217e69dbcc175ea21f4c6b28a317e96c05334edae734bb"
+        },
+        "kernelspec": {
+            "display_name": "Python 3.9.12 ('ML-BOOTCAMP')",
+            "language": "python",
+            "name": "python3"
+        },
+        "language_info": {
+            "codemirror_mode": {
+                "name": "ipython",
+                "version": 3
+            },
+            "file_extension": ".py",
+            "mimetype": "text/x-python",
+            "name": "python",
+            "nbconvert_exporter": "python",
+            "pygments_lexer": "ipython3",
+            "version": "3.11.4"
+        }
+    },
+    "nbformat": 4,
+    "nbformat_minor": 5
+}

From 686f136274b18a7054686513316c273c524dcfa3 Mon Sep 17 00:00:00 2001
From: Rob <rcu3@njit.edu>
Date: Thu, 5 Oct 2023 15:25:25 -0400
Subject: [PATCH 09/10] Added problems to notebook folder

---
 notebook/problems.ipynb | 90 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 90 insertions(+)
 create mode 100644 notebook/problems.ipynb

diff --git a/notebook/problems.ipynb b/notebook/problems.ipynb
new file mode 100644
index 00000000..ff2c594b
--- /dev/null
+++ b/notebook/problems.ipynb
@@ -0,0 +1,90 @@
+{
+    "cells": [
+        {
+            "cell_type": "markdown",
+            "id": "ac622319",
+            "metadata": {},
+            "source": [
+                "# Descriptive statistics problems"
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "id": "aa8993e4",
+            "metadata": {},
+            "source": [
+                "### Exercise 1"
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "id": "5e0ab0d5",
+            "metadata": {},
+            "source": [
+                "We will use Numpy to obtain information to describe statistically.\n",
+                "\n",
+                "- Generate an array of 100 elements following a normal distribution.\n",
+                "- Generate an array of 100 elements following a chi-square distribution with 3 degrees of freedom.\n",
+                "- Calculate the main metrics and statistical measures that best describe the two vectors."
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 1,
+            "id": "34720ab6",
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "# TODO"
+            ]
+        },
+        {
+            "cell_type": "markdown",
+            "id": "46c70c3d",
+            "metadata": {},
+            "source": [
+                "### Exercise 2\n",
+                "\n",
+                "Write a Python program to calculate the standard deviation of the following data:\n",
+                "\n",
+                "```py\n",
+                "data = [4, 2, 5, 8, 6]\n",
+                "```"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 2,
+            "id": "d590308e",
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "# TODO"
+            ]
+        }
+    ],
+    "metadata": {
+        "interpreter": {
+            "hash": "9248718ffe6ce6938b217e69dbcc175ea21f4c6b28a317e96c05334edae734bb"
+        },
+        "kernelspec": {
+            "display_name": "Python 3.9.12 ('ML-BOOTCAMP')",
+            "language": "python",
+            "name": "python3"
+        },
+        "language_info": {
+            "codemirror_mode": {
+                "name": "ipython",
+                "version": 3
+            },
+            "file_extension": ".py",
+            "mimetype": "text/x-python",
+            "name": "python",
+            "nbconvert_exporter": "python",
+            "pygments_lexer": "ipython3",
+            "version": "3.11.4"
+        }
+    },
+    "nbformat": 4,
+    "nbformat_minor": 5
+}

From 2fa212e787d6629e1d9f37192a6027bbcd9cef17 Mon Sep 17 00:00:00 2001
From: Rob <rcu3@njit.edu>
Date: Fri, 20 Oct 2023 19:57:31 +0000
Subject: [PATCH 10/10]  Both Problems finished

---
 notebook/problems.ipynb | 125 ++++++++++++++++++++++++++++++++++++++--
 1 file changed, 119 insertions(+), 6 deletions(-)

diff --git a/notebook/problems.ipynb b/notebook/problems.ipynb
index ff2c594b..3dfe3fc0 100644
--- a/notebook/problems.ipynb
+++ b/notebook/problems.ipynb
@@ -30,12 +30,104 @@
         },
         {
             "cell_type": "code",
-            "execution_count": 1,
+            "execution_count": 2,
             "id": "34720ab6",
             "metadata": {},
-            "outputs": [],
+            "outputs": [
+                {
+                    "name": "stdout",
+                    "output_type": "stream",
+                    "text": [
+                        "The Normal Distribution is[ 0.22827309  1.0268903  -0.83958485 -0.59118152 -0.9568883  -0.22232569\n",
+                        " -0.61991511  1.83790458 -2.05323076  0.86858305 -0.92073444 -0.23231186\n",
+                        "  2.1529569  -1.33466147  0.07637965 -1.24608928  1.20227231 -1.04994158\n",
+                        "  1.05661011 -0.41967767  2.29484234 -2.59448738  2.8227564   0.68088892\n",
+                        " -1.57769345 -1.97625359  0.53333982 -0.29086971 -0.51351967  1.98262608\n",
+                        "  0.22600105 -1.83990496  1.60767083  0.38829194  0.39973206  0.4054766\n",
+                        "  0.21700177 -0.6334391   0.24662153 -1.93954552  0.11405963 -1.8853414\n",
+                        "  0.24308048 -0.70548067  0.36462762 -0.50295216 -0.22575155 -0.56553773\n",
+                        "  0.10339501  2.01840842  1.09424827  1.6624344  -0.62745348  1.62119964\n",
+                        "  1.17813267 -0.37487875 -0.54432898  0.28776118 -0.20581999  1.18998786\n",
+                        "  0.72892688 -0.22204012 -1.62270578  0.31254055 -1.16042141  0.31355968\n",
+                        "  0.47199786  0.57786171  0.50540675 -0.62648777 -0.34636933 -2.06594183\n",
+                        "  0.76893629  1.12886631  0.16692354 -0.96725539  0.49199625 -0.55085717\n",
+                        " -0.08469407  1.96756834 -0.06267511 -0.85113578  0.42652063 -0.27756074\n",
+                        " -1.37794456 -0.09519641  0.83363873 -0.78475445  1.04614478 -0.645784\n",
+                        " -1.89157934 -0.09733285 -1.35889534  0.49830983 -1.14732055 -0.53652108\n",
+                        " -0.91648938 -0.21214793  0.19284449 -0.32268305] and the  Main Metrics and Statistical measures for it are:\n",
+                        "Mean: -0.051500969332526\n",
+                        "Standard Deviation: 1.083568563267722\n",
+                        "Median: -0.09626463210302683\n",
+                        "Variance: 1.1741208313020757\n",
+                        "The Chi-Square Distribution is[ 4.4036977   3.43357991  2.43865116  3.76468546  1.74738374  2.87304496\n",
+                        "  1.25990264  1.98658061  2.7382904   2.40379373  6.43281884  1.35117521\n",
+                        "  8.7849878  13.06470946  1.7418934   2.67968429  1.02479675  1.67765141\n",
+                        "  1.06959774  0.32544055 10.02554874  0.68163247  3.39104851  1.08370858\n",
+                        "  1.9876063   1.34763536  1.6517412   8.21316019  1.48801337  4.76964702\n",
+                        "  4.9766      1.96968626  0.87373953  3.55316881  2.3748913   0.79432302\n",
+                        "  0.7701773   3.68548924  3.2519995  10.09726069  3.06195584  4.94862294\n",
+                        "  8.40693551  8.2386102   0.51444887  1.57892549  9.45502228  6.76435901\n",
+                        "  0.08425656  4.31558523  0.53234731  6.0103969   1.6261617   6.64144191\n",
+                        "  5.66904724  2.45959271  1.31656293  5.12092043  9.13811987  0.02222266\n",
+                        "  1.50610432  1.57706424  3.32373864  1.99068763  6.89886783  2.93937469\n",
+                        "  0.78214448  1.80647672  0.62057492  3.73253103  6.79628785  5.09298138\n",
+                        "  4.54692477  1.54790254  2.34164297  0.80446453  3.46601364  0.68885048\n",
+                        "  0.68235736  8.19098932  3.05658688  3.85504193  1.97097259  2.02332414\n",
+                        "  2.90044156  3.14758326  7.51373069  2.52268567  0.96407427  0.66239969\n",
+                        "  2.55400914  1.26706758  4.04029785  1.91665878  1.57053958  0.1736914\n",
+                        "  2.77972265  5.91638755  2.69140858  6.50403792] and the  Main Metrics and Statistical measures for it are:\n",
+                        "Mean: 3.35461619770656\n",
+                        "Standard Deviation: 2.696252896948903\n",
+                        "Median: 2.5383474082247273\n",
+                        "Variance: 7.269779684305352\n"
+                    ]
+                },
+                {
+                    "data": {
+                        "text/plain": [
+                            "<function print(*args, sep=' ', end='\\n', file=None, flush=False)>"
+                        ]
+                    },
+                    "execution_count": 2,
+                    "metadata": {},
+                    "output_type": "execute_result"
+                }
+            ],
             "source": [
-                "# TODO"
+                "# TODO\n",
+                "import numpy as np\n",
+                "import pandas as pd\n",
+                "\n",
+                "np.random.seed(25)\n",
+                "\n",
+                "normal = np.random.normal(size=100)\n",
+                "chi_square = np.random.chisquare(3,100)\n",
+                "\n",
+                "\n",
+                "\n",
+                "normal_mean = np.mean(normal)\n",
+                "normal_std = np.std(normal)\n",
+                "normal_median = np.median(normal)\n",
+                "normal_variance = np.var(normal)\n",
+                "\n",
+                "chi_square_mean = np.mean(chi_square)\n",
+                "chi_square_std = np.std(chi_square)\n",
+                "chi_square_median = np.median(chi_square)\n",
+                "chi_square_variance = np.var(chi_square)\n",
+                "\n",
+                "print(f\"The Normal Distribution is{normal} and the  Main Metrics and Statistical measures for it are:\")\n",
+                "print(f\"Mean: {normal_mean}\")\n",
+                "print(f\"Standard Deviation: {normal_std}\")\n",
+                "print(f\"Median: {normal_median}\")\n",
+                "print(f\"Variance: {normal_variance}\")\n",
+                "\n",
+                "print(f\"The Chi-Square Distribution is{chi_square} and the  Main Metrics and Statistical measures for it are:\")\n",
+                "print(f\"Mean: {chi_square_mean}\")\n",
+                "print(f\"Standard Deviation: {chi_square_std}\")\n",
+                "print(f\"Median: {chi_square_median}\")\n",
+                "print(f\"Variance: {chi_square_variance}\")\n",
+                "\n",
+                "print"
             ]
         },
         {
@@ -54,12 +146,33 @@
         },
         {
             "cell_type": "code",
-            "execution_count": 2,
+            "execution_count": 1,
             "id": "d590308e",
             "metadata": {},
-            "outputs": [],
+            "outputs": [
+                {
+                    "name": "stdout",
+                    "output_type": "stream",
+                    "text": [
+                        "Standard Deviation:2.0\n"
+                    ]
+                }
+            ],
             "source": [
-                "# TODO"
+                "# TODO\n",
+                "\n",
+                "import math\n",
+                "\n",
+                "data = [4,2,5,8,6]\n",
+                "\n",
+                "\n",
+                "mean = sum(data) / len(data)\n",
+                "variance = sum((x - mean) ** 2 for x in data) / len(data)\n",
+                "\n",
+                "\n",
+                "std = math.sqrt(variance)\n",
+                "\n",
+                "print(f\"Standard Deviation:{std}\")\n"
             ]
         }
     ],