Sensor Framework Documentation

FUNCTION GET_TOTAL_ROW_COUNT(data):
  RETURN data.shape[0]
ENDFUNCTION

FUNCTION GET_TOTAL_COLUMN_COUNT(data):
  RETURN data.shape[1]
ENDFUNCTION

FUNCTION ESTIMATE_FILESIZE(data):
  RETURN data.memory_usage().sum()
ENDFUNCTION

FUNCTION COUNT_NUMERIC_SUFFIX_COLS(column_names):
  count = 0
  FOR name in column_names:
    IF name matches regex '.*_\d+$':
      count += 1
  RETURN count
ENDFUNCTION

FUNCTION AVG_UNDERSCORES(column_names):
  IF column_names is empty: RETURN 0.0
  total_underscores = SUM(name.count('_') FOR name in column_names)
  RETURN total_underscores / LENGTH(column_names)
ENDFUNCTION

FUNCTION COUNT_UPPERCASE_COLS(column_names):
  RETURN COUNT(name FOR name in column_names IF name.is_upper())
ENDFUNCTION

FUNCTION COUNT_LOWERCASE_COLS(column_names):
  RETURN COUNT(name FOR name in column_names IF name.is_lower())
ENDFUNCTION

FUNCTION COUNT_UNIQUE_DTYPES(data):
  all_dtypes = data.get_column_dtypes()
  RETURN LENGTH(UNIQUE(all_dtypes))
ENDFUNCTION

FUNCTION CALCULATE_DOMINANT_DTYPE_PCT(data):
  all_dtypes = data.get_column_dtypes()
  IF data.column_count == 0: RETURN 0.0
  dominant_dtype_freq = COUNT_MOST_FREQUENT(all_dtypes)
  RETURN dominant_dtype_freq / data.column_count
ENDFUNCTION

FUNCTION AVG_COL_NAME_LENGTH(column_names):
  IF column_names is empty: RETURN 0.0
  total_length = SUM(LENGTH(name) FOR name in column_names)
  RETURN total_length / LENGTH(column_names)
ENDFUNCTION

FUNCTION STD_COL_NAME_LENGTH(column_names):
  lengths = [LENGTH(name) FOR name in column_names]
  RETURN CALCULATE_STD_DEV(lengths)
ENDFUNCTION

FUNCTION GET_DAY_OF_WEEK(date_value):
  // Assumes a standard library where Monday=0 and Sunday=6
  RETURN date_value.weekday()
ENDFUNCTION

FUNCTION GET_MONTH(date_value):
  RETURN date_value.month
ENDFUNCTION

FUNCTION IS_WEEKEND(date_value):
  RETURN 1 IF date_value.weekday() >= 5 ELSE 0 // Saturday=5, Sunday=6
ENDFUNCTION

FUNCTION IS_MONTH_END(date_value):
  RETURN 1 IF date_value.is_month_end() ELSE 0
ENDFUNCTION

FUNCTION IS_QUARTER_END(date_value):
  RETURN 1 IF date_value.is_quarter_end() ELSE 0
ENDFUNCTION

FUNCTION DAYS_SINCE(current_date, previous_date):
  IF previous_date is None: RETURN 0
  time_delta = current_date - previous_date
  RETURN time_delta.in_days()
ENDFUNCTION

FUNCTION GET_COHORT_ROW_COUNT(cohort_data):
  // This is the total number of records belonging to the current group.
  RETURN cohort_data.row_count
ENDFUNCTION

FUNCTION COUNT_NULLS_IN_COLUMN(column_data):
  // column_data represents the values for this col within the current cohort.
  RETURN column_data.count_nulls()
ENDFUNCTION

FUNCTION CALCULATE_NULL_PERCENTAGE(column_data):
  total_rows = LENGTH(column_data)
  IF total_rows == 0: RETURN 0.0
  null_count = column_data.count_nulls()
  RETURN null_count / total_rows
ENDFUNCTION

FUNCTION HAS_NULLS(column_data):
  RETURN 1 IF column_data.count_nulls() > 0 ELSE 0
ENDFUNCTION

FUNCTION GET_DTYPE_COUNT():
  // Placeholder indicating one numeric column was processed.
  RETURN 1
ENDFUNCTION

FUNCTION CALCULATE_MEAN(column_data):
  IF column_data is empty: RETURN 0.0
  RETURN column_data.mean()
ENDFUNCTION

FUNCTION GET_STD_OF_MEANS():
  // This feature is not calculated from data and is always a fixed value.
  RETURN 0.0
ENDFUNCTION

