
from __future__ import annotations





class 							A__		:
      def __init__(      self    ,  __magic_name__      ):
       lowerCamelCase		:	Any							=      TypeError(
           """Matrices must be formed from a list of zero or more lists containing at """
           """least one and the same number of values, each of which must be of type """
           """int or float."""      )
       if len(__magic_name__      ) != 0:
        lowerCamelCase		:	List[str]							=      len(rows[0]      )
        if cols == 0:
         raise error
        for row in rows:
         if len(__magic_name__      ) != cols:
          raise error
         for value in row:
          if not isinstance(__magic_name__    ,  (int, float)      ):
           raise error
        lowerCamelCase		:	Optional[int]							=      rows
       else:
        lowerCamelCase		:	List[str]							=      []
      def 						UpperCamelCase__							(      self      ):
       return [[row[i] for row in self.rows] for i in range(len(self.rows[0]      )      )]
      @property
      def 						UpperCamelCase__							(      self      ):
       return len(self.rows      )
      @property
      def 						UpperCamelCase__							(      self      ):
       return len(self.rows[0]      )
      @property
      def 						UpperCamelCase__							(      self      ):
       return (self.num_rows, self.num_columns)
      @property
      def 						UpperCamelCase__							(      self      ):
       return self.order[0] == self.order[1]
      def 						UpperCamelCase__							(      self      ):
       lowerCamelCase		:	Any							=      [
           [0 if column_num != row_num else 1 for column_num in range(self.num_rows      )]
           for row_num in range(self.num_rows      )
       ]
       return Matrix(__magic_name__      )
      def 						UpperCamelCase__							(      self      ):
       if not self.is_square:
        return 0
       if self.order == (0, 0):
        return 1
       if self.order == (1, 1):
        return int(self.rows[0][0]      )
       if self.order == (2, 2):
        return int(
            (self.rows[0][0] * self.rows[1][1])
            - (self.rows[0][1] * self.rows[1][0])      )
       else:
        return sum(
            self.rows[0][column] * self.cofactors().rows[0][column]
            for column in range(self.num_columns      )      )
      def 						UpperCamelCase__							(      self      ):
       return bool(self.determinant()      )
      def 						UpperCamelCase__							(      self    ,  __magic_name__    ,  __magic_name__      ):
       lowerCamelCase		:	int							=      [
           [
               self.rows[other_row][other_column]
               for other_column in range(self.num_columns      )
               if other_column != column
           ]
           for other_row in range(self.num_rows      )
           if other_row != row
       ]
       return Matrix(__magic_name__      ).determinant()
      def 						UpperCamelCase__							(      self    ,  __magic_name__    ,  __magic_name__      ):
       if (row + column) % 2 == 0:
        return self.get_minor(__magic_name__    ,  __magic_name__      )
       return -1 * self.get_minor(__magic_name__    ,  __magic_name__      )
      def 						UpperCamelCase__							(      self      ):
       return Matrix(
           [
               [self.get_minor(__magic_name__    ,  __magic_name__      ) for column in range(self.num_columns      )]
               for row in range(self.num_rows      )
           ]      )
      def 						UpperCamelCase__							(      self      ):
       return Matrix(
           [
               [
                   self.minors().rows[row][column]
                   if (row + column) % 2 == 0
                   else self.minors().rows[row][column] * -1
                   for column in range(self.minors().num_columns      )
               ]
               for row in range(self.minors().num_rows      )
           ]      )
      def 						UpperCamelCase__							(      self      ):
       lowerCamelCase		:	Optional[Any]							=      [
           [self.cofactors().rows[column][row] for column in range(self.num_columns      )]
           for row in range(self.num_rows      )
       ]
       return Matrix(__magic_name__      )
      def 						UpperCamelCase__							(      self      ):
       lowerCamelCase		:	Dict							=      self.determinant()
       if not determinant:
        raise TypeError("""Only matrices with a non-zero determinant have an inverse"""      )
       return self.adjugate() * (1 / determinant)
      def __repr__(      self      ):
       return str(self.rows      )
      def __str__(      self      ):
       if self.num_rows == 0:
        return "[]"
       if self.num_rows == 1:
        return "[[" + ". ".join(str(self.rows[0]      )      ) + "]]"
       return (
           "["
           + "\n ".join(
               [
                   """[""" + """. """.join([str(__magic_name__      ) for value in row]      ) + """.]"""
                   for row in self.rows
               ]      )
           + "]"
       )
      def 						UpperCamelCase__							(      self    ,  __magic_name__    ,  __magic_name__ = None      ):
       lowerCamelCase		:	Optional[int]							=      TypeError("""Row must be a list containing all ints and/or floats"""      )
       if not isinstance(__magic_name__    ,  __magic_name__      ):
        raise type_error
       for value in row:
        if not isinstance(__magic_name__    ,  (int, float)      ):
         raise type_error
       if len(__magic_name__      ) != self.num_columns:
        raise ValueError(
            """Row must be equal in length to the other rows in the matrix"""      )
       if position is None:
        self.rows.append(__magic_name__      )
       else:
        lowerCamelCase		:	Union[str, Any]							=      self.rows[0:position] + [row] + self.rows[position:]
      def 						UpperCamelCase__							(      self    ,  __magic_name__    ,  __magic_name__ = None      ):
       lowerCamelCase		:	int							=      TypeError(
           """Column must be a list containing all ints and/or floats"""      )
       if not isinstance(__magic_name__    ,  __magic_name__      ):
        raise type_error
       for value in column:
        if not isinstance(__magic_name__    ,  (int, float)      ):
         raise type_error
       if len(__magic_name__      ) != self.num_rows:
        raise ValueError(
            """Column must be equal in length to the other columns in the matrix"""      )
       if position is None:
        lowerCamelCase		:	Optional[Any]							=      [self.rows[i] + [column[i]] for i in range(self.num_rows      )]
       else:
        lowerCamelCase		:	Union[str, Any]							=      [
            self.rows[i][0:position] + [column[i]] + self.rows[i][position:]
            for i in range(self.num_rows      )
        ]
      def __eq__(      self    ,  __magic_name__      ):
       if not isinstance(__magic_name__    ,  __magic_name__      ):
        return NotImplemented
       return self.rows == other.rows
      def __ne__(      self    ,  __magic_name__      ):
       return not self == other
      def __neg__(      self      ):
       return self * -1
      def __add__(      self    ,  __magic_name__      ):
       if self.order != other.order:
        raise ValueError("""Addition requires matrices of the same order"""      )
       return Matrix(
           [
               [self.rows[i][j] + other.rows[i][j] for j in range(self.num_columns      )]
               for i in range(self.num_rows      )
           ]      )
      def __sub__(      self    ,  __magic_name__      ):
       if self.order != other.order:
        raise ValueError("""Subtraction requires matrices of the same order"""      )
       return Matrix(
           [
               [self.rows[i][j] - other.rows[i][j] for j in range(self.num_columns      )]
               for i in range(self.num_rows      )
           ]      )
      def __mul__(      self    ,  __magic_name__      ):
       if isinstance(__magic_name__    ,  (int, float)      ):
        return Matrix(
            [[int(element * other      ) for element in row] for row in self.rows]      )
       elif isinstance(__magic_name__    ,  __magic_name__      ):
        if self.num_columns != other.num_rows:
         raise ValueError(
             """The number of columns in the first matrix must """
             """be equal to the number of rows in the second"""      )
        return Matrix(
            [
                [Matrix.dot_product(__magic_name__    ,  __magic_name__      ) for column in other.columns()]
                for row in self.rows
            ]      )
       else:
        raise TypeError(
            """A Matrix can only be multiplied by an int, float, or another matrix"""      )
      def __pow__(      self    ,  __magic_name__      ):
       if not isinstance(__magic_name__    ,  __magic_name__      ):
        raise TypeError("""A Matrix can only be raised to the power of an int"""      )
       if not self.is_square:
        raise ValueError("""Only square matrices can be raised to a power"""      )
       if other == 0:
        return self.identity()
       if other < 0:
        if self.is_invertable():
         return self.inverse() ** (-other)
        raise ValueError(
            """Only invertable matrices can be raised to a negative power"""      )
       lowerCamelCase		:	Optional[Any]							=      self
       for _ in range(other - 1      ):
        result *= self
       return result






      @classmethod
      def 						UpperCamelCase__							(      cls    ,  __magic_name__    ,  __magic_name__      ):
       return sum(row[i] * column[i] for i in range(len(__magic_name__      )      )      )


