The Fortran command translates Maple code to Fortran 77 code.

- If the parameter x is an algebraic expression, then a Fortran statement assigning the expression to a variable is generated.

- If x is a list, rtable or Maple Array of algebraic expressions, then a sequence of Fortran statements assigning the elements to a Fortran array is produced.  Only the initialized elements of the rtable or Maple Array are translated.

- If x is a list of equations $\mathrm{nm}=\mathrm{expr}$ where $\mathrm{nm}$ is a name and $\mathrm{expr}$ is an algebraic expression, this is understood to mean a sequence of assignment statements.  In this case, the equivalent sequence of Fortran assignment statements is generated.

- If x is a procedure, then either a Fortran function or a subroutine is generated.

- If x is a module, then a Fortran program is generated, as described on the FortranDetails help page.

The parameter cgopts may include one or more CodeGeneration options, as described in CodeGenerationOptions. The limitvariablelength=false option, available for this command only, allows you to use names longer than 6 characters.  By default, such names are automatically replaced because they do not comply with the Fortran 77 standard.

For more information about how the CodeGeneration package translates Maple code to other languages, see Translation Details. For more information about translation to Fortran in particular, see FortranDetails.

$\mathrm{with}\left(\mathrm{CodeGeneration}\right)\:$

$\mathrm{Fortran}\left(x+yz-2xz\,\mathrm{resultname}=''w''\right)$

      w = -2 * x * z + y * z + x

$\mathrm{Fortran}\left(\left[\left[x\,2y\right]\,\left[5\,z\right]\right]\,\mathrm{resultname}=''w''\right)$

      w(1,1) = x
      w(1,2) = 2 * y
      w(2,1) = 5
      w(2,2) = z

$\mathrm{cs}≔\left[s=1.0+x\,t=\ln \left(s\right)\exp \left(-x\right)\,r=\exp \left(-x\right)+xt\right]\:$

$\mathrm{Fortran}\left(\mathrm{cs}\,\mathrm{optimize}\right)$

      s = 0.10D1 + x
      t1 = log(s)
      t2 = exp(-x)
      t = t2 * t1
      r = x * t + t2

$s≔\mathrm{Fortran}\left(x+y+1\,\mathrm{declare}=\left[x::\mathrm{float}\,y::\mathrm{integer}\right]\,\mathrm{output}=\mathrm{string}\right)$

$s≔''cg\; =\; x\; +\; dble(y)\; +\; 0.1D1''$

f := proc(x, y, z) return x*y-y*z+x*z; end proc:

$\mathrm{Fortran}\left(f\,\mathrm{defaulttype}=\mathrm{integer}\right)$

      integer function f (x, y, z)
        integer x
        integer y
        integer z
        f = y * x - y * z + x * z
        return
      end

f := proc(n)
    local x, i;
    x := 0.0;
    for i to n do
        x := x + i;
    end do;
end proc:

$\mathrm{Fortran}\left(f\right)$

      doubleprecision function f (n)
        integer n
        doubleprecision x
        integer i
        doubleprecision cgret
        x = 0.0D0
        do 100, i = 1, n, 1
          x = x + dble(i)
          cgret = x
100     continue
        f = cgret
        return
      end

f := proc(x::Array(numeric, 5..7))
    return x[5]+x[6]+x[7];
end proc:

$\mathrm{Fortran}\left(f\right)$

      doubleprecision function f (x)
        doubleprecision x(5:7)
        f = x(5) + x(6) + x(7)
        return
      end

m := module() export p; local q;
    p := proc(x,y) if y>0 then trunc(x); else ceil(x); end if; end proc:
    q := proc(x) sin(x)^2 end proc:
end module:

$\mathrm{Fortran}\left(m\,\mathrm{resultname}=\mathrm{t0}\right)$

      doubleprecision function q (x)
        doubleprecision x
        q = sin(x) ** 2
        return
      end

      integer function p (x, y)
        doubleprecision x
        integer y
        if (0 .lt. y) then
          p = int(aint(x))
          return
        else
          p = int(ceil(x))
          return
        end if
      end

      program m
      end

f := proc(N)
    printf("%d is a Number.\n", N);
end proc:

$\mathrm{Fortran}\left(f\right)$

      subroutine f (N)
        doubleprecision N
        print *, N, ' is a Number.'
      end

p:=proc() local longvar: end proc;

$p≔\mathbf{proc}\left(\right)\mathbf{local}\mathrm{longvar}\;\mathbf{end\; proc}$

$\mathrm{Fortran}\left(p\right)$

      subroutine p
        doubleprecision cg
      end

$\mathrm{Fortran}\left(p\,\mathrm{limitvariablelength}=\mathrm{false}\right)$

      subroutine p
        doubleprecision longvar
      end