diff --git a/Conditional Probability.ipynb b/Conditional Probability.ipynb new file mode 100644 index 0000000..bcb57ef --- /dev/null +++ b/Conditional Probability.ipynb @@ -0,0 +1,61 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 4, + "id": "36a13cbb", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Conditional probabilities P(B_i|A): [0.9615384615384615, 0.038461538461538464]\n" + ] + } + ], + "source": [ + "def conditional(P_A_given_B, P_B):\n", + " # Calculate the total probability P(A)\n", + " P_A = 0\n", + " for i in range(len(P_B)):\n", + " P_A += P_A_given_B[i] * P_B[i]\n", + "\n", + " # Calculate P(B_i|A) for each i\n", + " P_B_given_A = []\n", + " for i in range(len(P_B)):\n", + " P_B_given_A.append(P_A_given_B[i] * P_B[i] / P_A)\n", + "\n", + " return P_B_given_A\n", + "\n", + "# Example usage\n", + "P_A_given_B = [250/2000, 5/1000] # Replace with actual values\n", + "P_B = [0.5, 0.5] # Replace with actual values\n", + "\n", + "P_B_given_A = conditional(P_A_given_B, P_B)\n", + "print(\"Conditional probabilities P(B_i|A):\", P_B_given_A)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.5" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/Determination of Eigen Vectors using Gaussian Elimination.ipynb b/Determination of Eigen Vectors using Gaussian Elimination.ipynb new file mode 100644 index 0000000..be3805f --- /dev/null +++ b/Determination of Eigen Vectors using Gaussian Elimination.ipynb @@ -0,0 +1,248 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 12, + "id": "dfb587b9", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Eigenvalues: \n", + " [ 0.457 0.22 0.35 0.7 -0.36386416 1. ]\n", + "\n", + "Eigenvectors: \n", + " [[ 0. 0. 0.22017812 0. 0.4356766 -0.38455393]\n", + " [ 0. 0.53937656 0.27098846 0. -0.11939122 -0.07888286]\n", + " [ 1. -0.84206468 -0.93706289 0. 0.05381494 -0.05375075]\n", + " [ 0. 0. 0. 0. 0.82621521 -0.81819985]\n", + " [ 0. 0. 0. 0. -0.31101391 -0.24996005]\n", + " [ 0. 0. 0. 1. 0.11693745 -0.33328007]]\n", + "\n", + "Dominant Eigenvalue: \n", + " 1.0\n", + "Corresponding Eigenvector: \n", + " [-0.38455393 -0.07888286 -0.05375075 -0.81819985 -0.24996005 -0.33328007]\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "L = np.array([[7/20, 0, 0, 0, 1, 0],\n", + " [4/25, 11/50, 0, 0, 0, 0],\n", + " [0, 37/100, 457/1000, 0, 0, 0],\n", + " [0, 0, 0, 389/1000, 2, 0],\n", + " [0, 0, 0, 23/100, 151/611, 0],\n", + " [0, 0, 0, 0, 2/5, 7/10]])\n", + "\n", + "\n", + "Evalues, Evectors = np.linalg.eig(L)\n", + "pos = np.argmax(np.abs(Evalues))\n", + "val = Evalues[pos]\n", + "vec = Evectors[:, pos]\n", + "\n", + "print(\"Eigenvalues: \\n\", Evalues)\n", + "print(\"\\nEigenvectors: \\n\", Evectors)\n", + "print(\"\\nDominant Eigenvalue: \\n\", val)\n", + "print(\"Corresponding Eigenvector: \\n\", vec)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "ab4fb811", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Solution Status: Unique Solution\n", + "The solution to LX = B is:\n", + "X= [[0.20042576]\n", + " [0.04109944]\n", + " [0.02801577]\n", + " [0.42644739]\n", + " [0.13028098]\n", + " [0.17369658]]\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "\n", + "# Define a function for Gaussian Elimination to solve a system of linear equations\n", + "def Gauss_Elimination(A):\n", + " # Get the number of rows in the matrix A (assuming it's a square matrix).\n", + " n = len(A)\n", + " \n", + " # Start the Gaussian elimination process.\n", + " for i in range(n):\n", + " # Find the row with the maximum absolute value in the current column.\n", + " max_row = i\n", + " for j in range(i + 1, n):\n", + " if abs(A[j, i]) > abs(A[max_row, i]):\n", + " max_row = j\n", + " \n", + " # Swap the current row (i) with the row containing the maximum value (max_row).\n", + " A[[i, max_row]] = A[[max_row, i]]\n", + " \n", + " # Perform row operations to make the elements below the pivot (A[i, i]) zero.\n", + " for j in range(i + 1, n):\n", + " factor = A[j, i] / A[i, i]\n", + " A[j, :] -= factor * A[i, :]\n", + "\n", + " # Initialize a solution vector X with zeros.\n", + " X = np.zeros((n, 1))\n", + " \n", + " # Back-substitution to find the values of X starting from the last row.\n", + " for i in range(n - 1, -1, -1):\n", + " # Calculate the value of X[i] using the previously found values of X.\n", + " X[i] = (A[i, -1] - np.matmul(A[i, :-1], X)) / A[i, i]\n", + "\n", + " # Return the solution vector X.\n", + " return X\n", + "\n", + "# Define a function to check the solution status (Inconsistent, Unique, or Infinite)\n", + "def check_solution_status(A):\n", + " # Check the row echelon form of the augmented matrix A\n", + " n = len(A)\n", + " rank_A = np.linalg.matrix_rank(A[:, :-1])\n", + " rank_Ab = np.linalg.matrix_rank(A)\n", + " \n", + " if rank_A < rank_Ab:\n", + " return \"Inconsistent Solution\" # No solution\n", + " elif rank_A == rank_Ab and rank_A == n:\n", + " return \"Unique Solution\" # Unique solution\n", + " elif rank_A == rank_Ab and rank_A < n:\n", + " return \"Infinite Solutions\" # Infinite solutions\n", + "\n", + "# Define the coefficient matrix L\n", + "L = np.array([[7/20, 0, 0, 0, 1, 0],\n", + " [4/25, 11/50, 0, 0, 0, 0],\n", + " [0, 37/100, 457/1000, 0, 0, 0],\n", + " [0, 0, 0, 389/1000, 2, 0],\n", + " [0, 0, 0, 23/100, 151/611, 0],\n", + " [0, 0, 0, 0, 2/5, 7/10]])\n", + "\n", + "# Define the right-hand side vector B\n", + "B = np.array([0.20043, 0.04111, 0.02801, 0.42645, 0.13028, 0.17370])\n", + "\n", + "\n", + "# Reshape the vector B into a column vector BT\n", + "BT = B.reshape(-1, 1)\n", + "\n", + "# Create the augmented matrix A by stacking L and BT as a new column\n", + "A = np.column_stack((L, BT))\n", + "\n", + "# Check the solution status of the system of linear equations\n", + "solution_status = check_solution_status(A)\n", + "\n", + "# Print the solution status\n", + "print(\"Solution Status:\", solution_status)\n", + "\n", + "# If the solution is Unique or Infinite, find and print the solution vector X\n", + "if solution_status == \"Unique Solution\" or solution_status == \"Infinite Solutions\":\n", + " X = Gauss_Elimination(A)\n", + " print(\"The solution to LX = B is:\")\n", + " print(\"X=\",X)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "0c8b7b5b", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "p1, p2, p3 = 7/20, 11/50, 457/1000 # Probabilities p1, p2, and p3\n", + "p1f, p2f, p3f = 389/1000, 151/611, 7/10 # Probabilities p1f, p2f, and p3f\n", + "m12, m23 = 4/25, 37/100 # Transition probabilities m12 and m23\n", + "m12f, m23f = 23/100, 2/5 # Transition probabilities m12f and m23f\n", + "f2m, f2f = 1, 2 # Factors f2m and f2f\n", + "\n", + "import matplotlib.pyplot as plt # Import the matplotlib library for plotting\n", + "import numpy as np # Import the numpy library for numerical operations\n", + "\n", + "# Define the initial population as an array sum\n", + "initial_population = np.array([50, 50, 50, 50, 50, 50]).sum()\n", + "\n", + "# Define a function to check if the final population is less than the initial population\n", + "def is_final_population_less_than_initial(a: float, b: float) -> bool:\n", + " L = np.array([ # Create a matrix L\n", + " [p1, 0, 0, 0, f2m, 0], # Row 1\n", + " [m12, p2, 0, 0, 0, 0], # Row 2\n", + " [0, m23, p3, 0, 0, 0], # Row 3\n", + " [0, 0, 0, a, f2f, 0], # Row 4\n", + " [0, 0, 0, m12f, b, 0], # Row 5\n", + " [0, 0, 0, 0, m23f, p3f] # Row 6\n", + " ])\n", + " Zk = np.array([ # Create an array Zk\n", + " [50], # Initial population values\n", + " [50],\n", + " [50],\n", + " [50],\n", + " [50],\n", + " [50]\n", + " ])\n", + " for _ in range(50): # Iterate 50 times to compute the final population\n", + " Zk = np.matmul(L, Zk) # Matrix multiplication to calculate the final population\n", + " return Zk.sum() < initial_population # Check if the final population is less than the initial population\n", + "\n", + "# Create lists to store the values of a and b that result in expected population < X\n", + "valid_a_values, valid_b_values = [], []\n", + "\n", + "a_values = b_values = np.linspace(0, 2, 60) # Create arrays of values from 0 to 1 with 100 points\n", + "\n", + "for a in a_values: # Iterate over a_values\n", + " for b in b_values: # Iterate over b_values\n", + " if is_final_population_less_than_initial(a, b): # Check if final population is less than initial\n", + " valid_a_values.append(a) # Append valid 'a' values\n", + " valid_b_values.append(b) # Append valid 'b' values\n", + "\n", + "# Create a scatter plot to visualize the results\n", + "plt.figure(figsize=(8, 6)) # Set the figure size\n", + "plt.scatter(valid_a_values, valid_b_values, s=10, c='red', marker='o') # Create a scatter plot\n", + "plt.xlabel('a') # Set the x-axis label\n", + "plt.ylabel('b') # Set the y-axis label\n", + "plt.title(f'Values of a and b for which Expected Population < Initial Population') # Set the title\n", + "plt.grid(True) # Display a grid on the plot\n", + "plt.show() # Show the plot" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.5" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}