HG_REPOSITORIES/LPP/INSTRUMENTATION/SOLO_LFR/LFR_basic-parameters Pull Request !1

Pull request !1 Created on by

chust

Comme t'as tout cassé t'assumes!
(Alexis)
Alignement Mémoire réglé pour BP2 aussi.
(Thomas)

Commit flow:

tag:tip of HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/CHUST/LFR_basic-parameters → rev:ancestor of HG_REPOSITORIES/LPP/INSTRUMENTATION/SOLO_LFR/LFR_basic-parameters

Versions:

1 version available for this pull request, show versions.

`v1`					`Fri, 02 May 2014 17:48:46`

There are new changes for `tag:tip` in source repository, please consider updating this pull request.

Collapse 3 commits

ver	Time	Author	Commit	Description
`latest`	Fri, 02 May 2014 15:06:17	chust	`r7:ccd69f4e7a60`	version 1.3 qui finalise la version 1.2 (pb d'alignement mémoire réglé pour BP1 et BP2) (NB_BINS_COMPRESSED_MATRIX_f0 = 11 + quelques mises en forme des commentaires)
`latest`	Fri, 02 May 2014 15:23:19	chust	`r9:19349b3a5e90`	Sync
`latest`	Fri, 02 May 2014 15:28:06	chust	`r10:f66dcaa5b47b`	Change Branch
3 commits hidden, click expand to show them.

Collapse all files

basic_parameters.c +211 -161

             // version 1.0: 31/07/2013
             // version 1.1: 02/04/2014
             // version 1.2: 30/04/2014
+            // version 1.3: 02/05/2014
             #include "basic_parameters.h"
             #include <math.h>
             float alpha_M = 45 * (3.1415927/180);
             void BP1_set( float * compressed_spec_mat, uint8_t nb_bins_compressed_spec_mat, uint8_t * lfr_bp1 ){
-                int exponent;                       // 32 bits signed
+                float PSDB;                         // 32-bit floating point
-                float PSDB;                         // 32 bits floating point
                 float PSDE;
                 float tmp;
                 float NVEC_V0;
                 float bx_bx_star;
                 float vphi;
                 float significand;
-                uint8_t nbitexp;                    // 8 bits unsigned
+                int exponent;                       // 32-bit signed integer
+                uint8_t nbitexp;                    // 8-bit unsigned integer
                 uint8_t nbitsig;
                 uint8_t tmp_uint8;
-                uint8_t *pt_uint8;                  // pointer on unsigned 8-bit bytes
+                uint8_t *pt_uint8;                  // pointer on unsigned 8-bit integer
-                int8_t expmin;                      // 8 bits signed
+                int8_t expmin;                      // 8-bit signed integer
                 int8_t expmax;
-                int16_t rangesig;                   // 16 bits unsigned
+                uint16_t rangesig;                  // 16-bit unsigned integer
                 uint16_t psd;
                 uint16_t exp;
                 uint16_t tmp_uint16;
                       exponent = expmax;
                       significand = 1.0;     // max value that can be recorded
                     }
-                    if (significand == 0) {// in that case exponent == 0 too
+                    if (significand == 0) {  // in that case exponent == 0 too
                       exponent = expmin;
-                      significand = 0.5;   // min value that can be recorded
+                      significand = 0.5;     // min value that can be recorded
                     }
                     psd = (uint16_t) ((significand*2-1)*rangesig + 0.5); // Shift and cast into a 16-bit unsigned int with rounding
                     NVEC_V1 = -compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+4] / tmp;  // S13 Im  => n2
                     NVEC_V2 =  compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+2] / tmp;  // S12 Im  => n3
-                    lfr_bp1[i*NB_BYTES_BP1+4] = (uint8_t) (NVEC_V0*127.5 + 128); // shift and cast into a 8-bit uint8_t (0, ..., 255) with rounding
+                    lfr_bp1[i*NB_BYTES_BP1+4] = (uint8_t) (NVEC_V0*127.5 + 128); // Shift and cast into a 8-bit uint8_t (0, ..., 255) with rounding
-                    lfr_bp1[i*NB_BYTES_BP1+5] = (uint8_t) (NVEC_V1*127.5 + 128); // shift and cast into a 8-bit uint8_t (0, ..., 255) with rounding
+                    lfr_bp1[i*NB_BYTES_BP1+5] = (uint8_t) (NVEC_V1*127.5 + 128); // Shift and cast into a 8-bit uint8_t (0, ..., 255) with rounding
-                    pt_uint8 = (uint8_t*) &NVEC_V2;    // affect an uint8_t pointer with the adress of NVEC_V2
+                    pt_uint8 = (uint8_t*) &NVEC_V2;                              // Affect an uint8_t pointer with the adress of NVEC_V2
             #ifdef LSB_FIRST_TCH
-                    lfr_bp1[i*NB_BYTES_BP1+6] = pt_uint8[3] & 0x80;  // extract the sign bit of NVEC_V2 (32-bit float, sign bit in the 4th octet:PC convention)
+                    lfr_bp1[i*NB_BYTES_BP1+6] = pt_uint8[3] & 0x80;  // Extract the sign bit of NVEC_V2 (32-bit float, sign bit in the 4th octet:PC convention)
-                                                              // record it at the 8th bit position (from the right to the left) of lfr_bp1[i*NB_BYTES_BP1+6]
+                                                                     // Record it at the 8th bit position (from the right to the left) of lfr_bp1[i*NB_BYTES_BP1+6]
             #endif
             #ifdef MSB_FIRST_TCH
-                    lfr_bp1[i*NB_BYTES_BP1+6] = pt_uint8[0] & 0x80;  // extract the sign bit of NVEC_V2 (32-bit float, sign bit in the 0th octet:SPARC convention)
+                    lfr_bp1[i*NB_BYTES_BP1+6] = pt_uint8[0] & 0x80;  // Extract the sign bit of NVEC_V2 (32-bit float, sign bit in the 0th octet:SPARC convention)
-                                                              // record it at the 8th bit position (from the right to the left) of lfr_bp1[i*NB_BYTES_BP1+6]
+                                                                     // Record it at the 8th bit position (from the right to the left) of lfr_bp1[i*NB_BYTES_BP1+6]
             #endif
             #ifdef DEBUG_TCH
                     printf("NVEC_V0  : %16.8e\n",NVEC_V0);
             #endif
                     //=======================================================
                     // BP1 ellipticity == PA_LFR_SC_BP1_ELLIP_F0 == 4 bits
-                    aux = 2*tmp / PSDB;                        // compute the ellipticity
+                    aux = 2*tmp / PSDB;                   // Compute the ellipticity
-                    tmp_uint8 = (uint8_t) (aux*15 + 0.5); // shift and cast into a 8-bit uint8_t with rounding
+                    tmp_uint8 = (uint8_t) (aux*15 + 0.5); // Shift and cast into a 8-bit uint8_t with rounding
-                                                                 // where just the first 4 bits are used (0, ..., 15)
+                                                          // where just the first 4 bits are used (0, ..., 15)
-                    lfr_bp1[i*NB_BYTES_BP1+6] = lfr_bp1[i*NB_BYTES_BP1+6] | (tmp_uint8 << 3); // put these 4 bits next to the right place
+                    lfr_bp1[i*NB_BYTES_BP1+6] = lfr_bp1[i*NB_BYTES_BP1+6] | (tmp_uint8 << 3); // Put these 4 bits next to the right place
-                                                                               // of the sign bit of NVEC_V2 (recorded
+                                                                                              // of the sign bit of NVEC_V2 (recorded
-                                                                               // previously in lfr_bp1[i*NB_BYTES_BP1+6])
+                                                                                              // previously in lfr_bp1[i*NB_BYTES_BP1+6])
             #ifdef DEBUG_TCH
                     printf("ellipticity  : %16.8e\n",aux);
                     printf("tmp_uint8 for ellipticity : %u\n",tmp_uint8);
                              + 2 * compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+10]*compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+10]
                              + 2 * compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+11]*compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+11];
                     aux = PSDB*PSDB;
