




"""simple docstring"""




from __future__ import annotations
def     A_	(						snake_case_   :				Optional[int]  ,snake_case_   :				Optional[Any]  ,snake_case_   :				Tuple  ,):







    '''simple docstring'''
    if not all((nth_term, start_term_a, common_ratio_r)			):
        return []
    UpperCamelCase :      Union[str, Any]      				=							[]
    UpperCamelCase :      Any      				=							1
    UpperCamelCase :      Optional[int]      				=							common_ratio_r
    for _ in range(int(snake_case_			)			):
        if not series:
            series.append(snake_case_			)
        else:
            power += 1
            series.append(float(start_term_a * multiple			)			)
            UpperCamelCase :      List[str]      				=							pow(float(snake_case_			)  ,snake_case_			)
    return series


if __name__ == "__main__":
  import doctest

  doctest.testmod()

  __A       :						List[str]												=			float(input('''Enter the last number (n term) of the Geometric Series'''))
  __A       :						Dict												=			float(input('''Enter the starting term (a) of the Geometric Series'''))
  __A       :						Dict												=			float(
      input('''Enter the common ratio between two terms (r) of the Geometric Series''')
  )
  print('''Formula of Geometric Series => a + ar + ar^2 ... +ar^n''')
  print(geometric_series(nth_term, start_term_a, common_ratio_r))












"""simple docstring"""







import unittest
from timeit import timeit






def 					_lowerCAmelCase				(					lowerCAmelCase		,					lowerCAmelCase						):







       '''simple docstring'''
       UpperCAmelCase					=	first_num if first_num >= second_num else second_num
       UpperCAmelCase					=	max_num
       while (common_mult % first_num > 0) or (common_mult % second_num > 0):
              common_mult += max_num
       return common_mult






def 					_lowerCAmelCase				(					lowerCAmelCase		,					lowerCAmelCase						):







       '''simple docstring'''
       return b if a == 0 else greatest_common_divisor(b % a		,					lowerCAmelCase						)






def 					_lowerCAmelCase				(					lowerCAmelCase		,					lowerCAmelCase						):







       '''simple docstring'''
       return first_num // greatest_common_divisor(lowerCAmelCase		,					lowerCAmelCase						) * second_num






def 					_lowerCAmelCase				(					):







       '''simple docstring'''
       UpperCAmelCase					=	(
           """from __main__ import least_common_multiple_slow, least_common_multiple_fast"""
       )
       print(
           """least_common_multiple_slow():"""		,					timeit("""least_common_multiple_slow(1000, 999)"""		,					setup=lowerCAmelCase						)		,					)
       print(
           """least_common_multiple_fast():"""		,					timeit("""least_common_multiple_fast(1000, 999)"""		,					setup=lowerCAmelCase						)		,					)





class      UpperCamelCase_       (				unittest.TestCase     ):
  _A				:    List[str] =		(
      (10, 20),
      (13, 15),
      (4, 31),
      (10, 42),
      (43, 34),
      (5, 12),
      (12, 25),
      (10, 25),
      (6, 9),
  )
  _A				:    int =		(20, 195, 124, 210, 1462, 60, 300, 50, 18)



  def 						UpperCamelCase_ (					self )	->	Any:



         """simple docstring"""





         for i, (first_num, second_num) in enumerate(self.test_inputs ):
                UpperCAmelCase					=	least_common_multiple_slow(snake_case__       ,						snake_case__ )
                UpperCAmelCase					=	least_common_multiple_fast(snake_case__       ,						snake_case__ )
                with self.subTest(i=snake_case__ ):
                       self.assertEqual(snake_case__       ,						self.expected_results[i] )
                       self.assertEqual(snake_case__       ,						self.expected_results[i] )


if __name__ == "__main__":
 benchmark()
 unittest.main()