FUNCTION CALCULATE_STD_DEV(column_data):
  IF LENGTH(column_data) < 2: RETURN 0.0
  RETURN column_data.std_dev()
ENDFUNCTION

FUNCTION CALCULATE_MAX(column_data):
  IF column_data is empty: RETURN 0.0
  RETURN column_data.max()
ENDFUNCTION

FUNCTION COUNT_ZEROS(column_data):
  RETURN column_data.count_where(value == 0)
ENDFUNCTION

FUNCTION GET_MEAN_CARDINALITY():
  RETURN UNIQUE(COLUMN)
ENDFUNCTION

FUNCTION CALCULATE_SKEWNESS(column_data):
  // This is the standardized third central moment.
  mean = MEAN(column_data)
  std_dev = STANDARD_DEVIATION(column_data)
  IF std_dev == 0: RETURN 0.0
  third_moment = MEAN( (value - mean)^3 FOR value in column_data )
  RETURN third_moment / (std_dev^3)
ENDFUNCTION

FUNCTION CALCULATE_EXCESS_KURTOSIS(column_data):
  // This is the standardized fourth central moment, minus 3.
  mean = MEAN(column_data)
  std_dev = STANDARD_DEVIATION(column_data)
  IF std_dev == 0: RETURN 0.0
  fourth_moment = MEAN( (value - mean)^4 FOR value in column_data )
  kurtosis = fourth_moment / (std_dev^4)
  RETURN kurtosis - 3.0
ENDFUNCTION

FUNCTION CALCULATE_PERCENTILE(column_data, percentile_q):
  // e.g., for 5th percentile, percentile_q = 5
  sorted_data = SORT(column_data)
  index = (percentile_q / 100) * (LENGTH(sorted_data) - 1)
  RETURN value at index in sorted_data (using interpolation if index is not an integer)
ENDFUNCTION

// Uses the same logic as the percentile_5 calculation.
FUNCTION CALCULATE_PERCENTILE(column_data, percentile_q=95):
  sorted_data = SORT(column_data)
  index = (95 / 100) * (LENGTH(sorted_data) - 1)
  RETURN value at index in sorted_data
ENDFUNCTION

FUNCTION CALCULATE_PERCENTILE_RANGE(column_data):
  p95 = CALCULATE_PERCENTILE(column_data, 95)
  p5 = CALCULATE_PERCENTILE(column_data, 5)
  RETURN p95 - p5
ENDFUNCTION

FUNCTION CALCULATE_CV(column_data):
  mean = MEAN(column_data)
  std_dev = STANDARD_DEVIATION(column_data)
  IF ABS(mean) < 1e-9: RETURN 0.0
  RETURN ABS(std_dev / mean)
ENDFUNCTION

FUNCTION CALCULATE_ZEROS_PCT(column_data):
  total_count = LENGTH(column_data)
  IF total_count == 0: RETURN 0.0
  zero_count = COUNT(value == 0 FOR value in column_data)
  RETURN zero_count / total_count
ENDFUNCTION

FUNCTION CALCULATE_NEGATIVES_PCT(column_data):
  total_count = LENGTH(column_data)
  IF total_count == 0: RETURN 0.0
  negative_count = COUNT(value < 0 FOR value in column_data)
  RETURN negative_count / total_count
ENDFUNCTION

FUNCTION CALCULATE_UNIQUE_RATIO(column_data):
  non_null_data = REMOVE_NULLS(column_data)
  total_count = LENGTH(non_null_data)
  IF total_count == 0: RETURN 0.0
  unique_count = COUNT(UNIQUE(non_null_data))
  RETURN unique_count / total_count
ENDFUNCTION

FUNCTION COUNT_IQR_OUTLIERS(column_data):
  Q1 = PERCENTILE(column_data, 25)
  Q3 = PERCENTILE(column_data, 75)
  IQR = Q3 - Q1
  lower_bound = Q1 - (1.5 * IQR)
  upper_bound = Q3 + (1.5 * IQR)
  RETURN COUNT(value < lower_bound OR value > upper_bound FOR value in column_data)
ENDFUNCTION

FUNCTION CALCULATE_IQR_OUTLIER_PCT(column_data):
  non_null_count = COUNT_NON_NULLS(column_data)
  IF non_null_count == 0: RETURN 0.0
  outlier_count = COUNT_IQR_OUTLIERS(column_data)
  RETURN outlier_count / non_null_count
ENDFUNCTION

FUNCTION COUNT_ZSCORE_OUTLIERS(column_data):
  mean = MEAN(column_data)
  std_dev = STANDARD_DEVIATION(column_data)
  IF std_dev == 0: RETURN 0
  RETURN COUNT( ABS((value - mean) / std_dev) > 3 FOR value in column_data )
