Line Coding Project.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1. user input\n",
      "2. random binary input\n",
      "2\n",
      "Enter 1 if you want fixed subsequence(size must be greater than 8) otherwise press 2\n",
      "1\n",
      "Enter size of binary input\n",
      "16\n",
      "Input is: \n",
      "0100000000111111\n",
      "Longest palindrome substring is: \n",
      "1000000001Length is: 10\n",
      "\n",
      "1.NRZ-L\n",
      " 2.NRZ-I\n",
      " 3.Manchester\n",
      " 4.Differantial Manchester\n",
      " 5.others(AMI/B8ZS/HDB3)\n",
      "\n",
      "5\n",
      "0.No Scrambling(AMI) 1.Scrambling(HDB3/B8ZS)\n",
      "1\n",
      "Perform Scrambling\n",
      "1.B8ZS 2.HDB3\n",
      "2\n",
      "Perform HDB3\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 0, 0, 0, 1, -1, 0, 0, -1, -1, -1, -1, -1, -1, -1]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "from random import *\n",
    "randBinList = lambda n: [randint(0,1) for b in range(1,n+1)]\n",
    "print(\"1. user input\")\n",
    "print(\"2. random binary input\")\n",
    "x=int(input())\n",
    "if(x==1):\n",
    "    print(\"Enter the binary input\")\n",
    "    s=input()\n",
    "else:\n",
    "    print(\"Enter 1 if you want fixed subsequence(size must be greater than 8) otherwise press 2\")\n",
    "    bla = int(input())\n",
    "    print(\"Enter size of binary input\")\n",
    "    size = int(input())\n",
    "    kla = randint(0,9)\n",
    "    if(bla==1):\n",
    "        size = size - 8\n",
    "    kla = kla%size\n",
    "    #print(kla)\n",
    "    s=[]\n",
    "    s=randBinList(size)\n",
    "    saurabh = \"00000000\"\n",
    "    #print(*s)\n",
    "    s=\"\".join(str(i) for i in s)\n",
    "    if(bla==1):\n",
    "        s=s[:kla]+saurabh+s[kla:]\n",
    "    print(\"Input is: \")\n",
    "    print(s)\n",
    "\n",
    "#palindrome code\n",
    "print(\"Longest palindrome substring is: \")\n",
    "import sys\n",
    "\n",
    "def printSubStr(st,low,high) : \n",
    "\tsys.stdout.write(st[low : high + 1]) \n",
    "\tsys.stdout.flush() \n",
    "\treturn '' \n",
    "\n",
    "def longestPalSubstr(st) : \n",
    "\tn = len(st) \n",
    "\ttable = [[0 for x in range(n)] for y \n",
    "\t\t\t\t\t\tin range(n)] \n",
    "\t\n",
    "\tmaxLength = 1\n",
    "\ti = 0\n",
    "\twhile (i < n) : \n",
    "\t\ttable[i][i] = True\n",
    "\t\ti = i + 1\n",
    "\t\n",
    "\t# check for sub-string of length 2. \n",
    "\tstart = 0\n",
    "\ti = 0\n",
    "\twhile i < n - 1 : \n",
    "\t\tif (st[i] == st[i + 1]) : \n",
    "\t\t\ttable[i][i + 1] = True\n",
    "\t\t\tstart = i \n",
    "\t\t\tmaxLength = 2\n",
    "\t\ti = i + 1\n",
    "\t\n",
    "\t# Check for lengths greater than 2. \n",
    "\t# k is length of substring \n",
    "\tk = 3\n",
    "\twhile k <= n : \n",
    "\t\t# Fix the starting index \n",
    "\t\ti = 0\n",
    "\t\twhile i < (n - k + 1) : \n",
    "\t\t\t\n",
    "\t\t\t# Get the ending index of \n",
    "\t\t\t# substring from starting \n",
    "\t\t\t# index i and length k \n",
    "\t\t\tj = i + k - 1\n",
    "\t\n",
    "\t\t\t# checking for sub-string from \n",
    "\t\t\t# ith index to jth index iff \n",
    "\t\t\t# st[i+1] to st[(j-1)] is a \n",
    "\t\t\t# palindrome \n",
    "\t\t\tif (table[i + 1][j - 1] and\n",
    "\t\t\t\t\tst[i] == st[j]) : \n",
    "\t\t\t\ttable[i][j] = True\n",
    "\t\n",
    "\t\t\t\tif (k > maxLength) : \n",
    "\t\t\t\t\tstart = i \n",
    "\t\t\t\t\tmaxLength = k \n",
    "\t\t\ti = i + 1\n",
    "\t\tk = k + 1\n",
    "\tprintSubStr(st, start, start + maxLength - 1) \n",
    "\n",
    "\treturn maxLength # return length\n",
    "\n",
    "\n",
    "# Driver program to test above functions \n",
    "st = s\n",
    "l = longestPalSubstr(st) \n",
    "print(\"Length is:\", l )\n",
    "    #pal end\n",
    "print(\"\\n1.NRZ-L\\n\",\"2.NRZ-I\\n\",\"3.Manchester\\n\",\"4.Differantial Manchester\\n\",\"5.others(AMI/B8ZS/HDB3)\\n\")\n",
    "n=int(input())\n",
    "\n",
    "if(n==1):\n",
    "    print(\"Perform NRZ-L\")\n",
    "    ls=list()\n",
    "    for i in range(len(s)):\n",
    "        if(s[i]=='0' or s[i]==0):\n",
    "            ls.append(-1)\n",
    "        else:\n",
    "            ls.append(1)\n",
    "    xs = np.repeat(range(len(s)), 2)\n",
    "    ys = np.repeat(ls, 2)\n",
    "    xs=xs[1:]\n",
    "    xs=np.append(xs,(xs[len(xs)-1]+1))\n",
    "    ys=ys[:-1]\n",
    "    ys=np.append(ys,(ys[len(ys)-1]))\n",
    "    plt.step(xs,ys)\n",
    "    plt.ylim(-2,2)\n",
    "    plt.show()\n",
    "    print(\"Positive logic\")\n",
    "    \n",
    "    ls1=list()\n",
    "    for i in range(len(s)):\n",
    "        if(s[i]=='0' or s[i]==0):\n",
    "            ls1.append(1)\n",
    "        else:\n",
    "            ls1.append(-1)\n",
    "    xs1 = np.repeat(range(len(s)), 2)\n",
    "    ys1 = np.repeat(ls1, 2)\n",
    "    xs1=xs1[1:]\n",
    "    xs1=np.append(xs1,(xs1[len(xs1)-1]+1))\n",
    "    ys1=ys1[:-1]\n",
    "    ys1=np.append(ys1,(ys1[len(ys1)-1]))\n",
    "    plt.step(xs1,ys1)\n",
    "    plt.ylim(-2,2)\n",
    "    plt.show()\n",
    "    print(\"Negative logic\")  \n",
    "elif(n==2):\n",
    "    print(\"Perform NRZ-I\")\n",
    "    Is=list()\n",
    "    if(s[0]=='0' or s[0]==0):\n",
    "        Is.append(-1)\n",
    "    else:\n",
    "        Is.append(1)\n",
    "    k=len(s)\n",
    "    i=1\n",
    "    while(i<k):\n",
    "        if(int(s[i])==0):\n",
    "            Is.append(Is[i-1])\n",
    "        else:\n",
    "            Is.append(-Is[i-1])\n",
    "        i=i+1\n",
    "    xs = np.repeat(range(len(s)), 2)\n",
    "    ys = np.repeat(Is, 2)\n",
    "    xs=xs[1:]\n",
    "    xs=np.append(xs,(xs[len(xs)-1]+1))\n",
    "    ys=ys[:-1]\n",
    "    ys=np.append(ys,(ys[len(ys)-1]))\n",
    "    plt.step(xs,ys)\n",
    "    plt.ylim(-2,2)\n",
    "    plt.show()\n",
    "    print(\"Positive logic\")\n",
    "    Is=list()\n",
    "    if(s[0]=='0' or s[0]==0):\n",
    "        Is.append(1)\n",
    "    else:\n",
    "        Is.append(-1)\n",
    "    k=len(s)\n",
    "    i=1\n",
    "    while(i<k):\n",
    "        if(int(s[i])==0):\n",
    "            Is.append(Is[i-1])\n",
    "        else:\n",
    "            Is.append(-Is[i-1])\n",
    "        i=i+1\n",
    "    xs1 = np.repeat(range(len(s)), 2)\n",
    "    ys1= np.repeat(Is, 2)\n",
    "    xs1=xs1[1:]\n",
    "    xs1=np.append(xs1,(xs1[len(xs1)-1]+1))\n",
    "    ys1=ys1[:-1]\n",
    "    ys1=np.append(ys1,(ys1[len(ys1)-1]))\n",
    "    plt.step(xs1,ys1)\n",
    "    plt.ylim(-2,2)\n",
    "    plt.show()\n",
    "    print(\"Negative logic\")\n",
    "elif(n==3):\n",
    "    print(\"Perform Manchester\")\n",
    "    pm=list()\n",
    "    for j in range(len(s)):\n",
    "        if(s[j]=='0' or s[j]==0):\n",
    "            pm.append(-1)\n",
    "            pm.append(1)\n",
    "        else:\n",
    "            pm.append(1)\n",
    "            pm.append(-1)\n",
    "    xs=[x*0.5 for x in range(0,(2*len(s)))]\n",
    "    xs=np.repeat(xs,2)\n",
    "    ys = np.repeat(pm, 2)\n",
    "    xs=xs[1:]\n",
    "    xs=np.append(xs,(xs[len(xs)-1]+0.5))\n",
    "    ys=ys[:-1]\n",
    "    ys=np.append(ys,(ys[len(ys)-1]))\n",
    "    plt.step(xs,ys)\n",
    "    plt.ylim(-2,2)\n",
    "    plt.show()\n",
    "    print(\"Positive logic\")\n",
    "\t\n",
    "    pm=list()\n",
    "    for j in range(len(s)):\n",
    "        if(s[j]=='0' or s[j]==0):\n",
    "            pm.append(1)\n",
    "            pm.append(-1)\n",
    "        else:\n",
    "            pm.append(-1)\n",
    "            pm.append(1)\n",
    "    xs1=[x*0.5 for x in range(0,(2*len(s)))]\n",
    "    xs1=np.repeat(xs1,2)\n",
    "    ys1= np.repeat(pm, 2)\n",
    "    xs1=xs1[1:]\n",
    "    xs1=np.append(xs1,(xs1[len(xs1)-1]+0.5))\n",
    "    ys1=ys1[:-1]\n",
    "    ys1=np.append(ys1,(ys1[len(ys1)-1]))\n",
    "    plt.step(xs1,ys1)\n",
    "    plt.ylim(-2,2)\n",
    "    plt.show()\n",
    "    print(\"Negative logic\")\n",
    "elif(n==4):\n",
    "    print(\"Perform Differantial Manchester\")\n",
    "    pdm=list()\n",
    "    pdm.append(1)\n",
    "    pdm.append(-1)\n",
    "    i=1\n",
    "    k=len(s)\n",
    "    while(i<k):\n",
    "        if(int(s[i])==1):\n",
    "            pdm.append(pdm[len(pdm)-1])\n",
    "            pdm.append(-pdm[len(pdm)-1])\n",
    "        else:\n",
    "            pdm.append(-pdm[len(pdm)-1])\n",
    "            pdm.append(-pdm[len(pdm)-1])\n",
    "        i=i+1\n",
    "    print(pdm)\n",
    "    xs=[x*0.5 for x in range(0,(2*len(s)))]\n",
    "    xs=np.repeat(xs,2)\n",
    "    ys = np.repeat(pdm, 2)\n",
    "    xs=xs[1:]\n",
    "    xs=np.append(xs,(xs[len(xs)-1]+0.5))\n",
    "    ys=ys[:-1]\n",
    "    ys=np.append(ys,(ys[len(ys)-1]))\n",
    "    plt.step(xs,ys)\n",
    "    plt.ylim(-2,2)\n",
    "    plt.show()\n",
    "    print(\"Positive logic\")\n",
    "    pdm=list()\n",
    "    pdm.append(-1)\n",
    "    pdm.append(1)\n",
    "    i=1\n",
    "    k=len(s)\n",
    "    while(i<k):\n",
    "        if(int(s[i])==1):\n",
    "            pdm.append(pdm[len(pdm)-1])\n",
    "            pdm.append(-pdm[len(pdm)-1])\n",
    "        else:\n",
    "            pdm.append(-pdm[len(pdm)-1])\n",
    "            pdm.append(-pdm[len(pdm)-1])\n",
    "        i=i+1\n",
    "    print(pdm)\n",
    "    xs1=[x*0.5 for x in range(0,(2*len(s)))]\n",
    "    xs1=np.repeat(xs1,2)\n",
    "    ys1 = np.repeat(pdm, 2)\n",
    "    xs1=xs1[1:]\n",
    "    xs1=np.append(xs1,(xs1[len(xs1)-1]+0.5))\n",
    "    ys1=ys1[:-1]\n",
    "    ys1=np.append(ys1,(ys1[len(ys1)-1]))\n",
    "    plt.step(xs1,ys1)\n",
    "    plt.ylim(-2,2)\n",
    "    plt.show()\n",
    "    print(\"Negative logic\")\n",
    "else:\n",
    "    print(\"0.No Scrambling(AMI)\",\"1.Scrambling(HDB3/B8ZS)\")\n",
    "    q=int(input())\n",
    "    if(q==0):\n",
    "        print(\"Perform AMI\")\n",
    "        am=list()\n",
    "        m=1\n",
    "        for i in range(len(s)):\n",
    "            if(int(s[i])==0):\n",
    "                am.append(0)\n",
    "            else:\n",
    "                if(m%2==1):\n",
    "                    am.append(1)\n",
    "                else:\n",
    "                    am.append(-1)\n",
    "                m=m+1\n",
    "        xs = np.repeat(range(len(s)), 2)\n",
    "        ys = np.repeat(am, 2)\n",
    "        xs=xs[1:]\n",
    "        xs=np.append(xs,(xs[len(xs)-1]+1))\n",
    "        ys=ys[:-1]\n",
    "        ys=np.append(ys,(ys[len(ys)-1]))\n",
    "        plt.step(xs,ys)\n",
    "        plt.ylim(-2,2)\n",
    "        plt.show()\n",
    "        print(\"Positive logic\")  \n",
    "        am=list()\n",
    "        m=1\n",
    "        for i in range(len(s)):\n",
    "            if(int(s[i])==0):\n",
    "                am.append(0)\n",
    "            else:\n",
    "                if(m%2==1):\n",
    "                    am.append(-1)\n",
    "                else:\n",
    "                    am.append(1)\n",
    "                m=m+1\n",
    "        xs1 = np.repeat(range(len(s)), 2)\n",
    "        ys1 = np.repeat(am, 2)\n",
    "        xs1=xs1[1:]\n",
    "        xs1=np.append(xs1,(xs1[len(xs1)-1]+1))\n",
    "        ys1=ys1[:-1]\n",
    "        ys1=np.append(ys1,(ys1[len(ys1)-1]))\n",
    "        plt.step(xs1,ys1)\n",
    "        plt.ylim(-2,2)\n",
    "        plt.show()\n",
    "        print(\"Negative logic\")  \n",
    "    else:\n",
    "        print(\"Perform Scrambling\")\n",
    "        print(\"1.B8ZS\",\"2.HDB3\")\n",
    "        p=int(input())\n",
    "        q=len(s)\n",
    "        if(p==1):\n",
    "            print(\"Perform B8ZS\")\n",
    "            bz=list()\n",
    "            m=1\n",
    "            s1=s.replace(\"00000000\",\"000vb0vb\")\n",
    "            for i in range(len(s1)):\n",
    "                if(s1[i]=='0' or s1[i]==0):\n",
    "                    bz.append(0)\n",
    "                elif(s1[i]=='1'):\n",
    "                    if(m%2==1):\n",
    "                        bz.append(1)\n",
    "                    else:\n",
    "                        bz.append(-1)\n",
    "                    m=m+1\n",
    "                elif(s1[i]=='v'):\n",
    "                    if(m%2==1):\n",
    "                        bz.append(-1)\n",
    "                    else:\n",
    "                        bz.append(1)\n",
    "                else:\n",
    "                    if(m%2==1):\n",
    "                        bz.append(1)\n",
    "                    else:\n",
    "                        bz.append(-1)\n",
    "                    m=m+1\n",
    "            xs = np.repeat(range(len(s)), 2)\n",
    "            ys = np.repeat(bz, 2)\n",
    "            xs=xs[1:]\n",
    "            xs=np.append(xs,(xs[len(xs)-1]+1))\n",
    "            ys=ys[:-1]\n",
    "            ys=np.append(ys,(ys[len(ys)-1]))\n",
    "            plt.step(xs,ys)\n",
    "            plt.ylim(-2,2)\n",
    "            plt.show()\n",
    "            print(\"Positive logic\")\n",
    "            bz=list()\n",
    "            m=1\n",
    "            for i in range(len(s1)):\n",
    "                if(s1[i]=='0'):\n",
    "                    bz.append(0)\n",
    "                elif(s1[i]=='1'):\n",
    "                    if(m%2==1):\n",
    "                        bz.append(-1)\n",
    "                    else:\n",
    "                        bz.append(1)\n",
    "                    m=m+1\n",
    "                elif(s1[i]=='v'):\n",
    "                    if(m%2==1):\n",
    "                        bz.append(1)\n",
    "                    else:\n",
    "                        bz.append(-1)\n",
    "                else:\n",
    "                    if(m%2==1):\n",
    "                        bz.append(-1)\n",
    "                    else:\n",
    "                        bz.append(1)\n",
    "                    m=m+1\n",
    "            xs1 = np.repeat(range(len(s)), 2)\n",
    "            ys1 = np.repeat(bz, 2)\n",
    "            xs1=xs1[1:]\n",
    "            xs1=np.append(xs1,(xs1[len(xs1)-1]+1))\n",
    "            ys1=ys1[:-1]\n",
    "            ys1=np.append(ys1,(ys1[len(ys1)-1]))\n",
    "            plt.step(xs1,ys1)\n",
    "            plt.ylim(-2,2)\n",
    "            plt.show()\n",
    "            print(\"Negative logic\")  \n",
    "        else:\n",
    "            print(\"Perform HDB3\")\n",
    "            m=0\n",
    "            hd=list()\n",
    "\t\t\t  \n",
    "            f=s.find(\"0000\")\n",
    "            if(f==-1):\n",
    "                f=len(s)\n",
    "            i=0\n",
    "            k=len(s)\n",
    "            d=1\n",
    "            p=0\n",
    "            while(i<k):\n",
    "                if(s[i]=='1' or s[i]==1):\n",
    "                    m=m+1\n",
    "                    p=p+1\n",
    "                    if(m%2==1):\n",
    "                        hd.append(d)\n",
    "                        d=1\n",
    "                    else:\n",
    "                        hd.append(-d)\n",
    "                        d=-d\n",
    "                else:\n",
    "                    if(i<f):\n",
    "                        hd.append(0)\n",
    "                    elif(i==f):\n",
    "                        i=i+3\n",
    "                        if(p%2==0):\n",
    "                            hd.append(-d)\n",
    "                            hd.append(0)\n",
    "                            hd.append(0)\n",
    "                            hd.append(-d)\n",
    "                            d=-d\n",
    "                            p=p+2\n",
    "                            m=m+1\n",
    "                        else:\n",
    "                            hd.append(0)\n",
    "                            hd.append(0)\n",
    "                            hd.append(0)\n",
    "                            hd.append(d)\n",
    "                            p=p+1\n",
    "                        jk=s[i+1:(i+1)+(k-i-1)]\n",
    "                        x=jk.find(\"0000\")\n",
    "                        if(x==-1):\n",
    "                            f=k\n",
    "                        else:\n",
    "                            f=i+1+x\n",
    "                i=i+1\n",
    "            xs = np.repeat(range(len(s)), 2)\n",
    "            ys = np.repeat(hd, 2)\n",
    "            xs=xs[1:]\n",
    "            xs=np.append(xs,(xs[len(xs)-1]+1))\n",
    "            ys=ys[:-1]\n",
    "            ys=np.append(ys,(ys[len(ys)-1]))\n",
    "            plt.step(xs,ys)\n",
    "            plt.ylim(-1.5,1.5)\n",
    "            plt.show()\n",
    "            print(hd)\n",
    "                \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",
   "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.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}