






"""simple docstring"""







import datasets


_UpperCamelCase					      =  """\
@InProceedings{conneau2018xnli,
  author = \"Conneau, Alexis
                 and Rinott, Ruty
                 and Lample, Guillaume
                 and Williams, Adina
                 and Bowman, Samuel R.
                 and Schwenk, Holger
                 and Stoyanov, Veselin\",
  title = \"XNLI: Evaluating Cross-lingual Sentence Representations\",
  booktitle = \"Proceedings of the 2018 Conference on Empirical Methods
               in Natural Language Processing\",
  year = \"2018\",
  publisher = \"Association for Computational Linguistics\",
  location = \"Brussels, Belgium\",
}
"""

_UpperCamelCase					      =  """\
XNLI is a subset of a few thousand examples from MNLI which has been translated
into a 14 different languages (some low-ish resource). As with MNLI, the goal is
to predict textual entailment (does sentence A imply/contradict/neither sentence
B) and is a classification task (given two sentences, predict one of three
labels).
"""

_UpperCamelCase					      =  """
Computes XNLI score which is just simple accuracy.
Args:
    predictions: Predicted labels.
    references: Ground truth labels.
Returns:
    'accuracy': accuracy
Examples:

    >>> predictions = [0, 1]
    >>> references = [0, 1]
    >>> xnli_metric = datasets.load_metric(\"xnli\")
    >>> results = xnli_metric.compute(predictions=predictions, references=references)
    >>> print(results)
    {'accuracy': 1.0}
"""

def _a			(		_snake_case				,	_snake_case							):







      """simple docstring"""






      return (preds == labels).mean()







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






    def     _UpperCamelCase							(			self ):
          return datasets.MetricInfo(
              description=_DESCRIPTION     ,citation=_CITATION     ,inputs_description=_KWARGS_DESCRIPTION     ,features=datasets.Features(
                  {
                      """predictions""": datasets.Value("""int64""" if self.config_name != """sts-b""" else """float32""" ),
                      """references""": datasets.Value("""int64""" if self.config_name != """sts-b""" else """float32""" ),
                  } )     ,codebase_urls=[]     ,reference_urls=[]     ,format="""numpy"""     ,)






    def     _UpperCamelCase							(			self     ,A     ,A ):
          return {"accuracy": simple_accuracy(A     ,A )}











"""simple docstring"""







from __future__ import annotations

def _a			(		_snake_case				,	_snake_case				,	_snake_case							):







      """simple docstring"""






      if (voltage, current, resistance).count(0							) != 1:
            raise ValueError("""One and only one argument must be 0"""							)
      if resistance < 0:
            raise ValueError("""Resistance cannot be negative"""							)
      if voltage == 0:
            return {"voltage": float(current * resistance							)}
      elif current == 0:
            return {"current": voltage / resistance}
      elif resistance == 0:
            return {"resistance": voltage / current}
      else:
            raise ValueError("""Exactly one argument must be 0"""							)


if __name__ == "__main__":
  import doctest

  doctest.testmod()



