Basic signal operations

Time shifting operations :

The different time shifting operations are as follow :
  • Time delay
  • Folding
  • Time advance
  • Folding
  • Folding and advance
  • Folding and delay
1. Time delay :

In the case of discrete time signal, the given sequence can be delayed by few samples. We know that the discrete time signal is denoted by x (n). 

Suppose we want to delay this sequence by "k" sample. It will be denoted by x (n-k).

x (n) = Original sequence 
x (n-k) = Original sequence delayed by k samples.

Here k is an integer

x(n) = {1, 2, 3, 4, 5 },  k=2
            ↑
x(n-2) = { 0, 0,1, 2, 3, 4, 5 }
                ↑

2. Time advance : 

Time advance operation is opposite to the time delay operation. Consider the same sequence is shown  given below :

x(n) = {1, 2, 3, 4, 5 }
            ↑

x(n+2) = { 1, 2, 3, 4, 5 }
                         ↑

3. Folding :

Folding is also called as reflection. Thus if x (n) represent input signal then x (-n) represent folded input signal.

x (n) = { 1, 2, 3, 4, 5 }

x  (-n) = { 5, 4, 3, 2, 1 }
                               ↑

4. Folding and delay :

  • First fold the sequence x(n); that means obtain x (-n)
  • Then delay the folded sequence by k sample

         delay
x (n)   →    x (n-k)
          
           delay
x (-n)    →    x [- (n-k) ] = x (-n+k)

x (n) = { 1, 2, 3, 4, 5 }
               ↑

x  (-n) = { 5, 4, 3, 2, 1 }
                                ↑

x (-n+2) =  { 5, 4, 3, 2, 1 }
                           ↑

5. Folding and advance  :

         advance
x (n)     →        x (n+k)

        advance
x (-n)     →        x [- (n+k) ] = x (-n-k)

x (n) = { 1, 2, 3, 4, 5 }
               ↑

x  (-n) = { 5, 4, 3, 2, 1 }
                                ↑

x(-n-2) = {  5, 4, 3, 2, 1, 0, 0 }
                                          
          
Time scaling operation :

  • Down scaling
  • up scaling

1. Down scaling :

consider the same sequence x (n)  = { 1, 2, 3, 4, 5 }
                                                              ↑

y (n) = x (2n)

Now from given sequence x (n)  we can write :
x(0) = 1
x(1) = 2
x(2) = 3
x(3) = 4
x(4) = 5

This gives the value of x (n) for different value of n;

y(n) = x (2n)
y(0) = x (0) = 1
y(1) = x (2) = 3
y(2) = x (4) = 5
y(3) = x (6) = 0

y(n) = x (2n) = {1, 3, 5, 0.....}
                         ↑

2. Up scaling or expansion :

Consider same input sequence x (n) =  { 1, 2, 3, 4, 5 } is applied to certain device which produces output y(n) = x(n/2).             ↑

Thus in this case :

y(n) = x(n/2) 

y(0) = x(0/2) = x(0) =1
y(1) = x(1/2) → No sample
y(2) = x(2/2) = x (1) = 2
y(3) = x(3/2)= x(1.5) → No sample
y(4) = x(4/2) = x (2) = 3
y(5) = x(5/2) = x (2.5)  → No sample
y(6) = x(6/2) = x (3) = 4
y(7) = x(7/2) = x (3.5) → No sample
y(8) = x(8/2) = x (4) = 5

y (n) = x (n/2) = { 1, 0, 2, 0, 3, 0, 4, 0, 5 }
                            ↑

Amplitude scaling operation :

  • Up-scaling 
  • Down-scaling
  • Addition
  • Multiplication

1. Up-scaling :

x (n) = { 1, 2, 3, 4, 5 }
               ↑
x(0) = 1
x(1) = 2
x(2) = 3
x(3) = 4
x(4) = 5

y (n) 2 x(n) = { 2, 4, 6, 8, 10 }
                        ↑

2. Down-scaling :

x (n) = { 1, 2, 3, 4, 5 }
              ↑

y (n) = x (n) / 2 = { 0.5, 1, 1.5, 2, 2.5 }
                                ↑

3. Addition :


x1(n) = { 1, 1, 0, 1, 1 }
                     ↑
x2(n) = { 2, 2, 0, 2, 2 }
                     ↑

y (n) = x1(n) + x2(n) 

y (n) = { 3, 3, 0, 3, 3 }
                     ↑

4. Multiplication :


x1(n) = { 1, 1, 0, 1, 1 }
                     ↑
x2(n) = { 2, 2, 0, 2, 2 }
                     ↑

y (n) = x1(n) * x2(n) 

y (n) = { 2, 2, 0, 2, 2 }
                     ↑