





"""simple docstring"""


import unittest

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



class      __SCREAMING_SNAKE_CASE    (						unittest.TestCase   ):







  '''simple docstring'''


  def    __SCREAMING_SNAKE_CASE				(		self   :       Dict	)		->				None:
        _UpperCamelCase      :	List[Any]						=       Vector([1, 2, 3]	)
        self.assertEqual(x.component(0	)					,   1	)
        self.assertEqual(x.component(2	)					,   3	)
        _UpperCamelCase      :	List[str]						=       Vector()

  def    __SCREAMING_SNAKE_CASE				(		self   :       int	)		->				None:
        _UpperCamelCase      :	str						=       Vector([0, 0, 0, 0, 0, 1]	)
        self.assertEqual(str(__a	)					,   "(0,0,0,0,0,1)"	)

  def    __SCREAMING_SNAKE_CASE				(		self   :       int	)		->				None:
        _UpperCamelCase      :	List[str]						=       Vector([1, 2, 3, 4]	)
        self.assertEqual(len(__a	)					,   4	)

  def    __SCREAMING_SNAKE_CASE				(		self   :       Tuple	)		->				None:
        _UpperCamelCase      :	List[Any]						=       Vector([1, 2]	)
        _UpperCamelCase      :	Dict						=       Vector([1, 2, 3, 4, 5]	)
        _UpperCamelCase      :	Optional[int]						=       Vector([0, 0, 0, 0, 0, 0, 0, 0, 0, 0]	)
        _UpperCamelCase      :	Tuple						=       Vector([1, -1, 1, -1, 2, -3, 4, -5]	)
        self.assertAlmostEqual(x.euclidean_length()					,   2.2_36					,   3	)
        self.assertAlmostEqual(y.euclidean_length()					,   7.4_16					,   3	)
        self.assertEqual(z.euclidean_length()					,   0	)
        self.assertAlmostEqual(w.euclidean_length()					,   7.6_16					,   3	)

  def    __SCREAMING_SNAKE_CASE				(		self   :       List[Any]	)		->				None:
        _UpperCamelCase      :	int						=       Vector([1, 2, 3]	)
        _UpperCamelCase      :	Any						=       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   :       List[str]	)		->				None:
        _UpperCamelCase      :	Dict						=       Vector([1, 2, 3]	)
        _UpperCamelCase      :	List[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   :       int	)		->				None:
        _UpperCamelCase      :	Dict						=       Vector([1, 2, 3]	)
        _UpperCamelCase      :	Union[str, Any]						=       Vector([2, -1, 4]	)  # for test of dot product
        _UpperCamelCase      :	Any						=       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   :       List[Any]	)		->				None:
        self.assertEqual(str(zero_vector(10	)	).count("0"	)					,   10	)

  def    __SCREAMING_SNAKE_CASE				(		self   :       List[Any]	)		->				None:
        self.assertEqual(str(unit_basis_vector(3					,   1	)	)					,   "(0,1,0)"	)

  def    __SCREAMING_SNAKE_CASE				(		self   :       Any	)		->				None:
        _UpperCamelCase      :	int						=       Vector([1, 2, 3]	)
        _UpperCamelCase      :	Any						=       Vector([1, 0, 1]	)
        self.assertEqual(str(axpy(2					,   __a					,   __a	)	)					,   "(3,4,7)"	)

  def    __SCREAMING_SNAKE_CASE				(		self   :       Optional[int]	)		->				None:
        _UpperCamelCase      :	str						=       Vector([1, 0, 0, 0, 0, 0]	)
        _UpperCamelCase      :	Any						=       x.copy()
        self.assertEqual(str(__a	)					,   str(__a	)	)

  def    __SCREAMING_SNAKE_CASE				(		self   :       List[Any]	)		->				None:
        _UpperCamelCase      :	Union[str, Any]						=       Vector([1, 0, 0]	)
        x.change_component(0					,   0	)
        x.change_component(1					,   1	)
        self.assertEqual(str(__a	)					,   "(0,1,0)"	)

  def    __SCREAMING_SNAKE_CASE				(		self   :       List[str]	)		->				None:
        _UpperCamelCase      :	Dict						=       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(__a	)	)

  def    __SCREAMING_SNAKE_CASE				(		self   :       Optional[int]	)		->				None:
        _UpperCamelCase      :	str						=       Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]					,   3					,   3	)
        _UpperCamelCase      :	Union[str, 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(__a					,   __a	)	)

  def    __SCREAMING_SNAKE_CASE				(		self   :       Union[str, Any]	)		->				None:
        _UpperCamelCase      :	str						=       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(__a					,   __a	)	)

  def    __SCREAMING_SNAKE_CASE				(		self   :       Tuple	)		->				None:
        _UpperCamelCase      :	Optional[Any]						=       Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]					,   3					,   3	)
        self.assertEqual(-5					,   a.determinant()	)

  def    __SCREAMING_SNAKE_CASE				(		self   :       List[Any]	)		->				None:
        _UpperCamelCase      :	int						=       Matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]]					,   3					,   3	)
        _UpperCamelCase      :	Dict						=       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   :       int	)		->				None:
        _UpperCamelCase      :	List[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(__a	)	)

  def    __SCREAMING_SNAKE_CASE				(		self   :       str	)		->				None:
        _UpperCamelCase      :	Union[str, Any]						=       Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]					,   3					,   3	)
        self.assertEqual(7					,   a.component(2					,   1	)					,   0.01	)

  def    __SCREAMING_SNAKE_CASE				(		self   :       Dict	)		->				None:
        _UpperCamelCase      :	Tuple						=       Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]					,   3					,   3	)
        _UpperCamelCase      :	Tuple						=       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   :       List[Any]	)		->				None:
        _UpperCamelCase      :	Tuple						=       Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]					,   3					,   3	)
        _UpperCamelCase      :	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   :       int	)		->				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 collections.abc import Iterator, MutableMapping
