From 4bc1110dd1490693c20dcecb767870f615988d7c Mon Sep 17 00:00:00 2001
From: flavis <christian@flavigny.de>
Date: Thu, 9 Jan 2020 23:12:12 +0100
Subject: [PATCH] add ipi9

---
 ws2019/ipi/uebungen/board.hh      | 138 ++++++++++++++++++++++++++++++
 ws2019/ipi/uebungen/canvas.hh     | 116 +++++++++++++++++++++++++
 ws2019/ipi/uebungen/gameoflife.cc | 125 +++++++++++++++++++++++++++
 ws2019/ipi/uebungen/ipi9.pdf      | Bin 0 -> 24460 bytes
 ws2019/ipi/uebungen/ipi9.tex      |  44 ++++++++++
 ws2019/ipi/uebungen/mandelbrot.cc |  61 +++++++++++++
 ws2019/ipi/uebungen/pgm.hh        |  64 ++++++++++++++
 7 files changed, 548 insertions(+)
 create mode 100644 ws2019/ipi/uebungen/board.hh
 create mode 100644 ws2019/ipi/uebungen/canvas.hh
 create mode 100644 ws2019/ipi/uebungen/gameoflife.cc
 create mode 100644 ws2019/ipi/uebungen/ipi9.pdf
 create mode 100644 ws2019/ipi/uebungen/ipi9.tex
 create mode 100644 ws2019/ipi/uebungen/mandelbrot.cc
 create mode 100644 ws2019/ipi/uebungen/pgm.hh

