coder.ceval

Appeler une fonction C/C++ à partir du code généré

réduire tous les éléments de la page

Syntaxe

out = coder.ceval(functionName,arg1,...,argN)
out = coder.ceval(options,functionName,arg1,...,argN)

Description

out = coder.ceval(functionName,arg1,...,argN) appelle la fonction C/C++ spécifiée dans functionName à partir du code généré. Vous pouvez passer un ou plusieurs arguments en entrée dans l’appel de la fonction C/C++. La fonction C/C++ appelée peut renvoyer une seule sortie scalaire. Par exemple, pour appeler la fonction C standard isalnum avec myChar en entrée et isNum en sortie, utilisez isnum = coder.ceval("isalnum",myChar).

Comme le générateur de code ne connaît pas le type de la sortie renvoyée par la fonction C/C++ au moment de la génération du code, vous devez spécifier le type de out (par exemple en lui affectant une valeur fictive) avant l’appel de coder.ceval. Vous pouvez passer les variables devant stocker une sortie non scalaire à la fonction C/C++ appelée sous forme de référence avec coder.ref (MATLAB Coder) ou coder.wref (MATLAB Coder).

Pour appeler des fonctions C/C++ standard, vous devez spécifier le fichier d’en-tête avec coder.cinclude (MATLAB Coder) ou l’argument "-headerfile" de coder.ceval. Pour appeler des fonctions C/C++ personnalisées, vous devez non seulement spécifier le fichier d’en-tête mais aussi le fichier source externe ou la bibliothèque avec coder.updateBuildInfo (MATLAB Coder).

La fonction coder.ceval ne peut être utilisée que dans le code généré. Les appels de coder.ceval exécutés dans MATLAB® produisent une erreur. Pour déterminer si une fonction MATLAB s’exécute dans MATLAB, utilisez coder.target (MATLAB Coder).

exemple

out = coder.ceval(options,functionName,arg1,...,argN) appelle la fonction C/C++ spécifiée dans functionName à partir du code généré avec les options spécifiées dans l’argument options. Par exemple, utilisez "-headerfile" pour spécifier un fichier d’en-tête C/C++ et "-global" pour indiquer que la fonction C/C++ appelée utilise des variables globales.

exemple

Exemples

réduire tout

Ouvrir le live script

Utilisez coder.ceval pour appeler la fonction de bibliothèque C standard cosh() à partir du code généré.

Créez une fonction MATLAB callCosh qui utilise une entrée de type double représentant un angle en radians et qui calcule le cosinus hyperbolique de cet angle avec la fonction C cosh(). Appelez cosh() avec coder.ceval et utilisez coder.cinclude pour inclure le fichier d’en-tête math.h qui définit cosh(). Placez math.h entre chevrons <> pour identifier math.h comme un fichier d’en-tête C standard.

Comme le type de la sortie renvoyée par l’appel de coder.ceval est inconnu au moment de la génération du code, vous devez convertir la sortie de l’appel de coder.ceval vers un type connu en l’affectant à une variable dont le type a déjà été défini par une précédente affectation. Sans cette précédente affectation, la génération de code échoue.

Les appels de coder.ceval exécutés dans MATLAB produisent une erreur. Utilisez coder.target (MATLAB Coder) pour vous assurer que callCosh s’exécute dans le code généré avant d’appeler coder.ceval.

type callCosh.m
function out = callCosh(x)
arguments
    x (1,1) double
end
out = 0; % assign a dummy value to specify variable type
if coder.target("MATLAB")
    disp("This function not supported in MATLAB execution");
else
    coder.cinclude("<math.h>")
    out = coder.ceval("cosh",x);
end
end

Testez callCosh dans MATLAB. callCosh n’appelle pas coder.ceval.

x = callCosh(1);
This function not supported in MATLAB execution

Générez une fonction MEX pour callCosh.

codegen callCosh
Code generation successful.

Testez la fonction MEX générée callCosh_mex avec un angle de π radians. Comme callCosh s’exécute dans le code généré, l’appel de coder.ceval n’entraîne pas d’erreur.

