'''simple docstring'''





def 	lowerCAmelCase_				(					snake_case_       : float					,    snake_case_       : float					,    snake_case_       : int			)    ->      float:


     '''simple docstring'''




     if principal <= 0:
          raise Exception("Principal borrowed must be > 0"			)
     if rate_per_annum < 0:
          raise Exception("Rate of interest must be >= 0"			)
     if years_to_repay <= 0 or not isinstance(snake_case_					,    snake_case_			):
          raise Exception("Years to repay must be an integer > 0"			)

     # Yearly rate is divided by 12 to get monthly rate
     UpperCAmelCase_           =   rate_per_annum / 12

     # Years to repay is multiplied by 12 to get number of payments as payment is monthly
     UpperCAmelCase_           =   years_to_repay * 12

     return (
         principal
         * rate_per_month
         * (1 + rate_per_month) ** number_of_payments
         / ((1 + rate_per_month) ** number_of_payments - 1)
     )


if __name__ == "__main__":
    import doctest

    doctest.testmod()











"""simple docstring"""





from collections.abc import Iterator, MutableMapping
from dataclasses import dataclass
from typing import Generic, TypeVar

__A											=		TypeVar("""KEY""")
__A											=		TypeVar("""VAL""")






@dataclass(frozen=a  ,   slots=a       )
class 					_lowerCAmelCase   (     Generic[KEY, VAL]       ):
       """simple docstring"""




       __magic_name__     :KEY
       __magic_name__     :VAL






class 					_lowerCAmelCase   (     _Item       ):
       """simple docstring"""




       def __init__(    self      ):



         '''simple docstring'''

         super().__init__(__UpperCAmelCase    , __UpperCAmelCase      )






       def __bool__(    self      ):



         '''simple docstring'''

         return False






__A											=		_DeletedItem()






class 					_lowerCAmelCase   (     MutableMapping[KEY, VAL]       ):
       """simple docstring"""




       def __init__(    self    , __UpperCAmelCase = 8    , __UpperCAmelCase = 0.75      ):



         '''simple docstring'''

         lowerCAmelCase__			:List[str]											=							initial_block_size
         lowerCAmelCase__			:list[_Item | None]											=							[None] * initial_block_size
         assert 0.0 < capacity_factor < 1.0
         lowerCAmelCase__			:Tuple											=							capacity_factor
         lowerCAmelCase__			:str											=							0






       def      snake_case						(    self    , __UpperCAmelCase      ):



         '''simple docstring'''

         return hash(__UpperCAmelCase      ) % len(self._buckets      )






       def      snake_case						(    self    , __UpperCAmelCase      ):



         '''simple docstring'''

         return (ind + 1) % len(self._buckets      )






       def      snake_case						(    self    , __UpperCAmelCase    , __UpperCAmelCase    , __UpperCAmelCase      ):



         '''simple docstring'''

         lowerCAmelCase__			:Any											=							self._buckets[ind]
         if not stored:
           lowerCAmelCase__			:Dict											=							_Item(__UpperCAmelCase    , __UpperCAmelCase      )
           self._len += 1
           return True
         elif stored.key == key:
           lowerCAmelCase__			:Optional[Any]											=							_Item(__UpperCAmelCase    , __UpperCAmelCase      )
           return True
         else:
           return False






       def      snake_case						(    self      ):



         '''simple docstring'''

         lowerCAmelCase__			:int											=							len(self._buckets      ) * self._capacity_factor
         return len(self      ) >= int(__UpperCAmelCase      )






       def      snake_case						(    self      ):



         '''simple docstring'''

         if len(self._buckets      ) <= self._initial_block_size:
           return False
         lowerCAmelCase__			:Optional[Any]											=							len(self._buckets      ) * self._capacity_factor / 2
         return len(self      ) < limit






       def      snake_case						(    self    , __UpperCAmelCase      ):



         '''simple docstring'''

         lowerCAmelCase__			:Optional[int]											=							self._buckets
         lowerCAmelCase__			:Tuple											=							[None] * new_size
         lowerCAmelCase__			:List[Any]											=							0
         for item in old_buckets:
           if item:
             self._add_item(item.key    , item.val      )






       def      snake_case						(    self      ):



         '''simple docstring'''

         self._resize(len(self._buckets      ) * 2      )






       def      snake_case						(    self      ):



         '''simple docstring'''

         self._resize(len(self._buckets      ) // 2      )






       def      snake_case						(    self    , __UpperCAmelCase      ):



         '''simple docstring'''

         lowerCAmelCase__			:Optional[Any]											=							self._get_bucket_index(__UpperCAmelCase      )
         for _ in range(len(self._buckets      )      ):
           yield ind
           lowerCAmelCase__			:Tuple											=							self._get_next_ind(__UpperCAmelCase      )






       def      snake_case						(    self    , __UpperCAmelCase    , __UpperCAmelCase      ):



         '''simple docstring'''

         for ind in self._iterate_buckets(__UpperCAmelCase      ):
           if self._try_set(__UpperCAmelCase    , __UpperCAmelCase    , __UpperCAmelCase      ):
             break






       def __setitem__(    self    , __UpperCAmelCase    , __UpperCAmelCase      ):



         '''simple docstring'''

         if self._is_full():
           self._size_up()

         self._add_item(__UpperCAmelCase    , __UpperCAmelCase      )






       def __delitem__(    self    , __UpperCAmelCase      ):



         '''simple docstring'''

         for ind in self._iterate_buckets(__UpperCAmelCase      ):
           lowerCAmelCase__			:int											=							self._buckets[ind]
           if item is None:
             raise KeyError(__UpperCAmelCase      )
           if item is _deleted:
             continue
           if item.key == key:
             lowerCAmelCase__			:List[str]											=							_deleted
             self._len -= 1
             break
         if self._is_sparse():
           self._size_down()






       def __getitem__(    self    , __UpperCAmelCase      ):



         '''simple docstring'''

         for ind in self._iterate_buckets(__UpperCAmelCase      ):
           lowerCAmelCase__			:str											=							self._buckets[ind]
           if item is None:
             break
           if item is _deleted:
             continue
           if item.key == key:
             return item.val
         raise KeyError(__UpperCAmelCase      )






       def __len__(    self      ):



         '''simple docstring'''

         return self._len






       def __iter__(    self      ):



         '''simple docstring'''

         yield from (item.key for item in self._buckets if item)






       def __repr__(    self      ):



         '''simple docstring'''

         lowerCAmelCase__			:Tuple											=							' ,'.join(
             F"{item.key}: {item.val}" for item in self._buckets if item      )
         return F"HashMap({val_string})"
