






"""simple docstring"""


lowercase_								=	(1, 153, 370, 371, 1634, 2467_8051, 115_1322_1901_8763_9925_6509_5597_9739_7152_2401)
lowercase_								=	(-153, -1, 0, 1.2, 200, "A", [], {}, None)



def    lowerCAmelCase							(       __UpperCamelCase					):




  """simple docstring"""







  if not isinstance(__UpperCamelCase						,			__UpperCamelCase					) or n < 1:
    return False

  # Initialization of sum and number of digits.
  __A		     =					0
  __A		     =					0
  __A		     =					n
  # Calculation of digits of the number
  while temp > 0:
    number_of_digits += 1
    temp //= 1_0
  # Dividing number into separate digits and find Armstrong number
  __A		     =					n
  while temp > 0:
    __A		     =					temp % 1_0
    total += rem**number_of_digits
    temp //= 1_0
  return n == total



def    lowerCAmelCase							(       __UpperCamelCase					):




  """simple docstring"""







  if not isinstance(__UpperCamelCase						,			__UpperCamelCase					) or n < 1:
    return False

  # Init a "histogram" of the digits
  __A		     =					[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
  __A		     =					0
  __A		     =					0
  __A		     =					n
  while temp > 0:
    __A     ,       __A		     =					divmod(__UpperCamelCase						,			1_0					)
    digit_histogram[rem] += 1
    digit_total += 1

  for cnt, i in zip(__UpperCamelCase						,			range(len(__UpperCamelCase					)					)					):
    total += cnt * i**digit_total

  return n == total



def    lowerCAmelCase							(       __UpperCamelCase					):




  """simple docstring"""







  if not isinstance(__UpperCamelCase						,			__UpperCamelCase					) or n < 1:
    return False
  __A		     =					len(str(__UpperCamelCase					)					)  # the power that all digits will be raised to
  # check if sum of each digit multiplied expo times is equal to number
  return n == sum(int(__UpperCamelCase					) ** expo for i in str(__UpperCamelCase					)					)



def    lowerCAmelCase							(       ):




  """simple docstring"""







  __A		     =					int(input('''Enter an integer to see if it is an Armstrong number: '''					).strip()					)
  print(f'{num} is {"" if armstrong_number(__UpperCamelCase					) else "not "}an Armstrong number.'					)
  print(f'{num} is {"" if narcissistic_number(__UpperCamelCase					) else "not "}an Armstrong number.'					)
  print(f'{num} is {"" if pluperfect_number(__UpperCamelCase					) else "not "}an Armstrong number.'					)


if __name__ == "__main__":
       import doctest

       doctest.testmod()
       main()












"""simple docstring"""


import os
import unittest

from transformers import is_torch_available
from transformers.testing_utils import require_sentencepiece, require_tokenizers, require_torch, slow, torch_device


if is_torch_available():
       import torch

       from transformers import GPTaLMHeadModel


@require_torch
@require_sentencepiece
@require_tokenizers
class    snake_case						(				unittest.TestCase		):


   '''simple docstring'''

   @slow
   @unittest.skip('''Model is not available.'''    )
   def 							_SCREAMING_SNAKE_CASE							(      self					:	int    ):

     '''simple docstring'''
     __A		     =					'''nvidia/megatron-gpt2-345m/'''
     if "MYDIR" in os.environ:
       __A		     =					os.path.join(os.environ['''MYDIR'''],			_lowerCamelCase    )
     __A		     =					GPTaLMHeadModel.from_pretrained(_lowerCamelCase    )
     model.to(_lowerCamelCase    )
     model.half()

     __A		     =					torch.tensor(
         [[1_01, 71_10, 10_05, 10_56, 20_23, 1_13_33, 1_74_13, 10_29, 1_02]],			device=_lowerCamelCase,			dtype=torch.long,			)

     with torch.no_grad():
       __A		     =					model(_lowerCamelCase    ).logits

     __A		     =					torch.Size((1, 9, 5_02_57)    )
     self.assertEqual(output.shape,			_lowerCamelCase    )

     __A		     =					torch.tensor(
         [
             4.94_14,
             -0.29_20,
             -1.21_48,
             -4.02_73,
             -0.51_61,
             -5.21_09,
             -1.24_12,
             -1.83_01,
             -1.77_34,
             -4.71_48,
             -0.23_17,
             -1.08_11,
             -2.17_77,
             0.41_41,
             -3.79_69,
             -4.05_86,
             -2.53_32,
             -3.38_09,
             4.38_67,
         ],			device=_lowerCamelCase,			dtype=torch.half,			)

     for i in range(19    ):
       __A     ,       __A		     =					8 * i // 17, 27_92 * i  # along the diagonal
       __A     ,       __A		     =					output[0, r, c], expected_diag[i]
       __A		     =					f'row={r} col={c} computed={computed} expected={expected}'
       self.assertAlmostEqual(_lowerCamelCase,			_lowerCamelCase,			delta=1e-4,			msg=_lowerCamelCase    )




