Restructure and update solutions branch

.gitignore

@@ -6,12 +6,20 @@ exercises/2.1-class-types/test
 exercises/2.2-complex/test
 exercises/3-containers/part1/test
 exercises/3-containers/part2/test
+exercises/4-pointers/pointers
 exercises/5-templates/part1/sum
 exercises/5-templates/part2/test
+exercises/6.1-my-array/part*/my_array
+exercises/6.2-special-pointers/part1/unique
+exercises/6.2-special-pointers/part2/shared
 exercises/8-algorithm/ex
 exercises/9-eigen/explicit
 exercises/9-eigen/implicit
 exercises/9-eigen/sparse
 exercises/9-eigen/*.txt
 exercises/9-eigen/*.gif
-exercises/10-threads/area
+exercises/10-threads/area
+
+lectures/1-cpp-intro/auto/auto
+lectures/1-cpp-intro/hello/hello
+lectures/1-cpp-intro/sum/sum

AUTHORS

@@ -0,0 +1,2 @@
+Rupert Nash
+Joseph Lee

README.md

@@ -1,8 +1,8 @@
 # Modern C++ for Computational Scientists
 
-Repository view: <https://github.com/EPCCed/archer2-CPP-2021-07-20>
+[Repository view](https://github.com/EPCCed/archer2-cpp/)
 
-Pages view: <https://EPCCed.github.io/archer2-CPP-2021-07-20/>
+[Pages view](https://epcced.github.io/archer2-cpp/)
 
 Since the 2011 revision to the C++ language and standard library, the
 ways it is now being used are quite different. Used well, these

exercises/10-threads/area.cpp

@@ -1,10 +1,6 @@
 #include <cstdio>
 #include <complex>
 #include <chrono>
-#include <vector>
-#include <thread>
-#include <atomic>
-#include <mutex>
 
 using complex = std::complex<double>;
 
@@ -20,66 +16,27 @@ bool in_mandelbrot(const complex& c) {
   return true;
 }
 
-void area(
-  int start,
-  int stop,
-  int npoints,
-  double scale_real,
-  double scale_imag,
-  int& num_inside,
-  std::mutex& mutex
-) {
-  const auto eps = 1.0e-7;
-  const auto shift = complex{-2.0 + eps, 0.0 + eps};
-
-  for (int i = start; i < stop; ++i) {
-    for (int j = 0; j < npoints; ++j) {
-      const auto c = shift + complex{
-        (scale_real * i) / npoints,
-        (scale_imag * j) / npoints
-      };
-      if (in_mandelbrot(c)) {
-        mutex.lock();
-        num_inside++;
-        mutex.unlock();
-      }
-    }
-  }
-}
-
 int main() {
   const auto NPOINTS = 2000;
+
   const auto scale_real = 2.5;
   const auto scale_imag = 1.125;
-
+  const auto eps = 1.0e-7;
+  const auto shift = complex{-2.0 + eps, 0.0 + eps};
   using clock = std::chrono::high_resolution_clock;
   auto start = clock::now();
 
-  std::mutex mutex;
+  // Outer loops run over npoints, initialise z=c
+  // Inner loop has the iteration z=z*z+c, and threshold test
   int num_inside = 0;
-
-  int n_threads = 16;
-  std::vector<std::thread> threads;
-
-  int points_per_thread = NPOINTS / n_threads;
-  int i = 0;
-  int j = 0;
-
-  for (int id = 0; id < n_threads; ++id) {
-    i = id * points_per_thread;
-    j = i + points_per_thread;
-    threads.push_back(
-      std::thread(
-        area, i, j, NPOINTS, scale_real, scale_imag, std::ref(num_inside), std::ref(mutex)
-      )
-    );
-  }
-
-  // Wait for all threads to finish
-  for (auto&& thread : threads) {
-    thread.join();
+  for (int i = 0; i < NPOINTS; ++i) {
+    for (int j = 0; j < NPOINTS; ++j) {
+      const auto c = shift + complex{(scale_real * i) / NPOINTS,
+                                     (scale_imag * j) / NPOINTS};
+      if (in_mandelbrot(c))
+	num_inside++;
+    }
   }
-
   auto finish = clock::now();
 
   // Calculate area and error and output the results

exercises/10-threads/instructions.md

@@ -5,7 +5,7 @@
 Source for this can be obtained from Github. Get a new copy with:
 
 ```
-git clone https://github.com/EPCCed/archer2-CPP-2021-07-20
+git clone https://github.com/EPCCed/archer2-cpp
 ```
 
 or update your existing one with
@@ -17,11 +17,9 @@ git pull
 then you can
 
 ```
-cd archer2-CPP-2021-07-20/exercises/threads
+cd archer2-cpp/exercises/threads
 ```
 
-
-
 `area.cpp` contains a C++ version of the Mandelbrot example which you used in Threaded Programming. 
 
 Parallelise the outer loop of the main computation using C++

exercises/2.1-class-types/complex.cpp

@@ -8,25 +8,21 @@ Complex::Complex(double real, double imag) : re(real), im(imag) {
 }
 
 double Complex::real() {
-  return re;
+  // Return real component
 }
 
-double Complex::imag() {
-  return im;
-}
+/* Add definition of a member function to access the imaginary component */
 
 Complex Complex::conj() {
-  return Complex{re, -im};
+  // Return complex conjugate
 }
 
