

def       __a       (   SCREAMING_SNAKE_CASE       ,   SCREAMING_SNAKE_CASE      )      ->     List[str]:






    '''simple docstring'''
    # "Simpson Rule"
    # int(f) = delta_x/2 * (b-a)/3*(f1 + 4f2 + 2f_3 + ... + fn)
    __UpperCAmelCase									=			(boundary[1] - boundary[0]) / steps
    __UpperCAmelCase									=			boundary[0]
    __UpperCAmelCase									=			boundary[1]
    __UpperCAmelCase									=			make_points(SCREAMING_SNAKE_CASE       ,   SCREAMING_SNAKE_CASE       ,   SCREAMING_SNAKE_CASE      )
    __UpperCAmelCase									=			0.0
    y += (h / 3.0) * f(SCREAMING_SNAKE_CASE      )
    __UpperCAmelCase									=			2
    for i in x_i:
        y += (h / 3) * (4 - 2 * (cnt % 2)) * f(SCREAMING_SNAKE_CASE      )
        cnt += 1
    y += (h / 3.0) * f(SCREAMING_SNAKE_CASE      )
    return y


def       __a       (   SCREAMING_SNAKE_CASE       ,   SCREAMING_SNAKE_CASE       ,   SCREAMING_SNAKE_CASE      )      ->     str:






    '''simple docstring'''
    __UpperCAmelCase									=			a + h
    while x < (b - h):
        yield x
        __UpperCAmelCase									=			x + h


def       __a       (   SCREAMING_SNAKE_CASE      )      ->     Union[str, Any]:  # enter your function here






    '''simple docstring'''
    __UpperCAmelCase									=			(x - 0) * (x - 0)
    return y


def       __a       (   )      ->     List[str]:






    '''simple docstring'''
    __UpperCAmelCase									=			0.0  # Lower bound of integration
    __UpperCAmelCase									=			1.0  # Upper bound of integration
    __UpperCAmelCase									=			10.0  # define number of steps or resolution
    __UpperCAmelCase									=			[a, b]  # define boundary of integration
    __UpperCAmelCase									=			method_a(SCREAMING_SNAKE_CASE       ,   SCREAMING_SNAKE_CASE      )
    print(f'''y = {y}'''      )


if __name__ == "__main__":
       main()







import copy

from ...configuration_utils import PretrainedConfig
from ...utils import logging
from ..auto.configuration_auto import AutoConfig


A_		:			int										=   logging.get_logger(__name__)
class 					A_   (      _a						):


    '''simple docstring'''






    a__     							=       "speech-encoder-decoder"
    a__     							=       True


    def __init__(self     ,      **lowercase__  )     ->      Optional[int]:
        super().__init__(**lowercase__  )
        if "encoder" not in kwargs or "decoder" not in kwargs:
            raise ValueError(
                F'''A configuraton of type {self.model_type} cannot be instantiated because not both `encoder` and'''
                F''' `decoder` sub-configurations are passed, but only {kwargs}'''  )

        __UpperCAmelCase									=			kwargs.pop('''encoder'''  )
        __UpperCAmelCase									=			encoder_config.pop('''model_type'''  )
        __UpperCAmelCase									=			kwargs.pop('''decoder'''  )
        __UpperCAmelCase									=			decoder_config.pop('''model_type'''  )

        __UpperCAmelCase									=			AutoConfig.for_model(lowercase__     ,      **lowercase__  )
        __UpperCAmelCase									=			AutoConfig.for_model(lowercase__     ,      **lowercase__  )
        __UpperCAmelCase									=			True


    @classmethod
    def      lowerCAmelCase_						(cls     ,      lowercase__     ,      lowercase__     ,      **lowercase__  )     ->      PretrainedConfig:
        logger.info('''Setting `config.is_decoder=True` and `config.add_cross_attention=True` for decoder_config'''  )
        __UpperCAmelCase									=			True
        __UpperCAmelCase									=			True

        return cls(encoder=encoder_config.to_dict()     ,      decoder=decoder_config.to_dict()     ,      **lowercase__  )






    def      lowerCAmelCase_						(self  )     ->      Optional[Any]:
        __UpperCAmelCase									=			copy.deepcopy(self.__dict__  )
        __UpperCAmelCase									=			self.encoder.to_dict()
        __UpperCAmelCase									=			self.decoder.to_dict()
        __UpperCAmelCase									=			self.__class__.model_type
        return output




