

import collections.abc
from typing import Optional, Tuple, Union

import torch
import torch.utils.checkpoint
from torch import nn
from torch.nn import BCEWithLogitsLoss, CrossEntropyLoss, MSELoss

from ...activations import ACTaFN
from ...modeling_outputs import BaseModelOutputWithNoAttention, ImageClassifierOutputWithNoAttention
from ...modeling_utils import PreTrainedModel
from ...utils import add_code_sample_docstrings, add_start_docstrings, add_start_docstrings_to_model_forward, logging
from .configuration_poolformer import PoolFormerConfig


lowerCAmelCase							:  int            =						logging.get_logger(__name__)

# General docstring
lowerCAmelCase							:  int            =						"""PoolFormerConfig"""

# Base docstring
lowerCAmelCase							:  Optional[int]            =						"""sail/poolformer_s12"""
lowerCAmelCase							:  Tuple            =						[1, 512, 7, 7]

# Image classification docstring
lowerCAmelCase							:  Any            =						"""sail/poolformer_s12"""
lowerCAmelCase							:  List[Any]            =						"""tabby, tabby cat"""

lowerCAmelCase							:  Optional[Any]            =						[
    """sail/poolformer_s12""",
    # See all PoolFormer models at https://huggingface.co/models?filter=poolformer
]







def       A_				(   _UpperCAmelCase    ,     _UpperCAmelCase = 0.0    ,     _UpperCAmelCase = False   ):
						if drop_prob == 0.0 or not training:
												return input
						SCREAMING_SNAKE_CASE_:			Union[str, Any]  		=	1 - drop_prob
						SCREAMING_SNAKE_CASE_:			str  		=	(input.shape[0],) + (1,) * (input.ndim - 1)  # work with diff dim tensors, not just 2D ConvNets
						SCREAMING_SNAKE_CASE_:			Any  		=	keep_prob + torch.rand(_UpperCAmelCase    ,     dtype=input.dtype    ,     device=input.device   )
						random_tensor.floor_()  # binarize
						SCREAMING_SNAKE_CASE_:			List[str]  		=	input.div(_UpperCAmelCase   ) * random_tensor
						return output



class   __lowercase    (			nn.Module     ):




			"""simple docstring"""







			def __init__(			self  :					List[Any]       ,						lowerCAmelCase__  :					Optional[float] = None):
									super().__init__()
									SCREAMING_SNAKE_CASE_:			List[str]  		=	drop_prob



			def 	_SCREAMING_SNAKE_CASE      (			self  :					Dict       ,						lowerCAmelCase__  :					torch.Tensor):
									return drop_path(lowerCAmelCase__       ,						self.drop_prob       ,						self.training)




			def 	_SCREAMING_SNAKE_CASE      (			self  :					Optional[Any]):
									return "p={}".format(self.drop_prob)







class   __lowercase    (			nn.Module     ):




			"""simple docstring"""







			def __init__(			self  :					Union[str, Any]       ,						lowerCAmelCase__  :					Dict       ,						lowerCAmelCase__  :					int       ,						lowerCAmelCase__  :					Tuple       ,						lowerCAmelCase__  :					Dict       ,						lowerCAmelCase__  :					Optional[int]       ,						lowerCAmelCase__  :					int=None):
									super().__init__()
									SCREAMING_SNAKE_CASE_:			str  		=	patch_size if isinstance(lowerCAmelCase__       ,						collections.abc.Iterable) else (patch_size, patch_size)
									SCREAMING_SNAKE_CASE_:			Optional[int]  		=	stride if isinstance(lowerCAmelCase__       ,						collections.abc.Iterable) else (stride, stride)
									SCREAMING_SNAKE_CASE_:			Any  		=	padding if isinstance(lowerCAmelCase__       ,						collections.abc.Iterable) else (padding, padding)

									SCREAMING_SNAKE_CASE_:			str  		=	nn.Convad(lowerCAmelCase__       ,						lowerCAmelCase__       ,						kernel_size=lowerCAmelCase__       ,						stride=lowerCAmelCase__       ,						padding=lowerCAmelCase__)
									SCREAMING_SNAKE_CASE_:			Tuple  		=	norm_layer(lowerCAmelCase__) if norm_layer else nn.Identity()




			def 	_SCREAMING_SNAKE_CASE      (			self  :					List[Any]       ,						lowerCAmelCase__  :					Union[str, Any]):
									SCREAMING_SNAKE_CASE_:			str  		=	self.projection(lowerCAmelCase__)
									SCREAMING_SNAKE_CASE_:			Dict  		=	self.norm(lowerCAmelCase__)
									return embeddings







