



from __future__ import annotations






def        __lowerCAmelCase		(	__lowerCamelCase						:     float					, __lowerCamelCase						:     float					, __lowerCamelCase						:     float						)	->    dict[str, float]:
					if (voltage, current, resistance).count(0						) != 1:
										raise ValueError("""One and only one argument must be 0"""						)
					if resistance < 0:
										raise ValueError("""Resistance cannot be negative"""						)
					if voltage == 0:
										return {"voltage": float(current * resistance						)}
					elif current == 0:
										return {"current": voltage / resistance}
					elif resistance == 0:
										return {"resistance": voltage / current}
					else:
										raise ValueError("""Exactly one argument must be 0"""						)


if __name__ == "__main__":
				import doctest

				doctest.testmod()









from manim import *






class     __a			(  SCREAMING_SNAKE_CASE					):



	def 		UpperCamelCase				(    self				:     Tuple)->				Dict:
						__lowerCAmelCase						 =Rectangle(height=0.5					,						width=0.5)
						__lowerCAmelCase						 =Rectangle(height=0.4_6					,						width=0.4_6).set_stroke(width=0)

						__lowerCAmelCase						 =[mem.copy() for i in range(6)]
						__lowerCAmelCase						 =[mem.copy() for i in range(6)]
						__lowerCAmelCase						 =VGroup(*snake_case_).arrange(snake_case_					,						buff=0)
						__lowerCAmelCase						 =VGroup(*snake_case_).arrange(snake_case_					,						buff=0)
						__lowerCAmelCase						 =VGroup(snake_case_					,						snake_case_).arrange(snake_case_					,						buff=0)
						__lowerCAmelCase						 =Text("""CPU"""					,						font_size=24)
						__lowerCAmelCase						 =Group(snake_case_					,						snake_case_).arrange(snake_case_					,						buff=0.5					,						aligned_edge=snake_case_)
						cpu.move_to([-2.5, -0.5, 0])
						self.add(snake_case_)

						__lowerCAmelCase						 =[mem.copy() for i in range(1)]
						__lowerCAmelCase						 =VGroup(*snake_case_).arrange(snake_case_					,						buff=0)
						__lowerCAmelCase						 =Text("""GPU"""					,						font_size=24)
						__lowerCAmelCase						 =Group(snake_case_					,						snake_case_).arrange(snake_case_					,						buff=0.5					,						aligned_edge=snake_case_)
						gpu.align_to(snake_case_					,						snake_case_)
						gpu.set_x(gpu.get_x() - 1)

						self.add(snake_case_)

						__lowerCAmelCase						 =[mem.copy() for i in range(6)]
						__lowerCAmelCase						 =VGroup(*snake_case_).arrange(snake_case_					,						buff=0)

						__lowerCAmelCase						 =Text("""Model"""					,						font_size=24)
						__lowerCAmelCase						 =Group(snake_case_					,						snake_case_).arrange(snake_case_					,						buff=0.5					,						aligned_edge=snake_case_)
						model.move_to([3, -1.0, 0])

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

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

						__lowerCAmelCase						 =Square(side_length=2.2)
						key.move_to([-5, 2, 0])

						__lowerCAmelCase						 =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(snake_case_					,						run_time=2.5)					,						Write(snake_case_)					,						Write(snake_case_))

						self.add(snake_case_)

						__lowerCAmelCase						 =[]
						__lowerCAmelCase						 =[]
						__lowerCAmelCase						 =[]
						for i, rect in enumerate(snake_case_):
											__lowerCAmelCase						 =Rectangle(height=0.4_6					,						width=0.4_6).set_stroke(width=0.0).set_fill(snake_case_					,						opacity=0.7)
											cpu_target.move_to(snake_case_)
											cpu_target.generate_target()
											__lowerCAmelCase						 =0.4_6 / 4
											__lowerCAmelCase						 =0.4_6 / 3

											if i == 0:
																cpu_target.target.next_to(cpu_left_col_base[0].get_corner(DOWN + LEFT)					,						buff=0.0_2					,						direction=snake_case_)
																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=snake_case_					,						buff=0.0)
											else:
																cpu_target.target.next_to(cpu_targs[i - 1].target					,						direction=snake_case_					,						buff=0.0)
											cpu_targs.append(snake_case_)

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

						self.play(*snake_case_)
						self.play(*snake_case_)

						self.wait()




