






import numpy as np




class 				__A     :





				"""simple docstring"""







				def __init__( self							,  lowerCamelCase__=None							,  lowerCamelCase__=None							,  lowerCamelCase__=None							,  lowerCamelCase__=None							,  lowerCamelCase__=None    ):




									"""simple docstring"""

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


				def       __lowercase							( self							,  lowerCamelCase__=None							,  lowerCamelCase__=None							,  lowerCamelCase__=None							,  lowerCamelCase__=None							,  lowerCamelCase__=None    ):




									"""simple docstring"""

									if red is not None:
														__UpperCamelCase      :					Dict       		=red
									if green is not None:
														__UpperCamelCase      :					List[Any]       		=green
									if blue is not None:
														__UpperCamelCase      :					Optional[Any]       		=blue
									if red_edge is not None:
														__UpperCamelCase      :					Optional[Any]       		=red_edge
									if nir is not None:
														__UpperCamelCase      :					Optional[Any]       		=nir
									return True


				def       __lowercase							( self							,  lowerCamelCase__=""							,  lowerCamelCase__=None							,  lowerCamelCase__=None							,  lowerCamelCase__=None							,  lowerCamelCase__=None							,  lowerCamelCase__=None    ):




									"""simple docstring"""

									self.set_matricies(red=_UpperCAmelCase							,  green=_UpperCAmelCase							,  blue=_UpperCAmelCase							,  red_edge=_UpperCAmelCase							,  nir=_UpperCAmelCase    )
									__UpperCamelCase      :					Optional[int]       		={
									    '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       __lowercase							( self    ):




									"""simple docstring"""

									return -0.18 + (1.17 * ((self.nir - self.red) / (self.nir + self.red)))


				def       __lowercase							( self    ):




									"""simple docstring"""

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


				def       __lowercase							( self    ):




									"""simple docstring"""

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


				def       __lowercase							( self    ):




									"""simple docstring"""

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


				def       __lowercase							( self    ):




									"""simple docstring"""

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


				def       __lowercase							( self    ):




									"""simple docstring"""

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


				def       __lowercase							( self    ):




									"""simple docstring"""

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


				def       __lowercase							( self    ):




									"""simple docstring"""

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


				def       __lowercase							( self    ):




									"""simple docstring"""

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


				def       __lowercase							( self    ):




									"""simple docstring"""

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


				def       __lowercase							( self    ):




									"""simple docstring"""

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


				def       __lowercase							( self    ):




									"""simple docstring"""

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


				def       __lowercase							( self							,  lowerCamelCase__=0.08							,  lowerCamelCase__=1.22							,  lowerCamelCase__=0.03    ):




									"""simple docstring"""

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


				def       __lowercase							( self    ):




									"""simple docstring"""

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


				def       __lowercase							( self    ):




									"""simple docstring"""

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


				def       __lowercase							( self    ):




									"""simple docstring"""

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


				def       __lowercase							( self    ):




									"""simple docstring"""

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


				def       __lowercase							( self    ):




									"""simple docstring"""

									__UpperCamelCase      :					Dict       		=self.ndvi()
									return ((ndvi + 0.5) / (abs(ndvi + 0.5    ))) * (abs(ndvi + 0.5    ) ** (1 / 2))


				def       __lowercase							( self    ):




									"""simple docstring"""

									return self.nir - self.green


				def       __lowercase							( self    ):




									"""simple docstring"""

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


				def       __lowercase							( self    ):




									"""simple docstring"""

									__UpperCamelCase      :					Tuple       		=(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.25 * n) - (self.red - 0.125) / (1 - self.red)


				def       __lowercase							( self							,  lowerCamelCase__=0.16    ):




									"""simple docstring"""

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


				def       __lowercase							( self							,  lowerCamelCase__=0.5    ):




									"""simple docstring"""

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


				def       __lowercase							( self    ):




									"""simple docstring"""

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


				def       __lowercase							( self							,  lowerCamelCase__=None							,  lowerCamelCase__=None    ):




									"""simple docstring"""

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


				def       __lowercase							( self    ):




									"""simple docstring"""

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


				def       __lowercase							( self    ):




									"""simple docstring"""

									return (self.red + self.green + self.blue) / 30.5


				def       __lowercase							( self    ):




									"""simple docstring"""

									return self.nir / self.red


				def       __lowercase							( self    ):




									"""simple docstring"""

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


				def       __lowercase							( self    ):




									"""simple docstring"""

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


				def       __lowercase							( self    ):




									"""simple docstring"""

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


				def       __lowercase							( self    ):




									"""simple docstring"""

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


				def       __lowercase							( self    ):




									"""simple docstring"""

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


				def       __lowercase							( self    ):




									"""simple docstring"""

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


				def       __lowercase							( self    ):




									"""simple docstring"""

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


				def       __lowercase							( self    ):




									"""simple docstring"""

									__UpperCamelCase      :					Union[str, Any]       		=np.max([np.max(self.red    ), np.max(self.green    ), np.max(self.blue    )]    )
									__UpperCamelCase      :					Dict       		=np.min([np.min(self.red    ), np.min(self.green    ), np.min(self.blue    )]    )
									return (max_value - min_value) / max_value


				def       __lowercase							( self    ):




									"""simple docstring"""

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


				def       __lowercase							( self    ):




									"""simple docstring"""

									return self.nir / self.red


				def       __lowercase							( self    ):




									"""simple docstring"""

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







				def       __lowercase							( self    ):




									"""simple docstring"""

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








'''simple docstring'''




import json
from typing import Iterator, List, Union

from tokenizers import AddedToken, Regex, Tokenizer, decoders, normalizers, pre_tokenizers, trainers
from tokenizers.implementations.base_tokenizer import BaseTokenizer
from tokenizers.models import Unigram
from tokenizers.processors import TemplateProcessing


class  SCREAMING_SNAKE_CASE    (a__							):


     def __init__(						self						,	_UpperCAmelCase = "▁"						,	_UpperCAmelCase = True						,	_UpperCAmelCase = "<unk>"						,	_UpperCAmelCase = "</s>"						,	_UpperCAmelCase = "<pad>"						,	):

          '''simple docstring'''






          __A						: Dict      =       {
              'pad': {'id': 0, 'token': pad_token},
              'eos': {'id': 1, 'token': eos_token},
              'unk': {'id': 2, 'token': unk_token},
          }

          __A						: List[Any]      =       [None] * len(self.special_tokens)
          for token_dict in self.special_tokens.values():
               __A						: List[str]      =       token_dict['token']

          __A						: str      =       Tokenizer(Unigram())

          __A						: Dict      =       normalizers.Sequence(
              [
                  normalizers.Nmt(),
                  normalizers.NFKC(),
                  normalizers.Replace(Regex(' {2,}')						,	' '),
                  normalizers.Lowercase(),
              ])
          __A						: Union[str, Any]      =       pre_tokenizers.Sequence(
              [
                  pre_tokenizers.Metaspace(replacement=_UpperCAmelCase						,	add_prefix_space=_UpperCAmelCase),
                  pre_tokenizers.Digits(individual_digits=_UpperCAmelCase),
                  pre_tokenizers.Punctuation(),
              ])
          __A						: Any      =       decoders.Metaspace(replacement=_UpperCAmelCase						,	add_prefix_space=_UpperCAmelCase)

          __A						: Dict      =       TemplateProcessing(
              single=F'$A {self.special_tokens["eos"]["token"]}'						,	special_tokens=[(self.special_tokens['eos']['token'], self.special_tokens['eos']['id'])]						,	)

          __A						: Any      =       {
              'model': 'SentencePieceUnigram',
              'replacement': replacement,
              'add_prefix_space': add_prefix_space,
          }

          super().__init__(_UpperCAmelCase						,	_UpperCAmelCase)


     def 							SCREAMING_SNAKE_CASE  (						self						,	_UpperCAmelCase						,	_UpperCAmelCase = 8000						,	_UpperCAmelCase = True						,	):

          '''simple docstring'''






          __A						: str      =       trainers.UnigramTrainer(
              vocab_size=_UpperCAmelCase						,	special_tokens=self.special_tokens_list						,	show_progress=_UpperCAmelCase						,	)

          if isinstance(_UpperCAmelCase						,	_UpperCAmelCase):
               __A						: Union[str, Any]      =       [files]
          self._tokenizer.train(_UpperCAmelCase						,	trainer=_UpperCAmelCase)

          self.add_unk_id()


     def 							SCREAMING_SNAKE_CASE  (						self						,	_UpperCAmelCase						,	_UpperCAmelCase = 8000						,	_UpperCAmelCase = True						,	):

          '''simple docstring'''






          __A						: Dict      =       trainers.UnigramTrainer(
              vocab_size=_UpperCAmelCase						,	special_tokens=self.special_tokens_list						,	show_progress=_UpperCAmelCase						,	)

          self._tokenizer.train_from_iterator(_UpperCAmelCase						,	trainer=_UpperCAmelCase)

          self.add_unk_id()


     def 							SCREAMING_SNAKE_CASE  (						self):

          '''simple docstring'''






          __A						: Any      =       json.loads(self._tokenizer.to_str())

          __A						: Union[str, Any]      =       self.special_tokens['unk']['id']

          __A						: str      =       Tokenizer.from_str(json.dumps(_UpperCAmelCase))