Esta página aún no se ha traducido para esta versión. Puede ver la versión más reciente de esta página en inglés.

Llame a funciones desde C++MATLAB

Llamar a funciones de C++ con las funciones miembro de la clase.MATLAB®fevalfevalAsyncmatlab::engine::MATLABEngine Utilice estas funciones cuando desee pasar argumentos de función de C++ a y para devolver el resultado de la ejecución de la función a C++.MATLAB Estas funciones miembro funcionan como la función.MATLABfeval

Para llamar a una función:MATLAB

  • Pase el nombre de la función como un.matlab::engine::String

  • Defina los argumentos de entrada requeridos por la función.MATLAB Puede usar los tipos de datos nativos de C++ o la API de datos.MATLAB Para obtener más información, consulte.API de datos de MATLAB

  • Especifique el número de salidas que se esperan de la función.MATLAB Una salida es la predeterminada. Para obtener más información, consulte y.Función de llamada con varios argumentos devueltosNúmero de control de salidas

  • Defina el tipo devuelto adecuado para los resultados de la función.MATLAB

  • Utilice búferes de secuencia para redirigir la salida estándar y el error estándar desde la ventana de comandos a C++.MATLAB Para obtener más información, consulteRedirigir salida de ventana de comandos a C++MATLAB

Para evaluar sentencias utilizando variables en el espacio de trabajo base, utilice las funciones miembro y.MATLABMATLABmatlab::engine::MATLABEngineevalevalAsync Estas funciones le permiten crear y utilizar variables en el espacio de trabajo, pero no devuelven valores.MATLAB Para obtener más información, consulte.Evaluar extractos de C++MATLAB

Para obtener información sobre cómo configurar y compilar programas de motor de C++, vea.Compilar programas de motor de C++

Función de llamada con único argumento devuelto

Este ejemplo utiliza la función para encontrar el máximo común divisor de dos números.MATLABgcd La función miembro devuelve los resultados de la llamada a la función.MATLABEngine::fevalgcd

Use la para crear dos argumentos escalares.matlab::data::ArrayFactoryint16_t Pase los argumentos a.MATLABEngine::fevalstd::vector

