advance numpy.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3721e909-c8b2-4435-84a0-36a58e7c3b38",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0c47ce98-6aae-4e49-a3e5-5de679801ac5",
   "metadata": {},
   "outputs": [],
   "source": [
    "Advanced array creation with specific dtypes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "2d802820-653d-4586-9579-ae5eae07bbba",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Complex array: [1.+2.j 3.+4.j]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "complex_array = np.array([1+2j, 3+4j], dtype=np.complex128)\n",
    "print(\"Complex array:\", complex_array)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3749ecff-66d1-4bc4-97d0-076ed8321840",
   "metadata": {},
   "outputs": [],
   "source": [
    "Memory layout optimization (order parameter)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "1944eec7-8237-446d-847c-bd5ce3f77839",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "C-order array: [[1 2 3]\n",
      " [4 5 6]]\n",
      "F-order array: [[1 2 3]\n",
      " [4 5 6]]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "c_order_array = np.array([[1, 2, 3], [4, 5, 6]], order='C')\n",
    "f_order_array = np.array([[1, 2, 3], [4, 5, 6]], order='F')\n",
    "print(\"C-order array:\", c_order_array)\n",
    "print(\"F-order array:\", f_order_array)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dd5e47cd-c0d1-498d-b9dc-ee862a78c5f1",
   "metadata": {},
   "outputs": [],
   "source": [
    "Memory views and broadcasting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "48fb4797-819b-429f-866a-381c51d160d1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Memory view and broadcasting array:\n",
      " [[[0 1 2]]\n",
      "\n",
      " [[3 4 5]]]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "x = np.arange(6).reshape(2, 3)\n",
    "y = x[:, np.newaxis, :]\n",
    "print(\"Memory view and broadcasting array:\\n\", y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "90597b46-1860-410b-9c3f-5c71c8c313f3",
   "metadata": {},
   "outputs": [],
   "source": [
    "Manipulating the shape and size of arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "ba7e2c73-5028-4ec0-9ddf-ccbe2d9c2977",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Flattened array: [0 1 2 3 4 5]\n"
     ]
    }
   ],
   "source": [
    "flattened = x.flatten()\n",
    "print(\"Flattened array:\", flattened)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "a02e980c-ec66-48fe-ab99-283fdb441b60",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Raveled array: [0 1 2 3 4 5]\n"
     ]
    }
   ],
   "source": [
    "raveled = x.ravel()\n",
    "print(\"Raveled array:\", raveled)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f9693c63-fb37-4fca-bdfe-552bd82072c1",
   "metadata": {},
   "outputs": [],
   "source": [
    "Tile and repeat arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "cfea85a1-4576-4889-a34d-0dcd3c2a61e9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tiled array:\n",
      " [[0 1 2]\n",
      " [3 4 5]\n",
      " [0 1 2]\n",
      " [3 4 5]]\n"
     ]
    }
   ],
   "source": [
    "tiled = np.tile(x, (2, 1))\n",
    "print(\"Tiled array:\\n\", tiled)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "85907e55-3d5c-42c4-bab4-6e84dfd563f9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Repeated array:\n",
      " [[0 1 2]\n",
      " [0 1 2]\n",
      " [3 4 5]\n",
      " [3 4 5]]\n"
     ]
    }
   ],
   "source": [
    "repeated = np.repeat(x, 2, axis=0)\n",
    "print(\"Repeated array:\\n\", repeated)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7858b926-5019-4977-8dfc-e39026cc9e3e",
   "metadata": {},
   "outputs": [],
   "source": [
    "Masked arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "9926b89c-6851-4a52-9eb7-329c1ac5632a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Masked array:\n",
      " [[0 1 2]\n",
      " [-- -- --]]\n"
     ]
    }
   ],
   "source": [
    "masked_array = np.ma.array(x, mask=x > 2)\n",
    "print(\"Masked array:\\n\", masked_array)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b63f34f4-cbd0-4139-9f04-8366428188da",
   "metadata": {},
   "outputs": [],
   "source": [
    "Advanced linear algebra operations\n",
    "\n",
    "\n",
    "Singular Value Decomposition (SVD)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "981fb2c1-2ae1-4e44-b7a9-25af266948fd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "U matrix:\n",
      " [[-0.27472113  0.96152395]\n",
      " [-0.96152395 -0.27472113]]\n",
      "Singular values: [7.34846923 1.        ]\n",
      "V^H matrix:\n",
      " [[-0.39254051 -0.56077215 -0.7290038 ]\n",
      " [-0.82416338 -0.13736056  0.54944226]]\n"
     ]
    }
   ],
   "source": [
    "u, s, vh = np.linalg.svd(x, full_matrices=False)\n",
    "print(\"U matrix:\\n\", u)\n",
    "print(\"Singular values:\", s)\n",
    "print(\"V^H matrix:\\n\", vh)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ba4d37d7-a743-4751-8dca-305b79d854b4",
   "metadata": {},
   "outputs": [],
   "source": [
    "QR Decomposition"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "f31a1e72-6231-4af9-9454-f0b761dab4a7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Q matrix:\n",
      " [[ 0. -1.]\n",
      " [-1.  0.]]\n",
      "R matrix:\n",
      " [[-3. -4. -5.]\n",
      " [ 0. -1. -2.]]\n"
     ]
    }
   ],
   "source": [
    "q, r = np.linalg.qr(x)\n",
    "print(\"Q matrix:\\n\", q)\n",
    "print(\"R matrix:\\n\", r)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "353747fb-798c-4e00-a0d4-14b119ad8980",
   "metadata": {},
   "outputs": [],
   "source": [
    "Cholesky Decomposition"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "9beeb4c2-dffb-494d-9260-33a2cb26b113",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cholesky decomposition:\n",
      " [[1. 0.]\n",
      " [2. 1.]]\n"
     ]
    }
   ],
   "source": [
    "A = np.array([[1, 2], [2, 5]])\n",
    "cholesky_decomp = np.linalg.cholesky(A)\n",
    "print(\"Cholesky decomposition:\\n\", cholesky_decomp)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "42be8d57-8fe7-4a89-9583-154995d04119",
   "metadata": {},
   "outputs": [],
   "source": [
    "Eigenvalue decomposition"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "d880b425-cd7d-4ebf-9b59-cb8e17a27a85",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Eigenvalues: [0.17157288 5.82842712]\n",
      "Eigenvectors:\n",
      " [[-0.92387953  0.38268343]\n",
      " [ 0.38268343  0.92387953]]\n"
     ]
    }
   ],
   "source": [
    "eigenvalues, eigenvectors = np.linalg.eigh(A)\n",
    "print(\"Eigenvalues:\", eigenvalues)\n",
    "print(\"Eigenvectors:\\n\", eigenvectors)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0c380e54-b5da-4e86-b8c7-4baa615a3e7b",
   "metadata": {},
   "outputs": [],
   "source": [
    "Fourier Transforms"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "54e7d287-db59-47bc-8148-5e1b95fbec2d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "FFT of array: [10.+0.j -2.+2.j -2.+0.j -2.-2.j]\n"
     ]
    }
   ],
   "source": [
    "fft_array = np.fft.fft([1, 2, 3, 4])\n",
    "print(\"FFT of array:\", fft_array)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "2e6f86f4-9442-4c12-be57-372bd6171aa3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Inverse FFT of array: [1.+0.j 2.+0.j 3.+0.j 4.+0.j]\n"
     ]
    }
   ],
   "source": [
    "ifft_array = np.fft.ifft(fft_array)\n",
    "print(\"Inverse FFT of array:\", ifft_array)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b810852d-db7f-45d4-9023-9fccd31b20a0",
   "metadata": {},
   "outputs": [],
   "source": [
    "Gradient and numerical differentiation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "886a46ea-520b-4221-933a-d65ac46e21b6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Gradient of y with respect to x: [ 0.91710906  0.69293215  0.12999645 -0.49649157 -0.88025613 -0.83368344\n",
      " -0.37954184  0.26014916  0.77265913  0.90743359  0.59858436 -0.00289918\n",
      " -0.60296538 -0.90825549 -0.9556918 ]\n"
     ]
    }
   ],
   "source": [
    "x = np.linspace(0, 10, 15)\n",
    "y = np.sin(x)\n",
    "gradient = np.gradient(y, x)\n",
    "print(\"Gradient of y with respect to x:\", gradient)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5b32b21c-5518-44c2-aa1f-088d65c6cdf1",
   "metadata": {},
   "outputs": [],
   "source": [
    "Advanced statistical functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "1561455a-fd7b-4723-a462-d2080b2e3a02",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "90th percentile: 9.0\n",
      "Quantiles (25%, 50%, 75%): [2.5 5.  7.5]\n"
     ]
    }
   ],
   "source": [
    "percentile_90 = np.percentile(x, 90)\n",
    "print(\"90th percentile:\", percentile_90)\n",
    "\n",
    "quantiles = np.quantile(x, [0.25, 0.5, 0.75])\n",
    "print(\"Quantiles (25%, 50%, 75%):\", quantiles)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "efc8d970-b485-4d7f-8c30-9bdeb3887a90",
   "metadata": {},
   "outputs": [],
   "source": [
    "Advanced random number generation\n",
    "\n",
    "Random samples from a multivariate normal distribution"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "00c68bc5-90d2-49c4-aa94-4c373f732d8d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Multivariate normal samples:\n",
      " [[-1.37950475 -0.3608752 ]\n",
      " [ 0.5488923   0.12376359]\n",
      " [ 0.45957741  1.34279064]\n",
      " [ 0.07766664 -0.72547353]\n",
      " [ 0.25018858  1.40772346]]\n"
     ]
    }
   ],
   "source": [
    "mean = [0, 0]\n",
    "cov = [[1, 0.5], [0.5, 1]]\n",
    "multivar_normal = np.random.multivariate_normal(mean, cov, 1000)\n",
    "print(\"Multivariate normal samples:\\n\", multivar_normal[:5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "57a3fa38-ddb4-423e-8058-fc30bfc0b7e5",
   "metadata": {},
   "outputs": [],
   "source": [
    "Working with large datasets\n",
    "\n",
    "Memory-mapped files for large datasets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "5f3d878d-3ade-4fde-9e09-246d1e2308cf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Large array using memmap:\n",
      " [[0.5517069  0.625127   0.28824514 ... 0.335688   0.75485647 0.12456546]\n",
      " [0.42455345 0.1237372  0.00763588 ... 0.03025853 0.20616902 0.24198219]\n",
      " [0.9657104  0.6872292  0.09361833 ... 0.09692259 0.54673225 0.98562753]\n",
      " ...\n",
      " [0.62150055 0.42994517 0.6301443  ... 0.95290226 0.37349352 0.17596494]\n",
      " [0.12116293 0.05929414 0.3259916  ... 0.36909208 0.95684445 0.9793124 ]\n",
      " [0.8184563  0.42437795 0.32313332 ... 0.01789521 0.688961   0.48136896]]\n"
     ]
    }
   ],
   "source": [
    "large_array = np.memmap('large_array.dat', dtype='float32', mode='w+', shape=(1000, 1000))\n",
    "large_array[:] = np.random.random((1000, 1000))\n",
    "print(\"Large array using memmap:\\n\", large_array)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f9e35eb4-a31e-4c0c-bf4c-d1f7a6212b88",
   "metadata": {},
   "outputs": [],
   "source": [
    "Sliding window view for advanced slicing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "c2f75027-455e-49f9-b273-b0407588e3e4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sliding window view:\n",
      " [[0 1 2]\n",
      " [1 2 3]\n",
      " [2 3 4]\n",
      " [3 4 5]\n",
      " [4 5 6]\n",
      " [5 6 7]\n",
      " [6 7 8]\n",
      " [7 8 9]]\n"
     ]
    }
   ],
   "source": [
    "from numpy.lib.stride_tricks import sliding_window_view\n",
    "array = np.arange(10)\n",
    "window_size = 3\n",
    "sliding_windows = sliding_window_view(array, window_shape=window_size)\n",
    "print(\"Sliding window view:\\n\", sliding_windows)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c1be911d-148c-4564-bc88-5e12b7e0b114",
   "metadata": {},
   "outputs": [],
   "source": [
    "Sparse matrix operations with Scipy integration"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "f75f5916-f99f-4810-840c-9ebae0ecca69",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sparse matrix:\n",
      "   (0, 1)\t1\n",
      "  (0, 2)\t2\n",
      "  (0, 3)\t3\n",
      "  (0, 4)\t4\n",
      "  (1, 0)\t5\n",
      "  (1, 1)\t6\n",
      "  (1, 2)\t7\n",
      "  (1, 3)\t8\n",
      "  (1, 4)\t9\n",
      "  (2, 0)\t10\n",
      "  (2, 1)\t11\n",
      "  (2, 2)\t12\n",
      "  (2, 3)\t13\n",
      "  (2, 4)\t14\n",
      "  (3, 0)\t15\n",
      "  (3, 1)\t16\n",
      "  (3, 2)\t17\n",
      "  (3, 3)\t18\n",
      "  (3, 4)\t19\n",
      "  (4, 0)\t20\n",
      "  (4, 1)\t21\n",
      "  (4, 2)\t22\n",
      "  (4, 3)\t23\n",
      "  (4, 4)\t24\n"
     ]
    }
   ],
   "source": [
    "from scipy import sparse\n",
    "a = np.arange(25).reshape(5, 5)\n",
    "sparse_matrix = sparse.csr_matrix(a)\n",
    "print(\"Sparse matrix:\\n\", sparse_matrix)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fa517c9a-9bd7-46a0-aab6-cf814d8ca8bf",
   "metadata": {},
   "outputs": [],
   "source": [
    "Sparse matrix operations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "a9834ef6-96d9-4aa5-bbfc-3fc1baa50803",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sum of sparse matrix elements: 300\n"
     ]
    }
   ],
   "source": [
    "sparse_matrix_sum = sparse_matrix.sum()\n",
    "print(\"Sum of sparse matrix elements:\", sparse_matrix_sum)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "97a19e98-eeee-4c40-a7f8-18b40ad9bad9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Squared elements using np.ufunc:\n",
      " [[  0   1   4   9  16]\n",
      " [ 25  36  49  64  81]\n",
      " [100 121 144 169 196]\n",
      " [225 256 289 324 361]\n",
      " [400 441 484 529 576]]\n"
     ]
    }
   ],
   "source": [
    "# element wise\n",
    "squared_elements = np.square(a)\n",
    "print(\"Squared elements using np.ufunc:\\n\", squared_elements)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6895aa6b-98d5-4ffa-85c3-330a60e2aaab",
   "metadata": {},
   "outputs": [],
   "source": [
    "Broadcasting with np.newaxis for higher-dimensional operations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "4340550f-d4fe-483d-94d1-96832cfa4ff7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Array expanded to 3D with newaxis:\n",
      " [[0]\n",
      " [1]\n",
      " [2]\n",
      " [3]\n",
      " [4]\n",
      " [5]\n",
      " [6]\n",
      " [7]\n",
      " [8]\n",
      " [9]]\n"
     ]
    }
   ],
   "source": [
    "array_3d = array[:, np.newaxis]\n",
    "print(\"Array expanded to 3D with newaxis:\\n\", array_3d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1ed8b2b0-8220-45d5-a16b-3b32e58b9a10",
   "metadata": {},
   "outputs": [],
   "source": [
    "Vectorized string operations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "767689f6-e952-4693-89e5-4b91df7099f8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Uppercased string array: ['HELLO' 'WORLD' 'NUMPY']\n"
     ]
    }
   ],
   "source": [
    "string_array = np.array(['hello', 'world', 'numpy'])\n",
    "uppercased = np.char.upper(string_array)\n",
    "print(\"Uppercased string array:\", uppercased)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ecf678d7-e4dc-43af-9105-e54a894104d6",
   "metadata": {},
   "outputs": [],
   "source": [
    "Vectorized datetime operations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "175fce40-db66-4f46-aa94-71ea4d972531",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Date differences in days: [  0 365]\n"
     ]
    }
   ],
   "source": [
    "dates = np.array(['2023-01-01', '2024-01-01'], dtype='datetime64')\n",
    "date_diffs = dates - np.datetime64('2023-01-01')\n",
    "print(\"Date differences in days:\", date_diffs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b6969e44-8f60-419e-ab29-e32975d7dc54",
   "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.12.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}