






"""simple docstring"""
import unittest

from .lib import (
    Matrix,
    Vector,
    axpy,
    square_zero_matrix,
    unit_basis_vector,
    zero_vector,
)







class     UpperCamelCase_ (unittest.TestCase  ):





	def   _SCREAMING_SNAKE_CASE   (   self      :				List[Any]		)		->    None:
				UpperCAmelCase_  :				Optional[Any]      =      Vector([1, 2, 3]		)
				self.assertEqual(x.component(0		)			,			1		)
				self.assertEqual(x.component(2		)			,			3		)
				UpperCAmelCase_  :				int      =      Vector()





	def   _SCREAMING_SNAKE_CASE   (   self      :				str		)		->    None:
				UpperCAmelCase_  :				Dict      =      Vector([0, 0, 0, 0, 0, 1]		)
				self.assertEqual(str(lowerCAmelCase_		)			,			"(0,0,0,0,0,1)"		)





	def   _SCREAMING_SNAKE_CASE   (   self      :				Dict		)		->    None:
				UpperCAmelCase_  :				Tuple      =      Vector([1, 2, 3, 4]		)
				self.assertEqual(len(lowerCAmelCase_		)			,			4		)





	def   _SCREAMING_SNAKE_CASE   (   self      :				List[str]		)		->    None:
				UpperCAmelCase_  :				int      =      Vector([1, 2]		)
				UpperCAmelCase_  :				Any      =      Vector([1, 2, 3, 4, 5]		)
				UpperCAmelCase_  :				Optional[Any]      =      Vector([0, 0, 0, 0, 0, 0, 0, 0, 0, 0]		)
				UpperCAmelCase_  :				Union[str, Any]      =      Vector([1, -1, 1, -1, 2, -3, 4, -5]		)
				self.assertAlmostEqual(x.euclidean_length()			,			2.2_3_6			,			3		)
				self.assertAlmostEqual(y.euclidean_length()			,			7.4_1_6			,			3		)
				self.assertEqual(z.euclidean_length()			,			0		)
				self.assertAlmostEqual(w.euclidean_length()			,			7.6_1_6			,			3		)





	def   _SCREAMING_SNAKE_CASE   (   self      :				int		)		->    None:
				UpperCAmelCase_  :				Dict      =      Vector([1, 2, 3]		)
				UpperCAmelCase_  :				str      =      Vector([1, 1, 1]		)
				self.assertEqual((x + y).component(0		)			,			2		)
				self.assertEqual((x + y).component(1		)			,			3		)
				self.assertEqual((x + y).component(2		)			,			4		)





	def   _SCREAMING_SNAKE_CASE   (   self      :				Union[str, Any]		)		->    None:
				UpperCAmelCase_  :				Dict      =      Vector([1, 2, 3]		)
				UpperCAmelCase_  :				Union[str, Any]      =      Vector([1, 1, 1]		)
				self.assertEqual((x - y).component(0		)			,			0		)
				self.assertEqual((x - y).component(1		)			,			1		)
				self.assertEqual((x - y).component(2		)			,			2		)





	def   _SCREAMING_SNAKE_CASE   (   self      :				Optional[int]		)		->    None:
				UpperCAmelCase_  :				List[str]      =      Vector([1, 2, 3]		)
				UpperCAmelCase_  :				Tuple      =      Vector([2, -1, 4]		)  # for test of dot product
				UpperCAmelCase_  :				Tuple      =      Vector([1, -2, -1]		)
				self.assertEqual(str(x * 3.0		)			,			"(3.0,6.0,9.0)"		)
				self.assertEqual((a * b)			,			0		)





	def   _SCREAMING_SNAKE_CASE   (   self      :				str		)		->    None:
				self.assertEqual(str(zero_vector(10		)		).count("0"		)			,			10		)





	def   _SCREAMING_SNAKE_CASE   (   self      :				int		)		->    None:
				self.assertEqual(str(unit_basis_vector(3			,			1		)		)			,			"(0,1,0)"		)





	def   _SCREAMING_SNAKE_CASE   (   self      :				Any		)		->    None:
				UpperCAmelCase_  :				Optional[Any]      =      Vector([1, 2, 3]		)
				UpperCAmelCase_  :				List[str]      =      Vector([1, 0, 1]		)
				self.assertEqual(str(axpy(2			,			lowerCAmelCase_			,			lowerCAmelCase_		)		)			,			"(3,4,7)"		)





	def   _SCREAMING_SNAKE_CASE   (   self      :				List[str]		)		->    None:
				UpperCAmelCase_  :				Optional[Any]      =      Vector([1, 0, 0, 0, 0, 0]		)
				UpperCAmelCase_  :				Union[str, Any]      =      x.copy()
				self.assertEqual(str(lowerCAmelCase_		)			,			str(lowerCAmelCase_		)		)





	def   _SCREAMING_SNAKE_CASE   (   self      :				Optional[int]		)		->    None:
				UpperCAmelCase_  :				Union[str, Any]      =      Vector([1, 0, 0]		)
				x.change_component(0			,			0		)
				x.change_component(1			,			1		)
				self.assertEqual(str(lowerCAmelCase_		)			,			"(0,1,0)"		)





	def   _SCREAMING_SNAKE_CASE   (   self      :				Any		)		->    None:
				UpperCAmelCase_  :				Optional[int]      =      Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]			,			3			,			3		)
				self.assertEqual("|1,2,3|\n|2,4,5|\n|6,7,8|\n"			,			str(lowerCAmelCase_		)		)





	def   _SCREAMING_SNAKE_CASE   (   self      :				str		)		->    None:
				UpperCAmelCase_  :				Optional[Any]      =      Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]			,			3			,			3		)
				UpperCAmelCase_  :				Any      =      [[-3, -14, -10], [-5, -10, -5], [-2, -1, 0]]
				for x in range(a.height()		):
							for y in range(a.width()		):
										self.assertEqual(minors[x][y]			,			a.minor(lowerCAmelCase_			,			lowerCAmelCase_		)		)





	def   _SCREAMING_SNAKE_CASE   (   self      :				Optional[int]		)		->    None:
				UpperCAmelCase_  :				Dict      =      Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]			,			3			,			3		)
				UpperCAmelCase_  :				Tuple      =      [[-3, 14, -10], [5, -10, 5], [-2, 1, 0]]
				for x in range(a.height()		):
							for y in range(a.width()		):
										self.assertEqual(cofactors[x][y]			,			a.cofactor(lowerCAmelCase_			,			lowerCAmelCase_		)		)





	def   _SCREAMING_SNAKE_CASE   (   self      :				List[str]		)		->    None:
				UpperCAmelCase_  :				int      =      Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]			,			3			,			3		)
				self.assertEqual(-5			,			a.determinant()		)





	def   _SCREAMING_SNAKE_CASE   (   self      :				Dict		)		->    None:
				UpperCAmelCase_  :				str      =      Matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]]			,			3			,			3		)
				UpperCAmelCase_  :				Union[str, Any]      =      Vector([1, 2, 3]		)
				self.assertEqual("(14,32,50)"			,			str(a * x		)		)
				self.assertEqual("|2,4,6|\n|8,10,12|\n|14,16,18|\n"			,			str(a * 2		)		)





	def   _SCREAMING_SNAKE_CASE   (   self      :				Optional[int]		)		->    None:
				UpperCAmelCase_  :				Optional[Any]      =      Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]			,			3			,			3		)
				a.change_component(0			,			2			,			5		)
				self.assertEqual("|1,2,5|\n|2,4,5|\n|6,7,8|\n"			,			str(lowerCAmelCase_		)		)





	def   _SCREAMING_SNAKE_CASE   (   self      :				Union[str, Any]		)		->    None:
				UpperCAmelCase_  :				Optional[int]      =      Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]			,			3			,			3		)
				self.assertEqual(7			,			a.component(2			,			1		)			,			0.0_1		)





	def   _SCREAMING_SNAKE_CASE   (   self      :				Dict		)		->    None:
				UpperCAmelCase_  :				str      =      Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]			,			3			,			3		)
				UpperCAmelCase_  :				List[str]      =      Matrix([[1, 2, 7], [2, 4, 5], [6, 7, 10]]			,			3			,			3		)
				self.assertEqual("|2,4,10|\n|4,8,10|\n|12,14,18|\n"			,			str(a + b		)		)





	def   _SCREAMING_SNAKE_CASE   (   self      :				Union[str, Any]		)		->    None:
				UpperCAmelCase_  :				int      =      Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]			,			3			,			3		)
				UpperCAmelCase_  :				List[str]      =      Matrix([[1, 2, 7], [2, 4, 5], [6, 7, 10]]			,			3			,			3		)
				self.assertEqual("|0,0,-4|\n|0,0,0|\n|0,0,-2|\n"			,			str(a - b		)		)





	def   _SCREAMING_SNAKE_CASE   (   self      :				str		)		->    None:
				self.assertEqual(
				    "|0,0,0,0,0|\n|0,0,0,0,0|\n|0,0,0,0,0|\n|0,0,0,0,0|\n|0,0,0,0,0|\n"			,			str(square_zero_matrix(5		)		)			,			)