ENDFUNCTION

FUNCTION CALCULATE_ZSCORE_OUTLIER_PCT(column_data):
  non_null_count = COUNT_NON_NULLS(column_data)
  IF non_null_count == 0: RETURN 0.0
  outlier_count = COUNT_ZSCORE_OUTLIERS(column_data)
  RETURN outlier_count / non_null_count
ENDFUNCTION

FUNCTION CALCULATE_ENTROPY(column_data):
  value_counts = GET_VALUE_COUNTS(column_data)
  total_count = LENGTH(column_data)
  entropy = 0.0
  FOR count in value_counts:
    probability = count / total_count
    entropy = entropy - (probability * LOG2(probability))
  ENDFOR
  RETURN entropy
ENDFUNCTION

FUNCTION GET_MAX_CONSECUTIVE_RUN(column_data):
  max_run = 0
  current_run = 0
  FOR i from 0 to LENGTH(column_data) - 1:
    IF i > 0 AND column_data[i] == column_data[i-1]:
      current_run = current_run + 1
    ELSE:
      current_run = 1
    ENDIF
    IF current_run > max_run: max_run = current_run
  ENDFOR
  RETURN max_run
ENDFUNCTION

FUNCTION GET_MONOTONIC_INCREASE_PCT(column_data):
  increases = 0
  transitions = 0
  FOR i from 1 to LENGTH(column_data) - 1:
    transitions = transitions + 1
    IF column_data[i] > column_data[i-1]:
      increases = increases + 1
    ENDIF
  ENDFOR
  IF transitions == 0: RETURN 0.0
  RETURN increases / transitions
ENDFUNCTION

FUNCTION GET_MONOTONIC_DECREASE_PCT(column_data):
  decreases = 0
  transitions = 0
  FOR i from 1 to LENGTH(column_data) - 1:
    transitions = transitions + 1
    IF column_data[i] < column_data[i-1]:
      decreases = decreases + 1
    ENDIF
  ENDFOR
  IF transitions == 0: RETURN 0.0
  RETURN decreases / transitions
ENDFUNCTION

FUNCTION CALCULATE_COHORT_SIZE(cohort_data):
  // cohort_data is the subset of the full dataframe belonging to one group.
  RETURN COUNT_ROWS(cohort_data)
ENDFUNCTION

FUNCTION CALCULATE_PEARSON_CORRELATION(col1_data, col2_data):
  // Measures the linear relationship between two variables.
  covariance = COVARIANCE(col1_data, col2_data)
  std_dev1 = STANDARD_DEVIATION(col1_data)
  std_dev2 = STANDARD_DEVIATION(col2_data)
  IF std_dev1 == 0 OR std_dev2 == 0: RETURN 0.0
  RETURN covariance / (std_dev1 * std_dev2)
ENDFUNCTION

FUNCTION CALCULATE_SPEARMAN_CORRELATION(col1_data, col2_data):
  // Measures the monotonic relationship using ranks.
  1. Convert each value in col1_data to its rank within the column.
  ranks1 = GET_RANKS(col1_data)
  2. Convert each value in col2_data to its rank within the column.
  ranks2 = GET_RANKS(col2_data)
  3. Calculate the Pearson correlation on the ranked data.
  RETURN CALCULATE_PEARSON_CORRELATION(ranks1, ranks2)
ENDFUNCTION

FUNCTION COUNT_VALID_PAIRS(col1_data, col2_data):
  count = 0
  FOR i from 0 to LENGTH(col1_data) - 1:
    IF col1_data[i] IS NOT NULL AND col2_data[i] IS NOT NULL:
      count = count + 1
    ENDIF
  ENDFOR
  RETURN count
ENDFUNCTION

FUNCTION CALCULATE_RATIO_MEAN(col1_data, col2_data):
  ratios = []
  FOR i from 0 to LENGTH(col1_data) - 1:
    IF col2_data[i] IS NOT NULL AND col2_data[i] != 0:
      ratios.APPEND(col1_data[i] / col2_data[i])
    ENDIF
  ENDFOR
  RETURN MEAN(ratios) IF ratios is not empty ELSE 0.0
ENDFUNCTION

FUNCTION CALCULATE_RATIO_STD(col1_data, col2_data):
  ratios = []
  FOR i from 0 to LENGTH(col1_data) - 1:
    IF col2_data[i] IS NOT NULL AND col2_data[i] != 0:
      ratios.APPEND(col1_data[i] / col2_data[i])
    ENDIF
  ENDFOR
  RETURN STANDARD_DEVIATION(ratios) IF LENGTH(ratios) > 1 ELSE 0.0
