Example Worksheet - Maple Help

All Products Maple MapleSim

Home : Support : Online Help : Programming : Calling External Routines : Example Worksheet

External Calling

(Using Compiled Code in Maple)

Introduction

External calling is a feature in Maple that allows you to seamlessly integrate your compiled C, Fortran, or Java code into Maple. Functions written in these languages can be linked and used as if they were native Maple procedures. There are many clear benefits to using this feature.

Reuse Code.
Many users have invested a lot of time writing fast algorithms in other languages. These algorithms do not need to be rewritten. They can usually be called as is from Maple.

Extend the Power of Maple.
Numerous routines for doing a variety of mathematical and non-math operations are available on the Web. You can use these routines in Maple to improve the range of capabilities of Maple, or write your own. You can add a database object, link to controlled hardware via a serial port, or interface with another program. The possibilities are endless.

Improve Performance.
It is hard to beat the speed of compiled C and Fortran code. You can use external calling to access fast numerical libraries. In some cases, Maple already does this. Access to the NAG library routines and other numerical algorithms is already built into Maple using the external calling mechanism.

Calling an External Function

Simple C Example

Consider the following C function.

     int __stdcall mult( int a, int b )
    {
         return a * b;
    }

This function was saved in a file, mult.c, and compiled into the shared library, mult.dll.

To run this example, mult.dll must be created and placed in the c:/shared directory.

mult.dll can be built using the following Microsoft Visual C/C++ compiler command line.
C:\shared> cl -Gz mult.c -link -dll -export:mult -out:mult.dll

A similar function (without the __stdcall declaration) can be compiled on macOS, Linux, or any of the Unix platforms.
% gcc-shared mult.c -o libmult.so

To access this function from Maple, provide a description of the external function, including:

Name of the function in the shared library (mult)

Name of the shared library (mult.dll)

Parameter and return types (all ints, which are written integer[4] in Maple)

>	$my_mult := define_external (' mult', LIB = c:/shared/mult.dll,' a' :: (integer [4]),' b' :: (integer [4]), RETURN :: (integer [4]))$

The function, my_mult, can be used like any other maple procedure now.

>	$my_mult (10, 3)$

$30$

(2.1.1)

Simple Fortran Example

Consider the following Fortran function.

     INTEGER mult( a, b )
     INTEGER a
     INTEGER b
     mult = a * b
     END

It has been compiled into the shared library, mult.dll.

To access this function from Maple, provide a description of the external function, including:

Name of the function in the shared library (mult)

Name of the shared library (mult.dll)

Keyword FORTRAN to indicate which language the target is written in

Parameter and return types (all INTEGERs, which are written integer[4] in Maple)

>	$fmult := define_external (' mult', LIB = c:/shared/mult.dll, FORTRAN,' a' :: (integer [4]),' b' :: (integer [4]), RETURN :: (integer [4]))$

The function, fmult, can be used like any other maple procedure now.

>	$fmult (10, 3)$

$30$

(2.2.1)

Simple Java Example

Consider the following Java function.

public class mult {

     static int jmult( int a, int b )
    {
         return a * b;
    }
}

It has been saved in the file, mult.java, and compiled into byte code in the class library, mult.class using the command javac mult.java.

To access this function from Maple, provide a description of the external function, including:

Name of the function in the shared library (mult)

Name of the class library (mult.class)

Path to this class and any other associated class files

Keyword JAVA to indicate which language the target is written in

Parameter and return types (all ints, which are written integer[4] in Maple)

>	$jmult := define_external (' jmult', CLASS = mult, CLASSPATH = c:/shared, JAVA,' a' :: (integer [4]),' b' :: (integer [4]), RETURN :: (integer [4]))$

The function, jmult, can be used like any other maple procedure now.

>	$jmult (10, 3)$

$30$

(2.3.1)

Type Declarations

The basic type conversions are as follows.

Maple C Java Fortran

integer[1]   char         byte     BYTE
integer[2]   short        short    INTEGER*2
integer[4]   int          int      INTEGER
integer[8]   long long*   long     INTEGER*8
float[4]     float        float    REAL
float[8]     double       double   DOUBLE PRECISION

*C's long size is compiler dependent, usually 32-bits, but often 64-bits when using a 64-bit compiler.

