'''simple docstring'''




def 						__snake_case (       lowerCAmelCase      ,  lowerCAmelCase			):
 # "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(snake_case__      ,  snake_case__      ,  snake_case__			)
 __UpperCAmelCase         =					0.0
 y += (h / 3.0) * f(snake_case__			)
 __UpperCAmelCase         =					2
 for i in x_i:
  y += (h / 3) * (4 - 2 * (cnt % 2)) * f(snake_case__			)
  cnt += 1
 y += (h / 3.0) * f(snake_case__			)
 return y



def 						__snake_case (       lowerCAmelCase      ,  lowerCAmelCase      ,  lowerCAmelCase			):
 __UpperCAmelCase         =					a + h
 while x < (b - h):
  yield x
  __UpperCAmelCase         =					x + h



def 						__snake_case (       lowerCAmelCase			):  # enter your function here
 __UpperCAmelCase         =					(x - 0) * (x - 0)
 return y



def 						__snake_case (       ):
 __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(snake_case__      ,  snake_case__			)
 print(F"""y = {y}"""			)


if __name__ == "__main__":
     main()




'''simple docstring'''




from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_torch_available,
)


_UpperCamelCase				:		int       			=		{
    'configuration_align': [
        'ALIGN_PRETRAINED_CONFIG_ARCHIVE_MAP',
        'AlignConfig',
        'AlignTextConfig',
        'AlignVisionConfig',
    ],
    'processing_align': ['AlignProcessor'],
}

try:
     if not is_torch_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     _UpperCamelCase				:		Optional[Any]       			=		[
         'ALIGN_PRETRAINED_MODEL_ARCHIVE_LIST',
         'AlignModel',
         'AlignPreTrainedModel',
         'AlignTextModel',
         'AlignVisionModel',
     ]

if TYPE_CHECKING:
     from .configuration_align import (
         ALIGN_PRETRAINED_CONFIG_ARCHIVE_MAP,
         AlignConfig,
         AlignTextConfig,
         AlignVisionConfig,
     )
     from .processing_align import AlignProcessor

     try:
          if not is_torch_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .modeling_align import (
              ALIGN_PRETRAINED_MODEL_ARCHIVE_LIST,
              AlignModel,
              AlignPreTrainedModel,
              AlignTextModel,
              AlignVisionModel,
          )

else:
     import sys

     _UpperCamelCase				:		str       			=		_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)



