matrixcomputationslib.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: Wed Aug 04 08:09:34 2004
 * Arguments: "-B" "macro_default" "-B" "csharedlib:matrixcomputationslib" "-W"
 * "lib:matrixcomputationslib" "-T" "link:lib" "mydet.m" "myinv.m" "myminus.m"
 * "mymtimes.m" "myplus.m" "mytranspose.m" 
 */

#include <stdio.h>
#include "matrixcomputationslib.h"
#ifdef __cplusplus
extern "C" {
#endif
extern const unsigned char __MCC_matrixcomputationslib_public_data[];
extern const char *__MCC_matrixcomputationslib_name_data;
extern const char *__MCC_matrixcomputationslib_root_data;
extern const unsigned char __MCC_matrixcomputationslib_session_data[];
extern const char *__MCC_matrixcomputationslib_matlabpath_data[];
extern const int __MCC_matrixcomputationslib_matlabpath_data_count;
extern const char *__MCC_matrixcomputationslib_mcr_runtime_options[];
extern const int __MCC_matrixcomputationslib_mcr_runtime_option_count;
extern const char *__MCC_matrixcomputationslib_mcr_application_options[];
extern const int __MCC_matrixcomputationslib_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 matrixcomputationslibInitializeWithHandlers(
    mclOutputHandlerFcn error_handler,
    mclOutputHandlerFcn print_handler
)
{
    if (_mcr_inst != NULL)
        return true;
    if (!mclmcrInitialize())
        return false;
    if (!mclInitializeComponentInstance(&_mcr_inst,
                                        __MCC_matrixcomputationslib_public_data,
                                        __MCC_matrixcomputationslib_name_data,
                                        __MCC_matrixcomputationslib_root_data,
                                        __MCC_matrixcomputationslib_session_data,
                                        __MCC_matrixcomputationslib_matlabpath_data,
                                        __MCC_matrixcomputationslib_matlabpath_data_count,
                                        __MCC_matrixcomputationslib_mcr_runtime_options,
                                        __MCC_matrixcomputationslib_mcr_runtime_option_count,
                                        true, NoObjectType, LibTarget,
                                        path_to_dll, error_handler,
                                        print_handler))
        return false;
    return true;
}

bool matrixcomputationslibInitialize(void)
{
    return matrixcomputationslibInitializeWithHandlers(mclDefaultErrorHandler,
                                                       mclDefaultPrintHandler);
}

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


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

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

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

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

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

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

void mlfMydet(int nargout, mxArray** y, mxArray* a)
{
    mclMlfFeval(_mcr_inst, "mydet", nargout, 1, 1, y, a);
}

void mlfMyinv(int nargout, mxArray** y, mxArray* a)
{
    mclMlfFeval(_mcr_inst, "myinv", nargout, 1, 1, y, a);
}

void mlfMyminus(int nargout, mxArray** y, mxArray* a, mxArray* b)
{
    mclMlfFeval(_mcr_inst, "myminus", nargout, 1, 2, y, a, b);
}

void mlfMymtimes(int nargout, mxArray** y, mxArray* a, mxArray* b)
{
    mclMlfFeval(_mcr_inst, "mymtimes", nargout, 1, 2, y, a, b);
}

void mlfMyplus(int nargout, mxArray** y, mxArray* a, mxArray* b)
{
    mclMlfFeval(_mcr_inst, "myplus", nargout, 1, 2, y, a, b);
}

void mlfMytranspose(int nargout, mxArray** y, mxArray* x)
{
    mclMlfFeval(_mcr_inst, "mytranspose", nargout, 1, 1, y, x);
}