Starta på 13

lab_2/13/Makefile

@@ -0,0 +1,21 @@
+binary = memleak
+folder = memleak
+objects = $(patsubst %.cpp,%.o,$(wildcard *.cpp))
+
+run: $(binary)
+	./$(binary) 7 100000000
+
+$(binary): $(objects)
+	g++ -o $@ $^
+
+clean:
+	rm -f *.o
+
+clear: clean
+	rm -f *.zip $(binary)
+
+zip: clean
+	zip $(folder) Makefile *.cpp *.h
+
+profile:
+	g++ -pg *.cpp -o $@ $^

lab_2/13/chain-random-walk.cpp

@@ -0,0 +1,80 @@
+#include <cstdlib>
+#include <iomanip>
+#include <iostream>
+
+#include "chain-random-walk.h"
+
+using namespace crw;
+
+namespace {
+   // set each element forward or backward by 1, at random
+   void stochastic_unit_step(long size, float config[])
+   {
+      for(long i = 0; i < size; i++)
+         if(std::rand() % 2 == 0) config[i]++;
+         else config[i]--;
+   }
+   
+   void shift_centre_to_origin(long size, float config[])
+   {
+       double sum = 0.0;
+       for(long i = 0; i < size; i++) sum += config[i];
+
+       const float ratio = sum/size;
+       for(long i = 0; i < size; i++) config[i] -= ratio;
+   }
+   
+   const int el_out_max = 9;  // show at most the first nine elements
+}
+
+float crw::elongation(long size, float config[])
+{
+   float min = config[0];
+   float max = config[0];
+   
+   for(long i = 1; i < size; i++)
+      if(config[i] > max) max = config[i];
+      else if(config[i] < min) min = config[i];
+
+   return max - min;
+}
+
+
+float* crw::step(long size, float previous[])
+{
+   // allocate the next configuration
+   float* config = new float[size]();
+    
+   // first, let the chain contract: each element is attracted by its neighbours
+   for(long i = 0; i < size; i++)
+      config[i] = 0.5*previous[i] + 0.25*previous[(i-1) % size]*2;
+
+   stochastic_unit_step(size, config);  // actual random walk step
+   shift_centre_to_origin(size, config);  // shift such that the average remains zero
+
+   return config;
+}
+
+void crw::output(long no, long size, float present[], float extreme[], double avg_el)
+{
+   /* output statistics over the run so far 
+    */
+   std::cout << std::setw(12) << no << "\t" << std::setprecision(3) << std::fixed
+             << std::setw(6) << elongation(size, present) << " "
+             << std::setprecision(7) << std::setw(10) << avg_el << " " << std::setprecision(5) 
+             << std::setw(9) << elongation(size, extreme) << std::setprecision(3) << "\t\t";
+   
+   /* display the present configuration, showing up to <el_out_max> element coordinates */
+   for(long i = 0; (i < size) && (i < el_out_max); i++)
+       std::cout << std::setw(7) << present[i] << " ";
+   if(size > el_out_max) std::cout << "...";
+   std::cout << "\t\t";
+    
+   /* display the most extreme configuration so far,
+    * showing up to <el_out_max> element coordinates
+    */
+   for(long i = 0; (i < size) && (i < el_out_max); i++)
+       std::cout << std::setw(7) << extreme[i] << " ";
+   if(size > el_out_max) std::cout << "...";
+   std::cout << "\n";
+}

lab_2/13/chain-random-walk.h

@@ -0,0 +1,11 @@
+#ifndef CHAIN_RANDOM_WALK_H
+#define CHAIN_RANDOM_WALK_H
+
+namespace crw
+{
+   float elongation(long size, float config[]);
+   float* step(long size, float previous[]);
+   void output(long no, long size, float present[], float extreme[], double avg_el);
+}
+
+#endif

lab_2/13/memleak.cpp

@@ -0,0 +1,66 @@
+#include <cassert>
+#include <cstdlib>
+#include <ctime>
+
+#include "chain-random-walk.h"
+
+namespace {
+   constexpr int default_size = 7;
+   constexpr int default_steps = 100000000;
+   constexpr int outlines = 25;
+}
+
+/* first argument: array size
+ * second argument: number of steps
+ */
+int main(int argc, char** argv)
+{
+   long size = default_size;
+   if(argc > 1) size = std::atol(argv[1]);
+   assert(size > 0);
+    
+   long steps = default_steps;
+   if(argc > 2) steps = std::atol(argv[2]);
+   assert(steps > 0);
+    
+   long outfreq = steps / outlines;
+   if(outfreq < 1) outfreq = 1;
+    
+   /* the configuration is given by an array of float numbers */
+   float* present_configuration = new float[size]();
+
+   /* store the one with greatest deviation between min and max element */
+   float* extreme_configuration = present_configuration;
+   float extreme_elongation = 0.0;
+   double el_sum = 0.0;
+   double el_avg = 0.0;
+
+   std::srand(std::time(nullptr)); // initialize the random number generator
+   
+   for(long i = 0; i < steps; i++)
+   {
+      if(i % outfreq == 0)
+         crw::output(i, size, present_configuration, extreme_configuration, el_avg);
+      
+      /* here we are calling the random walk step;
+       * this returns a new configuration (float array) on the heap
+       */
+
+      // Simple fix to memleak:
+      float* old_configuration = present_configuration;
+      present_configuration = crw::step(size, present_configuration);
+      delete[] old_configuration;
+      float present_elongation = crw::elongation(size, present_configuration);
+
+      if(present_elongation > extreme_elongation)
+      {
+          extreme_configuration = present_configuration;
+          extreme_elongation = present_elongation;
+      }
+      el_sum += present_elongation;
+      el_avg = el_sum / (i + 1.0);
+   }
+   crw::output(steps, size, present_configuration, extreme_configuration, el_avg);
+
+   delete[] present_configuration;
+}