From 8b457a2f43045673242ecdfdfe355ccb258298af Mon Sep 17 00:00:00 2001
From: Gromiusz <kgorka22@gmail.com>
Date: Mon, 13 Jan 2025 15:44:36 +0100
Subject: [PATCH] fix: remove unused thread functions

---
 code/linear_algebra_utils.py | 75 ------------------------------------
 1 file changed, 75 deletions(-)

diff --git a/code/linear_algebra_utils.py b/code/linear_algebra_utils.py
index 1f56d806..5448545b 100644
--- a/code/linear_algebra_utils.py
+++ b/code/linear_algebra_utils.py
@@ -118,7 +118,6 @@ class ThreadsLinearAlgebraUtils:
         remainder = num_elements % num_threads
         return chunk_size, num_threads, remainder
 
-
     @staticmethod
     def divide_vectors_to_chunks(v1, v2):
         chunk_size, num_threads, remainder = ThreadsLinearAlgebraUtils.get_chunk_size(v1)
@@ -145,15 +144,6 @@ class ThreadsLinearAlgebraUtils:
 
         return chunks
 
-
-    @staticmethod
-    @time_measurement(time_accumulator)
-    def dot_product(v1, v2):
-        chunks = ThreadsLinearAlgebraUtils.divide_vectors_to_chunks(v1, v2)
-        with ThreadPoolExecutor(max_workers=ThreadsLinearAlgebraUtils.NUM_THREADS) as executor:
-            results = executor.map(lambda pair: SequentialLinearAlgebraUtils.dot_product(*pair), chunks)
-        return sum(results)
-
     @staticmethod
     @time_measurement(time_accumulator)
     def matrix_vector_multiply(A, x):
@@ -176,23 +166,6 @@ class ThreadsLinearAlgebraUtils:
         total_sum = sum(results)
         return total_sum**0.5
 
-    @staticmethod
-    @time_measurement(time_accumulator)
-    def vector_scalar_divide(x, scalar):
-        chunks = ThreadsLinearAlgebraUtils.divide_vector_or_matrix_to_chunks(x)
-
-        with ThreadPoolExecutor(max_workers=ThreadsLinearAlgebraUtils.NUM_THREADS) as executor:
-            results = executor.map(lambda chunk: SequentialLinearAlgebraUtils.vector_scalar_divide(chunk, scalar), chunks)
-        return [item for sublist in results for item in sublist]
-
-    @staticmethod
-    @time_measurement(time_accumulator)
-    def matrix_scalar_multiply(A, w):
-        chunks = ThreadsLinearAlgebraUtils.divide_vector_or_matrix_to_chunks(A)
-        with ThreadPoolExecutor(max_workers=ThreadsLinearAlgebraUtils.NUM_THREADS) as executor:
-            results = executor.map(lambda chunk: SequentialLinearAlgebraUtils.matrix_scalar_multiply(w, chunk), chunks)
-        return [item for sublist in results for item in sublist]
-
     @staticmethod
     @time_measurement(time_accumulator)
     def vector_vector_subtraction(v1, v2):
@@ -219,54 +192,6 @@ class ThreadsLinearAlgebraUtils:
         
         return [item for sublist in results for item in sublist]
 
-    @staticmethod
-    @time_measurement(time_accumulator)
-    def matrix_norm(A):
-        chunks = ThreadsLinearAlgebraUtils.divide_vector_or_matrix_to_chunks(A)
-
-        def partial_norm(chunk):
-            return sum(element ** 2 for row in chunk for element in row)
-
-        with ThreadPoolExecutor(max_workers=ThreadsLinearAlgebraUtils.NUM_THREADS) as executor:
-            results = executor.map(partial_norm, chunks)
-
-        total_sum = sum(results)
-        return math.sqrt(total_sum)
-    
-    @staticmethod
-    @time_measurement(time_accumulator)
-    def divide_matrixes_to_chunks(A, B):
-        num_rows = len(A)
-        num_threads = ThreadsLinearAlgebraUtils.NUM_THREADS
-        if num_threads > num_rows:
-            num_threads = num_rows
-        if num_rows == 0:
-            return []
-        chunk_size = num_rows // num_threads
-        remainder = num_rows % num_threads
-        chunks = []
-        start = 0
-        for _ in range(num_threads):
-            end = start + chunk_size + (1 if remainder > 0 else 0)
-            chunks.append((A[start:end], B[start:end]))
-            start = end
-            if remainder > 0:
-                remainder -= 1
-        return chunks
-
-    @staticmethod
-    @time_measurement(time_accumulator)
-    def matrix_matrix_subtraction(A, B):
-
-        def subtract_chunk(pair):
-            chunk_A, chunk_B = pair
-            return [[chunk_A[i][j] - chunk_B[i][j] for j in range(len(chunk_A[0]))] for i in range(len(chunk_A))]
-
-        chunks = ThreadsLinearAlgebraUtils.divide_matrixes_to_chunks(A, B)
-        with ThreadPoolExecutor(max_workers=ThreadsLinearAlgebraUtils.NUM_THREADS) as executor:
-            results = executor.map(subtract_chunk, chunks)
-        return [row for chunk in results for row in chunk]
-
 
 @time_measurement(time_accumulator)
 def process_row(params):