exm110633_1.c

该程序为MATLAB对CDMA系统个部分的仿真

/*
 * MATLAB Compiler: 2.2
 * Date: Tue Jun 25 10:53:59 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" "-B" "sgl" "-m" "-W"
 * "main" "-L" "C" "-t" "-T" "link:exe" "-h" "libmmfile.mlib" "-W" "mainhg"
 * "libmwsglm.mlib" "exm110633_1" 
 */
#include "exm110633_1.h"
#include "comet3.h"
#include "libmatlbm.h"
#include "libmmfile.h"
#include "shading.h"
#include "shg.h"
#include "sphere.h"
#include "surf.h"

static mxChar _array1_[140] = { 'R', 'u', 'n', '-', 't', 'i', 'm', 'e', ' ',
                                'E', 'r', 'r', 'o', 'r', ':', ' ', 'F', 'i',
                                'l', 'e', ':', ' ', 'e', 'x', 'm', '1', '1',
                                '0', '6', '3', '3', '_', '1', ' ', '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', '1', '1', '0',
                                '6', '3', '3', '_', '1', '"', ' ', '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 mxArray * _mxarray0_;

static mxChar _array3_[139] = { 'R', 'u', 'n', '-', 't', 'i', 'm', 'e', ' ',
                                'E', 'r', 'r', 'o', 'r', ':', ' ', 'F', 'i',
                                'l', 'e', ':', ' ', 'e', 'x', 'm', '1', '1',
                                '0', '6', '3', '3', '_', '1', ' ', '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', '1', '1', '0',
                                '6', '3', '3', '_', '1', '"', ' ', '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', ' ',
                                '(', '0', ')', '.' };
static mxArray * _mxarray2_;
static mxArray * _mxarray4_;
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 mxChar _array15_[1] = { 'g' };
static mxArray * _mxarray14_;
static mxArray * _mxarray16_;

static mxChar _array18_[2] = { 'o', 'n' };
static mxArray * _mxarray17_;

static mxChar _array20_[6] = { 'i', 'n', 't', 'e', 'r', 'p' };
static mxArray * _mxarray19_;
static mxArray * _mxarray21_;
static mxArray * _mxarray22_;
static mxArray * _mxarray23_;
static mxArray * _mxarray24_;

static double _array26_[2] = { 117.0, 37.0 };
static mxArray * _mxarray25_;

static mxChar _array28_[69] = { 'P', 'l', 'e', 'a', 's', 'e', ' ', 'i', 'n',
                                'p', 'u', 't', ' ', 't', 'h', 'e', ' ', 'c',
                                'o', 'm', 'e', 't', 0x0027, ' ', 'l', 'e',
                                'n', 'g', 't', 'h', ' ', 'c', 'o', 'e', 'f',
                                'f', 'i', 'e', 'n', 't', ' ', '(', 't', 'h',
                                'e', ' ', 'd', 'e', 'f', 'a', 'u', 'l', 't',
                                ' ', 'v', 'a', 'l', 'u', 'e', ' ', 'i', 's',
                                ' ', '0', '.', '1', ')', ':', ' ' };
static mxArray * _mxarray27_;
static mxArray * _mxarray29_;

static mxChar _array31_[3] = { 'o', 'f', 'f' };
static mxArray * _mxarray30_;

void InitializeModule_exm110633_1(void) {
    _mxarray0_ = mclInitializeString(140, _array1_);
    _mxarray2_ = mclInitializeString(139, _array3_);
    _mxarray4_ = mclInitializeDouble(1.0);
    _mxarray5_ = mclInitializeDouble(12.0);
    _mxarray6_ = mclInitializeDouble(9.0);
    _mxarray7_ = mclInitializeDouble(6.283185307179586);
    _mxarray8_ = mclInitializeDouble(5.0);
    _mxarray9_ = mclInitializeDouble(.031415926535897934);
    _mxarray10_ = mclInitializeDouble(0.0);
    _mxarray11_ = mclInitializeDouble(2.0);
    _mxarray12_ = mclInitializeDouble(.2181661564992912);
    _mxarray13_ = mclInitializeDouble(20.0);
    _mxarray14_ = mclInitializeString(1, _array15_);
    _mxarray16_ = mclInitializeDouble(30.0);
    _mxarray17_ = mclInitializeString(2, _array18_);
    _mxarray19_ = mclInitializeString(6, _array20_);
    _mxarray21_ = mclInitializeDouble(-18.0);
    _mxarray22_ = mclInitializeDouble(6.0);
    _mxarray23_ = mclInitializeDouble(-12.0);
    _mxarray24_ = mclInitializeDouble(-6.0);
    _mxarray25_ = mclInitializeDoubleVector(1, 2, _array26_);
    _mxarray27_ = mclInitializeString(69, _array28_);
    _mxarray29_ = mclInitializeDouble(.1);
    _mxarray30_ = mclInitializeString(3, _array31_);
}

void TerminateModule_exm110633_1(void) {
    mxDestroyArray(_mxarray30_);
    mxDestroyArray(_mxarray29_);
    mxDestroyArray(_mxarray27_);
    mxDestroyArray(_mxarray25_);
    mxDestroyArray(_mxarray24_);
    mxDestroyArray(_mxarray23_);
    mxDestroyArray(_mxarray22_);
    mxDestroyArray(_mxarray21_);
    mxDestroyArray(_mxarray19_);
    mxDestroyArray(_mxarray17_);
    mxDestroyArray(_mxarray16_);
    mxDestroyArray(_mxarray14_);
    mxDestroyArray(_mxarray13_);
    mxDestroyArray(_mxarray12_);
    mxDestroyArray(_mxarray11_);
    mxDestroyArray(_mxarray10_);
    mxDestroyArray(_mxarray9_);
    mxDestroyArray(_mxarray8_);
    mxDestroyArray(_mxarray7_);
    mxDestroyArray(_mxarray6_);
    mxDestroyArray(_mxarray5_);
    mxDestroyArray(_mxarray4_);
    mxDestroyArray(_mxarray2_);
    mxDestroyArray(_mxarray0_);
}

static void Mexm110633_1(void);

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

/*
 * The function "mlfExm110633_1" contains the normal interface for the
 * "exm110633_1" M-function from file "D:\mywork\exm110633_1.m" (lines 1-20).
 * This function processes any input arguments and passes them to the
 * implementation version of the function, appearing above.
 */
void mlfExm110633_1(void) {
    mlfEnterNewContext(0, 0);
    Mexm110633_1();
    mlfRestorePreviousContext(0, 0);
}

/*
 * The function "mlxExm110633_1" contains the feval interface for the
 * "exm110633_1" M-function from file "D:\mywork\exm110633_1.m" (lines 1-20).
 * The feval function calls the implementation version of exm110633_1 through
 * this function. This function processes any input arguments and passes them
 * to the implementation version of the function, appearing above.
 */
void mlxExm110633_1(int nlhs, mxArray * plhs[], int nrhs, mxArray * prhs[]) {
    if (nlhs > 0) {
        mlfError(_mxarray0_);
    }
    if (nrhs > 0) {
        mlfError(_mxarray2_);
    }
    mlfEnterNewContext(0, 0);
    Mexm110633_1();
    mlfRestorePreviousContext(0, 0);
}

/*
 * The function "Mexm110633_1" is the implementation version of the
 * "exm110633_1" M-function from file "D:\mywork\exm110633_1.m" (lines 1-20).
 * 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 exm110633_1
 */
static void Mexm110633_1(void) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(&_local_function_table_exm110633_1);
    mxArray * p = mclGetUninitializedArray();
    mxArray * z2 = mclGetUninitializedArray();
    mxArray * z1 = mclGetUninitializedArray();
    mxArray * y2 = mclGetUninitializedArray();
    mxArray * y1 = mclGetUninitializedArray();
    mxArray * x2 = mclGetUninitializedArray();
    mxArray * x1 = mclGetUninitializedArray();
    mxArray * Z = mclGetUninitializedArray();
    mxArray * Y = mclGetUninitializedArray();
    mxArray * X = mclGetUninitializedArray();
    mxArray * z = mclGetUninitializedArray();
    mxArray * y = mclGetUninitializedArray();
    mxArray * x = mclGetUninitializedArray();
    mxArray * E = mclGetUninitializedArray();
    mxArray * th = mclGetUninitializedArray();
    mxArray * f = mclGetUninitializedArray();
    mxArray * t = mclGetUninitializedArray();
    mxArray * dt = mclGetUninitializedArray();
    mxArray * T = mclGetUninitializedArray();
    mxArray * T0 = mclGetUninitializedArray();
    mxArray * b = mclGetUninitializedArray();
    mxArray * a = mclGetUninitializedArray();
    mxArray * R0 = mclGetUninitializedArray();
    mxArray * ans = mclGetUninitializedArray();
    /*
     * shg;R0=1;								
     */
    mlfShg();
    mlfAssign(&R0, _mxarray4_);
    /*
     * a=12*R0;b=9*R0;T0=2*pi;							
     */
    mlfAssign(&a, mclMtimes(_mxarray5_, mclVv(R0, "R0")));
    mlfAssign(&b, mclMtimes(_mxarray6_, mclVv(R0, "R0")));
    mlfAssign(&T0, _mxarray7_);
    /*
     * T=5*T0;dt=pi/100;t=[0:dt:T]';
     */
    mlfAssign(&T, mclMtimes(_mxarray8_, mclVv(T0, "T0")));
    mlfAssign(&dt, _mxarray9_);
    mlfAssign(
      &t, mlfCtranspose(mlfColon(_mxarray10_, mclVv(dt, "dt"), mclVv(T, "T"))));
    /*
     * f=sqrt(a^2-b^2);							
     */
    mlfAssign(
      &f,
      mlfSqrt(
        mclMinus(
          mclMpower(mclVv(a, "a"), _mxarray11_),
          mclMpower(mclVv(b, "b"), _mxarray11_))));
    /*
     * th=12.5*pi/180;										
     */
    mlfAssign(&th, _mxarray12_);
    /*
     * E=exp(-t/20);											
     */
    mlfAssign(&E, mlfExp(mclMrdivide(mclUminus(mclVv(t, "t")), _mxarray13_)));
    /*
     * x=E.*(a*cos(t)-f);y=E.*(b*cos(th)*sin(t));z=E.*(b*sin(th)*sin(t));
     */
    mlfAssign(
      &x,
      mclTimes(
        mclVv(E, "E"),
        mclMinus(
          mclMtimes(mclVv(a, "a"), mclVe(mlfCos(mclVv(t, "t")))),
          mclVv(f, "f"))));
    mlfAssign(
      &y,
      mclTimes(
        mclVv(E, "E"),
        mclMtimes(
          mclMtimes(mclVv(b, "b"), mclVe(mlfCos(mclVv(th, "th")))),
          mclVe(mlfSin(mclVv(t, "t"))))));
    mlfAssign(
      &z,
      mclTimes(
        mclVv(E, "E"),
        mclMtimes(
          mclMtimes(mclVv(b, "b"), mclVe(mlfSin(mclVv(th, "th")))),
          mclVe(mlfSin(mclVv(t, "t"))))));
    /*
     * plot3(x,y,z,'g')										
     */
    mclPrintAns(
      &ans,
      mlfNPlot3(
        0, mclVv(x, "x"), mclVv(y, "y"), mclVv(z, "z"), _mxarray14_, NULL));
    /*
     * [X,Y,Z]=sphere(30);X=R0*X;Y=R0*Y;Z=R0*Z;		
     */
    mlfAssign(&X, mlfNSphere(3, &Y, &Z, _mxarray16_));
    mlfAssign(&X, mclMtimes(mclVv(R0, "R0"), mclVv(X, "X")));
    mlfAssign(&Y, mclMtimes(mclVv(R0, "R0"), mclVv(Y, "Y")));
    mlfAssign(&Z, mclMtimes(mclVv(R0, "R0"), mclVv(Z, "Z")));
    /*
     * grid on,hold on,surf(X,Y,Z),shading  interp	
     */
    mlfGrid(_mxarray17_, NULL);
    mlfHold(_mxarray17_);
    mclPrintAns(
      &ans, mlfNSurf(0, mclVv(X, "X"), mclVv(Y, "Y"), mclVv(Z, "Z"), NULL));
    mlfShading(_mxarray19_, NULL);
    /*
     * x1=-18*R0;x2=6*R0;y1=-12*R0;y2=12*R0;z1=-6*R0;z2=6*R0;
     */
    mlfAssign(&x1, mclMtimes(_mxarray21_, mclVv(R0, "R0")));
    mlfAssign(&x2, mclMtimes(_mxarray22_, mclVv(R0, "R0")));
    mlfAssign(&y1, mclMtimes(_mxarray23_, mclVv(R0, "R0")));
    mlfAssign(&y2, mclMtimes(_mxarray5_, mclVv(R0, "R0")));
    mlfAssign(&z1, mclMtimes(_mxarray24_, mclVv(R0, "R0")));
    mlfAssign(&z2, mclMtimes(_mxarray22_, mclVv(R0, "R0")));
    /*
     * axis([x1 x2 y1 y2 z1 z2])						
     */
    mclPrintAns(
      &ans,
      mlfAxis(
        NULL,
        NULL,
        mlfHorzcat(
          mclVv(x1, "x1"),
          mclVv(x2, "x2"),
          mclVv(y1, "y1"),
          mclVv(y2, "y2"),
          mclVv(z1, "z1"),
          mclVv(z2, "z2"),
          NULL),
        NULL));
    /*
     * view([117 37]),
     */
    mclPrintAns(&ans, mlfNView(0, NULL, _mxarray25_, NULL, NULL));
    /*
     * p=input('Please input the comet'' length coeffient (the default value is 0.1): ');
     */
    mlfAssign(&p, mlfInput(_mxarray27_, NULL));
    /*
     * if ~isempty(p),
     */
    if (mclNotBool(mclVe(mlfIsempty(mclVv(p, "p"))))) {
        /*
         * p=0.1;
         */
        mlfAssign(&p, _mxarray29_);
    /*
     * end
     */
    }
    /*
     * comet3(x,y,z,p),hold off	
     */
    mlfComet3(mclVv(x, "x"), mclVv(y, "y"), mclVv(z, "z"), mclVv(p, "p"));
    mlfHold(_mxarray30_);
    mxDestroyArray(ans);
    mxDestroyArray(R0);
    mxDestroyArray(a);
    mxDestroyArray(b);
    mxDestroyArray(T0);
    mxDestroyArray(T);
    mxDestroyArray(dt);
    mxDestroyArray(t);
    mxDestroyArray(f);
    mxDestroyArray(th);
    mxDestroyArray(E);
    mxDestroyArray(x);
    mxDestroyArray(y);
    mxDestroyArray(z);
    mxDestroyArray(X);
    mxDestroyArray(Y);
    mxDestroyArray(Z);
    mxDestroyArray(x1);
    mxDestroyArray(x2);
    mxDestroyArray(y1);
    mxDestroyArray(y2);
    mxDestroyArray(z1);
    mxDestroyArray(z2);
    mxDestroyArray(p);
    mclSetCurrentLocalFunctionTable(save_local_function_table_);
}