





from scipy.stats import pearsonr, spearmanr
from sklearn.metrics import fa_score, matthews_corrcoef

import datasets


SCREAMING_SNAKE_CASE_						       =	"""\
@inproceedings{wang2019glue,
  title={{GLUE}: A Multi-Task Benchmark and Analysis Platform for Natural Language Understanding},
  author={Wang, Alex and Singh, Amanpreet and Michael, Julian and Hill, Felix and Levy, Omer and Bowman, Samuel R.},
  note={In the Proceedings of ICLR.},
  year={2019}
}
"""

SCREAMING_SNAKE_CASE_						       =	"""\
GLUE, the General Language Understanding Evaluation benchmark
(https://gluebenchmark.com/) is a collection of resources for training,
evaluating, and analyzing natural language understanding systems.
"""

SCREAMING_SNAKE_CASE_						       =	"""
Compute GLUE evaluation metric associated to each GLUE dataset.
Args:
    predictions: list of predictions to score.
        Each translation should be tokenized into a list of tokens.
    references: list of lists of references for each translation.
        Each reference should be tokenized into a list of tokens.
Returns: depending on the GLUE subset, one or several of:
    \"accuracy\": Accuracy
    \"f1\": F1 score
    \"pearson\": Pearson Correlation
    \"spearmanr\": Spearman Correlation
    \"matthews_correlation\": Matthew Correlation
Examples:

    >>> glue_metric = datasets.load_metric('glue', 'sst2')  # 'sst2' or any of [\"mnli\", \"mnli_mismatched\", \"mnli_matched\", \"qnli\", \"rte\", \"wnli\", \"hans\"]
    >>> references = [0, 1]
    >>> predictions = [0, 1]
    >>> results = glue_metric.compute(predictions=predictions, references=references)
    >>> print(results)
    {'accuracy': 1.0}

    >>> glue_metric = datasets.load_metric('glue', 'mrpc')  # 'mrpc' or 'qqp'
    >>> references = [0, 1]
    >>> predictions = [0, 1]
    >>> results = glue_metric.compute(predictions=predictions, references=references)
    >>> print(results)
    {'accuracy': 1.0, 'f1': 1.0}

    >>> glue_metric = datasets.load_metric('glue', 'stsb')
    >>> references = [0., 1., 2., 3., 4., 5.]
    >>> predictions = [0., 1., 2., 3., 4., 5.]
    >>> results = glue_metric.compute(predictions=predictions, references=references)
    >>> print({\"pearson\": round(results[\"pearson\"], 2), \"spearmanr\": round(results[\"spearmanr\"], 2)})
    {'pearson': 1.0, 'spearmanr': 1.0}

    >>> glue_metric = datasets.load_metric('glue', 'cola')
    >>> references = [0, 1]
    >>> predictions = [0, 1]
    >>> results = glue_metric.compute(predictions=predictions, references=references)
    >>> print(results)
    {'matthews_correlation': 1.0}
"""



def        __lowercase       (				_SCREAMING_SNAKE_CASE			,						_SCREAMING_SNAKE_CASE     )			->       List[str]:


      '''simple docstring'''


      return float((preds == labels).mean()     )



def        __lowercase       (				_SCREAMING_SNAKE_CASE			,						_SCREAMING_SNAKE_CASE     )			->       Union[str, Any]:


      '''simple docstring'''


      SCREAMING_SNAKE_CASE		=						simple_accuracy(_SCREAMING_SNAKE_CASE			,						_SCREAMING_SNAKE_CASE     )
      SCREAMING_SNAKE_CASE		=						float(fa_score(y_true=_SCREAMING_SNAKE_CASE			,						y_pred=_SCREAMING_SNAKE_CASE     )     )
      return {
          "accuracy": acc,
          "f1": fa,
      }



def        __lowercase       (				_SCREAMING_SNAKE_CASE			,						_SCREAMING_SNAKE_CASE     )			->       Dict:


      '''simple docstring'''


      SCREAMING_SNAKE_CASE		=						float(pearsonr(_SCREAMING_SNAKE_CASE			,						_SCREAMING_SNAKE_CASE     )[0]     )
      SCREAMING_SNAKE_CASE		=						float(spearmanr(_SCREAMING_SNAKE_CASE			,						_SCREAMING_SNAKE_CASE     )[0]     )
      return {
          "pearson": pearson_corr,
          "spearmanr": spearman_corr,
      }