ENDFUNCTION

FUNCTION CALCULATE_DIFF_MEAN(col1_data, col2_data):
  differences = []
  FOR i from 0 to LENGTH(col1_data) - 1:
    IF col1_data[i] IS NOT NULL AND col2_data[i] IS NOT NULL:
      differences.APPEND(ABS(col1_data[i] - col2_data[i]))
    ENDIF
  ENDFOR
  RETURN MEAN(differences) IF differences is not empty ELSE 0.0
ENDFUNCTION

FUNCTION CALCULATE_DIFF_STD(col1_data, col2_data):
  differences = []
  FOR i from 0 to LENGTH(col1_data) - 1:
    IF col1_data[i] IS NOT NULL AND col2_data[i] IS NOT NULL:
      differences.APPEND(ABS(col1_data[i] - col2_data[i]))
    ENDIF
  ENDFOR
  RETURN STANDARD_DEVIATION(differences) IF LENGTH(differences) > 1 ELSE 0.0
ENDFUNCTION

FUNCTION CALCULATE_CORRELATION_PVALUE(correlation_r, num_pairs_n):
  IF num_pairs_n <= 2: RETURN 1.0
  // Calculate t-statistic from the correlation coefficient.
  t_stat = correlation_r * SQRT((num_pairs_n - 2) / (1 - correlation_r^2))
  // Calculate two-tailed p-value from the t-distribution.
  degrees_of_freedom = num_pairs_n - 2
  p_value = 2 * (1 - CUMULATIVE_DISTRIBUTION_FUNCTION_T(ABS(t_stat), degrees_of_freedom))
  RETURN p_value
ENDFUNCTION

FUNCTION CALCULATE_INTERACT_MEAN_VARIANCE(interaction_pairs, cohort_data):
  all_mean_variances = []
  FOR each pair (cat_col, num_col) in interaction_pairs:
    // 1. Group the cohort by the categorical column.
    sub_groups = GROUP_BY(cohort_data, cat_col)
    variances_for_this_pair = []
    // 2. Calculate variance of the numeric column for each sub-group.
    FOR each group in sub_groups:
      variances_for_this_pair.APPEND(VARIANCE(group[num_col]))
    ENDFOR
    // 3. Take the mean of those variances.
    all_mean_variances.APPEND(MEAN(variances_for_this_pair))
  ENDFOR
  // 4. Average the results across all interaction pairs.
  RETURN MEAN(all_mean_variances)
ENDFUNCTION

FUNCTION CALCULATE_INTERACT_STD_VARIANCE(interaction_pairs, cohort_data):
  all_std_variances = []
  FOR each pair (cat_col, num_col) in interaction_pairs:
    sub_groups = GROUP_BY(cohort_data, cat_col)
    variances_for_this_pair = []
    FOR each group in sub_groups:
      variances_for_this_pair.APPEND(VARIANCE(group[num_col]))
    ENDFOR
    // 3. Take the standard deviation of those variances.
    all_std_variances.APPEND(STANDARD_DEVIATION(variances_for_this_pair))
  ENDFOR
  // 4. Average the results across all interaction pairs.
  RETURN MEAN(all_std_variances)
ENDFUNCTION

FUNCTION GET_PCA_EIGENVALUES(pca_columns_data):
  // 1. Standardize the data (mean=0, std=1 for each column).
  standardized_data = STANDARDIZE(pca_columns_data)
  // 2. Compute the covariance matrix.
  covariance_matrix = COVARIANCE_MATRIX(standardized_data)
  // 3. Calculate eigenvalues and sort them in descending order.
  eigenvalues = EIGENVALUES(covariance_matrix)
  SORT(eigenvalues, descending=True)
  RETURN eigenvalues
ENDFUNCTION

// Feature calculation:
eigenvalues = GET_PCA_EIGENVALUES(cohort_pca_data)
RETURN eigenvalues[0] IF eigenvalues exists ELSE 0.0

// Assumes eigenvalues are pre-calculated and sorted.
eigenvalues = GET_PCA_EIGENVALUES(cohort_pca_data)
RETURN eigenvalues[1] IF LENGTH(eigenvalues) > 1 ELSE 0.0

eigenvalues = GET_PCA_EIGENVALUES(cohort_pca_data)
IF IS_EMPTY(eigenvalues): RETURN 0.0
total_variance = SUM(eigenvalues)
IF total_variance == 0: RETURN 0.0
RETURN eigenvalues[0] / total_variance
ENDFUNCTION

