windforceonvessel.c

船舶荷载计算程序

/*
 * MATLAB Compiler: 3.0
 * Date: Tue Aug 01 07:54:22 2006
 * 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" "-M" "-silentsetup" "-d"
 * "C:/MATLAB6p5/work/testwin/src" "-B" "cexcel:testwin,testwin,1.0" "-t" "-W"
 * "excel:testwin,testwin,1.0" "-T" "link:lib" "-h" "libmmfile.mlib" "-b" "-i"
 * "-b" "-i" "C:/MATLAB6p5/work/VesselLoad/WindForceOnVessel.m" 
 */
#include "windforceonvessel.h"
#include "libmatlbm.h"
#include "libmmfile.h"

static double _array1_[3] = { 1.0, 2.0, 3.0 };
static mxArray * _mxarray0_;
static mxArray * _mxarray2_;

static double _array4_[8] = { 50.0, 1.0, 100.0, .9, 200.0, .7, 250.0, .6 };
static mxArray * _mxarray3_;
static mxArray * _mxarray5_;
static mxArray * _mxarray6_;
static mxArray * _mxarray7_;
static mxArray * _mxarray8_;
static mxArray * _mxarray9_;
static mxArray * _mxarray10_;
static mxArray * _mxarray11_;
static mxArray * _mxarray12_;
static mxArray * _mxarray13_;
static mxArray * _mxarray14_;
static mxArray * _mxarray15_;
static mxArray * _mxarray16_;
static mxArray * _mxarray17_;
static mxArray * _mxarray18_;
static mxArray * _mxarray19_;
static mxArray * _mxarray20_;
static mxArray * _mxarray21_;
static mxArray * _mxarray22_;
static mxArray * _mxarray23_;
static mxArray * _mxarray24_;
static mxArray * _mxarray25_;
static mxArray * _mxarray26_;
static mxArray * _mxarray27_;
static mxArray * _mxarray28_;
static mxArray * _mxarray29_;
static mxArray * _mxarray30_;
static mxArray * _mxarray31_;
static mxArray * _mxarray32_;
static mxArray * _mxarray33_;
static mxArray * _mxarray34_;
static mxArray * _mxarray35_;
static mxArray * _mxarray36_;
static mxArray * _mxarray37_;

void InitializeModule_windforceonvessel(void) {
    _mxarray0_ = mclInitializeDoubleVector(1, 3, _array1_);
    _mxarray2_ = mclInitializeDouble(1.0);
    _mxarray3_ = mclInitializeDoubleVector(2, 4, _array4_);
    _mxarray5_ = mclInitializeDoubleVector(0, 0, (double *)NULL);
    _mxarray6_ = mclInitializeDouble(3.0);
    _mxarray7_ = mclInitializeDouble(10.0);
    _mxarray8_ = mclInitializeDouble(.648);
    _mxarray9_ = mclInitializeDouble(.55);
    _mxarray10_ = mclInitializeDouble(.427);
    _mxarray11_ = mclInitializeDouble(.48);
    _mxarray12_ = mclInitializeDouble(.733);
    _mxarray13_ = mclInitializeDouble(.601);
    _mxarray14_ = mclInitializeDouble(.377);
    _mxarray15_ = mclInitializeDouble(.533);
    _mxarray16_ = mclInitializeDouble(2.0);
    _mxarray17_ = mclInitializeDouble(.485);
    _mxarray18_ = mclInitializeDouble(.574);
    _mxarray19_ = mclInitializeDouble(.116);
    _mxarray20_ = mclInitializeDouble(.539);
    _mxarray21_ = mclInitializeDouble(.618);
    _mxarray22_ = mclInitializeDouble(.62);
    _mxarray23_ = mclInitializeDouble(.164);
    _mxarray24_ = mclInitializeDouble(.575);
    _mxarray25_ = mclInitializeDouble(-.036);
    _mxarray26_ = mclInitializeDouble(.742);
    _mxarray27_ = mclInitializeDouble(-.107);
    _mxarray28_ = mclInitializeDouble(.621);
    _mxarray29_ = mclInitializeDouble(.283);
    _mxarray30_ = mclInitializeDouble(.727);
    _mxarray31_ = mclInitializeDouble(.019);
    _mxarray32_ = mclInitializeDouble(.628);
    _mxarray33_ = mclInitializeDouble(50.0);
    _mxarray34_ = mclInitializeDouble(250.0);
    _mxarray35_ = mclInitializeDouble(.6);
    _mxarray36_ = mclInitializeDouble(.007359999999999999);
    _mxarray37_ = mclInitializeDouble(.0049);
}