@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION							,				_KWARGS_DESCRIPTION       )
class 		UpperCamelCase__			(				datasets.Metric       ):



     '''simple docstring'''

     def     SCREAMING_SNAKE_CASE__  (							self						:   List[Any]	)					->		str:




           '''simple docstring'''


           if self.config_name not in [
               "sst2",
               "mnli",
               "mnli_mismatched",
               "mnli_matched",
               "cola",
               "stsb",
               "mrpc",
               "qqp",
               "qnli",
               "rte",
               "wnli",
               "hans",
           ]:
                 raise KeyError(
                     """You should supply a configuration name selected in """
                     """[\"sst2\", \"mnli\", \"mnli_mismatched\", \"mnli_matched\", """
                     """\"cola\", \"stsb\", \"mrpc\", \"qqp\", \"qnli\", \"rte\", \"wnli\", \"hans\"]"""	)
           return datasets.MetricInfo(
               description=_DESCRIPTION						,citation=_CITATION						,inputs_description=_KWARGS_DESCRIPTION						,features=datasets.Features(
                   {
                       """predictions""": datasets.Value("""int64""" if self.config_name != """stsb""" else """float32"""	),
                       """references""": datasets.Value("""int64""" if self.config_name != """stsb""" else """float32"""	),
                   }	)						,codebase_urls=[]						,reference_urls=[]						,format="""numpy"""						,)






     def     SCREAMING_SNAKE_CASE__  (							self						:   Optional[int]						,lowerCamelCase__						:   List[Any]						,lowerCamelCase__						:   Tuple	)					->		List[Any]:




           '''simple docstring'''


           if self.config_name == "cola":
                 return {"matthews_correlation": matthews_corrcoef(lowerCamelCase__						,lowerCamelCase__	)}
           elif self.config_name == "stsb":
                 return pearson_and_spearman(lowerCamelCase__						,lowerCamelCase__	)
           elif self.config_name in ["mrpc", "qqp"]:
                 return acc_and_fa(lowerCamelCase__						,lowerCamelCase__	)
           elif self.config_name in ["sst2", "mnli", "mnli_mismatched", "mnli_matched", "qnli", "rte", "wnli", "hans"]:
                 return {"accuracy": simple_accuracy(lowerCamelCase__						,lowerCamelCase__	)}
           else:
                 raise KeyError(
                     """You should supply a configuration name selected in """
                     """[\"sst2\", \"mnli\", \"mnli_mismatched\", \"mnli_matched\", """
                     """\"cola\", \"stsb\", \"mrpc\", \"qqp\", \"qnli\", \"rte\", \"wnli\", \"hans\"]"""	)













from __future__ import annotations

import math



def        __lowercase       (				_SCREAMING_SNAKE_CASE     )			->       bool:


      '''simple docstring'''


      if 1 < number < 4:
            # 2 and 3 are primes
            return True
      elif number < 2 or number % 2 == 0 or number % 3 == 0:
            # Negatives, 0, 1, all even numbers, all multiples of 3 are not primes
            return False

      # All primes number are in format of 6k +/- 1
      for i in range(5			,						int(math.sqrt(_SCREAMING_SNAKE_CASE     ) + 1     )			,						6     ):
            if number % i == 0 or number % (i + 2) == 0:
                  return False
      return True



def        __lowercase       (				_SCREAMING_SNAKE_CASE     )			->       list[int]:


      '''simple docstring'''


      SCREAMING_SNAKE_CASE		=						str(_SCREAMING_SNAKE_CASE     )
      SCREAMING_SNAKE_CASE		=						[n]
      for i in range(1			,						len(_SCREAMING_SNAKE_CASE     )     ):
            list_nums.append(int(str_num[i:]     )     )
            list_nums.append(int(str_num[:-i]     )     )
      return list_nums



def        __lowercase       (				_SCREAMING_SNAKE_CASE     )			->       bool:


      '''simple docstring'''


      if len(str(_SCREAMING_SNAKE_CASE     )     ) > 3:
            if not is_prime(int(str(_SCREAMING_SNAKE_CASE     )[-3:]     )     ) or not is_prime(int(str(_SCREAMING_SNAKE_CASE     )[:3]     )     ):
                  return False
      return True



def        __lowercase       (				_SCREAMING_SNAKE_CASE = 11     )			->       list[int]:


      '''simple docstring'''


      SCREAMING_SNAKE_CASE		=						[]
      SCREAMING_SNAKE_CASE		=						13
      while len(_SCREAMING_SNAKE_CASE     ) != count:
            if validate(_SCREAMING_SNAKE_CASE     ):
                  SCREAMING_SNAKE_CASE		=						list_truncated_nums(_SCREAMING_SNAKE_CASE     )
                  if all(is_prime(_SCREAMING_SNAKE_CASE     ) for i in list_nums     ):
                        list_truncated_primes.append(_SCREAMING_SNAKE_CASE     )
            num += 2
      return list_truncated_primes



def        __lowercase       (				)			->       int:


      '''simple docstring'''


      return sum(compute_truncated_primes(11     )     )


if __name__ == "__main__":
      print(F'''{sum(compute_truncated_primes(1_1)) = }''')