eigenvalues = GET_PCA_EIGENVALUES(cohort_pca_data)
IF LENGTH(eigenvalues) < 2: RETURN 0.0
total_variance = SUM(eigenvalues)
IF total_variance == 0: RETURN 0.0
RETURN eigenvalues[1] / total_variance
ENDFUNCTION

eigenvalues = GET_PCA_EIGENVALUES(cohort_pca_data)
IF LENGTH(eigenvalues) < 2: RETURN pca_explained_variance_ratio_1
total_variance = SUM(eigenvalues)
IF total_variance == 0: RETURN 0.0
RETURN (eigenvalues[0] + eigenvalues[1]) / total_variance
ENDFUNCTION

eigenvalues = GET_PCA_EIGENVALUES(cohort_pca_data)
IF IS_EMPTY(eigenvalues): RETURN 0
total_variance = SUM(eigenvalues)
IF total_variance == 0: RETURN 0
cumulative_variance = 0.0
component_count = 0
FOR each eigenvalue in eigenvalues:
  cumulative_variance = cumulative_variance + (eigenvalue / total_variance)
  component_count = component_count + 1
  IF cumulative_variance >= 0.90: BREAK
ENDFOR
RETURN component_count
ENDFUNCTION

FUNCTION CALCULATE_ROLLING_MEAN(window_data):
  IF window_data is empty: RETURN 0.0
  RETURN SUM(window_data) / LENGTH(window_data)
ENDFUNCTION

FUNCTION CALCULATE_ROLLING_STD(window_data):
  IF LENGTH(window_data) < 2: RETURN 0.0
  mean = MEAN(window_data)
  variance = SUM((x - mean)^2 FOR x in window_data) / (LENGTH(window_data) - 1)
  RETURN SQRT(variance)
ENDFUNCTION

FUNCTION CALCULATE_ROLLING_MIN(window_data):
  IF window_data is empty: RETURN 0.0
  RETURN MINIMUM(window_data)
ENDFUNCTION

FUNCTION CALCULATE_ROLLING_MAX(window_data):
  IF window_data is empty: RETURN 0.0
  RETURN MAXIMUM(window_data)
ENDFUNCTION

FUNCTION CALCULATE_ZSCORE(current_value, window_data):
  mean = MEAN(window_data)
  std_dev = STANDARD_DEVIATION(window_data)
  IF std_dev < 1e-9: RETURN 0.0
  RETURN (current_value - mean) / std_dev
ENDFUNCTION

FUNCTION CALCULATE_NULL_RATIO(window_data):
  IF IS_EMPTY(window_data): RETURN 0.0
  null_count = COUNT(value IS NULL in window_data)
  RETURN null_count / LENGTH(window_data)
ENDFUNCTION

FUNCTION CALCULATE_OUTLIER_SCORE(current_value, window_data):
  IF LENGTH(window_data) < 4: RETURN 0
  Q1 = PERCENTILE(window_data, 25)
  Q3 = PERCENTILE(window_data, 75)
  IQR = Q3 - Q1
  lower_bound = Q1 - (1.5 * IQR)
  upper_bound = Q3 + (1.5 * IQR)
  RETURN 1 IF (current_value < lower_bound OR current_value > upper_bound) ELSE 0
ENDFUNCTION

FUNCTION CALCULATE_APPROX_TREND_SLOPE(current_value, window_data, window_size):
  IF LENGTH(window_data) < window_size: RETURN 0.0
  first_value = FIRST_VALUE(window_data)
  RETURN (current_value - first_value) / window_size
ENDFUNCTION

FUNCTION CALCULATE_VOLATILITY(window_data):
  mean = MEAN(window_data)
  std_dev = STANDARD_DEVIATION(window_data)
  IF ABS(mean) < 1e-9: RETURN 0.0 IF std_dev == 0 ELSE 1.0
  RETURN std_dev / ABS(mean)
ENDFUNCTION

FUNCTION CALCULATE_STABILITY_SCORE(window_data):
  volatility = CALCULATE_VOLATILITY(window_data)
  RETURN 1.0 / (1.0 + volatility)
ENDFUNCTION

FUNCTION CALCULATE_MOMENTUM(current_value, window_data):
  mean = MEAN(window_data)
  RETURN current_value - mean
ENDFUNCTION

FUNCTION CALCULATE_ACCELERATION(current_momentum, previous_momentum):
  RETURN current_momentum - previous_momentum
ENDFUNCTION

FUNCTION CALCULATE_MEAN_DIFF(current_value, window_data):
  mean = MEAN(window_data)
  RETURN ABS(current_value - mean)
