ALS
Inscrit le: 11 Sep 2006
Messages: 647
|
 Posté le: 22 Déc 2003 8:28 Sujet du message: Re: création d'une interface C++ pour Maple |
 |
|
Bonjour,
allez dans le répertoire d'installation de Maple, puis dans le sous-répertoire extern/include.
Vous y trouverez le fichier maplec.h qui assure l'interface entre C (ou C++) et Maple.
Voyez aussi le topic "OpenMaple" de l'aide.
Voici le listing de ce fichier, suivi du listing d'un fichier d'exemples en C montrant comment utiliser le fichier maplec.h.
D'autres exemples figurent dans le répertoire samples du répertoire d'installation de Maple.
A l'inverse, il est possible depuis Maple d'importer une fonction externe en C d'une bibliothèque gràce à la fonction define_external.
Fichier maplec.h
| Code: |
#ifndef _MAPLE_EXTERNAL_C_H_
#define _MAPLE_EXTERNAL_C_H_
/*
** Windows DLL Magic
*/
/* These are used to provide special annotations
of the .dll exports on Windows. */
#if !defined(EXT_DECL)
# ifdef _MSC_VER
# ifdef WMI_WINNT
# define EXT_DECL __declspec(dllexport)
# else
# define EXT_DECL __declspec(dllimport)
# endif /* WMI_WINNT */
# else
# define EXT_DECL
# endif /* _MSC_VER */
#endif /* EXT_DECL */
#if !defined(M_DECL)
# ifdef _MSC_VER
# define M_DECL __stdcall
# else
# define M_DECL
# endif /* _MSC_VER */
#endif /* M_DECL */
#if !defined(M_CDECL)
# ifdef _MSC_VER
# define M_CDECL __cdecl
# else
# define M_CDECL
# endif /* _MSC_VER */
#endif /* M_CDECL */
#include "mplshlib.h"
#ifdef __cplusplus
extern "C" {
#endif
/* ---------------------------------------------------------------------- */
/* Initialize a new Maple Session */
/* ---------------------------------------------------------------------- */
/* CallBack structure used by StartMaple for I/O */
typedef struct {
void (M_DECL *textCallBack) ( void *data, int tag, char *output );
void (M_DECL *errorCallBack) ( void *data, M_INT offset, char *msg );
void (M_DECL *statusCallBack) ( void *data, long kilobytesUsed,
long kilobytesAlloc, double cpuTime );
char * (M_DECL *readLineCallBack) ( void *data, M_BOOL debug );
M_BOOL (M_DECL *redirectCallBack) ( void *data, char *name,
char *mode ) ;
char * (M_DECL *streamCallBack) ( void *data, char *stream,
int nargs, char **args );
M_BOOL (M_DECL *queryInterrupt) ( void *data );
char * (M_DECL *callBackCallBack) ( void *data, char *output );
} MCallBackVectorDesc, *MCallBackVector;
/* Possible values for the tag parameter to the textCallBack function. */
#define MAPLE_TEXT_DIAG 1
#define MAPLE_TEXT_MISC 2
#define MAPLE_TEXT_OUTPUT 3
#define MAPLE_TEXT_QUIT 4
#define MAPLE_TEXT_WARNING 5
#define MAPLE_TEXT_ERROR 6
#define MAPLE_TEXT_STATUS 7
#define MAPLE_TEXT_PRETTY 8
#define MAPLE_TEXT_HELP 9
#define MAPLE_TEXT_DEBUG 10
/*
This function is used to initialze the Maple kernel and return a
MKernelVector. This function should not be called more than once.
It should not be executed if Maple is already running (eg via an
external function described by define_external() in Maple), since
external functions provide their own kernel vector.
argc: number of arguments in argv
argv: argument list (same arguments accepted by the command line
version of maple; see ?maple for complete list)
cb: I/O callbacks defined above. All unused callbacks
must be set to 0. If all callbacks are 0, stdout is used
for output, and certain functions like readline() raise errors.
user_data: pointer to anything; gets passed through to the I/O callbacks
void *info: version information -- always set to NULL
errstr: preallocated error buffer; filled in if something goes wrong
at startup.
*/
extern EXT_DECL MKernelVector M_DECL StartMaple( int argc, char *argv[],
MCallBackVector cb, void *user_data, void *info, char *errstr );
extern EXT_DECL void M_DECL StopMaple( MKernelVector kv );
extern EXT_DECL M_BOOL M_DECL RestartMaple( MKernelVector kv, char *errstr );
/* ---------------------------------------------------------------------- */
/* Set/Query Library Path */
/* ---------------------------------------------------------------------- */
/* Returns an EXPSEQ of the current library path. If the argument 'expseq'
is non NULL, then the library path is set to the given value.
See ?libname for more detail.
To set libname to a single directory use:
MapleLibName(kv,ToMapleString(kv,"/usr/local/lib"));
To specify multiple paths, use:
MapleLibName(kv,ToMapleExpressionSequence(kv,2,
ToMapleToMapleString(kv,"/usr/local/lib"),
ToMapleToMapleString(kv,"/home/mylib")));
*/
EXT_DECL ALGEB M_DECL MapleLibName( MKernelVector kv, ALGEB expseq );
/* ---------------------------------------------------------------------- */
/* Query/Set Kernel Options */
/* ---------------------------------------------------------------------- */
/* To query an option pass in val = NULL.
See ?kernelopts for a list of possible options and their possible values.
Returns the value of the given setting prior to update (or the current
value if val=NULL).
*/
EXT_DECL ALGEB M_DECL MapleKernelOptions( MKernelVector kv, char *option, ALGEB val );
/* ---------------------------------------------------------------------- */
/* Assign to Maple Variables */
/* ---------------------------------------------------------------------- */
EXT_DECL ALGEB M_DECL MapleAssign( MKernelVector kv, ALGEB lhs, ALGEB rhs );
EXT_DECL ALGEB M_DECL MapleAssignIndexed( MKernelVector kv, ALGEB lhs,
M_INT dim, M_INT *ind, ALGEB rhs );
/* ---------------------------------------------------------------------- */
/* Error Handling and User Information */
/* ---------------------------------------------------------------------- */
/* Raising Errors */
EXT_DECL void M_DECL MapleRaiseError( MKernelVector kv, char *msg );
EXT_DECL void M_DECL MapleRaiseError1( MKernelVector kv, char *msg, ALGEB arg1 );
EXT_DECL void M_DECL MapleRaiseError2( MKernelVector kv, char *msg, ALGEB arg1, ALGEB arg2 );
/* Evaluate a C Function, Trapping Any Raised Errors */
EXT_DECL void* M_DECL MapleTrapError( MKernelVector kv,
void *(M_DECL *proc) ( void *data ), void *data, M_BOOL *errorflag );
/* Provide Run-time Information */
EXT_DECL void M_DECL MapleUserInfo( MKernelVector kv, int level, char *name,
char *msg );
/* output to Maple's output stream */
EXT_DECL int M_CDECL MaplePrintf( MKernelVector kv, const char *, ... );
EXT_DECL int M_CDECL MapleALGEB_Printf( MKernelVector kv, const char *, ... );
EXT_DECL ALGEB M_CDECL MapleALGEB_SPrintf( MKernelVector kv, const char *, ... );
/* obsolete */
EXT_DECL void M_DECL InitMaplePrintf( MKernelVector kv );
EXT_DECL int M_DECL OldMaplePrintf( const char *, ... );
/* ---------------------------------------------------------------------- */
/* Evaluate a Maple Procedure or DAG using hardware floats */
/* ---------------------------------------------------------------------- */
EXT_DECL double M_DECL MapleEvalhf( MKernelVector kv, ALGEB s );
/* first argument here is args[1] */
EXT_DECL double M_DECL EvalhfMapleProc( MKernelVector kv, ALGEB fn,
int nargs, double *args );
/* ---------------------------------------------------------------------- */
/* Evaluate a Maple Procedure or statement */
/* ---------------------------------------------------------------------- */
EXT_DECL ALGEB M_CDECL EvalMapleProc( MKernelVector kv, ALGEB fn, int nargs,
/* ALGEB arg1, ALGEB arg2, */ ... );
EXT_DECL ALGEB M_DECL EvalMapleStatement( MKernelVector kv, char *statement );
EXT_DECL ALGEB M_DECL MapleEval( MKernelVector kv, ALGEB s );
/* ---------------------------------------------------------------------- */
/* Data Queries */
/* ---------------------------------------------------------------------- */
EXT_DECL M_BOOL M_DECL IsMapleAssignedName( MKernelVector kv, ALGEB s );
EXT_DECL M_BOOL M_DECL IsMapleComplexNumeric( MKernelVector kv, ALGEB s );
EXT_DECL M_BOOL M_DECL IsMapleNumeric( MKernelVector kv, ALGEB s );
EXT_DECL M_BOOL M_DECL IsMapleInteger( MKernelVector kv, ALGEB s );
EXT_DECL M_BOOL M_DECL IsMapleInteger8( MKernelVector kv, ALGEB s );
EXT_DECL M_BOOL M_DECL IsMapleInteger16( MKernelVector kv, ALGEB s );
EXT_DECL M_BOOL M_DECL IsMapleInteger32( MKernelVector kv, ALGEB s );
EXT_DECL M_BOOL M_DECL IsMapleInteger64( MKernelVector kv, ALGEB s );
EXT_DECL M_BOOL M_DECL IsMapleList( MKernelVector kv, ALGEB s );
EXT_DECL M_BOOL M_DECL IsMapleName( MKernelVector kv, ALGEB s );
EXT_DECL M_BOOL M_DECL IsMapleNULL( MKernelVector kv, ALGEB s );
EXT_DECL M_BOOL M_DECL IsMaplePointer( MKernelVector kv, ALGEB s );
EXT_DECL M_BOOL M_DECL IsMaplePointerNULL( MKernelVector kv, ALGEB s );
EXT_DECL M_BOOL M_DECL IsMapleProcedure( MKernelVector kv, ALGEB s );
EXT_DECL M_BOOL M_DECL IsMapleRTable( MKernelVector kv, ALGEB s );
EXT_DECL M_BOOL M_DECL IsMapleSet( MKernelVector kv, ALGEB s );
EXT_DECL M_BOOL M_DECL IsMapleStop( MKernelVector kv, ALGEB s );
EXT_DECL M_BOOL M_DECL IsMapleString( MKernelVector kv, ALGEB s );
EXT_DECL M_BOOL M_DECL IsMapleTable( MKernelVector kv, ALGEB s );
EXT_DECL M_BOOL M_DECL IsMapleUnassignedName( MKernelVector kv, ALGEB s );
EXT_DECL M_BOOL M_DECL IsMapleUnnamedZero( MKernelVector kv, ALGEB s );
/* ---------------------------------------------------------------------- */
/* List Manipulation */
/* ---------------------------------------------------------------------- */
EXT_DECL ALGEB M_DECL MapleListAlloc( MKernelVector kv, M_INT num_members );
EXT_DECL void M_DECL MapleListAssign( MKernelVector kv, ALGEB list, M_INT i,
ALGEB val );
EXT_DECL ALGEB M_DECL MapleListSelect( MKernelVector kv, ALGEB list, M_INT i );
/* ---------------------------------------------------------------------- */
/* Conversion from Maple Objects */
/* ---------------------------------------------------------------------- */
EXT_DECL COMPLEXF32 M_DECL MapleToComplexFloat32( MKernelVector kv, ALGEB s );
EXT_DECL COMPLEXF64 M_DECL MapleToComplexFloat64( MKernelVector kv, ALGEB s );
EXT_DECL CXDAG M_DECL MapleToComplexFloatDAG( MKernelVector kv, ALGEB s );
EXT_DECL FLOAT32 M_DECL MapleToFloat32( MKernelVector kv, ALGEB s );
EXT_DECL FLOAT64 M_DECL MapleToFloat64( MKernelVector kv, ALGEB s );
EXT_DECL INTEGER8 M_DECL MapleToInteger8( MKernelVector kv, ALGEB s );
EXT_DECL INTEGER16 M_DECL MapleToInteger16( MKernelVector kv, ALGEB s );
EXT_DECL INTEGER32 M_DECL MapleToInteger32( MKernelVector kv, ALGEB s );
EXT_DECL INTEGER64 M_DECL MapleToInteger64( MKernelVector kv, ALGEB s );
EXT_DECL M_BOOL M_DECL MapleToM_BOOL( MKernelVector kv, ALGEB s );
EXT_DECL M_INT M_DECL MapleToM_INT( MKernelVector kv, ALGEB s );
EXT_DECL void* M_DECL MapleToPointer( MKernelVector kv, ALGEB s );
EXT_DECL char* M_DECL MapleToString( MKernelVector kv, ALGEB s );
/* Determine the number of arguments in a Maple object */
EXT_DECL M_INT M_DECL MapleNumArgs( MKernelVector kv, ALGEB expr );
/* ---------------------------------------------------------------------- */
/* Rectangular Table (Vector, Matrix, Array) Manipulation */
/* ---------------------------------------------------------------------- */
EXT_DECL void M_DECL RTableAppendAttribute( MKernelVector kv, RTableSettings *s, char *name );
EXT_DECL void M_DECL RTableAppendIndFn( MKernelVector kv, RTableSettings *s,
ALGEB indfn );
EXT_DECL RTableData M_DECL RTableAssign( MKernelVector kv, ALGEB rt,
M_INT *index, RTableData val );
EXT_DECL ALGEB M_DECL RTableCopy( MKernelVector kv, RTableSettings *s,
ALGEB rt );
EXT_DECL ALGEB M_DECL RTableCopyImPart( MKernelVector kv, RTableSettings *s,
ALGEB rt );
EXT_DECL ALGEB M_DECL RTableCopyRealPart( MKernelVector kv, RTableSettings *s,
ALGEB rt );
EXT_DECL ALGEB M_DECL RTableCreate( MKernelVector kv, RTableSettings *s,
void *pdata, M_INT *bounds );
EXT_DECL void* M_DECL RTableDataBlock( MKernelVector kv, ALGEB rt );
EXT_DECL void M_DECL RTableGetDefaults( MKernelVector kv, RTableSettings *s );
EXT_DECL void M_DECL RTableGetSettings( MKernelVector kv, RTableSettings *s,
ALGEB rt );
EXT_DECL M_INT M_DECL RTableIndFn( MKernelVector kv, ALGEB rt, M_INT num );
EXT_DECL ALGEB M_DECL RTableIndFnArgs( MKernelVector kv, ALGEB rt, M_INT num );
EXT_DECL M_BOOL M_DECL RTableIsReal( MKernelVector kv, ALGEB rt );
EXT_DECL M_INT M_DECL RTableLowerBound( MKernelVector kv, ALGEB rt, M_INT dim );
EXT_DECL M_INT M_DECL RTableNumElements( MKernelVector kv, ALGEB rt );
EXT_DECL M_INT M_DECL RTableNumDimensions( MKernelVector kv, ALGEB rt );
EXT_DECL RTableData M_DECL RTableSelect( MKernelVector kv, ALGEB rt,
M_INT *index );
EXT_DECL void M_DECL RTableSetAttribute( MKernelVector kv, RTableSettings *s,
char *name );
EXT_DECL void M_DECL RTableSetIndFn( MKernelVector kv, RTableSettings *s,
ALGEB indfn );
EXT_DECL void M_DECL RTableSetType( MKernelVector kv, RTableSettings *s,
M_INT id, char *name );
EXT_DECL void M_DECL RTableSparseCompact( MKernelVector kv, ALGEB rt );
EXT_DECL NAG_INT* M_DECL RTableSparseIndexRow( MKernelVector kv, ALGEB rt,
M_INT dim );
EXT_DECL ALGEB M_DECL RTableSparseIndexSort( MKernelVector kv, ALGEB rt,
M_INT by_dim );
EXT_DECL void M_DECL RTableSparseSetNumElems( MKernelVector kv, ALGEB rt,
M_INT num );
EXT_DECL M_INT M_DECL RTableSparseSize( MKernelVector kv, ALGEB rt );
EXT_DECL void M_DECL RTableSparseResize( MKernelVector kv, ALGEB rt, M_INT size );
EXT_DECL M_INT M_DECL RTableUpperBound( MKernelVector kv, ALGEB rt, M_INT dim );
EXT_DECL ALGEB M_DECL RTableZipReIm( MKernelVector kv, RTableSettings *s,
ALGEB rt_re, ALGEB rt_im );
/* Data Selection */
EXT_DECL ALGEB M_DECL MapleSelectImaginaryPart( MKernelVector kv, ALGEB s );
EXT_DECL ALGEB M_DECL MapleSelectIndexed( MKernelVector kv, ALGEB s, M_INT dim, M_INT *ind );
EXT_DECL ALGEB M_DECL MapleSelectRealPart( MKernelVector kv, ALGEB s );
/* Data Uniquification */
EXT_DECL ALGEB M_DECL MapleUnique( MKernelVector kv,ALGEB s );
/* ---------------------------------------------------------------------- */
/* Table Manipulation */
/* ---------------------------------------------------------------------- */
EXT_DECL ALGEB M_DECL MapleTableAlloc( MKernelVector kv );
EXT_DECL void M_DECL MapleTableAssign( MKernelVector kv, ALGEB table, ALGEB ind, ALGEB val );
EXT_DECL void M_DECL MapleTableDelete( MKernelVector kv, ALGEB table, ALGEB ind );
EXT_DECL M_BOOL M_DECL MapleTableHasEntry( MKernelVector kv, ALGEB table, ALGEB ind );
EXT_DECL ALGEB M_DECL MapleTableSelect( MKernelVector kv, ALGEB table, ALGEB ind );
/* ---------------------------------------------------------------------- */
/* Conversion to Maple Objects */
/* ---------------------------------------------------------------------- */
EXT_DECL ALGEB M_DECL ToMapleBoolean( MKernelVector kv, long b );
EXT_DECL ALGEB M_DECL ToMapleChar( MKernelVector kv, long c );
EXT_DECL ALGEB M_DECL ToMapleComplex( MKernelVector kv, double re, double im );
EXT_DECL ALGEB M_DECL ToMapleComplexFloat( MKernelVector kv, ALGEB re, ALGEB im );
EXT_DECL ALGEB M_DECL NewMapleExpressionSequence( MKernelVector kv, int nargs);
EXT_DECL ALGEB M_CDECL ToMapleExpressionSequence( MKernelVector kv, int nargs, /* ALGEB arg1, ALGEB arg2, */ ... );
EXT_DECL ALGEB M_DECL ToMapleInteger( MKernelVector kv, long i );
EXT_DECL ALGEB M_DECL ToMapleInteger64( MKernelVector kv, INTEGER64 i );
EXT_DECL ALGEB M_DECL ToMapleFloat( MKernelVector kv, double f );
EXT_DECL ALGEB M_CDECL ToMapleFunction( MKernelVector kv, ALGEB fn, int nargs, ... );
EXT_DECL ALGEB M_DECL ToMapleName( MKernelVector kv, char *n, M_BOOL is_global );
EXT_DECL ALGEB M_DECL ToMapleNULL( MKernelVector kv );
EXT_DECL ALGEB M_DECL ToMapleNULLPointer( MKernelVector kv );
EXT_DECL ALGEB M_DECL ToMaplePointer( MKernelVector kv, void *v, M_INT type );
EXT_DECL ALGEB M_DECL ToMapleRelation( MKernelVector kv, const char *rel,
ALGEB lhs, ALGEB rhs );
EXT_DECL ALGEB M_DECL ToMapleString( MKernelVector kv, char *s );
EXT_DECL ALGEB M_DECL ToMapleUneval( MKernelVector kv, ALGEB s );
/* ---------------------------------------------------------------------- */
/* Memory Management */
/* ---------------------------------------------------------------------- */
/* Allocate Using Maple's Allocator */
EXT_DECL void* M_DECL MapleAlloc( MKernelVector kv, M_INT nbytes );
/* Free Memory Allocated By Maple's Allocator */
EXT_DECL void M_DECL MapleDispose( MKernelVector kv, ALGEB s );
/* Allow a to be garbage collected */
EXT_DECL void M_DECL MapleGcAllow( MKernelVector kv, ALGEB a );
/* Prevent a from being garbage collected */
EXT_DECL void M_DECL MapleGcProtect( MKernelVector kv, ALGEB a );
/* Check if an object is protected from being garbage collected */
EXT_DECL M_BOOL M_DECL MapleGcIsProtected( MKernelVector kv, ALGEB a );
/* Apply to all stored Maple objects during a gc sweep */
EXT_DECL void M_DECL MapleGcMark( MKernelVector kv, ALGEB a );
/* ---------------------------------------------------------------------- */
/* Foreign Object (MaplePointer) Management */
/* ---------------------------------------------------------------------- */
/* query the user-supplied pointer type marker */
EXT_DECL M_INT MaplePointerType( MKernelVector kv, ALGEB a );
/* set the pointer type marker */
EXT_DECL void MaplePointerSetType( MKernelVector kv, ALGEB a, M_INT type );
/* Set the function to be called during a gc mark sweep.
MapleGcMark can then be called on all Maple objects contained
in the foreign data-structure so they won't be collected.
*/
EXT_DECL void MaplePointerSetMarkFunction( MKernelVector kv, ALGEB a,
void (M_DECL *markfn)( ALGEB a ) );
/* Set a function to call when a Pointer object is about to be
garbage collected.
*/
EXT_DECL void MaplePointerSetDisposeFunction( MKernelVector kv, ALGEB a,
void (M_DECL *disposefn)( ALGEB a ) );
/* set the function to be called in order to convert a Pointer object
into a printable Maple object during printing */
EXT_DECL void MaplePointerSetPrintFunction( MKernelVector kv, ALGEB a,
ALGEB (M_DECL *printfn)( ALGEB a ) );
/* ---------------------------------------------------------------------- */
/* Access the Help System */
/* ---------------------------------------------------------------------- */
/* Possible values of the attribute passed to the writeAttrib call back. */
#define FN_NORM 0 /* normal text mode */
#define FN_ITAL 1 /* italic text mode */
#define FN_BOLD 3 /* boldfaced text mode */
#define FN_UNDER 4 /* underlined text mode */
/*
The HelpLookUpText function searches for and retrieves a help page or
a section of a help page, based on the topic passed to it. The results
are passed as a stream of characters and attributes to the specified
call-back functions.
topic: Specifies the help page retrieved
section: Indicates which section of the page to display. If this
is passed as "" or NULL, the entire page is displayed.
To restrict display to a particular section of the page,
one of the following values can be passed:
"usage"
Shows just the function name (one-line description) and
calling sequence information.
"description"
Shows the detailed description of the function.
"examples"
Shows examples of the function's usage.
"seealso"
Shows a list of alternate topics that may be related to
this function.
writeChar: Function to which output is sent. The writeChar
function can terminate rendering by returning TRUE.
writeAttrib: Function to which attribute information is passed.
Each given attribute applies to all subsequent characters
sent to writeChar until a new attribute is given.
Possible attribute values are describe above (FN_*).
The writeAttrib function can be omitted by passing NULL
for the writeAttrib parameter.
width: Indicates the width, in characters, to which the help
information should be formatted.
data: The data parameter given to StartMaple.
MapleHelp returns NULL if successful, or it returns a pointer
to an error message if unsuccessful.
*/
EXT_DECL char * M_DECL MapleHelp(
MKernelVector kv,
char *topic,
char *section,
M_BOOL (M_DECL *writechar) ( void *data, int c ),
M_BOOL (M_DECL *writeattrib) ( void *data, int a ),
int width,
void *data );
#ifdef __cplusplus
}
#endif
#endif /* _MAPLE_EXTERNAL_C_H_ */
|
Fichier simple.c
| Code: |
/* ***********************************************************************
* OpenMaple Example Program
*
* Copyright (c) Maplesoft, a division of Waterloo Maple Inc. 2003.
* You are permitted to copy, modify and distribute this code, as long as
* this copyright notice is prominently included and remains intact. If any
* modifications were done, a prominent notice of the fact that the code has
* been modified, as well as a list of the modifications, must also be
* included. To the maximum extent permitted by applicable laws, this
* material is provided "as is" without any warranty or condition of any kind.
*
* This example program illustrates how to use the OpenMaple API
* to initialize the Maple kernel and compute with it.
* Users are encouraged to use and modify this code as a starting
* point for learning the OpenMaple API.
*
*********************************************************************** */
#include <stdio.h>
#include <stdlib.h>
#include "maplec.h"
/* callback used for directing result output */
static void M_DECL textCallBack( void *data, int tag, char *output )
{
printf("%s\n",output);
}
int main( int argc, char *argv[] )
{
char err[2048]; /* command input and error string buffers */
MKernelVector kv; /* Maple kernel handle */
MCallBackVectorDesc cb = { textCallBack,
0, /* errorCallBack not used */
0, /* statusCallBack not used */
0, /* readLineCallBack not used */
0, /* redirectCallBack not used */
0, /* streamCallBack not used */
0, /* queryInterrupt not used */
0 /* callBackCallBack not used */
};
ALGEB r, l; /* Maple data-structures */
/* initialize Maple */
if( (kv=StartMaple(argc,argv,&cb,NULL,NULL,err)) == NULL ) {
printf("Fatal error, %s\n",err);
return( 1 );
}
/* example 1: find out where maple is installed */
r = MapleKernelOptions(kv,"mapledir",NULL);
if( IsMapleString(kv,r) )
printf("Maple directory = \"%s\"\n\n",MapleToString(kv,r));
/* example 2: compute an integral */
/* output goes through the textCallBack */
printf("Evaluate an integral: \n\t");
r = EvalMapleStatement(kv,"int(1/(x^4+1),x);");
/* example 3: assign x a value and reevaluate the integral */
MapleAssign(kv,
ToMapleName(kv,"x",TRUE),
ToMapleInteger(kv,0));
r = MapleEval(kv,r);
MapleALGEB_Printf(kv,"\nEvaluated at x=0, the integral is: %a\n",r);
/* example 4: create a list with 3 elements */
l = MapleListAlloc(kv,3);
MapleListAssign(kv,l,1,r);
MapleListAssign(kv,l,2,ToMapleBoolean(kv,1));
MapleListAssign(kv,l,3,ToMapleFloat(kv,3.14));
MapleALGEB_Printf(kv,"\nHere's the list: %a\n",l);
return( 0 );
}
|
A plus tard, |
|
Page d'accueil
FAQ
Rechercher
Liste des Membres
Groupes d'utilisateurs
S'enregistrer
Profil
Se connecter pour vérifier ses messages privés
Connexion
