The exponential of a causal is causal.

Begin with a causal filter response c_t and its associated C(Z). The Z-transform C(Z) could be evaluated, giving a complex value for each real $\omega$.This complex value could be exponentiated to get another value, say  

$$B(Z(\omega )) \eq e^{C(Z(\omega ))}$$ (13)

Next, we could inverse transform $B(Z(\omega ))$ back to b_t. We will prove the amazing fact that b_t must be causal too.

First notice that if C(Z) has no negative powers of Z, then C(Z)² does not either. Likewise for the third power or any positive integer power, or sum of positive integer powers. Now recall the basic power-series definition of the exponential function:  

$$e^x \eq 1 + x + {x^2 \over 2} + {x^3 \over 2 \cdot 3} + {x^4... ...dot 3 \cdot 4} + {x^5 \over 2 \cdot 3 \cdot 4 \cdot 5} + \cdots$$ (14)

Including equation (13) gives the exponential of a causal:   

$$B(Z) \eq e^{C(Z)} \eq 1 + C(Z) + {C(Z)^2 \over 2} + {C(Z)^3 \over 2 \cdot 3} + {C(Z)^4 \over 2 \cdot 3 \cdot 4} + \cdots$$ (15)

Each term in the infinite series corresponds to a causal response, so the sum, b_t, is causal. (If you have forgotten the series for the exponential function, then recall that the solution to dy/dx=y is the definition of the exponential function y(x)=e^x, and that the power series satisfies the differential equation term by term, so it must be the exponential too. The factorials in the denominators assure us that the power series always converges, i.e., it is finite for any finite x.)

Putting one polynomial into another or one infinite series into another is an onerous task, even if it does lead to a wavelet that is exactly causal. In practice we do operations that are conceptually the same, but for speed we do them with discrete Fourier transforms. The disadvantage is periodicity, i.e., negative times are represented computationally like negative frequencies. Negative times are the last half of the elements of a vector, so there can be some blurring of late times into negative ones. The subroutine we will use for Fourier transformation is fts()  

module fft { #   complex fourier transform.
contains 
  subroutine fts( signi, rr ) {
  #   if (signi>0) scale = 1; else scale=1/nx
  #
  #                      nx          signi*2*pi*i*(j-1)*(k-1)/nx
  #   rr(k)  =  scale * sum rr(j) * e
  #                     j=1             for k=1,2,...,nx=2**integer
  #
  integer signi, nx, i, j, k, m, istep
  real    arg
  complex rr(:), cw, cdel, ct
  nx = size (rr); if( nx != pad2(nx) ) call erexit('fts: nx not a power of 2')
  if( signi < 0) rr = rr / nx
  j = 1;  k = 1
  do i= 1, nx {
        if (i<=j) { ct = rr(j); rr(j) = rr(i); rr(i) = ct }
        m = nx/2
        do while (j>m .and. m>1) { j = j-m; m = m/2 } 
        j = j+m
        }
  do {
        istep = 2*k;   cw = 1.;   arg = signi*3.14159265/k
        cdel = cmplx( cos(arg), sin(arg))
        do m= 1, k {
                do i= m, nx, istep
                        { ct=cw*rr(i+k);  rr(i+k)=rr(i)-ct;  rr(i)=rr(i)+ct }
                cw = cw * cdel
                }
        k = istep
        if(k>=nx) exit
	}
   }
   integer function pad2( n ) {
   integer n
   pad2 = 1
   do while( pad2 < n )
        pad2 = pad2 * 2 
   }
}