Main Content

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.

Cree un archivo de código fuente MEX C++

Aquí es cómo crear una función básica de MEX de C++. Esta función solo agrega un desplazamiento a cada elemento de una matriz de entrada para demostrar la entrada y salida básica. Para una discusión más detallada sobre la creación de código fuente de la función MEX, vea y temas relacionados.Estructura de la función MEX de C++

Crear archivo de código fuente

Con el editor, cree un archivo con una extensión y agregue instrucciones comentadas..cpp Por ejemplo,.MyMEXFunction.cpp

/* MyMEXFunction  * Adds second input to each    * element of first input  * a = MyMEXFunction(a,b); */

Agregar archivos de encabezado requeridos

Para las funciones MEX de C++, agregue estos archivos de encabezado

/* MyMEXFunction  * Adds second input to each    * element of first input  * a = MyMEXFunction(a,b); */  #include "mex.hpp" #include "mexAdapter.hpp"

Uso de definiciones de conveniencia

Opcionalmente, especifique el espacio de nombres y defina otras conveniencias.matlab::data

/* MyMEXFunction  * Adds second input to each    * element of first input  * a = MyMEXFunction(a,b); */  #include "mex.hpp" #include "mexAdapter.hpp"  using namespace matlab::data; using matlab::mex::ArgumentList;

Definir clase MexFunction

Todas las funciones MEX de C++ se implementan como una clase denominada.MexFunction Esta clase debe derivar de.matlab::mex::Function

/* MyMEXFunction  * Adds second input to each    * element of first input  * a = MyMEXFunction(a,b); */  #include "mex.hpp" #include "mexAdapter.hpp"  using namespace matlab::data; using matlab::mex::ArgumentList;  class MexFunction : public matlab::mex::Function {  };

Definir operador ()

Todas las clases deben invalidar el operador de llamada de función, para aceptar dos argumentos de tipo.MexFunctionoperator()matlab::mex::ArgumentList Estos argumentos contienen las entradas y salidas.

/* MyMEXFunction  * Adds second input to each    * element of first input  * a = MyMEXFunction(a,b); */  #include "mex.hpp" #include "mexAdapter.hpp"  using namespace matlab::data; using matlab::mex::ArgumentList;  class MexFunction : public matlab::mex::Function { public:     void operator()(ArgumentList outputs, ArgumentList inputs) {      }  };

Agregar función miembro para comprobar argumentos

Prueba para ver si los argumentos son del tipo y tamaño correctos. Si las pruebas fallan, llame a la función.MATLAB®error

/* MyMEXFunction
 * Adds second input to each  
 * element of first input
 * a = MyMEXFunction(a,b);
*/

#include "mex.hpp"
#include "mexAdapter.hpp"

using namespace matlab::data;
using matlab::mex::ArgumentList;

class MexFunction : public matlab::mex::Function {
public:
    void operator()(ArgumentList outputs, ArgumentList inputs) {

    }
    void checkArguments(ArgumentList outputs, ArgumentList inputs) {
        // Get pointer to engine
        std::shared_ptr<matlab::engine::MATLABEngine> matlabPtr = getEngine();

        // Get array factory
        ArrayFactory factory;

        // Check first input argument
        if (inputs[0].getType() != ArrayType::DOUBLE ||
            inputs[0].getType() == ArrayType::COMPLEX_DOUBLE ||
            inputs[0].getNumberOfElements() != 1)
        {
            matlabPtr->feval(u"error",
                0,
                std::vector<Array>({ factory.createScalar("First input must scalar double") }));
        }

        // Check second input argument
        if (inputs[1].getType() != ArrayType::DOUBLE ||
            inputs[1].getType() == ArrayType::COMPLEX_DOUBLE)
        {
            matlabPtr->feval(u"error",
                0,
                std::vector<Array>({ factory.createScalar("Input must double array") }));
        }
        // Check number of outputs
        if (outputs.size() > 1) {
            matlabPtr->feval(u"error",
                0,
                std::vector<Array>({ factory.createScalar("Only one output is returned") }));
        }
    }
};

Implemente el cálculo

Obtenga el desplazamiento escalar y asígnelo a un.constdouble Obtener la matriz de entrada y moverlo a un para trabajar en la matriz.matlab::data::TypedArray<double> Agregue el desplazamiento a cada elemento de la matriz y asigne la matriz modificada a la variable de salida.

/* MyMEXFunction
 * Adds second input to each  
 * element of first input
 * a = MyMEXFunction(a,b);
*/

#include "mex.hpp"
#include "mexAdapter.hpp"

using namespace matlab::data;
using matlab::mex::ArgumentList;

class MexFunction : public matlab::mex::Function {
public:
    void operator()(ArgumentList outputs, ArgumentList inputs) {
        checkArguments(outputs, inputs);
        const double offSet = inputs[0][0];
        TypedArray<double> doubleArray = std::move(inputs[1]);
        for (auto& elem : doubleArray) {
            elem += offSet;
        }
        outputs[0] = doubleArray;
    }

    void checkArguments(ArgumentList outputs, ArgumentList inputs) {
        // Get pointer to engine
        std::shared_ptr<matlab::engine::MATLABEngine> matlabPtr = getEngine();

        // Get array factory
        ArrayFactory factory;

        // Check first input argument
        if (inputs[0].getType() != ArrayType::DOUBLE ||
            inputs[0].getType() == ArrayType::COMPLEX_DOUBLE ||
            inputs[0].getNumberOfElements() != 1)
        {
            matlabPtr->feval(u"error",
                0,
                std::vector<Array>({ factory.createScalar("First input must scalar double") }));
        }

        // Check second input argument
        if (inputs[1].getType() != ArrayType::DOUBLE ||
            inputs[1].getType() == ArrayType::COMPLEX_DOUBLE)
        {
            matlabPtr->feval(u"error",
                0,
                std::vector<Array>({ factory.createScalar("Input must double array") }));
        }
        // Check number of outputs
        if (outputs.size() > 1) {
            matlabPtr->feval(u"error",
                0,
                std::vector<Array>({ factory.createScalar("Only one output is returned") }));
        }
    }
};

Configurar y compilar

Después de instalar un compilador admitido, utilice el comando para compilar la función MEX.mex

mex -setup c++ mex MyMEXFunction.cpp

Para obtener más información sobre la creación de funciones MEX, consulte.Compilar programas MEX de C++

Llame a la función MEX

Llame a su función MEX desde.MATLAB

b = MyMEXFunction(11.5, rand(1000));

Consulte también

| |

Temas relacionados