matlab.h

#ifndef MATLAB_WRAPPER_H
#define MATLAB_WRAPPER_H

#include <map>
#include <cstring>
#include <fstream>
#include "engine.h" //Matlab engine
#include "mystringtools.h"

//include command line compile

//Uncomment next for lines if using MS Visual Studio
class MatlabHandle{

    public:
        MatlabHandle()
        {

        }

        ~MatlabHandle() {

            clearAllVariables();
        }

        template <class T>
        void pass( T scalar, const char* varName) {

            double scalar_in = scalar;

            //delete potentially old variable with same name;
            deleteVariable(varName);

            //create vectorPtr in correct format for matlab
            arrayMap[std::string(varName)] = mxCreateDoubleScalar((double)scalar);

            //copy data to this new vector in matlab format
            //memcpy( (void *)mxGetPr(arrayMap[std::string(varName)]), (void *)&scalar_in, sizeof(double) );

            //pass to matlab
            engPutVariable(matlabEnginePtr,varName,arrayMap[std::string(varName)]);

        }


        template <class T>
        void pass(  T * vectorPtr, int M, const char* varName){

            //create type-correct C array;
            double * vectorPtr_in = new double[M];
            for (int m = 0; m < M; m++) vectorPtr_in[m] = vectorPtr[m];

            //delete potentially old variable with same name;
            deleteVariable(varName);

            //create vectorPtr_in in correct format for matlab
            arrayMap[std::string(varName)] = mxCreateDoubleMatrix(M,1,mxREAL);

            //copy data to this new vector in matlab format
            memcpy( (void *)mxGetPr(arrayMap[std::string(varName)]), (void *)vectorPtr_in, sizeof(double)*M );

            //pass to matlab
            engPutVariable(matlabEnginePtr,varName,arrayMap[std::string(varName)]);

            delete [] vectorPtr_in;

        }
        template <class T>
        void pass( T ** matrixPtr, int M, int N, const char* varName){



            //delete potentially old variable with same name;
            deleteVariable(varName);
            std::string varName_string =varName;

            //create matrixPtr in correct format for matlab
            arrayMap[varName_string] = mxCreateNumericMatrix(M,N,mxDOUBLE_CLASS,mxREAL);

            unsigned int *mn_C = new unsigned int[2];
            for (int m = 0; m < M; m++){
                mn_C[0] = m;
                for (int n = 0; n < N; n++){
                    mn_C[1] = n;
                    mwIndex mn_matlab =  mxCalcSingleSubscript(arrayMap[varName_string],2,mn_C);//convert index to matlab's indexing
                    mxGetPr(arrayMap[varName_string])[mn_matlab] = (double)matrixPtr[m][n];
                }
            }

            //pass to matlab
            engPutVariable(matlabEnginePtr,varName,arrayMap[varName_string]);


        }


        void title(const char* Title) {
            send(std::string("title(")+"\'"+Title+"\')");
        }
        void xlabel(const char* Xlabel) {
            send(std::string("xlabel(")+"\'"+Xlabel+"\')");
        }
        void ylabel(const char* Ylabel) {
            send(std::string("ylabel(")+"\'"+Ylabel+"\')");
        }

        void send(std::string command = ""){
            if (command == "") return;

            engEvalString(matlabEnginePtr,command.c_str());

        }

        void clearAllVariables(){
            std::map<std::string,mxArray*>::iterator it;
            for (it = arrayMap.begin(); it != arrayMap.end(); it++){
                //mxDestroyArray(it->second);
            }
        }

        void deleteVariable(const char* varName){
            if (arrayMap.find(varName) == arrayMap.end())
                return;
            else
                arrayMap.erase(arrayMap.find(varName));//varName upcasts to string

        }

        //in local folder
        void loadScriptandSend(const char* fileName) {
            std::ifstream matlabScript(fileName);

            if (matlabScript.is_open()){
                matlabScript.seekg(0,std::ios::end);
                std::streampos length = matlabScript.tellg();
                matlabScript.seekg(0,std::ios::beg);
                std::string command;
                char buffer[(int)length];
                matlabScript.read(buffer,length);
                command = buffer;
                std::cout << "matlabScript: \n\n" << command << "\n" << std::endl;
                send(command);
            } else {
                send("display('Error: could not load requested script.');");
            }

            matlabScript.close();
        }

    private:

    std::map<std::string,mxArray*> arrayMap;
    static Engine * matlabEnginePtr;

};
Engine* MatlabHandle::matlabEnginePtr = engOpen(NULL);

// template <>
// void MatlabHandle::pass( int scalar, const char* varName) {

//  double scalar_in = scalar;

//  //delete potentially old variable with same name;
//  deleteVariable(varName);

//  //create vectorPtr in correct format for matlab
//  arrayMap[std::string(varName)] = mxCreateNumericMatrix(1,1,mxINT32_CLASS,mxREAL);

//  *mxGetPr(arrayMap[std::string(varName)]) = (int32_t)scalar;

//  //pass to matlab
//  engPutVariable(matlabEnginePtr,varName,arrayMap[std::string(varName)]);

// }
template <>
void MatlabHandle::pass(const char* textVariable, const char* varName) {

    //create string in matlab format - and initialization
    arrayMap[std::string(varName)] = mxCreateString(textVariable);

    //pass to matlab
    engPutVariable(matlabEnginePtr,varName,arrayMap[std::string(varName)]);

}
    //Extension
    #ifdef PROBABILITY_H
        #include "probability_and_matlab_extensions.h"
    #endif

#endif