-                    tmp = ( 3*tr_SB_SB - aux ) / ( 2 * aux );   // compute the degree of polarisation
+                    tmp = ( 3*tr_SB_SB - aux ) / ( 2 * aux );  // Compute the degree of polarisation
-                    tmp_uint8 = (uint8_t) (tmp*7 + 0.5);// shift and cast into a 8-bit uint8_t with rounding
+                    tmp_uint8 = (uint8_t) (tmp*7 + 0.5);       // Shift and cast into a 8-bit uint8_t with rounding
                                                                // where just the first 3 bits are used (0, ..., 7)
-                    lfr_bp1[i*NB_BYTES_BP1+6] = lfr_bp1[i*NB_BYTES_BP1+6] | tmp_uint8; // record these 3 bits at the 3 first bit positions
+                    lfr_bp1[i*NB_BYTES_BP1+6] = lfr_bp1[i*NB_BYTES_BP1+6] | tmp_uint8; // Record these 3 bits at the 3 first bit positions
-                                                                        // (from the right to the left) of lfr_bp1[i*NB_BYTES_BP1+6]
+                                                                                       // (from the right to the left) of lfr_bp1[i*NB_BYTES_BP1+6]
             #ifdef DEBUG_TCH
                     printf("DOP  : %16.8e\n",tmp);
                     printf("tmp_uint8 for DOP : %u\n",tmp_uint8);
             #ifdef DEBUG_TCH
                     printf("ReaSX / 2   : %16.8e\n",e_cross_b_re/2);
             #endif
-                    pt_uint8 = (uint8_t*) &e_cross_b_re; // Affect an uint8_t pointer with the adress of e_cross_b_re
+                    pt_uint8 = (uint8_t*) &e_cross_b_re;      // Affect an uint8_t pointer with the adress of e_cross_b_re
             #ifdef LSB_FIRST_TCH
                     lfr_bp1[i*NB_BYTES_BP1+1] = lfr_bp1[i*NB_BYTES_BP1+1] | (pt_uint8[3] & 0x80);  // Extract its sign bit (32-bit float, sign bit in the 4th octet:PC convention)
-                                                                                    // Record it at the 8th bit position (from the right to the left)
+                                                                                      // Record it at the 8th bit position (from the right to the left)
-                                                                                    // of lfr_bp1[i*NB_BYTES_BP1+1]
+                                                                                      // of lfr_bp1[i*NB_BYTES_BP1+1]
                     pt_uint8[3] = (pt_uint8[3] & 0x7f);       // Make e_cross_b_re be positive in any case: |ReaSX|
             #endif
             #ifdef MSB_FIRST_TCH
                     lfr_bp1[i*NB_BYTES_BP1+1] = lfr_bp1[i*NB_BYTES_BP1+1] | (pt_uint8[0] & 0x80);  // Extract its sign bit (32-bit float, sign bit in the 0th octet:SPARC convention)
-                                                                                    // Record it at the 8th bit position (from the right to the left)
+                                                                                      // Record it at the 8th bit position (from the right to the left)
-                                                                                    // of lfr_bp1[i*NB_BYTES_BP1+1]
+                                                                                      // of lfr_bp1[i*NB_BYTES_BP1+1]
                     pt_uint8[0] = (pt_uint8[0] & 0x7f);       // Make e_cross_b_re be positive in any case: |ReaSX|
             #endif
-                    significand = frexpf(e_cross_b_re/2, &exponent);// 0.5 <= significand < 1
+                    significand = frexpf(e_cross_b_re/2, &exponent); // 0.5 <= significand < 1
-                                                                    // ReaSX/2 = significand * 2^exponent
+                                                                     // ReaSX/2 = significand * 2^exponent
                     // The division by 2 is to ensure that max value <= 2^30 (rough estimate)
                     // Should be reconsidered by taking into account the k-coefficients ...
                       exponent = expmax;
                       significand = 1.0;     // max value that can be recorded
                     }