#include "MatlabEngine.hpp" #include "MatlabDataArray.hpp" #include <iostream>
void callFevalgcd() {      // Pass vector containing MATLAB data array scalar     using namespace matlab::engine;      // Start MATLAB engine synchronously     std::unique_ptr<MATLABEngine> matlabPtr = startMATLAB();      // Create MATLAB data array factory     matlab::data::ArrayFactory factory;      // Pass vector containing 2 scalar args in vector         std::vector<matlab::data::Array> args({         factory.createScalar<int16_t>(30),         factory.createScalar<int16_t>(56) });      // Call MATLAB function and return result     matlab::data::TypedArray<int16_t> result = matlabPtr->feval(u"gcd", args);     int16_t v = result[0];     std::cout << "Result: " << v << std::endl; } 

Puede llamar mediante tipos nativos de C++.MATLABEngine::feval Para ello, debe especificar el tipo devuelto con la llamada como:MATLABEngine::feval

feval<type>(...)

Por ejemplo, el tipo devuelto está aquí:int

int cresult = matlabPtr->feval<int>(u"gcd", 30, 56);

En este ejemplo se define a para pasar una matriz de tipo a la función.matlab::data::TypedArraydoubleMATLABsqrt Dado que uno de los números de la matriz es negativo, devuelve una matriz compleja como resultado.MATLAB Por lo tanto, defina el tipo devuelto como un.matlab::data::TypedArray<std::complex<double>>

#include "MatlabDataArray.hpp" #include "MatlabEngine.hpp" #include <iostream>
void callFevalsqrt() {     // Call MATLAB sqrt function on array      using namespace matlab::engine;      // Start MATLAB engine synchronously     std::unique_ptr<MATLABEngine> matlabPtr = startMATLAB();      // Create  MATLAB data array factory     matlab::data::ArrayFactory factory;      // Define a four-element array      matlab::data::TypedArray<double> const argArray =          factory.createArray({ 1,4 }, { -2.0, 2.0, 6.0, 8.0 });      // Call MATLAB function     matlab::data::TypedArray<std::complex<double>> const results =          matlabPtr->feval(u"sqrt", argArray);      // Display results     int i = 0;     for (auto r : results) {         double a = argArray[i++];         double realPart = r.real();         double imgPart = r.imag();         std::cout << "Square root of " << a << " is " <<              realPart << " + " << imgPart << "i" << std::endl;     } }

Es seguro usar un para los tipos devueltos al llamar a funciones.matlab::data::ArrayMATLAB Por ejemplo, puede escribir el ejemplo anterior utilizando un para el valor devuelto.matlab::data::Array

void callFevalsqrt() {     // Call MATLAB sqrt function on array      using namespace matlab::engine;      // Start MATLAB engine synchronously     std::unique_ptr<MATLABEngine> matlabPtr = startMATLAB();      // Create MATLAB data array factory     matlab::data::ArrayFactory factory;      // Define a four-element array      matlab::data::Array const argArray =          factory.createArray({ 1,4 }, { -2.0, 2.0, 6.0, 8.0 });      // Call MATLAB function         matlab::data::Array results = matlabPtr->feval(u"sqrt", argArray);      // Display results      for (int i = 0; i < results.getNumberOfElements(); i++) {         double a = argArray[i];         std::complex<double> v = results[i];         double realPart = v.real();         double imgPart = v.imag();         std::cout << "Square root of " << a << " is " <<             realPart << " + " << imgPart << std::endl;     } }

Función de llamada con argumentos de nombre/valor

Algunas funciones aceptan argumentos de par nombre-valor opcionales.MATLAB Los nombres son matrices de caracteres y los valores pueden ser cualquier tipo de valor. Utilice a para crear un vector de argumentos que contenga los nombres y valores en la secuencia correcta.std::vector

Este código de ejemplo llama a la función para calcular la suma de movimiento centrada en tres puntos de un vector de fila, descartando los cálculos del punto de conexión.MATLABmovsum Esta llamada de función requiere estos argumentos:

  • Matriz numérica

  • Longitud de la ventana escalar

  • Par nombre-valor que consta de las matrices de caracteres yEndpointdiscard

Aquí está el código equivalente:MATLAB

A = [4 8 6 -1 -2 -3 -1 3 4 5]; M = movsum(A,3,'Endpoints','discard');

Pase los argumentos a como un contenedor de estos argumentos para la función.MATLABEngine::fevalstd::vectorMATLAB Cree cada argumento utilizando el.matlab::data::ArrayFactory

void callFevalmovsum() {     //Pass vector containing various types of arguments      using namespace matlab::engine;      // Start MATLAB engine synchronously     std::unique_ptr<MATLABEngine> matlabPtr = startMATLAB();      // Create  MATLAB data array factory     matlab::data::ArrayFactory factory;     // Create a vector of input arguments     std::vector<matlab::data::Array> args({         factory.createArray<double>({ 1, 10 }, { 4, 8, 6, -1, -2, -3, -1, 3, 4, 5 }),         factory.createScalar<int32_t>(3),         factory.createCharArray("Endpoints"),         factory.createCharArray("discard")     });      // Call MATLAB function      matlab::data::TypedArray<double> const result = matlabPtr->feval(u"movsum", args);      // Display results         int i = 0;     for (auto r : result) {         std::cout << "results[" << i++ << "] = " << r << std::endl;     } } 

Función de llamada asincrónica

Este ejemplo llama a la función para multiplicar dos polinomios.MATLABconv Después de llamar, utilice para obtener el resultado de.MATLABEngine::fevalAsyncFutureResult::getMATLAB

#include "MatlabDataArray.hpp" #include "MatlabEngine.hpp" #include <iostream>
static void callFevalAsync() {     //Call MATLAB functions asynchronously      using namespace matlab::engine;      // Start MATLAB engine synchronously     std::unique_ptr<MATLABEngine> matlabPtr = startMATLAB();      // Create MATLAB data array factory     matlab::data::ArrayFactory factory;       // Create input argument arrays     std::vector<matlab::data::Array> args({         factory.createArray<double>({ 1, 3 },{ 1, 0, 1 }),         factory.createArray<double>({ 1, 2 },{ 2, 7 })      });     String func(u"conv");      // Call function asnychronously     FutureResult<matlab::data::Array> future = matlabPtr->fevalAsync(func, args);          // Get results     matlab::data::TypedArray<double> results = future.get();      // Display results     std::cout << "Coefficients: " << std::endl;     for (auto r : results) {         std::cout << r << " " << std::endl;     } }

Función de llamada con varios argumentos devueltos

Este código de ejemplo utiliza la función para encontrar el máximo común divisor y los coeficientes de Bézout de los dos valores numéricos pasa como entradas.MATLABgcd La función puede devolver uno o tres argumentos, en función de la cantidad de salidas que solicite la llamada a la función.gcd En este ejemplo, la llamada a la función devuelve tres salidas.MATLABgcd

De forma predeterminada, se supone que el número de valores devueltos es uno.MATLABEngine::feval Por lo tanto, debe especificar el número real de valores devueltos como el segundo argumento.MATLABEngine::feval

En este ejemplo, devuelve un que contiene los tres resultados de la llamada a la función.MATLABEngine::fevalstd::vectorgcd Los valores devueltos son enteros escalares.

#include "MatlabDataArray.hpp" #include "MatlabEngine.hpp" #include <iostream>
void multiOutput() {     //Pass vector containing MATLAB data array array      using namespace matlab::engine;      // Start MATLAB engine synchronously     std::unique_ptr<MATLABEngine> matlabPtr = startMATLAB();     std::cout << "Started MATLAB Engine" << std::endl;      //Create MATLAB data array factory     matlab::data::ArrayFactory factory;      //Create vector of MATLAB data array arrays     std::vector<matlab::data::Array> args({         factory.createScalar<int16_t>(30),         factory.createScalar<int16_t>(56)     });      //Call gcd function, get 3 outputs     const size_t numReturned = 3;     std::vector<matlab::data::Array> result = matlabPtr->feval(u"gcd", numReturned, args);      //Display results     for (auto r : result) {         std::cout << "gcd output: " << int16_t(r[0]) << std::endl;     } }

Función de llamada con tipos de C++ nativos

Puede usar tipos de C++ nativos al llamar a funciones. y acepte determinados tipos de C++ escalares pasados como argumentos de función.MATLABMATLABEngine::fevalMATLABEngine::fevalAsyncMATLAB Para pasar matrices y otros tipos a funciones, utilice la API de datos.MATLABMATLAB Para obtener más información sobre esta API, consulte.API de datos de MATLAB

En este ejemplo se utilizan valores como entradas y a para devolver los resultados de la función.int16_tstd::tupleMATLABgcd

Aquí está el código equivalente.MATLAB

[G,U,V] = gcd(int16(30),int16(56));
#include "MatlabEngine.hpp" #include <iostream> #include <tuple>
void multiOutputTuple() {     //Return tuple from MATLAB function call      using namespace matlab::engine;      // Start MATLAB engine synchronously     std::unique_ptr<MATLABEngine> matlabPtr = startMATLAB();      //Call MATLAB gcd function         std::tuple<int16_t, int16_t, int16_t> nresults;     nresults = matlabPtr->feval<std::tuple<int16_t, int16_t, int16_t>>         (u"gcd", int16_t(30), int16_t(56));      // Display results     int16_t G;     int16_t U;     int16_t V;     std::tie(G, U, V) = nresults;     std::cout << "GCD : " << G << ", "               << "Bezout U: " << U << ", "               << "Bezout V: " << V << std::endl; }

Para obtener información específica sobre la sintaxis de las funciones miembro, consulte.matlab::engine::MATLABEngine

Número de control de salidas

funciones pueden comportarse de manera diferente dependiendo del número de salidas solicitadas.MATLAB Algunas funciones no pueden devolver ninguna salida o un número especificado de salidas.

Por ejemplo, la función mantiene la ejecución durante un número especificado de segundos.MATLABpause Sin embargo, si llama con un argumento de salida, devuelve inmediatamente con un valor de estado sin pausar.pause

pause(20) % Pause for 20 seconds
state = pause(20); % No pause, return pause state

Este ejemplo llama sin asignar una salida.pause Con la salida especificada, pausa la ejecución durante 20 segundos.voidMATLAB

#include "MatlabEngine.hpp"
void voidOutput() {     // No output from feval     using namespace matlab::engine;      // Start MATLAB engine synchronously         std::unique_ptr<MATLABEngine> matlabPtr = startMATLAB();      // Call pause function with no output         matlabPtr->feval<void>(u"pause", 20);  }

Esta llamada a utiliza la firma que define los argumentos de función como un.MATLABEngine::fevalMATLABstd::vector<matlab::data::Array> Sin asignar un argumento de salida, se detiene la ejecución durante 20 segundos.MATLAB

#include "MatlabDataArray.hpp" #include "MatlabEngine.hpp"
void zeroOutput() {     // No output from feval      using namespace matlab::engine;      // Start MATLAB engine synchronously         std::unique_ptr<MATLABEngine> matlabPtr = startMATLAB();      //Create MATLAB data array factory     matlab::data::ArrayFactory factory;      // Call pause function with no output         matlab::data::Array arg = factory.createScalar<int16_t>(20);     const size_t numReturned = 0;     matlabPtr->feval(u"pause", numReturned, { arg });  }

La función devuelve la fecha y hora actuales como un vector de fecha.MATLABclock Si asigna dos salidas, devuelve la segunda salida como un valor booleano que indica si es hora de ahorro de luz diurna en la zona horaria del sistema.clock

En este ejemplo se llama a la función con una salida o dos salidas, en función del valor de un argumento de entrada.clock El segundo argumento pasado a la llamada para determinar el número de salidas para solicitar.MATLABEngine::fevalclock

Llame con estos argumentos.MATLABEngine::feval

Entradas

nombre de funciónMATLABconst matlab::engine::String
Número de salidasconst size_t
Argumentos de entrada para la función (vacío)MATLABstd::vector<matlab::data::Array>

Salidas

Todas las salidas std::vector<matlab::data::Array>
#include "MatlabDataArray.hpp" #include "MatlabEngine.hpp" #include <iostream>
void varOutputs(const bool tZone) {      using namespace matlab::engine;      // Start MATLAB engine synchronously     std::unique_ptr<MATLABEngine> matlabPtr = startMATLAB();     std::cout << "Started MATLAB Engine" << std::endl;      // Define number of outputs     size_t numReturned(0);     if (tZone) {         numReturned = 2;     } else {         numReturned = 1;     }     std::vector<matlab::data::Array> dateTime = matlabPtr->feval(u"clock", numReturned, { });     auto dateVector = dateTime[0];      // Display results     for (int i = 0; i < 6; i++) {         std::cout << double(dateVector[i]) << " ";     }      if (tZone) {         auto DTS = dateTime[1];         if (bool(DTS[0])) {             std::cout << "It is Daylight Saving Time" << std::endl;         }         else {           std::cout << "It is Standard Time" << std::endl;         }     } }

Consulte también

|

Temas relacionados