Refactor calculate_weighted_ownership function to operate on a single row of ownership values, improving clarity and performance in the reassess_edge function.

global_func/reassess_edge.py

@@ -9,53 +9,39 @@ import pandas as pd
 import numpy as np
 import math
 
-def calculate_weighted_ownership_vectorized(ownership_array):
+def calculate_weighted_ownership_single_row(row_ownerships):
     """
-    Vectorized version of calculate_weighted_ownership using NumPy operations.
+    Calculate weighted ownership for a single row of ownership values.
     
     Args:
-        ownership_array: 2D array of ownership values (rows x players)
+        row_ownerships: Series containing ownership values in percentage form
         
     Returns:
-        array: Calculated weighted ownership values for each row
+        float: Calculated weighted ownership value
     """
-    # Convert percentages to decimals and handle NaN values
-    ownership_array = np.where(np.isnan(ownership_array), 0, ownership_array) / 100
+    # Convert to numpy array and handle NaN values
+    ownership_values = np.where(np.isnan(row_ownerships.values), 0, row_ownerships.values) / 100
     
-    # Calculate row means
-    row_means = np.mean(ownership_array, axis=1, keepdims=True)
+    # Calculate mean
+    row_mean = np.mean(ownership_values)
     
     # Calculate average of each value with the overall mean
-    value_means = (ownership_array + row_means) / 2
+    value_means = (ownership_values + row_mean) / 2
     
     # Take average of all those means
-    avg_of_means = np.mean(value_means, axis=1)
+    avg_of_means = np.mean(value_means)
     
     # Multiply by count of values
-    weighted = avg_of_means * ownership_array.shape[1]
+    weighted = avg_of_means * len(ownership_values)
     
-    # Subtract (max - min) for each row
-    row_max = np.max(ownership_array, axis=1)
-    row_min = np.min(ownership_array, axis=1)
+    # Subtract (max - min)
+    row_max = np.max(ownership_values)
+    row_min = np.min(ownership_values)
     weighted = weighted - (row_max - row_min)
     
     # Convert back to percentage form
     return weighted * 10000
 
-def calculate_weighted_ownership_wrapper(row_ownerships):
-    """
-    Wrapper function for the original calculate_weighted_ownership to work with Pandas .apply()
-    
-    Args:
-        row_ownerships: Series containing ownership values in percentage form
-        
-    Returns:
-        float: Calculated weighted ownership value
-    """
-    # Convert Series to 2D array for vectorized function
-    ownership_array = row_ownerships.values.reshape(1, -1)
-    return calculate_weighted_ownership_vectorized(ownership_array)[0]
-
 def reassess_dupes(row: pd.Series, salary_max: int) -> float:
     return math.ceil(row['Dupes'] + ((row['salary_diff'] / 100) + ((salary_max + (salary_max - row['salary'])) / 100)) * (1 - (row['own_diff'] / 100)))
 
@@ -89,7 +75,7 @@ def reassess_edge(refactored_frame: pd.DataFrame, original_frame: pd.DataFrame,
         refactored_df.loc[lineups, 'Finish_percentile'] = refactored_df.loc[lineups, 'Finish_percentile']
         refactored_df.loc[lineups, 'Win%'] = refactored_df.loc[lineups, 'Win%']
         refactored_df.loc[lineups, 'Edge'] = reassess_lineup_edge(refactored_df.loc[lineups, :], Contest_Size)
-        refactored_df.loc[lineups, 'Weighted Own'] = calculate_weighted_ownership_wrapper(refactored_df.loc[lineups, own_columns])
+        refactored_df.loc[lineups, 'Weighted Own'] = calculate_weighted_ownership_single_row(refactored_df.loc[lineups, own_columns])
         refactored_df.loc[lineups, 'Geomean'] = np.power((refactored_df.loc[lineups, own_columns] * 100).product(axis=1), 1 / len(own_columns))
 
     return refactored_df