






'''simple docstring'''







def     _UpperCamelCase				(  snake_case__				,      snake_case__				):
      __A		 =   []
      __A		 =   len(snake_case__				)
      for i in range(snake_case__				):
            __A		 =   []
            for j in range(snake_case__				):
                  __A		 =   0
                  for k in range(snake_case__				):
                        __A		 =   val + matrix_a[i][k] * matrix_b[k][j]
                  list_a.append(snake_case__				)
            matrix_c.append(snake_case__				)
      return matrix_c


def     _UpperCamelCase				(  snake_case__				):
      return [[int(row == column				) for column in range(snake_case__				)] for row in range(snake_case__				)]


def     _UpperCamelCase				(  snake_case__				):
      if n <= 1:
            return n
      __A		 =   identity(2				)
      __A		 =   [[1, 1], [1, 0]]
      __A		 =   n - 1
      while n > 0:
            if n % 2 == 1:
                  __A		 =   multiply(snake_case__				,      snake_case__				)
            __A		 =   multiply(snake_case__				,      snake_case__				)
            __A		 =   int(n / 2				)
      return res_matrix[0][0]


def     _UpperCamelCase				(  snake_case__				):
      if n <= 1:
            return n
      __A		 =   0
      __A		 =   1
      for _ in range(2				,      n + 1				):
            __A ,					__A		 =   fiba, fiba + fiba
      return fiba


def     _UpperCamelCase				(  ):
      for ordinal in "0th 1st 2nd 3rd 10th 100th 1000th".split():
            __A		 =   int("".join(c for c in ordinal if c in "0123456789"				)				)  # 1000th --> 1000
            print(
                f"{ordinal} fibonacci number using matrix exponentiation is "
                f"{nth_fibonacci_matrix(snake_case__				)} and using bruteforce is "
                f"{nth_fibonacci_bruteforce(snake_case__				)}\n"				)
      # from timeit import timeit
      # print(timeit("nth_fibonacci_matrix(1000000)",
      #              "from main import nth_fibonacci_matrix", number=5))
      # print(timeit("nth_fibonacci_bruteforce(1000000)",
      #              "from main import nth_fibonacci_bruteforce", number=5))
      # 2.3342058970001744
      # 57.256506615000035


if __name__ == "__main__":
       import doctest

       doctest.testmod()
       main()










'''simple docstring'''







import torch

from diffusers import KDPMaAncestralDiscreteScheduler
from diffusers.utils import torch_device

from .test_schedulers import SchedulerCommonTest






class        a__     (      lowerCamelCase    ):
     '''simple docstring'''







     _snake_case							   =	(KDPMaAncestralDiscreteScheduler,)
     _snake_case							   =	10






     def      _UpperCamelCase (self     :						int					,					**lowercase__     :						Optional[int]       )	->							Dict:
           __A		 =   {
               "num_train_timesteps": 1100,
               "beta_start": 0.00_01,
               "beta_end": 0.02,
               "beta_schedule": "linear",
           }

           config.update(**lowercase__       )
           return config






     def      _UpperCamelCase (self     :						str       )	->							Optional[Any]:
           for timesteps in [10, 50, 100, 1000]:
                 self.check_over_configs(num_train_timesteps=lowercase__       )






     def      _UpperCamelCase (self     :						List[Any]       )	->							int:
           for beta_start, beta_end in zip([0.0_00_01, 0.00_01, 0.0_01]					,					[0.00_02, 0.0_02, 0.02]       ):
                 self.check_over_configs(beta_start=lowercase__					,					beta_end=lowercase__       )






     def      _UpperCamelCase (self     :						int       )	->							Tuple:
           for schedule in ["linear", "scaled_linear"]:
                 self.check_over_configs(beta_schedule=lowercase__       )






     def      _UpperCamelCase (self     :						int       )	->							Any:
           if torch_device == "mps":
                 return
           __A		 =   self.scheduler_classes[0]
           __A		 =   self.get_scheduler_config()
           __A		 =   scheduler_class(**lowercase__       )

           scheduler.set_timesteps(self.num_inference_steps       )

           __A		 =   torch.manual_seed(0       )

           __A		 =   self.dummy_model()
           __A		 =   self.dummy_sample_deter * scheduler.init_noise_sigma
           __A		 =   sample.to(lowercase__       )

           for i, t in enumerate(scheduler.timesteps       ):
                 __A		 =   scheduler.scale_model_input(lowercase__					,					lowercase__       )

                 __A		 =   model(lowercase__					,					lowercase__       )

                 __A		 =   scheduler.step(lowercase__					,					lowercase__					,					lowercase__					,					generator=lowercase__       )
                 __A		 =   output.prev_sample

           __A		 =   torch.sum(torch.abs(lowercase__       )       )
           __A		 =   torch.mean(torch.abs(lowercase__       )       )

           assert abs(result_sum.item() - 1_38_49.38_77       ) < 1e-2
           assert abs(result_mean.item() - 18.03_31       ) < 5e-3






     def      _UpperCamelCase (self     :						Optional[Any]       )	->							str:
           for prediction_type in ["epsilon", "v_prediction"]:
                 self.check_over_configs(prediction_type=lowercase__       )






     def      _UpperCamelCase (self     :						List[Any]       )	->							List[Any]:
           if torch_device == "mps":
                 return
           __A		 =   self.scheduler_classes[0]
           __A		 =   self.get_scheduler_config(prediction_type="v_prediction"       )
           __A		 =   scheduler_class(**lowercase__       )

           scheduler.set_timesteps(self.num_inference_steps       )

           __A		 =   self.dummy_model()
           __A		 =   self.dummy_sample_deter * scheduler.init_noise_sigma
           __A		 =   sample.to(lowercase__       )

           __A		 =   torch.manual_seed(0       )

           for i, t in enumerate(scheduler.timesteps       ):
                 __A		 =   scheduler.scale_model_input(lowercase__					,					lowercase__       )

                 __A		 =   model(lowercase__					,					lowercase__       )

                 __A		 =   scheduler.step(lowercase__					,					lowercase__					,					lowercase__					,					generator=lowercase__       )
                 __A		 =   output.prev_sample

           __A		 =   torch.sum(torch.abs(lowercase__       )       )
           __A		 =   torch.mean(torch.abs(lowercase__       )       )

           assert abs(result_sum.item() - 3_28.99_70       ) < 1e-2
           assert abs(result_mean.item() - 0.42_84       ) < 1e-3






     def      _UpperCamelCase (self     :						Optional[Any]       )	->							int:
           if torch_device == "mps":
                 return
           __A		 =   self.scheduler_classes[0]
           __A		 =   self.get_scheduler_config()
           __A		 =   scheduler_class(**lowercase__       )

           scheduler.set_timesteps(self.num_inference_steps					,					device=lowercase__       )
           __A		 =   torch.manual_seed(0       )

           __A		 =   self.dummy_model()
           __A		 =   self.dummy_sample_deter.to(lowercase__       ) * scheduler.init_noise_sigma

           for t in scheduler.timesteps:
                 __A		 =   scheduler.scale_model_input(lowercase__					,					lowercase__       )

                 __A		 =   model(lowercase__					,					lowercase__       )

                 __A		 =   scheduler.step(lowercase__					,					lowercase__					,					lowercase__					,					generator=lowercase__       )
                 __A		 =   output.prev_sample

           __A		 =   torch.sum(torch.abs(lowercase__       )       )
           __A		 =   torch.mean(torch.abs(lowercase__       )       )

           assert abs(result_sum.item() - 1_38_49.38_18       ) < 1e-1
           assert abs(result_mean.item() - 18.03_31       ) < 1e-3