callCosh_mex(pi)
ans = 
11.5920

Générez du code C pour callCosh et inspectez le code généré. La fonction C générée comprend un appel de cosh().

codegen -config:lib callCosh
Warning: Code generation is using a coder.EmbeddedCodeConfig object. Because
Embedded Coder is not installed, this might cause some Embedded Coder features
to fail.


Code generation successful (with warnings): View report

type(fullfile("codegen","lib","callCosh","callCosh.c"))
/*
 * File: callCosh.c
 *
 * MATLAB Coder version            : 25.2
 * C/C++ source code generated on  : 09-Aug-2025 12:53:57
 */

/* Include Files */
#include "callCosh.h"
#include <math.h>

/* Function Definitions */
/*
 * Arguments    : double x
 * Return Type  : double
 */
double callCosh(double x)
{
  /*  assign a dummy value to specify variable type */
  return cosh(x);
}

/*
 * File trailer for callCosh.c
 *
 * [EOF]
 */
Ouvrir le live script

Appelez les fonctions C fopen(), fclose() et fscanf() à partir du code généré avec coder.ceval et utilisez-les pour lire la première ligne d’un fichier texte contenant des valeurs séparées par des virgules. Les équivalents MATLAB de ces fonctions C, fopen, fclose, and fscanf, sont supportées pour la génération de code. Cet exemple montre comment appeler directement des fonctions C d’E/S fichiers.

Créez une fonction MATLAB useCFileIO qui renvoie la première ligne du fichier texte data.csv en utilisant coder.ceval pour appeler les fonctions C d’E/S fichiers fopen(), fclose() et fscanf(). Utilisez coder.cinclude avec des chevrons pour inclure le fichier d’en-tête C standard stdio.h dans le code généré. C’est dans ce fichier que son définies les fonctions C d’E/S fichiers. Utilisez coder.opaque (MATLAB Coder) pour initialiser la variable qui stocke le pointeur de fichier en tant que variable de type FILE * ayant la valeur initiale NULL.

Comme coder.ceval ne supporte pas les sorties de type tableau, utilisez coder.wref pour passer la variable de sortie out sous forme de référence à la fonction C fscanf(). Comme le type de out est inconnu au moment de la génération du code, initialisez cette variable avec des valeurs fictives avant l’appel de coder.ceval. Sans cette affectation, la génération de code échoue. Pour passer des vecteurs de caractères MATLAB aux fonctions C/C++ appelées avec coder.ceval, vous devez terminer chaque vecteur de manière explicite avec un caractère nul (0). Pour plus d’informations, consultez Generate C/C++ Strings from MATLAB Strings and Character Row Vectors (MATLAB Coder).

Les appels de coder.ceval exécutés dans MATLAB produisent une erreur. Utilisez coder.target pour vous assurer que useCFileIO s’exécute dans le code généré avant d’appeler coder.ceval.

type useCFileIO.m
function out = useCFileIO %#codegen
fileName = 'data.csv';
if coder.target("MATLAB")
    fid = fopen(fileName);
    out = fscanf(fid, "%f,%f,%f",3);
    fclose(fid);
else
    coder.cinclude("<stdio.h>")
    fileName = [fileName 0];
    fileMode = ['r' 0];
    fileFormat = ['%lf,%lf,%lf' 0];
    fileHandle = coder.opaque("FILE*", "NULL");
    fileHandle = coder.ceval("fopen", fileName, fileMode);
    out = [0,0,0];
    coder.ceval("fscanf", fileHandle, fileFormat, ...
        coder.wref(out), coder.wref(out(2)), coder.wref(out(3)));
    coder.ceval("fclose", fileHandle);
end

Générez et testez une fonction MEX pour useCFileIO.

codegen useCFileIO
Code generation successful.

out = useCFileIO_mex
out = 1×3

    0.7071    0.6690    0.5985

Générez du code C pour useCFileIO et inspectez le code généré. La fonction C générée appelle directement fopen(), fclose() et fscanf().