void TerminateModule_windforceonvessel(void) {
    mxDestroyArray(_mxarray37_);
    mxDestroyArray(_mxarray36_);
    mxDestroyArray(_mxarray35_);
    mxDestroyArray(_mxarray34_);
    mxDestroyArray(_mxarray33_);
    mxDestroyArray(_mxarray32_);
    mxDestroyArray(_mxarray31_);
    mxDestroyArray(_mxarray30_);
    mxDestroyArray(_mxarray29_);
    mxDestroyArray(_mxarray28_);
    mxDestroyArray(_mxarray27_);
    mxDestroyArray(_mxarray26_);
    mxDestroyArray(_mxarray25_);
    mxDestroyArray(_mxarray24_);
    mxDestroyArray(_mxarray23_);
    mxDestroyArray(_mxarray22_);
    mxDestroyArray(_mxarray21_);
    mxDestroyArray(_mxarray20_);
    mxDestroyArray(_mxarray19_);
    mxDestroyArray(_mxarray18_);
    mxDestroyArray(_mxarray17_);
    mxDestroyArray(_mxarray16_);
    mxDestroyArray(_mxarray15_);
    mxDestroyArray(_mxarray14_);
    mxDestroyArray(_mxarray13_);
    mxDestroyArray(_mxarray12_);
    mxDestroyArray(_mxarray11_);
    mxDestroyArray(_mxarray10_);
    mxDestroyArray(_mxarray9_);
    mxDestroyArray(_mxarray8_);
    mxDestroyArray(_mxarray7_);
    mxDestroyArray(_mxarray6_);
    mxDestroyArray(_mxarray5_);
    mxDestroyArray(_mxarray3_);
    mxDestroyArray(_mxarray2_);
    mxDestroyArray(_mxarray0_);
}

static mxArray * Mwindforceonvessel(int nargout_,
                                    mxArray * WinForceInput,
                                    mxArray * VesData);

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

/*
 * The function "mlfWindforceonvessel" contains the normal interface for the
 * "windforceonvessel" M-function from file
 * "c:\matlab6p5\work\vesselload\windforceonvessel.m" (lines 1-66). This
 * function processes any input arguments and passes them to the implementation
 * version of the function, appearing above.
 */
mxArray * mlfWindforceonvessel(mxArray * WinForceInput, mxArray * VesData) {
    int nargout = 1;
    mxArray * WinForceOutput = NULL;
    mlfEnterNewContext(0, 2, WinForceInput, VesData);
    WinForceOutput = Mwindforceonvessel(nargout, WinForceInput, VesData);
    mlfRestorePreviousContext(0, 2, WinForceInput, VesData);
    return mlfReturnValue(WinForceOutput);
}

/*
 * The function "mlxWindforceonvessel" contains the feval interface for the
 * "windforceonvessel" M-function from file
 * "c:\matlab6p5\work\vesselload\windforceonvessel.m" (lines 1-66). The feval
 * function calls the implementation version of windforceonvessel through this
 * function. This function processes any input arguments and passes them to the
 * implementation version of the function, appearing above.
 */
