//
// MATLAB Compiler: 2.1
// Date: Thu Dec 19 07:01:13 2002
// Arguments: "-B" "macro_default" "-O" "all" "-O" "fold_scalar_mxarrays:on"
// "-O" "fold_non_scalar_mxarrays:on" "-O" "optimize_integer_for_loops:on" "-O"
// "array_indexing:on" "-O" "optimize_conditionals:on" "-p" "-W" "main" "-L"
// "Cpp" "-t" "-T" "link:exe" "-h" "libmmfile.mlib" "-B" "sglcpp" "-p" "-W"
// "main" "-L" "Cpp" "-t" "-T" "link:exe" "-h" "libmmfile.mlib" "-W" "mainhg"
// "libmwsglm.mlib" "hier_community.m" "Default.m" "Stop_Simulation.m"
// "Call_SaveLoad_Fig.m" "SaveLoad_Fig.m" "SaveLoad.m" "Load_Population_Data.m"
// "Save_Population_Data.m" "Start_hier_community.m" "MyInline.m" "Find_Var.m"
// "isnumber.m" "Change_Number_of_Populations.m" "Switch_Populations.m"
// "Store_Parameters.m" 
//
#include "grid.hpp"
#include "libmatlbm.hpp"
#include "libmmfile.hpp"

static mxChar _array1_[126] = { 'R', 'u', 'n', '-', 't', 'i', 'm', 'e', ' ',
                                'E', 'r', 'r', 'o', 'r', ':', ' ', 'F', 'i',
                                'l', 'e', ':', ' ', 'g', 'r', 'i', 'd', ' ',
                                'L', 'i', 'n', 'e', ':', ' ', '1', ' ', 'C',
                                'o', 'l', 'u', 'm', 'n', ':', ' ', '1', ' ',
                                'T', 'h', 'e', ' ', 'f', 'u', 'n', 'c', 't',
                                'i', 'o', 'n', ' ', '"', 'g', 'r', 'i', 'd',
                                '"', ' ', 'w', 'a', 's', ' ', 'c', 'a', 'l',
                                'l', 'e', 'd', ' ', 'w', 'i', 't', 'h', ' ',
                                'm', 'o', 'r', 'e', ' ', 't', 'h', 'a', 'n',
                                ' ', 't', 'h', 'e', ' ', 'd', 'e', 'c', 'l',
                                'a', 'r', 'e', 'd', ' ', 'n', 'u', 'm', 'b',
                                'e', 'r', ' ', 'o', 'f', ' ', 'o', 'u', 't',
                                'p', 'u', 't', 's', ' ', '(', '0', ')', '.' };
static mwArray _mxarray0_ = mclInitializeString(126, _array1_);

static mxChar _array3_[125] = { 'R', 'u', 'n', '-', 't', 'i', 'm', 'e', ' ',
                                'E', 'r', 'r', 'o', 'r', ':', ' ', 'F', 'i',
                                'l', 'e', ':', ' ', 'g', 'r', 'i', 'd', ' ',
                                'L', 'i', 'n', 'e', ':', ' ', '1', ' ', 'C',
                                'o', 'l', 'u', 'm', 'n', ':', ' ', '1', ' ',
                                'T', 'h', 'e', ' ', 'f', 'u', 'n', 'c', 't',
                                'i', 'o', 'n', ' ', '"', 'g', 'r', 'i', 'd',
                                '"', ' ', 'w', 'a', 's', ' ', 'c', 'a', 'l',
                                'l', 'e', 'd', ' ', 'w', 'i', 't', 'h', ' ',
                                'm', 'o', 'r', 'e', ' ', 't', 'h', 'a', 'n',
                                ' ', 't', 'h', 'e', ' ', 'd', 'e', 'c', 'l',
                                'a', 'r', 'e', 'd', ' ', 'n', 'u', 'm', 'b',
                                'e', 'r', ' ', 'o', 'f', ' ', 'i', 'n', 'p',
                                'u', 't', 's', ' ', '(', '2', ')', '.' };
static mwArray _mxarray2_ = mclInitializeString(125, _array3_);
static mwArray _mxarray4_ = mclInitializeDouble(0.0);