codegen -config:lib -c useCFileIO
Warning: Code generation is using a coder.EmbeddedCodeConfig object. Because
Embedded Coder is not installed, this might cause some Embedded Coder features
to fail.


Code generation successful (with warnings): View report

type(fullfile("codegen","lib","useCFileIO","useCFileIO.c"))
/*
 * File: useCFileIO.c
 *
 * MATLAB Coder version            : 25.2
 * C/C++ source code generated on  : 09-Aug-2025 12:53:50
 */

/* Include Files */
#include "useCFileIO.h"
#include <stdio.h>

/* Function Definitions */
/*
 * Arguments    : double out[3]
 * Return Type  : void
 */
void useCFileIO(double out[3])
{
  static const char b_fileFormat[12] = "%lf,%lf,%lf";
  static const char b_fileName[9] = "data.csv";
  FILE *fileHandle;
  int i;
  char fileFormat[12];
  char fileName[9];
  for (i = 0; i < 9; i++) {
    fileName[i] = b_fileName[i];
  }
  char fileMode[2];
  fileMode[0] = 'r';
  fileMode[1] = '\x00';
  fileHandle = fopen(&fileName[0], &fileMode[0]);
  out[0] = 0.0;
  out[1] = 0.0;
  out[2] = 0.0;
  for (i = 0; i < 12; i++) {
    fileFormat[i] = b_fileFormat[i];
  }
  fscanf(fileHandle, &fileFormat[0], &out[0], &out[1], &out[2]);
  fclose(fileHandle);
}

/*
 * File trailer for useCFileIO.c
 *
 * [EOF]
 */
Ouvrir le live script

Appelez la fonction C personnalisée myAdd() à partir de la fonction MATLAB addTwo.

Créer une fonction C personnalisée

Créez le fichier d’en-tête C myAdd.h. Dans celui-ci, déclarez la fonction myAdd() qui reçoit deux arguments de type double en entrée et renvoie une valeur de type double. 

type myAdd.h
double myAdd(double a, double b);

Créez une fonction C myAdd() qui additionne les deux arguments reçus en entrée. Enregistrez la fonction dans myAdd.c et incluez le fichier d’en-tête myAdd.h.

type myAdd.c
#include <stdio.h>
#include <stdlib.h>
#include "myAdd.h"

double myAdd(double a, double b)
{
  return a + b;
}

Créer une fonction MATLAB qui appelle la fonction C personnalisée

Créez la fonction MATLAB addTwo qui appelle la fonction C personnalisée myAdd() avec coder.ceval. Créez une fonction MATLAB locale myAddML qui imite la fonction C myAdd(). Utilisez coder.target (MATLAB Coder) pour vous assurer que addTwo appelle la fonction MATLAB locale myAddML lorsqu’elle s’exécute dans MATLAB, mais qu’elle appelle la fonction C myAdd() lorsqu’elle s’exécute dans le code généré. Utilisez coder.updateBuildInfo (MATLAB Coder) pour indiquer au compilateur où se trouve le fichier C contenant la fonction myAdd(). Utilisez coder.ceval avec l’option "-headerfile" pour demander au générateur de code d’inclure le fichier d’en-tête myAdd.h.

type addTwo.m
function z = addTwo(x,y)  %#codegen
arguments
    x (1,1) double;
    y (1,1) double;
end
z = 0;
if coder.target("MATLAB")
    % Executing in MATLAB, call local MATLAB function
    z = myAddML(x,y);
else
    % Executing in generated code, call C function
    coder.updateBuildInfo("addSourceFiles","myAdd.c");
    z = coder.ceval("-headerfile","myAdd.h","myAdd",x,y);
end
end

function out = myAddML(a,b)
arguments
    a (1,1) double
    b (1,1) double
end
out = a + b;
end

Générer et tester une fonction MEX

Générez une fonction MEX pour addTwo et assurez-vous que la sortie de addTwo_mex correspond à celle de addTwo pour les mêmes entrées.

codegen addTwo
Code generation successful.

addTwo(4,5)
ans = 
9