Compound types can be built out of the basic types.

Maple C

Array(datatype=integer[4],order=..., etc.)   int x[size];
string[n]                                     char s[n];
complex[4]                                    struct { float r, i };
complex[8]                                    struct { double r, i };
REF(integer[4])                              int *x;

Matrix Example

This example uses external C code to multiply two matrices. The source code compiled into mat_mult.dll is as follows.

void mat_mult( double *A, double *B, double *C, int I, int J, int K )
{
    int i, j, k;
    double t;

    for( i = 0; i < I; i++ ) {
        for( k = 0; k < K; k++ ) {
            t = 0.0;
            for( j = 0; j < J; j++ ) {
                t += A[i*J+j] * B[j*K+k];
            }
            C[i*K+k] = t;
        }
    }
}

The Maple declaration including the name of the external function and library, plus the parameter types is as follows.

>	$matmult ≔ define_external (' mat_mult', LIB = c:/shared/mat_mult.dll,' A' ∷ ARRAY (datatype = float [8]),' B' ∷ ARRAY (datatype = float [8]),' C' ∷ ARRAY (datatype = float [8]),' i' ∷ integer [4],' j' ∷ integer [4],' k' ∷ integer [4]) &colon;$

The function is now ready to use. Create a pair of C_order Matrices with datatype=float[8] to test your function.

>	$A := Matrix ([[10, 20], [30, 40]], datatype = float [8], order = C_order)$

>	$B := Matrix ([[1.5, 2.5, 3.5], [4.5, 5.5, 6.5]], datatype = float [8], order = C_order)$

Create an empty Matrix of the right size to store the result.

>	$C := Matrix (2, 3, datatype = float [8], order = C_order)$

Call the external function.

>	$matmult (A, B, C, 2, 2, 3)$

$C$

$matmult (A, B, C, 2, 2, 3)$

$C$

(2.5.1)

Compare the result with the one the built-in Maple routine gives.

>	$A &period; B$

$A &period; B$

(2.5.2)

Compiler Notes

	_stdcall on Windows
	Most UNIX C compilers use one and only one calling convention. Windows C compilers can use any one of three conventions, __cdecl, __fastcall, or __stdcall. Maple only recognizes functions compiled with __stdcall. This is not the default used in most Windows compilers. When using Microsoft Visual C/C++, compile with the flag /Gz, or declare functions __stdcall in the code.

Functions need to be exported

Some compilers will export, or make public, all functions in your program. This means programs using the shared library can find all functions in order to make use of them. Other compilers need explicit decorations on the function declaration, and/or a file that lists all the functions that should be exported. The MSVC compiler can export functions in a variety of ways, including listing them in a .def file, putting the __declspec(dllexport) decoration on the function definition, or by using the /export:name option to the compiler.

	MSVC command line
	To build and link the Matrix Example shown above with the MSVC compiler, do one of the following. Two step method (separate compile and link): cl -c -Gz mat_mult.c link /dll /export:mat_mult mat_mult.obj One step method (compile and link on same line): cl -Gz mat_mult.c -link -dll -export:mat_mult -out:mat_mult.dll

	gcc command line
	gcc on Linux and other UNIX platforms use __stdcall and export all functions by default. Use the -shared option to create a shared library. gcc -shared mat_mult.c -olibmat_mult.so

	Fortran Compilers
	Fortran compilers use several different calling conventions. Fortran external call has only been tested with the GNU g77 compiler on various platforms. There are known incompatibilities with other compilers, especially when using string arguments. Try to get a simple example working before moving to a more complicated one.

Calling Java

To call Java functions, jvm.dll needs to be in your PATH. You may need to install a Java Developer's Kit (JDK) to get this dll. UNIX installations will need at least libjvm.so and libhpi.so in the PATH. Typically the following directories need to be added to your PATH.

Windows: $JAVA/jre/bin/classic, $JAVA/jre/bin

Solaris: $JAVA/jre/lib/sparc, $JAVA/jre/lib/sparc/native_threads

Linux: $JAVA/jre/lib/i386/classic, $JAVA/jre/lib/i386/native_threads, $JAVA/jre/lib/i386

Note: These paths may differ depending on the version and supplier of the JDK you install. $JAVA is the base directory where the JDK was installed.

Advanced Features

