João Pedro Dias Soares

Trabalho 01 de Sinais e Sistemas

Professor: Renato Dourado

Montes Claros – MG
30 de Agosto de 2019
 SUMÁRIO

1 INTRODUÇÃO E OBJETIVOS . . . . . . . . . . . . . . . . . . . . . . . 3

2 DESENVOLVIMENTO . . . . . . . . . . . . . . . . . . . . . . . . . . . 4

3 DISCUSSÃO E RESULTADOS . . . . . . . . . . . . . . . . . . . . . . . 7

4 CONCLUSÕES . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
4.1 Dificuldades . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
4.2 Aprendizados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
4.3 Relevância . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
4.4 Sugestões . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
4.5 Finalização . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
 3

1 INTRODUÇÃO E OBJETIVOS

O objetivo deste trabalho é verificar por meio da utilização de uma ferramenta computa-
cional, a decomposição de sinais em partes par e ímpar. Para tal foi construído um módulo capaz
desta decomposição e o retorno numérico e gráfico dos resultados. Como objetivo secundário,
teve-se o aprendizado da linguagem Python, e as bibliotecas NumPy e matplotlib.

Separação ímpar e par de uma função formada por uma senoide e uma distribuição gaussiana

Uso de numpy e matplotlib

 4

2 DESENVOLVIMENTO

Será descrito o código em Python utilizado para a realização do trabalho.

from matplotlib import pyplot as plt

from numpy import arange, flip, zeros

Apenas esta classe e funções além das padrões foram utilizadas para este trabalho. A
classe plt permite a plotagem de gráficos. As funções arange, flip, e zeros, permitem respectiva-
mente: construir uma numpy array de a até b com espaçamento c; permite inverter uma numpy
array qualquer; retorna uma numy array nula de tamanho especificado.

def decomposeSignal(signal, ni):

A função desenvolvida apenas recebe um sinal qualquer (que deve estar armazenado
numa numpy array) e ni que é o tempo inicial do sinal.

signal_length = len(signal)

t_begin = min(-ni - signal_length + 1, ni)

t_end = max(ni + signal_length, -ni + 1) - 1

A variável signal_length armazena o tamanho do sinal recebido. Com signal_length e

ni, será calculado t_begin e t_end, ambos são os extremos do eixo necessário para comportar as
partes ímpar e par do sinal.
O cálculo de t_begin foi feito pensando que o início do eixo pode assumir apenas dois
valores: o próprio ni originalmente dado, ou então o negativo da soma de ni com o tamanho
do sinal. O primeiro caso, onde ni é o início, acontece quando a reflexão do sinal não requer
um t menor que ni, geralmente quando o tamanho do sinal é pequeno, pois assim a reflexão do
sinal começa em ni ou a seguir. O segundo caso, onde é usado o negativo da soma de ni e o
tamanho do sinal, ocorre quando a reflexão requer valores t menores que ni; isto ocorre quando o
valor do último elemento do sinal acontece em um tempo maior que o módulo de ni, pois se isto
acontecer, a reflexão requer valores t menores que ni.
O cálculo de t_end foi pensado especialmente para prevenir problemas quando ni for
um tempo negativo, isto pois caso ni for zero ou positivo, t_end será a soma do ponto inicial e
o tamanho do sinal. A reflexão do sinal requer sempre um valor no tempo -ni, e caso seja ni
negativo, este valor torna-se positivo, e há situações que ele é maior que a soma de ni e tamanho
do sinal, e justamente para remediar estas situações, é visto qual dos valores é maior para assim
colocá-lo em t_end.
Capítulo 2. Desenvolvimento 5

Observa-se nos cálculos o uso de mais uns ou menos uns, mas estes foram apenas usados
para pequenos ajustes de natureza matemática básica ou computacional necessários para o uso
correto de métodos do Python; o importante deste trabalho é de mostrar a lógica e pensamento
necessário para entender a geração de partes par e ímpar, quais cuidados deve-se ter quando
pratica a reflexão do sinal.

axis = arange(t_begin, t_end + 1, 1)

_signal = zeros(len(axis))

Por fim, é gerado o eixo capaz de comportar as partes par e ímpar do sinal. Tendo o eixo
apropriado, será criado um sinal nulo que receberá o sinal, e assim será usado nos cálculos das
partes par e ímpar. Esta abordagem escolhida para resolver o problema eximiu-se a necessidade
de detectar especificamente onde e quanto de zeros deve-se colocar no sinal recebido para assim
permitir as computações necessárias no cálculo das partes par e ímpar. Porém, levou a um
novo problema, que pode-se dizer que é mais simples de ser resolvido, e que não envolve ifs ou
qualquer outro comando de fazer decisões, bastando apenas realizar um trabalho matemático
bem feito. Este novo problema é que deve ser visto onde o sinal original deve ser posto (ser
somado) no sinal nulo!

