Podemos transformar um sinal de direfentes maneiras, para um sinal x(t) podemos variar sua amplitude quando multiplicamos por uma constante $K$, desde que essa constante seja positiva e maior que 1, temos as seguintes transformações.

$$x(t)\cdot u(t)$$

Amplificando o sinal:

$$y(t) = K\cdot x(t)\cdot u(t) \:\: k>1$$

Atenuando o sinal:

$$y(t) = K\cdot x(t)\cdot u(t) \:\: 0<k<1$$

Caso o sinal seja multiplicado por um valor negativo, seus valores serão espelhados no eixo X

$$x(t)\cdot u(t)$$

Amplificando e espelhando o sinal:

$$y(t) = K\cdot x(t)\cdot u(t) \:\: k>1$$

Atenuando e espenhando o sinal:

$$y(t) = K\cdot x(t)\cdot u(t) \:\: 0<k<1$$

Amplificando e atenunado um sinal com valores positivos para K:

Sinal Original: $$x(t)=(5-t)\cdot u(t)$$
Sinal Amplificado:

Multiplicando o sinal por um valor de k=1,5 $$x(t)=1,5\cdot (5-t)\cdot u(t)$$

Sinal Atenuado:

Multiplicando o sinal por um valor de k=0,5 $$x(t) = 0,5 \cdot (5-t)\cdot u(t)$$

Código para visualização dos Sinais Transformados

import numpy as np
import matplotlib.pyplot as plt

plt.style.use('seaborn')
%matplotlib inline

t = np.linspace(-3, 5, 100)

# Degrau unitário
u = []
for i in t:
    if i <= 0:
        u.append(0)
    else:
        u.append(1)
u = np.array(u)

# Sinal Original
y = (5-t)

def transformacao_sinal(y, u, t, k = [1, 1, 1]):
    yu = y*u
    fig, (ax1, ax2, ax3) = plt.subplots(1, 3, figsize=(20, 6))
    plt.subplots_adjust(top=0.85)
    plt.suptitle("Aplicando Transformações no sinal $x(t) = 5-t$",
                fontweight="medium", fontsize = 14)
    ax1.plot(t, k[0]*yu, label="Sinal $x(t) = (5-t)\cdot u(t)$", lw=3)
    ax1.plot(t, y,"--", label="Sinal $x(t) = (5-t)$", color="black", lw=1.5)
    ax1.plot(t, u, "*", label="Sinal $Degrau \: u(t)$", lw=1.2)
    ax1.legend()

    ax1.axhline(0, color="black", lw=1.2)
    ax1.axvline(0, color="black", lw=1.2)
    if k[1] > 0:
        ax1.set_yticks(range(0, 9))
    else:
        ax1.set_yticks(range(-9, 9))

    ax1.set_title(f"Função $x(t)=(5-t)$ - Sinal Original",
                    fontweight="medium", fontsize = 14)
    ax1.set_xlabel("Tempo $(t)$", color="black", fontweight="medium", 
                    fontsize = 12)
    ax1.set_ylabel("Amplitude", color="black", fontweight="medium", 
                    fontsize = 12)

    # Amplificando o sinal, Multiplicando o sinal por um valor mair que 1.
    y1 = y; y1u = k[1]*y1*u
    ax2.plot(t, y1u, label="Sinal $x(t) = 1,5\cdot (5-t)\cdot u(t)$", lw=3)
    ax2.plot(t, y1,"--", color="black", label="Sinal $x(t) = 1,5\cdot (5-t)$",
             lw=1.5)
    ax2.plot(t, u, "*", label="Sinal $Degrau \: u(t)$", lw=1.2)
    ax2.legend()

    ax2.axhline(0, color="black", lw=1.2)
    ax2.axvline(0, color="black", lw=1.2)
    ax2.set_xticks(range(-3, 6))
    if k[0] > 0:
        ax2.set_yticks(range(0, 9))
    else:
        ax2.set_yticks(range(-9, 9))

    ax2.set_title(f"Função $x(t)=1,5\cdot(5-t)$ - Sinal Amplificado por 1,5", 
                    fontweight="medium", fontsize = 14)
    ax2.set_xlabel("Tempo $(t)$", color="black", fontweight="medium", 
                    fontsize = 12)
    ax2.set_ylabel("Amplitude", color="black", fontweight="medium", 
                    fontsize = 12)

    # atenuando o sinal, Multiplicando o sinal por um valor menor que 1.
    y2 = y; y2u = k[2]*y2*u
    ax3.plot(t, y2u, label="Sinal $x(t) = 0,5\cdot (5-t)\cdot u(t)$", lw=3)
    ax3.plot(t, y2,"--", color="black", label="Sinal $x(t) = 0,5\cdot (5-t)$", 
            lw=1.5)
    ax3.plot(t, u, "*", label="Sinal $Degrau \: u(t)$", lw=1.2)
    ax3.legend()

    ax3.axhline(0, color="black", lw=1.2)
    ax3.axvline(0, color="black", lw=1.2)
    if k[0] > 0:
        ax3.set_yticks(range(0, 9))
    else:
        ax3.set_yticks(range(-9, 9))

    ax3.set_title(f"Função $x(t)=0,5\cdot(5-t)$ - Sinal Atenuado por 0,5", 
                    fontweight="medium", fontsize = 14)
    ax3.set_xlabel("Tempo $(t)$", color="black", fontweight="medium", fontsize = 12)
    ax3.set_ylabel("Amplitude", color="black", fontweight="medium", fontsize = 12)

    plt.show()