Wrapper Generation

So far, all the examples given leave most of the behind the scenes work up to Maple. Maple's internal representation of some data types is not necessarily compatible with the representation used by other languages. As a result sometimes conversions are needed. Often Maple can automatically do the conversions. For example, in the mult examples above, Maple needs to turn its INTPOS data structure into a 4-byte hardware integer before calling the external functions. In some cases the conversions are non-trivial and cannot be done automatically. As an intermediate step before reading the section on writing custom wrappers, understand that Maple can generate and compile wrappers on the fly. A wrapper is a bit of code that makes use of Maple's external API for type conversions before calling the real external function.

Use the keyword, WRAPPER, to tell Maple to do translations via a compiled wrapper. Consider the same Matrix example presented earlier. This time specify the keyword, WRAPPER.

>	$matmult ≔ define_external (' mat_mult', LIB = c:/shared/mat_mult.dll, WRAPPER,' A' ∷ ARRAY (datatype = float [8]),' B' ∷ ARRAY (datatype = float [8]),' C' ∷ ARRAY (datatype = float [8]),' i' ∷ integer [4],' j' ∷ integer [4],' k' ∷ integer [4]) &colon;$

The ultimate result is the same (provided you have a compiler that is properly set up). The matmult function is defined and can be used like any other Maple function. This time, however, all translations are done by executing the code in the newly created and compiled mwrap_mat_mult.c file.

mwrap_mat_mult.c

/* MWRAP_mat_mult Wrapper
   Generated automatically by Maple 8
   Do not edit this file. */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <mplshlib.h>

#include <maplec.h>

MKernelVector mapleKernelVec;
typedef void *MaplePointer;
ALGEB *args;
static ALGEB Array[3];

static FLOAT64 *MWRAPARRAY_A0_ALLOC( ALGEB m ) {
    MapleRaiseError(mapleKernelVec,"cannot create ARRAY with unspecified bounds");
}

static ALGEB MWRAPARRAY_A0_TO_MAPLE( FLOAT64 *A ) {
    RTableSettings s;
    if( Array[0] && (void*)A == RTableDataBlock(mapleKernelVec,Array[0]) )
        return(Array[0]);

    MapleRaiseError(mapleKernelVec,"cannot create ARRAY with unspecified bounds");
}

static void MWRAPARRAY_A0_TO_C( FLOAT64 **A, ALGEB m ) {
    RTableSettings s;
    if( Array[0] && (void*)(*A) == RTableDataBlock(mapleKernelVec,Array[0]) )
        return;
    RTableGetSettings(mapleKernelVec,&s,m);
    if( s.data_type != RTABLE_FLOAT64
    || !IsMapleNULL(mapleKernelVec,s.index_functions) ) {
s.data_type = RTABLE_FLOAT64;
Array[0] = RTableCopy(mapleKernelVec,&s,m);
    }
    else Array[0] = m;
    *A = (FLOAT64 *)RTableDataBlock(mapleKernelVec,Array[0]);
}

static FLOAT64 *MWRAPARRAY_A1_ALLOC( ALGEB m ) {
    MapleRaiseError(mapleKernelVec,"cannot create ARRAY with unspecified bounds");
}

static ALGEB MWRAPARRAY_A1_TO_MAPLE( FLOAT64 *A ) {
    RTableSettings s;
    if( Array[1] && (void*)A == RTableDataBlock(mapleKernelVec,Array[1]) )
        return(Array[1]);

    MapleRaiseError(mapleKernelVec,"cannot create ARRAY with unspecified bounds");
}

static void MWRAPARRAY_A1_TO_C( FLOAT64 **A, ALGEB m ) {
    RTableSettings s;
    if( Array[1] && (void*)(*A) == RTableDataBlock(mapleKernelVec,Array[1]) )
        return;
    RTableGetSettings(mapleKernelVec,&s,m);
    if( s.data_type != RTABLE_FLOAT64
    || !IsMapleNULL(mapleKernelVec,s.index_functions) ) {
s.data_type = RTABLE_FLOAT64;
Array[1] = RTableCopy(mapleKernelVec,&s,m);
    }
    else Array[1] = m;
    *A = (FLOAT64 *)RTableDataBlock(mapleKernelVec,Array[1]);
}