-                    if (significand == 0) {// in that case exponent == 0 too
+                    if (significand == 0) {  // in that case exponent == 0 too
                       exponent = expmin;
-                      significand = 0.5;   // min value that can be recorded
+                      significand = 0.5;     // min value that can be recorded
                     }
                     lfr_bp1[i*NB_BYTES_BP1+7] = (uint8_t) ((significand*2-1)*7 + 0.5); // Shift and cast into a 8-bit uint8_t with rounding
-                                                                                     // where just the first 3 bits are used (0, ..., 7)
+                                                                                       // where just the first 3 bits are used (0, ..., 7)
                     tmp_uint8 = (uint8_t) (exponent-expmin); // Shift and cast into a 8-bit uint8_t where
-                                                                    // just the first 5 bits are used (0, ..., 2^5-1)
+                                                             // just the first 5 bits are used (0, ..., 2^5-1)
             #ifdef DEBUG_TCH
                     printf("|ReaSX| / 2 : %16.8e\n",e_cross_b_re/2);
                     printf("significand : %16.8e\n",significand);
                     printf("lfr_bp1[i*NB_BYTES_BP1+7] for ReaSX significand : %u\n",lfr_bp1[i*NB_BYTES_BP1+7]);
                     printf("tmp_uint8        for ReaSX exponent    : %d\n",tmp_uint8);
             #endif
-                    lfr_bp1[i*NB_BYTES_BP1+7] = lfr_bp1[i*NB_BYTES_BP1+7] | (tmp_uint8 << 3); // shift these 5 bits to the left before logical addition
+                    lfr_bp1[i*NB_BYTES_BP1+7] = lfr_bp1[i*NB_BYTES_BP1+7] | (tmp_uint8 << 3); // Shift these 5 bits to the left before logical addition
-                                                                               // with lfr_bp1[i*NB_BYTES_BP1+7]
+                                                                                              // with lfr_bp1[i*NB_BYTES_BP1+7]
             #ifdef DEBUG_TCH
                     printf("lfr_bp1[i*NB_BYTES_BP1+7] for ReaSX exponent + significand : %u\n",lfr_bp1[i*NB_BYTES_BP1+7]);
                     printf("lfr_bp1[i*NB_BYTES_BP1+1] for ReaSX sign + PSDE 'exponent' : %u\n",lfr_bp1[i*NB_BYTES_BP1+1]);
             #endif
                     pt_uint8 = (uint8_t*) &e_cross_b_im; // Affect an uint8_t pointer with the adress of e_cross_b_im
             #ifdef LSB_FIRST_TCH
-                    pt_uint8[3] = pt_uint8[3] & 0x7f;         // Make e_cross_b_im be positive in any case: |ImaSX|
+                    pt_uint8[3] = pt_uint8[3] & 0x7f;    // Make e_cross_b_im be positive in any case: |ImaSX|
             #endif
             #ifdef MSB_FIRST_TCH
-                    pt_uint8[0] = pt_uint8[0] & 0x7f;         // Make e_cross_b_im be positive in any case: |ImaSX|
+                    pt_uint8[0] = pt_uint8[0] & 0x7f;    // Make e_cross_b_im be positive in any case: |ImaSX|
             #endif
                     tmp_uint8 = (e_cross_b_im > e_cross_b_re) ? 0x40 : 0x00; // Determine the sector argument of SX. If |Im| > |Re| affect
-                                                                              // an unsigned 8-bit char with 01000000; otherwise with null.
+                                                                             // an unsigned 8-bit char with 01000000; otherwise with null.
-                    lfr_bp1[i*NB_BYTES_BP1+1] = lfr_bp1[i*NB_BYTES_BP1+1] |  tmp_uint8;      // Record it as a sign bit at the 7th bit position (from the right
+                    lfr_bp1[i*NB_BYTES_BP1+1] = lfr_bp1[i*NB_BYTES_BP1+1] |  tmp_uint8; // Record it as a sign bit at the 7th bit position (from the right
-                                                                              // to the left) of lfr_bp1[i*NB_BYTES_BP1+1], by simple logical addition.
+                                                                                        // to the left) of lfr_bp1[i*NB_BYTES_BP1+1], by simple logical addition.
             #ifdef DEBUG_TCH
                     printf("|ImaSX| / 2 : %16.8e\n",e_cross_b_im/2);
                     printf("ArgSX sign  : %u\n",tmp_uint8);
                     printf("n_cross_e_scal_b_im   : %16.8e\n",n_cross_e_scal_b_im);
             #endif
                     // vphi = n_cross_e_scal_b_re / bx_bx_star => sign(VPHI) = sign(n_cross_e_scal_b_re)
-                    pt_uint8 = (uint8_t*) &n_cross_e_scal_b_re;     // Affect an uint8_t pointer with the adress of n_cross_e_scal_b_re
+                    pt_uint8 = (uint8_t*) &n_cross_e_scal_b_re; // Affect an uint8_t pointer with the adress of n_cross_e_scal_b_re
             #ifdef LSB_FIRST_TCH
                     lfr_bp1[i*NB_BYTES_BP1+3] = lfr_bp1[i*NB_BYTES_BP1+3] | (pt_uint8[3] & 0x80);  // Extract its sign bit (32-bit float, sign bit in the 4th octet:PC convention)
                                                                                     // Record it at the 8th bit position (from the right to the left)
             #endif
                     vphi = n_cross_e_scal_b_re / bx_bx_star;  // Compute |VPHI|
-                    significand = frexpf(vphi/2, &exponent);   // 0.5 <= significand < 1
+                    significand = frexpf(vphi/2, &exponent);  // 0.5 <= significand < 1
-                                                               // vphi/2 = significand * 2^exponent
+                                                              // vphi/2 = significand * 2^exponent
                     // The division by 2 is to ensure that max value <= 2^30 (rough estimate)
                     // Should be reconsidered by taking into account the k-coefficients ...
                     printf("exponent    : %d\n"    ,exponent);
             #endif
                     lfr_bp1[i*NB_BYTES_BP1+8] = (uint8_t) ((significand*2-1)*7 + 0.5); // Shift and cast into a 8-bit uint8_t with rounding
-                                                                                     // where just the first 3 bits are used (0, ..., 7)
+                                                                                       // where just the first 3 bits are used (0, ..., 7)
                     tmp_uint8 = (uint8_t) (exponent-expmin); // Shift and cast into a 8-bit uint8_t where
-                                                                    // just the first 5 bits are used (0, ..., 2^5-1)
+                                                             // just the first 5 bits are used (0, ..., 2^5-1)
             #ifdef DEBUG_TCH
                     printf("lfr_bp1[i*NB_BYTES_BP1+8] for VPHI significand : %u\n",lfr_bp1[i*NB_BYTES_BP1+8]);
                     printf("tmp_uint8        for VPHI exponent    : %d\n",tmp_uint8);
             #endif
                     pt_uint8 = (uint8_t*) &n_cross_e_scal_b_im; // Affect an uint8_t pointer with the adress of n_cross_e_scal_b_im
             #ifdef LSB_FIRST_TCH
-                    pt_uint8[3] = pt_uint8[3] & 0x7f;         // Make n_cross_e_scal_b_im be positive in any case: |ImaSX|
+                    pt_uint8[3] = pt_uint8[3] & 0x7f;           // Make n_cross_e_scal_b_im be positive in any case: |ImaSX|
             #endif
             #ifdef MSB_FIRST_TCH
-                    pt_uint8[0] = pt_uint8[0] & 0x7f;         // Make n_cross_e_scal_b_im be positive in any case: |ImaSX|
+                    pt_uint8[0] = pt_uint8[0] & 0x7f;           // Make n_cross_e_scal_b_im be positive in any case: |ImaSX|
             #endif
                     tmp_uint8 = (n_cross_e_scal_b_im > n_cross_e_scal_b_re) ? 0x40 : 0x00; // Determine the sector argument of SX. If |Im| > |Re| affect
-                                                                              // an unsigned 8-bit char with 01000000; otherwise with null.
+                                                                                           // an unsigned 8-bit char with 01000000; otherwise with null.
-                    lfr_bp1[i*NB_BYTES_BP1+3] = lfr_bp1[i*NB_BYTES_BP1+3] |  tmp_uint8;      // Record it as a sign bit at the 7th bit position (from the right
+                    lfr_bp1[i*NB_BYTES_BP1+3] = lfr_bp1[i*NB_BYTES_BP1+3] |  tmp_uint8;    // Record it as a sign bit at the 7th bit position (from the right
-                                                                              // to the left) of lfr_bp1[i*NB_BYTES_BP1+3], by simple logical addition.
+                                                                                           // to the left) of lfr_bp1[i*NB_BYTES_BP1+3], by simple logical addition.
             #ifdef DEBUG_TCH
                     printf("|n_cross_e_scal_b_im|             : %16.8e\n",n_cross_e_scal_b_im);
                     printf("|n_cross_e_scal_b_im|/bx_bx_star/2: %16.8e\n",n_cross_e_scal_b_im/bx_bx_star/2);
             void BP2_set( float * compressed_spec_mat, uint8_t nb_bins_compressed_spec_mat, uint8_t * lfr_bp2 )
             {
-                int i, exponent;
+                float cross_re;                     // 32-bit floating point
-                float aux, significand, cross_re, cross_im;
+                float cross_im;
-                int8_t nbitexp, nbitsig, expmin, expmax;  //  8 bits
+                float aux;
-                int16_t rangesig;                            // 16 bits
+                float significand;
-                uint16_t autocor, tmp_uint16;   // 16 bits
+                int exponent;                       // 32-bit signed integer
-                uint16_t *pt_u_short_int;            // pointer on unsigned 16-bit words
+                uint8_t nbitexp;                    // 8-bit unsigned integer
+                uint8_t nbitsig;
+                uint8_t *pt_uint8;                  // pointer on unsigned 8-bit integer
+                int8_t expmin;                      // 8-bit signed integer
+                int8_t expmax;
+                uint16_t rangesig;                  // 16-bit unsigned integer
+                uint16_t autocor;
+                uint16_t exp;
+                uint16_t tmp_uint16;
+                uint16_t i;
             #ifdef DEBUG_TCH
                 printf("BP2 : \n");
             #endif
                 // For floating point data to be recorded on 16-bit words :
-                nbitexp = 6;             // number of bits for the exponent
+                nbitexp = 6;                  // number of bits for the exponent
-                nbitsig = 16 - nbitexp;  // number of bits for the significand
+                nbitsig = 16 - nbitexp;       // number of bits for the significand
                 rangesig = (1 << nbitsig)-1;  // == 2^nbitsig - 1
                 expmax = 32;
                 expmin = expmax - (1 << nbitexp) + 1;
                     aux = sqrt(compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX]*compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+9]);
                     cross_re = compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+1] / aux;
                     cross_im = compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+2] / aux;
