Added course files

08856433 · Christian Godenschwager · 11f4a0e1 · 08856433 · 08856433 · 08856433
Commit 08856433 authored Apr 20, 2018 by Christian Godenschwager
--- a/cppcourse/.gitignore
+++ b/cppcourse/.gitignore
+.ipynb_checkpoints
\ No newline at end of file
--- a/cppcourse/ClassTemplateFunctionDefinition.ipynb
+++ b/cppcourse/ClassTemplateFunctionDefinition.ipynb
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "template <typename T>\n",
+    "class Counter\n",
+    "{\n",
+    "public:\n",
+    "    Counter();\n",
+    "    void increment();\n",
+    "    T getValue() const;\n",
+    "private:\n",
+    "    T v_;\n",
+    "};"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "template< typename T >\n",
+    "Counter<T>::Counter() : v_(0) {}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "template< typename T >\n",
+    "void Counter<T>::increment()\n",
+    "{\n",
+    "    ++v_;\n",
+    "}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "template< typename T >\n",
+    "T Counter<T>::getValue() const\n",
+    "{\n",
+    "    return v_;\n",
+    "}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "Counter<short> ctr;"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "ctr.increment();"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "1"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "ctr.getValue()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "C++14",
+   "language": "C++14",
+   "name": "xeus-cling-cpp14"
+  },
+  "language_info": {
+   "codemirror_mode": "text/x-c++src",
+   "file_extension": ".cpp",
+   "mimetype": "text/x-c++src",
+   "name": "c++",
+   "version": "14"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
+%% Cell type:code id: tags:
+
+``` C++14
+template <typename T>
+class Counter
+{
+public:
+    Counter();
+    void increment();
+    T getValue() const;
+private:
+    T v_;
+};
+```
+
+%% Cell type:code id: tags:
+
+``` C++14
+template< typename T >
+Counter<T>::Counter() : v_(0) {}
+```
+
+%% Cell type:code id: tags:
+
+``` C++14
+template< typename T >
+void Counter<T>::increment()
+{
+    ++v_;
+}
+```
+
+%% Cell type:code id: tags:
+
+``` C++14
+template< typename T >
+T Counter<T>::getValue() const
+{
+    return v_;
+}
+```
+
+%% Cell type:code id: tags:
+
+``` C++14
+Counter<short> ctr;
+```
+
+%% Cell type:code id: tags:
+
+``` C++14
+ctr.increment();
+```
+
+%% Cell type:code id: tags:
+
+``` C++14
+ctr.getValue()
+```
+
+%% Output
+
+    1
+
+%% Cell type:code id: tags:
+
+``` C++14
+```
--- a/cppcourse/Homework_A.ipynb
+++ b/cppcourse/Homework_A.ipynb
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Homework A"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Write a function that parses the values from a matrix given as a string to a `std::vector`. A sample 3x4 matrix may be given like this:\n",
+    "\n",
+    "```\n",
+    "2.0 3.2 5.6 7.8\n",
+    "1.0 4.3 6.9 4.4\n",
+    "6.8 2.0 10.8 9.1\n",
+    "```\n",
+    "\n",
+    "Use `double` as a dataype for your vector. Store the values to the vector using [row-major order](https://en.wikipedia.org/wiki/Row-_and_column-major_order). Your function should also report the number of rows `m` and the number of columns `n` to the caller. Implement the following signature:\n",
+    "\n",
+    "```c++\n",
+    "void readMatrix( const std::string & matrix, std::vector<double> & values, unsigned int & m, unsigned int & n )\n",
+    "```\n",
+    "\n",
+    "Also write the opposite function that converts the matrix back to a string:\n",
+    "\n",
+    "```c++\n",
+    "std::string matrixToString( const std::vector<double> & values, const unsigned int m, const unsigned int n )\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "// readMatrix"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "// matrixToString"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "std::string matrix(\"2.0 3.2 5.6 7.8\\n1.0 4.3 6.9 4.4\\n6.8 2.0 10.8 9.1\");"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "unsigned int n, m;\n",
+    "std::vector<double> values;"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#include <iostream>\n",
+    "\n",
+    "readMatrix( matrix, values, m, n );\n",
+    "values"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "m // should be 3"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "n // should be 4"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "matrixToString( values, m , n )"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Also test some corner cases:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "std::string m1(\"2.0\"); // 1x1"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "std::string m2(\"\"); // empty matrix (0x0)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "C++14",
+   "language": "C++14",
+   "name": "xeus-cling-cpp14"
+  },
+  "language_info": {
+   "codemirror_mode": "text/x-c++src",
+   "file_extension": ".cpp",
+   "mimetype": "text/x-c++src",
+   "name": "c++",
+   "version": "14"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
+%% Cell type:markdown id: tags:
+
+# Homework A
+
+%% Cell type:markdown id: tags:
+
+Write a function that parses the values from a matrix given as a string to a `std::vector`. A sample 3x4 matrix may be given like this:
+
+```
+2.0 3.2 5.6 7.8
+1.0 4.3 6.9 4.4
+6.8 2.0 10.8 9.1
+```
+
+Use `double` as a dataype for your vector. Store the values to the vector using [row-major order](https://en.wikipedia.org/wiki/Row-_and_column-major_order). Your function should also report the number of rows `m` and the number of columns `n` to the caller. Implement the following signature:
+
+```c++
+void readMatrix( const std::string & matrix, std::vector<double> & values, unsigned int & m, unsigned int & n )
+```
+
+Also write the opposite function that converts the matrix back to a string:
+
+```c++
+std::string matrixToString( const std::vector<double> & values, const unsigned int m, const unsigned int n )
+```
+
+%% Cell type:code id: tags:
+
+``` C++14
+// readMatrix
+```
+
+%% Cell type:code id: tags:
+
+``` C++14
+// matrixToString
+```
+
+%% Cell type:code id: tags:
+
+``` C++14
+std::string matrix("2.0 3.2 5.6 7.8\n1.0 4.3 6.9 4.4\n6.8 2.0 10.8 9.1");
+```
+
+%% Cell type:code id: tags:
+
+``` C++14
+unsigned int n, m;
+std::vector<double> values;
+```
+
+%% Cell type:code id: tags:
+
+``` C++14
+#include <iostream>
+
+readMatrix( matrix, values, m, n );
+values
+```
+
+%% Cell type:code id: tags:
+
+``` C++14
+m // should be 3
+```
+
+%% Cell type:code id: tags:
+
+``` C++14
+n // should be 4
+```
+
+%% Cell type:code id: tags:
+
+``` C++14
+matrixToString( values, m , n )
+```
+
+%% Cell type:markdown id: tags:
+
+Also test some corner cases:
+
+%% Cell type:code id: tags:
+
+``` C++14
+std::string m1("2.0"); // 1x1
+```
+
+%% Cell type:code id: tags:
+
+``` C++14
+std::string m2(""); // empty matrix (0x0)
+```
--- a/cppcourse/Homework_A_sol.ipynb
+++ b/cppcourse/Homework_A_sol.ipynb
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Homework A"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Write a function that parses the values from a matrix given as a string to a `std::vector`. A sample 3x4 matrix may be given like this:\n",
+    "\n",
+    "```\n",
+    "2.0 3.2 5.6 7.8\n",
+    "1.0 4.3 6.9 4.4\n",
+    "6.8 2.0 10.8 9.1\n",
+    "```\n",
+    "\n",
+    "Use `double` as a dataype for your vector. Store the values to the vector using [row-major order](https://en.wikipedia.org/wiki/Row-_and_column-major_order). Your function should also report the number of rows `m` and the number of columns `n` to the caller. Implement the following signature:\n",
+    "\n",
+    "```c++\n",
+    "void readMatrix( const std::string & matrix, std::vector<double> & values, \n",
+    "                 unsigned int & m, unsigned int & n )\n",
+    "```\n",
+    "\n",
+    "Also write the opposite function that converts the matrix back to a string:\n",
+    "\n",
+    "```c++\n",
+    "std::string matrixToString( const std::vector<double> & values,\n",
+    "                            unsigned int m, const unsigned int n )\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#include <string>\n",
+    "#include <vector>\n",
+    "#include <sstream>\n",
+    "\n",
+    "void readMatrix( const std::string & matrix, \n",
+    "                 std::vector<double> & values, \n",
+    "                 unsigned int & m, unsigned int & n )\n",
+    "{\n",
+    "    values.clear();\n",
+    "    \n",
+    "    std::istringstream iss(matrix);\n",
+    "    \n",
+    "    std::string line;\n",
+    "    m = 0;\n",
+    "    n = 0;\n",
+    "    while( std::getline( iss, line ) )\n",
+    "    {\n",
+    "        ++m;\n",
+    "        std::istringstream issLine( line );\n",
+    "        double v;\n",
+    "        n = 0;\n",
+    "        while( issLine >> v )\n",
+    "        {\n",
+    "            ++n;\n",
+    "            values.push_back( v );\n",
+    "        }\n",
+    "    }\n",
+    "}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "std::vector<int> vector;\n",
+    "for( int = 0; i < 100; ++i )\n",
+    "{\n",
+    "    vector.assign( 100, i );\n",
+    "    \n",
+    "    // ...\n",
+    "}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "std::string matrixToString( const std::vector<double> & values,\n",
+    "                            const unsigned int m, const unsigned int n )\n",
+    "{\n",
+    "    // we should check whether m * n == values.size() but no error handling yet...\n",
+    "    \n",
+    "    std::ostringstream oss;\n",
+    "    \n",
+    "    size_t idx = 0;\n",
+    "    for( unsigned int i = 0; i < m; ++i )\n",
+    "    {\n",
+    "        if( i > 0 )\n",
+    "            oss << \"\\n\";\n",
+    "        \n",
+    "        for( unsigned int j = 0; j < m; ++j )\n",
+    "        {\n",
+    "            if( j > 0 )\n",
+    "                oss << \" \";\n",
+    "            \n",
+    "            oss << values[idx];\n",
+    "            \n",
+    "            ++idx;            \n",
+    "        }\n",
+    "    }\n",
+    "    \n",
+    "    return oss.str();\n",
+    "}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "std::string matrix(\"2.0 3.2 5.6 7.8\\n1.0 4.3 6.9 4.4\\n6.8 2.0 10.8 9.1\");"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "unsigned int n, m;\n",
+    "std::vector<double> values;"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{ 2, 3.2, 5.6, 7.8, 1, 4.3, 6.9, 4.4, 6.8, 2, 10.8, 9.1 }"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "#include <iostream>\n",
+    "\n",
+    "readMatrix( matrix, values, m, n );\n",
+    "values"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "3"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "m // should be 3"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "4"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "n // should be 4"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "\"2 3.2 5.6\n",
+       "7.8 1 4.3\n",
+       "6.9 4.4 6.8\""
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "matrixToString( values, m , n )"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Also test some corner cases:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "std::string m1(\"2.0\"); // 1x1"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "std::string m2(\"\"); // empty matrix (0x0)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,