addTwo_mex(4,5)
ans = 
9

Générer et inspecter le code C

Générez du code C packagé sous forme de bibliothèque C autonome à partir de addTwo en utilisant la commande codegen avec l’option -config:lib à la ligne de commande. Le code C généré comprend un appel de la fonction C myAdd() ainsi que l’instruction #include "myAdd.h".

codegen -config:lib addTwo.m
Warning: Code generation is using a coder.EmbeddedCodeConfig object. Because
Embedded Coder is not installed, this might cause some Embedded Coder features
to fail.


Code generation successful (with warnings): View report

type(fullfile("codegen","lib","addTwo","addTwo.c"))
/*
 * File: addTwo.c
 *
 * MATLAB Coder version            : 25.2
 * C/C++ source code generated on  : 09-Aug-2025 12:54:20
 */

/* Include Files */
#include "addTwo.h"
#include "myAdd.h"

/* Function Definitions */
/*
 * Arguments    : double x
 *                double y
 * Return Type  : double
 */
double addTwo(double x, double y)
{
  /*  Executing in generated code, call C function */
  return myAdd(x, y);
}

/*
 * File trailer for addTwo.c
 *
 * [EOF]
 */
Ouvrir le live script

En C++, une fonction membre ou méthode est une fonction associée à une classe ou un objet spécifique. Appelez une méthode publique d’une classe C++ personnalisée MyClass à partir du code généré avec coder.ceval.

Créer une classe C++ simple

Pour les besoins de cet exemple, créez la classe C++ MyClass dans le fichier MyClass.hpp. Dans ce fichier d’en-tête, définissez la fonction getValue() qui renvoie une valeur constante.

type MyClass.hpp
class MyClass {
   public:
    double getValue() const {
        return 3.14;
    }
};

Appeler une fonction membre à partir du code généré

Créez la fonction MATLAB callGetValue qui appelle la fonction membre C++ getValue(). Utilisez coder.opaque (MATLAB Coder) pour déclarer la variable instanceOfMyClass en tant qu’instance de la classe C++ MyClass. Utilisez l’argument "HeaderFile" pour indiquer que MyClass est définie dans le fichier d’en-tête MyClass.hpp.

Pour appeler getValue() à partir du code généré avec coder.ceval, utilisez le modèle de fonction C++ std:mem_fn pour accéder à getValue(). Ce modèle de fonction est défini dans l’en-tête C++ standard <functional>. Passez instanceOfMyClass à getValue() avec coder.ref pour obliger le générateur de code à passer cette variable sous forme de référence et non de valeur. 

type callGetValue.m
function out = callGetValue
instanceOfMyClass = coder.opaque("MyClass", "MyClass{}", "HeaderFile", "MyClass.hpp");
out = 0;
out = coder.ceval("-headerfile", "<functional>", ...
    "std::mem_fn(&MyClass::getValue)", coder.ref(instanceOfMyClass));
end

Générer et tester une fonction MEX

Générez une fonction MEX pour callGetValue et assurez-vous qu’elle produit la sortie prévue. Pour générer une fonction MEX C++, spécifiez -lang:C++ dans la commande codegen.

codegen -lang:c++ callGetValue
Code generation successful.

callGetValue_mex
ans = 
3.1400

Générer et inspecter le code C++

Générez du code C++ packagé sous forme de bibliothèque C++ autonome à partir de callGetValue en utilisant la commande codegen avec les options -config:lib et -lang:c++ à la ligne de commande. Le code C++ généré crée une instance de MyClass et appelle la fonction membre getValue().

codegen -config:lib -lang:c++ callGetValue
Warning: Code generation is using a coder.EmbeddedCodeConfig object. Because
Embedded Coder is not installed, this might cause some Embedded Coder features
to fail.


Code generation successful (with warnings): View report

type(fullfile("codegen","lib","callGetValue","callGetValue.cpp"))
//
// File: callGetValue.cpp
//
// MATLAB Coder version            : 25.2
// C/C++ source code generated on  : 09-Aug-2025 12:54:26
//

