exm2_f.c

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

/*
 * MATLAB Compiler: 2.2
 * Date: Tue Jun 25 12:35:15 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" "-m" "-W" "main" "-L"
 * "C" "-t" "-T" "link:exe" "-h" "libmmfile.mlib" "exm2" "exm2_f" 
 */
#include "exm2_f.h"
#include "libmatlbm.h"

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

static mxChar _array3_[129] = { 'R', 'u', 'n', '-', 't', 'i', 'm', 'e', ' ',
                                'E', 'r', 'r', 'o', 'r', ':', ' ', 'F', 'i',
                                'l', 'e', ':', ' ', 'e', 'x', 'm', '2', '_',
                                'f', ' ', 'L', 'i', 'n', 'e', ':', ' ', '1',
                                ' ', 'C', 'o', 'l', 'u', 'm', 'n', ':', ' ',
                                '1', ' ', 'T', 'h', 'e', ' ', 'f', 'u', 'n',
                                'c', 't', 'i', 'o', 'n', ' ', '"', 'e', 'x',
                                'm', '2', '_', 'f', '"', ' ', '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 mxArray * _mxarray2_;

static mxChar _array5_[9] = { 0xcae4, 0xc8eb, 0xbed8, 0xd5f3, 0xd3a6,
                              0xcac7, 0xb7bd, 0xd5f3, 0xa3a1 };
static mxArray * _mxarray4_;
static mxArray * _mxarray6_;
static mxArray * _mxarray7_;
static mxArray * _mxarray8_;

static mxChar _array10_[8] = { 0xbed8, 0xd5f3, 0xcede, 0xb7a8,
                               0xb6d4, 0xbdc7, 0xbbaf, 0xa3a1 };
static mxArray * _mxarray9_;

void InitializeModule_exm2_f(void) {
    _mxarray0_ = mclInitializeString(130, _array1_);
    _mxarray2_ = mclInitializeString(129, _array3_);
    _mxarray4_ = mclInitializeString(9, _array5_);
    _mxarray6_ = mclInitializeDouble(0.0);
    _mxarray7_ = mclInitializeDoubleVector(0, 0, (double *)NULL);
    _mxarray8_ = mclInitializeDouble(1.0);
    _mxarray9_ = mclInitializeString(8, _array10_);
}

void TerminateModule_exm2_f(void) {
    mxDestroyArray(_mxarray9_);
    mxDestroyArray(_mxarray8_);
    mxDestroyArray(_mxarray7_);
    mxDestroyArray(_mxarray6_);
    mxDestroyArray(_mxarray4_);
    mxDestroyArray(_mxarray2_);
    mxDestroyArray(_mxarray0_);
}

static mxArray * Mexm2_f(int nargout_, mxArray * A);

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

/*
 * The function "mlfExm2_f" contains the normal interface for the "exm2_f"
 * M-function from file "D:\mywork\exm2_f.m" (lines 1-22). This function
 * processes any input arguments and passes them to the implementation version
 * of the function, appearing above.
 */
mxArray * mlfExm2_f(mxArray * A) {
    int nargout = 1;
    mxArray * S = mclGetUninitializedArray();
    mlfEnterNewContext(0, 1, A);
    S = Mexm2_f(nargout, A);
    mlfRestorePreviousContext(0, 1, A);
    return mlfReturnValue(S);
}

/*
 * The function "mlxExm2_f" contains the feval interface for the "exm2_f"
 * M-function from file "D:\mywork\exm2_f.m" (lines 1-22). The feval function
 * calls the implementation version of exm2_f through this function. This
 * function processes any input arguments and passes them to the implementation
 * version of the function, appearing above.
 */
void mlxExm2_f(int nlhs, mxArray * plhs[], int nrhs, mxArray * prhs[]) {
    mxArray * mprhs[1];
    mxArray * mplhs[1];
    int i;
    if (nlhs > 1) {
        mlfError(_mxarray0_);
    }
    if (nrhs > 1) {
        mlfError(_mxarray2_);
    }
    for (i = 0; i < 1; ++i) {
        mplhs[i] = mclGetUninitializedArray();
    }
    for (i = 0; i < 1 && i < nrhs; ++i) {
        mprhs[i] = prhs[i];
    }
    for (; i < 1; ++i) {
        mprhs[i] = NULL;
    }
    mlfEnterNewContext(0, 1, mprhs[0]);
    mplhs[0] = Mexm2_f(nlhs, mprhs[0]);
    mlfRestorePreviousContext(0, 1, mprhs[0]);
    plhs[0] = mplhs[0];
}

/*
 * The function "Mexm2_f" is the implementation version of the "exm2_f"
 * M-function from file "D:\mywork\exm2_f.m" (lines 1-22). 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 S=exm2_f(A)
 */
static mxArray * Mexm2_f(int nargout_, mxArray * A) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_exm2_f);
    mxArray * S = mclGetUninitializedArray();
    mxArray * d = mclGetUninitializedArray();
    mxArray * v = mclGetUninitializedArray();
    mxArray * j = mclGetUninitializedArray();
    mxArray * i = mclGetUninitializedArray();
    mxArray * same = mclGetUninitializedArray();
    mxArray * e = mclGetUninitializedArray();
    mxArray * ans = mclGetUninitializedArray();
    mxArray * n = mclGetUninitializedArray();
    mxArray * m = mclGetUninitializedArray();
    mclCopyArray(&A);
    /*
     * [m,n]=size(A);
     */
    mlfSize(mlfVarargout(&m, &n, NULL), mclVa(A, "A"), NULL);
    /*
     * if m~=n
     */
    if (mclNeBool(mclVv(m, "m"), mclVv(n, "n"))) {
        /*
         * error('输入矩阵应是方阵！');
         */
        mlfError(_mxarray4_);
    /*
     * end;
     */
    }
    /*
     * e=eig(A);
     */
    mlfAssign(&e, mlfEig(NULL, mclVa(A, "A"), NULL, NULL));
    /*
     * %检查输入矩阵的特征值是否各异
     * same=0;
     */
    mlfAssign(&same, _mxarray6_);
    /*
     * for i=1:m-1
     */
    {
        int v_ = mclForIntStart(1);
        int e_ = mclForIntEnd(mclMinus(mclVv(m, "m"), _mxarray8_));
        if (v_ > e_) {
            mlfAssign(&i, _mxarray7_);
        } else {
            /*
             * for j=(i+1):m
             * if e(j)==e(i)
             * same=1;
             * end
             * end
             * end
             */
            for (; ; ) {
                int v_0 = mclForIntStart(v_ + 1);
                int e_0 = mclForIntEnd(mclVv(m, "m"));
                if (v_0 > e_0) {
                    mlfAssign(&j, _mxarray7_);
                } else {
                    for (; ; ) {
                        if (mclEqBool(
                              mclVe(mclIntArrayRef1(mclVsv(e, "e"), v_0)),
                              mclVe(mclIntArrayRef1(mclVsv(e, "e"), v_)))) {
                            mlfAssign(&same, _mxarray8_);
                        }
                        if (v_0 == e_0) {
                            break;
                        }
                        ++v_0;
                    }
                    mlfAssign(&j, mlfScalar(v_0));
                }
                if (v_ == e_) {
                    break;
                }
                ++v_;
            }
            mlfAssign(&i, mlfScalar(v_));
        }
    }
    /*
     * % A可以对角化的条件是A具有互异特征值或者A为埃尔米特矩阵。
     * if any(any((A'-A)))&(same==1)
     */
    {
        mxArray * a_
          = mclInitialize(
              mclVe(
                mlfAny(
                  mclVe(
                    mlfAny(
                      mclMinus(mlfCtranspose(mclVa(A, "A")), mclVa(A, "A")),
                      NULL)),
                  NULL)));
        if (mlfTobool(a_)
            && mlfTobool(mclAnd(a_, mclEq(mclVv(same, "same"), _mxarray8_)))) {
            mxDestroyArray(a_);
            /*
             * error('矩阵无法对角化！');
             */
            mlfError(_mxarray9_);
        } else {
            mxDestroyArray(a_);
        }
    /*
     * end
     */
    }
    /*
     * [v,d]=eig(A);
     */
    mlfAssign(&v, mlfEig(&d, mclVa(A, "A"), NULL, NULL));
    /*
     * S=v;
     */
    mlfAssign(&S, mclVsv(v, "v"));
    mclValidateOutput(S, 1, nargout_, "S", "exm2_f");
    mxDestroyArray(m);
    mxDestroyArray(n);
    mxDestroyArray(ans);
    mxDestroyArray(e);
    mxDestroyArray(same);
    mxDestroyArray(i);
    mxDestroyArray(j);
    mxDestroyArray(v);
    mxDestroyArray(d);
    mxDestroyArray(A);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
    return S;
}