





from manim import *

class  _UpperCAmelCase				(		_lowerCamelCase  ):
      def 		_lowerCamelCase   (		self							):
         A_  :					Optional[Any]         =						Rectangle(height=0.5   ,							width=0.5							)
         A_  :					int         =						Rectangle(height=0.46   ,							width=0.46							).set_stroke(width=0							)

         A_  :					str         =						[mem.copy() for i in range(6							)]
         A_  :					Tuple         =						[mem.copy() for i in range(6							)]
         A_  :					int         =						VGroup(*__UpperCAmelCase							).arrange(__UpperCAmelCase   ,							buff=0							)
         A_  :					Optional[int]         =						VGroup(*__UpperCAmelCase							).arrange(__UpperCAmelCase   ,							buff=0							)
         A_  :					Tuple         =						VGroup(__UpperCAmelCase   ,							__UpperCAmelCase							).arrange(__UpperCAmelCase   ,							buff=0							)
         A_  :					str         =						Text("""CPU"""   ,							font_size=24							)
         A_  :					List[str]         =						Group(__UpperCAmelCase   ,							__UpperCAmelCase							).arrange(__UpperCAmelCase   ,							buff=0.5   ,							aligned_edge=__UpperCAmelCase							)
         cpu.move_to([-2.5, -0.5, 0]							)
         self.add(__UpperCAmelCase							)

         A_  :					List[Any]         =						[mem.copy() for i in range(1							)]
         A_  :					Tuple         =						VGroup(*__UpperCAmelCase							).arrange(__UpperCAmelCase   ,							buff=0							)
         A_  :					Optional[Any]         =						Text("""GPU"""   ,							font_size=24							)
         A_  :					Tuple         =						Group(__UpperCAmelCase   ,							__UpperCAmelCase							).arrange(__UpperCAmelCase   ,							buff=0.5   ,							aligned_edge=__UpperCAmelCase							)
         gpu.align_to(__UpperCAmelCase   ,							__UpperCAmelCase							)
         gpu.set_x(gpu.get_x() - 1							)

         self.add(__UpperCAmelCase							)

         A_  :					List[str]         =						[mem.copy() for i in range(6							)]
         A_  :					Dict         =						VGroup(*__UpperCAmelCase							).arrange(__UpperCAmelCase   ,							buff=0							)

         A_  :					Any         =						Text("""Model"""   ,							font_size=24							)
         A_  :					Union[str, Any]         =						Group(__UpperCAmelCase   ,							__UpperCAmelCase							).arrange(__UpperCAmelCase   ,							buff=0.5   ,							aligned_edge=__UpperCAmelCase							)
         model.move_to([3, -1.0, 0]							)

         self.play(
             Create(__UpperCAmelCase   ,							run_time=1							)   ,							Create(__UpperCAmelCase   ,							run_time=1							)   ,							Create(__UpperCAmelCase   ,							run_time=1							)   ,							)

         A_  :					Any         =						MarkupText(
             F"""First, an empty model skeleton is loaded\ninto <span fgcolor='{YELLOW}'>memory</span> without using much RAM."""   ,							font_size=24   ,							)

         A_  :					Union[str, Any]         =						Square(side_length=2.2							)
         key.move_to([-5, 2, 0]							)

         A_  :					str         =						MarkupText(
             F"""<b>Key:</b>\n\n<span fgcolor='{YELLOW}'>●</span> Empty Model"""   ,							font_size=18   ,							)

         key_text.move_to([-5, 2.4, 0]							)

         step_a.move_to([2, 2, 0]							)
         self.play(Write(__UpperCAmelCase   ,							run_time=2.5							)   ,							Write(__UpperCAmelCase							)   ,							Write(__UpperCAmelCase							)							)

         self.add(__UpperCAmelCase							)

         A_  :					str         =						[]
         A_  :					Union[str, Any]         =						[]
         A_  :					Any         =						[]
         for i, rect in enumerate(__UpperCAmelCase							):
            A_  :					Union[str, Any]         =						Rectangle(height=0.46   ,							width=0.46							).set_stroke(width=0.0							).set_fill(__UpperCAmelCase   ,							opacity=0.7							)
            cpu_target.move_to(__UpperCAmelCase							)
            cpu_target.generate_target()
            A_  :					Optional[int]         =						0.46 / 4
            A_  :					Optional[Any]         =						0.46 / 3

            if i == 0:
               cpu_target.target.next_to(cpu_left_col_base[0].get_corner(DOWN + LEFT							)   ,							buff=0.02   ,							direction=__UpperCAmelCase							)
               cpu_target.target.set_x(cpu_target.target.get_x() + 0.1							)
            elif i == 3:
               cpu_target.target.next_to(cpu_targs[0].target   ,							direction=__UpperCAmelCase   ,							buff=0.0							)
            else:
               cpu_target.target.next_to(cpu_targs[i - 1].target   ,							direction=__UpperCAmelCase   ,							buff=0.0							)
            cpu_targs.append(__UpperCAmelCase							)

            first_animations.append(rect.animate(run_time=0.5							).set_stroke(__UpperCAmelCase							)							)
            second_animations.append(MoveToTarget(__UpperCAmelCase   ,							run_time=1.5							)							)

         self.play(*__UpperCAmelCase							)
         self.play(*__UpperCAmelCase							)

         self.wait()














from typing import Any

import numpy as np
def 		_a       ( a					:np.ndarray					)				->     bool:
 return np.array_equal(a      ,				matrix.conjugate().T					)
def 		_a       ( a					:np.ndarray      ,				a					:np.ndarray					)				->     Any:
 a						    = v.conjugate().T
 a						    = v_star.dot(a					)
 assert isinstance(a      ,				np.ndarray					)
 return (v_star_dot.dot(a					)) / (v_star.dot(a					))
def 		_a       ( )				->     None:
 a						    = np.array([[2, 2 + 1j, 4], [2 - 1j, 3, 1j], [4, -1j, 1]]					)
 a						    = np.array([[1], [2], [3]]					)
 assert is_hermitian(a					), F"""{a} is not hermitian."""
 print(rayleigh_quotient(a      ,				a					)					)

 a						    = np.array([[1, 2, 4], [2, 3, -1], [4, -1, 1]]					)
 assert is_hermitian(a					), F"""{a} is not hermitian."""
 assert rayleigh_quotient(a      ,				a					) == float(3					)


if __name__ == "__main__":
     import doctest

     doctest.testmod()
     tests()