class   __lowercase    (			nn.GroupNorm     ):




			"""simple docstring"""







			def __init__(			self  :					str       ,						lowerCAmelCase__  :					List[Any]       ,						**lowerCAmelCase__  :					int):
									super().__init__(1       ,						lowerCAmelCase__       ,						**lowerCAmelCase__)







class   __lowercase    (			nn.Module     ):




			"""simple docstring"""







			def __init__(			self  :					List[str]       ,						lowerCAmelCase__  :					str):
									super().__init__()
									SCREAMING_SNAKE_CASE_:			List[Any]  		=	nn.AvgPoolad(lowerCAmelCase__       ,						stride=1       ,						padding=pool_size // 2       ,						count_include_pad=lowerCAmelCase__)




			def 	_SCREAMING_SNAKE_CASE      (			self  :					str       ,						lowerCAmelCase__  :					str):
									return self.pool(lowerCAmelCase__) - hidden_states







class   __lowercase    (			nn.Module     ):




			"""simple docstring"""







			def __init__(			self  :					List[str]       ,						lowerCAmelCase__  :					List[Any]       ,						lowerCAmelCase__  :					str       ,						lowerCAmelCase__  :					List[str]       ,						lowerCAmelCase__  :					List[str]):
									super().__init__()
									SCREAMING_SNAKE_CASE_:			Tuple  		=	nn.Convad(lowerCAmelCase__       ,						lowerCAmelCase__       ,						1)
									SCREAMING_SNAKE_CASE_:			Optional[Any]  		=	nn.Convad(lowerCAmelCase__       ,						lowerCAmelCase__       ,						1)
									SCREAMING_SNAKE_CASE_:			Dict  		=	PoolFormerDropPath(lowerCAmelCase__)
									if isinstance(config.hidden_act       ,						lowerCAmelCase__):
															SCREAMING_SNAKE_CASE_:			List[Any]  		=	ACTaFN[config.hidden_act]
									else:
															SCREAMING_SNAKE_CASE_:			str  		=	config.hidden_act




			def 	_SCREAMING_SNAKE_CASE      (			self  :					str       ,						lowerCAmelCase__  :					List[str]):
									SCREAMING_SNAKE_CASE_:			int  		=	self.conva(lowerCAmelCase__)
									SCREAMING_SNAKE_CASE_:			Optional[Any]  		=	self.act_fn(lowerCAmelCase__)
									SCREAMING_SNAKE_CASE_:			Union[str, Any]  		=	self.drop(lowerCAmelCase__)
									SCREAMING_SNAKE_CASE_:			List[str]  		=	self.conva(lowerCAmelCase__)
									SCREAMING_SNAKE_CASE_:			Union[str, Any]  		=	self.drop(lowerCAmelCase__)

									return hidden_states







class   __lowercase    (			nn.Module     ):




			"""simple docstring"""







			def __init__(			self  :					Any       ,						lowerCAmelCase__  :					Dict       ,						lowerCAmelCase__  :					Optional[Any]       ,						lowerCAmelCase__  :					Tuple       ,						lowerCAmelCase__  :					int       ,						lowerCAmelCase__  :					int       ,						lowerCAmelCase__  :					Any):
									super().__init__()
									SCREAMING_SNAKE_CASE_:			Tuple  		=	PoolFormerPooling(lowerCAmelCase__)
									SCREAMING_SNAKE_CASE_:			Union[str, Any]  		=	PoolFormerOutput(lowerCAmelCase__       ,						lowerCAmelCase__       ,						lowerCAmelCase__       ,						lowerCAmelCase__)
									SCREAMING_SNAKE_CASE_:			Optional[int]  		=	PoolFormerGroupNorm(lowerCAmelCase__)
									SCREAMING_SNAKE_CASE_:			Optional[Any]  		=	PoolFormerGroupNorm(lowerCAmelCase__)

									# Useful for training neural nets
									SCREAMING_SNAKE_CASE_:			Optional[Any]  		=	PoolFormerDropPath(lowerCAmelCase__) if drop_path > 0.0 else nn.Identity()
									SCREAMING_SNAKE_CASE_:			str  		=	config.use_layer_scale
									if config.use_layer_scale:
															SCREAMING_SNAKE_CASE_:			Optional[Any]  		=	nn.Parameter(
															    config.layer_scale_init_value * torch.ones((lowerCAmelCase__))       ,						requires_grad=lowerCAmelCase__)
															SCREAMING_SNAKE_CASE_:			Union[str, Any]  		=	nn.Parameter(
															    config.layer_scale_init_value * torch.ones((lowerCAmelCase__))       ,						requires_grad=lowerCAmelCase__)




			def 	_SCREAMING_SNAKE_CASE      (			self  :					List[Any]       ,						lowerCAmelCase__  :					Dict):
									if self.use_layer_scale:
															SCREAMING_SNAKE_CASE_:			str  		=	self.pooling(self.before_norm(lowerCAmelCase__))
															SCREAMING_SNAKE_CASE_:			List[Any]  		=	self.layer_scale_a.unsqueeze(-1).unsqueeze(-1) * pooling_output
															# First residual connection
															SCREAMING_SNAKE_CASE_:			List[Any]  		=	hidden_states + self.drop_path(lowerCAmelCase__)
															SCREAMING_SNAKE_CASE_:			Optional[int]  		=	()

															SCREAMING_SNAKE_CASE_:			List[Any]  		=	self.output(self.after_norm(lowerCAmelCase__))
															SCREAMING_SNAKE_CASE_:			Optional[int]  		=	self.layer_scale_a.unsqueeze(-1).unsqueeze(-1) * layer_output
															# Second residual connection
															SCREAMING_SNAKE_CASE_:			Tuple  		=	hidden_states + self.drop_path(lowerCAmelCase__)

															SCREAMING_SNAKE_CASE_:			Tuple  		=	(output,) + outputs
															return outputs

									else:
															SCREAMING_SNAKE_CASE_:			Optional[Any]  		=	self.drop_path(self.pooling(self.before_norm(lowerCAmelCase__)))
															# First residual connection
															SCREAMING_SNAKE_CASE_:			List[Any]  		=	pooling_output + hidden_states
															SCREAMING_SNAKE_CASE_:			Any  		=	()

															# Second residual connection inside the PoolFormerOutput block
															SCREAMING_SNAKE_CASE_:			List[str]  		=	self.drop_path(self.output(self.after_norm(lowerCAmelCase__)))
															SCREAMING_SNAKE_CASE_:			Optional[int]  		=	hidden_states + layer_output

															SCREAMING_SNAKE_CASE_:			List[Any]  		=	(output,) + outputs
															return outputs







class   __lowercase    (			nn.Module     ):




			"""simple docstring"""







			def __init__(			self  :					Optional[int]       ,						lowerCAmelCase__  :					Union[str, Any]):
									super().__init__()
									SCREAMING_SNAKE_CASE_:			List[str]  		=	config
									# stochastic depth decay rule
									SCREAMING_SNAKE_CASE_:			Union[str, Any]  		=	[x.item() for x in torch.linspace(0       ,						config.drop_path_rate       ,						sum(config.depths))]

									# patch embeddings
									SCREAMING_SNAKE_CASE_:			int  		=	[]
									for i in range(config.num_encoder_blocks):
															embeddings.append(
															    PoolFormerEmbeddings(
															        patch_size=config.patch_sizes[i]       ,						stride=config.strides[i]       ,						padding=config.padding[i]       ,						num_channels=config.num_channels if i == 0 else config.hidden_sizes[i - 1]       ,						hidden_size=config.hidden_sizes[i]       ,						))
									SCREAMING_SNAKE_CASE_:			str  		=	nn.ModuleList(lowerCAmelCase__)

									# Transformer blocks
									SCREAMING_SNAKE_CASE_:			Union[str, Any]  		=	[]
									SCREAMING_SNAKE_CASE_:			Tuple  		=	0
									for i in range(config.num_encoder_blocks):
															# each block consists of layers
															SCREAMING_SNAKE_CASE_:			Tuple  		=	[]
															if i != 0:
																					cur += config.depths[i - 1]
															for j in range(config.depths[i]):
																					layers.append(
																					    PoolFormerLayer(
																					        lowerCAmelCase__       ,						num_channels=config.hidden_sizes[i]       ,						pool_size=config.pool_size       ,						hidden_size=config.hidden_sizes[i]       ,						intermediate_size=int(config.hidden_sizes[i] * config.mlp_ratio)       ,						drop_path=dpr[cur + j]       ,						))
															blocks.append(nn.ModuleList(lowerCAmelCase__))

									SCREAMING_SNAKE_CASE_:			Tuple  		=	nn.ModuleList(lowerCAmelCase__)




			def 	_SCREAMING_SNAKE_CASE      (			self  :					Optional[int]       ,						lowerCAmelCase__  :					int       ,						lowerCAmelCase__  :					Optional[Any]=False       ,						lowerCAmelCase__  :					str=True):
									SCREAMING_SNAKE_CASE_:			int  		=	() if output_hidden_states else None

									SCREAMING_SNAKE_CASE_:			Union[str, Any]  		=	pixel_values
									for idx, layers in enumerate(zip(self.patch_embeddings       ,						self.block)):
															SCREAMING_SNAKE_CASE_		,   SCREAMING_SNAKE_CASE_:			int  		=	layers
															# Get patch embeddings from hidden_states
															SCREAMING_SNAKE_CASE_:			Optional[int]  		=	embedding_layer(lowerCAmelCase__)
															# Send the embeddings through the blocks
															for _, blk in enumerate(lowerCAmelCase__):
																					SCREAMING_SNAKE_CASE_:			Union[str, Any]  		=	blk(lowerCAmelCase__)
																					SCREAMING_SNAKE_CASE_:			int  		=	layer_outputs[0]

															if output_hidden_states:
																					SCREAMING_SNAKE_CASE_:			List[str]  		=	all_hidden_states + (hidden_states,)

									if not return_dict:
															return tuple(v for v in [hidden_states, all_hidden_states] if v is not None)

									return BaseModelOutputWithNoAttention(last_hidden_state=lowerCAmelCase__       ,						hidden_states=lowerCAmelCase__)







class   __lowercase    (			UpperCAmelCase_     ):




			"""simple docstring"""







			_UpperCAmelCase       :							Dict      							=					PoolFormerConfig
			_UpperCAmelCase       :							Dict      							=					'''poolformer'''
			_UpperCAmelCase       :							Tuple      							=					'''pixel_values'''
			_UpperCAmelCase       :							List[str]      							=					True



			def 	_SCREAMING_SNAKE_CASE      (			self  :					Optional[Any]       ,						lowerCAmelCase__  :					Optional[Any]):
									if isinstance(lowerCAmelCase__       ,						(nn.Linear, nn.Convad)):
															module.weight.data.normal_(mean=0.0       ,						std=self.config.initializer_range)
															if module.bias is not None:
																					module.bias.data.zero_()
									elif isinstance(lowerCAmelCase__       ,						nn.LayerNorm):
															module.bias.data.zero_()
															module.weight.data.fill_(1.0)




			def 	_SCREAMING_SNAKE_CASE      (			self  :					Dict       ,						lowerCAmelCase__  :					Any       ,						lowerCAmelCase__  :					Optional[int]=False):
									if isinstance(lowerCAmelCase__       ,						lowerCAmelCase__):
															SCREAMING_SNAKE_CASE_:			str  		=	value







lowerCAmelCase							:  Union[str, Any]            =						R"""
    This model is a PyTorch [torch.nn.Module](https://pytorch.org/docs/stable/nn.html#torch.nn.Module) sub-class. Use
    it as a regular PyTorch Module and refer to the PyTorch documentation for all matter related to general usage and
    behavior.

    Parameters:
        config ([`PoolFormerConfig`]): Model configuration class with all the parameters of the model.
            Initializing with a config file does not load the weights associated with the model, only the
            configuration. Check out the [`~PreTrainedModel.from_pretrained`] method to load the model weights.
"""

lowerCAmelCase							:  List[str]            =						R"""
    Args:
        pixel_values (`torch.FloatTensor` of shape `(batch_size, num_channels, height, width)`):
            Pixel values. Pixel values can be obtained using [`AutoImageProcessor`]. See
            [`PoolFormerImageProcessor.__call__`] for details.
"""



@add_start_docstrings(
    '''The bare PoolFormer Model transformer outputting raw hidden-states without any specific head on top.'''		,	UpperCAmelCase_		,	)
class   __lowercase    (			UpperCAmelCase_     ):




			"""simple docstring"""







			def __init__(			self  :					Tuple       ,						lowerCAmelCase__  :					Optional[int]):
									super().__init__(lowerCAmelCase__)
									SCREAMING_SNAKE_CASE_:			Union[str, Any]  		=	config

									SCREAMING_SNAKE_CASE_:			Optional[int]  		=	PoolFormerEncoder(lowerCAmelCase__)

									# Initialize weights and apply final processing
									self.post_init()



			def 	_SCREAMING_SNAKE_CASE      (			self  :					Any):
									return self.embeddings.patch_embeddings




			@add_start_docstrings_to_model_forward(lowerCAmelCase__)
			@add_code_sample_docstrings(
			    checkpoint=_CHECKPOINT_FOR_DOC       ,						output_type=lowerCAmelCase__       ,						config_class=_CONFIG_FOR_DOC       ,						modality="vision"       ,						expected_output=_EXPECTED_OUTPUT_SHAPE       ,						)
			def 	_SCREAMING_SNAKE_CASE      (			self  :					List[str]       ,						lowerCAmelCase__  :					Optional[torch.FloatTensor] = None       ,						lowerCAmelCase__  :					Optional[bool] = None       ,						lowerCAmelCase__  :					Optional[bool] = None       ,						):
									SCREAMING_SNAKE_CASE_:			Optional[int]  		=	(
									    output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
									)
									SCREAMING_SNAKE_CASE_:			str  		=	return_dict if return_dict is not None else self.config.use_return_dict

									if pixel_values is None:
															raise ValueError("You have to specify pixel_values")

									SCREAMING_SNAKE_CASE_:			List[str]  		=	self.encoder(
									    lowerCAmelCase__       ,						output_hidden_states=lowerCAmelCase__       ,						return_dict=lowerCAmelCase__       ,						)
									SCREAMING_SNAKE_CASE_:			List[str]  		=	encoder_outputs[0]

									if not return_dict:
															return (sequence_output, None) + encoder_outputs[1:]

									return BaseModelOutputWithNoAttention(
									    last_hidden_state=lowerCAmelCase__       ,						hidden_states=encoder_outputs.hidden_states       ,						)







class   __lowercase    (			nn.Module     ):




			"""simple docstring"""







			def __init__(			self  :					str       ,						lowerCAmelCase__  :					str):
									super().__init__()
									SCREAMING_SNAKE_CASE_:			Dict  		=	nn.Linear(config.hidden_size       ,						config.hidden_size)




			def 	_SCREAMING_SNAKE_CASE      (			self  :					List[Any]       ,						lowerCAmelCase__  :					Optional[int]):
									SCREAMING_SNAKE_CASE_:			List[str]  		=	self.dense(lowerCAmelCase__)
									return output







@add_start_docstrings(
    '''
    PoolFormer Model transformer with an image classification head on top
    '''		,	UpperCAmelCase_		,	)
class   __lowercase    (			UpperCAmelCase_     ):




			"""simple docstring"""







			def __init__(			self  :					Optional[Any]       ,						lowerCAmelCase__  :					List[str]):
									super().__init__(lowerCAmelCase__)
									SCREAMING_SNAKE_CASE_:			List[Any]  		=	config.num_labels
									SCREAMING_SNAKE_CASE_:			List[str]  		=	PoolFormerModel(lowerCAmelCase__)

									# Final norm
									SCREAMING_SNAKE_CASE_:			Dict  		=	PoolFormerGroupNorm(config.hidden_sizes[-1])
									# Classifier head
									SCREAMING_SNAKE_CASE_:			Optional[Any]  		=	(
									    nn.Linear(config.hidden_sizes[-1]       ,						config.num_labels) if config.num_labels > 0 else nn.Identity()
									)

									# Initialize weights and apply final processing
									self.post_init()




			@add_start_docstrings_to_model_forward(lowerCAmelCase__)
			@add_code_sample_docstrings(
			    checkpoint=_IMAGE_CLASS_CHECKPOINT       ,						output_type=lowerCAmelCase__       ,						config_class=_CONFIG_FOR_DOC       ,						expected_output=_IMAGE_CLASS_EXPECTED_OUTPUT       ,						)
			def 	_SCREAMING_SNAKE_CASE      (			self  :					str       ,						lowerCAmelCase__  :					Optional[torch.FloatTensor] = None       ,						lowerCAmelCase__  :					Optional[torch.LongTensor] = None       ,						lowerCAmelCase__  :					Optional[bool] = None       ,						lowerCAmelCase__  :					Optional[bool] = None       ,						):
									SCREAMING_SNAKE_CASE_:			List[Any]  		=	return_dict if return_dict is not None else self.config.use_return_dict

									SCREAMING_SNAKE_CASE_:			List[str]  		=	self.poolformer(
									    lowerCAmelCase__       ,						output_hidden_states=lowerCAmelCase__       ,						return_dict=lowerCAmelCase__       ,						)

									SCREAMING_SNAKE_CASE_:			int  		=	outputs[0]

									SCREAMING_SNAKE_CASE_:			Any  		=	self.classifier(self.norm(lowerCAmelCase__).mean([-2, -1]))

									SCREAMING_SNAKE_CASE_:			Tuple  		=	None
									if labels is not None:
															if self.config.problem_type is None:
																					if self.num_labels == 1:
																											SCREAMING_SNAKE_CASE_:			Any  		=	"regression"
																					elif self.num_labels > 1 and (labels.dtype == torch.long or labels.dtype == torch.int):
																											SCREAMING_SNAKE_CASE_:			List[str]  		=	"single_label_classification"
																					else:
																											SCREAMING_SNAKE_CASE_:			List[str]  		=	"multi_label_classification"

															if self.config.problem_type == "regression":
																					SCREAMING_SNAKE_CASE_:			Tuple  		=	MSELoss()
																					if self.num_labels == 1:
																											SCREAMING_SNAKE_CASE_:			List[str]  		=	loss_fct(logits.squeeze()       ,						labels.squeeze())
																					else:
																											SCREAMING_SNAKE_CASE_:			Optional[Any]  		=	loss_fct(lowerCAmelCase__       ,						lowerCAmelCase__)
															elif self.config.problem_type == "single_label_classification":
																					SCREAMING_SNAKE_CASE_:			Dict  		=	CrossEntropyLoss()
																					SCREAMING_SNAKE_CASE_:			List[Any]  		=	loss_fct(logits.view(-1       ,						self.num_labels)       ,						labels.view(-1))
															elif self.config.problem_type == "multi_label_classification":
																					SCREAMING_SNAKE_CASE_:			Dict  		=	BCEWithLogitsLoss()
																					SCREAMING_SNAKE_CASE_:			str  		=	loss_fct(lowerCAmelCase__       ,						lowerCAmelCase__)

									if not return_dict:
															SCREAMING_SNAKE_CASE_:			str  		=	(logits,) + outputs[2:]
															return ((loss,) + output) if loss is not None else output

									return ImageClassifierOutputWithNoAttention(loss=lowerCAmelCase__       ,						logits=lowerCAmelCase__       ,						hidden_states=outputs.hidden_states)









import doctest
from collections import deque

import numpy as np



class   __lowercase    :




			"""simple docstring"""







			def __init__(			self  :					Union[str, Any]):
									SCREAMING_SNAKE_CASE_:			int  		=	[2, 1, 2, -1]
									SCREAMING_SNAKE_CASE_:			Optional[Any]  		=	[1, 2, 3, 4]




			def 	_SCREAMING_SNAKE_CASE      (			self  :					Tuple):
									SCREAMING_SNAKE_CASE_:			Any  		=	len(self.first_signal)
									SCREAMING_SNAKE_CASE_:			Dict  		=	len(self.second_signal)

									SCREAMING_SNAKE_CASE_:			Union[str, Any]  		=	max(lowerCAmelCase__       ,						lowerCAmelCase__)

									# create a zero matrix of max_length x max_length
									SCREAMING_SNAKE_CASE_:			List[Any]  		=	[[0] * max_length for i in range(lowerCAmelCase__)]

									# fills the smaller signal with zeros to make both signals of same length
									if length_first_signal < length_second_signal:
															self.first_signal += [0] * (max_length - length_first_signal)
									elif length_first_signal > length_second_signal:
															self.second_signal += [0] * (max_length - length_second_signal)
									for i in range(lowerCAmelCase__):
															SCREAMING_SNAKE_CASE_:			Tuple  		=	deque(self.second_signal)
															rotated_signal.rotate(lowerCAmelCase__)
															for j, item in enumerate(lowerCAmelCase__):
																					matrix[i][j] += item

        # multiply the matrix with the first signal
									SCREAMING_SNAKE_CASE_:			Optional[Any]  		=	np.matmul(np.transpose(lowerCAmelCase__)       ,						np.transpose(self.first_signal))

									# rounding-off to two decimal places
									return [round(lowerCAmelCase__       ,						2) for i in final_signal]


if __name__ == "__main__":
						doctest.testmod()






