
'''simple docstring'''
import warnings

from ...configuration_utils import PretrainedConfig
from ...utils import logging


a_											=						logging.get_logger(__name__)

a_											=						{
    "xlnet-base-cased": "https://huggingface.co/xlnet-base-cased/resolve/main/config.json",
    "xlnet-large-cased": "https://huggingface.co/xlnet-large-cased/resolve/main/config.json",
}






class    UpperCAmelCase_				(	snake_case__					):
 UpperCAmelCase_		    =						"""xlnet"""
 UpperCAmelCase_		    =						["""mems"""]
 UpperCAmelCase_		    =						{
     """n_token""": """vocab_size""",  # Backward compatibility
     """hidden_size""": """d_model""",
     """num_attention_heads""": """n_head""",
     """num_hidden_layers""": """n_layer""",
 }





 def __init__(    self ,       lowercase_=3_20_00 ,       lowercase_=10_24 ,       lowercase_=24 ,       lowercase_=16 ,       lowercase_=40_96 ,       lowercase_="gelu" ,       lowercase_=True ,       lowercase_="bi" ,       lowercase_=0.02 ,       lowercase_=1E-12 ,       lowercase_=0.1 ,       lowercase_=5_12 ,       lowercase_=None ,       lowercase_=True ,       lowercase_=False ,       lowercase_=False ,       lowercase_=-1 ,       lowercase_=False ,       lowercase_="last" ,       lowercase_=True ,       lowercase_="tanh" ,       lowercase_=0.1 ,       lowercase_=5 ,       lowercase_=5 ,       lowercase_=5 ,       lowercase_=1 ,       lowercase_=2 ,       **lowercase_ ,       ):
     snake_case_ :    Any     			=						vocab_size
     snake_case_ :    Any     			=						d_model
     snake_case_ :    Tuple     			=						n_layer
     snake_case_ :    Dict     			=						n_head
     if d_model % n_head != 0:
         raise ValueError(F'\'d_model % n_head\' ({d_model % n_head}) should be equal to 0')
     if "d_head" in kwargs:
         if kwargs["d_head"] != d_model // n_head:
             raise ValueError(
                 F'`d_head` ({kwargs["d_head"]}) should be equal to `d_model // n_head` ({d_model // n_head})')
     snake_case_ :    Any     			=						d_model // n_head
     snake_case_ :    Union[str, Any]     			=						ff_activation
     snake_case_ :    Dict     			=						d_inner
     snake_case_ :    Optional[int]     			=						untie_r
     snake_case_ :    Any     			=						attn_type

     snake_case_ :    Tuple     			=						initializer_range
     snake_case_ :    List[Any]     			=						layer_norm_eps

     snake_case_ :    str     			=						dropout
     snake_case_ :    Tuple     			=						mem_len
     snake_case_ :    Optional[Any]     			=						reuse_len
     snake_case_ :    Any     			=						bi_data
     snake_case_ :    Optional[int]     			=						clamp_len
     snake_case_ :    int     			=						same_length

     snake_case_ :    int     			=						summary_type
     snake_case_ :    Tuple     			=						summary_use_proj
     snake_case_ :    Dict     			=						summary_activation
     snake_case_ :    Optional[int]     			=						summary_last_dropout
     snake_case_ :    str     			=						start_n_top
     snake_case_ :    List[str]     			=						end_n_top

     snake_case_ :    Union[str, Any]     			=						bos_token_id
     snake_case_ :    List[Any]     			=						pad_token_id
     snake_case_ :    Any     			=						eos_token_id

     if "use_cache" in kwargs:
         warnings.warn(
             "The `use_cache` argument is deprecated and will be removed in a future version, use `use_mems_eval`"
             " instead." ,       lowercase_ ,       )
         snake_case_ :    Optional[int]     			=						kwargs["use_cache"]

     snake_case_ :    Dict     			=						use_mems_eval
     snake_case_ :    Optional[int]     			=						use_mems_train
     super().__init__(pad_token_id=lowercase_ ,       bos_token_id=lowercase_ ,       eos_token_id=lowercase_ ,       **lowercase_)





 @property
 def        snake_case__		(    self):
     logger.info(F'The model {self.model_type} is one of the few models that has no sequence length limit.')
     return -1





 @max_position_embeddings.setter
 def        snake_case__		(    self ,       lowercase_):
     # Message copied from Transformer-XL documentation
     raise NotImplementedError(
         F'The model {self.model_type} is one of the few models that has no sequence length limit.')






'''simple docstring'''
from __future__ import annotations

from cmath import sqrt

def 						UpperCamelCase_     (	__SCREAMING_SNAKE_CASE,		__SCREAMING_SNAKE_CASE,		__SCREAMING_SNAKE_CASE       ):
    """simple docstring"""






    if a == 0:
        raise ValueError("Coefficient 'a' must not be zero."       )
    snake_case_ :    Union[str, Any]     			=						b * b - 4 * a * c

    snake_case_ :    List[str]     			=						(-b + sqrt(__SCREAMING_SNAKE_CASE       )) / (2 * a)
    snake_case_ :    int     			=						(-b - sqrt(__SCREAMING_SNAKE_CASE       )) / (2 * a)

    return (
        root_a.real if not root_a.imag else root_a,
        root_a.real if not root_a.imag else root_a,
    )

def 						UpperCamelCase_     (	):
    """simple docstring"""






    snake_case_			, snake_case_ :    str     			=						quadratic_roots(a=5,		b=6,		c=1       )
    print(f'The solutions are: {solutiona} and {solutiona}'       )


if __name__ == "__main__":
  main()