-                    lfr_bp2[i*NB_BYTES_BP2+10] = (uint8_t) (cross_re*127.5 + 128); // shift and cast into a 8-bit uint8_t (0, ..., 255) with rounding
+                    lfr_bp2[i*NB_BYTES_BP2+10] = (uint8_t) (cross_re*127.5 + 128); // Shift and cast into a 8-bit uint8_t (0, ..., 255) with rounding
-                    lfr_bp2[i*NB_BYTES_BP2+20] = (uint8_t) (cross_im*127.5 + 128); // shift and cast into a 8-bit uint8_t (0, ..., 255) with rounding
+                    lfr_bp2[i*NB_BYTES_BP2+20] = (uint8_t) (cross_im*127.5 + 128); // Shift and cast into a 8-bit uint8_t (0, ..., 255) with rounding
             #ifdef DEBUG_TCH
                     printf("\nBin number: %d\n", i);
                     printf("lfr_bp2[i*NB_BYTES_BP2+10] for cross12_re (%16.8e) : %.3u\n",cross_re, lfr_bp2[i*NB_BYTES_BP2+10]);
                     aux = sqrt(compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX]*compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+16]);
                     cross_re = compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+3] / aux;
                     cross_im = compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+4] / aux;
-                    lfr_bp2[i*NB_BYTES_BP2+11] = (uint8_t) (cross_re*127.5 + 128); // shift and cast into a 8-bit uint8_t (0, ..., 255) with rounding
+                    lfr_bp2[i*NB_BYTES_BP2+11] = (uint8_t) (cross_re*127.5 + 128); // Shift and cast into a 8-bit uint8_t (0, ..., 255) with rounding
-                    lfr_bp2[i*NB_BYTES_BP2+21] = (uint8_t) (cross_im*127.5 + 128); // shift and cast into a 8-bit uint8_t (0, ..., 255) with rounding
+                    lfr_bp2[i*NB_BYTES_BP2+21] = (uint8_t) (cross_im*127.5 + 128); // Shift and cast into a 8-bit uint8_t (0, ..., 255) with rounding
             #ifdef DEBUG_TCH
                     printf("lfr_bp2[i*NB_BYTES_BP2+11] for cross13_re (%16.8e) : %.3u\n",cross_re, lfr_bp2[i*NB_BYTES_BP2+11]);
                     printf("lfr_bp2[i*NB_BYTES_BP2+21] for cross13_im (%16.8e) : %.3u\n",cross_im, lfr_bp2[i*NB_BYTES_BP2+21]);
                     aux = sqrt(compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX]*compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+21]);
                     cross_re = compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+5] / aux;
                     cross_im = compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+6] / aux;
-                    lfr_bp2[i*NB_BYTES_BP2+12] = (uint8_t) (cross_re*127.5 + 128); // shift and cast into a 8-bit uint8_t (0, ..., 255) with rounding
+                    lfr_bp2[i*NB_BYTES_BP2+12] = (uint8_t) (cross_re*127.5 + 128); // Shift and cast into a 8-bit uint8_t (0, ..., 255) with rounding
-                    lfr_bp2[i*NB_BYTES_BP2+22] = (uint8_t) (cross_im*127.5 + 128); // shift and cast into a 8-bit uint8_t (0, ..., 255) with rounding
+                    lfr_bp2[i*NB_BYTES_BP2+22] = (uint8_t) (cross_im*127.5 + 128); // Shift and cast into a 8-bit uint8_t (0, ..., 255) with rounding
             #ifdef DEBUG_TCH
                     printf("lfr_bp2[i*NB_BYTES_BP2+12] for cross14_re (%16.8e) : %.3u\n",cross_re, lfr_bp2[i*NB_BYTES_BP2+12]);
                     printf("lfr_bp2[i*NB_BYTES_BP2+22] for cross14_im (%16.8e) : %.3u\n",cross_im, lfr_bp2[i*NB_BYTES_BP2+22]);
                     aux = sqrt(compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX]*compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+24]);
                     cross_re = compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+7] / aux;
                     cross_im = compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+8] / aux;
-                    lfr_bp2[i*NB_BYTES_BP2+13] = (uint8_t) (cross_re*127.5 + 128); // shift and cast into a 8-bit uint8_t (0, ..., 255) with rounding
+                    lfr_bp2[i*NB_BYTES_BP2+13] = (uint8_t) (cross_re*127.5 + 128); // Shift and cast into a 8-bit uint8_t (0, ..., 255) with rounding
-                    lfr_bp2[i*NB_BYTES_BP2+23] = (uint8_t) (cross_im*127.5 + 128); // shift and cast into a 8-bit uint8_t (0, ..., 255) with rounding
+                    lfr_bp2[i*NB_BYTES_BP2+23] = (uint8_t) (cross_im*127.5 + 128); // Shift and cast into a 8-bit uint8_t (0, ..., 255) with rounding
             #ifdef DEBUG_TCH
                     printf("lfr_bp2[i*NB_BYTES_BP2+13] for cross15_re (%16.8e) : %.3u\n",cross_re, lfr_bp2[i*NB_BYTES_BP2+13]);
                     printf("lfr_bp2[i*NB_BYTES_BP2+23] for cross15_im (%16.8e) : %.3u\n",cross_im, lfr_bp2[i*NB_BYTES_BP2+23]);
                     aux = sqrt(compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+9]*compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+16]);
                     cross_re = compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+10] / aux;
                     cross_im = compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+11] / aux;
-                    lfr_bp2[i*NB_BYTES_BP2+14] = (uint8_t) (cross_re*127.5 + 128); // shift and cast into a 8-bit uint8_t (0, ..., 255) with rounding
+                    lfr_bp2[i*NB_BYTES_BP2+14] = (uint8_t) (cross_re*127.5 + 128); // Shift and cast into a 8-bit uint8_t (0, ..., 255) with rounding
-                    lfr_bp2[i*NB_BYTES_BP2+24] = (uint8_t) (cross_im*127.5 + 128); // shift and cast into a 8-bit uint8_t (0, ..., 255) with rounding
+                    lfr_bp2[i*NB_BYTES_BP2+24] = (uint8_t) (cross_im*127.5 + 128); // Shift and cast into a 8-bit uint8_t (0, ..., 255) with rounding
             #ifdef DEBUG_TCH
                     printf("lfr_bp2[i*NB_BYTES_BP2+14] for cross23_re (%16.8e) : %.3u\n",cross_re, lfr_bp2[i*NB_BYTES_BP2+14]);
                     printf("lfr_bp2[i*NB_BYTES_BP2+24] for cross23_im (%16.8e) : %.3u\n",cross_im, lfr_bp2[i*NB_BYTES_BP2+24]);
                     aux = sqrt(compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+9]*compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+21]);
                     cross_re = compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+12] / aux;
                     cross_im = compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+13] / aux;
-                    lfr_bp2[i*NB_BYTES_BP2+15] = (uint8_t) (cross_re*127.5 + 128); // shift and cast into a 8-bit uint8_t (0, ..., 255) with rounding
+                    lfr_bp2[i*NB_BYTES_BP2+15] = (uint8_t) (cross_re*127.5 + 128); // Shift and cast into a 8-bit uint8_t (0, ..., 255) with rounding
-                    lfr_bp2[i*NB_BYTES_BP2+25] = (uint8_t) (cross_im*127.5 + 128); // shift and cast into a 8-bit uint8_t (0, ..., 255) with rounding
+                    lfr_bp2[i*NB_BYTES_BP2+25] = (uint8_t) (cross_im*127.5 + 128); // Shift and cast into a 8-bit uint8_t (0, ..., 255) with rounding
             #ifdef DEBUG_TCH
                     printf("lfr_bp2[i*NB_BYTES_BP2+15] for cross24_re (%16.8e) : %.3u\n",cross_re, lfr_bp2[i*NB_BYTES_BP2+15]);
                     printf("lfr_bp2[i*NB_BYTES_BP2+25] for cross24_im (%16.8e) : %.3u\n",cross_im, lfr_bp2[i*NB_BYTES_BP2+25]);
                     aux = sqrt(compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+9]*compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+24]);
                     cross_re = compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+14] / aux;
                     cross_im = compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+15] / aux;
