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

vec mix::process(bvec ce, mat x)
{
 vec y;	
 int N;
 bvec one = ("1");

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

	N=ce.length();
	if (x.rows()!=N) { 
		throw sci_exception("mix::process - ce.size <> x.rows()", x.rows() );
	}
	if (x.cols()!=2) { 
		throw sci_exception("mix::process - x=[x1,x1] - x.cols()!=2", x.cols() );
	}

	y.set_length(N);
	for (int i=0; i<N; i++) {
		if ( bool(ce[i])) {
			y0 = G.process(one, to_vec(x(i,0)*x(i,1)))(0);
		}
		y[i]=y0;
	}
	#if (DEBUG_LEVEL==3)
	cout << "y=" << y << endl;
	cout << "+++++ mix::process +++++" << endl;	
	sleep(1000);
	#endif
	return (y);
}

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);
}

bvec Extended_Golay::decode(const bvec &coded_bits)
{
    int no_bits = coded_bits.length();
    int no_blocks = (int)floor((double)no_bits/24);
    bvec output(12*no_blocks);
    int i;
    int j;
    bvec S(12),BS(12),r(12),temp(12),e(24),c(24);
    bmat eyetemp = eye_b(12);

    for (i=0; i<no_blocks; i++) {
	r = coded_bits.mid(i*24,24);
	// Step 1. Compute S=G*r.
	S = G*r;
	// Step 2. w(S)<=3. e=(S,0). Goto 8.
	if( weight(S) <= 3 ) {
	    e = concat(S, zeros_b(12)); goto Step8;
	}
	  
	// Step 3. w(S+Ii)<=2. e=(S+Ii,yi). Goto 8.
	for (j=0; j<12; j++) {
			
	    temp = S + B.get_col(j);
	    if ( weight(temp) <=2 ) {
		e = concat(temp, eyetemp.get_row(j)); goto Step8;
	    }
	}

	// STEP 4. Compute B*S
	BS = B*S;

	// Step 5. w(B*S)<=3. e=(0,BS). Goto8.
	if ( weight(BS) <=3 ) {
	    e = concat(zeros_b(12), BS); goto Step8;
	}

	// Step 6. w(BS+Ri)<=2. e=(xi,BS+Ri). Goto 8.
	for (j=0; j<12; j++) {
	    temp = BS + B.get_row(j);
	    if ( weight(temp) <=2 ) {
		e = concat(eyetemp.get_row(j), temp); goto Step8;
	    }
	}

	// Step 7. Uncorrectable erreor pattern. Choose the first 12 bits.
	e = zeros_b(24); goto Step8;
	  
    Step8: // Step 8. c=r+e. STOP
	c = r + e;
	output.replace_mid(i*12, c.left(12));
    }
  
    return output;
}

void BERC::estimate_delay(const bvec &in1, const bvec &in2, int mindelay,
                          int maxdelay)
{
  int num, start1, start2;
  int min_input_length = std::min(in1.length(), in2.length());
  int bestdelay = mindelay;
  double correlation;
  double bestcorr = 0;
  for (int i = mindelay; i < maxdelay; i++) {
    num = min_input_length - std::abs(i) - ignorefirst - ignorelast;
    start1 = (i < 0) ? -i : 0;
    start2 = (i > 0) ?  i : 0;
    correlation = fabs(sum(to_vec(elem_mult(in1.mid(start1, num),
                                            in2.mid(start2, num)))));
    if (correlation > bestcorr) {
      bestdelay = i;
      bestcorr  = correlation;
    }
  }
  delay = bestdelay;
}

bvec Extended_Golay::encode(const bvec &uncoded_bits)
{
    int no_bits = uncoded_bits.length();
    int no_blocks = (int)floor((double)no_bits/12);
    bvec output(24*no_blocks);
    int i;
	
    for (i=0; i<no_blocks; i++) 
	output.replace_mid(24*i, uncoded_bits.mid(i*12,12)*G);

    return output;
}

void Hamming_Code::encode(const bvec &uncoded_bits, bvec &coded_bits)
{
    int length = uncoded_bits.length();
    int Itterations = floor_i(static_cast<double>(length) / k);
    bmat Gt = G.T();
    int i;

    coded_bits.set_size(Itterations * n, false);
    //Code all codewords
    for (i = 0; i < Itterations; i++)
        coded_bits.replace_mid(n*i, Gt * uncoded_bits.mid(i*k, k));
}

void BLERC::count(const bvec &in1, const bvec &in2)
{
  it_assert(setup_done == true,
            "BLERC::count(): Block size has to be setup before counting errors.");
  int min_input_length = std::min(in1.length(), in2.length());
  it_assert(blocksize <= min_input_length,
            "BLERC::count(): Block size must not be longer than input vectors.");

  for (int i = 0; i < (min_input_length / blocksize); i++) {
    CORR = true;
    for (int j = 0; j < blocksize; j++) {
      if (in1(i * blocksize + j) != in2(i * blocksize + j)) {
        CORR = false;
        break;
      }
    }
    if (CORR) {
      corrects++;
    }
    else {
      errors++;
    }
  }
}

