
import inspect
from typing import Optional, Union

import numpy as np
import PIL
import torch
from torch.nn import functional as F
from torchvision import transforms
from transformers import CLIPFeatureExtractor, CLIPModel, CLIPTextModel, CLIPTokenizer

from diffusers import (
    AutoencoderKL,
    DDIMScheduler,
    DiffusionPipeline,
    DPMSolverMultistepScheduler,
    LMSDiscreteScheduler,
    PNDMScheduler,
    UNetaDConditionModel,
)
from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion import StableDiffusionPipelineOutput
from diffusers.utils import (
    PIL_INTERPOLATION,
    randn_tensor,
)
def 				a__   (   a   :				str       ,     a   :				List[str]       ,     a   :				List[Any]		):

  """simple docstring"""







  if isinstance(_lowerCamelCase       ,     torch.Tensor		):
    return image
  elif isinstance(_lowerCamelCase       ,     PIL.Image.Image		):
    _snake_case     :						Optional[Any]						=   [image]

  if isinstance(image[0]       ,     PIL.Image.Image		):
    _snake_case     :						Union[str, Any]						=   [np.array(i.resize((w, h)       ,     resample=PIL_INTERPOLATION["lanczos"]		)		)[None, :] for i in image]
    _snake_case     :						Union[str, Any]						=   np.concatenate(_lowerCamelCase       ,     axis=0		)
    _snake_case     :						int						=   np.array(_lowerCamelCase		).astype(np.floataa		) / 255.0
    _snake_case     :						str						=   image.transpose(0       ,     3       ,     1       ,     2		)
    _snake_case     :						Any						=   2.0 * image - 1.0
    _snake_case     :						List[Any]						=   torch.from_numpy(_lowerCamelCase		)
  elif isinstance(image[0]       ,     torch.Tensor		):
    _snake_case     :						Dict						=   torch.cat(_lowerCamelCase       ,     dim=0		)
  return image
def 				a__   (   a   :				Tuple       ,     a   :				Union[str, Any]       ,     a   :				List[str]       ,     a   :				List[str]=0.9995		):

  """simple docstring"""







  if not isinstance(_lowerCamelCase       ,     np.ndarray		):
    _snake_case     :						Dict						=   True
    _snake_case     :						Union[str, Any]						=   va.device
    _snake_case     :						Optional[Any]						=   va.cpu().numpy()
    _snake_case     :						List[Any]						=   va.cpu().numpy()

  _snake_case     :						Any						=   np.sum(va * va / (np.linalg.norm(_lowerCamelCase		) * np.linalg.norm(_lowerCamelCase		))		)
  if np.abs(_lowerCamelCase		) > DOT_THRESHOLD:
    _snake_case     :						Any						=   (1 - t) * va + t * va
  else:
    _snake_case     :						List[str]						=   np.arccos(_lowerCamelCase		)
    _snake_case     :						str						=   np.sin(_lowerCamelCase		)
    _snake_case     :						Dict						=   theta_a * t
    _snake_case     :						Union[str, Any]						=   np.sin(_lowerCamelCase		)
    _snake_case     :						Optional[int]						=   np.sin(theta_a - theta_t		) / sin_theta_a
    _snake_case     :						Optional[Any]						=   sin_theta_t / sin_theta_a
    _snake_case     :						int						=   sa * va + sa * va

  if inputs_are_torch:
    _snake_case     :						Optional[Any]						=   torch.from_numpy(_lowerCamelCase		).to(_lowerCamelCase		)

  return va
def 				a__   (   a   :				str       ,     a   :				Any		):

  """simple docstring"""







  _snake_case     :						str						=   F.normalize(_lowerCamelCase       ,     dim=-1		)
  _snake_case     :						Optional[int]						=   F.normalize(_lowerCamelCase       ,     dim=-1		)
  return (x - y).norm(dim=-1		).div(2		).arcsin().pow(2		).mul(2		)
def 				a__   (   a   :				Dict       ,     a   :				Any		):

  """simple docstring"""







  for param in model.parameters():
    _snake_case     :						Tuple						=   value






