コード生成パッケージは作成、操作、そして Maple の手続きを他の言語へ翻訳するツールの集まりです。これは Maple の手続きの自動微分、コード最適化、C 言語、Fortran、そして MathML への翻訳、および Maple の手続きの操作の回数の合計を含みます。

新しい CodeGeneration パッケージは Maple のコードを他の言語に翻訳します。code to other languages. Although the codegen[C] および codegen[fortran] 関数はまだしよう可能ですが、代わりに CodeGeneration[C] および CodeGeneration[Fortran] 関数を使用されることをお勧めします。

パッケージで使用可能な関数は以下のとおりです：

特定の関数のより詳しい情報は codegen[function] を見てください。また実際の応用例については codegen[example] も見てください。

codegen 関数を使うため、コマンド with(codegen, function) を用いてその関数ひとつを定義するか、コマンド with(codegen) を用いてすべての codegen 関数を定義するか、どちらかを行ってください。さもなければ長い名前の関数 codegen[function] を呼び出してください。この長い形式の記法は、パッケージ関数名と、同じセッションで使われる他の関数の間に矛盾があるとき必要です。

with(codegen):

Warning, the protected name MathML has been redefined and
unprotected

f := 1-exp(-t)*x*y:
g := x-y*exp(-t)*x^2:
v := vector([f,g]);

fg := makeproc(v,parameters=[t,x,y]);

fortran(fg,optimized);

      subroutine fg(t,x,y,crea_par)
      doubleprecision t
      doubleprecision x
      doubleprecision y
      doubleprecision crea_par(2)
      doubleprecision t1
      doubleprecision t5
      doubleprecision v(2)
        t1 = exp(-t)
        v(1) = 1-t1*x*y
        t5 = x**2
        v(2) = x-y*t1*t5
        crea_par(1) = v(1)
        crea_par(2) = v(2)
        return
        return
      end

f := proc(C,D,theta,x,y,h,k,r)
local s,c,xbar,ybar,d1,d2,d;
  s := sin(theta);
  c := cos(theta);
  xbar := (x+C)*c + (y+D)*s;
  ybar := (y+D)*c - (x+C)*s;
  d1 := (h-xbar)^2;
  d2 := (k-ybar)^2;
  d := sqrt( d1+d2 ) - r;
  d^2
end proc:
G := GRADIENT(f,[C,D,theta],result_type=array);

C(G,optimized, precision=single);

#include <math.h>
void G(C,D,theta,x,y,h,k,r,grd)
float C;
float D;
float theta;
float x;
float y;
float h;
float k;
float r;
float grd[3];
{
  float c;
  float d1;
  float d2;
  float dfr0[7];
  float s;
  float t1;
  float t10;
  float t19;
  float t21;
  float t3;
  float t7;
  float t8;
  {
    s = sin(theta);
    c = cos(theta);
    t1 = x+C;
    t3 = y+D;
    t7 = h-t1*c-t3*s;
    d1 = t7*t7;
    t8 = k-t3*c+t1*s;
    d2 = t8*t8;
    t10 = sqrt(d1+d2);
    dfr0[6] = 2.0*t10-2.0*r;
    dfr0[5] = dfr0[6]/t10/2.0;
    dfr0[4] = dfr0[5];
    dfr0[3] = -2.0*dfr0[4]*t8;
    dfr0[2] = -2.0*dfr0[4]*t7;
    t19 = dfr0[3];
    t21 = dfr0[2];
    dfr0[1] = t19*t3+t21*t1;
    dfr0[0] = -t19*t1+t21*t3;
    grd[0] = 0.0;
    grd[1] = t19*c+t21*s;
    grd[2] = -dfr0[1]*s+dfr0[0]*c;
    return;
  }
}

cost(optimize(G));

f := Sum(x^i/i!,i=0..n);

F := makeproc(f,parameters=[n,x],locals=[i]);

F := prep2trans(F);

F := declare(n::integer,F);

C(F);

double F(n,x)
int n;
double x;
{
  double i;
  int i1;
  double s1;
  double t1;
  {
    if( n < 0.0 )
      s1 = 0.0;
    else
      {
        t1 = 1.0;
        s1 = 1.0;
        for(i1 = 1;i1 <= n;i1++)
        {
          t1 = x/i1*t1;
          s1 += t1;
        }
      }
    return(s1);
  }
}

f := Proc( Parameters(n::integer,x::float),
           Locals(i,s,t),
           StatSeq( Assign(s,1.0),
                    Assign(t,1.0),
                    For( i, 1, 1, n, true,
                         StatSeq( Assign(t,x*t/i), Assign(s,s+t) ) ),
                    s ));

F := intrep2maple(f);

f := 1-exp(-t)*x*y;

F := makeproc(f,[x,y,t]);

G := GRADIENT(F, [x,y], result_type=array);

G := dontreturn(grd, makeparam(grd,G));

H := HESSIAN(F, [x,y], result_type=array):
H := renamevar(grd=hes, dontreturn(grd, makeparam(grd,H)) );

GH := optimize( joinprocs([G,H]) );

f := proc(x,n) local A,i;
  A := array(0..n);
  A[0] := 1;
  for i to n do A[i] := x*A[i-1] end do;
  A
end proc:
IR := maple2intrep(f);

intrep2maple(IR); # array(0..n) is evaluated, giving an error

Error, non-integer ranges in array/table creation

intrep2maple(eval(IR,1));