-                    lfr_bp2[i*NB_BYTES_BP2+16] = (uint8_t) (cross_re*127.5 + 128); // shift and cast into a 8-bit uint8_t (0, ..., 255) with rounding
+                    lfr_bp2[i*NB_BYTES_BP2+16] = (uint8_t) (cross_re*127.5 + 128); // Shift and cast into a 8-bit uint8_t (0, ..., 255) with rounding
-                    lfr_bp2[i*NB_BYTES_BP2+26] = (uint8_t) (cross_im*127.5 + 128); // shift and cast into a 8-bit uint8_t (0, ..., 255) with rounding
+                    lfr_bp2[i*NB_BYTES_BP2+26] = (uint8_t) (cross_im*127.5 + 128); // Shift and cast into a 8-bit uint8_t (0, ..., 255) with rounding
             #ifdef DEBUG_TCH
                     printf("lfr_bp2[i*NB_BYTES_BP2+16] for cross25_re (%16.8e) : %.3u\n",cross_re, lfr_bp2[i*NB_BYTES_BP2+16]);
                     printf("lfr_bp2[i*NB_BYTES_BP2+26] for cross25_im (%16.8e) : %.3u\n",cross_im, lfr_bp2[i*NB_BYTES_BP2+26]);
                     aux = sqrt(compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+16]*compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+21]);
                     cross_re = compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+17] / aux;
                     cross_im = compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+18] / aux;
-                    lfr_bp2[i*NB_BYTES_BP2+17] = (uint8_t) (cross_re*127.5 + 128); // shift and cast into a 8-bit uint8_t (0, ..., 255) with rounding
+                    lfr_bp2[i*NB_BYTES_BP2+17] = (uint8_t) (cross_re*127.5 + 128); // Shift and cast into a 8-bit uint8_t (0, ..., 255) with rounding
-                    lfr_bp2[i*NB_BYTES_BP2+27] = (uint8_t) (cross_im*127.5 + 128); // shift and cast into a 8-bit uint8_t (0, ..., 255) with rounding
+                    lfr_bp2[i*NB_BYTES_BP2+27] = (uint8_t) (cross_im*127.5 + 128); // Shift and cast into a 8-bit uint8_t (0, ..., 255) with rounding
             #ifdef DEBUG_TCH
                     printf("lfr_bp2[i*NB_BYTES_BP2+17] for cross34_re (%16.8e) : %.3u\n",cross_re, lfr_bp2[i*NB_BYTES_BP2+17]);
                     printf("lfr_bp2[i*NB_BYTES_BP2+27] for cross34_im (%16.8e) : %.3u\n",cross_im, lfr_bp2[i*NB_BYTES_BP2+27]);
                     aux = sqrt(compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+16]*compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+24]);
                     cross_re = compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+19] / aux;
                     cross_im = compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+20] / aux;
-                    lfr_bp2[i*NB_BYTES_BP2+18] = (uint8_t) (cross_re*127.5 + 128); // shift and cast into a 8-bit uint8_t (0, ..., 255) with rounding
+                    lfr_bp2[i*NB_BYTES_BP2+18] = (uint8_t) (cross_re*127.5 + 128); // Shift and cast into a 8-bit uint8_t (0, ..., 255) with rounding
-                    lfr_bp2[i*NB_BYTES_BP2+28] = (uint8_t) (cross_im*127.5 + 128); // shift and cast into a 8-bit uint8_t (0, ..., 255) with rounding
+                    lfr_bp2[i*NB_BYTES_BP2+28] = (uint8_t) (cross_im*127.5 + 128); // Shift and cast into a 8-bit uint8_t (0, ..., 255) with rounding
             #ifdef DEBUG_TCH
                     printf("lfr_bp2[i*NB_BYTES_BP2+18] for cross35_re (%16.8e) : %.3u\n",cross_re, lfr_bp2[i*NB_BYTES_BP2+18]);
                     printf("lfr_bp2[i*NB_BYTES_BP2+28] for cross35_im (%16.8e) : %.3u\n",cross_im, lfr_bp2[i*NB_BYTES_BP2+28]);
                     aux = sqrt(compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+21]*compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+24]);
                     cross_re = compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+22] / aux;
                     cross_im = compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+23] / aux;
-                    lfr_bp2[i*NB_BYTES_BP2+19] = (uint8_t) (cross_re*127.5 + 128); // shift and cast into a 8-bit uint8_t (0, ..., 255) with rounding
+                    lfr_bp2[i*NB_BYTES_BP2+19] = (uint8_t) (cross_re*127.5 + 128); // Shift and cast into a 8-bit uint8_t (0, ..., 255) with rounding
-                    lfr_bp2[i*NB_BYTES_BP2+29] = (uint8_t) (cross_im*127.5 + 128); // shift and cast into a 8-bit uint8_t (0, ..., 255) with rounding
+                    lfr_bp2[i*NB_BYTES_BP2+29] = (uint8_t) (cross_im*127.5 + 128); // Shift and cast into a 8-bit uint8_t (0, ..., 255) with rounding
             #ifdef DEBUG_TCH
                     printf("lfr_bp2[i*NB_BYTES_BP2+19] for cross45_re (%16.8e) : %.3u\n",cross_re, lfr_bp2[i*NB_BYTES_BP2+19]);
                     printf("lfr_bp2[i*NB_BYTES_BP2+29] for cross45_im (%16.8e) : %.3u\n",cross_im, lfr_bp2[i*NB_BYTES_BP2+29]);
                                            // == PA_LFR_SC_BP2_AUTO_A4_F0 == 16 bits
                     // S11
                     significand = frexpf(compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX], &exponent);  // 0.5 <= significand < 1
-                                                                                           // S11 = significand * 2^exponent
+                                                                                                            // S11 = significand * 2^exponent
             #ifdef DEBUG_TCH
                     printf("S11         : %16.8e\n",compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX]);
                     printf("significand : %16.8e\n",significand);
                       exponent = expmax;
                       significand = 1.0;     // max value that can be recorded
                     }
