basic_parameters_1_ICD_issue1rev6_V1.c
625 lines
| 39.1 KiB
| text/x-c
|
CLexer
thomas
|
r0 | #include "basic_parameters_1_ICD_issue1rev6.h" | ||
#include <math.h> | ||||
#include <stdio.h> | ||||
float k44_pe = 1; | ||||
float k55_pe = 1; | ||||
float k45_pe_re = 1; | ||||
float k45_pe_im = 1; | ||||
float k14_sx_re = 1; | ||||
float k14_sx_im = 1; | ||||
float k15_sx_re = 1; | ||||
float k15_sx_im = 1; | ||||
float k24_sx_re = 1; | ||||
float k24_sx_im = 1; | ||||
float k25_sx_re = 1; | ||||
float k25_sx_im = 1; | ||||
float k34_sx_re = 1; | ||||
float k34_sx_im = 1; | ||||
float k35_sx_re = 1; | ||||
float k35_sx_im = 1; | ||||
float k24_ny_re = 1; | ||||
float k24_ny_im = 1; | ||||
float k25_ny_re = 1; | ||||
float k25_ny_im = 1; | ||||
float k34_ny_re = 1; | ||||
float k34_ny_im = 1; | ||||
float k35_ny_re = 1; | ||||
float k35_ny_im = 1; | ||||
float k24_nz_re = 1; | ||||
float k24_nz_im = 1; | ||||
float k25_nz_re = 1; | ||||
float k25_nz_im = 1; | ||||
float k34_nz_re = 1; | ||||
float k34_nz_im = 1; | ||||
float k35_nz_re = 1; | ||||
float k35_nz_im = 1; | ||||
float alpha_M = 45; | ||||
void BP1_set(){ | ||||
int i, j; | ||||
unsigned char tmp_u_char; | ||||
unsigned char *pt_u_char; | ||||
float significand; | ||||
int exponent; | ||||
float PSDB, PSDE; | ||||
float NVEC_V0, NVEC_V1, NVEC_V2; | ||||
float aux, tr_SB_SB, tmp; | ||||
float e_cross_b_re, e_cross_b_im; | ||||
float n_cross_e_scal_b_re = 0, n_cross_e_scal_b_im = 0; | ||||
float nx = 0, ny = 0; | ||||
float bz_bz_star = 0; | ||||
unsigned char toto_u_char; | ||||
unsigned char *pt_toto_u_char; | ||||
signed char toto_s_char; | ||||
float toto_f; | ||||
FILE *infile; | ||||
infile = fopen("sm_test1.dat", "rb"); // open explicitely a binary file !!! ... | ||||
if(infile == NULL) { | ||||
printf("Hello I cannot open the file!\n"); | ||||
return 0; | ||||
} | ||||
(void) fread(compressed_spectral_matrix_f0, sizeof(compressed_spectral_matrix_f0), 1, infile); | ||||
(void) fclose(infile); | ||||
//printf("size of compressed_spectral_matrix_f0 : %d\n", sizeof(compressed_spectral_matrix_f0)); | ||||
printf("compressed_spectral_matrix_f0 : \n"); | ||||
for (i = 0; i < 15; i++) { | ||||
printf("Element number %.2d (%.2d & %.2d) => Re:%16.8e Im:%16.8e\n", i+1, 2*i, 2*i+1, | ||||
compressed_spectral_matrix_f0[2*i], | ||||
compressed_spectral_matrix_f0[2*i+1]); | ||||
} | ||||
printf("Number of bins: %d\n", NB_BINS_COMPRESSED_MATRIX_f0); | ||||
printf("BP1 : \n"); | ||||
for(i=0; i<1; i++){ | ||||
//============================================== | ||||
// BP1 PSD == B PAR_LFR_SC_BP1_PB_F0 == 12 bits = 5 bits (exponent) + 7 bits (significand) | ||||
PSDB = compressed_spectral_matrix_f0[i*30] // S11 | ||||
+ compressed_spectral_matrix_f0[i*30+10] // S22 | ||||
+ compressed_spectral_matrix_f0[i*30+18]; // S33 | ||||
significand = frexpf(PSDB/3, &exponent); // 0.5 <= significand < 1 | ||||
// PSDB = significand * 2^exponent | ||||
// the division by 3 is to ensure that max value <= 2^30 | ||||
printf("PSDB : %16.8e\n",PSDB); | ||||
printf("significand : %16.8e\n",significand); | ||||
printf("exponent : %d\n" ,exponent); | ||||
if (exponent < 0) { // value is >= 0.5 * 2^0 (min value included) | ||||
exponent = 0; | ||||
significand = 0.5; // min value that can be recorded | ||||
} | ||||
if (exponent > 31) { // value is < 1.0 * 2^31 (max value excluded) | ||||
exponent = 31; | ||||
significand = 0.999; // max value that can be recorded | ||||
// (a minimum of 3 decimal is important !...) | ||||
} | ||||
if (significand == 0) {// in that case exponent == 0 too | ||||
significand = 0.5; // min value that can be recorded | ||||
} | ||||
LFR_BP1_F0[i*9+8] = (unsigned char) (significand*256 -128); // shift and cast into a 8-bit unsigned char | ||||
// where just the first 7 bits are used (0, ..., 127) | ||||
LFR_BP1_F0[i*9+7] = (unsigned char) exponent; // shift and cast into a 8-bit unsigned char | ||||
// where just the first 5 bits are used (0, ..., 31) | ||||
printf("LFR_BP1_F0[i*9+8] for PSDB significand : %u\n",LFR_BP1_F0[i*9+8]); | ||||
printf("LFR_BP1_F0[i*9+7] for PSDB exponent : %u\n",LFR_BP1_F0[i*9+7]); | ||||
//toto_f = 32768*32768; // max value ? | ||||
//significand = frexp(toto_f, &exponent); | ||||
//printf("toto_f : %16.8e\n",toto_f); | ||||
//printf("significand : %16.8e\n",significand); | ||||
//printf("exponent : %d\n" ,exponent); | ||||
//============================================== | ||||
// BP1 PSD == E PAR_LFR_SC_BP1_PE_F0 == 12 bits = 5 bits (exponent) + 7 bits (significand) | ||||
PSDE = compressed_spectral_matrix_f0[i*30+24] * k44_pe // S44 | ||||
+ compressed_spectral_matrix_f0[i*30+28] * k55_pe // S55 | ||||
+ compressed_spectral_matrix_f0[i*30+26] * k45_pe_re // S45 Re | ||||
- compressed_spectral_matrix_f0[i*30+27] * k45_pe_im; // S45 Im | ||||
significand = frexpf(PSDE/2, &exponent); // 0.5 <= significand < 1 | ||||
// PSDE = significand * 2^exponent | ||||
// the division by 2 is to ensure that max value < 2^31 | ||||
printf("PSDE : %16.8e\n",PSDE); | ||||
printf("significand : %16.8e\n",significand); | ||||
printf("exponent : %d\n" ,exponent); | ||||
if (exponent < 0) { // value is >= 0.5 * 2^0 (min value included) | ||||
exponent = 0; | ||||
significand = 0.5; // min value that can be recorded | ||||
} | ||||
if (exponent > 31) { // value is < 1.0 * 2^31 (max value excluded) | ||||
exponent = 31; | ||||
significand = 0.999; // max value that can be recorded | ||||
// (a minimum of 3 decimal is important !...) | ||||
} | ||||
if (significand == 0) {// in that case exponent == 0 too | ||||
significand = 0.5; // min value that can be recorded | ||||
} | ||||
LFR_BP1_F0[i*9+6] = (unsigned char) (significand*256 -128); // shift and cast into a 8-bit unsigned char | ||||
// where just the first 7 bits are used (0, ..., 127) | ||||
LFR_BP1_F0[i*9+5] = (unsigned char) exponent; // shift and cast into a 8-bit unsigned char | ||||
// where just the first 5 bits are used (0, ..., 31) | ||||
printf("LFR_BP1_F0[i*9+6] for PSDE significand : %u\n",LFR_BP1_F0[i*9+6]); | ||||
printf("LFR_BP1_F0[i*9+5] for PSDE exponent : %u\n",LFR_BP1_F0[i*9+5]); | ||||
//toto_f = 1./3; // min value ? | ||||
//significand = frexp(toto_f, &exponent); | ||||
//printf("toto_f : %16.8e\n",toto_f); | ||||
//printf("significand : %16.8e\n",significand); | ||||
//printf("exponent : %d\n" ,exponent); | ||||
//============================================================================== | ||||
// BP1 normal wave vector == PAR_LFR_SC_BP1_NVEC_V0_F0 == 8 bits | ||||
// == PAR_LFR_SC_BP1_NVEC_V1_F0 == 8 bits | ||||
// == PAR_LFR_SC_BP1_NVEC_V2_F0 == 1 sign bit | ||||
tmp = sqrt( compressed_spectral_matrix_f0[i*30+3] *compressed_spectral_matrix_f0[i*30+3] //Im S12 | ||||
+compressed_spectral_matrix_f0[i*30+5] *compressed_spectral_matrix_f0[i*30+5] //Im S13 | ||||
+compressed_spectral_matrix_f0[i*30+13]*compressed_spectral_matrix_f0[i*30+13] //Im S23 | ||||
); | ||||
NVEC_V0 = compressed_spectral_matrix_f0[i*30+13]/ tmp; // Im S23 | ||||
NVEC_V1 = -compressed_spectral_matrix_f0[i*30+5] / tmp; // Im S13 | ||||
NVEC_V2 = compressed_spectral_matrix_f0[i*30+3] / tmp; // Im S12 | ||||
printf("NVEC_V0 : %16.8e\n",NVEC_V0); | ||||
printf("NVEC_V1 : %16.8e\n",NVEC_V1); | ||||
printf("NVEC_V2 : %16.8e\n",NVEC_V2); | ||||
LFR_BP1_F0[i*9+4] = (unsigned char) (NVEC_V0*127.5 + 128); // shift and cast into a 8-bit unsigned char (0, ..., 255) with rounding | ||||
LFR_BP1_F0[i*9+3] = (unsigned char) (NVEC_V1*127.5 + 128); // shift and cast into a 8-bit unsigned char (0, ..., 255) with rounding | ||||
pt_u_char = (unsigned char*) &NVEC_V2; // affect an unsigned char pointer with the adress of NVEC_V2 | ||||
LFR_BP1_F0[i*9+2] = pt_u_char[3] & 0x80; // extract the sign bit of NVEC_V2 (32-bit float, sign bit in the 4th octet) | ||||
// record it at the 8th bit position of LFR_BP1_F0[i*9+2] | ||||
printf("LFR_BP1_F0[i*9+4] for NVEC_V0 : %u\n",LFR_BP1_F0[i*9+4]); | ||||
printf("LFR_BP1_F0[i*9+3] for NVEC_V1 : %u\n",LFR_BP1_F0[i*9+3]); | ||||
printf("LFR_BP1_F0[i*9+2] for NVEC_V2 : %u\n",LFR_BP1_F0[i*9+2]); | ||||
//toto_f = 128.9999 ; | ||||
//toto_s_char = (signed char) toto_f; | ||||
//printf("toto_s_char : %d\n",toto_s_char); | ||||
//toto_f = 255.999 ; | ||||
//toto_u_char = (unsigned char) (toto_f); | ||||
//printf("toto_u_char : %d\n",toto_u_char); | ||||
//toto_f = -1110.999 ; | ||||
//pt_toto_u_char = (unsigned char*) &toto_f; | ||||
//printf("pt_toto_u_char : %u\n", pt_toto_u_char[3] & 0x80); | ||||
//======================================================= | ||||
// BP1 ellipticity == PAR_LFR_SC_BP1_ELLIP_F0 == 4 bits | ||||
aux = 2*tmp / PSDB; // compute the ellipticity | ||||
printf("ellipticity : %16.8e\n",aux); | ||||
tmp_u_char = (unsigned char) (aux*15.999);// shift and cast into a 8-bit unsigned char | ||||
// where just the first 4 bits are used (0, ..., 15) | ||||
LFR_BP1_F0[i*9+2] = LFR_BP1_F0[i*9+2] | (tmp_u_char << 3); // put these 4 bits next to the right place | ||||
// of the sign bit of NVEC_V2 (recorded | ||||
// previously in LFR_BP1_F0[i*9+2]) | ||||
printf("tmp_u_char for ellipticity : %u\n",tmp_u_char); | ||||
printf("LFR_BP1_F0[i*9+2] for NVEC_V2 + ellipticity : %u\n",LFR_BP1_F0[i*9+2]); | ||||
//============================================================== | ||||
// BP1 degree of polarization == PAR_LFR_SC_BP1_DOP_F0 == 3 bits | ||||
tr_SB_SB = compressed_spectral_matrix_f0[i*30] *compressed_spectral_matrix_f0[i*30] | ||||
+ compressed_spectral_matrix_f0[i*30+10]*compressed_spectral_matrix_f0[i*30+10] | ||||
+ compressed_spectral_matrix_f0[i*30+18]*compressed_spectral_matrix_f0[i*30+18] | ||||
+ 2 * compressed_spectral_matrix_f0[i*30+2] *compressed_spectral_matrix_f0[i*30+2] | ||||
+ 2 * compressed_spectral_matrix_f0[i*30+3] *compressed_spectral_matrix_f0[i*30+3] | ||||
+ 2 * compressed_spectral_matrix_f0[i*30+4] *compressed_spectral_matrix_f0[i*30+4] | ||||
+ 2 * compressed_spectral_matrix_f0[i*30+5] *compressed_spectral_matrix_f0[i*30+5] | ||||
+ 2 * compressed_spectral_matrix_f0[i*30+12]*compressed_spectral_matrix_f0[i*30+12] | ||||
+ 2 * compressed_spectral_matrix_f0[i*30+13]*compressed_spectral_matrix_f0[i*30+13]; | ||||
aux = PSDB*PSDB; // compute the degree of polarisation | ||||
tmp = ( 3*tr_SB_SB - aux ) / ( 2 * aux ); | ||||
printf("DOP : %16.8e\n",tmp); | ||||
tmp_u_char = (unsigned char) (tmp*7.999);// shift and cast into a 8-bit unsigned char | ||||
// where just the first 3 bits are used (0, ..., 7) | ||||
LFR_BP1_F0[i*9+2] = LFR_BP1_F0[i*9+2] | tmp_u_char; // record these 3 bits at the 3 first | ||||
// bit positions of LFR_BP1_F0[i*9+2] | ||||
printf("tmp_u_char for DOP : %u\n",tmp_u_char); | ||||
printf("LFR_BP1_F0[i*9+2] for NVEC_V2 + ellipticity + DOP : %u\n",LFR_BP1_F0[i*9+2]); | ||||
//======================================================================================= | ||||
// BP1 X_SO-component of the Poynting flux == PAR_LFR_SC_BP1_SX_F0 == 12 bits | ||||
// = 5 bits (exponent) + 5 bits (significand) | ||||
// + 1 sign bit + 1 argument bit (two sectors) | ||||
e_cross_b_re = compressed_spectral_matrix_f0[i*30+20]*k34_sx_re | ||||
+ compressed_spectral_matrix_f0[i*30+22]*k35_sx_re | ||||
+ compressed_spectral_matrix_f0[i*30+6] *k14_sx_re | ||||
+ compressed_spectral_matrix_f0[i*30+8] *k15_sx_re | ||||
+ compressed_spectral_matrix_f0[i*30+14]*k24_sx_re | ||||
+ compressed_spectral_matrix_f0[i*30+16]*k25_sx_re | ||||
+ compressed_spectral_matrix_f0[i*30+21]*k34_sx_im | ||||
+ compressed_spectral_matrix_f0[i*30+23]*k35_sx_im | ||||
+ compressed_spectral_matrix_f0[i*30+7] *k14_sx_im | ||||
+ compressed_spectral_matrix_f0[i*30+9] *k15_sx_im | ||||
+ compressed_spectral_matrix_f0[i*30+15]*k24_sx_im | ||||
+ compressed_spectral_matrix_f0[i*30+17]*k25_sx_im; | ||||
// Im(S_ji) = -Im(S_ij) | ||||
// k_ji = k_ij | ||||
e_cross_b_im = compressed_spectral_matrix_f0[i*30+20]*k34_sx_im | ||||
+ compressed_spectral_matrix_f0[i*30+22]*k35_sx_im | ||||
+ compressed_spectral_matrix_f0[i*30+6] *k14_sx_im | ||||
+ compressed_spectral_matrix_f0[i*30+8] *k15_sx_im | ||||
+ compressed_spectral_matrix_f0[i*30+14]*k24_sx_im | ||||
+ compressed_spectral_matrix_f0[i*30+16]*k25_sx_im | ||||
- compressed_spectral_matrix_f0[i*30+21]*k34_sx_re | ||||
- compressed_spectral_matrix_f0[i*30+23]*k35_sx_re | ||||
- compressed_spectral_matrix_f0[i*30+7] *k14_sx_re | ||||
- compressed_spectral_matrix_f0[i*30+9] *k15_sx_re | ||||
- compressed_spectral_matrix_f0[i*30+15]*k24_sx_re | ||||
- compressed_spectral_matrix_f0[i*30+17]*k25_sx_re; | ||||
printf("ReaSX : %16.8e\n",e_cross_b_re); | ||||
pt_u_char = (unsigned char*) &e_cross_b_re; // affect an unsigned char pointer with the adress of e_cross_b_re | ||||
//LFR_BP1_F0[i*9+7] = LFR_BP1_F0[i*9+7] | (pt_u_char[3] & 0x80); // extract the sign bit of e_cross_b_re (32-bit float, sign bit in the 4th octet) | ||||
// record it at the 8th bit position of LFR_BP1_F0[i*9+7] | ||||
pt_u_char[3] = pt_u_char[3] & 0x7f; // make e_cross_b_re be positive in any case: |ReaSX| | ||||
significand = frexpf(e_cross_b_re, &exponent); | ||||
printf("|ReaSX| : %16.8e\n",e_cross_b_re); | ||||
printf("significand : %16.8e\n",significand); | ||||
printf("exponent : %d\n" ,exponent); | ||||
//printf("LFR_BP1_F0[i*9+7] for PSDB exponent + ReaSX sign : %u\n",LFR_BP1_F0[i*9+7]); | ||||
LFR_BP1_F0[i*9+1] = (unsigned char) (significand*64 -32); // shift and cast into a 8-bit unsigned char | ||||
// where just the first 5 bits are used (0, ..., 31) | ||||
LFR_BP1_F0[i*9+1] = (unsigned char) exponent+28; // shift and cast into a 8-bit unsigned char | ||||
// where just the first 6 bits are used (0, ..., 63) | ||||
// à réfléchir ... | ||||
// tmp = e_cross_b_re * e_cross_b_im; | ||||
// pt_char = (unsigned char*) &tmp; | ||||
// LFR_BP1_F0[i*9+1] = LFR_BP1_F0[i*9+1] | (pt_char[0] & 0x80); // extract the sign of ArgSz | ||||
printf("ImaSX : %16.8e\n",e_cross_b_im); | ||||
pt_u_char = (unsigned char*) &e_cross_b_im; // affect an unsigned char pointer with the adress of e_cross_b_im | ||||
pt_u_char[3] = pt_u_char[3] & 0x7f; // make e_cross_b_im be positive in any case: |ImaSX| | ||||
tmp_u_char = (e_cross_b_im > e_cross_b_re) ? 0x40 : 0x00; // determine the sector argument of SX | ||||
//LFR_BP1_F0[i*9+7] = LFR_BP1_F0[i*9+7] | tmp_u_char; // record it as a sign bit at the 7th bit position of LFR_BP1_F0[i*9+7] | ||||
printf("|ImaSX| : %16.8e\n",e_cross_b_im); | ||||
printf("argSX sign : %d\n",tmp_u_char); | ||||
//printf("LFR_BP1_F0[i*9+7] for PSDB exponent + ReaSX sign + argSX sign: %u\n",LFR_BP1_F0[i*9+7]); | ||||
//====================================================================== | ||||
//====================================================================== | ||||
} | ||||
} | ||||
void BP2_set(){ | ||||
int i, exponent; | ||||
float aux, significand, cross_re, cross_im; | ||||
signed char nbitexp, nbitsig, expmin, expmax; // 8 bits | ||||
short int rangesig; // 16 bits | ||||
unsigned short int autocor, tmp_u_short_int; // 16 bits | ||||
unsigned short int *pt_u_short_int; // pointer on unsigned 16-bit words | ||||
printf("Number of bins: %d\n", NB_BINS_COMPRESSED_MATRIX_f0); | ||||
printf("BP2 : \n"); | ||||
// For floating point data to be recorded on 16-bit words : | ||||
nbitexp = 6; // number of bits for the exponent | ||||
nbitsig = 16 - nbitexp; // number of bits for the significand | ||||
rangesig = (1 << nbitsig)-1; // == 2^nbitsig - 1 | ||||
printf("nbitexp : %d, nbitsig : %d, rangesig : %d\n", nbitexp, nbitsig, rangesig); | ||||
expmax = 32; | ||||
expmin = expmax - (1 << nbitexp) + 1; | ||||
printf("expmin : %d, expmax : %d\n", expmin, expmax); | ||||
for(i = 0; i<1; i++){ | ||||
//============================================== | ||||
// BP2 normalized cross correlations == PA_LFR_SC_BP2_CROSS_F0 == 10 * (8+8) bits | ||||
// == PA_LFR_SC_BP2_CROSS_RE_0_F0 == 8 bits | ||||
// == PA_LFR_SC_BP2_CROSS_IM_0_F0 == 8 bits | ||||
// == PA_LFR_SC_BP2_CROSS_RE_1_F0 == 8 bits | ||||
// == PA_LFR_SC_BP2_CROSS_IM_1_F0 == 8 bits | ||||
// == PA_LFR_SC_BP2_CROSS_RE_2_F0 == 8 bits | ||||
// == PA_LFR_SC_BP2_CROSS_IM_2_F0 == 8 bits | ||||
// == PA_LFR_SC_BP2_CROSS_RE_3_F0 == 8 bits | ||||
// == PA_LFR_SC_BP2_CROSS_IM_3_F0 == 8 bits | ||||
// == PA_LFR_SC_BP2_CROSS_RE_4_F0 == 8 bits | ||||
// == PA_LFR_SC_BP2_CROSS_IM_4_F0 == 8 bits | ||||
// == PA_LFR_SC_BP2_CROSS_RE_5_F0 == 8 bits | ||||
// == PA_LFR_SC_BP2_CROSS_IM_5_F0 == 8 bits | ||||
// == PA_LFR_SC_BP2_CROSS_RE_6_F0 == 8 bits | ||||
// == PA_LFR_SC_BP2_CROSS_IM_6_F0 == 8 bits | ||||
// == PA_LFR_SC_BP2_CROSS_RE_7_F0 == 8 bits | ||||
// == PA_LFR_SC_BP2_CROSS_IM_7_F0 == 8 bits | ||||
// == PA_LFR_SC_BP2_CROSS_RE_8_F0 == 8 bits | ||||
// == PA_LFR_SC_BP2_CROSS_IM_8_F0 == 8 bits | ||||
// == PA_LFR_SC_BP2_CROSS_RE_9_F0 == 8 bits | ||||
// == PA_LFR_SC_BP2_CROSS_IM_9_F0 == 8 bits | ||||
// S12 | ||||
aux = sqrt(compressed_spectral_matrix_f0[i*30]*compressed_spectral_matrix_f0[i*30+10]); | ||||
cross_re = compressed_spectral_matrix_f0[i*30+2] / aux; | ||||
cross_im = compressed_spectral_matrix_f0[i*30+3] / aux; | ||||
LFR_BP2_F0[i*30+19] = (unsigned char) (cross_re*127.5 + 128); // shift and cast into a 8-bit unsigned char (0, ..., 255) with rounding | ||||
LFR_BP2_F0[i*30+9] = (unsigned char) (cross_im*127.5 + 128); // shift and cast into a 8-bit unsigned char (0, ..., 255) with rounding | ||||
printf("LFR_BP2_F0[i*30+19] for cross12_re (%16.8e) : %u\n",cross_re, LFR_BP2_F0[i*30+19]); | ||||
printf("LFR_BP2_F0[i*30+9] for cross12_im (%16.8e) : %u\n",cross_im, LFR_BP2_F0[i*30+9]); | ||||
// S13 | ||||
aux = sqrt(compressed_spectral_matrix_f0[i*30]*compressed_spectral_matrix_f0[i*30+18]); | ||||
cross_re = compressed_spectral_matrix_f0[i*30+4] / aux; | ||||
cross_im = compressed_spectral_matrix_f0[i*30+5] / aux; | ||||
LFR_BP2_F0[i*30+18] = (unsigned char) (cross_re*127.5 + 128); // shift and cast into a 8-bit unsigned char (0, ..., 255) with rounding | ||||
LFR_BP2_F0[i*30+8] = (unsigned char) (cross_im*127.5 + 128); // shift and cast into a 8-bit unsigned char (0, ..., 255) with rounding | ||||
printf("LFR_BP2_F0[i*30+18] for cross13_re (%16.8e) : %u\n",cross_re, LFR_BP2_F0[i*30+18]); | ||||
printf("LFR_BP2_F0[i*30+8] for cross13_im (%16.8e) : %u\n",cross_im, LFR_BP2_F0[i*30+8]); | ||||
// S14 | ||||
aux = sqrt(compressed_spectral_matrix_f0[i*30]*compressed_spectral_matrix_f0[i*30+24]); | ||||
cross_re = compressed_spectral_matrix_f0[i*30+6] / aux; | ||||
cross_im = compressed_spectral_matrix_f0[i*30+7] / aux; | ||||
LFR_BP2_F0[i*30+17] = (unsigned char) (cross_re*127.5 + 128); // shift and cast into a 8-bit unsigned char (0, ..., 255) with rounding | ||||
LFR_BP2_F0[i*30+7] = (unsigned char) (cross_im*127.5 + 128); // shift and cast into a 8-bit unsigned char (0, ..., 255) with rounding | ||||
printf("LFR_BP2_F0[i*30+17] for cross14_re (%16.8e) : %u\n",cross_re, LFR_BP2_F0[i*30+17]); | ||||
printf("LFR_BP2_F0[i*30+7] for cross14_im (%16.8e) : %u\n",cross_im, LFR_BP2_F0[i*30+7]); | ||||
// S15 | ||||
aux = sqrt(compressed_spectral_matrix_f0[i*30]*compressed_spectral_matrix_f0[i*30+28]); | ||||
cross_re = compressed_spectral_matrix_f0[i*30+8] / aux; | ||||
cross_im = compressed_spectral_matrix_f0[i*30+9] / aux; | ||||
LFR_BP2_F0[i*30+16] = (unsigned char) (cross_re*127.5 + 128); // shift and cast into a 8-bit unsigned char (0, ..., 255) with rounding | ||||
LFR_BP2_F0[i*30+6] = (unsigned char) (cross_im*127.5 + 128); // shift and cast into a 8-bit unsigned char (0, ..., 255) with rounding | ||||
printf("LFR_BP2_F0[i*30+16] for cross15_re (%16.8e) : %u\n",cross_re, LFR_BP2_F0[i*30+16]); | ||||
printf("LFR_BP2_F0[i*30+6] for cross15_im (%16.8e) : %u\n",cross_im, LFR_BP2_F0[i*30+6]); | ||||
// S23 | ||||
aux = sqrt(compressed_spectral_matrix_f0[i*30+10]*compressed_spectral_matrix_f0[i*30+18]); | ||||
cross_re = compressed_spectral_matrix_f0[i*30+12] / aux; | ||||
cross_im = compressed_spectral_matrix_f0[i*30+13] / aux; | ||||
LFR_BP2_F0[i*30+15] = (unsigned char) (cross_re*127.5 + 128); // shift and cast into a 8-bit unsigned char (0, ..., 255) with rounding | ||||
LFR_BP2_F0[i*30+5] = (unsigned char) (cross_im*127.5 + 128); // shift and cast into a 8-bit unsigned char (0, ..., 255) with rounding | ||||
printf("LFR_BP2_F0[i*30+15] for cross23_re (%16.8e) : %u\n",cross_re, LFR_BP2_F0[i*30+15]); | ||||
printf("LFR_BP2_F0[i*30+5] for cross23_im (%16.8e) : %u\n",cross_im, LFR_BP2_F0[i*30+5]); | ||||
// S24 | ||||
aux = sqrt(compressed_spectral_matrix_f0[i*30+10]*compressed_spectral_matrix_f0[i*30+24]); | ||||
cross_re = compressed_spectral_matrix_f0[i*30+14] / aux; | ||||
cross_im = compressed_spectral_matrix_f0[i*30+15] / aux; | ||||
LFR_BP2_F0[i*30+14] = (unsigned char) (cross_re*127.5 + 128); // shift and cast into a 8-bit unsigned char (0, ..., 255) with rounding | ||||
LFR_BP2_F0[i*30+4] = (unsigned char) (cross_im*127.5 + 128); // shift and cast into a 8-bit unsigned char (0, ..., 255) with rounding | ||||
printf("LFR_BP2_F0[i*30+14] for cross24_re (%16.8e) : %u\n",cross_re, LFR_BP2_F0[i*30+14]); | ||||
printf("LFR_BP2_F0[i*30+4] for cross24_im (%16.8e) : %u\n",cross_im, LFR_BP2_F0[i*30+4]); | ||||
// S25 | ||||
aux = sqrt(compressed_spectral_matrix_f0[i*30+10]*compressed_spectral_matrix_f0[i*30+28]); | ||||
cross_re = compressed_spectral_matrix_f0[i*30+16] / aux; | ||||
cross_im = compressed_spectral_matrix_f0[i*30+17] / aux; | ||||
LFR_BP2_F0[i*30+13] = (unsigned char) (cross_re*127.5 + 128); // shift and cast into a 8-bit unsigned char (0, ..., 255) with rounding | ||||
LFR_BP2_F0[i*30+3] = (unsigned char) (cross_im*127.5 + 128); // shift and cast into a 8-bit unsigned char (0, ..., 255) with rounding | ||||
printf("LFR_BP2_F0[i*30+13] for cross25_re (%16.8e) : %u\n",cross_re, LFR_BP2_F0[i*30+13]); | ||||
printf("LFR_BP2_F0[i*30+3] for cross25_im (%16.8e) : %u\n",cross_im, LFR_BP2_F0[i*30+3]); | ||||
// S34 | ||||
aux = sqrt(compressed_spectral_matrix_f0[i*30+18]*compressed_spectral_matrix_f0[i*30+24]); | ||||
cross_re = compressed_spectral_matrix_f0[i*30+20] / aux; | ||||
cross_im = compressed_spectral_matrix_f0[i*30+21] / aux; | ||||
LFR_BP2_F0[i*30+12] = (unsigned char) (cross_re*127.5 + 128); // shift and cast into a 8-bit unsigned char (0, ..., 255) with rounding | ||||
LFR_BP2_F0[i*30+2] = (unsigned char) (cross_im*127.5 + 128); // shift and cast into a 8-bit unsigned char (0, ..., 255) with rounding | ||||
printf("LFR_BP2_F0[i*30+12] for cross34_re (%16.8e) : %u\n",cross_re, LFR_BP2_F0[i*30+12]); | ||||
printf("LFR_BP2_F0[i*30+2] for cross34_im (%16.8e) : %u\n",cross_im, LFR_BP2_F0[i*30+2]); | ||||
// S35 | ||||
aux = sqrt(compressed_spectral_matrix_f0[i*30+18]*compressed_spectral_matrix_f0[i*30+28]); | ||||
cross_re = compressed_spectral_matrix_f0[i*30+22] / aux; | ||||
cross_im = compressed_spectral_matrix_f0[i*30+23] / aux; | ||||
LFR_BP2_F0[i*30+11] = (unsigned char) (cross_re*127.5 + 128); // shift and cast into a 8-bit unsigned char (0, ..., 255) with rounding | ||||
LFR_BP2_F0[i*30+1] = (unsigned char) (cross_im*127.5 + 128); // shift and cast into a 8-bit unsigned char (0, ..., 255) with rounding | ||||
printf("LFR_BP2_F0[i*30+11] for cross35_re (%16.8e) : %u\n",cross_re, LFR_BP2_F0[i*30+11]); | ||||
printf("LFR_BP2_F0[i*30+1] for cross35_im (%16.8e) : %u\n",cross_im, LFR_BP2_F0[i*30+1]); | ||||
// S45 | ||||
aux = sqrt(compressed_spectral_matrix_f0[i*30+24]*compressed_spectral_matrix_f0[i*30+28]); | ||||
cross_re = compressed_spectral_matrix_f0[i*30+26] / aux; | ||||
cross_im = compressed_spectral_matrix_f0[i*30+27] / aux; | ||||
LFR_BP2_F0[i*30+10] = (unsigned char) (cross_re*127.5 + 128); // shift and cast into a 8-bit unsigned char (0, ..., 255) with rounding | ||||
LFR_BP2_F0[i*30+0] = (unsigned char) (cross_im*127.5 + 128); // shift and cast into a 8-bit unsigned char (0, ..., 255) with rounding | ||||
printf("LFR_BP2_F0[i*30+10] for cross45_re (%16.8e) : %u\n",cross_re, LFR_BP2_F0[i*30+10]); | ||||
printf("LFR_BP2_F0[i*30+0] for cross45_im (%16.8e) : %u\n",cross_im, LFR_BP2_F0[i*30+0]); | ||||
//============================================== | ||||
// BP2 auto correlations == PA_LFR_SC_BP2_AUTO_F0 == 5*16 bits = 5*[6 bits (exponent) + 10 bits (significand)] | ||||
// == PA_LFR_SC_BP2_AUTO_A0_F0 == 16 bits | ||||
// == PA_LFR_SC_BP2_AUTO_A1_F0 == 16 bits | ||||
// == PA_LFR_SC_BP2_AUTO_A2_F0 == 16 bits | ||||
// == PA_LFR_SC_BP2_AUTO_A3_F0 == 16 bits | ||||
// == PA_LFR_SC_BP2_AUTO_A4_F0 == 16 bits | ||||
// S11 | ||||
significand = frexpf(compressed_spectral_matrix_f0[i*30], &exponent); // 0.5 <= significand < 1 | ||||
// S11 = significand * 2^exponent | ||||
printf("S11 : %16.8e\n",compressed_spectral_matrix_f0[i*30]); | ||||
printf("significand : %16.8e\n",significand); | ||||
printf("exponent : %d\n" ,exponent); | ||||
if (exponent < expmin) { // value should be >= 0.5 * 2^expmin | ||||
exponent = expmin; | ||||
significand = 0.5; // min value that can be recorded | ||||
} | ||||
if (exponent > expmax) { // value should be < 0.5 * 2^(expmax+1) | ||||
exponent = expmax; | ||||
significand = 1.0; // max value that can be recorded | ||||
} | ||||
if (significand == 0) {// in that case exponent == 0 too | ||||
exponent = expmin; | ||||
significand = 0.5; // min value that can be recorded | ||||
} | ||||
autocor = (unsigned short int) ((significand*2-1)*rangesig + 0.5); // shift and cast into a 16-bit unsigned int with rounding | ||||
// where just the first nbitsig bits are used (0, ..., 2^nbitsig-1) | ||||
tmp_u_short_int = (unsigned short int) (exponent-expmin); // shift and cast into a 16-bit unsigned int | ||||
// where just the first nbitexp bits are used (0, ..., 2^nbitexp-1) | ||||
pt_u_short_int = (unsigned short int*) &LFR_BP2_F0[i*30+28]; // affect an unsigned short int pointer with the | ||||
// adress where the 16-bit word result will be stored | ||||
*pt_u_short_int = autocor | (tmp_u_short_int << nbitsig); // put the exponent bits (nbitexp) next to the | ||||
// left place of the significand bits (nbitsig), making | ||||
// the 16-bit word to be recorded, and record it using the pointer | ||||
//printf("size of autocor : %d\n",sizeof(autocor) ); | ||||
//printf("size of tmp_u_short_int : %d\n",sizeof(tmp_u_short_int) ); | ||||
printf("autocor for S11 significand : %u\n",autocor ); | ||||
printf("tmp_u_char for S11 exponent : %u\n",tmp_u_short_int ); | ||||
printf("*pt_u_short_int for S11 significand + exponent: %u or %x\n",*pt_u_short_int, *pt_u_short_int); | ||||
printf("LFR_BP2_F0[i*30+29] : %u or %x\n",LFR_BP2_F0[i*30+29], LFR_BP2_F0[i*30+29]); | ||||
printf("LFR_BP2_F0[i*30+28] : %u or %x\n",LFR_BP2_F0[i*30+28], LFR_BP2_F0[i*30+28]); | ||||
// S22 | ||||
significand = frexpf(compressed_spectral_matrix_f0[i*30+10], &exponent); // 0.5 <= significand < 1 | ||||
// S22 = significand * 2^exponent | ||||
printf("S22 : %16.8e\n",compressed_spectral_matrix_f0[i*30+10]); | ||||
printf("significand : %16.8e\n",significand); | ||||
printf("exponent : %d\n" ,exponent); | ||||
if (exponent < expmin) { // value should be >= 0.5 * 2^expmin | ||||
exponent = expmin; | ||||
significand = 0.5; // min value that can be recorded | ||||
} | ||||
if (exponent > expmax) { // value should be < 0.5 * 2^(expmax+1) | ||||
exponent = expmax; | ||||
significand = 1.0; // max value that can be recorded | ||||
} | ||||
if (significand == 0) {// in that case exponent == 0 too | ||||
exponent = expmin; | ||||
significand = 0.5; // min value that can be recorded | ||||
} | ||||
autocor = (unsigned short int) ((significand*2-1)*rangesig + 0.5); // shift and cast into a 16-bit unsigned int with rounding | ||||
// where just the first nbitsig bits are used (0, ..., 2^nbitsig-1) | ||||
tmp_u_short_int = (unsigned short int) (exponent-expmin); // shift and cast into a 16-bit unsigned int | ||||
// where just the first nbitexp bits are used (0, ..., 2^nbitexp-1) | ||||
pt_u_short_int = (unsigned short int*) &LFR_BP2_F0[i*30+26]; // affect an unsigned short int pointer with the | ||||
// adress where the 16-bit word result will be stored | ||||
*pt_u_short_int = autocor | (tmp_u_short_int << nbitsig); // put the exponent bits (nbitexp) next to the | ||||
// left place of the significand bits (nbitsig), making | ||||
// the 16-bit word to be recorded, and record it using the pointer | ||||
printf("autocor for S22 significand : %d\n",autocor ); | ||||
printf("tmp_u_char for S22 exponent : %d\n",tmp_u_short_int ); | ||||
printf("*pt_u_short_int for S22 significand + exponent: %d or %x\n",*pt_u_short_int, *pt_u_short_int); | ||||
printf("LFR_BP2_F0[i*30+27] : %d or %x\n",LFR_BP2_F0[i*30+27], LFR_BP2_F0[i*30+27]); | ||||
printf("LFR_BP2_F0[i*30+26] : %d or %x\n",LFR_BP2_F0[i*30+26], LFR_BP2_F0[i*30+26]); | ||||
// S33 | ||||
significand = frexpf(compressed_spectral_matrix_f0[i*30+18], &exponent); // 0.5 <= significand < 1 | ||||
// S33 = significand * 2^exponent | ||||
printf("S33 : %16.8e\n",compressed_spectral_matrix_f0[i*30+18]); | ||||
printf("significand : %16.8e\n",significand); | ||||
printf("exponent : %d\n" ,exponent); | ||||
if (exponent < expmin) { // value should be >= 0.5 * 2^expmin | ||||
exponent = expmin; | ||||
significand = 0.5; // min value that can be recorded | ||||
} | ||||
if (exponent > expmax) { // value should be < 0.5 * 2^(expmax+1) | ||||
exponent = expmax; | ||||
significand = 1.0; // max value that can be recorded | ||||
} | ||||
if (significand == 0) {// in that case exponent == 0 too | ||||
exponent = expmin; | ||||
significand = 0.5; // min value that can be recorded | ||||
} | ||||
autocor = (unsigned short int) ((significand*2-1)*rangesig + 0.5); // shift and cast into a 16-bit unsigned int with rounding | ||||
// where just the first nbitsig bits are used (0, ..., 2^nbitsig-1) | ||||
tmp_u_short_int = (unsigned short int) (exponent-expmin); // shift and cast into a 16-bit unsigned int | ||||
// where just the first nbitexp bits are used (0, ..., 2^nbitexp-1) | ||||
pt_u_short_int = (unsigned short int*) &LFR_BP2_F0[i*30+24]; // affect an unsigned short int pointer with the | ||||
// adress where the 16-bit word result will be stored | ||||
*pt_u_short_int = autocor | (tmp_u_short_int << nbitsig); // put the exponent bits (nbitexp) next to the | ||||
// left place of the significand bits (nbitsig), making | ||||
// the 16-bit word to be recorded, and record it using the pointer | ||||
printf("autocor for S33 significand : %d\n",autocor ); | ||||
printf("tmp_u_char for S33 exponent : %d\n",tmp_u_short_int ); | ||||
printf("*pt_u_short_int for S33 significand + exponent: %d or %x\n",*pt_u_short_int, *pt_u_short_int); | ||||
printf("LFR_BP2_F0[i*30+25] : %d or %x\n",LFR_BP2_F0[i*30+25], LFR_BP2_F0[i*30+25]); | ||||
printf("LFR_BP2_F0[i*30+24] : %d or %x\n",LFR_BP2_F0[i*30+24], LFR_BP2_F0[i*30+24]); | ||||
// S44 | ||||
significand = frexpf(compressed_spectral_matrix_f0[i*30+24], &exponent); // 0.5 <= significand < 1 | ||||
// S44 = significand * 2^exponent | ||||
printf("S44 : %16.8e\n",compressed_spectral_matrix_f0[i*30+24]); | ||||
printf("significand : %16.8e\n",significand); | ||||
printf("exponent : %d\n" ,exponent); | ||||
if (exponent < expmin) { // value should be >= 0.5 * 2^expmin | ||||
exponent = expmin; | ||||
significand = 0.5; // min value that can be recorded | ||||
} | ||||
if (exponent > expmax) { // value should be < 0.5 * 2^(expmax+1) | ||||
exponent = expmax; | ||||
significand = 1.0; // max value that can be recorded | ||||
} | ||||
if (significand == 0) {// in that case exponent == 0 too | ||||
exponent = expmin; | ||||
significand = 0.5; // min value that can be recorded | ||||
} | ||||
autocor = (unsigned short int) ((significand*2-1)*rangesig + 0.5); // shift and cast into a 16-bit unsigned int with rounding | ||||
// where just the first nbitsig bits are used (0, ..., 2^nbitsig-1) | ||||
tmp_u_short_int = (unsigned short int) (exponent-expmin); // shift and cast into a 16-bit unsigned int | ||||
// where just the first nbitexp bits are used (0, ..., 2^nbitexp-1) | ||||
pt_u_short_int = (unsigned short int*) &LFR_BP2_F0[i*30+22]; // affect an unsigned short int pointer with the | ||||
// adress where the 16-bit word result will be stored | ||||
*pt_u_short_int = autocor | (tmp_u_short_int << nbitsig); // put the exponent bits (nbitexp) next to the | ||||
// left place of the significand bits (nbitsig), making | ||||
// the 16-bit word to be recorded, and record it using the pointer | ||||
printf("autocor for S44 significand : %d\n",autocor ); | ||||
printf("tmp_u_char for S44 exponent : %d\n",tmp_u_short_int ); | ||||
printf("*pt_u_short_int for S44 significand + exponent: %d or %x\n",*pt_u_short_int, *pt_u_short_int); | ||||
printf("LFR_BP2_F0[i*30+23] : %d or %x\n",LFR_BP2_F0[i*30+23], LFR_BP2_F0[i*30+23]); | ||||
printf("LFR_BP2_F0[i*30+22] : %d or %x\n",LFR_BP2_F0[i*30+22], LFR_BP2_F0[i*30+22]); | ||||
// S55 | ||||
significand = frexpf(compressed_spectral_matrix_f0[i*30+28], &exponent); // 0.5 <= significand < 1 | ||||
// S55 = significand * 2^exponent | ||||
printf("S55 : %16.8e\n",compressed_spectral_matrix_f0[i*30+28]); | ||||
printf("significand : %16.8e\n",significand); | ||||
printf("exponent : %d\n" ,exponent); | ||||
if (exponent < expmin) { // value should be >= 0.5 * 2^expmin | ||||
exponent = expmin; | ||||
significand = 0.5; // min value that can be recorded | ||||
} | ||||
if (exponent > expmax) { // value should be < 0.5 * 2^(expmax+1) | ||||
exponent = expmax; | ||||
significand = 1.0; // max value that can be recorded | ||||
} | ||||
if (significand == 0) {// in that case exponent == 0 too | ||||
exponent = expmin; | ||||
significand = 0.5; // min value that can be recorded | ||||
} | ||||
autocor = (unsigned short int) ((significand*2-1)*rangesig + 0.5); // shift and cast into a 16-bit unsigned int with rounding | ||||
// where just the first nbitsig bits are used (0, ..., 2^nbitsig-1) | ||||
tmp_u_short_int = (unsigned short int) (exponent-expmin); // shift and cast into a 16-bit unsigned int | ||||
// where just the first nbitexp bits are used (0, ..., 2^nbitexp-1) | ||||
pt_u_short_int = (unsigned short int*) &LFR_BP2_F0[i*30+20]; // affect an unsigned short int pointer with the | ||||
// adress where the 16-bit word result will be stored | ||||
*pt_u_short_int = autocor | (tmp_u_short_int << nbitsig); // put the exponent bits (nbitexp) next to the | ||||
// left place of the significand bits (nbitsig), making | ||||
// the 16-bit word to be recorded, and record it using the pointer | ||||
printf("autocor for S55 significand : %d\n",autocor ); | ||||
printf("tmp_u_char for S55 exponent : %d\n",tmp_u_short_int ); | ||||
printf("*pt_u_short_int for S55 significand + exponent: %d or %x\n",*pt_u_short_int, *pt_u_short_int); | ||||
printf("LFR_BP2_F0[i*30+21] : %d or %x\n",LFR_BP2_F0[i*30+21], LFR_BP2_F0[i*30+21]); | ||||
printf("LFR_BP2_F0[i*30+20] : %d or %x\n",LFR_BP2_F0[i*30+20], LFR_BP2_F0[i*30+20]); | ||||
} | ||||
} | ||||