// Include Files
#include "callGetValue.h"
#include "MyClass.hpp"
#include <functional>

// Function Definitions
//
// Arguments    : void
// Return Type  : double
//
double callGetValue()
{
  MyClass instanceOfMyClass;
  instanceOfMyClass = MyClass{};
  return std::mem_fn(&MyClass::getValue)(&instanceOfMyClass);
}

//
// File trailer for callGetValue.cpp
//
// [EOF]
//
Ouvrir le live script

Vous pouvez utiliser coder.ceval pour appeler des fonctions C/C++ définies dans des librairies C/C++ personnalisées. Ces fonctions peuvent avoir leurs propres fonctions d’initialisation et d’arrêt.

Créer une fonction et une bibliothèque C personnalisées

Pour les besoins de cet exemple, créez une fonction MATLAB integrateSquare qui calcule l’intégrale définie de x2 sur l’intervalle [min, max]. Générez une bibliothèque C autonome pour integrateSquare.

type integrateSquare.m
function out = integrateSquare(min,max)
arguments
    min (1,1) double
    max (1,1) double
end
f = @(x) x.^2;
out = integral(f, min, max);
end

codegen -config:lib integrateSquare
Warning: Code generation is using a coder.EmbeddedCodeConfig object. Because
Embedded Coder is not installed, this might cause some Embedded Coder features
to fail.


Code generation successful (with warnings): View report

Inspectez le code C généré qui se trouve dans le répertoire codegen/lib/integrateSquare. Les fichiers d’en-tête et de bibliothèque integrateSquare se trouvent dans le même répertoire ainsi que les fichiers contenant les définitions des fonctions integrateSquare_initialize() et integrateSquare_terminate().

type(fullfile("codegen","lib","integrateSquare","integrateSquare.c"))
/*
 * File: integrateSquare.c
 *
 * MATLAB Coder version            : 25.2
 * C/C++ source code generated on  : 09-Aug-2025 12:54:02
 */

/* Include Files */
#include "integrateSquare.h"
#include "integral.h"
#include "rt_nonfinite.h"

/* Function Definitions */
/*
 * Arguments    : double b_min
 *                double b_max
 * Return Type  : double
 */
double integrateSquare(double b_min, double b_max)
{
  return integral(b_min, b_max);
}

/*
 * File trailer for integrateSquare.c
 *
 * [EOF]
 */

Créer une fonction MATLAB pour appeler la fonction C personnalisée

Créez une fonction MATLAB callIntegrateSquare qui appelle la fonction C personnalisée integrateSquare() avec coder.ceval. Pour les besoins de cet exemple, appelez la fonction integrateSquare_initialize() avant l’appel de integrateSquare() et appelez ensuite la fonction integrateSquare_terminate().

Utilisez coder.updateBuildInfo (MATLAB Coder) pour ajouter le répertoire contenant la bibliothèque integrateSquare() et les autres fichiers au chemin d’inclusion. Dans l’appel de la fonction coder.updateBuildInfo, vous pouvez utiliser la macro START_DIR pour faire référence au dossier de travail actuel. Cette macro peut uniquement être utilisée dans le code MATLAB pour la génération de code. Sachant que MATLAB Coder génère les fichiers de bibliothèque statique avec des extensions spécifiques à la plateforme, utilisez ispc pour vous assurer d’utiliser l’extension qui correspond à votre plateforme.

type callIntegrateSquare.m
function out = callIntegrateSquare(x,y) %#codegen
arguments
    x (1,1) double
    y (1,1) double
end
if coder.target("MATLAB")
    disp("Calling MATLAB function");
    out = integrateSquare(x,y);
