




def       __magic_name__    (			A		: list       ):






			'''simple docstring'''







			if not isinstance(A,  A       ):
						raise ValueError("Input series is not valid, valid series - [1, 2/3, 2]"       )
			if len(A       ) == 0:
						raise ValueError("Input list must be a non empty list"       )
			if len(A       ) == 1 and series[0] != 0:
						return True
			a   =      []
			a   =      len(A       )
			for i in range(0,  A       ):
						if series[i] == 0:
									raise ValueError("Input series cannot have 0 as an element"       )
						rec_series.append(1 / series[i]       )
			a   =      rec_series[1] - rec_series[0]
			for index in range(2,  A       ):
						if rec_series[index] - rec_series[index - 1] != common_diff:
									return False
			return True




def       __magic_name__    (			A		: list       ):






			'''simple docstring'''







			if not isinstance(A,  A       ):
						raise ValueError("Input series is not valid, valid series - [2, 4, 6]"       )
			if len(A       ) == 0:
						raise ValueError("Input list must be a non empty list"       )
			a   =      0
			for val in series:
						answer += 1 / val
			return len(A       ) / answer


if __name__ == "__main__":
		import doctest

		doctest.testmod()












import torch
import torch.nn.functional as F

from diffusers import VQDiffusionScheduler

from .test_schedulers import SchedulerCommonTest




class    snake_case__							(_UpperCamelCase       ):
				"""simple docstring"""



				SCREAMING_SNAKE_CASE_	:							Dict										= (VQDiffusionScheduler,)





				def 							__UpperCAmelCase							(				self    :					Tuple ,				**__lowerCamelCase    :					Optional[int]							) ->					Optional[Any]:
							a   =      {
							    "num_vec_classes": 40_97,
							    "num_train_timesteps": 1_00,
							}

							config.update(**__lowerCamelCase							)
							return config





				def 							__UpperCAmelCase							(				self    :					List[str] ,				__lowerCamelCase    :					Any							) ->					Union[str, Any]:
							a   =      4
							a   =      8
							a   =      8

							a   =      torch.randint(0 ,				__lowerCamelCase ,				(batch_size, height * width)							)

							return sample





				@property
				def 							__UpperCAmelCase							(				self    :					List[str]							) ->					Optional[Any]:
							assert False





				def 							__UpperCAmelCase							(				self    :					Any ,				__lowerCamelCase    :					Optional[int]							) ->					int:
							def model(__lowerCamelCase    :					Tuple ,				__lowerCamelCase    :					Any ,				*__lowerCamelCase    :					Optional[Any]							):
										a   ,		a   =      sample.shape
										a   =      torch.rand((batch_size, num_vec_classes - 1, num_latent_pixels)							)
										a   =      F.log_softmax(logits.double() ,				dim=1							).float()
										return return_value

							return model





				def 							__UpperCAmelCase							(				self    :					Optional[Any]							) ->					Any:
							for timesteps in [2, 5, 1_00, 10_00]:
										self.check_over_configs(num_train_timesteps=__lowerCamelCase							)





				def 							__UpperCAmelCase							(				self    :					Any							) ->					List[Any]:
							for num_vec_classes in [5, 1_00, 10_00, 40_00]:
										self.check_over_configs(num_vec_classes=__lowerCamelCase							)





				def 							__UpperCAmelCase							(				self    :					Optional[Any]							) ->					List[Any]:
							for t in [0, 50, 99]:
										self.check_over_forward(time_step=__lowerCamelCase							)





				def 							__UpperCAmelCase							(				self    :					List[Any]							) ->					Optional[Any]:
							pass






