The C command translates Maple code to ANSI C code.

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

- If x is a list, rtable or Maple Array of algebraic values, then a sequence of C statements assigning the elements to a C 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 C assignment statements is generated.

- If x is a procedure, then a C function is generated, along with any necessary directives for library inclusion.

- If x is a module, then the module members are translated as described on the CDetails help page.

The parameter cgopts may include one or more CodeGeneration options, as described in CodeGenerationOptions.

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

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

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

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

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

w[0][0] = x;
w[0][1] = 2 * y;
w[1][0] = 5;
w[1][1] = z;

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

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

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

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

$s≔''cg\; =\; x\; +\; (double)\; y\; +\; 0.1e1;''$

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

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

int f (int x, int y, int z)
{
  return(y * x - y * z + x * z);
}

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

$C\left(f\right)$

double f (int n)
{
  double x;
  int i;
  double cgret;
  x = 0.0e0;
  for (i = 1; i <= n; i++)
  {
    x = x + (double) i;
    cgret = x;
  }
  return(cgret);
}

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

$C\left(f\right)$

double f (double x[3])
{
  return(x[0] + x[1] + x[2]);
}

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:

$C\left(m\&comma;\mathrm{resultname}=\mathrm{t0}\right)$

#include <math.h>

double q;
double p (double x, int y);

double q (double x)
{
  return(pow(sin(x), 0.2e1));
}

double p (double x, int y)
{
  if (0 < y)
    return((double) (int)(x));
  else
    return(ceil(x));
}

$C\left(\max \left(\frac{1}{\mathrm{abs}\left(x\right)}\&comma;x^2\right)\right)$

cg0 = (x * x >= 1 / abs(x) ? x * x : 1 / abs(x));