static mxChar _array6_[38] = { 'F', 'i', 'r', 's', 't', ' ', 'a', 'r', 'g', 'u',
                               'm', 'e', 'n', 't', ' ', 'm', 'u', 's', 't', ' ',
                               'b', 'e', ' ', 'a', 'n', ' ', 'a', 'x', 'e', 's',
                               ' ', 'h', 'a', 'n', 'd', 'l', 'e', '.' };
static mwArray _mxarray5_ = mclInitializeString(38, _array6_);

static mxChar _array8_[28] = { 'A', 'x', 'e', 's', ' ', 'h', 'a', 'n', 'd', 'l',
                               'e', ' ', 'm', 'u', 's', 't', ' ', 'b', 'e', ' ',
                               'a', ' ', 's', 'c', 'a', 'l', 'a', 'r' };
static mwArray _mxarray7_ = mclInitializeString(28, _array8_);

static mxChar _array10_[4] = { 't', 'y', 'p', 'e' };
static mwArray _mxarray9_ = mclInitializeString(4, _array10_);

static mxChar _array12_[4] = { 'a', 'x', 'e', 's' };
static mwArray _mxarray11_ = mclInitializeString(4, _array12_);

static mxChar _array14_[23] = { 'U', 'n', 'k', 'n', 'o', 'w', 'n', ' ',
                                'c', 'o', 'm', 'm', 'a', 'n', 'd', ' ',
                                'o', 'p', 't', 'i', 'o', 'n', '.' };
static mwArray _mxarray13_ = mclInitializeString(23, _array14_);

static mxChar _array16_[5] = { 'X', 'G', 'r', 'i', 'd' };
static mwArray _mxarray15_ = mclInitializeString(5, _array16_);

static mxChar _array18_[3] = { 'o', 'f', 'f' };
static mwArray _mxarray17_ = mclInitializeString(3, _array18_);

static mxChar _array20_[2] = { 'o', 'n' };
static mwArray _mxarray19_ = mclInitializeString(2, _array20_);

static mxChar _array22_[5] = { 'Y', 'G', 'r', 'i', 'd' };
static mwArray _mxarray21_ = mclInitializeString(5, _array22_);

static mxChar _array24_[5] = { 'Z', 'G', 'r', 'i', 'd' };
static mwArray _mxarray23_ = mclInitializeString(5, _array24_);

void InitializeModule_grid() {
}

void TerminateModule_grid() {
}

static void Mgrid(mwArray arg1, mwArray arg2);

_mexLocalFunctionTable _local_function_table_grid
  = { 0, (mexFunctionTableEntry *)NULL };

//
// The function "grid" contains the normal interface for the "grid" M-function
// from file "C:\matlabR12\toolbox\matlab\graph2d\grid.m" (lines 1-81). This
// function processes any input arguments and passes them to the implementation
// version of the function, appearing above.
//
void grid(mwArray arg1, mwArray arg2) {
    Mgrid(arg1, arg2);
}

//
// The function "mlxGrid" contains the feval interface for the "grid"
// M-function from file "C:\matlabR12\toolbox\matlab\graph2d\grid.m" (lines
// 1-81). The feval function calls the implementation version of grid through
// this function. This function processes any input arguments and passes them
// to the implementation version of the function, appearing above.
//
void mlxGrid(int nlhs, mxArray * plhs[], int nrhs, mxArray * prhs[]) {
    MW_BEGIN_MLX();
    {
        mwArray mprhs[2];
        int i;
        if (nlhs > 0) {
            error(_mxarray0_);
        }
        if (nrhs > 2) {
            error(_mxarray2_);
        }
        for (i = 0; i < 2 && i < nrhs; ++i) {
            mprhs[i] = mwArray(prhs[i], 0);
        }
        for (; i < 2; ++i) {
            mprhs[i].MakeDIN();
        }
        Mgrid(mprhs[0], mprhs[1]);
    }
    MW_END_MLX();
}

