10.data-types-and-operators/20.operators.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "view-in-github",
    "colab_type": "text"
   },
   "source": [
    "<a href=\"https://colab.research.google.com/github/kangwonlee/2018pycpp/blob/main/10.data-types-and-operators/20.operators.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Operators\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Operator precedence\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[[ref0](https://en.cppreference.com/w/cpp/language/operator_precedence), [ref1](https://docs.python.org/3.4/library/operator.html), [ref2](https://www.tutorialspoint.com/python/python_basic_operators.htm)]\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "Precedence | C/C++ Operator | Description | Associativity\n",
    "-- | -- | -- | --\n",
    "1 | :: | Scope resolution | Left-to-right\n",
    "2 | a++ a-- | Suffix/postfix increment and decrement\n",
    "  | type() type{} | Functional cast\n",
    "  | a() | Function call\n",
    "  | a[] | Subscript\n",
    "  | . -> | Member access\n",
    "3 | ++a --a | Prefix increment and decrement | Right-to-left\n",
    " | +a -a | Unary plus and minus\n",
    " | ! ~ | Logical NOT and bitwise NOT\n",
    " | (type) | C-style cast\n",
    " | \\*a | Indirection (dereference)\n",
    " | &a | Address-of\n",
    " | sizeof | Size-of\n",
    " | new new[] | Dynamic memory allocation\n",
    " | delete delete[] | Dynamic memory deallocation\n",
    "4 | .* ->* | Pointer-to-member | Left-to-right\n",
    "5 | a\\*b a/b a%b | Multiplication, division, and remainder\n",
    "6 | a+b a-b | Addition and subtraction\n",
    "7 | << >> | Bitwise left shift and right shift\n",
    "8 | <=> | Three-way comparison operator (since C++20)\n",
    "9 | < <= | For relational operators < and ≤ respectively\n",
    "| \\> >= | For relational operators > and ≥ respectively\n",
    "10 | == != | For relational operators = and ≠ respectively\n",
    "11 | & | Bitwise AND\n",
    "12 | ^ | Bitwise XOR (exclusive or)\n",
    "13 | &#124; | Bitwise OR (inclusive or)\n",
    "14 | && | Logical AND\n",
    "15 | &#124;&#124; | Logical OR\n",
    "16 | a?b:c | Ternary conditional | Right-to-left\n",
    "  | throw | throw operator\n",
    "  | = | Direct assignment (provided by default for C++ classes)\n",
    "  | += -= | Compound assignment by sum and difference\n",
    "  | \\*= /= %= | Compound assignment by product, quotient, and remainder\n",
    "  | <<= >>= | Compound assignment by bitwise left shift and right shift\n",
    "  | &= ^= &vert;= | Compound assignment by bitwise AND, XOR, and OR\n",
    "17 | , | Comma | Left-to-right\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* For example, if you want to evauate adding two integers, please try compiling and running following source code.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%writefile add.cpp\n",
    "// for cout\n",
    "#include <iostream>\n",
    "\n",
    "// declare intention to use std namespace\n",
    "using namespace std;\n",
    "\n",
    "// program starting point\n",
    "int main(int argn, char * argv[]){\n",
    "\n",
    "    // present operation result\n",
    "    cout << \"1 + 2 = \" << 1 + 2 << '\\n';\n",
    "\n",
    "    // indicate that the program succeeded\n",
    "    return 0;\n",
    "}\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!g++ -Wall -g -std=c++14 add.cpp -o add -Wa,-adhln=add.s\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!./add\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "Sr.No. | Python Operator | Description\n",
    "-- | -- | --\n",
    "1 | ** | Exponentiation<br>(raise to the power)\n",
    "2 | ~ + - | Complement, unary plus and minus<br>(method names for the last two are +@ and -@)\n",
    "3 | * / % // | Multiply, divide, modulo and floor division\n",
    "4 | + - | Addition and subtraction\n",
    "5 | >> << | Right and left bitwise shift\n",
    "6 | & | Bitwise 'AND'\n",
    "7 | ^ &vert; | Bitwise exclusive `OR' and regular `OR'\n",
    "8 | <= < > >= | Comparison operators\n",
    "9 | <> == != |  Equality operators\n",
    "10 | %= /= //= -= += \\*= \\*\\*= | Assignment operators\n",
    "11 | is is not | Identity operators\n",
    "12 | in not in | Membership operators\n",
    "13 | not or and | Logical operators\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* To evauate adding two integers or lists in python, please try selecting following cell and press <kbd>Shift</kbd>+<kbd>Enter</kbd>.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# adding two numbers\n",
    "print(f'1 + 2 = {1 + 2}')\n",
    "\n",
    "# adding two lists\n",
    "print(f'[1] + [2] = {[1] + [2]}')\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Some of the notable operators\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Following operators may need some additional attention.\n",
    "\n",
    "| language | operator | description | example |\n",
    "|:--------:|:--------:|:-----------:| ------- |\n",
    "|  both   |   `+=`   | add in place | <pre><code class=\"language-c++\">int a=0;<br>a+=2;</code></pre> |\n",
    "\n",
    "[comment]:<> (https://www.quackit.com/html/tags/html_code_tag.cfm)\n",
    "[comment]:<> (https://stackoverflow.com/questions/4823468/comments-in-markdown)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Let's consider following C/C++ source code.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%writefile hello.cpp\n",
    "#include <iostream>\n",
    "#include <cstdio>\n",
    "\n",
    "int main(int argn, char * argv[]){\n",
    "\n",
    "\tint a = int(argv[0][0]);\n",
    "\tint b = int(argv[0][1]);\n",
    "\tint c = 0;\n",
    "\n",
    "\tprintf(\"argv[0] = %s\\n\", argv[0]);\n",
    "\tprintf(\"argv[1] = %s\\n\", argv[1]);\n",
    "\tprintf(\"argv[2] = %s\\n\\n\", argv[2]);\n",
    "\n",
    "\tprintf(\"a, b, c = %d, %d, %d\\n\", a, b, c);\n",
    "\n",
    "\tb++;\n",
    "\tputs(\"\\nb++\");\n",
    "\tprintf(\"a, b, c = %d, %d, %d\\n\", a, b, c);\n",
    "\n",
    "\tb+=a;\n",
    "\tputs(\"\\nb+=a\");\n",
    "\tprintf(\"a, b, c = %d, %d, %d\\n\", a, b, c);\n",
    "\n",
    "\tc = a + b;\n",
    "\tputs(\"\\nc = a + b\");\n",
    "\tprintf(\"a, b, c = %d, %d, %d\\n\", a, b, c);\n",
    "\n",
    "\treturn 0;\n",
    "\n",
    "}\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!g++ -Wall -g -std=c++14 hello.cpp -o hello -Wa,-adhln=hello.s\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!./hello\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Following is a part of assembly file from `-Wa,-adhln=$(ASM)` option.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%cat hello.s\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Here, let's say we found following instructions around \"`24:hello.cpp`\".\n",
    "\n",
    "``` assembly\n",
    "  24:hello.cpp     ****     c = a + b;\n",
    " 114                      .loc 1 24 0\n",
    " 115 0109 8B55F4           movl    -12(%rbp), %edx\n",
    " 116 010c 8B45F8           movl    -8(%rbp), %eax\n",
    " 117 010f 01D0             addl    %edx, %eax\n",
    " 118 0111 8945FC           movl    %eax, -4(%rbp)\n",
    "```\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* This indicates that `c = a + b` operation happens as follows.\n",
    "\n",
    "\n",
    "1. load `a` value to `%edx`\n",
    "1. load `b` value to `%eax`\n",
    "1. add value at `%edx` to `%eax`\n",
    "1. copy at `%eax` to `c`\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* The following instructions would implement `b += a` operation.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "``` assembly\n",
    "  20:hello.cpp     **** \tb+=a;\n",
    " 100              \t\t.loc 1 20 0\n",
    " 101 00db 8B45F4   \t\tmovl\t-12(%rbp), %eax\n",
    " 102 00de 0145F8   \t\taddl\t%eax, -8(%rbp)\n",
    "```\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. load `a` value to `%eax`\n",
    "1. add value at `%eax` to `b`\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Other compound operators such as `*=` and `%=` also indicate similar operation.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercises\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 00: Bitwise operators\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Please complete following Markdown table with bitwise operators in python and/or C/C++\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "| bitwise operator | expected behavior | available in python | available in C/C++ |\n",
    "|----------|-------------------|---------------------|--------------------|\n",
    "|    &vert;     |    Or     |          y          |         y          |\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 01 : Bitwise operators : python\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Please write a python cell presenting examples of the table above in binary\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 02 : Bitwise operators : C/C++\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Please write a C/C++ program presenting examples of the table above\n",
    "* Please consider using `<bitset>`\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 03* : Bitwise operators : Assembly\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* This is an optional assignment\n",
    "* Generate an Assembly file of the above C++\n",
    "* Duplicate the first table and add one more column indicating assembly *opcode*s\n",
    "\n"
   ]
  },
  {
   "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.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}