AFT.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/falseywinchnet/PyITD/blob/main/AFT.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Accumulator Fourier Transform: Question. Is it possible for us to decompose the fourier transform into a series of harmonically overlapping indexing at value? and as a result, can we rapidly perform some transposing and copying into scratch memory, and rapidly integrate over series of values that are consecutive in that we are essentially performing the FFT, but instead of doing so by the use of accumulators in butterfly space, we instead essentially roll out the carpet, duplicate our data the minimum number of times, using slicing, to create an alternative path through phase space that allows us to much more effectively vectorize the operations ? Suppose that we accepted a tradeoff in that this transform would be less efficient than the FFT, but more than the DFT, like the FFT it is an attempt to find the sort order internally, using overlapping harmonics and temporary storage, and, just like how the fft is related to sorting(and optimal) we can approach optimality but surrender some of it in order to get better contigious operations and sequential accumulation. This could be faster than the FFT- we can reason that iti s quick to multiply a bunch of numbers in a an array by just one coefficient, and then repeatedly sum them up by parts and add them together. if you decide to poke aroud with this and get somewhere, HMU"
      ],
      "metadata": {
        "id": "A0ZkjhMz4q_6"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "here is what we know: we can with very little loss simplify the unique coefficients to only 257 shared between real and imaginary. Secondly, no dft row requires 512 coefficients of any one value.  if we were, say, to conserve the indexes, and sort each dft row(sin or cos) by value, and look for overlaps, what we will find is that each dft row participates in multiple accumulators- for example, bin x requires elements a,b,c,d,e multiplied by 1, and bin y requires elements a,b,c,d,e,f,g multiplied by one. sorted by commonality, we can think of this as needing up to N^1.5 space for storage- every row is now a different twiddle factor, and the bins are sorted by what frequency bin that element is needed for, with the highest number of common elements to start with. We may need multiple such trees for different harmonics, but at most, each of them only needs 257 rows and at far less than 512 elements in each- in all probability each only needs to be a mask where there is an offset accumulation starts from, or gathers from specific offsets as precomputed accumulators. the question is if the transposition and slicing can be efficient. the answer, typically, is no, while that is a valid way to find the dft, it is not efficient to do this compared to just doing the fft.  even if i could get the amount of mathematical operations(mult and addition) down to the exact same as the fft itself, the number of cache swaps needed to go through all the tasks required will dramatically outfactor the savings gained by vectorization"
      ],
      "metadata": {
        "id": "O4Xkq0JZ7Bq0"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "zwFnJsE6vjf8",
        "outputId": "0dcc33cb-40a4-4225-dc40-76abfc61ece5",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Number of unique values after rounding: 257\n"
          ]
        }
      ],
      "source": [
        "import numpy as np\n",
        "\n",
        "N = 512\n",
        "k = np.arange(N)[:, np.newaxis]  # frequency bins\n",
        "n = np.arange(N)                 # time indices\n",
        "\n",
        "# Generate the real (cosine) parts\n",
        "real_parts = np.cos(2 * np.pi * k * n / N)\n",
        "# Generate the imaginary (sine) parts\n",
        "imag_parts = -np.sin(2 * np.pi * k * n / N)\n",
        "\n",
        "# Stack them vertically and round to 8 decimals\n",
        "full_matrix = np.round(np.vstack([real_parts, imag_parts]), decimals=10)\n",
        "\n",
        "# Let's see how many unique values we actually have\n",
        "unique_values = np.unique(full_matrix)\n",
        "print(f\"Number of unique values after rounding: {len(unique_values)}\")"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "from sympy import Symbol\n",
        "\n",
        "# Using our existing full_matrix\n",
        "unique_values = np.unique(full_matrix)\n",
        "# Create a mapping of value -> symbol\n",
        "value_to_symbol = {val: Symbol(f'v_{i}') for i, val in enumerate(unique_values)}\n",
        "\n",
        "# Convert our numerical matrix to symbolic\n",
        "symbolic_matrix = np.empty(full_matrix.shape, dtype=object)\n",
        "for i in range(full_matrix.shape[0]):\n",
        "    for j in range(full_matrix.shape[1]):\n",
        "        symbolic_matrix[i,j] = value_to_symbol[full_matrix[i,j]]"
      ],
      "metadata": {
        "id": "T7unAJniqtgx"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def find_harmonics(k, max_freq=512):\n",
        "    \"\"\"Find all harmonic frequencies of k up to max_freq\"\"\"\n",
        "    harmonics = []\n",
        "    n = 2\n",
        "    while k * n < max_freq:\n",
        "        harmonics.append(k * n)\n",
        "        n += 1\n",
        "    return harmonics\n",
        "\n",
        "def compute_overlap(symbolic_matrix, k1, k2):\n",
        "    \"\"\"Compute overlap between two frequency bins\"\"\"\n",
        "    # Get both real and imaginary parts\n",
        "    bin1_real = symbolic_matrix[k1, :]\n",
        "    bin1_imag = symbolic_matrix[k1 + 512, :]\n",
        "    bin2_real = symbolic_matrix[k2, :]\n",
        "    bin2_imag = symbolic_matrix[k2 + 512, :]\n",
        "\n",
        "    # Find common symbols\n",
        "    symbols1 = set(list(bin1_real) + list(bin1_imag))\n",
        "    symbols2 = set(list(bin2_real) + list(bin2_imag))\n",
        "\n",
        "    return len(symbols1.intersection(symbols2))\n",
        "\n",
        "# Let's analyze first few fundamental frequencies\n",
        "for k in range(1, 10):  # Start with small k to see pattern clearly\n",
        "    harmonics = find_harmonics(k)\n",
        "    print(f\"\\nFundamental frequency {k} harmonics:\")\n",
        "    for h in harmonics[:5]:  # Look at first 5 harmonics\n",
        "        overlap = compute_overlap(symbolic_matrix, k, h)\n",
        "        print(f\"  Harmonic {h}: {overlap} shared symbols\")"
      ],
      "metadata": {
        "id": "gwOTYDbQrD98",
        "outputId": "40e866eb-d9d7-47c7-e35e-c9fa929747bb",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "Fundamental frequency 1 harmonics:\n",
            "  Harmonic 2: 129 shared symbols\n",
            "  Harmonic 3: 257 shared symbols\n",
            "  Harmonic 4: 65 shared symbols\n",
            "  Harmonic 5: 257 shared symbols\n",
            "  Harmonic 6: 129 shared symbols\n",
            "\n",
            "Fundamental frequency 2 harmonics:\n",
            "  Harmonic 4: 65 shared symbols\n",
            "  Harmonic 6: 129 shared symbols\n",
            "  Harmonic 8: 33 shared symbols\n",
            "  Harmonic 10: 129 shared symbols\n",
            "  Harmonic 12: 65 shared symbols\n",
            "\n",
            "Fundamental frequency 3 harmonics:\n",
            "  Harmonic 6: 129 shared symbols\n",
            "  Harmonic 9: 257 shared symbols\n",
            "  Harmonic 12: 65 shared symbols\n",
            "  Harmonic 15: 257 shared symbols\n",
            "  Harmonic 18: 129 shared symbols\n",
            "\n",
            "Fundamental frequency 4 harmonics:\n",
            "  Harmonic 8: 33 shared symbols\n",
            "  Harmonic 12: 65 shared symbols\n",
            "  Harmonic 16: 17 shared symbols\n",
            "  Harmonic 20: 65 shared symbols\n",
            "  Harmonic 24: 33 shared symbols\n",
            "\n",
            "Fundamental frequency 5 harmonics:\n",
            "  Harmonic 10: 129 shared symbols\n",
            "  Harmonic 15: 257 shared symbols\n",
            "  Harmonic 20: 65 shared symbols\n",
            "  Harmonic 25: 257 shared symbols\n",
            "  Harmonic 30: 129 shared symbols\n",
            "\n",
            "Fundamental frequency 6 harmonics:\n",
            "  Harmonic 12: 65 shared symbols\n",
            "  Harmonic 18: 129 shared symbols\n",
            "  Harmonic 24: 33 shared symbols\n",
            "  Harmonic 30: 129 shared symbols\n",
            "  Harmonic 36: 65 shared symbols\n",
            "\n",
            "Fundamental frequency 7 harmonics:\n",
            "  Harmonic 14: 129 shared symbols\n",
            "  Harmonic 21: 257 shared symbols\n",
            "  Harmonic 28: 65 shared symbols\n",
            "  Harmonic 35: 257 shared symbols\n",
            "  Harmonic 42: 129 shared symbols\n",
            "\n",
            "Fundamental frequency 8 harmonics:\n",
            "  Harmonic 16: 17 shared symbols\n",
            "  Harmonic 24: 33 shared symbols\n",
            "  Harmonic 32: 9 shared symbols\n",
            "  Harmonic 40: 33 shared symbols\n",
            "  Harmonic 48: 17 shared symbols\n",
            "\n",
            "Fundamental frequency 9 harmonics:\n",
            "  Harmonic 18: 129 shared symbols\n",
            "  Harmonic 27: 257 shared symbols\n",
            "  Harmonic 36: 65 shared symbols\n",
            "  Harmonic 45: 257 shared symbols\n",
            "  Harmonic 54: 129 shared symbols\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def create_accumulator_group(k):\n",
        "   \"\"\"Create accumulator group for fundamental k and its harmonics\"\"\"\n",
        "   harmonics = find_harmonics(k)\n",
        "   overlaps = [(h, compute_overlap(symbolic_matrix, k, h)) for h in harmonics]\n",
        "\n",
        "   # Sort by overlap amount to identify highest reuse potential\n",
        "   sorted_overlaps = sorted(overlaps, key=lambda x: x[1], reverse=True)\n",
        "\n",
        "   # Group by overlap amount\n",
        "   groups = {}\n",
        "   for harmonic, overlap in sorted_overlaps:\n",
        "       if overlap not in groups:\n",
        "           groups[overlap] = []\n",
        "       groups[overlap].append(harmonic)\n",
        "\n",
        "   return groups\n",
        "\n",
        "# Let's examine a few odd fundamentals\n",
        "for k in [1,3,5,7,9]:\n",
        "   groups = create_accumulator_group(k)\n",
        "   print(f\"\\nFundamental {k} accumulator groups:\")\n",
        "   for overlap, harmonics in groups.items():\n",
        "       print(f\"  Overlap {overlap}: frequencies {harmonics}\")"
      ],
      "metadata": {
        "id": "qzwhnDgrsQ2k",
        "outputId": "dc980426-6022-4d87-860d-2f2a1813f57a",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "Fundamental 1 accumulator groups:\n",
            "  Overlap 257: frequencies [3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31, 33, 35, 37, 39, 41, 43, 45, 47, 49, 51, 53, 55, 57, 59, 61, 63, 65, 67, 69, 71, 73, 75, 77, 79, 81, 83, 85, 87, 89, 91, 93, 95, 97, 99, 101, 103, 105, 107, 109, 111, 113, 115, 117, 119, 121, 123, 125, 127, 129, 131, 133, 135, 137, 139, 141, 143, 145, 147, 149, 151, 153, 155, 157, 159, 161, 163, 165, 167, 169, 171, 173, 175, 177, 179, 181, 183, 185, 187, 189, 191, 193, 195, 197, 199, 201, 203, 205, 207, 209, 211, 213, 215, 217, 219, 221, 223, 225, 227, 229, 231, 233, 235, 237, 239, 241, 243, 245, 247, 249, 251, 253, 255, 257, 259, 261, 263, 265, 267, 269, 271, 273, 275, 277, 279, 281, 283, 285, 287, 289, 291, 293, 295, 297, 299, 301, 303, 305, 307, 309, 311, 313, 315, 317, 319, 321, 323, 325, 327, 329, 331, 333, 335, 337, 339, 341, 343, 345, 347, 349, 351, 353, 355, 357, 359, 361, 363, 365, 367, 369, 371, 373, 375, 377, 379, 381, 383, 385, 387, 389, 391, 393, 395, 397, 399, 401, 403, 405, 407, 409, 411, 413, 415, 417, 419, 421, 423, 425, 427, 429, 431, 433, 435, 437, 439, 441, 443, 445, 447, 449, 451, 453, 455, 457, 459, 461, 463, 465, 467, 469, 471, 473, 475, 477, 479, 481, 483, 485, 487, 489, 491, 493, 495, 497, 499, 501, 503, 505, 507, 509, 511]\n",
            "  Overlap 129: frequencies [2, 6, 10, 14, 18, 22, 26, 30, 34, 38, 42, 46, 50, 54, 58, 62, 66, 70, 74, 78, 82, 86, 90, 94, 98, 102, 106, 110, 114, 118, 122, 126, 130, 134, 138, 142, 146, 150, 154, 158, 162, 166, 170, 174, 178, 182, 186, 190, 194, 198, 202, 206, 210, 214, 218, 222, 226, 230, 234, 238, 242, 246, 250, 254, 258, 262, 266, 270, 274, 278, 282, 286, 290, 294, 298, 302, 306, 310, 314, 318, 322, 326, 330, 334, 338, 342, 346, 350, 354, 358, 362, 366, 370, 374, 378, 382, 386, 390, 394, 398, 402, 406, 410, 414, 418, 422, 426, 430, 434, 438, 442, 446, 450, 454, 458, 462, 466, 470, 474, 478, 482, 486, 490, 494, 498, 502, 506, 510]\n",
            "  Overlap 65: frequencies [4, 12, 20, 28, 36, 44, 52, 60, 68, 76, 84, 92, 100, 108, 116, 124, 132, 140, 148, 156, 164, 172, 180, 188, 196, 204, 212, 220, 228, 236, 244, 252, 260, 268, 276, 284, 292, 300, 308, 316, 324, 332, 340, 348, 356, 364, 372, 380, 388, 396, 404, 412, 420, 428, 436, 444, 452, 460, 468, 476, 484, 492, 500, 508]\n",
            "  Overlap 33: frequencies [8, 24, 40, 56, 72, 88, 104, 120, 136, 152, 168, 184, 200, 216, 232, 248, 264, 280, 296, 312, 328, 344, 360, 376, 392, 408, 424, 440, 456, 472, 488, 504]\n",
            "  Overlap 17: frequencies [16, 48, 80, 112, 144, 176, 208, 240, 272, 304, 336, 368, 400, 432, 464, 496]\n",
            "  Overlap 9: frequencies [32, 96, 160, 224, 288, 352, 416, 480]\n",
            "  Overlap 5: frequencies [64, 192, 320, 448]\n",
            "  Overlap 3: frequencies [128, 256, 384]\n",
            "\n",
            "Fundamental 3 accumulator groups:\n",
            "  Overlap 257: frequencies [9, 15, 21, 27, 33, 39, 45, 51, 57, 63, 69, 75, 81, 87, 93, 99, 105, 111, 117, 123, 129, 135, 141, 147, 153, 159, 165, 171, 177, 183, 189, 195, 201, 207, 213, 219, 225, 231, 237, 243, 249, 255, 261, 267, 273, 279, 285, 291, 297, 303, 309, 315, 321, 327, 333, 339, 345, 351, 357, 363, 369, 375, 381, 387, 393, 399, 405, 411, 417, 423, 429, 435, 441, 447, 453, 459, 465, 471, 477, 483, 489, 495, 501, 507]\n",
            "  Overlap 129: frequencies [6, 18, 30, 42, 54, 66, 78, 90, 102, 114, 126, 138, 150, 162, 174, 186, 198, 210, 222, 234, 246, 258, 270, 282, 294, 306, 318, 330, 342, 354, 366, 378, 390, 402, 414, 426, 438, 450, 462, 474, 486, 498, 510]\n",
            "  Overlap 65: frequencies [12, 36, 60, 84, 108, 132, 156, 180, 204, 228, 252, 276, 300, 324, 348, 372, 396, 420, 444, 468, 492]\n",
            "  Overlap 33: frequencies [24, 72, 120, 168, 216, 264, 312, 360, 408, 456, 504]\n",
            "  Overlap 17: frequencies [48, 144, 240, 336, 432]\n",
            "  Overlap 9: frequencies [96, 288, 480]\n",
            "  Overlap 5: frequencies [192]\n",
            "  Overlap 3: frequencies [384]\n",
            "\n",
            "Fundamental 5 accumulator groups:\n",
            "  Overlap 257: frequencies [15, 25, 35, 45, 55, 65, 75, 85, 95, 105, 115, 125, 135, 145, 155, 165, 175, 185, 195, 205, 215, 225, 235, 245, 255, 265, 275, 285, 295, 305, 315, 325, 335, 345, 355, 365, 375, 385, 395, 405, 415, 425, 435, 445, 455, 465, 475, 485, 495, 505]\n",
            "  Overlap 129: frequencies [10, 30, 50, 70, 90, 110, 130, 150, 170, 190, 210, 230, 250, 270, 290, 310, 330, 350, 370, 390, 410, 430, 450, 470, 490, 510]\n",
            "  Overlap 65: frequencies [20, 60, 100, 140, 180, 220, 260, 300, 340, 380, 420, 460, 500]\n",
            "  Overlap 33: frequencies [40, 120, 200, 280, 360, 440]\n",
            "  Overlap 17: frequencies [80, 240, 400]\n",
            "  Overlap 9: frequencies [160, 480]\n",
            "  Overlap 5: frequencies [320]\n",
            "\n",
            "Fundamental 7 accumulator groups:\n",
            "  Overlap 257: frequencies [21, 35, 49, 63, 77, 91, 105, 119, 133, 147, 161, 175, 189, 203, 217, 231, 245, 259, 273, 287, 301, 315, 329, 343, 357, 371, 385, 399, 413, 427, 441, 455, 469, 483, 497, 511]\n",
            "  Overlap 129: frequencies [14, 42, 70, 98, 126, 154, 182, 210, 238, 266, 294, 322, 350, 378, 406, 434, 462, 490]\n",
            "  Overlap 65: frequencies [28, 84, 140, 196, 252, 308, 364, 420, 476]\n",
            "  Overlap 33: frequencies [56, 168, 280, 392, 504]\n",
            "  Overlap 17: frequencies [112, 336]\n",
            "  Overlap 9: frequencies [224]\n",
            "  Overlap 5: frequencies [448]\n",
            "\n",
            "Fundamental 9 accumulator groups:\n",
            "  Overlap 257: frequencies [27, 45, 63, 81, 99, 117, 135, 153, 171, 189, 207, 225, 243, 261, 279, 297, 315, 333, 351, 369, 387, 405, 423, 441, 459, 477, 495]\n",
            "  Overlap 129: frequencies [18, 54, 90, 126, 162, 198, 234, 270, 306, 342, 378, 414, 450, 486]\n",
            "  Overlap 65: frequencies [36, 108, 180, 252, 324, 396, 468]\n",
            "  Overlap 33: frequencies [72, 216, 360, 504]\n",
            "  Overlap 17: frequencies [144, 432]\n",
            "  Overlap 9: frequencies [288]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def sort_symbols_by_frequency(symbolic_matrix):\n",
        "    # Create dictionary of symbol -> list of (freq_bin, real/imag) appearances\n",
        "    symbol_locations = {}\n",
        "\n",
        "    # First scan - map where each symbol appears\n",
        "    for i in range(512):  # frequency bins\n",
        "        # Real part\n",
        "        for s in symbolic_matrix[i,:]:\n",
        "            if s not in symbol_locations:\n",
        "                symbol_locations[s] = []\n",
        "            symbol_locations[s].append((i, 'real'))\n",
        "        # Imaginary part\n",
        "        for s in symbolic_matrix[i+512,:]:\n",
        "            if s not in symbol_locations:\n",
        "                symbol_locations[s] = []\n",
        "            symbol_locations[s].append((i, 'imag'))\n",
        "\n",
        "    # Sort symbols by number of appearances\n",
        "    sorted_symbols = sorted(symbol_locations.items(),\n",
        "                          key=lambda x: len(x[1]),\n",
        "                          reverse=True)\n",
        "\n",
        "    return sorted_symbols\n",
        "\n",
        "symbols = sort_symbols_by_frequency(symbolic_matrix)\n"
      ],
      "metadata": {
        "id": "rb9Axo5hsdry"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def create_accumulation_paths(symbolic_matrix):\n",
        "    symbol_paths = {}\n",
        "\n",
        "    # For each frequency bin, track its symbol chain\n",
        "    for i in range(512):\n",
        "        bin_symbols = set()\n",
        "        # Get both real and imaginary symbols\n",
        "        bin_symbols.update(symbolic_matrix[i,:])\n",
        "        bin_symbols.update(symbolic_matrix[i+512,:])\n",
        "\n",
        "        # Find harmonically related bins that share symbols\n",
        "        harmonics = [j for j in range(i+1, 512) if j % i == 0] if i > 0 else []\n",
        "\n",
        "        # Create path through shared symbols\n",
        "        symbol_paths[i] = {\n",
        "            'symbols': bin_symbols,\n",
        "            'harmonics': harmonics,\n",
        "            'shared_symbols': {}\n",
        "        }\n",
        "\n",
        "        # Track shared symbols with each harmonic\n",
        "        for h in harmonics:\n",
        "            h_symbols = set()\n",
        "            h_symbols.update(symbolic_matrix[h,:])\n",
        "            h_symbols.update(symbolic_matrix[h+512,:])\n",
        "            symbol_paths[i]['shared_symbols'][h] = bin_symbols.intersection(h_symbols)\n",
        "\n",
        "    return symbol_paths\n",
        "\n",
        "symbol_paths = create_accumulation_paths(symbolic_matrix)"
      ],
      "metadata": {
        "id": "yTdG3tPktNaM"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def create_sub_accumulators(symbol_paths):\n",
        "   # Extract numeric index from symbol name (v_n -> n)\n",
        "   def get_symbol_index(symbol):\n",
        "       return int(str(symbol).split('_')[1])\n",
        "\n",
        "   accumulators = {}\n",
        "   for freq, path_info in symbol_paths.items():\n",
        "       for harmonic, shared in path_info['shared_symbols'].items():\n",
        "           if shared:  # if there are shared symbols\n",
        "               # Convert symbols to their numeric indices for the key\n",
        "               indices = tuple(sorted(get_symbol_index(s) for s in shared))\n",
        "               if indices not in accumulators:\n",
        "                   accumulators[indices] = {'freqs': set(), 'symbols': shared}\n",
        "               accumulators[indices]['freqs'].update([freq, harmonic])\n",
        "\n",
        "   return accumulators\n",
        "\n",
        "sub_accumulators = create_sub_accumulators(symbol_paths)"
      ],
      "metadata": {
        "id": "bBo9AeRMuISe"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "def create_sub_accumulators(symbol_paths):\n",
        "    def get_symbol_index(symbol):\n",
        "        return int(str(symbol).split('_')[1])\n",
        "\n",
        "    # Create position lookup once\n",
        "    symbol_positions = {}  # symbol_idx -> list of (freq, real/imag, position)\n",
        "\n",
        "    # First pass: gather all symbol positions\n",
        "    for freq in range(512):\n",
        "        # Real part\n",
        "        for pos, symbol in enumerate(symbolic_matrix[freq,:]):\n",
        "            idx = get_symbol_index(symbol)\n",
        "            if idx not in symbol_positions:\n",
        "                symbol_positions[idx] = []\n",
        "            symbol_positions[idx].append((freq, 'real', pos))\n",
        "\n",
        "        # Imaginary part\n",
        "        for pos, symbol in enumerate(symbolic_matrix[freq+512,:]):\n",
        "            idx = get_symbol_index(symbol)\n",
        "            if idx not in symbol_positions:\n",
        "                symbol_positions[idx] = []\n",
        "            symbol_positions[idx].append((freq, 'imag', pos))\n",
        "\n",
        "    accumulators = {}\n",
        "    for freq, path_info in symbol_paths.items():\n",
        "        for harmonic, shared in path_info['shared_symbols'].items():\n",
        "            if shared:\n",
        "                indices = tuple(sorted(get_symbol_index(s) for s in shared))\n",
        "                if indices not in accumulators:\n",
        "                    positions = {get_symbol_index(s): symbol_positions[get_symbol_index(s)]\n",
        "                               for s in shared}\n",
        "                    accumulators[indices] = {\n",
        "                        'freqs': set(),\n",
        "                        'symbols': shared,\n",
        "                        'positions': positions\n",
        "                    }\n",
        "                accumulators[indices]['freqs'].update([freq, harmonic])\n",
        "\n",
        "    return accumulators, symbol_positions  # Return both structures\n",
        "\n",
        "# Now let's create both\n",
        "sub_accumulators, symbol_positions = create_sub_accumulators(symbol_paths)\n",
        "\n"
      ],
      "metadata": {
        "id": "MJYqbbSqvMA-"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "first_key = list(sub_accumulators.keys())[0]\n",
        "print(\"Structure of first accumulator:\")\n",
        "print(sub_accumulators[first_key].keys())"
      ],
      "metadata": {
        "id": "sO-5XU2KwBsR",
        "outputId": "b6b887cb-4c87-4378-bb52-a82649b2f16f",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Structure of first accumulator:\n",
            "dict_keys(['freqs', 'symbols', 'positions'])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def apply_sub_accumulators(signal, accumulators, unique_values):\n",
        "   N = len(signal)\n",
        "   results = {freq: complex(0,0) for freq in range(N)}\n",
        "\n",
        "   for indices, acc_info in accumulators.items():\n",
        "       shared_results = {}  # freq -> (real, imag)\n",
        "\n",
        "       for symbol_idx, positions in acc_info['positions'].items():\n",
        "           for freq, part, pos in positions:\n",
        "               if freq not in shared_results:\n",
        "                   shared_results[freq] = [0, 0]  # [real, imag]\n",
        "\n",
        "               twiddle = unique_values[symbol_idx]\n",
        "               value = signal[pos] * twiddle\n",
        "\n",
        "               # Apply scaling based on frequency and part\n",
        "               if freq < N//2:  # First half\n",
        "                   if part == 'real' and freq == 126:\n",
        "                       # No scaling for bin 126 real part\n",
        "                       shared_results[freq][0] += value\n",
        "                   else:\n",
        "                       # Scale by 1/2 for all other first half frequencies\n",
        "                       value = value / 2\n",
        "                       if part == 'real':\n",
        "                           shared_results[freq][0] += value\n",
        "                       else:  # 'imag'\n",
        "                           shared_results[freq][1] += value\n",
        "               else:\n",
        "                   # No scaling needed for second half\n",
        "                   if part == 'real':\n",
        "                       shared_results[freq][0] += value\n",
        "                   else:  # 'imag'\n",
        "                       shared_results[freq][1] += value\n",
        "\n",
        "       for freq in acc_info['freqs']:\n",
        "           if freq in shared_results:\n",
        "               real, imag = shared_results[freq]\n",
        "               results[freq] += complex(real, imag)\n",
        "\n",
        "   return results\n",
        "\n",
        "# Create test signal and compare\n",
        "test_signal = np.random.random(512) + 6* np.sin(np.linspace(0, 50 * np.pi, 512))\n",
        "import time\n",
        "then = time.time()\n",
        "result = apply_sub_accumulators(test_signal, sub_accumulators,unique_values)\n",
        "print(time.time() - then)\n",
        "result_array = np.array([result[i] for i in range(512)])\n",
        "\n",
        "# Compare with numpy's FFT\n",
        "np_fft = np.fft.fft(test_signal)\n",
        "\n",
        "print(\"First few frequencies comparison:\")\n",
        "print(\"Freq | Our DFT           | Numpy FFT\")\n",
        "print(\"-\" * 45)\n",
        "for i in range(5):\n",
        "   print(f\"{i:4d} | {result[i]:15.8f} | {np_fft[i]:15.8f}\")"
      ],
      "metadata": {
        "id": "9QL1hekHwN9O",
        "outputId": "cb395f2f-ef13-411e-e6b2-620ac394c88d",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1.8349359035491943\n",
            "First few frequencies comparison:\n",
            "Freq | Our DFT           | Numpy FFT\n",
            "---------------------------------------------\n",
            "   0 | 0.00000000+0.00000000j | 264.76935998+0.00000000j\n",
            "   1 | -13.42578500-16.93380713j | -9.12070970+1.81817954j\n",
            "   2 | -4.12290957+0.87634130j | -0.28303797-3.02376837j\n",
            "   3 | -2.62487292+7.58923158j | -0.66900912+2.57344230j\n",
            "   4 | -10.98215539-14.87693499j | -5.18046779-9.40886523j\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(np.argmax(np.abs(np_fft.real[0:200] - (result_array.real/2)[0:200])[1:]))\n"
      ],
      "metadata": {
        "id": "ra0zNQnZw7v4",
        "outputId": "a5ea451b-9594-42df-fd99-1e9d02e31370",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "19\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "plt.plot(np_fft.real)\n"
      ],
      "metadata": {
        "id": "jOFeO16FxWyl",
        "outputId": "3306a649-0ec6-4e29-ed53-62a0cb2f23a7",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 447
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[<matplotlib.lines.Line2D at 0x7e58c89801f0>]"
            ]
          },
          "metadata": {},
          "execution_count": 102
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "plt.plot(result_array.real)\n"
      ],
      "metadata": {
        "id": "ohUB23fb1DPK",
        "outputId": "1d75c29b-cc3e-4513-8846-bcd4aa67fa4f",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 447
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[<matplotlib.lines.Line2D at 0x7e58c8e8b040>]"
            ]
          },
          "metadata": {},
          "execution_count": 100
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def count_operations(signal, accumulators, unique_values):\n",
        "    multiplies = 0\n",
        "    additions = 0\n",
        "    memory_accesses = 0\n",
        "\n",
        "    for indices, acc_info in accumulators.items():\n",
        "        for symbol_idx, positions in acc_info['positions'].items():\n",
        "            for freq, part, pos in positions:\n",
        "                # Count each operation:\n",
        "                memory_accesses += 2  # Access signal and twiddle factor\n",
        "                multiplies += 1       # signal * twiddle\n",
        "                additions += 1        # accumulation\n",
        "\n",
        "    return {\n",
        "        'multiplies': multiplies,\n",
        "        'additions': additions,\n",
        "        'memory_accesses': memory_accesses\n",
        "    }\n",
        "\n",
        "print(count_operations(test_signal,sub_accumulators,unique_values))"
      ],
      "metadata": {
        "id": "l4xfgo4L11NK",
        "outputId": "71b43ea5-2ba1-4c46-abf5-04b7aa06e05c",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{'multiplies': 1550336, 'additions': 1550336, 'memory_accesses': 3100672}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "everything below this line is a work in process"
      ],
      "metadata": {
        "id": "NG-0lOh23rOK"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def extract_computation_sequence(accumulators, unique_values):\n",
        "   # Create parallel arrays for our computation sequence\n",
        "   positions = []\n",
        "   twiddle_factors = []\n",
        "   output_bins = []\n",
        "\n",
        "   for indices, acc_info in accumulators.items():\n",
        "       for symbol_idx, pos_list in acc_info['positions'].items():\n",
        "           twiddle = unique_values[symbol_idx]\n",
        "           for freq, part, pos in pos_list:\n",
        "               positions.append(pos)\n",
        "               twiddle_factors.append(twiddle)\n",
        "               output_bins.append(freq)\n",
        "\n",
        "   return (np.array(positions),\n",
        "           np.array(twiddle_factors, dtype=np.complex128),\n",
        "           np.array(output_bins))\n",
        "\n",
        "# Extract sequence\n",
        "pos_array, twiddle_array, bin_array = extract_computation_sequence(sub_accumulators, unique_values)\n",
        "import numba\n",
        "# Create Numba function\n",
        "@numba.jit(nopython=True)\n",
        "def ordered_dft_compute(signal, positions, twiddle_factors, output_bins):\n",
        "   results = np.zeros(512, dtype=np.complex128)\n",
        "\n",
        "   for i in range(len(positions)):\n",
        "       pos = positions[i]\n",
        "       twiddle = twiddle_factors[i]\n",
        "       bin_idx = output_bins[i]\n",
        "       results[bin_idx] += signal[pos] * twiddle\n",
        "\n",
        "   return results"
      ],
      "metadata": {
        "id": "s40T8mog25Xk"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "then = time.time()\n",
        "result = ordered_dft_compute(test_signal, pos_array, twiddle_array, bin_array)\n",
        "print(time.time() - then)"
      ],
      "metadata": {
        "id": "1aQbKdoB288J",
        "outputId": "263c442e-35f3-4725-a2ec-63fa25bbb5a6",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0.009353160858154297\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "plt.plot(result.imag)"
      ],
      "metadata": {
        "id": "vFPEXUaw3D58",
        "outputId": "1b21e136-d260-4d94-a6c5-8541c9066d52",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 447
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[<matplotlib.lines.Line2D at 0x7e58c5b8bee0>]"
            ]
          },
          "metadata": {},
          "execution_count": 118
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "def extract_hierarchical_sequence(accumulators, unique_values):\n",
        "    # Keep track of which accumulators feed into others\n",
        "    computation_groups = []\n",
        "\n",
        "    for indices, acc_info in accumulators.items():\n",
        "        group = {\n",
        "            'positions': [],\n",
        "            'twiddles': [],\n",
        "            'output_bins': [],\n",
        "            'freqs': list(acc_info['freqs'])  # frequencies this group contributes to\n",
        "        }\n",
        "\n",
        "        for symbol_idx, pos_list in acc_info['positions'].items():\n",
        "            twiddle = unique_values[symbol_idx]\n",
        "            for freq, part, pos in pos_list:\n",
        "                group['positions'].append(pos)\n",
        "                group['twiddles'].append(twiddle)\n",
        "                group['output_bins'].append(freq)\n",
        "\n",
        "        computation_groups.append(group)\n",
        "\n",
        "    return computation_groups\n",
        "\n",
        "computation_groups = extract_hierarchical_sequence(sub_accumulators, unique_values)\n",
        "\n",
        "@numba.jit(nopython=True)\n",
        "def hierarchical_dft_compute(signal, computation_groups):\n",
        "    results = np.zeros(512, dtype=np.complex128)\n",
        "\n",
        "    for group in computation_groups:\n",
        "        group_result = np.zeros(512, dtype=np.complex128)\n",
        "\n",
        "        # Compute this group's contribution\n",
        "        for i in range(len(group['positions'])):\n",
        "            pos = group['positions'][i]\n",
        "            twiddle = group['twiddles'][i]\n",
        "            bin_idx = group['output_bins'][i]\n",
        "            group_result[bin_idx] += signal[pos] * twiddle\n",
        "\n",
        "        # Apply to appropriate frequency bins\n",
        "        for freq in group['freqs']:\n",
        "            results[freq] += group_result[freq]\n",
        "\n",
        "    return results\n",
        "\n",
        "result = hierarchical_dft_compute(test_signal, computation_groups)"
      ],
      "metadata": {
        "id": "K8kN3inV3XNu",
        "outputId": "00272077-059a-4440-ee9a-11bfa6c60a08",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 530
        }
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "TypingError",
          "evalue": "Failed in nopython mode pipeline (step: nopython frontend)\nnon-precise type pyobject\nDuring: typing of argument at <ipython-input-119-f56583340b2f> (26)\n\nFile \"<ipython-input-119-f56583340b2f>\", line 26:\ndef extract_hierarchical_sequence(accumulators, unique_values):\n    <source elided>\n\n@numba.jit(nopython=True)\n^ \n\nThis error may have been caused by the following argument(s):\n- argument 1: Cannot type list element type <class 'dict'>\n",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mTypingError\u001b[0m                               Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-119-f56583340b2f>\u001b[0m in \u001b[0;36m<cell line: 46>\u001b[0;34m()\u001b[0m\n\u001b[1;32m     44\u001b[0m     \u001b[0;32mreturn\u001b[0m \u001b[0mresults\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     45\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 46\u001b[0;31m \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mhierarchical_dft_compute\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtest_signal\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcomputation_groups\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/numba/core/dispatcher.py\u001b[0m in \u001b[0;36m_compile_for_args\u001b[0;34m(self, *args, **kws)\u001b[0m\n\u001b[1;32m    421\u001b[0m                 \u001b[0me\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpatch_message\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmsg\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    422\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 423\u001b[0;31m             \u001b[0merror_rewrite\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0me\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'typing'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    424\u001b[0m         \u001b[0;32mexcept\u001b[0m \u001b[0merrors\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mUnsupportedError\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    425\u001b[0m             \u001b[0;31m# Something unsupported is present in the user code, add help info\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/numba/core/dispatcher.py\u001b[0m in \u001b[0;36merror_rewrite\u001b[0;34m(e, issue_type)\u001b[0m\n\u001b[1;32m    362\u001b[0m                 \u001b[0;32mraise\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    363\u001b[0m             \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 364\u001b[0;31m                 \u001b[0;32mraise\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mwith_traceback\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    365\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    366\u001b[0m         \u001b[0margtypes\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mTypingError\u001b[0m: Failed in nopython mode pipeline (step: nopython frontend)\nnon-precise type pyobject\nDuring: typing of argument at <ipython-input-119-f56583340b2f> (26)\n\nFile \"<ipython-input-119-f56583340b2f>\", line 26:\ndef extract_hierarchical_sequence(accumulators, unique_values):\n    <source elided>\n\n@numba.jit(nopython=True)\n^ \n\nThis error may have been caused by the following argument(s):\n- argument 1: Cannot type list element type <class 'dict'>\n"
          ]
        }
      ]
    }
  ],
  "metadata": {
    "colab": {
      "name": "Welcome To Colab",
      "toc_visible": true,
      "provenance": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}