-                    if (significand == 0) {// in that case exponent == 0 too
+                    if (significand == 0) {  // in that case exponent == 0 too
                       exponent = expmin;
-                      significand = 0.5;   // min value that can be recorded
+                      significand = 0.5;     // min value that can be recorded
                     }
                     autocor = (uint16_t) ((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)
+                                                                             // where just the first nbitsig bits are used (0, ..., 2^nbitsig-1)
-                    tmp_uint16 = (uint16_t) (exponent-expmin); // Shift and cast into a 16-bit unsigned int
+                    exp = (uint16_t) (exponent-expmin);      // Shift and cast into a 16-bit unsigned int where just
-                                                                              // where just the first nbitexp bits are used (0, ..., 2^nbitexp-1)
+                                                             // the first nbitexp bits are used (0, ..., 2^nbitexp-1)
-                    pt_u_short_int = (uint16_t*) &lfr_bp2[i*NB_BYTES_BP2+0]; // Affect an uint16_t pointer with the
+                    tmp_uint16 = autocor | (exp << nbitsig); // Put the exponent bits (nbitexp) next to the
-                                                                                // adress where the 16-bit word result will be stored
+                                                             // left place of the significand bits (nbitsig),
-                    *pt_u_short_int = autocor | (tmp_uint16 << nbitsig); // Put the exponent bits (nbitexp) next to the
+                                                             // making the 16-bit word to be recorded
-                                                                          // left place of the significand bits (nbitsig), making
+                    pt_uint8 = (uint8_t*) &tmp_uint16;       // Affect an uint8_t pointer with the adress of tmp_uint16
-                                                                          // the 16-bit word to be recorded, and record it using the pointer
+            #ifdef LSB_FIRST_TCH
+                    lfr_bp2[i*NB_BYTES_BP2+0] = pt_uint8[0]; // Record LSB of tmp_uint16
+                    lfr_bp2[i*NB_BYTES_BP2+1] = pt_uint8[1]; // Record MSB of tmp_uint16
+            #endif
+            #ifdef MSB_FIRST_TCH
+                    lfr_bp2[i*NB_BYTES_BP2+0] = pt_uint8[1]; // Record LSB of tmp_uint16
+                    lfr_bp2[i*NB_BYTES_BP2+1] = pt_uint8[0]; // Record MSB of tmp_uint16
+            #endif
             #ifdef DEBUG_TCH
-                    printf("autocor for S11 significand : %u\n",autocor );
+                    printf("autocor for S11 significand : %u\n",autocor);
-                    printf("tmp_uint8 for S11 exponent : %u\n",tmp_uint16 );
+                    printf("exp for S11 exponent : %u\n",exp);
-                    printf("*pt_u_short_int for S11 exponent + significand : %.3d or %x\n",*pt_u_short_int, *pt_u_short_int);
+                    printf("pt_uint8[1] for S11 exponent + significand : %.3d or %2x\n",pt_uint8[1], pt_uint8[1]);
-                    printf("lfr_bp2[i*NB_BYTES_BP2+1] : %u or %x\n",lfr_bp2[i*NB_BYTES_BP2+1], lfr_bp2[i*NB_BYTES_BP2+1]);
+                    printf("pt_uint8[0] for S11 exponent + significand : %.3d or %2x\n",pt_uint8[0], pt_uint8[0]);
-                    printf("lfr_bp2[i*NB_BYTES_BP2+0] : %u or %x\n",lfr_bp2[i*NB_BYTES_BP2+0], lfr_bp2[i*NB_BYTES_BP2+0]);
+                    printf("lfr_bp2[i*NB_BYTES_BP2+1] : %3u or %2x\n",lfr_bp2[i*NB_BYTES_BP2+1], lfr_bp2[i*NB_BYTES_BP2+1]);
+                    printf("lfr_bp2[i*NB_BYTES_BP2+0] : %3u or %2x\n",lfr_bp2[i*NB_BYTES_BP2+0], lfr_bp2[i*NB_BYTES_BP2+0]);
             #endif
                     // S22
                     significand = frexpf(compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+9], &exponent);  // 0.5 <= significand < 1
-                                                                                              // S22 = significand * 2^exponent
+                                                                                                              // S22 = significand * 2^exponent
             #ifdef DEBUG_TCH
                     printf("S22         : %16.8e\n",compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+9]);
                     printf("significand : %16.8e\n",significand);
                       exponent = expmax;
                       significand = 1.0;     // max value that can be recorded
                     }
-                    if (significand == 0) {// in that case exponent == 0 too
+                    if (significand == 0) {  // in that case exponent == 0 too
                       exponent = expmin;
-                      significand = 0.5;   // min value that can be recorded
+                      significand = 0.5;     // min value that can be recorded
                     }
                     autocor = (uint16_t) ((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)
+                                                                             // where just the first nbitsig bits are used (0, ..., 2^nbitsig-1)
-                    tmp_uint16 = (uint16_t) (exponent-expmin); // Shift and cast into a 16-bit unsigned int
+                    exp = (uint16_t) (exponent-expmin);      // Shift and cast into a 16-bit unsigned int where just
-                                                                              // where just the first nbitexp bits are used (0, ..., 2^nbitexp-1)
+                                                             // the first nbitexp bits are used (0, ..., 2^nbitexp-1)
-                    pt_u_short_int = (uint16_t*) &lfr_bp2[i*NB_BYTES_BP2+2]; // Affect an uint16_t pointer with the
+                    tmp_uint16 = autocor | (exp << nbitsig); // Put the exponent bits (nbitexp) next to the
-                                                                                // adress where the 16-bit word result will be stored
+                                                             // left place of the significand bits (nbitsig),
-                    *pt_u_short_int = autocor | (tmp_uint16 << nbitsig); // Put the exponent bits (nbitexp) next to the
+                                                             // making the 16-bit word to be recorded
-                                                                      // left place of the significand bits (nbitsig), making
+                    pt_uint8 = (uint8_t*) &tmp_uint16;       // Affect an uint8_t pointer with the adress of tmp_uint16
-                                                                      // the 16-bit word to be recorded, and record it using the pointer
+            #ifdef LSB_FIRST_TCH
+                    lfr_bp2[i*NB_BYTES_BP2+2] = pt_uint8[0]; // Record LSB of tmp_uint16
+                    lfr_bp2[i*NB_BYTES_BP2+3] = pt_uint8[1]; // Record MSB of tmp_uint16
+            #endif
+            #ifdef MSB_FIRST_TCH
+                    lfr_bp2[i*NB_BYTES_BP2+2] = pt_uint8[1]; // Record LSB of tmp_uint16
+                    lfr_bp2[i*NB_BYTES_BP2+3] = pt_uint8[0]; // Record MSB of tmp_uint16
+            #endif
             #ifdef DEBUG_TCH
-                    printf("autocor for S22 significand : %d\n",autocor );
+                    printf("autocor for S22 significand : %u\n",autocor);
-                    printf("tmp_uint8 for S22 exponent : %d\n",tmp_uint16 );
+                    printf("exp for S11 exponent : %u\n",exp);
-                    printf("*pt_u_short_int for S22 exponent + significand : %.3d or %x\n",*pt_u_short_int, *pt_u_short_int);
+                    printf("pt_uint8[1] for S22 exponent + significand : %.3d or %2x\n",pt_uint8[1], pt_uint8[1]);
-                    printf("lfr_bp2[i*NB_BYTES_BP2+3] : %.3d or %x\n",lfr_bp2[i*NB_BYTES_BP2+3], lfr_bp2[i*NB_BYTES_BP2+3]);
+                    printf("pt_uint8[0] for S22 exponent + significand : %.3d or %2x\n",pt_uint8[0], pt_uint8[0]);
-                    printf("lfr_bp2[i*NB_BYTES_BP2+2] : %.3d or %x\n",lfr_bp2[i*NB_BYTES_BP2+2], lfr_bp2[i*NB_BYTES_BP2+2]);
+                    printf("lfr_bp2[i*NB_BYTES_BP2+3] : %3u or %2x\n",lfr_bp2[i*NB_BYTES_BP2+3], lfr_bp2[i*NB_BYTES_BP2+3]);
+                    printf("lfr_bp2[i*NB_BYTES_BP2+2] : %3u or %2x\n",lfr_bp2[i*NB_BYTES_BP2+2], lfr_bp2[i*NB_BYTES_BP2+2]);
             #endif
                     // S33
                     significand = frexpf(compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+16], &exponent);  // 0.5 <= significand < 1
-                                                                                              // S33 = significand * 2^exponent
+                                                                                                               // S33 = significand * 2^exponent
             #ifdef DEBUG_TCH
                     printf("S33         : %16.8e\n",compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+16]);
                     printf("significand : %16.8e\n",significand);
                       exponent = expmax;
                       significand = 1.0;     // max value that can be recorded
                     }