else
    disp("Calling custom C function");
    out = 0;
    coder.updateBuildInfo("addIncludePaths", ...
        "$(START_DIR)/codegen/lib/integrateSquare");
    if ispc
        coder.updateBuildInfo("addLinkObjects","integrateSquare.lib", ...
            "$(START_DIR)/codegen/lib/integrateSquare","",true,true); 
    else
        coder.updateBuildInfo("addLinkObjects","integrateSquare.a", ...
            "$(START_DIR)/codegen/lib/integrateSquare","",true,true); 
    end  
    coder.ceval("-headerfile","integrateSquare_initialize.h", ...
        "integrateSquare_initialize");
    out = coder.ceval("-headerfile","integrateSquare.h","integrateSquare", ...
        x,y);
    coder.ceval("-headerfile","integrateSquare_terminate.h", ...
        "integrateSquare_terminate");
end
end

Générer et tester une fonction MEX

Générez une fonction MEX pour callIntegrateSquare. Assurez-vous que les résultats de la fonction MATLAB et de la fonction MEX correspondent.

codegen callIntegrateSquare
Code generation successful.

callIntegrateSquare(-2,2)
Calling MATLAB function

ans = 
5.3333

callIntegrateSquare_mex(-2,2)
Calling custom C function

ans = 
5.3333

Générer et inspecter le code C

Générez une bibliothèque C autonome pour callIntegrateSquare et inspectez l’appel de integrateSquare_initialize(), integrateSquare() et integrateSquare_terminate() dans le code généré.

codegen -config:lib callIntegrateSquare
Warning: Code generation is using a coder.EmbeddedCodeConfig object. Because
Embedded Coder is not installed, this might cause some Embedded Coder features
to fail.


Code generation successful (with warnings): View report

type(fullfile("codegen","lib","callIntegrateSquare","callIntegrateSquare.c"))
/*
 * File: callIntegrateSquare.c
 *
 * MATLAB Coder version            : 25.2
 * C/C++ source code generated on  : 09-Aug-2025 12:54:14
 */

/* Include Files */
#include "callIntegrateSquare.h"
#include "coder_platform.h"
#include "integrateSquare.h"
#include "integrateSquare_initialize.h"
#include "integrateSquare_terminate.h"

/* Function Definitions */
/*
 * Arguments    : double x
 *                double y
 * Return Type  : double
 */
double callIntegrateSquare(double x, double y)
{
  double out;
  coderIsPC();
  integrateSquare_initialize();
  out = integrateSquare(x, y);
  integrateSquare_terminate();
  return out;
}

/*
 * File trailer for callIntegrateSquare.c
 *
 * [EOF]
 */

Supposons que vous disposiez d’une fonction MATLAB qui appelle du code C personnalisé utilisant des nombres complexes en entrée. Vous devez définir les paramètres d’entrée de votre code C pour mapper les entrées en nombres complexes de votre fonction MATLAB sur votre code C.

Dans le code généré, les nombres complexes sont définis en tant que struct avec deux champs re et im contenant respectivement leurs parties réelle et imaginaire. Cette struct est définie dans le fichier d’en-tête rtwtypes.h qui se trouve dans le dossier codegen\lib\functionName du chemin d’accès actuel. La struct est définie comme suit :

typedef struct {
    real32_T re; /*Real Component*/
    real32_T im; /*Imaginary Component*/
} creal_T;

Pour plus d’informations, consultez Mapping MATLAB Types to Types in Generated Code (MATLAB Coder).

Le code C à intégrer doit inclure le fichier d’en-tête rtwtypes.h. Une exemple de code C foo.c est présenté ci-dessous :

#include "foo.h"
#include<stdio.h>
#include<stdlib.h>
#include "rtwtypes.h"

double foo(creal_T x) {
    double z = 0.0;
    z = x.re*x.re + x.im*x.im;
    return (z);
}

La struct est nommée creal_T. Un fichier d’en-tête foo.h doit également être défini comme suit :

#include "rtwtypes.h"
double foo(creal_T x);

Le code MATLAB exécute foo.c avec la fonction coder.ceval qui utilise des nombres complexes en entrée :

function y = complexCeval  %#codegen
y = 0.0;
coder.updateBuildInfo("addSourceFiles","foo.c");
coder.cinclude("foo.h");
y = coder.ceval("foo", 10+20i);
end
La commande coder.ceval reçoit le nombre complexe en entrée. Le générateur de code mappe ce nombre complexe sur la variable struct creal_T x et ses champs re et im.

