


"""simple docstring"""







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

import datasets


lowerCAmelCase__      				=   '''\
@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}
}
'''

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

lowerCAmelCase__      				=   '''
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 					a__			(				SCREAMING_SNAKE_CASE    :    Optional[Any]				,      SCREAMING_SNAKE_CASE    :    Any				):


  '''simple docstring'''







  return float((preds == labels).mean()				)
def 					a__			(				SCREAMING_SNAKE_CASE    :    Union[str, Any]				,      SCREAMING_SNAKE_CASE    :    Union[str, Any]				):


  '''simple docstring'''







  lowerCAmelCase     :     List[Any]								=							simple_accuracy(SCREAMING_SNAKE_CASE				,      SCREAMING_SNAKE_CASE				)
  lowerCAmelCase     :     Union[str, Any]								=							float(fa_score(y_true=SCREAMING_SNAKE_CASE				,      y_pred=SCREAMING_SNAKE_CASE				)				)
  return {
      "accuracy": acc,
      "f1": fa,
  }
def 					a__			(				SCREAMING_SNAKE_CASE    :    List[Any]				,      SCREAMING_SNAKE_CASE    :    List[str]				):


  '''simple docstring'''







  lowerCAmelCase     :     List[str]								=							float(pearsonr(SCREAMING_SNAKE_CASE				,      SCREAMING_SNAKE_CASE				)[0]				)
  lowerCAmelCase     :     List[Any]								=							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       SCREAMING_SNAKE_CASE__				(		datasets.Metric				):
       """simple docstring"""


       def        lowercase__							(						self						):






         """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        lowercase__							(						self		,     snake_case__		,     snake_case__						):






         """simple docstring"""





         if self.config_name == "cola":
           return {"matthews_correlation": matthews_corrcoef(snake_case__		,     snake_case__						)}
         elif self.config_name == "stsb":
           return pearson_and_spearman(snake_case__		,     snake_case__						)
         elif self.config_name in ["mrpc", "qqp"]:
           return acc_and_fa(snake_case__		,     snake_case__						)
         elif self.config_name in ["sst2", "mnli", "mnli_mismatched", "mnli_matched", "qnli", "rte", "wnli", "hans"]:
           return {"accuracy": simple_accuracy(snake_case__		,     snake_case__						)}
         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\"]"						)









"""simple docstring"""







def 					a__			(				SCREAMING_SNAKE_CASE    :    float				,      SCREAMING_SNAKE_CASE    :    float				,      SCREAMING_SNAKE_CASE    :    int				):


  '''simple docstring'''







  if principal <= 0:
    raise Exception("Principal borrowed must be > 0"				)
  if rate_per_annum < 0:
    raise Exception("Rate of interest must be >= 0"				)
  if years_to_repay <= 0 or not isinstance(SCREAMING_SNAKE_CASE				,      SCREAMING_SNAKE_CASE				):
    raise Exception("Years to repay must be an integer > 0"				)

  # Yearly rate is divided by 12 to get monthly rate
  lowerCAmelCase     :     Tuple								=							rate_per_annum / 1_2

  # Years to repay is multiplied by 12 to get number of payments as payment is monthly
  lowerCAmelCase     :     List[Any]								=							years_to_repay * 1_2

  return (
      principal
      * rate_per_month
      * (1 + rate_per_month) ** number_of_payments
      / ((1 + rate_per_month) ** number_of_payments - 1)
  )


if __name__ == "__main__":
     import doctest

     doctest.testmod()