ENDFUNCTION

FUNCTION CALCULATE_STD_DIFF(current_window_std, previous_window_std):
  RETURN current_window_std - previous_window_std
ENDFUNCTION

FUNCTION CALCULATE_RANGE_RATIO(current_value, window_data):
  min_val = MIN(window_data)
  max_val = MAX(window_data)
  range = max_val - min_val
  IF range < 1e-9: RETURN 0.5
  RETURN (current_value - min_val) / range
ENDFUNCTION

FUNCTION CALCULATE_PERCENTILE_RANK(current_value, window_data):
  IF IS_EMPTY(window_data): RETURN 50.0
  count_less = COUNT(x < current_value FOR x in window_data)
  RETURN (count_less / LENGTH(window_data)) * 100.0
ENDFUNCTION

FUNCTION CALCULATE_IQR(window_data):
  IF LENGTH(window_data) < 2: RETURN 0.0
  Q1 = PERCENTILE(window_data, 25)
  Q3 = PERCENTILE(window_data, 75)
  RETURN Q3 - Q1
ENDFUNCTION

FUNCTION CALCULATE_SKEWNESS(window_data):
  IF LENGTH(window_data) < 3: RETURN 0.0
  n = LENGTH(window_data)
  mean = MEAN(window_data)
  std_dev = STANDARD_DEVIATION(window_data)
  IF std_dev == 0: RETURN 0.0
  third_moment = SUM(((x - mean) / std_dev)^3 FOR x in window_data) / n
  RETURN third_moment
ENDFUNCTION

FUNCTION CALCULATE_KURTOSIS(window_data):
  IF LENGTH(window_data) < 4: RETURN 0.0
  n = LENGTH(window_data)
  mean = MEAN(window_data)
  std_dev = STANDARD_DEVIATION(window_data)
  IF std_dev == 0: RETURN 0.0
  fourth_moment = SUM(((x - mean) / std_dev)^4 FOR x in window_data) / n
  RETURN fourth_moment - 3.0
ENDFUNCTION

FUNCTION CALCULATE_VALUE_SUM(window_data):
  RETURN SUM(window_data)
ENDFUNCTION

FUNCTION CALCULATE_VALUE_MEAN_DIFF(current_value, window_data):
  mean = MEAN(window_data)
  RETURN current_value - mean
ENDFUNCTION

FUNCTION CALCULATE_VOLATILITY_RATIO(current_value, window_data):
  mean = MEAN(window_data)
  std_dev = STANDARD_DEVIATION(window_data)
  IF std_dev < 1e-9: RETURN 0.0
  RETURN ABS(current_value - mean) / std_dev
ENDFUNCTION

FUNCTION CALCULATE_EUCLIDEAN_DISTANCE(recent_window, historical_window):
  IF LENGTH(recent_window) != LENGTH(historical_window): RETURN 0.0
  sum_of_squares = 0.0
  FOR i from 0 to LENGTH(recent_window) - 1:
    difference = recent_window[i] - historical_window[i]
    sum_of_squares = sum_of_squares + (difference * difference)
  ENDFOR
  RETURN SQRT(sum_of_squares)
ENDFUNCTION

FUNCTION CALCULATE_COSINE_DISTANCE(recent_window, historical_window):
  IF LENGTH(recent_window) != LENGTH(historical_window): RETURN 1.0
  dot_product = 0.0
  magnitude_recent = 0.0
  magnitude_historical = 0.0
  FOR i from 0 to LENGTH(recent_window) - 1:
    dot_product = dot_product + (recent_window[i] * historical_window[i])
    magnitude_recent = magnitude_recent + (recent_window[i] * recent_window[i])
    magnitude_historical = magnitude_historical + (historical_window[i] * historical_window[i])
  ENDFOR
  magnitude_recent = SQRT(magnitude_recent)
  magnitude_historical = SQRT(magnitude_historical)
  IF magnitude_recent == 0.0 OR magnitude_historical == 0.0: RETURN 1.0
  cosine_similarity = dot_product / (magnitude_recent * magnitude_historical)
  RETURN 1.0 - cosine_similarity
ENDFUNCTION

FUNCTION CALCULATE_MAHALANOBIS_DISTANCE(current_point, historical_distribution):
  IF LENGTH(historical_distribution) < 2: RETURN 0.0
  mean_historical = MEAN(historical_distribution)
  variance_historical = VARIANCE(historical_distribution)
  IF variance_historical == 0.0:
    RETURN ABS(current_point - mean_historical)
  ENDIF
  distance = ABS(current_point - mean_historical) / SQRT(variance_historical)
  RETURN distance