if __name__ == "__main__":
			unittest.main()











"""simple docstring"""
from __future__ import annotations

import math

def        snake_case   (     A__		):

			if 1 < number < 4:
						# 2 and 3 are primes
						return True
			elif number < 2 or number % 2 == 0 or number % 3 == 0:
						# Negatives, 0, 1, all even numbers, all multiples of 3 are not primes
						return False

			# All primes number are in format of 6k +/- 1
			for i in range(5			,int(math.sqrt(A__		) + 1		)			,6		):
						if number % i == 0 or number % (i + 2) == 0:
									return False
			return True


lowerCamelCase_       			=   [num for num in range(3, 10_0001, 2) if not is_prime(num)]

def        snake_case   (     A__		):
			if not isinstance(A__			,A__		):
						raise ValueError("n must be an integer"		)
			if n <= 0:
						raise ValueError("n must be >= 0"		)

			UpperCAmelCase_  :				List[str]      =      []
			for num in range(len(A__		)		):
						UpperCAmelCase_  :				Dict      =      0
						while 2 * i * i <= odd_composites[num]:
									UpperCAmelCase_  :				List[str]      =      odd_composites[num] - 2 * i * i
									if is_prime(A__		):
												break
									i += 1
						else:
									list_nums.append(odd_composites[num]		)
									if len(A__		) == n:
												return list_nums

			return []

def        snake_case   (     ):
			return compute_nums(1		)[0]


if __name__ == "__main__":
			print(f'{solution() = }')



