1.7numpy_lab7AMF.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "769bb3fc-35a3-4bda-96f9-f1c91fba7129",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "#1. Import the NUMPY package under the name np.\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "8396e994-245f-4375-aa80-8b28f66d048c",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "blas_armpl_info:\n",
      "  NOT AVAILABLE\n",
      "blas_mkl_info:\n",
      "    libraries = ['mkl_rt']\n",
      "    library_dirs = ['C:/Users/Aida/anaconda3\\\\Library\\\\lib']\n",
      "    define_macros = [('SCIPY_MKL_H', None), ('HAVE_CBLAS', None)]\n",
      "    include_dirs = ['C:/Users/Aida/anaconda3\\\\Library\\\\include']\n",
      "blas_opt_info:\n",
      "    libraries = ['mkl_rt']\n",
      "    library_dirs = ['C:/Users/Aida/anaconda3\\\\Library\\\\lib']\n",
      "    define_macros = [('SCIPY_MKL_H', None), ('HAVE_CBLAS', None)]\n",
      "    include_dirs = ['C:/Users/Aida/anaconda3\\\\Library\\\\include']\n",
      "lapack_armpl_info:\n",
      "  NOT AVAILABLE\n",
      "lapack_mkl_info:\n",
      "    libraries = ['mkl_rt']\n",
      "    library_dirs = ['C:/Users/Aida/anaconda3\\\\Library\\\\lib']\n",
      "    define_macros = [('SCIPY_MKL_H', None), ('HAVE_CBLAS', None)]\n",
      "    include_dirs = ['C:/Users/Aida/anaconda3\\\\Library\\\\include']\n",
      "lapack_opt_info:\n",
      "    libraries = ['mkl_rt']\n",
      "    library_dirs = ['C:/Users/Aida/anaconda3\\\\Library\\\\lib']\n",
      "    define_macros = [('SCIPY_MKL_H', None), ('HAVE_CBLAS', None)]\n",
      "    include_dirs = ['C:/Users/Aida/anaconda3\\\\Library\\\\include']\n",
      "Supported SIMD extensions in this NumPy install:\n",
      "    baseline = SSE,SSE2,SSE3\n",
      "    found = SSSE3,SSE41,POPCNT,SSE42,AVX,F16C,FMA3,AVX2\n",
      "    not found = AVX512F,AVX512CD,AVX512_SKX,AVX512_CLX,AVX512_CNL,AVX512_ICL\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "#2. Print the NUMPY version and the configuration.\n",
    "print(np.show_config())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "34dd4310-191f-4669-a89b-11eed7133a8e",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[5 1 1 5 1]\n",
      "  [5 4 3 4 1]\n",
      "  [5 5 4 0 2]]\n",
      "\n",
      " [[5 0 1 5 2]\n",
      "  [2 5 3 3 1]\n",
      "  [1 2 5 4 2]]]\n"
     ]
    }
   ],
   "source": [
    "#3. Generate a 2x3x5 3-dimensional array with random values. Assign the array to variable \"a\"\n",
    "# Challenge: there are at least three easy ways that use numpy to generate random arrays. How many ways can you find?\n",
    "\n",
    "a=np.random.randint(6,size=(2,3,5))\n",
    "\n",
    "#4. Print a.\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "10f5b160-9e0f-41af-8dae-be1c627bb5bb",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "#5. Create a 5x2x3 3-dimensional array with all values equaling 1.\n",
    "#Assign the array to variable \"b\"\n",
    "\n",
    "b=np.random.randint(2,size=(5,2,3)) #now we have a file with numbers from 0 to 1 and 5 dimensions of 2 rows and 3 columns each"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "f202d0b8-4fe8-426c-80f8-3c838818f672",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[0 1 1]\n",
      "  [0 1 0]]\n",
      "\n",
      " [[0 1 1]\n",
      "  [1 1 1]]\n",
      "\n",
      " [[1 0 1]\n",
      "  [0 0 0]]\n",
      "\n",
      " [[1 1 1]\n",
      "  [0 0 0]]\n",
      "\n",
      " [[0 1 0]\n",
      "  [1 0 0]]]\n"
     ]
    }
   ],
   "source": [
    "#6. Print b.\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "ee40ed02-6914-45eb-be6c-121926e9ec2e",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "5\n",
      "both arrays have different sizes\n"
     ]
    }
   ],
   "source": [
    "#7. Do a and b have the same size? How do you prove that in Python code?\n",
    "def lenx(var):\n",
    "    x=len(var)\n",
    "    return x\n",
    "\n",
    "print(lenx(a))\n",
    "print(lenx(b))\n",
    "\n",
    "if lenx(a)==lenx(b):\n",
    "    print(\"both arrays have the same size\")\n",
    "else:\n",
    "    print(\"both arrays have different sizes\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "6906324e-7ec4-4856-8c6b-e07ecc168d1d",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "operands could not be broadcast together with shapes (2,3,5) (5,2,3) ",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[8], line 2\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[38;5;66;03m#8. Are you able to add a and b? Why or why not?\u001b[39;00m\n\u001b[1;32m----> 2\u001b[0m c \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39madd(a,b)\n",
      "\u001b[1;31mValueError\u001b[0m: operands could not be broadcast together with shapes (2,3,5) (5,2,3) "
     ]
    }
   ],
   "source": [
    "#8. Are you able to add a and b? Why or why not?\n",
    "c = np.add(a,b) #nope, I cannot sum them because the number of dimensions is different, the length is different, so I cannot match them\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "4ff5ca83-5649-427f-9158-759b200e9e37",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(2, 3, 5)\n"
     ]
    }
   ],
   "source": [
    "#9. Transpose b so that it has the same structure of a (i.e. become a 2x3x5 array). Assign the transposed array to varialbe \"c\".\n",
    "c=np.transpose(b,(1,2,0)) #we are specifying that the order of transposition has to be 1,2,0 (element 1 in b has to be now element 0 in c and so on)\n",
    "print(np.shape(c))\n",
    "#now we get an array which is formed, like b, by numbers 0 and 1, but transposed: 2 dimensions of 3 rows and 5 columns (like a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "18f8931c-a45b-45fc-a0d8-49ea9c0bf7a4",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[5 1 1 5 1]\n",
      "  [5 4 3 4 1]\n",
      "  [5 5 4 0 2]]\n",
      "\n",
      " [[5 0 1 5 2]\n",
      "  [2 5 3 3 1]\n",
      "  [1 2 5 4 2]]]\n",
      "[[[5 1 2 6 1]\n",
      "  [6 5 3 5 2]\n",
      "  [6 6 5 1 2]]\n",
      "\n",
      " [[5 1 1 5 3]\n",
      "  [3 6 3 3 1]\n",
      "  [1 3 5 4 2]]]\n"
     ]
    }
   ],
   "source": [
    "#10. Try to add a and c. Now it should work. Assign the sum to varialbe \"d\". But why does it work now?\n",
    "d=c+a #now we can add them as they have the same shapes!\n",
    "d\n",
    "\n",
    "#11. Print a and d. Notice the difference and relation of the two array in terms of the values? Explain.\n",
    "print(a)\n",
    "print(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "43ec604a-a484-4193-9d82-482235876342",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "#12. Multiply a and c. Assign the result to e.\n",
    "e=a*c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "b805d3bf-fc97-40d8-9fc6-a162291c1c94",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Equality Comparison Result:\n",
      "[[[False False  True  True False]\n",
      "  [ True  True False  True  True]\n",
      "  [ True  True  True  True False]]\n",
      "\n",
      " [[False  True False False  True]\n",
      "  [ True  True False False False]\n",
      "  [False  True False False False]]]\n"
     ]
    }
   ],
   "source": [
    "#13. Does e equal to a? Why or why not?\n",
    "equal_result = (e == a)\n",
    "print(\"Equality Comparison Result:\")\n",
    "print(equal_result) #in the first row of the first dimension, the first 3 values are equal between arrays, that's why equal_result array returns \"True\". The other two are false because they are different between arrays (3 vs.0 and 4 vs.0)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "026569a1-0b75-45fd-b502-db3cabb7c0c2",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "maximum value in d array is 6; lmin value is 1; the average is 3.4\n"
     ]
    }
   ],
   "source": [
    "#14. Identify the max, min, and mean values in d. Assign those values to variables \"d_max\", \"d_min\", and \"d_mean\"\n",
    "d_max=np.max(d)\n",
    "d_min=np.min(d)\n",
    "d_mean=np.mean(d)\n",
    "\n",
    "\n",
    "print (f\"maximum value in d array is {d_max}; lmin value is {d_min}; the average is {d_mean}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "13dc21ce-c13e-4df9-a820-d08f104662be",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[9.11085261e-312, 9.11084421e-312, 0.00000000e+000,\n",
       "         0.00000000e+000, 1.00000000e+000],\n",
       "        [1.16097020e-028, 1.26104862e-076, 2.17051576e-028,\n",
       "         5.14869415e-062, 1.04917183e-153],\n",
       "        [5.23081515e-143, 2.12713048e+160, 1.77393635e+160,\n",
       "         1.12895612e-042, 8.67783877e-067]],\n",
       "\n",
       "       [[5.43786184e-143, 3.59751658e+252, 1.46901661e+179,\n",
       "         8.37404147e+242, 4.31999013e-096],\n",
       "        [4.82337723e+228, 1.81786403e+185, 1.42143332e+160,\n",
       "         4.21989903e-090, 9.59367231e-071],\n",
       "        [1.12983478e-042, 5.04621343e+180, 1.94918963e-153,\n",
       "         1.14484251e+243, 2.59903827e-144]]])"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#15. Now we want to label the values in d. First create an empty array \"f\" with the same shape (i.e. 2x3x5) as d using `np.empty`.\n",
    "f=np.empty((2,3,5))\n",
    "f\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1d12cd03-f16e-46c6-ae1d-1e5c8cac03e6",
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "#16. Populate the values in f. For each value in d, if it's larger than d_min but smaller than d_mean, assign 25 to the corresponding value in f.\n",
    "If a value in d is larger than d_mean but smaller than d_max, assign 75 to the corresponding value in f.\n",
    "If a value equals to d_mean, assign 50 to the corresponding value in f.\n",
    "Assign 0 to the corresponding value(s) in f for d_min in d.\n",
    "Assign 100 to the corresponding value(s) in f for d_max in d.\n",
    "In the end, f should have only the following values: 0, 25, 50, 75, and 100.\n",
    "Note: you don't have to use Numpy in this question.\n",
    "\"\"\"\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "1f80aaba-3bd3-40db-a342-327a46b9a2cf",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "for i in range(2):\n",
    "    for j in range(3):\n",
    "        for k in range(5):\n",
    "            if d[i][j][k] > d_min and d[i][j][k] < d_mean:\n",
    "                f[i][j][k] = 25\n",
    "            elif d[i][j][k] > d_mean and d[i][j][k] < d_max:\n",
    "                f[i][j][k] = 75\n",
    "            elif d[i][j][k] == d_mean:\n",
    "                f[i][j][k] = 50\n",
    "            elif d[i][j][k] == d_min:\n",
    "                f[i][j][k] =0\n",
    "            elif d[i][j][k] == d_max:\n",
    "                f[i][j][k] =100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "eb4f00a4-0ce7-4092-9ede-4175a480e9e8",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n",
      "1\n",
      "3.4\n"
     ]
    }
   ],
   "source": [
    "print(d_max)\n",
    "print(d_min)\n",
    "print(d_mean)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "988e327f-d697-4752-9259-b810bf87417d",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[ 75.,   0.,  25., 100.,   0.],\n",
       "        [100.,  75.,  25.,  75.,  25.],\n",
       "        [100., 100.,  75.,   0.,  25.]],\n",
       "\n",
       "       [[ 75.,   0.,   0.,  75.,  25.],\n",
       "        [ 25., 100.,  25.,  25.,   0.],\n",
       "        [  0.,  25.,  75.,  75.,  25.]]])"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "\"\"\"\n",
    "#17. Print d and f. Do you have your expected f?\n",
    "For instance, if your d is:\n",
    "array([[[1.85836099, 1.67064465, 1.62576044, 1.40243961, 1.88454931],\n",
    "        [1.75354326, 1.69403643, 1.36729252, 1.61415071, 1.12104981],\n",
    "        [1.72201435, 1.1862918 , 1.87078449, 1.7726778 , 1.88180042]],\n",
    "\n",
    "       [[1.44747908, 1.31673383, 1.02000951, 1.52218947, 1.97066381],\n",
    "        [1.79129243, 1.74983003, 1.96028037, 1.85166831, 1.65450881],\n",
    "        [1.18068344, 1.9587381 , 1.00656599, 1.93402165, 1.73514584]]])\n",
    "\n",
    "Your f should be:\n",
    "array([[[ 75.,  75.,  75.,  25.,  75.],\n",
    "        [ 75.,  75.,  25.,  25.,  25.],\n",
    "        [ 75.,  25.,  75.,  75.,  75.]],\n",
    "\n",
    "       [[ 25.,  25.,  25.,  25., 100.],\n",
    "        [ 75.,  75.,  75.,  75.,  75.],\n",
    "        [ 25.,  75.,   0.,  75.,  75.]]])\n",
    "\"\"\"\n",
    "f"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "d14f96f3-e0ab-4b58-8b56-a10c02784523",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[5, 1, 2, 6, 1],\n",
       "        [6, 5, 3, 5, 2],\n",
       "        [6, 6, 5, 1, 2]],\n",
       "\n",
       "       [[5, 1, 1, 5, 3],\n",
       "        [3, 6, 3, 3, 1],\n",
       "        [1, 3, 5, 4, 2]]])"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "02a4f2a6-a02b-44f0-a714-3990ef6972a5",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'\\n#18. Bonus question: instead of using numbers (i.e. 0, 25, 50, 75, and 100), how to use string values \\n(\"A\", \"B\", \"C\", \"D\", and \"E\") to label the array elements? You are expecting the result to be:\\narray([[[ \\'D\\',  \\'D\\',  \\'D\\',  \\'B\\',  \\'D\\'],\\n        [ \\'D\\',  \\'D\\',  \\'B\\',  \\'B\\',  \\'B\\'],\\n        [ \\'D\\',  \\'B\\',  \\'D\\',  \\'D\\',  \\'D\\']],\\n\\n       [[ \\'B\\',  \\'B\\',  \\'B\\',  \\'B\\',  \\'E\\'],\\n        [ \\'D\\',  \\'D\\',  \\'D\\',  \\'D\\',  \\'D\\'],\\n        [ \\'B\\',  \\'D\\',   \\'A\\',  \\'D\\', \\'D\\']]])\\nAgain, you don\\'t need Numpy in this question.\\n'"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"\"\"\n",
    "#18. Bonus question: instead of using numbers (i.e. 0, 25, 50, 75, and 100), how to use string values \n",
    "(\"A\", \"B\", \"C\", \"D\", and \"E\") to label the array elements? You are expecting the result to be:\n",
    "array([[[ 'D',  'D',  'D',  'B',  'D'],\n",
    "        [ 'D',  'D',  'B',  'B',  'B'],\n",
    "        [ 'D',  'B',  'D',  'D',  'D']],\n",
    "\n",
    "       [[ 'B',  'B',  'B',  'B',  'E'],\n",
    "        [ 'D',  'D',  'D',  'D',  'D'],\n",
    "        [ 'B',  'D',   'A',  'D', 'D']]])\n",
    "Again, you don't need Numpy in this question.\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "4fda2d5a-c541-4ddb-a2fd-8f5e440f6e34",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[['' '' '' '' '']\n",
      "  ['' '' '' '' '']\n",
      "  ['' '' '' '' '']]\n",
      "\n",
      " [['' '' '' '' '']\n",
      "  ['' '' '' '' '']\n",
      "  ['' '' '' '' '']]]\n",
      "[[['B' 'D' 'A' 'E' 'D']\n",
      "  ['E' 'B' 'A' 'B' 'A']\n",
      "  ['E' 'E' 'B' 'D' 'A']]\n",
      "\n",
      " [['B' 'D' 'D' 'B' 'A']\n",
      "  ['A' 'E' 'A' 'A' 'D']\n",
      "  ['D' 'A' 'B' 'B' 'A']]]\n"
     ]
    }
   ],
   "source": [
    "empty_str=np.empty((2,3,5), dtype=\"str\")\n",
    "print(empty_str) #to check it is empty\n",
    "\n",
    "for i in range(2):\n",
    "    for j in range(3):\n",
    "        for k in range(5):\n",
    "            if d[i][j][k] > d_min and d[i][j][k] < d_mean:\n",
    "                value = \"A\"\n",
    "                empty_str[i][j][k] = value\n",
    "            elif d[i][j][k] > d_mean and d[i][j][k] < d_max:\n",
    "                value = \"B\"\n",
    "                empty_str[i][j][k] = value\n",
    "            elif d[i][j][k] == d_mean:\n",
    "                value = \"C\"\n",
    "                empty_str[i][j][k] = value\n",
    "            elif d[i][j][k] == d_min:\n",
    "                value = \"D\"\n",
    "                empty_str[i][j][k] = value\n",
    "            elif d[i][j][k] == d_max:\n",
    "                value = \"E\"\n",
    "                empty_str[i][j][k] = value\n",
    "\n",
    "print(empty_str)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "eb4cde24-d9e6-42ef-a47a-51922c1d0f17",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[5, 1, 2, 6, 1],\n",
       "        [6, 5, 3, 5, 2],\n",
       "        [6, 6, 5, 1, 2]],\n",
       "\n",
       "       [[5, 1, 1, 5, 3],\n",
       "        [3, 6, 3, 3, 1],\n",
       "        [1, 3, 5, 4, 2]]])"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "17f65013-3eca-4357-b875-5b79e38a00e6",
   "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.11.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}