






"""simple docstring"""







from __future__ import annotations

import numpy as np
from numpy import floataa
from numpy.typing import NDArray


def      UpperCamelCase       ( _A  ,				_A  ,				_A  ,				_A  ,				)     ->       Union[str, Any]:
				lowercase      ,      lowercase    :      List[Any]       = coefficient_matrix.shape
				lowercase      ,      lowercase    :      Optional[int]       = constant_matrix.shape

				if rowsa != colsa:
								lowercase    :      Tuple       = F"""Coefficient matrix dimensions must be nxn but received {rowsa}x{colsa}"""
								raise ValueError(__a )

				if colsa != 1:
								lowercase    :      Optional[Any]       = F"""Constant matrix must be nx1 but received {rowsa}x{colsa}"""
								raise ValueError(__a )

				if rowsa != rowsa:
								lowercase    :      Dict       = (
								    """Coefficient and constant matrices dimensions must be nxn and nx1 but """
								    F"""received {rowsa}x{colsa} and {rowsa}x{colsa}"""
								)
								raise ValueError(__a )

				if len(__a ) != rowsa:
								lowercase    :      Union[str, Any]       = (
								    """Number of initial values must be equal to number of rows in coefficient """
								    F"""matrix but received {len(__a )} and {rowsa}"""
								)
								raise ValueError(__a )

				if iterations <= 0:
								raise ValueError("""Iterations must be at least 1""" )

				lowercase    :      Optional[Any]       = np.concatenate(
				    (coefficient_matrix, constant_matrix)  ,				axis=1 )

				lowercase      ,      lowercase    :      Union[str, Any]       = table.shape

				strictly_diagonally_dominant(__a )

				# Iterates the whole matrix for given number of times
				for _ in range(__a ):
								lowercase    :      int       = []
								for row in range(__a ):
												lowercase    :      Optional[Any]       = 0
												for col in range(__a ):
																if col == row:
																				lowercase    :      Any       = table[row][col]
																elif col == cols - 1:
																				lowercase    :      Dict       = table[row][col]
																else:
																				temp += (-1) * table[row][col] * init_val[col]
												lowercase    :      Tuple       = (temp + val) / denom
												new_val.append(__a )
								lowercase    :      Any       = new_val

				return [float(__a ) for i in new_val]


def      UpperCamelCase       ( _A )     ->       Any:
				lowercase      ,      lowercase    :      int       = table.shape

				lowercase    :      Tuple       = True

				for i in range(0  ,				__a ):
								lowercase    :      str       = 0
								for j in range(0  ,				cols - 1 ):
												if i == j:
																continue
												else:
																total += table[i][j]

								if table[i][i] <= total:
												raise ValueError("""Coefficient matrix is not strictly diagonally dominant""" )

				return is_diagonally_dominant


# Test Cases
if __name__ == "__main__":
				import doctest

				doctest.testmod()




from typing import List, Optional

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


_lowerCAmelCase:						List[Any]   				=       logging.get_logger(__name__)

_lowerCAmelCase:						Any   				=       {
    'huggingface/autoformer-tourism-monthly': 'https://huggingface.co/huggingface/autoformer-tourism-monthly/resolve/main/config.json',
}




class       lowercase_					(lowercase__   ):
				snake_case	    ='autoformer'
				snake_case	    ={
				    'hidden_size': 'd_model',
				    'num_attention_heads': 'encoder_attention_heads',
				    'num_hidden_layers': 'encoder_layers',
				}





				def __init__(				self       ,  lowercase_ = None       ,  lowercase_ = None       ,  lowercase_ = "student_t"       ,  lowercase_ = "nll"       ,  lowercase_ = 1       ,  lowercase_ = [1, 2, 3, 4, 5, 6, 7]       ,  lowercase_ = True       ,  lowercase_ = 0       ,  lowercase_ = 0       ,  lowercase_ = 0       ,  lowercase_ = 0       ,  lowercase_ = None       ,  lowercase_ = None       ,  lowercase_ = 64       ,  lowercase_ = 2       ,  lowercase_ = 2       ,  lowercase_ = 2       ,  lowercase_ = 2       ,  lowercase_ = 32       ,  lowercase_ = 32       ,  lowercase_ = "gelu"       ,  lowercase_ = 0.1       ,  lowercase_ = 0.1       ,  lowercase_ = 0.1       ,  lowercase_ = 0.1       ,  lowercase_ = 0.1       ,  lowercase_ = 100       ,  lowercase_ = 0.02       ,  lowercase_ = True       ,  lowercase_=True       ,  lowercase_ = 10       ,  lowercase_ = 25       ,  lowercase_ = 3       ,  **lowercase_       ,  )  -> Union[str, Any]:
											# time series specific configuration
											a__      =prediction_length
											a__      =context_length if context_length is not None else prediction_length
											a__      =distribution_output
											a__      =loss
											a__      =input_size
											a__      =num_time_features
											a__      =lags_sequence
											a__      =scaling
											a__      =num_dynamic_real_features
											a__      =num_static_real_features
											a__      =num_static_categorical_features
											if cardinality is not None and num_static_categorical_features > 0:
																		if len(lowercase_) != num_static_categorical_features:
																									raise ValueError(
																									    'The cardinality should be a list of the same length as `num_static_categorical_features`')
																		a__      =cardinality
											else:
																		a__      =[0]
											if embedding_dimension is not None and num_static_categorical_features > 0:
																		if len(lowercase_) != num_static_categorical_features:
																									raise ValueError(
																									    'The embedding dimension should be a list of the same length as `num_static_categorical_features`')
																		a__      =embedding_dimension
											else:
																		a__      =[min(50       ,  (cat + 1) // 2) for cat in self.cardinality]
											a__      =num_parallel_samples

											# Transformer architecture configuration
											a__      =input_size * len(self.lags_sequence) + self._number_of_features
											a__      =d_model
											a__      =encoder_attention_heads
											a__      =decoder_attention_heads
											a__      =encoder_ffn_dim
											a__      =decoder_ffn_dim
											a__      =encoder_layers
											a__      =decoder_layers

											a__      =dropout
											a__      =attention_dropout
											a__      =activation_dropout
											a__      =encoder_layerdrop
											a__      =decoder_layerdrop

											a__      =activation_function
											a__      =init_std

											a__      =use_cache

											# Autoformer
											a__      =label_length
											a__      =moving_average
											a__      =autocorrelation_factor

											super().__init__(is_encoder_decoder=lowercase_       ,  **lowercase_)





				@property
				def 						__UpperCamelCase    (				self)  -> int:
											return (
											    sum(self.embedding_dimension)
											    + self.num_dynamic_real_features
											    + self.num_time_features
											    + self.num_static_real_features
											    + self.input_size * 2  # the log1p(abs(loc)) and log(scale) features
											)

