





# Imports
import numpy as np

class 		SCREAMING_SNAKE_CASE__    :


      def __init__(self	:				List[Any]    ,      a__	:				Dict=None    ,      a__	:				Union[str, Any]=None    ,      a__	:				str=None    ,      a__	:				Optional[int]=None    ,      a__	:				Any=None				):





         """simple docstring"""



         self.set_matricies(red=a__    ,      green=a__    ,      blue=a__    ,      red_edge=a__    ,      nir=a__				)


      def        a			(self	:				Optional[int]    ,      a__	:				Optional[int]=None    ,      a__	:				Any=None    ,      a__	:				Dict=None    ,      a__	:				Optional[Any]=None    ,      a__	:				str=None				):





         """simple docstring"""



         if red is not None:
            __snake_case								=       red
         if green is not None:
            __snake_case								=       green
         if blue is not None:
            __snake_case								=       blue
         if red_edge is not None:
            __snake_case								=       red_edge
         if nir is not None:
            __snake_case								=       nir
         return True


      def        a			(self	:				Any    ,      a__	:				Dict=""    ,      a__	:				List[str]=None    ,      a__	:				Union[str, Any]=None    ,      a__	:				List[str]=None    ,      a__	:				Optional[Any]=None    ,      a__	:				Tuple=None				):





         """simple docstring"""



         self.set_matricies(red=a__    ,      green=a__    ,      blue=a__    ,      red_edge=a__    ,      nir=a__				)
         __snake_case								=       {
             '''ARVI2''': self.arvaa,
             '''CCCI''': self.ccci,
             '''CVI''': self.cvi,
             '''GLI''': self.gli,
             '''NDVI''': self.ndvi,
             '''BNDVI''': self.bndvi,
             '''redEdgeNDVI''': self.red_edge_ndvi,
             '''GNDVI''': self.gndvi,
             '''GBNDVI''': self.gbndvi,
             '''GRNDVI''': self.grndvi,
             '''RBNDVI''': self.rbndvi,
             '''PNDVI''': self.pndvi,
             '''ATSAVI''': self.atsavi,
             '''BWDRVI''': self.bwdrvi,
             '''CIgreen''': self.ci_green,
             '''CIrededge''': self.ci_rededge,
             '''CI''': self.ci,
             '''CTVI''': self.ctvi,
             '''GDVI''': self.gdvi,
             '''EVI''': self.evi,
             '''GEMI''': self.gemi,
             '''GOSAVI''': self.gosavi,
             '''GSAVI''': self.gsavi,
             '''Hue''': self.hue,
             '''IVI''': self.ivi,
             '''IPVI''': self.ipvi,
             '''I''': self.i,
             '''RVI''': self.rvi,
             '''MRVI''': self.mrvi,
             '''MSAVI''': self.m_savi,
             '''NormG''': self.norm_g,
             '''NormNIR''': self.norm_nir,
             '''NormR''': self.norm_r,
             '''NGRDI''': self.ngrdi,
             '''RI''': self.ri,
             '''S''': self.s,
             '''IF''': self._if,
             '''DVI''': self.dvi,
             '''TVI''': self.tvi,
             '''NDRE''': self.ndre,
         }

         try:
            return funcs[index]()
         except KeyError:
            print('''Index not in the list!'''				)
            return False


      def        a			(self	:				Union[str, Any]				):





         """simple docstring"""



         return -0.1_8 + (1.1_7 * ((self.nir - self.red) / (self.nir + self.red)))


      def        a			(self	:				Optional[int]				):





         """simple docstring"""



         return ((self.nir - self.redEdge) / (self.nir + self.redEdge)) / (
             (self.nir - self.red) / (self.nir + self.red)
         )


      def        a			(self	:				int				):





         """simple docstring"""



         return self.nir * (self.red / (self.green**2))


      def        a			(self	:				str				):





         """simple docstring"""



         return (2 * self.green - self.red - self.blue) / (
             2 * self.green + self.red + self.blue
         )


      def        a			(self	:				Union[str, Any]				):





         """simple docstring"""



         return (self.nir - self.red) / (self.nir + self.red)


      def        a			(self	:				List[str]				):





         """simple docstring"""



         return (self.nir - self.blue) / (self.nir + self.blue)


      def        a			(self	:				List[str]				):





         """simple docstring"""



         return (self.redEdge - self.red) / (self.redEdge + self.red)


      def        a			(self	:				Optional[Any]				):





         """simple docstring"""



         return (self.nir - self.green) / (self.nir + self.green)


      def        a			(self	:				List[Any]				):





         """simple docstring"""



         return (self.nir - (self.green + self.blue)) / (
             self.nir + (self.green + self.blue)
         )


      def        a			(self	:				int				):





         """simple docstring"""



         return (self.nir - (self.green + self.red)) / (
             self.nir + (self.green + self.red)
         )


      def        a			(self	:				Optional[Any]				):





         """simple docstring"""



         return (self.nir - (self.blue + self.red)) / (self.nir + (self.blue + self.red))


      def        a			(self	:				Any				):





         """simple docstring"""



         return (self.nir - (self.green + self.red + self.blue)) / (
             self.nir + (self.green + self.red + self.blue)
         )


      def        a			(self	:				Any    ,      a__	:				Union[str, Any]=0.0_8    ,      a__	:				Any=1.2_2    ,      a__	:				Optional[Any]=0.0_3				):





         """simple docstring"""



         return a * (
             (self.nir - a * self.red - b)
             / (a * self.nir + self.red - a * b + x * (1 + a**2))
         )


      def        a			(self	:				Tuple				):





         """simple docstring"""



         return (0.1 * self.nir - self.blue) / (0.1 * self.nir + self.blue)


      def        a			(self	:				Union[str, Any]				):





         """simple docstring"""



         return (self.nir / self.green) - 1


      def        a			(self	:				List[str]				):





         """simple docstring"""



         return (self.nir / self.redEdge) - 1


      def        a			(self	:				Optional[Any]				):





         """simple docstring"""



         return (self.red - self.blue) / self.red


      def        a			(self	:				Union[str, Any]				):





         """simple docstring"""



         __snake_case								=       self.ndvi()
         return ((ndvi + 0.5) / (abs(ndvi + 0.5				))) * (abs(ndvi + 0.5				) ** (1 / 2))


      def        a			(self	:				Optional[int]				):





         """simple docstring"""



         return self.nir - self.green


      def        a			(self	:				Any				):





         """simple docstring"""



         return 2.5 * (
             (self.nir - self.red) / (self.nir + 6 * self.red - 7.5 * self.blue + 1)
         )


      def        a			(self	:				Optional[int]				):





         """simple docstring"""



         __snake_case								=       (2 * (self.nir**2 - self.red**2) + 1.5 * self.nir + 0.5 * self.red) / (
             self.nir + self.red + 0.5
         )
         return n * (1 - 0.2_5 * n) - (self.red - 0.1_2_5) / (1 - self.red)


      def        a			(self	:				Any    ,      a__	:				List[str]=0.1_6				):





         """simple docstring"""



         return (self.nir - self.green) / (self.nir + self.green + y)


      def        a			(self	:				int    ,      a__	:				Union[str, Any]=0.5				):





         """simple docstring"""



         return ((self.nir - self.green) / (self.nir + self.green + n)) * (1 + n)


      def        a			(self	:				Any				):





         """simple docstring"""



         return np.arctan(
             ((2 * self.red - self.green - self.blue) / 3_0.5) * (self.green - self.blue)				)


      def        a			(self	:				Any    ,      a__	:				List[str]=None    ,      a__	:				Any=None				):





         """simple docstring"""



         return (self.nir - b) / (a * self.red)


      def        a			(self	:				str				):





         """simple docstring"""



         return (self.nir / ((self.nir + self.red) / 2)) * (self.ndvi() + 1)


      def        a			(self	:				Union[str, Any]				):





         """simple docstring"""



         return (self.red + self.green + self.blue) / 3_0.5


      def        a			(self	:				List[Any]				):





         """simple docstring"""



         return self.nir / self.red


      def        a			(self	:				Optional[int]				):





         """simple docstring"""



         return (self.rvi() - 1) / (self.rvi() + 1)


      def        a			(self	:				Tuple				):





         """simple docstring"""



         return (
             (2 * self.nir + 1)
             - ((2 * self.nir + 1) ** 2 - 8 * (self.nir - self.red)) ** (1 / 2)
         ) / 2


      def        a			(self	:				List[Any]				):





         """simple docstring"""



         return self.green / (self.nir + self.red + self.green)


      def        a			(self	:				List[str]				):





         """simple docstring"""



         return self.nir / (self.nir + self.red + self.green)


      def        a			(self	:				str				):





         """simple docstring"""



         return self.red / (self.nir + self.red + self.green)


      def        a			(self	:				Optional[int]				):





         """simple docstring"""



         return (self.green - self.red) / (self.green + self.red)


      def        a			(self	:				str				):





         """simple docstring"""



         return (self.red - self.green) / (self.red + self.green)


      def        a			(self	:				Tuple				):





         """simple docstring"""



         __snake_case								=       np.max([np.max(self.red				), np.max(self.green				), np.max(self.blue				)]				)
         __snake_case								=       np.min([np.min(self.red				), np.min(self.green				), np.min(self.blue				)]				)
         return (max_value - min_value) / max_value


      def        a			(self	:				Optional[int]				):





         """simple docstring"""



         return (2 * self.red - self.green - self.blue) / (self.green - self.blue)


      def        a			(self	:				Optional[Any]				):





         """simple docstring"""



         return self.nir / self.red


      def        a			(self	:				List[str]				):





         """simple docstring"""



         return (self.ndvi() + 0.5) ** (1 / 2)


      def        a			(self	:				Optional[int]				):





         """simple docstring"""



         return (self.nir - self.redEdge) / (self.nir + self.redEdge)








