




'''simple docstring'''


# Lint as: python3
import dataclasses
import re
from dataclasses import dataclass
from functools import total_ordering
from typing import Optional, Union


UpperCAmelCase_ 		=      re.compile(r"^(?P<major>\d+)" r"\.(?P<minor>\d+)" r"\.(?P<patch>\d+)$")





@total_ordering
@dataclass
class    __lowercase						:
   _a							=      42
   _a							=      None
   _a							=      None
   _a							=      None
   _a							=      None







   def 		UpperCamelCase__			(	self      )				->    Any:
     __a	,       __a	,       __a			=					_str_to_version_tuple(self.version_str      )







   def __repr__(	self      )				->    Union[str, Any]:
     return f"{self.tuple[0]}.{self.tuple[1]}.{self.tuple[2]}"







   @property
   def 		UpperCamelCase__			(	self      )				->    List[str]:
     return self.major, self.minor, self.patch







   def 		UpperCamelCase__			(	self      ,							UpperCamelCase      )				->    Dict:
     if isinstance(UpperCamelCase      ,							UpperCamelCase      ):
       return Version(UpperCamelCase      )
     elif isinstance(UpperCamelCase      ,							UpperCamelCase      ):
       return other
     raise TypeError(f"{other} (type {type(UpperCamelCase      )}) cannot be compared to version."      )







   def __eq__(	self      ,							UpperCamelCase      )				->    List[str]:
     try:
       __a			=					self._validate_operand(UpperCamelCase      )
     except (TypeError, ValueError):
       return False
     else:
       return self.tuple == other.tuple







   def __lt__(	self      ,							UpperCamelCase      )				->    Any:
     __a			=					self._validate_operand(UpperCamelCase      )
     return self.tuple < other.tuple







   def __hash__(	self      )				->    Optional[int]:
     return hash(_version_tuple_to_str(self.tuple      )      )







   @classmethod
   def 		UpperCamelCase__			(	cls      ,							UpperCamelCase      )				->    Optional[Any]:
     __a			=					{f.name for f in dataclasses.fields(cls      )}
     return cls(**{k: v for k, v in dic.items() if k in field_names}      )







   def 		UpperCamelCase__			(	self      )				->    str:
     return self.version_str


def 						SCREAMING_SNAKE_CASE       (      a_	:							List[Any]			):
  __a			=					_VERSION_REG.match(a_			)
  if not res:
    raise ValueError(f"Invalid version '{version_str}'. Format should be x.y.z with {{x,y,z}} being digits."			)
  return tuple(int(a_			) for v in [res.group('major'			), res.group('minor'			), res.group('patch'			)]			)


def 						SCREAMING_SNAKE_CASE       (      a_	:							str			):
  return ".".join(str(a_			) for v in version_tuple			)









'''simple docstring'''


import numpy as np

import datasets


UpperCAmelCase_ 		=      "\nCompute the Mahalanobis Distance\n\nMahalonobis distance is the distance between a point and a distribution.\nAnd not between two distinct points. It is effectively a multivariate equivalent of the Euclidean distance.\nIt was introduced by Prof. P. C. Mahalanobis in 1936\nand has been used in various statistical applications ever since\n[source: https://www.machinelearningplus.com/statistics/mahalanobis-distance/]\n"

UpperCAmelCase_ 		=      "\\n@article{de2000mahalanobis,\n  title={The mahalanobis distance},\n  author={De Maesschalck, Roy and Jouan-Rimbaud, Delphine and Massart, D{\'e}sir{\'e} L},\n  journal={Chemometrics and intelligent laboratory systems},\n  volume={50},\n  number={1},\n  pages={1--18},\n  year={2000},\n  publisher={Elsevier}\n}\n"

UpperCAmelCase_ 		=      "\nArgs:\n    X: List of datapoints to be compared with the `reference_distribution`.\n    reference_distribution: List of datapoints from the reference distribution we want to compare to.\nReturns:\n    mahalanobis: The Mahalonobis distance for each datapoint in `X`.\nExamples:\n\n    >>> mahalanobis_metric = datasets.load_metric(\"mahalanobis\")\n    >>> results = mahalanobis_metric.compute(reference_distribution=[[0, 1], [1, 0]], X=[[0, 1]])\n    >>> print(results)\n    {'mahalanobis': array([0.5])}\n"





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







   def 		UpperCamelCase__			(	self      )				->    Optional[Any]:
     return datasets.MetricInfo(
         description=_DESCRIPTION      ,							citation=_CITATION      ,							inputs_description=_KWARGS_DESCRIPTION      ,							features=datasets.Features(
             {
                 'X': datasets.Sequence(datasets.Value('float'      ,							id='sequence'      )      ,							id='X'      ),
             }      )      ,							)







   def 		UpperCamelCase__			(	self      ,							UpperCamelCase      ,							UpperCamelCase      )				->    Optional[int]:
     # convert to numpy arrays
     __a			=					np.array(UpperCamelCase      )
     __a			=					np.array(UpperCamelCase      )

     # Assert that arrays are 2D
     if len(X.shape      ) != 2:
       raise ValueError('Expected `X` to be a 2D vector'      )
     if len(reference_distribution.shape      ) != 2:
       raise ValueError('Expected `reference_distribution` to be a 2D vector'      )
     if reference_distribution.shape[0] < 2:
       raise ValueError(
           'Expected `reference_distribution` to be a 2D vector with more than one element in the first dimension'      )

     # Get mahalanobis distance for each prediction
     __a			=					X - np.mean(UpperCamelCase      )
     __a			=					np.cov(reference_distribution.T      )
     try:
       __a			=					np.linalg.inv(UpperCamelCase      )
     except np.linalg.LinAlgError:
       __a			=					np.linalg.pinv(UpperCamelCase      )
     __a			=					np.dot(UpperCamelCase      ,							UpperCamelCase      )
     __a			=					np.dot(UpperCamelCase      ,							X_minus_mu.T      ).diagonal()

     return {"mahalanobis": mahal_dist}



