20.control-flow/20.functions.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/20.control-flow/20.functions.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": [
    "# Wrapping into Functions<br>and Calling by Value\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* We can define functions in python and C/C++ to modularize the code.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Python\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def main():\n",
    "    # call function add(1, 2) and print its return value\n",
    "    print(add(1, 2))\n",
    "    # call function add('1', '2') and print its return value\n",
    "    print(add('1', '2'))\n",
    "\n",
    "    \n",
    "def add(a, b):\n",
    "    # function returning the addition of a and b\n",
    "    return a + b\n",
    "\n",
    "\n",
    "if \"__main__\" == __name__ :\n",
    "    # this part would run if executed as top level\n",
    "    # == this part would not run if this module is imported\n",
    "    \n",
    "    # here, main() function is called\n",
    "    main()\n",
    "    # this way, main() may be like a program start point\n",
    "    \n",
    "    \n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* C/C++\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "``` C++\n",
    "// int32_t\n",
    "#include <cstdint>\n",
    "// printf\n",
    "#include <cstdio>\n",
    "\n",
    "\n",
    "// Function prototypes\n",
    "// Information to call the functions\n",
    "// return type, function name, arguments, and argument types\n",
    "int32_t add_int(const int32_t a, const int32_t b);\n",
    "double add_double(const double a, const double b);\n",
    "\n",
    "// To avoid writing multiple functions doing the same thing\n",
    "template<typename T> T add(const T a, const T b);\n",
    "\n",
    "\n",
    "// program start point\n",
    "int32_t main(const int32_t argn, const char *argv[]){\n",
    "    // call function add_int(1, 2) and print its return value\n",
    "    printf(\"%d\\n\", add_int(1, 2));\n",
    "    // call function add_double(1.0, 2.0) \n",
    "    // and print its return value\n",
    "    printf(\"%g\\n\", add_double(1.0, 2.0));\n",
    "\n",
    "    // function template example lines\n",
    "    printf(\"%d\\n\", add<int32_t>(3, 4));\n",
    "    printf(\"%g\\n\", add<double>(5.0, 6.0));\n",
    "    \n",
    "    // indicate program success\n",
    "    return 0;\n",
    "}\n",
    "\n",
    "\n",
    "// body of function add_int()\n",
    "int32_t add_int(const int32_t a, const int32_t b){\n",
    "    return a + b;\n",
    "}\n",
    "\n",
    "\n",
    "// body of function add_double()\n",
    "double add_double(const double a, const double b){\n",
    "    return a + b;\n",
    "}\n",
    "// we can see that C/C++ may need more functions \n",
    "// doing something similar but accept different types\n",
    "// as arguments\n",
    "           \n",
    "           \n",
    "// For C++, we may consider using the function template\n",
    "template<typename T> T add(const T a, const T b){\n",
    "    return a + b;\n",
    "}\n",
    "```\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Scope\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Variables within a function is valid only within that function.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Python\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# global variables\n",
    "a = 0\n",
    "c = 'zzz'\n",
    "\n",
    "\n",
    "# declare main() function\n",
    "def main():\n",
    "    # call add function and print its return value\n",
    "    print(add(1, 2))\n",
    "    # call add function and print its return value\n",
    "    print(add('a', 'b'))\n",
    "    # print c value of main() function\n",
    "    print(f'main() : c = {c}')\n",
    "\n",
    "    \n",
    "def add(a, b):\n",
    "    # calculate local variable c within add() function\n",
    "    c = a + b\n",
    "    # print c value of add() function\n",
    "    print(f'add() : c = {c}')\n",
    "\n",
    "    return c\n",
    "\n",
    "\n",
    "if \"__main__\" == __name__ :\n",
    "    main()\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* C/C++\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "``` C++\n",
    "// int32_t\n",
    "#include <cstdint>\n",
    "// std::cout\n",
    "#include <iostream>\n",
    "\n",
    "\n",
    "// Function prototypes\n",
    "// Information to call the functions\n",
    "// return type, function name, arguments, and argument types\n",
    "int32_t add_int(const int32_t a, const int32_t b);\n",
    "double add_double(const double a, const double b);\n",
    "\n",
    "\n",
    "// Global variables\n",
    "int a = 0;\n",
    "char c[] = \"zzz\";\n",
    "\n",
    "\n",
    "// program start point\n",
    "int32_t main(const int32_t argn, const char *argv[]){\n",
    "    // print c value of main() function\n",
    "    std::cout << \"main() : c = \" << c << '\\n';\n",
    "    // call function add_int(1, 2) and print its return value\n",
    "    std::cout << add_int(1, 2) << '\\n';\n",
    "    // call function add_double(1.1, 2.04) \n",
    "    // and print its return value\n",
    "    std::cout << add_double(1.1, 2.04) << '\\n';\n",
    "    // print c value of main() function\n",
    "    std::cout << \"main() : c = \" << c << '\\n';\n",
    "    \n",
    "    // indicate program success\n",
    "    return 0;\n",
    "\n",
    "}\n",
    "\n",
    "\n",
    "// body of function add_int()\n",
    "int32_t add_int(const int32_t a, const int32_t b){\n",
    "\n",
    "    int32_t c = a + b;\n",
    "\n",
    "    std::cout << \"add_int() : c = \" << c << '\\n';\n",
    "\n",
    "    return c;\n",
    "\n",
    "}\n",
    "\n",
    "\n",
    "// body of function add_double()\n",
    "double add_double(const double a, const double b){\n",
    "\n",
    "    double c = a + b;\n",
    "\n",
    "    std::cout << \"add_double() : c = \" << c << '\\n';\n",
    "\n",
    "    return c;\n",
    "\n",
    "}\n",
    "```\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Resolving scope\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* It is possible to access a global variable within a function even if the function has a local variable of the same name.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Global variables\n",
    "a = 0\n",
    "c = 'zzz'\n",
    "\n",
    "\n",
    "def main():\n",
    "    # print c value in main\n",
    "    print(f'main() : c = {c}')\n",
    "    # print return value from add()\n",
    "    print(add(1, 2))\n",
    "    # print c value in main after add()\n",
    "    print(f'main() : c = {c}')\n",
    "    # print return value from add()\n",
    "    print(add('a', 'b'))\n",
    "    # print c value in main after add()\n",
    "    print(f'main() : c = {c}')\n",
    "\n",
    "    \n",
    "def add(a, b):\n",
    "    # this way, we can designate that\n",
    "    # c here is the global variable\n",
    "    global c\n",
    "\n",
    "    c = a + b\n",
    "    # print c value in add()\n",
    "    print(f'add() : c = {c}')\n",
    "\n",
    "    return c\n",
    "\n",
    "\n",
    "if \"__main__\" == __name__ :\n",
    "    main()\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "``` C++\n",
    "// int32_t\n",
    "#include <cstdint>\n",
    "// std::cout\n",
    "#include <iostream>\n",
    "\n",
    "\n",
    "// Function prototypes\n",
    "// Information to call the functions\n",
    "// return type, function name, arguments, and argument types\n",
    "int32_t add_int(const int32_t a, const int32_t b);\n",
    "double add_double(const double a, const double b);\n",
    "\n",
    "\n",
    "// Global variables\n",
    "int32_t a = 0;\n",
    "char c[] = \"zzz\";\n",
    "\n",
    "\n",
    "// program start point\n",
    "int32_t main(const int32_t argn, const char *argv[]){\n",
    "    // print c value in main\n",
    "    std::cout << \"main() : c = \" << c << '\\n';\n",
    "    // print return value from add_int()\n",
    "    std::cout << add_int(1, 2) << '\\n';\n",
    "    // print return value from add_double()\n",
    "    std::cout << add_double(1.1, 2.04) << '\\n';\n",
    "    // print c value in main\n",
    "    std::cout << \"main() : c = \" << c << '\\n';\n",
    "    \n",
    "    // indicate program success\n",
    "    return 0;\n",
    "}\n",
    "\n",
    "\n",
    "// body of function add_int()\n",
    "int32_t add_int(const int32_t a, const int32_t b){\n",
    "    // local variable\n",
    "    const int c = a + b;\n",
    "    // print c value in add_int()\n",
    "    std::cout << \"add_int() : c = \" << c << '\\n';\n",
    "    // print global c value\n",
    "    std::cout << \"add_int() : ::c = \" << ::c << '\\n';\n",
    "    return c;\n",
    "}\n",
    "\n",
    "\n",
    "// body of function add_double()\n",
    "double add_double(const double a, const double b){\n",
    "    // local variable\n",
    "    const double c = a + b;\n",
    "    // print c value in add_double()\n",
    "    std::cout << \"add_double() : c = \" << c << '\\n';\n",
    "    return c;\n",
    "}\n",
    "\n",
    "```\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 00 Adding double precision floats\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Write python and C/C++ functions that can add two double precision floating point variables.\n",
    "* In python and C/C++, write appropriate programs checking the result using `assert` or `assert()`.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 01 Dot product of $1\\times2$ vectors of double precision floats\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Write python and C/C++ functions that can calculate the dot product of two $1\\times2$ double precision floating point vectors using `list`'s or arrays.\n",
    "* In python and C/C++, write appropriate programs checking the result using `assert` or `assert()`.\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.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}