"""simple docstring"""




from __future__ import annotations

import math
def 							lowerCAmelCase(     __lowerCamelCase				,    __lowerCamelCase						):
					if len(__lowerCamelCase						) != 2 or len(a[0]						) != 2 or len(__lowerCamelCase						) != 2 or len(b[0]						) != 2:
										raise Exception('Matrices are not 2x2'						)
					__a		 =       [
					    [a[0][0] * b[0][0] + a[0][1] * b[1][0], a[0][0] * b[0][1] + a[0][1] * b[1][1]],
					    [a[1][0] * b[0][0] + a[1][1] * b[1][0], a[1][0] * b[0][1] + a[1][1] * b[1][1]],
					]
					return new_matrix
def 							lowerCAmelCase(     __lowerCamelCase				,    __lowerCamelCase						):
					return [
					    [matrix_a[row][col] + matrix_b[row][col] for col in range(len(matrix_a[row]						)						)]
					    for row in range(len(__lowerCamelCase						)						)
					]
def 							lowerCAmelCase(     __lowerCamelCase				,    __lowerCamelCase						):
					return [
					    [matrix_a[row][col] - matrix_b[row][col] for col in range(len(matrix_a[row]						)						)]
					    for row in range(len(__lowerCamelCase						)						)
					]
def 							lowerCAmelCase(     __lowerCamelCase						):
					if len(__lowerCamelCase						) % 2 != 0 or len(a[0]						) % 2 != 0:
										raise Exception('Odd matrices are not supported!'						)

					__a		 =       len(__lowerCamelCase						)
					__a		 =       matrix_length // 2

					__a		 =       [[a[i][j] for j in range(__lowerCamelCase				,    __lowerCamelCase						)] for i in range(__lowerCamelCase						)]
					__a		 =       [
					    [a[i][j] for j in range(__lowerCamelCase				,    __lowerCamelCase						)] for i in range(__lowerCamelCase				,    __lowerCamelCase						)
					]

					__a		 =       [[a[i][j] for j in range(__lowerCamelCase						)] for i in range(__lowerCamelCase						)]
					__a		 =       [[a[i][j] for j in range(__lowerCamelCase						)] for i in range(__lowerCamelCase				,    __lowerCamelCase						)]

					return top_left, top_right, bot_left, bot_right
def 							lowerCAmelCase(     __lowerCamelCase						):
					return len(__lowerCamelCase						), len(matrix[0]						)
def 							lowerCAmelCase(     __lowerCamelCase						):
					print('\n'.join(str(__lowerCamelCase						) for line in matrix						)						)
def 							lowerCAmelCase(     __lowerCamelCase				,    __lowerCamelCase						):
					if matrix_dimensions(__lowerCamelCase						) == (2, 2):
										return default_matrix_multiplication(__lowerCamelCase				,    __lowerCamelCase						)

					__a ,				__a ,				__a ,				__a		 =       split_matrix(__lowerCamelCase						)
					__a ,				__a ,				__a ,				__a		 =       split_matrix(__lowerCamelCase						)

					__a		 =       actual_strassen(__lowerCamelCase				,    matrix_subtraction(__lowerCamelCase				,    __lowerCamelCase						)						)
					__a		 =       actual_strassen(matrix_addition(__lowerCamelCase				,    __lowerCamelCase						)				,    __lowerCamelCase						)
					__a		 =       actual_strassen(matrix_addition(__lowerCamelCase				,    __lowerCamelCase						)				,    __lowerCamelCase						)
					__a		 =       actual_strassen(__lowerCamelCase				,    matrix_subtraction(__lowerCamelCase				,    __lowerCamelCase						)						)
					__a		 =       actual_strassen(matrix_addition(__lowerCamelCase				,    __lowerCamelCase						)				,    matrix_addition(__lowerCamelCase				,    __lowerCamelCase						)						)
					__a		 =       actual_strassen(matrix_subtraction(__lowerCamelCase				,    __lowerCamelCase						)				,    matrix_addition(__lowerCamelCase				,    __lowerCamelCase						)						)
					__a		 =       actual_strassen(matrix_subtraction(__lowerCamelCase				,    __lowerCamelCase						)				,    matrix_addition(__lowerCamelCase				,    __lowerCamelCase						)						)

					__a		 =       matrix_addition(matrix_subtraction(matrix_addition(__lowerCamelCase				,    __lowerCamelCase						)				,    __lowerCamelCase						)				,    __lowerCamelCase						)
					__a		 =       matrix_addition(__lowerCamelCase				,    __lowerCamelCase						)
					__a		 =       matrix_addition(__lowerCamelCase				,    __lowerCamelCase						)
					__a		 =       matrix_subtraction(matrix_subtraction(matrix_addition(__lowerCamelCase				,    __lowerCamelCase						)				,    __lowerCamelCase						)				,    __lowerCamelCase						)

					# construct the new matrix from our 4 quadrants
					__a		 =       []
					for i in range(len(__lowerCamelCase						)						):
										new_matrix.append(top_left[i] + top_right[i]						)
					for i in range(len(__lowerCamelCase						)						):
										new_matrix.append(bot_left[i] + bot_right[i]						)
					return new_matrix