diff --git a/ws2019/ipi/uebungen/board.hh b/ws2019/ipi/uebungen/board.hh
new file mode 100644
index 0000000..a33423d
--- /dev/null
+++ b/ws2019/ipi/uebungen/board.hh
@@ -0,0 +1,138 @@
+#include <string>
+
+struct BoundaryCondition
+{
+    virtual bool boundary(Board& board, int i, int j) = 0;
+};
+
+class Board {
+    public :
+        // Konstruktor, erzeuge bool* _fields
+        Board(int width, int height, BoundaryCondition cond);
+
+        // Desktruktor, raeume bool* _fields auf
+        ~Board();
+        
+        // copy constructor, intializes by copying from 'other'
+        Board(Board& other);
+
+        // assignment operator
+        Board& operator=(Board& other);
+
+        // gibt die Breite des Bretts zurueck
+        double width();
+
+        // gibt die Hoehe des Bretts zurueck
+        double height();
+
+        // schreibe value an den Pixel (i,j)
+        // Ueberlegen Sie wie aus (i,j) den flachen Index bei row-major bekommen
+        void updateField(int i, int j, bool value);
+
+        // Zugang zum Pixel (i,j) im 1D Array
+        // Ueberlegen Sie wie aus (i,j) den flachen Index bei row-major bekommen
+        int operator()(int i, int j);
+
+        // Gibt zurueck ob Feld am Rand liegt
+        bool touchesBoundary(int i, int j);
+
+        // Gibt Zahl der lebenden Zellen zurueck, die das Feld umgeben
+        int livingCells(int i, int j);
+
+        // Prueft ob Zelle lebt oder nicht
+        bool isLiving(int i, int j);
+
+        // Gibt die BoundaryCondition zurueck
+        BoundaryCondition boundaryCondition();
+
+    private :
+        int _width;
+        int _height;
+        bool* _fields;
+        void copy(Board& other);
+        BoundaryCondition _boundCond;
+};
+
+Board::Board(int width, int height, BoundaryCondition cond) {
+    // initialize all values
+    _width = width;
+    _height = height;
+    _boundCond = cond;
+    _fields = new bool[width * height];
+}
+
+Board::~Board() {
+    _fields = 0;
+}
+
+void Board::copy(Board& other) {
+    _width = other.width();
+    _height = other.height();
+    _boundCond = other.boundaryCondition();
+    _fields = new bool[_width * _height];
+    for (int i = 0; i < _height; i++) {
+        for (int j = 0; j < _width; j++) {
+            updateField(i, j, other.isLiving(i, j));
+        }
+    }
+}
+
+Board::Board(Board& other) {
+    copy(other);
+}
+
+Board& Board::operator=(Board& other) {
+    if (this == &other) {
+        return *this;
+    }
+    copy(other);
+    return *this;
+}
+
+double Board::width() {
+    return _width;
+}
+
+double Board::height() {
+    return _height;
+}
+
+BoundaryCondition Board::BoundaryCondition() {
+    return _boundCond;
+}
+
+void Board::updateField(int i, int j, bool value) {
+    // i = Zeile und wegen row-major Konvention muss i mit der Breite
+    // multipliziert werden
+    _fields[i * _width + j] = value;
+}
+
+bool Board::touchesBoundary(int i, int j) {
+    return i == _height - 1 || i == -1 || j == _width - 1 || j == -1;
+}
+
+int Board::livingCells(int i, int j) {
+    bool surround[8] = { isLiving(i+1, j+1), isLiving(i, j+1), isLiving(i-1, j+1)
+                     , isLiving(i+1, j), isLiving(i-1, j)
+                     , isLiving(i+1, j-1), isLiving(i, j-1), isLiving(i-1, j-1)};
+    int numLiving = 0;
+    for (int i = 0; i < 8; i++) {
+        if (surround[i] == true) {
+            numLiving += 1;
+        }
+    }
+}
+
+bool Board::isLiving(int i, int j) {
+    if (touchesBoundary(i, j)) {
+        return _boundCond.boundary(i, j);
+    } else {
+        return _fields[i * _width + j];
+    }
+}
+
+int Board::operator()(int i, int j) {
+    // i = Zeile und wegen row-major Konvention muss i mit der Breite
+    // Pixel multipliziert werden
+    return _fields[i * _width+ j];
+}
diff --git a/ws2019/ipi/uebungen/canvas.hh b/ws2019/ipi/uebungen/canvas.hh
new file mode 100644
index 0000000..4441c7d
--- /dev/null
+++ b/ws2019/ipi/uebungen/canvas.hh
@@ -0,0 +1,116 @@
+#include <string>
+#include "pgm.hh"
+
+// Komplexe Zahl
+struct Complex
+{
+  double real;
+  double imag;
+};
+
+class Canvas
+{
+public :
+  // Konstruktor, erzeuge int* _pixels
+  Canvas(double center_x, double center_y,
+         double width, double height,
+         int horPixels, int vertPixels);
+
+  // Desktruktor, raeume int* _pixels auf
+  ~Canvas();
+
+  // gibt die Breite des Bildes zurueck
+  double width();
+
+  // gibt die Hoehe des Bildes zurueck
+  double height();
+
+  // gibt die Anzahl an horizontalen Pixeln
+  int horPixels();
+
+  // gibt die Anzahl an vertikalen Pixeln
+  int vertPixels();
+
+  // gebe die Koordinaten des Pixels (i,j) als Complex zurueck
+  Complex coord(int i, int j);
+
+  // schreibe value an den Pixel (i,j)
+  // Ueberlegen Sie wie aus (i,j) den flachen Index bei row-major bekommen
+  void writePixel(int i, int j, int value);
+
+  // Zugang zum Pixel (i,j) im 1D Array
+  // Ueberlegen Sie wie aus (i,j) den flachen Index bei row-major bekommen
+  int operator()(int i, int j);
+
+  // schreibe Bild mit Dateinamen filename
+  void write(std::string filename);
+private :
+  double _center_x;
+  double _center_y;
+  double _width;
+  double _height;
+  int _horPixels;
+  int _vertPixels;
+  int* _pixels;
+};
+
+// diese Methode ist bereits implementiert
+void Canvas::write(std::string filename)
+{
+  write_pgm(_pixels,_horPixels,_vertPixels,filename);
+}
+
+Canvas::Canvas(double center_x, double center_y, double width, double height, int horPixels,
+               int vertPixels) {
+    // initialize all values
+    _center_x = center_x;
+    _center_y = center_y;
+    _width = width;
+    _height = height;
+    _horPixels = horPixels;
+    _vertPixels = vertPixels;
+    _pixels = new int[horPixels * vertPixels];
+}
+
+Canvas::~Canvas() {
+    _pixels = 0;
+}
+
+double Canvas::width() {
+    return _width;
+}
+
+double Canvas::height() {
+    return _height;
+}
+
+int Canvas::horPixels() {
+    return _horPixels;
+}
+
+int Canvas::vertPixels() {
+    return _vertPixels;
+}
+
+Complex Canvas::coord(int i, int j) {
+    Complex c;
+    // Bringe die Pixel mit den echten Laengen ins Verhaeltnis
+    double y = i * (_height / _vertPixels) - _height / 2;
+    double x = j * (_width / _horPixels) - _width / 2;
+    // Gebe die Koordinaten in Relation zum gewuenschten Zentrum aus
+    c.imag = y + _center_y;
+    c.real = x + _center_x;
+    return c;
+}
+
+void Canvas::writePixel(int i, int j, int value) {
+    // i = Zeile und wegen row-major Konvention muss i mit der Zahl der horizontalen
+    // Pixel multipliziert werden
+    _pixels[i*_horPixels + j] = value;
+}
+
+int Canvas::operator()(int i, int j) {
+    // i = Zeile und wegen row-major Konvention muss i mit der Zahl der horizontalen
+    // Pixel multipliziert werden
+    return _pixels[i*_horPixels + j];
+}
diff --git a/ws2019/ipi/uebungen/gameoflife.cc b/ws2019/ipi/uebungen/gameoflife.cc
new file mode 100644
index 0000000..775e947
--- /dev/null
+++ b/ws2019/ipi/uebungen/gameoflife.cc
@@ -0,0 +1,125 @@
+#include <iostream>
+#include <unistd.h> // needed for usleep
+#include <string>
+#include <fstream>
+
+#include "board.hh"
+
+// Basisklassen
+struct Regel
+{
+    virtual void anwenden(Board& board) = 0;
+};
+
+class TorusCondition : public BoundaryCondition
+{
+    bool boundary(Board& board, int i, int j) {
+        if (i == board.height() - 1) {
+            return board.isLiving(0, j);
+        } else if (i == -1) {
+            return board.isLiving(board.height() - 1, j);
+        } else if (j == board.width() - 1) {
+            return board.isLiving(i, 0);
+        } else if (j == -1) {
+            return board.isLiving(i, board.width() - 1);
+        }
+    }
+};
+
+class AliveCondition : public BoundaryCondition
+{
+    bool boundary(Board& board, int i, int j) {
+        return true;
+    }
+};
+
+class DeadCondition : public BoundaryCondition
+{
+    bool boundary(Board& board, int i, int j) {
+        return false;
+    }
+};
+
+class GameOfLifeRules : public Regel
+{
+    public :
+        //void anwenden(Board& board) {
+        //    // copy new board from old board
+        //    Board updated = Board(board.width(), board.height());
+        //    for (int i = 0; i < board.height(); i++) {
+        //        for (int j = 0; i < board.width(); i++) {
+        //            int n = board.livingCells(i, j);
+        //            int self = board.isLiving(i, j);
+        //            if (self && n < 2) {
+        //                updated.updateField(i, j, false);
+        //            } else if (!self && n == 3) {
+        //                updated.updateField(i, j, true);
+        //            } else if (self && n > 3) {
+        //                updated.updateField(i, j, false);
+        //            } else {
+        //                updated.updateField(i, j, self);
+        //            }
+        //        }
+        //    }
+        //    board = updated;
+        //}
+};
+
+// Ein zellulaerer Automat, der Regeln und Datenstrukturen von aussen bekommt
+class Automat
+{
+    public :
+        // der Datentyp fuer das 2D Bool Array
+        Automat(Board& board, Regel& regel)
+            : _board(board)
+            , _regel(regel)
+        {}
+
+        // mache n Schritte
+        void doSteps(int n=1)
+        {
+            for (int i=0; i<n; ++i)
+            {
+                // Linux-spezifische Art und Weise den Inhalt der Konsole zu loeschen
+                // und den Cursor nach oben links zu setzen.
+                //std::cout << "\x1B[2J\x1B[H" << "Step " << i << std::endl << _board;
+                // Das Wiedergeben der Loesung soll immer 10 Sekunden (=1e7 Mikrosekunden)
+                // dauern. Sie koennen diesen Wert auch aendern.
+                usleep(1.e7/n);
+                //_regel.anwenden(_board);
+            }
+        }
+
+    private :
+        Board& _board;
+        Regel& _regel;
+};
+
+int main(int argc, char** argv)
+{
+    if (argc != 2)
+    {
+        std::cout << "Usage: ./<progname> <txt-file>" << std::endl;
+        return 1;
+    }
+
+    Board board = Board(2, 2, AliveCondition);
+    board.updateField(1,1, true);
+    board.livingCells(1,1);
+
+    // Initialisiere Datenstruktur des 2D Bool Array
+    // TODO
+    // Ueberlegen Sie sich wie Sie einen Startzustand in das 2D Bool Array bekommen
+    // Lesen Sie ggf.
+    // (1) eine solche Textdatei mittels Filestream ein
+    // (2) ueberladen Sie Operatoren operator<< oder operator>>
+
+    // TODO
+    // - legen Sie eine Instanz der Randbedingung an
+    // - legen Sie eine Instanz des Regelsystems an
+    // - Initialisieren Sie den zellulaeren Automaten
+
+    // Experimentieren Sie hier mit Ihrem Automaten
+
+    return 0;
+}
diff --git a/ws2019/ipi/uebungen/ipi9.pdf b/ws2019/ipi/uebungen/ipi9.pdf
new file mode 100644
index 0000000000000000000000000000000000000000..18b7528593c004e41357385912f45d6463916c32
GIT binary patch
literal 24460
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