import re
import string

import numpy as np

import datasets


snake_case_           =      '\nReturns the rate at which the input predicted strings exactly match their references, ignoring any strings input as part of the regexes_to_ignore list.\n'

snake_case_           =      '\nArgs:\n    predictions: List of predicted texts.\n    references: List of reference texts.\n    regexes_to_ignore: List, defaults to None. Regex expressions of characters to\n        ignore when calculating the exact matches. Note: these regexes are removed\n        from the input data before the changes based on the options below (e.g. ignore_case,\n        ignore_punctuation, ignore_numbers) are applied.\n    ignore_case: Boolean, defaults to False. If true, turns everything\n        to lowercase so that capitalization differences are ignored.\n    ignore_punctuation: Boolean, defaults to False. If true, removes all punctuation before\n        comparing predictions and references.\n    ignore_numbers: Boolean, defaults to False. If true, removes all punctuation before\n        comparing predictions and references.\nReturns:\n    exact_match: Dictionary containing exact_match rate. Possible values are between 0.0 and 100.0, inclusive.\nExamples:\n    >>> exact_match = datasets.load_metric("exact_match")\n    >>> refs = ["the cat", "theater", "YELLING", "agent007"]\n    >>> preds = ["cat?", "theater", "yelling", "agent"]\n    >>> results = exact_match.compute(references=refs, predictions=preds)\n    >>> print(round(results["exact_match"], 1))\n    25.0\n\n    >>> exact_match = datasets.load_metric("exact_match")\n    >>> refs = ["the cat", "theater", "YELLING", "agent007"]\n    >>> preds = ["cat?", "theater", "yelling", "agent"]\n    >>> results = exact_match.compute(references=refs, predictions=preds, regexes_to_ignore=["the ", "yell"], ignore_case=True, ignore_punctuation=True)\n    >>> print(round(results["exact_match"], 1))\n    50.0\n\n\n    >>> exact_match = datasets.load_metric("exact_match")\n    >>> refs = ["the cat", "theater", "YELLING", "agent007"]\n    >>> preds = ["cat?", "theater", "yelling", "agent"]\n    >>> results = exact_match.compute(references=refs, predictions=preds, regexes_to_ignore=["the ", "yell", "YELL"], ignore_case=True, ignore_punctuation=True)\n    >>> print(round(results["exact_match"], 1))\n    75.0\n\n    >>> exact_match = datasets.load_metric("exact_match")\n    >>> refs = ["the cat", "theater", "YELLING", "agent007"]\n    >>> preds = ["cat?", "theater", "yelling", "agent"]\n    >>> results = exact_match.compute(references=refs, predictions=preds, regexes_to_ignore=["the ", "yell", "YELL"], ignore_case=True, ignore_punctuation=True, ignore_numbers=True)\n    >>> print(round(results["exact_match"], 1))\n    100.0\n\n    >>> exact_match = datasets.load_metric("exact_match")\n    >>> refs = ["The cat sat on the mat.", "Theaters are great.", "It\'s like comparing oranges and apples."]\n    >>> preds = ["The cat sat on the mat?", "Theaters are great.", "It\'s like comparing apples and oranges."]\n    >>> results = exact_match.compute(references=refs, predictions=preds)\n    >>> print(round(results["exact_match"], 1))\n    33.3\n\n'

