path: root/Programming_with_ANSI_and_Turbo_C/Chapter12.ipynb

{
 "metadata": {
  "name": ""
 },
 "nbformat": 3,
 "nbformat_minor": 0,
 "worksheets": [
  {
   "cells": [
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "<h1>Chapter 12: Preprocessor Directives<h1>"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "<h3>Example 12.1, Page number: 386<h3>"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#Area of circle\n",
      "\n",
      "import sys\n",
      "\n",
      "#Defining the macro\n",
      "#There is no macro definitions/preprocessors in python\n",
      "PI =  3.14\n",
      "\n",
      "#Variable Initialization\n",
      "r = float(raw_input(\"Enter radius of circle in cms.\"))\n",
      "\n",
      "#Calculation\n",
      "area = PI * r * r\n",
      "\n",
      "#Result\n",
      "sys.stdout.write(\"Area of a Circle = %.2f cm2\"%(area))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "name": "stdout",
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Enter radius of circle in cms.7\n"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Area of a Circle = 153.86 cm2"
       ]
      }
     ],
     "prompt_number": 1
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "<h3>Example 12.2, Page number: 387<h3>"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#Identifers for 'c' statements and variables\n",
      "\n",
      "import sys\n",
      "import os\n",
      "\n",
      "#Macro definitions\n",
      "#in python, function definitions are used instead of macros\n",
      "def N():\n",
      "    return 10\n",
      "\n",
      "def cls():\n",
      "    os.system('cls')\n",
      "    \n",
      "def wait():\n",
      "    t = raw_input(\"\")\n",
      "    \n",
      "def display(s):\n",
      "    sys.stdout.write(s)\n",
      "\n",
      "for k in range(1,N()+1):\n",
      "    display(\"%d\\t\"%(k))\n",
      "    "
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "1\t2\t3\t4\t5\t6\t7\t8\t9\t10\t"
       ]
      }
     ],
     "prompt_number": 7
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "<h3>Example 12.3, Page number: 387<h3>"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#Macros for logical operators\n",
      "\n",
      "import sys\n",
      "\n",
      "#Macro definitions\n",
      "#in python, function definitions are used as macros\n",
      "\n",
      "#There is no preprocessors in python\n",
      "\n",
      "#Variable Initialization\n",
      "a = int(raw_input(\"Enter Three Numbers : \"))\n",
      "b = int(raw_input(\"Enter Three Numbers : \"))\n",
      "c = int(raw_input(\"Enter Three Numbers : \"))\n",
      "\n",
      "if a > b and a > c:\n",
      "    sys.stdout.write(\"%d is the larger number\"%(a))\n",
      "else:\n",
      "    if b > a and b > c:\n",
      "        sys.stdout.write(\"%d is the larger number\"%(b))\n",
      "    else:\n",
      "        if c > a and c > b:\n",
      "            sys.stdout.write(\"%d is the larger number\"%(c))\n",
      "        else:\n",
      "            if a == b and b == c:\n",
      "                sys.stdout.write(\"\\nNumbers are same.\")"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "name": "stdout",
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Enter Three Numbers : 5\n"
       ]
      },
      {
       "name": "stdout",
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Enter Three Numbers : 4\n"
       ]
      },
      {
       "name": "stdout",
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Enter Three Numbers : 7\n"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "7 is the larger number"
       ]
      }
     ],
     "prompt_number": 2
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "<h3>Example 12.4, Page number: 388<h3>"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#Identifier for displaying double and triple of a number.\n",
      "\n",
      "#Macro definitions\n",
      "#Function definitions are used as macros in python\n",
      "\n",
      "def DOUBLE(a):\n",
      "    return a*2\n",
      "\n",
      "def TRIPLE(a):\n",
      "    return a*3\n",
      "\n",
      "#Variable initialization\n",
      "a = 1\n",
      "\n",
      "#Result\n",
      "sys.stdout.write(\"\\nSINGLE\\tDOUBLE\\tTRIPLE\")\n",
      "\n",
      "for a in range(1,5+1):\n",
      "    sys.stdout.write(\"\\n%d\\t%d\\t%d\"%(a,DOUBLE(a),TRIPLE(a)))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "SINGLE\tDOUBLE\tTRIPLE\n",
        "1\t2\t3\n",
        "2\t4\t6\n",
        "3\t6\t9\n",
        "4\t8\t12\n",
        "5\t10\t15"
       ]
      }
     ],
     "prompt_number": 13
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "<h3>Example 12.5, Page number: 389<h3>"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#Undefine a macro\n",
      "\n",
      "#There is no preprocessor directives in python\n",
      "\n",
      "def wait():\n",
      "    return (raw_input(\"\"))\n",
      "\n",
      "#Result\n",
      "for k in range(1,5+1):\n",
      "    sys.stdout.write(\"%d\\t\"%(k))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "1\t2\t3\t4\t5\t"
       ]
      }
     ],
     "prompt_number": 14
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "<h3>Example 12.6, Page number: 389<h3>"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#Stringizing operation\n",
      "\n",
      "#Macro definition\n",
      "#in python, function definition can be used as macro\n",
      "\n",
      "def say(m):\n",
      "    sys.stdout.write(m)\n",
      "    \n",
      "#Function call\n",
      "say(\"Hello\")"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Hello"
       ]
      }
     ],
     "prompt_number": 16
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "<h3>Example 12.7, Page number: 390<h3>"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#Stringizing operation and macro arguments\n",
      "\n",
      "#There is no macro in python, function definitions can be used as macros\n",
      "\n",
      "def DOUBLE(x):\n",
      "    sys.stdout.write(\"Double of m = %d\\n\"%(x*2))\n",
      "    \n",
      "def TRIPLE(x):\n",
      "    sys.stdout.write(\"Triple of m = %d\\n\"%(x*3))\n",
      "    \n",
      "#Variable Initialization\n",
      "m = int(raw_input(\"Enter a number : \"))\n",
      "\n",
      "#Function call & Result\n",
      "DOUBLE(m)\n",
      "TRIPLE(m)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "name": "stdout",
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Enter a number : 5\n"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Double of m = 10\n",
        "Triple of m = 15\n"
       ]
      }
     ],
     "prompt_number": 3
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "<h3>Example 12.8, Page number: 390<h3>"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#Larger of two numbers using macro with arguments.\n",
      "\n",
      "import sys\n",
      "\n",
      "#Macro definition  //function definition itself is used as macro\n",
      "def MAX(x,y):\n",
      "    if x > y:\n",
      "        c = x\n",
      "    else:\n",
      "        c = y\n",
      "    return c\n",
      "\n",
      "#Variable Initialization\n",
      "x = 5\n",
      "y = 8\n",
      "\n",
      "#Function call\n",
      "c = MAX(x,y)\n",
      "\n",
      "#Result\n",
      "sys.stdout.write(\"\\nLarger of two numbers = %d\"%(c))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "Larger of two numbers = 8"
       ]
      }
     ],
     "prompt_number": 1
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "<h3>Example 12.9, Page number: 391<h3>"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#Function defined in \"udf.c\" file.\n",
      "\n",
      "import sys\n",
      "#since ipython notebook does not support this function, function is used\n",
      "#in python, the udf.c file can be written and saved in udf.py and import command\n",
      "#can be used to include that file in this program\n",
      "\n",
      "def display():\n",
      "    sys.stdout.write(\"\\nFunction Called\")\n",
      "    \n",
      "#Function call\n",
      "display()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "Function Called"
       ]
      }
     ],
     "prompt_number": 3
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "<h3>Example 12.10, Page number: 392<h3>"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#Conditional compilation \n",
      "\n",
      "import sys\n",
      "\n",
      "#There is no preprocessor directives in python\n",
      "\n",
      "LINE = 1\n",
      "\n",
      "if LINE:\n",
      "    sys.stdout.write(\"This is line number one\")\n",
      "else:\n",
      "    sys.stdout.write(\"This is line number two\")\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "This is line number one"
       ]
      }
     ],
     "prompt_number": 7
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "<h3>Example 12.11, Page number: 393<h3>"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#Conditional compilation \n",
      "import sys\n",
      "\n",
      "#There is no preprocessor directives in python\n",
      "def E():\n",
      "    return 1\n",
      "\n",
      "#Function call\n",
      "if E():\n",
      "    a = 2\n",
      "    b = 3\n",
      "    sys.stdout.write(\"A = %d  &  B = %d\"%(a,b))\n",
      "else:\n",
      "    c = 2\n",
      "    d = 3\n",
      "    sys.stdout.write(\"C = %d  &  D = %d\"%(c,d))\n",
      "    "
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "A = 2  &  B = 3"
       ]
      }
     ],
     "prompt_number": 9
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "<h3>Example 12.12, Page number: 394<h3>"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#Conditional compilation directives \n",
      "\n",
      "import sys\n",
      "\n",
      "#There is no preprocessor directives in python\n",
      "T = 8\n",
      "\n",
      "#Result\n",
      "if T == 0:\n",
      "    sys.stdout.write(\"\\nMacro is not defined.\")\n",
      "else:\n",
      "    sys.stdout.write(\"\\nMacro is defined\")"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "Macro is defined"
       ]
      }
     ],
     "prompt_number": 12
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "<h3>Example 12.13, Page number: 394<h3>"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#User defined error message \n",
      "\n",
      "import sys\n",
      "\n",
      "#There is no preprocessor directives in python\n",
      "B = 1\n",
      "A = 0\n",
      "\n",
      "#Result\n",
      "if A == 0:\n",
      "    sys.stdout.write(\"MACRO A IS NOT DEFINED.\")\n",
      "else:\n",
      "    sys.stdout.write(\"Macro found.\")"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "MACRO A IS NOT DEFINED."
       ]
      }
     ],
     "prompt_number": 14
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "<h3>Example 12.14, Page number: 397<h3>"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#Set off certain errors \n",
      "\n",
      "import sys\n",
      "\n",
      "#There is no preprocessor directives in python\n",
      "x = 2\n",
      "y = 1\n",
      "\n",
      "#Result\n",
      "sys.stdout.write(\"\\ny = %d\"%(y))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "y = 1"
       ]
      }
     ],
     "prompt_number": 15
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "<h3>Example 12.15, Page number: 398<h3>"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#Predefined macros \n",
      "\n",
      "import sys\n",
      "import datetime\n",
      "\n",
      "#Variable Initialization\n",
      "FILE = 'PRE_MA~1.C'\n",
      "LINE = 10\n",
      "STDC = 1\n",
      "\n",
      "#Date/time can be set using datetime.date(2001,5,12)\n",
      "#Result\n",
      "sys.stdout.write(\"\\nDATE    :  %s\"%('Dec 05 2001')) \n",
      "sys.stdout.write(\"\\nTIME    :  %s\"%(datetime.time(21,7,39)))\n",
      "sys.stdout.write(\"\\nFILE NAME : %s\"%(FILE))\n",
      "sys.stdout.write(\"\\nLINE NO : %d\"%(LINE))\n",
      "sys.stdout.write(\"\\n_STDC_  :  %x\"%(STDC))\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "DATE    :  Dec 05 2001\n",
        "TIME    :  21:07:39\n",
        "FILE NAME : PRE_MA~1.C\n",
        "LINE NO : 10\n",
        "_STDC_  :  1"
       ]
      }
     ],
     "prompt_number": 31
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "<h3>Example 12.16, Page number: 399<h3>"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#Display the name of memory model that is currently in use.\n",
      "\n",
      "import sys\n",
      "\n",
      "#There is no formal memory model and preprocessor directives in python\n",
      "\n",
      "TINY = 0\n",
      "SMALL = 0\n",
      "MEDIUM = 0\n",
      "COMPACT = 0\n",
      "LARGE = 1\n",
      "HUGE = 0\n",
      "\n",
      "#Result\n",
      "if TINY:\n",
      "    sys.stdout.write(\"\\nTINY %d\"%(TINY))\n",
      "else:\n",
      "    if SMALL:\n",
      "        sys.stdout.write(\"\\nSMALL %d\"%(SMALL))\n",
      "    else:\n",
      "        if MEDIUM:\n",
      "            sys.stdout.write(\"\\nMEDIUM %d\"%(MEDIUM))\n",
      "        else:\n",
      "            if COMPACT:\n",
      "                sys.stdout.write(\"\\nCOMPACT %d\"%(COMPACT))\n",
      "            else:\n",
      "                if LARGE:\n",
      "                    sys.stdout.write(\"\\nLARGE %d\"%(LARGE))\n",
      "                else:\n",
      "                    sys.stdout.write(\"\\nHUGE %d\"%(HUGE))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "LARGE 1"
       ]
      }
     ],
     "prompt_number": 32
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "<h3>Example 12.17, Page number: 400<h3>"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#Macro expansions\n",
      "\n",
      "import sys\n",
      "\n",
      "#There is no preprocessor directives in python\n",
      "ch = raw_input(\"Input a Text : \")\n",
      "\n",
      "#Result\n",
      "sys.stdout.write(\"Text Input : %s\"%(ch))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "name": "stdout",
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Input a Text : Programming\n"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Text Input : Programming"
       ]
      }
     ],
     "prompt_number": 4
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "<h3>Example 12.18, Page number: 401<h3>"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "#Predefined macros.\n",
      "\n",
      "import sys\n",
      "\n",
      "#Variable Initialization\n",
      "d = raw_input(\"Enter any character : \")\n",
      "\n",
      "#Result\n",
      "f = d.isalpha()\n",
      "\n",
      "if f != 0:\n",
      "    sys.stdout.write(\"\\n%c is a letter in\"%(d))\n",
      "    f = d.isupper()\n",
      "    if f != 0:\n",
      "        sys.stdout.write(\" Capital case\")\n",
      "    else:\n",
      "        sys.stdout.write(\" Small case\")\n",
      "else:\n",
      "    f = d.isdigit()\n",
      "    if f != 0:\n",
      "        sys.stdout.write(\"\\n%c is a digit\"%(d))\n",
      "    else:\n",
      "        f = d.ispunct()\n",
      "        if f != 0:\n",
      "            sys.stdout.write(\"\\n%c is a punctuation symbol\"%(d))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "name": "stdout",
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Enter any character : C\n"
       ]
      },
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "\n",
        "C is a letter in Capital case"
       ]
      }
     ],
     "prompt_number": 5
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [],
     "language": "python",
     "metadata": {},
     "outputs": []
    }
   ],
   "metadata": {}
  }
 ]
}