from dataclasses import dataclass
from typing import Generic, TypeVar

lowerCamelCase__				  =   TypeVar("KEY")
lowerCamelCase__				  =   TypeVar("VAL")



@dataclass(frozen=_UpperCamelCase		,  slots=_UpperCamelCase   )
class      __SCREAMING_SNAKE_CASE    (						Generic[KEY, VAL]   ):







  '''simple docstring'''


  SCREAMING_SNAKE_CASE__							:KEY
  SCREAMING_SNAKE_CASE__							:VAL





class      __SCREAMING_SNAKE_CASE    (						_Item   ):







  '''simple docstring'''


  def __init__(		self   :       List[str]	)		->				None:
        super().__init__(__a					,   __a	)


  def __bool__(		self   :       Dict	)		->				bool:
        return False





lowerCamelCase__				  =   _DeletedItem()



class      __SCREAMING_SNAKE_CASE    (						MutableMapping[KEY, VAL]   ):







  '''simple docstring'''


  def __init__(		self   :       int					,   __a   :       int = 8					,   __a   :       float = 0.75	)		->				None:
        _UpperCamelCase      :	str						=       initial_block_size
        _UpperCamelCase      :	list[_Item | None]						=       [None] * initial_block_size
        assert 0.0 < capacity_factor < 1.0
        _UpperCamelCase      :	List[str]						=       capacity_factor
        _UpperCamelCase      :	Dict						=       0

  def    __SCREAMING_SNAKE_CASE				(		self   :       int					,   __a   :       KEY	)		->				int:
        return hash(__a	) % len(self._buckets	)

  def    __SCREAMING_SNAKE_CASE				(		self   :       List[Any]					,   __a   :       int	)		->				int:
        return (ind + 1) % len(self._buckets	)

  def    __SCREAMING_SNAKE_CASE				(		self   :       Tuple					,   __a   :       int					,   __a   :       KEY					,   __a   :       VAL	)		->				bool:
        _UpperCamelCase      :	List[Any]						=       self._buckets[ind]
        if not stored:
              _UpperCamelCase      :	Tuple						=       _Item(__a					,   __a	)
              self._len += 1
              return True
        elif stored.key == key:
              _UpperCamelCase      :	Union[str, Any]						=       _Item(__a					,   __a	)
              return True
        else:
              return False

  def    __SCREAMING_SNAKE_CASE				(		self   :       List[str]	)		->				bool:
        _UpperCamelCase      :	Any						=       len(self._buckets	) * self._capacity_factor
        return len(self	) >= int(__a	)

  def    __SCREAMING_SNAKE_CASE				(		self   :       str	)		->				bool:
        if len(self._buckets	) <= self._initial_block_size:
              return False
        _UpperCamelCase      :	List[str]						=       len(self._buckets	) * self._capacity_factor / 2
        return len(self	) < limit

  def    __SCREAMING_SNAKE_CASE				(		self   :       Union[str, Any]					,   __a   :       int	)		->				None:
        _UpperCamelCase      :	Any						=       self._buckets
        _UpperCamelCase      :	List[Any]						=       [None] * new_size
        _UpperCamelCase      :	List[str]						=       0
        for item in old_buckets:
              if item:
                    self._add_item(item.key					,   item.val	)

  def    __SCREAMING_SNAKE_CASE				(		self   :       int	)		->				None:
        self._resize(len(self._buckets	) * 2	)

  def    __SCREAMING_SNAKE_CASE				(		self   :       Union[str, Any]	)		->				None:
        self._resize(len(self._buckets	) // 2	)

  def    __SCREAMING_SNAKE_CASE				(		self   :       List[Any]					,   __a   :       KEY	)		->				Iterator[int]:
        _UpperCamelCase      :	str						=       self._get_bucket_index(__a	)
        for _ in range(len(self._buckets	)	):
              yield ind
              _UpperCamelCase      :	Tuple						=       self._get_next_ind(__a	)

  def    __SCREAMING_SNAKE_CASE				(		self   :       Optional[int]					,   __a   :       KEY					,   __a   :       VAL	)		->				None:
        for ind in self._iterate_buckets(__a	):
              if self._try_set(__a					,   __a					,   __a	):
                    break

  def __setitem__(		self   :       int					,   __a   :       KEY					,   __a   :       VAL	)		->				None:
        if self._is_full():
              self._size_up()

        self._add_item(__a					,   __a	)

  def __delitem__(		self   :       str					,   __a   :       KEY	)		->				None:
        for ind in self._iterate_buckets(__a	):
              _UpperCamelCase      :	Tuple						=       self._buckets[ind]
              if item is None:
                    raise KeyError(__a	)
              if item is _deleted:
                    continue
              if item.key == key:
                    _UpperCamelCase      :	List[Any]						=       _deleted
                    self._len -= 1
                    break
        if self._is_sparse():
              self._size_down()

  def __getitem__(		self   :       str					,   __a   :       KEY	)		->				VAL:
        for ind in self._iterate_buckets(__a	):
              _UpperCamelCase      :	Tuple						=       self._buckets[ind]
              if item is None:
                    break
              if item is _deleted:
                    continue
              if item.key == key:
                    return item.val
        raise KeyError(__a	)

  def __len__(		self   :       List[Any]	)		->				int:
        return self._len

  def __iter__(		self   :       List[str]	)		->				Iterator[KEY]:
        yield from (item.key for item in self._buckets if item)


  def __repr__(		self   :       List[str]	)		->				str:
        _UpperCamelCase      :	Optional[int]						=       " ,".join(
            F'''{item.key}: {item.val}''' for item in self._buckets if item	)
        return F'''HashMap({val_string})'''
