{smcl}
{bf:Mata course:  Translating from FORTRAN}
{hline}

{title:FORTRAN code}

{p 4 4 2}
See {bf:{view balbak.f}} for complete code, with comments.

{p 4 4 2}
Code is one of the routines from the old EISPACK, a precurser of the LAPACK.

{p 4 4 2}
Here is balbak.f with comments removed:

	{hline}{cmd}
              subroutine balbak(nm,n,low,igh,scale,m,z)
        c
              integer i,j,k,m,n,ii,nm,igh,low
              double precision scale(n),z(nm,m)
              double precision s
        c
        c     ------------------------------------------------------------------
        c
              if (m .eq. 0) go to 200
              if (igh .eq. low) go to 120
        c
              do 110 i = low, igh
                 s = scale(i)
        c     .......... left hand eigenvectors are back transformed
        c                if the foregoing statement is replaced by
        c                s=1.0d0/scale(i). ..........
                 do 100 j = 1, m
          100    z(i,j) = z(i,j) * s
        c
          110 continue
        c     ......... for i=low-1 step -1 until 1,
        c               igh+1 step 1 until n do -- ..........
          120 do 140 ii = 1, n
                 i = ii
                 if (i .ge. low .and. i .le. igh) go to 140
                 if (i .lt. low) i = low - ii
                 k = scale(i)
                 if (k .eq. i) go to 140
        c
                 do 130 j = 1, m
                    s = z(i,j)
                    z(i,j) = z(k,j)
                    z(k,j) = s
          130    continue
        c
          140 continue
        c
          200 return
              end
	{txt}{hline}


{title:Line-by-line translation}

	{hline}{cmd}
              subroutine balbak(nm,n,low,igh,scale,m,z)
        c
              integer i,j,k,m,n,ii,nm,igh,low
              double precision scale(n),z(nm,m)
              double precision s
	{txt}{hline}

{p 4 4 2}
becomes

	{hline}{cmd}
	void balbak(real scalar nm, real scalar n, 
		    real scalar low, real scalar igh,
		    real vector scale,
		    real scalar m,
		    real matrix z)
	{
		real scalar     i, j, k, ii
		real scalar     s
	{txt}{hline}


{p 4 4 2}
FORTRAN code

	{hline}{cmd}
              if (m .eq. 0) go to 200
              if (igh .eq. low) go to 120
	{hline}{txt}

{p 4 4 2}
becomes

	{hline}{cmd}
		if (m==0) goto L200
		if (igh==low) goto L120
	{hline}{txt}

{p 4 4 2}
FORTRAN CODE


	{hline}{cmd}
              do 110 i = low, igh
                 s = scale(i)
                 do 100 j = 1, m
          100    z(i,j) = z(i,j) * s
        c
          110 continue
	{hline}{txt}

{p 4 4 2}
becomes

	{hline}{cmd}
		for (i=low; i<=igh; i++) {c -(}
			s = scale[i]
			for (j=1; j<=m; j++) z[i,j] = z[i,j] * s
		{c )-}
	{hline}{txt}

{p 4 4 2}
FORTRAN code

	{hline}{cmd}
          120 do 140 ii = 1, n
                 i = ii
                 if (i .ge. low .and. i .le. igh) go to 140
                 if (i .lt. low) i = low - ii
                 k = scale(i)
                 if (k .eq. i) go to 140
        c
                 do 130 j = 1, m
                    s = z(i,j)
                    z(i,j) = z(k,j)
                    z(k,j) = s
          130    continue
        c
          140 continue
	{hline}{txt}

{p 4 4 2}
becomes

	{hline}{cmd}
	L120:
		for(ii=1, ii<=n; ii++) {
			i = ii
			if (i>=low & i<=igh) goto L140
			if (i<low) i = low-ii
			k = scale[i]
			if (k==i) goto L140
			for (j=1;l j<=m; j++) {
				s = z[i,j]
				z[i,j] = z[k,j]
				z[i,j] = s
			}
	L140:	}
	{hline}{txt}

{p 4 4 2}
FORTRAN code

	{hline}{cmd}
          200 return
              end
	{hline}{txt}

{p 4 4 2}
becomes

	{hline}{cmd}
	L200:	return
	}
	{hline}{txt}


{title:Put the whole thing together, and we have}

	{hline}{cmd}
	void balbak(real scalar nm, real scalar n, 
		    real scalar low, real scalar igh,
		    real vector scale,
		    real scalar m,
		    real matrix z)
	{
		real scalar     i, j, k, ii
		real scalar     s


		if (m==0) goto L200
		if (igh==low) goto L120

		for (i=low; i<=igh; i++) {c -(}
			s = trunc(scale[i])
			for (j=1; j<=m; j++) z[i,j] = z[i,j] * s
		{c )-}

	L120:
		for(ii=1, ii<=n; ii++) {
			i = ii
			if (i>=low & i<=igh) goto L140
			if (i<low) i = low-ii
			k = scale[i]
			if (k==i) goto L140
			for (j=1;l j<=m; j++) {
				s = z[i,j]
				z[i,j] = z[k,j]
				z[i,j] = s
			}
	L140:	}
	L200:	return
	}
	{hline}{txt}


{title:It works!}

{p 4 4 2}
During development of Mata, and as a check that 

{p 8 12 2}
1.  Our LAPACK routines were working

{p 8 12 2}
2.  That our Mata compiler was working

{p 4 4 2}
I translated the majority of the EISPACK to Mata.  That took me a day or two.

{p 4 4 2}
In certification, 
we use the Mata-compiled EISPACK routines as a check 
against Mata-builtin LAPACK results.

{p 4 4 2}
By the way, performance (execution time) is excellent.

{p 4 4 2}
Translated EISPACK routines:

	{bf:{view eispack/cabssum.m}}
	{bf:{view eispack/eigbuild.m}}
	{bf:{view eispack/eigcg.m}}
	{bf:{view eispack/eigch.m}}
	{bf:{view eispack/eigc.m}}
	{bf:{view eispack/eig.m}}
	{bf:{view eispack/eigrg.m}}
	{bf:{view eispack/eigrs.m}}
	{bf:{view eispack/eisbalanc.m}}
	{bf:{view eispack/eisbalbak.m}}
	{bf:{view eispack/eiscbabk2.m}}
	{bf:{view eispack/eiscbal.m}}
	{bf:{view eispack/eiscomqr2.m}}
	{bf:{view eispack/eiscomqr.m}}
	{bf:{view eispack/eiscorth.m}}
	{bf:{view eispack/eiselmhes.m}}
	{bf:{view eispack/eiseltran.m}}
	{bf:{view eispack/eishqr2.m}}
	{bf:{view eispack/eishqr.m}}
	{bf:{view eispack/eishtribk.m}}
	{bf:{view eispack/eishtridi.m}}
	{bf:{view eispack/eisrg.m}}
	{bf:{view eispack/eistql2.m}}
	{bf:{view eispack/eistqlrat.m}}
	{bf:{view eispack/eistred1.m}}
	{bf:{view eispack/eistred2.m}}
	{bf:{view eispack/eisvalrg.m}}
	{bf:{view eispack/matpower.m}}


{hline}
{bf:{view talk.smcl:Top}}