static FLOAT64 *MWRAPARRAY_A2_ALLOC( ALGEB m ) {
    MapleRaiseError(mapleKernelVec,"cannot create ARRAY with unspecified bounds");
}

static ALGEB MWRAPARRAY_A2_TO_MAPLE( FLOAT64 *A ) {
    RTableSettings s;
    if( Array[2] && (void*)A == RTableDataBlock(mapleKernelVec,Array[2]) )
        return(Array[2]);

    MapleRaiseError(mapleKernelVec,"cannot create ARRAY with unspecified bounds");
}

static void MWRAPARRAY_A2_TO_C( FLOAT64 **A, ALGEB m ) {
    RTableSettings s;
    if( Array[2] && (void*)(*A) == RTableDataBlock(mapleKernelVec,Array[2]) )
        return;
    RTableGetSettings(mapleKernelVec,&s,m);
    if( s.data_type != RTABLE_FLOAT64
    || !IsMapleNULL(mapleKernelVec,s.index_functions) ) {
s.data_type = RTABLE_FLOAT64;
Array[2] = RTableCopy(mapleKernelVec,&s,m);
    }
    else Array[2] = m;
    *A = (FLOAT64 *)RTableDataBlock(mapleKernelVec,Array[2]);
}

/* main - MWRAP_mat_mult */
ALGEB MWRAP_mat_mult( MKernelVector kv,
void (*fn) ( FLOAT64 *a1, FLOAT64 *a2, FLOAT64 *a3, INTEGER32 a4, INTEGER32 a5, INTEGER32 a6 ),
ALGEB fn_args )

{
    FLOAT64 *a1;
    FLOAT64 *a2;
    FLOAT64 *a3;
    INTEGER32 a4;
    INTEGER32 a5;
    INTEGER32 a6;
    int i;
    mapleKernelVec = kv;
    args = (ALGEB*) fn_args;

    if( MapleNumArgs(mapleKernelVec,(ALGEB)args) != 6 )
        MapleRaiseError(mapleKernelVec,"Incorrect number of arguments");
    for( i=0; i<3; ++i ) Array[i] = NULL;

    /* integer[4] */
    a4 = MapleToInteger32(mapleKernelVec,args[4]);

    /* integer[4] */
    a5 = MapleToInteger32(mapleKernelVec,args[5]);

    /* integer[4] */
    a6 = MapleToInteger32(mapleKernelVec,args[6]);

    /* ARRAY(datatype = float[8]) */
    if( IsMaplePointerNULL(mapleKernelVec,args[1]) )
        a1 = NULL;
    else if( IsMapleUnassignedName(mapleKernelVec,args[1]) )
        a1 = MWRAPARRAY_A0_ALLOC( args[1]);
    else {
MWRAPARRAY_A0_TO_C(&a1,args[1]);
    }

    /* ARRAY(datatype = float[8]) */
    if( IsMaplePointerNULL(mapleKernelVec,args[2]) )
        a2 = NULL;
    else if( IsMapleUnassignedName(mapleKernelVec,args[2]) )
        a2 = MWRAPARRAY_A1_ALLOC( args[2]);
    else {
MWRAPARRAY_A1_TO_C(&a2,args[2]);
    }

    /* ARRAY(datatype = float[8]) */
    if( IsMaplePointerNULL(mapleKernelVec,args[3]) )
        a3 = NULL;
    else if( IsMapleUnassignedName(mapleKernelVec,args[3]) )
        a3 = MWRAPARRAY_A2_ALLOC( args[3]);
    else {
MWRAPARRAY_A2_TO_C(&a3,args[3]);
    }

    (*fn)(a1, a2, a3, a4, a5, a6);
    return( ToMapleNULL(mapleKernelVec) );
}

The generated wrapper has some ability to convert Arrays with the wrong data type, and handle one level of procedure parameters (callbacks). Most importantly, the generated wrapper gives a good template example of how to write your own wrapper (after cleaning up the extra auto-generated layers in the file).

Fortran External Call with Wrapper

Introduction

The Fortran external API (given in libmaplefortran.so) provides routines that translate Maple data types to Fortran data types and vice versa. This allows you to invoke Fortran routines from the Maple environment. To create a Fortran external call from Maple:

