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 a discrete time signal, the given sequence can be delayed by a 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) represents 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 :

• Downscaling
• upscaling

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 :

x₁(n) = { 1, 1, 0, 1, 1 }

                     ↑

x₂(n) = { 2, 2, 0, 2, 2 }

                     ↑

y (n) = x₁(n) + x₂(n) 

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

4. Multiplication :

x₁(n) = { 1, 1, 0, 1, 1 }

                     ↑

x₂(n) = { 2, 2, 0, 2, 2 }

                     ↑

y (n) = x₁(n) * x₂(n) 

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