-                    if (significand == 0) {// in that case exponent == 0 too
+                    if (significand == 0) {  // in that case exponent == 0 too
                       exponent = expmin;
-                      significand = 0.5;   // min value that can be recorded
+                      significand = 0.5;     // min value that can be recorded
                     }
                     autocor = (uint16_t) ((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)
+                                                                             // where just the first nbitsig bits are used (0, ..., 2^nbitsig-1)
-                    tmp_uint16 = (uint16_t) (exponent-expmin); // Shift and cast into a 16-bit unsigned int
+                    exp = (uint16_t) (exponent-expmin);      // Shift and cast into a 16-bit unsigned int where just
-                                                                              // where just the first nbitexp bits are used (0, ..., 2^nbitexp-1)
+                                                             // the first nbitexp bits are used (0, ..., 2^nbitexp-1)
-                    pt_u_short_int = (uint16_t*) &lfr_bp2[i*NB_BYTES_BP2+4]; // Affect an uint16_t pointer with the
+                    tmp_uint16 = autocor | (exp << nbitsig); // Put the exponent bits (nbitexp) next to the
-                                                                                // adress where the 16-bit word result will be stored
+                                                             // left place of the significand bits (nbitsig),
-                    *pt_u_short_int = autocor | (tmp_uint16 << nbitsig); // Put the exponent bits (nbitexp) next to the
+                                                             // making the 16-bit word to be recorded
-                                                                      // left place of the significand bits (nbitsig), making
+                    pt_uint8 = (uint8_t*) &tmp_uint16;       // Affect an uint8_t pointer with the adress of tmp_uint16
-                                                                      // the 16-bit word to be recorded, and record it using the pointer
+            #ifdef LSB_FIRST_TCH
+                    lfr_bp2[i*NB_BYTES_BP2+4] = pt_uint8[0]; // Record LSB of tmp_uint16
+                    lfr_bp2[i*NB_BYTES_BP2+5] = pt_uint8[1]; // Record MSB of tmp_uint16
+            #endif
+            #ifdef MSB_FIRST_TCH
+                    lfr_bp2[i*NB_BYTES_BP2+4] = pt_uint8[1]; // Record LSB of tmp_uint16
+                    lfr_bp2[i*NB_BYTES_BP2+5] = pt_uint8[0]; // Record MSB of tmp_uint16
+            #endif
             #ifdef DEBUG_TCH
-                    printf("autocor for S33 significand : %d\n",autocor );
+                    printf("autocor for S33 significand : %u\n",autocor);
-                    printf("tmp_uint8 for S33 exponent : %d\n",tmp_uint16 );
+                    printf("exp for S33 exponent : %u\n",exp);
-                    printf("*pt_u_short_int for S33 exponent + significand : %.3d or %x\n",*pt_u_short_int, *pt_u_short_int);
+                    printf("pt_uint8[1] for S33 exponent + significand : %.3d or %2x\n",pt_uint8[1], pt_uint8[1]);
-                    printf("lfr_bp2[i*NB_BYTES_BP2+5] : %.3d or %x\n",lfr_bp2[i*NB_BYTES_BP2+5], lfr_bp2[i*NB_BYTES_BP2+5]);
+                    printf("pt_uint8[0] for S33 exponent + significand : %.3d or %2x\n",pt_uint8[0], pt_uint8[0]);
-                    printf("lfr_bp2[i*NB_BYTES_BP2+4] : %.3d or %x\n",lfr_bp2[i*NB_BYTES_BP2+4], lfr_bp2[i*NB_BYTES_BP2+4]);
+                    printf("lfr_bp2[i*NB_BYTES_BP2+5] : %3u or %2x\n",lfr_bp2[i*NB_BYTES_BP2+5], lfr_bp2[i*NB_BYTES_BP2+5]);
+                    printf("lfr_bp2[i*NB_BYTES_BP2+4] : %3u or %2x\n",lfr_bp2[i*NB_BYTES_BP2+4], lfr_bp2[i*NB_BYTES_BP2+4]);
             #endif
                     // S44
                     significand = frexpf(compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+21], &exponent);  // 0.5 <= significand < 1
-                                                                                              // S44 = significand * 2^exponent
+                                                                                                               // S44 = significand * 2^exponent
             #ifdef DEBUG_TCH
                     printf("S44         : %16.8e\n",compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+21]);
                     printf("significand : %16.8e\n",significand);
                       exponent = expmax;
                       significand = 1.0;     // max value that can be recorded
                     }
-                    if (significand == 0) {// in that case exponent == 0 too
+                    if (significand == 0) {  // in that case exponent == 0 too
                       exponent = expmin;
-                      significand = 0.5;   // min value that can be recorded
+                      significand = 0.5;     // min value that can be recorded
                     }
                     autocor = (uint16_t) ((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)
+                                                                             // where just the first nbitsig bits are used (0, ..., 2^nbitsig-1)
-                    tmp_uint16 = (uint16_t) (exponent-expmin); // Shift and cast into a 16-bit unsigned int
+                    exp = (uint16_t) (exponent-expmin);      // Shift and cast into a 16-bit unsigned int where just
-                                                                              // where just the first nbitexp bits are used (0, ..., 2^nbitexp-1)
+                                                             // the first nbitexp bits are used (0, ..., 2^nbitexp-1)
-                    pt_u_short_int = (uint16_t*) &lfr_bp2[i*NB_BYTES_BP2+6]; // Affect an uint16_t pointer with the
+                    tmp_uint16 = autocor | (exp << nbitsig); // Put the exponent bits (nbitexp) next to the
-                                                                                // adress where the 16-bit word result will be stored
+                                                             // left place of the significand bits (nbitsig),
-                    *pt_u_short_int = autocor | (tmp_uint16 << nbitsig); // Put the exponent bits (nbitexp) next to the
+                                                             // making the 16-bit word to be recorded
-                                                                      // left place of the significand bits (nbitsig), making
+                    pt_uint8 = (uint8_t*) &tmp_uint16;       // Affect an uint8_t pointer with the adress of tmp_uint16
-                                                                      // the 16-bit word to be recorded, and record it using the pointer
+            #ifdef LSB_FIRST_TCH
+                    lfr_bp2[i*NB_BYTES_BP2+6] = pt_uint8[0]; // Record LSB of tmp_uint16
+                    lfr_bp2[i*NB_BYTES_BP2+7] = pt_uint8[1]; // Record MSB of tmp_uint16
+            #endif
+            #ifdef MSB_FIRST_TCH
+                    lfr_bp2[i*NB_BYTES_BP2+6] = pt_uint8[1]; // Record LSB of tmp_uint16
+                    lfr_bp2[i*NB_BYTES_BP2+7] = pt_uint8[0]; // Record MSB of tmp_uint16
+            #endif
             #ifdef DEBUG_TCH
-                    printf("autocor for S44 significand : %d\n",autocor );
+                    printf("autocor for S44 significand : %u\n",autocor);
-                    printf("tmp_uint8 for S44 exponent : %d\n",tmp_uint16 );
+                    printf("exp for S44 exponent : %u\n",exp);
-                    printf("*pt_u_short_int for S44 exponent + significand : %.3d or %x\n",*pt_u_short_int, *pt_u_short_int);
+                    printf("pt_uint8[1] for S44 exponent + significand : %.3d or %2x\n",pt_uint8[1], pt_uint8[1]);
-                    printf("lfr_bp2[i*NB_BYTES_BP2+7] : %.3d or %x\n",lfr_bp2[i*NB_BYTES_BP2+7], lfr_bp2[i*NB_BYTES_BP2+7]);
+                    printf("pt_uint8[0] for S44 exponent + significand : %.3d or %2x\n",pt_uint8[0], pt_uint8[0]);
-                    printf("lfr_bp2[i*NB_BYTES_BP2+6] : %.3d or %x\n",lfr_bp2[i*NB_BYTES_BP2+6], lfr_bp2[i*NB_BYTES_BP2+6]);
+                    printf("lfr_bp2[i*NB_BYTES_BP2+7] : %3u or %2x\n",lfr_bp2[i*NB_BYTES_BP2+7], lfr_bp2[i*NB_BYTES_BP2+7]);
+                    printf("lfr_bp2[i*NB_BYTES_BP2+6] : %3u or %2x\n",lfr_bp2[i*NB_BYTES_BP2+6], lfr_bp2[i*NB_BYTES_BP2+6]);
             #endif
                     // S55
                     significand = frexpf(compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+24], &exponent);  // 0.5 <= significand < 1
-                                                                                              // S55 = significand * 2^exponent
+                                                                                                               // S55 = significand * 2^exponent
             #ifdef DEBUG_TCH
                     printf("S55         : %16.8e\n",compressed_spec_mat[i*NB_VALUES_PER_SPECTRAL_MATRIX+24]);
                     printf("significand : %16.8e\n",significand);
                       exponent = expmax;
                       significand = 1.0;     // max value that can be recorded
                     }
