import math
import random




def    lowerCAmelCase_ (     __A,  __A = False							)     ->				float:







      '''simple docstring'''


      if deriv:
            return value * (1 - value)
      return 1 / (1 + math.exp(-value							))


# Initial Value
UpperCamelCase__											=					0.0_2




def    lowerCAmelCase_ (     __A,  __A							)     ->				float:







      '''simple docstring'''


      UpperCAmelCase__								=  float(2 * (random.randint(1,  100							)) - 1							)

      for _ in range(__A							):
            # Forward propagation
            UpperCAmelCase__								=  sigmoid_function(INITIAL_VALUE * weight							)
            # How much did we miss?
            UpperCAmelCase__								=  (expected / 100) - layer_a
            # Error delta
            UpperCAmelCase__								=  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()

      UpperCamelCase__											=					int(input('Expected value: '))
      UpperCamelCase__											=					int(input('Number of propagations: '))
      print(forward_propagation(expected, number_propagations))




def    lowerCAmelCase_ (     __A,  __A							)     ->				float:







      '''simple docstring'''


      def get_matched_characters(__A,  __A							) -> str:
            UpperCAmelCase__								=  []
            UpperCAmelCase__								=  min(len(_stra							),  len(_stra							)							) // 2
            for i, l in enumerate(_stra							):
                  UpperCAmelCase__								=  int(max(0,  i - limit							)							)
                  UpperCAmelCase__								=  int(min(i + limit + 1,  len(_stra							)							)							)
                  if l in _stra[left:right]:
                        matched.append(__A							)
                        UpperCAmelCase__								=  f"""{_stra[0:_stra.index(__A							)]} {_stra[_stra.index(__A							) + 1:]}"""

            return "".join(__A							)

      # matching characters
      UpperCAmelCase__								=  get_matched_characters(__A,  __A							)
      UpperCAmelCase__								=  get_matched_characters(__A,  __A							)
      UpperCAmelCase__								=  len(__A							)

      # transposition
      UpperCAmelCase__								=  (
          len([(ca, ca) for ca, ca in zip(__A,  __A							) if ca != ca]							) // 2
      )

      if not match_count:
            UpperCAmelCase__								=  0.0
      else:
            UpperCAmelCase__								=  (
                1
                / 3
                * (
                    match_count / len(__A							)
                    + match_count / len(__A							)
                    + (match_count - transpositions) / match_count
                )
            )

      # common prefix up to 4 characters
      UpperCAmelCase__								=  0
      for ca, ca in zip(stra[:4],  stra[:4]							):
            if ca == ca:
                  prefix_len += 1
            else:
                  break

      return jaro + 0.1 * prefix_len * (1 - jaro)


if __name__ == "__main__":
      import doctest

      doctest.testmod()
      print(jaro_winkler('hello', 'world'))