literal 0
HcmV?d00001

diff --git a/ws2019/ipi/uebungen/ipi9.tex b/ws2019/ipi/uebungen/ipi9.tex
new file mode 100644
index 0000000..8e61768
--- /dev/null
+++ b/ws2019/ipi/uebungen/ipi9.tex
@@ -0,0 +1,44 @@
+\documentclass[uebung]{../../../lecture}
+
+\title{IPI: Übungsblatt 9}
+\author{Samuel Weidemaier, Christian Merten}
+
+\usepackage[]{listings}
+
+\usepackage{xcolor}
+ 
+\lstdefinestyle{mystyle}{
+    commentstyle=\color{gray},
+    language=C++,
+    keywordstyle=\color{blue},
+    numberstyle=\tiny\color{gray},
+    stringstyle=\color{black},
+    basicstyle=\ttfamily\footnotesize,
+    breakatwhitespace=false,         
+    breaklines=true,                 
+    captionpos=b,                    
+    keepspaces=true,                 
+    numbers=left,                    
+    numbersep=5pt,                  
+    showspaces=false,                
+    showstringspaces=false,
+    showtabs=false,                  
+    tabsize=2
+}
+
+\lstset{style=mystyle}
+
+\begin{document}
+
+\begin{aufgabe}[Mandelbrot-Menge]
+    (a) und (b) siehe \textit{mandelbrot.cc} und \textit{canvas.hh}.
+
+    (c) Je höher \lstinline{threshold}, desto heller wird das Bild, allerdings ist bereits zwischen 100 und 1000
+    kein großer Unterschied mehr zu erkennen. Bei sehr kleinen \lstinline{threshold}s werden die Randbereiche
+    wieder schwarz.
+
+    Bei geringen \lstinline{maxIt}s ist die Genauigkeit sehr gering, je höher desto feiner wird das Bild.
+    Allerdings ist auch hier zwischen 100 und 1000 bereits kein Unterschied mehr zu erkennen.
+\end{aufgabe}
+
+\end{document}
diff --git a/ws2019/ipi/uebungen/mandelbrot.cc b/ws2019/ipi/uebungen/mandelbrot.cc
new file mode 100644
index 0000000..f9f4b1e
--- /dev/null
+++ b/ws2019/ipi/uebungen/mandelbrot.cc
@@ -0,0 +1,61 @@
+#include <iostream>
+#include <cmath>
+#include <string>
+
+// Datentyp Complex in der Datei canvas.hh
+#include "canvas.hh"
+
+// Summiert zwei komplexe Zahlen z und c und schreibt das Ergebnis in z
+void add_complex(Complex& z, Complex& c) {
+    z.real += c.real;
+    z.imag += c.imag;
+}
+
+// Multipliziert zwei komplexe Zahlen z und c und schreibt das Ergebnis in z
+void multiply_complex(Complex& z, Complex& c) {
+    double re = z.real*c.real - z.imag*c.imag;
+    double im = z.real*c.imag + z.imag*c.real;
+    z.real = re;
+    z.imag = im;
+}
+
+// Betrag einer komplexen Zahl
+double betrag(Complex z)
+{
+    return std::sqrt(std::pow(z.real, 2) + std::pow(z.imag, 2));
+}
+
+// Generiert die Mandelbrot Menge und speichert sie in canvas mit threshold als Entfernung, ab dem
+// ein Punkt ,,entkommt'', mit maxIt als maximale Anzahl an Iterationen, die für
+// die Folge durchgeführt werden soll. Wird als PGM Bild unter filename gespeichert
+void mandelbrot(Canvas& canvas, double threshold, int maxIt, std::string filename) {
+    for (int i = 0; i < canvas.vertPixels(); i++) {
+        for (int j = 0; j < canvas.horPixels(); j++) {
+            Complex c = canvas.coord(i, j);
+            Complex z;
+            z.real = 0;
+            z.imag = 0;
+            int neededIterations = -1;
+            for (int k = 1; k <= maxIt; k++) {
+                multiply_complex(z, z);
+                add_complex(z, c);
+                if (betrag(z) > threshold) {
+                    neededIterations = k;
+                    break;
+                }
+            }
+            if (neededIterations == -1) {
+                canvas.writePixel(i, j, 0);
+            } else {
+                canvas.writePixel(i, j, std::log(neededIterations)*100);
+            }
+        }
+    }
+    canvas.write(filename);
+}
+
+int main()
+{
+    Canvas canvas = Canvas(-1, 0, 4, 3, 4000, 3000);
+    mandelbrot(canvas, 1000, 10000, "mandelbrot.pgm");
+}
diff --git a/ws2019/ipi/uebungen/pgm.hh b/ws2019/ipi/uebungen/pgm.hh
new file mode 100644
index 0000000..e9f50ff
--- /dev/null
+++ b/ws2019/ipi/uebungen/pgm.hh
@@ -0,0 +1,64 @@
+#include <string>
+#include <fstream>
+#include <cmath>
+
+void write_pgm(int* pixels, int horPixels, int vertPixels, std::string filename)
+{
+  if(horPixels == 0 || vertPixels == 0)
+  {
+    std::cerr << "Leeres Pixel Array" << std::endl;
+    return;
+  }
+
+  // write file
+  // unfortunately we cannot use C++-11 which would simplify our life in that case
+  std::ofstream outfile;
+  outfile.open(filename.c_str());
+
+  outfile << "P2" << std::endl
+          << horPixels << " " << vertPixels << std::endl;
+
+  // renormalize if necessary
+  int maxVal = 0;
+  for(int entry=0; entry<horPixels*vertPixels; entry++)
+    maxVal = std::max(pixels[entry],maxVal);
+
+  // renormalizing output
+  if(maxVal > 65535)
+  {
+    outfile << 65535 << std::endl;
+    for(int j=0, entry=0; j<vertPixels; j++)
+    {
+      for(int i=0; i<horPixels; i++, entry++)
+      {
+        if(pixels[entry] < 0)
+        {
+          std::cerr << "Negativer Eintrag bei (" << i << ", " << j << ")" << std::endl;
+          return;
+        }
+        outfile << std::floor(pixels[entry] * (65535./maxVal)) << " ";
+      }
+      outfile << std::endl;
+    }
+  }
+  // normal output
+  else
+  {
+    outfile << maxVal << std::endl;
+    for(int j=0; j<vertPixels; j++)
+    {
+      for(int i=0; i<horPixels; i++)
+      {
+        int entry = i + horPixels*(vertPixels-1-j);
+        if(pixels[entry] < 0)
+        {
+          std::cerr << "Negativer Eintrag bei (" << i << ", " << j << ")" << std::endl;
+          return;
+        }
+        outfile << pixels[entry] << " ";
+      }
+      outfile << std::endl;
+    }
+  }
+  outfile.close();
+}