transformacao_sinal(y, u, t, k=[1, 1.5, 0.5])

Espelhando, Amplificando e atenunado um sinal com valores negativos para K:

Sinal Original: $$x(t)=-(5-t)\cdot u(t)$$
Sinal Amplificado e Espelhado no eixo X:

Multiplicando o sinal por um valor de k=-1,5 $$x(t)= -1,5\cdot (5-t)\cdot u(t)$$

Sinal Atenuado e Espelhado no eixo X:

Multiplicando o sinal por um valor de k=-0,5 $$x(t) = -0,5 \cdot (5-t)\cdot u(t)$$

Código para visualização dos Sinais Transformados

transformacao_sinal(y, u, t, k=[-1, -1.5, -0.5])

Deslocando o sinal no eixo Y

Se somar uma constante ao sinal, caso o valor for positivo o sinal é deslocando no eixo Y positivamente, do contrário o sinal será deslocado na direção negativa do eixo Y:

Sinal Original: $$x(t)=-(5-t)\cdot u(t)$$
Sinal Deslocado positivamente no eixo Y:

Somando um valor positivo ao sinal x(t). $$x(t)= (5-t) + 2\cdot u(t)$$

Sinal Deslocado negativamente no eixo Y:

Somando um valor negativo ao sinal x(t). $$x(t) = (5-t) + (-2)\cdot u(t)$$

