{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Wave Divisor Function: Audio\n", "\n", "The wave divisor function consists of a pulse outline modulated with a high frequency component. The real solution of the wave divisor function is:\n", "\n", "$$ \\Re(\\sigma_{0})=\\sum_{\\mathbb{X}=2}^{\\infty}\\cos^{N} \\left( \\frac{\\pi}{\\mathbb{X}}x \\right) \\cos \\left( \\frac{N\\pi}{\\mathbb{X}}x \\right) $$\n", "\n", "$N$ is determined by the pulse width of $cos^{N}$ and calculated with ($L$ pulseheight at position $\\Delta x$). For every $\\mathbb{X}$ a $N$ is calculated, this way all waves in the summation have similar pulsewidths. N should be an positive even integer to obtain positive pulses only.\n", "\n", "More information: [Wave Divisor Function][1], [Wiki Fourier Transform][2], [Wolfram Alpha][3]\n", "\n", "[1]: https://mybinder.org/v2/gh/oooVincentooo/Shared/master?filepath=Wave%20Divisor%20Function%20rev%202.4.ipynb\n", "[2]: https://en.wikipedia.org/wiki/Fourier_transform\n", "[3]: https://www.wolframalpha.com/input/?i=Fourier+transform+exp%28a*x%5E2%29*cos%28b*x%29\n" ] }, { "cell_type": "code", "execution_count": 46, "metadata": {}, "outputs": [], "source": [ "%matplotlib widget" ] }, { "cell_type": "code", "execution_count": 47, "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "import matplotlib.pyplot as plt1\n", "import matplotlib.pyplot as plt2\n", "import ipywidgets as widgets\n", "\n", "from operator import add\n", "from IPython.display import Audio\n", "from IPython.display import display" ] }, { "cell_type": "code", "execution_count": 52, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Options:\n", "L is pulse height at dx\n", "Select number of divisors waves (use: or to select multiples.)\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "1fe2d43f8de14cc8b4c9c4d199f80e1a", "version_major": 2, "version_minor": 0 }, "text/plain": [ "interactive(children=(FloatSlider(value=0.25, description='$\\\\Delta x$:', max=0.99, min=0.15, step=0.01), Floa…" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "divisors = 125\n", "samplerate = 3000\n", "samples = int(40001 * samplerate / 3000)\n", "x1 = np.linspace(0, divisors, samples)\n", "fig, ax1 = plt1.subplots(1, figsize=(9, 4))\n", "plt1.suptitle('$\\sigma_{0}$ Wave Divisor Function')\n", "\n", "def update_plot(dx, L, wave):\n", " \n", " ax1.clear()\n", " \n", " #Set zero list\n", " y=[0]*samples\n", " \n", " #Calc Re divisor solution for all selected divisor waves\n", " for w in wave:\n", " N=-2*(w**2)*np.log(L)/((np.pi**2)*(dx**2))\n", " N=2*round(0.5*N,0)\n", " yw = ((np.cos(x1*np.pi/w))**N)*(np.cos(np.pi*N*x1/w))\n", " y=list(map(add, y, yw) )\n", " \n", " #Determine scaling for y axis (x=0 is excluded)\n", " countMax=max(y[int(samples*(2)/100):samples])\n", " countMin=min(y[int(samples*(2)/100):samples])\n", " \n", " units = '$\\Delta x$ = {}, $L$ = {}'\n", " \n", " #update graph\n", " ax1.plot(x1, y, label=units.format(dx, L))\n", " ax1.axis([0, divisors, countMin-5,countMax+5])\n", " ax1.legend(loc=1)\n", " ax1.set_xlabel('$x$')\n", " ax1.set_ylabel('$\\sigma_{0}$')\n", " ax1.grid(which='major', color='#666666', linestyle='-')\n", " plt1.show()\n", "\n", " print(\"Download WAV for playback\")\n", " display(Audio(y, rate = samplerate))\n", " \n", "print(\"Options:\")\n", "print(\"L is pulse height at dx\")\n", "print(\"Select number of divisors waves (use: or to select multiples.)\")\n", "print(\"note: initial click on t=0, summation of all all waves occur there.)\")\n", "\n", "dx = widgets.FloatSlider(min=0.15, max=0.99, value=0.25, step=0.01, description='$\\Delta x$:')\n", "L = widgets.FloatSlider(min=0.15, max=0.99, value=0.5, step=0.01, description='$L$:')\n", "wave = widgets.SelectMultiple(options=list(range(2,101)), value=list(range(2,101)), description=\"$\\mathbb{X}$:\") \n", "\n", "\n", "widgets.interactive(update_plot, dx=dx, L=L, wave=wave)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Fourier Transform Wave Divisor Function.\n", "\n", "The wave divisor function consists of a pulse outline modulated with a high frequency component. The real solution of the wave divisor function is:\n", "\n", "$$ \\Re(\\sigma_{0})=\\sum_{\\mathbb{X}=2}^{\\infty}\\cos^{N} \\left( \\frac{\\pi}{\\mathbb{X}}x \\right) \\cos \\left( \\frac{N\\pi}{\\mathbb{X}}x \\right) $$\n", "\n", "$N$ is determined by the pulse width of $cos^{N}$ and calculated with ($L$ pulseheight at position $\\Delta x$). For every $\\mathbb{X}$ a $N$ is calculated, this way all waves in the summation have similar pulsewidths. N should be an positive even integer to obtain positive pulses only:\n", "\n", "$$ N(\\mathbb{X}) = \\frac{\\log(L)}{\\log \\left( \\cos \\left( \\frac {\\pi}{\\mathbb{X} } \\Delta x \\right) \\right)} \\approx - \\frac{2 \\mathbb{X}^2 \\log(L)}{\\pi^2 \\Delta x^2} + \\frac{\\log(L)}{3}+ \\mathcal{O} \\left( \\frac{1}{\\mathbb{X}^2} \\right)$$\n", "\n", "The first term $cos^N$ can also be simplified, this is the pulse outline. The pulse outline forms a bell shaped distribution arround the origin for $\\mathbb{X} \\rightarrow \\infty$:\n", "\n", "$$ O(x)=\\lim_{\\mathbb{X} \\rightarrow \\infty}\\cos^{N} \\left( \\frac{\\pi}{\\mathbb{X}}x \\right)= e^{a x^{2}}$$\n", "\n", "$$ a=\\frac{\\log(L) \\space}{\\Delta x^{2}}=constant$$\n", "\n", "The high frequency component $HF(\\mathbb{X})$ scales linear with $\\mathbb{X}$ (see link for more information) for: $\\mathbb{X} \\rightarrow \\infty$. \n", "\n", "$$ HF(\\mathbb{X})= \\cos \\left( \\frac{N\\pi}{\\mathbb{X}} x \\right) \\approx \\cos (b x)$$\n", "\n", "$$ b(\\mathbb{X}) = \\frac{N}{\\mathbb{X}}\\pi \\approx - \\frac{2 \\space \\log(L)}{\\pi \\space \\Delta x^{2}} \\mathbb{X} = constant \\cdot \\mathbb{X}$$\n", "\n", "So for $\\mathbb{X} \\rightarrow \\infty$ the wave divisor function becomes:\n", "\n", "$$ \\Re(\\sigma_{0})\\rightarrow \\sum_{\\mathbb{X}=2}^{\\infty}e^{a x^{2}} \\cos (b x) $$\n", "\n", "The wave divisor at infinity can be Fourier transformed in the frequency domain. The following Fourier transform definitation was used:\n", "\n", "$$ \\hat{f}(\\xi)=\\int_{-\\infty}^{\\infty}f(x) \\mspace{3mu} e^{-2 \\pi ix \\xi} \\mspace{3mu} dx$$\n", "\n", "With help of Wolfram Alpha the Fourier transform is determined (see link below). The frequency spectra of an individual divisor wave will consist of a bell shape mirrored in the y-axis.\n", "\n", "$$ \\hat{\\sigma}_{0}(\\xi)= \\frac{\\sqrt{\\pi}}{2 \\sqrt{-a}} \\left( e^{(b-2 \\pi \\xi)^{2} /4a} + e^{(b+2 \\pi \\xi)^{2} /4a} \\right) $$\n", "\n", "Every number will have at least on divisor wave. Because of the linearity properties of the Fourier transform we can sum the spectra to obtain the complete spectra of a number. The simulation below shows the time domain wave and the frequency spectra. Also the wave has been transposed to an audible signal.\n", "\n", "More information: [Wave Divisor Function][1], [Wiki Fourier Transform][2], [Wolfram Alpha][3]\n", "\n", "[1]: https://mybinder.org/v2/gh/oooVincentooo/Shared/master?filepath=Wave%20Divisor%20Function%20rev%202.4.ipynb\n", "[2]: https://en.wikipedia.org/wiki/Fourier_transform\n", "[3]: https://www.wolframalpha.com/input/?i=Fourier+transform+exp%28a*x%5E2%29*cos%28b*x%29\n" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Options: L is pulse height at dx, Audio is from Real Part.\n", "Orange dot in Wave graph indicates divisor count of: x\n", "Blue line in spectrum indicates total spectrum\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "fe98ad127eb34cf6949d38475084789d", "version_major": 2, "version_minor": 0 }, "text/plain": [ "interactive(children=(Dropdown(description='$\\\\Delta x$:', index=3, options=(0.05, 0.1, 0.15, 0.2, 0.25, 0.3, …" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "#Create Plot grid\n", "fig= plt2.figure(figsize=(9, 4), constrained_layout=True)\n", "widths = [4.5,4.5]\n", "heights = [4]\n", "gs=fig.add_gridspec(1,2,width_ratios=widths, height_ratios=heights, wspace=0.05)\n", "\n", "ax1=fig.add_subplot(gs[0,0])\n", "ax2=fig.add_subplot(gs[0,1])\n", "\n", "\n", "#fig, ax2= plt2.subplots(1,2, figsize=(9, 4))\n", " \n", "def update_plot(dx2, L2, sx):\n", " \n", " xf=np.linspace(sx-0.5,sx+0.5,5000,endpoint=True)\n", " \n", " ax1.clear()\n", " ax2.clear()\n", " \n", " reD=[0]*5000\n", " #imD=[0]*2000\n", " \n", " #amplification\n", " amp=[10]*5000\n", " \n", " #Create list with waves X=2 to X=100\n", " wave2=list(range(2,101))\n", " \n", " #Calculate Solution Wave Devisor Function\n", " for w2 in wave2:\n", " \n", " N2=(np.log(L2))/(np.log(np.cos(np.pi*dx2/w2)))\n", " N2=2*round(0.5*N2,0)\n", " \n", " reDw = ((np.cos(xf*np.pi/w2))**N2)*(np.cos(np.pi*N2*xf/w2))\n", " #imDw = (-(np.cos(xf*np.pi/w2))**N2)*(np.sin(np.pi*N2*xf/w2))\n", "\n", " reD=list(map(add, reD, reDw))\n", " #imD=list(map(add, imD, imDw))\n", "\n", " #Determine maximum Divisor Count\n", " countD=max(reD)\n", "\n", " #Plot Divisor Function\n", " units2 = '$\\Delta x$={}, $L$={}, $x$={}'\n", " ax1.plot(xf, reD,color='#1f77b4', label=units2.format(dx2, L2, sx))\n", " ax1.plot([sx],[countD], color='orange', marker='o')\n", " ax1.legend(loc=2)\n", " ax1.set_title('Divisor Wave $\\sigma_{0}(x)$')\n", " ax1.set_xlabel('$x$')\n", " ax1.set_ylabel('$\\sigma_{0}$')\n", " ax1.axis([(sx-0.5), (sx+0.5), None,(countD+countD/3)])\n", " ax1.grid(which='major', color='#666666', linestyle='-')\n", " \n", " #Calculate Fourier Transform set amplitude summation 0.\n", " ampliS=[0]*10000\n", " \n", " #Maximum Frequency Range\n", " N2=-2*(sx**2)*np.log(L2)/((np.pi**2)*(dx2**2))\n", " N2=2*round(0.5*N2,0)\n", " fmax=N2/sx\n", " frange=np.linspace(-fmax,fmax,10000)\n", "\n", " #Fourier Transform Calculated. Create graph label.\n", " lab='Divisors of ' + str(sx) +':'\n", " \n", " for w2 in wave2:\n", " \n", " #Determine coeficients: a, b calculate Fourier Transform.\n", " N2=(np.log(L2))/(np.log(np.cos(np.pi*dx2/w2)))\n", " N2=2*round(0.5*N2,0)\n", " a=np.log(L2)/(dx2**2)\n", " b=np.pi*N2/w2\n", " #b=-w2*(2/np.pi)*np.log(L2)/(dx2**2)\n", " \n", " \n", " #Only add waves from divisors of x (modules).\n", " if (sx%w2)==0:\n", " Spec = (np.sqrt(np.pi))/(2*np.sqrt(-a))*(np.exp(((b-2*np.pi*frange)**2)/(4*a)) + np.exp(((b+2*np.pi*frange)**2)/(4*a)))\n", " ampliS=list(map(add, ampliS, Spec))\n", " lab=lab+'\\n $\\mathbb{X}$='+str(w2) + '$, f$='+str(np.round(0.5*N2/w2,1)) \n", " \n", " #Plot individual divisor frequencies\n", " ax2.fill_between(frange,Spec, color='orange')\n", "\n", " #Plot summation frequencies.\n", " ax2.set_title('Divisor Spectrum $\\hat{\\sigma}_{0}$')\n", " ax2.annotate(lab, xy=(fmax-fmax/3.1,0.01))\n", " ax2.plot(frange, ampliS,color='#1f77b4')\n", " ax2.set_xlabel('$Frequency$')\n", " ax2.set_ylabel('$\\hat{\\sigma}_{0}$')\n", " ax2.axis([0,fmax, 0,None]) \n", " ax2.grid(which='major', color='#666666', linestyle='-')\n", " \n", " plt2.show();\n", " \n", " \n", " #print(np.sqrt(-a*2))\n", " \n", " #Create Audiofile\n", " display(Audio(reD, rate=20000))\n", " #display(Audio(imD, rate=20000))\n", "\n", "print('Options: L is pulse height at dx, Audio is from Real Part.')\n", "print('Orange dot in Wave graph indicates divisor count of: x')\n", "print('Blue line in spectrum indicates total spectrum')\n", "\n", "dx2 = widgets.Dropdown(options=[0.05, 0.10,0.15, 0.20,0.25,0.30,0.35,0.40,0.45,0.5], value=0.2, description='$\\Delta x$:') \n", "L2 = widgets.Dropdown(options=[0.10,0.15, 0.20,0.25,0.30,0.35,0.40,0.45,0.5], value=0.5, description='$L$:') \n", "sx = widgets.Dropdown(options=list(range(2,101)), description='$x$:',value=30) \n", "\n", "widgets.interactive(update_plot, dx2=dx2, L2=L2, sx=sx)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Audio Wave Divisor Function.\n", "\n", "An movie has been created where the divisor function and audio are synchronized. The movie has been created in the range till x=1000. The displayed movie below is done with the following settings: dx=0.15, L=0.5, Rate=3000, BPM=600. For other settings see my youtube channel." ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "data": { "image/jpeg": "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\n", "text/html": [ "\n", " \n", " " ], "text/plain": [ "" ] }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from IPython.display import YouTubeVideo\n", "\n", "#Wave divisor function audio\n", "YouTubeVideo('8qtZJ6yp5D0')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Properties Frequency Spectrum (uncertainty principle).\n", "\n", "When the pulsewidth in the time domain gets smaller the frequency spectrum of the divisors tend to be identified more clear. From Fourier transform properties one would expect the frequency bandwidth to become wider as the time domain pulse gets narrow: [Uncertainty principle][1].\n", "\n", "The spectrum of the wave divisor function seems to behave opposite to the uncertainty principle. Below the [z-score][2] of the wave divisor spectra is calculated. The z-score describes the behaviour and the uncertainty principle is maintained. \n", "\n", "Time domain $f(x)$:\n", "\n", "$$ \\Re(\\sigma_{0})\\rightarrow \\sum_{\\mathbb{X}=2}^{\\infty}e^{a x^{2}} \\cos (b x) $$\n", "\n", "The pulsewidth in the time domain is determined by: $L$ pulseheight at position $\\Delta x$. In the equations described later we will vary the pulsewidth in the time domain. Onward we set $L=0.5$ as an constant and the time domain pulsewidth is varied by reducing $\\Delta x \\rightarrow 0$. \n", "\n", "$$ a=\\frac{\\log(L) }{\\Delta x^{2}}=constant$$\n", "\n", "$$ b(\\mathbb{X}) = \\frac{N}{\\mathbb{X}}\\pi \\approx - \\frac{2 \\log(L)}{\\pi \\Delta x^{2}} \\mathbb{X} = constant \\cdot \\mathbb{X}$$\n", "\n", "Frequency domain $\\hat{f} (\\xi)$:\n", "\n", "$$ \\hat{\\sigma}_{0}(\\xi)= \\frac{\\sqrt{\\pi}}{2 \\sqrt{-a}} \\left( e^{(b-2 \\pi \\xi)^{2} /4a} + e^{(b+2 \\pi \\xi)^{2} /4a} \\right) $$\n", "\n", "The frequency pulses can be seen as [normal distributions][3] . The standard deviation of a pulse in the frequency domain is proportional to:\n", "\n", "$$ Stdev(\\hat{\\sigma}_{0}(\\xi)) \\propto \\sqrt{-a}$$\n", "\n", "The minimal frequency distance between two neigbour pulses is:\n", "\n", "$$ \\Delta \\xi = b(\\mathbb{X}+1)-b(\\mathbb{X})=b(1)$$\n", "\n", "The z-score between to neighbour frequency pulses then is:\n", "\n", "$$ Z \\propto \\frac{b(1)}{\\sqrt{-a}} \\propto \\frac{1}{\\Delta x}$$\n", "\n", "When the time domain pulse gets narrow $\\Delta x \\rightarrow 0$ the $z-score$ in the frequency domain gets bigger. Thus the individual pulses in the frequency domain become better identified. One can say that the pulsewidth in frequency domain $\\sqrt{-a}$ grows more slowly then the frequency difference between two neighbour divisors $b$.\n", "\n", "\n", "More information: [Uncertainty principle][1], [z-score][2]\n", "\n", "\n", "[1]: https://en.wikipedia.org/wiki/Fourier_transform#Uncertainty_principle\n", "[2]: https://en.wikipedia.org/wiki/Standard_score\n", "[3]: https://en.wikipedia.org/wiki/Normal_distribution\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "kernelspec": { "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.9.7" }, "widgets": { "application/vnd.jupyter.widget-state+json": { "state": {}, "version_major": 2, "version_minor": 0 } } }, "nbformat": 4, "nbformat_minor": 4 }