void PLA_clu( int *m, int *n, PLA_COMPLEX *a, int *lda, int *pivot )
{
int
j, index, m_min_j_p_1, m_min_j, n_min_j, i_one = 1, i_four = 4;
PLA_COMPLEX
ajj_inv, minus_one = {-1.0, 0.0};
for ( j=1; j<=min( *n, *m ); j++ ){
m_min_j_p_1 = *m-j+1;
m_min_j = *m-j;
n_min_j = *n-j;
index = PLA_icamax( &m_min_j_p_1, &A(j,j,*lda), &i_one );
Piv(j) = index-1;
PLA_cswap( n, &A(j,1,*lda), lda, &A(j+index-1,1,*lda), lda );
ajj_inv = complex_inverse( A(j,j,*lda) );
PLA_cscal( &m_min_j, &ajj_inv, &A(j+1,j,*lda), &i_one );
PLA_cger( &m_min_j, &n_min_j, &minus_one, &A(j+1,j,*lda), &i_one,
&A(j,j+1,*lda), lda, &A(j+1,j+1,*lda ), lda );
}
}
/* poly: pointer to coefficients array of size degree + 1.
* results: pointer to results output array of size degree.
*/
int solve_poly(int degree, const complex_t* poly, complex_t* results) {
complex_t normalized_poly[MAX_DEGREE + 1];
int i;
const complex_t a = poly[degree];
if (complex_eq(a, complex_from_real(0.0)))
return solve_poly(degree - 1, poly, results);
if (degree > MAX_DEGREE)
return -1;
if (degree > 2 && stableness_score(poly[degree], poly[degree - 1]) > stableness_score(poly[0], poly[1])) {
complex_t rev_poly[MAX_DEGREE + 1];
int num_results;
for (i = 0; i <= degree; ++i)
rev_poly[i] = poly[degree - i];
num_results = solve_poly(degree, rev_poly, results);
for (i = 0; i < num_results; ++i)
results[i] = complex_inverse(results[i]);
return num_results;
}
for (i = 0; i < degree; ++i)
normalized_poly[i] = complex_div(poly[i], a);
normalized_poly[degree] = complex_from_real(1.0);
return solve_normalized_poly(degree, normalized_poly, results);
}
static complex_t complex_div(complex_t a, complex_t b) {
return complex_mult(a, complex_inverse(b));
}
int main()
{
srand (time(NULL));
int i,j;
double sigma;
unsigned int *X = random_X (NUM_BLOCKS*NUM_CARRIERS);
complex_table *IP_SIG = (complex_table *) malloc (sizeof(complex_table));
complex_table_init (IP_SIG,NUM_CARRIERS,NUM_BLOCKS,"IP_SIG");
create_IP_BLOCKS (IP_SIG,X,ALPHA,PI);
complex_table *CARRIERS = (complex_table *) malloc (sizeof(complex_table));
complex_table_init (CARRIERS,NUM_BLOCKS,NUM_CARRIERS,"CARRIERS");
create_CARRIERS (CARRIERS);
print_table (CARRIERS);
complex_table *CARRIERST = (complex_table *) malloc (sizeof(complex_table));
complex_table_init (CARRIERST,NUM_CARRIERS,NUM_BLOCKS,"CARRIERST");
TRANSPOSE (CARRIERS,CARRIERST);
//print_table (CARRIERST);
//printf("\nrows : %d\tcolumns : %d",CARRIERST->rows,CARRIERST->columns);
complex_table *CORRELATION = (complex_table *) malloc (sizeof(complex_table));
complex_table_init (CORRELATION,CARRIERST->columns,CARRIERST->columns,"CORRELATION");
CORRELATET (CARRIERST,CORRELATION);
//print_table (CORRELATION);
complex_table *MODI = (complex_table *) malloc (sizeof(complex_table));
complex_table_init (MODI,NUM_BLOCKS,NUM_BLOCKS,"MODI");
modulate (MODI,CARRIERS,IP_SIG);
sigma = complex_sigma (MODI);
complex_table *AWGN = (complex_table *) malloc (sizeof(complex_table));
complex_table_init (AWGN,NUM_BLOCKS*OVERSAMPLING,NUM_BLOCKS,"AWGN");
create_noise (AWGN,Eb,sigma,OVERSAMPLING);
complex_table *NOISY = (complex_table *) malloc (sizeof(complex_table));
complex_table_init (NOISY,NUM_BLOCKS,NUM_BLOCKS*OVERSAMPLING,"NOISY");
// printf("\nhere\n");
// create_noisy (NOISY,AWGN,MODI);
complex_addition (NOISY,AWGN,MODI);
complex_table *INVERSE = (complex_table *) malloc (sizeof(complex_table));
complex_table_init (INVERSE,CORRELATION->rows,CORRELATION->columns,"INVERSE");
complex_idenity_init (INVERSE);
complex_inverse (CORRELATION,INVERSE);
//print_table (CORRELATION);
/*for (i=0;i<NUM_BLOCKS;i++) {
o = column_from_table (IP_SIG,i);
complex_Ax (CARRIERS,SYMBOL,IP_BLOCK);
list_to_table (MODI,SYMBOL,i);
}*/
//inverse (CORRELATION,INVERSE);
// send result to table :end of loop calculate sigma
/*complex_list *IP_BLOCK = (complex_list *) malloc (sizeof(complex_list));
complex_list_init (IP_BLOCK);*/
// printf("\t%d\t%d\t:\t%.5lf\t%.5lf\t\n",mynode->col,mynode->row,mynode->real,mynode->imag);
//complex_table *SYMBOL_MODI = create_SYMBOL_MODI (CARRIERS,IP_BLOCK);
//complex_list *SEFDM_SYMBOL = (complex_list *) malloc (sizeof(complex_list));
//A_complex_x (CARRIERS,SEFDM_SYMBOL,IP_BLOCK);
//double SEFDM_SQUARED = complex
printf("\n\n");
printf("NUM_CARRIERS :\t\t%d \n",NUM_CARRIERS);
printf("MODULATION_LEVEL :\t%d \n",MODULATION_LEVEL);
printf("NUM_BLOCKS :\t\t%d \n",NUM_BLOCKS);
printf("ALPHA :\t\t\t%d \n",ALPHA);
printf("OVERSAMPLING :\t\t%d \n",OVERSAMPLING);
printf("Eb :\t\t\t%d \n",Eb);
//print_table (CARRIERS);
//print_table (CORRELATION);
/*
print_table (IP_SIG);
print_table (CARRIERS);
print_table (CORRELATION);
print_table (MODI);
print_table (AWGN);
print_table (NOISY);
print_table (INVERSE);
*/
return 0;
}
int PLA_Local_inv_scal(PLA_Obj alpha, PLA_Obj x)
{
int value = PLA_SUCCESS;
int original_error = 0;
int error_value, i;
int local_length_x, local_width_x, ld_x;
int ld_x_buf, stride_x, orientation_x;
MPI_Datatype datatype_x;
void *x_buffer, *x_buffer_cur, *alpha_buffer;
/* Perform parameter checking */
if ( PLA_ERROR_CHECKING ) /* Perform parameter and error checking */
value = PLA_Local_inv_scal_enter( alpha, x );
PLA_Obj_local_length(x, &local_length_x);
PLA_Obj_local_width (x, &local_width_x);
PLA_Obj_datatype(x, &datatype_x);
PLA_Obj_local_ldim(x, &ld_x);
PLA_Obj_local_stride(x, &stride_x);
PLA_Obj_project_onto(x, &orientation_x);
PLA_Obj_local_buffer(x, &x_buffer);
x_buffer_cur = x_buffer;
PLA_Obj_local_buffer(alpha, &alpha_buffer);
if(local_length_x * local_width_x > 0)
{
if( PLA_PROJ_ONTO_ROW == orientation_x )
{
if (MPI_DOUBLE == datatype_x){
double alpha_inv;
alpha_inv = 1.0/(*((double *) alpha_buffer));
for(i = 0; i < local_length_x; i++)
{
PLA_dscal(&local_width_x, &alpha_inv, (double*)x_buffer_cur, &ld_x);
x_buffer_cur = (void*)(((double*)x_buffer_cur)+stride_x);
}
}
else if(MPI_FLOAT == datatype_x){
float alpha_inv;
alpha_inv = 1.0/(*((float *) alpha_buffer));
for(i = 0; i < local_length_x; i++)
{
PLA_sscal(&local_width_x, &alpha_inv, (float*)x_buffer_cur, &ld_x);
x_buffer_cur = (void*)(((float*)x_buffer_cur)+stride_x);
}
}
else if(MPI_COMPLEX == datatype_x){
PLA_COMPLEX alpha_inverse;
alpha_inverse = complex_inverse( *( PLA_COMPLEX * ) alpha_buffer );
for(i = 0; i < local_length_x; i++)
{
PLA_cscal(&local_width_x, &alpha_inverse,
(PLA_COMPLEX*)x_buffer_cur, &ld_x);
x_buffer_cur = (void*)(((PLA_COMPLEX*)x_buffer_cur)+stride_x);
}
}
else if(MPI_DOUBLE_COMPLEX == datatype_x){
PLA_DOUBLE_COMPLEX alpha_inverse;
alpha_inverse = double_complex_inverse(
*( PLA_DOUBLE_COMPLEX * ) alpha_buffer );
for(i = 0; i < local_length_x; i++)
{
PLA_zscal(&local_width_x, &alpha_inverse,
(PLA_DOUBLE_COMPLEX*)x_buffer_cur, &ld_x);
x_buffer_cur = (void*)(((PLA_DOUBLE_COMPLEX*)x_buffer_cur)+stride_x);
}
}
}
else
{
if (MPI_DOUBLE == datatype_x){
double alpha_inv;
alpha_inv = 1.0/(*((double *) alpha_buffer));
for(i = 0; i < local_width_x; i++)
{
PLA_dscal(&local_length_x, &alpha_inv,
(double*)x_buffer_cur, &stride_x);
x_buffer_cur = (void*)(((double*)x_buffer_cur)+ld_x);
}
}
else if(MPI_FLOAT == datatype_x){
float alpha_inv;
alpha_inv = 1.0/(*((float *) alpha_buffer));
for(i = 0; i < local_width_x; i++)
{
PLA_sscal(&local_length_x, &alpha_inv,
(float*)x_buffer_cur, &stride_x);
x_buffer_cur = (void*)(((float*)x_buffer_cur)+ld_x);
}
}
else if(MPI_COMPLEX == datatype_x){
PLA_COMPLEX alpha_inverse;
alpha_inverse = complex_inverse(
*( PLA_COMPLEX * ) alpha_buffer );
for(i = 0; i < local_width_x; i++)
{
PLA_cscal(&local_length_x, &alpha_inverse,
(PLA_COMPLEX*)x_buffer_cur, &stride_x);
x_buffer_cur = (void*)(((PLA_COMPLEX*)x_buffer_cur)+ld_x); /*complex == 2 floats */
}
}
else if(MPI_DOUBLE_COMPLEX == datatype_x){
PLA_DOUBLE_COMPLEX alpha_inverse;
alpha_inverse = double_complex_inverse(
*( PLA_DOUBLE_COMPLEX * ) alpha_buffer );
for(i = 0; i < local_width_x; i++)
{
PLA_zscal(&local_length_x, &alpha_inverse,
(PLA_DOUBLE_COMPLEX*)x_buffer_cur, &stride_x);
x_buffer_cur =(void*)(((PLA_DOUBLE_COMPLEX*)x_buffer_cur)+ld_x);
}
}
}
}
if ( PLA_ERROR_CHECKING ) /* Perform parameter and error checking */
value = PLA_Local_inv_scal_exit( alpha, x );
return value;
}
