
"""simple docstring"""

from __future__ import annotations

import math




def     lowercase__						(					lowerCAmelCase				:					int ) ->      bool:






    """simple docstring"""




    if 1 < number < 4:
        # 2 and 3 are primes
        return True
    elif number < 2 or number % 2 == 0 or number % 3 == 0:
        # Negatives, 0, 1, all even numbers, all multiples of 3 are not primes
        return False

    # All primes number are in format of 6k +/- 1
    for i in range(5 ,				int(math.sqrt(lowerCAmelCase ) + 1 ) ,				6 ):
        if number % i == 0 or number % (i + 2) == 0:
            return False
    return True




def     lowercase__						(					lowerCAmelCase				:					int ) ->      list[int]:






    """simple docstring"""




    UpperCAmelCase									=					str(lowerCAmelCase )
    UpperCAmelCase									=					[n]
    for i in range(1 ,				len(lowerCAmelCase ) ):
        list_nums.append(int(str_num[i:] ) )
        list_nums.append(int(str_num[:-i] ) )
    return list_nums




def     lowercase__						(					lowerCAmelCase				:					int ) ->      bool:






    """simple docstring"""




    if len(str(lowerCAmelCase ) ) > 3:
        if not is_prime(int(str(lowerCAmelCase )[-3:] ) ) or not is_prime(int(str(lowerCAmelCase )[:3] ) ):
            return False
    return True




def     lowercase__						(					lowerCAmelCase				:					int = 11 ) ->      list[int]:






    """simple docstring"""




    UpperCAmelCase									=					[]
    UpperCAmelCase									=					13
    while len(lowerCAmelCase ) != count:
        if validate(lowerCAmelCase ):
            UpperCAmelCase									=					list_truncated_nums(lowerCAmelCase )
            if all(is_prime(lowerCAmelCase ) for i in list_nums ):
                list_truncated_primes.append(lowerCAmelCase )
        num += 2
    return list_truncated_primes




def     lowercase__						(					) ->      int:






    """simple docstring"""




    return sum(compute_truncated_primes(11 ) )


if __name__ == "__main__":
   print(F'{sum(compute_truncated_primes(11)) = }')





"""simple docstring"""

import torch

from diffusers import DDPMScheduler

