


"""simple docstring"""
SCREAMING_SNAKE_CASE :    List[Any]									=				tuple[float, float, float]
SCREAMING_SNAKE_CASE :    List[str]									=				tuple[float, float, float]






def 		lowercase							(     _snake_case						:      Pointad     ,   _snake_case						:      Pointad     )     ->Vectorad:
	"""simple docstring"""





	__snake_case	:						List[str]						=				end_pointa[0] - end_pointa[0]
	__snake_case	:						Union[str, Any]						=				end_pointa[1] - end_pointa[1]
	__snake_case	:						List[str]						=				end_pointa[2] - end_pointa[2]
	return (x, y, z)






def 		lowercase							(     _snake_case						:      Vectorad     ,   _snake_case						:      Vectorad     )     ->Vectorad:
	"""simple docstring"""





	__snake_case	:						str						=				ab[1] * ac[2] - ab[2] * ac[1]  # *i
	__snake_case	:						int						=				(ab[0] * ac[2] - ab[2] * ac[0]) * -1  # *j
	__snake_case	:						str						=				ab[0] * ac[1] - ab[1] * ac[0]  # *k
	return (x, y, z)






def 		lowercase							(     _snake_case						:      Vectorad     ,   _snake_case						:      int     )     ->bool:
	"""simple docstring"""





	return tuple(round(_snake_case     ,   _snake_case     ) for x in vector     ) == (0, 0, 0)






def 		lowercase							(     _snake_case						:      Pointad     ,   _snake_case						:      Pointad     ,   _snake_case						:      Pointad     ,   _snake_case						:      int = 10     )     ->bool:
	"""simple docstring"""





	__snake_case	:						Dict						=				create_vector(_snake_case     ,   _snake_case     )
	__snake_case	:						Any						=				create_vector(_snake_case     ,   _snake_case     )
	return is_zero_vector(get_ad_vectors_cross(_snake_case     ,   _snake_case     )     ,   _snake_case     )












import math
import random



def A_	(		A__		,      A__ = False				)  ->		float:
       if deriv:
              return value * (1 - value)
       return 1 / (1 + math.exp(-value				))


# Initial Value
lowercase      :       Optional[Any]									=  0.02



def A_	(		A__		,      A__				)  ->		float:
       a__						:	int =				float(2 * (random.randint(1		,      100				)) - 1				)

       for _ in range(A__				):
              # Forward propagation
              a__						:	Union[str, Any] =				sigmoid_function(INITIAL_VALUE * weight				)
              # How much did we miss?
              a__						:	Optional[Any] =				(expected / 100) - layer_a
              # Error delta
              a__						:	Optional[int] =				layer_1_error * sigmoid_function(A__		,      A__				)
              # Update weight
              weight += INITIAL_VALUE * layer_1_delta

       return layer_a * 100


if __name__ == "__main__":
    import doctest

    doctest.testmod()

    lowercase      :       Dict									=  int(input("""Expected value: """))
    lowercase      :       Dict									=  int(input("""Number of propagations: """))
    print(forward_propagation(expected, number_propagations))


