{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "C++\n", "====\n", "\n", "A brief introduction to features of C++ that are not found in C, using C++11 features where possible. We will assume the following `#includes` in the code snippets. As usual, we will exclude classes and any discussion of object-oriented programming.\n", "\n", "```c++\n", "#include \n", "#include \n", "#include \n", "#include \n", "#include \n", "#include \n", "#include \"/usr/local/include/armadillo\"\n", "```" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Hello, world\n", "\n", "Note the use of the `iostream` library and the standard namepace qualification `std::cout`." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "```c++\n", "int main()\n", "{\n", " std::cout << \"Hello, world!\\n\";\n", "}\n", "```" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Namespaces\n", "\n", "Just like Python, C++ has namespaces that allow us to build large libraries without worrying about name collisions. In the `Hello world` program, we used the explicit name `std::cout` indicating that `cout` is a member of the standard workspace. We can also use the `using` keyword to import selected functions or classes from a namespace. \n", "\n", "```c++\n", "using std::cout;\n", "\n", "int main()\n", "{\n", " cout << \"Hello, world!\\n\";\n", "}\n", "```\n", "\n", "For small programs, we sometimes import the entire namespace for convenience, but this may cause namespace collisions in larger programs.\n", "\n", "```c++\n", "using namespace std;\n", "\n", "int main()\n", "{\n", " cout << \"Hello, world!\\n\";\n", "}\n", "```\n", "\n", "You can easily create your own namespace.\n", "\n", "```c++\n", "namespace sta_663 {\n", " const double pi=2.14159;\n", "\n", " void greet(string name) {\n", " cout << \"\\nTraditional first program\\n\";\n", " cout << \"Hello, \" << name << \"\\n\";\n", " }\n", "}\n", "\n", "int main() \n", "{\n", " cout << \"\\nUsing namespaces\\n\";\n", " string name = \"Tom\";\n", " cout << sta_663::pi << \"\\n\";\n", " sta_663::greet(name);\n", "}\n", "```" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Looping\n", "\n", "Note the traditional for loop and the new range for loop. There is also a `while` loop (not shown).\n", "\n", "```c++\n", "// for loops\n", "int main() \n", "{\n", " int x[] = {1, 2, 3, 4, 5};\n", "\n", " cout << \"\\nTraditional for loop\\n\";\n", " for (int i=0; i < sizeof(x)/sizeof(x[0]); i++) {\n", " cout << i << endl;\n", " }\n", "\n", " cout << \"\\nRanged for loop\\n\\n\";\n", " for (auto &i : x) {\n", " cout << i << endl;\n", " }\n", "}\n", "```" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Exercise 1**\n", "\n", "Use loop to generate the 12 by 12 times table. Compile and run. You don't have to worry much about formatting, but the output should have 12 rows with numbers separated by spaces." ] }, { "cell_type": "code", "execution_count": 1, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Overwriting ex1.cpp\n" ] } ], "source": [ "%%file ex1.cpp\n", "#include \n", "#include \n", "\n", "int main()\n", "{\n", " for (int i=1; i<=12; i++) {\n", " for (int j=1; j<=12; j++) {\n", " std::cout << std::setw(3) << i*j << ' ';\n", " }\n", " std::cout << \"\\n\";\n", " }\n", "}" ] }, { "cell_type": "code", "execution_count": 2, "metadata": { "collapsed": false }, "outputs": [], "source": [ "%%bash\n", "g++ ex1.cpp -o ex1" ] }, { "cell_type": "code", "execution_count": 3, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " 1 2 3 4 5 6 7 8 9 10 11 12 \n", " 2 4 6 8 10 12 14 16 18 20 22 24 \n", " 3 6 9 12 15 18 21 24 27 30 33 36 \n", " 4 8 12 16 20 24 28 32 36 40 44 48 \n", " 5 10 15 20 25 30 35 40 45 50 55 60 \n", " 6 12 18 24 30 36 42 48 54 60 66 72 \n", " 7 14 21 28 35 42 49 56 63 70 77 84 \n", " 8 16 24 32 40 48 56 64 72 80 88 96 \n", " 9 18 27 36 45 54 63 72 81 90 99 108 \n", " 10 20 30 40 50 60 70 80 90 100 110 120 \n", " 11 22 33 44 55 66 77 88 99 110 121 132 \n", " 12 24 36 48 60 72 84 96 108 120 132 144 \n" ] } ], "source": [ "%%bash\n", "./ex1" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Functions and Lambdas\n", "\n", "```c++\n", "// simple funciton\n", "int add0(int a, int b) {\n", " return a + b;\n", "}\n", "\n", "// simple function with reference variables\n", "void add1(int a, int b, int& c) {\n", " c = a + b;\n", "}\n", "\n", "// lambda function\n", "auto add2 = [] (int a, int b) { return a + b; };\n", "\n", "int main() {\n", "\n", " cout << \"\\nStandard function\\n\";\n", " int a = 3, b = 4;\n", " cout << add0(a, b) << endl;\n", "\n", " int c = 0;\n", " cout << \"\\nStandard with reference varaibles\\n\";\n", "\n", " add1(a, b, c);\n", " cout << c << endl;\n", "\n", " cout << \"\\nLambda function\\n\";\n", " cout << add2(a, b) << endl;\n", "\n", " auto add3 = [c] (int a, int b) { return c * add2(a, b); };\n", "\n", " c -= 5;\n", " cout << \"\\nLambda function with value capture\\n\";\n", " cout << add3(a, b) << endl;\n", "\n", " auto add4 = [&c] (int a, int b) { return c * add2(a, b); };\n", "\n", " cout << \"\\nLambda function with reference capture\\n\";\n", " cout << add4(a, b) << endl;\n", "\n", "}\n", "```" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Templates\n", "\n", "```c++\n", "// templates\n", "template \n", "T add5(T a, T b) { return a + b; }\n", "\n", "int main() \n", "{\n", "\n", " cout << \"\\nTemplate function with ints\\n\";\n", " cout << add5(3, 4) << endl;\n", "\n", " cout << \"\\nTemplate function with doubles\\n\";\n", " cout << add5(3.14, 2.78) << endl;\n", "}\n", "```" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Iterators\n", "\n", "```c++\n", "int main() \n", "{\n", " int x[] = {1, 2, 3, 4, 5};\n", "\n", " cout << \"\\nUsing iterators\\n\";\n", " for (auto it=begin(x); it != end(x); it++) {\n", " cout << *it << endl;\n", " }\n", "}\n", "```" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Containers\n", "\n", "```c++\n", "int main() \n", "{\n", " vector v = {1,2,3};\n", "\n", " cout << \"\\nUsing the vector container\\n\";\n", " for (auto it=begin(v); it != end(v); it++) {\n", " cout << *it << endl;\n", " }\n", "\n", " v.push_back(4);\n", " v.push_back(5);\n", " cout << \"\\nGrowing the vector container\\n\";\n", " for (auto it=begin(v); it != end(v); it++) {\n", " cout << *it << endl;\n", " }\n", "\n", " v.pop_back();\n", " cout << \"\\nShrinking the vector container\\n\";\n", " for (auto it=begin(v); it != end(v); it++) {\n", " cout << *it << endl;\n", " }\n", "\n", " cout << \"\\nUsing the unordered_map container\\n\";\n", " unordered_map dict = { {\"ann\", 23}, {\"bob\", 32}, {\"charles\", 17}};\n", " dict[\"doug\"] = 30;\n", " for (auto it=begin(dict); it != end(dict); it++) {\n", " cout << it->first << \", \" << it->second << endl;\n", " }\n", "\n", " cout << dict[\"bob\"] << endl;\n", "}\n", "```" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Exercise 2**\n", " \n", "Write a function that takes a vector of doubles returns the squared vector. Compile and run the function with the initial vector containing 1.0, 2.0, 3.0, 4.0, 5.0." ] }, { "cell_type": "code", "execution_count": 4, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Overwriting ex2.cpp\n" ] } ], "source": [ "%%file ex2.cpp\n", "#include \n", "#include \n", "using std::vector;\n", "using std::cout;\n", "\n", "vector squares(vector xs) {\n", " vector ys(xs.size());\n", " for (int i=0; i xs = {1.0, 2.0, 3.0, 4.0, 5.0};\n", "\n", " auto ys = squares(xs);\n", "\n", " for (auto& y: ys) {\n", " cout << y << \", \";\n", " }\n", " cout << \"\\n\";\n", "}" ] }, { "cell_type": "code", "execution_count": 5, "metadata": { "collapsed": false }, "outputs": [], "source": [ "%%bash\n", "g++ -std=c++11 ex2.cpp -o ex2" ] }, { "cell_type": "code", "execution_count": 6, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "1, 4, 9, 16, 25, \n" ] } ], "source": [ "%%bash\n", "./ex2" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**EXercise 3**\n", "\n", "Convert the function from Exercise 2 so that it works for lists or vectors of ints, floats and doubles." ] }, { "cell_type": "code", "execution_count": 7, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Overwriting ex3.cpp\n" ] } ], "source": [ "%%file ex3.cpp\n", "#include \n", "#include \n", "using std::vector;\n", "using std::cout;\n", "\n", "template\n", "vector squares(vector xs) {\n", " vector ys(xs.size());\n", " for (int i=0; i xs = {1, 2, 3, 4, 5};\n", "\n", " auto ys = squares(xs);\n", "\n", " for (auto& y: ys) {\n", " cout << y << \", \";\n", " }\n", " cout << \"\\n\";\n", "}" ] }, { "cell_type": "code", "execution_count": 8, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "1, 4, 9, 16, 25, \n" ] } ], "source": [ "%%bash\n", "./ex3" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Algorithms\n", "\n", "```c++\n", "int main()\n", "{\n", "void show_algorithms() {\n", " vector v(10, 0);\n", "\n", " cout << \"\\nWorking with standard library algorithm\\n\";\n", " cout << \"\\nInitial state\\n\";\n", " for (auto it=begin(v); it != end(v); it++) {\n", " cout << *it << \" \";\n", " }\n", " cout << endl;\n", "\n", " cout << \"\\nAfter iota\\n\";\n", " iota(begin(v), end(v), 5);\n", " for (auto it=begin(v); it != end(v); it++) {\n", " cout << *it << \" \";\n", " }\n", " cout << endl;\n", "\n", " cout << \"\\nSimple accumulate\\n\";\n", " int s = accumulate(begin(v), end(v), 0);\n", " cout << s << endl;\n", "\n", " cout << \"\\nAccumulate with custom sum of squares reduction\\n\";\n", " int t = accumulate(begin(v), end(v), 0, [] (int acc, int x) { return acc + x*x; });\n", " cout << t << endl;\n", "}\n", "```" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Exercise 4**\n", "\n", "Write a function to calculate the mean of a vector of numbers using `accumulate` from the `` library. Compile and test with some vectors." ] }, { "cell_type": "code", "execution_count": 9, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Overwriting ex4.cpp\n" ] } ], "source": [ "%%file ex4.cpp\n", "#include \n", "#include \n", "#include \n", "using std::vector;\n", "using std::cout;\n", "\n", "template\n", "double mean(vector xs) {\n", " double s = std::accumulate(begin(xs), end(xs), 0);\n", " return s/xs.size();\n", "}\n", "\n", "int main()\n", "{\n", " vector xs = {1, 2, 3, 4, 5};\n", " \n", " double mu = mean(xs);\n", " cout << mu << \"\\n\";\n", "}\n" ] }, { "cell_type": "code", "execution_count": 10, "metadata": { "collapsed": false }, "outputs": [], "source": [ "%%bash\n", "g++ -std=c++11 ex4.cpp -o ex4" ] }, { "cell_type": "code", "execution_count": 11, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "3\n" ] } ], "source": [ "%%bash\n", "./ex4" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Function pointers\n", "\n", "```c++\n", "int main() \n", "{\n", " cout << \"\\nUsing generalized function pointers\\n\";\n", " using func = function;\n", "\n", " auto f1 = [](double x, double y) { return x + y; };\n", " auto f2 = [](double x, double y) { return x * y; };\n", " auto f3 = [](double x, double y) { return x + y*y; };\n", "\n", " double x = 3, y = 4;\n", "\n", " vector funcs = {f1, f2, f3,};\n", "\n", " for (auto& f : funcs) {\n", " cout << f(x, y) << \"\\n\";\n", " }\n", "}\n", "```" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Exercise 5**\n", "\n", "Implement Newton's method in 1D for root finding. Pass in the function and gradient as generalized function pointers. Use the method to find all roots of the polynomial equation $f(x) = x^3 - 7x - 6$" ] }, { "cell_type": "code", "execution_count": 1, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Writing ex5.cpp\n" ] } ], "source": [ "%%file ex5.cpp\n", "#include \n", "#include \n", "#include \n", "#include \n", "#include \n", "#include \n", "using std::vector;\n", "using std::cout;\n", "using std::function;\n", "\n", "using func = function;\n", "\n", "double newton(double x0, func f, func grad, int max_iter=10) {\n", " double x = x0;\n", " for (int i=0; i x = {-5, 0, 5};\n", " for (auto& x0: x) {\n", " cout << std::setw(2) << x0 << \": \" << std::setw(3) << newton(x0, f, grad) << \"\\n\";\n", " }\n", "}" ] }, { "cell_type": "code", "execution_count": 2, "metadata": { "collapsed": false }, "outputs": [], "source": [ "%%bash\n", "g++ -std=c++11 ex5.cpp -o ex5" ] }, { "cell_type": "code", "execution_count": 3, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "-5: -2\n", " 0: -1\n", " 5: 3\n" ] } ], "source": [ "%%bash\n", "./ex5" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Random numbers\n", "\n", "C++ now comes with its own collection of random number generators and quite a broad selection of distributions. See [here](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3551.pdf) for a great explanation.\n", "\n", "```c++\n", "int main() \n", "{\n", " cout << \"\\nGenerating random numbers\\n\";\n", "\n", " // start random number engine wiht fixed seed\n", " default_random_engine re{12345};\n", "\n", " uniform_int_distribution uniform(1,6); // lower and upper bounds\n", " poisson_distribution poisson(30); // rate\n", " student_t_distribution t(10); // degrees of freedom\n", "\n", " auto runif = bind (uniform, re);\n", " auto rpois = bind(poisson, re);\n", " auto rt = bind(t, re);\n", "\n", " for (int i=0; i<10; i++) {\n", " cout << runif() << \", \" << rpois() << \", \" << rt() << \"\\n\";\n", "\n", " }\n", "}\n", "```" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Exercise 6**\n", "\n", "Generate 1000 random points from the exponential distribution and save as a comma-separated values (CSV) file. Open the file in Python and plot the distribution using `plt.hist`." ] }, { "cell_type": "code", "execution_count": 15, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Overwriting ex6.cpp\n" ] } ], "source": [ "%%file ex6.cpp\n", "#include \n", "#include \n", "#include \n", "using std::ofstream;\n", "using std::default_random_engine;\n", "using std::exponential_distribution;\n", "\n", "int main() \n", "{\n", " // start random number engine wiht fixed seed\n", " default_random_engine re;\n", " re.seed(12345);\n", "\n", " exponential_distribution exponential(1.0); \n", "\n", " auto rexp = bind (exponential, re);\n", "\n", " int n = 1000;\n", " ofstream fout(\"rexp.csv\");\n", " fout << rexp();\n", " for (int i=1; i" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "xs = np.loadtxt('rexp.csv', delimiter=',')\n", "plt.hist(xs)\n", "pass" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Numeric library\n", "\n", "Armadillo is an accessible library for doing numeric operations, much like `numpy` in Python. Please see [official documentation](http://arma.sourceforge.net/docs.html) for details. It provides vectors, matrices, tensors, linear algebra, statistical functions and a limited set of convenient random number generators.\n", "\n", "```c++\n", "int main() \n", "{\n", " using namespace arma;\n", "\n", " vec u = linspace(0,1,5);\n", " vec v = ones(5);\n", " mat A = randu(4,5); // uniform random deviates\n", " mat B = randn(4,5); // normal random deviates\n", "\n", " cout << \"\\nVecotrs in Armadillo\\n\";\n", " cout << u << endl;\n", " cout << v << endl;\n", " cout << u.t() * v << endl;\n", "\n", " cout << \"\\nRandom matrices in Armadillo\\n\";\n", " cout << A << endl;\n", " cout << B << endl;\n", " cout << A * B.t() << endl;\n", " cout << A * v << endl;\n", "\n", " cout << \"\\nQR in Armadillo\\n\";\n", " mat Q, R;\n", " qr(Q, R, A.t() * A);\n", " cout << Q << endl;\n", " cout << R << endl;\n", "}\n", "```\n", "\n", "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Exercise 7**\n", "\n", "Use the armadillo library to\n", "\n", "- Generate 10 x-coordinates linearly spaced between 10 and 15\n", "- Generate 10 random y-values as $y = 3x^2 - 7x + 2 + \\epsilon$ where $\\epsilon \\sim 10 N(0,1)$\n", "- Find the length of $x$ and $y$ and the Euclidean distance between $x$ and $y$\n", "- Find the correlation between $x$ and $y$\n", "- Solve the linear system to find a quadratic fit for this data" ] }, { "cell_type": "code", "execution_count": 4, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Writing ex7.cpp\n" ] } ], "source": [ "%%file ex7.cpp\n", "#include \n", "#include \n", "#include \n", "using std::cout;\n", "using std::ofstream;\n", "\n", "int main() \n", "{\n", " using namespace arma;\n", "\n", " vec x = linspace(10.0,15.0,10);\n", " vec eps = 10*randn(10);\n", " vec y = 3*x%x - 7*x + 2 + eps; \n", "\n", " cout << \"x:\\n\" << x << \"\\n\";\n", " cout << \"y:\\n\" << y << \"\\n\";\n", "\n", " cout << \"Lenght of x is: \" << norm(x) << \"\\n\";\n", " cout << \"Lenght of y is: \" << norm(y) << \"\\n\";\n", "\n", " cout << \"Distance(x, y) is: \" << norm(x -y) << \"\\n\";\n", "\n", " cout << \"Correlation(x, y) is: \" << cor(x, y) << \"\\n\";\n", "\n", " mat A = join_rows(ones(10), x);\n", " A = join_rows(A, x%x);\n", " cout << \"A:\\n\" << A << \"\\n\";\n", "\n", " vec b = solve(A, y);\n", " cout << \"b:\\n\" << b << \"\\n\";\n", "\n", " ofstream fout1(\"x.txt\");\n", " x.print(fout1);\n", " ofstream fout2(\"y.txt\");\n", " y.print(fout2);\n", " ofstream fout3(\"b.txt\");\n", " b.print(fout3);\n", "}" ] }, { "cell_type": "code", "execution_count": 5, "metadata": { "collapsed": false }, "outputs": [], "source": [ "%%bash\n", "g++ -std=c++11 ex7.cpp -o ex7 -larmadillo " ] }, { "cell_type": "code", "execution_count": 6, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "x:\n", " 10.0000\n", " 10.5556\n", " 11.1111\n", " 11.6667\n", " 12.2222\n", " 12.7778\n", " 13.3333\n", " 13.8889\n", " 14.4444\n", " 15.0000\n", "\n", "y:\n", " 2.4802e+02\n", " 2.6412e+02\n", " 2.9157e+02\n", " 3.3056e+02\n", " 3.4089e+02\n", " 3.9573e+02\n", " 4.4029e+02\n", " 4.7583e+02\n", " 5.2827e+02\n", " 5.8404e+02\n", "\n", "Lenght of x is: 39.8493\n", "Lenght of y is: 1280.16\n", "Distance(x, y) is: 1240.76\n", "Correlation(x, y) is: 0.9887\n", "\n", "A:\n", " 1.0000e+00 1.0000e+01 1.0000e+02\n", " 1.0000e+00 1.0556e+01 1.1142e+02\n", " 1.0000e+00 1.1111e+01 1.2346e+02\n", " 1.0000e+00 1.1667e+01 1.3611e+02\n", " 1.0000e+00 1.2222e+01 1.4938e+02\n", " 1.0000e+00 1.2778e+01 1.6327e+02\n", " 1.0000e+00 1.3333e+01 1.7778e+02\n", " 1.0000e+00 1.3889e+01 1.9290e+02\n", " 1.0000e+00 1.4444e+01 2.0864e+02\n", " 1.0000e+00 1.5000e+01 2.2500e+02\n", "\n", "b:\n", " 5.8621e+02\n", " -1.0156e+02\n", " 6.7586e+00\n", "\n" ] } ], "source": [ "%%bash\n", "./ex7" ] }, { "cell_type": "code", "execution_count": 7, "metadata": { "collapsed": false }, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYUAAAEJCAYAAAB7UTvrAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\ngjHGmCr/D/nCt4i6I7Z8AAAAAElFTkSuQmCC\n", "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "x = np.loadtxt('x.txt')\n", "y = np.loadtxt('y.txt')\n", "b = np.loadtxt('b.txt')\n", "\n", "plt.scatter(x, y, s=40)\n", "plt.plot(x, b[0] + b[1]*x + b[2]*x**2, c='red')\n", "pass" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Collected source code" ] }, { "cell_type": "code", "execution_count": 23, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Overwriting main.cpp\n" ] } ], "source": [ "%%file main.cpp\n", "#include \n", "#include \n", "#include \n", "#include \n", "#include \n", "#include \n", "#include \n", "#include \n", "#include \n", "\n", "using namespace std;\n", "\n", "/* Topics\n", " *\n", " * - for loop\n", " *\n", " *\n", " * - functions\n", " * - lambdas\n", " * - templates\n", " *\n", " * - iterators\n", " * - containers\n", " * - algorithms\n", " * - Armadillo\n", "*/\n", "\n", "// hello world\n", "void show_hello() {\n", " cout << \"Hello, world!\\n\";\n", "}\n", "\n", "namespace sta_663 {\n", " const double pi=2.14159;\n", "\n", " void greet(string name) {\n", " cout << \"\\nTraditional first program\\n\";\n", " cout << \"Hello, \" << name << \"\\n\";\n", " }\n", "}\n", "\n", "void show_namespace() {\n", " cout << \"\\nUsing namespaces\\n\";\n", " string name = \"Tom\";\n", " cout << sta_663::pi << \"\\n\";\n", " sta_663::greet(name);\n", "}\n", "\n", "\n", "// for loops\n", "void show_for() {\n", " int x[] = {1, 2, 3, 4, 5};\n", "\n", " cout << \"\\nTraditional for loop\\n\";\n", " for (int i=0; i < sizeof(x)/sizeof(x[0]); i++) {\n", " cout << i << endl;\n", " }\n", "\n", " cout << \"\\nRanged for loop\\n\\n\";\n", " for (auto &i : x) {\n", " cout << i << endl;\n", " }\n", "}\n", "\n", "// simple funciton\n", "int add0(int a, int b) {\n", " return a + b;\n", "}\n", "\n", "// simple function with reference variables\n", "void add1(int a, int b, int& c) {\n", " c = a + b;\n", "}\n", "\n", "// lambda function\n", "auto add2 = [] (int a, int b) { return a + b; };\n", "\n", "void show_func() {\n", "\n", " cout << \"\\nStandard function\\n\";\n", " int a = 3, b = 4;\n", " cout << add0(a, b) << endl;\n", "\n", " int c = 0;\n", " cout << \"\\nStandard with reference varaibles\\n\";\n", "\n", " add1(a, b, c);\n", " cout << c << endl;\n", "\n", " cout << \"\\nLambda function\\n\";\n", " cout << add2(a, b) << endl;\n", "\n", " auto add3 = [c] (int a, int b) { return c * add2(a, b); };\n", "\n", " c -= 5;\n", " cout << \"\\nLambda function with value capture\\n\";\n", " cout << add3(a, b) << endl;\n", "\n", " auto add4 = [&c] (int a, int b) { return c * add2(a, b); };\n", "\n", " cout << \"\\nLambda function with reference capture\\n\";\n", " cout << add4(a, b) << endl;\n", "\n", "}\n", "\n", "// templates\n", "template \n", "T add5(T a, T b) { return a + b; }\n", "\n", "void show_template() {\n", "\n", " cout << \"\\nTemplate function with ints\\n\";\n", " cout << add5(3, 4) << endl;\n", "\n", " cout << \"\\nTemplate function with doubles\\n\";\n", " cout << add5(3.14, 2.78) << endl;\n", "}\n", "\n", "void show_iterators() {\n", " int x[] = {1, 2, 3, 4, 5};\n", "\n", " cout << \"\\nUsing iterators\\n\";\n", " for (auto it=begin(x); it != end(x); it++) {\n", " cout << *it << endl;\n", " }\n", "}\n", "\n", "void show_containers() {\n", " vector v = {1,2,3};\n", "\n", " cout << \"\\nUsing the vector container\\n\";\n", " for (auto it=begin(v); it != end(v); it++) {\n", " cout << *it << endl;\n", " }\n", "\n", " v.push_back(4);\n", " v.push_back(5);\n", " cout << \"\\nGrowing the vector container\\n\";\n", " for (auto it=begin(v); it != end(v); it++) {\n", " cout << *it << endl;\n", " }\n", "\n", " v.pop_back();\n", " cout << \"\\nShrinking the vector container\\n\";\n", " for (auto it=begin(v); it != end(v); it++) {\n", " cout << *it << endl;\n", " }\n", "\n", " cout << \"\\nUsing the unordered_map container\\n\";\n", " unordered_map dict = { {\"ann\", 23}, {\"bob\", 32}, {\"charles\", 17}};\n", " dict[\"doug\"] = 30;\n", " for (auto it=begin(dict); it != end(dict); it++) {\n", " cout << it->first << \", \" << it->second << endl;\n", " }\n", "\n", " cout << dict[\"bob\"] << endl;\n", "}\n", "\n", "void show_algorithms() {\n", " vector v(10, 0);\n", "\n", " cout << \"\\nWorking with standard library algorithm\\n\";\n", " cout << \"\\nInitial state\\n\";\n", " for (auto it=begin(v); it != end(v); it++) {\n", " cout << *it << \" \";\n", " }\n", " cout << endl;\n", "\n", " cout << \"\\nAfter iota\\n\";\n", " iota(begin(v), end(v), 5);\n", " for (auto it=begin(v); it != end(v); it++) {\n", " cout << *it << \" \";\n", " }\n", " cout << endl;\n", "\n", " cout << \"\\nSimple accumulate\\n\";\n", " int s = accumulate(begin(v), end(v), 0);\n", " cout << s << endl;\n", "\n", " cout << \"\\nAccumulate with custom sum of squares reduction\\n\";\n", " int t = accumulate(begin(v), end(v), 0, [] (int acc, int x) { return acc + x*x; });\n", " cout << t << endl;\n", "}\n", "\n", "void show_functional() {\n", "\n", " cout << \"\\nUsing generalized function pointers\\n\";\n", " using func = function;\n", "\n", " auto f1 = [](double x, double y) { return x + y; };\n", " auto f2 = [](double x, double y) { return x * y; };\n", " auto f3 = [](double x, double y) { return x + y*y; };\n", "\n", " double x = 3, y = 4;\n", "\n", " vector funcs = {f1, f2, f3,};\n", "\n", " for (auto& f : funcs) {\n", " cout << f(x, y) << \"\\n\";\n", " }\n", "\n", "}\n", "\n", "void show_random() {\n", " cout << \"\\nGenerating random numbers\\n\";\n", "\n", " // start random number engine wiht fixed seed\n", " default_random_engine re{12345};\n", "\n", " uniform_int_distribution uniform(1,6); // lower and upper bounds\n", " poisson_distribution poisson(30); // rate\n", " student_t_distribution t(10); // degrees of freedom\n", "\n", " auto runif = bind (uniform, re);\n", " auto rpois = bind(poisson, re);\n", " auto rt = bind(t, re);\n", "\n", " for (int i=0; i<10; i++) {\n", " cout << runif() << \", \" << rpois() << \", \" << rt() << \"\\n\";\n", " }\n", "}\n", "\n", "void show_amrmadillo() {\n", " using namespace arma;\n", "\n", " vec u = linspace(0,1,5);\n", " vec v = ones(5);\n", " mat A = randu(4,5);\n", " mat B = randn(4,5);\n", "\n", " cout << \"\\nVecotrs in Armadillo\\n\";\n", " cout << u << endl;\n", " cout << v << endl;\n", " cout << u.t() * v << endl;\n", "\n", " cout << \"\\nRandom matrices in Armadillo\\n\";\n", " cout << A << endl;\n", " cout << B << endl;\n", " cout << A * B.t() << endl;\n", " cout << A * v << endl;\n", "\n", " cout << \"\\nQR in Armadillo\\n\";\n", " mat Q, R;\n", " qr(Q, R, A.t() * A);\n", " cout << Q << endl;\n", " cout << R << endl;\n", "}\n", "\n", "int main() {\n", " show_hello();\n", " show_namespace();\n", " show_for();\n", " show_func();\n", " show_template();\n", " show_iterators();\n", " show_containers();\n", " show_algorithms();\n", " show_functional();\n", " show_random();\n", " show_amrmadillo();\n", "}" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Compilation\n", "----" ] }, { "cell_type": "code", "execution_count": 1, "metadata": { "collapsed": false }, "outputs": [], "source": [ "%%bash\n", "g++ -std=c++11 -o main ex6.cpp -larmadillo" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Execution\n", "----" ] }, { "cell_type": "code", "execution_count": 2, "metadata": { "collapsed": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "x:\n", " 10.0000\n", " 10.5556\n", " 11.1111\n", " 11.6667\n", " 12.2222\n", " 12.7778\n", " 13.3333\n", " 13.8889\n", " 14.4444\n", " 15.0000\n", "\n", "y:\n", " 2.4802e+02\n", " 2.6412e+02\n", " 2.9157e+02\n", " 3.3056e+02\n", " 3.4089e+02\n", " 3.9573e+02\n", " 4.4029e+02\n", " 4.7583e+02\n", " 5.2827e+02\n", " 5.8404e+02\n", "\n", "Lenght of x is: 39.8493\n", "Lenght of y is: 1280.16\n", "Distance(x, y) is: 1240.76\n", "Correlation(x, y) is: 0.9887\n", "\n", "A:\n", " 1.0000e+00 1.0000e+01 1.0000e+02\n", " 1.0000e+00 1.0556e+01 1.1142e+02\n", " 1.0000e+00 1.1111e+01 1.2346e+02\n", " 1.0000e+00 1.1667e+01 1.3611e+02\n", " 1.0000e+00 1.2222e+01 1.4938e+02\n", " 1.0000e+00 1.2778e+01 1.6327e+02\n", " 1.0000e+00 1.3333e+01 1.7778e+02\n", " 1.0000e+00 1.3889e+01 1.9290e+02\n", " 1.0000e+00 1.4444e+01 2.0864e+02\n", " 1.0000e+00 1.5000e+01 2.2500e+02\n", "\n", "b:\n", " 5.8621e+02\n", " -1.0156e+02\n", " 6.7586e+00\n", "\n" ] } ], "source": [ "%%bash\n", "\n", "./main" ] }, { "cell_type": "code", "execution_count": null, "metadata": { "collapsed": true }, "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.5.1" } }, "nbformat": 4, "nbformat_minor": 0 }