1. Create a Fortran wrapper library.
In the wrapper library, translate all the Maple input parameters into Fortran data types using the routines provided by the Fortran external API. Since Fortran 77 does not provide mechanism for dynamic memory allocation, a static array is to be declared for each array parameter. This static array acts as a container and must be large enough to cover all the input array sizes. Every array parameter has to be copied to its corresponding container. After the translation is done and all the parameters have been converted to native Fortran data types, the core computation can proceed. When finished, the result must be converted back to a Maple data type.

2. Compile the wrapper library.
The wrapper must be linked with maplefortran.dll, which provides the Fortran external API routines.

3. Declare the function in Maple.
Use define_external to create a link to the Fortran wrapper shared library. This link allows invocation of the Fortran routine from Maple.

FFT Example with Wrapper

The following code invokes a Fortran external call to fftwrap that computes the Fast Fourier Transform (FFT) of a rectangular real signal. FFT is the fundamental operation of signal processing applications. FFT transforms a signal from the time domain to its spectrum in the frequency domain. The Fortran routines to compute the FFT are taken from SLATEC Common Mathematical Library, Version 4.1. The source code can be downloaded from the website http://netlib2.cs.utk.edu/slatec

fftwrap.f (source of SLATEC fftwrap function)

C***Fortran wrapper fftwrap for the FFT routine
C***Input must be a real signal
C***Every wrapper routine accepts two parameters
C***    kv   - address to the Maple kernel vector
C***    args - address to the array of input arguments

      INTEGER FUNCTION fftwrap(kv, args)
      INTEGER kv
      INTEGER args

C Header file for the Fortran external API
      INCLUDE "maplefortran.hf"

      PARAMETER( MAXFFT = 4096 )
      CHARACTER ERRMSG*100
      INTEGER ERRMSG_LEN

      REAL W( 2*MAXFFT + 15 )

C***Array used as "container" to the input array parameters
C X - real input signal
C RY - real part of FFT(X)
C IY - imaginary part of FFT(X)
C N - length of input signal
      REAL X( MAXFFT )
      DOUBLEPRECISION RY( MAXFFT )
      DOUBLEPRECISION IY( MAXFFT )

C length of input signal
      INTEGER N

C SX, SRY, SIY, and SN are addresses of Maple DAGS that correspond to
C X, RY, IY, and N, respectively
      INTEGER SX, SRY, SIY, SN

C Bounds to Maple rtables
      INTEGER RBOUNDS(2)

C Bounds to Fortran arrays
      INTEGER FBOUNDS(2)

      ERRMSG_LEN = 100
      IF ( num_args(kv, args) .NE. 4 ) THEN
          ERRMSG = 'Four parameters expected - X, RY, IY, N'
          CALL error( kv, ERRMSG, ERRMSG_LEN )
          fftwrap = 0
          RETURN
      ENDIF

C Extract each argument from the array args
      SX = extract_arg( kv, args, 1 )
      SRY = extract_arg( kv, args, 2 )
      SIY = extract_arg( kv, args, 3 )
      SN = extract_arg( kv, args, 4 )

C Argument checking
      IF ( is_rtable(kv, SX) .EQ. 0 .OR.
     *     rtable_is_real(kv, SX) .EQ. 0 ) THEN
          ERRMSG = 'input X has to be a real vector'
          CALL error( kv, ERRMSG, ERRMSG_LEN )
          fftwrap = 0
          RETURN
      ENDIF
      IF ( is_rtable(kv, SRY) .EQ. 0 .OR.
     *     rtable_is_real(kv, SRY) .EQ. 0 ) THEN
          ERRMSG = 'output RY has to be a real vector'
          CALL error( kv, ERRMSG, ERRMSG_LEN )
          fftwrap = 0
          RETURN
      ENDIF
      IF ( is_rtable(kv, SIY) .EQ. 0 .OR.
     *     rtable_is_real(kv, SIY) .EQ. 0 ) THEN
          ERRMSG = 'output IY has to be a real vector'
          CALL error( kv, ERRMSG, ERRMSG_LEN )
          fftwrap = 0
          RETURN
      ENDIF
      IF ( is_integer(kv, SN) .EQ. 0 ) THEN
          ERRMSG = 'input N has to be an integer'
          CALL error( kv, ERRMSG, ERRMSG_LEN )
          fftwrap = 0
          RETURN
      ENDIF