ENDFUNCTION

FUNCTION CALCULATE_WASSERSTEIN_DISTANCE(recent_window, historical_window):
  IF IS_EMPTY(recent_window) OR IS_EMPTY(historical_window): RETURN 0.0
  sorted_recent = SORT(recent_window)
  sorted_historical = SORT(historical_window)
  all_points = UNIQUE(CONCATENATE(sorted_recent, sorted_historical))
  all_points = SORT(all_points)
  distance = 0.0
  cdf_recent = 0.0
  cdf_historical = 0.0
  FOR i from 0 to LENGTH(all_points) - 2:
    point1 = all_points[i]
    point2 = all_points[i+1]
    cdf_recent = COUNT(p <= point1 IN sorted_recent) / LENGTH(sorted_recent)
    cdf_historical = COUNT(p <= point1 IN sorted_historical) / LENGTH(sorted_historical)
    distance = distance + ABS(cdf_recent - cdf_historical) * (point2 - point1)
  ENDFOR
  RETURN distance
ENDFUNCTION

FUNCTION CALCULATE_JENSEN_SHANNON_DIVERGENCE(recent_window, historical_window):
  min_val = MIN(MIN(recent_window), MIN(historical_window))
  max_val = MAX(MAX(recent_window), MAX(historical_window))
  bin_edges = CREATE_BINS(min_val, max_val, num_bins=10)
  hist_P = HISTOGRAM(recent_window, bin_edges)
  P = (hist_P + 1e-9) / SUM(hist_P)
  hist_Q = HISTOGRAM(historical_window, bin_edges)
  Q = (hist_Q + 1e-9) / SUM(hist_Q)
  M = 0.5 * (P + Q)
  kl_pm = SUM(P[i] * LOG(P[i] / M[i])) FOR i in P
  kl_qm = SUM(Q[i] * LOG(Q[i] / M[i])) FOR i in Q
  jsd = 0.5 * (kl_pm + kl_qm)
  RETURN jsd
ENDFUNCTION

FUNCTION PERFORM_KS_TEST(sample1, sample2):
  sorted1 = SORT(sample1)
  sorted2 = SORT(sample2)
  max_diff = 0.0
  n1 = LENGTH(sorted1)
  n2 = LENGTH(sorted2)
  i = 0
  j = 0
  WHILE i < n1 AND j < n2:
    diff = ABS((i+1)/n1 - (j+1)/n2)
    if diff > max_diff: max_diff = diff
    IF sorted1[i] < sorted2[j]: i = i + 1
    ELSE IF sorted2[j] < sorted1[i]: j = j + 1
    ELSE: i = i + 1; j = j + 1
    ENDIF
  ENDWHILE
  p_value = CALCULATE_P_VALUE_FROM_D_STATISTIC(max_diff, n1, n2)
  RETURN p_value
ENDFUNCTION

FUNCTION PERFORM_LEVENE_TEST(sample1, sample2):
  median1 = MEDIAN(sample1)
  median2 = MEDIAN(sample2)
  Z1 = [ABS(x - median1) FOR x in sample1]
  Z2 = [ABS(x - median2) FOR x in sample2]
  p_value = T_TEST(Z1, Z2)
  RETURN p_value
ENDFUNCTION

FUNCTION PERFORM_MANN_WHITNEY_U_TEST(sample1, sample2):
  combined_list = CREATE_LIST_OF_PAIRS([(v, 's1') for v in sample1] + [(v, 's2') for v in sample2])
  sorted_combined = SORT(combined_list by value)
  ADD_RANKS_TO(sorted_combined)
  rank_sum_1 = SUM(rank for (value, origin, rank) in sorted_combined if origin == 's1')
  n1 = LENGTH(sample1)
  n2 = LENGTH(sample2)
  U_statistic = rank_sum_1 - (n1 * (n1 + 1) / 2)
  p_value = CALCULATE_P_VALUE_FROM_U(U_statistic, n1, n2)
  RETURN p_value
ENDFUNCTION

FUNCTION CALCULATE_SUDDEN_CHANGE_SCORE(current_value, previous_value, recent_window):
  recent_std_dev = STANDARD_DEVIATION(recent_window)
  IF recent_std_dev < 1e-9: RETURN 0.0
  change = ABS(current_value - previous_value)
  score = change / recent_std_dev
  RETURN score
ENDFUNCTION

