mat_feat.cpp

《精通Matlab6.5版》张志勇等编著

//
// MATLAB Compiler: 2.2
// Date: Tue Jun 25 12:44:31 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" "maindet" "mat_feat"
// "my_det" 
//
#include "mat_feat.hpp"
#include "libmatlbm.hpp"
#include "libmmfile.hpp"

static mxChar _array1_[134] = { 'R', 'u', 'n', '-', 't', 'i', 'm', 'e', ' ',
                                'E', 'r', 'r', 'o', 'r', ':', ' ', 'F', 'i',
                                'l', 'e', ':', ' ', 'm', 'a', 't', '_', 'f',
                                'e', 'a', 't', ' ', 'L', 'i', 'n', 'e', ':',
                                ' ', '1', ' ', 'C', 'o', 'l', 'u', 'm', 'n',
                                ':', ' ', '1', ' ', 'T', 'h', 'e', ' ', 'f',
                                'u', 'n', 'c', 't', 'i', 'o', 'n', ' ', '"',
                                'm', 'a', 't', '_', 'f', 'e', 'a', 't', '"',
                                ' ', '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(134, _array1_);

static mxChar _array3_[133] = { 'R', 'u', 'n', '-', 't', 'i', 'm', 'e', ' ',
                                'E', 'r', 'r', 'o', 'r', ':', ' ', 'F', 'i',
                                'l', 'e', ':', ' ', 'm', 'a', 't', '_', 'f',
                                'e', 'a', 't', ' ', 'L', 'i', 'n', 'e', ':',
                                ' ', '1', ' ', 'C', 'o', 'l', 'u', 'm', 'n',
                                ':', ' ', '1', ' ', 'T', 'h', 'e', ' ', 'f',
                                'u', 'n', 'c', 't', 'i', 'o', 'n', ' ', '"',
                                'm', 'a', 't', '_', 'f', 'e', 'a', 't', '"',
                                ' ', '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', ' ', '(', '1', ')', '.' };
static mwArray _mxarray2_ = mclInitializeString(133, _array3_);

static mxChar _array5_[5] = { 0xb1bb, 0xb7d6, 0xcef6, 0xbed8, 0xd5f3 };
static mwArray _mxarray4_ = mclInitializeString(5, _array5_);
static mwArray _mxarray6_ = mclInitializeDouble(4.0);
static mwArray _mxarray7_ = mclInitializeDouble(8.0);
static mwArray _mxarray8_ = mclInitializeDouble(2.0);

static mxChar _array10_[6] = { 'm', 'y', '_', 'd', 'e', 't' };
static mwArray _mxarray9_ = mclInitializeString(6, _array10_);

static mxChar _array12_[13] = { 0xbed8, 0xd5f3, ' ', 'A', ' ', 0xb5c4, 0xd0d0,
                                0xc1d0, 0xcabd, 0xd6b5, ' ', '=', ' ' };
static mwArray _mxarray11_ = mclInitializeString(13, _array12_);

static mxChar _array14_[4] = { 'r', 'a', 'n', 'k' };
static mwArray _mxarray13_ = mclInitializeString(4, _array14_);

static mxChar _array16_[10] = { 0xbed8, 0xd5f3, ' ', 'A', ' ',
                                0xb5c4, 0xd6c8, ' ', '=', ' ' };
static mwArray _mxarray15_ = mclInitializeString(10, _array16_);

static mxChar _array18_[4] = { 'n', 'o', 'r', 'm' };
static mwArray _mxarray17_ = mclInitializeString(4, _array18_);

static mxChar _array20_[13] = { 0xbed8, 0xd5f3, ' ', 'A', ' ', 0xb5c4,
                                '2', '-', 0xb7b6, 0xcafd, ' ', '=', ' ' };
static mwArray _mxarray19_ = mclInitializeString(13, _array20_);

static mxChar _array22_[4] = { 'c', 'o', 'n', 'd' };
static mwArray _mxarray21_ = mclInitializeString(4, _array22_);

static mxChar _array24_[12] = { 0xbed8, 0xd5f3, ' ', 'A', ' ', 0xb5c4,
                                0xccf5, 0xbcfe, 0xcafd, ' ', '=', ' ' };
static mwArray _mxarray23_ = mclInitializeString(12, _array24_);

static mxChar _array26_[3] = { 'e', 'i', 'g' };
static mwArray _mxarray25_ = mclInitializeString(3, _array26_);
static mwArray _mxarray27_ = mclInitializeDouble(5.0);

static mxChar _array29_[12] = { 0xbed8, 0xd5f3, ' ', 'A', ' ', 0xb5c4,
                                0xccd8, 0xd5f7, 0xd6b5, ' ', '=', ' ' };
static mwArray _mxarray28_ = mclInitializeString(12, _array29_);

static mxChar _array31_[3] = { 's', 'v', 'd' };
static mwArray _mxarray30_ = mclInitializeString(3, _array31_);

static mxChar _array33_[12] = { 0xbed8, 0xd5f3, ' ', 'A', ' ', 0xb5c4,
                                0xc6e6, 0xd2ec, 0xd6b5, ' ', '=', ' ' };
static mwArray _mxarray32_ = mclInitializeString(12, _array33_);

static mxChar _array35_[28] = { 0xc4fa, 0xcae4, 0xc8eb, 0xb5c4, 0xd6b8, 0xc1ee,
                                0xa3ac, 0xbbf2, 0xd5df, 0xb2bb, 0xcac7, 0xb1be,
                                0xbaaf, 0xcafd, 0xcec4, 0xbcfe, 0xcbf9, 0xc4dc,
                                0xbde2, 0xbef6, 0xb5c4, 0xa3ac, 0xbbf2, 0xcac7,
                                0xb4ed, 0xcef3, 0xb5c4, 0xa3a1 };
static mwArray _mxarray34_ = mclInitializeString(28, _array35_);

void InitializeModule_mat_feat() {
}

void TerminateModule_mat_feat() {
}

static void Mmat_feat(mwArray f_name);

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

//
// The function "mat_feat" contains the normal interface for the "mat_feat"
// M-function from file "D:\mywork\mat_feat.m" (lines 1-25). This function
// processes any input arguments and passes them to the implementation version
// of the function, appearing above.
//
void mat_feat(mwArray f_name) {
    Mmat_feat(f_name);
}

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

//
// The function "Mmat_feat" is the implementation version of the "mat_feat"
// M-function from file "D:\mywork\mat_feat.m" (lines 1-25). 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 mat_feat(f_name)													%<1>
//
static void Mmat_feat(mwArray f_name) {
    mwLocalFunctionTable save_local_function_table_
      (&_local_function_table_mat_feat);
    mwArray d(mclGetUninitializedArray());
    mwArray ff_name(mclGetUninitializedArray());
    mwArray n(mclGetUninitializedArray());
    mwArray N(mclGetUninitializedArray());
    mwArray A(mclGetUninitializedArray());
    mwArray ans(mclGetUninitializedArray());
    //
    // %f_name='eig';                      %在例11.6.3.4-3用到
    // disp('被分析矩阵')															%<2>
    //
    disp(_mxarray4_);
    //
    // A=magic(4)							%给定的被分析矩阵
    //
    A = magic(_mxarray6_);
    mwVsv(A, "A").Print("A");
    //
    // N=8;								%为字符串比较而设的字符串长度 8 。
    //
    N = _mxarray7_;
    //
    // n=size(f_name,2);					%测量输入字符串的长度
    //
    n = size(mwValueVarargout(), mwVa(f_name, "f_name"), _mxarray8_);
    //
    // ff_name=[f_name blanks(N-n)];	%给输入字符串补充空字符，使长度为8。
    //
    ff_name
      = horzcat(
          mwVarargin(
            mwVa(f_name, "f_name"),
            mwVe(blanks(mwVv(N, "N") - mwVv(n, "n")))));
    //
    // if ff_name==['my_det' blanks(2)]
    //
    if (mclEqBool(
          mwVv(ff_name, "ff_name"),
          horzcat(mwVarargin(_mxarray9_, mwVe(blanks(_mxarray8_)))))) {
        //
        // disp('矩阵 A 的行列式值 = ')
        //
        disp(_mxarray11_);
    //
    // elseif ff_name==['rank' blanks(4)]
    //
    } else if (mclEqBool(
                 mwVv(ff_name, "ff_name"),
                 horzcat(mwVarargin(_mxarray13_, mwVe(blanks(_mxarray6_)))))) {
        //
        // disp('矩阵 A 的秩 = ')
        //
        disp(_mxarray15_);
    //
    // elseif ff_name==['norm' blanks(4)]
    //
    } else if (mclEqBool(
                 mwVv(ff_name, "ff_name"),
                 horzcat(mwVarargin(_mxarray17_, mwVe(blanks(_mxarray6_)))))) {
        //
        // disp('矩阵 A 的2-范数 = ')
        //
        disp(_mxarray19_);
    //
    // elseif ff_name==['cond' blanks(4)]
    //
    } else if (mclEqBool(
                 mwVv(ff_name, "ff_name"),
                 horzcat(mwVarargin(_mxarray21_, mwVe(blanks(_mxarray6_)))))) {
        //
        // disp('矩阵 A 的条件数 = ')
        //
        disp(_mxarray23_);
    //
    // elseif ff_name==['eig' blanks(5)]
    //
    } else if (mclEqBool(
                 mwVv(ff_name, "ff_name"),
                 horzcat(mwVarargin(_mxarray25_, mwVe(blanks(_mxarray27_)))))) {
        //
        // disp('矩阵 A 的特征值 = ')
        //
        disp(_mxarray28_);
    //
    // elseif ff_name==['svd' blanks(5)]
    //
    } else if (mclEqBool(
                 mwVv(ff_name, "ff_name"),
                 horzcat(mwVarargin(_mxarray30_, mwVe(blanks(_mxarray27_)))))) {
        //
        // disp('矩阵 A 的奇异值 = ')
        //
        disp(_mxarray32_);
    //
    // else
    //
    } else {
        //
        // disp('您输入的指令，或者不是本函数文件所能解决的，或是错误的！')
        //
        disp(_mxarray34_);
    //
    // end
    //
    }
    //
    // d=feval(f_name,A);
    //
    d
      = feval(
          mwValueVarargout(),
          mwVarargin(mwVa(f_name, "f_name"), mwVv(A, "A")));
    //
    // disp(d)
    //
    disp(mwVv(d, "d"));
}