A memoryless (or static) system does not need memory. It processes the input and output signals taking place at the same instant. For example

y ( n ) = 2x ( n ) y ( n ) = 2x ( n ) size 12{ matrix { {} # {} # {} } y \( n \) =2x \( n \) } {}

y ( n ) = 2x ( n ) − x 2 ( n ) y ( n ) = 2x ( n ) − x 2 ( n ) size 12{ matrix { {} # {} # {} } y \( n \) =2x \( n \) - x rSup { size 8{2} } \( n \) } {}

Actually there is a small delay between input and output due to the propagation delay of the system.

A system with memory (or dynamic) needs memory to store past and future values needed for the processing. For example

y(n)=x(n)+0.8x(n−1)     : one memory cell y(n)= 1 3 [x(n−1)+x(n)+x(n+1)] : two memory cell y(n)= ∑ k=−∞ +∞ x(n−k)          : infinite memory y(n)=x(n)+0.8x(n−1)     : one memory cell y(n)= 1 3 [x(n−1)+x(n)+x(n+1)] : two memory cell y(n)= ∑ k=−∞ +∞ x(n−k)          : infinite memory MathType@MTEF@5@5@+=feaagaart1ev2aaatCvAUfeBSjuyZL2yd9gzLbvyNv2CaerbuLwBLnhiov2DGi1BTfMBaeXatLxBI9gBaerbd9wDYLwzYbItLDharqqtubsr4rNCHbGeaGqipDI8FfYJH8YrFfeuY=Hhbbf9v8qqaqFr0xc9pk0xbba9q8WqFfeaY=biLkVcLq=JHqpepeea0=as0Fb9pgeaYRXxe9vr0=vr0=vqpWqadeaabiGaciaacaqaaeaadaqaaqaaaOabaeqabaGaamyEaiaacIcacaWGUbGaaiykaiabg2da9iaadIhacaGGOaGaamOBaiaacMcacqGHRaWkcaaIWaGaaiOlaiaaiIdacaWG4bGaaiikaiaad6gacqGHsislcaaIXaGaaiykaiaaywW7caaMf8UaaGzbVlaaywW7caaMf8UaaiOoaiaaysW7caWGVbGaamOBaiaadwgacaaMe8UaamyBaiaadwgacaWGTbGaam4BaiaadkhacaWG5bGaaGjbVlaadogacaWGLbGaamiBaiaadYgaaeaacaWG5bGaaiikaiaad6gacaGGPaGaeyypa0ZaaSaaaeaacaaIXaaabaGaaG4maaaacaGGBbGaamiEaiaacIcacaWGUbGaeyOeI0IaaGymaiaacMcacqGHRaWkcaWG4bGaaiikaiaad6gacaGGPaGaey4kaSIaamiEaiaacIcacaWGUbGaey4kaSIaaGymaiaacMcacaGGDbGaaGzbVlaacQdacaaMe8UaamiDaiaadEhacaWGVbGaaGjbVlaad2gacaWGLbGaamyBaiaad+gacaWGYbGaamyEaiaaysW7caWGJbGaamyzaiaadYgacaWGSbaabaGaamyEaiaacIcacaWGUbGaaiykaiabg2da9maaqahabaGaamiEaiaacIcacaWGUbGaeyOeI0Iaam4AaiaacMcaaSqaaiaadUgacqGH9aqpcqGHsislcqGHEisPaeaacqGHRaWkcqGHEisPa0GaeyyeIuoakiaaywW7caaMf8UaaGzbVlaaywW7caaMf8UaaGzbVlaaywW7caaMe8UaaGjbVlaacQdacaaMe8ocbiGaa8xAaiaa=5gacaWFMbGaamyAaiaad6gacaWGPbGaamiDaiaadwgacaaMe8UaamyBaiaadwgacaWGTbGaam4BaiaadkhacaWG5baaaaa@BA41@

In causal system the result comes after the cause, or, at the same time (simultaneously). This is to say that the output at index n only depends on the input at n, n – 1, n – 2,…, and not on n + 1, n + 2,… In noncausal systems, on the other hand the output also depends on future inputs. Following is a few examples.

( a ) y ( n ) = 2x ( n ) − 3x 2 ( n ) ( a ) y ( n ) = 2x ( n ) − 3x 2 ( n ) size 12{ matrix { {} # {} # {} } \( a \) matrix { {} # {} # {} } y \( n \) =2x \( n \) - 3x rSup { size 8{2} } \( n \) : matrix { {} # {} # {} # {} } ital "causal"} {} : noncausal

( b ) y ( n ) = 1 3 [ x ( n − 1 ) + x ( n ) + x ( n + 1 ) ] ( b ) y ( n ) = 1 3 [ x ( n − 1 ) + x ( n ) + x ( n + 1 ) ] size 12{ matrix { {} # {} # {} } \( b \) matrix { {} # {} # {} } y \( n \) = { {1} over {3} } \[ x \( n - 1 \) +x \( n \) +x \( n+1 \) \] : matrix { {} # {} # {} # {} } matrix { ital "noncausal" {} # {} } ital "due" matrix { {} } ital "to" matrix { {} } ital "the" matrix { {} } ital "last" matrix { {} } ital "term"} {} : noncausal due to the last term

( c ) y n = ∑ k = 0 ∞ x n − k ( c ) y n = ∑ k = 0 ∞ x n − k size 12{ matrix { {} # {} # {} } \( c \) matrix { {} # {} # {} } y left (n right )= Sum cSub { size 8{k=0} } cSup { size 8{ infinity } } {x left (n - k right )} : matrix { {} # {} # {} # {} } ital "causal"} {} : causal

(d)y(n)=∑n=−∞∞xn(d)y(n)=∑n=−∞∞xn size 12{ matrix { {} # {} # {} } \( d \) matrix { {} # {} # {} } y \( n \) = Sum cSub { size 8{n= - infinity } } cSup { size 8{ infinity } } {x left (n right )} : matrix { {} # {} # {} # {} } ital "noncausal"} {} : noncausal

( e ) y ( n ) = ∑ k = − ∞ ∞ x n − k ( e ) y ( n ) = ∑ k = − ∞ ∞ x n − k size 12{ matrix { {} # {} # {} } \( e \) matrix { {} # {} # {} } y \( n \) = Sum cSub { size 8{k= - infinity } } cSup { size 8{ infinity } } {x left (n - k right )} : matrix { {} # {} # {} # {} } ital "noncausal"} {} : noncausal

( f ) y ( n ) = x ( − n ) ( f ) y ( n ) = x ( − n ) size 12{ matrix { {} # {} # {} } \( f \) matrix { {} # {} # {} } y \( n \) =x \( - n \) : matrix { {} # {} # {} # {} } ital "noncausal"} {} : noncausal

( g ) y ( n ) = x 2 ( n ) ( g ) y ( n ) = x 2 ( n ) size 12{ matrix { {} # {} # {} } \( g \) matrix { {} # {} # {} } y \( n \) =x rSup { size 8{2} } \( n \) : matrix { {} # {} # {} # {} } ital "noncausal"} {} : noncausal

( h ) y ( n ) = x ( n 2 ) ( h ) y ( n ) = x ( n 2 ) size 12{ matrix { {} # {} # {} } \( h \) matrix { {} # {} # {} } y \( n \) =x \( n rSup { size 8{2} } \) : matrix { {} # {} # {} # {} } ital "noncausal"} {} : noncausal

In real-time processing (or on-line processing), systems must be causal, off-line processing (or batch processing or block processing) systems can be noncausal since all samples have been stored in memory, many of those will be future values with respect to the chosen time origin.

The concept of causality is also applied to signals but the definition is modified. A signal x(n) can be classified as

For example, the unit step u(n) is causal, u(-n-1) is anticausal, a∣n∣a∣n∣ size 12{a rSup { size 8{ lline n rline } } } {} is two-sided. We can plot out these signals to really see the difference.

The characteristics of a system may change with time so that the output depends on the input as well as the instant the input is applied. This is a time-variant system. On the other hand, many systems can be assumed to be time-invariant, i.e. the output does not depend on the time the input is applied. The terms shift-variant and shift- invariant can be used instead of time-variant and time-invariant respectively.

The time (shift) invariance is judged as follows.

If x(n)→y(n)x(n)→y(n) size 12{x \( n \) matrix { {} # {} } rightarrow y \( n \) } {}

then x(n−k)→y(n−k)x(n−k)→y(n−k) size 12{x \( n - k \) matrix { {} # {} } rightarrow y \( n - k \) } {}

This criterion is illustrated in Figure 1