





# Imports
import numpy as np







class   __lowerCAmelCase			:





   def __init__( self					,			snake_case=None					,			snake_case=None					,			snake_case=None					,			snake_case=None					,			snake_case=None      )				->  List[str]:
      """simple docstring"""





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





   def 	_snake_case ( self					,			snake_case=None					,			snake_case=None					,			snake_case=None					,			snake_case=None					,			snake_case=None      )				->  Optional[Any]:
      """simple docstring"""





      if red is not None:
         a__	:						Optional[int]      		=  red
      if green is not None:
         a__	:						Optional[int]      		=  green
      if blue is not None:
         a__	:						int      		=  blue
      if red_edge is not None:
         a__	:						Optional[int]      		=  red_edge
      if nir is not None:
         a__	:						Any      		=  nir
      return True





   def 	_snake_case ( self					,			snake_case=""					,			snake_case=None					,			snake_case=None					,			snake_case=None					,			snake_case=None					,			snake_case=None      )				->  Union[str, Any]:
      """simple docstring"""





      self.set_matricies(red=snake_case					,			green=snake_case					,			blue=snake_case					,			red_edge=snake_case					,			nir=snake_case      )
      a__	:						List[str]      		=  {
          "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 	_snake_case ( self      )				->  Union[str, Any]:
      """simple docstring"""





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





   def 	_snake_case ( self      )				->  str:
      """simple docstring"""





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





   def 	_snake_case ( self      )				->  int:
      """simple docstring"""





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





   def 	_snake_case ( self      )				->  Dict:
      """simple docstring"""





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





   def 	_snake_case ( self      )				->  Dict:
      """simple docstring"""





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





   def 	_snake_case ( self      )				->  Tuple:
      """simple docstring"""





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





   def 	_snake_case ( self      )				->  Dict:
      """simple docstring"""





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





   def 	_snake_case ( self      )				->  Union[str, Any]:
      """simple docstring"""





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





   def 	_snake_case ( self      )				->  Optional[Any]:
      """simple docstring"""





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





   def 	_snake_case ( self      )				->  Union[str, Any]:
      """simple docstring"""





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





   def 	_snake_case ( self      )				->  str:
      """simple docstring"""





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





   def 	_snake_case ( self      )				->  Tuple:
      """simple docstring"""





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





   def 	_snake_case ( self					,			snake_case=0.08					,			snake_case=1.22					,			snake_case=0.03      )				->  Dict:
      """simple docstring"""





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





   def 	_snake_case ( self      )				->  str:
      """simple docstring"""





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





   def 	_snake_case ( self      )				->  Union[str, Any]:
      """simple docstring"""





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





   def 	_snake_case ( self      )				->  Optional[Any]:
      """simple docstring"""





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





   def 	_snake_case ( self      )				->  str:
      """simple docstring"""





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





   def 	_snake_case ( self      )				->  List[str]:
      """simple docstring"""





      a__	:						Optional[int]      		=  self.ndvi()
      return ((ndvi + 0.5) / (abs(ndvi + 0.5      ))) * (abs(ndvi + 0.5      ) ** (1 / 2))





   def 	_snake_case ( self      )				->  Tuple:
      """simple docstring"""





      return self.nir - self.green





   def 	_snake_case ( self      )				->  Dict:
      """simple docstring"""





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





   def 	_snake_case ( self      )				->  List[str]:
      """simple docstring"""





      a__	:						List[Any]      		=  (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 	_snake_case ( self					,			snake_case=0.16      )				->  int:
      """simple docstring"""





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





   def 	_snake_case ( self					,			snake_case=0.5      )				->  int:
      """simple docstring"""





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





   def 	_snake_case ( self      )				->  Union[str, Any]:
      """simple docstring"""





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





   def 	_snake_case ( self					,			snake_case=None					,			snake_case=None      )				->  str:
      """simple docstring"""





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





   def 	_snake_case ( self      )				->  Dict:
      """simple docstring"""





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





   def 	_snake_case ( self      )				->  Optional[Any]:
      """simple docstring"""





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





   def 	_snake_case ( self      )				->  Dict:
      """simple docstring"""





      return self.nir / self.red





   def 	_snake_case ( self      )				->  Tuple:
      """simple docstring"""





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





   def 	_snake_case ( self      )				->  Union[str, Any]:
      """simple docstring"""





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





   def 	_snake_case ( self      )				->  int:
      """simple docstring"""





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





   def 	_snake_case ( self      )				->  List[str]:
      """simple docstring"""





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





   def 	_snake_case ( self      )				->  int:
      """simple docstring"""





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





   def 	_snake_case ( self      )				->  Union[str, Any]:
      """simple docstring"""





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





   def 	_snake_case ( self      )				->  int:
      """simple docstring"""





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





   def 	_snake_case ( self      )				->  List[Any]:
      """simple docstring"""





      a__	:						Optional[Any]      		=  np.max([np.max(self.red      ), np.max(self.green      ), np.max(self.blue      )]      )
      a__	:						Any      		=  np.min([np.min(self.red      ), np.min(self.green      ), np.min(self.blue      )]      )
      return (max_value - min_value) / max_value





   def 	_snake_case ( self      )				->  Dict:
      """simple docstring"""





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





   def 	_snake_case ( self      )				->  Any:
      """simple docstring"""





      return self.nir / self.red





   def 	_snake_case ( self      )				->  List[str]:
      """simple docstring"""





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





   def 	_snake_case ( self      )				->  Any:
      """simple docstring"""





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










from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


SCREAMING_SNAKE_CASE__       :			str			      =						{
    """configuration_distilbert""": [
        """DISTILBERT_PRETRAINED_CONFIG_ARCHIVE_MAP""",
        """DistilBertConfig""",
        """DistilBertOnnxConfig""",
    ],
    """tokenization_distilbert""": ["""DistilBertTokenizer"""],
}

try:
  if not is_tokenizers_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  SCREAMING_SNAKE_CASE__       :			Optional[int]			      =						["""DistilBertTokenizerFast"""]

try:
  if not is_torch_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  SCREAMING_SNAKE_CASE__       :			Tuple			      =						[
      """DISTILBERT_PRETRAINED_MODEL_ARCHIVE_LIST""",
      """DistilBertForMaskedLM""",
      """DistilBertForMultipleChoice""",
      """DistilBertForQuestionAnswering""",
      """DistilBertForSequenceClassification""",
      """DistilBertForTokenClassification""",
      """DistilBertModel""",
      """DistilBertPreTrainedModel""",
  ]

try:
  if not is_tf_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  SCREAMING_SNAKE_CASE__       :			List[Any]			      =						[
      """TF_DISTILBERT_PRETRAINED_MODEL_ARCHIVE_LIST""",
      """TFDistilBertForMaskedLM""",
      """TFDistilBertForMultipleChoice""",
      """TFDistilBertForQuestionAnswering""",
      """TFDistilBertForSequenceClassification""",
      """TFDistilBertForTokenClassification""",
      """TFDistilBertMainLayer""",
      """TFDistilBertModel""",
      """TFDistilBertPreTrainedModel""",
  ]

try:
  if not is_flax_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  SCREAMING_SNAKE_CASE__       :			Any			      =						[
      """FlaxDistilBertForMaskedLM""",
      """FlaxDistilBertForMultipleChoice""",
      """FlaxDistilBertForQuestionAnswering""",
      """FlaxDistilBertForSequenceClassification""",
      """FlaxDistilBertForTokenClassification""",
      """FlaxDistilBertModel""",
      """FlaxDistilBertPreTrainedModel""",
  ]


if TYPE_CHECKING:
  from .configuration_distilbert import (
      DISTILBERT_PRETRAINED_CONFIG_ARCHIVE_MAP,
      DistilBertConfig,
      DistilBertOnnxConfig,
  )
  from .tokenization_distilbert import DistilBertTokenizer

  try:
    if not is_tokenizers_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .tokenization_distilbert_fast import DistilBertTokenizerFast

  try:
    if not is_torch_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_distilbert import (
        DISTILBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
        DistilBertForMaskedLM,
        DistilBertForMultipleChoice,
        DistilBertForQuestionAnswering,
        DistilBertForSequenceClassification,
        DistilBertForTokenClassification,
        DistilBertModel,
        DistilBertPreTrainedModel,
    )

  try:
    if not is_tf_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_tf_distilbert import (
        TF_DISTILBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
        TFDistilBertForMaskedLM,
        TFDistilBertForMultipleChoice,
        TFDistilBertForQuestionAnswering,
        TFDistilBertForSequenceClassification,
        TFDistilBertForTokenClassification,
        TFDistilBertMainLayer,
        TFDistilBertModel,
        TFDistilBertPreTrainedModel,
    )

  try:
    if not is_flax_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_flax_distilbert import (
        FlaxDistilBertForMaskedLM,
        FlaxDistilBertForMultipleChoice,
        FlaxDistilBertForQuestionAnswering,
        FlaxDistilBertForSequenceClassification,
        FlaxDistilBertForTokenClassification,
        FlaxDistilBertModel,
        FlaxDistilBertPreTrainedModel,
    )

else:
  import sys

  SCREAMING_SNAKE_CASE__       :			Optional[int]			      =						_LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)

