

'''simple docstring'''





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






def 							_lowerCAmelCase (      __magic_name__	:    List[str]      ,   __magic_name__	:    List[Any]	)							->     Tuple:
						lowercase   :       Any								=[[float('''inf'''	) for _ in range(__magic_name__	)] for _ in range(__magic_name__	)]

						for i in range(__magic_name__	):
												for j in range(__magic_name__	):
																		lowercase   :       Optional[Any]								=graph[i][j]

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

						_print_dist(__magic_name__      ,   __magic_name__	)
						return dist, v


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

							UpperCamelCase_							=					[[float("""inf""") for i in range(v)] for j in range(v)]

							for i in range(v):
														UpperCamelCase_							=					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)
														UpperCamelCase_							=					int(input("""Enter source:"""))
														UpperCamelCase_							=					int(input("""Enter destination:"""))
														UpperCamelCase_							=					float(input("""Enter weight:"""))
														UpperCamelCase_							=					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








'''simple docstring'''





import math






def 							_lowerCAmelCase (      __magic_name__	:    float      ,   __magic_name__	:    float	)							->     float:
						if (
						    not isinstance(__magic_name__      ,   (int, float)	)
						    or power_factor < -1
						    or power_factor > 1
						):
												raise ValueError('''power_factor must be a valid float value between -1 and 1.'''	)
						return apparent_power * power_factor






def 							_lowerCAmelCase (      __magic_name__	:    float      ,   __magic_name__	:    float	)							->     float:
						if (
						    not isinstance(__magic_name__      ,   (int, float)	)
						    or power_factor < -1
						    or power_factor > 1
						):
												raise ValueError('''power_factor must be a valid float value between -1 and 1.'''	)
						return apparent_power * math.sqrt(1 - power_factor**2	)


if __name__ == "__main__":
							import doctest

							doctest.testmod()