class      _UpperCAmelCase				(					_snake_case):
    def __init__(    self						,    snake_case_						,    snake_case_						,    snake_case_						,    snake_case_						,    snake_case_						,    snake_case_						,    snake_case_						,    snake_case_=None						,    snake_case_=None						,    snake_case_=None						,    ):
      super().__init__()
      self.register_modules(
          vae=UpperCamelCase__						,    text_encoder=UpperCamelCase__						,    clip_model=UpperCamelCase__						,    tokenizer=UpperCamelCase__						,    unet=UpperCamelCase__						,    scheduler=UpperCamelCase__						,    feature_extractor=UpperCamelCase__						,    coca_model=UpperCamelCase__						,    coca_tokenizer=UpperCamelCase__						,    coca_transform=UpperCamelCase__						,    )
      _snake_case     :						Optional[int]						=   (
          feature_extractor.size
          if isinstance(feature_extractor.size						,    UpperCamelCase__     )
          else feature_extractor.size["shortest_edge"]
      )
      _snake_case     :						str						=   transforms.Normalize(mean=feature_extractor.image_mean						,    std=feature_extractor.image_std     )
      set_requires_grad(self.text_encoder						,    UpperCamelCase__     )
      set_requires_grad(self.clip_model						,    UpperCamelCase__     )
    def 					lowerCamelCase__	(    self						,    snake_case_ = "auto"     ):





      if slice_size == "auto":
        # half the attention head size is usually a good trade-off between
        # speed and memory
        _snake_case     :						Optional[Any]						=   self.unet.config.attention_head_dim // 2
      self.unet.set_attention_slice(UpperCamelCase__     )
    def 					lowerCamelCase__	(    self     ):
      self.enable_attention_slicing(UpperCamelCase__     )
    def 					lowerCamelCase__	(    self     ):
      set_requires_grad(self.vae						,    UpperCamelCase__     )
    def 					lowerCamelCase__	(    self     ):
      set_requires_grad(self.vae						,    UpperCamelCase__     )
    def 					lowerCamelCase__	(    self     ):
      set_requires_grad(self.unet						,    UpperCamelCase__     )
    def 					lowerCamelCase__	(    self     ):
      set_requires_grad(self.unet						,    UpperCamelCase__     )
    def 					lowerCamelCase__	(    self						,    snake_case_						,    snake_case_						,    snake_case_     ):
      _snake_case     :						Dict						=   min(int(num_inference_steps * strength     )						,    UpperCamelCase__     )

      _snake_case     :						Tuple						=   max(num_inference_steps - init_timestep						,    0     )
      _snake_case     :						Tuple						=   self.scheduler.timesteps[t_start:]

      return timesteps, num_inference_steps - t_start
    def 					lowerCamelCase__	(    self						,    snake_case_						,    snake_case_						,    snake_case_						,    snake_case_						,    snake_case_						,    snake_case_=None     ):





      if not isinstance(UpperCamelCase__						,    torch.Tensor     ):
        raise ValueError(F'`image` has to be of type `torch.Tensor` but is {type(UpperCamelCase__     )}'     )

      _snake_case     :						str						=   image.to(device=UpperCamelCase__						,    dtype=UpperCamelCase__     )

      if isinstance(UpperCamelCase__						,    UpperCamelCase__     ):
        _snake_case     :						Union[str, Any]						=   [
            self.vae.encode(image[i : i + 1]     ).latent_dist.sample(generator[i]     ) for i in range(UpperCamelCase__     )
        ]
        _snake_case     :						List[str]						=   torch.cat(UpperCamelCase__						,    dim=0     )
      else:
        _snake_case     :						Union[str, Any]						=   self.vae.encode(UpperCamelCase__     ).latent_dist.sample(UpperCamelCase__     )

      # Hardcode 0.18215 because stable-diffusion-2-base has not self.vae.config.scaling_factor
      _snake_case     :						List[Any]						=   0.18215 * init_latents
      _snake_case     :						List[str]						=   init_latents.repeat_interleave(UpperCamelCase__						,    dim=0     )

      _snake_case     :						Tuple						=   randn_tensor(init_latents.shape						,    generator=UpperCamelCase__						,    device=UpperCamelCase__						,    dtype=UpperCamelCase__     )

      # get latents
      _snake_case     :						int						=   self.scheduler.add_noise(UpperCamelCase__						,    UpperCamelCase__						,    UpperCamelCase__     )
      _snake_case     :						int						=   init_latents

      return latents
    def 					lowerCamelCase__	(    self						,    snake_case_     ):
      _snake_case     :						Any						=   self.coca_transform(UpperCamelCase__     ).unsqueeze(0     )
      with torch.no_grad(), torch.cuda.amp.autocast():
        _snake_case     :						int						=   self.coca_model.generate(transformed_image.to(device=self.device						,    dtype=self.coca_model.dtype     )     )
      _snake_case     :						str						=   self.coca_tokenizer.decode(generated[0].cpu().numpy()     )
      return generated.split("<end_of_text>"     )[0].replace("<start_of_text>"						,    ""     ).rstrip(" .,"     )
    def 					lowerCamelCase__	(    self						,    snake_case_						,    snake_case_     ):
      _snake_case     :						int						=   self.feature_extractor.preprocess(UpperCamelCase__     )
      _snake_case     :						List[str]						=   torch.from_numpy(clip_image_input["pixel_values"][0]     ).unsqueeze(0     ).to(self.device     ).half()
      _snake_case     :						str						=   self.clip_model.get_image_features(UpperCamelCase__     )
      _snake_case     :						Optional[int]						=   image_embeddings_clip / image_embeddings_clip.norm(p=2						,    dim=-1						,    keepdim=UpperCamelCase__     )
      _snake_case     :						Tuple						=   image_embeddings_clip.repeat_interleave(UpperCamelCase__						,    dim=0     )
      return image_embeddings_clip
    @torch.enable_grad()
    def 					lowerCamelCase__	(    self						,    snake_case_						,    snake_case_						,    snake_case_						,    snake_case_						,    snake_case_						,    snake_case_						,    snake_case_						,    ):
      _snake_case     :						Any						=   latents.detach().requires_grad_()

      _snake_case     :						List[Any]						=   self.scheduler.scale_model_input(UpperCamelCase__						,    UpperCamelCase__     )

      # predict the noise residual
      _snake_case     :						Union[str, Any]						=   self.unet(UpperCamelCase__						,    UpperCamelCase__						,    encoder_hidden_states=UpperCamelCase__     ).sample

      if isinstance(self.scheduler						,    (PNDMScheduler, DDIMScheduler, DPMSolverMultistepScheduler)     ):
        _snake_case     :						Any						=   self.scheduler.alphas_cumprod[timestep]
        _snake_case     :						Optional[Any]						=   1 - alpha_prod_t
        # compute predicted original sample from predicted noise also called
        # "predicted x_0" of formula (12) from https://arxiv.org/pdf/2010.02502.pdf
        _snake_case     :						Optional[Any]						=   (latents - beta_prod_t ** 0.5 * noise_pred) / alpha_prod_t ** 0.5

        _snake_case     :						Dict						=   torch.sqrt(UpperCamelCase__     )
        _snake_case     :						Optional[int]						=   pred_original_sample * (fac) + latents * (1 - fac)
      elif isinstance(self.scheduler						,    UpperCamelCase__     ):
        _snake_case     :						int						=   self.scheduler.sigmas[index]
        _snake_case     :						Tuple						=   latents - sigma * noise_pred
      else:
        raise ValueError(F'scheduler type {type(self.scheduler     )} not supported'     )

      # Hardcode 0.18215 because stable-diffusion-2-base has not self.vae.config.scaling_factor
      _snake_case     :						Dict						=   1 / 0.18215 * sample
      _snake_case     :						int						=   self.vae.decode(UpperCamelCase__     ).sample
      _snake_case     :						Dict						=   (image / 2 + 0.5).clamp(0						,    1     )

      _snake_case     :						Dict						=   transforms.Resize(self.feature_extractor_size     )(UpperCamelCase__     )
      _snake_case     :						Dict						=   self.normalize(UpperCamelCase__     ).to(latents.dtype     )

      _snake_case     :						Union[str, Any]						=   self.clip_model.get_image_features(UpperCamelCase__     )
      _snake_case     :						Optional[int]						=   image_embeddings_clip / image_embeddings_clip.norm(p=2						,    dim=-1						,    keepdim=UpperCamelCase__     )

      _snake_case     :						Optional[Any]						=   spherical_dist_loss(UpperCamelCase__						,    UpperCamelCase__     ).mean() * clip_guidance_scale

      _snake_case     :						Union[str, Any]						=   -torch.autograd.grad(UpperCamelCase__						,    UpperCamelCase__     )[0]

      if isinstance(self.scheduler						,    UpperCamelCase__     ):
        _snake_case     :						Optional[Any]						=   latents.detach() + grads * (sigma**2)
        _snake_case     :						Tuple						=   noise_pred_original
      else:
        _snake_case     :						int						=   noise_pred_original - torch.sqrt(UpperCamelCase__     ) * grads
      return noise_pred, latents


    @torch.no_grad()
    def __call__(    self						,    snake_case_						,    snake_case_						,    snake_case_ = None						,    snake_case_ = None						,    snake_case_ = 5_12						,    snake_case_ = 5_12						,    snake_case_ = 0.6						,    snake_case_ = 50						,    snake_case_ = 7.5						,    snake_case_ = 1						,    snake_case_ = 0.0						,    snake_case_ = 1_00						,    snake_case_ = None						,    snake_case_ = "pil"						,    snake_case_ = True						,    snake_case_ = 0.8						,    snake_case_ = 0.1						,    snake_case_ = 0.1						,    ):





      if isinstance(UpperCamelCase__						,    UpperCamelCase__     ) and len(UpperCamelCase__     ) != batch_size:
        raise ValueError(F'You have passed {batch_size} batch_size, but only {len(UpperCamelCase__     )} generators.'     )

      if height % 8 != 0 or width % 8 != 0:
        raise ValueError(F'`height` and `width` have to be divisible by 8 but are {height} and {width}.'     )

      if isinstance(UpperCamelCase__						,    torch.Generator     ) and batch_size > 1:
        _snake_case     :						Dict						=   [generator] + [None] * (batch_size - 1)

      _snake_case     :						int						=   [
          ("model", self.coca_model is None),
          ("tokenizer", self.coca_tokenizer is None),
          ("transform", self.coca_transform is None),
      ]
      _snake_case     :						Tuple						=   [x[0] for x in coca_is_none if x[1]]
      _snake_case     :						List[str]						=   ", ".join(UpperCamelCase__     )
      # generate prompts with coca model if prompt is None
      if content_prompt is None:
        if len(UpperCamelCase__     ):
          raise ValueError(
              F'Content prompt is None and CoCa [{coca_is_none_str}] is None.'
              F'Set prompt or pass Coca [{coca_is_none_str}] to DiffusionPipeline.'     )
        _snake_case     :						Tuple						=   self.get_image_description(UpperCamelCase__     )
      if style_prompt is None:
        if len(UpperCamelCase__     ):
          raise ValueError(
              F'Style prompt is None and CoCa [{coca_is_none_str}] is None.'
              F' Set prompt or pass Coca [{coca_is_none_str}] to DiffusionPipeline.'     )
        _snake_case     :						Union[str, Any]						=   self.get_image_description(UpperCamelCase__     )

      # get prompt text embeddings for content and style
      _snake_case     :						List[str]						=   self.tokenizer(
          UpperCamelCase__						,    padding="max_length"						,    max_length=self.tokenizer.model_max_length						,    truncation=UpperCamelCase__						,    return_tensors="pt"						,    )
      _snake_case     :						List[str]						=   self.text_encoder(content_text_input.input_ids.to(self.device     )     )[0]

      _snake_case     :						int						=   self.tokenizer(
          UpperCamelCase__						,    padding="max_length"						,    max_length=self.tokenizer.model_max_length						,    truncation=UpperCamelCase__						,    return_tensors="pt"						,    )
      _snake_case     :						Dict						=   self.text_encoder(style_text_input.input_ids.to(self.device     )     )[0]

      _snake_case     :						str						=   slerp(UpperCamelCase__						,    UpperCamelCase__						,    UpperCamelCase__     )

      # duplicate text embeddings for each generation per prompt
      _snake_case     :						Tuple						=   text_embeddings.repeat_interleave(UpperCamelCase__						,    dim=0     )

      # set timesteps
      _snake_case     :						Optional[Any]						=   "offset" in set(inspect.signature(self.scheduler.set_timesteps     ).parameters.keys()     )
      _snake_case     :						str						=   {}
      if accepts_offset:
        _snake_case     :						Tuple						=   1

      self.scheduler.set_timesteps(UpperCamelCase__						,    **UpperCamelCase__     )
      # Some schedulers like PNDM have timesteps as arrays
      # It's more optimized to move all timesteps to correct device beforehand
      self.scheduler.timesteps.to(self.device     )

      _snake_case			,					_snake_case     :						List[Any]						=   self.get_timesteps(UpperCamelCase__						,    UpperCamelCase__						,    self.device     )
      _snake_case     :						Any						=   timesteps[:1].repeat(UpperCamelCase__     )

      # Preprocess image
      _snake_case     :						List[str]						=   preprocess(UpperCamelCase__						,    UpperCamelCase__						,    UpperCamelCase__     )
      _snake_case     :						int						=   self.prepare_latents(
          UpperCamelCase__						,    UpperCamelCase__						,    UpperCamelCase__						,    text_embeddings.dtype						,    self.device						,    UpperCamelCase__     )

      _snake_case     :						Dict						=   preprocess(UpperCamelCase__						,    UpperCamelCase__						,    UpperCamelCase__     )
      _snake_case     :						Dict						=   self.prepare_latents(
          UpperCamelCase__						,    UpperCamelCase__						,    UpperCamelCase__						,    text_embeddings.dtype						,    self.device						,    UpperCamelCase__     )

      _snake_case     :						List[str]						=   slerp(UpperCamelCase__						,    UpperCamelCase__						,    UpperCamelCase__     )

      if clip_guidance_scale > 0:
        _snake_case     :						Optional[int]						=   self.get_clip_image_embeddings(UpperCamelCase__						,    UpperCamelCase__     )
        _snake_case     :						List[Any]						=   self.get_clip_image_embeddings(UpperCamelCase__						,    UpperCamelCase__     )
        _snake_case     :						str						=   slerp(
            UpperCamelCase__						,    UpperCamelCase__						,    UpperCamelCase__     )

      # here `guidance_scale` is defined analog to the guidance weight `w` of equation (2)
      # of the Imagen paper: https://arxiv.org/pdf/2205.11487.pdf . `guidance_scale = 1`
      # corresponds to doing no classifier free guidance.
      _snake_case     :						Optional[int]						=   guidance_scale > 1.0
      # get unconditional embeddings for classifier free guidance
      if do_classifier_free_guidance:
        _snake_case     :						List[str]						=   content_text_input.input_ids.shape[-1]
        _snake_case     :						Optional[Any]						=   self.tokenizer([""]						,    padding="max_length"						,    max_length=UpperCamelCase__						,    return_tensors="pt"     )
        _snake_case     :						List[Any]						=   self.text_encoder(uncond_input.input_ids.to(self.device     )     )[0]
        # duplicate unconditional embeddings for each generation per prompt
        _snake_case     :						Any						=   uncond_embeddings.repeat_interleave(UpperCamelCase__						,    dim=0     )

        # For classifier free guidance, we need to do two forward passes.
        # Here we concatenate the unconditional and text embeddings into a single batch
        # to avoid doing two forward passes
        _snake_case     :						Tuple						=   torch.cat([uncond_embeddings, text_embeddings]     )

      # get the initial random noise unless the user supplied it

      # Unlike in other pipelines, latents need to be generated in the target device
      # for 1-to-1 results reproducibility with the CompVis implementation.
      # However this currently doesn't work in `mps`.
      _snake_case     :						Optional[Any]						=   (batch_size, self.unet.config.in_channels, height // 8, width // 8)
      _snake_case     :						Tuple						=   text_embeddings.dtype
      if latents is None:
        if self.device.type == "mps":
          # randn does not work reproducibly on mps
          _snake_case     :						Tuple						=   torch.randn(UpperCamelCase__						,    generator=UpperCamelCase__						,    device="cpu"						,    dtype=UpperCamelCase__     ).to(
              self.device     )
        else:
          _snake_case     :						Optional[int]						=   torch.randn(UpperCamelCase__						,    generator=UpperCamelCase__						,    device=self.device						,    dtype=UpperCamelCase__     )
      else:
        if latents.shape != latents_shape:
          raise ValueError(F'Unexpected latents shape, got {latents.shape}, expected {latents_shape}'     )
        _snake_case     :						int						=   latents.to(self.device     )

      # scale the initial noise by the standard deviation required by the scheduler
      _snake_case     :						List[str]						=   latents * self.scheduler.init_noise_sigma

      # prepare extra kwargs for the scheduler step, since not all schedulers have the same signature
      # eta (η) is only used with the DDIMScheduler, it will be ignored for other schedulers.
      # eta corresponds to η in DDIM paper: https://arxiv.org/abs/2010.02502
      # and should be between [0, 1]
      _snake_case     :						str						=   "eta" in set(inspect.signature(self.scheduler.step     ).parameters.keys()     )
      _snake_case     :						Optional[int]						=   {}
      if accepts_eta:
        _snake_case     :						Any						=   eta

      # check if the scheduler accepts generator
      _snake_case     :						str						=   "generator" in set(inspect.signature(self.scheduler.step     ).parameters.keys()     )
      if accepts_generator:
        _snake_case     :						Union[str, Any]						=   generator

      with self.progress_bar(total=UpperCamelCase__     ):
        for i, t in enumerate(UpperCamelCase__     ):
          # expand the latents if we are doing classifier free guidance
          _snake_case     :						Optional[Any]						=   torch.cat([latents] * 2     ) if do_classifier_free_guidance else latents
          _snake_case     :						Tuple						=   self.scheduler.scale_model_input(UpperCamelCase__						,    UpperCamelCase__     )

          # predict the noise residual
          _snake_case     :						Tuple						=   self.unet(UpperCamelCase__						,    UpperCamelCase__						,    encoder_hidden_states=UpperCamelCase__     ).sample

          # perform classifier free guidance
          if do_classifier_free_guidance:
            _snake_case			,					_snake_case     :						Dict						=   noise_pred.chunk(2     )
            _snake_case     :						Any						=   noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond)

          # perform clip guidance
          if clip_guidance_scale > 0:
            _snake_case     :						str						=   (
                text_embeddings.chunk(2     )[1] if do_classifier_free_guidance else text_embeddings
            )
            _snake_case			,					_snake_case     :						Union[str, Any]						=   self.cond_fn(
                UpperCamelCase__						,    UpperCamelCase__						,    UpperCamelCase__						,    UpperCamelCase__						,    UpperCamelCase__						,    UpperCamelCase__						,    UpperCamelCase__						,    )

          # compute the previous noisy sample x_t -> x_t-1
          _snake_case     :						List[Any]						=   self.scheduler.step(UpperCamelCase__						,    UpperCamelCase__						,    UpperCamelCase__						,    **UpperCamelCase__     ).prev_sample

        # Hardcode 0.18215 because stable-diffusion-2-base has not self.vae.config.scaling_factor
      _snake_case     :						Optional[int]						=   1 / 0.18215 * latents
      _snake_case     :						Dict						=   self.vae.decode(UpperCamelCase__     ).sample

      _snake_case     :						Any						=   (image / 2 + 0.5).clamp(0						,    1     )
      _snake_case     :						List[str]						=   image.cpu().permute(0						,    2						,    3						,    1     ).numpy()

      if output_type == "pil":
        _snake_case     :						List[str]						=   self.numpy_to_pil(UpperCamelCase__     )

      if not return_dict:
        return (image, None)

      return StableDiffusionPipelineOutput(images=UpperCamelCase__						,    nsfw_content_detected=UpperCamelCase__     )



