




def 					_a							(					lowerCAmelCase    ,						lowerCAmelCase )->	Any:
		print('\nThe shortest path matrix using Floyd Warshall algorithm\n' )
		for i in range(UpperCamelCase__ ):
				for j in range(UpperCamelCase__ ):
						if dist[i][j] != float('inf' ):
								print(int(dist[i][j] )    ,						end='\t' )
						else:
								print('INF'    ,						end='\t' )
				print()


def 					_a							(					lowerCAmelCase    ,						lowerCAmelCase )->	int:
		SCREAMING_SNAKE_CASE_					      =							[[float('inf' ) for _ in range(UpperCamelCase__ )] for _ in range(UpperCamelCase__ )]

		for i in range(UpperCamelCase__ ):
				for j in range(UpperCamelCase__ ):
						SCREAMING_SNAKE_CASE_					      =							graph[i][j]

						# check vertex k against all other vertices (i, j)
		for k in range(UpperCamelCase__ ):
				# looping through rows of graph array
				for i in range(UpperCamelCase__ ):
						# looping through columns of graph array
						for j in range(UpperCamelCase__ ):
								if (
								    dist[i][k] != float('inf' )
								    and dist[k][j] != float('inf' )
								    and dist[i][k] + dist[k][j] < dist[i][j]
								):
										SCREAMING_SNAKE_CASE_					      =							dist[i][k] + dist[k][j]

		_print_dist(UpperCamelCase__    ,						UpperCamelCase__ )
		return dist, v


if __name__ == "__main__":
						SCREAMING_SNAKE_CASE:     List[Any]									= int(input('''Enter number of vertices: '''))
						SCREAMING_SNAKE_CASE:     Any									= int(input('''Enter number of edges: '''))

						SCREAMING_SNAKE_CASE:     List[Any]									= [[float('''inf''') for i in range(v)] for j in range(v)]

						for i in range(v):
												SCREAMING_SNAKE_CASE:     Tuple									= 0.0

												# src and dst are indices that must be within the array size graph[e][v]
												# failure to follow this will result in an error
						for i in range(e):
												print('''\nEdge ''', i + 1)
												SCREAMING_SNAKE_CASE:     Any									= int(input('''Enter source:'''))
												SCREAMING_SNAKE_CASE:     int									= int(input('''Enter destination:'''))
												SCREAMING_SNAKE_CASE:     str									= float(input('''Enter weight:'''))
												SCREAMING_SNAKE_CASE:     List[Any]									= weight

						floyd_warshall(graph, v)

						# Example Input
						# Enter number of vertices: 3
						# Enter number of edges: 2

						# # generated graph from vertex and edge inputs
						# [[inf, inf, inf], [inf, inf, inf], [inf, inf, inf]]
						# [[0.0, inf, inf], [inf, 0.0, inf], [inf, inf, 0.0]]

						# specify source, destination and weight for edge #1
						# Edge  1
						# Enter source:1
						# Enter destination:2
						# Enter weight:2

						# specify source, destination and weight for edge #2
						# Edge  2
						# Enter source:2
						# Enter destination:1
						# Enter weight:1

						# # Expected Output from the vertice, edge and src, dst, weight inputs!!
						# 0		INF	INF
						# INF	0	2
						# INF	1	0



import unittest

from transformers import BigBirdConfig, is_flax_available
from transformers.testing_utils import require_flax, slow

from ...test_modeling_flax_common import FlaxModelTesterMixin, ids_tensor, random_attention_mask


if is_flax_available():
				import jax

				from transformers.models.big_bird.modeling_flax_big_bird import (
				    FlaxBigBirdForCausalLM,
				    FlaxBigBirdForMaskedLM,
				    FlaxBigBirdForMultipleChoice,
				    FlaxBigBirdForPreTraining,
				    FlaxBigBirdForQuestionAnswering,
				    FlaxBigBirdForSequenceClassification,
				    FlaxBigBirdForTokenClassification,
				    FlaxBigBirdModel,
				)






