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::MATLABEngine
evalevalAsync 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++
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::feval
gcd
Use la para crear dos argumentos escalares.matlab::data::ArrayFactory
int16_t
Pase los argumentos a.MATLABEngine::feval
std::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::TypedArray
double
MATLABsqrt
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::Array
MATLAB 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; } }
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 yEndpoint
discard
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::feval
std::vector
MATLAB 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; } }
Este ejemplo llama a la función para multiplicar dos polinomios.MATLABconv
Después de llamar, utilice para obtener el resultado de.MATLABEngine::fevalAsync
FutureResult::get
MATLAB
#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; } }
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::feval
std::vector
gcd
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; } }
Puede usar tipos de C++ nativos al llamar a funciones. y acepte determinados tipos de C++ escalares pasados como argumentos de función.MATLABMATLABEngine::feval
MATLABEngine::fevalAsync
MATLAB 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_t
std::tuple
MATLABgcd
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
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.void
MATLAB
#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::feval
MATLABstd::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::feval
clock
Llame con estos argumentos.MATLABEngine::feval
Entradas
nombre de funciónMATLAB | const matlab::engine::String |
Número de salidas | const size_t |
Argumentos de entrada para la función (vacío)MATLAB | std::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; } } }
matlab::data::ArrayFactory
| matlab::engine::MATLABEngine