bitandpoweralloct2.c

好东西

/*
 * MATLAB Compiler: 3.0
 * Date: Fri Mar 24 11:31:36 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" "-W" "main" "-L"
 * "C" "-t" "-T" "link:exe" "-h" "libmmfile.mlib"
 * "adptive_bitpow_allocate_systems" 
 */
#include "bitandpoweralloct2.h"
#include "libmatlbm.h"
#include "libmmfile.h"
static mxArray * _mxarray0_;
static mxArray * _mxarray1_;
static mxArray * _mxarray2_;
static mxArray * _mxarray3_;
static mxArray * _mxarray4_;
static mxArray * _mxarray5_;
static mxArray * _mxarray6_;
static mxArray * _mxarray7_;
static mxArray * _mxarray8_;
static mxArray * _mxarray9_;

void InitializeModule_bitandpoweralloct2(void) {
    _mxarray0_ = mclInitializeDouble(1.0);
    _mxarray1_ = mclInitializeDouble(0.0);
    _mxarray2_ = mclInitializeDoubleVector(0, 0, (double *)NULL);
    _mxarray3_ = mclInitializeDouble(2.0);
    _mxarray4_ = mclInitializeDouble(10.0);
    _mxarray5_ = mclInitializeDouble(1.6);
    _mxarray6_ = mclInitializeDouble(5.0);
    _mxarray7_ = mclInitializeDouble(3.0);
    _mxarray8_ = mclInitializeDouble(4.0);
    _mxarray9_ = mclInitializeDouble(6.0);
}

void TerminateModule_bitandpoweralloct2(void) {
    mxDestroyArray(_mxarray9_);
    mxDestroyArray(_mxarray8_);
    mxDestroyArray(_mxarray7_);
    mxDestroyArray(_mxarray6_);
    mxDestroyArray(_mxarray5_);
    mxDestroyArray(_mxarray4_);
    mxDestroyArray(_mxarray3_);
    mxDestroyArray(_mxarray2_);
    mxDestroyArray(_mxarray1_);
    mxDestroyArray(_mxarray0_);
}

static mxArray * Mbitandpoweralloct2(mxArray * * Cbitvector,
                                     mxArray * * gama,
                                     int nargout_,
                                     mxArray * N_carrier,
                                     mxArray * groupnumber,
                                     mxArray * Hk,
                                     mxArray * SNR,
                                     mxArray * Pe,
                                     mxArray * N_ofdm);

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

/*
 * The function "mlfBitandpoweralloct2" contains the normal interface for the
 * "bitandpoweralloct2" M-function from file
 * "c:\matlab6p5\work\adptive_ofdm\adptive_ofdm\bitandpoweralloct2.m" (lines
 * 1-120). This function processes any input arguments and passes them to the
 * implementation version of the function, appearing above.
 */
mxArray * mlfBitandpoweralloct2(mxArray * * Cbitvector,
                                mxArray * * gama,
                                mxArray * N_carrier,
                                mxArray * groupnumber,
                                mxArray * Hk,
                                mxArray * SNR,
                                mxArray * Pe,
                                mxArray * N_ofdm) {
    int nargout = 1;
    mxArray * poweralloctvector = NULL;
    mxArray * Cbitvector__ = NULL;
    mxArray * gama__ = NULL;
    mlfEnterNewContext(
      2, 6, Cbitvector, gama, N_carrier, groupnumber, Hk, SNR, Pe, N_ofdm);
    if (Cbitvector != NULL) {
        ++nargout;
    }
    if (gama != NULL) {
        ++nargout;
    }
    poweralloctvector
      = Mbitandpoweralloct2(
          &Cbitvector__,
          &gama__,
          nargout,
          N_carrier,
          groupnumber,
          Hk,
          SNR,
          Pe,
          N_ofdm);
    mlfRestorePreviousContext(
      2, 6, Cbitvector, gama, N_carrier, groupnumber, Hk, SNR, Pe, N_ofdm);
    if (Cbitvector != NULL) {
        mclCopyOutputArg(Cbitvector, Cbitvector__);
    } else {
        mxDestroyArray(Cbitvector__);
    }
    if (gama != NULL) {
        mclCopyOutputArg(gama, gama__);
    } else {
        mxDestroyArray(gama__);
    }
    return mlfReturnValue(poweralloctvector);
}

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

/*
 * The function "Mbitandpoweralloct2" is the implementation version of the
 * "bitandpoweralloct2" M-function from file
 * "c:\matlab6p5\work\adptive_ofdm\adptive_ofdm\bitandpoweralloct2.m" (lines
 * 1-120). 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.
 */
/*
 * % funcion：
 * % 功率和比特的预分配
 * %
 * function [poweralloctvector,Cbitvector,gama]=bitandpoweralloct2(N_carrier,groupnumber,Hk,SNR,Pe,N_ofdm)
 */