C Translate Maple data type to Fortran data type
      N = maple_to_integer32( kv, SN )

      RBOUNDS(1) = 1
      RBOUNDS(2) = N
      FBOUNDS(1) = 1
      FBOUNDS(2) = MAXFFT
      CALL copy_to_array( kv,
     *                    SX,
     *                    X,
     *                    1,
     *                    RBOUNDS,
     *                    1,
     *                    FBOUNDS,
     *                    IRTABLE_FLOAT32
     *                   )

C Invoke the FFT routine to find the real and imaginary part of FFT(X)
      CALL realfft( X, RY, IY, N )

C Translate Fortran data type back to Maple data type
      RBOUNDS(1) = 1
      RBOUNDS(2) = N
      FBOUNDS(1) = 1
      FBOUNDS(2) = MAXFFT
      CALL copy_to_rtable( kv,
     *                     RY,
     *                     SRY,
     *                     1,
     *                     FBOUNDS,
     *                     1,
     *                     RBOUNDS,
     *                     IRTABLE_FLOAT64
     *                     )

      RBOUNDS(1) = 1
      RBOUNDS(2) = N
      FBOUNDS(1) = 1
      FBOUNDS(2) = MAXFFT
      CALL copy_to_rtable( kv,
     *                     IY,
     *                     SIY,
     *                     1,
     *                     FBOUNDS,
     *                     1,
     *                     RBOUNDS,
     *                     IRTABLE_FLOAT64
     *                     )

      fftwrap = 0

END

realfft.f (source of SLATEC realfft function)

C***FFT routine - it is the front end to the routines of the SLATEC library
C X - real input signal
C RY - real part of FFT(X)
C IY - imaginary part of FFT(X)
C N - length of input signal
      SUBROUTINE realfft( X, RY, IY, N )
      REAL X(*)
      DOUBLEPRECISION RY(*)
      DOUBLEPRECISION IY(*)
      INTEGER N

      PARAMETER( MAXFFT = 4096 )
      REAL W( 2*MAXFFT + 15 )

C Call the SLATEC routines to compute the FFT of the real signal X
      CALL RFFTI( N, W )
      CALL RFFTF( N, X, W )

C Since the input is a real signal, the FFT routine only computes the first
C half of the spectrum. The other half can be obtained by taking the
C conjugate of the first half.

C Real part of the FFT
      RY(1) = X(1)
      DO 10, I = 1, N/2-1
          RY(I+1) = X(2*I)
          RY(N-I+1) = X(2*I)
10    CONTINUE
      RY(N/2+1) = X(N)

C Imaginary part of the FFT
      IY(1) = 0
      DO 20, I = 1, N/2-1
          IY(I+1) = X(2*I+1)
          IY(N-I+1) = -X(2*I+1)
20    CONTINUE
      IY(N/2+1) = 0

END

Setup the parameters.

>	$N ≔ 512 &colon; &num; FFT length PULSE_LEN ≔ 16 &colon; &num; Length of rectangular input signal$

Build rectangular input signal.

>	$X ≔ Vector (N, datatype = float [4]) &colon; for i from 1 to PULSE_LEN / 2 do X [i] ≔ 1 &colon; X [N - i + 1] ≔ 1 &colon; end do &colon;$

Centralize and plot input signal.

>	$Xplot ≔ [seq (X [i], i = 1 .. N)] &colon; Xplot ≔ [op (Xplot [N / 2 + 1 .. N]), op (Xplot [1 .. N / 2])] &colon; T ≔ [seq (i, i = 1 .. N)] &colon; Xplot ≔ zip ((x, y) \to [x, y], T, Xplot) &colon; plot (Xplot) &semi;$

Real and Imaginary part of FFT(X)

>	$RY ≔ Vector (N, datatype = float [8]) &colon; IY ≔ Vector (N, datatype = float [8]) &colon;$

EXTERNAL CALL (with wrapper) TO FIND FFT OF X

>	$fftwrap ≔ define_external (' fftwrap_', MAPLE, LIB = libfftwrap.so) &colon; fftwrap (X, RY, IY, N) &colon;$

Centralize and plot the magnitude of FFT(X).

