code: 
  
  
  
  
  
  from __future__ import annotations
  
  
  
  
  def 						A_			(  lowercase_      ,		lowercase_  )			->						list:
         _snake_case      :							Dict     				=						[None] * (len(a_  ) + len(a_  ))
  
         _snake_case      :							Optional[Any]     				=						0  # pointer to current index for left Half
         _snake_case      :							Optional[Any]     				=						0  # pointer to current index for the right Half
         _snake_case      :							Union[str, Any]     				=						0  # pointer to current index for the sorted array Half
  
         while pointera < len(a_  ) and pointera < len(a_  ):
                if left_half[pointera] < right_half[pointera]:
                       _snake_case      :							List[Any]     				=						left_half[pointera]
                       pointera += 1
                       index += 1
                else:
                       _snake_case      :							str     				=						right_half[pointera]
                       pointera += 1
                       index += 1
         while pointera < len(a_  ):
                _snake_case      :							List[str]     				=						left_half[pointera]
                pointera += 1
                index += 1
  
         while pointera < len(a_  ):
                _snake_case      :							Dict     				=						right_half[pointera]
                pointera += 1
                index += 1
  
         return sorted_array
  
  
  
  
  def 						A_			(  lowercase_  )			->						list:
         if len(a_  ) <= 1:
                return array
         # the actual formula to calculate the middle element = left + (right - left) // 2
         # this avoids integer overflow in case of large N
         _snake_case      :							List[Any]     				=						0 + (len(a_  ) - 0) // 2
  
         # Split the array into halves till the array length becomes equal to One
         # merge the arrays of single length returned by mergeSort function and
         # pass them into the merge arrays function which merges the array
         _snake_case      :							Optional[int]     				=						array[:middle]
         _snake_case      :							List[str]     				=						array[middle:]
  
         return merge(merge_sort(a_  )      ,		merge_sort(a_  )  )
  
  
  if __name__ == "__main__":
     import doctest
  
     doctest.testmod()
  
  
  
  
  
  
  
style_context: 
  
  
  
  
  
  import numpy as np
  
  
  
  
  def 						A_			(  lowercase_  )			->						Optional[Any]:
         _snake_case      :							Union[str, Any]     				=						np.exp(lowercase_  )
  
         # Add up the all the exponentials
         _snake_case      :							List[str]     				=						np.sum(lowercase_  )
  
         # Divide every exponent by the sum of all exponents
         _snake_case      :							Optional[int]     				=						exponent_vector / sum_of_exponents
  
         return softmax_vector
  
  
  if __name__ == "__main__":
     print(softmax((0,)))
  
  
  
  
  
  
  