{"nbformat_minor": 0, "worksheets": [{"cells": [{"source": ["Entropic Coding and Compression\n", "===============================\n", "\n*Important:* Please read the [installation page](http://gpeyre.github.io/numerical-tours/installation_matlab/) for details about how to install the toolboxes.\n", "$\\newcommand{\\dotp}[2]{\\langle #1, #2 \\rangle}$\n", "$\\newcommand{\\enscond}[2]{\\lbrace #1, #2 \\rbrace}$\n", "$\\newcommand{\\pd}[2]{ \\frac{ \\partial #1}{\\partial #2} }$\n", "$\\newcommand{\\umin}[1]{\\underset{#1}{\\min}\\;}$\n", "$\\newcommand{\\umax}[1]{\\underset{#1}{\\max}\\;}$\n", "$\\newcommand{\\umin}[1]{\\underset{#1}{\\min}\\;}$\n", "$\\newcommand{\\uargmin}[1]{\\underset{#1}{argmin}\\;}$\n", "$\\newcommand{\\norm}[1]{\\|#1\\|}$\n", "$\\newcommand{\\abs}[1]{\\left|#1\\right|}$\n", "$\\newcommand{\\choice}[1]{ \\left\\{  \\begin{array}{l} #1 \\end{array} \\right. }$\n", "$\\newcommand{\\pa}[1]{\\left(#1\\right)}$\n", "$\\newcommand{\\diag}[1]{{diag}\\left( #1 \\right)}$\n", "$\\newcommand{\\qandq}{\\quad\\text{and}\\quad}$\n", "$\\newcommand{\\qwhereq}{\\quad\\text{where}\\quad}$\n", "$\\newcommand{\\qifq}{ \\quad \\text{if} \\quad }$\n", "$\\newcommand{\\qarrq}{ \\quad \\Longrightarrow \\quad }$\n", "$\\newcommand{\\ZZ}{\\mathbb{Z}}$\n", "$\\newcommand{\\CC}{\\mathbb{C}}$\n", "$\\newcommand{\\RR}{\\mathbb{R}}$\n", "$\\newcommand{\\EE}{\\mathbb{E}}$\n", "$\\newcommand{\\Zz}{\\mathcal{Z}}$\n", "$\\newcommand{\\Ww}{\\mathcal{W}}$\n", "$\\newcommand{\\Vv}{\\mathcal{V}}$\n", "$\\newcommand{\\Nn}{\\mathcal{N}}$\n", "$\\newcommand{\\NN}{\\mathcal{N}}$\n", "$\\newcommand{\\Hh}{\\mathcal{H}}$\n", "$\\newcommand{\\Bb}{\\mathcal{B}}$\n", "$\\newcommand{\\Ee}{\\mathcal{E}}$\n", "$\\newcommand{\\Cc}{\\mathcal{C}}$\n", "$\\newcommand{\\Gg}{\\mathcal{G}}$\n", "$\\newcommand{\\Ss}{\\mathcal{S}}$\n", "$\\newcommand{\\Pp}{\\mathcal{P}}$\n", "$\\newcommand{\\Ff}{\\mathcal{F}}$\n", "$\\newcommand{\\Xx}{\\mathcal{X}}$\n", "$\\newcommand{\\Mm}{\\mathcal{M}}$\n", "$\\newcommand{\\Ii}{\\mathcal{I}}$\n", "$\\newcommand{\\Dd}{\\mathcal{D}}$\n", "$\\newcommand{\\Ll}{\\mathcal{L}}$\n", "$\\newcommand{\\Tt}{\\mathcal{T}}$\n", "$\\newcommand{\\si}{\\sigma}$\n", "$\\newcommand{\\al}{\\alpha}$\n", "$\\newcommand{\\la}{\\lambda}$\n", "$\\newcommand{\\ga}{\\gamma}$\n", "$\\newcommand{\\Ga}{\\Gamma}$\n", "$\\newcommand{\\La}{\\Lambda}$\n", "$\\newcommand{\\si}{\\sigma}$\n", "$\\newcommand{\\Si}{\\Sigma}$\n", "$\\newcommand{\\be}{\\beta}$\n", "$\\newcommand{\\de}{\\delta}$\n", "$\\newcommand{\\De}{\\Delta}$\n", "$\\newcommand{\\phi}{\\varphi}$\n", "$\\newcommand{\\th}{\\theta}$\n", "$\\newcommand{\\om}{\\omega}$\n", "$\\newcommand{\\Om}{\\Omega}$\n"], "metadata": {}, "cell_type": "markdown"}, {"source": ["This numerical tour studies source coding using entropic coders (Huffman and arithmetic)."], "metadata": {}, "cell_type": "markdown"}, {"collapsed": false, "outputs": [], "prompt_number": 50, "cell_type": "code", "language": "python", "metadata": {}, "input": ["warning off\n", "addpath('toolbox_signal')\n", "addpath('toolbox_general')\n", "addpath('solutions/coding_2_entropic')\n", "warning on"]}, {"source": ["Source Coding and Entropy\n", "-------------------------\n", "Entropic coding converts a vector |x| of integers into a binary stream\n", "|y|. Entropic coding exploits the\n", "redundancies in the statistical distribution of the entries of |x| to\n", "reduce as much as possible the size of |y|. The lower bound for the\n", "number of bits |p| of |y| is the Shannon bound |p=-sum_i\n", "h(i)*log2(h(i))|, where |h(i)| is the probability of apparition of\n", "symbol |i| in |x|.\n", "\n", "\n", "Fist we generate a simple binary signal |x| so that 0 has a probability\n", "of appearance of |p|.\n", "\n", "probability of 0"], "metadata": {}, "cell_type": "markdown"}, {"collapsed": false, "outputs": [], "prompt_number": 3, "cell_type": "code", "language": "python", "metadata": {}, "input": ["p = 0.1;"]}, {"source": ["size"], "metadata": {}, "cell_type": "markdown"}, {"collapsed": false, "outputs": [], "prompt_number": 4, "cell_type": "code", "language": "python", "metadata": {}, "input": ["n = 512;"]}, {"source": ["signal, should be with token 1,2"], "metadata": {}, "cell_type": "markdown"}, {"collapsed": false, "outputs": [], "prompt_number": 5, "cell_type": "code", "language": "python", "metadata": {}, "input": ["x = (rand(n,1)>p)+1;"]}, {"source": ["One can check the probabilities by computing the empirical histogram."], "metadata": {}, "cell_type": "markdown"}, {"collapsed": false, "outputs": [{"metadata": {}, "text": ["Empirical p=0.085938.\n"], "output_type": "display_data"}], "prompt_number": 6, "cell_type": "code", "language": "python", "metadata": {}, "input": ["h = hist(x, [1 2]);\n", "h = h/sum(h);\n", "disp(strcat(['Empirical p=' num2str(h(1)) '.']));"]}, {"source": ["We can compute the entropy of the distribution represented as a vector |h| of proability that should sum to 1.\n", "We take a |max| to avoid problem with 0 probabilties."], "metadata": {}, "cell_type": "markdown"}, {"collapsed": false, "outputs": [{"metadata": {}, "text": ["Entropy=0.42276\n"], "output_type": "display_data"}], "prompt_number": 7, "cell_type": "code", "language": "python", "metadata": {}, "input": ["e = - sum( h .* log2( max(h,1e-20) ) );\n", "disp( strcat(['Entropy=' num2str(e)]) );"]}, {"source": ["Huffman Coding\n", "--------------\n", "A Hufman code |C| associate with each symbol |i| in |{1,...,m}| a binary code |C{i}|\n", "whose length |length(C{i})| is as close as possible to the optimal bound\n", "|-log2(h(i))|, where |h(i)| is the probability of apparition of the\n", "symbol |i|.\n", "\n", "\n", "We select a set of proabilities."], "metadata": {}, "cell_type": "markdown"}, {"collapsed": false, "outputs": [], "prompt_number": 8, "cell_type": "code", "language": "python", "metadata": {}, "input": ["h = [.1 .15 .4 .15 .2];"]}, {"source": ["The tree |T| cotainins the codes is generated by an iterative algorithm.\n", "The initial \"tree\" is a collection of empty trees, pointing to the symbols numbers."], "metadata": {}, "cell_type": "markdown"}, {"collapsed": false, "outputs": [], "prompt_number": 9, "cell_type": "code", "language": "python", "metadata": {}, "input": ["m = length(h);\n", "T = cell(0); % create an empty cell\n", "for i=1:m\n", "    T = cell_set(T,i,i);\n", "end"]}, {"source": ["We build iteratively the Huffman tree\n", "by grouping together the two Trees that have the smallest probabilities.\n", "The merged tree has a probability which is the sums of the two selected\n", "probabilities.\n", "\n", "initial probability."], "metadata": {}, "cell_type": "markdown"}, {"collapsed": false, "outputs": [], "prompt_number": 10, "cell_type": "code", "language": "python", "metadata": {}, "input": ["p = h;"]}, {"source": ["iterative merging of the leading probabilities"], "metadata": {}, "cell_type": "markdown"}, {"collapsed": false, "outputs": [], "prompt_number": 11, "cell_type": "code", "language": "python", "metadata": {}, "input": ["while length(p)>1   \n", "    % sort in decaying order the probabilities\n", "    [v,I] = sort(p);\n", "    if v(1)>v(length(v))\n", "        v = reverse(v); I = reverse(I);\n", "    end \n", "    q = sum(v(1:2));\n", "    t = cell_sub(T, I(1:2));\n", "    % trimed tree\n", "    T = cell_sub(T, I(3:length(I)) );\n", "    p = v(3:length(v));\n", "    % add a new node with the corresponding probability\n", "    p(length(p)+1) = q;\n", "    T = cell_set(T, length(p), t);\n", "end"]}, {"source": ["We display the computed tree."], "metadata": {}, "cell_type": "markdown"}, {"collapsed": false, "outputs": [{"metadata": {}, "png": "iVBORw0KGgoAAAANSUhEUgAAAkAAAAGwCAIAAADOgk3lAAAACXBIWXMAAAsSAAALEgHS3X78AAAA\nIXRFWHRTb2Z0d2FyZQBBcnRpZmV4IEdob3N0c2NyaXB0IDguNTRTRzzSAAARIUlEQVR4nO3dzXbi\nSLaAUXxXvf8rcwdkUyo7DUKKCJ2fvQe9elKZyAnxxQkE/rrf7zcAyOb/rn4AAHCEgAGQkoABkJKA\nAZCSgAGQkoABkJKAAZCSgAGQkoABkJKAAZCSgAGQkoABkJKAAZCSgAGQkoABkJKAAZCSgAGQkoAB\nkJKAAZCSgAGQkoABkJKAAZCSgAGQkoABkJKAAZCSgAGQkoABkJKAAZCSgAGQkoABkNI/Vz8AOOvr\n68//ud8vfRzAWiYwcnvWC+hGwEjsW72+vvQMGhEwstqeHG4PDzUMmvi6e9+AbLaJ+vb89X4Y9CFg\nJPM2US/yBlTiCJE0tm9xvSiT40RowgRGDgfmKqMY1GYCI4Hf7td4zSgGtZnACG3IFOXODijJBEZc\no84An/+tD4pBJSYwIprx9pW3xKAYExjhTCrN9v0zcxgUYAIjlgXvVxnFoAYTGFHs/JjXee5OhBpM\nYIRwyVRkFIPUTGBc79jHvM4zikFqJjCuFGQG8kExyMgExmWC1Ovmg2KQkwmMC8RJ11bMRwX8RsBY\nLXgngj884MkRIktddb/Gfu7sgCxMYCySbrJxZwcEZwJjhXT1urmzA8IzgTFXxnRtZX/8UJgJjIkK\nrP6+AhjCMoExS7H3kArEGIoxgTHesq/lXcndiRCNCYzByk8q5S8QsjCBMVL8j3mdZxSDIExgjNFw\nLql3TAq5mMAYoGG9bj4oBlczgXFKz3Rt+QnAVUxgHGftvvmgGFzHBMZB3gH6Rs5hMQHjY1bqF3Qd\nlnGEyGfU6zV3dsAyJjD2kq79/KxgARMYu1iRP+LODljABMZ73tc5TPhhHhMYr5T8Wt6VfO8UzGMC\n41emh4H8MGE4Exh/1+FreVcyisFwJjC+MytM5UgWRjGB8R/qNZsPisEoJjD+kK6V/LThPBMYt5v1\ndDkfFIPzTGB4V+ZKtg5wmIC1ZvUMwh4CDnCE2Jd6xeHODjhAwJryMa9ofFAMPuUIsR2DV3COE2En\nAevF4piCTQbs4QixC1/Lm4jjRNjDBNaCHX1S/uHgBRNYfe7XyMsoBi+YwCqzfy/D8S/8ZAIrS70q\n8UEx+MkEVpB0VeVfFrZMYNVY4wrzFcCwZQIrxTslTdimwM0EVoaPebXi7kS4mcBqsB9vyz89nZnA\n0vMxr86MYnRmAkvM7psnB8g0ZALLSr3Y8kExGjKB5SNd/MZzg1YELBkrFG95ktCEI8RM3K/BHu7s\noAkTWA721Bzgzg5qM4EloF4c484OajOBhSZdnOdZRFUmsLisOwzhK4CpygQWlHcvGM6WiGJMYOH4\nWl4mcXcixZjAYrFHZgFPM2owgQXiY16sYRSjBhNYCHbEXMJhNamZwK6nXlzFB8VIzQR2JekiAs9D\nkhKwy1g1CMUTknQcIV7D/RpE484O0jGBrWafS3Du7CALE9hS6kV87uwgCwFbx7EhWThOJAVHiCsY\nvEjKcSKRCdh0lgBSs/0iLEeIE/laXgpwnEhYJrBZ7FspxlOaaExgU7hfg3qMYkRjAhvMLpXyHIwT\nhAlsJPWiAx8UIwgT2BjSRTee81zOBDaAVzINbd/fNYdxCRPYWd4PoDkbOK4iYMd53cKTnRzrOUI8\nSL1gy50drCdgR/iYF/zkg2Is5gjxMwYveMtxImuYwD6gXrCH40TWMIHtIl3wKa8aZhOw97wO4TAv\nH+ZxhPiG+zXgDHd2MI8J7Fd2jjCQOzsYzgT2d+oFY7mzg+FMYN9JF8zj9cVAJrD/8OqCqXwFMAOZ\nwP7ljB6WsVnkPAG73byW4CJ2jZzhCFG94DLu7OCM7gHzMS+4lg+KcVjfI0SDF4TiOJFPNZ3A1Aui\ncZzIp9pNYNIFkXmFsl+vgHltQApequzR6AjR/RqQhTs72KPFBGY3B0m5s4MXKgfs58at7rVCWd9e\nyF7FPHU5QnRsCEl9e+U6UeSpS8CAvLYNsxPlqXLAnk90z3hIbTt1mcB4qhywm5NDyO/nfRwaxkPx\ngAE1POqlYWwJGBCXe4l5QcCAoF5/CMwQhoABof2sl4NEHgQMiOh1nBwkchMwIKD93yBlCOtMwICg\nXtfLQSICBsSyP0gOEpsTMCCQY18/bwjrScCAcPbXy0FiZwIGRHEsQg4S2xIwIITzv7vSENaNgAGB\nHKuXg8SeBAy43iM8Zw4DNawhAQMuNio53gzr5p+rH8B4X/97Ndw9nSG88299/fXP9OrvoNoE9qjX\n/X6/3+9fjhIgiVG9cZDYSrWA3TaDl4ZBcDNeoGavPgoGDEhhxuHhX/98qqoWsO37XsYviG9GvRwk\nNlHwJo6b+zggvNlpud/Vq76v2kv811fxC4SMZh8ervxbuFC1I8SfHCRCTLO74iCxvGoBkysIbuVr\n1OxVW7WA/eQIEeK46ljPzrakgm8RbYewelcHqZ3/zsPDf+n6v5fZCt6FKFoQ01VjkDsSq6p/hAhE\ncO0Y9PhLZawYAQOmi3OIp2GVCBiwyLX1cld9PQIGzBUnGJfPf4wlYMBEcQ4Pt+I0lTMEDJguTr0c\nJFYiYMAsMSMRp6acJGDAFDEPD7di9pX9BAyYKGa9HCTWIGDAePHDELOsfETAgMHiHx5uxW8tvxEw\nYIr49XKQmJ2AASPlikH8yvKCgAHD5Do8fPA9v3kJGDBGxnptaVg6AgaMlLFe3gxLSsCAAbIv/Rm7\ni4ABZ2U/PNzKXuJWBAwYI3u9HCSmI2DAKZWW++wN7kbAgOMqHR5uVapyYQIGnFWpXg4SExEw4KCq\nS3ylHtcmYMARVQ8Pt6oWugwBA46rWi8HiSkIGPCxDst61TZXImDAZzocHm51qHVSAgYc0aFeDhKD\nEzDgA4+lvEO9HjQsMgED9uq5iPepdToCBuzS7a2vn3r2OzIBAz7Qs14OEmMSMOA9C3fPcgcnYMAb\nDg+3tDwOAQN2US8HidEIGPCKxXpLxUMRMOBXDg9/o+sRCBjwhnptOUiMQ8CAv7NA/0bRgxAw4C8c\nHu6h8dcSMOBX6vUbB4kRCBjwXbdv7D1Gwy4nYMB/WI730/hrCRjwL299HaP6lxAw4Dv12s9B4oUE\nDPjDEnyM3l9FwIDbzeHhCHYAiwkY8C/1OsZB4iUEDLDsDqD96wkYdOfwcCy7gWUEDLjd1GsEB4mL\nCRi0Zqkdyz5gJQGDvhwezmNnsICAQXfqNZaDxGUEDJqyvM5jT7CGgEFHDg9ne/xg7RKmEjBoR71W\n0rB5BAyaUq/ZvBk2m4BBLxbTlewSphIwaMTh4VXsG2YQMGhHvVZykDiPgEEXFtCr2DFMImDQgsPD\nCOwhxhIwaES9ruIgcQYBg/osmhHYPQwnYFCcw8No7CdGETBoQb0icJA4loBBZRbKaOwkBhIwKMvh\nYWT2FucJGNSkXmE5SBxFwKAy9YpJw4YQMCjIshifvcV5AgbVODzMxW7jMAGDmtQrPgeJJwkYlGIp\nzMU+4wwBgzocHuZl53GAgEE16pWLg8TDBAyKsPzlZc9xjIBBBQ4Pa7AL+YiAQR3qlZeDxAMEDNKz\n5NVg//EpAYPcHB7WY0eyk4BBBepVg4PEjwgYJPZY5tSrEg3bT8AgKwtcVXYkOwkYpOStrw7sUV4T\nMMhHvcrbHiTK2G8EDICUBAwgNHP2bwQMIDRHiL8RMEhmu5xZ2uhMwCAlx0q12ZrsIWAAQflQ82sC\nBplsv3rj8b+WttqM2i8IGEAsviFsJwEDCM2o/RsBgzR+bswtbXQmYACBOD/cT8AAojNq/5WAQQ6/\nbcwtbbQlYABRvD0/tFPZEjBIYM+yZWmrzbtiPwkYpPHbEmZpq8EW5FMCBhDI2+2Izj0JGES3f8Gy\ntNVm1P5GwCCH14uXpS07m48DBAwgip0bEbV7EDAI7dOlytJWm1F7S8AggT3LlqUtL9uOYwQMIISP\ntiCadxMwiOzYImVpq82o/SRgEN3+BcvSlpENx2ECBnC9A5sP5RMwCOrM8mRpq82o/SBgENqnS5Wl\nLRdbjTMEDOBih7cdzfsnYBDR+YWp+dJWnlH7JmAQ2bFFytKWhU3GSQIGcKWTG47OFRQwCOft75X/\n6M+hKqO2gEFBlrb4bC/OEzCAy5zcajz+87YtFDCIZdT5YfOljQ4EDGC1UduU5gQMILHOo7aAQSBj\nN+adlzY6EDCApSadHzbcqQgYRDFvAWq4tLXS9r00AYNYxi5GbZe2sGwmBhIwgNUmbSy61VHAIITZ\nS0+3pa2bnqO2gEEgM5ahnktbTLYRYwkYwFJTtxStGilgcL01i06rpa2hhqO2gEEU8xaghktbQDYQ\nwwkYwDoLNhN9SilgcLGVy02fpa2nbqO2gEEIs5eebktbNLYOMwgYwCLLthFNeilgcKX1C02Tpa2t\nVqO2gMH11iw6rZa2UGwaJhEwgBUWbyA6VFPA4DJXLTEdlrbO+ozaAgYXW7nc9Fna4rBdmEfAAKa7\nZOtQvp0CBteY9HvlP/rbqarJqC1g0EuTpS0IG4WpBAxgrks2DY+/tHZBBQwucO354fYxQF4CBu04\nRVwjwjalNgEDqKn8KaKAwWoRNubllzY6EDCA8SJsU56q7lQEDJaqupQQU5CCTiJgcIEIy4pTRLIT\nMIDBQp0fPpTcqQgYrBNzEYn5qBglVEfHEjBYLc6CEueRVGJDsIyAAYwXcHNQr6wCBotEXj4iPzbO\nC1jTIQQMloq2lER7PNnZCqwkYACDhd0WFOurgMEK8ReO+I+QM8I29QwBg3ViLiIxH1VGNgGLCRjA\nSME3BJUqK2AwXZYlI8vj5JjgZT1AwGCRyMtH5MeWhfyvJ2AAw6TYCpRprYDBXLkWi1yPlk+l6Ot+\nAgYrxF844j/CyIT/EgIGMEaiTUCN4goYTBTw90K9VWNp4ze5no2vCRjwR6WlbSXJv4qAAQyQKP+P\nh1qguwIGs2Q8P3wosLTRgYAB/8qY22uJ/YUEDOCsdOGvcYooYDBF3vPDGksbHQgYwEF5tylPqXcq\nAgbjpV4UaCJ1dx8EDGbJu0A4RSQFAQM4osD54UPenYqAwWB5lwO6yV5fAYMpsi8NThFf85OJQMAA\nDsq+TXlK2mMBg5GSLgQv1LsitlI3WMBgvNSLwlONq5hB1IMQMIAjigU+Y5UFDIbJuATsUfW6eMhb\nYgGDwfIuBz9VupZR5DwOAQP4WMm0p2uzgMEY6V78H6l9dSTtsYDBSEkXghfqXdEZQh6KgAF8pnDU\ncxVawGCAXC/7YzpcY2cZqyxgMEzGJWCPqtf1KQmPRsAAPlA+54k6LWBwVpnfC/VWoqWNA9I9hwUM\neC/d0jaceAckYAB7lQ95rt8DJ2BwSp/zw4csSxsdCBiwS59I/yTbMQkYwC5NEp7oFFHA4KCvr3bn\nhw/PC2+i1cVuxb9wAYOz4r/OOcw/bmQCBvCrbuN1LgIGBz2Xtj5rXMNLfmp1yY+LjX/JX/f4jxEA\nfjCBAZCSgAGQkoABkJKAAZCSgAGQkoABkJKAAZCSgAGQkoABkJKAAZCSgAGQkoABkJKAAZCSgAGQ\nkoABkJKAwRFfzX7V/NfG1Y9ltYaXnMU/Vz8AILrHCv745bePhvX5Rbit6vXtYuP/KwsYfKbVivb0\nXMvu93ufn0CfK73dbhn3JY4Q4TP3+z3d65zD/FtHZgID3ui5iGecSE7aTpwprt0EBuzV5w2wVoeH\nW88DhhQ/AQEDdtneytFBnyt92J6NZ7l2R4jAe63q9bjY7QjS6vITETDgjW7L97cr7XNqmu4yHSEC\n76Vb2jgjS8xMYMB76T7iyqe2n/DL8u+bI7MA8I0jRABSEjAAUhIwAFISMABSEjAAUhIwAFISMABS\nEjAAUhIwAFISMABSEjAAUhIwAFISMABSEjAAUhIwAFISMABSEjAAUvp/xKTptoyRscQAAAAASUVO\nRK5CYII=\n", "output_type": "display_data"}], "prompt_number": 12, "cell_type": "code", "language": "python", "metadata": {}, "input": ["clf;\n", "plot_hufftree(T);"]}, {"source": ["Once the tree |T| is computed, one can compute the code |C{i}|\n", "associated to each symbol |i|. This requires to perform a deep first\n", "search in the tree and stop at each node. This is a little tricky to\n", "implement in Matlab, so you can use the function |huffman_gencode|."], "metadata": {}, "cell_type": "markdown"}, {"collapsed": false, "outputs": [], "prompt_number": 13, "cell_type": "code", "language": "python", "metadata": {}, "input": ["C = huffman_gencode(T);"]}, {"source": ["display the code"], "metadata": {}, "cell_type": "markdown"}, {"collapsed": false, "outputs": [{"metadata": {}, "text": ["Code of token 1 = 1  0  0\n"], "output_type": "display_data"}], "prompt_number": 14, "cell_type": "code", "language": "python", "metadata": {}, "input": ["for i=1:size(C,1)\n", "    disp(strcat(['Code of token ' num2str(i) ' = ' num2str( cell_get(C,i) )]));\n", "end"]}, {"source": ["We draw a vector |x| according to the distribution h\n", "\n", "size of the signal"], "metadata": {}, "cell_type": "markdown"}, {"collapsed": false, "outputs": [], "prompt_number": 15, "cell_type": "code", "language": "python", "metadata": {}, "input": ["n = 1024;"]}, {"source": ["randomization"], "metadata": {}, "cell_type": "markdown"}, {"collapsed": false, "outputs": [], "prompt_number": 16, "cell_type": "code", "language": "python", "metadata": {}, "input": ["x = rand_discr(h, n);\n", "x = x(:);"]}, {"source": ["__Exercise 1__\n", "\n", "Implement the coding of the vector |x| to obtain a binary vector |y|, which corresponds to replacing\n", "each sybmol |x(i)| by the code |C{x(i)}|."], "metadata": {}, "cell_type": "markdown"}, {"collapsed": false, "outputs": [], "prompt_number": 17, "cell_type": "code", "language": "python", "metadata": {}, "input": ["exo1()"]}, {"collapsed": false, "outputs": [], "prompt_number": 18, "cell_type": "code", "language": "python", "metadata": {}, "input": ["%% Insert your code here."]}, {"source": ["Compare the length of the code with the entropy bound."], "metadata": {}, "cell_type": "markdown"}, {"collapsed": false, "outputs": [{"metadata": {}, "text": ["Entropy bound = 2197.9539.\n", "Huffman code  = 2220.\n"], "output_type": "display_data"}], "prompt_number": 19, "cell_type": "code", "language": "python", "metadata": {}, "input": ["e = - sum( h .* log2( max(h,1e-20) ) );\n", "disp( strcat(['Entropy bound = ' num2str(n*e) '.']) );\n", "disp( strcat(['Huffman code  = ' num2str(length(y)) '.']) );"]}, {"source": ["Decoding is more complicated, since it requires parsing iteratively the\n", "tree |T|.\n", "\n", "initial pointer on the tree: on the root"], "metadata": {}, "cell_type": "markdown"}, {"collapsed": false, "outputs": [], "prompt_number": 20, "cell_type": "code", "language": "python", "metadata": {}, "input": ["t = cell_get(T,1);"]}, {"source": ["initial empty decoded stream"], "metadata": {}, "cell_type": "markdown"}, {"collapsed": false, "outputs": [], "prompt_number": 21, "cell_type": "code", "language": "python", "metadata": {}, "input": ["x1 = [];"]}, {"source": ["initial stream buffer"], "metadata": {}, "cell_type": "markdown"}, {"collapsed": false, "outputs": [], "prompt_number": 22, "cell_type": "code", "language": "python", "metadata": {}, "input": ["y1 = y;\n", "while not(isempty(y1))\n", "    % go down in the tree\n", "    if y1(1)==0\n", "        t = cell_get(t,1);\n", "    else\n", "        t = cell_get(t,2);\n", "    end\n", "    % remove the symbol from the stream buffer\n", "    y1(1) = [];\n", "    if not(iscell(t))\n", "        % we are on a leaf of the tree: output symbol\n", "        x1 = [x1 t];\n", "        t = cell_get(T,1);\n", "    end\n", "end\n", "x1 = x1(:);"]}, {"source": ["We test if the decoding is correct."], "metadata": {}, "cell_type": "markdown"}, {"collapsed": false, "outputs": [{"metadata": {}, "text": ["Error (should be 0)=0.\n"], "output_type": "display_data"}], "prompt_number": 23, "cell_type": "code", "language": "python", "metadata": {}, "input": ["err = norm(x-x1);\n", "disp( strcat(['Error (should be 0)=' num2str(err) '.']) );"]}, {"source": ["Huffman Block Coding\n", "--------------------\n", "A Huffman coder is inefficient because it can distribute only an integer\n", "number of bit per symbol. In particular, distribution where one of the\n", "symbol has a large probability are not well coded using a Huffman code.\n", "This can be aleviated by replacing the set of |m| symbols by |m^q|\n", "symbols obtained by packing the symbols by blocks of |q| (here we use |m=2| for a binary alphabet). This breaks\n", "symbols with large probability into many symbols with smaller proablity,\n", "thus approaching the Shannon entropy bound.\n", "\n", "\n", "Generate a binary vector with a high probability of having 1, so that the\n", "Huffman code is not very efficient (far from Shanon bound).\n", "\n", "proability of having 1"], "metadata": {}, "cell_type": "markdown"}, {"collapsed": false, "outputs": [], "prompt_number": 24, "cell_type": "code", "language": "python", "metadata": {}, "input": ["t = .12;"]}, {"source": ["probability distriution"], "metadata": {}, "cell_type": "markdown"}, {"collapsed": false, "outputs": [], "prompt_number": 25, "cell_type": "code", "language": "python", "metadata": {}, "input": ["h = [t; 1-t];"]}, {"source": ["generate signal"], "metadata": {}, "cell_type": "markdown"}, {"collapsed": false, "outputs": [], "prompt_number": 26, "cell_type": "code", "language": "python", "metadata": {}, "input": ["n = 4096*2;\n", "x = (rand(n,1)>t)+1;"]}, {"source": ["For block of length |q=3|, create a new vector by coding each block\n", "with an integer in |1,...,m^q=2^3|. The new length of the vector is\n", "|n1/q| where |n1=ceil(n/q)*q|.\n", "\n", "block size"], "metadata": {}, "cell_type": "markdown"}, {"collapsed": false, "outputs": [], "prompt_number": 27, "cell_type": "code", "language": "python", "metadata": {}, "input": ["q = 3;"]}, {"source": ["maximum token value"], "metadata": {}, "cell_type": "markdown"}, {"collapsed": false, "outputs": [], "prompt_number": 28, "cell_type": "code", "language": "python", "metadata": {}, "input": ["m = 2;"]}, {"source": ["new size"], "metadata": {}, "cell_type": "markdown"}, {"collapsed": false, "outputs": [], "prompt_number": 29, "cell_type": "code", "language": "python", "metadata": {}, "input": ["n1 = ceil(n/q)*q;"]}, {"source": ["new vector"], "metadata": {}, "cell_type": "markdown"}, {"collapsed": false, "outputs": [], "prompt_number": 30, "cell_type": "code", "language": "python", "metadata": {}, "input": ["x1 = x;\n", "x1(length(x1)+1:n1) = 1;\n", "x1 = reshape(x1,[q n1/q]);\n", "[Y,X] = meshgrid(1:n1/q,0:q-1);\n", "x1 = sum( (x1-1) .* (m.^X), 1 )' + 1;"]}, {"source": ["We generate the probability table |H| of |x1| that represents the probability\n", "of each new block symbols in |1,...,m^q|."], "metadata": {}, "cell_type": "markdown"}, {"collapsed": false, "outputs": [], "prompt_number": 31, "cell_type": "code", "language": "python", "metadata": {}, "input": ["H = h; \n", "for i=1:q-1\n", "    Hold = H;\n", "    H = [];\n", "    for i=1:length(h)\n", "        H = [H; Hold*h(i)];\n", "    end\n", "end"]}, {"source": ["A simpler way to compute this block-histogram is to use the Kronecker product."], "metadata": {}, "cell_type": "markdown"}, {"collapsed": false, "outputs": [], "prompt_number": 32, "cell_type": "code", "language": "python", "metadata": {}, "input": ["H = h;\n", "for i=1:q-1\n", "    H = kron(H,h);\n", "end"]}, {"source": ["__Exercise 2__\n", "\n", "For various values of block size |k|, Perform the hufman coding and compute the length of the code.\n", "Compare with the entropy lower bound.\n", "ntropy bound"], "metadata": {}, "cell_type": "markdown"}, {"collapsed": false, "outputs": [{"metadata": {}, "text": ["Entropy=0.52936.\n", "Huffman(block size 1)=1\n", "Huffman(block size 2)=0.68066\n", "Huffman(block size 3)=0.57996\n", "Huffman(block size 4)=0.55396\n", "Huffman(block size 5)=0.54919\n", "Huffman(block size 6)=0.54578\n", "Huffman(block size 7)=0.552\n", "Huffman(block size 8)=0.54626\n", "Huffman(block size 9)=0.54785\n", "Huffman(block size 10)=0.5459\n"], "output_type": "display_data"}, {"metadata": {}, "png": "iVBORw0KGgoAAAANSUhEUgAAAkAAAAGwCAIAAADOgk3lAAAACXBIWXMAAAsSAAALEgHS3X78AAAA\nIXRFWHRTb2Z0d2FyZQBBcnRpZmV4IEdob3N0c2NyaXB0IDguNTRTRzzSAAASc0lEQVR4nO3d0Zaj\nthIFUJOV//9l7gMZLgMYJMBCJe298pCxjZumbR+XVIhhHMcPAETzz9s7AABXCDAAQhJgAIQkwAAI\nSYABEJIAAyAkAQZASAIMgJAEGAAhCTAAQhJgAIQkwAAISYABEJIAAyAkAQZASAIMgJAEGAAhCTAA\nQhJgAIQkwAAISYABEJIAAyAkAQZASAIMgJAEGAAhCTAAQhJgAIQkwAAISYABEJIAAyCkxgNsGD7D\n8PZOAPAD/769AyUMQgwg0ziOb+/CiS4CrLY/wzAMte1SnRyodI5VIgcqUYjv/Y0PIX4+Af4GAFzQ\nfIAB0CYBBkBIAuwFhuATOVDpHKtEDlRL2g+wcdRJD9Cg9gMMgCYJMABCEmAAhFT6ROblyXFZs6nT\nhqtNdk+1M0kL0INyFdgwDKu8KXamtz4OgPaUrsDm8igrvQ4erN4C6FOhCuxbAqXEmLXLANgqWoEt\nc2gcx6eGEC/PqwEQV+1diAfl15Rbb82rAfCuqi+nkphGq3m1VebNTzIM4+djNBJgX7gCoOoA+yQM\nCZ4OSy7izQAjwFe7X/1rVm+AnfZuSCOAntUbYJ+9rwC7pzMD0KHXmjhC1KcAVKtQBTbNTm1HBQ9q\nqd1Vo7ZDtMe3/P2E0zTYlf0HoDZvroW4e1f68OAcis/sGQChlBtC3CbT/amsbT1negygE6+txPHU\nvRILoE+1r8QBALv6CjDXVQFoRl8BBkAzBBgAIQkwAEISYACE1F2A6eMAaEN3AQZAGwQYACEJMABC\nEmAAhNRjgOnjAGhAjwEGQAMEGAAhCTAAQhJgAITUaYDp4wCIrtMAAyA6AQZASAIMgJAEGAAh9Rtg\n+jgAQus3wAAITYABENK/b+/A2rAY1xvHMXfDrE0AiKuiCmwYhuHvWanBJBUAX1RXgc0lVFZ6XYu6\nqY9DzQYQUS0V2LcESkmmYRiMHAL0ppYAmyxzSCYBcKCuALtA+QXQp+rmwLIkDjAu/yntAHaF65uL\nHWCfhEA6foA+DoDJ8tMyRJgFHkI0eAjQs9gV2PY7gtOZATpRbwUWooAF4C21VGDjOE4rcayKp4Na\nanWX2gugK7UE2Oyg8PpRROnjAIiooiHEbTIppwD4pq4K7Kzl/fq9ADSmogoMANIJMABCEmCfz58+\nDgACEWAAhCTAAAhJgAEQkgADICQB9h99HACxCDAAQhJgAIQkwAAISYABEJIA+z99HACBCDAAQhJg\nAIQkwAAISYABEJIA+4s+DoAoBBgAIQkwAEISYACEJMAACOnfrEcP3zscxnG8vTNVmPo4WvltAJqV\nEWAH6XXtSVIyb/VDV5vs7lIzUQrAgbwKbHItIbZhMwzD8VNd2ASATmQH2M38mDc/reemByx/3HTL\nKsPkGUCfCjVxfIurrGFJWQXALKMCG8fx5jTYqnI6frb0uMqdVzuljwOgftkV2COtHNesBhXnEcXt\nYwBo3lEFljXu97vxvdMCaxtpBhsBmnelC7GwZT5tOztOhyWPG/EBmIQbwToKsNo+61f5lLh7tf0W\nAHXadn1XzlJS+1xXBaByGQE2j+Al3n76bDcfAEDPzufAHmnzm0b/tu0VpytxHJS03850NmYI0INn\nmjiunbO1e9f8VHPmfftZ3x4AQA/OA2zVpH65vtm2CJ4+1ekm19o6AGhA0Tb644A5Psfr2nPeYT0O\ngJrlLSX1u/0AgCwPXw9MyAFQxsPngWmpAKCMjABbtv/NlrdM/y/DACgg70Tmz14f4Le7GmA9DoBq\nWUoKgJAEGAAhCTAAQrp7ReblP1udCQOgQnknMs+XPN7e9eRO1cR6HAB1yltKatlzuLxl+/8A8FNX\n1kIUVAC8Li/ADk5SlmoAlJR9IjMA1MAQ4jl9HAAVym6j7y29AKiTE5kBCEmAARBS9uVUtHIAUIMr\nV2TezbC258b0cQDUxhAiACHlrYX4u/0AgCwqMABCuhJgwx8fPR0AvOSBtRCHYXhwdPHbUveJu/S7\ncU59HABVubIW4vYSKo/UYXNVt/2Jp7uUvgkAbcheC/HXrRzz8yem13J/5lFN/SYAzaulieNbXGVV\nVHILoB+1BNgk6/rO4zhKLIBuZQdY7jRVSdtBxWdNfRwA1CDvROZV6/xuW0d5x42LxdoUAUKrqiBJ\nkdfEsdtz+HokLPs+tkXY67sHEMK2J65yTV2Rea4RAWheXU0cAJCo3gC7cBZzAfo4ACpxNIRY8hys\nafRvew7y8dOuHm/8EKAfV+bAfuoghFYNGnPmrR5W7RQdAA86CrDCSbBtwUg5l7m2lkgAyqirAjuO\nn917JRZAnx5o4tgdx2uYPg6AGtTbhQgABx4YQjSIB0B5KjAAQhJgAIR0JcCGPz69njusjwPgdXkB\ntttw2GeGAfCujADbvfrX7gVWAODXsocQ9RwCUANNHACEJMAu0scB8K7sAFtNd5n9AuAVGQE2z37N\nobXb1gEABeRVYOM4brNKegFQ3pW1ECUWAK/TxHGdPg6AFwkwAEI6GkLM6jA0rghASSowAEI6qsBW\nRdVu0/x0o/ILgMLuroXY+WK++jgA3mIIEYCQBBgAIQkwAELKXoljGIY7TRzL2bKUrVaza9/6Sg4e\nA0CTMgJsHMcpMK61bGy3WmXhI5uUN/VxVLZTAO3Lq8C2PYe5cbJd0v6bbdf+HJ/LH1pbngFQRqHF\nfL/F1WlFtcqqbvv1AVi5Mge2uiU9z36URncqQgCCyutC3I2cH1VFu9ce2/5cV4gG6FNGBXawlFSZ\n3opvHY/Hk2THfYyP0McBNCBcAZA9hLhdSqrM73yaXt92xqAiQIqDr/51utLEUVhKdAHQm6oDbHfQ\nEgA+F5aSeqppInHD01YOAPqUEWDLXonZ6q7jbbMmqFLOdN5N01cCz3VVAArLXonjZpfEQSztxs/B\naofTzoSYaQTgcXe7ELM2fLyjffWcBhsB+nGriSP39K/0VaNOH5z7MAAak70Sx3baySAeAOVlBNh2\njip9afke6OMAKOnuFZmN4AHwirsBBgCvEGAAhPTaShwAcEdGG/180pUV379xXRWAYvIqsN2VCaUX\nAOVdOZFZYgHwuotNHM5fBuBduhABCEmAPcx6HABlCDAAQhJgAIQkwAAISYABEJIAe54+DoACBBgA\nIQkwAEK6spTUx2pSALxNBQZASBkV2Lz4ofLrlOuqAPxaRgU255aVfAF4Xd4c2JRhq8taKsgAKO/W\n9cCWSfZUjC1ru5TnXNWC0hSgE481cQx/3HyG1S2nm5zeAkCTLrbR79Y9c0F2pwxalXcp+7CtCGuo\nw/RxAPxUXoAdj9eN43i5APq24WkaLe+9swMAxFJXG700AiBRRoCl5FbJsbsaxgkBeMvFObA67fZD\nalMESBFu0OtKgOV2upfxrZv/xT3UxwEEsvy0DBFmt5o4Pk+fBHZNDfsAQGG3TmT+vN25bjUQgG5l\nnMi8W+j8LjkSC9hxHKUXQIdquZzK8lTo7e27QgzRAvAj1XUhHsRSSpPhpJ6aTB8HwI/UUoF9Kmsg\nBKByeScyT+vtbps4nkqa9FWjHvyhAESUGmDLkbrTNeBFCwC/VtEQIgCkS63AFFWX6eMA+AUVGAAh\nZbfRZ52qBQA/kleB7Z505YRiAMq7e0HLd9dCBKBb2XNgTsa6YOrjAOBBmjgACEmAARBSdoCtWjZ0\ncADwiuy1ED866QGoQF4FthtU0iuFPg6AZ2WfyCyuAKhBRgU2XUvld7sCAOl0IQIQUkaAGTwEoB7Z\nS0l9G0UUb6dcVwXgQYYQAQgp7zyw3+0HAGRRgQEQ0gNt9NrrASjvfAjR4ocP0scB8JRnhhBNjwFQ\n2HkFNofTVHvdzKplAZf1VLsXfd4tB6UpQA/KNXFsp8rSRyONWwKwUrqNflXPnTp9mHoLoE95q9Ef\nxMlxkHzbcHdgMOXHxaWPA+AR2UtJ3bHMqvnymCmPP37k5Xm1V0w7K8MAbsq+HtinmpDYXZvxuKQD\noBktXNByVaitMmyVcK/v//TzWxwcBWILN2tzpQKryumw5OuJBRDCwVf/OgUOsNDJpJUD4KbsC1qG\niOUQpgwD4JorXYiPrH8hCAG4o9BKHN+qtzvDgN+W9gg0tKgIA7is9EocB4VXbvxMLRvRKzmTYQDX\nlFsLcZtM9xNx9QzjOAYqvwC440oX4lz0TDVQVs107d5rd0WhCAO4IK8C2x2yiz6IVwOTYQC5MgJs\nWXjNN+qtB+AV2XNgDQzZ1UkRBpClXBMHADxIgFVEEQaQLjvAds8d5ikyDCBR9lqIn701pUyMAVBY\nXgW2e6aw9HqWIgwgReArMjfMqc0ApzRxABCSAKuUgUSAYwKsXjIM4IAAAyAkAVY1RRjANwIMgJAE\nWO0UYQC7BFgAMgxgS4ABEJIAi0ERBrAiwMKQYQBLAgyAkARYJIowgJkAC0aGAUyuXE7lp5aXeM66\nbsswDK7zAtCPiiqwYRiGv4uLIbnWSH9kAxRhAJ8KK7C5ikrMpK6iC4BZLRXYtxw6zqdu00sRBlBL\ngE2Wk1gpE1rjH7/cqUrJMKBzdQUYACSqbg7scathxpbKtakIa+gXAt4UblKm/QBrKbG2ZBjwlOWn\nZYgwM4QIQEgCLDzdHECf6g2wEAVsJWQY0KFaAmwae92GVtszWABcVl0Tx0HhNd0l0nbp5gB6U0sF\n9tlLJlkFwDd1VWDHiXVwr6j7KMKAzlRUgXGfbg6gHwIMgJAEWGsUYUAnBFiDZBjQAwEGQEgCrE2K\nMKB5AqxZMgxomwADICQB1jJFGNAwAQZASAKscYowoFUCrH0yDGiSAAMgJAHWBUUY0B4B1gsZBjRG\ngAEQkgDriCIMaIkAAyAkAdYXRRjQDAHWHRkGtEGAARCSAOuRIgxogADrlAwDohNgAIT0b+GfNyy+\n9o/jeHOTYa+ISHxapiLM0QKCKleBDcOwypvd+Lm5CVkMJAJxla7A5vIoPYqON1FvAfSpUAX2La4O\nYuzCJlygCAOCKtrEsayWEiunlE2GhZt7CEAUgbsQp7gySXbfVIQ5ckAspefAfmE1STYMw7JWW0Wa\nObMDmhKhZ+EKgPABthpj3P4BJFaK+SBNx88xgw4dfPWvU+AAk0y/MB3U+aXrGAPVChxg/I6CDKjf\nawF2oT4NUdI2RkEGVKtQF+I03Jc1QXW6ybd1OgwtPm4c//tPsyJQjzfXQty9axs/3zaZWjaUZSUp\nyIB6lDsPbJtMp6XS6Sbbfyq/ClCQATUoWoEdp8vuvRdCjmIUZMCLdCFyl5ZF4BUCjMcoyICSBBgP\nU5ABZQgwfmVZkIkx4HECjN8yrgj8iACjBOOKwOMEGEUpyICnCDBeoCAD7hNgvElBBlwmwHifggy4\nQIBRkVVBtrwRYEWAUZ1VjG3XCxZpwEeAUa1ptfvdrEpfAl/UvcW8JgUIsBcMw2AR/TTD57N7jYLk\n7dOiroG/xisvqpTDe/yY8kfeu68lAoyWJX5Spedcb20mv46f0yPfz6HmAgEG2TmXdRnPyj+C362Q\nTp+/h4Tr7VvRgwQYpLr2EXPtotUPfpzVNoiX5X7CfdbnaWT/wmUuO/7sT3niz1r3K+Pz+Xw+jQ8H\nD654T1QPvjG9C24ezIgH8JnXT+X50HiAQQ+MQaX71trKUpQmUgEGQEj/vL0DAHCFAAMgJAEGQEgC\nDICQBBgAITmRuajVeWlaQE9NR8yBOrZ8XTlW33j3HTteJbLO15gKrJztWdXOs+a+1avIi2qXd9+x\ng6MxDEO1rzEVWCHzn3z+8jLdYm3sA/W8T6q1qlAdsV3efQcSXzN1vsZUYEUt3y3eOcd8uJzajq9O\n/1/VR0w9vPu2Tl8q3x5QyWtMBQZN8dFMusS6apX9laTXR4AV42Mli/IrS50T7PWYPnOXLyrNQW0w\nhPgab6Fv6vl+F0K1E+xVmQdX55YEb70GCLB3eAsdc2SyjH9M/5RhW7oQm2QIsTTRdczgYa5q5yfq\nsX3T6UJsgwArZ9vLy65vX5YdN54i6dsgwIryEQyEVlXwmwMrpKq/es3Gvy1vfHfHKrQ968vLLJED\nlejbmYWVvB9VYEXtvm0qeSkQl1X+js1t9NvbX9mfiOqMfBUYBLb9CPahvMuBuqzmQ6cJB4CQVGAA\nhCTAAAhJgAEQkgADICQBBkBIAgyAkAQYACEJMABCEmDwvt2FjoBj1kKEFyzjymo4cI0Ag6JcGhie\nIsDgBdurAwO5zIFBObuXljaECNcIMABCEmAAhCTAAAhJgEE503TXqmtDEwdcowsRXiC04D4VGBS1\n7TnUhQjXqMCgNIkFj1CBARCSAAMgJAEGQEiD4XgAIlKBARDS/wCk8/6iFRD0CAAAAABJRU5ErkJg\ngg==\n", "output_type": "display_data"}], "prompt_number": 33, "cell_type": "code", "language": "python", "metadata": {}, "input": ["exo2()"]}, {"collapsed": false, "outputs": [], "prompt_number": 34, "cell_type": "code", "language": "python", "metadata": {}, "input": ["%% Insert your code here."]}, {"source": ["Arithmetic Coding\n", "-----------------\n", "A block coder is able to reach the Shannon bound, but requires the use of\n", "many symbols, thus making the coding process slow and memory intensive.\n", "A better alternative is the use of an arithmetic coder, that encode a\n", "stream using an interval.\n", "\n", "\n", "Note : for this particular implementation of\n", "an arithmetic coder, the entries of this binary stream are packed by group of 8 bits so\n", "that each |y(i)| is in [0,255].\n", "\n", "\n", "Generate a random binary signal.\n", "\n", "probability of 0"], "metadata": {}, "cell_type": "markdown"}, {"collapsed": false, "outputs": [], "prompt_number": 35, "cell_type": "code", "language": "python", "metadata": {}, "input": ["p = 0.1;"]}, {"source": ["size"], "metadata": {}, "cell_type": "markdown"}, {"collapsed": false, "outputs": [], "prompt_number": 36, "cell_type": "code", "language": "python", "metadata": {}, "input": ["n = 512;"]}, {"source": ["signal, should be with token 1,2"], "metadata": {}, "cell_type": "markdown"}, {"collapsed": false, "outputs": [], "prompt_number": 37, "cell_type": "code", "language": "python", "metadata": {}, "input": ["x = (rand(n,1)>p)+1;"]}, {"source": ["The coding is performed using the function |perform_arith_fixed|.\n", "\n", "probability distribution"], "metadata": {}, "cell_type": "markdown"}, {"collapsed": false, "outputs": [], "prompt_number": 38, "cell_type": "code", "language": "python", "metadata": {}, "input": ["h = [p 1-p];"]}, {"source": ["coding"], "metadata": {}, "cell_type": "markdown"}, {"collapsed": false, "outputs": [{"metadata": {}, "text": ["[\bWarning: BITCMP(A,N) will not accept integer valued input N in a future\n", "release. Use BITCMP(A,ASSUMEDTYPE) instead.]\b \n", "[\b> In perform_arith_fixed>arithenco at 117\n", "  In perform_arith_fixed at 23\n", "  In pymat_eval at 38\n", "  In matlabserver at 27]\b \n", "[\bWarning: BITCMP(A,N) will not accept integer valued input N in a future\n", "release. Use BITCMP(A,ASSUMEDTYPE) instead.]\b \n", "[\b> In perform_arith_fixed>arithenco at 117\n", "  In perform_arith_fixed at 23\n", "  In pymat_eval at 38\n", "  In matlabserver at 27]\b \n", "[\bWarning: BITCMP(A,N) will not accept integer valued input N in a future\n", "release. Use BITCMP(A,ASSUMEDTYPE) instead.]\b \n", "[\b> In perform_arith_fixed>arithenco at 117\n", "  In perform_arith_fixed at 23\n", "  In pymat_eval at 38\n", "  In matlabserver at 27]\b \n", "[\bWarning: BITCMP(A,N) will not accept integer valued input N in a future\n", "release. Use BITCMP(A,ASSUMEDTYPE) instead.]\b \n", "[\b> In perform_arith_fixed>arithenco at 117\n", "  In perform_arith_fixed at 23\n", "  In pymat_eval at 38\n", "  In matlabserver at 27]\b \n", "[\bWarning: BITCMP(A,N) will not accept integer valued input N in a future\n", "release. Use BITCMP(A,ASSUMEDTYPE) instead.]\b \n", "[\b> In perform_arith_fixed>arithenco at 117\n", "  In perform_arith_fixed at 23\n", "  In pymat_eval at 38\n", "  In matlabserver at 27]\b \n", "[\bWarning: BITCMP(A,N) will not accept integer valued input N in a future\n", "release. Use BITCMP(A,ASSUMEDTYPE) instead.]\b \n", "[\b> In perform_arith_fixed>arithenco at 117\n", "  In perform_arith_fixed at 23\n", "  In pymat_eval at 38\n", "  In matlabserver at 27]\b \n", "[\bWarning: BITCMP(A,N) will not accept integer valued input N in a future\n", "release. Use BITCMP(A,ASSUMEDTYPE) instead.]\b \n", "[\b> In perform_arith_fixed>arithenco at 117\n", "  In perform_arith_fixed at 23\n", "  In pymat_eval at 38\n", "  In matlabserver at 27]\b \n", "[\bWarning: BITCMP(A,N) will not accept integer valued input N in a future\n", "release. Use BITCMP(A,ASSUMEDTYPE) instead.]\b \n", "[\b> In perform_arith_fixed>arithenco at 117\n", "  In perform_arith_fixed at 23\n", "  In pymat_eval at 38\n", "  In matlabserver at 27]\b \n", "[\bWarning: BITCMP(A,N) will not accept integer valued input N in a future\n", "release. Use BITCMP(A,ASSUMEDTYPE) instead.]\b \n", "[\b> In perform_arith_fixed>arithenco at 117\n", "  In perform_arith_fixed at 23\n", "  In pymat_eval at 38\n", "  In matlabserver at 27]\b \n", "[\bWarning: BITCMP(A,N) will not accept integer valued input N in a future\n", "release. Use BITCMP(A,ASSUMEDTYPE) instead.]\b \n", "[\b> In perform_arith_fixed>arithenco at 117\n", "  In perform_arith_fixed at 23\n", "  In pymat_eval at 38\n", "  In matlabserver at 27]\b \n", "[\bWarning: BITCMP(A,N) will not accept integer valued input N in a future\n", "release. Use BITCMP(A,ASSUMEDTYPE) instead.]\b \n", "[\b> In perform_arith_fixed>arithenco at 117\n", "  In perform_arith_fixed at 23\n", "  In pymat_eval at 38\n", "  In matlabserver at 27]\b \n", "[\bWarning: BITCMP(A,N) will not accept integer valued input N in a future\n", "release. Use BITCMP(A,ASSUMEDTYPE) instead.]\b \n", "[\b> In perform_arith_fixed>arithenco at 117\n", "  In perform_arith_fixed at 23\n", "  In pymat_eval at 38\n", "  In matlabserver at 27]\b \n", "[\bWarning: BITCMP(A,N) will not accept integer valued input N in a future\n", "release. Use BITCMP(A,ASSUMEDTYPE) instead.]\b \n", "[\b> In perform_arith_fixed>arithenco at 117\n", "  In perform_arith_fixed at 23\n", "  In pymat_eval at 38\n", "  In matlabserver at 27]\b \n", "[\bWarning: BITCMP(A,N) will not accept integer valued input N in a future\n", "release. Use BITCMP(A,ASSUMEDTYPE) instead.]\b \n", "[\b> In perform_arith_fixed>arithenco at 117\n", "  In perform_arith_fixed at 23\n", "  In pymat_eval at 38\n", "  In matlabserver at 27]\b \n", "[\bWarning: BITCMP(A,N) will not accept integer valued input N in a future\n", "release. Use BITCMP(A,ASSUMEDTYPE) instead.]\b \n", "[\b> In perform_arith_fixed>arithenco at 117\n", "  In perform_arith_fixed at 23\n", "  In pymat_eval at 38\n", "  In matlabserver at 27]\b \n", "[\bWarning: BITCMP(A,N) will not accept integer valued input N in a future\n", "release. Use BITCMP(A,ASSUMEDTYPE) instead.]\b \n", "[\b> In perform_arith_fixed>arithenco at 117\n", "  In perform_arith_fixed at 23\n", "  In pymat_eval at 38\n", "  In matlabserver at 27]\b \n", "[\bWarning: BITCMP(A,N) will not accept integer valued input N in a future\n", "release. Use BITCMP(A,ASSUMEDTYPE) instead.]\b \n", "[\b> In perform_arith_fixed>arithenco at 117\n", "  In perform_arith_fixed at 23\n", "  In pymat_eval at 38\n", "  In matlabserver at 27]\b \n", "[\bWarning: BITCMP(A,N) will not accept integer valued input N in a future\n", "release. Use BITCMP(A,ASSUMEDTYPE) instead.]\b \n", "[\b> In perform_arith_fixed>arithenco at 117\n", "  In perform_arith_fixed at 23\n", "  In pymat_eval at 38\n", "  In matlabserver at 27]\b \n", "[\bWarning: BITCMP(A,N) will not accept integer valued input N in a future\n", "release. Use BITCMP(A,ASSUMEDTYPE) instead.]\b \n", "[\b> In perform_arith_fixed>arithenco at 117\n", "  In perform_arith_fixed at 23\n", "  In pymat_eval at 38\n", "  In matlabserver at 27]\b \n", "[\bWarning: BITCMP(A,N) will not accept integer valued input N in a future\n", "release. Use BITCMP(A,ASSUMEDTYPE) instead.]\b \n", "[\b> In perform_arith_fixed>arithenco at 117\n", "  In perform_arith_fixed at 23\n", "  In pymat_eval at 38\n", "  In matlabserver at 27]\b \n", "[\bWarning: BITCMP(A,N) will not accept integer valued input N in a future\n", "release. Use BITCMP(A,ASSUMEDTYPE) instead.]\b \n", "[\b> In perform_arith_fixed>arithenco at 117\n", "  In perform_arith_fixed at 23\n", "  In pymat_eval at 38\n", "  In matlabserver at 27]\b \n", "[\bWarning: BITCMP(A,N) will not accept integer valued input N in a future\n", "release. Use BITCMP(A,ASSUMEDTYPE) instead.]\b \n", "[\b> In perform_arith_fixed>arithenco at 117\n", "  In perform_arith_fixed at 23\n", "  In pymat_eval at 38\n", "  In matlabserver at 27]\b \n", "[\bWarning: BITCMP(A,N) will not accept integer valued input N in a future\n", "release. Use BITCMP(A,ASSUMEDTYPE) instead.]\b \n", "[\b> In perform_arith_fixed>arithenco at 117\n", "  In perform_arith_fixed at 23\n", "  In pymat_eval at 38\n", "  In matlabserver at 27]\b \n", "[\bWarning: BITCMP(A,N) will not accept integer valued input N in a future\n", "release. Use BITCMP(A,ASSUMEDTYPE) instead.]\b \n", "[\b> In perform_arith_fixed>arithenco at 117\n", "  In perform_arith_fixed at 23\n", "  In pymat_eval at 38\n", "  In matlabserver at 27]\b \n", "[\bWarning: BITCMP(A,N) will not accept integer valued input N in a future\n", "release. Use BITCMP(A,ASSUMEDTYPE) instead.]\b \n", "[\b> In perform_arith_fixed>arithenco at 117\n", "  In perform_arith_fixed at 23\n", "  In pymat_eval at 38\n", "  In matlabserver at 27]\b \n", "[\bWarning: BITCMP(A,N) will not accept integer valued input N in a future\n", "release. Use BITCMP(A,ASSUMEDTYPE) instead.]\b \n", "[\b> In perform_arith_fixed>arithenco at 117\n", "  In perform_arith_fixed at 23\n", "  In pymat_eval at 38\n", "  In matlabserver at 27]\b \n", "[\bWarning: BITCMP(A,N) will not accept integer valued input N in a future\n", "release. Use BITCMP(A,ASSUMEDTYPE) instead.]\b \n", "[\b> In perform_arith_fixed>arithenco at 117\n", "  In perform_arith_fixed at 23\n", "  In pymat_eval at 38\n", "  In matlabserver at 27]\b \n", "[\bWarning: BITCMP(A,N) will not accept integer valued input N in a future\n", "release. Use BITCMP(A,ASSUMEDTYPE) instead.]\b \n", "[\b> In perform_arith_fixed>arithenco at 117\n", "  In perform_arith_fixed at 23\n", "  In pymat_eval at 38\n", "  In matlabserver at 27]\b \n", "[\bWarning: BITCMP(A,N) will not accept integer valued input N in a future\n", "release. Use BITCMP(A,ASSUMEDTYPE) instead.]\b \n", "[\b> In perform_arith_fixed>arithenco at 117\n", "  In perform_arith_fixed at 23\n", "  In pymat_eval at 38\n", "  In matlabserver at 27]\b \n", "[\bWarning: BITCMP(A,N) will not accept integer valued input N in a future\n", "release. Use BITCMP(A,ASSUMEDTYPE) instead.]\b \n", "[\b> In perform_arith_fixed>arithenco at 117\n", "  In perform_arith_fixed at 23\n", "  In pymat_eval at 38\n", "  In matlabserver at 27]\b \n", "[\bWarning: BITCMP(A,N) will not accept integer valued input N in a future\n", "release. Use BITCMP(A,ASSUMEDTYPE) instead.]\b \n", "[\b> In perform_arith_fixed>arithenco at 117\n", "  In perform_arith_fixed at 23\n", "  In pymat_eval at 38\n", "  In matlabserver at 27]\b \n", "[\bWarning: BITCMP(A,N) will not accept integer valued input N in a future\n", "release. Use BITCMP(A,ASSUMEDTYPE) instead.]\b \n", "[\b> In perform_arith_fixed>arithenco at 117\n", "  In perform_arith_fixed at 23\n", "  In pymat_eval at 38\n", "  In matlabserver at 27]\b \n", "[\bWarning: BITCMP(A,N) will not accept integer valued input N in a future\n", "release. Use BITCMP(A,ASSUMEDTYPE) instead.]\b \n", "[\b> In perform_arith_fixed>arithenco at 117\n", "  In perform_arith_fixed at 23\n", "  In pymat_eval at 38\n", "  In matlabserver at 27]\b \n", "[\bWarning: BITCMP(A,N) will not accept integer valued input N in a future\n", "release. Use BITCMP(A,ASSUMEDTYPE) instead.]\b \n", "[\b> In perform_arith_fixed>arithenco at 117\n", "  In perform_arith_fixed at 23\n", "  In pymat_eval at 38\n", "  In matlabserver at 27]\b \n", "[\bWarning: BITCMP(A,N) will not accept integer valued input N in a future\n", "release. Use BITCMP(A,ASSUMEDTYPE) instead.]\b \n", "[\b> In perform_arith_fixed>arithenco at 117\n", "  In perform_arith_fixed at 23\n", "  In pymat_eval at 38\n", "  In matlabserver at 27]\b \n", "[\bWarning: BITCMP(A,N) will not accept integer valued input N in a future\n", "release. Use BITCMP(A,ASSUMEDTYPE) instead.]\b \n", "[\b> In perform_arith_fixed>arithenco at 117\n", "  In perform_arith_fixed at 23\n", "  In pymat_eval at 38\n", "  In matlabserver at 27]\b \n", "[\bWarning: BITCMP(A,N) will not accept integer valued input N in a future\n", "release. Use BITCMP(A,ASSUMEDTYPE) instead.]\b \n", "[\b> In perform_arith_fixed>arithenco at 117\n", "  In perform_arith_fixed at 23\n", "  In pymat_eval at 38\n", "  In matlabserver at 27]\b \n", "[\bWarning: BITCMP(A,N) will not accept integer valued input N in a future\n", "release. Use BITCMP(A,ASSUMEDTYPE) instead.]\b \n", "[\b> In perform_arith_fixed>arithenco at 161\n", "  In perform_arith_fixed at 23\n", "  In pymat_eval at 38\n", "  In matlabserver at 27]\b \n"], "output_type": "display_data"}], "prompt_number": 39, "cell_type": "code", "language": "python", "metadata": {}, "input": ["y = perform_arith_fixed(x,h);"]}, {"source": ["de-coding"], "metadata": {}, "cell_type": "markdown"}, {"collapsed": false, "outputs": [], "prompt_number": 40, "cell_type": "code", "language": "python", "metadata": {}, "input": ["x1 = perform_arith_fixed(y,h,n);"]}, {"source": ["see if everything is fine"], "metadata": {}, "cell_type": "markdown"}, {"collapsed": false, "outputs": [{"metadata": {}, "text": ["Decoding error (should be 0)=0.\n"], "output_type": "display_data"}], "prompt_number": 41, "cell_type": "code", "language": "python", "metadata": {}, "input": ["disp(strcat(['Decoding error (should be 0)=' num2str(norm(x-x1)) '.']));"]}, {"source": ["__Exercise 3__\n", "\n", "Compare the average number of bits per symbol generated by the arithmetic coder\n", "and the Shanon bound.\n", "omparison with entropy bound"], "metadata": {}, "cell_type": "markdown"}, {"collapsed": false, "outputs": [{"metadata": {}, "text": ["Entropy=0.469, arithmetic=0.467.\n"], "output_type": "display_data"}], "prompt_number": 42, "cell_type": "code", "language": "python", "metadata": {}, "input": ["exo3()"]}, {"collapsed": false, "outputs": [], "prompt_number": 43, "cell_type": "code", "language": "python", "metadata": {}, "input": ["%% Insert your code here."]}, {"source": ["We can generate a more complex integer signal"], "metadata": {}, "cell_type": "markdown"}, {"collapsed": false, "outputs": [], "prompt_number": 44, "cell_type": "code", "language": "python", "metadata": {}, "input": ["n = 4096;"]}, {"source": ["this is an example of probability distribution"], "metadata": {}, "cell_type": "markdown"}, {"collapsed": false, "outputs": [], "prompt_number": 45, "cell_type": "code", "language": "python", "metadata": {}, "input": ["q = 10;\n", "h = 1:q; h = h/sum(h);"]}, {"source": ["draw according to the distribution h"], "metadata": {}, "cell_type": "markdown"}, {"collapsed": false, "outputs": [], "prompt_number": 46, "cell_type": "code", "language": "python", "metadata": {}, "input": ["x = rand_discr(h, n);"]}, {"source": ["check we have the correct distribution"], "metadata": {}, "cell_type": "markdown"}, {"collapsed": false, "outputs": [{"metadata": {}, "png": "iVBORw0KGgoAAAANSUhEUgAAAkAAAAGwCAIAAADOgk3lAAAACXBIWXMAAAsSAAALEgHS3X78AAAA\nIXRFWHRTb2Z0d2FyZQBBcnRpZmV4IEdob3N0c2NyaXB0IDguNTRTRzzSAAASYElEQVR4nO3dXbaj\nthIGULgrA85QMmPuAysOjQBjjKUqsfdTt39Ax2A+lyTL4zRNAwBk87/WDQCAKwQYACkJMABSEmAA\npCTAAEhJgAGQkgADICUBBkBKAgyAlAQYACkJMABSEmAApCTAAEhJgAGQkgADIKW/WjcAzhrH8e1j\n2v6+3dzCuQ3Lf8ff+I+2CT+lAgMgJRUYaayKg+AVw6cNe/vn/OIvXe407CsJe1RgAKQkwOAnxnE8\nM2jXcIOVtw+304VIb17dYuU/Nh9W3vhy3Kv26eV+b+PL28dxfNvygwYsH3n8V5c7/ajNe5s6aC3c\nTgVGny4UE+VTDjbyZXqd2cItf8I3zrT5wt8Fd1GB0afLdcBmYXRmL5dn+e/NjD/zJ5QNOCinzux0\ntbWheEHK7X/0isGNVGAwDPv5sXlR3rzu1+86q9CAt4H6aeLCjVRg8J/f1RDzWFHwqf+QiwCDSsqu\nNkkG3xBg8J86ifLqnDw5XgVsMgbGE+11Fa5u3/tq1Obw2HH34y++ZbXZgINE/HJaozkaRKMC4ymO\nr7+v7zPV/CrY5gM+qslumYu/udNrLwjUpAKjf5tX58sPe9310STAzY1/OYWvbMDxBj/6Ay88HirT\nBQ9ASiowAFISYACkJMAASEmAAZCSAAMgJQEGQEoCDICUBBgAKQkwAFISYACkJMAASEmAAZCSAAMg\nJQEGQEqd/6Cl35AFuCb+j211HmDD1WPw6Q/j/kiQZgxhWhKkGUOYlgRpxqAlVZoxjuMw/HPvNvf9\nXWtH1+lCBCAlAQZASgIMgJQE2LYIfehDmGYMYVoSpBlDmJYEacagJYUgzeibAAMgJQEGQEoCDICU\nBBgAKQkwAFISYACkJMAASKn/tRABvlF5TXBfIDtPgAG8ZQndiHQhApCSAAMgpdpdiMve5I+6ejd/\nXGezb1oPMsAT1KvAxnFc5c35oVE/rAzASu0K7FUencyktw9TbwE8U6UKbC+HjvNJ4QXAnqoV2LJa\nmqbpfHV1PucUZAAPkXgW4pxbl8fVAEithy8yrwq11XzFVaQp0QD6kD7A3nZLSiyALiUOMMkE8GSJ\nx8AAeLJmFZjZFsCB+pcInTrpVAqweXSqXA7qmzNmPr/L+RrOQuhFtTXgB8vAZ9RyLcTNu87HzysU\n72kZAKnUGwMrk+n7Uqms55RfAA/RbCWOj+69dhcAHTMLEYCUBBgAKQkwAFISYACkJMAASEmAAZCS\nAAMgJQEGQEqJf04F+IXKy7NZi4DLBBhQqraKriV0uU4XIgApCTAAUhJgAKQkwABISYABkJIAAyAl\nAQZASgIMgJQEGAApCTAAUhJgAKRkLUQIofISuoNVdMkvXIAt38YfvcHGcfSGJLlqS+gOVtGlA4G6\nEMdxXH0IPf+ZtP6nVwDaCleBvaqok5kkugCeKUoFtpdDx/kkvQAeK0qAzZaDWGcGtKZ//bJRAEQU\nK8AA4KRwY2C3W3UzKtcA+tB/gEksgC7pQgQgJQEGQEpxA8wUeQAORAmweaSqDC0jWABsCjeJ46Dw\nmu8SaQAMoQJsmiZT3qmvcme1sxruEijAhnfv7YN7XRT4TrVl4K0BD7eJMgYGAB8RYACkJMAASEmA\nAZCSAAMgJQEGQEoCDICUBBgAKQkwAFISYACkJMAASCnWWog8R/3fe7NgJnRGgNFQtSV0B6voQn90\nIQKQkgADICUBBkBKAgyAlAQYACkJMABSEmAApCTAAEhJgAGQUu2VOJYLCJ1c2ufgKZvLEVkxCOAJ\n6lVg4ziu8ubtangXngLAQ9SuwF7l0fkoOn6KeutTlT8EOEDAj1QKsL2L5jiOexe4C0/htGqr6FpC\nF/iVqpM4lsFzMoTOPGVc+LKFAGSReBbiHFcGyQCeqYffA1sNkq36GFeRpvsRoA/pA2zVx1hWYBIL\noEuJA0wyATxZ4jEwAJ6sWYBdmG1hggYAL5UCbO7u+2iA6u1T9tbp0LUI8AQt10LcvKuMn72nzFM2\nlGUAz1SvC7FMprel0tunlP9VfgE8RNUK7DhdNu+9EHIAPIFZiACklPh7YLlYAx7gXgKsJmvAA9xG\nFyIAKQkwAFISYACkJMAASEmAAZCSAAMgJQEGQEoCDICUBBgAKQkwAFISYACk1P9aiFbRBehS/wFW\ncQndwSq6ANXoQgQgJQEGQEoCDICUBBgAKQkwAFLqYRbicqK8WewAD5G7AhvHcfU1r8rf+gKglR4q\nsFfVJb0AniNxBbYXV2IM4AkSB9hsOehlAAzgOdIHGADPNOatWuauwlX7VzfqTgS4Jn469DCJ40D8\nAwDANboQAUhJgAGQUlcBZsQL4DkSB9g8vlWGlnEvgCfoYRKHwgvggRJXYMNWsaX8AniIxN8D+7Vx\nbPnirMpKLXnZ/P5f5b2vRGhMkzYcdH5EaM+Tj8vefpu37V65K7DfadstWe69VXvitIQVv8OwEuRc\nLY9L5WYcLBLb3znTwxjYvZof1FcDVuuJ1K8Iy1qnVUtWDWgrwufWICvObL4UbWOj7btmrxmV936g\n+TlzLxXYH+Ic1JiLFLdtSdtO3TjKDxZ7M3JbaXWYgrxrmhya4130+tsdKrA/dPbx5EvSYk/AgYQg\nzfAho5Uz165VsnZwlVOBhTNNU9hLQMMJFBGujK9eqfLGJsaFVm1YatiMstBpO9mHOlRgCTR/KzYv\nOIJcoF+aD08OWzka4WLdtuNuleUNR2r15dShAouueXoN/xaFrw+5Td6TEa7OsyADLcOfx2Vofa1s\nfqWOMAtxeSziVMYdE2BxzW+AUD2Kj+08nIU9FkFa1byTYFpY3l7T6kUIcmh6pQsxonIy7sPtfbj2\n+gQRsNRoOEnBaVmNCiyoCB/2A16VCKv56cpH+nh3C7BwQp1YEWbcTX9a3li5JXtrGVRuyd6Mu1ZC\nnbEvrb5PHeEMKe19Ha15w76kCzGozbdf/Qvl5kB09pP+sr0XpJVVSx57XIYw5+pmM0Idlzhn7y1U\nYBwp33uh3o31lUP0TV4Qx6UU5DUJO4kjyOtzryjzuwDgIyowAFISYACkJMAASEmAAZCSAAMgJQEG\nQEoCDICUBBgAKQkwAFISYACkJMAASEmAAZCSAAMgJQEGQEoCDICUBBgAKQkwAFISYACk9FfrBvAs\n4zge3DtN00/3e7D9tw+4d3fHT/lpY+7d+O+2CW+pwABISQVGA/U/qr/dY6jq4XLp9v3Wru001KvH\nc6jAAEhJBUY4r0/3ywGz5eDQ8pbVU95u8/IDamo+IBdwF1ASYAS1mu5Rzv4Yx7G8Yu4lXPmYV0Ae\nP2xva2V7LvT7XXvwajrG69+rCSAf/XXlZjf/3tWnis1DcNzmvU0dNBX26EIkrmmaVhe18palMvMO\ncuI4Qjbz8vi55zPpm/Q6+fSPdnH5Kec3de0WOKYCo4G9S9UynJYTBMopA2e28P2U/YOtvS3Ivtn4\n8YNXN24WTNf+uoOK6sxOl5saipKu3PhmKQnnqcDox+b18XItchAJ33R2Xc6be/26AW9frrteT55M\nBUYDfVyw6tQNc7lplgSUBBh8rIyTn4ZZ2dUmyWDQhQgnvcqghsXQaw6LQSMYBBg92Zx5fzlpymmH\n56ekH9hMoOPZkr+Iq49eqy/nNIpbfkQXIg2cmUN475Y/8prl+Oks/DOz+I63cPnBH+36zDZPTtYv\nd7r36un25HYqMPqxeTG9fVPf72Xz+20fteT7KXwHX7A78wce7/TGAwEHPv7UBgGZpAcPpAIDICUB\nBkBKAgyAlIyBAZCSCgyAlAQYACkJMABSEmAApCTAAEhJgAGQkgADICUBBkBKAgyAlAQYACkJMABS\n6vwXmf2WOcA18VfK7TzAhqvH4MIPtP9CkGYMYVoSpBlDmJYEacagJVWaMY7jMPxz7zb3/V1rR9fp\nQgQgJQEGQEoCDICUBNi2CH3oQ5hmDGFaEqQZQ5iWBGnGoCWFIM3omwADIKX+ZyECfKPyt3GUbucJ\nMIC3TF6PSBciACkJMABSEmAApCTAAEhJgAGQkgADIKXa0+iX36j46OsOm0s7b34/w7coAJ6gXgU2\njuMqb85/PdDPegGwUrsCe5VHJzPp7cPUWwDPVKkC28uh43xSeAGwp2oFtqyWpmk6X12dzzkFGcBD\nJJ6FOOfW5XE1AFLrYTHfVaG2mq+4ijQlGkAf0gfY225JiQXQpcQBJpkAnizxGBgAT9YswMy2AOAb\nlboQ59Gpcjmob7oB5wgs52voWoQO1P+M69KRTsu1EDfvOn8OvULxnpYB4fxTcV9/V9wX96jXhVgm\n0/efd8p6zmcogIdothLHR/deuwuAjpmFCEBKAgyAlAQYACkJMABSEmAApCTAAEhJgAGQkgADICUB\nBkBKAgyAlAQYACkl/kVm4Bcq/8KD5Uy5TIABpWq/Y+JHTLhOFyIAKQkwAFISYACkJMAASEmAAZCS\nAAMgJQEGQEoCDICUBBgAKYVbiWO5jM1Ha8yM42hNGvKqvIDTYA0n8gsUYOUb+Hwm1X/zww9UW8Bp\nsIYTHQgUYLNXYp3MJNEF8ExRxsD2cug4n6QXwGNFCbDZssPwTOfh9K9fNgqAiGIFGACcFG4M7Har\nbkblGkAf+g8wiQXQJV2IAKQkwABIKW6AmSIPwIEoATaPVJWhZQQLgE3hJnEcFF7zXSKNe1Wu9Z3A\ncJdAATZNkynvNFJtEUIrEMJtAgXY8C6xDu4VdQBPE2UMDAA+IsAASEmAAZCSAAMgJQEGQEoCDICU\nBBgAKQkwAFISYACkJMAASEmAAZCSAAMgpViL+fIc9X+w1IrP0BkBRkPVfsRk8Dsm0B9diACkJMAA\nSEmAAZCSAAMgJQEGQEoCDICUBBgAKQkwAFISYACkVHsljuUCQieX9jl4yuZyRFYMAniCehXYOI6r\nvHm7Gt6FpwDwELUrsFd5dD6Kjp+i3gJ4pkoBthdX4zjuJdCFp3BG5SrWwQJ+pGoFtryWTdN05kp6\n5ikXxtUer9oy8NaAB34l8SzEObcMkgE8Uw+/B7YaJFv1Ma4iTYkG0If0Afa2j1FiAXQpcYBJJoAn\nSzwGBsCTNQuwC7MtTNAA4KVSgM3dfR8NUL19yt46HboWAZ6g5VqIm3eV8bP3lHnKhrIM4JnqdSGW\nyfS2VHr7lPK/yi+Ah2i2EsfJey+EHABPkHgafS5WIAS4lwCryQqEALfxPTAAUhJgAKQkwABISYAB\nkJIAAyAlAQZASgIMgJQEGAApCTAAUhJgAKTU/1JSFiEE6FL/AVZxBcLBIoQA1ehCBCAlAQZASgIM\ngJQEGAApCTAAUhJgAKQkwABISYABkFIPX2RerrVhIQyAh8hdgY3juFopqvLCUQC00kMF9qq6pBfA\ncySuwPbiSowBPEHiAJstB70MgAE8R/oAA+CZxrxVy9xVuGr/6kbdiQDXxE+HHiZxHIh/AAC4Rhci\nACkJMABS6irAjHgBPEfiAJvHt8rQMu4F8AQ9TOJQeAE8UOIKbNgqtpRfAA+R+HtgvzaOLV+cVVmp\nJS+b3/+rvPeVCI1p0oaDzo8I7Xnycdnbb/O23St3BfY7bbsly723ak+clrDidxhWgpyr5XGp3IyD\nRWL7O2d6GAO7V/OD+mrAaj2R+hVhWeu0asmqAW1F+NwaZMWZzZeibWy0fdfsNaPy3g80P2fupQL7\nQ5yDGnOR4rYtadupG0f5wWJvRm4rrQ5TkHdNk0NzvItef7tDBfaHzj6efEla7Ak4kBCkGT5ktHLm\n2rVK1g6uciqwcKZpCnsJaDiBIsKV8dUrVd7YxLjQqg1LDZtRFjptJ/tQhwosgeZvxeYFR5AL9Evz\n4clhK0cjXKzbdtytsrzhSK2+nDpUYNE1T6/h36Lw9SG3yXsywtV5FmSgZfjzuAytr5XNr9QRZiEu\nj0WcyrhjAiyu+Q0QqkfxsZ2Hs7DHIkirmncSTAvL22tavQhBDk2vdCFGVE7Gfbi9D9denyAClhoN\nJyk4LatRgQUV4cN+wKsSYTU/XflIH+9uARZOqBMrwoy76U/LGyu3ZG8tg8ot2Ztx10qoM/al1fep\nI5whpb2vozVv2Jd0IQa1+farf6HcHIjOftJftveCtLJqyWOPyxDmXN1sRqjjEufsvYUKjCPley/U\nu7G+coi+yQviuJSCvCZhJ3EEeX3uFWV+FwB8RAUGQEoCDICUBBgAKQkwAFISYACkJMAASEmAAZCS\nAAMgJQEGQEoCDICUBBgAKQkwAFISYACkJMAASEmAAZCSAAMgJQEGQEoCDICUBBgAKQkwAFISYACk\nJMAASEmAAZCSAAMgJQEGQEr/B4u3lFodSqy2AAAAAElFTkSuQmCC\n", "output_type": "display_data"}], "prompt_number": 47, "cell_type": "code", "language": "python", "metadata": {}, "input": ["h1 = hist(x, 1:q)/n;\n", "clf;\n", "subplot(2,1,1); \n", "bar(h); axis('tight');\n", "set_graphic_sizes([], 20);\n", "title('True distribution');\n", "subplot(2,1,2);\n", "bar(h1); axis('tight');\n", "set_graphic_sizes([], 20);\n", "title('Empirical distribution');"]}, {"source": ["__Exercise 4__\n", "\n", "Encode a signal with an increasing size |n|, and check how close the\n", "generated signal coding rate |length(y)/n| becomes close to the optimal\n", "Shannon bound.\n", "ompute the differencial of coding for a varying length signal"], "metadata": {}, "cell_type": "markdown"}, {"collapsed": false, "outputs": [{"metadata": {}, "png": "iVBORw0KGgoAAAANSUhEUgAAAkAAAAGwCAIAAADOgk3lAAAACXBIWXMAAAsSAAALEgHS3X78AAAA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\nyag6s7AAAAAASUVORK5CYII=\n", "output_type": "display_data"}], "prompt_number": 52, "cell_type": "code", "language": "python", "metadata": {}, "input": ["warning off\n", "exo4()\n", "warning on"]}, {"collapsed": false, "outputs": [], "prompt_number": 49, "cell_type": "code", "language": "python", "metadata": {}, "input": ["%% Insert your code here."]}], "metadata": {}}], "nbformat": 3, "metadata": {"kernelspec": {"name": "matlab_kernel", "language": "matlab", "display_name": "Matlab"}, "language_info": {"mimetype": "text/x-matlab", "name": "matlab", "file_extension": ".m", "help_links": [{"url": "https://github.com/calysto/metakernel/blob/master/metakernel/magics/README.md", "text": "MetaKernel Magics"}]}}}