

lowerCAmelCase						:   Optional[Any]										=    1000





def 			_lowercase    (      __UpperCamelCase     :		float ):
      return x * x





def 			_lowercase    (      __UpperCamelCase     :		int   ,       __UpperCamelCase     :		float   ,       __UpperCamelCase     :		float   ,       __UpperCamelCase     :		int = 4 ):
      assert callable(
          __UpperCamelCase ), F'''the function(object) passed should be callable your input : {function}'''
      assert isinstance(__UpperCamelCase   ,       (float, int) ), F'''a should be float or integer your input : {a}'''
      assert isinstance(function(__UpperCamelCase )   ,       (float, int) ), (
          "the function should return integer or float return type of your function, "
          F'''{type(__UpperCamelCase )}'''
      )
      assert isinstance(__UpperCamelCase   ,       (float, int) ), F'''b should be float or integer your input : {b}'''
      assert (
          isinstance(__UpperCamelCase   ,       __UpperCamelCase ) and precision > 0
      ), F'''precision should be positive integer your input : {precision}'''

      # just applying the formula of simpson for approximate integration written in
      # mentioned article in first comment of this file and above this function

      snake_case__					=   (b - a) / N_STEPS
      snake_case__					=   function(__UpperCamelCase ) + function(__UpperCamelCase )

      for i in range(1   ,       __UpperCamelCase ):
            snake_case__					=   a + h * i
            result += function(__UpperCamelCase ) * (4 if i % 2 else 2)

      result *= h / 3
      return round(__UpperCamelCase   ,       __UpperCamelCase )


if __name__ == "__main__":
       import doctest

       doctest.testmod()









from doctest import testmod
from math import sqrt





def 			_lowercase    (      __UpperCamelCase     :		int ):
      snake_case__					=   []
      if num < 1:
            return facs
      facs.append(1 )
      if num == 1:
            return facs
      facs.append(__UpperCamelCase )
      for i in range(2   ,       int(sqrt(__UpperCamelCase ) ) + 1 ):
            if num % i == 0:  # If i is a factor of num
                  facs.append(__UpperCamelCase )
                  snake_case__					=   num // i  # num//i is the other factor of num
                  if d != i:  # If d and i are distinct
                        facs.append(__UpperCamelCase )  # we have found another factor
      facs.sort()
      return facs


if __name__ == "__main__":
       testmod(name='''factors_of_a_number''', verbose=True)






