dnl cblas.m4.h
dnl
dnl ----------------------------------------------------------------------
define(`s_scalar', `float')   dnl
define(`s_array',  `float*')  dnl
define(`d_scalar', `double')  dnl
define(`d_array',  `double*') dnl
define(`c_scalar', `void*')   dnl
define(`c_array',  `void*')   dnl
define(`z_scalar', `void*')   dnl
define(`z_array',  `void*')   dnl
define(`s_type', `real_S')    dnl
define(`d_type', `real_D')    dnl
define(`c_type', `complex_S') dnl
define(`z_type', `complex_D') dnl
dnl
dnl ----------------------------------------------------------------------
dnl Usage: PTR_CAST(var, type_prec, `const') ...  cast the input pointer
dnl        argument into an internal pointer of proper type.
dnl ----------------------------------------------------------------------
define(`PTR_CAST', `ifelse(
	`$2',`real_S', `$3 float *$1_i = $1;',
	`$2',`real_D', `$3 double *$1_i = $1;',
	`$2',`complex_S', `$3 float *$1_i = (float*) $1;',
	`$2',`complex_D', `$3 double *$1_i = (double*) $1;',
      )') dnl
dnl
dnl ----------------------------------------------------------------------
dnl Usage: SCALAR_CAST(var, type_prec) ... cast the input scalar
dnl        argument into an internal representation.
dnl ----------------------------------------------------------------------
define(`SCALAR_CAST', `ifelse(
	`$2',`real_S', `float $1_i = $1;',
	`$2',`real_D', `double $1_i = $1;',
	`$2',`complex_S', `float *$1_i = (float*) $1;',
	`$2',`complex_D', `double *$1_i = (double*) $1;',
      )') dnl
dnl
dnl ----------------------------------------------------------------------
dnl Usage: DECLARE(var, type_prec) ... declare a variable
dnl ----------------------------------------------------------------------
define(`DECLARE', `ifelse(
	`$2',`real_S', `float $1;',
	`$2',`real_D', `double $1;',
	`$2',`real_E', `double $1_l, $1_t;',
	`$2',`complex_S', `float $1[2];',
	`$2',`complex_D', `double $1[2];',
	`$2',`complex_E', `double $1_l[2], $1_t[2];',
      )') dnl
dnl
dnl ----------------------------------------------------------------------
dnl Usage: ZERO(a, type_prec) ... a = 0
dnl ----------------------------------------------------------------------
define(`ZERO', `ifelse(
	`$2',`real_E', `$1_l = $1_t = 0.0;',
	`$2',`complex_S', `$1[0] = $1[1] = 0.0;',
	`$2',`complex_D', `$1[0] = $1[1] = 0.0;',
	`$2',`complex_E', `$1_l[0] = $1_l[1] = $1_t[0] = $1_t[1] = 0.0;',
        `$1 = 0.0;')') dnl
dnl
dnl ----------------------------------------------------------------------
dnl Usage: ZERO_OUT(a, type_prec) ... *a = 0
dnl ----------------------------------------------------------------------
define(`ZERO_OUT', `ifelse(
	`$2',`complex_S', `$1[0] = $1[1] = 0.0;',
	`$2',`complex_D', `$1[0] = $1[1] = 0.0;',
	`*$1 = 0.0;')') dnl
dnl
dnl ----------------------------------------------------------------------
dnl Usage: ASSIGN(a, type_prec, b, type_prec) ... a = b
dnl ----------------------------------------------------------------------
define(`ASSIGN', `ifelse(
        `$2&&$4',`real_E&&real_E', `$1_l = $3_l; $1_t = $3_t;',
	`$2',`real_E', `$1_l = $3; $1_t = 0.0;',
	`$1 = $3;')') dnl
dnl
dnl ----------------------------------------------------------------------
dnl Usage: ROUND(a, type_prec, b, type_prec) ... *a = (round)b
dnl ----------------------------------------------------------------------
define(`ROUND', `ifelse( 
	`$4', `real_E', `*$1 = $3_l;',
	`$4', `complex_S', `((float*)$1)[0] = $3[0]; ((float*)$1)[1] = $3[1];',
	`$4', `complex_D', `((double*)$1)[0] = $3[0]; ((double*)$1)[1] = $3[1];',
	`$4', `complex_E',
        `((double*)$1)[0] = $3_l[0]; ((double*)$1)[1] = $3_l[1];',
	`*$1 = $3;')') dnl
dnl
dnl ----------------------------------------------------------------------
dnl Usage: INC_ADJUST(inc, type_prec) ... increment by 2 for complex array
dnl ----------------------------------------------------------------------
define(`INC_ADJUST', `ifelse(
        `$2', `complex_S', `$1 *= 2;',
        `$2', `complex_D', `$1 *= 2;')') dnl
dnl
dnl ----------------------------------------------------------------------
dnl Usage: GET_VECTOR_ELEMENT(xi, x, i, type_prec)   ... xi = x[i]
dnl ----------------------------------------------------------------------
define(`GET_VECTOR_ELEMENT', `ifelse( 
        `$4', `complex_S', `$1[0] = $2[$3]; $1[1] = $2[$3+1];',
        `$4', `complex_D', `$1[0] = $2[$3]; $1[1] = $2[$3+1];',
        `$1 = $2[$3];')') dnl
dnl
dnl ----------------------------------------------------------------------
dnl Usage: SET_VECTOR_ELEMENT(x, i, val, type_prec)  ... x[i] = val
dnl ----------------------------------------------------------------------
define(`SET_VECTOR_ELEMENT', `ifelse( 
        `$4', `complex_S', `$1[$2] = $3[0]; $1[$2+1] = $3[1];',
        `$4', `complex_D', `$1[$2] = $3[0]; $1[$2+1] = $3[1];',
        `$1[$2] = $3;')') dnl
dnl
dnl ----------------------------------------------------------------------
dnl Usage: SET_ZERO_VECTOR_ELEMENT(x, i, type_prec)  ... x[i] = 0
dnl ----------------------------------------------------------------------
define(`SET_ZERO_VECTOR_ELEMENT', `ifelse( 
        `$3', `complex_S', `$1[$2] = 0.0; $1[$2+1] = 0.0;',
        `$3', `complex_D', `$1[$2] = 0.0; $1[$2+1] = 0.0;',
        `$1[$2] = 0.0;')') dnl
dnl
dnl ----------------------------------------------------------------------
dnl Usage: SET_ROUND_VECTOR_ELEMENT(x, i, val, type_prec) ... x[i] = (round)val
dnl ----------------------------------------------------------------------
define(`SET_ROUND_VECTOR_ELEMENT', `ifelse(
	`$4', `real_E', `$1[$2] = $3_l;',
	`$4', `complex_S', `$1[$2] = $3[0]; $1[$2+1] = $3[1];',
	`$4', `complex_D', `$1[$2] = $3[0]; $1[$2+1] = $3[1];',
	`$4', `complex_E', `$1[$2] = $3_l[0]; $1[$2+1] = $3_l[1];',
	`$1[$2] = $3;')') dnl
dnl
dnl ----------------------------------------------------------------------
dnl Usage: GET_MATRIX_ELEMENT(aij, A, i, j, lda, type_prec) ... aij = A[i,j]
dnl ----------------------------------------------------------------------
define(`GET_MATRIX_ELEMENT', `ifelse(
        `$6', `complex_S', `$1[0] = $2[$3+$4*$5]; $1[1] = $2[$3+$4*$5+1];',
        `$6', `complex_D', `$1[0] = $2[$3+$4*$5]; $1[1] = $2[$3+$4*$5+1];',
        `$1 = $2[$3+$4*$5];')') dnl
dnl
dnl ----------------------------------------------------------------------
dnl Usage: SET_MATRIX_ELEMENT(A, i, j, lda, val, type_prec) ... A[i,j] = val
dnl ----------------------------------------------------------------------
define(`SET_MATRIX_ELEMENT', `ifelse(
        `$6', `complex_S', `$1[$2+$3*$4] = $5[0]; $1[$2+$3*$4+1] = $5[1];',
        `$6', `complex_D', `$1[$2+$3*$4] = $5[0]; $1[$2+$3*$4+1] = $5[1];',
        `$1[$2] = $5;')') dnl
dnl
dnl ----------------------------------------------------------------------
dnl Usage: SET_ZERO_MATRIX_ELEMENT(A, i, j, lda, type_prec) ... A[i,j] = 0
dnl ----------------------------------------------------------------------
define(`SET_ZERO_MATRIX_ELEMENT', `ifelse(
        `$5', `complex_S', `$1[$2+$3*$4] = 0.0; $1[$2+$3*$4+1] = 0.0;',
        `$5', `complex_D', `$1[$2+$3*$4] = 0.0; $1[$2+$3*$4+1] = 0.0;',
        `$1[$2] = 0.0;')') dnl
dnl
dnl ----------------------------------------------------------------------
dnl Usage: SET_ROUND_MATRIX_ELEMENT(A, i, j, lda, val, type_prec)
dnl        ... A[i,j] = (round)val
dnl ----------------------------------------------------------------------
define(`SET_ROUND_MATRIX_ELEMENT', `ifelse(
	`$6', `real_E', `$1[$2] = $3_l;',
	`$6', `complex_S', `$1[$2] = $3[0]; $1[$2+1] = $3[1];',
	`$6', `complex_D', `$1[$2] = $3[0]; $1[$2+1] = $3[1];',
	`$6', `complex_E', `$1[$2] = $3_l[0]; $1[$2+1] = $3_l[1];',
	`$1[$2] = $3;')') dnl
dnl
dnl ----------------------------------------------------------------------
dnl Usage: TEST_0(val, type_prec)  ... val == 0?
dnl ----------------------------------------------------------------------
define(`TEST_0', `ifelse(
        `$2', `complex_S', `$1[0] == 0.0 && $1[1] == 0.0',
        `$2', `complex_D', `$1[0] == 0.0 && $1[1] == 0.0',
        `$1 == 0.0')') dnl
dnl
dnl ----------------------------------------------------------------------
dnl Usage: TEST_1(val, type_prec)  ... val == 1?
dnl ----------------------------------------------------------------------
define(`TEST_1', `ifelse(
        `$2', `complex_S', `($1[0] == 1.0 && $1[1] == 0.0)',
        `$2', `complex_D', `($1[0] == 1.0 && $1[1] == 0.0)',
        `$1 == 1.0')') dnl
dnl
dnl ----------------------------------------------------------------------
dnl Usage: MUL(c, type_prec, a, type_prec, b, type_prec) ... c = a * b
dnl ----------------------------------------------------------------------
define(`MUL', `ifelse(
	`$2&&$4&&$6', `real_E&&real_D&&real_D',
        `{
  	    /* Compute double_double = double * double. */
            double a1, a2, b1, b2, con;
            
            con = $3 * split;
            a1 = con - $3;
            a1 = con - a1;
            a2 = $3 - a1;
            con = $5 * split;
            b1 = con - $5;
            b1 = con - b1;
            b2 = $5 - b1;

            $1_l = $3 * $5;
            $1_t = (((a1 * b1 - $1_l) + a1 * b2) + a2 * b1) + a2 * b2;
            }',
	`$2&&$4&&$6', `real_E&&real_E&&real_D',
	`{
  	    /* Compute double-double = double-double * double. */
            double a11, a21, b1, b2, c11, c21, c2, con, e, t1, t2;

	    con = $3_l * split;
            a11 = con - $3_l;
	    a11 = con - a11;
	    a21 = $3_l - a11;
	    con = $5 * split;
	    b1 = con - $5;
	    b1 = con - b1;
	    b2 = $5 - b1;

	    c11 = $3_l * $5;
	    c21 = (((a11 * b1 - c11) + a11 * b2) + a21 * b1) + a21 * b2;

 	    c2 = $3_t * $5;
	    t1 = c11 + c2;
	    e = t1 - c11;
	    t2 = ((c2 - e) + (c11 - (t1 - e))) + c21;
	   
	    $1_l = t1 + t2;
	    $1_t = t2 - ($1_l - t1);
            }',
	`$2&&$4&&$6', `real_E&&real_S&&real_S', `$1_l = $3 * $5; $1_t = 0.0;',
	`$2&&$4&&$6', `real_E&&real_D&&real_S',
        `{
            double dt = (double) $5;
            MUL($1, $2, $3, $4, dt, real_D)
         }',
	`$2&&$4&&$6', `real_E&&real_S&&real_D',
        `{
            double dt = (double) $3;
            MUL($1, $2, dt, real_D, $5, $6)
         }',
	`$2&&$4&&$6', `real_E&&real_E&&real_S',
        `{
            double dt = (double) $5;
            MUL($1, $2, $3, $4, dt, real_D)
         }',
	`$2&&$4&&$6', `real_D&&real_S&&real_S', `$1 = (double) $3 * $5;',
        `$2',`complex_S', `S_CMPLX_MUL($1, $2, $3, $4, $5, $6)',
        `$2',`complex_D', `D_CMPLX_MUL($1, $2, $3, $4, $5, $6)',
        `$2',`complex_E', `E_CMPLX_MUL($1, $2, $3, $4, $5, $6)',
	`$1 = $3 * $5;')') dnl
define(`S_CMPLX_MUL', `ifelse(
        `$4&&$6', `complex_S&&real_S', `C_TIMES_R($1, $3, $5)',
        `$4&&$6', `real_S&&complex_S', `C_TIMES_R($1, $5, $3)',
        `$4&&$6', `complex_S&&complex_S', `C_TIMES_C($1, $3, $5)'
       )') dnl
define(`D_CMPLX_MUL', `ifelse(
        `$4&&$6', `complex_S&&real_S', `C_TIMES_R($1, $3, $5)',
        `$4&&$6', `real_S&&complex_S', `C_TIMES_R($1, $5, $3)',
        `$4&&$6', `complex_D&&real_S', `C_TIMES_R($1, $3, $5)',
        `$4&&$6', `real_S&&complex_D', `C_TIMES_R($1, $5, $3)',
        `$4&&$6', `complex_D&&real_D', `C_TIMES_R($1, $3, $5)',
        `$4&&$6', `real_D&&complex_D', `C_TIMES_R($1, $5, $3)',
        `$4&&$6', `real_D&&complex_S', `C_TIMES_R($1, $5, $3)',
        `C_TIMES_C($1, $3, $5)' )') dnl
define(`E_CMPLX_MUL', `ifelse(
        `$4&&$6',`complex_D&&real_D', `E_C_TIMES_R($1, $2, $3, $4, $5, $6)',
        `$4&&$6',`real_D&&complex_D', `E_C_TIMES_R($1, $2, $5, $6, $3, $4)',
	`$4&&$6',`real_E&&complex_D', `E_C_TIMES_R($1, $2, $5, $6, $3, $4)',
        `$4&&$6',`complex_E&&real_D', `E_C_TIMES_R($1, $2, $3, $4, $5, $6)',
        `$4&&$6',`complex_D&&complex_D', `E_C_TIMES_C($1, $2, $3, $4, $5, $6)',
        `$4&&$6',`complex_E&&complex_D', `E_C_TIMES_C($1, $2, $3, $4, $5, $6)',
        `$4&&$6',`complex_S&&complex_S', `E_C_TIMES_C($1, $2, $3, $4, $5, $6)',
        `$4&&$6',`complex_D&&complex_S', `E_C_TIMES_C($1, $2, $3, $4, $5, $6)',
        `$4&&$6',`complex_S&&complex_D', `E_C_TIMES_C($1, $2, $5, $6, $3, $4)',
        `$4&&$6',`complex_E&&complex_S', `E_C_TIMES_C($1, $2, $3, $4, $5, $6)',
        `$4&&$6',`complex_S&&real_S', `E_C_TIMES_R($1, $2, $3, $4, $5, $6)',
        `$4&&$6',`real_S&&complex_S', `E_C_TIMES_R($1, $2, $5, $6, $3, $4)',
        `$4&&$6',`complex_D&&real_S', `E_C_TIMES_R($1, $2, $3, $4, $5, $6)',
        `$4&&$6',`complex_E&&real_S', `E_C_TIMES_R($1, $2, $3, $4, $5, $6)',
        `$4&&$6',`real_E&&complex_S', `E_C_TIMES_R($1, $2, $5, $6, $3, $4)',
        `miss($1, $2, $3, $4, $5, $6)' )') dnl
define(`C_TIMES_R',
        `{
           $1[0] = $2[0] * $3; $1[1] = $2[1] * $3;
         }') dnl
define(`C_TIMES_C',
        `{
           $1[0] = $2[0] * $3[0] - $2[1] * $3[1];
           $1[1] = $2[0] * $3[1] + $2[1] * $3[0];
         }') dnl
define(`E_C_TIMES_R', `ifelse(
        `$4&&$6', `complex_S&&real_S',
        `{
           $1_l[0] = $3[0] * $5; $1_t[0] = 0.0;
           $1_l[1] = $3[1] * $5; $1_t[1] = 0.0;
         }',
        `$4&&$6', `complex_S&&real_E',
        `{
           DECLARE(e1, real_E)
	   DECLARE(dt, real_D)
	   dt = (double) $3[0];
           MUL(e1, real_E, $5, real_E, dt, real_D)
	   $1_l[0] = e1_l; $1_t[0] = e1_t;
	   dt = (double) $3[1];
           MUL(e1, real_E, $5, real_E, dt, real_D)
	   $1_l[1] = e1_l; $1_t[1] = e1_t;
         }',
        `$4&&$6', `complex_D&&real_S',
        `{
	   double dt = (double) $5;
	   MUL($1, $2, $3, $4, dt, real_D)
         }',
        `$4&&$6', `complex_E&&real_S',
        `{
           double dt = (double) $5;
	   MUL($1, $2, $3, $4, dt, real_D)
         }',
	`$4', `complex_D',
        `{
	   /* Compute complex-extra = complex-double * real. */
           DECLARE(t, real_E)
	   MUL(t, real_E, $5, $6, $3[0], real_D)
           $1_l[0] = t_l; $1_t[0] = t_t;
           MUL(t, real_E, $5, $6, $3[1], real_D)
           $1_l[1] = t_l; $1_t[1] = t_t;
	}',
        `$4', `complex_E',
        `{
           /* Compute complex-extra = complex-extra * real. */
           DECLARE(a0, real_E)
           DECLARE(a1, real_E)
           DECLARE(t, real_E)
	   a0_l = $3_l[0]; a0_t = $3_t[0];
	   a1_l = $3_l[1]; a1_t = $3_t[1];
           MUL(t, real_E, a0, real_E, $5, $6)
           $1_l[0] = t_l; $1_t[0] = t_t;
           MUL(t2 real_E, a1, real_E, $5, $6)
           $1_l[1] = t2_l; $1_t[1] = t2_t;
         }'
       )') dnl
define(`E_C_TIMES_C', `ifelse(
        `$4&&$6', `complex_S&&complex_S', 
	`{
	    DECLARE(e1, real_E)
	    DECLARE(d1, real_D)
	    DECLARE(d2, real_D)
	    /* Real part */
	    d1 = $3[0] * $5[0];
	    d2 = -$3[1] * $5[1];
	    ADD(e1, real_E, d1, real_D, d2, real_D)
	    $1_l[0] = e1_l; $1_t[0] = e1_t;
	    /* imaginary part */
	    d1 = $3[0] * $5[1];
	    d2 = $3[1] * $5[0];
	    ADD(e1, real_E, d1, real_D, d2, real_D)
	    $1_l[1] = e1_l; $1_t[1] = e1_t;
	 }',
        `$4&&$6', `complex_D&&complex_D', 
        `{
           /* Compute complex-extra = complex-double * complex-double. */
           DECLARE(t1, real_E)
           DECLARE(t2, real_E)
           /* Real part */
           MUL(t1, real_E, $3[0], real_D, $5[0], real_D)
           MUL(t2, real_E, $3[1], real_D, $5[1], real_D)
           t2_l = -t2_l; t2_t = -t2_t;
           ADD(t1, real_E, t1, real_E, t2, real_E)
           $1_l[0] = t1_l; $1_t[0] = t1_t;
           /* Imaginary part */
           MUL(t1, real_E, $3[1], real_D, $5[0], real_D)
           MUL(t2, real_E, $3[0], real_D, $5[1], real_D)
           ADD(t1, real_E, t1, real_E, t2, real_E)
           $1_l[1] = t1_l; $1_t[1] = t1_t;
         }',
        `$4&&$6', `complex_D&&complex_S',
	`{
	   DECLARE(cd, complex_D)
	   cd[0] = (double) $5[0]; cd[1] = (double) $5[1];
	   MUL($1, $2, $3, $4, cd, complex_D)
	 }',
        `$4&&$6', `complex_E&&complex_S',
	`{
	   DECLARE(cd, complex_D)
	   cd[0] = (double) $5[0]; cd[1] = (double) $5[1];
	   MUL($1, $2, $3, $4, cd, complex_D)
	 }',
        `$4&&$6', `complex_E&&complex_D',
	`{
           /* Compute complex-extra = complex-extra * complex-double. */
           DECLARE(a0, real_E)
           DECLARE(a1, real_E)
           DECLARE(t1, real_E)
           DECLARE(t2, real_E)
	   a0_l = $3_l[0]; a0_t = $3_t[0];
	   a1_l = $3_l[1]; a1_t = $3_t[1];
	   /* Real part */
           MUL(t1, real_E, a0, real_E, $5[0], real_D)
           MUL(t2, real_E, a1, real_E, $5[1], real_D)
           t2_l = -t2_l; t2_t = -t2_t;
           ADD(t1, real_E, t1, real_E, t2, real_E)
           $1_l[0] = t1_l; $1_t[0] = t1_t;
           /* Imaginary part */
           MUL(t1, real_E, a1, real_E, $5[0], real_D)
           MUL(t2, real_E, a0, real_E, $5[1], real_D)
           ADD(t1, real_E, t1, real_E, t2, real_E)
           $1_l[1] = t1_l; $1_t[1] = t1_t;
         }'
       )') dnl
dnl
dnl ----------------------------------------------------------------------
dnl Usage: ADD(c, type_prec, a, type_prec, b, type_prec) ... c = a + b
dnl ----------------------------------------------------------------------
define(`ADD', `ifelse(
	`$2&&$4&&$6',`real_E&&real_D&&real_D',
        `{
  	    /* Compute double-double = double + double. */
  	    double e, t1, t2;

	    /* Knuth trick. */
	    t1 = $3 + $5;
      	    e = t1 - $3;
	    t2 = (($5 - e) + ($3 - (t1 - e)));

	    /* The result is t1 + t2, after normalization. */
	    $1_l = t1 + t2;
	    $1_t = t2 - ($1_l - t1);
            }',
	`$2&&$4&&$6',`real_E&&real_E&&real_D',
        `{
  	    /* Compute double-double = double-double + double. */
  	    double e, t1, t2;

	    /* Knuth trick. */
	    t1 = $3_l + $5;
      	    e = t1 - $3_l;
	    t2 = (($5 - e) + ($3_l - (t1 - e))) + $3_t;

	    /* The result is t1 + t2, after normalization. */
	    $1_l = t1 + t2;
	    $1_t = t2 - ($1_l - t1);
            }',
	`$2&&$4&&$6',`real_E&&real_E&&real_E',
        `{ 
	    /* Compute double-double = double-double + double-double. */
  	    double e, t1, t2;

	    /* Knuth trick. */
	    t1 = $3_l + $5_l;
      	    e = t1 - $3_l;
	    t2 = (($5_l - e) + ($3_l - (t1 - e))) + $3_t + $5_t;

	    /* The result is t1 + t2, after normalization. */
	    $1_l = t1 + t2;
	    $1_t = t2 - ($1_l - t1);
         }',
	`$2&&$4&&$6', `real_D&&real_S&&real_S', `$1 = (double) $3 + $5;',
	`$2&&$4&&$6', `real_E&&real_E&&real_S', 
        `{
            double dt = (double) $5;
            ADD($1, $2, $3, $4, dt, real_D);
         }',
        `$2',`complex_S', `$1[0] = $3[0] + $5[0]; $1[1] = $3[1] + $5[1];',
        `$2',`complex_D', `$1[0] = $3[0] + $5[0]; $1[1] = $3[1] + $5[1];',
        `$2',`complex_E&&complex_E&&complex_S',
	`{
	    DECLARE(cd, complex_D)
	    cd[0] = (double) $5[0]; cd[1] = (double) $5[1];
	    ADD($1, $2, $3, $4, cd, compelx_D)
	}',
        `$2',`complex_E&&complex_E&&complex_D',
        `{
            DECLARE(t, real_E)
            DECLARE(a, real_E)
            a_l = $3_l[0]; a_t = $3_t[0];
            ADD(t, real_E, a, real_E, $5[0], real_D)
            $1_l[0] = t_l; $1_t[0] = t_t;
            a_l = $3_l[1]; a_t = $3_t[1];
            ADD(t, real_E, a, real_E, $5[1], real_D)
            $1_l[1] = t_l; $1_t[1] = t_t;
         }',
        `$2',`complex_E',
	`{
	    DECLARE(t, real_E)
	    DECLARE(a, real_E)
	    DECLARE(b, real_E)
	    /* Real part */
	    a_l = $3_l[0]; a_t = $3_t[0];
	    b_l = $5_l[0]; b_t = $5_t[0];
	    ADD(t, real_E, a, real_E, b, real_E)
            $1_l[0] = t_l; $1_t[0] = t_t;
	    /* Imaginary part */
	    a_l = $3_l[1]; a_t = $3_t[1];
	    b_l = $5_l[1]; b_t = $5_t[1];
	    ADD(t, real_E, a, real_E, b, real_E)
            $1_l[1] = t_l; $1_t[1] = t_t;
	}',
	`$1 = $3 + $5;')') dnl