docs: def constant_pad(X, multiple_of, up_down_rule='even', left_right_rule='even', pad_value=0):
      """Function pads an image of shape (rows, columns, channels) with zeros.
  
      It pads an image so that the shape becomes (rows + padded_rows, columns + padded_columns, channels), where
      padded_rows = (int(rows/multiple_of[0]) + 1) * multiple_of[0] - rows
  
      Same rule is applied to columns.
  
      :type X: array of shape (rows, columns, channels) or (rows, columns)
      :param multiple_of: make X' rows and columns multiple of this tuple
      :type multiple_of: tuple (rows, columns)
      :param up_down_rule: Add padded rows evenly to the top/bottom of the image, or up (top) / down (bottom) only
      :type up_down_rule: up_down_rule: string, (even, up, down)
      :param up_down_rule: Add padded columns evenly to the left/right of the image, or left / right only
      :type up_down_rule: up_down_rule: string, (even, left, right)
      :param pad_value: Value to be assigned to padded rows and columns
      :type pad_value: int
      """
      # pylint: disable=invalid-name
      shape = X.shape
  
      row_padding, col_padding = 0, 0
  
      if shape[0] % multiple_of[0]:
          row_padding = (int(shape[0] / multiple_of[0]) + 1) * multiple_of[0] - shape[0]
  
      if shape[1] % multiple_of[1]:
          col_padding = (int(shape[1] / multiple_of[1]) + 1) * multiple_of[1] - shape[1]
  
      row_padding_up, row_padding_down, col_padding_left, col_padding_right = 0, 0, 0, 0
  
      if row_padding > 0:
          if up_down_rule == 'up':
              row_padding_up = row_padding
          elif up_down_rule == 'down':
              row_padding_down = row_padding
          elif up_down_rule == 'even':
              row_padding_up = int(row_padding / 2)
              row_padding_down = row_padding_up + (row_padding % 2)
          else:
              raise ValueError('Padding rule for rows not supported. Choose beteen even, down or up!')
  
      if col_padding > 0:
          if left_right_rule == 'left':
              col_padding_left = col_padding
          elif left_right_rule == 'right':
              col_padding_right = col_padding
          elif left_right_rule == 'even':
              col_padding_left = int(col_padding / 2)
              col_padding_right = col_padding_left + (col_padding % 2)
          else:
              raise ValueError('Padding rule for columns not supported. Choose beteen even, left or right!')
  
      return np.lib.pad(X, ((row_padding_up, row_padding_down), (col_padding_left, col_padding_right)),
                        'constant', constant_values=((pad_value, pad_value), (pad_value, pad_value)))