curvefittinglib.c

MATLAB C# Book. This book is a great tutorial for C# programmers who use MATLAB to develop applicati

/*
 * MATLAB Compiler: 4.0 (R14)
 * Date: Sat Aug 21 09:54:33 2004
 * Arguments: "-B" "macro_default" "-B" "csharedlib:curvefittinglib" "-W"
 * "lib:curvefittinglib" "-T" "link:lib" "myinterp1.m" "myinterp2.m"
 * "mypolyfit.m" "mypolyval.m" "mymeshgrid.m" "mygriddata.m" "myfinemeshgrid.m" 
 */

#include <stdio.h>
#include "curvefittinglib.h"
#ifdef __cplusplus
extern "C" {
#endif
extern const unsigned char __MCC_curvefittinglib_public_data[];
extern const char *__MCC_curvefittinglib_name_data;
extern const char *__MCC_curvefittinglib_root_data;
extern const unsigned char __MCC_curvefittinglib_session_data[];
extern const char *__MCC_curvefittinglib_matlabpath_data[];
extern const int __MCC_curvefittinglib_matlabpath_data_count;
extern const char *__MCC_curvefittinglib_mcr_runtime_options[];
extern const int __MCC_curvefittinglib_mcr_runtime_option_count;
extern const char *__MCC_curvefittinglib_mcr_application_options[];
extern const int __MCC_curvefittinglib_mcr_application_option_count;
#ifdef __cplusplus
}
#endif


static HMCRINSTANCE _mcr_inst = NULL;


#if defined( _MSC_VER) || defined(__BORLANDC__) || defined(__WATCOMC__) || defined(__LCC__)
#include <windows.h>

static char path_to_dll[_MAX_PATH];

BOOL WINAPI DllMain(HINSTANCE hInstance, DWORD dwReason, void *pv)
{
    if (dwReason == DLL_PROCESS_ATTACH)
    {
        char szDllPath[_MAX_PATH];
        char szDir[_MAX_DIR];
        if (GetModuleFileName(hInstance, szDllPath, _MAX_PATH) > 0)
        {
             _splitpath(szDllPath, path_to_dll, szDir, NULL, NULL);
            strcat(path_to_dll, szDir);
        }
	else return FALSE;
    }
    else if (dwReason == DLL_PROCESS_DETACH)
    {
    }
    return TRUE;
}
#endif
static int mclDefaultPrintHandler(const char *s)
{
    return fwrite(s, sizeof(char), strlen(s), stdout);
}

static int mclDefaultErrorHandler(const char *s)
{
    int written = 0, len = 0;
    len = strlen(s);
    written = fwrite(s, sizeof(char), len, stderr);
    if (len > 0 && s[ len-1 ] != '\n')
        written += fwrite("\n", sizeof(char), 1, stderr);
    return written;
}

bool curvefittinglibInitializeWithHandlers(
    mclOutputHandlerFcn error_handler,
    mclOutputHandlerFcn print_handler
)
{
    if (_mcr_inst != NULL)
        return true;
    if (!mclmcrInitialize())
        return false;
    if (!mclInitializeComponentInstance(&_mcr_inst,
                                        __MCC_curvefittinglib_public_data,
                                        __MCC_curvefittinglib_name_data,
                                        __MCC_curvefittinglib_root_data,
                                        __MCC_curvefittinglib_session_data,
                                        __MCC_curvefittinglib_matlabpath_data,
                                        __MCC_curvefittinglib_matlabpath_data_count,
                                        __MCC_curvefittinglib_mcr_runtime_options,
                                        __MCC_curvefittinglib_mcr_runtime_option_count,
                                        true, NoObjectType, LibTarget,
                                        path_to_dll, error_handler,
                                        print_handler))
        return false;
    return true;
}

bool curvefittinglibInitialize(void)
{
    return curvefittinglibInitializeWithHandlers(mclDefaultErrorHandler,
                                                 mclDefaultPrintHandler);
}

void curvefittinglibTerminate(void)
{
    if (_mcr_inst != NULL)
        mclTerminateInstance(&_mcr_inst);
}


void mlxMyinterp1(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])
{
    mclFeval(_mcr_inst, "myinterp1", nlhs, plhs, nrhs, prhs);
}

void mlxMyinterp2(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])
{
    mclFeval(_mcr_inst, "myinterp2", nlhs, plhs, nrhs, prhs);
}

void mlxMypolyfit(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])
{
    mclFeval(_mcr_inst, "mypolyfit", nlhs, plhs, nrhs, prhs);
}

void mlxMypolyval(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])
{
    mclFeval(_mcr_inst, "mypolyval", nlhs, plhs, nrhs, prhs);
}

void mlxMymeshgrid(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])
{
    mclFeval(_mcr_inst, "mymeshgrid", nlhs, plhs, nrhs, prhs);
}

void mlxMygriddata(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])
{
    mclFeval(_mcr_inst, "mygriddata", nlhs, plhs, nrhs, prhs);
}

void mlxMyfinemeshgrid(int nlhs, mxArray *plhs[], int nrhs, mxArray *prhs[])
{
    mclFeval(_mcr_inst, "myfinemeshgrid", nlhs, plhs, nrhs, prhs);
}

void mlfMyinterp1(int nargout, mxArray** yi, mxArray* x
                  , mxArray* y, mxArray* xi)
{
    mclMlfFeval(_mcr_inst, "myinterp1", nargout, 1, 3, yi, x, y, xi);
}

void mlfMyinterp2(int nargout, mxArray** ZI, mxArray* X, mxArray* Y
                  , mxArray* Z, mxArray* XI, mxArray* YI, mxArray* method)
{
    mclMlfFeval(_mcr_inst, "myinterp2", nargout, 1,
                6, ZI, X, Y, Z, XI, YI, method);
}

void mlfMypolyfit(int nargout, mxArray** p, mxArray* x
                  , mxArray* y, mxArray* n)
{
    mclMlfFeval(_mcr_inst, "mypolyfit", nargout, 1, 3, p, x, y, n);
}

void mlfMypolyval(int nargout, mxArray** y, mxArray* p, mxArray* x)
{
    mclMlfFeval(_mcr_inst, "mypolyval", nargout, 1, 2, y, p, x);
}

void mlfMymeshgrid(int nargout, mxArray** X, mxArray** Y
                   , mxArray* vectorstepx, mxArray* vectorstepy)
{
    mclMlfFeval(_mcr_inst, "mymeshgrid", nargout, 2,
                2, X, Y, vectorstepx, vectorstepy);
}

void mlfMygriddata(int nargout, mxArray** ZI, mxArray* x, mxArray* y
                   , mxArray* z, mxArray* XI, mxArray* YI)
{
    mclMlfFeval(_mcr_inst, "mygriddata", nargout, 1, 5, ZI, x, y, z, XI, YI);
}

void mlfMyfinemeshgrid(int nargout, mxArray** row, mxArray** col
                       , mxArray* vectorstepx, mxArray* vectorstepy)
{
    mclMlfFeval(_mcr_inst, "myfinemeshgrid", nargout, 2,
                2, row, col, vectorstepx, vectorstepy);
}