class    _UpperCamelCase     (       unittest.TestCase					):

				"""simple docstring"""







				def __init__(    self					, a__					, a__=2					, a__=56					, a__=True					, a__=True					, a__=True					, a__=True					, a__=99					, a__=32					, a__=2					, a__=2					, a__=7					, a__="gelu_new"					, a__=0.1					, a__=0.1					, a__=512					, a__=16					, a__=2					, a__=0.02					, a__=4					, a__="block_sparse"					, a__=True					, a__=False					, a__=2					, a__=3					, )						->					List[Any]:
					A             =					parent
					A             =					batch_size
					A             =					seq_length
					A             =					is_training
					A             =					use_attention_mask
					A             =					use_token_type_ids
					A             =					use_labels
					A             =					vocab_size
					A             =					hidden_size
					A             =					num_hidden_layers
					A             =					num_attention_heads
					A             =					intermediate_size
					A             =					hidden_act
					A             =					hidden_dropout_prob
					A             =					attention_probs_dropout_prob
					A             =					max_position_embeddings
					A             =					type_vocab_size
					A             =					type_sequence_label_size
					A             =					initializer_range
					A             =					num_choices

					A             =					rescale_embeddings
					A             =					attention_type
					A             =					use_bias
					A             =					block_size
					A             =					num_random_blocks

				def   _UpperCAmelCase       (    self )						->					List[Any]:
					A             =					ids_tensor([self.batch_size, self.seq_length]					, self.vocab_size )

					A             =					None
					if self.use_attention_mask:
						A             =					random_attention_mask([self.batch_size, self.seq_length] )

					A             =					None
					if self.use_token_type_ids:
						A             =					ids_tensor([self.batch_size, self.seq_length]					, self.type_vocab_size )

					A             =					BigBirdConfig(
					    vocab_size=self.vocab_size					, hidden_size=self.hidden_size					, num_hidden_layers=self.num_hidden_layers					, num_attention_heads=self.num_attention_heads					, intermediate_size=self.intermediate_size					, hidden_act=self.hidden_act					, hidden_dropout_prob=self.hidden_dropout_prob					, attention_probs_dropout_prob=self.attention_probs_dropout_prob					, max_position_embeddings=self.max_position_embeddings					, type_vocab_size=self.type_vocab_size					, is_decoder=a__					, initializer_range=self.initializer_range					, attention_type=self.attention_type					, block_size=self.block_size					, num_random_blocks=self.num_random_blocks					, use_bias=self.use_bias					, rescale_embeddings=self.rescale_embeddings					, )

					return config, input_ids, token_type_ids, attention_mask

				def   _UpperCAmelCase       (    self )						->					Optional[int]:
					A             =					self.prepare_config_and_inputs()
					A       ,      A       ,      A       ,      A             =					config_and_inputs
					A             =					{
					    """input_ids""": input_ids,
					    """token_type_ids""": token_type_ids,
					    """attention_mask""": attention_mask,
					}
					return config, inputs_dict






@require_flax
class    _UpperCamelCase     (       __snake_case     ,		unittest.TestCase					):

				"""simple docstring"""







				lowerCAmelCase					=			(
				    (
				        FlaxBigBirdForCausalLM,
				        FlaxBigBirdModel,
				        FlaxBigBirdForPreTraining,
				        FlaxBigBirdForMaskedLM,
				        FlaxBigBirdForMultipleChoice,
				        FlaxBigBirdForQuestionAnswering,
				        FlaxBigBirdForSequenceClassification,
				        FlaxBigBirdForTokenClassification,
				    )
				    if is_flax_available()
				    else ()
				)

				lowerCAmelCase					=			False
				lowerCAmelCase					=			False

				def   _UpperCAmelCase       (    self )						->					Optional[int]:
					A             =					FlaxBigBirdModelTester(self )

				@slow
				# copied from `test_modeling_flax_common` because it takes much longer than other models
				def   _UpperCAmelCase       (    self )						->					Tuple:
					super().test_from_pretrained_save_pretrained()

				@slow
				# copied from `test_modeling_flax_common` because it takes much longer than other models
				def   _UpperCAmelCase       (    self )						->					Dict:
					super().test_from_pretrained_with_no_automatic_init()

				@slow
				# copied from `test_modeling_flax_common` because it takes much longer than other models
				def   _UpperCAmelCase       (    self )						->					str:
					super().test_no_automatic_init()

				@slow
				# copied from `test_modeling_flax_common` because it takes much longer than other models
				def   _UpperCAmelCase       (    self )						->					List[Any]:
					super().test_hidden_states_output()

				@slow
				def   _UpperCAmelCase       (    self )						->					str:
					for model_class_name in self.all_model_classes:
						A             =					model_class_name.from_pretrained("""google/bigbird-roberta-base""" )
						self.assertIsNotNone(a__ )

				def   _UpperCAmelCase       (    self )						->					Optional[int]:
					if self.test_attn_probs:
						super().test_attention_outputs()

				@slow
				# copied from `test_modeling_flax_common` because it takes much longer than other models
				def   _UpperCAmelCase       (    self )						->					List[Any]:
					A       ,      A             =					self.model_tester.prepare_config_and_inputs_for_common()

					for model_class in self.all_model_classes:
						with self.subTest(model_class.__name__ ):
							A             =					self._prepare_for_class(a__					, a__ )
							A             =					model_class(a__ )

							@jax.jit
							def model_jitted(a__					, a__=None					, **a__ ):
								return model(input_ids=a__					, attention_mask=a__					, **a__ )

							with self.subTest("""JIT Enabled""" ):
								A             =					model_jitted(**a__ ).to_tuple()

							with self.subTest("""JIT Disabled""" ):
								with jax.disable_jit():
									A             =					model_jitted(**a__ ).to_tuple()

							self.assertEqual(len(a__ )					, len(a__ ) )
							for jitted_output, output in zip(a__					, a__ ):
								self.assertEqual(jitted_output.shape					, output.shape )

				def   _UpperCAmelCase       (    self					, a__					, a__					, a__					, a__=1e-5					, a__="outputs"					, a__=None )						->					Tuple:
					# `bigbird_block_sparse_attention` in `FlaxBigBird` returns `attention_probs = None`, while in PyTorch version,
					# an effort was done to return `attention_probs` (yet to be verified).
					if name.startswith("""outputs.attentions""" ):
						return
					else:
						super().check_pt_flax_outputs(a__					, a__					, a__					, a__					, a__					, a__ )