-double Complex::norm() {
-  return std::sqrt(re*re + im*im);
-}
+/* Add definition of 'norm' member function. Hint: Look up std::sqrt from the
+cmath header to help calculate the magnitude of a complex number */
 
-Complex Complex::add(Complex other_complex) {
-  return Complex{re + other_complex.re, im + other_complex.im};
-}
+/* Add definition of 'add' member function */
 
 bool Complex::equals(Complex other_complex) {
-  return re == other_complex.re && im == other_complex.im;
-}
+  // Return true if the real and imaginary parts of the complex numbers are
+  // equal. False otherwise.
+}

exercises/2.1-class-types/complex.hpp

@@ -4,32 +4,34 @@
 // Simple complex number class
 class Complex {
 public:
-  // Default value is zero
-  Complex() = default;
-  // Construct purely real complex
-  Complex(double real);
-  // Construct from real and imaginary parts
-  Complex(double real, double imag);
+  /* Add declarations to create:
+  - A default constructor
+  - A constructor using just a real component
+  - A constructor using real and imaginary components
+  */
 
   // Access components
   double real();
-  double imag();
+  /* Add declaration to access the imaginary component */
 
   // Compute the complex conjugate
   Complex conj();
 
-  // Compute the magnitude
-  double norm();
+  /* Add declaration for member function 'norm' that takes no arguments and
+  returns the magnitude of the complex number.
+  */
 
-  // Add two complex numbers
-  Complex add(Complex other_complex);
+  /* Add declaration for an 'add' member function as so: z = i.add(j)
+  I.e. For complex numbers i and j, z is the result of i + j. 
+  */
 
   // Check if two complex numbers are equal
   bool equals(Complex other_complex);
 
-private:
-  double re = 0.0;
-  double im = 0.0;
+  /* Add private member variables to store the real and imaginary components of
+  the complex number. These should have type 'double' and a suitable default
+  value.
+  */
 };
 
-#endif
+#endif

exercises/2.1-class-types/test.cpp

@@ -93,4 +93,4 @@ TEST_CASE("Complex number can be added") {
   CheckZminusZeq0(-1);
   CheckZminusZeq0(Complex{1, 2});
   CheckZminusZeq0(Complex{-42, 1e-3});
-}
+}

exercises/2.2-complex/README.md

@@ -11,7 +11,12 @@ The files `complex.hpp` and `complex.cpp` contain a partially working comple
 You can compile and run with:
 
 ```
-$ make && ./testc++ --std=c++14 -I../include   -c -o complex.o complex.cppc++ --std=c++14 -I../include   -c -o test.o test.cppc++ complex.o test.o -o test===============================================================================All tests passed (34 assertions in 6 test cases)
+$ make && ./test
+g++ --std=c++14 -I../include   -c -o complex.o complex.cpp
+g++ --std=c++14 -I../include   -c -o test.o test.cpp
+g++ complex.o test.o -o test
+===============================================================================
+All tests passed (34 assertions in 6 test cases)
 ```
 
 But to get to this point you need to complete the code and fix a few bugs!