static mxArray * Mbitandpoweralloct2(mxArray * * Cbitvector,
                                     mxArray * * gama,
                                     int nargout_,
                                     mxArray * N_carrier,
                                     mxArray * groupnumber,
                                     mxArray * Hk,
                                     mxArray * SNR,
                                     mxArray * Pe,
                                     mxArray * N_ofdm) {
    mexLocalFunctionTable save_local_function_table_
      = mclSetCurrentLocalFunctionTable(
          &_local_function_table_bitandpoweralloct2);
    mxArray * poweralloctvector = NULL;
    mxArray * sumsum1 = NULL;
    mxArray * t = NULL;
    mxArray * poweralloctvector1 = NULL;
    mxArray * s = NULL;
    mxArray * sum1 = NULL;
    mxArray * q = NULL;
    mxArray * Cbitvector1 = NULL;
    mxArray * gama_sum = NULL;
    mxArray * p = NULL;
    mxArray * right = NULL;
    mxArray * k = NULL;
    mxArray * i = NULL;
    mxArray * Saverage = NULL;
    mxArray * pow = NULL;
    mxArray * An = NULL;
    mxArray * flag = NULL;
    mxArray * gamag = NULL;
    mxArray * N = NULL;
    mxArray * K = NULL;
    mclCopyArray(&N_carrier);
    mclCopyArray(&groupnumber);
    mclCopyArray(&Hk);
    mclCopyArray(&SNR);
    mclCopyArray(&Pe);
    mclCopyArray(&N_ofdm);
    /*
     * % 初始化
     * K=groupnumber;
     */
    mlfAssign(&K, mclVa(groupnumber, "groupnumber"));
    /*
     * N=N_carrier;
     */
    mlfAssign(&N, mclVa(N_carrier, "N_carrier"));
    /*
     * %HHk=zeros(K,N_ofdm);                            % 每子信道组的平均信道响应
     * gamag=zeros(K,N_ofdm);                          % gama值
     */
    mlfAssign(&gamag, mlfZeros(mclVv(K, "K"), mclVa(N_ofdm, "N_ofdm"), NULL));
    /*
     * flag=zeros(K,N_ofdm);                           % 子信道组分配标志：0   不分配   1  分配 
     */
    mlfAssign(&flag, mlfZeros(mclVv(K, "K"), mclVa(N_ofdm, "N_ofdm"), NULL));
    /*
     * poweralloctvector=zeros(K,N_ofdm);              % 子信道组分配功率
     */
    mlfAssign(
      &poweralloctvector,
      mlfZeros(mclVv(K, "K"), mclVa(N_ofdm, "N_ofdm"), NULL));
    /*
     * Cbitvector=zeros(K,N_ofdm);                     % 子信道组比特分配
     */
    mlfAssign(
      Cbitvector, mlfZeros(mclVv(K, "K"), mclVa(N_ofdm, "N_ofdm"), NULL));
    /*
     * An=1;                                           % 放大倍数
     */
    mlfAssign(&An, _mxarray0_);
    /*
     * pow=0;                                          % 总功率
     */
    mlfAssign(&pow, _mxarray1_);
    /*
     * Saverage=1;
     */
    mlfAssign(&Saverage, _mxarray0_);
    /*
     * 
     * for i=1:N_ofdm
     */
    {
        int v_ = mclForIntStart(1);
        int e_ = mclForIntEnd(mclVa(N_ofdm, "N_ofdm"));
        if (v_ > e_) {
            mlfAssign(&i, _mxarray2_);
        } else {
            /*
             * for k=1:K
             * %       HHk(k,i)=sum(Hk((N/K)*(k-1)+1:(N/K)*k,i))/(N/K);      %将N/K内的子载波信道响应求平均
             * %         gamag(k,i)=(abs(HHk(k,i))).^2*10^log10(SNR); 
             * % 
             * %     gamag(k,i)=An^2*(abs(HHk(k,i))).^2*SNR; 
             * gamag(k,i)=sum((abs(Hk((N/K)*(k-1)+1:(N/K)*k,i)).^2))/(N/K)*SNR; 
             * 
             * end
             * end
             */
            for (; ; ) {
                int v_0 = mclForIntStart(1);
                int e_0 = mclForIntEnd(mclVv(K, "K"));
                if (v_0 > e_0) {
                    mlfAssign(&k, _mxarray2_);
                } else {
                    for (; ; ) {
                        mclIntArrayAssign2(
                          &gamag,
                          mclMtimes(
                            mclMrdivide(
                              mlfSum(
                                mlfPower(
                                  mlfAbs(
                                    mclArrayRef2(
                                      mclVa(Hk, "Hk"),
                                      mlfColon(
                                        mclPlus(
                                          mclMtimes(
                                            mclMrdivide(
                                              mclVv(N, "N"), mclVv(K, "K")),
                                            mlfScalar(v_0 - 1)),
                                          _mxarray0_),
                                        mclMtimes(
                                          mclMrdivide(
                                            mclVv(N, "N"), mclVv(K, "K")),
                                          mlfScalar(v_0)),
                                        NULL),
                                      mlfScalar(v_))),
                                  _mxarray3_),
                                NULL),
                              mclMrdivide(mclVv(N, "N"), mclVv(K, "K"))),
                            mclVa(SNR, "SNR")),
                          v_0,
                          v_);
                        if (v_0 == e_0) {
                            break;
                        }
                        ++v_0;
                    }
                    mlfAssign(&k, mlfScalar(v_0));
                }
                if (v_ == e_) {
                    break;
                }
                ++v_;
            }
            mlfAssign(&i, mlfScalar(v_));
        }
    }
    /*
     * gama=10*log10(gamag);
     */
    mlfAssign(gama, mclMtimes(_mxarray4_, mlfLog10(mclVv(gamag, "gamag"))));
    /*
     * for i=1:N_ofdm
     */
    {
        int v_ = mclForIntStart(1);
        int e_ = mclForIntEnd(mclVa(N_ofdm, "N_ofdm"));