Numpy_Assignment.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f64219db-84d5-4bf3-9192-81cbdc8bdc54",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9421f658-7aa0-41fb-8039-8c9ce16b2465",
   "metadata": {},
   "outputs": [],
   "source": [
    "                                                  **** Numpy Assignment Questions ****"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "27aed698-0637-44d2-8075-47fea5f63c08",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "c3fb909a-50bb-41cb-a8cf-ef7183a63734",
   "metadata": {},
   "source": [
    "### 1. What is a Python library? Why do we use Python libraries?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "30ca53c0-e3ce-48ef-b8d4-ad0a19f5caac",
   "metadata": {},
   "outputs": [],
   "source": [
    "'''\n",
    "A Python library is a collection of pre-written functions and tools that help developers perform tasks efficiently\n",
    "without having to write code from scratch. We use Python libraries for code reusability, efficiency, \n",
    "accessing specialized functionality, community support, and interoperability with other libraries.\n",
    "\n",
    "import numpy as np \n",
    "python libraries are collection of modules and function that can be used to perform specific task.\n",
    "Libraries are prewritten code which save time and efforts.\n",
    "'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "82b8b9ed-05de-4481-ab3c-cabf2641c8b1",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "7d91c0ad-f7bc-4237-b832-0d42f0ee6b2d",
   "metadata": {},
   "source": [
    "### 2. What is the difference between Numpy array and List?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c068cb6a-9ca5-4d39-8494-6fa9a550f5af",
   "metadata": {},
   "outputs": [],
   "source": [
    "'''\n",
    "The main differences between a NumPy array and a list are:\n",
    "\n",
    "#NumPy arrays are homogeneous, meaning all elements must be of the same data type, while lists can contain elements of different data types.\n",
    "#NumPy arrays offer more efficient storage and operations for numerical data.\n",
    "#NumPy arrays support vectorized operations, making it easier to perform element-wise operations without explicit looping.\n",
    "#memory allocation in array is contigious while in list it is random.\n",
    "#In array homogeneous data is used while in list hetrogeneous data can be used.\n",
    "#array is statically defined while lists are dynamically defined.\n",
    "'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "aabe202c-bb4a-4525-be66-a612a1d1fa18",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "27e0e0f5-439e-4fcd-80fa-1d614b73fbcd",
   "metadata": {},
   "source": [
    "### 3. Find the shape, size and dimension of the following array?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "30a80ea1-1275-410e-9723-c47a6c52ceff",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Shape of the array: (3, 4)\n",
      "Size of the array: 12\n",
      "Dimension of the array: 2\n"
     ]
    }
   ],
   "source": [
    "'''\n",
    "3. Find the shape, size and dimension of the following array?\n",
    "[[1, 2, 3, 4]\n",
    "[5, 6, 7, 8],\n",
    "[9, 10, 11, 12]]\n",
    "'''\n",
    "import numpy as np\n",
    "\n",
    "# Define the array\n",
    "arr = np.array([[1, 2, 3, 4],\n",
    "                [5, 6, 7, 8],\n",
    "                [9, 10, 11, 12]])\n",
    "\n",
    "# Find the shape, size, and dimension of the array\n",
    "shape = arr.shape\n",
    "size = arr.size\n",
    "dimension = arr.ndim\n",
    "\n",
    "# Print the results\n",
    "print(\"Shape of the array:\", shape)\n",
    "print(\"Size of the array:\", size)\n",
    "print(\"Dimension of the array:\", dimension)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "801a1a5a-f789-43e0-9d11-ba3f5e0f0fa9",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2a7bf71b-d4a5-4bbe-873f-e7fea15a832b",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "6f8b6e41-463e-4565-84ed-2478fdc383c3",
   "metadata": {},
   "source": [
    "### 4. Write python code to access the first row of the following array?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "59482a52-9a86-4e64-898c-e9b13faaa0b0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "First row of the array: [1 2 3 4]\n"
     ]
    }
   ],
   "source": [
    "'''\n",
    "4. Write python code to access the first row of the following array?\n",
    "[[1, 2, 3, 4]\n",
    "[5, 6, 7, 8],\n",
    "[9, 10, 11, 12]]\n",
    "'''\n",
    "import numpy as np\n",
    "\n",
    "# Define the array\n",
    "arr = np.array([[1, 2, 3, 4],\n",
    "                [5, 6, 7, 8],\n",
    "                [9, 10, 11, 12]])\n",
    "\n",
    "# Access the first row\n",
    "first_row = arr[0 , :]\n",
    "\n",
    "# Print the first row\n",
    "print(\"First row of the array:\", first_row)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6f0a5a4d-2547-402f-93c0-7973ab9f43ff",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a6f62ffd-f324-47f2-a7cb-bf17a78c102a",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "141ac174-e130-48ec-b4a9-0a44e316d190",
   "metadata": {},
   "source": [
    "### 5. How do you access the element at the third row and fourth column from the given numpy array?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "f9c59002-a8c9-43bf-8a7e-0d4f5f35907d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "element at the third row and fourth column of the array: 12\n"
     ]
    }
   ],
   "source": [
    "'''\n",
    "5. How do you access the element at the third row and fourth column from the given numpy array?\n",
    "[[1, 2, 3, 4]\n",
    "[5, 6, 7, 8],\n",
    "[9, 10, 11, 12]]\n",
    "'''\n",
    "import numpy as np\n",
    "\n",
    "# Define the array\n",
    "arr = np.array([[1, 2, 3, 4],\n",
    "                [5, 6, 7, 8],\n",
    "                [9, 10, 11, 12]])\n",
    "\n",
    "# Access the third row and fourth column\n",
    "element = arr[2, 3]\n",
    "\n",
    "# Print the third row and fourth column\n",
    "print(\"element at the third row and fourth column of the array:\", element)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "31346c6f-f532-4ef9-9e9c-93833ad0241a",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "05f27b4a-848c-44d7-aab7-cf534ee012a3",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "51a22925-07e8-4ef5-9763-d474c2389d1e",
   "metadata": {},
   "source": [
    "### 6. Write code to extract all odd indexed elements from the given numpy array?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "996a2149-311c-4d93-9738-1577044e0482",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Odd-indexed elements of the array: [[ 2  4]\n",
      " [ 6  8]\n",
      " [10 12]]\n"
     ]
    }
   ],
   "source": [
    "'''\n",
    "6. Write code to extract all odd indexed elements from the given numpy array?\n",
    "[[1, 2, 3, 4]\n",
    "[5, 6, 7, 8],\n",
    "[9, 10, 11, 12]]\n",
    "'''\n",
    "import numpy as np\n",
    "\n",
    "# Define the array\n",
    "arr = np.array([[1, 2, 3, 4],\n",
    "                [5, 6, 7, 8],\n",
    "                [9, 10, 11, 12]])\n",
    "\n",
    "# Extract all odd-indexed elements\n",
    "odd_indexed_elements = arr[:, 1::2]\n",
    "#The 1::2 notation means start from index 1 and step by 2, which effectively selects the elements at odd indices.\n",
    "# Print the odd-indexed elements\n",
    "print(\"Odd-indexed elements of the array:\", odd_indexed_elements)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b787fb71-80bc-442d-8c57-15336db7bf2e",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c5dc02c3-caf6-42a5-9b77-185e22172064",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "c48a3ab1-04bb-46bd-8d4d-550d463c2e8e",
   "metadata": {},
   "source": [
    "### 7. How can you generate a random 3x3 matrix with values between 0 and 1?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "e89946d3-3b57-42a8-9d01-8de81c6dfe57",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Random 3x3 matrix:\n",
      "[[0.27509997 0.43764037 0.87851662]\n",
      " [0.269348   0.85146163 0.30074917]\n",
      " [0.31152026 0.9796925  0.27737527]]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "# Generate a random 3x3 matrix with values between 0 and 1\n",
    "random_matrix = np.random.rand(3, 3)\n",
    "\n",
    "print(\"Random 3x3 matrix:\")\n",
    "print(random_matrix)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "48c31a7e-b6e1-4682-8a60-bce678065965",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ee879715-d786-43a2-85dc-04106fb9ee5d",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "a6835b0c-7e26-4d4c-a4f5-83aa1bbcc447",
   "metadata": {},
   "source": [
    "### 8. Describe the difference between np.random.rand and np.random.randn?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "ecb5b179-cc4c-4044-8b66-7631196de440",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Random matrix from np.random.rand (uniform distribution):\n",
      "[[0.32569687 0.7975001 ]\n",
      " [0.45077854 0.85247847]]\n",
      "\n",
      "Random matrix from np.random.randn (standard normal distribution):\n",
      "[[ 0.30655833 -0.42640899]\n",
      " [-0.92719157 -0.21654065]]\n"
     ]
    }
   ],
   "source": [
    "'''\n",
    "The difference between np.random.rand and np.random.randn is that the former generates random values from a uniform distribution \n",
    "between 0 and 1, while the latter generates values from a standard normal distribution (mean=0, standard deviation=1).\n",
    "'''\n",
    "import numpy as np\n",
    "\n",
    "# Generate a 2x2 matrix with random numbers from a uniform distribution [0, 1) using np.random.rand\n",
    "uniform_random_matrix = np.random.rand(2, 2)\n",
    "\n",
    "# Generate a 2x2 matrix with random numbers from a standard normal distribution using np.random.randn\n",
    "normal_random_matrix = np.random.randn(2, 2)\n",
    "\n",
    "print(\"Random matrix from np.random.rand (uniform distribution):\")\n",
    "print(uniform_random_matrix)\n",
    "print(\"\\nRandom matrix from np.random.randn (standard normal distribution):\")\n",
    "print(normal_random_matrix)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1ba0eb0a-b196-4997-9ccd-c188ba02c118",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8c88d9b7-c2f1-44ae-84f4-f23629007bba",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "f26100be-5cf8-4118-93f9-4c3b0b592a9b",
   "metadata": {},
   "source": [
    "### 9. Write code to increase the dimension of the following array?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "8905b71b-ee49-428a-a1fa-c77cafbebab6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original array:\n",
      "[[ 1  2  3  4]\n",
      " [ 5  6  7  8]\n",
      " [ 9 10 11 12]]\n",
      "\n",
      "Array with increased dimension:\n",
      "[[[ 1]\n",
      "  [ 2]\n",
      "  [ 3]\n",
      "  [ 4]]\n",
      "\n",
      " [[ 5]\n",
      "  [ 6]\n",
      "  [ 7]\n",
      "  [ 8]]\n",
      "\n",
      " [[ 9]\n",
      "  [10]\n",
      "  [11]\n",
      "  [12]]]\n"
     ]
    }
   ],
   "source": [
    "'''\n",
    "9. Write code to increase the dimension of the following array?\n",
    "[[1, 2, 3, 4]\n",
    "[5, 6, 7, 8],\n",
    "[9, 10, 11, 12]]\n",
    "'''\n",
    "import numpy as np\n",
    "\n",
    "# Given array\n",
    "arr = np.array([[1, 2, 3, 4],\n",
    "                [5, 6, 7, 8],\n",
    "                [9, 10, 11, 12]])\n",
    "\n",
    "# Increasing the dimension using np.newaxis\n",
    "new_arr = arr[:, :, np.newaxis]\n",
    "\n",
    "print(\"Original array:\")\n",
    "print(arr)\n",
    "print(\"\\nArray with increased dimension:\")\n",
    "print(new_arr)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "08adc0b9-3802-452d-bd66-1653fc760843",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "30635a5c-583f-44c8-9ad9-0924b46037df",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "50f7d9f0-3ae7-4527-803c-1d26e3ec4932",
   "metadata": {},
   "source": [
    "### 10. How to transpose the following array in NumPy?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "60ed1a90-c7aa-40cc-a238-973018bff57f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original array:\n",
      "[[ 1  2  3  4]\n",
      " [ 5  6  7  8]\n",
      " [ 9 10 11 12]]\n",
      "\n",
      "Transposed array:\n",
      "[[ 1  5  9]\n",
      " [ 2  6 10]\n",
      " [ 3  7 11]\n",
      " [ 4  8 12]]\n"
     ]
    }
   ],
   "source": [
    "'''\n",
    "10. How to transpose the following array in NumPy?\n",
    "[[1, 2, 3, 4]\n",
    "[5, 6, 7, 8],\n",
    "[9, 10, 11, 12]]\n",
    "'''\n",
    "import numpy as np\n",
    "\n",
    "# Given array\n",
    "arr = np.array([[1, 2, 3, 4],\n",
    "                [5, 6, 7, 8],\n",
    "                [9, 10, 11, 12]])\n",
    "\n",
    "# Transpose the array using numpy.transpose()\n",
    "transposed_arr = np.transpose(arr)\n",
    "\n",
    "# Alternatively, you can use arr.T attribute for transpose\n",
    "# transposed_arr = arr.T\n",
    "\n",
    "print(\"Original array:\")\n",
    "print(arr)\n",
    "print(\"\\nTransposed array:\")\n",
    "print(transposed_arr)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b6234ca2-313c-4e76-89e3-c94ccb3a3214",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4ce333de-127a-403a-8abc-1270c2b5c040",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "78e01761-0697-4c75-805b-1bd71ec96dbf",
   "metadata": {},
   "source": [
    "### 11. Consider the following matrix:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7c5c3782-eed7-410a-a8e9-7a8489330ed7",
   "metadata": {},
   "outputs": [],
   "source": [
    "'''\n",
    "11. Consider the following matrix:\n",
    "Matrix A2 [[1, 2, 3, 4] [5, 6, 7, 8],[9, 10, 11, 12]]\n",
    "Matrix B2 [[1, 2, 3, 4] [5, 6, 7, 8],[9, 10, 11, 12]]\n",
    "\n",
    "Perform the following operation using Python: \n",
    "1. Index wise multiplication\n",
    "2. Matrix multiplication\n",
    "3. Add both the matrics\n",
    "4. Subtract matrix B from A\n",
    "5. Divide Matrix B by A\n",
    "'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "e43db4a6-e0f0-4e81-a72f-1284d1d1f635",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1. Index wise multiplication:\n",
      "[[  1   4   9  16]\n",
      " [ 25  36  49  64]\n",
      " [ 81 100 121 144]]\n",
      "\n",
      "2. Matrix multiplication:\n",
      "[[ 30  70 110]\n",
      " [ 70 174 278]\n",
      " [110 278 446]]\n",
      "\n",
      "3. Addition of matrices:\n",
      "[[ 2  4  6  8]\n",
      " [10 12 14 16]\n",
      " [18 20 22 24]]\n",
      "\n",
      "4. Subtraction of matrix B from A:\n",
      "[[0 0 0 0]\n",
      " [0 0 0 0]\n",
      " [0 0 0 0]]\n",
      "\n",
      "5. Division of matrix B by A:\n",
      "[[1. 1. 1. 1.]\n",
      " [1. 1. 1. 1.]\n",
      " [1. 1. 1. 1.]]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "# Define matrices A and B\n",
    "A = np.array([[1, 2, 3, 4],\n",
    "              [5, 6, 7, 8],\n",
    "              [9, 10, 11, 12]])\n",
    "\n",
    "B = np.array([[1, 2, 3, 4],\n",
    "              [5, 6, 7, 8],\n",
    "              [9, 10, 11, 12]])\n",
    "\n",
    "# 1. Index wise multiplication\n",
    "index_wise_mul = A * B\n",
    "print(\"1. Index wise multiplication:\")\n",
    "print(index_wise_mul)\n",
    "\n",
    "# 2. Matrix multiplication\n",
    "matrix_mul = np.dot(A, B.T)  # Transpose B to match dimensions\n",
    "print(\"\\n2. Matrix multiplication:\")\n",
    "print(matrix_mul)\n",
    "\n",
    "# 3. Add both the matrices\n",
    "matrix_addition = A + B\n",
    "print(\"\\n3. Addition of matrices:\")\n",
    "print(matrix_addition)\n",
    "\n",
    "# 4. Subtract matrix B from A\n",
    "matrix_subtraction = A - B\n",
    "print(\"\\n4. Subtraction of matrix B from A:\")\n",
    "print(matrix_subtraction)\n",
    "\n",
    "# 5. Divide Matrix B by A\n",
    "matrix_division = np.divide(B, A)\n",
    "print(\"\\n5. Division of matrix B by A:\")\n",
    "print(matrix_division)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4912cb71-4f4a-423d-a63b-178411cba3fe",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5aef1fec-f467-4238-aad6-a18e15feaeec",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "f8087a1d-b5ac-4e5c-b0c2-3c349daae9e1",
   "metadata": {},
   "source": [
    "### 12. Which function in Numpy can be used to swap the byte order of an array?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "d1246138-13f6-4970-b621-8b7899a89a00",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original array: [1 2 3 4]\n",
      "Swapped array: [16777216 33554432 50331648 67108864]\n"
     ]
    }
   ],
   "source": [
    "'''\n",
    "byteswap() function to swap the byte order of an array. \n",
    "This function swaps the byte order of the elements in the array. \n",
    "'''\n",
    "import numpy as np\n",
    "\n",
    "# Create an array\n",
    "arr = np.array([1, 2, 3, 4], dtype=np.int32)\n",
    "\n",
    "# Swap the byte order\n",
    "arr_swapped = arr.byteswap()\n",
    "\n",
    "print(\"Original array:\", arr)\n",
    "print(\"Swapped array:\", arr_swapped)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0c50efdc-7d2a-487c-a48b-5ab685559bfc",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f1abd8a2-fe0a-4335-9f7e-2011a216ac4d",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "93042b53-1afb-4228-979e-607482d631e3",
   "metadata": {},
   "source": [
    "### 13. What is the significance of the np.linalg.inv function?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "0b61c1dd-e32e-447e-9c21-560998240c7d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Solution for x: [ 5.00000000e+00 -1.11022302e-16]\n"
     ]
    }
   ],
   "source": [
    "'''\n",
    "The np.linalg.inv function calculates the inverse of a matrix. It is significant in linear algebra for solving systems of linear equations.\n",
    "\n",
    "np.linalg.inv\n",
    "example- 2x + 3y = 10\n",
    "         4x - 5y = 20\n",
    "We can represent this system in matrix form as Ax = b, where:\n",
    "\n",
    "A = [[2, 3],\n",
    "     [4, -5]]\n",
    "\n",
    "x = [x, y]\n",
    "\n",
    "b = [10, 20]\n",
    "'''\n",
    "import numpy as np\n",
    "\n",
    "# Define matrix A and vector b\n",
    "A = np.array([[2, 3],\n",
    "              [4, -5]])\n",
    "\n",
    "b = np.array([10, 20])\n",
    "\n",
    "# Compute the inverse of matrix A\n",
    "A_inv = np.linalg.inv(A)\n",
    "\n",
    "# Solve for x by multiplying the inverse of A with b\n",
    "x = np.dot(A_inv, b)\n",
    "\n",
    "print(\"Solution for x:\", x)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0c239dcf-f979-44a3-b197-8e3180c19328",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5364dfab-6eba-4c4f-aea7-19fac3bfcc31",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "8e0fc20d-1fbe-4a41-921d-72d4f515d5bd",
   "metadata": {},
   "source": [
    "### 14. What does the np.reshape function do and how is it used?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "31957f14-f171-46a5-97d0-23679753fc09",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2]\n",
      " [3 4]\n",
      " [5 6]]\n"
     ]
    }
   ],
   "source": [
    "#to change the shape (dimensions) of an array without changing its data.\n",
    "# np.reshape is used to change the shape of an array. It returns a new array with the specified shape.\n",
    "import numpy as np\n",
    "\n",
    "# Create a 1D array\n",
    "arr = np.array([1, 2, 3, 4, 5, 6])\n",
    "\n",
    "# Reshape the array into a 2D array with 3 rows and 2 columns\n",
    "reshaped_arr = np.reshape(arr, (3, 2))\n",
    "\n",
    "print(reshaped_arr)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "59f38285-8275-4c7f-887c-57cfbb86b95a",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e8f9e2e3-32f7-4d0f-9198-f2241c9f0510",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "2a2a30a7-4358-4fff-acbd-898d0e64c5af",
   "metadata": {},
   "source": [
    "### 15. What is broadcasting in Numpy?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "0f4127fb-53f8-45bd-b015-a92e75e4bfad",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2 4 6]\n"
     ]
    }
   ],
   "source": [
    "''' \n",
    "Broadcasting is a feature in NumPy that allows for arithmetic operations to be performed on arrays of different shapes and sizes.\n",
    "When operating on arrays with different shapes, NumPy automatically \"broadcasts\" the smaller array across the larger array \n",
    "so that they have compatible shapes for the operation.'''\n",
    "\n",
    "import numpy as np\n",
    "\n",
    "# Create a 1D array\n",
    "x = np.array([1, 2, 3])\n",
    "\n",
    "# Create a scalar\n",
    "y = 2\n",
    "\n",
    "# Multiply the array by the scalar\n",
    "result = x * y\n",
    "\n",
    "print(result)  # Output: [2 4 6]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "409d3d65-52b3-412e-81bc-9215a4250645",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7e40ef00-bb01-4767-a363-773b69588d80",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.10.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}