-                    if (significand == 0) {// in that case exponent == 0 too
+                    if (significand == 0) {  // in that case exponent == 0 too
                       exponent = expmin;
-                      significand = 0.5;   // min value that can be recorded
+                      significand = 0.5;     // min value that can be recorded
                     }
                     autocor = (uint16_t) ((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)
+                                                                             // where just the first nbitsig bits are used (0, ..., 2^nbitsig-1)
-                    tmp_uint16 = (uint16_t) (exponent-expmin); // Shift and cast into a 16-bit unsigned int
+                    exp = (uint16_t) (exponent-expmin);      // Shift and cast into a 16-bit unsigned int where just
-                                                                              // where just the first nbitexp bits are used (0, ..., 2^nbitexp-1)
+                                                             // the first nbitexp bits are used (0, ..., 2^nbitexp-1)
-                    pt_u_short_int = (uint16_t*) &lfr_bp2[i*NB_BYTES_BP2+8]; // Affect an uint16_t pointer with the
+                    tmp_uint16 = autocor | (exp << nbitsig); // Put the exponent bits (nbitexp) next to the
-                                                                                // adress where the 16-bit word result will be stored
+                                                             // left place of the significand bits (nbitsig),
-                    *pt_u_short_int = autocor | (tmp_uint16 << nbitsig); // Put the exponent bits (nbitexp) next to the
+                                                             // making the 16-bit word to be recorded
-                                                                      // left place of the significand bits (nbitsig), making
+                    pt_uint8 = (uint8_t*) &tmp_uint16;       // Affect an uint8_t pointer with the adress of tmp_uint16
-                                                                      // the 16-bit word to be recorded, and record it using the pointer
+            #ifdef LSB_FIRST_TCH
+                    lfr_bp2[i*NB_BYTES_BP2+8] = pt_uint8[0]; // Record LSB of tmp_uint16
+                    lfr_bp2[i*NB_BYTES_BP2+9] = pt_uint8[1]; // Record MSB of tmp_uint16
+            #endif
+            #ifdef MSB_FIRST_TCH
+                    lfr_bp2[i*NB_BYTES_BP2+8] = pt_uint8[1]; // Record LSB of tmp_uint16
+                    lfr_bp2[i*NB_BYTES_BP2+9] = pt_uint8[0]; // Record MSB of tmp_uint16
+            #endif
             #ifdef DEBUG_TCH
-                    printf("autocor for S55 significand : %d\n",autocor );
+                    printf("autocor for S55 significand : %u\n",autocor);
-                    printf("tmp_uint8 for S55 exponent : %d\n",tmp_uint16 );
+                    printf("exp for S55 exponent : %u\n",exp);
-                    printf("*pt_u_short_int for S55 exponent + significand : %.3d or %x\n",*pt_u_short_int, *pt_u_short_int);
+                    printf("pt_uint8[1] for S55 exponent + significand : %.3d or %2x\n",pt_uint8[1], pt_uint8[1]);
-                    printf("lfr_bp2[i*NB_BYTES_BP2+9] : %.3d or %x\n",lfr_bp2[i*NB_BYTES_BP2+9], lfr_bp2[i*NB_BYTES_BP2+9]);
+                    printf("pt_uint8[0] for S55 exponent + significand : %.3d or %2x\n",pt_uint8[0], pt_uint8[0]);
-                    printf("lfr_bp2[i*NB_BYTES_BP2+8] : %.3d or %x\n",lfr_bp2[i*NB_BYTES_BP2+8], lfr_bp2[i*NB_BYTES_BP2+8]);
+                    printf("lfr_bp2[i*NB_BYTES_BP2+9] : %3u or %2x\n",lfr_bp2[i*NB_BYTES_BP2+9], lfr_bp2[i*NB_BYTES_BP2+9]);
+                    printf("lfr_bp2[i*NB_BYTES_BP2+8] : %3u or %2x\n",lfr_bp2[i*NB_BYTES_BP2+8], lfr_bp2[i*NB_BYTES_BP2+8]);
             #endif
                 }
             }

basic_parameters.h +2 -1

             // version 1.0: 31/07/2013
             // version 1.1: 02/04/2014
             // version 1.2: 30/04/2014
+            // version 1.3: 02/05/2014
             #ifndef BASIC_PARAMETERS_H_INCLUDED
             #define BASIC_PARAMETERS_H_INCLUDED
             #define NB_VALUES_PER_SPECTRAL_MATRIX 25
-            #define NB_BINS_COMPRESSED_MATRIX_f0 1
+            #define NB_BINS_COMPRESSED_MATRIX_f0 11
             #define NB_BYTES_BP1 9
             #define NB_BYTES_BP2 30

file_utilities.c +5 -3

             // version 1.0: 31/07/2013
             // version 1.1: 02/04/2014
             // version 1.2: 30/04/2014
+            // version 1.3: 02/05/2014
             #include <file_utilities.h>
                 }
                 (void) fread(compressed_spectral_matrix_f0, sizeof(compressed_spectral_matrix_f0), 1, infile);
                 (void) fclose(infile);
-                printf("size of compressed_spectral_matrix_f0 : %lu\n", sizeof(compressed_spectral_matrix_f0));
-                printf("Number of bins: %d\n\n", NB_BINS_COMPRESSED_MATRIX_f0);
-                printf("compressed_spectral_matrix_f0 : \n");
+                printf("Compressed_spectral_matrix_f0 : \n");
+                printf("Number of bins: %d\n", NB_BINS_COMPRESSED_MATRIX_f0);
+                printf("Number of values per spectral matrix: %d\n", NB_VALUES_PER_SPECTRAL_MATRIX);
+                printf("Size of compressed_spectral_matrix_f0 : %lu\n", sizeof(compressed_spectral_matrix_f0));
                 for(i=0; i<NB_BINS_COMPRESSED_MATRIX_f0; i++){

file_utilities.h +1 0

             // version 1.0: 31/07/2013
             // version 1.1: 02/04/2014
             // version 1.2: 30/04/2014
+            // version 1.3: 02/05/2014
             #ifndef FILE_UTILITIES_H
             #define FILE_UTILITIES_H

main.c +1 0

             // version 1.O: 31/07/2013
             // version 1.1: 02/04/2014
             // version 1.2: 30/04/2014
+            // version 1.3: 02/05/2014
             #include <stdio.h>
             #include <basic_parameters.h>

Collapse all files

.hgignore +2 0

@@ -0,0 +1,2
	1	syntax: glob
	2	tab_test2_v1.3

Collapse all files

No files

General Comments 1

chust

v1 |

|

Auto status change to Under Review

Write
Preview

You need to be logged in to leave comments. Login now

Merge is not currently possible because of below failed checks.

- User `default` not allowed to perform merge.
- Pull request reviewer approval is pending.
- This pull request cannot be merged because the target `ancestor` is not a head.

No TODOs yet

Auto status change to Under Review

In pull request description:

No Ticket data found.

In commit messages:

No Ticket data found.

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages