exm110633_1.cpp

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

//
// MATLAB Compiler: 2.2
// Date: Tue Jun 25 10:54:11 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" "sglcpp" "-p" "-W"
// "main" "-L" "Cpp" "-t" "-T" "link:exe" "-h" "libmmfile.mlib" "-W" "mainhg"
// "libmwsglm.mlib" "exm110633_1" 
//
#include "exm110633_1.hpp"
#include "comet3.hpp"
#include "libmatlbm.hpp"
#include "libmmfile.hpp"
#include "shading.hpp"
#include "shg.hpp"
#include "sphere.hpp"
#include "surf.hpp"

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 mwArray _mxarray0_ = mclInitializeString(140, _array1_);

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 mwArray _mxarray2_ = mclInitializeString(139, _array3_);
static mwArray _mxarray4_ = mclInitializeDouble(1.0);
static mwArray _mxarray5_ = mclInitializeDouble(12.0);
static mwArray _mxarray6_ = mclInitializeDouble(9.0);
static mwArray _mxarray7_ = mclInitializeDouble(6.283185307179586);
static mwArray _mxarray8_ = mclInitializeDouble(5.0);
static mwArray _mxarray9_ = mclInitializeDouble(.031415926535897934);
static mwArray _mxarray10_ = mclInitializeDouble(0.0);
static mwArray _mxarray11_ = mclInitializeDouble(2.0);
static mwArray _mxarray12_ = mclInitializeDouble(.2181661564992912);
static mwArray _mxarray13_ = mclInitializeDouble(20.0);

static mxChar _array15_[1] = { 'g' };
static mwArray _mxarray14_ = mclInitializeString(1, _array15_);
static mwArray _mxarray16_ = mclInitializeDouble(30.0);

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

static mxChar _array20_[6] = { 'i', 'n', 't', 'e', 'r', 'p' };
static mwArray _mxarray19_ = mclInitializeString(6, _array20_);
static mwArray _mxarray21_ = mclInitializeDouble(-18.0);
static mwArray _mxarray22_ = mclInitializeDouble(6.0);
static mwArray _mxarray23_ = mclInitializeDouble(-12.0);
static mwArray _mxarray24_ = mclInitializeDouble(-6.0);

static double _array26_[2] = { 117.0, 37.0 };
static mwArray _mxarray25_ = mclInitializeDoubleVector(1, 2, _array26_);

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 mwArray _mxarray27_ = mclInitializeString(69, _array28_);
static mwArray _mxarray29_ = mclInitializeDouble(.1);

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

void InitializeModule_exm110633_1() {
}

void TerminateModule_exm110633_1() {
}

static void Mexm110633_1();

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

//
// The function "exm110633_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 exm110633_1() {
    Mexm110633_1();
}

//
// 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[]) {
    MW_BEGIN_MLX();
    {
        if (nlhs > 0) {
            error(_mxarray0_);
        }
        if (nrhs > 0) {
            error(_mxarray2_);
        }
        Mexm110633_1();
    }
    MW_END_MLX();
}

