Prepare vector_mpi.py for proper implementation

src/vector_mpi.py

@@ -1,363 +1,365 @@
-import numpy as np
+from mpi4py import MPI
-from mpi4py import MPI
+
-
+
-
+class VectorMPI:
-class Vector:
+    ...
-    start_idx = 0  # Nullter Eintrag des Vektors auf dem aktuellen Rang
+
-    end_idx = 0  # Letzer Eintrag des Vektors auf dem aktuellen Rang
+# class Vector:
-    rank_size = 0  # Dimension des Vektors der auf dem aktuellen Rang gespeichert wird
+#     start_idx = 0  # Nullter Eintrag des Vektors auf dem aktuellen Rang
-    kind = ''  # Art des Vektors, Zeilen oder Spaltenvektor
+#     end_idx = 0  # Letzer Eintrag des Vektors auf dem aktuellen Rang
-    vec = np.arange(rank_size)
+#     rank_size = 0  # Dimension des Vektors der auf dem aktuellen Rang gespeichert wird
-    vshape = np.arange(2)  # Array mit Länge 2, um die Shape des Vektors zu speichern
+#     kind = ''  # Art des Vektors, Zeilen oder Spaltenvektor
-    dim = 0  # Gesamtdimension des Vektors, Länge des Vektors
+#     vec = np.arange(rank_size)
-
+#     vshape = np.arange(2)  # Array mit Länge 2, um die Shape des Vektors zu speichern
-    comm = MPI.COMM_WORLD
+#     dim = 0  # Gesamtdimension des Vektors, Länge des Vektors
-    size = comm.Get_size()
+#
-    rank = comm.Get_rank()
+#     comm = MPI.COMM_WORLD
-
+#     size = comm.Get_size()
-    # Konstruktor
+#     rank = comm.Get_rank()
-    def __init__(self, array):
+#
-
+#     # Konstruktor
-        if isinstance(array, np.ndarray):
+#     def __init__(self, array):
-            form = array.shape
+#
-            if len(array) < self.size:
+#         if isinstance(array, np.ndarray):
-                raise ValueError("ERROR_3: Die Dimension des Vektors ist kleiner als die Anzahl der benutzten Ränge.")
+#             form = array.shape
-
+#             if len(array) < self.size:
-            if len(form) > 2:
+#                 raise ValueError("ERROR_3: Die Dimension des Vektors ist kleiner als die Anzahl der benutzten Ränge.")
-                raise ValueError("ERROR_2: Falsche Dimension, kann kein 1 x n oder n x 1 Vektor sein.")
+#
-            # Array ist Zeilenvektor:
+#             if len(form) > 2:
-            if len(form) == 1 or (len(form) == 2 and form[0] == 1):
+#                 raise ValueError("ERROR_2: Falsche Dimension, kann kein 1 x n oder n x 1 Vektor sein.")
-                self.vshape[0] = 1
+#             # Array ist Zeilenvektor:
-                self.vshape[1] = len(array)  # Shape des Vectors
+#             if len(form) == 1 or (len(form) == 2 and form[0] == 1):
-                self.start_idx = int(self.rank * len(array) / self.size)
+#                 self.vshape[0] = 1
-                self.end_idx = int(len(array) / self.size + self.rank * len(array) / self.size) - 1
+#                 self.vshape[1] = len(array)  # Shape des Vectors
-                self.rank_size = (
+#                 self.start_idx = int(self.rank * len(array) / self.size)
-                                         self.end_idx - self.start_idx) + 1  # Größe des Teilvektors auf dem akt. Rang: Differenz zw. Start- und Endindex + 1
+#                 self.end_idx = int(len(array) / self.size + self.rank * len(array) / self.size) - 1
-                self.vec = array[
+#                 self.rank_size = (
-                           self.start_idx: self.end_idx + 1]  # Auf jedem Rang werden die Einträge vom Start bis zum Endindex gespeichert
+#                                          self.end_idx - self.start_idx) + 1  # Größe des Teilvektors auf dem akt. Rang: Differenz zw. Start- und Endindex + 1
-                self.kind = 'row'
+#                 self.vec = array[
-                self.dim = len(array)
+#                            self.start_idx: self.end_idx + 1]  # Auf jedem Rang werden die Einträge vom Start bis zum Endindex gespeichert
-
+#                 self.kind = 'row'
-            # Array ist Spaltenvektor
+#                 self.dim = len(array)
-            if len(form) == 2 and form[1] == 1:
+#
-                self.vshape[0] = len(array)
+#             # Array ist Spaltenvektor
-                self.vshape[1] = 1
+#             if len(form) == 2 and form[1] == 1:
-                self.start_idx = int(self.rank * len(array) / self.size)
+#                 self.vshape[0] = len(array)
-                self.end_idx = int(len(array) / self.size + self.rank * len(array) / self.size) - 1
+#                 self.vshape[1] = 1
-                self.rank_size = (
+#                 self.start_idx = int(self.rank * len(array) / self.size)
-                                         self.end_idx - self.start_idx) + 1  # Größe des Teilvektors auf dem akt. Rang: Differenz zw. Start- und Endindex + 1
+#                 self.end_idx = int(len(array) / self.size + self.rank * len(array) / self.size) - 1
-                self.vec = array[
+#                 self.rank_size = (
-                           self.start_idx: self.end_idx + 1]  # Auf jedem Rang werden die Einträge vom Start bis zum Endindex gespeichert
+#                                          self.end_idx - self.start_idx) + 1  # Größe des Teilvektors auf dem akt. Rang: Differenz zw. Start- und Endindex + 1
-                self.kind = 'column'
+#                 self.vec = array[
-                self.dim = len(array)
+#                            self.start_idx: self.end_idx + 1]  # Auf jedem Rang werden die Einträge vom Start bis zum Endindex gespeichert
-
+#                 self.kind = 'column'
-        elif isinstance(array, list):
+#                 self.dim = len(array)
-            self.vshape[0] = 1
+#
-            self.vshape[1] = len(array)
+#         elif isinstance(array, list):
-            self.start_idx = int(self.rank * len(array) / self.size)
+#             self.vshape[0] = 1
-            self.end_idx = int(len(array) / self.size + self.rank * len(array) / self.size) - 1
+#             self.vshape[1] = len(array)
-            self.rank_size = (self.end_idx - self.start_idx) + 1
+#             self.start_idx = int(self.rank * len(array) / self.size)
-            self.vec = np.array(array[self.start_idx:self.end_idx + 1])
+#             self.end_idx = int(len(array) / self.size + self.rank * len(array) / self.size) - 1
-            self.kind = 'row'
+#             self.rank_size = (self.end_idx - self.start_idx) + 1
-            self.dim = len(array)
+#             self.vec = np.array(array[self.start_idx:self.end_idx + 1])
-        else:
+#             self.kind = 'row'
-            raise ValueError(
+#             self.dim = len(array)
-                "ERROR_1: Die übergebene Variable ist kein Numpy-Array, Keine Initialisierung der Vector-Klasse möglich.")
+#         else:
-
+#             raise ValueError(
-    def __add__(self, other):  # Überschreibung der Addition
+#                 "ERROR_1: Die übergebene Variable ist kein Numpy-Array, Keine Initialisierung der Vector-Klasse möglich.")
-        if isinstance(self, Vector) and isinstance(other, Vector):
+#
-            Add_Vec = Vector(np.arange(self.dim))
+#     def __add__(self, other):  # Überschreibung der Addition
-            if self.vshape[0] == other.vshape[0] and self.vshape[1] == other.vshape[1]:
+#         if isinstance(self, Vector) and isinstance(other, Vector):
-                for i in range(0, self.rank_size):
+#             Add_Vec = Vector(np.arange(self.dim))
-                    Add_Vec.vec[i] = self.vec[i] + other.vec[i]
+#             if self.vshape[0] == other.vshape[0] and self.vshape[1] == other.vshape[1]:
-            else:
+#                 for i in range(0, self.rank_size):
-                raise ValueError("Die Dimensionen der Vektoren stimmen nicht überein, Addition nicht möglich.")
+#                     Add_Vec.vec[i] = self.vec[i] + other.vec[i]
-        elif isinstance(self, Vector) and isinstance(other, (int, float, complex)):
+#             else:
-            Add_Vec = Vector(np.arange(self.dim))
+#                 raise ValueError("Die Dimensionen der Vektoren stimmen nicht überein, Addition nicht möglich.")
-            for i in range(0, self.rank_size):
+#         elif isinstance(self, Vector) and isinstance(other, (int, float, complex)):
-                Add_Vec.vec[i] = self.vec[i] + other
+#             Add_Vec = Vector(np.arange(self.dim))
-        elif isinstance(self, (int, float, complex)) and isinstance(other, Vector):
+#             for i in range(0, self.rank_size):
-            Add_Vec = Vector(np.arange(other.dim))
+#                 Add_Vec.vec[i] = self.vec[i] + other
-            for i in range(0, other.rank_size):
+#         elif isinstance(self, (int, float, complex)) and isinstance(other, Vector):
-                Add_Vec.vec[i] = other.vec[i] + self
+#             Add_Vec = Vector(np.arange(other.dim))
-        else:
+#             for i in range(0, other.rank_size):
-            raise ValueError("Ungeeigneter Datentyp für die Addition mit einem Vektor.")
+#                 Add_Vec.vec[i] = other.vec[i] + self
-        return Add_Vec
+#         else:
-
+#             raise ValueError("Ungeeigneter Datentyp für die Addition mit einem Vektor.")
-    def __radd__(self, other):  # Überschreibung der Addition eines Vektors von rechts
+#         return Add_Vec
-        Vector(np.arange(self.dim))
+#
-        if isinstance(self, Vector) and isinstance(other, (int, float, complex)):
+#     def __radd__(self, other):  # Überschreibung der Addition eines Vektors von rechts
-            Add_Vec = Vector(np.arange(self.dim))
+#         Vector(np.arange(self.dim))
-            for i in range(0, self.rank_size):
+#         if isinstance(self, Vector) and isinstance(other, (int, float, complex)):
-                Add_Vec.vec[i] = self.vec[i] + other
+#             Add_Vec = Vector(np.arange(self.dim))
-        else:
+#             for i in range(0, self.rank_size):
-            raise ValueError("Ungeeigneter Datentyp für die Addition mit einem Vektor.")
+#                 Add_Vec.vec[i] = self.vec[i] + other
-        return Add_Vec
+#         else:
-
+#             raise ValueError("Ungeeigneter Datentyp für die Addition mit einem Vektor.")
-    def __sub__(self, other):  # Überschreibung der Subtraktion
+#         return Add_Vec
-        if isinstance(self, Vector) and isinstance(other, Vector):
+#
-            Sub_Vec = Vector(np.arange(self.dim))
+#     def __sub__(self, other):  # Überschreibung der Subtraktion
-            if self.vshape[0] == other.vshape[0] and self.vshape[1] == other.vshape[1]:
+#         if isinstance(self, Vector) and isinstance(other, Vector):
-                for i in range(0, self.rank_size):
+#             Sub_Vec = Vector(np.arange(self.dim))
-                    Sub_Vec.vec[i] = self.vec[i] - other.vec[i]
+#             if self.vshape[0] == other.vshape[0] and self.vshape[1] == other.vshape[1]:
-            else:
+#                 for i in range(0, self.rank_size):
-                raise ValueError("Die Dimension der Vektoren stimmen nicht überein, Subtraktion nicht möglich.")
+#                     Sub_Vec.vec[i] = self.vec[i] - other.vec[i]
-        elif isinstance(self, Vector) and isinstance(other, (int, float, complex)):
+#             else:
-            Sub_Vec = Vector(np.arange(self.dim))
+#                 raise ValueError("Die Dimension der Vektoren stimmen nicht überein, Subtraktion nicht möglich.")
-            for i in range(0, self.rank_size):
+#         elif isinstance(self, Vector) and isinstance(other, (int, float, complex)):
-                Sub_Vec.vec[i] = self.vec[i] - other
+#             Sub_Vec = Vector(np.arange(self.dim))
-        elif isinstance(self, (int, float, complex)) and isinstance(other, Vector):
+#             for i in range(0, self.rank_size):
-            Sub_Vec = Vector(np.arange(self.dim))
+#                 Sub_Vec.vec[i] = self.vec[i] - other
-            for i in range(0, other.rank_size):
+#         elif isinstance(self, (int, float, complex)) and isinstance(other, Vector):
-                Sub_Vec.vec[i] = other.vec[i] - self
+#             Sub_Vec = Vector(np.arange(self.dim))
-        else:
+#             for i in range(0, other.rank_size):
-            raise ValueError("Ungeeigneter Datentyp für die Subtraktion mit einem Vektor.")
+#                 Sub_Vec.vec[i] = other.vec[i] - self
-        return Sub_Vec
+#         else:
-
+#             raise ValueError("Ungeeigneter Datentyp für die Subtraktion mit einem Vektor.")
-    def __rsub__(self, other):  # Subtraktion einer Zahl von einem Vektor
+#         return Sub_Vec
-        Sub_Vec = Vector(np.arange(self.dim))
+#
-        if isinstance(self, Vector) and isinstance(other, (float, int, complex)):
+#     def __rsub__(self, other):  # Subtraktion einer Zahl von einem Vektor
-            for i in range(0, self.rank_size):
+#         Sub_Vec = Vector(np.arange(self.dim))
-                Sub_Vec.vec[i] = self.vec[i] - other
+#         if isinstance(self, Vector) and isinstance(other, (float, int, complex)):
-        else:
+#             for i in range(0, self.rank_size):
-            raise ValueError("Ungeeigneter Datentyp für die Subtraktion von einem Vektor.")
+#                 Sub_Vec.vec[i] = self.vec[i] - other
-        return Sub_Vec
+#         else:
-
+#             raise ValueError("Ungeeigneter Datentyp für die Subtraktion von einem Vektor.")
-    def __mul__(self, other):  # Überschreibung der Multiplikation
+#         return Sub_Vec
-        if isinstance(self, Vector) and isinstance(other, Vector):
+#
-            Mult_Vec = Vector(np.arange(self.dim))
+#     def __mul__(self, other):  # Überschreibung der Multiplikation
-            if (self.vshape[0] == other.vshape[0] and self.vshape[1] == other.vshape[
+#         if isinstance(self, Vector) and isinstance(other, Vector):
-                1]):  # Elementweise Multiplikation
+#             Mult_Vec = Vector(np.arange(self.dim))
-                for i in range(0, self.rank_size):
+#             if (self.vshape[0] == other.vshape[0] and self.vshape[1] == other.vshape[
-                    Mult_Vec.vec[i] = self.vec[i] * other.vec[i]
+#                 1]):  # Elementweise Multiplikation
-            elif self.vshape[1] == other.vshape[0] and self.vshape[0] == 1:  # Inneres Produkt (Skalarprodukt)
+#                 for i in range(0, self.rank_size):
-                skal_prod = 0
+#                     Mult_Vec.vec[i] = self.vec[i] * other.vec[i]
-                for i in range(0, self.rank_size):
+#             elif self.vshape[1] == other.vshape[0] and self.vshape[0] == 1:  # Inneres Produkt (Skalarprodukt)
-                    skal_prod = skal_prod + self.vec[i] * other.vec[i]
+#                 skal_prod = 0
-                return skal_prod
+#                 for i in range(0, self.rank_size):
-            elif self.vshape[0] == other.vshape[1] and self.vshape[1] == 1:
+#                     skal_prod = skal_prod + self.vec[i] * other.vec[i]
-                raise ValueError("Kann erst implementiert werden, wenn Matrix-Klasse existiert.")
+#                 return skal_prod
-            else:
+#             elif self.vshape[0] == other.vshape[1] and self.vshape[1] == 1:
-                raise ValueError("Die Dimensionen der Vektoren stimmen nicht überein, Multiplikation nicht möglich.")
+#                 raise ValueError("Kann erst implementiert werden, wenn Matrix-Klasse existiert.")
-        elif isinstance(self, Vector) and isinstance(other, (int, float, complex)):
+#             else:
-            Mult_Vec = Vector(np.arange(self.dim))
+#                 raise ValueError("Die Dimensionen der Vektoren stimmen nicht überein, Multiplikation nicht möglich.")
-            for i in range(0, self.rank_size):
+#         elif isinstance(self, Vector) and isinstance(other, (int, float, complex)):
-                Mult_Vec.vec[i] = self.vec[i] * other
+#             Mult_Vec = Vector(np.arange(self.dim))
-        elif isinstance(self, (int, float, complex)) and isinstance(other, Vector):
+#             for i in range(0, self.rank_size):
-            Mult_Vec = Vector(np.arange(self.dim))
+#                 Mult_Vec.vec[i] = self.vec[i] * other
-            for i in range(0, other.rank_size):
+#         elif isinstance(self, (int, float, complex)) and isinstance(other, Vector):
-                Mult_Vec.vec[i] = other.vec[i] * self
+#             Mult_Vec = Vector(np.arange(self.dim))
-        else:
+#             for i in range(0, other.rank_size):
-            raise ValueError("Ungeeigneter Datentyp für die Multiplikation mit einem Vektor.")
+#                 Mult_Vec.vec[i] = other.vec[i] * self
-        return Mult_Vec
+#         else:
-
+#             raise ValueError("Ungeeigneter Datentyp für die Multiplikation mit einem Vektor.")
-    def __rmul__(self, other):  # Rechtsseitige Multiplikation von einer Zahl an einen Vektor
+#         return Mult_Vec
-        Mult_Vec = Vector(np.arange(self.dim))
+#
-        if isinstance(self, Vector) and isinstance(other, (int, float, complex)):
+#     def __rmul__(self, other):  # Rechtsseitige Multiplikation von einer Zahl an einen Vektor
-            for i in range(0, self.rank_size):
+#         Mult_Vec = Vector(np.arange(self.dim))
-                Mult_Vec.vec[i] = self.vec[i] * other
+#         if isinstance(self, Vector) and isinstance(other, (int, float, complex)):
-        else:
+#             for i in range(0, self.rank_size):
-            raise ValueError("Ungeeigneter Datentyp für die Multiplikation mit einem Vektor.")
+#                 Mult_Vec.vec[i] = self.vec[i] * other
-        return Mult_Vec
+#         else:
-
+#             raise ValueError("Ungeeigneter Datentyp für die Multiplikation mit einem Vektor.")
-    def __truediv__(self, other):
+#         return Mult_Vec
-        Div_Vec = Vector(np.arange(self.dim, dtype=np.double))
+#
-        if isinstance(self, Vector) and isinstance(other, Vector):
+#     def __truediv__(self, other):
-            if self.vshape[0] == other.vshape[0] and self.vshape[1] == other.vshape[1]:
+#         Div_Vec = Vector(np.arange(self.dim, dtype=np.double))
-                for i in range(0, self.rank_size):
+#         if isinstance(self, Vector) and isinstance(other, Vector):
-                    if other.vec[i] == 0:
+#             if self.vshape[0] == other.vshape[0] and self.vshape[1] == other.vshape[1]:
-                        raise ValueError("Ein Eintrag des Divisor-Vektors ist 0, Divion nicht möglich.")
+#                 for i in range(0, self.rank_size):
-                    Div_Vec.vec[i] = self.vec[i] / other.vec[i]
+#                     if other.vec[i] == 0:
-            else:
+#                         raise ValueError("Ein Eintrag des Divisor-Vektors ist 0, Divion nicht möglich.")
-                raise ValueError("Die Dimensionen der Vektoren stimmen nicht überein, Division nicht möglich.")
+#                     Div_Vec.vec[i] = self.vec[i] / other.vec[i]
-        elif isinstance(self, (int, float, complex)) and isinstance(other, Vector):
+#             else:
-            for i in range(0, other.rank_size):
+#                 raise ValueError("Die Dimensionen der Vektoren stimmen nicht überein, Division nicht möglich.")
-                if other.vec[i] == 0:
+#         elif isinstance(self, (int, float, complex)) and isinstance(other, Vector):
-                    raise ValueError("Ein Eintrag des Divisor-Vektors ist 0, Divion nicht möglich.")
+#             for i in range(0, other.rank_size):
-                Div_Vec.vec[i] = self / other.vec[i]
+#                 if other.vec[i] == 0:
-        elif isinstance(self, Vector) and isinstance(other, (float, int, complex)):
+#                     raise ValueError("Ein Eintrag des Divisor-Vektors ist 0, Divion nicht möglich.")
-            if other == 0:
+#                 Div_Vec.vec[i] = self / other.vec[i]
-                raise ValueError("Division durch Null ist nicht möglich.")
+#         elif isinstance(self, Vector) and isinstance(other, (float, int, complex)):
-            else:
+#             if other == 0:
-                for i in range(0, self.rank_size):
+#                 raise ValueError("Division durch Null ist nicht möglich.")
-                    Div_Vec.vec[i] = self.vec[i] / other
+#             else:
-        else:
+#                 for i in range(0, self.rank_size):
-            raise ValueError("ERROR 11: Ungeeigneter Datentyp für die Division mit einem Vektor.")
+#                     Div_Vec.vec[i] = self.vec[i] / other
-        return Div_Vec
+#         else:
-
+#             raise ValueError("ERROR 11: Ungeeigneter Datentyp für die Division mit einem Vektor.")
-    def __rtruediv__(self, other):
+#         return Div_Vec
-        Div_Vec = Vector(np.arange(self.dim, dtype=np.double))
+#
-        if isinstance(self, Vector) and isinstance(other, (float, int, complex)):
+#     def __rtruediv__(self, other):
-            if other == 0:
+#         Div_Vec = Vector(np.arange(self.dim, dtype=np.double))
-                raise ValueError("Division durch Null ist nicht möglich.")
+#         if isinstance(self, Vector) and isinstance(other, (float, int, complex)):
-            else:
+#             if other == 0:
-                for i in range(0, self.rank_size):
+#                 raise ValueError("Division durch Null ist nicht möglich.")
-                    Div_Vec.vec[i] = self.vec[i] / other
+#             else:
-        else:
+#                 for i in range(0, self.rank_size):
-            raise ValueError("ERROR 10: Uneignete Datentyp, um einen Vektor durch diesen zu dividieren")
+#                     Div_Vec.vec[i] = self.vec[i] / other
-        return Div_Vec
+#         else:
-
+#             raise ValueError("ERROR 10: Uneignete Datentyp, um einen Vektor durch diesen zu dividieren")
-    def __neg__(self):
+#         return Div_Vec
-        Neg_Vec = -1 * self
+#
-        return Neg_Vec
+#     def __neg__(self):
-
+#         Neg_Vec = -1 * self
-    def shape(self):
+#         return Neg_Vec
-        if self.rank == 0:
+#
-            return self.vshape
+#     def shape(self):
-
+#         if self.rank == 0:
-    def T(self):
+#             return self.vshape
-        Transpose = self
+#
-        if self.kind == 'row':
+#     def T(self):
-            Transpose.kind = 'column'
+#         Transpose = self
-        else:
+#         if self.kind == 'row':
-            Transpose.kind = 'row'
+#             Transpose.kind = 'column'
-
+#         else:
-        # Tauschen der Dimensionen
+#             Transpose.kind = 'row'
-        var_shift = self.vshape[0]
+#
-        Transpose.vshape[0] = self.vshape[1]
+#         # Tauschen der Dimensionen
-        Transpose.vshape[1] = var_shift
+#         var_shift = self.vshape[0]
-        return Transpose
+#         Transpose.vshape[0] = self.vshape[1]
-
+#         Transpose.vshape[1] = var_shift
-    def str(self):  # Rückgabe des gesamten Vektors als string
+#         return Transpose
-        str_rep = ''
+#
-
+#     def str(self):  # Rückgabe des gesamten Vektors als string
-        if self.rank == 0:
+#         str_rep = ''
-            if self.kind == 'row':
+#
-                str_rep = '[' + ','.join(map(str, self.vec))
+#         if self.rank == 0:
-            if self.kind == 'column':
+#             if self.kind == 'row':
-                str_rep = '[' + '\n'.join(map(str, self.vec))
+#                 str_rep = '[' + ','.join(map(str, self.vec))
-            if self.size > 1:
+#             if self.kind == 'column':
-                self.comm.send(str_rep, dest=self.rank + 1)
+#                 str_rep = '[' + '\n'.join(map(str, self.vec))
-
+#             if self.size > 1:
-        elif self.rank == self.size - 1:
+#                 self.comm.send(str_rep, dest=self.rank + 1)
-            if self.kind == 'row':
+#
-                str_rep = self.comm.recv(source=self.rank - 1) + ',' + ','.join(map(str, self.vec))
+#         elif self.rank == self.size - 1:
-            if self.kind == 'column':
+#             if self.kind == 'row':
-                str_rep = self.comm.recv(source=self.rank - 1) + '\n' + '\n'.join(map(str, self.vec))
+#                 str_rep = self.comm.recv(source=self.rank - 1) + ',' + ','.join(map(str, self.vec))
-
+#             if self.kind == 'column':
-        else:
+#                 str_rep = self.comm.recv(source=self.rank - 1) + '\n' + '\n'.join(map(str, self.vec))
-            if self.kind == 'row':
+#
-                str_rep = self.comm.recv(source=self.rank - 1) + ',' + ','.join(map(str, self.vec))
+#         else:
-            if self.kind == 'column':
+#             if self.kind == 'row':
-                str_rep = self.comm.recv(source=self.rank - 1) + '\n' + '\n'.join(map(str, self.vec))
+#                 str_rep = self.comm.recv(source=self.rank - 1) + ',' + ','.join(map(str, self.vec))
-            self.comm.send(str_rep, dest=self.rank + 1)
+#             if self.kind == 'column':
-
+#                 str_rep = self.comm.recv(source=self.rank - 1) + '\n' + '\n'.join(map(str, self.vec))
-        str_rep = self.comm.bcast(str_rep, root=self.size - 1)
+#             self.comm.send(str_rep, dest=self.rank + 1)
-        if self.rank == 0:
+#
-            return str_rep + ']'
+#         str_rep = self.comm.bcast(str_rep, root=self.size - 1)
-
+#         if self.rank == 0:
-    def string(self, limit_entry):  # Gibt den Vektor als String zurück bis zum Eintrag limit_entry
+#             return str_rep + ']'
-        str_rep = ''
+#
-
+#     def string(self, limit_entry):  # Gibt den Vektor als String zurück bis zum Eintrag limit_entry
-        if limit_entry > self.vec_size:
+#         str_rep = ''
-            raise ValueError("ERROR_4: Die eingegebene Zahl ist größer, als der größte Index des Vectors.")
+#
-
+#         if limit_entry > self.vec_size:
-        # Rank 0
+#             raise ValueError("ERROR_4: Die eingegebene Zahl ist größer, als der größte Index des Vectors.")
-        if self.rank == 0 and limit_entry <= self.end_idx:  # Limit_entry befindet sich im Rang 0
+#
-            if self.kind == 'row':
+#         # Rank 0
-                str_rep = '[' + ','.join(map(str, self.vec[:limit_entry]))
+#         if self.rank == 0 and limit_entry <= self.end_idx:  # Limit_entry befindet sich im Rang 0
-            if self.kind == 'column':
+#             if self.kind == 'row':
-                str_rep = '[' + '\n'.join(map(str, self.vec[:limit_entry]))
+#                 str_rep = '[' + ','.join(map(str, self.vec[:limit_entry]))
-            if self.size > 1:
+#             if self.kind == 'column':
-                self.comm.send(str_rep, dest=self.rank + 1)
+#                 str_rep = '[' + '\n'.join(map(str, self.vec[:limit_entry]))
-        if self.rank == 0 and limit_entry > self.end_idx:  # Limit_entry befindet sich nicht im Rang 0
+#             if self.size > 1:
-            if self.kind == 'row':
+#                 self.comm.send(str_rep, dest=self.rank + 1)
-                str_rep = '[' + ','.join(map(str, self.vec))
+#         if self.rank == 0 and limit_entry > self.end_idx:  # Limit_entry befindet sich nicht im Rang 0
-            if self.kind == 'column':
+#             if self.kind == 'row':
-                str_rep = '[' + '\n'.join(map(str, self.vec))
+#                 str_rep = '[' + ','.join(map(str, self.vec))
-            if self.size > 1:
+#             if self.kind == 'column':
-                self.comm.send(str_rep, dest=self.rank + 1)
+#                 str_rep = '[' + '\n'.join(map(str, self.vec))
-
+#             if self.size > 1:
-        # Rank im Intervall [1,size-1]
+#                 self.comm.send(str_rep, dest=self.rank + 1)
-        if (
+#
-                0 < self.rank < self.size - 1 and limit_entry <= self.start_idx):  # wenn lim_ent == start_idx, dann wurden bereits alle relevanten Indizes im String gespeichert, da Vector nullinitialisiert ist
+#         # Rank im Intervall [1,size-1]
-            str_rep = self.comm.recv(source=self.rank - 1)
+#         if (
-            self.comm.send(str_rep, dest=self.rank + 1)
+#                 0 < self.rank < self.size - 1 and limit_entry <= self.start_idx):  # wenn lim_ent == start_idx, dann wurden bereits alle relevanten Indizes im String gespeichert, da Vector nullinitialisiert ist
-        if (
+#             str_rep = self.comm.recv(source=self.rank - 1)
-                0 < self.rank < self.size - 1 and self.start_idx < limit_entry <= self.end_idx):
+#             self.comm.send(str_rep, dest=self.rank + 1)
-            if self.kind == 'row':
+#         if (
-                str_rep = self.comm.recv(source=self.rank - 1) + ',' + ','.join(
+#                 0 < self.rank < self.size - 1 and self.start_idx < limit_entry <= self.end_idx):
-                    map(str, self.vec[:(limit_entry - self.start_idx)]))
+#             if self.kind == 'row':
-            if self.kind == 'column':
+#                 str_rep = self.comm.recv(source=self.rank - 1) + ',' + ','.join(
-                str_rep = self.comm.recv(source=self.rank - 1) + '\n' + '\n'.join(
+#                     map(str, self.vec[:(limit_entry - self.start_idx)]))
-                    map(str, self.vec[:(limit_entry - self.start_idx)])) + ']'
+#             if self.kind == 'column':
-            self.comm.send(str_rep, dest=self.rank + 1)
+#                 str_rep = self.comm.recv(source=self.rank - 1) + '\n' + '\n'.join(
-        if 0 < self.rank < self.size - 1 and limit_entry > self.end_idx:
+#                     map(str, self.vec[:(limit_entry - self.start_idx)])) + ']'
-            if self.kind == 'row':
+#             self.comm.send(str_rep, dest=self.rank + 1)
-                str_rep = self.comm.recv(source=self.rank - 1) + ',' + ','.join(map(str, self.vec))
+#         if 0 < self.rank < self.size - 1 and limit_entry > self.end_idx:
-            if self.kind == 'column':
+#             if self.kind == 'row':
-                str_rep = self.comm.recv(source=self.rank - 1) + '\n' + '\n'.join(map(str, self.vec))
+#                 str_rep = self.comm.recv(source=self.rank - 1) + ',' + ','.join(map(str, self.vec))
-            self.comm.send(str_rep, dest=self.rank + 1)
+#             if self.kind == 'column':
-
+#                 str_rep = self.comm.recv(source=self.rank - 1) + '\n' + '\n'.join(map(str, self.vec))
-        # Rank size-1
+#             self.comm.send(str_rep, dest=self.rank + 1)
-        if self.rank == self.size - 1 and limit_entry <= self.start_idx and self.rank > 1:
+#
-            str_rep = self.comm.recv(source=self.rank - 1)
+#         # Rank size-1
-
+#         if self.rank == self.size - 1 and limit_entry <= self.start_idx and self.rank > 1:
-        if self.rank == self.size - 1 and limit_entry >= self.start_idx and self.rank > 1:
+#             str_rep = self.comm.recv(source=self.rank - 1)
-            if self.kind == 'row':
+#
-                str_rep = self.comm.recv(source=self.rank - 1) + ',' + ','.join(
+#         if self.rank == self.size - 1 and limit_entry >= self.start_idx and self.rank > 1:
-                    map(str, self.vec[:(limit_entry - self.start_idx)]))
+#             if self.kind == 'row':
-            if self.kind == 'column':
+#                 str_rep = self.comm.recv(source=self.rank - 1) + ',' + ','.join(
-                str_rep = self.comm.recv(source=self.rank - 1) + '\n' + '\n'.join(
+#                     map(str, self.vec[:(limit_entry - self.start_idx)]))
-                    map(str, self.vec[:(limit_entry - self.start_idx)]))
+#             if self.kind == 'column':
-
+#                 str_rep = self.comm.recv(source=self.rank - 1) + '\n' + '\n'.join(
-        str_rep = self.comm.bcast(str_rep, root=self.size - 1)
+#                     map(str, self.vec[:(limit_entry - self.start_idx)]))
-        if self.rank == 0:
+#
-            return str_rep + ']'
+#         str_rep = self.comm.bcast(str_rep, root=self.size - 1)
-
+#         if self.rank == 0:
-    def norm(self):  # Berechnung der 2-Norm / euklidischen Norm
+#             return str_rep + ']'
-        0
+#
-        sum_of_squares = 0
+#     def norm(self):  # Berechnung der 2-Norm / euklidischen Norm
-        if self.rank == 0:
+#         0
-            for i in range(0, self.rank_size):
+#         sum_of_squares = 0
-                sum_of_squares = sum_of_squares + self.vec[i] ** 2
+#         if self.rank == 0:
-
+#             for i in range(0, self.rank_size):
-            if self.size > 1:
+#                 sum_of_squares = sum_of_squares + self.vec[i] ** 2
-                self.comm.send(sum_of_squares, dest=self.rank + 1)
+#
-
+#             if self.size > 1:
-        elif self.rank == self.size - 1:
+#                 self.comm.send(sum_of_squares, dest=self.rank + 1)
-            sum_of_squares = self.comm.recv(source=self.rank - 1)
+#
-            for i in range(0, self.rank_size):
+#         elif self.rank == self.size - 1:
-                sum_of_squares = sum_of_squares + self.vec[i] ** 2
+#             sum_of_squares = self.comm.recv(source=self.rank - 1)
-
+#             for i in range(0, self.rank_size):
-        else:
+#                 sum_of_squares = sum_of_squares + self.vec[i] ** 2
-            sum_of_squares = self.comm.recv(source=self.rank - 1)
+#
-            for i in range(0, self.rank_size):
+#         else:
-                sum_of_squares = sum_of_squares + self.vec[i] ** 2
+#             sum_of_squares = self.comm.recv(source=self.rank - 1)
-            self.comm.send(sum_of_squares, dest=self.rank + 1)
+#             for i in range(0, self.rank_size):
-
+#                 sum_of_squares = sum_of_squares + self.vec[i] ** 2
-        sum_of_squares = self.comm.bcast(sum_of_squares, root=self.size - 1)
+#             self.comm.send(sum_of_squares, dest=self.rank + 1)
-        norm = np.sqrt(sum_of_squares)
+#
-
+#         sum_of_squares = self.comm.bcast(sum_of_squares, root=self.size - 1)
-        return norm
+#         norm = np.sqrt(sum_of_squares)
-
+#
-    def normalize(self):  # Normalisierung eines Vectors
+#         return norm
-        norm = self.norm()
+#
-        if norm == 0:
+#     def normalize(self):  # Normalisierung eines Vectors
-            return self
+#         norm = self.norm()
-        normalized_vec = self / norm
+#         if norm == 0:
-        return normalized_vec
+#             return self
-
+#         normalized_vec = self / norm
-
+#         return normalized_vec
-# Main-Funktion
+#
-x = Vector(np.arange(10))
+#
-print(x.str(), x.shape())
+# # Main-Funktion
-print(x.vshape[0], x.vshape[1])
+# x = Vector(np.arange(10))
-minus = -1 * x
+# print(x.str(), x.shape())
-_x = -x
+# print(x.vshape[0], x.vshape[1])
-print(_x.str())
+# minus = -1 * x
-print(minus.str())
+# _x = -x
-y = Vector(2 * np.arange(10))
+# print(_x.str())
-print(y.str())
+# print(minus.str())
-z = x - y
+# y = Vector(2 * np.arange(10))
-print(z.str())
+# print(y.str())
-ae = x + 5
+# z = x - y
-print(ae.str())
+# print(z.str())
-o = x * y
+# ae = x + 5
-print(o.str())
+# print(ae.str())
-
+# o = x * y
-a = Vector(np.array([[1], [2]]))
+# print(o.str())
-b = Vector(np.array([1, 2]))
+#
-print(a.shape())
+# a = Vector(np.array([[1], [2]]))
-# c = a * b
+# b = Vector(np.array([1, 2]))
-# print(c.vec)
+# print(a.shape())
+# # c = a * b
+# # print(c.vec)