def transformacao_sinal2(y, u, t):
    yu = y*u
    fig, (ax1, ax2, ax3) = plt.subplots(1, 3, figsize=(20, 6))
    plt.subplots_adjust(top=0.85)
    plt.suptitle("Aplicando Transformações no sinal $x(t) = 5-t$", 
                    fontweight="medium", fontsize = 14)
    ax1.plot(t, yu, label="Sinal $x(t) = (5-t)\cdot u(t)$", lw=3)
    ax1.plot(t, y,"--", label="Sinal $x(t) = (5-t)$", color="black", lw=1.5)
    ax1.plot(t, u, "-.", color="black", label="Sinal $Degrau \: u(t)$", lw=1.2)
    ax1.legend()

    ax1.axhline(0, color="black", lw=1.2)
    ax1.axvline(0, color="black", lw=1.2)
    ax1.set_yticks(range(-9, 9))

    ax1.set_title(f"$x(t)=(5-t)$ - Sinal Original", fontweight="medium", fontsize = 14)
    ax1.set_xlabel("Tempo $(t)$", color="black", fontweight="medium", fontsize = 12)
    ax1.set_ylabel("Amplitude", color="black", fontweight="medium", fontsize = 12)
    
    # Amplificando o sinal, Multiplicando o sinal por um valor mair que 1.
    y1u = y * u + 2
    ax2.plot(t, y1u, label="Sinal $x(t) = (5-t) + 2\cdot u(t)$", lw=3)
    ax2.plot(t, y,"--", color="black", label="Sinal $x(t) = (5-t)$", lw=1.5)
    ax2.plot(t, u, "-.", color="black", label="Sinal $Degrau \: u(t)$", lw=1.2)
    ax2.legend()

    ax2.axhline(0, color="black", lw=1.2)
    ax2.axvline(0, color="black", lw=1.2)
    ax2.set_xticks(range(-3, 6))
    ax2.set_yticks(range(-9, 9))


    ax2.set_title(f"$x(t)=(5-t) + 2$ - Deslocamento Positivo em Y", 
                    fontweight="medium", fontsize = 14)
    ax2.set_xlabel("Tempo $(t)$", color="black", fontweight="medium", fontsize = 12)
    ax2.set_ylabel("Amplitude", color="black", fontweight="medium", fontsize = 12)

    # atenuando o sinal, Multiplicando o sinal por um valor menor que 1.
    y2u = y*u-2
    ax3.plot(t, y2u, label="Sinal $x(t) = (5-t) - 2\cdot u(t)$", lw=3)
    ax3.plot(t, y,"--", color="black", label="Sinal $x(t) = (5-t)$", lw=1.5)
    ax3.plot(t, u, "-.", color="black", label="Sinal $Degrau \: u(t)$", lw=1.2)
    ax3.legend()

    ax3.axhline(0, color="black", lw=1.2)
    ax3.axvline(0, color="black", lw=1.2)
    ax3.set_yticks(range(-9, 9))

    ax3.set_title(f"$x(t )= (5-t) - 2$ - Deslocamento Negativo em Y", 
                    fontweight="medium", fontsize = 14)
    ax3.set_xlabel("Tempo $(t)$", color="black", fontweight="medium", fontsize = 12)
    ax3.set_ylabel("Amplitude", color="black", fontweight="medium", fontsize = 12)

    plt.show()

transformacao_sinal2(y, u, t)

Transformações no Argumento de $x(t) \rightarrow x(\alpha t + \beta)$

Quando a transformação é no argumento da função x(t) o sinal sofre mudanças no eixo do tempo. dependendo dos valores de $\alpha $ e de $\beta$, o sinal sofrerá diferentes transformações:

Transformações no Argumento: $$x(\alpha t + \beta)$$

Aplicando Transformações no Argumento:

01 - Deslocamento no Tempo

Para que um sinal seja deslocado no tempo, sem sofrer mudanças na frequência, deve-se aplicar os seguintes valores para $\alpha$ e $\beta$:

$$\alpha = 1 \:\:\:\: \beta \neq 0$$

$$x(t) = \begin{cases} 0 & \text{$ t \lt 0 $}\\ 1 & \text{0 < t $\le 1$}\\ 2 - t & \text{$1 \lt t \lt 2$}\\ 0 & \text{$ t \lt 2 $}\\ \end{cases}$$

Gráfico da Função x(t):

t0 = np.linspace(-1, 0, 10)
t1 = np.linspace(0, 1, 10)
t2 = np.linspace(1, 2, 10)
t3 = np.linspace(2, 3, 10)

x0 = np.zeros_like(t0)
x1 = np.ones_like(t1)
x2 = 2 - t2
x3 = np.zeros_like(t3)

tt = np.concatenate((t0, t1, t2, t3), axis=None)
xt = np.concatenate((x0, x1, x2, x3), axis=None)

fig1, ax = plt.subplots(1, figsize=(10, 5))
ax.plot(tt, xt, color="blue", lw=2)

ax.axhline(0, color="black", lw=1.2)
ax.axvline(0, color="black", lw=1.2)
ax.set_yticks(range(-1, 3))
ax.set_title(f"$x(t)$ - Sinal Original", fontweight="medium", fontsize = 14)
ax.set_xlabel("Tempo $(t)$", color="black", fontweight="medium", fontsize = 12)
ax.set_ylabel("Amplitude", color="black", fontweight="medium", fontsize = 12)