//
// 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() {
    mwLocalFunctionTable save_local_function_table_
      (&_local_function_table_exm110633_1);
    mwArray p(mclGetUninitializedArray());
    mwArray z2(mclGetUninitializedArray());
    mwArray z1(mclGetUninitializedArray());
    mwArray y2(mclGetUninitializedArray());
    mwArray y1(mclGetUninitializedArray());
    mwArray x2(mclGetUninitializedArray());
    mwArray x1(mclGetUninitializedArray());
    mwArray Z(mclGetUninitializedArray());
    mwArray Y(mclGetUninitializedArray());
    mwArray X(mclGetUninitializedArray());
    mwArray z(mclGetUninitializedArray());
    mwArray y(mclGetUninitializedArray());
    mwArray x(mclGetUninitializedArray());
    mwArray E(mclGetUninitializedArray());
    mwArray th(mclGetUninitializedArray());
    mwArray f(mclGetUninitializedArray());
    mwArray t(mclGetUninitializedArray());
    mwArray dt(mclGetUninitializedArray());
    mwArray T(mclGetUninitializedArray());
    mwArray T0(mclGetUninitializedArray());
    mwArray b(mclGetUninitializedArray());
    mwArray a(mclGetUninitializedArray());
    mwArray R0(mclGetUninitializedArray());
    mwArray ans(mclGetUninitializedArray());
    //
    // shg;R0=1;								
    //
    shg();
    R0 = _mxarray4_;
    //
    // a=12*R0;b=9*R0;T0=2*pi;							
    //
    a = _mxarray5_ * mwVv(R0, "R0");
    b = _mxarray6_ * mwVv(R0, "R0");
    T0 = _mxarray7_;
    //
    // T=5*T0;dt=pi/100;t=[0:dt:T]';
    //
    T = _mxarray8_ * mwVv(T0, "T0");
    dt = _mxarray9_;
    t = ctranspose(colon(_mxarray10_, mwVv(dt, "dt"), mwVv(T, "T")));
    //
    // f=sqrt(a^2-b^2);							
    //
    f = sqrt((mwVv(a, "a") ^ _mxarray11_) - (mwVv(b, "b") ^ _mxarray11_));
    //
    // th=12.5*pi/180;										
    //
    th = _mxarray12_;
    //
    // E=exp(-t/20);											
    //
    E = exp(- mwVv(t, "t") / _mxarray13_);
    //
    // x=E.*(a*cos(t)-f);y=E.*(b*cos(th)*sin(t));z=E.*(b*sin(th)*sin(t));
    //
    x
      = times(
          mwVv(E, "E"), mwVv(a, "a") * mwVe(cos(mwVv(t, "t"))) - mwVv(f, "f"));
    y
      = times(
          mwVv(E, "E"),
          mwVv(b, "b") * mwVe(cos(mwVv(th, "th"))) * mwVe(sin(mwVv(t, "t"))));
    z
      = times(
          mwVv(E, "E"),
          mwVv(b, "b") * mwVe(sin(mwVv(th, "th"))) * mwVe(sin(mwVv(t, "t"))));
    //
    // plot3(x,y,z,'g')										
    //
    ans.EqPrintAns(
      Nplot3(
        0, mwVarargin(mwVv(x, "x"), mwVv(y, "y"), mwVv(z, "z"), _mxarray14_)));
    //
    // [X,Y,Z]=sphere(30);X=R0*X;Y=R0*Y;Z=R0*Z;		
    //
    X = Nsphere(3, &Y, &Z, _mxarray16_);
    X = mwVv(R0, "R0") * mwVv(X, "X");
    Y = mwVv(R0, "R0") * mwVv(Y, "Y");
    Z = mwVv(R0, "R0") * mwVv(Z, "Z");
    //
    // grid on,hold on,surf(X,Y,Z),shading  interp	
    //
    grid(_mxarray17_);
    hold(_mxarray17_);
    ans.EqPrintAns(
      Nsurf(0, mwVarargin(mwVv(X, "X"), mwVv(Y, "Y"), mwVv(Z, "Z"))));
    shading(_mxarray19_);
    //
    // x1=-18*R0;x2=6*R0;y1=-12*R0;y2=12*R0;z1=-6*R0;z2=6*R0;
    //
    x1 = _mxarray21_ * mwVv(R0, "R0");
    x2 = _mxarray22_ * mwVv(R0, "R0");
    y1 = _mxarray23_ * mwVv(R0, "R0");
    y2 = _mxarray5_ * mwVv(R0, "R0");
    z1 = _mxarray24_ * mwVv(R0, "R0");
    z2 = _mxarray22_ * mwVv(R0, "R0");
    //
    // axis([x1 x2 y1 y2 z1 z2])						
    //
    ans.EqPrintAns(
      axis(
        mwVarargin(
          horzcat(
            mwVarargin(
              mwVv(x1, "x1"),
              mwVv(x2, "x2"),
              mwVv(y1, "y1"),
              mwVv(y2, "y2"),
              mwVv(z1, "z1"),
              mwVv(z2, "z2"))))));
    //
    // view([117 37]),
    //
    ans.EqPrintAns(Nview(0, NULL, _mxarray25_));
    //
    // p=input('Please input the comet'' length coeffient (the default value is 0.1): ');
    //
    p = input(_mxarray27_);
    //
    // if ~isempty(p),
    //
    if (mclNotBool(mwVe(isempty(mwVv(p, "p"))))) {
        //
        // p=0.1;
        //
        p = _mxarray29_;
    //
    // end
    //
    }
    //
    // comet3(x,y,z,p),hold off	
    //
    comet3(mwVv(x, "x"), mwVv(y, "y"), mwVv(z, "z"), mwVv(p, "p"));
    hold(_mxarray30_);
}