from .test_schedulers import SchedulerCommonTest
class      _UpperCAmelCase							(		SCREAMING_SNAKE_CASE_							):
      __SCREAMING_SNAKE_CASE   :							str							      =	(DDPMScheduler,)




      def     a_      (							self   ,       **lowercase_							)						->					Union[str, Any]:
          UpperCAmelCase									=					{
              'num_train_timesteps': 1_0_0_0,
              'beta_start': 0.0_0_0_1,
              'beta_end': 0.0_2,
              'beta_schedule': 'linear',
              'variance_type': 'fixed_small',
              'clip_sample': True,
          }

          config.update(**lowercase_							)
          return config




      def     a_      (							self							)						->					int:
          for timesteps in [1, 5, 1_0_0, 1_0_0_0]:
              self.check_over_configs(num_train_timesteps=lowercase_							)




      def     a_      (							self							)						->					Optional[int]:
          for beta_start, beta_end in zip([0.0_0_0_1, 0.0_0_1, 0.0_1, 0.1]   ,       [0.0_0_2, 0.0_2, 0.2, 2]							):
              self.check_over_configs(beta_start=lowercase_   ,       beta_end=lowercase_							)




      def     a_      (							self							)						->					Dict:
          for schedule in ["linear", "squaredcos_cap_v2"]:
              self.check_over_configs(beta_schedule=lowercase_							)




      def     a_      (							self							)						->					Union[str, Any]:
          for variance in ["fixed_small", "fixed_large", "other"]:
              self.check_over_configs(variance_type=lowercase_							)




      def     a_      (							self							)						->					Optional[Any]:
          for clip_sample in [True, False]:
              self.check_over_configs(clip_sample=lowercase_							)




      def     a_      (							self							)						->					Tuple:
          self.check_over_configs(thresholding=lowercase_							)
          for threshold in [0.5, 1.0, 2.0]:
              for prediction_type in ["epsilon", "sample", "v_prediction"]:
                  self.check_over_configs(
                      thresholding=lowercase_   ,       prediction_type=lowercase_   ,       sample_max_value=lowercase_   ,       )




      def     a_      (							self							)						->					Any:
          for prediction_type in ["epsilon", "sample", "v_prediction"]:
              self.check_over_configs(prediction_type=lowercase_							)




      def     a_      (							self							)						->					Union[str, Any]:
          for t in [0, 5_0_0, 9_9_9]:
              self.check_over_forward(time_step=lowercase_							)




      def     a_      (							self							)						->					Optional[Any]:
          UpperCAmelCase									=					self.scheduler_classes[0]
          UpperCAmelCase									=					self.get_scheduler_config()
          UpperCAmelCase									=					scheduler_class(**lowercase_							)

          assert torch.sum(torch.abs(scheduler._get_variance(0							) - 0.0							)							) < 1E-5
          assert torch.sum(torch.abs(scheduler._get_variance(4_8_7							) - 0.0_0_9_7_9							)							) < 1E-5
          assert torch.sum(torch.abs(scheduler._get_variance(9_9_9							) - 0.0_2							)							) < 1E-5




      def     a_      (							self							)						->					str:
          UpperCAmelCase									=					self.scheduler_classes[0]
          UpperCAmelCase									=					self.get_scheduler_config()
          UpperCAmelCase									=					scheduler_class(**lowercase_							)

          UpperCAmelCase									=					len(lowercase_							)

          UpperCAmelCase									=					self.dummy_model()
          UpperCAmelCase									=					self.dummy_sample_deter
          UpperCAmelCase									=					torch.manual_seed(0							)

          for t in reversed(range(lowercase_							)							):
              # 1. predict noise residual
              UpperCAmelCase									=					model(lowercase_   ,       lowercase_							)

              # 2. predict previous mean of sample x_t-1
              UpperCAmelCase									=					scheduler.step(lowercase_   ,       lowercase_   ,       lowercase_   ,       generator=lowercase_							).prev_sample

              # if t > 0:
              #     noise = self.dummy_sample_deter
              #     variance = scheduler.get_variance(t) ** (0.5) * noise
              #
              # sample = pred_prev_sample + variance
              UpperCAmelCase									=					pred_prev_sample

          UpperCAmelCase									=					torch.sum(torch.abs(lowercase_							)							)
          UpperCAmelCase									=					torch.mean(torch.abs(lowercase_							)							)

          assert abs(result_sum.item() - 2_5_8.9_6_0_6							) < 1E-2
          assert abs(result_mean.item() - 0.3_3_7_2							) < 1E-3




      def     a_      (							self							)						->					Union[str, Any]:
          UpperCAmelCase									=					self.scheduler_classes[0]
          UpperCAmelCase									=					self.get_scheduler_config(prediction_type='v_prediction'							)
          UpperCAmelCase									=					scheduler_class(**lowercase_							)

          UpperCAmelCase									=					len(lowercase_							)

          UpperCAmelCase									=					self.dummy_model()
          UpperCAmelCase									=					self.dummy_sample_deter
          UpperCAmelCase									=					torch.manual_seed(0							)

          for t in reversed(range(lowercase_							)							):
              # 1. predict noise residual
              UpperCAmelCase									=					model(lowercase_   ,       lowercase_							)

              # 2. predict previous mean of sample x_t-1
              UpperCAmelCase									=					scheduler.step(lowercase_   ,       lowercase_   ,       lowercase_   ,       generator=lowercase_							).prev_sample

              # if t > 0:
              #     noise = self.dummy_sample_deter
              #     variance = scheduler.get_variance(t) ** (0.5) * noise
              #
              # sample = pred_prev_sample + variance
              UpperCAmelCase									=					pred_prev_sample

          UpperCAmelCase									=					torch.sum(torch.abs(lowercase_							)							)
          UpperCAmelCase									=					torch.mean(torch.abs(lowercase_							)							)

          assert abs(result_sum.item() - 2_0_2.0_2_9_6							) < 1E-2
          assert abs(result_mean.item() - 0.2_6_3_1							) < 1E-3




      def     a_      (							self							)						->					Optional[Any]:
          UpperCAmelCase									=					self.scheduler_classes[0]
          UpperCAmelCase									=					self.get_scheduler_config()
          UpperCAmelCase									=					scheduler_class(**lowercase_							)

          UpperCAmelCase									=					[1_0_0, 8_7, 5_0, 1, 0]

          scheduler.set_timesteps(timesteps=lowercase_							)

          UpperCAmelCase									=					scheduler.timesteps

          for i, timestep in enumerate(lowercase_							):
              if i == len(lowercase_							) - 1:
                  UpperCAmelCase									=					-1
              else:
                  UpperCAmelCase									=					timesteps[i + 1]

              UpperCAmelCase									=					scheduler.previous_timestep(lowercase_							)
              UpperCAmelCase									=					prev_t.item()

              self.assertEqual(lowercase_   ,       lowercase_							)




      def     a_      (							self							)						->					Optional[Any]:
          UpperCAmelCase									=					self.scheduler_classes[0]
          UpperCAmelCase									=					self.get_scheduler_config()
          UpperCAmelCase									=					scheduler_class(**lowercase_							)

          UpperCAmelCase									=					[1_0_0, 8_7, 5_0, 5_1, 0]

          with self.assertRaises(lowercase_   ,       msg='`custom_timesteps` must be in descending order.'							):
              scheduler.set_timesteps(timesteps=lowercase_							)




      def     a_      (							self							)						->					List[Any]:
          UpperCAmelCase									=					self.scheduler_classes[0]
          UpperCAmelCase									=					self.get_scheduler_config()
          UpperCAmelCase									=					scheduler_class(**lowercase_							)

          UpperCAmelCase									=					[1_0_0, 8_7, 5_0, 1, 0]
          UpperCAmelCase									=					len(lowercase_							)

          with self.assertRaises(lowercase_   ,       msg='Can only pass one of `num_inference_steps` or `custom_timesteps`.'							):
              scheduler.set_timesteps(num_inference_steps=lowercase_   ,       timesteps=lowercase_							)




      def     a_      (							self							)						->					str:
          UpperCAmelCase									=					self.scheduler_classes[0]
          UpperCAmelCase									=					self.get_scheduler_config()
          UpperCAmelCase									=					scheduler_class(**lowercase_							)

          UpperCAmelCase									=					[scheduler.config.num_train_timesteps]

          with self.assertRaises(
              lowercase_   ,       msg='`timesteps` must start before `self.config.train_timesteps`: {scheduler.config.num_train_timesteps}}'   ,       ):
              scheduler.set_timesteps(timesteps=lowercase_							)



