
def 			UpperCAmelCase_     (  __lowerCAmelCase		,    __lowerCAmelCase		)       ->  str:
    if mass < 0:
        raise ValueError('''The mass of a body cannot be negative'''		)
    return 0.5 * mass * abs(UpperCamelCase__		) * abs(UpperCamelCase__		)


if __name__ == "__main__":
 import doctest

 doctest.testmod(verbose=True)






import unittest

import torch

from diffusers import VQModel
from diffusers.utils import floats_tensor, torch_device
from diffusers.utils.testing_utils import enable_full_determinism

from .test_modeling_common import ModelTesterMixin, UNetTesterMixin


enable_full_determinism()







class      lowerCAmelCase__       (				a     ,    a     ,    unittest.TestCase):




     '''simple docstring'''
     __SCREAMING_SNAKE_CASE  			= VQModel
     __SCREAMING_SNAKE_CASE  			= "sample"


     @property
     def  _lowerCamelCase (						self ,						__lowerCamelCase=(3_2, 3_2))			->				Optional[Any]:
            _A      :       Optional[int]				    = 4
            _A      :       Tuple				    = 3

            _A      :       List[Any]				    = floats_tensor((batch_size, num_channels) + sizes).to(__lowerCamelCase)

            return {"sample": image}


     @property
     def  _lowerCamelCase (						self)			->				int:
            return (3, 3_2, 3_2)


     @property
     def  _lowerCamelCase (						self)			->				List[Any]:
            return (3, 3_2, 3_2)


     def  _lowerCamelCase (						self)			->				Union[str, Any]:
            _A      :       List[Any]				    = {
                "block_out_channels": [3_2, 6_4],
                "in_channels": 3,
                "out_channels": 3,
                "down_block_types": ["DownEncoderBlock2D", "DownEncoderBlock2D"],
                "up_block_types": ["UpDecoderBlock2D", "UpDecoderBlock2D"],
                "latent_channels": 3,
            }
            _A      :       int				    = self.dummy_input
            return init_dict, inputs_dict


     def  _lowerCamelCase (						self)			->				Union[str, Any]:
            pass


     def  _lowerCamelCase (						self)			->				Any:
            pass


     def  _lowerCamelCase (						self)			->				Any:
            _A    ,			_A      :       List[Any]				    = VQModel.from_pretrained("fusing/vqgan-dummy" ,						output_loading_info=__lowerCamelCase)
            self.assertIsNotNone(__lowerCamelCase)
            self.assertEqual(len(loading_info["missing_keys"]) ,						0)

            model.to(__lowerCamelCase)
            _A      :       str				    = model(**self.dummy_input)

            assert image is not None, "Make sure output is not None"


     def  _lowerCamelCase (						self)			->				Union[str, Any]:
            _A      :       Optional[Any]				    = VQModel.from_pretrained("fusing/vqgan-dummy")
            model.to(__lowerCamelCase).eval()

            torch.manual_seed(0)
            if torch.cuda.is_available():
                   torch.cuda.manual_seed_all(0)

            _A      :       Tuple				    = torch.randn(1 ,						model.config.in_channels ,						model.config.sample_size ,						model.config.sample_size)
            _A      :       Optional[int]				    = image.to(__lowerCamelCase)
            with torch.no_grad():
                   _A      :       List[str]				    = model(__lowerCamelCase).sample

            _A      :       int				    = output[0, -1, -3:, -3:].flatten().cpu()
            # fmt: off
            _A      :       Optional[Any]				    = torch.tensor([-0.0_1_5_3, -0.4_0_4_4, -0.1_8_8_0, -0.5_1_6_1, -0.2_4_1_8, -0.4_0_7_2, -0.1_6_1_2, -0.0_6_3_3, -0.0_1_4_3])
            # fmt: on
            self.assertTrue(torch.allclose(__lowerCamelCase ,						__lowerCamelCase ,						atol=1e-3))