plt.show()

Atrazando o sinal x(t)

Para atrazar o sinal x(t), é preciso subtrair do argumento um valor, assim temos que $\beta$ tem que ser negativo, como mostra o exemplo abaixo:

$$x(\alpha t + \beta) \:\:\: \rightarrow \beta \lt 0 \:\:\: \text{atraso}$$

Gráfico da Função x(t):

$$\alpha = 1 \:\:\:\: \beta = \text{-0,5}$$

$$x(\alpha t -0,5) = \begin{cases} 0 & \text{$ t \lt 0,5 $}\\ 1 & \text{0,5 < t $\le 1,5$}\\ 2 - t & \text{$1,5 \lt t \lt 2,5$}\\ 0 & \text{$ t \lt 2,5 $}\\ \end{cases}$$

t01 = np.linspace(-0.5, 0.5, 10)
t11 = np.linspace(0.5, 1.5, 10)
t21 = np.linspace(1.5, 2.5, 10)
t31 = np.linspace(2.5, 3.5, 10)

x01 = np.zeros_like(t01)
x11 = np.ones_like(t11)
x21 = 2.5 - t21
x31 = np.zeros_like(t31)

tt2 = np.concatenate((t01, t11, t21, t31), axis=None)
xt2 = np.concatenate((x01, x11, x21, x31), axis=None)

fig2, ax2 = plt.subplots(1, figsize=(10, 5))
ax2.plot(tt, xt, "-.", color="blue", lw=2)
ax2.plot(tt2, xt2, color="black", lw=2)

ax2.axhline(0, color="black", lw=1.2)
ax2.axvline(0, color="black", lw=1.2)
ax2.set_yticks(range(-1, 3))
ax2.set_title(f"$x(t)$ - Sinal Original", fontweight="medium", fontsize = 14)
ax2.set_xlabel("Tempo $(t)$", color="black", fontweight="medium", fontsize = 12)
ax2.set_ylabel("Amplitude", color="black", fontweight="medium", fontsize = 12)

plt.show()

Adiantando o sinal x(t)

Para adiantar o sinal x(t), é preciso somar no argumento um valor, assim temos que $\beta$ tem que ser positivo, como mostra o exemplo abaixo:

$$x(\alpha t + \beta) \:\:\: \rightarrow \beta > 0 \:\:\: \text{adiantado}$$

Gráfico da Função x(t):

$$\alpha = 1 \:\:\:\: \beta = \text{0,5}$$

$$x(\alpha t + 0,5) = \begin{cases} 0 & \text{$ t \lt -0,5 $}\\ 1 & \text{-0,5 < t $\le 0,5$}\\ 2 - t & \text{$0,5 \lt t \lt 1,5$}\\ 0 & \text{$ t \lt 1,5 $}\\ \end{cases}$$

t02 = np.linspace(-1, -0.5, 10)
t12 = np.linspace(-0.5, 0.5, 10)
t22 = np.linspace(0.5, 1.5, 10)
t32 = np.linspace(1.5, 2.5, 10)

x02 = np.zeros_like(t02)
x12 = np.ones_like(t12)
x22 = 1.5 - t22
x32 = np.zeros_like(t32)

tt2 = np.concatenate((t02, t12, t22, t32), axis=None)
xt2 = np.concatenate((x02, x12, x22, x32), axis=None)

fig2, ax2 = plt.subplots(1, figsize=(10, 5))
ax2.plot(tt, xt, "-.", color="blue", lw=2)
ax2.plot(tt2, xt2, color="black", lw=2)

ax2.axhline(0, color="black", lw=1.2)
ax2.axvline(0, color="black", lw=1.2)
ax2.set_yticks(range(-1, 3))
ax2.set_title(f"$x(t)$ - Sinal Original", fontweight="medium", fontsize = 14)
ax2.set_xlabel("Tempo $(t)$", color="black", fontweight="medium", fontsize = 12)
ax2.set_ylabel("Amplitude", color="black", fontweight="medium", fontsize = 12)

plt.show()