snake_case_           =      '\n'

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


      def        a			(self	:				Optional[Any]				):





         """simple docstring"""



         return datasets.MetricInfo(
             description=_DESCRIPTION    ,      citation=_CITATION    ,      inputs_description=_KWARGS_DESCRIPTION    ,      features=datasets.Features(
                 {
                     '''predictions''': datasets.Value('''string'''    ,      id='''sequence'''				),
                     '''references''': datasets.Value('''string'''    ,      id='''sequence'''				),
                 }				)    ,      reference_urls=[]    ,      )


      def        a			(self	:				List[Any]    ,      a__	:				int    ,      a__	:				Optional[int]    ,      a__	:				Optional[Any]=None    ,      a__	:				Any=False    ,      a__	:				Dict=False    ,      a__	:				Tuple=False    ,      ):





         """simple docstring"""



         if regexes_to_ignore is not None:
            for s in regexes_to_ignore:
               __snake_case								=       np.array([re.sub(a__    ,      ''''''    ,      a__				) for x in predictions]				)
               __snake_case								=       np.array([re.sub(a__    ,      ''''''    ,      a__				) for x in references]				)
         else:
            __snake_case								=       np.asarray(a__				)
            __snake_case								=       np.asarray(a__				)

         if ignore_case:
            __snake_case								=       np.char.lower(a__				)
            __snake_case								=       np.char.lower(a__				)

         if ignore_punctuation:
            __snake_case								=       string.punctuation.maketrans(''''''    ,      ''''''    ,      string.punctuation				)
            __snake_case								=       np.char.translate(a__    ,      table=a__				)
            __snake_case								=       np.char.translate(a__    ,      table=a__				)

         if ignore_numbers:
            __snake_case								=       string.digits.maketrans(''''''    ,      ''''''    ,      string.digits				)
            __snake_case								=       np.char.translate(a__    ,      table=a__				)
            __snake_case								=       np.char.translate(a__    ,      table=a__				)

         __snake_case								=       predictions == references

         return {"exact_match": np.mean(a__				) * 100}

