
'''simple docstring'''







_lowercase :  List[str]    							=       tuple[float, float, float]
_lowercase :  int    							=       tuple[float, float, float]
def 					snake_case_		(				__SCREAMING_SNAKE_CASE					: Optional[int]      ,      __SCREAMING_SNAKE_CASE					: Optional[int]							):



						"""simple docstring"""





						lowercase_	:     Optional[int]													=       end_pointa[0] - end_pointa[0]
						lowercase_	:     str													=       end_pointa[1] - end_pointa[1]
						lowercase_	:     Dict													=       end_pointa[2] - end_pointa[2]
						return (x, y, z)
def 					snake_case_		(				__SCREAMING_SNAKE_CASE					: List[str]      ,      __SCREAMING_SNAKE_CASE					: List[Any]							):



						"""simple docstring"""





						lowercase_	:     Tuple													=       ab[1] * ac[2] - ab[2] * ac[1]  # *i
						lowercase_	:     Dict													=       (ab[0] * ac[2] - ab[2] * ac[0]) * -1  # *j
						lowercase_	:     Optional[int]													=       ab[0] * ac[1] - ab[1] * ac[0]  # *k
						return (x, y, z)
def 					snake_case_		(				__SCREAMING_SNAKE_CASE					: Any      ,      __SCREAMING_SNAKE_CASE					: Dict							):



						"""simple docstring"""





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




def 					snake_case_		(				__SCREAMING_SNAKE_CASE					: Tuple      ,      __SCREAMING_SNAKE_CASE					: Optional[Any]      ,      __SCREAMING_SNAKE_CASE					: str      ,      __SCREAMING_SNAKE_CASE					: List[Any] = 10							):



						"""simple docstring"""





						lowercase_	:     Tuple													=       create_vector(A__      ,      A__							)
						lowercase_	:     str													=       create_vector(A__      ,      A__							)
						return is_zero_vector(get_ad_vectors_cross(A__      ,      A__							)      ,      A__							)










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))