void mlxWindforceonvessel(int nlhs,
                          mxArray * plhs[],
                          int nrhs,
                          mxArray * prhs[]) {
    mxArray * mprhs[2];
    mxArray * mplhs[1];
    int i;
    if (nlhs > 1) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: windforceonvessel Line: 1 Colu"
            "mn: 1 The function \"windforceonvessel\" was called "
            "with more than the declared number of outputs (1)."),
          NULL);
    }
    if (nrhs > 2) {
        mlfError(
          mxCreateString(
            "Run-time Error: File: windforceonvessel Line: 1 Colu"
            "mn: 1 The function \"windforceonvessel\" was called "
            "with more than the declared number of inputs (2)."),
          NULL);
    }
    for (i = 0; i < 1; ++i) {
        mplhs[i] = NULL;
    }
    for (i = 0; i < 2 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 2; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 2, mprhs[0], mprhs[1]);
    mplhs[0] = Mwindforceonvessel(nlhs, mprhs[0], mprhs[1]);
    mlfRestorePreviousContext(0, 2, mprhs[0], mprhs[1]);
    plhs[0] = mplhs[0];
}

/*
 * The function "Mwindforceonvessel" is the implementation version of the
 * "windforceonvessel" M-function from file
 * "c:\matlab6p5\work\vesselload\windforceonvessel.m" (lines 1-66). 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 WinForceOutput=WindLoadOnVessel(WinForceInput,VesData)
 */
static mxArray * Mwindforceonvessel(int nargout_,
                                    mxArray * WinForceInput,
                                    mxArray * VesData) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(
          &_local_function_table_windforceonvessel);
    mxArray * WinForceOutput = NULL;
    mxArray * Fywin = NULL;
    mxArray * Fxwin = NULL;
    mxArray * Cwinpy = NULL;
    mxArray * Cwinpx = NULL;
    mxArray * Aywin = NULL;
    mxArray * Axwin = NULL;
    mxArray * i = NULL;
    mxArray * Tab10_2_3 = NULL;
    mxArray * L = NULL;
    mxArray * B = NULL;
    mxArray * DW = NULL;
    mxArray * PerVesData = NULL;
    mxArray * Vwin = NULL;
    mxArray * VesLoadCon = NULL;
    mxArray * VesNo = NULL;
    mclCopyArray(&WinForceInput);
    mclCopyArray(&VesData);
    /*
     * VesNo=WinForceInput(1);
     */
    mlfAssign(
      &VesNo, mclIntArrayRef1(mclVa(WinForceInput, "WinForceInput"), 1));
    /*
     * VesLoadCon=[1 2 3];
     */
    mlfAssign(&VesLoadCon, _mxarray0_);
    /*
     * Vwin=WinForceInput(2);
     */
    mlfAssign(&Vwin, mclIntArrayRef1(mclVa(WinForceInput, "WinForceInput"), 2));
    /*
     * PerVesData=VesData(find(VesData(:,1)==VesNo),:)%设计船型数据PerVesData，从船型数据VesData中查出相应的行。
     */
    mlfAssign(
      &PerVesData,
      mclArrayRef2(
        mclVa(VesData, "VesData"),
        mlfFind(
          NULL,
          NULL,
          mclEq(
            mclArrayRef2(
              mclVa(VesData, "VesData"), mlfCreateColonIndex(), _mxarray2_),
            mclVv(VesNo, "VesNo"))),
        mlfCreateColonIndex()));
    mclPrintArray(mclVv(PerVesData, "PerVesData"), "PerVesData");
    /*
     * DW=PerVesData(8)%查载重量DW，位于设计船型数据第8列。
     */
    mlfAssign(&DW, mclIntArrayRef1(mclVv(PerVesData, "PerVesData"), 8));
    mclPrintArray(mclVv(DW, "DW"), "DW");
    /*
     * B=PerVesData(3)
     */
    mlfAssign(&B, mclIntArrayRef1(mclVv(PerVesData, "PerVesData"), 3));
    mclPrintArray(mclVv(B, "B"), "B");
    /*
     * L=PerVesData(2)
     */
    mlfAssign(&L, mclIntArrayRef1(mclVv(PerVesData, "PerVesData"), 2));
    mclPrintArray(mclVv(L, "L"), "L");
    /*
     * 
     * Tab10_2_3=[50 100 200 250;1 0.9 0.7 0.6]
     */
    mlfAssign(&Tab10_2_3, _mxarray3_);