Subjective Assignment - 7 - Numpy 3.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Assignment"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q1. Create two arrays of six elements. Write the NumPy program to\n",
    "count the number of instances of a value occurring in one array on\n",
    "the condition of another array.\n",
    "\n",
    "    Sample OutputOriginal arrays-\n",
    "    [ 10 -10 10 -10 -10 10]\n",
    "    [0.85 0.45 0.9 0.8 0.12 0.6 ]\n",
    "    Number of instances of a value occurring in one array on the condition of another\n",
    "    array: 3\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original arrays:\n",
      "[ 10 -10  10 -10 -10  10]\n",
      "[0.85 0.45 0.9  0.8  0.12 0.6 ]\n",
      "\n",
      "Number of instances of a value occurring in one array on the condition of another array:\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "x = np.array([10,-10,10,-10,-10,10])\n",
    "y = np.array([.85,.45,.9,.8,.12,.6])\n",
    "print(\"Original arrays:\")\n",
    "print(x)\n",
    "print(y)\n",
    "result = np.sum((x == 10) & (y > .5))\n",
    "print(\"\\nNumber of instances of a value occurring in one array on the condition of another array:\")\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q2. Write the NumPy program to convert a Python dictionary to a\n",
    "Numpy ndarray ?\n",
    "    \n",
    "    Original dictionary-\n",
    "    {'column0': {'a': 1, 'b': 0.0, 'c': 0.0, 'd': 2.0},\n",
    "    'column1': {'a': 3.0, 'b': 1, 'c': 0.0, 'd': -1.0},\n",
    "    'column2': {'a': 4, 'b': 1, 'c': 5.0, 'd': -1.0},\n",
    "    'column3': {'a': 3.0, 'b': -1.0, 'c': -1.0, 'd': -1.0}}\n",
    "    Type: <class 'dict'>\n",
    "    ndarray-\n",
    "    [[ 1. 0. 0. 2.]\n",
    "    [ 3. 1. 0. -1.]\n",
    "    [ 4. 1. 5. -1.]\n",
    "    [ 3. -1. -1. -1.]]\n",
    "    Type: <class 'numpy.ndarray'>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Original dictionary:\n",
      "{'column0': {'a': 1, 'b': 0.0, 'c': 0.0, 'd': 2.0}, 'column1': {'a': 3.0, 'b': 1, 'c': 0.0, 'd': -1.0}, 'column2': {'a': 4, 'b': 1, 'c': 5.0, 'd': -1.0}, 'column3': {'a': 3.0, 'b': -1.0, 'c': -1.0, 'd': -1.0}}\n",
      "Type:  <class 'dict'>\n",
      "\n",
      "ndarray:\n",
      "[[ 1.  0.  0.  2.]\n",
      " [ 3.  1.  0. -1.]\n",
      " [ 4.  1.  5. -1.]\n",
      " [ 3. -1. -1. -1.]]\n",
      "Type:  <class 'numpy.ndarray'>\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "from ast import literal_eval\n",
    "udict = \"\"\"{\"column0\":{\"a\":1,\"b\":0.0,\"c\":0.0,\"d\":2.0},\n",
    "   \"column1\":{\"a\":3.0,\"b\":1,\"c\":0.0,\"d\":-1.0},\n",
    "   \"column2\":{\"a\":4,\"b\":1,\"c\":5.0,\"d\":-1.0},\n",
    "   \"column3\":{\"a\":3.0,\"b\":-1.0,\"c\":-1.0,\"d\":-1.0}\n",
    "  }\"\"\"\n",
    "t = literal_eval(udict)\n",
    "print(\"\\nOriginal dictionary:\")\n",
    "print(t)\n",
    "print(\"Type: \",type(t))\n",
    "result_nparra = np.array([[v[j] for j in ['a', 'b', 'c', 'd']] for k, v in t.items()])\n",
    "print(\"\\nndarray:\")\n",
    "print(result_nparra)\n",
    "print(\"Type: \",type(result_nparra))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q3. Write the Numpy program to find and store the non-zero unique\n",
    "rows in an array after comparing each row with other row in the\n",
    "given matrix?\n",
    " \n",
    "    Original array-\n",
    "    [[ 1 1 0]\n",
    "    [ 0 0 0]\n",
    "    [ 0 2 3]\n",
    "    [ 0 0 0]\n",
    "    [ 0 -1 1]\n",
    "    [ 0 0 0]]\n",
    "    Non-zero unique rows-\n",
    "    [[ 1 1 0]\n",
    "    [ 0 2 3]\n",
    "    [ 0 -1 1]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original array-\n",
      " [[ 1  1  0]\n",
      " [ 0  2  3]\n",
      " [ 0 -1  1]]\n",
      "Non-zero unique rows-\n",
      " [[ 1  1  0]\n",
      " [ 0  2  3]\n",
      " [ 0 -1  1]]\n"
     ]
    }
   ],
   "source": [
    "original = np.array([[1, 1, 0], [0, 0, 0], [0, 2, 3], [0, 0, 0], [0, -1, 1], [0, 0, 0]])\n",
    "l = []\n",
    "for row in original:\n",
    "    if np.all(row == 0):\n",
    "        continue\n",
    "    else:\n",
    "        l.append(row)\n",
    "l = np.array(l)\n",
    "print('Original array-\\n', l)\n",
    "print('Non-zero unique rows-\\n', l)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q4. Write the NumPy program to multiply the matrix by another matrix\n",
    "of complex numbers and create a new matrix of complex\n",
    "numbers?\n",
    "\n",
    "    Sample outputFirst array-\n",
    "    [ 1.+2.j 3.+4.j]\n",
    "    Second array-\n",
    "    [ 5.+6.j 7.+8.j]\n",
    "    Product of above two arrays-\n",
    "    (70-8j)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "First array-\n",
      " [1.+2.j 3.+4.j]\n",
      "Second array-\n",
      " [5.+6.j 7.+8.j]\n",
      "Product of above two arrays-\n",
      " (70-8j)\n"
     ]
    }
   ],
   "source": [
    "n1 = np.array([ 1.+2.j, 3.+4.j])\n",
    "n2 = np.array([ 5.+6.j, 7.+8.j])\n",
    "print('First array-\\n', n1)\n",
    "print('Second array-\\n', n2)\n",
    "print('Product of above two arrays-\\n', np.vdot(n1, n2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q5. Write a NumPy program to generate the matrix product of two\n",
    "Arrays?\n",
    "\n",
    "    Sample OutputMatrices and vectors.\n",
    "    x-\n",
    "    [[1, 0], [1, 1]]\n",
    "    y-\n",
    "    [[3, 1], [2, 2]]\n",
    "    Matrix product of above two arrays-\n",
    "    [[3 1]\n",
    "    [5 3]]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Matrices and vectors.\n",
      "x:\n",
      "[[1, 0], [1, 1]]\n",
      "y:\n",
      "[[3, 1], [2, 2]]\n",
      "Matrix product of above two arrays:\n",
      "[[3 1]\n",
      " [5 3]]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "x = [[1, 0], [1, 1]]\n",
    "y = [[3, 1], [2, 2]]\n",
    "print(\"Matrices and vectors.\")\n",
    "print(\"x:\")\n",
    "print(x)\n",
    "print(\"y:\")\n",
    "print(y)\n",
    "print(\"Matrix product of above two arrays:\")\n",
    "print(np.matmul(x, y))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q6. Write the NumPy program to find roots of the following\n",
    "Polynomials?\n",
    "\n",
    "    a) (x\n",
    "    2\n",
    "    - 4x + 7)\n",
    "    b) x4\n",
    "    - 11x3 + 9x2 + 11x ? 10\n",
    "    Sample outputRoots of the first polynomial-\n",
    "    [ 1. 1.]\n",
    "    Roots of the second polynomial-\n",
    "    [ 11.04461946+0.j -0.87114210+0.j 0.91326132+0.4531004j\n",
    "    0.91326132-0.4531004j ]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2.+1.73205081j 2.-1.73205081j]\n",
      "[ 9.97739366+0.j          1.9206355 +0.j         -0.44901458+0.56588568j\n",
      " -0.44901458-0.56588568j]\n"
     ]
    }
   ],
   "source": [
    "print(np.roots([1, -4, 7]))\n",
    "print(np.roots([1, -11, 9, 11, 10]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q7. Write the NumPy program to calculate inverse of sine, cosine,\n",
    "and inverse tangent for all elements in a given array?\n",
    "\n",
    "    Sample outputInverse sine- [-1.57079633 0. 1.57079633]\n",
    "    Inverse cosine- [3.14159265 1.57079633 0. ]\n",
    "    Inverse tangent- [-0.78539816 0. 0.78539816]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Inverse sine [1.57079633 0.30469265]\n",
      "Inverse cosine [0.         1.26610367]\n",
      "Inverse tangent [0.78539816 0.29145679]\n"
     ]
    }
   ],
   "source": [
    "array = [1, 0.3]\n",
    "print('Inverse sine', np.arcsin(array))\n",
    "print('Inverse cosine', np.arccos(array))\n",
    "print('Inverse tangent', np.arctan(array))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q8. Write the NumPy program to calculate the difference between in\n",
    "neighbouring elements, element-wise of a given array?\n",
    "\n",
    "    Sample outputOriginal array-\n",
    "    [1 3 5 7 0]\n",
    "    Difference between neighbouring elements, element-wise of the said array-\n",
    "    [ 2 2 2 -7]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original array-\n",
      " [1, 3, 5, 7, 0]\n",
      "Difference between neighbouring elements, element-wise of the said array-\n",
      " [2, 2, 2, -7]\n"
     ]
    }
   ],
   "source": [
    "a = [1, 3, 5, 7, 0]\n",
    "l = []\n",
    "for i in range(len(a) - 1):\n",
    "    l.append(a[i+1] - a[i])\n",
    "print('Original array-\\n', a)\n",
    "print('Difference between neighbouring elements, element-wise of the said array-\\n', l)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q9. Write the Python program to find the maximum and the minimum\n",
    "value of a given flattened array?\n",
    "\n",
    "    Expected OutputOriginal flattened array-\n",
    "    [[0 1]\n",
    "    [2 3]]\n",
    "    Maximum value of the above flattened array3\n",
    "    Minimum value of the above flattened array0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Maximum value of the above flattened array  3\n",
      "Minimum value of the above flattened array 0\n"
     ]
    }
   ],
   "source": [
    "a = np.array([[0, 1], [2, 3]])\n",
    "print('Maximum value of the above flattened array ', np.argmax(a.ravel()))\n",
    "print('Minimum value of the above flattened array', np.argmin(a.ravel()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q10. Write the NumPy program to calculate the difference between in\n",
    "the maximum and the minimum values of a given array along the\n",
    "second axis ?\n",
    "\n",
    "    Expected OutputOriginal array-\n",
    "    [[ 0 1 2 3 4 5]\n",
    "    [ 6 7 8 9 10 11]]\n",
    "    Difference between the maximum and the minimum values of the said array-\n",
    "    [5 5]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original array-\n",
      " [[ 0  1  2  3  4  5]\n",
      " [ 6  7  8  9 10 11]]\n",
      "Difference between the maximum and the minimum values of the said array-\n",
      " [5, 5]\n"
     ]
    }
   ],
   "source": [
    "a = np.reshape(np.arange(12), (2, -1))\n",
    "l = []\n",
    "for row in a:\n",
    "    l.append(np.max(row) - np.min(row))\n",
    "print('Original array-\\n', a)\n",
    "print('Difference between the maximum and the minimum values of the said array-\\n', l)    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q11. Write the NumPy program to compute the weighted of the given\n",
    "array ?\n",
    "\n",
    "    Sample OutputOriginal array-\n",
    "    [0 1 2 3 4]\n",
    "    Weighted average of the said array2.6666666666666665"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original flattened array:\n",
      "[[0 1 2]\n",
      " [3 4 5]\n",
      " [6 7 8]]\n",
      "Weighted average along the specified axis of the above flattened array:\n",
      "[1.2 4.2 7.2]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "a = np.arange(9).reshape((3,3))\n",
    "print(\"Original flattened array:\")\n",
    "print(a)\n",
    "print(\"Weighted average along the specified axis of the above flattened array:\")\n",
    "print(np.average(a, axis=1, weights=[1./4, 2./4, 2./4]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q12. Write the NumPy program to compute the mean, standard\n",
    "deviation, and the variance of a given array along the second\n",
    "axis?\n",
    "\n",
    "    Sample outputOriginal array-\n",
    "    [0 1 2 3 4 5]\n",
    "    Mean- 2.5\n",
    "    std- 1\n",
    "    variance- 2.9166666666666665"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 1 2 3 4 5]\n",
      "Mean- 2.5\n",
      "std- 1.707825127659933\n",
      "var- 2.9166666666666665\n"
     ]
    }
   ],
   "source": [
    "o = np.array(np.arange(6))\n",
    "print(o)\n",
    "print('Mean-', np.mean(o))\n",
    "print('std-', np.std(o))\n",
    "print('var-', np.var(o))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q13. Write the Numpy program to compute the covariance matrix of the\n",
    "two given arrays?\n",
    "    \n",
    "    Sample OutputOriginal array1-\n",
    "    [0 1 2]\n",
    "    Original array1-\n",
    "    [2 1 0]\n",
    "    Covariance matrix of the said arrays-\n",
    "    [[ 1. -1.]\n",
    "    [-1. 1.]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original array1-\n",
      " [0, 1, 2]\n",
      "Original array2-\n",
      " [2, 1, 0]\n",
      "Covariance matrix of the said arrays-\n",
      " [[ 1. -1.]\n",
      " [-1.  1.]]\n",
      "[[ 1. -1.]\n",
      " [-1.  1.]]\n"
     ]
    }
   ],
   "source": [
    "a = [0, 1, 2]\n",
    "b = [2, 1, 0]\n",
    "c = np.cov(a, b)\n",
    "print('Original array1-\\n', a)\n",
    "print('Original array2-\\n', b)\n",
    "print('Covariance matrix of the said arrays-\\n', c)\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q14. Write a NumPy program to compute the cross-correlation of two\n",
    "given arrays ?\n",
    "\n",
    "    Sample OutputOriginal array1-\n",
    "    [0 1 3]\n",
    "    Original array1-\n",
    "    [2 4 5]\n",
    "    Cross-correlation of the said arrays-\n",
    "    [ [ 2.33333333 2.16666667 ]\n",
    "     [ 2.16666667 2.33333333 ] ]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original array1-\n",
      " [0 1 3]\n",
      "Original array2-\n",
      " [2 4 5]\n",
      "Cross-correlation of the said arrays-\n",
      " [[2.33333333 2.16666667]\n",
      " [2.16666667 2.33333333]]\n"
     ]
    }
   ],
   "source": [
    "a = np.array([0, 1, 3])\n",
    "b = np.array([2, 4, 5])\n",
    "c = np.cov(a, b)\n",
    "print('Original array1-\\n', a)\n",
    "print('Original array2-\\n', b)\n",
    "print('Cross-correlation of the said arrays-\\n', c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q15. Write the NumPy program to compute Pearson product-moment\n",
    "correlation coefficients of two given arrays?\n",
    "\n",
    "    Sample OutputOriginal array1-\n",
    "    [0 1 3]\n",
    "    Original array1-\n",
    "    [2 4 5]\n",
    "    Pearson product-moment correlation coefficients of the said arrays-\n",
    "    [[1. 0.92857143]\n",
    "    [0.92857143 1. ]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original array1:\n",
      " [0 1 3]\n",
      "Original array1:\n",
      " [2 4 5]\n",
      "Pearson product-moment correlation coefficients of the said arrays:\n",
      " [[1.         0.92857143]\n",
      " [0.92857143 1.        ]]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "x = np.array([0, 1, 3])\n",
    "y = np.array([2, 4, 5])\n",
    "print(\"Original array1:\\n\", x)\n",
    "print(\"Original array1:\\n\", y)\n",
    "print(\"Pearson product-moment correlation coefficients of the said arrays:\\n\",np.corrcoef(x, y))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q16. Write the python program to count the number of occurrences of\n",
    "each value in a given array of non-negative integers?\n",
    " \n",
    "Note: bincount() Function- It count the occurrence of each value in an array of the\n",
    "non- negative integers in the range of the array between the minimum and maximum values\n",
    "including the values that did not occur.\n",
    "\n",
    "    Sample OutputOriginal array-\n",
    "    [0, 1, 6, 1, 4, 1, 2, 2, 7]\n",
    "    Number of occurrences of each value in array-\n",
    "    [1 3 2 0 1 0 1 1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original array1:\n",
      " [0, 1, 6, 1, 4, 1, 2, 2, 7]\n",
      "Number of occurrences of each value in array-\n",
      " [1 3 2 0 1 0 1 1]\n"
     ]
    }
   ],
   "source": [
    "a = [0, 1, 6, 1, 4, 1, 2, 2, 7]\n",
    "print(\"Original array1:\\n\", a)\n",
    "print(\"Number of occurrences of each value in array-\\n\",np.bincount(a))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q17. Write a Numpy program to compute the histogram of nums\n",
    "against the bins?\n",
    "\n",
    "    Sample Outputnums- [0.5 0.7 1. 1.2 1.3 2.1]\n",
    "    P a g e 29 | 44\n",
    "    bins- [0 1 2 3]\n",
    "    Result- (array([2, 3, 1], dtype=int64), array([0, 1, 2, 3]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "nums:  [0.5 0.7 1.  1.2 1.3 2.1]\n",
      "bins:  [0 1 2 3]\n",
      "Result: (array([2, 3, 1]), array([0, 1, 2, 3]))\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "nums = np.array([0.5, 0.7, 1.0, 1.2, 1.3, 2.1])\n",
    "bins = np.array([0, 1, 2, 3])\n",
    "print(\"nums: \",nums)\n",
    "print(\"bins: \",bins)\n",
    "print(\"Result:\", np.histogram(nums, bins))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Great Job!"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.7.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}