code: 
  
  
  import argparse
  import json
  import re
  import string
  import sys
  from collections import Counter
  
  
  
  
  def   lowerCamelCase_       (					UpperCAmelCase__      ):
  
  
  
        """simple docstring"""
  
  
  
  
        def remove_articles(UpperCAmelCase__      ):
              return re.sub(r"""\b(a|an|the)\b"""       ,    """ """       ,    UpperCAmelCase__      )
  
        def white_space_fix(UpperCAmelCase__      ):
              return " ".join(text.split()      )
  
        def remove_punc(UpperCAmelCase__      ):
              a_					=		set(string.punctuation      )
              return "".join(ch for ch in text if ch not in exclude      )
  
        def lower(UpperCAmelCase__      ):
              return text.lower()
  
        return white_space_fix(remove_articles(remove_punc(lower(UpperCAmelCase__      )      )      )      )
  
  
  
  
  def   lowerCamelCase_       (					UpperCAmelCase__       ,    UpperCAmelCase__      ):
  
  
  
        """simple docstring"""
  
  
  
  
        a_					=		normalize_answer(UpperCAmelCase__      ).split()
        a_					=		normalize_answer(UpperCAmelCase__      ).split()
        a_					=		Counter(UpperCAmelCase__      ) & Counter(UpperCAmelCase__      )
        a_					=		sum(common.values()      )
        if num_same == 0:
              return 0
        a_					=		1.0 * num_same / len(UpperCAmelCase__      )
        a_					=		1.0 * num_same / len(UpperCAmelCase__      )
        a_					=		(2 * precision * recall) / (precision + recall)
        return fa
  
  
  
  
  def   lowerCamelCase_       (					UpperCAmelCase__       ,    UpperCAmelCase__      ):
  
  
  
        """simple docstring"""
  
  
  
  
        return normalize_answer(UpperCAmelCase__      ) == normalize_answer(UpperCAmelCase__      )
  
  
  
  
  def   lowerCamelCase_       (					UpperCAmelCase__       ,    UpperCAmelCase__       ,    UpperCAmelCase__      ):
  
  
  
        """simple docstring"""
  
  
  
  
        a_					=		[]
        for ground_truth in ground_truths:
              a_					=		metric_fn(UpperCAmelCase__       ,    UpperCAmelCase__      )
              scores_for_ground_truths.append(UpperCAmelCase__      )
        return max(UpperCAmelCase__      )
  
  
  
  
  def   lowerCamelCase_       (					UpperCAmelCase__       ,    UpperCAmelCase__      ):
  
  
  
        """simple docstring"""
  
  
  
  
        a_					=		0
        for article in dataset:
              for paragraph in article["paragraphs"]:
                    for qa in paragraph["qas"]:
                          total += 1
                          if qa["id"] not in predictions:
                                a_					=		"Unanswered question " + qa["id"] + " will receive score 0."
                                print(UpperCAmelCase__       ,    file=sys.stderr      )
                                continue
                          a_					=		[x["text"] for x in qa["answers"]]
                          a_					=		predictions[qa["id"]]
                          exact_match += metric_max_over_ground_truths(UpperCAmelCase__       ,    UpperCAmelCase__       ,    UpperCAmelCase__      )
                          fa += metric_max_over_ground_truths(UpperCAmelCase__       ,    UpperCAmelCase__       ,    UpperCAmelCase__      )
  
        a_					=		1_00.0 * exact_match / total
        a_					=		1_00.0 * fa / total
  
        return {"exact_match": exact_match, "f1": fa}
  
  
  if __name__ == "__main__":
   A_    :					Tuple             ="""1.1"""
   A_    :					int             =argparse.ArgumentParser(description="""Evaluation for SQuAD """ + expected_version)
   parser.add_argument("""dataset_file""", help="""Dataset file""")
   parser.add_argument("""prediction_file""", help="""Prediction File""")
   A_    :					Any             =parser.parse_args()
   with open(args.dataset_file) as dataset_file:
    A_    :					Optional[int]             =json.load(dataset_file)
    if dataset_json["version"] != expected_version:
     print(
         """Evaluation expects v-""" + expected_version + """, but got dataset with v-""" + dataset_json["""version"""],
         file=sys.stderr,
     )
    A_    :					Optional[Any]             =dataset_json["""data"""]
   with open(args.prediction_file) as prediction_file:
    A_    :					Optional[int]             =json.load(prediction_file)
   print(json.dumps(evaluate(dataset, predictions)))
style_context: 
  
  
  from collections.abc import Callable
  
  A_    :					Any             =Callable[[float], float]  # type alias for a real -> real function
  
  
  
  
  def   lowerCamelCase_       (					UpperCAmelCase__       ,    UpperCAmelCase__       ,    UpperCAmelCase__       ,    ):
  
  
  
  						"""simple docstring"""
  
  
  
  
  						a_					=		float(UpperCAmelCase__      )
  						while True:
  												try:
  																		a_					=		prev_guess - function(UpperCAmelCase__      ) / derivative(UpperCAmelCase__      )
  												except ZeroDivisionError:
  																		raise ZeroDivisionError("""Could not find root"""      ) from None
  												if abs(prev_guess - next_guess      ) < 10**-5:
  																		return next_guess
  												a_					=		next_guess
  
  
  
  
  def   lowerCamelCase_       (					UpperCAmelCase__      ):
  
  
  
  						"""simple docstring"""
  
  
  
  
  						return (x**3) - (2 * x) - 5
  
  
  
  
  def   lowerCamelCase_       (					UpperCAmelCase__      ):
  
  
  
  						"""simple docstring"""
  
  
  
  
  						return 3 * (x**2) - 2
  
  
  if __name__ == "__main__":
  	print(newton(f, fa, 3))