C++ cvec::length方法代码示例

cvec fir_x::process(bvec ce, cvec x)
{
 cvec y;	
 int N;

	#if (DEBUG_LEVEL==3)
	cout << "***** fir_x::proc *****" << endl;	
	cout << "ce=" << ce << endl;
	cout << "x=" << x << endl;
	sleep(1000);
	#endif

	N=ce.length();
	if (x.length()!=N) { 
		throw sci_exception("fir_x::process - ce.size <> x.size", x.length() );
	}	
	y.set_size(N);
	for (int i=0; i<N; i++) {
		if (bool(ce[i])) y0=update(x[i]);				
		y[i]=y0;
	}
	

	#if (DEBUG_LEVEL==3)
	cout << "y=" << y << endl;
	cout << "+++++ fir_x::proc +++++" << endl;	
	sleep(1000);
	#endif

	return (y);
}

static
void assert_cvec_p(const cvec &ref, const cvec &act, int line)
{
  ASSERT_EQ(ref.length(), act.length()) << line;
  for (int n = 0; n < ref.length(); ++n) {
    ASSERT_NEAR(ref(n).real(), act(n).real(), tol) << line;
    ASSERT_NEAR(ref(n).imag(), act(n).imag(), tol) << line;
  }
}

static
void assert_cvec(const cvec &ref, const cvec &act)
{
  ASSERT_EQ(ref.length(), act.length());
  for (int n = 0; n < ref.length(); ++n) {
    ASSERT_NEAR(ref[n].real(), act[n].real(), tol);
    ASSERT_NEAR(ref[n].imag(), act[n].imag(), tol);
  }
}

	cvec descrambling(cvec data,cvec code)
	{
		cvec result;
		result.set_length(data.length());
		result.zeros();
		for(int i=0;i<data.length();i++)
		{
			result[i]=data(i)*code(i);
		}
		return result;
	}

void zero_pad_back(cvec& vec_in, int m_in)
{
  int quotient = vec_in.length() / m_in;
  if (quotient*m_in == vec_in.length()) {
    return;
  }
  else {
    int n_remainder = (quotient + 1) * m_in - vec_in.length();
    vec_in = concat(vec_in, zeros_c(n_remainder));
  }
}

void fir_x::set_state(cvec cv)
{
int k,N;

	N=get_size();
	if (cv.length()!=N ) {
		throw sci_exception("fir::set_state v.lenght <> fir_size", cv.length() );
	}	

	for (k=0; k < N; k++) {
		z[k]=cv[k];
	}
}

void Plot::Plot_data(cvec ydata, int plot_number){

    double x[ydata.length()];
    double y[ydata.length()];
    if(plot_number==2){
        curve2.setStyle(QwtPlotCurve::CurveStyle(4));
        for (int i=0;i<ydata.length();i++){
            x[i]=real(ydata.get(i));
            y[i]=imag(ydata.get(i));
        }
            curve2.setData(x,y,ydata.length());
            gui->qwtPlot_2->replot();
    }
}

/** Return the channel FIR estimation based on trainSeq and fill phiHat, Ahat, delay, sigmaSqrNoise
 *
 * @pre:
 *    - dataC: cvec of the received data
 *    - trainC: pointer to array of the training sequence
 *             !!!  length assume to be < than dataC.length()!!!
 *    - delay: pointer to a int with synchornization point
 *
 * @post:
 *    - Estimators are now filled!
 *    - returned the channel FIR estimation
 */
void synchCatchChannel(cvec dataC, cvec trainCUp , int *delay ){

  if(dataC.length()<trainCUp.length()){
    cerr << "The training sequence is too big compare to datas!\n";
    exit(1);
  }

  //std::cout<<"Data="<<dataC<<"\n";
  //std::cout<<"Train="<<trainCUp<<"\n";
  
  //Computes crosscorrelation:

  int timeLag=1000;

  cvec dataCSmall=dataC(1,timeLag);

  cvec crossCorr=itpp::xcorr(dataCSmall, trainCUp, timeLag);

  
    //std::cout<<"Cross="<<crossCorr<<"\n";

  //Search for the maximum
  double max=0.0;
  int index=0, count=0;
  double tmp[crossCorr.length()-timeLag+1];
  for(int i=timeLag-1;i<crossCorr.length();i++){
    tmp[count]=abs(crossCorr[i]);
   
    //DispVal(tmp[count]);
    //DispVal(count);
    if (tmp[count]> max ){
      max=tmp[count];
      index=i;
     
    }
     count++;
  }
  
  index=index-timeLag+1;
  *delay=index;


  // Save data to file
     std::ofstream ofs( "xcorr.dat" , std::ifstream::out );
     ofs.write((char * ) tmp, (crossCorr.length()-timeLag+1)*sizeof(double));
     ofs.close();

}

cvec prePost (cvec data_time, int pre, int post){

   data_time.ins(0, data_time.right(pre));
   data_time.ins(data_time.length(), data_time.mid(pre,post));
   return(data_time);

}

cvec xcorr(const cvec &x, const cvec &y, const int max_lag, const std::string scaleopt)
{
  cvec out(2*x.length() - 1); //Initial size does ont matter, it will get adjusted
  xcorr(x, y, out, max_lag, scaleopt, false);

  return out;
}

void FDE(cvec& signal_in, cvec& signal_out, vec& imp_response, int ifftSize, bool verbose)
{
  cvec para = fft(to_cvec(concat(imp_response, zeros(ifftSize-imp_response.length()))));
  if (verbose) {cout << "para: \n" << para << endl;}
  
  int nSymbols = signal_in.length() / ifftSize;
  it_assert(nSymbols * ifftSize == signal_in.length(), "warning");
  
  signal_out = zeros_c(signal_in.length());
  int IdxSig = 0;
  for (int i = 0; i < nSymbols; i++) {
    for (int j = 0; j < ifftSize; j++) {
      signal_out[IdxSig] = signal_in[IdxSig] / para[j];
      IdxSig++;
    }
  }
}

//Evaluate average power of given vector of symbols #M00
double eval_avg_power(const cvec& symbol_vec)
{
  //Overflow check is not implemented in this function
  bool verbose = true;
  double average_power = 0.0;
  double acculmulate_power = 0.0;
  for (size_t i = 0; i < symbol_vec.length(); ++i) {
    acculmulate_power += pow(std::abs(symbol_vec(i)), 2.0);
  }
  average_power = acculmulate_power / symbol_vec.length();

  //Result [verbose]
  if (verbose) {
    cout << "[M00] " << "Average power = " << average_power << endl;
  }
  return average_power;
}

void cofdm_sel::set_output(cvec y_0)
{
	if( y_0.length()== NFFT ) {
		y0=y_0;
	}
	else {
		throw sci_exception("cofdm_sel::set_output - bad y_0.size() <> NFFT=", NFFT);
	}
}

cvec operator/(const double &s, const cvec &v)
{
  it_assert_debug(v.size() > 0, "operator/(): Vector of zero length");

  cvec temp(v.length());
  for (int i = 0;i < v.size();i++) {
    temp(i) = s / v(i);
  }
  return temp;
}

cvec TestEseNonGrayFixture::conv(const cmat &a, const cvec &b) {
	// check a.rows()==b.length()
	int len = a.cols()+b.length()-1;
	cvec ret = zeros_c(len);
	for(int i=0; i<a.cols(); i++) {
		cvec tmp = zeros_c(len);
		tmp.set_subvector(i, elem_mult(a.get_col(i), b));
		ret += tmp;
	}
	return ret;
}