if __name__ == "__main__":
      import doctest

      doctest.testmod()






from scipy.stats import pearsonr

import datasets


_lowerCamelCase					   ="""
Pearson correlation coefficient and p-value for testing non-correlation.
The Pearson correlation coefficient measures the linear relationship between two datasets. The calculation of the p-value relies on the assumption that each dataset is normally distributed. Like other correlation coefficients, this one varies between -1 and +1 with 0 implying no correlation. Correlations of -1 or +1 imply an exact linear relationship. Positive correlations imply that as x increases, so does y. Negative correlations imply that as x increases, y decreases.
The p-value roughly indicates the probability of an uncorrelated system producing datasets that have a Pearson correlation at least as extreme as the one computed from these datasets.
"""


_lowerCamelCase					   ="""
Args:
    predictions (`list` of `int`): Predicted class labels, as returned by a model.
    references (`list` of `int`): Ground truth labels.
    return_pvalue (`boolean`): If `True`, returns the p-value, along with the correlation coefficient. If `False`, returns only the correlation coefficient. Defaults to `False`.

Returns:
    pearsonr (`float`): Pearson correlation coefficient. Minimum possible value is -1. Maximum possible value is 1. Values of 1 and -1 indicate exact linear positive and negative relationships, respectively. A value of 0 implies no correlation.
    p-value (`float`): P-value, which roughly indicates the probability of an The p-value roughly indicates the probability of an uncorrelated system producing datasets that have a Pearson correlation at least as extreme as the one computed from these datasets. Minimum possible value is 0. Maximum possible value is 1. Higher values indicate higher probabilities.

Examples:

    Example 1-A simple example using only predictions and references.
        >>> pearsonr_metric = datasets.load_metric(\"pearsonr\")
        >>> results = pearsonr_metric.compute(predictions=[10, 9, 2.5, 6, 4], references=[1, 2, 3, 4, 5])
        >>> print(round(results['pearsonr'], 2))
        -0.74

    Example 2-The same as Example 1, but that also returns the `p-value`.
        >>> pearsonr_metric = datasets.load_metric(\"pearsonr\")
        >>> results = pearsonr_metric.compute(predictions=[10, 9, 2.5, 6, 4], references=[1, 2, 3, 4, 5], return_pvalue=True)
        >>> print(sorted(list(results.keys())))
        ['p-value', 'pearsonr']
        >>> print(round(results['pearsonr'], 2))
        -0.74
        >>> print(round(results['p-value'], 2))
        0.15
"""


_lowerCamelCase					   ="""
@article{2020SciPy-NMeth,
author  = {Virtanen, Pauli and Gommers, Ralf and Oliphant, Travis E. and
      Haberland, Matt and Reddy, Tyler and Cournapeau, David and
      Burovski, Evgeni and Peterson, Pearu and Weckesser, Warren and
      Bright, Jonathan and {van der Walt}, St{\'e}fan J. and
      Brett, Matthew and Wilson, Joshua and Millman, K. Jarrod and
      Mayorov, Nikolay and Nelson, Andrew R. J. and Jones, Eric and
      Kern, Robert and Larson, Eric and Carey, C J and
      Polat, Ilhan and Feng, Yu and Moore, Eric W. and
      {VanderPlas}, Jake and Laxalde, Denis and Perktold, Josef and
      Cimrman, Robert and Henriksen, Ian and Quintero, E. A. and
      Harris, Charles R. and Archibald, Anne M. and
      Ribeiro, Antonio H. and Pedregosa, Fabian and
      {van Mulbregt}, Paul and {SciPy 1.0 Contributors}},
title   = {{{SciPy} 1.0: Fundamental Algorithms for Scientific
      Computing in Python}},
journal = {Nature Methods},
year    = {2020},
volume  = {17},
pages   = {261--272},
adsurl  = {https://rdcu.be/b08Wh},
doi = {10.1038/s41592-019-0686-2},
}
"""





@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION  ,   _KWARGS_DESCRIPTION)
class 							A__		(	datasets.Metric):
      def 						UpperCamelCase__							(      self      ):
       return datasets.MetricInfo(
           description=_DESCRIPTION    ,  citation=_CITATION    ,  inputs_description=_KWARGS_DESCRIPTION    ,  features=datasets.Features(
               {
                   """predictions""": datasets.Value("""float"""      ),
                   """references""": datasets.Value("""float"""      ),
               }      )    ,  reference_urls=["""https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.pearsonr.html"""]    ,  )






      def 						UpperCamelCase__							(      self    ,  __magic_name__    ,  __magic_name__    ,  __magic_name__=False      ):
       if return_pvalue:
        lowerCamelCase		:	Optional[Any]							=      pearsonr(__magic_name__    ,  __magic_name__      )
        return {"pearsonr": results[0], "p-value": results[1]}
       else:
        return {"pearsonr": float(pearsonr(__magic_name__    ,  __magic_name__      )[0]      )}




