kuhyx/WUT_Computer_Science
1
0
Fork 0
mirror of https://github.com/kuhyx/WUT_Computer_Science.git synced 2026-07-04 16:43:12 +02:00
Code Issues Actions Packages Projects Releases Wiki Activity

fix: remove unused thread functions

Browse Source
This commit is contained in:
Gromiusz 2025-01-13 15:44:36 +01:00
parent fcfd95a1af
commit 8b457a2f43
1 changed files with 0 additions and 75 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

75
code/linear_algebra_utils.py
View File

@ -118,7 +118,6 @@ class ThreadsLinearAlgebraUtils:
remainder = num_elements % num_threads remainder = num_elements % num_threads
return chunk_size, num_threads, remainder return chunk_size, num_threads, remainder
@staticmethod @staticmethod
def divide_vectors_to_chunks(v1, v2): def divide_vectors_to_chunks(v1, v2):
chunk_size, num_threads, remainder = ThreadsLinearAlgebraUtils.get_chunk_size(v1) chunk_size, num_threads, remainder = ThreadsLinearAlgebraUtils.get_chunk_size(v1)
@ -145,15 +144,6 @@ class ThreadsLinearAlgebraUtils:
return chunks 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 @staticmethod
@time_measurement(time_accumulator) @time_measurement(time_accumulator)
def matrix_vector_multiply(A, x): def matrix_vector_multiply(A, x):
@ -176,23 +166,6 @@ class ThreadsLinearAlgebraUtils:
total_sum = sum(results) total_sum = sum(results)
return total_sum**0.5 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 @staticmethod
@time_measurement(time_accumulator) @time_measurement(time_accumulator)
def vector_vector_subtraction(v1, v2): def vector_vector_subtraction(v1, v2):
@ -219,54 +192,6 @@ class ThreadsLinearAlgebraUtils:
return [item for sublist in results for item in sublist] 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) @time_measurement(time_accumulator)
def process_row(params): def process_row(params):