Générez le code pour la fonction complexCeval en exécutant la commande suivante :

codegen -config:lib -report complexCeval

Arguments d'entrée

réduire tout

Nom de la fonction C/C++ à exécuter dans le code généré, spécifiée en tant que string scalar ou vecteur de caractères. functionName doit être une constante au moment de la génération du code.

Exemple : x = coder.ceval("myFunction")

Exemple : coder.ceval("myFunction")

Types de données : char | string

Arguments passés à la fonction C/C++ appelée, spécifiés sous forme de liste de vecteurs de caractères, tableaux, éléments de tableau, structures, champs de structure ou propriétés d’objet séparés par des virgules, dans l’ordre requis par la fonction. Les string scalars et les tableaux de chaînes de caractères ne sont pas supportés.

Par défaut, coder.ceval passe les arguments sous forme de valeur à la fonction C/C++ appelée chaque fois que le passage par valeur est supporté par le langage C/C++. Pour obliger coder.ceval à passer les arguments sous forme de référence, utilisez les constructions coder.ref (MATLAB Coder), coder.rref (MATLAB Coder) et coder.wref (MATLAB Coder). Dans les situations où le C/C++ ne supporte pas le passage d’arguments par valeur, par exemple lorsque l’argument est un tableau, coder.ceval passe les arguments par référence. Si vous n’utilisez pas coder.ref, coder.rref ni coder.wref, des copies des arguments de la fonction C/C++ peuvent apparaître dans le code généré pour appliquer la sémantique MATLAB pour les tableaux.

Exemple : x = coder.ceval("tolower",myChar)

Exemple : coder.ceval("myFunction",coder.ref(x))

Types de données : single | double | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64 | logical | char | struct
Support des nombres complexes : Oui

Options d’appel de la fonction C/C++ évaluée par coder.ceval, spécifiées sous forme de valeur d’option ou de liste de valeurs d’options séparées par des virgules. Vous pouvez spécifier plusieurs options pour la fonction coder.ceval dans l’ordre de votre choix. Toutes les options (y compris headerfile) doivent être des constantes au moment de la génération du code. Le tableau suivant présente les options disponibles pour coder.ceval.

OptionDescription
"-global"Spécifier que la fonction C/C++ que doit appeler coder.ceval utilise une ou plusieurs variables globales. L’option -global désactive certaines optimisations de la génération de code qui peuvent gêner l’utilisation de variables globales dans la fonction C/C++ appelée.
"-gpudevicefcn"Spécifier que la fonction C/C++ que doit appeler coder.ceval se trouve sur un dispositif GPU. Cette option permet d’appeler des fonctions CUDA® GPU __device__ depuis les noyaux. Cette option nécessite une licence GPU Coder™.
"-headerfile","headerfile"

Spécifier que la fonction C/C++ que doit appeler coder.ceval est déclarée dans le fichier d’en-tête headerfile. Le générateur de code ajoute une instruction #include pour le fichier d’en-tête spécifié dans le code généré. Vous pouvez utiliser l’argument "-headerfile" avec coder.ceval au lieu d’appeler séparément la fonction coder.cinclude (MATLAB Coder). Vous ne pouvez spécifier qu’un seul fichier d’en-tête avec l’option "-headerfile".

Pour inclure un fichier d’en-tête C/C++ standard, placez son nom entre chevrons <>. L’instruction #include générée est au format #include <headerfile>. Le fichier d’en-tête standard doit se trouver à un emplacement standard ou dans le chemin d’inclusion.

coder.ceval("-headerfile","<math.h>","atan",45)

Pour inclure un fichier d’en-tête non standard, n’utilisez pas de chevrons. L’instruction #include générée est au format #include "headerfile". Le fichier d’en-tête non standard doit se trouver dans le dossier actuel ou dans le chemin d’inclusion.

coder.ceval("-headerfile","myHeader","myFun")

Pour spécifier le chemin d’inclusion, utilisez addIncludePaths (MATLAB Coder).