exercises/2.2-complex/complex.cpp

@@ -1,13 +1,9 @@
 #include "complex.hpp"
 #include <cmath>
 
-Complex::Complex(double real) : re(real) {
-}
 
-Complex::Complex(double real, double imag) : re(real), im(imag) {
-}
 
-double Complex::real() const {
+double const& Complex::real() {
   return re;
 }
 
@@ -28,7 +24,7 @@ double Complex::norm2() const {
 }
 
 bool operator==(Complex const& a, Complex const& b) {
-  return (a.re == b.re) && (a.im == b.im);
+  return (a.re == b.re) && (a.im == b.re);
 }
 bool operator!=(Complex const& a, Complex const& b) {
   return !(a == b);
@@ -38,16 +34,9 @@ Complex operator+(Complex const& a, Complex const& b) {
   return Complex{a.re + b.re, a.im + b.im};
 }
 
-Complex operator-(Complex const& a, Complex const& b) {
-  return Complex{a.re - b.re, a.im - b.im};
-}
 
 Complex operator*(Complex const& a, Complex const& b) {
   // (a + ib)*(c + id) == (a*c - b*d) + i(b*c + a*d)
-  return Complex{
-    a.re*b.re - a.im*b.im,
-    a.re*b.im + a.im*b.re
-  };
 }
 
 Complex operator-(Complex const& a) {

exercises/2.2-complex/complex.hpp

@@ -7,16 +7,14 @@ class Complex {
   // Default value is zero
   Complex() = default;
   // Construct purely real complex
-  Complex(double real);
   // Construct from real and imaginary parts
-  Complex(double real, double imag);
 
   // Access components
   double real() const;
   double imag() const;
 
   // Compute the complex conjugate
-  Complex conj() const;
+  Complex conj();
 
   // Compute the magnitude and squared magnitude
   double norm() const;
@@ -32,8 +30,6 @@ class Complex {
   friend Complex operator*(Complex const& a, Complex const& b);
   friend Complex operator/(Complex const& a, Complex const& b);
   // Question: how would you declare multiplication and division by a real number?
-  friend Complex operator*(Complex const& a, double const& b);
-  friend Complex operator*(double const& a, Complex const& b);
 
   // Unary negation
   friend Complex operator-(Complex const& a);

exercises/3-containers/part1/vector_ex.cpp

@@ -4,23 +4,5 @@
 // https://en.cppreference.com/w/cpp/container/vector
 
 std::vector<int> GetEven(std::vector<int> const& source) {
-  auto ans = std::vector<int>{};
-  for (auto&& elem: source) {
-    if (elem % 2 == 0)
-      ans.push_back(elem);
-  }
-  return ans;
 }
 
-void PrintVectorOfInt(std::ostream& output, std::vector<int> const& data) {
-  output << "[ ";
-  bool first = true;
-  for (auto const& x: data) {
-    if (!first) {
-      output << ", ";
-    }
-    first = false;
-    output << x;
-  }
-  output << "]";
-}

exercises/3-containers/part2/vector_ex.cpp

@@ -4,23 +4,5 @@
 // https://en.cppreference.com/w/cpp/container/vector
 
 std::vector<int> GetEven(std::vector<int> const& source) {
-  auto ans = std::vector<int>{};
-  for (auto&& elem: source) {
-    if (elem % 2 == 0)
-      ans.push_back(elem);
-  }
-  return ans;
 }
 
-void PrintVectorOfInt(std::ostream& output, std::vector<int> const& data) {
-  output << "[ ";
-  bool first = true;
-  for (auto const& x: data) {
-    if (!first) {
-      output << ", ";
-    }
-    first = false;
-    output << x;
-  }
-  output << "]";
-}

exercises/4-pointers/Makefile

@@ -0,0 +1,10 @@
+CXXFLAGS = --std=c++17
+
+pointers : pointers.o
+	$(CXX) $^ -o $@
+
+run : pointers
+	./pointers
+
+clean :
+	rm -rf *.o pointers