






"""simple docstring"""
def 			__UpperCamelCase	(		snake_case__   ,   snake_case__   ,   snake_case__					):
	return not any(
	    neighbour == 1 and colored_vertices[i] == color
	    for i, neighbour in enumerate(snake_case__					)					)






def 			__UpperCamelCase	(		snake_case__   ,   snake_case__   ,   snake_case__   ,   snake_case__					):

	# Base Case
	if index == len(snake_case__					):
		return True

	# Recursive Step
	for i in range(snake_case__					):
		if valid_coloring(graph[index]   ,   snake_case__   ,   snake_case__					):
			# Color current vertex
			A_		:						Dict	    =   i
			# Validate coloring
			if util_color(snake_case__   ,   snake_case__   ,   snake_case__   ,   index + 1					):
				return True
			# Backtrack
			A_		:						Union[str, Any]	    =   -1
	return False






def 			__UpperCamelCase	(		snake_case__   ,   snake_case__					):
	A_		:						int	    =   [-1] * len(snake_case__					)

	if util_color(snake_case__   ,   snake_case__   ,   snake_case__   ,   0					):
		return colored_vertices

	return []









"""simple docstring"""
import unittest

import torch
from torch import nn

from diffusers.models.activations import get_activation



class      SCREAMING_SNAKE_CASE  (				unittest.TestCase						):





	"""simple docstring"""




	def    lowerCamelCase(self							):
		A_		:						Optional[int]	    =   get_activation("""swish"""							)

		self.assertIsInstance(lowerCAmelCase_     ,     nn.SiLU							)

		self.assertEqual(act(torch.tensor(-100     ,     dtype=torch.floataa							)							).item()     ,     0							)
		self.assertNotEqual(act(torch.tensor(-1     ,     dtype=torch.floataa							)							).item()     ,     0							)
		self.assertEqual(act(torch.tensor(0     ,     dtype=torch.floataa							)							).item()     ,     0							)
		self.assertEqual(act(torch.tensor(20     ,     dtype=torch.floataa							)							).item()     ,     20							)





	def    lowerCamelCase(self							):
		A_		:						Dict	    =   get_activation("""silu"""							)

		self.assertIsInstance(lowerCAmelCase_     ,     nn.SiLU							)

		self.assertEqual(act(torch.tensor(-100     ,     dtype=torch.floataa							)							).item()     ,     0							)
		self.assertNotEqual(act(torch.tensor(-1     ,     dtype=torch.floataa							)							).item()     ,     0							)
		self.assertEqual(act(torch.tensor(0     ,     dtype=torch.floataa							)							).item()     ,     0							)
		self.assertEqual(act(torch.tensor(20     ,     dtype=torch.floataa							)							).item()     ,     20							)





	def    lowerCamelCase(self							):
		A_		:						Optional[Any]	    =   get_activation("""mish"""							)

		self.assertIsInstance(lowerCAmelCase_     ,     nn.Mish							)

		self.assertEqual(act(torch.tensor(-200     ,     dtype=torch.floataa							)							).item()     ,     0							)
		self.assertNotEqual(act(torch.tensor(-1     ,     dtype=torch.floataa							)							).item()     ,     0							)
		self.assertEqual(act(torch.tensor(0     ,     dtype=torch.floataa							)							).item()     ,     0							)
		self.assertEqual(act(torch.tensor(20     ,     dtype=torch.floataa							)							).item()     ,     20							)





	def    lowerCamelCase(self							):
		A_		:						int	    =   get_activation("""gelu"""							)

		self.assertIsInstance(lowerCAmelCase_     ,     nn.GELU							)

		self.assertEqual(act(torch.tensor(-100     ,     dtype=torch.floataa							)							).item()     ,     0							)
		self.assertNotEqual(act(torch.tensor(-1     ,     dtype=torch.floataa							)							).item()     ,     0							)
		self.assertEqual(act(torch.tensor(0     ,     dtype=torch.floataa							)							).item()     ,     0							)
		self.assertEqual(act(torch.tensor(20     ,     dtype=torch.floataa							)							).item()     ,     20							)