t_signal_begin = ni - t_begin
t_signal_end = ni + signal_length - t_begin

O cálculo de onde o sinal original deve ser posto na variável _signal, é definir o índice
inicial e final em _signal onde sinal original está presente. Observa-se que o índice final
t_signal_end será o índice inicial t_signal_begin mais o tamanho do sinal. Ou seja, a única
dificuldade que tem-se é de calcular o índice inicial, e essa é pouca.
Para o cálculo do índice inicial, é importante lembrar que o eixo é uma sucessão de
números inteiros crescentes. E sendo uma sucessão, o eixo tem um valor inicial, que será
chamado de t0 . De t0 pode-se andar n passos, assim encontrando um valor tn , que pode ser
expresso como t0 + n. Ou seja, tn = t0 + n.
Note-se que se andar 0 passos, obtem-se t0 , que é o primeiro elemento. Se andar 1 passo,
obtem-se t1 , que é o segundo elemento, e assim por diante pode ser demonstrado por indução
matemática, que para obter o n + 1º termo, é necessário n passos. Isolando o n, chamando
tn de t e pondo n em função de t sendo t0 constante, temos: n(t) = t − t0 . Assim testando
essa fórmula variando t com a posição que desejamos, conseguimos obter o índice dele, pois
retornará um n(t) que mostra o quanto a partir de t0 para chegar em t é necessáro, e este valor
comporta perfeitamente como um índice em Python. Lembrando que isto apenas ocorre pois
estamos lidando com uma sucessão de números inteiros crescentes!
Capítulo 2. Desenvolvimento 6

No caso deste trabalho, tem-se que t0 é t_begin, que é o primeiro valor do eico. Assim
substituindo t por ni e por ni mais tamanho do sinal, é obtido onde exatamente na numpy array
deve estar contido o sinal original.

_signal[t_signal_begin:t_signal_end] = signal

Após os cálculos necessários, sinal original é posto no sinal temporário _signal, no lugar
correto.

_signal_even = (_signal + flip(_signal))/2.0

_signal_odd = (_signal - flip(_signal))/2.0
_signal_sum = _signal_even + _signal_odd

return (axis, _signal_even, _signal_odd, _signal_sum)

Tendo _signal perfeitamente calculado, para obter-se a parte par e ímpar do sinal, é fácil:
basta aplicar as definições matemáticas que geram cada parte.
Relembrando: para obter a parte par basta pegar a metade da soma do sinal normal com
sua reflexão. E para obter a parte ímpar, basta a metade da subtração do sinal normal com sua
reflexão.
Feitos estes cálculos, obtem-se também a soma das partes. E por fim, todos os valores
importantes: eixo, parte par, parte ímpar e soma das partes, são retornados pela função.
 7

3 DISCUSSÃO E RESULTADOS

Resultado para o sinal a*cos(b*t)*sin(c*t). Coeficientes a, b, e c são escolhidos aleatoriamente

a cada execução.

Resultado para um sinal constante em 4 e que depois decresce. Tem como tempo inicial -7.
 8

4 CONCLUSÕES

4.1 Dificuldades

A única dificuldade encontrada no trabalho foi de produzir uma versão genérica do

algoritmo capaz de embarcar todos os casos, pois a reflexão do sinal gera uma leve dificul-
dade computacional, que deve ser solucionada para permitir solucionar o trabalho de maneira
facilmente visualizável, que é um objetivo sob todo bom aprendizado.

4.2 Aprendizados

Este trabalho ajudou a produzir uma intuição e visões matemáticas básicas, mas insti-
gantes e necessárias, sobre como operar com dados numéricos e de sempre tentar imaginar uma
solução simples porém profunda: muitas formas de abordar o problema tentei, usando até mais
recursos de programação, mas curiosamente, apenas com um bom pensamento matemático e
com menos recursos consegui resolver o problema, até mesmo com resultados mais satisfatórios,
que necessitam de menos custo computacional.

4.3 Relevância

Este trabalho tem relevância por introduzir aos estudantes os sinais e algumas proprieda-
des básicas. Por exemplo, este trabalho foi feito testando apenas sinais de tempo discreto e de
amplitude contínua, mas podem ser feitas modificações para conseguir estudar também casos
onde tempo é contínuo e amplitude é discreta.

4.4 Sugestões

Talvez seria interessante apresentar situações de uso as quais são usadas as partes par e
ímpar de um sinal.

4.5 Finalização

Foi muito interessante este trabalho, pois permitiu um estudo sobre Python e outros
recursos computacionais que são bons para um engenheiro de sistemas, permitindo-o então a
implementar algoritmos capazes de lidar com sinais assim ajudando-o nos estudos ou até mesmo
profissionalmente.