"""simple docstring"""
import unittest

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






class      _UpperCAmelCase				(					unittest.TestCase):
    def 					lowerCamelCase__	(    self     ):
      _snake_case     :						List[Any]						=   Vector([1, 2, 3]     )
      self.assertEqual(x.component(0     )						,    1     )
      self.assertEqual(x.component(2     )						,    3     )
      _snake_case     :						List[Any]						=   Vector()
    def 					lowerCamelCase__	(    self     ):
      _snake_case     :						Any						=   Vector([0, 0, 0, 0, 0, 1]     )
      self.assertEqual(str(snake_case_     )						,    "(0,0,0,0,0,1)"     )
    def 					lowerCamelCase__	(    self     ):
      _snake_case     :						Dict						=   Vector([1, 2, 3, 4]     )
      self.assertEqual(len(snake_case_     )						,    4     )
    def 					lowerCamelCase__	(    self     ):
      _snake_case     :						List[Any]						=   Vector([1, 2]     )
      _snake_case     :						List[str]						=   Vector([1, 2, 3, 4, 5]     )
      _snake_case     :						List[Any]						=   Vector([0, 0, 0, 0, 0, 0, 0, 0, 0, 0]     )
      _snake_case     :						Any						=   Vector([1, -1, 1, -1, 2, -3, 4, -5]     )
      self.assertAlmostEqual(x.euclidean_length()						,    2.236						,    3     )
      self.assertAlmostEqual(y.euclidean_length()						,    7.416						,    3     )
      self.assertEqual(z.euclidean_length()						,    0     )
      self.assertAlmostEqual(w.euclidean_length()						,    7.616						,    3     )
    def 					lowerCamelCase__	(    self     ):
      _snake_case     :						List[Any]						=   Vector([1, 2, 3]     )
      _snake_case     :						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 					lowerCamelCase__	(    self     ):
      _snake_case     :						str						=   Vector([1, 2, 3]     )
      _snake_case     :						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 					lowerCamelCase__	(    self     ):
      _snake_case     :						Optional[int]						=   Vector([1, 2, 3]     )
      _snake_case     :						List[Any]						=   Vector([2, -1, 4]     )  # for test of dot product
      _snake_case     :						Union[str, Any]						=   Vector([1, -2, -1]     )
      self.assertEqual(str(x * 3.0     )						,    "(3.0,6.0,9.0)"     )
      self.assertEqual((a * b)						,    0     )
    def 					lowerCamelCase__	(    self     ):
      self.assertEqual(str(zero_vector(10     )     ).count("0"     )						,    10     )
    def 					lowerCamelCase__	(    self     ):
      self.assertEqual(str(unit_basis_vector(3						,    1     )     )						,    "(0,1,0)"     )
    def 					lowerCamelCase__	(    self     ):
      _snake_case     :						Tuple						=   Vector([1, 2, 3]     )
      _snake_case     :						Optional[Any]						=   Vector([1, 0, 1]     )
      self.assertEqual(str(axpy(2						,    snake_case_						,    snake_case_     )     )						,    "(3,4,7)"     )
    def 					lowerCamelCase__	(    self     ):
      _snake_case     :						Union[str, Any]						=   Vector([1, 0, 0, 0, 0, 0]     )
      _snake_case     :						Optional[int]						=   x.copy()
      self.assertEqual(str(snake_case_     )						,    str(snake_case_     )     )
    def 					lowerCamelCase__	(    self     ):
      _snake_case     :						Dict						=   Vector([1, 0, 0]     )
      x.change_component(0						,    0     )
      x.change_component(1						,    1     )
      self.assertEqual(str(snake_case_     )						,    "(0,1,0)"     )
    def 					lowerCamelCase__	(    self     ):
      _snake_case     :						str						=   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(snake_case_     )     )
    def 					lowerCamelCase__	(    self     ):
      _snake_case     :						Dict						=   Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]						,    3						,    3     )
      _snake_case     :						str						=   [[-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(snake_case_						,    snake_case_     )     )
    def 					lowerCamelCase__	(    self     ):
      _snake_case     :						Union[str, Any]						=   Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]						,    3						,    3     )
      _snake_case     :						Optional[Any]						=   [[-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(snake_case_						,    snake_case_     )     )
    def 					lowerCamelCase__	(    self     ):
      _snake_case     :						int						=   Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]						,    3						,    3     )
      self.assertEqual(-5						,    a.determinant()     )
    def 					lowerCamelCase__	(    self     ):
      _snake_case     :						str						=   Matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]]						,    3						,    3     )
      _snake_case     :						List[str]						=   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 					lowerCamelCase__	(    self     ):
      _snake_case     :						Optional[int]						=   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(snake_case_     )     )
    def 					lowerCamelCase__	(    self     ):
      _snake_case     :						List[Any]						=   Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]						,    3						,    3     )
      self.assertEqual(7						,    a.component(2						,    1     )						,    0.01     )
    def 					lowerCamelCase__	(    self     ):
      _snake_case     :						Tuple						=   Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]						,    3						,    3     )
      _snake_case     :						int						=   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 					lowerCamelCase__	(    self     ):
      _snake_case     :						int						=   Matrix([[1, 2, 3], [2, 4, 5], [6, 7, 8]]						,    3						,    3     )
      _snake_case     :						Optional[Any]						=   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 					lowerCamelCase__	(    self     ):
      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()

