# HG changeset patch
# User chust
# Date 2014-04-30 17:47:21
# Node ID be100cfb14bdf6e110059075a2e1194adfb6a4d4
# Parent  4f3902999c69e4dd12fe4cff29c1cb1f8a4a65e6

version 1.2 qui règle le problème d'alignement mémoire pour BP1 (pour BP2 plus tard ...)

diff --git a/basic_parameters.c b/basic_parameters.c
--- a/basic_parameters.c
+++ b/basic_parameters.c
@@ -1,10 +1,12 @@
 // In the frame of RPW LFR Sofware ICD Issue1 Rev8 (05/07/2013)
 // version 1.0: 31/07/2013
 // version 1.1: 02/04/2014
+// version 1.2: 30/04/2014
 
 #include "basic_parameters.h"
 #include <math.h>
 #include <stdio.h>
+#include <stdint.h>
 
 #define K44_PE    0
 #define K55_PE    1
@@ -46,7 +48,7 @@ float k_f0[NB_BINS_COMPRESSED_MATRIX_f0]
 
 void init_k_f0( void )
 {
-    unsigned char i;
+    uint16_t i;                        // 16 bits unsigned
 
     for(i=0; i<NB_BINS_COMPRESSED_MATRIX_f0; i++){
     k_f0[i][K44_PE]    = 1;
@@ -89,9 +91,9 @@ void init_k_f0( void )
 
 float alpha_M = 45 * (3.1415927/180);
 
-void BP1_set( float * compressed_spec_mat, unsigned char nb_bins_compressed_spec_mat, unsigned char * lfr_bp1 ){
-    int i, exponent;
-    float PSDB;
+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 bits floating point
     float PSDE;
     float tmp;
     float NVEC_V0;
@@ -108,16 +110,17 @@ void BP1_set( float * compressed_spec_ma
     float bx_bx_star;
     float vphi;
     float significand;
-    signed char nbitexp;
-    signed char nbitsig;
-    signed char expmin;
-    signed char expmax;                       //  8 bits
-    short int rangesig;                       // 16 bits
-    unsigned short int psd;
-    unsigned short int tmp_u_short_int;       // 16 bits
-    unsigned short int *pt_u_short_int;            // pointer on unsigned 16-bit words
-    unsigned char tmp_u_char;                      //  8 bits
-    unsigned char *pt_u_char;                      // pointer on unsigned 8-bit bytes
+    uint8_t nbitexp;                    // 8 bits unsigned
+    uint8_t nbitsig;
+    uint8_t tmp_uint8;
+    uint8_t *pt_uint8;                  // pointer on unsigned 8-bit bytes
+    int8_t expmin;                      // 8 bits signed
+    int8_t expmax;
+    int16_t rangesig;                   // 16 bits unsigned
+    uint16_t psd;
+    uint16_t exp;
+    uint16_t tmp_uint16;
+    uint16_t i;
 
     init_k_f0();
 
@@ -131,7 +134,7 @@ void BP1_set( float * compressed_spec_ma
     expmax = 30;                           // maximum value of the exponent
     expmin = expmax - (1 << nbitexp) + 1;  // accordingly the minimum exponent value
     // for floating point data to be recorded on 12-bit words:
-    nbitsig = 12 - nbitexp;  // number of bits for the significand
+    nbitsig = 12 - nbitexp;       // number of bits for the significand
     rangesig = (1 << nbitsig)-1;  // == 2^nbitsig - 1
 
 #ifdef DEBUG_TCH
@@ -163,23 +166,31 @@ void BP1_set( float * compressed_spec_ma
           significand = 0.5;   // min value that can be recorded
         }
 
-        psd = (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_bp1[i*NB_BYTES_BP1+2]; // Affect an unsigned short int pointer with the
-                                                                   // adress where the 16-bit word result will be stored
-        *pt_u_short_int = psd | (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
+        psd = (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)
+        exp = (uint16_t) (exponent-expmin);      // Shift and cast into a 16-bit unsigned int where just
+                                                 // the first nbitexp bits are used (0, ..., 2^nbitexp-1)
+        tmp_uint16 = psd | (exp << nbitsig);     // Put the exponent bits (nbitexp) next to the
+                                                 // left place of the significand bits (nbitsig),
+                                                 // making the 16-bit word to be recorded
+        pt_uint8 = (uint8_t*) &tmp_uint16;       // Affect an uint8_t pointer with the adress of tmp_uint16
+#ifdef LSB_FIRST_TCH
+        lfr_bp1[i*NB_BYTES_BP1+2] = pt_uint8[0]; // Record LSB of tmp_uint16
+        lfr_bp1[i*NB_BYTES_BP1+3] = pt_uint8[1]; // Record MSB of tmp_uint16
+#endif
+#ifdef MSB_FIRST_TCH
+        lfr_bp1[i*NB_BYTES_BP1+2] = pt_uint8[1]; // Record LSB of tmp_uint16
+        lfr_bp1[i*NB_BYTES_BP1+3] = pt_uint8[0]; // Record MSB of tmp_uint16
+#endif
 #ifdef DEBUG_TCH
         printf("\nBin number: %d\n", i);
         printf("PSDB / 3    : %16.8e\n",PSDB/3);
         printf("significand : %16.8e\n",significand);
         printf("exponent    : %d\n"    ,exponent);
         printf("psd for PSDB significand : %d\n",psd);
-        printf("tmp_u_short_int for PSDB exponent : %d\n",tmp_u_short_int);
-        printf("*pt_u_short_int for PSDB exponent + significand: %.3d or %.4x\n",*pt_u_short_int, *pt_u_short_int);
+        printf("exp for PSDB exponent : %d\n",exp);
+        printf("pt_uint8[1] for PSDB exponent + significand: %.3d or %.2x\n",pt_uint8[1], pt_uint8[1]);
+        printf("pt_uint8[0] for PSDB exponent + significand: %.3d or %.2x\n",pt_uint8[0], pt_uint8[0]);
         printf("lfr_bp1[i*NB_BYTES_BP1+3] : %.3d or %.2x\n",lfr_bp1[i*NB_BYTES_BP1+3], lfr_bp1[i*NB_BYTES_BP1+3]);
         printf("lfr_bp1[i*NB_BYTES_BP1+2] : %.3d or %.2x\n",lfr_bp1[i*NB_BYTES_BP1+2], lfr_bp1[i*NB_BYTES_BP1+2]);
 #endif
@@ -208,22 +219,31 @@ void BP1_set( float * compressed_spec_ma
           significand = 0.5;   // min value that can be recorded
         }
 
-        psd = (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_bp1[i*NB_BYTES_BP1+0]; // Affect an unsigned short int pointer with the
-                                                                    // adress where the 16-bit word result will be stored
-        *pt_u_short_int = psd | (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
+        psd = (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)
+        exp = (uint16_t) (exponent-expmin);      // Shift and cast into a 16-bit unsigned int where just
+                                                 // the first nbitexp bits are used (0, ..., 2^nbitexp-1)
+        tmp_uint16 = psd | (exp << nbitsig);     // Put the exponent bits (nbitexp) next to the
+                                                 // left place of the significand bits (nbitsig),
+                                                 // making the 16-bit word to be recorded
+        pt_uint8 = (uint8_t*) &tmp_uint16;       // Affect an uint8_t pointer with the adress of tmp_uint16
+#ifdef LSB_FIRST_TCH
+        lfr_bp1[i*NB_BYTES_BP1+0] = pt_uint8[0]; // Record LSB of tmp_uint16
+        lfr_bp1[i*NB_BYTES_BP1+1] = pt_uint8[1]; // Record MSB of tmp_uint16
+#endif
+#ifdef MSB_FIRST_TCH
+        lfr_bp1[i*NB_BYTES_BP1+0] = pt_uint8[1]; // Record LSB of tmp_uint16
+        lfr_bp1[i*NB_BYTES_BP1+1] = pt_uint8[0]; // Record MSB of tmp_uint16
+#endif
 #ifdef DEBUG_TCH
-        printf("PSDE / 2    : %16.8e\n",PSDE/2);
+        printf("Bin number: %d\n", i);
+        printf("PSDE/2      : %16.8e\n",PSDE/2);
         printf("significand : %16.8e\n",significand);
         printf("exponent    : %d\n"    ,exponent);
         printf("psd for PSDE significand : %d\n",psd);
-        printf("tmp_u_short_int for PSDE exponent : %d\n",tmp_u_short_int);
-        printf("*pt_u_short_int for PSDE exponent + significand: %.3d or %.4x\n",*pt_u_short_int, *pt_u_short_int);
+        printf("exp for PSDE exponent : %d\n",exp);
+        printf("pt_uint8[1] for PSDE exponent + significand: %.3d or %.2x\n",pt_uint8[1], pt_uint8[1]);
+        printf("pt_uint8[0] for PSDE exponent + significand: %.3d or %.2x\n",pt_uint8[0], pt_uint8[0]);
         printf("lfr_bp1[i*NB_BYTES_BP1+1] : %.3d or %.2x\n",lfr_bp1[i*NB_BYTES_BP1+1], lfr_bp1[i*NB_BYTES_BP1+1]);
         printf("lfr_bp1[i*NB_BYTES_BP1+0] : %.3d or %.2x\n",lfr_bp1[i*NB_BYTES_BP1+0], lfr_bp1[i*NB_BYTES_BP1+0]);
 #endif
@@ -239,15 +259,15 @@ void BP1_set( float * compressed_spec_ma
         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] = (unsigned char) (NVEC_V0*127.5 + 128); // shift and cast into a 8-bit unsigned char (0, ..., 255) with rounding
-        lfr_bp1[i*NB_BYTES_BP1+5] = (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[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
+        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_u_char[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]
 #endif
 #ifdef MSB_FIRST_TCH
-        lfr_bp1[i*NB_BYTES_BP1+6] = pt_u_char[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]
 #endif
 #ifdef DEBUG_TCH
@@ -262,14 +282,14 @@ void BP1_set( float * compressed_spec_ma
         // BP1 ellipticity == PA_LFR_SC_BP1_ELLIP_F0 == 4 bits
         aux = 2*tmp / PSDB;                        // compute the ellipticity
 
-        tmp_u_char = (unsigned char) (aux*15 + 0.5); // shift and cast into a 8-bit unsigned char 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)
-        lfr_bp1[i*NB_BYTES_BP1+6] = lfr_bp1[i*NB_BYTES_BP1+6] | (tmp_u_char << 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
                                                                    // previously in lfr_bp1[i*NB_BYTES_BP1+6])
 #ifdef DEBUG_TCH
         printf("ellipticity  : %16.8e\n",aux);
-        printf("tmp_u_char for ellipticity : %u\n",tmp_u_char);
+        printf("tmp_uint8 for ellipticity : %u\n",tmp_uint8);
         printf("lfr_bp1[i*NB_BYTES_BP1+6] for NVEC_V2 + ellipticity : %u\n",lfr_bp1[i*NB_BYTES_BP1+6]);
 #endif
         //==============================================================
@@ -286,13 +306,13 @@ void BP1_set( float * compressed_spec_ma
         aux = PSDB*PSDB;
         tmp = ( 3*tr_SB_SB - aux ) / ( 2 * aux );   // compute the degree of polarisation
 
-        tmp_u_char = (unsigned char) (tmp*7 + 0.5);// shift and cast into a 8-bit unsigned char 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_u_char; // 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]
 #ifdef DEBUG_TCH
         printf("DOP  : %16.8e\n",tmp);
-        printf("tmp_u_char for DOP : %u\n",tmp_u_char);
+        printf("tmp_uint8 for DOP : %u\n",tmp_uint8);
         printf("lfr_bp1[i*NB_BYTES_BP1+6] for NVEC_V2 + ellipticity + DOP : %u\n",lfr_bp1[i*NB_BYTES_BP1+6]);
 #endif
         //=======================================================================================
@@ -328,18 +348,18 @@ void BP1_set( float * compressed_spec_ma
 #ifdef DEBUG_TCH
         printf("ReaSX / 2   : %16.8e\n",e_cross_b_re/2);
 #endif
-        pt_u_char = (unsigned char*) &e_cross_b_re; // Affect an unsigned char 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_u_char[3] & 0x80);  // Extract its sign bit (32-bit float, sign bit in the 4th octet:PC convention)
+        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)
                                                                         // of lfr_bp1[i*NB_BYTES_BP1+1]
-        pt_u_char[3] = (pt_u_char[3] & 0x7f);       // Make e_cross_b_re be positive in any case: |ReaSX|
+        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_u_char[0] & 0x80);  // Extract its sign bit (32-bit float, sign bit in the 0th octet:SPARC convention)
+        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)
                                                                         // of lfr_bp1[i*NB_BYTES_BP1+1]
-        pt_u_char[0] = (pt_u_char[0] & 0x7f);       // Make e_cross_b_re be positive in any case: |ReaSX|
+        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
                                                         // ReaSX/2 = significand * 2^exponent
@@ -359,38 +379,38 @@ void BP1_set( float * compressed_spec_ma
           significand = 0.5;   // min value that can be recorded
         }
 
-        lfr_bp1[i*NB_BYTES_BP1+7] = (unsigned char) ((significand*2-1)*7 + 0.5); // Shift and cast into a 8-bit unsigned char with rounding
+        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)
-        tmp_u_char = (unsigned char) (exponent-expmin); // Shift and cast into a 8-bit unsigned char where
+        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)
 #ifdef DEBUG_TCH
         printf("|ReaSX| / 2 : %16.8e\n",e_cross_b_re/2);
         printf("significand : %16.8e\n",significand);
         printf("exponent    : %d\n"    ,exponent);
         printf("lfr_bp1[i*NB_BYTES_BP1+7] for ReaSX significand : %u\n",lfr_bp1[i*NB_BYTES_BP1+7]);
-        printf("tmp_u_char        for ReaSX exponent    : %d\n",tmp_u_char);
+        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_u_char << 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]
 #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]);
         printf("ImaSX / 2   : %16.8e\n",e_cross_b_im/2);
 #endif
-        pt_u_char = (unsigned char*) &e_cross_b_im; // Affect an unsigned char pointer with the adress of e_cross_b_im
+        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_u_char[3] = pt_u_char[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_u_char[0] = pt_u_char[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_u_char = (e_cross_b_im > e_cross_b_re) ? 0x40 : 0x00; // Determine the sector argument of SX. If |Im| > |Re| affect
+        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.
-        lfr_bp1[i*NB_BYTES_BP1+1] = lfr_bp1[i*NB_BYTES_BP1+1] |  tmp_u_char;      // 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.
 #ifdef DEBUG_TCH
         printf("|ImaSX| / 2 : %16.8e\n",e_cross_b_im/2);
-        printf("ArgSX sign  : %u\n",tmp_u_char);
+        printf("ArgSX sign  : %u\n",tmp_uint8);
         printf("lfr_bp1[i*NB_BYTES_BP1+1] for ReaSX & ArgSX signs + PSDE 'exponent'  : %u\n",lfr_bp1[i*NB_BYTES_BP1+1]);
 #endif
         //======================================================================
@@ -442,18 +462,18 @@ void BP1_set( float * compressed_spec_ma
         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_u_char = (unsigned char*) &n_cross_e_scal_b_re;     // Affect an unsigned char 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_u_char[3] & 0x80);  // Extract its sign bit (32-bit float, sign bit in the 4th octet:PC convention)
+        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)
                                                                         // of lfr_bp1[i*NB_BYTES_BP1+3]
-        pt_u_char[3] = (pt_u_char[3] & 0x7f);     // Make n_cross_e_scal_b_re be positive in any case: |n_cross_e_scal_b_re|
+        pt_uint8[3] = (pt_uint8[3] & 0x7f);     // Make n_cross_e_scal_b_re be positive in any case: |n_cross_e_scal_b_re|
 #endif
 #ifdef MSB_FIRST_TCH
-        lfr_bp1[i*NB_BYTES_BP1+3] = lfr_bp1[i*NB_BYTES_BP1+3] | (pt_u_char[0] & 0x80);  // Extract its sign bit (32-bit float, sign bit in the 0th octet:SPARC convention)
+        lfr_bp1[i*NB_BYTES_BP1+3] = lfr_bp1[i*NB_BYTES_BP1+3] | (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)
                                                                         // of lfr_bp1[i*NB_BYTES_BP1+3]
-        pt_u_char[0] = (pt_u_char[0] & 0x7f);     // Make n_cross_e_scal_b_re be positive in any case: |n_cross_e_scal_b_re|
+        pt_uint8[0] = (pt_uint8[0] & 0x7f);     // Make n_cross_e_scal_b_re be positive in any case: |n_cross_e_scal_b_re|
 #endif
         vphi = n_cross_e_scal_b_re / bx_bx_star;  // Compute |VPHI|
 
@@ -479,48 +499,48 @@ void BP1_set( float * compressed_spec_ma
         printf("significand : %16.8e\n",significand);
         printf("exponent    : %d\n"    ,exponent);
 #endif
-        lfr_bp1[i*NB_BYTES_BP1+8] = (unsigned char) ((significand*2-1)*7 + 0.5); // Shift and cast into a 8-bit unsigned char with rounding
+        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)
-        tmp_u_char = (unsigned char) (exponent-expmin); // Shift and cast into a 8-bit unsigned char where
+        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)
 #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_u_char        for VPHI exponent    : %d\n",tmp_u_char);
+        printf("tmp_uint8        for VPHI exponent    : %d\n",tmp_uint8);
 #endif
-        lfr_bp1[i*NB_BYTES_BP1+8] = lfr_bp1[i*NB_BYTES_BP1+8] | (tmp_u_char << 3); // shift these 5 bits to the left before logical addition
+        lfr_bp1[i*NB_BYTES_BP1+8] = lfr_bp1[i*NB_BYTES_BP1+8] | (tmp_uint8 << 3); // shift these 5 bits to the left before logical addition
                                                                    // with lfr_bp1[i*NB_BYTES_BP1+8]
 #ifdef DEBUG_TCH
         printf("lfr_bp1[i*NB_BYTES_BP1+8] for VPHI exponent + significand : %u\n",lfr_bp1[i*NB_BYTES_BP1+8]);
         printf("lfr_bp1[i*NB_BYTES_BP1+3] for VPHI sign + PSDB 'exponent' : %u\n",lfr_bp1[i*NB_BYTES_BP1+3]);
 #endif
-        pt_u_char = (unsigned char*) &n_cross_e_scal_b_im; // Affect an unsigned char pointer with the adress of n_cross_e_scal_b_im
+        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_u_char[3] = pt_u_char[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_u_char[0] = pt_u_char[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_u_char = (n_cross_e_scal_b_im > n_cross_e_scal_b_re) ? 0x40 : 0x00; // Determine the sector argument of SX. If |Im| > |Re| affect
+        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.
-        lfr_bp1[i*NB_BYTES_BP1+3] = lfr_bp1[i*NB_BYTES_BP1+3] |  tmp_u_char;      // 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.
 #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);
-        printf("ArgNEBX sign          : %u\n",tmp_u_char);
+        printf("ArgNEBX sign          : %u\n",tmp_uint8);
         printf("lfr_bp1[i*NB_BYTES_BP1+3] for VPHI & ArgNEBX signs + PSDB 'exponent'  : %u\n",lfr_bp1[i*NB_BYTES_BP1+3]);
 #endif
     }
 }
 
-void BP2_set( float * compressed_spec_mat, unsigned char nb_bins_compressed_spec_mat, unsigned char * lfr_bp2 )
+void BP2_set( float * compressed_spec_mat, uint8_t nb_bins_compressed_spec_mat, uint8_t * lfr_bp2 )
 {
     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
+    int8_t nbitexp, nbitsig, expmin, expmax;  //  8 bits
+    int16_t rangesig;                            // 16 bits
+    uint16_t autocor, tmp_uint16;   // 16 bits
+    uint16_t *pt_u_short_int;            // pointer on unsigned 16-bit words
 
 #ifdef DEBUG_TCH
     printf("BP2 : \n");
@@ -566,8 +586,8 @@ void BP2_set( float * compressed_spec_ma
         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] = (unsigned char) (cross_re*127.5 + 128); // shift and cast into a 8-bit unsigned char (0, ..., 255) with rounding
-        lfr_bp2[i*NB_BYTES_BP2+20] = (unsigned char) (cross_im*127.5 + 128); // shift and cast into a 8-bit unsigned char (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
 #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]);
@@ -577,8 +597,8 @@ void BP2_set( float * compressed_spec_ma
         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] = (unsigned char) (cross_re*127.5 + 128); // shift and cast into a 8-bit unsigned char (0, ..., 255) with rounding
-        lfr_bp2[i*NB_BYTES_BP2+21] = (unsigned char) (cross_im*127.5 + 128); // shift and cast into a 8-bit unsigned char (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
 #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]);
@@ -587,8 +607,8 @@ void BP2_set( float * compressed_spec_ma
         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] = (unsigned char) (cross_re*127.5 + 128); // shift and cast into a 8-bit unsigned char (0, ..., 255) with rounding
-        lfr_bp2[i*NB_BYTES_BP2+22] = (unsigned char) (cross_im*127.5 + 128); // shift and cast into a 8-bit unsigned char (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
 #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]);
@@ -597,8 +617,8 @@ void BP2_set( float * compressed_spec_ma
         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] = (unsigned char) (cross_re*127.5 + 128); // shift and cast into a 8-bit unsigned char (0, ..., 255) with rounding
-        lfr_bp2[i*NB_BYTES_BP2+23] = (unsigned char) (cross_im*127.5 + 128); // shift and cast into a 8-bit unsigned char (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
 #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]);
@@ -607,8 +627,8 @@ void BP2_set( float * compressed_spec_ma
         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] = (unsigned char) (cross_re*127.5 + 128); // shift and cast into a 8-bit unsigned char (0, ..., 255) with rounding
-        lfr_bp2[i*NB_BYTES_BP2+24] = (unsigned char) (cross_im*127.5 + 128); // shift and cast into a 8-bit unsigned char (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
 #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]);
@@ -617,8 +637,8 @@ void BP2_set( float * compressed_spec_ma
         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] = (unsigned char) (cross_re*127.5 + 128); // shift and cast into a 8-bit unsigned char (0, ..., 255) with rounding
-        lfr_bp2[i*NB_BYTES_BP2+25] = (unsigned char) (cross_im*127.5 + 128); // shift and cast into a 8-bit unsigned char (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
 #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]);
@@ -627,8 +647,8 @@ void BP2_set( float * compressed_spec_ma
         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] = (unsigned char) (cross_re*127.5 + 128); // shift and cast into a 8-bit unsigned char (0, ..., 255) with rounding
-        lfr_bp2[i*NB_BYTES_BP2+26] = (unsigned char) (cross_im*127.5 + 128); // shift and cast into a 8-bit unsigned char (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
 #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]);
@@ -637,8 +657,8 @@ void BP2_set( float * compressed_spec_ma
         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] = (unsigned char) (cross_re*127.5 + 128); // shift and cast into a 8-bit unsigned char (0, ..., 255) with rounding
-        lfr_bp2[i*NB_BYTES_BP2+27] = (unsigned char) (cross_im*127.5 + 128); // shift and cast into a 8-bit unsigned char (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
 #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]);
@@ -647,8 +667,8 @@ void BP2_set( float * compressed_spec_ma
         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] = (unsigned char) (cross_re*127.5 + 128); // shift and cast into a 8-bit unsigned char (0, ..., 255) with rounding
-        lfr_bp2[i*NB_BYTES_BP2+28] = (unsigned char) (cross_im*127.5 + 128); // shift and cast into a 8-bit unsigned char (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
 #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]);
@@ -657,8 +677,8 @@ void BP2_set( float * compressed_spec_ma
         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] = (unsigned char) (cross_re*127.5 + 128); // shift and cast into a 8-bit unsigned char (0, ..., 255) with rounding
-        lfr_bp2[i*NB_BYTES_BP2+29] = (unsigned char) (cross_im*127.5 + 128); // shift and cast into a 8-bit unsigned char (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
 #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]);
@@ -691,18 +711,18 @@ void BP2_set( float * compressed_spec_ma
           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
+        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)
-        tmp_u_short_int = (unsigned short int) (exponent-expmin); // Shift and cast into a 16-bit unsigned int
+        tmp_uint16 = (uint16_t) (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[i*NB_BYTES_BP2+0]; // Affect an unsigned short int pointer with the
+        pt_u_short_int = (uint16_t*) &lfr_bp2[i*NB_BYTES_BP2+0]; // Affect an uint16_t 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
+        *pt_u_short_int = autocor | (tmp_uint16 << 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
 #ifdef DEBUG_TCH
         printf("autocor for S11 significand : %u\n",autocor );
-        printf("tmp_u_char for S11 exponent : %u\n",tmp_u_short_int );
+        printf("tmp_uint8 for S11 exponent : %u\n",tmp_uint16 );
         printf("*pt_u_short_int for S11 exponent + significand : %.3d or %x\n",*pt_u_short_int, *pt_u_short_int);
         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("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]);
@@ -728,18 +748,18 @@ void BP2_set( float * compressed_spec_ma
           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
+        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)
-        tmp_u_short_int = (unsigned short int) (exponent-expmin); // Shift and cast into a 16-bit unsigned int
+        tmp_uint16 = (uint16_t) (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[i*NB_BYTES_BP2+2]; // Affect an unsigned short int pointer with the
+        pt_u_short_int = (uint16_t*) &lfr_bp2[i*NB_BYTES_BP2+2]; // Affect an uint16_t 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
+        *pt_u_short_int = autocor | (tmp_uint16 << 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
 #ifdef DEBUG_TCH
         printf("autocor for S22 significand : %d\n",autocor );
-        printf("tmp_u_char for S22 exponent : %d\n",tmp_u_short_int );
+        printf("tmp_uint8 for S22 exponent : %d\n",tmp_uint16 );
         printf("*pt_u_short_int for S22 exponent + significand : %.3d or %x\n",*pt_u_short_int, *pt_u_short_int);
         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("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]);
@@ -765,18 +785,18 @@ void BP2_set( float * compressed_spec_ma
           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
+        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)
-        tmp_u_short_int = (unsigned short int) (exponent-expmin); // Shift and cast into a 16-bit unsigned int
+        tmp_uint16 = (uint16_t) (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[i*NB_BYTES_BP2+4]; // Affect an unsigned short int pointer with the
+        pt_u_short_int = (uint16_t*) &lfr_bp2[i*NB_BYTES_BP2+4]; // Affect an uint16_t 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
+        *pt_u_short_int = autocor | (tmp_uint16 << 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
 #ifdef DEBUG_TCH
         printf("autocor for S33 significand : %d\n",autocor );
-        printf("tmp_u_char for S33 exponent : %d\n",tmp_u_short_int );
+        printf("tmp_uint8 for S33 exponent : %d\n",tmp_uint16 );
         printf("*pt_u_short_int for S33 exponent + significand : %.3d or %x\n",*pt_u_short_int, *pt_u_short_int);
         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("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]);
@@ -803,18 +823,18 @@ void BP2_set( float * compressed_spec_ma
           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
+        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)
-        tmp_u_short_int = (unsigned short int) (exponent-expmin); // Shift and cast into a 16-bit unsigned int
+        tmp_uint16 = (uint16_t) (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[i*NB_BYTES_BP2+6]; // Affect an unsigned short int pointer with the
+        pt_u_short_int = (uint16_t*) &lfr_bp2[i*NB_BYTES_BP2+6]; // Affect an uint16_t 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
+        *pt_u_short_int = autocor | (tmp_uint16 << 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
 #ifdef DEBUG_TCH
         printf("autocor for S44 significand : %d\n",autocor );
-        printf("tmp_u_char for S44 exponent : %d\n",tmp_u_short_int );
+        printf("tmp_uint8 for S44 exponent : %d\n",tmp_uint16 );
         printf("*pt_u_short_int for S44 exponent + significand : %.3d or %x\n",*pt_u_short_int, *pt_u_short_int);
         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("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]);
@@ -840,18 +860,18 @@ void BP2_set( float * compressed_spec_ma
           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
+        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)
-        tmp_u_short_int = (unsigned short int) (exponent-expmin); // Shift and cast into a 16-bit unsigned int
+        tmp_uint16 = (uint16_t) (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[i*NB_BYTES_BP2+8]; // Affect an unsigned short int pointer with the
+        pt_u_short_int = (uint16_t*) &lfr_bp2[i*NB_BYTES_BP2+8]; // Affect an uint16_t 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
+        *pt_u_short_int = autocor | (tmp_uint16 << 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
 #ifdef DEBUG_TCH
         printf("autocor for S55 significand : %d\n",autocor );
-        printf("tmp_u_char for S55 exponent : %d\n",tmp_u_short_int );
+        printf("tmp_uint8 for S55 exponent : %d\n",tmp_uint16 );
         printf("*pt_u_short_int for S55 exponent + significand : %.3d or %x\n",*pt_u_short_int, *pt_u_short_int);
         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("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]);
diff --git a/basic_parameters.h b/basic_parameters.h
--- a/basic_parameters.h
+++ b/basic_parameters.h
@@ -1,6 +1,7 @@
 // In the frame of RPW LFR Sofware ICD Issue1 Rev8 (05/07/2013)
 // version 1.0: 31/07/2013
 // version 1.1: 02/04/2014
+// version 1.2: 30/04/2014
 
 #ifndef BASIC_PARAMETERS_H_INCLUDED
 #define BASIC_PARAMETERS_H_INCLUDED
diff --git a/file_utilities.c b/file_utilities.c
--- a/file_utilities.c
+++ b/file_utilities.c
@@ -1,6 +1,7 @@
 // In the frame of RPW LFR Sofware ICD Issue1 Rev8 (05/07/2013)
 // version 1.0: 31/07/2013
-// version 1.1: 01/04/2014
+// version 1.1: 02/04/2014
+// version 1.2: 30/04/2014
 
 #include <file_utilities.h>
 
diff --git a/file_utilities.h b/file_utilities.h
--- a/file_utilities.h
+++ b/file_utilities.h
@@ -1,6 +1,7 @@
 // In the frame of RPW LFR Sofware ICD Issue1 Rev8 (05/07/2013)
 // version 1.0: 31/07/2013
-// version 1.1: 01/04/2014
+// version 1.1: 02/04/2014
+// version 1.2: 30/04/2014
 
 #ifndef FILE_UTILITIES_H
 #define FILE_UTILITIES_H
diff --git a/main.c b/main.c
--- a/main.c
+++ b/main.c
@@ -1,5 +1,7 @@
 // In the frame of RPW LFR Sofware ICD Issue1 Rev8 (05/07/2013)
-// version 1: 31/07/2013
+// version 1.O: 31/07/2013
+// version 1.1: 02/04/2014
+// version 1.2: 30/04/2014
 
 #include <stdio.h>
 #include <basic_parameters.h>
@@ -15,8 +17,17 @@ int main(void)
     const char *filename;
     printf("Hello World!\n\n");
 
+#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
+    //LSB FIRST
+    printf("The multi-byte quantities are laid out in a LSB FIRST (little endian) fashion \n\n");
+#endif
+
+#if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
+    //MSB FIRST
+    printf("The multi-byte quantities are laid out in a MSB FIRST (big endian) fashion\n\n");
+#endif
+
     //filename="/WIN/Users/chust/DD CHUST/Missions/Solar Orbiter/LFR/Prog C/tests bp Paul/tests2/sm_test2.dat";
-    //filename="/WIN/Users/chust/DD CHUST/Missions/Solar Orbiter/LFR/Prog C/tests bp Paul/tests2/asm_f0_test_paul_1.dat";
     filename="sm_test2.dat";
 
     lecture_file_sm(filename);
diff --git a/tests3.pro b/tests3.pro
new file mode 100755
--- /dev/null
+++ b/tests3.pro
@@ -0,0 +1,18 @@
+TEMPLATE = app
+CONFIG += console
+CONFIG -= app_bundle
+CONFIG -= qt
+
+DEFINES += DEBUG_TCH
+#DEFINES += MSB_FIRST_TCH    # SPARC convention
+DEFINES += LSB_FIRST_TCH    # PC convention
+
+SOURCES += main.c \
+    basic_parameters.c \
+    file_utilities.c
+
+HEADERS += \
+    basic_parameters.h \
+    file_utilities.h
+
+