"-layout:any"Passer des données d’entrée et de sortie entre le code généré et la fonction C/C++ appelée sans modifier la disposition des données même quand les tableaux ont des dispositions différentes.
"-layout:rowMajor" ou "-row"Passer des données d’entrée et de sortie entre le code généré et la fonction C/C++ appelée dans une disposition de type row-major. Lorsque l’appel s’effectue à partir d’une fonction MATLAB ou d’un bloc MATLAB Function qui utilise une disposition de type column-major, le générateur de code convertit les entrées vers la disposition de type row-major puis il reconvertit les sorties vers la disposition de type column-major.
"-layout:columnMajor" ou "-col"Passer des données d’entrée et de sortie entre le code généré et la fonction C/C++ appelée dans une disposition de type column-major. Lorsque l’appel s’effectue à partir d’une fonction MATLAB ou d’un bloc MATLAB Function qui utilise une disposition de type row-major, le générateur de code convertit les entrées vers la disposition de type column-major puis il reconvertit les sorties vers la disposition de type row-major. Il s’agit du comportement par défaut.

Exemple : coder.ceval("-headerfile","myHeader.h","-layout:rowMajor","-global","myFunction",coder.rref(in),coder.wref(out));

Limitations

  • Vous ne pouvez pas utiliser coder.ceval avec des fonctions déclarées comme extrinsèques avec coder.extrinsic (MATLAB Coder).

  • Si une propriété a une méthode get ou set ou des validateurs, ou bien si c’est une propriété System object™ avec un attribut qui restreint ou modifie sa valeur, vous ne pouvez pas la passer par référence à une fonction externe. Consultez la rubrique Passing by Reference Not Supported for Some Properties.

  • Les matrices de taille variable en tant que paramètres de point d’entrée ne sont pas supportées pour la génération de code de type row-major.

  • Vous ne pouvez pas utiliser coder.ceval pour modifier la taille d’un tableau initialisé dans votre code MATLAB.

Conseils

  • Pour utiliser coder.ceval pour appeler une fonction C/C++ qui accepte ou renvoie des types de variables qui n’existent pas dans le code MATLAB, par exemple des pointeurs, des types FILE pour les E/S fichiers et des macros C/C++, utilisez la fonction coder.opaque.

  • Le code externe appelé avec coder.ceval et le code généré s’exécutent dans le même processus et partagent la mémoire. Si le code externe écrit par erreur dans la mémoire qui contient les structures de données utilisées par le code généré, un comportement inattendu ou une panne peut survenir. Par exemple, si le code externe tente d’écrire des données dans un tableau après son point de fin, le code généré peut avoir un comportement inattendu ou cesser de fonctionner.

  • MATLAB utilise l’encodage système UTF-8 sur la plateforme Windows®. Par conséquent, les appels système effectués à partir d’une fonction MEX générée acceptent et renvoient des chaînes de caractères à encodage UTF-8. En revanche, le code généré par MATLAB Coder™ encode les données texte avec l’encodage spécifié par les paramètres régionaux Windows. Si votre fonction de point d’entrée MATLAB utilise coder.ceval (MATLAB Coder) pour appeler une fonction C/C++ externe qui suppose un encodage système différent, la fonction MEX générée risque donc de produire du texte brouillé. Si cela se produit, vous devez mettre à jour la fonction C/C++ externe.

  • Pour passer des vecteurs de caractères MATLAB aux fonctions C/C++ appelées avec coder.ceval, vous devez terminer chaque vecteur de manière explicite avec un caractère nul (0). Pour plus d’informations, consultez Generate C/C++ Strings from MATLAB Strings and Character Row Vectors (MATLAB Coder).

Capacités étendues

développer tout

Génération de code C/C++
Générez du code C et C++ avec MATLAB® Coder™.

Génération de code GPU
Générez du code CUDA® pour les GPU NVIDIA® avec GPU Coder™.

Historique des versions

Introduit dans R2011a

développer tout

Voir aussi

| | | | | |

Rubriques