





def 					lowerCamelCase_						(    _UpperCamelCase			,    _UpperCamelCase			)		->						Tuple:






				"""simple docstring"""


				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 					lowerCamelCase_						(    _UpperCamelCase			,    _UpperCamelCase			)		->						str:






				"""simple docstring"""


				snake_case_						:   Union[str, Any]           =  [[float('''inf'''			) for _ in range(_UpperCamelCase			)] for _ in range(_UpperCamelCase			)]

				for i in range(_UpperCamelCase			):
								for j in range(_UpperCamelCase			):
												snake_case_						:   int           =  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]
																):
																				snake_case_						:   str           =  dist[i][k] + dist[k][j]

				_print_dist(_UpperCamelCase			,    _UpperCamelCase			)
				return dist, v


if __name__ == "__main__":
	lowerCAmelCase_    =    int(input('''Enter number of vertices: '''))
	lowerCAmelCase_    =    int(input('''Enter number of edges: '''))

	lowerCAmelCase_    =    [[float('''inf''') for i in range(v)] for j in range(v)]

	for i in range(v):
		lowerCAmelCase_    =    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)
		lowerCAmelCase_    =    int(input('''Enter source:'''))
		lowerCAmelCase_    =    int(input('''Enter destination:'''))
		lowerCAmelCase_    =    float(input('''Enter weight:'''))
		lowerCAmelCase_    =    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 load_tool
from transformers.utils import is_torch_available


if is_torch_available():
	import torch

from transformers.testing_utils import require_torch

from .test_tools_common import ToolTesterMixin



@require_torch
class  __lowerCAmelCase	(      unittest.TestCase,					_a					):






			def       lowerCamelCase  (self   )					->       int:


							'''simple docstring'''



							snake_case_						:   Dict           =  load_tool('''text-to-speech'''   )
							self.tool.setup()






			def       lowerCamelCase  (self   )					->       List[str]:


							'''simple docstring'''



							torch.manual_seed(0   )
							snake_case_						:   Optional[int]           =  self.tool('''hey'''   )
							snake_case_						:   Union[str, Any]           =  result.to_raw()
							self.assertTrue(
							    torch.allclose(
							        resulting_tensor[:3] ,							torch.tensor([-0.0_005_966_668_832_115_829, -0.0_003_657_640_190_795_064, -0.00_013_439_502_799_883_485]   ) ,							)   )






			def       lowerCamelCase  (self   )					->       Optional[Any]:


							'''simple docstring'''



							torch.manual_seed(0   )
							snake_case_						:   Any           =  self.tool('''hey'''   )
							snake_case_						:   str           =  result.to_raw()
							self.assertTrue(
							    torch.allclose(
							        resulting_tensor[:3] ,							torch.tensor([-0.0_005_966_668_832_115_829, -0.0_003_657_640_190_795_064, -0.00_013_439_502_799_883_485]   ) ,							)   )
