void PrintCover(const gsl_vector_uint * const rowCov,
const gsl_vector_uint * const colCov,
const char * const name)
{
unsigned int i, j;
unsigned int rCov, cCov;
fprintf(stderr, "..........................................\n");
fprintf(stderr, "\t%s\n", name == NULL ? "(NULL)":name);
fprintf(stderr, "..........................................\n");
for(i = 0; i < rowCov->size; i++)
{
rCov = gsl_vector_uint_get(rowCov, i);
for(j = 0; j < colCov->size; j++)
{
cCov = gsl_vector_uint_get(colCov, j);
if( rCov == UNCOVERED && cCov == UNCOVERED ) fprintf(stderr, ".\t");
else if( rCov == UNCOVERED && cCov == COVERED ) fprintf(stderr, "|\t");
else if( rCov == COVERED && cCov == UNCOVERED ) fprintf(stderr, "--\t");
else if( rCov == COVERED && cCov == UNCOVERED ) fprintf(stderr, "+\t");
}
fprintf(stderr, "\n");
}
fprintf(stderr, "\n");
}
/*!
Find a zero (Z) in the resulting matrix. If there is no starred zero in its row or column, star Z. Repeat for each element in the matrix. Go to STEP3.
*/
nextstep Step2(const gsl_matrix * const M,
gsl_matrix_uint * const mask,
gsl_vector_uint * const rowCov,
gsl_vector_uint * const colCov)
{
unsigned int i, j;
for(i = 0; i < M->size1; i++)
{
for(j = 0; j < M->size2; j++)
{
if(gsl_vector_uint_get(rowCov, i) == COVERED) break;
if(gsl_vector_uint_get(colCov, j) == UNCOVERED &&
gsl_matrix_get(M, i, j) == (float) 0 )
{
gsl_matrix_uint_set(mask, i, j, STAR);
#ifdef VERBOSE
fprintf(stderr, "Covering col %d\n", j);
#endif
gsl_vector_uint_set(colCov, j, COVERED);
#ifdef VERBOSE
fprintf(stderr, "Covering row %d\n", i);
#endif
gsl_vector_uint_set(rowCov, i, COVERED);
}
}
}
gsl_vector_uint_set_all(rowCov, UNCOVERED);
gsl_vector_uint_set_all(colCov, UNCOVERED);
return STEP3;
}
double logRV(size_t dims,gsl_vector_uint *x,gsl_vector_uint *sums,unsigned int NN) {
unsigned int n=0;
double r=0;
size_t i;
for(i=0;i<dims;i++) {
n+=gsl_vector_uint_get(x,i);
}
// x*(log(Na)-log(x))+y*(log(Nb)-log(y))+n*(log(n)-log(NN));
for(i=0;i<dims;i++) {
unsigned int xi=gsl_vector_uint_get(x,i);
if (xi != 0) {
r+=xi*(log(ELT(sums,i))-log(xi));
} else {
r+=SMALL_P*(log(ELT(sums,i))-log(SMALL_P));
}
}
if (n==0)
return r;
else
return r+n*(log(n)-log(NN));
}
void MBitBer::Run() {
unsigned int t,tt;
gsl_matrix_uint ref = min1.GetDataObj();
gsl_matrix_uint rec = min2.GetDataObj();
stopFlag = ! (maxerrs()==0);
for (int i=0;i<M();i++) { // user loop
unsigned int userErrors = 0;
for (int j=0;j<bpu();j++) { // bit loop
tt = gsl_matrix_uint_get(&ref,i,j);
t = gsl_matrix_uint_get(&rec,i,j);
userErrors += (tt != t);
} // bit loop
gsl_vector_uint_set(bitcount,i,gsl_vector_uint_get(bitcount,i)+bpu());
gsl_vector_uint_set(errcount,i,gsl_vector_uint_get(errcount,i)+userErrors);
if (gsl_vector_uint_get(errcount,i)<maxerrs())
stopFlag=false;
} // user loop
if (framecount == ERROR_REPORT_INTERVAL) { // report errors
// dumperrs <- errocount
gsl_vector_uint_memcpy(dumperrs,errcount);
// dumperrs <- dumperrs - lasterrs
gsl_vector_uint_sub(dumperrs,lasterrs);
// lasterrs <- errcount
gsl_vector_uint_memcpy(lasterrs,errcount);
framecount = 0;
#ifdef DUMPERRS
for (int i=0;i<M();i++) {
cout << gsl_vector_uint_get(dumperrs,i) << " errors for user " << i << endl;
}
#endif
} // end update report errors
framecount++;
//////// production of data
vout1.DeliverDataObj(*dumperrs);
}
void PSKMapper::Run() {
unsigned int nbits,nsymbs,count;
/// fetch data objects
gsl_vector_uint_class input = vin1.GetDataObj();
// number of input bits
nbits = input.vec->size;
// number of output symbols
nsymbs = nbits / Nb();
gsl_vector_complex *tmp=gsl_vector_complex_alloc(nsymbs);
count=0;
for (int n=0; n<nsymbs; n++) {
symbol_id=0;
//////// I take Nb bits from input and map it in new_symbol
for (int i=0;i<Nb();i++) {
symbol_id = (symbol_id << 1);
symbol_id += gsl_vector_uint_get(input.vec,count++);
}
new_symbol = gsl_complex_polar(1.0,
symbol_arg *
double(gsl_vector_uint_get(gray_encoding,
symbol_id)));
gsl_vector_complex_set(tmp,n,new_symbol);
}
// show output
// gsl_vector_complex_show(tmp);
// deliver data
vout1.DeliverDataObj(gsl_vector_complex_class(tmp));
gsl_vector_complex_free(tmp);
}
/**
* Evaluate the delayed vector field from fields for each delay.
* \param[in] state State at which to evaluate the vector field.
* \param[out] field Vector resulting from the evaluation of the vector field.
*/
void
vectorFieldDelay::evalField(gsl_matrix *state, gsl_vector *field)
{
gsl_vector_view delayedState;
unsigned int delay;
// Set field evaluation to 0
gsl_vector_set_zero(field);
/** Add delayed drifts */
for (size_t d = 0; d < nDelays; d++)
{
delay = gsl_vector_uint_get(delays, nDelays - d - 1);
// Assign pointer to delayed state
delayedState = gsl_matrix_row(state, delay);
// Evaluate vector field at delayed state
fields->at(nDelays - d - 1)->evalField(&delayedState.vector, work);
// Add to newState in workspace
gsl_vector_add(field, work);
}
return;
}
/*!
Find a zero.
*/
void FindAZero(const gsl_matrix * const M,
const gsl_vector_uint * const rowCov,
const gsl_vector_uint * const colCov,
int * const row,
int * const col)
{
int i, j;
bool done;
*row = -1;
*col = -1;
// Don't bother if the minimum value is COVERED
// since we'll never find an UNCOVERED element.
// Note this depends on the enum order.
if(gsl_vector_uint_min(rowCov) == COVERED ||
gsl_vector_uint_min(colCov) == COVERED) return;
#ifdef VERBOSE
Matrix_print_with_mask(M, NULL, rowCov, colCov, "Finding Zero");
#endif
for(i = 0, done = false; i < M->size1 && done == false; ++i)
{
if(gsl_vector_uint_get(rowCov, i) != UNCOVERED)
continue;
for(j = M->size2-1; j >= 0; --j)
{
if( gsl_vector_uint_get(colCov, j) != UNCOVERED )
continue;
#ifdef VERBOSE
fprintf(stderr, "Finding zero at %d, %d\n", i, j);
#endif
if(gsl_matrix_get(M, i, j) != (float) 0) continue;
*row = i;
*col = j;
done = true;
break;
}
}
}
float FindSmallest(const gsl_matrix * const M,
const gsl_vector_uint * const rowCov,
const gsl_vector_uint * const colCov)
{
float minval = FLT_MAX;
unsigned int i, j;
for(i = 0; i < M->size1; i++)
{
if(gsl_vector_uint_get(rowCov, i) != UNCOVERED) continue;
for(j = 0; j < M->size2; j++)
{
if(gsl_vector_uint_get(colCov, j) != UNCOVERED) continue;
if(minval > gsl_matrix_get(M, i, j))
minval = gsl_matrix_get(M, i, j);
}
}
return minval;
}
void Matrix_print_with_mask(const gsl_matrix * const M,
const gsl_matrix_uint * const mask,
const gsl_vector_uint * const rowCov,
const gsl_vector_uint * const colCov,
const char *const name)
{
unsigned int i, j, rCov, cCov;
fprintf(stderr, "====================================================\n");
fprintf(stderr, "\t\t%s\n", name == NULL ? "(NULL)":name);
fprintf(stderr, "====================================================\n");
for(i = 0; i < M->size1; i++)
{
for(j = 0; j < M->size2; j++)
{
fprintf(stderr, "%.1f", gsl_matrix_get(M, i, j));
if(mask != NULL)
{
if(gsl_matrix_uint_get(mask, i, j) == STAR)
fprintf(stderr, "*");
else if(gsl_matrix_uint_get(mask, i, j) == PRIME)
fprintf(stderr, "'");
}
fprintf(stderr, "\t");
}
fprintf(stderr, "\t");
rCov = gsl_vector_uint_get(rowCov, i);
for(j = 0; j < M->size2; j++)
{
cCov = gsl_vector_uint_get(colCov, j);
if( rCov == UNCOVERED && cCov == UNCOVERED ) fprintf(stderr, ".\t");
else if( rCov == UNCOVERED && cCov == COVERED ) fprintf(stderr, "|\t");
else if( rCov == COVERED && cCov == UNCOVERED ) fprintf(stderr, "--\t");
else if( rCov == COVERED && cCov == COVERED ) fprintf(stderr, "+\t");
}
fprintf(stderr, "\n");
}
fprintf(stderr, "\n");
}
/**
* Constructor for a delayed vector field.
* \param[in] fields_ Vector of vector fields for each delay.
* \param[in] delays_ Delays associated with each vector field.
*/
vectorFieldDelay::vectorFieldDelay(std::vector<vectorField *> *fields_,
const gsl_vector_uint *delays_)
: dim(fields_->at(0)->getDim()), nDelays(delays_->size),
delayMax(gsl_vector_uint_get(delays_, nDelays - 1)), fields(fields_)
{
// Copy delays
delays = gsl_vector_uint_alloc(nDelays);
gsl_vector_uint_memcpy(delays, delays_);
// Allocate workspace
work = gsl_vector_alloc(dim);
}
/*!
Cover each column containing a starred zero. If K columns are covered, the starred zeroes describe a complete set of unique assignments. In this case, go to DONE. Otherwise, go to STEP4.
Once we have searched the entire cost matrix, we count the number of independent zeroes found. If we have found (and starred) K independent zeroes then we are done. If not we proceed to STEP4.
*/
nextstep Step3(const gsl_matrix * const M,
const gsl_matrix_uint * const mask,
gsl_vector_uint * const colCov)
{
unsigned int i, j;
for(j = 0; j < M->size2; ++j)
{
if(gsl_vector_uint_get(colCov, j) == COVERED) continue;
for(i = 0; i < M->size1; ++i)
{
if(gsl_matrix_uint_get(mask, i, j) == STAR)
gsl_vector_uint_set(colCov, j, COVERED);
}
}
for(j = 0; j < colCov->size; j++)
if(gsl_vector_uint_get(colCov, j) == UNCOVERED)
return STEP4;
return DONE;
}
nextstep Step6(gsl_matrix * const M,
gsl_vector_uint * const rowCov,
gsl_vector_uint * const colCov)
{
unsigned int i, j;
float minval;
bool hasRowCov;
minval = FindSmallest(M, rowCov, colCov);
for(i = 0; i < M->size1; i++)
{
hasRowCov = (gsl_vector_uint_get(rowCov, i) == COVERED);
for(j = 0; j < M->size2; j++)
{
if(hasRowCov == true)
gsl_matrix_set(M, i, j, gsl_matrix_get(M, i, j)+minval);
if(gsl_vector_uint_get(colCov, j) == UNCOVERED)
gsl_matrix_set(M, i, j, gsl_matrix_get(M, i, j)-minval);
}
}
return STEP4;
}
void MAIAllocator::UpdateInputLink(){
for (int u=0;u<M();u++) { // user loop
// user errors
pAgent->Update(umapUserErrsVec[u],gsl_vector_uint_get(errs,u));
// channel coefficients
for (int j=0;j<N();j++) {
double coeffVal = gsl_complex_abs(gsl_matrix_complex_get(Hmat,j,u));
pAgent->Update(chansCoeffValueMat[u*N()+j],mudisp::lintodb(coeffVal));
} // j loop
// current allocation (channels and powers)
for (int j=0;j<J();j++) {
unsigned int carr = gsl_matrix_uint_get(signature_frequencies,u,j);
double power = gsl_matrix_get(signature_powers,u,j);
pAgent->Update(umapUserCarrCidMat[u*J()+j],carr);
pAgent->Update(umapUserCarrPowerMat[u*J()+j],power);
} // j loop
} // user loop
}
void SoftDemapper::Run() {
unsigned int nbits,nsymbs,count;
/// fetch data objects
gsl_vector_complex_class input = vin1.GetDataObj();
// number of input symbs
nsymbs = input.vec->size;
// cout << "received " << nsymbs << " elements in vector." << endl;
// number of output symbols
nbits = nsymbs * Nb();
gsl_vector *llr=gsl_vector_alloc(nbits);
double *den = (double *)calloc( Nb(), sizeof(double) );
double *num = (double *)calloc( Nb(), sizeof(double) );
// determine symb_likelyhood
for (int i=0;i<nsymbs;i++) { // cycle through received symbols
for (int k=0;k<Nb();k++) {
num[k] = GSL_NEGINF;
den[k] = GSL_NEGINF;
}
// the received symbol
gsl_complex recsym = gsl_vector_complex_get(input.vec,i);
// cout << "received symbol = ("
// << GSL_REAL(recsym)
// << ","
// << GSL_IMAG(recsym)
// << ") " << endl;
for (int j=0;j<Ns;j++) { // cycle through postulated symbol
// gray encoded symbol id
unsigned int symbol_id = gsl_vector_uint_get(gray_encoding,j);
// complex symbol
gsl_complex refsym = gsl_complex_polar(1.0,symbol_arg * symbol_id );
// likelyhood metric
double metric = gsl_complex_abs( gsl_complex_sub(refsym,recsym) );
metric = -EsNo()*metric*metric;
//gsl_matrix_complex_set(symb_likelihoods,j,i);
//
// HERE is available a metric for symb i and refsymb j
//
int mask = 1 << Nb() - 1;
for (int k=0;k<Nb();k++) { /* loop over bits */
if (mask&j) {
/* this bit is a one */
num[k] = ( *max_star[LMAP()] )( num[k], metric );
} else {
/* this bit is a zero */
den[k] = ( *max_star[LMAP()] )( den[k], metric );
}
mask = mask >> 1;
} //bits
} // alphabet
for (int k=0;k<Nb();k++) {
gsl_vector_set(llr,Nb()*i+k,num[k] - den[k]);
}
} // symbols
gsl_vector_class outv(llr);
// outv.show();
// output bitwise LLR
vout1.DeliverDataObj(outv);
gsl_vector_free(llr);
// free dynamic structures
free(num);
free(den);
}
//
//
// BlockUser
//
//
void MBlockUser::Setup() {
//////// initialization of dynamic data structures
// number of symbols
Ns=(1 << Nb());
/// vector and matrix allocation
gray_encoding = gsl_vector_uint_alloc(Ns);
symbol_arg = 2.0*double(PI/Ns);
count=0;
coding_mat = gsl_matrix_complex_calloc(J(),K());
selection_mat = gsl_matrix_complex_calloc(N(),J());
transform_mat = gsl_matrix_complex_calloc(N(),N());
outmat = gsl_matrix_complex_calloc(N(),M()); // outmat(i,j) = symbol at time i from user j
tmp = gsl_vector_complex_calloc(K());
tmp1 = gsl_vector_complex_calloc(J());
tmp2 = gsl_vector_complex_calloc(N());
// tmpout = gsl_vector_complex_calloc(N()); // tmpout is a view from outmat
//
//
// IFFT MATRIX UNITARY
//
//
double ifftarg=2.0*double(M_PI/N());
double ifftamp=1.0/sqrt(double(N()));
for (int i=0; i<N(); i++)
for (int j=0; j<N(); j++)
gsl_matrix_complex_set(transform_mat,
i,
j,
gsl_complex_polar(ifftamp,ifftarg*i*j) );
//////// rate declaration for ports
// in1.SetRate( Nb()*K()*M() ); // M users K symbols Nb bits
///////// Gray Encoder SetUp
for (unsigned int i=0; i<Ns; i++) {
gsl_vector_uint_set(gray_encoding,i,0);
for (unsigned int k=0; k<Nb(); k++) {
unsigned int t=(1<<k);
unsigned int tt=2*t;
unsigned int ttt= gsl_vector_uint_get(gray_encoding,i)
+ t * (((t+i)/tt) % 2);
gsl_vector_uint_set(gray_encoding,i,ttt);
}
}
}
void MBlockUser::Run() {
//
// Allocation Matrices
//
gsl_matrix_uint signature_frequencies=min2.GetDataObj();
gsl_matrix signature_powers=min3.GetDataObj();
//
// input bits
//
gsl_matrix_uint inputbits = min1.GetDataObj();
//
// outer loop: the users
//
for (int u=0;u<M();u++) {
gsl_vector_complex_view tmpout = gsl_matrix_complex_column(outmat,u);
//
//
// FETCH K INPUT SYMBOLS
//
//
for (int j=0;j<K();j++) {
symbol_id=0;
//////// I take Nb bits from input and map it in new_symbol
for (int i=0;i<Nb();i++) {
symbol_id = (symbol_id << 1);
// symbol_id += in1.GetDataObj();
symbol_id += gsl_matrix_uint_get(&inputbits,u,j*Nb()+i);
}
new_symbol = gsl_complex_polar(1.0,
symbol_arg *
double(gsl_vector_uint_get(gray_encoding,
symbol_id)));
gsl_vector_complex_set(tmp,j,new_symbol);
}
//
//
// SELECTION MATRIX UPDATE and POWER
//
//
// gsl_matrix_complex_set_identity(selection_mat);
gsl_matrix_complex_set_zero(selection_mat);
for (int i=0;i<J(); i++) {
unsigned int carrier=gsl_matrix_uint_get(&signature_frequencies,u,i);
double power=gsl_matrix_get(&signature_powers,u,i);
gsl_complex one=gsl_complex_polar(power,0.0);
gsl_matrix_complex_set(selection_mat,carrier,i,one);
}
//
//
// PRECODING MATRIX UPDATE
//
//
#ifdef GIANNAKIS_PRECODING
double roarg=2.0*double(M_PI/N());
for (int i=0;i<J(); i++) {
unsigned int carrier=gsl_matrix_uint_get(&signature_frequencies,u,i);
for (int j=0; j<K(); j++) {
gsl_complex ro=gsl_complex_polar(sqrt(1.0/double(J())),-j*carrier*roarg);
gsl_matrix_complex_set(coding_mat,i,j,ro);
}
}
#else
double roarg=2.0*double(M_PI/J());
for (int i=0;i<J(); i++) {
for (int j=0; j<K(); j++) {
gsl_complex ro=gsl_complex_polar(sqrt(1.0/double(J())),-j*i*roarg);
gsl_matrix_complex_set(coding_mat,i,j,ro);
}
}
#endif
#ifdef SHOW_MATRIX
cout << endl << BlockName << " user: "******"coding matrix (theta) = " << endl;
gsl_matrix_complex_show(coding_mat);
cout << "T^h*T matrix = " << endl;
gsl_matrix_complex_show(THT);
cout << "T^h*T trace = "
<< GSL_REAL(trace)
<< ", "
<< GSL_IMAG(trace)
<< endl;
gsl_matrix_complex_free(THT);
#endif
//
//
// PRECODING
//
//
gsl_blas_zgemv(CblasNoTrans,
gsl_complex_rect(1.0,0),
coding_mat,
tmp,
gsl_complex_rect(0,0),
tmp1);
//
//
// CARRIER SELECTION
//
//
gsl_blas_zgemv(CblasNoTrans,
gsl_complex_rect(1.0,0),
selection_mat,
tmp1,
gsl_complex_rect(0,0),
tmp2);
//
//
// IFFT TRANSFORM
//
//
gsl_blas_zgemv(CblasNoTrans,
gsl_complex_rect(1.0,0),
transform_mat,
tmp2,
gsl_complex_rect(0,0),
&tmpout.vector);
// cout << "\n\n symbols (user " << u << ") = " << endl;
// gsl_vector_complex_fprintf(stdout,tmp,"%f");
#ifdef SHOW_MATRIX
cout << "\n\n symbols (user " << u << ") = " << endl;
gsl_vector_complex_fprintf(stdout,tmp,"%f");
cout << "\n\n precoded = " << endl;
gsl_vector_complex_fprintf(stdout,tmp1,"%f");
cout << "\n\n precoded selected = " << endl;
gsl_vector_complex_fprintf(stdout,tmp2,"%f");
cout << "\n\n precoded selected transformed = " << endl;
gsl_vector_complex_fprintf(stdout,&tmpout.vector,"%f");
#endif
} // close user loop
mout1.DeliverDataObj(*outmat);
}
void MBitBer::Finish() {
ofstream ofs;
string fn( fname() );
if (fn != "cout")
ofs.open( fname(),ios::app);
if (! ofs ) {
cerr << BlockName << ": error opening "
<< fn << endl;
exit(_ERROR_OPEN_FILE_);
}
unsigned int minimum, maximum, sum;
minimum = (unsigned int)GSL_POSINF;
maximum = sum = 0;
for (int u=0;u<M();u++) { // user loop
if (gsl_vector_uint_get(bitcount,u)!=0) {
if (fn != "cout") {
ofs.width(NUMWIDTH);
ofs << u;
ofs.width(NUMWIDTH);
ofs << value();
ofs.width(NUMWIDTH);
ofs << 1.0*gsl_vector_uint_get(errcount,u)/gsl_vector_uint_get(bitcount,u);
ofs.width(NUMWIDTH);
ofs << gsl_vector_uint_get(bitcount,u);
ofs.width(NUMWIDTH);
ofs << gsl_vector_uint_get(errcount,u) << endl;
}
else {
cout.width(NUMWIDTH);
cout << u;
cout.width(NUMWIDTH);
cout << value();
cout.width(NUMWIDTH);
cout << 1.0*gsl_vector_uint_get(errcount,u)/gsl_vector_uint_get(bitcount,u);
cout.width(NUMWIDTH);
cout << gsl_vector_uint_get(bitcount,u);
cout.width(NUMWIDTH);
cout << gsl_vector_uint_get(errcount,u) << endl;
}
}
// find maximum
if (gsl_vector_uint_get(errcount,u)>maximum)
maximum = gsl_vector_uint_get(errcount,u);
// find minimum
if (gsl_vector_uint_get(errcount,u)<minimum)
minimum = gsl_vector_uint_get(errcount,u);
sum += gsl_vector_uint_get(errcount,u);
} // user loop
// min, max and mean
if (gsl_vector_uint_get(bitcount,0)!=0) {
if (fn != "cout") {
ofs.width(NUMWIDTH);
ofs << "min";
ofs.width(NUMWIDTH);
ofs << value();
ofs.width(NUMWIDTH);
ofs << 1.0*minimum/gsl_vector_uint_get(bitcount,0);
ofs.width(NUMWIDTH);
ofs << gsl_vector_uint_get(bitcount,0);
ofs.width(NUMWIDTH);
ofs << minimum << endl;
ofs.width(NUMWIDTH);
ofs << "max";
ofs.width(NUMWIDTH);
ofs << value();
ofs.width(NUMWIDTH);
ofs << 1.0*maximum/gsl_vector_uint_get(bitcount,0);
ofs.width(NUMWIDTH);
ofs << gsl_vector_uint_get(bitcount,0);
ofs.width(NUMWIDTH);
ofs << maximum << endl;
ofs.width(NUMWIDTH);
ofs << "mean";
ofs.width(NUMWIDTH);
ofs << value();
ofs.width(NUMWIDTH);
ofs << 1.0*sum/gsl_vector_uint_get(bitcount,0)/M();
ofs.width(NUMWIDTH);
ofs << gsl_vector_uint_get(bitcount,0);
ofs.width(NUMWIDTH);
ofs << sum/M() << endl;
}
else {
cout.width(NUMWIDTH);
cout << "min";
cout.width(NUMWIDTH);
cout << value();
cout.width(NUMWIDTH);
cout << 1.0*minimum/gsl_vector_uint_get(bitcount,0);
cout.width(NUMWIDTH);
cout << gsl_vector_uint_get(bitcount,0);
cout.width(NUMWIDTH);
cout << minimum << endl;
cout.width(NUMWIDTH);
cout << "max";
cout.width(NUMWIDTH);
cout << value();
cout.width(NUMWIDTH);
cout << 1.0*maximum/gsl_vector_uint_get(bitcount,0);
cout.width(NUMWIDTH);
cout << gsl_vector_uint_get(bitcount,0);
cout.width(NUMWIDTH);
cout << maximum << endl;
cout.width(NUMWIDTH);
cout << "mean";
cout.width(NUMWIDTH);
cout << value();
cout.width(NUMWIDTH);
cout << 1.0*sum/gsl_vector_uint_get(bitcount,0)/M();
cout.width(NUMWIDTH);
cout << gsl_vector_uint_get(bitcount,0);
cout.width(NUMWIDTH);
cout << sum/M() << endl;
}
}
ofs.close();
double ebnol=pow(10.0,(value()/10.0));
cout << "\n BPSK reference BER (AWGN) = " << gsl_cdf_ugaussian_Q(sqrt(2*ebnol)) << endl;
gsl_vector_uint_free(lasterrs);
gsl_vector_uint_free(errcount);
gsl_vector_uint_free(bitcount);
gsl_vector_uint_free(dumperrs);
}
void MAIAllocator::Run() {
// fetch channel matrix
gsl_matrix_complex hmm = min1.GetDataObj();
// hmm : channel coeffs matrix h(n) (M**2xN)
// ij
// ch matrix structure
//
// +- -+
// | h(0) . . . . h(n) | |
// | 11 11 | |
// | | | Rx1
// | h(0) . . . . h(n) | |
// | 12 12 | |
// | |
// | h(0) . . . . h(n) | |
// | 21 21 | |
// | | | Rx2
// | h(0) . . . . h(n) | |
// | 22 22 | |
// +- -+
//
// where h(n) represents the channel impulse response
// ij
//
// at time n, from tx_i to rx_j
// the matrix has MxM rows and N comumns.
// The (i,j) channel is locater at row i*M+j
// with i,j in the range [0,M-1] and rows counting from 0
//
//
// fetch error report
// e(u) = errors for user u in the last ERROR_REPORT_INTERVAL (ERI) frames
gsl_vector_uint temperr = vin2.GetDataObj();
// update error reports at receiver rx_m every ERI
if (ericount % ERROR_REPORT_INTERVAL == 0) { // once every ERU
if (temperr.size == M()) {
gsl_vector_uint_memcpy(errs,&temperr);
}
ericount = 0;
}
//
// every DECISION_INTERVAL frames we updates the CSI knowledge
//
if (framecount % DECISION_INTERVAL == 0) {
for (int u=0;u<M();u++) { // user loop
// extract time domain response from hmm corresponding to txn-->rxn channel
gsl_vector_complex_const_view hii = gsl_matrix_complex_const_row(&hmm,u*M()+u);
// copy the N-sized vector hii into u-th column of huu
gsl_matrix_complex_set_col(huu,u,&hii.vector);
} // user loop
//cout << "maiallocator:453 - CSI update received" << endl;
// huu matrix structure
//
// +- -+
// | h(0) . . . . h(n) |
// | 11 uu |
// | |
// | h(n) . . . . h(n) |
// | 11 uu |
// +- -+
//
// where h(n) represents the channel impulse response
// ii
//
// at time n, from tx_u to rx_u
// the matrix has N rows and M columns.
//
// ATTENTION! user_0 channel response is the first column
//
// Hmat(NxM) = Fourier( huu(NxM) )
//
gsl_blas_zgemm(CblasNoTrans,
CblasNoTrans,
gsl_complex_rect(1,0),
transform_mat,
huu,
gsl_complex_rect(0,0),
Hmat);
#ifdef SHOW_MATRIX
cout << "Hmat(freq,user) (frame:" << framecount << ") = " << endl;
gsl_matrix_complex_show(Hmat);
#endif
//
// ***********************************************************
// CARRIER ALLOCATION STRATEGIES
// ***********************************************************
//
switch (Mode()) {
case 0: // FIXED_ALLOCATION
break;
case 1: // GIVE_BEST_CARR
//
// SORT CARRIERS OF EACH USERS
//
// uses Hmat: the frequency responses of channel tx_n --> rx_n
//
// starting from user u ...
// find the best (in u ranking) unused carrier and assign it to u
// next user until no more available carriers
for(int u=0; u<M(); u++) { // cycle through users
gsl_vector_complex_const_view huser
= gsl_matrix_complex_const_column(Hmat,u);
gsl_vector_uint_view sortindu = gsl_matrix_uint_column(Hperm,u);
for (int j=0; j<N(); j++) {
double currpower
= gsl_complex_abs2(gsl_vector_complex_get(&huser.vector,j));
gsl_vector_set(huserabs,j,currpower);
}
// sort over c using abs(h(u,c))
gsl_sort_vector_index(p,huserabs);
for (int j=0; j<N(); j++) {
uint currindex = p->data[j];
gsl_vector_uint_set(&sortindu.vector,j,currindex);
}
}
//
// FIND INITIAL USER RANDOMLY
//
curruser = gsl_rng_uniform_int(ran,M());
//
// ASSIGN FREQUENCIES
//
gsl_vector_uint_set_all(nextcarr,0);
gsl_vector_uint_set_all(usedcarr,0);
for (int j=0; j<J(); j++) {
for (int uu=0; uu<M(); uu++) {
int u = (uu+curruser) % M();
int isassigned = 0;
while (! isassigned) {
int tag = gsl_vector_uint_get(nextcarr,u);
gsl_vector_uint_set(nextcarr,u,++tag);
int carrier = gsl_matrix_uint_get(Hperm,N()-tag,u);
if (! gsl_vector_uint_get(usedcarr,carrier)) {
isassigned = 1;
gsl_vector_uint_set(usedcarr,carrier,isassigned);
gsl_matrix_uint_set(signature_frequencies,u,j,carrier);
} else if (tag==N()) {
cerr << "Block: " << BlockName << " allocation problem." << endl;
exit(1);
}
}
}
}
//
// show channels and permutations
//
// gsl_matrix_complex_show(Hmat);
//gsl_matrix_uint_show(Hperm);
//gsl_matrix_uint_show(signature_frequencies);
break;
case 2: // SWAP_BAD_GOOD
//
// SWAP_BAD_GOOD
//
// sort carriers for each user
// choose randomly a starting user u
// for each user starting with u
// swap worst carrier used by u with best carrier if used by others
// sort carriers
for(int u=0; u<M(); u++) {
gsl_vector_complex_const_view huser
= gsl_matrix_complex_const_column(Hmat,u);
gsl_vector_uint_view sortindu = gsl_matrix_uint_column(Hperm,u);
gsl_vector_view huserabs = gsl_matrix_column(habs,u);
for (int j=0; j<N(); j++) {
double currpower
= gsl_complex_abs2(gsl_vector_complex_get(&huser.vector,j));
gsl_vector_set(&huserabs.vector,j,currpower);
}
//
// sort channels for user <u>
//
gsl_sort_vector_index(p,&huserabs.vector);
for (int j=0; j<N(); j++) {
uint currindex = p->data[j];
gsl_vector_uint_set(&sortindu.vector,j,currindex);
}
}
//
// Hperm(N,USERS) contains sorted channels index for each users
// habs(N,USERS) contains channel energy per each user
//
//
// FIND INITIAL USER RANDOMLY for fairness
//
curruser = gsl_rng_uniform_int(ran,M());
//
// ASSIGN FREQUENCIES
//
//
// for each user ...
//
for (int uu=0; uu<M(); uu++) {
int u = (uu+curruser) % M();
//
// worst allocated channel for user u
//
double worstvalue=GSL_POSINF;
unsigned int worstjindex;
for (int j=0; j<J(); j++) {
unsigned int chind = gsl_matrix_uint_get(signature_frequencies,u,j);
double currh = gsl_matrix_get(habs,chind,u);
if (currh < worstvalue) {
worstvalue = currh;
worstjindex = j;
}
}
//
// find best channel allocated by other users
//
//
double bestvalue=0;
unsigned int bestuser, bestjindex;
for (int uuu=0; uuu<M()-1; uuu++) {
unsigned int otheru = (uuu+u) % M();
for (int j=0; j<J(); j++) {
unsigned int chind
= gsl_matrix_uint_get(signature_frequencies,otheru,j);
double currh = gsl_matrix_get(habs,chind,otheru);
if (currh > bestvalue) {
bestvalue = currh;
bestjindex = j;
bestuser = otheru;
}
}
}
//
// finally the swap !
//
unsigned int chind
= gsl_matrix_uint_get(signature_frequencies,u,worstjindex);
gsl_matrix_uint_set(signature_frequencies,u,worstjindex,
gsl_matrix_uint_get(signature_frequencies,
bestuser,bestjindex));
gsl_matrix_uint_set(signature_frequencies,bestuser,bestjindex,chind);
// cout << "\n\nProcessing user " << u << endl
// << "\tSwapped " << u << "." << worstjindex
// << " <-> " << bestuser << "." << bestjindex << endl;
}
break;
case 3: // BEST_OVERLAP
//
// SORT CARRIERS OF EACH USERS
//
gsl_matrix_uint_memcpy(signature_frequencies,
signature_frequencies_init);
for(int u=0; u<M(); u++) {
gsl_vector_complex_const_view huser
= gsl_matrix_complex_const_column(Hmat,u);
gsl_vector_uint_view sortindu = gsl_matrix_uint_column(Hperm,u);
for (int j=0; j<N(); j++) {
double currpower = gsl_complex_abs2(gsl_vector_complex_get(&huser.vector,
j));
gsl_vector_set(huserabs,j,currpower);
}
gsl_sort_vector_index(p,huserabs);
for (int j=0; j<N(); j++) {
uint currindex = p->data[j];
gsl_vector_uint_set(&sortindu.vector,j,currindex);
}
}
//
// each user take his best carriers allowing carrier overlap
//
for (int u=0; u<M(); u++) {
for (int j=0; j<J(); j++) {
int carrier = gsl_matrix_uint_get(Hperm,N()-j-1,u);
gsl_matrix_uint_set(signature_frequencies,u,j,carrier);
}
}
//
// show channels and permutations
//
//gsl_matrix_complex_show(Hmat);
//gsl_matrix_uint_show(Hperm);
//gsl_matrix_uint_show(signature_frequencies);
break;
case 4: // SOAR_AI
//
// SOAR
//
// agent crai5
// bases the decisions on the frequency response tx_m --> rx_m in Hmat(N,M)
// for each user it proposes a swap between carriers if the instantaneous impulse channel response
// is better
//
// agent crai6
// for each user it proposes a swap of allocated carriers with one other users
// error report is the metric for correct decisions (RL)
#ifdef PAUSED
// keypress
cout << "pause maillocator: before decision loop ... (press ENTER key)" << endl;
cin.ignore();
#endif
// Every DECISION_INTERVAL we increase the input-time and allow decisions
if (framecount % DECISION_INTERVAL == 0) {
pAgent->Update(inputTime,++input_time);
pAgent->Commit();
}
// run agent till output
noDecisions = 0;
numberCommands=0;
while (! (noDecisions) ) { // main decisional loop
//
// INPUT LINK Update
//
UpdateInputLink();
//pAgent->RunSelf(1);
pAgent->RunSelfTilOutput();
numberCommands = pAgent->GetNumberCommands() ;
#ifdef PAUSED
// keypress
cout << "pause maillocator: after RunSelfTilOutput() ... (press ENTER key)" << endl;
cin.ignore();
#endif
// loop through received commands
for (int cmd = 0 ; cmd < numberCommands ; cmd++) {
Identifier* pCommand = pAgent->GetCommand(cmd) ;
string name = pCommand->GetCommandName() ;
if (name == "assign-free") {
std::string sUid = pCommand->GetParameterValue("uid");
std::string sDeassign = pCommand->GetParameterValue("deassign");
std::string sAssign = pCommand->GetParameterValue("assign");
#ifdef SHOW_SOAR
cout << "assign-free command received [ u:"
<< sUid << " , -"
<< sDeassign << " , +"
<< sAssign << " ]"
<< endl;
#endif
AssignFree(sUid,sDeassign,sAssign);
pCommand->AddStatusComplete();
} else if (name == "swap-carriers") {
std::string sU1 = pCommand->GetParameterValue("u1");
std::string sC1 = pCommand->GetParameterValue("c1");
std::string sU2 = pCommand->GetParameterValue("u2");
std::string sC2 = pCommand->GetParameterValue("c2");
#ifdef SHOW_SOAR
cout << "swap-carriers command received [ u1:"
<< sU1 << " , c1:"
<< sC1 << " , u2:"
<< sU2 << " , c2:"
<< sC2 << " ]" << endl;
#endif
SwapCarriers(sU1,sC1,sU2,sC2);
pCommand->AddStatusComplete();
} else if (name == "increase-power") {
std::string sUid = pCommand->GetParameterValue("uid");
std::string sCid = pCommand->GetParameterValue("cid");
#ifdef SHOW_SOAR
cout << "increase-power command received [ u:"
<< sUid << " , c:"
<< sCid << " ]" << endl;
#endif
IncreasePower(sUid,sCid);
pCommand->AddStatusComplete();
break;
} else if (name == "no-choices") {
#ifdef SHOW_SOAR
cout << "no-choices command received" << endl;
#endif
noDecisions = 1;
pCommand->AddStatusComplete();
break;
} else {
#ifdef SHOW_SOAR
cout << "ignoring unknown output command from SOAR" << endl;
#endif
break;
}
// cout << "framecount = " << framecount << endl;
} // end command loop
} // while (! (noDecisions) )
break;
} // switch (Mode())
} // if DECISION_INTERVAL % 0
//
// every 10s dump frame count
//
time(&nowtime);
if (difftime(nowtime,reporttime) > TIMEDELTA) {
reporttime = nowtime;
cout << "frame:" << framecount << "\r";
cout.flush();
}
//////// production of data
framecount++;
ericount++;
mout1.DeliverDataObj( *signature_frequencies );
mout2.DeliverDataObj( *signature_powers );
#ifdef SHOW_MATRIX
cout << "signature frequencies (frame:" << framecount-1 << ") = " << endl;
gsl_matrix_uint_show(signature_frequencies);
#endif
}