Untitled 4.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [],
   "source": [
    "dest_arr = ['034123314233', '301421133211', '311313221022', '222204323211', \n",
    "            '331131134313', '232120324210', '232131223134', '202440121422',\n",
    "            '341013310233',  '133124120131', '212313324234', '242331120310']\n",
    "dest_arr = [[int(i) for i in da] for da in dest_arr]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from prime_sieve.array import PrimeArraySieve\n",
    "# x horizontal\n",
    "# y vertical"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define a function to split a rectangle into n sub rectangles\n",
    "import math\n",
    "def split_rectangle(x, y, n):\n",
    "    print(n)\n",
    "    # Find the best ratio of rows and columns\n",
    "    rows = round(math.sqrt(n))\n",
    "    cols = n // rows\n",
    "    if rows * cols < n:\n",
    "        cols += 1\n",
    "    # Calculate the width and height of each sub rectangle\n",
    "    width = x / cols\n",
    "    height = y / rows\n",
    "    # Create a list of sub rectangles\n",
    "    sub_rectangles = []\n",
    "    for i in range(rows):\n",
    "        for j in range(cols):\n",
    "            # Create a sub rectangle as a tuple of (x1, y1, x2, y2)\n",
    "            x1 = j * width\n",
    "            y1 = i * height\n",
    "            x2 = min((j + 1) * width, x)\n",
    "            y2 = min((i + 1) * height, y)\n",
    "            sub_rectangles.append((x1, y1, x2, y2))\n",
    "    return sub_rectangles\n",
    "# Import the modules\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib.patches import Rectangle\n",
    "import random\n",
    "\n",
    "# Define a function to plot and color the sub rectangles\n",
    "def plot_sub_rectangles(x, y, sub_rectangles):\n",
    "    # Create a figure and an axis\n",
    "    fig, ax = plt.subplots()\n",
    "    # Set the axis limits\n",
    "    ax.set_xlim(0, x)\n",
    "    ax.set_ylim(0, y)\n",
    "    # Loop through the sub rectangles\n",
    "    for sub_rectangle in sub_rectangles:\n",
    "        # Get the coordinates of the sub rectangle\n",
    "        x1, y1, x2, y2 = sub_rectangle\n",
    "        # Create a Rectangle object with a random color\n",
    "        rect = Rectangle((x1, y1), x2 - x1, y2 - y1, color=random.choice([\"red\", \"green\", \"blue\", \"yellow\", \"orange\", \"purple\"]))\n",
    "        # Add the Rectangle to the axis\n",
    "        ax.add_patch(rect)\n",
    "    plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[(0.0, 0.0, 25.5, 90.5),\n",
       " (25.5, 0.0, 51.0, 90.5),\n",
       " (0.0, 90.5, 25.5, 181.0),\n",
       " (25.5, 90.5, 51.0, 181.0)]"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "split_rectangle(51,181, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "188 48\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[(50, 187),\n",
       " (51, 184),\n",
       " (51, 185),\n",
       " (52, 181),\n",
       " (53, 176),\n",
       " (53, 177),\n",
       " (53, 178),\n",
       " (53, 179),\n",
       " (54, 173),\n",
       " (54, 175),\n",
       " (55, 171),\n",
       " (55, 172),\n",
       " (56, 167),\n",
       " (56, 169),\n",
       " (57, 164),\n",
       " (57, 166),\n",
       " (58, 161),\n",
       " (58, 163),\n",
       " (59, 159),\n",
       " (59, 160),\n",
       " (60, 157),\n",
       " (61, 154),\n",
       " (61, 155),\n",
       " (62, 151),\n",
       " (62, 153),\n",
       " (63, 149),\n",
       " (64, 147),\n",
       " (65, 144),\n",
       " (65, 146),\n",
       " (67, 140),\n",
       " (67, 141),\n",
       " (68, 139),\n",
       " (69, 136),\n",
       " (69, 137),\n",
       " (71, 132),\n",
       " (71, 133),\n",
       " (72, 131),\n",
       " (73, 129),\n",
       " (73, 130),\n",
       " (74, 127),\n",
       " (77, 122),\n",
       " (77, 123),\n",
       " (78, 121),\n",
       " (79, 119),\n",
       " (79, 120),\n",
       " (81, 116),\n",
       " (82, 115),\n",
       " (83, 113),\n",
       " (83, 114),\n",
       " (85, 111),\n",
       " (87, 109),\n",
       " (88, 107),\n",
       " (89, 106),\n",
       " (92, 103),\n",
       " (93, 101),\n",
       " (95, 99),\n",
       " (99, 95),\n",
       " (103, 92),\n",
       " (106, 89),\n",
       " (107, 88),\n",
       " (109, 87),\n",
       " (111, 85),\n",
       " (114, 83),\n",
       " (115, 82),\n",
       " (120, 79),\n",
       " (121, 78),\n",
       " (123, 77),\n",
       " (130, 73),\n",
       " (131, 72),\n",
       " (133, 71),\n",
       " (137, 69),\n",
       " (139, 68),\n",
       " (141, 67),\n",
       " (146, 65),\n",
       " (153, 62),\n",
       " (155, 61),\n",
       " (160, 59),\n",
       " (163, 58),\n",
       " (166, 57),\n",
       " (169, 56),\n",
       " (172, 55),\n",
       " (175, 54),\n",
       " (179, 53),\n",
       " (189, 50),\n",
       " (193, 49),\n",
       " (197, 48)]"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "factor(9491,200,50)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "def return_matrix(arr, factor):\n",
    "    x, y = factor\n",
    "    mat = np.zeros((x,y), dtype=np.int64)\n",
    "    for i in range(x*y):\n",
    "        mat[i%x, i%y] = arr[i]\n",
    "    return mat\n",
    "\n",
    "def sequence(prime_num):\n",
    "    m = np.arange(1,prime_num)\n",
    "    n = np.zeros(prime_num-1, dtype=np.int64)\n",
    "    for i in range(1, prime_num):\n",
    "        n[i-1] = (2 ** i) % prime_num\n",
    "    return n\n",
    "def get_well_depth(matrix, _lambda, p):\n",
    "    return matrix * (_lambda / (2 * p))\n",
    "\n",
    "def phase_change(matrix, _lambda):\n",
    "    return (2 * matrix) * ((2 * np.pi) / _lambda)\n",
    "def get_lambda(fg, mult):\n",
    "    return 343/fg * mult\n",
    "\n",
    "def pure_sine_wave(frequency, duration, sampling_rate, initial):\n",
    "    # Calculate the time array\n",
    "    time = np.linspace(0, duration, int(duration * sampling_rate)).tolist()\n",
    "    time = np.array(time[initial:]+ time[:initial])\n",
    "    # Calculate the sine wave array\n",
    "    sinewave = np.sin(2 * np.pi * frequency * time)\n",
    "    return sinewave, time\n",
    "\n",
    "def time_delay(depth): # in sec\n",
    "    c = 343\n",
    "    return (2 * depth) / c\n",
    "\n",
    "\n",
    "def return_matrix(arr, factor):\n",
    "    #x,y = (34,35) #factor(prime_num)\n",
    "    #x,y = factor(prime_num)\n",
    "    x, y = factor\n",
    "    mat2 = {}\n",
    "    mat = np.zeros((x,y), dtype=np.int64)\n",
    "    for i in range(x*y):\n",
    "        lx2 = (i%x+(i//x))%x\n",
    "        lx = ((i//x)+(i%x))%x\n",
    "        llx = i%x\n",
    "        #print(i%y, i%x, i)\n",
    "        mat[i%x, i%y] = arr[i]\n",
    "        mat2[i] = (i%x, i%y)\n",
    "    return mat, mat2\n",
    "    \n",
    "def is_prime(n):\n",
    "    if n < 2:\n",
    "        return False\n",
    "    for i in range(2, int(n**0.5) + 1):\n",
    "        if n % i == 0:\n",
    "            return False\n",
    "    return True\n",
    "\n",
    "def sequence(prime_num):\n",
    "    m = np.arange(1,prime_num)\n",
    "    n = np.zeros(prime_num-1, dtype=np.int64)\n",
    "    for i in range(1, prime_num):\n",
    "        n[i-1] = (2 ** i) % prime_num\n",
    "    return n\n",
    "\n",
    "def n_sequence(prime_num):\n",
    "    m = np.arange(1,prime_num)\n",
    "    n = np.zeros(prime_num-1, dtype=np.int64)\n",
    "    for i in range(1, prime_num):\n",
    "        n[i-1] = (i ** 2) % prime_num\n",
    "    return n\n",
    "\n",
    "def factor(n, min_x=1, max_x=1):\n",
    "    out = list()\n",
    "    lower = int(n / max_x) - 1\n",
    "    upper = int(n / min_x) + 1\n",
    "    if max_x == 1:\n",
    "        lower = 1\n",
    "    print(lower, upper)\n",
    "    for i in range(*sorted((lower, upper))):\n",
    "        if np.gcd(i, n//i) <= 1:\n",
    "            #if mi <= n//i <= ma:\n",
    "                #print(i, n//i)\n",
    "            #out.add(tuple(sorted(((n//i), i), reverse=True)))\n",
    "            out.append(((n//i), i))\n",
    "            #out.append((i, (n//i)))\n",
    "    return list(sorted(out))\n",
    "\n",
    "def get_panel_size(max_x, max_y, f_upper):\n",
    "    c = 343\n",
    "    column_width = (c / f_upper / 2) * 100\n",
    "    print((c/f_upper)/2, c/(f_upper/2), column_width)\n",
    "    print(max_x / column_width)\n",
    "    x_wells = max_x / column_width\n",
    "    y_wells = max_y / column_width\n",
    "    return {'x': x_wells, 'y': y_wells, 'area': x_wells * y_wells}\n",
    "    #return (max_x / column_width) * (max_y / column_width)\n",
    "    \n",
    "def get_highest_prime(n):\n",
    "    n_is_prime = is_prime(n)\n",
    "    while not n_is_prime:\n",
    "        n -= 1\n",
    "        print(n, is_prime(n))\n",
    "        n_is_prime = is_prime(n)\n",
    "    return n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "se = sequence(307)\n",
    "fg = 1200\n",
    "ma = return_matrix(se, (18,17))\n",
    "de = get_well_depth(ma, get_lambda(fg,1), 307)\n",
    "pa = phase_change(de, get_lambda(fg,1))\n",
    "\n",
    "test = np.random.random(441)\n",
    "conv = np.convolve(test, pa.flatten())\n",
    "norm_conv = conv / np.max(conv)\n",
    "\n",
    "y = fft(norm_conv) # FFT array\n",
    "N = len(y)  # Number of samples\n",
    "f = fftfreq(N, 1/44100)  # Frequency array\n",
    "\n",
    "# Plot the frequency spectrum\n",
    "plt.plot(f[:N//2], np.abs(y[:N//2]))  # Plot the positive frequencies\n",
    "plt.xlabel(\"Frequency (Hz)\")  # Label the x-axis\n",
    "plt.ylabel(\"Amplitude\")  # Label the y-axis\n",
    "plt.show()  # Show the plot\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.05 0.2 5.0\n",
      "40.0\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'x': 40.0, 'y': 10.0, 'area': 400.0}"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "get_panel_size(200,50,3430)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from itertools import product\n",
    "def is_prime(n):\n",
    "    if n < 2:\n",
    "        return False\n",
    "    for i in range(2, int(n**0.5) + 1):\n",
    "        if n % i == 0:\n",
    "            return False\n",
    "    return True\n",
    "\n",
    "dicti = []\n",
    "primes_up = [i for i in range(0,10001//2) if is_prime(i)]\n",
    "for i in range(2,5):\n",
    "   # for j in product(primes_up, repeat=i):\n",
    "        if 9000 <= sum(j) <= 11000:\n",
    "            dicti.append((i,j))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5 11\n"
     ]
    }
   ],
   "source": [
    "#r = factor(401, 180, 220)\n",
    "t = factor(401, 40, 60)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(44, 9)\n",
      "396\n",
      "(57, 7)\n",
      "399\n"
     ]
    }
   ],
   "source": [
    "for kkk in t:\n",
    "    print(kkk)\n",
    "    print(kkk[0]*kkk[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "mat = return_matrix(sequence(397), (44,9))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.05 0.2 5.0\n",
      "40.0\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'x': 40.0, 'y': 10.0, 'area': 400.0}"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "get_panel_size(200, 50, 3430)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1195"
      ]
     },
     "execution_count": 100,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "307*3+137*2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "prime_num = 34*35 + 1\n",
    "n = sequence(prime_num)\n",
    "#n = np.arange(1,1+144)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.05"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "343/3430/2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [],
   "source": [
    "mat, mat2 = return_matrix(n, prime_num)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[8.39630563e-05, 4.55079765e-02, 1.53232578e-02, ...,\n",
       "        2.25860621e-02, 4.16456759e-02, 2.19563392e-02],\n",
       "       [4.39126784e-02, 1.67926113e-04, 4.10159530e-02, ...,\n",
       "        2.81276238e-02, 4.51721243e-02, 3.32913518e-02],\n",
       "       [1.65827036e-02, 3.78253568e-02, 3.35852225e-04, ...,\n",
       "        2.68681780e-03, 6.25524769e-03, 4.03442485e-02],\n",
       "       ...,\n",
       "       [2.56507137e-02, 2.68681780e-03, 6.25524769e-03, ...,\n",
       "        4.19815281e-05, 3.06884971e-02, 3.31654072e-02],\n",
       "       [1.63308144e-02, 1.30142737e-03, 5.37363560e-03, ...,\n",
       "        4.29890848e-02, 8.39630563e-05, 1.13769941e-02],\n",
       "       [2.27539882e-02, 3.26616289e-02, 2.60285474e-03, ...,\n",
       "        2.08228380e-02, 3.59781696e-02, 1.67926113e-04]])"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "size = mat * ((0.1/2) / ((34*35)+1))\n",
    "size"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9001\n",
      "9007\n",
      "9011\n",
      "9013\n",
      "9029\n",
      "9041\n",
      "9043\n",
      "9049\n",
      "9059\n",
      "9067\n",
      "9091\n",
      "9103\n",
      "9109\n",
      "9127\n",
      "9133\n",
      "9137\n",
      "9151\n",
      "9157\n",
      "9161\n",
      "9173\n",
      "9181\n",
      "9187\n",
      "9199\n",
      "9203\n",
      "9209\n",
      "9221\n",
      "9227\n",
      "9239\n",
      "9241\n",
      "9257\n",
      "9277\n",
      "9281\n",
      "9283\n",
      "9293\n",
      "9311\n",
      "9319\n",
      "9323\n",
      "9337\n",
      "9341\n",
      "9343\n",
      "9349\n",
      "9371\n",
      "9377\n",
      "9391\n",
      "9397\n",
      "9403\n",
      "9413\n",
      "9419\n",
      "9421\n",
      "9431\n",
      "9433\n",
      "9437\n",
      "9439\n",
      "9461\n",
      "9463\n",
      "9467\n",
      "9473\n",
      "9479\n",
      "9491\n",
      "9497\n"
     ]
    }
   ],
   "source": [
    "ld = {}\n",
    "sieve = PrimeArraySieve()\n",
    "for k in sieve.primes_in_range(9000,9500):\n",
    "    print(k)\n",
    "    k = int(k)\n",
    "    sn = sequence(k)\n",
    "    u, c = np.unique(sn, return_counts=True)\n",
    "    if c.shape[0]-1 == sn.shape[0] or c.shape == sn.shape:\n",
    "        ld[k] = sn"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_keys([9011, 9029, 9059, 9173, 9181, 9203, 9221, 9227, 9283, 9293, 9323, 9341, 9349, 9371, 9397, 9419, 9421, 9437, 9467, 9491])"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ld.keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([   2,    4,    8, ..., 2373, 4746,    1])"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ld[9491]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "218"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(sieve.primes_in_range(9000,11000))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "83"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(ld.keys())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9001\n",
      "9007\n",
      "9011 (9010,)\n",
      "9013\n",
      "9029 (9028,)\n",
      "9041\n",
      "9043\n",
      "9049\n",
      "9059 (9058,)\n",
      "9067\n",
      "9091\n",
      "9103\n",
      "9109\n",
      "9127\n",
      "9133\n",
      "9137\n",
      "9151\n",
      "9157\n",
      "9161\n",
      "9173 (9172,)\n",
      "9181 (9180,)\n",
      "9187\n",
      "9199\n",
      "9203 (9202,)\n",
      "9209\n",
      "9221 (9220,)\n",
      "9227 (9226,)\n",
      "9239\n",
      "9241\n",
      "9257\n",
      "9277\n",
      "9281\n",
      "9283 (9282,)\n",
      "9293 (9292,)\n",
      "9311\n",
      "9319\n",
      "9323 (9322,)\n",
      "9337\n",
      "9341 (9340,)\n",
      "9343\n",
      "9349 (9348,)\n",
      "9371 (9370,)\n",
      "9377\n",
      "9391\n",
      "9397 (9396,)\n",
      "9403\n",
      "9413\n",
      "9419 (9418,)\n",
      "9421 (9420,)\n",
      "9431\n",
      "9433\n",
      "9437 (9436,)\n",
      "9439\n",
      "9461\n",
      "9463\n",
      "9467 (9466,)\n",
      "9473\n",
      "9479\n",
      "9491 (9490,)\n",
      "9497\n",
      "9511\n",
      "9521\n",
      "9533 (9532,)\n",
      "9539 (9538,)\n",
      "9547 (9546,)\n",
      "9551\n",
      "9587 (9586,)\n",
      "9601\n",
      "9613 (9612,)\n",
      "9619 (9618,)\n",
      "9623\n",
      "9629 (9628,)\n",
      "9631\n",
      "9643 (9642,)\n",
      "9649\n",
      "9661 (9660,)\n",
      "9677 (9676,)\n",
      "9679\n",
      "9689\n",
      "9697\n",
      "9719\n",
      "9721\n",
      "9733 (9732,)\n",
      "9739\n",
      "9743\n",
      "9749 (9748,)\n",
      "9767\n",
      "9769\n",
      "9781\n",
      "9787\n",
      "9791\n",
      "9803 (9802,)\n",
      "9811\n",
      "9817\n",
      "9829\n",
      "9833\n",
      "9839\n",
      "9851 (9850,)\n",
      "9857\n",
      "9859 (9858,)\n",
      "9871\n",
      "9883 (9882,)\n",
      "9887\n",
      "9901 (9900,)\n",
      "9907 (9906,)\n",
      "9923 (9922,)\n",
      "9929\n",
      "9931\n",
      "9941 (9940,)\n",
      "9949 (9948,)\n",
      "9967\n",
      "9973\n",
      "10007\n",
      "10009\n",
      "10037 (10036,)\n",
      "10039\n",
      "10061\n",
      "10067 (10066,)\n",
      "10069 (10068,)\n",
      "10079\n",
      "10091 (10090,)\n",
      "10093 (10092,)\n",
      "10099 (10098,)\n",
      "10103\n",
      "10111\n",
      "10133 (10132,)\n",
      "10139 (10138,)\n",
      "10141 (10140,)\n",
      "10151\n",
      "10159\n",
      "10163 (10162,)\n",
      "10169\n",
      "10177\n",
      "10181 (10180,)\n",
      "10193\n",
      "10211\n",
      "10223\n",
      "10243\n",
      "10247\n",
      "10253 (10252,)\n",
      "10259 (10258,)\n",
      "10267 (10266,)\n",
      "10271\n",
      "10273\n",
      "10289\n",
      "10301 (10300,)\n",
      "10303\n",
      "10313\n",
      "10321\n",
      "10331 (10330,)\n",
      "10333\n",
      "10337\n",
      "10343\n",
      "10357 (10356,)\n",
      "10369\n",
      "10391\n",
      "10399\n",
      "10427 (10426,)\n",
      "10429\n",
      "10433\n",
      "10453\n",
      "10457\n",
      "10459 (10458,)\n",
      "10463\n",
      "10477 (10476,)\n",
      "10487\n",
      "10499 (10498,)\n",
      "10501 (10500,)\n",
      "10513\n",
      "10529\n",
      "10531\n",
      "10559\n",
      "10567\n",
      "10589 (10588,)\n",
      "10597\n",
      "10601\n",
      "10607\n",
      "10613 (10612,)\n",
      "10627\n",
      "10631\n",
      "10639\n",
      "10651\n",
      "10657\n",
      "10663\n",
      "10667 (10666,)\n",
      "10687\n",
      "10691 (10690,)\n",
      "10709 (10708,)\n",
      "10711\n",
      "10723 (10722,)\n",
      "10729\n",
      "10733 (10732,)\n",
      "10739\n",
      "10753\n",
      "10771\n",
      "10781\n",
      "10789 (10788,)\n",
      "10799\n",
      "10831\n",
      "10837 (10836,)\n",
      "10847\n",
      "10853 (10852,)\n",
      "10859 (10858,)\n",
      "10861 (10860,)\n",
      "10867 (10866,)\n",
      "10883 (10882,)\n",
      "10889\n",
      "10891 (10890,)\n",
      "10903\n",
      "10909 (10908,)\n",
      "10937\n",
      "10939\n",
      "10949 (10948,)\n",
      "10957\n",
      "10973 (10972,)\n",
      "10979 (10978,)\n",
      "10987 (10986,)\n",
      "10993\n"
     ]
    }
   ],
   "source": [
    "for k in sieve.primes_in_range(9000,11000):\n",
    "    if k in ld:\n",
    "        print(k, ld[k])\n",
    "    else:\n",
    "        print(k)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 48\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[(203, 47),\n",
       " (217, 44),\n",
       " (222, 43),\n",
       " (233, 41),\n",
       " (239, 40),\n",
       " (245, 39),\n",
       " (281, 34),\n",
       " (290, 33),\n",
       " (299, 32),\n",
       " (309, 31),\n",
       " (319, 30),\n",
       " (330, 29),\n",
       " (355, 27),\n",
       " (383, 25),\n",
       " (416, 23),\n",
       " (435, 22),\n",
       " (479, 20),\n",
       " (504, 19),\n",
       " (563, 17),\n",
       " (599, 16),\n",
       " (737, 13),\n",
       " (871, 11),\n",
       " (1369, 7),\n",
       " (1597, 6),\n",
       " (1917, 5),\n",
       " (4793, 2),\n",
       " (9587, 1)]"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "factor(9587, 200)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "mat = return_matrix(sequence(9587), (203, 47))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.1994186046511628"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "343/860/2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "dn = mat[0] * (0.34 / 2 * 9587) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9586"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.max(mat[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "n1 = 9568 * (0.34 / 2 * 9587)\n",
    "n2 = 9568 * ((0.34 / 2) * 9587)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(15593830.720000003, 15593830.720000003)"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n1, n2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "15623166.940000001"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.max(dn)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [],
   "source": [
    "tester = np.interp(mat[0], (np.min(mat[0]), np.max(mat[0])), (0,41))\n",
    "for i in range(1,41):\n",
    "    bp = tester+0.5 >= i\n",
    "    bn = tester-0.5 <= i\n",
    "    boolp = np.zeros(tester.shape)\n",
    "    boolp[bp] = 1\n",
    "    boolp *= bn.astype(int)\n",
    "    for xi in range(tester.shape[0]):\n",
    "        for yi in range(tester.shape[1]):\n",
    "            if boolp[xi,yi]:\n",
    "                tester[xi,yi] = i\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20]\n",
      "[349 464 465 466 467 464 466 468 467 466 462 466 467 467 467 463 467 468\n",
      " 463 465 344]\n"
     ]
    }
   ],
   "source": [
    "u, c = np.unique(tester.astype(int)//2, return_counts=True)\n",
    "print(u)\n",
    "print(c)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}