





from typing import TYPE_CHECKING

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


__lowerCamelCase       :     List[str]   =     {
    """configuration_whisper""": ["""WHISPER_PRETRAINED_CONFIG_ARCHIVE_MAP""", """WhisperConfig""", """WhisperOnnxConfig"""],
    """feature_extraction_whisper""": ["""WhisperFeatureExtractor"""],
    """processing_whisper""": ["""WhisperProcessor"""],
    """tokenization_whisper""": ["""WhisperTokenizer"""],
}

try:
    if not is_tokenizers_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    __lowerCamelCase       :     Dict   =     ["""WhisperTokenizerFast"""]

try:
    if not is_torch_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    __lowerCamelCase       :     Union[str, Any]   =     [
        """WHISPER_PRETRAINED_MODEL_ARCHIVE_LIST""",
        """WhisperForConditionalGeneration""",
        """WhisperModel""",
        """WhisperPreTrainedModel""",
        """WhisperForAudioClassification""",
    ]

try:
    if not is_tf_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    __lowerCamelCase       :     Dict   =     [
        """TF_WHISPER_PRETRAINED_MODEL_ARCHIVE_LIST""",
        """TFWhisperForConditionalGeneration""",
        """TFWhisperModel""",
        """TFWhisperPreTrainedModel""",
    ]

try:
    if not is_flax_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    __lowerCamelCase       :     Any   =     [
        """FlaxWhisperForConditionalGeneration""",
        """FlaxWhisperModel""",
        """FlaxWhisperPreTrainedModel""",
        """FlaxWhisperForAudioClassification""",
    ]


if TYPE_CHECKING:
    from .configuration_whisper import WHISPER_PRETRAINED_CONFIG_ARCHIVE_MAP, WhisperConfig, WhisperOnnxConfig
    from .feature_extraction_whisper import WhisperFeatureExtractor
    from .processing_whisper import WhisperProcessor
    from .tokenization_whisper import WhisperTokenizer

    try:
        if not is_tokenizers_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .tokenization_whisper_fast import WhisperTokenizerFast

    try:
        if not is_torch_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .modeling_whisper import (
            WHISPER_PRETRAINED_MODEL_ARCHIVE_LIST,
            WhisperForAudioClassification,
            WhisperForConditionalGeneration,
            WhisperModel,
            WhisperPreTrainedModel,
        )

    try:
        if not is_tf_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .modeling_tf_whisper import (
            TF_WHISPER_PRETRAINED_MODEL_ARCHIVE_LIST,
            TFWhisperForConditionalGeneration,
            TFWhisperModel,
            TFWhisperPreTrainedModel,
        )

    try:
        if not is_flax_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .modeling_flax_whisper import (
            FlaxWhisperForAudioClassification,
            FlaxWhisperForConditionalGeneration,
            FlaxWhisperModel,
            FlaxWhisperPreTrainedModel,
        )

else:
    import sys

    __lowerCamelCase       :     Any   =     _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)




from math import sqrt

import numpy as np
from sympy import symbols

# Coefficient
# Speed of light (m/s)
_snake_case             =     2_99_79_24_58

# Symbols
_snake_case      ,       _snake_case      ,       _snake_case      ,       _snake_case             =     symbols('''ct x y z''')






def 		lowercase_(  SCREAMING_SNAKE_CASE_	):


  '''simple docstring'''

  if velocity > c:
    raise ValueError("Speed must not exceed light speed 299,792,458 [m/s]!"	)
  elif velocity < 1:
    # Usually the speed should be much higher than 1 (c order of magnitude)
    raise ValueError("Speed must be greater than or equal to 1!"	)

  return velocity / c






def 		lowercase_(  SCREAMING_SNAKE_CASE_	):


  '''simple docstring'''

  return 1 / sqrt(1 - beta(SCREAMING_SNAKE_CASE_	) ** 2	)






def 		lowercase_(  SCREAMING_SNAKE_CASE_	):


  '''simple docstring'''

  return np.array(
      [
          [gamma(SCREAMING_SNAKE_CASE_	), -gamma(SCREAMING_SNAKE_CASE_	) * beta(SCREAMING_SNAKE_CASE_	), 0, 0],
          [-gamma(SCREAMING_SNAKE_CASE_	) * beta(SCREAMING_SNAKE_CASE_	), gamma(SCREAMING_SNAKE_CASE_	), 0, 0],
          [0, 0, 1, 0],
          [0, 0, 0, 1],
      ]	)






def 		lowercase_(  SCREAMING_SNAKE_CASE_      ,						SCREAMING_SNAKE_CASE_ = None	):


  '''simple docstring'''

  if event is None:
    lowerCamelCase :					Tuple    =				np.array([ct, x, y, z]	)  # Symbolic four vector
  else:
    event[0] *= c  # x0 is ct (speed of light * time)

  return transformation_matrix(SCREAMING_SNAKE_CASE_	) @ event


if __name__ == "__main__":
   import doctest

   doctest.testmod()

   # Example of symbolic vector:
   _snake_case             =     transform(29_97_92_45)
   print('''Example of four vector: ''')
   print(f'''ct\' = {four_vector[0]}''')
   print(f'''x\' = {four_vector[1]}''')
   print(f'''y\' = {four_vector[2]}''')
   print(f'''z\' = {four_vector[3]}''')

   # Substitute symbols with numerical values
   _snake_case             =     {ct: c, x: 1, y: 1, z: 1}
   _snake_case             =     [four_vector[i].subs(sub_dict) for i in range(4)]

   print(f'''\n{numerical_vector}''')



