Please address the comments from this code review:
## Individual Comments

### Comment 1
<location> `pdll/_pairwise.py:1037` </location>
<code_context>
+    self.threshold_ = best_threshold
+    self.percentile_ = best_percentile
+
+    print(f" Best percentile selected: {self.percentile_} with F1-macro: {best_f1:.4f}")
+
+    return self
</code_context>

<issue_to_address>
Use of print statement for logging may not be appropriate in production code.

Replace the print statement with a logging call for improved output management and integration.

Suggested implementation:

```python
    import logging
    logging.info(f"Best percentile selected: {self.percentile_} with F1-macro: {best_f1:.4f}")

```

If the file already imports `logging` at the top, you can omit the `import logging` line in the replacement. For best practice, ensure logging is configured somewhere in your codebase (e.g., with `logging.basicConfig(level=logging.INFO)` in your main entrypoint).
</issue_to_address>

### Comment 2
<location> `pdll/_pairwise.py:1093` </location>
<code_context>
+    Returns:
+    - tuple: (paired feature differences, symmetric feature differences)
+    """
+    X_pair = X1.merge(X2, how="cross")
+
+    # Extract and rename columns for difference calculation
</code_context>

<issue_to_address>
Cross-join for pairwise differences may have high memory and performance cost.

For large inputs, this approach may cause memory issues or slowdowns. Consider implementing checks for input size or using a more efficient method.
</issue_to_address>

<suggested_fix>
<<<<<<< SEARCH
    X_pair = X1.merge(X2, how="cross")

    # Extract and rename columns for difference calculation
=======
    # Check for large input sizes before performing cross-join
    max_cross_rows = 1_000_000  # threshold for warning/error
    expected_rows = len(X1) * len(X2)
    if expected_rows > max_cross_rows:
        raise ValueError(
            f"PairwiseDifference: Cross-join would result in {expected_rows} rows, "
            "which may cause memory or performance issues. "
            "Consider using smaller inputs or a more efficient method."
        )

    X_pair = X1.merge(X2, how="cross")

    # Extract and rename columns for difference calculation
>>>>>>> REPLACE

</suggested_fix>

### Comment 3
<location> `pdll/_pairwise.py:1099` </location>
<code_context>
+    x1_pair = X_pair[[f'{col}_x' for col in X1.columns]].rename(columns={f'{col}_x': f'{col}_diff' for col in X1.columns})
+    x2_pair = X_pair[[f'{col}_y' for col in X1.columns]].rename(columns={f'{col}_y': f'{col}_diff' for col in X1.columns})
+
+    try:
+        calculate_difference = x1_pair - x2_pair
+    except Exception as e:
</code_context>

<issue_to_address>
Exception handling for non-numeric data is broad.

Catching only relevant exceptions like TypeError will help ensure other errors are not inadvertently ignored.
</issue_to_address>

<suggested_fix>
<<<<<<< SEARCH
    try:
        calculate_difference = x1_pair - x2_pair
    except Exception as e:
        raise ValueError("PairwiseDifference: Non-numeric data found.") from e
=======
    try:
        calculate_difference = x1_pair - x2_pair
    except TypeError as e:
        raise ValueError("PairwiseDifference: Non-numeric data found.") from e
>>>>>>> REPLACE

</suggested_fix>

### Comment 4
<location> `pdll/_pairwise.py:1105` </location>
<code_context>
+        raise ValueError("PairwiseDifference: Non-numeric data found.") from e
+
+    # Concatenate the original cross-join and calculated differences
+    X_pair = pd.concat([X_pair, calculate_difference], axis='columns')
+
+
</code_context>

<issue_to_address>
Concatenation of DataFrames may result in duplicate columns or misalignment.

Check for overlapping column names before concatenation and validate the output DataFrame's structure and columns.
</issue_to_address>

<suggested_fix>
<<<<<<< SEARCH
    # Concatenate the original cross-join and calculated differences
=======
    # Check for overlapping column names before concatenation
    overlap = set(X_pair.columns) & set(calculate_difference.columns)
    if overlap:
        raise ValueError(f"PairwiseDifference: Overlapping column names detected during concatenation: {overlap}")

    # Concatenate the original cross-join and calculated differences
    X_pair = pd.concat([X_pair, calculate_difference], axis='columns')

    # Validate the output DataFrame's structure and columns
    expected_columns = list(X_pair.columns)  # Adjust this as needed for your use case
    if X_pair.columns.duplicated().any():
        raise ValueError("PairwiseDifference: Duplicate columns found in the output DataFrame after concatenation.")
>>>>>>> REPLACE

</suggested_fix>

### Comment 5
<location> `pdll/_pairwise.py:1113` </location>
<code_context>
+    x1_pair_sym = X_pair[[f'{col}_y' for col in X1.columns]].rename(columns={f'{col}_y': f'{col}_x' for col in X1.columns})
+    X_pair_sym = pd.concat([x1_pair_sym, x2_pair_sym, x2_pair - x1_pair], axis='columns')
+
+    return X_pair, X_pair_sym
+
+    
</code_context>

<issue_to_address>
Returned symmetric feature differences are not used elsewhere in the class.

Consider removing symmetric feature differences from the return value if they are not needed, to keep the interface clean.

Suggested implementation:

```python

```

```python
    return X_pair

```
</issue_to_address>

### Comment 6
<location> `tests/unsupervised_outlier_detection.py:72` </location>
<code_context>
+    X_sampled = df_sampled.drop(columns=['class']).values
+    y_sampled = df_sampled['class'].values
+
+    # Train/Test Split (without random_state, fully random split)
+    X_train, X_test, y_train, y_test = train_test_split(X_sampled, y_sampled, test_size=0.4)
+    assert len(np.unique(y_train)) == 2
+    assert len(np.unique(y_test)) == 2
</code_context>

<issue_to_address>
Test split does not use a fixed random_state, which may lead to non-reproducible results.

Set random_state in train_test_split for consistent and reproducible test splits.
</issue_to_address>

<suggested_fix>
<<<<<<< SEARCH
    # Train/Test Split (without random_state, fully random split)
    X_train, X_test, y_train, y_test = train_test_split(X_sampled, y_sampled, test_size=0.4)
=======
    # Train/Test Split (with fixed random_state for reproducibility)
    X_train, X_test, y_train, y_test = train_test_split(X_sampled, y_sampled, test_size=0.4, random_state=42)
>>>>>>> REPLACE

</suggested_fix>

### Comment 7
<location> `tests/unsupervised_outlier_detection.py:77` </location>
<code_context>
+    assert len(np.unique(y_train)) == 2
+    assert len(np.unique(y_test)) == 2
+
+    # Baseline: IsolationForest
+    iso_forest = IsolationForest()
+    iso_forest.fit(X_train)
+    y_pred_iso = np.where(iso_forest.predict(X_test) == -1, 1, 0)
+
</code_context>

<issue_to_address>
No test for error handling when input data contains non-numeric values.

Add a test with non-numeric input to confirm that ValueError is raised by PairwiseDifferenceOutlierDetection.
</issue_to_address>

<suggested_fix>
<<<<<<< SEARCH
    assert len(np.unique(y_train)) == 2
    assert len(np.unique(y_test)) == 2
=======
    assert len(np.unique(y_train)) == 2
    assert len(np.unique(y_test)) == 2

    # Error handling test: non-numeric input for PairwiseDifferenceOutlierDetection
    import pytest

    X_non_numeric = [['a', 'b'], ['c', 'd']]
    y_dummy = [0, 1]

    from unsupervised_outlier_detection import PairwiseDifferenceOutlierDetection

    with pytest.raises(ValueError):
        model = PairwiseDifferenceOutlierDetection()
        model.fit(X_non_numeric, y_dummy)
>>>>>>> REPLACE

</suggested_fix>

### Comment 8
<location> `tests/unsupervised_outlier_detection.py:96` </location>
<code_context>
+        "AUC_PR": auc_pr_iso
+    })
+
+    # Train PairwiseDifferenceOutlierDetection
+    model = PairwiseDifferenceOutlierDetection()
+
+    # >>> Threshold is optimized inside 'fit()' based on mean anomaly scores
+    # >>> Threshold is found on X_train_pair with best F1 macro (based on y_train)
+    model.fit(pd.DataFrame(X_train), y_train)   # Important "i did it already in PairwiseDifferenceOutlierDetection": Pass X_train_Pair as DataFrame
+
+    # Predict using the best found threshold 
</code_context>

<issue_to_address>
No test for estimator behavior when all samples are identical.

Add a test with identical input samples to verify the estimator's robustness and correctness in this edge case.
</issue_to_address>

### Comment 9
<location> `tests/unsupervised_outlier_detection.py:107` </location>
<code_context>
+    # >>> Prediction is made on X_test by applying the selected best threshold from training
+    y_pred_pdl = model.predict(pd.DataFrame(X_test))
+
+    # Metrics for PairwiseDifferenceOutlierDetection
+    f1_pdl = f1_score(y_test, y_pred_pdl, average='macro')
+    auc_roc_pdl = roc_auc_score(y_test, y_pred_pdl)
+    auc_pr_pdl = average_precision_score(y_test, y_pred_pdl)
+
+    all_results.append({
</code_context>

<issue_to_address>
No test for estimator behavior when input contains NaN or infinite values.

Add a test with NaN or infinite values in the input to ensure the estimator responds correctly.

Suggested implementation:

```python
    model = PairwiseDifferenceOutlierDetection()

    # >>> Threshold is optimized inside 'fit()' based on mean anomaly scores
    # >>> Threshold is found on X_train_pair with best F1 macro (based on y_train)
    model.fit(pd.DataFrame(X_train), y_train)   # Important "i did it already in PairwiseDifferenceOutlierDetection": Pass X_train_Pair as DataFrame

    # Predict using the best found threshold 
    # >>> Prediction is made on X_test by applying the selected best threshold from training
    y_pred_pdl = model.predict(pd.DataFrame(X_test))

    # Test estimator behavior with NaN and infinite values in input
    import numpy as np
    import pytest

    X_test_nan = pd.DataFrame(X_test.copy())
    X_test_nan.iloc[0, 0] = np.nan
    X_test_inf = pd.DataFrame(X_test.copy())
    X_test_inf.iloc[0, 0] = np.inf

    # Check for NaN
    with pytest.raises(ValueError):
        model.predict(X_test_nan)

    # Check for infinite
    with pytest.raises(ValueError):
        model.predict(X_test_inf)

```

- Ensure that `pytest` is available in your test environment.
- If the estimator does not currently raise a `ValueError` for NaN or infinite values, you may need to update the estimator implementation to do so.
- If you use a different test framework, adjust the exception assertion accordingly.
</issue_to_address>