artoby/symlog_bins.py

Hi, thanks for the code!. I wrote a similar function to yours that I think fixes possible issues. In particular, if pos_n_bin_edges_raw in your code is zero, it will fail, since neg_n_bin_edges would be nonzero_n_bin_edges and pos_n_bin__edges would be 2, so the total number of cuts will be bigger than n_cuts. Also, I extend the minimum and maximum values by a 10% to fix possible issues with floats (I use this together with pd.cut and sometime edge values are not included in their bin because float precision).
Another difference in my code is that I don't start from zero_eps but from the closest value to zero, so positive and negative bins do not start from the same value. I paste here my function in case it can help anyone.

def symlogspace(col, n_cuts, dtype='float64'):
    """
    Splits a data range into log-like bins but with 0 and negative values
    taken into account. Log cuts start from the closest value to zero.
    
    Parameters
    ----------
    col: df column or array
    n_cuts: int
            Number of cuts to perform
    dtype: dtype of the outputs
    """
    min_val = col.min()
    max_val = col.max()

    # compute negative and positive range
    min_pos = col[col > 0].min() if not np.isnan(col[col > 0].min()) else 0
    max_neg = col[col < 0].max() if not np.isnan(col[col < 0].max()) else 0
    neg_range = [-min_val, -max_neg] if min_val < max_neg else None
    pos_range = [max(min_val, min_pos), max_val] if max_val > min_pos else None

    # If min value is 0 create a bin for it
    zero_cut = [min_val] if max_neg <= min_val < min_pos else []

    n_cuts = n_cuts - len(zero_cut)

    neg_range_size = (neg_range[0] - neg_range[1]) if neg_range is not None else 0
    pos_range_size = (pos_range[1] - pos_range[0]) if pos_range is not None else 0
    range_size = neg_range_size + pos_range_size

    n_pos_cuts = max(2, int(round(n_cuts * (pos_range_size / range_size)))) if range_size > 0 and pos_range_size > 0 else 0
    # Ensure each range has at least 2 edges if it's not empty
    n_neg_cuts = max(2, n_cuts - n_pos_cuts) if neg_range_size > 0 else 0   
    # In case n_pos_cuts + n_neg_cuts > n_cuts this is needed
    n_pos_cuts = max(2, n_cuts - n_neg_cuts) if pos_range_size > 0 else 0

    neg_cuts = []
    if n_neg_cuts > 0:
        neg_cuts = list(-np.geomspace(neg_range[0], neg_range[1], n_neg_cuts, dtype=dtype))

    pos_cuts = []
    if n_pos_cuts > 0:
        pos_cuts = list(np.geomspace(pos_range[0], pos_range[1], n_pos_cuts, dtype=dtype))

    result = neg_cuts + zero_cut + pos_cuts
    # Add 0.1% to the edges to include min and max
    result[0] = min(result[0] * 1.1, result[0] * 0.9)
    result[-1] = result[-1] * 1.1
    return result