def 							lowerCAmelCase(     __lowerCamelCase				,    __lowerCamelCase						):
					if matrix_dimensions(__lowerCamelCase						)[1] != matrix_dimensions(__lowerCamelCase						)[0]:
										__a		 =       (
										    'Unable to multiply these matrices, please check the dimensions.\n'
										    f'''Matrix A: {matrixa}\n'''
										    f'''Matrix B: {matrixa}'''
										)
										raise Exception(__lowerCamelCase						)
					__a		 =       matrix_dimensions(__lowerCamelCase						)
					__a		 =       matrix_dimensions(__lowerCamelCase						)

					if dimensiona[0] == dimensiona[1] and dimensiona[0] == dimensiona[1]:
										return [matrixa, matrixa]

					__a		 =       max(*__lowerCamelCase				,    *__lowerCamelCase						)
					__a		 =       int(math.pow(2				,    math.ceil(math.loga(__lowerCamelCase						)						)						)						)
					__a		 =       matrixa
					__a		 =       matrixa

					# Adding zeros to the matrices so that the arrays dimensions are the same and also
					# power of 2
					for i in range(0				,    __lowerCamelCase						):
										if i < dimensiona[0]:
															for _ in range(dimensiona[1]				,    __lowerCamelCase						):
																				new_matrixa[i].append(0						)
										else:
															new_matrixa.append([0] * maxim						)
										if i < dimensiona[0]:
															for _ in range(dimensiona[1]				,    __lowerCamelCase						):
																				new_matrixa[i].append(0						)
										else:
															new_matrixa.append([0] * maxim						)

					__a		 =       actual_strassen(__lowerCamelCase				,    __lowerCamelCase						)

					# Removing the additional zeros
					for i in range(0				,    __lowerCamelCase						):
										if i < dimensiona[0]:
															for _ in range(dimensiona[1]				,    __lowerCamelCase						):
																				final_matrix[i].pop()
										else:
															final_matrix.pop()
					return final_matrix


if __name__ == "__main__":
	lowerCamelCase_    :		Union[str, Any]							=	[
	    [2, 3, 4, 5],
	    [6, 4, 3, 1],
	    [2, 3, 6, 7],
	    [3, 1, 2, 4],
	    [2, 3, 4, 5],
	    [6, 4, 3, 1],
	    [2, 3, 6, 7],
	    [3, 1, 2, 4],
	    [2, 3, 4, 5],
	    [6, 2, 3, 1],
	]
	lowerCamelCase_    :		List[Any]							=	[[0, 2, 1, 1], [16, 2, 3, 3], [2, 2, 7, 7], [13, 11, 22, 4]]
	print(strassen(matrixa, matrixa))





import numpy as np
from sklearn.datasets import fetch_california_housing
from sklearn.metrics import mean_absolute_error, mean_squared_error
from sklearn.model_selection import train_test_split
from xgboost import XGBRegressor
def 							lowerCAmelCase(     __lowerCamelCase						):
					return (data["data"], data["target"])
def 							lowerCAmelCase(     __lowerCamelCase				,    __lowerCamelCase				,    __lowerCamelCase						):
					__a		 =       XGBRegressor(verbosity=0				,    random_state=42						)
					xgb.fit(__lowerCamelCase				,    __lowerCamelCase						)
					# Predict target for test data
					__a		 =       xgb.predict(__lowerCamelCase						)
					__a		 =       predictions.reshape(len(__lowerCamelCase						)				,    1						)
					return predictions
def 							lowerCAmelCase(     ):
					__a		 =       fetch_california_housing()
					__a ,				__a		 =       data_handling(__lowerCamelCase						)
					__a ,				__a ,				__a ,				__a		 =       train_test_split(
					    __lowerCamelCase				,    __lowerCamelCase				,    test_size=0.25				,    random_state=1						)
					__a		 =       xgboost(__lowerCamelCase				,    __lowerCamelCase				,    __lowerCamelCase						)
					# Error printing
					print(f'''Mean Absolute Error : {mean_absolute_error(__lowerCamelCase				,    __lowerCamelCase						)}'''						)
					print(f'''Mean Square Error  : {mean_squared_error(__lowerCamelCase				,    __lowerCamelCase						)}'''						)


if __name__ == "__main__":
	import doctest

	doctest.testmod(verbose=True)
	main()