//
// The function "Mgrid" is the implementation version of the "grid" M-function
// from file "C:\matlabR12\toolbox\matlab\graph2d\grid.m" (lines 1-81). It
// contains the actual compiled code for that M-function. It is a static
// function and must only be called from one of the interface functions,
// appearing below.
//
//
// function grid(arg1, arg2);
//
static void Mgrid(mwArray arg1, mwArray arg2) {
    mwLocalFunctionTable save_local_function_table_(&_local_function_table_grid);
    int nargin_(nargin(2, mwVarargin(arg1, arg2)));
    mwArray ans(mclGetUninitializedArray());
    mwArray ax(mclGetUninitializedArray());
    mwArray opt_grid(mclGetUninitializedArray());
    //
    // %GRID   Grid lines.
    // %   GRID ON adds grid lines to the current axes.
    // %   GRID OFF takes them off.
    // %   GRID, by itself, toggles the grid state of the current axes.
    // %   GRID(AX,...) uses axes AX instead of the current axes.
    // %
    // %   GRID sets the XGrid, YGrid, and ZGrid properties of
    // %   the current axes.
    // %
    // %   See also TITLE, XLABEL, YLABEL, ZLABEL, AXES, PLOT.
    // 
    // %   Copyright 1984-2000 The MathWorks, Inc. 
    // %   $Revision: 5.8 $  $Date: 2000/07/30 12:50:34 $
    // 
    // % To ensure the correct current handle is taken in all situations.
    // 
    // opt_grid = 0;
    //
    opt_grid = _mxarray4_;
    //
    // if nargin == 0
    //
    if (nargin_ == 0) {
        //
        // ax = gca;
        //
        ax = gca(mwArray::DIN);
    //
    // else
    //
    } else {
        //
        // if isempty(arg1)
        //
        if (tobool(mwVe(isempty(mwVa(arg1, "arg1"))))) {
            //
            // opt_grid = lower(arg1);
            //
            opt_grid = lower(mwVa(arg1, "arg1"));
        //
        // end
        //
        }
        //
        // if ischar(arg1)
        //
        if (tobool(mwVe(ischar(mwVa(arg1, "arg1"))))) {
            //
            // % string input (check for valid option later)
            // if nargin == 2
            //
            if (nargin_ == 2) {
                //
                // error('First argument must be an axes handle.')
                //
                error(_mxarray5_);
            //
            // end
            //
            }
            //
            // ax = gca;
            //
            ax = gca(mwArray::DIN);
            //
            // opt_grid = lower(arg1);
            //
            opt_grid = lower(mwVa(arg1, "arg1"));
        //
        // else
        //
        } else {
            //
            // % make sure non string is a scalar handle
            // if length(arg1) > 1
            //
            if (mclLengthInt(mwVa(arg1, "arg1")) > 1) {
                //
                // error('Axes handle must be a scalar');
                //
                error(_mxarray7_);
            //
            // end
            //
            }
            //
            // % handle must be a handle and axes handle
            // if ~ishandle(arg1) | ~strcmp(get(arg1, 'type'), 'axes')
            //
            {
                mwArray a_(~ mwVe(ishandle(mwVa(arg1, "arg1"))));
                if (tobool(a_)
                    || tobool(
                         a_
                         | ~ mwVe(
                               strcmp(
                                 mwVe(
                                   Nget(
                                     1,
                                     mwVarargin(
                                       mwVa(arg1, "arg1"), _mxarray9_))),
                                 _mxarray11_)))) {
                    //
                    // error('First argument must be an axes handle.');
                    //
                    error(_mxarray5_);
                } else {
                }
            //
            // end
            //
            }
            //
            // ax = arg1;
            //
            ax = mwVsa(arg1, "arg1");
            //
            // 
            // % check for string option
            // if nargin == 2
            //
            if (nargin_ == 2) {
                //
                // opt_grid = lower(arg2);
                //
                opt_grid = lower(mwVa(arg2, "arg2"));
            //
            // end
            //
            }
        //
        // end
        //
        }
    //
    // end
    //
    }
    //
    // 
    // if (isempty(opt_grid))
    //
    if (tobool(mwVe(isempty(mwVv(opt_grid, "opt_grid"))))) {
        //
        // error('Unknown command option.');
        //
        error(_mxarray13_);
    //
    // end
    //
    }
    //
    // 
    // if (opt_grid == 0)
    //
    if (mclEqBool(mwVv(opt_grid, "opt_grid"), _mxarray4_)) {
        //
        // if (strcmp(get(ax,'XGrid'),'off'))
        //
        if (tobool(
              mwVe(
                strcmp(
                  mwVe(Nget(1, mwVarargin(mwVv(ax, "ax"), _mxarray15_))),
                  _mxarray17_)))) {
            //
            // set(ax,'XGrid','on');
            //
            ans.EqAns(
              Nset(0, mwVarargin(mwVv(ax, "ax"), _mxarray15_, _mxarray19_)));
        //
        // else
        //
        } else {
            //
            // set(ax,'XGrid','off');
            //
            ans.EqAns(
              Nset(0, mwVarargin(mwVv(ax, "ax"), _mxarray15_, _mxarray17_)));
        //
        // end
        //
        }
        //
        // if (strcmp(get(ax,'YGrid'),'off'))
        //
        if (tobool(
              mwVe(
                strcmp(
                  mwVe(Nget(1, mwVarargin(mwVv(ax, "ax"), _mxarray21_))),
                  _mxarray17_)))) {
            //
            // set(ax,'YGrid','on');
            //
            ans.EqAns(
              Nset(0, mwVarargin(mwVv(ax, "ax"), _mxarray21_, _mxarray19_)));
        //
        // else
        //
        } else {
            //
            // set(ax,'YGrid','off');
            //
            ans.EqAns(
              Nset(0, mwVarargin(mwVv(ax, "ax"), _mxarray21_, _mxarray17_)));
        //
        // end
        //
        }
        //
        // if (strcmp(get(ax,'ZGrid'),'off'))
        //
        if (tobool(
              mwVe(
                strcmp(
                  mwVe(Nget(1, mwVarargin(mwVv(ax, "ax"), _mxarray23_))),
                  _mxarray17_)))) {
            //
            // set(ax,'ZGrid','on');
            //
            ans.EqAns(
              Nset(0, mwVarargin(mwVv(ax, "ax"), _mxarray23_, _mxarray19_)));
        //
        // else
        //
        } else {
            //
            // set(ax,'ZGrid','off');
            //
            ans.EqAns(
              Nset(0, mwVarargin(mwVv(ax, "ax"), _mxarray23_, _mxarray17_)));
        //
        // end
        //
        }
    //
    // elseif (strcmp(opt_grid, 'on'))
    //
    } else if (tobool(mwVe(strcmp(mwVv(opt_grid, "opt_grid"), _mxarray19_)))) {
        //
        // set(ax,'XGrid', 'on');
        //
        ans.EqAns(
          Nset(0, mwVarargin(mwVv(ax, "ax"), _mxarray15_, _mxarray19_)));
        //
        // set(ax,'YGrid', 'on');
        //
        ans.EqAns(
          Nset(0, mwVarargin(mwVv(ax, "ax"), _mxarray21_, _mxarray19_)));
        //
        // set(ax,'ZGrid', 'on');
        //
        ans.EqAns(
          Nset(0, mwVarargin(mwVv(ax, "ax"), _mxarray23_, _mxarray19_)));
    //
    // elseif (strcmp(opt_grid, 'off'))
    //
    } else if (tobool(mwVe(strcmp(mwVv(opt_grid, "opt_grid"), _mxarray17_)))) {
        //
        // set(ax,'XGrid', 'off');
        //
        ans.EqAns(
          Nset(0, mwVarargin(mwVv(ax, "ax"), _mxarray15_, _mxarray17_)));
        //
        // set(ax,'YGrid', 'off');
        //
        ans.EqAns(
          Nset(0, mwVarargin(mwVv(ax, "ax"), _mxarray21_, _mxarray17_)));
        //
        // set(ax,'ZGrid', 'off');
        //
        ans.EqAns(
          Nset(0, mwVarargin(mwVv(ax, "ax"), _mxarray23_, _mxarray17_)));
    //
    // else
    //
    } else {
        //
        // error('Unknown command option.');
        //
        error(_mxarray13_);
    //
    // end
    //
    }
}
