UnravelledBliss.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "authorship_tag": "ABX9TyPd8HJcVM9NkbphDGJV3q4y",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/walkerjian/Physics/blob/main/UnravelledBliss.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import math\n",
        "\n",
        "def generate_fft_code_python(N, filename):\n",
        "    with open(filename, 'w') as file:\n",
        "        # Start of the C code\n",
        "        file.write(\"#include <complex.h>\\n#include <stdio.h>\\n\\n\")\n",
        "        file.write(f\"void fft_unrolled_{N}(double* x, complex double* X) {{\\n\")\n",
        "\n",
        "        log2N = int(math.log2(N))\n",
        "\n",
        "        for stage in range(1, log2N + 1):\n",
        "            span = 1 << stage\n",
        "            half_span = span // 2\n",
        "            file.write(f\"    // Stage {stage}\\n\")\n",
        "\n",
        "            for k in range(0, N, span):\n",
        "                # First half without twiddles\n",
        "                file.write(f\"    {{\\n        double t = x[{k}];\\n\")\n",
        "                file.write(f\"        x[{k}] = t + x[{k + half_span}];\\n\")\n",
        "                file.write(f\"        x[{k + half_span}] = t - x[{k + half_span}];\\n    }}\\n\")\n",
        "\n",
        "                # Second half with twiddles\n",
        "                for j in range(1, half_span):\n",
        "                    twiddle_real = math.cos(-2.0 * math.pi * j / N)\n",
        "                    twiddle_imag = math.sin(-2.0 * math.pi * j / N)\n",
        "                    file.write(f\"    {{\\n        complex double t = x[{k + j + half_span}] * ({twiddle_real} - I * {twiddle_imag});\\n\")\n",
        "                    file.write(f\"        x[{k + j + half_span}] = x[{k + j}] - t;\\n\")\n",
        "                    file.write(f\"        x[{k + j}] += t;\\n    }}\\n\")\n",
        "\n",
        "            file.write(\"\\n\")\n",
        "\n",
        "        # End of the FFT logic\n",
        "        file.write(\"    // Copy results to X\\n\")\n",
        "        for k in range(N):\n",
        "            file.write(f\"    X[{k}] = x[{k}];\\n\")\n",
        "\n",
        "        # Add the main function for standalone execution\n",
        "        file.write(f\"\"\"}}\n",
        "int main() {{\n",
        "    double input[{N}];\n",
        "    complex double output[{N}];\n",
        "\n",
        "    // Read input data\n",
        "    for(int i = 0; i < {N}; i++) {{\n",
        "        scanf(\"%lf\", &input[i]);\n",
        "    }}\n",
        "\n",
        "    // Call FFT function\n",
        "    fft_unrolled_{N}(input, output);\n",
        "\n",
        "    // Print FFT results\n",
        "    for(int i = 0; i < {N}; i++) {{\n",
        "        printf(\"%lf + %lfi\\\\n\", creal(output[i]), cimag(output[i]));\n",
        "    }}\n",
        "\n",
        "    return 0;\n",
        "}}\n",
        "\"\"\")\n"
      ],
      "metadata": {
        "id": "IyZm5tDwdW4R"
      },
      "execution_count": 60,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "\n",
        "def top_hat(N):\n",
        "    \"\"\"Generate a top-hat waveform.\"\"\"\n",
        "    waveform = np.zeros(N)\n",
        "    waveform[N//4:3*N//4] = 1\n",
        "    return waveform\n",
        "\n",
        "def sinc(N):\n",
        "    \"\"\"Generate a sinc waveform.\"\"\"\n",
        "    x = np.linspace(-2*np.pi, 2*np.pi, N, endpoint=False)\n",
        "    return np.sinc(x)\n",
        "\n",
        "def sin(N):\n",
        "    \"\"\"Generate a sin waveform.\"\"\"\n",
        "    x = np.linspace(-2*np.pi, 2*np.pi, N, endpoint=False)\n",
        "    return np.sin(x)\n",
        "\n",
        "def cos(N):\n",
        "    \"\"\"Generate a cos waveform.\"\"\"\n",
        "    x = np.linspace(-2*np.pi, 2*np.pi, N, endpoint=False)\n",
        "    return np.cos(x)\n",
        "\n",
        "def sincos(N):\n",
        "    \"\"\"Generate a sincos waveform.\"\"\"\n",
        "    x = np.linspace(-2*np.pi, 2*np.pi, N, endpoint=False)\n",
        "    return np.sin(x)*np.cos(x)\n",
        "\n",
        "# ... (similar functions for other waveforms: sin, gaussian, delta, sawtooth)\n"
      ],
      "metadata": {
        "id": "LDhVqEX6TWo4"
      },
      "execution_count": 129,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def ascii_art(data, width=256, height=40):\n",
        "    \"\"\"Convert data to ASCII art.\"\"\"\n",
        "    screen = [[' ' for _ in range(width)] for _ in range(height)]\n",
        "    max_val, min_val = max(data), min(data)\n",
        "\n",
        "    for i, value in enumerate(data):\n",
        "        norm_val = 1 - (value - min_val) / (max_val - min_val)  # Invert the normalization here\n",
        "        y = int(norm_val * (height - 1))\n",
        "        screen[y][i * width // len(data)] = '*'\n",
        "\n",
        "    for row in screen:\n",
        "        print(''.join(row))\n",
        "\n",
        "def ascii_art2(data, width=128, height=40):\n",
        "    \"\"\"Convert data to ASCII art.\"\"\"\n",
        "    screen = [[' ' for _ in range(width)] for _ in range(height)]\n",
        "    max_val, min_val = max(data), min(data)\n",
        "\n",
        "    for i, value in enumerate(data):\n",
        "        # Normalize the value between 0 and 1\n",
        "        norm_val = (value - min_val) / (max_val - min_val)\n",
        "\n",
        "        # Calculate the number of asterisks to be printed\n",
        "        num_asterisks = int(norm_val * height)\n",
        "\n",
        "        # Update the screen to show the column of asterisks\n",
        "        for j in range(num_asterisks):\n",
        "            screen[height - 1 - j][i * width // len(data)] = '*'\n",
        "\n",
        "    # Print the ASCII art\n",
        "    for row in screen:\n",
        "        print(''.join(row))\n",
        "\n"
      ],
      "metadata": {
        "id": "qRySpTfuTZ4s"
      },
      "execution_count": 134,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import os\n",
        "import subprocess\n",
        "import numpy as np\n",
        "\n",
        "def check_generate_fft(N):\n",
        "    filename = f\"unrolled_fft_{N}.c\"\n",
        "    if not os.path.exists(filename):\n",
        "        # Generate FFT code using Python function\n",
        "        generate_fft_code_python(N, filename)\n",
        "    return filename\n",
        "\n",
        "def compile_fft(N):\n",
        "    \"\"\"Compile the FFT code.\"\"\"\n",
        "    # Compile the generated C code\n",
        "    subprocess.run([\"gcc\", f\"unrolled_fft_{N}.c\", \"-o\", f\"fft_{N}\", \"-lm\"])\n",
        "\n",
        "def run_fft(N, data):\n",
        "    # Prepare input data for the FFT\n",
        "    input_data_str = \"\\n\".join(map(str, data)) + \"\\n\"\n",
        "\n",
        "    # Execute the FFT\n",
        "    result = subprocess.run([f\"./fft_{N}\"], input=input_data_str, stdout=subprocess.PIPE, text=True)\n",
        "\n",
        "    def extract_complex_numbers(output):\n",
        "        # Split the output into individual lines\n",
        "        lines = output.splitlines()\n",
        "\n",
        "        # Extract complex numbers from each line\n",
        "        complex_numbers = []\n",
        "        for line in lines:\n",
        "            # Split the line at the '+' sign and remove the trailing 'i'\n",
        "            real_part, imag_part = line.split('+')\n",
        "\n",
        "            # Convert the parts to float and then to a complex number\n",
        "            complex_num = complex(float(real_part.strip()), float(imag_part.strip()[:-1]))\n",
        "\n",
        "            complex_numbers.append(complex_num)\n",
        "\n",
        "        return complex_numbers\n",
        "\n",
        "    fft_output = extract_complex_numbers(result.stdout)\n",
        "\n",
        "    return np.array(fft_output)\n",
        "\n",
        "\n",
        "\n",
        "def main():\n",
        "    N = 1024  # or other desired values\n",
        "    waveform = top_hat(N)\n",
        "\n",
        "    print(\"Input:\")\n",
        "    ascii_art2(np.real(waveform))\n",
        "\n",
        "    # Apply the shifty operation on the input waveform\n",
        "    waveform_shifted = [waveform[i] * (-1)**i for i in range(N)]\n",
        "\n",
        "    print(\"Input (Shifted):\")\n",
        "    ascii_art2(np.real(waveform_shifted))\n",
        "\n",
        "    # Compute the FFT using numpy\n",
        "    fft_output_np = np.fft.fft(waveform_shifted)\n",
        "\n",
        "    # Shift the FFT output back\n",
        "    fft_output_shifted_back = [fft_output_np[i] * (-1)**i for i in range(N)]\n",
        "    fft_magnitude_np = np.abs(fft_output_shifted_back)\n",
        "\n",
        "    print(\"\\nFFT Output using numpy:\")\n",
        "    ascii_art2(fft_magnitude_np)\n",
        "\n",
        "    #this section using the generated unrolled c code\n",
        "    check_generate_fft(N)\n",
        "    compile_fft(N)\n",
        "\n",
        "    # Run the unrolled FFT\n",
        "    fft_result = run_fft(N, waveform_shifted)\n",
        "\n",
        "    # Shift the unrolled FFT output back\n",
        "    fft_result_shifted_back = [fft_result[i] * (-1)**i for i in range(N)]\n",
        "\n",
        "    print(\"\\nFFT Magnitude (Unrolled):\")\n",
        "    ascii_art2(np.abs(fft_result_shifted_back))\n",
        "\n",
        "\n",
        "main()\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "NZ5ao7ZQTckE",
        "outputId": "7a52ea33-3dce-4103-9d82-75b17ed36bf4"
      },
      "execution_count": 144,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Input:\n",
            "                                ****************************************************************                                \n",
            "                                ****************************************************************                                \n",
            "                                ****************************************************************                                \n",
            "                                ****************************************************************                                \n",
            "                                ****************************************************************                                \n",
            "                                ****************************************************************                                \n",
            "                                ****************************************************************                                \n",
            "                                ****************************************************************                                \n",
            "                                ****************************************************************                                \n",
            "                                ****************************************************************                                \n",
            "                                ****************************************************************                                \n",
            "                                ****************************************************************                                \n",
            "                                ****************************************************************                                \n",
            "                                ****************************************************************                                \n",
            "                                ****************************************************************                                \n",
            "                                ****************************************************************                                \n",
            "                                ****************************************************************                                \n",
            "                                ****************************************************************                                \n",
            "                                ****************************************************************                                \n",
            "                                ****************************************************************                                \n",
            "                                ****************************************************************                                \n",
            "                                ****************************************************************                                \n",
            "                                ****************************************************************                                \n",
            "                                ****************************************************************                                \n",
            "                                ****************************************************************                                \n",
            "                                ****************************************************************                                \n",
            "                                ****************************************************************                                \n",
            "                                ****************************************************************                                \n",
            "                                ****************************************************************                                \n",
            "                                ****************************************************************                                \n",
            "                                ****************************************************************                                \n",
            "                                ****************************************************************                                \n",
            "                                ****************************************************************                                \n",
            "                                ****************************************************************                                \n",
            "                                ****************************************************************                                \n",
            "                                ****************************************************************                                \n",
            "                                ****************************************************************                                \n",
            "                                ****************************************************************                                \n",
            "                                ****************************************************************                                \n",
            "                                ****************************************************************                                \n",
            "Input (Shifted):\n",
            "                                ****************************************************************                                \n",
            "                                ****************************************************************                                \n",
            "                                ****************************************************************                                \n",
            "                                ****************************************************************                                \n",
            "                                ****************************************************************                                \n",
            "                                ****************************************************************                                \n",
            "                                ****************************************************************                                \n",
            "                                ****************************************************************                                \n",
            "                                ****************************************************************                                \n",
            "                                ****************************************************************                                \n",
            "                                ****************************************************************                                \n",
            "                                ****************************************************************                                \n",
            "                                ****************************************************************                                \n",
            "                                ****************************************************************                                \n",
            "                                ****************************************************************                                \n",
            "                                ****************************************************************                                \n",
            "                                ****************************************************************                                \n",
            "                                ****************************************************************                                \n",
            "                                ****************************************************************                                \n",
            "                                ****************************************************************                                \n",
            "********************************************************************************************************************************\n",
            "********************************************************************************************************************************\n",
            "********************************************************************************************************************************\n",
            "********************************************************************************************************************************\n",
            "********************************************************************************************************************************\n",
            "********************************************************************************************************************************\n",
            "********************************************************************************************************************************\n",
            "********************************************************************************************************************************\n",
            "********************************************************************************************************************************\n",
            "********************************************************************************************************************************\n",
            "********************************************************************************************************************************\n",
            "********************************************************************************************************************************\n",
            "********************************************************************************************************************************\n",
            "********************************************************************************************************************************\n",
            "********************************************************************************************************************************\n",
            "********************************************************************************************************************************\n",
            "********************************************************************************************************************************\n",
            "********************************************************************************************************************************\n",
            "********************************************************************************************************************************\n",
            "********************************************************************************************************************************\n",
            "\n",
            "FFT Output using numpy:\n",
            "                                                                *                                                               \n",
            "                                                                *                                                               \n",
            "                                                                *                                                               \n",
            "                                                                *                                                               \n",
            "                                                                *                                                               \n",
            "                                                                *                                                               \n",
            "                                                                *                                                               \n",
            "                                                                *                                                               \n",
            "                                                                *                                                               \n",
            "                                                                *                                                               \n",
            "                                                                *                                                               \n",
            "                                                                *                                                               \n",
            "                                                                *                                                               \n",
            "                                                                *                                                               \n",
            "                                                                *                                                               \n",
            "                                                               **                                                               \n",
            "                                                               **                                                               \n",
            "                                                               **                                                               \n",
            "                                                               **                                                               \n",
            "                                                               **                                                               \n",
            "                                                               **                                                               \n",
            "                                                               **                                                               \n",
            "                                                               **                                                               \n",
            "                                                               **                                                               \n",
            "                                                               **                                                               \n",
            "                                                               **                                                               \n",
            "                                                               **                                                               \n",
            "                                                               **                                                               \n",
            "                                                               **                                                               \n",
            "                                                               **                                                               \n",
            "                                                               **                                                               \n",
            "                                                               **                                                               \n",
            "                                                               **                                                               \n",
            "                                                               **                                                               \n",
            "                                                               **                                                               \n",
            "                                                               **                                                               \n",
            "                                                               **                                                               \n",
            "                                                               **                                                               \n",
            "                                                              ****                                                              \n",
            "                                                            ********                                                            \n",
            "\n",
            "FFT Magnitude (Unrolled):\n",
            "*                                                                                                                               \n",
            "*                                                                                                                               \n",
            "*                                                                                                                               \n",
            "*                                                                                                                               \n",
            "*                                                                                                                               \n",
            "*                                                                                                                               \n",
            "*                                                                                                                               \n",
            "*                                                                                                                               \n",
            "*                                                                                                                               \n",
            "*                                                                                                                               \n",
            "*                                                                                                                               \n",
            "*                                                                                                                               \n",
            "*                                                                                                                               \n",
            "*                                                                                                                               \n",
            "*                                                                                                                               \n",
            "*                                                                                                                               \n",
            "*                                                                                                                               \n",
            "*                                                                                                                               \n",
            "*                                                                                                                               \n",
            "*                                                                                                                               \n",
            "*                               *                                                                                               \n",
            "*                               *                                                               *                               \n",
            "*                               *                                                               *                               \n",
            "*                               *                                                               *                               \n",
            "*                               *                                                               *                               \n",
            "*                               *                                                               *                               \n",
            "*                               *                                                               *                               \n",
            "*                               *                                                               *                               \n",
            "*                               *                                                               *                               \n",
            "*                               *                                                               *                               \n",
            "*                               *                                                               *                               \n",
            "*                               *                                                               *                               \n",
            "*                               *                                                               *                               \n",
            "*                               *                                                               *                               \n",
            "*                               *                                                               *                               \n",
            "*                               *                                                               *                               \n",
            "*                               *                                                               *                               \n",
            "*                               *                                                               *                               \n",
            "*                               *                                                               *                               \n",
            "*                               *                                                               *                               \n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!ls -lash"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "S0kb2zsgFyIJ",
        "outputId": "78869c08-d262-4535-8f73-56feefc95eb7"
      },
      "execution_count": 145,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "total 2.8M\n",
            "4.0K drwxr-xr-x 1 root root 4.0K Sep 19 11:54 .\n",
            "4.0K drwxr-xr-x 1 root root 4.0K Sep 19 07:11 ..\n",
            "4.0K drwxr-xr-x 4 root root 4.0K Sep 15 13:21 .config\n",
            "772K -rwxr-xr-x 1 root root 772K Sep 19 11:54 fft_1024\n",
            " 80K -rwxr-xr-x 1 root root  80K Sep 19 11:29 fft_128\n",
            " 20K -rwxr-xr-x 1 root root  20K Sep 19 11:33 fft_16\n",
            "164K -rwxr-xr-x 1 root root 164K Sep 19 11:31 fft_256\n",
            " 28K -rwxr-xr-x 1 root root  28K Sep 19 11:01 fft_32\n",
            "352K -rwxr-xr-x 1 root root 352K Sep 19 11:20 fft_512\n",
            " 44K -rwxr-xr-x 1 root root  44K Sep 19 11:02 fft_64\n",
            " 16K -rwxr-xr-x 1 root root  16K Sep 19 11:37 fft_8\n",
            "4.0K drwxr-xr-x 1 root root 4.0K Sep 15 13:22 sample_data\n",
            "708K -rw-r--r-- 1 root root 705K Sep 19 11:54 unrolled_fft_1024.c\n",
            " 60K -rw-r--r-- 1 root root  60K Sep 19 11:04 unrolled_fft_128.c\n",
            "8.0K -rw-r--r-- 1 root root 4.5K Sep 19 11:33 unrolled_fft_16.c\n",
            "140K -rw-r--r-- 1 root root 139K Sep 19 10:07 unrolled_fft_256.c\n",
            " 12K -rw-r--r-- 1 root root  11K Sep 19 11:01 unrolled_fft_32.c\n",
            "316K -rw-r--r-- 1 root root 315K Sep 19 11:13 unrolled_fft_512.c\n",
            " 28K -rw-r--r-- 1 root root  26K Sep 19 11:02 unrolled_fft_64.c\n",
            "4.0K -rw-r--r-- 1 root root 2.0K Sep 19 11:37 unrolled_fft_8.c\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!cat unrolled_fft_8.c"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1lAJ4XzTN1j2",
        "outputId": "5a5f23d5-2f5c-4cdb-eb0a-fdf83dccde25"
      },
      "execution_count": 143,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "#include <complex.h>\n",
            "#include <stdio.h>\n",
            "\n",
            "void fft_unrolled_8(double* x, complex double* X) {\n",
            "    // Stage 1\n",
            "    {\n",
            "        double t = x[0];\n",
            "        x[0] = t + x[1];\n",
            "        x[1] = t - x[1];\n",
            "    }\n",
            "    {\n",
            "        double t = x[2];\n",
            "        x[2] = t + x[3];\n",
            "        x[3] = t - x[3];\n",
            "    }\n",
            "    {\n",
            "        double t = x[4];\n",
            "        x[4] = t + x[5];\n",
            "        x[5] = t - x[5];\n",
            "    }\n",
            "    {\n",
            "        double t = x[6];\n",
            "        x[6] = t + x[7];\n",
            "        x[7] = t - x[7];\n",
            "    }\n",
            "\n",
            "    // Stage 2\n",
            "    {\n",
            "        double t = x[0];\n",
            "        x[0] = t + x[2];\n",
            "        x[2] = t - x[2];\n",
            "    }\n",
            "    {\n",
            "        complex double t = x[3] * (0.7071067811865476 - I * -0.7071067811865475);\n",
            "        x[3] = x[1] - t;\n",
            "        x[1] += t;\n",
            "    }\n",
            "    {\n",
            "        double t = x[4];\n",
            "        x[4] = t + x[6];\n",
            "        x[6] = t - x[6];\n",
            "    }\n",
            "    {\n",
            "        complex double t = x[7] * (0.7071067811865476 - I * -0.7071067811865475);\n",
            "        x[7] = x[5] - t;\n",
            "        x[5] += t;\n",
            "    }\n",
            "\n",
            "    // Stage 3\n",
            "    {\n",
            "        double t = x[0];\n",
            "        x[0] = t + x[4];\n",
            "        x[4] = t - x[4];\n",
            "    }\n",
            "    {\n",
            "        complex double t = x[5] * (0.7071067811865476 - I * -0.7071067811865475);\n",
            "        x[5] = x[1] - t;\n",
            "        x[1] += t;\n",
            "    }\n",
            "    {\n",
            "        complex double t = x[6] * (6.123233995736766e-17 - I * -1.0);\n",
            "        x[6] = x[2] - t;\n",
            "        x[2] += t;\n",
            "    }\n",
            "    {\n",
            "        complex double t = x[7] * (-0.7071067811865475 - I * -0.7071067811865476);\n",
            "        x[7] = x[3] - t;\n",
            "        x[3] += t;\n",
            "    }\n",
            "\n",
            "    // Copy results to X\n",
            "    X[0] = x[0];\n",
            "    X[1] = x[1];\n",
            "    X[2] = x[2];\n",
            "    X[3] = x[3];\n",
            "    X[4] = x[4];\n",
            "    X[5] = x[5];\n",
            "    X[6] = x[6];\n",
            "    X[7] = x[7];\n",
            "}\n",
            "int main() {\n",
            "    double input[8];\n",
            "    complex double output[8];\n",
            "\n",
            "    // Read input data\n",
            "    for(int i = 0; i < 8; i++) {\n",
            "        scanf(\"%lf\", &input[i]);\n",
            "    }\n",
            "\n",
            "    // Call FFT function\n",
            "    fft_unrolled_8(input, output);\n",
            "\n",
            "    // Print FFT results\n",
            "    for(int i = 0; i < 8; i++) {\n",
            "        printf(\"%lf + %lfi\\n\", creal(output[i]), cimag(output[i]));\n",
            "    }\n",
            "\n",
            "    return 0;\n",
            "}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/content/drive')\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zz9xTm3eOTX6",
        "outputId": "85cf3e0c-d16c-45b1-d463-2ae3db000d0d"
      },
      "execution_count": 146,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mounted at /content/drive\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!mkdir \"/content/drive/My Drive/FFT_Files\"\n",
        "!cp fft_* \"/content/drive/My Drive/FFT_Files/\"\n",
        "!cp unrolled_fft_* \"/content/drive/My Drive/FFT_Files/\"\n"
      ],
      "metadata": {
        "id": "2-HR0P63Tw1U"
      },
      "execution_count": 147,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "M4fi9wGCT6UN"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}