





def lowerCAmelCase__(__snake_case							)				->      list[list]:







	'''simple docstring'''







	lowerCamelCase__								=		current_set.copy()
	for row_index, row in enumerate(__snake_case							):
		lowerCamelCase__								=		row[0]
		for column_index, column in enumerate(__snake_case							):
			if magnitude == 0:
				lowerCamelCase__								=		column
				continue
			lowerCamelCase__								=		column / magnitude
    # Subtract to cancel term
	lowerCamelCase__								=		current_set[0]
	lowerCamelCase__								=		[first_row]
	lowerCamelCase__								=		current_set[1::]
	for row in current_set:
		lowerCamelCase__								=		[]
		# If first term is 0, it is already in form we want, so we preserve it
		if row[0] == 0:
			final_set.append(__snake_case							)
			continue
		for column_index in range(len(__snake_case							)							):
			temp_row.append(first_row[column_index] - row[column_index]							)
		final_set.append(__snake_case							)
	# Create next recursion iteration set
	if len(final_set[0]							) != 3:
		lowerCamelCase__								=		final_set[0]
		lowerCamelCase__								=		[]
		lowerCamelCase__								=		[]
		for row in final_set[1::]:
			current_first_column.append(row[0]							)
			next_iteration.append(row[1::]							)
		lowerCamelCase__								=		simplify(__snake_case							)
		for i in range(len(__snake_case							)							):
			resultant[i].insert(0       ,current_first_column[i]							)
		resultant.insert(0       ,__snake_case							)
		lowerCamelCase__								=		resultant
	return final_set





def lowerCAmelCase__(__snake_case							)				->      list:







	'''simple docstring'''







	if len(__snake_case							) == 0:
		raise IndexError('''solve_simultaneous() requires n lists of length n+1'''							)
	lowerCamelCase__								=		len(__snake_case							) + 1
	if any(len(__snake_case							) != _length for item in equations							):
		raise IndexError('''solve_simultaneous() requires n lists of length n+1'''							)
	for row in equations:
		if any(not isinstance(__snake_case       ,(int, float)							) for column in row							):
			raise ValueError('''solve_simultaneous() requires lists of integers'''							)
	if len(__snake_case							) == 1:
		return [equations[0][-1] / equations[0][0]]
	lowerCamelCase__								=		equations.copy()
	if any(0 in row for row in data_set							):
		lowerCamelCase__								=		data_set.copy()
		lowerCamelCase__								=		[]
		for row_index, row in enumerate(__snake_case							):
			if 0 not in row:
				lowerCamelCase__								=		data_set.pop(__snake_case							)
				break
		if not full_row:
			raise ValueError('''solve_simultaneous() requires at least 1 full equation'''							)
		data_set.insert(0       ,__snake_case							)
	lowerCamelCase__								=		data_set.copy()
	lowerCamelCase__								=		simplify(__snake_case							)
	lowerCamelCase__								=		simplified[::-1]
	lowerCamelCase__								=		[]
	for row in simplified:
		lowerCamelCase__								=		row[-1]
		if not solutions:
			if row[-2] == 0:
				solutions.append(0							)
				continue
			solutions.append(current_solution / row[-2]							)
			continue
		lowerCamelCase__								=		row.copy()[: len(__snake_case							) - 1 :]
		while temp_row[0] == 0:
			temp_row.pop(0							)
		if len(__snake_case							) == 0:
			solutions.append(0							)
			continue
		lowerCamelCase__								=		temp_row[1::]
		lowerCamelCase__								=		temp_row[::-1]
		for column_index, column in enumerate(__snake_case							):
			current_solution -= column * solutions[column_index]
		solutions.append(__snake_case							)
	lowerCamelCase__								=		[]
	for item in solutions:
		final.append(float(round(__snake_case       ,5							)							)							)
	return final[::-1]


if __name__ == "__main__":
			import doctest

			doctest.testmod()
			_a 						=      [
			    [2, 1, 1, 1, 1, 4],
			    [1, 2, 1, 1, 1, 5],
			    [1, 1, 2, 1, 1, 6],
			    [1, 1, 1, 2, 1, 7],
			    [1, 1, 1, 1, 2, 8],
			]
			print(solve_simultaneous(eq))
			print(solve_simultaneous([[4, 2]]))










def lowerCAmelCase__(__snake_case       ,__snake_case							)				->      float:







	'''simple docstring'''







	if mass < 0:
		raise ValueError('''The mass of a body cannot be negative'''							)
	return 0.5 * mass * abs(__snake_case							) * abs(__snake_case							)


if __name__ == "__main__":
			import doctest

			doctest.testmod(verbose=True)



