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