


"""simple docstring"""

import unittest

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





class  lowerCamelCase__    (		unittest.TestCase     ):
      def SCREAMING_SNAKE_CASE_						(		self						:						Union[str, Any]				):






       '''simple docstring'''


       __lowercase						=						Vector([1, 2, 3]				)
       self.assertEqual(x.component(0				)   ,							1				)
       self.assertEqual(x.component(2				)   ,							3				)
       __lowercase						=						Vector()
      def SCREAMING_SNAKE_CASE_						(		self						:						int				):






       '''simple docstring'''


       __lowercase						=						Vector([0, 0, 0, 0, 0, 1]				)
       self.assertEqual(str(A_				)   ,							"""(0,0,0,0,0,1)"""				)
      def SCREAMING_SNAKE_CASE_						(		self						:						List[Any]				):






       '''simple docstring'''


       __lowercase						=						Vector([1, 2, 3, 4]				)
       self.assertEqual(len(A_				)   ,							4				)
      def SCREAMING_SNAKE_CASE_						(		self						:						int				):






       '''simple docstring'''


       __lowercase						=						Vector([1, 2]				)
       __lowercase						=						Vector([1, 2, 3, 4, 5]				)
       __lowercase						=						Vector([0, 0, 0, 0, 0, 0, 0, 0, 0, 0]				)
       __lowercase						=						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]				):






       '''simple docstring'''


       __lowercase						=						Vector([1, 2, 3]				)
       __lowercase						=						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						:						Optional[int]				):






       '''simple docstring'''


       __lowercase						=						Vector([1, 2, 3]				)
       __lowercase						=						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						:						Any				):






       '''simple docstring'''


       __lowercase						=						Vector([1, 2, 3]				)
       __lowercase						=						Vector([2, -1, 4]				)  # for test of dot product
       __lowercase						=						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						:						Any				):






       '''simple docstring'''


       self.assertEqual(str(zero_vector(1_0				)				).count("""0"""				)   ,							1_0				)
      def SCREAMING_SNAKE_CASE_						(		self						:						Tuple				):






       '''simple docstring'''


       self.assertEqual(str(unit_basis_vector(3   ,							1				)				)   ,							"""(0,1,0)"""				)
      def SCREAMING_SNAKE_CASE_						(		self						:						List[str]				):






       '''simple docstring'''


       __lowercase						=						Vector([1, 2, 3]				)
       __lowercase						=						Vector([1, 0, 1]				)
       self.assertEqual(str(axpy(2   ,							A_   ,							A_				)				)   ,							"""(3,4,7)"""				)
      def SCREAMING_SNAKE_CASE_						(		self						:						Union[str, Any]				):






       '''simple docstring'''


       __lowercase						=						Vector([1, 0, 0, 0, 0, 0]				)
       __lowercase						=						x.copy()
       self.assertEqual(str(A_				)   ,							str(A_				)				)
      def SCREAMING_SNAKE_CASE_						(		self						:						List[str]				):






       '''simple docstring'''


       __lowercase						=						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						:						Any				):






       '''simple docstring'''


       __lowercase						=						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						:						Tuple				):






       '''simple docstring'''


       __lowercase						=						Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]   ,							3   ,							3				)
       __lowercase						=						[[-3, -1_4, -1_0], [-5, -1_0, -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						:						Dict				):






       '''simple docstring'''


       __lowercase						=						Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]   ,							3   ,							3				)
       __lowercase						=						[[-3, 1_4, -1_0], [5, -1_0, 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				):






       '''simple docstring'''


       __lowercase						=						Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]   ,							3   ,							3				)
       self.assertEqual(-5   ,							a.determinant()				)
      def SCREAMING_SNAKE_CASE_						(		self						:						List[str]				):






       '''simple docstring'''


       __lowercase						=						Matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]]   ,							3   ,							3				)
       __lowercase						=						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						:						Union[str, Any]				):






       '''simple docstring'''


       __lowercase						=						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						:						Any				):






       '''simple docstring'''


       __lowercase						=						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						:						Optional[Any]				):






       '''simple docstring'''


       __lowercase						=						Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]   ,							3   ,							3				)
       __lowercase						=						Matrix([[1, 2, 7], [2, 4, 5], [6, 7, 1_0]]   ,							3   ,							3				)
       self.assertEqual("""|2,4,10|\n|4,8,10|\n|12,14,18|\n"""   ,							str(a + b				)				)
      def SCREAMING_SNAKE_CASE_						(		self						:						Optional[Any]				):






       '''simple docstring'''


       __lowercase						=						Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]   ,							3   ,							3				)
       __lowercase						=						Matrix([[1, 2, 7], [2, 4, 5], [6, 7, 1_0]]   ,							3   ,							3				)
       self.assertEqual("""|0,0,-4|\n|0,0,0|\n|0,0,-2|\n"""   ,							str(a - b				)				)






      def SCREAMING_SNAKE_CASE_						(		self						:						Dict				):






       '''simple docstring'''


       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 PIL import Image


def lowerCAmelCase_   (					UpperCamelCase__						:			Image					, UpperCamelCase__						:			int			):






 """simple docstring"""







 __lowercase						=						(259 * (level + 255)) / (255 * (259 - level))

 def contrast(UpperCamelCase__						:			int			) -> int:
  return int(128 + factor * (c - 128)			)

 return img.point(UpperCamelCase__			)


if __name__ == "__main__":
       # Load image
       with Image.open("image_data/lena.jpg") as img:
              # Change contrast to 170
              UpperCAmelCase__					=change_contrast(img, 170)
              cont_img.save("image_data/lena_high_contrast.png", format="png")