FUNCTION CALCULATE_GRADUAL_CHANGE_SCORE(recent_window):
  IF LENGTH(recent_window) < 3: RETURN 0.0
  time_indices = [i for i from 0 to LENGTH(recent_window) - 1]
  slope, intercept, r_value = LINEAR_REGRESSION(x=time_indices, y=recent_window)
  r_squared = r_value * r_value
  mean_val = MEAN(recent_window)
  IF ABS(mean_val) < 1e-9: normalized_slope = slope
  ELSE: normalized_slope = slope / mean_val
  score = r_squared * normalized_slope
  RETURN ABS(score)
ENDFUNCTION

FUNCTION CALCULATE_TREND_DEVIATION(current_value, historical_window):
  IF LENGTH(historical_window) < 3: RETURN 0.0
  time_indices = [i for i from 0 to LENGTH(historical_window) - 1]
  slope, intercept = LINEAR_REGRESSION(x=time_indices, y=historical_window)
  current_time_index = LENGTH(historical_window)
  predicted_value = (slope * current_time_index) + intercept
  deviation = ABS(current_value - predicted_value)
  historical_std_dev = STANDARD_DEVIATION(historical_window)
  IF historical_std_dev < 1e-9: RETURN deviation
  ELSE: RETURN deviation / historical_std_dev
ENDFUNCTION

FUNCTION CALCULATE_STABILITY_INDEX(recent_window):
  IF LENGTH(recent_window) < 2: RETURN 1.0
  mean_val = MEAN(recent_window)
  std_dev = STANDARD_DEVIATION(recent_window)
  IF ABS(mean_val) < 1e-9: RETURN 1.0 / (1.0 + std_dev)
  coefficient_of_variation = std_dev / ABS(mean_val)
  stability = 1.0 / (1.0 + coefficient_of_variation)
  RETURN stability
ENDFUNCTION

FUNCTION CALCULATE_ACCELERATION(data_column, current_index):
  IF current_index < 2: RETURN 0.0
  current_value = data_column[current_index]
  previous_value = data_column[current_index - 1]
  pre_previous_value = data_column[current_index - 2]
  velocity_recent = current_value - previous_value
  velocity_prior = previous_value - pre_previous_value
  acceleration = velocity_recent - velocity_prior
  value_range = MAX(ABS(current_value), ABS(previous_value), ABS(pre_previous_value))
  IF value_range == 0: RETURN 0.0
  RETURN acceleration / value_range
ENDFUNCTION

FUNCTION CALCULATE_MOMENTUM(recent_window):
  IF LENGTH(recent_window) < 2: RETURN 0.0
  changes = []
  FOR i from 1 to LENGTH(recent_window) - 1:
    changes.APPEND(recent_window[i] - recent_window[i-1])
  ENDFOR
  weights = [i for i from 1 to LENGTH(changes)]
  weighted_sum = SUM(changes[i] * weights[i] FOR i in range(LENGTH(changes)))
  sum_of_weights = SUM(weights)
  IF sum_of_weights == 0: RETURN 0.0
  RETURN weighted_sum / sum_of_weights
ENDFUNCTION

FUNCTION CALCULATE_VOLATILITY_RATIO(current_value, previous_value, historical_window):
  IF LENGTH(historical_window) < 2: RETURN 1.0
  recent_absolute_change = ABS(current_value - previous_value)
  historical_changes = [ABS(historical_window[i] - historical_window[i-1]) for i from 1 to LENGTH-1]
  historical_volatility = STANDARD_DEVIATION(historical_changes)
  IF historical_volatility < 1e-9:
    RETURN 1.0 if recent_absolute_change == 0 else 10.0
  ENDIF
  RETURN recent_absolute_change / historical_volatility
ENDFUNCTION

FUNCTION CALCULATE_PERCENTILE_SCORE(current_value, historical_window):
  IF IS_EMPTY(historical_window): RETURN 0.0
  count_less = COUNT(p < current_value IN historical_window)
  percentile_rank = (count_less / LENGTH(historical_window)) * 100.0
  extremeness_score = ABS(percentile_rank - 50.0) / 50.0
  RETURN extremeness_score
ENDFUNCTION

FUNCTION CALCULATE_REGIME_CHANGE_PROB(current_value, historical_window):
  IF LENGTH(historical_window) < 20: RETURN 0.0
  p5 = PERCENTILE(historical_window, 5)
  p95 = PERCENTILE(historical_window, 95)
  normal_range_width = p95 - p5
  IF normal_range_width < 1e-9: RETURN 0.0
  deviation = 0.0
  IF current_value > p95: deviation = (current_value - p95) / normal_range_width
  ELSE IF current_value < p5: deviation = (p5 - current_value) / normal_range_width
  probability = 1.0 - EXP(-deviation)
  RETURN probability
ENDFUNCTION