plotext-plus 1.0.1__py3-none-any.whl

plotext_plus/_utility.py

@@ -0,0 +1,853 @@
+import sys, shutil, os, re, math, inspect
+from plotext_plus._dict import *
+
+###############################################
+#########    Number Manipulation     ##########
+###############################################
+
+def round(n, d = 0): # the standard round(0.5) = 0 instead of 1; this version rounds 0.5 to 1
+    n *= 10 ** d
+    f = math.floor(n)
+    r = f if n - f < 0.5 else math.ceil(n)
+    return r * 10 ** (-d)
+
+def mean(x, y, p = 1): # mean of x and y with optional power p; if p tends to 0 the minimum is returned; if p tends to infinity the max is returned; p = 1 is the standard mean
+    return ((x ** p + y ** p) / 2) ** (1 / p)
+
+def replace(data, data2, element = None): # replace element in data with correspondent in data2 when element is found
+    res = []
+    for i in range(len(data)):
+        el = data[i] if data[i] != element else data2[i]
+        res.append(el)
+    return res
+
+def try_float(data): # it turn a string into float if it can
+    try:
+        return float(data)
+    except:
+        return data
+
+def quantile(data, q): # calculate the quantile of a given array
+    data = sorted(data)
+    index = q * (len(data) - 1)
+    if index.is_integer():
+        return data[int(index)]
+    else:
+        return (data[int(index)] + data[int(index) + 1]) / 2
+
+###############################################
+###########    List Creation     ##############
+###############################################
+
+def linspace(lower, upper, length = 10): # it returns a lists of numbers from lower to upper with given length
+    slope = (upper - lower) / (length - 1) if length > 1 else 0
+    return [lower + x * slope for x in range(length)]
+
+def sin(periods = 2, length = 200, amplitude = 1, phase = 0, decay = 0): # sinusoidal data with given parameters
+    f = 2 * math.pi * periods / (length - 1)
+    phase =  math.pi * phase
+    d = decay / length
+    return [amplitude * math.sin(f * el + phase) * math.exp(- d * el) for el in range(length)]
+
+def square(periods = 2, length = 200, amplitude = 1):
+    T = length / periods
+    step = lambda t: amplitude if t % T <= T / 2 else - amplitude
+    return [step(i) for i in range(length)]
+
+def to_list(data, length): # eg: to_list(1, 3) = [1, 1 ,1]; to_list([1,2,3], 6) = [1, 2, 3, 1, 2, 3]
+    data = data if isinstance(data, list) else [data] * length
+    data = data * math.ceil(length / len(data)) if len(data) > 0 else []
+    return data[ : length]
+
+def difference(data1, data2) : # elements in data1 not in date2
+    return [el for el in data1 if el not in data2]
+
+###############################################
+#########    List Transformation     ##########
+###############################################
+
+def log(data): # it apply log function to the data
+    return [math.log10(el) for el in data] if isinstance(data, list) else math.log10(data)
+
+def power10(data): # it apply log function to the data
+    return [10 ** el for el in data]
+
+def floor(data): # it floors a list of data
+    return list(map(math.floor, data))
+
+def repeat(data, length): # repeat the same data till length is reached
+    l = len(data) if type(data) == list else 1
+    data = join([data] * math.ceil(length / l))
+    return data[ : length]
+
+###############################################
+##########    List Manipulation     ###########
+###############################################
+
+def no_duplicates(data): # removes duplicates from a list
+    return list(set(list(data)))
+    #return list(dict.fromkeys(data)) # it takes double time
+
+def join(data): # flatten lists at first level
+    #return [el for row in data for el in row]
+    return [el for row in data for el in (join(row) if type (row) == list else [row])]
+
+def cumsum(data): # it returns the cumulative sums of a list; eg: cumsum([0,1,2,3,4]) = [0,1,3,6,10]
+    s = [0]
+    for i in range(len(data)):
+        s.append(s[-1] + data[i])
+    return s[1:]
+
+###############################################
+#########    Matrix Manipulation     ##########
+###############################################
+
+def matrix_size(matrix):  # cols, height
+    return [len(matrix[0]), len(matrix)] if matrix != [] else [0, 0]
+
+def transpose(data, length = 1): # it needs no explanation
+    return [[]] * length if data == [] else list(map(list, zip(*data)))
+
+def vstack(matrix, extra): # vertical stack of two matrices
+    return extra + matrix # + extra
+
+def hstack(matrix, extra): # horizontal stack of two matrices
+    lm, le = len(matrix), len(extra)
+    l = max(lm, le)
+    return [matrix[i] + extra[i] for i in range(l)]
+
+def turn_gray(matrix): # it takes a standard matrix and turns it into an grayscale one
+    M, m = max(join(matrix), default = 0), min(join(matrix), default = 0)
+    to_gray = lambda el: tuple([int(255 * (el - m) / (M - m))] * 3) if M != m else (127, 127, 127)
+    return [[to_gray(el) for el in l] for l in matrix]
+
+def brush(*lists): # remove duplicates from lists x, y, z ...
+    l = min(map(len, lists))
+    lists = [el[:l] for el in lists]
+    z = list(zip(*lists))
+    z = no_duplicates(z)
+    #z = sorted(z)#, key = lambda x: x[0])
+    lists = transpose(z, len(lists))
+    return lists
+
+###############################################
+#########   String Manipulation     ###########
+###############################################
+
+nl = "\n"
+
+def only_spaces(string): # it returns True if string is made of only empty spaces or is None or ''
+    return (type(string) == str) and (string == len(string) * space) #and len(string) != 0
+
+def format_time(time): # it properly formats the computational time
+    t = time if time is not None else 0
+    unit = 's' if t >= 1 else 'ms' if t >= 10 ** -3 else 'µs'
+    p = 0 if unit == 's' else 3 if unit == 'ms' else 6
+    t = round(10 ** p * t, 1)
+    l = len(str(int(t)))
+    t = str(t)
+    #t = ' ' * (3 - l) + t
+    return t[ : l + 2] + ' ' + unit
+
+positive_color = 'green+'
+negative_color = 'red'
+title_color = 'cyan+'
+
+def format_strings(string1, string2, color = positive_color): # returns string1 in bold and with color + string2 with a pre-formatted style
+    return colorize(string1, color, "bold") + " " + colorize(string2, style = info_style)
+
+def correct_coord(string, label, coord): # In the attempt to insert a label in string at given coordinate, the coordinate is adjusted so not to hit the borders of the string
+    l = len(label)
+    b, e = max(coord - l + 1, 0), min(coord + l, len(string) - 1)
+    data = [i for i in range(b, e) if string[i] is space]
+    b, e = min(data, default = coord - l + 1), max(data, default = coord + l)
+    b, e = e - l + 1, b + l
+    return (b + e - l) // 2
+
+def no_char_duplicates(string, char): # it remove char duplicates from string
+    pattern = char + '{2,}'
+    string = re.sub(pattern, char, string)
+    return string
+
+def read_lines(text, delimiter = None, columns = None): # from a long text to well formatted data
+    delimiter = " " if delimiter is None else delimiter
+    data = []
+    columns = len(no_char_duplicates(text[0], delimiter).split(delimiter)) if columns is None else columns
+    for i in range(len(text)):
+        row = text[i]
+        row = no_char_duplicates(row, delimiter)
+        row = row.split(delimiter)
+        row = [el.replace('\n', '') for el in row]
+        cols = len(row)
+        row = [row[col].replace('\n', '') if col in range(cols) else '' for col in range(columns)]
+        row = [try_float(el) for el in row]
+        data.append(row)
+    return data
+
+def pad_string(num, length): # pad a number with spaces before to reach length
+    num = str(num)
+    l = len(num)
+    return num + ' ' * (length - l)
+
+def max_length(strings):
+    strings = map(str, strings)
+    return max(map(len, strings), default = 0)
+
+###############################################
+##########   File Manipulation     ############
+###############################################
+
+def correct_path(path):
+    folder, base = os.path.dirname(path), os.path.basename(path)
+    folder = os.path.expanduser("~") if folder in ['', '~'] else folder
+    path = os.path.join(folder, base)
+    return path
+
+def is_file(path, log = True): # returns True if path exists
+    res = os.path.isfile(path)
+    print(format_strings("not a file:", path, negative_color)) if not res and log else None
+    return res
+
+def script_folder(): # the folder of the script executed
+    return parent_folder(inspect.getfile(sys._getframe(1)))
+
+def parent_folder(path, level = 1): # it return the parent folder of the path or file given; if level is higher then 1 the process is iterated
+    if level <= 0:
+        return path
+    elif level == 1:
+        return os.path.abspath(os.path.join(path, os.pardir))
+    else:
+        return parent_folder(parent_folder(path, level - 1))
+
+def join_paths(*args): # it join a list of string in a proper file path; if the first argument is ~ it is turnded into the used home folder path
+    args = list(args)
+    args[0] = _correct_path(args[0]) if args[0] == "~" else args[0]
+    return os.path.abspath(os.path.join(*args))
+
+def delete_file(path, log = True): # remove the file if it exists
+    path = correct_path(path)
+    if is_file(path):
+        os.remove(path)
+        print(format_strings("file removed:", path, negative_color)) if log else None
+
+def read_data(path, delimiter = None, columns = None, first_row = None, log = True): # it turns a text file into data lists
+    path = correct_path(path)
+    first_row = 0 if first_row is None else int(first_row)
+    file = open(path, "r")
+    text = file.readlines()[first_row:]
+    file.close()
+    print(format_strings("data read from", path)) if log else None
+    return read_lines(text, delimiter, columns)
+
+def write_data(data, path, delimiter = None, columns = None, log = True): # it turns a matrix into a text file
+    delimiter = " " if delimiter is None else delimiter
+    cols = len(data[0])
+    cols = range(1, cols + 1) if columns is None else columns
+    text = ""
+    for row in data:
+        row = [row[i - 1] for i in cols]
+        row = list(map(str, row))
+        text += delimiter.join(row) + '\n'
+    save_text(text, path, log = log)
+
+def save_text(text, path, append = False, log = True): # it saves some text to the path selected
+    path = correct_path(path)
+    mode = "a" if append else "w+"
+    with open(path , mode, encoding='utf-8') as file:
+        file.write(text)
+    print(format_strings("text saved in", path)) if log else None
+
+def download(url, path, log = True): # it download the url (image, video, gif etc) to path
+    from urllib.request import urlretrieve
+    path = correct_path(path)
+    urlretrieve(url, path)
+    print(format_strings('url saved in', path)) if log else None
+
+###############################################
+#########    Platform Utilities    ############
+###############################################
+
+def is_ipython(): # true if running in ipython shenn
+    try:
+        __IPYTHON__
+        return True
+    except NameError:
+        return False
+
+def platform(): # the platform (unix or windows) you are using plotext in
+   platform = sys.platform
+   if platform in {'win32', 'cygwin'}:
+       return 'windows'
+   else:
+       return 'unix'
+
+platform = platform()
+
+# to enable ascii escape color sequences
+if platform == "windows":
+    import subprocess
+    subprocess.call('', shell = True)
+
+def terminal_size(): # it returns the terminal size as [width, height]
+    try:
+        size = shutil.get_terminal_size()
+        return list(size)
+    except OSError:
+        return [None, None]
+
+def terminal_width(): # returns terminal width, adjusted for banner borders when banners are enabled
+    width = terminal_size()[0]
+    if width is None:
+        return None
+    
+    # Check if banners are enabled by checking the global output instance
+    try:
+        from plotext_plus._output import get_output_instance
+        output_instance = get_output_instance()
+        if hasattr(output_instance, 'use_banners') and output_instance.use_banners:
+            # Rich Panel with borders and padding=(0, 1) uses:
+            # - 2 characters for left/right borders
+            # - 2 characters for padding (1 on each side)
+            # Total: 4 characters of horizontal space
+            return max(width - 4, 1)  # Ensure minimum width of 1
+    except:
+        pass  # If anything fails, fall back to original width
+    
+    return width
+
+tw = terminal_width
+
+terminal_height = lambda: terminal_size()[1]
+th = terminal_height
+
+def clear_terminal(lines = None): # it cleat the entire terminal, or the specified number of lines
+    if lines is None:
+        write('\033c')
+    else:
+        for r in range(lines):
+            write("\033[A") # moves the curson up
+            write("\033[2K") # clear the entire line
+
+def write(string): # the print function used by plotext - now uses chuk-term backend
+    from plotext_plus._output import write as output_write
+    output_write(string)
+
+class memorize: # it memorise the arguments of a function, when used as its decorator, to reduce computational time
+    def __init__(self, f):
+        self.f = f
+        self.memo = {}
+    def __call__(self, *args):
+        if not args in self.memo:
+            self.memo[args] = self.f(*args)
+        return self.memo[args]
+
+##############################################
+#########    Marker Utilities      ###########
+##############################################
+
+space = ' ' # the default null character that appears as background to all plots
+plot_marker = "hd" if platform == 'unix' else 'dot'
+
+hd_markers = {hd_codes[el] : el for el in hd_codes}
+fhd_markers = {fhd_codes[el] : el for el in fhd_codes}
+braille_markers = {braille_codes[el] : el for el in braille_codes}
+simple_bar_marker = '▇'
+
+@memorize
+def get_hd_marker(code):
+   return hd_codes[code] if len(code) == 4 else fhd_codes[code] if len(code) == 6 else braille_codes[code]
+
+def marker_factor(marker, hd, fhd, braille): # useful to improve the resolution of the canvas for higher resolution markers
+   return hd if marker == 'hd' else fhd if marker == 'fhd' else braille if marker == 'braille' else 1
+
+##############################################
+###########    Color Utilities    ############
+##############################################
+
+# A user could specify three types of colors
+  # an integer for 256 color codes
+  # a tuple    for RGB color codes
+  # a string   for 16 color codes or styles
+
+# Along side the user needs to specify whatever it is for background / fullground / style
+# which plotext calls 'character' = 0 / 1 / 2
+
+
+#colors_no_plus = [el for el in colors if '+' not in el and el + '+' not in colors and el is not no_color] # basically just [black, white]
+
+def get_color_code(color): # the color number code from color string
+    color = color.strip()
+    return color_codes[color]
+
+def get_color_name(code): # the color string from color number code
+    codes = list(color_codes.values())
+    return colors[codes.index(code)] if code in codes else no_color
+
+def is_string_color(color):
+    return isinstance(color, str) and color.strip() in colors
+
+def is_integer_color(color):
+    return isinstance(color, int) and 0 <= color <= 255
+
+def is_rgb_color(color):
+    is_rgb = isinstance(color, list) or isinstance(color, tuple)
+    is_rgb = is_rgb and len(color) == 3
+    is_rgb = is_rgb and all([is_integer_color(el) for el in color])
+    return is_rgb
+
+def is_color(color):
+    return is_string_color(color) or is_integer_color(color) or is_rgb_color(color)
+
+def colorize(string, color = None, style = None, background = None, show = False): # it paints a text with given fullground and background color
+    string = apply_ansi(string, background, 0)
+    string = apply_ansi(string, color, 1)
+    string = apply_ansi(string, style, 2)
+    if show:
+        print(string)
+    return string
+
+def uncolorize(string): # remove color codes from colored string
+    colored = lambda: ansi_begin in string
+    while colored():
+        b = string.index(ansi_begin)
+        e = string[b : ].index('m') + b + 1
+        string = string.replace(string[b : e], '')
+    return string
+
+def apply_ansi(string, color, character):
+    begin, end = ansi(color, character)
+    return begin + string + end
+
+#ansi_begin = '\033['
+ansi_begin = '\x1b['
+ansi_end = ansi_begin + '0m'
+
+@memorize
+def colors_to_ansi(fullground, style, background):
+    color = [background, fullground, style]
+    return ''.join([ansi(color[i], i)[0] for i in range(3)])
+
+@memorize
+def ansi(color, character):
+    if color == no_color:
+        return ['', '']
+    col, fg, tp = '', '', ''
+    if character == 2 and is_style(color):
+        col = get_style_codes(color)
+        col = ';'.join([str(el) for el in col])
+    elif character != 2:
+        fg = '38;' if character == 1 else '48;'
+        tp = '5;'
+        if is_string_color(color):
+            col = str(get_color_code(color))
+        elif is_integer_color(color):
+            col = str(color)
+        elif is_rgb_color(color):
+            col = ';'.join([str(el) for el in color])
+            tp = '2;'
+    is_color = col != ''
+    begin = ansi_begin + fg + tp + col + 'm' if is_color else ''
+    end = ansi_end if is_color else ''
+    return [begin, end]
+
+## This section is useful to produce html colored version of the plot and to translate all color types (types 0 and 1) in rgb (type 2 in plotext) and avoid confusion. the match is almost exact and it depends on the terminal i suppose
+
+def to_rgb(color):
+    if is_string_color(color): # from 0 to 1
+        color = get_color_code(color)
+        #color = type0_to_type1_codes[code]
+    if is_integer_color(color): # from 0 or 1 to 2
+        return type1_to_type2_codes[color]
+    return color
+
+##############################################
+############     Style Codes    ##############
+##############################################
+
+no_style = 'default'
+
+styles = list(style_codes.keys()) + [no_style]
+
+info_style = 'dim'
+
+def get_style_code(style): # from single style to style number code
+    style = style.strip()
+    return style_codes[style]
+
+def get_style_codes(style): # from many styles (separated by space) to as many number codes
+    style = style.strip().split()
+    codes = [get_style_code(el) for el in style if el in styles]
+    codes = no_duplicates(codes)
+    return codes
+
+def get_style_name(code): # from style number code to style name
+    codes = list(style_codes.values())
+    return styles[codes.index(code)] if code in codes else no_style
+
+def clean_styles(style): # it returns a well written sequence of styles (separated by spaces) from a possible confused one
+    codes = get_style_codes(style)
+    return ' '.join([get_style_name(el) for el in codes])
+
+def is_style(style):
+    style = style.strip().split() if isinstance(style, str) else ['']
+    return any([el in styles for el in style])
+
+##############################################
+###########     Plot Utilities    ############
+##############################################
+
+def set_data(x = None, y = None): # it return properly formatted x and y data lists
+   if x is None and y is None :
+       x, y = [], []
+   elif x is not None and y is None:
+       y = x
+       x = list(range(1, len(y) + 1))
+   lx, ly = len(x), len(y)
+   if lx != ly:
+       l = min(lx, ly)
+       x = x[ : l]
+       y = y[ : l]
+   return [list(x), list(y)]
+
+##############################################
+#######     Figure Class Utilities    ########
+##############################################
+
+def set_sizes(sizes, size_max): # given certain widths (or heights) - some of them are None -  it sets them so to respect max value
+    bins = len(sizes)
+    for s in range(bins):
+        size_set = sum([el for el in sizes[0 : s] + sizes[s + 1 : ] if el is not None])
+        available = max(size_max - size_set, 0)
+        to_set = len([el for el in sizes[s : ] if el is None])
+        sizes[s] = available // to_set if sizes[s] is None else sizes[s]
+    return sizes
+
+def fit_sizes(sizes, size_max): # honestly forgot the point of this function: yeeeeei :-) but it is useful - probably assumes all sizes not None (due to set_sizes) and reduces those that exceed size_max from last one to first
+    bins = len(sizes)
+    s = bins - 1
+    #while (sum(sizes) != size_max if not_less else sum(sizes) > size_max) and s >= 0:
+    while sum(sizes) > size_max and s >= 0:
+        other_sizes = sum([sizes[i] for i in range(bins) if i != s])
+        sizes[s] = max(size_max - other_sizes, 0)
+        s -= 1
+    return sizes
+
+##############################################
+#######     Build Class Utilities    #########
+##############################################
+
+def get_first(data, test = True): # if test take the first element, otherwise the second
+    return data[0] if test else data[1]
+
+def apply_scale(data, test = False): # apply log scale if test
+    return log(data) if test else data
+
+def reverse_scale(data, test = False): # apply log scale if test
+    return power10(data) if test else data
+
+def replace_none(data, num_data): # replace None elements in data with correspondent in num_data
+    return [data[i] if data[i] is not None else num_data[i] for i in range(len(data))]
+
+numerical = lambda el:  not (el is None or math.isnan(el)) or isinstance(el, str) # in the case of string datetimes
+all_numerical = lambda data: all([numerical(el) for el in data])
+
+def get_lim(data): # it returns the data minimum and maximum limits
+    data = [el for el in data if numerical(el)]
+    m = min(data, default = 0)
+    M = max(data, default = 0)
+    m, M = (m, M) if m != M else (0.5 * m, 1.5 * m) if m == M != 0 else (-1, 1)
+    return [m, M]
+
+def get_matrix_data(data, lim, bins): # from data to relative canvas coordinates
+    change = lambda el: 0.5 + (bins - 1) * (el - lim[0]) / (lim[1] - lim[0])
+    # round is so that for example 9.9999 = 10, otherwise the floor function will give different results
+    return [math.floor(round(change(el), 8)) if numerical(el) else el for el in data]
+
+def get_lines(x, y, *other): # it returns the lines between all couples of data points like x[i], y[i] to x[i + 1], y[i + 1]; other are the lisXt of markers and colors that needs to be elongated
+    # if len(x) * len(y) == 0:
+    #     return [], [], *[[]] * len(other)
+    o = transpose(other, len(other))
+    xl, yl, ol = [[] for i in range(3)]
+    for n in range(len(x) - 1):
+        xn, yn = x[n : n + 2], y[n : n + 2]
+        xn, yn = get_line(xn, yn)
+        xl += xn[:-1]
+        yl += yn[:-1]
+        ol += [o[n]] * len(xn[:-1])
+    xl = xl + [x[-1]] if x != [] else xl
+    yl = yl + [y[-1]] if x != [] else yl
+    ol = ol + [o[-1]] if x != [] else ol
+    return [xl, yl] + transpose(ol, len(other))
+
+def get_line(x, y): # it returns a line of points from x[0],y[0] to x[1],y[1] distanced between each other in x and y by at least 1.
+    if not all_numerical(join([x, y])):
+        return x, y
+    x0, x1 = x
+    y0, y1 = y
+    dx, dy = int(x1) - int(x0), int(y1) - int(y0)
+    ax, ay = abs(dx), abs(dy)
+    a = int(max(ax, ay) + 1)
+    x = [int(el) for el in linspace(x0, x1, a)]
+    y = [int(el) for el in linspace(y0, y1, a)]
+    return [x, y]
+
+def get_fill_level(fill, lim, bins):
+    if fill is False:
+        return False
+    elif isinstance(fill, str):
+        return fill
+    else:
+        fill = min(max(fill, lim[0]), lim[1])
+        fill = get_matrix_data([fill], lim, bins)[0]
+        return fill
+
+def find_filling_values(x, y, y0):
+    xn, yn, yf = [[]] * 3
+    l = len(x);
+    while len(x) > 0:
+        i = len(xn)
+        xn.append(x[i])
+        yn.append(y[i])
+        J = [j for j in range(l) if x[j] == x[i]]
+        if J != []:
+            Y = [y[j] for j in J]
+            j = Y.index(min(Y))
+            J.pop(j)
+            [x.pop(j) for j in J]
+            [y.pop(j) for j in J]
+            yf.append(y[j])
+    return xn, yn, yf
+
+def get_fill_boundaries(x, y):
+    xm = []
+    l = len(x)
+    for i in range(l):
+        xi, yi = x[i], y[i]
+        I = [j for j in range(l) if x[j] == xi and y[j] < yi]
+        Y = [y[j] for j in I]
+        m = min(Y, default = yi)
+        xm.append([x[i], m])
+    x, m = transpose(xm)
+    return m
+
+def fill_data(x, y, y0, *other): # it fills x, y with y data points reaching y0; and c are the list of markers and colors that needs to be elongated
+    #y0 = get_fill_boundaries(x, y)
+    y0 = get_fill_boundaries(x, y) if isinstance(y0, str) else [y0] * len(x)
+    o = transpose(other, len(other))
+    xf, yf, of = [[] for i in range(3)]
+    xy = []
+    for i in range(len(x)):
+        xi, yi, y0i = x[i], y[i], y0[i]
+        if [xi, yi] not in xy:
+            xy.append([xi, yi])
+            yn = range(y0i, yi + 1) if y0i < yi else range(yi, y0i) if y0i > yi else [y0i]
+            yn = list(yn)
+            xn = [xi] * len(yn)
+            xf += xn
+            yf += yn
+            of += [o[i]] * len(xn)
+    return [xf, yf] + transpose(of, len(other))
+
+def remove_outsiders(x, y, width, height, *other):
+    I = [i for i in range(len(x)) if x[i] in range(width) and y[i] in range(height)]
+    o = transpose(other, len(other))
+    return transpose([(x[i], y[i], *o[i]) for i in I], 2 + len(other))
+
+def get_labels(ticks): # it returns the approximated string version of the data ticks
+    d = distinguishing_digit(ticks)
+    formatting_string = "{:." + str(d + 1) + "f}"
+    labels = [formatting_string.format(el) for el in ticks]
+    pos = [el.index('.') + d + 2 for el in labels]
+    labels = [labels[i][: pos[i]] for i in range(len(labels))]
+    all_integers = all(map(lambda el: el == int(el), ticks))
+    labels = [add_extra_zeros(el, d) if len(labels) > 1 else el for el in labels] if not all_integers else [str(int(el)) for el in ticks]
+    #sign = any([el < 0 for el in ticks])
+    #labels = ['+' + labels[i] if ticks[i] > 0 and sign else labels[i] for i in range(len(labels))]
+    return labels
+
+def distinguishing_digit(data): # it return the minimum amount of decimal digits necessary to distinguish all elements of a list
+    #data = [el for el in data if 'e' not in str(el)]
+    d = [_distinguishing_digit(data[i], data[i + 1]) for i in range(len(data) - 1)]
+    return max(d, default = 1)
+
+def _distinguishing_digit(a, b): # it return the minimum amount of decimal digits necessary to distinguish a from b (when both are rounded to those digits).
+    d = abs(a - b)
+    d = 0 if d == 0 else - math.log10(2 * d)
+    #d = round(d, 10)
+    d = 0 if d < 0 else math.ceil(d)
+    d = d + 1 if round(a, d) == round(b, d) else d
+    return d
+
+def add_extra_zeros(label, d): # it adds 0s at the end of a label if necessary
+    zeros = len(label) - 1 - label.index('.' if 'e' not in label else 'e')
+    if zeros < d:
+        label += '0' * (d - zeros)
+    return label
+
+def add_extra_spaces(labels, side): # it adds empty spaces before or after the labels if necessary
+    length = 0 if labels == [] else max_length(labels)
+    if side == "left":
+        labels = [space * (length - len(el)) + el for el in labels]
+    if side == "right":
+        labels = [el + space * (length - len(el)) for el in labels]
+    return labels
+
+def hd_group(x, y, xf, yf): # it returns the real coordinates of the HD markers and the matrix that defines the marker
+    l, xfm, yfm = len(x), max(xf), max(yf)
+    xm = [el // xfm if numerical(el) else el for el in x]
+    ym = [el // yfm if numerical(el) else el for el in y]
+    m = {}
+    for i in range(l):
+        xyi = xm[i], ym[i]
+        xfi, yfi = xf[i], yf[i]
+        mi = [[0 for x in range(xfi)] for y in range(yfi)]
+        m[xyi] = mi
+    for i in range(l):
+        xyi = xm[i], ym[i]
+        if all_numerical(xyi):
+            xk, yk = x[i] % xfi, y[i] % yfi
+            xk, yk = math.floor(xk), math.floor(yk)
+            m[xyi][yk][xk] = 1
+    x, y = transpose(m.keys(), 2)
+    m = [tuple(join(el[::-1])) for el in m.values()]
+    return x, y, m
+
+###############################################
+#############   Bar Functions    ##############
+###############################################
+
+def bars(x, y, width, minimum): # given the bars center coordinates and height, it returns the full bar coordinates
+   # if x == []:
+   #     return [], []
+   bins = len(x)
+   #bin_size_half = (max(x) - min(x)) / (bins - 1) * width / 2
+   bin_size_half = width / 2
+   # adjust the bar width according to the number of bins
+   if bins > 1:
+       bin_size_half *= (max(x) - min(x)) / (bins - 1)
+   xbar, ybar = [], []
+   for i in range(bins):
+       xbar.append([x[i] - bin_size_half, x[i] + bin_size_half])
+       ybar.append([minimum, y[i]])
+   return xbar, ybar
+
+def set_multiple_bar_data(*args):
+    l = len(args)
+    Y = [] if l == 0 else args[0] if l == 1 else args[1]
+    Y = [Y] if not isinstance(Y, list) or len(Y) == 0 else Y
+    m = len(Y[0])
+    x = [] if l == 0 else list(range(1, m + 1)) if l == 1 else args[0]
+    return x, Y
+
+def hist_data(data, bins = 10, norm = False): # it returns data in histogram form if norm is False. Otherwise, it returns data in density form where all bins sum to 1.
+    #data = [round(el, 15) for el in data]
+    # if data == []:
+    #     return [], []
+    bins = 0 if len(data) == 0 else bins
+    m, M = min(data, default = 0), max(data, default = 0)
+    data = [(el - m) / (M - m) * bins if el != M else bins - 1 for el in data]
+    data = [int(el) for el in data]
+    histx = linspace(m, M, bins)
+    histy = [0] * bins
+    for el in data:
+        histy[el] += 1
+    if norm:
+        histy = [el / len(data) for el in histy]
+    return histx, histy
+
+def single_bar(x, y, ylabel, marker, colors):
+    l = len(y)
+    lc = len(colors)
+    xs = colorize(str(x), 'gray+', 'bold')
+    bar = [marker * el for el in y]
+    bar = [apply_ansi(bar[i], colors[i % lc], 1) for i in range(l)]
+    ylabel = colorize(f'{ylabel:.2f}', 'gray+', 'bold')
+    bar = xs + space + ''.join(bar) + space + ylabel
+    return bar
+
+def bar_data(*args, width = None, mode = 'stacked'):
+    x, Y = set_multiple_bar_data(*args)
+    x = list(map(str, x))
+    x = add_extra_spaces(x, 'right')
+    lx = len(x[0])
+    y = [sum(el) for el in transpose(Y)] if mode == 'stacked' else Y
+    ly = max_length([round(el, 2) for el in join(y)])
+
+    width_term = terminal_width()
+    width = width_term if width is None else min(width, width_term)
+    width = max(width, lx + ly + 2 + 1)
+
+    my = max(join(y))
+    my = 1 if my == 0 else my
+    dx = my / (width - lx - ly - 2)
+    Yi = [[round(el / dx, 0) for el in y] for y in Y]
+    Yi = transpose(Yi)
+
+    return x, y, Yi, width
+
+def correct_marker(marker = None):
+    return simple_bar_marker if marker is None else marker[0]
+
+def get_title(title, width):
+    out = ''
+    if title is not None:
+        l = len(uncolorize(title))
+        w1 = (width - 2 - l) // 2; w2 = width - l - 2 - w1
+        l1 = '─' * w1 + space
+        l2 = space + '─' * w2
+        out = colorize(l1 + title + l2, 'gray+', 'bold') + '\n'
+    return out
+
+def get_simple_labels(marker, labels, colors, width):
+    out = '\n'
+    if labels != None:
+        l = len(labels)
+        lc = len(colors)
+        out =  space.join([colorize(marker * 3, colors[i % lc]) + space + colorize(labels[i], 'gray+', 'bold') for i in range(l)])
+        out = '\n' + get_title(out, width)
+    return out
+
+###############################################
+#############   Box Functions    ##############
+###############################################
+
+def box(x, y, width, minimum): # given the bars center coordinates and height, it returns the full bar coordinates
+    # if x == []:
+    #     return [], []
+    bins = len(x)
+    #bin_size_half = (max(x) - min(x)) / (bins - 1) * width / 2
+    bin_size_half = width / 2
+    # adjust the bar width according to the number of bins
+    if bins > 1:
+        bin_size_half *= (max(x) - min(x)) / (bins - 1)
+    c, q1, q2, q3, h, l = [], [], [], [], [], []
+    xbar, ybar, mybar = [], [], []
+
+    for i in range(bins):
+        c.append(x[i])
+        xbar.append([x[i] - bin_size_half, x[i] + bin_size_half])
+        q1.append(quantile(y[i], 0.25))
+        q2.append(quantile(y[i], 0.50))
+        q3.append(quantile(y[i], 0.75))
+        h.append(max(y[i]))
+        l.append(min(y[i]))
+
+    return q1, q2, q3, h, l, c, xbar
+
+##############################################
+##########    Image Utilities    #############
+##############################################
+
+def update_size(size_old, size_new): # it resize an image to the desired size, maintaining or not its size ratio and adding or not a pixel averaging factor with resample = True
+    size_old = [size_old[0], size_old[1] / 2]
+    ratio_old = size_old[1] / size_old[0]
+    size_new = replace(size_new, size_old)
+    ratio_new = size_new[1] / size_new[0]
+    #ratio_new = size_new[1] / size_new[0]
+    size_new = [1 if el == 0 else el for el in size_new]
+    return [int(size_new[0]), int(size_new[1])]
+
+def image_to_matrix(image): # from image to a matrix of pixels
+    pixels = list(image.getdata())
+    width, height = image.size
+    return [pixels[i * width:(i + 1) * width] for i in range(height)]