double BERC::count_errors(const bvec &in1, const bvec &in2, int indelay,
                          int inignorefirst, int inignorelast)
{
  int countlength = std::min(in1.length(), in2.length()) - std::abs(indelay)
                    - inignorefirst - inignorelast;
  int local_errors = 0;

  if (indelay >= 0) {
    for (int i = 0; i < countlength; i++) {
      if (in1(i + inignorefirst) != in2(i + inignorefirst + indelay)) {
        local_errors++;
      }
    }
  }
  else {
    for (int i = 0; i < countlength; i++) {
      if (in1(i + inignorefirst - indelay) != in2(i + inignorefirst)) {
        local_errors++;
      }
    }
  }

  return local_errors;
}

char sigma2::bvec2char(bvec &bv, int pos)
{
	char ret = 0;
	int a[] = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80};
	if(pos > bv.length() - 8)
	{
		cout << "Can sua loi nay";
		return 0;
	}
	for(int i = pos; i < pos + 8; i++)
	{
		if(bv[i] == 1)
			ret = ret | a[7 - i + pos];
	}
	return ret;
}

	vec spreading(bvec data,vec code)
	{
		vec result;
		vec code_neg=code*-1;
		for(int i=0; i<data.length();i++)
		{
		if(data[i]==1)
		{
			result=concat(result,code);
		}
		else
		{
			result=concat(result,code_neg);
		}
		}
		return result;
	}

void Reed_Solomon::encode(const bvec &uncoded_bits, bvec &coded_bits)
{
  int i, j, iterations = floor_i(static_cast<double>(uncoded_bits.length())
                                 / (k * m));
  GFX mx(q, k), cx(q, n);
  GFX r(n + 1, n - k);
  GFX uncoded_shifted(n + 1, n);
  GF mpow;
  bvec mbit(k * m), cbit(m);

  coded_bits.set_size(iterations * n * m, false);

  if (systematic)
    for (i = 0; i < n - k; i++)
      uncoded_shifted[i] = GF(n + 1, -1);

  for (i = 0; i < iterations; i++) {
    //Fix the message polynom m(x).
    for (j = 0; j < k; j++) {
      mpow.set(q, uncoded_bits.mid((i * m * k) + (j * m), m));
      mx[j] = mpow;
      if (systematic) {
        cx[j] = mx[j];
        uncoded_shifted[j + n - k] = mx[j];
      }
    }
    //Fix the outputbits cbit.
    if (systematic) {
      r = modgfx(uncoded_shifted, g);
      for (j = k; j < n; j++) {
        cx[j] = r[j - k];
      }
    }
    else {
      cx = g * mx;
    }
    for (j = 0; j < n; j++) {
      cbit = cx[j].get_vectorspace();
      coded_bits.replace_mid((i * n * m) + (j * m), cbit);
    }
  }
}

void cofdm_map::set_pilots(bvec x)
{
int K = x.length();
complex<double> p1 ( PA , 0.0);
complex<double> p0 (-PA , 0.0);
int L = zero_carriers.length();
complex<double> c0 (0.0 , 0.0);
int i;

	if( K == pilots_carriers.length() ) {
		for (i=0; i<K; i++) {
			y0(pilots_carriers(i))=x(i)?p1:p0;
		}
		for (i=0; i<L; i++) {
			y0(zero_carriers(i))=c0;
		}
	}
	else {
		throw sci_exception("cofdm_map::set_pilots - x.size() <> pilots_carriers.size()=", pilots_carriers.length());
	}	
}

cvec qam_mod::process(bvec ce, ivec x)
{
 cvec y;	
 int N;
 ivec iv;
 cvec cv;

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

	iv.set_length(1);
	cv.set_length(1);
	N=ce.length();
	y.set_length(N);
	if (x.length()!=N) {
		throw sci_exception("qam_mod::process - ce.size <> x.size", x.length() );
	}	
	for (int i=0; i<N; i++) {
		if ( bool(ce[i])) {
			iv[0]  = x[i];
			cv = modulate(iv);
			y0 = scale * cv[0];
		}
		y[i]=y0;
	}

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

	return (y);
}

bmat int2bin::process(bvec ce, ivec x)
{
 bmat y;	
 int N;

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

	N=ce.length();
	if (x.length()!=N) { 
		throw sci_exception("int2bin::process - ce.size <> x.rows()", x.length() );
	}

	y.set_size(N,symbol_size);
	for (int i=0; i<N; i++) {
		if ( bool(ce[i])) {
			y0 = dec2bin(symbol_size, x[i]);
			if (! msb_first) {
				y0 = reverse(y0);
			}
		}
		y.set_row(i,y0);
	}

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

	return (y);
}

bool any(const bvec &testvec)
{
    for (int i = 0; i < testvec.length(); i++)
        if (testvec(i)) return true;
    return false;
}