>	$Yplot ≔ zip ((u, v) \to sqrt (u &Hat; 2 + v &Hat; 2), RY, IY) &colon; Yplot ≔ [seq (Yplot [i], i = 1 .. N)] &colon; Yplot ≔ [op (Yplot [N / 2 + 1 .. N]), op (Yplot [1 .. N / 2])] &colon; F ≔ [seq (i, i = 1 .. N)] &colon; Yplot ≔ zip ((x, y) \to [x, y], F, Yplot) &colon; plot (Yplot) &semi;$

FFT Example without Wrapper

	Introduction
	Alternatively, Maple also allows you to invoke Fortran routines directly without using any wrapper program. In this case, Maple makes all the data type translation automatically and hence eliminates the need for a wrapper program. This method is cleaner and requires less overhead than the wrapper method because array input does not have to be copied to a container.

Again, using the FFT example, you can make an external call to the FFT routine realfft directly without the need of a wrapper program. All the data type translation is done automatically by Maple.

The following Maple code directly invokes the FFT routine realfft to compute the FFT of a rectangular signal.

Setup

>	$restart &colon; N ≔ 512 &colon; &num; FFT length PULSE_LEN ≔ 16 &colon; &num; Length of rectangular input signal$

Build rectangular input signal.

>	$X ≔ Vector (N, datatype = float [4]) &colon; for i from 1 to PULSE_LEN / 2 do X [i] ≔ 1 &colon; X [N - i + 1] ≔ 1 &colon; end do &colon;$

Centralize and plot input signal.

>	$Xplot ≔ [seq (X [i], i = 1 .. N)] &colon; Xplot ≔ [op (Xplot [N / 2 + 1 .. N]), op (Xplot [1 .. N / 2])] &colon; T ≔ [seq (i, i = 1 .. N)] &colon; Xplot ≔ zip ((x, y) \to [x, y], T, Xplot) &colon; plot (Xplot) &semi;$

Real and Imaginary part of FFT(X)

>	$RY ≔ Vector (N, datatype = float [8]) &colon; IY ≔ Vector (N, datatype = float [8]) &colon;$

EXTERNAL CALL (without wrapper) TO FIND FFT OF X

>	$realfft ≔ define_external (' realfft_', AUTO, FORTRAN, x ∷ ARRAY (float [4]), ry ∷ ARRAY (float [8]), iy ∷ ARRAY (float [8]), n ∷ integer [4], LIB = librealfft.so) &colon; realfft (X, RY, IY, N) &colon;$

Centralize and plot the magnitude of FFT(X).

>	$Yplot ≔ zip ((u, v) \to sqrt (u &Hat; 2 + v &Hat; 2), RY, IY)$

Maple

Erweiterungen für Maple

MapleSim

Erweiterungen für MapleSim

Systementwicklung

Beratende Dienstleistungen

Produkte zur Online-Ausbildung

Ausbildung

Industrie

Automobil und Luftfahrt

Robotik

Maschinendesign & industrielle Automation

Andere

Lösungen für die Industrie

Kaufen: Einzelheiten und Preise

Kaufen

Institutionelle Studentenlizenzierung

Elite-Wartungsprogramm

Support

Produktschulung

Online Hilfe zu Produkten

Webinare und Veranstaltungen

Veröffentlichungen

Content Hubs

Anwendungsbeispiele

Community

Über Maplesoft

Pressezentrum

User Community

Kontakt

Online Help

All Products Maple MapleSim

Maple

Leistungsfähige intuitive Mathematiksoftware

Erweiterungen für Maple

MapleSim

Modellierung auf Systemebene

Erweiterungen für MapleSim

Systementwicklung

Beratende Dienstleistungen

Produkte zur Online-Ausbildung

Ausbildung

Industrie

Automobil und Luftfahrt

Robotik

Maschinendesign & industrielle Automation

Andere

Lösungen für die Industrie

Kaufen: Einzelheiten und Preise

Kaufen

Institutionelle Studentenlizenzierung

Elite-Wartungsprogramm

Support

Produktschulung

Online Hilfe zu Produkten

Webinare und Veranstaltungen

Veröffentlichungen

Content Hubs

Anwendungsbeispiele

Community

Über Maplesoft

Pressezentrum

User Community

Kontakt

Online Help

All Products Maple MapleSim